Index: trunk/sources/HeuristicLab.Encodings.LinearLinkageEncoding/3.4/HeuristicLab.Encodings.LinearLinkageEncoding-3.4.csproj
===================================================================
--- trunk/sources/HeuristicLab.Encodings.LinearLinkageEncoding/3.4/HeuristicLab.Encodings.LinearLinkageEncoding-3.4.csproj	(revision 15077)
+++ trunk/sources/HeuristicLab.Encodings.LinearLinkageEncoding/3.4/HeuristicLab.Encodings.LinearLinkageEncoding-3.4.csproj	(revision 15079)
@@ -165,4 +165,5 @@
     <Compile Include="Crossovers\SinglePointCrossover.cs" />
     <Compile Include="Interfaces\ILinearLinkageMoveOperator.cs" />
+    <Compile Include="Interfaces\ILinearLinkageEMSSMoveOperator.cs" />
     <Compile Include="Interfaces\ILinearLinkageSwap2MoveOperator.cs" />
     <Compile Include="Interfaces\ILinearLinkageCreator.cs" />
@@ -177,10 +178,14 @@
     <Compile Include="Manipulators\MergeGroupManipulator.cs" />
     <Compile Include="Manipulators\MultiLLEManipulator.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="Moves\EMSS\EMSSMoveMaker.cs" />
+    <Compile Include="Moves\EMSS\ExtractMove.cs" />
+    <Compile Include="Moves\EMSS\MergeMove.cs" />
+    <Compile Include="Moves\EMSS\EMSSMove.cs" />
+    <Compile Include="Moves\EMSS\ExhaustiveEMSSMoveGenerator.cs" />
+    <Compile Include="Moves\EMSS\EMSSMoveGenerator.cs" />
+    <Compile Include="Moves\EMSS\StochasticEMSSMultiMoveGenerator.cs" />
+    <Compile Include="Moves\EMSS\StochasticEMSSSingleMoveGenerator.cs" />
+    <Compile Include="Moves\EMSS\ShiftMove.cs" />
+    <Compile Include="Moves\EMSS\SplitMove.cs" />
     <Compile Include="Moves\Swap\ExhaustiveSwap2MoveGenerator.cs" />
     <Compile Include="Moves\Swap\StochasticSwap2MultiMoveGenerator.cs" />
Index: trunk/sources/HeuristicLab.Encodings.LinearLinkageEncoding/3.4/Interfaces/ILinearLinkageEMSSMoveOperator.cs
===================================================================
--- trunk/sources/HeuristicLab.Encodings.LinearLinkageEncoding/3.4/Interfaces/ILinearLinkageEMSSMoveOperator.cs	(revision 15079)
+++ trunk/sources/HeuristicLab.Encodings.LinearLinkageEncoding/3.4/Interfaces/ILinearLinkageEMSSMoveOperator.cs	(revision 15079)
@@ -0,0 +1,28 @@
+﻿#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.Core;
+
+namespace HeuristicLab.Encodings.LinearLinkageEncoding {
+  public interface ILinearLinkageEMSSMoveOperator : ILinearLinkageMoveOperator {
+    ILookupParameter<EMSSMove> EMSSMoveParameter { get; }
+  }
+}
Index: trunk/sources/HeuristicLab.Encodings.LinearLinkageEncoding/3.4/Moves/EMSS/EMSSMove.cs
===================================================================
--- trunk/sources/HeuristicLab.Encodings.LinearLinkageEncoding/3.4/Moves/EMSS/EMSSMove.cs	(revision 15079)
+++ trunk/sources/HeuristicLab.Encodings.LinearLinkageEncoding/3.4/Moves/EMSS/EMSSMove.cs	(revision 15079)
@@ -0,0 +1,49 @@
+﻿#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.Common;
+using HeuristicLab.Core;
+using HeuristicLab.Persistence.Default.CompositeSerializers.Storable;
+
+namespace HeuristicLab.Encodings.LinearLinkageEncoding {
+  [Item("EMSSMove", "Base class for shift, split, merge, and extract moves.")]
+  [StorableClass]
+  public abstract class EMSSMove : Item {
+    [Storable]
+    private int item;
+    public int Item { get { return item; } }
+
+    [StorableConstructor]
+    protected EMSSMove(bool deserializing) : base(deserializing) { }
+    protected EMSSMove(EMSSMove original, Cloner cloner)
+      : base(original, cloner) {
+      item = original.item;
+    }
+    protected EMSSMove(int item) : base() {
+      this.item = item;
+    }
+    
+    public abstract void Apply(LinearLinkage lle);
+    public abstract void Undo(LinearLinkage lle);
+
+    public abstract void ApplyToLLEb(int[] lleb);
+  }
+}
Index: trunk/sources/HeuristicLab.Encodings.LinearLinkageEncoding/3.4/Moves/EMSS/EMSSMoveGenerator.cs
===================================================================
--- trunk/sources/HeuristicLab.Encodings.LinearLinkageEncoding/3.4/Moves/EMSS/EMSSMoveGenerator.cs	(revision 15079)
+++ trunk/sources/HeuristicLab.Encodings.LinearLinkageEncoding/3.4/Moves/EMSS/EMSSMoveGenerator.cs	(revision 15079)
@@ -0,0 +1,66 @@
+﻿#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.Common;
+using HeuristicLab.Core;
+using HeuristicLab.Operators;
+using HeuristicLab.Optimization;
+using HeuristicLab.Parameters;
+using HeuristicLab.Persistence.Default.CompositeSerializers.Storable;
+
+namespace HeuristicLab.Encodings.LinearLinkageEncoding {
+  [Item("EMSSMoveGenerator", "Base class for all EMSS move generators (extract, merge, shift, and split).")]
+  [StorableClass]
+  public abstract class EMSSMoveGenerator : SingleSuccessorOperator, ILinearLinkageEMSSMoveOperator, IMoveGenerator {
+    public override bool CanChangeName {
+      get { return false; }
+    }
+    public ILookupParameter<LinearLinkage> LLEParameter {
+      get { return (ILookupParameter<LinearLinkage>)Parameters["LLE"]; }
+    }
+    public ILookupParameter<EMSSMove> EMSSMoveParameter {
+      get { return (LookupParameter<EMSSMove>)Parameters["EMSSMove"]; }
+    }
+
+    [StorableConstructor]
+    protected EMSSMoveGenerator(bool deserializing) : base(deserializing) { }
+    protected EMSSMoveGenerator(EMSSMoveGenerator original, Cloner cloner) : base(original, cloner) { }
+    public EMSSMoveGenerator()
+      : base() {
+      Parameters.Add(new LookupParameter<LinearLinkage>("LLE", "The LLE solution for which moves should be generated."));
+      Parameters.Add(new LookupParameter<EMSSMove>("EMSSMove", "The moves that should be generated in subscopes."));
+    }
+
+    public override IOperation Apply() {
+      var lle = LLEParameter.ActualValue;
+      var moves = GenerateMoves(lle);
+      var moveScopes = new Scope[moves.Length];
+      for (var i = 0; i < moveScopes.Length; i++) {
+        moveScopes[i] = new Scope(i.ToString());
+        moveScopes[i].Variables.Add(new Variable(EMSSMoveParameter.ActualName, moves[i]));
+      }
+      ExecutionContext.Scope.SubScopes.AddRange(moveScopes);
+      return base.Apply();
+    }
+
+    protected abstract EMSSMove[] GenerateMoves(LinearLinkage lle);
+  }
+}
Index: trunk/sources/HeuristicLab.Encodings.LinearLinkageEncoding/3.4/Moves/EMSS/EMSSMoveMaker.cs
===================================================================
--- trunk/sources/HeuristicLab.Encodings.LinearLinkageEncoding/3.4/Moves/EMSS/EMSSMoveMaker.cs	(revision 15079)
+++ trunk/sources/HeuristicLab.Encodings.LinearLinkageEncoding/3.4/Moves/EMSS/EMSSMoveMaker.cs	(revision 15079)
@@ -0,0 +1,78 @@
+﻿#region License Information
+/* HeuristicLab
+ * Copyright (C) 2002-2017 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.Common;
+using HeuristicLab.Core;
+using HeuristicLab.Data;
+using HeuristicLab.Operators;
+using HeuristicLab.Optimization;
+using HeuristicLab.Parameters;
+using HeuristicLab.Persistence.Default.CompositeSerializers.Storable;
+
+namespace HeuristicLab.Encodings.LinearLinkageEncoding {
+  [Item("EMSSMoveMaker", "Applies an EMSS move to the lle grouping (extract, merge, shift, and split.")]
+  [StorableClass]
+  public class EMSSMoveMaker : SingleSuccessorOperator, ILinearLinkageEMSSMoveOperator, IMoveMaker, ISingleObjectiveOperator {
+    public override bool CanChangeName {
+      get { return false; }
+    }
+    public ILookupParameter<DoubleValue> QualityParameter {
+      get { return (ILookupParameter<DoubleValue>)Parameters["Quality"]; }
+    }
+    public ILookupParameter<DoubleValue> MoveQualityParameter {
+      get { return (ILookupParameter<DoubleValue>)Parameters["MoveQuality"]; }
+    }
+    public ILookupParameter<EMSSMove> EMSSMoveParameter {
+      get { return (ILookupParameter<EMSSMove>)Parameters["EMSSMove"]; }
+    }
+    public ILookupParameter<LinearLinkage> LLEParameter {
+      get { return (ILookupParameter<LinearLinkage>)Parameters["LLE"]; }
+    }
+
+    [StorableConstructor]
+    protected EMSSMoveMaker(bool deserializing) : base(deserializing) { }
+    protected EMSSMoveMaker(EMSSMoveMaker original, Cloner cloner) : base(original, cloner) { }
+    public EMSSMoveMaker()
+      : base() {
+      Parameters.Add(new LookupParameter<DoubleValue>("Quality", "The quality of the solution."));
+      Parameters.Add(new LookupParameter<EMSSMove>("EMSSMove", "The move to apply."));
+      Parameters.Add(new LookupParameter<DoubleValue>("MoveQuality", "The relative quality of the move."));
+      Parameters.Add(new LookupParameter<LinearLinkage>("LLE", "The linear linkage encoded solution to which the move should be applied."));
+    }
+
+    public override IDeepCloneable Clone(Cloner cloner) {
+      return new EMSSMoveMaker(this, cloner);
+    }
+
+    public override IOperation Apply() {
+      var move = EMSSMoveParameter.ActualValue;
+      var lle = LLEParameter.ActualValue;
+      var moveQuality = MoveQualityParameter.ActualValue;
+      var quality = QualityParameter.ActualValue;
+
+      move.Apply(lle);
+
+      quality.Value = moveQuality.Value;
+
+      return base.Apply();
+    }
+  }
+}
Index: trunk/sources/HeuristicLab.Encodings.LinearLinkageEncoding/3.4/Moves/EMSS/ExhaustiveEMSSMoveGenerator.cs
===================================================================
--- trunk/sources/HeuristicLab.Encodings.LinearLinkageEncoding/3.4/Moves/EMSS/ExhaustiveEMSSMoveGenerator.cs	(revision 15079)
+++ trunk/sources/HeuristicLab.Encodings.LinearLinkageEncoding/3.4/Moves/EMSS/ExhaustiveEMSSMoveGenerator.cs	(revision 15079)
@@ -0,0 +1,89 @@
+﻿#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 System.Collections.Generic;
+using System.Linq;
+using HeuristicLab.Common;
+using HeuristicLab.Core;
+using HeuristicLab.Optimization;
+using HeuristicLab.Persistence.Default.CompositeSerializers.Storable;
+
+namespace HeuristicLab.Encodings.LinearLinkageEncoding {
+  [Item("ExhaustiveEMSSMoveGenerator", "Generates all possible extract, merge, shift, and split (EMSS) moves from a given LLE solution.")]
+  [StorableClass]
+  public class ExhaustiveEMSSMoveGenerator : EMSSMoveGenerator, IExhaustiveMoveGenerator {
+    [StorableConstructor]
+    protected ExhaustiveEMSSMoveGenerator(bool deserializing) : base(deserializing) { }
+    protected ExhaustiveEMSSMoveGenerator(ExhaustiveEMSSMoveGenerator original, Cloner cloner) : base(original, cloner) { }
+    public ExhaustiveEMSSMoveGenerator() : base() { }
+
+    public override IDeepCloneable Clone(Cloner cloner) {
+      return new ExhaustiveEMSSMoveGenerator(this, cloner);
+    }
+
+    protected override EMSSMove[] GenerateMoves(LinearLinkage lle) {
+      int length = lle.Length;
+      if (length == 1) throw new ArgumentException("ExhaustiveEMSSMoveGenerator: There cannot be a move given only one item.", "lle");
+
+      return Generate(lle).ToArray();
+    }
+
+    public static IEnumerable<EMSSMove> GenerateForItem(int i, List<int> groupItems, LinearLinkage lle, int[] lleb) {
+      var pred = lleb[i];
+      var next = lle[i];
+      var isFirst = pred == i;
+      var isLast = next == i;
+
+      // First: shift i into each previous group
+      foreach (var m in groupItems.Where(x => lle[x] != i)) {
+        yield return new ShiftMove(i, pred, m, next, lle[m]);
+      }
+
+      if (!isLast) {
+        // Second: split group at i
+        yield return new SplitMove(i);
+
+        if (isFirst) {
+          // Third: merge with closed groups
+          foreach (var m in groupItems.Where(x => lle[x] == x)) {
+            yield return new MergeMove(i, m);
+          }
+        } else {
+          // Fourth: extract i into group of its own (exclude first and last, because of SplitMove)
+          yield return new ExtractMove(i, pred, next);
+        }
+      }
+    }
+
+    public static IEnumerable<EMSSMove> Generate(LinearLinkage lle) {
+      var groupItems = new List<int>();
+      var lleb = lle.ToBackLinks();
+      for (var i = 0; i < lle.Length; i++) {
+        foreach (var move in GenerateForItem(i, groupItems, lle, lleb))
+          yield return move;
+        if (lleb[i] != i)
+          groupItems.Remove(lleb[i]);
+        groupItems.Add(i);
+      }
+    }
+  }
+}
Index: trunk/sources/HeuristicLab.Encodings.LinearLinkageEncoding/3.4/Moves/EMSS/ExtractMove.cs
===================================================================
--- trunk/sources/HeuristicLab.Encodings.LinearLinkageEncoding/3.4/Moves/EMSS/ExtractMove.cs	(revision 15079)
+++ trunk/sources/HeuristicLab.Encodings.LinearLinkageEncoding/3.4/Moves/EMSS/ExtractMove.cs	(revision 15079)
@@ -0,0 +1,81 @@
+﻿#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.Common;
+using HeuristicLab.Core;
+using HeuristicLab.Persistence.Default.CompositeSerializers.Storable;
+
+namespace HeuristicLab.Encodings.LinearLinkageEncoding {
+  [Item("Extract Move", "Extracts an item into a group of its own.")]
+  [StorableClass]
+  public sealed class ExtractMove : EMSSMove {
+    [Storable]
+    private int previousItem;
+    public int PreviousItem { get { return previousItem; } }
+    [Storable]
+    private int nextItem;
+    public int NextItem { get { return nextItem; } }
+
+    private bool IsFirst { get { return PreviousItem == Item; } }
+    private bool IsLast { get { return NextItem == Item; } }
+
+
+    [StorableConstructor]
+    private ExtractMove(bool deserializing) : base(deserializing) { }
+    private ExtractMove(ExtractMove original, Cloner cloner)
+      : base(original, cloner) {
+      previousItem = original.previousItem;
+      nextItem = original.nextItem;
+    }
+    public ExtractMove(int item, int prev, int next)
+      : base(item) {
+      previousItem = prev;
+      nextItem = next;
+    }
+    
+    public override IDeepCloneable Clone(Cloner cloner) {
+      return new ExtractMove(this, cloner);
+    }
+
+    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 ApplyToLLEb(int[] lleb) {
+      if (!IsLast) lleb[NextItem] = IsFirst ? NextItem : PreviousItem;
+      lleb[Item] = Item;
+    }
+  }
+}
Index: trunk/sources/HeuristicLab.Encodings.LinearLinkageEncoding/3.4/Moves/EMSS/MergeMove.cs
===================================================================
--- trunk/sources/HeuristicLab.Encodings.LinearLinkageEncoding/3.4/Moves/EMSS/MergeMove.cs	(revision 15079)
+++ trunk/sources/HeuristicLab.Encodings.LinearLinkageEncoding/3.4/Moves/EMSS/MergeMove.cs	(revision 15079)
@@ -0,0 +1,64 @@
+﻿#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.Common;
+using HeuristicLab.Core;
+using HeuristicLab.Persistence.Default.CompositeSerializers.Storable;
+
+namespace HeuristicLab.Encodings.LinearLinkageEncoding {
+  [Item("Merge Move", "Merges two groups together.")]
+  [StorableClass]
+  public sealed class MergeMove : EMSSMove {
+    [Storable]
+    private int lastItemOfOtherGroup;
+    public int LastItemOfOtherGroup { get { return lastItemOfOtherGroup; } }
+    
+    [StorableConstructor]
+    private MergeMove(bool deserializing) : base(deserializing) { }
+    private MergeMove(MergeMove original, Cloner cloner)
+      : base(original, cloner) {
+      lastItemOfOtherGroup = original.lastItemOfOtherGroup;
+    }
+    public MergeMove(int item, int lastOfOther)
+      : base(item) {
+      lastItemOfOtherGroup = lastOfOther;
+    }
+    
+    public override IDeepCloneable Clone(Cloner cloner) {
+      return new MergeMove(this, cloner);
+    }
+
+    public override void Apply(LinearLinkage lle) {
+      if (lle[LastItemOfOtherGroup] != LastItemOfOtherGroup) throw new ArgumentException("Move conditions have changed, group does not terminate at " + 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);
+      lle[LastItemOfOtherGroup] = LastItemOfOtherGroup;
+    }
+
+    public override void ApplyToLLEb(int[] lleb) {
+      lleb[Item] = LastItemOfOtherGroup;
+    }
+  }
+}
Index: trunk/sources/HeuristicLab.Encodings.LinearLinkageEncoding/3.4/Moves/EMSS/ShiftMove.cs
===================================================================
--- trunk/sources/HeuristicLab.Encodings.LinearLinkageEncoding/3.4/Moves/EMSS/ShiftMove.cs	(revision 15079)
+++ trunk/sources/HeuristicLab.Encodings.LinearLinkageEncoding/3.4/Moves/EMSS/ShiftMove.cs	(revision 15079)
@@ -0,0 +1,100 @@
+﻿#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.Common;
+using HeuristicLab.Core;
+using HeuristicLab.Persistence.Default.CompositeSerializers.Storable;
+
+namespace HeuristicLab.Encodings.LinearLinkageEncoding {
+  [Item("Shift Move", "Shifts an item from one group to another.")]
+  [StorableClass]
+  public sealed class ShiftMove : EMSSMove {
+    [Storable]
+    private int previousItemOfOldGroup;
+    public int PreviousItemOfOldGroup { get { return previousItemOfOldGroup; } }
+    [Storable]
+    private int previousItemOfNewGroup;
+    public int PreviousItemOfNewGroup { get { return previousItemOfNewGroup; } }
+    [Storable]
+    private int nextItemOfOldGroup;
+    public int NextItemOfOldGroup { get { return nextItemOfOldGroup; } }
+    [Storable]
+    private int nextItemOfNewGroup;
+    public int NextItemOfNewGroup { get { return nextItemOfNewGroup; } }
+
+    private bool IsFirst { get { return PreviousItemOfOldGroup == Item; } }
+    private bool IsLast { get { return NextItemOfOldGroup == Item; } }
+    private bool NewGroupClosed { get { return PreviousItemOfNewGroup == NextItemOfNewGroup; } }
+
+    [StorableConstructor]
+    private ShiftMove(bool deserializing) : base(deserializing) { }
+    private ShiftMove(ShiftMove original, Cloner cloner)
+      : base(original, cloner) {
+      previousItemOfOldGroup = original.previousItemOfOldGroup;
+      previousItemOfNewGroup = original.previousItemOfNewGroup;
+      nextItemOfOldGroup = original.nextItemOfOldGroup;
+      nextItemOfNewGroup = original.nextItemOfNewGroup;
+    }
+    public ShiftMove(int item, int prevOld, int prevNew, int nextOld, int nextNew)
+      : base(item) {
+      previousItemOfOldGroup = prevOld;
+      previousItemOfNewGroup = prevNew;
+      nextItemOfOldGroup = nextOld;
+      nextItemOfNewGroup = nextNew;
+    }
+
+    public override IDeepCloneable Clone(Cloner cloner) {
+      return new ShiftMove(this, cloner);
+    }
+
+    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 ApplyToLLEb(int[] lleb) {
+      if (!IsLast)
+        lleb[NextItemOfOldGroup] = IsFirst ? NextItemOfOldGroup : PreviousItemOfOldGroup;
+      lleb[Item] = PreviousItemOfNewGroup;
+      if (!NewGroupClosed)
+        lleb[NextItemOfNewGroup] = Item;
+    }
+  }
+}
Index: trunk/sources/HeuristicLab.Encodings.LinearLinkageEncoding/3.4/Moves/EMSS/SplitMove.cs
===================================================================
--- trunk/sources/HeuristicLab.Encodings.LinearLinkageEncoding/3.4/Moves/EMSS/SplitMove.cs	(revision 15079)
+++ trunk/sources/HeuristicLab.Encodings.LinearLinkageEncoding/3.4/Moves/EMSS/SplitMove.cs	(revision 15079)
@@ -0,0 +1,66 @@
+﻿#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.Common;
+using HeuristicLab.Core;
+using HeuristicLab.Persistence.Default.CompositeSerializers.Storable;
+
+namespace HeuristicLab.Encodings.LinearLinkageEncoding {
+  [Item("Split Move", "Splits a group into two groups.")]
+  [StorableClass]
+  public sealed class SplitMove : EMSSMove {
+    [Storable]
+    private int nextItem; // is only used for undo -> no public property
+
+    [StorableConstructor]
+    private SplitMove(bool deserializing) : base(deserializing) { }
+    private SplitMove(SplitMove original, Cloner cloner)
+      : base(original, cloner) {
+      nextItem = original.nextItem;
+    }
+    public SplitMove(int item)
+      : base(item) {
+      nextItem = -1;
+    }
+    
+    public override IDeepCloneable Clone(Cloner cloner) {
+      return new SplitMove(this, cloner);
+    }
+
+    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 ApplyToLLEb(int[] lleb) {
+      if (nextItem < 0) throw new InvalidOperationException("Cannot undo move that has not been applied first to LLE.");
+      lleb[nextItem] = nextItem;
+    }
+  }
+}
Index: trunk/sources/HeuristicLab.Encodings.LinearLinkageEncoding/3.4/Moves/EMSS/StochasticEMSSMultiMoveGenerator.cs
===================================================================
--- trunk/sources/HeuristicLab.Encodings.LinearLinkageEncoding/3.4/Moves/EMSS/StochasticEMSSMultiMoveGenerator.cs	(revision 15079)
+++ trunk/sources/HeuristicLab.Encodings.LinearLinkageEncoding/3.4/Moves/EMSS/StochasticEMSSMultiMoveGenerator.cs	(revision 15079)
@@ -0,0 +1,70 @@
+﻿#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 System.Linq;
+using HeuristicLab.Common;
+using HeuristicLab.Core;
+using HeuristicLab.Data;
+using HeuristicLab.Optimization;
+using HeuristicLab.Parameters;
+using HeuristicLab.Persistence.Default.CompositeSerializers.Storable;
+using HeuristicLab.Random;
+
+namespace HeuristicLab.Encodings.LinearLinkageEncoding {
+  [Item("StochasticEMSSMultiMoveGenerator", "Randomly samples n from all possible EMSS moves (extract, merge, shift, and split) from a given lle grouping.")]
+  [StorableClass]
+  public class StochasticEMSSMultiMoveGenerator : EMSSMoveGenerator, IMultiMoveGenerator, IStochasticOperator {
+    public ILookupParameter<IRandom> RandomParameter {
+      get { return (ILookupParameter<IRandom>)Parameters["Random"]; }
+    }
+    public IValueLookupParameter<IntValue> SampleSizeParameter {
+      get { return (IValueLookupParameter<IntValue>)Parameters["SampleSize"]; }
+    }
+
+    public IntValue SampleSize {
+      get { return SampleSizeParameter.Value; }
+      set { SampleSizeParameter.Value = value; }
+    }
+
+    [StorableConstructor]
+    protected StochasticEMSSMultiMoveGenerator(bool deserializing) : base(deserializing) { }
+    protected StochasticEMSSMultiMoveGenerator(StochasticEMSSMultiMoveGenerator original, Cloner cloner) : base(original, cloner) { }
+    public StochasticEMSSMultiMoveGenerator()
+      : base() {
+      Parameters.Add(new LookupParameter<IRandom>("Random", "The random number generator."));
+      Parameters.Add(new ValueLookupParameter<IntValue>("SampleSize", "The number of moves to generate."));
+    }
+
+    public override IDeepCloneable Clone(Cloner cloner) {
+      return new StochasticEMSSMultiMoveGenerator(this, cloner);
+    }
+
+    protected override EMSSMove[] GenerateMoves(LinearLinkage lle) {
+      int length = lle.Length;
+      if (length == 1) throw new ArgumentException("StochasticEMSSMultiMoveGenerator: There cannot be a move given only one item.", "lle");
+
+      var random = RandomParameter.ActualValue;
+      var sampleSize = SampleSizeParameter.ActualValue.Value;
+      return ExhaustiveEMSSMoveGenerator.Generate(lle).Shuffle(random).Take(sampleSize).ToArray();
+    }
+  }
+}
Index: trunk/sources/HeuristicLab.Encodings.LinearLinkageEncoding/3.4/Moves/EMSS/StochasticEMSSSingleMoveGenerator.cs
===================================================================
--- trunk/sources/HeuristicLab.Encodings.LinearLinkageEncoding/3.4/Moves/EMSS/StochasticEMSSSingleMoveGenerator.cs	(revision 15079)
+++ trunk/sources/HeuristicLab.Encodings.LinearLinkageEncoding/3.4/Moves/EMSS/StochasticEMSSSingleMoveGenerator.cs	(revision 15079)
@@ -0,0 +1,59 @@
+﻿#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 System.Linq;
+using HeuristicLab.Common;
+using HeuristicLab.Core;
+using HeuristicLab.Optimization;
+using HeuristicLab.Parameters;
+using HeuristicLab.Persistence.Default.CompositeSerializers.Storable;
+using HeuristicLab.Random;
+
+namespace HeuristicLab.Encodings.LinearLinkageEncoding {
+  [Item("StochasticEMSSSingleMoveGenerator", "Randomly samples a single from all possible EMSS moves (extract, merge, shift, and split) from a given lle grouping.")]
+  [StorableClass]
+  public class StochasticEMSSSingleMoveGenerator : EMSSMoveGenerator, IStochasticOperator, ISingleMoveGenerator {
+    public ILookupParameter<IRandom> RandomParameter {
+      get { return (ILookupParameter<IRandom>)Parameters["Random"]; }
+    }
+
+    [StorableConstructor]
+    protected StochasticEMSSSingleMoveGenerator(bool deserializing) : base(deserializing) { }
+    protected StochasticEMSSSingleMoveGenerator(StochasticEMSSSingleMoveGenerator original, Cloner cloner) : base(original, cloner) { }
+    public StochasticEMSSSingleMoveGenerator()
+      : base() {
+      Parameters.Add(new LookupParameter<IRandom>("Random", "The random number generator."));
+    }
+
+    public override IDeepCloneable Clone(Cloner cloner) {
+      return new StochasticEMSSSingleMoveGenerator(this, cloner);
+    }
+
+    protected override EMSSMove[] GenerateMoves(LinearLinkage lle) {
+      int length = lle.Length;
+      if (length == 1) throw new ArgumentException("StochasticEMSSSingleMoveGenerator: There cannot be a move given only one item.", "lle");
+
+      var random = RandomParameter.ActualValue;
+      return new[] { ExhaustiveEMSSMoveGenerator.Generate(lle).Shuffle(random).First() };
+    }
+  }
+}
Index: trunk/sources/HeuristicLab.Encodings.LinearLinkageEncoding/3.4/Moves/ExtractMove.cs
===================================================================
--- trunk/sources/HeuristicLab.Encodings.LinearLinkageEncoding/3.4/Moves/ExtractMove.cs	(revision 15077)
+++ 	(revision )
@@ -1,60 +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;
-
-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 ApplyToLLEb(int[] lleb) {
-      if (!IsLast) lleb[NextItem] = IsFirst ? NextItem : PreviousItem;
-      lleb[Item] = Item;
-    }
-  }
-}
Index: trunk/sources/HeuristicLab.Encodings.LinearLinkageEncoding/3.4/Moves/MergeMove.cs
===================================================================
--- trunk/sources/HeuristicLab.Encodings.LinearLinkageEncoding/3.4/Moves/MergeMove.cs	(revision 15077)
+++ 	(revision )
@@ -1,48 +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;
-
-namespace HeuristicLab.Encodings.LinearLinkageEncoding {
-  public class MergeMove : Move {
-
-    public int LastItemOfOtherGroup { get; private set; }
-
-    public MergeMove(int item, int lastOfOther) {
-      Item = item;
-      LastItemOfOtherGroup = lastOfOther;
-    }
-
-    public override void Apply(LinearLinkage lle) {
-      if (lle[LastItemOfOtherGroup] != LastItemOfOtherGroup) throw new ArgumentException("Move conditions have changed, group does not terminate at " + 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);
-      lle[LastItemOfOtherGroup] = LastItemOfOtherGroup;
-    }
-
-    public override void ApplyToLLEb(int[] lleb) {
-      lleb[Item] = LastItemOfOtherGroup;
-    }
-  }
-}
Index: trunk/sources/HeuristicLab.Encodings.LinearLinkageEncoding/3.4/Moves/Move.cs
===================================================================
--- trunk/sources/HeuristicLab.Encodings.LinearLinkageEncoding/3.4/Moves/Move.cs	(revision 15077)
+++ 	(revision )
@@ -1,31 +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
-
-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 ApplyToLLEb(int[] lleb);
-  }
-}
Index: trunk/sources/HeuristicLab.Encodings.LinearLinkageEncoding/3.4/Moves/ShiftMove.cs
===================================================================
--- trunk/sources/HeuristicLab.Encodings.LinearLinkageEncoding/3.4/Moves/ShiftMove.cs	(revision 15077)
+++ 	(revision )
@@ -1,74 +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;
-
-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 ApplyToLLEb(int[] lleb) {
-      if (!IsLast)
-        lleb[NextItemOfOldGroup] = IsFirst ? NextItemOfOldGroup : PreviousItemOfOldGroup;
-      lleb[Item] = PreviousItemOfNewGroup;
-      if (!NewGroupClosed)
-        lleb[NextItemOfNewGroup] = Item;
-    }
-  }
-}
Index: trunk/sources/HeuristicLab.Encodings.LinearLinkageEncoding/3.4/Moves/SplitMove.cs
===================================================================
--- trunk/sources/HeuristicLab.Encodings.LinearLinkageEncoding/3.4/Moves/SplitMove.cs	(revision 15077)
+++ 	(revision )
@@ -1,51 +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;
-
-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 ApplyToLLEb(int[] lleb) {
-      if (nextItem < 0) throw new InvalidOperationException("Cannot undo move that has not been applied first to LLE.");
-      lleb[nextItem] = nextItem;
-    }
-  }
-}
Index: trunk/sources/HeuristicLab.Encodings.LinearLinkageEncoding/3.4/Moves/Swap/ExhaustiveSwap2MoveGenerator.cs
===================================================================
--- trunk/sources/HeuristicLab.Encodings.LinearLinkageEncoding/3.4/Moves/Swap/ExhaustiveSwap2MoveGenerator.cs	(revision 15077)
+++ trunk/sources/HeuristicLab.Encodings.LinearLinkageEncoding/3.4/Moves/Swap/ExhaustiveSwap2MoveGenerator.cs	(revision 15079)
@@ -29,5 +29,5 @@
 
 namespace HeuristicLab.Encodings.LinearLinkageEncoding {
-  [Item("ExhaustiveSwap2MoveGenerator", "Generates all possible swap-2 moves from a given permutation.")]
+  [Item("ExhaustiveSwap2MoveGenerator", "Generates all possible swap-2 moves from a given lle grouping.")]
   [StorableClass]
   public class ExhaustiveSwap2MoveGenerator : Swap2MoveGenerator, IExhaustiveMoveGenerator {
Index: trunk/sources/HeuristicLab.Encodings.LinearLinkageEncoding/3.4/Moves/Swap/StochasticSwap2SingleMoveGenerator.cs
===================================================================
--- trunk/sources/HeuristicLab.Encodings.LinearLinkageEncoding/3.4/Moves/Swap/StochasticSwap2SingleMoveGenerator.cs	(revision 15077)
+++ trunk/sources/HeuristicLab.Encodings.LinearLinkageEncoding/3.4/Moves/Swap/StochasticSwap2SingleMoveGenerator.cs	(revision 15079)
@@ -29,5 +29,5 @@
 
 namespace HeuristicLab.Encodings.LinearLinkageEncoding {
-  [Item("StochasticSwap2SingleMoveGenerator", "Randomly samples a single from all possible swap-2 moves from a given grouping.")]
+  [Item("StochasticSwap2SingleMoveGenerator", "Randomly samples a single from all possible swap-2 moves from a given lle grouping.")]
   [StorableClass]
   public class StochasticSwap2SingleMoveGenerator : Swap2MoveGenerator, IStochasticOperator, ISingleMoveGenerator {
Index: trunk/sources/HeuristicLab.Tests/HeuristicLab.Encodings.LinearLinkageEncoding-3.4/MoveTests.cs
===================================================================
--- trunk/sources/HeuristicLab.Tests/HeuristicLab.Encodings.LinearLinkageEncoding-3.4/MoveTests.cs	(revision 15077)
+++ trunk/sources/HeuristicLab.Tests/HeuristicLab.Encodings.LinearLinkageEncoding-3.4/MoveTests.cs	(revision 15079)
@@ -39,5 +39,5 @@
         var beforeb = before.ToBackLinks();
         var moves = 0;
-        foreach (var move in MoveGenerator.Generate(lle)) {
+        foreach (var move in ExhaustiveEMSSMoveGenerator.Generate(lle)) {
           var lleb = lle.ToBackLinks();
           move.Apply(lle);
@@ -66,5 +66,5 @@
         var moves = 0;
         for (var i = 1; i < lle.Length; i++) {
-          var move = MoveGenerator.GenerateForItem(i, groupItems, lle, lleb).SampleRandom(random);
+          var move = ExhaustiveEMSSMoveGenerator.GenerateForItem(i, groupItems, lle, lleb).SampleRandom(random);
           move.Apply(lle);
           move.ApplyToLLEb(lleb);
