Index: /branches/PushGP/HeuristicLab.PushGP/HeuristicLab.Problems.ProgramSynthesis.Base/Erc/IReadOnlyErcOptions.cs
===================================================================
--- /branches/PushGP/HeuristicLab.PushGP/HeuristicLab.Problems.ProgramSynthesis.Base/Erc/IReadOnlyErcOptions.cs	(revision 15274)
+++ /branches/PushGP/HeuristicLab.PushGP/HeuristicLab.Problems.ProgramSynthesis.Base/Erc/IReadOnlyErcOptions.cs	(revision 15275)
@@ -2,5 +2,7 @@
 
 namespace HeuristicLab.Problems.ProgramSynthesis.Base.Erc {
-  public interface IReadOnlyErcOptions {
+  using HeuristicLab.Core;
+
+  public interface IReadOnlyErcOptions : IItem {
     double ErcProbability { get; }
     IErcItem<int> IntegerErcOptions { get; }
Index: /branches/PushGP/HeuristicLab.PushGP/HeuristicLab.Problems.ProgramSynthesis/HeuristicLab.Problems.ProgramSynthesis.csproj
===================================================================
--- /branches/PushGP/HeuristicLab.PushGP/HeuristicLab.Problems.ProgramSynthesis/HeuristicLab.Problems.ProgramSynthesis.csproj	(revision 15274)
+++ /branches/PushGP/HeuristicLab.PushGP/HeuristicLab.Problems.ProgramSynthesis/HeuristicLab.Problems.ProgramSynthesis.csproj	(revision 15275)
@@ -123,5 +123,7 @@
     </Compile>
     <Compile Include="Push\Analyzer\IIndividualZeroErrorAnalyzer.cs" />
+    <Compile Include="Push\Analyzer\IIndividualZeroErrorDistributionAnalyzer.cs" />
     <Compile Include="Push\Analyzer\IndividualZeroErrorAnalyzer.cs" />
+    <Compile Include="Push\Analyzer\IndividualZeroErrorDistributionAnalyzer.cs" />
     <Compile Include="Push\Analyzer\IPushExpressionAnalyzer.cs" />
     <Compile Include="Push\Analyzer\PushExpressionFrequencyAnalyzer.cs" />
@@ -131,4 +133,6 @@
     <Compile Include="Push\Configuration\PushConfigurationBase.cs" />
     <Compile Include="Push\Configuration\PushConfigurationParameterCollection.cs" />
+    <Compile Include="Push\Crossover\AlternationCrossover.cs" />
+    <Compile Include="Push\Crossover\IPlushCrossover.cs" />
     <Compile Include="Push\Data\List\SkipList.cs" />
     <Compile Include="Push\Data\Pool\IPooledObject.cs" />
@@ -139,4 +143,8 @@
     <Compile Include="Push\Data\Tree\TreeNode.cs" />
     <Compile Include="Push\Constants\PushEnvironment.cs" />
+    <Compile Include="Push\Encoding\IPlushOperator.cs" />
+    <Compile Include="Push\Encoding\PlushEncoding.cs" />
+    <Compile Include="Push\Encoding\PlushEntry.cs" />
+    <Compile Include="Push\Encoding\PlushVector.cs" />
     <Compile Include="Push\Exporter\Exporter.cs" />
     <Compile Include="Push\Expressions\BooleanExpressions.cs" />
@@ -213,7 +221,11 @@
     <Compile Include="Push\Interpreter\PushInterpreter.cs" />
     <Compile Include="Push\Interpreter\PushInterpreterPool.cs" />
+    <Compile Include="Push\Manipulator\IPlushManipulator.cs" />
+    <Compile Include="Push\Manipulator\UniformMutation.cs" />
     <Compile Include="Push\ObjectPools\Random\SeededRandomPool.cs" />
     <Compile Include="Push\ObjectPools\StringBuilderPool.cs" />
     <Compile Include="Push\Parser\PushParser.cs" />
+    <Compile Include="Push\Problem\BenchmarkSuite\PlushPushBenchmarkSuiteProblem.cs" />
+    <Compile Include="Push\Problem\PlushPushProblem.cs" />
     <Compile Include="Push\Problem\BenchmarkSuite\PushBenchmarkSuiteSolution.cs" />
     <Compile Include="Push\Problem\DataBounds.cs" />
@@ -221,8 +233,9 @@
     <Compile Include="Push\Individual\IndividualExtensions.cs" />
     <Compile Include="Push\Problem\BenchmarkSuite\PushBenchmarkSuiteEvaluator.cs" />
-    <Compile Include="Push\Problem\BenchmarkSuite\PushBenchmarkSuiteProblem.cs" />
+    <Compile Include="Push\Problem\BenchmarkSuite\IntegerVectorPushBenchmarkSuiteProblem.cs" />
     <Compile Include="Push\Problem\IPushEvaluator.cs" />
-    <Compile Include="Push\Problem\PushProblem.cs" />
+    <Compile Include="Push\Problem\IntegerVectorPushProblem.cs" />
     <Compile Include="Properties\AssemblyInfo.cs" />
+    <Compile Include="Push\Problem\PushProblemBase.cs" />
     <Compile Include="Push\Problem\PushSolution.cs" />
     <Compile Include="Push\Data\Pool\PooledObject.cs" />
@@ -230,6 +243,8 @@
     <Compile Include="Push\Selector\LexicaseSelector.cs" />
     <Compile Include="Push\Simplifier\Simplifier.cs" />
+    <Compile Include="Push\SolutionCreator\IPlushCreator.cs" />
     <Compile Include="Push\SolutionCreator\PushSolutionCreator.cs" />
     <Compile Include="Push\SolutionCreator\PushSolutionEncoding.cs" />
+    <Compile Include="Push\SolutionCreator\PlushCreator.cs" />
     <Compile Include="Push\Stack\IPrintStack.cs" />
     <Compile Include="Push\Stack\IPushStack.cs" />
Index: /branches/PushGP/HeuristicLab.PushGP/HeuristicLab.Problems.ProgramSynthesis/Push/Analyzer/IIndividualZeroErrorDistributionAnalyzer.cs
===================================================================
--- /branches/PushGP/HeuristicLab.PushGP/HeuristicLab.Problems.ProgramSynthesis/Push/Analyzer/IIndividualZeroErrorDistributionAnalyzer.cs	(revision 15275)
+++ /branches/PushGP/HeuristicLab.PushGP/HeuristicLab.Problems.ProgramSynthesis/Push/Analyzer/IIndividualZeroErrorDistributionAnalyzer.cs	(revision 15275)
@@ -0,0 +1,14 @@
+﻿using System;
+using System.Collections.Generic;
+using System.Linq;
+using System.Text;
+using System.Threading.Tasks;
+
+namespace HeuristicLab.Problems.ProgramSynthesis.Push.Analyzer
+{
+  using HeuristicLab.Optimization;
+
+  public interface IIndividualZeroErrorDistributionAnalyzer : 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 15274)
+++ /branches/PushGP/HeuristicLab.PushGP/HeuristicLab.Problems.ProgramSynthesis/Push/Analyzer/IndividualZeroErrorAnalyzer.cs	(revision 15275)
@@ -22,5 +22,5 @@
     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 Y_AXIS_TITLE = "Count of zero error individuals";
     private const string X_AXIS_TITLE = "Case Index";
     private const string ROW_NAME = "Cases";
@@ -36,5 +36,5 @@
 
       Parameters.Add(new ScopeTreeLookupParameter<DoubleArray>(
-       PushProblem.CaseQualitiesScopeParameterName,
+       IntegerVectorPushProblem.CaseQualitiesScopeParameterName,
        "The quality of every single training case for each individual."));
     }
@@ -63,5 +63,5 @@
     public ILookupParameter<ItemArray<DoubleArray>> CaseQualitiesParameter
     {
-      get { return (ILookupParameter<ItemArray<DoubleArray>>)Parameters[PushProblem.CaseQualitiesScopeParameterName]; }
+      get { return (ILookupParameter<ItemArray<DoubleArray>>)Parameters[IntegerVectorPushProblem.CaseQualitiesScopeParameterName]; }
     }
 
Index: /branches/PushGP/HeuristicLab.PushGP/HeuristicLab.Problems.ProgramSynthesis/Push/Analyzer/IndividualZeroErrorDistributionAnalyzer.cs
===================================================================
--- /branches/PushGP/HeuristicLab.PushGP/HeuristicLab.Problems.ProgramSynthesis/Push/Analyzer/IndividualZeroErrorDistributionAnalyzer.cs	(revision 15275)
+++ /branches/PushGP/HeuristicLab.PushGP/HeuristicLab.Problems.ProgramSynthesis/Push/Analyzer/IndividualZeroErrorDistributionAnalyzer.cs	(revision 15275)
@@ -0,0 +1,137 @@
+﻿namespace HeuristicLab.Problems.ProgramSynthesis.Push.Analyzer {
+  using System.Linq;
+
+  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("IndividualZeroErrorDistributionAnalyzer", "An operater that tracks the distribution of individuals with zero error on the cases")]
+  [StorableClass]
+  public class IndividualZeroErrorDistributionAnalyzer : SingleSuccessorOperator, IIndividualZeroErrorDistributionAnalyzer {
+    private const string RESULTS_PARAMETER_NAME = "Results";
+    private const string INDIVIDUAL_ZERO_ERROR_PARAMETER_NAME = "ZeroErrorIndividualsPerCaseDistribution";
+
+    private const string RESULT_PARAMETER_NAME = "Zero Error Individual Per Case Distribution";
+    private const string RESULT_PARAMETER_DESCRIPTION = "Relative frequency of instructions aggregated over the whole population.";
+    private const string Y_AXIS_TITLE = "Number of zero error cases";
+    private const string X_AXIS_TITLE = "Number of individuals";
+    private const string ROW_NAME = "Cases";
+
+    public IndividualZeroErrorDistributionAnalyzer() {
+      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>(
+       IntegerVectorPushProblem.CaseQualitiesScopeParameterName,
+       "The quality of every single training case for each individual."));
+    }
+
+    [StorableConstructorAttribute]
+    public IndividualZeroErrorDistributionAnalyzer(bool deserializing) : base(deserializing) { }
+
+    public IndividualZeroErrorDistributionAnalyzer(IndividualZeroErrorDistributionAnalyzer origin, Cloner cloner) : base(origin, cloner) { }
+
+    public override IDeepCloneable Clone(Cloner cloner) {
+      return new IndividualZeroErrorDistributionAnalyzer(this, cloner);
+    }
+
+    public bool EnabledByDefault { get { return true; } }
+
+    public ILookupParameter<DataTable> IndividualZeroErrorDistributionParameter
+    {
+      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[IntegerVectorPushProblem.CaseQualitiesScopeParameterName]; }
+    }
+
+    public override IOperation Apply() {
+      var caseQualitiesPerIndividual = CaseQualitiesParameter.ActualValue;
+      var individualCount = caseQualitiesPerIndividual.Length;
+      var caseCount = caseQualitiesPerIndividual[0].Length;
+
+      var results = ResultsParameter.ActualValue;
+      var individualZeroErrorDistribution = IndividualZeroErrorDistributionParameter.ActualValue;
+
+      if (individualZeroErrorDistribution == null) {
+        individualZeroErrorDistribution = new DataTable(
+         RESULT_PARAMETER_NAME,
+         RESULT_PARAMETER_DESCRIPTION) {
+          VisualProperties = {
+            YAxisTitle = Y_AXIS_TITLE,
+            XAxisTitle = X_AXIS_TITLE,
+            XAxisMinimumFixedValue = 0,
+            XAxisMaximumAuto = true,
+            XAxisMinimumAuto = false,
+          }
+        };
+
+        IndividualZeroErrorDistributionParameter.ActualValue = individualZeroErrorDistribution;
+      }
+
+      if (!results.ContainsKey(RESULT_PARAMETER_NAME)) {
+        results.Add(new Result(RESULT_PARAMETER_NAME, individualZeroErrorDistribution));
+      }
+
+      DataRow row;
+      if (!individualZeroErrorDistribution.Rows.TryGetValue(ROW_NAME, out row)) {
+        row = new DataRow(ROW_NAME) {
+          VisualProperties = {
+              StartIndexZero = true,
+              IsVisibleInLegend = false,
+              ChartType = DataRowVisualProperties.DataRowChartType.Histogram,
+            }
+        };
+
+        individualZeroErrorDistribution.Rows.Add(row);
+      }
+
+      var caseCountChanged = row.Values.Count != caseCount;
+
+      if (caseCountChanged) {
+        row.Values.Clear();
+      }
+
+      // key represents the number of cases with zero error
+      // value represents the number of individuals with key cases with zero error
+      var distribution = caseQualitiesPerIndividual
+              .Select(individual => individual.Count(x => x == 0.0))
+              .GroupBy(x => x)
+              .ToDictionary(x => x.Key, x => x.Count());
+
+      for (var i = 0; i < caseCount; i++) {
+        int count;
+        distribution.TryGetValue(i, out count);
+        var x = count / (double)individualCount;
+
+        if (caseCountChanged)
+          row.Values.Add(x);
+        else
+          row.Values[i] = x;
+      }
+
+      return base.Apply();
+    }
+  }
+}
Index: /branches/PushGP/HeuristicLab.PushGP/HeuristicLab.Problems.ProgramSynthesis/Push/Crossover/AlternationCrossover.cs
===================================================================
--- /branches/PushGP/HeuristicLab.PushGP/HeuristicLab.Problems.ProgramSynthesis/Push/Crossover/AlternationCrossover.cs	(revision 15275)
+++ /branches/PushGP/HeuristicLab.PushGP/HeuristicLab.Problems.ProgramSynthesis/Push/Crossover/AlternationCrossover.cs	(revision 15275)
@@ -0,0 +1,122 @@
+﻿namespace HeuristicLab.Problems.ProgramSynthesis.Push.Crossover {
+  using System;
+  using System.Linq;
+
+  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.Encoding;
+  using HeuristicLab.Random;
+
+  /// <summary>
+  /// Alternation crossover for plush vectors.
+  /// </summary>
+  [Item("AlternationCrossover", "Alternation crossover for plush vectors.")]
+  [StorableClass]
+  public class AlternationCrossover : InstrumentedOperator, IPlushCrossover, IStochasticOperator {
+    private const double Mean = 0.0;
+
+    public AlternationCrossover() {
+      Parameters.Add(new LookupParameter<IRandom>("Random", "The pseudo random number generator which should be used for stochastic crossover operators."));
+      Parameters.Add(new ScopeTreeLookupParameter<PlushVector>("Parents", "The parent vectors which should be crossed."));
+      ParentsParameter.ActualName = "PlushVector";
+      Parameters.Add(new LookupParameter<PlushVector>("Child", "The child vector resulting from the crossover."));
+      ChildParameter.ActualName = "PlushVector";
+      Parameters.Add(new FixedValueParameter<PercentValue>("AlternationRate", "Specifies the probability of switching to another parent.", new PercentValue(0.5)));
+      Parameters.Add(new FixedValueParameter<DoubleValue>("AlignmentDeviation", "When alternating between parents, the index at which to continue copying may be offset backward or forward some amount based on a random sample from a normal distribution with mean 0 and standard deviation set by the alignment deviation parameter", new DoubleValue(1.0)));
+      Parameters.Add(new FixedValueParameter<IntValue>("MaxLength", "The max length of a children", new IntValue(100)));
+    }
+
+    [StorableConstructor]
+    public AlternationCrossover(bool deserializing) : base(deserializing) {
+    }
+
+    public AlternationCrossover(AlternationCrossover origin, Cloner cloner) : base(origin, cloner) {
+    }
+
+    public override IDeepCloneable Clone(Cloner cloner) {
+      return new AlternationCrossover(this, cloner);
+    }
+
+    public IValueParameter<IntValue> MaxLengthParameter
+    {
+      get { return (IValueParameter<IntValue>)Parameters["MaxLength"]; }
+    }
+
+    public int MaxLength
+    {
+      get { return MaxLengthParameter.Value.Value; }
+      set { MaxLengthParameter.Value.Value = value; }
+    }
+
+    public IValueParameter<PercentValue> AlternationRateParameter
+    {
+      get { return (IValueParameter<PercentValue>)Parameters["AlternationRate"]; }
+    }
+
+    public double AlternationRate
+    {
+      get { return AlternationRateParameter.Value.Value; }
+      set { AlternationRateParameter.Value.Value = value; }
+    }
+
+    public IValueParameter<DoubleValue> AlignmentDeviationParameter
+    {
+      get { return (IValueParameter<DoubleValue>)Parameters["AlignmentDeviation"]; }
+    }
+
+    public double AlignmentDeviation
+    {
+      get { return AlignmentDeviationParameter.Value.Value; }
+      set { AlignmentDeviationParameter.Value.Value = value; }
+    }
+
+    public ILookupParameter<IRandom> RandomParameter
+    {
+      get { return (LookupParameter<IRandom>)Parameters["Random"]; }
+    }
+    public ILookupParameter<ItemArray<PlushVector>> ParentsParameter
+    {
+      get { return (ScopeTreeLookupParameter<PlushVector>)Parameters["Parents"]; }
+    }
+    public ILookupParameter<PlushVector> ChildParameter
+    {
+      get { return (ILookupParameter<PlushVector>)Parameters["Child"]; }
+    }
+
+    public sealed override IOperation InstrumentedApply() {
+      ChildParameter.ActualValue = Cross(RandomParameter.ActualValue, ParentsParameter.ActualValue);
+      return base.InstrumentedApply();
+    }
+
+    private PlushVector Cross(IRandom random, ItemArray<PlushVector> parents) {
+      var normalDistributedRandom = new NormalDistributedRandom(random, Mean, AlignmentDeviation);
+      var maxLength = parents.Max(p => p.Entries.Count);
+      var parentIndex = random.Next(0, 2);
+      var parent = parents[parentIndex];
+      var child = new PlushVector(maxLength);
+      var maxChildLength = MaxLength;
+
+      for (var i = 0; i < maxLength && child.Entries.Count <= maxChildLength; i++) {
+
+        // if parent is shorter than the other, then ignore those entries
+        if (i < parent.Entries.Count)
+          child.Add(parent[i]);
+
+        // switch parent?
+        if (random.NextDouble() < AlternationRate) {
+          parentIndex = parentIndex == 0 ? 1 : 0;
+          parent = parents[parentIndex];
+          i += normalDistributedRandom.Next();
+          i = Math.Max(i, 0);
+        }
+      }
+
+      return child;
+    }
+  }
+}
Index: /branches/PushGP/HeuristicLab.PushGP/HeuristicLab.Problems.ProgramSynthesis/Push/Crossover/IPlushCrossover.cs
===================================================================
--- /branches/PushGP/HeuristicLab.PushGP/HeuristicLab.Problems.ProgramSynthesis/Push/Crossover/IPlushCrossover.cs	(revision 15275)
+++ /branches/PushGP/HeuristicLab.PushGP/HeuristicLab.Problems.ProgramSynthesis/Push/Crossover/IPlushCrossover.cs	(revision 15275)
@@ -0,0 +1,10 @@
+﻿namespace HeuristicLab.Problems.ProgramSynthesis.Push.Crossover {
+  using HeuristicLab.Core;
+  using HeuristicLab.Optimization;
+  using HeuristicLab.Problems.ProgramSynthesis.Push.Encoding;
+
+  public interface IPlushCrossover : IPlushOperator, ICrossover {
+    ILookupParameter<ItemArray<PlushVector>> ParentsParameter { get; }
+    ILookupParameter<PlushVector> ChildParameter { get; }
+  }
+}
Index: /branches/PushGP/HeuristicLab.PushGP/HeuristicLab.Problems.ProgramSynthesis/Push/Encoding/PlushEncoding.cs
===================================================================
--- /branches/PushGP/HeuristicLab.PushGP/HeuristicLab.Problems.ProgramSynthesis/Push/Encoding/PlushEncoding.cs	(revision 15274)
+++ /branches/PushGP/HeuristicLab.PushGP/HeuristicLab.Problems.ProgramSynthesis/Push/Encoding/PlushEncoding.cs	(revision 15275)
@@ -2,9 +2,18 @@
 
 namespace HeuristicLab.Problems.ProgramSynthesis.Push.Encoding {
+  using System;
+  using System.Linq;
 
   using HeuristicLab.Common;
   using HeuristicLab.Core;
+  using HeuristicLab.Data;
   using HeuristicLab.Optimization;
+  using HeuristicLab.Parameters;
   using HeuristicLab.Persistence.Default.CompositeSerializers.Storable;
+  using HeuristicLab.PluginInfrastructure;
+  using HeuristicLab.Problems.ProgramSynthesis.Base.Erc;
+  using HeuristicLab.Problems.ProgramSynthesis.Push.Configuration;
+  using HeuristicLab.Problems.ProgramSynthesis.Push.Crossover;
+  using HeuristicLab.Problems.ProgramSynthesis.Push.Manipulator;
   using HeuristicLab.Problems.ProgramSynthesis.Push.SolutionCreator;
 
@@ -12,14 +21,40 @@
   [StorableClass]
   public class PlushEncoding : Encoding<IPlushCreator> {
+
+    public PlushEncoding() : this("Plush") { }
+
+    public PlushEncoding(string name) : base(name) {
+      minLengthParameter = new FixedValueParameter<IntValue>(Name + ".MinLength", new IntValue(25));
+      maxLengthParameter = new FixedValueParameter<IntValue>(Name + ".MaxLength", new IntValue(100));
+      minCloseParameter = new FixedValueParameter<IntValue>(Name + ".MinClose", new IntValue(0));
+      maxCloseParameter = new FixedValueParameter<IntValue>(Name + ".MaxClose", new IntValue(3));
+      closeBiasLevelParameter = new FixedValueParameter<DoubleValue>(Name + ".CloseBiasLevel", new DoubleValue(3d));
+      instructionsParameter = new ValueParameter<IExpressionsConfiguration>(Name + ".Instructions");
+      ercOptionsParameter = new ValueParameter<ErcOptions>(Name + ".ErcOptions");
+      inInstructionProbabilityParameter = new FixedValueParameter<PercentValue>(Name + ".InInstructionProbability");
+
+      Parameters.Add(instructionsParameter);
+      Parameters.Add(ercOptionsParameter);
+      Parameters.Add(inInstructionProbabilityParameter);
+
+      SolutionCreator = new PlushCreator();
+      RegisterParameterEvents();
+      DiscoverOperators();
+    }
+
     public PlushEncoding(bool deserializing)
       : base(deserializing) {
     }
 
-    public PlushEncoding(Encoding<IPlushCreator> original, Cloner cloner)
+    public PlushEncoding(PlushEncoding original, Cloner cloner)
       : base(original, cloner) {
-    }
-
-    public PlushEncoding(string name)
-      : base(name) {
+      minLengthParameter = cloner.Clone(original.minLengthParameter);
+      maxLengthParameter = cloner.Clone(original.maxLengthParameter);
+    }
+
+    [StorableHook(HookType.AfterDeserialization)]
+    private void AfterDeserialization() {
+      RegisterParameterEvents();
+      DiscoverOperators();
     }
 
@@ -28,20 +63,346 @@
     }
 
+    #region events
+
+    private void OnMinLengthParameterChanged() {
+      RegisterMinLengthParameterEvents();
+      ConfigureOperators(Operators);
+    }
+    private void OnMaxLengthParameterChanged() {
+      RegisterMaxLengthParameterEvents();
+      ConfigureOperators(Operators);
+    }
+    private void OnMinCloseParameterChanged() {
+      RegisterMinCloseParameterEvents();
+      ConfigureOperators(Operators);
+    }
+    private void OnMaxCloseParameterChanged() {
+      RegisterMaxCloseParameterEvents();
+      ConfigureOperators(Operators);
+    }
+    private void OnCloseBiasLevelParameterChanged() {
+      RegisterCloseBiasLevelParameterEvents();
+      ConfigureOperators(Operators);
+    }
+    private void OnErcOptionsParameterChanged() {
+      RegisterErcOptionsParameterEvents();
+      ConfigureOperators(Operators);
+    }
+    private void OnInstructionsParameterChanged() {
+      RegisterInstructionsParameterEvents();
+      ConfigureOperators(Operators);
+    }
+    private void OnInInstructionProbabilityParameterChanged() {
+      RegisterInInstructionProbabilityParameterEvents();
+      ConfigureOperators(Operators);
+    }
+
+    private void RegisterParameterEvents() {
+      RegisterMinLengthParameterEvents();
+      RegisterMaxLengthParameterEvents();
+      RegisterMinCloseParameterEvents();
+      RegisterMaxCloseParameterEvents();
+      RegisterCloseBiasLevelParameterEvents();
+      RegisterErcOptionsParameterEvents();
+      RegisterInstructionsParameterEvents();
+      RegisterInInstructionProbabilityParameterEvents();
+    }
+
+    private void RegisterMinLengthParameterEvents() {
+      MinLengthParameter.ValueChanged += (o, s) => ConfigureOperators(Operators);
+      MinLengthParameter.Value.ValueChanged += (o, s) => ConfigureOperators(Operators);
+    }
+
+    private void RegisterMaxLengthParameterEvents() {
+      MaxLengthParameter.ValueChanged += (o, s) => ConfigureOperators(Operators);
+      MaxLengthParameter.Value.ValueChanged += (o, s) => ConfigureOperators(Operators);
+    }
+
+    private void RegisterMinCloseParameterEvents() {
+      MinCloseParameter.ValueChanged += (o, s) => ConfigureOperators(Operators);
+      MinCloseParameter.Value.ValueChanged += (o, s) => ConfigureOperators(Operators);
+    }
+
+    private void RegisterMaxCloseParameterEvents() {
+      MaxCloseParameter.ValueChanged += (o, s) => ConfigureOperators(Operators);
+      MaxCloseParameter.Value.ValueChanged += (o, s) => ConfigureOperators(Operators);
+    }
+
+    private void RegisterCloseBiasLevelParameterEvents() {
+      CloseBiasLevelParameter.ValueChanged += (o, s) => ConfigureOperators(Operators);
+      CloseBiasLevelParameter.Value.ValueChanged += (o, s) => ConfigureOperators(Operators);
+    }
+
+    private void RegisterInInstructionProbabilityParameterEvents() {
+      InInstructionProbabilityParameter.ValueChanged += (o, s) => ConfigureOperators(Operators);
+      InInstructionProbabilityParameter.Value.ValueChanged += (o, s) => ConfigureOperators(Operators);
+    }
+
+    private void RegisterErcOptionsParameterEvents() {
+      ErcOptionsParameter.ValueChanged += (o, s) => ConfigureOperators(Operators);
+    }
+
+    private void RegisterInstructionsParameterEvents() {
+      InstructionsParameter.ValueChanged += (o, s) => ConfigureOperators(Operators);
+    }
+
+    #endregion
+
+    #region Encoding Parameters
+    [Storable]
+    private IFixedValueParameter<IntValue> minLengthParameter;
+    public IFixedValueParameter<IntValue> MinLengthParameter
+    {
+      get { return minLengthParameter; }
+      set
+      {
+        if (value == null) throw new ArgumentNullException("Min length parameter must not be null.");
+        if (value.Value == null) throw new ArgumentNullException("Min length parameter value must not be null.");
+        if (minLengthParameter == value) return;
+
+        if (minLengthParameter != null) Parameters.Remove(minLengthParameter);
+        minLengthParameter = value;
+        Parameters.Add(minLengthParameter);
+        OnMinLengthParameterChanged();
+      }
+    }
+
+    [Storable]
+    private IFixedValueParameter<IntValue> maxLengthParameter;
+    public IFixedValueParameter<IntValue> MaxLengthParameter
+    {
+      get { return maxLengthParameter; }
+      set
+      {
+        if (value == null) throw new ArgumentNullException("Max length parameter must not be null.");
+        if (value.Value == null) throw new ArgumentNullException("Max length parameter value must not be null.");
+        if (maxLengthParameter == value) return;
+
+        if (maxLengthParameter != null) Parameters.Remove(maxLengthParameter);
+        maxLengthParameter = value;
+        Parameters.Add(maxLengthParameter);
+        OnMaxLengthParameterChanged();
+      }
+    }
+
+    [Storable]
+    private IFixedValueParameter<IntValue> minCloseParameter;
+    public IFixedValueParameter<IntValue> MinCloseParameter
+    {
+      get { return minCloseParameter; }
+      set
+      {
+        if (value == null) throw new ArgumentNullException("Min close parameter must not be null.");
+        if (value.Value == null) throw new ArgumentNullException("Min close parameter value must not be null.");
+        if (minCloseParameter == value) return;
+
+        if (minCloseParameter != null) Parameters.Remove(minCloseParameter);
+        minCloseParameter = value;
+        Parameters.Add(minCloseParameter);
+        OnMinCloseParameterChanged();
+      }
+    }
+
+    [Storable]
+    private IFixedValueParameter<IntValue> maxCloseParameter;
+    public IFixedValueParameter<IntValue> MaxCloseParameter
+    {
+      get { return maxCloseParameter; }
+      set
+      {
+        if (value == null) throw new ArgumentNullException("Max close parameter must not be null.");
+        if (value.Value == null) throw new ArgumentNullException("Max close parameter value must not be null.");
+        if (maxCloseParameter == value) return;
+
+        if (maxCloseParameter != null) Parameters.Remove(maxCloseParameter);
+        maxCloseParameter = value;
+        Parameters.Add(maxCloseParameter);
+        OnMaxCloseParameterChanged();
+      }
+    }
+
+    [Storable]
+    private IFixedValueParameter<DoubleValue> closeBiasLevelParameter;
+    public IFixedValueParameter<DoubleValue> CloseBiasLevelParameter
+    {
+      get { return closeBiasLevelParameter; }
+      set
+      {
+        if (value == null) throw new ArgumentNullException("Close bias level parameter must not be null.");
+        if (value.Value == null) throw new ArgumentNullException("Close bias level parameter value must not be null.");
+        if (closeBiasLevelParameter == value) return;
+
+        if (closeBiasLevelParameter != null) Parameters.Remove(closeBiasLevelParameter);
+        closeBiasLevelParameter = value;
+        Parameters.Add(closeBiasLevelParameter);
+        OnCloseBiasLevelParameterChanged();
+      }
+    }
+
+    [Storable]
+    private IFixedValueParameter<PercentValue> inInstructionProbabilityParameter;
+    public IFixedValueParameter<PercentValue> InInstructionProbabilityParameter
+    {
+      get { return inInstructionProbabilityParameter; }
+      set
+      {
+        if (value == null) throw new ArgumentNullException("In instruciton probability parameter must not be null.");
+        if (value.Value == null) throw new ArgumentNullException("In instruciton probability parameter value must not be null.");
+        if (inInstructionProbabilityParameter == value) return;
+
+        if (inInstructionProbabilityParameter != null) Parameters.Remove(inInstructionProbabilityParameter);
+        inInstructionProbabilityParameter = value;
+        Parameters.Add(inInstructionProbabilityParameter);
+        OnInInstructionProbabilityParameterChanged();
+      }
+    }
+
+    [Storable]
+    private IValueParameter<IExpressionsConfiguration> instructionsParameter;
+    public IValueParameter<IExpressionsConfiguration> InstructionsParameter
+    {
+      get { return instructionsParameter; }
+      set
+      {
+        if (value == null) throw new ArgumentNullException("Instructions paramter must not be null");
+        if (instructionsParameter == value) return;
+
+        if (instructionsParameter != null) Parameters.Remove(instructionsParameter);
+        instructionsParameter = value;
+        Parameters.Add(instructionsParameter);
+        OnInstructionsParameterChanged();
+      }
+    }
+
+    [Storable]
+    private IValueParameter<ErcOptions> ercOptionsParameter;
+    public IValueParameter<ErcOptions> ErcOptionsParameter
+    {
+      get { return ercOptionsParameter; }
+      set
+      {
+        if (value == null) throw new ArgumentNullException("ErcOptions paramter must not be null");
+        if (ercOptionsParameter == value) return;
+
+        if (ercOptionsParameter != null) Parameters.Remove(ercOptionsParameter);
+        ercOptionsParameter = value;
+        Parameters.Add(ercOptionsParameter);
+        OnErcOptionsParameterChanged();
+      }
+    }
+
+    public IExpressionsConfiguration Instructions
+    {
+      get { return InstructionsParameter.Value; }
+      set { InstructionsParameter.Value = value; }
+    }
+
+    public ErcOptions ErcOptions
+    {
+      get { return ErcOptionsParameter.Value; }
+      set { ErcOptionsParameter.Value = value; }
+    }
+
+    public int MinLength
+    {
+      get { return MinLengthParameter.Value.Value; }
+      set { MinLengthParameter.Value.Value = value; }
+    }
+
+    public int MaxLength
+    {
+      get { return MaxLengthParameter.Value.Value; }
+      set { MaxLengthParameter.Value.Value = value; }
+    }
+
+    public int MinClose
+    {
+      get { return MinCloseParameter.Value.Value; }
+      set { MinCloseParameter.Value.Value = value; }
+    }
+
+    public int MaxClose
+    {
+      get { return MaxCloseParameter.Value.Value; }
+      set { MaxCloseParameter.Value.Value = value; }
+    }
+
+    public double InInstructionProbability
+    {
+      get { return InInstructionProbabilityParameter.Value.Value; }
+      set { InInstructionProbabilityParameter.Value.Value = value; }
+    }
+    #endregion
+
+    #region Operator Discovery
+    private static readonly IEnumerable<Type> encodingSpecificOperatorTypes;
+    static PlushEncoding() {
+      encodingSpecificOperatorTypes = new List<Type>() {
+        typeof (IPlushOperator),
+        typeof (IPlushCreator),
+        typeof (IPlushCrossover),
+        typeof (IPlushManipulator),
+      };
+    }
+
+    private void DiscoverOperators() {
+      var assembly = typeof(IPlushOperator).Assembly;
+      var discoveredTypes = ApplicationManager.Manager.GetTypes(encodingSpecificOperatorTypes, assembly, true, false, false);
+      var operators = discoveredTypes.Select(t => (IOperator)Activator.CreateInstance(t));
+      var newOperators = operators.Except(Operators, new TypeEqualityComparer<IOperator>()).ToList();
+
+      ConfigureOperators(newOperators);
+      foreach (var @operator in newOperators)
+        AddOperator(@operator);
+    }
+    #endregion
+
     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;
-    //  }
-    //}
+      ConfigureCreators(operators.OfType<IPlushCreator>());
+      ConfigureCrossovers(operators.OfType<IPlushCrossover>());
+      ConfigureManipulators(operators.OfType<IPlushManipulator>());
+    }
+
+    private void ConfigureCreators(IEnumerable<IPlushCreator> creators) {
+      foreach (var creator in creators) {
+        creator.PlushVectorParameter.ActualName = Name;
+        creator.MinLengthParameter.ActualName = MinLengthParameter.Name;
+        creator.MaxLengthParameter.ActualName = MaxLengthParameter.Name;
+        creator.MinCloseParameter.ActualName = MinCloseParameter.Name;
+        creator.MaxCloseParameter.ActualName = MinCloseParameter.Name;
+        creator.ErcOptionsParameter.ActualName = ErcOptionsParameter.Name;
+        creator.InstructionsParameter.ActualName = InstructionsParameter.Name;
+        creator.InInstructionProbabilityParameter.ActualName = InInstructionProbabilityParameter.Name;
+      }
+    }
+
+    private void ConfigureCrossovers(IEnumerable<IPlushCrossover> crossovers) {
+      foreach (var crossover in crossovers) {
+        crossover.ChildParameter.ActualName = Name;
+        crossover.ParentsParameter.ActualName = Name;
+      }
+    }
+
+    private void ConfigureManipulators(IEnumerable<IPlushManipulator> manipulators) {
+      foreach (var manipulator in manipulators) {
+        manipulator.PlushVectorParameter.ActualName = Name;
+        manipulator.PlushVectorParameter.Hidden = true;
+
+        manipulator.ErcOptionsParameter.ActualName = ErcOptionsParameter.Name;
+        manipulator.InstructionsParameter.ActualName = InstructionsParameter.Name;
+        manipulator.InInstructionProbabilityParameter.ActualName = InInstructionProbabilityParameter.Name;
+      }
+    }
+  }
+
+  public static class IndividualExtensionMethods {
+    public static PlushVector PlushVector(this Individual individual) {
+      var encoding = individual.GetEncoding<PlushEncoding>();
+      return individual.PlushVector(encoding.Name);
+    }
+
+    public static PlushVector PlushVector(this Individual individual, string name) {
+      return (PlushVector)individual[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 15274)
+++ /branches/PushGP/HeuristicLab.PushGP/HeuristicLab.Problems.ProgramSynthesis/Push/Encoding/PlushEntry.cs	(revision 15275)
@@ -1,8 +1,27 @@
 ﻿namespace HeuristicLab.Problems.ProgramSynthesis.Push.Encoding {
+  using HeuristicLab.Common;
+  using HeuristicLab.Core;
+  using HeuristicLab.Persistence.Default.CompositeSerializers.Storable;
   using HeuristicLab.Problems.ProgramSynthesis.Push.Expressions;
 
-  public class PlushEntry {
+  [StorableClass]
+  public class PlushEntry : Item {
+    public PlushEntry() { }
+
+    public PlushEntry(bool deserializing) : base(deserializing) { }
+
+    public PlushEntry(PlushEntry origin, Cloner cloner) : base(origin, cloner) {
+      Instruction = cloner.Clone(origin.Instruction);
+      Close = origin.Close;
+    }
+
+    [Storable]
     public Expression Instruction { get; set; }
+    [Storable]
     public int Close { get; set; }
+
+    public override IDeepCloneable Clone(Cloner cloner) {
+      return new PlushEntry(this, cloner);
+    }
   }
 }
Index: /branches/PushGP/HeuristicLab.PushGP/HeuristicLab.Problems.ProgramSynthesis/Push/Encoding/PlushVector.cs
===================================================================
--- /branches/PushGP/HeuristicLab.PushGP/HeuristicLab.Problems.ProgramSynthesis/Push/Encoding/PlushVector.cs	(revision 15274)
+++ /branches/PushGP/HeuristicLab.PushGP/HeuristicLab.Problems.ProgramSynthesis/Push/Encoding/PlushVector.cs	(revision 15275)
@@ -5,13 +5,15 @@
   using HeuristicLab.Core;
   using HeuristicLab.Persistence.Default.CompositeSerializers.Storable;
+  using HeuristicLab.Problems.ProgramSynthesis.Push.Attributes;
+  using HeuristicLab.Problems.ProgramSynthesis.Push.Expressions;
 
   [StorableClass]
   public class PlushVector : Item {
 
-    private List<PlushEntry> entries;
+    [Storable]
+    private readonly List<PlushEntry> entries;
+    public IReadOnlyList<PlushEntry> Entries { get { return entries; } }
 
-    public PlushVector() : this(0) {
-
-    }
+    public PlushVector() : this(0) { }
 
     public PlushVector(int length) {
@@ -29,4 +31,85 @@
       return new PlushVector(this, cloner);
     }
+
+    private PushProgram pushProgram;
+
+    public PushProgram PushProgram
+    {
+      get
+      {
+        if (pushProgram == null) CreatePushProgram();
+        return pushProgram;
+      }
+    }
+
+    private void CreatePushProgram() {
+      var close = 0;
+      var currentIndex = 0;
+
+      pushProgram = FromPlush(ref currentIndex, ref close, 0);
+    }
+
+    private PushProgram FromPlush(
+     ref int currentIndex,
+     ref int close,
+     int depth) {
+
+      if (currentIndex >= entries.Count)
+        return PushProgram.Empty;
+
+      var instructions = new List<Expression>();
+
+      for (var i = currentIndex; i < entries.Count; i++) {
+        var entry = entries[i];
+        var instructionType = entry.Instruction.GetType();
+
+        close += entry.Close;
+
+        PushExpressionAttribute attribute;
+        if (ExpressionTable.TypeToAttributeTable.TryGetValue(instructionType, out attribute)) {
+          for (var blockIdx = 0u; blockIdx < attribute.ExecIn && currentIndex < entries.Count; blockIdx++) {
+            if (close != 0) {
+              close--;
+              instructions.Add(PushProgram.Empty);
+            } else {
+              currentIndex++;
+              var subProgram = FromPlush(ref currentIndex, ref close, depth + 1);
+              var subExpression = subProgram.Count == 1 ? subProgram.Expressions[0] : subProgram;
+
+              instructions.Add(subExpression);
+            }
+          }
+        }
+
+        instructions.Add(entry.Instruction);
+
+        if (close > 0 && depth > 0) {
+          close--;
+          break;
+        }
+
+        if (depth == 0) {
+          close = 0;
+        }
+      }
+
+      return new PushProgram(instructions);
+    }
+
+    public void UpdatePushProgram() {
+      pushProgram = null;
+    }
+
+    public void Add(PlushEntry entry) {
+      entries.Add(entry);
+    }
+
+    public PlushEntry this[int key]
+    {
+      get
+      {
+        return entries[key];
+      }
+    }
   }
 }
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 15274)
+++ /branches/PushGP/HeuristicLab.PushGP/HeuristicLab.Problems.ProgramSynthesis/Push/Generators/CodeGenerator/CodeGeneratorUtils.cs	(revision 15275)
@@ -57,4 +57,40 @@
       var name = config.EnabledExpressions[index];
       return ExpressionTable.GetExpression(name);
+    }
+
+    public static Expression GetRandomExpression(IRandom random, IReadOnlyErcOptions ercOptions, IReadOnlyExpressionsConfiguration instructions, double inInstructionProbability) {
+      var x = random.NextDouble();
+      var inInstructionRelativeProbability = ercOptions.ErcProbability + inInstructionProbability;
+
+      Expression expression;
+
+      if (ercOptions.ErcProbability > 0 && x <= ercOptions.ErcProbability) {
+        var stackType = instructions.ExpressionsPerStackCount.RandomWeightedOrDefault(random, pair => pair.Value).Key;
+
+        expression = stackType == default(StackTypes)
+          ? GetRandomExpression(random, instructions)
+          : CreateRandomErcExpression(stackType, random, ercOptions);
+      } else if (
+        inInstructionProbability > 0 &&
+        x <= inInstructionRelativeProbability &&
+        instructions.InExpressionCount > 0) {
+
+        var nr = random.Next(0, instructions.InExpressionCount) + 1;
+        expression = ExpressionTable.InExpressionTable[nr];
+      } else {
+        expression = GetRandomExpression(random, instructions);
+      }
+
+      return expression;
+    }
+
+    private static Expression GetRandomExpression(
+      IRandom random,
+      IReadOnlyExpressionsConfiguration instructionsConfig) {
+      var index = random.Next(0, instructionsConfig.EnabledExpressions.Count);
+      var expressionName = instructionsConfig.EnabledExpressions[index];
+      var expression = ExpressionTable.GetExpression(expressionName);
+
+      return expression;
     }
 
Index: /branches/PushGP/HeuristicLab.PushGP/HeuristicLab.Problems.ProgramSynthesis/Push/Manipulator/IPlushManipulator.cs
===================================================================
--- /branches/PushGP/HeuristicLab.PushGP/HeuristicLab.Problems.ProgramSynthesis/Push/Manipulator/IPlushManipulator.cs	(revision 15275)
+++ /branches/PushGP/HeuristicLab.PushGP/HeuristicLab.Problems.ProgramSynthesis/Push/Manipulator/IPlushManipulator.cs	(revision 15275)
@@ -0,0 +1,15 @@
+﻿namespace HeuristicLab.Problems.ProgramSynthesis.Push.Manipulator {
+  using HeuristicLab.Core;
+  using HeuristicLab.Data;
+  using HeuristicLab.Optimization;
+  using HeuristicLab.Problems.ProgramSynthesis.Base.Erc;
+  using HeuristicLab.Problems.ProgramSynthesis.Push.Configuration;
+  using HeuristicLab.Problems.ProgramSynthesis.Push.Encoding;
+
+  public interface IPlushManipulator : IPlushOperator, IManipulator {
+    IValueLookupParameter<PercentValue> InInstructionProbabilityParameter { get; }
+    IValueLookupParameter<IReadOnlyErcOptions> ErcOptionsParameter { get; }
+    IValueLookupParameter<IReadOnlyExpressionsConfiguration> InstructionsParameter { get; }
+    ILookupParameter<PlushVector> PlushVectorParameter { get; }
+  }
+}
Index: /branches/PushGP/HeuristicLab.PushGP/HeuristicLab.Problems.ProgramSynthesis/Push/Manipulator/UniformMutation.cs
===================================================================
--- /branches/PushGP/HeuristicLab.PushGP/HeuristicLab.Problems.ProgramSynthesis/Push/Manipulator/UniformMutation.cs	(revision 15275)
+++ /branches/PushGP/HeuristicLab.PushGP/HeuristicLab.Problems.ProgramSynthesis/Push/Manipulator/UniformMutation.cs	(revision 15275)
@@ -0,0 +1,132 @@
+﻿namespace HeuristicLab.Problems.ProgramSynthesis.Push.Manipulator {
+  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.Base.Erc;
+  using HeuristicLab.Problems.ProgramSynthesis.Push.Configuration;
+  using HeuristicLab.Problems.ProgramSynthesis.Push.Encoding;
+  using HeuristicLab.Problems.ProgramSynthesis.Push.Generators.CodeGenerator;
+  using HeuristicLab.Random;
+
+  /// <summary>
+  /// Uniformly distributed change of a single position of an integer vector.
+  /// </summary>
+  [Item("UniformMutation", " Uniformly distributed change of a single position of an plush vector.")]
+  [StorableClass]
+  public class UniformMutation : InstrumentedOperator, IPlushManipulator, IStochasticOperator {
+
+    public UniformMutation() {
+      Parameters.Add(new LookupParameter<IRandom>("Random", "The pseudo random number generator which should be used for stochastic manipulation operators."));
+      Parameters.Add(new LookupParameter<PlushVector>("PlushVector", "The vector which should be manipulated."));
+      Parameters.Add(new ValueLookupParameter<IntValue>("MinLength", "The min length of the vector."));
+      Parameters.Add(new ValueLookupParameter<IntValue>("MaxLength", "The max length of the vector."));
+      Parameters.Add(new ValueLookupParameter<IReadOnlyExpressionsConfiguration>("Instructions", "The enabled instructions"));
+      Parameters.Add(new ValueLookupParameter<IReadOnlyErcOptions>("ErcOptions", "ERC options"));
+      Parameters.Add(new ValueLookupParameter<PercentValue>("InInstructionProbability", "The probability of IN Instructions"));
+
+      Parameters.Add(new FixedValueParameter<PercentValue>("InstructionMutationProbability", "The probability a value gets mutated", new PercentValue(0.02)));
+      Parameters.Add(new FixedValueParameter<DoubleValue>("CloseMutationDeviation", "When mutating individual, the amount of which the close marker is incremented or decrement is based on a random sample from a normal distribution with mean 0 and standard deviation set by the close mutation deviation parameter", new DoubleValue(1.0)));
+    }
+
+    public UniformMutation(bool deserializing) : base(deserializing) {
+    }
+
+    public UniformMutation(UniformMutation origin, Cloner cloner) : base(origin, cloner) {
+    }
+
+    public IValueParameter<PercentValue> InstructionMutationProbabilityParameter
+    {
+      get { return (IValueParameter<PercentValue>)Parameters["InstructionMutationProbability"]; }
+    }
+
+    public double InstructionMutationProbability
+    {
+      get { return InstructionMutationProbabilityParameter.Value.Value; }
+      set { InstructionMutationProbabilityParameter.Value.Value = value; }
+    }
+
+    public IValueParameter<PercentValue> CloseMutationDeviationParameter
+    {
+      get { return (IValueParameter<PercentValue>)Parameters["CloseMutationDeviation"]; }
+    }
+
+    public double CloseMutationDeviation
+    {
+      get { return CloseMutationDeviationParameter.Value.Value; }
+      set { CloseMutationDeviationParameter.Value.Value = value; }
+    }
+
+    public override bool CanChangeName
+    {
+      get { return false; }
+    }
+    public ILookupParameter<IRandom> RandomParameter
+    {
+      get { return (LookupParameter<IRandom>)Parameters["Random"]; }
+    }
+    public ILookupParameter<PlushVector> PlushVectorParameter
+    {
+      get { return (ILookupParameter<PlushVector>)Parameters["PlushVector"]; }
+    }
+    public IValueLookupParameter<IntValue> MinLengthParameter
+    {
+      get { return (IValueLookupParameter<IntValue>)Parameters["MinLength"]; }
+    }
+    public IValueLookupParameter<IntValue> MaxLengthParameter
+    {
+      get { return (IValueLookupParameter<IntValue>)Parameters["MaxLength"]; }
+    }
+    public IValueLookupParameter<IReadOnlyExpressionsConfiguration> InstructionsParameter
+    {
+      get { return (IValueLookupParameter<IReadOnlyExpressionsConfiguration>)Parameters["Instructions"]; }
+    }
+    public IValueLookupParameter<IReadOnlyErcOptions> ErcOptionsParameter
+    {
+      get { return (IValueLookupParameter<IReadOnlyErcOptions>)Parameters["ErcOptions"]; }
+    }
+    public IValueLookupParameter<PercentValue> InInstructionProbabilityParameter
+    {
+      get { return (IValueLookupParameter<PercentValue>)Parameters["InInstructionProbability"]; }
+    }
+
+    public override IDeepCloneable Clone(Cloner cloner) {
+      return new UniformMutation(this, cloner);
+    }
+
+    public sealed override IOperation InstrumentedApply() {
+      Manipulate(RandomParameter.ActualValue, PlushVectorParameter.ActualValue);
+      return base.InstrumentedApply();
+    }
+
+    private void Manipulate(IRandom random, PlushVector plushVector) {
+      var normalDistributedRandom = new NormalDistributedRandom(random, 0, CloseMutationDeviation);
+      var ercOptions = ErcOptionsParameter.ActualValue;
+      var instructions = InstructionsParameter.ActualValue;
+      var inInstructionProbability = InInstructionProbabilityParameter.ActualValue.Value;
+      var instructionMutationProbability = InstructionMutationProbability;
+
+      for (var i = 0; i < plushVector.Entries.Count; i++) {
+        var entry = plushVector[i];
+        var x = random.NextDouble();
+
+        if (x < instructionMutationProbability) {
+          var instruction = CodeGeneratorUtils.GetRandomExpression(
+            random,
+            ercOptions,
+            instructions,
+            inInstructionProbability);
+          entry.Instruction = instruction;
+        }
+
+        entry.Close += normalDistributedRandom.Next();
+      }
+
+      // specifies that the program cached within entry must be updated before reuse
+      plushVector.UpdatePushProgram();
+    }
+  }
+}
Index: /branches/PushGP/HeuristicLab.PushGP/HeuristicLab.Problems.ProgramSynthesis/Push/Problem/BenchmarkSuite/IntegerVectorPushBenchmarkSuiteProblem.cs
===================================================================
--- /branches/PushGP/HeuristicLab.PushGP/HeuristicLab.Problems.ProgramSynthesis/Push/Problem/BenchmarkSuite/IntegerVectorPushBenchmarkSuiteProblem.cs	(revision 15275)
+++ /branches/PushGP/HeuristicLab.PushGP/HeuristicLab.Problems.ProgramSynthesis/Push/Problem/BenchmarkSuite/IntegerVectorPushBenchmarkSuiteProblem.cs	(revision 15275)
@@ -0,0 +1,72 @@
+﻿namespace HeuristicLab.Problems.ProgramSynthesis.Push.Problem.BenchmarkSuite {
+
+  using Common;
+  using Configuration;
+  using Core;
+
+  using HeuristicLab.BenchmarkSuite;
+  using HeuristicLab.BenchmarkSuite.Problems;
+  using HeuristicLab.Problems.ProgramSynthesis.Push.Expressions;
+
+  using Instances;
+  using Persistence.Default.CompositeSerializers.Storable;
+  using Stack;
+
+  [StorableClass]
+  [Creatable(CreatableAttribute.Categories.GeneticProgrammingProblems, Priority = 180)]
+  [Item("Integer Vector Push Problem", "")]
+  public class IntegerVectorPushBenchmarkSuiteProblem : IntegerVectorPushProblem, IProblemInstanceConsumer<ProblemData> {
+    public IntegerVectorPushBenchmarkSuiteProblem() : base(new PushBenchmarkSuiteEvaluator()) {
+      Parameters.Add(PushEvaluator.DataParameter);
+      Parameters.Add(PushEvaluator.DataBoundsParameter);
+
+      if (PushEvaluator.Data == null) {
+        var defaultProblem = new NumberIO();
+        Load(defaultProblem.CreateProblemData());
+      }
+    }
+
+    [StorableConstructor]
+    protected IntegerVectorPushBenchmarkSuiteProblem(bool deserializing)
+      : base(deserializing) {
+    }
+
+    protected IntegerVectorPushBenchmarkSuiteProblem(IntegerVectorPushBenchmarkSuiteProblem original, Cloner cloner)
+      : base(original, cloner) {
+    }
+
+    public override IDeepCloneable Clone(Cloner cloner) {
+      return new IntegerVectorPushBenchmarkSuiteProblem(this, cloner);
+    }
+
+    public new PushBenchmarkSuiteEvaluator PushEvaluator { get { return (PushBenchmarkSuiteEvaluator)base.PushEvaluator; } }
+
+    public void Load(ProblemData data) {
+      PushEvaluator.LoadData(data);
+
+      Name = "Push Problem: " + data.Name;
+      Description = data.Description;
+      BestKnownQuality = data.BestResult;
+      Config.MaxPointsInProgram = data.MaxSize;
+      Config.EvalPushLimit = data.EvalLimit;
+      Config.ErcOptions = data.ErcOptions;
+      Config.FloatStringFormat = data.FloatStringFormat;
+
+      Config.SetEnabledStacks((StackTypes)data.EnabledDataTypes);
+      Config.InitInExpressions(data.TotalInputArgumentCount);
+
+      Encoding.Bounds[0, 0] = 0;
+      Encoding.Bounds[0, 1] = Config.EnabledExpressions.Count;
+
+      Encoding.Length = data.MaxSize;
+    }
+
+    protected override PushSolution CreatePushSolution(
+      PushProgram program,
+      double bestQuality,
+      IRandom random,
+      IReadOnlyPushConfiguration config) {
+      return new PushBenchmarkSuiteSolution(program, bestQuality, random, config, (PushBenchmarkSuiteEvaluator)PushEvaluator.Clone());
+    }
+  }
+}
Index: /branches/PushGP/HeuristicLab.PushGP/HeuristicLab.Problems.ProgramSynthesis/Push/Problem/BenchmarkSuite/PlushPushBenchmarkSuiteProblem.cs
===================================================================
--- /branches/PushGP/HeuristicLab.PushGP/HeuristicLab.Problems.ProgramSynthesis/Push/Problem/BenchmarkSuite/PlushPushBenchmarkSuiteProblem.cs	(revision 15275)
+++ /branches/PushGP/HeuristicLab.PushGP/HeuristicLab.Problems.ProgramSynthesis/Push/Problem/BenchmarkSuite/PlushPushBenchmarkSuiteProblem.cs	(revision 15275)
@@ -0,0 +1,66 @@
+﻿namespace HeuristicLab.Problems.ProgramSynthesis.Push.Problem.BenchmarkSuite {
+  using HeuristicLab.BenchmarkSuite;
+  using HeuristicLab.BenchmarkSuite.Problems;
+  using HeuristicLab.Common;
+  using HeuristicLab.Core;
+  using HeuristicLab.Persistence.Default.CompositeSerializers.Storable;
+  using HeuristicLab.Problems.Instances;
+  using HeuristicLab.Problems.ProgramSynthesis.Push.Configuration;
+  using HeuristicLab.Problems.ProgramSynthesis.Push.Expressions;
+  using HeuristicLab.Problems.ProgramSynthesis.Push.Stack;
+
+  [StorableClass]
+  [Creatable(CreatableAttribute.Categories.GeneticProgrammingProblems, Priority = 180)]
+  [Item("Plush Push Problem", "")]
+  public class PlushPushBenchmarkSuiteProblem : PlushPushProblem, IProblemInstanceConsumer<ProblemData> {
+    public PlushPushBenchmarkSuiteProblem() : base(new PushBenchmarkSuiteEvaluator()) {
+      Parameters.Add(PushEvaluator.DataParameter);
+      Parameters.Add(PushEvaluator.DataBoundsParameter);
+
+      if (PushEvaluator.Data == null) {
+        var defaultProblem = new NumberIO();
+        Load(defaultProblem.CreateProblemData());
+      }
+    }
+
+    [StorableConstructor]
+    protected PlushPushBenchmarkSuiteProblem(bool deserializing)
+      : base(deserializing) {
+    }
+
+    protected PlushPushBenchmarkSuiteProblem(PlushPushBenchmarkSuiteProblem original, Cloner cloner)
+      : base(original, cloner) {
+    }
+
+    public override IDeepCloneable Clone(Cloner cloner) {
+      return new PlushPushBenchmarkSuiteProblem(this, cloner);
+    }
+
+    public new PushBenchmarkSuiteEvaluator PushEvaluator { get { return (PushBenchmarkSuiteEvaluator)base.PushEvaluator; } }
+
+    public void Load(ProblemData data) {
+      PushEvaluator.LoadData(data);
+
+      Name = "Push Problem: " + data.Name;
+      Description = data.Description;
+      BestKnownQuality = data.BestResult;
+      Config.MaxPointsInProgram = data.MaxSize;
+      Config.EvalPushLimit = data.EvalLimit;
+      Config.ErcOptions = data.ErcOptions;
+      Config.FloatStringFormat = data.FloatStringFormat;
+
+      Config.SetEnabledStacks((StackTypes)data.EnabledDataTypes);
+      Config.InitInExpressions(data.TotalInputArgumentCount);
+
+      Encoding.MaxLength = data.MaxSize;
+    }
+
+    protected override PushSolution CreatePushSolution(
+      PushProgram program,
+      double bestQuality,
+      IRandom random,
+      IReadOnlyPushConfiguration config) {
+      return new PushBenchmarkSuiteSolution(program, bestQuality, random, config, (PushBenchmarkSuiteEvaluator)PushEvaluator.Clone());
+    }
+  }
+}
Index: anches/PushGP/HeuristicLab.PushGP/HeuristicLab.Problems.ProgramSynthesis/Push/Problem/BenchmarkSuite/PushBenchmarkSuiteProblem.cs
===================================================================
--- /branches/PushGP/HeuristicLab.PushGP/HeuristicLab.Problems.ProgramSynthesis/Push/Problem/BenchmarkSuite/PushBenchmarkSuiteProblem.cs	(revision 15274)
+++ 	(revision )
@@ -1,72 +1,0 @@
-﻿namespace HeuristicLab.Problems.ProgramSynthesis.Push.Problem.BenchmarkSuite {
-
-  using Common;
-  using Configuration;
-  using Core;
-
-  using HeuristicLab.BenchmarkSuite;
-  using HeuristicLab.BenchmarkSuite.Problems;
-  using HeuristicLab.Problems.ProgramSynthesis.Push.Expressions;
-
-  using Instances;
-  using Persistence.Default.CompositeSerializers.Storable;
-  using Stack;
-
-  [StorableClass]
-  [Creatable(CreatableAttribute.Categories.GeneticProgrammingProblems, Priority = 180)]
-  [Item("Push Problem", "")]
-  public class PushBenchmarkSuiteProblem : PushProblem, IProblemInstanceConsumer<ProblemData> {
-    public PushBenchmarkSuiteProblem() : base(new PushBenchmarkSuiteEvaluator()) {
-      Parameters.Add(PushEvaluator.DataParameter);
-      Parameters.Add(PushEvaluator.DataBoundsParameter);
-
-      if (PushEvaluator.Data == null) {
-        var defaultProblem = new NumberIO();
-        Load(defaultProblem.CreateProblemData());
-      }
-    }
-
-    [StorableConstructor]
-    protected PushBenchmarkSuiteProblem(bool deserializing)
-      : base(deserializing) {
-    }
-
-    protected PushBenchmarkSuiteProblem(PushBenchmarkSuiteProblem original, Cloner cloner)
-      : base(original, cloner) {
-    }
-
-    public override IDeepCloneable Clone(Cloner cloner) {
-      return new PushBenchmarkSuiteProblem(this, cloner);
-    }
-
-    public new PushBenchmarkSuiteEvaluator PushEvaluator { get { return (PushBenchmarkSuiteEvaluator)base.PushEvaluator; } }
-
-    public void Load(ProblemData data) {
-      PushEvaluator.LoadData(data);
-
-      Name = "Push Problem: " + data.Name;
-      Description = data.Description;
-      BestKnownQuality = data.BestResult;
-      Config.MaxPointsInProgram = data.MaxSize;
-      Config.EvalPushLimit = data.EvalLimit;
-      Config.ErcOptions = data.ErcOptions;
-      Config.FloatStringFormat = data.FloatStringFormat;
-
-      Config.SetEnabledStacks((StackTypes)data.EnabledDataTypes);
-      Config.InitInExpressions(data.TotalInputArgumentCount);
-
-      Encoding.Bounds[0, 0] = 0;
-      Encoding.Bounds[0, 1] = Config.EnabledExpressions.Count;
-
-      Encoding.Length = data.MaxSize;
-    }
-
-    protected override PushSolution CreatePushSolution(
-      PushProgram program,
-      double bestQuality,
-      IRandom random,
-      IReadOnlyPushConfiguration config) {
-      return new PushBenchmarkSuiteSolution(program, bestQuality, random, config, (PushBenchmarkSuiteEvaluator)PushEvaluator.Clone());
-    }
-  }
-}
Index: /branches/PushGP/HeuristicLab.PushGP/HeuristicLab.Problems.ProgramSynthesis/Push/Problem/IntegerVectorPushProblem.cs
===================================================================
--- /branches/PushGP/HeuristicLab.PushGP/HeuristicLab.Problems.ProgramSynthesis/Push/Problem/IntegerVectorPushProblem.cs	(revision 15275)
+++ /branches/PushGP/HeuristicLab.PushGP/HeuristicLab.Problems.ProgramSynthesis/Push/Problem/IntegerVectorPushProblem.cs	(revision 15275)
@@ -0,0 +1,107 @@
+﻿namespace HeuristicLab.Problems.ProgramSynthesis.Push.Problem {
+  using System.Linq;
+
+  using Common;
+  using Configuration;
+  using Core;
+  using HeuristicLab.Data;
+  using HeuristicLab.Encodings.IntegerVectorEncoding;
+  using HeuristicLab.Problems.ProgramSynthesis.Push.Analyzer;
+  using HeuristicLab.Problems.ProgramSynthesis.Push.Expressions;
+  using HeuristicLab.Problems.ProgramSynthesis.Push.Individual;
+  using HeuristicLab.Problems.ProgramSynthesis.Push.SolutionCreator;
+  using Optimization;
+  using Persistence.Default.CompositeSerializers.Storable;
+
+  [StorableClass]
+  public abstract class IntegerVectorPushProblem : PushProblemBase<IntegerVectorEncoding> {
+    protected IntegerVectorPushProblem(IPushEvaluator evaluator) : base(evaluator) {
+      InitEvents();
+      InitEncoding();
+      InitOperators();
+    }
+
+    [StorableConstructor]
+    protected IntegerVectorPushProblem(bool deserializing)
+      : base(deserializing) {
+    }
+
+    protected IntegerVectorPushProblem(IntegerVectorPushProblem original, Cloner cloner)
+      : base(original, cloner) {
+      InitEvents();
+    }
+
+    [StorableHook(HookType.AfterDeserialization)]
+    // ReSharper disable once UnusedMember.Local
+    private void AfterDeserialization() {
+      InitEvents();
+    }
+
+    private void InitEvents() {
+      Config.EnabledExpressionsChanged += EnabledExpressionsChanged;
+    }
+
+    private void EnabledExpressionsChanged(object sender, EnabledExpressionsChangedEventArgs e) {
+      Encoding.Bounds[0, 1] = Config.EnabledExpressions.Count;
+      Encoding.BoundsParameter.Value[0, 1] = Config.EnabledExpressions.Count;
+    }
+
+    //protected override void OnReset() {
+    //  base.OnReset();
+
+    //  // clear pools and free reserved memory
+    //  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;
+    }
+
+    private void InitOperators() {
+
+      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;
+    }
+
+    protected override PushProgram MapIndividual(Individual individual, IRandom random) {
+      var program = individual.ToPushProgram(Config, random);
+
+      return program;
+    }
+
+    public override double Evaluate(Individual individual, IRandom random) {
+      // init seed of random pool
+      //Interlocked.CompareExchange(ref RandomPool.Seed, random.Next(), 0);
+      //Config.Seed = RandomPool.Seed;
+
+      //var rand = RandomPool.ResetAndAllocate();
+      var program = MapIndividual(individual, random);
+      //RandomPool.Free(rand);
+
+      //rand = RandomPool.ResetAndAllocate();
+      var result = PushEvaluator.EvaluateTraining(Pool, program, random);
+      //RandomPool.Free(rand);
+
+      individual[CaseQualitiesScopeParameterName] = new DoubleArray(result.ExampleQualities);
+
+      return result.AvgQuality;
+    }
+  }
+}
Index: /branches/PushGP/HeuristicLab.PushGP/HeuristicLab.Problems.ProgramSynthesis/Push/Problem/PlushPushProblem.cs
===================================================================
--- /branches/PushGP/HeuristicLab.PushGP/HeuristicLab.Problems.ProgramSynthesis/Push/Problem/PlushPushProblem.cs	(revision 15275)
+++ /branches/PushGP/HeuristicLab.PushGP/HeuristicLab.Problems.ProgramSynthesis/Push/Problem/PlushPushProblem.cs	(revision 15275)
@@ -0,0 +1,61 @@
+﻿namespace HeuristicLab.Problems.ProgramSynthesis.Push.Problem {
+  using System.Linq;
+
+  using HeuristicLab.Common;
+  using HeuristicLab.Core;
+  using HeuristicLab.Data;
+  using HeuristicLab.Optimization;
+  using HeuristicLab.Persistence.Default.CompositeSerializers.Storable;
+  using HeuristicLab.Problems.ProgramSynthesis.Push.Analyzer;
+  using HeuristicLab.Problems.ProgramSynthesis.Push.Encoding;
+  using HeuristicLab.Problems.ProgramSynthesis.Push.Expressions;
+
+  [StorableClass]
+  public abstract class PlushPushProblem : PushProblemBase<PlushEncoding> {
+    protected PlushPushProblem(IPushEvaluator evaluator)
+      : base(evaluator) {
+      InitEncoding();
+      InitOperators();
+    }
+
+    protected PlushPushProblem(bool deserializing)
+      : base(deserializing) {
+    }
+
+    protected PlushPushProblem(PushProblemBase<PlushEncoding> original, Cloner cloner)
+      : base(original, cloner) {
+    }
+
+    private void InitEncoding() {
+      Encoding.ErcOptionsParameter = Config.ErcOptionsParameter;
+      Encoding.InstructionsParameter = Config.InstructionsParameter;
+      Encoding.MaxLength = Config.MaxPointsInProgram;
+    }
+
+    private void InitOperators() {
+      if (!Operators.OfType<PushExpressionFrequencyAnalyzer>().Any()) {
+        Operators.Add(new PushExpressionFrequencyAnalyzer());
+      }
+
+      if (!Operators.OfType<IndividualZeroErrorAnalyzer>().Any()) {
+        Operators.Add(new IndividualZeroErrorAnalyzer());
+      }
+    }
+
+    protected override PushProgram MapIndividual(Individual individual, IRandom random) {
+      var plushVector = individual.PlushVector();
+      var program = plushVector.PushProgram;
+
+      return program;
+    }
+
+    public override double Evaluate(Individual individual, IRandom random) {
+      var program = MapIndividual(individual, random);
+      var result = PushEvaluator.EvaluateTraining(Pool, program, random);
+
+      individual[CaseQualitiesScopeParameterName] = new DoubleArray(result.ExampleQualities);
+
+      return result.AvgQuality;
+    }
+  }
+}
Index: anches/PushGP/HeuristicLab.PushGP/HeuristicLab.Problems.ProgramSynthesis/Push/Problem/PushProblem.cs
===================================================================
--- /branches/PushGP/HeuristicLab.PushGP/HeuristicLab.Problems.ProgramSynthesis/Push/Problem/PushProblem.cs	(revision 15274)
+++ 	(revision )
@@ -1,236 +1,0 @@
-﻿using System;
-
-namespace HeuristicLab.Problems.ProgramSynthesis.Push.Problem {
-  using System.Linq;
-
-  using Common;
-  using Configuration;
-  using Core;
-  using HeuristicLab.Data;
-  using HeuristicLab.Encodings.IntegerVectorEncoding;
-  using HeuristicLab.Problems.ProgramSynthesis.Push.Analyzer;
-  using HeuristicLab.Problems.ProgramSynthesis.Push.Expressions;
-  using HeuristicLab.Problems.ProgramSynthesis.Push.Individual;
-  using HeuristicLab.Problems.ProgramSynthesis.Push.ObjectPools.Random;
-  using HeuristicLab.Problems.ProgramSynthesis.Push.SolutionCreator;
-
-  using Interpreter;
-  using Optimization;
-  using Parameters;
-  using Persistence.Default.CompositeSerializers.Storable;
-
-  [StorableClass]
-  public abstract class PushProblem : SingleObjectiveBasicProblem<IntegerVectorEncoding> {
-    [Storable]
-    protected readonly PushConfigurationParameterCollection Config;
-
-    protected PushInterpreterPool Pool;
-    protected readonly SeededRandomPool RandomPool = new SeededRandomPool();
-
-    [Storable]
-    protected readonly IPushEvaluator PushEvaluator;
-
-    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;
-
-      InitData();
-      InitEvents();
-      InitParameters();
-      InitEncoding();
-      InitOperators();
-    }
-
-    [StorableConstructor]
-    protected PushProblem(bool deserializing)
-      : base(deserializing) {
-    }
-
-    protected PushProblem(PushProblem original, Cloner cloner)
-      : base(original, cloner) {
-      Config = cloner.Clone(original.Config);
-      PushEvaluator = cloner.Clone(original.PushEvaluator);
-
-      InitData();
-      InitEvents();
-    }
-
-    [StorableHook(HookType.AfterDeserialization)]
-    // ReSharper disable once UnusedMember.Local
-    private void AfterDeserialization() {
-      InitData();
-      InitEvents();
-      InitParameters();
-    }
-
-    private void InitData() {
-      Pool = new PushInterpreterPool(Environment.ProcessorCount * 2, 4096, 1024, Config);
-    }
-
-    private void InitEvents() {
-      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;
-    }
-
-    private const string PUSH_CONFIGURATION_PARAMETER_NAME = "PushConfiguration";
-
-    public const string CasesScopeParameterName = "CaseQualities";
-    public const string CaseQualitiesScopeParameterName = "CaseQualities";
-
-    private void InitParameters() {
-      foreach (var paramater in Config.Parameters) {
-        if (!Parameters.ContainsKey(paramater.Name)) {
-          Parameters.Add(paramater);
-        }
-      }
-
-      if (!Parameters.ContainsKey(PUSH_CONFIGURATION_PARAMETER_NAME))
-        Parameters.Add(new ValueParameter<IReadOnlyPushConfiguration>(PUSH_CONFIGURATION_PARAMETER_NAME, Config) {
-          Hidden = true
-        });
-
-      if (!Parameters.ContainsKey(CasesScopeParameterName))
-        Parameters.Add(new LookupParameter<BoolArray>(CasesScopeParameterName, "The training cases that have been successfully executed."));
-
-      if (!Parameters.ContainsKey(CaseQualitiesScopeParameterName))
-        Parameters.Add(new LookupParameter<DoubleArray>(CaseQualitiesScopeParameterName, "The quality of every single training case for each individual"));
-    }
-
-    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();
-      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;
-    }
-
-    private void InitOperators() {
-
-      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; } }
-
-    public override void Analyze(Individual[] individuals, double[] qualities, ResultCollection results, IRandom random) {
-      IndividualMapper.Reset();
-
-      var bestQuality = Maximization ? qualities.Max() : qualities.Min();
-      var bestIdx = Array.IndexOf(qualities, bestQuality);
-      var vector = individuals[bestIdx].IntegerVector();
-
-      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 = RandomPool.ResetAndAllocate();
-        AnalyzeBestTestSolution(program, results, rand);
-        RandomPool.Free(rand);
-      }
-    }
-
-    private void AnalyzeBestTestSolution(PushProgram program, ResultCollection results, IRandom random) {
-      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[TEST_QUALITY_RESULT_NAME].Value).Value = testResult.AvgQuality;
-      }
-    }
-
-    private bool AnalyzeBestTrainingSolution(PushProgram program, double bestQuality, ResultCollection results, IRandom random) {
-      if (!results.ContainsKey(BEST_TRAINING_SOLUTION_RESULT_NAME)) {
-        var solution = CreatePushSolution(
-            program,
-            bestQuality,
-            (IRandom)random.Clone(),
-            (IReadOnlyPushConfiguration)Config.Clone());
-
-        results.Add(new Result(BEST_TRAINING_SOLUTION_RESULT_NAME, solution));
-        return true;
-      }
-
-      var currentBestQuality = ((PushSolution)results[BEST_TRAINING_SOLUTION_RESULT_NAME].Value).Quality;
-
-      if ((!Maximization && currentBestQuality > bestQuality) ||
-           (Maximization && currentBestQuality < bestQuality)) {
-        results[BEST_TRAINING_SOLUTION_RESULT_NAME].Value = CreatePushSolution(
-            program,
-            bestQuality,
-            random,
-            Config);
-        return true;
-      }
-
-      return false;
-    }
-
-    protected abstract PushSolution CreatePushSolution(
-      PushProgram program,
-      double bestQuality,
-      IRandom random,
-      IReadOnlyPushConfiguration config);
-
-    public override double Evaluate(Individual individual, IRandom random) {
-      // init seed of random pool
-      //Interlocked.CompareExchange(ref RandomPool.Seed, random.Next(), 0);
-      //Config.Seed = RandomPool.Seed;
-
-      //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);
-
-      return result.AvgQuality;
-    }
-  }
-}
Index: /branches/PushGP/HeuristicLab.PushGP/HeuristicLab.Problems.ProgramSynthesis/Push/Problem/PushProblemBase.cs
===================================================================
--- /branches/PushGP/HeuristicLab.PushGP/HeuristicLab.Problems.ProgramSynthesis/Push/Problem/PushProblemBase.cs	(revision 15275)
+++ /branches/PushGP/HeuristicLab.PushGP/HeuristicLab.Problems.ProgramSynthesis/Push/Problem/PushProblemBase.cs	(revision 15275)
@@ -0,0 +1,153 @@
+﻿using System;
+using System.Linq;
+
+namespace HeuristicLab.Problems.ProgramSynthesis.Push.Problem {
+  using HeuristicLab.Common;
+  using HeuristicLab.Core;
+  using HeuristicLab.Data;
+  using HeuristicLab.Optimization;
+  using HeuristicLab.Parameters;
+  using HeuristicLab.Persistence.Default.CompositeSerializers.Storable;
+  using HeuristicLab.Problems.ProgramSynthesis.Push.Configuration;
+  using HeuristicLab.Problems.ProgramSynthesis.Push.Expressions;
+  using HeuristicLab.Problems.ProgramSynthesis.Push.Interpreter;
+  using HeuristicLab.Problems.ProgramSynthesis.Push.ObjectPools.Random;
+
+  [StorableClass]
+  public abstract class PushProblemBase<T> : SingleObjectiveBasicProblem<T> where T : class, IEncoding {
+    [Storable]
+    protected readonly PushConfigurationParameterCollection Config;
+
+    protected PushInterpreterPool Pool;
+    protected readonly SeededRandomPool RandomPool = new SeededRandomPool();
+
+    [Storable]
+    protected readonly IPushEvaluator PushEvaluator;
+
+    private const string BEST_TRAINING_SOLUTION_RESULT_NAME = "Best Solution";
+    private const string TEST_QUALITY_RESULT_NAME = "Test Quality";
+    private const string PUSH_CONFIGURATION_PARAMETER_NAME = "PushConfiguration";
+
+    public const string CasesScopeParameterName = "CaseQualities";
+    public const string CaseQualitiesScopeParameterName = "CaseQualities";
+
+    protected PushProblemBase(IPushEvaluator evaluator) {
+      Config = new PushConfigurationParameterCollection();
+      PushEvaluator = evaluator;
+
+      InitData();
+      InitParameters();
+    }
+
+    [StorableConstructor]
+    protected PushProblemBase(bool deserializing)
+      : base(deserializing) {
+    }
+
+    protected PushProblemBase(PushProblemBase<T> original, Cloner cloner)
+      : base(original, cloner) {
+      Config = cloner.Clone(original.Config);
+      PushEvaluator = cloner.Clone(original.PushEvaluator);
+
+      InitData();
+    }
+
+    [StorableHook(HookType.AfterDeserialization)]
+    // ReSharper disable once UnusedMember.Local
+    private void AfterDeserialization() {
+      InitData();
+      InitParameters();
+    }
+
+    private void InitData() {
+      Pool = new PushInterpreterPool(Environment.ProcessorCount * 2, 4096, 1024, Config);
+    }
+
+    private void InitParameters() {
+      foreach (var paramater in Config.Parameters) {
+        if (!Parameters.ContainsKey(paramater.Name)) {
+          Parameters.Add(paramater);
+        }
+      }
+
+      if (!Parameters.ContainsKey(PUSH_CONFIGURATION_PARAMETER_NAME))
+        Parameters.Add(new ValueParameter<IReadOnlyPushConfiguration>(PUSH_CONFIGURATION_PARAMETER_NAME, Config) {
+          Hidden = true
+        });
+
+      if (!Parameters.ContainsKey(CasesScopeParameterName))
+        Parameters.Add(new LookupParameter<BoolArray>(CasesScopeParameterName, "The training cases that have been successfully executed."));
+
+      if (!Parameters.ContainsKey(CaseQualitiesScopeParameterName))
+        Parameters.Add(new LookupParameter<DoubleArray>(CaseQualitiesScopeParameterName, "The quality of every single training case for each individual"));
+    }
+
+    public override bool Maximization { get { return false; } }
+
+    public override void Analyze(Individual[] individuals, double[] qualities, ResultCollection results, IRandom random) {
+      var bestQuality = Maximization ? qualities.Max() : qualities.Min();
+      var bestIdx = Array.IndexOf(qualities, bestQuality);
+      var program = MapIndividual(individuals[bestIdx], random);
+
+      var isIndividualBetter = AnalyzeBestTrainingSolution(program, bestQuality, results, random);
+
+      if (isIndividualBetter) {
+        AnalyzeBestTestSolution(program, results, random);
+      }
+    }
+
+    protected void AnalyzeBestTestSolution(PushProgram program, ResultCollection results, IRandom random) {
+      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[TEST_QUALITY_RESULT_NAME].Value).Value = testResult.AvgQuality;
+      }
+    }
+
+    protected bool AnalyzeBestTrainingSolution(PushProgram program, double bestQuality, ResultCollection results, IRandom random) {
+      if (!results.ContainsKey(BEST_TRAINING_SOLUTION_RESULT_NAME)) {
+        var solution = CreatePushSolution(
+            program,
+            bestQuality,
+            (IRandom)random.Clone(),
+            (IReadOnlyPushConfiguration)Config.Clone());
+
+        results.Add(new Result(BEST_TRAINING_SOLUTION_RESULT_NAME, solution));
+        return true;
+      }
+
+      var currentBestQuality = ((PushSolution)results[BEST_TRAINING_SOLUTION_RESULT_NAME].Value).Quality;
+
+      if ((!Maximization && currentBestQuality > bestQuality) ||
+           (Maximization && currentBestQuality < bestQuality)) {
+        results[BEST_TRAINING_SOLUTION_RESULT_NAME].Value = CreatePushSolution(
+            program,
+            bestQuality,
+            random,
+            Config);
+        return true;
+      }
+
+      return false;
+    }
+
+    public override double Evaluate(Individual individual, IRandom random) {
+      var program = MapIndividual(individual, random);
+      var result = PushEvaluator.EvaluateTraining(Pool, program, random);
+
+      individual[CaseQualitiesScopeParameterName] = new DoubleArray(result.ExampleQualities);
+
+      return result.AvgQuality;
+    }
+
+    protected abstract PushProgram MapIndividual(Individual individual, IRandom random);
+
+    protected abstract PushSolution CreatePushSolution(
+      PushProgram program,
+      double bestQuality,
+      IRandom random,
+      IReadOnlyPushConfiguration config);
+  }
+}
Index: /branches/PushGP/HeuristicLab.PushGP/HeuristicLab.Problems.ProgramSynthesis/Push/Selector/LexicaseSelector.cs
===================================================================
--- /branches/PushGP/HeuristicLab.PushGP/HeuristicLab.Problems.ProgramSynthesis/Push/Selector/LexicaseSelector.cs	(revision 15274)
+++ /branches/PushGP/HeuristicLab.PushGP/HeuristicLab.Problems.ProgramSynthesis/Push/Selector/LexicaseSelector.cs	(revision 15275)
@@ -37,6 +37,4 @@
   /// <summary>
   /// A lexicase selection operator which considers all successful evaluated training cases for selection.
-  ///
-  /// ToDo: LexicaseSelector and ICaseSingleObjectiveSelector are ISingleObjectiveOperator, which contains Maximization and Qualities which is not needed
   /// </summary>
   [Item("LexicaseSelector", "A lexicase selection operator which considers all successful evaluated training cases for selection.")]
@@ -45,5 +43,5 @@
     public ILookupParameter<ItemArray<DoubleArray>> CaseQualitiesParameter
     {
-      get { return (ILookupParameter<ItemArray<DoubleArray>>)Parameters[PushProblem.CaseQualitiesScopeParameterName]; }
+      get { return (ILookupParameter<ItemArray<DoubleArray>>)Parameters[IntegerVectorPushProblem.CaseQualitiesScopeParameterName]; }
     }
 
@@ -57,5 +55,5 @@
     public LexicaseSelector() {
       Parameters.Add(new ScopeTreeLookupParameter<DoubleArray>(
-        PushProblem.CaseQualitiesScopeParameterName,
+        IntegerVectorPushProblem.CaseQualitiesScopeParameterName,
         "The quality of every single training case for each individual."));
     }
@@ -68,5 +66,5 @@
       var selected = new IScope[count];
       var caseQualities = CaseQualitiesParameter.ActualValue;
-      var repeats = Math.Ceiling(count / (double)population.Count);
+      var repeats = (int)Math.Ceiling(count / (double)population.Count);
       var caseCount = caseQualities[0].Length;
       var source = Enumerable.Range(0, population.Count).ToList();
@@ -77,16 +75,17 @@
 
         // copy list if required
-        var pool = k == repeats - 1 ? source : new List<int>(source);
+        var pool = repeats == 1 ? source : new List<int>(source);
         var countLimit = Math.Min(count - k * population.Count, population.Count);
 
         for (var i = 0; i < countLimit; i++) {
-          var bestIndividuals = pool;
+          var candidates = pool;
 
-          for (var j = 0; j < fitnessCaseIndexes.Count && bestIndividuals.Count > 1; j++)
-            bestIndividuals = GetBestIndividuals(maximization, caseQualities, bestIndividuals, fitnessCaseIndexes[j]);
+          for (var j = 0; j < fitnessCaseIndexes.Count && candidates.Count > 1; j++) {
+            candidates = GetBestIndividuals(maximization, caseQualities, candidates, fitnessCaseIndexes[j]);
+          }
 
           /*  If only one individual remains, it is the chosen parent. If no more fitness cases are left, a parent is
               chosen randomly from the remaining individuals */
-          var bestIndividualIndex = bestIndividuals.Count == 1 ? bestIndividuals[0] : bestIndividuals.Random(random);
+          var bestIndividualIndex = candidates.Count == 1 ? candidates[0] : candidates.Random(random);
           var bestIndividual = population[bestIndividualIndex];
 
Index: /branches/PushGP/HeuristicLab.PushGP/HeuristicLab.Problems.ProgramSynthesis/Push/SolutionCreator/IPlushCreator.cs
===================================================================
--- /branches/PushGP/HeuristicLab.PushGP/HeuristicLab.Problems.ProgramSynthesis/Push/SolutionCreator/IPlushCreator.cs	(revision 15274)
+++ /branches/PushGP/HeuristicLab.PushGP/HeuristicLab.Problems.ProgramSynthesis/Push/SolutionCreator/IPlushCreator.cs	(revision 15275)
@@ -1,8 +1,19 @@
 ﻿namespace HeuristicLab.Problems.ProgramSynthesis.Push.SolutionCreator {
+  using HeuristicLab.Core;
+  using HeuristicLab.Data;
   using HeuristicLab.Optimization;
+  using HeuristicLab.Problems.ProgramSynthesis.Base.Erc;
+  using HeuristicLab.Problems.ProgramSynthesis.Push.Configuration;
   using HeuristicLab.Problems.ProgramSynthesis.Push.Encoding;
 
   public interface IPlushCreator : ISolutionCreator, IPlushOperator {
-
+    IValueLookupParameter<IntValue> MinLengthParameter { get; }
+    IValueLookupParameter<IntValue> MaxLengthParameter { get; }
+    IValueLookupParameter<IntValue> MinCloseParameter { get; }
+    IValueLookupParameter<IntValue> MaxCloseParameter { get; }
+    IValueLookupParameter<PercentValue> InInstructionProbabilityParameter { get; }
+    IValueLookupParameter<IReadOnlyErcOptions> ErcOptionsParameter { get; }
+    IValueLookupParameter<IReadOnlyExpressionsConfiguration> InstructionsParameter { get; }
+    ILookupParameter<PlushVector> PlushVectorParameter { get; }
   }
 }
Index: /branches/PushGP/HeuristicLab.PushGP/HeuristicLab.Problems.ProgramSynthesis/Push/SolutionCreator/PlushCreator.cs
===================================================================
--- /branches/PushGP/HeuristicLab.PushGP/HeuristicLab.Problems.ProgramSynthesis/Push/SolutionCreator/PlushCreator.cs	(revision 15275)
+++ /branches/PushGP/HeuristicLab.PushGP/HeuristicLab.Problems.ProgramSynthesis/Push/SolutionCreator/PlushCreator.cs	(revision 15275)
@@ -0,0 +1,125 @@
+﻿using System;
+
+namespace HeuristicLab.Problems.ProgramSynthesis.Push.SolutionCreator {
+  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.Base.Erc;
+  using HeuristicLab.Problems.ProgramSynthesis.Push.Configuration;
+  using HeuristicLab.Problems.ProgramSynthesis.Push.Encoding;
+  using HeuristicLab.Problems.ProgramSynthesis.Push.Extensions;
+  using HeuristicLab.Problems.ProgramSynthesis.Push.Generators.CodeGenerator;
+
+  [Item("PlushCreator", "An operator which creates a new random plush vector with each element uniformly distributed")]
+  [StorableClass]
+  public class PlushCreator : InstrumentedOperator, IPlushCreator, IStochasticOperator {
+
+    public PlushCreator() {
+      Parameters.Add(new LookupParameter<IRandom>("Random", "The pseudo random number generator which should be used for stochastic manipulation operators."));
+      Parameters.Add(new LookupParameter<PlushVector>("PlushVector", "The vector which should be manipulated."));
+      Parameters.Add(new ValueLookupParameter<IntValue>("MinLength", "The min length of the vector."));
+      Parameters.Add(new ValueLookupParameter<IntValue>("MaxLength", "The max length of the vector."));
+      Parameters.Add(new ValueLookupParameter<IntValue>("MinClose", "The min close variable for a plush genome entry."));
+      Parameters.Add(new ValueLookupParameter<IntValue>("MaxClose", "The max close variable for a plush genome entry."));
+      Parameters.Add(new ValueLookupParameter<DoubleValue>("CloseBiasLevel", "Determines how strongly the random close variable is biased towards 0."));
+      Parameters.Add(new ValueLookupParameter<IReadOnlyExpressionsConfiguration>("Instructions", "The enabled instructions"));
+      Parameters.Add(new ValueLookupParameter<IReadOnlyErcOptions>("ErcOptions", "ERC options"));
+      Parameters.Add(new ValueLookupParameter<PercentValue>("InInstructionProbability", "The probability of IN Instructions"));
+    }
+
+    [StorableConstructor]
+    public PlushCreator(bool deserializing) : base(deserializing) { }
+
+    public PlushCreator(PlushCreator origin, Cloner cloner) : base(origin, cloner) { }
+
+    public override bool CanChangeName
+    {
+      get { return false; }
+    }
+    public ILookupParameter<IRandom> RandomParameter
+    {
+      get { return (LookupParameter<IRandom>)Parameters["Random"]; }
+    }
+    public ILookupParameter<PlushVector> PlushVectorParameter
+    {
+      get { return (ILookupParameter<PlushVector>)Parameters["PlushVector"]; }
+    }
+    public IValueLookupParameter<IntValue> MinLengthParameter
+    {
+      get { return (IValueLookupParameter<IntValue>)Parameters["MinLength"]; }
+    }
+    public IValueLookupParameter<IntValue> MaxLengthParameter
+    {
+      get { return (IValueLookupParameter<IntValue>)Parameters["MaxLength"]; }
+    }
+    public IValueLookupParameter<IReadOnlyExpressionsConfiguration> InstructionsParameter
+    {
+      get { return (IValueLookupParameter<IReadOnlyExpressionsConfiguration>)Parameters["Instructions"]; }
+    }
+    public IValueLookupParameter<IReadOnlyErcOptions> ErcOptionsParameter
+    {
+      get { return (IValueLookupParameter<IReadOnlyErcOptions>)Parameters["ErcOptions"]; }
+    }
+    public IValueLookupParameter<PercentValue> InInstructionProbabilityParameter
+    {
+      get { return (IValueLookupParameter<PercentValue>)Parameters["InInstructionProbability"]; }
+    }
+    public IValueLookupParameter<IntValue> MinCloseParameter
+    {
+      get { return (IValueLookupParameter<IntValue>)Parameters["MinClose"]; }
+    }
+    public IValueLookupParameter<IntValue> MaxCloseParameter
+    {
+      get { return (IValueLookupParameter<IntValue>)Parameters["MaxClose"]; }
+    }
+    public IValueLookupParameter<DoubleValue> CloseBiasLevel
+    {
+      get { return (IValueLookupParameter<DoubleValue>)Parameters["CloseBiasLevel"]; }
+    }
+    public override IDeepCloneable Clone(Cloner cloner) {
+      return new PlushCreator(this, cloner);
+    }
+
+    public sealed override IOperation InstrumentedApply() {
+      PlushVectorParameter.ActualValue = Create();
+      return base.InstrumentedApply();
+    }
+
+    private PlushVector Create() {
+      var random = RandomParameter.ActualValue;
+      var minLength = MinLengthParameter.ActualValue.Value;
+      var maxLength = MaxLengthParameter.ActualValue.Value;
+      var ercOptions = ErcOptionsParameter.ActualValue;
+      var instructions = InstructionsParameter.ActualValue;
+      var inInstructionProbability = InInstructionProbabilityParameter.ActualValue.Value;
+      var minClose = MinCloseParameter.ActualValue.Value;
+      var maxClose = MaxCloseParameter.ActualValue.Value;
+      var biasLevel = CloseBiasLevel.ActualValue.Value;
+
+      if (minLength > maxLength)
+        throw new InvalidOperationException("MinLength > MaxLength");
+
+      if (minClose > maxClose)
+        throw new InvalidOperationException("MinClose > MaxClose");
+
+      var length = random.Next(minLength, maxLength);
+      var result = new PlushVector(length);
+
+      for (var i = 0; i < length; i++) {
+        var expression = CodeGeneratorUtils.GetRandomExpression(random, ercOptions, instructions, inInstructionProbability);
+        var close = random.NextBiased(minClose, maxClose, biasLevel);
+
+        result.Add(new PlushEntry {
+          Close = close,
+          Instruction = expression,
+        });
+      }
+
+      return result;
+    }
+  }
+}
