Index: /branches/MemPRAlgorithm/HeuristicLab.Algorithms.MemPR/3.3/LinearLinkage/LinearLinkageMemPR.cs
===================================================================
--- /branches/MemPRAlgorithm/HeuristicLab.Algorithms.MemPR/3.3/LinearLinkage/LinearLinkageMemPR.cs	(revision 14476)
+++ /branches/MemPRAlgorithm/HeuristicLab.Algorithms.MemPR/3.3/LinearLinkage/LinearLinkageMemPR.cs	(revision 14477)
@@ -26,4 +26,5 @@
 using HeuristicLab.Algorithms.MemPR.Interfaces;
 using HeuristicLab.Algorithms.MemPR.Util;
+using HeuristicLab.Collections;
 using HeuristicLab.Common;
 using HeuristicLab.Core;
@@ -92,98 +93,83 @@
     }
 
-    protected override int TabuWalk(ISingleObjectiveSolutionScope<Encodings.LinearLinkageEncoding.LinearLinkage> scope, int maxEvals, CancellationToken token, ISolutionSubspace<Encodings.LinearLinkageEncoding.LinearLinkage> subspace = null) {
-      return 0;
-      /*Func<Encodings.LinearLinkageEncoding.LinearLinkage, IRandom, double> eval = new EvaluationWrapper<Encodings.LinearLinkageEncoding.LinearLinkage>(Context.Problem, scope).Evaluate;
+    protected override int TabuWalk(
+        ISingleObjectiveSolutionScope<Encodings.LinearLinkageEncoding.LinearLinkage> scope,
+        int maxEvals, CancellationToken token,
+        ISolutionSubspace<Encodings.LinearLinkageEncoding.LinearLinkage> sub_space = null) {
+      var maximization = Context.Problem.Maximization;
+      var subspace = sub_space is LinearLinkageSolutionSubspace ? ((LinearLinkageSolutionSubspace)sub_space).Subspace : null;
+      var evaluations = 0;
       var quality = scope.Fitness;
-      var lle = scope.Solution;
-      var random = Context.Random;
-      var evaluations = 0;
-      var maximization = Context.Problem.Maximization;
+      var bestQuality = quality;
       if (double.IsNaN(quality)) {
-        quality = eval(lle, random);
+        Evaluate(scope, token);
+        quality = scope.Fitness;
         evaluations++;
-      }
-      Encodings.LinearLinkageEncoding.LinearLinkage bestOfTheWalk = null;
-      double bestOfTheWalkF = double.NaN;
-      var current = (Encodings.LinearLinkageEncoding.LinearLinkage)lle.Clone();
-      var currentF = quality;
-      var overallImprovement = false;
+        if (evaluations >= maxEvals) return evaluations;
+      }
+      var currentScope = (ISingleObjectiveSolutionScope<Encodings.LinearLinkageEncoding.LinearLinkage>)scope.Clone();
+      var current = currentScope.Solution;
+
       var tabu = new double[current.Length, current.Length];
       for (var i = 0; i < current.Length; i++) {
         for (var j = i; j < current.Length; j++) {
-          tabu[i, j] = tabu[j, i] = double.MaxValue;
-        }
-        tabu[i, current[i]] = currentF;
-      }
-
-      var steps = 0;
-      var stepsUntilBestOfWalk = 0;
+          tabu[i, j] = tabu[j, i] = maximization ? double.MinValue : double.MaxValue;
+        }
+        tabu[i, current[i]] = quality;
+      }
+      
+      // this dictionary holds the last relevant links
+      var links = new BidirectionalDictionary<int, int>();
+      bool allMoveTabu;
       for (var iter = 0; iter < int.MaxValue; iter++) {
-        var allTabu = true;
-        var bestOfTheRestF = double.NaN;
-        object bestOfTheRest = null;
-        var improved = false;
-        foreach () {
-          if (subspace != null && !(subspace[swap.Index1, 0] && subspace[swap.Index2, 0]))
+        allMoveTabu = true;
+        // clear the dictionary before a new pass through the array is made
+        links.Clear();
+        for (var i = 0; i < current.Length; i++) {
+          if (subspace != null && !subspace[i]) {
+            links.RemoveBySecond(i);
+            links.Add(i, current[i]);
             continue;
-
-
-          var q = eval(current, random);
-          evaluations++;
-          if (FitnessComparer.IsBetter(maximization, q, quality)) {
-            overallImprovement = true;
-            quality = q;
-            for (var i = 0; i < current.Length; i++) lle[i] = current[i];
-          }
-          // check if it would not be an improvement to swap these into their positions
-          var isTabu = !FitnessComparer.IsBetter(maximization, q, tabu[swap.Index1, current[swap.Index1]])
-                    && !FitnessComparer.IsBetter(maximization, q, tabu[swap.Index2, current[swap.Index2]]);
-          if (!isTabu) allTabu = false;
-          if (FitnessComparer.IsBetter(maximization, q, currentF) && !isTabu) {
-            if (FitnessComparer.IsBetter(maximization, q, bestOfTheWalkF)) {
-              bestOfTheWalk = (Encodings.LinearLinkageEncoding.LinearLinkage)current.Clone();
-              bestOfTheWalkF = q;
-              stepsUntilBestOfWalk = steps;
-            }
-            steps++;
-            improved = true;
-            // perform the move
-            currentF = q;
-            // mark that to move them to their previous position requires to make an improvement
-            tabu[swap.Index1, current[swap.Index2]] = maximization ? Math.Max(q, tabu[swap.Index1, current[swap.Index2]])
-                                                                   : Math.Min(q, tabu[swap.Index1, current[swap.Index2]]);
-            tabu[swap.Index2, current[swap.Index1]] = maximization ? Math.Max(q, tabu[swap.Index2, current[swap.Index1]])
-                                                                   : Math.Min(q, tabu[swap.Index2, current[swap.Index1]]);
-          } else { // undo the move
-            if (!isTabu && FitnessComparer.IsBetter(maximization, q, bestOfTheRestF)) {
-              bestOfTheRest = swap;
-              bestOfTheRestF = q;
-            }
-            current[swap.Index2] = current[swap.Index1];
-            current[swap.Index1] = h;
-          }
+          }
+
+          var next = current[i];
+          foreach (var move in MoveGenerator.GenerateForItem(i, next, links)) {
+            // we intend to break link i -> next
+            var qualityToBreak = tabu[i, next];
+            move.Apply(current);
+            var qualityToRestore = tabu[i, current[i]]; // current[i] is new next
+            Evaluate(currentScope, token);
+            evaluations++;
+            var moveF = currentScope.Fitness;
+            var isNotTabu = FitnessComparer.IsBetter(maximization, moveF, qualityToBreak)
+                         && FitnessComparer.IsBetter(maximization, moveF, qualityToRestore);
+            if (isNotTabu) allMoveTabu = false;
+            var isImprovement = FitnessComparer.IsBetter(maximization, moveF, bestQuality);
+            if (isNotTabu || isImprovement) {
+              if (maximization) {
+                tabu[i, next] = Math.Max(tabu[i, next], moveF);
+                tabu[i, current[i]] = Math.Max(tabu[i, current[i]], moveF);
+              } else {
+                tabu[i, next] = Math.Min(tabu[i, next], moveF);
+                tabu[i, current[i]] = Math.Min(tabu[i, current[i]], moveF);
+              }
+              quality = moveF;
+              if (isImprovement) bestQuality = quality;
+
+              move.UpdateLinks(links);
+              break;
+            } else move.Undo(current);
+            if (evaluations >= maxEvals) break;
+          }
+          links.RemoveBySecond(i);
+          links.Add(i, current[i]);
           if (evaluations >= maxEvals) break;
-        }
-        if (!allTabu && !improved && bestOfTheRest != null) {
-          tabu[bestOfTheRest.Index1, current[bestOfTheRest.Index1]] = maximization ? Math.Max(currentF, tabu[bestOfTheRest.Index1, current[bestOfTheRest.Index1]])
-                                                                                   : Math.Min(currentF, tabu[bestOfTheRest.Index1, current[bestOfTheRest.Index1]]);
-          tabu[bestOfTheRest.Index2, current[bestOfTheRest.Index2]] = maximization ? Math.Max(currentF, tabu[bestOfTheRest.Index2, current[bestOfTheRest.Index2]])
-                                                                                   : Math.Min(currentF, tabu[bestOfTheRest.Index2, current[bestOfTheRest.Index2]]);
-
-          var h = current[bestOfTheRest.Index1];
-          current[bestOfTheRest.Index1] = current[bestOfTheRest.Index2];
-          current[bestOfTheRest.Index2] = h;
-
-          currentF = bestOfTheRestF;
-          steps++;
-        } else if (allTabu) break;
+          if (token.IsCancellationRequested) break;
+        }
+        if (allMoveTabu) break;
         if (evaluations >= maxEvals) break;
-      }
-      Context.IncrementEvaluatedSolutions(evaluations);
-      if (!overallImprovement && bestOfTheWalk != null) {
-        quality = bestOfTheWalkF;
-        for (var i = 0; i < current.Length; i++) lle[i] = bestOfTheWalk[i];
-      }
-      return stepsUntilBestOfWalk;*/
+        if (token.IsCancellationRequested) break;
+      }
+      return evaluations;
     }
 
Index: /branches/MemPRAlgorithm/HeuristicLab.Algorithms.MemPR/3.3/LinearLinkage/LocalSearch/StaticAPI/ExhaustiveLocalSearch.cs
===================================================================
--- /branches/MemPRAlgorithm/HeuristicLab.Algorithms.MemPR/3.3/LinearLinkage/LocalSearch/StaticAPI/ExhaustiveLocalSearch.cs	(revision 14476)
+++ /branches/MemPRAlgorithm/HeuristicLab.Algorithms.MemPR/3.3/LinearLinkage/LocalSearch/StaticAPI/ExhaustiveLocalSearch.cs	(revision 14477)
@@ -49,9 +49,8 @@
             continue;
           }
-          var isFirst = !links.ContainsSecond(i);
           var pred = -1;
+          var isFirst = !links.TryGetBySecond(i, out pred);
           var keepLink = false;
           if (!isFirst) {
-            pred = links.GetBySecond(i);
             keepLink = subspace != null && !subspace[pred];
           }
Index: /branches/MemPRAlgorithm/HeuristicLab.Algorithms.MemPR/3.3/MemPRAlgorithm.cs
===================================================================
--- /branches/MemPRAlgorithm/HeuristicLab.Algorithms.MemPR/3.3/MemPRAlgorithm.cs	(revision 14476)
+++ /branches/MemPRAlgorithm/HeuristicLab.Algorithms.MemPR/3.3/MemPRAlgorithm.cs	(revision 14477)
@@ -216,4 +216,7 @@
         Context.Problem = Problem;
       }
+
+      if (MaximumExecutionTime.HasValue)
+        CancellationTokenSource.CancelAfter(MaximumExecutionTime.Value);
 
       IExecutionContext context = null;
Index: /branches/MemPRAlgorithm/HeuristicLab.Algorithms.MemPR/3.3/Permutation/PermutationMemPR.cs
===================================================================
--- /branches/MemPRAlgorithm/HeuristicLab.Algorithms.MemPR/3.3/Permutation/PermutationMemPR.cs	(revision 14476)
+++ /branches/MemPRAlgorithm/HeuristicLab.Algorithms.MemPR/3.3/Permutation/PermutationMemPR.cs	(revision 14477)
@@ -187,5 +187,5 @@
       for (var i = 0; i < current.Length; i++) {
         for (var j = i; j < current.Length; j++) {
-          tabu[i, j] = tabu[j, i] = double.MaxValue;
+          tabu[i, j] = tabu[j, i] = maximization ? double.MinValue : double.MaxValue;
         }
         tabu[i, current[i]] = currentF;
Index: /branches/MemPRAlgorithm/HeuristicLab.Collections/3.3/BidirectionalDictionary.cs
===================================================================
--- /branches/MemPRAlgorithm/HeuristicLab.Collections/3.3/BidirectionalDictionary.cs	(revision 14476)
+++ /branches/MemPRAlgorithm/HeuristicLab.Collections/3.3/BidirectionalDictionary.cs	(revision 14477)
@@ -135,4 +135,12 @@
     }
 
+    public bool TryGetByFirst(TFirst key, out TSecond secondValue) {
+      return firstToSecond.TryGetValue(key, out secondValue);
+    }
+
+    public bool TryGetBySecond(TSecond key, out TFirst firstValue) {
+      return secondToFirst.TryGetValue(key, out firstValue);
+    }
+
     public void Clear() {
       firstToSecond.Clear();
Index: /branches/MemPRAlgorithm/HeuristicLab.Encodings.LinearLinkageEncoding/3.3/HeuristicLab.Encodings.LinearLinkageEncoding-3.3.csproj
===================================================================
--- /branches/MemPRAlgorithm/HeuristicLab.Encodings.LinearLinkageEncoding/3.3/HeuristicLab.Encodings.LinearLinkageEncoding-3.3.csproj	(revision 14476)
+++ /branches/MemPRAlgorithm/HeuristicLab.Encodings.LinearLinkageEncoding/3.3/HeuristicLab.Encodings.LinearLinkageEncoding-3.3.csproj	(revision 14477)
@@ -181,4 +181,10 @@
     <Compile Include="Moves\Swap\Swap2MoveGenerator.cs" />
     <Compile Include="Moves\Swap\Swap2MoveMaker.cs" />
+    <Compile Include="Moves\ExtractMove.cs" />
+    <Compile Include="Moves\MergeMove.cs" />
+    <Compile Include="Moves\Move.cs" />
+    <Compile Include="Moves\ShiftMove.cs" />
+    <Compile Include="Moves\SplitMove.cs" />
+    <Compile Include="Moves\StaticAPI\MoveGenerator.cs" />
     <Compile Include="ShakingOperators\LLEShakingOperator.cs" />
     <Compile Include="SimilarityCalculators\HammingSimilarityCalculator.cs" />
Index: /branches/MemPRAlgorithm/HeuristicLab.Encodings.LinearLinkageEncoding/3.3/Moves/ExtractMove.cs
===================================================================
--- /branches/MemPRAlgorithm/HeuristicLab.Encodings.LinearLinkageEncoding/3.3/Moves/ExtractMove.cs	(revision 14477)
+++ /branches/MemPRAlgorithm/HeuristicLab.Encodings.LinearLinkageEncoding/3.3/Moves/ExtractMove.cs	(revision 14477)
@@ -0,0 +1,65 @@
+﻿#region License Information
+/* HeuristicLab
+ * Copyright (C) 2002-2016 Heuristic and Evolutionary Algorithms Laboratory (HEAL)
+ *
+ * This file is part of HeuristicLab.
+ *
+ * HeuristicLab is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation, either version 3 of the License, or
+ * (at your option) any later version.
+ *
+ * HeuristicLab is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with HeuristicLab. If not, see <http://www.gnu.org/licenses/>.
+ */
+#endregion
+
+using System;
+using HeuristicLab.Collections;
+
+namespace HeuristicLab.Encodings.LinearLinkageEncoding {
+  public class ExtractMove : Move {
+    public int PreviousItem { get; private set; }
+    public int NextItem { get; private set; }
+
+    private bool IsFirst { get { return PreviousItem == Item; } }
+    private bool IsLast { get { return NextItem == Item; } }
+
+    public ExtractMove(int item, int prev, int next) {
+      Item = item;
+      PreviousItem = prev;
+      NextItem = next;
+    }
+
+    public override void Apply(LinearLinkage lle) {
+      if ((!IsFirst && lle[PreviousItem] != Item)
+        || lle[Item] != NextItem)
+        throw new ArgumentException("Move conditions have changed!");
+      if (!IsFirst)
+        lle[PreviousItem] = IsLast ? PreviousItem : NextItem;
+      lle[Item] = Item;
+    }
+
+    public override void Undo(LinearLinkage lle) {
+      if (!IsFirst && lle[PreviousItem] != (IsLast ? PreviousItem : NextItem)
+        || lle[Item] != Item)
+        throw new ArgumentException("Move conditions have changed, cannot undo move.");
+
+      if (!IsFirst)
+        lle[PreviousItem] = Item;
+      lle[Item] = NextItem;
+    }
+
+    public override void UpdateLinks(BidirectionalDictionary<int, int> links) {
+      if (!IsFirst) {
+        links.RemoveBySecond(Item);
+        links.SetByFirst(PreviousItem, IsLast ? PreviousItem : NextItem);
+      }
+    }
+  }
+}
Index: /branches/MemPRAlgorithm/HeuristicLab.Encodings.LinearLinkageEncoding/3.3/Moves/MergeMove.cs
===================================================================
--- /branches/MemPRAlgorithm/HeuristicLab.Encodings.LinearLinkageEncoding/3.3/Moves/MergeMove.cs	(revision 14477)
+++ /branches/MemPRAlgorithm/HeuristicLab.Encodings.LinearLinkageEncoding/3.3/Moves/MergeMove.cs	(revision 14477)
@@ -0,0 +1,54 @@
+﻿#region License Information
+/* HeuristicLab
+ * Copyright (C) 2002-2016 Heuristic and Evolutionary Algorithms Laboratory (HEAL)
+ *
+ * This file is part of HeuristicLab.
+ *
+ * HeuristicLab is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation, either version 3 of the License, or
+ * (at your option) any later version.
+ *
+ * HeuristicLab is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with HeuristicLab. If not, see <http://www.gnu.org/licenses/>.
+ */
+#endregion
+
+using System;
+using HeuristicLab.Collections;
+
+namespace HeuristicLab.Encodings.LinearLinkageEncoding {
+  public class MergeMove : Move {
+
+    public int LastItemOfOtherGroup { get; private set; }
+    private int nextItemOfOtherGroup; // undo information
+
+    public MergeMove(int item, int lastOfOther) {
+      Item = item;
+      LastItemOfOtherGroup = lastOfOther;
+      nextItemOfOtherGroup = -1;
+    }
+
+    public override void Apply(LinearLinkage lle) {
+      if (lle[LastItemOfOtherGroup] != LastItemOfOtherGroup) throw new ArgumentException("Move conditions have changed, group does not terminate at " + LastItemOfOtherGroup);
+      nextItemOfOtherGroup = lle[LastItemOfOtherGroup];
+      lle[LastItemOfOtherGroup] = Item;
+    }
+
+    public override void Undo(LinearLinkage lle) {
+      if (lle[LastItemOfOtherGroup] != Item) throw new ArgumentException("Move conditions have changed, groups are no longer linked between " + LastItemOfOtherGroup + " and " + Item);
+      if (nextItemOfOtherGroup < 0) throw new InvalidOperationException("Cannot undo move that has not been applied first.");
+      lle[LastItemOfOtherGroup] = nextItemOfOtherGroup;
+    }
+
+    public override void UpdateLinks(BidirectionalDictionary<int, int> links) {
+      if (nextItemOfOtherGroup < 0) throw new InvalidOperationException("Cannot update links for move that has not been applied first.");
+      links.RemoveBySecond(nextItemOfOtherGroup);
+    }
+  }
+}
Index: /branches/MemPRAlgorithm/HeuristicLab.Encodings.LinearLinkageEncoding/3.3/Moves/Move.cs
===================================================================
--- /branches/MemPRAlgorithm/HeuristicLab.Encodings.LinearLinkageEncoding/3.3/Moves/Move.cs	(revision 14477)
+++ /branches/MemPRAlgorithm/HeuristicLab.Encodings.LinearLinkageEncoding/3.3/Moves/Move.cs	(revision 14477)
@@ -0,0 +1,33 @@
+﻿#region License Information
+/* HeuristicLab
+ * Copyright (C) 2002-2016 Heuristic and Evolutionary Algorithms Laboratory (HEAL)
+ *
+ * This file is part of HeuristicLab.
+ *
+ * HeuristicLab is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation, either version 3 of the License, or
+ * (at your option) any later version.
+ *
+ * HeuristicLab is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with HeuristicLab. If not, see <http://www.gnu.org/licenses/>.
+ */
+#endregion
+
+using HeuristicLab.Collections;
+
+namespace HeuristicLab.Encodings.LinearLinkageEncoding {
+  public abstract class Move {
+    public int Item { get; protected set; }
+
+    public abstract void Apply(LinearLinkage lle);
+    public abstract void Undo(LinearLinkage lle);
+
+    public abstract void UpdateLinks(BidirectionalDictionary<int, int> links);
+  }
+}
Index: /branches/MemPRAlgorithm/HeuristicLab.Encodings.LinearLinkageEncoding/3.3/Moves/ShiftMove.cs
===================================================================
--- /branches/MemPRAlgorithm/HeuristicLab.Encodings.LinearLinkageEncoding/3.3/Moves/ShiftMove.cs	(revision 14477)
+++ /branches/MemPRAlgorithm/HeuristicLab.Encodings.LinearLinkageEncoding/3.3/Moves/ShiftMove.cs	(revision 14477)
@@ -0,0 +1,73 @@
+﻿#region License Information
+/* HeuristicLab
+ * Copyright (C) 2002-2016 Heuristic and Evolutionary Algorithms Laboratory (HEAL)
+ *
+ * This file is part of HeuristicLab.
+ *
+ * HeuristicLab is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation, either version 3 of the License, or
+ * (at your option) any later version.
+ *
+ * HeuristicLab is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with HeuristicLab. If not, see <http://www.gnu.org/licenses/>.
+ */
+#endregion
+
+using System;
+using HeuristicLab.Collections;
+
+namespace HeuristicLab.Encodings.LinearLinkageEncoding {
+  public class ShiftMove : Move {
+    public int PreviousItemOfOldGroup { get; private set; }
+    public int PreviousItemOfNewGroup { get; private set; }
+    public int NextItemOfOldGroup { get; private set; }
+    public int NextItemOfNewGroup { get; private set; }
+
+    private bool IsFirst { get { return PreviousItemOfOldGroup == Item; } }
+    private bool IsLast { get { return NextItemOfOldGroup == Item; } }
+    private bool NewGroupClosed { get { return PreviousItemOfNewGroup == NextItemOfNewGroup; } }
+
+    public ShiftMove(int item, int prevOld, int prevNew, int nextOld, int nextNew) {
+      Item = item;
+      PreviousItemOfOldGroup = prevOld;
+      PreviousItemOfNewGroup = prevNew;
+      NextItemOfOldGroup = nextOld;
+      NextItemOfNewGroup = nextNew;
+    }
+
+    public override void Apply(LinearLinkage lle) {
+      if ((!IsFirst && lle[PreviousItemOfOldGroup] != Item)
+        || lle[Item] != NextItemOfOldGroup
+        || lle[PreviousItemOfNewGroup] != NextItemOfNewGroup)
+        throw new ArgumentException("Move conditions have changed!");
+      if (!IsFirst)
+        lle[PreviousItemOfOldGroup] = IsLast ? PreviousItemOfOldGroup : NextItemOfOldGroup;
+      lle[PreviousItemOfNewGroup] = Item;
+      lle[Item] = NewGroupClosed ? Item : NextItemOfNewGroup;
+    }
+
+    public override void Undo(LinearLinkage lle) {
+      if (!IsFirst && lle[PreviousItemOfOldGroup] != (IsLast ? PreviousItemOfOldGroup : NextItemOfOldGroup)
+        || lle[PreviousItemOfNewGroup] != Item
+        || lle[Item] != (NewGroupClosed ? Item : NextItemOfNewGroup))
+        throw new ArgumentException("Move conditions have changed, cannot undo move.");
+
+      if (!IsFirst)
+        lle[PreviousItemOfOldGroup] = Item;
+      lle[PreviousItemOfNewGroup] = NextItemOfNewGroup;
+      lle[Item] = NextItemOfOldGroup;
+    }
+
+    public override void UpdateLinks(BidirectionalDictionary<int, int> links) {
+      links.RemoveBySecond(Item);
+      links.SetByFirst(PreviousItemOfNewGroup, Item);
+      if (!IsFirst) links.SetByFirst(PreviousItemOfOldGroup, IsLast ? PreviousItemOfOldGroup : NextItemOfOldGroup);
+    }
+  }
+}
Index: /branches/MemPRAlgorithm/HeuristicLab.Encodings.LinearLinkageEncoding/3.3/Moves/SplitMove.cs
===================================================================
--- /branches/MemPRAlgorithm/HeuristicLab.Encodings.LinearLinkageEncoding/3.3/Moves/SplitMove.cs	(revision 14477)
+++ /branches/MemPRAlgorithm/HeuristicLab.Encodings.LinearLinkageEncoding/3.3/Moves/SplitMove.cs	(revision 14477)
@@ -0,0 +1,51 @@
+﻿#region License Information
+/* HeuristicLab
+ * Copyright (C) 2002-2016 Heuristic and Evolutionary Algorithms Laboratory (HEAL)
+ *
+ * This file is part of HeuristicLab.
+ *
+ * HeuristicLab is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation, either version 3 of the License, or
+ * (at your option) any later version.
+ *
+ * HeuristicLab is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with HeuristicLab. If not, see <http://www.gnu.org/licenses/>.
+ */
+#endregion
+
+using System;
+using HeuristicLab.Collections;
+
+namespace HeuristicLab.Encodings.LinearLinkageEncoding {
+  public class SplitMove : Move {
+
+    private int nextItem;
+
+    public SplitMove(int item) {
+      Item = item;
+      nextItem = -1;
+    }
+
+    public override void Apply(LinearLinkage lle) {
+      if (lle[Item] == Item) throw new ArgumentException("Move conditions have changed, group is already split at " + Item);
+      nextItem = lle[Item];
+      lle[Item] = Item;
+    }
+
+    public override void Undo(LinearLinkage lle) {
+      if (lle[Item] != Item) throw new ArgumentException("Move conditions have changed, group no longer terminates at " + Item);
+      if (nextItem < 0) throw new InvalidOperationException("Cannot undo move that has not been applied first.");
+      lle[Item] = nextItem;
+    }
+
+    public override void UpdateLinks(BidirectionalDictionary<int, int> links) {
+      // nothing has to be done
+    }
+  }
+}
Index: /branches/MemPRAlgorithm/HeuristicLab.Encodings.LinearLinkageEncoding/3.3/Moves/StaticAPI/MoveGenerator.cs
===================================================================
--- /branches/MemPRAlgorithm/HeuristicLab.Encodings.LinearLinkageEncoding/3.3/Moves/StaticAPI/MoveGenerator.cs	(revision 14477)
+++ /branches/MemPRAlgorithm/HeuristicLab.Encodings.LinearLinkageEncoding/3.3/Moves/StaticAPI/MoveGenerator.cs	(revision 14477)
@@ -0,0 +1,65 @@
+﻿#region License Information
+/* HeuristicLab
+ * Copyright (C) 2002-2016 Heuristic and Evolutionary Algorithms Laboratory (HEAL)
+ *
+ * This file is part of HeuristicLab.
+ *
+ * HeuristicLab is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation, either version 3 of the License, or
+ * (at your option) any later version.
+ *
+ * HeuristicLab is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with HeuristicLab. If not, see <http://www.gnu.org/licenses/>.
+ */
+#endregion
+
+using System.Collections.Generic;
+using System.Linq;
+using HeuristicLab.Collections;
+
+namespace HeuristicLab.Encodings.LinearLinkageEncoding {
+  public static class MoveGenerator {
+    public static IEnumerable<Move> GenerateForItem(int i, int next, BidirectionalDictionary<int, int> links) {
+      var pred = -1;
+      var isFirst = !links.TryGetBySecond(i, out pred);
+      var isLast = next == i;
+
+      // First: shift i into each previous group
+      foreach (var l in links.Where(x => x.Value != i)) {
+        yield return new ShiftMove(i, isFirst ? i : pred, l.Key, next, l.Value);
+      }
+
+      if (!isLast) {
+        // Second: split group at i
+        yield return new SplitMove(i);
+
+        if (isFirst) {
+          // Third: merge with closed groups
+          foreach (var l in links.Where(x => x.Key == x.Value)) {
+            yield return new MergeMove(i, l.Key);
+          }
+        }
+      }
+      if (!isFirst)
+        // Fourth: extract i into group of its own (exclude first, because of Second)
+        yield return new ExtractMove(i, pred, next);
+
+    }
+
+    public static IEnumerable<Move> Generate(LinearLinkage lle) {
+      var links = new BidirectionalDictionary<int, int>();
+      for (var i = 0; i < lle.Length; i++) {
+        foreach (var move in GenerateForItem(i, lle[i], links))
+          yield return move;
+        links.RemoveBySecond(i);
+        links.Add(i, lle[i]);
+      }
+    }
+  }
+}
Index: anches/MemPRAlgorithm/HeuristicLab.Problems.Instances.DIMACS/3.3/Plugin.cs
===================================================================
--- /branches/MemPRAlgorithm/HeuristicLab.Problems.Instances.DIMACS/3.3/Plugin.cs	(revision 14476)
+++ 	(revision )
@@ -1,30 +1,0 @@
-﻿#region License Information
-/* HeuristicLab
- * Copyright (C) 2002-2016 Heuristic and Evolutionary Algorithms Laboratory (HEAL)
- *
- * This file is part of HeuristicLab.
- *
- * HeuristicLab is free software: you can redistribute it and/or modify
- * it under the terms of the GNU General Public License as published by
- * the Free Software Foundation, either version 3 of the License, or
- * (at your option) any later version.
- *
- * HeuristicLab is distributed in the hope that it will be useful,
- * but WITHOUT ANY WARRANTY; without even the implied warranty of
- * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
- * GNU General Public License for more details.
- *
- * You should have received a copy of the GNU General Public License
- * along with HeuristicLab. If not, see <http://www.gnu.org/licenses/>.
- */
-#endregion
-
-using HeuristicLab.PluginInfrastructure;
-
-namespace HeuristicLab.Problems.Instances.DIMACS {
-  [Plugin("HeuristicLab.Problems.Instances.DIMACS", "Adds the DIMACS benchmark instances, e.g. graph coloring.", "3.3.14.14185")]
-  [PluginFile("HeuristicLab.Problems.Instances.DIMACS-3.3.dll", PluginFileType.Assembly)]
-  [PluginDependency("HeuristicLab.Common", "3.3")]
-  [PluginDependency("HeuristicLab.Problems.Instances", "3.3")]
-  public class HeuristicLabProblemsInstancesDIMACSPlugin : PluginBase { }
-}
Index: anches/MemPRAlgorithm/HeuristicLab.Problems.Instances.DIMACS/3.3/Properties/AssemblyInfo.cs
===================================================================
--- /branches/MemPRAlgorithm/HeuristicLab.Problems.Instances.DIMACS/3.3/Properties/AssemblyInfo.cs	(revision 14476)
+++ 	(revision )
@@ -1,56 +1,0 @@
-﻿#region License Information
-/* HeuristicLab
- * Copyright (C) 2002-2016 Heuristic and Evolutionary Algorithms Laboratory (HEAL)
- *
- * This file is part of HeuristicLab.
- *
- * HeuristicLab is free software: you can redistribute it and/or modify
- * it under the terms of the GNU General Public License as published by
- * the Free Software Foundation, either version 3 of the License, or
- * (at your option) any later version.
- *
- * HeuristicLab is distributed in the hope that it will be useful,
- * but WITHOUT ANY WARRANTY; without even the implied warranty of
- * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
- * GNU General Public License for more details.
- *
- * You should have received a copy of the GNU General Public License
- * along with HeuristicLab. If not, see <http://www.gnu.org/licenses/>.
- */
-#endregion
-
-using System.Reflection;
-using System.Runtime.InteropServices;
-
-// General Information about an assembly is controlled through the following 
-// set of attributes. Change these attribute values to modify the information
-// associated with an assembly.
-[assembly: AssemblyTitle("HeuristicLab.Problems.Instances.DIMACS")]
-[assembly: AssemblyDescription("")]
-[assembly: AssemblyConfiguration("")]
-[assembly: AssemblyCompany("HEAL")]
-[assembly: AssemblyProduct("HeuristicLab")]
-[assembly: AssemblyCopyright("(c) 2002-2016 HEAL")]
-[assembly: AssemblyTrademark("")]
-[assembly: AssemblyCulture("")]
-
-// Setting ComVisible to false makes the types in this assembly not visible 
-// to COM components.  If you need to access a type in this assembly from 
-// COM, set the ComVisible attribute to true on that type.
-[assembly: ComVisible(false)]
-
-// The following GUID is for the ID of the typelib if this project is exposed to COM
-[assembly: Guid("9943ff23-8619-459c-b84a-e7fbdcba04e6")]
-
-// Version information for an assembly consists of the following four values:
-//
-//      Major Version
-//      Minor Version 
-//      Build Number
-//      Revision
-//
-// You can specify all the values or you can default the Build and Revision Numbers 
-// by using the '*' as shown below:
-// [assembly: AssemblyVersion("1.0.*")]
-[assembly: AssemblyVersion("3.3.0.0")]
-[assembly: AssemblyFileVersion("3.3.14.14185")]
Index: /branches/MemPRAlgorithm/HeuristicLab.Tests/HeuristicLab-3.3/DeepCloneableCloningTest.cs
===================================================================
--- /branches/MemPRAlgorithm/HeuristicLab.Tests/HeuristicLab-3.3/DeepCloneableCloningTest.cs	(revision 14476)
+++ /branches/MemPRAlgorithm/HeuristicLab.Tests/HeuristicLab-3.3/DeepCloneableCloningTest.cs	(revision 14477)
@@ -42,18 +42,18 @@
     public DeepCloneableCloningTest() {
       excludedTypes = new HashSet<Type> {
-        typeof (HeuristicLab.Problems.DataAnalysis.Dataset),
-        typeof (HeuristicLab.Problems.TravelingSalesman.DistanceMatrix),
-        typeof (HeuristicLab.Problems.DataAnalysis.ClassificationEnsembleSolution),
-        typeof (HeuristicLab.Problems.DataAnalysis.RegressionEnsembleSolution),
-        typeof (HeuristicLab.Problems.Orienteering.DistanceMatrix),
-        typeof (HeuristicLab.Problems.PTSP.DistanceMatrix)
+        typeof (global::HeuristicLab.Problems.DataAnalysis.Dataset),
+        typeof (global::HeuristicLab.Problems.TravelingSalesman.DistanceMatrix),
+        typeof (global::HeuristicLab.Problems.DataAnalysis.ClassificationEnsembleSolution),
+        typeof (global::HeuristicLab.Problems.DataAnalysis.RegressionEnsembleSolution),
+        typeof (global::HeuristicLab.Problems.Orienteering.DistanceMatrix),
+        typeof (global::HeuristicLab.Problems.PTSP.DistanceMatrix)
       };
       excludedTypes.Add(typeof(SymbolicExpressionGrammar).Assembly.GetType("HeuristicLab.Encodings.SymbolicExpressionTreeEncoding.EmptySymbolicExpressionTreeGrammar"));
 
-      foreach (var symbolType in ApplicationManager.Manager.GetTypes(typeof(HeuristicLab.Encodings.SymbolicExpressionTreeEncoding.Symbol)))
+      foreach (var symbolType in ApplicationManager.Manager.GetTypes(typeof(global::HeuristicLab.Encodings.SymbolicExpressionTreeEncoding.Symbol)))
         excludedTypes.Add(symbolType);
       // SimpleSymbol is a non-discoverable type and thus needs to be added manually
-      excludedTypes.Add(typeof(HeuristicLab.Encodings.SymbolicExpressionTreeEncoding.SimpleSymbol));
-      foreach (var grammarType in ApplicationManager.Manager.GetTypes(typeof(HeuristicLab.Encodings.SymbolicExpressionTreeEncoding.SymbolicExpressionGrammarBase)))
+      excludedTypes.Add(typeof(global::HeuristicLab.Encodings.SymbolicExpressionTreeEncoding.SimpleSymbol));
+      foreach (var grammarType in ApplicationManager.Manager.GetTypes(typeof(global::HeuristicLab.Encodings.SymbolicExpressionTreeEncoding.SymbolicExpressionGrammarBase)))
         excludedTypes.Add(grammarType);
     }
Index: /branches/MemPRAlgorithm/HeuristicLab.Tests/HeuristicLab-3.3/Samples/AlpsSampleTest.cs
===================================================================
--- /branches/MemPRAlgorithm/HeuristicLab.Tests/HeuristicLab-3.3/Samples/AlpsSampleTest.cs	(revision 14476)
+++ /branches/MemPRAlgorithm/HeuristicLab.Tests/HeuristicLab-3.3/Samples/AlpsSampleTest.cs	(revision 14477)
@@ -88,5 +88,5 @@
       TravelingSalesmanProblem tspProblem = new TravelingSalesmanProblem();
       tspProblem.Load(provider.LoadData(instance));
-      tspProblem.UseDistanceMatrix.Value = true;
+      tspProblem.UseDistanceMatrix = true;
       #endregion
       #region Algorithm Configuration
Index: /branches/MemPRAlgorithm/HeuristicLab.Tests/HeuristicLab-3.3/Samples/GATspSampleTest.cs
===================================================================
--- /branches/MemPRAlgorithm/HeuristicLab.Tests/HeuristicLab-3.3/Samples/GATspSampleTest.cs	(revision 14476)
+++ /branches/MemPRAlgorithm/HeuristicLab.Tests/HeuristicLab-3.3/Samples/GATspSampleTest.cs	(revision 14477)
@@ -65,5 +65,5 @@
       TravelingSalesmanProblem tspProblem = new TravelingSalesmanProblem();
       tspProblem.Load(provider.LoadData(instance));
-      tspProblem.UseDistanceMatrix.Value = true;
+      tspProblem.UseDistanceMatrix = true;
       #endregion
       #region Algorithm Configuration
Index: /branches/MemPRAlgorithm/HeuristicLab.Tests/HeuristicLab-3.3/Samples/GPMultiplexerSampleTest.cs
===================================================================
--- /branches/MemPRAlgorithm/HeuristicLab.Tests/HeuristicLab-3.3/Samples/GPMultiplexerSampleTest.cs	(revision 14476)
+++ /branches/MemPRAlgorithm/HeuristicLab.Tests/HeuristicLab-3.3/Samples/GPMultiplexerSampleTest.cs	(revision 14477)
@@ -55,5 +55,5 @@
 
     public static OffspringSelectionGeneticAlgorithm CreateGpMultiplexerSample() {
-      var problem = new HeuristicLab.Problems.GeneticProgramming.Boolean.MultiplexerProblem();
+      var problem = new global::HeuristicLab.Problems.GeneticProgramming.Boolean.MultiplexerProblem();
       problem.Name = "11-Multiplexer Problem";
       problem.Encoding.TreeLength = 50;
Index: /branches/MemPRAlgorithm/HeuristicLab.Tests/HeuristicLab-3.3/Samples/GeSymbolicRegressionSampleTest.cs
===================================================================
--- /branches/MemPRAlgorithm/HeuristicLab.Tests/HeuristicLab-3.3/Samples/GeSymbolicRegressionSampleTest.cs	(revision 14476)
+++ /branches/MemPRAlgorithm/HeuristicLab.Tests/HeuristicLab-3.3/Samples/GeSymbolicRegressionSampleTest.cs	(revision 14477)
@@ -57,5 +57,5 @@
 
       #region Problem Configuration
-      var problem = new HeuristicLab.Problems.GrammaticalEvolution.GEArtificialAntProblem();
+      var problem = new global::HeuristicLab.Problems.GrammaticalEvolution.GEArtificialAntProblem();
       #endregion
       #region Algorithm Configuration
@@ -96,5 +96,5 @@
 
       #region Problem Configuration
-      var problem = new HeuristicLab.Problems.GrammaticalEvolution.GESymbolicRegressionSingleObjectiveProblem();
+      var problem = new global::HeuristicLab.Problems.GrammaticalEvolution.GESymbolicRegressionSingleObjectiveProblem();
 
       #endregion
Index: /branches/MemPRAlgorithm/HeuristicLab.Tests/HeuristicLab-3.3/Samples/IslandGaTspSampleTest.cs
===================================================================
--- /branches/MemPRAlgorithm/HeuristicLab.Tests/HeuristicLab-3.3/Samples/IslandGaTspSampleTest.cs	(revision 14476)
+++ /branches/MemPRAlgorithm/HeuristicLab.Tests/HeuristicLab-3.3/Samples/IslandGaTspSampleTest.cs	(revision 14477)
@@ -64,5 +64,5 @@
       TravelingSalesmanProblem tspProblem = new TravelingSalesmanProblem();
       tspProblem.Load(provider.LoadData(instance));
-      tspProblem.UseDistanceMatrix.Value = true;
+      tspProblem.UseDistanceMatrix = true;
       #endregion
       #region Algorithm Configuration
Index: /branches/MemPRAlgorithm/HeuristicLab.Tests/HeuristicLab-3.3/Samples/LocalSearchKnapsackSampleTest.cs
===================================================================
--- /branches/MemPRAlgorithm/HeuristicLab.Tests/HeuristicLab-3.3/Samples/LocalSearchKnapsackSampleTest.cs	(revision 14476)
+++ /branches/MemPRAlgorithm/HeuristicLab.Tests/HeuristicLab-3.3/Samples/LocalSearchKnapsackSampleTest.cs	(revision 14477)
@@ -60,5 +60,5 @@
       KnapsackProblem problem = new KnapsackProblem();
       problem.BestKnownQuality = new DoubleValue(362);
-      problem.BestKnownSolution = new HeuristicLab.Encodings.BinaryVectorEncoding.BinaryVector(new bool[] { 
+      problem.BestKnownSolution = new global::HeuristicLab.Encodings.BinaryVectorEncoding.BinaryVector(new bool[] { 
        true , false, false, true , true , true , true , true , false, true , true , true , true , true , true , false, true , false, true , true , false, true , true , false, true , false, true , true , true , false, true , true , false, true , true , false, true , false, true , true , true , true , true , true , true , true , true , true , true , true , true , false, true , false, false, true , true , false, true , true , true , true , true , true , true , true , false, true , false, true , true , true , true , false, true , true , true , true , true , true , true , true});
       problem.EvaluatorParameter.Value = new KnapsackEvaluator();
Index: /branches/MemPRAlgorithm/HeuristicLab.Tests/HeuristicLab-3.3/Samples/TabuSearchTspSampleTest.cs
===================================================================
--- /branches/MemPRAlgorithm/HeuristicLab.Tests/HeuristicLab-3.3/Samples/TabuSearchTspSampleTest.cs	(revision 14476)
+++ /branches/MemPRAlgorithm/HeuristicLab.Tests/HeuristicLab-3.3/Samples/TabuSearchTspSampleTest.cs	(revision 14477)
@@ -62,5 +62,5 @@
       TravelingSalesmanProblem tspProblem = new TravelingSalesmanProblem();
       tspProblem.Load(provider.LoadData(instance));
-      tspProblem.UseDistanceMatrix.Value = true;
+      tspProblem.UseDistanceMatrix = true;
       #endregion
       #region Algorithm Configuration
@@ -76,5 +76,5 @@
       ts.MoveGenerator = moveGenerator;
       var moveEvaluator = ts.MoveEvaluatorParameter.ValidValues
-        .OfType<TSPInversionMoveRoundedEuclideanPathEvaluator>()
+        .OfType<TSPInversionMovePathEvaluator>()
         .Single();
       ts.MoveEvaluator = moveEvaluator;
Index: /branches/MemPRAlgorithm/HeuristicLab.Tests/HeuristicLab-3.3/Samples/VnsTspSampleTest.cs
===================================================================
--- /branches/MemPRAlgorithm/HeuristicLab.Tests/HeuristicLab-3.3/Samples/VnsTspSampleTest.cs	(revision 14476)
+++ /branches/MemPRAlgorithm/HeuristicLab.Tests/HeuristicLab-3.3/Samples/VnsTspSampleTest.cs	(revision 14477)
@@ -66,9 +66,9 @@
 {48, 71}, {49, 71}, {50, 71}, {44, 70}, {45, 70}, {52, 70}, {53, 70}, {54, 70}, {41, 69}, {42, 69}, {55, 69}, {56, 69}, {40, 68}, {56, 68}, {57, 68}, {39, 67}, {57, 67}, {58, 67}, {59, 67}, {38, 66}, {59, 66}, {60, 66}, {37, 65}, {60, 65}, {36, 64}, {43, 64}, {35, 63}, {37, 63}, {41, 63}, {42, 63}, {43, 63}, {47, 63}, {61, 63}, {40, 62}, {41, 62}, {42, 62}, {43, 62}, {45, 62}, {46, 62}, {47, 62}, {62, 62}, {34, 61}, {38, 61}, {39, 61}, {42, 61}, {43, 61}, {44, 61}, {45, 61}, {46, 61}, {47, 61}, {52, 61}, {62, 61}, {63, 61}, {26, 60}, {38, 60}, {42, 60}, {43, 60}, {44, 60}, {46, 60}, {47, 60}, {63, 60}, {23, 59}, {24, 59}, {27, 59}, {29, 59}, {30, 59}, {31, 59}, {33, 59}, {42, 59}, {46, 59}, {47, 59}, {63, 59}, {21, 58}, {32, 58}, {33, 58}, {34, 58}, {35, 58}, {46, 58}, {47, 58}, {48, 58}, {53, 58}, {21, 57}, {35, 57}, {47, 57}, {48, 57}, {53, 57}, {36, 56}, {37, 56}, {46, 56}, {47, 56}, {48, 56}, {64, 56}, {65, 56}, {20, 55}, {38, 55}, {46, 55}, {47, 55}, {48, 55}, {52, 55}, {21, 54}, {40, 54}, {47, 54}, {48, 54}, {52, 54}, {65, 54}, {30, 53}, {41, 53}, {46, 53}, {47, 53}, {48, 53}, {52, 53}, {65, 53}, {21, 52}, {32, 52}, {33, 52}, {42, 52}, {51, 52}, {21, 51}, {33, 51}, {34, 51}, {43, 51}, {51, 51}, {21, 50}, {35, 50}, {44, 50}, {50, 50}, {66, 50}, {67, 50}, {21, 49}, {34, 49}, {36, 49}, {37, 49}, {46, 49}, {49, 49}, {67, 49}, {22, 48}, {36, 48}, {37, 48}, {46, 48}, {47, 48}, {22, 47}, {30, 47}, {34, 47}, {37, 47}, {38, 47}, {39, 47}, {47, 47}, {48, 47}, {67, 47}, {23, 46}, {28, 46}, {29, 46}, {30, 46}, {31, 46}, {32, 46}, {35, 46}, {37, 46}, {38, 46}, {39, 46}, {49, 46}, {67, 46}, {23, 45}, {28, 45}, {29, 45}, {31, 45}, {32, 45}, {40, 45}, {41, 45}, {49, 45}, {50, 45}, {68, 45}, {24, 44}, {29, 44}, {32, 44}, {41, 44}, {51, 44}, {68, 44}, {25, 43}, {30, 43}, {32, 43}, {42, 43}, {43, 43}, {51, 43}, {68, 43}, {69, 43}, {31, 42}, {32, 42}, {43, 42}, {52, 42}, {55, 42}, {26, 41}, {27, 41}, {31, 41}, {32, 41}, {33, 41}, {44, 41}, {45, 41}, {46, 41}, {47, 41}, {48, 41}, {49, 41}, {53, 41}, {25, 40}, {27, 40}, {32, 40}, {43, 40}, {44, 40}, {45, 40}, {46, 40}, {48, 40}, {49, 40}, {50, 40}, {51, 40}, {53, 40}, {56, 40}, {32, 39}, {33, 39}, {43, 39}, {50, 39}, {51, 39}, {54, 39}, {56, 39}, {69, 39}, {24, 38}, {32, 38}, {41, 38}, {42, 38}, {51, 38}, {52, 38}, {54, 38}, {57, 38}, {69, 38}, {31, 37}, {32, 37}, {40, 37}, {41, 37}, {42, 37}, {43, 37}, {44, 37}, {45, 37}, {46, 37}, {47, 37}, {48, 37}, {51, 37}, {52, 37}, {55, 37}, {57, 37}, {69, 37}, {24, 36}, {31, 36}, {32, 36}, {39, 36}, {40, 36}, {41, 36}, {42, 36}, {43, 36}, {45, 36}, {48, 36}, {49, 36}, {51, 36}, {53, 36}, {55, 36}, {58, 36}, {22, 35}, {23, 35}, {24, 35}, {25, 35}, {30, 35}, {31, 35}, {32, 35}, {39, 35}, {41, 35}, {49, 35}, {51, 35}, {55, 35}, {56, 35}, {58, 35}, {71, 35}, {20, 34}, {27, 34}, {30, 34}, {31, 34}, {51, 34}, {53, 34}, {57, 34}, {60, 34}, {18, 33}, {19, 33}, {29, 33}, {30, 33}, {31, 33}, {45, 33}, {46, 33}, {47, 33}, {52, 33}, {53, 33}, {55, 33}, {57, 33}, {58, 33}, {17, 32}, {30, 32}, {44, 32}, {47, 32}, {54, 32}, {57, 32}, {59, 32}, {61, 32}, {71, 32}, {72, 32}, {43, 31}, {47, 31}, {56, 31}, {58, 31}, {59, 31}, {61, 31}, {72, 31}, {74, 31}, {16, 30}, {43, 30}, {46, 30}, {47, 30}, {59, 30}, {63, 30}, {71, 30}, {75, 30}, {43, 29}, {46, 29}, {47, 29}, {59, 29}, {60, 29}, {75, 29}, {15, 28}, {43, 28}, {46, 28}, {61, 28}, {76, 28}, {15, 27}, {43, 27}, {44, 27}, {45, 27}, {46, 27}, {60, 27}, {62, 27}, {15, 26}, {43, 26}, {44, 26}, {46, 26}, {59, 26}, {60, 26}, {64, 26}, {77, 26}, {15, 25}, {58, 25}, {61, 25}, {77, 25}, {15, 24}, {53, 24}, {55, 24}, {61, 24}, {77, 24}, {62, 23}, {16, 22}, {61, 22}, {62, 22}, {15, 21}, {16, 21}, {52, 21}, {63, 21}, {77, 21}, {16, 20}, {17, 20}, {46, 20}, {47, 20}, {60, 20}, {62, 20}, {63, 20}, {65, 20}, {76, 20}, {15, 19}, {17, 19}, {18, 19}, {44, 19}, {45, 19}, {48, 19}, {53, 19}, {56, 19}, {60, 19}, {62, 19}, {67, 19}, {68, 19}, {76, 19}, {15, 18}, {18, 18}, {19, 18}, {20, 18}, {32, 18}, {33, 18}, {34, 18}, {41, 18}, {42, 18}, {43, 18}, {46, 18}, {48, 18}, {53, 18}, {59, 18}, {60, 18}, {69, 18}, {75, 18}, {16, 17}, {17, 17}, {20, 17}, {21, 17}, {22, 17}, {23, 17}, {24, 17}, {26, 17}, {28, 17}, {29, 17}, {30, 17}, {31, 17}, {32, 17}, {34, 17}, {35, 17}, {36, 17}, {37, 17}, {38, 17}, {39, 17}, {40, 17}, {44, 17}, {46, 17}, {48, 17}, {53, 17}, {56, 17}, {58, 17}, {75, 17}, {17, 16}, {18, 16}, {20, 16}, {24, 16}, {26, 16}, {27, 16}, {29, 16}, {33, 16}, {41, 16}, {42, 16}, {44, 16}, {47, 16}, {52, 16}, {57, 16}, {70, 16}, {73, 16}, {74, 16}, {17, 15}, {18, 15}, {20, 15}, {22, 15}, {24, 15}, {27, 15}, {29, 15}, {31, 15}, {33, 15}, {35, 15}, {36, 15}, {38, 15}, {39, 15}, {42, 15}, {45, 15}, {47, 15}, {52, 15}, {53, 15}, {55, 15}, {56, 15}, {70, 15}, {73, 15}, {17, 14}, {19, 14}, {21, 14}, {24, 14}, {26, 14}, {29, 14}, {31, 14}, {34, 14}, {37, 14}, {40, 14}, {42, 14}, {44, 14}, {46, 14}, {47, 14}, {53, 14}, {54, 14}, {55, 14}, {62, 14}, {70, 14}, {72, 14}, {17, 13}, {19, 13}, {21, 13}, {23, 13}, {25, 13}, {27, 13}, {30, 13}, {32, 13}, {34, 13}, {36, 13}, {38, 13}, {41, 13}, {43, 13}, {44, 13}, {45, 13}, {60, 13}, {70, 13}, {71, 13}, {18, 12}, {21, 12}, {23, 12}, {26, 12}, {28, 12}, {31, 12}, {34, 12}, {37, 12}, {39, 12}, {41, 12}, {42, 12}, {70, 12}, {18, 11}, {19, 11}, {20, 11}, {21, 11}, {24, 11}, {25, 11}, {27, 11}, {29, 11}, {31, 11}, {33, 11}, {35, 11}, {38, 11}, {41, 11}, {59, 11}, {26, 10}, {29, 10}, {32, 10}, {34, 10}, {36, 10}, {39, 10}, {40, 10}, {69, 10}, {21, 9}, {26, 9}, {28, 9}, {30, 9}, {32, 9}, {33, 9}, {35, 9}, {36, 9}, {37, 9}, {38, 9}, {39, 9}, {22, 8}, {27, 8}, {28, 8}, {29, 8}, {30, 8}, {31, 8}, {68, 8}, {23, 7}, {66, 7}, {24, 6}, {65, 6}, {25, 5}, {62, 5}, {63, 5}, {26, 4}, {55, 4}, {56, 4}, {57, 4}, {58, 4}, {59, 4}, {60, 4}, {61, 4}, {28, 3}, {53, 3}, {29, 2}, {50, 2}, {51, 2}, {52, 2}, {31, 1}, {32, 1}, {48, 1}
       });
-      tspProblem.BestKnownQuality = new DoubleValue(867);
+      tspProblem.BestKnownQuality = 867;
 
-      tspProblem.EvaluatorParameter.Value = new TSPRoundedEuclideanPathEvaluator();
+      tspProblem.DistanceFunction = TSPDistanceFunction.RoundedEuclidean;
       tspProblem.SolutionCreatorParameter.Value = new RandomPermutationCreator();
-      tspProblem.UseDistanceMatrix.Value = true;
+      tspProblem.UseDistanceMatrix = true;
       tspProblem.Name = "Funny TSP";
       tspProblem.Description = "Represents a symmetric Traveling Salesman Problem.";
@@ -87,5 +87,5 @@
         .Single();
       localImprovement.MoveEvaluator = localImprovement.MoveEvaluatorParameter.ValidValues
-        .OfType<TSPInversionMoveRoundedEuclideanPathEvaluator>()
+        .OfType<TSPInversionMovePathEvaluator>()
         .Single();
       localImprovement.MoveMaker = localImprovement.MoveMakerParameter.ValidValues
Index: /branches/MemPRAlgorithm/HeuristicLab.Tests/HeuristicLab.Algorithms.DataAnalysis-3.4/SupportVectorMachineTest.cs
===================================================================
--- /branches/MemPRAlgorithm/HeuristicLab.Tests/HeuristicLab.Algorithms.DataAnalysis-3.4/SupportVectorMachineTest.cs	(revision 14476)
+++ /branches/MemPRAlgorithm/HeuristicLab.Tests/HeuristicLab.Algorithms.DataAnalysis-3.4/SupportVectorMachineTest.cs	(revision 14477)
@@ -61,5 +61,5 @@
       var cv = new CrossValidation();
       cv.Algorithm = new SupportVectorRegression();
-      var rand = new HeuristicLab.Random.MersenneTwister();
+      var rand = new global::HeuristicLab.Random.MersenneTwister();
       double[,] data = GenerateData(1000, rand);
       List<string> variables = new List<string>() { "x1", "x2", "x3", "x4", "x5", "x6", "x7", "x8", "x9", "x10", "y" };
Index: /branches/MemPRAlgorithm/HeuristicLab.Tests/HeuristicLab.Encodings.LinearLinkageEncoding-3.3/MoveTests.cs
===================================================================
--- /branches/MemPRAlgorithm/HeuristicLab.Tests/HeuristicLab.Encodings.LinearLinkageEncoding-3.3/MoveTests.cs	(revision 14477)
+++ /branches/MemPRAlgorithm/HeuristicLab.Tests/HeuristicLab.Encodings.LinearLinkageEncoding-3.3/MoveTests.cs	(revision 14477)
@@ -0,0 +1,26 @@
+﻿using System;
+using System.Linq;
+using HeuristicLab.Encodings.LinearLinkageEncoding;
+using HeuristicLab.Random;
+using Microsoft.VisualStudio.TestTools.UnitTesting;
+
+namespace HeuristicLab.Tests.HeuristicLab.Encodings.LinearLinkageEncoding {
+  [TestClass]
+  public class LinearLinkageMoveTests {
+    [TestMethod]
+    public void TestApplyUndo() {
+      var random = new MersenneTwister(42);
+      var lle = MaxGroupsLinearLinkageCreator.Apply(random, 32, 8);
+      var before = (LinearLinkage)lle.Clone();
+      var moves = 0;
+      foreach (var move in MoveGenerator.Generate(lle)) {
+        move.Apply(lle);
+        Assert.IsFalse(before.SequenceEqual(lle));
+        move.Undo(lle);
+        Assert.IsTrue(before.SequenceEqual(lle));
+        moves++;
+      }
+      Assert.IsTrue(moves > 0);
+    }
+  }
+}
Index: /branches/MemPRAlgorithm/HeuristicLab.Tests/HeuristicLab.Problems.TravelingSalesman-3.3/TSPMoveEvaluatorTest.cs
===================================================================
--- /branches/MemPRAlgorithm/HeuristicLab.Tests/HeuristicLab.Problems.TravelingSalesman-3.3/TSPMoveEvaluatorTest.cs	(revision 14476)
+++ /branches/MemPRAlgorithm/HeuristicLab.Tests/HeuristicLab.Problems.TravelingSalesman-3.3/TSPMoveEvaluatorTest.cs	(revision 14477)
@@ -61,5 +61,5 @@
     [TestProperty("Time", "short")]
     public void InversionMoveEvaluatorTest() {
-      var evaluator = new TSPRoundedEuclideanPathEvaluator();
+      /*var evaluator = new TSPRoundedEuclideanPathEvaluator();
       var moveEvaluator = new TSPInversionMoveRoundedEuclideanPathEvaluator();
       double beforeMatrix = TSPDistanceMatrixEvaluator.Apply(distances, tour);
@@ -87,5 +87,5 @@
         beforeMatrix = afterMatrix;
         beforeCoordinates = afterCoordinates;
-      }
+      }*/
     }
 
@@ -94,5 +94,5 @@
     [TestProperty("Time", "short")]
     public void TranslocationMoveEvaluatorTest() {
-      var evaluator = new TSPRoundedEuclideanPathEvaluator();
+      /*var evaluator = new TSPRoundedEuclideanPathEvaluator();
       var moveEvaluator = new TSPTranslocationMoveRoundedEuclideanPathEvaluator();
       double beforeMatrix = TSPDistanceMatrixEvaluator.Apply(distances, tour);
@@ -119,5 +119,5 @@
         beforeMatrix = afterMatrix;
         beforeCoordinates = afterCoordinates;
-      }
+      }*/
     }
 
Index: /branches/MemPRAlgorithm/HeuristicLab.Tests/HeuristicLab.Tests.csproj
===================================================================
--- /branches/MemPRAlgorithm/HeuristicLab.Tests/HeuristicLab.Tests.csproj	(revision 14476)
+++ /branches/MemPRAlgorithm/HeuristicLab.Tests/HeuristicLab.Tests.csproj	(revision 14477)
@@ -510,4 +510,5 @@
     <Compile Include="HeuristicLab.Encodings.IntegerVectorEncoding-3.3\SinglePointCrossoverTest.cs" />
     <Compile Include="HeuristicLab.Encodings.IntegerVectorEncoding-3.3\UniformOnePositionManipulatorTest.cs" />
+    <Compile Include="HeuristicLab.Encodings.LinearLinkageEncoding-3.3\MoveTests.cs" />
     <Compile Include="HeuristicLab.Encodings.PermutationEncoding-3.3\Auxiliary.cs" />
     <Compile Include="HeuristicLab.Encodings.PermutationEncoding-3.3\CosaCrossoverTest.cs" />
