Index: branches/PushGP/HeuristicLab.PushGP/HeuristicLab.Problem.ProgramSynthesis.BenchmarkSuite/BenchmarkSuiteDataDescriptor.cs
===================================================================
--- branches/PushGP/HeuristicLab.PushGP/HeuristicLab.Problem.ProgramSynthesis.BenchmarkSuite/BenchmarkSuiteDataDescriptor.cs	(revision 14733)
+++ branches/PushGP/HeuristicLab.PushGP/HeuristicLab.Problem.ProgramSynthesis.BenchmarkSuite/BenchmarkSuiteDataDescriptor.cs	(revision 14744)
@@ -9,48 +9,48 @@
 
   using HeuristicLab.BenchmarkSuite.Problems;
+  using HeuristicLab.Common;
+  using HeuristicLab.Core;
+  using HeuristicLab.Persistence.Default.CompositeSerializers.Storable;
 
   using Microsoft.VisualBasic.FileIO;
 
-  public abstract class BenchmarkSuiteDataDescriptor : IBenchmarkSuiteDataDescriptor, IExampleParser {
-    protected const string InstanceArchiveName = "HeuristicLab.BenchmarkSuite.Data.BenchmarkExamples.zip";
-    protected const string ResourcePath = @".*\.Data\.";
-    protected const string ExampleSeparator = ",";
 
-    protected const char ArrayValueSeparator = ' ';
-    protected static readonly char[] ArraySymbolTrim = { '[', ']' };
+  [StorableClass]
+  public abstract class BenchmarkSuiteDataDescriptor : NamedItem, IBenchmarkSuiteDataDescriptor {
+    private const string InstanceArchiveName = "HeuristicLab.BenchmarkSuite.Data.BenchmarkExamples.zip";
+    private const string ResourcePath = @".*\.Data\.";
+    private const string ExampleSeparator = ",";
 
-    private readonly Lazy<Data> data;
-    private readonly Lazy<Example[]> examples;
+    private const char ArrayValueSeparator = ' ';
+    private static readonly char[] ArraySymbolTrim = { '[', ']' };
 
-    protected BenchmarkSuiteDataDescriptor() {
-      examples = new Lazy<Example[]>(ParseData().ToArray, false);
+    protected BenchmarkSuiteDataDescriptor() { }
+
+    [StorableConstructor]
+    protected BenchmarkSuiteDataDescriptor(bool deserializing) : base(deserializing) { }
+
+
+    [Storable]
+    private Example[] examples;
+    public Example[] Examples
+    {
+      get
+      {
+        return this.examples ?? (this.examples = this.ParseData().ToArray());
+      }
     }
 
-    protected Example[] Examples { get { return examples.Value; } }
-
-    public abstract string Name { get; }
-    public abstract string FileName { get; }
-    public abstract string Description { get; }
-    protected abstract int OriginalTrainingCount { get; }
-    protected abstract int OriginalTestCount { get; }
-    protected abstract int BestResult { get; }
-    protected abstract int WorstResult { get; }
-    protected abstract int InputArgumentCount { get; }
-    protected abstract int OutputArgumentCount { get; }
-    protected int TotalArgumentCount { get { return InputArgumentCount + OutputArgumentCount; } }
+    public new abstract string Name { get; }
+    protected abstract string FileName { get; }
+    public new abstract string Description { get; }
+    public abstract int OriginalTrainingCount { get; }
+    public abstract int OriginalTestCount { get; }
+    public abstract int BestResult { get; }
+    public abstract int WorstResult { get; }
+    public abstract int InputArgumentCount { get; }
+    public abstract int OutputArgumentCount { get; }
+    public int TotalArgumentCount { get { return InputArgumentCount + OutputArgumentCount; } }
 
     public abstract Example ParseExample(string[] input, string[] output);
-
-    public Data CreateData() {
-      return new Data(
-        BestResult,
-        WorstResult,
-        OriginalTestCount,
-        OriginalTrainingCount,
-        InputArgumentCount,
-        OutputArgumentCount,
-        Examples,
-        this);
-    }
 
     private IEnumerable<Example> ParseData() {
@@ -127,4 +127,8 @@
       throw new InvalidDataException(string.Format("Unable to parse {0} as boolean", str));
     }
+
+    public override IDeepCloneable Clone(Cloner cloner) {
+      return this;
+    }
   }
 }
Index: branches/PushGP/HeuristicLab.PushGP/HeuristicLab.Problem.ProgramSynthesis.BenchmarkSuite/BenchmarkSuiteInstanceProvider.cs
===================================================================
--- branches/PushGP/HeuristicLab.PushGP/HeuristicLab.Problem.ProgramSynthesis.BenchmarkSuite/BenchmarkSuiteInstanceProvider.cs	(revision 14733)
+++ branches/PushGP/HeuristicLab.PushGP/HeuristicLab.Problem.ProgramSynthesis.BenchmarkSuite/BenchmarkSuiteInstanceProvider.cs	(revision 14744)
@@ -3,10 +3,9 @@
 
 namespace HeuristicLab.BenchmarkSuite {
-  using System.Linq;
 
   using HeuristicLab.BenchmarkSuite.Problems;
   using HeuristicLab.Problems.Instances;
 
-  public class BenchmarkSuiteInstanceProvider : ProblemInstanceProvider<Data> {
+  public class BenchmarkSuiteInstanceProvider : ProblemInstanceProvider<IBenchmarkSuiteDataDescriptor> {
     private const string name = "General Program Synthesis Benchmark Suite";
     private const string referencePublication =
@@ -53,8 +52,6 @@
     }
 
-    public override Data LoadData(IDataDescriptor descriptor) {
-      var benchmarkSuiteDataDescriptor = (IBenchmarkSuiteDataDescriptor)descriptor;
-
-      return benchmarkSuiteDataDescriptor.CreateData();
+    public override IBenchmarkSuiteDataDescriptor LoadData(IDataDescriptor descriptor) {
+      return (IBenchmarkSuiteDataDescriptor)descriptor;
     }
   }
Index: branches/PushGP/HeuristicLab.PushGP/HeuristicLab.Problem.ProgramSynthesis.BenchmarkSuite/HeuristicLab.BenchmarkSuite.csproj
===================================================================
--- branches/PushGP/HeuristicLab.PushGP/HeuristicLab.Problem.ProgramSynthesis.BenchmarkSuite/HeuristicLab.BenchmarkSuite.csproj	(revision 14733)
+++ branches/PushGP/HeuristicLab.PushGP/HeuristicLab.Problem.ProgramSynthesis.BenchmarkSuite/HeuristicLab.BenchmarkSuite.csproj	(revision 14744)
@@ -98,7 +98,5 @@
     <Compile Include="BenchmarkSuiteInstanceProvider.cs" />
     <Compile Include="IBenchmarkSuiteDataDescriptor.cs" />
-    <Compile Include="IExampleParser.cs" />
     <Compile Include="Plugin.cs" />
-    <Compile Include="Problems\Data.cs" />
     <Compile Include="Problems\Example.cs" />
     <Compile Include="Problems\ReplaceSpaceWithNewline.cs" />
Index: branches/PushGP/HeuristicLab.PushGP/HeuristicLab.Problem.ProgramSynthesis.BenchmarkSuite/IBenchmarkSuiteDataDescriptor.cs
===================================================================
--- branches/PushGP/HeuristicLab.PushGP/HeuristicLab.Problem.ProgramSynthesis.BenchmarkSuite/IBenchmarkSuiteDataDescriptor.cs	(revision 14733)
+++ branches/PushGP/HeuristicLab.PushGP/HeuristicLab.Problem.ProgramSynthesis.BenchmarkSuite/IBenchmarkSuiteDataDescriptor.cs	(revision 14744)
@@ -1,8 +1,22 @@
 ﻿namespace HeuristicLab.BenchmarkSuite {
   using HeuristicLab.BenchmarkSuite.Problems;
+  using HeuristicLab.Core;
   using HeuristicLab.Problems.Instances;
 
-  public interface IBenchmarkSuiteDataDescriptor : IDataDescriptor {
-    Data CreateData();
+  public interface IBenchmarkSuiteDataDescriptor : IDataDescriptor, INamedItem {
+    //Data CreateData();
+    Example[] Examples { get; }
+
+    string Name { get; }
+    string Description { get; }
+    int OriginalTrainingCount { get; }
+    int OriginalTestCount { get; }
+    int BestResult { get; }
+    int WorstResult { get; }
+    int InputArgumentCount { get; }
+    int OutputArgumentCount { get; }
+    int TotalArgumentCount { get; }
+
+    Example ParseExample(string[] input, string[] output);
   }
 }
Index: branches/PushGP/HeuristicLab.PushGP/HeuristicLab.Problem.ProgramSynthesis.BenchmarkSuite/Problems/Checksum.cs
===================================================================
--- branches/PushGP/HeuristicLab.PushGP/HeuristicLab.Problem.ProgramSynthesis.BenchmarkSuite/Problems/Checksum.cs	(revision 14733)
+++ branches/PushGP/HeuristicLab.PushGP/HeuristicLab.Problem.ProgramSynthesis.BenchmarkSuite/Problems/Checksum.cs	(revision 14744)
@@ -3,18 +3,25 @@
   using System.Text;
 
+  using HeuristicLab.Persistence.Default.CompositeSerializers.Storable;
+
+  [StorableClass]
   public class Checksum : BenchmarkSuiteDataDescriptor {
     private const string name = "Checksum";
     private const string fileName = "Checksum.csv";
     private const string description = "";
+    public Checksum() { }
+
+    [StorableConstructor]
+    public Checksum(bool deserializing) : base(deserializing) { }
 
     public override string Name { get { return name; } }
-    public override string FileName { get { return fileName; } }
+    protected override string FileName { get { return fileName; } }
     public override string Description { get { return description; } }
-    protected override int InputArgumentCount { get { return 1; } }
-    protected override int OutputArgumentCount { get { return 1; } }
-    protected override int OriginalTrainingCount { get { return 228; } }
-    protected override int OriginalTestCount { get { return 1254; } }
-    protected override int BestResult { get { return 0; } }
-    protected override int WorstResult { get { return byte.MaxValue; } }
+    public override int InputArgumentCount { get { return 1; } }
+    public override int OutputArgumentCount { get { return 1; } }
+    public override int OriginalTrainingCount { get { return 228; } }
+    public override int OriginalTestCount { get { return 1254; } }
+    public override int BestResult { get { return 0; } }
+    public override int WorstResult { get { return byte.MaxValue; } }
 
     public override Example ParseExample(string[] input, string[] output) {
Index: branches/PushGP/HeuristicLab.PushGP/HeuristicLab.Problem.ProgramSynthesis.BenchmarkSuite/Problems/CountOdds.cs
===================================================================
--- branches/PushGP/HeuristicLab.PushGP/HeuristicLab.Problem.ProgramSynthesis.BenchmarkSuite/Problems/CountOdds.cs	(revision 14733)
+++ branches/PushGP/HeuristicLab.PushGP/HeuristicLab.Problem.ProgramSynthesis.BenchmarkSuite/Problems/CountOdds.cs	(revision 14744)
@@ -1,4 +1,6 @@
 ﻿namespace HeuristicLab.BenchmarkSuite.Problems {
+  using HeuristicLab.Persistence.Default.CompositeSerializers.Storable;
 
+  [StorableClass]
   public class CountOdds : BenchmarkSuiteDataDescriptor {
     private const string name = "Count Odds";
@@ -6,13 +8,18 @@
     private const string description = "";
 
+    public CountOdds() { }
+
+    [StorableConstructor]
+    public CountOdds(bool deserializing) : base(deserializing) { }
+
     public override string Name { get { return name; } }
-    public override string FileName { get { return fileName; } }
     public override string Description { get { return description; } }
-    protected override int InputArgumentCount { get { return 1; } }
-    protected override int OutputArgumentCount { get { return 1; } }
-    protected override int OriginalTrainingCount { get { return 200; } }
-    protected override int OriginalTestCount { get { return 2000; } }
-    protected override int BestResult { get { return 0; } }
-    protected override int WorstResult { get { return 50; } }
+    protected override string FileName { get { return fileName; } }
+    public override int InputArgumentCount { get { return 1; } }
+    public override int OutputArgumentCount { get { return 1; } }
+    public override int OriginalTrainingCount { get { return 200; } }
+    public override int OriginalTestCount { get { return 2000; } }
+    public override int BestResult { get { return 0; } }
+    public override int WorstResult { get { return 50; } }
 
     public override Example ParseExample(string[] input, string[] output) {
Index: branches/PushGP/HeuristicLab.PushGP/HeuristicLab.Problem.ProgramSynthesis.BenchmarkSuite/Problems/Example.cs
===================================================================
--- branches/PushGP/HeuristicLab.PushGP/HeuristicLab.Problem.ProgramSynthesis.BenchmarkSuite/Problems/Example.cs	(revision 14733)
+++ branches/PushGP/HeuristicLab.PushGP/HeuristicLab.Problem.ProgramSynthesis.BenchmarkSuite/Problems/Example.cs	(revision 14744)
@@ -1,3 +1,4 @@
 ﻿namespace HeuristicLab.BenchmarkSuite.Problems {
+  using System;
 
   using HeuristicLab.Common;
@@ -23,14 +24,14 @@
 
     public void CopyTo(Example example) {
-      example.InputArgs = this.InputArgs;
-      example.OutputArgs = this.OutputArgs;
+      Array.Copy(InputArgs, example.InputArgs, InputArgs.Length);
+      Array.Copy(OutputArgs, example.OutputArgs, OutputArgs.Length);
 
-      example.InputBoolean = this.InputBoolean;
-      example.InputInt = this.InputInt;
-      example.InputFloat = this.InputFloat;
+      Array.Copy(InputBoolean, example.InputBoolean, InputBoolean.Length);
+      Array.Copy(InputInt, example.InputInt, InputInt.Length);
+      Array.Copy(InputFloat, example.InputFloat, InputFloat.Length);
 
-      example.OutputBoolean = this.OutputBoolean;
-      example.OutputInt = this.OutputInt;
-      example.OutputFloat = this.OutputFloat;
+      Array.Copy(OutputBoolean, example.OutputBoolean, OutputBoolean.Length);
+      Array.Copy(OutputInt, example.OutputInt, OutputInt.Length);
+      Array.Copy(OutputFloat, example.OutputFloat, OutputFloat.Length);
     }
 
Index: branches/PushGP/HeuristicLab.PushGP/HeuristicLab.Problem.ProgramSynthesis.BenchmarkSuite/Views/DataEditorView.cs
===================================================================
--- branches/PushGP/HeuristicLab.PushGP/HeuristicLab.Problem.ProgramSynthesis.BenchmarkSuite/Views/DataEditorView.cs	(revision 14733)
+++ branches/PushGP/HeuristicLab.PushGP/HeuristicLab.Problem.ProgramSynthesis.BenchmarkSuite/Views/DataEditorView.cs	(revision 14744)
@@ -2,11 +2,9 @@
 
 namespace HeuristicLab.BenchmarkSuite.Views {
-
-  using HeuristicLab.BenchmarkSuite.Problems;
   using HeuristicLab.Core.Views;
   using HeuristicLab.MainForm;
 
   [View("Push Expression Selection Editor")]
-  [Content(typeof(Data), true)]
+  [Content(typeof(IBenchmarkSuiteDataDescriptor), true)]
   public partial class DataEditorView : NamedItemView {
     public DataEditorView() {
@@ -35,5 +33,5 @@
 
       try {
-        var newExample = Content.ExampleParser.ParseExample(inputArgs, outputArgs);
+        var newExample = Content.ParseExample(inputArgs, outputArgs);
         newExample.CopyTo(example);
       }
@@ -48,7 +46,7 @@
     }
 
-    public new Data Content
+    public new IBenchmarkSuiteDataDescriptor Content
     {
-      get { return (Data)base.Content; }
+      get { return (IBenchmarkSuiteDataDescriptor)base.Content; }
       set
       {
@@ -64,7 +62,4 @@
 
     protected override void OnContentChanged() {
-      const string inputPrefix = "in_";
-      const string outputPrefix = "out_";
-
       dataGridView.Columns.Clear();
       dataGridView.Rows.Clear();
Index: branches/PushGP/HeuristicLab.PushGP/HeuristicLab.Problems.ProgramSynthesis/HeuristicLab.Problems.ProgramSynthesis.csproj
===================================================================
--- branches/PushGP/HeuristicLab.PushGP/HeuristicLab.Problems.ProgramSynthesis/HeuristicLab.Problems.ProgramSynthesis.csproj	(revision 14733)
+++ branches/PushGP/HeuristicLab.PushGP/HeuristicLab.Problems.ProgramSynthesis/HeuristicLab.Problems.ProgramSynthesis.csproj	(revision 14744)
@@ -116,7 +116,8 @@
     <Compile Include="Push\Configuration\IEnabledExpressionsConfiguration.cs" />
     <Compile Include="Push\Creator\PointsBasedPushProgramCreator.cs" />
+    <Compile Include="Push\Data\List\SkipList.cs" />
+    <Compile Include="Push\Data\Pool\ManagedPool.cs" />
     <Compile Include="Push\Data\Pool\ObjectPool.cs" />
-    <Compile Include="Push\Data\Tree\ExpressionNode.cs" />
-    <Compile Include="Push\Data\Tree\ExpressionTree.cs" />
+    <Compile Include="Push\Data\Pool\PoolContainer.cs" />
     <Compile Include="Push\Exporter\Exporter.cs" />
     <Compile Include="Push\Expressions\BooleanExpressions.cs" />
Index: branches/PushGP/HeuristicLab.PushGP/HeuristicLab.Problems.ProgramSynthesis/HeuristicLab.Problems.ProgramSynthesis.csproj.user
===================================================================
--- branches/PushGP/HeuristicLab.PushGP/HeuristicLab.Problems.ProgramSynthesis/HeuristicLab.Problems.ProgramSynthesis.csproj.user	(revision 14733)
+++ branches/PushGP/HeuristicLab.PushGP/HeuristicLab.Problems.ProgramSynthesis/HeuristicLab.Problems.ProgramSynthesis.csproj.user	(revision 14744)
@@ -7,8 +7,10 @@
     <StartAction>Program</StartAction>
     <StartProgram>T:\BTSync\projects\svn\hl\trunk\sources\bin\HeuristicLab 3.3.exe</StartProgram>
+    <StartArguments>/hideStarter /start:Optimizer</StartArguments>
   </PropertyGroup>
   <PropertyGroup Condition="'$(Configuration)|$(Platform)' == 'Release|AnyCPU'">
     <StartAction>Program</StartAction>
     <StartProgram>T:\BTSync\projects\svn\hl\trunk\sources\bin\HeuristicLab 3.3.exe</StartProgram>
+    <StartArguments>/hideStarter /start:Optimizer</StartArguments>
   </PropertyGroup>
 </Project>
Index: branches/PushGP/HeuristicLab.PushGP/HeuristicLab.Problems.ProgramSynthesis/Push/Configuration/IReadonlyPushConfiguration.cs
===================================================================
--- branches/PushGP/HeuristicLab.PushGP/HeuristicLab.Problems.ProgramSynthesis/Push/Configuration/IReadonlyPushConfiguration.cs	(revision 14744)
+++ branches/PushGP/HeuristicLab.PushGP/HeuristicLab.Problems.ProgramSynthesis/Push/Configuration/IReadonlyPushConfiguration.cs	(revision 14744)
@@ -0,0 +1,25 @@
+﻿namespace HeuristicLab.Problems.ProgramSynthesis.Push.Configuration {
+  using System.Collections.Generic;
+
+  public interface IReadonlyPushConfiguration {
+    bool IsBooleanStackEnabled { get; }
+    bool IsIntegerStackEnabled { get; }
+    bool IsFloatStackEnabled { get; }
+    bool IsCodeStackEnabled { get; }
+    bool IsNameStackEnabled { get; }
+    double ErcProbability { get; }
+    int EvalPushLimit { get; }
+    int MaxDepth { get; }
+    int MaxPointsInProgram { get; }
+    int MaxPointsInRandomExpression { get; }
+    bool TopLevelPushCode { get; }
+    bool TopLevelPopCode { get; }
+    int MinRandomInteger { get; }
+    int MaxRandomInteger { get; }
+    double MinRandomFloat { get; }
+    double MaxRandomFloat { get; }
+    double NewErcNameProbability { get; }
+
+    IReadOnlyList<string> EnabledExpressions { 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 14744)
+++ branches/PushGP/HeuristicLab.PushGP/HeuristicLab.Problems.ProgramSynthesis/Push/Configuration/PushConfiguration.cs	(revision 14744)
@@ -0,0 +1,357 @@
+﻿namespace HeuristicLab.Problems.ProgramSynthesis.Push.Configuration {
+  using System;
+  using System.Collections.Generic;
+  using System.Linq;
+
+  using HeuristicLab.Common;
+  using HeuristicLab.Core;
+  using HeuristicLab.Persistence.Default.CompositeSerializers.Storable;
+  using HeuristicLab.Problems.ProgramSynthesis.Push.Attributes;
+  using HeuristicLab.Problems.ProgramSynthesis.Push.Expressions;
+  using HeuristicLab.Problems.ProgramSynthesis.Push.Stack;
+
+  [StorableClass]
+  public class PushConfiguration : NamedItem, IReadonlyPushConfiguration, IEnabledExpressionsConfiguration {
+    private static readonly string itemName = "PushGP Configuration";
+
+    public PushConfiguration() {
+      this.EvalPushLimit = 4096;
+      this.MaxPointsInProgram = 128;
+      this.MaxPointsInRandomExpression = 64;
+
+      this.TopLevelPushCode = true;
+      this.TopLevelPopCode = false;
+
+      this.MinRandomInteger = -128;
+      this.MaxRandomInteger = 128;
+      this.MinRandomFloat = -128D;
+      this.MaxRandomFloat = 128D;
+      this.NewErcNameProbability = 0.5;
+      this.ErcProbability = 0.2;
+
+      this.EnabledExpressions = ExpressionTable.ExpressionNames.ToList();
+    }
+
+    [StorableConstructor]
+    public PushConfiguration(bool deserializing) : base(deserializing) { }
+
+    public PushConfiguration(PushConfiguration origin, Cloner cloner) : base(origin, cloner) {
+      this.EnabledExpressions = origin.EnabledExpressions.ToList();
+
+      this.EvalPushLimit = origin.EvalPushLimit;
+      this.MaxPointsInProgram = origin.MaxPointsInProgram;
+      this.MaxPointsInRandomExpression = origin.MaxPointsInRandomExpression;
+
+      this.TopLevelPushCode = origin.TopLevelPushCode;
+      this.TopLevelPopCode = origin.TopLevelPopCode;
+
+      this.MinRandomInteger = origin.MinRandomInteger;
+      this.MaxRandomInteger = origin.MaxRandomInteger;
+      this.MinRandomFloat = origin.MinRandomFloat;
+      this.MaxRandomFloat = origin.MaxRandomFloat;
+      this.NewErcNameProbability = origin.NewErcNameProbability;
+      this.ErcProbability = origin.ErcProbability;
+
+      this.isBooleanStackEnabled = origin.IsBooleanStackEnabled;
+      this.isIntegerStackEnabled = origin.IsIntegerStackEnabled;
+      this.isFloatStackEnabled = origin.IsFloatStackEnabled;
+      this.isNameStackEnabled = origin.IsNameStackEnabled;
+      this.isCodeStackEnabled = origin.IsCodeStackEnabled;
+      this.isExecStackEnabled = origin.IsExecStackEnable;
+    }
+
+    public event EventHandler<EnabledExpressionsChangedEventArgs> EnabledExpressionsChanged;
+
+    [Storable]
+    public IList<string> EnabledExpressions { get; private set; }
+
+    IReadOnlyList<string> IReadonlyPushConfiguration.EnabledExpressions { get { return this.EnabledExpressions as IReadOnlyList<string>; } }
+
+    [Storable]
+    private bool isBooleanStackEnabled = true;
+
+    public bool IsBooleanStackEnabled
+    {
+      get
+      {
+        return this.isBooleanStackEnabled;
+      }
+
+      set
+      {
+        if (this.isBooleanStackEnabled == value) return;
+
+        this.isBooleanStackEnabled = value;
+
+        if (this.isBooleanStackEnabled) EnableExpressionOfStack(StackType.Boolean);
+        else DisableExpressionOfStack(StackType.Boolean);
+      }
+    }
+
+    [Storable]
+    private bool isIntegerStackEnabled = true;
+
+    public bool IsIntegerStackEnabled
+    {
+      get
+      {
+        return this.isIntegerStackEnabled;
+      }
+
+      set
+      {
+        if (this.isIntegerStackEnabled == value) return;
+
+        this.isIntegerStackEnabled = value;
+
+        if (this.isIntegerStackEnabled) EnableExpressionOfStack(StackType.Integer);
+        else DisableExpressionOfStack(StackType.Integer);
+      }
+    }
+
+    [Storable]
+    private bool isFloatStackEnabled = true;
+
+    public bool IsFloatStackEnabled
+    {
+      get
+      {
+        return this.isFloatStackEnabled;
+      }
+
+      set
+      {
+        if (this.isFloatStackEnabled == value) return;
+
+        this.isFloatStackEnabled = value;
+
+        if (this.isFloatStackEnabled) EnableExpressionOfStack(StackType.Float);
+        else DisableExpressionOfStack(StackType.Float);
+      }
+    }
+
+    [Storable]
+    private bool isCodeStackEnabled = true;
+
+    public bool IsCodeStackEnabled
+    {
+      get
+      {
+        return this.isCodeStackEnabled;
+      }
+
+      set
+      {
+        if (this.isCodeStackEnabled == value) return;
+
+        this.isCodeStackEnabled = value;
+
+        if (this.isCodeStackEnabled) EnableExpressionOfStack(StackType.Code);
+        else DisableExpressionOfStack(StackType.Code);
+      }
+    }
+
+    [Storable]
+    private bool isExecStackEnabled = true;
+
+    public bool IsExecStackEnable
+    {
+      get
+      {
+        return this.isExecStackEnabled;
+      }
+
+      set
+      {
+        if (this.isExecStackEnabled == value) return;
+
+        this.isExecStackEnabled = value;
+
+        if (this.isExecStackEnabled) EnableExpressionOfStack(StackType.Exec);
+        else DisableExpressionOfStack(StackType.Exec);
+      }
+    }
+
+    [Storable]
+    private bool isNameStackEnabled = true;
+
+    public bool IsNameStackEnabled
+    {
+      get
+      {
+        return this.isNameStackEnabled;
+      }
+
+      set
+      {
+        if (this.isNameStackEnabled == value) return;
+
+        this.isNameStackEnabled = value;
+
+        if (this.isNameStackEnabled) EnableExpressionOfStack(StackType.Name);
+        else DisableExpressionOfStack(StackType.Name);
+      }
+    }
+
+    [Storable]
+    public double ErcProbability { get; set; }
+
+    /// <summary>
+    ///     This is the maximum allowed number of "executions" in a single top-level call to the interpreter.
+    ///     The execution of a single Push instruction counts as one execution, as does the processing of a single literal,
+    ///     as does the descent into one layer of parentheses (that is, the processing of the "(" counts as one execution).
+    ///     When this limit is exceeded the interpreter aborts immediately, leaving its stacks in the states they were in prior
+    ///     to the abort (so they may still be examined by a calling program). Whether or not this counts as an "abnormal"
+    ///     termination
+    ///     is up to the calling program.
+    /// </summary>
+    [Storable]
+    public int EvalPushLimit { get; set; }
+
+    /// <summary>
+    /// This is the maximum of depth a push program can have. Expressions, which lead to exceed this limit are interpreted as NOOP.
+    /// </summary>
+    [Storable]
+    public int MaxDepth { get; set; }
+
+    /// <summary>
+    ///     This is the maximum size of an item on the CODE stack, expressed as a number of points.
+    ///     A point is an instruction, a literal, or a pair of parentheses. Any instruction that would cause this limit to be
+    ///     exceeded
+    ///     should instead act as a NOOP, leaving all stacks in the states that they were in before the execution of the
+    ///     instruction.
+    /// </summary>
+    [Storable]
+    public int MaxPointsInProgram { get; set; }
+
+    /// <summary>
+    ///     The maximum number of points in an expression produced by the CODE.RAND instruction.
+    /// </summary>
+    [Storable]
+    public int MaxPointsInRandomExpression { get; set; }
+
+    /// <summary>
+    ///     When TRUE (which is the default), code passed to the top level of the interpreter
+    ///     will be pushed onto the CODE stack prior to execution.
+    /// </summary>
+    [Storable]
+    public bool TopLevelPushCode { get; set; }
+
+    /// <summary>
+    ///     When TRUE, the CODE stack will be popped at the end of top level calls to the interpreter. The default is FALSE.
+    /// </summary>
+    [Storable]
+    public bool TopLevelPopCode { get; set; }
+
+    /// <summary>
+    ///     The minimum INTEGER that will be produced as an ephemeral random INTEGER constant or from a call to INTEGER.RAND.
+    /// </summary>
+    [Storable]
+    public int MinRandomInteger { get; set; }
+
+    /// <summary>
+    ///     The maximum INTEGER that will be produced as an ephemeral random INTEGER constant or from a call to INTEGER.RAND.
+    /// </summary>
+    [Storable]
+    public int MaxRandomInteger { get; set; }
+
+    /// <summary>
+    ///     The minimum FLOAT that will be produced as an ephemeral random FLOAT constant or from a call to FLOAT.RAND.
+    /// </summary>
+    [Storable]
+    public double MinRandomFloat { get; set; }
+
+    /// <summary>
+    ///     The maximum FLOAT that will be produced as an ephemeral random FLOAT constant or from a call to FLOAT.RAND.
+    /// </summary>
+    [Storable]
+    public double MaxRandomFloat { get; set; }
+
+    /// <summary>
+    ///     The probability that the selection of the ephemeral
+    ///     random NAME constant for inclusion in randomly generated code will produce a new name
+    ///     (rather than a name that was previously generated).
+    /// </summary>
+    [Storable]
+    public double NewErcNameProbability { get; set; }
+
+    public void EnableExpressionOfStack(StackType type) {
+      foreach (var name in ExpressionTable.StackTypeToNamesTable[type]) {
+        EnableExpression(name);
+      }
+    }
+
+    public void DisableExpressionOfStack(StackType type) {
+      foreach (var name in ExpressionTable.StackTypeToNamesTable[type]) {
+        DisableExpression(name);
+      }
+    }
+
+    public void EnableExpression(string name) {
+      if (EnabledExpressions.Contains(name)) return;
+
+      EnabledExpressions.Add(name);
+
+      if (EnabledExpressionsChanged != null) {
+        EnabledExpressionsChanged.Invoke(this, new EnabledExpressionsChangedEventArgs(
+          new[] { name },
+          new string[0]));
+      }
+    }
+
+    public void DisableExpression(string name) {
+      if (!EnabledExpressions.Contains(name)) return;
+
+      EnabledExpressions.Remove(name);
+
+      if (EnabledExpressionsChanged != null) {
+        EnabledExpressionsChanged.Invoke(this, new EnabledExpressionsChangedEventArgs(
+          new string[0],
+          new[] { name }));
+      }
+    }
+
+    public void EnableExpression<T>() where T : Expression {
+      var attribute = (PushExpressionAttribute)Attribute.GetCustomAttribute(typeof(T), typeof(PushExpressionAttribute));
+      EnableExpression(attribute.ExpressionName);
+    }
+
+    public void DisableExpression<T>() where T : Expression {
+      var attribute = (PushExpressionAttribute)Attribute.GetCustomAttribute(typeof(T), typeof(PushExpressionAttribute));
+      DisableExpression(attribute.ExpressionName);
+    }
+
+    public void EnableStack(StackType type) {
+      SetStack(type, true);
+    }
+
+    public void DisableStack(StackType type) {
+      SetStack(type, false);
+    }
+
+    private void SetStack(StackType type, bool value) {
+      switch (type) {
+        case StackType.Boolean:
+          IsBooleanStackEnabled = value;
+          break;
+        case StackType.Integer:
+          IsIntegerStackEnabled = value;
+          break;
+        case StackType.Float:
+          IsFloatStackEnabled = value;
+          break;
+        case StackType.Name:
+          IsNameStackEnabled = value;
+          break;
+        case StackType.Code:
+          IsCodeStackEnabled = value;
+          break;
+        default: throw new InvalidOperationException("Stacktype unkown");
+      }
+    }
+
+    public override IDeepCloneable Clone(Cloner cloner) {
+      return new PushConfiguration(this, cloner);
+    }
+  }
+}
Index: branches/PushGP/HeuristicLab.PushGP/HeuristicLab.Problems.ProgramSynthesis/Push/Creator/PointsBasedPushProgramCreator.cs
===================================================================
--- branches/PushGP/HeuristicLab.PushGP/HeuristicLab.Problems.ProgramSynthesis/Push/Creator/PointsBasedPushProgramCreator.cs	(revision 14733)
+++ branches/PushGP/HeuristicLab.PushGP/HeuristicLab.Problems.ProgramSynthesis/Push/Creator/PointsBasedPushProgramCreator.cs	(revision 14744)
@@ -1,29 +1,29 @@
-﻿namespace HeuristicLab.Problems.ProgramSynthesis.Push.Creator {
+﻿//namespace HeuristicLab.Problems.ProgramSynthesis.Push.Creator {
 
-  using HeuristicLab.Common;
-  using HeuristicLab.Core;
-  using HeuristicLab.Operators;
-  using HeuristicLab.Persistence.Default.CompositeSerializers.Storable;
-  using HeuristicLab.Problems.ProgramSynthesis.Push.Configuration;
-  using HeuristicLab.Problems.ProgramSynthesis.Push.Expressions;
-  using HeuristicLab.Problems.ProgramSynthesis.Push.Generators;
+//  using HeuristicLab.Common;
+//  using HeuristicLab.Core;
+//  using HeuristicLab.Operators;
+//  using HeuristicLab.Persistence.Default.CompositeSerializers.Storable;
+//  using HeuristicLab.Problems.ProgramSynthesis.Push.Configuration;
+//  using HeuristicLab.Problems.ProgramSynthesis.Push.Expressions;
+//  using HeuristicLab.Problems.ProgramSynthesis.Push.Generators;
 
-  [Item("PointBasedPushProgramCreator", "Creates a Push program whereby points specify the max size but not the min size of the program.")]
-  [StorableClass]
-  public class PointsBasedPushProgramCreator : InstrumentedOperator, IPushProgramCreator {
+//  [Item("PointBasedPushProgramCreator", "Creates a Push program whereby points specify the max size but not the min size of the program.")]
+//  [StorableClass]
+//  public class PointsBasedPushProgramCreator : InstrumentedOperator, IPushProgramCreator {
 
-    public PointsBasedPushProgramCreator(bool deserializing) : base(deserializing) { }
+//    public PointsBasedPushProgramCreator(bool deserializing) : base(deserializing) { }
 
-    public PointsBasedPushProgramCreator(PointsBasedPushProgramCreator origin, Cloner cloner) : base(origin, cloner) {
+//    public PointsBasedPushProgramCreator(PointsBasedPushProgramCreator origin, Cloner cloner) : base(origin, cloner) {
 
-    }
+//    }
 
-    public override IDeepCloneable Clone(Cloner cloner) {
-      return new PointsBasedPushProgramCreator(this, cloner);
-    }
+//    public override IDeepCloneable Clone(Cloner cloner) {
+//      return new PointsBasedPushProgramCreator(this, cloner);
+//    }
 
-    public PushProgram CreateProgram(IRandom random, IReadonlyPushConfiguration config) {
-      return CodeGenerator.RandomProgram(10, random, config);
-    }
-  }
-}
+//    public PushProgram CreateProgram(IRandom random, IReadonlyPushConfiguration config) {
+//      return CodeGenerator.RandomProgram(10, random, config);
+//    }
+//  }
+//}
Index: branches/PushGP/HeuristicLab.PushGP/HeuristicLab.Problems.ProgramSynthesis/Push/Data/List/SkipList.cs
===================================================================
--- branches/PushGP/HeuristicLab.PushGP/HeuristicLab.Problems.ProgramSynthesis/Push/Data/List/SkipList.cs	(revision 14744)
+++ branches/PushGP/HeuristicLab.PushGP/HeuristicLab.Problems.ProgramSynthesis/Push/Data/List/SkipList.cs	(revision 14744)
@@ -0,0 +1,506 @@
+﻿using System;
+using System.Collections.Generic;
+
+namespace HeuristicLab.Problems.ProgramSynthesis.Push.Data.List {
+  using System.Collections;
+
+  using HeuristicLab.Core;
+  using HeuristicLab.Random;
+
+  /// <summary>
+  /// The basic data block of a Skip List
+  /// </summary>
+  class SkipListNode<T> : IDisposable
+      where T : IComparable {
+    private T value;
+    private SkipListNode<T> next;
+    private SkipListNode<T> previous;
+    private SkipListNode<T> above;
+    private SkipListNode<T> below;
+
+    public virtual T Value
+    {
+      get { return value; }
+      set { this.value = value; }
+    }
+
+    public virtual SkipListNode<T> Next
+    {
+      get { return next; }
+      set { next = value; }
+    }
+
+    public virtual SkipListNode<T> Previous
+    {
+      get { return previous; }
+      set { previous = value; }
+    }
+
+    public virtual SkipListNode<T> Above
+    {
+      get { return above; }
+      set { above = value; }
+    }
+
+    public virtual SkipListNode<T> Below
+    {
+      get { return below; }
+      set { below = value; }
+    }
+
+    public SkipListNode(T value) {
+      this.Value = value;
+    }
+
+    public void Dispose() {
+      value = default(T);
+      next = null;
+      previous = null;
+      above = null;
+      previous = null;
+    }
+
+    public virtual bool IsHeader() {
+      return this.GetType() == typeof(SkipListNodeHeader<T>);
+    }
+
+    public virtual bool IsFooter() {
+      return this.GetType() == typeof(SkipListNodeFooter<T>);
+    }
+  }
+
+  /// <summary>
+  /// Represents a Skip List node that is the header of a level
+  /// </summary>
+  class SkipListNodeHeader<T> : SkipListNode<T>
+      where T : IComparable {
+    public SkipListNodeHeader()
+        : base(default(T)) {
+    }
+  }
+
+  /// <summary>
+  /// Represents a Skip List node that is the footer of a level
+  /// </summary>
+  class SkipListNodeFooter<T> : SkipListNode<T>
+      where T : IComparable {
+    public SkipListNodeFooter()
+        : base(default(T)) {
+    }
+  }
+
+  class SkipList<T> : ICollection<T>
+      where T : IComparable {
+    internal SkipListNode<T> topLeft;
+    internal SkipListNode<T> bottomLeft;
+    internal IRandom random;
+    private int levels;
+    private int size;
+    private int maxLevels = int.MaxValue;
+
+    public virtual int Levels
+    {
+      get { return levels; }
+    }
+
+    public virtual int MaxLevels
+    {
+      get { return maxLevels; }
+      set { maxLevels = value; }
+    }
+
+    public virtual int Count
+    {
+      get { return size; }
+    }
+
+    public virtual bool IsReadOnly
+    {
+      get { return false; }
+    }
+
+    public virtual SkipListNode<T> Head
+    {
+      get { return bottomLeft; }
+    }
+
+    public SkipList(IRandom random = null) {
+      topLeft = getEmptyLevel(); //create an empty level
+      bottomLeft = topLeft;
+      levels = 1; //update the level count
+      size = 0; //no elements added
+      this.random = random ?? new FastRandom(); //used for adding new values
+    }
+
+    /// <summary>
+    /// Creates an empty level with a header and footer node
+    /// </summary>
+    protected SkipListNode<T> getEmptyLevel() {
+      SkipListNode<T> negativeInfinity = new SkipListNodeHeader<T>();
+      SkipListNode<T> positiveInfinity = new SkipListNodeFooter<T>();
+
+      negativeInfinity.Next = positiveInfinity;
+      positiveInfinity.Previous = negativeInfinity;
+
+      return negativeInfinity;
+    }
+
+    /// <summary>
+    /// Randomly determines how many levels to add
+    /// </summary>
+    protected int getRandomLevels() {
+      int newLevels = 0;
+      while (random.Next(0, 2) == 1 && newLevels < maxLevels) //1 is heads, 0 is tails
+      {
+        newLevels++;
+      }
+      return newLevels;
+    }
+
+    /// <summary>
+    /// Removes all the empty levels leftover in the Skip List
+    /// </summary>
+    protected void clearEmptyLevels() {
+      if (this.levels > 1) //more than one level, don't want to remove bottom level
+      {
+        SkipListNode<T> currentNode = this.topLeft;
+
+        while (currentNode != this.bottomLeft) //do not remove the bottom level
+        {
+          if (currentNode.IsHeader() && currentNode.Next.IsFooter()) {
+            SkipListNode<T> belowNode = currentNode.Below;
+
+            //Remove the empty level
+
+            //Update pointers
+            topLeft = currentNode.Below;
+
+            //Remove links
+            currentNode.Next.Dispose();
+            currentNode.Dispose();
+
+            //Update counters
+            this.levels--;
+
+            currentNode = belowNode; //scan down
+          } else
+            break; //a single non-emtpy level means the rest of the levels are not empty
+        }
+      }
+    }
+
+    /// <summary>
+    /// Add a value to the Skip List
+    /// </summary>
+    public virtual void Add(T value) {
+      int valueLevels = getRandomLevels(); //determine height of value's tower
+
+      //Add levels to entire list if necessary
+      int newLevelCount = valueLevels - this.levels; //number of levels missing
+      while (newLevelCount > 0) {
+        //Create new level
+        SkipListNode<T> newLevel = getEmptyLevel();
+
+        //Link down
+        newLevel.Below = this.topLeft;
+        this.topLeft.Above = newLevel;
+        this.topLeft = newLevel; //update reference to most top-left node
+
+        //Update counters
+        newLevelCount--;
+        this.levels++;
+      }
+
+      //Insert the value in the proper position, creating as many levels as was randomly determined
+      SkipListNode<T> currentNode = this.topLeft;
+      SkipListNode<T> lastNodeAbove = null; //keeps track of the upper-level nodes in a tower
+      int currentLevel = this.levels - 1;
+
+      while (currentLevel >= 0 && currentNode != null) {
+        if (currentLevel > valueLevels) //too high on the list, nothing would be added to this level
+        {
+          currentNode = currentNode.Below; //scan down
+          currentLevel--; //going one level lower
+          continue; //skip adding to this level
+        }
+
+        //Add the value to the current level
+
+        //Find the biggest value on the current level that is less than the value to be added
+        while (currentNode.Next != null) {
+          if (!currentNode.Next.IsFooter() && currentNode.Next.Value.CompareTo(value) < 0) //smaller
+            currentNode = currentNode.Next; //keep scanning across
+          else
+            break; //the next node would be bigger than the value
+
+        }
+
+        //Insert the value right after the node found
+        SkipListNode<T> newNode = new SkipListNode<T>(value);
+        newNode.Next = currentNode.Next;
+        newNode.Previous = currentNode;
+        newNode.Next.Previous = newNode;
+        currentNode.Next = newNode;
+
+        //Link down/up the tower
+        if (lastNodeAbove != null) //is this node part of a tower?
+        {
+          lastNodeAbove.Below = newNode;
+          newNode.Above = lastNodeAbove;
+        }
+        lastNodeAbove = newNode; //start/continue tower
+
+        //Scan down
+        currentNode = currentNode.Below;
+        currentLevel--;
+      }
+
+      this.size++; //update count
+    }
+
+    /// <summary>
+    /// Returns the first node whose value matches the input value
+    /// </summary>
+    public virtual SkipListNode<T> Find(T value) {
+      SkipListNode<T> foundNode = this.topLeft;
+
+      //Look for the highest-level node with an element value matching the parameter value
+      while (foundNode != null && foundNode.Next != null) {
+        if (!foundNode.Next.IsFooter() && foundNode.Next.Value.CompareTo(value) < 0) //next node's value is still smaller
+          foundNode = foundNode.Next; //keep scanning across
+        else {
+          if (!foundNode.Next.IsFooter() && foundNode.Next.Value.Equals(value)) //value found
+          {
+            foundNode = foundNode.Next;
+            break;
+          } else
+            foundNode = foundNode.Below; //element not in this level, scan down
+        }
+      }
+
+      return foundNode;
+    }
+
+    /// <summary>
+    /// Returns the lowest node on the first tower to match the input value
+    /// </summary>
+    public virtual SkipListNode<T> FindLowest(T value) {
+      SkipListNode<T> valueNode = this.Find(value);
+      return this.FindLowest(valueNode);
+    }
+
+    /// <summary>
+    /// Returns the lowest node on the first tower to match the input value
+    /// </summary>
+    public virtual SkipListNode<T> FindLowest(SkipListNode<T> valueNode) {
+      if (valueNode == null)
+        return null;
+      else {
+        //Scan down to the lowest level
+        while (valueNode.Below != null) {
+          valueNode = valueNode.Below;
+        }
+        return valueNode;
+      }
+    }
+
+    /// <summary>
+    /// Returns the highest node on the first tower to match the input value
+    /// </summary>
+    public virtual SkipListNode<T> FindHighest(T value) {
+      SkipListNode<T> valueNode = this.Find(value);
+      return this.FindHighest(valueNode);
+    }
+
+    /// <summary>
+    /// Returns the highest node on the first tower to match the input value
+    /// </summary>
+    public virtual SkipListNode<T> FindHighest(SkipListNode<T> valueNode) {
+      if (valueNode == null)
+        return null;
+      else {
+        //Scan up to the highest level
+        while (valueNode.Above != null) {
+          valueNode = valueNode.Above;
+        }
+        return valueNode;
+      }
+    }
+
+    /// <summary>
+    /// Returns whether a value exists in the Skip List
+    /// </summary>
+    public virtual bool Contains(T value) {
+      return (this.Find(value) != null);
+    }
+
+    /// <summary>
+    /// Removes a value or node from the Skip List
+    /// </summary>
+    public virtual bool Remove(T value) {
+      SkipListNode<T> valueNode = this.FindHighest(value);
+      return this.Remove(valueNode);
+    }
+
+    /// <summary>
+    /// Removes a value or node from the Skip List
+    /// </summary>
+    public virtual bool Remove(SkipListNode<T> valueNode) {
+      if (valueNode == null)
+        return false;
+      else {
+        //Make sure node is top-level node in it's tower
+        if (valueNode.Above != null)
+          valueNode = this.FindHighest(valueNode);
+
+        //---Delete nodes going down the tower
+        SkipListNode<T> currentNodeDown = valueNode;
+        while (currentNodeDown != null) {
+          //Remove right-left links
+          SkipListNode<T> previousNode = currentNodeDown.Previous;
+          SkipListNode<T> nextNode = currentNodeDown.Next;
+
+          //Link the previous and next nodes to each other
+          previousNode.Next = nextNode;
+          nextNode.Previous = previousNode;
+
+          SkipListNode<T> belowNode = currentNodeDown.Below; //scan down
+          currentNodeDown.Dispose(); //unlink previous
+
+          currentNodeDown = belowNode;
+        }
+
+        //update counter
+        this.size--;
+
+        //Clean up the Skip List by removing levels that are now empty
+        this.clearEmptyLevels();
+
+        return true;
+      }
+    }
+
+    /// <summary>
+    /// Removes all values in the Skip List
+    /// </summary>
+    public virtual void Clear() {
+      SkipListNode<T> currentNode = this.Head;
+
+      while (currentNode != null) {
+        SkipListNode<T> nextNode = currentNode.Next; //save reference to next node
+
+        if (!currentNode.IsHeader() && !currentNode.IsFooter()) {
+          this.Remove(currentNode);
+        }
+
+        currentNode = nextNode;
+      }
+    }
+
+    /// <summary>
+    /// Copies the values of the Skip List to an array
+    /// </summary>
+    public virtual void CopyTo(T[] array) {
+      CopyTo(array, 0);
+    }
+
+    /// <summary>
+    /// Copies the values of the Skip List to an array
+    /// </summary>
+    public virtual void CopyTo(T[] array, int startIndex) {
+      IEnumerator<T> enumerator = this.GetEnumerator();
+
+      for (int i = startIndex; i < array.Length; i++) {
+        if (enumerator.MoveNext())
+          array[i] = enumerator.Current;
+        else
+          break;
+      }
+    }
+
+    /// <summary>
+    /// Gets the number of levels of a value in the Skip List
+    /// </summary>
+    public virtual int GetHeight(T value) {
+      SkipListNode<T> valueNode = this.FindLowest(value);
+      return this.GetHeight(valueNode);
+    }
+
+    /// <summary>
+    /// Gets the number of levels of a value in the Skip List
+    /// </summary>
+    public virtual int GetHeight(SkipListNode<T> valueNode) {
+      int height = 0;
+      SkipListNode<T> currentNode = valueNode;
+
+      //Move all the way down to the bottom first
+      while (currentNode.Below != null) {
+        currentNode = currentNode.Below;
+      }
+
+      //Count going back up to the top
+      while (currentNode != null) {
+        height++;
+        currentNode = currentNode.Above;
+      }
+
+      return height;
+    }
+
+    /// <summary>
+    /// Gets the enumerator for the Skip List
+    /// </summary>
+    public IEnumerator<T> GetEnumerator() {
+      return new SkipListEnumerator(this);
+    }
+
+    /// <summary>
+    /// Gets the enumerator for the Skip List
+    /// </summary>
+    IEnumerator IEnumerable.GetEnumerator() {
+      return this.GetEnumerator();
+    }
+
+    /// <summary>
+    /// Enumerator for a Skip List. Scans across the lowest level of a Skip List.
+    /// </summary>
+    internal class SkipListEnumerator : IEnumerator<T> {
+      private SkipListNode<T> current;
+      private SkipList<T> skipList;
+
+      public SkipListEnumerator(SkipList<T> skipList) {
+        this.skipList = skipList;
+      }
+
+      public T Current
+      {
+        get { return current.Value; }
+      }
+
+      object IEnumerator.Current
+      {
+        get { return this.Current; }
+      }
+
+      public void Dispose() {
+        current = null;
+      }
+
+      public void Reset() {
+        current = null;
+      }
+
+      public bool MoveNext() {
+        if (current == null)
+          current = this.skipList.Head.Next; //Head is header node, start after
+        else
+          current = current.Next;
+
+        if (current != null && current.IsFooter())
+          current = null; //end of list
+
+        return (current != null);
+      }
+    }
+  }
+}
Index: branches/PushGP/HeuristicLab.PushGP/HeuristicLab.Problems.ProgramSynthesis/Push/Data/Pool/ManagedPool.cs
===================================================================
--- branches/PushGP/HeuristicLab.PushGP/HeuristicLab.Problems.ProgramSynthesis/Push/Data/Pool/ManagedPool.cs	(revision 14744)
+++ branches/PushGP/HeuristicLab.PushGP/HeuristicLab.Problems.ProgramSynthesis/Push/Data/Pool/ManagedPool.cs	(revision 14744)
@@ -0,0 +1,53 @@
+﻿using System.Collections.Generic;
+
+namespace HeuristicLab.Problems.ProgramSynthesis.Push.Data.Pool {
+  using System;
+  using System.Collections.Concurrent;
+  using System.Linq;
+
+  public class ManagedPool<T> : IDisposable where T : class {
+
+    private static readonly ConcurrentStack<LinkedList<T>> Pool = new ConcurrentStack<LinkedList<T>>();
+    private readonly Func<T> Factory;
+    public readonly int PartitionSize;
+
+    private readonly IList<LinkedList<T>> partitions = new List<LinkedList<T>>();
+    private LinkedList<T> currentPartition;
+    private LinkedListNode<T> currentNode;
+
+    public ManagedPool(int partitionSize, Func<T> factory) {
+      PartitionSize = partitionSize;
+      Factory = factory;
+    }
+
+    public T Get() {
+      if (currentPartition == null || currentPartition.Count == PartitionSize) {
+        currentPartition = GetPartition();
+        currentNode = currentPartition.First;
+
+        partitions.Add(currentPartition);
+      }
+
+      T entry = null;
+      if (currentNode == null) {
+        entry = Factory();
+        currentPartition.AddLast(entry);
+      } else {
+        entry = currentNode.Value;
+        currentNode = currentNode.Next;
+      }
+
+      return entry;
+    }
+
+    private LinkedList<T> GetPartition() {
+      LinkedList<T> partition;
+
+      return Pool.TryPop(out partition) ? partition : new LinkedList<T>();
+    }
+
+    public void Dispose() {
+      Pool.PushRange(partitions.ToArray());
+    }
+  }
+}
Index: branches/PushGP/HeuristicLab.PushGP/HeuristicLab.Problems.ProgramSynthesis/Push/Data/Pool/PoolContainer.cs
===================================================================
--- branches/PushGP/HeuristicLab.PushGP/HeuristicLab.Problems.ProgramSynthesis/Push/Data/Pool/PoolContainer.cs	(revision 14744)
+++ branches/PushGP/HeuristicLab.PushGP/HeuristicLab.Problems.ProgramSynthesis/Push/Data/Pool/PoolContainer.cs	(revision 14744)
@@ -0,0 +1,9 @@
+﻿//namespace HeuristicLab.Problems.ProgramSynthesis.Push.Data.Pool {
+//  using System.Threading;
+
+//  using HeuristicLab.Problems.ProgramSynthesis.Push.Expressions;
+
+//  internal static class PoolContainer {
+//    public static readonly ThreadLocal<ManagedPool<PushProgram>> PushProgramPool = new ThreadLocal<ManagedPool<PushProgram>>(() => new ManagedPool<PushProgram>(256, () => new PushProgram()));
+//  }
+//}
Index: branches/PushGP/HeuristicLab.PushGP/HeuristicLab.Problems.ProgramSynthesis/Push/Expressions/BooleanExpressions.cs
===================================================================
--- branches/PushGP/HeuristicLab.PushGP/HeuristicLab.Problems.ProgramSynthesis/Push/Expressions/BooleanExpressions.cs	(revision 14733)
+++ branches/PushGP/HeuristicLab.PushGP/HeuristicLab.Problems.ProgramSynthesis/Push/Expressions/BooleanExpressions.cs	(revision 14744)
@@ -9,6 +9,6 @@
   [PushExpression(StackType.Boolean, "BOOLEAN.AND")]
   public class BooleanAndExpression : PushResultExpression<bool> {
-    public override void Eval(IPushInterpreter interpreter) {
-      this.Eval(interpreter.BooleanStack, 2, values => values[0] && values[1]);
+    public override bool Eval(IPushInterpreter interpreter) {
+      return Eval(interpreter.BooleanStack, 2, values => values[0] && values[1]);
     }
   }
@@ -19,6 +19,6 @@
   [PushExpression(StackType.Boolean, "BOOLEAN.OR")]
   public class BooleanOrExpression : PushResultExpression<bool> {
-    public override void Eval(IPushInterpreter interpreter) {
-      this.Eval(interpreter.BooleanStack, 2, values => values[0] || values[1]);
+    public override bool Eval(IPushInterpreter interpreter) {
+      return Eval(interpreter.BooleanStack, 2, values => values[0] || values[1]);
     }
   }
@@ -29,6 +29,6 @@
   [PushExpression(StackType.Boolean, "BOOLEAN.NOT")]
   public class BooleanNotExpression : PushResultExpression<bool> {
-    public override void Eval(IPushInterpreter interpreter) {
-      this.Eval(interpreter.BooleanStack, 1, values => !values[0]);
+    public override bool Eval(IPushInterpreter interpreter) {
+      return Eval(interpreter.BooleanStack, 1, values => !values[0]);
     }
   }
@@ -39,10 +39,11 @@
   [PushExpression(StackType.Boolean, "BOOLEAN.FROMFLOAT")]
   public class BooleanFromFloatExpression : StatelessExpression {
-    public override void Eval(IPushInterpreter interpreter) {
-      if (interpreter.FloatStack.Count == 0) return;
+    public override bool Eval(IPushInterpreter interpreter) {
+      if (interpreter.FloatStack.Count == 0) return false;
 
       var value = interpreter.FloatStack.Pop() != 0.0;
 
       interpreter.BooleanStack.Push(value);
+      return true;
     }
   }
@@ -53,10 +54,11 @@
   [PushExpression(StackType.Boolean, "BOOLEAN.FROMINTEGER")]
   public class BooleanFromIntegerExpression : StatelessExpression {
-    public override void Eval(IPushInterpreter interpreter) {
-      if (interpreter.IntegerStack.Count == 0) return;
+    public override bool Eval(IPushInterpreter interpreter) {
+      if (interpreter.IntegerStack.Count == 0) return false;
 
       var value = interpreter.IntegerStack.Pop() != 0;
 
       interpreter.BooleanStack.Push(value);
+      return true;
     }
   }
Index: branches/PushGP/HeuristicLab.PushGP/HeuristicLab.Problems.ProgramSynthesis/Push/Expressions/CodeExpressions.cs
===================================================================
--- branches/PushGP/HeuristicLab.PushGP/HeuristicLab.Problems.ProgramSynthesis/Push/Expressions/CodeExpressions.cs	(revision 14733)
+++ branches/PushGP/HeuristicLab.PushGP/HeuristicLab.Problems.ProgramSynthesis/Push/Expressions/CodeExpressions.cs	(revision 14744)
@@ -22,10 +22,12 @@
   [PushExpression(StackType.Code, "CODE.DO")]
   public class CodeDoExpression : StatelessExpression {
-    public override void Eval(IPushInterpreter interpreter) {
+    public override bool Eval(IPushInterpreter interpreter) {
       // not enough arguments on stack
-      if (interpreter.CodeStack.Count == 0) return;
+      if (interpreter.CodeStack.Count == 0) return false;
 
       var codePopExpression = ExpressionTable.GetStatelessExpression<CodePopExpression>();
       interpreter.ExecStack.Push(codePopExpression, interpreter.CodeStack.Top);
+
+      return true;
     }
   }
@@ -36,10 +38,12 @@
   [PushExpression(StackType.Code, "CODE.DO*")]
   public class CodeDoXExpression : StatelessExpression {
-    public override void Eval(IPushInterpreter interpreter) {
+    public override bool Eval(IPushInterpreter interpreter) {
       // not enough arguments on stack
-      if (interpreter.CodeStack.Count == 0) return;
+      if (interpreter.CodeStack.Count == 0) return false;
 
       var expression = interpreter.CodeStack.Pop();
       interpreter.ExecStack.Push(expression);
+
+      return true;
     }
   }
@@ -50,6 +54,6 @@
   [PushExpression(StackType.Code, "CODE.NOOP")]
   public class CodeNoopExpression : StatelessExpression {
-    public override void Eval(IPushInterpreter interpreter) {
-      // nothing to do
+    public override bool Eval(IPushInterpreter interpreter) {
+      return false;
     }
   }
@@ -61,10 +65,12 @@
   [PushExpression(StackType.Code, "CODE.QUOTE")]
   public class CodeQuoteExpression : StatelessExpression {
-    public override void Eval(IPushInterpreter interpreter) {
+    public override bool Eval(IPushInterpreter interpreter) {
       // not enough arguments on stack
-      if (interpreter.ExecStack.Count == 0) return;
+      if (interpreter.ExecStack.Count == 0) return false;
 
       var expression = interpreter.ExecStack.Pop();
       interpreter.CodeStack.Push(expression);
+
+      return true;
     }
   }
@@ -77,7 +83,7 @@
   [PushExpression(StackType.Code, "CODE.IF")]
   public class CodeIfExpression : StatelessExpression {
-    public override void Eval(IPushInterpreter interpreter) {
+    public override bool Eval(IPushInterpreter interpreter) {
       // not enough arguments on stack
-      if ((interpreter.BooleanStack.Count == 0) || (interpreter.CodeStack.Count < 2)) return;
+      if ((interpreter.BooleanStack.Count == 0) || (interpreter.CodeStack.Count < 2)) return false;
 
       var condition = interpreter.BooleanStack.Pop();
@@ -85,4 +91,6 @@
 
       interpreter.ExecStack.Push(condition ? items[0] : items[1]);
+
+      return true;
     }
   }
@@ -94,6 +102,6 @@
   [PushExpression(StackType.Code, "CODE.APPEND")]
   public class CodeAppendExpression : StatelessExpression {
-    public override void Eval(IPushInterpreter interpreter) {
-      if (interpreter.CodeStack.Count < 2) return;
+    public override bool Eval(IPushInterpreter interpreter) {
+      if (interpreter.CodeStack.Count < 2) return false;
 
       var first = interpreter.CodeStack.Pop();
@@ -113,5 +121,5 @@
 
           // if size > maxPointsInProgram this expressions results in a NOOP
-          if (size > interpreter.Configuration.MaxPointsInProgram) return;
+          if (size > interpreter.Configuration.MaxPointsInProgram) return false;
 
           result = new Expression[size];
@@ -128,5 +136,5 @@
 
           // if size > maxPointsInProgram this expressions results in a NOOP
-          if (size > interpreter.Configuration.MaxPointsInProgram) return;
+          if (size > interpreter.Configuration.MaxPointsInProgram) return false;
 
           result = new Expression[size];
@@ -141,5 +149,5 @@
 
         // if size > maxPointsInProgram this expressions results in a NOOP
-        if (size > interpreter.Configuration.MaxPointsInProgram) return;
+        if (size > interpreter.Configuration.MaxPointsInProgram) return false;
 
         result = new Expression[size];
@@ -154,4 +162,6 @@
 
       interpreter.CodeStack.SetTop(expression);
+
+      return true;
     }
   }
@@ -163,6 +173,6 @@
   [PushExpression(StackType.Code, "CODE.ATOM")]
   public class CodeAtomExpression : StatelessExpression {
-    public override void Eval(IPushInterpreter interpreter) {
-      if (interpreter.CodeStack.Count == 0) return;
+    public override bool Eval(IPushInterpreter interpreter) {
+      if (interpreter.CodeStack.Count == 0) return false;
 
       var expression = interpreter.CodeStack.Pop();
@@ -170,4 +180,5 @@
 
       interpreter.BooleanStack.Push(!isExpandExpression);
+      return true;
     }
   }
@@ -181,14 +192,15 @@
   [PushExpression(StackType.Code, "CODE.CAR")]
   public class CodeCarExpression : StatelessExpression {
-    public override void Eval(IPushInterpreter interpreter) {
-      if ((interpreter.CodeStack.Count == 0) || (interpreter.CodeStack.Top.GetType() !=
-                                                 typeof(ExecExpandExpression))) return;
+    public override bool Eval(IPushInterpreter interpreter) {
+      if ((interpreter.CodeStack.Count == 0) ||
+          (interpreter.CodeStack.Top.GetType() != typeof(ExecExpandExpression))) return false;
 
       var expand = interpreter.CodeStack.Top as ExecExpandExpression;
 
-      if (expand.State.IsEmpty) return;
+      if (expand.State.IsEmpty) return false;
       var first = expand.State.Expressions[expand.State.Expressions.Count - 1];
 
       interpreter.CodeStack.SetTop(first);
+      return true;
     }
   }
@@ -202,8 +214,8 @@
   [PushExpression(StackType.Code, "CODE.CDR")]
   public class CodeCdrExpression : StatelessExpression {
-    public override void Eval(IPushInterpreter interpreter) {
-      if (interpreter.CodeStack.Count == 0) return;
-
-      Expression expandExpression = null;
+    public override bool Eval(IPushInterpreter interpreter) {
+      if (interpreter.CodeStack.Count == 0) return false;
+
+      ExecExpandExpression expandExpression;
       var top = interpreter.CodeStack.Top;
 
@@ -211,5 +223,5 @@
         var expand = (ExecExpandExpression)top;
 
-        if (expand.State.IsEmpty) return;
+        if (expand.State.IsEmpty) return false;
         var length = expand.State.Expressions.Count - 1;
         var newExpressions = new Expression[length];
@@ -223,4 +235,5 @@
 
       interpreter.CodeStack.SetTop(expandExpression);
+      return true;
     }
   }
@@ -233,7 +246,7 @@
   [PushExpression(StackType.Code, "CODE.CONS")]
   public class CodeConsExpression : StatelessExpression {
-    public override void Eval(IPushInterpreter interpreter) {
+    public override bool Eval(IPushInterpreter interpreter) {
       if (interpreter.CodeStack.Count < 2)
-        return;
+        return false;
 
       ExecExpandExpression result;
@@ -243,5 +256,5 @@
         var size = first.State.Expressions.Count + 1;
 
-        if (size > interpreter.Configuration.MaxPointsInProgram) return;
+        if (size > interpreter.Configuration.MaxPointsInProgram) return false;
 
         var expressions = new Expression[size];
@@ -256,4 +269,5 @@
 
       interpreter.CodeStack.SetTop(result);
+      return true;
     }
   }
@@ -269,8 +283,8 @@
   [PushExpression(StackType.Code, "CODE.CONTAINER")]
   public class CodeContainerExpression : StatelessExpression {
-    public override void Eval(IPushInterpreter interpreter) {
+    public override bool Eval(IPushInterpreter interpreter) {
       if ((interpreter.CodeStack.Count < 2) ||
           (interpreter.CodeStack[interpreter.CodeStack.Count - 2].GetType() !=
-           typeof(ExecExpandExpression))) return;
+           typeof(ExecExpandExpression))) return false;
 
       var target = interpreter.CodeStack.Pop();
@@ -281,4 +295,5 @@
 
       interpreter.CodeStack.SetTop(result);
+      return true;
     }
 
@@ -307,8 +322,8 @@
   [PushExpression(StackType.Code, "CODE.CONTAINS")]
   public class CodeContainsExpression : StatelessExpression {
-    public override void Eval(IPushInterpreter interpreter) {
+    public override bool Eval(IPushInterpreter interpreter) {
       if (interpreter.CodeStack.Count < 2 ||
          !interpreter.CodeStack[interpreter.CodeStack.Count - 2].CanExpand)
-        return;
+        return false;
 
       var values = interpreter.CodeStack.Pop(2);
@@ -317,4 +332,6 @@
 
       interpreter.BooleanStack.Push(contains);
+
+      return true;
     }
   }
@@ -327,7 +344,7 @@
   [PushExpression(StackType.Code, "CODE.DEFINITION")]
   public class CodeDefinitionExpression : StatelessExpression {
-    public override void Eval(IPushInterpreter interpreter) {
+    public override bool Eval(IPushInterpreter interpreter) {
       if ((interpreter.NameStack.Count == 0) ||
-          !interpreter.CustomExpressions.ContainsKey(interpreter.NameStack.Top)) return;
+          !interpreter.CustomExpressions.ContainsKey(interpreter.NameStack.Top)) return false;
 
       var name = interpreter.NameStack.Pop();
@@ -335,4 +352,6 @@
 
       interpreter.CodeStack.Push(definition);
+
+      return true;
     }
   }
@@ -363,6 +382,6 @@
   [PushExpression(StackType.Code, "CODE.DISCREPANCY")]
   public class CodeDiscrepancyExpression : StatelessExpression {
-    public override void Eval(IPushInterpreter interpreter) {
-      if (interpreter.CodeStack.Count < 2) return;
+    public override bool Eval(IPushInterpreter interpreter) {
+      if (interpreter.CodeStack.Count < 2) return false;
 
       var expressions = interpreter.CodeStack.Pop(2);
@@ -376,4 +395,6 @@
 
       interpreter.IntegerStack.Push(discrepancy);
+
+      return true;
     }
 
@@ -418,9 +439,9 @@
   [PushExpression(StackType.Code, "CODE.EXTRACT")]
   public class CodeExtractExpression : StatelessExpression {
-    public override void Eval(IPushInterpreter interpreter) {
+    public override bool Eval(IPushInterpreter interpreter) {
       if (interpreter.IntegerStack.Count == 0 ||
           interpreter.CodeStack.Count == 0 ||
           !interpreter.CodeStack.Top.CanExpand)
-        return;
+        return false;
 
       var expression = (ExecExpandExpression)interpreter.CodeStack.Top;
@@ -429,4 +450,6 @@
 
       interpreter.CodeStack.SetTop(result);
+
+      return true;
     }
   }
@@ -437,6 +460,6 @@
   [PushExpression(StackType.Code, "CODE.FROMBOOLEAN")]
   public class CodeFromBooleanExpression : StatelessExpression {
-    public override void Eval(IPushInterpreter interpreter) {
-      if (interpreter.BooleanStack.Count == 0) return;
+    public override bool Eval(IPushInterpreter interpreter) {
+      if (interpreter.BooleanStack.Count == 0) return false;
 
       var value = interpreter.BooleanStack.Pop();
@@ -444,4 +467,6 @@
 
       interpreter.CodeStack.Push(expression);
+
+      return true;
     }
   }
@@ -452,6 +477,6 @@
   [PushExpression(StackType.Code, "CODE.FROMFLOAT")]
   public class CodeFromFloatExpression : StatelessExpression {
-    public override void Eval(IPushInterpreter interpreter) {
-      if (interpreter.FloatStack.Count == 0) return;
+    public override bool Eval(IPushInterpreter interpreter) {
+      if (interpreter.FloatStack.Count == 0) return false;
 
       var value = interpreter.FloatStack.Pop();
@@ -459,4 +484,6 @@
 
       interpreter.CodeStack.Push(expression);
+
+      return true;
     }
   }
@@ -467,6 +494,6 @@
   [PushExpression(StackType.Code, "CODE.FROMINTEGER")]
   public class CodeFromIntegerExpression : StatelessExpression {
-    public override void Eval(IPushInterpreter interpreter) {
-      if (interpreter.IntegerStack.Count == 0) return;
+    public override bool Eval(IPushInterpreter interpreter) {
+      if (interpreter.IntegerStack.Count == 0) return false;
 
       var value = interpreter.IntegerStack.Pop();
@@ -474,4 +501,6 @@
 
       interpreter.CodeStack.Push(expression);
+
+      return true;
     }
   }
@@ -482,6 +511,6 @@
   [PushExpression(StackType.Code, "CODE.FROMNAME")]
   public class CodeFromNameExpression : StatelessExpression {
-    public override void Eval(IPushInterpreter interpreter) {
-      if (interpreter.NameStack.Count == 0) return;
+    public override bool Eval(IPushInterpreter interpreter) {
+      if (interpreter.NameStack.Count == 0) return false;
 
       var value = interpreter.NameStack.Pop();
@@ -489,4 +518,6 @@
 
       interpreter.CodeStack.Push(expression);
+
+      return true;
     }
   }
@@ -498,9 +529,9 @@
   [PushExpression(StackType.Code, "CODE.CODEINSERT")]
   public class CodeInsertExpression : StatelessExpression {
-    public override void Eval(IPushInterpreter interpreter) {
+    public override bool Eval(IPushInterpreter interpreter) {
       if (interpreter.IntegerStack.Count == 0 ||
           interpreter.CodeStack.Count < 2 ||
           !interpreter.CodeStack.Top.CanExpand)
-        return;
+        return false;
 
       var source = interpreter.CodeStack[interpreter.CodeStack.Count - 2];
@@ -522,4 +553,6 @@
       var result = new ExecExpandExpression(newExpressions);
       interpreter.CodeStack.SetTop(result);
+
+      return true;
     }
   }
@@ -533,6 +566,6 @@
   [PushExpression(StackType.Code, "CODE.LENGTH")]
   public class CodeLengthExpression : StatelessExpression {
-    public override void Eval(IPushInterpreter interpreter) {
-      if (interpreter.CodeStack.Count == 0) return;
+    public override bool Eval(IPushInterpreter interpreter) {
+      if (interpreter.CodeStack.Count == 0) return false;
 
       var expression = interpreter.CodeStack.Pop();
@@ -543,4 +576,6 @@
 
       interpreter.IntegerStack.Push(count);
+
+      return true;
     }
   }
@@ -551,6 +586,6 @@
   [PushExpression(StackType.Code, "CODE.LIST")]
   public class CodeListExpression : StatelessExpression {
-    public override void Eval(IPushInterpreter interpreter) {
-      if (interpreter.CodeStack.Count < 2) return;
+    public override bool Eval(IPushInterpreter interpreter) {
+      if (interpreter.CodeStack.Count < 2) return false;
 
       var first = interpreter.CodeStack.Pop();
@@ -559,4 +594,6 @@
 
       interpreter.CodeStack.SetTop(expandExpression);
+
+      return true;
     }
   }
@@ -568,6 +605,6 @@
   [PushExpression(StackType.Code, "CODE.MEMBER")]
   public class CodeMemberExpression : StatelessExpression {
-    public override void Eval(IPushInterpreter interpreter) {
-      if (interpreter.CodeStack.Count < 2) return;
+    public override bool Eval(IPushInterpreter interpreter) {
+      if (interpreter.CodeStack.Count < 2) return false;
 
       var expressions = interpreter.CodeStack.Pop(2);
@@ -578,4 +615,6 @@
 
       interpreter.BooleanStack.Push(contains);
+
+      return true;
     }
   }
@@ -588,11 +627,11 @@
   [PushExpression(StackType.Code, "CODE.NTH")]
   public class CodeNthExpression : StatelessExpression {
-    public override void Eval(IPushInterpreter interpreter) {
-      if ((interpreter.CodeStack.Count == 0) || (interpreter.IntegerStack.Count == 0)) return;
+    public override bool Eval(IPushInterpreter interpreter) {
+      if ((interpreter.CodeStack.Count == 0) || (interpreter.IntegerStack.Count == 0)) return false;
 
       var n = interpreter.IntegerStack.Pop();
       var expression = interpreter.CodeStack.Top;
 
-      Expression nthExpression = null;
+      Expression nthExpression;
 
       if (expression.CanExpand) {
@@ -612,4 +651,6 @@
 
       interpreter.CodeStack.SetTop(nthExpression);
+
+      return true;
     }
   }
@@ -625,6 +666,6 @@
   [PushExpression(StackType.Code, "CODE.NTHCDR")]
   public class CodeNthCdrExpression : StatelessExpression {
-    public override void Eval(IPushInterpreter interpreter) {
-      if ((interpreter.CodeStack.Count == 0) || (interpreter.IntegerStack.Count == 0)) return;
+    public override bool Eval(IPushInterpreter interpreter) {
+      if ((interpreter.CodeStack.Count == 0) || (interpreter.IntegerStack.Count == 0)) return false;
 
       var n = interpreter.IntegerStack.Pop();
@@ -648,4 +689,6 @@
 
       interpreter.CodeStack.SetTop(nthExpression);
+
+      return true;
     }
   }
@@ -656,10 +699,11 @@
   [PushExpression(StackType.Code, "CODE.NULL")]
   public class CodeNullExpression : StatelessExpression {
-    public override void Eval(IPushInterpreter interpreter) {
-      if (interpreter.CodeStack.Count == 0) return;
+    public override bool Eval(IPushInterpreter interpreter) {
+      if (interpreter.CodeStack.Count == 0) return false;
 
       var result = interpreter.CodeStack.Pop().Equals(ExecExpandExpression.Empty);
-
       interpreter.BooleanStack.Push(result);
+
+      return true;
     }
   }
@@ -671,6 +715,6 @@
   [PushExpression(StackType.Code, "CODE.POSITION")]
   public class CodePositionExpression : StatelessExpression {
-    public override void Eval(IPushInterpreter interpreter) {
-      if (interpreter.CodeStack.Count < 2) return;
+    public override bool Eval(IPushInterpreter interpreter) {
+      if (interpreter.CodeStack.Count < 2) return false;
 
       var expressions = interpreter.CodeStack.Pop(2);
@@ -688,4 +732,6 @@
 
       interpreter.IntegerStack.Push(position);
+
+      return true;
     }
   }
@@ -697,6 +743,6 @@
   [PushExpression(StackType.Code, "CODE.SIZE")]
   public class CodeSizeExpression : StatelessExpression {
-    public override void Eval(IPushInterpreter interpreter) {
-      if (interpreter.CodeStack.Count == 0) return;
+    public override bool Eval(IPushInterpreter interpreter) {
+      if (interpreter.CodeStack.Count == 0) return false;
 
       var expression = interpreter.CodeStack.Pop();
@@ -706,4 +752,6 @@
 
       interpreter.IntegerStack.Push(points);
+
+      return true;
     }
   }
@@ -717,7 +765,7 @@
   [PushExpression(StackType.Code, "CODE.SUBST")]
   public class CodeSubstitutionExpression : StatelessExpression {
-    public override void Eval(IPushInterpreter interpreter) {
+    public override bool Eval(IPushInterpreter interpreter) {
       if ((interpreter.CodeStack.Count < 3) || (interpreter.CodeStack.Top.GetType() !=
-                                                typeof(ExecExpandExpression))) return;
+                                                typeof(ExecExpandExpression))) return false;
 
       var expressions = interpreter.CodeStack.Pop(2);
@@ -736,4 +784,6 @@
 
       interpreter.CodeStack.SetTop(result);
+
+      return true;
     }
   }
Index: branches/PushGP/HeuristicLab.PushGP/HeuristicLab.Problems.ProgramSynthesis/Push/Expressions/DefineExpressions.cs
===================================================================
--- branches/PushGP/HeuristicLab.PushGP/HeuristicLab.Problems.ProgramSynthesis/Push/Expressions/DefineExpressions.cs	(revision 14733)
+++ branches/PushGP/HeuristicLab.PushGP/HeuristicLab.Problems.ProgramSynthesis/Push/Expressions/DefineExpressions.cs	(revision 14744)
@@ -3,7 +3,7 @@
   using System.Collections.Generic;
 
-  using HeuristicLab.Problems.ProgramSynthesis.Push.Attributes;
-  using HeuristicLab.Problems.ProgramSynthesis.Push.Interpreter;
-  using HeuristicLab.Problems.ProgramSynthesis.Push.Stack;
+  using Attributes;
+  using Interpreter;
+  using Stack;
 
   /// <summary>
@@ -13,5 +13,5 @@
   /// <typeparam name="T">Stacktype</typeparam>
   public abstract class DefineExpression<T> : StatelessExpression {
-    protected void Eval(
+    protected bool Eval(
       IStack<T> stack,
       IStack<string> nameStack,
@@ -19,5 +19,5 @@
       Func<T, Expression> creator) {
       // not enough arguments on stack
-      if ((nameStack.Count == 0) || (stack.Count < 1)) return;
+      if ((nameStack.Count == 0) || (stack.Count < 1)) return false;
 
       var name = nameStack.Pop();
@@ -26,4 +26,6 @@
       if (customExpressions.ContainsKey(name)) customExpressions[name] = expression;
       else customExpressions.Add(name, expression);
+
+      return true;
     }
   }
@@ -31,6 +33,6 @@
   [PushExpression(StackType.Code, "CODE.DEFINE")]
   public class CodeDefineExpression : DefineExpression<Expression> {
-    public override void Eval(IPushInterpreter interpreter) {
-      if (interpreter.Configuration.TopLevelPushCode && (interpreter.CodeStack.Count < 2)) return;
+    public override bool Eval(IPushInterpreter interpreter) {
+      if (interpreter.Configuration.TopLevelPushCode && (interpreter.CodeStack.Count < 2)) return false;
 
       this.Eval(
@@ -41,4 +43,6 @@
 
       interpreter.CodeStack.Pop();
+
+      return true;
     }
   }
@@ -46,8 +50,8 @@
   [PushExpression(StackType.Exec, "EXEC.DEFINE")]
   public class ExecDefineExpression : DefineExpression<Expression> {
-    public override void Eval(IPushInterpreter interpreter) {
-      if (interpreter.ExecStack.Count < 2) return;
+    public override bool Eval(IPushInterpreter interpreter) {
+      if (interpreter.ExecStack.Count < 2) return false;
 
-      this.Eval(
+      var noop = this.Eval(
         interpreter.ExecStack,
         interpreter.NameStack,
@@ -55,5 +59,8 @@
         v => new ExecPushExpression(v));
 
-      interpreter.ExecStack.Pop();
+      if (!noop)
+        interpreter.ExecStack.Pop();
+
+      return noop;
     }
   }
@@ -62,6 +69,6 @@
   public class FloatDefineExpression : DefineExpression<double> {
 
-    public override void Eval(IPushInterpreter interpreter) {
-      this.Eval(
+    public override bool Eval(IPushInterpreter interpreter) {
+      return this.Eval(
         interpreter.FloatStack,
         interpreter.NameStack,
@@ -73,6 +80,6 @@
   [PushExpression(StackType.Integer, "INTEGER.DEFINE")]
   public class IntegerDefineExpression : DefineExpression<long> {
-    public override void Eval(IPushInterpreter interpreter) {
-      this.Eval(
+    public override bool Eval(IPushInterpreter interpreter) {
+      return this.Eval(
         interpreter.IntegerStack,
         interpreter.NameStack,
@@ -84,6 +91,6 @@
   [PushExpression(StackType.Boolean, "BOOLEAN.DEFINE")]
   public class BooleanDefineExpression : DefineExpression<bool> {
-    public override void Eval(IPushInterpreter interpreter) {
-      this.Eval(
+    public override bool Eval(IPushInterpreter interpreter) {
+      return this.Eval(
         interpreter.BooleanStack,
         interpreter.NameStack,
Index: branches/PushGP/HeuristicLab.PushGP/HeuristicLab.Problems.ProgramSynthesis/Push/Expressions/DoCountExpressions.cs
===================================================================
--- branches/PushGP/HeuristicLab.PushGP/HeuristicLab.Problems.ProgramSynthesis/Push/Expressions/DoCountExpressions.cs	(revision 14733)
+++ branches/PushGP/HeuristicLab.PushGP/HeuristicLab.Problems.ProgramSynthesis/Push/Expressions/DoCountExpressions.cs	(revision 14744)
@@ -47,6 +47,6 @@
     public CodeDoCountExpression(LoopState state) : base(state) { }
 
-    public override void Eval(IPushInterpreter interpreter) {
-      this.Eval(interpreter, interpreter.CodeStack);
+    public override bool Eval(IPushInterpreter interpreter) {
+      return this.Eval(interpreter, interpreter.CodeStack);
     }
 
@@ -75,6 +75,6 @@
     public ExecDoCountExpression(LoopState state) : base(state) { }
 
-    public override void Eval(IPushInterpreter interpreter) {
-      this.Eval(interpreter, interpreter.ExecStack);
+    public override bool Eval(IPushInterpreter interpreter) {
+      return this.Eval(interpreter, interpreter.ExecStack);
     }
 
Index: branches/PushGP/HeuristicLab.PushGP/HeuristicLab.Problems.ProgramSynthesis/Push/Expressions/DoRangeExpressions.cs
===================================================================
--- branches/PushGP/HeuristicLab.PushGP/HeuristicLab.Problems.ProgramSynthesis/Push/Expressions/DoRangeExpressions.cs	(revision 14733)
+++ branches/PushGP/HeuristicLab.PushGP/HeuristicLab.Problems.ProgramSynthesis/Push/Expressions/DoRangeExpressions.cs	(revision 14744)
@@ -52,6 +52,6 @@
 
     public CodeDoRangeExpression(LoopState state) : base(state) { }
-    public override void Eval(IPushInterpreter interpreter) {
-      this.Eval(interpreter, interpreter.CodeStack);
+    public override bool Eval(IPushInterpreter interpreter) {
+      return this.Eval(interpreter, interpreter.CodeStack);
     }
 
@@ -90,6 +90,6 @@
 
     public ExecDoRangeExpression(LoopState state) : base(state) { }
-    public override void Eval(IPushInterpreter interpreter) {
-      this.Eval(interpreter, interpreter.ExecStack);
+    public override bool Eval(IPushInterpreter interpreter) {
+      return this.Eval(interpreter, interpreter.ExecStack);
     }
     protected override LoopExpression Clone(LoopState state) {
Index: branches/PushGP/HeuristicLab.PushGP/HeuristicLab.Problems.ProgramSynthesis/Push/Expressions/DoTimesExpressions.cs
===================================================================
--- branches/PushGP/HeuristicLab.PushGP/HeuristicLab.Problems.ProgramSynthesis/Push/Expressions/DoTimesExpressions.cs	(revision 14733)
+++ branches/PushGP/HeuristicLab.PushGP/HeuristicLab.Problems.ProgramSynthesis/Push/Expressions/DoTimesExpressions.cs	(revision 14744)
@@ -12,9 +12,4 @@
 
     protected override LoopState InitState(IPushInterpreter interpreter, IStack<Expression> sourceStack) {
-      //this.State.Body = sourceStack.Pop();
-      //this.State.DestinationIndex = interpreter.IntegerStack.Pop();
-      //this.State.CurrentIndex = 1;
-      //this.State.Incrementor = 1;
-
       return new LoopState(
         body: sourceStack.Pop(),
@@ -47,6 +42,6 @@
     public CodeDoTimesExpression(LoopState state) : base(state) { }
 
-    public override void Eval(IPushInterpreter interpreter) {
-      this.Eval(interpreter, interpreter.CodeStack);
+    public override bool Eval(IPushInterpreter interpreter) {
+      return this.Eval(interpreter, interpreter.CodeStack);
     }
 
@@ -70,6 +65,6 @@
     public ExecDoTimesExpression(LoopState state) : base(state) { }
 
-    public override void Eval(IPushInterpreter interpreter) {
-      this.Eval(interpreter, interpreter.ExecStack);
+    public override bool Eval(IPushInterpreter interpreter) {
+      return this.Eval(interpreter, interpreter.ExecStack);
     }
 
Index: branches/PushGP/HeuristicLab.PushGP/HeuristicLab.Problems.ProgramSynthesis/Push/Expressions/DuplicateExpressions.cs
===================================================================
--- branches/PushGP/HeuristicLab.PushGP/HeuristicLab.Problems.ProgramSynthesis/Push/Expressions/DuplicateExpressions.cs	(revision 14733)
+++ branches/PushGP/HeuristicLab.PushGP/HeuristicLab.Problems.ProgramSynthesis/Push/Expressions/DuplicateExpressions.cs	(revision 14744)
@@ -10,16 +10,19 @@
   /// <typeparam name="T">Stacktype</typeparam>
   public abstract class DuplicateExpression<T> : StatelessExpression {
-    protected void Eval(IStack<T> stack) {
-      if (stack.Count == 0) return;
+    protected bool Eval(IStack<T> stack) {
+      if (stack.Count == 0) return false;
 
       stack.Push(stack.Top);
+
+      return true;
     }
 
-    protected void Eval(IStack<Expression> stack) {
-      if (stack.Count == 0) return;
+    protected bool Eval(IStack<Expression> stack) {
+      if (stack.Count == 0) return false;
 
       var top = stack.Top;
 
       stack.Push(top);
+      return true;
     }
   }
@@ -27,6 +30,6 @@
   [PushExpression(StackType.Integer, "INTEGER.DUP")]
   public class IntegerDuplicateExpression : DuplicateExpression<long> {
-    public override void Eval(IPushInterpreter interpreter) {
-      this.Eval(interpreter.IntegerStack);
+    public override bool Eval(IPushInterpreter interpreter) {
+      return this.Eval(interpreter.IntegerStack);
     }
   }
@@ -34,6 +37,6 @@
   [PushExpression(StackType.Float, "FLOAT.DUP")]
   public class FloatDuplicateExpression : DuplicateExpression<double> {
-    public override void Eval(IPushInterpreter interpreter) {
-      this.Eval(interpreter.FloatStack);
+    public override bool Eval(IPushInterpreter interpreter) {
+      return this.Eval(interpreter.FloatStack);
     }
   }
@@ -41,6 +44,6 @@
   [PushExpression(StackType.Boolean, "BOOLEAN.DUP")]
   public class BooleanDuplicateExpression : DuplicateExpression<bool> {
-    public override void Eval(IPushInterpreter interpreter) {
-      this.Eval(interpreter.BooleanStack);
+    public override bool Eval(IPushInterpreter interpreter) {
+      return this.Eval(interpreter.BooleanStack);
     }
   }
@@ -48,6 +51,6 @@
   [PushExpression(StackType.Name, "NAME.DUP")]
   public class NameDuplicateExpression : DuplicateExpression<string> {
-    public override void Eval(IPushInterpreter interpreter) {
-      this.Eval(interpreter.NameStack);
+    public override bool Eval(IPushInterpreter interpreter) {
+      return this.Eval(interpreter.NameStack);
     }
   }
@@ -55,6 +58,6 @@
   [PushExpression(StackType.Exec, "EXEC.DUP")]
   public class ExecDuplicateExpression : DuplicateExpression<Expression> {
-    public override void Eval(IPushInterpreter interpreter) {
-      this.Eval(interpreter.ExecStack);
+    public override bool Eval(IPushInterpreter interpreter) {
+      return this.Eval(interpreter.ExecStack);
     }
   }
@@ -62,6 +65,6 @@
   [PushExpression(StackType.Code, "CODE.DUP")]
   public class CodeDuplicateExpression : DuplicateExpression<Expression> {
-    public override void Eval(IPushInterpreter interpreter) {
-      this.Eval(interpreter.CodeStack);
+    public override bool Eval(IPushInterpreter interpreter) {
+      return this.Eval(interpreter.CodeStack);
     }
   }
Index: branches/PushGP/HeuristicLab.PushGP/HeuristicLab.Problems.ProgramSynthesis/Push/Expressions/EqualsExpressions.cs
===================================================================
--- branches/PushGP/HeuristicLab.PushGP/HeuristicLab.Problems.ProgramSynthesis/Push/Expressions/EqualsExpressions.cs	(revision 14733)
+++ branches/PushGP/HeuristicLab.PushGP/HeuristicLab.Problems.ProgramSynthesis/Push/Expressions/EqualsExpressions.cs	(revision 14744)
@@ -9,10 +9,12 @@
   /// <typeparam name="T">Stacktype</typeparam>
   public abstract class EqualsExpression<T> : StatelessExpression {
-    public void Eval(IStack<T> stack, IStack<bool> booleanStack) {
-      if (stack.Count < 2) return;
+    public bool Eval(IStack<T> stack, IStack<bool> booleanStack) {
+      if (stack.Count < 2) return false;
 
       var items = stack.Pop(2);
 
       booleanStack.Push(items[0].Equals(items[1]));
+
+      return true;
     }
   }
@@ -20,6 +22,6 @@
   [PushExpression(StackType.Integer, "INTEGER.=")]
   public class IntegerEqualsExpression : EqualsExpression<long> {
-    public override void Eval(IPushInterpreter interpreter) {
-      this.Eval(interpreter.IntegerStack, interpreter.BooleanStack);
+    public override bool Eval(IPushInterpreter interpreter) {
+      return Eval(interpreter.IntegerStack, interpreter.BooleanStack);
     }
   }
@@ -27,6 +29,6 @@
   [PushExpression(StackType.Float, "FLOAT.=")]
   public class FloatEqualsExpression : EqualsExpression<double> {
-    public override void Eval(IPushInterpreter interpreter) {
-      this.Eval(interpreter.FloatStack, interpreter.BooleanStack);
+    public override bool Eval(IPushInterpreter interpreter) {
+      return Eval(interpreter.FloatStack, interpreter.BooleanStack);
     }
   }
@@ -34,6 +36,6 @@
   [PushExpression(StackType.Boolean, "BOOLEAN.=")]
   public class BooleanEqualsExpression : EqualsExpression<bool> {
-    public override void Eval(IPushInterpreter interpreter) {
-      this.Eval(interpreter.BooleanStack, interpreter.BooleanStack);
+    public override bool Eval(IPushInterpreter interpreter) {
+      return Eval(interpreter.BooleanStack, interpreter.BooleanStack);
     }
   }
@@ -41,6 +43,6 @@
   [PushExpression(StackType.Name, "NAME.=")]
   public class NameEqualsExpression : EqualsExpression<string> {
-    public override void Eval(IPushInterpreter interpreter) {
-      this.Eval(interpreter.NameStack, interpreter.BooleanStack);
+    public override bool Eval(IPushInterpreter interpreter) {
+      return Eval(interpreter.NameStack, interpreter.BooleanStack);
     }
   }
@@ -48,6 +50,6 @@
   [PushExpression(StackType.Exec, "EXEC.=")]
   public class ExecEqualsExpression : EqualsExpression<Expression> {
-    public override void Eval(IPushInterpreter interpreter) {
-      this.Eval(interpreter.ExecStack, interpreter.BooleanStack);
+    public override bool Eval(IPushInterpreter interpreter) {
+      return Eval(interpreter.ExecStack, interpreter.BooleanStack);
     }
   }
@@ -55,6 +57,6 @@
   [PushExpression(StackType.Code, "CODE.=")]
   public class CodeEqualsExpression : EqualsExpression<Expression> {
-    public override void Eval(IPushInterpreter interpreter) {
-      this.Eval(interpreter.CodeStack, interpreter.BooleanStack);
+    public override bool Eval(IPushInterpreter interpreter) {
+      return Eval(interpreter.CodeStack, interpreter.BooleanStack);
     }
   }
Index: branches/PushGP/HeuristicLab.PushGP/HeuristicLab.Problems.ProgramSynthesis/Push/Expressions/ExecExpressions.cs
===================================================================
--- branches/PushGP/HeuristicLab.PushGP/HeuristicLab.Problems.ProgramSynthesis/Push/Expressions/ExecExpressions.cs	(revision 14733)
+++ branches/PushGP/HeuristicLab.PushGP/HeuristicLab.Problems.ProgramSynthesis/Push/Expressions/ExecExpressions.cs	(revision 14744)
@@ -10,5 +10,5 @@
 
   public class ExecExpandExpression : StatefulExpression<PushProgram> {
-    public static readonly ExecExpandExpression Empty = new ExecExpandExpression();
+    public static readonly ExecExpandExpression Empty = new ExecExpandExpression(PushProgram.Empty);
 
     public ExecExpandExpression(PushProgram program)
@@ -32,6 +32,7 @@
     }
 
-    public override void Eval(IPushInterpreter interpreter) {
+    public override bool Eval(IPushInterpreter interpreter) {
       interpreter.ExecStack.Push(this.State.Expressions);
+      return true;
     }
 
@@ -81,7 +82,7 @@
   [PushExpression(StackType.Exec, "EXEC.IF")]
   public class ExecIfExpression : StatelessExpression {
-    public override void Eval(IPushInterpreter interpreter) {
+    public override bool Eval(IPushInterpreter interpreter) {
       // not enough arguments on stack
-      if ((interpreter.BooleanStack.Count == 0) || (interpreter.ExecStack.Count < 2)) return;
+      if ((interpreter.BooleanStack.Count == 0) || (interpreter.ExecStack.Count < 2)) return false;
 
       var condition = interpreter.BooleanStack.Pop();
@@ -89,4 +90,6 @@
       if (condition) interpreter.ExecStack.RemoveAt(interpreter.ExecStack.Count - 2);
       else interpreter.ExecStack.RemoveTop();
+
+      return true;
     }
   }
@@ -98,17 +101,19 @@
   [PushExpression(StackType.Exec, "EXEC.Y")]
   public class ExecYExpression : StatelessExpression {
-    public override void Eval(IPushInterpreter interpreter) {
+    public override bool Eval(IPushInterpreter interpreter) {
       // not enough arguments on stack
       if (interpreter.ExecStack.Count == 0 ||
           interpreter.Configuration.MaxPointsInProgram < 2)
-        return;
+        return false;
 
       var top = interpreter.ExecStack.Top;
       var execYExpression = ExpressionTable.GetStatelessExpression<ExecYExpression>();
+
       var result = new ExecExpandExpression(top, execYExpression);
 
-      //interpreter.ExecStack.Insert(interpreter.ExecStack.Count - 1, result);
       interpreter.ExecStack.SetTop(result);
       interpreter.ExecStack.Add(top);
+
+      return true;
     }
   }
@@ -119,9 +124,11 @@
   [PushExpression(StackType.Exec, "EXEC.K")]
   public class ExecKExpression : StatelessExpression {
-    public override void Eval(IPushInterpreter interpreter) {
-      if (interpreter.ExecStack.Count < 2) return;
+    public override bool Eval(IPushInterpreter interpreter) {
+      if (interpreter.ExecStack.Count < 2) return false;
 
       var top = interpreter.ExecStack.Pop();
       interpreter.ExecStack.SetTop(top);
+
+      return true;
     }
   }
@@ -134,6 +141,6 @@
   [PushExpression(StackType.Exec, "EXEC.S")]
   public class ExecSExpression : StatelessExpression {
-    public override void Eval(IPushInterpreter interpreter) {
-      if (interpreter.ExecStack.Count < 3) return;
+    public override bool Eval(IPushInterpreter interpreter) {
+      if (interpreter.ExecStack.Count < 3) return false;
 
       var expression = interpreter.ExecStack.Pop(2);
@@ -146,4 +153,6 @@
       interpreter.ExecStack.SetTop(newTop);
       interpreter.ExecStack.Push(c, a);
+
+      return true;
     }
   }
Index: branches/PushGP/HeuristicLab.PushGP/HeuristicLab.Problems.ProgramSynthesis/Push/Expressions/Expression.cs
===================================================================
--- branches/PushGP/HeuristicLab.PushGP/HeuristicLab.Problems.ProgramSynthesis/Push/Expressions/Expression.cs	(revision 14733)
+++ branches/PushGP/HeuristicLab.PushGP/HeuristicLab.Problems.ProgramSynthesis/Push/Expressions/Expression.cs	(revision 14744)
@@ -24,5 +24,5 @@
     }
 
-    public abstract void Eval(IPushInterpreter interpreter);
+    public abstract bool Eval(IPushInterpreter interpreter);
 
     public override string ToString() {
Index: branches/PushGP/HeuristicLab.PushGP/HeuristicLab.Problems.ProgramSynthesis/Push/Expressions/ExpressionTable.cs
===================================================================
--- branches/PushGP/HeuristicLab.PushGP/HeuristicLab.Problems.ProgramSynthesis/Push/Expressions/ExpressionTable.cs	(revision 14733)
+++ branches/PushGP/HeuristicLab.PushGP/HeuristicLab.Problems.ProgramSynthesis/Push/Expressions/ExpressionTable.cs	(revision 14744)
@@ -124,11 +124,12 @@
 
     public static ExecExpandExpression GetProgram(int[] index) {
-      var expressions = new List<Expression>(index.Length);
+      var expressions = new Expression[index.Length];
 
       for (var i = 0; i < index.Length; i++) {
-        expressions.Add(GetExpression(index[i]));
+        expressions[i] = GetExpression(index[i]);
       }
 
-      return new ExecExpandExpression(expressions);
+      var program = new PushProgram(expressions);
+      return new ExecExpandExpression(program);
     }
 
Index: branches/PushGP/HeuristicLab.PushGP/HeuristicLab.Problems.ProgramSynthesis/Push/Expressions/FloatExpressions.cs
===================================================================
--- branches/PushGP/HeuristicLab.PushGP/HeuristicLab.Problems.ProgramSynthesis/Push/Expressions/FloatExpressions.cs	(revision 14733)
+++ branches/PushGP/HeuristicLab.PushGP/HeuristicLab.Problems.ProgramSynthesis/Push/Expressions/FloatExpressions.cs	(revision 14744)
@@ -11,6 +11,6 @@
   [PushExpression(StackType.Float, "FLOAT.+")]
   public class FloatAddExpression : PushResultExpression<double> {
-    public override void Eval(IPushInterpreter interpreter) {
-      Eval(interpreter.FloatStack, 2, values => values[0] + values[1]);
+    public override bool Eval(IPushInterpreter interpreter) {
+      return Eval(interpreter.FloatStack, 2, values => values[0] + values[1]);
     }
   }
@@ -21,6 +21,6 @@
   [PushExpression(StackType.Float, "FLOAT.-")]
   public class FloatSubtractExpression : PushResultExpression<double> {
-    public override void Eval(IPushInterpreter interpreter) {
-      this.Eval(interpreter.FloatStack, 2, values => values[0] - values[1]);
+    public override bool Eval(IPushInterpreter interpreter) {
+      return Eval(interpreter.FloatStack, 2, values => values[0] - values[1]);
     }
   }
@@ -31,6 +31,6 @@
   [PushExpression(StackType.Float, "FLOAT.*")]
   public class FloatMultiplyExpression : PushResultExpression<double> {
-    public override void Eval(IPushInterpreter interpreter) {
-      this.Eval(interpreter.FloatStack, 2, values => values[0] * values[1]);
+    public override bool Eval(IPushInterpreter interpreter) {
+      return Eval(interpreter.FloatStack, 2, values => values[0] * values[1]);
     }
   }
@@ -42,6 +42,6 @@
   [PushExpression(StackType.Float, "FLOAT./")]
   public class FloatDivideExpression : PushResultExpression<double> {
-    public override void Eval(IPushInterpreter interpreter) {
-      this.Eval(interpreter.FloatStack, 2, values => values[0] / values[1], 0);
+    public override bool Eval(IPushInterpreter interpreter) {
+      return Eval(interpreter.FloatStack, 2, values => values[0] / values[1], 0);
     }
   }
@@ -56,6 +56,6 @@
   [PushExpression(StackType.Float, "FLOAT.%")]
   public class FloatModuloExpression : PushResultExpression<double> {
-    public override void Eval(IPushInterpreter interpreter) {
-      this.Eval(interpreter.FloatStack, 2, values => values[0] % values[1], 0);
+    public override bool Eval(IPushInterpreter interpreter) {
+      return Eval(interpreter.FloatStack, 2, values => values[0] % values[1], 0);
     }
   }
@@ -66,6 +66,6 @@
   [PushExpression(StackType.Float, "FLOAT.MIN")]
   public class FloatMinExpression : PushResultExpression<double> {
-    public override void Eval(IPushInterpreter interpreter) {
-      this.Eval(interpreter.FloatStack, 2, values => Math.Min(values[0], values[1]));
+    public override bool Eval(IPushInterpreter interpreter) {
+      return Eval(interpreter.FloatStack, 2, values => Math.Min(values[0], values[1]));
     }
   }
@@ -76,6 +76,6 @@
   [PushExpression(StackType.Float, "FLOAT.MAX")]
   public class FloatMaxExpression : PushResultExpression<double> {
-    public override void Eval(IPushInterpreter interpreter) {
-      this.Eval(interpreter.FloatStack, 2, values => Math.Max(values[0], values[1]));
+    public override bool Eval(IPushInterpreter interpreter) {
+      return Eval(interpreter.FloatStack, 2, values => Math.Max(values[0], values[1]));
     }
   }
@@ -86,6 +86,6 @@
   [PushExpression(StackType.Float, "FLOAT.<")]
   public class FloatSmallerThanExpression : PushResultExpression<double> {
-    public override void Eval(IPushInterpreter interpreter) {
-      this.Eval(interpreter.FloatStack, interpreter.BooleanStack, 2, values => values[0] < values[1]);
+    public override bool Eval(IPushInterpreter interpreter) {
+      return Eval(interpreter.FloatStack, interpreter.BooleanStack, 2, values => values[0] < values[1]);
     }
   }
@@ -96,6 +96,6 @@
   [PushExpression(StackType.Float, "FLOAT.>")]
   public class FloatGreaterThanExpression : PushResultExpression<double> {
-    public override void Eval(IPushInterpreter interpreter) {
-      this.Eval(interpreter.FloatStack, interpreter.BooleanStack, 2, values => values[0] > values[1]);
+    public override bool Eval(IPushInterpreter interpreter) {
+      return Eval(interpreter.FloatStack, interpreter.BooleanStack, 2, values => values[0] > values[1]);
     }
   }
@@ -106,6 +106,6 @@
   [PushExpression(StackType.Float, "FLOAT.SIN")]
   public class FloatSineExpression : PushResultExpression<double> {
-    public override void Eval(IPushInterpreter interpreter) {
-      this.Eval(interpreter.FloatStack, 1, values => Math.Sin(values[0]));
+    public override bool Eval(IPushInterpreter interpreter) {
+      return Eval(interpreter.FloatStack, 1, values => Math.Sin(values[0]));
     }
   }
@@ -116,6 +116,6 @@
   [PushExpression(StackType.Float, "FLOAT.COS")]
   public class FloatCosineExpression : PushResultExpression<double> {
-    public override void Eval(IPushInterpreter interpreter) {
-      this.Eval(interpreter.FloatStack, 1, values => Math.Cos(values[0]));
+    public override bool Eval(IPushInterpreter interpreter) {
+      return Eval(interpreter.FloatStack, 1, values => Math.Cos(values[0]));
     }
   }
@@ -126,6 +126,6 @@
   [PushExpression(StackType.Float, "FLOAT.FROMBOOLEAN")]
   public class FloatFromBooleanExpression : StatelessExpression {
-    public override void Eval(IPushInterpreter interpreter) {
-      if (interpreter.BooleanStack.Count == 0) return;
+    public override bool Eval(IPushInterpreter interpreter) {
+      if (interpreter.BooleanStack.Count == 0) return false;
 
       var condition = interpreter.BooleanStack.Pop();
@@ -133,4 +133,6 @@
 
       interpreter.FloatStack.Push(value);
+
+      return true;
     }
   }
@@ -141,10 +143,12 @@
   [PushExpression(StackType.Float, "FLOAT.FROMINTEGER")]
   public class FloatFromIntegerExpression : StatelessExpression {
-    public override void Eval(IPushInterpreter interpreter) {
-      if (interpreter.IntegerStack.Count == 0) return;
+    public override bool Eval(IPushInterpreter interpreter) {
+      if (interpreter.IntegerStack.Count == 0) return false;
 
       var value = (double)interpreter.IntegerStack.Pop();
 
       interpreter.FloatStack.Push(value);
+
+      return true;
     }
   }
Index: branches/PushGP/HeuristicLab.PushGP/HeuristicLab.Problems.ProgramSynthesis/Push/Expressions/FlushExpressions.cs
===================================================================
--- branches/PushGP/HeuristicLab.PushGP/HeuristicLab.Problems.ProgramSynthesis/Push/Expressions/FlushExpressions.cs	(revision 14733)
+++ branches/PushGP/HeuristicLab.PushGP/HeuristicLab.Problems.ProgramSynthesis/Push/Expressions/FlushExpressions.cs	(revision 14744)
@@ -10,6 +10,7 @@
   /// <typeparam name="T">Stacktype</typeparam>
   public abstract class FlushExpression<T> : StatelessExpression {
-    public void Eval(IStack<T> stack) {
+    public bool Eval(IStack<T> stack) {
       stack.Clear();
+      return true;
     }
   }
@@ -17,6 +18,6 @@
   [PushExpression(StackType.Integer, "INTEGER.FLUSH")]
   public class IntegerFlushExpression : FlushExpression<long> {
-    public override void Eval(IPushInterpreter interpreter) {
-      Eval(interpreter.IntegerStack);
+    public override bool Eval(IPushInterpreter interpreter) {
+      return Eval(interpreter.IntegerStack);
     }
   }
@@ -24,6 +25,6 @@
   [PushExpression(StackType.Float, "FLOAT.FLUSH")]
   public class FloatFlushExpression : FlushExpression<double> {
-    public override void Eval(IPushInterpreter interpreter) {
-      Eval(interpreter.FloatStack);
+    public override bool Eval(IPushInterpreter interpreter) {
+      return Eval(interpreter.FloatStack);
     }
   }
@@ -31,6 +32,6 @@
   [PushExpression(StackType.Boolean, "BOOLEAN.FLUSH")]
   public class BooleanFlushExpression : FlushExpression<bool> {
-    public override void Eval(IPushInterpreter interpreter) {
-      Eval(interpreter.BooleanStack);
+    public override bool Eval(IPushInterpreter interpreter) {
+      return Eval(interpreter.BooleanStack);
     }
   }
@@ -38,6 +39,6 @@
   [PushExpression(StackType.Name, "NAME.FLUSH")]
   public class NameFlushExpression : FlushExpression<string> {
-    public override void Eval(IPushInterpreter interpreter) {
-      Eval(interpreter.NameStack);
+    public override bool Eval(IPushInterpreter interpreter) {
+      return Eval(interpreter.NameStack);
     }
   }
@@ -45,6 +46,6 @@
   [PushExpression(StackType.Exec, "EXEC.FLUSH")]
   public class ExecFlushExpression : FlushExpression<Expression> {
-    public override void Eval(IPushInterpreter interpreter) {
-      Eval(interpreter.ExecStack);
+    public override bool Eval(IPushInterpreter interpreter) {
+      return Eval(interpreter.ExecStack);
     }
   }
@@ -52,6 +53,6 @@
   [PushExpression(StackType.Code, "CODE.FLUSH")]
   public class CodeFlushExpression : FlushExpression<Expression> {
-    public override void Eval(IPushInterpreter interpreter) {
-      Eval(interpreter.CodeStack);
+    public override bool Eval(IPushInterpreter interpreter) {
+      return Eval(interpreter.CodeStack);
     }
   }
Index: branches/PushGP/HeuristicLab.PushGP/HeuristicLab.Problems.ProgramSynthesis/Push/Expressions/IntegerExpressions.cs
===================================================================
--- branches/PushGP/HeuristicLab.PushGP/HeuristicLab.Problems.ProgramSynthesis/Push/Expressions/IntegerExpressions.cs	(revision 14733)
+++ branches/PushGP/HeuristicLab.PushGP/HeuristicLab.Problems.ProgramSynthesis/Push/Expressions/IntegerExpressions.cs	(revision 14744)
@@ -12,6 +12,6 @@
   [PushExpression(StackType.Integer, "INTEGER.+")]
   public class IntegerAddExpression : PushResultExpression<long> {
-    public override void Eval(IPushInterpreter interpreter) {
-      this.Eval(interpreter.IntegerStack, 2, values => values[0] + values[1]);
+    public override bool Eval(IPushInterpreter interpreter) {
+      return Eval(interpreter.IntegerStack, 2, values => values[0] + values[1]);
     }
   }
@@ -22,6 +22,6 @@
   [PushExpression(StackType.Integer, "INTEGER.-")]
   public class IntegerSubtractExpression : PushResultExpression<long> {
-    public override void Eval(IPushInterpreter interpreter) {
-      this.Eval(interpreter.IntegerStack, 2, values => values[0] - values[1]);
+    public override bool Eval(IPushInterpreter interpreter) {
+      return Eval(interpreter.IntegerStack, 2, values => values[0] - values[1]);
     }
   }
@@ -32,6 +32,6 @@
   [PushExpression(StackType.Integer, "INTEGER.*")]
   public class IntegerMultiplyExpression : PushResultExpression<long> {
-    public override void Eval(IPushInterpreter interpreter) {
-      this.Eval(interpreter.IntegerStack, 2, values => values[0] * values[1]);
+    public override bool Eval(IPushInterpreter interpreter) {
+      return Eval(interpreter.IntegerStack, 2, values => values[0] * values[1]);
     }
   }
@@ -43,6 +43,6 @@
   [PushExpression(StackType.Integer, "INTEGER./")]
   public class IntegerDivideExpression : PushResultExpression<long> {
-    public override void Eval(IPushInterpreter interpreter) {
-      this.Eval(interpreter.IntegerStack, 2, values => values[0] / values[1], 0);
+    public override bool Eval(IPushInterpreter interpreter) {
+      return Eval(interpreter.IntegerStack, 2, values => values[0] / values[1], 0);
     }
   }
@@ -58,6 +58,6 @@
   [PushExpression(StackType.Integer, "INTEGER.%")]
   public class IntegerModuloExpression : PushResultExpression<long> {
-    public override void Eval(IPushInterpreter interpreter) {
-      this.Eval(interpreter.IntegerStack, 2, values => values[0] % values[1], 0);
+    public override bool Eval(IPushInterpreter interpreter) {
+      return Eval(interpreter.IntegerStack, 2, values => values[0] % values[1], 0);
     }
   }
@@ -68,6 +68,6 @@
   [PushExpression(StackType.Integer, "INTEGER.MIN")]
   public class IntegerMinExpression : PushResultExpression<long> {
-    public override void Eval(IPushInterpreter interpreter) {
-      this.Eval(interpreter.IntegerStack, 2, values => Math.Min(values[0], values[1]));
+    public override bool Eval(IPushInterpreter interpreter) {
+      return Eval(interpreter.IntegerStack, 2, values => Math.Min(values[0], values[1]));
     }
   }
@@ -78,6 +78,6 @@
   [PushExpression(StackType.Integer, "INTEGER.MAX")]
   public class IntegerMaxExpression : PushResultExpression<long> {
-    public override void Eval(IPushInterpreter interpreter) {
-      this.Eval(interpreter.IntegerStack, 2, values => Math.Max(values[0], values[1]));
+    public override bool Eval(IPushInterpreter interpreter) {
+      return Eval(interpreter.IntegerStack, 2, values => Math.Max(values[0], values[1]));
     }
   }
@@ -88,6 +88,6 @@
   [PushExpression(StackType.Integer, "INTEGER.<")]
   public class IntegerSmallerThanExpression : PushResultExpression<long> {
-    public override void Eval(IPushInterpreter interpreter) {
-      this.Eval(interpreter.IntegerStack, interpreter.BooleanStack, 2, values => values[0] < values[1]);
+    public override bool Eval(IPushInterpreter interpreter) {
+      return Eval(interpreter.IntegerStack, interpreter.BooleanStack, 2, values => values[0] < values[1]);
     }
   }
@@ -98,6 +98,6 @@
   [PushExpression(StackType.Integer, "INTEGER.>")]
   public class IntegerGreaterThanExpression : PushResultExpression<long> {
-    public override void Eval(IPushInterpreter interpreter) {
-      this.Eval(interpreter.IntegerStack, interpreter.BooleanStack, 2, values => values[0] > values[1]);
+    public override bool Eval(IPushInterpreter interpreter) {
+      return Eval(interpreter.IntegerStack, interpreter.BooleanStack, 2, values => values[0] > values[1]);
     }
   }
@@ -108,6 +108,6 @@
   [PushExpression(StackType.Integer, "INTEGER.FROMBOOLEAN")]
   public class IntegerFromBooleanExpression : StatelessExpression {
-    public override void Eval(IPushInterpreter interpreter) {
-      if (interpreter.BooleanStack.Count == 0) return;
+    public override bool Eval(IPushInterpreter interpreter) {
+      if (interpreter.BooleanStack.Count == 0) return false;
 
       var condition = interpreter.BooleanStack.Pop();
@@ -115,4 +115,6 @@
 
       interpreter.IntegerStack.Push(value);
+
+      return true;
     }
   }
@@ -123,10 +125,12 @@
   [PushExpression(StackType.Integer, "INTEGER.FROMFLOAT")]
   public class IntegerFromFloatExpression : StatelessExpression {
-    public override void Eval(IPushInterpreter interpreter) {
-      if (interpreter.FloatStack.Count == 0) return;
+    public override bool Eval(IPushInterpreter interpreter) {
+      if (interpreter.FloatStack.Count == 0) return false;
 
       var value = (int)interpreter.FloatStack.Pop();
 
       interpreter.IntegerStack.Push(value);
+
+      return true;
     }
   }
Index: branches/PushGP/HeuristicLab.PushGP/HeuristicLab.Problems.ProgramSynthesis/Push/Expressions/LoopExpression.cs
===================================================================
--- branches/PushGP/HeuristicLab.PushGP/HeuristicLab.Problems.ProgramSynthesis/Push/Expressions/LoopExpression.cs	(revision 14733)
+++ branches/PushGP/HeuristicLab.PushGP/HeuristicLab.Problems.ProgramSynthesis/Push/Expressions/LoopExpression.cs	(revision 14744)
@@ -4,6 +4,6 @@
   using HeuristicLab.Problems.ProgramSynthesis.Push.Stack;
 
-  public class LoopState {
-    public LoopState() { }
+  public struct LoopState {
+    //public LoopState() { }
     public LoopState(Expression body, long currentIndex, long destinationIndex, long incrementor) {
       this.Body = body;
@@ -36,8 +36,8 @@
     protected LoopExpression(LoopState state) : base(state) { }
 
-    protected void Eval(IPushInterpreter interpreter, IStack<Expression> sourceStack, bool pushCurrentIndex = false) {
+    protected bool Eval(IPushInterpreter interpreter, IStack<Expression> sourceStack, bool pushCurrentIndex = false) {
       // if not initialized
       if (this.State.Body == null) {
-        if (this.HasInsufficientArguments(interpreter, sourceStack)) return;
+        if (this.HasInsufficientArguments(interpreter, sourceStack)) return false;
 
         var state = this.InitState(interpreter, sourceStack);
@@ -45,5 +45,5 @@
 
         interpreter.ExecStack.Push(initLoopExpression, state.Body);
-        return;
+        return true;
       }
 
@@ -51,11 +51,11 @@
       if (this.State.DestinationIndex == this.State.CurrentIndex) {
         this.PushLastIteration(interpreter);
-        return;
+        return true;
       }
 
       this.PushIteration(interpreter);
+
+      return true;
     }
-
-    protected abstract LoopExpression Clone(LoopState state);
 
     protected virtual void PushIteration(IPushInterpreter interpreter) {
@@ -73,28 +73,6 @@
     }
 
-    //public override bool Equals(object obj) {
-    //  if (this == obj)
-    //    return true;
-
-    //  if (obj == null || obj.GetType() != this.GetType())
-    //    return false;
-
-    //  var other = obj as LoopExpression;
-
-    //  if (this.State.CurrentIndex != other.State.CurrentIndex ||
-    //      this.State.DestinationIndex != other.State.DestinationIndex ||
-    //      this.State.Incrementor != other.State.Incrementor)
-    //    return false;
-
-    //  var isBodyEqual = this.State.Body == other.State.Body ||
-    //                    (this.State.Body != null &&
-    //                    other.State.Body != null &&
-    //                    this.State.Body.Equals(other.State.Body));
-
-    //  return isBodyEqual;
-    //}
-
+    protected abstract LoopExpression Clone(LoopState state);
     protected abstract bool HasInsufficientArguments(IPushInterpreter interpreter, IStack<Expression> sourceStack);
-
     protected abstract LoopState InitState(IPushInterpreter interpreter, IStack<Expression> sourceStack);
   }
Index: branches/PushGP/HeuristicLab.PushGP/HeuristicLab.Problems.ProgramSynthesis/Push/Expressions/NameExpressions.cs
===================================================================
--- branches/PushGP/HeuristicLab.PushGP/HeuristicLab.Problems.ProgramSynthesis/Push/Expressions/NameExpressions.cs	(revision 14733)
+++ branches/PushGP/HeuristicLab.PushGP/HeuristicLab.Problems.ProgramSynthesis/Push/Expressions/NameExpressions.cs	(revision 14744)
@@ -8,5 +8,5 @@
     public NameDefineXExecExpression(string state) : base(state) { }
 
-    public override void Eval(IPushInterpreter interpreter) {
+    public override bool Eval(IPushInterpreter interpreter) {
       Expression expression;
       if (!interpreter.IsNameQuoteFlagSet &&
@@ -17,4 +17,6 @@
         interpreter.IsNameQuoteFlagSet = false;
       }
+
+      return true;
     }
 
@@ -31,6 +33,9 @@
   [PushExpression(StackType.Name, "NAME.QUOTE")]
   public class NameQuoteExpression : StatelessExpression {
-    public override void Eval(IPushInterpreter interpreter) {
+    public override bool Eval(IPushInterpreter interpreter) {
+      if (interpreter.IsNameQuoteFlagSet) return false;
+
       interpreter.IsNameQuoteFlagSet = true;
+      return true;
     }
   }
@@ -41,7 +46,7 @@
   [PushExpression(StackType.Name, "NAME.RANDBOUNDNAME")]
   public class NameRandBoundNameExpression : StatelessExpression {
-    public override void Eval(IPushInterpreter interpreter) {
+    public override bool Eval(IPushInterpreter interpreter) {
       if (interpreter.CustomExpressions.Count == 0)
-        return;
+        return false;
 
       var index = interpreter.CustomExpressions.Keys.Count == 1
@@ -52,4 +57,6 @@
 
       interpreter.NameStack.Push(state);
+
+      return true;
     }
   }
Index: branches/PushGP/HeuristicLab.PushGP/HeuristicLab.Problems.ProgramSynthesis/Push/Expressions/PopExpressions.cs
===================================================================
--- branches/PushGP/HeuristicLab.PushGP/HeuristicLab.Problems.ProgramSynthesis/Push/Expressions/PopExpressions.cs	(revision 14733)
+++ branches/PushGP/HeuristicLab.PushGP/HeuristicLab.Problems.ProgramSynthesis/Push/Expressions/PopExpressions.cs	(revision 14744)
@@ -6,8 +6,9 @@
 
   public abstract class PopExpression<T> : StatelessExpression {
-    public void Eval(IStack<T> stack) {
-      if (stack.Count == 0) return;
+    public bool Eval(IStack<T> stack) {
+      if (stack.Count == 0) return false;
 
       stack.Pop();
+      return true;
     }
   }
@@ -15,6 +16,6 @@
   [PushExpression(StackType.Integer, "INTEGER.POP")]
   public class IntegerPopExpression : PopExpression<long> {
-    public override void Eval(IPushInterpreter interpreter) {
-      this.Eval(interpreter.IntegerStack);
+    public override bool Eval(IPushInterpreter interpreter) {
+      return Eval(interpreter.IntegerStack);
     }
   }
@@ -22,6 +23,6 @@
   [PushExpression(StackType.Float, "FLOAT.POP")]
   public class FloatPopExpression : PopExpression<double> {
-    public override void Eval(IPushInterpreter interpreter) {
-      this.Eval(interpreter.FloatStack);
+    public override bool Eval(IPushInterpreter interpreter) {
+      return Eval(interpreter.FloatStack);
     }
   }
@@ -29,6 +30,6 @@
   [PushExpression(StackType.Boolean, "BOOLEAN.POP")]
   public class BooleanPopExpression : PopExpression<bool> {
-    public override void Eval(IPushInterpreter interpreter) {
-      this.Eval(interpreter.BooleanStack);
+    public override bool Eval(IPushInterpreter interpreter) {
+      return Eval(interpreter.BooleanStack);
     }
   }
@@ -36,6 +37,6 @@
   [PushExpression(StackType.Name, "NAME.POP")]
   public class NamePopExpression : PopExpression<string> {
-    public override void Eval(IPushInterpreter interpreter) {
-      this.Eval(interpreter.NameStack);
+    public override bool Eval(IPushInterpreter interpreter) {
+      return Eval(interpreter.NameStack);
     }
   }
@@ -43,6 +44,6 @@
   [PushExpression(StackType.Exec, "EXEC.POP")]
   public class ExecPopExpression : PopExpression<Expression> {
-    public override void Eval(IPushInterpreter interpreter) {
-      this.Eval(interpreter.ExecStack);
+    public override bool Eval(IPushInterpreter interpreter) {
+      return Eval(interpreter.ExecStack);
     }
   }
@@ -50,6 +51,6 @@
   [PushExpression(StackType.Code, "CODE.POP")]
   public class CodePopExpression : PopExpression<Expression> {
-    public override void Eval(IPushInterpreter interpreter) {
-      this.Eval(interpreter.CodeStack);
+    public override bool Eval(IPushInterpreter interpreter) {
+      return Eval(interpreter.CodeStack);
     }
   }
Index: branches/PushGP/HeuristicLab.PushGP/HeuristicLab.Problems.ProgramSynthesis/Push/Expressions/PushExpressions.cs
===================================================================
--- branches/PushGP/HeuristicLab.PushGP/HeuristicLab.Problems.ProgramSynthesis/Push/Expressions/PushExpressions.cs	(revision 14733)
+++ branches/PushGP/HeuristicLab.PushGP/HeuristicLab.Problems.ProgramSynthesis/Push/Expressions/PushExpressions.cs	(revision 14744)
@@ -7,7 +7,9 @@
     protected PushExpression(T state) : base(state) { }
 
-    protected void Eval(IStack<T> stack) {
+    protected bool Eval(IStack<T> stack) {
       stack.Push(this.State);
+      return true;
     }
+
     public override string StringRepresentation { get { return this.State.ToString(); } }
   }
@@ -18,6 +20,6 @@
     }
 
-    public override void Eval(IPushInterpreter interpreter) {
-      this.Eval(interpreter.IntegerStack);
+    public override bool Eval(IPushInterpreter interpreter) {
+      return Eval(interpreter.IntegerStack);
     }
   }
@@ -28,6 +30,6 @@
     }
 
-    public override void Eval(IPushInterpreter interpreter) {
-      this.Eval(interpreter.FloatStack);
+    public override bool Eval(IPushInterpreter interpreter) {
+      return Eval(interpreter.FloatStack);
     }
   }
@@ -38,6 +40,6 @@
     }
 
-    public override void Eval(IPushInterpreter interpreter) {
-      this.Eval(interpreter.BooleanStack);
+    public override bool Eval(IPushInterpreter interpreter) {
+      return Eval(interpreter.BooleanStack);
     }
   }
@@ -48,6 +50,6 @@
     }
 
-    public override void Eval(IPushInterpreter interpreter) {
-      this.Eval(interpreter.NameStack);
+    public override bool Eval(IPushInterpreter interpreter) {
+      return Eval(interpreter.NameStack);
     }
   }
@@ -58,6 +60,6 @@
     }
 
-    public override void Eval(IPushInterpreter interpreter) {
-      this.Eval(interpreter.ExecStack);
+    public override bool Eval(IPushInterpreter interpreter) {
+      return Eval(interpreter.ExecStack);
     }
   }
Index: branches/PushGP/HeuristicLab.PushGP/HeuristicLab.Problems.ProgramSynthesis/Push/Expressions/PushProgram.cs
===================================================================
--- branches/PushGP/HeuristicLab.PushGP/HeuristicLab.Problems.ProgramSynthesis/Push/Expressions/PushProgram.cs	(revision 14733)
+++ branches/PushGP/HeuristicLab.PushGP/HeuristicLab.Problems.ProgramSynthesis/Push/Expressions/PushProgram.cs	(revision 14744)
@@ -2,5 +2,4 @@
 
 namespace HeuristicLab.Problems.ProgramSynthesis.Push.Expressions {
-  using System;
   using System.Diagnostics;
   using System.Linq;
@@ -14,11 +13,19 @@
     private const string Delimiter = " ";
 
+    public static readonly PushProgram Empty = new PushProgram(new Expression[0]);
+
     public readonly IReadOnlyList<Expression> Expressions;
-    public readonly bool IsEmpty;
-
+    public bool IsEmpty { get; private set; }
+
+    public PushProgram(Expression[] expressions) {
+      this.Expressions = expressions;
+      this.IsEmpty = expressions.Length == 0;
+    }
 
     private string stringRepresentation;
-    private string StringRepresentation {
-      get {
+    private string StringRepresentation
+    {
+      get
+      {
         if (string.IsNullOrEmpty(stringRepresentation))
           stringRepresentation = BuildString();
@@ -28,6 +35,8 @@
 
     private int depth = -1;
-    private int Depth {
-      get {
+    private int Depth
+    {
+      get
+      {
         if (depth == -1) depth = CalcDepth();
         return depth;
@@ -36,24 +45,21 @@
 
     private int[] treeIndex = null;
-    public int[] TreeIndex {
-      get {
-        if (treeIndex == null) treeIndex = BuildTreeIndex();
-        return treeIndex;
+    public int[] TreeIndex
+    {
+      get
+      {
+        return this.treeIndex ?? (this.treeIndex = this.BuildTreeIndex());
       }
     }
 
     private int hashCode;
-    private int HashCode {
-      get {
+    private int HashCode
+    {
+      get
+      {
         if (hashCode == default(int)) hashCode = HashExpressions();
         return hashCode;
       }
     }
-
-    public PushProgram(Expression[] expressions) {
-      this.Expressions = expressions;
-      this.IsEmpty = expressions.Length == 0;
-    }
-
 
     public override int GetHashCode() {
@@ -69,9 +75,11 @@
     /// </summary>
     /// <returns></returns>
-    public int TotalCount {
-      get {
+    public int TotalCount
+    {
+      get
+      {
         return this.IsEmpty
             ? 1
-          // + 1 because "this" is also counted
+            // + 1 because "this" is also counted
             : TreeIndex[0] + 1;
       }
@@ -90,12 +98,15 @@
 
     public PushProgram Copy() {
-      var copy = this.CopyExpressions();
-
-      return new PushProgram(copy);
+      return IsEmpty ? this : new PushProgram((Expression[])Expressions) {
+        stringRepresentation = this.stringRepresentation,
+        hashCode = this.hashCode,
+        depth = this.depth,
+        treeIndex = this.treeIndex
+      };
     }
 
     public Expression[] CopyExpressions() {
       var copy = new Expression[this.Expressions.Count];
-      Array.Copy((Expression[])this.Expressions, copy, this.Expressions.Count);
+      ((Expression[])this.Expressions).CopyTo(copy, Expressions.Count);
 
       return copy;
Index: branches/PushGP/HeuristicLab.PushGP/HeuristicLab.Problems.ProgramSynthesis/Push/Expressions/PushResultExpression.cs
===================================================================
--- branches/PushGP/HeuristicLab.PushGP/HeuristicLab.Problems.ProgramSynthesis/Push/Expressions/PushResultExpression.cs	(revision 14733)
+++ branches/PushGP/HeuristicLab.PushGP/HeuristicLab.Problems.ProgramSynthesis/Push/Expressions/PushResultExpression.cs	(revision 14744)
@@ -5,18 +5,20 @@
 
   public abstract class PushResultExpression<T> : StatelessExpression {
-    protected void Eval(IStack<T> stack, int count, Func<T[], T> templateFunc) {
-      if (stack.Count < count) return;
+    protected bool Eval(IStack<T> stack, int count, Func<T[], T> templateFunc) {
+      if (stack.Count < count) return false;
 
       stack.PushResult(count, templateFunc);
+      return true;
     }
 
-    protected void Eval(IStack<T> stack, int count, Func<T[], T> templateFunc, T ignoreValue) {
-      if ((stack.Count < count) || stack.Top.Equals(ignoreValue)) return;
+    protected bool Eval(IStack<T> stack, int count, Func<T[], T> templateFunc, T ignoreValue) {
+      if ((stack.Count < count) || stack.Top.Equals(ignoreValue)) return false;
 
       stack.PushResult(count, templateFunc);
+      return true;
     }
 
-    protected void Eval<R>(IStack<T> stack, IStack<R> resultStack, int count, Func<T[], R> templateFunc) {
-      if (stack.Count < count) return;
+    protected bool Eval<R>(IStack<T> stack, IStack<R> resultStack, int count, Func<T[], R> templateFunc) {
+      if (stack.Count < count) return false;
 
       var items = stack.Pop(count);
@@ -24,4 +26,5 @@
 
       resultStack.Push(result);
+      return true;
     }
   }
Index: branches/PushGP/HeuristicLab.PushGP/HeuristicLab.Problems.ProgramSynthesis/Push/Expressions/RandExpressions.cs
===================================================================
--- branches/PushGP/HeuristicLab.PushGP/HeuristicLab.Problems.ProgramSynthesis/Push/Expressions/RandExpressions.cs	(revision 14733)
+++ branches/PushGP/HeuristicLab.PushGP/HeuristicLab.Problems.ProgramSynthesis/Push/Expressions/RandExpressions.cs	(revision 14744)
@@ -10,8 +10,9 @@
   [PushExpression(StackType.Name, "NAME.RAND")]
   public class NameRandExpression : StatelessExpression {
-    public override void Eval(IPushInterpreter interpreter) {
+    public override bool Eval(IPushInterpreter interpreter) {
       var name = NameGenerator.RandomName(interpreter.Random);
 
       interpreter.NameStack.Push(name);
+      return true;
     }
   }
@@ -22,5 +23,5 @@
   [PushExpression(StackType.Integer, "INTEGER.RAND")]
   public class IntegerRandExpression : StatelessExpression {
-    public override void Eval(IPushInterpreter interpreter) {
+    public override bool Eval(IPushInterpreter interpreter) {
       var value = interpreter.Random.Next(
           interpreter.Configuration.MinRandomInteger,
@@ -28,4 +29,5 @@
 
       interpreter.IntegerStack.Push(value);
+      return true;
     }
   }
@@ -36,8 +38,9 @@
   [PushExpression(StackType.Float, "FLOAT.RAND")]
   public class FloatRandExpression : StatelessExpression {
-    public override void Eval(IPushInterpreter interpreter) {
+    public override bool Eval(IPushInterpreter interpreter) {
       var value = interpreter.Random.NextDouble() * (interpreter.Configuration.MaxRandomFloat - interpreter.Configuration.MinRandomFloat) + interpreter.Configuration.MinRandomFloat;
 
       interpreter.FloatStack.Push(value);
+      return true;
     }
   }
@@ -48,8 +51,9 @@
   [PushExpression(StackType.Boolean, "BOOLEAN.RAND")]
   public class BooleanRandExpression : StatelessExpression {
-    public override void Eval(IPushInterpreter interpreter) {
+    public override bool Eval(IPushInterpreter interpreter) {
       var value = interpreter.Random.NextDouble() > 0.5;
 
       interpreter.BooleanStack.Push(value);
+      return true;
     }
   }
@@ -60,12 +64,17 @@
   [PushExpression(StackType.Code, "CODE.RAND")]
   public class CodeRandExpression : StatelessExpression {
-    public override void Eval(IPushInterpreter interpreter) {
+    public override bool Eval(IPushInterpreter interpreter) {
       if (interpreter.IntegerStack.Count == 0 ||
-          interpreter.IntegerStack.Top < 1) return;
+          interpreter.IntegerStack.Top < 1) return false;
 
       var size = (int)(interpreter.IntegerStack.Pop() % interpreter.Configuration.MaxPointsInRandomExpression);
-      var program = CodeGenerator.RandomExpandExpression(size, interpreter.Random, interpreter.Configuration, interpreter.CustomExpressions);
+      var program = CodeGenerator.RandomExpandExpression(
+        size,
+        interpreter.Random,
+        interpreter.Configuration,
+        interpreter.CustomExpressions);
 
       interpreter.CodeStack.Push(program);
+      return true;
     }
   }
Index: branches/PushGP/HeuristicLab.PushGP/HeuristicLab.Problems.ProgramSynthesis/Push/Expressions/RotateExpressions.cs
===================================================================
--- branches/PushGP/HeuristicLab.PushGP/HeuristicLab.Problems.ProgramSynthesis/Push/Expressions/RotateExpressions.cs	(revision 14733)
+++ branches/PushGP/HeuristicLab.PushGP/HeuristicLab.Problems.ProgramSynthesis/Push/Expressions/RotateExpressions.cs	(revision 14744)
@@ -6,8 +6,9 @@
 
   public abstract class RotateExpression<T> : StatelessExpression {
-    public void Eval(IStack<T> stack) {
-      if (stack.Count < 3) return;
+    public bool Eval(IStack<T> stack) {
+      if (stack.Count < 3) return false;
 
       stack.Swap(3);
+      return true;
     }
   }
@@ -16,6 +17,6 @@
   [PushExpression(StackType.Integer, "INTEGER.ROT")]
   public class IntegerRotateExpression : RotateExpression<long> {
-    public override void Eval(IPushInterpreter interpreter) {
-      Eval(interpreter.IntegerStack);
+    public override bool Eval(IPushInterpreter interpreter) {
+      return Eval(interpreter.IntegerStack);
     }
   }
@@ -23,6 +24,6 @@
   [PushExpression(StackType.Float, "FLOAT.ROT")]
   public class FloatRotateExpression : RotateExpression<double> {
-    public override void Eval(IPushInterpreter interpreter) {
-      Eval(interpreter.FloatStack);
+    public override bool Eval(IPushInterpreter interpreter) {
+      return Eval(interpreter.FloatStack);
     }
   }
@@ -30,6 +31,6 @@
   [PushExpression(StackType.Boolean, "BOOLEAN.ROT")]
   public class BooleanRotateExpression : RotateExpression<bool> {
-    public override void Eval(IPushInterpreter interpreter) {
-      Eval(interpreter.BooleanStack);
+    public override bool Eval(IPushInterpreter interpreter) {
+      return Eval(interpreter.BooleanStack);
     }
   }
@@ -37,6 +38,6 @@
   [PushExpression(StackType.Name, "NAME.ROT")]
   public class NameRotateExpression : RotateExpression<string> {
-    public override void Eval(IPushInterpreter interpreter) {
-      Eval(interpreter.NameStack);
+    public override bool Eval(IPushInterpreter interpreter) {
+      return Eval(interpreter.NameStack);
     }
   }
@@ -44,6 +45,6 @@
   [PushExpression(StackType.Exec, "EXEC.ROT")]
   public class ExecRotateExpression : RotateExpression<Expression> {
-    public override void Eval(IPushInterpreter interpreter) {
-      Eval(interpreter.ExecStack);
+    public override bool Eval(IPushInterpreter interpreter) {
+      return Eval(interpreter.ExecStack);
     }
   }
@@ -51,6 +52,6 @@
   [PushExpression(StackType.Code, "CODE.ROT")]
   public class CodeRotateExpression : RotateExpression<Expression> {
-    public override void Eval(IPushInterpreter interpreter) {
-      Eval(interpreter.CodeStack);
+    public override bool Eval(IPushInterpreter interpreter) {
+      return Eval(interpreter.CodeStack);
     }
   }
Index: branches/PushGP/HeuristicLab.PushGP/HeuristicLab.Problems.ProgramSynthesis/Push/Expressions/ShoveExpressions.cs
===================================================================
--- branches/PushGP/HeuristicLab.PushGP/HeuristicLab.Problems.ProgramSynthesis/Push/Expressions/ShoveExpressions.cs	(revision 14733)
+++ branches/PushGP/HeuristicLab.PushGP/HeuristicLab.Problems.ProgramSynthesis/Push/Expressions/ShoveExpressions.cs	(revision 14744)
@@ -6,10 +6,10 @@
 
   public abstract class ShoveExpression<T> : StatelessExpression {
-    protected void Eval(IStack<T> stack, IStack<long> integerStack, int count = 1) {
+    protected bool Eval(IStack<T> stack, IStack<long> integerStack, int count = 1) {
       if (integerStack.Count == 0 ||
           integerStack.Top > stack.Count - count ||
           integerStack.Top < 0 ||
           stack.Count < 2)
-        return;
+        return false;
 
       var index = (int)integerStack.Pop();
@@ -17,4 +17,5 @@
 
       stack.Insert(index, item);
+      return true;
     }
   }
@@ -22,6 +23,6 @@
   [PushExpression(StackType.Integer, "INTEGER.SHOVE")]
   public class IntegerShoveExpression : ShoveExpression<long> {
-    public override void Eval(IPushInterpreter interpreter) {
-      Eval(interpreter.IntegerStack, interpreter.IntegerStack, 2);
+    public override bool Eval(IPushInterpreter interpreter) {
+      return Eval(interpreter.IntegerStack, interpreter.IntegerStack, 2);
     }
   }
@@ -29,6 +30,6 @@
   [PushExpression(StackType.Float, "FLOAT.SHOVE")]
   public class FloatShoveExpression : ShoveExpression<double> {
-    public override void Eval(IPushInterpreter interpreter) {
-      Eval(interpreter.FloatStack, interpreter.IntegerStack);
+    public override bool Eval(IPushInterpreter interpreter) {
+      return Eval(interpreter.FloatStack, interpreter.IntegerStack);
     }
   }
@@ -36,6 +37,6 @@
   [PushExpression(StackType.Boolean, "BOOLEAN.SHOVE")]
   public class BooleanShoveExpression : ShoveExpression<bool> {
-    public override void Eval(IPushInterpreter interpreter) {
-      Eval(interpreter.BooleanStack, interpreter.IntegerStack);
+    public override bool Eval(IPushInterpreter interpreter) {
+      return Eval(interpreter.BooleanStack, interpreter.IntegerStack);
     }
   }
@@ -43,6 +44,6 @@
   [PushExpression(StackType.Name, "NAME.SHOVE")]
   public class NameShoveExpression : ShoveExpression<string> {
-    public override void Eval(IPushInterpreter interpreter) {
-      Eval(interpreter.NameStack, interpreter.IntegerStack);
+    public override bool Eval(IPushInterpreter interpreter) {
+      return Eval(interpreter.NameStack, interpreter.IntegerStack);
     }
   }
@@ -50,6 +51,6 @@
   [PushExpression(StackType.Exec, "EXEC.SHOVE")]
   public class ExecShoveExpression : ShoveExpression<Expression> {
-    public override void Eval(IPushInterpreter interpreter) {
-      Eval(interpreter.ExecStack, interpreter.IntegerStack);
+    public override bool Eval(IPushInterpreter interpreter) {
+      return Eval(interpreter.ExecStack, interpreter.IntegerStack);
     }
   }
@@ -57,6 +58,6 @@
   [PushExpression(StackType.Code, "CODE.SHOVE")]
   public class CodeShoveExpression : ShoveExpression<Expression> {
-    public override void Eval(IPushInterpreter interpreter) {
-      Eval(interpreter.CodeStack, interpreter.IntegerStack);
+    public override bool Eval(IPushInterpreter interpreter) {
+      return Eval(interpreter.CodeStack, interpreter.IntegerStack);
     }
   }
Index: branches/PushGP/HeuristicLab.PushGP/HeuristicLab.Problems.ProgramSynthesis/Push/Expressions/StackdepthExpressions.cs
===================================================================
--- branches/PushGP/HeuristicLab.PushGP/HeuristicLab.Problems.ProgramSynthesis/Push/Expressions/StackdepthExpressions.cs	(revision 14733)
+++ branches/PushGP/HeuristicLab.PushGP/HeuristicLab.Problems.ProgramSynthesis/Push/Expressions/StackdepthExpressions.cs	(revision 14744)
@@ -10,5 +10,5 @@
   /// <typeparam name="T">Stacktype</typeparam>
   public abstract class StackdepthExpression<T> : StatelessExpression {
-    public void Eval(IStack<T> stack, IStack<long> integerStack, bool incremental = false) {
+    public bool Eval(IStack<T> stack, IStack<long> integerStack, bool incremental = false) {
       var count = stack.Count;
 
@@ -16,4 +16,5 @@
 
       integerStack.Push(count);
+      return true;
     }
   }
@@ -22,6 +23,6 @@
   public class IntegerStackdepthExpression : StackdepthExpression<long> {
 
-    public override void Eval(IPushInterpreter interpreter) {
-      Eval(interpreter.IntegerStack, interpreter.IntegerStack, true);
+    public override bool Eval(IPushInterpreter interpreter) {
+      return Eval(interpreter.IntegerStack, interpreter.IntegerStack, true);
     }
   }
@@ -29,6 +30,6 @@
   [PushExpression(StackType.Float, "FLOAT.STACKDEPTH")]
   public class FloatStackdepthExpression : StackdepthExpression<double> {
-    public override void Eval(IPushInterpreter interpreter) {
-      Eval(interpreter.FloatStack, interpreter.IntegerStack);
+    public override bool Eval(IPushInterpreter interpreter) {
+      return Eval(interpreter.FloatStack, interpreter.IntegerStack);
     }
   }
@@ -36,6 +37,6 @@
   [PushExpression(StackType.Boolean, "BOOLEAN.STACKDEPTH")]
   public class BooleanStackdepthExpression : StackdepthExpression<bool> {
-    public override void Eval(IPushInterpreter interpreter) {
-      Eval(interpreter.BooleanStack, interpreter.IntegerStack);
+    public override bool Eval(IPushInterpreter interpreter) {
+      return Eval(interpreter.BooleanStack, interpreter.IntegerStack);
     }
   }
@@ -43,6 +44,6 @@
   [PushExpression(StackType.Name, "NAME.STACKDEPTH")]
   public class NameStackdepthExpression : StackdepthExpression<string> {
-    public override void Eval(IPushInterpreter interpreter) {
-      Eval(interpreter.NameStack, interpreter.IntegerStack);
+    public override bool Eval(IPushInterpreter interpreter) {
+      return Eval(interpreter.NameStack, interpreter.IntegerStack);
     }
   }
@@ -50,6 +51,6 @@
   [PushExpression(StackType.Exec, "EXEC.STACKDEPTH")]
   public class ExecStackdepthExpression : StackdepthExpression<Expression> {
-    public override void Eval(IPushInterpreter interpreter) {
-      Eval(interpreter.ExecStack, interpreter.IntegerStack);
+    public override bool Eval(IPushInterpreter interpreter) {
+      return Eval(interpreter.ExecStack, interpreter.IntegerStack);
     }
   }
@@ -57,6 +58,6 @@
   [PushExpression(StackType.Code, "CODE.STACKDEPTH")]
   public class CodeStackdepthExpression : StackdepthExpression<Expression> {
-    public override void Eval(IPushInterpreter interpreter) {
-      Eval(interpreter.CodeStack, interpreter.IntegerStack);
+    public override bool Eval(IPushInterpreter interpreter) {
+      return Eval(interpreter.CodeStack, interpreter.IntegerStack);
     }
   }
Index: branches/PushGP/HeuristicLab.PushGP/HeuristicLab.Problems.ProgramSynthesis/Push/Expressions/StatefulExpression.cs
===================================================================
--- branches/PushGP/HeuristicLab.PushGP/HeuristicLab.Problems.ProgramSynthesis/Push/Expressions/StatefulExpression.cs	(revision 14744)
+++ branches/PushGP/HeuristicLab.PushGP/HeuristicLab.Problems.ProgramSynthesis/Push/Expressions/StatefulExpression.cs	(revision 14744)
@@ -0,0 +1,43 @@
+﻿namespace HeuristicLab.Problems.ProgramSynthesis.Push.Expressions {
+  using HeuristicLab.Problems.ProgramSynthesis.Push.Data.Pool;
+
+  public abstract class StatefulExpression<T> : Expression
+  {
+    public readonly T State;
+
+    private int hashCode;
+    private int HashCode
+    {
+      get
+      {
+        if (hashCode == default(int)) hashCode = CalcHashCode();
+        return hashCode;
+      }
+    }
+
+    protected StatefulExpression(T state) {
+      this.State = state;
+    }
+
+    protected virtual int CalcHashCode() {
+      return this.State.GetHashCode();
+    }
+
+    public override bool Equals(object obj) {
+      if (ReferenceEquals(this, obj))
+        return true;
+
+      if (this.GetType() != obj.GetType())
+        return false;
+
+      var other = (StatefulExpression<T>)obj;
+
+      return ReferenceEquals(this.State, other.State) ||
+             this.GetHashCode() == other.GetHashCode();
+    }
+
+    public override int GetHashCode() {
+      return HashCode;
+    }
+  }
+}
Index: branches/PushGP/HeuristicLab.PushGP/HeuristicLab.Problems.ProgramSynthesis/Push/Expressions/SwapExpressions.cs
===================================================================
--- branches/PushGP/HeuristicLab.PushGP/HeuristicLab.Problems.ProgramSynthesis/Push/Expressions/SwapExpressions.cs	(revision 14733)
+++ branches/PushGP/HeuristicLab.PushGP/HeuristicLab.Problems.ProgramSynthesis/Push/Expressions/SwapExpressions.cs	(revision 14744)
@@ -10,9 +10,10 @@
   /// <typeparam name="T">Stacktype</typeparam>
   public abstract class SwapExpression<T> : StatelessExpression {
-    public void Eval(IStack<T> stack) {
+    public bool Eval(IStack<T> stack) {
       if (stack.Count < 2)
-        return;
+        return false;
 
       stack.Swap(2);
+      return true;
     }
   }
@@ -20,6 +21,6 @@
   [PushExpression(StackType.Integer, "INTEGER.SWAP")]
   public class IntegerSwapExpression : SwapExpression<long> {
-    public override void Eval(IPushInterpreter interpreter) {
-      Eval(interpreter.IntegerStack);
+    public override bool Eval(IPushInterpreter interpreter) {
+      return Eval(interpreter.IntegerStack);
     }
   }
@@ -27,6 +28,6 @@
   [PushExpression(StackType.Float, "FLOAT.SWAP")]
   public class FloatSwapExpression : SwapExpression<double> {
-    public override void Eval(IPushInterpreter interpreter) {
-      Eval(interpreter.FloatStack);
+    public override bool Eval(IPushInterpreter interpreter) {
+      return Eval(interpreter.FloatStack);
     }
   }
@@ -34,6 +35,6 @@
   [PushExpression(StackType.Boolean, "BOOLEAN.SWAP")]
   public class BooleanSwapExpression : SwapExpression<bool> {
-    public override void Eval(IPushInterpreter interpreter) {
-      Eval(interpreter.BooleanStack);
+    public override bool Eval(IPushInterpreter interpreter) {
+      return Eval(interpreter.BooleanStack);
     }
   }
@@ -41,6 +42,6 @@
   [PushExpression(StackType.Name, "NAME.SWAP")]
   public class NameSwapExpression : SwapExpression<string> {
-    public override void Eval(IPushInterpreter interpreter) {
-      Eval(interpreter.NameStack);
+    public override bool Eval(IPushInterpreter interpreter) {
+      return Eval(interpreter.NameStack);
     }
   }
@@ -48,6 +49,6 @@
   [PushExpression(StackType.Exec, "EXEC.SWAP")]
   public class ExecSwapExpression : SwapExpression<Expression> {
-    public override void Eval(IPushInterpreter interpreter) {
-      Eval(interpreter.ExecStack);
+    public override bool Eval(IPushInterpreter interpreter) {
+      return Eval(interpreter.ExecStack);
     }
   }
@@ -55,6 +56,6 @@
   [PushExpression(StackType.Code, "CODE.SWAP")]
   public class CodeSwapExpression : SwapExpression<Expression> {
-    public override void Eval(IPushInterpreter interpreter) {
-      Eval(interpreter.CodeStack);
+    public override bool Eval(IPushInterpreter interpreter) {
+      return Eval(interpreter.CodeStack);
     }
   }
Index: branches/PushGP/HeuristicLab.PushGP/HeuristicLab.Problems.ProgramSynthesis/Push/Expressions/YankDuplicateExpressions.cs
===================================================================
--- branches/PushGP/HeuristicLab.PushGP/HeuristicLab.Problems.ProgramSynthesis/Push/Expressions/YankDuplicateExpressions.cs	(revision 14733)
+++ branches/PushGP/HeuristicLab.PushGP/HeuristicLab.Problems.ProgramSynthesis/Push/Expressions/YankDuplicateExpressions.cs	(revision 14744)
@@ -10,17 +10,25 @@
   /// <typeparam name="T">Stacktype</typeparam>
   public abstract class YankDuplicateExpression<T> : StatelessExpression {
-    public void Eval(IStack<T> stack, IStack<long> integerStack) {
+    public bool Eval(IStack<T> stack, IStack<long> integerStack) {
       T item;
-      if (this.TryGetItem(stack, integerStack, out item)) stack.Push(item);
+      if (!this.TryGetItem(stack, integerStack, out item))
+        return false;
+
+      stack.Push(item);
+      return true;
     }
 
-    public void Eval(IStack<Expression> stack, IStack<long> integerStack) {
+    public bool Eval(IStack<Expression> stack, IStack<long> integerStack) {
       Expression item;
-      if (this.TryGetItem(stack, integerStack, out item)) stack.Push(item);
+      if (!this.TryGetItem(stack, integerStack, out item))
+        return false;
+
+      stack.Push(item);
+      return true;
     }
 
-    public void Eval(IStack<long> integerStack) {
+    public bool Eval(IStack<long> integerStack) {
       if ((integerStack.Count < 2) || (integerStack.Top > integerStack.Count - 2) ||
-          (integerStack.Top < 0)) return;
+          (integerStack.Top < 0)) return false;
 
       var index = (int)integerStack.Pop();
@@ -28,4 +36,5 @@
 
       integerStack.Push(item);
+      return true;
     }
 
@@ -48,6 +57,6 @@
   [PushExpression(StackType.Integer, "INTEGER.YANKDUP")]
   public class IntegerYankDuplicateExpression : YankDuplicateExpression<long> {
-    public override void Eval(IPushInterpreter interpreter) {
-      this.Eval(interpreter.IntegerStack);
+    public override bool Eval(IPushInterpreter interpreter) {
+      return this.Eval(interpreter.IntegerStack);
     }
   }
@@ -55,6 +64,6 @@
   [PushExpression(StackType.Float, "FLOAT.YANKDUP")]
   public class FloatYankDuplicateExpression : YankDuplicateExpression<double> {
-    public override void Eval(IPushInterpreter interpreter) {
-      this.Eval(interpreter.FloatStack, interpreter.IntegerStack);
+    public override bool Eval(IPushInterpreter interpreter) {
+      return this.Eval(interpreter.FloatStack, interpreter.IntegerStack);
     }
   }
@@ -62,6 +71,6 @@
   [PushExpression(StackType.Boolean, "BOOLEAN.YANKDUP")]
   public class BooleanYankDuplicateExpression : YankDuplicateExpression<bool> {
-    public override void Eval(IPushInterpreter interpreter) {
-      this.Eval(interpreter.BooleanStack, interpreter.IntegerStack);
+    public override bool Eval(IPushInterpreter interpreter) {
+      return this.Eval(interpreter.BooleanStack, interpreter.IntegerStack);
     }
   }
@@ -69,6 +78,6 @@
   [PushExpression(StackType.Name, "NAME.YANKDUP")]
   public class NameYankDuplicateExpression : YankDuplicateExpression<string> {
-    public override void Eval(IPushInterpreter interpreter) {
-      this.Eval(interpreter.NameStack, interpreter.IntegerStack);
+    public override bool Eval(IPushInterpreter interpreter) {
+      return this.Eval(interpreter.NameStack, interpreter.IntegerStack);
     }
   }
@@ -76,6 +85,6 @@
   [PushExpression(StackType.Exec, "EXEC.YANKDUP")]
   public class ExecYankDuplicateExpression : YankDuplicateExpression<Expression> {
-    public override void Eval(IPushInterpreter interpreter) {
-      this.Eval(interpreter.ExecStack, interpreter.IntegerStack);
+    public override bool Eval(IPushInterpreter interpreter) {
+      return this.Eval(interpreter.ExecStack, interpreter.IntegerStack);
     }
   }
@@ -83,6 +92,6 @@
   [PushExpression(StackType.Code, "CODE.YANKDUP")]
   public class CodeYankDuplicateExpression : YankDuplicateExpression<Expression> {
-    public override void Eval(IPushInterpreter interpreter) {
-      this.Eval(interpreter.CodeStack, interpreter.IntegerStack);
+    public override bool Eval(IPushInterpreter interpreter) {
+      return this.Eval(interpreter.CodeStack, interpreter.IntegerStack);
     }
   }
Index: branches/PushGP/HeuristicLab.PushGP/HeuristicLab.Problems.ProgramSynthesis/Push/Expressions/YankExpressions.cs
===================================================================
--- branches/PushGP/HeuristicLab.PushGP/HeuristicLab.Problems.ProgramSynthesis/Push/Expressions/YankExpressions.cs	(revision 14733)
+++ branches/PushGP/HeuristicLab.PushGP/HeuristicLab.Problems.ProgramSynthesis/Push/Expressions/YankExpressions.cs	(revision 14744)
@@ -10,13 +10,15 @@
   /// <typeparam name="T">Stacktype</typeparam>
   public abstract class YankExpression<T> : StatelessExpression {
-    public void Eval(IStack<T> stack, IStack<long> integerStack, int count = 1) {
-      if (integerStack.Count == 0) return;
+    public bool Eval(IStack<T> stack, IStack<long> integerStack, int count = 1) {
+      if (integerStack.Count == 0) return false;
 
       var index = integerStack.Top;
 
-      if ((index > stack.Count - count) || (index < 0) || (stack.Count < 2)) return;
+      if ((index > stack.Count - count) || (index < 0) || (stack.Count < 2)) return false;
 
       integerStack.Pop();
       stack.Yank((int)index);
+
+      return true;
     }
   }
@@ -24,6 +26,6 @@
   [PushExpression(StackType.Integer, "INTEGER.YANK")]
   public class IntegerYankExpression : YankExpression<long> {
-    public override void Eval(IPushInterpreter interpreter) {
-      this.Eval(interpreter.IntegerStack, interpreter.IntegerStack, 2);
+    public override bool Eval(IPushInterpreter interpreter) {
+      return this.Eval(interpreter.IntegerStack, interpreter.IntegerStack, 2);
     }
   }
@@ -31,6 +33,6 @@
   [PushExpression(StackType.Float, "FLOAT.YANK")]
   public class FloatYankExpression : YankExpression<double> {
-    public override void Eval(IPushInterpreter interpreter) {
-      this.Eval(interpreter.FloatStack, interpreter.IntegerStack);
+    public override bool Eval(IPushInterpreter interpreter) {
+      return this.Eval(interpreter.FloatStack, interpreter.IntegerStack);
     }
   }
@@ -38,6 +40,6 @@
   [PushExpression(StackType.Boolean, "BOOLEAN.YANK")]
   public class BooleanYankExpression : YankExpression<bool> {
-    public override void Eval(IPushInterpreter interpreter) {
-      this.Eval(interpreter.BooleanStack, interpreter.IntegerStack);
+    public override bool Eval(IPushInterpreter interpreter) {
+      return this.Eval(interpreter.BooleanStack, interpreter.IntegerStack);
     }
   }
@@ -45,6 +47,6 @@
   [PushExpression(StackType.Name, "NAME.YANK")]
   public class NameYankExpression : YankExpression<string> {
-    public override void Eval(IPushInterpreter interpreter) {
-      this.Eval(interpreter.NameStack, interpreter.IntegerStack);
+    public override bool Eval(IPushInterpreter interpreter) {
+      return this.Eval(interpreter.NameStack, interpreter.IntegerStack);
     }
   }
@@ -52,6 +54,6 @@
   [PushExpression(StackType.Exec, "EXEC.YANK")]
   public class ExecYankExpression : YankExpression<Expression> {
-    public override void Eval(IPushInterpreter interpreter) {
-      this.Eval(interpreter.ExecStack, interpreter.IntegerStack);
+    public override bool Eval(IPushInterpreter interpreter) {
+      return this.Eval(interpreter.ExecStack, interpreter.IntegerStack);
     }
   }
@@ -59,6 +61,6 @@
   [PushExpression(StackType.Code, "CODE.YANK")]
   public class CodeYankExpression : YankExpression<Expression> {
-    public override void Eval(IPushInterpreter interpreter) {
-      this.Eval(interpreter.CodeStack, interpreter.IntegerStack);
+    public override bool Eval(IPushInterpreter interpreter) {
+      return this.Eval(interpreter.CodeStack, interpreter.IntegerStack);
     }
   }
Index: branches/PushGP/HeuristicLab.PushGP/HeuristicLab.Problems.ProgramSynthesis/Push/Generators/CodeGenerator.cs
===================================================================
--- branches/PushGP/HeuristicLab.PushGP/HeuristicLab.Problems.ProgramSynthesis/Push/Generators/CodeGenerator.cs	(revision 14733)
+++ branches/PushGP/HeuristicLab.PushGP/HeuristicLab.Problems.ProgramSynthesis/Push/Generators/CodeGenerator.cs	(revision 14744)
@@ -6,5 +6,4 @@
   using HeuristicLab.Problems.ProgramSynthesis.Push.Configuration;
   using HeuristicLab.Problems.ProgramSynthesis.Push.Expressions;
-  using HeuristicLab.Problems.ProgramSynthesis.Push.Interpreter;
   using HeuristicLab.Random;
 
Index: branches/PushGP/HeuristicLab.PushGP/HeuristicLab.Problems.ProgramSynthesis/Push/Interpreter/IPushInterpreter.cs
===================================================================
--- branches/PushGP/HeuristicLab.PushGP/HeuristicLab.Problems.ProgramSynthesis/Push/Interpreter/IPushInterpreter.cs	(revision 14744)
+++ branches/PushGP/HeuristicLab.PushGP/HeuristicLab.Problems.ProgramSynthesis/Push/Interpreter/IPushInterpreter.cs	(revision 14744)
@@ -0,0 +1,44 @@
+﻿namespace HeuristicLab.Problems.ProgramSynthesis.Push.Interpreter {
+  using System.Collections.Generic;
+  using System.Threading;
+  using System.Threading.Tasks;
+  using Core;
+  using Expressions;
+
+  using HeuristicLab.Problems.ProgramSynthesis.Push.Configuration;
+
+  using Stack;
+
+  public interface IPushInterpreter {
+    IRandom Random { get; set; }
+
+    IStack<Expression> CodeStack { get; }
+    IStack<Expression> ExecStack { get; }
+    IStack<string> NameStack { get; }
+    IStack<bool> BooleanStack { get; }
+    IStack<long> IntegerStack { get; }
+    IStack<double> FloatStack { get; }
+
+    IDictionary<string, Expression> CustomExpressions { get; }
+
+    IReadonlyPushConfiguration Configuration { get; }
+
+    bool IsNameQuoteFlagSet { get; set; }
+
+    void Clear();
+    void Run(string code, bool stepwise = false);
+    void Run(Expression program, bool stepwise = false);
+    void Run(PushProgram program, bool stepwise = false);
+    Task RunAsync(PushProgram program, bool paused = false, CancellationToken token = default(CancellationToken));
+    Task RunAsync(Expression program, bool paused = false, CancellationToken token = default(CancellationToken));
+    Task RunAsync(string code, bool paused = false, CancellationToken token = default(CancellationToken));
+    Task AbortAndResetAsync();
+    Task AbortAsync();
+    Task PauseAsync();
+    void Resume();
+    Task ResumeAsync();
+
+    bool Step();
+    void PrintStacks();
+  }
+}
Index: branches/PushGP/HeuristicLab.PushGP/HeuristicLab.Problems.ProgramSynthesis/Push/Interpreter/PooledPushInterpreter.cs
===================================================================
--- branches/PushGP/HeuristicLab.PushGP/HeuristicLab.Problems.ProgramSynthesis/Push/Interpreter/PooledPushInterpreter.cs	(revision 14744)
+++ branches/PushGP/HeuristicLab.PushGP/HeuristicLab.Problems.ProgramSynthesis/Push/Interpreter/PooledPushInterpreter.cs	(revision 14744)
@@ -0,0 +1,22 @@
+﻿namespace HeuristicLab.Problems.ProgramSynthesis.Push.Interpreter {
+  using System;
+
+  using HeuristicLab.Core;
+  using HeuristicLab.Problems.ProgramSynthesis.Push.Configuration;
+
+  public class PooledPushInterpreter : PushInterpreter, IDisposable {
+
+    private readonly PushInterpreterPool pool;
+
+    public PooledPushInterpreter(PushInterpreterPool pool, PushConfiguration config, IRandom random = null)
+      : base(config, random) {
+      this.pool = pool;
+    }
+
+    public void Dispose() {
+      this.Reset();
+      this.Configuration = this.Configuration;
+      this.pool.Free(this);
+    }
+  }
+}
Index: branches/PushGP/HeuristicLab.PushGP/HeuristicLab.Problems.ProgramSynthesis/Push/Interpreter/PushInterpreter.cs
===================================================================
--- branches/PushGP/HeuristicLab.PushGP/HeuristicLab.Problems.ProgramSynthesis/Push/Interpreter/PushInterpreter.cs	(revision 14744)
+++ branches/PushGP/HeuristicLab.PushGP/HeuristicLab.Problems.ProgramSynthesis/Push/Interpreter/PushInterpreter.cs	(revision 14744)
@@ -0,0 +1,283 @@
+﻿namespace HeuristicLab.Problems.ProgramSynthesis.Push.Interpreter {
+  using System;
+  using System.Collections.Generic;
+  using System.Runtime.CompilerServices;
+  using System.Threading;
+  using System.Threading.Tasks;
+  using HeuristicLab.Core;
+  using HeuristicLab.Problems.ProgramSynthesis.Push.Configuration;
+  using HeuristicLab.Problems.ProgramSynthesis.Push.Data.Pool;
+  using HeuristicLab.Problems.ProgramSynthesis.Push.Expressions;
+  using HeuristicLab.Problems.ProgramSynthesis.Push.Parser;
+  using HeuristicLab.Problems.ProgramSynthesis.Push.Stack;
+  using HeuristicLab.Random;
+
+  public class PushInterpreter : IPushInterpreter {
+    private Task currentTask;
+
+    public PushInterpreter(IReadonlyPushConfiguration config = null, IRandom random = null) {
+      Random = random ?? new FastRandom();
+
+      Configuration = config ?? new PushConfiguration();
+
+      // setting the capacity of the stacks to max points ensures that there will be enough memory at runtime
+      ExecStack = new PushStack<Expression>(Configuration.EvalPushLimit);
+
+      CodeStack = new PushStack<Expression>(Configuration.EvalPushLimit) {
+        IsEnabled = Configuration.IsCodeStackEnabled
+      };
+
+      NameStack = new PushStack<string> {
+        IsEnabled = Configuration.IsNameStackEnabled
+      };
+      BooleanStack = new PushStack<bool> {
+        IsEnabled = Configuration.IsBooleanStackEnabled
+      };
+      IntegerStack = new PushStack<long> {
+        IsEnabled = Configuration.IsIntegerStackEnabled
+      };
+      FloatStack = new PushStack<double> {
+        IsEnabled = Configuration.IsFloatStackEnabled
+      };
+
+      CustomExpressions = new Dictionary<string, Expression>();
+    }
+
+    public PushInterpreter(int seed, IReadonlyPushConfiguration config = null)
+      : this(config, new FastRandom(seed)) {
+    }
+
+    public IRandom Random { get; set; }
+
+    public int ExecCounter { get; private set; }
+
+    public bool IsPaused { get; private set; }
+
+    public bool IsAborted { get; private set; }
+
+    public bool IsRunning
+    {
+      get
+      {
+        return !ExecStack.IsEmpty &&
+               !IsPaused &&
+               !IsAborted &&
+               (ExecCounter < Configuration.EvalPushLimit);
+      }
+    }
+
+    public bool IsCompleted
+    {
+      get
+      {
+        return ExecStack.Count == 0;
+      }
+    }
+
+    public bool CanStep
+    {
+      get
+      {
+        return !IsCompleted && !IsAborted && IsPaused;
+      }
+    }
+
+    public IReadonlyPushConfiguration Configuration { get; protected set; }
+
+    public IStack<Expression> CodeStack { get; private set; }
+
+    public IStack<Expression> ExecStack { get; private set; }
+
+    public IStack<string> NameStack { get; private set; }
+
+    public IStack<bool> BooleanStack { get; private set; }
+
+    public IStack<long> IntegerStack { get; private set; }
+
+    public IStack<double> FloatStack { get; private set; }
+
+    public IDictionary<string, Expression> CustomExpressions { get; private set; }
+
+    public bool IsNameQuoteFlagSet { get; set; }
+
+    public void Run(string code, bool stepwise = false) {
+      var program = PushParser.Parse(code);
+      Run(program, stepwise);
+    }
+
+    public Task RunAsync(string code, bool stepwise = false, CancellationToken token = default(CancellationToken)) {
+      var program = PushParser.Parse(code);
+
+      currentTask = RunAsync(program, stepwise, token);
+
+      return currentTask;
+    }
+
+    public async Task RunAsync(
+      PushProgram program,
+      bool stepwise = false,
+      CancellationToken token = default(CancellationToken)) {
+      var expression = new ExecExpandExpression(program);
+
+      await RunAsync(expression, stepwise, token);
+    }
+
+    public async Task RunAsync(
+      Expression program,
+      bool stepwise = false,
+      CancellationToken token = default(CancellationToken)) {
+      await Task.Run(() => Run(program, stepwise), token);
+    }
+
+    public void Run(PushProgram program, bool stepwise = false) {
+      var expression = new ExecExpandExpression(program);
+
+      Run(expression, stepwise);
+    }
+
+    public void Run(Expression program, bool stepwise = false) {
+      IsPaused = stepwise;
+
+      /* Push top expression so the loop is able to enter
+       * If the top expression is a single statement then the loop has nothing to do
+       * Otherwise the expand expression will be evaluated and pushes code onto the EXEC stack */
+      ExecStack.Push(program);
+
+      if (Configuration.TopLevelPushCode) CodeStack.Insert(0, program);
+
+      // run top expression
+      DoStep();
+
+      Interpret();
+    }
+
+    public async Task AbortAsync() {
+      if (IsAborted || IsCompleted) return;
+
+      IsAborted = true;
+
+      if (currentTask != null) await currentTask;
+    }
+
+    public async Task AbortAndResetAsync() {
+      await AbortAsync();
+      Reset();
+    }
+
+    public async Task PauseAsync() {
+      if (IsPaused || IsCompleted) return;
+
+      IsPaused = true;
+
+      if (currentTask != null) await currentTask;
+    }
+
+    public async Task ResumeAsync() {
+      if (IsPaused || !IsAborted) {
+        IsPaused = false;
+        await InterpretAsync();
+      } else await currentTask;
+    }
+
+    public void Resume() {
+      if (!IsPaused && IsAborted)
+        return;
+
+      IsPaused = false;
+      Interpret();
+    }
+
+    [MethodImpl(MethodImplOptions.AggressiveInlining)]
+    public bool Step() {
+      if (!CanStep) return false;
+
+      var successful = DoStep();
+      Finally();
+
+      return successful;
+    }
+
+    [MethodImpl(MethodImplOptions.AggressiveInlining)]
+    public void Step(int count) {
+      for (var i = 0; i < count; i++) Step();
+    }
+
+    public void PrintStacks() {
+      PrintStack("EXEC", ExecStack);
+      PrintStack("CODE", CodeStack);
+      PrintStack("NAME", NameStack);
+      PrintStack("BOOLEAN", BooleanStack);
+      PrintStack("FLOAT", FloatStack);
+      PrintStack("INTEGER", IntegerStack);
+
+      if (CustomExpressions.Count == 0) return;
+      Console.WriteLine("--------- Custom Expressions ---------");
+      foreach (var ce in CustomExpressions) {
+        Console.WriteLine("{0}: {1}", ce.Key, ce.Value);
+      }
+    }
+
+    /// <summary>
+    /// Clears stacks
+    /// </summary>
+    public void Reset() {
+      IsAborted = false;
+      IsPaused = false;
+      currentTask = null;
+
+      Clear();
+    }
+
+    /// <summary>
+    /// Clears stacks
+    /// </summary>
+    public void Clear() {
+      ExecCounter = 0;
+
+      ExecStack.Clear();
+      CodeStack.Clear();
+
+      NameStack.Clear();
+      BooleanStack.Clear();
+      IntegerStack.Clear();
+      FloatStack.Clear();
+
+      CustomExpressions.Clear();
+    }
+
+    [MethodImpl(MethodImplOptions.AggressiveInlining)]
+    private void Interpret() {
+      while (IsRunning) {
+        DoStep();
+        ExecCounter++;
+      }
+
+      Finally();
+    }
+
+    [MethodImpl(MethodImplOptions.AggressiveInlining)]
+    private void Finally() {
+      if (!IsCompleted)
+        return;
+
+      if (Configuration.TopLevelPopCode && (CodeStack.Count > 0))
+        CodeStack.Pop();
+    }
+
+    [MethodImpl(MethodImplOptions.AggressiveInlining)]
+    private bool DoStep() {
+      return ExecStack.Pop().Eval(this);
+    }
+
+    private Task InterpretAsync() {
+      currentTask = Task.Run(() => Interpret());
+
+      return currentTask;
+    }
+
+    private void PrintStack<T>(string name, IStack<T> stack) {
+      if (stack.IsEmpty) return;
+      Console.WriteLine("--------- {0} ---------\n{1}\n", name, stack);
+    }
+  }
+}
Index: branches/PushGP/HeuristicLab.PushGP/HeuristicLab.Problems.ProgramSynthesis/Push/Interpreter/PushInterpreterPool.cs
===================================================================
--- branches/PushGP/HeuristicLab.PushGP/HeuristicLab.Problems.ProgramSynthesis/Push/Interpreter/PushInterpreterPool.cs	(revision 14744)
+++ branches/PushGP/HeuristicLab.PushGP/HeuristicLab.Problems.ProgramSynthesis/Push/Interpreter/PushInterpreterPool.cs	(revision 14744)
@@ -0,0 +1,35 @@
+﻿namespace HeuristicLab.Problems.ProgramSynthesis.Push.Interpreter {
+  using System;
+
+  using HeuristicLab.Problems.ProgramSynthesis.Push.Data.Pool;
+  using HeuristicLab.Core;
+  using HeuristicLab.Problems.ProgramSynthesis.Push.Configuration;
+  using HeuristicLab.Random;
+
+  public class PushInterpreterPool {
+    private readonly ObjectPool<PooledPushInterpreter> pool;
+
+    public PushInterpreterPool(PushConfiguration config = null)
+      : this(Environment.ProcessorCount * 2, config) {
+    }
+
+    public PushInterpreterPool(int size, PushConfiguration config = null) {
+      this.PushGpConfiguration = config ?? new PushConfiguration();
+
+      this.pool = new ObjectPool<PooledPushInterpreter>(() => new PooledPushInterpreter(this, this.PushGpConfiguration), size);
+    }
+
+    public PushConfiguration PushGpConfiguration { get; private set; }
+
+    public PooledPushInterpreter GetInstance(IRandom random = null) {
+      var interpreter = this.pool.Allocate();
+      interpreter.Random = random ?? new FastRandom();
+
+      return interpreter;
+    }
+
+    public void Free(PooledPushInterpreter interpreter) {
+      this.pool.Free(interpreter);
+    }
+  }
+}
Index: branches/PushGP/HeuristicLab.PushGP/HeuristicLab.Problems.ProgramSynthesis/Push/Parser/PushParser.cs
===================================================================
--- branches/PushGP/HeuristicLab.PushGP/HeuristicLab.Problems.ProgramSynthesis/Push/Parser/PushParser.cs	(revision 14744)
+++ branches/PushGP/HeuristicLab.PushGP/HeuristicLab.Problems.ProgramSynthesis/Push/Parser/PushParser.cs	(revision 14744)
@@ -0,0 +1,92 @@
+﻿namespace HeuristicLab.Problems.ProgramSynthesis.Push.Parser {
+  using System.Collections.Generic;
+  using System.Globalization;
+
+  using HeuristicLab.Problems.ProgramSynthesis.Push.Expressions;
+
+  public static class PushParser {
+    private const string openBrace = "(";
+
+    private const string closeBrace = ")";
+
+    private const char delimiter = ' ';
+
+    private static readonly CultureInfo cultureInfo = CultureInfo.CreateSpecificCulture("en-US");
+
+    private static readonly char[] symbolTrim = { '\r', '\n' };
+
+    public static Expression Parse(string source, int startIndex = 0) {
+      var symbols = source.Split(delimiter);
+
+      int endIndex;
+      return Parse(symbols, 0, out endIndex);
+    }
+
+    private static Expression Parse(string[] symbols, int startIndex, out int endIndex) {
+      var expressions = new List<Expression>();
+
+      for (var i = startIndex; i < symbols.Length; i++) {
+        var symbol = symbols[i].TrimEnd(symbolTrim);
+
+        if (string.IsNullOrWhiteSpace(symbol)) continue;
+
+        switch (symbol) {
+          case openBrace:
+            var subExpression = Parse(symbols, i + 1, out endIndex);
+            expressions.Insert(0, subExpression);
+            i = endIndex;
+            continue;
+          case closeBrace:
+            endIndex = i;
+            return new ExecExpandExpression(expressions.ToArray());
+        }
+
+        // literal
+        Expression expression;
+        if (TryParseLiteral(symbol, out expression)) {
+          expressions.Insert(0, expression);
+          continue;
+        }
+
+        // expression
+        if (ExpressionTable.TryGetStatelessExpression(symbol, out expression)
+            || ExpressionTable.TryGetStatefullExpression(symbol, out expression)) {
+          expressions.Insert(0, expression);
+          continue;
+        }
+
+        // identifier - custom expression or named literals
+        expressions.Insert(0, new NameDefineXExecExpression(symbol));
+      }
+
+      endIndex = symbols.Length - 1;
+
+      return expressions.Count == 1
+        ? expressions[0]
+        : new ExecExpandExpression(expressions.ToArray());
+    }
+
+    private static bool TryParseLiteral(string word, out Expression expression) {
+      long longValue;
+      if (long.TryParse(word, out longValue)) {
+        expression = new IntegerPushExpression(longValue);
+        return true;
+      }
+
+      double floatValue;
+      if (double.TryParse(word, NumberStyles.Float, cultureInfo, out floatValue)) {
+        expression = new FloatPushExpression(floatValue);
+        return true;
+      }
+
+      bool booleanValue;
+      if (bool.TryParse(word, out booleanValue)) {
+        expression = new BooleanPushExpression(booleanValue);
+        return true;
+      }
+
+      expression = null;
+      return false;
+    }
+  }
+}
Index: branches/PushGP/HeuristicLab.PushGP/HeuristicLab.Problems.ProgramSynthesis/Push/Problem/PushEncoding.cs
===================================================================
--- branches/PushGP/HeuristicLab.PushGP/HeuristicLab.Problems.ProgramSynthesis/Push/Problem/PushEncoding.cs	(revision 14733)
+++ branches/PushGP/HeuristicLab.PushGP/HeuristicLab.Problems.ProgramSynthesis/Push/Problem/PushEncoding.cs	(revision 14744)
@@ -37,14 +37,14 @@
 
   public static class IndividualExtensionMethods {
-    public static PushProgram PushProgram(this Individual individual, IList<string> enabledExpressions) {
-      return MapToProgram(individual.IntegerVector(), enabledExpressions);
+    public static PushProgram PushProgram(this Individual individual, IReadOnlyList<string> enabledExpressions) {
+      return individual.IntegerVector().MapToPushProgram(enabledExpressions);
     }
 
-    private static PushProgram MapToProgram(IntegerVector vector, IList<string> enabledExpressions) {
+    public static PushProgram MapToPushProgram(this IntegerVector vector, IReadOnlyList<string> enabledExpressions) {
       var expressions = vector
         .Select(i => ExpressionTable.GetExpression(enabledExpressions[i]))
         .ToArray();
 
-      return new PushProgram(expressions);
+      return new Expressions.PushProgram(expressions);
     }
   }
Index: branches/PushGP/HeuristicLab.PushGP/HeuristicLab.Problems.ProgramSynthesis/Push/Problem/PushProblem.cs
===================================================================
--- branches/PushGP/HeuristicLab.PushGP/HeuristicLab.Problems.ProgramSynthesis/Push/Problem/PushProblem.cs	(revision 14733)
+++ branches/PushGP/HeuristicLab.PushGP/HeuristicLab.Problems.ProgramSynthesis/Push/Problem/PushProblem.cs	(revision 14744)
@@ -4,5 +4,4 @@
   using System.Collections.Generic;
   using System.Linq;
-  using BenchmarkSuite.Problems;
   using Common;
   using Configuration;
@@ -10,4 +9,6 @@
   using Encodings.IntegerVectorEncoding;
   using Expressions;
+
+  using HeuristicLab.BenchmarkSuite;
   using HeuristicLab.Data;
   using Instances;
@@ -21,5 +22,5 @@
   [Creatable(CreatableAttribute.Categories.GeneticProgrammingProblems, Priority = 180)]
   [Item("Push Problem", "")]
-  public class PushProblem : SingleObjectiveBasicProblem<IntegerVectorEncoding>, IProblemInstanceConsumer<Data> {
+  public class PushProblem : SingleObjectiveBasicProblem<IntegerVectorEncoding>, IProblemInstanceConsumer<IBenchmarkSuiteDataDescriptor> {
     [Storable]
     private readonly PushConfiguration config;
@@ -49,5 +50,4 @@
       this.InitEvents();
     }
-
 
     [StorableHook(HookType.AfterDeserialization)]
@@ -102,8 +102,8 @@
       var bounds = new IntMatrix(1, 3, new[] { "Training Start", "Training End | Test Start", "Test End" });
       bounds.ItemChanged += (s, e) => {
-        if (Data == null)
+        if (this.DataDescriptor == null)
           return;
 
-        var max = Data.OriginalTestCount + Data.OriginalTrainingCount - 1;
+        var max = this.DataDescriptor.OriginalTestCount + this.DataDescriptor.OriginalTrainingCount - 1;
         bounds[0, 0] = Math.Min(Math.Max(bounds[0, 0], 0), max);
         bounds[0, 2] = Math.Max(Math.Min(bounds[0, 2], max), 0);
@@ -174,5 +174,5 @@
         new IntValue(config.MaxPointsInRandomExpression)) { Hidden = true });
 
-      Parameters.Add(new ValueParameter<Data>(DataParameterName, DataParameterDescription));
+      Parameters.Add(new ValueParameter<IBenchmarkSuiteDataDescriptor>(DataParameterName, DataParameterDescription));
 
       Encoding.Bounds[0, 0] = 0;
@@ -204,10 +204,10 @@
     }
 
-    public IValueParameter<Data> DataParameter
-    {
-      get { return (IValueParameter<Data>)Parameters[DataParameterName]; }
-    }
-
-    public Data Data
+    public IValueParameter<IBenchmarkSuiteDataDescriptor> DataParameter
+    {
+      get { return (IValueParameter<IBenchmarkSuiteDataDescriptor>)Parameters[DataParameterName]; }
+    }
+
+    public IBenchmarkSuiteDataDescriptor DataDescriptor
     {
       get { return DataParameter.Value; }
@@ -394,6 +394,5 @@
       var bestIdx = Array.IndexOf(qualities, bestQuality);
       var bestIndividual = individuals[bestIdx];
-      var program = bestIndividual.PushProgram(config.EnabledExpressions);
-      var solution = new PushSolution(program, bestQuality, Data, random, pool);
+      var solution = new PushSolution(bestIndividual.IntegerVector(), bestQuality, DataDescriptor, random, config);
 
       if (!results.ContainsKey(bestSolutionResultName)) {
@@ -405,5 +404,6 @@
 
     public override double Evaluate(Individual individual, IRandom random) {
-      var program = individual.PushProgram(config.EnabledExpressions);
+
+      var program = individual.PushProgram(config.EnabledExpressions as IReadOnlyList<string>);
       var expandExpression = new ExecExpandExpression(program);
       var results = new List<double>();
@@ -411,5 +411,5 @@
       using (var interpreter = pool.GetInstance(random)) {
         for (var i = DataBounds[0, 0]; i < DataBounds[0, 1]; i++) {
-          var example = Data.Examples[i];
+          var example = this.DataDescriptor.Examples[i];
 
           interpreter.BooleanStack.Push(example.InputBoolean);
@@ -419,7 +419,7 @@
           interpreter.Run(expandExpression);
 
-          var diff = GetDiff(example.OutputInt, interpreter.IntegerStack, Data.WorstResult, LongDiffer) +
-                     GetDiff(example.OutputFloat, interpreter.FloatStack, Data.WorstResult, DoubleDiffer) +
-                     GetDiff(example.OutputBoolean, interpreter.BooleanStack, Data.WorstResult, BooleanDiffer);
+          var diff = GetDiff(example.OutputInt, interpreter.IntegerStack, this.DataDescriptor.WorstResult, LongDiffer) +
+                     GetDiff(example.OutputFloat, interpreter.FloatStack, this.DataDescriptor.WorstResult, DoubleDiffer) +
+                     GetDiff(example.OutputBoolean, interpreter.BooleanStack, this.DataDescriptor.WorstResult, BooleanDiffer);
 
           results.Add(diff);
@@ -466,11 +466,11 @@
     }
 
-    public void Load(Data data) {
-      Data = data;
-      BestKnownQuality = data.BestResult;
+    public void Load(IBenchmarkSuiteDataDescriptor descriptor) {
+      this.DataDescriptor = descriptor;
+      BestKnownQuality = descriptor.BestResult;
 
       DataBounds[0, 0] = 0;
-      DataBounds[0, 2] = Data.OriginalTrainingCount + Data.OriginalTestCount;
-      DataBounds[0, 1] = Data.OriginalTrainingCount;
+      DataBounds[0, 2] = this.DataDescriptor.OriginalTrainingCount + this.DataDescriptor.OriginalTestCount;
+      DataBounds[0, 1] = this.DataDescriptor.OriginalTrainingCount;
     }
   }
Index: branches/PushGP/HeuristicLab.PushGP/HeuristicLab.Problems.ProgramSynthesis/Push/Problem/PushSolution.cs
===================================================================
--- branches/PushGP/HeuristicLab.PushGP/HeuristicLab.Problems.ProgramSynthesis/Push/Problem/PushSolution.cs	(revision 14733)
+++ branches/PushGP/HeuristicLab.PushGP/HeuristicLab.Problems.ProgramSynthesis/Push/Problem/PushSolution.cs	(revision 14744)
@@ -1,31 +1,36 @@
 ﻿namespace HeuristicLab.Problems.ProgramSynthesis.Push.Problem {
-  using HeuristicLab.BenchmarkSuite.Problems;
+  using HeuristicLab.BenchmarkSuite;
   using HeuristicLab.Common;
   using HeuristicLab.Core;
+  using HeuristicLab.Encodings.IntegerVectorEncoding;
+  using HeuristicLab.Optimization;
   using HeuristicLab.Persistence.Default.CompositeSerializers.Storable;
   using HeuristicLab.Problems.ProgramSynthesis.Push.Configuration;
   using HeuristicLab.Problems.ProgramSynthesis.Push.Expressions;
-  using HeuristicLab.Problems.ProgramSynthesis.Push.Interpreter;
 
   [StorableClass]
   public class PushSolution : NamedItem {
+    [Storable]
     public readonly double Quality;
-    public readonly PushProgram Program;
-    public readonly Data Data;
+    [Storable]
+    public readonly IntegerVector IntegerVector;
+    [Storable]
+    public readonly IBenchmarkSuiteDataDescriptor DataDescriptor;
+    [Storable]
     public readonly IRandom Random;
-    public readonly PushInterpreterPool Pool;
+    [Storable]
+    public readonly IReadonlyPushConfiguration Config;
 
-    public PushSolution(PushProgram program, double quality, Data data,
-      IRandom random, PushInterpreterPool pool)
+    public PushSolution(IntegerVector integerVector, double quality, IBenchmarkSuiteDataDescriptor dataDescriptor, IRandom random, IReadonlyPushConfiguration config)
       : base("Solution", "A push solution.") {
-      Program = program;
+      IntegerVector = integerVector;
       Quality = quality;
-      Data = data;
+      DataDescriptor = dataDescriptor;
       Random = random;
-      Pool = pool;
+      Config = config;
     }
 
     public PushSolution(PushSolution origin, Cloner cloner) : base(origin, cloner) {
-      Program = origin.Program;
+      IntegerVector = origin.IntegerVector;
       Quality = origin.Quality;
     }
Index: branches/PushGP/HeuristicLab.PushGP/HeuristicLab.Problems.ProgramSynthesis/Push/Simplifier/RandomSimplifier.cs
===================================================================
--- branches/PushGP/HeuristicLab.PushGP/HeuristicLab.Problems.ProgramSynthesis/Push/Simplifier/RandomSimplifier.cs	(revision 14733)
+++ branches/PushGP/HeuristicLab.PushGP/HeuristicLab.Problems.ProgramSynthesis/Push/Simplifier/RandomSimplifier.cs	(revision 14744)
@@ -1,6 +1,6 @@
 ﻿namespace HeuristicLab.Problems.ProgramSynthesis.Push.Simplifier {
   using System;
+  using HeuristicLab.Core;
   using HeuristicLab.Problems.ProgramSynthesis.Push.Expressions;
-  using HeuristicLab.Core;
 
   public class RandomSimplifier : ISimplifier {
Index: branches/PushGP/HeuristicLab.PushGP/HeuristicLab.Problems.ProgramSynthesis/Push/Stack/PushStack.cs
===================================================================
--- branches/PushGP/HeuristicLab.PushGP/HeuristicLab.Problems.ProgramSynthesis/Push/Stack/PushStack.cs	(revision 14744)
+++ branches/PushGP/HeuristicLab.PushGP/HeuristicLab.Problems.ProgramSynthesis/Push/Stack/PushStack.cs	(revision 14744)
@@ -0,0 +1,280 @@
+﻿namespace HeuristicLab.Problems.ProgramSynthesis.Push.Stack {
+  using System;
+  using System.Collections;
+  using System.Collections.Generic;
+  using System.Linq;
+
+  /// <summary>
+  ///     While Push's stacks are generally treated as genuine stacks---that is, inclassions take their arguments from the
+  ///     tops of
+  ///     the stacks and push their results onto the tops of the stacks---a few inclassions (like YANK and SHOVE) do allow
+  ///     direct access
+  ///     to "deep" stack elements by means of integer indices. To this extent the stacks can be used as general, random
+  ///     access memory
+  ///     classures. This is one of the features that ensures the Turing-completeness of Push (another being the arbitrary
+  ///     name/value
+  ///     bindings supported by the NAME data type and DEFINE methods; see below).
+  /// </summary>
+  /// <typeparam name="T">The item type of the collection.</typeparam>
+  public class PushStack<T> : IStack<T> {
+    private const string Delimiter = " ";
+
+    private readonly List<T> data;
+
+    public PushStack(int capacity = 0) {
+      data = new List<T>(capacity);
+      IsEnabled = true;
+    }
+
+    public bool IsEnabled { get; set; }
+
+    public int Capacity
+    {
+      get
+      {
+        return this.data.Capacity;
+      }
+    }
+
+    public T Top
+    {
+      get
+      {
+        return this.data[this.Count - 1];
+      }
+    }
+
+    public T TopOrDefault
+    {
+      get
+      {
+        return this.Count > 0 ? this.data[this.Count - 1] : default(T);
+      }
+    }
+
+    public T Bottom
+    {
+      get
+      {
+        return this.data[0];
+      }
+    }
+
+    public T BottomOrDefault
+    {
+      get
+      {
+        return this.Count > 0 ? this.data[0] : default(T);
+      }
+    }
+
+    public int Count
+    {
+      get
+      {
+        return this.data.Count;
+      }
+    }
+
+    public bool IsEmpty
+    {
+      get
+      {
+        return this.Count == 0;
+      }
+    }
+
+    public bool IsReadOnly
+    {
+      get
+      {
+        return false;
+      }
+    }
+
+    public void Add(T item) {
+      this.Push(item);
+    }
+
+    public void Clear() {
+      this.data.Clear();
+    }
+
+    public bool Contains(T item) {
+      return this.data.Contains(item);
+    }
+
+    public void CopyTo(T[] array, int arrayIndex) {
+      this.data.CopyTo(array, arrayIndex);
+    }
+
+    public IEnumerator<T> GetEnumerator() {
+      return this.data.GetEnumerator();
+    }
+
+    public T ElementAt(int index) {
+      return this.data[index];
+    }
+
+    public T ReverseElementAt(int offset) {
+      return this.data[this.data.Count - 1 - offset];
+    }
+
+    public void SetTop(T value) {
+      this.data[this.Count - 1] = value;
+    }
+
+    public T this[int key]
+    {
+      get
+      {
+        return this.data[key];
+      }
+      set
+      {
+        this.data[key] = value;
+      }
+    }
+
+    public void Swap(int count) {
+      var top = this.Top;
+      var bottomIndex = this.Count - count;
+
+      for (var i = this.Count - 1; i > bottomIndex; i--) this.data[i] = this.data[i - 1];
+
+      this.data[bottomIndex] = top;
+    }
+
+    public void Yank(int index) {
+      if (index == this.Count - 1) return;
+
+      var item = this.ElementAt(index);
+      this.data.RemoveAt(index);
+      this.data.Add(item);
+    }
+
+    public T Pop() {
+      var value = this.data[this.Count - 1];
+      this.data.RemoveAt(this.Count - 1);
+
+      return value;
+    }
+
+    public T[] Pop(int count) {
+      var items = Peek(count);
+      this.Remove(count);
+
+      return items;
+    }
+
+    public T Peek() {
+      return Top;
+    }
+
+    public T[] Peek(int count) {
+      var startIndex = this.Count - count;
+
+      var items = new T[count];
+      this.data.CopyTo(startIndex, items, 0, count);
+
+      return items;
+    }
+
+    public void Push(T item) {
+      if (!IsEnabled) return;
+
+      this.data.Add(item);
+    }
+
+    public void PushResult(int count, Func<T[], T> templateFunc) {
+      if (!IsEnabled) return;
+
+      var startIndex = this.Count - count;
+      var items = new T[count];
+
+      this.data.CopyTo(startIndex, items, 0, count);
+      this.Remove(count - 1);
+
+      this.data[this.Count - 1] = templateFunc(items);
+    }
+
+    public void Push(params T[] items) {
+      if (!IsEnabled) return;
+
+      for (var i = 0; i < items.Length; i++) this.data.Add(items[i]);
+      //this.data.AddRange(items);
+    }
+
+    public void ReversePush(params T[] items) {
+      for (var i = items.Length - 1; i >= 0; i--) this.data.Add(items[i]);
+    }
+
+    public void Push(IReadOnlyList<T> items) {
+      if (!IsEnabled) return;
+
+      for (var i = 0; i < items.Count; i++) this.data.Add(items[i]);
+      //this.data.AddRange(items);
+    }
+
+    public void Insert(int index, T item) {
+      if (!IsEnabled) return;
+
+      this.data.Insert(index, item);
+    }
+
+    public void Insert(int index, params T[] items) {
+      if (!IsEnabled) return;
+
+      this.data.InsertRange(index, items);
+    }
+
+    public void Insert(int index, IEnumerable<T> items) {
+      if (!IsEnabled) return;
+
+      this.data.InsertRange(index, items);
+    }
+
+    public bool Remove(T item) {
+      var index = this.Count - 1;
+      if ((this.Count > 0) && this.data[index].Equals(item)) {
+        this.data.RemoveAt(index);
+        return true;
+      }
+      return false;
+    }
+
+    public void RemoveTop() {
+      this.data.RemoveAt(this.Count - 1);
+    }
+
+    public void Remove(int count) {
+      for (var i = 0; i < count; i++) this.data.RemoveAt(this.Count - 1);
+    }
+
+    public void RemoveAt(int index) {
+      this.data.RemoveAt(index);
+    }
+
+    public void RemoveAt(int index, int count) {
+      this.data.RemoveRange(index, count);
+    }
+
+    public bool TryPop(out T item) {
+      if (this.Count > 0) {
+        item = this.Pop();
+        return true;
+      }
+      item = default(T);
+      return false;
+    }
+
+    IEnumerator IEnumerable.GetEnumerator() {
+      return data.GetEnumerator();
+    }
+
+    public override string ToString() {
+      var data = this.data as IEnumerable<T>;
+      return string.Join(Delimiter, data.Reverse());
+    }
+  }
+}
Index: branches/PushGP/HeuristicLab.PushGP/HeuristicLab.Problems.ProgramSynthesis/Push/Views/PushProgramDebuggerView.Designer.cs
===================================================================
--- branches/PushGP/HeuristicLab.PushGP/HeuristicLab.Problems.ProgramSynthesis/Push/Views/PushProgramDebuggerView.Designer.cs	(revision 14733)
+++ branches/PushGP/HeuristicLab.PushGP/HeuristicLab.Problems.ProgramSynthesis/Push/Views/PushProgramDebuggerView.Designer.cs	(revision 14744)
@@ -26,5 +26,5 @@
       System.ComponentModel.ComponentResourceManager resources = new System.ComponentModel.ComponentResourceManager(typeof(PushProgramDebuggerView));
       this.execGroupBox = new System.Windows.Forms.GroupBox();
-      this.execList = new System.Windows.Forms.ListBox();
+      this.execList = new System.Windows.Forms.ListView();
       this.integerGroupBox = new System.Windows.Forms.GroupBox();
       this.integerList = new System.Windows.Forms.ListBox();
@@ -44,4 +44,5 @@
       this.stepWidthBox = new System.Windows.Forms.NumericUpDown();
       this.runButton = new System.Windows.Forms.Button();
+      this.skipNoopsCheckBox = new System.Windows.Forms.CheckBox();
       ((System.ComponentModel.ISupportInitialize)(this.errorProvider)).BeginInit();
       this.execGroupBox.SuspendLayout();
@@ -83,11 +84,11 @@
             | System.Windows.Forms.AnchorStyles.Left)
             | System.Windows.Forms.AnchorStyles.Right)));
-      this.execList.FormattingEnabled = true;
-      this.execList.HorizontalScrollbar = true;
-      this.execList.Location = new System.Drawing.Point(7, 20);
+      this.execList.Location = new System.Drawing.Point(3, 16);
       this.execList.Name = "execList";
-      this.execList.SelectionMode = System.Windows.Forms.SelectionMode.None;
-      this.execList.Size = new System.Drawing.Size(231, 602);
-      this.execList.TabIndex = 0;
+      this.execList.Size = new System.Drawing.Size(235, 605);
+      this.execList.TabIndex = 1;
+      this.execList.UseCompatibleStateImageBehavior = false;
+      this.execList.View = System.Windows.Forms.View.List;
+      this.execList.VirtualMode = true;
       //
       // integerGroupBox
@@ -254,6 +255,5 @@
       // exampleComboBox
       //
-      this.exampleComboBox.Anchor = ((System.Windows.Forms.AnchorStyles)((((System.Windows.Forms.AnchorStyles.Top | System.Windows.Forms.AnchorStyles.Bottom)
-            | System.Windows.Forms.AnchorStyles.Left)
+      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;
@@ -325,8 +325,22 @@
       this.runButton.UseVisualStyleBackColor = true;
       //
+      // skipNoopsCheckBox
+      //
+      this.skipNoopsCheckBox.Anchor = ((System.Windows.Forms.AnchorStyles)((System.Windows.Forms.AnchorStyles.Bottom | System.Windows.Forms.AnchorStyles.Left)));
+      this.skipNoopsCheckBox.AutoSize = true;
+      this.skipNoopsCheckBox.Checked = true;
+      this.skipNoopsCheckBox.CheckState = System.Windows.Forms.CheckState.Checked;
+      this.skipNoopsCheckBox.Location = new System.Drawing.Point(150, 704);
+      this.skipNoopsCheckBox.Name = "skipNoopsCheckBox";
+      this.skipNoopsCheckBox.Size = new System.Drawing.Size(81, 17);
+      this.skipNoopsCheckBox.TabIndex = 11;
+      this.skipNoopsCheckBox.Text = "Skip NOOP";
+      this.skipNoopsCheckBox.UseVisualStyleBackColor = true;
+      //
       // PushProgramDebuggerView
       //
       this.AutoScaleDimensions = new System.Drawing.SizeF(6F, 13F);
       this.AutoScaleMode = System.Windows.Forms.AutoScaleMode.Font;
+      this.Controls.Add(this.skipNoopsCheckBox);
       this.Controls.Add(this.runButton);
       this.Controls.Add(this.stepWidthBox);
@@ -348,4 +362,5 @@
       this.Controls.SetChildIndex(this.stepWidthBox, 0);
       this.Controls.SetChildIndex(this.runButton, 0);
+      this.Controls.SetChildIndex(this.skipNoopsCheckBox, 0);
       ((System.ComponentModel.ISupportInitialize)(this.errorProvider)).EndInit();
       this.execGroupBox.ResumeLayout(false);
@@ -370,5 +385,4 @@
     private System.Windows.Forms.GroupBox booleanGroupBox;
     private System.Windows.Forms.GroupBox nameGroupBox;
-    private System.Windows.Forms.ListBox execList;
     private System.Windows.Forms.ListBox integerList;
     private System.Windows.Forms.ListBox floatList;
@@ -383,4 +397,6 @@
     private System.Windows.Forms.NumericUpDown stepWidthBox;
     private System.Windows.Forms.Button runButton;
+    private System.Windows.Forms.CheckBox skipNoopsCheckBox;
+    private System.Windows.Forms.ListView execList;
   }
 }
Index: branches/PushGP/HeuristicLab.PushGP/HeuristicLab.Problems.ProgramSynthesis/Push/Views/PushProgramDebuggerView.cs
===================================================================
--- branches/PushGP/HeuristicLab.PushGP/HeuristicLab.Problems.ProgramSynthesis/Push/Views/PushProgramDebuggerView.cs	(revision 14733)
+++ branches/PushGP/HeuristicLab.PushGP/HeuristicLab.Problems.ProgramSynthesis/Push/Views/PushProgramDebuggerView.cs	(revision 14744)
@@ -8,14 +8,21 @@
   using System.Linq;
 
-  using HeuristicLab.BenchmarkSuite.Problems;
+  using HeuristicLab.BenchmarkSuite;
   using HeuristicLab.Problems.ProgramSynthesis.Push.Expressions;
   using HeuristicLab.Problems.ProgramSynthesis.Push.Interpreter;
   using HeuristicLab.Problems.ProgramSynthesis.Push.Problem;
+  using HeuristicLab.Random;
 
   [View("Push Program Debugger")]
   [Content(typeof(PushSolution), true)]
   public partial class PushProgramDebuggerView : NamedItemView {
+    private const string Separator = ", ";
+    private PushProgram program;
+
+    private ListViewItem[] execListCache; //array to cache items for the virtual list
+    private int firstExecListItemIndex; //stores the index of the first item in the cache
+
     private const string exampleSplitter = " => ";
-    private PushGpInterpreter interpreter;
+    private PushInterpreter interpreter;
 
     public PushProgramDebuggerView() {
@@ -28,9 +35,80 @@
       resetButton.Click += ResetButtonClick;
       stepButton.Click += StepButtonClick;
-    }
-
-    protected override void OnReadOnlyChanged() {
-      base.OnReadOnlyChanged();
-
+
+      execList.RetrieveVirtualItem += ExecListRetrieveVirtualItem;
+      execList.CacheVirtualItems += ExecListCacheVirtualItems;
+
+      execList.View = View.Details;
+      execList.HeaderStyle = ColumnHeaderStyle.Nonclickable;
+      execList.AutoResizeColumns(ColumnHeaderAutoResizeStyle.None);
+      execList.Columns.Add(new ColumnHeader { Width = execList.Width - 40 });
+      execList.VirtualMode = true;
+      execList.VirtualListSize = 100;
+    }
+
+    private void ExecListCacheVirtualItems(object sender, CacheVirtualItemsEventArgs e) {
+      //We've gotten a request to refresh the cache.
+      //First check if it's really neccesary.
+      if (execListCache != null &&
+        e.StartIndex >= firstExecListItemIndex &&
+        e.EndIndex <= firstExecListItemIndex + execListCache.Length) {
+        //If the newly requested cache is a subset of the old cache,
+        //no need to rebuild everything, so do nothing.
+        return;
+      }
+
+      //Now we need to rebuild the cache.
+      UpdateListCache(e.StartIndex, e.EndIndex);
+    }
+
+    private void ExecListRetrieveVirtualItem(object sender, RetrieveVirtualItemEventArgs e) {
+      //check to see if the requested item is currently in the cache
+      if (execListCache == null ||
+        e.ItemIndex < firstExecListItemIndex ||
+        e.ItemIndex >= firstExecListItemIndex + execListCache.Length) {
+        UpdateListCache(e.ItemIndex, execList.VirtualListSize);
+      }
+
+      e.Item = e.ItemIndex >= firstExecListItemIndex && e.ItemIndex < firstExecListItemIndex + execListCache.Length
+          ? execListCache[e.ItemIndex - firstExecListItemIndex]
+          : e.Item = new ListViewItem();
+    }
+
+    private void UpdateListCache(int startIndex, int endIndex) {
+      if (interpreter == null) {
+        execListCache = new ListViewItem[0];
+        return;
+      }
+
+      this.firstExecListItemIndex = startIndex;
+      var length = Math.Min(endIndex - startIndex + 1, interpreter.ExecStack.Count); //indexes are inclusive
+      this.execListCache = new ListViewItem[length];
+
+      var expressions = this.interpreter.ExecStack.Peek(length);
+
+      //Fill the cache with the appropriate ListViewItems.
+      for (var i = 0; i < length; i++)
+        this.execListCache[i] = new ListViewItem(expressions[length - 1 - i].ToString());
+
+      execList.AutoResizeColumns(ColumnHeaderAutoResizeStyle.None);
+      execList.AutoResizeColumns(ColumnHeaderAutoResizeStyle.ColumnContent);
+    }
+
+    //protected override void OnEnabledChanged(EventArgs e) {
+    //  SetReadonlyFields();
+    //}
+
+    //protected override void OnReadOnlyChanged() {
+    //  base.OnReadOnlyChanged();
+
+    //  SetReadonlyFields();
+    //}
+
+    //protected override void SetEnabledStateOfControls()
+    //{
+    //  SetReadonlyFields();
+    //}
+
+    private void SetReadonlyFields() {
       exampleComboBox.Enabled = !ReadOnly;
       execList.Enabled = !ReadOnly;
@@ -40,4 +118,9 @@
       floatList.Enabled = !ReadOnly;
       booleanList.Enabled = !ReadOnly;
+      stepButton.Enabled = !ReadOnly;
+      runButton.Enabled = !ReadOnly;
+      resetButton.Enabled = !ReadOnly;
+      skipNoopsCheckBox.Enabled = !ReadOnly;
+      stepWidthBox.Enabled = !ReadOnly;
     }
 
@@ -54,11 +137,7 @@
 
     private void SyncExecList() {
-      execList.Items.RemoveAt(0);
-
-      if (!interpreter.ExecStack.SequenceEqual(execList.Items.Cast<Expression>().Reverse())) {
-        UpdateExecList();
-      }
-
-      this.execGroupBox.Text = string.Format("Exec [{0}]", this.execList.Items.Count);
+      UpdateExecList();
+
+      this.execGroupBox.Text = string.Format("Exec [{0}]", this.interpreter.ExecStack.Count);
     }
 
@@ -70,5 +149,12 @@
 
       for (var i = 0; i < count; i++) {
-        interpreter.Step();
+        if (skipNoopsCheckBox.Checked) {
+          bool noop;
+
+          do {
+            noop = !interpreter.Step();
+          }
+          while (interpreter.CanStep && noop);
+        } else interpreter.Step();
       }
 
@@ -114,5 +200,5 @@
       interpreter.Clear();
 
-      var example = Content.Data.Examples[this.exampleComboBox.SelectedIndex];
+      var example = Content.DataDescriptor.Examples[this.exampleComboBox.SelectedIndex];
 
       interpreter.BooleanStack.Push(example.InputBoolean);
@@ -120,5 +206,5 @@
       interpreter.FloatStack.Push(example.InputFloat);
 
-      interpreter.Run(Content.Program, true);
+      interpreter.Run(program, true);
       stepWidthBox.Maximum = interpreter.ExecStack.Count;
 
@@ -131,7 +217,9 @@
       if (Content == null) return;
 
-      interpreter = Content.Pool.GetInstance(Content.Random);
-
-      UpdateExamples(Content.Data);
+      var random = Content.Random ?? new FastRandom();
+      interpreter = new PushInterpreter(Content.Config, random);
+      program = Content.IntegerVector.MapToPushProgram(Content.Config.EnabledExpressions);
+
+      UpdateExamples(Content.DataDescriptor);
 
       if (this.exampleComboBox.SelectedIndex < 0) {
@@ -151,8 +239,6 @@
 
     private void UpdateExecList() {
-      execList.Items.Clear();
-
-      foreach (var item in interpreter.ExecStack.Reverse())
-        this.execList.Items.Add(item);
+      UpdateListCache(0, execList.VirtualListSize);
+      execList.Update();
 
       this.execGroupBox.Text = string.Format("Exec [{0}]", this.execList.Items.Count);
@@ -226,10 +312,11 @@
     }
 
-    private void UpdateExamples(Data data) {
-      const string seperator = ", ";
+    private void UpdateExamples(IBenchmarkSuiteDataDescriptor data) {
+      if (data == null) return;
+
       var stringRepresentations = data.Examples.Select(e =>
-        string.Join(seperator, e.InputArgs) +
+        string.Join(Separator, e.InputArgs) +
         exampleSplitter +
-        string.Join(seperator, e.OutputArgs));
+        string.Join(Separator, e.OutputArgs));
 
       exampleComboBox.Items.Clear();
Index: branches/PushGP/HeuristicLab.PushGP/HeuristicLab.Problems.ProgramSynthesis/Push/Views/PushProgramDebuggerView.resx
===================================================================
--- branches/PushGP/HeuristicLab.PushGP/HeuristicLab.Problems.ProgramSynthesis/Push/Views/PushProgramDebuggerView.resx	(revision 14733)
+++ branches/PushGP/HeuristicLab.PushGP/HeuristicLab.Problems.ProgramSynthesis/Push/Views/PushProgramDebuggerView.resx	(revision 14744)
@@ -1,16 +1,16 @@
 ﻿<?xml version="1.0" encoding="utf-8"?>
 <root>
-  <!-- 
-    Microsoft ResX Schema 
-    
+  <!--
+    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 
+
+    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>
@@ -27,34 +27,34 @@
         <comment>This is a comment</comment>
     </data>
-                
-    There are any number of "resheader" rows that contain simple 
+
+    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 
+
+    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 
+
+    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 
+
+    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 
+    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 
+    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 
+    value   : The object must be serialized into a byte array
             : using a System.ComponentModel.TypeConverter
             : and then encoded with base64 encoding.
Index: branches/PushGP/HeuristicLab.PushGP/HeuristicLab.Tests/Benchmark/ProblemTests.cs
===================================================================
--- branches/PushGP/HeuristicLab.PushGP/HeuristicLab.Tests/Benchmark/ProblemTests.cs	(revision 14733)
+++ branches/PushGP/HeuristicLab.PushGP/HeuristicLab.Tests/Benchmark/ProblemTests.cs	(revision 14744)
@@ -9,4 +9,5 @@
   using HeuristicLab.Problems.Instances;
   using HeuristicLab.Problems.ProgramSynthesis.Push.Configuration;
+  using HeuristicLab.Problems.ProgramSynthesis.Push.Data.Pool;
   using HeuristicLab.Problems.ProgramSynthesis.Push.Expressions;
   using HeuristicLab.Problems.ProgramSynthesis.Push.Generators;
Index: branches/PushGP/HeuristicLab.PushGP/HeuristicLab.Tests/Interpreter/ExpressionTest.cs
===================================================================
--- branches/PushGP/HeuristicLab.PushGP/HeuristicLab.Tests/Interpreter/ExpressionTest.cs	(revision 14733)
+++ branches/PushGP/HeuristicLab.PushGP/HeuristicLab.Tests/Interpreter/ExpressionTest.cs	(revision 14744)
@@ -6,5 +6,5 @@
 
   public class ExpressionTest {
-    protected PushGpInterpreter interpreter;
+    protected PushInterpreter interpreter;
 
     protected PushConfiguration configuration = new PushConfiguration { TopLevelPushCode = false };
@@ -12,5 +12,5 @@
     [TestInitialize]
     public void BeforeTest() {
-      this.interpreter = new PushGpInterpreter(configuration);
+      this.interpreter = new PushInterpreter(configuration);
     }
 
Index: branches/PushGP/HeuristicLab.PushGP/PushGP.Cli/Program.cs
===================================================================
--- branches/PushGP/HeuristicLab.PushGP/PushGP.Cli/Program.cs	(revision 14733)
+++ branches/PushGP/HeuristicLab.PushGP/PushGP.Cli/Program.cs	(revision 14744)
@@ -18,7 +18,7 @@
       //Stepwise().Wait();
       //PerformanceTestInterpreter();
-      PerformanceParallelTestInterpreter();
+      //PerformanceParallelTestInterpreter();
       //PerformanceTestCodeGenerator();
-      //TestRobustness();
+      TestRobustness();
       //TestPool();
       //TestPoolPerformance();
@@ -36,5 +36,5 @@
 
     static async Task EvaluateStepwise(string code) {
-      var interpreter = new PushGpInterpreter(new PushConfiguration {
+      var interpreter = new PushInterpreter(new PushConfiguration {
         TopLevelPushCode = false
       });
@@ -60,5 +60,5 @@
 
     static void SimpleTest() {
-      var interpreter = new PushGpInterpreter();
+      var interpreter = new PushInterpreter();
 
       interpreter.Run("5 INTEGER.DUP INTEGER.+");
@@ -68,5 +68,5 @@
 
     static async Task Stepwise() {
-      var interpreter = new PushGpInterpreter();
+      var interpreter = new PushInterpreter();
 
       interpreter.RunAsync("( 0 2 CODE.QUOTE ( 1 INTEGER.+ 0 3 CODE.QUOTE ( 1 INTEGER.+ INTEGER.* ) CODE.DO*RANGE INTEGER.+ ) CODE.DO*RANGE )", true).Wait();
@@ -92,5 +92,5 @@
       var program = PushParser.Parse("( 5 INTEGER.DUP INTEGER.+ )");
 
-      var interpreter = new PushGpInterpreter();
+      var interpreter = new PushInterpreter();
       var sw = new Stopwatch();
 
@@ -149,14 +149,14 @@
       var parallelism = Environment.ProcessorCount;
       var maxProgramSizeLimit = 1024;
-      var partitionSize = 1000;
+      var partitionSize = 10000;
       var execCounters = new int[parallelism];
 
       var config = new PushConfiguration {
         EvalPushLimit = 4096,
-        //IsCodeStackEnabled = false,
-        IsExecStackEnable = false,
-        IsBooleanStackEnabled = false,
-        IsFloatStackEnabled = false,
-        IsIntegerStackEnabled = false,
+        IsCodeStackEnabled = false,
+        //IsExecStackEnable = false,
+        //IsBooleanStackEnabled = false,
+        //IsFloatStackEnabled = false,
+        //IsIntegerStackEnabled = false,
         IsNameStackEnabled = false,
       };
@@ -166,5 +166,5 @@
       sw.Start();
       Parallel.For(0, parallelism, i => {
-        var random = new FastRandom(1337);
+        var random = new MersenneTwister(1337);
         using (var interpreter = pool.GetInstance(random)) {
           for (var j = 0; j < partitionSize; j++) {
@@ -186,5 +186,5 @@
     static void TestPool() {
       var pool = new PushInterpreterPool();
-      var normal = new PushGpInterpreter();
+      var normal = new PushInterpreter();
       int id;
 
@@ -210,5 +210,5 @@
       sw.Start();
       for (var i = 0; i < iterations; i++) {
-        var interpreter = new PushGpInterpreter();
+        var interpreter = new PushInterpreter();
         interpreter.Clear();
       }
@@ -230,7 +230,7 @@
 
     static void TestSimplifier() {
-      var interpreter = new PushGpInterpreter();
+      var interpreter = new PushInterpreter();
       var program = PushParser.Parse("( 5 INTEGER.DUP FLOAT.+ INTEGER.+ )") as ExecExpandExpression;
-      var simplifier = new RandomSimplifier() { Trys = 10 };
+      var simplifier = new RandomSimplifier { Trys = 10 };
       var random = new FastRandom(1337);
 
Index: branches/PushGP/HeuristicLab.PushGP/PushGp.sln
===================================================================
--- branches/PushGP/HeuristicLab.PushGP/PushGp.sln	(revision 14733)
+++ branches/PushGP/HeuristicLab.PushGP/PushGp.sln	(revision 14744)
@@ -11,4 +11,6 @@
 EndProject
 Project("{FAE04EC0-301F-11D3-BF4B-00C04F79EFBC}") = "HeuristicLab.Problems.ProgramSynthesis", "HeuristicLab.Problems.ProgramSynthesis\HeuristicLab.Problems.ProgramSynthesis.csproj", "{5C93448C-47E3-4C3F-B1D0-EE62A48C3204}"
+EndProject
+Project("{FAE04EC0-301F-11D3-BF4B-00C04F79EFBC}") = "TestPooling", "TestPooling\TestPooling.csproj", "{B184A849-1403-4F5F-96F8-952C6599A7C0}"
 EndProject
 Global
@@ -34,4 +36,8 @@
 		{5C93448C-47E3-4C3F-B1D0-EE62A48C3204}.Release|Any CPU.ActiveCfg = Release|Any CPU
 		{5C93448C-47E3-4C3F-B1D0-EE62A48C3204}.Release|Any CPU.Build.0 = Release|Any CPU
+		{B184A849-1403-4F5F-96F8-952C6599A7C0}.Debug|Any CPU.ActiveCfg = Debug|Any CPU
+		{B184A849-1403-4F5F-96F8-952C6599A7C0}.Debug|Any CPU.Build.0 = Debug|Any CPU
+		{B184A849-1403-4F5F-96F8-952C6599A7C0}.Release|Any CPU.ActiveCfg = Release|Any CPU
+		{B184A849-1403-4F5F-96F8-952C6599A7C0}.Release|Any CPU.Build.0 = Release|Any CPU
 	EndGlobalSection
 	GlobalSection(SolutionProperties) = preSolution
Index: branches/PushGP/HeuristicLab.PushGP/TestPooling/App.config
===================================================================
--- branches/PushGP/HeuristicLab.PushGP/TestPooling/App.config	(revision 14744)
+++ branches/PushGP/HeuristicLab.PushGP/TestPooling/App.config	(revision 14744)
@@ -0,0 +1,6 @@
+﻿<?xml version="1.0" encoding="utf-8" ?>
+<configuration>
+    <startup> 
+        <supportedRuntime version="v4.0" sku=".NETFramework,Version=v4.5.2" />
+    </startup>
+</configuration>
Index: branches/PushGP/HeuristicLab.PushGP/TestPooling/Pool/ManagedPool.cs
===================================================================
--- branches/PushGP/HeuristicLab.PushGP/TestPooling/Pool/ManagedPool.cs	(revision 14744)
+++ branches/PushGP/HeuristicLab.PushGP/TestPooling/Pool/ManagedPool.cs	(revision 14744)
@@ -0,0 +1,58 @@
+﻿using System.Collections.Generic;
+
+namespace TestPooling.Pool {
+  using System;
+  using System.Collections.Concurrent;
+  using System.Linq;
+
+  public class ManagedPool<T> : IDisposable where T : class {
+
+    private static readonly ConcurrentStack<LinkedList<T>> Pool = new ConcurrentStack<LinkedList<T>>();
+    private readonly Func<T> Factory;
+    public readonly int PartitionSize;
+
+    private readonly IList<LinkedList<T>> partitions = new List<LinkedList<T>>();
+    private LinkedList<T> currentPartition;
+    private LinkedListNode<T> currentNode;
+
+    private int entryIndex = 0;
+
+    public ManagedPool(int partitionSize, Func<T> factory) {
+      PartitionSize = partitionSize;
+      Factory = factory;
+    }
+
+    public T Get() {
+      if (currentPartition == null || entryIndex == PartitionSize) {
+        currentPartition = GetPartition();
+        currentNode = currentPartition.First;
+        entryIndex = 0;
+
+        partitions.Add(currentPartition);
+      }
+
+      T entry;
+      if (currentNode == null) {
+        entry = Factory();
+        currentPartition.AddLast(entry);
+      } else {
+        entry = currentNode.Value;
+        currentNode = currentNode.Next;
+      }
+
+      entryIndex++;
+
+      return entry;
+    }
+
+    private LinkedList<T> GetPartition() {
+      LinkedList<T> partition;
+
+      return Pool.TryPop(out partition) ? partition : new LinkedList<T>();
+    }
+
+    public void Dispose() {
+      Pool.PushRange(partitions.ToArray());
+    }
+  }
+}
Index: branches/PushGP/HeuristicLab.PushGP/TestPooling/Pool/ManagedPool2.cs
===================================================================
--- branches/PushGP/HeuristicLab.PushGP/TestPooling/Pool/ManagedPool2.cs	(revision 14744)
+++ branches/PushGP/HeuristicLab.PushGP/TestPooling/Pool/ManagedPool2.cs	(revision 14744)
@@ -0,0 +1,75 @@
+﻿using System.Collections.Generic;
+
+namespace TestPooling.Pool {
+  using System;
+  using System.Collections.Concurrent;
+  using System.IO;
+  using System.Linq;
+  using System.Runtime.Serialization.Formatters.Binary;
+
+  public class ManagedPool2<T> : IDisposable where T : class {
+
+    private static readonly ConcurrentStack<T[]> Pool = new ConcurrentStack<T[]>();
+
+    private readonly T[] DummyPartition;
+    private readonly Func<T> Factory;
+    public readonly int PartitionSize;
+
+    private readonly IList<T[]> partitions = new List<T[]>();
+    private T[] currentPartition;
+    private int entryIndex;
+
+    public ManagedPool2(int partitionSize, T[] dummyPartition, Func<T> factory) {
+      PartitionSize = partitionSize;
+      Factory = factory;
+      entryIndex = partitionSize;
+
+      DummyPartition = dummyPartition;
+    }
+
+    public T Get() {
+      if (entryIndex == PartitionSize) {
+        currentPartition = GetPartition();
+        partitions.Add(currentPartition);
+        entryIndex = 0;
+      }
+
+      return currentPartition[entryIndex++];
+    }
+
+    private T[] GetPartition() {
+      //T[] partition;
+
+      //partition = Pool.TryPop(out partition) ? partition : new T[PartitionSize];
+
+      //for (var i = 0; i < PartitionSize; i++) {
+      //  partition[i] = Factory();
+      //}
+
+      //return partition;
+
+      T[] partition;
+      if (Pool.TryPop(out partition)) return partition;
+
+      //partition = new T[PartitionSize];
+      //DummyPartition.CopyTo(partition, 0);
+
+      return DeepArrayCopy(DummyPartition);
+    }
+
+    private static T[] DeepArrayCopy(object objectToCopy) {
+      using (var memoryStream = new MemoryStream()) {
+        var binaryFormatter = new BinaryFormatter();
+
+        binaryFormatter.Serialize(memoryStream, objectToCopy);
+        memoryStream.Seek(0, SeekOrigin.Begin);
+
+        return (T[])binaryFormatter.Deserialize(memoryStream);
+      }
+    }
+
+    public void Dispose() {
+      Pool.PushRange(partitions.ToArray());
+    }
+  }
+}
Index: branches/PushGP/HeuristicLab.PushGP/TestPooling/Pool/ManagedPoolProvider.cs
===================================================================
--- branches/PushGP/HeuristicLab.PushGP/TestPooling/Pool/ManagedPoolProvider.cs	(revision 14744)
+++ branches/PushGP/HeuristicLab.PushGP/TestPooling/Pool/ManagedPoolProvider.cs	(revision 14744)
@@ -0,0 +1,45 @@
+﻿//using System;
+
+//namespace TestPooling.Pool {
+//  using System.Collections.Concurrent;
+//  using System.Threading.Tasks;
+
+//  public class ManagedPoolProvider<T> where T : class {
+//    private static readonly volatile ConcurrentStack<T[]> partitions = new ConcurrentStack<T[]>();
+//    private readonly Func<T> Factory;
+//    public readonly int PartitionSize;
+
+//    public ManagedPoolProvider(int partitionSize, Func<T> factory) {
+//      PartitionSize = partitionSize;
+//      Factory = factory;
+//    }
+
+//    public T[] GetPartition() {
+//      T[] partition;
+
+//      return partitions.TryPop(out partition) ? partition : CreatePartition();
+//    }
+
+//    public void ReleasePartitions(params T[][] partition) {
+//      partitions.PushRange(partition);
+//    }
+
+//    public T CreateEntry() {
+//      return Factory();
+//    }
+
+//    private T[] CreatePartition() {
+//      //return new T[PartitionSize];
+
+//      var partition = new T[PartitionSize];
+
+//      Parallel.For(0, PartitionSize, i => partition[i] = Factory());
+
+//      return partition;
+//    }
+
+//    public ManagedPool<T> CreatePool() {
+//      return new ManagedPool<T>(this);
+//    }
+//  }
+//}
Index: branches/PushGP/HeuristicLab.PushGP/TestPooling/Pool/ObjectPool.cs
===================================================================
--- branches/PushGP/HeuristicLab.PushGP/TestPooling/Pool/ObjectPool.cs	(revision 14744)
+++ branches/PushGP/HeuristicLab.PushGP/TestPooling/Pool/ObjectPool.cs	(revision 14744)
@@ -0,0 +1,105 @@
+﻿// Licensed to the .NET Foundation under one or more agreements.
+// The .NET Foundation licenses this file to you under the MIT license.
+// See the LICENSE file in the project root for more information.
+
+using System;
+
+namespace TestPooling.Pool {
+  using System.Threading;
+
+  /// <summary>
+  /// Generic implementation of object pooling pattern with predefined pool size limit. The main
+  /// purpose is that limited number of frequently used objects can be kept in the pool for
+  /// further recycling.
+  ///
+  /// Notes:
+  /// 1) it is not the goal to keep all returned objects. Pool is not meant for storage. If there
+  ///    is no space in the pool, extra returned objects will be dropped.
+  ///
+  /// 2) it is implied that if object was obtained from a pool, the caller will return it back in
+  ///    a relatively short time. Keeping checked out objects for long durations is ok, but
+  ///    reduces usefulness of pooling. Just new up your own.
+  ///
+  /// Not returning objects to the pool in not detrimental to the pool's work, but is a bad practice.
+  /// Rationale:
+  ///    If there is no intent for reusing the object, do not use pool - just use "new".
+  /// </summary>
+  public sealed class ObjectPool<T> where T : class {
+    private struct Element {
+      internal T Value;
+    }
+
+    // storage for the pool objects.
+    private readonly Element[] _items;
+
+    // factory is stored for the lifetime of the pool. We will call this only when pool needs to
+    // expand. compared to "new T()", Func gives more flexibility to implementers and faster
+    // than "new T()".
+    private readonly Func<T> _factory;
+
+
+    internal ObjectPool(Func<T> factory)
+        : this(factory, Environment.ProcessorCount * 2) { }
+
+    internal ObjectPool(Func<T> factory, int size) {
+      _factory = factory;
+      _items = new Element[size];
+    }
+
+    private T CreateInstance() {
+      var inst = _factory();
+      return inst;
+    }
+
+    /// <summary>
+    /// Produces an instance.
+    /// </summary>
+    /// <remarks>
+    /// Search strategy is a simple linear probing which is chosen for it cache-friendliness.
+    /// Note that Free will try to store recycled objects close to the start thus statistically
+    /// reducing how far we will typically search.
+    /// </remarks>
+    internal T Allocate() {
+      var items = _items;
+      T inst;
+
+      for (int i = 0; i < items.Length; i++) {
+        // Note that the read is optimistically not synchronized. That is intentional.
+        // We will interlock only when we have a candidate. in a worst case we may miss some
+        // recently returned objects. Not a big deal.
+        inst = items[i].Value;
+        if (inst != null) {
+          if (inst == Interlocked.CompareExchange(ref items[i].Value, null, inst)) {
+            goto gotInstance;
+          }
+        }
+      }
+
+      inst = CreateInstance();
+      gotInstance:
+
+      return inst;
+    }
+
+    /// <summary>
+    /// Returns objects to the pool.
+    /// </summary>
+    /// <remarks>
+    /// Search strategy is a simple linear probing which is chosen for it cache-friendliness.
+    /// Note that Free will try to store recycled objects close to the start thus statistically
+    /// reducing how far we will typically search in Allocate.
+    /// </remarks>
+    internal void Free(T obj) {
+      var items = _items;
+      for (int i = 0; i < items.Length; i++) {
+        if (items[i].Value == null) {
+          // Intentionally not using interlocked here.
+          // In a worst case scenario two objects may be stored into same slot.
+          // It is very unlikely to happen and will only mean that one of the objects will get collected.
+          items[i].Value = obj;
+          break;
+        }
+      }
+    }
+  }
+}
Index: branches/PushGP/HeuristicLab.PushGP/TestPooling/Program.cs
===================================================================
--- branches/PushGP/HeuristicLab.PushGP/TestPooling/Program.cs	(revision 14744)
+++ branches/PushGP/HeuristicLab.PushGP/TestPooling/Program.cs	(revision 14744)
@@ -0,0 +1,127 @@
+﻿using System.Threading.Tasks;
+
+namespace TestPooling {
+  using System;
+  using System.Diagnostics;
+
+  using TestPooling.Pool;
+
+  class Program {
+    private const int Count = 3000;
+    static void Main(string[] args) {
+      Test1();
+      Test1_2();
+      Test3();
+    }
+
+    private static void Test1() {
+      var sw = new Stopwatch();
+
+      sw.Start();
+      //Parallel.For(0, 3, k => {
+      Parallel.For(0, 10000, i => {
+        using (var pool = new ManagedPool<Person>(Count, () => new Person())) {
+          for (var j = 0; j < 3000; j++) {
+            var person = pool.Get();
+            person.Age = i + j;
+            person.Name = string.Format("{0} - {1}", i, j);
+          }
+        }
+      });
+      //});
+      sw.Stop();
+
+      Console.WriteLine("1 - Duration: {0} - {1}", sw.ElapsedTicks, sw.Elapsed.TotalSeconds);
+    }
+
+    private static void Test1_2() {
+      var sw = new Stopwatch();
+      sw.Start();
+
+      var dummyPartition = new Person[Count];
+
+      for (var i = 0; i < Count; i++) {
+        dummyPartition[i] = new Person();
+      }
+
+      //Parallel.For(0, 3, k => {
+      Parallel.For(0, 10000, i => {
+        using (var pool = new ManagedPool2<Person>(Count, dummyPartition, () => new Person())) {
+          for (var j = 0; j < 3000; j++) {
+            var person = pool.Get();
+            person.Age = i + j;
+            person.Name = string.Format("{0} - {1}", i, j);
+          }
+        }
+      });
+      //});
+      sw.Stop();
+
+      //var p1 = new ManagedPool2<Person>(Count, dummyPartition, () => new TestPooling.Person());
+      //var p2 = new ManagedPool2<Person>(Count, dummyPartition, () => new TestPooling.Person());
+      //var pa1 = p1.Get();
+      //var pa2 = p2.Get();
+
+      Console.WriteLine("1_2 - Duration: {0} - {1}", sw.ElapsedTicks, sw.Elapsed.TotalSeconds);
+    }
+
+    private static void Test4() {
+      var sw = new Stopwatch();
+
+      sw.Start(); ;
+      var pool = new ManagedPool<Person>(512, () => new Person());
+
+      Parallel.For(0, 10000, i => {
+        for (var j = 0; j < 3000; j++) {
+          var person = pool.Get();
+          person.Age = i + j;
+          person.Name = string.Format("{0} - {1}", i, j);
+        }
+        pool.Dispose();
+      });
+      sw.Stop();
+
+      Console.WriteLine("1 - Duration: {0}", sw.ElapsedTicks);
+    }
+
+    private static void Test3() {
+      var count = 0;
+      var sw = new Stopwatch();
+
+      sw.Start();
+      Parallel.For(0, 10000, i => {
+        var list = new Person[3000];
+
+        for (var j = 0; j < 3000; j++) {
+          list[j] = new Person { Age = i + j, Name = string.Format("{0} - {1}", i, j) };
+        }
+
+        count += list.Length;
+      });
+      sw.Stop();
+
+      Console.WriteLine("3 - Duration: {0} - {1}", sw.ElapsedTicks, sw.Elapsed.TotalSeconds);
+      Console.WriteLine("Count: {0}", count);
+    }
+
+    private static void Test2() {
+      var pool = new ObjectPool<Person>(() => new Person(), 2048);
+
+      Parallel.For(0, 10000, i => {
+        for (var j = 0; j < 3000; j++) {
+          var person = pool.Allocate();
+          person.Age = i + j;
+          person.Name = string.Format("{0} - {1}", i, j);
+        }
+
+        //pool.Free()
+      });
+    }
+  }
+
+  [Serializable]
+  class Person {
+    public string Name { get; set; }
+    public int Age { get; set; }
+  }
+}
Index: branches/PushGP/HeuristicLab.PushGP/TestPooling/Properties/AssemblyInfo.cs
===================================================================
--- branches/PushGP/HeuristicLab.PushGP/TestPooling/Properties/AssemblyInfo.cs	(revision 14744)
+++ branches/PushGP/HeuristicLab.PushGP/TestPooling/Properties/AssemblyInfo.cs	(revision 14744)
@@ -0,0 +1,36 @@
+﻿using System.Reflection;
+using System.Runtime.CompilerServices;
+using System.Runtime.InteropServices;
+
+// General Information about an assembly is controlled through the following 
+// set of attributes. Change these attribute values to modify the information
+// associated with an assembly.
+[assembly: AssemblyTitle("TestPooling")]
+[assembly: AssemblyDescription("")]
+[assembly: AssemblyConfiguration("")]
+[assembly: AssemblyCompany("")]
+[assembly: AssemblyProduct("TestPooling")]
+[assembly: AssemblyCopyright("Copyright ©  2017")]
+[assembly: AssemblyTrademark("")]
+[assembly: AssemblyCulture("")]
+
+// Setting ComVisible to false makes the types in this assembly not visible 
+// to COM components.  If you need to access a type in this assembly from 
+// COM, set the ComVisible attribute to true on that type.
+[assembly: ComVisible(false)]
+
+// The following GUID is for the ID of the typelib if this project is exposed to COM
+[assembly: Guid("b184a849-1403-4f5f-96f8-952c6599a7c0")]
+
+// Version information for an assembly consists of the following four values:
+//
+//      Major Version
+//      Minor Version 
+//      Build Number
+//      Revision
+//
+// You can specify all the values or you can default the Build and Revision Numbers 
+// by using the '*' as shown below:
+// [assembly: AssemblyVersion("1.0.*")]
+[assembly: AssemblyVersion("1.0.0.0")]
+[assembly: AssemblyFileVersion("1.0.0.0")]
Index: branches/PushGP/HeuristicLab.PushGP/TestPooling/TestPooling.csproj
===================================================================
--- branches/PushGP/HeuristicLab.PushGP/TestPooling/TestPooling.csproj	(revision 14744)
+++ branches/PushGP/HeuristicLab.PushGP/TestPooling/TestPooling.csproj	(revision 14744)
@@ -0,0 +1,64 @@
+﻿<?xml version="1.0" encoding="utf-8"?>
+<Project ToolsVersion="14.0" DefaultTargets="Build" xmlns="http://schemas.microsoft.com/developer/msbuild/2003">
+  <Import Project="$(MSBuildExtensionsPath)\$(MSBuildToolsVersion)\Microsoft.Common.props" Condition="Exists('$(MSBuildExtensionsPath)\$(MSBuildToolsVersion)\Microsoft.Common.props')" />
+  <PropertyGroup>
+    <Configuration Condition=" '$(Configuration)' == '' ">Debug</Configuration>
+    <Platform Condition=" '$(Platform)' == '' ">AnyCPU</Platform>
+    <ProjectGuid>{B184A849-1403-4F5F-96F8-952C6599A7C0}</ProjectGuid>
+    <OutputType>Exe</OutputType>
+    <AppDesignerFolder>Properties</AppDesignerFolder>
+    <RootNamespace>TestPooling</RootNamespace>
+    <AssemblyName>TestPooling</AssemblyName>
+    <TargetFrameworkVersion>v4.5.2</TargetFrameworkVersion>
+    <FileAlignment>512</FileAlignment>
+    <AutoGenerateBindingRedirects>true</AutoGenerateBindingRedirects>
+  </PropertyGroup>
+  <PropertyGroup Condition=" '$(Configuration)|$(Platform)' == 'Debug|AnyCPU' ">
+    <PlatformTarget>AnyCPU</PlatformTarget>
+    <DebugSymbols>true</DebugSymbols>
+    <DebugType>full</DebugType>
+    <Optimize>false</Optimize>
+    <OutputPath>bin\Debug\</OutputPath>
+    <DefineConstants>DEBUG;TRACE</DefineConstants>
+    <ErrorReport>prompt</ErrorReport>
+    <WarningLevel>4</WarningLevel>
+  </PropertyGroup>
+  <PropertyGroup Condition=" '$(Configuration)|$(Platform)' == 'Release|AnyCPU' ">
+    <PlatformTarget>AnyCPU</PlatformTarget>
+    <DebugType>pdbonly</DebugType>
+    <Optimize>true</Optimize>
+    <OutputPath>bin\Release\</OutputPath>
+    <DefineConstants>TRACE</DefineConstants>
+    <ErrorReport>prompt</ErrorReport>
+    <WarningLevel>4</WarningLevel>
+  </PropertyGroup>
+  <ItemGroup>
+    <Reference Include="System" />
+    <Reference Include="System.Core" />
+    <Reference Include="System.Xml.Linq" />
+    <Reference Include="System.Data.DataSetExtensions" />
+    <Reference Include="Microsoft.CSharp" />
+    <Reference Include="System.Data" />
+    <Reference Include="System.Net.Http" />
+    <Reference Include="System.Xml" />
+  </ItemGroup>
+  <ItemGroup>
+    <Compile Include="Pool\ManagedPool.cs" />
+    <Compile Include="Pool\ManagedPool2.cs" />
+    <Compile Include="Pool\ManagedPoolProvider.cs" />
+    <Compile Include="Pool\ObjectPool.cs" />
+    <Compile Include="Program.cs" />
+    <Compile Include="Properties\AssemblyInfo.cs" />
+  </ItemGroup>
+  <ItemGroup>
+    <None Include="App.config" />
+  </ItemGroup>
+  <Import Project="$(MSBuildToolsPath)\Microsoft.CSharp.targets" />
+  <!-- To modify your build process, add your task inside one of the targets below and uncomment it. 
+       Other similar extension points exist, see Microsoft.Common.targets.
+  <Target Name="BeforeBuild">
+  </Target>
+  <Target Name="AfterBuild">
+  </Target>
+  -->
+</Project>
