Index: branches/DataPreprocessing/HeuristicLab.Problems.VehicleRouting/3.4/Encodings/Alba/Creators/AlbaCreator.cs
===================================================================
--- branches/DataPreprocessing/HeuristicLab.Problems.VehicleRouting/3.4/Encodings/Alba/Creators/AlbaCreator.cs	(revision 10085)
+++ branches/DataPreprocessing/HeuristicLab.Problems.VehicleRouting/3.4/Encodings/Alba/Creators/AlbaCreator.cs	(revision 10538)
@@ -45,8 +45,8 @@
     }
 
-    public override IOperation Apply() {
+    public override IOperation InstrumentedApply() {
       (VRPToursParameter.ActualValue as AlbaEncoding).Repair();
 
-      return base.Apply();
+      return base.InstrumentedApply();
     }
   }
Index: branches/DataPreprocessing/HeuristicLab.Problems.VehicleRouting/3.4/Encodings/Alba/Creators/RandomCreator.cs
===================================================================
--- branches/DataPreprocessing/HeuristicLab.Problems.VehicleRouting/3.4/Encodings/Alba/Creators/RandomCreator.cs	(revision 10085)
+++ branches/DataPreprocessing/HeuristicLab.Problems.VehicleRouting/3.4/Encodings/Alba/Creators/RandomCreator.cs	(revision 10538)
@@ -86,9 +86,9 @@
     }
 
-    public override IOperation Apply() {
+    public override IOperation InstrumentedApply() {
       //choose default encoding here
       VRPToursParameter.ActualValue = AlbaEncoding.ConvertFrom(CreateSolution(), ProblemInstance);
 
-      return base.Apply();
+      return base.InstrumentedApply();
     }
   }
Index: branches/DataPreprocessing/HeuristicLab.Problems.VehicleRouting/3.4/Encodings/Alba/Crossovers/AlbaCrossover.cs
===================================================================
--- branches/DataPreprocessing/HeuristicLab.Problems.VehicleRouting/3.4/Encodings/Alba/Crossovers/AlbaCrossover.cs	(revision 10085)
+++ branches/DataPreprocessing/HeuristicLab.Problems.VehicleRouting/3.4/Encodings/Alba/Crossovers/AlbaCrossover.cs	(revision 10538)
@@ -52,5 +52,5 @@
     protected abstract AlbaEncoding Crossover(IRandom random, AlbaEncoding parent1, AlbaEncoding parent2);
 
-    public override IOperation Apply() {
+    public override IOperation InstrumentedApply() {
       ItemArray<IVRPEncoding> parents = new ItemArray<IVRPEncoding>(ParentsParameter.ActualValue.Length);
       for (int i = 0; i < ParentsParameter.ActualValue.Length; i++) {
@@ -69,5 +69,5 @@
       (ChildParameter.ActualValue as AlbaEncoding).Repair();
 
-      return base.Apply();
+      return base.InstrumentedApply();
     }
   }
Index: branches/DataPreprocessing/HeuristicLab.Problems.VehicleRouting/3.4/Encodings/Alba/LocalImprovement/AlbaLambdaInterchangeLocalImprovementOperator.cs
===================================================================
--- branches/DataPreprocessing/HeuristicLab.Problems.VehicleRouting/3.4/Encodings/Alba/LocalImprovement/AlbaLambdaInterchangeLocalImprovementOperator.cs	(revision 10085)
+++ branches/DataPreprocessing/HeuristicLab.Problems.VehicleRouting/3.4/Encodings/Alba/LocalImprovement/AlbaLambdaInterchangeLocalImprovementOperator.cs	(revision 10538)
@@ -125,5 +125,5 @@
     }
 
-    public override IOperation Apply() {
+    public override IOperation InstrumentedApply() {
       int maxIterations = MaximumIterationsParameter.ActualValue.Value;
       AlbaEncoding solution = null;
@@ -146,5 +146,5 @@
       QualityParameter.ActualValue.Value = quality;
 
-      return base.Apply();
+      return base.InstrumentedApply();
     }
   }
Index: branches/DataPreprocessing/HeuristicLab.Problems.VehicleRouting/3.4/Encodings/Alba/Manipulators/AlbaManipulator.cs
===================================================================
--- branches/DataPreprocessing/HeuristicLab.Problems.VehicleRouting/3.4/Encodings/Alba/Manipulators/AlbaManipulator.cs	(revision 10085)
+++ branches/DataPreprocessing/HeuristicLab.Problems.VehicleRouting/3.4/Encodings/Alba/Manipulators/AlbaManipulator.cs	(revision 10538)
@@ -62,5 +62,5 @@
     }
 
-    public override IOperation Apply() {
+    public override IOperation InstrumentedApply() {
       IVRPEncoding solution = VRPToursParameter.ActualValue;
       if (!(solution is AlbaEncoding)) {
@@ -71,5 +71,5 @@
       (VRPToursParameter.ActualValue as AlbaEncoding).Repair();
 
-      return base.Apply();
+      return base.InstrumentedApply();
     }
   }
Index: branches/DataPreprocessing/HeuristicLab.Problems.VehicleRouting/3.4/Encodings/Alba/Moves/AlbaMoveGenerator.cs
===================================================================
--- branches/DataPreprocessing/HeuristicLab.Problems.VehicleRouting/3.4/Encodings/Alba/Moves/AlbaMoveGenerator.cs	(revision 10085)
+++ branches/DataPreprocessing/HeuristicLab.Problems.VehicleRouting/3.4/Encodings/Alba/Moves/AlbaMoveGenerator.cs	(revision 10538)
@@ -41,5 +41,5 @@
     }
 
-    public override IOperation Apply() {
+    public override IOperation InstrumentedApply() {
       IVRPEncoding solution = VRPToursParameter.ActualValue;
       if (!(solution is AlbaEncoding)) {
@@ -47,5 +47,5 @@
       }
 
-      return base.Apply();
+      return base.InstrumentedApply();
     }
   }
Index: branches/DataPreprocessing/HeuristicLab.Problems.VehicleRouting/3.4/Encodings/Alba/Moves/IntraRouteInversion/AlbaIntraRouteInversionMoveGenerator.cs
===================================================================
--- branches/DataPreprocessing/HeuristicLab.Problems.VehicleRouting/3.4/Encodings/Alba/Moves/IntraRouteInversion/AlbaIntraRouteInversionMoveGenerator.cs	(revision 10085)
+++ branches/DataPreprocessing/HeuristicLab.Problems.VehicleRouting/3.4/Encodings/Alba/Moves/IntraRouteInversion/AlbaIntraRouteInversionMoveGenerator.cs	(revision 10538)
@@ -58,6 +58,6 @@
     protected abstract AlbaIntraRouteInversionMove[] GenerateMoves(AlbaEncoding individual, IVRPProblemInstance problemInstance);
 
-    public override IOperation Apply() {
-      IOperation next = base.Apply();
+    public override IOperation InstrumentedApply() {
+      IOperation next = base.InstrumentedApply();
 
       AlbaEncoding individual = VRPToursParameter.ActualValue as AlbaEncoding;
Index: branches/DataPreprocessing/HeuristicLab.Problems.VehicleRouting/3.4/Encodings/Alba/Moves/LambdaInterchange/AlbaLambdaInterchangeMoveGenerator.cs
===================================================================
--- branches/DataPreprocessing/HeuristicLab.Problems.VehicleRouting/3.4/Encodings/Alba/Moves/LambdaInterchange/AlbaLambdaInterchangeMoveGenerator.cs	(revision 10085)
+++ branches/DataPreprocessing/HeuristicLab.Problems.VehicleRouting/3.4/Encodings/Alba/Moves/LambdaInterchange/AlbaLambdaInterchangeMoveGenerator.cs	(revision 10538)
@@ -68,6 +68,6 @@
     protected abstract AlbaLambdaInterchangeMove[] GenerateMoves(AlbaEncoding individual, IVRPProblemInstance problemInstance, int lambda);
 
-    public override IOperation Apply() {
-      IOperation next = base.Apply();
+    public override IOperation InstrumentedApply() {
+      IOperation next = base.InstrumentedApply();
 
       AlbaEncoding individual = VRPToursParameter.ActualValue as AlbaEncoding;
Index: branches/DataPreprocessing/HeuristicLab.Problems.VehicleRouting/3.4/Encodings/Alba/Moves/ThreeOpt/AlbaStochasticTranslocationSingleMoveGenerator.cs
===================================================================
--- branches/DataPreprocessing/HeuristicLab.Problems.VehicleRouting/3.4/Encodings/Alba/Moves/ThreeOpt/AlbaStochasticTranslocationSingleMoveGenerator.cs	(revision 10085)
+++ branches/DataPreprocessing/HeuristicLab.Problems.VehicleRouting/3.4/Encodings/Alba/Moves/ThreeOpt/AlbaStochasticTranslocationSingleMoveGenerator.cs	(revision 10538)
@@ -69,6 +69,6 @@
     }
 
-    public override IOperation Apply() {
-      IOperation next = base.Apply();
+    public override IOperation InstrumentedApply() {
+      IOperation next = base.InstrumentedApply();
 
       IVRPEncoding solution = VRPToursParameter.ActualValue;
Index: branches/DataPreprocessing/HeuristicLab.Problems.VehicleRouting/3.4/Encodings/Alba/Moves/ThreeOpt/AlbaTranslocationMoveGenerator.cs
===================================================================
--- branches/DataPreprocessing/HeuristicLab.Problems.VehicleRouting/3.4/Encodings/Alba/Moves/ThreeOpt/AlbaTranslocationMoveGenerator.cs	(revision 10085)
+++ branches/DataPreprocessing/HeuristicLab.Problems.VehicleRouting/3.4/Encodings/Alba/Moves/ThreeOpt/AlbaTranslocationMoveGenerator.cs	(revision 10538)
@@ -93,6 +93,6 @@
     }
 
-    public override IOperation Apply() {
-      IOperation next = base.Apply();
+    public override IOperation InstrumentedApply() {
+      IOperation next = base.InstrumentedApply();
 
       IVRPEncoding solution = VRPToursParameter.ActualValue;
Index: branches/DataPreprocessing/HeuristicLab.Problems.VehicleRouting/3.4/Encodings/Alba/Moves/ThreeOpt/AlbaTranslocationMoveHardTabuCriterion.cs
===================================================================
--- branches/DataPreprocessing/HeuristicLab.Problems.VehicleRouting/3.4/Encodings/Alba/Moves/ThreeOpt/AlbaTranslocationMoveHardTabuCriterion.cs	(revision 10085)
+++ branches/DataPreprocessing/HeuristicLab.Problems.VehicleRouting/3.4/Encodings/Alba/Moves/ThreeOpt/AlbaTranslocationMoveHardTabuCriterion.cs	(revision 10538)
@@ -81,6 +81,6 @@
     }
 
-    public override IOperation Apply() {
-      IOperation next = base.Apply();
+    public override IOperation InstrumentedApply() {
+      IOperation next = base.InstrumentedApply();
 
       IVRPEncoding solution = VRPToursParameter.ActualValue;
Index: branches/DataPreprocessing/HeuristicLab.Problems.VehicleRouting/3.4/Encodings/Alba/Moves/ThreeOpt/AlbaTranslocationMoveSoftTabuCriterion.cs
===================================================================
--- branches/DataPreprocessing/HeuristicLab.Problems.VehicleRouting/3.4/Encodings/Alba/Moves/ThreeOpt/AlbaTranslocationMoveSoftTabuCriterion.cs	(revision 10085)
+++ branches/DataPreprocessing/HeuristicLab.Problems.VehicleRouting/3.4/Encodings/Alba/Moves/ThreeOpt/AlbaTranslocationMoveSoftTabuCriterion.cs	(revision 10538)
@@ -81,6 +81,6 @@
     }
 
-    public override IOperation Apply() {
-      IOperation next = base.Apply();
+    public override IOperation InstrumentedApply() {
+      IOperation next = base.InstrumentedApply();
 
       IVRPEncoding solution = VRPToursParameter.ActualValue;
Index: branches/DataPreprocessing/HeuristicLab.Problems.VehicleRouting/3.4/Encodings/Alba/Moves/ThreeOpt/AlbaTranslocationMoveTabuMaker.cs
===================================================================
--- branches/DataPreprocessing/HeuristicLab.Problems.VehicleRouting/3.4/Encodings/Alba/Moves/ThreeOpt/AlbaTranslocationMoveTabuMaker.cs	(revision 10085)
+++ branches/DataPreprocessing/HeuristicLab.Problems.VehicleRouting/3.4/Encodings/Alba/Moves/ThreeOpt/AlbaTranslocationMoveTabuMaker.cs	(revision 10538)
@@ -81,6 +81,6 @@
     }
 
-    public override IOperation Apply() {
-      IOperation next = base.Apply();
+    public override IOperation InstrumentedApply() {
+      IOperation next = base.InstrumentedApply();
 
       IVRPEncoding solution = VRPToursParameter.ActualValue;
Index: branches/DataPreprocessing/HeuristicLab.Problems.VehicleRouting/3.4/Encodings/GVR/Crossovers/GVRCrossover.cs
===================================================================
--- branches/DataPreprocessing/HeuristicLab.Problems.VehicleRouting/3.4/Encodings/GVR/Crossovers/GVRCrossover.cs	(revision 10085)
+++ branches/DataPreprocessing/HeuristicLab.Problems.VehicleRouting/3.4/Encodings/GVR/Crossovers/GVRCrossover.cs	(revision 10538)
@@ -103,5 +103,5 @@
     }
 
-    public override IOperation Apply() {
+    public override IOperation InstrumentedApply() {
       ItemArray<IVRPEncoding> parents = new ItemArray<IVRPEncoding>(ParentsParameter.ActualValue.Length);
       for (int i = 0; i < ParentsParameter.ActualValue.Length; i++) {
@@ -117,5 +117,5 @@
       ChildParameter.ActualValue = Crossover(RandomParameter.ActualValue, parents[0] as GVREncoding, parents[1] as GVREncoding);
 
-      return base.Apply();
+      return base.InstrumentedApply();
     }
   }
Index: branches/DataPreprocessing/HeuristicLab.Problems.VehicleRouting/3.4/Encodings/GVR/Manipulators/GVRManipulator.cs
===================================================================
--- branches/DataPreprocessing/HeuristicLab.Problems.VehicleRouting/3.4/Encodings/GVR/Manipulators/GVRManipulator.cs	(revision 10085)
+++ branches/DataPreprocessing/HeuristicLab.Problems.VehicleRouting/3.4/Encodings/GVR/Manipulators/GVRManipulator.cs	(revision 10538)
@@ -49,5 +49,5 @@
     protected abstract void Manipulate(IRandom random, GVREncoding individual);
 
-    public override IOperation Apply() {
+    public override IOperation InstrumentedApply() {
       IVRPEncoding solution = VRPToursParameter.ActualValue;
       if (!(solution is GVREncoding)) {
@@ -57,5 +57,5 @@
       Manipulate(RandomParameter.ActualValue, VRPToursParameter.ActualValue as GVREncoding);
 
-      return base.Apply();
+      return base.InstrumentedApply();
     }
   }
Index: branches/DataPreprocessing/HeuristicLab.Problems.VehicleRouting/3.4/Encodings/General/Creators/MultiVRPSolutionCreator.cs
===================================================================
--- branches/DataPreprocessing/HeuristicLab.Problems.VehicleRouting/3.4/Encodings/General/Creators/MultiVRPSolutionCreator.cs	(revision 10085)
+++ branches/DataPreprocessing/HeuristicLab.Problems.VehicleRouting/3.4/Encodings/General/Creators/MultiVRPSolutionCreator.cs	(revision 10538)
@@ -97,7 +97,7 @@
     }
 
-    public override IOperation Apply() {
+    public override IOperation InstrumentedApply() {
       if (Operators.Count == 0) throw new InvalidOperationException(Name + ": Please add at least one VRP creator to choose from.");
-      return base.Apply();
+      return base.InstrumentedApply();
     }
   }
Index: branches/DataPreprocessing/HeuristicLab.Problems.VehicleRouting/3.4/Encodings/General/Crossovers/BiasedMultiVRPSolutionCrossover.cs
===================================================================
--- branches/DataPreprocessing/HeuristicLab.Problems.VehicleRouting/3.4/Encodings/General/Crossovers/BiasedMultiVRPSolutionCrossover.cs	(revision 10085)
+++ branches/DataPreprocessing/HeuristicLab.Problems.VehicleRouting/3.4/Encodings/General/Crossovers/BiasedMultiVRPSolutionCrossover.cs	(revision 10538)
@@ -21,15 +21,14 @@
 
 using System;
-using System.Collections.Generic;
 using System.Linq;
-using System.Text;
+using HeuristicLab.Analysis;
+using HeuristicLab.Collections;
+using HeuristicLab.Common;
 using HeuristicLab.Core;
+using HeuristicLab.Data;
+using HeuristicLab.Optimization;
+using HeuristicLab.Parameters;
 using HeuristicLab.Persistence.Default.CompositeSerializers.Storable;
-using HeuristicLab.Common;
-using HeuristicLab.Analysis;
-using HeuristicLab.Parameters;
-using HeuristicLab.Optimization;
-using HeuristicLab.Data;
-using HeuristicLab.Collections;
+using HeuristicLab.Random;
 
 namespace HeuristicLab.Problems.VehicleRouting.Encodings.General {
@@ -69,4 +68,6 @@
       Parameters.Add(new ValueParameter<DoubleValue>("LowerBound", "The depth of the individuals in the scope tree.", new DoubleValue(0.01)));
       Parameters.Add(new ValueParameter<IntValue>("Depth", "The depth of the individuals in the scope tree.", new IntValue(1)));
+
+      SelectedOperatorParameter.ActualName = "SelectedCrossoverOperator";
     }
 
@@ -81,5 +82,5 @@
     }
 
-    public override IOperation Apply() {
+    public override IOperation InstrumentedApply() {
       IOperator successor = null;
 
@@ -133,5 +134,5 @@
       }
 
-      ////////////////
+      //////////////// code has to be duplicated since ActualProbabilitiesParameter.ActualValue are updated and used for operator selection
       IRandom random = RandomParameter.ActualValue;
       DoubleArray probabilities = ActualProbabilitiesParameter.ActualValue;
@@ -142,15 +143,5 @@
       if (checkedOperators.Count() > 0) {
         // select a random operator from the checked operators
-        double sum = (from indexedItem in checkedOperators select probabilities[indexedItem.Index]).Sum();
-        if (sum == 0) throw new InvalidOperationException(Name + ": All selected operators have zero probability.");
-        double r = random.NextDouble() * sum;
-        sum = 0;
-        foreach (var indexedItem in checkedOperators) {
-          sum += probabilities[indexedItem.Index];
-          if (sum > r) {
-            successor = indexedItem.Value;
-            break;
-          }
-        }
+        successor = checkedOperators.SampleProportional(random, 1, checkedOperators.Select(x => probabilities[x.Index]), false, false).First().Value;
       }
 
Index: branches/DataPreprocessing/HeuristicLab.Problems.VehicleRouting/3.4/Encodings/General/Crossovers/MultiVRPSolutionCrossover.cs
===================================================================
--- branches/DataPreprocessing/HeuristicLab.Problems.VehicleRouting/3.4/Encodings/General/Crossovers/MultiVRPSolutionCrossover.cs	(revision 10085)
+++ branches/DataPreprocessing/HeuristicLab.Problems.VehicleRouting/3.4/Encodings/General/Crossovers/MultiVRPSolutionCrossover.cs	(revision 10538)
@@ -67,4 +67,6 @@
       Parameters.Add(new LookupParameter<IVRPEncoding>("Child", "The child permutation resulting from the crossover."));
       ChildParameter.ActualName = "VRPTours";
+
+      SelectedOperatorParameter.ActualName = "SelectedCrossoverOperator";
     }
 
@@ -106,7 +108,7 @@
     }
 
-    public override IOperation Apply() {
+    public override IOperation InstrumentedApply() {
       if (Operators.Count == 0) throw new InvalidOperationException(Name + ": Please add at least one permutation crossover to choose from.");
-      return base.Apply();
+      return base.InstrumentedApply();
     }
   }
Index: branches/DataPreprocessing/HeuristicLab.Problems.VehicleRouting/3.4/Encodings/General/Crossovers/RandomParentCloneCrossover.cs
===================================================================
--- branches/DataPreprocessing/HeuristicLab.Problems.VehicleRouting/3.4/Encodings/General/Crossovers/RandomParentCloneCrossover.cs	(revision 10085)
+++ branches/DataPreprocessing/HeuristicLab.Problems.VehicleRouting/3.4/Encodings/General/Crossovers/RandomParentCloneCrossover.cs	(revision 10538)
@@ -65,5 +65,5 @@
     }
 
-    public override IOperation Apply() {
+    public override IOperation InstrumentedApply() {
       if (RandomParameter.ActualValue.Next() < 0.5)
         ChildParameter.ActualValue = ParentsParameter.ActualValue[0].Clone() as IVRPEncoding;
@@ -71,5 +71,5 @@
         ChildParameter.ActualValue = ParentsParameter.ActualValue[1].Clone() as IVRPEncoding;
 
-      return base.Apply();
+      return base.InstrumentedApply();
     }
   }
Index: branches/DataPreprocessing/HeuristicLab.Problems.VehicleRouting/3.4/Encodings/General/Manipulators/BiasedMultiVRPSolutionManipulator.cs
===================================================================
--- branches/DataPreprocessing/HeuristicLab.Problems.VehicleRouting/3.4/Encodings/General/Manipulators/BiasedMultiVRPSolutionManipulator.cs	(revision 10085)
+++ branches/DataPreprocessing/HeuristicLab.Problems.VehicleRouting/3.4/Encodings/General/Manipulators/BiasedMultiVRPSolutionManipulator.cs	(revision 10538)
@@ -21,15 +21,14 @@
 
 using System;
-using System.Collections.Generic;
 using System.Linq;
-using System.Text;
+using HeuristicLab.Analysis;
+using HeuristicLab.Collections;
+using HeuristicLab.Common;
 using HeuristicLab.Core;
+using HeuristicLab.Data;
+using HeuristicLab.Optimization;
+using HeuristicLab.Parameters;
 using HeuristicLab.Persistence.Default.CompositeSerializers.Storable;
-using HeuristicLab.Common;
-using HeuristicLab.Analysis;
-using HeuristicLab.Parameters;
-using HeuristicLab.Optimization;
-using HeuristicLab.Data;
-using HeuristicLab.Collections;
+using HeuristicLab.Random;
 
 namespace HeuristicLab.Problems.VehicleRouting.Encodings.General {
@@ -40,5 +39,5 @@
       get { return (ValueLookupParameter<DoubleArray>)Parameters["ActualProbabilities"]; }
     }
-    
+
     public ValueLookupParameter<StringValue> SuccessProgressAnalyisis {
       get { return (ValueLookupParameter<StringValue>)Parameters["SuccessProgressAnalysis"]; }
@@ -63,5 +62,5 @@
       : base() {
       Parameters.Add(new ValueLookupParameter<DoubleArray>("ActualProbabilities", "The array of relative probabilities for each operator."));
-      Parameters.Add(new ValueLookupParameter<StringValue>("SuccessProgressAnalysis", "The success progress analyisis to be considered", 
+      Parameters.Add(new ValueLookupParameter<StringValue>("SuccessProgressAnalysis", "The success progress analyisis to be considered",
         new StringValue("ExecutedMutationOperator")));
 
@@ -69,4 +68,6 @@
       Parameters.Add(new ValueParameter<DoubleValue>("LowerBound", "The depth of the individuals in the scope tree.", new DoubleValue(0.01)));
       Parameters.Add(new ValueParameter<IntValue>("Depth", "The depth of the individuals in the scope tree.", new IntValue(1)));
+
+      SelectedOperatorParameter.ActualName = "SelectedManipulationOperator";
     }
 
@@ -81,5 +82,5 @@
     }
 
-    public override IOperation Apply() {
+    public override IOperation InstrumentedApply() {
       IOperator successor = null;
 
@@ -133,5 +134,5 @@
       }
 
-      ////////////////
+      //////////////// code has to be duplicated since ActualProbabilitiesParameter.ActualValue are updated and used for operator selection
       IRandom random = RandomParameter.ActualValue;
       DoubleArray probabilities = ActualProbabilitiesParameter.ActualValue;
@@ -142,15 +143,6 @@
       if (checkedOperators.Count() > 0) {
         // select a random operator from the checked operators
-        double sum = (from indexedItem in checkedOperators select probabilities[indexedItem.Index]).Sum();
-        if (sum == 0) throw new InvalidOperationException(Name + ": All selected operators have zero probability.");
-        double r = random.NextDouble() * sum;
-        sum = 0;
-        foreach (var indexedItem in checkedOperators) {
-          sum += probabilities[indexedItem.Index];
-          if (sum > r) {
-            successor = indexedItem.Value;
-            break;
-          }
-        }
+        successor =
+          checkedOperators.SampleProportional(random, 1, checkedOperators.Select(x => probabilities[x.Index]), false, false).First().Value;
       }
 
Index: branches/DataPreprocessing/HeuristicLab.Problems.VehicleRouting/3.4/Encodings/General/Manipulators/MultiVRPSolutionManipulator.cs
===================================================================
--- branches/DataPreprocessing/HeuristicLab.Problems.VehicleRouting/3.4/Encodings/General/Manipulators/MultiVRPSolutionManipulator.cs	(revision 10085)
+++ branches/DataPreprocessing/HeuristicLab.Problems.VehicleRouting/3.4/Encodings/General/Manipulators/MultiVRPSolutionManipulator.cs	(revision 10538)
@@ -59,4 +59,6 @@
       Parameters.Add(new LookupParameter<IVRPProblemInstance>("ProblemInstance", "The VRP problem instance"));
       Parameters.Add(new LookupParameter<IVRPEncoding>("VRPTours", "The VRP tours to be manipulated."));
+
+      SelectedOperatorParameter.ActualName = "SelectedManipulationOperator";
     }
 
@@ -97,7 +99,7 @@
     }
 
-    public override IOperation Apply() {
+    public override IOperation InstrumentedApply() {
       if (Operators.Count == 0) throw new InvalidOperationException(Name + ": Please add at least one permutation manipulator to choose from.");
-      return base.Apply();
+      return base.InstrumentedApply();
     }
   }
Index: branches/DataPreprocessing/HeuristicLab.Problems.VehicleRouting/3.4/Encodings/General/Moves/MultiVRPMoveOperator/MultiVRPMoveEvaluator.cs
===================================================================
--- branches/DataPreprocessing/HeuristicLab.Problems.VehicleRouting/3.4/Encodings/General/Moves/MultiVRPMoveOperator/MultiVRPMoveEvaluator.cs	(revision 10085)
+++ branches/DataPreprocessing/HeuristicLab.Problems.VehicleRouting/3.4/Encodings/General/Moves/MultiVRPMoveOperator/MultiVRPMoveEvaluator.cs	(revision 10538)
@@ -53,5 +53,5 @@
     protected override void EvaluateMove() { }
 
-    public override IOperation Apply() {
+    public override IOperation InstrumentedApply() {
       IVRPMove move = VRPMoveParameter.ActualValue as IVRPMove;
 
@@ -59,5 +59,5 @@
       moveEvaluator.VRPMoveParameter.ActualName = VRPMoveParameter.Name;
 
-      OperationCollection next = new OperationCollection(base.Apply());
+      OperationCollection next = new OperationCollection(base.InstrumentedApply());
       next.Insert(0, ExecutionContext.CreateOperation(moveEvaluator));
 
Index: branches/DataPreprocessing/HeuristicLab.Problems.VehicleRouting/3.4/Encodings/General/Moves/MultiVRPMoveOperator/MultiVRPMoveGenerator.cs
===================================================================
--- branches/DataPreprocessing/HeuristicLab.Problems.VehicleRouting/3.4/Encodings/General/Moves/MultiVRPMoveOperator/MultiVRPMoveGenerator.cs	(revision 10085)
+++ branches/DataPreprocessing/HeuristicLab.Problems.VehicleRouting/3.4/Encodings/General/Moves/MultiVRPMoveOperator/MultiVRPMoveGenerator.cs	(revision 10538)
@@ -153,7 +153,7 @@
     }
 
-    public override IOperation Apply() {
+    public override IOperation InstrumentedApply() {
       if (Operators.Count == 0) throw new InvalidOperationException(Name + ": Please add at least one VRP move generator choose from.");
-      OperationCollection next = new OperationCollection(base.Apply());
+      OperationCollection next = new OperationCollection(base.InstrumentedApply());
 
       for (int i = 0; i < SelectedOperatorsParameter.ActualValue.Value; i++) {
Index: branches/DataPreprocessing/HeuristicLab.Problems.VehicleRouting/3.4/Encodings/General/Moves/VRPMoveEvaluator.cs
===================================================================
--- branches/DataPreprocessing/HeuristicLab.Problems.VehicleRouting/3.4/Encodings/General/Moves/VRPMoveEvaluator.cs	(revision 10085)
+++ branches/DataPreprocessing/HeuristicLab.Problems.VehicleRouting/3.4/Encodings/General/Moves/VRPMoveEvaluator.cs	(revision 10538)
@@ -76,8 +76,8 @@
     protected abstract void EvaluateMove();
 
-    public override IOperation Apply() {
+    public override IOperation InstrumentedApply() {
       EvaluateMove();
 
-      return base.Apply();
+      return base.InstrumentedApply();
     }
   }
Index: branches/DataPreprocessing/HeuristicLab.Problems.VehicleRouting/3.4/Encodings/General/Moves/VRPMoveMaker.cs
===================================================================
--- branches/DataPreprocessing/HeuristicLab.Problems.VehicleRouting/3.4/Encodings/General/Moves/VRPMoveMaker.cs	(revision 10085)
+++ branches/DataPreprocessing/HeuristicLab.Problems.VehicleRouting/3.4/Encodings/General/Moves/VRPMoveMaker.cs	(revision 10538)
@@ -99,9 +99,9 @@
     }
 
-    public override IOperation Apply() {
+    public override IOperation InstrumentedApply() {
       PerformMove();
       UpdateMoveEvaluation();
 
-      return base.Apply();
+      return base.InstrumentedApply();
     }
   }
Index: branches/DataPreprocessing/HeuristicLab.Problems.VehicleRouting/3.4/Encodings/Potvin/Creators/IterativeInsertionCreator.cs
===================================================================
--- branches/DataPreprocessing/HeuristicLab.Problems.VehicleRouting/3.4/Encodings/Potvin/Creators/IterativeInsertionCreator.cs	(revision 10085)
+++ branches/DataPreprocessing/HeuristicLab.Problems.VehicleRouting/3.4/Encodings/Potvin/Creators/IterativeInsertionCreator.cs	(revision 10538)
@@ -81,5 +81,5 @@
     }
 
-    private static PotvinEncoding CreateSolution(IVRPProblemInstance instance, IRandom random, bool adhereTimeWindows) {
+    public static PotvinEncoding CreateSolution(IVRPProblemInstance instance, IRandom random, bool adhereTimeWindows) {
       PotvinEncoding result = new PotvinEncoding(instance);
 
@@ -91,10 +91,10 @@
           customers.Add(i);
 
-      customers.Sort(delegate(int city1, int city2) {
-            double angle1 = CalculateAngleToDepot(instance, city1);
-            double angle2 = CalculateAngleToDepot(instance, city2);
+      customers.Sort((city1, city2) => {
+        double angle1 = CalculateAngleToDepot(instance, city1);
+        double angle2 = CalculateAngleToDepot(instance, city2);
 
-            return angle1.CompareTo(angle2);
-          });
+        return angle1.CompareTo(angle2);
+      });
 
       Tour currentTour = new Tour();
@@ -140,8 +140,8 @@
     }
 
-    public override IOperation Apply() {
+    public override IOperation InstrumentedApply() {
       VRPToursParameter.ActualValue = CreateSolution(ProblemInstance, RandomParameter.ActualValue, AdhereTimeWindowsParameter.Value.Value);
 
-      return base.Apply();
+      return base.InstrumentedApply();
     }
   }
Index: branches/DataPreprocessing/HeuristicLab.Problems.VehicleRouting/3.4/Encodings/Potvin/Creators/PushForwardInsertionCreator.cs
===================================================================
--- branches/DataPreprocessing/HeuristicLab.Problems.VehicleRouting/3.4/Encodings/Potvin/Creators/PushForwardInsertionCreator.cs	(revision 10085)
+++ branches/DataPreprocessing/HeuristicLab.Problems.VehicleRouting/3.4/Encodings/Potvin/Creators/PushForwardInsertionCreator.cs	(revision 10538)
@@ -373,10 +373,10 @@
     }
 
-    public override IOperation Apply() {
+    public override IOperation InstrumentedApply() {
       VRPToursParameter.ActualValue = CreateSolution(ProblemInstance, RandomParameter.ActualValue,
         Alpha.Value.Value, Beta.Value.Value, Gamma.Value.Value,
         AlphaVariance.Value.Value, BetaVariance.Value.Value, GammaVariance.Value.Value);
 
-      return base.Apply();
+      return base.InstrumentedApply();
     }
   }
Index: branches/DataPreprocessing/HeuristicLab.Problems.VehicleRouting/3.4/Encodings/Potvin/Crossovers/PotvinCrossover.cs
===================================================================
--- branches/DataPreprocessing/HeuristicLab.Problems.VehicleRouting/3.4/Encodings/Potvin/Crossovers/PotvinCrossover.cs	(revision 10085)
+++ branches/DataPreprocessing/HeuristicLab.Problems.VehicleRouting/3.4/Encodings/Potvin/Crossovers/PotvinCrossover.cs	(revision 10538)
@@ -144,5 +144,5 @@
     }
 
-    public override IOperation Apply() {
+    public override IOperation InstrumentedApply() {
       ItemArray<IVRPEncoding> parents = new ItemArray<IVRPEncoding>(ParentsParameter.ActualValue.Length);
       for (int i = 0; i < ParentsParameter.ActualValue.Length; i++) {
@@ -160,5 +160,5 @@
       (ChildParameter.ActualValue as PotvinEncoding).Repair();
 
-      return base.Apply();
+      return base.InstrumentedApply();
     }
   }
Index: branches/DataPreprocessing/HeuristicLab.Problems.VehicleRouting/3.4/Encodings/Potvin/Manipulators/PotvinLocalSearchManipulator.cs
===================================================================
--- branches/DataPreprocessing/HeuristicLab.Problems.VehicleRouting/3.4/Encodings/Potvin/Manipulators/PotvinLocalSearchManipulator.cs	(revision 10085)
+++ branches/DataPreprocessing/HeuristicLab.Problems.VehicleRouting/3.4/Encodings/Potvin/Manipulators/PotvinLocalSearchManipulator.cs	(revision 10538)
@@ -52,6 +52,6 @@
     }
 
-    private bool FindBetterInsertionPlace(
-      PotvinEncoding individual, int tour, int city, int length,
+    private static bool FindBetterInsertionPlace(
+      PotvinEncoding individual, IVRPProblemInstance instance, int tour, int city, int length,
       out int insertionTour, out int insertionPlace) {
       bool insertionFound = false;
@@ -70,5 +70,5 @@
           distance = individual.GetTourLength(individual.Tours[currentTour]);
           individual.Tours[currentTour].Stops.InsertRange(currentCity, toBeDeleted);
-          if (ProblemInstance.TourFeasible(individual.Tours[currentTour], individual)) {
+          if (instance.TourFeasible(individual.Tours[currentTour], individual)) {
             double lengthIncrease =
               individual.GetTourLength(individual.Tours[currentTour]) - distance;
@@ -92,7 +92,7 @@
     }
 
-    protected override void Manipulate(IRandom random, PotvinEncoding individual) {
+    public static void ApplyManipulation(IRandom random, PotvinEncoding individual, IVRPProblemInstance instance, int maxIterations) {
       //only apply to feasible individuals
-      if (ProblemInstance.Feasible(individual)) {
+      if (instance.Feasible(individual)) {
         bool insertionFound;
         int iterations = 0;
@@ -107,5 +107,5 @@
               while (city <= individual.Tours[tour].Stops.Count - length && !insertionFound) {
                 int insertionTour, insertionPlace;
-                if (FindBetterInsertionPlace(individual, tour, city, length,
+                if (FindBetterInsertionPlace(individual, instance, tour, city, length,
                  out insertionTour, out insertionPlace)) {
                   insertionFound = true;
@@ -126,5 +126,5 @@
           iterations++;
         } while (insertionFound &&
-          iterations < Iterations.Value.Value);
+          iterations < maxIterations);
 
         IList<Tour> toBeRemoved = new List<Tour>();
@@ -139,4 +139,9 @@
       }
     }
+ 
+
+    protected override void Manipulate(IRandom random, PotvinEncoding individual) {
+      ApplyManipulation(random, individual, ProblemInstance, Iterations.Value.Value);     
+    }
   }
 }
Index: branches/DataPreprocessing/HeuristicLab.Problems.VehicleRouting/3.4/Encodings/Potvin/Manipulators/PotvinManipulator.cs
===================================================================
--- branches/DataPreprocessing/HeuristicLab.Problems.VehicleRouting/3.4/Encodings/Potvin/Manipulators/PotvinManipulator.cs	(revision 10085)
+++ branches/DataPreprocessing/HeuristicLab.Problems.VehicleRouting/3.4/Encodings/Potvin/Manipulators/PotvinManipulator.cs	(revision 10538)
@@ -55,5 +55,5 @@
     protected abstract void Manipulate(IRandom random, PotvinEncoding individual);
 
-    protected int SelectRandomTourBiasedByLength(IRandom random, PotvinEncoding individual) {
+    protected static int SelectRandomTourBiasedByLength(IRandom random, PotvinEncoding individual, IVRPProblemInstance instance) {
       int tourIndex = -1;
 
@@ -61,5 +61,5 @@
       double[] probabilities = new double[individual.Tours.Count];
       for (int i = 0; i < individual.Tours.Count; i++) {
-        probabilities[i] = 1.0 / ((double)individual.Tours[i].Stops.Count / (double)ProblemInstance.Cities.Value);
+        probabilities[i] = 1.0 / ((double)individual.Tours[i].Stops.Count / (double)instance.Cities.Value);
         sum += probabilities[i];
       }
@@ -82,10 +82,10 @@
     }
 
-    protected bool FindInsertionPlace(PotvinEncoding individual, int city, int routeToAvoid, bool allowInfeasible, out int route, out int place) {
+    protected static bool FindInsertionPlace(PotvinEncoding individual, int city, int routeToAvoid, bool allowInfeasible, out int route, out int place) {
       return individual.FindInsertionPlace(
         city, routeToAvoid, allowInfeasible, out route, out place);
     }
 
-    public override IOperation Apply() {
+    public override IOperation InstrumentedApply() {
       IVRPEncoding solution = VRPToursParameter.ActualValue;
       if (!(solution is PotvinEncoding)) {
@@ -96,5 +96,5 @@
       (VRPToursParameter.ActualValue as PotvinEncoding).Repair();
 
-      return base.Apply();
+      return base.InstrumentedApply();
     }
   }
Index: branches/DataPreprocessing/HeuristicLab.Problems.VehicleRouting/3.4/Encodings/Potvin/Manipulators/PotvinOneLevelExchangeManipulator.cs
===================================================================
--- branches/DataPreprocessing/HeuristicLab.Problems.VehicleRouting/3.4/Encodings/Potvin/Manipulators/PotvinOneLevelExchangeManipulator.cs	(revision 10085)
+++ branches/DataPreprocessing/HeuristicLab.Problems.VehicleRouting/3.4/Encodings/Potvin/Manipulators/PotvinOneLevelExchangeManipulator.cs	(revision 10538)
@@ -23,4 +23,5 @@
 using HeuristicLab.Core;
 using HeuristicLab.Persistence.Default.CompositeSerializers.Storable;
+using HeuristicLab.Problems.VehicleRouting.Interfaces;
 
 namespace HeuristicLab.Problems.VehicleRouting.Encodings.Potvin {
@@ -41,8 +42,6 @@
     }
 
-    protected override void Manipulate(IRandom random, PotvinEncoding individual) {
-      bool allowInfeasible = AllowInfeasibleSolutions.Value.Value;
-
-      int selectedIndex = SelectRandomTourBiasedByLength(random, individual);
+    public static void ApplyManipulation(IRandom random, PotvinEncoding individual, IVRPProblemInstance instance, bool allowInfeasible) {
+      int selectedIndex = SelectRandomTourBiasedByLength(random, individual, instance);
       if (selectedIndex >= 0) {
         Tour route1 =
@@ -68,4 +67,9 @@
       }
     }
+
+    protected override void Manipulate(IRandom random, PotvinEncoding individual) {
+      bool allowInfeasible = AllowInfeasibleSolutions.Value.Value;
+      ApplyManipulation(random, individual, ProblemInstance, allowInfeasible);      
+    }
   }
 }
Index: branches/DataPreprocessing/HeuristicLab.Problems.VehicleRouting/3.4/Encodings/Potvin/Manipulators/PotvinPairwiseOneLevelExchangeManipulator.cs
===================================================================
--- branches/DataPreprocessing/HeuristicLab.Problems.VehicleRouting/3.4/Encodings/Potvin/Manipulators/PotvinPairwiseOneLevelExchangeManipulator.cs	(revision 10085)
+++ branches/DataPreprocessing/HeuristicLab.Problems.VehicleRouting/3.4/Encodings/Potvin/Manipulators/PotvinPairwiseOneLevelExchangeManipulator.cs	(revision 10538)
@@ -25,4 +25,5 @@
 using HeuristicLab.Problems.VehicleRouting.ProblemInstances;
 using HeuristicLab.Problems.VehicleRouting.Variants;
+using HeuristicLab.Problems.VehicleRouting.Interfaces;
 
 namespace HeuristicLab.Problems.VehicleRouting.Encodings.Potvin {
@@ -43,8 +44,8 @@
     }
 
-    public bool PairwiseMove(PotvinEncoding individual, int city, bool allowInfeasible) {
+    public static bool PairwiseMove(PotvinEncoding individual, IVRPProblemInstance instance, int city, bool allowInfeasible) {
       bool success;
 
-      IPickupAndDeliveryProblemInstance pdp = ProblemInstance as IPickupAndDeliveryProblemInstance;
+      IPickupAndDeliveryProblemInstance pdp = instance as IPickupAndDeliveryProblemInstance;
 
       if (pdp != null) {
@@ -64,5 +65,5 @@
 
         int source, target;
-        if (ProblemInstance.GetDemand(city) >= 0) {
+        if (instance.GetDemand(city) >= 0) {
           source = city;
           target = dest;
@@ -80,12 +81,12 @@
           if (tourIdx != routeToAvoid) {
             Tour tour = individual.Tours[tourIdx];
-            VRPEvaluation eval = ProblemInstance.EvaluateTour(tour, individual);
-            individual.InsertPair(tour, source, target, ProblemInstance);
-            VRPEvaluation evalNew = ProblemInstance.EvaluateTour(tour, individual);
+            VRPEvaluation eval = instance.EvaluateTour(tour, individual);
+            individual.InsertPair(tour, source, target, instance);
+            VRPEvaluation evalNew = instance.EvaluateTour(tour, individual);
 
             double delta = evalNew.Quality - eval.Quality;
 
             if (delta < bestQuality &&
-               (ProblemInstance.Feasible(evalNew) || allowInfeasible)) {
+               (instance.Feasible(evalNew) || allowInfeasible)) {
               bestQuality = delta;
               bestTour = tourIdx;
@@ -127,26 +128,32 @@
     }
 
+    public static void ApplyManipulation(IRandom random, PotvinEncoding individual, IPickupAndDeliveryProblemInstance pdp, bool allowInfeasible) {
+      int selectedIndex = SelectRandomTourBiasedByLength(random, individual, pdp);
+      if (selectedIndex >= 0) {
+        Tour route1 =
+          individual.Tours[selectedIndex];
+
+        int count = route1.Stops.Count;
+
+        if (count > 0) {
+          int i = random.Next(0, count);
+          int city = route1.Stops[i];
+
+          if (!PairwiseMove(individual, pdp, city, allowInfeasible))
+            i++;
+
+          count = route1.Stops.Count;
+        }
+      }
+    }
+
+
     protected override void Manipulate(IRandom random, PotvinEncoding individual) {
       bool allowInfeasible = AllowInfeasibleSolutions.Value.Value;
+
       IPickupAndDeliveryProblemInstance pdp = ProblemInstance as IPickupAndDeliveryProblemInstance;
 
       if (pdp != null) {
-        int selectedIndex = SelectRandomTourBiasedByLength(random, individual);
-        if (selectedIndex >= 0) {
-          Tour route1 =
-            individual.Tours[selectedIndex];
-
-          int count = route1.Stops.Count;
-
-          if (count > 0) {
-            int i = random.Next(0, count);
-            int city = route1.Stops[i];
-
-            if (!PairwiseMove(individual, city, allowInfeasible))
-              i++;
-
-            count = route1.Stops.Count;
-          }
-        }
+        ApplyManipulation(random, individual, pdp, allowInfeasible);
       }
     }
Index: branches/DataPreprocessing/HeuristicLab.Problems.VehicleRouting/3.4/Encodings/Potvin/Manipulators/PotvinPairwiseTwoLevelExchangeManipulator.cs
===================================================================
--- branches/DataPreprocessing/HeuristicLab.Problems.VehicleRouting/3.4/Encodings/Potvin/Manipulators/PotvinPairwiseTwoLevelExchangeManipulator.cs	(revision 10085)
+++ branches/DataPreprocessing/HeuristicLab.Problems.VehicleRouting/3.4/Encodings/Potvin/Manipulators/PotvinPairwiseTwoLevelExchangeManipulator.cs	(revision 10538)
@@ -26,4 +26,5 @@
 using HeuristicLab.Problems.VehicleRouting.ProblemInstances;
 using HeuristicLab.Problems.VehicleRouting.Variants;
+using HeuristicLab.Problems.VehicleRouting.Interfaces;
 
 namespace HeuristicLab.Problems.VehicleRouting.Encodings.Potvin {
@@ -44,7 +45,7 @@
     }
 
-    private PotvinEncoding ReplacePair(PotvinEncoding individual, int replaced, int replacing, bool allowInfeasible) {
+    private static PotvinEncoding ReplacePair(PotvinEncoding individual, IVRPProblemInstance instance, int replaced, int replacing, bool allowInfeasible) {
       individual = individual.Clone() as PotvinEncoding;
-      IPickupAndDeliveryProblemInstance pdp = ProblemInstance as IPickupAndDeliveryProblemInstance;
+      IPickupAndDeliveryProblemInstance pdp = instance as IPickupAndDeliveryProblemInstance;
 
       int replacedDest = pdp.GetPickupDeliveryLocation(replaced);
@@ -76,9 +77,9 @@
 
       replacedSourceTour.Stops[replacedSourceTour.Stops.IndexOf(replacedSource)] = replacingSource;
-      if (!allowInfeasible && !ProblemInstance.TourFeasible(replacedSourceTour, individual))
+      if (!allowInfeasible && !instance.TourFeasible(replacedSourceTour, individual))
         return null;
 
       replacedTargetTour.Stops[replacedTargetTour.Stops.IndexOf(replacedTarget)] = replacingTarget;
-      if (!allowInfeasible && !ProblemInstance.TourFeasible(replacedTargetTour, individual))
+      if (!allowInfeasible && !instance.TourFeasible(replacedTargetTour, individual))
         return null;
 
@@ -93,12 +94,12 @@
         if (tourIdx != routeToAvoid) {
           Tour tour = individual.Tours[tourIdx];
-          VRPEvaluation eval = ProblemInstance.EvaluateTour(tour, individual);
-          individual.InsertPair(tour, replacedSource, replacedTarget, ProblemInstance);
-          VRPEvaluation evalNew = ProblemInstance.EvaluateTour(tour, individual);
+          VRPEvaluation eval = instance.EvaluateTour(tour, individual);
+          individual.InsertPair(tour, replacedSource, replacedTarget, instance);
+          VRPEvaluation evalNew = instance.EvaluateTour(tour, individual);
 
           double delta = evalNew.Quality - eval.Quality;
 
           if (delta < bestQuality &&
-              (ProblemInstance.Feasible(evalNew) || allowInfeasible)) {
+              (instance.Feasible(evalNew) || allowInfeasible)) {
             bestQuality = delta;
             bestTour = tourIdx;
@@ -127,4 +128,58 @@
     }
 
+    public static PotvinEncoding ApplyManipulation(IRandom random, PotvinEncoding individual, IPickupAndDeliveryProblemInstance pdp, bool allowInfeasible) {
+      PotvinEncoding result = null;
+      
+      int selectedIndex = SelectRandomTourBiasedByLength(random, individual, pdp);
+      if (selectedIndex >= 0) {
+        bool performed = false;
+        Tour route1 = individual.Tours[selectedIndex];
+
+        if (route1.Stops.Count > 0) {
+          //randomize customer selection
+          Permutation perm = new Permutation(PermutationTypes.Absolute, route1.Stops.Count, random);
+          int customer1Position = 0;
+
+          while (customer1Position < route1.Stops.Count) {
+            performed = false;
+
+            int customer1 = route1.Stops[perm[customer1Position]];
+            int customer2 = -1;
+
+            for (int i = 0; i < individual.Tours.Count; i++) {
+              if (i != selectedIndex) {
+                Tour tour = individual.Tours[i];
+                for (int customer2Position = 0; customer2Position < tour.Stops.Count; customer2Position++) {
+                  customer2 = tour.Stops[customer2Position];
+
+                  if (pdp.GetPickupDeliveryLocation(customer1) != customer2) {
+                    result = ReplacePair(individual, pdp, customer2, customer1, allowInfeasible);
+                    if (result != null) {
+                      individual = result;
+
+                      route1 = individual.Tours[selectedIndex];
+                      performed = true;
+                      break;
+                    }
+                  }
+                }
+              }
+
+              if (performed) {
+                break;
+              }
+            }
+
+            if (!performed)
+              customer1Position++;
+            else
+              break;
+          }
+        }
+      }
+
+      return result;
+    }
+
     protected override void Manipulate(IRandom random, PotvinEncoding individual) {
       bool allowInfeasible = AllowInfeasibleSolutions.Value.Value;
@@ -132,52 +187,8 @@
 
       if (pdp != null) {
-        int selectedIndex = SelectRandomTourBiasedByLength(random, individual);
-        if (selectedIndex >= 0) {
-          bool performed = false;
-          Tour route1 = individual.Tours[selectedIndex];
-
-          if (route1.Stops.Count > 0) {
-            //randomize customer selection
-            Permutation perm = new Permutation(PermutationTypes.Absolute, route1.Stops.Count, random);
-            int customer1Position = 0;
-
-            while (customer1Position < route1.Stops.Count) {
-              performed = false;
-
-              int customer1 = route1.Stops[perm[customer1Position]];
-              int customer2 = -1;
-
-              for (int i = 0; i < individual.Tours.Count; i++) {
-                if (i != selectedIndex) {
-                  Tour tour = individual.Tours[i];
-                  for (int customer2Position = 0; customer2Position < tour.Stops.Count; customer2Position++) {
-                    customer2 = tour.Stops[customer2Position];
-
-                    if (pdp.GetPickupDeliveryLocation(customer1) != customer2) {
-                      PotvinEncoding result = ReplacePair(individual, customer2, customer1, allowInfeasible);
-                      if (result != null) {
-                        VRPToursParameter.ActualValue = result;
-                        individual = result;
-
-                        route1 = individual.Tours[selectedIndex];
-                        performed = true;
-                        break;
-                      }
-                    }
-                  }
-                }
-
-                if (performed) {
-                  break;
-                }
-              }
-
-              if (!performed)
-                customer1Position++;
-              else
-                break;
-            }
-          }
-        }
+        PotvinEncoding result = ApplyManipulation(random, individual, pdp, allowInfeasible);
+        if (result != null) {
+          VRPToursParameter.ActualValue = result;
+        }        
       }
     }
Index: branches/DataPreprocessing/HeuristicLab.Problems.VehicleRouting/3.4/Encodings/Potvin/Manipulators/PotvinTwoLevelExchangeManipulator.cs
===================================================================
--- branches/DataPreprocessing/HeuristicLab.Problems.VehicleRouting/3.4/Encodings/Potvin/Manipulators/PotvinTwoLevelExchangeManipulator.cs	(revision 10085)
+++ branches/DataPreprocessing/HeuristicLab.Problems.VehicleRouting/3.4/Encodings/Potvin/Manipulators/PotvinTwoLevelExchangeManipulator.cs	(revision 10538)
@@ -23,4 +23,5 @@
 using HeuristicLab.Core;
 using HeuristicLab.Persistence.Default.CompositeSerializers.Storable;
+using HeuristicLab.Problems.VehicleRouting.Interfaces;
 
 namespace HeuristicLab.Problems.VehicleRouting.Encodings.Potvin {
@@ -41,8 +42,6 @@
     }
 
-    protected override void Manipulate(IRandom random, PotvinEncoding individual) {
-      bool allowInfeasible = AllowInfeasibleSolutions.Value.Value;
-
-      int selectedIndex = SelectRandomTourBiasedByLength(random, individual);
+    public static void ApplyManipulation(IRandom random, PotvinEncoding individual, IVRPProblemInstance instance, bool allowInfeasible) {
+      int selectedIndex = SelectRandomTourBiasedByLength(random, individual, instance);
       if (selectedIndex >= 0) {
         Tour route1 = individual.Tours[selectedIndex];
@@ -63,5 +62,5 @@
                 route1.Stops.RemoveAt(customer1Position);
 
-                if (ProblemInstance.TourFeasible(tour, individual)) {
+                if (instance.TourFeasible(tour, individual)) {
                   int routeIdx, place;
                   if (FindInsertionPlace(individual,
@@ -92,4 +91,11 @@
       }
     }
+      
+
+    protected override void Manipulate(IRandom random, PotvinEncoding individual) {
+      bool allowInfeasible = AllowInfeasibleSolutions.Value.Value;
+
+      ApplyManipulation(random, individual, ProblemInstance, allowInfeasible);
+    }
   }
 }
Index: branches/DataPreprocessing/HeuristicLab.Problems.VehicleRouting/3.4/Encodings/Potvin/Manipulators/PotvinVehicleAssignmentManipulator.cs
===================================================================
--- branches/DataPreprocessing/HeuristicLab.Problems.VehicleRouting/3.4/Encodings/Potvin/Manipulators/PotvinVehicleAssignmentManipulator.cs	(revision 10085)
+++ branches/DataPreprocessing/HeuristicLab.Problems.VehicleRouting/3.4/Encodings/Potvin/Manipulators/PotvinVehicleAssignmentManipulator.cs	(revision 10538)
@@ -60,5 +60,5 @@
     }
 
-    public override IOperation Apply() {
+    public override IOperation InstrumentedApply() {
       IVRPEncoding solution = VRPToursParameter.ActualValue;
       if (!(solution is PotvinEncoding)) {
@@ -66,5 +66,5 @@
       }
 
-      OperationCollection next = new OperationCollection(base.Apply());
+      OperationCollection next = new OperationCollection(base.InstrumentedApply());
 
       VehicleAssignmentParameter.ActualValue = (VRPToursParameter.ActualValue as PotvinEncoding).VehicleAssignment;
Index: branches/DataPreprocessing/HeuristicLab.Problems.VehicleRouting/3.4/Encodings/Potvin/Moves/CustomerRelocation/PotvinCustomerRelocationMoveGenerator.cs
===================================================================
--- branches/DataPreprocessing/HeuristicLab.Problems.VehicleRouting/3.4/Encodings/Potvin/Moves/CustomerRelocation/PotvinCustomerRelocationMoveGenerator.cs	(revision 10085)
+++ branches/DataPreprocessing/HeuristicLab.Problems.VehicleRouting/3.4/Encodings/Potvin/Moves/CustomerRelocation/PotvinCustomerRelocationMoveGenerator.cs	(revision 10538)
@@ -57,6 +57,6 @@
     protected abstract PotvinCustomerRelocationMove[] GenerateMoves(PotvinEncoding individual, IVRPProblemInstance problemInstance);
 
-    public override IOperation Apply() {
-      IOperation next = base.Apply();
+    public override IOperation InstrumentedApply() {
+      IOperation next = base.InstrumentedApply();
 
       PotvinEncoding individual = VRPToursParameter.ActualValue as PotvinEncoding;
Index: branches/DataPreprocessing/HeuristicLab.Problems.VehicleRouting/3.4/Encodings/Potvin/Moves/PickupDelivery/PDExchange/PotvinPDExchangeMoveGenerator.cs
===================================================================
--- branches/DataPreprocessing/HeuristicLab.Problems.VehicleRouting/3.4/Encodings/Potvin/Moves/PickupDelivery/PDExchange/PotvinPDExchangeMoveGenerator.cs	(revision 10085)
+++ branches/DataPreprocessing/HeuristicLab.Problems.VehicleRouting/3.4/Encodings/Potvin/Moves/PickupDelivery/PDExchange/PotvinPDExchangeMoveGenerator.cs	(revision 10538)
@@ -57,6 +57,6 @@
     protected abstract PotvinPDExchangeMove[] GenerateMoves(PotvinEncoding individual, IVRPProblemInstance problemInstance);
 
-    public override IOperation Apply() {
-      IOperation next = base.Apply();
+    public override IOperation InstrumentedApply() {
+      IOperation next = base.InstrumentedApply();
 
       PotvinEncoding individual = VRPToursParameter.ActualValue as PotvinEncoding;
Index: branches/DataPreprocessing/HeuristicLab.Problems.VehicleRouting/3.4/Encodings/Potvin/Moves/PickupDelivery/PDRearrange/PotvinPDRearrangeMoveGenerator.cs
===================================================================
--- branches/DataPreprocessing/HeuristicLab.Problems.VehicleRouting/3.4/Encodings/Potvin/Moves/PickupDelivery/PDRearrange/PotvinPDRearrangeMoveGenerator.cs	(revision 10085)
+++ branches/DataPreprocessing/HeuristicLab.Problems.VehicleRouting/3.4/Encodings/Potvin/Moves/PickupDelivery/PDRearrange/PotvinPDRearrangeMoveGenerator.cs	(revision 10538)
@@ -57,6 +57,6 @@
     protected abstract PotvinPDRearrangeMove[] GenerateMoves(PotvinEncoding individual, IVRPProblemInstance problemInstance);
 
-    public override IOperation Apply() {
-      IOperation next = base.Apply();
+    public override IOperation InstrumentedApply() {
+      IOperation next = base.InstrumentedApply();
 
       PotvinEncoding individual = VRPToursParameter.ActualValue as PotvinEncoding;
Index: branches/DataPreprocessing/HeuristicLab.Problems.VehicleRouting/3.4/Encodings/Potvin/Moves/PickupDelivery/PDShift/PotvinPDShiftMoveGenerator.cs
===================================================================
--- branches/DataPreprocessing/HeuristicLab.Problems.VehicleRouting/3.4/Encodings/Potvin/Moves/PickupDelivery/PDShift/PotvinPDShiftMoveGenerator.cs	(revision 10085)
+++ branches/DataPreprocessing/HeuristicLab.Problems.VehicleRouting/3.4/Encodings/Potvin/Moves/PickupDelivery/PDShift/PotvinPDShiftMoveGenerator.cs	(revision 10538)
@@ -57,6 +57,6 @@
     protected abstract PotvinPDShiftMove[] GenerateMoves(PotvinEncoding individual, IVRPProblemInstance problemInstance);
 
-    public override IOperation Apply() {
-      IOperation next = base.Apply();
+    public override IOperation InstrumentedApply() {
+      IOperation next = base.InstrumentedApply();
 
       PotvinEncoding individual = VRPToursParameter.ActualValue as PotvinEncoding;
Index: branches/DataPreprocessing/HeuristicLab.Problems.VehicleRouting/3.4/Encodings/Potvin/Moves/PotvinMoveGenerator.cs
===================================================================
--- branches/DataPreprocessing/HeuristicLab.Problems.VehicleRouting/3.4/Encodings/Potvin/Moves/PotvinMoveGenerator.cs	(revision 10085)
+++ branches/DataPreprocessing/HeuristicLab.Problems.VehicleRouting/3.4/Encodings/Potvin/Moves/PotvinMoveGenerator.cs	(revision 10538)
@@ -41,5 +41,5 @@
     }
 
-    public override IOperation Apply() {
+    public override IOperation InstrumentedApply() {
       IVRPEncoding solution = VRPToursParameter.ActualValue;
       if (!(solution is PotvinEncoding)) {
@@ -47,5 +47,5 @@
       }
 
-      return base.Apply();
+      return base.InstrumentedApply();
     }
   }
Index: branches/DataPreprocessing/HeuristicLab.Problems.VehicleRouting/3.4/Encodings/Potvin/Moves/TwoOptStar/PotvinTwoOptStarMoveGenerator.cs
===================================================================
--- branches/DataPreprocessing/HeuristicLab.Problems.VehicleRouting/3.4/Encodings/Potvin/Moves/TwoOptStar/PotvinTwoOptStarMoveGenerator.cs	(revision 10085)
+++ branches/DataPreprocessing/HeuristicLab.Problems.VehicleRouting/3.4/Encodings/Potvin/Moves/TwoOptStar/PotvinTwoOptStarMoveGenerator.cs	(revision 10538)
@@ -57,6 +57,6 @@
     protected abstract PotvinTwoOptStarMove[] GenerateMoves(PotvinEncoding individual, IVRPProblemInstance problemInstance);
 
-    public override IOperation Apply() {
-      IOperation next = base.Apply();
+    public override IOperation InstrumentedApply() {
+      IOperation next = base.InstrumentedApply();
 
       PotvinEncoding individual = VRPToursParameter.ActualValue as PotvinEncoding;
Index: branches/DataPreprocessing/HeuristicLab.Problems.VehicleRouting/3.4/Encodings/Potvin/Moves/VehicleAssignment/PotvinVehicleAssignmentMoveGenerator.cs
===================================================================
--- branches/DataPreprocessing/HeuristicLab.Problems.VehicleRouting/3.4/Encodings/Potvin/Moves/VehicleAssignment/PotvinVehicleAssignmentMoveGenerator.cs	(revision 10085)
+++ branches/DataPreprocessing/HeuristicLab.Problems.VehicleRouting/3.4/Encodings/Potvin/Moves/VehicleAssignment/PotvinVehicleAssignmentMoveGenerator.cs	(revision 10538)
@@ -57,6 +57,6 @@
     protected abstract PotvinVehicleAssignmentMove[] GenerateMoves(PotvinEncoding individual, IVRPProblemInstance problemInstance);
 
-    public override IOperation Apply() {
-      IOperation next = base.Apply();
+    public override IOperation InstrumentedApply() {
+      IOperation next = base.InstrumentedApply();
 
       PotvinEncoding individual = VRPToursParameter.ActualValue as PotvinEncoding;
Index: branches/DataPreprocessing/HeuristicLab.Problems.VehicleRouting/3.4/Encodings/Prins/Crossovers/PrinsCrossover.cs
===================================================================
--- branches/DataPreprocessing/HeuristicLab.Problems.VehicleRouting/3.4/Encodings/Prins/Crossovers/PrinsCrossover.cs	(revision 10085)
+++ branches/DataPreprocessing/HeuristicLab.Problems.VehicleRouting/3.4/Encodings/Prins/Crossovers/PrinsCrossover.cs	(revision 10538)
@@ -51,5 +51,5 @@
     protected abstract PrinsEncoding Crossover(IRandom random, PrinsEncoding parent1, PrinsEncoding parent2);
 
-    public override IOperation Apply() {
+    public override IOperation InstrumentedApply() {
       ItemArray<IVRPEncoding> parents = new ItemArray<IVRPEncoding>(ParentsParameter.ActualValue.Length);
       for (int i = 0; i < ParentsParameter.ActualValue.Length; i++) {
@@ -67,5 +67,5 @@
         Crossover(RandomParameter.ActualValue, parents[0] as PrinsEncoding, parents[1] as PrinsEncoding);
 
-      return base.Apply();
+      return base.InstrumentedApply();
     }
   }
Index: branches/DataPreprocessing/HeuristicLab.Problems.VehicleRouting/3.4/Encodings/Prins/Manipulators/PrinsManipulator.cs
===================================================================
--- branches/DataPreprocessing/HeuristicLab.Problems.VehicleRouting/3.4/Encodings/Prins/Manipulators/PrinsManipulator.cs	(revision 10085)
+++ branches/DataPreprocessing/HeuristicLab.Problems.VehicleRouting/3.4/Encodings/Prins/Manipulators/PrinsManipulator.cs	(revision 10538)
@@ -50,5 +50,5 @@
     protected abstract void Manipulate(IRandom random, PrinsEncoding individual);
 
-    public override IOperation Apply() {
+    public override IOperation InstrumentedApply() {
       IVRPEncoding solution = VRPToursParameter.ActualValue;
       if (!(solution is PrinsEncoding)) {
@@ -58,5 +58,5 @@
       Manipulate(RandomParameter.ActualValue, VRPToursParameter.ActualValue as PrinsEncoding);
 
-      return base.Apply();
+      return base.InstrumentedApply();
     }
   }
Index: branches/DataPreprocessing/HeuristicLab.Problems.VehicleRouting/3.4/Encodings/VRPOperator.cs
===================================================================
--- branches/DataPreprocessing/HeuristicLab.Problems.VehicleRouting/3.4/Encodings/VRPOperator.cs	(revision 10085)
+++ branches/DataPreprocessing/HeuristicLab.Problems.VehicleRouting/3.4/Encodings/VRPOperator.cs	(revision 10538)
@@ -30,5 +30,5 @@
   [Item("VRPOperator", "Represents a VRP operator.")]
   [StorableClass]
-  public abstract class VRPOperator : SingleSuccessorOperator, IVRPOperator {
+  public abstract class VRPOperator : InstrumentedOperator, IVRPOperator {
     public ILookupParameter<IVRPProblemInstance> ProblemInstanceParameter {
       get { return (LookupParameter<IVRPProblemInstance>)Parameters["ProblemInstance"]; }
Index: branches/DataPreprocessing/HeuristicLab.Problems.VehicleRouting/3.4/Encodings/Zhu/Crossovers/ZhuCrossover.cs
===================================================================
--- branches/DataPreprocessing/HeuristicLab.Problems.VehicleRouting/3.4/Encodings/Zhu/Crossovers/ZhuCrossover.cs	(revision 10085)
+++ branches/DataPreprocessing/HeuristicLab.Problems.VehicleRouting/3.4/Encodings/Zhu/Crossovers/ZhuCrossover.cs	(revision 10538)
@@ -50,5 +50,5 @@
     protected abstract ZhuEncoding Crossover(IRandom random, ZhuEncoding parent1, ZhuEncoding parent2);
 
-    public override IOperation Apply() {
+    public override IOperation InstrumentedApply() {
       ItemArray<IVRPEncoding> parents = new ItemArray<IVRPEncoding>(ParentsParameter.ActualValue.Length);
       for (int i = 0; i < ParentsParameter.ActualValue.Length; i++) {
@@ -66,5 +66,5 @@
         Crossover(RandomParameter.ActualValue, parents[0] as ZhuEncoding, parents[1] as ZhuEncoding);
 
-      return base.Apply();
+      return base.InstrumentedApply();
     }
   }
Index: branches/DataPreprocessing/HeuristicLab.Problems.VehicleRouting/3.4/Encodings/Zhu/Manipulators/ZhuManipulator.cs
===================================================================
--- branches/DataPreprocessing/HeuristicLab.Problems.VehicleRouting/3.4/Encodings/Zhu/Manipulators/ZhuManipulator.cs	(revision 10085)
+++ branches/DataPreprocessing/HeuristicLab.Problems.VehicleRouting/3.4/Encodings/Zhu/Manipulators/ZhuManipulator.cs	(revision 10538)
@@ -50,5 +50,5 @@
     protected abstract void Manipulate(IRandom random, ZhuEncoding individual);
 
-    public override IOperation Apply() {
+    public override IOperation InstrumentedApply() {
       IVRPEncoding solution = VRPToursParameter.ActualValue;
       if (!(solution is ZhuEncoding)) {
@@ -58,5 +58,5 @@
       Manipulate(RandomParameter.ActualValue, VRPToursParameter.ActualValue as ZhuEncoding);
 
-      return base.Apply();
+      return base.InstrumentedApply();
     }
   }
Index: branches/DataPreprocessing/HeuristicLab.Problems.VehicleRouting/3.4/HeuristicLab.Problems.VehicleRouting-3.4.csproj
===================================================================
--- branches/DataPreprocessing/HeuristicLab.Problems.VehicleRouting/3.4/HeuristicLab.Problems.VehicleRouting-3.4.csproj	(revision 10085)
+++ branches/DataPreprocessing/HeuristicLab.Problems.VehicleRouting/3.4/HeuristicLab.Problems.VehicleRouting-3.4.csproj	(revision 10538)
@@ -465,4 +465,8 @@
       <Private>False</Private>
     </ProjectReference>
+    <ProjectReference Include="..\..\HeuristicLab.Random\3.3\HeuristicLab.Random-3.3.csproj">
+      <Project>{F4539FB6-4708-40C9-BE64-0A1390AEA197}</Project>
+      <Name>HeuristicLab.Random-3.3</Name>
+    </ProjectReference>
   </ItemGroup>
   <Import Project="$(MSBuildBinPath)\Microsoft.CSharp.targets" />
Index: branches/DataPreprocessing/HeuristicLab.Problems.VehicleRouting/3.4/Improver/VRPImprovementOperator.cs
===================================================================
--- branches/DataPreprocessing/HeuristicLab.Problems.VehicleRouting/3.4/Improver/VRPImprovementOperator.cs	(revision 10085)
+++ branches/DataPreprocessing/HeuristicLab.Problems.VehicleRouting/3.4/Improver/VRPImprovementOperator.cs	(revision 10538)
@@ -75,5 +75,5 @@
     }
 
-    public override IOperation Apply() {
+    public override IOperation InstrumentedApply() {
       var solution = SolutionParameter.ActualValue as IVRPEncoding;
       var potvinSolution = solution is PotvinEncoding ? solution as PotvinEncoding : PotvinEncoding.ConvertFrom(solution, ProblemInstance);
@@ -87,5 +87,5 @@
       LocalEvaluatedSolutions.ActualValue = new IntValue(evaluatedSolutions);
 
-      return base.Apply();
+      return base.InstrumentedApply();
     }
 
Index: branches/DataPreprocessing/HeuristicLab.Problems.VehicleRouting/3.4/Plugin.cs.frame
===================================================================
--- branches/DataPreprocessing/HeuristicLab.Problems.VehicleRouting/3.4/Plugin.cs.frame	(revision 10085)
+++ branches/DataPreprocessing/HeuristicLab.Problems.VehicleRouting/3.4/Plugin.cs.frame	(revision 10538)
@@ -41,4 +41,5 @@
   [PluginDependency("HeuristicLab.Persistence", "3.3")]
   [PluginDependency("HeuristicLab.Problems.Instances", "3.3")]
+  [PluginDependency("HeuristicLab.Random", "3.3")]
   public class HeuristicLabProblemsVehicleRoutingPlugin : PluginBase {
   }
Index: branches/DataPreprocessing/HeuristicLab.Problems.VehicleRouting/3.4/ProblemInstances/VRPEvaluator.cs
===================================================================
--- branches/DataPreprocessing/HeuristicLab.Problems.VehicleRouting/3.4/ProblemInstances/VRPEvaluator.cs	(revision 10085)
+++ branches/DataPreprocessing/HeuristicLab.Problems.VehicleRouting/3.4/ProblemInstances/VRPEvaluator.cs	(revision 10538)
@@ -128,5 +128,5 @@
     }
 
-    public override IOperation Apply() {
+    public override IOperation InstrumentedApply() {
       InitResultParameters();
 
@@ -140,5 +140,5 @@
       QualityParameter.ActualValue = new DoubleValue(evaluation.Quality);
 
-      return base.Apply();
+      return base.InstrumentedApply();
     }
 
Index: branches/DataPreprocessing/HeuristicLab.Problems.VehicleRouting/3.4/VehicleRoutingProblem.cs
===================================================================
--- branches/DataPreprocessing/HeuristicLab.Problems.VehicleRouting/3.4/VehicleRoutingProblem.cs	(revision 10085)
+++ branches/DataPreprocessing/HeuristicLab.Problems.VehicleRouting/3.4/VehicleRoutingProblem.cs	(revision 10538)
@@ -39,14 +39,8 @@
 
 namespace HeuristicLab.Problems.VehicleRouting {
-  public interface IVRPInstanceConsumer :  
-    IProblemInstanceConsumer<CVRPData>, IProblemInstanceConsumer<CVRPTWData>, 
-    IProblemInstanceConsumer<MDCVRPData>, IProblemInstanceConsumer<MDCVRPTWData>,
-    IProblemInstanceConsumer<PDPTWData> {
-  }
-
   [Item("Vehicle Routing Problem", "Represents a Vehicle Routing Problem.")]
   [Creatable("Problems")]
   [StorableClass]
-  public sealed class VehicleRoutingProblem : Problem, ISingleObjectiveHeuristicOptimizationProblem, IStorableContent, IVRPInstanceConsumer {
+  public sealed class VehicleRoutingProblem : Problem, ISingleObjectiveHeuristicOptimizationProblem, IStorableContent, IProblemInstanceConsumer<VRPData> {
     public string Filename { get; set; }
 
@@ -143,4 +137,6 @@
       AttachEventHandlers();
       AttachProblemInstanceEventHandlers();
+
+      EvaluatorParameter.Value = ProblemInstance.SolutionEvaluator;
     }
 
@@ -153,4 +149,7 @@
       : base(original, cloner) {
       this.AttachEventHandlers();
+      this.AttachProblemInstanceEventHandlers();
+
+      ProblemInstance.SolutionEvaluator = EvaluatorParameter.Value;
     }
 
@@ -173,4 +172,6 @@
       AttachEventHandlers();
       AttachProblemInstanceEventHandlers();
+
+      ProblemInstance.SolutionEvaluator = EvaluatorParameter.Value;
     }
 
@@ -189,5 +190,4 @@
     private void AttachProblemInstanceEventHandlers() {
       if (ProblemInstance != null) {
-        EvaluatorParameter.Value = ProblemInstance.SolutionEvaluator;
         ProblemInstance.EvaluationChanged += new EventHandler(ProblemInstance_EvaluationChanged);
       }
@@ -209,5 +209,4 @@
 
     void ProblemInstance_EvaluationChanged(object sender, EventArgs e) {
-      EvaluatorParameter.Value = ProblemInstance.SolutionEvaluator;
       EvalBestKnownSolution();
     }
@@ -216,4 +215,6 @@
       InitializeOperators();
       AttachProblemInstanceEventHandlers();
+
+      EvaluatorParameter.Value = ProblemInstance.SolutionEvaluator;
 
       OnSolutionCreatorChanged();
@@ -383,23 +384,26 @@
       }
     }
-
-    public void Load(CVRPData data) {
-      Load(data, new CVRPInterpreter());
-    }
-
-    public void Load(CVRPTWData data) {
-      Load(data, new CVRPTWInterpreter());
-    }
-
-    public void Load(MDCVRPData data) {
-      Load(data, new MDCVRPInterpreter());
-    }
-
-    public void Load(MDCVRPTWData data) {
-      Load(data, new MDCVRPTWInterpreter());
-    }
-
-    public void Load(PDPTWData data) {
-      Load(data, new PDPTWInterpreter());
+    #endregion
+
+    #region IProblemInstanceConsumer<VRPData> Members
+
+    public void Load(VRPData data) {
+      Type interpreterType = typeof(IVRPDataInterpreter<>).MakeGenericType(data.GetType());
+      var interpreters = ApplicationManager.Manager.GetInstances(interpreterType);
+      IVRPDataInterpreter interpreter = null;
+      foreach (object i in interpreters) {
+        var parentInterfaces = i.GetType().BaseType.GetInterfaces();
+        var interfaces = i.GetType().GetInterfaces().Except(parentInterfaces);
+        var interpreterInterface = interfaces.First(j => typeof(IVRPDataInterpreter).IsAssignableFrom(j));
+        var interpreterDataType = interpreterInterface.GetGenericArguments()[0];
+        if (interpreterDataType == data.GetType()) {
+          interpreter = i as IVRPDataInterpreter;
+          break;
+        }
+      }
+
+      if (interpreter == null)
+        throw new ArgumentException("No interpreter found for the VRP type");
+      Load(data, interpreter);
     }
 
