Index: branches/PushGP/HeuristicLab.PushGP/FeatureTests/Program.cs
===================================================================
--- branches/PushGP/HeuristicLab.PushGP/FeatureTests/Program.cs	(revision 15033)
+++ branches/PushGP/HeuristicLab.PushGP/FeatureTests/Program.cs	(revision 15189)
@@ -6,4 +6,5 @@
   using System.Diagnostics;
   using System.Linq;
+  using System.Text;
   using System.Threading;
   using DirtyList;
@@ -44,5 +45,5 @@
       //PerformanceParallelTestInterpreter();
       //PerformanceTestLinearCodeGenerator();
-      TestRobustness();
+      //TestRobustness();
       //TestPool();
       //TestPoolPerformance();
@@ -51,7 +52,19 @@
       //TestExpressionDependencies();
       //TestSplitLogic();
+      TestStringBuilder();
 
       Console.WriteLine("\nPress any key to continue...");
       Console.ReadKey(false);
+    }
+
+    private static void TestStringBuilder() {
+      var sb = new StringBuilder();
+      sb.Append("test");
+
+      var s1 = sb.ToString();
+      var s2 = sb.ToString();
+
+      // false
+      var equal = ReferenceEquals(s1, s2);
     }
 
Index: branches/PushGP/HeuristicLab.PushGP/HeuristicLab.Problem.ProgramSynthesis.BenchmarkSuite/BenchmarkSuiteDataDescriptor.cs
===================================================================
--- branches/PushGP/HeuristicLab.PushGP/HeuristicLab.Problem.ProgramSynthesis.BenchmarkSuite/BenchmarkSuiteDataDescriptor.cs	(revision 15033)
+++ branches/PushGP/HeuristicLab.PushGP/HeuristicLab.Problem.ProgramSynthesis.BenchmarkSuite/BenchmarkSuiteDataDescriptor.cs	(revision 15189)
@@ -30,31 +30,4 @@
     protected abstract Example ParseExample(string[] input, string[] output);
 
-    //private IEnumerable<Example> ParseData() {
-    //  using (var file = GetType().Assembly.GetManifestResourceStream(InstanceArchiveName))
-    //  using (var archive = new ZipArchive(file, ZipArchiveMode.Read)) {
-    //    var entry = archive.Entries.SingleOrDefault(x => x.Name == FileName);
-
-    //    using (var parser = new TextFieldParser(entry.Open())) {
-    //      parser.TextFieldType = FieldType.Delimited;
-    //      parser.SetDelimiters(ExampleFieldDelimiter);
-    //      parser.HasFieldsEnclosedInQuotes = true;
-    //      parser.TrimWhiteSpace = false;
-
-    //      //Processing rows
-    //      while (!parser.EndOfData) {
-    //        var fields = parser.ReadFields();
-
-    //        if (fields.Length != InputArgumentCount + OutputArgumentCount)
-    //          throw new InvalidDataException("Number of values do not fit");
-
-    //        var input = fields.Take(InputArgumentCount).ToArray();
-    //        var output = fields.Skip(InputArgumentCount).ToArray();
-
-    //        yield return ParseExample(input, output);
-    //      }
-    //    }
-    //  }
-    //}
-
     private IEnumerable<Example> ParseData() {
       using (var file = GetType().Assembly.GetManifestResourceStream(InstanceArchiveName))
@@ -69,5 +42,7 @@
             var output = line.Skip(InputArgumentCount).ToArray();
 
-            yield return ParseExample(input, output);
+            var example = ParseExample(input, output);
+
+            yield return example;
           }
         }
Index: branches/PushGP/HeuristicLab.PushGP/HeuristicLab.Problem.ProgramSynthesis.BenchmarkSuite/ProblemData.cs
===================================================================
--- branches/PushGP/HeuristicLab.PushGP/HeuristicLab.Problem.ProgramSynthesis.BenchmarkSuite/ProblemData.cs	(revision 15033)
+++ branches/PushGP/HeuristicLab.PushGP/HeuristicLab.Problem.ProgramSynthesis.BenchmarkSuite/ProblemData.cs	(revision 15189)
@@ -34,4 +34,5 @@
       ErcOptions = cloner.Clone(origin.ErcOptions);
       FloatStringFormat = origin.FloatStringFormat;
+      ProblemType = origin.ProblemType;
     }
 
@@ -51,5 +52,9 @@
     [Storable]
     public ExampleArgumentType[] OutputArgumentTypes { get; set; }
+
+    public int TotalIntputArgumentCount { get { return InputArgumentTypes.Length; } }
+    public int TotalOutputArgumentCount { get { return OutputArgumentTypes.Length; } }
     public int TotalArgumentCount { get { return InputArgumentTypes.Length + OutputArgumentTypes.Length; } }
+
     [Storable]
     public Example[] Examples { get; set; }
Index: branches/PushGP/HeuristicLab.PushGP/HeuristicLab.Problem.ProgramSynthesis.BenchmarkSuite/Problems/Checksum.cs
===================================================================
--- branches/PushGP/HeuristicLab.PushGP/HeuristicLab.Problem.ProgramSynthesis.BenchmarkSuite/Problems/Checksum.cs	(revision 15033)
+++ branches/PushGP/HeuristicLab.PushGP/HeuristicLab.Problem.ProgramSynthesis.BenchmarkSuite/Problems/Checksum.cs	(revision 15189)
@@ -2,4 +2,5 @@
   using HeuristicLab.Problems.ProgramSynthesis.Base.Erc.Char;
   using HeuristicLab.Problems.ProgramSynthesis.Base.Erc.Integer;
+  using HeuristicLab.Problems.ProgramSynthesis.Base.Erc.String;
 
   public class Checksum : BenchmarkSuiteDataDescriptor {
@@ -35,5 +36,7 @@
           CharErcOptions = new CharErcOptions(
             new IntegerConstantErc(' '),
-            new IntegerRangeErc(0x20, 0x7e))
+            new IntegerRangeErc(0x20, 0x7e)),
+          StringErcOptions = new StringErcOptions(
+            new StringConstantErc("Check sum is "))
         }
       };
Index: branches/PushGP/HeuristicLab.PushGP/HeuristicLab.Problem.ProgramSynthesis.BenchmarkSuite/Problems/NumberIo.cs
===================================================================
--- branches/PushGP/HeuristicLab.PushGP/HeuristicLab.Problem.ProgramSynthesis.BenchmarkSuite/Problems/NumberIo.cs	(revision 15033)
+++ branches/PushGP/HeuristicLab.PushGP/HeuristicLab.Problem.ProgramSynthesis.BenchmarkSuite/Problems/NumberIo.cs	(revision 15189)
@@ -24,8 +24,8 @@
         WorstResult = 400,
         InputArgumentTypes = new[] { ExampleArgumentType.Float, ExampleArgumentType.Integer },
-        OutputArgumentTypes = new[] { ExampleArgumentType.Float },
+        OutputArgumentTypes = new[] { ExampleArgumentType.Print },
         TrainingCount = 25,
         TestCount = 1000,
-        EnabledDataTypes = DataTypes.Integer | DataTypes.Float, // | DataTypes.Print,
+        EnabledDataTypes = DataTypes.Integer | DataTypes.Float | DataTypes.Print,
         EvalLimit = 200,
         MaxSize = 200,
@@ -48,5 +48,5 @@
         InputInteger = ExampleArgumentConverter.ConvertIntegers(input[1]),
         OutputFloat = ExampleArgumentConverter.ConvertDoubles(output),
-        //OutputPrint = estimedFloatValue.ToString("R", CultureInfo.InvariantCulture),
+        OutputPrint = estimedFloatValue.ToString("R", CultureInfo.InvariantCulture),
       };
     }
Index: branches/PushGP/HeuristicLab.PushGP/HeuristicLab.Problems.ProgramSynthesis/HeuristicLab.Problems.ProgramSynthesis.csproj
===================================================================
--- branches/PushGP/HeuristicLab.PushGP/HeuristicLab.Problems.ProgramSynthesis/HeuristicLab.Problems.ProgramSynthesis.csproj	(revision 15033)
+++ branches/PushGP/HeuristicLab.PushGP/HeuristicLab.Problems.ProgramSynthesis/HeuristicLab.Problems.ProgramSynthesis.csproj	(revision 15189)
@@ -136,5 +136,5 @@
     <Compile Include="Push\Data\Tree\TreeExtensions.cs" />
     <Compile Include="Push\Data\Tree\TreeNode.cs" />
-    <Compile Include="Push\Constants\Environment.cs" />
+    <Compile Include="Push\Constants\PushEnvironment.cs" />
     <Compile Include="Push\Exporter\Exporter.cs" />
     <Compile Include="Push\Expressions\BooleanExpressions.cs" />
@@ -153,4 +153,5 @@
     <Compile Include="Push\Expressions\FloatExpressions.cs" />
     <Compile Include="Push\Expressions\FlushExpressions.cs" />
+    <Compile Include="Push\Expressions\InExpressions.cs" />
     <Compile Include="Push\Expressions\IntegerExpressions.cs" />
     <Compile Include="Push\Expressions\NameExpressions.cs" />
@@ -194,9 +195,12 @@
     <Compile Include="Push\Extensions\ControlExntensions.cs" />
     <Compile Include="Push\Extensions\EnumExtensions.cs" />
+    <Compile Include="Push\Extensions\ProblemDataExtensions.cs" />
     <Compile Include="Push\Extensions\LongExtensions.cs" />
     <Compile Include="Push\Extensions\RandomExtensions.cs" />
+    <Compile Include="Push\Extensions\StringBuilderExtensions.cs" />
     <Compile Include="Push\Generators\CodeGenerator\CodeGeneratorUtils.cs" />
     <Compile Include="Push\Generators\CodeGenerator\LinearCodeGenerator.cs" />
     <Compile Include="Push\Generators\CodeGenerator\RecursiveCodeGenerator.cs" />
+    <Compile Include="Push\Individual\InduvidualMapper.cs" />
     <Compile Include="Push\Interpreter\Extensions.cs" />
     <Compile Include="Push\Interpreter\IInternalPushInterpreter.cs" />
@@ -208,9 +212,10 @@
     <Compile Include="Push\Interpreter\PushInterpreter.cs" />
     <Compile Include="Push\Interpreter\PushInterpreterPool.cs" />
+    <Compile Include="Push\ObjectPools\StringBuilderPool.cs" />
     <Compile Include="Push\Parser\PushParser.cs" />
     <Compile Include="Push\Problem\BenchmarkSuite\PushBenchmarkSuiteSolution.cs" />
     <Compile Include="Push\Problem\DataBounds.cs" />
     <Compile Include="Push\Problem\EvaluationResult.cs" />
-    <Compile Include="Push\Problem\IndividualMapper.cs" />
+    <Compile Include="Push\Individual\IndividualExtensions.cs" />
     <Compile Include="Push\Problem\BenchmarkSuite\PushBenchmarkSuiteEvaluator.cs" />
     <Compile Include="Push\Problem\BenchmarkSuite\PushBenchmarkSuiteProblem.cs" />
@@ -223,6 +228,8 @@
     <Compile Include="Push\Selector\LexicaseSelector.cs" />
     <Compile Include="Push\Simplifier\Simplifier.cs" />
+    <Compile Include="Push\Stack\IPrintStack.cs" />
     <Compile Include="Push\Stack\IPushStack.cs" />
     <Compile Include="Push\Stack\IPushStackBase.cs" />
+    <Compile Include="Push\Stack\PrintStack.cs" />
     <Compile Include="Push\Stack\PushStack.cs" />
     <Compile Include="Push\Stack\InterpreterStackStringifier.cs" />
Index: branches/PushGP/HeuristicLab.PushGP/HeuristicLab.Problems.ProgramSynthesis/Push/Analyzer/PushExpressionFrequencyAnalyzer.cs
===================================================================
--- branches/PushGP/HeuristicLab.PushGP/HeuristicLab.Problems.ProgramSynthesis/Push/Analyzer/PushExpressionFrequencyAnalyzer.cs	(revision 15033)
+++ branches/PushGP/HeuristicLab.PushGP/HeuristicLab.Problems.ProgramSynthesis/Push/Analyzer/PushExpressionFrequencyAnalyzer.cs	(revision 15189)
@@ -14,5 +14,5 @@
   using HeuristicLab.Problems.ProgramSynthesis.Push.Configuration;
   using HeuristicLab.Problems.ProgramSynthesis.Push.Expressions;
-  using HeuristicLab.Problems.ProgramSynthesis.Push.Problem;
+  using HeuristicLab.Problems.ProgramSynthesis.Push.Individual;
 
   /// <summary>
@@ -35,5 +35,5 @@
       Parameters.Add(new LookupParameter<ResultCollection>(ResultsParameterName, "The result collection where the symbol frequencies should be stored."));
 
-      Parameters.Add(new FixedValueParameter<BoolValue>(AggregateStackTypesParameterName, "Determines if expressions should be aggregated by their primary stack type."));
+      Parameters.Add(new FixedValueParameter<BoolValue>(AggregateStackTypesParameterName, "Determines if expressions should be aggregated by their primary stack type.", new BoolValue(true)));
     }
 
@@ -84,5 +84,5 @@
       var config = PushConfigurationParameter.ActualValue;
       var integerVectors = IntegerVectorParameter.ActualValue;
-      var pushPrograms = integerVectors.Select(iv => iv.ToPushProgram(config)).ToArray();
+      var pushPrograms = integerVectors.Select(iv => iv.ToPushProgram(config));
 
       var results = ResultsParameter.ActualValue;
Index: branches/PushGP/HeuristicLab.PushGP/HeuristicLab.Problems.ProgramSynthesis/Push/Configuration/PushConfigurationBase.cs
===================================================================
--- branches/PushGP/HeuristicLab.PushGP/HeuristicLab.Problems.ProgramSynthesis/Push/Configuration/PushConfigurationBase.cs	(revision 15033)
+++ branches/PushGP/HeuristicLab.PushGP/HeuristicLab.Problems.ProgramSynthesis/Push/Configuration/PushConfigurationBase.cs	(revision 15189)
@@ -48,5 +48,5 @@
       set
       {
-        var removedExpressions = enabledExpressions.ToArray();
+        var removedExpressions = enabledExpressions.ToList();
         enabledExpressions.Clear();
         enabledExpressions.AddRange(value);
@@ -68,5 +68,7 @@
         var attribute = ExpressionTable.TypeToAttributeTable[type];
 
-        expressionsPerStackCount[attribute.StackType]++;
+        if (expressionsPerStackCount.ContainsKey(attribute.StackType)) {
+          expressionsPerStackCount[attribute.StackType]++;
+        }
 
         foreach (var additionalStackType in attribute.AdditionalStackDependencies.ToValues())
@@ -150,6 +152,9 @@
 
       enabledExpressions.Add(expressionName);
-      expressionsPerStackCount[attribute.StackType]++;
-      foreach (var additionalStackType in attribute.AdditionalStackDependencies.ToValues())
+
+      if (expressionsPerStackCount.ContainsKey(attribute.StackType))
+        expressionsPerStackCount[attribute.StackType]++;
+
+      foreach (var additionalStackType in attribute.AdditionalStackDependencies.ToValues().Where(expressionsPerStackCount.ContainsKey))
         expressionsPerStackCount[additionalStackType]++;
 
@@ -172,6 +177,9 @@
 
       enabledExpressions.Remove(expressionName);
-      expressionsPerStackCount[attribute.StackType]--;
-      foreach (var additionalStackType in attribute.AdditionalStackDependencies.ToValues())
+
+      if (expressionsPerStackCount.ContainsKey(attribute.StackType))
+        expressionsPerStackCount[attribute.StackType]--;
+
+      foreach (var additionalStackType in attribute.AdditionalStackDependencies.ToValues().Where(expressionsPerStackCount.ContainsKey))
         expressionsPerStackCount[additionalStackType]--;
 
Index: branches/PushGP/HeuristicLab.PushGP/HeuristicLab.Problems.ProgramSynthesis/Push/Constants/PushEnvironment.cs
===================================================================
--- branches/PushGP/HeuristicLab.PushGP/HeuristicLab.Problems.ProgramSynthesis/Push/Constants/PushEnvironment.cs	(revision 15189)
+++ branches/PushGP/HeuristicLab.PushGP/HeuristicLab.Problems.ProgramSynthesis/Push/Constants/PushEnvironment.cs	(revision 15189)
@@ -0,0 +1,21 @@
+﻿namespace HeuristicLab.Problems.ProgramSynthesis.Push.Constants {
+  public static class PushEnvironment {
+    public const char VectorStartSymbol = '[';
+    public const string VectorStartSymbolStr = "[";
+    public const char VectorEndSymbol = ']';
+    public const string VectorEndSymbolStr = "]";
+    public const char VectorSeparatorSymbol = ' ';
+    public const string VectorSeparatorSymbolStr = " ";
+
+    public const char ProgramStartSymbol = '(';
+    public const string ProgramStartSymbolStr = "(";
+    public const char ProgramEndSymbol = ')';
+    public const string ProgramEndSymbolStr = ")";
+
+    public const char CharSymbol = '\'';
+    public const char StringSymbol = '\"';
+    public const string CharSymbolStr = "'";
+    public const string StringSymbolStr = "\"";
+    public const string NewLine = "\n";
+  }
+}
Index: branches/PushGP/HeuristicLab.PushGP/HeuristicLab.Problems.ProgramSynthesis/Push/Data/Pool/IPooledObject.cs
===================================================================
--- branches/PushGP/HeuristicLab.PushGP/HeuristicLab.Problems.ProgramSynthesis/Push/Data/Pool/IPooledObject.cs	(revision 15033)
+++ branches/PushGP/HeuristicLab.PushGP/HeuristicLab.Problems.ProgramSynthesis/Push/Data/Pool/IPooledObject.cs	(revision 15189)
@@ -1,4 +1,5 @@
 ﻿namespace HeuristicLab.Problems.ProgramSynthesis.Push.Data.Pool {
   public interface IPooledObject {
+    void Init();
     void Reset();
   }
Index: branches/PushGP/HeuristicLab.PushGP/HeuristicLab.Problems.ProgramSynthesis/Push/Data/Pool/ManagedPoolProvider.cs
===================================================================
--- branches/PushGP/HeuristicLab.PushGP/HeuristicLab.Problems.ProgramSynthesis/Push/Data/Pool/ManagedPoolProvider.cs	(revision 15033)
+++ branches/PushGP/HeuristicLab.PushGP/HeuristicLab.Problems.ProgramSynthesis/Push/Data/Pool/ManagedPoolProvider.cs	(revision 15189)
@@ -10,4 +10,5 @@
   public interface IManagedPool<T> : IDisposable where T : class, IPooledObject {
     T Get(bool reset = true);
+    void Release();
   }
 
@@ -17,4 +18,5 @@
     private readonly BinaryFormatter binaryFormatter = new BinaryFormatter();
     private byte[] dummyPartition;
+    private static volatile object dummyCreationLockObject = new object();
 
     private static readonly FieldInfo InternalListArrayProperty = typeof(List<T[]>).GetField(
@@ -37,18 +39,7 @@
     public int InstanceCount { get { return partitions.Count * PartitionSize; } }
 
-    private void InitDummyPartition(Func<T> factory) {
-      var temp = new T[PartitionSize];
-
-      for (var i = 0u; i < PartitionSize; i++) {
-        temp[i] = factory();
-      }
-
-      using (var memoryStream = new MemoryStream()) {
-        binaryFormatter.Serialize(memoryStream, temp);
-        dummyPartition = memoryStream.ToArray();
-      }
-    }
-
     public void Clear() {
+      dummyPartition = null;
+      managedPools.Clear();
       partitions.Clear();
     }
@@ -65,11 +56,30 @@
 
     private T[] CloneDummyPartition() {
-      if (dummyPartition == null)
-        InitDummyPartition(factory);
+      if (dummyPartition == null) {
+        lock (dummyCreationLockObject) {
+          if (dummyPartition == null) {
+            var temp = new T[PartitionSize];
+
+            for (var i = 0u; i < PartitionSize; i++) {
+              temp[i] = factory();
+            }
+
+            using (var memoryStream = new MemoryStream()) {
+              binaryFormatter.Serialize(memoryStream, temp);
+              dummyPartition = memoryStream.ToArray();
+            }
+          }
+        }
+      }
 
       using (var memoryStream = new MemoryStream(dummyPartition)) {
         memoryStream.Seek(0, SeekOrigin.Begin);
 
-        return (T[])binaryFormatter.Deserialize(memoryStream);
+        var result = (T[])binaryFormatter.Deserialize(memoryStream);
+
+        for (var i = 0; i < result.Length; i++)
+          result[i].Init();
+
+        return result;
       }
     }
@@ -102,5 +112,5 @@
       }
 
-      public void Dispose() {
+      public void Release() {
         if (partitions.Count > 0) {
           provider.ReleasePartitions(partitions);
@@ -109,4 +119,8 @@
           entryIndex = provider.PartitionSize;
         }
+      }
+
+      public void Dispose() {
+        Release();
 
         provider.managedPools.Free(this);
Index: branches/PushGP/HeuristicLab.PushGP/HeuristicLab.Problems.ProgramSynthesis/Push/Data/Pool/ObjectPool.cs
===================================================================
--- branches/PushGP/HeuristicLab.PushGP/HeuristicLab.Problems.ProgramSynthesis/Push/Data/Pool/ObjectPool.cs	(revision 15033)
+++ branches/PushGP/HeuristicLab.PushGP/HeuristicLab.Problems.ProgramSynthesis/Push/Data/Pool/ObjectPool.cs	(revision 15189)
@@ -6,4 +6,5 @@
 
 namespace HeuristicLab.Problems.ProgramSynthesis.Push.Data.Pool {
+  using System.Collections.Generic;
   using System.Threading;
 
@@ -102,4 +103,23 @@
       }
     }
+
+    public void Clear() {
+      for (int i = 0; i < _items.Length; i++) {
+        _items[i] = default(Element);
+      }
+    }
+
+    public IEnumerable<T> Items
+    {
+      get
+      {
+        var items = _items;
+        for (var i = 0; i < items.Length; i++) {
+          if (items[i].Value != null) {
+            yield return items[i].Value;
+          }
+        }
+      }
+    }
   }
 }
Index: branches/PushGP/HeuristicLab.PushGP/HeuristicLab.Problems.ProgramSynthesis/Push/Data/Pool/PooledList.cs
===================================================================
--- branches/PushGP/HeuristicLab.PushGP/HeuristicLab.Problems.ProgramSynthesis/Push/Data/Pool/PooledList.cs	(revision 15033)
+++ branches/PushGP/HeuristicLab.PushGP/HeuristicLab.Problems.ProgramSynthesis/Push/Data/Pool/PooledList.cs	(revision 15189)
@@ -6,5 +6,11 @@
   [Serializable]
   public class PooledList<T> : List<T>, IPooledObject {
-    public void Reset() {
+    public Guid Id { get; private set; }
+
+    void IPooledObject.Init() {
+      Id = Guid.NewGuid();
+    }
+
+    void IPooledObject.Reset() {
       Clear();
     }
Index: branches/PushGP/HeuristicLab.PushGP/HeuristicLab.Problems.ProgramSynthesis/Push/Data/Pool/PooledObject.cs
===================================================================
--- branches/PushGP/HeuristicLab.PushGP/HeuristicLab.Problems.ProgramSynthesis/Push/Data/Pool/PooledObject.cs	(revision 15033)
+++ branches/PushGP/HeuristicLab.PushGP/HeuristicLab.Problems.ProgramSynthesis/Push/Data/Pool/PooledObject.cs	(revision 15189)
@@ -20,4 +20,6 @@
     }
 
+    void IPooledObject.Init() { }
+
     public void Reset() {
       resetor(item);
Index: branches/PushGP/HeuristicLab.PushGP/HeuristicLab.Problems.ProgramSynthesis/Push/Data/Tree/TreeExtensions.cs
===================================================================
--- branches/PushGP/HeuristicLab.PushGP/HeuristicLab.Problems.ProgramSynthesis/Push/Data/Tree/TreeExtensions.cs	(revision 15033)
+++ branches/PushGP/HeuristicLab.PushGP/HeuristicLab.Problems.ProgramSynthesis/Push/Data/Tree/TreeExtensions.cs	(revision 15189)
@@ -81,5 +81,5 @@
       }
 
-      return new PushProgram(expressions.ToArray());
+      return new PushProgram(expressions.ToList());
     }
   }
Index: branches/PushGP/HeuristicLab.PushGP/HeuristicLab.Problems.ProgramSynthesis/Push/Expressions/CharExpressions.cs
===================================================================
--- branches/PushGP/HeuristicLab.PushGP/HeuristicLab.Problems.ProgramSynthesis/Push/Expressions/CharExpressions.cs	(revision 15033)
+++ branches/PushGP/HeuristicLab.PushGP/HeuristicLab.Problems.ProgramSynthesis/Push/Expressions/CharExpressions.cs	(revision 15189)
@@ -151,5 +151,5 @@
 
     public override void Eval(IInternalPushInterpreter interpreter) {
-      var chars = interpreter.StringStack.Pop().Reverse().ToArray();
+      var chars = interpreter.StringStack.Pop().Reverse().ToList();
       interpreter.CharStack.Push(chars);
     }
Index: branches/PushGP/HeuristicLab.PushGP/HeuristicLab.Problems.ProgramSynthesis/Push/Expressions/Expression.cs
===================================================================
--- branches/PushGP/HeuristicLab.PushGP/HeuristicLab.Problems.ProgramSynthesis/Push/Expressions/Expression.cs	(revision 15033)
+++ branches/PushGP/HeuristicLab.PushGP/HeuristicLab.Problems.ProgramSynthesis/Push/Expressions/Expression.cs	(revision 15189)
@@ -43,10 +43,12 @@
 
     public object Clone() {
+      return Clone(new Cloner());
+    }
+
+    public virtual IDeepCloneable Clone(Cloner cloner) {
       return this;
     }
 
-    public IDeepCloneable Clone(Cloner cloner) {
-      return this;
-    }
+    void IPooledObject.Init() { }
 
     void IPooledObject.Reset() { }
Index: branches/PushGP/HeuristicLab.PushGP/HeuristicLab.Problems.ProgramSynthesis/Push/Expressions/ExpressionTable.cs
===================================================================
--- branches/PushGP/HeuristicLab.PushGP/HeuristicLab.Problems.ProgramSynthesis/Push/Expressions/ExpressionTable.cs	(revision 15033)
+++ branches/PushGP/HeuristicLab.PushGP/HeuristicLab.Problems.ProgramSynthesis/Push/Expressions/ExpressionTable.cs	(revision 15189)
@@ -25,6 +25,6 @@
 
     static ExpressionTable() {
-      StatelessExpressionTypes = GetExpressionTypes(typeof(StatelessExpression)).ToArray();
-      StatefulExpressionTypes = GetExpressionTypes(typeof(StatefulExpression<>)).ToArray();
+      StatelessExpressionTypes = GetExpressionTypes(typeof(StatelessExpression)).ToList();
+      StatefulExpressionTypes = GetExpressionTypes(typeof(StatefulExpression<>)).ToList();
 
       StatelessExpressionTable = GetStatelessExpressionTable();
@@ -35,5 +35,5 @@
         .Where(t => typeToNameTable.ContainsKey(t))
         .Select(type => typeToNameTable[type])
-        .ToArray();
+        .ToList();
 
       ExpressionCount = StatelessExpressionTable.Count + StatefulExpressionFactory.Count;
@@ -57,6 +57,6 @@
         dictionary.Add(type, expression);
 
-        // do not index hidden expressions like push expression in tables
-        if (attribute.IsHidden) continue;
+        //// do not index hidden expressions like push expression in tables
+        //if (attribute.IsHidden) continue;
 
         indexToNameTable.Add(indexToNameTable.Keys.Count, attribute.Name);
@@ -156,5 +156,5 @@
           .Where(entry => (entry.Key & ~allowedTypes) == 0x0)
           .SelectMany(entry => entry.Value)
-          .ToArray();
+          .ToList();
     }
 
Index: branches/PushGP/HeuristicLab.PushGP/HeuristicLab.Problems.ProgramSynthesis/Push/Expressions/InExpressions.cs
===================================================================
--- branches/PushGP/HeuristicLab.PushGP/HeuristicLab.Problems.ProgramSynthesis/Push/Expressions/InExpressions.cs	(revision 15189)
+++ branches/PushGP/HeuristicLab.PushGP/HeuristicLab.Problems.ProgramSynthesis/Push/Expressions/InExpressions.cs	(revision 15189)
@@ -0,0 +1,161 @@
+﻿namespace HeuristicLab.Problems.ProgramSynthesis.Push.Expressions {
+  using HeuristicLab.Persistence.Default.CompositeSerializers.Storable;
+  using HeuristicLab.Problems.ProgramSynthesis.Push.Attributes;
+  using HeuristicLab.Problems.ProgramSynthesis.Push.Interpreter;
+  using HeuristicLab.Problems.ProgramSynthesis.Push.Stack;
+
+  /// <summary>
+  /// InExpression has a state, but this state is static at compile time and therefore InExpression can be seen as stateless at runtime
+  /// </summary>
+  [StorableClass]
+  public abstract class InExpression : StatelessExpression {
+    private readonly int index;
+
+    protected InExpression(int nr) {
+      this.index = nr - 1;
+    }
+
+    [StorableConstructor]
+    protected InExpression(bool deserializing) : base(deserializing) { }
+
+    public override bool IsNoop(IInternalPushInterpreter interpreter) {
+      return false;
+    }
+
+    public override void Eval(IInternalPushInterpreter interpreter) {
+      var inputArgument = interpreter.InputExpressions[index];
+
+      inputArgument.Eval(interpreter);
+    }
+  }
+
+  [PushExpression(
+    StackTypes.None,
+    "IN1",
+    "Pushes first input parameter.",
+    isHidden: true)]
+  [StorableClass]
+  public class In1Expression : InExpression {
+    public In1Expression() : base(1) { }
+
+    [StorableConstructor]
+    protected In1Expression(bool deserializing) : base(deserializing) { }
+  }
+
+  [PushExpression(
+    StackTypes.None,
+    "IN2",
+    "Pushes second input parameter.",
+    isHidden: true)]
+  [StorableClass]
+  public class In2Expression : InExpression {
+    public In2Expression() : base(2) { }
+
+    [StorableConstructor]
+    protected In2Expression(bool deserializing) : base(deserializing) { }
+  }
+
+  [PushExpression(
+   StackTypes.None,
+   "IN3",
+   "Pushes third input parameter.",
+    isHidden: true)]
+  [StorableClass]
+  public class In3Expression : InExpression {
+    public In3Expression() : base(3) { }
+
+    [StorableConstructor]
+    protected In3Expression(bool deserializing) : base(deserializing) { }
+  }
+
+  [PushExpression(
+    StackTypes.None,
+    "IN4",
+    "Pushes fourth input parameter.",
+    isHidden: true)]
+  [StorableClass]
+  public class In4Expression : InExpression {
+    public In4Expression() : base(4) { }
+
+    [StorableConstructor]
+    protected In4Expression(bool deserializing) : base(deserializing) { }
+  }
+
+  [PushExpression(
+    StackTypes.None,
+    "IN5",
+    "Pushes fifth input parameter.",
+    isHidden: true)]
+  [StorableClass]
+  public class In5Expression : InExpression {
+    public In5Expression() : base(5) { }
+
+    [StorableConstructor]
+    protected In5Expression(bool deserializing) : base(deserializing) { }
+  }
+
+  [PushExpression(
+    StackTypes.None,
+    "IN6",
+    "Pushes sixth input parameter.",
+    isHidden: true)]
+  [StorableClass]
+  public class In6Expression : InExpression {
+    public In6Expression() : base(6) { }
+
+    [StorableConstructor]
+    protected In6Expression(bool deserializing) : base(deserializing) { }
+  }
+
+  [PushExpression(
+    StackTypes.None,
+    "IN7",
+    "Pushes seventh input parameter.",
+    isHidden: true)]
+  [StorableClass]
+  public class In7Expression : InExpression {
+    public In7Expression() : base(7) { }
+
+    [StorableConstructor]
+    protected In7Expression(bool deserializing) : base(deserializing) { }
+  }
+
+  [PushExpression(
+    StackTypes.None,
+    "IN8",
+    "Pushes eighth input parameter.",
+    isHidden: true)]
+  [StorableClass]
+  public class In8Expression : InExpression {
+    public In8Expression() : base(8) { }
+
+    [StorableConstructor]
+    protected In8Expression(bool deserializing) : base(deserializing) { }
+  }
+
+  [PushExpression(
+    StackTypes.None,
+    "IN9",
+    "Pushes nineth input parameter.",
+    isHidden: true)]
+  [StorableClass]
+  public class In9Expression : InExpression {
+    public In9Expression() : base(9) { }
+
+    [StorableConstructor]
+    protected In9Expression(bool deserializing) : base(deserializing) { }
+  }
+
+  [PushExpression(
+    StackTypes.None,
+    "IN10",
+    "Pushes tenth input parameter.",
+    isHidden: true)]
+  [StorableClass]
+  public class In10Expression : InExpression {
+    public In10Expression() : base(10) { }
+
+    [StorableConstructor]
+    protected In10Expression(bool deserializing) : base(deserializing) { }
+  }
+}
Index: branches/PushGP/HeuristicLab.PushGP/HeuristicLab.Problems.ProgramSynthesis/Push/Expressions/PrintExpressions.cs
===================================================================
--- branches/PushGP/HeuristicLab.PushGP/HeuristicLab.Problems.ProgramSynthesis/Push/Expressions/PrintExpressions.cs	(revision 15033)
+++ branches/PushGP/HeuristicLab.PushGP/HeuristicLab.Problems.ProgramSynthesis/Push/Expressions/PrintExpressions.cs	(revision 15189)
@@ -2,8 +2,8 @@
   using System.Collections.Generic;
   using System.Globalization;
-  using System.Text;
   using Attributes;
   using HeuristicLab.Persistence.Default.CompositeSerializers.Storable;
   using HeuristicLab.Problems.ProgramSynthesis.Push.Constants;
+
   using Interpreter;
   using Stack;
@@ -21,5 +21,5 @@
 
     public override void Eval(IInternalPushInterpreter interpreter) {
-      interpreter.PrintStack.Push(string.Empty);
+      interpreter.PrintStack.NewLine();
     }
   }
@@ -28,35 +28,29 @@
   public abstract class PrintExpression<T> : StatelessExpression {
     protected PrintExpression() { }
+
     [StorableConstructor]
     protected PrintExpression(bool deserializing) : base(deserializing) { }
 
     protected void Eval(IInternalPushInterpreter interpreter, IPushStack<T> stack) {
-      var value = stack.Pop().ToString();
-
-      if (interpreter.PrintStack.IsEmpty)
-        interpreter.PrintStack.Push(value);
-      else
-        interpreter.PrintStack.Top += value;
+      var value = stack.Pop();
+
+      interpreter.PrintStack.Push(value);
     }
 
     protected void EvalVector(IInternalPushInterpreter interpreter, IPushStack<IReadOnlyList<T>> vectorStack) {
-      var sb = new StringBuilder();
       var vector = vectorStack.Pop();
 
-      sb.Append(PushEnvironment.VectorStartSymbol);
+      interpreter.PrintStack.Push(PushEnvironment.VectorStartSymbol);
 
       if (vector.Count > 0) {
-        sb.Append(vector[0]);
+        interpreter.PrintStack.Push(vector[0]);
 
         for (var i = 1; i < vector.Count; i++) {
-          sb.Append(PushEnvironment.VectorSeparatorSymbol);
-          sb.Append(vector[i]);
+          interpreter.PrintStack.Push(PushEnvironment.VectorSeparatorSymbol);
+          interpreter.PrintStack.Push(vector[i]);
         }
       }
 
-      sb.Append(PushEnvironment.VectorEndSymbol);
-
-      var value = sb.ToString();
-      interpreter.PrintStack.Push(value);
+      interpreter.PrintStack.Push(PushEnvironment.VectorEndSymbol);
     }
   }
@@ -165,5 +159,6 @@
 
     public override void Eval(IInternalPushInterpreter interpreter) {
-      Eval(interpreter, interpreter.IntegerStack);
+      var value = interpreter.IntegerStack.Pop();
+      interpreter.PrintStack.Push(value);
     }
   }
Index: branches/PushGP/HeuristicLab.PushGP/HeuristicLab.Problems.ProgramSynthesis/Push/Expressions/PushProgram.cs
===================================================================
--- branches/PushGP/HeuristicLab.PushGP/HeuristicLab.Problems.ProgramSynthesis/Push/Expressions/PushProgram.cs	(revision 15033)
+++ branches/PushGP/HeuristicLab.PushGP/HeuristicLab.Problems.ProgramSynthesis/Push/Expressions/PushProgram.cs	(revision 15189)
@@ -8,4 +8,7 @@
   using Data.Pool;
   using Extensions;
+
+  using HeuristicLab.Common;
+
   using Interpreter;
   using Persistence.Default.CompositeSerializers.Storable;
@@ -41,4 +44,16 @@
     }
 
+    public PushProgram(PushProgram origin, Cloner cloner) {
+      stringRepresentation = origin.stringRepresentation;
+      hashCode = origin.hashCode;
+      depth = origin.depth;
+      treeIndex = origin.treeIndex;
+      expressions = new List<Expression>(origin.expressions);
+    }
+
+    public override IDeepCloneable Clone(Cloner cloner) {
+      return new PushProgram(this, cloner);
+    }
+
     public bool IsEmpty { get { return Count == 0; } }
     public int Count { get { return expressions.Count; } }
@@ -51,4 +66,6 @@
       return program;
     }
+
+    void IPooledObject.Init() { }
 
     void IPooledObject.Reset() {
@@ -263,4 +280,21 @@
             yield return sub;
         else yield return expr;
+      }
+    }
+
+    public IReadOnlyList<Expression> Flatten() {
+      var result = new List<Expression>();
+      Flatten(result);
+      return result;
+    }
+
+    private void Flatten(List<Expression> result) {
+      result.AddRange(expressions);
+
+      for (var i = 0; i < expressions.Count; i++) {
+        var expr = expressions[i];
+        if (expr.IsProgram) {
+          ((PushProgram)expr).Flatten(result);
+        }
       }
     }
Index: branches/PushGP/HeuristicLab.PushGP/HeuristicLab.Problems.ProgramSynthesis/Push/Expressions/StatefulExpression.cs
===================================================================
--- branches/PushGP/HeuristicLab.PushGP/HeuristicLab.Problems.ProgramSynthesis/Push/Expressions/StatefulExpression.cs	(revision 15033)
+++ branches/PushGP/HeuristicLab.PushGP/HeuristicLab.Problems.ProgramSynthesis/Push/Expressions/StatefulExpression.cs	(revision 15189)
@@ -69,4 +69,6 @@
     }
 
+    void IPooledObject.Init() { }
+
     public void Reset() {
       State = default(T);
Index: branches/PushGP/HeuristicLab.PushGP/HeuristicLab.Problems.ProgramSynthesis/Push/Expressions/StringExpressions.cs
===================================================================
--- branches/PushGP/HeuristicLab.PushGP/HeuristicLab.Problems.ProgramSynthesis/Push/Expressions/StringExpressions.cs	(revision 15033)
+++ branches/PushGP/HeuristicLab.PushGP/HeuristicLab.Problems.ProgramSynthesis/Push/Expressions/StringExpressions.cs	(revision 15189)
@@ -453,7 +453,7 @@
         .Where(x => !string.IsNullOrWhiteSpace(x))
         .Reverse()
-        .ToArray();
-
-      if (words.Length == 0) {
+        .ToList();
+
+      if (words.Count == 0) {
         interpreter.StringStack.Pop();
       } else {
Index: branches/PushGP/HeuristicLab.PushGP/HeuristicLab.Problems.ProgramSynthesis/Push/Expressions/VectorButLastExpressions.cs
===================================================================
--- branches/PushGP/HeuristicLab.PushGP/HeuristicLab.Problems.ProgramSynthesis/Push/Expressions/VectorButLastExpressions.cs	(revision 15033)
+++ branches/PushGP/HeuristicLab.PushGP/HeuristicLab.Problems.ProgramSynthesis/Push/Expressions/VectorButLastExpressions.cs	(revision 15189)
@@ -25,5 +25,5 @@
       vectorStack.Top = vectorStack.Top
         .Take(vectorStack.Top.Count - 1)
-        .ToArray();
+        .ToList();
     }
   }
Index: branches/PushGP/HeuristicLab.PushGP/HeuristicLab.Problems.ProgramSynthesis/Push/Expressions/VectorIterateExpressions.cs
===================================================================
--- branches/PushGP/HeuristicLab.PushGP/HeuristicLab.Problems.ProgramSynthesis/Push/Expressions/VectorIterateExpressions.cs	(revision 15033)
+++ branches/PushGP/HeuristicLab.PushGP/HeuristicLab.Problems.ProgramSynthesis/Push/Expressions/VectorIterateExpressions.cs	(revision 15189)
@@ -56,5 +56,5 @@
         }
 
-        vectorStack.Top = vector.Take(last).ToArray();
+        vectorStack.Top = vector.Take(last).ToList();
       }
     }
Index: branches/PushGP/HeuristicLab.PushGP/HeuristicLab.Problems.ProgramSynthesis/Push/Expressions/VectorPushAllExpressions.cs
===================================================================
--- branches/PushGP/HeuristicLab.PushGP/HeuristicLab.Problems.ProgramSynthesis/Push/Expressions/VectorPushAllExpressions.cs	(revision 15033)
+++ branches/PushGP/HeuristicLab.PushGP/HeuristicLab.Problems.ProgramSynthesis/Push/Expressions/VectorPushAllExpressions.cs	(revision 15189)
@@ -23,5 +23,5 @@
 
     protected void Eval(IPushStack<IReadOnlyList<T>> vectorStack, IPushStack<T> literalStack) {
-      var vector = vectorStack.Pop().Reverse().ToArray();
+      var vector = vectorStack.Pop().Reverse().ToList();
       literalStack.Push(vector);
     }
Index: branches/PushGP/HeuristicLab.PushGP/HeuristicLab.Problems.ProgramSynthesis/Push/Expressions/VectorRemoveExpressions.cs
===================================================================
--- branches/PushGP/HeuristicLab.PushGP/HeuristicLab.Problems.ProgramSynthesis/Push/Expressions/VectorRemoveExpressions.cs	(revision 15033)
+++ branches/PushGP/HeuristicLab.PushGP/HeuristicLab.Problems.ProgramSynthesis/Push/Expressions/VectorRemoveExpressions.cs	(revision 15189)
@@ -25,5 +25,5 @@
     protected void Eval(IPushStack<IReadOnlyList<T>> vectorStack, IPushStack<T> literalStack) {
       var literal = literalStack.Pop();
-      vectorStack.Top = vectorStack.Top.Where(x => !x.Equals(literal)).ToArray();
+      vectorStack.Top = vectorStack.Top.Where(x => !x.Equals(literal)).ToList();
     }
   }
@@ -92,6 +92,6 @@
   [PushExpression(
     StackTypes.StringVector,
+    "STRING[].REMOVE",
     "Removes all occurrences of the top STRING in the top STRING[].",
-    "STRING[].REMOVE",
     StackTypes.String)]
   public class StringVectorRemoveExpression : VectorRemoveExpression<string> {
Index: branches/PushGP/HeuristicLab.PushGP/HeuristicLab.Problems.ProgramSynthesis/Push/Expressions/VectorRestExpressions.cs
===================================================================
--- branches/PushGP/HeuristicLab.PushGP/HeuristicLab.Problems.ProgramSynthesis/Push/Expressions/VectorRestExpressions.cs	(revision 15033)
+++ branches/PushGP/HeuristicLab.PushGP/HeuristicLab.Problems.ProgramSynthesis/Push/Expressions/VectorRestExpressions.cs	(revision 15189)
@@ -42,5 +42,5 @@
       }
 
-      vectorStack.Top = vector.Skip(1).ToArray();
+      vectorStack.Top = vector.Skip(1).ToList();
     }
   }
Index: branches/PushGP/HeuristicLab.PushGP/HeuristicLab.Problems.ProgramSynthesis/Push/Expressions/VectorReverseExpressions.cs
===================================================================
--- branches/PushGP/HeuristicLab.PushGP/HeuristicLab.Problems.ProgramSynthesis/Push/Expressions/VectorReverseExpressions.cs	(revision 15033)
+++ branches/PushGP/HeuristicLab.PushGP/HeuristicLab.Problems.ProgramSynthesis/Push/Expressions/VectorReverseExpressions.cs	(revision 15189)
@@ -25,5 +25,5 @@
 
     protected void Eval(IPushStack<IReadOnlyList<T>> vectorStack) {
-      vectorStack.Top = vectorStack.Top.Reverse().ToArray();
+      vectorStack.Top = vectorStack.Top.Reverse().ToList();
     }
   }
Index: branches/PushGP/HeuristicLab.PushGP/HeuristicLab.Problems.ProgramSynthesis/Push/Expressions/VectorSubExpressions.cs
===================================================================
--- branches/PushGP/HeuristicLab.PushGP/HeuristicLab.Problems.ProgramSynthesis/Push/Expressions/VectorSubExpressions.cs	(revision 15033)
+++ branches/PushGP/HeuristicLab.PushGP/HeuristicLab.Problems.ProgramSynthesis/Push/Expressions/VectorSubExpressions.cs	(revision 15189)
@@ -51,5 +51,5 @@
       }
 
-      vectorStack.Top = vector.Skip(first).Take(lenght).ToArray();
+      vectorStack.Top = vector.Skip(first).Take(lenght).ToList();
     }
   }
Index: branches/PushGP/HeuristicLab.PushGP/HeuristicLab.Problems.ProgramSynthesis/Push/Expressions/VectorTakeExpressions.cs
===================================================================
--- branches/PushGP/HeuristicLab.PushGP/HeuristicLab.Problems.ProgramSynthesis/Push/Expressions/VectorTakeExpressions.cs	(revision 15033)
+++ branches/PushGP/HeuristicLab.PushGP/HeuristicLab.Problems.ProgramSynthesis/Push/Expressions/VectorTakeExpressions.cs	(revision 15189)
@@ -53,5 +53,5 @@
       }
 
-      vectorStack.Top = vector.Take(count).ToArray();
+      vectorStack.Top = vector.Take(count).ToList();
     }
   }
Index: branches/PushGP/HeuristicLab.PushGP/HeuristicLab.Problems.ProgramSynthesis/Push/Extensions/ProblemDataExtensions.cs
===================================================================
--- branches/PushGP/HeuristicLab.PushGP/HeuristicLab.Problems.ProgramSynthesis/Push/Extensions/ProblemDataExtensions.cs	(revision 15189)
+++ branches/PushGP/HeuristicLab.PushGP/HeuristicLab.Problems.ProgramSynthesis/Push/Extensions/ProblemDataExtensions.cs	(revision 15189)
@@ -0,0 +1,25 @@
+﻿using System;
+
+namespace HeuristicLab.Problems.ProgramSynthesis.Push.Extensions {
+  using HeuristicLab.BenchmarkSuite;
+  using HeuristicLab.Problems.ProgramSynthesis.Push.Configuration;
+  using HeuristicLab.Problems.ProgramSynthesis.Push.Expressions;
+
+  public static class ProblemDataExtensions {
+    public static void InitInExpressions(this ProblemData data, IEnabledExpressionsConfiguration config) {
+      if (data.TotalIntputArgumentCount >= 1) config.EnableExpression<In1Expression>();
+      if (data.TotalIntputArgumentCount >= 2) config.EnableExpression<In2Expression>();
+      if (data.TotalIntputArgumentCount >= 3) config.EnableExpression<In3Expression>();
+      if (data.TotalIntputArgumentCount >= 4) config.EnableExpression<In4Expression>();
+      if (data.TotalIntputArgumentCount >= 5) config.EnableExpression<In5Expression>();
+      if (data.TotalIntputArgumentCount >= 6) config.EnableExpression<In6Expression>();
+      if (data.TotalIntputArgumentCount >= 7) config.EnableExpression<In7Expression>();
+      if (data.TotalIntputArgumentCount >= 8) config.EnableExpression<In8Expression>();
+      if (data.TotalIntputArgumentCount >= 9) config.EnableExpression<In9Expression>();
+      if (data.TotalIntputArgumentCount == 10) config.EnableExpression<In10Expression>();
+
+      if (data.TotalIntputArgumentCount > 10)
+        throw new InvalidOperationException("More input arguments defined as InExpressions types");
+    }
+  }
+}
Index: branches/PushGP/HeuristicLab.PushGP/HeuristicLab.Problems.ProgramSynthesis/Push/Extensions/StringBuilderExtensions.cs
===================================================================
--- branches/PushGP/HeuristicLab.PushGP/HeuristicLab.Problems.ProgramSynthesis/Push/Extensions/StringBuilderExtensions.cs	(revision 15189)
+++ branches/PushGP/HeuristicLab.PushGP/HeuristicLab.Problems.ProgramSynthesis/Push/Extensions/StringBuilderExtensions.cs	(revision 15189)
@@ -0,0 +1,236 @@
+﻿namespace HeuristicLab.Problems.ProgramSynthesis.Push.Extensions {
+  using System;
+  using System.Diagnostics;
+  using System.Globalization;
+  using System.Text;
+
+  public static class StringBuilderExtension {
+    // These digits are here in a static array to support hex with simple, easily-understandable code.
+    // Since A-Z don't sit next to 0-9 in the ascii table.
+    private static readonly char[] MsDigits =
+      {
+        '0', '1', '2', '3', '4', '5', '6', '7', '8', '9', 'A', 'B', 'C', 'D',
+        'E', 'F'
+      };
+
+    //private static readonly ulong MsDefaultDecimalPlaces = 5; //< Matches standard .NET formatting dp's
+
+    private const char MsDefaultPadChar = '0';
+
+    //! Convert a given unsigned integer value to a string and concatenate onto the stringbuilder. Any base value allowed.
+    public static StringBuilder Concat(
+      this StringBuilder stringBuilder,
+      ulong ulongVal,
+      ulong padAmount,
+      char padChar,
+      ulong baseVal) {
+      Debug.Assert((baseVal > 0) && (baseVal <= 16));
+
+      // Calculate length of integer when written out
+      ulong length = 0;
+      var lengthCalc = ulongVal;
+
+      do {
+        lengthCalc /= baseVal;
+        length++;
+      }
+      while (lengthCalc > 0);
+
+      // Pad out space for writing.
+      stringBuilder.Append(padChar, (int)Math.Max(padAmount, length));
+
+      var strpos = stringBuilder.Length;
+
+      // We're writing backwards, one character at a time.
+      while (length > 0) {
+        strpos--;
+
+        // Lookup from static char array, to cover hex values too
+        stringBuilder[strpos] = MsDigits[ulongVal % baseVal];
+
+        ulongVal /= baseVal;
+        length--;
+      }
+
+      return stringBuilder;
+    }
+
+    //! Convert a given unsigned integer value to a string and concatenate onto the stringbuilder. Assume no padding and base ten.
+    public static StringBuilder Concat(this StringBuilder stringBuilder, ulong ulongVal) {
+      stringBuilder.Concat(ulongVal, 0, MsDefaultPadChar, 10);
+      return stringBuilder;
+    }
+
+    //! Convert a given unsigned integer value to a string and concatenate onto the stringbuilder. Assume base ten.
+    public static StringBuilder Concat(this StringBuilder stringBuilder, ulong ulongVal, ulong padAmount) {
+      stringBuilder.Concat(ulongVal, padAmount, MsDefaultPadChar, 10);
+      return stringBuilder;
+    }
+
+    //! Convert a given unsigned integer value to a string and concatenate onto the stringbuilder. Assume base ten.
+    public static StringBuilder Concat(
+      this StringBuilder stringBuilder,
+      ulong ulongVal,
+      ulong padAmount,
+      char padChar) {
+      stringBuilder.Concat(ulongVal, padAmount, padChar, 10);
+      return stringBuilder;
+    }
+
+    //! Convert a given signed integer value to a string and concatenate onto the stringbuilder. Any base value allowed.
+    public static StringBuilder Concat(
+      this StringBuilder stringBuilder,
+      long longVal,
+      ulong padAmount,
+      char padChar,
+      ulong baseVal) {
+      Debug.Assert((baseVal > 0) && (baseVal <= 16));
+
+      // Deal with negative numbers
+      if (longVal < 0) {
+        stringBuilder.Append('-');
+        var ulongVal = ulong.MaxValue - (ulong)longVal + 1; //< This is to deal with Int64.MinValue
+        stringBuilder.Concat(ulongVal, padAmount, padChar, baseVal);
+      } else {
+        stringBuilder.Concat((ulong)longVal, padAmount, padChar, baseVal);
+      }
+
+      return stringBuilder;
+    }
+
+    //! Convert a given signed integer value to a string and concatenate onto the stringbuilder. Assume no padding and base ten.
+    public static StringBuilder Concat(this StringBuilder stringBuilder, long longVal) {
+      stringBuilder.Concat(longVal, 0, MsDefaultPadChar, 10);
+      return stringBuilder;
+    }
+
+    //! Convert a given signed integer value to a string and concatenate onto the stringbuilder. Assume base ten.
+    public static StringBuilder Concat(this StringBuilder stringBuilder, long longVal, ulong padAmount) {
+      stringBuilder.Concat(longVal, padAmount, MsDefaultPadChar, 10);
+      return stringBuilder;
+    }
+
+    //! Convert a given signed integer value to a string and concatenate onto the stringbuilder. Assume base ten.
+    public static StringBuilder Concat(
+      this StringBuilder stringBuilder,
+      long longVal,
+      ulong padAmount,
+      char padChar) {
+      stringBuilder.Concat(longVal, padAmount, padChar, 10);
+      return stringBuilder;
+    }
+
+    //! Convert a given signed integer value to a string and concatenate onto the stringbuilder. Any base value allowed.
+    public static StringBuilder Concat(
+      this StringBuilder stringBuilder,
+      int intVal,
+      ulong padAmount,
+      char padChar,
+      ulong baseVal) {
+      Debug.Assert((baseVal > 0) && (baseVal <= 16));
+
+      // Deal with negative numbers
+      if (intVal < 0) {
+        stringBuilder.Append('-');
+        var ulongVal = ulong.MaxValue - (ulong)intVal + 1; //< This is to deal with Int32.MinValue
+        stringBuilder.Concat(ulongVal, padAmount, padChar, baseVal);
+      } else {
+        stringBuilder.Concat((ulong)intVal, padAmount, padChar, baseVal);
+      }
+
+      return stringBuilder;
+    }
+
+    //! Convert a given signed integer value to a string and concatenate onto the stringbuilder. Assume no padding and base ten.
+    public static StringBuilder Concat(this StringBuilder stringBuilder, int intVal) {
+      stringBuilder.Concat(intVal, 0, MsDefaultPadChar, 10);
+      return stringBuilder;
+    }
+
+    //! Convert a given signed integer value to a string and concatenate onto the stringbuilder. Assume base ten.
+    public static StringBuilder Concat(this StringBuilder stringBuilder, int intVal, ulong padAmount) {
+      stringBuilder.Concat(intVal, padAmount, MsDefaultPadChar, 10);
+      return stringBuilder;
+    }
+
+    //! Convert a given signed integer value to a string and concatenate onto the stringbuilder. Assume base ten.
+    public static StringBuilder Concat(this StringBuilder stringBuilder, int intVal, ulong padAmount, char padChar) {
+      stringBuilder.Concat(intVal, padAmount, padChar, 10);
+      return stringBuilder;
+    }
+
+    //! Convert a given double value to a string and concatenate onto the stringbuilder
+    public static StringBuilder Concat(
+      this StringBuilder stringBuilder,
+      double doubleVal,
+      uint decimalPlaces,
+      uint padAmount,
+      char padChar,
+      CultureInfo culturInfo = null) {
+      culturInfo = culturInfo ?? CultureInfo.CurrentCulture;
+
+      if (decimalPlaces == 0) {
+        // No decimal places, just round up and print it as an int
+
+        // Agh, Math.Floor() just works on doubles/decimals. Don't want to cast! Let's do this the old-fashioned way.
+        int intVal;
+        if (doubleVal >= 0.0d) intVal = (int)(doubleVal + 0.5d);
+        else intVal = (int)(doubleVal - 0.5d);
+
+        stringBuilder.Concat(intVal, padAmount, padChar, 10);
+      } else {
+        var intPart = (int)doubleVal;
+
+        // First part is easy, just cast to an integer
+        stringBuilder.Concat(intPart, padAmount, padChar, 10);
+
+        // Decimal point
+        var numberDecimalSeparator = Convert.ToChar(culturInfo.NumberFormat.NumberDecimalSeparator);
+        stringBuilder.Append(numberDecimalSeparator);
+
+        // Work out remainder we need to print after the d.p.
+        var remainder = Math.Abs(doubleVal - intPart);
+
+        // Multiply up to become an int that we can print
+        do {
+          remainder *= 10;
+          decimalPlaces--;
+        }
+        while (remainder > (int)remainder && decimalPlaces > 0);
+
+        // Round up. It's guaranteed to be a positive number, so no extra work required here.
+        remainder += 0.5d;
+
+        // All done, print that as an int!
+        stringBuilder.Concat((ulong)remainder, 0, '0', 10);
+      }
+      return stringBuilder;
+    }
+
+    //! Convert a given double value to a string and concatenate onto the stringbuilder. Assumes five decimal places, and no padding.
+    public static StringBuilder Concat(this StringBuilder stringBuilder, double doubleVal, CultureInfo culturInfo = null) {
+      culturInfo = culturInfo ?? CultureInfo.CurrentCulture;
+
+      stringBuilder.Concat(doubleVal, (uint)culturInfo.NumberFormat.NumberDecimalDigits, 0, MsDefaultPadChar, culturInfo);
+      return stringBuilder;
+    }
+
+    //! Convert a given double value to a string and concatenate onto the stringbuilder. Assumes no padding.
+    public static StringBuilder Concat(this StringBuilder stringBuilder, double doubleVal, uint decimalPlaces, CultureInfo culturInfo = null) {
+      stringBuilder.Concat(doubleVal, decimalPlaces, 0, MsDefaultPadChar, culturInfo);
+      return stringBuilder;
+    }
+
+    //! Convert a given double value to a string and concatenate onto the stringbuilder.
+    public static StringBuilder Concat(
+      this StringBuilder stringBuilder,
+      double doubleVal,
+      uint decimalPlaces,
+      uint padAmount,
+      CultureInfo culturInfo = null) {
+
+      stringBuilder.Concat(doubleVal, decimalPlaces, padAmount, MsDefaultPadChar, culturInfo);
+      return stringBuilder;
+    }
+  }
+}
Index: branches/PushGP/HeuristicLab.PushGP/HeuristicLab.Problems.ProgramSynthesis/Push/Generators/CodeGenerator/CodeGeneratorUtils.cs
===================================================================
--- branches/PushGP/HeuristicLab.PushGP/HeuristicLab.Problems.ProgramSynthesis/Push/Generators/CodeGenerator/CodeGeneratorUtils.cs	(revision 15033)
+++ branches/PushGP/HeuristicLab.PushGP/HeuristicLab.Problems.ProgramSynthesis/Push/Generators/CodeGenerator/CodeGeneratorUtils.cs	(revision 15189)
@@ -38,18 +38,22 @@
       IRandom random,
       IReadOnlyErcOptions ercOptions) {
-      var x = random.NextDouble();
-      Expression expression = null;
+      //var x = random.NextDouble();
+      //Expression expression = null;
 
-      if (x < ercOptions.ErcProbability) {
-        var expressionType = ExpressionTable.NameToTypeTable[expressionName];
-        expression = CreateRandomErcExpression(
-            ExpressionTable.TypeToAttributeTable[expressionType].StackType,
-            random,
-            ercOptions);
-      }
+      //if (x < ercOptions.ErcProbability) {
+      //  var expressionType = ExpressionTable.NameToTypeTable[expressionName];
+      //  expression = CreateRandomErcExpression(
+      //      ExpressionTable.TypeToAttributeTable[expressionType].StackType,
+      //      random,
+      //      ercOptions);
+      //}
 
-      if (expression == null || expression is ExecNoopExpression) {
-        expression = ExpressionTable.GetExpression(expressionName);
-      }
+      //if (expression == null || expression is ExecNoopExpression) {
+      //  expression = ExpressionTable.GetExpression(expressionName);
+      //}
+
+      //return expression;
+
+      var expression = ExpressionTable.GetExpression(expressionName);
 
       return expression;
Index: branches/PushGP/HeuristicLab.PushGP/HeuristicLab.Problems.ProgramSynthesis/Push/Generators/CodeGenerator/RecursiveCodeGenerator.cs
===================================================================
--- branches/PushGP/HeuristicLab.PushGP/HeuristicLab.Problems.ProgramSynthesis/Push/Generators/CodeGenerator/RecursiveCodeGenerator.cs	(revision 15033)
+++ branches/PushGP/HeuristicLab.PushGP/HeuristicLab.Problems.ProgramSynthesis/Push/Generators/CodeGenerator/RecursiveCodeGenerator.cs	(revision 15189)
@@ -23,5 +23,5 @@
       var code = RandomCode(maxPoints, random, pushGpConfiguration, customExpressions);
 
-      return PushProgram.Create(pool, code.ToArray());
+      return PushProgram.Create(pool, code.ToList());
     }
 
@@ -29,5 +29,5 @@
       var code = RandomCode(maxPoints, random, pushGpConfiguration, customExpressions);
 
-      return new PushProgram(code.ToArray());
+      return new PushProgram(code.ToList());
     }
 
Index: branches/PushGP/HeuristicLab.PushGP/HeuristicLab.Problems.ProgramSynthesis/Push/Individual/IndividualExtensions.cs
===================================================================
--- branches/PushGP/HeuristicLab.PushGP/HeuristicLab.Problems.ProgramSynthesis/Push/Individual/IndividualExtensions.cs	(revision 15189)
+++ branches/PushGP/HeuristicLab.PushGP/HeuristicLab.Problems.ProgramSynthesis/Push/Individual/IndividualExtensions.cs	(revision 15189)
@@ -0,0 +1,71 @@
+﻿namespace HeuristicLab.Problems.ProgramSynthesis.Push.Individual {
+  using System.Collections.Generic;
+
+  using HeuristicLab.Core;
+  using HeuristicLab.Encodings.IntegerVectorEncoding;
+  using HeuristicLab.Optimization;
+  using HeuristicLab.Problems.ProgramSynthesis.Push.Configuration;
+  using HeuristicLab.Problems.ProgramSynthesis.Push.Data.Pool;
+  using HeuristicLab.Problems.ProgramSynthesis.Push.Expressions;
+  using HeuristicLab.Problems.ProgramSynthesis.Push.Generators.CodeGenerator;
+  using HeuristicLab.Random;
+
+  public static class IndividualExtensions {
+    public static PushProgram ToPushProgram(this Individual individual, IReadOnlyPushConfiguration config, ObjectPool<IRandom> randomPool) {
+      return individual.IntegerVector().ToPushProgram(config, randomPool);
+    }
+
+    public static PushProgram ToPushProgram(this Individual individual, IReadOnlyPushConfiguration config) {
+      return individual.IntegerVector().ToPushProgram(config);
+    }
+
+    public static PushProgram ToPushProgram(this Individual individual, IReadOnlyPushConfiguration config, IRandom random) {
+      return individual.IntegerVector().ToPushProgram(config, random);
+    }
+
+    public static PushProgram ToPushProgram(this IntegerVector vector, IReadOnlyPushConfiguration config, ObjectPool<IRandom> randomPool) {
+      var random = randomPool.Allocate();
+      var seed = vector.GetSeed();
+
+      random.Reset(seed);
+      var program = vector.ToPushProgram(config, random);
+      randomPool.Free(random);
+
+      return program;
+    }
+
+    public static PushProgram ToPushProgram(this IntegerVector vector, IReadOnlyPushConfiguration config) {
+      var seed = (uint)vector.GetSeed();
+      return vector.ToPushProgram(config, new MersenneTwister(seed));
+    }
+
+    public static int GetSeed(this IntegerVector vector) {
+      var seed = 17;
+      for (var i = 0; i < vector.Length; i++)
+        seed = seed * 23 + vector[i];
+      return seed;
+    }
+
+    public static PushProgram ToPushProgram(this IntegerVector vector, IReadOnlyPushConfiguration config, IRandom random) {
+      //var currentIndex = 0;
+      //var close = 0;
+      var expressions = new List<Expression>(vector.Length);
+
+      for (var i = vector.Length - 1; i >= 0; i--) {
+        var expression = CodeGeneratorUtils.CreateExpressionOrErc(
+          vector[i],
+          random,
+          config.EnabledExpressions,
+          config.ErcOptions);
+
+        expressions.Add(expression);
+      }
+
+      return new PushProgram(expressions);
+
+      //using (var mapper = IndividualMapper.Create()) {
+      //  return mapper.FromPlush(vector, ref currentIndex, ref close, 0, config, random);
+      //}
+    }
+  }
+}
Index: branches/PushGP/HeuristicLab.PushGP/HeuristicLab.Problems.ProgramSynthesis/Push/Individual/InduvidualMapper.cs
===================================================================
--- branches/PushGP/HeuristicLab.PushGP/HeuristicLab.Problems.ProgramSynthesis/Push/Individual/InduvidualMapper.cs	(revision 15189)
+++ branches/PushGP/HeuristicLab.PushGP/HeuristicLab.Problems.ProgramSynthesis/Push/Individual/InduvidualMapper.cs	(revision 15189)
@@ -0,0 +1,110 @@
+﻿namespace HeuristicLab.Problems.ProgramSynthesis.Push.Individual {
+  using System;
+  using Configuration;
+  using Core;
+  using Data.Pool;
+  using Encodings.IntegerVectorEncoding;
+  using Expressions;
+  using Extensions;
+  using Generators.CodeGenerator;
+
+  public class ListCheck {
+    public PooledList<Expression> List { get; set; }
+    public IManagedPool<PooledList<Expression>> Pool { get; set; }
+    public IndividualMapper Mapper { get; set; }
+  }
+
+  public class IndividualMapper : IDisposable {
+    private static readonly ObjectPool<IndividualMapper> MapperPool = new ObjectPool<IndividualMapper>(() => new IndividualMapper());
+    private static readonly ManagedPoolProvider<PushProgram> PushProgramPoolProvider = new ManagedPoolProvider<PushProgram>(1000, () => new PushProgram());
+    private static readonly ManagedPoolProvider<PooledList<Expression>> ExpressionListPoolProvider = new ManagedPoolProvider<PooledList<Expression>>(1000, () => new PooledList<Expression>());
+
+    private readonly IManagedPool<PushProgram> pushProgramPool = PushProgramPoolProvider.CreatePool();
+    private readonly IManagedPool<PooledList<Expression>> expressionListPool = ExpressionListPoolProvider.CreatePool();
+
+    private IndividualMapper() { }
+
+    public PushProgram FromPlush(
+      IntegerVector vector,
+      ref int currentIndex,
+      ref int close,
+      int depth,
+      IReadOnlyPushConfiguration config,
+      IRandom random) {
+
+      if (currentIndex >= vector.Length)
+        return PushProgram.Empty;
+
+      var expressions = expressionListPool.Get();
+
+      for (; currentIndex < vector.Length; currentIndex++) {
+        var expression = CodeGeneratorUtils.CreateExpressionOrErc(
+          vector[currentIndex] % config.EnabledExpressions.Count,
+          random,
+          config.EnabledExpressions,
+          config.ErcOptions);
+
+        var expressionType = expression.GetType();
+
+        if (config.ParenthesesCloseBiasLevel > 0) {
+          close += random.NextBiased(0, config.MaxParenthesesClose, config.ParenthesesCloseBiasLevel);
+
+          // check if expression requires additional blocks
+          if (ExpressionTable.TypeToAttributeTable.ContainsKey(expressionType)) {
+            var attr = ExpressionTable.TypeToAttributeTable[expressionType];
+
+            for (var blockIdx = 0u; blockIdx < attr.ExecIn && currentIndex < vector.Length; blockIdx++) {
+              if (close != 0) {
+                close--;
+                expressions.Add(PushProgram.Empty);
+              } else {
+                currentIndex++;
+                var subProgram = FromPlush(vector, ref currentIndex, ref close, depth + 1, config, random);
+                var subExpression = subProgram.Count == 1 ? subProgram.Expressions[0] : subProgram;
+
+                expressions.Add(subExpression);
+              }
+            }
+          }
+        }
+
+        expressions.Add(expression);
+
+        if (close > 0 && depth > 0) {
+          close--;
+          break;
+        }
+
+        if (depth == 0) {
+          close = 0;
+        }
+      }
+
+      return PushProgram.Create(pushProgramPool, expressions);
+    }
+
+    public static IndividualMapper Create() {
+      return MapperPool.Allocate();
+    }
+
+    public static void Reset() {
+      foreach (var mapper in MapperPool.Items) {
+        mapper.expressionListPool.Release();
+        mapper.pushProgramPool.Release();
+      }
+    }
+
+    public static void Clear() {
+      Reset();
+
+      PushProgramPoolProvider.Clear();
+      ExpressionListPoolProvider.Clear();
+
+      MapperPool.Clear();
+    }
+
+    public void Dispose() {
+      MapperPool.Free(this);
+    }
+  }
+}
Index: branches/PushGP/HeuristicLab.PushGP/HeuristicLab.Problems.ProgramSynthesis/Push/Interpreter/Extensions.cs
===================================================================
--- branches/PushGP/HeuristicLab.PushGP/HeuristicLab.Problems.ProgramSynthesis/Push/Interpreter/Extensions.cs	(revision 15033)
+++ branches/PushGP/HeuristicLab.PushGP/HeuristicLab.Problems.ProgramSynthesis/Push/Interpreter/Extensions.cs	(revision 15189)
@@ -25,21 +25,29 @@
 
     public static Type GetStackEntryType(this StackTypes stackType) {
+      if (StackProperties.ContainsKey(stackType) &&
+          StackProperties[stackType].PropertyType.IsGenericType) {
+        var genericTypeDef = StackProperties[stackType].PropertyType.GetGenericTypeDefinition();
+        if (genericTypeDef == typeof(IPushStack<>))
+          return genericTypeDef.GetGenericArguments()[0];
+      }
+
       return StackProperties.ContainsKey(stackType)
-        ? StackProperties[stackType].PropertyType.GetGenericArguments().Single()
+        ? StackProperties[stackType]
+            .PropertyType
+            .GetInterfaces()
+            .First(i => i.IsGenericType && i.GetGenericTypeDefinition() == typeof(IPushStack<>))
+            .GetGenericArguments()
+            .First()
         : null;
     }
 
     public static void PrintStacks(this IPushInterpreter interpreter) {
-      var stackTypesType = typeof(StackTypes);
-
-      foreach (StackTypes type in Enum.GetValues(stackTypesType)) {
-        if (!interpreter.Stacks.ContainsKey(type)) continue;
-
-        var stackName = Enum.GetName(stackTypesType, type);
-        var stack = interpreter.Stacks[type];
+      foreach (var pair in interpreter.Stacks) {
+        var stackName = pair.Key.ToString();
+        var stack = interpreter.Stacks[pair.Key];
 
         if (stack.IsEmpty || !stack.IsEnabled) continue;
 
-        var stackString = string.Join(" ", interpreter.StringifyStack(type).Reverse());
+        var stackString = string.Join(" ", interpreter.StringifyStack(pair.Key).Reverse());
         Console.WriteLine("--------- {0} ---------\n{1}\n", stackName, stackString);
       }
Index: branches/PushGP/HeuristicLab.PushGP/HeuristicLab.Problems.ProgramSynthesis/Push/Interpreter/IInternalPushInterpreter.cs
===================================================================
--- branches/PushGP/HeuristicLab.PushGP/HeuristicLab.Problems.ProgramSynthesis/Push/Interpreter/IInternalPushInterpreter.cs	(revision 15033)
+++ branches/PushGP/HeuristicLab.PushGP/HeuristicLab.Problems.ProgramSynthesis/Push/Interpreter/IInternalPushInterpreter.cs	(revision 15189)
@@ -1,6 +1,11 @@
 ﻿namespace HeuristicLab.Problems.ProgramSynthesis.Push.Interpreter {
+  using System.Collections.Generic;
+
+  using HeuristicLab.Problems.ProgramSynthesis.Push.Expressions;
+
   public interface IInternalPushInterpreter : IPushInterpreter {
     InterpreterPoolContainer PoolContainer { get; }
     bool IsNameQuoteFlagSet { get; set; }
+    IReadOnlyList<Expression> InputExpressions { get; }
   }
 }
Index: branches/PushGP/HeuristicLab.PushGP/HeuristicLab.Problems.ProgramSynthesis/Push/Interpreter/IPushInterpreter.cs
===================================================================
--- branches/PushGP/HeuristicLab.PushGP/HeuristicLab.Problems.ProgramSynthesis/Push/Interpreter/IPushInterpreter.cs	(revision 15033)
+++ branches/PushGP/HeuristicLab.PushGP/HeuristicLab.Problems.ProgramSynthesis/Push/Interpreter/IPushInterpreter.cs	(revision 15189)
@@ -24,5 +24,5 @@
     IPushStack<IReadOnlyList<bool>> BooleanVectorStack { get; }
     IPushStack<IReadOnlyList<string>> StringVectorStack { get; }
-    IPushStack<string> PrintStack { get; }
+    IPrintStack PrintStack { get; }
     IDictionary<string, Expression> CustomExpressions { get; }
     IReadOnlyDictionary<StackTypes, IPushStack> Stacks { get; }
@@ -30,4 +30,14 @@
     void Clear();
     void Reset();
+
+    void SetInput(
+      IReadOnlyList<long> integers = null,
+      IReadOnlyList<double> floats = null,
+      IReadOnlyList<bool> booleans = null,
+      IReadOnlyList<char> chars = null,
+      IReadOnlyList<string> strings = null,
+      IReadOnlyList<IReadOnlyList<long>> integerVectors = null,
+      IReadOnlyList<IReadOnlyList<double>> floatVectors = null,
+      IReadOnlyList<IReadOnlyList<string>> stringVectors = null);
 
     void Run(bool stepwise);
Index: branches/PushGP/HeuristicLab.PushGP/HeuristicLab.Problems.ProgramSynthesis/Push/Interpreter/PushInterpreter.cs
===================================================================
--- branches/PushGP/HeuristicLab.PushGP/HeuristicLab.Problems.ProgramSynthesis/Push/Interpreter/PushInterpreter.cs	(revision 15033)
+++ branches/PushGP/HeuristicLab.PushGP/HeuristicLab.Problems.ProgramSynthesis/Push/Interpreter/PushInterpreter.cs	(revision 15189)
@@ -2,4 +2,5 @@
   using System;
   using System.Collections.Generic;
+  using System.Linq;
   using System.Runtime.CompilerServices;
   using System.Threading;
@@ -35,5 +36,5 @@
       BooleanVectorStack = new PushStack<IReadOnlyList<bool>>();
       StringVectorStack = new PushStack<IReadOnlyList<string>>();
-      PrintStack = new PushStack<string>();
+      PrintStack = new PrintStack();
 
       Stacks = new Dictionary<StackTypes, IPushStack> {
@@ -53,4 +54,6 @@
       };
 
+      supportedStackTypes = Stacks.Keys.ToArray();
+
       CustomExpressions = new Dictionary<string, Expression>();
       PoolContainer = poolContainer ?? new InterpreterPoolContainer();
@@ -63,4 +66,5 @@
     }
 
+    private readonly StackTypes[] supportedStackTypes;
     public IReadOnlyDictionary<StackTypes, IPushStack> Stacks { get; private set; }
 
@@ -128,9 +132,104 @@
     public IPushStack<IReadOnlyList<string>> StringVectorStack { get; private set; }
     [PushStack(StackTypes.Print)]
-    public IPushStack<string> PrintStack { get; private set; }
+    public IPrintStack PrintStack { get; private set; }
 
     public IDictionary<string, Expression> CustomExpressions { get; private set; }
 
     public bool IsNameQuoteFlagSet { get; set; }
+
+    private readonly List<Expression> inputExpressions = new List<Expression>();
+    IReadOnlyList<Expression> IInternalPushInterpreter.InputExpressions { get { return inputExpressions; } }
+
+    public void SetInput(
+      IReadOnlyList<long> integers = null,
+      IReadOnlyList<double> floats = null,
+      IReadOnlyList<bool> booleans = null,
+      IReadOnlyList<char> chars = null,
+      IReadOnlyList<string> strings = null,
+      IReadOnlyList<IReadOnlyList<long>> integerVectors = null,
+      IReadOnlyList<IReadOnlyList<double>> floatVectors = null,
+      IReadOnlyList<IReadOnlyList<string>> stringVectors = null) {
+
+      // Integer
+      if (integers != null && integers.Count > 0) {
+        var integerPushExpressionPool = PoolContainer.GetStatefulExpressionPool<IntegerPushExpression>();
+
+        for (var i = 0; i < integers.Count; i++) {
+          var expression = IntegerPushExpression.Create(integerPushExpressionPool, integers[i]);
+          inputExpressions.Add(expression);
+        }
+      }
+
+      // Float
+      if (floats != null && floats.Count > 0) {
+        var floatPushExpressionPool = PoolContainer.GetStatefulExpressionPool<FloatPushExpression>();
+
+        for (var i = 0; i < floats.Count; i++) {
+          var expression = FloatPushExpression.Create(floatPushExpressionPool, floats[i]);
+          inputExpressions.Add(expression);
+        }
+      }
+
+      // Booleans
+      if (booleans != null && booleans.Count > 0) {
+        var booleanPushExpressionPool = PoolContainer.GetStatefulExpressionPool<BooleanPushExpression>();
+
+        for (var i = 0; i < booleans.Count; i++) {
+          var expression = BooleanPushExpression.Create(booleanPushExpressionPool, booleans[i]);
+          inputExpressions.Add(expression);
+        }
+      }
+
+      // Char
+      if (chars != null && chars.Count > 0) {
+        var charPushExpressionPool = PoolContainer.GetStatefulExpressionPool<CharPushExpression>();
+
+        for (var i = 0; i < chars.Count; i++) {
+          var expression = CharPushExpression.Create(charPushExpressionPool, chars[i]);
+          inputExpressions.Add(expression);
+        }
+      }
+
+      // String
+      if (strings != null && strings.Count > 0) {
+        var stringPushExpressionPool = PoolContainer.GetStatefulExpressionPool<StringPushExpression>();
+
+        for (var i = 0; i < strings.Count; i++) {
+          var expression = StringPushExpression.Create(stringPushExpressionPool, strings[i]);
+          inputExpressions.Add(expression);
+        }
+      }
+
+      // IntegerVector
+      if (integerVectors != null && integerVectors.Count > 0) {
+        var integerVectorPushExpressionPool = PoolContainer.GetStatefulExpressionPool<IntegerVectorPushExpression>();
+
+        for (var i = 0; i < integerVectors.Count; i++) {
+          var expression = IntegerVectorPushExpression.Create(integerVectorPushExpressionPool, integerVectors[i]);
+          inputExpressions.Add(expression);
+        }
+      }
+
+      // FloatVector
+      if (floatVectors != null && floatVectors.Count > 0) {
+        var floatVectorPushExpressionPool = PoolContainer.GetStatefulExpressionPool<FloatVectorPushExpression>();
+
+        for (var i = 0; i < floatVectors.Count; i++) {
+          var expression = FloatVectorPushExpression.Create(floatVectorPushExpressionPool, floatVectors[i]);
+          inputExpressions.Add(expression);
+        }
+      }
+
+      // StringVector
+      if (stringVectors != null && stringVectors.Count > 0) {
+        var stringVectorPushExpressionPool = PoolContainer.GetStatefulExpressionPool<StringVectorPushExpression>();
+
+        for (var i = 0; i < stringVectors.Count; i++) {
+          var expression = StringVectorPushExpression.Create(stringVectorPushExpressionPool, stringVectors[i]);
+          inputExpressions.Add(expression);
+        }
+      }
+    }
+
 
     public Task RunAsync(string code, CancellationToken token = default(CancellationToken)) {
@@ -240,4 +339,5 @@
       currentProgram = null;
 
+      inputExpressions.Clear();
       Clear();
       ConfigureStacks();
@@ -245,6 +345,7 @@
 
     private void ConfigureStacks() {
-      foreach (var pair in this.Stacks) {
-        pair.Value.IsEnabled = Configuration.IsStackEnabled(pair.Key);
+      for (var i = 0u; i < supportedStackTypes.Length; i++) {
+        var key = supportedStackTypes[i];
+        Stacks[key].IsEnabled = Configuration.IsStackEnabled(key);
       }
 
@@ -257,6 +358,8 @@
     /// </summary>
     public void Clear() {
-      foreach (var stack in Stacks)
-        stack.Value.Clear();
+      for (var i = 0u; i < supportedStackTypes.Length; i++) {
+        var key = supportedStackTypes[i];
+        Stacks[key].Clear();
+      }
 
       CustomExpressions.Clear();
Index: branches/PushGP/HeuristicLab.PushGP/HeuristicLab.Problems.ProgramSynthesis/Push/Interpreter/PushInterpreterPool.cs
===================================================================
--- branches/PushGP/HeuristicLab.PushGP/HeuristicLab.Problems.ProgramSynthesis/Push/Interpreter/PushInterpreterPool.cs	(revision 15033)
+++ branches/PushGP/HeuristicLab.PushGP/HeuristicLab.Problems.ProgramSynthesis/Push/Interpreter/PushInterpreterPool.cs	(revision 15189)
@@ -47,4 +47,5 @@
       PushProgramPoolProvider.Clear();
       ExpressionListPoolProvider.Clear();
+      pool.Clear();
     }
   }
Index: branches/PushGP/HeuristicLab.PushGP/HeuristicLab.Problems.ProgramSynthesis/Push/ObjectPools/StringBuilderPool.cs
===================================================================
--- branches/PushGP/HeuristicLab.PushGP/HeuristicLab.Problems.ProgramSynthesis/Push/ObjectPools/StringBuilderPool.cs	(revision 15189)
+++ branches/PushGP/HeuristicLab.PushGP/HeuristicLab.Problems.ProgramSynthesis/Push/ObjectPools/StringBuilderPool.cs	(revision 15189)
@@ -0,0 +1,9 @@
+﻿using System.Text;
+
+namespace HeuristicLab.Problems.ProgramSynthesis.Push.ObjectPools {
+  using HeuristicLab.Problems.ProgramSynthesis.Push.Data.Pool;
+
+  public static class StringBuilderPool {
+    public static readonly ObjectPool<StringBuilder> Instance = new ObjectPool<StringBuilder>(() => new StringBuilder());
+  }
+}
Index: branches/PushGP/HeuristicLab.PushGP/HeuristicLab.Problems.ProgramSynthesis/Push/Parser/PushParser.cs
===================================================================
--- branches/PushGP/HeuristicLab.PushGP/HeuristicLab.Problems.ProgramSynthesis/Push/Parser/PushParser.cs	(revision 15033)
+++ branches/PushGP/HeuristicLab.PushGP/HeuristicLab.Problems.ProgramSynthesis/Push/Parser/PushParser.cs	(revision 15189)
@@ -175,7 +175,7 @@
           .Substring(1, word.Length - 2)
           .Split(PushEnvironment.VectorSeparatorSymbol)
-          .ToArray();
-
-        if (vectorEntries.Length == 0) {
+          .ToList();
+
+        if (vectorEntries.Count == 0) {
           expression = null;
           return false;
@@ -190,14 +190,14 @@
 
         if (e.GetType() == typeof(IntegerPushExpression)) {
-          var integerValues = vectorEntries.Select(long.Parse).ToArray();
+          var integerValues = vectorEntries.Select(long.Parse).ToList();
           expression = new IntegerVectorPushExpression(integerValues);
         } else if (e.GetType() == typeof(FloatPushExpression)) {
-          var doubleValues = vectorEntries.Select(x => double.Parse(x, NumberStyles.Float, cultureInfo)).ToArray();
+          var doubleValues = vectorEntries.Select(x => double.Parse(x, NumberStyles.Float, cultureInfo)).ToList();
           expression = new FloatVectorPushExpression(doubleValues);
         } else if (e.GetType() == typeof(StringPushExpression)) {
-          var stringValues = vectorEntries.Select(str => str.Substring(1, str.Length - 2)).ToArray();
+          var stringValues = vectorEntries.Select(str => str.Substring(1, str.Length - 2)).ToList();
           expression = new StringVectorPushExpression(stringValues);
         } else if (e.GetType() == typeof(BooleanPushExpression)) {
-          var booleanValues = vectorEntries.Select(bool.Parse).ToArray();
+          var booleanValues = vectorEntries.Select(bool.Parse).ToList();
           expression = new BooleanVectorPushExpression(booleanValues);
         } else {
Index: branches/PushGP/HeuristicLab.PushGP/HeuristicLab.Problems.ProgramSynthesis/Push/Problem/BenchmarkSuite/BenchmarkSuitePushSolutionView.cs
===================================================================
--- branches/PushGP/HeuristicLab.PushGP/HeuristicLab.Problems.ProgramSynthesis/Push/Problem/BenchmarkSuite/BenchmarkSuitePushSolutionView.cs	(revision 15033)
+++ branches/PushGP/HeuristicLab.PushGP/HeuristicLab.Problems.ProgramSynthesis/Push/Problem/BenchmarkSuite/BenchmarkSuitePushSolutionView.cs	(revision 15189)
@@ -53,13 +53,23 @@
       var example = Evaluator.Data.Examples[exampleComboBox.SelectedIndex];
 
-      interpreter.BooleanStack.Push(example.InputBoolean);
-      interpreter.IntegerStack.Push(example.InputInteger);
-      interpreter.FloatStack.Push(example.InputFloat);
-      interpreter.CharStack.Push(example.InputChar);
-      interpreter.StringStack.Push(example.InputString);
-      interpreter.IntegerVectorStack.Push(example.InputIntegerVector.Select(x => x.ToList()).ToArray());
-      interpreter.FloatVectorStack.Push(example.InputFloatVector.Select(x => x.ToList()).ToArray());
-      interpreter.StringVectorStack.Push(example.InputStringVector.Select(x => x.ToList()).ToArray());
-      interpreter.BooleanVectorStack.Push(example.InputBooleanVector.Select(x => x.ToList()).ToArray());
+      interpreter.SetInput(
+        integers: example.InputInteger,
+        floats: example.InputFloat,
+        booleans: example.InputBoolean,
+        chars: example.InputChar,
+        strings: example.InputString,
+        integerVectors: example.InputIntegerVector,
+        floatVectors: example.InputFloatVector,
+        stringVectors: example.InputStringVector);
+
+      //interpreter.BooleanStack.Push(example.InputBoolean);
+      //interpreter.IntegerStack.Push(example.InputInteger);
+      //interpreter.FloatStack.Push(example.InputFloat);
+      //interpreter.CharStack.Push(example.InputChar);
+      //interpreter.StringStack.Push(example.InputString);
+      //interpreter.IntegerVectorStack.Push(example.InputIntegerVector.Select(x => x.ToList()).ToList());
+      //interpreter.FloatVectorStack.Push(example.InputFloatVector.Select(x => x.ToList()).ToList());
+      //interpreter.StringVectorStack.Push(example.InputStringVector.Select(x => x.ToList()).ToList());
+      //interpreter.BooleanVectorStack.Push(example.InputBooleanVector.Select(x => x.ToList()).ToList());
     }
 
@@ -198,6 +208,11 @@
             var type = data.OutputArgumentTypes[j];
             var offset = outputArgumentCountDict[type];
+
+            // estimated
             row.Cells[data.InputArgumentTypes.Length + j * 2].Value = ViewHelper.StringifyOutput(type, offset, Content.Config.FloatStringFormat, example, Separator);
+
+            // output
             row.Cells[data.InputArgumentTypes.Length + j * 2 + 1].Value = StringifyResult(type, offset, pushInterpreter, example, Separator);
+
             outputArgumentCountDict[type]++;
           }
@@ -243,5 +258,5 @@
 
         case ExampleArgumentType.Print:
-          return string.Join(valueSeparator, string.Join(PushEnvironment.NewLine, interpreter.PrintStack.Take(example.OutputPrintLineCount)));
+          return string.Join(valueSeparator, string.Join(PushEnvironment.NewLine, interpreter.PrintStack.AsStrings().Take(example.OutputPrintLineCount)));
 
         case ExampleArgumentType.String:
Index: branches/PushGP/HeuristicLab.PushGP/HeuristicLab.Problems.ProgramSynthesis/Push/Problem/BenchmarkSuite/PushBenchmarkSuiteEvaluator.cs
===================================================================
--- branches/PushGP/HeuristicLab.PushGP/HeuristicLab.Problems.ProgramSynthesis/Push/Problem/BenchmarkSuite/PushBenchmarkSuiteEvaluator.cs	(revision 15033)
+++ branches/PushGP/HeuristicLab.PushGP/HeuristicLab.Problems.ProgramSynthesis/Push/Problem/BenchmarkSuite/PushBenchmarkSuiteEvaluator.cs	(revision 15189)
@@ -2,4 +2,5 @@
   using System;
   using System.Collections.Generic;
+  using System.Globalization;
   using System.Linq;
 
@@ -130,40 +131,70 @@
       var example = Data.Examples[exampleIndex];
 
-      interpreter.BooleanStack.Push(example.InputBoolean);
-      interpreter.IntegerStack.Push(example.InputInteger);
-      interpreter.FloatStack.Push(example.InputFloat);
-      interpreter.CharStack.Push(example.InputChar);
-      interpreter.StringStack.Push(example.InputString);
-      interpreter.StringVectorStack.Push(example.InputStringVector);
-      interpreter.IntegerVectorStack.Push(example.InputIntegerVector);
-      interpreter.FloatVectorStack.Push(example.InputFloatVector);
+      //interpreter.BooleanStack.Push(example.InputBoolean);
+      //interpreter.IntegerStack.Push(example.InputInteger);
+      //interpreter.FloatStack.Push(example.InputFloat);
+      //interpreter.CharStack.Push(example.InputChar);
+      //interpreter.StringStack.Push(example.InputString);
+      //interpreter.StringVectorStack.Push(example.InputStringVector);
+      //interpreter.IntegerVectorStack.Push(example.InputIntegerVector);
+      //interpreter.FloatVectorStack.Push(example.InputFloatVector);
+
+      interpreter.SetInput(
+        integers: example.InputInteger,
+        floats: example.InputFloat,
+        booleans: example.InputBoolean,
+        chars: example.InputChar,
+        strings: example.InputString,
+        integerVectors: example.InputIntegerVector,
+        floatVectors: example.InputFloatVector,
+        stringVectors: example.InputStringVector);
 
       interpreter.Run(program);
 
       switch (Data.ProblemType) {
-        //case ProblemType.NumberIO:
-        //  if (interpreter.PrintStack.IsEmpty)
-        //    return Data.WorstResult;
-
-        //  double value;
-        //  var levenshteinDistance = GetPrintDiffer(example.OutputPrint, interpreter.PrintStack, example.OutputPrintLineCount, Data.WorstResult);
-        //  return levenshteinDistance + (double.TryParse(interpreter.PrintStack.Top, out value)
-        //    ? FloatDiffer(value, example.OutputFloat[0], example.OutputFloatPrecision)
-        //    : Data.WorstResult / 2);
-
-        case ProblemType.Median: return interpreter.PrintStack.IsEmpty ? 1 : interpreter.PrintStack.Top.Equals(example.OutputPrint) ? 0 : 1;
-      }
-
+        case ProblemType.NumberIO: return NumberIo(interpreter, example);
+        case ProblemType.Median: return Median(interpreter, example);
+      }
+
+      return Default(interpreter, example);
+    }
+
+    private double Default(IPushInterpreter interpreter, Example example) {
       var result = GetDiff(example.OutputInteger, interpreter.IntegerStack, Data.WorstResult, IntegerDiffer)
-                 + GetDiff(example.OutputFloat, interpreter.FloatStack, Data.WorstResult, (a, b) => FloatDiffer(a, b, example.OutputFloatPrecision))
-                 + GetDiff(example.OutputBoolean, interpreter.BooleanStack, Data.WorstResult, BooleanDiffer)
-                 + GetDiff(example.OutputString, interpreter.StringStack, Data.WorstResult, StringDiffer)
-                 + GetDiff(example.OutputChar, interpreter.CharStack, Data.WorstResult, CharDiffer)
-                 + GetPrintDiffer(example.OutputPrint, interpreter.PrintStack, example.OutputPrintLineCount, Data.WorstResult)
-                 + GetVectorDiff(example.OutputIntegerVector, interpreter.IntegerVectorStack, Data.WorstResult, (a, b) => VectorDiffer(a, b, IntegerDiffer))
-                 + GetVectorDiff(example.OutputFloatVector, interpreter.FloatVectorStack, Data.WorstResult, (a, b) => VectorDiffer(a, b, (x, y) => FloatDiffer(x, y, example.OutputFloatVectorPrecision)))
-                 + GetVectorDiff(example.OutputStringVector, interpreter.StringVectorStack, Data.WorstResult, (a, b) => VectorDiffer(a, b, StringDiffer));
+             + GetDiff(example.OutputFloat, interpreter.FloatStack, Data.WorstResult, (a, b) => FloatDiffer(a, b, example.OutputFloatPrecision))
+             + GetDiff(example.OutputBoolean, interpreter.BooleanStack, Data.WorstResult, BooleanDiffer)
+             + GetDiff(example.OutputString, interpreter.StringStack, Data.WorstResult, StringDiffer)
+             + GetDiff(example.OutputChar, interpreter.CharStack, Data.WorstResult, CharDiffer)
+             + GetPrintDiffer(example.OutputPrint, interpreter.PrintStack, example.OutputPrintLineCount, Data.WorstResult)
+             + GetVectorDiff(example.OutputIntegerVector, interpreter.IntegerVectorStack, Data.WorstResult, (a, b) => VectorDiffer(a, b, IntegerDiffer))
+             + GetVectorDiff(example.OutputFloatVector, interpreter.FloatVectorStack, Data.WorstResult, (a, b) => VectorDiffer(a, b, (x, y) => FloatDiffer(x, y, example.OutputFloatVectorPrecision)))
+             + GetVectorDiff(example.OutputStringVector, interpreter.StringVectorStack, Data.WorstResult, (a, b) => VectorDiffer(a, b, StringDiffer));
 
       return result;
+    }
+
+    private double Median(IPushInterpreter interpreter, Example example) {
+      return interpreter.PrintStack.IsEmpty || !interpreter.PrintStack.Top.Equals(example.OutputPrint) ? 1 : 0;
+    }
+
+    private double NumberIo(IPushInterpreter interpreter, Example example) {
+      if (interpreter.PrintStack.IsEmpty)
+        return Data.WorstResult;
+
+      double value;
+      if (double.TryParse(interpreter.PrintStack.Top, NumberStyles.Number | NumberStyles.AllowDecimalPoint, CultureInfo.InvariantCulture, out value)) {
+        var diff = Math.Abs(example.OutputFloat[0] - value);
+        var result = Math.Min(diff, Data.WorstResult);
+
+        return result;
+      }
+
+      var penaltyError = Data.WorstResult / 4.0d;
+      var levenshteinDistance = GetPrintDiffer(
+        example.OutputPrint,
+        interpreter.PrintStack.Top,
+        Data.WorstResult);
+
+      return levenshteinDistance + penaltyError;
     }
 
@@ -217,6 +248,12 @@
     }
 
+    private static double GetPrintDiffer(string estimated, string printResult, double worstResult) {
+      var distance = LevenshteinDistance(estimated, printResult);
+
+      return Math.Min(distance, worstResult);
+    }
+
     private static double GetPrintDiffer(string estimated, IPushStack<string> printStack, int estimatedCount, double worstResult) {
-      var printResult = string.Join(PushEnvironment.NewLine, printStack.Take(estimatedCount));
+      var printResult = string.Join(PushEnvironment.NewLine, printStack.AsStrings().Take(estimatedCount));
       var distance = LevenshteinDistance(estimated, printResult);
 
@@ -234,5 +271,5 @@
         var count = Math.Min(estimated.Count, resultStack.Count);
         var result = resultStack.Peek(count);
-        comparableLength = Math.Min(estimated.Count, result.Length);
+        comparableLength = Math.Min(estimated.Count, result.Count);
 
         for (var i = 0; i < comparableLength; i++) {
@@ -259,5 +296,5 @@
         var count = Math.Min(estimated.Count, resultStack.Count);
         var result = resultStack.Peek(count);
-        comparableLength = Math.Min(estimated.Count, result.Length);
+        comparableLength = Math.Min(estimated.Count, result.Count);
 
         for (var i = 0; i < comparableLength; i++) {
Index: branches/PushGP/HeuristicLab.PushGP/HeuristicLab.Problems.ProgramSynthesis/Push/Problem/BenchmarkSuite/PushBenchmarkSuiteProblem.cs
===================================================================
--- branches/PushGP/HeuristicLab.PushGP/HeuristicLab.Problems.ProgramSynthesis/Push/Problem/BenchmarkSuite/PushBenchmarkSuiteProblem.cs	(revision 15033)
+++ branches/PushGP/HeuristicLab.PushGP/HeuristicLab.Problems.ProgramSynthesis/Push/Problem/BenchmarkSuite/PushBenchmarkSuiteProblem.cs	(revision 15189)
@@ -1,3 +1,4 @@
 ﻿namespace HeuristicLab.Problems.ProgramSynthesis.Push.Problem.BenchmarkSuite {
+
   using Common;
   using Configuration;
@@ -7,4 +8,5 @@
   using HeuristicLab.BenchmarkSuite.Problems;
   using HeuristicLab.Problems.ProgramSynthesis.Push.Expressions;
+  using HeuristicLab.Problems.ProgramSynthesis.Push.Extensions;
 
   using Instances;
@@ -53,4 +55,5 @@
 
       config.SetEnabledStacks((StackTypes)data.EnabledDataTypes);
+      data.InitInExpressions(config);
 
       Encoding.Bounds[0, 0] = 0;
Index: branches/PushGP/HeuristicLab.PushGP/HeuristicLab.Problems.ProgramSynthesis/Push/Problem/PushProblem.cs
===================================================================
--- branches/PushGP/HeuristicLab.PushGP/HeuristicLab.Problems.ProgramSynthesis/Push/Problem/PushProblem.cs	(revision 15033)
+++ branches/PushGP/HeuristicLab.PushGP/HeuristicLab.Problems.ProgramSynthesis/Push/Problem/PushProblem.cs	(revision 15189)
@@ -12,4 +12,5 @@
   using HeuristicLab.Problems.ProgramSynthesis.Push.Analyzer;
   using HeuristicLab.Problems.ProgramSynthesis.Push.Expressions;
+  using HeuristicLab.Problems.ProgramSynthesis.Push.Individual;
   using HeuristicLab.Problems.ProgramSynthesis.Push.Problem.BenchmarkSuite;
 
@@ -125,4 +126,5 @@
       // clear pools and free reserved memory
       pool.Clear();
+      IndividualMapper.Clear();
     }
 
@@ -158,4 +160,6 @@
 
     public override void Analyze(Individual[] individuals, double[] qualities, ResultCollection results, IRandom random) {
+      IndividualMapper.Reset();
+
       var bestQuality = Maximization ? qualities.Max() : qualities.Min();
       var bestIdx = Array.IndexOf(qualities, bestQuality);
@@ -165,5 +169,5 @@
       rand.Reset(seed);
 
-      var program = vector.ToPushProgram(config, rand);
+      var program = (PushProgram)vector.ToPushProgram(config, rand).Clone();
       var isIndividualBetter = AnalyzeBestTrainingSolution(program, bestQuality, results, rand);
 
Index: branches/PushGP/HeuristicLab.PushGP/HeuristicLab.Problems.ProgramSynthesis/Push/Selector/LexicaseSelector.cs
===================================================================
--- branches/PushGP/HeuristicLab.PushGP/HeuristicLab.Problems.ProgramSynthesis/Push/Selector/LexicaseSelector.cs	(revision 15033)
+++ branches/PushGP/HeuristicLab.PushGP/HeuristicLab.Problems.ProgramSynthesis/Push/Selector/LexicaseSelector.cs	(revision 15189)
@@ -74,5 +74,5 @@
       for (var k = 0; k < repeats; k++) {
         // The fitness cases are shuffled.
-        var fitnessCaseIndexes = Enumerable.Range(0, caseCount).Shuffle(random).ToArray();
+        var fitnessCaseIndexes = Enumerable.Range(0, caseCount).Shuffle(random).ToList();
 
         // copy list if required
@@ -83,5 +83,5 @@
           var bestIndividuals = pool;
 
-          for (var j = 0; j < fitnessCaseIndexes.Length && bestIndividuals.Count > 1; j++)
+          for (var j = 0; j < fitnessCaseIndexes.Count && bestIndividuals.Count > 1; j++)
             bestIndividuals = GetBestIndividuals(maximization, caseQualities, bestIndividuals, fitnessCaseIndexes[j]);
 
Index: branches/PushGP/HeuristicLab.PushGP/HeuristicLab.Problems.ProgramSynthesis/Push/Stack/IPrintStack.cs
===================================================================
--- branches/PushGP/HeuristicLab.PushGP/HeuristicLab.Problems.ProgramSynthesis/Push/Stack/IPrintStack.cs	(revision 15189)
+++ branches/PushGP/HeuristicLab.PushGP/HeuristicLab.Problems.ProgramSynthesis/Push/Stack/IPrintStack.cs	(revision 15189)
@@ -0,0 +1,11 @@
+﻿namespace HeuristicLab.Problems.ProgramSynthesis.Push.Stack {
+  public interface IPrintStack : IPushStack<string> {
+    void NewLine();
+    void Push<T>(T item);
+    void Push(double item);
+    void Push(long item);
+    void Push(int item);
+    void Push(char item);
+    void Push(bool item);
+  }
+}
Index: branches/PushGP/HeuristicLab.PushGP/HeuristicLab.Problems.ProgramSynthesis/Push/Stack/IPushStack.cs
===================================================================
--- branches/PushGP/HeuristicLab.PushGP/HeuristicLab.Problems.ProgramSynthesis/Push/Stack/IPushStack.cs	(revision 15033)
+++ branches/PushGP/HeuristicLab.PushGP/HeuristicLab.Problems.ProgramSynthesis/Push/Stack/IPushStack.cs	(revision 15189)
@@ -1,4 +1,3 @@
 ﻿namespace HeuristicLab.Problems.ProgramSynthesis.Push.Stack {
-  using System;
   using System.Collections.Generic;
 
@@ -18,11 +17,8 @@
     void Push(IEnumerable<T> items);
     new void Clear();
-    T Peek();
-    T[] Peek(int count);
-    void PushResult(int count, Func<T[], T> templateFunc);
+    IReadOnlyList<T> Peek(int count);
     void Insert(int index, T item);
-    T ReverseElementAt(int offset);
     T Pop();
-    T[] Pop(int count);
+    IReadOnlyList<T> Pop(int count);
     bool TryPop(out T item);
     T ElementAt(int index);
Index: branches/PushGP/HeuristicLab.PushGP/HeuristicLab.Problems.ProgramSynthesis/Push/Stack/InterpreterStackStringifier.cs
===================================================================
--- branches/PushGP/HeuristicLab.PushGP/HeuristicLab.Problems.ProgramSynthesis/Push/Stack/InterpreterStackStringifier.cs	(revision 15033)
+++ branches/PushGP/HeuristicLab.PushGP/HeuristicLab.Problems.ProgramSynthesis/Push/Stack/InterpreterStackStringifier.cs	(revision 15189)
@@ -45,5 +45,5 @@
 
     private static IEnumerable<string> StringifyLiteralStack<T>(IPushStack<T> stack, string prefix = "", string postfix = "", bool reverse = true) {
-      var result = stack.AsEnumerable();
+      var result = stack.AsStrings();
 
       if (reverse)
Index: branches/PushGP/HeuristicLab.PushGP/HeuristicLab.Problems.ProgramSynthesis/Push/Stack/PrintStack.cs
===================================================================
--- branches/PushGP/HeuristicLab.PushGP/HeuristicLab.Problems.ProgramSynthesis/Push/Stack/PrintStack.cs	(revision 15189)
+++ branches/PushGP/HeuristicLab.PushGP/HeuristicLab.Problems.ProgramSynthesis/Push/Stack/PrintStack.cs	(revision 15189)
@@ -0,0 +1,354 @@
+﻿using System.Text;
+
+
+namespace HeuristicLab.Problems.ProgramSynthesis.Push.Stack {
+  using System.Collections;
+  using System.Collections.Generic;
+
+  using HeuristicLab.Problems.ProgramSynthesis.Push.Extensions;
+
+  /// <summary>
+  /// Optimized for string concatenation to reduce memory effort
+  /// </summary>
+  public class PrintStack : IPrintStack {
+    private string currentTop;
+    private readonly IPushStack<string> stack = new PushStack<string>();
+    private readonly StringBuilder stringBuilder = new StringBuilder();
+
+    private string CurrentTop
+    {
+      get
+      {
+        return currentTop ?? (currentTop = stringBuilder.ToString());
+      }
+    }
+
+    public IEnumerator<string> GetEnumerator() {
+      return stack.GetEnumerator();
+    }
+
+    IEnumerator IEnumerable.GetEnumerator() {
+      return GetEnumerator();
+    }
+
+    public void Add(string item) {
+      Push(item);
+    }
+
+    void IPushStack<string>.Clear() {
+      stack.Clear();
+      stringBuilder.Clear();
+      currentTop = null;
+    }
+
+    public IReadOnlyList<string> Peek(int count) {
+      if (count == 1)
+        return new[] { CurrentTop };
+
+      var peek = stack.Peek(count - 1);
+      var result = new List<string>(peek) { CurrentTop };
+
+      return result;
+    }
+
+    public void Insert(int index, string item) {
+      if (index == 0)
+        Add(item);
+
+      stack.Insert(index - 1, item);
+    }
+
+    public string Pop() {
+      var result = CurrentTop;
+
+      var top = stack.Pop();
+      SetBuilderToTop(top);
+
+      return result;
+    }
+
+    public IReadOnlyList<string> Pop(int count) {
+      if (count == 1)
+        return new[] { Pop() };
+
+      var popped = stack.Pop(count - 1);
+      var result = new List<string>(popped) { CurrentTop };
+
+      var newTop = stack.Pop();
+      SetBuilderToTop(newTop);
+
+      return result;
+    }
+
+    private void ClearTop() {
+      stringBuilder.Clear();
+      currentTop = null;
+    }
+
+    private void SetBuilderToTop(string top) {
+      stringBuilder.Clear();
+      stringBuilder.Append(top);
+      currentTop = top;
+    }
+
+    public bool TryPop(out string item) {
+      if (string.IsNullOrEmpty(CurrentTop)) {
+        item = null;
+        return false;
+      }
+
+      item = Pop();
+      return true;
+    }
+
+    public string ElementAt(int index) {
+      if (index == 0)
+        return CurrentTop;
+
+      return stack.ElementAt(index - 1);
+    }
+
+    public string Top
+    {
+      get
+      {
+        return CurrentTop;
+      }
+      set
+      {
+        SetBuilderToTop(value);
+      }
+    }
+
+    public string TopOrDefault { get { return CurrentTop; } }
+
+    public string Bottom { get { return Count > 1 ? stack.Bottom : CurrentTop; } }
+
+    public string BottomOrDefault { get { return Bottom; } }
+
+    public string this[int key]
+    {
+      get
+      {
+        return key == 0 ? CurrentTop : stack[key - 1];
+      }
+      set
+      {
+        if (key == 0)
+          SetBuilderToTop(value);
+        else
+          stack[key - 1] = value;
+      }
+    }
+
+    public int Count
+    {
+      get
+      {
+        return stack.Count + (string.IsNullOrEmpty(CurrentTop) ? 0 : 1);
+      }
+    }
+
+    public void NewLine() {
+      if (IsEmpty) return;
+
+      stack.Push(CurrentTop);
+      ClearTop();
+    }
+
+    public void Push<T>(T item) {
+      stringBuilder.Append(item);
+      currentTop = null;
+    }
+
+    public void Push(float item) {
+      stringBuilder.Concat(item);
+      currentTop = null;
+    }
+
+    public void Push(double item) {
+      stringBuilder.Concat(item);
+      currentTop = null;
+    }
+
+    public void Push(long item) {
+      stringBuilder.Concat(item);
+      currentTop = null;
+    }
+
+    public void Push(int item) {
+      stringBuilder.Concat(item);
+      currentTop = null;
+    }
+
+    public void Push(char item) {
+      stringBuilder.Append(item);
+      currentTop = null;
+    }
+
+    public void Push(bool item) {
+      stringBuilder.Append(item);
+      currentTop = null;
+    }
+
+
+    public void Push(string item) {
+      stringBuilder.Append(item);
+      currentTop = null;
+    }
+
+    public void Push(string item1, string item2) {
+      stringBuilder.Append(item1);
+      stringBuilder.Append(item2);
+      currentTop = null;
+    }
+
+    public void Push(string item1, string item2, string item3) {
+      stringBuilder.Append(item1);
+      stringBuilder.Append(item2);
+      stringBuilder.Append(item3);
+      currentTop = null;
+    }
+
+    public void Push(string item1, string item2, string item3, string item4) {
+      stringBuilder.Append(item1);
+      stringBuilder.Append(item2);
+      stringBuilder.Append(item3);
+      stringBuilder.Append(item4);
+      currentTop = null;
+    }
+
+    public void Push(IReadOnlyList<string> items, int startIndex) {
+      for (var i = startIndex; i < items.Count; i++)
+        stringBuilder.Append(items[i]);
+
+      currentTop = null;
+    }
+
+    public void Push(IReadOnlyList<string> items) {
+      Push(items, 0);
+    }
+
+    public void Push(IEnumerable<string> items) {
+      foreach (var item in items)
+        stringBuilder.Append(item);
+
+      currentTop = null;
+    }
+
+    void IPushStack.Clear() {
+      stringBuilder.Clear();
+      currentTop = null;
+      stack.Clear();
+    }
+
+    public void Swap(int count) {
+      stack.Push(CurrentTop);
+      stack.Swap(count);
+
+      var newTop = stack.Pop();
+      SetBuilderToTop(newTop);
+    }
+
+    public void Yank(int index) {
+      if (index == Count - 1) return;
+
+      stack.Push(CurrentTop);
+
+      var item = stack[index];
+      stack.RemoveAt(index);
+      SetBuilderToTop(item);
+    }
+
+    public void RemoveTop() {
+      var newTop = stack.Pop();
+      SetBuilderToTop(newTop);
+    }
+
+    public void Remove(int count) {
+      if (count == 1)
+        RemoveTop();
+
+      stack.Remove(count - 1);
+      var newTop = stack.Pop();
+      SetBuilderToTop(newTop);
+    }
+
+    public void RemoveAt(int index) {
+      if (index == 0)
+        ClearTop();
+      else
+        stack.RemoveAt(index - 1);
+    }
+
+    public void RemoveAt(int index, int count) {
+      if (index == 0)
+        count--;
+
+      stack.RemoveAt(index - 1, count);
+
+      if (index == 0) {
+        var newTop = stack.Pop();
+        SetBuilderToTop(newTop);
+      }
+    }
+
+    public IEnumerable<string> AsStrings() {
+      foreach (var item in stack)
+        yield return item;
+
+      if (!IsEmpty)
+        yield return CurrentTop;
+    }
+
+    public IEnumerable<object> AsObjects() {
+      return AsStrings();
+    }
+
+    void ICollection<string>.Clear() {
+      stack.Clear();
+      stringBuilder.Clear();
+    }
+
+    public bool Contains(string item) {
+
+      return CurrentTop.Equals(item) || stack.Contains(item);
+    }
+
+    public void CopyTo(string[] array, int arrayIndex) {
+      stack.CopyTo(array, arrayIndex);
+      array[arrayIndex + stack.Count] = CurrentTop;
+    }
+
+    public bool Remove(string item) {
+      if (item.Equals(CurrentTop)) {
+        RemoveTop();
+        return true;
+      }
+
+      return stack.Remove(item);
+    }
+
+    int IPushStack<string>.Count
+    {
+      get
+      {
+        return Count;
+      }
+    }
+
+    public bool IsEmpty { get { return stack.IsEmpty && string.IsNullOrEmpty(CurrentTop); } }
+
+    public bool IsEnabled { get; set; }
+
+    int ICollection<string>.Count
+    {
+      get
+      {
+        return Count;
+      }
+    }
+
+    public bool IsReadOnly { get { return false; } }
+  }
+}
Index: branches/PushGP/HeuristicLab.PushGP/HeuristicLab.Problems.ProgramSynthesis/Push/Stack/PushStack.cs
===================================================================
--- branches/PushGP/HeuristicLab.PushGP/HeuristicLab.Problems.ProgramSynthesis/Push/Stack/PushStack.cs	(revision 15033)
+++ branches/PushGP/HeuristicLab.PushGP/HeuristicLab.Problems.ProgramSynthesis/Push/Stack/PushStack.cs	(revision 15189)
@@ -122,8 +122,4 @@
     }
 
-    public T ReverseElementAt(int offset) {
-      return data[offset];
-    }
-
     public T this[int index]
     {
@@ -145,5 +141,5 @@
       if (index == Count - 1) return;
 
-      var item = ReverseElementAt(index);
+      var item = data[index];
       data.RemoveAt(index);
       data.Add(item);
@@ -157,5 +153,5 @@
     }
 
-    public T[] Pop(int count) {
+    public IReadOnlyList<T> Pop(int count) {
       var items = Peek(count);
       Remove(count);
@@ -164,9 +160,5 @@
     }
 
-    public T Peek() {
-      return Top;
-    }
-
-    public T[] Peek(int count) {
+    public IReadOnlyList<T> Peek(int count) {
       var startIndex = Count - count;
 
@@ -207,16 +199,4 @@
     }
 
-    public void PushResult(int count, Func<T[], T> templateFunc) {
-      if (!IsEnabled) return;
-
-      var startIndex = Count - count;
-      var items = new T[count];
-
-      data.CopyTo(startIndex, items, 0, count);
-      Remove(count - 1);
-
-      data[Count - 1] = templateFunc(items);
-    }
-
     public void Push(IReadOnlyList<T> items, int startIndex) {
       if (!IsEnabled) return;
Index: branches/PushGP/HeuristicLab.PushGP/HeuristicLab.Problems.ProgramSynthesis/Push/Stack/StackTypes.cs
===================================================================
--- branches/PushGP/HeuristicLab.PushGP/HeuristicLab.Problems.ProgramSynthesis/Push/Stack/StackTypes.cs	(revision 15033)
+++ branches/PushGP/HeuristicLab.PushGP/HeuristicLab.Problems.ProgramSynthesis/Push/Stack/StackTypes.cs	(revision 15189)
@@ -20,3 +20,25 @@
     BooleanVector = 0x2000,
   }
+
+  //public static class StackTypeExtensions {
+  //  private static readonly IReadOnlyDictionary<StackTypes, string> StackTypesNameDict = new Dictionary<StackTypes, string> {
+  //    { StackTypes.Integer, "Integer" },
+  //    { StackTypes.Float, "Float" },
+  //    { StackTypes.Char, "Char" },
+  //    { StackTypes.String, "String" },
+  //    { StackTypes.Boolean, "Boolean" },
+  //    { StackTypes.Name, "Name" },
+  //    { StackTypes.Code, "Code" },
+  //    { StackTypes.Exec, "Exec" },
+  //    { StackTypes.Print, "Print" },
+  //    { StackTypes.IntegerVector, "IntegerVector" },
+  //    { StackTypes.FloatVector, "FloatVector" },
+  //    { StackTypes.StringVector, "StringVector" },
+  //    { StackTypes.BooleanVector, "BooleanVector" },
+  //  };
+
+  //  public static string GetName(this StackTypes types) {
+  //    return StackTypesNameDict[types];
+  //  }
+  //}
 }
Index: branches/PushGP/HeuristicLab.PushGP/HeuristicLab.Problems.ProgramSynthesis/Push/Views/ExpressionSelectionView.cs
===================================================================
--- branches/PushGP/HeuristicLab.PushGP/HeuristicLab.Problems.ProgramSynthesis/Push/Views/ExpressionSelectionView.cs	(revision 15033)
+++ branches/PushGP/HeuristicLab.PushGP/HeuristicLab.Problems.ProgramSynthesis/Push/Views/ExpressionSelectionView.cs	(revision 15189)
@@ -98,4 +98,7 @@
     private IEnumerable<TreeNode> GetTreeNodes(IReadOnlyList<string> enabledExpressions) {
       foreach (var stackType in ExpressionTable.StackTypeToNamesTable.Keys) {
+        if (stackType == StackTypes.None)
+          continue;
+
         var stackTreeNode = new TreeNode {
           Tag = stackType
Index: branches/PushGP/HeuristicLab.PushGP/HeuristicLab.Tests/Benchmark/SolutionTests.cs
===================================================================
--- branches/PushGP/HeuristicLab.PushGP/HeuristicLab.Tests/Benchmark/SolutionTests.cs	(revision 15033)
+++ branches/PushGP/HeuristicLab.PushGP/HeuristicLab.Tests/Benchmark/SolutionTests.cs	(revision 15189)
@@ -6,4 +6,5 @@
   using HeuristicLab.Problems.ProgramSynthesis.Push.Configuration;
   using HeuristicLab.Problems.ProgramSynthesis.Push.Expressions;
+  using HeuristicLab.Problems.ProgramSynthesis.Push.Extensions;
   using HeuristicLab.Problems.ProgramSynthesis.Push.Interpreter;
   using HeuristicLab.Problems.ProgramSynthesis.Push.Parser;
@@ -34,4 +35,5 @@
 
       config.SetEnabledStacks((StackTypes)data.EnabledDataTypes);
+      data.InitInExpressions(config);
 
       var evaluator = new PushBenchmarkSuiteEvaluator(data);
@@ -47,5 +49,5 @@
     public void Checksum() {
       TestProgram(
-        PushParser.ParseProgram("( 0 STRING.ITERATE ( INTEGER.FROMCHAR INTEGER.+ ) 64 INTEGER.% \' \' INTEGER.FROMCHAR INTEGER.+ \"Check sum is \" PRINT.PRINTSTRING CHAR.FROMINTEGER PRINT.PRINTCHAR )"),
+        PushParser.ParseProgram("( IN1 0 STRING.ITERATE ( INTEGER.FROMCHAR INTEGER.+ ) 64 INTEGER.% \' \' INTEGER.FROMCHAR INTEGER.+ \"Check sum is \" PRINT.PRINTSTRING CHAR.FROMINTEGER PRINT.PRINTCHAR )"),
         new Checksum());
     }
@@ -56,5 +58,5 @@
     public void CollatzNumbers() {
       TestProgram(
-        PushParser.ParseProgram("( INTEGER.DUP 1 INTEGER.= BOOLEAN.NOT EXEC.WHILE ( INTEGER.DUP INTEGER.DUP 2 INTEGER.% 0 INTEGER.= EXEC.IF ( 2 INTEGER./ ) ( 3 INTEGER.* 1 INTEGER.+ ) INTEGER.DUP 1 INTEGER.= BOOLEAN.NOT ) INTEGER.POP INTEGER.STACKDEPTH )"),
+        PushParser.ParseProgram("( IN1 INTEGER.DUP 1 INTEGER.= BOOLEAN.NOT EXEC.WHILE ( INTEGER.DUP INTEGER.DUP 2 INTEGER.% 0 INTEGER.= EXEC.IF ( 2 INTEGER./ ) ( 3 INTEGER.* 1 INTEGER.+ ) INTEGER.DUP 1 INTEGER.= BOOLEAN.NOT ) INTEGER.POP INTEGER.STACKDEPTH )"),
         new CollatzNumbers());
     }
@@ -65,5 +67,5 @@
     public void CompareStringLengths() {
       TestProgram(
-        PushParser.ParseProgram("STRING.LENGTH STRING.LENGTH INTEGER.DUP STRING.LENGTH INTEGER.> INTEGER.> BOOLEAN.AND"),
+        PushParser.ParseProgram("IN1 IN2 IN3 STRING.LENGTH STRING.LENGTH INTEGER.DUP STRING.LENGTH INTEGER.> INTEGER.> BOOLEAN.AND"),
         new CompareStringLengths());
     }
@@ -74,5 +76,5 @@
     public void CountOdds() {
       TestProgram(
-        PushParser.ParseProgram("( 0 INTEGER[].ITERATE ( 2 INTEGER.% INTEGER.DUP 1 INTEGER.= -1 INTEGER.= BOOLEAN.OR EXEC.WHEN INTEGER.INC ) )"),
+        PushParser.ParseProgram("( IN1 0 INTEGER[].ITERATE ( 2 INTEGER.% INTEGER.DUP 1 INTEGER.= -1 INTEGER.= BOOLEAN.OR EXEC.WHEN INTEGER.INC ) )"),
         new CountOdds());
     }
@@ -83,5 +85,5 @@
     public void Digits() {
       TestProgram(
-        PushParser.ParseProgram("( INTEGER.DUP STRING.FROMINTEGER 0 INTEGER.< BOOLEAN.DUP EXEC.WHEN ( STRING.REST STRING.DUP STRING.FIRST STRING.SWAP STRING.REST ) STRING.REVERSE STRING.ITERATE ( PRINT.NEWLINE PRINT.PRINTCHAR ) EXEC.WHEN ( PRINT.NEWLINE \'-\' PRINT.PRINTCHAR PRINT.PRINTSTRING ) )"),
+        PushParser.ParseProgram("( IN1 INTEGER.DUP STRING.FROMINTEGER 0 INTEGER.< BOOLEAN.DUP EXEC.WHEN ( STRING.REST STRING.DUP STRING.FIRST STRING.SWAP STRING.REST ) STRING.REVERSE STRING.ITERATE ( PRINT.NEWLINE PRINT.PRINTCHAR ) EXEC.WHEN ( PRINT.NEWLINE \'-\' PRINT.PRINTCHAR PRINT.PRINTSTRING ) )"),
         new Digits());
     }
@@ -93,10 +95,10 @@
       TestProgram(
         PushParser.ParseProgram(
-        @"
-        STRING.ITERATE (
-          3 EXEC.DO*COUNT CHAR.DUP
-          CHAR.ISLETTER EXEC.WHEN PRINT.PRINTCHAR
-          '!' CHAR.= EXEC.WHEN ( CHAR.DUP PRINT.PRINTCHAR PRINT.PRINTCHAR )
-          PRINT.PRINTCHAR
+        @"IN1
+          STRING.ITERATE (
+            3 EXEC.DO*COUNT CHAR.DUP
+            CHAR.ISLETTER EXEC.WHEN PRINT.PRINTCHAR
+            '!' CHAR.= EXEC.WHEN ( CHAR.DUP PRINT.PRINTCHAR PRINT.PRINTCHAR )
+            PRINT.PRINTCHAR
         )"),
         new DoubleLetters());
@@ -109,5 +111,5 @@
       TestProgram(
         PushParser.ParseProgram(
-        @"INTEGER.DUP EXEC.DO*COUNT (
+        @"IN1 INTEGER.DUP EXEC.DO*COUNT (
             INTEGER.DUP 0 INTEGER.>
             EXEC.WHEN (
@@ -133,5 +135,5 @@
       TestProgram(
         PushParser.ParseProgram(
-        @"( STRING.FROMINTEGER INTEGER.SWAP true EXEC.WHILE ( INTEGER.DUP PRINT.NEWLINE PRINT.PRINTINTEGER STRING.DUP INTEGER.FROMSTRING INTEGER.+ INTEGER.DUP 2 INTEGER.YANKDUP INTEGER.< ) )"),
+        @"( IN1 IN2 IN3 STRING.FROMINTEGER INTEGER.SWAP true EXEC.WHILE ( INTEGER.DUP PRINT.NEWLINE PRINT.PRINTINTEGER STRING.DUP INTEGER.FROMSTRING INTEGER.+ INTEGER.DUP 2 INTEGER.YANKDUP INTEGER.< ) )"),
         new ForLoopIndex());
     }
@@ -142,5 +144,5 @@
     public void Grades() {
       TestProgram(
-        PushParser.ParseProgram("( \"Student has a \" PRINT.PRINTSTRING INTEGER.DUP INTEGER.ROT INTEGER.> EXEC.WHEN ( \"F\" \" grade.\" STRING.CONCAT PRINT.PRINTSTRING EXEC.FLUSH ) INTEGER.DUP INTEGER.ROT INTEGER.> EXEC.WHEN ( \"D\" \" grade.\" STRING.CONCAT PRINT.PRINTSTRING EXEC.FLUSH ) INTEGER.DUP INTEGER.ROT INTEGER.> EXEC.WHEN ( \"C\" \" grade.\" STRING.CONCAT PRINT.PRINTSTRING EXEC.FLUSH ) INTEGER.DUP INTEGER.ROT INTEGER.> EXEC.WHEN ( \"B\" \" grade.\" STRING.CONCAT PRINT.PRINTSTRING EXEC.FLUSH ) \"A\" \" grade.\" STRING.CONCAT PRINT.PRINTSTRING )"),
+        PushParser.ParseProgram("( IN1 IN2 IN3 IN4 IN5 \"Student has a \" PRINT.PRINTSTRING INTEGER.DUP INTEGER.ROT INTEGER.> EXEC.WHEN ( \"F\" \" grade.\" STRING.CONCAT PRINT.PRINTSTRING EXEC.FLUSH ) INTEGER.DUP INTEGER.ROT INTEGER.> EXEC.WHEN ( \"D\" \" grade.\" STRING.CONCAT PRINT.PRINTSTRING EXEC.FLUSH ) INTEGER.DUP INTEGER.ROT INTEGER.> EXEC.WHEN ( \"C\" \" grade.\" STRING.CONCAT PRINT.PRINTSTRING EXEC.FLUSH ) INTEGER.DUP INTEGER.ROT INTEGER.> EXEC.WHEN ( \"B\" \" grade.\" STRING.CONCAT PRINT.PRINTSTRING EXEC.FLUSH ) \"A\" \" grade.\" STRING.CONCAT PRINT.PRINTSTRING )"),
         new Grades());
     }
@@ -151,5 +153,5 @@
     public void LastIndexOfZero() {
       TestProgram(
-        PushParser.ParseProgram("( INTEGER[].DUP INTEGER[].LENGTH INTEGER[].REVERSE 0 INTEGER[].INDEXOF INTEGER.- INTEGER.DEC )"),
+        PushParser.ParseProgram("( IN1 INTEGER[].DUP INTEGER[].LENGTH INTEGER[].REVERSE 0 INTEGER[].INDEXOF INTEGER.- INTEGER.DEC )"),
         new LastIndexOfZero());
     }
@@ -160,5 +162,5 @@
     public void Median() {
       TestProgram(
-        PushParser.ParseProgram("( INTEGER.ROT INTEGER.DUP 2 INTEGER.YANKDUP INTEGER.MAX 3 INTEGER.YANKDUP INTEGER.MIN INTEGER.ROT INTEGER.MIN INTEGER.MAX PRINT.PRINTINTEGER )"),
+        PushParser.ParseProgram("( IN1 IN2 IN3 INTEGER.ROT INTEGER.DUP 2 INTEGER.YANKDUP INTEGER.MAX 3 INTEGER.YANKDUP INTEGER.MIN INTEGER.ROT INTEGER.MIN INTEGER.MAX PRINT.PRINTINTEGER )"),
         new Median());
     }
@@ -170,5 +172,6 @@
       TestProgram(
         PushParser.ParseProgram(
-          @"( INTEGER[].PUSHALL INTEGER[].ITERATE (
+          @"( IN1 IN2
+              INTEGER[].PUSHALL INTEGER[].ITERATE (
                 INTEGER.= BOOLEAN.NOT EXEC.WHEN ( false EXEC.FLUSH )
               )
@@ -183,5 +186,5 @@
     public void NegativeToZero() {
       TestProgram(
-        PushParser.ParseProgram("( INTEGER[].DUP INTEGER[].LENGTH INTEGER.DEC EXEC.DO*COUNT ( INTEGER.DUP INTEGER[].DUP INTEGER[].NTH 0 INTEGER.< EXEC.WHEN ( 0 INTEGER[].SET ) ) )"),
+        PushParser.ParseProgram("( IN1 INTEGER[].DUP INTEGER[].LENGTH INTEGER.DEC EXEC.DO*COUNT ( INTEGER.DUP INTEGER[].DUP INTEGER[].NTH 0 INTEGER.< EXEC.WHEN ( 0 INTEGER[].SET ) ) )"),
         new NegativeToZero());
     }
@@ -192,5 +195,5 @@
     public void NumberIo() {
       TestProgram(
-        PushParser.ParseProgram("FLOAT.FROMINTEGER FLOAT.+ PRINT.PRINTFLOAT"),
+        PushParser.ParseProgram("IN1 IN2 FLOAT.FROMINTEGER FLOAT.+ PRINT.PRINTFLOAT"),
         new NumberIO());
     }
@@ -202,5 +205,5 @@
     public void PigLatin() {
       TestProgram(
-        PushParser.ParseProgram("@( STRING.SPLIT STRING.STACKDEPTH 0 INTEGER.= EXEC.WHEN EXEC.FLUSH STRING.STACKDEPTH EXEC.DO*TIMES ( STRING.DUP STRING.FIRST CHAR.ALLFROMSTRING CHAR.DUP \"aeiou\" STRING.CONTAINSCHAR EXEC.IF ( CHAR.POP ) ( STRING.REST STRING.CONJCHAR ) \"ay\" STRING.CONCAT STRING.STACKDEPTH 1 INTEGER.> EXEC.WHEN ( ' ' STRING.CONJCHAR ) PRINT.PRINTSTRING ) )"),
+        PushParser.ParseProgram("@( IN1 STRING.SPLIT STRING.STACKDEPTH 0 INTEGER.= EXEC.WHEN EXEC.FLUSH STRING.STACKDEPTH EXEC.DO*TIMES ( STRING.DUP STRING.FIRST CHAR.ALLFROMSTRING CHAR.DUP \"aeiou\" STRING.CONTAINSCHAR EXEC.IF ( CHAR.POP ) ( STRING.REST STRING.CONJCHAR ) \"ay\" STRING.CONCAT STRING.STACKDEPTH 1 INTEGER.> EXEC.WHEN ( ' ' STRING.CONJCHAR ) PRINT.PRINTSTRING ) )"),
         new PigLatin());
     }
@@ -212,5 +215,5 @@
 
       TestProgram(
-        PushParser.ParseProgram("STRING.DUP 0 STRING.ITERATE ( CHAR.DUP ' ' CHAR.= EXEC.IF ( CHAR.POP '\n' ) INTEGER.INC PRINT.PRINTCHAR )"),
+        PushParser.ParseProgram("IN1 STRING.DUP 0 STRING.ITERATE ( CHAR.DUP ' ' CHAR.= EXEC.IF ( CHAR.POP '\n' ) INTEGER.INC PRINT.PRINTCHAR )"),
         new ReplaceSpaceWithNewline());
     }
@@ -221,5 +224,5 @@
     public void ScrabbleScore() {
       TestProgram(
-        PushParser.ParseProgram("( STRING.ITERATE ( INTEGER.FROMCHAR INTEGER.DUP INTEGER.DUP 96 INTEGER.> 123 INTEGER.< BOOLEAN.AND EXEC.WHEN ( 32 INTEGER.- ) 65 INTEGER.- INTEGER.DUP INTEGER.DUP 0 INTEGER.>= 26 INTEGER.< BOOLEAN.AND EXEC.IF ( [1 3 3 2 1 4 2 4 1 8 5 1 3 1 1 3 10 1 1 1 1 4 4 8 4 10] INTEGER[].NTH INTEGER.+ ) ( INTEGER.POP ) ) )"),
+        PushParser.ParseProgram("( IN1 STRING.ITERATE ( INTEGER.FROMCHAR INTEGER.DUP INTEGER.DUP 96 INTEGER.> 123 INTEGER.< BOOLEAN.AND EXEC.WHEN ( 32 INTEGER.- ) 65 INTEGER.- INTEGER.DUP INTEGER.DUP 0 INTEGER.>= 26 INTEGER.< BOOLEAN.AND EXEC.IF ( [1 3 3 2 1 4 2 4 1 8 5 1 3 1 1 3 10 1 1 1 1 4 4 8 4 10] INTEGER[].NTH INTEGER.+ ) ( INTEGER.POP ) ) )"),
         new ScrabbleScore());
     }
@@ -230,5 +233,5 @@
     public void Smallest() {
       TestProgram(
-        PushParser.ParseProgram("( 3 EXEC.DO*TIMES INTEGER.MIN )"),
+        PushParser.ParseProgram("( IN1 IN2 IN3 IN4 3 EXEC.DO*TIMES INTEGER.MIN )"),
         new Smallest());
     }
@@ -240,5 +243,6 @@
       TestProgram(
         PushParser.ParseProgram(
-          @"INTEGER.DUP 1000 INTEGER.< 2000 INTEGER.>=
+          @"IN1
+            INTEGER.DUP 1000 INTEGER.< 2000 INTEGER.>=
             EXEC.WHEN ""large""
             EXEC.WHEN ""small""
@@ -255,5 +259,6 @@
       TestProgram(
         PushParser.ParseProgram(
-          @"CHAR.ALLFROMSTRING 0 STRING.ITERATE (
+          @"IN1 IN2
+            CHAR.ALLFROMSTRING 0 STRING.ITERATE (
             CHAR.DUP 2 CHAR.YANKDUP CHAR.= BOOLEAN.NOT EXEC.IF (
               INTEGER.DUP PRINT.PRINTINTEGER
@@ -272,5 +277,5 @@
     public void StringLengthsBackwards() {
       TestProgram(
-        PushParser.ParseProgram(@"STRING[].ITERATE ( STRING.LENGTH PRINT.NEWLINE PRINT.PRINTINTEGER )"),
+        PushParser.ParseProgram(@"IN1 STRING[].ITERATE ( STRING.LENGTH PRINT.NEWLINE PRINT.PRINTINTEGER )"),
         new StringLengthsBackwards());
     }
@@ -281,5 +286,5 @@
     public void SumOfSquares() {
       TestProgram(
-       PushParser.ParseProgram(@"( EXEC.DO*COUNT ( INTEGER.DUP INTEGER.* INTEGER.+ ) )"),
+       PushParser.ParseProgram(@"( IN1 EXEC.DO*COUNT ( INTEGER.DUP INTEGER.* INTEGER.+ ) )"),
        new SumOfSquares());
     }
@@ -290,5 +295,5 @@
     public void SuperAnagrams() {
       TestProgram(
-        PushParser.ParseProgram(@"( STRING.SWAP STRING.DUP STRING.ITERATE ( CHAR.DUP STRING.DUP STRING.OCCURRENCESOFCHAR 1 STRING.YANKDUP STRING.OCCURRENCESOFCHAR INTEGER.> EXEC.WHEN ( false EXEC.FLUSH ) ) true )"),
+        PushParser.ParseProgram(@"( IN1 IN2 STRING.SWAP STRING.DUP STRING.ITERATE ( CHAR.DUP STRING.DUP STRING.OCCURRENCESOFCHAR 1 STRING.YANKDUP STRING.OCCURRENCESOFCHAR INTEGER.> EXEC.WHEN ( false EXEC.FLUSH ) ) true )"),
         new SuperAnagrams());
     }
@@ -299,5 +304,5 @@
     public void Syllables() {
       TestProgram(
-       PushParser.ParseProgram("( \"aeiouy\" 0 STRING.ITERATE ( STRING.DUP STRING.OCCURRENCESOFCHAR INTEGER.+ ) \"The number of syllables is \" PRINT.PRINTSTRING PRINT.PRINTINTEGER )"),
+       PushParser.ParseProgram("( IN1 \"aeiouy\" 0 STRING.ITERATE ( STRING.DUP STRING.OCCURRENCESOFCHAR INTEGER.+ ) \"The number of syllables is \" PRINT.PRINTSTRING PRINT.PRINTINTEGER )"),
        new Syllables());
     }
@@ -308,5 +313,5 @@
     public void VectorAverage() {
       TestProgram(
-        PushParser.ParseProgram("( FLOAT[].DUP FLOAT[].LENGTH FLOAT[].ITERATE FLOAT.+ FLOAT.FROMINTEGER FLOAT./ )"),
+        PushParser.ParseProgram("( IN1 FLOAT[].DUP FLOAT[].LENGTH FLOAT[].ITERATE FLOAT.+ FLOAT.FROMINTEGER FLOAT./ )"),
         new VectorAverage());
     }
@@ -317,5 +322,5 @@
     public void VectorSummed() {
       TestProgram(
-        PushParser.ParseProgram(@"( INTEGER[].PUSHALL INTEGER[].DUP INTEGER[].LENGTH INTEGER.DEC EXEC.DO*COUNT ( INTEGER.DUP INTEGER[].DUP INTEGER[].NTH INTEGER.SWAP INTEGER.ROT INTEGER.+ INTEGER[].SET ) )"),
+        PushParser.ParseProgram(@"( IN1 IN2 INTEGER[].PUSHALL INTEGER[].DUP INTEGER[].LENGTH INTEGER.DEC EXEC.DO*COUNT ( INTEGER.DUP INTEGER[].DUP INTEGER[].NTH INTEGER.SWAP INTEGER.ROT INTEGER.+ INTEGER[].SET ) )"),
         new VectorSummed());
     }
@@ -326,5 +331,5 @@
     public void WallisPi() {
       TestProgram(
-        PushParser.ParseProgram(@"( 2 3 INTEGER.ROT INTEGER.ROT EXEC.DO*TIMES ( 2 EXEC.DO*TIMES ( 1 INTEGER.YANKDUP 1 INTEGER.YANKDUP ) FLOAT.FROMINTEGER FLOAT.FROMINTEGER FLOAT.SWAP FLOAT./ FLOAT.* INTEGER.< EXEC.IF ( INTEGER.SWAP 2 INTEGER.+ INTEGER.SWAP ) ( 2 INTEGER.+ ) ) )"),
+        PushParser.ParseProgram(@"( IN1 2 3 INTEGER.ROT INTEGER.ROT EXEC.DO*TIMES ( 2 EXEC.DO*TIMES ( 1 INTEGER.YANKDUP 1 INTEGER.YANKDUP ) FLOAT.FROMINTEGER FLOAT.FROMINTEGER FLOAT.SWAP FLOAT./ FLOAT.* INTEGER.< EXEC.IF ( INTEGER.SWAP 2 INTEGER.+ INTEGER.SWAP ) ( 2 INTEGER.+ ) ) )"),
         new WallisPi());
     }
@@ -335,5 +340,5 @@
     public void WordStats() {
       TestProgram(
-        PushParser.ParseProgram("( STRING.DUP STRING.SPLIT STRING.STACKDEPTH 1 INTEGER.= BOOLEAN.NOT EXEC.WHEN ( true EXEC.WHILE ( STRING.LENGTH INTEGER.MAX STRING.STACKDEPTH 1 INTEGER.= BOOLEAN.NOT ) [0] 2 INTEGER.- INTEGER.DUP 0 INTEGER.>= EXEC.WHEN ( INTEGER.INC EXEC.DO*TIMES ( 0 INTEGER[].CONJ ) ) STRING.DUP STRING.SPLIT STRING.STACKDEPTH 1 INTEGER.> EXEC.WHILE ( STRING.LENGTH INTEGER.DEC INTEGER.DUP INTEGER[].DUP INTEGER[].NTH INTEGER.INC INTEGER[].SET STRING.STACKDEPTH 1 INTEGER.> ) INTEGER[].DUP INTEGER[].LENGTH INTEGER.DEC EXEC.DO*COUNT ( PRINT.NEWLINE \"words of length \" PRINT.PRINTSTRING INTEGER.DUP INTEGER.INC PRINT.PRINTINTEGER \": \" PRINT.PRINTSTRING INTEGER[].DUP INTEGER[].NTH PRINT.PRINTINTEGER ) \'.\' STRING.DUP STRING.OCCURRENCESOFCHAR \'!\' STRING.DUP STRING.OCCURRENCESOFCHAR INTEGER.+ \'?\' STRING.DUP STRING.OCCURRENCESOFCHAR INTEGER.+ INTEGER.DUP PRINT.NEWLINE \"number of sentences: \" PRINT.PRINTSTRING PRINT.PRINTINTEGER STRING.SPLIT STRING.STACKDEPTH FLOAT.FROMINTEGER FLOAT.FROMINTEGER FLOAT./ PRINT.NEWLINE \"average sentence length: \" PRINT.PRINTSTRING PRINT.PRINTFLOAT ) )"),
+        PushParser.ParseProgram("( IN1 STRING.DUP STRING.SPLIT STRING.STACKDEPTH 1 INTEGER.= BOOLEAN.NOT EXEC.WHEN ( true EXEC.WHILE ( STRING.LENGTH INTEGER.MAX STRING.STACKDEPTH 1 INTEGER.= BOOLEAN.NOT ) [0] 2 INTEGER.- INTEGER.DUP 0 INTEGER.>= EXEC.WHEN ( INTEGER.INC EXEC.DO*TIMES ( 0 INTEGER[].CONJ ) ) STRING.DUP STRING.SPLIT STRING.STACKDEPTH 1 INTEGER.> EXEC.WHILE ( STRING.LENGTH INTEGER.DEC INTEGER.DUP INTEGER[].DUP INTEGER[].NTH INTEGER.INC INTEGER[].SET STRING.STACKDEPTH 1 INTEGER.> ) INTEGER[].DUP INTEGER[].LENGTH INTEGER.DEC EXEC.DO*COUNT ( PRINT.NEWLINE \"words of length \" PRINT.PRINTSTRING INTEGER.DUP INTEGER.INC PRINT.PRINTINTEGER \": \" PRINT.PRINTSTRING INTEGER[].DUP INTEGER[].NTH PRINT.PRINTINTEGER ) \'.\' STRING.DUP STRING.OCCURRENCESOFCHAR \'!\' STRING.DUP STRING.OCCURRENCESOFCHAR INTEGER.+ \'?\' STRING.DUP STRING.OCCURRENCESOFCHAR INTEGER.+ INTEGER.DUP PRINT.NEWLINE \"number of sentences: \" PRINT.PRINTSTRING PRINT.PRINTINTEGER STRING.SPLIT STRING.STACKDEPTH FLOAT.FROMINTEGER FLOAT.FROMINTEGER FLOAT./ PRINT.NEWLINE \"average sentence length: \" PRINT.PRINTSTRING PRINT.PRINTFLOAT ) )"),
         new WordStats(),
         "0.0#########");
@@ -345,5 +350,5 @@
     public void XWordLines() {
       TestProgram(
-        PushParser.ParseProgram(@"( STRING.SPLIT STRING.EMPTY BOOLEAN.NOT INTEGER.DUP 1 INTEGER.= EXEC.IF ( EXEC.WHILE ( PRINT.NEWLINE PRINT.PRINTSTRING STRING.EMPTY BOOLEAN.NOT ) ) ( 2 INTEGER.- EXEC.WHILE ( STRING.STACKDEPTH 2 INTEGER.- 1 INTEGER.YANKDUP INTEGER.MIN INTEGER.DUP 0 INTEGER.>= EXEC.IF ( INTEGER.INC EXEC.DO*TIMES ( ' ' STRING.CONJCHAR STRING.SWAP STRING.CONCAT ) PRINT.NEWLINE PRINT.PRINTSTRING STRING.EMPTY BOOLEAN.NOT ) ( PRINT.NEWLINE PRINT.PRINTSTRING STRING.EMPTY BOOLEAN.NOT ) ) ) )"),
+        PushParser.ParseProgram(@"( IN1 IN2 STRING.SPLIT STRING.EMPTY BOOLEAN.NOT INTEGER.DUP 1 INTEGER.= EXEC.IF ( EXEC.WHILE ( PRINT.NEWLINE PRINT.PRINTSTRING STRING.EMPTY BOOLEAN.NOT ) ) ( 2 INTEGER.- EXEC.WHILE ( STRING.STACKDEPTH 2 INTEGER.- 1 INTEGER.YANKDUP INTEGER.MIN INTEGER.DUP 0 INTEGER.>= EXEC.IF ( INTEGER.INC EXEC.DO*TIMES ( ' ' STRING.CONJCHAR STRING.SWAP STRING.CONCAT ) PRINT.NEWLINE PRINT.PRINTSTRING STRING.EMPTY BOOLEAN.NOT ) ( PRINT.NEWLINE PRINT.PRINTSTRING STRING.EMPTY BOOLEAN.NOT ) ) ) )"),
         new XWordLines());
     }
Index: branches/PushGP/HeuristicLab.PushGP/HeuristicLab.Tests/Components/PrintStackTests.cs
===================================================================
--- branches/PushGP/HeuristicLab.PushGP/HeuristicLab.Tests/Components/PrintStackTests.cs	(revision 15189)
+++ branches/PushGP/HeuristicLab.PushGP/HeuristicLab.Tests/Components/PrintStackTests.cs	(revision 15189)
@@ -0,0 +1,58 @@
+﻿namespace HeuristicLab.Tests.Components {
+  using System.Linq;
+
+  using HeuristicLab.Problems.ProgramSynthesis.Push.Stack;
+
+  using Microsoft.VisualStudio.TestTools.UnitTesting;
+
+  [TestClass]
+  public class PrintStackTests {
+
+    private PrintStack printStack;
+
+    [TestInitialize]
+    public void BeforeTest() {
+      printStack = new PrintStack();
+    }
+
+    [TestMethod]
+    public void TestPushLong() {
+      printStack.Push(100L);
+
+      Assert.AreEqual(100L.ToString(), printStack.Top);
+    }
+
+    [TestMethod]
+    public void TestPushDouble() {
+      printStack.Push(100.5D);
+
+      Assert.AreEqual(100.5D.ToString(), printStack.Top);
+    }
+
+    [TestMethod]
+    public void TestAsStringsWithNewline() {
+      printStack.Push(100.5D);
+      printStack.Push(10);
+      printStack.NewLine();
+      printStack.Push("abc");
+      printStack.Push('d');
+
+      var lines = printStack.AsStrings().ToList();
+
+      Assert.AreEqual(2, lines.Count);
+      Assert.AreEqual("100,510", lines[0]);
+      Assert.AreEqual("abcd", lines[1]);
+    }
+
+    [TestMethod]
+    public void TestAsStringsWithoutNewline() {
+      printStack.Push(100.5D);
+      printStack.Push(10);
+
+      var lines = printStack.AsStrings().ToList();
+
+      Assert.AreEqual(1, lines.Count);
+      Assert.AreEqual("100,510", lines[0]);
+    }
+  }
+}
Index: branches/PushGP/HeuristicLab.PushGP/HeuristicLab.Tests/HeuristicLab.Tests.csproj
===================================================================
--- branches/PushGP/HeuristicLab.PushGP/HeuristicLab.Tests/HeuristicLab.Tests.csproj	(revision 15033)
+++ branches/PushGP/HeuristicLab.PushGP/HeuristicLab.Tests/HeuristicLab.Tests.csproj	(revision 15189)
@@ -89,4 +89,5 @@
     <Compile Include="Benchmark\RandomWalkTests.cs" />
     <Compile Include="Benchmark\SolutionTests.cs" />
+    <Compile Include="Components\PrintStackTests.cs" />
     <Compile Include="Erc\ErcTests.cs" />
     <Compile Include="Interpreter\Expressions\BooleanVectorExpressionsTests.cs" />
Index: branches/PushGP/HeuristicLab.PushGP/HeuristicLab.Tests/Interpreter/Expressions/CommonTests.cs
===================================================================
--- branches/PushGP/HeuristicLab.PushGP/HeuristicLab.Tests/Interpreter/Expressions/CommonTests.cs	(revision 15033)
+++ branches/PushGP/HeuristicLab.PushGP/HeuristicLab.Tests/Interpreter/Expressions/CommonTests.cs	(revision 15189)
@@ -310,5 +310,5 @@
         Test(ExpressionTable.GetStatelessExpression(fullInstructionName));
 
-        for (var j = 0; j < i; j++) Assert.AreEqual(values[j], Stack.ReverseElementAt(j));
+        for (var j = 0; j < i; j++) Assert.AreEqual(values[j], Stack[i - j - 1]);
 
         CheckOtherStacksAreEmpty();
Index: branches/PushGP/HeuristicLab.PushGP/HeuristicLab.Tests/Problem/IndividualMapperTests.cs
===================================================================
--- branches/PushGP/HeuristicLab.PushGP/HeuristicLab.Tests/Problem/IndividualMapperTests.cs	(revision 15033)
+++ branches/PushGP/HeuristicLab.PushGP/HeuristicLab.Tests/Problem/IndividualMapperTests.cs	(revision 15189)
@@ -11,4 +11,5 @@
   using HeuristicLab.Problems.ProgramSynthesis.Push.Configuration;
   using HeuristicLab.Problems.ProgramSynthesis.Push.Data.Pool;
+  using HeuristicLab.Problems.ProgramSynthesis.Push.Individual;
   using HeuristicLab.Problems.ProgramSynthesis.Push.Interpreter;
   using HeuristicLab.Problems.ProgramSynthesis.Push.Problem;
Index: branches/PushGP/HeuristicLab.PushGP/PushGp.sln.DotSettings.user
===================================================================
--- branches/PushGP/HeuristicLab.PushGP/PushGp.sln.DotSettings.user	(revision 15033)
+++ branches/PushGP/HeuristicLab.PushGP/PushGp.sln.DotSettings.user	(revision 15189)
@@ -1,6 +1,6 @@
 ﻿<wpf:ResourceDictionary xml:space="preserve" xmlns:x="http://schemas.microsoft.com/winfx/2006/xaml" xmlns:s="clr-namespace:System;assembly=mscorlib" xmlns:ss="urn:shemas-jetbrains-com:settings-storage-xaml" xmlns:wpf="http://schemas.microsoft.com/winfx/2006/xaml/presentation">
-	<s:Boolean x:Key="/Default/CoverageSessionsPersistenceManagerSettings/SessionPersistentData/=93500A25BF4B4D74BD88F90837CFB4C0/@KeyIndexDefined">True</s:Boolean>
-	<s:String x:Key="/Default/CoverageSessionsPersistenceManagerSettings/SessionPersistentData/=93500A25BF4B4D74BD88F90837CFB4C0/ProductVersion/@EntryValue">2016.2.2</s:String>
-	<s:String x:Key="/Default/CoverageSessionsPersistenceManagerSettings/SessionPersistentData/=93500A25BF4B4D74BD88F90837CFB4C0/SnapshotLocation/@EntryValue">C:\Users\patrik\AppData\Local\Temp\ssm.Nabitin.tmp</s:String>
+	
+	
+	
 	<s:String x:Key="/Default/Environment/AssemblyExplorer/XmlDocument/@EntryValue">&lt;AssemblyExplorer&gt;&#xD;
   &lt;Assembly Path="T:\BTSync\projects\svn\hl\trunk\sources\bin\HeuristicLab.Encodings.SymbolicExpressionTreeEncoding-3.4.dll" /&gt;&#xD;
