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 93b2b7e..cdf4683 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
@@ -16,7 +16,6 @@
 import java.util.HashMap;
 import java.util.List;
 import java.util.Map;
-import java.util.Set;
 
 import org.eclipse.emf.ecore.EClassifier;
 import org.eclipse.emf.ecore.EPackage;
@@ -46,6 +45,7 @@
 import org.eclipse.ocl.pivot.ids.ElementId;
 import org.eclipse.ocl.pivot.ids.PropertyId;
 import org.eclipse.ocl.pivot.ids.TypeId;
+import org.eclipse.ocl.pivot.internal.manager.MetamodelManager;
 import org.eclipse.ocl.pivot.utilities.ClassUtil;
 import org.eclipse.ocl.pivot.utilities.NameUtil;
 import org.eclipse.ocl.pivot.utilities.ValueUtil;
@@ -89,9 +89,45 @@
  */
 public class QVTiCG2JavaVisitor extends CG2JavaVisitor<QVTiCodeGenerator> implements QVTiCGModelVisitor<Boolean>
 {
+	protected class MyTransformationAnalysis extends QVTiTransformationAnalysis
+	{
+		protected final @NonNull String classIndex2classIdName;
+		protected final @NonNull String classIndex2allClassIndexesName;
+		protected final @NonNull String classIndex2objectsName;
+		protected final @NonNull String modelObjectsName;
+		
+		protected MyTransformationAnalysis(@NonNull MetamodelManager metamodelManager, @NonNull CGTransformation cgTransformation) {
+			super(metamodelManager);
+			@SuppressWarnings("null")@NonNull Transformation transformation = (Transformation) cgTransformation.getAst();
+			analyzeTransformation(transformation);
+			NameManager nameManager = getGlobalContext().getNameManager();
+			classIndex2classIdName = nameManager.getGlobalSymbolName(null, "classIndex2classId");
+			classIndex2allClassIndexesName = nameManager.getGlobalSymbolName(null, "classIndex2allClassIndexes");
+			classIndex2objectsName = "classIndex2objects"; // nameManager.getGlobalSymbolName(null, "classIndex2objects");
+			modelObjectsName = "modelObjects"; // nameManager.getGlobalSymbolName(null, "modelObjects");
+		}
+
+		public @NonNull String getClassIndex2classIdName() {
+			return classIndex2classIdName;
+		}
+
+		public @NonNull String getClassIndex2allClassIndexesName() {
+			return classIndex2allClassIndexesName;
+		}
+
+		public @NonNull String getClassIndex2objectsName() {
+			return classIndex2objectsName;
+		}
+
+		public @NonNull String getModelObjectsName() {
+			return modelObjectsName;
+		}
+	}
+
 	protected final @NonNull QVTiAnalyzer analyzer;
 	protected final @NonNull CGPackage cgPackage;
 	protected final @Nullable List<CGValuedElement> sortedGlobals;
+	private MyTransformationAnalysis transformationAnalysis = null;
 	
 	public QVTiCG2JavaVisitor(@NonNull QVTiCodeGenerator codeGenerator, @NonNull CGPackage cgPackage,
 			@Nullable List<CGValuedElement> sortedGlobals) {
@@ -131,26 +167,41 @@
 		}
 		CGTypedModel cgTypedModel = cgRealizedVariable.getTypedModel();
 		//
-		js.append("modelObjects[");
+		js.append(transformationAnalysis.getModelObjectsName());
+		js.append("[");
 		appendModelIndex(cgTypedModel);
 		js.append("].add(");
 		js.appendValueName(cgRealizedVariable);
 		js.append(");\n");
+		if (transformationAnalysis != null) {
+			TypeId typeId = pRealizedVariable.getTypeId();
+			if (typeId instanceof ClassId) {
+				Integer classIndex = transformationAnalysis.getAllInstancesClassIndex((ClassId)typeId);
+				if (classIndex != null) {
+					js.append(transformationAnalysis.getClassIndex2objectsName());
+					js.append("[");
+					js.append(classIndex + "/*" + typeId.getDisplayName() + "*/");
+					js.append("].add(");
+					js.appendValueName(cgRealizedVariable);
+					js.append(");\n");
+				}
+			}
+		}
 	}
 
-	protected String[] doAllInstances(@NonNull QVTiTransformationAnalysis transformationAnalysis) {
-		Set<org.eclipse.ocl.pivot.Class> allInstancesClasses = transformationAnalysis.getAllInstancesClasses();
-		if (allInstancesClasses.size() > 0) {
-			NameManager nameManager = getGlobalContext().getNameManager();
-			Map<org.eclipse.ocl.pivot.Class, List<org.eclipse.ocl.pivot.Class>> instancesClassAnalysis = transformationAnalysis.getInstancesClassAnalysis(allInstancesClasses);
+	protected String[] doAllInstances() {
+//		Set<org.eclipse.ocl.pivot.Class> allInstancesClasses = transformationAnalysis.getAllInstancesClasses();
+		Map<ClassId, Integer> allInstancesClassId2classIndex = transformationAnalysis.getAllInstancesClassId2classIndex();
+		if (allInstancesClassId2classIndex.size() > 0) {
+			Map<ClassId, List<ClassId>> instancesClassAnalysis = transformationAnalysis.getInstancesClassAnalysis(transformationAnalysis.getAllInstancesClasses());
 			//
 			// Populate a mapping from instancesClass to linear index.
 			//
-			Map<org.eclipse.ocl.pivot.Class, Integer> instancesClass2index = new HashMap<org.eclipse.ocl.pivot.Class, Integer>(instancesClassAnalysis.size());
-			List<org.eclipse.ocl.pivot.Class> sortedList = new ArrayList<org.eclipse.ocl.pivot.Class>(instancesClassAnalysis.keySet());
-			Collections.sort(sortedList, NameUtil.NameableComparator.INSTANCE);
-			for (int i = 0; i < sortedList.size(); i++) {
-				instancesClass2index.put(sortedList.get(i), i);
+//			Map<org.eclipse.ocl.pivot.Class, Integer> instancesClass2index = new HashMap<org.eclipse.ocl.pivot.Class, Integer>(instancesClassAnalysis.size());
+			ClassId[] classIndex2classId = new ClassId[allInstancesClassId2classIndex.size()];
+//			Collections.sort(sortedList, NameUtil.NameableComparator.INSTANCE);
+			for (ClassId classId : allInstancesClassId2classIndex.keySet()) {
+				classIndex2classId[allInstancesClassId2classIndex.get(classId)] = classId;
 			}
 			//
 			//	Emit the ClassId array
@@ -158,32 +209,30 @@
 			js.append("/*\n");
 			js.append(" * Array of the ClassIds of each class for which allInstances() may be invoked. Array index is the ClassIndex.\n");
 			js.append(" */\n");
-			String classIndex2classIdName = nameManager.getGlobalSymbolName(null, "classIndex2classId");
 			js.append("private static final ");
 			js.appendIsRequired(true);
 			js.append(" ");
 			js.appendClassReference(ClassId.class);
 			js.append("[] ");
-			js.append(classIndex2classIdName);
+			js.append(transformationAnalysis.getClassIndex2classIdName());
 			js.append(" = new ");
 			js.appendClassReference(ClassId.class);
 			js.append("[]{\n");
 			js.pushIndentation(null);
-			for (int i = 0; i < sortedList.size(); i++) {
-				org.eclipse.ocl.pivot.Class instancesClass = sortedList.get(i);
-				CGTypeId cgTypeId = getCodeGenerator().getAnalyzer().getTypeId(instancesClass.getTypeId());
+			for (int i = 0; i < classIndex2classId.length; i++) {
+				@SuppressWarnings("null")@NonNull ClassId instancesClassId = classIndex2classId[i];
+				CGTypeId cgTypeId = getCodeGenerator().getAnalyzer().getTypeId(instancesClassId);
 				js.appendValueName(cgTypeId);
-				if ((i+1) < sortedList.size()) {
+				if ((i+1) < classIndex2classId.length) {
 					js.append(",");
 				}
-				js.append("\t\t// " + i + " => " + instancesClass.getName() + "\n");
+				js.append("\t\t// " + i + " => " + instancesClassId.getDisplayName() + "\n");
 			}
 			js.popIndentation();
 			js.append("};\n");
 			//
 			//	Emit the classIndex2allClassIndexes array of arrays
 			//
-			String classIndex2allClassIndexes = nameManager.getGlobalSymbolName(null, "classIndex2allClassIndexes");
 			js.append("/*\n");
 			js.append(" * Mapping from each ClassIndex to all the ClassIndexes to which an object of the outer index\n");
 			js.append(" * may contribute results to an allInstances() invocation.\n");
@@ -195,43 +244,43 @@
 			js.append(" ");
 			js.appendClassReference(int.class);
 			js.append("[][] ");
-			js.append(classIndex2allClassIndexes);
+			js.append(transformationAnalysis.getClassIndex2allClassIndexesName());
 			js.append(" = new ");
 			js.appendClassReference(int.class);
 			js.append("[][] {\n");
 			js.pushIndentation(null);
-			for (int i = 0; i < sortedList.size(); i++) {
-				org.eclipse.ocl.pivot.Class instancesClass = sortedList.get(i);
-				List<org.eclipse.ocl.pivot.Class> superInstancesClasses = instancesClassAnalysis.get(instancesClass);
+			for (int i = 0; i < classIndex2classId.length; i++) {
+				ClassId instancesClassId = classIndex2classId[i];
+				List<ClassId> superInstancesClassIds = instancesClassAnalysis.get(instancesClassId);
 				js.append("{");
 				boolean isFirst = true;
-				for (org.eclipse.ocl.pivot.Class superInstancesClass : superInstancesClasses) {
+				for (ClassId superInstancesClassId : superInstancesClassIds) {
 					if (!isFirst) {
 						js.append(",");
 					}
-					js.append("" + instancesClass2index.get(superInstancesClass));
+					js.append("" + allInstancesClassId2classIndex.get(superInstancesClassId));
 					isFirst = false;
 				}
 				js.append("}");
-				if ((i+1) < sortedList.size()) {
+				if ((i+1) < classIndex2classId.length) {
 					js.append(",");
 				}
 				js.append("\t\t// " + i + " : ");
-				js.append(instancesClass.getName());
+				js.append(instancesClassId.getDisplayName());
 				js.append(" -> {");
 				isFirst = true;
-				for (org.eclipse.ocl.pivot.Class superInstancesClass : superInstancesClasses) {
+				for (ClassId superInstancesClassId : superInstancesClassIds) {
 					if (!isFirst) {
 						js.append(",");
 					}
-					js.append(superInstancesClass.getName());
+					js.append(superInstancesClassId.getDisplayName());
 					isFirst = false;
 				}
 				js.append("}\n");
 			}
 			js.popIndentation();
 			js.append("};\n");
-			return new String[]{ classIndex2classIdName, classIndex2allClassIndexes};
+			return new String[]{ transformationAnalysis.getClassIndex2classIdName(), transformationAnalysis.getClassIndex2allClassIndexesName()};
 		}
 		return null;
     }
@@ -306,7 +355,7 @@
 		}
     }
     
-	protected @Nullable String doOppositeCaches(@NonNull QVTiTransformationAnalysis transformationAnalysis) {
+	protected @Nullable String doOppositeCaches() {
 		Map<Property, Integer> opposites = transformationAnalysis.getOpposites();
 		if (opposites.size() <= 0) {
 			return null;
@@ -982,9 +1031,7 @@
 
 	@Override
 	public @NonNull Boolean visitCGTransformation(@NonNull CGTransformation cgTransformation) {		
-		QVTiTransformationAnalysis transformationAnalysis = new QVTiTransformationAnalysis(getMetamodelManager());
-		@SuppressWarnings("null")@NonNull Transformation transformation = (Transformation) cgTransformation.getAst();
-		transformationAnalysis.analyzeTransformation(transformation);
+		transformationAnalysis = new MyTransformationAnalysis(getMetamodelManager(), cgTransformation);
 		String className = cgTransformation.getName();
 		js.append("/**\n");
 		js.append(" * The " + className + " transformation:\n");
@@ -1011,9 +1058,9 @@
 		}
 		doMiddleOppositeCaches();
 		js.append("\n");
-		String oppositeName = doOppositeCaches(transformationAnalysis);
+		String oppositeName = doOppositeCaches();
 		js.append("\n");
-		String[] allInstancesNames = doAllInstances(transformationAnalysis);
+		String[] allInstancesNames = doAllInstances();
 		js.append("\n");
 		doConstructor(cgTransformation, oppositeName, allInstancesNames);
 		js.append("\n");
@@ -1028,6 +1075,7 @@
 		}
 		js.popIndentation();
 		js.append("}\n");
+		transformationAnalysis = null;
 		return true;
 	}
 
diff --git a/plugins/org.eclipse.qvtd.pivot.qvtbase/src/org/eclipse/qvtd/pivot/qvtbase/evaluation/AbstractTransformationExecutor.java b/plugins/org.eclipse.qvtd.pivot.qvtbase/src/org/eclipse/qvtd/pivot/qvtbase/evaluation/AbstractTransformationExecutor.java
index be4c259..6419173 100644
--- a/plugins/org.eclipse.qvtd.pivot.qvtbase/src/org/eclipse/qvtd/pivot/qvtbase/evaluation/AbstractTransformationExecutor.java
+++ b/plugins/org.eclipse.qvtd.pivot.qvtbase/src/org/eclipse/qvtd/pivot/qvtbase/evaluation/AbstractTransformationExecutor.java
@@ -43,6 +43,10 @@
 	protected final @NonNull IdResolver idResolver;
 	protected final @NonNull List<EObject>[] modelObjects;
 	protected final @NonNull Map<String, Integer> modelIndexes = new HashMap<String, Integer>();
+	/**
+	 * All possible allInstances() returns indexed by the ClassIndex of the ClassId for which allInstances() may be invoked.
+	 */
+	protected final @NonNull Set<EObject>[] classIndex2objects;
 
 	/**
 	 * Unchanging configured list PropertyId for which unnavigable opposite navigation may occur indexed by the PropertyIndex for that PropertyId.
@@ -77,10 +81,6 @@
 	 */
 	private final @Nullable Map<ClassId, Set<Integer>> classId2classIndexes;
 
-	/**
-	 * All possible allInstances() returns indexed by the ClassIndex of the ClassId for which allInstances() may be invoked.
-	 */
-	private final @Nullable Set<EObject>[] classIndex2objects;
 	
 	protected AbstractTransformationExecutor(@NonNull Evaluator evaluator, @NonNull String[] modelNames,
 			@Nullable PropertyId[] propertyIndex2propertyId, @Nullable ClassId[] classIndex2classId, @Nullable int[][] classIndex2allClassIndexes) {
@@ -142,7 +142,8 @@
 		else {
 	    	this.classId2classIndex = null;
 	    	this.classId2classIndexes = null;
-	    	this.classIndex2objects = null;
+			@SuppressWarnings("unchecked")Set<EObject>[] classIndex2objects = (Set<EObject>[]) new HashSet<?>[0];
+			this.classIndex2objects = classIndex2objects;
 		}
 	}
 
@@ -204,7 +205,7 @@
     	Map<EClass, Set<Integer>> eClass2allClassIndexes = null;
 		Map<EClass, List<Integer>> eClass2allPropertyIndexes = null;
 		Map<EReference, Integer> eReference2propertyIndex = null;
-		if ((classId2classIndexes != null) && (classIndex2objects != null)) {
+		if (classId2classIndexes != null) {
 			eClass2allClassIndexes = new HashMap<EClass, Set<Integer>>();
 		}
 		if (propertyIndex2propertyId != null) {
@@ -237,7 +238,7 @@
 	public @NonNull Set<EObject> get(@NonNull org.eclipse.ocl.pivot.Class type) {
 		Map<ClassId, Integer> classId2classIndex2 = classId2classIndex;
 		Set<EObject>[] classIndex2objects2 = classIndex2objects;
-		if ((classId2classIndex2 == null) || (classIndex2objects2 == null)) {
+		if (classId2classIndex2 == null) {
 			throw new IllegalArgumentException("No allInstances() support");
 		}
 		ClassId classId = IdManager.getClassId(type);
diff --git a/plugins/org.eclipse.qvtd.pivot.qvtimperative/META-INF/MANIFEST.MF b/plugins/org.eclipse.qvtd.pivot.qvtimperative/META-INF/MANIFEST.MF
index abeff01..dedfbe3 100644
--- a/plugins/org.eclipse.qvtd.pivot.qvtimperative/META-INF/MANIFEST.MF
+++ b/plugins/org.eclipse.qvtd.pivot.qvtimperative/META-INF/MANIFEST.MF
@@ -15,7 +15,8 @@
  org.eclipse.qvtd.pivot.qvtimperative.util,
  org.eclipse.qvtd.pivot.qvtimperative.utilities
 Require-Bundle: org.eclipse.core.runtime;bundle-version="[3.5.0,4.0.0)",
- org.eclipse.qvtd.pivot.qvtcorebase;visibility:=reexport
+ org.eclipse.qvtd.pivot.qvtcorebase;visibility:=reexport,
+ org.eclipse.ocl.pivot
 Bundle-ActivationPolicy: lazy
 Import-Package: com.google.inject,
  org.apache.log4j;version="1.2.15"
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
index b7bfa3a..04ec371 100644
--- 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
@@ -11,6 +11,7 @@
 package org.eclipse.qvtd.pivot.qvtimperative.evaluation;
 
 import java.util.ArrayList;
+import java.util.Collections;
 import java.util.HashMap;
 import java.util.HashSet;
 import java.util.List;
@@ -20,6 +21,7 @@
 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.CompleteClass;
 import org.eclipse.ocl.pivot.OCLExpression;
 import org.eclipse.ocl.pivot.Operation;
@@ -27,8 +29,11 @@
 import org.eclipse.ocl.pivot.OppositePropertyCallExp;
 import org.eclipse.ocl.pivot.Property;
 import org.eclipse.ocl.pivot.Type;
+import org.eclipse.ocl.pivot.ids.ClassId;
+import org.eclipse.ocl.pivot.ids.ElementId;
 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.internal.manager.MetamodelManager;
 import org.eclipse.qvtd.pivot.qvtbase.Transformation;
 import org.eclipse.qvtd.pivot.qvtimperative.MiddlePropertyAssignment;
@@ -54,6 +59,11 @@
 	private @NonNull Set<org.eclipse.ocl.pivot.Class> allInstancesClasses = new HashSet<org.eclipse.ocl.pivot.Class>();
 
 	/**
+	 *  Mapping from all the ClassIds of all types for which allInstnaces() may be invoked to a distinct class-index.
+	 */
+	private @Nullable Map<ClassId, Integer> allInstancesClassId2classIndex = null;
+
+	/**
 	 *  Map from navigable property to sequential index.
 	 */
 	private @NonNull Map<Property, Integer> property2cacheIndex = new HashMap<Property, Integer>();
@@ -130,6 +140,29 @@
 		return allInstancesClasses;
 	}
 	
+	public @NonNull Map<ClassId, Integer> getAllInstancesClassId2classIndex() {
+		Map<ClassId, Integer> allInstancesClassId2classIndex2 = allInstancesClassId2classIndex;
+		if (allInstancesClassId2classIndex2 == null) {
+			allInstancesClassId2classIndex = allInstancesClassId2classIndex2 = new HashMap<ClassId, Integer>();
+			List<ClassId> classIds = new ArrayList<ClassId>();
+			for (org.eclipse.ocl.pivot.Class asClass : getAllInstancesClasses()) {
+				TypeId typeId = asClass.getTypeId();
+				if (typeId instanceof ClassId) {
+					classIds.add((ClassId) typeId);
+				}
+			}
+			Collections.sort(classIds, ElementId.ElementIdComparator.INSTANCE);
+			for (int i = 0; i < classIds.size(); i++) {
+				allInstancesClassId2classIndex2.put(classIds.get(i),  i);
+			}
+		}
+		return allInstancesClassId2classIndex2;
+	}
+	
+	public @Nullable Integer getAllInstancesClassIndex(@NonNull ClassId classId) {
+		return getAllInstancesClassId2classIndex().get(classId);
+	}
+	
 	protected int getCacheIndex(@NonNull Property navigableProperty) {
 		Integer cacheIndex = property2cacheIndex.get(navigableProperty);
 		if (cacheIndex == null) { 
@@ -146,22 +179,23 @@
 	/**
 	 * Return a Map from each instanceClasses to the subset of instanceClasses that are transitive superClasses of the particular instanceClass.
 	 */
-	public @NonNull Map<org.eclipse.ocl.pivot.Class, List<org.eclipse.ocl.pivot.Class>> getInstancesClassAnalysis(@NonNull Iterable<org.eclipse.ocl.pivot.Class> instanceClasses) {
-		Map<org.eclipse.ocl.pivot.Class, List<org.eclipse.ocl.pivot.Class>> instancesClassAnalysis = new HashMap<org.eclipse.ocl.pivot.Class, List<org.eclipse.ocl.pivot.Class>>();
+	public @NonNull Map<ClassId, List<ClassId>> getInstancesClassAnalysis(@NonNull Iterable<org.eclipse.ocl.pivot.Class> instanceClasses) {
+		Map<ClassId, List<ClassId>> instancesClassAnalysis = new HashMap<ClassId, List<ClassId>>();
 		for (@SuppressWarnings("null")@NonNull org.eclipse.ocl.pivot.Class instanceClass : instanceClasses) {
 			CompleteClass completeInstanceClass = metamodelManager.getCompleteClass(instanceClass);
-			instancesClassAnalysis.put(completeInstanceClass.getPivotClass(),  null);
+			instancesClassAnalysis.put((ClassId) completeInstanceClass.getPivotClass().getTypeId(),  null);
 		}
-		for (@SuppressWarnings("null")@NonNull org.eclipse.ocl.pivot.Class instanceClass : instancesClassAnalysis.keySet()) {
-			List<org.eclipse.ocl.pivot.Class> superInstanceClasses = new ArrayList<org.eclipse.ocl.pivot.Class>();
-			superInstanceClasses.add(instanceClass);
+		for (@SuppressWarnings("null")@NonNull org.eclipse.ocl.pivot.Class instanceClass : instanceClasses) {
+			List<ClassId> superInstanceClassIds = new ArrayList<ClassId>();
+			ClassId instanceClassId = (ClassId)instanceClass.getTypeId();
+			superInstanceClassIds.add(instanceClassId);
 			CompleteClass completeClass = metamodelManager.getCompleteClass(instanceClass);
 			for (CompleteClass superCompleteClass : completeClass.getProperSuperCompleteClasses()) {
 				org.eclipse.ocl.pivot.Class superClass = superCompleteClass.getPivotClass();
 				if (instancesClassAnalysis.containsKey(superClass)) {
-					superInstanceClasses.add(superClass);
+					superInstanceClassIds.add((ClassId) superClass.getTypeId());
 				}
-				instancesClassAnalysis.put(instanceClass, superInstanceClasses);
+				instancesClassAnalysis.put(instanceClassId, superInstanceClassIds);
 			}
 		}
 		return instancesClassAnalysis;
diff --git a/tests/org.eclipse.qvtd.xtext.qvtimperative.tests/src-gen/cg/classescs2as.java b/tests/org.eclipse.qvtd.xtext.qvtimperative.tests/src-gen/cg/classescs2as.java
index 65e9179..65aa0c7 100644
--- a/tests/org.eclipse.qvtd.xtext.qvtimperative.tests/src-gen/cg/classescs2as.java
+++ b/tests/org.eclipse.qvtd.xtext.qvtimperative.tests/src-gen/cg/classescs2as.java
@@ -166,6 +166,7 @@
             final /*@Thrown*/ ClassCS2Class c2c_0 = ClassescstracesFactory.eINSTANCE.createClassCS2Class();
             assert c2c_0 != null;
             modelObjects[2/*middle*/].add(c2c_0);
+            classIndex2objects[2/*ClassCS2Class*/].add(c2c_0);
             // assignments
             c2c_0.setClassCS(classCS);
             OPPOSITE_OF_ClassCS2Class_classCS.put(classCS, c2c_0);
@@ -205,6 +206,7 @@
             final /*@Thrown*/ RootCS2Root r2r_0 = ClassescstracesFactory.eINSTANCE.createRootCS2Root();
             assert r2r_0 != null;
             modelObjects[2/*middle*/].add(r2r_0);
+            classIndex2objects[8/*RootCS2Root*/].add(r2r_0);
             // assignments
             r2r_0.setRootCS(rootCS);
             OPPOSITE_OF_RootCS2Root_rootCS.put(rootCS, r2r_0);
@@ -244,6 +246,7 @@
             final /*@Thrown*/ PackageCS2Package p2p_0 = ClassescstracesFactory.eINSTANCE.createPackageCS2Package();
             assert p2p_0 != null;
             modelObjects[2/*middle*/].add(p2p_0);
+            classIndex2objects[5/*PackageCS2Package*/].add(p2p_0);
             // assignments
             p2p_0.setPackageCS(packageCS);
             OPPOSITE_OF_PackageCS2Package_packageCS.put(packageCS, p2p_0);
@@ -283,6 +286,7 @@
             final /*@Thrown*/ classes.Class symbol_3 = ClassesFactory.eINSTANCE.createClass();
             assert symbol_3 != null;
             modelObjects[1/*rightAS*/].add(symbol_3);
+            classIndex2objects[0/*Class*/].add(symbol_3);
             // assignments
             c2c.setClass(symbol_3);
             // mapping statements
@@ -321,6 +325,7 @@
             final /*@Thrown*/ Root root_0 = ClassesFactory.eINSTANCE.createRoot();
             assert root_0 != null;
             modelObjects[1/*rightAS*/].add(root_0);
+            classIndex2objects[6/*Root*/].add(root_0);
             // assignments
             r2r.setRoot(root_0);
             // mapping statements
@@ -359,6 +364,7 @@
             final /*@Thrown*/ Package symbol_3 = ClassesFactory.eINSTANCE.createPackage();
             assert symbol_3 != null;
             modelObjects[1/*rightAS*/].add(symbol_3);
+            classIndex2objects[3/*Package*/].add(symbol_3);
             // assignments
             p2p.setPackage(symbol_3);
             // mapping statements