Index: branches/HeuristicLab.BinPacking/HeuristicLab.Problems.BinPacking/3.3/Decoders/3D/EP/ExtremePointGroupingVectorDecoder3D.cs
===================================================================
--- branches/HeuristicLab.BinPacking/HeuristicLab.Problems.BinPacking/3.3/Decoders/3D/EP/ExtremePointGroupingVectorDecoder3D.cs	(revision 9473)
+++ branches/HeuristicLab.BinPacking/HeuristicLab.Problems.BinPacking/3.3/Decoders/3D/EP/ExtremePointGroupingVectorDecoder3D.cs	(revision 9495)
@@ -41,9 +41,8 @@
   [Item("Identical bin, three dimensional, extreme points based decoder for the GroupingVector encoding.", "<Description missing...>")]
   [StorableClass]
-  public class ExtremePointGroupingVectorDecoder3D : IdenticalBinPackingSolutionDecoder<
+  public class ExtremePointGroupingVectorDecoder3D : PackingSolutionDecoder<
       ThreeDimensionalPacking,
       CuboidPackingBin,
-      CuboidPackingItem,
-      PackingPlan<ThreeDimensionalPacking, CuboidPackingBin, CuboidPackingItem>> {
+      CuboidPackingItem> {
 
     public ExtremePointGroupingVectorDecoder3D ()
@@ -68,10 +67,10 @@
     }
 
-    protected override PackingPlan<ThreeDimensionalPacking, CuboidPackingBin, CuboidPackingItem> CreatePackingPlanFromEncoding(IPackingSolutionEncoding encodedSolution) {
+    public override PackingPlan<ThreeDimensionalPacking, CuboidPackingBin, CuboidPackingItem> CreatePackingPlanFromEncoding(IPackingSolutionEncoding encodedSolution, CuboidPackingBin binMeasures, ItemList<CuboidPackingItem> itemMeasures) {
                       
       var solution = encodedSolution as GroupingVectorEncoding;
       if (solution == null) throw new InvalidOperationException("Encoding is not of type GroupingVector");
 
-      return Decode(solution, PackingBinMeasuresParameter.ActualValue, PackingItemMeasuresParameter.ActualValue);
+      return Decode(solution, binMeasures, itemMeasures);
     }
   }
Index: branches/HeuristicLab.BinPacking/HeuristicLab.Problems.BinPacking/3.3/Decoders/3D/EP/ExtremePointMultiComponentVectorDecoder3D.cs
===================================================================
--- branches/HeuristicLab.BinPacking/HeuristicLab.Problems.BinPacking/3.3/Decoders/3D/EP/ExtremePointMultiComponentVectorDecoder3D.cs	(revision 9473)
+++ branches/HeuristicLab.BinPacking/HeuristicLab.Problems.BinPacking/3.3/Decoders/3D/EP/ExtremePointMultiComponentVectorDecoder3D.cs	(revision 9495)
@@ -42,9 +42,8 @@
   [Item("Identical bin, three dimensional, extreme points based decoder for the MultiComponentVector encoding.", "<Description missing...>")]
   [StorableClass]
-  public class ExtremePointMultiComponentVectorDecoder3D : IdenticalBinPackingSolutionDecoder<
+  public class ExtremePointMultiComponentVectorDecoder3D : PackingSolutionDecoder<
       ThreeDimensionalPacking,
       CuboidPackingBin,
-      CuboidPackingItem,
-      PackingPlan<ThreeDimensionalPacking, CuboidPackingBin, CuboidPackingItem>> {
+      CuboidPackingItem> {
 
     public ExtremePointMultiComponentVectorDecoder3D ()
@@ -69,10 +68,10 @@
     }
 
-    protected override PackingPlan<ThreeDimensionalPacking, CuboidPackingBin, CuboidPackingItem> CreatePackingPlanFromEncoding(IPackingSolutionEncoding encodedSolution) {
+    public override PackingPlan<ThreeDimensionalPacking, CuboidPackingBin, CuboidPackingItem> CreatePackingPlanFromEncoding(IPackingSolutionEncoding encodedSolution, CuboidPackingBin binMeasures, ItemList<CuboidPackingItem> itemMeasures) {
 
       var solution = encodedSolution as MultiComponentVectorEncoding;
       if (solution == null) throw new InvalidOperationException("Encoding is not of type MultiComponentVector");
 
-      return Decode(solution, PackingBinMeasuresParameter.ActualValue, PackingItemMeasuresParameter.ActualValue);
+      return Decode(solution, binMeasures, itemMeasures);
     }
   }
Index: branches/HeuristicLab.BinPacking/HeuristicLab.Problems.BinPacking/3.3/Decoders/3D/EP/ExtremePointPackingSequenceDecoder3D.cs
===================================================================
--- branches/HeuristicLab.BinPacking/HeuristicLab.Problems.BinPacking/3.3/Decoders/3D/EP/ExtremePointPackingSequenceDecoder3D.cs	(revision 9473)
+++ branches/HeuristicLab.BinPacking/HeuristicLab.Problems.BinPacking/3.3/Decoders/3D/EP/ExtremePointPackingSequenceDecoder3D.cs	(revision 9495)
@@ -40,9 +40,8 @@
   [Item("Identical bin, three dimensional, extreme points based decoder for the PackingSequence encoding.", "<Description missing...>")]
   [StorableClass]
-  public class ExtremePointPackingSequenceDecoder3D : IdenticalBinPackingSolutionDecoder<
+  public class ExtremePointPackingSequenceDecoder3D : PackingSolutionDecoder<
       ThreeDimensionalPacking,
       CuboidPackingBin,
-      CuboidPackingItem,
-      PackingPlan<ThreeDimensionalPacking, CuboidPackingBin, CuboidPackingItem>> {
+      CuboidPackingItem> {
 
     public ExtremePointPackingSequenceDecoder3D ()
@@ -59,5 +58,5 @@
 
 
-    protected override PackingPlan<ThreeDimensionalPacking, CuboidPackingBin, CuboidPackingItem> CreatePackingPlanFromEncoding(IPackingSolutionEncoding encodedSolution) {
+    public override PackingPlan<ThreeDimensionalPacking, CuboidPackingBin, CuboidPackingItem> CreatePackingPlanFromEncoding(IPackingSolutionEncoding encodedSolution, CuboidPackingBin binMeasures, ItemList<CuboidPackingItem> itemMeasures) {
 
       var solution = encodedSolution as PackingSequenceEncoding;
Index: branches/HeuristicLab.BinPacking/HeuristicLab.Problems.BinPacking/3.3/Decoders/3D/EP/ExtremePointsFunctions3D.cs
===================================================================
--- branches/HeuristicLab.BinPacking/HeuristicLab.Problems.BinPacking/3.3/Decoders/3D/EP/ExtremePointsFunctions3D.cs	(revision 9473)
+++ branches/HeuristicLab.BinPacking/HeuristicLab.Problems.BinPacking/3.3/Decoders/3D/EP/ExtremePointsFunctions3D.cs	(revision 9495)
@@ -9,5 +9,4 @@
 using HeuristicLab.Encodings.PackingEncoding.MultiComponentVector;
 using HeuristicLab.Encodings.PackingEncoding.PackingSequence;
-using HeuristicLab.Encodings.PackingEncoding.Potvin;
 using HeuristicLab.Problems.BinPacking.Dimensions;
 using HeuristicLab.Problems.BinPacking.Interfaces;
@@ -20,153 +19,9 @@
 
 
-
-    public static ObservableDictionary<int, ThreeDimensionalPacking> ExtremePointBasedPacking(ref PotvinEncoding solution, 
-      ItemList<CuboidPackingItem> itemMeasures, CuboidPackingBin binMeasures) {
-        if (!solution.DelimiterInitialized) {
-          #region Preperations
-          var itemPositions = new ObservableDictionary<int, ThreeDimensionalPacking>();
-          int nrOfBins = 1;
-
-          var occupiedPoints = new List<int[, ,]>();
-          occupiedPoints = IncreaseBinCountForOccupiedPoints(occupiedPoints, binMeasures);
-
-          HashSet<ThreeDimensionalPacking> extremePoints = new HashSet<ThreeDimensionalPacking>();
-          extremePoints.Add(new ThreeDimensionalPacking(0, 0, 0, 0, false));
-          #endregion
-
-          Dictionary<int, List<int>> itemIndexesForBin = new Dictionary<int, List<int>>();
-          itemIndexesForBin[0] = new List<int>();
-
-          foreach (int itemIndex in solution.IntVector) {
-            var item = itemMeasures[itemIndex];
-            extremePoints = OrderExtremePoints(extremePoints, occupiedPoints, binMeasures);
-            var positionFound = FindExtremePointForItem(itemIndex, itemMeasures, binMeasures, extremePoints, occupiedPoints, itemPositions);
-            if (positionFound != null) {
-              extremePoints.Remove(positionFound);
-            } else {
-              positionFound = new ThreeDimensionalPacking(nrOfBins, 0, 0, 0);
-              occupiedPoints = IncreaseBinCountForOccupiedPoints(occupiedPoints, binMeasures);
-              itemIndexesForBin[nrOfBins] = new List<int>();
-              nrOfBins++;
-            }
-            itemPositions[itemIndex] = positionFound;
-            itemIndexesForBin[positionFound.AssignedBin].Add(itemIndex);
-            occupiedPoints = OccupyPointsForNewItem(occupiedPoints, item, positionFound, itemIndex);
-            extremePoints = GenerateNewExtremePointsForNewItem(extremePoints, occupiedPoints, item, positionFound, binMeasures);
-          }
-          List<int> intVector = new List<int>();
-          foreach (var indexes in itemIndexesForBin) {
-            foreach (var index in indexes.Value) {
-              intVector.Add(index);
-            }
-            intVector.Add(-1);
-          }
-          intVector.RemoveAt(intVector.Count - 1);
-          solution.IntVector = new IntegerVector (intVector.ToArray());
-
-          return itemPositions;
-        } else {
-          #region Preperations
-          int nrOfBins = solution.IntVector.Count(i => i.Equals (-1)) + 1;
-
-          //Get all indexes of items for every bin according to int vector
-          Dictionary<int, List<int>> unpackedItemIndexesPerBin = new Dictionary<int, List<int>>();
-          Dictionary<int, HashSet<ThreeDimensionalPacking>> extremePointsForBin = new Dictionary<int, HashSet<ThreeDimensionalPacking>>();
-          var occupiedPoints = new List<int[, ,]>();
-
-          int binCounter = 0;
-          unpackedItemIndexesPerBin[binCounter] = new List<int>();
-          for (int i = 0; i < solution.IntVector.Length; i++) {
-            if (solution.IntVector[i].Equals(-1)) {
-              unpackedItemIndexesPerBin[binCounter++] = new List<int>();
-              extremePointsForBin[i] = new HashSet<ThreeDimensionalPacking>();
-              extremePointsForBin[i].Add(new ThreeDimensionalPacking(i, 0, 0, 0, false));
-              occupiedPoints = IncreaseBinCountForOccupiedPoints(occupiedPoints, binMeasures);
-            } else {
-              unpackedItemIndexesPerBin[binCounter].Add(solution.IntVector[i]);
-            }
-
-          }
-
-
-          ObservableDictionary<int, ThreeDimensionalPacking> itemPositions = new ObservableDictionary<int, ThreeDimensionalPacking>();
-          var remainingItems = new List<int>();
-
-          #endregion Preperations
-
-
-
-          //Iterate over all bin-lists
-          for (int binNr = 0; binNr < nrOfBins; binNr++) {
-            //Iterate over the current bin-item-list and find feasible positions in the current bin for each item
-            var unpackedItems = unpackedItemIndexesPerBin[binNr];
-            for (int i = 0; i < unpackedItems.Count; i++) {
-              var itemIndex = unpackedItems[i];
-              var item = itemMeasures[itemIndex];
-
-              extremePointsForBin[binNr] = OrderExtremePoints(extremePointsForBin[binNr], occupiedPoints, binMeasures);
-              var positionFound = FindExtremePointForItem(itemIndex, itemMeasures, binMeasures, extremePointsForBin[binNr], occupiedPoints, itemPositions);
-              if (positionFound != null) {
-                extremePointsForBin[binNr].Remove(positionFound);
-                itemPositions[itemIndex] = positionFound;
-                occupiedPoints = OccupyPointsForNewItem(occupiedPoints, item, positionFound, itemIndex);
-                extremePointsForBin[binNr] = GenerateNewExtremePointsForNewItem(extremePointsForBin[binNr], occupiedPoints, item, positionFound, binMeasures);
-              } else
-                remainingItems.Add(itemIndex);
-            }
-          }
-
-
-
-          //Packing of remaining items    
-          //Iterate over all bin-lists
-          for (int binNr = 0; binNr < nrOfBins && remainingItems.Count > 0; binNr++) {
-            var unpackedItems = new List<int>(remainingItems);
-            //Iterate over all the remaining items
-            for (int i = 0; i < unpackedItems.Count; i++) {
-              var itemIndex = unpackedItems[i];
-              var item = itemMeasures[itemIndex];
-
-              extremePointsForBin[binNr] = OrderExtremePoints(extremePointsForBin[binNr], occupiedPoints, binMeasures);
-              var positionFound = FindExtremePointForItem(itemIndex, itemMeasures, binMeasures, extremePointsForBin[binNr], occupiedPoints, itemPositions);
-              if (positionFound != null) {
-                extremePointsForBin[binNr].Remove(positionFound);
-                InsertItemgeneAfterLastItemgeneOfUsedBin(ref solution, itemIndex, binNr);
-                itemPositions[itemIndex] = positionFound;
-                occupiedPoints = OccupyPointsForNewItem(occupiedPoints, item, positionFound, itemIndex);
-                extremePointsForBin[binNr] = GenerateNewExtremePointsForNewItem(extremePointsForBin[binNr], occupiedPoints, item, positionFound, binMeasures);
-                remainingItems.Remove(itemIndex);
-              }
-            }
-            if (remainingItems.Count > 0 && binNr + 1 >= nrOfBins) {
-              extremePointsForBin[nrOfBins] = new HashSet<ThreeDimensionalPacking>();
-              extremePointsForBin[nrOfBins].Add(new ThreeDimensionalPacking(nrOfBins, 0, 0, 0, false));
-              occupiedPoints = IncreaseBinCountForOccupiedPoints(occupiedPoints, binMeasures);
-              nrOfBins++;
-            }
-          }
-
-          return itemPositions;
-        }
-    }
-    private static void InsertItemgeneAfterLastItemgeneOfUsedBin(ref PotvinEncoding solution, int itemIndex, int binNr) { 
-      List<int> temp = new List<int> (solution.IntVector);
-      temp.Remove(itemIndex);
-      var delimiterIndexes = temp.Select((value, index) => value == -1).Select((value, index) => index);
-      int insertionIndex = temp.Count; 
-      if (binNr < delimiterIndexes.Count()) {
-        insertionIndex = delimiterIndexes.ElementAt(binNr);
-      }
-      temp.Insert(insertionIndex, itemIndex);
-      solution.IntVector = new IntegerVector (temp.ToArray());
-    }
-
-
     public static ObservableDictionary<int, ThreeDimensionalPacking> ExtremePointBasedPacking(ref MultiComponentVectorEncoding solution, 
         ItemList<CuboidPackingItem> itemMeasures, CuboidPackingBin binMeasures) {
 
       #region Preperations
-      int lowerBound = solution.PackingInformations.Max(x => x.AssignedBin);
-      int nrOfBins = lowerBound + 1;
+      int nrOfBins = solution.NrOfBins;
 
       //Get all indexes of items for every bin according to grouping-vector                      
@@ -176,7 +31,5 @@
 
       for (int i = 0; i < nrOfBins; i++) {        
-        unpackedItemIndexesPerBin[i] = solution.PackingInformations
-          .Where(pi => pi.AssignedBin == i)
-          .ToList();
+        unpackedItemIndexesPerBin[i] = new List<PackingInformation> (solution.PackingInformations[i]);
 
         extremePointsForBin[i] = new HashSet<ThreeDimensionalPacking>();
@@ -196,5 +49,5 @@
         var unpackedItems = unpackedItemIndexesPerBin[binNr];
         for (int i = 0; i < unpackedItems.Count; i++) {
-          var itemIndex = unpackedItems[i].ItemIndex;
+          var itemIndex = unpackedItems[i].ItemID;
           var item = itemMeasures[itemIndex];
 
@@ -206,6 +59,8 @@
             occupiedPoints = OccupyPointsForNewItem(occupiedPoints, item, positionFound, itemIndex);
             extremePointsForBin[binNr] = GenerateNewExtremePointsForNewItem(extremePointsForBin[binNr], occupiedPoints, item, positionFound, binMeasures);
-          } else
+          } else {
             remainingItems.Add(unpackedItems[i]);
+            solution.PackingInformations[binNr].Remove(unpackedItems[i]);
+          }
         }
       }
@@ -218,5 +73,5 @@
         //Iterate over all the remaining items
         for (int i = 0; i < unpackedItems.Count; i++) {
-          var itemIndex = unpackedItems[i].ItemIndex;
+          var itemIndex = unpackedItems[i].ItemID;
           var item = itemMeasures[itemIndex];
 
@@ -227,9 +82,7 @@
             itemPositions[itemIndex] = positionFound;
             occupiedPoints = OccupyPointsForNewItem(occupiedPoints, item, positionFound, itemIndex);
-            extremePointsForBin[binNr] = GenerateNewExtremePointsForNewItem(extremePointsForBin[binNr], occupiedPoints, item, positionFound, binMeasures);
+            extremePointsForBin[binNr] = GenerateNewExtremePointsForNewItem(extremePointsForBin[binNr], occupiedPoints, item, positionFound, binMeasures);      
             remainingItems.Remove(unpackedItems[i]);
-            if (binNr <= lowerBound) {
-              InsertItemgeneAfterLastItemgeneOfUsedBin(ref solution, itemIndex, binNr);
-            }
+            solution.PackingInformations[binNr].Add(unpackedItems[i]);
           }
         }
@@ -238,4 +91,5 @@
           extremePointsForBin[nrOfBins].Add(new ThreeDimensionalPacking(nrOfBins, 0, 0, 0, false));
           occupiedPoints = IncreaseBinCountForOccupiedPoints(occupiedPoints, binMeasures);
+          solution.PackingInformations[nrOfBins] = new ItemList<PackingInformation>();
           nrOfBins++;
         }
@@ -243,11 +97,4 @@
 
       return itemPositions;
-    }
-    private static void InsertItemgeneAfterLastItemgeneOfUsedBin(ref MultiComponentVectorEncoding solution, int itemIndex, int binNr) {
-      var itemgene = solution.PackingInformations.Find(pi => pi.ItemIndex == itemIndex);
-      solution.PackingInformations.Remove (itemgene);
-      itemgene.AssignedBin = binNr;
-      int targetIndex = solution.PackingInformations.FindLastIndex(pi => pi.AssignedBin == binNr);
-      solution.PackingInformations.Insert(targetIndex + 1, itemgene);
     }
 
@@ -370,9 +217,9 @@
 
 
-    private static ThreeDimensionalPacking FindExtremePointForItem(int itemIndex, ItemList<CuboidPackingItem> itemMeasures, CuboidPackingBin binMeasures,
+    public static ThreeDimensionalPacking FindExtremePointForItem(int itemIndex, ItemList<CuboidPackingItem> itemMeasures, CuboidPackingBin binMeasures,
         HashSet<ThreeDimensionalPacking> extremePoints, List<int[, ,]> occupiedPoints, ObservableDictionary<int, ThreeDimensionalPacking> itemPositions) {
           return FindExtremePointForItem(itemIndex, itemMeasures, binMeasures, extremePoints, occupiedPoints, itemPositions, false);
     }
-    private static ThreeDimensionalPacking FindExtremePointForItem(int itemIndex, ItemList<CuboidPackingItem> itemMeasures, CuboidPackingBin binMeasures, 
+    public static ThreeDimensionalPacking FindExtremePointForItem(int itemIndex, ItemList<CuboidPackingItem> itemMeasures, CuboidPackingBin binMeasures, 
         HashSet<ThreeDimensionalPacking> extremePoints, List<int[,,]> occupiedPoints, ObservableDictionary<int, ThreeDimensionalPacking> itemPositions, bool rotated) {
 
@@ -397,5 +244,5 @@
       return null;
     }
-    private static List<int[, ,]> IncreaseBinCountForOccupiedPoints(List<int[, ,]> occupiedPoints, CuboidPackingBin binMeasures) {
+    public static List<int[, ,]> IncreaseBinCountForOccupiedPoints(List<int[, ,]> occupiedPoints, CuboidPackingBin binMeasures) {
       occupiedPoints.Add(new int[binMeasures.Width, binMeasures.Height, binMeasures.Depth]);
       int lastIndex = occupiedPoints.Count - 1;
@@ -409,5 +256,5 @@
       return occupiedPoints;
     }
-    private static bool IsStaticStable(int[, ,] occupiedPoints, CuboidPackingItem item, ThreeDimensionalPacking ep) {
+    public static bool IsStaticStable(int[, ,] occupiedPoints, CuboidPackingItem item, ThreeDimensionalPacking ep) {
       //Static stability is given, if item is placed on the ground
       if (ep.Y == 0)
@@ -433,5 +280,5 @@
       return false;
     }
-    private static List<int[, ,]>  OccupyPointsForNewItem(List<int[, ,]> occupiedPoints, CuboidPackingItem newItem, ThreeDimensionalPacking position, int itemIndex) {
+    public static List<int[, ,]>  OccupyPointsForNewItem(List<int[, ,]> occupiedPoints, CuboidPackingItem newItem, ThreeDimensionalPacking position, int itemIndex) {
       int width = position.Rotated ? newItem.Depth : newItem.Width; 
       int depth = position.Rotated ? newItem.Width : newItem.Depth;
@@ -445,5 +292,5 @@
       return occupiedPoints;
     }
-    private static HashSet<ThreeDimensionalPacking> GenerateNewExtremePointsForNewItem(HashSet<ThreeDimensionalPacking> extremePoints, List<int[, ,]> occupiedPoints, 
+    public static HashSet<ThreeDimensionalPacking> GenerateNewExtremePointsForNewItem(HashSet<ThreeDimensionalPacking> extremePoints, List<int[, ,]> occupiedPoints, 
         CuboidPackingItem newItem, ThreeDimensionalPacking position, CuboidPackingBin binMeasures) {
       int currentBin = position.AssignedBin;
@@ -518,8 +365,8 @@
 
 
-    private static HashSet<ThreeDimensionalPacking> OrderExtremePoints(HashSet<ThreeDimensionalPacking> hashSet, List<int[, ,]> occupiedPoints, CuboidPackingBin binMeasures) {
+    public static HashSet<ThreeDimensionalPacking> OrderExtremePoints(HashSet<ThreeDimensionalPacking> hashSet, List<int[, ,]> occupiedPoints, CuboidPackingBin binMeasures) {
       return new HashSet<ThreeDimensionalPacking>(hashSet.OrderBy(ep => ep.AssignedBin).ThenBy(ep => ep.Z).ThenBy(ep => ep.X).ThenBy(ep => ep.Y).ThenBy(ep => ShortestPossibleSideFromEP(ep, occupiedPoints, binMeasures)));
     }
-    private static int ShortestPossibleSideFromEP(ThreeDimensionalPacking ep, List<int[, ,]> occupiedPoints, CuboidPackingBin binMeasures) {
+    public static int ShortestPossibleSideFromEP(ThreeDimensionalPacking ep, List<int[, ,]> occupiedPoints, CuboidPackingBin binMeasures) {
       int shortestSide = int.MaxValue;
 
Index: branches/HeuristicLab.BinPacking/HeuristicLab.Problems.BinPacking/3.3/Decoders/3D/EP/ISOContainerMultiComponentVectorDecoder3D.cs
===================================================================
--- branches/HeuristicLab.BinPacking/HeuristicLab.Problems.BinPacking/3.3/Decoders/3D/EP/ISOContainerMultiComponentVectorDecoder3D.cs	(revision 9495)
+++ branches/HeuristicLab.BinPacking/HeuristicLab.Problems.BinPacking/3.3/Decoders/3D/EP/ISOContainerMultiComponentVectorDecoder3D.cs	(revision 9495)
@@ -0,0 +1,155 @@
+﻿#region License Information
+/* HeuristicLab
+ * Copyright (C) 2002-2012 Heuristic and Evolutionary Algorithms Laboratory (HEAL)
+ *
+ * This file is part of HeuristicLab.
+ *
+ * HeuristicLab is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation, either version 3 of the License, or
+ * (at your option) any later version.
+ *
+ * HeuristicLab is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with HeuristicLab. If not, see <http://www.gnu.org/licenses/>.
+ */
+#endregion
+
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using System.Text;
+using HeuristicLab.Persistence.Default.CompositeSerializers.Storable;
+using HeuristicLab.Core;
+using HeuristicLab.Problems.BinPacking.Dimensions;
+using HeuristicLab.Problems.BinPacking.PackingBin;
+using HeuristicLab.Problems.BinPacking.PackingItem;
+using HeuristicLab.Encodings.PackingEncoding.PackingPlan;
+using HeuristicLab.Encodings.PermutationEncoding;
+using HeuristicLab.Common;
+using HeuristicLab.Data;
+using HeuristicLab.Collections;
+using HeuristicLab.Encodings.PackingEncoding.PackingSequence;
+using HeuristicLab.Problems.BinPacking.Interfaces;
+using HeuristicLab.Encodings.PackingEncoding.GroupingVector;
+using HeuristicLab.Encodings.PackingEncoding.MultiComponentVector;
+
+namespace HeuristicLab.Problems.BinPacking.Decoders {
+  [Item("Identical bin, three dimensional, extreme points based decoder for the MultiComponentVector encoding.", "<Description missing...>")]
+  [StorableClass]
+  public class ISOContainerMultiComponentVectorDecoder3D : IdenticalBinPackingSolutionDecoder<
+      ThreeDimensionalPacking,
+      CuboidPackingBin,
+      CuboidPackingItem,
+      MultipleBinSizePackingPlan<ThreeDimensionalPacking, CuboidPackingBin, CuboidPackingItem>> {
+
+    public ISOContainerMultiComponentVectorDecoder3D ()
+      : base() {
+    }
+    [StorableConstructor]
+    protected ISOContainerMultiComponentVectorDecoder3D (bool deserializing) : base(deserializing) { }
+    protected ISOContainerMultiComponentVectorDecoder3D(ISOContainerMultiComponentVectorDecoder3D original, Cloner cloner)
+      : base(original, cloner) {
+    }
+    public override IDeepCloneable Clone(Cloner cloner) {
+      return new ISOContainerMultiComponentVectorDecoder3D(this, cloner);
+    }
+
+    public static MultipleBinSizePackingPlan<ThreeDimensionalPacking, CuboidPackingBin, CuboidPackingItem> Decode(MultiComponentVectorEncoding solution, CuboidPackingBin binMeasures, ItemList<CuboidPackingItem> itemMeasures) {
+      
+      MultipleBinSizePackingPlan<ThreeDimensionalPacking, CuboidPackingBin, CuboidPackingItem> result =
+        new MultipleBinSizePackingPlan<ThreeDimensionalPacking, CuboidPackingBin, CuboidPackingItem>(new ObservableDictionary<int, CuboidPackingBin>(), itemMeasures);
+
+      #region Preperations
+      int nrOfBins = solution.NrOfBins;
+
+      //Get all indexes of items for every bin according to grouping-vector                      
+      Dictionary<int, List<PackingInformation>> unpackedItemIndexesPerBin = new Dictionary<int, List<PackingInformation>>();
+      Dictionary<int, HashSet<ThreeDimensionalPacking>> extremePointsForBin = new Dictionary<int, HashSet<ThreeDimensionalPacking>>();
+      var occupiedPoints = new List<int[, ,]>();
+
+      for (int i = 0; i < nrOfBins; i++) {
+        unpackedItemIndexesPerBin[i] = new List<PackingInformation>(solution.PackingInformations[i]);
+
+        extremePointsForBin[i] = new HashSet<ThreeDimensionalPacking>();
+        extremePointsForBin[i].Add(new ThreeDimensionalPacking(i, 0, 0, 0, false));
+        occupiedPoints = ExtremePointsFunctions3D.IncreaseBinCountForOccupiedPoints(occupiedPoints, binMeasures);
+      }
+
+      ObservableDictionary<int, ThreeDimensionalPacking> itemPositions = new ObservableDictionary<int, ThreeDimensionalPacking>();
+      var remainingItems = new List<PackingInformation>();
+
+      #endregion Preperations
+
+
+      //Iterate over all bin-lists
+      for (int binNr = 0; binNr < nrOfBins; binNr++) {
+        //Iterate over the current bin-item-list and find feasible positions in the current bin for each item
+        var unpackedItems = unpackedItemIndexesPerBin[binNr];
+        for (int i = 0; i < unpackedItems.Count; i++) {
+          var itemIndex = unpackedItems[i].ItemID;
+          var item = itemMeasures[itemIndex];
+
+          extremePointsForBin[binNr] = ExtremePointsFunctions3D.OrderExtremePoints(extremePointsForBin[binNr], occupiedPoints, binMeasures);
+          var positionFound = ExtremePointsFunctions3D.FindExtremePointForItem(itemIndex, itemMeasures, binMeasures, extremePointsForBin[binNr], occupiedPoints, itemPositions, unpackedItems[i].Rotated);
+          if (positionFound != null) {
+            extremePointsForBin[binNr].Remove(positionFound);
+            itemPositions[itemIndex] = positionFound;
+            occupiedPoints = ExtremePointsFunctions3D.OccupyPointsForNewItem(occupiedPoints, item, positionFound, itemIndex);
+            extremePointsForBin[binNr] = ExtremePointsFunctions3D.GenerateNewExtremePointsForNewItem(extremePointsForBin[binNr], occupiedPoints, item, positionFound, binMeasures);
+          } else {
+            remainingItems.Add(unpackedItems[i]);
+            //solution.PackingInformations[binNr].Remove(unpackedItems[i]);
+          }
+        }
+      }
+
+
+      //Packing of remaining items    
+      //Iterate over all bin-lists
+      for (int binNr = 0; binNr < nrOfBins && remainingItems.Count > 0; binNr++) {
+        var unpackedItems = new List<PackingInformation>(remainingItems);
+        //Iterate over all the remaining items
+        for (int i = 0; i < unpackedItems.Count; i++) {
+          var itemIndex = unpackedItems[i].ItemID;
+          var item = itemMeasures[itemIndex];
+
+          extremePointsForBin[binNr] = ExtremePointsFunctions3D.OrderExtremePoints(extremePointsForBin[binNr], occupiedPoints, binMeasures);
+          var positionFound = ExtremePointsFunctions3D.FindExtremePointForItem(itemIndex, itemMeasures, binMeasures, extremePointsForBin[binNr], occupiedPoints, itemPositions, unpackedItems[i].Rotated);
+          if (positionFound != null) {
+            extremePointsForBin[binNr].Remove(positionFound);
+            itemPositions[itemIndex] = positionFound;
+            occupiedPoints = ExtremePointsFunctions3D.OccupyPointsForNewItem(occupiedPoints, item, positionFound, itemIndex);
+            extremePointsForBin[binNr] = ExtremePointsFunctions3D.GenerateNewExtremePointsForNewItem(extremePointsForBin[binNr], occupiedPoints, item, positionFound, binMeasures);
+            remainingItems.Remove(unpackedItems[i]);
+            //solution.PackingInformations[binNr].Add(unpackedItems[i]);
+          }
+        }
+        if (remainingItems.Count > 0 && binNr + 1 >= nrOfBins) {
+          extremePointsForBin[nrOfBins] = new HashSet<ThreeDimensionalPacking>();
+          extremePointsForBin[nrOfBins].Add(new ThreeDimensionalPacking(nrOfBins, 0, 0, 0, false));
+          occupiedPoints = ExtremePointsFunctions3D.IncreaseBinCountForOccupiedPoints(occupiedPoints, binMeasures);
+          //solution.PackingInformations[nrOfBins] = new ItemList<PackingInformation>();
+          nrOfBins++;
+        }
+      }
+
+      return itemPositions;
+
+
+      return result;
+    }
+
+    protected override MultipleBinSizePackingPlan<ThreeDimensionalPacking, CuboidPackingBin, CuboidPackingItem> CreatePackingPlanFromEncoding(IPackingSolutionEncoding encodedSolution) {
+
+      var solution = encodedSolution as MultiComponentVectorEncoding;
+      if (solution == null) throw new InvalidOperationException("Encoding is not of type MultiComponentVector");
+
+      return Decode(solution, PackingBinMeasuresParameter.ActualValue, PackingItemMeasuresParameter.ActualValue);
+    }
+  }
+}
