diff --git a/plugins/org.eclipse.qvtd.codegen/src/org/eclipse/qvtd/codegen/qvti/analyzer/QVTiAS2CGVisitor.java b/plugins/org.eclipse.qvtd.codegen/src/org/eclipse/qvtd/codegen/qvti/analyzer/QVTiAS2CGVisitor.java
index 21b8066..5f9c4bc 100644
--- a/plugins/org.eclipse.qvtd.codegen/src/org/eclipse/qvtd/codegen/qvti/analyzer/QVTiAS2CGVisitor.java
+++ b/plugins/org.eclipse.qvtd.codegen/src/org/eclipse/qvtd/codegen/qvti/analyzer/QVTiAS2CGVisitor.java
@@ -138,7 +138,7 @@
 import org.eclipse.qvtd.pivot.qvtimperative.SimpleParameterBinding;
 import org.eclipse.qvtd.pivot.qvtimperative.Statement;
 import org.eclipse.qvtd.pivot.qvtimperative.VariableStatement;
-import org.eclipse.qvtd.pivot.qvtimperative.evaluation.QVTiTransformationAnalysis;
+import org.eclipse.qvtd.pivot.qvtimperative.evaluation.EntryPointsAnalysis;
 import org.eclipse.qvtd.pivot.qvtimperative.util.QVTimperativeVisitor;
 import org.eclipse.qvtd.pivot.qvtimperative.utilities.QVTimperativeUtil;
 
@@ -1029,7 +1029,7 @@
 
 	@Override
 	public @Nullable CGNamedElement visitImperativeTransformation(@NonNull ImperativeTransformation asTransformation) {
-		/*QVTiTransformationAnalysis transformationAnalysis =*/ analyzer.getCodeGenerator().getTransformationAnalysis(asTransformation);
+		/*QVTiTransformationAnalysis entryPointsAnalysis =*/ analyzer.getCodeGenerator().getEntryPointsAnalysis(asTransformation);
 		CGTransformation cgTransformation = QVTiCGModelFactory.eINSTANCE.createCGTransformation();
 		setAst(cgTransformation, asTransformation);
 		pushCurrentClass(cgTransformation);
@@ -1203,8 +1203,8 @@
 	@Override
 	public @Nullable CGNamedElement visitSetStatement(@NonNull SetStatement asSetStatement) {
 		ImperativeTransformation asTransformation = QVTimperativeUtil.getContainingTransformation(asSetStatement);
-		QVTiTransformationAnalysis transformationAnalysis = analyzer.getCodeGenerator().getTransformationAnalysis(asTransformation);
-		Integer cacheIndex = transformationAnalysis.getCacheIndex(asSetStatement);
+		EntryPointsAnalysis entryPointsAnalysis = analyzer.getCodeGenerator().getEntryPointsAnalysis(asTransformation);
+		Integer cacheIndex = entryPointsAnalysis.getCacheIndex(asSetStatement);
 		if (cacheIndex != null) {
 			//			Property asProperty = ClassUtil.nonNullModel(asPropertyAssignment.getTargetProperty());
 			CGMiddlePropertyAssignment cgPropertyAssignment = QVTiCGModelFactory.eINSTANCE.createCGMiddlePropertyAssignment();
diff --git a/plugins/org.eclipse.qvtd.codegen/src/org/eclipse/qvtd/codegen/qvti/java/QVTiCG2JavaPreVisitor.java b/plugins/org.eclipse.qvtd.codegen/src/org/eclipse/qvtd/codegen/qvti/java/QVTiCG2JavaPreVisitor.java
index f0421a3..4929a8b 100644
--- a/plugins/org.eclipse.qvtd.codegen/src/org/eclipse/qvtd/codegen/qvti/java/QVTiCG2JavaPreVisitor.java
+++ b/plugins/org.eclipse.qvtd.codegen/src/org/eclipse/qvtd/codegen/qvti/java/QVTiCG2JavaPreVisitor.java
@@ -41,7 +41,7 @@
 import org.eclipse.qvtd.codegen.qvticgmodel.util.QVTiCGModelVisitor;
 import org.eclipse.qvtd.codegen.utilities.QVTiCGUtil;
 import org.eclipse.qvtd.pivot.qvtimperative.ImperativeTransformation;
-import org.eclipse.qvtd.pivot.qvtimperative.evaluation.QVTiTransformationAnalysis;
+import org.eclipse.qvtd.pivot.qvtimperative.evaluation.EntryPointsAnalysis;
 
 public class QVTiCG2JavaPreVisitor extends CG2JavaPreVisitor implements QVTiCGModelVisitor<@Nullable Object>
 {
@@ -165,8 +165,8 @@
 	@Override
 	public Object visitCGTransformation(@NonNull CGTransformation cgTransformation) {
 		ImperativeTransformation transformation = QVTiCGUtil.getAST(cgTransformation);
-		QVTiTransformationAnalysis transformationAnalysis = getCodeGenerator().getTransformationAnalysis(transformation);
-		Map<@NonNull Property, @NonNull Integer> opposites = transformationAnalysis.getCaches();
+		EntryPointsAnalysis entryPointsAnalysis = getCodeGenerator().getEntryPointsAnalysis(transformation);
+		Map<@NonNull Property, @NonNull Integer> opposites = entryPointsAnalysis.getCaches();
 		for (@NonNull Property property : opposites.keySet()) {
 			CGElementId cgPropertyId = analyzer.getElementId(property.getPropertyId());
 			cgPropertyId.accept(this);
diff --git a/plugins/org.eclipse.qvtd.codegen/src/org/eclipse/qvtd/codegen/qvti/java/QVTiCG2JavaVisitor.java b/plugins/org.eclipse.qvtd.codegen/src/org/eclipse/qvtd/codegen/qvti/java/QVTiCG2JavaVisitor.java
index de691c2..c6ace48 100644
--- a/plugins/org.eclipse.qvtd.codegen/src/org/eclipse/qvtd/codegen/qvti/java/QVTiCG2JavaVisitor.java
+++ b/plugins/org.eclipse.qvtd.codegen/src/org/eclipse/qvtd/codegen/qvti/java/QVTiCG2JavaVisitor.java
@@ -13,6 +13,7 @@
 import java.lang.reflect.Method;
 import java.util.ArrayList;
 import java.util.Collections;
+import java.util.Comparator;
 import java.util.HashMap;
 import java.util.HashSet;
 import java.util.List;
@@ -114,6 +115,7 @@
 import org.eclipse.qvtd.codegen.qvticgmodel.CGTypedModel;
 import org.eclipse.qvtd.codegen.qvticgmodel.util.QVTiCGModelVisitor;
 import org.eclipse.qvtd.codegen.utilities.QVTiCGUtil;
+import org.eclipse.qvtd.pivot.qvtbase.Function;
 import org.eclipse.qvtd.pivot.qvtbase.TypedModel;
 import org.eclipse.qvtd.pivot.qvtimperative.AppendParameterBinding;
 import org.eclipse.qvtd.pivot.qvtimperative.BufferStatement;
@@ -130,8 +132,9 @@
 import org.eclipse.qvtd.pivot.qvtimperative.NewStatement;
 import org.eclipse.qvtd.pivot.qvtimperative.ObservableStatement;
 import org.eclipse.qvtd.pivot.qvtimperative.SetStatement;
+import org.eclipse.qvtd.pivot.qvtimperative.evaluation.EntryPointAnalysis;
 import org.eclipse.qvtd.pivot.qvtimperative.evaluation.QVTiModelsManager;
-import org.eclipse.qvtd.pivot.qvtimperative.evaluation.QVTiTransformationAnalysis;
+import org.eclipse.qvtd.pivot.qvtimperative.evaluation.EntryPointsAnalysis;
 import org.eclipse.qvtd.pivot.qvtimperative.evaluation.TypedModelAnalysis;
 import org.eclipse.qvtd.pivot.qvtimperative.utilities.QVTimperativeUtil;
 import org.eclipse.qvtd.runtime.evaluation.AbstractComputation;
@@ -160,10 +163,10 @@
 		private @NonNull String @Nullable [] names = null;
 		private @Nullable String extentOppositesName = null;
 
-		public AllInstancesAnalysis(@NonNull QVTiTransformationAnalysis transformationAnalysis, @NonNull TypedModel typedModel, @NonNull Set<@NonNull CompleteClass> allInstancesCompleteClasses) {
-			super(transformationAnalysis, typedModel, allInstancesCompleteClasses);
+		public AllInstancesAnalysis(@NonNull EntryPointsAnalysis entryPointsAnalysis, @NonNull TypedModel typedModel, @NonNull Set<@NonNull CompleteClass> allInstancesCompleteClasses) {
+			super(entryPointsAnalysis, typedModel, allInstancesCompleteClasses);
 			ClassId extentClassId = QVTiModelsManager.EXTENT_CLASSID;
-			Map<@NonNull Property, @NonNull Integer> opposites = transformationAnalysis.getCaches();
+			Map<@NonNull Property, @NonNull Integer> opposites = entryPointsAnalysis.getCaches();
 			for (@NonNull Property property : opposites.keySet()) {
 				org.eclipse.ocl.pivot.Class owningClass = PivotUtil.getOwningClass(property);
 				TypeId typeId = owningClass.getTypeId();
@@ -217,7 +220,6 @@
 	protected boolean isIncremental = false;
 	protected boolean alwaysUseClasses = false;
 	protected boolean useGot = true;
-	protected QVTiTransformationAnalysis transformationAnalysis;
 
 	/* Non-null while wrapping a function-implemented mapping in a SimpleInvocation */
 	private @Nullable Mapping invocationWrapper = null;
@@ -336,10 +338,11 @@
 		}
 	}
 
-	protected @Nullable List<@Nullable AllInstancesAnalysis> doAllInstances(@NonNull QVTiTransformationAnalysis transformationAnalysis) {
+	protected @Nullable List<@Nullable AllInstancesAnalysis> doAllInstances(@NonNull EntryPointAnalysis entryPointAnalysis) {
+		EntryPointsAnalysis entryPointsAnalysis = entryPointAnalysis.getEntryPointsAnalysis();
 		CompleteModelInternal completeModel = environmentFactory.getCompleteModel();
 		Set<@NonNull CompleteClass> allInstancesCompleteClasses = new HashSet<>();
-		for (@NonNull CompleteClass allInstancesCompleteClass : transformationAnalysis.getAllInstancesCompleteClasses()) {
+		for (@NonNull CompleteClass allInstancesCompleteClass : entryPointAnalysis.getAllInstancesCompleteClasses()) {
 			allInstancesCompleteClasses.add(allInstancesCompleteClass);
 		}
 		if (allInstancesCompleteClasses.size() <= 0) {
@@ -347,14 +350,14 @@
 		}
 		List<@Nullable AllInstancesAnalysis> allInstancesAnalyses = new ArrayList<>();
 		int typedModelNumber = 0;
-		for (@NonNull TypedModel typedModel : QVTimperativeUtil.getModelParameters(transformationAnalysis.getTransformation())) {
+		for (@NonNull TypedModel typedModel : QVTimperativeUtil.getModelParameters(entryPointsAnalysis.getTransformation())) {
 			Set<@NonNull CompleteClass> allInstancesCompleteClasses2 = new HashSet<>();
 			for (org.eclipse.ocl.pivot.@NonNull Class usedClass : QVTimperativeUtil.getUsedClasses(typedModel)) {
 				allInstancesCompleteClasses2.add(completeModel.getCompleteClass(usedClass));
 			}
 			allInstancesCompleteClasses2.retainAll(allInstancesCompleteClasses);
 			if (!allInstancesCompleteClasses2.isEmpty()) {
-				AllInstancesAnalysis allInstancesAnalysis = new AllInstancesAnalysis(transformationAnalysis, typedModel, allInstancesCompleteClasses2);
+				AllInstancesAnalysis allInstancesAnalysis = new AllInstancesAnalysis(entryPointsAnalysis, typedModel, allInstancesCompleteClasses2);
 				Map<@NonNull CompleteClass, @NonNull Integer> instancesClass2index = allInstancesAnalysis.getInstancesCompleteClass2index();
 				List<@NonNull CompleteClass> sortedCompleteClasses = allInstancesAnalysis.getSortedCompleteClasses();
 				Map<@NonNull CompleteClass, @Nullable List<@NonNull CompleteClass>> instancesClassAnalysis = allInstancesAnalysis.getInstancesCompleteClassAnalysis();
@@ -945,6 +948,9 @@
 	}
 
 	protected boolean doFunctionBody2(@NonNull CGFunction cgFunction, @NonNull CGShadowExp cgShadowExp, @NonNull String instanceName) {
+		Function function = QVTiCGUtil.getAST(cgFunction);
+		ImperativeTransformation transformation = QVTimperativeUtil.getContainingTransformation(function);
+		EntryPointsAnalysis entryPointsAnalysis = context.getEntryPointsAnalysis(transformation);
 		String functionName = getFunctionName(cgFunction);
 		js.append(" {\n");
 		js.pushIndentation(null);
@@ -1007,7 +1013,7 @@
 		ImperativeTypedModel bestOutputTypedModel = null;
 		ImperativeTypedModel bestMiddleTypedModel = null;
 		ImperativeTypedModel bestInputTypedModel = null;
-		for (@NonNull ImperativeTypedModel typedModel : QVTimperativeUtil.getOwnedTypedModels(transformationAnalysis.getTransformation())) {
+		for (@NonNull ImperativeTypedModel typedModel : QVTimperativeUtil.getOwnedTypedModels(entryPointsAnalysis.getTransformation())) {
 			ImperativeTypedModel imperativeTypedModel = null;
 			for (org.eclipse.ocl.pivot.Package usedPackage : typedModel.getUsedPackage()) {
 				if (usedPackage.getESObject() == ePackage) {
@@ -2024,8 +2030,8 @@
 		//		}
 	}
 
-	protected void doOppositeCaches(@NonNull QVTiTransformationAnalysis transformationAnalysis) {
-		Map<@NonNull Property, @NonNull Integer> opposites = transformationAnalysis.getCaches();
+	protected void doOppositeCaches(@NonNull EntryPointsAnalysis entryPointsAnalysis) {
+		Map<@NonNull Property, @NonNull Integer> opposites = entryPointsAnalysis.getCaches();
 		if (opposites.size() <= 0) {
 			return;
 		}
@@ -2056,10 +2062,10 @@
 		}
 	}
 
-	protected @Nullable String doOppositePropertyIds(@NonNull QVTiTransformationAnalysis transformationAnalysis) {
+	protected @Nullable String doOppositePropertyIds(@NonNull EntryPointsAnalysis entryPointsAnalysis) {
 		// This code is no longer used, and since it is not used it generates undefined references
 		// It appears to have 'worked' only because a duplicate incomplete TransformationAnalysis was in use.
-		Map<@NonNull Property, @NonNull Integer> opposites = transformationAnalysis.getCaches();
+		Map<@NonNull Property, @NonNull Integer> opposites = entryPointsAnalysis.getCaches();
 		if (opposites.size() <= 0) {
 			return null;
 		}
@@ -2107,38 +2113,67 @@
 		CompleteModelInternal completeModel = environmentFactory.getCompleteModel();
 		Map<@NonNull TypedModel, @NonNull CGTypedModel> asTypedModel2cgTypedModel = new HashMap<>();
 		ImperativeTransformation asTransformation = QVTiCGUtil.getAST(cgTransformation);
+		List<@NonNull TypedModel> asTypedModels = QVTimperativeUtil.Internal.getModelParameterList(asTransformation);
 		for (@NonNull CGTypedModel cgTypedModel : QVTiCGUtil.getOwnedTypedModels(cgTransformation)) {
 			TypedModel asTypedModel = QVTiCGUtil.getAST(cgTypedModel);
 			asTypedModel2cgTypedModel.put(asTypedModel, cgTypedModel);
 		}
-		List<@NonNull EntryPoint> asEntryPoints = new ArrayList<>();
-		for (@NonNull Mapping asMapping : QVTimperativeUtil.getOwnedMappings(asTransformation)) {
+		List<@NonNull CGMapping> cgRootMappings = new ArrayList<>();
+		//		CGMapping cgRootMapping = NameUtil.getNameable(cgTransformation.getOwnedMappings(), QVTscheduleConstants.ROOT_MAPPING_NAME);	// Obsolete relic
+		for (@NonNull CGMapping cgMapping : QVTiCGUtil.getOwnedMappings(cgTransformation)) {
+			Mapping asMapping = QVTiCGUtil.getAST(cgMapping);
 			if (asMapping instanceof EntryPoint) {
-				asEntryPoints.add((EntryPoint) asMapping);
+				cgRootMappings.add(cgMapping);
 			}
-
 		}
-		EntryPoint asEntryPoint = (asEntryPoints.size() > 0) ? asEntryPoints.get(0) : null;
-		CGMapping cgRootMapping = QVTiCGUtil.getRootMapping(cgTransformation);
+		Collections.sort(cgRootMappings, new Comparator<@NonNull CGMapping>() {
+
+			@Override
+			public int compare(@NonNull CGMapping o1, @NonNull CGMapping o2) {
+				EntryPoint asEntryPoint1 = (EntryPoint) QVTiCGUtil.getAST(o1);
+				EntryPoint asEntryPoint2 = (EntryPoint) QVTiCGUtil.getAST(o2);
+				TypedModel asTypedModel1 = asEntryPoint1.getEnforcedTypedModels().get(0);
+				TypedModel asTypedModel2 = asEntryPoint2.getEnforcedTypedModels().get(0);
+				int index1 = asTypedModels.indexOf(asTypedModel1);
+				int index2 = asTypedModels.indexOf(asTypedModel2);
+				return index1 - index2;
+			}});
+		boolean isMultiDirectional = cgRootMappings.size() > 1;
 		js.append("@Override\n");
-		js.append("public boolean run() {\n");
+		js.append("public boolean run(");
+		if (isMultiDirectional) {
+			js.append("int targetTypedModelIndex");
+		}
+		js.append(") {\n");
 		js.pushIndentation(null);
-		for (@NonNull CGGuardVariable cgGuardVariable : QVTiCGUtil.getOwnedGuardVariables(cgRootMapping)) {
-			//			js.appendDeclaration(cgGuardVariable);
-			js.append("final ");
-			js.appendClassReference(true, Connection.class);
-			js.append(" ");
-			js.appendValueName(cgGuardVariable);
-			js.append(" = ");
-			js.append(QVTiGlobalContext.MODELS_NAME);
-			js.append("[");
-			VariableDeclaration asGuardVariable = QVTiCGUtil.getAST(cgGuardVariable);
-			Type type = QVTimperativeUtil.getType(asGuardVariable);
-			org.eclipse.ocl.pivot.Package asPackage = PivotUtil.getContainingPackage(type);
-			assert asPackage != null;
-			AllInstancesAnalysis allInstancesAnalysis = null;
-			CGTypedModel cgTypedModel = null;
-			if (asEntryPoint != null) {
+		if (isMultiDirectional) {
+			js.append("switch (targetTypedModelIndex) {\n");
+			js.pushIndentation(null);
+		}
+		for (@NonNull CGMapping cgRootMapping : cgRootMappings) {
+			EntryPoint asEntryPoint = (EntryPoint) QVTiCGUtil.getAST(cgRootMapping);
+			if (isMultiDirectional) {
+				js.append("case ");
+				TypedModel asTargetTypedModel = asEntryPoint.getEnforcedTypedModels().get(0);
+				js.appendIntegerString(asTypedModels.indexOf(asTargetTypedModel));
+				js.append(": { /* " + asTargetTypedModel.getName() + " */\n");
+				js.pushIndentation(null);
+			}
+			for (@NonNull CGGuardVariable cgGuardVariable : QVTiCGUtil.getOwnedGuardVariables(cgRootMapping)) {
+				//			js.appendDeclaration(cgGuardVariable);
+				js.append("final ");
+				js.appendClassReference(true, Connection.class);
+				js.append(" ");
+				js.appendValueName(cgGuardVariable);
+				js.append(" = ");
+				js.append(QVTiGlobalContext.MODELS_NAME);
+				js.append("[");
+				VariableDeclaration asGuardVariable = QVTiCGUtil.getAST(cgGuardVariable);
+				Type type = QVTimperativeUtil.getType(asGuardVariable);
+				org.eclipse.ocl.pivot.Package asPackage = PivotUtil.getContainingPackage(type);
+				assert asPackage != null;
+				AllInstancesAnalysis allInstancesAnalysis = null;
+				CGTypedModel cgTypedModel = null;
 				for (@NonNull TypedModel asTypedModel : QVTimperativeUtil.getCheckedTypedModels(asEntryPoint)) {
 					if (asTypedModel.getUsedPackage().contains(asPackage)) {
 						cgTypedModel = asTypedModel2cgTypedModel.get(asTypedModel);
@@ -2147,51 +2182,51 @@
 						}
 					}
 				}
-			}
-			else {			// FIXME Obsolete non-EntryPoint support
-				for (@NonNull CGTypedModel cgTypedModel2 : QVTiCGUtil.getOwnedTypedModels(cgTransformation)) {
-					ImperativeTypedModel asTypedModel = QVTiCGUtil.getAST(cgTypedModel2);
-					if (asTypedModel.isIsChecked() && asTypedModel.getUsedPackage().contains(asPackage)) {
-						cgTypedModel = cgTypedModel2;
-						break;
-					}
+				if (cgTypedModel != null) {
+					appendModelIndex(cgTypedModel);
+					assert allInstancesAnalyses != null;
+					allInstancesAnalysis = allInstancesAnalyses.get(cgTypedModel.getModelIndex());
 				}
+				js.append("].getConnection(");
+				assert allInstancesAnalysis != null;
+				CompleteClass completeType = completeModel.getCompleteClass(type);
+				Integer classIndex = allInstancesAnalysis.getInstancesCompleteClass2index().get(completeType);
+				js.append(classIndex + "/*" + type + "*/");
+				js.append(");\n");
 			}
-			if (cgTypedModel != null) {
-				appendModelIndex(cgTypedModel);
-				assert allInstancesAnalyses != null;
-				allInstancesAnalysis = allInstancesAnalyses.get(cgTypedModel.getModelIndex());
+			if (isIncremental || useClass(cgRootMapping)) {
+				js.append(getMappingCtorName(cgRootMapping) + ".invoke(");
 			}
-			js.append("].getConnection(");
-			assert allInstancesAnalysis != null;
-			CompleteClass completeType = completeModel.getCompleteClass(type);
-			Integer classIndex = allInstancesAnalysis.getInstancesCompleteClass2index().get(completeType);
-			js.append(classIndex + "/*" + type + "*/");
-			js.append(");\n");
-		}
-		if (isIncremental || useClass(cgRootMapping)) {
-			js.append(getMappingCtorName(cgRootMapping) + ".invoke(");
-		}
-		else {
-			js.append("return ");
-			js.append(getMappingName(cgRootMapping));
-			js.append("(");
-		}
-		boolean isFirst = true;
-		for (@NonNull CGGuardVariable cgGuardVariable : QVTiCGUtil.getOwnedGuardVariables(cgRootMapping)) {
-			if (!isFirst) {
-				js.append(", ");
+			else {
+				js.append("return ");
+				js.append(getMappingName(cgRootMapping));
+				js.append("(");
 			}
-			js.appendValueName(cgGuardVariable);
-			isFirst = false;
+			boolean isFirst = true;
+			for (@NonNull CGGuardVariable cgGuardVariable : QVTiCGUtil.getOwnedGuardVariables(cgRootMapping)) {
+				if (!isFirst) {
+					js.append(", ");
+				}
+				js.appendValueName(cgGuardVariable);
+				isFirst = false;
+			}
+			js.append(")");
+			if (isIncremental || useClass(cgRootMapping)) {
+				js.append(";\n");
+				js.append("return invocationManager.flush();\n");
+			}
+			else {
+				js.append(" && invocationManager.flush();\n");
+			}
+			if (isMultiDirectional) {
+				js.popIndentation();
+				js.append("}\n");
+			}
 		}
-		js.append(")");
-		if (isIncremental || useClass(cgRootMapping)) {
-			js.append(";\n");
-			js.append("return invocationManager.flush();\n");
-		}
-		else {
-			js.append(" && invocationManager.flush();\n");
+		if (isMultiDirectional) {
+			js.append("default: return false;\n");
+			js.popIndentation();
+			js.append("}\n");
 		}
 		js.popIndentation();
 		js.append("}\n");
@@ -3146,7 +3181,7 @@
 	public @NonNull Boolean visitCGShadowExp(@NonNull CGShadowExp cgShadowExp) {
 		super.visitCGShadowExp(cgShadowExp);
 		ShadowExp asShadowExp = (ShadowExp)ClassUtil.nonNullState(cgShadowExp.getAst());
-		DomainUsage usage = transformationAnalysis.getDomainUsageAnalysis().getUsage(asShadowExp);
+		DomainUsage usage = entryPointsAnalysis.getDomainUsageAnalysis().getUsage(asShadowExp);
 		TypedModel asTypedModel = ClassUtil.nonNullState(usage.getTypedModel(asShadowExp));
 		CGTypedModel cgTypedModel = context.getAnalyzer().getTypedModel(asTypedModel);
 		js.append(QVTiGlobalContext.MODELS_NAME);
@@ -3162,8 +3197,8 @@
 	public @NonNull Boolean visitCGTransformation(@NonNull CGTransformation cgTransformation) {
 		js.appendClassHeader(cgTransformation.getContainingPackage());
 		ImperativeTransformation transformation = QVTiCGUtil.getAST(cgTransformation);
-		QVTiTransformationAnalysis transformationAnalysis = context.getTransformationAnalysis(transformation);
-		this.transformationAnalysis = transformationAnalysis;
+		EntryPointsAnalysis entryPointsAnalysis = context.getEntryPointsAnalysis(transformation);
+		//		this.entryPointsAnalysis = entryPointsAnalysis;
 		String className = cgTransformation.getName();
 		assert className != null;
 		js.append("/**\n");
@@ -3188,29 +3223,32 @@
 				cgElement.accept(this);
 			}
 		}
-		doOppositeCaches(transformationAnalysis);
+		doOppositeCaches(entryPointsAnalysis);
 		js.append("\n");
-		String oppositeIndex2propertyIdName = doOppositePropertyIds(transformationAnalysis);
+		String oppositeIndex2propertyIdName = doOppositePropertyIds(entryPointsAnalysis);
 		if (oppositeIndex2propertyIdName != null) {
 			js.append("\n");
 		}
-		List<@Nullable AllInstancesAnalysis> allInstancesAnalyses = doAllInstances(transformationAnalysis);
-		//	@NonNull String @Nullable [] allInstancesNames = allInstancesAnalysis != null ? allInstancesAnalysis.getNames() : null;
-		js.append("\n");
 		List<@NonNull CGMapping> cgMappings = ClassUtil.nullFree(cgTransformation.getOwnedMappings());
 		List<CGOperation> cgOperations = cgTransformation.getOperations();
 		doMappingConstructorConstants(cgMappings);
 		doFunctionConstructorConstants(ClassUtil.nullFree(cgOperations));
 		js.append("\n");
-		doConstructor(cgTransformation, oppositeIndex2propertyIdName, allInstancesAnalyses);
-		js.append("\n");
-		/*		if (isIncremental) {
-			doCreateIncrementalManagers();
+		for (@NonNull EntryPointAnalysis entryPointAnalysis : entryPointsAnalysis.getEntryPointAnalyses()) {
+			List<@Nullable AllInstancesAnalysis> allInstancesAnalyses = doAllInstances(entryPointAnalysis);
+			//	@NonNull String @Nullable [] allInstancesNames = allInstancesAnalysis != null ? allInstancesAnalysis.getNames() : null;
 			js.append("\n");
-		} */
-		/*	doCreateInterval(cgTransformation);
-		js.append("\n"); */
-		doRun(cgTransformation, allInstancesAnalyses);
+			doConstructor(cgTransformation, oppositeIndex2propertyIdName, allInstancesAnalyses);
+			js.append("\n");
+			/*		if (isIncremental) {
+				doCreateIncrementalManagers();
+				js.append("\n");
+			} */
+			/*	doCreateInterval(cgTransformation);
+			js.append("\n"); */
+			doRun(cgTransformation, allInstancesAnalyses);
+			break;
+		}
 		for (@NonNull CGOperation cgOperation : ClassUtil.nullFree(cgOperations)) {
 			if (!(cgOperation instanceof CGCachedOperation)) {
 				js.append("\n");
diff --git a/plugins/org.eclipse.qvtd.codegen/src/org/eclipse/qvtd/codegen/qvti/java/QVTiCodeGenerator.java b/plugins/org.eclipse.qvtd.codegen/src/org/eclipse/qvtd/codegen/qvti/java/QVTiCodeGenerator.java
index f86747a..89e49a6 100644
--- a/plugins/org.eclipse.qvtd.codegen/src/org/eclipse/qvtd/codegen/qvti/java/QVTiCodeGenerator.java
+++ b/plugins/org.eclipse.qvtd.codegen/src/org/eclipse/qvtd/codegen/qvti/java/QVTiCodeGenerator.java
@@ -54,7 +54,7 @@
 import org.eclipse.qvtd.pivot.qvtbase.utilities.QVTbaseEnvironmentFactory;
 import org.eclipse.qvtd.pivot.qvtbase.utilities.QVTbaseUtil;
 import org.eclipse.qvtd.pivot.qvtimperative.ImperativeTransformation;
-import org.eclipse.qvtd.pivot.qvtimperative.evaluation.QVTiTransformationAnalysis;
+import org.eclipse.qvtd.pivot.qvtimperative.evaluation.EntryPointsAnalysis;
 
 /**
  * QVTiCodeGenerator supports generation of the content of a JavaClassFile to
@@ -67,7 +67,7 @@
 	private/* @LazyNonNull*/ CGPackage cgPackage;
 	private/* @LazyNonNull*/ String javaSourceCode = null;
 	protected final @NonNull QVTiGlobalContext globalContext = new QVTiGlobalContext(this);
-	protected final @NonNull Map<Transformation, QVTiTransformationAnalysis> transformation2analysis = new HashMap<Transformation, QVTiTransformationAnalysis>();
+	protected final @NonNull Map<@NonNull Transformation, @NonNull EntryPointsAnalysis> transformation2analysis = new HashMap<>();
 
 	public QVTiCodeGenerator(@NonNull QVTbaseEnvironmentFactory environmentFactory, @NonNull Transformation transformation) {
 		super(environmentFactory);
@@ -259,15 +259,15 @@
 		}
 	}
 
-	public @NonNull QVTiTransformationAnalysis getTransformationAnalysis(@NonNull ImperativeTransformation transformation) {
+	public @NonNull EntryPointsAnalysis getEntryPointsAnalysis(@NonNull ImperativeTransformation transformation) {
 		//		Map<Transformation, QVTiTransformationAnalysis> transformation2analysis = new HashMap<Transformation, QVTiTransformationAnalysis>();
-		QVTiTransformationAnalysis transformationAnalysis = transformation2analysis.get(transformation);
-		if (transformationAnalysis == null) {
-			transformationAnalysis = new QVTiTransformationAnalysis(getEnvironmentFactory(), transformation);
-			transformationAnalysis.analyzeTransformation();
-			transformation2analysis.put(transformation, transformationAnalysis);
+		EntryPointsAnalysis entryPointsAnalysis = transformation2analysis.get(transformation);
+		if (entryPointsAnalysis == null) {
+			entryPointsAnalysis = new EntryPointsAnalysis(getEnvironmentFactory(), transformation);
+			entryPointsAnalysis.analyzeTransformation();
+			transformation2analysis.put(transformation, entryPointsAnalysis);
 		}
-		return transformationAnalysis;
+		return entryPointsAnalysis;
 	}
 
 	public @NonNull File saveSourceFile(@NonNull String savePath) throws IOException {
diff --git a/plugins/org.eclipse.qvtd.compiler/src/org/eclipse/qvtd/compiler/AbstractCompilerChain.java b/plugins/org.eclipse.qvtd.compiler/src/org/eclipse/qvtd/compiler/AbstractCompilerChain.java
index 0e66d9b..1e057b1 100644
--- a/plugins/org.eclipse.qvtd.compiler/src/org/eclipse/qvtd/compiler/AbstractCompilerChain.java
+++ b/plugins/org.eclipse.qvtd.compiler/src/org/eclipse/qvtd/compiler/AbstractCompilerChain.java
@@ -16,11 +16,8 @@
 import java.util.Collection;
 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 javax.tools.JavaFileObject;
 
 import org.eclipse.emf.codegen.ecore.genmodel.GenModel;
@@ -37,20 +34,9 @@
 import org.eclipse.ocl.examples.codegen.dynamic.JavaClasspath;
 import org.eclipse.ocl.examples.codegen.dynamic.JavaFileUtil;
 import org.eclipse.ocl.examples.codegen.dynamic.JavaSourceFileObject;
-import org.eclipse.ocl.pivot.Import;
-import org.eclipse.ocl.pivot.Iteration;
-import org.eclipse.ocl.pivot.LoopExp;
-import org.eclipse.ocl.pivot.Namespace;
-import org.eclipse.ocl.pivot.Operation;
-import org.eclipse.ocl.pivot.OperationCallExp;
-import org.eclipse.ocl.pivot.OppositePropertyCallExp;
-import org.eclipse.ocl.pivot.Property;
-import org.eclipse.ocl.pivot.PropertyCallExp;
 import org.eclipse.ocl.pivot.internal.manager.MetamodelManagerInternal;
 import org.eclipse.ocl.pivot.utilities.ClassUtil;
-import org.eclipse.ocl.pivot.utilities.NameUtil;
 import org.eclipse.ocl.pivot.utilities.PivotUtil;
-import org.eclipse.ocl.pivot.utilities.TreeIterable;
 import org.eclipse.qvtd.codegen.qvti.QVTiCodeGenOptions;
 import org.eclipse.qvtd.codegen.qvti.java.QVTiCodeGenerator;
 import org.eclipse.qvtd.compiler.internal.qvtb2qvts.ScheduleManager;
@@ -71,7 +57,6 @@
 import org.eclipse.qvtd.pivot.qvtcore.utilities.QVTcoreUtil;
 import org.eclipse.qvtd.pivot.qvtimperative.ImperativeModel;
 import org.eclipse.qvtd.pivot.qvtimperative.ImperativeTransformation;
-import org.eclipse.qvtd.pivot.qvtimperative.ImperativeTypedModel;
 import org.eclipse.qvtd.pivot.qvtimperative.QVTimperativePackage;
 import org.eclipse.qvtd.pivot.qvtimperative.evaluation.QVTiEnvironmentFactory;
 import org.eclipse.qvtd.pivot.qvtschedule.MappingRegion;
diff --git a/plugins/org.eclipse.qvtd.debug/src/org/eclipse/qvtd/debug/evaluator/BasicQVTcExecutor.java b/plugins/org.eclipse.qvtd.debug/src/org/eclipse/qvtd/debug/evaluator/BasicQVTcExecutor.java
index cece963..e64e322 100644
--- a/plugins/org.eclipse.qvtd.debug/src/org/eclipse/qvtd/debug/evaluator/BasicQVTcExecutor.java
+++ b/plugins/org.eclipse.qvtd.debug/src/org/eclipse/qvtd/debug/evaluator/BasicQVTcExecutor.java
@@ -11,7 +11,7 @@
 package org.eclipse.qvtd.debug.evaluator;
 
 import org.eclipse.jdt.annotation.NonNull;
-import org.eclipse.qvtd.pivot.qvtimperative.ImperativeTransformation;
+import org.eclipse.qvtd.pivot.qvtimperative.EntryPoint;
 import org.eclipse.qvtd.pivot.qvtimperative.evaluation.BasicQVTiExecutor;
 import org.eclipse.qvtd.pivot.qvtimperative.evaluation.QVTiEnvironmentFactory;
 import org.eclipse.qvtd.pivot.qvtimperative.evaluation.QVTiIncrementalExecutor;
@@ -25,7 +25,7 @@
  */
 public class BasicQVTcExecutor extends QVTiIncrementalExecutor
 {
-	public BasicQVTcExecutor(@NonNull QVTiEnvironmentFactory environmentFactory, @NonNull ImperativeTransformation transformation) {
-		super(environmentFactory, transformation, ModeFactory.LAZY);
+	public BasicQVTcExecutor(@NonNull QVTiEnvironmentFactory environmentFactory, @NonNull EntryPoint entryPoint) {
+		super(environmentFactory, entryPoint, ModeFactory.LAZY);
 	}
 }
diff --git a/plugins/org.eclipse.qvtd.debug/src/org/eclipse/qvtd/debug/evaluator/BasicQVTrExecutor.java b/plugins/org.eclipse.qvtd.debug/src/org/eclipse/qvtd/debug/evaluator/BasicQVTrExecutor.java
index d4b39ba..b9facd9 100644
--- a/plugins/org.eclipse.qvtd.debug/src/org/eclipse/qvtd/debug/evaluator/BasicQVTrExecutor.java
+++ b/plugins/org.eclipse.qvtd.debug/src/org/eclipse/qvtd/debug/evaluator/BasicQVTrExecutor.java
@@ -11,7 +11,7 @@
 package org.eclipse.qvtd.debug.evaluator;
 
 import org.eclipse.jdt.annotation.NonNull;
-import org.eclipse.qvtd.pivot.qvtimperative.ImperativeTransformation;
+import org.eclipse.qvtd.pivot.qvtimperative.EntryPoint;
 import org.eclipse.qvtd.pivot.qvtimperative.evaluation.BasicQVTiExecutor;
 import org.eclipse.qvtd.pivot.qvtimperative.evaluation.QVTiEnvironmentFactory;
 import org.eclipse.qvtd.pivot.qvtimperative.evaluation.QVTiIncrementalExecutor;
@@ -25,7 +25,7 @@
  */
 public class BasicQVTrExecutor extends QVTiIncrementalExecutor
 {
-	public BasicQVTrExecutor(@NonNull QVTiEnvironmentFactory environmentFactory, @NonNull ImperativeTransformation transformation) {
-		super(environmentFactory, transformation, ModeFactory.LAZY);
+	public BasicQVTrExecutor(@NonNull QVTiEnvironmentFactory environmentFactory, @NonNull EntryPoint entryPoint) {
+		super(environmentFactory, entryPoint, ModeFactory.LAZY);
 	}
 }
diff --git a/plugins/org.eclipse.qvtd.debug/src/org/eclipse/qvtd/debug/evaluator/QVTiVMExecutor.java b/plugins/org.eclipse.qvtd.debug/src/org/eclipse/qvtd/debug/evaluator/QVTiVMExecutor.java
index 662422b..e27730d 100644
--- a/plugins/org.eclipse.qvtd.debug/src/org/eclipse/qvtd/debug/evaluator/QVTiVMExecutor.java
+++ b/plugins/org.eclipse.qvtd.debug/src/org/eclipse/qvtd/debug/evaluator/QVTiVMExecutor.java
@@ -35,7 +35,7 @@
 	private long envId = 0;
 
 	public QVTiVMExecutor(@NonNull IVMContext vmContext, @NonNull URI transformationURI) throws IOException {
-		super((QVTiEnvironmentFactory)vmContext.getEnvironmentFactory(), QVTimperativeUtil.loadTransformation((QVTiEnvironmentFactory)vmContext.getEnvironmentFactory(), transformationURI, vmContext.keepDebug()), ModeFactory.LAZY);
+		super((QVTiEnvironmentFactory)vmContext.getEnvironmentFactory(), QVTimperativeUtil.getDefaultEntryPoint(QVTimperativeUtil.loadTransformation((QVTiEnvironmentFactory)vmContext.getEnvironmentFactory(), transformationURI, vmContext.keepDebug())), ModeFactory.LAZY);
 		this.vmContext = vmContext;
 	}
 
@@ -57,6 +57,11 @@
 	}
 
 	@Override
+	public Boolean execute() {
+		return execute(null);
+	}
+
+	@Override
 	protected Boolean executeInternal() {
 		QVTiVMEvaluationVisitor visitor = (QVTiVMEvaluationVisitor) getEvaluationVisitor();
 		VMEvaluationStepper vmStepper = visitor.getVMEvaluationStepper();
diff --git a/plugins/org.eclipse.qvtd.debug/src/org/eclipse/qvtd/debug/launching/QVTcLaunchConfigurationDelegate.java b/plugins/org.eclipse.qvtd.debug/src/org/eclipse/qvtd/debug/launching/QVTcLaunchConfigurationDelegate.java
index cb4f476..9aa6dc9 100644
--- a/plugins/org.eclipse.qvtd.debug/src/org/eclipse/qvtd/debug/launching/QVTcLaunchConfigurationDelegate.java
+++ b/plugins/org.eclipse.qvtd.debug/src/org/eclipse/qvtd/debug/launching/QVTcLaunchConfigurationDelegate.java
@@ -25,7 +25,7 @@
 import org.eclipse.qvtd.debug.QVTiDebugPlugin;
 import org.eclipse.qvtd.debug.core.QVTiDebugCore;
 import org.eclipse.qvtd.debug.evaluator.BasicQVTcExecutor;
-import org.eclipse.qvtd.pivot.qvtimperative.ImperativeTransformation;
+import org.eclipse.qvtd.pivot.qvtimperative.EntryPoint;
 import org.eclipse.qvtd.pivot.qvtimperative.evaluation.QVTiEnvironmentFactory;
 import org.eclipse.qvtd.pivot.qvtimperative.evaluation.QVTiExecutor;
 import org.eclipse.qvtd.pivot.qvtimperative.utilities.QVTimperative;
@@ -101,8 +101,8 @@
 	}
 
 	@Override
-	protected @NonNull QVTiExecutor createExecutor(@NonNull QVTiEnvironmentFactory envFactory, @NonNull ImperativeTransformation transformation) {
-		return new BasicQVTcExecutor(envFactory, transformation);
+	protected @NonNull QVTiExecutor createExecutor(@NonNull QVTiEnvironmentFactory envFactory, @NonNull EntryPoint entryPoint) {
+		return new BasicQVTcExecutor(envFactory, entryPoint);
 	}
 
 	@Override
diff --git a/plugins/org.eclipse.qvtd.debug/src/org/eclipse/qvtd/debug/launching/QVTcompiledJob.java b/plugins/org.eclipse.qvtd.debug/src/org/eclipse/qvtd/debug/launching/QVTcompiledJob.java
index e74ec08..5be0459 100644
--- a/plugins/org.eclipse.qvtd.debug/src/org/eclipse/qvtd/debug/launching/QVTcompiledJob.java
+++ b/plugins/org.eclipse.qvtd.debug/src/org/eclipse/qvtd/debug/launching/QVTcompiledJob.java
@@ -117,7 +117,7 @@
 			//	if (!generatedExecutor.preExecute()) {
 			//
 			//	}
-			if (!generatedExecutor.execute()) {
+			if (!generatedExecutor.execute(null)) {		// FIXME TypedModel index
 				//	if (!suppressFailureDiagnosis) {						// FIXME BUG 511028
 				StringBuilder s = new StringBuilder();
 				transformer.getInvocationManager().diagnoseWorkLists(s);
diff --git a/plugins/org.eclipse.qvtd.debug/src/org/eclipse/qvtd/debug/launching/QVTiLaunchConfigurationDelegate.java b/plugins/org.eclipse.qvtd.debug/src/org/eclipse/qvtd/debug/launching/QVTiLaunchConfigurationDelegate.java
index a265edf..84846d3 100644
--- a/plugins/org.eclipse.qvtd.debug/src/org/eclipse/qvtd/debug/launching/QVTiLaunchConfigurationDelegate.java
+++ b/plugins/org.eclipse.qvtd.debug/src/org/eclipse/qvtd/debug/launching/QVTiLaunchConfigurationDelegate.java
@@ -26,7 +26,7 @@
 import org.eclipse.qvtd.compiler.DefaultCompilerOptions;
 import org.eclipse.qvtd.debug.QVTiDebugPlugin;
 import org.eclipse.qvtd.debug.core.QVTiDebugCore;
-import org.eclipse.qvtd.pivot.qvtimperative.ImperativeTransformation;
+import org.eclipse.qvtd.pivot.qvtimperative.EntryPoint;
 import org.eclipse.qvtd.pivot.qvtimperative.evaluation.QVTiEnvironmentFactory;
 import org.eclipse.qvtd.pivot.qvtimperative.evaluation.QVTiExecutor;
 import org.eclipse.qvtd.pivot.qvtimperative.evaluation.QVTiIncrementalExecutor;
@@ -56,8 +56,8 @@
 		return new DefaultCompilerOptions();
 	}
 
-	protected @NonNull QVTiExecutor createExecutor(@NonNull QVTiEnvironmentFactory envFactory, @NonNull ImperativeTransformation transformation) {
-		return new QVTiIncrementalExecutor(envFactory, transformation, ModeFactory.LAZY);
+	protected @NonNull QVTiExecutor createExecutor(@NonNull QVTiEnvironmentFactory envFactory, @NonNull EntryPoint entryPoint) {
+		return new QVTiIncrementalExecutor(envFactory, entryPoint, ModeFactory.LAZY);
 	}
 
 	protected @NonNull QVTiDebugCore getDebugCore() {
diff --git a/plugins/org.eclipse.qvtd.debug/src/org/eclipse/qvtd/debug/launching/QVTinterpretedJob.java b/plugins/org.eclipse.qvtd.debug/src/org/eclipse/qvtd/debug/launching/QVTinterpretedJob.java
index 5b7eeb7..5c54015 100644
--- a/plugins/org.eclipse.qvtd.debug/src/org/eclipse/qvtd/debug/launching/QVTinterpretedJob.java
+++ b/plugins/org.eclipse.qvtd.debug/src/org/eclipse/qvtd/debug/launching/QVTinterpretedJob.java
@@ -30,6 +30,7 @@
 import org.eclipse.ocl.pivot.resource.BasicProjectManager;
 import org.eclipse.ocl.pivot.utilities.ClassUtil;
 import org.eclipse.qvtd.pivot.qvtbase.TypedModel;
+import org.eclipse.qvtd.pivot.qvtimperative.EntryPoint;
 import org.eclipse.qvtd.pivot.qvtimperative.ImperativeTransformation;
 import org.eclipse.qvtd.pivot.qvtimperative.evaluation.QVTiEnvironmentFactory;
 import org.eclipse.qvtd.pivot.qvtimperative.evaluation.QVTiExecutor;
@@ -62,7 +63,7 @@
 				environmentFactory.setEvaluationTracingEnabled(true);
 			}
 			subMonitor.split(LOAD_TX_TICKS, SubMonitor.SUPPRESS_NONE).beginTask("Loading '" + txURI + "'", LOAD_TX_TICKS);
-			ImperativeTransformation transformation = QVTimperativeUtil.loadTransformation(environmentFactory, txURI, environmentFactory.keepDebug());
+			ImperativeTransformation iTransformation = QVTimperativeUtil.loadTransformation(environmentFactory, txURI, environmentFactory.keepDebug());
 			if (monitor.isCanceled()) {
 				throw new OperationCanceledException();
 			}
@@ -70,9 +71,10 @@
 
 			//		QVTiExecutor executor2 = new QVTiTransformationExecutor(getEnvironmentFactory(), txClass);
 
-			QVTiExecutor executor = launchConfigurationDelegate.createExecutor(environmentFactory, transformation);
+			EntryPoint iEntryPoint = QVTimperativeUtil.getDefaultEntryPoint(iTransformation);
+			QVTiExecutor executor = launchConfigurationDelegate.createExecutor(environmentFactory, iEntryPoint);
 			QVTiModelsManager modelsManager = executor.getModelsManager();
-			for (@NonNull TypedModel typedModel : ClassUtil.nullFree(transformation.getModelParameter())) {
+			for (@NonNull TypedModel typedModel : ClassUtil.nullFree(iTransformation.getModelParameter())) {
 				if (monitor.isCanceled()) {
 					throw new OperationCanceledException();
 				}
@@ -105,7 +107,7 @@
 				throw new OperationCanceledException();
 			}
 			subMonitor.split(EXECUTING_TICKS, SubMonitor.SUPPRESS_NONE).beginTask("Executing '" + txURI + "'", EXECUTING_TICKS);
-			executor.execute();
+			executor.execute(null);
 			if (monitor.isCanceled()) {
 				throw new OperationCanceledException();
 			}
diff --git a/plugins/org.eclipse.qvtd.debug/src/org/eclipse/qvtd/debug/launching/QVTrLaunchConfigurationDelegate.java b/plugins/org.eclipse.qvtd.debug/src/org/eclipse/qvtd/debug/launching/QVTrLaunchConfigurationDelegate.java
index b17a2af..73a27fb 100644
--- a/plugins/org.eclipse.qvtd.debug/src/org/eclipse/qvtd/debug/launching/QVTrLaunchConfigurationDelegate.java
+++ b/plugins/org.eclipse.qvtd.debug/src/org/eclipse/qvtd/debug/launching/QVTrLaunchConfigurationDelegate.java
@@ -25,7 +25,7 @@
 import org.eclipse.qvtd.debug.QVTiDebugPlugin;
 import org.eclipse.qvtd.debug.core.QVTiDebugCore;
 import org.eclipse.qvtd.debug.evaluator.BasicQVTrExecutor;
-import org.eclipse.qvtd.pivot.qvtimperative.ImperativeTransformation;
+import org.eclipse.qvtd.pivot.qvtimperative.EntryPoint;
 import org.eclipse.qvtd.pivot.qvtimperative.evaluation.QVTiEnvironmentFactory;
 import org.eclipse.qvtd.pivot.qvtimperative.evaluation.QVTiExecutor;
 import org.eclipse.qvtd.pivot.qvtimperative.utilities.QVTimperative;
@@ -106,8 +106,8 @@
 	}
 
 	@Override
-	protected @NonNull QVTiExecutor createExecutor(@NonNull QVTiEnvironmentFactory envFactory, @NonNull ImperativeTransformation transformation) {
-		return new BasicQVTrExecutor(envFactory, transformation);
+	protected @NonNull QVTiExecutor createExecutor(@NonNull QVTiEnvironmentFactory envFactory, @NonNull EntryPoint entryPoint) {
+		return new BasicQVTrExecutor(envFactory, entryPoint);
 	}
 
 	@Override
diff --git a/plugins/org.eclipse.qvtd.pivot.qvtimperative/src/org/eclipse/qvtd/pivot/qvtimperative/evaluation/BasicQVTiExecutor.java b/plugins/org.eclipse.qvtd.pivot.qvtimperative/src/org/eclipse/qvtd/pivot/qvtimperative/evaluation/BasicQVTiExecutor.java
index 377f7af..325c1c8 100644
--- a/plugins/org.eclipse.qvtd.pivot.qvtimperative/src/org/eclipse/qvtd/pivot/qvtimperative/evaluation/BasicQVTiExecutor.java
+++ b/plugins/org.eclipse.qvtd.pivot.qvtimperative/src/org/eclipse/qvtd/pivot/qvtimperative/evaluation/BasicQVTiExecutor.java
@@ -11,7 +11,6 @@
 package org.eclipse.qvtd.pivot.qvtimperative.evaluation;
 
 import java.io.IOException;
-import java.util.ArrayList;
 import java.util.HashMap;
 import java.util.List;
 import java.util.Map;
@@ -102,8 +101,10 @@
 		}
 	}
 
+	//	protected final @NonNull Mapping entryPoint;
 	protected final @NonNull ImperativeTransformation transformation;
-	protected final @NonNull QVTiTransformationAnalysis transformationAnalysis;
+	protected final @NonNull EntryPointsAnalysis entryPointsAnalysis;
+	protected final @NonNull EntryPointAnalysis entryPointAnalysis;
 	protected final @NonNull ModeFactory modeFactory;
 	protected final @NonNull QVTiModelsManager modelsManager;
 	private @Nullable WrappedModelManager wrappedModelManager = null;
@@ -111,13 +112,15 @@
 	protected final boolean debugInvocations = AbstractTransformer.INVOCATIONS.isActive();
 	private final @NonNull Map<@NonNull Mapping, @NonNull Interval> mapping2interval = new HashMap<>();;
 
-	public BasicQVTiExecutor(@NonNull QVTiEnvironmentFactory environmentFactory, @NonNull ImperativeTransformation transformation, @NonNull ModeFactory modeFactory) {
+	public BasicQVTiExecutor(@NonNull QVTiEnvironmentFactory environmentFactory, @NonNull EntryPoint entryPoint, @NonNull ModeFactory modeFactory) {
 		super(environmentFactory);
-		this.transformation = transformation;
-		this.transformationAnalysis = environmentFactory.createTransformationAnalysis(transformation);
+		//		this.entryPoint = entryPoint;
+		this.transformation = QVTimperativeUtil.getContainingTransformation(entryPoint);
+		this.entryPointsAnalysis = environmentFactory.createEntryPointsAnalysis(transformation);
 		this.modeFactory = modeFactory;
-		transformationAnalysis.analyzeTransformation();
-		this.modelsManager = environmentFactory.createModelsManager(transformationAnalysis);
+		entryPointsAnalysis.analyzeTransformation();
+		this.entryPointAnalysis = entryPointsAnalysis.getEntryPointAnalysis(entryPoint);
+		this.modelsManager = environmentFactory.createModelsManager(entryPointAnalysis);
 		for (@NonNull TypedModel typedModel : QVTimperativeUtil.getModelParameters(transformation)) {
 			QVTiTypedModelInstance typedModelInstance = createTypedModelInstance((ImperativeTypedModel)typedModel);
 			modelsManager.initTypedModelInstance(typedModelInstance);
@@ -184,7 +187,7 @@
 	}
 
 	@Override
-	public Boolean execute() {
+	public Boolean execute(@Nullable Integer targetTypedModelIndex) {
 		modelsManager.analyzeInputResources();
 		initializeEvaluationEnvironment(transformation);
 		getRootEvaluationEnvironment();
@@ -202,6 +205,10 @@
 		return (Boolean) getEvaluationVisitor().visit(transformation);
 	}
 
+	//	public @NonNull EntryPointsAnalysis getEntryPointsAnalysis() {
+	//		return entryPointsAnalysis;
+	//	}
+
 	@Override
 	public @NonNull QVTiEnvironmentFactory getEnvironmentFactory() {
 		return (QVTiEnvironmentFactory) super.getEnvironmentFactory();
@@ -249,10 +256,6 @@
 		return transformation;
 	}
 
-	public @NonNull QVTiTransformationAnalysis getTransformationAnalysis() {
-		return transformationAnalysis;
-	}
-
 	public @NonNull ImperativeTypedModel getTypedModel(@NonNull String name) {
 		ImperativeTypedModel typedModel = NameUtil.getNameable(QVTimperativeUtil.getOwnedTypedModels(transformation), name);
 		if (typedModel == null) {
@@ -266,6 +269,18 @@
 		return typedModel;
 	}
 
+	@Override
+	public int getTypedModelIndex(@NonNull String targetModelName) {
+		int index = 0;
+		for (@NonNull TypedModel typedModel : QVTimperativeUtil.getOwnedTypedModels(transformation)) {
+			if (targetModelName.equals(typedModel.getName())) {
+				return index;
+			}
+			index++;
+		}
+		return -1;
+	}
+
 	protected @Nullable Object internalExecuteFunctionCallExp(@NonNull OperationCallExp operationCallExp,
 			@NonNull Function referredFunction, @Nullable Object @NonNull [] boxedSourceAndArgumentValues) {
 		//		PivotUtil.checkExpression(expressionInOCL);
@@ -448,49 +463,26 @@
 		else {
 			targetProperty.initValue(slotObject, ecoreValue);
 		}
-		Integer cacheIndex = modelsManager.getTransformationAnalysis().getCacheIndex(setStatement);
+		Integer cacheIndex = entryPointsAnalysis.getCacheIndex(setStatement);
 		if (cacheIndex != null) {
 			modelsManager.setUnnavigableOpposite(cacheIndex, slotObject, ecoreValue);
 		}
 	}
 
 	@Override
-	public @Nullable Object internalExecuteTransformation(@NonNull ImperativeTransformation transformation, @NonNull EvaluationVisitor undecoratedVisitor) {
-		Mapping rule = QVTimperativeUtil.getRootMapping(transformation);
+	public @Nullable Object internalExecuteTransformation(@NonNull EntryPoint entryPoint, @NonNull EvaluationVisitor undecoratedVisitor) {
 		CallExp callExp = PivotFactory.eINSTANCE.createOperationCallExp();		// FIXME TransformationCallExp
-		pushEvaluationEnvironment(rule, (TypedElement)callExp);
+		pushEvaluationEnvironment(entryPoint, (TypedElement)callExp);
 		try {
-			List<@NonNull EntryPoint> asEntryPoints = new ArrayList<>();
-			for (@NonNull Mapping asMapping : QVTimperativeUtil.getOwnedMappings(transformation)) {
-				if (asMapping instanceof EntryPoint) {
-					asEntryPoints.add((EntryPoint) asMapping);
-				}
-
-			}
-			EntryPoint asEntryPoint = (asEntryPoints.size() > 0) ? asEntryPoints.get(0) : null;
 			Interval rootInterval = getInvocationManager().getRootInterval();
-			mapping2interval.put(rule, rootInterval);
+			mapping2interval.put(entryPoint, rootInterval);
 			TypedModelInstance modelInstance = null;
-			TypedModel typedModel = null;
-			if (asEntryPoint != null) {
-				for (@NonNull TypedModel typedModel2 : QVTimperativeUtil.getCheckedTypedModels(asEntryPoint)) {
-					typedModel = typedModel2;
-					break;
-				}
-			}
-			else {			// FIXME Obsolete non-EntryPoint support
-				for (@NonNull ImperativeTypedModel typedModel2 : QVTimperativeUtil.getOwnedTypedModels(transformation)) {
-					if (typedModel2.isIsChecked()) {
-						typedModel = typedModel2;
-						break;
-					}
-				}
-			}
-			if (typedModel != null) {
+			for (@NonNull TypedModel typedModel : QVTimperativeUtil.getCheckedTypedModels(entryPoint)) {
 				modelInstance = getModelsManager().getTypedModelInstance(typedModel);
+				break;
 			}
 			assert modelInstance != null;
-			for (@NonNull MappingParameter mappingParameter : QVTimperativeUtil.getOwnedMappingParameters(rule)) {
+			for (@NonNull MappingParameter mappingParameter : QVTimperativeUtil.getOwnedMappingParameters(entryPoint)) {
 				if (mappingParameter instanceof AppendParameter) {
 					org.eclipse.ocl.pivot.Class type = QVTimperativeUtil.getClassType(mappingParameter);
 					Connection theConnection = null;
@@ -504,7 +496,8 @@
 					getEvaluationEnvironment().add(mappingParameter, theConnection);
 				}
 			}
-			rule.accept(undecoratedVisitor);			// Use an outer InvocationConstructor?
+			//	rule.accept(undecoratedVisitor);			// Use an outer InvocationConstructor?
+			internalExecuteMapping(entryPoint, undecoratedVisitor);
 			getInvocationManager().flush();
 		}
 		finally {
diff --git a/plugins/org.eclipse.qvtd.pivot.qvtimperative/src/org/eclipse/qvtd/pivot/qvtimperative/evaluation/EntryPointAnalysis.java b/plugins/org.eclipse.qvtd.pivot.qvtimperative/src/org/eclipse/qvtd/pivot/qvtimperative/evaluation/EntryPointAnalysis.java
new file mode 100644
index 0000000..307fd68
--- /dev/null
+++ b/plugins/org.eclipse.qvtd.pivot.qvtimperative/src/org/eclipse/qvtd/pivot/qvtimperative/evaluation/EntryPointAnalysis.java
@@ -0,0 +1,330 @@
+/*******************************************************************************
+ * Copyright (c) 2019 Willink Transformations and others.
+ * All rights reserved. This program and the accompanying materials
+ * are made available under the terms of the Eclipse Public License v2.0
+ * which accompanies this distribution, and is available at
+ * http://www.eclipse.org/legal/epl-v20.html
+ *
+ * Contributors:
+ *     E.D.Willink - initial API and implementation
+ ******************************************************************************/
+package org.eclipse.qvtd.pivot.qvtimperative.evaluation;
+
+import java.util.ArrayList;
+import java.util.HashMap;
+import java.util.HashSet;
+import java.util.List;
+import java.util.Map;
+import java.util.Set;
+
+import org.eclipse.emf.common.util.TreeIterator;
+import org.eclipse.emf.ecore.EObject;
+import org.eclipse.jdt.annotation.NonNull;
+import org.eclipse.jdt.annotation.Nullable;
+import org.eclipse.ocl.pivot.CollectionType;
+import org.eclipse.ocl.pivot.CompleteClass;
+import org.eclipse.ocl.pivot.NavigationCallExp;
+import org.eclipse.ocl.pivot.OCLExpression;
+import org.eclipse.ocl.pivot.Operation;
+import org.eclipse.ocl.pivot.OperationCallExp;
+import org.eclipse.ocl.pivot.OppositePropertyCallExp;
+import org.eclipse.ocl.pivot.PrimitiveType;
+import org.eclipse.ocl.pivot.Property;
+import org.eclipse.ocl.pivot.PropertyCallExp;
+import org.eclipse.ocl.pivot.Type;
+import org.eclipse.ocl.pivot.TypedElement;
+import org.eclipse.ocl.pivot.ids.IdManager;
+import org.eclipse.ocl.pivot.ids.OperationId;
+import org.eclipse.ocl.pivot.ids.TypeId;
+import org.eclipse.ocl.pivot.library.LibraryFeature;
+import org.eclipse.ocl.pivot.library.oclany.OclElementOclContainerProperty;
+import org.eclipse.ocl.pivot.utilities.TreeIterable;
+import org.eclipse.ocl.pivot.utilities.UniqueList;
+import org.eclipse.qvtd.pivot.qvtimperative.AppendParameter;
+import org.eclipse.qvtd.pivot.qvtimperative.EntryPoint;
+import org.eclipse.qvtd.pivot.qvtimperative.Mapping;
+import org.eclipse.qvtd.pivot.qvtimperative.SetStatement;
+import org.eclipse.qvtd.pivot.qvtimperative.utilities.QVTimperativeUtil;
+
+/**
+ * EntryPointAnalysis provides the pre-execution analysis of a particular transformation entry-point.
+ */
+public class EntryPointAnalysis
+{
+	protected final @NonNull EntryPointsAnalysis entryPointsAnalysis;
+	protected final @NonNull EntryPoint entryPoint;
+	protected final @NonNull UniqueList<@NonNull Mapping> mappings = new UniqueList<>();
+
+	/**
+	 *  Set of all types for which allInstances() is invoked.
+	 */
+	private final @NonNull Set<@NonNull CompleteClass> allInstancesCompleteClasses = new HashSet<>();
+	/**
+	 * Map from oppositePropertyCallExp to the cache index identifying the relevant un-navigable lookup cache.
+	 */
+	private final @NonNull Map<@NonNull OppositePropertyCallExp, @NonNull Integer> oppositePropertyCallExp2cacheIndex = new HashMap<>();
+
+	/**
+	 * Mappings that have an isPolled input.
+	 */
+	private final @NonNull Set<@NonNull Mapping> hazardousMappings = new HashSet<>();
+
+	/**
+	 * Map from mapping to the properties that it may access.
+	 */
+	private final @NonNull Map<@NonNull Mapping, @NonNull Set<@NonNull NavigationCallExp>> mapping2property = new HashMap<>();
+
+	/**
+	 * Map from mapping to the properties that it may assign.
+	 */
+	private final @NonNull Map<@NonNull Mapping, @NonNull Set<@NonNull SetStatement>> mapping2propertyAssignments = new HashMap<>();
+
+	/**
+	 * Map from operation to the properties that it may access.
+	 */
+	private final @NonNull Map<@NonNull Operation, @NonNull Set<@NonNull NavigationCallExp>> operation2property = new HashMap<>();
+
+	/**
+	 * The SetStatements to each Property.
+	 */
+	private final @NonNull Map<@NonNull Property, @NonNull Set<@NonNull SetStatement>> property2propertyAssignments = new HashMap<>();
+
+	/**
+	 * Map of all oclContainer() accesses.
+	 */
+	private final @NonNull Map<@NonNull Type, @NonNull List<@NonNull Type>> parentClass2childClasses = new HashMap<>();
+
+	public EntryPointAnalysis(@NonNull EntryPointsAnalysis entryPointsAnalysis, @NonNull EntryPoint entryPoint) {
+		this.entryPointsAnalysis = entryPointsAnalysis;
+		this.entryPoint = entryPoint;
+		mappings.add(entryPoint);
+	}
+
+	private void addAllInstancesClass(@NonNull TypedElement asExpression) {
+		Type asType = asExpression instanceof OCLExpression ? ((OCLExpression)asExpression).getTypeValue() : null;
+		if (asType == null) {
+			asType = asExpression.getType();
+		}
+		if (asType instanceof org.eclipse.ocl.pivot.Class) {
+			assert !(asType instanceof PrimitiveType);
+			assert !(asType instanceof CollectionType);
+			CompleteClass completeClass = entryPointsAnalysis.environmentFactory.getCompleteModel().getCompleteClass(asType);
+			allInstancesCompleteClasses.add(completeClass);
+		}
+	}
+
+	public boolean addMapping(@NonNull Mapping iMapping) {
+		return mappings.add(iMapping);
+	}
+
+	public void analyze() {
+		//
+		//	First pass
+		//  - identify all allInstances() source types
+		//  - identify all SetStatements
+		//  - identify all assigned PropertyCallExp and allocate a cacheIndex
+		//
+		List<@NonNull SetStatement> setStatements = new ArrayList<>();
+		Type oclElementType = entryPointsAnalysis.environmentFactory.getStandardLibrary().getOclElementType();
+		Type modelType = entryPointsAnalysis.environmentFactory.getStandardLibrary().getLibraryType("Model");
+		OperationId allInstancesOperationId = oclElementType.getTypeId().getOperationId(0, "allInstances", IdManager.getParametersId());
+		OperationId objectsOfKindOperationId = modelType.getTypeId().getOperationId(1, "objectsOfKind", IdManager.getParametersId(TypeId.T_1));
+		OperationId objectsOfTypeOperationId = modelType.getTypeId().getOperationId(1, "objectsOfType", IdManager.getParametersId(TypeId.T_1));
+		for (@NonNull Mapping iMapping : getMappings()) {
+			for (EObject eObject : new TreeIterable(iMapping, true)) {
+				if (eObject instanceof Mapping) {
+					Mapping mapping = (Mapping)eObject;
+					analyzeMappingPropertyAccesses(mapping);
+					analyzeMappingSetStatements(mapping);
+					if (QVTimperativeUtil.isObserver(mapping)) {
+						hazardousMappings.add(mapping);
+					}
+				}
+				else if (eObject instanceof OppositePropertyCallExp) {
+					OppositePropertyCallExp oppositePropertyCallExp = (OppositePropertyCallExp)eObject;
+					Property navigableProperty = oppositePropertyCallExp.getReferredProperty();
+					if ((navigableProperty != null) && !navigableProperty.isIsComposite()) {
+						int cacheIndex = entryPointsAnalysis.allocateCacheIndex(oppositePropertyCallExp.getOwnedSource(), navigableProperty);
+						oppositePropertyCallExp2cacheIndex.put(oppositePropertyCallExp, cacheIndex);
+					}
+				}
+				else if (eObject instanceof SetStatement) {
+					setStatements.add((SetStatement)eObject);
+				}
+				else if (eObject instanceof AppendParameter) {
+					Mapping mapping = QVTimperativeUtil.getContainingMapping(eObject);
+					if (entryPoint == mapping) {
+						addAllInstancesClass((AppendParameter)eObject);
+					}
+				}
+				else if (eObject instanceof OperationCallExp) {
+					OperationCallExp operationCallExp = (OperationCallExp)eObject;
+					Operation referredOperation = operationCallExp.getReferredOperation();
+					if (referredOperation != null) {
+						OperationId operationId = referredOperation.getOperationId();
+						if (operationId == allInstancesOperationId) {
+							OCLExpression source = operationCallExp.getOwnedSource();
+							if (source != null) {
+								addAllInstancesClass(source);
+							}
+						}
+						else if ((operationId == objectsOfKindOperationId) || (operationId == objectsOfTypeOperationId)) {
+							OCLExpression argument = operationCallExp.getOwnedArguments().get(0);
+							if (argument != null) {
+								addAllInstancesClass(argument);
+							}
+						}
+					}
+				}
+				/*			else if (eObject instanceof OppositePropertyCallExp) {
+					OppositePropertyCallExp oppositePropertyCallExp = (OppositePropertyCallExp)eObject;
+					Property referredProperty = oppositePropertyCallExp.getReferredProperty();
+					if (referredProperty != null) {
+						getOppositeCacheIndex(referredProperty);
+					}
+				} */
+			}
+			//
+			//	Second pass
+			//  - install cacheIndex allocated to MiddlePropertyCallExp in each MiddleSetStatement
+			//
+			entryPointsAnalysis.analyzeStatements(setStatements);
+			//
+			analyzeProperties();
+		}
+	}
+
+	private @NonNull Set<@NonNull NavigationCallExp> analyzeMappingPropertyAccesses(@NonNull Mapping mapping) {
+		Set<@NonNull NavigationCallExp> accessedProperties = mapping2property.get(mapping);
+		if (accessedProperties != null) {
+			return accessedProperties;
+		}
+		accessedProperties = new HashSet<>();
+		mapping2property.put(mapping, accessedProperties);
+		analyzeTree(accessedProperties, mapping.eAllContents());
+		return accessedProperties;
+	}
+
+	private @NonNull Set<@NonNull SetStatement> analyzeMappingSetStatements(@NonNull Mapping mapping) {
+		Set<@NonNull SetStatement> assignedProperties = mapping2propertyAssignments.get(mapping);
+		if (assignedProperties == null) {
+			assignedProperties = new HashSet<>();
+			mapping2propertyAssignments.put(mapping, assignedProperties);
+		}
+		for (TreeIterator<EObject> treeIterator = mapping.eAllContents(); treeIterator.hasNext(); ) {
+			EObject eObject = treeIterator.next();
+			if (eObject instanceof SetStatement) {
+				assignedProperties.add((SetStatement) eObject);
+			}
+		}
+		return assignedProperties;
+	}
+
+	private @NonNull Set<@NonNull NavigationCallExp> analyzeOperation(@NonNull Operation operation) {
+		Set<@NonNull NavigationCallExp> operationProperties = operation2property.get(operation);
+		if (operationProperties != null) {
+			return operationProperties;
+		}
+		operationProperties = new HashSet<>();
+		operation2property.put(operation, operationProperties);
+		analyzeTree(operationProperties, operation.eAllContents());
+		return operationProperties;
+	}
+
+	private void analyzeProperties() {
+		for (@NonNull Set<@NonNull SetStatement> propertyAssignments : mapping2propertyAssignments.values()) {
+			for (@NonNull SetStatement propertyAssignment : propertyAssignments) {
+				Property property = propertyAssignment.getTargetProperty();
+				assert property != null;
+				Set<@NonNull SetStatement> assignments = property2propertyAssignments.get(property);
+				if (assignments == null) {
+					assignments = new HashSet<>();
+					property2propertyAssignments.put(property, assignments);
+				}
+				assignments.add(propertyAssignment);
+			}
+		}
+	}
+
+	protected void analyzeTree(@NonNull Set<NavigationCallExp> properties, /*@NonNull*/ TreeIterator<EObject> treeIterator) {
+		while (treeIterator.hasNext()) {
+			EObject eObject = treeIterator.next();
+			if (eObject instanceof OperationCallExp) {
+				Operation referredOperation = ((OperationCallExp)eObject).getReferredOperation();
+				if (referredOperation != null) {
+					properties.addAll(analyzeOperation(referredOperation));
+				}
+			}
+			else if (eObject instanceof PropertyCallExp) {
+				PropertyCallExp asPropertyCallExp = (PropertyCallExp)eObject;
+				Property referredProperty = asPropertyCallExp.getReferredProperty();
+				if (referredProperty != null) {
+					LibraryFeature implementation = referredProperty.getImplementation();
+					if (implementation instanceof OclElementOclContainerProperty) {
+						Type childType = asPropertyCallExp.getOwnedSource().getType();
+						assert childType != null;
+						Type parentType = asPropertyCallExp.getType();
+						assert parentType != null;
+						List<@NonNull Type> childClasses = parentClass2childClasses .get(parentType);
+						if (childClasses == null) {
+							childClasses = new ArrayList<>();
+							parentClass2childClasses.put(parentType, childClasses);
+						}
+						if (!childClasses.contains(childType)) {
+							childClasses.add(childType);
+						}
+					}
+					else {
+						properties.add(asPropertyCallExp);
+					}
+				}
+			}
+			else if (eObject instanceof OppositePropertyCallExp) {
+				OppositePropertyCallExp asOppositePropertyCallExp = (OppositePropertyCallExp)eObject;
+				Property referredOppositeProperty = asOppositePropertyCallExp.getReferredProperty();
+				if (referredOppositeProperty != null) {
+					Property referredProperty = referredOppositeProperty.getOpposite();
+					if (referredProperty != null) {
+						properties.add(asOppositePropertyCallExp);
+					}
+				}
+			}
+		}
+	}
+
+	public @NonNull Set<@NonNull CompleteClass> getAllInstancesCompleteClasses() {
+		return allInstancesCompleteClasses;
+	}
+
+	public @Nullable Integer getCacheIndex(@NonNull OppositePropertyCallExp oppositePropertyCallExp) {
+		return oppositePropertyCallExp2cacheIndex.get(oppositePropertyCallExp);
+	}
+
+	public @NonNull EntryPoint getEntryPoint() {
+		return entryPoint;
+	}
+
+	public @NonNull EntryPointsAnalysis getEntryPointsAnalysis() {
+		return entryPointsAnalysis;
+	}
+
+	//		public @NonNull Set<@NonNull Mapping> getHazardousMappings() {
+	//			return hazardousMappings;
+	//		}
+
+	//		public @NonNull Map<@NonNull Mapping, @NonNull Set<@NonNull NavigationCallExp>> getMapping2Property() {
+	//			return mapping2property;
+	//		}
+
+	//		public @NonNull Map<Mapping, @NonNull Set<@NonNull SetStatement>> getMapping2SetStatements() {
+	//			return mapping2propertyAssignments;
+	//		}
+
+	public @NonNull List<@NonNull Mapping> getMappings() {
+		return mappings;
+	}
+
+	public boolean isHazardous(@NonNull Mapping mapping) {
+		return hazardousMappings.contains(mapping);
+	}
+}
\ No newline at end of file
diff --git a/plugins/org.eclipse.qvtd.pivot.qvtimperative/src/org/eclipse/qvtd/pivot/qvtimperative/evaluation/EntryPointsAnalysis.java b/plugins/org.eclipse.qvtd.pivot.qvtimperative/src/org/eclipse/qvtd/pivot/qvtimperative/evaluation/EntryPointsAnalysis.java
new file mode 100644
index 0000000..6d4a16c
--- /dev/null
+++ b/plugins/org.eclipse.qvtd.pivot.qvtimperative/src/org/eclipse/qvtd/pivot/qvtimperative/evaluation/EntryPointsAnalysis.java
@@ -0,0 +1,194 @@
+/*******************************************************************************
+ * Copyright (c) 2013, 2018 Willink Transformations and others.
+ * All rights reserved. This program and the accompanying materials
+ * are made available under the terms of the Eclipse Public License v2.0
+ * which accompanies this distribution, and is available at
+ * http://www.eclipse.org/legal/epl-v20.html
+ *
+ * Contributors:
+ *     E.D.Willink - initial API and implementation
+ ******************************************************************************/
+package org.eclipse.qvtd.pivot.qvtimperative.evaluation;
+
+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;
+import org.eclipse.ocl.pivot.CompleteClass;
+import org.eclipse.ocl.pivot.OCLExpression;
+import org.eclipse.ocl.pivot.Property;
+import org.eclipse.ocl.pivot.ids.PropertyId;
+import org.eclipse.ocl.pivot.internal.manager.MetamodelManagerInternal;
+import org.eclipse.ocl.pivot.internal.utilities.EnvironmentFactoryInternal;
+import org.eclipse.ocl.pivot.utilities.ClassUtil;
+import org.eclipse.ocl.pivot.utilities.EnvironmentFactory;
+import org.eclipse.ocl.pivot.utilities.TreeIterable;
+import org.eclipse.qvtd.pivot.qvtimperative.EntryPoint;
+import org.eclipse.qvtd.pivot.qvtimperative.ImperativeTransformation;
+import org.eclipse.qvtd.pivot.qvtimperative.Mapping;
+import org.eclipse.qvtd.pivot.qvtimperative.MappingCall;
+import org.eclipse.qvtd.pivot.qvtimperative.SetStatement;
+import org.eclipse.qvtd.pivot.qvtimperative.utilities.QVTimperativeUtil;
+
+/**
+ * EntryPointsAnalysis accumulates salient characteristics of one or more entry points for a transformation
+ * prior to execution so that those characteristics can be exploited during execution.
+ * <p>
+ * Salient characteristics are:
+ * <br>
+ * - the source types of allInstances() calls
+ * - cache indexes of MiddleSetStatement/MiddlePropertyCallExp
+ */
+public class EntryPointsAnalysis
+{
+	protected final @NonNull EnvironmentFactoryInternal environmentFactory;
+
+	protected final @NonNull ImperativeTransformation transformation;
+
+	/**
+	 *  Map from navigable property to sequential index in any TypedModel.
+	 */
+	private final @NonNull Map<@NonNull Property, @NonNull Integer> property2cacheIndex = new HashMap<>();
+
+	/**
+	 * Map from propertyAssignment to the cache index of an un-navigable lookup cache to be updated by the assignment.
+	 */
+	private final @NonNull Map<@NonNull SetStatement, @NonNull Integer> setStatement2cacheIndex = new HashMap<>();
+
+
+	/**
+	 * Mappings that can be used as entry points.
+	 */
+	private final @NonNull Map<@NonNull EntryPoint, @NonNull EntryPointAnalysis> entryPoint2entryPointAnalysis = new HashMap<>();
+
+	/**
+	 * Mapping and their entry points.
+	 */
+	private final @NonNull Map<@NonNull Mapping, @NonNull EntryPointAnalysis> mapping2entryPointAnalysis = new HashMap<>();
+
+	public EntryPointsAnalysis(@NonNull EnvironmentFactoryInternal environmentFactory, @NonNull ImperativeTransformation transformation) {
+		this.environmentFactory = environmentFactory;
+		this.transformation = transformation;
+	}
+
+	protected @NonNull Integer allocateCacheIndex(@Nullable OCLExpression sourceExpression, @NonNull Property navigableProperty) {
+		Integer cacheIndex = property2cacheIndex.get(navigableProperty);
+		if (cacheIndex == null) {
+			Integer size = property2cacheIndex.size();
+			property2cacheIndex.put(navigableProperty, size);
+			cacheIndex = size;
+		}
+		return cacheIndex;
+	}
+
+	protected void analyzeStatements(@NonNull Iterable<@NonNull SetStatement> setStatements) {
+		for (@NonNull SetStatement propertyAssignment : setStatements) {
+			Property navigableProperty = propertyAssignment.getTargetProperty();
+			if (navigableProperty != null) {
+				Integer cacheIndex = property2cacheIndex.get(navigableProperty);
+				if (cacheIndex != null) { 		// No need to set cacheIndex if it is never accessed by an OppositePropertyCallExp
+					setStatement2cacheIndex.put(propertyAssignment, cacheIndex);
+				}
+			}
+		}
+	}
+
+	public void analyzeTransformation() {
+		for (@NonNull Mapping iMapping : QVTimperativeUtil.getOwnedMappings(transformation)) {
+			if (iMapping instanceof EntryPoint) {
+				EntryPoint iEntryPoint = (EntryPoint) iMapping;
+				EntryPointAnalysis entryPointAnalysis = new EntryPointAnalysis(this, iEntryPoint);
+				entryPoint2entryPointAnalysis.put(iEntryPoint, entryPointAnalysis);
+				mapping2entryPointAnalysis.put(iEntryPoint, entryPointAnalysis);
+				List<@NonNull Mapping> mappings = entryPointAnalysis.getMappings();
+				for (int i = 0; i < mappings.size(); i++) {
+					for (EObject eObject : new TreeIterable(mappings.get(i), true)) {
+						if (eObject instanceof MappingCall) {
+							MappingCall iMappingCall = (MappingCall)eObject;
+							Mapping referredMapping = QVTimperativeUtil.getReferredMapping(iMappingCall);
+							if (entryPointAnalysis.addMapping(referredMapping)) {
+								mapping2entryPointAnalysis.put(referredMapping, entryPointAnalysis);
+							}
+						}
+					}
+				}
+			}
+		}
+		assert !entryPoint2entryPointAnalysis.isEmpty();
+		for (@NonNull EntryPointAnalysis entryPointAnalysis : entryPoint2entryPointAnalysis.values()) {
+			entryPointAnalysis.analyze();
+		}
+	}
+
+	public @Nullable Integer getCacheIndex(@NonNull SetStatement setStatement) {
+		return setStatement2cacheIndex.get(setStatement);
+	}
+
+	public int getCacheIndexes() {
+		return property2cacheIndex.size();
+	}
+
+	public @NonNull Map<@NonNull Property, @NonNull Integer> getCaches() {
+		return property2cacheIndex;
+	}
+
+	//	@Deprecated
+	//	public @NonNull EntryPointAnalysis getDefaultEntryPointAnalysis() {
+	//		return entryPoint2entryPointAnalysis.values().iterator().next();
+	//	}
+
+	public @NonNull EnvironmentFactory getEnvironmentFactory() {
+		return environmentFactory;
+	}
+
+	public @NonNull Iterable<@NonNull EntryPointAnalysis> getEntryPointAnalyses() {
+		return entryPoint2entryPointAnalysis.values();
+	}
+
+	public @NonNull EntryPointAnalysis getEntryPointAnalysis(@NonNull EntryPoint entryPoint) {
+		return ClassUtil.nonNullState(entryPoint2entryPointAnalysis.get(entryPoint));
+	}
+
+	/**
+	 * Return a Map from each instanceClasses to the subset of instanceClasses that are transitive superClasses of the particular instanceClass.
+	 */
+	public @NonNull Map<@NonNull CompleteClass, @Nullable List<@NonNull CompleteClass>> getInstancesCompleteClassAnalysis(@NonNull Iterable<@NonNull CompleteClass> instanceCompleteClasses) {
+		Map<@NonNull CompleteClass, @Nullable List<@NonNull CompleteClass>> instancesClassAnalysis = new HashMap<>();
+		for (@NonNull CompleteClass instanceCompleteClass : instanceCompleteClasses) {
+			instancesClassAnalysis.put(instanceCompleteClass, null);
+		}
+		for (@NonNull CompleteClass instanceCompleteClass : instancesClassAnalysis.keySet()) {
+			List<@NonNull CompleteClass> superInstanceCompleteClasses = new ArrayList<>();
+			superInstanceCompleteClasses.add(instanceCompleteClass);
+			for (@NonNull CompleteClass superCompleteClass : instanceCompleteClass.getProperSuperCompleteClasses()) {
+				if (instancesClassAnalysis.containsKey(superCompleteClass)) {
+					superInstanceCompleteClasses.add(superCompleteClass);
+				}
+				instancesClassAnalysis.put(instanceCompleteClass, superInstanceCompleteClasses);
+			}
+		}
+		return instancesClassAnalysis;
+	}
+
+	public @NonNull MetamodelManagerInternal getMetamodelManager() {
+		return environmentFactory.getMetamodelManager();
+	}
+
+	public @NonNull PropertyId @NonNull [] getPropertyIndex2propertyId() {
+		@NonNull PropertyId @NonNull [] propertyIndex2propertyId = new @NonNull PropertyId[property2cacheIndex.size()];
+		for (@NonNull Property property : property2cacheIndex.keySet()) {
+			Integer index = property2cacheIndex.get(property);
+			assert index != null;
+			propertyIndex2propertyId[index] = property.getPropertyId();
+		}
+		return propertyIndex2propertyId;
+	}
+
+	public @NonNull ImperativeTransformation getTransformation() {
+		return transformation;
+	}
+}
diff --git a/plugins/org.eclipse.qvtd.pivot.qvtimperative/src/org/eclipse/qvtd/pivot/qvtimperative/evaluation/QVTiEnvironmentFactory.java b/plugins/org.eclipse.qvtd.pivot.qvtimperative/src/org/eclipse/qvtd/pivot/qvtimperative/evaluation/QVTiEnvironmentFactory.java
index 2fe0d5d..4efd644 100644
--- a/plugins/org.eclipse.qvtd.pivot.qvtimperative/src/org/eclipse/qvtd/pivot/qvtimperative/evaluation/QVTiEnvironmentFactory.java
+++ b/plugins/org.eclipse.qvtd.pivot.qvtimperative/src/org/eclipse/qvtd/pivot/qvtimperative/evaluation/QVTiEnvironmentFactory.java
@@ -42,13 +42,17 @@
 		getStandardLibrary().setDefaultStandardLibraryURI(QVTimperativeLibrary.STDLIB_URI);
 	}
 
+	public @NonNull EntryPointsAnalysis createEntryPointsAnalysis(@NonNull ImperativeTransformation transformation) {
+		return new EntryPointsAnalysis(this, transformation);
+	}
+
 	//	@Override
 	//	public @NonNull BasicOCLExecutor createExecutor( @NonNull ModelManager modelManager) {
 	//		return new BasicOCLExecutor(this, modelManager);		// Inherited functionality used for validation
 	//	}
 
-	public @NonNull QVTiModelsManager createModelsManager(@NonNull QVTiTransformationAnalysis transformationAnalysis) {
-		return new QVTiModelsManager(transformationAnalysis);
+	public @NonNull QVTiModelsManager createModelsManager(@NonNull EntryPointAnalysis entryPointAnalysis) {
+		return new QVTiModelsManager(entryPointAnalysis);
 	}
 
 	@Override
@@ -56,10 +60,6 @@
 		return new QVTimperativeFlowAnalysis(this, contextExpression);
 	}
 
-	public @NonNull QVTiTransformationAnalysis createTransformationAnalysis(@NonNull ImperativeTransformation transformation) {
-		return new QVTiTransformationAnalysis(this, transformation);
-	}
-
 	public boolean keepDebug() {
 		return false;
 	}
diff --git a/plugins/org.eclipse.qvtd.pivot.qvtimperative/src/org/eclipse/qvtd/pivot/qvtimperative/evaluation/QVTiEvaluationVisitor.java b/plugins/org.eclipse.qvtd.pivot.qvtimperative/src/org/eclipse/qvtd/pivot/qvtimperative/evaluation/QVTiEvaluationVisitor.java
index ca35280..0f05fc7 100644
--- a/plugins/org.eclipse.qvtd.pivot.qvtimperative/src/org/eclipse/qvtd/pivot/qvtimperative/evaluation/QVTiEvaluationVisitor.java
+++ b/plugins/org.eclipse.qvtd.pivot.qvtimperative/src/org/eclipse/qvtd/pivot/qvtimperative/evaluation/QVTiEvaluationVisitor.java
@@ -358,7 +358,7 @@
 
 	@Override
 	public @Nullable Object visitEntryPoint(@NonNull EntryPoint entryPoint) {
-		return visitMapping(entryPoint);
+		return executor.internalExecuteTransformation(entryPoint, undecoratedVisitor);
 	}
 
 	@Override
@@ -391,7 +391,8 @@
 
 	@Override
 	public @Nullable Object visitImperativeTransformation(@NonNull ImperativeTransformation transformation) {
-		return executor.internalExecuteTransformation(transformation, undecoratedVisitor);
+		EntryPoint entryPoint = QVTimperativeUtil.getDefaultEntryPoint(transformation);
+		return executor.internalExecuteTransformation(entryPoint, undecoratedVisitor);
 	}
 
 	@Override
diff --git a/plugins/org.eclipse.qvtd.pivot.qvtimperative/src/org/eclipse/qvtd/pivot/qvtimperative/evaluation/QVTiExecutor.java b/plugins/org.eclipse.qvtd.pivot.qvtimperative/src/org/eclipse/qvtd/pivot/qvtimperative/evaluation/QVTiExecutor.java
index 6ec6093..0036d3d 100644
--- a/plugins/org.eclipse.qvtd.pivot.qvtimperative/src/org/eclipse/qvtd/pivot/qvtimperative/evaluation/QVTiExecutor.java
+++ b/plugins/org.eclipse.qvtd.pivot.qvtimperative/src/org/eclipse/qvtd/pivot/qvtimperative/evaluation/QVTiExecutor.java
@@ -21,7 +21,7 @@
 import org.eclipse.ocl.pivot.TypedElement;
 import org.eclipse.ocl.pivot.evaluation.EvaluationVisitor;
 import org.eclipse.ocl.pivot.internal.evaluation.ExecutorInternal;
-import org.eclipse.qvtd.pivot.qvtimperative.ImperativeTransformation;
+import org.eclipse.qvtd.pivot.qvtimperative.EntryPoint;
 import org.eclipse.qvtd.pivot.qvtimperative.Mapping;
 import org.eclipse.qvtd.pivot.qvtimperative.MappingCall;
 import org.eclipse.qvtd.pivot.qvtimperative.NewStatement;
@@ -33,7 +33,7 @@
 public interface QVTiExecutor extends ExecutorInternal
 {
 	void checkModels() throws CoreException;
-	Boolean execute();
+	Boolean execute(@Nullable Integer targetTypedModelIndex);
 	@Override
 	@NonNull QVTiEvaluationEnvironment getEvaluationEnvironment();
 	@NonNull Interval getInterval(@NonNull Mapping asMapping);
@@ -45,7 +45,7 @@
 	@Nullable Object internalExecuteMappingCall(@NonNull MappingCall mappingCall, @NonNull Object @NonNull [] boundValues, @NonNull EvaluationVisitor undecoratedVisitor);
 	@Nullable Object internalExecuteNewStatement(@NonNull NewStatement newStatement, @NonNull EvaluationVisitor undecoratedVisitor);
 	void internalExecuteSetStatement(@NonNull SetStatement setStatement, @NonNull Object slotObject, @Nullable Object ecoreValue);
-	@Nullable Object internalExecuteTransformation(@NonNull ImperativeTransformation transformation, @NonNull EvaluationVisitor undecoratedVisitor);
+	@Nullable Object internalExecuteTransformation(@NonNull EntryPoint entryPoint, @NonNull EvaluationVisitor undecoratedVisitor);
 	boolean replace(@NonNull TypedElement referredVariable, @Nullable Object value, boolean checkType);
 	void saveModels(@Nullable Map<?, ?> savingOptions) throws IOException;
 	void saveOutput(@NonNull String outName, @NonNull URI outURI);
diff --git a/plugins/org.eclipse.qvtd.pivot.qvtimperative/src/org/eclipse/qvtd/pivot/qvtimperative/evaluation/QVTiIncrementalExecutor.java b/plugins/org.eclipse.qvtd.pivot.qvtimperative/src/org/eclipse/qvtd/pivot/qvtimperative/evaluation/QVTiIncrementalExecutor.java
index bb31e20..2e91c0a 100644
--- a/plugins/org.eclipse.qvtd.pivot.qvtimperative/src/org/eclipse/qvtd/pivot/qvtimperative/evaluation/QVTiIncrementalExecutor.java
+++ b/plugins/org.eclipse.qvtd.pivot.qvtimperative/src/org/eclipse/qvtd/pivot/qvtimperative/evaluation/QVTiIncrementalExecutor.java
@@ -38,7 +38,7 @@
 import org.eclipse.ocl.pivot.values.InvalidValueException;
 import org.eclipse.qvtd.pivot.qvtbase.Function;
 import org.eclipse.qvtd.pivot.qvtbase.graphs.GraphStringBuilder;
-import org.eclipse.qvtd.pivot.qvtimperative.ImperativeTransformation;
+import org.eclipse.qvtd.pivot.qvtimperative.EntryPoint;
 import org.eclipse.qvtd.pivot.qvtimperative.ImperativeTypedModel;
 import org.eclipse.qvtd.pivot.qvtimperative.Mapping;
 import org.eclipse.qvtd.pivot.qvtimperative.MappingCall;
@@ -164,13 +164,13 @@
 	private @Nullable Map<@NonNull Mapping, @NonNull InvocationConstructor> mapping2invocationConstructor = null;
 	private @Nullable Map<@NonNull Operation, Computation.@NonNull Constructor> operation2computationConstructor = null;
 
-	public QVTiIncrementalExecutor(@NonNull QVTiEnvironmentFactory environmentFactory, @NonNull ImperativeTransformation transformation, @NonNull ModeFactory modeFactory) {
-		super(environmentFactory, transformation, modeFactory);
+	public QVTiIncrementalExecutor(@NonNull QVTiEnvironmentFactory environmentFactory, @NonNull EntryPoint entryPoint, @NonNull ModeFactory modeFactory) {
+		super(environmentFactory, entryPoint, modeFactory);
 		boolean isLazy = modeFactory.isLazy();
 		this.invocationManager = isLazy ? new LazyInvocationManager(this) : new IncrementalInvocationManager(this);
 		this.objectManager = isLazy ? new LazyObjectManager((LazyInvocationManager)invocationManager) : new IncrementalObjectManager((IncrementalInvocationManager)invocationManager);
-		Set<@NonNull CompleteClass> allInstancesCompleteClasses = transformationAnalysis.getAllInstancesCompleteClasses();
-		@NonNull PropertyId @NonNull [] propertyIndex2propertyId = transformationAnalysis.getPropertyIndex2propertyId();
+		Set<@NonNull CompleteClass> allInstancesCompleteClasses = entryPointAnalysis.getAllInstancesCompleteClasses();
+		@NonNull PropertyId @NonNull [] propertyIndex2propertyId = entryPointsAnalysis.getPropertyIndex2propertyId();
 		modelsManager.initOpposites(propertyIndex2propertyId);
 
 		for (@NonNull QVTiTypedModelInstance typedModelInstance : modelsManager.getTypedModelInstances()) {
@@ -180,7 +180,7 @@
 				usedCompleteClasses.add(environmentFactory.getCompleteModel().getCompleteClass(usedClass));
 			}
 			usedCompleteClasses.retainAll(allInstancesCompleteClasses);
-			TypedModelAnalysis typedModelAnalysis = new TypedModelAnalysis(transformationAnalysis, typedModel, usedCompleteClasses);
+			TypedModelAnalysis typedModelAnalysis = new TypedModelAnalysis(entryPointsAnalysis, typedModel, usedCompleteClasses);
 			@NonNull ClassId @NonNull [] classIndex2classId = typedModelAnalysis.getClassIndex2ClassId();
 			int @Nullable [] @NonNull [] classIndex2allClassIndexes = typedModelAnalysis.getClassIndex2allClassIndexes();
 			typedModelInstance.initClassIds(classIndex2classId, classIndex2allClassIndexes);
@@ -189,7 +189,7 @@
 				Map<@NonNull Object, Object> extentOpposites = modelsManager.getExtentOpposites();
 				typedModelInstance.initExtent(extentClassIndex, extentOpposites);
 			}
-			typedModelAnalysis.toString();
+			//			typedModelAnalysis.toString();
 		}
 		initConnections();
 	}
@@ -305,7 +305,7 @@
 	public @Nullable Object internalExecuteMappingCall(@NonNull MappingCall mappingCall, @NonNull Object @NonNull [] boundValues, @NonNull EvaluationVisitor undecoratedVisitor) {
 		Mapping asMapping = ClassUtil.nonNullState(mappingCall.getReferredMapping());
 		if (modeFactory.isLazy()) {
-			if (!transformationAnalysis.isHazardous(asMapping)) {
+			if (!entryPointAnalysis.isHazardous(asMapping)) {
 				return super.internalExecuteMappingCall(mappingCall, boundValues, undecoratedVisitor);
 			}
 		}
@@ -318,7 +318,7 @@
 	public @Nullable Object internalExecuteNavigationCallExp(@NonNull NavigationCallExp navigationCallExp, @NonNull Property referredProperty, @Nullable Object sourceValue) {
 		if (referredProperty.isIsImplicit()) {
 			QVTiModelsManager modelManager = getModelsManager();
-			Integer cacheIndex = modelManager.getTransformationAnalysis().getCacheIndex((OppositePropertyCallExp) navigationCallExp);
+			Integer cacheIndex = entryPointAnalysis.getCacheIndex((OppositePropertyCallExp) navigationCallExp);
 			if (cacheIndex != null) {
 				if (sourceValue != null) {
 					return modelManager.getUnnavigableOpposite(cacheIndex, sourceValue);
diff --git a/plugins/org.eclipse.qvtd.pivot.qvtimperative/src/org/eclipse/qvtd/pivot/qvtimperative/evaluation/QVTiModelsManager.java b/plugins/org.eclipse.qvtd.pivot.qvtimperative/src/org/eclipse/qvtd/pivot/qvtimperative/evaluation/QVTiModelsManager.java
index f6ea2e2..82ebeb5 100644
--- a/plugins/org.eclipse.qvtd.pivot.qvtimperative/src/org/eclipse/qvtd/pivot/qvtimperative/evaluation/QVTiModelsManager.java
+++ b/plugins/org.eclipse.qvtd.pivot.qvtimperative/src/org/eclipse/qvtd/pivot/qvtimperative/evaluation/QVTiModelsManager.java
@@ -54,7 +54,8 @@
 	@SuppressWarnings("null")
 	public static final @NonNull ClassId EXTENT_CLASSID = IdManager.getClassId(QVTruntimeLibraryPackage.Literals.EXTENT);
 
-	protected final @NonNull QVTiTransformationAnalysis transformationAnalysis;
+	protected final @NonNull EntryPointAnalysis entryPointAnalysis;
+	protected final @NonNull EntryPointsAnalysis entryPointsAnalysis;
 	protected final @NonNull EnvironmentFactoryInternalExtension environmentFactory;
 
 	/**
@@ -82,11 +83,12 @@
 	 * Instantiates a new QVTi Domain Manager. Responsible for creating new
 	 * instances of the middle model and the middle model EFactory.
 	 */
-	public QVTiModelsManager(@NonNull QVTiTransformationAnalysis transformationAnalysis) {
-		this.transformationAnalysis = transformationAnalysis;
-		this.environmentFactory = (EnvironmentFactoryInternalExtension) transformationAnalysis.getEnvironmentFactory();
-		//	this.allInstancesClasses = transformationAnalysis.getAllInstancesClasses();
-		int cacheIndexes = transformationAnalysis.getCacheIndexes();
+	public QVTiModelsManager(@NonNull EntryPointAnalysis entryPointAnalysis) {
+		this.entryPointAnalysis = entryPointAnalysis;
+		this.entryPointsAnalysis = entryPointAnalysis.getEntryPointsAnalysis();
+		this.environmentFactory = (EnvironmentFactoryInternalExtension) entryPointsAnalysis.getEnvironmentFactory();
+		//	this.allInstancesClasses = entryPointsAnalysis.getAllInstancesClasses();
+		int cacheIndexes = entryPointsAnalysis.getCacheIndexes();
 		this.unnavigableOpposites = new @NonNull Map<?, ?>[cacheIndexes];
 		for (int i = 0; i < cacheIndexes; i++) {
 			this.unnavigableOpposites[i] = new HashMap<>();
@@ -110,11 +112,9 @@
 	 */
 	public @NonNull Set<@NonNull Object> get(org.eclipse.ocl.pivot.@NonNull Class type) {
 		Set<@NonNull Object> elements = new HashSet<>();
-		for (@NonNull ImperativeTypedModel typedModel : QVTimperativeUtil.getOwnedTypedModels(transformationAnalysis.getTransformation())) {
-			if (typedModel.isIsChecked()) {
-				TypedModelInstance typedModelInstance = getTypedModelInstance(typedModel);
-				Iterables.addAll(elements, typedModelInstance.getObjectsOfKind(type));
-			}
+		for (@NonNull TypedModel typedModel : QVTimperativeUtil.getCheckedTypedModels(entryPointAnalysis.getEntryPoint())) {
+			TypedModelInstance typedModelInstance = getTypedModelInstance(typedModel);
+			Iterables.addAll(elements, typedModelInstance.getObjectsOfKind(type));
 		}
 		return elements;
 	}
@@ -145,8 +145,8 @@
 		throw new UnsupportedOperationException();
 	}
 
-	public @NonNull QVTiTransformationAnalysis getTransformationAnalysis() {
-		return transformationAnalysis;
+	public @NonNull EntryPointsAnalysis getTransformationAnalysis() {
+		return entryPointsAnalysis;
 	}
 
 	/*	public List<EObject> getTypeModelEObjectList(@NonNull ImperativeTypedModel model) {
diff --git a/plugins/org.eclipse.qvtd.pivot.qvtimperative/src/org/eclipse/qvtd/pivot/qvtimperative/evaluation/QVTiTransformationAnalysis.java b/plugins/org.eclipse.qvtd.pivot.qvtimperative/src/org/eclipse/qvtd/pivot/qvtimperative/evaluation/QVTiTransformationAnalysis.java
deleted file mode 100644
index 165f160..0000000
--- a/plugins/org.eclipse.qvtd.pivot.qvtimperative/src/org/eclipse/qvtd/pivot/qvtimperative/evaluation/QVTiTransformationAnalysis.java
+++ /dev/null
@@ -1,406 +0,0 @@
-/*******************************************************************************
- * Copyright (c) 2013, 2018 Willink Transformations and others.
- * All rights reserved. This program and the accompanying materials
- * are made available under the terms of the Eclipse Public License v2.0
- * which accompanies this distribution, and is available at
- * http://www.eclipse.org/legal/epl-v20.html
- *
- * Contributors:
- *     E.D.Willink - initial API and implementation
- ******************************************************************************/
-package org.eclipse.qvtd.pivot.qvtimperative.evaluation;
-
-import java.util.ArrayList;
-import java.util.HashMap;
-import java.util.HashSet;
-import java.util.List;
-import java.util.Map;
-import java.util.Set;
-
-import org.eclipse.emf.common.util.TreeIterator;
-import org.eclipse.emf.ecore.EObject;
-import org.eclipse.jdt.annotation.NonNull;
-import org.eclipse.jdt.annotation.Nullable;
-import org.eclipse.ocl.pivot.CollectionType;
-import org.eclipse.ocl.pivot.CompleteClass;
-import org.eclipse.ocl.pivot.NavigationCallExp;
-import org.eclipse.ocl.pivot.OCLExpression;
-import org.eclipse.ocl.pivot.Operation;
-import org.eclipse.ocl.pivot.OperationCallExp;
-import org.eclipse.ocl.pivot.OppositePropertyCallExp;
-import org.eclipse.ocl.pivot.PrimitiveType;
-import org.eclipse.ocl.pivot.Property;
-import org.eclipse.ocl.pivot.PropertyCallExp;
-import org.eclipse.ocl.pivot.Type;
-import org.eclipse.ocl.pivot.TypedElement;
-import org.eclipse.ocl.pivot.ids.IdManager;
-import org.eclipse.ocl.pivot.ids.OperationId;
-import org.eclipse.ocl.pivot.ids.PropertyId;
-import org.eclipse.ocl.pivot.ids.TypeId;
-import org.eclipse.ocl.pivot.internal.manager.MetamodelManagerInternal;
-import org.eclipse.ocl.pivot.internal.utilities.EnvironmentFactoryInternal;
-import org.eclipse.ocl.pivot.library.LibraryFeature;
-import org.eclipse.ocl.pivot.library.oclany.OclElementOclContainerProperty;
-import org.eclipse.ocl.pivot.utilities.EnvironmentFactory;
-import org.eclipse.ocl.pivot.utilities.TreeIterable;
-import org.eclipse.qvtd.pivot.qvtimperative.AppendParameter;
-import org.eclipse.qvtd.pivot.qvtimperative.ImperativeTransformation;
-import org.eclipse.qvtd.pivot.qvtimperative.Mapping;
-import org.eclipse.qvtd.pivot.qvtimperative.SetStatement;
-import org.eclipse.qvtd.pivot.qvtimperative.utilities.QVTimperativeUtil;
-
-/**
- * QVTiTransformationAnalysis accumulates salient characteristics of one or more
- * transformations prior to execution so that those characteristics can be exploited
- * during execution.
- * <p>
- * Salient characteristics are:
- * <br>
- * - the source types of allInstances() calls
- * - cache indexes of MiddleSetStatement/MiddlePropertyCallExp
- */
-public class QVTiTransformationAnalysis
-{
-	protected final @NonNull EnvironmentFactoryInternal environmentFactory;
-
-	protected final @NonNull ImperativeTransformation transformation;
-
-	/**
-	 *  Set of all types for which allInstances() is invoked.
-	 */
-	private final @NonNull Set<@NonNull CompleteClass> allInstancesCompleteClasses = new HashSet<>();
-
-	/**
-	 *  Map from navigable property to sequential index in any TypedModel.
-	 */
-	private final @NonNull Map<@NonNull Property, @NonNull Integer> property2cacheIndex = new HashMap<>();
-
-	/**
-	 * Map from propertyAssignment to the cache index of an un-navigable lookup cache to be updated by the assignment.
-	 */
-	private final @NonNull Map<@NonNull SetStatement, @NonNull Integer> setStatement2cacheIndex = new HashMap<>();
-
-	/**
-	 * Map from oppositePropertyCallExp to the cache index identifying the relevant un-navigable lookup cache.
-	 */
-	private final @NonNull Map<@NonNull OppositePropertyCallExp, @NonNull Integer> oppositePropertyCallExp2cacheIndex = new HashMap<>();
-
-	/**
-	 * Map from operation to the properties that it may access.
-	 */
-	private final @NonNull Map<@NonNull Operation, @NonNull Set<@NonNull NavigationCallExp>> operation2property = new HashMap<>();
-
-	/**
-	 * Map from mapping to the properties that it may access.
-	 */
-	private final @NonNull Map<@NonNull Mapping, @NonNull Set<@NonNull NavigationCallExp>> mapping2property = new HashMap<>();
-
-	/**
-	 * Map from mapping to the properties that it may assign.
-	 */
-	private final @NonNull Map<@NonNull Mapping, @NonNull Set<@NonNull SetStatement>> mapping2propertyAssignments = new HashMap<>();
-
-	/**
-	 * Mappings that have an isPolled input.
-	 */
-	private final @NonNull Set<@NonNull Mapping> hazardousMappings = new HashSet<>();
-
-	/**
-	 * The SetStatements to each Property.
-	 */
-	private final @NonNull Map<@NonNull Property, @NonNull Set<@NonNull SetStatement>> property2propertyAssignments = new HashMap<>();
-
-	/**
-	 * Map of all oclContainer() accesses.
-	 */
-	private final @NonNull Map<@NonNull Type, @NonNull List<@NonNull Type>> parentClass2childClasses = new HashMap<>();
-
-	public QVTiTransformationAnalysis(@NonNull EnvironmentFactoryInternal environmentFactory, @NonNull ImperativeTransformation transformation) {
-		this.environmentFactory = environmentFactory;
-		this.transformation = transformation;
-	}
-
-	private void addAllInstancesClass(@NonNull TypedElement asExpression) {
-		Type asType = asExpression instanceof OCLExpression ? ((OCLExpression)asExpression).getTypeValue() : null;
-		if (asType == null) {
-			asType = asExpression.getType();
-		}
-		if (asType instanceof org.eclipse.ocl.pivot.Class) {
-			assert !(asType instanceof PrimitiveType);
-			assert !(asType instanceof CollectionType);
-			CompleteClass completeClass = environmentFactory.getCompleteModel().getCompleteClass(asType);
-			allInstancesCompleteClasses.add(completeClass);
-		}
-	}
-
-	protected @NonNull Integer allocateCacheIndex(@Nullable OCLExpression sourceExpression, @NonNull Property navigableProperty) {
-		Integer cacheIndex = property2cacheIndex.get(navigableProperty);
-		if (cacheIndex == null) {
-			Integer size = property2cacheIndex.size();
-			property2cacheIndex.put(navigableProperty, size);
-			cacheIndex = size;
-		}
-		return cacheIndex;
-	}
-
-	private @NonNull Set<@NonNull NavigationCallExp> analyzeMappingPropertyAccesses(@NonNull Mapping mapping) {
-		Set<@NonNull NavigationCallExp> accessedProperties = mapping2property.get(mapping);
-		if (accessedProperties != null) {
-			return accessedProperties;
-		}
-		accessedProperties = new HashSet<>();
-		mapping2property.put(mapping, accessedProperties);
-		analyzeTree(accessedProperties, mapping.eAllContents());
-		return accessedProperties;
-	}
-
-	private @NonNull Set<@NonNull SetStatement> analyzeMappingSetStatements(@NonNull Mapping mapping) {
-		Set<@NonNull SetStatement> assignedProperties = mapping2propertyAssignments.get(mapping);
-		if (assignedProperties == null) {
-			assignedProperties = new HashSet<>();
-			mapping2propertyAssignments.put(mapping, assignedProperties);
-		}
-		for (TreeIterator<EObject> treeIterator = mapping.eAllContents(); treeIterator.hasNext(); ) {
-			EObject eObject = treeIterator.next();
-			if (eObject instanceof SetStatement) {
-				assignedProperties.add((SetStatement) eObject);
-			}
-		}
-		return assignedProperties;
-	}
-
-	private @NonNull Set<@NonNull NavigationCallExp> analyzeOperation(@NonNull Operation operation) {
-		Set<@NonNull NavigationCallExp> operationProperties = operation2property.get(operation);
-		if (operationProperties != null) {
-			return operationProperties;
-		}
-		operationProperties = new HashSet<>();
-		operation2property.put(operation, operationProperties);
-		analyzeTree(operationProperties, operation.eAllContents());
-		return operationProperties;
-	}
-
-	private void analyzeProperties() {
-		for (@NonNull Set<@NonNull SetStatement> propertyAssignments : mapping2propertyAssignments.values()) {
-			for (@NonNull SetStatement propertyAssignment : propertyAssignments) {
-				Property property = propertyAssignment.getTargetProperty();
-				assert property != null;
-				Set<@NonNull SetStatement> assignments = property2propertyAssignments.get(property);
-				if (assignments == null) {
-					assignments = new HashSet<>();
-					property2propertyAssignments.put(property, assignments);
-				}
-				assignments.add(propertyAssignment);
-			}
-		}
-	}
-
-	protected void analyzeTree(@NonNull Set<NavigationCallExp> properties, /*@NonNull*/ TreeIterator<EObject> treeIterator) {
-		while (treeIterator.hasNext()) {
-			EObject eObject = treeIterator.next();
-			if (eObject instanceof OperationCallExp) {
-				Operation referredOperation = ((OperationCallExp)eObject).getReferredOperation();
-				if (referredOperation != null) {
-					properties.addAll(analyzeOperation(referredOperation));
-				}
-			}
-			else if (eObject instanceof PropertyCallExp) {
-				PropertyCallExp asPropertyCallExp = (PropertyCallExp)eObject;
-				Property referredProperty = asPropertyCallExp.getReferredProperty();
-				if (referredProperty != null) {
-					LibraryFeature implementation = referredProperty.getImplementation();
-					if (implementation instanceof OclElementOclContainerProperty) {
-						Type childType = asPropertyCallExp.getOwnedSource().getType();
-						assert childType != null;
-						Type parentType = asPropertyCallExp.getType();
-						assert parentType != null;
-						List<@NonNull Type> childClasses = parentClass2childClasses .get(parentType);
-						if (childClasses == null) {
-							childClasses = new ArrayList<>();
-							parentClass2childClasses.put(parentType, childClasses);
-						}
-						if (!childClasses.contains(childType)) {
-							childClasses.add(childType);
-						}
-					}
-					else {
-						properties.add(asPropertyCallExp);
-					}
-				}
-			}
-			else if (eObject instanceof OppositePropertyCallExp) {
-				OppositePropertyCallExp asOppositePropertyCallExp = (OppositePropertyCallExp)eObject;
-				Property referredOppositeProperty = asOppositePropertyCallExp.getReferredProperty();
-				if (referredOppositeProperty != null) {
-					Property referredProperty = referredOppositeProperty.getOpposite();
-					if (referredProperty != null) {
-						properties.add(asOppositePropertyCallExp);
-					}
-				}
-			}
-		}
-	}
-
-	public void analyzeTransformation() {
-		//
-		//	First pass
-		//  - identify all allInstances() source types
-		//  - identify all SetStatements
-		//  - identify all assigned PropertyCallExp and allocate a cacheIndex
-		//
-		Type oclElementType = environmentFactory.getStandardLibrary().getOclElementType();
-		Type modelType = environmentFactory.getStandardLibrary().getLibraryType("Model");
-		OperationId allInstancesOperationId = oclElementType.getTypeId().getOperationId(0, "allInstances", IdManager.getParametersId());
-		OperationId objectsOfKindOperationId = modelType.getTypeId().getOperationId(1, "objectsOfKind", IdManager.getParametersId(TypeId.T_1));
-		OperationId objectsOfTypeOperationId = modelType.getTypeId().getOperationId(1, "objectsOfType", IdManager.getParametersId(TypeId.T_1));
-		List<@NonNull SetStatement> setStatements = new ArrayList<>();
-		for (EObject eObject : new TreeIterable(transformation, true)) {
-			if (eObject instanceof Mapping) {
-				Mapping mapping = (Mapping)eObject;
-				analyzeMappingPropertyAccesses(mapping);
-				analyzeMappingSetStatements(mapping);
-				if (QVTimperativeUtil.isObserver(mapping)) {
-					hazardousMappings.add(mapping);
-				}
-			}
-			else if (eObject instanceof OppositePropertyCallExp) {
-				OppositePropertyCallExp oppositePropertyCallExp = (OppositePropertyCallExp)eObject;
-				Property navigableProperty = oppositePropertyCallExp.getReferredProperty();
-				if ((navigableProperty != null) && !navigableProperty.isIsComposite()) {
-					int cacheIndex = allocateCacheIndex(oppositePropertyCallExp.getOwnedSource(), navigableProperty);
-					oppositePropertyCallExp2cacheIndex.put(oppositePropertyCallExp, cacheIndex);
-				}
-			}
-			else if (eObject instanceof SetStatement) {
-				setStatements.add((SetStatement)eObject);
-			}
-			else if (eObject instanceof AppendParameter) {
-				Mapping mapping = QVTimperativeUtil.getContainingMapping(eObject);
-				Mapping rootMapping = QVTimperativeUtil.getRootMapping(QVTimperativeUtil.getContainingTransformation(mapping));
-				if (rootMapping == mapping) {
-					addAllInstancesClass((AppendParameter)eObject);
-				}
-			}
-			else if (eObject instanceof OperationCallExp) {
-				OperationCallExp operationCallExp = (OperationCallExp)eObject;
-				Operation referredOperation = operationCallExp.getReferredOperation();
-				if (referredOperation != null) {
-					OperationId operationId = referredOperation.getOperationId();
-					if (operationId == allInstancesOperationId) {
-						OCLExpression source = operationCallExp.getOwnedSource();
-						if (source != null) {
-							addAllInstancesClass(source);
-						}
-					}
-					else if ((operationId == objectsOfKindOperationId) || (operationId == objectsOfTypeOperationId)) {
-						OCLExpression argument = operationCallExp.getOwnedArguments().get(0);
-						if (argument != null) {
-							addAllInstancesClass(argument);
-						}
-					}
-				}
-			}
-			/*			else if (eObject instanceof OppositePropertyCallExp) {
-				OppositePropertyCallExp oppositePropertyCallExp = (OppositePropertyCallExp)eObject;
-				Property referredProperty = oppositePropertyCallExp.getReferredProperty();
-				if (referredProperty != null) {
-					getOppositeCacheIndex(referredProperty);
-				}
-			} */
-		}
-		//
-		//	Second pass
-		//  - install cacheIndex allocated to MiddlePropertyCallExp in each MiddleSetStatement
-		//
-		for (@NonNull SetStatement propertyAssignment : setStatements) {
-			Property navigableProperty = propertyAssignment.getTargetProperty();
-			if (navigableProperty != null) {
-				Integer cacheIndex = property2cacheIndex.get(navigableProperty);
-				if (cacheIndex != null) { 		// No need to set cacheIndex if it is never accessed by an OppositePropertyCallExp
-					setStatement2cacheIndex.put(propertyAssignment, cacheIndex);
-				}
-			}
-		}
-		//
-		analyzeProperties();
-	}
-
-	public @NonNull Set<@NonNull CompleteClass> getAllInstancesCompleteClasses() {
-		return allInstancesCompleteClasses;
-	}
-
-	public @Nullable Integer getCacheIndex(@NonNull OppositePropertyCallExp oppositePropertyCallExp) {
-		return oppositePropertyCallExp2cacheIndex.get(oppositePropertyCallExp);
-	}
-
-	public @Nullable Integer getCacheIndex(@NonNull SetStatement setStatement) {
-		return setStatement2cacheIndex.get(setStatement);
-	}
-
-	public int getCacheIndexes() {
-		return property2cacheIndex.size();
-	}
-
-	public @NonNull Map<@NonNull Property, @NonNull Integer> getCaches() {
-		return property2cacheIndex;
-	}
-
-	public @NonNull EnvironmentFactory getEnvironmentFactory() {
-		return environmentFactory;
-	}
-
-	public @NonNull Set<@NonNull Mapping> getHazardousMappings() {
-		return hazardousMappings;
-	}
-
-	/**
-	 * Return a Map from each instanceClasses to the subset of instanceClasses that are transitive superClasses of the particular instanceClass.
-	 */
-	public @NonNull Map<@NonNull CompleteClass, @Nullable List<@NonNull CompleteClass>> getInstancesCompleteClassAnalysis(@NonNull Iterable<@NonNull CompleteClass> instanceCompleteClasses) {
-		Map<@NonNull CompleteClass, @Nullable List<@NonNull CompleteClass>> instancesClassAnalysis = new HashMap<>();
-		for (@NonNull CompleteClass instanceCompleteClass : instanceCompleteClasses) {
-			instancesClassAnalysis.put(instanceCompleteClass, null);
-		}
-		for (@NonNull CompleteClass instanceCompleteClass : instancesClassAnalysis.keySet()) {
-			List<@NonNull CompleteClass> superInstanceCompleteClasses = new ArrayList<>();
-			superInstanceCompleteClasses.add(instanceCompleteClass);
-			for (@NonNull CompleteClass superCompleteClass : instanceCompleteClass.getProperSuperCompleteClasses()) {
-				if (instancesClassAnalysis.containsKey(superCompleteClass)) {
-					superInstanceCompleteClasses.add(superCompleteClass);
-				}
-				instancesClassAnalysis.put(instanceCompleteClass, superInstanceCompleteClasses);
-			}
-		}
-		return instancesClassAnalysis;
-	}
-
-	public @NonNull Map<@NonNull Mapping, @NonNull Set<@NonNull NavigationCallExp>> getMapping2Property() {
-		return mapping2property;
-	}
-
-	public @NonNull Map<Mapping, @NonNull Set<@NonNull SetStatement>> getMapping2SetStatements() {
-		return mapping2propertyAssignments;
-	}
-
-	public @NonNull MetamodelManagerInternal getMetamodelManager() {
-		return environmentFactory.getMetamodelManager();
-	}
-
-	public @NonNull PropertyId @NonNull [] getPropertyIndex2propertyId() {
-		@NonNull PropertyId @NonNull [] propertyIndex2propertyId = new @NonNull PropertyId[property2cacheIndex.size()];
-		for (@NonNull Property property : property2cacheIndex.keySet()) {
-			Integer index = property2cacheIndex.get(property);
-			assert index != null;
-			propertyIndex2propertyId[index] = property.getPropertyId();
-		}
-		return propertyIndex2propertyId;
-	}
-
-	public @NonNull ImperativeTransformation getTransformation() {
-		return transformation;
-	}
-
-	public boolean isHazardous(@NonNull Mapping mapping) {
-		return hazardousMappings.contains(mapping);
-	}
-}
diff --git a/plugins/org.eclipse.qvtd.pivot.qvtimperative/src/org/eclipse/qvtd/pivot/qvtimperative/evaluation/TypedModelAnalysis.java b/plugins/org.eclipse.qvtd.pivot.qvtimperative/src/org/eclipse/qvtd/pivot/qvtimperative/evaluation/TypedModelAnalysis.java
index 06c3c4f..ea715e7 100644
--- a/plugins/org.eclipse.qvtd.pivot.qvtimperative/src/org/eclipse/qvtd/pivot/qvtimperative/evaluation/TypedModelAnalysis.java
+++ b/plugins/org.eclipse.qvtd.pivot.qvtimperative/src/org/eclipse/qvtd/pivot/qvtimperative/evaluation/TypedModelAnalysis.java
@@ -28,9 +28,12 @@
 import org.eclipse.ocl.pivot.utilities.PivotUtil;
 import org.eclipse.qvtd.pivot.qvtbase.TypedModel;
 
+/**
+ * TypedModelAnalysis captures the class and property relationships of the use packges of a TypedModel.
+ */
 public class TypedModelAnalysis
 {
-	protected final @NonNull QVTiTransformationAnalysis transformationAnalysis;
+	protected final @NonNull EntryPointsAnalysis entryPointsAnalysis;
 	protected final @NonNull TypedModel typedModel;
 	protected final @NonNull Set<@NonNull CompleteClass> allInstancesCompleteClasses;
 	protected final @NonNull Map<@NonNull CompleteClass, @Nullable List<@NonNull CompleteClass>> instancesCompleteClassAnalysis;
@@ -39,11 +42,11 @@
 	protected final int extentClassIndex;
 	protected @Nullable List<@NonNull Integer> extentOppositePropertyIndexes = null;
 
-	public TypedModelAnalysis(@NonNull QVTiTransformationAnalysis transformationAnalysis, @NonNull TypedModel typedModel, @NonNull Set<@NonNull CompleteClass> allInstancesCompleteClasses) {
-		this.transformationAnalysis = transformationAnalysis;
+	public TypedModelAnalysis(@NonNull EntryPointsAnalysis entryPointsAnalysis, @NonNull TypedModel typedModel, @NonNull Set<@NonNull CompleteClass> allInstancesCompleteClasses) {
+		this.entryPointsAnalysis = entryPointsAnalysis;
 		this.typedModel = typedModel;
 		this.allInstancesCompleteClasses = allInstancesCompleteClasses;
-		this.instancesCompleteClassAnalysis = transformationAnalysis.getInstancesCompleteClassAnalysis(allInstancesCompleteClasses);
+		this.instancesCompleteClassAnalysis = entryPointsAnalysis.getInstancesCompleteClassAnalysis(allInstancesCompleteClasses);
 		//
 		// Populate a mapping from instancesClass to linear index.
 		//
@@ -62,7 +65,7 @@
 		}
 		this.extentClassIndex = extentClassIndex;
 		//
-		Map<@NonNull Property, @NonNull Integer> opposites = transformationAnalysis.getCaches();
+		Map<@NonNull Property, @NonNull Integer> opposites = entryPointsAnalysis.getCaches();
 		for (@NonNull Property property : opposites.keySet()) {
 			org.eclipse.ocl.pivot.Class owningClass = PivotUtil.getOwningClass(property);
 			TypeId typeId = owningClass.getTypeId();
@@ -90,7 +93,7 @@
 
 	public int @Nullable [] @NonNull [] getClassIndex2allClassIndexes() {
 		int iMax = sortedCompleteClasses.size();
-		int [] @NonNull [] classIndex2allClassIndexes = new int @Nullable [iMax] [];
+		int [] @NonNull [] classIndex2allClassIndexes = new int [iMax] @NonNull [];
 		for (int i = 0; i < iMax; i++) {
 			CompleteClass instancesClass = sortedCompleteClasses.get(i);
 			List<@NonNull CompleteClass> superInstancesClasses = ClassUtil.nonNullState(instancesCompleteClassAnalysis.get(instancesClass));
diff --git a/plugins/org.eclipse.qvtd.pivot.qvtimperative/src/org/eclipse/qvtd/pivot/qvtimperative/utilities/QVTimperativeUtil.java b/plugins/org.eclipse.qvtd.pivot.qvtimperative/src/org/eclipse/qvtd/pivot/qvtimperative/utilities/QVTimperativeUtil.java
index edbc44e..607c80b 100644
--- a/plugins/org.eclipse.qvtd.pivot.qvtimperative/src/org/eclipse/qvtd/pivot/qvtimperative/utilities/QVTimperativeUtil.java
+++ b/plugins/org.eclipse.qvtd.pivot.qvtimperative/src/org/eclipse/qvtd/pivot/qvtimperative/utilities/QVTimperativeUtil.java
@@ -139,6 +139,20 @@
 		return ClassUtil.nonNullState(basicGetContainingTransformation(eObject));
 	}
 
+	/**
+	 * Return the default (first) entry point of asTransformation.
+	 *
+	 * This method is close to deprecated being mainly intended for legacy / unidirectional usage.
+	 */
+	public static @NonNull EntryPoint getDefaultEntryPoint(@NonNull ImperativeTransformation asTransformation) {
+		for (@NonNull Mapping mapping : getOwnedMappings(asTransformation)) {
+			if (mapping instanceof EntryPoint) {
+				return (EntryPoint)mapping;
+			}
+		}
+		throw new IllegalStateException();
+	}
+
 	public static @NonNull Iterable<@NonNull TypedModel> getEnforcedTypedModels(@NonNull EntryPoint entryPoint) {
 		return ClassUtil.nullFree(entryPoint.getEnforcedTypedModels());
 	}
diff --git a/plugins/org.eclipse.qvtd.runtime/src/org/eclipse/qvtd/runtime/evaluation/AbstractTransformationExecutor.java b/plugins/org.eclipse.qvtd.runtime/src/org/eclipse/qvtd/runtime/evaluation/AbstractTransformationExecutor.java
index c5c71e4..1a497d2 100644
--- a/plugins/org.eclipse.qvtd.runtime/src/org/eclipse/qvtd/runtime/evaluation/AbstractTransformationExecutor.java
+++ b/plugins/org.eclipse.qvtd.runtime/src/org/eclipse/qvtd/runtime/evaluation/AbstractTransformationExecutor.java
@@ -14,6 +14,7 @@
 import java.util.Set;
 
 import org.eclipse.jdt.annotation.NonNull;
+import org.eclipse.jdt.annotation.Nullable;
 import org.eclipse.ocl.pivot.Property;
 import org.eclipse.ocl.pivot.evaluation.AbstractModelManager;
 import org.eclipse.ocl.pivot.evaluation.ModelManager;
@@ -61,9 +62,9 @@
 	}
 
 	@Override
-	public final Boolean execute() throws Exception {
+	public final Boolean execute(@Nullable Integer targetTypedModelIndex) throws Exception {
 		transformer.analyzeInputResources();
-		if (transformer.run()) {
+		if (targetTypedModelIndex != null ? transformer.run(targetTypedModelIndex) : transformer.run()) {
 			return Boolean.TRUE;
 		}
 		if (!suppressFailureDiagnosis) {						// FIXME BUG 511028
@@ -109,6 +110,11 @@
 	}
 
 	@Override
+	public int getTypedModelIndex(@NonNull String targetModelName) {
+		return transformer.getTypedModelIndex(targetModelName);
+	}
+
+	@Override
 	public @NonNull TypedModelInstance getTypedModelInstance(@NonNull String modelName) {
 		return transformer.getTypedModelInstance(modelName);
 	}
diff --git a/plugins/org.eclipse.qvtd.runtime/src/org/eclipse/qvtd/runtime/evaluation/TransformationExecutor.java b/plugins/org.eclipse.qvtd.runtime/src/org/eclipse/qvtd/runtime/evaluation/TransformationExecutor.java
index 5ded05a..ca03fe2 100644
--- a/plugins/org.eclipse.qvtd.runtime/src/org/eclipse/qvtd/runtime/evaluation/TransformationExecutor.java
+++ b/plugins/org.eclipse.qvtd.runtime/src/org/eclipse/qvtd/runtime/evaluation/TransformationExecutor.java
@@ -11,6 +11,7 @@
 package org.eclipse.qvtd.runtime.evaluation;
 
 import org.eclipse.jdt.annotation.NonNull;
+import org.eclipse.jdt.annotation.Nullable;
 import org.eclipse.ocl.pivot.evaluation.Executor;
 
 /**
@@ -22,9 +23,10 @@
 {
 	@Override
 	void dispose();
-	Boolean execute() throws Exception;
+	Boolean execute(@Nullable Integer targetTypedModelIndex) throws Exception;
 	@NonNull ModelsManager getModelsManager();
 	@NonNull Transformer getTransformer();
+	int getTypedModelIndex(@NonNull String targetModelName);
 	@NonNull TypedModelInstance getTypedModelInstance(@NonNull String modelName);
 	void setSuppressFailureDiagnosis(boolean suppressFailureDiagnosis);
 }
diff --git a/plugins/org.eclipse.qvtd.runtime/src/org/eclipse/qvtd/runtime/evaluation/Transformer.java b/plugins/org.eclipse.qvtd.runtime/src/org/eclipse/qvtd/runtime/evaluation/Transformer.java
index aeb9d96..1b57ce6 100644
--- a/plugins/org.eclipse.qvtd.runtime/src/org/eclipse/qvtd/runtime/evaluation/Transformer.java
+++ b/plugins/org.eclipse.qvtd.runtime/src/org/eclipse/qvtd/runtime/evaluation/Transformer.java
@@ -44,6 +44,8 @@
 	@NonNull InvocationManager getInvocationManager();
 	@NonNull ModelsManager getModelsManager();
 	@NonNull ObjectManager getObjectManager();
+	int getTypedModelIndex(@NonNull String targetModelName);
 	@NonNull TypedModelInstance getTypedModelInstance(@NonNull String modelName);
 	boolean run() throws Exception;
+	boolean run(int targetTypedModelIndex) throws Exception;
 }
diff --git a/plugins/org.eclipse.qvtd.runtime/src/org/eclipse/qvtd/runtime/internal/evaluation/AbstractTransformerInternal.java b/plugins/org.eclipse.qvtd.runtime/src/org/eclipse/qvtd/runtime/internal/evaluation/AbstractTransformerInternal.java
index 26769a4..60a349b 100644
--- a/plugins/org.eclipse.qvtd.runtime/src/org/eclipse/qvtd/runtime/internal/evaluation/AbstractTransformerInternal.java
+++ b/plugins/org.eclipse.qvtd.runtime/src/org/eclipse/qvtd/runtime/internal/evaluation/AbstractTransformerInternal.java
@@ -270,6 +270,11 @@
 	} */
 
 	@Override
+	public int getTypedModelIndex(@NonNull String targetModelName) {
+		return modelsManager.getTypedModelIndex(targetModelName);
+	}
+
+	@Override
 	public @NonNull TypedModelInstance getTypedModelInstance(@NonNull String modelName) {
 		return modelsManager.getTypedModelInstance(modelName);
 	}
@@ -377,8 +382,12 @@
 	} */
 
 	@Override
-	public boolean run()throws Exception {
-		// TODO Auto-generated method stub
+	public boolean run() throws Exception {
+		return false;
+	}
+
+	@Override
+	public boolean run(int targetTypedModelIndex) throws Exception {
 		return false;
 	}
 
diff --git a/plugins/org.eclipse.qvtd.runtime/src/org/eclipse/qvtd/runtime/internal/evaluation/RuntimeModelsManager.java b/plugins/org.eclipse.qvtd.runtime/src/org/eclipse/qvtd/runtime/internal/evaluation/RuntimeModelsManager.java
index 0ee0972..f27c634 100644
--- a/plugins/org.eclipse.qvtd.runtime/src/org/eclipse/qvtd/runtime/internal/evaluation/RuntimeModelsManager.java
+++ b/plugins/org.eclipse.qvtd.runtime/src/org/eclipse/qvtd/runtime/internal/evaluation/RuntimeModelsManager.java
@@ -98,6 +98,17 @@
 		throw new IllegalStateException("Unknown model name '" + modelName + "'");
 	}
 
+	public int getTypedModelIndex(@NonNull String targetModelName) {
+		int index = 0;
+		for (@NonNull Model model : models) {
+			if (targetModelName.equals(model.getName())) {
+				return index;
+			}
+			index++;
+		}
+		throw new IllegalStateException("Unknown model name '" + targetModelName + "'");
+	}
+
 	@Override
 	public @NonNull Iterable<@NonNull TypedModelInstance> getTypedModelInstances() {
 		return new ArrayIterable<@NonNull TypedModelInstance>(models);
diff --git a/plugins/org.eclipse.qvtd.umlx.ui/src/org/eclipse/qvtd/umlx/ui/launching/UMLXLaunchConfigurationDelegate.java b/plugins/org.eclipse.qvtd.umlx.ui/src/org/eclipse/qvtd/umlx/ui/launching/UMLXLaunchConfigurationDelegate.java
index 97e6764..bfaedd2 100644
--- a/plugins/org.eclipse.qvtd.umlx.ui/src/org/eclipse/qvtd/umlx/ui/launching/UMLXLaunchConfigurationDelegate.java
+++ b/plugins/org.eclipse.qvtd.umlx.ui/src/org/eclipse/qvtd/umlx/ui/launching/UMLXLaunchConfigurationDelegate.java
@@ -27,7 +27,7 @@
 import org.eclipse.qvtd.debug.launching.QVTcLaunchConstants;
 import org.eclipse.qvtd.debug.launching.QVTiLaunchConfigurationDelegate;
 import org.eclipse.qvtd.debug.launching.QVTrLaunchConfigurationDelegate;
-import org.eclipse.qvtd.pivot.qvtimperative.ImperativeTransformation;
+import org.eclipse.qvtd.pivot.qvtimperative.EntryPoint;
 import org.eclipse.qvtd.pivot.qvtimperative.evaluation.QVTiEnvironmentFactory;
 import org.eclipse.qvtd.pivot.qvtimperative.evaluation.QVTiExecutor;
 import org.eclipse.qvtd.pivot.qvtimperative.utilities.QVTimperative;
@@ -97,8 +97,8 @@
 	}
 
 	@Override
-	protected @NonNull QVTiExecutor createExecutor(@NonNull QVTiEnvironmentFactory envFactory, @NonNull ImperativeTransformation transformation) {
-		return new BasicQVTrExecutor(envFactory, transformation);
+	protected @NonNull QVTiExecutor createExecutor(@NonNull QVTiEnvironmentFactory envFactory, @NonNull EntryPoint entryPoint) {
+		return new BasicQVTrExecutor(envFactory, entryPoint);
 	}
 
 	@Override
diff --git a/tests/org.eclipse.qvtd.cs2as.compiler.tests/src/org/eclipse/qvtd/cs2as/compiler/tests/ExecutionBenchmarks.java b/tests/org.eclipse.qvtd.cs2as.compiler.tests/src/org/eclipse/qvtd/cs2as/compiler/tests/ExecutionBenchmarks.java
index a5a5a6e..4ab19fc 100644
--- a/tests/org.eclipse.qvtd.cs2as.compiler.tests/src/org/eclipse/qvtd/cs2as/compiler/tests/ExecutionBenchmarks.java
+++ b/tests/org.eclipse.qvtd.cs2as.compiler.tests/src/org/eclipse/qvtd/cs2as/compiler/tests/ExecutionBenchmarks.java
@@ -30,6 +30,7 @@
 import org.eclipse.ocl.pivot.utilities.OCL;
 import org.eclipse.ocl.xtext.completeocl.CompleteOCLStandaloneSetup;
 import org.eclipse.qvtd.compiler.DefaultCompilerOptions;
+import org.eclipse.qvtd.pivot.qvtimperative.EntryPoint;
 import org.eclipse.qvtd.pivot.qvtimperative.ImperativeModel;
 import org.eclipse.qvtd.pivot.qvtimperative.ImperativeTransformation;
 import org.eclipse.qvtd.pivot.qvtimperative.evaluation.BasicQVTiExecutor;
@@ -37,6 +38,7 @@
 import org.eclipse.qvtd.pivot.qvtimperative.evaluation.QVTiIncrementalExecutor;
 import org.eclipse.qvtd.pivot.qvtimperative.evaluation.QVTiTransformationExecutor;
 import org.eclipse.qvtd.pivot.qvtimperative.utilities.QVTimperative;
+import org.eclipse.qvtd.pivot.qvtimperative.utilities.QVTimperativeUtil;
 import org.eclipse.qvtd.runtime.evaluation.ModeFactory;
 import org.eclipse.qvtd.runtime.evaluation.ModelsManager;
 import org.eclipse.qvtd.runtime.evaluation.TransformationExecutor;
@@ -63,8 +65,8 @@
 			super(environmentFactory);
 		}
 
-		public @NonNull BasicQVTiExecutor createEvaluator(@NonNull ImperativeTransformation transformation) {
-			return new QVTiIncrementalExecutor(getEnvironmentFactory(), transformation, ModeFactory.LAZY);
+		public @NonNull BasicQVTiExecutor createEvaluator(@NonNull EntryPoint entryPoint) {
+			return new QVTiIncrementalExecutor(getEnvironmentFactory(), entryPoint, ModeFactory.LAZY);
 		}
 
 		public @NonNull TransformationExecutor createEvaluator(@NonNull Class<? extends Transformer> txClass) throws ReflectiveOperationException {
@@ -110,13 +112,14 @@
 
 			ImperativeTransformation qvtiTransf = getTransformation(myQVT.getMetamodelManager().getASResourceSet(), txURI);
 			assert qvtiTransf != null;
-			trackExample_Interpreted(myQVT, qvtiTransf, baseURI, "model1", results);
-			trackExample_Interpreted(myQVT, qvtiTransf, baseURI, "model2", results);
-			trackExample_Interpreted(myQVT, qvtiTransf, baseURI, "model3", results);
-			trackExample_Interpreted(myQVT, qvtiTransf, baseURI, "model4", results);
-			trackExample_Interpreted(myQVT, qvtiTransf, baseURI, "model5", results);
-			trackExample_Interpreted(myQVT, qvtiTransf, baseURI, "model6", results);
-			trackExample_Interpreted(myQVT, qvtiTransf, baseURI, "model7", results);
+			EntryPoint entryPoint = QVTimperativeUtil.getDefaultEntryPoint(qvtiTransf);
+			trackExample_Interpreted(myQVT, entryPoint, baseURI, "model1", results);
+			trackExample_Interpreted(myQVT, entryPoint, baseURI, "model2", results);
+			trackExample_Interpreted(myQVT, entryPoint, baseURI, "model3", results);
+			trackExample_Interpreted(myQVT, entryPoint, baseURI, "model4", results);
+			trackExample_Interpreted(myQVT, entryPoint, baseURI, "model5", results);
+			trackExample_Interpreted(myQVT, entryPoint, baseURI, "model6", results);
+			trackExample_Interpreted(myQVT, entryPoint, baseURI, "model7", results);
 			myQVT.dispose();
 
 		}
@@ -192,10 +195,10 @@
 		System.out.println("Iteration on " +modelName+": " + (finalStamp - initStamp) + " ms");
 	}
 
-	private void trackExample_Interpreted(MyQVT qvt, @NonNull ImperativeTransformation tx, URI baseURI, String modelName,
+	private void trackExample_Interpreted(MyQVT qvt, @NonNull EntryPoint entryPoint, URI baseURI, String modelName,
 			Map<String, List<Integer>> results)  throws Exception  {
 		long initStamp = System.currentTimeMillis();
-		executeModelsTX_Interpreted(qvt, tx, baseURI, modelName);
+		executeModelsTX_Interpreted(qvt, entryPoint, baseURI, modelName);
 		long finalStamp = System.currentTimeMillis();
 		trackResults(results, modelName, initStamp, finalStamp);
 		System.out.println("Iteration on " +modelName+": " + (finalStamp - initStamp) + " ms");
@@ -268,12 +271,12 @@
 	// Execute the transformation with the CGed transformation
 	//
 
-	protected void executeModelsTX_Interpreted(MyQVT qvt, @NonNull ImperativeTransformation tx, URI baseURI, String modelName) throws Exception {
+	protected void executeModelsTX_Interpreted(MyQVT qvt, @NonNull EntryPoint entryPoint, URI baseURI, String modelName) throws Exception {
 		URI samplesBaseUri = baseURI.appendSegment("samples");
 		URI csModelURI = samplesBaseUri.appendSegment(String.format("%s_input.xmi", modelName));
 		URI asModelURI = samplesBaseUri.appendSegment(String.format("%s_output_Interpreted.xmi", modelName));
 
-		BasicQVTiExecutor testEvaluator = qvt.createEvaluator(tx);
+		BasicQVTiExecutor testEvaluator = qvt.createEvaluator(entryPoint);
 		testEvaluator.saveTransformation(null, null);
 		ModelsManager modelsManager = testEvaluator.getModelsManager();
 		TypedModelInstance inputTypedModelInstance = modelsManager.getTypedModelInstance("leftCS");
@@ -281,7 +284,7 @@
 		ResourceSet rSet = qvt.getResourceSet();
 		Resource inputResource = ClassUtil.nonNullState(rSet.getResource(csModelURI, true));
 		inputTypedModelInstance.addInputResource(inputResource);
-		boolean success = testEvaluator.execute();
+		boolean success = testEvaluator.execute(null);
 		Resource outputResource = ClassUtil.nonNullState(rSet.createResource(asModelURI));
 		outputTypedModelInstance.addOutputResource(outputResource);
 		modelsManager.saveModels(DefaultCompilerOptions.defaultSavingOptions);
diff --git a/tests/org.eclipse.qvtd.cs2as.compiler.tests/src/org/eclipse/qvtd/cs2as/compiler/tests/OCL2QVTiTestCases.java b/tests/org.eclipse.qvtd.cs2as.compiler.tests/src/org/eclipse/qvtd/cs2as/compiler/tests/OCL2QVTiTestCases.java
index 325b165..bf41840 100644
--- a/tests/org.eclipse.qvtd.cs2as.compiler.tests/src/org/eclipse/qvtd/cs2as/compiler/tests/OCL2QVTiTestCases.java
+++ b/tests/org.eclipse.qvtd.cs2as.compiler.tests/src/org/eclipse/qvtd/cs2as/compiler/tests/OCL2QVTiTestCases.java
@@ -47,9 +47,11 @@
 import org.eclipse.qvtd.cs2as.compiler.internal.OCL2QVTm;
 import org.eclipse.qvtd.pivot.qvtbase.Transformation;
 import org.eclipse.qvtd.pivot.qvtbase.utilities.QVTbase;
+import org.eclipse.qvtd.pivot.qvtimperative.EntryPoint;
 import org.eclipse.qvtd.pivot.qvtimperative.ImperativeModel;
 import org.eclipse.qvtd.pivot.qvtimperative.ImperativeTransformation;
 import org.eclipse.qvtd.pivot.qvtimperative.utilities.QVTimperative;
+import org.eclipse.qvtd.pivot.qvtimperative.utilities.QVTimperativeUtil;
 import org.eclipse.qvtd.pivot.qvtschedule.impl.RuleRegionImpl;
 import org.eclipse.qvtd.runtime.evaluation.Transformer;
 import org.eclipse.qvtd.xtext.qvtbase.tests.AbstractTestQVT;
@@ -133,7 +135,8 @@
 			String inputURIstring = modelTestName + "/" + modelSamples + "/" + modelName + "_input.xmi";
 			String outURIstring = modelName + "_output_Interpreted.xmi";
 			String refURIstring = modelTestName + "/" + modelSamples + "/" + modelName + "_output_ref.xmi";
-			createInterpretedExecutor(tx);
+			EntryPoint iEntryPoint = QVTimperativeUtil.getDefaultEntryPoint(tx);
+			createInterpretedExecutor(iEntryPoint);
 			addInputURI(OCL2QVTm.LEFT_MODEL_TYPE_NAME, getModelsURI(inputURIstring));
 			assertTrue(executeTransformation());
 			addOutputURI(OCL2QVTm.RIGHT_MODEL_TYPE_NAME, getTestURI(outURIstring));
diff --git a/tests/org.eclipse.qvtd.doc.bigmde2016.tests/src/org/eclipse/qvtd/doc/bigmde2016/tests/BigMDE2016InterpreterTests.java b/tests/org.eclipse.qvtd.doc.bigmde2016.tests/src/org/eclipse/qvtd/doc/bigmde2016/tests/BigMDE2016InterpreterTests.java
index 72e2bdf..0330c76 100644
--- a/tests/org.eclipse.qvtd.doc.bigmde2016.tests/src/org/eclipse/qvtd/doc/bigmde2016/tests/BigMDE2016InterpreterTests.java
+++ b/tests/org.eclipse.qvtd.doc.bigmde2016.tests/src/org/eclipse/qvtd/doc/bigmde2016/tests/BigMDE2016InterpreterTests.java
@@ -12,8 +12,10 @@
 
 import org.eclipse.emf.ecore.resource.Resource;
 import org.eclipse.qvtd.doc.bigmde2016.tests.qvtc.BigMDE2016CGTests;
+import org.eclipse.qvtd.pivot.qvtimperative.EntryPoint;
 import org.eclipse.qvtd.pivot.qvtimperative.ImperativeTransformation;
 import org.eclipse.qvtd.pivot.qvtimperative.evaluation.BasicQVTiExecutor;
+import org.eclipse.qvtd.pivot.qvtimperative.utilities.QVTimperativeUtil;
 import org.eclipse.qvtd.xtext.qvtcore.tests.QVTcCompilerTests;
 import org.junit.Test;
 
@@ -31,10 +33,11 @@
 		MyQVT myQVT = createQVT("Families2Persons", getModelsURI("families2persons/Families2Persons.qvtc"));
 		//    	myQVT.getEnvironmentFactory().setEvaluationTracingEnabled(true);
 		try {
-			ImperativeTransformation asTransformation = myQVT.compileTransformation("person");
+			ImperativeTransformation iTransformation = myQVT.compileTransformation("person");
+			EntryPoint iEntryPoint = QVTimperativeUtil.getDefaultEntryPoint(iTransformation);
 			int[] tests = PrintAndLog.getTestSizes();
 			for (int testSize : tests) {
-				BasicQVTiExecutor interpretedExecutor = myQVT.createInterpretedExecutor(asTransformation);
+				BasicQVTiExecutor interpretedExecutor = myQVT.createInterpretedExecutor(iEntryPoint);
 				myQVT.addInputURI("family", getModelsURI("families2persons/samples/Families.xmi"));
 				Resource inResource = interpretedExecutor.getModel("family");
 				inResource.getContents().clear();
diff --git a/tests/org.eclipse.qvtd.doc.exe2016.tests/src/org/eclipse/qvtd/doc/exe2016/tests/qvtc/EXE2016InterpreterTests.java b/tests/org.eclipse.qvtd.doc.exe2016.tests/src/org/eclipse/qvtd/doc/exe2016/tests/qvtc/EXE2016InterpreterTests.java
index 0c8c0cf..928d207 100644
--- a/tests/org.eclipse.qvtd.doc.exe2016.tests/src/org/eclipse/qvtd/doc/exe2016/tests/qvtc/EXE2016InterpreterTests.java
+++ b/tests/org.eclipse.qvtd.doc.exe2016.tests/src/org/eclipse/qvtd/doc/exe2016/tests/qvtc/EXE2016InterpreterTests.java
@@ -20,8 +20,10 @@
 import org.eclipse.qvtd.doc.exe2016.tests.qvtc.doublylinkedlist.DoublyLinkedList;
 import org.eclipse.qvtd.doc.exe2016.tests.qvtc.doublylinkedlist.DoublylinkedlistPackage;
 import org.eclipse.qvtd.doc.exe2016.tests.qvtc.list2list.List2listPackage;
+import org.eclipse.qvtd.pivot.qvtimperative.EntryPoint;
 import org.eclipse.qvtd.pivot.qvtimperative.ImperativeTransformation;
 import org.eclipse.qvtd.pivot.qvtimperative.evaluation.BasicQVTiExecutor;
+import org.eclipse.qvtd.pivot.qvtimperative.utilities.QVTimperativeUtil;
 import org.eclipse.qvtd.xtext.qvtcore.tests.QVTcCompilerTests;
 import org.junit.Test;
 
@@ -43,10 +45,11 @@
 		myQVT.loadEcoreFile(getModelsURI("forward2reverse/List2List.ecore"), List2listPackage.eINSTANCE);
 		//    	myQVT.getEnvironmentFactory().setEvaluationTracingEnabled(true);
 		try {
-			ImperativeTransformation asTransformation = myQVT.compileTransformation("reverse");
+			ImperativeTransformation iTransformation = myQVT.compileTransformation("reverse");
+			EntryPoint iEntryPoint = QVTimperativeUtil.getDefaultEntryPoint(iTransformation);
 			int[] tests = /**new int[]{100000}; //*/PrintAndLog.getTestSizes();
 			for (int testSize : tests) {
-				@SuppressWarnings("unused")BasicQVTiExecutor interpretedExecutor = myQVT.createInterpretedExecutor(asTransformation);
+				@SuppressWarnings("unused")BasicQVTiExecutor interpretedExecutor = myQVT.createInterpretedExecutor(iEntryPoint);
 				Resource inResource = myQVT.addInputURI("forward", getModelsURI("families2persons/samples/EmptyList.xmi"));
 				assert inResource != null;
 				inResource.getContents().clear();
@@ -87,9 +90,10 @@
 		myQVT.loadEcoreFile(getModelsURI("forward2reverse/List2List.ecore"), List2listPackage.eINSTANCE);
 		//		myQVT.getEnvironmentFactory().setEvaluationTracingEnabled(true);
 		try {
-			ImperativeTransformation asTransformation = myQVT.compileTransformation("reverse");
+			ImperativeTransformation iTransformation = myQVT.compileTransformation("reverse");
+			EntryPoint iEntryPoint = QVTimperativeUtil.getDefaultEntryPoint(iTransformation);
 			int testSize = 100000;
-			BasicQVTiExecutor interpretedExecutor = myQVT.createInterpretedExecutor(asTransformation);
+			BasicQVTiExecutor interpretedExecutor = myQVT.createInterpretedExecutor(iEntryPoint);
 			myQVT.addInputURI("forward", getModelsURI("families2persons/samples/EmptyList.xmi"));
 			Resource inResource = interpretedExecutor.getModel("forward");
 			assert inResource != null;
diff --git a/tests/org.eclipse.qvtd.xtext.qvtbase.tests/src/org/eclipse/qvtd/xtext/qvtbase/tests/AbstractTestQVT.java b/tests/org.eclipse.qvtd.xtext.qvtbase.tests/src/org/eclipse/qvtd/xtext/qvtbase/tests/AbstractTestQVT.java
index 1c03606..e80f2ae 100644
--- a/tests/org.eclipse.qvtd.xtext.qvtbase.tests/src/org/eclipse/qvtd/xtext/qvtbase/tests/AbstractTestQVT.java
+++ b/tests/org.eclipse.qvtd.xtext.qvtbase.tests/src/org/eclipse/qvtd/xtext/qvtbase/tests/AbstractTestQVT.java
@@ -60,6 +60,7 @@
 import org.eclipse.qvtd.compiler.internal.qvts2qvts.partitioner.RootPartitionAnalysis;
 import org.eclipse.qvtd.pivot.qvtbase.Transformation;
 import org.eclipse.qvtd.pivot.qvtbase.utilities.QVTbase;
+import org.eclipse.qvtd.pivot.qvtimperative.EntryPoint;
 import org.eclipse.qvtd.pivot.qvtimperative.ImperativeTransformation;
 import org.eclipse.qvtd.pivot.qvtimperative.evaluation.BasicQVTiExecutor;
 import org.eclipse.qvtd.pivot.qvtimperative.evaluation.Execution2GraphVisitor;
@@ -384,14 +385,14 @@
 		return new QVTiTransformationExecutor(environmentFactory, txClass);
 	}
 
-	public @NonNull BasicQVTiExecutor createInterpretedExecutor(@NonNull ImperativeTransformation asTransformation) throws Exception {
-		BasicQVTiExecutor interpretedExecutor = createInterpretedExecutor(getEnvironmentFactory(), asTransformation);
+	public @NonNull BasicQVTiExecutor createInterpretedExecutor(@NonNull EntryPoint entryPoint) throws Exception {
+		BasicQVTiExecutor interpretedExecutor = createInterpretedExecutor(getEnvironmentFactory(), entryPoint);
 		this.executor = interpretedExecutor;
 		return interpretedExecutor;
 	}
 
-	protected @NonNull BasicQVTiExecutor createInterpretedExecutor(@NonNull QVTiEnvironmentFactory environmentFactory, @NonNull ImperativeTransformation asTransformation) throws Exception {
-		return new QVTiIncrementalExecutor(environmentFactory, asTransformation, ModeFactory.LAZY);
+	protected @NonNull BasicQVTiExecutor createInterpretedExecutor(@NonNull QVTiEnvironmentFactory environmentFactory, @NonNull EntryPoint entryPoint) throws Exception {
+		return new QVTiIncrementalExecutor(environmentFactory, entryPoint, ModeFactory.LAZY);
 	}
 
 	@Override
@@ -495,7 +496,15 @@
 		if (suppressFailureDiagnosis) {
 			executor.setSuppressFailureDiagnosis(true);
 		}
-		Boolean success = executor.execute();
+		Boolean success = executor.execute(null);
+		return success == Boolean.TRUE;
+	}
+
+	public boolean executeTransformation(@NonNull String targetModelName) throws Exception {
+		if (suppressFailureDiagnosis) {
+			executor.setSuppressFailureDiagnosis(true);
+		}
+		Boolean success = executor.execute(executor.getTypedModelIndex(targetModelName));
 		return success == Boolean.TRUE;
 	}
 
diff --git a/tests/org.eclipse.qvtd.xtext.qvtcore.tests/src/org/eclipse/qvtd/xtext/qvtcore/tests/QVTcCompilerTests.java b/tests/org.eclipse.qvtd.xtext.qvtcore.tests/src/org/eclipse/qvtd/xtext/qvtcore/tests/QVTcCompilerTests.java
index 3a7cea5..7fe1933 100644
--- a/tests/org.eclipse.qvtd.xtext.qvtcore.tests/src/org/eclipse/qvtd/xtext/qvtcore/tests/QVTcCompilerTests.java
+++ b/tests/org.eclipse.qvtd.xtext.qvtcore.tests/src/org/eclipse/qvtd/xtext/qvtcore/tests/QVTcCompilerTests.java
@@ -34,8 +34,10 @@
 import org.eclipse.qvtd.compiler.internal.qvtm2qvts.QVTm2QVTs;
 import org.eclipse.qvtd.compiler.internal.qvts2qvts.splitter.Splitter;
 import org.eclipse.qvtd.pivot.qvtcore.utilities.QVTcore;
+import org.eclipse.qvtd.pivot.qvtimperative.EntryPoint;
 import org.eclipse.qvtd.pivot.qvtimperative.ImperativeTransformation;
 import org.eclipse.qvtd.pivot.qvtimperative.evaluation.QVTiEnvironmentFactory;
+import org.eclipse.qvtd.pivot.qvtimperative.utilities.QVTimperativeUtil;
 import org.eclipse.qvtd.pivot.qvtschedule.impl.RuleRegionImpl;
 import org.eclipse.qvtd.runtime.evaluation.Transformer;
 import org.eclipse.qvtd.xtext.qvtbase.tests.AbstractTestQVT;
@@ -173,8 +175,9 @@
 		myQVT.loadEcoreFile(getModelsURI("families2persons/Persons.ecore"), PersonsPackage.eINSTANCE);
 		//    	myQVT.getEnvironmentFactory().setEvaluationTracingEnabled(true);
 		try {
-			ImperativeTransformation asTransformation = myQVT.compileTransformation("person");
-			myQVT.createInterpretedExecutor(asTransformation);
+			ImperativeTransformation iTransformation = myQVT.compileTransformation("person");
+			EntryPoint iEntryPoint = QVTimperativeUtil.getDefaultEntryPoint(iTransformation);
+			myQVT.createInterpretedExecutor(iEntryPoint);
 			myQVT.addInputURI("family", getModelsURI("families2persons/samples/Families.xmi"));
 			myQVT.executeTransformation();
 			myQVT.addOutputURI("person", getTestURI("Persons_Interpreted.xmi"));
@@ -239,30 +242,31 @@
 		myQVT.loadEcoreFile(getModelsURI("forward2reverse/List2List.ecore"), List2listPackage.eINSTANCE);
 		//		myQVT.getEnvironmentFactory().setEvaluationTracingEnabled(true);
 		try {
-			ImperativeTransformation asTransformation = myQVT.compileTransformation("reverse");
+			ImperativeTransformation iTransformation = myQVT.compileTransformation("reverse");
+			EntryPoint iEntryPoint = QVTimperativeUtil.getDefaultEntryPoint(iTransformation);
 			//
-			myQVT.createInterpretedExecutor(asTransformation);
+			myQVT.createInterpretedExecutor(iEntryPoint);
 			myQVT.addInputURI("forward", getModelsURI("forward2reverse/samples/EmptyList.xmi"));
 			myQVT.executeTransformation();
 			myQVT.addOutputURI("reverse", getTestURI("EmptyList_Interpreted.xmi"));
 			myQVT.saveModels(null);
 			myQVT.checkOutput(getTestURI("EmptyList_Interpreted.xmi"), getModelsURI("forward2reverse/samples/EmptyList_expected.xmi"), Forward2ReverseNormalizer.INSTANCE);
 			//
-			myQVT.createInterpretedExecutor(asTransformation);
+			myQVT.createInterpretedExecutor(iEntryPoint);
 			myQVT.addInputURI("forward", getModelsURI("forward2reverse/samples/OneElementList.xmi"));
 			myQVT.executeTransformation();
 			myQVT.addOutputURI("reverse", getTestURI("OneElementList_Interpreted.xmi"));
 			myQVT.saveModels(null);
 			myQVT.checkOutput(getTestURI("OneElementList_Interpreted.xmi"), getModelsURI("forward2reverse/samples/OneElementList_expected.xmi"), Forward2ReverseNormalizer.INSTANCE);
 			//
-			myQVT.createInterpretedExecutor(asTransformation);
+			myQVT.createInterpretedExecutor(iEntryPoint);
 			myQVT.addInputURI("forward", getModelsURI("forward2reverse/samples/TwoElementList.xmi"));
 			myQVT.executeTransformation();
 			myQVT.addOutputURI("reverse", getTestURI("TwoElementList_Interpreted.xmi"));
 			myQVT.saveModels(null);
 			myQVT.checkOutput(getTestURI("TwoElementList_Interpreted.xmi"), getModelsURI("forward2reverse/samples/TwoElementList_expected.xmi"), Forward2ReverseNormalizer.INSTANCE);
 			//
-			myQVT.createInterpretedExecutor(asTransformation);
+			myQVT.createInterpretedExecutor(iEntryPoint);
 			myQVT.addInputURI("forward", getModelsURI("forward2reverse/samples/ThreeElementList.xmi"));
 			myQVT.executeTransformation();
 			myQVT.addOutputURI("reverse", getTestURI("ThreeElementList_Interpreted.xmi"));
@@ -346,8 +350,9 @@
 		myQVT.loadEcoreFile(getModelsURI("hsv2hsl/HSLTree.ecore"), HSLTreePackage.eINSTANCE);
 		//		myQVT.getEnvironmentFactory().setEvaluationTracingEnabled(true);
 		try {
-			ImperativeTransformation asTransformation = myQVT.compileTransformation("hsl");
-			myQVT.createInterpretedExecutor(asTransformation);
+			ImperativeTransformation iTransformation = myQVT.compileTransformation("hsl");
+			EntryPoint iEntryPoint = QVTimperativeUtil.getDefaultEntryPoint(iTransformation);
+			myQVT.createInterpretedExecutor(iEntryPoint);
 			myQVT.addInputURI("hsv", getModelsURI("hsv2hsl/samples/SolarizedHSV.xmi"));
 			myQVT.executeTransformation();
 			myQVT.addOutputURI("hsl", getTestURI("SolarizedHSL_Interpreted.xmi"));
@@ -401,22 +406,23 @@
 		myQVT.loadEcoreFile(getModelsURI("uml2rdbms/SimpleRDBMS.ecore"), SimplerdbmsPackage.eINSTANCE);
 		//    	myQVT.getEnvironmentFactory().setEvaluationTracingEnabled(true);
 		try {
-			ImperativeTransformation asTransformation = myQVT.compileTransformation("rdbms");
-			myQVT.createInterpretedExecutor(asTransformation);
+			ImperativeTransformation iTransformation = myQVT.compileTransformation("rdbms");
+			EntryPoint iEntryPoint = QVTimperativeUtil.getDefaultEntryPoint(iTransformation);
+			myQVT.createInterpretedExecutor(iEntryPoint);
 			myQVT.addInputURI("uml", getModelsURI("uml2rdbms/samples/SimplerUMLPeople.xmi"));
 			myQVT.executeTransformation();
 			myQVT.addOutputURI("rdbms", getTestURI("SimplerRDBMSPeople_Interpreted.xmi"));
 			myQVT.saveModels(null);
 			myQVT.checkOutput(getTestURI("SimplerRDBMSPeople_Interpreted.xmi"), getModelsURI("uml2rdbms/samples/SimplerRDBMSPeople_expected.xmi"), SimpleRDBMSNormalizer.INSTANCE);
 			//
-			myQVT.createInterpretedExecutor(asTransformation);
+			myQVT.createInterpretedExecutor(iEntryPoint);
 			myQVT.addInputURI("uml", getModelsURI("uml2rdbms/samples/SimplerUMLPeople2.xmi"));
 			myQVT.executeTransformation();
 			myQVT.addOutputURI("rdbms", getTestURI("SimplerRDBMSPeople2_Interpreted.xmi"));
 			myQVT.saveModels(null);
 			myQVT.checkOutput(getTestURI("SimplerRDBMSPeople2_Interpreted.xmi"), getModelsURI("uml2rdbms/samples/SimplerRDBMSPeople2_expected.xmi"), SimpleRDBMSNormalizer.INSTANCE);
 			//
-			myQVT.createInterpretedExecutor(asTransformation);
+			myQVT.createInterpretedExecutor(iEntryPoint);
 			myQVT.addInputURI("uml", getModelsURI("uml2rdbms/samples/SimpleUMLPeople.xmi"));
 			myQVT.executeTransformation();
 			myQVT.addOutputURI("rdbms", getTestURI("SimpleRDBMSPeople_Interpreted.xmi"));
@@ -560,8 +566,9 @@
 		MyQVT myQVT = createQVT("Upper2Lower", getModelsURI("upper2lower/Upper2Lower.qvtcas"));
 		//    	myQVT.getEnvironmentFactory().setEvaluationTracingEnabled(true);
 		try {
-			ImperativeTransformation asTransformation = myQVT.compileTransformation("lowerGraph");
-			myQVT.createInterpretedExecutor(asTransformation);
+			ImperativeTransformation iTransformation = myQVT.compileTransformation("lowerGraph");
+			EntryPoint iEntryPoint = QVTimperativeUtil.getDefaultEntryPoint(iTransformation);
+			myQVT.createInterpretedExecutor(iEntryPoint);
 			myQVT.addInputURI("upperGraph", getModelsURI("upper2lower/samples/SimpleGraph.xmi"));
 			myQVT.executeTransformation();
 			myQVT.addOutputURI("lowerGraph", getTestURI("SimpleGraphLower_Interpreted.xmi"));
diff --git a/tests/org.eclipse.qvtd.xtext.qvtimperative.tests/models/ClassesCS2AS/ClassesCS2AS.qvti b/tests/org.eclipse.qvtd.xtext.qvtimperative.tests/models/ClassesCS2AS/ClassesCS2AS.qvti
index 6b05231..0578ae4 100644
--- a/tests/org.eclipse.qvtd.xtext.qvtimperative.tests/models/ClassesCS2AS/ClassesCS2AS.qvti
+++ b/tests/org.eclipse.qvtd.xtext.qvtimperative.tests/models/ClassesCS2AS/ClassesCS2AS.qvti
@@ -4,8 +4,8 @@
 
 transformation classescs2as
 {
-	check leftCS imports classescs;
-	enforce rightAS imports classes;
+	leftCS imports classescs;
+	rightAS imports classes;
 	middle imports classescstraces;
 }
 
@@ -85,7 +85,7 @@
 	set	_'package'.ownedClasses := ownedClasses;
 }
 
-map __root__ in classescs2as
+entry __root__ check leftCS enforce rightAS in classescs2as
 {
 	for packageCS : classescs::PackageCS in classescs::PackageCS.allInstances() {
 		call mPackageCS2Package_LM {
diff --git a/tests/org.eclipse.qvtd.xtext.qvtimperative.tests/models/ClassesCS2AS/bug456900/ClassesCS2AS.qvti b/tests/org.eclipse.qvtd.xtext.qvtimperative.tests/models/ClassesCS2AS/bug456900/ClassesCS2AS.qvti
index 30da960..9ef025f 100644
--- a/tests/org.eclipse.qvtd.xtext.qvtimperative.tests/models/ClassesCS2AS/bug456900/ClassesCS2AS.qvti
+++ b/tests/org.eclipse.qvtd.xtext.qvtimperative.tests/models/ClassesCS2AS/bug456900/ClassesCS2AS.qvti
@@ -3,8 +3,8 @@
 
 transformation classescs2as
 {
-	check leftCS imports classescs;
-	enforce rightAS imports classes;
+	leftCS imports classescs;
+	rightAS imports classes;
 }
 
 map mCreationRootCS2Root in classescs2as
@@ -36,7 +36,8 @@
 	set z1.ownedPackages :=
 		rootCS.ownedPackages.ast.oclAsType(classes::Package)->asOrderedSet();
 }
-map __root__ in classescs2as
+
+entry __root__ check leftCS enforce rightAS in classescs2as
 {
 	for rootCS : classescs::RootCS in classescs::RootCS.allInstances() {
 		call mCreationRootCS2Root {
diff --git a/tests/org.eclipse.qvtd.xtext.qvtimperative.tests/models/ClassesCS2AS/bug457239/ClassesCS2AS.qvti b/tests/org.eclipse.qvtd.xtext.qvtimperative.tests/models/ClassesCS2AS/bug457239/ClassesCS2AS.qvti
index 12b6895..04e590f 100644
--- a/tests/org.eclipse.qvtd.xtext.qvtimperative.tests/models/ClassesCS2AS/bug457239/ClassesCS2AS.qvti
+++ b/tests/org.eclipse.qvtd.xtext.qvtimperative.tests/models/ClassesCS2AS/bug457239/ClassesCS2AS.qvti
@@ -4,8 +4,8 @@
 
 transformation classescs2as
 {
-	check leftCS imports classescs;
-	enforce rightAS imports classes;
+	leftCS imports classescs;
+	rightAS imports classes;
 }
 
 map createPackage in classescs2as
@@ -18,7 +18,7 @@
 						endif;
 }
 
-map __root__ in classescs2as
+entry __root__ check leftCS enforce rightAS in classescs2as
 {
 	for packageCS : classescs::PackageCS in classescs::PackageCS.allInstances() {
 		call createPackage {
diff --git a/tests/org.eclipse.qvtd.xtext.qvtimperative.tests/models/ClassesCS2AS/bug457239/ClassesCS2ASv2.qvti b/tests/org.eclipse.qvtd.xtext.qvtimperative.tests/models/ClassesCS2AS/bug457239/ClassesCS2ASv2.qvti
index 9ac842e..f70324c 100644
--- a/tests/org.eclipse.qvtd.xtext.qvtimperative.tests/models/ClassesCS2AS/bug457239/ClassesCS2ASv2.qvti
+++ b/tests/org.eclipse.qvtd.xtext.qvtimperative.tests/models/ClassesCS2AS/bug457239/ClassesCS2ASv2.qvti
@@ -4,8 +4,8 @@
 
 transformation classescs2as
 {
-	check leftCS imports classescs;
-	enforce rightAS imports classes;
+	leftCS imports classescs;
+	rightAS imports classes;
 }
 
 map createPackage in classescs2as
@@ -19,7 +19,7 @@
 						endif;
 }
 
-map __root__ in classescs2as
+entry __root__ check leftCS enforce rightAS in classescs2as
 {
 	for packageCS : classescs::PackageCS in classescs::PackageCS.allInstances() {
 		call createPackage {
diff --git a/tests/org.eclipse.qvtd.xtext.qvtimperative.tests/models/ClassesCS2AS/bug457239/ClassesCS2ASv2_AS.qvtias b/tests/org.eclipse.qvtd.xtext.qvtimperative.tests/models/ClassesCS2AS/bug457239/ClassesCS2ASv2_AS.qvtias
index e04bd8c..fb8f47d 100644
--- a/tests/org.eclipse.qvtd.xtext.qvtimperative.tests/models/ClassesCS2AS/bug457239/ClassesCS2ASv2_AS.qvtias
+++ b/tests/org.eclipse.qvtd.xtext.qvtimperative.tests/models/ClassesCS2AS/bug457239/ClassesCS2ASv2_AS.qvtias
@@ -1,69 +1,67 @@
 <?xml version="1.0" encoding="UTF-8"?>
 <qvti:ImperativeModel xmi:version="2.0" xmlns:xmi="http://www.omg.org/XMI" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xmlns:pivot="http://www.eclipse.org/ocl/2015/Pivot"
     xmlns:qvti="http://www.eclipse.org/qvt/2016/QVTimperative" xsi:schemaLocation="http://www.eclipse.org/ocl/2015/Pivot java://org.eclipse.ocl.pivot.PivotPackage http://www.eclipse.org/qvt/2016/QVTimperative java://org.eclipse.qvtd.pivot.qvtimperative.QVTimperativePackage"
-    name="ClassesCS2ASv2.qvti" externalURI="platform:/resource/org.eclipse.qvtd.xtext.qvtimperative.tests/bin/org/eclipse/qvtd/xtext/qvtimperative/tests/ClassesCS2AS/bug457239/ClassesCS2ASv2.qvti">
-  <ownedImports name="classes" importedNamespace="pivot:Model ../Classes.ecore.oclas#/"/>
-  <ownedImports name="classescs" importedNamespace="pivot:Model ../ClassesCS.ecore.oclas#/"/>
-  <ownedImports importedNamespace="pivot:Model helpers.ocl.oclas#/"/>
-  <ownedPackages xmi:id="P." name="">
-    <ownedClasses xsi:type="qvti:ImperativeTransformation" xmi:id="T..classescs2as" name="classescs2as" superClasses="http://www.eclipse.org/ocl/2015/Library.oclas#T.ocl.OclElement">
-      <modelParameter xsi:type="qvti:ImperativeTypedModel" xmi:id="qT..classescs2as.leftCS" name="leftCS" usedPackage="helpers.ocl.oclas#P.classescs"
-          isChecked="true">
-        <ownedContext xsi:type="pivot:ParameterVariable" xmi:id="qV..classescs2as.leftCS.leftCS" name="leftCS" type="pivot:Class http://www.eclipse.org/qvt/2016/QVTimperativeLibrary.oclas#T.qvtruntimelibrary.Model"/>
+    xmi:id="AAAAA" name="ClassesCS2ASv2.qvti" externalURI="platform:/resource/org.eclipse.qvtd.xtext.qvtimperative.tests/models/ClassesCS2AS/bug457239/ClassesCS2ASv2.qvti"
+    xmiidVersion="1">
+  <ownedImports name="classes" importedNamespace="pivot:Package ../Classes.ecore.oclas#gm0v7" xmiidVersion="1"/>
+  <ownedImports name="classescs" importedNamespace="pivot:Package ../ClassesCS.ecore.oclas#QSeUI" xmiidVersion="1"/>
+  <ownedImports importedNamespace="pivot:Model helpers.ocl.oclas#AAAAA" xmiidVersion="1"/>
+  <ownedPackages xmi:id="6Fh3I" name="">
+    <ownedClasses xsi:type="qvti:ImperativeTransformation" xmi:id="ll3DG" name="classescs2as" superClasses="http://www.eclipse.org/ocl/2015/Library.oclas#zfDWR">
+      <modelParameter xsi:type="qvti:ImperativeTypedModel" xmi:id="IsZt9" name="leftCS" usedPackage="../ClassesCS.ecore.oclas#QSeUI">
+        <ownedContext xsi:type="pivot:ParameterVariable" name="leftCS" type="pivot:Class http://www.eclipse.org/qvt/2016/QVTimperativeLibrary.oclas#qeoBC"/>
       </modelParameter>
-      <modelParameter xsi:type="qvti:ImperativeTypedModel" xmi:id="qT..classescs2as.rightAS" name="rightAS" usedPackage="../Classes.ecore.oclas#P.classes"
-          isEnforced="true">
-        <ownedContext xsi:type="pivot:ParameterVariable" xmi:id="qV..classescs2as.rightAS.rightAS" name="rightAS" type="pivot:Class http://www.eclipse.org/qvt/2016/QVTimperativeLibrary.oclas#T.qvtruntimelibrary.Model"/>
+      <modelParameter xsi:type="qvti:ImperativeTypedModel" xmi:id="fuoOH" name="rightAS" usedPackage="../Classes.ecore.oclas#gm0v7">
+        <ownedContext xsi:type="pivot:ParameterVariable" name="rightAS" type="pivot:Class http://www.eclipse.org/qvt/2016/QVTimperativeLibrary.oclas#qeoBC"/>
       </modelParameter>
-      <rule xsi:type="qvti:Mapping" xmi:id="m..classescs2as.createPackage" name="createPackage">
-        <ownedMappingParameters xsi:type="qvti:GuardParameter" name="packageCS" isRequired="false" type="pivot:Class ../ClassesCS.ecore.oclas#T.classescs.PackageCS"
-            referredTypedModel="#qT..classescs2as.leftCS"/>
-        <ownedStatements xsi:type="qvti:NewStatement" xmi:id="qV..classescs2as.createPackage._package" name="_package" isRequired="false"
-            type="pivot:Class ../Classes.ecore.oclas#T.classes.Package" referredTypedModel="#qT..classescs2as.rightAS"/>
-        <ownedStatements xsi:type="qvti:SetStatement" targetVariable="#qV..classescs2as.createPackage._package" targetProperty="../Classes.ecore.oclas#p.classes.NamedElement.name">
-          <ownedExpression xsi:type="pivot:IfExp" type="pivot:PrimitiveType http://www.eclipse.org/ocl/2015/Library.oclas#String">
-            <ownedCondition xsi:type="pivot:OperationCallExp" isRequired="false" type="pivot:PrimitiveType http://www.eclipse.org/ocl/2015/Library.oclas#Boolean"
-                referredOperation="helpers.ocl.oclas#o.ocl.OclElement.aBooleanElementOp">
-              <ownedSource xsi:type="pivot:VariableExp" isRequired="false" type="pivot:Class ../ClassesCS.ecore.oclas#T.classescs.PackageCS"
-                  referredVariable="#//@ownedPackages.0/@ownedClasses.0/@rule.0/@ownedMappingParameters.0"/>
+      <rule xsi:type="qvti:Mapping" xmi:id="nJ3jC" name="createPackage">
+        <ownedMappingParameters xsi:type="qvti:GuardParameter" xmi:id="AYM4v" name="packageCS" isRequired="false" type="pivot:Class ../ClassesCS.ecore.oclas#rYaOy"
+            referredTypedModel="#IsZt9"/>
+        <ownedStatements xsi:type="qvti:NewStatement" xmi:id="f7sVT" name="_package" isRequired="false" type="pivot:Class ../Classes.ecore.oclas#LACyd"
+            referredTypedModel="#fuoOH"/>
+        <ownedStatements xsi:type="qvti:SetStatement" targetVariable="#f7sVT" targetProperty="../Classes.ecore.oclas#LKAVE">
+          <ownedExpression xsi:type="pivot:IfExp" type="pivot:PrimitiveType http://www.eclipse.org/ocl/2015/Library.oclas#AlwVZ">
+            <ownedCondition xsi:type="pivot:OperationCallExp" name="aBooleanElementOp" isRequired="false" type="pivot:PrimitiveType http://www.eclipse.org/ocl/2015/Library.oclas#XEMMs"
+                referredOperation="helpers.ocl.oclas#S+Y2+">
+              <ownedSource xsi:type="pivot:VariableExp" name="packageCS" isRequired="false" type="pivot:Class ../ClassesCS.ecore.oclas#rYaOy"
+                  referredVariable="#AYM4v"/>
             </ownedCondition>
-            <ownedElse xsi:type="pivot:StringLiteralExp" type="pivot:PrimitiveType http://www.eclipse.org/ocl/2015/Library.oclas#String"
+            <ownedElse xsi:type="pivot:StringLiteralExp" type="pivot:PrimitiveType http://www.eclipse.org/ocl/2015/Library.oclas#AlwVZ"
                 stringSymbol="unexpected"/>
-            <ownedThen xsi:type="pivot:StringLiteralExp" type="pivot:PrimitiveType http://www.eclipse.org/ocl/2015/Library.oclas#String"
+            <ownedThen xsi:type="pivot:StringLiteralExp" type="pivot:PrimitiveType http://www.eclipse.org/ocl/2015/Library.oclas#AlwVZ"
                 stringSymbol="transformation worked"/>
           </ownedExpression>
         </ownedStatements>
       </rule>
-      <rule xsi:type="qvti:Mapping" xmi:id="m..classescs2as.__root__" name="__root__">
+      <rule xsi:type="qvti:EntryPoint" name="__root__" checkedTypedModels="#IsZt9" enforcedTypedModels="#fuoOH">
         <ownedStatements xsi:type="qvti:MappingLoop">
-          <ownedIterators name="packageCS" type="pivot:Class ../ClassesCS.ecore.oclas#T.classescs.PackageCS"/>
-          <ownedMappingStatements xsi:type="qvti:MappingCall" referredMapping="#m..classescs2as.createPackage">
-            <ownedMappingParameterBindings xsi:type="qvti:LoopParameterBinding" boundVariable="#//@ownedPackages.0/@ownedClasses.0/@rule.0/@ownedMappingParameters.0"
-                value="#//@ownedPackages.0/@ownedClasses.0/@rule.1/@ownedStatements.0/@ownedIterators.0"/>
+          <ownedIterators xmi:id="GM8oC" name="packageCS" type="pivot:Class ../ClassesCS.ecore.oclas#rYaOy"/>
+          <ownedMappingStatements xsi:type="qvti:MappingCall" referredMapping="#nJ3jC">
+            <ownedMappingParameterBindings xsi:type="qvti:LoopParameterBinding" boundVariable="#AYM4v" value="#GM8oC"/>
           </ownedMappingStatements>
-          <ownedExpression xsi:type="pivot:OperationCallExp" type="#//@ownedPackages.1/@ownedClasses.0" referredOperation="http://www.eclipse.org/ocl/2015/Library.oclas#o.ocl.OclElement.allInstances">
-            <ownedSource xsi:type="pivot:TypeExp" type="pivot:Class http://www.eclipse.org/ocl/2015/Pivot.oclas#T.pivot.Class" referredType="pivot:Class ../ClassesCS.ecore.oclas#T.classescs.PackageCS"/>
+          <ownedExpression xsi:type="pivot:OperationCallExp" name="allInstances" type="#MA2i0" referredOperation="http://www.eclipse.org/ocl/2015/Library.oclas#5w96x">
+            <ownedSource xsi:type="pivot:TypeExp" name="PackageCS" type="pivot:Class http://www.eclipse.org/ocl/2015/Pivot.oclas#pDcbe"
+                referredType="pivot:Class ../ClassesCS.ecore.oclas#rYaOy"/>
           </ownedExpression>
         </ownedStatements>
       </rule>
-      <ownedContext xsi:type="pivot:ParameterVariable" xmi:id="qV..classescs2as.this" name="this" type="#T..classescs2as"/>
+      <ownedContext xsi:type="pivot:ParameterVariable" name="this" type="#ll3DG"/>
     </ownedClasses>
   </ownedPackages>
-  <ownedPackages xmi:id="P.$$" name="$$" URI="http://www.eclipse.org/ocl/2015/Orphanage" nsPrefix="orphanage">
-    <ownedClasses xsi:type="pivot:SetType" name="Set" superClasses="#//@ownedPackages.1/@ownedClasses.1"
-        isNullFree="true">
+  <ownedPackages name="$$" URI="http://www.eclipse.org/ocl/2015/Orphanage" nsPrefix="orphanage">
+    <ownedClasses xsi:type="pivot:SetType" xmi:id="MA2i0" name="Set" superClasses="#0VKgz" isNullFree="true">
       <ownedBindings>
-        <ownedSubstitutions actual="pivot:Class ../ClassesCS.ecore.oclas#T.classescs.PackageCS" formal="http://www.eclipse.org/ocl/2015/Library.oclas#t.ocl..SetT"/>
+        <ownedSubstitutions actual="pivot:Class ../ClassesCS.ecore.oclas#rYaOy" formal="http://www.eclipse.org/ocl/2015/Library.oclas#ODsm5"/>
       </ownedBindings>
     </ownedClasses>
-    <ownedClasses xsi:type="pivot:CollectionType" name="UniqueCollection" superClasses="#//@ownedPackages.1/@ownedClasses.2">
+    <ownedClasses xsi:type="pivot:CollectionType" xmi:id="0VKgz" name="UniqueCollection" superClasses="#DbakD">
       <ownedBindings>
-        <ownedSubstitutions actual="pivot:Class ../ClassesCS.ecore.oclas#T.classescs.PackageCS" formal="http://www.eclipse.org/ocl/2015/Library.oclas#t.ocl..UniqueCollectionT"/>
+        <ownedSubstitutions actual="pivot:Class ../ClassesCS.ecore.oclas#rYaOy" formal="http://www.eclipse.org/ocl/2015/Library.oclas#jdfjE"/>
       </ownedBindings>
     </ownedClasses>
-    <ownedClasses xsi:type="pivot:CollectionType" name="Collection" superClasses="http://www.eclipse.org/ocl/2015/Library.oclas#T.ocl.OclAny">
+    <ownedClasses xsi:type="pivot:CollectionType" xmi:id="DbakD" name="Collection" superClasses="http://www.eclipse.org/ocl/2015/Library.oclas#jbMkR">
       <ownedBindings>
-        <ownedSubstitutions actual="pivot:Class ../ClassesCS.ecore.oclas#T.classescs.PackageCS" formal="http://www.eclipse.org/ocl/2015/Library.oclas#t.ocl..CollectionT"/>
+        <ownedSubstitutions actual="pivot:Class ../ClassesCS.ecore.oclas#rYaOy" formal="http://www.eclipse.org/ocl/2015/Library.oclas#qs59R"/>
       </ownedBindings>
     </ownedClasses>
   </ownedPackages>
diff --git a/tests/org.eclipse.qvtd.xtext.qvtimperative.tests/models/ClassesCS2AS/bug459225/ClassesCS2AS.qvti b/tests/org.eclipse.qvtd.xtext.qvtimperative.tests/models/ClassesCS2AS/bug459225/ClassesCS2AS.qvti
index 1d74cc8..b4a417d 100644
--- a/tests/org.eclipse.qvtd.xtext.qvtimperative.tests/models/ClassesCS2AS/bug459225/ClassesCS2AS.qvti
+++ b/tests/org.eclipse.qvtd.xtext.qvtimperative.tests/models/ClassesCS2AS/bug459225/ClassesCS2AS.qvti
@@ -4,8 +4,8 @@
 
 transformation classescs2as_Bug459225
 {
-	check leftCS imports classescs;
-	enforce rightAS imports classes;
+	leftCS imports classescs;
+	rightAS imports classes;
 }
 
 map createPackage in classescs2as_Bug459225
@@ -18,7 +18,7 @@
 						endif;
 }
 
-map __root__ in classescs2as_Bug459225
+entry __root__ check leftCS enforce rightAS in classescs2as_Bug459225
 {
 	for packageCS : classescs::PackageCS in classescs::PackageCS.allInstances() {
 		call createPackage {
diff --git a/tests/org.eclipse.qvtd.xtext.qvtimperative.tests/models/Graph2GraphHierarchical/Graph2GraphHierarchical.qvti b/tests/org.eclipse.qvtd.xtext.qvtimperative.tests/models/Graph2GraphHierarchical/Graph2GraphHierarchical.qvti
index 6eeebba..c282fd0 100644
--- a/tests/org.eclipse.qvtd.xtext.qvtimperative.tests/models/Graph2GraphHierarchical/Graph2GraphHierarchical.qvti
+++ b/tests/org.eclipse.qvtd.xtext.qvtimperative.tests/models/Graph2GraphHierarchical/Graph2GraphHierarchical.qvti
@@ -2,12 +2,12 @@
 import SimpleGraph2Graph : '../Graph2GraphMinimal/SimpleGraph2Graph.ecore'::simplegraph2graph;
 
 transformation CopyGraph {
-	check upperGraph imports SimpleGraph;
-	enforce lowerGraph imports SimpleGraph;
+	upperGraph imports SimpleGraph;
+	lowerGraph imports SimpleGraph;
 	middle imports SimpleGraph2Graph;
 }
 
-map __root__ in CopyGraph {
+entry __root__ check upperGraph enforce lowerGraph in CopyGraph {
     
     for g1 : SimpleGraph::Graph in SimpleGraph::Graph.allInstances() {
         call Graph2Middle {
diff --git a/tests/org.eclipse.qvtd.xtext.qvtimperative.tests/models/Graph2GraphMinimal/Graph2GraphMinimal.qvti b/tests/org.eclipse.qvtd.xtext.qvtimperative.tests/models/Graph2GraphMinimal/Graph2GraphMinimal.qvti
index 2344657..52618ab 100644
--- a/tests/org.eclipse.qvtd.xtext.qvtimperative.tests/models/Graph2GraphMinimal/Graph2GraphMinimal.qvti
+++ b/tests/org.eclipse.qvtd.xtext.qvtimperative.tests/models/Graph2GraphMinimal/Graph2GraphMinimal.qvti
@@ -2,8 +2,8 @@
 import SimpleGraph2Graph : 'SimpleGraph2Graph.ecore'::simplegraph2graph;
 
 transformation CopyGraphMinimal {
-	check upperGraph imports SimpleGraph;
-	enforce lowerGraph imports SimpleGraph;
+	upperGraph imports SimpleGraph;
+	lowerGraph imports SimpleGraph;
 	middle imports SimpleGraph2Graph;
 }
 
@@ -24,7 +24,7 @@
     set g2.name := g2gout.name;
 }
 
-map __root__ in CopyGraphMinimal {
+entry __root__ check upperGraph enforce lowerGraph in CopyGraphMinimal {
     for g1 : SimpleGraph::Graph in SimpleGraph::Graph.allInstances() {
         call graph2graphLM {
             g1 iterates g1;
diff --git a/tests/org.eclipse.qvtd.xtext.qvtimperative.tests/models/HSV2HSL/HSV2HSL.qvti b/tests/org.eclipse.qvtd.xtext.qvtimperative.tests/models/HSV2HSL/HSV2HSL.qvti
index 7aaae89..c470dae 100644
--- a/tests/org.eclipse.qvtd.xtext.qvtimperative.tests/models/HSV2HSL/HSV2HSL.qvti
+++ b/tests/org.eclipse.qvtd.xtext.qvtimperative.tests/models/HSV2HSL/HSV2HSL.qvti
@@ -6,8 +6,8 @@
 -- library '../../myOclHelper.ocl'; -- Import a complete OCL with helpers
 
 transformation hsv2hsl {
-	check hsv imports HSVTree;  -- Should specify the correct package
-	enforce hsl imports HSLTree;  --
+	hsv imports HSVTree;  -- Should specify the correct package
+	hsl imports HSLTree;  --
 	-- hsl imports "strict" HSLTree;  -- 
 	-- hsl imports HSLTree{strict};   -- The model has to strictly conform to the HSLTree mm, without strict the model can have classes that match the name but not completely conform to the mm  
 	middle imports HSV2HSL;
@@ -18,7 +18,7 @@
 query hsv2hsl::rgb2hsl(color : HSV2HSL::RGB) : HSLTree::HSL;
 query hsv2hsl::rgb2hsv(color : HSV2HSL::RGB) : HSVTree::HSV;
 
-map __root__ in hsv2hsl {
+entry __root__ check hsv enforce hsl in hsv2hsl {
 	append nodes : HSVTree::HSVNode;
     for hsvRoot : HSVTree::HSVNode in nodes {
         call HSV2MiddleRoot {
diff --git a/tests/org.eclipse.qvtd.xtext.qvtimperative.tests/models/ManualUML2RDBMS/ManualUML2RDBMS.qvti b/tests/org.eclipse.qvtd.xtext.qvtimperative.tests/models/ManualUML2RDBMS/ManualUML2RDBMS.qvti
index 20ac270..295c096 100644
--- a/tests/org.eclipse.qvtd.xtext.qvtimperative.tests/models/ManualUML2RDBMS/ManualUML2RDBMS.qvti
+++ b/tests/org.eclipse.qvtd.xtext.qvtimperative.tests/models/ManualUML2RDBMS/ManualUML2RDBMS.qvti
@@ -3,12 +3,12 @@
 import UML2RDBMS: 'ManualUML2RDBMS.ecore'::uml2rdbms;
 
 transformation ManualUML2RDBMS {
-    check uml imports UML;
-    enforce rdbms imports RDBMS;
+    uml imports UML;
+    rdbms imports RDBMS;
     middle imports UML2RDBMS;
 }
 
-map __root__ in ManualUML2RDBMS {
+entry __root__ check uml enforce rdbms in ManualUML2RDBMS {
     for p1 : UML::Package in UML::Package.allInstances() {
         call packageToSchemaLM {
             p iterates p1;
diff --git a/tests/org.eclipse.qvtd.xtext.qvtimperative.tests/models/SimpleUML2RDBMS/SimpleUML2RDBMS.qvti b/tests/org.eclipse.qvtd.xtext.qvtimperative.tests/models/SimpleUML2RDBMS/SimpleUML2RDBMS.qvti
index d644918..4adb3cd 100644
--- a/tests/org.eclipse.qvtd.xtext.qvtimperative.tests/models/SimpleUML2RDBMS/SimpleUML2RDBMS.qvti
+++ b/tests/org.eclipse.qvtd.xtext.qvtimperative.tests/models/SimpleUML2RDBMS/SimpleUML2RDBMS.qvti
@@ -6,8 +6,8 @@
 {
 	transformation SimpleUML2RDBMS
 	{
-		check uml imports simpleuml;
-		enforce rdbms imports simplerdbms;
+		uml imports simpleuml;
+		rdbms imports simplerdbms;
 		middle imports umltordbms;
 	}
 }
@@ -320,7 +320,7 @@
 	set c.type := ct;
 }
 
-map __root__ in simpleUML2RDBMS::SimpleUML2RDBMS
+entry __root__ check uml enforce rdbms in simpleUML2RDBMS::SimpleUML2RDBMS
 {
 	for p : simpleuml::Package in uml.objectsOfKind(Package) {
 		call packageToSchema_LM {
diff --git a/tests/org.eclipse.qvtd.xtext.qvtimperative.tests/models/Tree2TallTree/Tree2TallTree.qvti b/tests/org.eclipse.qvtd.xtext.qvtimperative.tests/models/Tree2TallTree/Tree2TallTree.qvti
index 83e390a..24382c4 100644
--- a/tests/org.eclipse.qvtd.xtext.qvtimperative.tests/models/Tree2TallTree/Tree2TallTree.qvti
+++ b/tests/org.eclipse.qvtd.xtext.qvtimperative.tests/models/Tree2TallTree/Tree2TallTree.qvti
@@ -3,12 +3,12 @@
 import 'Tree2TallTree.ecore'::tree2talltree;
 
 transformation Tree2TallTree {
-	check tree imports tree;
-	enforce talltree imports talltree;
+	tree imports tree;
+	talltree imports talltree;
 	tree2talltree imports tree2talltree;
 }
 
-map __root__ in Tree2TallTree {
+entry __root__ check tree enforce talltree in Tree2TallTree {
     append nodes : tree::Node;
     buffer node2tallNodes : tree2talltree::Node2TallNode;
     install Node2MiddleNode {
diff --git a/tests/org.eclipse.qvtd.xtext.qvtimperative.tests/src/org/eclipse/qvtd/xtext/qvtimperative/tests/QVTiInterpreterTests.java b/tests/org.eclipse.qvtd.xtext.qvtimperative.tests/src/org/eclipse/qvtd/xtext/qvtimperative/tests/QVTiInterpreterTests.java
index a6a91a5..32929f9 100644
--- a/tests/org.eclipse.qvtd.xtext.qvtimperative.tests/src/org/eclipse/qvtd/xtext/qvtimperative/tests/QVTiInterpreterTests.java
+++ b/tests/org.eclipse.qvtd.xtext.qvtimperative.tests/src/org/eclipse/qvtd/xtext/qvtimperative/tests/QVTiInterpreterTests.java
@@ -38,6 +38,7 @@
 import org.eclipse.qvtd.compiler.QVTiCompilerChain;
 import org.eclipse.qvtd.pivot.qvtbase.graphs.GraphMLBuilder;
 import org.eclipse.qvtd.pivot.qvtbase.graphs.GraphMLStringBuilder;
+import org.eclipse.qvtd.pivot.qvtimperative.EntryPoint;
 import org.eclipse.qvtd.pivot.qvtimperative.ImperativeTransformation;
 import org.eclipse.qvtd.pivot.qvtimperative.QVTimperativePackage;
 import org.eclipse.qvtd.pivot.qvtimperative.evaluation.BasicQVTiExecutor;
@@ -70,8 +71,8 @@
 		}
 
 		@Override
-		protected @NonNull BasicQVTiExecutor createInterpretedExecutor(@NonNull QVTiEnvironmentFactory environmentFactory, @NonNull ImperativeTransformation asTransformation) throws Exception {
-			return new QVTiIncrementalExecutor(environmentFactory, asTransformation, modeFactory);
+		protected @NonNull BasicQVTiExecutor createInterpretedExecutor(@NonNull QVTiEnvironmentFactory environmentFactory, @NonNull EntryPoint entryPoint) throws Exception {
+			return new QVTiIncrementalExecutor(environmentFactory, entryPoint, modeFactory);
 		}
 
 		@Override
@@ -190,8 +191,9 @@
 		URI outputURI = getTestURI("Graph2GraphMinimal.xmi");
 		URI traceURI = getTestURI("Graph2Graph.xmi");
 		MyQVT myQVT = createQVT("Graph2GraphMinimal", txURI, ModeFactory.LAZY);
-		ImperativeTransformation asTransformation = myQVT.loadTransformation();
-		BasicQVTiExecutor testEvaluator = myQVT.createInterpretedExecutor(asTransformation);
+		ImperativeTransformation iTransformation = myQVT.loadTransformation();
+		EntryPoint iEntryPoint = QVTimperativeUtil.getDefaultEntryPoint(iTransformation);
+		BasicQVTiExecutor testEvaluator = myQVT.createInterpretedExecutor(iEntryPoint);
 		testEvaluator.saveTransformation(txASURI, null);
 		assertLoadable(txASURI);
 		//
@@ -221,8 +223,9 @@
 		URI outputURI = getTestURI("Graph2GraphHierarchical.xmi");
 		URI traceURI = getTestURI("Graph2Graph.xmi");
 		MyQVT myQVT = createQVT("Graph2GraphHierarchical", txURI, ModeFactory.LAZY);
-		ImperativeTransformation asTransformation = myQVT.loadTransformation();
-		BasicQVTiExecutor testEvaluator = myQVT.createInterpretedExecutor(asTransformation);
+		ImperativeTransformation iTransformation = myQVT.loadTransformation();
+		EntryPoint iEntryPoint = QVTimperativeUtil.getDefaultEntryPoint(iTransformation);
+		BasicQVTiExecutor testEvaluator = myQVT.createInterpretedExecutor(iEntryPoint);
 		testEvaluator.saveTransformation(txASURI, null);
 		assertLoadable(txASURI);
 		//
@@ -255,8 +258,9 @@
 		URI outputURI = getTestURI("HSLNode.xmi");
 		URI traceURI = getTestURI("HSV2HSLNode.xmi");
 		MyQVT myQVT = createQVT("HSV2HSL", txURI, ModeFactory.LAZY);
-		ImperativeTransformation asTransformation = myQVT.loadTransformation();
-		BasicQVTiExecutor testEvaluator = myQVT.createInterpretedExecutor(asTransformation);
+		ImperativeTransformation iTransformation = myQVT.loadTransformation();
+		EntryPoint iEntryPoint = QVTimperativeUtil.getDefaultEntryPoint(iTransformation);
+		BasicQVTiExecutor testEvaluator = myQVT.createInterpretedExecutor(iEntryPoint);
 		testEvaluator.saveTransformation(txASURI, null);
 		assertLoadable(txASURI);
 		//
@@ -281,8 +285,9 @@
 		URI outputURI = getTestURI("TallTree.xmi");
 		URI traceURI = getTestURI("Tree2TallTree.xmi");
 		MyQVT myQVT = createQVT("Tree2TallTree", txURI, ModeFactory.INCREMENTAL);
-		ImperativeTransformation asTransformation = myQVT.loadTransformation();
-		BasicQVTiExecutor testEvaluator = myQVT.createInterpretedExecutor(asTransformation);
+		ImperativeTransformation iTransformation = myQVT.loadTransformation();
+		EntryPoint iEntryPoint = QVTimperativeUtil.getDefaultEntryPoint(iTransformation);
+		BasicQVTiExecutor testEvaluator = myQVT.createInterpretedExecutor(iEntryPoint);
 		testEvaluator.saveTransformation(txASURI, null);
 		assertLoadable(txASURI);
 		//
@@ -309,8 +314,9 @@
 		URI outputURI = getTestURI("TallTree.xmi");
 		URI traceURI = getTestURI("Tree2TallTree.xmi");
 		MyQVT myQVT = createQVT("Tree2TallTree", txURI, ModeFactory.LAZY);
-		ImperativeTransformation asTransformation = myQVT.loadTransformation();
-		BasicQVTiExecutor testEvaluator = myQVT.createInterpretedExecutor(asTransformation);
+		ImperativeTransformation iTransformation = myQVT.loadTransformation();
+		EntryPoint iEntryPoint = QVTimperativeUtil.getDefaultEntryPoint(iTransformation);
+		BasicQVTiExecutor testEvaluator = myQVT.createInterpretedExecutor(iEntryPoint);
 		testEvaluator.saveTransformation(txASURI, null);
 		assertLoadable(txASURI);
 		//
@@ -343,8 +349,9 @@
 		@SuppressWarnings("unused")
 		CompleteOCLEObjectValidator completeOCLEObjectValidator2 = new CompleteOCLEObjectValidator(ClassUtil.nonNullState(QVTimperativePackage.eINSTANCE), oclURI, myQVT.getEnvironmentFactory());
 
-		ImperativeTransformation asTransformation = myQVT.loadTransformation();
-		BasicQVTiExecutor testEvaluator = myQVT.createInterpretedExecutor(asTransformation);
+		ImperativeTransformation iTransformation = myQVT.loadTransformation();
+		EntryPoint iEntryPoint = QVTimperativeUtil.getDefaultEntryPoint(iTransformation);
+		BasicQVTiExecutor testEvaluator = myQVT.createInterpretedExecutor(iEntryPoint);
 		testEvaluator.saveTransformation(txASURI, null);
 		assertLoadable(txASURI);
 		//
@@ -378,8 +385,9 @@
 		@SuppressWarnings("unused")
 		CompleteOCLEObjectValidator completeOCLEObjectValidator2 = new CompleteOCLEObjectValidator(ClassUtil.nonNullState(QVTimperativePackage.eINSTANCE), oclURI, environmentFactory);
 
-		ImperativeTransformation asTransformation = myQVT.loadTransformation();
-		BasicQVTiExecutor testEvaluator = myQVT.createInterpretedExecutor(asTransformation);
+		ImperativeTransformation iTransformation = myQVT.loadTransformation();
+		EntryPoint iEntryPoint = QVTimperativeUtil.getDefaultEntryPoint(iTransformation);
+		BasicQVTiExecutor testEvaluator = myQVT.createInterpretedExecutor(iEntryPoint);
 		testEvaluator.saveTransformation(txASURI, null);
 		assertLoadable(txASURI);
 		//
@@ -401,8 +409,9 @@
 		URI inputURI = getModelsURI("ClassesCS2AS/bug456900/example_input.xmi");
 		URI outputURI = getTestURI("example_output.xmi");
 		MyQVT myQVT = createQVT("ClassesCS2AS", txURI, ModeFactory.LAZY);
-		ImperativeTransformation asTransformation = myQVT.loadTransformation();
-		BasicQVTiExecutor testEvaluator = myQVT.createInterpretedExecutor(asTransformation);
+		ImperativeTransformation iTransformation = myQVT.loadTransformation();
+		EntryPoint iEntryPoint = QVTimperativeUtil.getDefaultEntryPoint(iTransformation);
+		BasicQVTiExecutor testEvaluator = myQVT.createInterpretedExecutor(iEntryPoint);
 		testEvaluator.saveTransformation(txASURI, null);
 		assertLoadable(txASURI);
 		//
@@ -424,8 +433,9 @@
 		URI inputURI = getModelsURI("ClassesCS2AS/bug457239/example_input.xmi");
 		URI outputURI = getTestURI("example_output.xmi");
 		MyQVT myQVT = createQVT("ClassesCS2AS", txURI, ModeFactory.LAZY);
-		ImperativeTransformation asTransformation = myQVT.loadTransformation();
-		BasicQVTiExecutor testEvaluator = myQVT.createInterpretedExecutor(asTransformation);
+		ImperativeTransformation iTransformation = myQVT.loadTransformation();
+		EntryPoint iEntryPoint = QVTimperativeUtil.getDefaultEntryPoint(iTransformation);
+		BasicQVTiExecutor testEvaluator = myQVT.createInterpretedExecutor(iEntryPoint);
 		testEvaluator.saveTransformation(txASURI, null);
 		assertLoadable(txASURI);
 		//
@@ -446,8 +456,9 @@
 		URI inputURI = getModelsURI("ClassesCS2AS/bug457239/example_input.xmi");
 		URI outputURI = getTestURI("example_output.xmi");
 		MyQVT myQVT = createQVT("ClassesCS2AS", txURI, ModeFactory.LAZY);
-		ImperativeTransformation asTransformation = myQVT.loadTransformation();
-		myQVT.createInterpretedExecutor(asTransformation);
+		ImperativeTransformation iTransformation = myQVT.loadTransformation();
+		EntryPoint iEntryPoint = QVTimperativeUtil.getDefaultEntryPoint(iTransformation);
+		myQVT.createInterpretedExecutor(iEntryPoint);
 		//
 		myQVT.addInputURI("leftCS", inputURI);
 		assertTrue(myQVT.executeTransformation());
diff --git a/tests/org.eclipse.qvtd.xtext.qvtrelation.tests/src/org/eclipse/qvtd/xtext/qvtrelation/tests/QVTrCompilerTests.java b/tests/org.eclipse.qvtd.xtext.qvtrelation.tests/src/org/eclipse/qvtd/xtext/qvtrelation/tests/QVTrCompilerTests.java
index c3ead40..4e9e012 100644
--- a/tests/org.eclipse.qvtd.xtext.qvtrelation.tests/src/org/eclipse/qvtd/xtext/qvtrelation/tests/QVTrCompilerTests.java
+++ b/tests/org.eclipse.qvtd.xtext.qvtrelation.tests/src/org/eclipse/qvtd/xtext/qvtrelation/tests/QVTrCompilerTests.java
@@ -52,8 +52,10 @@
 import org.eclipse.qvtd.compiler.internal.qvtc2qvtu.QVTuConfiguration;
 import org.eclipse.qvtd.compiler.internal.qvtm2qvts.QVTm2QVTs;
 import org.eclipse.qvtd.pivot.qvtbase.utilities.QVTbaseUtil;
+import org.eclipse.qvtd.pivot.qvtimperative.EntryPoint;
 import org.eclipse.qvtd.pivot.qvtimperative.ImperativeTransformation;
 import org.eclipse.qvtd.pivot.qvtimperative.evaluation.QVTiEnvironmentFactory;
+import org.eclipse.qvtd.pivot.qvtimperative.utilities.QVTimperativeUtil;
 import org.eclipse.qvtd.pivot.qvtrelation.utilities.QVTrelation;
 import org.eclipse.qvtd.pivot.qvtrelation.utilities.QVTrelationToStringVisitor;
 import org.eclipse.qvtd.pivot.qvtschedule.impl.RuleRegionImpl;
@@ -789,7 +791,7 @@
 		try {
 			ImperativeTransformation asTransformation = myQVT.compileTransformation("as");
 			//
-			myQVT.createInterpretedExecutor(asTransformation);
+			myQVT.createInterpretedExecutor(QVTimperativeUtil.getDefaultEntryPoint(asTransformation));
 			myQVT.addInputURI("ecore", ecoreURI);
 			myQVT.executeTransformation();
 			myQVT.addOutputURI("as", asURI2);
@@ -981,30 +983,31 @@
 		MyQVT myQVT = createQVT("Forward2Reverse", getModelsURI("forward2reverse/Forward2Reverse.qvtr"));
 		//		myQVT.getEnvironmentFactory().setEvaluationTracingEnabled(true);
 		try {
-			ImperativeTransformation asTransformation = myQVT.compileTransformation("reverse");
+			ImperativeTransformation iTransformation = myQVT.compileTransformation("reverse");
+			EntryPoint iEntryPoint = QVTimperativeUtil.getDefaultEntryPoint(iTransformation);
 			//
-			myQVT.createInterpretedExecutor(asTransformation);
+			myQVT.createInterpretedExecutor(iEntryPoint);
 			myQVT.addInputURI("forward", getModelsURI("forward2reverse/samples/EmptyList.xmi"));
 			myQVT.executeTransformation();
 			myQVT.addOutputURI("reverse", getTestURI("EmptyList_Interpreted.xmi"));
 			myQVT.saveModels(null);
 			myQVT.checkOutput(getTestURI("EmptyList_Interpreted.xmi"), getModelsURI("forward2reverse/samples/EmptyList_expected.xmi"), Forward2ReverseNormalizer.INSTANCE);
 			//
-			myQVT.createInterpretedExecutor(asTransformation);
+			myQVT.createInterpretedExecutor(iEntryPoint);
 			myQVT.addInputURI("forward", getModelsURI("forward2reverse/samples/OneElementList.xmi"));
 			myQVT.executeTransformation();
 			myQVT.addOutputURI("reverse", getTestURI("OneElementList_Interpreted.xmi"));
 			myQVT.saveModels(null);
 			myQVT.checkOutput(getTestURI("OneElementList_Interpreted.xmi"), getModelsURI("forward2reverse/samples/OneElementList_expected.xmi"), Forward2ReverseNormalizer.INSTANCE);
 			//
-			myQVT.createInterpretedExecutor(asTransformation);
+			myQVT.createInterpretedExecutor(iEntryPoint);
 			myQVT.addInputURI("forward", getModelsURI("forward2reverse/samples/TwoElementList.xmi"));
 			myQVT.executeTransformation();
 			myQVT.addOutputURI("reverse", getTestURI("TwoElementList_Interpreted.xmi"));
 			myQVT.saveModels(null);
 			myQVT.checkOutput(getTestURI("TwoElementList_Interpreted.xmi"), getModelsURI("forward2reverse/samples/TwoElementList_expected.xmi"), Forward2ReverseNormalizer.INSTANCE);
 			//
-			myQVT.createInterpretedExecutor(asTransformation);
+			myQVT.createInterpretedExecutor(iEntryPoint);
 			myQVT.addInputURI("forward", getModelsURI("forward2reverse/samples/ThreeElementList.xmi"));
 			myQVT.executeTransformation();
 			myQVT.addOutputURI("reverse", getTestURI("ThreeElementList_Interpreted.xmi"));
@@ -1033,8 +1036,8 @@
 		try {
 			Iterable<@NonNull String> forwardOutputNames = Collections.singletonList("forward");
 			Iterable<@NonNull String> reverseOutputNames = Collections.singletonList("reverse");
-			//			txClass = myQVT1.buildTransformation(Lists.newArrayList(reverseOutputNames, forwardOutputNames), false);//,
-			txClass = myQVT1.buildTransformation(Collections.singletonList(reverseOutputNames), false);//,
+			txClass = myQVT1.buildTransformation(Lists.newArrayList(reverseOutputNames, forwardOutputNames), false);//,
+			//			txClass = myQVT1.buildTransformation(Collections.singletonList(reverseOutputNames), false);//,
 			//			Class<? extends Transformer> txClass = Forward2Reverse.class;
 			//			myQVT1.assertRegionCount(ActivatorRegionImpl.class, 2);
 			//	myQVT1.assertRegionCount(RuleRegionImpl.class, 1);
@@ -1052,31 +1055,38 @@
 			//
 			myQVT2.createGeneratedExecutor(txClass);
 			myQVT2.addInputURI("forward", getModelsURI("forward2reverse/samples/EmptyList.xmi"));
-			myQVT2.executeTransformation();
+			myQVT2.executeTransformation("reverse");
 			myQVT2.addOutputURI("reverse", getTestURI("EmptyList_CG.xmi"));
 			myQVT2.saveModels(null);
 			myQVT2.checkOutput(getTestURI("EmptyList_CG.xmi"), getModelsURI("forward2reverse/samples/EmptyList_expected.xmi"), Forward2ReverseNormalizer.INSTANCE);
 			//
 			myQVT2.createGeneratedExecutor(txClass);
 			myQVT2.addInputURI("forward", getModelsURI("forward2reverse/samples/OneElementList.xmi"));
-			myQVT2.executeTransformation();
+			myQVT2.executeTransformation("reverse");
 			myQVT2.addOutputURI("reverse", getTestURI("OneElementList_CG.xmi"));
 			myQVT2.saveModels(null);
 			myQVT2.checkOutput(getTestURI("OneElementList_CG.xmi"), getModelsURI("forward2reverse/samples/OneElementList_expected.xmi"), Forward2ReverseNormalizer.INSTANCE);
 			//
 			myQVT2.createGeneratedExecutor(txClass);
 			myQVT2.addInputURI("forward", getModelsURI("forward2reverse/samples/TwoElementList.xmi"));
-			myQVT2.executeTransformation();
+			myQVT2.executeTransformation("reverse");
 			myQVT2.addOutputURI("reverse", getTestURI("TwoElementList_CG.xmi"));
 			myQVT2.saveModels(null);
 			myQVT2.checkOutput(getTestURI("TwoElementList_CG.xmi"), getModelsURI("forward2reverse/samples/TwoElementList_expected.xmi"), Forward2ReverseNormalizer.INSTANCE);
 			//
 			myQVT2.createGeneratedExecutor(txClass);
 			myQVT2.addInputURI("forward", getModelsURI("forward2reverse/samples/ThreeElementList.xmi"));
-			myQVT2.executeTransformation();
+			myQVT2.executeTransformation("reverse");
 			myQVT2.addOutputURI("reverse", getTestURI("ThreeElementList_CG.xmi"));
 			myQVT2.saveModels(null);
 			myQVT2.checkOutput(getTestURI("ThreeElementList_CG.xmi"), getModelsURI("forward2reverse/samples/ThreeElementList_expected.xmi"), Forward2ReverseNormalizer.INSTANCE);
+			//
+			myQVT2.createGeneratedExecutor(txClass);
+			myQVT2.addInputURI("reverse", getModelsURI("forward2reverse/samples/ThreeElementList.xmi"));
+			myQVT2.executeTransformation("forward");
+			myQVT2.addOutputURI("forward", getTestURI("ThreeElementList_CG.xmi"));
+			myQVT2.saveModels(null);
+			myQVT2.checkOutput(getTestURI("ThreeElementList_CG.xmi"), getModelsURI("forward2reverse/samples/ThreeElementList_expected.xmi"), Forward2ReverseNormalizer.INSTANCE);
 		}
 		finally {
 			myQVT2.dispose();
@@ -1090,23 +1100,24 @@
 		MyQVT myQVT = createQVT("HierarchicalStateMachine2FlatStateMachine", getModelsURI("hstm2fstm/HierarchicalStateMachine2FlatStateMachine.qvtr"));
 		//		myQVT.getEnvironmentFactory().setEvaluationTracingEnabled(true);
 		try {
-			ImperativeTransformation asTransformation = myQVT.compileTransformation("flat");
+			ImperativeTransformation iTransformation = myQVT.compileTransformation("flat");
+			EntryPoint iEntryPoint = QVTimperativeUtil.getDefaultEntryPoint(iTransformation);
 			//
-			myQVT.createInterpretedExecutor(asTransformation);
+			myQVT.createInterpretedExecutor(iEntryPoint);
 			myQVT.addInputURI("hier", getModelsURI("hstm2fstm/samples/MiniModel.xmi"));
 			myQVT.executeTransformation();
 			myQVT.addOutputURI("flat", getTestURI("MiniModel_Interpreted.xmi"));
 			myQVT.saveModels(null);
 			myQVT.checkOutput(getTestURI("MiniModel_Interpreted.xmi"), getModelsURI("hstm2fstm/samples/MiniModel_expected.xmi"), FlatStateMachineNormalizer.INSTANCE);
 			//
-			myQVT.createInterpretedExecutor(asTransformation);
+			myQVT.createInterpretedExecutor(iEntryPoint);
 			myQVT.addInputURI("hier", getModelsURI("hstm2fstm/samples/SimpleModel.xmi"));
 			myQVT.executeTransformation();
 			myQVT.addOutputURI("flat", getTestURI("SimpleModel_Interpreted.xmi"));
 			myQVT.saveModels(null);
 			myQVT.checkOutput(getTestURI("SimpleModel_Interpreted.xmi"), getModelsURI("hstm2fstm/samples/SimpleModel_expected.xmi"), FlatStateMachineNormalizer.INSTANCE);
 			//
-			myQVT.createInterpretedExecutor(asTransformation);
+			myQVT.createInterpretedExecutor(iEntryPoint);
 			myQVT.addInputURI("hier", getModelsURI("hstm2fstm/samples/LargerModel.xmi"));
 			myQVT.executeTransformation();
 			myQVT.addOutputURI("flat", getTestURI("LargerModel_Interpreted.xmi"));
@@ -1453,7 +1464,7 @@
 		//		myQVT.getEnvironmentFactory().setEvaluationTracingEnabled(true);
 		try {
 			ImperativeTransformation asTransformation = myQVT.compileTransformation("stm");
-			myQVT.createInterpretedExecutor(asTransformation);
+			myQVT.createInterpretedExecutor(QVTimperativeUtil.getDefaultEntryPoint(asTransformation));
 			myQVT.addInputURI("seqDgm", getModelsURI("seq2stm/samples/Seq.xmi"));
 			myQVT.executeTransformation();
 			myQVT.addOutputURI("stm", getTestURI("Stmc_Interpreted.xmi"));