Index: /branches/HeuristicLab.BinPacking/HeuristicLab.Problems.BinPacking.2D/3.3/BinPacking2D.cs
===================================================================
--- /branches/HeuristicLab.BinPacking/HeuristicLab.Problems.BinPacking.2D/3.3/BinPacking2D.cs	(revision 14127)
+++ /branches/HeuristicLab.BinPacking/HeuristicLab.Problems.BinPacking.2D/3.3/BinPacking2D.cs	(revision 14128)
@@ -66,5 +66,5 @@
 
       //Find ExtremePoints beginning from sourcepointY
-      var sourcePointY = new PackingPosition(0, position.X, position.Y + newItem.Height);
+      var sourcePointY = new PackingPosition(0, position.X, position.Y + newHeight);
       if (sourcePointY.X < BinMeasures.Width && sourcePointY.Y < BinMeasures.Height) {
         //Traversing down the x-axis  
Index: /branches/HeuristicLab.BinPacking/HeuristicLab.Problems.BinPacking.2D/3.3/Decoders/BL/BottomLeftPackingSequenceDecoder.cs
===================================================================
--- /branches/HeuristicLab.BinPacking/HeuristicLab.Problems.BinPacking.2D/3.3/Decoders/BL/BottomLeftPackingSequenceDecoder.cs	(revision 14127)
+++ /branches/HeuristicLab.BinPacking/HeuristicLab.Problems.BinPacking.2D/3.3/Decoders/BL/BottomLeftPackingSequenceDecoder.cs	(revision 14128)
@@ -25,7 +25,7 @@
 using HeuristicLab.Core;
 using HeuristicLab.Common;
-using HeuristicLab.Encodings.PackingEncoding.PackingSequence;
 using HeuristicLab.Problems.BinPacking;
 using HeuristicLab.Encodings.PackingEncoding;
+using HeuristicLab.Encodings.PermutationEncoding;
 
 namespace HeuristicLab.Problems.BinPacking2D {
@@ -45,5 +45,5 @@
 
     public override PackingPlan<PackingPosition, PackingShape, PackingItem> CreatePackingPlanFromEncoding(IItem encodedSolution, PackingShape binMeasures, ItemList<PackingItem> itemMeasures) {
-      var solution = encodedSolution as PackingSequenceEncoding;
+      var solution = encodedSolution as Permutation;
       if (solution == null) throw new InvalidOperationException("Encoding is not of type PackingSequence");
       Solution result = new Solution(binMeasures);
Index: /branches/HeuristicLab.BinPacking/HeuristicLab.Problems.BinPacking.2D/3.3/Decoders/EP/ExtremePointMultiComponentVectorDecoder2D.cs
===================================================================
--- /branches/HeuristicLab.BinPacking/HeuristicLab.Problems.BinPacking.2D/3.3/Decoders/EP/ExtremePointMultiComponentVectorDecoder2D.cs	(revision 14127)
+++ /branches/HeuristicLab.BinPacking/HeuristicLab.Problems.BinPacking.2D/3.3/Decoders/EP/ExtremePointMultiComponentVectorDecoder2D.cs	(revision 14128)
@@ -24,5 +24,4 @@
 using HeuristicLab.Core;
 using HeuristicLab.Common;
-using HeuristicLab.Encodings.PackingEncoding.MultiComponentVector;
 using HeuristicLab.Problems.BinPacking;
 using HeuristicLab.Encodings.PackingEncoding;
Index: /branches/HeuristicLab.BinPacking/HeuristicLab.Problems.BinPacking.2D/3.3/Decoders/EP/ExtremePointPackingSequenceDecoder2D.cs
===================================================================
--- /branches/HeuristicLab.BinPacking/HeuristicLab.Problems.BinPacking.2D/3.3/Decoders/EP/ExtremePointPackingSequenceDecoder2D.cs	(revision 14127)
+++ /branches/HeuristicLab.BinPacking/HeuristicLab.Problems.BinPacking.2D/3.3/Decoders/EP/ExtremePointPackingSequenceDecoder2D.cs	(revision 14128)
@@ -25,7 +25,7 @@
 using HeuristicLab.Core;
 using HeuristicLab.Common;
-using HeuristicLab.Encodings.PackingEncoding.PackingSequence;
 using HeuristicLab.Problems.BinPacking;
 using HeuristicLab.Encodings.PackingEncoding;
+using HeuristicLab.Encodings.PermutationEncoding;
 
 namespace HeuristicLab.Problems.BinPacking2D {
@@ -45,6 +45,6 @@
 
     public override PackingPlan<PackingPosition, PackingShape, PackingItem> CreatePackingPlanFromEncoding(IItem encodedSolution, PackingShape binMeasures, ItemList<PackingItem> itemMeasures) {
-      var solution = encodedSolution as PackingSequenceEncoding;
-      if (solution == null) throw new InvalidOperationException("Encoding is not of type PackingSequence");
+      var solution = encodedSolution as Permutation;
+      if (solution == null) throw new InvalidOperationException("Encoding is not of type Permutation");
       Solution result = new Solution(binMeasures, true, false);
       result.Pack(solution, itemMeasures);
Index: /branches/HeuristicLab.BinPacking/HeuristicLab.Problems.BinPacking.2D/3.3/HeuristicLab.Problems.BinPacking2D-3.3.csproj
===================================================================
--- /branches/HeuristicLab.BinPacking/HeuristicLab.Problems.BinPacking.2D/3.3/HeuristicLab.Problems.BinPacking2D-3.3.csproj	(revision 14127)
+++ /branches/HeuristicLab.BinPacking/HeuristicLab.Problems.BinPacking.2D/3.3/HeuristicLab.Problems.BinPacking2D-3.3.csproj	(revision 14128)
@@ -163,10 +163,7 @@
   <ItemGroup>
     <Compile Include="BinPacking2D.cs" />
-    <Compile Include="Decoders\BL\BottomLeftGroupingVectorDecoder.cs" />
-    <Compile Include="Decoders\BL\BottomLeftMultiComponentVectorDecoder.cs" />
-    <Compile Include="Decoders\BL\BottomLeftPackingSequenceDecoder.cs" />
-    <Compile Include="Decoders\EP\ExtremePointGroupingVectorDecoder2D.cs" />
-    <Compile Include="Decoders\EP\ExtremePointMultiComponentVectorDecoder2D.cs" />
-    <Compile Include="Decoders\EP\ExtremePointPackingSequenceDecoder2D.cs" />
+    <Compile Include="Decoders\EP\ExtremePointPackingSequenceDecoder2D.cs">
+      <SubType>Code</SubType>
+    </Compile>
     <Compile Include="Instances\BPPData.cs" />
     <Compile Include="Instances\RandomDataDescriptor.cs" />
@@ -176,13 +173,10 @@
     <Compile Include="Interfaces\I2DOperator.cs" />
     <Compile Include="Interfaces\I2DPSDecoder.cs" />
-    <Compile Include="MoveEvaluators\PackingMoveEvaluator2DGV.cs" />
-    <Compile Include="MoveEvaluators\PackingMoveEvaluator2DMCV.cs" />
-    <Compile Include="MoveEvaluators\PackingMoveEvaluator2DPS.cs" />
     <Compile Include="PackingItem.cs" />
     <Compile Include="PackingPosition.cs" />
     <Compile Include="PackingRatioEvaluator.cs" />
+    <Compile Include="PackingSequenceProblem.cs" />
     <Compile Include="PackingShape.cs" />
     <Compile Include="Plugin.cs" />
-    <Compile Include="Problem.cs" />
     <Compile Include="Properties\AssemblyInfo.cs" />
     <Compile Include="Solution.cs" />
@@ -198,4 +192,8 @@
       <Name>HeuristicLab.Problems.BinPacking-3.3</Name>
     </ProjectReference>
+  </ItemGroup>
+  <ItemGroup>
+    <Folder Include="Decoders\BL\" />
+    <Folder Include="MoveEvaluators\" />
   </ItemGroup>
   <Import Project="$(MSBuildToolsPath)\Microsoft.CSharp.targets" />
Index: /branches/HeuristicLab.BinPacking/HeuristicLab.Problems.BinPacking.2D/3.3/MoveEvaluators/PackingMoveEvaluator2DGV.cs
===================================================================
--- /branches/HeuristicLab.BinPacking/HeuristicLab.Problems.BinPacking.2D/3.3/MoveEvaluators/PackingMoveEvaluator2DGV.cs	(revision 14127)
+++ /branches/HeuristicLab.BinPacking/HeuristicLab.Problems.BinPacking.2D/3.3/MoveEvaluators/PackingMoveEvaluator2DGV.cs	(revision 14128)
@@ -29,12 +29,13 @@
   [Item("GroupingVectorMoveEvaluator2D", "Class for evaluating packing moves for 2dimensional problems.")]
   [StorableClass]
-  public class PackingMoveEvaluator2DGV : PackingMoveEvaluator<PackingPosition, PackingShape, PackingItem>, ISingleObjectiveMoveEvaluator, IGroupingVectorMoveOperator, I2DOperator {
+  public class PackingMoveEvaluator2DGV<T> : PackingMoveEvaluator<PackingPosition, PackingShape, PackingItem, T>, ISingleObjectiveMoveEvaluator, IGroupingVectorMoveOperator, I2DOperator
+  where T : class , IItem {
     [StorableConstructor]
     protected PackingMoveEvaluator2DGV(bool deserializing) : base(deserializing) { }
-    protected PackingMoveEvaluator2DGV(PackingMoveEvaluator2DGV original, Cloner cloner)
+    protected PackingMoveEvaluator2DGV(PackingMoveEvaluator2DGV<T> original, Cloner cloner)
       : base(original, cloner) {
     }
     public override IDeepCloneable Clone(Cloner cloner) {
-      return new PackingMoveEvaluator2DGV(this, cloner);
+      return new PackingMoveEvaluator2DGV<T>(this, cloner);
     }
     public PackingMoveEvaluator2DGV()
Index: /branches/HeuristicLab.BinPacking/HeuristicLab.Problems.BinPacking.2D/3.3/MoveEvaluators/PackingMoveEvaluator2DMCV.cs
===================================================================
--- /branches/HeuristicLab.BinPacking/HeuristicLab.Problems.BinPacking.2D/3.3/MoveEvaluators/PackingMoveEvaluator2DMCV.cs	(revision 14127)
+++ /branches/HeuristicLab.BinPacking/HeuristicLab.Problems.BinPacking.2D/3.3/MoveEvaluators/PackingMoveEvaluator2DMCV.cs	(revision 14128)
@@ -29,12 +29,13 @@
   [Item("MultiComponentVectorMoveEvaluator2D", "Class for evaluating packing moves for 2dimensional problems.")]
   [StorableClass]
-  public class PackingMoveEvaluator2DMCV : PackingMoveEvaluator<PackingPosition, PackingShape, PackingItem>, ISingleObjectiveMoveEvaluator, IMultiComponentVectorMoveOperator, I2DOperator {
+  public class PackingMoveEvaluator2DMCV<T> : PackingMoveEvaluator<PackingPosition, PackingShape, PackingItem, T>, ISingleObjectiveMoveEvaluator, IMultiComponentVectorMoveOperator, I2DOperator 
+  where T : class, IItem {
     [StorableConstructor]
     protected PackingMoveEvaluator2DMCV(bool deserializing) : base(deserializing) { }
-    protected PackingMoveEvaluator2DMCV(PackingMoveEvaluator2DMCV original, Cloner cloner)
+    protected PackingMoveEvaluator2DMCV(PackingMoveEvaluator2DMCV<T> original, Cloner cloner)
       : base(original, cloner) {
     }
     public override IDeepCloneable Clone(Cloner cloner) {
-      return new PackingMoveEvaluator2DMCV(this, cloner);
+      return new PackingMoveEvaluator2DMCV<T>(this, cloner);
     }
     public PackingMoveEvaluator2DMCV()
Index: /branches/HeuristicLab.BinPacking/HeuristicLab.Problems.BinPacking.2D/3.3/MoveEvaluators/PackingMoveEvaluator2DPS.cs
===================================================================
--- /branches/HeuristicLab.BinPacking/HeuristicLab.Problems.BinPacking.2D/3.3/MoveEvaluators/PackingMoveEvaluator2DPS.cs	(revision 14127)
+++ /branches/HeuristicLab.BinPacking/HeuristicLab.Problems.BinPacking.2D/3.3/MoveEvaluators/PackingMoveEvaluator2DPS.cs	(revision 14128)
@@ -29,12 +29,13 @@
   [Item("PackingSequenceMoveEvaluator2D", "Class for evaluating packing moves for 2dimensional problems.")]
   [StorableClass]
-  public class PackingMoveEvaluator2DPS : PackingMoveEvaluator<PackingPosition, PackingShape, PackingItem>, ISingleObjectiveMoveEvaluator, IPackingSequenceMoveOperator, I2DOperator {
+  public class PackingMoveEvaluator2DPS<T> : PackingMoveEvaluator<PackingPosition, PackingShape, PackingItem, T>, ISingleObjectiveMoveEvaluator, IPackingSequenceMoveOperator, I2DOperator
+  where T : class, IItem {
     [StorableConstructor]
     protected PackingMoveEvaluator2DPS(bool deserializing) : base(deserializing) { }
-    protected PackingMoveEvaluator2DPS(PackingMoveEvaluator2DPS original, Cloner cloner)
+    protected PackingMoveEvaluator2DPS(PackingMoveEvaluator2DPS<T> original, Cloner cloner)
       : base(original, cloner) {
     }
     public override IDeepCloneable Clone(Cloner cloner) {
-      return new PackingMoveEvaluator2DPS(this, cloner);
+      return new PackingMoveEvaluator2DPS<T>(this, cloner);
     }
     public PackingMoveEvaluator2DPS()
Index: /branches/HeuristicLab.BinPacking/HeuristicLab.Problems.BinPacking.2D/3.3/PackingSequenceProblem.cs
===================================================================
--- /branches/HeuristicLab.BinPacking/HeuristicLab.Problems.BinPacking.2D/3.3/PackingSequenceProblem.cs	(revision 14128)
+++ /branches/HeuristicLab.BinPacking/HeuristicLab.Problems.BinPacking.2D/3.3/PackingSequenceProblem.cs	(revision 14128)
@@ -0,0 +1,79 @@
+﻿#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.CodeDom;
+using System.Linq;
+using System.Text;
+using HeuristicLab.Common;
+using HeuristicLab.Core;
+using HeuristicLab.Data;
+using HeuristicLab.Encodings.PermutationEncoding;
+using HeuristicLab.Optimization;
+using HeuristicLab.Persistence.Default.CompositeSerializers.Storable;
+using HeuristicLab.Problems.BinPacking;
+using HeuristicLab.Problems.BinPacking2D;
+
+namespace HeuristicLab.Problems.BinPacking2d {
+  [StorableClass]
+  [Creatable(Category = CreatableAttribute.Categories.CombinatorialProblems, Priority = 300)]
+  public class PackingSequenceProblem : PackingSequenceProblem<Permutation, PermutationEncoding> {
+
+    // persistence
+    [StorableConstructor]
+    protected PackingSequenceProblem(bool deserializing) : base(deserializing) { }
+    [StorableHook(HookType.AfterDeserialization)]
+    private void AfterDeserialization() { }
+
+    public override bool Maximization {
+      get { return true; }
+    }
+
+
+    // cloning
+    protected PackingSequenceProblem(PackingSequenceProblem original, Cloner cloner)
+      : base(original, cloner) {
+    }
+
+    protected PackingSequenceProblem() : base() { }
+
+
+    public override IDeepCloneable Clone(Cloner cloner) {
+      return new PackingSequenceProblem(this, cloner);
+    }
+
+
+    public override double Evaluate(Individual individual, IRandom random) {
+      var permutation = individual.Permutation();
+      var decoder = new ExtremePointPackingSequenceDecoder2D();
+      var packingPlan = decoder.CreatePackingPlanFromEncoding(permutation, Bin, Items);
+      var ratio = PackingRatioEvaluator.CalculatePackingRatio(packingPlan);
+      return ratio.Value;
+    }
+
+    public override void Analyze(Individual[] individuals, double[] qualities, ResultCollection results, IRandom random) {
+      base.Analyze(individuals, qualities, results, random);
+      Analyze(individuals.Select(i => i.Permutation()).ToArray(), qualities, results, random);
+    }
+  }
+}
Index: /branches/HeuristicLab.BinPacking/HeuristicLab.Problems.BinPacking.2D/3.3/Problem.cs
===================================================================
--- /branches/HeuristicLab.BinPacking/HeuristicLab.Problems.BinPacking.2D/3.3/Problem.cs	(revision 14127)
+++ /branches/HeuristicLab.BinPacking/HeuristicLab.Problems.BinPacking.2D/3.3/Problem.cs	(revision 14128)
@@ -26,9 +26,6 @@
 using HeuristicLab.PluginInfrastructure;
 using HeuristicLab.Encodings.PackingEncoding.PackingSequence;
-using HeuristicLab.Encodings.PackingEncoding.GroupingVector;
 using HeuristicLab.Problems.Instances;
-using HeuristicLab.Encodings.PackingEncoding.MultiComponentVector;
 using HeuristicLab.Data;
-using System;
 using HeuristicLab.Problems.BinPacking;
 
@@ -37,5 +34,4 @@
   [StorableClass]
   [Creatable(CreatableAttribute.Categories.CombinatorialProblems, Priority = 300)]
-  // TODO: only support 2d BPPData
   public class Problem : Problem<PackingPosition, PackingShape, PackingItem>, IProblemInstanceConsumer<BPPData>, IProblemInstanceExporter<BPPData> {
 
@@ -131,9 +127,9 @@
       if (SolutionCreator is PackingSequenceRandomCreator) {
         PackingSolutionDecoderParameter.ValidValues.UnionWith(ApplicationManager.Manager.GetInstances<I2DPSDecoder>());
-      } else if (SolutionCreator is GroupingVectorRandomCreator) {
+      } /*else if (SolutionCreator is GroupingVectorRandomCreator) {
         PackingSolutionDecoderParameter.ValidValues.UnionWith(ApplicationManager.Manager.GetInstances<I2DGVDecoder>());
       } else if (SolutionCreator is MultiComponentVectorRandomCreator) {
         PackingSolutionDecoderParameter.ValidValues.UnionWith(ApplicationManager.Manager.GetInstances<I2DMCVDecoder>());
-      } else {
+      } */ else {
         string error = "The given problem does not support the selected solution-creator.";
         ErrorHandling.ShowErrorDialog(error, null);
Index: /branches/HeuristicLab.BinPacking/HeuristicLab.Problems.BinPacking.3D/3.3/Decoders/DBL/DeepestBottomLeftPackingSequenceDecoder.cs
===================================================================
--- /branches/HeuristicLab.BinPacking/HeuristicLab.Problems.BinPacking.3D/3.3/Decoders/DBL/DeepestBottomLeftPackingSequenceDecoder.cs	(revision 14127)
+++ /branches/HeuristicLab.BinPacking/HeuristicLab.Problems.BinPacking.3D/3.3/Decoders/DBL/DeepestBottomLeftPackingSequenceDecoder.cs	(revision 14128)
@@ -24,7 +24,7 @@
 using HeuristicLab.Core;
 using HeuristicLab.Common;
-using HeuristicLab.Encodings.PackingEncoding.PackingSequence;
 using HeuristicLab.Problems.BinPacking;
 using HeuristicLab.Encodings.PackingEncoding;
+using HeuristicLab.Encodings.PermutationEncoding;
 
 namespace HeuristicLab.Problems.BinPacking3D {
@@ -32,5 +32,5 @@
   [StorableClass]
   public class DeepestBottomLeftPackingSequenceDecoder : PackingSolutionDecoder<PackingPosition, PackingShape, PackingItem>, I3DPSDecoder {
-    public DeepestBottomLeftPackingSequenceDecoder(): base() {}
+    public DeepestBottomLeftPackingSequenceDecoder() : base() { }
     [StorableConstructor]
     protected DeepestBottomLeftPackingSequenceDecoder(bool deserializing) : base(deserializing) { }
@@ -43,6 +43,6 @@
 
     public override PackingPlan<PackingPosition, PackingShape, PackingItem> CreatePackingPlanFromEncoding(IItem encodedSolution, PackingShape binMeasures, ItemList<PackingItem> itemMeasures) {
-      var solution = encodedSolution as PackingSequenceEncoding;
-      if (solution == null) throw new InvalidOperationException("Encoding is not of type PackingSequence");
+      var solution = encodedSolution as Permutation;
+      if (solution == null) throw new InvalidOperationException("Encoding is not of type Permutation");
       Solution result = new Solution(binMeasures);
       result.Pack(solution, itemMeasures);
Index: /branches/HeuristicLab.BinPacking/HeuristicLab.Problems.BinPacking.3D/3.3/Decoders/EP/ExtremePointPackingSequenceDecoder3D.cs
===================================================================
--- /branches/HeuristicLab.BinPacking/HeuristicLab.Problems.BinPacking.3D/3.3/Decoders/EP/ExtremePointPackingSequenceDecoder3D.cs	(revision 14127)
+++ /branches/HeuristicLab.BinPacking/HeuristicLab.Problems.BinPacking.3D/3.3/Decoders/EP/ExtremePointPackingSequenceDecoder3D.cs	(revision 14128)
@@ -25,7 +25,7 @@
 using HeuristicLab.Core;
 using HeuristicLab.Common;
-using HeuristicLab.Encodings.PackingEncoding.PackingSequence;
 using HeuristicLab.Problems.BinPacking;
 using HeuristicLab.Encodings.PackingEncoding;
+using HeuristicLab.Encodings.PermutationEncoding;
 
 namespace HeuristicLab.Problems.BinPacking3D {
@@ -45,6 +45,6 @@
 
     public override PackingPlan<PackingPosition, PackingShape, PackingItem> CreatePackingPlanFromEncoding(IItem encodedSolution, PackingShape binMeasures, ItemList<PackingItem> itemMeasures) {
-      var solution = encodedSolution as PackingSequenceEncoding;
-      if (solution == null) throw new InvalidOperationException("Encoding is not of type PackingSequence");
+      var solution = encodedSolution as Permutation;
+      if (solution == null) throw new InvalidOperationException("Encoding is not of type Permutation");
       Solution result = new Solution(binMeasures, true, StackingConstraintsParameter.Value.Value);
       result.Pack(solution, itemMeasures); 
Index: /branches/HeuristicLab.BinPacking/HeuristicLab.Problems.BinPacking.3D/3.3/HeuristicLab.Problems.BinPacking3D-3.3.csproj
===================================================================
--- /branches/HeuristicLab.BinPacking/HeuristicLab.Problems.BinPacking.3D/3.3/HeuristicLab.Problems.BinPacking3D-3.3.csproj	(revision 14127)
+++ /branches/HeuristicLab.BinPacking/HeuristicLab.Problems.BinPacking.3D/3.3/HeuristicLab.Problems.BinPacking3D-3.3.csproj	(revision 14128)
@@ -166,9 +166,5 @@
     <Compile Include="DecoderInterfaces\I3DMCVDecoder.cs" />
     <Compile Include="DecoderInterfaces\I3DPSDecoder.cs" />
-    <Compile Include="Decoders\DBL\DeepestBottomLeftGroupingVectorDecoder.cs" />
-    <Compile Include="Decoders\DBL\DeepestBottomLeftMultiComponentVectorDecoder.cs" />
     <Compile Include="Decoders\DBL\DeepestBottomLeftPackingSequenceDecoder.cs" />
-    <Compile Include="Decoders\EP\ExtremePointGroupingVectorDecoder3D.cs" />
-    <Compile Include="Decoders\EP\ExtremePointMultiComponentVectorDecoder3D.cs" />
     <Compile Include="Decoders\EP\ExtremePointPackingSequenceDecoder3D.cs" />
     <Compile Include="I3DOperator.cs" />
@@ -184,5 +180,4 @@
     <Compile Include="PackingShape.cs" />
     <Compile Include="Plugin.cs" />
-    <Compile Include="Problem.cs" />
     <Compile Include="Properties\AssemblyInfo.cs" />
     <Compile Include="Solution.cs" />
Index: /branches/HeuristicLab.BinPacking/HeuristicLab.Problems.BinPacking.3D/3.3/MoveEvaluators/PackingMoveEvaluator3DGV.cs
===================================================================
--- /branches/HeuristicLab.BinPacking/HeuristicLab.Problems.BinPacking.3D/3.3/MoveEvaluators/PackingMoveEvaluator3DGV.cs	(revision 14127)
+++ /branches/HeuristicLab.BinPacking/HeuristicLab.Problems.BinPacking.3D/3.3/MoveEvaluators/PackingMoveEvaluator3DGV.cs	(revision 14128)
@@ -30,12 +30,13 @@
   [Item("GroupingVectorMoveEvaluator3D", "Class for evaluating packing moves for 3dimensional problems.")]
   [StorableClass]
-  public class PackingMoveEvaluator3DGV : PackingMoveEvaluator<PackingPosition, PackingShape, PackingItem>, ISingleObjectiveMoveEvaluator, IGroupingVectorMoveOperator, I3DOperator {
+  public class PackingMoveEvaluator3DGV<M> : PackingMoveEvaluator<PackingPosition, PackingShape, PackingItem, M>, ISingleObjectiveMoveEvaluator, IGroupingVectorMoveOperator, I3DOperator 
+  where M: class, IItem {
     [StorableConstructor]
     protected PackingMoveEvaluator3DGV(bool deserializing) : base(deserializing) { }
-    protected PackingMoveEvaluator3DGV(PackingMoveEvaluator3DGV original, Cloner cloner)
+    protected PackingMoveEvaluator3DGV(PackingMoveEvaluator3DGV<M> original, Cloner cloner)
       : base(original, cloner) {
     }
     public override IDeepCloneable Clone(Cloner cloner) {
-      return new PackingMoveEvaluator3DGV(this, cloner);
+      return new PackingMoveEvaluator3DGV<M>(this, cloner);
     }
     public PackingMoveEvaluator3DGV()
Index: /branches/HeuristicLab.BinPacking/HeuristicLab.Problems.BinPacking.3D/3.3/MoveEvaluators/PackingMoveEvaluator3DMCV.cs
===================================================================
--- /branches/HeuristicLab.BinPacking/HeuristicLab.Problems.BinPacking.3D/3.3/MoveEvaluators/PackingMoveEvaluator3DMCV.cs	(revision 14127)
+++ /branches/HeuristicLab.BinPacking/HeuristicLab.Problems.BinPacking.3D/3.3/MoveEvaluators/PackingMoveEvaluator3DMCV.cs	(revision 14128)
@@ -30,12 +30,13 @@
   [Item("MultiComponentVectorMoveEvaluator3D", "Class for evaluating packing moves for 3dimensional problems.")]
   [StorableClass]
-  public class PackingMoveEvaluator3DMCV : PackingMoveEvaluator<PackingPosition, PackingShape, PackingItem>, ISingleObjectiveMoveEvaluator, IMultiComponentVectorMoveOperator, I3DOperator {
+  public class PackingMoveEvaluator3DMCV<M> : PackingMoveEvaluator<PackingPosition, PackingShape, PackingItem, M>, ISingleObjectiveMoveEvaluator, IMultiComponentVectorMoveOperator, I3DOperator
+  where M : class, IItem {
     [StorableConstructor]
     protected PackingMoveEvaluator3DMCV(bool deserializing) : base(deserializing) { }
-    protected PackingMoveEvaluator3DMCV(PackingMoveEvaluator3DMCV original, Cloner cloner)
+    protected PackingMoveEvaluator3DMCV(PackingMoveEvaluator3DMCV<M> original, Cloner cloner)
       : base(original, cloner) {
     }
     public override IDeepCloneable Clone(Cloner cloner) {
-      return new PackingMoveEvaluator3DMCV(this, cloner);
+      return new PackingMoveEvaluator3DMCV<M>(this, cloner);
     }
     public PackingMoveEvaluator3DMCV()
Index: /branches/HeuristicLab.BinPacking/HeuristicLab.Problems.BinPacking.3D/3.3/MoveEvaluators/PackingMoveEvaluator3DPS.cs
===================================================================
--- /branches/HeuristicLab.BinPacking/HeuristicLab.Problems.BinPacking.3D/3.3/MoveEvaluators/PackingMoveEvaluator3DPS.cs	(revision 14127)
+++ /branches/HeuristicLab.BinPacking/HeuristicLab.Problems.BinPacking.3D/3.3/MoveEvaluators/PackingMoveEvaluator3DPS.cs	(revision 14128)
@@ -30,12 +30,13 @@
   [Item("PackingSequenceMoveEvaluator3D", "Class for evaluating packing moves for 3dimensional problems.")]
   [StorableClass]
-  public class PackingMoveEvaluator3DPS : PackingMoveEvaluator<PackingPosition, PackingShape, PackingItem>, ISingleObjectiveMoveEvaluator, IPackingSequenceMoveOperator, I3DOperator {
+  public class PackingMoveEvaluator3DPS<M> : PackingMoveEvaluator<PackingPosition, PackingShape, PackingItem, M>, ISingleObjectiveMoveEvaluator, IPackingSequenceMoveOperator, I3DOperator
+  where M : class, IItem {
     [StorableConstructor]
     protected PackingMoveEvaluator3DPS(bool deserializing) : base(deserializing) { }
-    protected PackingMoveEvaluator3DPS(PackingMoveEvaluator3DPS original, Cloner cloner)
+    protected PackingMoveEvaluator3DPS(PackingMoveEvaluator3DPS<M> original, Cloner cloner)
       : base(original, cloner) {
     }
     public override IDeepCloneable Clone(Cloner cloner) {
-      return new PackingMoveEvaluator3DPS(this, cloner);
+      return new PackingMoveEvaluator3DPS<M>(this, cloner);
     }
     public PackingMoveEvaluator3DPS()
Index: /branches/HeuristicLab.BinPacking/HeuristicLab.Problems.BinPacking.3D/3.3/Problem.cs
===================================================================
--- /branches/HeuristicLab.BinPacking/HeuristicLab.Problems.BinPacking.3D/3.3/Problem.cs	(revision 14127)
+++ /branches/HeuristicLab.BinPacking/HeuristicLab.Problems.BinPacking.3D/3.3/Problem.cs	(revision 14128)
@@ -26,7 +26,5 @@
 using HeuristicLab.Encodings.PermutationEncoding;
 using HeuristicLab.Encodings.PackingEncoding.PackingSequence;
-using HeuristicLab.Encodings.PackingEncoding.GroupingVector;
 using HeuristicLab.Problems.Instances;
-using HeuristicLab.Encodings.PackingEncoding.MultiComponentVector;
 using HeuristicLab.PluginInfrastructure;
 using HeuristicLab.Data;
@@ -131,9 +129,9 @@
       if (SolutionCreator is PackingSequenceRandomCreator) {
         PackingSolutionDecoderParameter.ValidValues.UnionWith(ApplicationManager.Manager.GetInstances<I3DPSDecoder>());
-      } else if (SolutionCreator is GroupingVectorRandomCreator) {
+      } /* else if (SolutionCreator is GroupingVectorRandomCreator) {
         PackingSolutionDecoderParameter.ValidValues.UnionWith(ApplicationManager.Manager.GetInstances<I3DGVDecoder>());
       } else if (SolutionCreator is MultiComponentVectorRandomCreator) {
         PackingSolutionDecoderParameter.ValidValues.UnionWith(ApplicationManager.Manager.GetInstances<I3DMCVDecoder>());
-      } else {
+      } */ else {
         string error = "The given problem does not support the selected solution-creator.";
         ErrorHandling.ShowErrorDialog(error, null);
Index: /branches/HeuristicLab.BinPacking/HeuristicLab.Problems.BinPacking.Views/3.3/HeuristicLab.Problems.BinPacking.Views-3.3.csproj
===================================================================
--- /branches/HeuristicLab.BinPacking/HeuristicLab.Problems.BinPacking.Views/3.3/HeuristicLab.Problems.BinPacking.Views-3.3.csproj	(revision 14127)
+++ /branches/HeuristicLab.BinPacking/HeuristicLab.Problems.BinPacking.Views/3.3/HeuristicLab.Problems.BinPacking.Views-3.3.csproj	(revision 14128)
@@ -108,30 +108,27 @@
   </PropertyGroup>
   <ItemGroup>
-    <Reference Include="HeuristicLab.Collections-3.3, Version=3.3.0.0, Culture=neutral, PublicKeyToken=ba48961d6f65dcec, processorArchitecture=MSIL">
-      <Private>False</Private>
-    </Reference>
-    <Reference Include="HeuristicLab.Common-3.3, Version=3.3.0.0, Culture=neutral, PublicKeyToken=ba48961d6f65dcec, processorArchitecture=MSIL">
-      <Private>False</Private>
-    </Reference>
-    <Reference Include="HeuristicLab.Core-3.3, Version=3.3.0.0, Culture=neutral, PublicKeyToken=ba48961d6f65dcec, processorArchitecture=MSIL">
-      <Private>False</Private>
-    </Reference>
-    <Reference Include="HeuristicLab.Core.Views-3.3, Version=3.3.0.0, Culture=neutral, PublicKeyToken=ba48961d6f65dcec, processorArchitecture=MSIL">
-      <Private>False</Private>
-    </Reference>
-    <Reference Include="HeuristicLab.MainForm-3.3, Version=3.3.0.0, Culture=neutral, PublicKeyToken=ba48961d6f65dcec, processorArchitecture=MSIL">
-      <Private>False</Private>
-    </Reference>
-    <Reference Include="HeuristicLab.MainForm.WindowsForms-3.3, Version=3.3.0.0, Culture=neutral, PublicKeyToken=ba48961d6f65dcec, processorArchitecture=MSIL">
-      <Private>False</Private>
-    </Reference>
-    <Reference Include="HeuristicLab.Optimization-3.3, Version=3.3.0.0, Culture=neutral, PublicKeyToken=ba48961d6f65dcec, processorArchitecture=MSIL">
-      <Private>False</Private>
-    </Reference>
-    <Reference Include="HeuristicLab.Optimization.Views-3.3, Version=3.3.0.0, Culture=neutral, PublicKeyToken=ba48961d6f65dcec, processorArchitecture=MSIL">
-      <Private>False</Private>
-    </Reference>
-    <Reference Include="HeuristicLab.PluginInfrastructure-3.3, Version=3.3.0.0, Culture=neutral, PublicKeyToken=ba48961d6f65dcec, processorArchitecture=MSIL">
-      <Private>False</Private>
+    <Reference Include="HeuristicLab.Collections-3.3">
+      <HintPath>..\..\..\..\trunk\sources\bin\HeuristicLab.Collections-3.3.dll</HintPath>
+    </Reference>
+    <Reference Include="HeuristicLab.Common-3.3">
+      <HintPath>..\..\..\..\trunk\sources\bin\HeuristicLab.Common-3.3.dll</HintPath>
+    </Reference>
+    <Reference Include="HeuristicLab.Core-3.3">
+      <HintPath>..\..\..\..\trunk\sources\bin\HeuristicLab.Core-3.3.dll</HintPath>
+    </Reference>
+    <Reference Include="HeuristicLab.Core.Views-3.3">
+      <HintPath>..\..\..\..\trunk\sources\bin\HeuristicLab.Core.Views-3.3.dll</HintPath>
+    </Reference>
+    <Reference Include="HeuristicLab.Data.Views-3.3">
+      <HintPath>..\..\..\..\trunk\sources\bin\HeuristicLab.Data.Views-3.3.dll</HintPath>
+    </Reference>
+    <Reference Include="HeuristicLab.MainForm-3.3">
+      <HintPath>..\..\..\..\trunk\sources\bin\HeuristicLab.MainForm-3.3.dll</HintPath>
+    </Reference>
+    <Reference Include="HeuristicLab.MainForm.WindowsForms-3.3">
+      <HintPath>..\..\..\..\trunk\sources\bin\HeuristicLab.MainForm.WindowsForms-3.3.dll</HintPath>
+    </Reference>
+    <Reference Include="HeuristicLab.PluginInfrastructure-3.3">
+      <HintPath>..\..\..\..\trunk\sources\bin\HeuristicLab.PluginInfrastructure-3.3.dll</HintPath>
     </Reference>
     <Reference Include="HeuristicLab.Problems.Instances-3.3, Version=3.3.0.0, Culture=neutral, PublicKeyToken=ba48961d6f65dcec, processorArchitecture=MSIL">
@@ -177,4 +174,22 @@
   </ItemGroup>
   <ItemGroup>
+    <EmbeddedResource Include="PackingPlan2DView.resx">
+      <DependentUpon>PackingPlan2DView.cs</DependentUpon>
+    </EmbeddedResource>
+    <EmbeddedResource Include="PackingPlan3DView.resx">
+      <DependentUpon>PackingPlan3DView.cs</DependentUpon>
+    </EmbeddedResource>
+  </ItemGroup>
+  <ItemGroup>
+    <Page Include="Container3DView.xaml">
+      <Generator>MSBuild:Compile</Generator>
+      <SubType>Designer</SubType>
+    </Page>
+    <Page Include="Container2DView.xaml">
+      <Generator>MSBuild:Compile</Generator>
+      <SubType>Designer</SubType>
+    </Page>
+  </ItemGroup>
+  <ItemGroup>
     <ProjectReference Include="..\..\HeuristicLab.Problems.BinPacking.2D\3.3\HeuristicLab.Problems.BinPacking2D-3.3.csproj">
       <Project>{56dd7f51-3164-4c26-a97a-add6fe4b4e86}</Project>
@@ -186,26 +201,7 @@
     </ProjectReference>
     <ProjectReference Include="..\..\HeuristicLab.Problems.BinPacking\3.3\HeuristicLab.Problems.BinPacking-3.3.csproj">
-      <Project>{F8A55094-3CD5-4034-B0CA-5BD7FFB016D4}</Project>
+      <Project>{f8a55094-3cd5-4034-b0ca-5bd7ffb016d4}</Project>
       <Name>HeuristicLab.Problems.BinPacking-3.3</Name>
-      <Private>False</Private>
     </ProjectReference>
-  </ItemGroup>
-  <ItemGroup>
-    <EmbeddedResource Include="PackingPlan2DView.resx">
-      <DependentUpon>PackingPlan2DView.cs</DependentUpon>
-    </EmbeddedResource>
-    <EmbeddedResource Include="PackingPlan3DView.resx">
-      <DependentUpon>PackingPlan3DView.cs</DependentUpon>
-    </EmbeddedResource>
-  </ItemGroup>
-  <ItemGroup>
-    <Page Include="Container3DView.xaml">
-      <Generator>MSBuild:Compile</Generator>
-      <SubType>Designer</SubType>
-    </Page>
-    <Page Include="Container2DView.xaml">
-      <Generator>MSBuild:Compile</Generator>
-      <SubType>Designer</SubType>
-    </Page>
   </ItemGroup>
   <Import Project="$(MSBuildToolsPath)\Microsoft.CSharp.targets" />
Index: /branches/HeuristicLab.BinPacking/HeuristicLab.Problems.BinPacking/3.3/Analyzers/BestBinPackingSolutionAnalyzer.cs
===================================================================
--- /branches/HeuristicLab.BinPacking/HeuristicLab.Problems.BinPacking/3.3/Analyzers/BestBinPackingSolutionAnalyzer.cs	(revision 14127)
+++ /branches/HeuristicLab.BinPacking/HeuristicLab.Problems.BinPacking/3.3/Analyzers/BestBinPackingSolutionAnalyzer.cs	(revision 14128)
@@ -93,5 +93,5 @@
       }
       string binUtilKey = "Overall Bin Utilization";
-      DoubleValue binUtil = BinUtilizationEvaluator<D, B, I>.CalculateBinUtilization(bestSolution);
+      var binUtil = new DoubleValue(BinUtilizationEvaluator<D, B, I>.CalculateBinUtilization(bestSolution));
       if (!results.ContainsKey(binUtilKey))
         results.Add(new Result(binUtilKey, binUtil));
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 14127)
+++ /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 14127)
+++ /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 14127)
+++ /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 14127)
+++ /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 14127)
+++ /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 14127)
+++ /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 14127)
+++ /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 14127)
+++ /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 14127)
+++ /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 14127)
+++ /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 14127)
+++ /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 14127)
+++ /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 14127)
+++ /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 14127)
+++ /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 14127)
+++ /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 14127)
+++ /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 14127)
+++ /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 14127)
+++ /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 14127)
+++ /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 14127)
+++ /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 14127)
+++ /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 14127)
+++ /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 14127)
+++ /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 14127)
+++ /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 14127)
+++ /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 14127)
+++ /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."));
     }
Index: /branches/HeuristicLab.BinPacking/HeuristicLab.Problems.BinPacking/3.3/Evaluators/BinUtilizationEvaluator.cs
===================================================================
--- /branches/HeuristicLab.BinPacking/HeuristicLab.Problems.BinPacking/3.3/Evaluators/BinUtilizationEvaluator.cs	(revision 14127)
+++ /branches/HeuristicLab.BinPacking/HeuristicLab.Problems.BinPacking/3.3/Evaluators/BinUtilizationEvaluator.cs	(revision 14128)
@@ -42,5 +42,5 @@
     public BinUtilizationEvaluator() : base() { }
 
-    protected override DoubleValue Evaluate() {
+    protected override double Evaluate() {
       DoubleValue quality = new DoubleValue(0);
 
@@ -67,5 +67,5 @@
     }
 
-    public static DoubleValue CalculateBinUtilization(PackingPlan<D, B, I> plan) {
+    public static double CalculateBinUtilization(PackingPlan<D, B, I> plan) {
       int nrOfBins = plan.NrOfBins;
       double result = 0;
@@ -97,5 +97,5 @@
 
       result = totalUsedSpace / totalUsableSpace;
-      return new DoubleValue(result);
+      return result;
     }
   }
Index: /branches/HeuristicLab.BinPacking/HeuristicLab.Problems.BinPacking/3.3/Evaluators/EvaluatorBase.cs
===================================================================
--- /branches/HeuristicLab.BinPacking/HeuristicLab.Problems.BinPacking/3.3/Evaluators/EvaluatorBase.cs	(revision 14127)
+++ /branches/HeuristicLab.BinPacking/HeuristicLab.Problems.BinPacking/3.3/Evaluators/EvaluatorBase.cs	(revision 14128)
@@ -75,7 +75,7 @@
     }
 
-    protected abstract DoubleValue Evaluate();                                                                        
+    protected abstract double Evaluate();                                                                        
     public override IOperation Apply() {
-      QualityParameter.ActualValue = Evaluate();
+      QualityParameter.ActualValue = new DoubleValue(Evaluate());
       return base.Apply();
     }
Index: /branches/HeuristicLab.BinPacking/HeuristicLab.Problems.BinPacking/3.3/Evaluators/PackingRatioEvaluator.cs
===================================================================
--- /branches/HeuristicLab.BinPacking/HeuristicLab.Problems.BinPacking/3.3/Evaluators/PackingRatioEvaluator.cs	(revision 14127)
+++ /branches/HeuristicLab.BinPacking/HeuristicLab.Problems.BinPacking/3.3/Evaluators/PackingRatioEvaluator.cs	(revision 14128)
@@ -41,5 +41,5 @@
     public PackingRatioEvaluator() : base() { }
 
-    protected override DoubleValue Evaluate() {
+    protected override double Evaluate() {
       DoubleValue quality = new DoubleValue(0);
 
@@ -74,5 +74,5 @@
         k.......a constant, k>1.
      */
-    public static DoubleValue CalculatePackingRatio(PackingPlan<D, B, I> plan) {
+    public static double CalculatePackingRatio(PackingPlan<D, B, I> plan) {
       int nrOfBins = plan.NrOfBins;
       double result = 0;
@@ -90,10 +90,10 @@
         //k = 2 --> (Fi/C)*(Fi/C)
         //result += (((usedSpaceInThisBin) / (usableSpace)) * ((usedSpaceInThisBin) / (usableSpace))) / (i*i + 1);
-        var PD = plan.BinPackings[i].PackingDensity;
-        result += (PD * PD) / (i + 1);
+        var pd = plan.BinPackings[i].PackingDensity;
+        result += (pd * pd) / (i + 1);
       }
 
       result = result / nrOfBins;
-      return new DoubleValue(result);
+      return result;
     }
   }
Index: /branches/HeuristicLab.BinPacking/HeuristicLab.Problems.BinPacking/3.3/HeuristicLab.Problems.BinPacking-3.3.csproj
===================================================================
--- /branches/HeuristicLab.BinPacking/HeuristicLab.Problems.BinPacking/3.3/HeuristicLab.Problems.BinPacking-3.3.csproj	(revision 14127)
+++ /branches/HeuristicLab.BinPacking/HeuristicLab.Problems.BinPacking/3.3/HeuristicLab.Problems.BinPacking-3.3.csproj	(revision 14128)
@@ -160,93 +160,6 @@
     <Compile Include="Analyzers\BestBinPackingSolutionAnalyzer.cs" />
     <Compile Include="Analyzers\BinPackingAnalyzer.cs" />
-    <Compile Include="Encodings\GroupingVector\GroupingVectorSwap2Manipulator.cs" />
-    <Compile Include="Encodings\GroupingVector\GroupingVectorSinglePointCrossover.cs" />
-    <Compile Include="Encodings\GroupingVector\GroupingVectorDiscreteCrossover.cs" />
-    <Compile Include="Encodings\GroupingVector\Moves\GroupingMove.cs" />
-    <Compile Include="Encodings\GroupingVector\Moves\GroupingMoveAttribute.cs" />
-    <Compile Include="Encodings\GroupingVector\Moves\SwapGrouping\ExhaustiveSwapGroupingMoveGenerator.cs" />
-    <Compile Include="Encodings\GroupingVector\Moves\SwapGrouping\SwapGroupingMove.cs" />
-    <Compile Include="Encodings\GroupingVector\Moves\SwapGrouping\SwapGroupingMoveAttribute.cs" />
-    <Compile Include="Encodings\GroupingVector\Moves\SwapGrouping\SwapGroupingMoveGenerator.cs" />
-    <Compile Include="Encodings\GroupingVector\Moves\GroupingMoveMaker.cs" />
-    <Compile Include="Encodings\GroupingVector\Moves\GroupingTabuMaker.cs" />
-    <Compile Include="Encodings\GroupingVector\Moves\SwapGrouping\StochasticSwapGroupingMoveGenerator.cs" />
-    <Compile Include="Encodings\GroupingVector\Moves\GroupingMoveSoftTabuCriterion.cs" />
-    <Compile Include="Encodings\GroupingVector\Moves\ChangeGrouping\ExhaustiveChangeGroupingMoveGenerator.cs" />
-    <Compile Include="Encodings\GroupingVector\Moves\ChangeGrouping\ChangeGroupingMove.cs" />
-    <Compile Include="Encodings\GroupingVector\Moves\ChangeGrouping\ChangeGroupingMoveAttribute.cs" />
-    <Compile Include="Encodings\GroupingVector\Moves\ChangeGrouping\ChangeGroupingMoveGenerator.cs" />
-    <Compile Include="Encodings\GroupingVector\Moves\GroupingMoveHardTabuCriterion.cs" />
-    <Compile Include="Encodings\GroupingVector\Moves\ChangeGrouping\StochasticChangeGroupingMoveGenerator.cs" />
-    <Compile Include="Encodings\GroupingVector\GroupingVectorOnePositionManipulator.cs" />
-    <Compile Include="Encodings\GroupingVector\GroupingVectorCrossover.cs" />
-    <Compile Include="Encodings\GroupingVector\GroupingVectorEncoding.cs" />
-    <Compile Include="Encodings\GroupingVector\GroupingVectorManipulator.cs" />
-    <Compile Include="Encodings\GroupingVector\GroupingVectorRandomCreator.cs" />
-    <Compile Include="Encodings\MultiComponentVector\SequenceBasedMultiComponentVectorCrossover.cs" />
-    <Compile Include="Encodings\MultiComponentVector\BinBasedMultiComponentVectorCrossover.cs" />
-    <Compile Include="Encodings\MultiComponentVector\Moves\Multi\Attributes\ChangePositionMoveAttribute.cs" />
-    <Compile Include="Encodings\MultiComponentVector\Moves\Triple\Attributes\MCVTripleMoveAttribute.cs" />
-    <Compile Include="Encodings\MultiComponentVector\Moves\Multi\Attributes\SwapPositionMoveAttribute.cs" />
-    <Compile Include="Encodings\MultiComponentVector\Moves\Multi\Attributes\SingleGroupingMoveAttribute.cs" />
-    <Compile Include="Encodings\MultiComponentVector\Moves\MultiComponentVectorMoveAttribute.cs" />
-    <Compile Include="Encodings\MultiComponentVector\Moves\Multi\Attributes\SingleItemRotationMoveAttribute.cs" />
-    <Compile Include="Encodings\MultiComponentVector\Moves\Triple\StochasticMCVTripleMoveGenerator.cs" />
-    <Compile Include="Encodings\MultiComponentVector\Moves\Triple\ExhaustiveMCVTripleMoveGenerator.cs" />
-    <Compile Include="Encodings\MultiComponentVector\Moves\Multi\Moves\ChangePositionMove.cs" />
-    <Compile Include="Encodings\MultiComponentVector\Moves\Triple\Moves\MCVTripleMove.cs" />
-    <Compile Include="Encodings\MultiComponentVector\Moves\MultiComponentVectorMoveHardTabuCriterion.cs" />
-    <Compile Include="Encodings\MultiComponentVector\Moves\MultiComponentVectorMove.cs" />
-    <Compile Include="Encodings\MultiComponentVector\Moves\Multi\Moves\SwapPositionMove.cs" />
-    <Compile Include="Encodings\MultiComponentVector\Moves\Multi\Moves\SingleItemRotationMove.cs" />
-    <Compile Include="Encodings\MultiComponentVector\Moves\Multi\ExhaustiveMultiComponentVectorMoveGenerator.cs" />
-    <Compile Include="Encodings\MultiComponentVector\Moves\Multi\Moves\SingleGroupingMove.cs" />
-    <Compile Include="Encodings\MultiComponentVector\Moves\MultiComponentVectorMoveGenerator.cs" />
-    <Compile Include="Encodings\MultiComponentVector\Moves\MultiComponentVectorMoveSoftTabuCriterion.cs" />
-    <Compile Include="Encodings\MultiComponentVector\Moves\MultiComponentVectorMoveMaker.cs" />
-    <Compile Include="Encodings\MultiComponentVector\Moves\MultiComponentVectorTabuMaker.cs" />
-    <Compile Include="Encodings\MultiComponentVector\Moves\Multi\StochasticMultiComponentVectorMoveGenerator.cs" />
-    <Compile Include="Encodings\MultiComponentVector\MultiComponentVectorEncoding.cs">
-      <SubType>Code</SubType>
-    </Compile>
-    <Compile Include="Encodings\MultiComponentVector\MultiComponentVectorCrossover.cs" />
-    <Compile Include="Encodings\MultiComponentVector\MultiComponentVectorManipulator.cs" />
-    <Compile Include="Encodings\MultiComponentVector\MultiComponentVectorRandomCreator.cs" />
-    <Compile Include="Encodings\MultiComponentVector\ThreeWayMultiComponentVectorManipulator.cs" />
     <Compile Include="Encodings\PackingPlans\BinPacking.cs" />
     <Compile Include="Encodings\PackingPlans\PackingPlan.cs" />
-    <Compile Include="Encodings\PackingSequence\Encoding.cs" />
-    <Compile Include="Encodings\PackingSequence\IPackingSequenceCreator.cs" />
-    <Compile Include="Encodings\PackingSequence\Moves\Insertion\ExhaustiveInsertionMoveGenerator.cs" />
-    <Compile Include="Encodings\PackingSequence\Moves\Insertion\StochasticInsertionMoveGenerator.cs" />
-    <Compile Include="Encodings\PackingSequence\Moves\Insertion\InsertionMove.cs" />
-    <Compile Include="Encodings\PackingSequence\Moves\Insertion\InsertionMoveAttribute.cs" />
-    <Compile Include="Encodings\PackingSequence\Moves\Insertion\InsertionMoveGenerator.cs" />
-    <Compile Include="Encodings\PackingSequence\PackingSequence.cs" />
-    <Compile Include="Encodings\PackingSequence\PackingSequenceInversionManipulator.cs" />
-    <Compile Include="Encodings\PackingSequence\PackingSequencePartiallyMatchedCrossover.cs" />
-    <Compile Include="Encodings\PackingSequence\PackingSequenceOrderCrossover.cs" />
-    <Compile Include="Encodings\PackingSequence\Moves\SequenceMove.cs" />
-    <Compile Include="Encodings\PackingSequence\Moves\SequenceMoveAttribute.cs" />
-    <Compile Include="Encodings\PackingSequence\Moves\GroupingMoveHardTabuCriterion.cs" />
-    <Compile Include="Encodings\PackingSequence\Moves\GroupingMoveMaker.cs" />
-    <Compile Include="Encodings\PackingSequence\Moves\GroupingMoveSoftTabuCriterion.cs" />
-    <Compile Include="Encodings\PackingSequence\Moves\SequenceTabuMaker.cs" />
-    <Compile Include="Encodings\PackingSequence\Moves\Swap2\ExhaustiveSwap2MoveGenerator.cs" />
-    <Compile Include="Encodings\PackingSequence\Moves\Swap2\StochasticSwap2MoveGenerator.cs" />
-    <Compile Include="Encodings\PackingSequence\Moves\Swap2\Swap2Move.cs" />
-    <Compile Include="Encodings\PackingSequence\Moves\Swap2\Swap2MoveAttribute.cs" />
-    <Compile Include="Encodings\PackingSequence\Moves\Swap2\Swap2MoveGenerator.cs" />
-    <Compile Include="Encodings\PackingSequence\PackingSequenceCrossover.cs">
-      <SubType>Code</SubType>
-    </Compile>
-    <Compile Include="Encodings\PackingSequence\PackingSequenceEncoding.cs">
-      <SubType>Code</SubType>
-    </Compile>
-    <Compile Include="Encodings\PackingSequence\PackingSequenceManipulator.cs">
-      <SubType>Code</SubType>
-    </Compile>
-    <Compile Include="Encodings\PackingSequence\PackingSequenceRandomCreator.cs" />
-    <Compile Include="Encodings\PackingSequence\PackingSequenceScrambleManipulator.cs" />
     <Compile Include="Encodings\PackingSolutionCreator.cs" />
     <Compile Include="Encodings\PackingSolutionCrossover.cs" />
@@ -282,5 +195,4 @@
     <Compile Include="Plugin.cs" />
     <Compile Include="PackingSequenceProblem.cs" />
-    <Compile Include="Problem.cs" />
     <Compile Include="Properties\AssemblyInfo.cs" />
   </ItemGroup>
Index: /branches/HeuristicLab.BinPacking/HeuristicLab.Problems.BinPacking/3.3/Interfaces/IPackingMove.cs
===================================================================
--- /branches/HeuristicLab.BinPacking/HeuristicLab.Problems.BinPacking/3.3/Interfaces/IPackingMove.cs	(revision 14127)
+++ /branches/HeuristicLab.BinPacking/HeuristicLab.Problems.BinPacking/3.3/Interfaces/IPackingMove.cs	(revision 14128)
@@ -23,6 +23,6 @@
 
 namespace HeuristicLab.Problems.BinPacking  {
-  public interface IPackingMove : IItem {
-    IPackingSolutionEncoding GetSolutionAfterMove();
+  public interface IPackingMove<out T> : IItem {
+    T GetSolutionAfterMove();
   }
 }
Index: /branches/HeuristicLab.BinPacking/HeuristicLab.Problems.BinPacking/3.3/Interfaces/IPackingSolutionCreator.cs
===================================================================
--- /branches/HeuristicLab.BinPacking/HeuristicLab.Problems.BinPacking/3.3/Interfaces/IPackingSolutionCreator.cs	(revision 14127)
+++ /branches/HeuristicLab.BinPacking/HeuristicLab.Problems.BinPacking/3.3/Interfaces/IPackingSolutionCreator.cs	(revision 14128)
@@ -24,5 +24,5 @@
 
 namespace HeuristicLab.Problems.BinPacking {
-  public interface IPackingSolutionCreator : ISolutionCreator{
+  public interface IPackingSolutionCreator : ISolutionCreator {
     ILookupParameter<IItem> EncodedSolutionParameter { get; }
   }
Index: /branches/HeuristicLab.BinPacking/HeuristicLab.Problems.BinPacking/3.3/Interfaces/IPackingSolutionCrossover.cs
===================================================================
--- /branches/HeuristicLab.BinPacking/HeuristicLab.Problems.BinPacking/3.3/Interfaces/IPackingSolutionCrossover.cs	(revision 14127)
+++ /branches/HeuristicLab.BinPacking/HeuristicLab.Problems.BinPacking/3.3/Interfaces/IPackingSolutionCrossover.cs	(revision 14128)
@@ -25,7 +25,8 @@
 
 namespace HeuristicLab.Problems.BinPacking {
-  public interface IPackingSolutionCrossover : ICrossover, IPackingOperator {
-    ILookupParameter<IPackingSolutionEncoding> ChildParameter { get; }
-    IScopeTreeLookupParameter<IPackingSolutionEncoding> ParentsParameter { get; }
+  public interface IPackingSolutionCrossover<T> : ICrossover, IPackingOperator
+  where T : class, IItem {
+    ILookupParameter<T> ChildParameter { get; }
+    IScopeTreeLookupParameter<T> ParentsParameter { get; }
   }
 }
Index: /branches/HeuristicLab.BinPacking/HeuristicLab.Problems.BinPacking/3.3/Interfaces/IPackingSolutionManipulator.cs
===================================================================
--- /branches/HeuristicLab.BinPacking/HeuristicLab.Problems.BinPacking/3.3/Interfaces/IPackingSolutionManipulator.cs	(revision 14127)
+++ /branches/HeuristicLab.BinPacking/HeuristicLab.Problems.BinPacking/3.3/Interfaces/IPackingSolutionManipulator.cs	(revision 14128)
@@ -24,6 +24,7 @@
 
 namespace HeuristicLab.Problems.BinPacking {
-  public interface IPackingSolutionManipulator : IManipulator, IPackingOperator {
-    ILookupParameter<IPackingSolutionEncoding> EncodedSolutionParameter { get; }
+  public interface IPackingSolutionManipulator<T> : IManipulator, IPackingOperator
+  where T : class, IItem {
+    ILookupParameter<T> EncodedSolutionParameter { get; }
   }
 }
Index: /branches/HeuristicLab.BinPacking/HeuristicLab.Problems.BinPacking/3.3/PackingMoveEvaluator.cs
===================================================================
--- /branches/HeuristicLab.BinPacking/HeuristicLab.Problems.BinPacking/3.3/PackingMoveEvaluator.cs	(revision 14127)
+++ /branches/HeuristicLab.BinPacking/HeuristicLab.Problems.BinPacking/3.3/PackingMoveEvaluator.cs	(revision 14128)
@@ -24,4 +24,5 @@
 using HeuristicLab.Data;
 using HeuristicLab.Encodings.PackingEncoding;
+using HeuristicLab.Encodings.PermutationEncoding;
 using HeuristicLab.Operators;
 using HeuristicLab.Optimization;
@@ -32,8 +33,9 @@
   [Item("PackingMoveEvaluator", "A base class for operators which evaluate Packing-Solution moves.")]
   [StorableClass]
-  public abstract class PackingMoveEvaluator<D, B, I> : SingleSuccessorOperator, IPackingMoveEvaluator, IMoveOperator
+  public abstract class PackingMoveEvaluator<D, B, I, M> : SingleSuccessorOperator, IPackingMoveEvaluator
     where D : class, IPackingPosition
     where B : PackingShape<D>
-    where I : PackingShape<D>, IPackingItem {     
+    where I : PackingShape<D>, IPackingItem 
+    where M : IItem {     
     public override bool CanChangeName {
       get { return false; }
@@ -61,11 +63,11 @@
       get { return (ScopeParameter)Parameters["CurrentScope"]; }
     }
-    public ILookupParameter<IPackingMove> PackingMoveParameter {
-      get { return (ILookupParameter<IPackingMove>)Parameters["PackingMove"]; }
+    public ILookupParameter<IPackingMove<M>> PackingMoveParameter {
+      get { return (ILookupParameter<IPackingMove<M>>)Parameters["PackingMove"]; }
     }  
     
     [StorableConstructor]
     protected PackingMoveEvaluator(bool deserializing) : base(deserializing) { }
-    protected PackingMoveEvaluator(PackingMoveEvaluator<D, B, I> original, Cloner cloner) : base(original, cloner) { }
+    protected PackingMoveEvaluator(PackingMoveEvaluator<D, B, I, M> original, Cloner cloner) : base(original, cloner) { }
     protected PackingMoveEvaluator()
       : base() {
@@ -77,5 +79,5 @@
       Parameters.Add(new ValueLookupParameter<IEvaluator>("PackingPlanEvaluator", "The actual packing plan evaluation operator."));
       Parameters.Add(new ScopeParameter("CurrentScope", "The current scope where the decoded solution should be added to."));
-      Parameters.Add(new LookupParameter<IPackingMove>("PackingMove", "The move to evaluate."));
+      Parameters.Add(new LookupParameter<IPackingMove<M>>("PackingMove", "The move to evaluate."));
     }
 
@@ -83,6 +85,6 @@
 
     public override IOperation Apply() {
-      IPackingMove move = PackingMoveParameter.ActualValue;
-      IPackingSolutionEncoding newSolution = move.GetSolutionAfterMove();
+      IPackingMove<M> move = PackingMoveParameter.ActualValue;
+      var newSolution = move.GetSolutionAfterMove();
       CurrentScopeParameter.ActualValue.Variables.Add(new Variable("MovedSolution", newSolution));
 
@@ -93,7 +95,7 @@
       CurrentScopeParameter.ActualValue.Variables.Add(new Variable("PackingPlanAfterMove", packingPlan));
 
-      DoubleValue quality = PackingRatioEvaluator<D, B, I>.CalculatePackingRatio(packingPlan);
+      var quality = PackingRatioEvaluator<D, B, I>.CalculatePackingRatio(packingPlan);
 
-      double moveQuality = quality.Value;
+      double moveQuality = quality;
 
       if (MoveQualityParameter.ActualValue == null) MoveQualityParameter.ActualValue = new DoubleValue(moveQuality);
Index: /branches/HeuristicLab.BinPacking/HeuristicLab.Problems.BinPacking/3.3/PackingSequenceProblem.cs
===================================================================
--- /branches/HeuristicLab.BinPacking/HeuristicLab.Problems.BinPacking/3.3/PackingSequenceProblem.cs	(revision 14127)
+++ /branches/HeuristicLab.BinPacking/HeuristicLab.Problems.BinPacking/3.3/PackingSequenceProblem.cs	(revision 14128)
@@ -23,15 +23,20 @@
 
 using System;
+using System.CodeDom;
 using System.Linq;
+using System.Text;
 using HeuristicLab.Common;
 using HeuristicLab.Core;
 using HeuristicLab.Data;
-using HeuristicLab.Encodings.PackingEncoding.PackingSequence;
+using HeuristicLab.Encodings.PermutationEncoding;
 using HeuristicLab.Optimization;
 using HeuristicLab.Persistence.Default.CompositeSerializers.Storable;
+using HeuristicLab.Problems.BinPacking;
 
-namespace HeuristicLab.Problems.BinPacking2d {
+namespace HeuristicLab.Problems.BinPacking {
   [StorableClass]
-  abstract class PackingSequenceProblem : SingleObjectiveBasicProblem<Encoding> {
+  public abstract class PackingSequenceProblem<TSolution, TEncoding> : SingleObjectiveBasicProblem<TEncoding>
+    where TSolution : class, IItem
+    where TEncoding : class, IEncoding {
 
     // persistence
@@ -43,5 +48,5 @@
 
     // cloning
-    protected PackingSequenceProblem(PackingSequenceProblem original, Cloner cloner)
+    protected PackingSequenceProblem(PackingSequenceProblem<TSolution, TEncoding> original, Cloner cloner)
       : base(original, cloner) {
     }
@@ -53,10 +58,5 @@
     }
 
-    public sealed override double Evaluate(Individual individual, IRandom random) {
-      return Evaluate(individual.PackingSequence(), random);
-    }
-    public abstract double Evaluate(PackingSequence sequence, IRandom random);
-
-    public virtual void Analyze(PackingSequence[] trees, double[] qualities, ResultCollection results,
+    public virtual void Analyze(TSolution[] solutions, double[] qualities, ResultCollection results,
       IRandom random) {
       if (!results.ContainsKey("Best Solution Quality")) {
@@ -64,5 +64,5 @@
       }
       if (!results.ContainsKey("Best Solution")) {
-        results.Add(new Result("Best Solution", typeof(PackingSequence)));
+        results.Add(new Result("Best Solution", typeof(TSolution)));
       }
 
@@ -72,13 +72,9 @@
           IsBetter(bestQuality, ((DoubleValue)results["Best Solution Quality"].Value).Value)) {
         var bestIdx = Array.IndexOf(qualities, bestQuality);
-        var bestClone = (IItem)trees[bestIdx].Clone();
+        var bestClone = (IItem)solutions[bestIdx].Clone();
         results["Best Solution"].Value = bestClone;
         results["Best Solution Quality"].Value = new DoubleValue(bestQuality);
       }
     }
-
-    public sealed override void Analyze(Individual[] individuals, double[] qualities, ResultCollection results, IRandom random) {
-      Analyze(individuals.Select(ind => ind.PackingSequence()).ToArray(), qualities, results, random);
-    }
   }
 }
Index: /branches/HeuristicLab.BinPacking/HeuristicLab.Problems.BinPacking/3.3/Problem.cs
===================================================================
--- /branches/HeuristicLab.BinPacking/HeuristicLab.Problems.BinPacking/3.3/Problem.cs	(revision 14127)
+++ /branches/HeuristicLab.BinPacking/HeuristicLab.Problems.BinPacking/3.3/Problem.cs	(revision 14128)
@@ -26,10 +26,7 @@
 using HeuristicLab.Parameters;
 using HeuristicLab.Data;
-using HeuristicLab.Encodings.PackingEncoding.MultiComponentVector;
 using HeuristicLab.PluginInfrastructure;
 using System.Linq;
 using System;
-using HeuristicLab.Encodings.PackingEncoding.PackingSequence;
-using HeuristicLab.Encodings.PackingEncoding.GroupingVector;
 using HeuristicLab.Encodings.PackingEncoding;
 
@@ -97,7 +94,8 @@
     }
 
-    protected Problem(IDecodingEvaluator e) : this(e, new MultiComponentVectorRandomCreator()) { }
-
-    protected Problem(IDecodingEvaluator e, IPackingSolutionCreator c) : base(e, c) {
+    protected Problem(IDecodingEvaluator e) : this(e, new PackingSequenceRandomCreator()) { }
+
+    protected Problem(IDecodingEvaluator e, IPackingSolutionCreator c)
+      : base(e, c) {
       Parameters.Add(new OptionalValueParameter<PackingPlan<D, B, I>>("BestKnownSolution", "The best known solution of this bin-packing instance."));
       Parameters.Add(new ValueParameter<ItemList<I>>("PackingItemMeasures", "Packing-item data defining the measures of the different items that need to be packed.", new ItemList<I>()));
@@ -109,5 +107,5 @@
       Parameters.Add(new ConstrainedValueParameter<IPackingSolutionDecoder>("PackingSolutionDecoder", "The operator that decodes the representation and creates a packing plan."));
       this.Maximization.Value = true;
-      InitializeProblemInstance();
+      InitializeProblemInstance(); // TODO
       InitializeOperators();
       InitializeEventHandlers();
@@ -163,5 +161,5 @@
         Operators.AddRange(ApplicationManager.Manager.GetInstances<IPackingSequenceOperator>());
         InitializeDecoder();
-      } else if (SolutionCreator.GetType() == typeof(GroupingVectorRandomCreator)) {
+      } /* else if (SolutionCreator.GetType() == typeof(GroupingVectorRandomCreator)) {
         Operators.AddRange(ApplicationManager.Manager.GetInstances<IGroupingVectorOperator>());
         InitializeDecoder();
@@ -169,5 +167,5 @@
         Operators.AddRange(ApplicationManager.Manager.GetInstances<IMultiComponentVectorOperator>());
         InitializeDecoder();
-      }
+      } */
     }
     private void ParameterizeOperators() {
@@ -193,4 +191,5 @@
         PackingPlanEvaluator.PackingPlanParameter.Hidden = false;
       }
+      /*
 
       foreach (var op in Operators.OfType<IPackingSolutionManipulator>()) {
@@ -205,5 +204,5 @@
         op.ParentsParameter.Hidden = true;
       }
-
+      */
       foreach (var op in Operators.OfType<BestBinPackingSolutionAnalyzer<D, B, I>>()) {
         op.QualityParameter.ActualName = PackingPlanEvaluator.QualityParameter.ActualName;
