Index: /branches/PushGP/HeuristicLab.PushGP/HeuristicLab.Problems.ProgramSynthesis.Base/Extensions/NormalDistributedRandomExtensions.cs
===================================================================
--- /branches/PushGP/HeuristicLab.PushGP/HeuristicLab.Problems.ProgramSynthesis.Base/Extensions/NormalDistributedRandomExtensions.cs	(revision 15289)
+++ /branches/PushGP/HeuristicLab.PushGP/HeuristicLab.Problems.ProgramSynthesis.Base/Extensions/NormalDistributedRandomExtensions.cs	(revision 15289)
@@ -0,0 +1,11 @@
+﻿namespace HeuristicLab.Problems.ProgramSynthesis.Base.Extensions {
+  using System;
+
+  using HeuristicLab.Random;
+
+  public static class NormalDistributedRandomExtensions {
+    public static int NextRounded(this NormalDistributedRandom random) {
+      return (int)Math.Round(random.NextDouble(), 0);
+    }
+  }
+}
Index: /branches/PushGP/HeuristicLab.PushGP/HeuristicLab.Problems.ProgramSynthesis.Base/HeuristicLab.Problems.ProgramSynthesis.Base.csproj
===================================================================
--- /branches/PushGP/HeuristicLab.PushGP/HeuristicLab.Problems.ProgramSynthesis.Base/HeuristicLab.Problems.ProgramSynthesis.Base.csproj	(revision 15288)
+++ /branches/PushGP/HeuristicLab.PushGP/HeuristicLab.Problems.ProgramSynthesis.Base/HeuristicLab.Problems.ProgramSynthesis.Base.csproj	(revision 15289)
@@ -124,4 +124,5 @@
     <Compile Include="Erc\String\StringErcOptions.cs" />
     <Compile Include="Extensions\EnumerableExtensions.cs" />
+    <Compile Include="Extensions\NormalDistributedRandomExtensions.cs" />
     <Compile Include="Generators\StringGenerator.cs" />
     <Compile Include="Weighted\IWeighted.cs" />
Index: /branches/PushGP/HeuristicLab.PushGP/HeuristicLab.Problems.ProgramSynthesis/HeuristicLab.Problems.ProgramSynthesis.csproj
===================================================================
--- /branches/PushGP/HeuristicLab.PushGP/HeuristicLab.Problems.ProgramSynthesis/HeuristicLab.Problems.ProgramSynthesis.csproj	(revision 15288)
+++ /branches/PushGP/HeuristicLab.PushGP/HeuristicLab.Problems.ProgramSynthesis/HeuristicLab.Problems.ProgramSynthesis.csproj	(revision 15289)
@@ -228,15 +228,16 @@
     <Compile Include="Push\Problem\BenchmarkSuite\PlushPushBenchmarkSuiteProblem.cs" />
     <Compile Include="Push\Problem\PlushPushProblem.cs" />
-    <Compile Include="Push\Problem\BenchmarkSuite\PushBenchmarkSuiteSolution.cs" />
+    <Compile Include="Push\Solution\IPushSolution.cs" />
+    <Compile Include="Push\Solution\BenchmarkSuite\PushBenchmarkSuiteSolution.cs" />
     <Compile Include="Push\Problem\DataBounds.cs" />
-    <Compile Include="Push\Problem\EvaluationResult.cs" />
+    <Compile Include="Push\Evaluator\EvaluationResult.cs" />
     <Compile Include="Push\Individual\IndividualExtensions.cs" />
-    <Compile Include="Push\Problem\BenchmarkSuite\PushBenchmarkSuiteEvaluator.cs" />
+    <Compile Include="Push\Evaluator\PushBenchmarkSuiteEvaluator.cs" />
     <Compile Include="Push\Problem\BenchmarkSuite\IntegerVectorPushBenchmarkSuiteProblem.cs" />
-    <Compile Include="Push\Problem\IPushEvaluator.cs" />
+    <Compile Include="Push\Evaluator\IPushEvaluator.cs" />
     <Compile Include="Push\Problem\IntegerVectorPushProblem.cs" />
     <Compile Include="Properties\AssemblyInfo.cs" />
     <Compile Include="Push\Problem\PushProblemBase.cs" />
-    <Compile Include="Push\Problem\PushSolution.cs" />
+    <Compile Include="Push\Solution\PushSolution.cs" />
     <Compile Include="Push\Data\Pool\PooledObject.cs" />
     <Compile Include="Push\Selector\ICaseSingleObjectiveSelector.cs" />
@@ -266,8 +267,8 @@
       <DependentUpon>PushDebuggerView.cs</DependentUpon>
     </Compile>
-    <Compile Include="Push\Problem\BenchmarkSuite\BenchmarkSuitePushSolutionView.cs">
+    <Compile Include="Push\Solution\BenchmarkSuite\BenchmarkSuitePushSolutionView.cs">
       <SubType>UserControl</SubType>
     </Compile>
-    <Compile Include="Push\Problem\BenchmarkSuite\BenchmarkSuitePushSolutionView.Designer.cs">
+    <Compile Include="Push\Solution\BenchmarkSuite\BenchmarkSuitePushSolutionView.Designer.cs">
       <DependentUpon>BenchmarkSuitePushSolutionView.cs</DependentUpon>
     </Compile>
@@ -291,5 +292,5 @@
       <DependentUpon>PushDebuggerView.cs</DependentUpon>
     </EmbeddedResource>
-    <EmbeddedResource Include="Push\Problem\BenchmarkSuite\BenchmarkSuitePushSolutionView.resx">
+    <EmbeddedResource Include="Push\Solution\BenchmarkSuite\BenchmarkSuitePushSolutionView.resx">
       <DependentUpon>BenchmarkSuitePushSolutionView.cs</DependentUpon>
     </EmbeddedResource>
Index: /branches/PushGP/HeuristicLab.PushGP/HeuristicLab.Problems.ProgramSynthesis/Push/Analyzer/IndividualZeroErrorAnalyzer.cs
===================================================================
--- /branches/PushGP/HeuristicLab.PushGP/HeuristicLab.Problems.ProgramSynthesis/Push/Analyzer/IndividualZeroErrorAnalyzer.cs	(revision 15288)
+++ /branches/PushGP/HeuristicLab.PushGP/HeuristicLab.Problems.ProgramSynthesis/Push/Analyzer/IndividualZeroErrorAnalyzer.cs	(revision 15289)
@@ -19,10 +19,12 @@
     private const string RESULTS_PARAMETER_NAME = "Results";
     private const string INDIVIDUAL_ZERO_ERROR_PARAMETER_NAME = "ZeroErrorIndividualsPerCase";
+    private const string INDIVIDUAL_ZERO_ERROR_HISTORY_PARAMETER_NAME = INDIVIDUAL_ZERO_ERROR_PARAMETER_NAME + "History";
 
     private const string RESULT_PARAMETER_NAME = "Zero Error Individuals Per Case";
     private const string RESULT_PARAMETER_DESCRIPTION = "Relative frequency of instructions aggregated over the whole population.";
     private const string Y_AXIS_TITLE = "Count of zero error individuals";
-    private const string X_AXIS_TITLE = "Case Index";
+    private const string X_AXIS_TITLE = "Case Nr";
     private const string ROW_NAME = "Cases";
+    private const string HISTORY_TABLE_NAME = "Individual Zero Error history";
 
     public IndividualZeroErrorAnalyzer() {
@@ -31,4 +33,8 @@
         "The data table to store the count of individuals with zero error."));
 
+      Parameters.Add(new ValueLookupParameter<DataTableHistory>(
+        INDIVIDUAL_ZERO_ERROR_HISTORY_PARAMETER_NAME,
+        "The data table to store the history."));
+
       Parameters.Add(new LookupParameter<ResultCollection>(
         RESULTS_PARAMETER_NAME,
@@ -38,4 +44,24 @@
        IntegerVectorPushProblem.CaseQualitiesScopeParameterName,
        "The quality of every single training case for each individual."));
+
+      Parameters.Add(new ValueParameter<BoolValue>(
+        "StoreHistory",
+        "True if the history of the analysis should be stored.",
+        new BoolValue(false)));
+
+      Parameters.Add(new ValueParameter<IntValue>(
+        "UpdateInterval",
+        "The interval in which the analysis should be applied.",
+        new IntValue(1)));
+
+      Parameters.Add(new ValueParameter<IntValue>(
+        "UpdateCounter",
+        "The value which counts how many times the operator was called since the last update.",
+        new IntValue(0)));
+
+      IndividualZeroErrorParameter.Hidden = true;
+      IndividualZeroErrorHistoryParameter.Hidden = true;
+      ResultsParameter.Hidden = true;
+      UpdateCounterParameter.Hidden = true;
     }
 
@@ -51,4 +77,17 @@
     public bool EnabledByDefault { get { return true; } }
 
+    public ValueParameter<BoolValue> StoreHistoryParameter
+    {
+      get { return (ValueParameter<BoolValue>)Parameters["StoreHistory"]; }
+    }
+    public ValueParameter<IntValue> UpdateIntervalParameter
+    {
+      get { return (ValueParameter<IntValue>)Parameters["UpdateInterval"]; }
+    }
+    public ValueParameter<IntValue> UpdateCounterParameter
+    {
+      get { return (ValueParameter<IntValue>)Parameters["UpdateCounter"]; }
+    }
+
     public ILookupParameter<DataTable> IndividualZeroErrorParameter
     {
@@ -56,4 +95,9 @@
     }
 
+    public ValueLookupParameter<DataTableHistory> IndividualZeroErrorHistoryParameter
+    {
+      get { return (ValueLookupParameter<DataTableHistory>)Parameters[INDIVIDUAL_ZERO_ERROR_HISTORY_PARAMETER_NAME]; }
+    }
+
     public ILookupParameter<ResultCollection> ResultsParameter
     {
@@ -67,4 +111,11 @@
 
     public override IOperation Apply() {
+      UpdateCounterParameter.Value.Value++;
+      // the analyzer runs periodically, every 'updateInterval' times
+      if (UpdateCounterParameter.Value.Value != UpdateIntervalParameter.Value.Value)
+        return base.Apply();
+
+      UpdateCounterParameter.Value.Value = 0; // reset counter
+
       var caseQualitiesPerIndividual = CaseQualitiesParameter.ActualValue;
       var caseCount = caseQualitiesPerIndividual[0].Length;
@@ -80,5 +131,9 @@
             YAxisTitle = Y_AXIS_TITLE,
             XAxisTitle = X_AXIS_TITLE,
-            XAxisMinimumFixedValue = 0,
+            YAxisMinimumFixedValue = 0,
+            YAxisMaximumFixedValue = 1,
+            YAxisMinimumAuto = false,
+            SecondYAxisMaximumAuto = false,
+            XAxisMinimumFixedValue = 1,
             XAxisMaximumFixedValue = caseCount,
             XAxisMaximumAuto = false,
@@ -100,5 +155,5 @@
               StartIndexZero = true,
               IsVisibleInLegend = false,
-              ChartType = DataRowVisualProperties.DataRowChartType.Bars,
+              ChartType = DataRowVisualProperties.DataRowChartType.Columns,
             }
         };
@@ -107,10 +162,5 @@
       }
 
-      var caseCountChanged = row.Values.Count != caseCount;
-
-      if (caseCountChanged) {
-        individualZeroErrorCounts.VisualProperties.XAxisMaximumFixedValue = caseCount;
-        row.Values.Clear();
-      }
+      row.Values.Clear();
 
       for (var i = 0; i < caseCount; i++) {
@@ -124,8 +174,26 @@
         }
 
-        if (caseCountChanged)
-          row.Values.Add(count);
-        else
-          row.Values[i] = count;
+        var relativeCount = count / (double)caseQualitiesPerIndividual.Length;
+
+        row.Values.Add(relativeCount);
+      }
+
+      var storeHistory = StoreHistoryParameter.Value.Value;
+
+      if (storeHistory) {
+        var history = IndividualZeroErrorHistoryParameter.ActualValue;
+
+        if (history == null) {
+          history = new DataTableHistory();
+          IndividualZeroErrorHistoryParameter.ActualValue = history;
+        }
+
+        history.Add((DataTable)individualZeroErrorCounts.Clone());
+
+        if (!results.ContainsKey(HISTORY_TABLE_NAME)) {
+          results.Add(new Result(HISTORY_TABLE_NAME, history));
+        } else {
+          results[HISTORY_TABLE_NAME].Value = history;
+        }
       }
 
Index: /branches/PushGP/HeuristicLab.PushGP/HeuristicLab.Problems.ProgramSynthesis/Push/Analyzer/IndividualZeroErrorDistributionAnalyzer.cs
===================================================================
--- /branches/PushGP/HeuristicLab.PushGP/HeuristicLab.Problems.ProgramSynthesis/Push/Analyzer/IndividualZeroErrorDistributionAnalyzer.cs	(revision 15288)
+++ /branches/PushGP/HeuristicLab.PushGP/HeuristicLab.Problems.ProgramSynthesis/Push/Analyzer/IndividualZeroErrorDistributionAnalyzer.cs	(revision 15289)
@@ -20,9 +20,11 @@
     private const string RESULTS_PARAMETER_NAME = "Results";
     private const string INDIVIDUAL_ZERO_ERROR_PARAMETER_NAME = "ZeroErrorIndividualsPerCaseDistribution";
+    private const string INDIVIDUAL_ZERO_ERROR_HISTORY_PARAMETER_NAME = "ZeroErrorIndividualsPerCaseDistributionHistory";
 
+    private const string HISTORY_TABLE_NAME = "Individual Zero Error Distribution History";
     private const string RESULT_PARAMETER_NAME = "Zero Error Individual Per Case Distribution";
     private const string RESULT_PARAMETER_DESCRIPTION = "Relative frequency of instructions aggregated over the whole population.";
     private const string Y_AXIS_TITLE = "Number of zero error cases";
-    private const string X_AXIS_TITLE = "Number of individuals";
+    private const string X_AXIS_TITLE = "Individuals Nr";
     private const string ROW_NAME = "Cases";
 
@@ -31,4 +33,8 @@
         INDIVIDUAL_ZERO_ERROR_PARAMETER_NAME,
         "The data table to store the count of individuals with zero error."));
+
+      Parameters.Add(new ValueLookupParameter<DataTableHistory>(
+        INDIVIDUAL_ZERO_ERROR_HISTORY_PARAMETER_NAME,
+        "The data table to store the history."));
 
       Parameters.Add(new LookupParameter<ResultCollection>(
@@ -39,7 +45,27 @@
        IntegerVectorPushProblem.CaseQualitiesScopeParameterName,
        "The quality of every single training case for each individual."));
+
+      Parameters.Add(new ValueParameter<BoolValue>(
+        "StoreHistory",
+        "True if the history of the analysis should be stored.",
+        new BoolValue(false)));
+
+      Parameters.Add(new ValueParameter<IntValue>(
+        "UpdateInterval",
+        "The interval in which the analysis should be applied.",
+        new IntValue(1)));
+
+      Parameters.Add(new ValueParameter<IntValue>(
+        "UpdateCounter",
+        "The value which counts how many times the operator was called since the last update.",
+        new IntValue(0)));
+
+      IndividualZeroErrorDistributionParameter.Hidden = true;
+      IndividualZeroErrorDistributionHistoryParameter.Hidden = true;
+      ResultsParameter.Hidden = true;
+      UpdateCounterParameter.Hidden = true;
     }
 
-    [StorableConstructorAttribute]
+    [StorableConstructor]
     public IndividualZeroErrorDistributionAnalyzer(bool deserializing) : base(deserializing) { }
 
@@ -52,7 +78,25 @@
     public bool EnabledByDefault { get { return true; } }
 
+    public ValueParameter<BoolValue> StoreHistoryParameter
+    {
+      get { return (ValueParameter<BoolValue>)Parameters["StoreHistory"]; }
+    }
+    public ValueParameter<IntValue> UpdateIntervalParameter
+    {
+      get { return (ValueParameter<IntValue>)Parameters["UpdateInterval"]; }
+    }
+    public ValueParameter<IntValue> UpdateCounterParameter
+    {
+      get { return (ValueParameter<IntValue>)Parameters["UpdateCounter"]; }
+    }
+
     public ILookupParameter<DataTable> IndividualZeroErrorDistributionParameter
     {
       get { return (ILookupParameter<DataTable>)Parameters[INDIVIDUAL_ZERO_ERROR_PARAMETER_NAME]; }
+    }
+
+    public ValueLookupParameter<DataTableHistory> IndividualZeroErrorDistributionHistoryParameter
+    {
+      get { return (ValueLookupParameter<DataTableHistory>)Parameters[INDIVIDUAL_ZERO_ERROR_HISTORY_PARAMETER_NAME]; }
     }
 
@@ -68,4 +112,11 @@
 
     public override IOperation Apply() {
+      UpdateCounterParameter.Value.Value++;
+      // the analyzer runs periodically, every 'updateInterval' times
+      if (UpdateCounterParameter.Value.Value != UpdateIntervalParameter.Value.Value)
+        return base.Apply();
+
+      UpdateCounterParameter.Value.Value = 0; // reset counter
+
       var caseQualitiesPerIndividual = CaseQualitiesParameter.ActualValue;
       var individualCount = caseQualitiesPerIndividual.Length;
@@ -82,6 +133,11 @@
             YAxisTitle = Y_AXIS_TITLE,
             XAxisTitle = X_AXIS_TITLE,
-            XAxisMinimumFixedValue = 0,
-            XAxisMaximumAuto = true,
+            YAxisMaximumFixedValue = 1,
+            YAxisMinimumFixedValue = 0,
+            YAxisMaximumAuto = false,
+            YAxisMinimumAuto = false,
+            XAxisMinimumFixedValue = 1,
+            XAxisMaximumFixedValue = individualCount,
+            XAxisMaximumAuto = false,
             XAxisMinimumAuto = false,
           }
@@ -101,5 +157,5 @@
               StartIndexZero = true,
               IsVisibleInLegend = false,
-              ChartType = DataRowVisualProperties.DataRowChartType.Histogram,
+              ChartType = DataRowVisualProperties.DataRowChartType.Columns,
             }
         };
@@ -108,26 +164,30 @@
       }
 
-      var caseCountChanged = row.Values.Count != caseCount;
+      row.Values.Clear();
 
-      if (caseCountChanged) {
-        row.Values.Clear();
+      for (var i = 0; i < caseQualitiesPerIndividual.Length; i++) {
+        var count = caseQualitiesPerIndividual[i].Count(q => q == 0.0);
+        var ratio = count / (double)caseCount;
+
+        row.Values.Add(ratio);
       }
 
-      // key represents the number of cases with zero error
-      // value represents the number of individuals with key cases with zero error
-      var distribution = caseQualitiesPerIndividual
-              .Select(individual => individual.Count(x => x == 0.0))
-              .GroupBy(x => x)
-              .ToDictionary(x => x.Key, x => x.Count());
+      var storeHistory = StoreHistoryParameter.Value.Value;
 
-      for (var i = 0; i < caseCount; i++) {
-        int count;
-        distribution.TryGetValue(i, out count);
-        var x = count / (double)individualCount;
+      if (storeHistory) {
+        var history = IndividualZeroErrorDistributionHistoryParameter.ActualValue;
 
-        if (caseCountChanged)
-          row.Values.Add(x);
-        else
-          row.Values[i] = x;
+        if (history == null) {
+          history = new DataTableHistory();
+          IndividualZeroErrorDistributionHistoryParameter.ActualValue = history;
+        }
+
+        history.Add((DataTable)individualZeroErrorDistribution.Clone());
+
+        if (!results.ContainsKey(HISTORY_TABLE_NAME)) {
+          results.Add(new Result(HISTORY_TABLE_NAME, history));
+        } else {
+          results[HISTORY_TABLE_NAME].Value = history;
+        }
       }
 
Index: /branches/PushGP/HeuristicLab.PushGP/HeuristicLab.Problems.ProgramSynthesis/Push/Analyzer/PushExpressionFrequencyAnalyzer.cs
===================================================================
--- /branches/PushGP/HeuristicLab.PushGP/HeuristicLab.Problems.ProgramSynthesis/Push/Analyzer/PushExpressionFrequencyAnalyzer.cs	(revision 15288)
+++ /branches/PushGP/HeuristicLab.PushGP/HeuristicLab.Problems.ProgramSynthesis/Push/Analyzer/PushExpressionFrequencyAnalyzer.cs	(revision 15289)
@@ -1,4 +1,5 @@
 ﻿namespace HeuristicLab.Problems.ProgramSynthesis.Push.Analyzer {
   using System;
+  using System.Collections.Generic;
   using System.Linq;
 
@@ -14,7 +15,7 @@
   using HeuristicLab.Problems.ProgramSynthesis.Push.Attributes;
   using HeuristicLab.Problems.ProgramSynthesis.Push.Configuration;
+  using HeuristicLab.Problems.ProgramSynthesis.Push.Encoding;
   using HeuristicLab.Problems.ProgramSynthesis.Push.Expressions;
   using HeuristicLab.Problems.ProgramSynthesis.Push.Individual;
-  using HeuristicLab.Problems.ProgramSynthesis.Push.ObjectPools.Random;
 
   /// <summary>
@@ -24,5 +25,4 @@
   [StorableClass]
   public class PushExpressionFrequencyAnalyzer : SingleSuccessorOperator, IPushExpressionAnalyzer {
-    private readonly SeededRandomPool randomPool = new SeededRandomPool();
 
     private const string PUSH_CONFIGURATION_PARAMETER_NAME = "PushConfiguration";
@@ -40,4 +40,5 @@
       Parameters.Add(new LookupParameter<IReadOnlyPushConfiguration>(PUSH_CONFIGURATION_PARAMETER_NAME, "The current specified push configuration."));
       Parameters.Add(new ScopeTreeLookupParameter<IntegerVector>(INTEGER_VECTOR_PARAMETER_NAME, "The integer vectors to analyze."));
+      Parameters.Add(new ScopeTreeLookupParameter<PlushVector>("Plush", "The plush vectors to analyze."));
       Parameters.Add(new LookupParameter<DataTable>(EXPRESSION_FREQUENCIES_PARAMETER_NAME, "The data table to store the instruction frequencies."));
       Parameters.Add(new LookupParameter<ResultCollection>(RESULTS_PARAMETER_NAME, "The result collection where the symbol frequencies should be stored."));
@@ -60,4 +61,9 @@
     {
       get { return (ILookupParameter<IReadOnlyPushConfiguration>)Parameters[PUSH_CONFIGURATION_PARAMETER_NAME]; }
+    }
+
+    public IScopeTreeLookupParameter<PlushVector> PlushVectorParameter
+    {
+      get { return (IScopeTreeLookupParameter<PlushVector>)Parameters["Plush"]; }
     }
 
@@ -95,15 +101,15 @@
     public override IOperation Apply() {
       var config = PushConfigurationParameter.ActualValue;
-      var integerVectors = IntegerVectorParameter.ActualValue;
 
-      randomPool.Seed = config.Seed;
+      IReadOnlyList<PushProgram> pushPrograms = null;
 
-      var pushPrograms = integerVectors.Select(iv => {
-        var random = randomPool.ResetAndAllocate();
-        var program = iv.ToPushProgram(config, random);
-        randomPool.Free(random);
-
-        return program;
-      });
+      if (IntegerVectorParameter.ActualValue.Length > 0) {
+        pushPrograms = IntegerVectorParameter.ActualValue.Select(iv => iv.ToPushProgram(config)).ToList();
+      } else if (PlushVectorParameter.ActualValue.Length > 0) {
+        pushPrograms = PlushVectorParameter.ActualValue.Select(pv => pv.PushProgram).ToList();
+      } else {
+        // nothing to do
+        return base.Apply();
+      }
 
       var results = ResultsParameter.ActualValue;
@@ -136,5 +142,5 @@
           group => group.Count());
 
-      var totalNumberofExpressions = Math.Max(1.0, expressionFrequencies.Values.Sum());
+      var totalNumberOfExpressions = Math.Max(1.0, expressionFrequencies.Values.Sum());
 
       // all rows must have the same number of values so we can just take the first
@@ -152,5 +158,5 @@
         }
 
-        frequencies.Rows[pair.Key].Values.Add(Math.Round(pair.Value / totalNumberofExpressions, 3));
+        frequencies.Rows[pair.Key].Values.Add(Math.Round(pair.Value / totalNumberOfExpressions, 3));
       }
 
Index: /branches/PushGP/HeuristicLab.PushGP/HeuristicLab.Problems.ProgramSynthesis/Push/Attributes/PushStackAttribute.cs
===================================================================
--- /branches/PushGP/HeuristicLab.PushGP/HeuristicLab.Problems.ProgramSynthesis/Push/Attributes/PushStackAttribute.cs	(revision 15288)
+++ /branches/PushGP/HeuristicLab.PushGP/HeuristicLab.Problems.ProgramSynthesis/Push/Attributes/PushStackAttribute.cs	(revision 15289)
@@ -7,4 +7,5 @@
   public class PushStackAttribute : Attribute {
     public readonly StackTypes StackType;
+
     public PushStackAttribute(StackTypes stackType) {
       StackType = stackType;
Index: /branches/PushGP/HeuristicLab.PushGP/HeuristicLab.Problems.ProgramSynthesis/Push/Configuration/IEnabledExpressionsConfiguration.cs
===================================================================
--- /branches/PushGP/HeuristicLab.PushGP/HeuristicLab.Problems.ProgramSynthesis/Push/Configuration/IEnabledExpressionsConfiguration.cs	(revision 15288)
+++ /branches/PushGP/HeuristicLab.PushGP/HeuristicLab.Problems.ProgramSynthesis/Push/Configuration/IEnabledExpressionsConfiguration.cs	(revision 15289)
@@ -20,4 +20,5 @@
     int InExpressionCount { get; }
 
+
     IReadOnlyList<string> EnabledExpressions { get; }
     IReadOnlyDictionary<StackTypes, int> ExpressionsPerStackCount { get; }
Index: /branches/PushGP/HeuristicLab.PushGP/HeuristicLab.Problems.ProgramSynthesis/Push/Configuration/IReadonlyPushConfiguration.cs
===================================================================
--- /branches/PushGP/HeuristicLab.PushGP/HeuristicLab.Problems.ProgramSynthesis/Push/Configuration/IReadonlyPushConfiguration.cs	(revision 15288)
+++ /branches/PushGP/HeuristicLab.PushGP/HeuristicLab.Problems.ProgramSynthesis/Push/Configuration/IReadonlyPushConfiguration.cs	(revision 15289)
@@ -1,4 +1,3 @@
 ﻿namespace HeuristicLab.Problems.ProgramSynthesis.Push.Configuration {
-  using System.Collections.Generic;
   using Base.Erc;
 
@@ -6,5 +5,4 @@
 
   public interface IReadOnlyPushConfiguration : IReadOnlyExpressionsConfiguration {
-    int Seed { get; }
     int EvalPushLimit { get; }
     int MaxDepth { get; }
@@ -18,5 +16,4 @@
     double ParenthesesCloseBiasLevel { get; }
     IReadOnlyErcOptions ErcOptions { get; }
-    IReadOnlyList<string> EnabledExpressions { get; }
     string FloatStringFormat { get; }
 
Index: /branches/PushGP/HeuristicLab.PushGP/HeuristicLab.Problems.ProgramSynthesis/Push/Configuration/PushConfiguration.cs
===================================================================
--- /branches/PushGP/HeuristicLab.PushGP/HeuristicLab.Problems.ProgramSynthesis/Push/Configuration/PushConfiguration.cs	(revision 15288)
+++ /branches/PushGP/HeuristicLab.PushGP/HeuristicLab.Problems.ProgramSynthesis/Push/Configuration/PushConfiguration.cs	(revision 15289)
@@ -52,5 +52,5 @@
 
 
-    IReadOnlyList<string> IReadOnlyPushConfiguration.EnabledExpressions { get { return enabledExpressions; } }
+    IReadOnlyList<string> IReadOnlyExpressionsConfiguration.EnabledExpressions { get { return enabledExpressions; } }
 
     [Storable]
Index: /branches/PushGP/HeuristicLab.PushGP/HeuristicLab.Problems.ProgramSynthesis/Push/Configuration/PushConfigurationParameterCollection.cs
===================================================================
--- /branches/PushGP/HeuristicLab.PushGP/HeuristicLab.Problems.ProgramSynthesis/Push/Configuration/PushConfigurationParameterCollection.cs	(revision 15288)
+++ /branches/PushGP/HeuristicLab.PushGP/HeuristicLab.Problems.ProgramSynthesis/Push/Configuration/PushConfigurationParameterCollection.cs	(revision 15289)
@@ -154,5 +154,5 @@
     }
 
-    IReadOnlyList<string> IReadOnlyPushConfiguration.EnabledExpressions
+    IReadOnlyList<string> IReadOnlyExpressionsConfiguration.EnabledExpressions
     {
       get
Index: /branches/PushGP/HeuristicLab.PushGP/HeuristicLab.Problems.ProgramSynthesis/Push/Constants/PushEnvironment.cs
===================================================================
--- /branches/PushGP/HeuristicLab.PushGP/HeuristicLab.Problems.ProgramSynthesis/Push/Constants/PushEnvironment.cs	(revision 15288)
+++ /branches/PushGP/HeuristicLab.PushGP/HeuristicLab.Problems.ProgramSynthesis/Push/Constants/PushEnvironment.cs	(revision 15289)
@@ -17,5 +17,6 @@
     public const string CharSymbolStr = "'";
     public const string StringSymbolStr = "\"";
-    public const string NewLine = "\n";
+    public const char NewLine = '\n';
+    public const string NewLineStr = "\n";
   }
 }
Index: /branches/PushGP/HeuristicLab.PushGP/HeuristicLab.Problems.ProgramSynthesis/Push/Crossover/AlternationCrossover.cs
===================================================================
--- /branches/PushGP/HeuristicLab.PushGP/HeuristicLab.Problems.ProgramSynthesis/Push/Crossover/AlternationCrossover.cs	(revision 15288)
+++ /branches/PushGP/HeuristicLab.PushGP/HeuristicLab.Problems.ProgramSynthesis/Push/Crossover/AlternationCrossover.cs	(revision 15289)
@@ -10,4 +10,5 @@
   using HeuristicLab.Parameters;
   using HeuristicLab.Persistence.Default.CompositeSerializers.Storable;
+  using HeuristicLab.Problems.ProgramSynthesis.Base.Extensions;
   using HeuristicLab.Problems.ProgramSynthesis.Push.Encoding;
   using HeuristicLab.Random;
@@ -23,8 +24,11 @@
     public AlternationCrossover() {
       Parameters.Add(new LookupParameter<IRandom>("Random", "The pseudo random number generator which should be used for stochastic crossover operators."));
+
       Parameters.Add(new ScopeTreeLookupParameter<PlushVector>("Parents", "The parent vectors which should be crossed."));
       ParentsParameter.ActualName = "PlushVector";
+
       Parameters.Add(new LookupParameter<PlushVector>("Child", "The child vector resulting from the crossover."));
       ChildParameter.ActualName = "PlushVector";
+
       Parameters.Add(new FixedValueParameter<PercentValue>("AlternationRate", "Specifies the probability of switching to another parent.", new PercentValue(0.5)));
       Parameters.Add(new FixedValueParameter<DoubleValue>("AlignmentDeviation", "When alternating between parents, the index at which to continue copying may be offset backward or forward some amount based on a random sample from a normal distribution with mean 0 and standard deviation set by the alignment deviation parameter", new DoubleValue(1.0)));
@@ -90,15 +94,24 @@
 
     public sealed override IOperation InstrumentedApply() {
-      ChildParameter.ActualValue = Cross(RandomParameter.ActualValue, ParentsParameter.ActualValue);
+      ChildParameter.ActualValue = Cross(
+        RandomParameter.ActualValue,
+        ParentsParameter.ActualValue,
+        AlternationRate,
+        MaxLength,
+        AlignmentDeviation);
       return base.InstrumentedApply();
     }
 
-    private PlushVector Cross(IRandom random, ItemArray<PlushVector> parents) {
-      var normalDistributedRandom = new NormalDistributedRandom(random, Mean, AlignmentDeviation);
+    private static PlushVector Cross(
+      IRandom random,
+      ItemArray<PlushVector> parents,
+      double alternationRate,
+      int maxChildLength,
+      double alignmentDeviation) {
+      var normalDistributedRandom = new NormalDistributedRandom(random, Mean, alignmentDeviation);
       var maxLength = parents.Max(p => p.Entries.Count);
       var parentIndex = random.Next(0, 2);
       var parent = parents[parentIndex];
       var child = new PlushVector(maxLength);
-      var maxChildLength = MaxLength;
 
       for (var i = 0; i < maxLength && child.Entries.Count <= maxChildLength; i++) {
@@ -109,8 +122,8 @@
 
         // switch parent?
-        if (random.NextDouble() < AlternationRate) {
+        if (random.NextDouble() < alternationRate) {
           parentIndex = parentIndex == 0 ? 1 : 0;
           parent = parents[parentIndex];
-          i += normalDistributedRandom.Next();
+          i += normalDistributedRandom.NextRounded();
           i = Math.Max(i, 0);
         }
Index: /branches/PushGP/HeuristicLab.PushGP/HeuristicLab.Problems.ProgramSynthesis/Push/Encoding/PlushEncoding.cs
===================================================================
--- /branches/PushGP/HeuristicLab.PushGP/HeuristicLab.Problems.ProgramSynthesis/Push/Encoding/PlushEncoding.cs	(revision 15288)
+++ /branches/PushGP/HeuristicLab.PushGP/HeuristicLab.Problems.ProgramSynthesis/Push/Encoding/PlushEncoding.cs	(revision 15289)
@@ -34,4 +34,9 @@
       inInstructionProbabilityParameter = new FixedValueParameter<PercentValue>(Name + ".InInstructionProbability");
 
+      Parameters.Add(minLengthParameter);
+      Parameters.Add(maxLengthParameter);
+      Parameters.Add(minCloseParameter);
+      Parameters.Add(maxCloseParameter);
+      Parameters.Add(closeBiasLevelParameter);
       Parameters.Add(instructionsParameter);
       Parameters.Add(ercOptionsParameter);
@@ -371,4 +376,5 @@
         creator.MinCloseParameter.ActualName = MinCloseParameter.Name;
         creator.MaxCloseParameter.ActualName = MinCloseParameter.Name;
+        creator.CloseBiasLevelParameter.ActualName = CloseBiasLevelParameter.Name;
         creator.ErcOptionsParameter.ActualName = ErcOptionsParameter.Name;
         creator.InstructionsParameter.ActualName = InstructionsParameter.Name;
Index: /branches/PushGP/HeuristicLab.PushGP/HeuristicLab.Problems.ProgramSynthesis/Push/Encoding/PlushVector.cs
===================================================================
--- /branches/PushGP/HeuristicLab.PushGP/HeuristicLab.Problems.ProgramSynthesis/Push/Encoding/PlushVector.cs	(revision 15288)
+++ /branches/PushGP/HeuristicLab.PushGP/HeuristicLab.Problems.ProgramSynthesis/Push/Encoding/PlushVector.cs	(revision 15289)
@@ -26,4 +26,6 @@
 
     public PlushVector(PlushVector origin, Cloner cloner) : base(origin, cloner) {
+      entries = new List<PlushEntry>(origin.entries);
+      pushProgram = origin.pushProgram;
     }
 
Index: /branches/PushGP/HeuristicLab.PushGP/HeuristicLab.Problems.ProgramSynthesis/Push/Evaluator/EvaluationResult.cs
===================================================================
--- /branches/PushGP/HeuristicLab.PushGP/HeuristicLab.Problems.ProgramSynthesis/Push/Evaluator/EvaluationResult.cs	(revision 15289)
+++ /branches/PushGP/HeuristicLab.PushGP/HeuristicLab.Problems.ProgramSynthesis/Push/Evaluator/EvaluationResult.cs	(revision 15289)
@@ -0,0 +1,11 @@
+﻿namespace HeuristicLab.Problems.ProgramSynthesis.Push.Evaluator {
+  public class EvaluationResult {
+    public EvaluationResult(int exampleCount) {
+      ExampleQualities = new double[exampleCount];
+    }
+
+
+    public double AvgQuality { get; set; }
+    public double[] ExampleQualities { get; set; }
+  }
+}
Index: /branches/PushGP/HeuristicLab.PushGP/HeuristicLab.Problems.ProgramSynthesis/Push/Evaluator/IPushEvaluator.cs
===================================================================
--- /branches/PushGP/HeuristicLab.PushGP/HeuristicLab.Problems.ProgramSynthesis/Push/Evaluator/IPushEvaluator.cs	(revision 15289)
+++ /branches/PushGP/HeuristicLab.PushGP/HeuristicLab.Problems.ProgramSynthesis/Push/Evaluator/IPushEvaluator.cs	(revision 15289)
@@ -0,0 +1,16 @@
+﻿namespace HeuristicLab.Problems.ProgramSynthesis.Push.Evaluator {
+  using HeuristicLab.Common;
+  using HeuristicLab.Core;
+  using HeuristicLab.Problems.ProgramSynthesis.Push.Configuration;
+  using HeuristicLab.Problems.ProgramSynthesis.Push.Expressions;
+  using HeuristicLab.Problems.ProgramSynthesis.Push.Interpreter;
+
+  public interface IPushEvaluator : IDeepCloneable {
+    EvaluationResult EvaluateTest(IReadOnlyPushConfiguration config, PushProgram program, IRandom random);
+    EvaluationResult EvaluateTest(IPushInterpreter interpreter, PushProgram program);
+    EvaluationResult EvaluateTest(PushInterpreterPool pool, PushProgram program, IRandom random);
+    EvaluationResult EvaluateTraining(IReadOnlyPushConfiguration config, PushProgram program, IRandom random);
+    EvaluationResult EvaluateTraining(IPushInterpreter interpreter, PushProgram program);
+    EvaluationResult EvaluateTraining(PushInterpreterPool pool, PushProgram program, IRandom random);
+  }
+}
Index: /branches/PushGP/HeuristicLab.PushGP/HeuristicLab.Problems.ProgramSynthesis/Push/Evaluator/PushBenchmarkSuiteEvaluator.cs
===================================================================
--- /branches/PushGP/HeuristicLab.PushGP/HeuristicLab.Problems.ProgramSynthesis/Push/Evaluator/PushBenchmarkSuiteEvaluator.cs	(revision 15289)
+++ /branches/PushGP/HeuristicLab.PushGP/HeuristicLab.Problems.ProgramSynthesis/Push/Evaluator/PushBenchmarkSuiteEvaluator.cs	(revision 15289)
@@ -0,0 +1,341 @@
+﻿namespace HeuristicLab.Problems.ProgramSynthesis.Push.Evaluator {
+  using System;
+  using System.Collections.Generic;
+  using System.Globalization;
+
+  using HeuristicLab.BenchmarkSuite;
+  using HeuristicLab.Common;
+  using HeuristicLab.Core;
+  using HeuristicLab.Parameters;
+  using HeuristicLab.Persistence.Default.CompositeSerializers.Storable;
+  using HeuristicLab.Problems.ProgramSynthesis.Push.Configuration;
+  using HeuristicLab.Problems.ProgramSynthesis.Push.Expressions;
+  using HeuristicLab.Problems.ProgramSynthesis.Push.Interpreter;
+  using HeuristicLab.Problems.ProgramSynthesis.Push.Problem;
+  using HeuristicLab.Problems.ProgramSynthesis.Push.Stack;
+
+  [StorableClass]
+  public class PushBenchmarkSuiteEvaluator : ParameterizedNamedItem, IPushEvaluator {
+
+    private const string DataBoundsParameterName = "DataBounds";
+    private const string DataParameterName = "Data";
+    private const string DataParameterDescription = "Program Synthesis";
+
+    public PushBenchmarkSuiteEvaluator() {
+      Parameters.Add(new FixedValueParameter<DataBounds>(DataBoundsParameterName));
+
+      Parameters.Add(new ValueParameter<ProblemData>(
+        DataParameterName,
+        DataParameterDescription));
+    }
+
+    public PushBenchmarkSuiteEvaluator(ProblemData data) : this() {
+      LoadData(data);
+    }
+
+    [StorableConstructor]
+    public PushBenchmarkSuiteEvaluator(bool deserializing) : base(deserializing) { }
+
+    public PushBenchmarkSuiteEvaluator(PushBenchmarkSuiteEvaluator origin, Cloner cloner) : base(origin, cloner) {
+      Data = cloner.Clone(origin.Data);
+    }
+
+    public override IDeepCloneable Clone(Cloner cloner) {
+      return new PushBenchmarkSuiteEvaluator(this, cloner);
+    }
+
+    public IValueParameter<ProblemData> DataParameter
+    {
+      get { return (IValueParameter<ProblemData>)Parameters[DataParameterName]; }
+    }
+
+    public ProblemData Data
+    {
+      get { return DataParameter.Value; }
+      set { DataParameter.Value = value; }
+    }
+
+    public IValueParameter<DataBounds> DataBoundsParameter
+    {
+      get { return (IValueParameter<DataBounds>)Parameters[DataBoundsParameterName]; }
+    }
+
+    public DataBounds DataBounds
+    {
+      get { return DataBoundsParameter.Value; }
+      set { DataBoundsParameter.Value = value; }
+    }
+
+    public void LoadData(ProblemData data) {
+      Data = data;
+
+      DataBounds.TrainingRange.Start = 0;
+      DataBounds.TrainingRange.End = Data.TrainingCount;
+      DataBounds.TestRange.Start = Data.TrainingCount;
+      DataBounds.TestRange.End = Data.TrainingCount + Data.TestCount;
+    }
+
+    public EvaluationResult Evaluate(IPushInterpreter interpreter, PushProgram program, int start, int end) {
+      var length = end - start;
+      if (length <= 0) return null;
+
+      var evaluationResult = new EvaluationResult(length);
+
+      for (var i = start; i < end; i++) {
+        var result = Evaluate(interpreter, program, i);
+        evaluationResult.ExampleQualities[i - start] = result;
+        evaluationResult.AvgQuality += result;
+        interpreter.Reset();
+      }
+
+      evaluationResult.AvgQuality /= length;
+
+      return evaluationResult;
+    }
+
+    public EvaluationResult EvaluateTest(IPushInterpreter interpreter, PushProgram program) {
+      return Evaluate(interpreter, program, DataBounds.TestRange.Start, DataBounds.TestRange.End);
+    }
+
+    public EvaluationResult EvaluateTest(IReadOnlyPushConfiguration config, PushProgram program, IRandom random) {
+      var interpreter = new PushInterpreter(config, random);
+      return EvaluateTest(interpreter, program);
+    }
+
+    public EvaluationResult EvaluateTest(PushInterpreterPool pool, PushProgram program, IRandom random) {
+      using (var interpreter = pool.Create(random)) {
+        return EvaluateTest(interpreter, program);
+      }
+    }
+
+    public EvaluationResult EvaluateTraining(IPushInterpreter interpreter, PushProgram program) {
+      return Evaluate(interpreter, program, DataBounds.TrainingRange.Start, DataBounds.TrainingRange.End);
+    }
+
+    public EvaluationResult EvaluateTraining(IReadOnlyPushConfiguration config, PushProgram program, IRandom random) {
+      var interpreter = new PushInterpreter(config, random);
+      return EvaluateTraining(interpreter, program);
+    }
+
+    public EvaluationResult EvaluateTraining(PushInterpreterPool pool, PushProgram program, IRandom random) {
+      using (var interpreter = pool.Create(random)) {
+        return EvaluateTraining(interpreter, program);
+      }
+    }
+
+    public double Evaluate(IPushInterpreter interpreter, PushProgram program, int exampleIndex) {
+      var example = Data.Examples[exampleIndex];
+
+      interpreter.InitExample(example);
+      interpreter.Run(program);
+
+      switch (Data.ProblemType) {
+        case ProblemType.NumberIO: return NumberIo(interpreter, example);
+        case ProblemType.Median: return Median(interpreter, example);
+      }
+
+      return Default(interpreter, example);
+    }
+
+    private double Default(IPushInterpreter interpreter, Example example) {
+      var integerDiff = GetDiff(example.OutputInteger, interpreter.IntegerStack, Data.WorstResult, IntegerDiffer);
+      var floatDiff = GetDiff(example.OutputFloat, interpreter.FloatStack, Data.WorstResult, (a, b) => FloatDiffer(a, b, example.OutputFloatPrecision));
+      var booleanDiff = GetDiff(example.OutputBoolean, interpreter.BooleanStack, Data.WorstResult, BooleanDiffer);
+      var stringDiff = GetDiff(example.OutputString, interpreter.StringStack, Data.WorstResult, StringDiffer);
+      var charDiff = GetDiff(example.OutputChar, interpreter.CharStack, Data.WorstResult, CharDiffer);
+      var printDiff = GetPrintDiffer(example.OutputPrint, interpreter.PrintStack, Data.WorstResult);
+      var integerVectorDiff = GetVectorDiff(example.OutputIntegerVector, interpreter.IntegerVectorStack, Data.WorstResult, (a, b) => VectorDiffer(a, b, IntegerDiffer));
+      var floatVectorDiff = GetVectorDiff(example.OutputFloatVector, interpreter.FloatVectorStack, Data.WorstResult, (a, b) => VectorDiffer(a, b, (x, y) => FloatDiffer(x, y, example.OutputFloatVectorPrecision)));
+      var stringVectorDiff = GetVectorDiff(example.OutputStringVector, interpreter.StringVectorStack, Data.WorstResult, (a, b) => VectorDiffer(a, b, StringDiffer));
+
+      var result =
+          integerDiff
+        + floatDiff
+        + booleanDiff
+        + stringDiff
+        + charDiff
+        + printDiff
+        + integerVectorDiff
+        + floatVectorDiff
+        + stringVectorDiff;
+
+      return result;
+    }
+
+    private double Median(IPushInterpreter interpreter, Example example) {
+      return interpreter.PrintStack.IsEmpty || !interpreter.PrintStack.ToString().Equals(example.OutputPrint) ? 1 : 0;
+    }
+
+    private double NumberIo(IPushInterpreter interpreter, Example example) {
+      if (interpreter.PrintStack.IsEmpty)
+        return Data.WorstResult;
+
+      var printResult = interpreter.PrintStack.ToString();
+
+      double value;
+      if (double.TryParse(printResult, NumberStyles.Number | NumberStyles.AllowDecimalPoint, CultureInfo.InvariantCulture, out value)) {
+        var diff = Math.Abs(example.OutputFloat[0] - value);
+        var result = Math.Min(diff, Data.WorstResult);
+
+        return result;
+      }
+
+      var penaltyError = Data.WorstResult / 4.0d;
+      var levenshteinDistance = GetPrintDiffer(
+        example.OutputPrint,
+        printResult,
+        Data.WorstResult);
+
+      return levenshteinDistance + penaltyError;
+    }
+
+    private static double FloatDiffer(double a, double b, int digits) {
+      var result = Math.Round(a, digits) - Math.Round(b, digits);
+
+      // ReSharper disable once CompareOfFloatsByEqualityOperator
+      if (result == double.MinValue || double.IsPositiveInfinity(result) || double.IsNaN(result))
+        return double.MaxValue;
+
+      // ReSharper disable once CompareOfFloatsByEqualityOperator
+      if (result == double.MaxValue || double.IsNegativeInfinity(result))
+        return double.MinValue;
+
+      return Math.Abs(result);
+    }
+
+    private static double IntegerDiffer(long a, long b) {
+      var result = a - b;
+
+      return result == long.MinValue ? long.MaxValue : Math.Abs(result);
+    }
+
+    private static double BooleanDiffer(bool a, bool b) {
+      return a == b ? 0 : 1;
+    }
+
+    private static double StringDiffer(string a, string b) {
+      return LevenshteinDistance(a, b);
+    }
+
+    private static double CharDiffer(char a, char b) {
+      return IntegerDiffer(a, b);
+    }
+
+    private static double VectorDiffer<T>(IReadOnlyList<T> estimated, IReadOnlyList<T> outcome, Func<T, T, double> differ) {
+      var length = Math.Min(estimated.Count, outcome.Count);
+      var result = 0d;
+
+      for (var i = 0; i < length; i++) {
+        result += differ(estimated[i], outcome[i]);
+      }
+
+      if (estimated.Count > outcome.Count) {
+        var remainingLength = estimated.Count - length;
+        for (var i = 0; i < remainingLength; i++)
+          result += differ(estimated[i], default(T));
+      }
+
+      return result;
+    }
+
+    private static double GetPrintDiffer(string estimated, string printResult, double worstResult) {
+      var distance = LevenshteinDistance(estimated, printResult);
+
+      return Math.Min(distance, worstResult);
+    }
+
+    private static double GetPrintDiffer(string estimated, IPrintStack printStack, double worstResult) {
+      var printResult = printStack.ToString();
+      var distance = LevenshteinDistance(estimated, printResult);
+
+      return Math.Min(distance, worstResult);
+    }
+
+    private static double GetVectorDiff<T>(IReadOnlyList<IReadOnlyList<T>> estimated, IPushStack<IReadOnlyList<T>> resultStack, double worstResult, Func<IReadOnlyList<T>, IReadOnlyList<T>, double> differ)
+      where T : IComparable {
+      if (estimated.Count == 0) return 0d;
+
+      var diff = 0d;
+      var comparableLength = Math.Min(estimated.Count, resultStack.Count);
+
+      if (!resultStack.IsEmpty) {
+
+        for (var i = 0; i < comparableLength; i++) {
+          diff += Math.Min(differ(estimated[i], resultStack[i]), worstResult);
+        }
+      }
+
+      var emptyTArray = new T[0];
+      for (var i = comparableLength; i < estimated.Count - comparableLength; i++) {
+        diff += differ(estimated[i], emptyTArray);
+      }
+
+      return diff;
+    }
+
+    private static double GetDiff<T>(IReadOnlyList<T> estimated, IPushStack<T> resultStack, double worstResult, Func<T, T, double> differ)
+      where T : IComparable {
+      if (estimated.Count == 0) return 0d;
+
+      var diff = 0d;
+      var comparableLength = Math.Min(estimated.Count, resultStack.Count);
+
+      if (!resultStack.IsEmpty) {
+        for (var i = 0; i < comparableLength; i++) {
+          diff += Math.Min(differ(estimated[i], resultStack[i]), worstResult);
+        }
+      }
+
+      for (var i = comparableLength; i < estimated.Count - comparableLength; i++) {
+        diff += differ(estimated[i], default(T));
+      }
+
+      return diff;
+    }
+
+    /// <summary>
+    /// https://www.dotnetperls.com/levenshtein
+    /// </summary>
+    private static int LevenshteinDistance(string source, string target) {
+      if (source == null && target == null) return 0;
+      if (source == null) return target.Length;
+      if (target == null) return source.Length;
+
+      int n = source.Length;
+      int m = target.Length;
+      int[,] d = new int[n + 1, m + 1];
+
+      // Step 1
+      if (n == 0) {
+        return m;
+      }
+
+      if (m == 0) {
+        return n;
+      }
+
+      // Step 2
+      for (int i = 0; i <= n; d[i, 0] = i++) {
+      }
+
+      for (int j = 0; j <= m; d[0, j] = j++) {
+      }
+
+      // Step 3
+      for (int i = 1; i <= n; i++) {
+        //Step 4
+        for (int j = 1; j <= m; j++) {
+          // Step 5
+          int cost = (target[j - 1] == source[i - 1]) ? 0 : 1;
+
+          // Step 6
+          d[i, j] = Math.Min(
+              Math.Min(d[i - 1, j] + 1, d[i, j - 1] + 1),
+              d[i - 1, j - 1] + cost);
+        }
+      }
+      // Step 7
+      return d[n, m];
+    }
+  }
+}
Index: /branches/PushGP/HeuristicLab.PushGP/HeuristicLab.Problems.ProgramSynthesis/Push/Expressions/PrintExpressions.cs
===================================================================
--- /branches/PushGP/HeuristicLab.PushGP/HeuristicLab.Problems.ProgramSynthesis/Push/Expressions/PrintExpressions.cs	(revision 15288)
+++ /branches/PushGP/HeuristicLab.PushGP/HeuristicLab.Problems.ProgramSynthesis/Push/Expressions/PrintExpressions.cs	(revision 15289)
@@ -72,5 +72,6 @@
 
     public override void Eval(IInternalPushInterpreter interpreter) {
-      Eval(interpreter, interpreter.BooleanStack);
+      var value = interpreter.BooleanStack.Pop();
+      interpreter.PrintStack.Push(value);
     }
   }
@@ -92,5 +93,6 @@
 
     public override void Eval(IInternalPushInterpreter interpreter) {
-      Eval(interpreter, interpreter.CharStack);
+      var value = interpreter.CharStack.Pop();
+      interpreter.PrintStack.Push(value);
     }
   }
@@ -113,5 +115,6 @@
 
     public override void Eval(IInternalPushInterpreter interpreter) {
-      Eval(interpreter, interpreter.ExecStack);
+      var value = interpreter.ExecStack.Pop();
+      interpreter.PrintStack.Push(value);
     }
   }
@@ -136,8 +139,5 @@
       var str = value.ToString(interpreter.Configuration.FloatStringFormat, CultureInfo.InvariantCulture);
 
-      if (interpreter.PrintStack.IsEmpty)
-        interpreter.PrintStack.Push(str);
-      else
-        interpreter.PrintStack.Top += str;
+      interpreter.PrintStack.Push(str);
     }
   }
@@ -180,5 +180,6 @@
 
     public override void Eval(IInternalPushInterpreter interpreter) {
-      Eval(interpreter, interpreter.StringStack);
+      var value = interpreter.StringStack.Pop();
+      interpreter.PrintStack.Push(value);
     }
   }
Index: /branches/PushGP/HeuristicLab.PushGP/HeuristicLab.Problems.ProgramSynthesis/Push/Generators/CodeGenerator/CodeGeneratorUtils.cs
===================================================================
--- /branches/PushGP/HeuristicLab.PushGP/HeuristicLab.Problems.ProgramSynthesis/Push/Generators/CodeGenerator/CodeGeneratorUtils.cs	(revision 15288)
+++ /branches/PushGP/HeuristicLab.PushGP/HeuristicLab.Problems.ProgramSynthesis/Push/Generators/CodeGenerator/CodeGeneratorUtils.cs	(revision 15289)
@@ -28,4 +28,17 @@
         ? customExpressions.Values.ElementAt(index - enabledExpressionCount)
         : MapToExpression(index, random, ercOptions, config);
+    }
+
+    internal static Expression MapToExpression(
+      int index,
+      IReadOnlyExpressionsConfiguration config) {
+
+      switch (index) {
+        case PushSolutionEncoding.Noop:
+          return Noop;
+      }
+
+      var name = config.EnabledExpressions[index];
+      return ExpressionTable.GetExpression(name);
     }
 
@@ -76,6 +89,6 @@
         instructions.InExpressionCount > 0) {
 
-        var nr = random.Next(0, instructions.InExpressionCount) + 1;
-        expression = ExpressionTable.InExpressionTable[nr];
+        var index = random.Next(0, instructions.InExpressionCount);
+        expression = ExpressionTable.InExpressionTable[index];
       } else {
         expression = GetRandomExpression(random, instructions);
Index: /branches/PushGP/HeuristicLab.PushGP/HeuristicLab.Problems.ProgramSynthesis/Push/Individual/IndividualExtensions.cs
===================================================================
--- /branches/PushGP/HeuristicLab.PushGP/HeuristicLab.Problems.ProgramSynthesis/Push/Individual/IndividualExtensions.cs	(revision 15288)
+++ /branches/PushGP/HeuristicLab.PushGP/HeuristicLab.Problems.ProgramSynthesis/Push/Individual/IndividualExtensions.cs	(revision 15289)
@@ -1,20 +1,17 @@
 ﻿namespace HeuristicLab.Problems.ProgramSynthesis.Push.Individual {
   using System.Collections.Generic;
-
-  using HeuristicLab.Core;
   using HeuristicLab.Encodings.IntegerVectorEncoding;
   using HeuristicLab.Optimization;
   using HeuristicLab.Problems.ProgramSynthesis.Push.Configuration;
   using HeuristicLab.Problems.ProgramSynthesis.Push.Expressions;
-  using HeuristicLab.Problems.ProgramSynthesis.Push.Generators.CodeGenerator;
   using HeuristicLab.Problems.ProgramSynthesis.Push.SolutionCreator;
 
   public static class IndividualExtensions {
 
-    public static PushProgram ToPushProgram(this Individual individual, IReadOnlyPushConfiguration config, IRandom random) {
-      return individual.IntegerVector().ToPushProgram(config, random);
+    public static PushProgram ToPushProgram(this Individual individual, IReadOnlyPushConfiguration config) {
+      return individual.IntegerVector().ToPushProgram(config);
     }
 
-    public static PushProgram ToPushProgram(this IntegerVector vector, IReadOnlyPushConfiguration config, IRandom random) {
+    public static PushProgram ToPushProgram(this IntegerVector vector, IReadOnlyPushConfiguration config) {
       //var currentIndex = 0;
       //var close = 0;
@@ -24,16 +21,15 @@
         var index = vector[i];
 
-        if (index == PushSolutionEncoding.End)
-          break;
+        if (index == PushSolutionEncoding.End) break;
+        if (index == PushSolutionEncoding.Noop) continue;
 
-        // skip noops
-        if (index == PushSolutionEncoding.Noop)
-          continue;
+        var name = config.EnabledExpressions[index];
+        var expression = ExpressionTable.GetExpression(name);
 
-        var expression = CodeGeneratorUtils.MapToExpression(
-          index,
-          random,
-          config.ErcOptions,
-          config);
+        //var expression = CodeGeneratorUtils.MapToExpression(
+        //  index,
+        //  random,
+        //  config.ErcOptions,
+        //  config);
 
         expressions.Add(expression);
Index: /branches/PushGP/HeuristicLab.PushGP/HeuristicLab.Problems.ProgramSynthesis/Push/Interpreter/Extensions.cs
===================================================================
--- /branches/PushGP/HeuristicLab.PushGP/HeuristicLab.Problems.ProgramSynthesis/Push/Interpreter/Extensions.cs	(revision 15288)
+++ /branches/PushGP/HeuristicLab.PushGP/HeuristicLab.Problems.ProgramSynthesis/Push/Interpreter/Extensions.cs	(revision 15289)
@@ -5,4 +5,5 @@
   using System;
   using System.Collections;
+  using System.Globalization;
   using System.Reflection;
 
@@ -26,20 +27,51 @@
     }
 
-    public static Type GetStackEntryType(this StackTypes stackType) {
-      if (StackProperties.ContainsKey(stackType) &&
-          StackProperties[stackType].PropertyType.IsGenericType) {
-        var genericTypeDef = StackProperties[stackType].PropertyType.GetGenericTypeDefinition();
-        if (genericTypeDef == typeof(IPushStack<>))
-          return genericTypeDef.GetGenericArguments()[0];
+    public static string StringifyResult(this IPushInterpreter interpreter, ExampleArgumentType type, int offset) {
+      var emptyString = string.Empty;
+
+      switch (type) {
+        case ExampleArgumentType.Integer:
+          return GetEntryAsString(offset, interpreter.IntegerStack);
+
+        case ExampleArgumentType.IntegerVector:
+          return GetVectorEntryAsString(offset, interpreter.IntegerVectorStack);
+
+        case ExampleArgumentType.Float:
+          return interpreter.FloatStack.Count > offset
+            ? interpreter.FloatStack[offset].ToString(CultureInfo.CurrentUICulture)
+            : emptyString;
+
+        case ExampleArgumentType.FloatVector:
+          return GetVectorEntryAsString(offset, interpreter.FloatVectorStack);
+
+        case ExampleArgumentType.Boolean:
+          return GetEntryAsString(offset, interpreter.BooleanStack);
+
+        case ExampleArgumentType.Char:
+          return GetEntryAsString(offset, interpreter.CharStack);
+
+        case ExampleArgumentType.Print:
+          return interpreter.PrintStack.ToString();
+
+        case ExampleArgumentType.String:
+          return GetEntryAsString(offset, interpreter.StringStack);
+
+        case ExampleArgumentType.StringVector:
+          return GetVectorEntryAsString(offset, interpreter.StringVectorStack);
+
+        default: return string.Empty;
       }
+    }
 
-      return StackProperties.ContainsKey(stackType)
-        ? StackProperties[stackType]
-            .PropertyType
-            .GetInterfaces()
-            .First(i => i.IsGenericType && i.GetGenericTypeDefinition() == typeof(IPushStack<>))
-            .GetGenericArguments()
-            .First()
-        : null;
+    private static string GetEntryAsString<T>(int offset, IPushStack<T> stack) {
+      return stack.Count > offset
+       ? stack[offset].ToString()
+       : string.Empty;
+    }
+
+    private static string GetVectorEntryAsString<T>(int offset, IPushStack<IReadOnlyList<T>> vectorStack) {
+      return vectorStack.Count > offset
+       ? "[" + string.Join(",", vectorStack[offset]) + "]"
+       : string.Empty;
     }
 
Index: /branches/PushGP/HeuristicLab.PushGP/HeuristicLab.Problems.ProgramSynthesis/Push/Manipulator/UniformMutation.cs
===================================================================
--- /branches/PushGP/HeuristicLab.PushGP/HeuristicLab.Problems.ProgramSynthesis/Push/Manipulator/UniformMutation.cs	(revision 15288)
+++ /branches/PushGP/HeuristicLab.PushGP/HeuristicLab.Problems.ProgramSynthesis/Push/Manipulator/UniformMutation.cs	(revision 15289)
@@ -1,3 +1,4 @@
 ﻿namespace HeuristicLab.Problems.ProgramSynthesis.Push.Manipulator {
+
   using HeuristicLab.Common;
   using HeuristicLab.Core;
@@ -11,5 +12,4 @@
   using HeuristicLab.Problems.ProgramSynthesis.Push.Encoding;
   using HeuristicLab.Problems.ProgramSynthesis.Push.Generators.CodeGenerator;
-  using HeuristicLab.Random;
 
   /// <summary>
@@ -23,12 +23,11 @@
       Parameters.Add(new LookupParameter<IRandom>("Random", "The pseudo random number generator which should be used for stochastic manipulation operators."));
       Parameters.Add(new LookupParameter<PlushVector>("PlushVector", "The vector which should be manipulated."));
-      Parameters.Add(new ValueLookupParameter<IntValue>("MinLength", "The min length of the vector."));
-      Parameters.Add(new ValueLookupParameter<IntValue>("MaxLength", "The max length of the vector."));
       Parameters.Add(new ValueLookupParameter<IReadOnlyExpressionsConfiguration>("Instructions", "The enabled instructions"));
       Parameters.Add(new ValueLookupParameter<IReadOnlyErcOptions>("ErcOptions", "ERC options"));
       Parameters.Add(new ValueLookupParameter<PercentValue>("InInstructionProbability", "The probability of IN Instructions"));
 
-      Parameters.Add(new FixedValueParameter<PercentValue>("InstructionMutationProbability", "The probability a value gets mutated", new PercentValue(0.02)));
-      Parameters.Add(new FixedValueParameter<DoubleValue>("CloseMutationDeviation", "When mutating individual, the amount of which the close marker is incremented or decrement is based on a random sample from a normal distribution with mean 0 and standard deviation set by the close mutation deviation parameter", new DoubleValue(1.0)));
+      Parameters.Add(new FixedValueParameter<PercentValue>("InstructionMutationProbability", "The probability an instruction gets mutated", new PercentValue(0.02)));
+      Parameters.Add(new FixedValueParameter<PercentValue>("CloseMutationProbability", "The probability close gets mutated", new PercentValue(0.02)));
+      Parameters.Add(new FixedValueParameter<PercentValue>("CloseIncrementRate", "When mutating individual, the increment rate specifies if close should be increased or decreased by 1.", new PercentValue(0.5)));
     }
 
@@ -50,13 +49,24 @@
     }
 
-    public IValueParameter<PercentValue> CloseMutationDeviationParameter
+    public IValueParameter<PercentValue> CloseMutationProbabilityParameter
     {
-      get { return (IValueParameter<PercentValue>)Parameters["CloseMutationDeviation"]; }
+      get { return (IValueParameter<PercentValue>)Parameters["CloseMutationProbability"]; }
     }
 
-    public double CloseMutationDeviation
+    public double CloseMutationProbability
     {
-      get { return CloseMutationDeviationParameter.Value.Value; }
-      set { CloseMutationDeviationParameter.Value.Value = value; }
+      get { return CloseMutationProbabilityParameter.Value.Value; }
+      set { CloseMutationProbabilityParameter.Value.Value = value; }
+    }
+
+    public IValueParameter<PercentValue> CloseIncrementRateParameter
+    {
+      get { return (IValueParameter<PercentValue>)Parameters["CloseIncrementRate"]; }
+    }
+
+    public double CloseIncrementRate
+    {
+      get { return CloseIncrementRateParameter.Value.Value; }
+      set { CloseIncrementRateParameter.Value.Value = value; }
     }
 
@@ -72,12 +82,4 @@
     {
       get { return (ILookupParameter<PlushVector>)Parameters["PlushVector"]; }
-    }
-    public IValueLookupParameter<IntValue> MinLengthParameter
-    {
-      get { return (IValueLookupParameter<IntValue>)Parameters["MinLength"]; }
-    }
-    public IValueLookupParameter<IntValue> MaxLengthParameter
-    {
-      get { return (IValueLookupParameter<IntValue>)Parameters["MaxLength"]; }
     }
     public IValueLookupParameter<IReadOnlyExpressionsConfiguration> InstructionsParameter
@@ -99,14 +101,26 @@
 
     public sealed override IOperation InstrumentedApply() {
-      Manipulate(RandomParameter.ActualValue, PlushVectorParameter.ActualValue);
+      Manipulate(
+        RandomParameter.ActualValue,
+        PlushVectorParameter.ActualValue,
+        CloseIncrementRate,
+        ErcOptionsParameter.ActualValue,
+        InstructionsParameter.ActualValue,
+        InInstructionProbabilityParameter.ActualValue.Value,
+        CloseMutationProbability,
+        InstructionMutationProbability);
       return base.InstrumentedApply();
     }
 
-    private void Manipulate(IRandom random, PlushVector plushVector) {
-      var normalDistributedRandom = new NormalDistributedRandom(random, 0, CloseMutationDeviation);
-      var ercOptions = ErcOptionsParameter.ActualValue;
-      var instructions = InstructionsParameter.ActualValue;
-      var inInstructionProbability = InInstructionProbabilityParameter.ActualValue.Value;
-      var instructionMutationProbability = InstructionMutationProbability;
+    private static void Manipulate(
+      IRandom random,
+      PlushVector plushVector,
+      double closeIncrementRate,
+      IReadOnlyErcOptions ercOptions,
+      IReadOnlyExpressionsConfiguration instructions,
+      double inInstructionProbability,
+      double closeMutationProbability,
+      double instructionMutationProbability
+      ) {
 
       for (var i = 0; i < plushVector.Entries.Count; i++) {
@@ -123,5 +137,13 @@
         }
 
-        entry.Close += normalDistributedRandom.Next();
+        x = random.NextDouble();
+
+        if (x < closeMutationProbability) {
+          x = random.NextDouble();
+          entry.Close += x < closeIncrementRate ? 1 : -1;
+
+          if (entry.Close < 0)
+            entry.Close = 0;
+        }
       }
 
Index: /branches/PushGP/HeuristicLab.PushGP/HeuristicLab.Problems.ProgramSynthesis/Push/ObjectPools/Random/SeededRandomPool.cs
===================================================================
--- /branches/PushGP/HeuristicLab.PushGP/HeuristicLab.Problems.ProgramSynthesis/Push/ObjectPools/Random/SeededRandomPool.cs	(revision 15288)
+++ /branches/PushGP/HeuristicLab.PushGP/HeuristicLab.Problems.ProgramSynthesis/Push/ObjectPools/Random/SeededRandomPool.cs	(revision 15289)
@@ -12,5 +12,5 @@
     public SeededRandomPool() : this(new Random().Next()) { }
 
-    public SeededRandomPool(int seed) : this(seed, () => new MersenneTwister()) { }
+    public SeededRandomPool(int seed) : this(seed, () => new FastRandom()) { }
 
     public SeededRandomPool(int seed, Func<IRandom> randomCreator) {
Index: anches/PushGP/HeuristicLab.PushGP/HeuristicLab.Problems.ProgramSynthesis/Push/Problem/BenchmarkSuite/BenchmarkSuitePushSolutionView.Designer.cs
===================================================================
--- /branches/PushGP/HeuristicLab.PushGP/HeuristicLab.Problems.ProgramSynthesis/Push/Problem/BenchmarkSuite/BenchmarkSuitePushSolutionView.Designer.cs	(revision 15288)
+++ 	(revision )
@@ -1,212 +1,0 @@
-﻿namespace HeuristicLab.Problems.ProgramSynthesis.Push.Problem.BenchmarkSuite {
-  using HeuristicLab.Problems.ProgramSynthesis.Push.Views;
-
-  partial class BenchmarkSuitePushSolutionView {
-    /// <summary>
-    /// Required designer variable.
-    /// </summary>
-    private System.ComponentModel.IContainer components = null;
-
-    /// <summary>
-    /// Clean up any resources being used.
-    /// </summary>
-    /// <param name="disposing">true if managed resources should be disposed; otherwise, false.</param>
-    protected override void Dispose(bool disposing) {
-      if (disposing && (this.components != null)) {
-        this.components.Dispose();
-      }
-      base.Dispose(disposing);
-    }
-
-    #region Component Designer generated code
-
-    /// <summary>
-    /// Required method for Designer support - do not modify
-    /// the contents of this method with the code editor.
-    /// </summary>
-    private void InitializeComponent() {
-      System.Windows.Forms.DataGridViewCellStyle dataGridViewCellStyle1 = new System.Windows.Forms.DataGridViewCellStyle();
-      this.tabControl = new System.Windows.Forms.TabControl();
-      this.tabPage1 = new System.Windows.Forms.TabPage();
-      this.exampleComboBox = new System.Windows.Forms.ComboBox();
-      this.label1 = new System.Windows.Forms.Label();
-      this.tabPage2 = new System.Windows.Forms.TabPage();
-      this.trainingResultsDataGrid = new System.Windows.Forms.DataGridView();
-      this.tabPage3 = new System.Windows.Forms.TabPage();
-      this.testResultsDataGrid = new System.Windows.Forms.DataGridView();
-      this.pushDebugger = new HeuristicLab.Problems.ProgramSynthesis.Push.Views.PushDebuggerView();
-      ((System.ComponentModel.ISupportInitialize)(this.errorProvider)).BeginInit();
-      this.tabControl.SuspendLayout();
-      this.tabPage1.SuspendLayout();
-      this.tabPage2.SuspendLayout();
-      ((System.ComponentModel.ISupportInitialize)(this.trainingResultsDataGrid)).BeginInit();
-      this.tabPage3.SuspendLayout();
-      ((System.ComponentModel.ISupportInitialize)(this.testResultsDataGrid)).BeginInit();
-      this.SuspendLayout();
-      //
-      // nameTextBox
-      //
-      this.errorProvider.SetIconAlignment(this.nameTextBox, System.Windows.Forms.ErrorIconAlignment.MiddleLeft);
-      this.errorProvider.SetIconPadding(this.nameTextBox, 2);
-      this.nameTextBox.Size = new System.Drawing.Size(755, 20);
-      //
-      // infoLabel
-      //
-      this.infoLabel.Location = new System.Drawing.Point(838, 3);
-      //
-      // tabControl
-      //
-      this.tabControl.Anchor = ((System.Windows.Forms.AnchorStyles)((((System.Windows.Forms.AnchorStyles.Top | System.Windows.Forms.AnchorStyles.Bottom)
-            | System.Windows.Forms.AnchorStyles.Left)
-            | System.Windows.Forms.AnchorStyles.Right)));
-      this.tabControl.Controls.Add(this.tabPage1);
-      this.tabControl.Controls.Add(this.tabPage2);
-      this.tabControl.Controls.Add(this.tabPage3);
-      this.tabControl.Location = new System.Drawing.Point(6, 26);
-      this.tabControl.Name = "tabControl";
-      this.tabControl.SelectedIndex = 0;
-      this.tabControl.Size = new System.Drawing.Size(848, 602);
-      this.tabControl.TabIndex = 12;
-      //
-      // tabPage1
-      //
-      this.tabPage1.AutoScroll = true;
-      this.tabPage1.Controls.Add(this.pushDebugger);
-      this.tabPage1.Controls.Add(this.exampleComboBox);
-      this.tabPage1.Controls.Add(this.label1);
-      this.tabPage1.Location = new System.Drawing.Point(4, 22);
-      this.tabPage1.Name = "tabPage1";
-      this.tabPage1.Padding = new System.Windows.Forms.Padding(3);
-      this.tabPage1.Size = new System.Drawing.Size(840, 576);
-      this.tabPage1.TabIndex = 0;
-      this.tabPage1.Text = "Debug";
-      this.tabPage1.UseVisualStyleBackColor = true;
-      //
-      // exampleComboBox
-      //
-      this.exampleComboBox.Anchor = ((System.Windows.Forms.AnchorStyles)(((System.Windows.Forms.AnchorStyles.Top | System.Windows.Forms.AnchorStyles.Left)
-            | System.Windows.Forms.AnchorStyles.Right)));
-      this.exampleComboBox.FormattingEnabled = true;
-      this.exampleComboBox.Location = new System.Drawing.Point(58, 6);
-      this.exampleComboBox.Name = "exampleComboBox";
-      this.exampleComboBox.Size = new System.Drawing.Size(776, 21);
-      this.exampleComboBox.TabIndex = 11;
-      //
-      // label1
-      //
-      this.label1.AutoSize = true;
-      this.label1.Location = new System.Drawing.Point(3, 9);
-      this.label1.Name = "label1";
-      this.label1.Size = new System.Drawing.Size(50, 13);
-      this.label1.TabIndex = 10;
-      this.label1.Text = "Example:";
-      //
-      // tabPage2
-      //
-      this.tabPage2.Controls.Add(this.trainingResultsDataGrid);
-      this.tabPage2.Location = new System.Drawing.Point(4, 22);
-      this.tabPage2.Name = "tabPage2";
-      this.tabPage2.Padding = new System.Windows.Forms.Padding(3);
-      this.tabPage2.Size = new System.Drawing.Size(840, 576);
-      this.tabPage2.TabIndex = 1;
-      this.tabPage2.Text = "Traning Results";
-      this.tabPage2.UseVisualStyleBackColor = true;
-      //
-      // trainingResultsDataGrid
-      //
-      this.trainingResultsDataGrid.AllowUserToAddRows = false;
-      this.trainingResultsDataGrid.AllowUserToDeleteRows = false;
-      this.trainingResultsDataGrid.AutoSizeRowsMode = System.Windows.Forms.DataGridViewAutoSizeRowsMode.AllCells;
-      this.trainingResultsDataGrid.ColumnHeadersHeightSizeMode = System.Windows.Forms.DataGridViewColumnHeadersHeightSizeMode.AutoSize;
-      dataGridViewCellStyle1.Alignment = System.Windows.Forms.DataGridViewContentAlignment.MiddleLeft;
-      dataGridViewCellStyle1.BackColor = System.Drawing.SystemColors.Window;
-      dataGridViewCellStyle1.Font = new System.Drawing.Font("Microsoft Sans Serif", 8.25F, System.Drawing.FontStyle.Regular, System.Drawing.GraphicsUnit.Point, ((byte)(0)));
-      dataGridViewCellStyle1.ForeColor = System.Drawing.SystemColors.ControlText;
-      dataGridViewCellStyle1.SelectionBackColor = System.Drawing.SystemColors.Highlight;
-      dataGridViewCellStyle1.SelectionForeColor = System.Drawing.SystemColors.HighlightText;
-      dataGridViewCellStyle1.WrapMode = System.Windows.Forms.DataGridViewTriState.True;
-      this.trainingResultsDataGrid.DefaultCellStyle = dataGridViewCellStyle1;
-      this.trainingResultsDataGrid.Dock = System.Windows.Forms.DockStyle.Fill;
-      this.trainingResultsDataGrid.EditMode = System.Windows.Forms.DataGridViewEditMode.EditProgrammatically;
-      this.trainingResultsDataGrid.Location = new System.Drawing.Point(3, 3);
-      this.trainingResultsDataGrid.Name = "trainingResultsDataGrid";
-      this.trainingResultsDataGrid.ReadOnly = true;
-      this.trainingResultsDataGrid.RowHeadersWidthSizeMode = System.Windows.Forms.DataGridViewRowHeadersWidthSizeMode.AutoSizeToAllHeaders;
-      this.trainingResultsDataGrid.Size = new System.Drawing.Size(834, 570);
-      this.trainingResultsDataGrid.TabIndex = 0;
-      //
-      // tabPage3
-      //
-      this.tabPage3.Controls.Add(this.testResultsDataGrid);
-      this.tabPage3.Location = new System.Drawing.Point(4, 22);
-      this.tabPage3.Name = "tabPage3";
-      this.tabPage3.Size = new System.Drawing.Size(840, 576);
-      this.tabPage3.TabIndex = 2;
-      this.tabPage3.Text = "Test Results";
-      this.tabPage3.UseVisualStyleBackColor = true;
-      //
-      // testResultsDataGrid
-      //
-      this.testResultsDataGrid.AllowUserToAddRows = false;
-      this.testResultsDataGrid.AllowUserToDeleteRows = false;
-      this.testResultsDataGrid.AutoSizeRowsMode = System.Windows.Forms.DataGridViewAutoSizeRowsMode.AllHeaders;
-      this.testResultsDataGrid.ColumnHeadersHeightSizeMode = System.Windows.Forms.DataGridViewColumnHeadersHeightSizeMode.AutoSize;
-      this.testResultsDataGrid.Dock = System.Windows.Forms.DockStyle.Fill;
-      this.testResultsDataGrid.EditMode = System.Windows.Forms.DataGridViewEditMode.EditProgrammatically;
-      this.testResultsDataGrid.Location = new System.Drawing.Point(0, 0);
-      this.testResultsDataGrid.Name = "testResultsDataGrid";
-      this.testResultsDataGrid.ReadOnly = true;
-      this.testResultsDataGrid.RowHeadersWidthSizeMode = System.Windows.Forms.DataGridViewRowHeadersWidthSizeMode.AutoSizeToAllHeaders;
-      this.testResultsDataGrid.Size = new System.Drawing.Size(840, 576);
-      this.testResultsDataGrid.TabIndex = 1;
-      //
-      // pushDebugger
-      //
-      this.pushDebugger.Anchor = ((System.Windows.Forms.AnchorStyles)((((System.Windows.Forms.AnchorStyles.Top | System.Windows.Forms.AnchorStyles.Bottom)
-            | System.Windows.Forms.AnchorStyles.Left)
-            | System.Windows.Forms.AnchorStyles.Right)));
-      this.pushDebugger.Caption = "View";
-      this.pushDebugger.Content = null;
-      this.pushDebugger.Location = new System.Drawing.Point(6, 33);
-      this.pushDebugger.Name = "pushDebugger";
-      this.pushDebugger.ReadOnly = false;
-      this.pushDebugger.Size = new System.Drawing.Size(831, 540);
-      this.pushDebugger.TabIndex = 12;
-      //
-      // BenchmarkSuitePushSolutionView
-      //
-      this.AutoScaleDimensions = new System.Drawing.SizeF(6F, 13F);
-      this.AutoScaleMode = System.Windows.Forms.AutoScaleMode.Font;
-      this.Controls.Add(this.tabControl);
-      this.Name = "BenchmarkSuitePushSolutionView";
-      this.Size = new System.Drawing.Size(857, 631);
-      this.Controls.SetChildIndex(this.tabControl, 0);
-      this.Controls.SetChildIndex(this.nameLabel, 0);
-      this.Controls.SetChildIndex(this.nameTextBox, 0);
-      this.Controls.SetChildIndex(this.infoLabel, 0);
-      ((System.ComponentModel.ISupportInitialize)(this.errorProvider)).EndInit();
-      this.tabControl.ResumeLayout(false);
-      this.tabPage1.ResumeLayout(false);
-      this.tabPage1.PerformLayout();
-      this.tabPage2.ResumeLayout(false);
-      ((System.ComponentModel.ISupportInitialize)(this.trainingResultsDataGrid)).EndInit();
-      this.tabPage3.ResumeLayout(false);
-      ((System.ComponentModel.ISupportInitialize)(this.testResultsDataGrid)).EndInit();
-      this.ResumeLayout(false);
-      this.PerformLayout();
-
-    }
-
-    #endregion
-
-    private System.Windows.Forms.TabControl tabControl;
-    private System.Windows.Forms.TabPage tabPage1;
-    private System.Windows.Forms.ComboBox exampleComboBox;
-    private System.Windows.Forms.Label label1;
-    private System.Windows.Forms.TabPage tabPage2;
-    private System.Windows.Forms.DataGridView trainingResultsDataGrid;
-    private PushDebuggerView pushDebugger;
-    private System.Windows.Forms.TabPage tabPage3;
-    private System.Windows.Forms.DataGridView testResultsDataGrid;
-  }
-}
Index: anches/PushGP/HeuristicLab.PushGP/HeuristicLab.Problems.ProgramSynthesis/Push/Problem/BenchmarkSuite/BenchmarkSuitePushSolutionView.cs
===================================================================
--- /branches/PushGP/HeuristicLab.PushGP/HeuristicLab.Problems.ProgramSynthesis/Push/Problem/BenchmarkSuite/BenchmarkSuitePushSolutionView.cs	(revision 15288)
+++ 	(revision )
@@ -1,283 +1,0 @@
-﻿namespace HeuristicLab.Problems.ProgramSynthesis.Push.Problem.BenchmarkSuite {
-  using System;
-  using System.Collections.Generic;
-  using System.Drawing;
-  using System.Globalization;
-  using System.Linq;
-  using System.Windows.Forms;
-  using Core.Views;
-  using HeuristicLab.BenchmarkSuite;
-  using HeuristicLab.BenchmarkSuite.Views;
-  using HeuristicLab.Common;
-  using HeuristicLab.Problems.ProgramSynthesis.Push.Constants;
-
-  using Interpreter;
-  using MainForm;
-  using Problem;
-  using Stack;
-
-  [View("Push Program Debugger")]
-  [Content(typeof(PushSolution), true)]
-  public partial class BenchmarkSuitePushSolutionView : NamedItemView {
-
-    private const string Separator = ", ";
-
-    private const string exampleSplitter = " => ";
-    private const string AbsoluteDiffHeaderText = "Absolute Diff.";
-    private const string RelativeDiffHeaderText = "Relative Diff.";
-    private const string InputHeaderStringFormat = "Input {0} : {1}";
-    private const string EstimatedOutputHeaderStringFormat = "Estimated Output {0} : {1}";
-    private const string OutputHeaderStringFormat = "Output {0} : {1}";
-    private static readonly Color correctExampleFontColor = Color.FromArgb(0x5cb85c);
-    private PooledPushInterpreter interpreter;
-    private PushInterpreterPool pool;
-
-    public BenchmarkSuitePushSolutionView() {
-      InitializeComponent();
-      Name = "Push Program Debugger";
-      InitEvents();
-    }
-
-    ~BenchmarkSuitePushSolutionView() {
-      interpreter.Dispose();
-    }
-
-    private void InitEvents() {
-      exampleComboBox.SelectedIndexChanged += SelectedExampleIndexChanged;
-      pushDebugger.OnReset += PushDebuggerReset;
-    }
-
-    private void PushDebuggerReset(object sender, IPushInterpreter interpreter) {
-      if (exampleComboBox.SelectedIndex < 0) return;
-
-      var example = Evaluator.Data.Examples[exampleComboBox.SelectedIndex];
-
-      interpreter.InitExample(example);
-    }
-
-    private void SelectedExampleIndexChanged(object sender, EventArgs e) {
-      pushDebugger.ResetDebugging();
-    }
-
-    public new PushBenchmarkSuiteSolution Content
-    {
-      get { return (PushBenchmarkSuiteSolution)base.Content; }
-      set
-      {
-        base.Content = value;
-      }
-    }
-
-    public PushBenchmarkSuiteEvaluator Evaluator
-    {
-      get { return (PushBenchmarkSuiteEvaluator)Content.Evaluator; }
-    }
-
-
-    protected override void OnContentChanged() {
-      if (Content == null) return;
-
-      Name = "Push Solution";
-      nameTextBox.Text = Name;
-
-      pool = new PushInterpreterPool(Content.Config);
-
-      if (interpreter != null) {
-        interpreter.Dispose();
-      }
-
-      var random = Content.GetRandom();
-      interpreter = pool.Create(random);
-      UpdateExamples(Evaluator.Data);
-
-      if (exampleComboBox.SelectedIndex < 0) {
-        exampleComboBox.SelectedIndex = 0; // Triggers ResetDebugging via event
-      }
-
-      InitResultGrid(trainingResultsDataGrid, Evaluator.DataBounds.TrainingRange.Start, Evaluator.DataBounds.TrainingRange.End);
-      InitResultGrid(testResultsDataGrid, Evaluator.DataBounds.TestRange.Start, Evaluator.DataBounds.TestRange.End);
-
-      pushDebugger.Content = Content;
-    }
-
-    private void InitResultGrid(DataGridView grid, int start, int end) {
-      grid.Columns.Clear();
-      grid.Rows.Clear();
-
-      var cellTemplate = new DataGridViewTextBoxCell { Style = { WrapMode = DataGridViewTriState.True } };
-      var data = Evaluator.Data;
-
-      for (var i = 0; i < data.InputArgumentTypes.Length; i++) {
-        var headerTypeName = ViewHelper.GetHeaderTypeName(data.InputArgumentTypes[i]);
-        var column = new DataGridViewColumn {
-          HeaderText = string.Format(InputHeaderStringFormat, i + 1, headerTypeName),
-          AutoSizeMode = DataGridViewAutoSizeColumnMode.Fill,
-          CellTemplate = cellTemplate,
-          DefaultCellStyle = { Alignment = DataGridViewContentAlignment.MiddleRight },
-          SortMode = DataGridViewColumnSortMode.Automatic
-        };
-
-        grid.Columns.Add(column);
-      }
-
-      for (var i = 0; i < data.OutputArgumentTypes.Length; i++) {
-        var headerTypeName = ViewHelper.GetHeaderTypeName(data.OutputArgumentTypes[i]);
-
-        var estimatedOutputColumn = new DataGridViewColumn {
-          HeaderText = string.Format(EstimatedOutputHeaderStringFormat, i + 1, headerTypeName),
-          AutoSizeMode = DataGridViewAutoSizeColumnMode.Fill,
-          CellTemplate = cellTemplate,
-          SortMode = DataGridViewColumnSortMode.Automatic
-        };
-
-        var outputColumn = new DataGridViewColumn {
-          HeaderText = string.Format(OutputHeaderStringFormat, i + 1, headerTypeName),
-          AutoSizeMode = DataGridViewAutoSizeColumnMode.Fill,
-          CellTemplate = cellTemplate,
-          SortMode = DataGridViewColumnSortMode.Automatic
-        };
-
-        estimatedOutputColumn.DefaultCellStyle.Alignment = DataGridViewContentAlignment.MiddleRight;
-        outputColumn.DefaultCellStyle.Alignment = DataGridViewContentAlignment.MiddleRight;
-
-        grid.Columns.Add(estimatedOutputColumn);
-        grid.Columns.Add(outputColumn);
-      }
-
-      var absoluteDiffColumn = new DataGridViewColumn {
-        HeaderText = AbsoluteDiffHeaderText,
-        AutoSizeMode = DataGridViewAutoSizeColumnMode.ColumnHeader,
-        CellTemplate = cellTemplate,
-        SortMode = DataGridViewColumnSortMode.Automatic
-      };
-
-      var relativeDiffColumn = new DataGridViewColumn {
-        HeaderText = RelativeDiffHeaderText,
-        AutoSizeMode = DataGridViewAutoSizeColumnMode.ColumnHeader,
-        CellTemplate = cellTemplate,
-        SortMode = DataGridViewColumnSortMode.Automatic
-      };
-
-      absoluteDiffColumn.DefaultCellStyle.Alignment = DataGridViewContentAlignment.MiddleRight;
-      relativeDiffColumn.DefaultCellStyle.Alignment = DataGridViewContentAlignment.MiddleRight;
-
-      grid.Columns.Add(absoluteDiffColumn);
-      grid.Columns.Add(relativeDiffColumn);
-
-      var random = Content.GetRandom();
-      using (var pushInterpreter = pool.Create(random)) {
-        var rowIndex = 1;
-        for (var i = start; i < end; i++, rowIndex++) {
-          var example = data.Examples[i];
-          var row = new DataGridViewRow {
-            HeaderCell = {
-              Value = rowIndex.ToString(),
-            }
-          };
-
-          row.CreateCells(grid);
-
-          var absoluteDiff = Evaluator.Evaluate(pushInterpreter, Content.Program, i);
-          var relativeDiff = absoluteDiff / Math.Abs(data.BestResult - data.WorstResult) * 100d;
-
-          var inputArgumentCountDict = ViewHelper.CreateArgumentCountDict();
-          for (var j = 0; j < data.InputArgumentTypes.Length; j++) {
-            var type = data.InputArgumentTypes[j];
-            var offset = inputArgumentCountDict[type];
-            row.Cells[j].Value = ViewHelper.StringifyInput(type, offset, Content.Config.FloatStringFormat, example, Separator);
-            inputArgumentCountDict[type]++;
-          }
-
-          var outputArgumentCountDict = ViewHelper.CreateArgumentCountDict();
-          for (var j = 0; j < data.OutputArgumentTypes.Length; j++) {
-            var type = data.OutputArgumentTypes[j];
-            var offset = outputArgumentCountDict[type];
-
-            // estimated
-            row.Cells[data.InputArgumentTypes.Length + j * 2].Value = ViewHelper.StringifyOutput(type, offset, Content.Config.FloatStringFormat, example, Separator);
-
-            // output
-            row.Cells[data.InputArgumentTypes.Length + j * 2 + 1].Value = StringifyResult(type, offset, pushInterpreter, example, Separator);
-
-            outputArgumentCountDict[type]++;
-          }
-
-          row.Cells[data.TotalArgumentCount + 1].Value = absoluteDiff.ToString("0.####");
-          row.Cells[data.TotalArgumentCount + 2].Value = relativeDiff.ToString("0.##") + "%";
-
-          if (absoluteDiff.IsAlmost(data.BestResult)) {
-            for (var j = 0; j < row.Cells.Count; j++) {
-              row.Cells[j].Style.ForeColor = correctExampleFontColor;
-            }
-          }
-
-          grid.Rows.Add(row);
-          pushInterpreter.Reset();
-        }
-      }
-    }
-
-    private string StringifyResult(ExampleArgumentType type, int offset, IPushInterpreter interpreter, Example example, string valueSeparator) {
-      var emptyString = string.Empty;
-
-      switch (type) {
-        case ExampleArgumentType.Integer:
-          return GetEntryAsString(offset, interpreter.IntegerStack);
-
-        case ExampleArgumentType.IntegerVector:
-          return GetVectorEntryAsString(offset, interpreter.IntegerVectorStack);
-
-        case ExampleArgumentType.Float:
-          return interpreter.FloatStack.Count > offset
-            ? interpreter.FloatStack[offset].ToString(CultureInfo.CurrentUICulture)
-            : emptyString;
-
-        case ExampleArgumentType.FloatVector:
-          return GetVectorEntryAsString(offset, interpreter.FloatVectorStack);
-
-        case ExampleArgumentType.Boolean:
-          return GetEntryAsString(offset, interpreter.BooleanStack);
-
-        case ExampleArgumentType.Char:
-          return GetEntryAsString(offset, interpreter.CharStack);
-
-        case ExampleArgumentType.Print:
-          return string.Join(valueSeparator, string.Join(PushEnvironment.NewLine, interpreter.PrintStack.AsStrings().Take(example.OutputPrintLineCount)));
-
-        case ExampleArgumentType.String:
-          return GetEntryAsString(offset, interpreter.StringStack);
-
-        case ExampleArgumentType.StringVector:
-          return GetVectorEntryAsString(offset, interpreter.StringVectorStack);
-
-        default: return string.Empty;
-      }
-    }
-
-    private static string GetEntryAsString<T>(int offset, IPushStack<T> stack) {
-      return stack.Count > offset
-       ? stack[offset].ToString()
-       : string.Empty;
-    }
-
-    private static string GetVectorEntryAsString<T>(int offset, IPushStack<IReadOnlyList<T>> vectorStack) {
-      return vectorStack.Count > offset
-       ? "[" + string.Join(",", vectorStack[offset]) + "]"
-       : string.Empty;
-    }
-
-    private void UpdateExamples(ProblemData data) {
-      exampleComboBox.Items.Clear();
-      if (data == null) return;
-
-      var stringRepresentations = data.Examples.Select(e =>
-        string.Join(Separator, e.InputArgs) +
-        exampleSplitter +
-        string.Join(Separator, e.OutputArgs));
-
-      foreach (var str in stringRepresentations) {
-        exampleComboBox.Items.Add(str);
-      }
-    }
-  }
-}
Index: anches/PushGP/HeuristicLab.PushGP/HeuristicLab.Problems.ProgramSynthesis/Push/Problem/BenchmarkSuite/BenchmarkSuitePushSolutionView.resx
===================================================================
--- /branches/PushGP/HeuristicLab.PushGP/HeuristicLab.Problems.ProgramSynthesis/Push/Problem/BenchmarkSuite/BenchmarkSuitePushSolutionView.resx	(revision 15288)
+++ 	(revision )
@@ -1,126 +1,0 @@
-﻿<?xml version="1.0" encoding="utf-8"?>
-<root>
-  <!-- 
-    Microsoft ResX Schema 
-    
-    Version 2.0
-    
-    The primary goals of this format is to allow a simple XML format 
-    that is mostly human readable. The generation and parsing of the 
-    various data types are done through the TypeConverter classes 
-    associated with the data types.
-    
-    Example:
-    
-    ... ado.net/XML headers & schema ...
-    <resheader name="resmimetype">text/microsoft-resx</resheader>
-    <resheader name="version">2.0</resheader>
-    <resheader name="reader">System.Resources.ResXResourceReader, System.Windows.Forms, ...</resheader>
-    <resheader name="writer">System.Resources.ResXResourceWriter, System.Windows.Forms, ...</resheader>
-    <data name="Name1"><value>this is my long string</value><comment>this is a comment</comment></data>
-    <data name="Color1" type="System.Drawing.Color, System.Drawing">Blue</data>
-    <data name="Bitmap1" mimetype="application/x-microsoft.net.object.binary.base64">
-        <value>[base64 mime encoded serialized .NET Framework object]</value>
-    </data>
-    <data name="Icon1" type="System.Drawing.Icon, System.Drawing" mimetype="application/x-microsoft.net.object.bytearray.base64">
-        <value>[base64 mime encoded string representing a byte array form of the .NET Framework object]</value>
-        <comment>This is a comment</comment>
-    </data>
-                
-    There are any number of "resheader" rows that contain simple 
-    name/value pairs.
-    
-    Each data row contains a name, and value. The row also contains a 
-    type or mimetype. Type corresponds to a .NET class that support 
-    text/value conversion through the TypeConverter architecture. 
-    Classes that don't support this are serialized and stored with the 
-    mimetype set.
-    
-    The mimetype is used for serialized objects, and tells the 
-    ResXResourceReader how to depersist the object. This is currently not 
-    extensible. For a given mimetype the value must be set accordingly:
-    
-    Note - application/x-microsoft.net.object.binary.base64 is the format 
-    that the ResXResourceWriter will generate, however the reader can 
-    read any of the formats listed below.
-    
-    mimetype: application/x-microsoft.net.object.binary.base64
-    value   : The object must be serialized with 
-            : System.Runtime.Serialization.Formatters.Binary.BinaryFormatter
-            : and then encoded with base64 encoding.
-    
-    mimetype: application/x-microsoft.net.object.soap.base64
-    value   : The object must be serialized with 
-            : System.Runtime.Serialization.Formatters.Soap.SoapFormatter
-            : and then encoded with base64 encoding.
-
-    mimetype: application/x-microsoft.net.object.bytearray.base64
-    value   : The object must be serialized into a byte array 
-            : using a System.ComponentModel.TypeConverter
-            : and then encoded with base64 encoding.
-    -->
-  <xsd:schema id="root" xmlns="" xmlns:xsd="http://www.w3.org/2001/XMLSchema" xmlns:msdata="urn:schemas-microsoft-com:xml-msdata">
-    <xsd:import namespace="http://www.w3.org/XML/1998/namespace" />
-    <xsd:element name="root" msdata:IsDataSet="true">
-      <xsd:complexType>
-        <xsd:choice maxOccurs="unbounded">
-          <xsd:element name="metadata">
-            <xsd:complexType>
-              <xsd:sequence>
-                <xsd:element name="value" type="xsd:string" minOccurs="0" />
-              </xsd:sequence>
-              <xsd:attribute name="name" use="required" type="xsd:string" />
-              <xsd:attribute name="type" type="xsd:string" />
-              <xsd:attribute name="mimetype" type="xsd:string" />
-              <xsd:attribute ref="xml:space" />
-            </xsd:complexType>
-          </xsd:element>
-          <xsd:element name="assembly">
-            <xsd:complexType>
-              <xsd:attribute name="alias" type="xsd:string" />
-              <xsd:attribute name="name" type="xsd:string" />
-            </xsd:complexType>
-          </xsd:element>
-          <xsd:element name="data">
-            <xsd:complexType>
-              <xsd:sequence>
-                <xsd:element name="value" type="xsd:string" minOccurs="0" msdata:Ordinal="1" />
-                <xsd:element name="comment" type="xsd:string" minOccurs="0" msdata:Ordinal="2" />
-              </xsd:sequence>
-              <xsd:attribute name="name" type="xsd:string" use="required" msdata:Ordinal="1" />
-              <xsd:attribute name="type" type="xsd:string" msdata:Ordinal="3" />
-              <xsd:attribute name="mimetype" type="xsd:string" msdata:Ordinal="4" />
-              <xsd:attribute ref="xml:space" />
-            </xsd:complexType>
-          </xsd:element>
-          <xsd:element name="resheader">
-            <xsd:complexType>
-              <xsd:sequence>
-                <xsd:element name="value" type="xsd:string" minOccurs="0" msdata:Ordinal="1" />
-              </xsd:sequence>
-              <xsd:attribute name="name" type="xsd:string" use="required" />
-            </xsd:complexType>
-          </xsd:element>
-        </xsd:choice>
-      </xsd:complexType>
-    </xsd:element>
-  </xsd:schema>
-  <resheader name="resmimetype">
-    <value>text/microsoft-resx</value>
-  </resheader>
-  <resheader name="version">
-    <value>2.0</value>
-  </resheader>
-  <resheader name="reader">
-    <value>System.Resources.ResXResourceReader, System.Windows.Forms, Version=4.0.0.0, Culture=neutral, PublicKeyToken=b77a5c561934e089</value>
-  </resheader>
-  <resheader name="writer">
-    <value>System.Resources.ResXResourceWriter, System.Windows.Forms, Version=4.0.0.0, Culture=neutral, PublicKeyToken=b77a5c561934e089</value>
-  </resheader>
-  <metadata name="errorProvider.TrayLocation" type="System.Drawing.Point, System.Drawing, Version=4.0.0.0, Culture=neutral, PublicKeyToken=b03f5f7f11d50a3a">
-    <value>17, 17</value>
-  </metadata>
-  <metadata name="toolTip.TrayLocation" type="System.Drawing.Point, System.Drawing, Version=4.0.0.0, Culture=neutral, PublicKeyToken=b03f5f7f11d50a3a">
-    <value>140, 17</value>
-  </metadata>
-</root>
Index: /branches/PushGP/HeuristicLab.PushGP/HeuristicLab.Problems.ProgramSynthesis/Push/Problem/BenchmarkSuite/IntegerVectorPushBenchmarkSuiteProblem.cs
===================================================================
--- /branches/PushGP/HeuristicLab.PushGP/HeuristicLab.Problems.ProgramSynthesis/Push/Problem/BenchmarkSuite/IntegerVectorPushBenchmarkSuiteProblem.cs	(revision 15288)
+++ /branches/PushGP/HeuristicLab.PushGP/HeuristicLab.Problems.ProgramSynthesis/Push/Problem/BenchmarkSuite/IntegerVectorPushBenchmarkSuiteProblem.cs	(revision 15289)
@@ -7,5 +7,8 @@
   using HeuristicLab.BenchmarkSuite;
   using HeuristicLab.BenchmarkSuite.Problems;
+  using HeuristicLab.Problems.ProgramSynthesis.Push.Evaluator;
   using HeuristicLab.Problems.ProgramSynthesis.Push.Expressions;
+  using HeuristicLab.Problems.ProgramSynthesis.Push.Solution;
+  using HeuristicLab.Problems.ProgramSynthesis.Push.Solution.BenchmarkSuite;
 
   using Instances;
Index: /branches/PushGP/HeuristicLab.PushGP/HeuristicLab.Problems.ProgramSynthesis/Push/Problem/BenchmarkSuite/PlushPushBenchmarkSuiteProblem.cs
===================================================================
--- /branches/PushGP/HeuristicLab.PushGP/HeuristicLab.Problems.ProgramSynthesis/Push/Problem/BenchmarkSuite/PlushPushBenchmarkSuiteProblem.cs	(revision 15288)
+++ /branches/PushGP/HeuristicLab.PushGP/HeuristicLab.Problems.ProgramSynthesis/Push/Problem/BenchmarkSuite/PlushPushBenchmarkSuiteProblem.cs	(revision 15289)
@@ -7,5 +7,8 @@
   using HeuristicLab.Problems.Instances;
   using HeuristicLab.Problems.ProgramSynthesis.Push.Configuration;
+  using HeuristicLab.Problems.ProgramSynthesis.Push.Evaluator;
   using HeuristicLab.Problems.ProgramSynthesis.Push.Expressions;
+  using HeuristicLab.Problems.ProgramSynthesis.Push.Solution;
+  using HeuristicLab.Problems.ProgramSynthesis.Push.Solution.BenchmarkSuite;
   using HeuristicLab.Problems.ProgramSynthesis.Push.Stack;
 
Index: anches/PushGP/HeuristicLab.PushGP/HeuristicLab.Problems.ProgramSynthesis/Push/Problem/BenchmarkSuite/PushBenchmarkSuiteEvaluator.cs
===================================================================
--- /branches/PushGP/HeuristicLab.PushGP/HeuristicLab.Problems.ProgramSynthesis/Push/Problem/BenchmarkSuite/PushBenchmarkSuiteEvaluator.cs	(revision 15288)
+++ 	(revision )
@@ -1,339 +1,0 @@
-﻿namespace HeuristicLab.Problems.ProgramSynthesis.Push.Problem.BenchmarkSuite {
-  using System;
-  using System.Collections.Generic;
-  using System.Globalization;
-  using System.Linq;
-
-  using Common;
-  using Core;
-  using Expressions;
-
-  using HeuristicLab.BenchmarkSuite;
-  using HeuristicLab.Parameters;
-  using HeuristicLab.Persistence.Default.CompositeSerializers.Storable;
-  using HeuristicLab.Problems.ProgramSynthesis.Push.Configuration;
-  using HeuristicLab.Problems.ProgramSynthesis.Push.Constants;
-
-  using Interpreter;
-  using Problem;
-  using Stack;
-
-  [StorableClass]
-  public class PushBenchmarkSuiteEvaluator : ParameterizedNamedItem, IPushEvaluator {
-
-    private const string DataBoundsParameterName = "DataBounds";
-    private const string DataParameterName = "Data";
-    private const string DataParameterDescription = "Program Synthesis";
-
-    public PushBenchmarkSuiteEvaluator() {
-      Parameters.Add(new FixedValueParameter<DataBounds>(DataBoundsParameterName));
-
-      Parameters.Add(new ValueParameter<ProblemData>(
-        DataParameterName,
-        DataParameterDescription));
-    }
-
-    public PushBenchmarkSuiteEvaluator(ProblemData data) : this() {
-      LoadData(data);
-    }
-
-    [StorableConstructor]
-    public PushBenchmarkSuiteEvaluator(bool deserializing) : base(deserializing) { }
-
-    public PushBenchmarkSuiteEvaluator(PushBenchmarkSuiteEvaluator origin, Cloner cloner) : base(origin, cloner) {
-      Data = cloner.Clone(origin.Data);
-    }
-
-    public override IDeepCloneable Clone(Cloner cloner) {
-      return new PushBenchmarkSuiteEvaluator(this, cloner);
-    }
-
-    public IValueParameter<ProblemData> DataParameter
-    {
-      get { return (IValueParameter<ProblemData>)Parameters[DataParameterName]; }
-    }
-
-    public ProblemData Data
-    {
-      get { return DataParameter.Value; }
-      set { DataParameter.Value = value; }
-    }
-
-    public IValueParameter<DataBounds> DataBoundsParameter
-    {
-      get { return (IValueParameter<DataBounds>)Parameters[DataBoundsParameterName]; }
-    }
-
-    public DataBounds DataBounds
-    {
-      get { return DataBoundsParameter.Value; }
-      set { DataBoundsParameter.Value = value; }
-    }
-
-    public void LoadData(ProblemData data) {
-      Data = data;
-
-      DataBounds.TrainingRange.Start = 0;
-      DataBounds.TrainingRange.End = Data.TrainingCount;
-      DataBounds.TestRange.Start = Data.TrainingCount;
-      DataBounds.TestRange.End = Data.TrainingCount + Data.TestCount;
-    }
-
-    public EvaluationResult Evaluate(IPushInterpreter interpreter, PushProgram program, int start, int end) {
-      var length = end - start;
-      if (length <= 0) return null;
-
-      var evaluationResult = new EvaluationResult(length);
-
-      for (var i = start; i < end; i++) {
-        var result = Evaluate(interpreter, program, i);
-        evaluationResult.ExampleQualities[i - start] = result;
-        evaluationResult.AvgQuality += result;
-        interpreter.Reset();
-      }
-
-      evaluationResult.AvgQuality /= length;
-
-      return evaluationResult;
-    }
-
-    public EvaluationResult EvaluateTest(IPushInterpreter interpreter, PushProgram program) {
-      return Evaluate(interpreter, program, DataBounds.TestRange.Start, DataBounds.TestRange.End);
-    }
-
-    public EvaluationResult EvaluateTest(IReadOnlyPushConfiguration config, PushProgram program, IRandom random) {
-      var interpreter = new PushInterpreter(config, random);
-      return EvaluateTest(interpreter, program);
-    }
-
-    public EvaluationResult EvaluateTest(PushInterpreterPool pool, PushProgram program, IRandom random) {
-      using (var interpreter = pool.Create(random)) {
-        return EvaluateTest(interpreter, program);
-      }
-    }
-
-    public EvaluationResult EvaluateTraining(IPushInterpreter interpreter, PushProgram program) {
-      return Evaluate(interpreter, program, DataBounds.TrainingRange.Start, DataBounds.TrainingRange.End);
-    }
-
-    public EvaluationResult EvaluateTraining(IReadOnlyPushConfiguration config, PushProgram program, IRandom random) {
-      var interpreter = new PushInterpreter(config, random);
-      return EvaluateTraining(interpreter, program);
-    }
-
-    public EvaluationResult EvaluateTraining(PushInterpreterPool pool, PushProgram program, IRandom random) {
-      using (var interpreter = pool.Create(random)) {
-        return EvaluateTraining(interpreter, program);
-      }
-    }
-
-    public double Evaluate(IPushInterpreter interpreter, PushProgram program, int exampleIndex) {
-      var example = Data.Examples[exampleIndex];
-
-      interpreter.InitExample(example);
-      interpreter.Run(program);
-
-      switch (Data.ProblemType) {
-        case ProblemType.NumberIO: return NumberIo(interpreter, example);
-        case ProblemType.Median: return Median(interpreter, example);
-      }
-
-      return Default(interpreter, example);
-    }
-
-    private double Default(IPushInterpreter interpreter, Example example) {
-      var result = GetDiff(example.OutputInteger, interpreter.IntegerStack, Data.WorstResult, IntegerDiffer)
-             + GetDiff(example.OutputFloat, interpreter.FloatStack, Data.WorstResult, (a, b) => FloatDiffer(a, b, example.OutputFloatPrecision))
-             + GetDiff(example.OutputBoolean, interpreter.BooleanStack, Data.WorstResult, BooleanDiffer)
-             + GetDiff(example.OutputString, interpreter.StringStack, Data.WorstResult, StringDiffer)
-             + GetDiff(example.OutputChar, interpreter.CharStack, Data.WorstResult, CharDiffer)
-             + GetPrintDiffer(example.OutputPrint, interpreter.PrintStack, example.OutputPrintLineCount, Data.WorstResult)
-             + GetVectorDiff(example.OutputIntegerVector, interpreter.IntegerVectorStack, Data.WorstResult, (a, b) => VectorDiffer(a, b, IntegerDiffer))
-             + GetVectorDiff(example.OutputFloatVector, interpreter.FloatVectorStack, Data.WorstResult, (a, b) => VectorDiffer(a, b, (x, y) => FloatDiffer(x, y, example.OutputFloatVectorPrecision)))
-             + GetVectorDiff(example.OutputStringVector, interpreter.StringVectorStack, Data.WorstResult, (a, b) => VectorDiffer(a, b, StringDiffer));
-
-      return result;
-    }
-
-    private double Median(IPushInterpreter interpreter, Example example) {
-      return interpreter.PrintStack.IsEmpty || !interpreter.PrintStack.Top.Equals(example.OutputPrint) ? 1 : 0;
-    }
-
-    private double NumberIo(IPushInterpreter interpreter, Example example) {
-      if (interpreter.PrintStack.IsEmpty)
-        return Data.WorstResult;
-
-      double value;
-      if (double.TryParse(interpreter.PrintStack.Top, NumberStyles.Number | NumberStyles.AllowDecimalPoint, CultureInfo.InvariantCulture, out value)) {
-        var diff = Math.Abs(example.OutputFloat[0] - value);
-        var result = Math.Min(diff, Data.WorstResult);
-
-        return result;
-      }
-
-      var penaltyError = Data.WorstResult / 4.0d;
-      var levenshteinDistance = GetPrintDiffer(
-        example.OutputPrint,
-        interpreter.PrintStack.Top,
-        Data.WorstResult);
-
-      return levenshteinDistance + penaltyError;
-    }
-
-    private static double FloatDiffer(double a, double b, int digits) {
-      var result = Math.Round(a, digits) - Math.Round(b, digits);
-
-      // ReSharper disable once CompareOfFloatsByEqualityOperator
-      if (result == double.MinValue || double.IsPositiveInfinity(result) || double.IsNaN(result))
-        return double.MaxValue;
-
-      // ReSharper disable once CompareOfFloatsByEqualityOperator
-      if (result == double.MaxValue || double.IsNegativeInfinity(result))
-        return double.MinValue;
-
-      return Math.Abs(result);
-    }
-
-    private static double IntegerDiffer(long a, long b) {
-      var result = a - b;
-
-      return result == long.MinValue ? long.MaxValue : Math.Abs(result);
-    }
-
-    private static double BooleanDiffer(bool a, bool b) {
-      return a == b ? 0 : 1;
-    }
-
-    private static double StringDiffer(string a, string b) {
-      return LevenshteinDistance(a, b);
-    }
-
-    private static double CharDiffer(char a, char b) {
-      return IntegerDiffer(a, b);
-    }
-
-    private static double VectorDiffer<T>(IReadOnlyList<T> estimated, IReadOnlyList<T> outcome, Func<T, T, double> differ) {
-      var length = Math.Min(estimated.Count, outcome.Count);
-      var result = 0d;
-
-      for (var i = 0; i < length; i++) {
-        result += differ(estimated[i], outcome[i]);
-      }
-
-      if (estimated.Count > outcome.Count) {
-        var remainingLength = estimated.Count - length;
-        for (var i = 0; i < remainingLength; i++)
-          result += differ(estimated[i], default(T));
-      }
-
-      return result;
-    }
-
-    private static double GetPrintDiffer(string estimated, string printResult, double worstResult) {
-      var distance = LevenshteinDistance(estimated, printResult);
-
-      return Math.Min(distance, worstResult);
-    }
-
-    private static double GetPrintDiffer(string estimated, IPushStack<string> printStack, int estimatedCount, double worstResult) {
-      var printResult = string.Join(PushEnvironment.NewLine, printStack.AsStrings().Take(estimatedCount));
-      var distance = LevenshteinDistance(estimated, printResult);
-
-      return Math.Min(distance, worstResult);
-    }
-
-    private static double GetVectorDiff<T>(IReadOnlyList<IReadOnlyList<T>> estimated, IPushStack<IReadOnlyList<T>> resultStack, double worstResult, Func<IReadOnlyList<T>, IReadOnlyList<T>, double> differ)
-      where T : IComparable {
-      if (estimated.Count == 0) return 0d;
-
-      var diff = 0d;
-      var comparableLength = 0;
-
-      if (!resultStack.IsEmpty) {
-        var count = Math.Min(estimated.Count, resultStack.Count);
-        var result = resultStack.Peek(count);
-        comparableLength = Math.Min(estimated.Count, result.Count);
-
-        for (var i = 0; i < comparableLength; i++) {
-          diff += Math.Min(differ(estimated[i], result[i]), worstResult);
-        }
-      }
-
-      var emptyTArray = new T[0];
-      for (var i = comparableLength; i < estimated.Count - comparableLength; i++) {
-        diff += differ(estimated[i], emptyTArray);
-      }
-
-      return diff;
-    }
-
-    private static double GetDiff<T>(IReadOnlyList<T> estimated, IPushStack<T> resultStack, double worstResult, Func<T, T, double> differ)
-      where T : IComparable {
-      if (estimated.Count == 0) return 0d;
-
-      var diff = 0d;
-      var comparableLength = 0;
-
-      if (!resultStack.IsEmpty) {
-        var count = Math.Min(estimated.Count, resultStack.Count);
-        var result = resultStack.Peek(count);
-        comparableLength = Math.Min(estimated.Count, result.Count);
-
-        for (var i = 0; i < comparableLength; i++) {
-          diff += Math.Min(differ(estimated[i], result[i]), worstResult);
-        }
-      }
-
-      for (var i = comparableLength; i < estimated.Count - comparableLength; i++) {
-        diff += differ(estimated[i], default(T));
-      }
-
-      return diff;
-    }
-
-    /// <summary>
-    /// https://www.dotnetperls.com/levenshtein
-    /// </summary>
-    private static int LevenshteinDistance(string source, string target) {
-      if (source == null && target == null) return 0;
-      if (source == null) return target.Length;
-      if (target == null) return source.Length;
-
-      int n = source.Length;
-      int m = target.Length;
-      int[,] d = new int[n + 1, m + 1];
-
-      // Step 1
-      if (n == 0) {
-        return m;
-      }
-
-      if (m == 0) {
-        return n;
-      }
-
-      // Step 2
-      for (int i = 0; i <= n; d[i, 0] = i++) {
-      }
-
-      for (int j = 0; j <= m; d[0, j] = j++) {
-      }
-
-      // Step 3
-      for (int i = 1; i <= n; i++) {
-        //Step 4
-        for (int j = 1; j <= m; j++) {
-          // Step 5
-          int cost = (target[j - 1] == source[i - 1]) ? 0 : 1;
-
-          // Step 6
-          d[i, j] = Math.Min(
-              Math.Min(d[i - 1, j] + 1, d[i, j - 1] + 1),
-              d[i - 1, j - 1] + cost);
-        }
-      }
-      // Step 7
-      return d[n, m];
-    }
-  }
-}
Index: anches/PushGP/HeuristicLab.PushGP/HeuristicLab.Problems.ProgramSynthesis/Push/Problem/BenchmarkSuite/PushBenchmarkSuiteSolution.cs
===================================================================
--- /branches/PushGP/HeuristicLab.PushGP/HeuristicLab.Problems.ProgramSynthesis/Push/Problem/BenchmarkSuite/PushBenchmarkSuiteSolution.cs	(revision 15288)
+++ 	(revision )
@@ -1,34 +1,0 @@
-﻿namespace HeuristicLab.Problems.ProgramSynthesis.Push.Problem.BenchmarkSuite {
-  using Common;
-  using Configuration;
-  using Core;
-
-  using HeuristicLab.Problems.ProgramSynthesis.Push.Expressions;
-
-  using Persistence.Default.CompositeSerializers.Storable;
-
-  [StorableClass]
-  public class PushBenchmarkSuiteSolution : PushSolution {
-    public PushBenchmarkSuiteSolution(
-      PushProgram program,
-      double quality,
-      IRandom random,
-      IReadOnlyPushConfiguration config,
-      PushBenchmarkSuiteEvaluator evaluator,
-      bool simplify = false) : base(program, quality, random, config, evaluator, simplify) {
-    }
-
-    public PushBenchmarkSuiteSolution(PushBenchmarkSuiteSolution origin, Cloner cloner) : base(origin, cloner) { }
-
-    [StorableConstructor]
-    public PushBenchmarkSuiteSolution(bool deserializing) : base(deserializing) { }
-
-    public override PushSolution Simplify() {
-      return new PushBenchmarkSuiteSolution(Program, Quality, Random, Config, (PushBenchmarkSuiteEvaluator)Evaluator, true);
-    }
-
-    public override IDeepCloneable Clone(Cloner cloner) {
-      return new PushBenchmarkSuiteSolution(this, cloner);
-    }
-  }
-}
Index: anches/PushGP/HeuristicLab.PushGP/HeuristicLab.Problems.ProgramSynthesis/Push/Problem/EvaluationResult.cs
===================================================================
--- /branches/PushGP/HeuristicLab.PushGP/HeuristicLab.Problems.ProgramSynthesis/Push/Problem/EvaluationResult.cs	(revision 15288)
+++ 	(revision )
@@ -1,11 +1,0 @@
-﻿namespace HeuristicLab.Problems.ProgramSynthesis.Push.Problem {
-  public class EvaluationResult {
-    public EvaluationResult(int exampleCount) {
-      ExampleQualities = new double[exampleCount];
-    }
-
-
-    public double AvgQuality { get; set; }
-    public double[] ExampleQualities { get; set; }
-  }
-}
Index: anches/PushGP/HeuristicLab.PushGP/HeuristicLab.Problems.ProgramSynthesis/Push/Problem/IPushEvaluator.cs
===================================================================
--- /branches/PushGP/HeuristicLab.PushGP/HeuristicLab.Problems.ProgramSynthesis/Push/Problem/IPushEvaluator.cs	(revision 15288)
+++ 	(revision )
@@ -1,16 +1,0 @@
-﻿namespace HeuristicLab.Problems.ProgramSynthesis.Push.Problem {
-  using HeuristicLab.Common;
-  using HeuristicLab.Core;
-  using HeuristicLab.Problems.ProgramSynthesis.Push.Configuration;
-  using HeuristicLab.Problems.ProgramSynthesis.Push.Expressions;
-  using HeuristicLab.Problems.ProgramSynthesis.Push.Interpreter;
-
-  public interface IPushEvaluator : IDeepCloneable {
-    EvaluationResult EvaluateTest(IReadOnlyPushConfiguration config, PushProgram program, IRandom random);
-    EvaluationResult EvaluateTest(IPushInterpreter interpreter, PushProgram program);
-    EvaluationResult EvaluateTest(PushInterpreterPool pool, PushProgram program, IRandom random);
-    EvaluationResult EvaluateTraining(IReadOnlyPushConfiguration config, PushProgram program, IRandom random);
-    EvaluationResult EvaluateTraining(IPushInterpreter interpreter, PushProgram program);
-    EvaluationResult EvaluateTraining(PushInterpreterPool pool, PushProgram program, IRandom random);
-  }
-}
Index: /branches/PushGP/HeuristicLab.PushGP/HeuristicLab.Problems.ProgramSynthesis/Push/Problem/IntegerVectorPushProblem.cs
===================================================================
--- /branches/PushGP/HeuristicLab.PushGP/HeuristicLab.Problems.ProgramSynthesis/Push/Problem/IntegerVectorPushProblem.cs	(revision 15288)
+++ /branches/PushGP/HeuristicLab.PushGP/HeuristicLab.Problems.ProgramSynthesis/Push/Problem/IntegerVectorPushProblem.cs	(revision 15289)
@@ -4,11 +4,11 @@
   using Common;
   using Configuration;
-  using Core;
-  using HeuristicLab.Data;
   using HeuristicLab.Encodings.IntegerVectorEncoding;
   using HeuristicLab.Problems.ProgramSynthesis.Push.Analyzer;
+  using HeuristicLab.Problems.ProgramSynthesis.Push.Evaluator;
   using HeuristicLab.Problems.ProgramSynthesis.Push.Expressions;
   using HeuristicLab.Problems.ProgramSynthesis.Push.Individual;
   using HeuristicLab.Problems.ProgramSynthesis.Push.SolutionCreator;
+
   using Optimization;
   using Persistence.Default.CompositeSerializers.Storable;
@@ -54,5 +54,4 @@
     //  IndividualMapper.Clear();
     //  RandomPool.Clear();
-    //  Config.Seed = 0;
     //}
 
@@ -81,27 +80,23 @@
     }
 
-    protected override PushProgram MapIndividual(Individual individual, IRandom random) {
-      var program = individual.ToPushProgram(Config, random);
+    protected override PushProgram MapIndividual(Individual individual) {
+      var program = individual.ToPushProgram(Config);
 
       return program;
     }
 
-    public override double Evaluate(Individual individual, IRandom random) {
-      // init seed of random pool
-      //Interlocked.CompareExchange(ref RandomPool.Seed, random.Next(), 0);
-      //Config.Seed = RandomPool.Seed;
+    //public override double Evaluate(Individual individual, IRandom random) {
+    //  var seed = random.Next();
 
-      //var rand = RandomPool.ResetAndAllocate();
-      var program = MapIndividual(individual, random);
-      //RandomPool.Free(rand);
+    //  var program = individual.ToPushProgram(Config);
 
-      //rand = RandomPool.ResetAndAllocate();
-      var result = PushEvaluator.EvaluateTraining(Pool, program, random);
-      //RandomPool.Free(rand);
+    //  var rand = new FastRandom(seed);
+    //  var result = PushEvaluator.EvaluateTraining(Pool, program, rand);
 
-      individual[CaseQualitiesScopeParameterName] = new DoubleArray(result.ExampleQualities);
+    //  individual[CaseQualitiesScopeParameterName] = new DoubleArray(result.ExampleQualities);
+    //  individual[SeedScopeParameterName] = new IntValue(seed);
 
-      return result.AvgQuality;
-    }
+    //  return result.AvgQuality;
+    //}
   }
 }
Index: /branches/PushGP/HeuristicLab.PushGP/HeuristicLab.Problems.ProgramSynthesis/Push/Problem/PlushPushProblem.cs
===================================================================
--- /branches/PushGP/HeuristicLab.PushGP/HeuristicLab.Problems.ProgramSynthesis/Push/Problem/PlushPushProblem.cs	(revision 15288)
+++ /branches/PushGP/HeuristicLab.PushGP/HeuristicLab.Problems.ProgramSynthesis/Push/Problem/PlushPushProblem.cs	(revision 15289)
@@ -9,4 +9,5 @@
   using HeuristicLab.Problems.ProgramSynthesis.Push.Analyzer;
   using HeuristicLab.Problems.ProgramSynthesis.Push.Encoding;
+  using HeuristicLab.Problems.ProgramSynthesis.Push.Evaluator;
   using HeuristicLab.Problems.ProgramSynthesis.Push.Expressions;
 
@@ -43,5 +44,5 @@
     }
 
-    protected override PushProgram MapIndividual(Individual individual, IRandom random) {
+    protected override PushProgram MapIndividual(Individual individual) {
       var plushVector = individual.PlushVector();
       var program = plushVector.PushProgram;
@@ -49,13 +50,4 @@
       return program;
     }
-
-    public override double Evaluate(Individual individual, IRandom random) {
-      var program = MapIndividual(individual, random);
-      var result = PushEvaluator.EvaluateTraining(Pool, program, random);
-
-      individual[CaseQualitiesScopeParameterName] = new DoubleArray(result.ExampleQualities);
-
-      return result.AvgQuality;
-    }
   }
 }
Index: /branches/PushGP/HeuristicLab.PushGP/HeuristicLab.Problems.ProgramSynthesis/Push/Problem/PushProblemBase.cs
===================================================================
--- /branches/PushGP/HeuristicLab.PushGP/HeuristicLab.Problems.ProgramSynthesis/Push/Problem/PushProblemBase.cs	(revision 15288)
+++ /branches/PushGP/HeuristicLab.PushGP/HeuristicLab.Problems.ProgramSynthesis/Push/Problem/PushProblemBase.cs	(revision 15289)
@@ -10,7 +10,10 @@
   using HeuristicLab.Persistence.Default.CompositeSerializers.Storable;
   using HeuristicLab.Problems.ProgramSynthesis.Push.Configuration;
+  using HeuristicLab.Problems.ProgramSynthesis.Push.Evaluator;
   using HeuristicLab.Problems.ProgramSynthesis.Push.Expressions;
   using HeuristicLab.Problems.ProgramSynthesis.Push.Interpreter;
   using HeuristicLab.Problems.ProgramSynthesis.Push.ObjectPools.Random;
+  using HeuristicLab.Problems.ProgramSynthesis.Push.Solution;
+  using HeuristicLab.Random;
 
   [StorableClass]
@@ -31,4 +34,5 @@
     public const string CasesScopeParameterName = "CaseQualities";
     public const string CaseQualitiesScopeParameterName = "CaseQualities";
+    public const string SeedScopeParameterName = "Seed";
 
     protected PushProblemBase(IPushEvaluator evaluator) {
@@ -88,15 +92,19 @@
       var bestQuality = Maximization ? qualities.Max() : qualities.Min();
       var bestIdx = Array.IndexOf(qualities, bestQuality);
-      var program = MapIndividual(individuals[bestIdx], random);
+      var bestIndividual = individuals[bestIdx];
+      var seed = (IntValue)bestIndividual[SeedScopeParameterName];
+      var program = MapIndividual(bestIndividual);
 
-      var isIndividualBetter = AnalyzeBestTrainingSolution(program, bestQuality, results, random);
+      var rand = new FastRandom(seed.Value);
+      var isIndividualBetter = AnalyzeBestTrainingSolution(program, bestQuality, results, rand);
 
       if (isIndividualBetter) {
-        AnalyzeBestTestSolution(program, results, random);
+        rand.Reset(seed.Value);
+        AnalyzeBestTestSolution(program, results, rand);
       }
     }
 
     protected void AnalyzeBestTestSolution(PushProgram program, ResultCollection results, IRandom random) {
-      var testResult = PushEvaluator.EvaluateTraining(Pool, program, random);
+      var testResult = PushEvaluator.EvaluateTest(Pool, program, random);
 
       if (!results.ContainsKey(TEST_QUALITY_RESULT_NAME)) {
@@ -108,11 +116,11 @@
 
     protected bool AnalyzeBestTrainingSolution(PushProgram program, double bestQuality, ResultCollection results, IRandom random) {
-      if (!results.ContainsKey(BEST_TRAINING_SOLUTION_RESULT_NAME)) {
-        var solution = CreatePushSolution(
+      var solution = CreatePushSolution(
             program,
             bestQuality,
-            (IRandom)random.Clone(),
+            random, // is already cloned
             (IReadOnlyPushConfiguration)Config.Clone());
 
+      if (!results.ContainsKey(BEST_TRAINING_SOLUTION_RESULT_NAME)) {
         results.Add(new Result(BEST_TRAINING_SOLUTION_RESULT_NAME, solution));
         return true;
@@ -123,9 +131,5 @@
       if ((!Maximization && currentBestQuality > bestQuality) ||
            (Maximization && currentBestQuality < bestQuality)) {
-        results[BEST_TRAINING_SOLUTION_RESULT_NAME].Value = CreatePushSolution(
-            program,
-            bestQuality,
-            random,
-            Config);
+        results[BEST_TRAINING_SOLUTION_RESULT_NAME].Value = solution;
         return true;
       }
@@ -135,13 +139,16 @@
 
     public override double Evaluate(Individual individual, IRandom random) {
-      var program = MapIndividual(individual, random);
-      var result = PushEvaluator.EvaluateTraining(Pool, program, random);
+      var program = MapIndividual(individual);
+      var seed = random.Next();
+      var rand = new FastRandom(seed);
+      var result = PushEvaluator.EvaluateTraining(Pool, program, rand);
 
       individual[CaseQualitiesScopeParameterName] = new DoubleArray(result.ExampleQualities);
+      individual[SeedScopeParameterName] = new IntValue(seed);
 
       return result.AvgQuality;
     }
 
-    protected abstract PushProgram MapIndividual(Individual individual, IRandom random);
+    protected abstract PushProgram MapIndividual(Individual individual);
 
     protected abstract PushSolution CreatePushSolution(
Index: anches/PushGP/HeuristicLab.PushGP/HeuristicLab.Problems.ProgramSynthesis/Push/Problem/PushSolution.cs
===================================================================
--- /branches/PushGP/HeuristicLab.PushGP/HeuristicLab.Problems.ProgramSynthesis/Push/Problem/PushSolution.cs	(revision 15288)
+++ 	(revision )
@@ -1,63 +1,0 @@
-﻿namespace HeuristicLab.Problems.ProgramSynthesis.Push.Problem {
-  using Common;
-  using Configuration;
-  using Core;
-  using Expressions;
-  using Persistence.Default.CompositeSerializers.Storable;
-
-  [StorableClass]
-  public class PushSolution : NamedItem {
-    [Storable]
-    public readonly double Quality;
-    [Storable]
-    protected readonly IRandom Random;
-    [Storable]
-    public readonly IReadOnlyPushConfiguration Config;
-    [Storable]
-    public readonly IPushEvaluator Evaluator;
-    [Storable]
-    protected readonly bool simplify;
-    [Storable]
-    public PushProgram Program;
-
-
-    public PushSolution(PushProgram program, double quality, IRandom random, IReadOnlyPushConfiguration config, IPushEvaluator evaluator, bool simplify = false)
-      : base("Solution", "A push solution.") {
-      Quality = quality;
-      Random = random;
-      Config = config;
-      Evaluator = evaluator;
-      this.simplify = simplify;
-
-      Program = simplify
-        ? Simplifier.Simplifier.Simplify(program, Config, p => Evaluator.EvaluateTraining(Config, p, Random).AvgQuality)
-        : program;
-
-    }
-
-    public PushSolution(PushSolution origin, Cloner cloner) : base(origin, cloner) {
-      Program = cloner.Clone(origin.Program);
-      Quality = origin.Quality;
-      Random = cloner.Clone(origin.Random);
-      Config = cloner.Clone(origin.Config);
-      Evaluator = cloner.Clone(origin.Evaluator);
-      Program = origin.Program; // push programs are immutable like all expressions
-      simplify = origin.simplify;
-    }
-
-    public IRandom GetRandom() {
-      return (IRandom)Random.Clone();
-    }
-
-    public virtual PushSolution Simplify() {
-      return new PushSolution(Program, Quality, Random, Config, Evaluator, true);
-    }
-
-    [StorableConstructor]
-    protected PushSolution(bool deserializing) : base(deserializing) { }
-
-    public override IDeepCloneable Clone(Cloner cloner) {
-      return new PushSolution(this, cloner);
-    }
-  }
-}
Index: /branches/PushGP/HeuristicLab.PushGP/HeuristicLab.Problems.ProgramSynthesis/Push/Selector/LexicaseSelector.cs
===================================================================
--- /branches/PushGP/HeuristicLab.PushGP/HeuristicLab.Problems.ProgramSynthesis/Push/Selector/LexicaseSelector.cs	(revision 15288)
+++ /branches/PushGP/HeuristicLab.PushGP/HeuristicLab.Problems.ProgramSynthesis/Push/Selector/LexicaseSelector.cs	(revision 15289)
@@ -60,10 +60,23 @@
 
     protected override IScope[] Select(List<IScope> population) {
-      var count = NumberOfSelectedSubScopesParameter.ActualValue.Value;
-      var copy = CopySelectedParameter.Value.Value;
-      var maximization = MaximizationParameter.ActualValue.Value;
-      var random = RandomParameter.ActualValue;
+      var selected = Apply(
+        population,
+        NumberOfSelectedSubScopesParameter.ActualValue.Value,
+        CopySelectedParameter.Value.Value,
+        MaximizationParameter.ActualValue.Value,
+        RandomParameter.ActualValue,
+        CaseQualitiesParameter.ActualValue);
+
+      return selected;
+    }
+
+    public static IScope[] Apply(
+      List<IScope> population,
+      int count,
+      bool copy,
+      bool maximization,
+      IRandom random,
+      ItemArray<DoubleArray> caseQualities) {
       var selected = new IScope[count];
-      var caseQualities = CaseQualitiesParameter.ActualValue;
       var repeats = (int)Math.Ceiling(count / (double)population.Count);
       var caseCount = caseQualities[0].Length;
Index: /branches/PushGP/HeuristicLab.PushGP/HeuristicLab.Problems.ProgramSynthesis/Push/Solution/BenchmarkSuite/BenchmarkSuitePushSolutionView.Designer.cs
===================================================================
--- /branches/PushGP/HeuristicLab.PushGP/HeuristicLab.Problems.ProgramSynthesis/Push/Solution/BenchmarkSuite/BenchmarkSuitePushSolutionView.Designer.cs	(revision 15289)
+++ /branches/PushGP/HeuristicLab.PushGP/HeuristicLab.Problems.ProgramSynthesis/Push/Solution/BenchmarkSuite/BenchmarkSuitePushSolutionView.Designer.cs	(revision 15289)
@@ -0,0 +1,212 @@
+﻿namespace HeuristicLab.Problems.ProgramSynthesis.Push.Solution.BenchmarkSuite {
+  using HeuristicLab.Problems.ProgramSynthesis.Push.Views;
+
+  partial class BenchmarkSuitePushSolutionView {
+    /// <summary>
+    /// Required designer variable.
+    /// </summary>
+    private System.ComponentModel.IContainer components = null;
+
+    /// <summary>
+    /// Clean up any resources being used.
+    /// </summary>
+    /// <param name="disposing">true if managed resources should be disposed; otherwise, false.</param>
+    protected override void Dispose(bool disposing) {
+      if (disposing && (this.components != null)) {
+        this.components.Dispose();
+      }
+      base.Dispose(disposing);
+    }
+
+    #region Component Designer generated code
+
+    /// <summary>
+    /// Required method for Designer support - do not modify
+    /// the contents of this method with the code editor.
+    /// </summary>
+    private void InitializeComponent() {
+      System.Windows.Forms.DataGridViewCellStyle dataGridViewCellStyle1 = new System.Windows.Forms.DataGridViewCellStyle();
+      this.tabControl = new System.Windows.Forms.TabControl();
+      this.tabPage1 = new System.Windows.Forms.TabPage();
+      this.exampleComboBox = new System.Windows.Forms.ComboBox();
+      this.label1 = new System.Windows.Forms.Label();
+      this.tabPage2 = new System.Windows.Forms.TabPage();
+      this.trainingResultsDataGrid = new System.Windows.Forms.DataGridView();
+      this.tabPage3 = new System.Windows.Forms.TabPage();
+      this.testResultsDataGrid = new System.Windows.Forms.DataGridView();
+      this.pushDebugger = new HeuristicLab.Problems.ProgramSynthesis.Push.Views.PushDebuggerView();
+      ((System.ComponentModel.ISupportInitialize)(this.errorProvider)).BeginInit();
+      this.tabControl.SuspendLayout();
+      this.tabPage1.SuspendLayout();
+      this.tabPage2.SuspendLayout();
+      ((System.ComponentModel.ISupportInitialize)(this.trainingResultsDataGrid)).BeginInit();
+      this.tabPage3.SuspendLayout();
+      ((System.ComponentModel.ISupportInitialize)(this.testResultsDataGrid)).BeginInit();
+      this.SuspendLayout();
+      //
+      // nameTextBox
+      //
+      this.errorProvider.SetIconAlignment(this.nameTextBox, System.Windows.Forms.ErrorIconAlignment.MiddleLeft);
+      this.errorProvider.SetIconPadding(this.nameTextBox, 2);
+      this.nameTextBox.Size = new System.Drawing.Size(755, 20);
+      //
+      // infoLabel
+      //
+      this.infoLabel.Location = new System.Drawing.Point(838, 3);
+      //
+      // tabControl
+      //
+      this.tabControl.Anchor = ((System.Windows.Forms.AnchorStyles)((((System.Windows.Forms.AnchorStyles.Top | System.Windows.Forms.AnchorStyles.Bottom)
+            | System.Windows.Forms.AnchorStyles.Left)
+            | System.Windows.Forms.AnchorStyles.Right)));
+      this.tabControl.Controls.Add(this.tabPage1);
+      this.tabControl.Controls.Add(this.tabPage2);
+      this.tabControl.Controls.Add(this.tabPage3);
+      this.tabControl.Location = new System.Drawing.Point(6, 26);
+      this.tabControl.Name = "tabControl";
+      this.tabControl.SelectedIndex = 0;
+      this.tabControl.Size = new System.Drawing.Size(848, 602);
+      this.tabControl.TabIndex = 12;
+      //
+      // tabPage1
+      //
+      this.tabPage1.AutoScroll = true;
+      this.tabPage1.Controls.Add(this.pushDebugger);
+      this.tabPage1.Controls.Add(this.exampleComboBox);
+      this.tabPage1.Controls.Add(this.label1);
+      this.tabPage1.Location = new System.Drawing.Point(4, 22);
+      this.tabPage1.Name = "tabPage1";
+      this.tabPage1.Padding = new System.Windows.Forms.Padding(3);
+      this.tabPage1.Size = new System.Drawing.Size(840, 576);
+      this.tabPage1.TabIndex = 0;
+      this.tabPage1.Text = "Debug";
+      this.tabPage1.UseVisualStyleBackColor = true;
+      //
+      // exampleComboBox
+      //
+      this.exampleComboBox.Anchor = ((System.Windows.Forms.AnchorStyles)(((System.Windows.Forms.AnchorStyles.Top | System.Windows.Forms.AnchorStyles.Left)
+            | System.Windows.Forms.AnchorStyles.Right)));
+      this.exampleComboBox.FormattingEnabled = true;
+      this.exampleComboBox.Location = new System.Drawing.Point(58, 6);
+      this.exampleComboBox.Name = "exampleComboBox";
+      this.exampleComboBox.Size = new System.Drawing.Size(776, 21);
+      this.exampleComboBox.TabIndex = 11;
+      //
+      // label1
+      //
+      this.label1.AutoSize = true;
+      this.label1.Location = new System.Drawing.Point(3, 9);
+      this.label1.Name = "label1";
+      this.label1.Size = new System.Drawing.Size(50, 13);
+      this.label1.TabIndex = 10;
+      this.label1.Text = "Example:";
+      //
+      // tabPage2
+      //
+      this.tabPage2.Controls.Add(this.trainingResultsDataGrid);
+      this.tabPage2.Location = new System.Drawing.Point(4, 22);
+      this.tabPage2.Name = "tabPage2";
+      this.tabPage2.Padding = new System.Windows.Forms.Padding(3);
+      this.tabPage2.Size = new System.Drawing.Size(840, 576);
+      this.tabPage2.TabIndex = 1;
+      this.tabPage2.Text = "Traning Results";
+      this.tabPage2.UseVisualStyleBackColor = true;
+      //
+      // trainingResultsDataGrid
+      //
+      this.trainingResultsDataGrid.AllowUserToAddRows = false;
+      this.trainingResultsDataGrid.AllowUserToDeleteRows = false;
+      this.trainingResultsDataGrid.AutoSizeRowsMode = System.Windows.Forms.DataGridViewAutoSizeRowsMode.AllCells;
+      this.trainingResultsDataGrid.ColumnHeadersHeightSizeMode = System.Windows.Forms.DataGridViewColumnHeadersHeightSizeMode.AutoSize;
+      dataGridViewCellStyle1.Alignment = System.Windows.Forms.DataGridViewContentAlignment.MiddleLeft;
+      dataGridViewCellStyle1.BackColor = System.Drawing.SystemColors.Window;
+      dataGridViewCellStyle1.Font = new System.Drawing.Font("Microsoft Sans Serif", 8.25F, System.Drawing.FontStyle.Regular, System.Drawing.GraphicsUnit.Point, ((byte)(0)));
+      dataGridViewCellStyle1.ForeColor = System.Drawing.SystemColors.ControlText;
+      dataGridViewCellStyle1.SelectionBackColor = System.Drawing.SystemColors.Highlight;
+      dataGridViewCellStyle1.SelectionForeColor = System.Drawing.SystemColors.HighlightText;
+      dataGridViewCellStyle1.WrapMode = System.Windows.Forms.DataGridViewTriState.True;
+      this.trainingResultsDataGrid.DefaultCellStyle = dataGridViewCellStyle1;
+      this.trainingResultsDataGrid.Dock = System.Windows.Forms.DockStyle.Fill;
+      this.trainingResultsDataGrid.EditMode = System.Windows.Forms.DataGridViewEditMode.EditProgrammatically;
+      this.trainingResultsDataGrid.Location = new System.Drawing.Point(3, 3);
+      this.trainingResultsDataGrid.Name = "trainingResultsDataGrid";
+      this.trainingResultsDataGrid.ReadOnly = true;
+      this.trainingResultsDataGrid.RowHeadersWidthSizeMode = System.Windows.Forms.DataGridViewRowHeadersWidthSizeMode.AutoSizeToAllHeaders;
+      this.trainingResultsDataGrid.Size = new System.Drawing.Size(834, 570);
+      this.trainingResultsDataGrid.TabIndex = 0;
+      //
+      // tabPage3
+      //
+      this.tabPage3.Controls.Add(this.testResultsDataGrid);
+      this.tabPage3.Location = new System.Drawing.Point(4, 22);
+      this.tabPage3.Name = "tabPage3";
+      this.tabPage3.Size = new System.Drawing.Size(840, 576);
+      this.tabPage3.TabIndex = 2;
+      this.tabPage3.Text = "Test Results";
+      this.tabPage3.UseVisualStyleBackColor = true;
+      //
+      // testResultsDataGrid
+      //
+      this.testResultsDataGrid.AllowUserToAddRows = false;
+      this.testResultsDataGrid.AllowUserToDeleteRows = false;
+      this.testResultsDataGrid.AutoSizeRowsMode = System.Windows.Forms.DataGridViewAutoSizeRowsMode.AllHeaders;
+      this.testResultsDataGrid.ColumnHeadersHeightSizeMode = System.Windows.Forms.DataGridViewColumnHeadersHeightSizeMode.AutoSize;
+      this.testResultsDataGrid.Dock = System.Windows.Forms.DockStyle.Fill;
+      this.testResultsDataGrid.EditMode = System.Windows.Forms.DataGridViewEditMode.EditProgrammatically;
+      this.testResultsDataGrid.Location = new System.Drawing.Point(0, 0);
+      this.testResultsDataGrid.Name = "testResultsDataGrid";
+      this.testResultsDataGrid.ReadOnly = true;
+      this.testResultsDataGrid.RowHeadersWidthSizeMode = System.Windows.Forms.DataGridViewRowHeadersWidthSizeMode.AutoSizeToAllHeaders;
+      this.testResultsDataGrid.Size = new System.Drawing.Size(840, 576);
+      this.testResultsDataGrid.TabIndex = 1;
+      //
+      // pushDebugger
+      //
+      this.pushDebugger.Anchor = ((System.Windows.Forms.AnchorStyles)((((System.Windows.Forms.AnchorStyles.Top | System.Windows.Forms.AnchorStyles.Bottom)
+            | System.Windows.Forms.AnchorStyles.Left)
+            | System.Windows.Forms.AnchorStyles.Right)));
+      this.pushDebugger.Caption = "View";
+      this.pushDebugger.Content = null;
+      this.pushDebugger.Location = new System.Drawing.Point(6, 33);
+      this.pushDebugger.Name = "pushDebugger";
+      this.pushDebugger.ReadOnly = false;
+      this.pushDebugger.Size = new System.Drawing.Size(831, 540);
+      this.pushDebugger.TabIndex = 12;
+      //
+      // BenchmarkSuitePushSolutionView
+      //
+      this.AutoScaleDimensions = new System.Drawing.SizeF(6F, 13F);
+      this.AutoScaleMode = System.Windows.Forms.AutoScaleMode.Font;
+      this.Controls.Add(this.tabControl);
+      this.Name = "BenchmarkSuitePushSolutionView";
+      this.Size = new System.Drawing.Size(857, 631);
+      this.Controls.SetChildIndex(this.tabControl, 0);
+      this.Controls.SetChildIndex(this.nameLabel, 0);
+      this.Controls.SetChildIndex(this.nameTextBox, 0);
+      this.Controls.SetChildIndex(this.infoLabel, 0);
+      ((System.ComponentModel.ISupportInitialize)(this.errorProvider)).EndInit();
+      this.tabControl.ResumeLayout(false);
+      this.tabPage1.ResumeLayout(false);
+      this.tabPage1.PerformLayout();
+      this.tabPage2.ResumeLayout(false);
+      ((System.ComponentModel.ISupportInitialize)(this.trainingResultsDataGrid)).EndInit();
+      this.tabPage3.ResumeLayout(false);
+      ((System.ComponentModel.ISupportInitialize)(this.testResultsDataGrid)).EndInit();
+      this.ResumeLayout(false);
+      this.PerformLayout();
+
+    }
+
+    #endregion
+
+    private System.Windows.Forms.TabControl tabControl;
+    private System.Windows.Forms.TabPage tabPage1;
+    private System.Windows.Forms.ComboBox exampleComboBox;
+    private System.Windows.Forms.Label label1;
+    private System.Windows.Forms.TabPage tabPage2;
+    private System.Windows.Forms.DataGridView trainingResultsDataGrid;
+    private PushDebuggerView pushDebugger;
+    private System.Windows.Forms.TabPage tabPage3;
+    private System.Windows.Forms.DataGridView testResultsDataGrid;
+  }
+}
Index: /branches/PushGP/HeuristicLab.PushGP/HeuristicLab.Problems.ProgramSynthesis/Push/Solution/BenchmarkSuite/BenchmarkSuitePushSolutionView.cs
===================================================================
--- /branches/PushGP/HeuristicLab.PushGP/HeuristicLab.Problems.ProgramSynthesis/Push/Solution/BenchmarkSuite/BenchmarkSuitePushSolutionView.cs	(revision 15289)
+++ /branches/PushGP/HeuristicLab.PushGP/HeuristicLab.Problems.ProgramSynthesis/Push/Solution/BenchmarkSuite/BenchmarkSuitePushSolutionView.cs	(revision 15289)
@@ -0,0 +1,231 @@
+﻿namespace HeuristicLab.Problems.ProgramSynthesis.Push.Solution.BenchmarkSuite {
+  using System;
+  using System.Drawing;
+  using System.Linq;
+  using System.Windows.Forms;
+
+  using HeuristicLab.BenchmarkSuite;
+  using HeuristicLab.BenchmarkSuite.Views;
+  using HeuristicLab.Common;
+  using HeuristicLab.Core.Views;
+  using HeuristicLab.MainForm;
+  using HeuristicLab.Problems.ProgramSynthesis.Push.Evaluator;
+  using HeuristicLab.Problems.ProgramSynthesis.Push.Interpreter;
+  using HeuristicLab.Problems.ProgramSynthesis.Push.Solution;
+
+  [View("Push Program Debugger")]
+  [Content(typeof(PushSolution), true)]
+  public partial class BenchmarkSuitePushSolutionView : NamedItemView {
+
+    private const string Separator = ", ";
+
+    private const string exampleSplitter = " => ";
+    private const string AbsoluteDiffHeaderText = "Absolute Diff.";
+    private const string RelativeDiffHeaderText = "Relative Diff.";
+    private const string InputHeaderStringFormat = "Input {0} : {1}";
+    private const string EstimatedOutputHeaderStringFormat = "Expected Output {0} : {1}";
+    private const string OutputHeaderStringFormat = "Output {0} : {1}";
+    private static readonly Color correctExampleFontColor = Color.FromArgb(0x5cb85c);
+    private PooledPushInterpreter interpreter;
+    private PushInterpreterPool pool;
+
+    public BenchmarkSuitePushSolutionView() {
+      InitializeComponent();
+      Name = "Push Program Debugger";
+      InitEvents();
+    }
+
+    ~BenchmarkSuitePushSolutionView() {
+      interpreter.Dispose();
+    }
+
+    private void InitEvents() {
+      exampleComboBox.SelectedIndexChanged += SelectedExampleIndexChanged;
+      pushDebugger.OnReset += PushDebuggerReset;
+    }
+
+    private void PushDebuggerReset(object sender, IPushInterpreter interpreter) {
+      if (exampleComboBox.SelectedIndex < 0) return;
+
+      var example = Evaluator.Data.Examples[exampleComboBox.SelectedIndex];
+
+      interpreter.InitExample(example);
+    }
+
+    private void SelectedExampleIndexChanged(object sender, EventArgs e) {
+      pushDebugger.ResetDebugging();
+    }
+
+    public new PushBenchmarkSuiteSolution Content
+    {
+      get { return (PushBenchmarkSuiteSolution)base.Content; }
+      set
+      {
+        base.Content = value;
+      }
+    }
+
+    public PushBenchmarkSuiteEvaluator Evaluator
+    {
+      get { return (PushBenchmarkSuiteEvaluator)Content.Evaluator; }
+    }
+
+
+    protected override void OnContentChanged() {
+      if (Content == null) return;
+
+      Name = "Push Solution";
+      nameTextBox.Text = Name;
+
+      pool = new PushInterpreterPool(Content.Config);
+
+      if (interpreter != null) {
+        interpreter.Dispose();
+      }
+
+      var random = Content.GetRandom();
+      interpreter = pool.Create(random);
+      UpdateExamples(Evaluator.Data);
+
+      if (exampleComboBox.SelectedIndex < 0) {
+        exampleComboBox.SelectedIndex = 0; // Triggers ResetDebugging via event
+      }
+
+      InitResultGrid(trainingResultsDataGrid, Evaluator.DataBounds.TrainingRange.Start, Evaluator.DataBounds.TrainingRange.End);
+      InitResultGrid(testResultsDataGrid, Evaluator.DataBounds.TestRange.Start, Evaluator.DataBounds.TestRange.End);
+
+      pushDebugger.Content = Content;
+    }
+
+    private void InitResultGrid(DataGridView grid, int start, int end) {
+      grid.Columns.Clear();
+      grid.Rows.Clear();
+
+      var cellTemplate = new DataGridViewTextBoxCell { Style = { WrapMode = DataGridViewTriState.True } };
+      var data = Evaluator.Data;
+
+      for (var i = 0; i < data.InputArgumentTypes.Length; i++) {
+        var headerTypeName = ViewHelper.GetHeaderTypeName(data.InputArgumentTypes[i]);
+        var column = new DataGridViewColumn {
+          HeaderText = string.Format(InputHeaderStringFormat, i + 1, headerTypeName),
+          AutoSizeMode = DataGridViewAutoSizeColumnMode.Fill,
+          CellTemplate = cellTemplate,
+          DefaultCellStyle = { Alignment = DataGridViewContentAlignment.MiddleRight },
+          SortMode = DataGridViewColumnSortMode.Automatic
+        };
+
+        grid.Columns.Add(column);
+      }
+
+      for (var i = 0; i < data.OutputArgumentTypes.Length; i++) {
+        var headerTypeName = ViewHelper.GetHeaderTypeName(data.OutputArgumentTypes[i]);
+
+        var estimatedOutputColumn = new DataGridViewColumn {
+          HeaderText = string.Format(EstimatedOutputHeaderStringFormat, i + 1, headerTypeName),
+          AutoSizeMode = DataGridViewAutoSizeColumnMode.Fill,
+          CellTemplate = cellTemplate,
+          SortMode = DataGridViewColumnSortMode.Automatic
+        };
+
+        var outputColumn = new DataGridViewColumn {
+          HeaderText = string.Format(OutputHeaderStringFormat, i + 1, headerTypeName),
+          AutoSizeMode = DataGridViewAutoSizeColumnMode.Fill,
+          CellTemplate = cellTemplate,
+          SortMode = DataGridViewColumnSortMode.Automatic
+        };
+
+        estimatedOutputColumn.DefaultCellStyle.Alignment = DataGridViewContentAlignment.MiddleRight;
+        outputColumn.DefaultCellStyle.Alignment = DataGridViewContentAlignment.MiddleRight;
+
+        grid.Columns.Add(estimatedOutputColumn);
+        grid.Columns.Add(outputColumn);
+      }
+
+      var absoluteDiffColumn = new DataGridViewColumn {
+        HeaderText = AbsoluteDiffHeaderText,
+        AutoSizeMode = DataGridViewAutoSizeColumnMode.ColumnHeader,
+        CellTemplate = cellTemplate,
+        SortMode = DataGridViewColumnSortMode.Automatic
+      };
+
+      var relativeDiffColumn = new DataGridViewColumn {
+        HeaderText = RelativeDiffHeaderText,
+        AutoSizeMode = DataGridViewAutoSizeColumnMode.ColumnHeader,
+        CellTemplate = cellTemplate,
+        SortMode = DataGridViewColumnSortMode.Automatic
+      };
+
+      absoluteDiffColumn.DefaultCellStyle.Alignment = DataGridViewContentAlignment.MiddleRight;
+      relativeDiffColumn.DefaultCellStyle.Alignment = DataGridViewContentAlignment.MiddleRight;
+
+      grid.Columns.Add(absoluteDiffColumn);
+      grid.Columns.Add(relativeDiffColumn);
+
+      var random = Content.GetRandom();
+      using (var pushInterpreter = pool.Create(random)) {
+        var rowIndex = 1;
+        for (var i = start; i < end; i++, rowIndex++) {
+          var example = data.Examples[i];
+          var row = new DataGridViewRow {
+            HeaderCell = {
+              Value = rowIndex.ToString(),
+            }
+          };
+
+          row.CreateCells(grid);
+
+          var absoluteDiff = Evaluator.Evaluate(pushInterpreter, Content.Program, i);
+          var relativeDiff = absoluteDiff / Math.Abs(data.BestResult - data.WorstResult) * 100d;
+
+          var inputArgumentCountDict = ViewHelper.CreateArgumentCountDict();
+          for (var j = 0; j < data.InputArgumentTypes.Length; j++) {
+            var type = data.InputArgumentTypes[j];
+            var offset = inputArgumentCountDict[type];
+            row.Cells[j].Value = ViewHelper.StringifyInput(type, offset, Content.Config.FloatStringFormat, example, Separator);
+            inputArgumentCountDict[type]++;
+          }
+
+          var outputArgumentCountDict = ViewHelper.CreateArgumentCountDict();
+          for (var j = 0; j < data.OutputArgumentTypes.Length; j++) {
+            var type = data.OutputArgumentTypes[j];
+            var offset = outputArgumentCountDict[type];
+
+            // expected
+            row.Cells[data.InputArgumentTypes.Length + j * 2].Value = ViewHelper.StringifyOutput(type, offset, Content.Config.FloatStringFormat, example, Separator);
+
+            // output
+            row.Cells[data.InputArgumentTypes.Length + j * 2 + 1].Value = pushInterpreter.StringifyResult(type, offset);
+
+            outputArgumentCountDict[type]++;
+          }
+
+          row.Cells[data.TotalArgumentCount + 1].Value = absoluteDiff.ToString("0.####");
+          row.Cells[data.TotalArgumentCount + 2].Value = relativeDiff.ToString("0.##") + "%";
+
+          if (absoluteDiff.IsAlmost(data.BestResult)) {
+            for (var j = 0; j < row.Cells.Count; j++) {
+              row.Cells[j].Style.ForeColor = correctExampleFontColor;
+            }
+          }
+
+          grid.Rows.Add(row);
+          pushInterpreter.Reset();
+        }
+      }
+    }
+
+    private void UpdateExamples(ProblemData data) {
+      exampleComboBox.Items.Clear();
+      if (data == null) return;
+
+      var stringRepresentations = data.Examples.Select(e =>
+        string.Join(Separator, e.InputArgs) +
+        exampleSplitter +
+        string.Join(Separator, e.OutputArgs));
+
+      foreach (var str in stringRepresentations) {
+        exampleComboBox.Items.Add(str);
+      }
+    }
+  }
+}
Index: /branches/PushGP/HeuristicLab.PushGP/HeuristicLab.Problems.ProgramSynthesis/Push/Solution/BenchmarkSuite/BenchmarkSuitePushSolutionView.resx
===================================================================
--- /branches/PushGP/HeuristicLab.PushGP/HeuristicLab.Problems.ProgramSynthesis/Push/Solution/BenchmarkSuite/BenchmarkSuitePushSolutionView.resx	(revision 15289)
+++ /branches/PushGP/HeuristicLab.PushGP/HeuristicLab.Problems.ProgramSynthesis/Push/Solution/BenchmarkSuite/BenchmarkSuitePushSolutionView.resx	(revision 15289)
@@ -0,0 +1,126 @@
+﻿<?xml version="1.0" encoding="utf-8"?>
+<root>
+  <!-- 
+    Microsoft ResX Schema 
+    
+    Version 2.0
+    
+    The primary goals of this format is to allow a simple XML format 
+    that is mostly human readable. The generation and parsing of the 
+    various data types are done through the TypeConverter classes 
+    associated with the data types.
+    
+    Example:
+    
+    ... ado.net/XML headers & schema ...
+    <resheader name="resmimetype">text/microsoft-resx</resheader>
+    <resheader name="version">2.0</resheader>
+    <resheader name="reader">System.Resources.ResXResourceReader, System.Windows.Forms, ...</resheader>
+    <resheader name="writer">System.Resources.ResXResourceWriter, System.Windows.Forms, ...</resheader>
+    <data name="Name1"><value>this is my long string</value><comment>this is a comment</comment></data>
+    <data name="Color1" type="System.Drawing.Color, System.Drawing">Blue</data>
+    <data name="Bitmap1" mimetype="application/x-microsoft.net.object.binary.base64">
+        <value>[base64 mime encoded serialized .NET Framework object]</value>
+    </data>
+    <data name="Icon1" type="System.Drawing.Icon, System.Drawing" mimetype="application/x-microsoft.net.object.bytearray.base64">
+        <value>[base64 mime encoded string representing a byte array form of the .NET Framework object]</value>
+        <comment>This is a comment</comment>
+    </data>
+                
+    There are any number of "resheader" rows that contain simple 
+    name/value pairs.
+    
+    Each data row contains a name, and value. The row also contains a 
+    type or mimetype. Type corresponds to a .NET class that support 
+    text/value conversion through the TypeConverter architecture. 
+    Classes that don't support this are serialized and stored with the 
+    mimetype set.
+    
+    The mimetype is used for serialized objects, and tells the 
+    ResXResourceReader how to depersist the object. This is currently not 
+    extensible. For a given mimetype the value must be set accordingly:
+    
+    Note - application/x-microsoft.net.object.binary.base64 is the format 
+    that the ResXResourceWriter will generate, however the reader can 
+    read any of the formats listed below.
+    
+    mimetype: application/x-microsoft.net.object.binary.base64
+    value   : The object must be serialized with 
+            : System.Runtime.Serialization.Formatters.Binary.BinaryFormatter
+            : and then encoded with base64 encoding.
+    
+    mimetype: application/x-microsoft.net.object.soap.base64
+    value   : The object must be serialized with 
+            : System.Runtime.Serialization.Formatters.Soap.SoapFormatter
+            : and then encoded with base64 encoding.
+
+    mimetype: application/x-microsoft.net.object.bytearray.base64
+    value   : The object must be serialized into a byte array 
+            : using a System.ComponentModel.TypeConverter
+            : and then encoded with base64 encoding.
+    -->
+  <xsd:schema id="root" xmlns="" xmlns:xsd="http://www.w3.org/2001/XMLSchema" xmlns:msdata="urn:schemas-microsoft-com:xml-msdata">
+    <xsd:import namespace="http://www.w3.org/XML/1998/namespace" />
+    <xsd:element name="root" msdata:IsDataSet="true">
+      <xsd:complexType>
+        <xsd:choice maxOccurs="unbounded">
+          <xsd:element name="metadata">
+            <xsd:complexType>
+              <xsd:sequence>
+                <xsd:element name="value" type="xsd:string" minOccurs="0" />
+              </xsd:sequence>
+              <xsd:attribute name="name" use="required" type="xsd:string" />
+              <xsd:attribute name="type" type="xsd:string" />
+              <xsd:attribute name="mimetype" type="xsd:string" />
+              <xsd:attribute ref="xml:space" />
+            </xsd:complexType>
+          </xsd:element>
+          <xsd:element name="assembly">
+            <xsd:complexType>
+              <xsd:attribute name="alias" type="xsd:string" />
+              <xsd:attribute name="name" type="xsd:string" />
+            </xsd:complexType>
+          </xsd:element>
+          <xsd:element name="data">
+            <xsd:complexType>
+              <xsd:sequence>
+                <xsd:element name="value" type="xsd:string" minOccurs="0" msdata:Ordinal="1" />
+                <xsd:element name="comment" type="xsd:string" minOccurs="0" msdata:Ordinal="2" />
+              </xsd:sequence>
+              <xsd:attribute name="name" type="xsd:string" use="required" msdata:Ordinal="1" />
+              <xsd:attribute name="type" type="xsd:string" msdata:Ordinal="3" />
+              <xsd:attribute name="mimetype" type="xsd:string" msdata:Ordinal="4" />
+              <xsd:attribute ref="xml:space" />
+            </xsd:complexType>
+          </xsd:element>
+          <xsd:element name="resheader">
+            <xsd:complexType>
+              <xsd:sequence>
+                <xsd:element name="value" type="xsd:string" minOccurs="0" msdata:Ordinal="1" />
+              </xsd:sequence>
+              <xsd:attribute name="name" type="xsd:string" use="required" />
+            </xsd:complexType>
+          </xsd:element>
+        </xsd:choice>
+      </xsd:complexType>
+    </xsd:element>
+  </xsd:schema>
+  <resheader name="resmimetype">
+    <value>text/microsoft-resx</value>
+  </resheader>
+  <resheader name="version">
+    <value>2.0</value>
+  </resheader>
+  <resheader name="reader">
+    <value>System.Resources.ResXResourceReader, System.Windows.Forms, Version=4.0.0.0, Culture=neutral, PublicKeyToken=b77a5c561934e089</value>
+  </resheader>
+  <resheader name="writer">
+    <value>System.Resources.ResXResourceWriter, System.Windows.Forms, Version=4.0.0.0, Culture=neutral, PublicKeyToken=b77a5c561934e089</value>
+  </resheader>
+  <metadata name="errorProvider.TrayLocation" type="System.Drawing.Point, System.Drawing, Version=4.0.0.0, Culture=neutral, PublicKeyToken=b03f5f7f11d50a3a">
+    <value>17, 17</value>
+  </metadata>
+  <metadata name="toolTip.TrayLocation" type="System.Drawing.Point, System.Drawing, Version=4.0.0.0, Culture=neutral, PublicKeyToken=b03f5f7f11d50a3a">
+    <value>140, 17</value>
+  </metadata>
+</root>
Index: /branches/PushGP/HeuristicLab.PushGP/HeuristicLab.Problems.ProgramSynthesis/Push/Solution/BenchmarkSuite/PushBenchmarkSuiteSolution.cs
===================================================================
--- /branches/PushGP/HeuristicLab.PushGP/HeuristicLab.Problems.ProgramSynthesis/Push/Solution/BenchmarkSuite/PushBenchmarkSuiteSolution.cs	(revision 15289)
+++ /branches/PushGP/HeuristicLab.PushGP/HeuristicLab.Problems.ProgramSynthesis/Push/Solution/BenchmarkSuite/PushBenchmarkSuiteSolution.cs	(revision 15289)
@@ -0,0 +1,33 @@
+﻿namespace HeuristicLab.Problems.ProgramSynthesis.Push.Solution.BenchmarkSuite {
+  using HeuristicLab.Common;
+  using HeuristicLab.Core;
+  using HeuristicLab.Persistence.Default.CompositeSerializers.Storable;
+  using HeuristicLab.Problems.ProgramSynthesis.Push.Configuration;
+  using HeuristicLab.Problems.ProgramSynthesis.Push.Evaluator;
+  using HeuristicLab.Problems.ProgramSynthesis.Push.Expressions;
+
+  [StorableClass]
+  public class PushBenchmarkSuiteSolution : PushSolution {
+    public PushBenchmarkSuiteSolution(
+      PushProgram program,
+      double quality,
+      IRandom random,
+      IReadOnlyPushConfiguration config,
+      PushBenchmarkSuiteEvaluator evaluator,
+      bool simplify = false) : base(program, quality, random, config, evaluator, simplify) {
+    }
+
+    public PushBenchmarkSuiteSolution(PushBenchmarkSuiteSolution origin, Cloner cloner) : base(origin, cloner) { }
+
+    [StorableConstructor]
+    public PushBenchmarkSuiteSolution(bool deserializing) : base(deserializing) { }
+
+    public override PushSolution Simplify() {
+      return new PushBenchmarkSuiteSolution(Program, Quality, Random, Config, (PushBenchmarkSuiteEvaluator)Evaluator, true);
+    }
+
+    public override IDeepCloneable Clone(Cloner cloner) {
+      return new PushBenchmarkSuiteSolution(this, cloner);
+    }
+  }
+}
Index: /branches/PushGP/HeuristicLab.PushGP/HeuristicLab.Problems.ProgramSynthesis/Push/Solution/IPushSolution.cs
===================================================================
--- /branches/PushGP/HeuristicLab.PushGP/HeuristicLab.Problems.ProgramSynthesis/Push/Solution/IPushSolution.cs	(revision 15289)
+++ /branches/PushGP/HeuristicLab.PushGP/HeuristicLab.Problems.ProgramSynthesis/Push/Solution/IPushSolution.cs	(revision 15289)
@@ -0,0 +1,7 @@
+﻿namespace HeuristicLab.Problems.ProgramSynthesis.Push.Solution {
+  using HeuristicLab.Core;
+
+  public interface IPushSolution : IItem {
+
+  }
+}
Index: /branches/PushGP/HeuristicLab.PushGP/HeuristicLab.Problems.ProgramSynthesis/Push/Solution/PushSolution.cs
===================================================================
--- /branches/PushGP/HeuristicLab.PushGP/HeuristicLab.Problems.ProgramSynthesis/Push/Solution/PushSolution.cs	(revision 15289)
+++ /branches/PushGP/HeuristicLab.PushGP/HeuristicLab.Problems.ProgramSynthesis/Push/Solution/PushSolution.cs	(revision 15289)
@@ -0,0 +1,64 @@
+﻿namespace HeuristicLab.Problems.ProgramSynthesis.Push.Solution {
+  using Common;
+  using Configuration;
+  using Core;
+  using Evaluator;
+  using Expressions;
+  using Persistence.Default.CompositeSerializers.Storable;
+
+  [StorableClass]
+  public class PushSolution : NamedItem, IPushSolution {
+    [Storable]
+    public readonly double Quality;
+    [Storable]
+    protected readonly IRandom Random;
+    [Storable]
+    public readonly IReadOnlyPushConfiguration Config;
+    [Storable]
+    public readonly IPushEvaluator Evaluator;
+    [Storable]
+    protected readonly bool simplify;
+    [Storable]
+    public PushProgram Program;
+
+
+    public PushSolution(PushProgram program, double quality, IRandom random, IReadOnlyPushConfiguration config, IPushEvaluator evaluator, bool simplify = false)
+      : base("Solution", "A push solution.") {
+      Quality = quality;
+      Random = random;
+      Config = config;
+      Evaluator = evaluator;
+      this.simplify = simplify;
+
+      Program = simplify
+        ? Simplifier.Simplifier.Simplify(program, Config, p => Evaluator.EvaluateTraining(Config, p, Random).AvgQuality)
+        : program;
+
+    }
+
+    public PushSolution(PushSolution origin, Cloner cloner) : base(origin, cloner) {
+      Program = cloner.Clone(origin.Program);
+      Quality = origin.Quality;
+      Random = cloner.Clone(origin.Random);
+      Config = cloner.Clone(origin.Config);
+      Evaluator = cloner.Clone(origin.Evaluator);
+      Program = origin.Program; // push programs are immutable like all expressions
+      simplify = origin.simplify;
+    }
+
+    public IRandom GetRandom() {
+      return (IRandom)Random.Clone();
+    }
+
+    public virtual PushSolution Simplify() {
+      return new PushSolution(Program, Quality, Random, Config, Evaluator, true);
+    }
+
+    [StorableConstructor]
+    protected PushSolution(bool deserializing) : base(deserializing) { }
+
+    public override IDeepCloneable Clone(Cloner cloner) {
+      return new PushSolution(this, cloner);
+    }
+  }
+}
Index: /branches/PushGP/HeuristicLab.PushGP/HeuristicLab.Problems.ProgramSynthesis/Push/SolutionCreator/IPlushCreator.cs
===================================================================
--- /branches/PushGP/HeuristicLab.PushGP/HeuristicLab.Problems.ProgramSynthesis/Push/SolutionCreator/IPlushCreator.cs	(revision 15288)
+++ /branches/PushGP/HeuristicLab.PushGP/HeuristicLab.Problems.ProgramSynthesis/Push/SolutionCreator/IPlushCreator.cs	(revision 15289)
@@ -12,4 +12,5 @@
     IValueLookupParameter<IntValue> MinCloseParameter { get; }
     IValueLookupParameter<IntValue> MaxCloseParameter { get; }
+    IValueLookupParameter<DoubleValue> CloseBiasLevelParameter { get; }
     IValueLookupParameter<PercentValue> InInstructionProbabilityParameter { get; }
     IValueLookupParameter<IReadOnlyErcOptions> ErcOptionsParameter { get; }
Index: /branches/PushGP/HeuristicLab.PushGP/HeuristicLab.Problems.ProgramSynthesis/Push/SolutionCreator/PlushCreator.cs
===================================================================
--- /branches/PushGP/HeuristicLab.PushGP/HeuristicLab.Problems.ProgramSynthesis/Push/SolutionCreator/PlushCreator.cs	(revision 15288)
+++ /branches/PushGP/HeuristicLab.PushGP/HeuristicLab.Problems.ProgramSynthesis/Push/SolutionCreator/PlushCreator.cs	(revision 15289)
@@ -77,5 +77,5 @@
       get { return (IValueLookupParameter<IntValue>)Parameters["MaxClose"]; }
     }
-    public IValueLookupParameter<DoubleValue> CloseBiasLevel
+    public IValueLookupParameter<DoubleValue> CloseBiasLevelParameter
     {
       get { return (IValueLookupParameter<DoubleValue>)Parameters["CloseBiasLevel"]; }
@@ -99,5 +99,5 @@
       var minClose = MinCloseParameter.ActualValue.Value;
       var maxClose = MaxCloseParameter.ActualValue.Value;
-      var biasLevel = CloseBiasLevel.ActualValue.Value;
+      var biasLevel = CloseBiasLevelParameter.ActualValue.Value;
 
       if (minLength > maxLength)
@@ -111,5 +111,10 @@
 
       for (var i = 0; i < length; i++) {
-        var expression = CodeGeneratorUtils.GetRandomExpression(random, ercOptions, instructions, inInstructionProbability);
+        var expression = CodeGeneratorUtils.GetRandomExpression(
+          random,
+          ercOptions,
+          instructions,
+          inInstructionProbability);
+
         var close = random.NextBiased(minClose, maxClose, biasLevel);
 
Index: /branches/PushGP/HeuristicLab.PushGP/HeuristicLab.Problems.ProgramSynthesis/Push/SolutionCreator/PushSolutionCreator.cs
===================================================================
--- /branches/PushGP/HeuristicLab.PushGP/HeuristicLab.Problems.ProgramSynthesis/Push/SolutionCreator/PushSolutionCreator.cs	(revision 15288)
+++ /branches/PushGP/HeuristicLab.PushGP/HeuristicLab.Problems.ProgramSynthesis/Push/SolutionCreator/PushSolutionCreator.cs	(revision 15289)
@@ -1,4 +1,3 @@
 ﻿namespace HeuristicLab.Problems.ProgramSynthesis.Push.SolutionCreator {
-  using System;
 
   using HeuristicLab.Common;
@@ -9,4 +8,5 @@
   using HeuristicLab.Persistence.Default.CompositeSerializers.Storable;
   using HeuristicLab.Problems.ProgramSynthesis.Base.Erc;
+  using HeuristicLab.Problems.ProgramSynthesis.Push.Configuration;
 
   /// <summary>
@@ -34,4 +34,6 @@
       if (!Parameters.ContainsKey(IN_INSTRUCTION_PROBABILITY))
         Parameters.Add(new FixedValueParameter<PercentValue>(IN_INSTRUCTION_PROBABILITY, new PercentValue(0.05)));
+
+      Parameters.Add(new ValueLookupParameter<IReadOnlyExpressionsConfiguration>("Instructions", "The enabled instructions"));
     }
 
@@ -68,4 +70,9 @@
     }
 
+    public IValueLookupParameter<IReadOnlyExpressionsConfiguration> InstructionsParameter
+    {
+      get { return (IValueLookupParameter<IReadOnlyExpressionsConfiguration>)Parameters["Instructions"]; }
+    }
+
     //public IValueParameter<IntValue> MaxLengthParameter
     //{
@@ -94,21 +101,24 @@
       var result = new IntegerVector(len);
 
-      var variableLength = random.Next(MinLength, len);
-      var contentLength = Math.Min(variableLength, len);
+      var contentLength = random.Next(MinLength, len);
       var lowerBound = bounds[0, 0];
       var upperBound = bounds[0, 1];
-      var inInstructionRelativeProbability = ErcOptions.ErcProbability + InInstructionProbability;
+      //var inInstructionRelativeProbability = ErcOptions.ErcProbability + InInstructionProbability;
+      //var instructions = InstructionsParameter.ActualValue;
 
       for (var i = 0; i < contentLength; i++) {
-        var x = random.NextDouble();
+        //var x = random.NextDouble();
 
-        if (ErcOptions.ErcProbability > 0 &&
-            x <= ErcOptions.ErcProbability)
-          result[i] = PushSolutionEncoding.Erc;
-        else if (InInstructionProbability > 0 &&
-                 x <= inInstructionRelativeProbability)
-          result[i] = PushSolutionEncoding.In;
-        else
-          result[i] = random.Next(lowerBound, upperBound);
+        //if (ErcOptions.ErcProbability > 0 && x <= ErcOptions.ErcProbability) {
+        //  result[i] = PushSolutionEncoding.Erc;
+        //} else if (InInstructionProbability > 0 && x <= inInstructionRelativeProbability && instructions.InExpressionCount > 0) {
+        //  var index = random.Next(0, instructions.InExpressionCount);
+        //  var expression = ExpressionTable.InExpressionTable[index];
+
+        //  instructions.EnabledExpressions
+        //  //result[i] = PushSolutionEncoding.In;
+        //} else {
+        result[i] = random.Next(lowerBound, upperBound);
+        //}
       }
 
Index: /branches/PushGP/HeuristicLab.PushGP/HeuristicLab.Problems.ProgramSynthesis/Push/Stack/IPrintStack.cs
===================================================================
--- /branches/PushGP/HeuristicLab.PushGP/HeuristicLab.Problems.ProgramSynthesis/Push/Stack/IPrintStack.cs	(revision 15288)
+++ /branches/PushGP/HeuristicLab.PushGP/HeuristicLab.Problems.ProgramSynthesis/Push/Stack/IPrintStack.cs	(revision 15289)
@@ -1,4 +1,4 @@
 ﻿namespace HeuristicLab.Problems.ProgramSynthesis.Push.Stack {
-  public interface IPrintStack : IPushStack<string> {
+  public interface IPrintStack : IPushStack {
     void NewLine();
     void Push<T>(T item);
Index: /branches/PushGP/HeuristicLab.PushGP/HeuristicLab.Problems.ProgramSynthesis/Push/Stack/IPushStack.cs
===================================================================
--- /branches/PushGP/HeuristicLab.PushGP/HeuristicLab.Problems.ProgramSynthesis/Push/Stack/IPushStack.cs	(revision 15288)
+++ /branches/PushGP/HeuristicLab.PushGP/HeuristicLab.Problems.ProgramSynthesis/Push/Stack/IPushStack.cs	(revision 15289)
@@ -16,4 +16,10 @@
     void Push(IReadOnlyList<T> items);
     void Push(IEnumerable<T> items);
+    void Swap(int count);
+    void Yank(int index);
+    void RemoveTop();
+    void Remove(int count);
+    void RemoveAt(int index);
+    void RemoveAt(int index, int count);
     new void Clear();
     IReadOnlyList<T> Peek(int count);
Index: /branches/PushGP/HeuristicLab.PushGP/HeuristicLab.Problems.ProgramSynthesis/Push/Stack/IPushStackBase.cs
===================================================================
--- /branches/PushGP/HeuristicLab.PushGP/HeuristicLab.Problems.ProgramSynthesis/Push/Stack/IPushStackBase.cs	(revision 15288)
+++ /branches/PushGP/HeuristicLab.PushGP/HeuristicLab.Problems.ProgramSynthesis/Push/Stack/IPushStackBase.cs	(revision 15289)
@@ -9,10 +9,5 @@
 
     void Clear();
-    void Swap(int count);
-    void Yank(int index);
-    void RemoveTop();
-    void Remove(int count);
-    void RemoveAt(int index);
-    void RemoveAt(int index, int count);
+
     IEnumerable<string> AsStrings();
     IEnumerable<object> AsObjects();
Index: /branches/PushGP/HeuristicLab.PushGP/HeuristicLab.Problems.ProgramSynthesis/Push/Stack/InterpreterStackStringifier.cs
===================================================================
--- /branches/PushGP/HeuristicLab.PushGP/HeuristicLab.Problems.ProgramSynthesis/Push/Stack/InterpreterStackStringifier.cs	(revision 15288)
+++ /branches/PushGP/HeuristicLab.PushGP/HeuristicLab.Problems.ProgramSynthesis/Push/Stack/InterpreterStackStringifier.cs	(revision 15289)
@@ -44,5 +44,5 @@
     }
 
-    private static IEnumerable<string> StringifyLiteralStack<T>(IPushStack<T> stack, string prefix = "", string postfix = "", bool reverse = true) {
+    private static IEnumerable<string> StringifyLiteralStack(IPushStack stack, string prefix = "", string postfix = "", bool reverse = true) {
       var result = stack.AsStrings();
 
Index: /branches/PushGP/HeuristicLab.PushGP/HeuristicLab.Problems.ProgramSynthesis/Push/Stack/PrintStack.cs
===================================================================
--- /branches/PushGP/HeuristicLab.PushGP/HeuristicLab.Problems.ProgramSynthesis/Push/Stack/PrintStack.cs	(revision 15288)
+++ /branches/PushGP/HeuristicLab.PushGP/HeuristicLab.Problems.ProgramSynthesis/Push/Stack/PrintStack.cs	(revision 15289)
@@ -6,4 +6,5 @@
   using System.Collections.Generic;
 
+  using HeuristicLab.Problems.ProgramSynthesis.Push.Constants;
   using HeuristicLab.Problems.ProgramSynthesis.Push.Extensions;
 
@@ -12,22 +13,10 @@
   /// </summary>
   public class PrintStack : IPrintStack {
-    private string currentTop;
-    private readonly IPushStack<string> stack = new PushStack<string>();
+    private int lineCount = 0;
     private readonly StringBuilder stringBuilder = new StringBuilder();
 
-    private string CurrentTop
-    {
-      get
-      {
-        return currentTop ?? (currentTop = stringBuilder.ToString());
-      }
-    }
-
-    public IEnumerator<string> GetEnumerator() {
-      return stack.GetEnumerator();
-    }
-
     IEnumerator IEnumerable.GetEnumerator() {
-      return GetEnumerator();
+      var lines = AsStrings();
+      return lines.GetEnumerator();
     }
 
@@ -36,185 +25,52 @@
     }
 
-    void IPushStack<string>.Clear() {
-      stack.Clear();
+    void IPushStack.Clear() {
       stringBuilder.Clear();
-      currentTop = null;
-    }
-
-    public IReadOnlyList<string> Peek(int count) {
-      if (count == 1)
-        return new[] { CurrentTop };
-
-      var peek = stack.Peek(count - 1);
-      var result = new List<string>(peek) { CurrentTop };
-
-      return result;
-    }
-
-    public void Insert(int index, string item) {
-      if (index == 0)
-        Add(item);
-
-      stack.Insert(index - 1, item);
-    }
-
-    public string Pop() {
-      var result = CurrentTop;
-
-      var top = stack.Pop();
-      SetBuilderToTop(top);
-
-      return result;
-    }
-
-    public IReadOnlyList<string> Pop(int count) {
-      if (count == 1)
-        return new[] { Pop() };
-
-      var popped = stack.Pop(count - 1);
-      var result = new List<string>(popped) { CurrentTop };
-
-      var newTop = stack.Pop();
-      SetBuilderToTop(newTop);
-
-      return result;
-    }
-
-    private void ClearTop() {
-      stringBuilder.Clear();
-      currentTop = null;
-    }
-
-    private void SetBuilderToTop(string top) {
-      stringBuilder.Clear();
-      stringBuilder.Append(top);
-      currentTop = top;
-    }
-
-    public bool TryPop(out string item) {
-      if (string.IsNullOrEmpty(CurrentTop)) {
-        item = null;
-        return false;
-      }
-
-      item = Pop();
-      return true;
-    }
-
-    public string ElementAt(int index) {
-      if (index == 0)
-        return CurrentTop;
-
-      return stack.ElementAt(index - 1);
-    }
-
-    public string Top
-    {
-      get
-      {
-        return CurrentTop;
-      }
-      set
-      {
-        SetBuilderToTop(value);
-      }
-    }
-
-    public string TopOrDefault { get { return CurrentTop; } }
-
-    public string Bottom { get { return Count > 1 ? stack.Bottom : CurrentTop; } }
-
-    public string BottomOrDefault { get { return Bottom; } }
-
-    public string this[int key]
-    {
-      get
-      {
-        return key == 0 ? CurrentTop : stack[key - 1];
-      }
-      set
-      {
-        if (key == 0)
-          SetBuilderToTop(value);
-        else
-          stack[key - 1] = value;
-      }
-    }
-
-    public int Count
-    {
-      get
-      {
-        return stack.Count + (string.IsNullOrEmpty(CurrentTop) ? 0 : 1);
-      }
     }
 
     public void NewLine() {
-      if (IsEmpty) return;
-
-      stack.Push(CurrentTop);
-      ClearTop();
+      stringBuilder.Append(PushEnvironment.NewLine);
+      lineCount++;
     }
 
     public void Push<T>(T item) {
+      if (IsEmpty) lineCount = 1;
       stringBuilder.Append(item);
-      currentTop = null;
     }
 
     public void Push(float item) {
+      if (IsEmpty) lineCount = 1;
       stringBuilder.Concat(item);
-      currentTop = null;
     }
 
     public void Push(double item) {
+      if (IsEmpty) lineCount = 1;
       stringBuilder.Concat(item);
-      currentTop = null;
     }
 
     public void Push(long item) {
+      if (IsEmpty) lineCount = 1;
       stringBuilder.Concat(item);
-      currentTop = null;
     }
 
     public void Push(int item) {
+      if (IsEmpty) lineCount = 1;
       stringBuilder.Concat(item);
-      currentTop = null;
     }
 
     public void Push(char item) {
+      if (IsEmpty) lineCount = 1;
       stringBuilder.Append(item);
-      currentTop = null;
     }
 
     public void Push(bool item) {
+      if (IsEmpty) lineCount = 1;
       stringBuilder.Append(item);
-      currentTop = null;
     }
 
 
     public void Push(string item) {
+      if (IsEmpty) lineCount = 1;
       stringBuilder.Append(item);
-      currentTop = null;
-    }
-
-    public void Push(string item1, string item2) {
-      stringBuilder.Append(item1);
-      stringBuilder.Append(item2);
-      currentTop = null;
-    }
-
-    public void Push(string item1, string item2, string item3) {
-      stringBuilder.Append(item1);
-      stringBuilder.Append(item2);
-      stringBuilder.Append(item3);
-      currentTop = null;
-    }
-
-    public void Push(string item1, string item2, string item3, string item4) {
-      stringBuilder.Append(item1);
-      stringBuilder.Append(item2);
-      stringBuilder.Append(item3);
-      stringBuilder.Append(item4);
-      currentTop = null;
     }
 
@@ -222,6 +78,4 @@
       for (var i = startIndex; i < items.Count; i++)
         stringBuilder.Append(items[i]);
-
-      currentTop = null;
     }
 
@@ -233,71 +87,9 @@
       foreach (var item in items)
         stringBuilder.Append(item);
-
-      currentTop = null;
-    }
-
-    void IPushStack.Clear() {
-      stringBuilder.Clear();
-      currentTop = null;
-      stack.Clear();
-    }
-
-    public void Swap(int count) {
-      stack.Push(CurrentTop);
-      stack.Swap(count);
-
-      var newTop = stack.Pop();
-      SetBuilderToTop(newTop);
-    }
-
-    public void Yank(int index) {
-      if (index == Count - 1) return;
-
-      stack.Push(CurrentTop);
-
-      var item = stack[index];
-      stack.RemoveAt(index);
-      SetBuilderToTop(item);
-    }
-
-    public void RemoveTop() {
-      var newTop = stack.Pop();
-      SetBuilderToTop(newTop);
-    }
-
-    public void Remove(int count) {
-      if (count == 1)
-        RemoveTop();
-
-      stack.Remove(count - 1);
-      var newTop = stack.Pop();
-      SetBuilderToTop(newTop);
-    }
-
-    public void RemoveAt(int index) {
-      if (index == 0)
-        ClearTop();
-      else
-        stack.RemoveAt(index - 1);
-    }
-
-    public void RemoveAt(int index, int count) {
-      if (index == 0)
-        count--;
-
-      stack.RemoveAt(index - 1, count);
-
-      if (index == 0) {
-        var newTop = stack.Pop();
-        SetBuilderToTop(newTop);
-      }
     }
 
     public IEnumerable<string> AsStrings() {
-      foreach (var item in stack)
-        yield return item;
-
-      if (!IsEmpty)
-        yield return CurrentTop;
+      var lines = stringBuilder.ToString().Split(PushEnvironment.NewLine);
+      return lines;
     }
 
@@ -306,49 +98,21 @@
     }
 
-    void ICollection<string>.Clear() {
-      stack.Clear();
-      stringBuilder.Clear();
-    }
-
-    public bool Contains(string item) {
-
-      return CurrentTop.Equals(item) || stack.Contains(item);
-    }
-
-    public void CopyTo(string[] array, int arrayIndex) {
-      stack.CopyTo(array, arrayIndex);
-      array[arrayIndex + stack.Count] = CurrentTop;
-    }
-
-    public bool Remove(string item) {
-      if (item.Equals(CurrentTop)) {
-        RemoveTop();
-        return true;
-      }
-
-      return stack.Remove(item);
-    }
-
-    int IPushStack<string>.Count
+    int IPushStack.Count
     {
       get
       {
-        return Count;
+        return lineCount;
       }
     }
 
-    public bool IsEmpty { get { return stack.IsEmpty && string.IsNullOrEmpty(CurrentTop); } }
+    public bool IsEmpty { get { return stringBuilder.Length == 0; } }
 
     public bool IsEnabled { get; set; }
 
-    int ICollection<string>.Count
-    {
-      get
-      {
-        return Count;
-      }
+    public bool IsReadOnly { get { return false; } }
+
+    public override string ToString() {
+      return stringBuilder.ToString();
     }
-
-    public bool IsReadOnly { get { return false; } }
   }
 }
Index: /branches/PushGP/HeuristicLab.PushGP/HeuristicLab.Problems.ProgramSynthesis/Push/Views/PushDebuggerView.cs
===================================================================
--- /branches/PushGP/HeuristicLab.PushGP/HeuristicLab.Problems.ProgramSynthesis/Push/Views/PushDebuggerView.cs	(revision 15288)
+++ /branches/PushGP/HeuristicLab.PushGP/HeuristicLab.Problems.ProgramSynthesis/Push/Views/PushDebuggerView.cs	(revision 15289)
@@ -9,7 +9,9 @@
   using Core.Views;
   using Expressions;
+
+  using HeuristicLab.Problems.ProgramSynthesis.Push.Solution;
+
   using Interpreter;
   using MainForm;
-  using Problem;
   using Stack;
 
@@ -227,7 +229,6 @@
 
       // align numbers right
-      var stackEntryType = type.GetStackEntryType();
-      if (stackEntryType == typeof(double) ||
-          stackEntryType == typeof(long)) {
+      if (type == StackTypes.Integer ||
+          type == StackTypes.Float) {
         list.DrawMode = DrawMode.OwnerDrawFixed;
         list.DrawItem += (sender, e) => {
Index: /branches/PushGP/HeuristicLab.PushGP/HeuristicLab.Tests/Benchmark/RandomWalkTests.cs
===================================================================
--- /branches/PushGP/HeuristicLab.PushGP/HeuristicLab.Tests/Benchmark/RandomWalkTests.cs	(revision 15288)
+++ /branches/PushGP/HeuristicLab.PushGP/HeuristicLab.Tests/Benchmark/RandomWalkTests.cs	(revision 15289)
@@ -5,4 +5,5 @@
 
   using HeuristicLab.BenchmarkSuite.Problems;
+  using HeuristicLab.Problems.ProgramSynthesis.Push.Evaluator;
 
   using Microsoft.VisualStudio.TestTools.UnitTesting;
Index: /branches/PushGP/HeuristicLab.PushGP/HeuristicLab.Tests/Benchmark/SolutionTests.cs
===================================================================
--- /branches/PushGP/HeuristicLab.PushGP/HeuristicLab.Tests/Benchmark/SolutionTests.cs	(revision 15288)
+++ /branches/PushGP/HeuristicLab.PushGP/HeuristicLab.Tests/Benchmark/SolutionTests.cs	(revision 15289)
@@ -3,10 +3,9 @@
   using HeuristicLab.BenchmarkSuite;
   using HeuristicLab.BenchmarkSuite.Problems;
-  using HeuristicLab.Core;
   using HeuristicLab.Problems.ProgramSynthesis.Push.Configuration;
+  using HeuristicLab.Problems.ProgramSynthesis.Push.Evaluator;
   using HeuristicLab.Problems.ProgramSynthesis.Push.Expressions;
   using HeuristicLab.Problems.ProgramSynthesis.Push.Interpreter;
   using HeuristicLab.Problems.ProgramSynthesis.Push.Parser;
-  using HeuristicLab.Problems.ProgramSynthesis.Push.Problem.BenchmarkSuite;
   using HeuristicLab.Problems.ProgramSynthesis.Push.Stack;
   using HeuristicLab.Random;
@@ -16,12 +15,4 @@
   [TestClass]
   public class SolutionTests {
-
-    private IRandom random;
-
-    [TestInitialize]
-    public void BeforeTest() {
-      random = new MersenneTwister(1337);
-    }
-
     private void TestProgram(PushProgram program, IBenchmarkSuiteDataDescriptor descriptor, string floatStringFormat = "R") {
       var data = descriptor.CreateProblemData();
@@ -38,7 +29,10 @@
       var evaluator = new PushBenchmarkSuiteEvaluator(data);
       var pool = new PushInterpreterPool(config);
-      var result = evaluator.EvaluateTraining(pool, program, random);
-
-      Assert.AreEqual(0, result.AvgQuality);
+
+      var trainingResult = evaluator.EvaluateTraining(pool, program, new MersenneTwister(1337));
+      //var testResult = evaluator.EvaluateTest(pool, program, new MersenneTwister(1337));
+
+      Assert.AreEqual(0, trainingResult.AvgQuality);
+      //Assert.AreEqual(0, testResult.AvgQuality);
     }
 
@@ -57,5 +51,5 @@
     public void CollatzNumbers() {
       TestProgram(
-        PushParser.ParseProgram("( IN1 INTEGER.DUP 1 INTEGER.= BOOLEAN.NOT EXEC.WHILE ( INTEGER.DUP INTEGER.DUP 2 INTEGER.% 0 INTEGER.= EXEC.IF ( 2 INTEGER./ ) ( 3 INTEGER.* 1 INTEGER.+ ) INTEGER.DUP 1 INTEGER.= BOOLEAN.NOT ) INTEGER.POP INTEGER.STACKDEPTH )"),
+        PushParser.ParseProgram("( INTEGER.DUP 1 INTEGER.= BOOLEAN.NOT EXEC.WHILE ( INTEGER.DUP INTEGER.DUP 2 INTEGER.% 0 INTEGER.= EXEC.IF ( 2 INTEGER./ ) ( 3 INTEGER.* 1 INTEGER.+ ) INTEGER.DUP 1 INTEGER.= BOOLEAN.NOT ) INTEGER.POP INTEGER.STACKDEPTH )"),
         new CollatzNumbers());
     }
@@ -84,5 +78,5 @@
     public void Digits() {
       TestProgram(
-        PushParser.ParseProgram("( IN1 INTEGER.DUP STRING.FROMINTEGER 0 INTEGER.< BOOLEAN.DUP EXEC.WHEN ( STRING.REST STRING.DUP STRING.FIRST STRING.SWAP STRING.REST ) STRING.REVERSE STRING.ITERATE ( PRINT.NEWLINE PRINT.PRINTCHAR ) EXEC.WHEN ( PRINT.NEWLINE \'-\' PRINT.PRINTCHAR PRINT.PRINTSTRING ) )"),
+        PushParser.ParseProgram("( INTEGER.DUP STRING.FROMINTEGER 0 INTEGER.< BOOLEAN.DUP EXEC.WHEN ( STRING.REST STRING.DUP STRING.FIRST STRING.SWAP STRING.REST ) STRING.REVERSE STRING.ITERATE ( PRINT.NEWLINE PRINT.PRINTCHAR ) EXEC.WHEN ( PRINT.NEWLINE \'-\' PRINT.PRINTCHAR PRINT.PRINTSTRING ) )"),
         new Digits());
     }
@@ -110,5 +104,5 @@
       TestProgram(
         PushParser.ParseProgram(
-        @"IN1 INTEGER.DUP EXEC.DO*COUNT (
+        @"INTEGER.DUP EXEC.DO*COUNT (
             INTEGER.DUP 0 INTEGER.>
             EXEC.WHEN (
@@ -134,5 +128,5 @@
       TestProgram(
         PushParser.ParseProgram(
-        @"( IN1 IN2 IN3 STRING.FROMINTEGER INTEGER.SWAP true EXEC.WHILE ( INTEGER.DUP PRINT.NEWLINE PRINT.PRINTINTEGER STRING.DUP INTEGER.FROMSTRING INTEGER.+ INTEGER.DUP 2 INTEGER.YANKDUP INTEGER.< ) )"),
+        @"( STRING.FROMINTEGER INTEGER.SWAP true EXEC.WHILE ( INTEGER.DUP PRINT.NEWLINE PRINT.PRINTINTEGER STRING.DUP INTEGER.FROMSTRING INTEGER.+ INTEGER.DUP 2 INTEGER.YANKDUP INTEGER.< ) )"),
         new ForLoopIndex());
     }
@@ -143,5 +137,5 @@
     public void Grades() {
       TestProgram(
-        PushParser.ParseProgram("( IN1 IN2 IN3 IN4 IN5 \"Student has a \" PRINT.PRINTSTRING INTEGER.DUP INTEGER.ROT INTEGER.> EXEC.WHEN ( \"F\" \" grade.\" STRING.CONCAT PRINT.PRINTSTRING EXEC.FLUSH ) INTEGER.DUP INTEGER.ROT INTEGER.> EXEC.WHEN ( \"D\" \" grade.\" STRING.CONCAT PRINT.PRINTSTRING EXEC.FLUSH ) INTEGER.DUP INTEGER.ROT INTEGER.> EXEC.WHEN ( \"C\" \" grade.\" STRING.CONCAT PRINT.PRINTSTRING EXEC.FLUSH ) INTEGER.DUP INTEGER.ROT INTEGER.> EXEC.WHEN ( \"B\" \" grade.\" STRING.CONCAT PRINT.PRINTSTRING EXEC.FLUSH ) \"A\" \" grade.\" STRING.CONCAT PRINT.PRINTSTRING )"),
+        PushParser.ParseProgram("( \"Student has a \" PRINT.PRINTSTRING INTEGER.DUP INTEGER.ROT INTEGER.> EXEC.WHEN ( \"F\" \" grade.\" STRING.CONCAT PRINT.PRINTSTRING EXEC.FLUSH ) INTEGER.DUP INTEGER.ROT INTEGER.> EXEC.WHEN ( \"D\" \" grade.\" STRING.CONCAT PRINT.PRINTSTRING EXEC.FLUSH ) INTEGER.DUP INTEGER.ROT INTEGER.> EXEC.WHEN ( \"C\" \" grade.\" STRING.CONCAT PRINT.PRINTSTRING EXEC.FLUSH ) INTEGER.DUP INTEGER.ROT INTEGER.> EXEC.WHEN ( \"B\" \" grade.\" STRING.CONCAT PRINT.PRINTSTRING EXEC.FLUSH ) \"A\" \" grade.\" STRING.CONCAT PRINT.PRINTSTRING )"),
         new Grades());
     }
@@ -204,5 +198,5 @@
     public void PigLatin() {
       TestProgram(
-        PushParser.ParseProgram("@( IN1 STRING.SPLIT STRING.STACKDEPTH 0 INTEGER.= EXEC.WHEN EXEC.FLUSH STRING.STACKDEPTH EXEC.DO*TIMES ( STRING.DUP STRING.FIRST CHAR.ALLFROMSTRING CHAR.DUP \"aeiou\" STRING.CONTAINSCHAR EXEC.IF ( CHAR.POP ) ( STRING.REST STRING.CONJCHAR ) \"ay\" STRING.CONCAT STRING.STACKDEPTH 1 INTEGER.> EXEC.WHEN ( ' ' STRING.CONJCHAR ) PRINT.PRINTSTRING ) )"),
+        PushParser.ParseProgram("@( STRING.SPLIT STRING.STACKDEPTH 0 INTEGER.= EXEC.WHEN EXEC.FLUSH STRING.STACKDEPTH EXEC.DO*TIMES ( STRING.DUP STRING.FIRST CHAR.ALLFROMSTRING CHAR.DUP \"aeiou\" STRING.CONTAINSCHAR EXEC.IF ( CHAR.POP ) ( STRING.REST STRING.CONJCHAR ) \"ay\" STRING.CONCAT STRING.STACKDEPTH 1 INTEGER.> EXEC.WHEN ( ' ' STRING.CONJCHAR ) PRINT.PRINTSTRING ) )"),
         new PigLatin());
     }
@@ -258,6 +252,5 @@
       TestProgram(
         PushParser.ParseProgram(
-          @"IN1 IN2
-            CHAR.ALLFROMSTRING 0 STRING.ITERATE (
+          @"CHAR.ALLFROMSTRING 0 STRING.ITERATE (
             CHAR.DUP 2 CHAR.YANKDUP CHAR.= BOOLEAN.NOT EXEC.IF (
               INTEGER.DUP PRINT.PRINTINTEGER
@@ -276,5 +269,5 @@
     public void StringLengthsBackwards() {
       TestProgram(
-        PushParser.ParseProgram(@"IN1 STRING[].ITERATE ( STRING.LENGTH PRINT.NEWLINE PRINT.PRINTINTEGER )"),
+        PushParser.ParseProgram(@"STRING[].ITERATE ( STRING.LENGTH PRINT.NEWLINE PRINT.PRINTINTEGER )"),
         new StringLengthsBackwards());
     }
@@ -285,5 +278,5 @@
     public void SumOfSquares() {
       TestProgram(
-       PushParser.ParseProgram(@"( IN1 EXEC.DO*COUNT ( INTEGER.DUP INTEGER.* INTEGER.+ ) )"),
+       PushParser.ParseProgram(@"( EXEC.DO*COUNT ( INTEGER.DUP INTEGER.* INTEGER.+ ) )"),
        new SumOfSquares());
     }
@@ -339,5 +332,5 @@
     public void WordStats() {
       TestProgram(
-        PushParser.ParseProgram("( IN1 STRING.DUP STRING.SPLIT STRING.STACKDEPTH 1 INTEGER.= BOOLEAN.NOT EXEC.WHEN ( true EXEC.WHILE ( STRING.LENGTH INTEGER.MAX STRING.STACKDEPTH 1 INTEGER.= BOOLEAN.NOT ) [0] 2 INTEGER.- INTEGER.DUP 0 INTEGER.>= EXEC.WHEN ( INTEGER.INC EXEC.DO*TIMES ( 0 INTEGER[].CONJ ) ) STRING.DUP STRING.SPLIT STRING.STACKDEPTH 1 INTEGER.> EXEC.WHILE ( STRING.LENGTH INTEGER.DEC INTEGER.DUP INTEGER[].DUP INTEGER[].NTH INTEGER.INC INTEGER[].SET STRING.STACKDEPTH 1 INTEGER.> ) INTEGER[].DUP INTEGER[].LENGTH INTEGER.DEC EXEC.DO*COUNT ( PRINT.NEWLINE \"words of length \" PRINT.PRINTSTRING INTEGER.DUP INTEGER.INC PRINT.PRINTINTEGER \": \" PRINT.PRINTSTRING INTEGER[].DUP INTEGER[].NTH PRINT.PRINTINTEGER ) \'.\' STRING.DUP STRING.OCCURRENCESOFCHAR \'!\' STRING.DUP STRING.OCCURRENCESOFCHAR INTEGER.+ \'?\' STRING.DUP STRING.OCCURRENCESOFCHAR INTEGER.+ INTEGER.DUP PRINT.NEWLINE \"number of sentences: \" PRINT.PRINTSTRING PRINT.PRINTINTEGER STRING.SPLIT STRING.STACKDEPTH FLOAT.FROMINTEGER FLOAT.FROMINTEGER FLOAT./ PRINT.NEWLINE \"average sentence length: \" PRINT.PRINTSTRING PRINT.PRINTFLOAT ) )"),
+        PushParser.ParseProgram("( STRING.DUP STRING.SPLIT STRING.STACKDEPTH 1 INTEGER.= BOOLEAN.NOT EXEC.WHEN ( true EXEC.WHILE ( STRING.LENGTH INTEGER.MAX STRING.STACKDEPTH 1 INTEGER.= BOOLEAN.NOT ) [0] 2 INTEGER.- INTEGER.DUP 0 INTEGER.>= EXEC.WHEN ( INTEGER.INC EXEC.DO*TIMES ( 0 INTEGER[].CONJ ) ) STRING.DUP STRING.SPLIT STRING.STACKDEPTH 1 INTEGER.> EXEC.WHILE ( STRING.LENGTH INTEGER.DEC INTEGER.DUP INTEGER[].DUP INTEGER[].NTH INTEGER.INC INTEGER[].SET STRING.STACKDEPTH 1 INTEGER.> ) INTEGER[].DUP INTEGER[].LENGTH INTEGER.DEC EXEC.DO*COUNT ( PRINT.NEWLINE \"words of length \" PRINT.PRINTSTRING INTEGER.DUP INTEGER.INC PRINT.PRINTINTEGER \": \" PRINT.PRINTSTRING INTEGER[].DUP INTEGER[].NTH PRINT.PRINTINTEGER ) \'.\' STRING.DUP STRING.OCCURRENCESOFCHAR \'!\' STRING.DUP STRING.OCCURRENCESOFCHAR INTEGER.+ \'?\' STRING.DUP STRING.OCCURRENCESOFCHAR INTEGER.+ INTEGER.DUP PRINT.NEWLINE \"number of sentences: \" PRINT.PRINTSTRING PRINT.PRINTINTEGER STRING.SPLIT STRING.STACKDEPTH FLOAT.FROMINTEGER FLOAT.FROMINTEGER FLOAT./ PRINT.NEWLINE \"average sentence length: \" PRINT.PRINTSTRING PRINT.PRINTFLOAT ) )"),
         new WordStats(),
         "0.0#########");
@@ -349,5 +342,5 @@
     public void XWordLines() {
       TestProgram(
-        PushParser.ParseProgram(@"( IN1 IN2 STRING.SPLIT STRING.EMPTY BOOLEAN.NOT INTEGER.DUP 1 INTEGER.= EXEC.IF ( EXEC.WHILE ( PRINT.NEWLINE PRINT.PRINTSTRING STRING.EMPTY BOOLEAN.NOT ) ) ( 2 INTEGER.- EXEC.WHILE ( STRING.STACKDEPTH 2 INTEGER.- 1 INTEGER.YANKDUP INTEGER.MIN INTEGER.DUP 0 INTEGER.>= EXEC.IF ( INTEGER.INC EXEC.DO*TIMES ( ' ' STRING.CONJCHAR STRING.SWAP STRING.CONCAT ) PRINT.NEWLINE PRINT.PRINTSTRING STRING.EMPTY BOOLEAN.NOT ) ( PRINT.NEWLINE PRINT.PRINTSTRING STRING.EMPTY BOOLEAN.NOT ) ) ) )"),
+        PushParser.ParseProgram(@"( STRING.SPLIT STRING.EMPTY BOOLEAN.NOT INTEGER.DUP 1 INTEGER.= EXEC.IF ( EXEC.WHILE ( PRINT.NEWLINE PRINT.PRINTSTRING STRING.EMPTY BOOLEAN.NOT ) ) ( 2 INTEGER.- EXEC.WHILE ( STRING.STACKDEPTH 2 INTEGER.- 1 INTEGER.YANKDUP INTEGER.MIN INTEGER.DUP 0 INTEGER.>= EXEC.IF ( INTEGER.INC EXEC.DO*TIMES ( ' ' STRING.CONJCHAR STRING.SWAP STRING.CONCAT ) PRINT.NEWLINE PRINT.PRINTSTRING STRING.EMPTY BOOLEAN.NOT ) ( PRINT.NEWLINE PRINT.PRINTSTRING STRING.EMPTY BOOLEAN.NOT ) ) ) )"),
         new XWordLines());
     }
Index: /branches/PushGP/HeuristicLab.PushGP/HeuristicLab.Tests/Components/LexicaseTests.cs
===================================================================
--- /branches/PushGP/HeuristicLab.PushGP/HeuristicLab.Tests/Components/LexicaseTests.cs	(revision 15289)
+++ /branches/PushGP/HeuristicLab.PushGP/HeuristicLab.Tests/Components/LexicaseTests.cs	(revision 15289)
@@ -0,0 +1,14 @@
+﻿namespace HeuristicLab.Tests.Components {
+
+  using Microsoft.VisualStudio.TestTools.UnitTesting;
+
+  public class LexicaseTests {
+    [TestMethod]
+    [TestCategory("Problem")]
+    [TestProperty("Time", "short")]
+    public void TestLexicase() {
+      // how to test this?
+      //var selected = LexicaseSelector.Apply()
+    }
+  }
+}
Index: /branches/PushGP/HeuristicLab.PushGP/HeuristicLab.Tests/Components/PrintStackTests.cs
===================================================================
--- /branches/PushGP/HeuristicLab.PushGP/HeuristicLab.Tests/Components/PrintStackTests.cs	(revision 15288)
+++ /branches/PushGP/HeuristicLab.PushGP/HeuristicLab.Tests/Components/PrintStackTests.cs	(revision 15289)
@@ -20,5 +20,5 @@
       printStack.Push(100L);
 
-      Assert.AreEqual(100L.ToString(), printStack.Top);
+      Assert.AreEqual(100L.ToString(), printStack.ToString());
     }
 
@@ -27,5 +27,5 @@
       printStack.Push(100.5D);
 
-      Assert.AreEqual(100.5D.ToString(), printStack.Top);
+      Assert.AreEqual(100.5D.ToString(), printStack.ToString());
     }
 
Index: /branches/PushGP/HeuristicLab.PushGP/HeuristicLab.Tests/HeuristicLab.Tests.csproj
===================================================================
--- /branches/PushGP/HeuristicLab.PushGP/HeuristicLab.Tests/HeuristicLab.Tests.csproj	(revision 15288)
+++ /branches/PushGP/HeuristicLab.PushGP/HeuristicLab.Tests/HeuristicLab.Tests.csproj	(revision 15289)
@@ -39,4 +39,7 @@
   </PropertyGroup>
   <ItemGroup>
+    <Reference Include="HeuristicLab.Algorithms.GeneticAlgorithm-3.3">
+      <HintPath>..\..\..\..\trunk\sources\bin\HeuristicLab.Algorithms.GeneticAlgorithm-3.3.dll</HintPath>
+    </Reference>
     <Reference Include="HeuristicLab.Collections-3.3, Version=3.3.0.0, Culture=neutral, PublicKeyToken=ba48961d6f65dcec, processorArchitecture=MSIL">
       <SpecificVersion>False</SpecificVersion>
@@ -59,7 +62,14 @@
       <HintPath>..\..\..\..\trunk\sources\bin\HeuristicLab.Encodings.IntegerVectorEncoding-3.3.dll</HintPath>
     </Reference>
+    <Reference Include="HeuristicLab.Operators-3.3, Version=3.3.0.0, Culture=neutral, PublicKeyToken=ba48961d6f65dcec, processorArchitecture=MSIL">
+      <SpecificVersion>False</SpecificVersion>
+      <HintPath>..\..\..\..\trunk\sources\bin\HeuristicLab.Operators-3.3.dll</HintPath>
+    </Reference>
     <Reference Include="HeuristicLab.Optimization-3.3, Version=3.3.0.0, Culture=neutral, PublicKeyToken=ba48961d6f65dcec, processorArchitecture=MSIL">
       <SpecificVersion>False</SpecificVersion>
       <HintPath>..\..\..\..\trunk\sources\bin\HeuristicLab.Optimization-3.3.dll</HintPath>
+    </Reference>
+    <Reference Include="HeuristicLab.ParallelEngine-3.3">
+      <HintPath>..\..\..\..\trunk\sources\bin\HeuristicLab.ParallelEngine-3.3.dll</HintPath>
     </Reference>
     <Reference Include="HeuristicLab.Problems.Instances-3.3, Version=3.3.0.0, Culture=neutral, PublicKeyToken=ba48961d6f65dcec, processorArchitecture=MSIL">
@@ -70,4 +80,11 @@
       <SpecificVersion>False</SpecificVersion>
       <HintPath>..\..\..\..\trunk\sources\bin\HeuristicLab.Random-3.3.dll</HintPath>
+    </Reference>
+    <Reference Include="HeuristicLab.Selection-3.3, Version=3.3.0.0, Culture=neutral, PublicKeyToken=ba48961d6f65dcec, processorArchitecture=MSIL">
+      <SpecificVersion>False</SpecificVersion>
+      <HintPath>..\..\..\..\trunk\sources\bin\HeuristicLab.Selection-3.3.dll</HintPath>
+    </Reference>
+    <Reference Include="HeuristicLab.SequentialEngine-3.3">
+      <HintPath>..\..\..\..\trunk\sources\bin\HeuristicLab.SequentialEngine-3.3.dll</HintPath>
     </Reference>
     <Reference Include="System" />
@@ -89,4 +106,5 @@
     <Compile Include="Benchmark\RandomWalkTests.cs" />
     <Compile Include="Benchmark\SolutionTests.cs" />
+    <Compile Include="Components\LexicaseTests.cs" />
     <Compile Include="Components\PrintStackTests.cs" />
     <Compile Include="Erc\ErcTests.cs" />
@@ -110,4 +128,5 @@
     <Compile Include="Interpreter\Expressions\VectorExpressionTests.cs" />
     <Compile Include="Interpreter\ExpressionTest.cs" />
+    <Compile Include="Problem\DeterministicTests.cs" />
     <Compile Include="Problem\IndividualMapperTests.cs" />
     <Compile Include="Properties\AssemblyInfo.cs" />
@@ -128,4 +147,5 @@
     </ProjectReference>
   </ItemGroup>
+  <ItemGroup />
   <Choose>
     <When Condition="'$(VisualStudioVersion)' == '10.0' And '$(IsCodedUITest)' == 'True'">
Index: /branches/PushGP/HeuristicLab.PushGP/HeuristicLab.Tests/Interpreter/Expressions/PrintExpressionTests.cs
===================================================================
--- /branches/PushGP/HeuristicLab.PushGP/HeuristicLab.Tests/Interpreter/Expressions/PrintExpressionTests.cs	(revision 15288)
+++ /branches/PushGP/HeuristicLab.PushGP/HeuristicLab.Tests/Interpreter/Expressions/PrintExpressionTests.cs	(revision 15289)
@@ -18,5 +18,5 @@
       interpreter.Run(new FloatPrintExpression());
 
-      Assert.AreEqual(value.ToString("R", CultureInfo.InvariantCulture), interpreter.PrintStack.Top);
+      Assert.AreEqual(value.ToString("R", CultureInfo.InvariantCulture), interpreter.PrintStack.ToString());
     }
   }
Index: /branches/PushGP/HeuristicLab.PushGP/HeuristicLab.Tests/Problem/DeterministicTests.cs
===================================================================
--- /branches/PushGP/HeuristicLab.PushGP/HeuristicLab.Tests/Problem/DeterministicTests.cs	(revision 15289)
+++ /branches/PushGP/HeuristicLab.PushGP/HeuristicLab.Tests/Problem/DeterministicTests.cs	(revision 15289)
@@ -0,0 +1,96 @@
+﻿using System;
+using System.Linq;
+
+namespace HeuristicLab.Tests.Problem {
+  using System.Threading;
+
+  using HeuristicLab.Algorithms.GeneticAlgorithm;
+  using HeuristicLab.BenchmarkSuite.Problems;
+  using HeuristicLab.Data;
+  using HeuristicLab.Encodings.IntegerVectorEncoding;
+  using HeuristicLab.Optimization;
+  using HeuristicLab.ParallelEngine;
+  using HeuristicLab.Problems.ProgramSynthesis.Push.Problem.BenchmarkSuite;
+  using HeuristicLab.Problems.ProgramSynthesis.Push.Selector;
+
+  using Microsoft.VisualStudio.TestTools.UnitTesting;
+
+  [TestClass]
+  public class DeterministicTests {
+
+    [TestMethod]
+    [TestCategory("Problem")]
+    [TestProperty("Time", "long")]
+    public void TestMedian() {
+      var ga = GetAlgorithm();
+
+      RunAlgorithm(ga);
+    }
+
+    [TestMethod]
+    [TestCategory("Problem")]
+    [TestProperty("Time", "long")]
+    public void TestSimilarResult() {
+      var ga1 = GetAlgorithm();
+      var ga2 = GetAlgorithm();
+
+      RunAlgorithm(ga1);
+      RunAlgorithm(ga2);
+
+      var bestQuality1 = GetDoubleResult(ga1, "BestQuality");
+      var bestQuality2 = GetDoubleResult(ga2, "BestQuality");
+      Assert.AreEqual(bestQuality1, bestQuality2, 0.0001);
+
+      var currentAverageQuality1 = GetDoubleResult(ga1, "CurrentAverageQuality");
+      var currentAverageQuality2 = GetDoubleResult(ga2, "CurrentAverageQuality");
+      Assert.AreEqual(currentAverageQuality1, currentAverageQuality2, 0.0001);
+
+      var currentWorstQuality1 = GetDoubleResult(ga1, "CurrentWorstQuality");
+      var currentWorstQuality2 = GetDoubleResult(ga2, "CurrentWorstQuality");
+      Assert.AreEqual(currentWorstQuality1, currentWorstQuality2, 0.0001);
+    }
+
+    public static IAlgorithm GetAlgorithm() {
+      var ga = new GeneticAlgorithm();
+
+      var instance = new Median();
+      var problemData = instance.CreateProblemData();
+      var pushProblem = new IntegerVectorPushBenchmarkSuiteProblem();
+
+      pushProblem.Load(problemData);
+
+      ga.Problem = pushProblem;
+      pushProblem.Encoding.Length = 100;
+
+      ga.Crossover = ga.CrossoverParameter.ValidValues.OfType<SinglePointCrossover>().First();
+      ga.Selector = ga.SelectorParameter.ValidValues.OfType<LexicaseSelector>().First();
+      ga.Mutator = ga.MutatorParameter.ValidValues.OfType<UniformSomePositionsManipulator>().First();
+
+      ga.Seed.Value = 1337;
+      ga.SetSeedRandomly.Value = false;
+      ga.MutationProbability.Value = 0.05;
+      ga.PopulationSize.Value = 1000;
+      ga.MaximumGenerations.Value = 10;
+
+      ga.Engine = new ParallelEngine();
+
+      return ga;
+    }
+
+    public static void RunAlgorithm(IAlgorithm a) {
+      var trigger = new EventWaitHandle(false, EventResetMode.ManualReset);
+      Exception ex = null;
+      a.Stopped += (src, e) => trigger.Set();
+      a.ExceptionOccurred += (src, e) => { ex = e.Value; trigger.Set(); };
+      a.Prepare();
+      a.Start();
+      trigger.WaitOne();
+
+      Assert.AreEqual(ex, null);
+    }
+
+    public static double GetDoubleResult(IAlgorithm a, string resultName) {
+      return ((DoubleValue)a.Results[resultName].Value).Value;
+    }
+  }
+}
Index: /branches/PushGP/HeuristicLab.PushGP/HeuristicLab.Tests/Problem/IndividualMapperTests.cs
===================================================================
--- /branches/PushGP/HeuristicLab.PushGP/HeuristicLab.Tests/Problem/IndividualMapperTests.cs	(revision 15288)
+++ /branches/PushGP/HeuristicLab.PushGP/HeuristicLab.Tests/Problem/IndividualMapperTests.cs	(revision 15289)
@@ -13,5 +13,4 @@
   using HeuristicLab.Problems.ProgramSynthesis.Push.Individual;
   using HeuristicLab.Problems.ProgramSynthesis.Push.Interpreter;
-  using HeuristicLab.Problems.ProgramSynthesis.Push.Problem;
   using HeuristicLab.Problems.ProgramSynthesis.Push.Stack;
   using HeuristicLab.Random;
@@ -41,8 +40,8 @@
       var programs = Enumerable.Range(0, Environment.ProcessorCount)
         .AsParallel()
-        .Select(i => vector.ToPushProgram(config, randomPool))
+        .Select(i => vector.ToPushProgram(config))
         .ToArray();
 
-      var referenceProgram = vector.ToPushProgram(config, randomPool);
+      var referenceProgram = vector.ToPushProgram(config);
       Assert.IsTrue(programs.All(p => p.Equals(referenceProgram)));
     }
@@ -70,5 +69,5 @@
 
       sw.Start();
-      var program = vector.ToPushProgram(config, random);
+      var program = vector.ToPushProgram(config);
       sw.Stop();
 
Index: anches/PushGP/HeuristicLab.PushGP/PushGp.sln.DotSettings.user
===================================================================
--- /branches/PushGP/HeuristicLab.PushGP/PushGp.sln.DotSettings.user	(revision 15288)
+++ 	(revision )
@@ -1,16 +1,0 @@
-﻿<wpf:ResourceDictionary xml:space="preserve" xmlns:x="http://schemas.microsoft.com/winfx/2006/xaml" xmlns:s="clr-namespace:System;assembly=mscorlib" xmlns:ss="urn:shemas-jetbrains-com:settings-storage-xaml" xmlns:wpf="http://schemas.microsoft.com/winfx/2006/xaml/presentation">
-	
-	
-	
-	<s:String x:Key="/Default/Environment/AssemblyExplorer/XmlDocument/@EntryValue">&lt;AssemblyExplorer&gt;&#xD;
-  &lt;Assembly Path="T:\BTSync\projects\svn\hl\trunk\sources\bin\HeuristicLab.Encodings.SymbolicExpressionTreeEncoding-3.4.dll" /&gt;&#xD;
-  &lt;Assembly Path="T:\BTSync\projects\svn\hl\trunk\sources\bin\HeuristicLab.Data-3.3.dll" /&gt;&#xD;
-&lt;/AssemblyExplorer&gt;</s:String>
-	<s:String x:Key="/Default/Environment/ContinuousTesting/PersistentDataLocation/@EntryValue">C:\Users\patrik\AppData\Local\Temp\JetBrains\ContinuousTesting\746fd168-170a-41d1-95ca-ce9f1586dc7d</s:String>
-	<s:String x:Key="/Default/Environment/ContinuousTesting/ScopeCriterion/@EntryValue">9b0nIQIAAAD5I2nNAgAAANetlRIwh2K/AQAAAOWawpcGAAAATQBTAFQAZQBzAHQAJAAAADEAMQA3AEIANwBEADYAOAAtAEUARAA3AEQALQA0ADMANQAwAC0AOQA5ADYAQgAtADkAQwBBADEANQAyADUAOQBFADEAMAA3ADgAAABIAGUAdQByAGkAcwB0AGkAYwBMAGEAYgAuAFQAZQBzAHQAcwAuAEIAZQBuAGMAaABtAGEAcgBrAC4AUAByAG8AYgBsAGUAbQBUAGUAcwB0AHMALgBDAG8AbABsAGEAdAB6AE4AdQBtAGIAZQByAHMA9b0nIQIAAADXrZUSMIdivwEAAADlmsKXBgAAAE0AUwBUAGUAcwB0ACQAAAAxADEANwBCADcARAA2ADgALQBFAEQANwBEAC0ANAAzADUAMAAtADkAOQA2AEIALQA5AEMAQQAxADUAMgA1ADkARQAxADAANwA4AAAASABlAHUAcgBpAHMAdABpAGMATABhAGIALgBUAGUAcwB0AHMALgBCAGUAbgBjAGgAbQBhAHIAawAuAFAAcgBvAGIAbABlAG0AVABlAHMAdABzAC4AQwBvAGwAbABhAHQAegBOAHUAbQBiAGUAcgBzADCHYr8BAAAA5ZrClwYAAABNAFMAVABlAHMAdAAkAAAAMQAxADcAQgA3AEQANgA4AC0ARQBEADcARAAtADQAMwA1ADAALQA5ADkANgBCAC0AOQBDAEEAMQA1ADIANQA5AEUAMQAwADcAMAAAAEgAZQB1AHIAaQBzAHQAaQBjAEwAYQBiAC4AVABlAHMAdABzAC4AUAByAG8AYgBsAGUAbQAuAEkAbgBkAGkAdgBpAGQAdQBhAGwATQBhAHAAcABlAHIAVABlAHMAdABzADCHYr8BAAAA5ZrClwYAAABNAFMAVABlAHMAdAAkAAAAMQAxADcAQgA3AEQANgA4AC0ARQBEADcARAAtADQAMwA1ADAALQA5ADkANgBCAC0AOQBDAEEAMQA1ADIANQA5AEUAMQAwADcAMwAAAEgAZQB1AHIAaQBzAHQAaQBjAEwAYQBiAC4AVABlAHMAdABzAC4AQgBlAG4AYwBoAG0AYQByAGsALgBTAG8AbAB1AHQAaQBvAG4AVABlAHMAdABzAC4AVwBhAGwAbABpAHMAUABpAA==</s:String>
-	<s:String x:Key="/Default/Environment/ContinuousTesting/SnapshotLocation/@EntryValue">C:\Users\patrik\AppData\Local\Temp\ssm.Gihabis.tmp</s:String>
-	
-	
-	<s:Int64 x:Key="/Default/Environment/ContinuousTestingSessionDescriptor/GroupingIndex/@EntryValue">5</s:Int64>
-	<s:Boolean x:Key="/Default/VsIntegrationViewOptions/ShowCharts/@EntryValue">False</s:Boolean>
-	</wpf:ResourceDictionary>
