Index: branches/HeuristicLab.BinPacking/HeuristicLab.Problems.BinPacking/3.3/Encodings/PackingPlans/BinPacking.cs
===================================================================
--- branches/HeuristicLab.BinPacking/HeuristicLab.Problems.BinPacking/3.3/Encodings/PackingPlans/BinPacking.cs	(revision 14064)
+++ branches/HeuristicLab.BinPacking/HeuristicLab.Problems.BinPacking/3.3/Encodings/PackingPlans/BinPacking.cs	(revision 14128)
@@ -40,8 +40,8 @@
 
     [Storable]
-    public ObservableDictionary<int, I> ItemMeasures { get; private set; } // TODO: renamed to item
+    public ObservableDictionary<int, I> ItemMeasures { get; private set; } // TODO: rename to items
 
     [Storable]
-    public B BinMeasures { get; private set; }
+    public B BinMeasures { get; private set; } 
 
     [Storable]
Index: branches/HeuristicLab.BinPacking/HeuristicLab.Problems.BinPacking/3.3/Encodings/PackingPlans/PackingPlan.cs
===================================================================
--- branches/HeuristicLab.BinPacking/HeuristicLab.Problems.BinPacking/3.3/Encodings/PackingPlans/PackingPlan.cs	(revision 14064)
+++ branches/HeuristicLab.BinPacking/HeuristicLab.Problems.BinPacking/3.3/Encodings/PackingPlans/PackingPlan.cs	(revision 14128)
@@ -28,9 +28,7 @@
 using HeuristicLab.Data;
 using HeuristicLab.Collections;
-using HeuristicLab.Encodings.PackingEncoding.MultiComponentVector;
-using HeuristicLab.Encodings.PackingEncoding.GroupingVector;
-using HeuristicLab.Encodings.PackingEncoding.PackingSequence;
 using HeuristicLab.Encodings.IntegerVectorEncoding;
 using HeuristicLab.Problems.BinPacking;
+using HeuristicLab.Encodings.PermutationEncoding;
 
 namespace HeuristicLab.Encodings.PackingEncoding {
@@ -98,4 +96,5 @@
     }
 
+    /*
     public void Pack(MultiComponentVectorEncoding solution, ItemList<I> itemMeasures) {
       var sequenceMatrix = solution.GenerateSequenceMatrix();
@@ -197,6 +196,8 @@
       solution.GroupingVector = new IntegerVector(newSolution);
     }
-    public void Pack(PackingSequenceEncoding solution, ItemList<I> itemMeasures) {
-      List<int> remainingIDs = new List<int>(solution.PackingSequence);
+     * 
+     
+    public void Pack(Permutation solution, ItemList<I> itemMeasures) {
+      List<int> remainingIDs = new List<int>(solution);
       while (remainingIDs.Count > 0) {
         var bp = NewBinPacking();
@@ -210,5 +211,5 @@
     }
 
-
+    */
     #region Events
     public event EventHandler QualityChanged;
Index: branches/HeuristicLab.BinPacking/HeuristicLab.Problems.BinPacking/3.3/Encodings/PackingSequence/Encoding.cs
===================================================================
--- branches/HeuristicLab.BinPacking/HeuristicLab.Problems.BinPacking/3.3/Encodings/PackingSequence/Encoding.cs	(revision 14064)
+++ branches/HeuristicLab.BinPacking/HeuristicLab.Problems.BinPacking/3.3/Encodings/PackingSequence/Encoding.cs	(revision 14128)
@@ -6,4 +6,5 @@
 using HeuristicLab.Common;
 using HeuristicLab.Core;
+using HeuristicLab.Encodings.PermutationEncoding;
 using HeuristicLab.Optimization;
 using HeuristicLab.Persistence.Default.CompositeSerializers.Storable;
@@ -13,8 +14,9 @@
 namespace HeuristicLab.Encodings.PackingEncoding.PackingSequence {
   [StorableClass]
-  internal class Encoding : HeuristicLab.Optimization.Encoding<PackingSolutionCreator> {
+  public class Encoding : HeuristicLab.Optimization.Encoding<IPackingSolutionCreator> {
     [StorableConstructor]
     private Encoding(bool deserializing) : base(deserializing) { }
-    public Encoding() : base("PackingSequence") {
+    public Encoding()
+      : base("PackingSequence") {
       SolutionCreator = new PackingSequenceRandomCreator();
       RegisterParameterEvents();
@@ -64,11 +66,11 @@
 
   public static class IndividualExtensionMethods {
-    public static PackingSequence PackingSequence(this Individual individual) {
+    public static Permutation PackingSequence(this Individual individual) {
       var encoding = individual.GetEncoding<Encoding>();
       return individual.PackingSequence(encoding.Name);
     }
 
-    public static PackingSequence PackingSequence(this Individual individual, string name) {
-      return (PackingSequence)individual[name];
+    public static Permutation PackingSequence(this Individual individual, string name) {
+      return (Permutation)individual[name];
     }
   }
Index: branches/HeuristicLab.BinPacking/HeuristicLab.Problems.BinPacking/3.3/Encodings/PackingSequence/IPackingSequenceCreator.cs
===================================================================
--- branches/HeuristicLab.BinPacking/HeuristicLab.Problems.BinPacking/3.3/Encodings/PackingSequence/IPackingSequenceCreator.cs	(revision 14064)
+++ branches/HeuristicLab.BinPacking/HeuristicLab.Problems.BinPacking/3.3/Encodings/PackingSequence/IPackingSequenceCreator.cs	(revision 14128)
@@ -23,4 +23,5 @@
 using HeuristicLab.Core;
 using HeuristicLab.Data;
+using HeuristicLab.Encodings.PermutationEncoding;
 using HeuristicLab.Optimization;
 using HeuristicLab.Problems.BinPacking;
@@ -28,7 +29,6 @@
 namespace HeuristicLab.Encodings.PackingEncoding.PackingSequence {
   interface IPackingSequenceCreator : ISolutionCreator, IPackingSequenceOperator {
-    IValueLookupParameter<IntValue> PackingItemsParameter { get; }
-    ILookupParameter<PackingSequence> SolutionParameter { get; }
-
+    ILookupParameter<IntValue> NumberOfPackingItemsParameter { get; }
+    ILookupParameter<Permutation> SolutionParameter { get; }
   }
 }
Index: branches/HeuristicLab.BinPacking/HeuristicLab.Problems.BinPacking/3.3/Encodings/PackingSequence/Moves/GroupingMoveHardTabuCriterion.cs
===================================================================
--- branches/HeuristicLab.BinPacking/HeuristicLab.Problems.BinPacking/3.3/Encodings/PackingSequence/Moves/GroupingMoveHardTabuCriterion.cs	(revision 14064)
+++ branches/HeuristicLab.BinPacking/HeuristicLab.Problems.BinPacking/3.3/Encodings/PackingSequence/Moves/GroupingMoveHardTabuCriterion.cs	(revision 14128)
@@ -24,4 +24,5 @@
 using HeuristicLab.Core;
 using HeuristicLab.Data;
+using HeuristicLab.Encodings.PermutationEncoding;
 using HeuristicLab.Operators;
 using HeuristicLab.Optimization;
@@ -37,9 +38,9 @@
       get { return false; }
     }
-    public ILookupParameter<IPackingMove> PackingMoveParameter {
-      get { return (ILookupParameter<IPackingMove>)Parameters["PackingMove"]; }
+    public ILookupParameter<IPackingMove<Permutation>> PackingMoveParameter {
+      get { return (ILookupParameter<IPackingMove<Permutation>>)Parameters["PackingMove"]; }
     }
-    public ILookupParameter<PackingSequenceEncoding> PackingSequenceParameter {
-      get { return (ILookupParameter<PackingSequenceEncoding>)Parameters["PackingSequence"]; }
+    public ILookupParameter<Permutation> PackingSequenceParameter {
+      get { return (ILookupParameter<Permutation>)Parameters["PackingSequence"]; }
     }
     public ILookupParameter<ItemList<IItem>> TabuListParameter {
@@ -64,6 +65,6 @@
     public SequenceMoveHardTabuCriterion()
       : base() {
-      Parameters.Add(new LookupParameter<IPackingMove>("PackingMove", "The move to evaluate."));
-      Parameters.Add(new LookupParameter<PackingSequenceEncoding>("PackingSequence", "The solution to evaluate."));
+      Parameters.Add(new LookupParameter<IPackingMove<Permutation>>("PackingMove", "The move to evaluate."));
+      Parameters.Add(new LookupParameter<Permutation>("PackingSequence", "The solution candidate to evaluate."));
       Parameters.Add(new LookupParameter<BoolValue>("MoveTabu", "The variable to store if a move was tabu."));
       Parameters.Add(new LookupParameter<ItemList<IItem>>("TabuList", "The tabu list."));
@@ -80,10 +81,8 @@
       ItemList<IItem> tabuList = TabuListParameter.ActualValue;
       SequenceMove move = PackingMoveParameter.ActualValue as SequenceMove;
-      PackingSequenceEncoding PackingSequence = PackingSequenceParameter.ActualValue;
-      int length = PackingSequence.PackingSequence.Length;
       double moveQuality = MoveQualityParameter.ActualValue.Value;
       bool maximization = MaximizationParameter.ActualValue.Value;
       bool useAspiration = UseAspirationCriterionParameter.Value.Value;
-      bool isTabu = IsMoveTabu(tabuList, move, PackingSequence, moveQuality, maximization, useAspiration);
+      bool isTabu = IsMoveTabu(tabuList, move, moveQuality, maximization, useAspiration);
 
       MoveTabuParameter.ActualValue = new BoolValue(isTabu);
@@ -91,7 +90,7 @@
     }
 
-    private bool IsMoveTabu(ItemList<IItem> tabuList, SequenceMove move, PackingSequenceEncoding PackingSequence, double moveQuality, bool maximization, bool useAspiration) {
+    private bool IsMoveTabu(ItemList<IItem> tabuList, SequenceMove move, double moveQuality, bool maximization, bool useAspiration) {
       bool isTabu = false;
-      var attributes = tabuList.FindAll(ta => ta.GetType().Equals(move.GetMoveAttributeType()));
+      var attributes = tabuList.FindAll(ta => ta.GetType() == move.GetMoveAttributeType());
 
       foreach (IItem attr in attributes) {
@@ -102,5 +101,5 @@
               || !maximization && moveQuality >= gvAttr.MoveQuality)) {
 
-          isTabu = move.BelongsToAttribute(gvAttr, true);
+          isTabu = move.BelongsToAttribute(gvAttr, true); // only difference to soft tabu criterion
         }
         if (isTabu) break;
Index: branches/HeuristicLab.BinPacking/HeuristicLab.Problems.BinPacking/3.3/Encodings/PackingSequence/Moves/GroupingMoveMaker.cs
===================================================================
--- branches/HeuristicLab.BinPacking/HeuristicLab.Problems.BinPacking/3.3/Encodings/PackingSequence/Moves/GroupingMoveMaker.cs	(revision 14064)
+++ branches/HeuristicLab.BinPacking/HeuristicLab.Problems.BinPacking/3.3/Encodings/PackingSequence/Moves/GroupingMoveMaker.cs	(revision 14128)
@@ -24,4 +24,5 @@
 using HeuristicLab.Core;
 using HeuristicLab.Data;
+using HeuristicLab.Encodings.PermutationEncoding;
 using HeuristicLab.Operators;
 using HeuristicLab.Optimization;
@@ -43,9 +44,9 @@
       get { return (ILookupParameter<DoubleValue>)Parameters["MoveQuality"]; }
     }
-    public ILookupParameter<IPackingMove> PackingMoveParameter {
-      get { return (ILookupParameter<IPackingMove>)Parameters["PackingMove"]; }
+    public ILookupParameter<IPackingMove<Permutation>> PackingMoveParameter {
+      get { return (ILookupParameter<IPackingMove<Permutation>>)Parameters["PackingMove"]; }
     }
-    public ILookupParameter<PackingSequenceEncoding> PackingSequenceParameter {
-      get { return (ILookupParameter<PackingSequenceEncoding>)Parameters["PackingSequence"]; }
+    public ILookupParameter<Permutation> PackingSequenceParameter {
+      get { return (ILookupParameter<Permutation>)Parameters["PackingSequence"]; }
     }
     public ILookupParameter<IPackingPlan> PackingPlanParameter {
@@ -62,7 +63,7 @@
       : base() {
       Parameters.Add(new LookupParameter<DoubleValue>("Quality", "The quality of the solution."));
-      Parameters.Add(new LookupParameter<IPackingMove>("PackingMove", "The move to evaluate."));
+      Parameters.Add(new LookupParameter<IPackingMove<Permutation>>("PackingMove", "The move to evaluate."));
       Parameters.Add(new LookupParameter<DoubleValue>("MoveQuality", "The relative quality of the move."));
-      Parameters.Add(new LookupParameter<PackingSequenceEncoding>("PackingSequence", "The solution as Sequence vector."));
+      Parameters.Add(new LookupParameter<Permutation>("PackingSequence", "The solution as Sequence vector."));
       Parameters.Add(new LookupParameter<IPackingPlan>("PackingPlan", "The currently best performing, decoded bin-packing solution represented as generalized packing-plan."));
       Parameters.Add(new LookupParameter<IPackingPlan>("PackingPlanAfterMove", "The moved and decoded bin-packing solution represented as generalized packing-plan."));
@@ -74,10 +75,7 @@
 
     public override IOperation Apply() {
-      IPackingMove move = PackingMoveParameter.ActualValue;
-      PackingSequenceEncoding PackingSequence = PackingSequenceParameter.ActualValue;
       DoubleValue moveQuality = MoveQualityParameter.ActualValue;
       DoubleValue quality = QualityParameter.ActualValue;
 
-      PackingSequence.PackingSequence = (move.GetSolutionAfterMove() as PackingSequenceEncoding).PackingSequence;
       PackingPlanParameter.ActualValue = PackingPlanAfterMoveParameter.ActualValue;
 
Index: branches/HeuristicLab.BinPacking/HeuristicLab.Problems.BinPacking/3.3/Encodings/PackingSequence/Moves/GroupingMoveSoftTabuCriterion.cs
===================================================================
--- branches/HeuristicLab.BinPacking/HeuristicLab.Problems.BinPacking/3.3/Encodings/PackingSequence/Moves/GroupingMoveSoftTabuCriterion.cs	(revision 14064)
+++ branches/HeuristicLab.BinPacking/HeuristicLab.Problems.BinPacking/3.3/Encodings/PackingSequence/Moves/GroupingMoveSoftTabuCriterion.cs	(revision 14128)
@@ -24,4 +24,5 @@
 using HeuristicLab.Core;
 using HeuristicLab.Data;
+using HeuristicLab.Encodings.PermutationEncoding;
 using HeuristicLab.Operators;
 using HeuristicLab.Optimization;
@@ -38,9 +39,9 @@
       get { return false; }
     }
-    public ILookupParameter<IPackingMove> PackingMoveParameter {
-      get { return (ILookupParameter<IPackingMove>)Parameters["PackingMove"]; }
+    public ILookupParameter<IPackingMove<Permutation>> PackingMoveParameter {
+      get { return (ILookupParameter<IPackingMove<Permutation>>)Parameters["PackingMove"]; }
     }
-    public ILookupParameter<PackingSequenceEncoding> PackingSequenceParameter {
-      get { return (ILookupParameter<PackingSequenceEncoding>)Parameters["PackingSequence"]; }
+    public ILookupParameter<Permutation> PackingSequenceParameter {
+      get { return (ILookupParameter<Permutation>)Parameters["PackingSequence"]; }
     }
     public ILookupParameter<ItemList<IItem>> TabuListParameter {
@@ -65,6 +66,6 @@
     public SequenceMoveSoftTabuCriterion()
       : base() {
-      Parameters.Add(new LookupParameter<IPackingMove>("PackingMove", "The move to evaluate."));
-      Parameters.Add(new LookupParameter<PackingSequenceEncoding>("PackingSequence", "The solution to evaluate."));
+      Parameters.Add(new LookupParameter<IPackingMove<Permutation>>("PackingMove", "The move to evaluate."));
+      Parameters.Add(new LookupParameter<Permutation>("PackingSequence", "The solution to evaluate."));
       Parameters.Add(new LookupParameter<BoolValue>("MoveTabu", "The variable to store if a move was tabu."));
       Parameters.Add(new LookupParameter<ItemList<IItem>>("TabuList", "The tabu list."));
@@ -81,10 +82,8 @@
       ItemList<IItem> tabuList = TabuListParameter.ActualValue;
       SequenceMove move = PackingMoveParameter.ActualValue as SequenceMove;
-      PackingSequenceEncoding PackingSequence = PackingSequenceParameter.ActualValue;
-      int length = PackingSequence.PackingSequence.Length;
       double moveQuality = MoveQualityParameter.ActualValue.Value;
-      bool maximization = MaximizationParameter.ActualValue.Value;   
+      bool maximization = MaximizationParameter.ActualValue.Value;
       bool useAspiration = UseAspirationCriterionParameter.Value.Value;
-      bool isTabu = IsMoveTabu(tabuList, move, PackingSequence, moveQuality, maximization, useAspiration);
+      bool isTabu = IsMoveTabu(tabuList, move, moveQuality, maximization, useAspiration);
 
       MoveTabuParameter.ActualValue = new BoolValue(isTabu);
@@ -92,7 +91,7 @@
     }
 
-    private bool IsMoveTabu(ItemList<IItem> tabuList, SequenceMove move, PackingSequenceEncoding PackingSequence, double moveQuality, bool maximization, bool useAspiration) {
+    private bool IsMoveTabu(ItemList<IItem> tabuList, SequenceMove move, double moveQuality, bool maximization, bool useAspiration) {
       bool isTabu = false;
-      var attributes = tabuList.FindAll(ta => ta.GetType().Equals(move.GetMoveAttributeType()));
+      var attributes = tabuList.FindAll(ta => ta.GetType() == move.GetMoveAttributeType());
 
       foreach (IItem attr in attributes) {
@@ -103,5 +102,5 @@
               || !maximization && moveQuality >= gvAttr.MoveQuality)) {
 
-          isTabu = move.BelongsToAttribute(gvAttr, false);
+          isTabu = move.BelongsToAttribute(gvAttr, false); // only difference to hard tabu criterion 
         }
         if (isTabu) break;
Index: branches/HeuristicLab.BinPacking/HeuristicLab.Problems.BinPacking/3.3/Encodings/PackingSequence/Moves/Insertion/ExhaustiveInsertionMoveGenerator.cs
===================================================================
--- branches/HeuristicLab.BinPacking/HeuristicLab.Problems.BinPacking/3.3/Encodings/PackingSequence/Moves/Insertion/ExhaustiveInsertionMoveGenerator.cs	(revision 14064)
+++ branches/HeuristicLab.BinPacking/HeuristicLab.Problems.BinPacking/3.3/Encodings/PackingSequence/Moves/Insertion/ExhaustiveInsertionMoveGenerator.cs	(revision 14128)
@@ -24,4 +24,5 @@
 using HeuristicLab.Common;
 using HeuristicLab.Core;
+using HeuristicLab.Encodings.PermutationEncoding;
 using HeuristicLab.Optimization;
 using HeuristicLab.Persistence.Default.CompositeSerializers.Storable;
@@ -39,15 +40,15 @@
       return new ExhaustiveInsertionMoveGenerator(this, cloner);
     }
-    public static IEnumerable<InsertionMove> Generate(PackingSequenceEncoding PackingSequence, int nrOfBins) {
-      for (int i = 0; i < PackingSequence.PackingSequence.Length - 1; i++)
-        for (int j = i + 1; j < PackingSequence.PackingSequence.Length; j++) {
+    public static IEnumerable<InsertionMove> Generate(Permutation packingSequence, int nrOfBins) {
+      for (int i = 0; i < packingSequence.Length - 1; i++)
+        for (int j = i + 1; j < packingSequence.Length; j++) {
           if (j != i)
-            yield return new InsertionMove(i, j, PackingSequence);
+            yield return new InsertionMove(i, j, packingSequence);
         }
     }
 
-    public static InsertionMove[] Apply(PackingSequenceEncoding PackingSequence) {
+    public static InsertionMove[] Apply(Permutation packingSequence) {
       int nrOfBins = 0;
-      foreach (int binNr in PackingSequence.PackingSequence) {
+      foreach (int binNr in packingSequence) {
         if (binNr > nrOfBins)
           nrOfBins = binNr;
@@ -55,8 +56,8 @@
       nrOfBins++;
 
-      int totalMoves = (PackingSequence.PackingSequence.Length * (PackingSequence.PackingSequence.Length - 1)) / 2;
+      int totalMoves = (packingSequence.Length * (packingSequence.Length - 1)) / 2;
       InsertionMove[] moves = new InsertionMove[totalMoves];
       int count = 0;
-      foreach (InsertionMove move in Generate(PackingSequence, nrOfBins)) {
+      foreach (InsertionMove move in Generate(packingSequence, nrOfBins)) {
         moves[count++] = move;
       }
@@ -64,6 +65,6 @@
     }
 
-    protected override InsertionMove[] GenerateMoves(PackingSequenceEncoding PackingSequence) {
-      return Apply(PackingSequence);
+    protected override InsertionMove[] GenerateMoves(Permutation packingSequence) {
+      return Apply(packingSequence);
     }
   }
Index: branches/HeuristicLab.BinPacking/HeuristicLab.Problems.BinPacking/3.3/Encodings/PackingSequence/Moves/Insertion/InsertionMove.cs
===================================================================
--- branches/HeuristicLab.BinPacking/HeuristicLab.Problems.BinPacking/3.3/Encodings/PackingSequence/Moves/Insertion/InsertionMove.cs	(revision 14064)
+++ branches/HeuristicLab.BinPacking/HeuristicLab.Problems.BinPacking/3.3/Encodings/PackingSequence/Moves/Insertion/InsertionMove.cs	(revision 14128)
@@ -32,5 +32,5 @@
   [Item("Insertion Move", "A move on a Sequence vector that is specified by two group-assignment-indexes.")]
   [StorableClass]
-  public class InsertionMove : SequenceMove, IPackingMove {
+  public class InsertionMove : SequenceMove {
     [Storable]
     public int Index1 { get; protected set; }
@@ -45,6 +45,6 @@
       this.Index2 = original.Index2;
     }
-    public InsertionMove(int index1, int index2, PackingSequenceEncoding PackingSequence)
-      : base(PackingSequence) {
+    public InsertionMove(int index1, int index2, Permutation packingSequence)
+      : base(packingSequence) {
       Index1 = index1;
       Index2 = index2;
@@ -55,9 +55,7 @@
     }
 
-    public override IPackingSolutionEncoding GetSolutionAfterMove() {
-      PackingSequenceEncoding newSolution = new PackingSequenceEncoding();
-
-      Permutation original = PackingSequence.PackingSequence;
-      Permutation resultingPermutation = (Permutation)PackingSequence.PackingSequence.Clone();
+    public override Permutation GetSolutionAfterMove() {
+      Permutation original = PackingSequence;
+      Permutation resultingPermutation = (Permutation)PackingSequence.Clone();
       int cutIndex, insertIndex, number;
 
@@ -68,5 +66,5 @@
       int i = 0;  // index in new permutation
       int j = 0;  // index in old permutation
-      while (i < PackingSequence.PackingSequence.Length) {
+      while (i < PackingSequence.Length) {
         if (j == cutIndex) {
           j++;
@@ -83,6 +81,5 @@
       }
 
-      newSolution.PackingSequence = resultingPermutation;
-      return newSolution;
+      return resultingPermutation;
     }
 
@@ -92,5 +89,5 @@
 
     public override SequenceMoveAttribute GetAttribute(double quality) {
-      return new InsertionMoveAttribute(Index1, Index2, PackingSequence.PackingSequence[Index1], PackingSequence.PackingSequence[Index2], quality);
+      return new InsertionMoveAttribute(Index1, Index2, PackingSequence[Index1], PackingSequence[Index2], quality);
     }
 
@@ -103,5 +100,5 @@
         } else
           if (Index1 == attr.Index1 && Index2 == attr.Index2)
-          return true;
+            return true;
       }
       return false;
Index: branches/HeuristicLab.BinPacking/HeuristicLab.Problems.BinPacking/3.3/Encodings/PackingSequence/Moves/Insertion/InsertionMoveGenerator.cs
===================================================================
--- branches/HeuristicLab.BinPacking/HeuristicLab.Problems.BinPacking/3.3/Encodings/PackingSequence/Moves/Insertion/InsertionMoveGenerator.cs	(revision 14064)
+++ branches/HeuristicLab.BinPacking/HeuristicLab.Problems.BinPacking/3.3/Encodings/PackingSequence/Moves/Insertion/InsertionMoveGenerator.cs	(revision 14128)
@@ -23,4 +23,5 @@
 using HeuristicLab.Common;
 using HeuristicLab.Core;
+using HeuristicLab.Encodings.PermutationEncoding;
 using HeuristicLab.Operators;
 using HeuristicLab.Optimization;
@@ -37,9 +38,9 @@
       get { return false; }
     }
-    public ILookupParameter<PackingSequenceEncoding> PackingSequenceParameter {
-      get { return (ILookupParameter<PackingSequenceEncoding>)Parameters["PackingSequence"]; }
+    public ILookupParameter<Permutation> PackingSequenceParameter {
+      get { return (ILookupParameter<Permutation>)Parameters["PackingSequence"]; }
     }
-    public ILookupParameter<IPackingMove> PackingMoveParameter {
-      get { return (LookupParameter<IPackingMove>)Parameters["PackingMove"]; }
+    public ILookupParameter<IPackingMove<Permutation>> PackingMoveParameter {
+      get { return (LookupParameter<IPackingMove<Permutation>>)Parameters["PackingMove"]; }
     }
     protected ScopeParameter CurrentScopeParameter {
@@ -52,11 +53,11 @@
     public InsertionMoveGenerator()
       : base() {
-      Parameters.Add(new LookupParameter<PackingSequenceEncoding>("PackingSequence", "The Sequence vector for which moves should be generated."));
-      Parameters.Add(new LookupParameter<IPackingMove>("PackingMove", "The moves that should be generated in subscopes."));
+      Parameters.Add(new LookupParameter<Permutation>("PackingSequence", "The Sequence vector for which moves should be generated."));
+      Parameters.Add(new LookupParameter<IPackingMove<Permutation>>("PackingMove", "The moves that should be generated in subscopes."));
       Parameters.Add(new ScopeParameter("CurrentScope", "The current scope where the moves should be added as subscopes."));
     }
 
     public override IOperation Apply() {
-      PackingSequenceEncoding ps = PackingSequenceParameter.ActualValue;
+      Permutation ps = PackingSequenceParameter.ActualValue;
       InsertionMove[] moves = GenerateMoves(ps);
       Scope[] moveScopes = new Scope[moves.Length];
@@ -69,5 +70,5 @@
     }
 
-    protected abstract InsertionMove[] GenerateMoves(PackingSequenceEncoding PackingSequence);
+    protected abstract InsertionMove[] GenerateMoves(Permutation packingSequence);
   }
 }
Index: branches/HeuristicLab.BinPacking/HeuristicLab.Problems.BinPacking/3.3/Encodings/PackingSequence/Moves/Insertion/StochasticInsertionMoveGenerator.cs
===================================================================
--- branches/HeuristicLab.BinPacking/HeuristicLab.Problems.BinPacking/3.3/Encodings/PackingSequence/Moves/Insertion/StochasticInsertionMoveGenerator.cs	(revision 14064)
+++ branches/HeuristicLab.BinPacking/HeuristicLab.Problems.BinPacking/3.3/Encodings/PackingSequence/Moves/Insertion/StochasticInsertionMoveGenerator.cs	(revision 14128)
@@ -25,4 +25,5 @@
 using HeuristicLab.Core;
 using HeuristicLab.Data;
+using HeuristicLab.Encodings.PermutationEncoding;
 using HeuristicLab.Optimization;
 using HeuristicLab.Parameters;
@@ -58,8 +59,8 @@
     }
 
-    public static InsertionMove[] Apply(PackingSequenceEncoding PackingSequence, IRandom random, int sampleSize) {
+    public static InsertionMove[] Apply(Permutation packingSequence, IRandom random, int sampleSize) {
 
       int nrOfBins = 0;
-      foreach (int binNr in PackingSequence.PackingSequence) {
+      foreach (int binNr in packingSequence) {
         if (binNr > nrOfBins)
           nrOfBins = binNr;
@@ -67,5 +68,5 @@
       nrOfBins++;
       var generatedMoves = new List<InsertionMove>();
-      var moves = new List<InsertionMove>(ExhaustiveInsertionMoveGenerator.Generate(PackingSequence, nrOfBins));
+      var moves = new List<InsertionMove>(ExhaustiveInsertionMoveGenerator.Generate(packingSequence, nrOfBins));
       int moveCount = moves.Count;
       for (int i = 0; i < sampleSize; i++) {
@@ -76,7 +77,7 @@
     }
 
-    protected override InsertionMove[] GenerateMoves(PackingSequenceEncoding SwapSequence) {
+    protected override InsertionMove[] GenerateMoves(Permutation packingSequence) {
       IRandom random = RandomParameter.ActualValue;
-      return Apply(SwapSequence, random, SampleSizeParameter.ActualValue.Value);
+      return Apply(packingSequence, random, SampleSizeParameter.ActualValue.Value);
     }
   }
Index: branches/HeuristicLab.BinPacking/HeuristicLab.Problems.BinPacking/3.3/Encodings/PackingSequence/Moves/SequenceMove.cs
===================================================================
--- branches/HeuristicLab.BinPacking/HeuristicLab.Problems.BinPacking/3.3/Encodings/PackingSequence/Moves/SequenceMove.cs	(revision 14064)
+++ branches/HeuristicLab.BinPacking/HeuristicLab.Problems.BinPacking/3.3/Encodings/PackingSequence/Moves/SequenceMove.cs	(revision 14128)
@@ -24,13 +24,14 @@
 using HeuristicLab.Common;
 using HeuristicLab.Core;
+using HeuristicLab.Encodings.PermutationEncoding;
 using HeuristicLab.Persistence.Default.CompositeSerializers.Storable;
 using HeuristicLab.Problems.BinPacking;
 
 namespace HeuristicLab.Encodings.PackingEncoding.PackingSequence {
-  [Item("SequenceMove", "An abstract move for a packingSequence encoded solution.")]
+  [Item("SequenceMove", "An abstract move for a packing sequence encoded solution.")]
   [StorableClass]
-  public abstract class SequenceMove : Item, IPackingMove {
+  public abstract class SequenceMove : Item, IPackingMove<Permutation> {
     [Storable]
-    public PackingSequenceEncoding PackingSequence { get; protected set; }
+    public Permutation PackingSequence { get; protected set; }
 
     [StorableConstructor]
@@ -41,10 +42,10 @@
           this.PackingSequence = cloner.Clone(original.PackingSequence);
     }
-    public SequenceMove(PackingSequenceEncoding packingSequence)
+    public SequenceMove(Permutation packingSequence)
       : base() {
         PackingSequence = packingSequence;
     }
 
-    public abstract IPackingSolutionEncoding GetSolutionAfterMove();
+    public abstract Permutation GetSolutionAfterMove();
     public abstract Type GetMoveAttributeType();
     public abstract SequenceMoveAttribute GetAttribute(double quality);
Index: branches/HeuristicLab.BinPacking/HeuristicLab.Problems.BinPacking/3.3/Encodings/PackingSequence/Moves/SequenceTabuMaker.cs
===================================================================
--- branches/HeuristicLab.BinPacking/HeuristicLab.Problems.BinPacking/3.3/Encodings/PackingSequence/Moves/SequenceTabuMaker.cs	(revision 14064)
+++ branches/HeuristicLab.BinPacking/HeuristicLab.Problems.BinPacking/3.3/Encodings/PackingSequence/Moves/SequenceTabuMaker.cs	(revision 14128)
@@ -23,4 +23,5 @@
 using HeuristicLab.Common;
 using HeuristicLab.Core;
+using HeuristicLab.Encodings.PermutationEncoding;
 using HeuristicLab.Optimization.Operators;
 using HeuristicLab.Parameters;
@@ -32,9 +33,9 @@
   [StorableClass]
   public class SequenceTabuMaker : TabuMaker, IPackingSequenceMoveOperator {
-    public ILookupParameter<IPackingMove> PackingMoveParameter {
-      get { return (ILookupParameter<IPackingMove>)Parameters["PackingMove"]; }
+    public ILookupParameter<IPackingMove<Permutation>> PackingMoveParameter {
+      get { return (ILookupParameter<IPackingMove<Permutation>>)Parameters["PackingMove"]; }
     }
-    public ILookupParameter<PackingSequenceEncoding> PackingSequenceParameter {
-      get { return (ILookupParameter<PackingSequenceEncoding>)Parameters["PackingSequence"]; }
+    public ILookupParameter<Permutation> PackingSequenceParameter {
+      get { return (ILookupParameter<Permutation>)Parameters["PackingSequence"]; }
     }
 
@@ -44,6 +45,6 @@
     public SequenceTabuMaker()
       : base() {
-      Parameters.Add(new LookupParameter<IPackingMove>("PackingMove", "The move to evaluate."));
-      Parameters.Add(new LookupParameter<PackingSequenceEncoding>("PackingSequence", "The solution to evaluate."));
+      Parameters.Add(new LookupParameter<IPackingMove<Permutation>>("PackingMove", "The move to evaluate."));
+      Parameters.Add(new LookupParameter<Permutation>("PackingSequence", "The solution to evaluate."));
     }
 
@@ -53,6 +54,5 @@
 
     protected override IItem GetTabuAttribute(bool maximization, double quality, double moveQuality) {
-      IPackingMove move = PackingMoveParameter.ActualValue;
-      PackingSequenceEncoding PackingSequence = PackingSequenceParameter.ActualValue;
+      var move = PackingMoveParameter.ActualValue;
       double baseQuality = moveQuality;
       if (maximization && quality > moveQuality || !maximization && quality < moveQuality)
Index: branches/HeuristicLab.BinPacking/HeuristicLab.Problems.BinPacking/3.3/Encodings/PackingSequence/Moves/Swap2/ExhaustiveSwap2MoveGenerator.cs
===================================================================
--- branches/HeuristicLab.BinPacking/HeuristicLab.Problems.BinPacking/3.3/Encodings/PackingSequence/Moves/Swap2/ExhaustiveSwap2MoveGenerator.cs	(revision 14064)
+++ branches/HeuristicLab.BinPacking/HeuristicLab.Problems.BinPacking/3.3/Encodings/PackingSequence/Moves/Swap2/ExhaustiveSwap2MoveGenerator.cs	(revision 14128)
@@ -24,4 +24,5 @@
 using HeuristicLab.Common;
 using HeuristicLab.Core;
+using HeuristicLab.Encodings.PermutationEncoding;
 using HeuristicLab.Optimization;
 using HeuristicLab.Persistence.Default.CompositeSerializers.Storable;
@@ -39,15 +40,15 @@
       return new ExhaustiveSwap2MoveGenerator(this, cloner);
     }
-    public static IEnumerable<Swap2Move> Generate(PackingSequenceEncoding PackingSequence, int nrOfBins) {
-      for (int i = 0; i < PackingSequence.PackingSequence.Length - 1; i++)
-        for (int j = i + 1; j < PackingSequence.PackingSequence.Length; j++) {
+    public static IEnumerable<Swap2Move> Generate(Permutation packingSequence, int nrOfBins) {
+      for (int i = 0; i < packingSequence.Length - 1; i++)
+        for (int j = i + 1; j < packingSequence.Length; j++) {
           if (j != i)
-            yield return new Swap2Move(i, j, PackingSequence);
+            yield return new Swap2Move(i, j, packingSequence);
         }
     }
 
-    public static Swap2Move[] Apply(PackingSequenceEncoding PackingSequence) {
+    public static Swap2Move[] Apply(Permutation packingSequence) {
       int nrOfBins = 0;
-      foreach (int binNr in PackingSequence.PackingSequence) {
+      foreach (int binNr in packingSequence) {
         if (binNr > nrOfBins)
           nrOfBins = binNr;
@@ -55,8 +56,8 @@
       nrOfBins++;
 
-      int totalMoves = (PackingSequence.PackingSequence.Length * (PackingSequence.PackingSequence.Length - 1)) / 2;
+      int totalMoves = (packingSequence.Length * (packingSequence.Length - 1)) / 2;
       Swap2Move[] moves = new Swap2Move[totalMoves];
       int count = 0;
-      foreach (Swap2Move move in Generate(PackingSequence, nrOfBins)) {
+      foreach (Swap2Move move in Generate(packingSequence, nrOfBins)) {
         moves[count++] = move;
       }
@@ -64,6 +65,6 @@
     }
 
-    protected override Swap2Move[] GenerateMoves(PackingSequenceEncoding PackingSequence) {
-      return Apply(PackingSequence);
+    protected override Swap2Move[] GenerateMoves(Permutation packingSequence) {
+      return Apply(packingSequence);
     }
   }
Index: branches/HeuristicLab.BinPacking/HeuristicLab.Problems.BinPacking/3.3/Encodings/PackingSequence/Moves/Swap2/StochasticSwap2MoveGenerator.cs
===================================================================
--- branches/HeuristicLab.BinPacking/HeuristicLab.Problems.BinPacking/3.3/Encodings/PackingSequence/Moves/Swap2/StochasticSwap2MoveGenerator.cs	(revision 14064)
+++ branches/HeuristicLab.BinPacking/HeuristicLab.Problems.BinPacking/3.3/Encodings/PackingSequence/Moves/Swap2/StochasticSwap2MoveGenerator.cs	(revision 14128)
@@ -25,4 +25,5 @@
 using HeuristicLab.Core;
 using HeuristicLab.Data;
+using HeuristicLab.Encodings.PermutationEncoding;
 using HeuristicLab.Optimization;
 using HeuristicLab.Parameters;
@@ -58,8 +59,8 @@
     }
 
-    public static Swap2Move[] Apply(PackingSequenceEncoding PackingSequence, IRandom random, int sampleSize) {
+    public static Swap2Move[] Apply(Permutation packingSequence, IRandom random, int sampleSize) {
 
       int nrOfBins = 0;
-      foreach (int binNr in PackingSequence.PackingSequence) {
+      foreach (int binNr in packingSequence) {
         if (binNr > nrOfBins)
           nrOfBins = binNr;
@@ -67,5 +68,5 @@
       nrOfBins++;
       var generatedMoves = new List<Swap2Move>();
-      var moves = new List<Swap2Move>(ExhaustiveSwap2MoveGenerator.Generate(PackingSequence, nrOfBins));
+      var moves = new List<Swap2Move>(ExhaustiveSwap2MoveGenerator.Generate(packingSequence, nrOfBins));
       int moveCount = moves.Count;
       for (int i = 0; i < sampleSize; i++) {
@@ -76,7 +77,7 @@
     }
 
-    protected override Swap2Move[] GenerateMoves(PackingSequenceEncoding SwapSequence) {
+    protected override Swap2Move[] GenerateMoves(Permutation packingSequence) {
       IRandom random = RandomParameter.ActualValue;
-      return Apply(SwapSequence, random, SampleSizeParameter.ActualValue.Value);
+      return Apply(packingSequence, random, SampleSizeParameter.ActualValue.Value);
     }
   }
Index: branches/HeuristicLab.BinPacking/HeuristicLab.Problems.BinPacking/3.3/Encodings/PackingSequence/Moves/Swap2/Swap2Move.cs
===================================================================
--- branches/HeuristicLab.BinPacking/HeuristicLab.Problems.BinPacking/3.3/Encodings/PackingSequence/Moves/Swap2/Swap2Move.cs	(revision 14064)
+++ branches/HeuristicLab.BinPacking/HeuristicLab.Problems.BinPacking/3.3/Encodings/PackingSequence/Moves/Swap2/Swap2Move.cs	(revision 14128)
@@ -32,5 +32,5 @@
   [Item("Swap2 Move", "A move on a Sequence vector that is specified by two group-assignment-indexes.")]
   [StorableClass]
-  public class Swap2Move : SequenceMove, IPackingMove {
+  public class Swap2Move : SequenceMove, IPackingMove<Permutation> {
     [Storable]
     public int Index1 { get; protected set; }
@@ -45,6 +45,6 @@
       this.Index2 = original.Index2;
     }
-    public Swap2Move(int index1, int index2, PackingSequenceEncoding PackingSequence)
-      : base(PackingSequence) {
+    public Swap2Move(int index1, int index2, Permutation packingSequence)
+      : base(packingSequence) {
       Index1 = index1;
       Index2 = index2;
@@ -55,9 +55,8 @@
     }
 
-    public override IPackingSolutionEncoding GetSolutionAfterMove() {
-      PackingSequenceEncoding newSolution = new PackingSequenceEncoding();
-      newSolution.PackingSequence = (Permutation)PackingSequence.PackingSequence.Clone(new Cloner());
-      newSolution.PackingSequence[Index1] = PackingSequence.PackingSequence[Index2];
-      newSolution.PackingSequence[Index2] = PackingSequence.PackingSequence[Index1];
+    public override Permutation GetSolutionAfterMove() {
+      Permutation newSolution = (Permutation)PackingSequence.Clone(new Cloner());
+      newSolution[Index1] = PackingSequence[Index2];
+      newSolution[Index2] = PackingSequence[Index1];
       return newSolution;
     }
@@ -68,5 +67,5 @@
 
     public override SequenceMoveAttribute GetAttribute(double quality) {
-      return new Swap2MoveAttribute(Index1, Index2, PackingSequence.PackingSequence[Index1], PackingSequence.PackingSequence[Index2], quality);
+      return new Swap2MoveAttribute(Index1, Index2, PackingSequence[Index1], PackingSequence[Index2], quality);
     }
 
Index: branches/HeuristicLab.BinPacking/HeuristicLab.Problems.BinPacking/3.3/Encodings/PackingSequence/Moves/Swap2/Swap2MoveGenerator.cs
===================================================================
--- branches/HeuristicLab.BinPacking/HeuristicLab.Problems.BinPacking/3.3/Encodings/PackingSequence/Moves/Swap2/Swap2MoveGenerator.cs	(revision 14064)
+++ branches/HeuristicLab.BinPacking/HeuristicLab.Problems.BinPacking/3.3/Encodings/PackingSequence/Moves/Swap2/Swap2MoveGenerator.cs	(revision 14128)
@@ -23,4 +23,5 @@
 using HeuristicLab.Common;
 using HeuristicLab.Core;
+using HeuristicLab.Encodings.PermutationEncoding;
 using HeuristicLab.Operators;
 using HeuristicLab.Optimization;
@@ -36,9 +37,9 @@
       get { return false; }
     }
-    public ILookupParameter<PackingSequenceEncoding> PackingSequenceParameter {
-      get { return (ILookupParameter<PackingSequenceEncoding>)Parameters["PackingSequence"]; }
+    public ILookupParameter<Permutation> PackingSequenceParameter {
+      get { return (ILookupParameter<Permutation>)Parameters["PackingSequence"]; }
     }
-    public ILookupParameter<IPackingMove> PackingMoveParameter {
-      get { return (LookupParameter<IPackingMove>)Parameters["PackingMove"]; }
+    public ILookupParameter<IPackingMove<Permutation>> PackingMoveParameter {
+      get { return (LookupParameter<IPackingMove<Permutation>>)Parameters["PackingMove"]; }
     }
     protected ScopeParameter CurrentScopeParameter {
@@ -51,11 +52,11 @@
     public Swap2MoveGenerator()
       : base() {
-      Parameters.Add(new LookupParameter<PackingSequenceEncoding>("PackingSequence", "The Sequence vector for which moves should be generated."));
-      Parameters.Add(new LookupParameter<IPackingMove>("PackingMove", "The moves that should be generated in subscopes."));
+      Parameters.Add(new LookupParameter<Permutation>("PackingSequence", "The Sequence vector for which moves should be generated."));
+      Parameters.Add(new LookupParameter<IPackingMove<Permutation>>("PackingMove", "The moves that should be generated in subscopes."));
       Parameters.Add(new ScopeParameter("CurrentScope", "The current scope where the moves should be added as subscopes."));
     }
 
     public override IOperation Apply() {
-      PackingSequenceEncoding ps = PackingSequenceParameter.ActualValue;
+      Permutation ps = PackingSequenceParameter.ActualValue;
       Swap2Move[] moves = GenerateMoves(ps);
       Scope[] moveScopes = new Scope[moves.Length];
@@ -68,5 +69,5 @@
     }
 
-    protected abstract Swap2Move[] GenerateMoves(PackingSequenceEncoding PackingSequence);
+    protected abstract Swap2Move[] GenerateMoves(Permutation packingSequence);
   }
 }
Index: branches/HeuristicLab.BinPacking/HeuristicLab.Problems.BinPacking/3.3/Encodings/PackingSequence/PackingSequenceCrossover.cs
===================================================================
--- branches/HeuristicLab.BinPacking/HeuristicLab.Problems.BinPacking/3.3/Encodings/PackingSequence/PackingSequenceCrossover.cs	(revision 14064)
+++ branches/HeuristicLab.BinPacking/HeuristicLab.Problems.BinPacking/3.3/Encodings/PackingSequence/PackingSequenceCrossover.cs	(revision 14128)
@@ -23,4 +23,5 @@
 using HeuristicLab.Common;
 using HeuristicLab.Core;
+using HeuristicLab.Encodings.PermutationEncoding;
 using HeuristicLab.Persistence.Default.CompositeSerializers.Storable;
 using HeuristicLab.Problems.BinPacking;
@@ -29,5 +30,5 @@
   [Item("PackingSequenceCrossover", "An operator which crosses two PackingSequence representations.")]
   [StorableClass]
-  public abstract class PackingSequenceCrossover : PackingSolutionCrossover, IPackingSequenceOperator {
+  public abstract class PackingSequenceCrossover : PackingSolutionCrossover<Permutation>, IPackingSequenceOperator {
 
     [StorableConstructor]
@@ -36,9 +37,9 @@
     public PackingSequenceCrossover()
       : base() {
-        ParentsParameter.ActualName = "PackingSequence";
-        ChildParameter.ActualName = "PackingSequence";
+      ParentsParameter.ActualName = "PackingSequence";
+      ChildParameter.ActualName = "PackingSequence";
     }
 
-    public abstract PackingSequenceEncoding Cross(IRandom random, PackingSequenceEncoding parent1, PackingSequenceEncoding parent2);
+    public abstract Permutation Cross(IRandom random, Permutation parent1, Permutation parent2);
 
     public override IOperation Apply() {
@@ -46,5 +47,5 @@
 
       ChildParameter.ActualValue =
-        Cross(RandomParameter.ActualValue, parents[0] as PackingSequenceEncoding, parents[1] as PackingSequenceEncoding);
+        Cross(RandomParameter.ActualValue, parents[0], parents[1]);
 
       return base.Apply();
Index: branches/HeuristicLab.BinPacking/HeuristicLab.Problems.BinPacking/3.3/Encodings/PackingSequence/PackingSequenceInversionManipulator.cs
===================================================================
--- branches/HeuristicLab.BinPacking/HeuristicLab.Problems.BinPacking/3.3/Encodings/PackingSequence/PackingSequenceInversionManipulator.cs	(revision 14064)
+++ branches/HeuristicLab.BinPacking/HeuristicLab.Problems.BinPacking/3.3/Encodings/PackingSequence/PackingSequenceInversionManipulator.cs	(revision 14128)
@@ -43,6 +43,6 @@
     }
 
-    protected override void Manipulate(IRandom random, PackingSequenceEncoding individual) {
-      InversionManipulator.Apply(random, individual.PackingSequence);
+    protected override void Manipulate(IRandom random, Permutation individual) {
+      InversionManipulator.Apply(random, individual);
     }
   }
Index: branches/HeuristicLab.BinPacking/HeuristicLab.Problems.BinPacking/3.3/Encodings/PackingSequence/PackingSequenceManipulator.cs
===================================================================
--- branches/HeuristicLab.BinPacking/HeuristicLab.Problems.BinPacking/3.3/Encodings/PackingSequence/PackingSequenceManipulator.cs	(revision 14064)
+++ branches/HeuristicLab.BinPacking/HeuristicLab.Problems.BinPacking/3.3/Encodings/PackingSequence/PackingSequenceManipulator.cs	(revision 14128)
@@ -24,4 +24,5 @@
 using HeuristicLab.Common;
 using HeuristicLab.Core;
+using HeuristicLab.Encodings.PermutationEncoding;
 using HeuristicLab.Persistence.Default.CompositeSerializers.Storable;
 using HeuristicLab.Problems.BinPacking;
@@ -30,5 +31,5 @@
   [Item("PackingSequenceManipulator", "An operator which manipulates a PackingSequence representation.")]
   [StorableClass]
-  public abstract class PackingSequenceManipulator : PackingSolutionManipulator, IPackingSequenceOperator {
+  public abstract class PackingSequenceManipulator : PackingSolutionManipulator<Permutation>, IPackingSequenceOperator {
     [StorableConstructor]
     protected PackingSequenceManipulator(bool deserializing) : base(deserializing) { }
@@ -39,8 +40,8 @@
     }
 
-    protected abstract void Manipulate(IRandom random, PackingSequenceEncoding individual);
+    protected abstract void Manipulate(IRandom random, Permutation individual);
 
     public override IOperation Apply() {
-      var solution = EncodedSolutionParameter.ActualValue as PackingSequenceEncoding;
+      var solution = EncodedSolutionParameter.ActualValue;
       if (solution == null) throw new InvalidOperationException("PackingSolutionEncoding was not found or is not of type PackingSequenceEncoding.");
       Manipulate(RandomParameter.ActualValue, solution);
Index: branches/HeuristicLab.BinPacking/HeuristicLab.Problems.BinPacking/3.3/Encodings/PackingSequence/PackingSequenceOrderCrossover.cs
===================================================================
--- branches/HeuristicLab.BinPacking/HeuristicLab.Problems.BinPacking/3.3/Encodings/PackingSequence/PackingSequenceOrderCrossover.cs	(revision 14064)
+++ branches/HeuristicLab.BinPacking/HeuristicLab.Problems.BinPacking/3.3/Encodings/PackingSequence/PackingSequenceOrderCrossover.cs	(revision 14128)
@@ -30,5 +30,5 @@
   [Item("PackingSequence OX", "An operator which crosses two PackingSequence representations using the OX-strategy.")]
   [StorableClass]
-  public class PackingSequenceOrderCrossover : PackingSequenceCrossover, IPackingSequenceOperator {
+  public class PackingSequenceOrderCrossover : PackingSequenceCrossover {
 
     [StorableConstructor]
@@ -42,8 +42,6 @@
     }
 
-    public override PackingSequenceEncoding Cross(IRandom random, PackingSequenceEncoding parent1, PackingSequenceEncoding parent2) {
-      PackingSequenceEncoding result = new PackingSequenceEncoding();
-      result.PackingSequence = OrderCrossover.Apply(random, parent1.PackingSequence, parent2.PackingSequence);
-      return result;
+    public override Permutation Cross(IRandom random, Permutation parent1, Permutation parent2) {
+      return OrderCrossover.Apply(random, parent1, parent2);
     }
   }
Index: branches/HeuristicLab.BinPacking/HeuristicLab.Problems.BinPacking/3.3/Encodings/PackingSequence/PackingSequencePartiallyMatchedCrossover.cs
===================================================================
--- branches/HeuristicLab.BinPacking/HeuristicLab.Problems.BinPacking/3.3/Encodings/PackingSequence/PackingSequencePartiallyMatchedCrossover.cs	(revision 14064)
+++ branches/HeuristicLab.BinPacking/HeuristicLab.Problems.BinPacking/3.3/Encodings/PackingSequence/PackingSequencePartiallyMatchedCrossover.cs	(revision 14128)
@@ -31,5 +31,5 @@
   [Item("PackingSequence PMX", "An operator which crosses two PackingSequence representations using the OX-strategy.")]
   [StorableClass]
-  public class PackingSequencePartiallyMatchedCrossover : PackingSequenceCrossover, IPackingSequenceOperator {
+  public class PackingSequencePartiallyMatchedCrossover : PackingSequenceCrossover {
 
     [StorableConstructor]
@@ -43,8 +43,6 @@
     }
 
-    public override PackingSequenceEncoding Cross(IRandom random, PackingSequenceEncoding parent1, PackingSequenceEncoding parent2) {
-      PackingSequenceEncoding result = new PackingSequenceEncoding();
-      result.PackingSequence = PartiallyMatchedCrossover.Apply(random, parent1.PackingSequence, parent2.PackingSequence);
-      return result;
+    public override Permutation Cross(IRandom random, Permutation parent1, Permutation parent2) {
+      return PartiallyMatchedCrossover.Apply(random, parent1, parent2);
     }
   }
Index: branches/HeuristicLab.BinPacking/HeuristicLab.Problems.BinPacking/3.3/Encodings/PackingSequence/PackingSequenceRandomCreator.cs
===================================================================
--- branches/HeuristicLab.BinPacking/HeuristicLab.Problems.BinPacking/3.3/Encodings/PackingSequence/PackingSequenceRandomCreator.cs	(revision 14064)
+++ branches/HeuristicLab.BinPacking/HeuristicLab.Problems.BinPacking/3.3/Encodings/PackingSequence/PackingSequenceRandomCreator.cs	(revision 14128)
@@ -33,15 +33,15 @@
   [Item("PackingSequenceCreator", "Creator class used to create PackingSequence solutions for bin packing problems.")]
   [StorableClass]
-  public class PackingSequenceRandomCreator : PackingSolutionCreator, IStochasticOperator {
+  public class PackingSequenceRandomCreator : PackingSolutionCreator, IPackingSequenceCreator, IStochasticOperator {
 
     public ILookupParameter<IRandom> RandomParameter {
       get { return (LookupParameter<IRandom>)Parameters["Random"]; }
     }
-    public IValueLookupParameter<IntValue> PackingItemsParameter {
-      get { return (IValueLookupParameter<IntValue>)Parameters["PackingItems"]; }
+    public ILookupParameter<IntValue> NumberOfPackingItemsParameter {
+      get { return (ILookupParameter<IntValue>)Parameters["NumberOfItems"]; }
     }
 
-    public ILookupParameter<PackingSequence> SolutionParameter {
-      get { return (ILookupParameter<PackingSequence>)Parameters["PackingItems"]; }
+    public ILookupParameter<Permutation> SolutionParameter {
+      get { return (ILookupParameter<Permutation>)Parameters["PackingSequence"]; }
     }
 
@@ -58,22 +58,18 @@
       : base() {
       Parameters.Add(new LookupParameter<IRandom>("Random", "The pseudo random number generator."));
-      Parameters.Add(new ValueLookupParameter<IntValue>("PackingItems", "The number of packing-items handled in this problem instance."));
-      Parameters.Add(new LookupParameter<PackingSequence>("PackingSequence"));
-
-      SolutionParameter.ActualName = "PackingSequence";
+      Parameters.Add(new ValueLookupParameter<IntValue>("NumberOfPackingItems", "The number of packing-items handled in this problem instance."));
+      Parameters.Add(new LookupParameter<Permutation>("PackingSequence", "The randomly created solution candidate."));
     }
 
     public override IOperation Apply() {
-      Apply(PackingItemsParameter.ActualValue.Value, RandomParameter.ActualValue);
+      Apply(NumberOfPackingItemsParameter.ActualValue.Value, RandomParameter.ActualValue);
       return base.Apply();
     }
 
-    public static PackingSequenceEncoding Apply(int items, IRandom random) {
-      var solution = new PackingSequenceEncoding();
-      solution.PackingSequence = new Permutation(PermutationTypes.Absolute, items, random);
-      return solution;
+    public static Permutation Apply(int items, IRandom random) {
+      return new Permutation(PermutationTypes.Absolute, items, random);
     }
     protected override IItem CreateSolution() {
-      return Apply(PackingItemsParameter.ActualValue.Value, RandomParameter.ActualValue);
+      return Apply(NumberOfPackingItemsParameter.ActualValue.Value, RandomParameter.ActualValue);
     }
   }
Index: branches/HeuristicLab.BinPacking/HeuristicLab.Problems.BinPacking/3.3/Encodings/PackingSequence/PackingSequenceScrambleManipulator.cs
===================================================================
--- branches/HeuristicLab.BinPacking/HeuristicLab.Problems.BinPacking/3.3/Encodings/PackingSequence/PackingSequenceScrambleManipulator.cs	(revision 14064)
+++ branches/HeuristicLab.BinPacking/HeuristicLab.Problems.BinPacking/3.3/Encodings/PackingSequence/PackingSequenceScrambleManipulator.cs	(revision 14128)
@@ -41,6 +41,6 @@
     }
 
-    protected override void Manipulate(IRandom random, PackingSequenceEncoding individual) {
-      ScrambleManipulator.Apply(random, individual.PackingSequence);
+    protected override void Manipulate(IRandom random, Permutation individual) {
+      ScrambleManipulator.Apply(random, individual);
     }
   }
Index: branches/HeuristicLab.BinPacking/HeuristicLab.Problems.BinPacking/3.3/Encodings/PackingSolutionCrossover.cs
===================================================================
--- branches/HeuristicLab.BinPacking/HeuristicLab.Problems.BinPacking/3.3/Encodings/PackingSolutionCrossover.cs	(revision 14064)
+++ branches/HeuristicLab.BinPacking/HeuristicLab.Problems.BinPacking/3.3/Encodings/PackingSolutionCrossover.cs	(revision 14128)
@@ -32,11 +32,12 @@
   [Item("PackingSolutionCrossover", "A bin packing crossover operation.")]
   [StorableClass]
-  public abstract class PackingSolutionCrossover : SingleSuccessorOperator, IPackingSolutionCrossover, IStochasticOperator {
+  public abstract class PackingSolutionCrossover<T> : SingleSuccessorOperator, IPackingSolutionCrossover<T>, IStochasticOperator
+  where T : class, IItem {
 
-    public ILookupParameter<IPackingSolutionEncoding> ChildParameter {
-      get { return (ILookupParameter<IPackingSolutionEncoding>)Parameters["Child"]; }
+    public ILookupParameter<T> ChildParameter {
+      get { return (ILookupParameter<T>)Parameters["Child"]; }
     }
-    public IScopeTreeLookupParameter<IPackingSolutionEncoding> ParentsParameter {
-      get { return (IScopeTreeLookupParameter<IPackingSolutionEncoding>)Parameters["Parents"]; }
+    public IScopeTreeLookupParameter<T> ParentsParameter {
+      get { return (IScopeTreeLookupParameter<T>)Parameters["Parents"]; }
     }
     public ILookupParameter<IRandom> RandomParameter {
@@ -46,11 +47,11 @@
     [StorableConstructor]
     protected PackingSolutionCrossover(bool deserializing) : base(deserializing) { }
-    protected PackingSolutionCrossover(PackingSolutionCrossover original, Cloner cloner) : base(original, cloner) { }
+    protected PackingSolutionCrossover(PackingSolutionCrossover<T> original, Cloner cloner) : base(original, cloner) { }
     public PackingSolutionCrossover()
       : base() {
       Parameters.Add(new LookupParameter<IRandom>("Random", "The pseudo random number generator which should be used for stochastic manipulation operators."));
-      Parameters.Add(new LookupParameter<IPackingSolutionEncoding>("Child", "The child solution resulting from the crossover."));
+      Parameters.Add(new LookupParameter<T>("Child", "The child solution resulting from the crossover."));
       ChildParameter.ActualName = "EncodedSolution";
-      Parameters.Add(new ScopeTreeLookupParameter<IPackingSolutionEncoding>("Parents", "The parent solution which should be crossed."));
+      Parameters.Add(new ScopeTreeLookupParameter<T>("Parents", "The parent solution which should be crossed."));
       ParentsParameter.ActualName = "EncodedSolution";
     }
Index: branches/HeuristicLab.BinPacking/HeuristicLab.Problems.BinPacking/3.3/Encodings/PackingSolutionManipulator.cs
===================================================================
--- branches/HeuristicLab.BinPacking/HeuristicLab.Problems.BinPacking/3.3/Encodings/PackingSolutionManipulator.cs	(revision 14064)
+++ branches/HeuristicLab.BinPacking/HeuristicLab.Problems.BinPacking/3.3/Encodings/PackingSolutionManipulator.cs	(revision 14128)
@@ -32,8 +32,9 @@
   [Item("PackingSolutionManipulator", "A bin packing manipulation operation.")]
   [StorableClass]
-  public abstract class PackingSolutionManipulator : SingleSuccessorOperator, IPackingSolutionManipulator, IStochasticOperator {
+  public abstract class PackingSolutionManipulator<T> : SingleSuccessorOperator, IPackingSolutionManipulator<T>, IStochasticOperator
+  where T : class, IItem {
 
-    public ILookupParameter<IPackingSolutionEncoding> EncodedSolutionParameter {
-      get { return (ILookupParameter<IPackingSolutionEncoding>)Parameters["EncodedSolution"]; }
+    public ILookupParameter<T> EncodedSolutionParameter {
+      get { return (ILookupParameter<T>)Parameters["EncodedSolution"]; }
     }
 
@@ -44,8 +45,8 @@
     [StorableConstructor]
     protected PackingSolutionManipulator(bool deserializing) : base(deserializing) { }
-    protected PackingSolutionManipulator(PackingSolutionManipulator original, Cloner cloner) : base(original, cloner) { }
+    protected PackingSolutionManipulator(PackingSolutionManipulator<T> original, Cloner cloner) : base(original, cloner) { }
     public PackingSolutionManipulator()
       : base() {
-      Parameters.Add(new LookupParameter<IPackingSolutionEncoding>("EncodedSolution", "The bin packing solution to be manipulated."));
+      Parameters.Add(new LookupParameter<T>("EncodedSolution", "The bin packing solution to be manipulated."));
       Parameters.Add(new LookupParameter<IRandom>("Random", "The pseudo random number generator which should be used for stochastic manipulation operators."));
     }
