Index: branches/LinearLinkage/HeuristicLab.Encodings.LinearLinkageEncoding/3.3/Creators/RandomLinearLinkageCreator.cs
===================================================================
--- branches/LinearLinkage/HeuristicLab.Encodings.LinearLinkageEncoding/3.3/Creators/RandomLinearLinkageCreator.cs	(revision 12286)
+++ branches/LinearLinkage/HeuristicLab.Encodings.LinearLinkageEncoding/3.3/Creators/RandomLinearLinkageCreator.cs	(revision 12288)
@@ -27,5 +27,5 @@
 
 namespace HeuristicLab.Encodings.LinearLinkageEncoding.Creators {
-  [Item("Random Linear Linkage Creator", "Creates a random linear linkage LLE-e encoded solution.")]
+  [Item("Random Linear Linkage Creator", "Creates a random linear linkage LLE encoded solution.")]
   [StorableClass]
   public sealed class RandomLinearLinkageCreator : LinearLinkageCreator {
Index: branches/LinearLinkage/HeuristicLab.Encodings.LinearLinkageEncoding/3.3/Crossovers/GroupCrossover.cs
===================================================================
--- branches/LinearLinkage/HeuristicLab.Encodings.LinearLinkageEncoding/3.3/Crossovers/GroupCrossover.cs	(revision 12286)
+++ branches/LinearLinkage/HeuristicLab.Encodings.LinearLinkageEncoding/3.3/Crossovers/GroupCrossover.cs	(revision 12288)
@@ -22,4 +22,5 @@
 using System;
 using System.Collections.Generic;
+using System.Linq;
 using HeuristicLab.Common;
 using HeuristicLab.Core;
@@ -53,28 +54,15 @@
       for (var i = 0; i < length; i++) {
         if (endNodes.Contains(i)) continue;
-        if (endNodes.Contains(p1[i]) && endNodes.Contains(p2[i])) {
+        var p1End = endNodes.Contains(p1[i]);
+        var p2End = endNodes.Contains(p2[i]);
+        if ((p1End && p2End) || (!p1End && !p2End)) {
           child[i] = random.NextDouble() < 0.5 ? p1[i] : p2[i];
-        } else if (endNodes.Contains(p1[i])) {
+        } else if (p1End) {
           child[i] = p1[i];
-        } else if (endNodes.Contains(p2[i])) {
+        } else {
           child[i] = p2[i];
-        } else {
-          var a = p1[i];
-          var b = p2[i];
-          while (true) {
-            if (endNodes.Contains(p2[a])) {
-              child[i] = p2[a];
-              break;
-            }
-            if (endNodes.Contains(p1[b])) {
-              child[i] = p1[b];
-              break;
-            }
-            var tmp = b;
-            b = p2[a];
-            a = p1[tmp];
-          }
         }
       }
+      child.LinearizeTreeStructures();
       return child;
     }
Index: branches/LinearLinkage/HeuristicLab.Encodings.LinearLinkageEncoding/3.3/Crossovers/LowestIndexFirstCrossover.cs
===================================================================
--- branches/LinearLinkage/HeuristicLab.Encodings.LinearLinkageEncoding/3.3/Crossovers/LowestIndexFirstCrossover.cs	(revision 12286)
+++ branches/LinearLinkage/HeuristicLab.Encodings.LinearLinkageEncoding/3.3/Crossovers/LowestIndexFirstCrossover.cs	(revision 12288)
@@ -42,18 +42,21 @@
     public static LinearLinkage Apply(IRandom random, ItemArray<LinearLinkage> parents) {
       var len = parents[0].Length;
+      var p = random.Next(parents.Length);
       var child = new LinearLinkage(len);
-      var childGroup = new List<HashSet<int>>();
-      var currentParent = random.Next(parents.Length);
-      var remaining = new HashSet<int>(Enumerable.Range(0, len));
+      var remaining = new SortedSet<int>(Enumerable.Range(0, len));
       do {
-        var i = remaining.Min();
-        var group = new HashSet<int>(parents[currentParent].GetGroupForward(i));
-        group.IntersectWith(remaining);
-        childGroup.Add(group);
-        remaining.ExceptWith(group);
-        currentParent = (currentParent + 1) % parents.Length;
+        var i = remaining.Min;
+        foreach (var g in parents[p].GetGroupForward(i)) {
+          if (!remaining.Contains(g)) continue;
+          child[i] = g;
+          i = g;
+          remaining.Remove(g);
+        }
+        child[i] = i;
+        remaining.Remove(i);
+
+        p = (p + 1) % parents.Length;
       } while (remaining.Count > 0);
 
-      child.SetGroups(childGroup);
       return child;
     }
Index: branches/LinearLinkage/HeuristicLab.Encodings.LinearLinkageEncoding/3.3/Crossovers/LowestIndexMaxCrossover.cs
===================================================================
--- branches/LinearLinkage/HeuristicLab.Encodings.LinearLinkageEncoding/3.3/Crossovers/LowestIndexMaxCrossover.cs	(revision 12286)
+++ branches/LinearLinkage/HeuristicLab.Encodings.LinearLinkageEncoding/3.3/Crossovers/LowestIndexMaxCrossover.cs	(revision 12288)
@@ -45,18 +45,18 @@
       var len = parents[0].Length;
       var child = new LinearLinkage(len);
-      var childGroup = new List<HashSet<int>>();
-      var remaining = new HashSet<int>(Enumerable.Range(0, len));
+      var remaining = new SortedSet<int>(Enumerable.Range(0, len));
       do {
-        var i = remaining.Min();
-        var groups = parents.Select(x => new HashSet<int>(x.GetGroupForward(i))).ToList();
-        for (var k = 0; k < groups.Count; k++)
-          groups[k].IntersectWith(remaining);
-
-        var maxGroup = groups.Select((v, idx) => Tuple.Create(idx, v)).MaxItems(x => x.Item2.Count).SampleRandom(random).Item1;
-        childGroup.Add(groups[maxGroup]);
-        remaining.ExceptWith(groups[maxGroup]);
+        var groups = parents.Select(x => x.GetGroupForward(remaining.Min).Where(y => remaining.Contains(y)).ToList()).ToList();
+        var max = groups.Select((v, idx) => Tuple.Create(idx, v.Count)).MaxItems(x => x.Item2).SampleRandom(random).Item1;
+        var i = groups[max][0];
+        for (var k = 1; k < groups[max].Count; k++) {
+          child[i] = groups[max][k];
+          remaining.Remove(i);
+          i = child[i];
+        }
+        child[i] = i;
+        remaining.Remove(i);
       } while (remaining.Count > 0);
 
-      child.SetGroups(childGroup);
       return child;
     }
Index: branches/LinearLinkage/HeuristicLab.Encodings.LinearLinkageEncoding/3.3/HeuristicLab.Encodings.LinearLinkageEncoding-3.3.csproj
===================================================================
--- branches/LinearLinkage/HeuristicLab.Encodings.LinearLinkageEncoding/3.3/HeuristicLab.Encodings.LinearLinkageEncoding-3.3.csproj	(revision 12286)
+++ branches/LinearLinkage/HeuristicLab.Encodings.LinearLinkageEncoding/3.3/HeuristicLab.Encodings.LinearLinkageEncoding-3.3.csproj	(revision 12288)
@@ -113,4 +113,5 @@
     <Compile Include="LinearLinkageManipulator.cs" />
     <Compile Include="LinearLinkageCrossover.cs" />
+    <Compile Include="Manipulators\GraftManipulator.cs" />
     <Compile Include="Manipulators\MoveItemManipulator.cs" />
     <Compile Include="Manipulators\MergeGroupManipulator.cs" />
@@ -119,5 +120,4 @@
     <None Include="HeuristicLab.snk" />
     <None Include="Plugin.cs.frame" />
-    <Compile Include="Crossovers\LargestGroupFirstCrossover.cs" />
     <Compile Include="Crossovers\LowestIndexFirstCrossover.cs" />
     <Compile Include="Interfaces\ILinearLinkageCrossover.cs" />
Index: branches/LinearLinkage/HeuristicLab.Encodings.LinearLinkageEncoding/3.3/LinearLinkage.cs
===================================================================
--- branches/LinearLinkage/HeuristicLab.Encodings.LinearLinkageEncoding/3.3/LinearLinkage.cs	(revision 12286)
+++ branches/LinearLinkage/HeuristicLab.Encodings.LinearLinkageEncoding/3.3/LinearLinkage.cs	(revision 12288)
@@ -29,5 +29,5 @@
 
 namespace HeuristicLab.Encodings.LinearLinkageEncoding {
-  [Item("LinearLinkage", "Represents an LLE-e grouping of items.")]
+  [Item("LinearLinkage", "Represents an LLE grouping of items.")]
   [StorableClass]
   public sealed class LinearLinkage : IntArray {
@@ -45,26 +45,14 @@
 
     /// <summary>
-    /// This method parses the encoded array and calculates the membership of each element to the groups.
-    /// It starts at the lowest element.
-    /// </summary>
-    /// <remarks>
-    /// Runtime complexity of this method is O(n) where n is the length of the array.
+    /// This method parses the encoded array and calculates the membership of
+    /// each element to the groups. It starts at the lowest element.
+    /// </summary>
+    /// <remarks>
+    /// Runtime complexity of this method is O(n) where n is the length of the
+    /// array.
     /// </remarks>
     /// <returns>An enumeration of all groups.</returns>
     public IEnumerable<List<int>> GetGroups() {
       var len = array.Length;
-      var dict = new Dictionary<int, List<int>>();
-      for (var i = 0; i < len; i++) {
-        var end = array[i];
-        if (end < i || end >= len || array[end] != end)
-          throw new ArgumentException("Array is malformed and does not represent a valid LLE-e encoding.");
-        List<int> list;
-        if (!dict.TryGetValue(end, out list))
-          dict.Add(end, new List<int>() { i });
-        else list.Add(i);
-      }
-      return dict.Values;
-      /* This code implements group extraction from LLE forward encoding
-       * var len = array.Length;
       var remaining = new HashSet<int>(Enumerable.Range(0, len));
       // iterate from lowest to highest index
@@ -85,22 +73,15 @@
         }
         yield return group;
-      }*/
-    }
-
-    /// <summary>
-    /// This method parses the encoded array and gathers all items that belong to the same group as element <paramref name="index"/>.
+      }
+    }
+
+    /// <summary>
+    /// This method parses the encoded array and gathers all items that
+    /// belong to the same group as element <paramref name="index"/>.
     /// </summary>
     /// <param name="index">The element whose group should be returned.</param>
-    /// <returns>The element at <paramref name="index"/> and all other elements in the same group.</returns>
+    /// <returns>The element at <paramref name="index"/> and all other
+    /// elements in the same group.</returns>
     public IEnumerable<int> GetGroup(int index) {
-      yield return index;
-      var gn = array[index];
-      for (var i = index + 1; i <= gn; i++) {
-        if (array[i] == gn) yield return i;
-      }
-      for (var i = index - 1; i >= 0; i++) {
-        if (array[i] == gn) yield return i;
-      }
-      /* This code implements group extraction from LLE forward encoding
       // return current element
       yield return index;
@@ -120,19 +101,17 @@
         next = prev;
         yield return next;
-      }*/
-    }
-
-    /// <summary>
-    /// This method parses the encoded array and gathers the item itself as well as subsequent items that belong to the same group as element <paramref name="index"/>.
-    /// </summary>
-    /// <param name="index">The element from which items in the group should be returned.</param>
-    /// <returns>The element at <paramref name="index"/> and all subsequent elements in the same group.</returns>
+      }
+    }
+
+    /// <summary>
+    /// This method parses the encoded array and gathers the item itself as
+    /// well as subsequent items that belong to the same group as element
+    /// <paramref name="index"/>.
+    /// </summary>
+    /// <param name="index">The element from which items in the group should
+    /// be returned.</param>
+    /// <returns>The element at <paramref name="index"/> and all subsequent
+    /// elements in the same group.</returns>
     public IEnumerable<int> GetGroupForward(int index) {
-      yield return index;
-      var gn = array[index];
-      for (var i = index + 1; i <= gn; i++) {
-        if (array[i] == gn) yield return i;
-      }
-      /* This code implements group extraction from LLE forward encoding
       yield return index;
       var next = array[index];
@@ -143,29 +122,18 @@
         prev = next;
         next = array[next];
-      } while (next != prev);*/
-    }
-
-    /// <summary>
-    /// This method translates an enumeration of groups into the underlying array representation.
-    /// </summary>
-    /// <remarks>
-    /// Throws an ArgumentException when there is an element assigned to multiple groups or elements that
-    /// are not assigned to any group.
-    /// </remarks>
-    /// <param name="grouping">The grouping of the elements, each element must be part of exactly one group.</param>
+      } while (next != prev);
+    }
+
+    /// <summary>
+    /// This method translates an enumeration of groups into the underlying
+    /// array representation.
+    /// </summary>
+    /// <remarks>
+    /// Throws an ArgumentException when there is an element assigned to
+    /// multiple groups or elements that  are not assigned to any group.
+    /// </remarks>
+    /// <param name="grouping">The grouping of the elements, each element must
+    /// be part of exactly one group.</param>
     public void SetGroups(IEnumerable<IEnumerable<int>> grouping) {
-      var len = array.Length;
-      var remaining = new HashSet<int>(Enumerable.Range(0, len));
-      foreach (var group in grouping) {
-        var max = -1;
-        foreach (var g in group.OrderByDescending(x => x)) {
-          if (max < 0) max = g;
-          array[g] = max;
-          remaining.Remove(g);
-        }
-      }
-      if (remaining.Count > 0)
-        throw new ArgumentException(string.Format("Elements are not assigned a group: {0}", string.Join(", ", remaining)));
-      /* This code implements group setting for LLE forward encoding
       var len = array.Length;
       var remaining = new HashSet<int>(Enumerable.Range(0, len));
@@ -182,23 +150,15 @@
       if (remaining.Count > 0)
         throw new ArgumentException(string.Format("Elements are not assigned a group: {0}", string.Join(", ", remaining)));
-       */
-    }
-
-    /// <summary>
-    /// Performs a check whether the array represents a valid LLE-e encoding.
-    /// </summary>
-    /// <remarks>
-    /// The runtime complexity of this method is O(n) where n is the length of the array.
+    }
+
+    /// <summary>
+    /// Performs a check whether the array represents a valid LLE encoding.
+    /// </summary>
+    /// <remarks>
+    /// The runtime complexity of this method is O(n) where n is the length of
+    /// the array.
     /// </remarks>
     /// <returns>True if the encoding is valid.</returns>
     public bool Validate() {
-      var len = array.Length;
-      for (var i = 0; i < len; i++) {
-        var end = array[i];
-        if (end < i || end >= len || array[end] != end)
-          return false;
-      }
-      return true;
-      /* This code implements group setting for LLE forward encoding
       var len = array.Length;
       var remaining = new HashSet<int>(Enumerable.Range(0, len));
@@ -215,5 +175,42 @@
         } while (next != prev);
       }
-      return remaining.Count == 0;*/
+      return remaining.Count == 0;
+    }
+
+    /// <summary>
+    /// This method flattens tree structures that may be present in groups.
+    /// These tree structures may be created by e.g. merging two groups by
+    /// linking one end node to the end node of another.
+    /// Consider following example: 6, 6, 7, 5, 5, 8, 8, 8, 9.
+    /// This results in the following tree structure for group 8:
+    ///      8
+    ///    /   \
+    ///   6     7
+    ///  / \
+    /// 1   2
+    /// After this operation the array will be 2, 3, 6, 5, 5, 7, 8, 8, 9.
+    /// </summary>
+    /// <remarks>
+    /// The method first converts the array to LLE-e format and then
+    /// linearizes the links. This requires two passes of the whole array
+    /// as well as a dictionary to hold the smallest index of each group.
+    /// 
+    /// The method assumes that there are no back links present.
+    /// </remarks>
+    public void LinearizeTreeStructures() {
+      // Step 1: Convert the array into LLE-e
+      var length = array.Length;
+      var groups = new Dictionary<int, int>();
+      for (var i = length - 1; i >= 0; i--) {
+        if (array[i] == i) groups[i] = i;
+        else array[i] = array[array[i]];
+      }
+      // Step 2: For all groups linearize the links
+      for (var i = length - 1; i >= 0; i--) {
+        if (array[i] == i) continue;
+        var g = array[i];
+        array[i] = groups[g];
+        groups[g] = i;
+      }
     }
   }
Index: branches/LinearLinkage/HeuristicLab.Encodings.LinearLinkageEncoding/3.3/LinearLinkageCreator.cs
===================================================================
--- branches/LinearLinkage/HeuristicLab.Encodings.LinearLinkageEncoding/3.3/LinearLinkageCreator.cs	(revision 12286)
+++ branches/LinearLinkage/HeuristicLab.Encodings.LinearLinkageEncoding/3.3/LinearLinkageCreator.cs	(revision 12288)
@@ -29,5 +29,5 @@
 
 namespace HeuristicLab.Encodings.LinearLinkageEncoding {
-  [Item("Linear Linkage Creator", "Base class for LLE-e creators.")]
+  [Item("Linear Linkage Creator", "Base class for linear linkage creators.")]
   [StorableClass]
   public abstract class LinearLinkageCreator : InstrumentedOperator, ILinearLinkageCreator, IStochasticOperator {
Index: branches/LinearLinkage/HeuristicLab.Encodings.LinearLinkageEncoding/3.3/LinearLinkageEncoding.cs
===================================================================
--- branches/LinearLinkage/HeuristicLab.Encodings.LinearLinkageEncoding/3.3/LinearLinkageEncoding.cs	(revision 12286)
+++ branches/LinearLinkage/HeuristicLab.Encodings.LinearLinkageEncoding/3.3/LinearLinkageEncoding.cs	(revision 12288)
@@ -33,5 +33,5 @@
 
 namespace HeuristicLab.Encodings.LinearLinkageEncoding {
-  [Item("Linear Linkage Encoding", "Describes a linear linkage (LLE-e) encoding.")]
+  [Item("Linear Linkage Encoding", "Describes a linear linkage (LLE) encoding.")]
   [StorableClass]
   public sealed class LinearLinkageEncoding : Encoding<ILinearLinkageCreator> {
Index: branches/LinearLinkage/HeuristicLab.Encodings.LinearLinkageEncoding/3.3/LinearLinkageManipulator.cs
===================================================================
--- branches/LinearLinkage/HeuristicLab.Encodings.LinearLinkageEncoding/3.3/LinearLinkageManipulator.cs	(revision 12286)
+++ branches/LinearLinkage/HeuristicLab.Encodings.LinearLinkageEncoding/3.3/LinearLinkageManipulator.cs	(revision 12288)
@@ -28,5 +28,5 @@
 
 namespace HeuristicLab.Encodings.LinearLinkageEncoding {
-  [Item("Linear Linkage Manipulator", "Base class for manipulators of the linear linkage encoding.")]
+  [Item("Linear Linkage Manipulator", "Base class for linear linkage manipulators.")]
   [StorableClass]
   public abstract class LinearLinkageManipulator : InstrumentedOperator, ILinearLinkageManipulator, IStochasticOperator {
Index: branches/LinearLinkage/HeuristicLab.Encodings.LinearLinkageEncoding/3.3/Manipulators/GraftManipulator.cs
===================================================================
--- branches/LinearLinkage/HeuristicLab.Encodings.LinearLinkageEncoding/3.3/Manipulators/GraftManipulator.cs	(revision 12288)
+++ branches/LinearLinkage/HeuristicLab.Encodings.LinearLinkageEncoding/3.3/Manipulators/GraftManipulator.cs	(revision 12288)
@@ -0,0 +1,90 @@
+﻿#region License Information
+/* HeuristicLab
+ * Copyright (C) 2002-2015 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.Parameters;
+using HeuristicLab.Persistence.Default.CompositeSerializers.Storable;
+
+namespace HeuristicLab.Encodings.LinearLinkageEncoding {
+  [Item("Graft Manipulator", "Performs graft mutation as described in Du, J., Korkmaz, E.E., Alhajj, R., and Barker, K. 2004. Novel Clustering Approach that employs Genetic Algorithm with New Representation Scheme and Multiple Objectives. Data Warehousing and Knowledge Discovery, pp. 219-228. Springer Berlin Heidelberg.")]
+  [StorableClass]
+  public sealed class GraftManipulator : LinearLinkageManipulator {
+
+    public IValueLookupParameter<IntValue> MaxGroupsParameter {
+      get { return (IValueLookupParameter<IntValue>)Parameters["MaxGroups"]; }
+    }
+
+    [StorableConstructor]
+    private GraftManipulator(bool deserializing) : base(deserializing) { }
+    private GraftManipulator(GraftManipulator original, Cloner cloner) : base(original, cloner) { }
+    public GraftManipulator() {
+      Parameters.Add(new ValueLookupParameter<IntValue>("MaxGroups", "The maximum number of groups. If a value less or equal than 0 is used the number of groups is not limited.", new IntValue(-1)));
+    }
+    public GraftManipulator(int maxGroups)
+      : this() {
+      MaxGroupsParameter.Value = new IntValue(maxGroups);
+    }
+
+    public override IDeepCloneable Clone(Cloner cloner) {
+      return new GraftManipulator(this, cloner);
+    }
+
+    public static void Apply(IRandom random, LinearLinkage lle, int maxGroups) {
+      int tries = lle.Length;
+      var index = random.Next(lle.Length);
+      while (tries > 0 && lle[index] == index) {
+        index = random.Next(lle.Length);
+        tries--;
+      }
+      if (lle[index] != index) Apply(random, lle, maxGroups, index);
+    }
+
+    public static void Apply(IRandom random, LinearLinkage lle, int maxGroups, int index) {
+      var groups = lle.Select((val, idx) => Tuple.Create(idx, val))
+                      .Where(x => x.Item1 == x.Item2)
+                      .Select(x => x.Item2).ToList();
+      var z = groups.Count;
+
+      if (random.NextDouble() < 0.5)
+        lle[index] = index; // divide the cluster into two
+      else {
+        var c = random.Next(z);
+        if (groups[c] > index)
+          lle[index] = groups[c]; // combine the portion with another class
+        else {
+          // combine the other class here
+          lle[groups[c]] = lle[index];
+          lle[index] = index;
+        }
+        lle.LinearizeTreeStructures();
+      }
+    }
+
+    protected override void Manipulate(IRandom random, LinearLinkage lle) {
+      var maxGroups = MaxGroupsParameter.ActualValue.Value;
+      Apply(random, lle, maxGroups <= 0 ? int.MaxValue : maxGroups);
+    }
+  }
+}
Index: branches/LinearLinkage/HeuristicLab.Encodings.LinearLinkageEncoding/3.3/Manipulators/MultiLLEManipulator.cs
===================================================================
--- branches/LinearLinkage/HeuristicLab.Encodings.LinearLinkageEncoding/3.3/Manipulators/MultiLLEManipulator.cs	(revision 12286)
+++ branches/LinearLinkage/HeuristicLab.Encodings.LinearLinkageEncoding/3.3/Manipulators/MultiLLEManipulator.cs	(revision 12288)
@@ -58,4 +58,5 @@
       }
       Operators.SetItemCheckedState(Operators.OfType<SwapItemManipulator>().First(), false);
+      Operators.SetItemCheckedState(Operators.OfType<GraftManipulator>().First(), false);
       SelectedOperatorParameter.ActualName = "SelectedManipulatorOperator";
     }
Index: branches/LinearLinkage/HeuristicLab.Encodings.LinearLinkageEncoding/3.3/Plugin.cs.frame
===================================================================
--- branches/LinearLinkage/HeuristicLab.Encodings.LinearLinkageEncoding/3.3/Plugin.cs.frame	(revision 12286)
+++ branches/LinearLinkage/HeuristicLab.Encodings.LinearLinkageEncoding/3.3/Plugin.cs.frame	(revision 12288)
@@ -23,5 +23,5 @@
 
 namespace HeuristicLab.Encodings.LinearLinkageEncoding {
-  [Plugin("HeuristicLab.Encodings.LinearLinkageEncoding", "Provides data structures and operators for the linear linkage encoding (LLE-e).", "3.3.11.$WCREV$")]
+  [Plugin("HeuristicLab.Encodings.LinearLinkageEncoding", "Provides data structures and operators for the linear linkage encoding (LLE).", "3.3.11.$WCREV$")]
   [PluginFile("HeuristicLab.Encodings.LinearLinkageEncoding-3.3.dll", PluginFileType.Assembly)]
   [PluginDependency("HeuristicLab.Collections", "3.3")]
Index: branches/LinearLinkage/HeuristicLab.Encodings.LinearLinkageEncoding/3.3/ShakingOperators/LLEShakingOperator.cs
===================================================================
--- branches/LinearLinkage/HeuristicLab.Encodings.LinearLinkageEncoding/3.3/ShakingOperators/LLEShakingOperator.cs	(revision 12286)
+++ branches/LinearLinkage/HeuristicLab.Encodings.LinearLinkageEncoding/3.3/ShakingOperators/LLEShakingOperator.cs	(revision 12288)
@@ -34,5 +34,5 @@
   /// A shaking operator for VNS.
   /// </summary>
-  [Item("LLE Shaking Operator", "A shaking operator for VNS which LLE manipulators to perform the shaking.")]
+  [Item("LLE Shaking Operator", "A shaking operator for VNS which uses LLE manipulators to perform the shaking.")]
   [StorableClass]
   public class LLEShakingOperator : ShakingOperator<ILinearLinkageManipulator>, IStochasticOperator, ILinearLinkageShakingOperator {
