Index: /stable/HeuristicLab.Algorithms.ParameterlessPopulationPyramid/3.3/EvaluationTracker.cs
===================================================================
--- /stable/HeuristicLab.Algorithms.ParameterlessPopulationPyramid/3.3/EvaluationTracker.cs	(revision 15323)
+++ /stable/HeuristicLab.Algorithms.ParameterlessPopulationPyramid/3.3/EvaluationTracker.cs	(revision 15324)
@@ -27,4 +27,5 @@
 using HeuristicLab.Encodings.BinaryVectorEncoding;
 using HeuristicLab.Parameters;
+using HeuristicLab.Persistence.Default.CompositeSerializers.Storable;
 using HeuristicLab.Problems.Binary;
 
@@ -33,25 +34,28 @@
   // B. W. Goldman and W. F. Punch, "Parameter-less Population Pyramid," GECCO, pp. 785–792, 2014
   // and the original source code in C++11 available from: https://github.com/brianwgoldman/Parameter-less_Population_Pyramid
+  [StorableClass]
   internal sealed class EvaluationTracker : BinaryProblem {
+    [Storable]
     private readonly BinaryProblem problem;
-
+    [Storable]
     private int maxEvaluations;
 
     #region Properties
+    [Storable]
     public double BestQuality {
       get;
       private set;
     }
-
+    [Storable]
     public int Evaluations {
       get;
       private set;
     }
-
+    [Storable]
     public int BestFoundOnEvaluation {
       get;
       private set;
     }
-
+    [Storable]
     public BinaryVector BestSolution {
       get;
@@ -59,4 +63,8 @@
     }
     #endregion
+
+
+    [StorableConstructor]
+    private EvaluationTracker(bool deserializing) : base(deserializing) { }
 
     private EvaluationTracker(EvaluationTracker original, Cloner cloner)
@@ -67,9 +75,10 @@
       Evaluations = original.Evaluations;
       BestFoundOnEvaluation = original.BestFoundOnEvaluation;
-      BestSolution = cloner.Clone(BestSolution);
+      BestSolution = cloner.Clone(original.BestSolution);
     }
     public override IDeepCloneable Clone(Cloner cloner) {
       return new EvaluationTracker(this, cloner);
     }
+
     public EvaluationTracker(BinaryProblem problem, int maxEvaluations) {
       this.problem = problem;
Index: /stable/HeuristicLab.Algorithms.ParameterlessPopulationPyramid/3.3/LinkageTree.cs
===================================================================
--- /stable/HeuristicLab.Algorithms.ParameterlessPopulationPyramid/3.3/LinkageTree.cs	(revision 15323)
+++ /stable/HeuristicLab.Algorithms.ParameterlessPopulationPyramid/3.3/LinkageTree.cs	(revision 15324)
@@ -27,4 +27,5 @@
 using HeuristicLab.Core;
 using HeuristicLab.Encodings.BinaryVectorEncoding;
+using HeuristicLab.Persistence.Default.CompositeSerializers.Storable;
 using HeuristicLab.Random;
 
@@ -33,11 +34,44 @@
   // B. W. Goldman and W. F. Punch, "Parameter-less Population Pyramid," GECCO, pp. 785–792, 2014
   // and the original source code in C++11 available from: https://github.com/brianwgoldman/Parameter-less_Population_Pyramid
-  public class LinkageTree {
+  [StorableClass]
+  public class LinkageTree : DeepCloneable {
+    [Storable]
     private readonly int[][][] occurances;
+    [Storable]
     private readonly List<int>[] clusters;
+    [Storable]
     private List<int> clusterOrdering;
+    [Storable]
     private readonly int length;
+    [Storable]
     private readonly IRandom rand;
+    [Storable]
     private bool rebuildRequired = false;
+
+
+    [StorableConstructor]
+    protected LinkageTree(bool deserializing) : base() { }
+
+
+    protected LinkageTree(LinkageTree original, Cloner cloner) : base(original, cloner) {
+      occurances = new int[original.occurances.Length][][];
+      //mkommend: first entry is not used, cf. ctor line 83
+      for (int i = 1; i < original.occurances.Length; i++) {
+        occurances[i] = new int[original.occurances[i].Length][];
+        for (int j = 0; j < original.occurances[i].Length; j++)
+          occurances[i][j] = original.occurances[i][j].ToArray();
+      }
+
+      clusters = original.clusters.Select(c => c.ToList()).ToArray();
+      clusterOrdering = new List<int>(original.clusterOrdering);
+      length = original.length;
+      rand = cloner.Clone(original.rand);
+      rebuildRequired = original.rebuildRequired;
+    }
+
+
+    public override IDeepCloneable Clone(Cloner cloner) {
+      return new LinkageTree(this, cloner);
+    }
 
     public LinkageTree(int length, IRandom rand) {
@@ -93,6 +127,6 @@
     // Uses the frequency table to calcuate the entropy distance between two indices.
     // In the GECCO paper, calculates Equation 1
-    private int[] bits = new int[4];
     private double EntropyDistance(int i, int j) {
+      int[] bits = new int[4];
       // This ensures you are using the lower triangular part of "occurances"
       if (i < j) {
@@ -125,6 +159,6 @@
     // by I. Gronau and S. Moran
     // In the GECCO paper, Figure 2 is a simplified version of this algorithm.
-    private double[][] distances;
     private void Rebuild() {
+      double[][] distances = null;
       if (distances == null) {
         distances = new double[clusters.Length * 2 - 1][];
Index: /stable/HeuristicLab.Algorithms.ParameterlessPopulationPyramid/3.3/ParameterlessPopulationPyramid.cs
===================================================================
--- /stable/HeuristicLab.Algorithms.ParameterlessPopulationPyramid/3.3/ParameterlessPopulationPyramid.cs	(revision 15323)
+++ /stable/HeuristicLab.Algorithms.ParameterlessPopulationPyramid/3.3/ParameterlessPopulationPyramid.cs	(revision 15324)
@@ -23,4 +23,5 @@
 using System;
 using System.Collections.Generic;
+using System.Linq;
 using System.Threading;
 using HeuristicLab.Analysis;
@@ -51,10 +52,19 @@
     }
 
+    [Storable]
     private readonly IRandom random = new MersenneTwister();
-    private List<Population> pyramid;
+    [Storable]
+    private List<Population> pyramid = new List<Population>();
+    [Storable]
     private EvaluationTracker tracker;
 
     // Tracks all solutions in Pyramid for quick membership checks
-    private readonly HashSet<BinaryVector> seen = new HashSet<BinaryVector>(new EnumerableBoolEqualityComparer());
+
+    private HashSet<BinaryVector> seen = new HashSet<BinaryVector>(new EnumerableBoolEqualityComparer());
+    [Storable]
+    private IEnumerable<BinaryVector> StorableSeen {
+      get { return seen; }
+      set { seen = new HashSet<BinaryVector>(value, new EnumerableBoolEqualityComparer()); }
+    }
 
     #region ParameterNames
@@ -160,4 +170,8 @@
     protected ParameterlessPopulationPyramid(ParameterlessPopulationPyramid original, Cloner cloner)
       : base(original, cloner) {
+      random = cloner.Clone(original.random);
+      pyramid = original.pyramid.Select(cloner.Clone).ToList();
+      tracker = cloner.Clone(original.tracker);
+      seen = new HashSet<BinaryVector>(original.seen.Select(cloner.Clone), new EnumerableBoolEqualityComparer());
     }
 
@@ -166,5 +180,5 @@
     }
 
-    public ParameterlessPopulationPyramid() {
+    public ParameterlessPopulationPyramid() : base() {
       Parameters.Add(new FixedValueParameter<IntValue>(MaximumIterationsParameterName, "", new IntValue(Int32.MaxValue)));
       Parameters.Add(new FixedValueParameter<IntValue>(MaximumEvaluationsParameterName, "", new IntValue(Int32.MaxValue)));
@@ -256,5 +270,6 @@
           ResultsIterations++;
           cancellationToken.ThrowIfCancellationRequested();
-        } finally {
+        }
+        finally {
           ResultsEvaluations = tracker.Evaluations;
           ResultsBestSolution = new BinaryVector(tracker.BestSolution);
Index: /stable/HeuristicLab.Algorithms.ParameterlessPopulationPyramid/3.3/Population.cs
===================================================================
--- /stable/HeuristicLab.Algorithms.ParameterlessPopulationPyramid/3.3/Population.cs	(revision 15323)
+++ /stable/HeuristicLab.Algorithms.ParameterlessPopulationPyramid/3.3/Population.cs	(revision 15324)
@@ -22,6 +22,9 @@
 
 using System.Collections.Generic;
+using System.Linq;
+using HeuristicLab.Common;
 using HeuristicLab.Core;
 using HeuristicLab.Encodings.BinaryVectorEncoding;
+using HeuristicLab.Persistence.Default.CompositeSerializers.Storable;
 
 namespace HeuristicLab.Algorithms.ParameterlessPopulationPyramid {
@@ -29,13 +32,29 @@
   // B. W. Goldman and W. F. Punch, "Parameter-less Population Pyramid," GECCO, pp. 785–792, 2014
   // and the original source code in C++11 available from: https://github.com/brianwgoldman/Parameter-less_Population_Pyramid
-  public class Population {
+  [StorableClass]
+  public class Population : DeepCloneable {
+    [Storable]
     public List<BinaryVector> Solutions {
       get;
       private set;
     }
-
+    [Storable]
     public LinkageTree Tree {
       get;
       private set;
+    }
+
+
+    [StorableConstructor]
+    protected Population(bool deserializing) : base() { }
+
+
+    protected Population(Population original, Cloner cloner) : base(original, cloner) {
+      Solutions = original.Solutions.Select(cloner.Clone).ToList();
+      Tree = cloner.Clone(original.Tree);
+    }
+
+    public override IDeepCloneable Clone(Cloner cloner) {
+      return new Population(this, cloner);
     }
 
