Index: /branches/HeuristicLab.EvolutionTracking/HeuristicLab.EvolutionTracking.Views/3.4/GenealogyGraphView.cs
===================================================================
--- /branches/HeuristicLab.EvolutionTracking/HeuristicLab.EvolutionTracking.Views/3.4/GenealogyGraphView.cs	(revision 11252)
+++ /branches/HeuristicLab.EvolutionTracking/HeuristicLab.EvolutionTracking.Views/3.4/GenealogyGraphView.cs	(revision 11253)
@@ -45,5 +45,5 @@
     // TODO: Put event handlers of child controls here.
     public virtual void graphChart_GenealogyGraphNodeClicked(object sender, MouseEventArgs args) {
-      var content = ((VisualGenealogyGraphNode)sender).Data.Content;
+      var content = ((VisualGenealogyGraphNode)sender).Data.Data;
       if (content != null) {
         viewHost.Content = (IContent)content;
Index: /branches/HeuristicLab.EvolutionTracking/HeuristicLab.EvolutionTracking.Views/3.4/HeuristicLab.EvolutionTracking.Views-3.4.csproj
===================================================================
--- /branches/HeuristicLab.EvolutionTracking/HeuristicLab.EvolutionTracking.Views/3.4/HeuristicLab.EvolutionTracking.Views-3.4.csproj	(revision 11252)
+++ /branches/HeuristicLab.EvolutionTracking/HeuristicLab.EvolutionTracking.Views/3.4/HeuristicLab.EvolutionTracking.Views-3.4.csproj	(revision 11253)
@@ -97,7 +97,5 @@
       <DependentUpon>FrequentFragmentsDialog.cs</DependentUpon>
     </Compile>
-    <Compile Include="GenealogyGraphChart.cs">
-      <SubType>UserControl</SubType>
-    </Compile>
+    <Compile Include="GenealogyGraphChart.cs" />
     <Compile Include="GenealogyGraphChart.Designer.cs">
       <DependentUpon>GenealogyGraphChart.cs</DependentUpon>
Index: /branches/HeuristicLab.EvolutionTracking/HeuristicLab.EvolutionTracking/3.4/Analyzers/GenealogyAnalyzer.cs
===================================================================
--- /branches/HeuristicLab.EvolutionTracking/HeuristicLab.EvolutionTracking/3.4/Analyzers/GenealogyAnalyzer.cs	(revision 11252)
+++ /branches/HeuristicLab.EvolutionTracking/HeuristicLab.EvolutionTracking/3.4/Analyzers/GenealogyAnalyzer.cs	(revision 11253)
@@ -20,5 +20,5 @@
 #endregion
 
-using System.Collections.Generic;
+using System;
 using System.Linq;
 using HeuristicLab.Analysis;
@@ -259,6 +259,9 @@
         int index = 0;
         T elite = null;
+
+        int psum1 = GenealogyGraph.Ranks[generation].Sum(x => x.Parents.Count());
+
         for (int i = 0; i < population.Length; ++i) {
-          if (GenealogyGraph.Contains(population[i])) {
+          if (GenealogyGraph.GetByContent(population[i]).Rank.Equals(generation - 1)) {
             elite = population[i];
             index = i;
@@ -271,8 +274,6 @@
           var prevVertex = (IGenealogyGraphNode<T>)GenealogyGraph.GetByContent(elite);
           prevVertex.IsElite = true; // mark elites in the graph retroactively
-
-          var clone = (T)elite.Clone();
-
-          var v = new GenealogyGraphNode<T>(prevVertex.Content) {
+          var w = new GenealogyGraphNode<T>(prevVertex); //shallow copy, arcs are not copied
+          var v = new GenealogyGraphNode<T>(prevVertex.Data) {
             Rank = generation,
             Quality = prevVertex.Quality,
@@ -280,20 +281,10 @@
           };
 
-          var w = new GenealogyGraphNode<T>(clone) {
-            Rank = generation - 1,
-            Quality = prevVertex.Quality,
-            IsElite = true
-          };
-
-          // replace previous elite with vertex w 
-          List<IGenealogyGraphNode<T>> parents = null;
           object data = null;
-          if (prevVertex.InArcs.Any()) {
+          if (prevVertex.InArcs.Any())
             data = prevVertex.InArcs.Last().Data;
-            parents = prevVertex.InArcs.Select(x => (IGenealogyGraphNode<T>)x.Source).ToList();
-            //            v.InArcs.Last().Data = prevVertex.InArcs.Last().Data; // save the fragment in case there is one
-            //            var p = prevVertex.InArcs.First().Source;
-            //            GenealogyGraph.AddArc(p, w);
-          }
+          var children = prevVertex.Children.ToList();
+          var parents = prevVertex.Parents.ToList();
+
           GenealogyGraph.RemoveVertex(prevVertex);
           GenealogyGraph.AddVertex(w);
@@ -301,9 +292,12 @@
           GenealogyGraph.AddArc(w, v); // connect current elite with previous elite
 
+          // recreate connections after prevVertex was replaced with w
+          foreach (var c in children) GenealogyGraph.AddArc(w, c);
+          foreach (var p in parents) GenealogyGraph.AddArc(p, w);
+
           v.InArcs.Last().Data = data;
-          if (parents != null) {
-            foreach (var p in parents)
-              GenealogyGraph.AddArc(p, w);
-          }
+
+          if (w.InArcs.Any())
+            w.InArcs.Last().Data = data;
 
           // inject the graph node unique id to the scope
@@ -311,4 +305,8 @@
         }
         #endregion
+        int psum2 = GenealogyGraph.Ranks[generation].Sum(x => x.Parents.Count());
+
+        if (psum1 != psum2 - 1) // -1 because we have added an additional arc from the previous elite to the current one
+          throw new InvalidOperationException("Parent sum should remain the same.");
 
         ComputeSuccessRatios();
@@ -316,10 +314,10 @@
       // update qualities
       for (int i = 0; i < population.Length; ++i) {
-        var vertex = (IGenealogyGraphNode)GenealogyGraph.GetByContent(population[i]);
+        var vertex = GenealogyGraph.GetByContent(population[i]);
         vertex.Quality = qualities[i].Value;
       }
 
       // remove extra graph nodes (added by the instrumented operators in the case of offspring selection)
-      var discardedOffspring = GenealogyGraph.Ranks[generation].Select(x => (T)x.Content).Except(population).ToList();
+      var discardedOffspring = GenealogyGraph.Ranks[generation].Select(x => (T)x.Data).Except(population).ToList();
       foreach (var vertex in discardedOffspring.Select(individual => GenealogyGraph.GetByContent(individual))) {
         GenealogyGraph.RemoveVertex(vertex);
@@ -334,5 +332,5 @@
       // compute the weight of each genealogy graph node as the ratio (produced offspring) / (surviving offspring)
       foreach (var ind in population) {
-        var v = (IGenealogyGraphNode)GenealogyGraph.GetByContent(ind);
+        var v = GenealogyGraph.GetByContent(ind);
         foreach (var p in v.Parents)
           p.Weight++;
Index: /branches/HeuristicLab.EvolutionTracking/HeuristicLab.EvolutionTracking/3.4/GenealogyGraph/GenealogyGraph.cs
===================================================================
--- /branches/HeuristicLab.EvolutionTracking/HeuristicLab.EvolutionTracking/3.4/GenealogyGraph/GenealogyGraph.cs	(revision 11252)
+++ /branches/HeuristicLab.EvolutionTracking/HeuristicLab.EvolutionTracking/3.4/GenealogyGraph/GenealogyGraph.cs	(revision 11253)
@@ -69,7 +69,5 @@
     public override IArc AddArc(IVertex source, IVertex target) {
       var arc = new GenealogyGraphArc((IGenealogyGraphNode)source, (IGenealogyGraphNode)target);
-      source.AddArc(arc);
-      target.AddArc(arc);
-      arcs.Add(arc);
+      base.AddArc(arc);
       return arc;
     }
@@ -82,18 +80,16 @@
       Ranks[node.Rank].Add(node);
 
-      if (contentMap.ContainsKey(node.Content))
+      if (contentMap.ContainsKey(node.Data))
         throw new InvalidOperationException("Duplicate content is not allowed in the genealogy graph.");
-      contentMap[node.Content] = node;
+      contentMap[node.Data] = node;
 
       if (idMap.ContainsKey(node.Id))
         throw new InvalidOperationException("Duplicate content is not allowed in the genealogy graph.");
       idMap[node.Id] = node;
-
-      vertex.Changed += OnVertexChanged;
     }
 
     public override void RemoveVertex(IVertex vertex) {
       var node = (IGenealogyGraphNode)vertex;
-      contentMap.Remove(node.Content);
+      contentMap.Remove(node.Data);
       idMap.Remove(node.Id);
       if (Ranks.ContainsKey(node.Rank)) {
@@ -129,87 +125,8 @@
       ranks.Clear();
     }
-
-    protected override void OnVertexChanged(object sender, EventArgs args) {
-      base.OnVertexChanged(sender, args);
-
-      var vertex = (IGenealogyGraphNode)sender;
-      if (!contentMap.ContainsKey(vertex.Content)) {
-        // vertex has received new content
-      }
-    }
   }
 
-  //  [StorableClass]
-  //  [Item("GenealogyGraph", "A class representing a genealogy graph")]
-  //  public class GenealogyGraph<T> : DirectedGraph, IGenealogyGraph<T> where T : class, IItem {
-  //    // members and properties
-  //    [Storable]
-  //    private Dictionary<double, List<IGenealogyGraphNode>> ranks;
-  //    public Dictionary<double, List<IGenealogyGraphNode>> Ranks {
-  //      get { return ranks; }
-  //      set { ranks = value; }
-  //    }
-  //    public new IEnumerable<IGenealogyGraphNode<T>> Vertices {
-  //      get { return from n in base.Vertices select (IGenealogyGraphNode<T>)n; }
-  //    }
-  //    // contructors
-  //    protected GenealogyGraph(GenealogyGraph<T> original, Cloner cloner)
-  //      : base(original, cloner) {
-  //    }
-  //    public override IDeepCloneable Clone(Cloner cloner) {
-  //      return new GenealogyGraph<T>(this, cloner);
-  //    }
-  //
-  //    [StorableConstructor]
-  //    protected GenealogyGraph(bool deserializing) : base(deserializing) { }
-  //    public GenealogyGraph() {
-  //      Ranks = new Dictionary<double, List<IGenealogyGraphNode>>();
-  //    }
-  //
-  //    // methods
-  //    public override void AddVertex(IVertex vertex) {
-  //      base.AddVertex(vertex);
-  //      var node = (IGenealogyGraphNode)vertex;
-  //      if (!Ranks.ContainsKey(node.Rank)) {
-  //        Ranks[node.Rank] = new List<IGenealogyGraphNode>();
-  //      }
-  //      Ranks[node.Rank].Add(node);
-  //    }
-  //
-  //    public override void RemoveVertex(IVertex vertex) {
-  //      var node = (IGenealogyGraphNode<T>)vertex;
-  //      if (Ranks.ContainsKey(node.Rank)) {
-  //        Ranks[node.Rank].Remove(node);
-  //      }
-  //      base.RemoveVertex(vertex);
-  //    }
-  //
-  //    public override IArc AddArc(IVertex source, IVertex target) {
-  //      var arc = new GenealogyGraphArc((IGenealogyGraphNode)source, (IGenealogyGraphNode)target);
-  //      source.AddArc(arc);
-  //      target.AddArc(arc);
-  //      arcs.Add(arc);
-  //      return arc;
-  //    }
-  //
-  //    IEnumerable<IGenealogyGraphNode> IGenealogyGraph.Vertices {
-  //      get { return Vertices; }
-  //    }
-  //
-  //    public IGenealogyGraphNode GetByContent(object content)
-  //    {
-  //      IGenealogyGraphNode result;
-  //      contentMap.
-  //    }
-  //
-  //    public event EventHandler GraphUpdated;
-  //    private void OnGraphUpdated(object sender, EventArgs args) {
-  //      var updated = GraphUpdated;
-  //      if (updated != null) updated(sender, args);
-  //    }
-  //  }
+  [Item("GenealogyGraph", "A specialization of the genealogy graph with T as content for vertices")]
   [StorableClass]
-
-  [Item("GenealogyGraph", "A specialization of the genealogy graph with T as content for vertices")]
   public class GenealogyGraph<T> : GenealogyGraph, IGenealogyGraph<T> where T : class, IItem {
     public new IEnumerable<IGenealogyGraphNode<T>> Vertices {
Index: /branches/HeuristicLab.EvolutionTracking/HeuristicLab.EvolutionTracking/3.4/GenealogyGraph/GenealogyGraphNode.cs
===================================================================
--- /branches/HeuristicLab.EvolutionTracking/HeuristicLab.EvolutionTracking/3.4/GenealogyGraph/GenealogyGraphNode.cs	(revision 11252)
+++ /branches/HeuristicLab.EvolutionTracking/HeuristicLab.EvolutionTracking/3.4/GenealogyGraph/GenealogyGraphNode.cs	(revision 11253)
@@ -33,13 +33,29 @@
     [StorableConstructor]
     protected GenealogyGraphNode(bool deserializing) : base(deserializing) { }
+
     public override IDeepCloneable Clone(Cloner cloner) {
       return new GenealogyGraphNode(this, cloner);
     }
+
+    // this constructor emulates the behavior of a copy constructor
+    // it returns a shallow copy in which the arcs are not cloned
+    protected GenealogyGraphNode(IGenealogyGraphNode original)
+      : base((IDeepCloneable)original.Data.Clone()) {
+      Quality = original.Quality;
+      Rank = original.Rank;
+      IsElite = original.IsElite;
+      Id = Guid.NewGuid().ToString();
+    }
+
     protected GenealogyGraphNode(GenealogyGraphNode original, Cloner cloner)
       : base(original, cloner) {
+      Quality = original.Quality;
+      Rank = original.Rank;
+      IsElite = original.IsElite;
+      Id = Guid.NewGuid().ToString();
     }
 
-    public GenealogyGraphNode(object content)
-      : base(content) {
+    public GenealogyGraphNode(IDeepCloneable data)
+      : base(data) {
       Id = Guid.NewGuid().ToString();
     }
@@ -48,7 +64,9 @@
       get { return base.InArcs.Cast<IGenealogyGraphArc>(); }
     }
+
     public new IEnumerable<IGenealogyGraphArc> OutArcs {
       get { return base.OutArcs.Cast<IGenealogyGraphArc>(); }
     }
+
     public IEnumerable<IGenealogyGraphNode> Ancestors {
       get {
@@ -123,15 +141,15 @@
   [Item("GenealogyGraphNode", "A genealogy graph node which also has a Content")]
   public class GenealogyGraphNode<T> : GenealogyGraphNode, IGenealogyGraphNode<T> where T : class, IItem {
-    public new T Content {
-      get { return (T)base.Content; }
-      set { base.Content = value; }
+    public new T Data {
+      get { return (T)base.Data; }
+      set { base.Data = value; }
     }
 
-    public GenealogyGraphNode(object content) : base(content) { }
+    public GenealogyGraphNode(IGenealogyGraphNode<T> original) : base(original) { }
+
+    public GenealogyGraphNode(IDeepCloneable content) : base(content) { }
 
     protected GenealogyGraphNode(GenealogyGraphNode<T> original, Cloner cloner)
       : base(original, cloner) {
-      // we do not clone the content
-      Content = original.Content;
     }
     public override IDeepCloneable Clone(Cloner cloner) {
Index: /branches/HeuristicLab.EvolutionTracking/HeuristicLab.EvolutionTracking/3.4/GenealogyGraph/Interfaces/IGenealogyGraphArc.cs
===================================================================
--- /branches/HeuristicLab.EvolutionTracking/HeuristicLab.EvolutionTracking/3.4/GenealogyGraph/Interfaces/IGenealogyGraphArc.cs	(revision 11252)
+++ /branches/HeuristicLab.EvolutionTracking/HeuristicLab.EvolutionTracking/3.4/GenealogyGraph/Interfaces/IGenealogyGraphArc.cs	(revision 11253)
@@ -20,4 +20,6 @@
 #endregion
 
+using HeuristicLab.Core;
+
 namespace HeuristicLab.EvolutionTracking {
   public interface IGenealogyGraphArc : IArc {
Index: /branches/HeuristicLab.EvolutionTracking/HeuristicLab.EvolutionTracking/3.4/GenealogyGraph/Interfaces/IGenealogyGraphNode.cs
===================================================================
--- /branches/HeuristicLab.EvolutionTracking/HeuristicLab.EvolutionTracking/3.4/GenealogyGraph/Interfaces/IGenealogyGraphNode.cs	(revision 11252)
+++ /branches/HeuristicLab.EvolutionTracking/HeuristicLab.EvolutionTracking/3.4/GenealogyGraph/Interfaces/IGenealogyGraphNode.cs	(revision 11253)
@@ -22,4 +22,5 @@
 using System;
 using System.Collections.Generic;
+using HeuristicLab.Core;
 
 namespace HeuristicLab.EvolutionTracking {
Index: /branches/HeuristicLab.EvolutionTracking/HeuristicLab.EvolutionTracking/3.4/HeuristicLab.EvolutionTracking-3.4.csproj
===================================================================
--- /branches/HeuristicLab.EvolutionTracking/HeuristicLab.EvolutionTracking/3.4/HeuristicLab.EvolutionTracking-3.4.csproj	(revision 11252)
+++ /branches/HeuristicLab.EvolutionTracking/HeuristicLab.EvolutionTracking/3.4/HeuristicLab.EvolutionTracking-3.4.csproj	(revision 11253)
@@ -105,10 +105,4 @@
   <ItemGroup>
     <Compile Include="Analyzers\GenealogyAnalyzer.cs" />
-    <Compile Include="DirectedGraph\Arc.cs" />
-    <Compile Include="DirectedGraph\DirectedGraph.cs" />
-    <Compile Include="DirectedGraph\Interfaces\IArc.cs" />
-    <Compile Include="DirectedGraph\Interfaces\IDirectedGraph.cs" />
-    <Compile Include="DirectedGraph\Interfaces\IVertex.cs" />
-    <Compile Include="DirectedGraph\Vertex.cs" />
     <Compile Include="Fragment.cs" />
     <Compile Include="Interfaces\IFragment.cs" />
Index: /branches/HeuristicLab.EvolutionTracking/HeuristicLab.EvolutionTracking/3.4/Operators/BeforeCrossoverOperator.cs
===================================================================
--- /branches/HeuristicLab.EvolutionTracking/HeuristicLab.EvolutionTracking/3.4/Operators/BeforeCrossoverOperator.cs	(revision 11252)
+++ /branches/HeuristicLab.EvolutionTracking/HeuristicLab.EvolutionTracking/3.4/Operators/BeforeCrossoverOperator.cs	(revision 11253)
@@ -77,4 +77,6 @@
       var subScopes = ExecutionContext.Scope.SubScopes;
       var parentVertices = subScopes.Select(x => (GenealogyGraphNode<T>)GenealogyGraph.GetById(getScopeId(x))).ToList();
+      if (!parentVertices.Any())
+        throw new InvalidOperationException("Could not retrieve parent vertices.");
 
       var parents = ParentsParameter.ActualValue.ToList();
@@ -84,9 +86,8 @@
       GenealogyGraph.AddVertex(childVertex);
 
-      foreach (var parentVertex in parentVertices.Distinct()) {
+      foreach (var parentVertex in parentVertices)
         GenealogyGraph.AddArc(parentVertex, childVertex);
-      }
+
       ExecutionContext.Scope.Variables.Add(new Variable("Id", new StringValue(childVertex.Id)));
-
       return base.Apply();
     }
Index: /branches/HeuristicLab.EvolutionTracking/HeuristicLab.EvolutionTracking/3.4/Operators/BeforeManipulatorOperator.cs
===================================================================
--- /branches/HeuristicLab.EvolutionTracking/HeuristicLab.EvolutionTracking/3.4/Operators/BeforeManipulatorOperator.cs	(revision 11252)
+++ /branches/HeuristicLab.EvolutionTracking/HeuristicLab.EvolutionTracking/3.4/Operators/BeforeManipulatorOperator.cs	(revision 11253)
@@ -54,8 +54,9 @@
       var v = (IGenealogyGraphNode<T>)GenealogyGraph.GetByContent(ChildParameter.ActualValue);
       var clone = (T)ChildParameter.ActualValue.Clone();
+      var c = new GenealogyGraphNode<T>(clone) { Rank = v.Rank - 0.5 };
+      GenealogyGraph.AddVertex(c);
 
-      var c = new GenealogyGraphNode<T>(clone) { Rank = v.Rank - 0.5 };
-
-      foreach (var arc in v.InArcs) {
+      var arcs = v.InArcs;
+      foreach (var arc in arcs) {
         var p = arc.Source;
         GenealogyGraph.RemoveArc(arc);
@@ -63,12 +64,4 @@
       }
 
-      //      foreach (var a in v.InArcs) {
-      //        a.Target = c;
-      //        c.AddReverseArc(a);
-      //      }
-
-      //      v.InArcs = Enumerable.Empty<IGenealogyGraphArc>();
-
-      GenealogyGraph.AddVertex(c);
       GenealogyGraph.AddArc(c, v);
 
Index: /branches/HeuristicLab.EvolutionTracking/HeuristicLab.Problems.DataAnalysis.Symbolic.Views/3.4/HeuristicLab.Problems.DataAnalysis.Symbolic.Views-3.4.csproj
===================================================================
--- /branches/HeuristicLab.EvolutionTracking/HeuristicLab.Problems.DataAnalysis.Symbolic.Views/3.4/HeuristicLab.Problems.DataAnalysis.Symbolic.Views-3.4.csproj	(revision 11252)
+++ /branches/HeuristicLab.EvolutionTracking/HeuristicLab.Problems.DataAnalysis.Symbolic.Views/3.4/HeuristicLab.Problems.DataAnalysis.Symbolic.Views-3.4.csproj	(revision 11253)
@@ -283,7 +283,5 @@
       <DependentUpon>SymboldDataAnalysisGenealogyView.cs</DependentUpon>
     </Compile>
-    <Compile Include="Tracking\SymbolicDataAnalysisExpressionGenealogyGraphChart.cs">
-      <SubType>UserControl</SubType>
-    </Compile>
+    <Compile Include="Tracking\SymbolicDataAnalysisExpressionGenealogyGraphChart.cs" />
     <Compile Include="Tracking\SymbolicDataAnalysisExpressionGenealogyGraphChart.Designer.cs">
       <DependentUpon>SymbolicDataAnalysisExpressionGenealogyGraphChart.cs</DependentUpon>
Index: /branches/HeuristicLab.EvolutionTracking/HeuristicLab.Problems.DataAnalysis.Symbolic.Views/3.4/Tracking/FragmentGraphView.cs
===================================================================
--- /branches/HeuristicLab.EvolutionTracking/HeuristicLab.Problems.DataAnalysis.Symbolic.Views/3.4/Tracking/FragmentGraphView.cs	(revision 11252)
+++ /branches/HeuristicLab.EvolutionTracking/HeuristicLab.Problems.DataAnalysis.Symbolic.Views/3.4/Tracking/FragmentGraphView.cs	(revision 11253)
@@ -70,10 +70,10 @@
       tileDictionary.Clear();
       foreach (var node in Content.Vertices) {
-        var graphNode = (IGenealogyGraphNode<ISymbolicExpressionTree>)node.Content;
+        var graphNode = (IGenealogyGraphNode<ISymbolicExpressionTree>)node.Data;
         var tile = new SymbolicExpressionTreeTile(chart);
         tile.LayoutEngine = symbolicExpressionEngine;
-        tile.Label = "Generation " + node.Content.Rank + Environment.NewLine +
-                     "Quality " + String.Format("{0:0.000}", node.Content.Quality);
-        tile.Root = graphNode.Content.Root;
+        tile.Label = "Generation " + node.Data.Rank + Environment.NewLine +
+                     "Quality " + String.Format("{0:0.000}", node.Data.Quality);
+        tile.Root = graphNode.Data.Root;
         var tileNode = new TileLayoutNode { Tile = tile };
         tileDictionary.Add(node, tileNode);
@@ -117,8 +117,8 @@
         var aSize = aTile.Size;
         var aPos = aTile.Position;
-        var graphNode = node.Content;
+        var graphNode = node.Data;
 
         if (node.SubtreeIndex > 0) {
-          var subtree = graphNode.Content.Root.NodeAt(node.SubtreeIndex);
+          var subtree = graphNode.Data.Root.NodeAt(node.SubtreeIndex);
           foreach (var s in subtree.IterateNodesPrefix()) {
             var primitive = aTile.GetPrimitive(s);
@@ -132,5 +132,5 @@
         }
         if (node.FragmentIndex > 0) {
-          var subtree = graphNode.Content.Root.NodeAt(node.FragmentIndex);
+          var subtree = graphNode.Data.Root.NodeAt(node.FragmentIndex);
           foreach (var s in subtree.IterateNodesPrefix()) {
             var primitive = aTile.GetPrimitive(s);
@@ -149,6 +149,6 @@
             var index = node.SubtreeIndex + (parent.FragmentIndex - parent.SubtreeIndex);
             // some mutations create discontinuities which invalidate the index
-            if (index >= 0 && index < graphNode.Content.Length) {
-              var subtree = graphNode.Content.NodeAt(index);
+            if (index >= 0 && index < graphNode.Data.Length) {
+              var subtree = graphNode.Data.NodeAt(index);
               var primitive = aTile.GetPrimitive(subtree);
               primitive.Brush = new SolidBrush(Color.LightCoral);
Index: /branches/HeuristicLab.EvolutionTracking/HeuristicLab.Problems.DataAnalysis.Symbolic.Views/3.4/Tracking/SymboldDataAnalysisGenealogyView.cs
===================================================================
--- /branches/HeuristicLab.EvolutionTracking/HeuristicLab.Problems.DataAnalysis.Symbolic.Views/3.4/Tracking/SymboldDataAnalysisGenealogyView.cs	(revision 11252)
+++ /branches/HeuristicLab.EvolutionTracking/HeuristicLab.Problems.DataAnalysis.Symbolic.Views/3.4/Tracking/SymboldDataAnalysisGenealogyView.cs	(revision 11253)
@@ -74,5 +74,5 @@
       var visualNode = (VisualGenealogyGraphNode)sender;
       var graphNode = (IGenealogyGraphNode<ISymbolicExpressionTree>)visualNode.Data;
-      var tree = graphNode.Content;
+      var tree = graphNode.Data;
       symbolicExpressionTreeChart.Tree = tree;
 
@@ -80,5 +80,5 @@
         var fragment = (IFragment<ISymbolicExpressionTreeNode>)graphNode.InArcs.Last().Data;
         if (fragment != null) {
-          treeChart_HighlightSubtree(graphNode.Content.NodeAt(fragment.Index1));
+          treeChart_HighlightSubtree(graphNode.Data.NodeAt(fragment.Index1));
         }
       }
@@ -98,5 +98,5 @@
         // perform fragment tracing
         var graphNode = (IGenealogyGraphNode<ISymbolicExpressionTree>)genealogyGraphChart.SelectedGraphNode;
-        var subtreeIndex = graphNode.Content.IterateNodesPrefix().ToList().IndexOf(subtree);
+        var subtreeIndex = graphNode.Data.IterateNodesPrefix().ToList().IndexOf(subtree);
         var fragmentGraph = SymbolicDataAnalysisExpressionTracing.TraceSubtree(graphNode, subtreeIndex);
         if (fragmentGraph.Vertices.Any()) {
@@ -106,5 +106,5 @@
         // perform matching like it was done before
         // currently there is no possibility to specify the subtree matching criteria
-        var trees = Content.Vertices.Select(x => x.Content);
+        var trees = Content.Vertices.Select(x => x.Data);
         var matchingTrees = trees.Where(x => x.Root.ContainsSubtree(subtree, comparer));
 
Index: /branches/HeuristicLab.EvolutionTracking/HeuristicLab.Problems.DataAnalysis.Symbolic.Views/3.4/Tracking/SymbolicDataAnalysisExpressionLineageExplorerView.cs
===================================================================
--- /branches/HeuristicLab.EvolutionTracking/HeuristicLab.Problems.DataAnalysis.Symbolic.Views/3.4/Tracking/SymbolicDataAnalysisExpressionLineageExplorerView.cs	(revision 11252)
+++ /branches/HeuristicLab.EvolutionTracking/HeuristicLab.Problems.DataAnalysis.Symbolic.Views/3.4/Tracking/SymbolicDataAnalysisExpressionLineageExplorerView.cs	(revision 11253)
@@ -64,5 +64,5 @@
         var treeNode = new TreeNode(g.Quality.ToString(CultureInfo.InvariantCulture));
         treeView.Nodes.Add(treeNode);
-        treeMap.Add(treeNode, (ISymbolicExpressionTree)g.Content);
+        treeMap.Add(treeNode, (ISymbolicExpressionTree)g.Data);
       }
     }
Index: anches/HeuristicLab.EvolutionTracking/HeuristicLab.Problems.DataAnalysis.Symbolic/3.4/Analyzers/SymbolicDataAnalysisPopulationDiversityAnalyzer.cs
===================================================================
--- /branches/HeuristicLab.EvolutionTracking/HeuristicLab.Problems.DataAnalysis.Symbolic/3.4/Analyzers/SymbolicDataAnalysisPopulationDiversityAnalyzer.cs	(revision 11252)
+++ 	(revision )
@@ -1,185 +1,0 @@
-﻿#region License Information
-/* HeuristicLab
- * Copyright (C) 2002-2014 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.Linq;
-using HeuristicLab.Analysis;
-using HeuristicLab.Common;
-using HeuristicLab.Core;
-using HeuristicLab.Data;
-using HeuristicLab.Encodings.SymbolicExpressionTreeEncoding;
-using HeuristicLab.Operators;
-using HeuristicLab.Optimization;
-using HeuristicLab.Parameters;
-using HeuristicLab.Persistence.Default.CompositeSerializers.Storable;
-
-// type definitions for ease of use
-
-namespace HeuristicLab.Problems.DataAnalysis.Symbolic {
-  /// <summary>
-  /// Population diversity analyzer
-  /// </summary>
-  [Item("SymbolicDataAnalysisPopulationDiversityAnalyzer", "An operator that tracks population diversity")]
-  [StorableClass]
-  public sealed class SymbolicDataAnalysisPopulationDiversityAnalyzer : SingleSuccessorOperator, IAnalyzer {
-    #region Parameter names
-    private const string MaximumSymbolicExpressionTreeDepthParameterName = "MaximumSymbolicExpressionTreeDepth";
-    private const string SymbolicExpressionTreeParameterName = "SymbolicExpressionTree";
-    private const string UpdateIntervalParameterName = "UpdateInterval";
-    private const string UpdateCounterParameterName = "UpdateCounter";
-    private const string ResultsParameterName = "Results";
-    private const string GenerationsParameterName = "Generations";
-    private const string StoreHistoryParameterName = "StoreHistory";
-    // comparer parameters
-    private const string SimilarityValuesParmeterName = "Similarity";
-
-    private const string DistanceCalculatorParameterName = "DistanceCalculator";
-
-    #endregion
-
-    #region Parameters
-    public IValueLookupParameter<IntValue> MaximumSymbolicExpressionTreeDepthParameter {
-      get { return (IValueLookupParameter<IntValue>)Parameters[MaximumSymbolicExpressionTreeDepthParameterName]; }
-    }
-    public ValueParameter<IntValue> UpdateIntervalParameter {
-      get { return (ValueParameter<IntValue>)Parameters[UpdateIntervalParameterName]; }
-    }
-    public ValueParameter<IntValue> UpdateCounterParameter {
-      get { return (ValueParameter<IntValue>)Parameters[UpdateCounterParameterName]; }
-    }
-    public LookupParameter<ResultCollection> ResultsParameter {
-      get { return (LookupParameter<ResultCollection>)Parameters[ResultsParameterName]; }
-    }
-    public LookupParameter<IntValue> GenerationsParameter {
-      get { return (LookupParameter<IntValue>)Parameters[GenerationsParameterName]; }
-    }
-    public ValueParameter<BoolValue> StoreHistoryParameter {
-      get { return (ValueParameter<BoolValue>)Parameters[StoreHistoryParameterName]; }
-    }
-    public IScopeTreeLookupParameter<ISymbolicExpressionTree> SymbolicExpressionTreeParameter {
-      get { return (IScopeTreeLookupParameter<ISymbolicExpressionTree>)Parameters[SymbolicExpressionTreeParameterName]; }
-    }
-    public ILookupParameter<DoubleValue> SimilarityParameter {
-      get { return (ILookupParameter<DoubleValue>)Parameters[SimilarityValuesParmeterName]; }
-    }
-    public IValueParameter<IDistanceCalculator> DistanceCalculatorParameter {
-      get { return (IValueParameter<IDistanceCalculator>)Parameters[DistanceCalculatorParameterName]; }
-    }
-    #endregion
-
-    #region Parameter properties
-    public IntValue MaximumSymbolicExpressionTreeDepth { get { return MaximumSymbolicExpressionTreeDepthParameter.ActualValue; } }
-    public IntValue UpdateInterval { get { return UpdateIntervalParameter.Value; } }
-    public IntValue UpdateCounter { get { return UpdateCounterParameter.Value; } }
-    public ResultCollection Results { get { return ResultsParameter.ActualValue; } }
-    public IntValue Generations { get { return GenerationsParameter.ActualValue; } }
-    public BoolValue StoreHistory { get { return StoreHistoryParameter.Value; } }
-    #endregion
-
-    [StorableConstructor]
-    private SymbolicDataAnalysisPopulationDiversityAnalyzer(bool deserializing)
-      : base(deserializing) {
-    }
-
-    private SymbolicDataAnalysisPopulationDiversityAnalyzer(
-      SymbolicDataAnalysisPopulationDiversityAnalyzer original, Cloner cloner)
-      : base(original, cloner) {
-    }
-
-    public override IDeepCloneable Clone(Cloner cloner) {
-      return new SymbolicDataAnalysisPopulationDiversityAnalyzer(this, cloner);
-    }
-
-    public SymbolicDataAnalysisPopulationDiversityAnalyzer() {
-      // add parameters
-      Parameters.Add(new ScopeTreeLookupParameter<ISymbolicExpressionTree>(SymbolicExpressionTreeParameterName, "The symbolic expression trees to analyze."));
-      Parameters.Add(new ValueParameter<IntValue>(UpdateIntervalParameterName, "The interval in which the tree length analysis should be applied.", new IntValue(1)));
-      Parameters.Add(new ValueParameter<IntValue>(UpdateCounterParameterName, "The value which counts how many times the operator was called since the last update", new IntValue(0)));
-      Parameters.Add(new ValueLookupParameter<ResultCollection>(ResultsParameterName, "The results collection where the analysis values should be stored."));
-      Parameters.Add(new LookupParameter<IntValue>(GenerationsParameterName, "The number of generations so far."));
-      Parameters.Add(new ValueParameter<BoolValue>(StoreHistoryParameterName, "True if the tree lengths history of the population should be stored.", new BoolValue(false)));
-      Parameters.Add(new LookupParameter<DoubleValue>(SimilarityValuesParmeterName, ""));
-      Parameters.Add(new ValueLookupParameter<IntValue>(MaximumSymbolicExpressionTreeDepthParameterName, "The maximal depth of the symbolic expression tree (a tree with one node has depth = 0)."));
-      Parameters.Add(new ValueParameter<IDistanceCalculator>(DistanceCalculatorParameterName, "The distance calculator between trees.", new BottomUpDistanceCalculator()));
-      UpdateCounterParameter.Hidden = true;
-      UpdateIntervalParameter.Hidden = true;
-    }
-
-    [StorableHook(HookType.AfterDeserialization)]
-    private void AfterDeserialization() {
-      if (!Parameters.ContainsKey(MaximumSymbolicExpressionTreeDepthParameterName)) {
-        Parameters.Add(new ValueLookupParameter<IntValue>(MaximumSymbolicExpressionTreeDepthParameterName, "The maximal depth of the symbolic expression tree (a tree with one node has depth = 0)."));
-      }
-    }
-
-    #region IStatefulItem members
-    public override void InitializeState() {
-      UpdateCounter.Value = 0;
-      base.InitializeState();
-    }
-    #endregion
-
-    public bool EnabledByDefault {
-      get { return true; }
-    }
-
-    public override IOperation Apply() {
-      if (SimilarityParameter.ActualValue == null || SimilarityParameter.ActualValue.Value.IsAlmost(-1.0)) {
-        UpdateCounter.Value++;
-        if (UpdateCounter.Value != UpdateInterval.Value) return base.Apply();
-        UpdateCounter.Value = 0;
-        var trees = SymbolicExpressionTreeParameter.ActualValue.ToList();
-
-        SimilarityParameter.ActualValue = new DoubleValue();
-
-        var operations = new OperationCollection { Parallel = true };
-        foreach (var tree in trees) {
-          var op = new SymbolicDataAnalysisExpressionTreeSimilarityCalculator(DistanceCalculatorParameter.Value) {
-            CurrentSymbolicExpressionTree = tree,
-            MaximumTreeDepth = MaximumSymbolicExpressionTreeDepth.Value
-          };
-          var operation = ExecutionContext.CreateChildOperation(op, ExecutionContext.Scope);
-          operations.Add(operation);
-        }
-        return new OperationCollection { operations, ExecutionContext.CreateOperation(this) };
-      }
-
-      var results = ResultsParameter.ActualValue;
-      // population diversity
-      DataTable populationDiversityTable;
-      if (!results.ContainsKey("PopulationDiversity")) {
-        populationDiversityTable = new DataTable("PopulationDiversity") { VisualProperties = { YAxisTitle = "Diversity" } };
-        results.Add(new Result("PopulationDiversity", populationDiversityTable));
-      }
-      populationDiversityTable = (DataTable)results["PopulationDiversity"].Value;
-      if (!populationDiversityTable.Rows.ContainsKey("Diversity"))
-        populationDiversityTable.Rows.Add(new DataRow("Diversity") { VisualProperties = { StartIndexZero = true } });
-
-      int length = SymbolicExpressionTreeParameter.ActualValue.Length;
-      var similarity = SimilarityParameter.ActualValue.Value / (length * (length - 1) / 2.0);
-      var diversity = 1 - similarity;
-      SimilarityParameter.ActualValue.Value = -1.0;
-
-      populationDiversityTable.Rows["Diversity"].Values.Add(diversity);
-
-      return base.Apply();
-    }
-  }
-}
Index: /branches/HeuristicLab.EvolutionTracking/HeuristicLab.Problems.DataAnalysis.Symbolic/3.4/HeuristicLab.Problems.DataAnalysis.Symbolic-3.4.csproj
===================================================================
--- /branches/HeuristicLab.EvolutionTracking/HeuristicLab.Problems.DataAnalysis.Symbolic/3.4/HeuristicLab.Problems.DataAnalysis.Symbolic-3.4.csproj	(revision 11252)
+++ /branches/HeuristicLab.EvolutionTracking/HeuristicLab.Problems.DataAnalysis.Symbolic/3.4/HeuristicLab.Problems.DataAnalysis.Symbolic-3.4.csproj	(revision 11253)
@@ -173,5 +173,4 @@
   </ItemGroup>
   <ItemGroup>
-    <Compile Include="Analyzers\SymbolicDataAnalysisInternalDiversityAnalyzer.cs" />
     <Compile Include="Analyzers\SymbolicDataAnalysisSingleObjectivePruningAnalyzer.cs" />
     <Compile Include="Analyzers\SymbolicDataAnalysisGenealogyAnalyzer.cs" />
@@ -207,5 +206,4 @@
     <Compile Include="SlidingWindow\SlidingWindowVisualizer.cs" />
     <Compile Include="SymbolicDataAnalysisExpressionPruningOperator.cs" />
-    <Compile Include="SymbolicDataAnalysisExpressionTreeSimilarityCalculator.cs" />
     <Compile Include="SymbolicDataAnalysisSolutionPruningOptimizer.cs" />
     <Compile Include="Analyzers\SymbolicDataAnalysisVariableFrequencyAnalyzer.cs" />
Index: /branches/HeuristicLab.EvolutionTracking/HeuristicLab.Problems.DataAnalysis.Symbolic/3.4/Tracking/SymbolicDataAnalysisExpressionAfterCrossoverOperator.cs
===================================================================
--- /branches/HeuristicLab.EvolutionTracking/HeuristicLab.Problems.DataAnalysis.Symbolic/3.4/Tracking/SymbolicDataAnalysisExpressionAfterCrossoverOperator.cs	(revision 11252)
+++ /branches/HeuristicLab.EvolutionTracking/HeuristicLab.Problems.DataAnalysis.Symbolic/3.4/Tracking/SymbolicDataAnalysisExpressionAfterCrossoverOperator.cs	(revision 11253)
@@ -34,5 +34,5 @@
       var nodes0 = (List<ISymbolicExpressionTreeNode>)arcs[0].Data;
       var nodes1 = (List<ISymbolicExpressionTreeNode>)arcs[1].Data;
-      var childNodes = childVertex.Content.IterateNodesPrefix().ToList();
+      var childNodes = childVertex.Data.IterateNodesPrefix().ToList();
       IFragment<ISymbolicExpressionTreeNode> fragment = null;
       for (int i = 0; i < Math.Min(nodes0.Count, childNodes.Count); ++i) {
Index: /branches/HeuristicLab.EvolutionTracking/HeuristicLab.Problems.DataAnalysis.Symbolic/3.4/Tracking/SymbolicDataAnalysisExpressionAfterManipulatorOperator.cs
===================================================================
--- /branches/HeuristicLab.EvolutionTracking/HeuristicLab.Problems.DataAnalysis.Symbolic/3.4/Tracking/SymbolicDataAnalysisExpressionAfterManipulatorOperator.cs	(revision 11252)
+++ /branches/HeuristicLab.EvolutionTracking/HeuristicLab.Problems.DataAnalysis.Symbolic/3.4/Tracking/SymbolicDataAnalysisExpressionAfterManipulatorOperator.cs	(revision 11253)
@@ -29,55 +29,75 @@
 namespace HeuristicLab.Problems.DataAnalysis.Symbolic {
   public class SymbolicDataAnalysisExpressionAfterManipulatorOperator : AfterManipulatorOperator<ISymbolicExpressionTree> {
-    private readonly SymbolicExpressionTreeNodeSimilarityComparer comparer;
-
-    public SymbolicDataAnalysisExpressionAfterManipulatorOperator() {
-      comparer = new SymbolicExpressionTreeNodeSimilarityComparer {
-        MatchVariableNames = true,
-        MatchVariableWeights = true,
-        MatchConstantValues = true
-      };
-    }
-
     public override IOperation Apply() {
-      var vChild = (IGenealogyGraphNode<ISymbolicExpressionTree>)GenealogyGraph.GetByContent(ChildParameter.ActualValue);
-      var nodesBefore = (List<ISymbolicExpressionTreeNode>)vChild.InArcs.First().Data;
+      var childVertex = (IGenealogyGraphNode<ISymbolicExpressionTree>)GenealogyGraph.GetByContent(ChildParameter.ActualValue);
+      var nodesBefore = (List<ISymbolicExpressionTreeNode>)childVertex.InArcs.First().Data;
       var nodesAfter = ChildParameter.ActualValue.IterateNodesPrefix().ToList();
       IFragment<ISymbolicExpressionTreeNode> fragment = null;
 
-      for (int i = 0; i < Math.Min(nodesAfter.Count, nodesBefore.Count); ++i) {
-        var a = nodesAfter[i];
-        var b = nodesBefore[i];
+      // try to find if a subtree was replaced by comparing references
+      for (int i = 0; i < Math.Min(nodesBefore.Count, nodesAfter.Count); ++i) {
+        if (nodesAfter[i] != nodesBefore[i]) {
+          fragment = new Fragment<ISymbolicExpressionTreeNode> {
+            Root = nodesAfter[i],
+            Index1 = i,
+            Index2 = i
+          };
+        }
+      }
+      // if the fragment could not be identified by reference comparison, we try to identify it by comparing node labels
+      // the fragment root will be the lowest common ancestor of all the differing nodes
+      if (fragment == null) {
+        var list = new List<ISymbolicExpressionTreeNode>();
+        var root = ChildParameter.ActualValue.Root;
 
-        bool found = false;
-        if (comparer.Equals(a, b)) {
-          int m = 0;
-          for (int j = 0; j < a.SubtreeCount; ++j) {
-            if (!AreSimilar(a.GetSubtree(j), b.GetSubtree(j), comparer)) { ++m; }
-            if (m > 1) {
-              found = true;
-              break;
-            }
-          }
-          if (m == 0) {
-            // everything is similar so we skip the whole subtree
-            i += a.GetLength();
-          }
-          if (!found) continue;
+        for (int i = 0; i < Math.Min(nodesBefore.Count, nodesAfter.Count); ++i) {
+          var a = nodesAfter[i];
+          var b = nodesBefore[i];
+
+          if (!Equals(a.ToString(), b.ToString())) // label comparison is sufficient
+            list.Add(a);
         }
+
+        var lca = LowestCommonAncestor(root, list);
+        int index = nodesAfter.IndexOf(lca);
         fragment = new Fragment<ISymbolicExpressionTreeNode> {
-          Root = a,
-          Index1 = i,
-          Index2 = i
+          Root = lca,
+          Index1 = index,
+          Index2 = index
         };
-        break;
       }
 
-      vChild.InArcs.First().Data = fragment;
+      if (fragment == null)
+        throw new ArgumentNullException("Could not identify fragment.");
+
+      childVertex.InArcs.First().Data = fragment;
       return base.Apply();
     }
 
-    private bool AreSimilar(ISymbolicExpressionTreeNode a, ISymbolicExpressionTreeNode b, SymbolicExpressionTreeNodeSimilarityComparer comp) {
-      int length = a.GetLength();
-      return comparer.Equals(a, b) && length.Equals(b.GetLength()) && SymbolicExpressionTreeMatching.Match(a, b, comp) == length;
+    private static ISymbolicExpressionTreeNode LowestCommonAncestor(ISymbolicExpressionTreeNode root, List<ISymbolicExpressionTreeNode> nodes) {
+      if (nodes.Count == 0)
+        throw new ArgumentException("The nodes list should contain at least one element.");
+
+      if (nodes.Count == 1)
+        return nodes[0];
+
+      int lowestLevel = nodes.Min(x => root.GetBranchLevel(x));
+
+      // bring the nodes in the nodes to the same level (relative to the root)
+      for (int i = 0; i < nodes.Count; ++i) {
+        var node = nodes[i];
+        var level = root.GetBranchLevel(node);
+        for (int j = lowestLevel; j < level; ++j)
+          node = node.Parent;
+        nodes[i] = node;
+      }
+
+      // while not all the elements in the nodes are equal, go one level up
+      while (nodes.Any(x => x != nodes[0])) {
+        for (int i = 0; i < nodes.Count; ++i)
+          nodes[i] = nodes[i].Parent;
+      }
+
+      return nodes[0];
     }
   }
Index: /branches/HeuristicLab.EvolutionTracking/HeuristicLab.Problems.DataAnalysis.Symbolic/3.4/Tracking/SymbolicDataAnalysisExpressionBeforeManipulatorOperator.cs
===================================================================
--- /branches/HeuristicLab.EvolutionTracking/HeuristicLab.Problems.DataAnalysis.Symbolic/3.4/Tracking/SymbolicDataAnalysisExpressionBeforeManipulatorOperator.cs	(revision 11252)
+++ /branches/HeuristicLab.EvolutionTracking/HeuristicLab.Problems.DataAnalysis.Symbolic/3.4/Tracking/SymbolicDataAnalysisExpressionBeforeManipulatorOperator.cs	(revision 11253)
@@ -32,5 +32,5 @@
       var vChild = (IGenealogyGraphNode<ISymbolicExpressionTree>)GenealogyGraph.GetByContent(ChildParameter.ActualValue);
       var vClone = vChild.Parents.Last();
-      vChild.InArcs.First().Data = vClone.Content.IterateNodesPrefix().ToList();
+      vChild.InArcs.First().Data = vClone.Data.IterateNodesPrefix().ToList();
 
       var fragment = (IFragment<ISymbolicExpressionTreeNode>)vClone.InArcs.Last().Data;
@@ -38,5 +38,5 @@
         // this step must be performed because the fragment root actually references the original child (not the clone). 
         // then, a mutation operation (acting on the original child), could disrupt it
-        fragment.Root = vClone.Content.IterateNodesPrefix().ElementAt(fragment.Index1);
+        fragment.Root = vClone.Data.IterateNodesPrefix().ElementAt(fragment.Index1);
       }
 
Index: /branches/HeuristicLab.EvolutionTracking/HeuristicLab.Problems.DataAnalysis.Symbolic/3.4/Tracking/SymbolicDataAnalysisExpressionTracing.cs
===================================================================
--- /branches/HeuristicLab.EvolutionTracking/HeuristicLab.Problems.DataAnalysis.Symbolic/3.4/Tracking/SymbolicDataAnalysisExpressionTracing.cs	(revision 11252)
+++ /branches/HeuristicLab.EvolutionTracking/HeuristicLab.Problems.DataAnalysis.Symbolic/3.4/Tracking/SymbolicDataAnalysisExpressionTracing.cs	(revision 11253)
@@ -24,4 +24,5 @@
 using System.IO;
 using System.Linq;
+using HeuristicLab.Core;
 using HeuristicLab.Encodings.SymbolicExpressionTreeEncoding;
 using HeuristicLab.EvolutionTracking;
@@ -74,5 +75,5 @@
         }
         var fragmentLength = fragment.Root.GetLength();
-        var tree = node.Content;
+        var tree = node.Data;
         var subtree = tree.NodeAt(index);
         var subtreeLength = subtree.GetLength();
@@ -97,5 +98,5 @@
               // subtree contained in fragment, index stays the same
             } else {
-              index += node.Content.NodeAt(fragment.Index1).GetLength() - fragmentLength;
+              index += node.Data.NodeAt(fragment.Index1).GetLength() - fragmentLength;
             }
           } else if (subtreeIndex < fragment.Index1) {
@@ -131,5 +132,5 @@
               // fragment distinct from subtree
               node = parents[0]; // take first parent which contains the subtree
-              index += node.Content.NodeAt(fragment.Index1).GetLength() - fragmentLength; // subtreeIndex must be adjusted according to swapped fragments sizes
+              index += node.Data.NodeAt(fragment.Index1).GetLength() - fragmentLength; // subtreeIndex must be adjusted according to swapped fragments sizes
             }
             continue;
@@ -150,5 +151,5 @@
               yield return fragmentNode;
 
-              if (parents[1].Content.NodeAt(fragment.Index2).GetLength() != fragmentLength) {
+              if (parents[1].Data.NodeAt(fragment.Index2).GetLength() != fragmentLength) {
                 throw new Exception("Fragment lengths should match!");
               }
