Index: branches/PushGP/HeuristicLab.PushGP/HeuristicLab.Problems.ProgramSynthesis/Push/Interpreter/Extensions.cs
===================================================================
--- branches/PushGP/HeuristicLab.PushGP/HeuristicLab.Problems.ProgramSynthesis/Push/Interpreter/Extensions.cs	(revision 14834)
+++ branches/PushGP/HeuristicLab.PushGP/HeuristicLab.Problems.ProgramSynthesis/Push/Interpreter/Extensions.cs	(revision 14834)
@@ -0,0 +1,58 @@
+﻿using System.Collections.Generic;
+using System.Linq;
+
+namespace HeuristicLab.Problems.ProgramSynthesis.Push.Interpreter {
+  using System;
+  using System.Collections;
+  using System.Reflection;
+
+  using Attributes;
+
+  using Stack;
+
+  public static class Extensions {
+    private static readonly IDictionary<StackTypes, PropertyInfo> StackProperties = typeof(PushInterpreter)
+        .GetProperties()
+        .Select(p => new { Property = p, Attribute = p.GetCustomAttribute<PushStackAttribute>() })
+        .Where(x => x.Attribute != null)
+        .ToDictionary(x => x.Attribute.StackType, x => x.Property);
+
+    public static IEnumerable<T> GetStackEntriesByType<T>(this IPushInterpreter interpreter, StackTypes stackType) {
+      return StackProperties.ContainsKey(stackType)
+        ? ((IEnumerable)StackProperties[stackType].GetValue(interpreter)).OfType<T>()
+        : null;
+    }
+
+    public static IPushStackBase GetStackBaseByType(this IPushInterpreter interpreter, StackTypes stackType) {
+      return StackProperties.ContainsKey(stackType)
+        ? (IPushStackBase)StackProperties[stackType].GetValue(interpreter)
+        : null;
+    }
+
+    public static Type GetStackEntryType(this StackTypes stackType) {
+      return StackProperties.ContainsKey(stackType)
+        ? StackProperties[stackType].PropertyType.GetGenericArguments().Single()
+        : null;
+    }
+
+    public static void PrintStacks(this IPushInterpreter interpreter) {
+      var stackTypesType = typeof(StackTypes);
+
+      foreach (StackTypes type in Enum.GetValues(stackTypesType)) {
+        var stackName = Enum.GetName(stackTypesType, type);
+        var stack = GetStackBaseByType(interpreter, type);
+
+        if (stack.IsEmpty || !stack.IsEnabled) return;
+        Console.WriteLine("--------- {0} ---------\n{1}\n", stackName, stack);
+      }
+
+      if (interpreter.CustomExpressions.Count > 0) {
+        Console.WriteLine("--------- Custom Expressions ---------");
+        foreach (var ce in interpreter.CustomExpressions) {
+          Console.WriteLine("{0}: {1}", ce.Key, ce.Value);
+        }
+      }
+    }
+  }
+}
+
Index: branches/PushGP/HeuristicLab.PushGP/HeuristicLab.Problems.ProgramSynthesis/Push/Interpreter/IInternalPushInterpreter.cs
===================================================================
--- branches/PushGP/HeuristicLab.PushGP/HeuristicLab.Problems.ProgramSynthesis/Push/Interpreter/IInternalPushInterpreter.cs	(revision 14834)
+++ branches/PushGP/HeuristicLab.PushGP/HeuristicLab.Problems.ProgramSynthesis/Push/Interpreter/IInternalPushInterpreter.cs	(revision 14834)
@@ -0,0 +1,6 @@
+﻿namespace HeuristicLab.Problems.ProgramSynthesis.Push.Interpreter {
+  public interface IInternalPushInterpreter : IPushInterpreter {
+    InterpreterPoolContainer PoolContainer { get; }
+    bool IsNameQuoteFlagSet { get; set; }
+  }
+}
Index: branches/PushGP/HeuristicLab.PushGP/HeuristicLab.Problems.ProgramSynthesis/Push/Interpreter/IPushInterpreter.cs
===================================================================
--- branches/PushGP/HeuristicLab.PushGP/HeuristicLab.Problems.ProgramSynthesis/Push/Interpreter/IPushInterpreter.cs	(revision 14777)
+++ branches/PushGP/HeuristicLab.PushGP/HeuristicLab.Problems.ProgramSynthesis/Push/Interpreter/IPushInterpreter.cs	(revision 14834)
@@ -7,5 +7,4 @@
 
   using HeuristicLab.Problems.ProgramSynthesis.Push.Configuration;
-  using HeuristicLab.Problems.ProgramSynthesis.Push.Data.Pool;
 
   using Stack;
@@ -13,27 +12,23 @@
   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; }
-    IStack<char> CharStack { get; }
-    IStack<string> StringStack { get; }
-
+    IPushStack<Expression> CodeStack { get; }
+    IPushStack<Expression> ExecStack { get; }
+    IPushStack<string> NameStack { get; }
+    IPushStack<bool> BooleanStack { get; }
+    IPushStack<long> IntegerStack { get; }
+    IPushStack<double> FloatStack { get; }
+    IPushStack<char> CharStack { get; }
+    IPushStack<string> StringStack { get; }
+    IPushStack<List<long>> IntegerVectorStack { get; }
+    IPushStack<List<double>> FloatVectorStack { get; }
+    IPushStack<List<bool>> BooleanVectorStack { get; }
+    IPushStack<List<string>> StringVectorStack { get; }
     IDictionary<string, Expression> CustomExpressions { get; }
-
     IReadOnlyPushConfiguration Configuration { get; }
-
-    InterpreterPoolContainer PoolContainer { get; }
-
-    bool IsNameQuoteFlagSet { get; set; }
-
     void Clear();
     void Run(string code, bool stepwise = false);
     void Run(Expression expression, bool stepwise = false);
-    Task RunAsync(Expression expression, bool paused = false, CancellationToken token = default(CancellationToken));
-    Task RunAsync(string code, bool paused = false, CancellationToken token = default(CancellationToken));
+    Task RunAsync(Expression expression, CancellationToken token = default(CancellationToken));
+    Task RunAsync(string code, CancellationToken token = default(CancellationToken));
     Task AbortAndResetAsync();
     Task AbortAsync();
@@ -41,7 +36,5 @@
     void Resume();
     Task ResumeAsync();
-
     bool Step();
-    void PrintStacks();
   }
 }
Index: branches/PushGP/HeuristicLab.PushGP/HeuristicLab.Problems.ProgramSynthesis/Push/Interpreter/InterpreterPoolContainer.cs
===================================================================
--- branches/PushGP/HeuristicLab.PushGP/HeuristicLab.Problems.ProgramSynthesis/Push/Interpreter/InterpreterPoolContainer.cs	(revision 14777)
+++ branches/PushGP/HeuristicLab.PushGP/HeuristicLab.Problems.ProgramSynthesis/Push/Interpreter/InterpreterPoolContainer.cs	(revision 14834)
@@ -22,5 +22,5 @@
       expressionListPoolProvider = new ManagedPoolProvider<PooledList<Expression>>(partitionSize, () => new PooledList<Expression>(), maxPartitionCount);
 
-      InitStatefulExpressionPools();
+      InitStatefulExpressionPools(partitionSize, maxPartitionCount);
     }
 
@@ -33,18 +33,46 @@
       this.expressionListPoolProvider = expressionListPoolProvider;
 
-      InitStatefulExpressionPools();
+      InitStatefulExpressionPools(1024, 2048);
     }
 
-    public IManagedPool<PushProgram> PushProgramPool { get; private set; }
-    public IManagedPool<LoopState> LoopStatePool { get; private set; }
-    public IManagedPool<PooledList<Expression>> ExpressionListPool { get; private set; }
+    private IManagedPool<PushProgram> pushProgramPool;
+    public IManagedPool<PushProgram> PushProgramPool
+    {
+      get
+      {
+        if (pushProgramPool == null) pushProgramPool = pushProgramPoolProvider.CreatePool();
+        return pushProgramPool;
+      }
+    }
 
-    private void InitStatefulExpressionPools() {
+    private IManagedPool<LoopState> loopStatePool;
+    public IManagedPool<LoopState> LoopStatePool
+    {
+      get
+      {
+        if (loopStatePool == null) loopStatePool = loopStatePoolProvider.CreatePool();
+        return loopStatePool;
+      }
+    }
+
+    private IManagedPool<PooledList<Expression>> expressionListPool;
+    public IManagedPool<PooledList<Expression>> ExpressionListPool
+    {
+      get
+      {
+        if (expressionListPool == null) expressionListPool = expressionListPoolProvider.CreatePool();
+        return expressionListPool;
+      }
+    }
+
+    private void InitStatefulExpressionPools(int partitionSize, int maxPartitionCount) {
       for (var i = 0; i < ExpressionTable.StatefulExpressionTypes.Length; i++) {
         var type = ExpressionTable.StatefulExpressionTypes[i];
         var name = ExpressionTable.TypeToNameTable[type];
-        var factory = ExpressionTable.StatefulExpressionFactory[name];
 
-        statefulExpressionPoolProviders.Add(type, new ManagedPoolProvider<Expression>(1024, factory));
+        statefulExpressionPoolProviders.Add(type, new ManagedPoolProvider<Expression>(
+          partitionSize,
+          ExpressionTable.StatefulExpressionFactory[name],
+          maxPartitionCount));
 
         statefulExpressionPools.Add(type, null);
@@ -52,31 +80,36 @@
     }
 
-    public IManagedPool<Expression> GetStatefulExpressionPool<T, StateT>() where T : StatefulExpression<StateT> {
-      return statefulExpressionPools[typeof(T)];
+    public T GetStatefulExpression<T>() where T : Expression {
+      var type = typeof(T);
+      if (statefulExpressionPools[type] == null)
+        statefulExpressionPools[type] = statefulExpressionPoolProviders[type].CreatePool();
+
+      return (T)statefulExpressionPools[type].Get();
     }
 
-    public T GetStatefulExpression<T>() where T : Expression {
-      return (T)statefulExpressionPools[typeof(T)].Get();
-    }
+    public void DisposePools() {
+      if (pushProgramPool != null) {
+        pushProgramPool.Dispose();
+        pushProgramPool = null;
+      }
 
-    public void CreatePools() {
-      PushProgramPool = pushProgramPoolProvider.CreatePool();
-      LoopStatePool = loopStatePoolProvider.CreatePool();
-      ExpressionListPool = expressionListPoolProvider.CreatePool();
+      if (loopStatePool != null) {
+        loopStatePool.Dispose();
+        loopStatePool = null;
+      }
+
+      if (expressionListPool != null) {
+        expressionListPool.Dispose();
+        expressionListPool = null;
+      }
 
       for (var i = 0; i < ExpressionTable.StatefulExpressionTypes.Length; i++) {
         var type = ExpressionTable.StatefulExpressionTypes[i];
-        statefulExpressionPools[type] = statefulExpressionPoolProviders[type].CreatePool();
-      }
-    }
+        var pool = statefulExpressionPools[type];
 
-    public void DisposePools() {
-      if (PushProgramPool != null) PushProgramPool.Dispose();
-      if (LoopStatePool != null) LoopStatePool.Dispose();
-      if (ExpressionListPool != null) ExpressionListPool.Dispose();
-
-      for (var i = 0; i < ExpressionTable.StatefulExpressionTypes.Length; i++) {
-        var type = ExpressionTable.StatefulExpressionTypes[i];
-        if (statefulExpressionPools[type] != null) statefulExpressionPools[type].Dispose();
+        if (pool != null) {
+          pool.Dispose();
+          statefulExpressionPools[type] = null;
+        }
       }
     }
Index: branches/PushGP/HeuristicLab.PushGP/HeuristicLab.Problems.ProgramSynthesis/Push/Interpreter/PooledPushInterpreter.cs
===================================================================
--- branches/PushGP/HeuristicLab.PushGP/HeuristicLab.Problems.ProgramSynthesis/Push/Interpreter/PooledPushInterpreter.cs	(revision 14777)
+++ branches/PushGP/HeuristicLab.PushGP/HeuristicLab.Problems.ProgramSynthesis/Push/Interpreter/PooledPushInterpreter.cs	(revision 14834)
@@ -1,9 +1,8 @@
 ﻿namespace HeuristicLab.Problems.ProgramSynthesis.Push.Interpreter {
-  using System;
 
   using HeuristicLab.Core;
   using HeuristicLab.Problems.ProgramSynthesis.Push.Configuration;
 
-  public class PooledPushInterpreter : PushInterpreter, IDisposable {
+  public class PooledPushInterpreter : PushInterpreter {
 
     private readonly PushInterpreterPool pool;
@@ -14,8 +13,8 @@
     }
 
-    public void Dispose() {
-      this.Reset();
-      this.Configuration = this.Configuration;
-      this.pool.Free(this);
+    public override void Dispose() {
+      base.Dispose();
+      Reset();
+      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 14777)
+++ branches/PushGP/HeuristicLab.PushGP/HeuristicLab.Problems.ProgramSynthesis/Push/Interpreter/PushInterpreter.cs	(revision 14834)
@@ -2,17 +2,21 @@
   using System;
   using System.Collections.Generic;
-#if DEBUG
-#endif
   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.Expressions;
-  using HeuristicLab.Problems.ProgramSynthesis.Push.Parser;
-  using HeuristicLab.Problems.ProgramSynthesis.Push.Stack;
-  using HeuristicLab.Random;
-
-  public class PushInterpreter : IPushInterpreter {
+  using Attributes;
+  using Configuration;
+  using Core;
+  using Expressions;
+  using Parser;
+  using Random;
+  using Stack;
+
+#if DEBUG
+  using System.Diagnostics;
+  using System.Linq;
+#endif
+
+  public class PushInterpreter : IInternalPushInterpreter, IDisposable {
     private Task currentTask;
 
@@ -27,24 +31,36 @@
 
       CodeStack = new PushStack<Expression>(Configuration.EvalPushLimit) {
-        IsEnabled = Configuration.IsCodeStackEnabled
+        IsEnabled = Configuration.EnabledStacks[StackTypes.Code]
       };
 
       NameStack = new PushStack<string> {
-        IsEnabled = Configuration.IsNameStackEnabled
+        IsEnabled = Configuration.EnabledStacks[StackTypes.Code]
       };
       BooleanStack = new PushStack<bool> {
-        IsEnabled = Configuration.IsBooleanStackEnabled
+        IsEnabled = Configuration.EnabledStacks[StackTypes.Boolean]
       };
       IntegerStack = new PushStack<long> {
-        IsEnabled = Configuration.IsIntegerStackEnabled
+        IsEnabled = Configuration.EnabledStacks[StackTypes.Integer]
       };
       FloatStack = new PushStack<double> {
-        IsEnabled = Configuration.IsFloatStackEnabled
+        IsEnabled = Configuration.EnabledStacks[StackTypes.Float]
       };
       CharStack = new PushStack<char> {
-        IsEnabled = Configuration.IsCharStackEnabled
+        IsEnabled = Configuration.EnabledStacks[StackTypes.Char]
       };
       StringStack = new PushStack<string> {
-        IsEnabled = Configuration.IsStringStackEnabled
+        IsEnabled = Configuration.EnabledStacks[StackTypes.String]
+      };
+      IntegerVectorStack = new PushStack<List<long>> {
+        IsEnabled = Configuration.EnabledStacks[StackTypes.IntegerVector]
+      };
+      FloatVectorStack = new PushStack<List<double>> {
+        IsEnabled = Configuration.EnabledStacks[StackTypes.FloatVector]
+      };
+      BooleanVectorStack = new PushStack<List<bool>> {
+        IsEnabled = Configuration.EnabledStacks[StackTypes.BooleanVector]
+      };
+      StringVectorStack = new PushStack<List<string>> {
+        IsEnabled = Configuration.EnabledStacks[StackTypes.StringVector]
       };
 
@@ -81,5 +97,5 @@
       get
       {
-        return ExecStack.Count == 0;
+        return ExecStack.IsEmpty || ExecCounter >= Configuration.EvalPushLimit;
       }
     }
@@ -97,17 +113,39 @@
     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 IStack<char> CharStack { get; private set; }
-    public IStack<string> StringStack { get; private set; }
+    [PushStack(StackTypes.Code)]
+    public IPushStack<Expression> CodeStack { get; private set; }
+
+    [PushStack(StackTypes.Exec)]
+    public IPushStack<Expression> ExecStack { get; private set; }
+
+    [PushStack(StackTypes.Name)]
+    public IPushStack<string> NameStack { get; private set; }
+
+    [PushStack(StackTypes.Boolean)]
+    public IPushStack<bool> BooleanStack { get; private set; }
+
+    [PushStack(StackTypes.Integer)]
+    public IPushStack<long> IntegerStack { get; private set; }
+
+    [PushStack(StackTypes.Float)]
+    public IPushStack<double> FloatStack { get; private set; }
+
+    [PushStack(StackTypes.Char)]
+    public IPushStack<char> CharStack { get; private set; }
+
+    [PushStack(StackTypes.String)]
+    public IPushStack<string> StringStack { get; private set; }
+
+    [PushStack(StackTypes.IntegerVector)]
+    public IPushStack<List<long>> IntegerVectorStack { get; private set; }
+
+    [PushStack(StackTypes.FloatVector)]
+    public IPushStack<List<double>> FloatVectorStack { get; private set; }
+
+    [PushStack(StackTypes.BooleanVector)]
+    public IPushStack<List<bool>> BooleanVectorStack { get; private set; }
+
+    [PushStack(StackTypes.StringVector)]
+    public IPushStack<List<string>> StringVectorStack { get; private set; }
 
     public IDictionary<string, Expression> CustomExpressions { get; private set; }
@@ -115,16 +153,11 @@
     public bool IsNameQuoteFlagSet { get; set; }
 
-    public Task RunAsync(string code, bool stepwise = false, CancellationToken token = default(CancellationToken)) {
+    public Task RunAsync(string code, CancellationToken token = default(CancellationToken)) {
       var program = PushParser.Parse(code);
-
-      currentTask = RunAsync(program, stepwise, token);
-
+      currentTask = RunAsync(program, token);
       return currentTask;
     }
-    public async Task RunAsync(
-      Expression expression,
-      bool stepwise = false,
-      CancellationToken token = default(CancellationToken)) {
-      await Task.Run(() => Run(expression, stepwise), token);
+    public async Task RunAsync(Expression expression, CancellationToken token = default(CancellationToken)) {
+      await Task.Run(() => Run(expression, false), token);
     }
 
@@ -134,21 +167,20 @@
     }
 
-    public void Run(Expression program, bool stepwise = false) {
-      PoolContainer.CreatePools();
-
+    public void Run(Expression expression, 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();
-
-      PoolContainer.DisposePools();
+       * 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.
+       * Expanding the initial program is not counted */
+      ExecStack.Push(expression);
+
+      if (Configuration.TopLevelPushCode) CodeStack.Insert(0, expression);
+
+      // expand if program
+      if (expression.IsProgram)
+        DoStep();
+
+      Run();
     }
 
@@ -188,5 +220,5 @@
 
       IsPaused = false;
-      Interpret();
+      this.Run();
     }
 
@@ -196,5 +228,7 @@
 
       var successful = DoStep();
-      Finally();
+
+      if (IsCompleted)
+        Finally();
 
       return successful;
@@ -204,20 +238,4 @@
     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) {
-        Console.WriteLine("--------- Custom Expressions ---------");
-        foreach (var ce in CustomExpressions) {
-          Console.WriteLine("{0}: {1}", ce.Key, ce.Value);
-        }
-      }
     }
 
@@ -226,4 +244,6 @@
     /// </summary>
     public void Reset() {
+      ExecCounter = 0;
+
       IsAborted = false;
       IsPaused = false;
@@ -234,12 +254,9 @@
 
     /// <summary>
-    /// Clears stacks
+    /// Clears stacks and custom expressions
     /// </summary>
     public void Clear() {
-      ExecCounter = 0;
-
       ExecStack.Clear();
       CodeStack.Clear();
-
       NameStack.Clear();
       BooleanStack.Clear();
@@ -251,20 +268,18 @@
 
     [MethodImpl(MethodImplOptions.AggressiveInlining)]
-    private void Interpret() {
-      while (IsRunning) {
+    private void Run() {
+      while (IsRunning)
         DoStep();
-        ExecCounter++;
-      }
-
-      Finally();
+
+      if (IsCompleted)
+        Finally();
     }
 
     [MethodImpl(MethodImplOptions.AggressiveInlining)]
     private void Finally() {
-      if (!IsCompleted)
-        return;
-
-      if (Configuration.TopLevelPopCode && (CodeStack.Count > 0))
+      if (Configuration.TopLevelPopCode && !CodeStack.IsEmpty)
         CodeStack.Pop();
+
+      PoolContainer.DisposePools();
     }
 
@@ -272,13 +287,21 @@
     private Expression last;
     private bool DoStep() {
+      double[] bk;
+      if (!FloatStack.IsEmpty) {
+        bk = FloatStack.Peek(Math.Min(FloatStack.Count, 3));
+      }
+
       var expression = ExecStack.Pop();
-
-      //if (ExecStack.Any(e => e == null)) {
-      //  throw new InvalidProgramException();
-      //}
-
       var succ = expression.Eval(this);
-      //last = expression;
-
+
+      if ((ExecStack.Count > 0 && ExecStack.Top == null) ||
+          (CodeStack.Count > 0 && CodeStack.Top == null) ||
+          FloatStack.Any(x => double.IsNaN(x) || double.IsInfinity(x)) ||
+          StringStack.Count > 0 && StringStack.Any(x => x == null)) {
+        Debugger.Break();
+      }
+
+      ExecCounter++;
+      last = expression;
       return succ;
     }
@@ -286,4 +309,5 @@
     [MethodImpl(MethodImplOptions.AggressiveInlining)]
     private bool DoStep() {
+      ExecCounter++;
       return ExecStack.Pop().Eval(this);
     }
@@ -291,12 +315,11 @@
 
     private Task InterpretAsync() {
-      currentTask = Task.Run(() => Interpret());
+      currentTask = Task.Run(() => this.Run());
 
       return currentTask;
     }
 
-    private void PrintStack<T>(string name, IStack<T> stack) {
-      if (stack.IsEmpty) return;
-      Console.WriteLine("--------- {0} ---------\n{1}\n", name, stack);
+    public virtual void Dispose() {
+      PoolContainer.DisposePools();
     }
   }
Index: branches/PushGP/HeuristicLab.PushGP/HeuristicLab.Problems.ProgramSynthesis/Push/Interpreter/PushInterpreterPool.cs
===================================================================
--- branches/PushGP/HeuristicLab.PushGP/HeuristicLab.Problems.ProgramSynthesis/Push/Interpreter/PushInterpreterPool.cs	(revision 14777)
+++ branches/PushGP/HeuristicLab.PushGP/HeuristicLab.Problems.ProgramSynthesis/Push/Interpreter/PushInterpreterPool.cs	(revision 14834)
@@ -14,15 +14,14 @@
     public readonly ManagedPoolProvider<PooledList<Expression>> ExpressionListPoolProvider;
 
-
     public PushInterpreterPool(IReadOnlyPushConfiguration config = null)
       : this(Environment.ProcessorCount * 2, 1024, null, config) {
     }
 
-    public PushInterpreterPool(int size, int pushProgramPoolPartitionSize, int? maxPartitionCount = null, IReadOnlyPushConfiguration config = null) {
+    public PushInterpreterPool(int size, int poolPartitionSize, int? maxPartitionCount = null, IReadOnlyPushConfiguration config = null) {
       PushGpConfiguration = config ?? new PushConfiguration();
 
-      PushProgramPoolProvider = new ManagedPoolProvider<PushProgram>(pushProgramPoolPartitionSize, () => new PushProgram(), maxPartitionCount);
-      LoopStatePoolProvider = new ManagedPoolProvider<LoopState>(pushProgramPoolPartitionSize, () => new LoopState(), maxPartitionCount);
-      ExpressionListPoolProvider = new ManagedPoolProvider<PooledList<Expression>>(pushProgramPoolPartitionSize * 2, () => new PooledList<Expression>(), maxPartitionCount);
+      PushProgramPoolProvider = new ManagedPoolProvider<PushProgram>(poolPartitionSize, () => new PushProgram(), maxPartitionCount);
+      LoopStatePoolProvider = new ManagedPoolProvider<LoopState>(poolPartitionSize, () => new LoopState(), maxPartitionCount);
+      ExpressionListPoolProvider = new ManagedPoolProvider<PooledList<Expression>>(poolPartitionSize * 2, () => new PooledList<Expression>(), maxPartitionCount);
 
       pool = new ObjectPool<PooledPushInterpreter>(() => {
@@ -35,6 +34,6 @@
 
     public PooledPushInterpreter Create(IRandom random = null) {
-      var interpreter = this.pool.Allocate();
-      interpreter.Random = random ?? new FastRandom();
+      var interpreter = pool.Allocate();
+      interpreter.Random = random ?? new MersenneTwister();
 
       return interpreter;
@@ -42,5 +41,5 @@
 
     public void Free(PooledPushInterpreter interpreter) {
-      this.pool.Free(interpreter);
+      pool.Free(interpreter);
     }
   }
