Index: /branches/PushGP/HeuristicLab.PushGP/FeatureTests/Program.cs
===================================================================
--- /branches/PushGP/HeuristicLab.PushGP/FeatureTests/Program.cs	(revision 15272)
+++ /branches/PushGP/HeuristicLab.PushGP/FeatureTests/Program.cs	(revision 15273)
@@ -52,5 +52,6 @@
       //TestExpressionDependencies();
       //TestSplitLogic();
-      TestStringBuilder();
+      //TestStringBuilder();
+      TestRandomReset();
 
       Console.WriteLine("\nPress any key to continue...");
@@ -67,4 +68,16 @@
       // false
       var equal = ReferenceEquals(s1, s2);
+    }
+
+    private static void TestRandomReset() {
+      var random = new MersenneTwister(1000);
+
+      var x = random.Next();
+      random.Reset();
+      var y = random.Next();
+
+      if (x != y) {
+        throw new InvalidOperationException();
+      }
     }
 
@@ -422,5 +435,5 @@
       for (var i = 0; i < 60000000; i++) {
         interpreter.Run(program);
-        interpreter.Clear();
+        interpreter.ClearStacks();
       }
       sw.Stop();
@@ -442,5 +455,5 @@
           for (var j = 0; j < amount; j++) {
             interpreter.Run(program);
-            interpreter.Clear();
+            interpreter.ClearStacks();
           }
         }
@@ -552,5 +565,5 @@
       for (var i = 0; i < iterations; i++) {
         var interpreter = new PushInterpreter();
-        interpreter.Clear();
+        interpreter.ClearStacks();
       }
       sw.Stop();
@@ -562,5 +575,5 @@
       for (var i = 0; i < iterations; i++) {
         using (var interpreter = pool.Create()) {
-          interpreter.Clear();
+          interpreter.ClearStacks();
         }
       }
@@ -597,4 +610,6 @@
     public int Age { get; set; }
 
+    public void Init() { }
+
     public void Reset() {
       Age = default(int);
Index: /branches/PushGP/HeuristicLab.PushGP/HeuristicLab.Problem.ProgramSynthesis.BenchmarkSuite/ProblemData.cs
===================================================================
--- /branches/PushGP/HeuristicLab.PushGP/HeuristicLab.Problem.ProgramSynthesis.BenchmarkSuite/ProblemData.cs	(revision 15272)
+++ /branches/PushGP/HeuristicLab.PushGP/HeuristicLab.Problem.ProgramSynthesis.BenchmarkSuite/ProblemData.cs	(revision 15273)
@@ -53,5 +53,5 @@
     public ExampleArgumentType[] OutputArgumentTypes { get; set; }
 
-    public int TotalIntputArgumentCount { get { return InputArgumentTypes.Length; } }
+    public int TotalInputArgumentCount { get { return InputArgumentTypes.Length; } }
     public int TotalOutputArgumentCount { get { return OutputArgumentTypes.Length; } }
     public int TotalArgumentCount { get { return InputArgumentTypes.Length + OutputArgumentTypes.Length; } }
Index: /branches/PushGP/HeuristicLab.PushGP/HeuristicLab.Problems.ProgramSynthesis.Base/Erc/ErcOptionConvertible.cs
===================================================================
--- /branches/PushGP/HeuristicLab.PushGP/HeuristicLab.Problems.ProgramSynthesis.Base/Erc/ErcOptionConvertible.cs	(revision 15272)
+++ /branches/PushGP/HeuristicLab.PushGP/HeuristicLab.Problems.ProgramSynthesis.Base/Erc/ErcOptionConvertible.cs	(revision 15273)
@@ -7,5 +7,5 @@
   using HeuristicLab.Core;
   using HeuristicLab.Persistence.Default.CompositeSerializers.Storable;
-  using HeuristicLab.Problems.ProgramSynthesis.Base.Weighted;
+  using HeuristicLab.Problems.ProgramSynthesis.Base.Extensions;
 
   [StorableClass]
@@ -93,5 +93,5 @@
       var ercValueItem = list
         .Where(item => item.IsEnabled)
-        .RandomWeightedOrDefault(random);
+        .RandomWeightedOrDefault(random, x => x.Weight);
 
       return ercValueItem == null
Index: /branches/PushGP/HeuristicLab.PushGP/HeuristicLab.Problems.ProgramSynthesis.Base/Extensions/EnumerableExtensions.cs
===================================================================
--- /branches/PushGP/HeuristicLab.PushGP/HeuristicLab.Problems.ProgramSynthesis.Base/Extensions/EnumerableExtensions.cs	(revision 15273)
+++ /branches/PushGP/HeuristicLab.PushGP/HeuristicLab.Problems.ProgramSynthesis.Base/Extensions/EnumerableExtensions.cs	(revision 15273)
@@ -0,0 +1,29 @@
+﻿namespace HeuristicLab.Problems.ProgramSynthesis.Base.Extensions {
+  using System;
+  using System.Collections.Generic;
+  using System.Linq;
+
+  using HeuristicLab.Core;
+  using HeuristicLab.Random;
+
+  public static class EnumerableExtensions {
+    public static T RandomWeightedOrDefault<T>(this IEnumerable<T> items, IRandom random, Func<T, double> weightResolver) {
+      random = random ?? new MersenneTwister();
+      var totalWeight = items.Sum(weightResolver);
+
+      // The weight we are after...
+      var itemWeightIndex = random.NextDouble() * totalWeight;
+      var currentWeightIndex = 0d;
+
+      foreach (var item in items) {
+        currentWeightIndex += weightResolver(item);
+
+        // If we've hit or passed the weight we are after for this item then it's the one we want....
+        if (currentWeightIndex >= itemWeightIndex)
+          return item;
+      }
+
+      return default(T);
+    }
+  }
+}
Index: /branches/PushGP/HeuristicLab.PushGP/HeuristicLab.Problems.ProgramSynthesis.Base/HeuristicLab.Problems.ProgramSynthesis.Base.csproj
===================================================================
--- /branches/PushGP/HeuristicLab.PushGP/HeuristicLab.Problems.ProgramSynthesis.Base/HeuristicLab.Problems.ProgramSynthesis.Base.csproj	(revision 15272)
+++ /branches/PushGP/HeuristicLab.PushGP/HeuristicLab.Problems.ProgramSynthesis.Base/HeuristicLab.Problems.ProgramSynthesis.Base.csproj	(revision 15273)
@@ -123,9 +123,9 @@
     <Compile Include="Erc\String\StringRandomErc.cs" />
     <Compile Include="Erc\String\StringErcOptions.cs" />
+    <Compile Include="Extensions\EnumerableExtensions.cs" />
     <Compile Include="Generators\StringGenerator.cs" />
     <Compile Include="Weighted\IWeighted.cs" />
     <Compile Include="Plugin.cs" />
     <Compile Include="Properties\AssemblyInfo.cs" />
-    <Compile Include="Weighted\WeightedExtensions.cs" />
   </ItemGroup>
   <ItemGroup>
Index: anches/PushGP/HeuristicLab.PushGP/HeuristicLab.Problems.ProgramSynthesis.Base/Weighted/WeightedExtensions.cs
===================================================================
--- /branches/PushGP/HeuristicLab.PushGP/HeuristicLab.Problems.ProgramSynthesis.Base/Weighted/WeightedExtensions.cs	(revision 15272)
+++ 	(revision )
@@ -1,27 +1,0 @@
-﻿using System.Collections.Generic;
-using System.Linq;
-
-namespace HeuristicLab.Problems.ProgramSynthesis.Base.Weighted {
-  using HeuristicLab.Core;
-  using HeuristicLab.Random;
-
-  public static class WeightedExtensions {
-    public static T RandomWeightedOrDefault<T>(this IEnumerable<T> items, IRandom random = null) where T : IWeighted {
-      random = random ?? new MersenneTwister();
-      var totalWeight = items.Sum(x => x.Weight);
-      // The weight we are after...
-      var itemWeightIndex = random.NextDouble() * totalWeight;
-      var currentWeightIndex = 0d;
-
-      foreach (var item in items) {
-        currentWeightIndex += item.Weight;
-
-        // If we've hit or passed the weight we are after for this item then it's the one we want....
-        if (currentWeightIndex >= itemWeightIndex)
-          return item;
-      }
-
-      return default(T);
-    }
-  }
-}
Index: /branches/PushGP/HeuristicLab.PushGP/HeuristicLab.Problems.ProgramSynthesis/HeuristicLab.Problems.ProgramSynthesis.csproj
===================================================================
--- /branches/PushGP/HeuristicLab.PushGP/HeuristicLab.Problems.ProgramSynthesis/HeuristicLab.Problems.ProgramSynthesis.csproj	(revision 15272)
+++ /branches/PushGP/HeuristicLab.PushGP/HeuristicLab.Problems.ProgramSynthesis/HeuristicLab.Problems.ProgramSynthesis.csproj	(revision 15273)
@@ -122,4 +122,6 @@
       <DependentUpon>Resources.resx</DependentUpon>
     </Compile>
+    <Compile Include="Push\Analyzer\IIndividualZeroErrorAnalyzer.cs" />
+    <Compile Include="Push\Analyzer\IndividualZeroErrorAnalyzer.cs" />
     <Compile Include="Push\Analyzer\IPushExpressionAnalyzer.cs" />
     <Compile Include="Push\Analyzer\PushExpressionFrequencyAnalyzer.cs" />
@@ -195,5 +197,4 @@
     <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" />
@@ -212,4 +213,5 @@
     <Compile Include="Push\Interpreter\PushInterpreter.cs" />
     <Compile Include="Push\Interpreter\PushInterpreterPool.cs" />
+    <Compile Include="Push\ObjectPools\Random\SeededRandomPool.cs" />
     <Compile Include="Push\ObjectPools\StringBuilderPool.cs" />
     <Compile Include="Push\Parser\PushParser.cs" />
@@ -228,4 +230,6 @@
     <Compile Include="Push\Selector\LexicaseSelector.cs" />
     <Compile Include="Push\Simplifier\Simplifier.cs" />
+    <Compile Include="Push\SolutionCreator\PushSolutionCreator.cs" />
+    <Compile Include="Push\SolutionCreator\PushSolutionEncoding.cs" />
     <Compile Include="Push\Stack\IPrintStack.cs" />
     <Compile Include="Push\Stack\IPushStack.cs" />
Index: /branches/PushGP/HeuristicLab.PushGP/HeuristicLab.Problems.ProgramSynthesis/Push/Analyzer/IIndividualZeroErrorAnalyzer.cs
===================================================================
--- /branches/PushGP/HeuristicLab.PushGP/HeuristicLab.Problems.ProgramSynthesis/Push/Analyzer/IIndividualZeroErrorAnalyzer.cs	(revision 15273)
+++ /branches/PushGP/HeuristicLab.PushGP/HeuristicLab.Problems.ProgramSynthesis/Push/Analyzer/IIndividualZeroErrorAnalyzer.cs	(revision 15273)
@@ -0,0 +1,7 @@
+﻿namespace HeuristicLab.Problems.ProgramSynthesis.Push.Analyzer {
+  using HeuristicLab.Optimization;
+
+  public interface IIndividualZeroErrorAnalyzer : IAnalyzer {
+
+  }
+}
Index: /branches/PushGP/HeuristicLab.PushGP/HeuristicLab.Problems.ProgramSynthesis/Push/Analyzer/IndividualZeroErrorAnalyzer.cs
===================================================================
--- /branches/PushGP/HeuristicLab.PushGP/HeuristicLab.Problems.ProgramSynthesis/Push/Analyzer/IndividualZeroErrorAnalyzer.cs	(revision 15273)
+++ /branches/PushGP/HeuristicLab.PushGP/HeuristicLab.Problems.ProgramSynthesis/Push/Analyzer/IndividualZeroErrorAnalyzer.cs	(revision 15273)
@@ -0,0 +1,135 @@
+﻿namespace HeuristicLab.Problems.ProgramSynthesis.Push.Analyzer {
+
+  using HeuristicLab.Analysis;
+  using HeuristicLab.Common;
+  using HeuristicLab.Core;
+  using HeuristicLab.Data;
+  using HeuristicLab.Operators;
+  using HeuristicLab.Optimization;
+  using HeuristicLab.Parameters;
+  using HeuristicLab.Persistence.Default.CompositeSerializers.Storable;
+  using HeuristicLab.Problems.ProgramSynthesis.Push.Problem;
+
+  /// <summary>
+  /// An operater that tracks the count of individuals with zero error on the cases
+  /// </summary>
+  [Item("IndividualZeroErrorAnalyzer", "An operater that tracks the count of individuals with zero error on the cases")]
+  [StorableClass]
+  public class IndividualZeroErrorAnalyzer : SingleSuccessorOperator, IIndividualZeroErrorAnalyzer {
+    private const string RESULTS_PARAMETER_NAME = "Results";
+    private const string INDIVIDUAL_ZERO_ERROR_PARAMETER_NAME = "ZeroErrorIndividualsPerCase";
+
+    private const string RESULT_PARAMETER_NAME = "Zero Error Individuals Per Case";
+    private const string RESULT_PARAMETER_DESCRIPTION = "Relative frequency of instructions aggregated over the whole population.";
+    private const string Y_AXIS_TITLE = "Count if zero error individuals";
+    private const string X_AXIS_TITLE = "Case Index";
+    private const string ROW_NAME = "Cases";
+
+    public IndividualZeroErrorAnalyzer() {
+      Parameters.Add(new LookupParameter<DataTable>(
+        INDIVIDUAL_ZERO_ERROR_PARAMETER_NAME,
+        "The data table to store the count of individuals with zero error."));
+
+      Parameters.Add(new LookupParameter<ResultCollection>(
+        RESULTS_PARAMETER_NAME,
+        "The result collection where the symbol frequencies should be stored."));
+
+      Parameters.Add(new ScopeTreeLookupParameter<DoubleArray>(
+       PushProblem.CaseQualitiesScopeParameterName,
+       "The quality of every single training case for each individual."));
+    }
+
+    [StorableConstructor]
+    public IndividualZeroErrorAnalyzer(bool deserializing) : base(deserializing) { }
+
+    public IndividualZeroErrorAnalyzer(IndividualZeroErrorAnalyzer origin, Cloner cloner) : base(origin, cloner) { }
+
+    public override IDeepCloneable Clone(Cloner cloner) {
+      return new IndividualZeroErrorAnalyzer(this, cloner);
+    }
+
+    public bool EnabledByDefault { get { return true; } }
+
+    public ILookupParameter<DataTable> IndividualZeroErrorParameter
+    {
+      get { return (ILookupParameter<DataTable>)Parameters[INDIVIDUAL_ZERO_ERROR_PARAMETER_NAME]; }
+    }
+
+    public ILookupParameter<ResultCollection> ResultsParameter
+    {
+      get { return (ILookupParameter<ResultCollection>)Parameters[RESULTS_PARAMETER_NAME]; }
+    }
+
+    public ILookupParameter<ItemArray<DoubleArray>> CaseQualitiesParameter
+    {
+      get { return (ILookupParameter<ItemArray<DoubleArray>>)Parameters[PushProblem.CaseQualitiesScopeParameterName]; }
+    }
+
+    public override IOperation Apply() {
+      var caseQualitiesPerIndividual = CaseQualitiesParameter.ActualValue;
+      var caseCount = caseQualitiesPerIndividual[0].Length;
+
+      var results = ResultsParameter.ActualValue;
+      var individualZeroErrorCounts = IndividualZeroErrorParameter.ActualValue;
+
+      if (individualZeroErrorCounts == null) {
+        individualZeroErrorCounts = new DataTable(
+         RESULT_PARAMETER_NAME,
+         RESULT_PARAMETER_DESCRIPTION) {
+          VisualProperties = {
+            YAxisTitle = Y_AXIS_TITLE,
+            XAxisTitle = X_AXIS_TITLE,
+            XAxisMinimumFixedValue = 0,
+            XAxisMaximumFixedValue = caseCount,
+            XAxisMaximumAuto = false,
+            XAxisMinimumAuto = false,
+          }
+        };
+
+        IndividualZeroErrorParameter.ActualValue = individualZeroErrorCounts;
+      }
+
+      if (!results.ContainsKey(RESULT_PARAMETER_NAME)) {
+        results.Add(new Result(RESULT_PARAMETER_NAME, individualZeroErrorCounts));
+      }
+
+      DataRow row;
+      if (!individualZeroErrorCounts.Rows.TryGetValue(ROW_NAME, out row)) {
+        row = new DataRow(ROW_NAME) {
+          VisualProperties = {
+              StartIndexZero = true,
+              IsVisibleInLegend = false,
+              ChartType = DataRowVisualProperties.DataRowChartType.Bars,
+            }
+        };
+
+        individualZeroErrorCounts.Rows.Add(row);
+      }
+
+      var caseCountChanged = row.Values.Count != caseCount;
+
+      if (caseCountChanged) {
+        individualZeroErrorCounts.VisualProperties.XAxisMaximumFixedValue = caseCount;
+        row.Values.Clear();
+      }
+
+      for (var i = 0; i < caseCount; i++) {
+        var count = 0;
+
+        for (var j = 0; j < caseQualitiesPerIndividual.Length; j++) {
+          var caseQuality = caseQualitiesPerIndividual[j][i];
+
+          if (caseQuality == 0.0)
+            count++;
+        }
+
+        if (caseCountChanged)
+          row.Values.Add(count);
+        else
+          row.Values[i] = count;
+      }
+
+      return base.Apply();
+    }
+  }
+}
Index: /branches/PushGP/HeuristicLab.PushGP/HeuristicLab.Problems.ProgramSynthesis/Push/Analyzer/PushExpressionFrequencyAnalyzer.cs
===================================================================
--- /branches/PushGP/HeuristicLab.PushGP/HeuristicLab.Problems.ProgramSynthesis/Push/Analyzer/PushExpressionFrequencyAnalyzer.cs	(revision 15272)
+++ /branches/PushGP/HeuristicLab.PushGP/HeuristicLab.Problems.ProgramSynthesis/Push/Analyzer/PushExpressionFrequencyAnalyzer.cs	(revision 15273)
@@ -12,7 +12,9 @@
   using HeuristicLab.Parameters;
   using HeuristicLab.Persistence.Default.CompositeSerializers.Storable;
+  using HeuristicLab.Problems.ProgramSynthesis.Push.Attributes;
   using HeuristicLab.Problems.ProgramSynthesis.Push.Configuration;
   using HeuristicLab.Problems.ProgramSynthesis.Push.Expressions;
   using HeuristicLab.Problems.ProgramSynthesis.Push.Individual;
+  using HeuristicLab.Problems.ProgramSynthesis.Push.ObjectPools.Random;
 
   /// <summary>
@@ -22,18 +24,24 @@
   [StorableClass]
   public class PushExpressionFrequencyAnalyzer : SingleSuccessorOperator, IPushExpressionAnalyzer {
+    private readonly SeededRandomPool randomPool = new SeededRandomPool();
 
-    private const string PushConfigurationParameterName = "PushConfiguration";
-    private const string IntegerVectorParameterName = "IntegerVector";
-    private const string ResultsParameterName = "Results";
-    private const string ExpressionFrequenciesParameterName = "InstructionFrequencies";
-    private const string AggregateStackTypesParameterName = "Aggregate stack types";
+    private const string PUSH_CONFIGURATION_PARAMETER_NAME = "PushConfiguration";
+    private const string INTEGER_VECTOR_PARAMETER_NAME = "IntegerVector";
+    private const string RESULTS_PARAMETER_NAME = "Results";
+    private const string EXPRESSION_FREQUENCIES_PARAMETER_NAME = "InstructionFrequencies";
+    private const string AGGREGATE_STACK_TYPES_PARAMETER_NAME = "Aggregate stack types";
+    private const string IN_EXPRESSION_GROUP_NAME = "IN";
+    private const string RANDOM_PARAMETER_NAME = "Random";
+    private const string RESULT_PARAMETER_NAME = "Instruction frequencies";
+    private const string RESULT_PARAMETER_DESCRIPTION = "Relative frequency of instructions aggregated over the whole population.";
+    private const string Y_AXIS_TITLE = "Relative Instruction Frequency";
 
     public PushExpressionFrequencyAnalyzer() {
-      Parameters.Add(new LookupParameter<IReadOnlyPushConfiguration>(PushConfigurationParameterName, "The current specified push configuration."));
-      Parameters.Add(new ScopeTreeLookupParameter<IntegerVector>(IntegerVectorParameterName, "The integer vectors to analyze."));
-      Parameters.Add(new LookupParameter<DataTable>(ExpressionFrequenciesParameterName, "The data table to store the instruction frequencies."));
-      Parameters.Add(new LookupParameter<ResultCollection>(ResultsParameterName, "The result collection where the symbol frequencies should be stored."));
+      Parameters.Add(new LookupParameter<IReadOnlyPushConfiguration>(PUSH_CONFIGURATION_PARAMETER_NAME, "The current specified push configuration."));
+      Parameters.Add(new ScopeTreeLookupParameter<IntegerVector>(INTEGER_VECTOR_PARAMETER_NAME, "The integer vectors to analyze."));
+      Parameters.Add(new LookupParameter<DataTable>(EXPRESSION_FREQUENCIES_PARAMETER_NAME, "The data table to store the instruction frequencies."));
+      Parameters.Add(new LookupParameter<ResultCollection>(RESULTS_PARAMETER_NAME, "The result collection where the symbol frequencies should be stored."));
 
-      Parameters.Add(new FixedValueParameter<BoolValue>(AggregateStackTypesParameterName, "Determines if expressions should be aggregated by their primary stack type.", new BoolValue(true)));
+      Parameters.Add(new FixedValueParameter<BoolValue>(AGGREGATE_STACK_TYPES_PARAMETER_NAME, "Determines if expressions should be aggregated by their primary stack type.", new BoolValue(true)));
     }
 
@@ -51,25 +59,30 @@
     public ILookupParameter<IReadOnlyPushConfiguration> PushConfigurationParameter
     {
-      get { return (ILookupParameter<IReadOnlyPushConfiguration>)Parameters[PushConfigurationParameterName]; }
+      get { return (ILookupParameter<IReadOnlyPushConfiguration>)Parameters[PUSH_CONFIGURATION_PARAMETER_NAME]; }
     }
 
     public IScopeTreeLookupParameter<IntegerVector> IntegerVectorParameter
     {
-      get { return (IScopeTreeLookupParameter<IntegerVector>)Parameters[IntegerVectorParameterName]; }
+      get { return (IScopeTreeLookupParameter<IntegerVector>)Parameters[INTEGER_VECTOR_PARAMETER_NAME]; }
     }
 
     public ILookupParameter<DataTable> ExpressionFrequenciesParameter
     {
-      get { return (ILookupParameter<DataTable>)Parameters[ExpressionFrequenciesParameterName]; }
+      get { return (ILookupParameter<DataTable>)Parameters[EXPRESSION_FREQUENCIES_PARAMETER_NAME]; }
+    }
+
+    public ILookupParameter<IRandom> RandomParameter
+    {
+      get { return (ILookupParameter<IRandom>)Parameters[RANDOM_PARAMETER_NAME]; }
     }
 
     public ILookupParameter<ResultCollection> ResultsParameter
     {
-      get { return (ILookupParameter<ResultCollection>)Parameters[ResultsParameterName]; }
+      get { return (ILookupParameter<ResultCollection>)Parameters[RESULTS_PARAMETER_NAME]; }
     }
 
     public IValueParameter<BoolValue> AggregateStackTypesParameter
     {
-      get { return (IValueParameter<BoolValue>)Parameters[AggregateStackTypesParameterName]; }
+      get { return (IValueParameter<BoolValue>)Parameters[AGGREGATE_STACK_TYPES_PARAMETER_NAME]; }
     }
 
@@ -80,9 +93,17 @@
     }
 
-
     public override IOperation Apply() {
       var config = PushConfigurationParameter.ActualValue;
       var integerVectors = IntegerVectorParameter.ActualValue;
-      var pushPrograms = integerVectors.Select(iv => iv.ToPushProgram(config));
+
+      randomPool.Seed = config.Seed;
+
+      var pushPrograms = integerVectors.Select(iv => {
+        var random = randomPool.ResetAndAllocate();
+        var program = iv.ToPushProgram(config, random);
+        randomPool.Free(random);
+
+        return program;
+      });
 
       var results = ResultsParameter.ActualValue;
@@ -91,13 +112,13 @@
       if (frequencies == null) {
         frequencies = new DataTable(
-          "Instruction frequencies",
-          "Relative frequency of instructions aggregated over the whole population.") {
+          RESULT_PARAMETER_NAME,
+          RESULT_PARAMETER_DESCRIPTION) {
           VisualProperties = {
-            YAxisTitle = "Relative Instruction Frequency"
+            YAxisTitle = Y_AXIS_TITLE
           }
         };
 
         ExpressionFrequenciesParameter.ActualValue = frequencies;
-        results.Add(new Result("Instruction frequencies", frequencies));
+        results.Add(new Result(RESULT_PARAMETER_NAME, frequencies));
       }
 
@@ -110,7 +131,5 @@
 
       var expressionFrequencies = allExpressions
-        .GroupBy(x => AggregateStackTypes
-          ? x.Attribute.StackType.ToString()
-          : x.Attribute.Name)
+        .GroupBy(x => GetGroupName(x.Attribute, AggregateStackTypes))
         .ToDictionary(
           group => group.Key,
@@ -126,5 +145,5 @@
           var row = new DataRow(pair.Key, string.Empty, Enumerable.Repeat(0.0, numberOfValues)) {
             VisualProperties = {
-              StartIndexZero = true
+              StartIndexZero = true,
             }
           };
@@ -142,4 +161,14 @@
       return base.Apply();
     }
+
+    private string GetGroupName(PushExpressionAttribute attribute, bool aggregateStackTypes) {
+      if (aggregateStackTypes) {
+        return attribute.IsInExpression
+         ? IN_EXPRESSION_GROUP_NAME
+         : attribute.StackType.ToString();
+      }
+
+      return attribute.Name;
+    }
   }
 }
Index: /branches/PushGP/HeuristicLab.PushGP/HeuristicLab.Problems.ProgramSynthesis/Push/Attributes/PushExpressionAttriubte.cs
===================================================================
--- /branches/PushGP/HeuristicLab.PushGP/HeuristicLab.Problems.ProgramSynthesis/Push/Attributes/PushExpressionAttriubte.cs	(revision 15272)
+++ /branches/PushGP/HeuristicLab.PushGP/HeuristicLab.Problems.ProgramSynthesis/Push/Attributes/PushExpressionAttriubte.cs	(revision 15273)
@@ -10,4 +10,5 @@
     public readonly string Name;
     public readonly string Description;
+    public readonly int? InExpressionNr;
 
     /// <summary>
@@ -32,5 +33,6 @@
       StackTypes additionalStackDependencies = default(StackTypes),
       uint execIn = 0,
-      bool isHidden = false) {
+      bool isHidden = false,
+      int inExpressionNr = -1) {
 
       StackType = stackType;
@@ -40,6 +42,9 @@
       ExecIn = execIn;
       IsHidden = isHidden;
+      InExpressionNr = inExpressionNr > 0 ? inExpressionNr : default(int?);
       ManipulatesExec = stackType == StackTypes.Exec || AdditionalStackDependencies.HasFlag(StackTypes.Exec);
     }
+
+    public bool IsInExpression { get { return this.InExpressionNr.HasValue; } }
   }
 }
Index: /branches/PushGP/HeuristicLab.PushGP/HeuristicLab.Problems.ProgramSynthesis/Push/Configuration/IEnabledExpressionsConfiguration.cs
===================================================================
--- /branches/PushGP/HeuristicLab.PushGP/HeuristicLab.Problems.ProgramSynthesis/Push/Configuration/IEnabledExpressionsConfiguration.cs	(revision 15272)
+++ /branches/PushGP/HeuristicLab.PushGP/HeuristicLab.Problems.ProgramSynthesis/Push/Configuration/IEnabledExpressionsConfiguration.cs	(revision 15273)
@@ -17,11 +17,16 @@
   }
 
-  public interface IEnabledExpressionsConfiguration : INamedItem {
+  public interface IReadOnlyExpressionsConfiguration : INamedItem {
+    int InExpressionCount { get; }
+
+    IReadOnlyList<string> EnabledExpressions { get; }
+    IReadOnlyDictionary<StackTypes, int> ExpressionsPerStackCount { get; }
+  }
+
+  public interface IExpressionsConfiguration : IReadOnlyExpressionsConfiguration {
     event EventHandler<EnabledExpressionsChangedEventArgs> EnabledExpressionsChanged;
 
-    IReadOnlyList<string> EnabledExpressions { get; }
-
     void EnableStack(StackTypes types, bool enableDependencies = false);
-    void DisableStack(StackTypes type, bool enableDepenencies = false);
+    void DisableStack(StackTypes type, bool enableDependencies = false);
     void SetStack(StackTypes type, bool state, bool setDependencies = false);
     void EnableExpressionOfStack(StackTypes types);
Index: /branches/PushGP/HeuristicLab.PushGP/HeuristicLab.Problems.ProgramSynthesis/Push/Configuration/IReadonlyPushConfiguration.cs
===================================================================
--- /branches/PushGP/HeuristicLab.PushGP/HeuristicLab.Problems.ProgramSynthesis/Push/Configuration/IReadonlyPushConfiguration.cs	(revision 15272)
+++ /branches/PushGP/HeuristicLab.PushGP/HeuristicLab.Problems.ProgramSynthesis/Push/Configuration/IReadonlyPushConfiguration.cs	(revision 15273)
@@ -2,11 +2,9 @@
   using System.Collections.Generic;
   using Base.Erc;
-  using Common;
-
-  using HeuristicLab.Core;
 
   using Stack;
 
-  public interface IReadOnlyPushConfiguration : IItem {
+  public interface IReadOnlyPushConfiguration : IReadOnlyExpressionsConfiguration {
+    int Seed { get; }
     int EvalPushLimit { get; }
     int MaxDepth { get; }
Index: /branches/PushGP/HeuristicLab.PushGP/HeuristicLab.Problems.ProgramSynthesis/Push/Configuration/PushConfigurationBase.cs
===================================================================
--- /branches/PushGP/HeuristicLab.PushGP/HeuristicLab.Problems.ProgramSynthesis/Push/Configuration/PushConfigurationBase.cs	(revision 15272)
+++ /branches/PushGP/HeuristicLab.PushGP/HeuristicLab.Problems.ProgramSynthesis/Push/Configuration/PushConfigurationBase.cs	(revision 15273)
@@ -12,5 +12,5 @@
 
   [StorableClass]
-  public abstract class PushConfigurationBase : NamedItem, IEnabledExpressionsConfiguration {
+  public abstract class PushConfigurationBase : NamedItem, IExpressionsConfiguration {
 
     protected PushConfigurationBase() {
@@ -28,8 +28,18 @@
       enabledExpressions = origin.EnabledExpressions.ToList();
       expressionsPerStackCount = origin.expressionsPerStackCount.ToDictionary(x => x.Key, x => x.Value);
-    }
+      InExpressionCount = origin.InExpressionCount;
+      Seed = origin.Seed;
+    }
+
+    [Storable]
+    public int Seed { get; set; }
+
+    [Storable]
+    public int InExpressionCount { get; private set; }
 
     [Storable]
     private readonly Dictionary<StackTypes, int> expressionsPerStackCount;
+
+    public IReadOnlyDictionary<StackTypes, int> ExpressionsPerStackCount { get { return expressionsPerStackCount; } }
 
     public event EventHandler<EnabledExpressionsChangedEventArgs> EnabledExpressionsChanged;
@@ -112,9 +122,11 @@
 
     private void EnableExpressions(IEnumerable<string> expressionNames) {
-      foreach (var expressionName in expressionNames.Except(EnabledExpressions))
+      var addedExpressions = expressionNames as IList<string> ?? expressionNames.ToList();
+
+      foreach (var expressionName in addedExpressions.Except(EnabledExpressions))
         EnableExpression(expressionName, false);
 
       if (EnabledExpressionsChanged != null) {
-        EnabledExpressionsChanged(this, new EnabledExpressionsChangedEventArgs(expressionNames, new string[0]));
+        EnabledExpressionsChanged(this, new EnabledExpressionsChangedEventArgs(addedExpressions, new string[0]));
       }
     }
@@ -133,9 +145,11 @@
 
     private void DisableExpressions(IEnumerable<string> expressionNames) {
-      foreach (var expressionName in expressionNames.Intersect(EnabledExpressions))
+      var removedExpressions = expressionNames as IList<string> ?? expressionNames.ToList();
+
+      foreach (var expressionName in removedExpressions.Intersect(EnabledExpressions))
         DisableExpression(expressionName, false);
 
       if (EnabledExpressionsChanged != null) {
-        EnabledExpressionsChanged(this, new EnabledExpressionsChangedEventArgs(new string[0], expressionNames));
+        EnabledExpressionsChanged(this, new EnabledExpressionsChangedEventArgs(new string[0], removedExpressions));
       }
     }
@@ -229,4 +243,25 @@
       else DisableStack(type, setDependencies);
     }
+
+    public void InitInExpressions(int totalInputArgumentCount) {
+      InExpressionCount = totalInputArgumentCount;
+
+      for (var i = 0; i < ExpressionTable.InExpressionTable.Count; i++) {
+        var expression = ExpressionTable.InExpressionTable[i];
+        var expressionName = ExpressionTable.TypeToNameTable[expression.GetType()];
+
+        DisableExpression(expressionName);
+      }
+
+      if (totalInputArgumentCount > ExpressionTable.InExpressionTable.Count)
+        throw new InvalidOperationException("More input arguments defined as InExpression types");
+
+      for (var i = 0; i < totalInputArgumentCount; i++) {
+        var expression = ExpressionTable.InExpressionTable[i];
+        var expressionName = ExpressionTable.TypeToNameTable[expression.GetType()];
+
+        EnableExpression(expressionName);
+      }
+    }
   }
 }
Index: /branches/PushGP/HeuristicLab.PushGP/HeuristicLab.Problems.ProgramSynthesis/Push/Configuration/PushConfigurationParameterCollection.cs
===================================================================
--- /branches/PushGP/HeuristicLab.PushGP/HeuristicLab.Problems.ProgramSynthesis/Push/Configuration/PushConfigurationParameterCollection.cs	(revision 15272)
+++ /branches/PushGP/HeuristicLab.PushGP/HeuristicLab.Problems.ProgramSynthesis/Push/Configuration/PushConfigurationParameterCollection.cs	(revision 15273)
@@ -11,24 +11,24 @@
   [StorableClass]
   public class PushConfigurationParameterCollection : PushConfigurationBase, IReadOnlyPushConfiguration {
-    private const string InstructionsParameterName = "Instructions";
-    private const string InstructionsParameterDescription = "Enables/Disables Instructions";
-    private const string EvalPushLimitParameterName = "EvalPushLimit";
-    private const string EvalPushLimitParameterDescription = "This is the maximum allowed number of \"executions\" in a single top-level call to the interpreter. The execution of a single Push instruction counts as one execution, as does the processing of a single literal, as does the descent into one layer of parentheses (that is, the processing of the \"(\" counts as one execution).";
-    private const string MaxPointsInProgramParameterName = "MaxProgramLength";
-    private const string MaxProgramLengthParameterDescription = "This is the maximum size of an item on the CODE/EXEC stack, expressed as a number of points. A point is an instruction, a literal, or a pair of parentheses.";
-    private const string TopLevelPushCodeParameterName = "TopLevelPushCode";
-    private const string TopLevelPushCodeParameterDescription = "When TRUE (which is the default), code passed to the top level of the interpreter will be pushed onto the CODE stack prior to execution.";
-    private const string TopLevelPopCodeParameterName = "TopLevelPopCode";
-    private const string TopLevelPopCodeParameterDescription = "When TRUE, the CODE stack will be popped at the end of top level calls to the interpreter. The default is FALSE.";
-    private const string MaxPointsInRandomInstructionParameterName = "MaxPointsInRandomInstruction";
-    private const string MaxPointsInRandomInstructionParameterDescription = "MaxPointsInRandomInstruction";
-    private const string ErcOptionsParameterName = "ERC options";
-    private const string MaxStringLengthParameterName = "Max. string length";
-    private const string MaxDepthParameterName = "Max. program recursion";
-    private const string MaxParenthesesCloseParameterName = "Max. parentheses close";
-    private const string MaxParenthesesCloseParameterDescription = "Specifies how many sub programs are closed if open during the recursive translation of an individual to a push program. Value is exclusive.";
-    private const string ParenthesesCloseBiasLevelParameterName = "Parentheses close bias level";
-    private const string ParenthesesCloseBiasLevelParameterDescription = "Specifies how strong a random value between 0 .. 'Max. parentheses close' is biased towards 0. In other words, this parameter controls the length of sub programs.";
-    private const string MaxVectorLengthParameterName = "Max. vector length";
+    private const string INSTRUCTIONS_PARAMETER_NAME = "Instructions";
+    private const string INSTRUCTIONS_PARAMETER_DESCRIPTION = "Enables/Disables Instructions";
+    private const string EVAL_PUSH_LIMIT_PARAMETER_NAME = "EvalPushLimit";
+    private const string EVAL_PUSH_LIMIT_PARAMETER_DESCRIPTION = "This is the maximum allowed number of \"executions\" in a single top-level call to the interpreter. The execution of a single Push instruction counts as one execution, as does the processing of a single literal, as does the descent into one layer of parentheses (that is, the processing of the \"(\" counts as one execution).";
+    private const string MAX_POINTS_IN_PROGRAM_PARAMETER_NAME = "MaxProgramLength";
+    private const string MAX_PROGRAM_LENGTH_PARAMETER_DESCRIPTION = "This is the maximum size of an item on the CODE/EXEC stack, expressed as a number of points. A point is an instruction, a literal, or a pair of parentheses.";
+    private const string TOP_LEVEL_PUSH_CODE_PARAMETER_NAME = "TopLevelPushCode";
+    private const string TOP_LEVEL_PUSH_CODE_PARAMETER_DESCRIPTION = "When TRUE (which is the default), code passed to the top level of the interpreter will be pushed onto the CODE stack prior to execution.";
+    private const string TOP_LEVEL_POP_CODE_PARAMETER_NAME = "TopLevelPopCode";
+    private const string TOP_LEVEL_POP_CODE_PARAMETER_DESCRIPTION = "When TRUE, the CODE stack will be popped at the end of top level calls to the interpreter. The default is FALSE.";
+    private const string MAX_POINTS_IN_RANDOM_INSTRUCTION_PARAMETER_NAME = "MaxPointsInRandomInstruction";
+    private const string MAX_POINTS_IN_RANDOM_INSTRUCTION_PARAMETER_DESCRIPTION = "MaxPointsInRandomInstruction";
+    private const string ERC_OPTIONS_PARAMETER_NAME = "ERC options";
+    private const string MAX_STRING_LENGTH_PARAMETER_NAME = "Max. string length";
+    private const string MAX_DEPTH_PARAMETER_NAME = "Max. program recursion";
+    private const string MAX_PARENTHESES_CLOSE_PARAMETER_NAME = "Max. parentheses close";
+    private const string MAX_PARENTHESES_CLOSE_PARAMETER_DESCRIPTION = "Specifies how many sub programs are closed if open during the recursive translation of an individual to a push program. Value is exclusive.";
+    private const string PARENTHESES_CLOSE_BIAS_LEVEL_PARAMETER_NAME = "Parentheses close bias level";
+    private const string PARENTHESES_CLOSE_BIAS_LEVEL_PARAMETER_DESCRIPTION = "Specifies how strong a random value between 0 .. 'Max. parentheses close' is biased towards 0. In other words, this parameter controls the length of sub programs.";
+    private const string MAX_VECTOR_LENGTH_PARAMETER_NAME = "Max. vector length";
 
     public PushConfigurationParameterCollection() {
@@ -62,77 +62,77 @@
 
     private void InitParameters() {
-      if (!Parameters.ContainsKey(InstructionsParameterName))
-        Parameters.Add(new ValueParameter<IEnabledExpressionsConfiguration>(
-          InstructionsParameterName,
-          InstructionsParameterDescription,
+      if (!Parameters.ContainsKey(INSTRUCTIONS_PARAMETER_NAME))
+        Parameters.Add(new ValueParameter<IExpressionsConfiguration>(
+          INSTRUCTIONS_PARAMETER_NAME,
+          INSTRUCTIONS_PARAMETER_DESCRIPTION,
           this));
 
-      if (!Parameters.ContainsKey(ErcOptionsParameterName))
-        Parameters.Add(new ValueParameter<ErcOptions>(ErcOptionsParameterName));
-
-      if (!Parameters.ContainsKey(MaxVectorLengthParameterName))
-        Parameters.Add(new FixedValueParameter<IntValue>(
-          MaxVectorLengthParameterName,
+      if (!Parameters.ContainsKey(ERC_OPTIONS_PARAMETER_NAME))
+        Parameters.Add(new ValueParameter<ErcOptions>(ERC_OPTIONS_PARAMETER_NAME));
+
+      if (!Parameters.ContainsKey(MAX_VECTOR_LENGTH_PARAMETER_NAME))
+        Parameters.Add(new FixedValueParameter<IntValue>(
+          MAX_VECTOR_LENGTH_PARAMETER_NAME,
           new IntValue(500)) { Hidden = true });
 
-      if (!Parameters.ContainsKey(EvalPushLimitParameterName))
-        Parameters.Add(new FixedValueParameter<IntValue>(
-          EvalPushLimitParameterName,
-          EvalPushLimitParameterDescription,
+      if (!Parameters.ContainsKey(EVAL_PUSH_LIMIT_PARAMETER_NAME))
+        Parameters.Add(new FixedValueParameter<IntValue>(
+          EVAL_PUSH_LIMIT_PARAMETER_NAME,
+          EVAL_PUSH_LIMIT_PARAMETER_DESCRIPTION,
           new IntValue(1000)));
 
-      if (!Parameters.ContainsKey(MaxPointsInProgramParameterName))
-        Parameters.Add(new FixedValueParameter<IntValue>(
-          MaxPointsInProgramParameterName,
-          MaxProgramLengthParameterDescription,
+      if (!Parameters.ContainsKey(MAX_POINTS_IN_PROGRAM_PARAMETER_NAME))
+        Parameters.Add(new FixedValueParameter<IntValue>(
+          MAX_POINTS_IN_PROGRAM_PARAMETER_NAME,
+          MAX_PROGRAM_LENGTH_PARAMETER_DESCRIPTION,
           new IntValue(200)));
 
-      if (!Parameters.ContainsKey(MaxParenthesesCloseParameterName))
-        Parameters.Add(new FixedValueParameter<IntValue>(
-          MaxParenthesesCloseParameterName,
-          MaxParenthesesCloseParameterDescription,
+      if (!Parameters.ContainsKey(MAX_PARENTHESES_CLOSE_PARAMETER_NAME))
+        Parameters.Add(new FixedValueParameter<IntValue>(
+          MAX_PARENTHESES_CLOSE_PARAMETER_NAME,
+          MAX_PARENTHESES_CLOSE_PARAMETER_DESCRIPTION,
           new IntValue(4)) { Hidden = true });
 
-      if (!Parameters.ContainsKey(ParenthesesCloseBiasLevelParameterName))
+      if (!Parameters.ContainsKey(PARENTHESES_CLOSE_BIAS_LEVEL_PARAMETER_NAME))
         Parameters.Add(new FixedValueParameter<DoubleValue>(
-          ParenthesesCloseBiasLevelParameterName,
-          ParenthesesCloseBiasLevelParameterDescription,
+          PARENTHESES_CLOSE_BIAS_LEVEL_PARAMETER_NAME,
+          PARENTHESES_CLOSE_BIAS_LEVEL_PARAMETER_DESCRIPTION,
           new DoubleValue(4)) { Hidden = true });
 
-      if (!Parameters.ContainsKey(TopLevelPushCodeParameterName))
+      if (!Parameters.ContainsKey(TOP_LEVEL_PUSH_CODE_PARAMETER_NAME))
         Parameters.Add(new FixedValueParameter<BoolValue>(
-          TopLevelPushCodeParameterName,
-          TopLevelPushCodeParameterDescription,
+          TOP_LEVEL_PUSH_CODE_PARAMETER_NAME,
+          TOP_LEVEL_PUSH_CODE_PARAMETER_DESCRIPTION,
           new BoolValue(true)) { Hidden = true });
 
-      if (!Parameters.ContainsKey(TopLevelPopCodeParameterName))
+      if (!Parameters.ContainsKey(TOP_LEVEL_POP_CODE_PARAMETER_NAME))
         Parameters.Add(new FixedValueParameter<BoolValue>(
-          TopLevelPopCodeParameterName,
-          TopLevelPopCodeParameterDescription,
+          TOP_LEVEL_POP_CODE_PARAMETER_NAME,
+          TOP_LEVEL_POP_CODE_PARAMETER_DESCRIPTION,
           new BoolValue(false)) { Hidden = true });
 
-      if (!Parameters.ContainsKey(MaxPointsInRandomInstructionParameterName))
-        Parameters.Add(new FixedValueParameter<IntValue>(
-          MaxPointsInRandomInstructionParameterName,
-          MaxPointsInRandomInstructionParameterDescription,
+      if (!Parameters.ContainsKey(MAX_POINTS_IN_RANDOM_INSTRUCTION_PARAMETER_NAME))
+        Parameters.Add(new FixedValueParameter<IntValue>(
+          MAX_POINTS_IN_RANDOM_INSTRUCTION_PARAMETER_NAME,
+          MAX_POINTS_IN_RANDOM_INSTRUCTION_PARAMETER_DESCRIPTION,
           new IntValue(50)) { Hidden = true });
 
-      if (!Parameters.ContainsKey(MaxStringLengthParameterName))
-        Parameters.Add(new FixedValueParameter<IntValue>(
-          MaxStringLengthParameterName,
+      if (!Parameters.ContainsKey(MAX_STRING_LENGTH_PARAMETER_NAME))
+        Parameters.Add(new FixedValueParameter<IntValue>(
+          MAX_STRING_LENGTH_PARAMETER_NAME,
           new IntValue(1000)) { Hidden = true });
 
-      if (!Parameters.ContainsKey(MaxDepthParameterName))
-        Parameters.Add(new FixedValueParameter<IntValue>(
-          MaxDepthParameterName,
+      if (!Parameters.ContainsKey(MAX_DEPTH_PARAMETER_NAME))
+        Parameters.Add(new FixedValueParameter<IntValue>(
+          MAX_DEPTH_PARAMETER_NAME,
           new IntValue(1000)) { Hidden = true });
     }
 
-    public IValueParameter<IEnabledExpressionsConfiguration> InstructionsParameter
-    {
-      get { return (IValueParameter<IEnabledExpressionsConfiguration>)Parameters[InstructionsParameterName]; }
-    }
-
-    public IEnabledExpressionsConfiguration Instructions
+    public IValueParameter<IExpressionsConfiguration> InstructionsParameter
+    {
+      get { return (IValueParameter<IExpressionsConfiguration>)Parameters[INSTRUCTIONS_PARAMETER_NAME]; }
+    }
+
+    public IExpressionsConfiguration Instructions
     {
       get { return InstructionsParameter.Value; }
@@ -142,5 +142,5 @@
     public IValueParameter<ErcOptions> ErcOptionsParameter
     {
-      get { return (IValueParameter<ErcOptions>)Parameters[ErcOptionsParameterName]; }
+      get { return (IValueParameter<ErcOptions>)Parameters[ERC_OPTIONS_PARAMETER_NAME]; }
     }
 
@@ -181,5 +181,5 @@
     public IValueParameter<IntValue> EvalPushLimitParameter
     {
-      get { return (IValueParameter<IntValue>)Parameters[EvalPushLimitParameterName]; }
+      get { return (IValueParameter<IntValue>)Parameters[EVAL_PUSH_LIMIT_PARAMETER_NAME]; }
     }
 
@@ -198,5 +198,5 @@
     public IValueParameter<DoubleValue> ParenthesesCloseBiasLevelParameter
     {
-      get { return (IValueParameter<DoubleValue>)Parameters[ParenthesesCloseBiasLevelParameterName]; }
+      get { return (IValueParameter<DoubleValue>)Parameters[PARENTHESES_CLOSE_BIAS_LEVEL_PARAMETER_NAME]; }
     }
 
@@ -212,5 +212,5 @@
     public IValueParameter<IntValue> MaxParenthesesCloseParameter
     {
-      get { return (IValueParameter<IntValue>)Parameters[MaxParenthesesCloseParameterName]; }
+      get { return (IValueParameter<IntValue>)Parameters[MAX_PARENTHESES_CLOSE_PARAMETER_NAME]; }
     }
 
@@ -229,5 +229,5 @@
     public IValueParameter<IntValue> MaxDepthParameter
     {
-      get { return (IValueParameter<IntValue>)Parameters[MaxDepthParameterName]; }
+      get { return (IValueParameter<IntValue>)Parameters[MAX_DEPTH_PARAMETER_NAME]; }
     }
 
@@ -249,5 +249,5 @@
     public IValueParameter<IntValue> MaxPointsInProgramParameter
     {
-      get { return (IValueParameter<IntValue>)Parameters[MaxPointsInProgramParameterName]; }
+      get { return (IValueParameter<IntValue>)Parameters[MAX_POINTS_IN_PROGRAM_PARAMETER_NAME]; }
     }
 
@@ -263,5 +263,5 @@
     public IValueParameter<IntValue> MaxVectorLengthParameter
     {
-      get { return (IValueParameter<IntValue>)Parameters[MaxVectorLengthParameterName]; }
+      get { return (IValueParameter<IntValue>)Parameters[MAX_VECTOR_LENGTH_PARAMETER_NAME]; }
     }
 
@@ -277,5 +277,5 @@
     public IValueParameter<IntValue> MaxPointsInRandomExpressionParameter
     {
-      get { return (IValueParameter<IntValue>)Parameters[MaxPointsInRandomInstructionParameterName]; }
+      get { return (IValueParameter<IntValue>)Parameters[MAX_POINTS_IN_RANDOM_INSTRUCTION_PARAMETER_NAME]; }
     }
 
@@ -295,5 +295,5 @@
     public IValueParameter<BoolValue> TopLevelPushCodeParameter
     {
-      get { return (IValueParameter<BoolValue>)Parameters[TopLevelPushCodeParameterName]; }
+      get { return (IValueParameter<BoolValue>)Parameters[TOP_LEVEL_PUSH_CODE_PARAMETER_NAME]; }
     }
 
@@ -312,5 +312,5 @@
     public IValueParameter<BoolValue> TopLevelPopCodeParameter
     {
-      get { return (IValueParameter<BoolValue>)Parameters[TopLevelPopCodeParameterName]; }
+      get { return (IValueParameter<BoolValue>)Parameters[TOP_LEVEL_POP_CODE_PARAMETER_NAME]; }
     }
 
@@ -326,5 +326,5 @@
     public IValueParameter<IntValue> MaxStringLengthParameter
     {
-      get { return (IValueParameter<IntValue>)Parameters[MaxStringLengthParameterName]; }
+      get { return (IValueParameter<IntValue>)Parameters[MAX_STRING_LENGTH_PARAMETER_NAME]; }
     }
 
Index: anches/PushGP/HeuristicLab.PushGP/HeuristicLab.Problems.ProgramSynthesis/Push/Constants/Environment.cs
===================================================================
--- /branches/PushGP/HeuristicLab.PushGP/HeuristicLab.Problems.ProgramSynthesis/Push/Constants/Environment.cs	(revision 15272)
+++ 	(revision )
@@ -1,21 +1,0 @@
-﻿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/Encoding/IPlushOperator.cs
===================================================================
--- /branches/PushGP/HeuristicLab.PushGP/HeuristicLab.Problems.ProgramSynthesis/Push/Encoding/IPlushOperator.cs	(revision 15273)
+++ /branches/PushGP/HeuristicLab.PushGP/HeuristicLab.Problems.ProgramSynthesis/Push/Encoding/IPlushOperator.cs	(revision 15273)
@@ -0,0 +1,7 @@
+﻿namespace HeuristicLab.Problems.ProgramSynthesis.Push.Encoding {
+  using HeuristicLab.Core;
+
+  public interface IPlushOperator : IOperator {
+
+  }
+}
Index: /branches/PushGP/HeuristicLab.PushGP/HeuristicLab.Problems.ProgramSynthesis/Push/Encoding/PlushEncoding.cs
===================================================================
--- /branches/PushGP/HeuristicLab.PushGP/HeuristicLab.Problems.ProgramSynthesis/Push/Encoding/PlushEncoding.cs	(revision 15273)
+++ /branches/PushGP/HeuristicLab.PushGP/HeuristicLab.Problems.ProgramSynthesis/Push/Encoding/PlushEncoding.cs	(revision 15273)
@@ -0,0 +1,47 @@
+﻿using System.Collections.Generic;
+
+namespace HeuristicLab.Problems.ProgramSynthesis.Push.Encoding {
+
+  using HeuristicLab.Common;
+  using HeuristicLab.Core;
+  using HeuristicLab.Optimization;
+  using HeuristicLab.Persistence.Default.CompositeSerializers.Storable;
+  using HeuristicLab.Problems.ProgramSynthesis.Push.SolutionCreator;
+
+  [Item("PlushEncoding", "Describes an linear push (Plush) encoding.")]
+  [StorableClass]
+  public class PlushEncoding : Encoding<IPlushCreator> {
+    public PlushEncoding(bool deserializing)
+      : base(deserializing) {
+    }
+
+    public PlushEncoding(Encoding<IPlushCreator> original, Cloner cloner)
+      : base(original, cloner) {
+    }
+
+    public PlushEncoding(string name)
+      : base(name) {
+    }
+
+    public override IDeepCloneable Clone(Cloner cloner) {
+      return new PlushEncoding(this, cloner);
+    }
+
+    public override void ConfigureOperators(IEnumerable<IOperator> operators) {
+      //ConfigureBoundedOperators(operators.OfType<IBoundedIntegerVectorOperator>());
+      //ConfigureCreators(operators.OfType<IPlushCreator>());
+      //ConfigureCrossovers(operators.OfType<IIntegerVectorCrossover>());
+      //ConfigureManipulators(operators.OfType<IIntegerVectorManipulator>());
+      //ConfigureShakingOperators(operators.OfType<IIntegerVectorMultiNeighborhoodShakingOperator>());
+      //ConfigureStrategyVectorOperator(operators.OfType<IIntegerVectorStdDevStrategyParameterOperator>());
+    }
+
+    //private void ConfigureCreators(IEnumerable<IPlushCreator> creators) {
+    //  foreach (var creator in creators) {
+    //    creator.IntegerVectorParameter.ActualName = Name;
+    //    creator.BoundsParameter.ActualName = BoundsParameter.Name;
+    //    creator.LengthParameter.ActualName = LengthParameter.Name;
+    //  }
+    //}
+  }
+}
Index: /branches/PushGP/HeuristicLab.PushGP/HeuristicLab.Problems.ProgramSynthesis/Push/Encoding/PlushEntry.cs
===================================================================
--- /branches/PushGP/HeuristicLab.PushGP/HeuristicLab.Problems.ProgramSynthesis/Push/Encoding/PlushEntry.cs	(revision 15273)
+++ /branches/PushGP/HeuristicLab.PushGP/HeuristicLab.Problems.ProgramSynthesis/Push/Encoding/PlushEntry.cs	(revision 15273)
@@ -0,0 +1,8 @@
+﻿namespace HeuristicLab.Problems.ProgramSynthesis.Push.Encoding {
+  using HeuristicLab.Problems.ProgramSynthesis.Push.Expressions;
+
+  public class PlushEntry {
+    public Expression Instruction { get; set; }
+    public int Close { get; set; }
+  }
+}
Index: /branches/PushGP/HeuristicLab.PushGP/HeuristicLab.Problems.ProgramSynthesis/Push/Encoding/PlushVector.cs
===================================================================
--- /branches/PushGP/HeuristicLab.PushGP/HeuristicLab.Problems.ProgramSynthesis/Push/Encoding/PlushVector.cs	(revision 15273)
+++ /branches/PushGP/HeuristicLab.PushGP/HeuristicLab.Problems.ProgramSynthesis/Push/Encoding/PlushVector.cs	(revision 15273)
@@ -0,0 +1,32 @@
+﻿namespace HeuristicLab.Problems.ProgramSynthesis.Push.Encoding {
+  using System.Collections.Generic;
+
+  using HeuristicLab.Common;
+  using HeuristicLab.Core;
+  using HeuristicLab.Persistence.Default.CompositeSerializers.Storable;
+
+  [StorableClass]
+  public class PlushVector : Item {
+
+    private List<PlushEntry> entries;
+
+    public PlushVector() : this(0) {
+
+    }
+
+    public PlushVector(int length) {
+      entries = new List<PlushEntry>(length);
+    }
+
+    [StorableConstructor]
+    public PlushVector(bool deserializing) : base(deserializing) {
+    }
+
+    public PlushVector(PlushVector origin, Cloner cloner) : base(origin, cloner) {
+    }
+
+    public override IDeepCloneable Clone(Cloner cloner) {
+      return new PlushVector(this, cloner);
+    }
+  }
+}
Index: /branches/PushGP/HeuristicLab.PushGP/HeuristicLab.Problems.ProgramSynthesis/Push/Expressions/ExpressionTable.cs
===================================================================
--- /branches/PushGP/HeuristicLab.PushGP/HeuristicLab.Problems.ProgramSynthesis/Push/Expressions/ExpressionTable.cs	(revision 15272)
+++ /branches/PushGP/HeuristicLab.PushGP/HeuristicLab.Problems.ProgramSynthesis/Push/Expressions/ExpressionTable.cs	(revision 15273)
@@ -20,4 +20,5 @@
     private static readonly Dictionary<StackTypes, IList<string>> stackDependencyToNamesTable = new Dictionary<StackTypes, IList<string>>();
     private static readonly Dictionary<Type, PushExpressionAttribute> typeToAttributeTable = new Dictionary<Type, PushExpressionAttribute>();
+    private static readonly List<Expression> inExpressionTable = new List<Expression>();
 
     public static readonly IReadOnlyList<Type> StatelessExpressionTypes;
@@ -43,4 +44,5 @@
     public static IReadOnlyDictionary<Type, string> TypeToNameTable { get { return typeToNameTable; } }
     public static IReadOnlyDictionary<string, Type> NameToTypeTable { get { return nameToTypeTable; } }
+    public static IReadOnlyList<Expression> InExpressionTable { get { return inExpressionTable; } }
     public static IReadOnlyDictionary<StackTypes, IList<string>> StackTypeToNamesTable { get { return stackTypeToNamesTable; } }
     public static IReadOnlyDictionary<StackTypes, IList<string>> StackDependencyToNamesTable { get { return stackDependencyToNamesTable; } }
@@ -57,10 +59,13 @@
         dictionary.Add(type, expression);
 
-        //// do not index hidden expressions like push expression in tables
-        //if (attribute.IsHidden) continue;
-
         indexToNameTable.Add(indexToNameTable.Keys.Count, attribute.Name);
         typeToNameTable.Add(type, attribute.Name);
         nameToTypeTable.Add(attribute.Name, type);
+
+        if (attribute.IsInExpression) {
+          // ReSharper disable once AssignNullToNotNullAttribute
+          // ReSharper disable once PossibleInvalidOperationException
+          inExpressionTable.Insert(attribute.InExpressionNr.Value - 1, expression);
+        }
 
         if (!stackTypeToNamesTable.ContainsKey(attribute.StackType)) {
Index: /branches/PushGP/HeuristicLab.PushGP/HeuristicLab.Problems.ProgramSynthesis/Push/Expressions/InExpressions.cs
===================================================================
--- /branches/PushGP/HeuristicLab.PushGP/HeuristicLab.Problems.ProgramSynthesis/Push/Expressions/InExpressions.cs	(revision 15272)
+++ /branches/PushGP/HeuristicLab.PushGP/HeuristicLab.Problems.ProgramSynthesis/Push/Expressions/InExpressions.cs	(revision 15273)
@@ -13,5 +13,5 @@
 
     protected InExpression(int nr) {
-      this.index = nr - 1;
+      index = nr - 1;
     }
 
@@ -20,11 +20,13 @@
 
     public override bool IsNoop(IInternalPushInterpreter interpreter) {
-      return false;
+      var expression = interpreter.InputExpressions[index];
+
+      return expression.IsNoop(interpreter);
     }
 
     public override void Eval(IInternalPushInterpreter interpreter) {
-      var inputArgument = interpreter.InputExpressions[index];
+      var expression = interpreter.InputExpressions[index];
 
-      inputArgument.Eval(interpreter);
+      expression.Eval(interpreter);
     }
   }
@@ -34,5 +36,6 @@
     "IN1",
     "Pushes first input parameter.",
-    isHidden: true)]
+    isHidden: true,
+    inExpressionNr: 1)]
   [StorableClass]
   public class In1Expression : InExpression {
@@ -47,5 +50,6 @@
     "IN2",
     "Pushes second input parameter.",
-    isHidden: true)]
+    isHidden: true,
+    inExpressionNr: 2)]
   [StorableClass]
   public class In2Expression : InExpression {
@@ -60,5 +64,6 @@
    "IN3",
    "Pushes third input parameter.",
-    isHidden: true)]
+    isHidden: true,
+    inExpressionNr: 3)]
   [StorableClass]
   public class In3Expression : InExpression {
@@ -73,5 +78,6 @@
     "IN4",
     "Pushes fourth input parameter.",
-    isHidden: true)]
+    isHidden: true,
+    inExpressionNr: 4)]
   [StorableClass]
   public class In4Expression : InExpression {
@@ -86,5 +92,6 @@
     "IN5",
     "Pushes fifth input parameter.",
-    isHidden: true)]
+    isHidden: true,
+    inExpressionNr: 5)]
   [StorableClass]
   public class In5Expression : InExpression {
@@ -99,5 +106,6 @@
     "IN6",
     "Pushes sixth input parameter.",
-    isHidden: true)]
+    isHidden: true,
+    inExpressionNr: 6)]
   [StorableClass]
   public class In6Expression : InExpression {
@@ -112,5 +120,6 @@
     "IN7",
     "Pushes seventh input parameter.",
-    isHidden: true)]
+    isHidden: true,
+    inExpressionNr: 7)]
   [StorableClass]
   public class In7Expression : InExpression {
@@ -125,5 +134,6 @@
     "IN8",
     "Pushes eighth input parameter.",
-    isHidden: true)]
+    isHidden: true,
+    inExpressionNr: 8)]
   [StorableClass]
   public class In8Expression : InExpression {
@@ -138,5 +148,6 @@
     "IN9",
     "Pushes nineth input parameter.",
-    isHidden: true)]
+    isHidden: true,
+    inExpressionNr: 9)]
   [StorableClass]
   public class In9Expression : InExpression {
@@ -151,5 +162,6 @@
     "IN10",
     "Pushes tenth input parameter.",
-    isHidden: true)]
+    isHidden: true,
+    inExpressionNr: 10)]
   [StorableClass]
   public class In10Expression : InExpression {
Index: anches/PushGP/HeuristicLab.PushGP/HeuristicLab.Problems.ProgramSynthesis/Push/Extensions/ProblemDataExtensions.cs
===================================================================
--- /branches/PushGP/HeuristicLab.PushGP/HeuristicLab.Problems.ProgramSynthesis/Push/Extensions/ProblemDataExtensions.cs	(revision 15272)
+++ 	(revision )
@@ -1,25 +1,0 @@
-﻿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/Generators/CodeGenerator/CodeGeneratorUtils.cs
===================================================================
--- /branches/PushGP/HeuristicLab.PushGP/HeuristicLab.Problems.ProgramSynthesis/Push/Generators/CodeGenerator/CodeGeneratorUtils.cs	(revision 15272)
+++ /branches/PushGP/HeuristicLab.PushGP/HeuristicLab.Problems.ProgramSynthesis/Push/Generators/CodeGenerator/CodeGeneratorUtils.cs	(revision 15273)
@@ -7,58 +7,78 @@
 
   using HeuristicLab.Problems.ProgramSynthesis.Base.Erc;
+  using HeuristicLab.Problems.ProgramSynthesis.Base.Extensions;
+  using HeuristicLab.Problems.ProgramSynthesis.Push.Configuration;
+  using HeuristicLab.Problems.ProgramSynthesis.Push.SolutionCreator;
 
   using Stack;
 
   internal static class CodeGeneratorUtils {
-    internal static Expression CreateExpressionOrErc(
+    private static readonly Expression Noop = ExpressionTable.GetStatelessExpression<ExecNoopExpression>();
+
+    internal static Expression MapToExpression(
       IRandom random,
-      IReadOnlyList<string> enabledExpressions,
       IReadOnlyErcOptions ercOptions,
+      IReadOnlyExpressionsConfiguration config,
       IDictionary<string, Expression> customExpressions = null) {
       var customCount = customExpressions == null ? 0 : customExpressions.Count;
-      var index = random.Next(enabledExpressions.Count + customCount);
+      var enabledExpressionCount = config.EnabledExpressions.Count;
+      var index = random.Next(enabledExpressionCount + customCount);
 
-      return index >= enabledExpressions.Count
-        ? customExpressions.Values.ElementAt(index - enabledExpressions.Count)
-        : CreateExpressionOrErc(index, random, enabledExpressions, ercOptions);
+      return index >= config.EnabledExpressions.Count
+        ? customExpressions.Values.ElementAt(index - enabledExpressionCount)
+        : MapToExpression(index, random, ercOptions, config);
     }
 
-    internal static Expression CreateExpressionOrErc(
+    internal static Expression MapToExpression(
       int index,
       IRandom random,
-      IReadOnlyList<string> enabledExpressions,
-      IReadOnlyErcOptions ercOptions) {
-      var name = enabledExpressions[index];
+      IReadOnlyErcOptions ercOptions,
+      IReadOnlyExpressionsConfiguration config) {
 
-      return CreateExpressionOrErc(name, random, ercOptions);
+      switch (index) {
+        case PushSolutionEncoding.Noop:
+          return Noop;
+
+        case PushSolutionEncoding.Erc:
+          var stackType = config.ExpressionsPerStackCount.RandomWeightedOrDefault(random, pair => pair.Value).Key;
+
+          if (stackType == default(StackTypes))
+            break;
+
+          return CreateRandomErcExpression(stackType, random, ercOptions);
+
+        case PushSolutionEncoding.In:
+          if (config.InExpressionCount == 0) break;
+
+          var nr = random.Next(0, config.InExpressionCount) + 1;
+          return ExpressionTable.InExpressionTable[nr];
+      }
+
+      var name = config.EnabledExpressions[index];
+      return ExpressionTable.GetExpression(name);
     }
 
-    private static Expression CreateExpressionOrErc(
-      string expressionName,
-      IRandom random,
-      IReadOnlyErcOptions ercOptions) {
-      //var x = random.NextDouble();
-      //Expression expression = null;
+    //private static Expression CreateExpressionOrErc(
+    //  string expressionName,
+    //  IRandom random,
+    //  IReadOnlyErcOptions ercOptions) {
+    //  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;
+    //  return expression;
+    //}
 
-      var expression = ExpressionTable.GetExpression(expressionName);
-
-      return expression;
-    }
-
-    private static readonly Expression Noop = ExpressionTable.GetStatelessExpression<ExecNoopExpression>();
     /// <summary>
     /// Create a ErcExpression whereby the type of the expression conforms to the passed stack type.
Index: /branches/PushGP/HeuristicLab.PushGP/HeuristicLab.Problems.ProgramSynthesis/Push/Generators/CodeGenerator/LinearCodeGenerator.cs
===================================================================
--- /branches/PushGP/HeuristicLab.PushGP/HeuristicLab.Problems.ProgramSynthesis/Push/Generators/CodeGenerator/LinearCodeGenerator.cs	(revision 15272)
+++ /branches/PushGP/HeuristicLab.PushGP/HeuristicLab.Problems.ProgramSynthesis/Push/Generators/CodeGenerator/LinearCodeGenerator.cs	(revision 15273)
@@ -31,11 +31,11 @@
       IManagedPool<PooledList<Expression>> expressionListPool = null,
       IRandom random = null,
-      IReadOnlyPushConfiguration pushConfiguration = null,
+      IReadOnlyPushConfiguration config = null,
       IDictionary<string, Expression> customExpressions = null) {
       if (maxPoints == 0)
         return new Expression[0];
 
-      random = random ?? new FastRandom();
-      pushConfiguration = pushConfiguration ?? new PushConfiguration();
+      random = random ?? new MersenneTwister();
+      config = config ?? new PushConfiguration();
 
       var size = maxPoints <= 1 ? 1 : random.Next(1, maxPoints);
@@ -43,8 +43,8 @@
 
       for (var i = 0; i < size; i++) {
-        var expression = CodeGeneratorUtils.CreateExpressionOrErc(
+        var expression = CodeGeneratorUtils.MapToExpression(
           random,
-          pushConfiguration.EnabledExpressions,
-          pushConfiguration.ErcOptions,
+          config.ErcOptions,
+          config,
           customExpressions);
 
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 15272)
+++ /branches/PushGP/HeuristicLab.PushGP/HeuristicLab.Problems.ProgramSynthesis/Push/Generators/CodeGenerator/RecursiveCodeGenerator.cs	(revision 15273)
@@ -49,8 +49,8 @@
     private static IEnumerable<Expression> RandomCodeWithSize(int points, IRandom random, IReadOnlyPushConfiguration pushConfiguration, IDictionary<string, Expression> customExpressions = null) {
       if (points == 1) {
-        return new[] { CodeGeneratorUtils.CreateExpressionOrErc(
+        return new[] { CodeGeneratorUtils.MapToExpression(
           random,
-          pushConfiguration.EnabledExpressions,
           pushConfiguration.ErcOptions,
+          pushConfiguration,
           customExpressions)
         };
Index: /branches/PushGP/HeuristicLab.PushGP/HeuristicLab.Problems.ProgramSynthesis/Push/Individual/IndividualExtensions.cs
===================================================================
--- /branches/PushGP/HeuristicLab.PushGP/HeuristicLab.Problems.ProgramSynthesis/Push/Individual/IndividualExtensions.cs	(revision 15272)
+++ /branches/PushGP/HeuristicLab.PushGP/HeuristicLab.Problems.ProgramSynthesis/Push/Individual/IndividualExtensions.cs	(revision 15273)
@@ -6,43 +6,12 @@
   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;
+  using HeuristicLab.Problems.ProgramSynthesis.Push.SolutionCreator;
 
   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;
     }
 
@@ -53,9 +22,18 @@
 
       for (var i = vector.Length - 1; i >= 0; i--) {
-        var expression = CodeGeneratorUtils.CreateExpressionOrErc(
-          vector[i],
+        var index = vector[i];
+
+        if (index == PushSolutionEncoding.End)
+          break;
+
+        // skip noops
+        if (index == PushSolutionEncoding.Noop)
+          continue;
+
+        var expression = CodeGeneratorUtils.MapToExpression(
+          index,
           random,
-          config.EnabledExpressions,
-          config.ErcOptions);
+          config.ErcOptions,
+          config);
 
         expressions.Add(expression);
Index: /branches/PushGP/HeuristicLab.PushGP/HeuristicLab.Problems.ProgramSynthesis/Push/Individual/InduvidualMapper.cs
===================================================================
--- /branches/PushGP/HeuristicLab.PushGP/HeuristicLab.Problems.ProgramSynthesis/Push/Individual/InduvidualMapper.cs	(revision 15272)
+++ /branches/PushGP/HeuristicLab.PushGP/HeuristicLab.Problems.ProgramSynthesis/Push/Individual/InduvidualMapper.cs	(revision 15273)
@@ -39,9 +39,9 @@
 
       for (; currentIndex < vector.Length; currentIndex++) {
-        var expression = CodeGeneratorUtils.CreateExpressionOrErc(
+        var expression = CodeGeneratorUtils.MapToExpression(
           vector[currentIndex] % config.EnabledExpressions.Count,
           random,
-          config.EnabledExpressions,
-          config.ErcOptions);
+          config.ErcOptions,
+          config);
 
         var expressionType = expression.GetType();
Index: /branches/PushGP/HeuristicLab.PushGP/HeuristicLab.Problems.ProgramSynthesis/Push/Interpreter/Extensions.cs
===================================================================
--- /branches/PushGP/HeuristicLab.PushGP/HeuristicLab.Problems.ProgramSynthesis/Push/Interpreter/Extensions.cs	(revision 15272)
+++ /branches/PushGP/HeuristicLab.PushGP/HeuristicLab.Problems.ProgramSynthesis/Push/Interpreter/Extensions.cs	(revision 15273)
@@ -8,4 +8,6 @@
 
   using Attributes;
+
+  using HeuristicLab.BenchmarkSuite;
 
   using Stack;
@@ -60,4 +62,25 @@
       }
     }
+
+    public static void InitExample(this IPushInterpreter interpreter, Example example) {
+      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);
+    }
   }
 }
Index: /branches/PushGP/HeuristicLab.PushGP/HeuristicLab.Problems.ProgramSynthesis/Push/Interpreter/IPushInterpreter.cs
===================================================================
--- /branches/PushGP/HeuristicLab.PushGP/HeuristicLab.Problems.ProgramSynthesis/Push/Interpreter/IPushInterpreter.cs	(revision 15272)
+++ /branches/PushGP/HeuristicLab.PushGP/HeuristicLab.Problems.ProgramSynthesis/Push/Interpreter/IPushInterpreter.cs	(revision 15273)
@@ -11,5 +11,5 @@
 
   public interface IPushInterpreter {
-    IRandom Random { get; set; }
+    IRandom Random { get; }
     IPushStack<Expression> CodeStack { get; }
     IPushStack<Expression> ExecStack { get; }
@@ -28,6 +28,6 @@
     IReadOnlyDictionary<StackTypes, IPushStack> Stacks { get; }
     IReadOnlyPushConfiguration Configuration { get; }
-    void Clear();
-    void Reset();
+    void ClearStacks();
+    void Reset(IRandom random = null);
 
     void SetInput(
Index: /branches/PushGP/HeuristicLab.PushGP/HeuristicLab.Problems.ProgramSynthesis/Push/Interpreter/PooledPushInterpreter.cs
===================================================================
--- /branches/PushGP/HeuristicLab.PushGP/HeuristicLab.Problems.ProgramSynthesis/Push/Interpreter/PooledPushInterpreter.cs	(revision 15272)
+++ /branches/PushGP/HeuristicLab.PushGP/HeuristicLab.Problems.ProgramSynthesis/Push/Interpreter/PooledPushInterpreter.cs	(revision 15273)
@@ -15,5 +15,5 @@
     public override void Dispose() {
       base.Dispose();
-      Clear();
+      ClearStacks();
       pool.Free(this);
     }
Index: /branches/PushGP/HeuristicLab.PushGP/HeuristicLab.Problems.ProgramSynthesis/Push/Interpreter/PushInterpreter.cs
===================================================================
--- /branches/PushGP/HeuristicLab.PushGP/HeuristicLab.Problems.ProgramSynthesis/Push/Interpreter/PushInterpreter.cs	(revision 15272)
+++ /branches/PushGP/HeuristicLab.PushGP/HeuristicLab.Problems.ProgramSynthesis/Push/Interpreter/PushInterpreter.cs	(revision 15273)
@@ -19,6 +19,13 @@
     private Expression currentProgram;
 
+    /// <summary>
+    /// An interpreter for Push
+    /// </summary>
+    /// <param name="config">Determines the runtime behavior of the interpreter</param>
+    /// <param name="random">Note that random may be reseted</param>
+    /// <param name="poolContainer">Used to save resources used by the interpreter</param>
     public PushInterpreter(IReadOnlyPushConfiguration config = null, IRandom random = null, InterpreterPoolContainer poolContainer = null) {
-      Random = random ?? new MersenneTwister();
+      randomOrigin = random ?? new MersenneTwister();
+      Random = (IRandom)randomOrigin.Clone();
       Configuration = config ?? new PushConfiguration();
 
@@ -69,5 +76,6 @@
     public IReadOnlyDictionary<StackTypes, IPushStack> Stacks { get; private set; }
 
-    public IRandom Random { get; set; }
+    private IRandom randomOrigin;
+    public IRandom Random { get; private set; }
 
     public long ExecCounter { get; private set; }
@@ -330,7 +338,13 @@
 
     /// <summary>
-    /// Reset while interpreter
+    /// Reset interpreter which clears and reconfigures stacks and local variables
     /// </summary>
-    public void Reset() {
+    public void Reset(IRandom random = null) {
+      if (random != null)
+        randomOrigin = random;
+
+      // Reset Random
+      Random = (IRandom)randomOrigin.Clone();
+
       ExecCounter = 0;
       IsAborted = false;
@@ -340,5 +354,5 @@
 
       inputExpressions.Clear();
-      Clear();
+      ClearStacks();
       ConfigureStacks();
     }
@@ -357,5 +371,5 @@
     /// Clears Stacks and custom expressions
     /// </summary>
-    public void Clear() {
+    public void ClearStacks() {
       for (var i = 0u; i < supportedStackTypes.Length; i++) {
         var key = supportedStackTypes[i];
Index: /branches/PushGP/HeuristicLab.PushGP/HeuristicLab.Problems.ProgramSynthesis/Push/Interpreter/PushInterpreterPool.cs
===================================================================
--- /branches/PushGP/HeuristicLab.PushGP/HeuristicLab.Problems.ProgramSynthesis/Push/Interpreter/PushInterpreterPool.cs	(revision 15272)
+++ /branches/PushGP/HeuristicLab.PushGP/HeuristicLab.Problems.ProgramSynthesis/Push/Interpreter/PushInterpreterPool.cs	(revision 15273)
@@ -5,5 +5,4 @@
   using HeuristicLab.Problems.ProgramSynthesis.Push.Data.Pool;
   using HeuristicLab.Problems.ProgramSynthesis.Push.Expressions;
-  using HeuristicLab.Random;
 
   public class PushInterpreterPool {
@@ -33,6 +32,5 @@
     public PooledPushInterpreter Create(IRandom random = null) {
       var interpreter = pool.Allocate();
-      interpreter.Random = random ?? new MersenneTwister();
-      interpreter.Reset();
+      interpreter.Reset(random);
 
       return interpreter;
@@ -40,5 +38,5 @@
 
     public void Free(PooledPushInterpreter interpreter) {
-      interpreter.Random = null;
+      interpreter.ClearStacks();
       pool.Free(interpreter);
     }
Index: /branches/PushGP/HeuristicLab.PushGP/HeuristicLab.Problems.ProgramSynthesis/Push/ObjectPools/Random/SeededRandomPool.cs
===================================================================
--- /branches/PushGP/HeuristicLab.PushGP/HeuristicLab.Problems.ProgramSynthesis/Push/ObjectPools/Random/SeededRandomPool.cs	(revision 15273)
+++ /branches/PushGP/HeuristicLab.PushGP/HeuristicLab.Problems.ProgramSynthesis/Push/ObjectPools/Random/SeededRandomPool.cs	(revision 15273)
@@ -0,0 +1,36 @@
+﻿namespace HeuristicLab.Problems.ProgramSynthesis.Push.ObjectPools.Random {
+  using System;
+
+  using HeuristicLab.Core;
+  using HeuristicLab.Problems.ProgramSynthesis.Push.Data.Pool;
+  using HeuristicLab.Random;
+
+  public class SeededRandomPool {
+    public int Seed;
+    protected readonly ObjectPool<IRandom> Pool;
+
+    public SeededRandomPool() : this(new Random().Next()) { }
+
+    public SeededRandomPool(int seed) : this(seed, () => new MersenneTwister()) { }
+
+    public SeededRandomPool(int seed, Func<IRandom> randomCreator) {
+      Seed = seed;
+      Pool = new ObjectPool<IRandom>(randomCreator);
+    }
+
+    public IRandom ResetAndAllocate() {
+      var random = Pool.Allocate();
+      random.Reset(Seed);
+
+      return random;
+    }
+
+    public void Free(IRandom random) {
+      Pool.Free(random);
+    }
+
+    public void Clear() {
+      Pool.Clear();
+    }
+  }
+}
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 15272)
+++ /branches/PushGP/HeuristicLab.PushGP/HeuristicLab.Problems.ProgramSynthesis/Push/Problem/BenchmarkSuite/BenchmarkSuitePushSolutionView.cs	(revision 15273)
@@ -53,23 +53,5 @@
       var example = Evaluator.Data.Examples[exampleComboBox.SelectedIndex];
 
-      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());
+      interpreter.InitExample(example);
     }
 
@@ -92,4 +74,5 @@
     }
 
+
     protected override void OnContentChanged() {
       if (Content == null) return;
@@ -104,5 +87,6 @@
       }
 
-      interpreter = pool.Create(Content.Random);
+      var random = Content.GetRandom();
+      interpreter = pool.Create(random);
       UpdateExamples(Evaluator.Data);
 
@@ -181,5 +165,6 @@
       grid.Columns.Add(relativeDiffColumn);
 
-      using (var pushInterpreter = pool.Create(Content.Random)) {
+      var random = Content.GetRandom();
+      using (var pushInterpreter = pool.Create(random)) {
         var rowIndex = 1;
         for (var i = start; i < end; i++, rowIndex++) {
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 15272)
+++ /branches/PushGP/HeuristicLab.PushGP/HeuristicLab.Problems.ProgramSynthesis/Push/Problem/BenchmarkSuite/PushBenchmarkSuiteEvaluator.cs	(revision 15273)
@@ -131,23 +131,5 @@
       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.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.InitExample(example);
       interpreter.Run(program);
 
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 15272)
+++ /branches/PushGP/HeuristicLab.PushGP/HeuristicLab.Problems.ProgramSynthesis/Push/Problem/BenchmarkSuite/PushBenchmarkSuiteProblem.cs	(revision 15273)
@@ -8,5 +8,4 @@
   using HeuristicLab.BenchmarkSuite.Problems;
   using HeuristicLab.Problems.ProgramSynthesis.Push.Expressions;
-  using HeuristicLab.Problems.ProgramSynthesis.Push.Extensions;
 
   using Instances;
@@ -49,16 +48,16 @@
       Description = data.Description;
       BestKnownQuality = data.BestResult;
-      config.MaxPointsInProgram = data.MaxSize;
-      config.EvalPushLimit = data.EvalLimit;
-      config.ErcOptions = data.ErcOptions;
-      config.FloatStringFormat = data.FloatStringFormat;
+      Config.MaxPointsInProgram = data.MaxSize;
+      Config.EvalPushLimit = data.EvalLimit;
+      Config.ErcOptions = data.ErcOptions;
+      Config.FloatStringFormat = data.FloatStringFormat;
 
-      config.SetEnabledStacks((StackTypes)data.EnabledDataTypes);
-      data.InitInExpressions(config);
+      Config.SetEnabledStacks((StackTypes)data.EnabledDataTypes);
+      Config.InitInExpressions(data.TotalInputArgumentCount);
 
       Encoding.Bounds[0, 0] = 0;
-      Encoding.Bounds[0, 1] = config.EnabledExpressions.Count;
+      Encoding.Bounds[0, 1] = Config.EnabledExpressions.Count;
 
-      InitProgramLength = data.MaxSize / 2;
+      Encoding.Length = data.MaxSize;
     }
 
@@ -67,7 +66,6 @@
       double bestQuality,
       IRandom random,
-      IReadOnlyPushConfiguration config,
-      IPushEvaluator evaluator) {
-      return new PushBenchmarkSuiteSolution(program, bestQuality, random, (IReadOnlyPushConfiguration)config.Clone(), (PushBenchmarkSuiteEvaluator)PushEvaluator.Clone());
+      IReadOnlyPushConfiguration config) {
+      return new PushBenchmarkSuiteSolution(program, bestQuality, random, config, (PushBenchmarkSuiteEvaluator)PushEvaluator.Clone());
     }
   }
Index: anches/PushGP/HeuristicLab.PushGP/HeuristicLab.Problems.ProgramSynthesis/Push/Problem/IndividualMapper.cs
===================================================================
--- /branches/PushGP/HeuristicLab.PushGP/HeuristicLab.Problems.ProgramSynthesis/Push/Problem/IndividualMapper.cs	(revision 15272)
+++ 	(revision )
@@ -1,108 +1,0 @@
-﻿namespace HeuristicLab.Problems.ProgramSynthesis.Push.Problem {
-  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.Extensions;
-  using HeuristicLab.Problems.ProgramSynthesis.Push.Generators.CodeGenerator;
-  using HeuristicLab.Random;
-
-  public static class IndividualMapper {
-    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;
-
-      return FromPlush(vector, ref currentIndex, ref close, 0, config, random);
-    }
-
-    private static 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 = new List<Expression>();
-
-      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 new PushProgram(expressions);
-    }
-  }
-}
Index: /branches/PushGP/HeuristicLab.PushGP/HeuristicLab.Problems.ProgramSynthesis/Push/Problem/PushProblem.cs
===================================================================
--- /branches/PushGP/HeuristicLab.PushGP/HeuristicLab.Problems.ProgramSynthesis/Push/Problem/PushProblem.cs	(revision 15272)
+++ /branches/PushGP/HeuristicLab.PushGP/HeuristicLab.Problems.ProgramSynthesis/Push/Problem/PushProblem.cs	(revision 15273)
@@ -7,5 +7,4 @@
   using Configuration;
   using Core;
-  using Data.Pool;
   using HeuristicLab.Data;
   using HeuristicLab.Encodings.IntegerVectorEncoding;
@@ -13,5 +12,6 @@
   using HeuristicLab.Problems.ProgramSynthesis.Push.Expressions;
   using HeuristicLab.Problems.ProgramSynthesis.Push.Individual;
-  using HeuristicLab.Problems.ProgramSynthesis.Push.Problem.BenchmarkSuite;
+  using HeuristicLab.Problems.ProgramSynthesis.Push.ObjectPools.Random;
+  using HeuristicLab.Problems.ProgramSynthesis.Push.SolutionCreator;
 
   using Interpreter;
@@ -19,21 +19,21 @@
   using Parameters;
   using Persistence.Default.CompositeSerializers.Storable;
-  using Random;
 
   [StorableClass]
   public abstract class PushProblem : SingleObjectiveBasicProblem<IntegerVectorEncoding> {
     [Storable]
-    protected readonly PushConfigurationParameterCollection config;
-    protected PushInterpreterPool pool;
-    protected readonly ObjectPool<IRandom> randomPool = new ObjectPool<IRandom>(() => new MersenneTwister(), Environment.ProcessorCount * 4);
+    protected readonly PushConfigurationParameterCollection Config;
+
+    protected PushInterpreterPool Pool;
+    protected readonly SeededRandomPool RandomPool = new SeededRandomPool();
 
     [Storable]
     protected readonly IPushEvaluator PushEvaluator;
 
-    private const string BestTrainingSolutionResultName = "Best Solution";
-    private const string TestQualityResultName = "Test Quality";
-
-    protected PushProblem(PushBenchmarkSuiteEvaluator evaluator) {
-      config = new PushConfigurationParameterCollection();
+    private const string BEST_TRAINING_SOLUTION_RESULT_NAME = "Best Solution";
+    private const string TEST_QUALITY_RESULT_NAME = "Test Quality";
+
+    protected PushProblem(IPushEvaluator evaluator) {
+      Config = new PushConfigurationParameterCollection();
       PushEvaluator = evaluator;
 
@@ -52,5 +52,5 @@
     protected PushProblem(PushProblem original, Cloner cloner)
       : base(original, cloner) {
-      config = cloner.Clone(original.config);
+      Config = cloner.Clone(original.Config);
       PushEvaluator = cloner.Clone(original.PushEvaluator);
 
@@ -68,25 +68,18 @@
 
     private void InitData() {
-      pool = new PushInterpreterPool(Environment.ProcessorCount * 2, 4096, 1024, config);
+      Pool = new PushInterpreterPool(Environment.ProcessorCount * 2, 4096, 1024, Config);
     }
 
     private void InitEvents() {
-      config.EnabledExpressionsChanged += EnabledExpressionsChanged;
+      Config.EnabledExpressionsChanged += EnabledExpressionsChanged;
+      Reset += PushProblemReset;
     }
 
     private void EnabledExpressionsChanged(object sender, EnabledExpressionsChangedEventArgs e) {
-      Encoding.Bounds[0, 1] = config.EnabledExpressions.Count;
-      Encoding.BoundsParameter.Value[0, 1] = config.EnabledExpressions.Count;
-    }
-
-    public ILookupParameter<IntValue> SeedParamater
-    {
-      get { return (ILookupParameter<IntValue>)Parameters["Seed"]; }
-    }
-
-    #region Parameters
-    private const string InitProgramLengthParameterName = "InitProgramLength";
-    private const string InitProgramLengthParameterDescription = "This is the initial size of a push program.";
-    private const string PushConfigurationParameterName = "PushConfiguration";
+      Encoding.Bounds[0, 1] = Config.EnabledExpressions.Count;
+      Encoding.BoundsParameter.Value[0, 1] = Config.EnabledExpressions.Count;
+    }
+
+    private const string PUSH_CONFIGURATION_PARAMETER_NAME = "PushConfiguration";
 
     public const string CasesScopeParameterName = "CaseQualities";
@@ -94,5 +87,5 @@
 
     private void InitParameters() {
-      foreach (var paramater in config.Parameters) {
+      foreach (var paramater in Config.Parameters) {
         if (!Parameters.ContainsKey(paramater.Name)) {
           Parameters.Add(paramater);
@@ -100,18 +93,9 @@
       }
 
-      if (!Parameters.ContainsKey(PushConfigurationParameterName))
-        Parameters.Add(new ValueParameter<IReadOnlyPushConfiguration>(PushConfigurationParameterName, config) {
+      if (!Parameters.ContainsKey(PUSH_CONFIGURATION_PARAMETER_NAME))
+        Parameters.Add(new ValueParameter<IReadOnlyPushConfiguration>(PUSH_CONFIGURATION_PARAMETER_NAME, Config) {
           Hidden = true
         });
 
-      if (!Parameters.ContainsKey(InitProgramLengthParameterName)) {
-        Parameters.Add(new FixedValueParameter<IntValue>(
-          InitProgramLengthParameterName,
-          InitProgramLengthParameterDescription,
-          new IntValue(50)));
-      }
-
-      Encoding.LengthParameter = InitProgramLengthParameter as IFixedValueParameter<IntValue>;
-
       if (!Parameters.ContainsKey(CasesScopeParameterName))
         Parameters.Add(new LookupParameter<BoolArray>(CasesScopeParameterName, "The training cases that have been successfully executed."));
@@ -121,39 +105,47 @@
     }
 
+    private void PushProblemReset(object sender, EventArgs e) {
+      // clear pools and free reserved memory
+      Pool.Clear();
+      IndividualMapper.Clear();
+      RandomPool.Clear();
+
+      // reset seed
+      Config.Seed = 0;
+    }
+
     protected override void OnReset() {
       base.OnReset();
 
       // clear pools and free reserved memory
-      pool.Clear();
+      Pool.Clear();
       IndividualMapper.Clear();
+      RandomPool.Clear();
+      Config.Seed = 0;
     }
 
     private void InitEncoding() {
       Encoding.Bounds[0, 0] = 0;
-      Encoding.Bounds[0, 1] = config.EnabledExpressions.Count;
-      Encoding.Length = config.MaxPointsInProgram;
+      Encoding.Bounds[0, 1] = Config.EnabledExpressions.Count;
+      Encoding.Length = Config.MaxPointsInProgram;
     }
 
     private void InitOperators() {
-      Operators.Add(new PushExpressionFrequencyAnalyzer());
-    }
-
-    /// <summary>
-    ///     This is the inital size of an push program generated by a solution creator
-    /// </summary>
-    public IValueParameter<IntValue> InitProgramLengthParameter
-    {
-      get { return (IValueParameter<IntValue>)Parameters[InitProgramLengthParameterName]; }
-    }
-
-    public int InitProgramLength
-    {
-      get { return InitProgramLengthParameter.Value.Value; }
-      set
-      {
-        InitProgramLengthParameter.Value.Value = value;
-      }
-    }
-    #endregion
+
+      var solutionCreator = Operators.OfType<PushSolutionCreator>().FirstOrDefault();
+
+      if (solutionCreator == null) {
+        solutionCreator = new PushSolutionCreator();
+        Operators.Add(solutionCreator);
+      }
+
+      solutionCreator.ErcOptions = Config.ErcOptions;
+
+      if (!Operators.OfType<PushExpressionFrequencyAnalyzer>().Any()) {
+        Operators.Add(new PushExpressionFrequencyAnalyzer());
+      }
+
+      SolutionCreator = solutionCreator;
+    }
 
     public override bool Maximization { get { return false; } }
@@ -165,68 +157,55 @@
       var bestIdx = Array.IndexOf(qualities, bestQuality);
       var vector = individuals[bestIdx].IntegerVector();
-      var seed = vector.GetSeed();
-      var rand = randomPool.Allocate();
-      rand.Reset(seed);
-
-      var program = (PushProgram)vector.ToPushProgram(config, rand).Clone();
+
+      var rand = RandomPool.ResetAndAllocate();
+      var program = (PushProgram)vector.ToPushProgram(Config, rand).Clone();
+      RandomPool.Free(rand);
+
+      rand = RandomPool.ResetAndAllocate();
       var isIndividualBetter = AnalyzeBestTrainingSolution(program, bestQuality, results, rand);
+      RandomPool.Free(rand);
 
       if (isIndividualBetter) {
-        rand.Reset(seed);
+        rand = RandomPool.ResetAndAllocate();
         AnalyzeBestTestSolution(program, results, rand);
-      }
-
-      randomPool.Free(rand);
+        RandomPool.Free(rand);
+      }
     }
 
     private void AnalyzeBestTestSolution(PushProgram program, ResultCollection results, IRandom random) {
-      var testResult = PushEvaluator.EvaluateTraining(pool, program, random);
-
-      if (!results.ContainsKey(TestQualityResultName)) {
-        results.Add(new Result(TestQualityResultName, new DoubleValue(testResult.AvgQuality)));
+      var testResult = PushEvaluator.EvaluateTraining(Pool, program, random);
+
+      if (!results.ContainsKey(TEST_QUALITY_RESULT_NAME)) {
+        results.Add(new Result(TEST_QUALITY_RESULT_NAME, new DoubleValue(testResult.AvgQuality)));
       } else {
-        ((DoubleValue)results[TestQualityResultName].Value).Value = testResult.AvgQuality;
+        ((DoubleValue)results[TEST_QUALITY_RESULT_NAME].Value).Value = testResult.AvgQuality;
       }
     }
 
     private bool AnalyzeBestTrainingSolution(PushProgram program, double bestQuality, ResultCollection results, IRandom random) {
-      if (!results.ContainsKey(BestTrainingSolutionResultName)) {
+      if (!results.ContainsKey(BEST_TRAINING_SOLUTION_RESULT_NAME)) {
         var solution = CreatePushSolution(
             program,
             bestQuality,
-            random,
-            config,
-            PushEvaluator);
-
-        results.Add(new Result(BestTrainingSolutionResultName, solution));
+            (IRandom)random.Clone(),
+            (IReadOnlyPushConfiguration)Config.Clone());
+
+        results.Add(new Result(BEST_TRAINING_SOLUTION_RESULT_NAME, solution));
         return true;
       }
 
-      var currentBestQuality = ((PushSolution)results[BestTrainingSolutionResultName].Value).Quality;
+      var currentBestQuality = ((PushSolution)results[BEST_TRAINING_SOLUTION_RESULT_NAME].Value).Quality;
 
       if ((!Maximization && currentBestQuality > bestQuality) ||
            (Maximization && currentBestQuality < bestQuality)) {
-        results[BestTrainingSolutionResultName].Value = CreatePushSolution(
+        results[BEST_TRAINING_SOLUTION_RESULT_NAME].Value = CreatePushSolution(
             program,
             bestQuality,
             random,
-            config,
-            PushEvaluator);
+            Config);
         return true;
       }
 
       return false;
-    }
-
-    private EvaluationResult EvaluateIntegerVector(IntegerVector vector) {
-      var rand = randomPool.Allocate();
-      var seed = vector.GetSeed();
-      rand.Reset(seed);
-
-      var program = vector.ToPushProgram(config, rand);
-      var result = PushEvaluator.EvaluateTraining(pool, program, rand);
-      randomPool.Free(rand);
-
-      return result;
     }
 
@@ -235,10 +214,18 @@
       double bestQuality,
       IRandom random,
-      IReadOnlyPushConfiguration config,
-      IPushEvaluator evaluator);
+      IReadOnlyPushConfiguration config);
 
     public override double Evaluate(Individual individual, IRandom random) {
-      var vector = individual.IntegerVector();
-      var result = EvaluateIntegerVector(vector);
+      // init seed of random pool
+      //Interlocked.CompareExchange(ref RandomPool.Seed, random.Next(), 0);
+      //Config.Seed = RandomPool.Seed;
+
+      //var rand = RandomPool.ResetAndAllocate();
+      var program = individual.ToPushProgram(Config, random);
+      //RandomPool.Free(rand);
+
+      //rand = RandomPool.ResetAndAllocate();
+      var result = PushEvaluator.EvaluateTraining(Pool, program, random);
+      //RandomPool.Free(rand);
 
       individual[CaseQualitiesScopeParameterName] = new DoubleArray(result.ExampleQualities);
Index: /branches/PushGP/HeuristicLab.PushGP/HeuristicLab.Problems.ProgramSynthesis/Push/Problem/PushSolution.cs
===================================================================
--- /branches/PushGP/HeuristicLab.PushGP/HeuristicLab.Problems.ProgramSynthesis/Push/Problem/PushSolution.cs	(revision 15272)
+++ /branches/PushGP/HeuristicLab.PushGP/HeuristicLab.Problems.ProgramSynthesis/Push/Problem/PushSolution.cs	(revision 15273)
@@ -11,5 +11,5 @@
     public readonly double Quality;
     [Storable]
-    public readonly IRandom Random;
+    protected readonly IRandom Random;
     [Storable]
     public readonly IReadOnlyPushConfiguration Config;
@@ -46,4 +46,8 @@
     }
 
+    public IRandom GetRandom() {
+      return (IRandom)Random.Clone();
+    }
+
     public virtual PushSolution Simplify() {
       return new PushSolution(Program, Quality, Random, Config, Evaluator, true);
Index: /branches/PushGP/HeuristicLab.PushGP/HeuristicLab.Problems.ProgramSynthesis/Push/SolutionCreator/IPlushCreator.cs
===================================================================
--- /branches/PushGP/HeuristicLab.PushGP/HeuristicLab.Problems.ProgramSynthesis/Push/SolutionCreator/IPlushCreator.cs	(revision 15273)
+++ /branches/PushGP/HeuristicLab.PushGP/HeuristicLab.Problems.ProgramSynthesis/Push/SolutionCreator/IPlushCreator.cs	(revision 15273)
@@ -0,0 +1,8 @@
+﻿namespace HeuristicLab.Problems.ProgramSynthesis.Push.SolutionCreator {
+  using HeuristicLab.Optimization;
+  using HeuristicLab.Problems.ProgramSynthesis.Push.Encoding;
+
+  public interface IPlushCreator : ISolutionCreator, IPlushOperator {
+
+  }
+}
Index: /branches/PushGP/HeuristicLab.PushGP/HeuristicLab.Problems.ProgramSynthesis/Push/SolutionCreator/PushSolutionCreator.cs
===================================================================
--- /branches/PushGP/HeuristicLab.PushGP/HeuristicLab.Problems.ProgramSynthesis/Push/SolutionCreator/PushSolutionCreator.cs	(revision 15273)
+++ /branches/PushGP/HeuristicLab.PushGP/HeuristicLab.Problems.ProgramSynthesis/Push/SolutionCreator/PushSolutionCreator.cs	(revision 15273)
@@ -0,0 +1,126 @@
+﻿namespace HeuristicLab.Problems.ProgramSynthesis.Push.SolutionCreator {
+  using System;
+
+  using HeuristicLab.Common;
+  using HeuristicLab.Core;
+  using HeuristicLab.Data;
+  using HeuristicLab.Encodings.IntegerVectorEncoding;
+  using HeuristicLab.Parameters;
+  using HeuristicLab.Persistence.Default.CompositeSerializers.Storable;
+  using HeuristicLab.Problems.ProgramSynthesis.Base.Erc;
+
+  /// <summary>
+  /// Generates a new random integer vector with each element uniformly distributed in a specified range.
+  /// </summary>
+  [Item("PushSolutionCreator", "An operator which creates a new random int vector with each element uniformly distributed in a specified range and considering Push specific details")]
+  [StorableClass]
+  public class PushSolutionCreator : UniformRandomIntegerVectorCreator {
+
+    private const string ERC_OPTIONS_PARAMETER_NAME = "ERC options";
+    private const string MIN_LENGTH_PARAMETER_NAME = "Min. Length";
+    private const string MAX_LENGTH_PARAMETER_NAME = "Max. Length";
+    private const string IN_INSTRUCTION_PROBABILITY = "IN Instruction Probability";
+
+    public PushSolutionCreator() {
+      if (!Parameters.ContainsKey(ERC_OPTIONS_PARAMETER_NAME))
+        Parameters.Add(new ValueParameter<ErcOptions>(ERC_OPTIONS_PARAMETER_NAME));
+
+      if (!Parameters.ContainsKey(MIN_LENGTH_PARAMETER_NAME))
+        Parameters.Add(new FixedValueParameter<IntValue>(MIN_LENGTH_PARAMETER_NAME, new IntValue(20)));
+
+      //if (!Parameters.ContainsKey(MAX_LENGTH_PARAMETER_NAME))
+      //  Parameters.Add(new FixedValueParameter<IntValue>(MAX_LENGTH_PARAMETER_NAME, new IntValue(100)));
+
+      if (!Parameters.ContainsKey(IN_INSTRUCTION_PROBABILITY))
+        Parameters.Add(new FixedValueParameter<PercentValue>(IN_INSTRUCTION_PROBABILITY, new PercentValue(0.05)));
+    }
+
+    [StorableConstructor]
+    public PushSolutionCreator(bool deserializing) : base(deserializing) {
+    }
+
+    public PushSolutionCreator(PushSolutionCreator origin, Cloner cloner) : base(origin, cloner) { }
+
+
+    public IValueParameter<ErcOptions> ErcOptionsParameter
+    {
+      get { return (IValueParameter<ErcOptions>)Parameters[ERC_OPTIONS_PARAMETER_NAME]; }
+    }
+
+    public ErcOptions ErcOptions
+    {
+      get { return ErcOptionsParameter.Value; }
+      set
+      {
+        ErcOptionsParameter.Value = value;
+      }
+    }
+
+    public IValueParameter<IntValue> MinLengthParameter
+    {
+      get { return (IValueParameter<IntValue>)Parameters[MIN_LENGTH_PARAMETER_NAME]; }
+    }
+
+    public int MinLength
+    {
+      get { return MinLengthParameter.Value.Value; }
+      set { MinLengthParameter.Value.Value = value; }
+    }
+
+    //public IValueParameter<IntValue> MaxLengthParameter
+    //{
+    //  get { return LengthParameter; } //(IValueParameter<IntValue>)Parameters[MAX_LENGTH_PARAMETER_NAME]; }
+    //}
+
+    //public int MaxLength
+    //{
+    //  get { return MaxLengthParameter.Value.Value; }
+    //  set { MaxLengthParameter.Value.Value = value; }
+    //}
+
+    public IValueParameter<PercentValue> InInstructionProbabilityParameter
+    {
+      get { return (IValueParameter<PercentValue>)Parameters[IN_INSTRUCTION_PROBABILITY]; }
+    }
+
+    public double InInstructionProbability
+    {
+      get { return InInstructionProbabilityParameter.Value.Value; }
+      set { InInstructionProbabilityParameter.Value.Value = value; }
+    }
+
+    protected override IntegerVector Create(IRandom random, IntValue length, IntMatrix bounds) {
+      var len = length.Value;
+      var result = new IntegerVector(len);
+
+      var variableLength = random.Next(MinLength, len);
+      var contentLength = Math.Min(variableLength, len);
+      var lowerBound = bounds[0, 0];
+      var upperBound = bounds[0, 1];
+      var inInstructionRelativeProbability = ErcOptions.ErcProbability + InInstructionProbability;
+
+      for (var i = 0; i < contentLength; i++) {
+        var x = random.NextDouble();
+
+        if (ErcOptions.ErcProbability > 0 &&
+            x <= ErcOptions.ErcProbability)
+          result[i] = PushSolutionEncoding.Erc;
+        else if (InInstructionProbability > 0 &&
+                 x <= inInstructionRelativeProbability)
+          result[i] = PushSolutionEncoding.In;
+        else
+          result[i] = random.Next(lowerBound, upperBound);
+      }
+
+      if (contentLength < len) {
+        result[contentLength] = PushSolutionEncoding.End;
+
+        for (var i = contentLength + 1; i < len; i++) {
+          result[i] = PushSolutionEncoding.Noop;
+        }
+      }
+
+      return result;
+    }
+  }
+}
Index: /branches/PushGP/HeuristicLab.PushGP/HeuristicLab.Problems.ProgramSynthesis/Push/SolutionCreator/PushSolutionEncoding.cs
===================================================================
--- /branches/PushGP/HeuristicLab.PushGP/HeuristicLab.Problems.ProgramSynthesis/Push/SolutionCreator/PushSolutionEncoding.cs	(revision 15273)
+++ /branches/PushGP/HeuristicLab.PushGP/HeuristicLab.Problems.ProgramSynthesis/Push/SolutionCreator/PushSolutionEncoding.cs	(revision 15273)
@@ -0,0 +1,8 @@
+﻿namespace HeuristicLab.Problems.ProgramSynthesis.Push.SolutionCreator {
+  public class PushSolutionEncoding {
+    public const int Noop = -1;
+    public const int Erc = -2;
+    public const int In = -3;
+    public const int End = -4;
+  }
+}
Index: /branches/PushGP/HeuristicLab.PushGP/HeuristicLab.Problems.ProgramSynthesis/Push/Views/ExpressionSelectionView.cs
===================================================================
--- /branches/PushGP/HeuristicLab.PushGP/HeuristicLab.Problems.ProgramSynthesis/Push/Views/ExpressionSelectionView.cs	(revision 15272)
+++ /branches/PushGP/HeuristicLab.PushGP/HeuristicLab.Problems.ProgramSynthesis/Push/Views/ExpressionSelectionView.cs	(revision 15273)
@@ -15,5 +15,5 @@
 
   [View("Push Expression Selection Editor")]
-  [Content(typeof(IEnabledExpressionsConfiguration), true)]
+  [Content(typeof(IExpressionsConfiguration), true)]
   public partial class ExpressionSelectionView : ItemView {
     public ExpressionSelectionView() {
@@ -24,7 +24,7 @@
     }
 
-    public new IEnabledExpressionsConfiguration Content
+    public new IExpressionsConfiguration Content
     {
-      get { return (IEnabledExpressionsConfiguration)base.Content; }
+      get { return (IExpressionsConfiguration)base.Content; }
       set
       {
Index: /branches/PushGP/HeuristicLab.PushGP/HeuristicLab.Problems.ProgramSynthesis/Push/Views/PushDebuggerView.cs
===================================================================
--- /branches/PushGP/HeuristicLab.PushGP/HeuristicLab.Problems.ProgramSynthesis/Push/Views/PushDebuggerView.cs	(revision 15272)
+++ /branches/PushGP/HeuristicLab.PushGP/HeuristicLab.Problems.ProgramSynthesis/Push/Views/PushDebuggerView.cs	(revision 15273)
@@ -54,5 +54,6 @@
       }
 
-      interpreter = pool.Create(Content.Random);
+      var random = Content.GetRandom();
+      interpreter = pool.Create(random);
 
       InitDebugLists(Content.Config);
Index: /branches/PushGP/HeuristicLab.PushGP/HeuristicLab.Tests/Benchmark/SolutionTests.cs
===================================================================
--- /branches/PushGP/HeuristicLab.PushGP/HeuristicLab.Tests/Benchmark/SolutionTests.cs	(revision 15272)
+++ /branches/PushGP/HeuristicLab.PushGP/HeuristicLab.Tests/Benchmark/SolutionTests.cs	(revision 15273)
@@ -6,5 +6,4 @@
   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;
@@ -35,5 +34,5 @@
 
       config.SetEnabledStacks((StackTypes)data.EnabledDataTypes);
-      data.InitInExpressions(config);
+      config.InitInExpressions(data.TotalInputArgumentCount);
 
       var evaluator = new PushBenchmarkSuiteEvaluator(data);
Index: /branches/PushGP/HeuristicLab.PushGP/HeuristicLab.Tests/Interpreter/Expressions/CommonTests.cs
===================================================================
--- /branches/PushGP/HeuristicLab.PushGP/HeuristicLab.Tests/Interpreter/Expressions/CommonTests.cs	(revision 15272)
+++ /branches/PushGP/HeuristicLab.PushGP/HeuristicLab.Tests/Interpreter/Expressions/CommonTests.cs	(revision 15273)
@@ -313,5 +313,5 @@
 
         CheckOtherStacksAreEmpty();
-        interpreter.Clear();
+        interpreter.ClearStacks();
       }
     }
Index: /branches/PushGP/HeuristicLab.PushGP/HeuristicLab.Tests/Interpreter/Expressions/ExampleTests.cs
===================================================================
--- /branches/PushGP/HeuristicLab.PushGP/HeuristicLab.Tests/Interpreter/Expressions/ExampleTests.cs	(revision 15272)
+++ /branches/PushGP/HeuristicLab.PushGP/HeuristicLab.Tests/Interpreter/Expressions/ExampleTests.cs	(revision 15273)
@@ -173,5 +173,5 @@
       Assert.IsTrue(interpreter.BooleanStack.IsEmpty);
 
-      interpreter.Clear();
+      interpreter.ClearStacks();
       interpreter.IntegerStack.Push(1, 2);
       interpreter.FloatStack.Push(2.1, 0.7);
@@ -204,5 +204,5 @@
       Assert.IsTrue(interpreter.BooleanStack.IsEmpty);
 
-      interpreter.Clear();
+      interpreter.ClearStacks();
       interpreter.IntegerStack.Push(1, 2);
       interpreter.FloatStack.Push(2.1, 0.7);
