Index: branches/HeuristicLab.EvolutionTracking/HeuristicLab.EvolutionTracking/3.4/Analyzers/GenealogyAnalyzer.cs
===================================================================
--- branches/HeuristicLab.EvolutionTracking/HeuristicLab.EvolutionTracking/3.4/Analyzers/GenealogyAnalyzer.cs	(revision 12891)
+++ branches/HeuristicLab.EvolutionTracking/HeuristicLab.EvolutionTracking/3.4/Analyzers/GenealogyAnalyzer.cs	(revision 12892)
@@ -22,5 +22,4 @@
 using System.Collections.Generic;
 using System.Linq;
-using HeuristicLab.Analysis;
 using HeuristicLab.Common;
 using HeuristicLab.Core;
@@ -34,5 +33,5 @@
   [StorableClass]
   [Item("GenealogyAnalyzer", "An analyzer which performs the necessary instrumentation to record the evolution of a genetic algorithm.")]
-  public class GenealogyAnalyzer<T> : SingleSuccessorOperator, IAnalyzer
+  public abstract class GenealogyAnalyzer<T> : SingleSuccessorOperator, IAnalyzer
   where T : class, IItem {
     #region parameter names
@@ -146,5 +145,5 @@
     #endregion properties
 
-    public GenealogyAnalyzer() {
+    protected GenealogyAnalyzer() {
       #region add parameters
       // the instrumented operators
@@ -166,8 +165,4 @@
       Parameters.Add(new ValueParameter<IManipulatorOperator<T>>(AfterManipulatorOperatorParameterName));
       #endregion add parameters
-    }
-
-    public override IDeepCloneable Clone(Cloner cloner) {
-      return new GenealogyAnalyzer<T>(this, cloner);
     }
 
@@ -246,4 +241,6 @@
     }
 
+    protected abstract void EvaluateIntermediateChildren();
+
     public override IOperation Apply() {
       IGenealogyGraph<T> genealogyGraph;
@@ -273,5 +270,5 @@
         int index = 0;
         T elite = null;
-
+        // identify previous elite individual
         for (int i = 0; i < population.Length; ++i) {
           if (genealogyGraph.GetByContent(population[i]).Rank.Equals(generation - 1)) {
@@ -281,5 +278,5 @@
           }
         }
-
+        // add current elite and connect with previous
         #region add elite in the graph and connect it with the previous elite
         if (elite != null) {
@@ -303,4 +300,7 @@
         vertex.Quality = qualities[i].Value;
       }
+      // update qualities for intermediate vertices
+      EvaluateIntermediateChildren();
+
       // remove extra graph nodes (added by the instrumented operators in the case of offspring selection)
       var pop = new HashSet<T>(population);
Index: branches/HeuristicLab.EvolutionTracking/HeuristicLab.Problems.DataAnalysis.Symbolic/3.4/Analyzers/SymbolicDataAnalysisGenealogyAnalyzer.cs
===================================================================
--- branches/HeuristicLab.EvolutionTracking/HeuristicLab.Problems.DataAnalysis.Symbolic/3.4/Analyzers/SymbolicDataAnalysisGenealogyAnalyzer.cs	(revision 12891)
+++ branches/HeuristicLab.EvolutionTracking/HeuristicLab.Problems.DataAnalysis.Symbolic/3.4/Analyzers/SymbolicDataAnalysisGenealogyAnalyzer.cs	(revision 12892)
@@ -1,15 +1,117 @@
-﻿using HeuristicLab.Core;
+﻿#region License Information
+/* HeuristicLab
+ * Copyright (C) 2002-2015 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.Common;
+using HeuristicLab.Core;
+using HeuristicLab.Data;
 using HeuristicLab.Encodings.SymbolicExpressionTreeEncoding;
 using HeuristicLab.EvolutionTracking;
+using HeuristicLab.Optimization;
+using HeuristicLab.Parameters;
 using HeuristicLab.Persistence.Default.CompositeSerializers.Storable;
 
 namespace HeuristicLab.Problems.DataAnalysis.Symbolic {
-  [Item("SymbolicDataAnalysisGenealogyAnalyzer", "")]
+  [Item("SymbolicDataAnalysisGenealogyAnalyzer", "Genealogy analyzer for symbolic data analysis problems")]
   [StorableClass]
   public class SymbolicDataAnalysisGenealogyAnalyzer : GenealogyAnalyzer<ISymbolicExpressionTree> {
-    public SymbolicDataAnalysisGenealogyAnalyzer() { }
+    private const string EvaluatorParameterName = "Evaluator";
+    private const string ProblemDataParameterName = "ProblemData";
+    private const string InterpreterParameterName = "SymbolicExpressionTreeInterpreter";
+    private const string EstimationLimitsParameterName = "EstimationLimits";
+    private const string ApplyLinearScalingParameterName = "ApplyLinearScaling";
+
+    #region parameters
+    public ILookupParameter<ISingleObjectiveEvaluator> EvaluatorParameter {
+      get {
+        return (ILookupParameter<ISingleObjectiveEvaluator>)Parameters[EvaluatorParameterName];
+      }
+    }
+
+    public ILookupParameter<IDataAnalysisProblemData> ProblemDataParameter {
+      get {
+        return (ILookupParameter<IDataAnalysisProblemData>)Parameters[ProblemDataParameterName];
+      }
+    }
+
+    public ILookupParameter<ISymbolicDataAnalysisExpressionTreeInterpreter> InterpreterParameter {
+      get {
+        return (ILookupParameter<ISymbolicDataAnalysisExpressionTreeInterpreter>)Parameters[InterpreterParameterName];
+      }
+    }
+
+    public ILookupParameter<DoubleLimit> EstimationLimitsParameter {
+      get { return (ILookupParameter<DoubleLimit>)Parameters[EstimationLimitsParameterName]; }
+    }
+
+    public ILookupParameter<BoolValue> ApplyLinearScalingParameter {
+      get { return (ILookupParameter<BoolValue>)Parameters[ApplyLinearScalingParameterName]; }
+    }
+    #endregion
+
+    public SymbolicDataAnalysisGenealogyAnalyzer() {
+      Parameters.Add(new LookupParameter<ISingleObjectiveEvaluator>(EvaluatorParameterName));
+      Parameters.Add(new LookupParameter<IDataAnalysisProblemData>(ProblemDataParameterName));
+      Parameters.Add(new LookupParameter<ISymbolicDataAnalysisExpressionTreeInterpreter>(InterpreterParameterName));
+      Parameters.Add(new LookupParameter<DoubleLimit>(EstimationLimitsParameterName));
+      Parameters.Add(new LookupParameter<BoolValue>(ApplyLinearScalingParameterName));
+    }
+
+    public SymbolicDataAnalysisGenealogyAnalyzer(SymbolicDataAnalysisGenealogyAnalyzer original, Cloner cloner)
+      : base(original, cloner) {
+    }
+
+    public override IDeepCloneable Clone(Cloner cloner) {
+      return new SymbolicDataAnalysisGenealogyAnalyzer(this, cloner);
+    }
 
     [StorableConstructor]
-    protected SymbolicDataAnalysisGenealogyAnalyzer(bool deserializing) : base(deserializing) { }
+    protected SymbolicDataAnalysisGenealogyAnalyzer(bool deserializing) : base(deserializing) {
+    }
+
+    protected override void EvaluateIntermediateChildren() {
+      var results = ResultsParameter.ActualValue;
+      var graph = (IGenealogyGraph<ISymbolicExpressionTree>)results["PopulationGraph"].Value;
+      var population = PopulationParameter.ActualValue;
+      var generation = GenerationsParameter.ActualValue.Value;
+      var problemData = ProblemDataParameter.ActualValue;
+
+      var vertices = population.Select(graph.GetByContent).Where(x => x.InDegree == 1).Select(x => x.Parents.First());
+      var intermediateVertices = vertices.Where(x => x.Rank.IsAlmost(generation - 0.5));
+
+      var classificationProblemData = problemData as IClassificationProblemData;
+      var regressionProblemData = problemData as IRegressionProblemData;
+      if (classificationProblemData != null) {
+        var evaluator = (ISymbolicDataAnalysisSingleObjectiveEvaluator<IClassificationProblemData>)EvaluatorParameter.ActualValue;
+        foreach (var v in intermediateVertices) {
+          var child = v.Data;
+          v.Quality = evaluator.Evaluate(this.ExecutionContext, child, classificationProblemData, classificationProblemData.TrainingIndices);
+        }
+      } else if (regressionProblemData != null) {
+        var evaluator = (ISymbolicDataAnalysisSingleObjectiveEvaluator<IRegressionProblemData>)EvaluatorParameter.ActualValue;
+        foreach (var v in intermediateVertices) {
+          var child = v.Data;
+          v.Quality = evaluator.Evaluate(this.ExecutionContext, child, regressionProblemData, problemData.TrainingIndices);
+        }
+      }
+    }
   }
 }
Index: branches/HeuristicLab.EvolutionTracking/HeuristicLab.Problems.DataAnalysis.Symbolic/3.4/Analyzers/SymbolicDataAnalysisGeneticOperatorImprovementAnalyzer.cs
===================================================================
--- branches/HeuristicLab.EvolutionTracking/HeuristicLab.Problems.DataAnalysis.Symbolic/3.4/Analyzers/SymbolicDataAnalysisGeneticOperatorImprovementAnalyzer.cs	(revision 12892)
+++ branches/HeuristicLab.EvolutionTracking/HeuristicLab.Problems.DataAnalysis.Symbolic/3.4/Analyzers/SymbolicDataAnalysisGeneticOperatorImprovementAnalyzer.cs	(revision 12892)
@@ -0,0 +1,192 @@
+﻿#region License Information
+/* HeuristicLab
+ * Copyright (C) 2002-2015 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.EvolutionTracking;
+using HeuristicLab.Optimization;
+using HeuristicLab.Parameters;
+using HeuristicLab.Persistence.Default.CompositeSerializers.Storable;
+
+namespace HeuristicLab.Problems.DataAnalysis.Symbolic.Analyzers {
+  [StorableClass]
+  [Item("SymbolicDataAnalysisGeneticOperatorImprovementAnalyzer", "An analyzer which records the best and average genetic operator improvement")]
+  public class SymbolicDataAnalysisGeneticOperatorImprovementAnalyzer : EvolutionTrackingAnalyzer<ISymbolicExpressionTree> {
+    public const string QualityParameterName = "Quality";
+    public const string PopulationParameterName = "SymbolicExpressionTree";
+    public const string CountIntermediateChildrenParameterName = "CountIntermediateChildren";
+
+    public IScopeTreeLookupParameter<DoubleValue> QualityParameter {
+      get { return (IScopeTreeLookupParameter<DoubleValue>)Parameters[QualityParameterName]; }
+    }
+
+    public IScopeTreeLookupParameter<ISymbolicExpressionTree> PopulationParameter {
+      get { return (IScopeTreeLookupParameter<ISymbolicExpressionTree>)Parameters[PopulationParameterName]; }
+    }
+
+    public IFixedValueParameter<BoolValue> CountIntermediateChildrenParameter {
+      get { return (IFixedValueParameter<BoolValue>)Parameters[CountIntermediateChildrenParameterName]; }
+    }
+
+    public bool CountIntermediateChildren {
+      get { return CountIntermediateChildrenParameter.Value.Value; }
+      set { CountIntermediateChildrenParameter.Value.Value = value; }
+    }
+
+    public SymbolicDataAnalysisGeneticOperatorImprovementAnalyzer() {
+      Parameters.Add(new ScopeTreeLookupParameter<ISymbolicExpressionTree>(PopulationParameterName, "The population of individuals."));
+      Parameters.Add(new ScopeTreeLookupParameter<DoubleValue>(QualityParameterName, "The individual qualities."));
+      Parameters.Add(new FixedValueParameter<BoolValue>(CountIntermediateChildrenParameterName, "Specifies whether to consider intermediate children (when crossover was followed by mutation). This should be set to false for offspring selection.", new BoolValue(true)));
+
+      CountIntermediateChildrenParameter.Hidden = true;
+    }
+
+    public SymbolicDataAnalysisGeneticOperatorImprovementAnalyzer(
+    SymbolicDataAnalysisGeneticOperatorImprovementAnalyzer original, Cloner cloner) : base(original, cloner) {
+      CountIntermediateChildren = original.CountIntermediateChildren;
+    }
+
+    public override IDeepCloneable Clone(Cloner cloner) {
+      return new SymbolicDataAnalysisGeneticOperatorImprovementAnalyzer(this, cloner);
+    }
+
+    [StorableHook(HookType.AfterDeserialization)]
+    private void AfterDeserialization() {
+      if (!Parameters.ContainsKey(CountIntermediateChildrenParameterName))
+        Parameters.Add(new FixedValueParameter<BoolValue>(CountIntermediateChildrenParameterName, "Specifies whether to consider intermediate children (when crossover was followed by mutation", new BoolValue(true)));
+      CountIntermediateChildrenParameter.Hidden = true;
+    }
+
+    public override void ClearState() {
+      base.ClearState();
+      UpdateCounter.Value = 0;
+    }
+
+    public override IOperation Apply() {
+      int updateInterval = UpdateIntervalParameter.Value.Value;
+      IntValue updateCounter = UpdateCounterParameter.ActualValue;
+      if (updateCounter == null) {
+        updateCounter = new IntValue(updateInterval);
+        UpdateCounterParameter.ActualValue = updateCounter;
+      } else updateCounter.Value++;
+
+      if (updateCounter.Value == updateInterval) {
+        updateCounter.Value = 0;
+
+        var graph = PopulationGraph;
+        if (graph == null || Generation.Value == 0)
+          return base.Apply();
+
+        var generation = Generation.Value;
+        var averageQuality = QualityParameter.ActualValue.Average(x => x.Value);
+        var population = PopulationParameter.ActualValue;
+        var populationSize = population.Length;
+
+        var vertices = population.Select(graph.GetByContent).ToList();
+        DataTable table;
+        double aac = 0; // ratio of above average children produced
+        double aacp = 0; // ratio of above average children from above average parents
+        #region crossover improvement
+        if (!Results.ContainsKey("Crossover improvement")) {
+          table = new DataTable("Crossover improvement");
+          Results.Add(new Result("Crossover improvement", table));
+          table.Rows.AddRange(
+            new[]
+            {
+              new DataRow("Average crossover improvement (root parent)") {VisualProperties = {StartIndexZero = true}},
+              new DataRow("Average crossover improvement (non-root parent)") {VisualProperties = {StartIndexZero = true}},
+              new DataRow("Average child-parents quality difference") {VisualProperties = {StartIndexZero = true}},
+              new DataRow("Best crossover improvement (root parent)") {VisualProperties = {StartIndexZero = true}},
+              new DataRow("Best crossover improvement (non-root parent)") {VisualProperties = {StartIndexZero = true}},
+              new DataRow("Above average children") {VisualProperties = {StartIndexZero = true}},
+              new DataRow("Above average children from above average parents") {VisualProperties = {StartIndexZero = true}},
+            });
+        } else {
+          table = (DataTable)Results["Crossover improvement"].Value;
+        }
+        var crossoverChildren = vertices.Where(x => x.InDegree == 2).ToList();
+        if (CountIntermediateChildren)
+          crossoverChildren.AddRange(vertices.Where(x => x.InDegree == 1).Select(v => v.Parents.First()).Where(p => p.Rank.IsAlmost(generation - 0.5))); // add intermediate children
+
+        foreach (var c in crossoverChildren) {
+          if (c.Quality > averageQuality) {
+            aac++;
+            if (c.Parents.All(x => x.Quality > averageQuality))
+              aacp++;
+          }
+        }
+        var avgRootParentQualityImprovement = crossoverChildren.Average(x => x.Quality - x.Parents.First().Quality);
+        var avgNonRootParentQualityImprovement = crossoverChildren.Average(x => x.Quality - x.Parents.Last().Quality);
+        var avgChildParentQuality = crossoverChildren.Average(x => x.Quality - x.Parents.Average(p => p.Quality));
+        var bestRootParentQualityImprovement = crossoverChildren.Max(x => x.Quality - x.Parents.First().Quality);
+        var bestNonRootParentQualityImprovement = crossoverChildren.Max(x => x.Quality - x.Parents.Last().Quality);
+        table.Rows["Average crossover improvement (root parent)"].Values.Add(avgRootParentQualityImprovement);
+        table.Rows["Average crossover improvement (non-root parent)"].Values.Add(avgNonRootParentQualityImprovement);
+        table.Rows["Best crossover improvement (root parent)"].Values.Add(bestRootParentQualityImprovement);
+        table.Rows["Best crossover improvement (non-root parent)"].Values.Add(bestNonRootParentQualityImprovement);
+        table.Rows["Average child-parents quality difference"].Values.Add(avgChildParentQuality);
+        table.Rows["Above average children"].Values.Add(aac / populationSize);
+        table.Rows["Above average children from above average parents"].Values.Add(aacp / populationSize);
+        #endregion
+
+        #region mutation improvement
+        if (!Results.ContainsKey("Mutation improvement")) {
+          table = new DataTable("Mutation improvement");
+          Results.Add(new Result("Mutation improvement", table));
+          table.Rows.AddRange(
+            new[]
+            {
+              new DataRow("Average mutation improvement") {VisualProperties = {StartIndexZero = true}},
+              new DataRow("Best mutation improvement") {VisualProperties = {StartIndexZero = true}},
+              new DataRow("Above average children") {VisualProperties = {StartIndexZero = true}},
+              new DataRow("Above average children from above average parents") {VisualProperties = {StartIndexZero = true}},
+            });
+        } else {
+          table = (DataTable)Results["Mutation improvement"].Value;
+        }
+
+        aac = 0;
+        aacp = 0;
+        var mutationChildren = vertices.Where(x => x.InDegree == 1).ToList();
+
+        foreach (var c in mutationChildren) {
+          if (c.Quality > averageQuality)
+            aac++;
+          if (c.Parents.All(x => x.Quality > averageQuality))
+            aacp++;
+        }
+        var avgMutationImprovement = mutationChildren.Average(x => x.Quality - x.Parents.First().Quality);
+        var bestMutationImprovement = mutationChildren.Max(x => x.Quality - x.Parents.First().Quality);
+
+        table.Rows["Average mutation improvement"].Values.Add(avgMutationImprovement);
+        table.Rows["Best mutation improvement"].Values.Add(bestMutationImprovement);
+        table.Rows["Above average children"].Values.Add(aac / populationSize);
+        table.Rows["Above average children from above average parents"].Values.Add(aacp / populationSize);
+        #endregion
+      }
+      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 12891)
+++ branches/HeuristicLab.EvolutionTracking/HeuristicLab.Problems.DataAnalysis.Symbolic/3.4/HeuristicLab.Problems.DataAnalysis.Symbolic-3.4.csproj	(revision 12892)
@@ -183,4 +183,5 @@
     <Compile Include="Analyzers\BuildingBlockAnalyzers\SymbolicDataAnalysisPoly10Analyzer.cs" />
     <Compile Include="Analyzers\SymbolicDataAnalysisBottomUpDiversityAnalyzer.cs" />
+    <Compile Include="Analyzers\SymbolicDataAnalysisGeneticOperatorImprovementAnalyzer.cs" />
     <Compile Include="Analyzers\SymbolicDataAnalysisSingleObjectivePruningAnalyzer.cs" />
     <Compile Include="Analyzers\SymbolicDataAnalysisGenealogyAnalyzer.cs" />
Index: branches/HeuristicLab.EvolutionTracking/HeuristicLab.Problems.DataAnalysis.Symbolic/3.4/SymbolicDataAnalysisSingleObjectiveProblem.cs
===================================================================
--- branches/HeuristicLab.EvolutionTracking/HeuristicLab.Problems.DataAnalysis.Symbolic/3.4/SymbolicDataAnalysisSingleObjectiveProblem.cs	(revision 12891)
+++ branches/HeuristicLab.EvolutionTracking/HeuristicLab.Problems.DataAnalysis.Symbolic/3.4/SymbolicDataAnalysisSingleObjectiveProblem.cs	(revision 12892)
@@ -25,6 +25,4 @@
 using HeuristicLab.Core;
 using HeuristicLab.Data;
-using HeuristicLab.Encodings.SymbolicExpressionTreeEncoding;
-using HeuristicLab.EvolutionTracking;
 using HeuristicLab.Optimization;
 using HeuristicLab.Parameters;
@@ -34,5 +32,5 @@
   [StorableClass]
   public abstract class SymbolicDataAnalysisSingleObjectiveProblem<T, U, V> : SymbolicDataAnalysisProblem<T, U, V>, ISymbolicDataAnalysisSingleObjectiveProblem
-    where T : class,IDataAnalysisProblemData
+    where T : class, IDataAnalysisProblemData
     where U : class, ISymbolicDataAnalysisSingleObjectiveEvaluator<T>
     where V : class, ISymbolicDataAnalysisSolutionCreator {
@@ -118,5 +116,5 @@
       }
 
-      foreach (var op in Operators.OfType<GenealogyAnalyzer<ISymbolicExpressionTree>>()) {
+      foreach (var op in Operators.OfType<SymbolicDataAnalysisGenealogyAnalyzer>()) {
         op.QualityParameter.ActualName = Evaluator.QualityParameter.ActualName;
         op.PopulationParameter.ActualName = Evaluator.SymbolicExpressionTreeParameter.ActualName;
Index: branches/HeuristicLab.EvolutionTracking/HeuristicLab.Problems.TravelingSalesman/3.3/Analyzers/TSPGenealogyAnalyzer.cs
===================================================================
--- branches/HeuristicLab.EvolutionTracking/HeuristicLab.Problems.TravelingSalesman/3.3/Analyzers/TSPGenealogyAnalyzer.cs	(revision 12891)
+++ branches/HeuristicLab.EvolutionTracking/HeuristicLab.Problems.TravelingSalesman/3.3/Analyzers/TSPGenealogyAnalyzer.cs	(revision 12892)
@@ -1,3 +1,4 @@
-﻿using HeuristicLab.Core;
+﻿using HeuristicLab.Common;
+using HeuristicLab.Core;
 using HeuristicLab.Encodings.PermutationEncoding;
 using HeuristicLab.EvolutionTracking;
@@ -12,4 +13,15 @@
     [StorableConstructor]
     protected TSPGenealogyAnalyzer(bool deserializing) : base(deserializing) { }
+
+    public TSPGenealogyAnalyzer(TSPGenealogyAnalyzer original, Cloner cloner) : base(original, cloner) {
+    }
+
+    public override IDeepCloneable Clone(Cloner cloner) {
+      return new TSPGenealogyAnalyzer(this, cloner);
+    }
+
+    protected override void EvaluateIntermediateChildren() {
+      throw new System.NotImplementedException();
+    }
   }
 }
