Index: branches/FitnessLandscapeAnalysis/HeuristicLab.Analysis.FitnessLandscape.VRP/Manipulators/ExchangeManipulator.cs
===================================================================
--- branches/FitnessLandscapeAnalysis/HeuristicLab.Analysis.FitnessLandscape.VRP/Manipulators/ExchangeManipulator.cs	(revision 9835)
+++ branches/FitnessLandscapeAnalysis/HeuristicLab.Analysis.FitnessLandscape.VRP/Manipulators/ExchangeManipulator.cs	(revision 9836)
@@ -49,8 +49,8 @@
     public static void Apply(IRandom random, PotvinEncoding individual, IVRPProblemInstance problemInstance, bool allowInfeasible) {
       bool feasible;
+      int count = 0;
 
       do {
         feasible = true;
-
         if (individual.Tours.Count > 1) {
           int tour1Idx = random.Next(individual.Tours.Count);
@@ -68,38 +68,20 @@
           int city2 = tour2.Stops[index2];
 
-          if (!allowInfeasible) {
-            bool originalFeasible = problemInstance.TourFeasible(tour1, individual) &&
-                                    problemInstance.TourFeasible(tour2, individual);
+          bool originalFeasible = problemInstance.TourFeasible(tour1, individual) &&
+                                  problemInstance.TourFeasible(tour2, individual);
 
-            if (originalFeasible) {
-              var tmpCity1 = tour1.Stops[index1];
-              tour1.Stops.RemoveAt(index1);
-              tour1.Stops.Insert(index1, city2);
+          tour1.Stops[index1] = city2;
+          tour2.Stops[index2] = city1;
 
-              if (problemInstance.TourFeasible(tour1, individual)) {
-                var tmpCity2 = tour2.Stops[index2];
-                tour2.Stops.RemoveAt(index2);
-                tour2.Stops.Insert(index2, city1);
-
-                feasible = problemInstance.TourFeasible(tour2, individual);
-
-                if (!feasible) {
-                  // undo tour1 and tour2 changes
-                  tour2.Stops.RemoveAt(index2);
-                  tour2.Stops.Insert(index2, tmpCity2);
-
-                  tour1.Stops.RemoveAt(index1);
-                  tour1.Stops.Insert(index1, tmpCity1);
-                }
-              } else {
-                feasible = false;
-                // undo tour1 change
-                tour1.Stops.RemoveAt(index1);
-                tour1.Stops.Insert(index1, tmpCity1);
-              }
-            } else feasible = false;
+          if (!allowInfeasible && originalFeasible) {
+            feasible = problemInstance.TourFeasible(tour1, individual) &&
+                       problemInstance.TourFeasible(tour2, individual);
+            if (!feasible) {
+              tour1.Stops[index1] = city1;
+              tour2.Stops[index2] = city2;
+            }
           }
         }
-      } while (!feasible);
+      } while (!feasible && count++ < 100);
     }
 
Index: branches/FitnessLandscapeAnalysis/HeuristicLab.Analysis.FitnessLandscape.VRP/Manipulators/OrOptManipulator.cs
===================================================================
--- branches/FitnessLandscapeAnalysis/HeuristicLab.Analysis.FitnessLandscape.VRP/Manipulators/OrOptManipulator.cs	(revision 9835)
+++ branches/FitnessLandscapeAnalysis/HeuristicLab.Analysis.FitnessLandscape.VRP/Manipulators/OrOptManipulator.cs	(revision 9836)
@@ -30,4 +30,5 @@
 using HeuristicLab.Problems.VehicleRouting;
 using System;
+using HeuristicLab.Problems.VehicleRouting.Interfaces;
 
 namespace HeuristicLab.Analysis.FitnessLandscape.VRP {
@@ -47,8 +48,12 @@
     }
 
-    public static void Apply(IRandom random, PotvinEncoding individual) {
+    public static void Apply(IRandom random, PotvinEncoding individual, IVRPProblemInstance instance, bool allowInfeasible) {
       List<Tour> tours = individual.Tours.FindAll(t => t.Stops.Count >= 2);
+      if (tours.Count == 0) return;
+      bool feasible;
+      int count = 0;
 
-      if (tours.Count > 0) {
+      do {
+        feasible = true;
         int tourIdx = random.Next(tours.Count);
         Tour tour = tours[tourIdx];
@@ -58,7 +63,10 @@
         if (segmentStart == 0) {
           segmentLength = 1 + random.Next(tour.Stops.Count - 1);
-        } else {
+        }
+        else {
           segmentLength = 1 + random.Next(tour.Stops.Count - segmentStart);
         }
+
+        bool originalFeasible = instance.TourFeasible(tour, individual);
 
         List<int> segment = tour.Stops.GetRange(segmentStart, segmentLength);
@@ -73,9 +81,18 @@
           newPos++;
         tour.Stops.InsertRange(newPos, segment);
-      }
+
+        if (!allowInfeasible && originalFeasible) {
+          feasible = instance.TourFeasible(tour, individual);
+          if (!feasible) {
+            tour.Stops.RemoveRange(newPos, segment.Count);
+            tour.Stops.InsertRange(segmentStart, segment);
+          }
+        }
+      } while (!feasible && count++ < 100);
     }
 
     protected override void Manipulate(IRandom random, PotvinEncoding individual) {
-      Apply(random, individual);
+      bool allowInfeasible = AllowInfeasibleSolutions.Value.Value;
+      Apply(random, individual, ProblemInstance, allowInfeasible);
     }
   }
Index: branches/FitnessLandscapeAnalysis/HeuristicLab.Analysis.FitnessLandscape.VRP/Manipulators/RelocateManipulator.cs
===================================================================
--- branches/FitnessLandscapeAnalysis/HeuristicLab.Analysis.FitnessLandscape.VRP/Manipulators/RelocateManipulator.cs	(revision 9835)
+++ branches/FitnessLandscapeAnalysis/HeuristicLab.Analysis.FitnessLandscape.VRP/Manipulators/RelocateManipulator.cs	(revision 9836)
@@ -49,4 +49,5 @@
     public static void Apply(IRandom random, PotvinEncoding individual, IVRPProblemInstance problemInstance, bool allowInfeasible) {
       bool feasible;
+      int count = 0;
 
       do {
@@ -64,4 +65,6 @@
         }
 
+        var originalFeasible = problemInstance.TourFeasible(originalTour, individual);
+
         int originalPosition = originalTour.Stops.IndexOf(city);
         originalTour.Stops.RemoveAt(originalPosition);
@@ -72,26 +75,21 @@
           insertionTour = individual.Tours.Find(t => t.Stops.Contains(position));
           insertionPosition = insertionTour.Stops.IndexOf(position) + 1;
-        } else {
+        } else { // additional insertion positions at beginning of tours
           insertionTour = individual.Tours[position - cities - 1];
           insertionPosition = 0;
         }
+        originalFeasible &= problemInstance.TourFeasible(insertionTour, individual);
+        insertionTour.Stops.Insert(insertionPosition, city);
 
-        if (!allowInfeasible && insertionTour != originalTour) {
-          bool originalFeasible = problemInstance.TourFeasible(insertionTour, individual);
-
-          if (originalFeasible) {
-            // try insert into insertionTour
-            insertionTour.Stops.Insert(insertionPosition, city);
-            feasible = problemInstance.TourFeasible(insertionTour, individual);
-
-            if (!feasible) {
-              // when insertionTour is not feasible we undo the change and add to the original tour instead
-              insertionTour.Stops.RemoveAt(insertionPosition);
-              originalTour.Stops.Insert(originalPosition, city);
-            }
-          } else feasible = false;
+        if (!allowInfeasible && originalFeasible) {
+          feasible = problemInstance.TourFeasible(insertionTour, individual) &&
+                     problemInstance.TourFeasible(originalTour, individual);
+          if (!feasible) {
+            insertionTour.Stops.RemoveAt(insertionPosition);
+            originalTour.Stops.Insert(originalPosition, city);
+          }
         }
         individual.Tours.RemoveAll(t => t.Stops.Count == 0);
-      } while (!feasible);
+      } while (!feasible && count++ < 100);
     }
 
Index: branches/FitnessLandscapeAnalysis/HeuristicLab.Analysis.FitnessLandscape.VRP/Manipulators/TwoOptManipulator.cs
===================================================================
--- branches/FitnessLandscapeAnalysis/HeuristicLab.Analysis.FitnessLandscape.VRP/Manipulators/TwoOptManipulator.cs	(revision 9835)
+++ branches/FitnessLandscapeAnalysis/HeuristicLab.Analysis.FitnessLandscape.VRP/Manipulators/TwoOptManipulator.cs	(revision 9836)
@@ -30,4 +30,5 @@
 using HeuristicLab.Problems.VehicleRouting;
 using System;
+using HeuristicLab.Problems.VehicleRouting.Interfaces;
 
 namespace HeuristicLab.Analysis.FitnessLandscape.VRP {
@@ -47,49 +48,52 @@
     }
 
-    public static void Apply(IRandom random, PotvinEncoding individual) {
-      List<Tour> tours = individual.Tours.FindAll(t => t.Stops.Count >= 4);
+    public static void Apply(IRandom random, PotvinEncoding individual, IVRPProblemInstance instance, bool allowInfeasible) {
+      List<Tour> tours = individual.Tours.FindAll(t => t.Stops.Count >= 2);
+      if (tours.Count == 0) return;
 
-      if (tours.Count > 0) {
+      bool feasible;
+      int count = 0;
+
+      do {
+        feasible = true;
         int tourIdx = random.Next(tours.Count);
         Tour tour = tours[tourIdx];
 
-        int a;
-        if (tour.Stops.Count == 4) {
-            a = 0;
-        } else if (tour.Stops.Count == 5) {
-          int idx = random.Next(4);
-          if (idx >= 2)
-            idx++;
-          a = idx;
+        int first;
+        int length;
+        if (tour.Stops.Count == 2) {
+          first = 0;
+          length = 2;
         } else {
-          a = random.Next(tour.Stops.Count);
+          first = random.Next(tour.Stops.Count - 1);
+          if (first == tour.Stops.Count - 2) {
+            length = tour.Stops.Count - first;
+          } else {
+            length = random.Next(tour.Stops.Count - first - 1) + 2;
+          }
         }
 
-        int b;
-        List<int> indices = new List<int>();
-        for (int i = 0; i < tour.Stops.Count; i++) {
-          if (Math.Abs(i - a) > 2) {
-            indices.Add(i);
+        var originalFeasible = instance.TourFeasible(tour, individual);
+
+        var segment = tour.Stops.GetRange(first, length);
+        tour.Stops.RemoveRange(first, length);
+        segment.Reverse();
+        tour.Stops.InsertRange(first, segment);
+
+        if (!allowInfeasible && originalFeasible) {
+          feasible = instance.TourFeasible(tour, individual);
+          if (!feasible) {
+            tour.Stops.RemoveRange(first, length);
+            segment.Reverse();
+            tour.Stops.InsertRange(first, segment);
           }
         }
-        b = indices[random.Next(indices.Count)];
 
-        if (b < a) {
-          int tmp = a;
-          a = b;
-          b = tmp;
-        }
-
-        int index = a + 1;
-        int count = b - a - 1;
-        List<int> segment = tour.Stops.GetRange(index, count);
-        tour.Stops.RemoveRange(index, count);
-        segment.Reverse();
-        tour.Stops.InsertRange(index, segment);
-      }
+      } while(!feasible && count++ < 100);
     }
 
     protected override void Manipulate(IRandom random, PotvinEncoding individual) {
-      Apply(random, individual);
+      bool allowInfeasible = AllowInfeasibleSolutions.Value.Value;
+      Apply(random, individual, ProblemInstance, allowInfeasible);
     }
   }
Index: branches/FitnessLandscapeAnalysis/HeuristicLab.Analysis.FitnessLandscape.VRP/Manipulators/TwoOptStarManipulator.cs
===================================================================
--- branches/FitnessLandscapeAnalysis/HeuristicLab.Analysis.FitnessLandscape.VRP/Manipulators/TwoOptStarManipulator.cs	(revision 9835)
+++ branches/FitnessLandscapeAnalysis/HeuristicLab.Analysis.FitnessLandscape.VRP/Manipulators/TwoOptStarManipulator.cs	(revision 9836)
@@ -49,4 +49,5 @@
     public static void Apply(IRandom random, PotvinEncoding individual, IVRPProblemInstance problemInstance, bool allowInfeasible) {
       bool feasible;
+      int count = 0;
 
       //consider creating new tour
@@ -67,49 +68,35 @@
         int x2 = random.Next(route2.Stops.Count + 1);
 
-        if (!allowInfeasible) {
-          bool originalFeasible = problemInstance.TourFeasible(route1, individual) &&
-                                  problemInstance.TourFeasible(route2, individual);
+        var originalFeasible =
+          problemInstance.TourFeasible(route1, individual) &&
+          problemInstance.TourFeasible(route2, individual);
 
-          if (originalFeasible) {
-            int count = route1.Stops.Count - x1;
-            List<int> segmentX1 = new List<int>();
-            if (count > 0) {
-              segmentX1 = route1.Stops.GetRange(x1, count);
-              route1.Stops.RemoveRange(x1, count);
-            }
+       SwapSegments(x1, route1, x2, route2);
 
-            count = route2.Stops.Count - x2;
-            List<int> segmentX2 = new List<int>();
-            if (count > 0) {
-              segmentX2 = route2.Stops.GetRange(x2, count);
-              route2.Stops.RemoveRange(x2, count);
-            }
-
-            route1.Stops.AddRange(segmentX2);
-            feasible = problemInstance.TourFeasible(route1, individual);
-            if (feasible) {
-              route2.Stops.AddRange(segmentX1);
-              feasible = problemInstance.TourFeasible(route2, individual);
-              if (!feasible) {
-                // undo all changes
-                route1.Stops.RemoveRange(x1, segmentX2.Count);
-                route1.Stops.AddRange(segmentX1);
-                route2.Stops.RemoveRange(x2, segmentX1.Count);
-                route2.Stops.AddRange(segmentX2);
-              }
-            } else {
-              // undo changes 
-              route1.Stops.RemoveRange(x1, segmentX2.Count);
-              route1.Stops.AddRange(segmentX1);
-              route2.Stops.AddRange(segmentX2);
-            }
-
-          } else {
-            feasible = false;
-          }
-        }
-      } while (!feasible);
+       if (!allowInfeasible && originalFeasible) {
+         feasible = problemInstance.TourFeasible(route1, individual) &&
+                    problemInstance.TourFeasible(route2, individual);
+         if (!feasible) SwapSegments(x1, route1, x2, route2);
+       }
+      } while (!feasible && count++ < 100);
 
       individual.Tours.RemoveAll(t => t.Stops.Count == 0);
+    }
+
+    private static void SwapSegments(int x1, Tour route1, int x2, Tour route2) {
+      int count = route1.Stops.Count - x1;
+      List<int> segmentX1 = new List<int>();
+      if (count > 0) {
+        segmentX1 = route1.Stops.GetRange(x1, count);
+        route1.Stops.RemoveRange(x1, count);
+      }
+      count = route2.Stops.Count - x2;
+      List<int> segmentX2 = new List<int>();
+      if (count > 0) {
+        segmentX2 = route2.Stops.GetRange(x2, count);
+        route2.Stops.RemoveRange(x2, count);
+      }
+      route1.Stops.AddRange(segmentX2);
+      route2.Stops.AddRange(segmentX1);
     }
 
