Index: /branches/PushGP/HeuristicLab.PushGP/HeuristicLab.Problem.ProgramSynthesis.BenchmarkSuite/DataTypes.cs
===================================================================
--- /branches/PushGP/HeuristicLab.PushGP/HeuristicLab.Problem.ProgramSynthesis.BenchmarkSuite/DataTypes.cs	(revision 15031)
+++ /branches/PushGP/HeuristicLab.PushGP/HeuristicLab.Problem.ProgramSynthesis.BenchmarkSuite/DataTypes.cs	(revision 15032)
@@ -3,5 +3,5 @@
 
   [Flags]
-  public enum DataTypes : ushort {
+  public enum DataTypes {
     None = 0x01, // Required to specify expression dependencies
     Integer = 0x02,
Index: /branches/PushGP/HeuristicLab.PushGP/HeuristicLab.Problem.ProgramSynthesis.BenchmarkSuite/Problems/NumberIo.cs
===================================================================
--- /branches/PushGP/HeuristicLab.PushGP/HeuristicLab.Problem.ProgramSynthesis.BenchmarkSuite/Problems/NumberIo.cs	(revision 15031)
+++ /branches/PushGP/HeuristicLab.PushGP/HeuristicLab.Problem.ProgramSynthesis.BenchmarkSuite/Problems/NumberIo.cs	(revision 15032)
@@ -24,8 +24,8 @@
         WorstResult = 400,
         InputArgumentTypes = new[] { ExampleArgumentType.Float, ExampleArgumentType.Integer },
-        OutputArgumentTypes = new[] { ExampleArgumentType.Print },
+        OutputArgumentTypes = new[] { ExampleArgumentType.Float },
         TrainingCount = 25,
         TestCount = 1000,
-        EnabledDataTypes = DataTypes.Integer | DataTypes.Float | DataTypes.Print,
+        EnabledDataTypes = DataTypes.Integer | DataTypes.Float, // | DataTypes.Print,
         EvalLimit = 200,
         MaxSize = 200,
@@ -47,6 +47,6 @@
         InputFloat = ExampleArgumentConverter.ConvertDoubles(input[0]),
         InputInteger = ExampleArgumentConverter.ConvertIntegers(input[1]),
-        //OutputFloat = new[] { estimedFloatValue },
-        OutputPrint = estimedFloatValue.ToString("R", CultureInfo.InvariantCulture),
+        OutputFloat = ExampleArgumentConverter.ConvertDoubles(output),
+        //OutputPrint = estimedFloatValue.ToString("R", CultureInfo.InvariantCulture),
       };
     }
Index: /branches/PushGP/HeuristicLab.PushGP/HeuristicLab.Problem.ProgramSynthesis.BenchmarkSuite/Views/DataEditorView.cs
===================================================================
--- /branches/PushGP/HeuristicLab.PushGP/HeuristicLab.Problem.ProgramSynthesis.BenchmarkSuite/Views/DataEditorView.cs	(revision 15031)
+++ /branches/PushGP/HeuristicLab.PushGP/HeuristicLab.Problem.ProgramSynthesis.BenchmarkSuite/Views/DataEditorView.cs	(revision 15032)
@@ -188,5 +188,5 @@
           var type = Content.InputArgumentTypes[i];
           var offset = inputArgumentCountDict[type];
-          row.Cells[i].Value = ViewHelper.StringifyInput(type, offset, example, ValueSeparator);
+          row.Cells[i].Value = ViewHelper.StringifyInput(type, offset, "R", example, ValueSeparator);
           inputArgumentCountDict[type]++;
         }
@@ -196,5 +196,5 @@
           var type = Content.OutputArgumentTypes[i];
           var offset = outputArgumentCountDict[type];
-          row.Cells[Content.InputArgumentTypes.Length + i].Value = ViewHelper.StringifyOutput(type, offset, example, ValueSeparator);
+          row.Cells[Content.InputArgumentTypes.Length + i].Value = ViewHelper.StringifyOutput(type, offset, "R", example, ValueSeparator);
           outputArgumentCountDict[type]++;
         }
Index: /branches/PushGP/HeuristicLab.PushGP/HeuristicLab.Problem.ProgramSynthesis.BenchmarkSuite/Views/ViewHelper.cs
===================================================================
--- /branches/PushGP/HeuristicLab.PushGP/HeuristicLab.Problem.ProgramSynthesis.BenchmarkSuite/Views/ViewHelper.cs	(revision 15031)
+++ /branches/PushGP/HeuristicLab.PushGP/HeuristicLab.Problem.ProgramSynthesis.BenchmarkSuite/Views/ViewHelper.cs	(revision 15032)
@@ -6,11 +6,11 @@
 
   public static class ViewHelper {
-    public static string StringifyInput(ExampleArgumentType type, int offset, Example example, string valueSeparator) {
+    public static string StringifyInput(ExampleArgumentType type, int offset, string floatFormat, Example example, string valueSeparator) {
       switch (type) {
         case ExampleArgumentType.Integer: return example.InputInteger[offset].ToString();
         case ExampleArgumentType.IntegerVector: return "[" + string.Join(", ", example.InputIntegerVector[offset]) + "]";
 
-        case ExampleArgumentType.Float: return example.InputFloat[offset].ToString(CultureInfo.CurrentUICulture);
-        case ExampleArgumentType.FloatVector: return "[" + string.Join(", ", example.InputFloatVector[offset]) + "]";
+        case ExampleArgumentType.Float: return example.InputFloat[offset].ToString(floatFormat, CultureInfo.CurrentUICulture);
+        case ExampleArgumentType.FloatVector: return "[" + string.Join(", ", example.InputFloatVector[offset].Select(x => x.ToString(floatFormat, CultureInfo.InvariantCulture))) + "]";
 
         case ExampleArgumentType.Boolean: return example.InputBoolean[offset].ToString();
@@ -24,11 +24,11 @@
     }
 
-    public static string StringifyOutput(ExampleArgumentType type, int offset, Example example, string valueSeparator) {
+    public static string StringifyOutput(ExampleArgumentType type, int offset, string floatFormat, Example example, string valueSeparator) {
       switch (type) {
         case ExampleArgumentType.Integer: return example.OutputInteger[offset].ToString();
         case ExampleArgumentType.IntegerVector: return "[" + string.Join(", ", example.OutputIntegerVector[offset]) + "]";
 
-        case ExampleArgumentType.Float: return example.OutputFloat[offset].ToString(CultureInfo.CurrentUICulture);
-        case ExampleArgumentType.FloatVector: return "[" + string.Join(", ", example.OutputFloatVector[offset]) + "]";
+        case ExampleArgumentType.Float: return example.OutputFloat[offset].ToString(floatFormat, CultureInfo.InvariantCulture);
+        case ExampleArgumentType.FloatVector: return "[" + string.Join(", ", example.OutputFloatVector[offset].Select(x => x.ToString(floatFormat, CultureInfo.InvariantCulture))) + "]";
 
         case ExampleArgumentType.Boolean: return example.OutputBoolean[offset].ToString();
Index: /branches/PushGP/HeuristicLab.PushGP/HeuristicLab.Problems.ProgramSynthesis.Base/Erc/Boolean/BooleanRandomErc.cs
===================================================================
--- /branches/PushGP/HeuristicLab.PushGP/HeuristicLab.Problems.ProgramSynthesis.Base/Erc/Boolean/BooleanRandomErc.cs	(revision 15031)
+++ /branches/PushGP/HeuristicLab.PushGP/HeuristicLab.Problems.ProgramSynthesis.Base/Erc/Boolean/BooleanRandomErc.cs	(revision 15032)
@@ -14,5 +14,5 @@
     private const string AllowFalseParameterName = "Allow false";
 
-    public BooleanRandomErc() : this(false, true, true) { }
+    public BooleanRandomErc() : this(true, true, true) { }
 
     public BooleanRandomErc(bool isEnabled, bool allowTrue, bool allowFalse, double weight = 1d) : base(isEnabled, weight) {
Index: /branches/PushGP/HeuristicLab.PushGP/HeuristicLab.Problems.ProgramSynthesis.Base/Erc/Float/FloatConstantErc.cs
===================================================================
--- /branches/PushGP/HeuristicLab.PushGP/HeuristicLab.Problems.ProgramSynthesis.Base/Erc/Float/FloatConstantErc.cs	(revision 15031)
+++ /branches/PushGP/HeuristicLab.PushGP/HeuristicLab.Problems.ProgramSynthesis.Base/Erc/Float/FloatConstantErc.cs	(revision 15032)
@@ -7,5 +7,5 @@
   public class FloatConstantErc : ConstantsWeightedErc<double, DoubleArray> {
 
-    public FloatConstantErc() : this(false, 1d) { }
+    public FloatConstantErc() : this(true, 1d) { }
 
     public FloatConstantErc(params double[] constants) : this(true, 1d, constants) { }
Index: /branches/PushGP/HeuristicLab.PushGP/HeuristicLab.Problems.ProgramSynthesis.Base/Erc/Float/FloatRangeErc.cs
===================================================================
--- /branches/PushGP/HeuristicLab.PushGP/HeuristicLab.Problems.ProgramSynthesis.Base/Erc/Float/FloatRangeErc.cs	(revision 15031)
+++ /branches/PushGP/HeuristicLab.PushGP/HeuristicLab.Problems.ProgramSynthesis.Base/Erc/Float/FloatRangeErc.cs	(revision 15032)
@@ -10,5 +10,5 @@
     private const string RangeParameterName = "Range";
 
-    public FloatRangeErc() : this(false, 0d, 0d) { }
+    public FloatRangeErc() : this(true, 0d, 0d) { }
 
     public FloatRangeErc(double start, double end) : this(true, start, end) { }
Index: /branches/PushGP/HeuristicLab.PushGP/HeuristicLab.Problems.ProgramSynthesis.Base/Erc/Integer/IntegerConstantErc.cs
===================================================================
--- /branches/PushGP/HeuristicLab.PushGP/HeuristicLab.Problems.ProgramSynthesis.Base/Erc/Integer/IntegerConstantErc.cs	(revision 15031)
+++ /branches/PushGP/HeuristicLab.PushGP/HeuristicLab.Problems.ProgramSynthesis.Base/Erc/Integer/IntegerConstantErc.cs	(revision 15032)
@@ -7,5 +7,5 @@
   public class IntegerConstantErc : ConstantsWeightedErc<int, IntArray> {
 
-    public IntegerConstantErc() : this(false, 1d) { }
+    public IntegerConstantErc() : this(true, 1d) { }
 
     public IntegerConstantErc(params int[] constants) : this(true, 1d, constants) { }
Index: /branches/PushGP/HeuristicLab.PushGP/HeuristicLab.Problems.ProgramSynthesis.Base/Erc/Integer/IntegerRangeErc.cs
===================================================================
--- /branches/PushGP/HeuristicLab.PushGP/HeuristicLab.Problems.ProgramSynthesis.Base/Erc/Integer/IntegerRangeErc.cs	(revision 15031)
+++ /branches/PushGP/HeuristicLab.PushGP/HeuristicLab.Problems.ProgramSynthesis.Base/Erc/Integer/IntegerRangeErc.cs	(revision 15032)
@@ -10,5 +10,5 @@
     private const string RangeParameterName = "Range";
 
-    public IntegerRangeErc() : this(false, 0, 0) { }
+    public IntegerRangeErc() : this(true, 0, 0) { }
 
     public IntegerRangeErc(int start, int end) : this(true, start, end) { }
Index: /branches/PushGP/HeuristicLab.PushGP/HeuristicLab.Problems.ProgramSynthesis.Base/Erc/String/StringConstantErc.cs
===================================================================
--- /branches/PushGP/HeuristicLab.PushGP/HeuristicLab.Problems.ProgramSynthesis.Base/Erc/String/StringConstantErc.cs	(revision 15031)
+++ /branches/PushGP/HeuristicLab.PushGP/HeuristicLab.Problems.ProgramSynthesis.Base/Erc/String/StringConstantErc.cs	(revision 15032)
@@ -12,5 +12,5 @@
     private const string ConstantsParameterName = "Constants";
 
-    public StringConstantErc() : this(false, 1d) { }
+    public StringConstantErc() : this(true, 1d) { }
 
     public StringConstantErc(params string[] constants) : this(true, 1d, constants) { }
Index: /branches/PushGP/HeuristicLab.PushGP/HeuristicLab.Problems.ProgramSynthesis.Base/Erc/String/StringRandomErc.cs
===================================================================
--- /branches/PushGP/HeuristicLab.PushGP/HeuristicLab.Problems.ProgramSynthesis.Base/Erc/String/StringRandomErc.cs	(revision 15031)
+++ /branches/PushGP/HeuristicLab.PushGP/HeuristicLab.Problems.ProgramSynthesis.Base/Erc/String/StringRandomErc.cs	(revision 15032)
@@ -27,5 +27,5 @@
     private const string NewStringProbabilityParameterDescription = "The probability that the selection of the ephemeral random string constant for inclusion in randomly generated code will produce a new string (rather than a string that was previously generated).";
 
-    public StringRandomErc() : this(false, 1d) { }
+    public StringRandomErc() : this(true, 1d) { }
 
     public StringRandomErc(bool isEnabled, double weight = 1d) : base(isEnabled, weight) {
Index: /branches/PushGP/HeuristicLab.PushGP/HeuristicLab.Problems.ProgramSynthesis.Base/Erc/StringVector/StringVectorConstantsErc.cs
===================================================================
--- /branches/PushGP/HeuristicLab.PushGP/HeuristicLab.Problems.ProgramSynthesis.Base/Erc/StringVector/StringVectorConstantsErc.cs	(revision 15031)
+++ /branches/PushGP/HeuristicLab.PushGP/HeuristicLab.Problems.ProgramSynthesis.Base/Erc/StringVector/StringVectorConstantsErc.cs	(revision 15032)
@@ -15,5 +15,5 @@
     private const string ConstantsParameterName = "Constants";
 
-    public StringVectorConstantsErc() : this(false, 1d) { }
+    public StringVectorConstantsErc() : this(true, 1d) { }
     public StringVectorConstantsErc(params string[][] arrays) : this(true, 1d, arrays.Select(x => new StringArray(x)).ToArray()) { }
     public StringVectorConstantsErc(params StringArray[] arrays) : this(true, 1d, arrays) { }
Index: /branches/PushGP/HeuristicLab.PushGP/HeuristicLab.Problems.ProgramSynthesis.Base/Erc/Views/ErcOptionsView.cs
===================================================================
--- /branches/PushGP/HeuristicLab.PushGP/HeuristicLab.Problems.ProgramSynthesis.Base/Erc/Views/ErcOptionsView.cs	(revision 15031)
+++ /branches/PushGP/HeuristicLab.PushGP/HeuristicLab.Problems.ProgramSynthesis.Base/Erc/Views/ErcOptionsView.cs	(revision 15032)
@@ -32,5 +32,6 @@
       double value;
       if (double.TryParse(text, out value)) {
-        possibilityTextBox.Text = (value / 100.0).ToString(PERCENTAGE_FORMAT);
+        if (value > 1) value /= 100.0;
+        possibilityTextBox.Text = value.ToString(PERCENTAGE_FORMAT);
       } else {
         possibilityTextBox.Text = "0%";
Index: /branches/PushGP/HeuristicLab.PushGP/HeuristicLab.Problems.ProgramSynthesis/HeuristicLab.Problems.ProgramSynthesis.csproj
===================================================================
--- /branches/PushGP/HeuristicLab.PushGP/HeuristicLab.Problems.ProgramSynthesis/HeuristicLab.Problems.ProgramSynthesis.csproj	(revision 15031)
+++ /branches/PushGP/HeuristicLab.PushGP/HeuristicLab.Problems.ProgramSynthesis/HeuristicLab.Problems.ProgramSynthesis.csproj	(revision 15032)
@@ -36,4 +36,8 @@
   </PropertyGroup>
   <ItemGroup>
+    <Reference Include="HeuristicLab.Analysis-3.3, Version=3.3.0.0, Culture=neutral, PublicKeyToken=ba48961d6f65dcec, processorArchitecture=MSIL">
+      <SpecificVersion>False</SpecificVersion>
+      <HintPath>..\..\..\..\trunk\sources\bin\HeuristicLab.Analysis-3.3.dll</HintPath>
+    </Reference>
     <Reference Include="HeuristicLab.Collections-3.3, Version=3.3.0.0, Culture=neutral, PublicKeyToken=ba48961d6f65dcec, processorArchitecture=MSIL">
       <SpecificVersion>False</SpecificVersion>
@@ -118,4 +122,6 @@
       <DependentUpon>Resources.resx</DependentUpon>
     </Compile>
+    <Compile Include="Push\Analyzer\IPushExpressionAnalyzer.cs" />
+    <Compile Include="Push\Analyzer\PushExpressionFrequencyAnalyzer.cs" />
     <Compile Include="Push\Attributes\PushExpressionAttriubte.cs" />
     <Compile Include="Push\Attributes\PushStackAttribute.cs" />
@@ -187,4 +193,5 @@
     <Compile Include="Push\Extensions\CollectionExtensions.cs" />
     <Compile Include="Push\Extensions\ControlExntensions.cs" />
+    <Compile Include="Push\Extensions\EnumExtensions.cs" />
     <Compile Include="Push\Extensions\LongExtensions.cs" />
     <Compile Include="Push\Extensions\RandomExtensions.cs" />
Index: /branches/PushGP/HeuristicLab.PushGP/HeuristicLab.Problems.ProgramSynthesis/Push/Attributes/PushExpressionAttriubte.cs
===================================================================
--- /branches/PushGP/HeuristicLab.PushGP/HeuristicLab.Problems.ProgramSynthesis/Push/Attributes/PushExpressionAttriubte.cs	(revision 15031)
+++ /branches/PushGP/HeuristicLab.PushGP/HeuristicLab.Problems.ProgramSynthesis/Push/Attributes/PushExpressionAttriubte.cs	(revision 15032)
@@ -8,10 +8,19 @@
     public readonly StackTypes StackType;
     public readonly StackTypes AdditionalStackDependencies;
-    public readonly string ExpressionName;
+    public readonly string Name;
+    public readonly string Description;
+
+    /// <summary>
+    /// Determines if this expression manipulates the exec stack.
+    /// </summary>
     public readonly bool ManipulatesExec;
+
+    /// <summary>
+    /// Determines the amount of items fetched form the EXEC stack required for this expression. Used for mapping individuals.
+    /// </summary>
     public readonly uint ExecIn;
 
     /// <summary>
-    /// Determines if the expression is visible to the user during the configuration phase for example.
+    /// Determines if the expression is visible to the user for configuration purposes.
     /// </summary>
     public readonly bool IsHidden;
@@ -19,11 +28,14 @@
     public PushExpressionAttribute(
       StackTypes stackType,
-      string expressionName,
+      string name,
+      string description,
       StackTypes additionalStackDependencies = default(StackTypes),
       uint execIn = 0,
       bool isHidden = false) {
+
       StackType = stackType;
       AdditionalStackDependencies = additionalStackDependencies;
-      ExpressionName = expressionName;
+      Name = name;
+      Description = description;
       ExecIn = execIn;
       IsHidden = isHidden;
Index: /branches/PushGP/HeuristicLab.PushGP/HeuristicLab.Problems.ProgramSynthesis/Push/Configuration/IEnabledExpressionsConfiguration.cs
===================================================================
--- /branches/PushGP/HeuristicLab.PushGP/HeuristicLab.Problems.ProgramSynthesis/Push/Configuration/IEnabledExpressionsConfiguration.cs	(revision 15031)
+++ /branches/PushGP/HeuristicLab.PushGP/HeuristicLab.Problems.ProgramSynthesis/Push/Configuration/IEnabledExpressionsConfiguration.cs	(revision 15032)
@@ -20,17 +20,17 @@
     event EventHandler<EnabledExpressionsChangedEventArgs> EnabledExpressionsChanged;
 
-    IList<string> EnabledExpressions { get; }
+    IReadOnlyList<string> EnabledExpressions { get; }
 
-    void EnableStack(StackTypes types, bool enableExpressions = true, bool enableDependencies = true);
-    void DisableStack(StackTypes type, bool disableExpressions = true, bool enableDepenencies = true);
-    void SetStack(StackTypes type, bool state, bool setExpressions = true, bool setDependencies = true);
+    void EnableStack(StackTypes types, bool enableDependencies = false);
+    void DisableStack(StackTypes type, bool enableDepenencies = false);
+    void SetStack(StackTypes type, bool state, bool setDependencies = false);
     void EnableExpressionOfStack(StackTypes types);
     void DisableExpressionsOfStack(StackTypes types);
-    void EnableExpression(string name, bool enableStackIfDisabled = false);
-    void DisableExpression(string name, bool disableStackIfEnabled = false);
-    void SetExpression(string name, bool state, bool cascadeForStack = false);
-    void SetExpression<T>(bool state, bool cascadeForStack = false) where T : Expression;
-    void EnableExpression<T>(bool enableStackIfDisabled = false) where T : Expression;
-    void DisableExpression<T>(bool disableStackIfEnabled = false) where T : Expression;
+    void EnableExpression(string name);
+    void DisableExpression(string name);
+    void SetExpression(string name, bool state);
+    void SetExpression<T>(bool state) where T : Expression;
+    void EnableExpression<T>() where T : Expression;
+    void DisableExpression<T>() where T : Expression;
   }
 }
Index: /branches/PushGP/HeuristicLab.PushGP/HeuristicLab.Problems.ProgramSynthesis/Push/Configuration/IReadonlyPushConfiguration.cs
===================================================================
--- /branches/PushGP/HeuristicLab.PushGP/HeuristicLab.Problems.ProgramSynthesis/Push/Configuration/IReadonlyPushConfiguration.cs	(revision 15031)
+++ /branches/PushGP/HeuristicLab.PushGP/HeuristicLab.Problems.ProgramSynthesis/Push/Configuration/IReadonlyPushConfiguration.cs	(revision 15032)
@@ -3,8 +3,10 @@
   using Base.Erc;
   using Common;
+
+  using HeuristicLab.Core;
+
   using Stack;
 
-  public interface IReadOnlyPushConfiguration : IDeepCloneable {
-    IReadOnlyDictionary<StackTypes, bool> EnabledStacks { get; }
+  public interface IReadOnlyPushConfiguration : IItem {
     int EvalPushLimit { get; }
     int MaxDepth { get; }
@@ -20,4 +22,6 @@
     IReadOnlyList<string> EnabledExpressions { get; }
     string FloatStringFormat { get; }
+
+    bool IsStackEnabled(StackTypes stackType);
   }
 }
Index: /branches/PushGP/HeuristicLab.PushGP/HeuristicLab.Problems.ProgramSynthesis/Push/Configuration/PushConfiguration.cs
===================================================================
--- /branches/PushGP/HeuristicLab.PushGP/HeuristicLab.Problems.ProgramSynthesis/Push/Configuration/PushConfiguration.cs	(revision 15031)
+++ /branches/PushGP/HeuristicLab.PushGP/HeuristicLab.Problems.ProgramSynthesis/Push/Configuration/PushConfiguration.cs	(revision 15032)
@@ -1,20 +1,12 @@
 ﻿namespace HeuristicLab.Problems.ProgramSynthesis.Push.Configuration {
-  using System;
   using System.Collections.Generic;
-  using System.Linq;
   using Base.Erc;
   using Common;
-  using Core;
-  using Expressions;
   using Persistence.Default.CompositeSerializers.Storable;
-  using Stack;
 
   [StorableClass]
-  public class PushConfiguration : ParameterizedNamedItem, IReadOnlyPushConfiguration, IEnabledExpressionsConfiguration {
+  public class PushConfiguration : PushConfigurationBase, IReadOnlyPushConfiguration {
     public PushConfiguration() {
       Name = "Push Configuration";
-
-      enabledExpressions = ExpressionTable.ExpressionNames.ToList();
-      enabledStacks = new Dictionary<StackTypes, bool>();
 
       ErcOptions = new ErcOptions();
@@ -31,14 +23,6 @@
       MaxParenthesesClose = 4;
       ParenthesesCloseBiasLevel = 1;
-
-      InitEnabledStacks();
     }
 
-    private void InitEnabledStacks(bool state = true) {
-      foreach (StackTypes type in Enum.GetValues(typeof(StackTypes))) {
-        if (!enabledStacks.ContainsKey(type) && type != StackTypes.None)
-          enabledStacks.Add(type, state);
-      }
-    }
 
     [StorableConstructor]
@@ -48,6 +32,4 @@
 
     public PushConfiguration(PushConfiguration origin, Cloner cloner) : base(origin, cloner) {
-      enabledExpressions = origin.EnabledExpressions.ToList();
-      enabledStacks = origin.EnabledStacks.ToDictionary(x => x.Key, x => x.Value);
 
       ErcOptions = cloner.Clone(origin.ErcOptions);
@@ -66,38 +48,8 @@
     }
 
-    [StorableHook(HookType.AfterDeserialization)]
-    // ReSharper disable once UnusedMember.Local
-    private void AfterDeserialization() {
-      // Ensures that all types added after last serialization are available in enabledStacks
-      InitEnabledStacks(false);
-    }
-
     [Storable]
     public string FloatStringFormat { get; set; }
 
-    [Storable]
-    private readonly Dictionary<StackTypes, bool> enabledStacks;
 
-    public IReadOnlyDictionary<StackTypes, bool> EnabledStacks { get { return enabledStacks; } }
-
-    public event EventHandler<EnabledExpressionsChangedEventArgs> EnabledExpressionsChanged;
-
-    [Storable]
-    private readonly List<string> enabledExpressions;
-
-    public IList<string> EnabledExpressions
-    {
-      get { return enabledExpressions; }
-      set
-      {
-        var removedExpressions = enabledExpressions.ToArray();
-        enabledExpressions.Clear();
-        enabledExpressions.AddRange(value);
-
-        if (EnabledExpressionsChanged != null) {
-          EnabledExpressionsChanged(this, new EnabledExpressionsChangedEventArgs(value, removedExpressions));
-        }
-      }
-    }
     IReadOnlyList<string> IReadOnlyPushConfiguration.EnabledExpressions { get { return enabledExpressions; } }
 
@@ -174,146 +126,4 @@
     public int MaxVectorLength { get; set; }
 
-
-    public void SetEnabledStacks(StackTypes types) {
-      // Disable all
-      EnabledExpressions.Clear();
-
-      foreach (StackTypes type in Enum.GetValues(types.GetType())) {
-        if (type == StackTypes.None) continue;
-        enabledStacks[type] = false;
-      }
-
-      foreach (var pair in ExpressionTable.StackDependencyToNamesTable) {
-        if (types.HasFlag(pair.Key)) {
-          foreach (var name in pair.Value) {
-            EnableExpression(name, true);
-          }
-        }
-      }
-    }
-
-    public void EnableExpressionOfStack(StackTypes types) {
-      EnableExpressions(ExpressionTable.StackTypeToNamesTable[types]);
-    }
-
-    public void EnableExpressionDependentOnStack(StackTypes types) {
-      var names = ExpressionTable.StackDependencyToNamesTable[types].Where(
-        name => {
-          var type = ExpressionTable.NameToTypeTable[name];
-          var attribute = ExpressionTable.TypeToAttributeTable[type];
-
-          return (attribute.StackType | attribute.AdditionalStackDependencies)
-            .ToEnumerable()
-            .All(st => enabledStacks.ContainsKey(st) && enabledStacks[st]);
-        });
-
-      EnableExpressions(names);
-    }
-
-    private void EnableExpressions(IEnumerable<string> names) {
-      foreach (var name in names.Except(EnabledExpressions))
-        EnabledExpressions.Add(name);
-
-      if (EnabledExpressionsChanged != null) {
-        EnabledExpressionsChanged(this, new EnabledExpressionsChangedEventArgs(names, new string[0]));
-      }
-    }
-
-    public void DisableExpressionsOfStack(StackTypes types) {
-      DisableExpressions(ExpressionTable.StackTypeToNamesTable[types]);
-    }
-
-    public void DisableExpressionsDependentOnStack(StackTypes types) {
-      var names = ExpressionTable.StackDependencyToNamesTable
-          .Where(pair => pair.Key.HasFlag(types))
-          .SelectMany(pair => pair.Value);
-
-      DisableExpressions(names);
-    }
-
-    private void DisableExpressions(IEnumerable<string> names) {
-      foreach (var name in names.Intersect(EnabledExpressions))
-        EnabledExpressions.Remove(name);
-
-      if (EnabledExpressionsChanged != null) {
-        EnabledExpressionsChanged(this, new EnabledExpressionsChangedEventArgs(new string[0], names));
-      }
-    }
-
-    public void EnableExpression(string name, bool enableStackIfDisabled = false) {
-      if (EnabledExpressions.Contains(name)) return;
-
-      EnabledExpressions.Add(name);
-
-      if (enableStackIfDisabled) {
-        var type = ExpressionTable.TypeToNameTable.Single(x => x.Value == name).Key;
-        var attribute = ExpressionTable.TypeToAttributeTable[type];
-        enabledStacks[attribute.StackType] = true;
-      }
-
-      if (EnabledExpressionsChanged != null) {
-        EnabledExpressionsChanged(this, new EnabledExpressionsChangedEventArgs(
-          new[] { name },
-          new string[0]));
-      }
-    }
-
-    public void DisableExpression(string name, bool disableStackIfEnabled = false) {
-      if (!EnabledExpressions.Contains(name)) return;
-
-      EnabledExpressions.Remove(name);
-
-      if (disableStackIfEnabled) {
-        var type = ExpressionTable.TypeToNameTable.Single(x => x.Value == name).Key;
-        var attribute = ExpressionTable.TypeToAttributeTable[type];
-        enabledStacks[attribute.StackType] = false;
-      }
-
-      if (EnabledExpressionsChanged != null) {
-        EnabledExpressionsChanged(this, new EnabledExpressionsChangedEventArgs(
-          new string[0],
-          new[] { name }));
-      }
-    }
-
-    public void EnableExpression<T>(bool enableStackIfDisabled = false) where T : Expression {
-      var attribute = ExpressionTable.TypeToAttributeTable[typeof(T)];
-      EnableExpression(attribute.ExpressionName, enableStackIfDisabled);
-    }
-
-    public void DisableExpression<T>(bool disableStackIfEnabled = false) where T : Expression {
-      var attribute = ExpressionTable.TypeToAttributeTable[typeof(T)];
-      DisableExpression(attribute.ExpressionName, disableStackIfEnabled);
-    }
-
-    public void SetExpression(string name, bool state, bool cascadeForStack = false) {
-      if (state) EnableExpression(name, cascadeForStack);
-      else DisableExpression(name, cascadeForStack);
-    }
-
-    public void SetExpression<T>(bool state, bool cascadeForStack = false) where T : Expression {
-      if (state) EnableExpression<T>(cascadeForStack);
-      else DisableExpression<T>(cascadeForStack);
-    }
-
-    public void EnableStack(StackTypes type, bool enableExpressions = true, bool enableDependencies = true) {
-      enabledStacks[type] = true;
-
-      if (enableExpressions) EnableExpressionOfStack(type);
-      if (enableDependencies) EnableExpressionDependentOnStack(type);
-    }
-
-    public void DisableStack(StackTypes type, bool disableExpressions = true, bool disableDependencies = true) {
-      enabledStacks[type] = false;
-
-      if (disableExpressions) DisableExpressionsOfStack(type);
-      if (disableDependencies) DisableExpressionsDependentOnStack(type);
-    }
-
-    public void SetStack(StackTypes type, bool state, bool setExpressions = true, bool setDependencies = true) {
-      if (state) EnableStack(type, setExpressions, setDependencies);
-      else DisableStack(type, setExpressions, setDependencies);
-    }
-
     public override IDeepCloneable Clone(Cloner cloner) {
       return new PushConfiguration(this, cloner);
Index: /branches/PushGP/HeuristicLab.PushGP/HeuristicLab.Problems.ProgramSynthesis/Push/Configuration/PushConfigurationBase.cs
===================================================================
--- /branches/PushGP/HeuristicLab.PushGP/HeuristicLab.Problems.ProgramSynthesis/Push/Configuration/PushConfigurationBase.cs	(revision 15031)
+++ /branches/PushGP/HeuristicLab.PushGP/HeuristicLab.Problems.ProgramSynthesis/Push/Configuration/PushConfigurationBase.cs	(revision 15032)
@@ -8,4 +8,5 @@
   using HeuristicLab.Persistence.Default.CompositeSerializers.Storable;
   using HeuristicLab.Problems.ProgramSynthesis.Push.Expressions;
+  using HeuristicLab.Problems.ProgramSynthesis.Push.Extensions;
   using HeuristicLab.Problems.ProgramSynthesis.Push.Stack;
 
@@ -17,7 +18,6 @@
 
       enabledExpressions = ExpressionTable.ExpressionNames.ToList();
-      enabledStacks = new Dictionary<StackTypes, bool>();
-
-      InitEnabledStacks();
+      expressionsPerStackCount = new Dictionary<StackTypes, int>();
+      InitExpressionsPerStackCount();
     }
 
@@ -27,11 +27,9 @@
     protected PushConfigurationBase(PushConfigurationBase origin, Cloner cloner) : base(origin, cloner) {
       enabledExpressions = origin.EnabledExpressions.ToList();
-      enabledStacks = origin.EnabledStacks.ToDictionary(x => x.Key, x => x.Value);
+      expressionsPerStackCount = origin.expressionsPerStackCount.ToDictionary(x => x.Key, x => x.Value);
     }
 
     [Storable]
-    private readonly Dictionary<StackTypes, bool> enabledStacks;
-
-    public IReadOnlyDictionary<StackTypes, bool> EnabledStacks { get { return enabledStacks; } }
+    private readonly Dictionary<StackTypes, int> expressionsPerStackCount;
 
     public event EventHandler<EnabledExpressionsChangedEventArgs> EnabledExpressionsChanged;
@@ -40,5 +38,10 @@
     protected readonly List<string> enabledExpressions;
 
-    public IList<string> EnabledExpressions
+    public bool IsStackEnabled(StackTypes type) {
+      int count;
+      return expressionsPerStackCount.TryGetValue(type, out count) && count > 0;
+    }
+
+    public IReadOnlyList<string> EnabledExpressions
     {
       get { return enabledExpressions; }
@@ -55,8 +58,18 @@
     }
 
-    private void InitEnabledStacks(bool state = true) {
+    private void InitExpressionsPerStackCount() {
       foreach (StackTypes type in Enum.GetValues(typeof(StackTypes))) {
-        if (!enabledStacks.ContainsKey(type) && type != StackTypes.None)
-          enabledStacks.Add(type, state);
+        if (type == StackTypes.None) continue;
+        expressionsPerStackCount.Add(type, 0);
+      }
+
+      foreach (var expressionName in ExpressionTable.ExpressionNames) {
+        var type = ExpressionTable.TypeToNameTable.Single(x => x.Value == expressionName).Key;
+        var attribute = ExpressionTable.TypeToAttributeTable[type];
+
+        expressionsPerStackCount[attribute.StackType]++;
+
+        foreach (var additionalStackType in attribute.AdditionalStackDependencies.ToValues())
+          expressionsPerStackCount[additionalStackType]++;
       }
     }
@@ -64,18 +77,16 @@
     public void SetEnabledStacks(StackTypes types) {
       // Disable all
-      EnabledExpressions.Clear();
-
-      foreach (StackTypes type in Enum.GetValues(types.GetType())) {
+      enabledExpressions.Clear();
+
+      foreach (StackTypes type in Enum.GetValues(typeof(StackTypes))) {
         if (type == StackTypes.None) continue;
-        enabledStacks[type] = false;
-      }
-
-      foreach (var pair in ExpressionTable.StackDependencyToNamesTable) {
-        if (types.HasFlag(pair.Key)) {
-          foreach (var name in pair.Value) {
-            EnableExpression(name, true);
-          }
-        }
-      }
+        expressionsPerStackCount[type] = 0;
+      }
+
+      var expressionNames = ExpressionTable.StackDependencyToNamesTable
+        .Where(pair => types.HasFlag(pair.Key))
+        .SelectMany(pair => pair.Value);
+
+      EnableExpressions(expressionNames);
     }
 
@@ -92,5 +103,5 @@
           return (attribute.StackType | attribute.AdditionalStackDependencies)
             .ToEnumerable()
-            .All(st => enabledStacks.ContainsKey(st) && enabledStacks[st]);
+            .All(IsStackEnabled);
         });
 
@@ -98,10 +109,10 @@
     }
 
-    private void EnableExpressions(IEnumerable<string> names) {
-      foreach (var name in names.Except(EnabledExpressions))
-        EnabledExpressions.Add(name);
+    private void EnableExpressions(IEnumerable<string> expressionNames) {
+      foreach (var expressionName in expressionNames.Except(EnabledExpressions))
+        EnableExpression(expressionName, false);
 
       if (EnabledExpressionsChanged != null) {
-        EnabledExpressionsChanged(this, new EnabledExpressionsChangedEventArgs(names, new string[0]));
+        EnabledExpressionsChanged(this, new EnabledExpressionsChangedEventArgs(expressionNames, new string[0]));
       }
     }
@@ -119,86 +130,94 @@
     }
 
-    private void DisableExpressions(IEnumerable<string> names) {
-      foreach (var name in names.Intersect(EnabledExpressions))
-        EnabledExpressions.Remove(name);
+    private void DisableExpressions(IEnumerable<string> expressionNames) {
+      foreach (var expressionName in expressionNames.Intersect(EnabledExpressions))
+        DisableExpression(expressionName, false);
 
       if (EnabledExpressionsChanged != null) {
-        EnabledExpressionsChanged(this, new EnabledExpressionsChangedEventArgs(new string[0], names));
-      }
-    }
-
-    public void EnableExpression(string name, bool enableStackIfDisabled = false) {
-      if (EnabledExpressions.Contains(name)) return;
-
-      EnabledExpressions.Add(name);
-
-      if (enableStackIfDisabled) {
-        var type = ExpressionTable.TypeToNameTable.Single(x => x.Value == name).Key;
-        var attribute = ExpressionTable.TypeToAttributeTable[type];
-        enabledStacks[attribute.StackType] = true;
-      }
-
-      if (EnabledExpressionsChanged != null) {
+        EnabledExpressionsChanged(this, new EnabledExpressionsChangedEventArgs(new string[0], expressionNames));
+      }
+    }
+
+    public void EnableExpression(string expressionName) {
+      EnableExpression(expressionName, true);
+    }
+
+    private void EnableExpression(string expressionName, bool triggerExpressionChanged) {
+      if (enabledExpressions.Contains(expressionName)) return;
+
+      var type = ExpressionTable.TypeToNameTable.Single(x => x.Value == expressionName).Key;
+      var attribute = ExpressionTable.TypeToAttributeTable[type];
+
+      enabledExpressions.Add(expressionName);
+      expressionsPerStackCount[attribute.StackType]++;
+      foreach (var additionalStackType in attribute.AdditionalStackDependencies.ToValues())
+        expressionsPerStackCount[additionalStackType]++;
+
+      if (EnabledExpressionsChanged != null && triggerExpressionChanged) {
         EnabledExpressionsChanged(this, new EnabledExpressionsChangedEventArgs(
-          new[] { name },
+          new[] { expressionName },
           new string[0]));
       }
     }
 
-    public void DisableExpression(string name, bool disableStackIfEnabled = false) {
-      if (!EnabledExpressions.Contains(name)) return;
-
-      EnabledExpressions.Remove(name);
-
-      if (disableStackIfEnabled) {
-        var type = ExpressionTable.TypeToNameTable.Single(x => x.Value == name).Key;
-        var attribute = ExpressionTable.TypeToAttributeTable[type];
-        enabledStacks[attribute.StackType] = false;
-      }
-
-      if (EnabledExpressionsChanged != null) {
+    public void DisableExpression(string expressionName) {
+      DisableExpression(expressionName, true);
+    }
+
+    public void DisableExpression(string expressionName, bool triggerExpressionChanged) {
+      if (!EnabledExpressions.Contains(expressionName)) return;
+
+      var type = ExpressionTable.TypeToNameTable.Single(x => x.Value == expressionName).Key;
+      var attribute = ExpressionTable.TypeToAttributeTable[type];
+
+      enabledExpressions.Remove(expressionName);
+      expressionsPerStackCount[attribute.StackType]--;
+      foreach (var additionalStackType in attribute.AdditionalStackDependencies.ToValues())
+        expressionsPerStackCount[additionalStackType]--;
+
+      if (EnabledExpressionsChanged != null && triggerExpressionChanged) {
         EnabledExpressionsChanged(this, new EnabledExpressionsChangedEventArgs(
           new string[0],
-          new[] { name }));
-      }
-    }
-
-    public void EnableExpression<T>(bool enableStackIfDisabled = false) where T : Expression {
+          new[] { expressionName }));
+      }
+    }
+
+    public void EnableExpression<T>() where T : Expression {
       var attribute = ExpressionTable.TypeToAttributeTable[typeof(T)];
-      EnableExpression(attribute.ExpressionName, enableStackIfDisabled);
-    }
-
-    public void DisableExpression<T>(bool disableStackIfEnabled = false) where T : Expression {
+      EnableExpression(attribute.Name);
+    }
+
+    public void DisableExpression<T>() where T : Expression {
       var attribute = ExpressionTable.TypeToAttributeTable[typeof(T)];
-      DisableExpression(attribute.ExpressionName, disableStackIfEnabled);
-    }
-
-    public void SetExpression(string name, bool state, bool cascadeForStack = false) {
-      if (state) EnableExpression(name, cascadeForStack);
-      else DisableExpression(name, cascadeForStack);
-    }
-
-    public void SetExpression<T>(bool state, bool cascadeForStack = false) where T : Expression {
-      if (state) EnableExpression<T>(cascadeForStack);
-      else DisableExpression<T>(cascadeForStack);
-    }
-
-    public void EnableStack(StackTypes type, bool enableExpressions = true, bool enableDependencies = true) {
-      enabledStacks[type] = true;
-
-      if (enableExpressions) EnableExpressionOfStack(type);
-      if (enableDependencies) EnableExpressionDependentOnStack(type);
-    }
-
-    public void DisableStack(StackTypes type, bool disableExpressions = true, bool disableDependencies = true) {
-      enabledStacks[type] = false;
-
-      if (disableExpressions) DisableExpressionsOfStack(type);
-      if (disableDependencies) DisableExpressionsDependentOnStack(type);
-    }
-
-    public void SetStack(StackTypes type, bool state, bool setExpressions = true, bool setDependencies = true) {
-      if (state) EnableStack(type, setExpressions, setDependencies);
-      else DisableStack(type, setExpressions, setDependencies);
+      DisableExpression(attribute.Name);
+    }
+
+    public void SetExpression(string name, bool state) {
+      if (state) EnableExpression(name);
+      else DisableExpression(name);
+    }
+
+    public void SetExpression<T>(bool state) where T : Expression {
+      if (state) EnableExpression<T>();
+      else DisableExpression<T>();
+    }
+
+    public void EnableStack(StackTypes type, bool enableDependencies = false) {
+      EnableExpressionOfStack(type);
+
+      if (enableDependencies)
+        EnableExpressionDependentOnStack(type);
+    }
+
+    public void DisableStack(StackTypes type, bool disableDependencies = false) {
+      DisableExpressionsOfStack(type);
+
+      if (disableDependencies)
+        DisableExpressionsDependentOnStack(type);
+    }
+
+    public void SetStack(StackTypes type, bool state, bool setDependencies = false) {
+      if (state) EnableStack(type, setDependencies);
+      else DisableStack(type, setDependencies);
     }
   }
Index: /branches/PushGP/HeuristicLab.PushGP/HeuristicLab.Problems.ProgramSynthesis/Push/Configuration/PushConfigurationParameterCollection.cs
===================================================================
--- /branches/PushGP/HeuristicLab.PushGP/HeuristicLab.Problems.ProgramSynthesis/Push/Configuration/PushConfigurationParameterCollection.cs	(revision 15031)
+++ /branches/PushGP/HeuristicLab.PushGP/HeuristicLab.Problems.ProgramSynthesis/Push/Configuration/PushConfigurationParameterCollection.cs	(revision 15032)
@@ -192,5 +192,7 @@
 
     /// <summary>
-    /// This is the maximum of depth a push program can have. Expressions, which lead to exceed this limit are interpreted as NOOP.
+    /// Determines the likelyhood of smaller or bigger values.
+    /// x greater than 1 means that result is biased towards min.
+    /// x smaller than 1 means that result is biased towards max.
     /// </summary>
     public IValueParameter<DoubleValue> ParenthesesCloseBiasLevelParameter
@@ -206,5 +208,5 @@
 
     /// <summary>
-    /// This is the maximum of depth a push program can have. Expressions, which lead to exceed this limit are interpreted as NOOP.
+    /// Determines the maximum of blocks which will be closed.
     /// </summary>
     public IValueParameter<IntValue> MaxParenthesesCloseParameter
Index: /branches/PushGP/HeuristicLab.PushGP/HeuristicLab.Problems.ProgramSynthesis/Push/Expressions/BooleanExpressions.cs
===================================================================
--- /branches/PushGP/HeuristicLab.PushGP/HeuristicLab.Problems.ProgramSynthesis/Push/Expressions/BooleanExpressions.cs	(revision 15031)
+++ /branches/PushGP/HeuristicLab.PushGP/HeuristicLab.Problems.ProgramSynthesis/Push/Expressions/BooleanExpressions.cs	(revision 15032)
@@ -13,5 +13,5 @@
   ///     Pushes the logical AND of the top two BOOLEANs.
   /// </summary>
-  [PushExpression(StackTypes.Boolean, "BOOLEAN.AND")]
+  [PushExpression(StackTypes.Boolean, "BOOLEAN.AND", "Pushes the logical AND of the top two BOOLEANs.")]
   [StorableClass]
   public class BooleanAndExpression : StatelessExpression {
@@ -36,5 +36,5 @@
   ///     Pushes the logical OR of the top two BOOLEANs.
   /// </summary>
-  [PushExpression(StackTypes.Boolean, "BOOLEAN.OR")]
+  [PushExpression(StackTypes.Boolean, "BOOLEAN.OR", "Pushes the logical OR of the top two BOOLEANs.")]
   [StorableClass]
   public class BooleanOrExpression : StatelessExpression {
@@ -59,5 +59,5 @@
   ///     Pushes the logical NOT of the top BOOLEAN.
   /// </summary>
-  [PushExpression(StackTypes.Boolean, "BOOLEAN.NOT")]
+  [PushExpression(StackTypes.Boolean, "BOOLEAN.NOT", "Pushes the logical NOT of the top BOOLEAN.")]
   [StorableClass]
   public class BooleanNotExpression : StatelessExpression {
@@ -78,5 +78,5 @@
   ///     Pushes FALSE if the top FLOAT is 0.0, or TRUE otherwise.
   /// </summary>
-  [PushExpression(StackTypes.Boolean, "BOOLEAN.FROMFLOAT", StackTypes.Float)]
+  [PushExpression(StackTypes.Boolean, "BOOLEAN.FROMFLOAT", "Pushes FALSE if the top FLOAT is 0.0, or TRUE otherwise.", StackTypes.Float)]
   [StorableClass]
   public class BooleanFromFloatExpression : StatelessExpression {
@@ -98,5 +98,5 @@
   ///     Pushes FALSE if the top INTEGER is 0, or TRUE otherwise.
   /// </summary>
-  [PushExpression(StackTypes.Boolean, "BOOLEAN.FROMINTEGER", StackTypes.Integer)]
+  [PushExpression(StackTypes.Boolean, "BOOLEAN.FROMINTEGER", "Pushes FALSE if the top INTEGER is 0, or TRUE otherwise.", StackTypes.Integer)]
   [StorableClass]
   public class BooleanFromIntegerExpression : StatelessExpression {
@@ -118,5 +118,5 @@
   ///     Pushes the logical AND of the top two BOOLEANs, whereby the first value is inverted first.
   /// </summary>
-  [PushExpression(StackTypes.Boolean, "BOOLEAN.INVERT_FIRST_THEN_AND")]
+  [PushExpression(StackTypes.Boolean, "BOOLEAN.INVERT_FIRST_THEN_AND", "Pushes the logical AND of the top two BOOLEANs, whereby the first value is inverted first.")]
   [StorableClass]
   public class BooleanInvertFirstThenAnd : StatelessExpression {
@@ -141,5 +141,5 @@
   ///     Pushes the logical AND of the top two BOOLEANs, whereby the second value is inverted first.
   /// </summary>
-  [PushExpression(StackTypes.Boolean, "BOOLEAN.INVERT_SECOND_THEN_AND")]
+  [PushExpression(StackTypes.Boolean, "BOOLEAN.INVERT_SECOND_THEN_AND", "Pushes the logical AND of the top two BOOLEANs, whereby the second value is inverted first.")]
   [StorableClass]
   public class BooleanInvertSecondThenAnd : StatelessExpression {
@@ -165,5 +165,5 @@
   ///     Pushes the xor of the top tow BOOLEANs
   /// </summary>
-  [PushExpression(StackTypes.Boolean, "BOOLEAN.XOR")]
+  [PushExpression(StackTypes.Boolean, "BOOLEAN.XOR", "Pushes the xor of the top tow BOOLEANs.")]
   [StorableClass]
   public class BooleanXorExpression : StatelessExpression {
Index: /branches/PushGP/HeuristicLab.PushGP/HeuristicLab.Problems.ProgramSynthesis/Push/Expressions/CharExpressions.cs
===================================================================
--- /branches/PushGP/HeuristicLab.PushGP/HeuristicLab.Problems.ProgramSynthesis/Push/Expressions/CharExpressions.cs	(revision 15031)
+++ /branches/PushGP/HeuristicLab.PushGP/HeuristicLab.Problems.ProgramSynthesis/Push/Expressions/CharExpressions.cs	(revision 15032)
@@ -8,5 +8,12 @@
   using Stack;
 
-  [PushExpression(StackTypes.Char, "CHAR.ISWHITESPACE", StackTypes.Boolean)]
+  /// <summary>
+  /// Pushes TRUE onto the BOOLEAN stack if the top char represents a whitespace char, otherwise FALSE.
+  /// </summary>
+  [PushExpression(
+    StackTypes.Char,
+    "CHAR.ISWHITESPACE",
+    "Pushes TRUE onto the BOOLEAN stack if the top char represents a whitespace char, otherwise FALSE.",
+    StackTypes.Boolean)]
   [StorableClass]
   public class CharIsWhitespaceExpression : StatelessExpression {
@@ -25,5 +32,12 @@
   }
 
-  [PushExpression(StackTypes.Char, "CHAR.ISLETTER", StackTypes.Boolean)]
+  /// <summary>
+  /// Pushes TRUE onto the CHAR stack if the top char represents a letter, otherwise FALSE.
+  /// </summary>
+  [PushExpression(
+    StackTypes.Char,
+    "CHAR.ISLETTER",
+    "Pushes TRUE onto the CHAR stack if the top char represents a letter, otherwise FALSE.",
+    StackTypes.Boolean)]
   [StorableClass]
   public class CharIsLetterExpression : StatelessExpression {
@@ -42,5 +56,12 @@
   }
 
-  [PushExpression(StackTypes.Char, "CHAR.ISDIGIT", StackTypes.Boolean)]
+  /// <summary>
+  /// Pushes TRUE onto the CHAR stack if the top char represents a digit, otherwise FALSE.
+  /// </summary>
+  [PushExpression(
+    StackTypes.Char,
+    "CHAR.ISDIGIT",
+    "Pushes TRUE onto the CHAR stack if the top char represents a digit, otherwise FALSE.",
+    StackTypes.Boolean)]
   [StorableClass]
   public class CharIsDigitExpression : StatelessExpression {
@@ -59,5 +80,12 @@
   }
 
-  [PushExpression(StackTypes.Char, "CHAR.FROMINTEGER", StackTypes.Integer)]
+  /// <summary>
+  /// Takes the top integer, converts it to an char using ASCII encoding and pushes this char onto the CHAR stack.
+  /// </summary>
+  [PushExpression(
+    StackTypes.Char,
+    "CHAR.FROMINTEGER",
+    "Takes the top integer, converts it to an char using ASCII encoding and pushes this char onto the CHAR stack.",
+    StackTypes.Integer)]
   [StorableClass]
   public class CharFromIntegerExpression : StatelessExpression {
@@ -78,5 +106,12 @@
   }
 
-  [PushExpression(StackTypes.Char, "CHAR.FROMFLOAT", StackTypes.Float)]
+  /// <summary>
+  /// Takes the top float, casts it to an integer, converts it to an char using ASCII encoding and pushes this char onto the CHAR stack.
+  /// </summary>
+  [PushExpression(
+    StackTypes.Char,
+    "CHAR.FROMFLOAT",
+    "Takes the top float, casts it to an integer, converts it to an char using ASCII encoding and pushes this char onto the CHAR stack.",
+    StackTypes.Float)]
   [StorableClass]
   public class CharFromFloatExpression : StatelessExpression {
@@ -97,5 +132,12 @@
   }
 
-  [PushExpression(StackTypes.Char, "CHAR.ALLFROMSTRING", StackTypes.String)]
+  /// <summary>
+  /// Takes the top string and pushes the chars of this string onto the CHAR stack in reversed order.
+  /// </summary>
+  [PushExpression(
+    StackTypes.Char,
+    "CHAR.ALLFROMSTRING",
+    "Takes the top string and pushes the chars of this string onto the CHAR stack in reversed order.",
+    StackTypes.String)]
   [StorableClass]
   public class CharAllFromStringExpression : StatelessExpression {
Index: /branches/PushGP/HeuristicLab.PushGP/HeuristicLab.Problems.ProgramSynthesis/Push/Expressions/CodeExpressions.cs
===================================================================
--- /branches/PushGP/HeuristicLab.PushGP/HeuristicLab.Problems.ProgramSynthesis/Push/Expressions/CodeExpressions.cs	(revision 15031)
+++ /branches/PushGP/HeuristicLab.PushGP/HeuristicLab.Problems.ProgramSynthesis/Push/Expressions/CodeExpressions.cs	(revision 15032)
@@ -1,7 +1,5 @@
-﻿/// <summary>
-/// For explicit code manipulation and execution. May also be used as a general list data types.
-/// This types must always be present, as the top level interpreter will push any code to be executed on the
-/// CODE stack prior to execution. However, one may turn off all CODE instructions if code manipulation is not needed.
-/// </summary>
+﻿// For explicit code manipulation and execution. May also be used as a general list data types.
+// This types must always be present, as the top level interpreter will push any code to be executed on the
+// CODE stack prior to execution. However, one may turn off all CODE instructions if code manipulation is not needed.
 
 namespace HeuristicLab.Problems.ProgramSynthesis.Push.Expressions {
@@ -18,9 +16,13 @@
 
   /// <summary>
-  ///     Recursively invokes the interpreter on the program on top of the CODE stack. After evaluation the
-  ///     CODE stack is popped; normally this pops the program that was just executed, but if the expression itself
-  ///     manipulates the stack then this final pop may end up popping something else.
-  /// </summary>
-  [PushExpression(StackTypes.Code, "CODE.DO", StackTypes.Exec)]
+  /// Recursively invokes the interpreter on the program on top of the CODE stack. After evaluation the
+  /// CODE stack is popped; normally this pops the program that was just executed, but if the expression itself
+  /// manipulates the stack then this final pop may end up popping something else.
+  /// </summary>
+  [PushExpression(
+    StackTypes.Code,
+    "CODE.DO",
+    "Recursively invokes the interpreter on the program on top of the CODE stack. After evaluation the CODE stack is popped; normally this pops the program that was just executed, but if the expression itself manipulates the stack then this final pop may end up popping something else.",
+    StackTypes.Exec)]
   [StorableClass]
   public class CodeDoExpression : StatelessExpression {
@@ -40,7 +42,11 @@
 
   /// <summary>
-  ///     Like CODE.DO but pops the stack before, rather than after, the recursive execution
-  /// </summary>
-  [PushExpression(StackTypes.Code, "CODE.DO*", StackTypes.Exec)]
+  /// Like CODE.DO but pops the stack before, rather than after, the recursive execution.
+  /// </summary>
+  [PushExpression(
+    StackTypes.Code,
+    "CODE.DO*",
+    "Like CODE.DO but pops the stack before, rather than after, the recursive execution.",
+    StackTypes.Exec)]
   [StorableClass]
   public class CodeDoXExpression : StatelessExpression {
@@ -62,5 +68,8 @@
   ///     Does nothing.
   /// </summary>
-  [PushExpression(StackTypes.Code, "CODE.NOOP")]
+  [PushExpression(
+    StackTypes.Code,
+    "CODE.NOOP",
+    "Does nothing.")]
   [StorableClass]
   public class CodeNoopExpression : StatelessExpression {
@@ -79,8 +88,11 @@
 
   /// <summary>
-  ///     Specifies that the next expression submitted for execution will instead be pushed literally onto the CODE stack.
-  ///     This can be implemented by moving the top item on the EXEC stack onto the CODE stack.
-  /// </summary>
-  [PushExpression(StackTypes.Code, "CODE.QUOTE", StackTypes.Exec)]
+  /// Specifies that the next expression submitted for execution will instead be pushed literally onto the CODE stack.
+  /// </summary>
+  [PushExpression(
+    StackTypes.Code,
+    "CODE.QUOTE",
+    "Specifies that the next expression submitted for execution will instead be pushed literally onto the CODE stack.",
+    StackTypes.Exec)]
   [StorableClass]
   public class CodeQuoteExpression : StatelessExpression {
@@ -100,9 +112,13 @@
 
   /// <summary>
-  ///     If the top item of the BOOLEAN stack is TRUE this recursively executes the second item of the CODE stack;
-  ///     otherwise it recursively executes the first item of the CODE stack. Either way both elements of the CODE stack
-  ///     (and the BOOLEAN value upon which the decision was made) are popped.
-  /// </summary>
-  [PushExpression(StackTypes.Code, "CODE.IF", StackTypes.Exec | StackTypes.Boolean)]
+  /// If the top item of the BOOLEAN stack is TRUE this recursively executes the second item of the CODE stack;
+  /// otherwise it recursively executes the first item of the CODE stack. Either way both elements of the CODE stack
+  /// (and the BOOLEAN value upon which the decision was made) are popped.
+  /// </summary>
+  [PushExpression(
+    StackTypes.Code,
+    "CODE.IF",
+    "If the top item of the BOOLEAN stack is TRUE this recursively executes the second item of the CODE stack, otherwise it recursively executes the first item of the CODE stack",
+    StackTypes.Exec | StackTypes.Boolean)]
   [StorableClass]
   public class CodeIfExpression : StatelessExpression {
@@ -126,8 +142,11 @@
 
   /// <summary>
-  ///     Pushes the result of appending the top two pieces of code. If one of the pieces of code is a single instruction or
-  ///     literal (that is, something not surrounded by parentheses) then it is surrounded by parentheses first.
-  /// </summary>
-  [PushExpression(StackTypes.Code, "CODE.APPEND")]
+  /// Pushes the result of appending the top two pieces of code. If one of the pieces of code is a single instruction or
+  /// literal (that is, something not surrounded by parentheses) then it is surrounded by parentheses first.
+  /// </summary>
+  [PushExpression(
+    StackTypes.Code,
+    "CODE.APPEND",
+    "Pushes the result of appending the top two pieces of code.")]
   [StorableClass]
   public class CodeAppendExpression : StatelessExpression {
@@ -191,8 +210,12 @@
 
   /// <summary>
-  ///     Pushes TRUE onto the BOOLEAN stack if the top piece of code is a single instruction or a literal,
-  ///     and FALSE otherwise (that is, if it is something surrounded by parentheses).
-  /// </summary>
-  [PushExpression(StackTypes.Code, "CODE.ATOM", StackTypes.Boolean)]
+  /// Pushes TRUE onto the BOOLEAN stack if the top piece of code is a single instruction or a literal,
+  /// and FALSE otherwise (that is, if it is something surrounded by parentheses).
+  /// </summary>
+  [PushExpression(
+    StackTypes.Code,
+    "CODE.ATOM",
+    "Pushes TRUE onto the BOOLEAN stack if the top piece of code is a single instruction or a literal, and FALSE otherwise",
+    StackTypes.Boolean)]
   [StorableClass]
   public class CodeAtomExpression : StatelessExpression {
@@ -214,10 +237,9 @@
 
   /// <summary>
-  ///     Pushes the first item of the list on top of the CODE stack. For example, if the top piece of code is "( A B )"
-  ///     then this pushes "A" (after popping the argument). If the code on top of the stack is not a list then this has no
-  ///     effect.
-  ///     The name derives from the similar Lisp function; a more generic name would be "FIRST".
-  /// </summary>
-  [PushExpression(StackTypes.Code, "CODE.CAR")]
+  /// Pushes the first item of the list on top of the CODE stack. For example, if the top piece of code is "( A B )"
+  /// then this pushes "A" (after popping the argument). If the code on top of the stack is not a list then this has no
+  /// effect. The name derives from the similar Lisp function; a more generic name would be "FIRST".
+  /// </summary>
+  [PushExpression(StackTypes.Code, "CODE.CAR", "Pushes the first item of the list on top of the CODE stack.")]
   [StorableClass]
   public class CodeCarExpression : StatelessExpression {
@@ -241,10 +263,13 @@
 
   /// <summary>
-  ///     Pushes a version of the list from the top of the CODE stack without its first element.
-  ///     For example, if the top piece of code is "( A B )" then this pushes "( B )" (after popping the argument).
-  ///     If the code on top of the stack is not a list then this pushes the empty list ("( )"). The name derives from
-  ///     the similar Lisp function; a more generic name would be "REST".
-  /// </summary>
-  [PushExpression(StackTypes.Code, "CODE.CDR")]
+  /// Pushes a version of the list from the top of the CODE stack without its first element.
+  /// For example, if the top piece of code is "( A B )" then this pushes "( B )" (after popping the argument).
+  /// If the code on top of the stack is not a list then this pushes the empty list ("( )"). The name derives from
+  /// the similar Lisp function; a more generic name would be "REST".
+  /// </summary>
+  [PushExpression(
+    StackTypes.Code,
+    "CODE.CDR",
+    "Pushes a version of the list from the top of the CODE stack without its first element.")]
   [StorableClass]
   public class CodeCdrExpression : StatelessExpression {
@@ -276,9 +301,12 @@
 
   /// <summary>
-  ///     Pushes the result of "consing" (in the Lisp sense) the second stack item onto the first stack item
-  ///     (which is coerced to a list if necessary). For example, if the top piece of code is "( A B )" and the
-  ///     second piece of code is "X" then this pushes "( X A B )" (after popping the argument).
-  /// </summary>
-  [PushExpression(StackTypes.Code, "CODE.CONS")]
+  /// Pushes the result of "consing" (in the Lisp sense) the second stack item onto the first stack item
+  /// (which is coerced to a list if necessary). For example, if the top piece of code is "( A B )" and the
+  /// second piece of code is "X" then this pushes "( X A B )" (after popping the argument).
+  /// </summary>
+  [PushExpression(
+    StackTypes.Code,
+    "CODE.CONS",
+    "Pushes the result of \"consing\" (in the Lisp sense) the second stack item onto the first stack item.")]
   [StorableClass]
   public class CodeConsExpression : StatelessExpression {
@@ -310,12 +338,14 @@
 
   /// <summary>
-  ///     Pushes the "container" of the second CODE stack item within the first CODE stack item onto the CODE stack.
-  ///     If second item contains the first anywhere (i.e. in any nested list) then the container is the smallest sub-list
-  ///     that contains but is not equal to the first instance. For example, if the top piece of code is "( B ( C ( A ) ) ( D
-  ///     ( A ) ) )"
-  ///     and the second piece of code is "( A )" then this pushes ( C ( A ) ). Pushes an empty list if there is no such
-  ///     container.
-  /// </summary>
-  [PushExpression(StackTypes.Code, "CODE.CONTAINER")]
+  /// Pushes the "container" of the second CODE stack item within the first CODE stack item onto the CODE stack.
+  /// If second item contains the first anywhere (i.e. in any nested list) then the container is the smallest sub-list
+  /// that contains but is not equal to the first instance. For example, if the top piece of code is "( B ( C ( A ) ) ( D
+  /// ( A ) ) )" and the second piece of code is "( A )" then this pushes ( C ( A ) ). Pushes an empty list if there is no such
+  /// container.
+  /// </summary>
+  [PushExpression(
+    StackTypes.Code,
+    "CODE.CONTAINER",
+    "Pushes the \"container\" of the second CODE stack item within the first CODE stack item onto the CODE stack")]
   [StorableClass]
   public class CodeContainerExpression : StatelessExpression {
@@ -358,8 +388,12 @@
 
   /// <summary>
-  ///     Pushes TRUE on the BOOLEAN stack if the second CODE stack item contains the first CODE stack
-  ///     item anywhere (e.g. in a sub-list).
-  /// </summary>
-  [PushExpression(StackTypes.Code, "CODE.CONTAINS", StackTypes.Boolean)]
+  /// Pushes TRUE on the BOOLEAN stack if the second CODE stack item contains the first CODE stack
+  /// item anywhere (e.g. in a sub-list).
+  /// </summary>
+  [PushExpression(
+    StackTypes.Code,
+    "CODE.CONTAINS",
+    "Pushes TRUE on the BOOLEAN stack if the second CODE stack item contains the first CODE stack item anywhere.",
+    StackTypes.Boolean)]
   [StorableClass]
   public class CodeContainsExpression : StatelessExpression {
@@ -383,9 +417,13 @@
 
   /// <summary>
-  ///     Pushes the definition associated with the top NAME on the NAME stack (if any) onto the CODE stack.
-  ///     This extracts the definition for inspection/manipulation, rather than for immediate execution (although it
-  ///     may then be executed with a call to CODE.DO or a similar instruction).
-  /// </summary>
-  [PushExpression(StackTypes.Code, "CODE.DEFINITION", StackTypes.Name)]
+  /// Pushes the definition associated with the top NAME on the NAME stack (if any) onto the CODE stack.
+  /// This extracts the definition for inspection/manipulation, rather than for immediate execution (although it
+  /// may then be executed with a call to CODE.DO or a similar instruction).
+  /// </summary>
+  [PushExpression(
+    StackTypes.Code,
+    "CODE.DEFINITION",
+    "Pushes the definition associated with the top NAME on the NAME stack (if any) onto the CODE stack.",
+    StackTypes.Name)]
   [StorableClass]
   public class CodeDefinitionExpression : StatelessExpression {
@@ -432,5 +470,9 @@
   ///     </list>
   /// </summary>
-  [PushExpression(StackTypes.Code, "CODE.DISCREPANCY", StackTypes.Integer)]
+  [PushExpression(
+    StackTypes.Code,
+    "CODE.DISCREPANCY",
+    "Pushes a measure of the discrepancy between the top two CODE stack items onto the INTEGER stack",
+    StackTypes.Integer)]
   [StorableClass]
   public class CodeDiscrepancyExpression : StatelessExpression {
@@ -488,14 +530,15 @@
 
   /// <summary>
-  ///     Pushes the sub-expression of the top item of the CODE stack that is indexed by the top item of the INTEGER stack.
-  ///     The indexing here counts "points," where each parenthesized expression and each literal/instruction is considered a
-  ///     point,
-  ///     and it proceeds in depth first order. The entire piece of code is at index 0; if it is a list then the first item
-  ///     in the list
-  ///     is at index 1, etc. The integer used as the index is taken modulo the number of points in the overall expression
-  ///     (and its
-  ///     absolute value is taken in case it is negative) to ensure that it is within the meaningful range.
-  /// </summary>
-  [PushExpression(StackTypes.Code, "CODE.EXTRACT", StackTypes.Integer)]
+  /// Pushes the sub-expression of the top item of the CODE stack that is indexed by the top item of the INTEGER stack.
+  /// The indexing here counts "points," where each parenthesized expression and each literal/instruction is considered a
+  /// point, and it proceeds in depth first order. The entire piece of code is at index 0; if it is a list then the first item
+  /// in the list is at index 1, etc. The integer used as the index is taken modulo the number of points in the overall expression
+  /// (and its absolute value is taken in case it is negative) to ensure that it is within the meaningful range.
+  /// </summary>
+  [PushExpression(
+    StackTypes.Code,
+    "CODE.EXTRACT",
+    "Pushes the sub-expression of the top item of the CODE stack that is indexed by the top item of the INTEGER stack.",
+    StackTypes.Integer)]
   [StorableClass]
   public class CodeExtractExpression : StatelessExpression {
@@ -520,7 +563,11 @@
 
   /// <summary>
-  ///     Pops the BOOLEAN stack and pushes the popped item (TRUE or FALSE) onto the CODE stack.
-  /// </summary>
-  [PushExpression(StackTypes.Code, "CODE.FROMBOOLEAN", StackTypes.Boolean)]
+  /// Pops the BOOLEAN stack and pushes the popped item (TRUE or FALSE) onto the CODE stack.
+  /// </summary>
+  [PushExpression(
+    StackTypes.Code,
+    "CODE.FROMBOOLEAN",
+    "Pops the BOOLEAN stack and pushes the popped item(TRUE or FALSE) onto the CODE stack.",
+    StackTypes.Boolean)]
   [StorableClass]
   public class CodeFromBooleanExpression : StatelessExpression {
@@ -543,7 +590,11 @@
 
   /// <summary>
-  ///     Pops the FLOAT stack and pushes the popped item onto the CODE stack.
-  /// </summary>
-  [PushExpression(StackTypes.Code, "CODE.FROMFLOAT", StackTypes.Float)]
+  /// Pops the FLOAT stack and pushes the popped item onto the CODE stack.
+  /// </summary>
+  [PushExpression(
+    StackTypes.Code,
+    "CODE.FROMFLOAT",
+    "Pops the FLOAT stack and pushes the popped item onto the CODE stack.",
+    StackTypes.Float)]
   [StorableClass]
   public class CodeFromFloatExpression : StatelessExpression {
@@ -566,7 +617,11 @@
 
   /// <summary>
-  ///     Pops the INTEGER stack and pushes the popped integer onto the CODE stack.
-  /// </summary>
-  [PushExpression(StackTypes.Code, "CODE.FROMINTEGER", StackTypes.Integer)]
+  /// Pops the INTEGER stack and pushes the popped integer onto the CODE stack.
+  /// </summary>
+  [PushExpression(
+    StackTypes.Code,
+    "CODE.FROMINTEGER",
+    "Pops the INTEGER stack and pushes the popped integer onto the CODE stack.",
+    StackTypes.Integer)]
   [StorableClass]
   public class CodeFromIntegerExpression : StatelessExpression {
@@ -589,7 +644,11 @@
 
   /// <summary>
-  ///     Pops the NAME stack and pushes the popped item onto the CODE stack.
-  /// </summary>
-  [PushExpression(StackTypes.Code, "CODE.FROMNAME", StackTypes.Name)]
+  /// Pops the NAME stack and pushes the popped item onto the CODE stack.
+  /// </summary>
+  [PushExpression(
+    StackTypes.Code,
+    "CODE.FROMNAME",
+    "Pops the NAME stack and pushes the popped item onto the CODE stack.",
+    StackTypes.Name)]
   [StorableClass]
   public class CodeFromNameExpression : StatelessExpression {
@@ -611,8 +670,12 @@
 
   /// <summary>
-  ///     Pushes the result of inserting the second item of the CODE stack into the first item, at the position indexed
-  ///     by the top item of the INTEGER stack (and replacing whatever was there formerly).
-  /// </summary>
-  [PushExpression(StackTypes.Code, "CODE.CODEINSERT", StackTypes.Integer)]
+  /// Pushes the result of inserting the second item of the CODE stack into the first item, at the position indexed
+  /// by the top item of the INTEGER stack (and replacing whatever was there formerly).
+  /// </summary>
+  [PushExpression(
+    StackTypes.Code,
+    "CODE.CODEINSERT",
+    "Pushes the result of inserting the second item of the CODE stack into the first item, at the position indexed by the top item of the INTEGER stack.",
+    StackTypes.Integer)]
   [StorableClass]
   public class CodeInsertExpression : StatelessExpression {
@@ -651,10 +714,14 @@
 
   /// <summary>
-  ///     Pushes the length of the top item on the CODE stack onto the INTEGER stack.
-  ///     If the top item is not a list then this pushes a 1. If the top item is a list then this pushes the
-  ///     number of items in the top level of the list; that is, nested lists contribute only 1 to this count, no
-  ///     matter what they contain.
-  /// </summary>
-  [PushExpression(StackTypes.Code, "CODE.LENGTH", StackTypes.Integer)]
+  /// Pushes the length of the top item on the CODE stack onto the INTEGER stack.
+  /// If the top item is not a list then this pushes a 1. If the top item is a list then this pushes the
+  /// number of items in the top level of the list; that is, nested lists contribute only 1 to this count, no
+  /// matter what they contain.
+  /// </summary>
+  [PushExpression(
+    StackTypes.Code,
+    "CODE.LENGTH",
+    "Pushes the length of the top item on the CODE stack onto the INTEGER stack.",
+    StackTypes.Integer)]
   [StorableClass]
   public class CodeLengthExpression : StatelessExpression {
@@ -679,7 +746,10 @@
 
   /// <summary>
-  ///     Pushes a list of the top two items of the CODE stack onto the CODE stack.
-  /// </summary>
-  [PushExpression(StackTypes.Code, "CODE.LIST")]
+  /// Pushes a list of the top two items of the CODE stack onto the CODE stack.
+  /// </summary>
+  [PushExpression(
+    StackTypes.Code,
+    "CODE.LIST",
+    "Pushes a list of the top two items of the CODE stack onto the CODE stack.")]
   [StorableClass]
   public class CodeListExpression : StatelessExpression {
@@ -708,8 +778,12 @@
 
   /// <summary>
-  ///     Pushes TRUE onto the BOOLEAN stack if the second item of the CODE stack is a member of the first item
-  ///     (which is coerced to a list if necessary). Pushes FALSE onto the BOOLEAN stack otherwise.
-  /// </summary>
-  [PushExpression(StackTypes.Code, "CODE.MEMBER", StackTypes.Boolean)]
+  /// Pushes TRUE onto the BOOLEAN stack if the second item of the CODE stack is a member of the first item
+  /// (which is coerced to a list if necessary). Pushes FALSE onto the BOOLEAN stack otherwise.
+  /// </summary>
+  [PushExpression(
+    StackTypes.Code,
+    "CODE.MEMBER",
+    "Pushes TRUE onto the BOOLEAN stack if the second item of the CODE stack is a member of the first item, FALSE otherwise.",
+    StackTypes.Boolean)]
   [StorableClass]
   public class CodeMemberExpression : StatelessExpression {
@@ -736,9 +810,13 @@
 
   /// <summary>
-  ///     Pushes the nth element of the expression on top of the CODE stack (which is coerced to a list first if necessary).
-  ///     If the expression is an empty list then the result is an empty list. N is taken from the INTEGER stack and is taken
-  ///     modulo the length of the expression into which it is indexing.
-  /// </summary>
-  [PushExpression(StackTypes.Code, "CODE.NTH", StackTypes.Integer)]
+  /// Pushes the nth element of the expression on top of the CODE stack (which is coerced to a list first if necessary).
+  /// If the expression is an empty list then the result is an empty list. N is taken from the INTEGER stack and is taken
+  /// modulo the length of the expression into which it is indexing.
+  /// </summary>
+  [PushExpression(
+    StackTypes.Code,
+    "CODE.NTH",
+    "Pushes the nth element, whereby n is taken from the INTEGER stack, of the expression on top of the CODE stack.",
+    StackTypes.Integer)]
   [StorableClass]
   public class CodeNthExpression : StatelessExpression {
@@ -776,12 +854,14 @@
 
   /// <summary>
-  ///     Pushes the nth "CDR" (in the Lisp sense) of the expression on top of the CODE stack (which is coerced to a list
-  ///     first if necessary). If the expression is an empty list then the result is an empty list. N is taken from the
-  ///     INTEGER
-  ///     stack and is taken modulo the length of the expression into which it is indexing. A "CDR" of a list is the list
-  ///     without
-  ///     its first element.
-  /// </summary>
-  [PushExpression(StackTypes.Code, "CODE.NTHCDR", StackTypes.Integer)]
+  /// Pushes the nth "CDR" (in the Lisp sense) of the expression on top of the CODE stack (which is coerced to a list
+  /// first if necessary). If the expression is an empty list then the result is an empty list. N is taken from the
+  /// INTEGER stack and is taken modulo the length of the expression into which it is indexing. A "CDR" of a list is the list
+  /// without its first element.
+  /// </summary>
+  [PushExpression(
+    StackTypes.Code,
+    "CODE.NTHCDR",
+    "Pushes the nth \"CDR\" (in the Lisp sense) of the expression on top of the CODE stack, whereby n is taken from the INTEGER stack.",
+    StackTypes.Integer)]
   [StorableClass]
   public class CodeNthCdrExpression : StatelessExpression {
@@ -819,7 +899,11 @@
 
   /// <summary>
-  ///     Pushes TRUE onto the BOOLEAN stack if the top item of the CODE stack is an empty list, or FALSE otherwise.
-  /// </summary>
-  [PushExpression(StackTypes.Code, "CODE.NULL", StackTypes.Boolean)]
+  /// Pushes TRUE onto the BOOLEAN stack if the top item of the CODE stack is an empty list, or FALSE otherwise.
+  /// </summary>
+  [PushExpression(
+    StackTypes.Code,
+    "CODE.NULL",
+    "Pushes TRUE onto the BOOLEAN stack if the top item of the CODE stack is an empty list, or FALSE otherwise",
+    StackTypes.Boolean)]
   [StorableClass]
   public class CodeNullExpression : StatelessExpression {
@@ -840,8 +924,12 @@
 
   /// <summary>
-  ///     Pushes onto the INTEGER stack the position of the second item on the CODE stack within the first item
-  ///     (which is coerced to a list if necessary). Pushes -1 if no match is found.
-  /// </summary>
-  [PushExpression(StackTypes.Code, "CODE.POSITION", StackTypes.Integer)]
+  /// Pushes onto the INTEGER stack the position of the second item on the CODE stack within the first item
+  /// (which is coerced to a list if necessary). Pushes -1 if no match is found.
+  /// </summary>
+  [PushExpression(
+    StackTypes.Code,
+    "CODE.POSITION",
+    "Pushes onto the INTEGER stack the position of the second item on the CODE stack within the first item. Pushes -1 if no match is found",
+    StackTypes.Integer)]
   [StorableClass]
   public class CodePositionExpression : StatelessExpression {
@@ -872,8 +960,12 @@
 
   /// <summary>
-  ///     Pushes the number of "points" in the top piece of CODE onto the INTEGER stack. Each instruction, literal,
-  ///     and pair of parentheses counts as a point.
-  /// </summary>
-  [PushExpression(StackTypes.Code, "CODE.SIZE", StackTypes.Integer)]
+  /// Pushes the number of "points" in the top piece of CODE onto the INTEGER stack. Each instruction, literal,
+  /// and pair of parentheses counts as a point.
+  /// </summary>
+  [PushExpression(
+    StackTypes.Code,
+    "CODE.SIZE",
+    "Pushes the number of \"points\" in the top piece of CODE onto the INTEGER stack. Each instruction, literal, and pair of parentheses counts as a point.",
+    StackTypes.Integer)]
   [StorableClass]
   public class CodeSizeExpression : StatelessExpression {
@@ -897,10 +989,13 @@
 
   /// <summary>
-  ///     Pushes the result of substituting the third item on the code stack for the second item in the first item.
-  ///     As of this writing this is implemented only in the Lisp implementation, within which it relies on the Lisp "subst"
-  ///     function. As such, there are several problematic possibilities; for example "dotted-lists" can result in certain
-  ///     cases with empty-list arguments. If any of these problematic possibilities occurs the stack is left unchanged.
-  /// </summary>
-  [PushExpression(StackTypes.Code, "CODE.SUBST")]
+  /// Pushes the result of substituting the third item on the code stack for the second item in the first item.
+  /// As of this writing this is implemented only in the Lisp implementation, within which it relies on the Lisp "subst"
+  /// function. As such, there are several problematic possibilities; for example "dotted-lists" can result in certain
+  /// cases with empty-list arguments. If any of these problematic possibilities occurs the stack is left unchanged.
+  /// </summary>
+  [PushExpression(
+    StackTypes.Code,
+    "CODE.SUBST",
+    "Pushes the result of substituting the third item on the code stack for the second item in the first item.")]
   [StorableClass]
   public class CodeSubstitutionExpression : StatelessExpression {
Index: /branches/PushGP/HeuristicLab.PushGP/HeuristicLab.Problems.ProgramSynthesis/Push/Expressions/DefineExpressions.cs
===================================================================
--- /branches/PushGP/HeuristicLab.PushGP/HeuristicLab.Problems.ProgramSynthesis/Push/Expressions/DefineExpressions.cs	(revision 15031)
+++ /branches/PushGP/HeuristicLab.PushGP/HeuristicLab.Problems.ProgramSynthesis/Push/Expressions/DefineExpressions.cs	(revision 15032)
@@ -11,8 +11,7 @@
 
   /// <summary>
-  ///     Defines the name on top of the NAME stack as an instruction that will push the top item of the T stack onto the
-  ///     EXEC stack.
+  /// Defines the name on top of the NAME stack as an instruction that will push the top item of the T stack onto the EXEC stack.
   /// </summary>
-  /// <typeparam name="T">Stacktype</typeparam>
+  /// <typeparam name="T">Stack item type</typeparam>
   [StorableClass]
   public abstract class DefineExpression<T> : StatelessExpression {
@@ -34,5 +33,9 @@
   }
 
-  [PushExpression(StackTypes.Code, "CODE.DEFINE", StackTypes.Name)]
+  [PushExpression(
+    StackTypes.Code,
+    "CODE.DEFINE",
+    "Defines the name on top of the NAME stack as an instruction that will push the top item of the CODE stack onto the EXEC stack.",
+    StackTypes.Name)]
   [StorableClass]
   public class CodeDefineExpression : DefineExpression<Expression> {
@@ -60,5 +63,10 @@
   }
 
-  [PushExpression(StackTypes.Exec, "EXEC.DEFINE", StackTypes.Name, execIn: 1)]
+  [PushExpression(
+    StackTypes.Exec,
+    "EXEC.DEFINE",
+    "Defines the name on top of the NAME stack as an instruction that will push the top item of the EXEC stack onto the EXEC stack.",
+    StackTypes.Name,
+    execIn: 1)]
   [StorableClass]
   public class ExecDefineExpression : DefineExpression<Expression> {
@@ -85,5 +93,9 @@
   }
 
-  [PushExpression(StackTypes.Float, "FLOAT.DEFINE", StackTypes.Name)]
+  [PushExpression(
+    StackTypes.Float,
+    "FLOAT.DEFINE",
+    "Defines the name on top of the NAME stack as an instruction that will push the top item of the FLOAT stack onto the EXEC stack.",
+    StackTypes.Name)]
   [StorableClass]
   public class FloatDefineExpression : DefineExpression<double> {
@@ -108,5 +120,9 @@
   }
 
-  [PushExpression(StackTypes.Integer, "INTEGER.DEFINE", StackTypes.Name)]
+  [PushExpression(
+    StackTypes.Integer,
+    "INTEGER.DEFINE",
+    "Defines the name on top of the NAME stack as an instruction that will push the top item of the INTEGER stack onto the EXEC stack.",
+    StackTypes.Name)]
   [StorableClass]
   public class IntegerDefineExpression : DefineExpression<long> {
@@ -131,5 +147,9 @@
   }
 
-  [PushExpression(StackTypes.Boolean, "BOOLEAN.DEFINE", StackTypes.Name)]
+  [PushExpression(
+    StackTypes.Boolean,
+    "BOOLEAN.DEFINE",
+    "Defines the name on top of the NAME stack as an instruction that will push the top item of the BOOLEAN stack onto the EXEC stack.",
+    StackTypes.Name)]
   [StorableClass]
   public class BooleanDefineExpression : DefineExpression<bool> {
@@ -154,5 +174,9 @@
   }
 
-  [PushExpression(StackTypes.Char, "CHAR.DEFINE", StackTypes.Name)]
+  [PushExpression(
+    StackTypes.Char,
+    "CHAR.DEFINE",
+    "Defines the name on top of the NAME stack as an instruction that will push the top item of the CHAR stack onto the EXEC stack.",
+    StackTypes.Name)]
   [StorableClass]
   public class CharDefineExpression : DefineExpression<char> {
@@ -177,5 +201,9 @@
   }
 
-  [PushExpression(StackTypes.String, "STRING.DEFINE", StackTypes.Name)]
+  [PushExpression(
+    StackTypes.String,
+    "STRING.DEFINE",
+    "Defines the name on top of the NAME stack as an instruction that will push the top item of the STRING stack onto the EXEC stack.",
+    StackTypes.Name)]
   [StorableClass]
   public class StringDefineExpression : DefineExpression<string> {
@@ -200,5 +228,9 @@
   }
 
-  [PushExpression(StackTypes.IntegerVector, "INTEGER[].DEFINE", StackTypes.Name)]
+  [PushExpression(
+    StackTypes.IntegerVector,
+    "INTEGER[].DEFINE",
+    "Defines the name on top of the NAME stack as an instruction that will push the top item of the INTEGER[] stack onto the EXEC stack.",
+    StackTypes.Name)]
   [StorableClass]
   public class IntegerVectorDefineExpression : DefineExpression<IReadOnlyList<long>> {
@@ -223,5 +255,9 @@
   }
 
-  [PushExpression(StackTypes.FloatVector, "FLOAT[].DEFINE", StackTypes.Name)]
+  [PushExpression(
+    StackTypes.FloatVector,
+    "FLOAT[].DEFINE",
+    "Defines the name on top of the NAME stack as an instruction that will push the top item of the FLOAT[] stack onto the EXEC stack.",
+    StackTypes.Name)]
   [StorableClass]
   public class FloatVectorDefineExpression : DefineExpression<IReadOnlyList<double>> {
@@ -246,5 +282,9 @@
   }
 
-  [PushExpression(StackTypes.BooleanVector, "BOOLEAN[].DEFINE", StackTypes.Name)]
+  [PushExpression(
+    StackTypes.BooleanVector,
+    "BOOLEAN[].DEFINE",
+    "Defines the name on top of the NAME stack as an instruction that will push the top item of the BOOLEAN[] stack onto the EXEC stack.",
+    StackTypes.Name)]
   [StorableClass]
   public class BooleanVectorDefineExpression : DefineExpression<IReadOnlyList<bool>> {
@@ -269,5 +309,9 @@
   }
 
-  [PushExpression(StackTypes.StringVector, "STRING[].DEFINE", StackTypes.Name)]
+  [PushExpression(
+    StackTypes.StringVector,
+    "STRING[].DEFINE",
+    "Defines the name on top of the NAME stack as an instruction that will push the top item of the STRING[] stack onto the EXEC stack.",
+    StackTypes.Name)]
   [StorableClass]
   public class StringVectorDefineExpression : DefineExpression<IReadOnlyList<string>> {
Index: /branches/PushGP/HeuristicLab.PushGP/HeuristicLab.Problems.ProgramSynthesis/Push/Expressions/DoCountExpressions.cs
===================================================================
--- /branches/PushGP/HeuristicLab.PushGP/HeuristicLab.Problems.ProgramSynthesis/Push/Expressions/DoCountExpressions.cs	(revision 15031)
+++ /branches/PushGP/HeuristicLab.PushGP/HeuristicLab.Problems.ProgramSynthesis/Push/Expressions/DoCountExpressions.cs	(revision 15032)
@@ -16,5 +16,9 @@
   [Serializable]
   [StorableClass]
-  [PushExpression(StackTypes.Code, "CODE.DO*COUNT", StackTypes.Integer)]
+  [PushExpression(
+    StackTypes.Code,
+    "CODE.DO*COUNT",
+    "An iteration instruction that performs a loop (the body of which is taken from the CODE stack) the number of times indicated by the INTEGER argument, pushing an index (which runs from zero to one less than the number of iterations) onto the INTEGER stack prior to each execution of the loop body.",
+    StackTypes.Integer)]
   public class CodeDoCountExpression : StatelessExpression {
 
@@ -48,5 +52,10 @@
   [Serializable]
   [StorableClass]
-  [PushExpression(StackTypes.Exec, "EXEC.DO*COUNT", StackTypes.Integer, execIn: 1)]
+  [PushExpression(
+    StackTypes.Exec,
+    "EXEC.DO*COUNT",
+    "An iteration instruction that performs a loop (the body of which is taken from the EXEC stack) the number of times indicated by the INTEGER argument, pushing an index (which runs from zero to one less than the number of iterations) onto the INTEGER stack prior to each execution of the loop body.",
+    StackTypes.Integer,
+    execIn: 1)]
   public class ExecDoCountExpression : StatelessExpression {
     public ExecDoCountExpression() { }
Index: /branches/PushGP/HeuristicLab.PushGP/HeuristicLab.Problems.ProgramSynthesis/Push/Expressions/DoRangeExpressions.cs
===================================================================
--- /branches/PushGP/HeuristicLab.PushGP/HeuristicLab.Problems.ProgramSynthesis/Push/Expressions/DoRangeExpressions.cs	(revision 15031)
+++ /branches/PushGP/HeuristicLab.PushGP/HeuristicLab.Problems.ProgramSynthesis/Push/Expressions/DoRangeExpressions.cs	(revision 15032)
@@ -21,5 +21,9 @@
   [Serializable]
   [StorableClass]
-  [PushExpression(StackTypes.Code, "CODE.DO*RANGE", StackTypes.Integer)]
+  [PushExpression(
+    StackTypes.Code,
+    "CODE.DO*RANGE",
+    "An iteration instruction that executes the top item on the CODE stack a number of times that depends on the top two integers, while also pushing the loop counter onto the INTEGER stack for possible access during the execution of the body of the loop.",
+    StackTypes.Integer)]
   public class CodeDoRangeExpression : StatelessExpression {
     public CodeDoRangeExpression() { }
@@ -74,5 +78,10 @@
   [Serializable]
   [StorableClass]
-  [PushExpression(StackTypes.Exec, "EXEC.DO*RANGE", StackTypes.Integer, execIn: 1)]
+  [PushExpression(
+    stackType: StackTypes.Exec,
+    name: "EXEC.DO*RANGE",
+    description: "An iteration instruction that executes the top item on the EXEC stack a number of times that depends on the top two integers, while also pushing the loop counter onto the INTEGER stack for possible access during the execution of the body of the loop.",
+    additionalStackDependencies: StackTypes.Integer,
+    execIn: 1)]
   public class ExecDoRangeExpression : StatelessExpression {
     public ExecDoRangeExpression() { }
Index: /branches/PushGP/HeuristicLab.PushGP/HeuristicLab.Problems.ProgramSynthesis/Push/Expressions/DoTimesExpressions.cs
===================================================================
--- /branches/PushGP/HeuristicLab.PushGP/HeuristicLab.Problems.ProgramSynthesis/Push/Expressions/DoTimesExpressions.cs	(revision 15031)
+++ /branches/PushGP/HeuristicLab.PushGP/HeuristicLab.Problems.ProgramSynthesis/Push/Expressions/DoTimesExpressions.cs	(revision 15032)
@@ -14,5 +14,5 @@
   [Serializable]
   [StorableClass]
-  [PushExpression(StackTypes.Code, "CODE.DO*TIMES", StackTypes.Integer)]
+  [PushExpression(StackTypes.Code, "CODE.DO*TIMES", "Like CODE.DO*COUNT but does not push the loop counter", StackTypes.Integer)]
   public class CodeDoTimesExpression : StatelessExpression {
     public CodeDoTimesExpression() { }
@@ -61,15 +61,12 @@
 
   /// <summary>
-  ///     Like EXEC.DO*COUNT but does not push the loop counter. This should be implemented as a macro that expands into
-  ///     EXEC.DO*RANGE,
-  ///     similarly to the implementation of EXEC.DO*COUNT, except that a call to INTEGER.POP should be tacked on to the
-  ///     front of the
-  ///     loop body code in the call to EXEC.DO*RANGE. This call to INTEGER.POP will remove the loop counter, which will have
-  ///     been
-  ///     pushed by EXEC.DO*RANGE, prior to the execution of the loop body.
+  /// Like EXEC.DO*COUNT but does not push the loop counter. This should be implemented as a macro that expands into
+  /// EXEC.DO*RANGE, similarly to the implementation of EXEC.DO*COUNT, except that a call to INTEGER.POP should be tacked on to the
+  /// front of the loop body code in the call to EXEC.DO*RANGE. This call to INTEGER.POP will remove the loop counter, which will have
+  /// been pushed by EXEC.DO*RANGE, prior to the execution of the loop body.
   /// </summary>
   [Serializable]
   [StorableClass]
-  [PushExpression(StackTypes.Exec, "EXEC.DO*TIMES", StackTypes.Integer, execIn: 1)]
+  [PushExpression(StackTypes.Exec, "EXEC.DO*TIMES", "Like EXEC.DO*COUNT but does not push the loop counter", StackTypes.Integer, execIn: 1)]
   public class ExecDoTimesExpression : StatelessExpression {
     public ExecDoTimesExpression() { }
Index: /branches/PushGP/HeuristicLab.PushGP/HeuristicLab.Problems.ProgramSynthesis/Push/Expressions/DuplicateExpressions.cs
===================================================================
--- /branches/PushGP/HeuristicLab.PushGP/HeuristicLab.Problems.ProgramSynthesis/Push/Expressions/DuplicateExpressions.cs	(revision 15031)
+++ /branches/PushGP/HeuristicLab.PushGP/HeuristicLab.Problems.ProgramSynthesis/Push/Expressions/DuplicateExpressions.cs	(revision 15032)
@@ -8,6 +8,6 @@
 
   /// <summary>
-  ///     Duplicates the top item on the INTEGER stack. Does not pop its argument
-  ///     (which, if it did, would negate the effect of the duplication!).
+  /// Duplicates the top item on the T stack. Does not pop its argument
+  /// (which, if it did, would negate the effect of the duplication!).
   /// </summary>
   /// <typeparam name="T">Stacktype</typeparam>
@@ -24,5 +24,5 @@
 
   [StorableClass]
-  [PushExpression(StackTypes.Integer, "INTEGER.DUP")]
+  [PushExpression(StackTypes.Integer, "INTEGER.DUP", "Duplicates the top item on the INTEGER stack.")]
   public class IntegerDuplicateExpression : DuplicateExpression<long> {
     public IntegerDuplicateExpression() { }
@@ -40,5 +40,5 @@
 
   [StorableClass]
-  [PushExpression(StackTypes.Float, "FLOAT.DUP")]
+  [PushExpression(StackTypes.Float, "FLOAT.DUP", "Duplicates the top item on the FLOAT stack.")]
   public class FloatDuplicateExpression : DuplicateExpression<double> {
     public FloatDuplicateExpression() { }
@@ -56,5 +56,5 @@
 
   [StorableClass]
-  [PushExpression(StackTypes.Boolean, "BOOLEAN.DUP")]
+  [PushExpression(StackTypes.Boolean, "BOOLEAN.DUP", "Duplicates the top item on the BOOLEAN stack.")]
   public class BooleanDuplicateExpression : DuplicateExpression<bool> {
     public BooleanDuplicateExpression() { }
@@ -72,5 +72,5 @@
 
   [StorableClass]
-  [PushExpression(StackTypes.Name, "NAME.DUP")]
+  [PushExpression(StackTypes.Name, "NAME.DUP", "Duplicates the top item on the NAME stack.")]
   public class NameDuplicateExpression : DuplicateExpression<string> {
     public NameDuplicateExpression() { }
@@ -88,5 +88,5 @@
 
   [StorableClass]
-  [PushExpression(StackTypes.Exec, "EXEC.DUP", execIn: 1)]
+  [PushExpression(StackTypes.Exec, "EXEC.DUP", "Duplicates the top item on the EXEC stack." , execIn: 1)]
   public class ExecDuplicateExpression : DuplicateExpression<Expression> {
     public ExecDuplicateExpression() { }
@@ -104,5 +104,5 @@
 
   [StorableClass]
-  [PushExpression(StackTypes.Code, "CODE.DUP")]
+  [PushExpression(StackTypes.Code, "CODE.DUP", "Duplicates the top item on the CODE stack.")]
   public class CodeDuplicateExpression : DuplicateExpression<Expression> {
     public CodeDuplicateExpression() { }
@@ -120,5 +120,5 @@
 
   [StorableClass]
-  [PushExpression(StackTypes.Char, "CHAR.DUP")]
+  [PushExpression(StackTypes.Char, "CHAR.DUP", "Duplicates the top item on the CHAR stack.")]
   public class CharDuplicateExpression : DuplicateExpression<char> {
     public CharDuplicateExpression() { }
@@ -136,5 +136,5 @@
 
   [StorableClass]
-  [PushExpression(StackTypes.String, "STRING.DUP")]
+  [PushExpression(StackTypes.String, "STRING.DUP", "Duplicates the top item on the STRING stack.")]
   public class StringDuplicateExpression : DuplicateExpression<string> {
     public StringDuplicateExpression() { }
@@ -152,5 +152,5 @@
 
   [StorableClass]
-  [PushExpression(StackTypes.IntegerVector, "INTEGER[].DUP")]
+  [PushExpression(StackTypes.IntegerVector, "INTEGER[].DUP", "Duplicates the top item on the INTEGER[] stack.")]
   public class IntegerVectorDuplicateExpression : DuplicateExpression<IReadOnlyList<long>> {
     public IntegerVectorDuplicateExpression() { }
@@ -168,5 +168,5 @@
 
   [StorableClass]
-  [PushExpression(StackTypes.FloatVector, "FLOAT[].DUP")]
+  [PushExpression(StackTypes.FloatVector, "FLOAT[].DUP", "Duplicates the top item on the FLOAT[] stack.")]
   public class FloatVectorDuplicateExpression : DuplicateExpression<IReadOnlyList<double>> {
     public FloatVectorDuplicateExpression() { }
@@ -184,5 +184,5 @@
 
   [StorableClass]
-  [PushExpression(StackTypes.BooleanVector, "BOOLEAN[].DUP")]
+  [PushExpression(StackTypes.BooleanVector, "BOOLEAN[].DUP", "Duplicates the top item on the BOOLEAN[] stack.")]
   public class BooleanVectorDuplicateExpression : DuplicateExpression<IReadOnlyList<bool>> {
     public BooleanVectorDuplicateExpression() { }
@@ -200,5 +200,5 @@
 
   [StorableClass]
-  [PushExpression(StackTypes.StringVector, "STRING[].DUP")]
+  [PushExpression(StackTypes.StringVector, "STRING[].DUP", "Duplicates the top item on the STRING[] stack.")]
   public class StringVectorDuplicateExpression : DuplicateExpression<IReadOnlyList<string>> {
     public StringVectorDuplicateExpression() { }
Index: /branches/PushGP/HeuristicLab.PushGP/HeuristicLab.Problems.ProgramSynthesis/Push/Expressions/EmptyExpression.cs
===================================================================
--- /branches/PushGP/HeuristicLab.PushGP/HeuristicLab.Problems.ProgramSynthesis/Push/Expressions/EmptyExpression.cs	(revision 15031)
+++ /branches/PushGP/HeuristicLab.PushGP/HeuristicLab.Problems.ProgramSynthesis/Push/Expressions/EmptyExpression.cs	(revision 15032)
@@ -27,5 +27,9 @@
 
   [StorableClass]
-  [PushExpression(StackTypes.Exec, "EXEC.EMPTY", StackTypes.Boolean)]
+  [PushExpression(
+    StackTypes.Exec,
+    "EXEC.EMPTY",
+    "Pushes TRUE onto the BOOLEAN stack if the EXEC stack is empty, otherwise FALSE.",
+    StackTypes.Boolean)]
   public class ExecEmptyExpression : EmptyExpression<Expression> {
     public ExecEmptyExpression() { }
@@ -39,5 +43,9 @@
 
   [StorableClass]
-  [PushExpression(StackTypes.Code, "CODE.EMPTY", StackTypes.Boolean)]
+  [PushExpression(
+    StackTypes.Code,
+    "CODE.EMPTY",
+    "Pushes TRUE onto the BOOLEAN stack if the CODE stack is empty, otherwise FALSE.",
+    StackTypes.Boolean)]
   public class CodeEmptyExpression : EmptyExpression<Expression> {
     public CodeEmptyExpression() { }
@@ -50,5 +58,9 @@
 
   [StorableClass]
-  [PushExpression(StackTypes.Integer, "INTEGER.EMPTY", StackTypes.Boolean)]
+  [PushExpression(
+    StackTypes.Integer,
+    "INTEGER.EMPTY",
+    "Pushes TRUE onto the BOOLEAN stack if the INTEGER stack is empty, otherwise FALSE.",
+    StackTypes.Boolean)]
   public class IntegerEmptyExpression : EmptyExpression<long> {
     public IntegerEmptyExpression() { }
@@ -60,5 +72,8 @@
   }
 
-  [PushExpression(StackTypes.Float, "FLOAT.EMPTY", StackTypes.Boolean)]
+  [PushExpression(
+    StackTypes.Float,
+    "FLOAT.EMPTY", "Pushes TRUE onto the BOOLEAN stack if the FLOAT stack is empty, otherwise FALSE.",
+    StackTypes.Boolean)]
   public class FloatEmptyExpression : EmptyExpression<double> {
     public FloatEmptyExpression() { }
@@ -70,5 +85,9 @@
   }
 
-  [PushExpression(StackTypes.Boolean, "BOOLEAN.EMPTY", StackTypes.Boolean)]
+  [PushExpression(
+    StackTypes.Boolean,
+    "BOOLEAN.EMPTY",
+    "Pushes TRUE onto the BOOLEAN stack if the BOOLEAN stack is empty, otherwise FALSE.",
+    StackTypes.Boolean)]
   public class BooleanEmptyExpression : EmptyExpression<bool> {
     public BooleanEmptyExpression() { }
@@ -80,5 +99,9 @@
   }
 
-  [PushExpression(StackTypes.Char, "CHAR.EMPTY", StackTypes.Boolean)]
+  [PushExpression(
+    StackTypes.Char,
+    "CHAR.EMPTY",
+    "Pushes TRUE onto the BOOLEAN stack if the CHAR stack is empty, otherwise FALSE.",
+    StackTypes.Boolean)]
   public class CharEmptyExpression : EmptyExpression<char> {
     public CharEmptyExpression() { }
@@ -90,5 +113,9 @@
   }
 
-  [PushExpression(StackTypes.String, "STRING.EMPTY", StackTypes.Boolean)]
+  [PushExpression(
+    StackTypes.String,
+    "STRING.EMPTY",
+    "Pushes TRUE onto the BOOLEAN stack if the STRING stack is empty, otherwise FALSE.",
+    StackTypes.Boolean)]
   public class StringEmptyExpression : EmptyExpression<string> {
     public StringEmptyExpression() { }
@@ -100,5 +127,9 @@
   }
 
-  [PushExpression(StackTypes.IntegerVector, "INTEGER[].EMPTY", StackTypes.Boolean)]
+  [PushExpression(
+    StackTypes.IntegerVector,
+    "INTEGER[].EMPTY",
+    "Pushes TRUE onto the BOOLEAN stack if the INTEGER[] stack is empty, otherwise FALSE.",
+    StackTypes.Boolean)]
   public class IntegerVectorEmptyExpression : EmptyExpression<IReadOnlyList<long>> {
     public IntegerVectorEmptyExpression() { }
@@ -110,5 +141,9 @@
   }
 
-  [PushExpression(StackTypes.FloatVector, "FLOAT[].EMPTY", StackTypes.Boolean)]
+  [PushExpression(
+    StackTypes.FloatVector,
+    "FLOAT[].EMPTY",
+    "Pushes TRUE onto the BOOLEAN stack if the FLOAT[] stack is empty, otherwise FALSE.",
+    StackTypes.Boolean)]
   public class FloatVectorEmptyExpression : EmptyExpression<IReadOnlyList<double>> {
     public FloatVectorEmptyExpression() { }
@@ -120,5 +155,9 @@
   }
 
-  [PushExpression(StackTypes.BooleanVector, "BOOLEAN[].EMPTY", StackTypes.Boolean)]
+  [PushExpression(
+    StackTypes.BooleanVector,
+    "BOOLEAN[].EMPTY",
+    "Pushes TRUE onto the BOOLEAN stack if the BOOLEAN[] stack is empty, otherwise FALSE.",
+    StackTypes.Boolean)]
   public class BooleanVectorEmptyExpression : EmptyExpression<IReadOnlyList<bool>> {
     public BooleanVectorEmptyExpression() { }
@@ -130,5 +169,9 @@
   }
 
-  [PushExpression(StackTypes.StringVector, "STRING[].EMPTY", StackTypes.Boolean)]
+  [PushExpression(
+    StackTypes.StringVector,
+    "STRING[].EMPTY",
+    "Pushes TRUE onto the BOOLEAN stack if the STRING[] stack is empty, otherwise FALSE.",
+    StackTypes.Boolean)]
   public class StringVectorEmptyExpression : EmptyExpression<IReadOnlyList<string>> {
     public StringVectorEmptyExpression() { }
Index: /branches/PushGP/HeuristicLab.PushGP/HeuristicLab.Problems.ProgramSynthesis/Push/Expressions/EqualsExpressions.cs
===================================================================
--- /branches/PushGP/HeuristicLab.PushGP/HeuristicLab.Problems.ProgramSynthesis/Push/Expressions/EqualsExpressions.cs	(revision 15031)
+++ /branches/PushGP/HeuristicLab.PushGP/HeuristicLab.Problems.ProgramSynthesis/Push/Expressions/EqualsExpressions.cs	(revision 15032)
@@ -11,5 +11,5 @@
 
   /// <summary>
-  ///     Pushes TRUE onto the BOOLEAN stack if the top two items are equal, or FALSE otherwise
+  /// Pushes TRUE onto the T stack if the top two items are equal, or FALSE otherwise
   /// </summary>
   /// <typeparam name="T">Stacktype</typeparam>
@@ -40,5 +40,9 @@
 
   [StorableClass]
-  [PushExpression(StackTypes.Integer, "INTEGER.=", StackTypes.Boolean)]
+  [PushExpression(
+    StackTypes.Integer,
+    "INTEGER.=",
+    "Pushes TRUE onto the BOOLEAN stack if the top two INTEGER items are equal, or FALSE otherwise.",
+    StackTypes.Boolean)]
   public class IntegerEqualsExpression : EqualsExpression<long> {
     public IntegerEqualsExpression() { }
@@ -56,5 +60,9 @@
 
   [StorableClass]
-  [PushExpression(StackTypes.Float, "FLOAT.=", StackTypes.Boolean)]
+  [PushExpression(
+    StackTypes.Float,
+    "FLOAT.=",
+    "Pushes TRUE onto the BOOLEAN stack if the top two FLOAT items are equal, or FALSE otherwise.",
+    StackTypes.Boolean)]
   public class FloatEqualsExpression : EqualsExpression<double> {
     public FloatEqualsExpression() { }
@@ -72,5 +80,9 @@
 
   [StorableClass]
-  [PushExpression(StackTypes.Boolean, "BOOLEAN.=", StackTypes.Boolean)]
+  [PushExpression(
+    StackTypes.Boolean,
+    "BOOLEAN.=",
+    "Pushes TRUE onto the BOOLEAN stack if the top two BOOLEAN items are equal, or FALSE otherwise.",
+    StackTypes.Boolean)]
   public class BooleanEqualsExpression : EqualsExpression<bool> {
     public BooleanEqualsExpression() { }
@@ -88,5 +100,9 @@
 
   [StorableClass]
-  [PushExpression(StackTypes.Name, "NAME.=", StackTypes.Boolean)]
+  [PushExpression(
+    StackTypes.Name,
+    "NAME.=",
+    "Pushes TRUE onto the BOOLEAN stack if the top two NAME items are equal, or FALSE otherwise.",
+    StackTypes.Boolean)]
   public class NameEqualsExpression : EqualsExpression<string> {
     public NameEqualsExpression() { }
@@ -104,5 +120,10 @@
 
   [StorableClass]
-  [PushExpression(StackTypes.Exec, "EXEC.=", StackTypes.Boolean, execIn: 0)]
+  [PushExpression(
+    StackTypes.Exec,
+    "EXEC.=",
+    "Pushes TRUE onto the BOOLEAN stack if the top two EXEC items are equal, or FALSE otherwise.",
+    StackTypes.Boolean,
+    execIn: 0)]
   public class ExecEqualsExpression : EqualsExpression<Expression> {
     public ExecEqualsExpression() { }
@@ -120,5 +141,9 @@
 
   [StorableClass]
-  [PushExpression(StackTypes.Code, "CODE.=", StackTypes.Boolean)]
+  [PushExpression(
+    StackTypes.Code,
+    "CODE.=",
+    "Pushes TRUE onto the BOOLEAN stack if the top two CODE items are equal, or FALSE otherwise.",
+    StackTypes.Boolean)]
   public class CodeEqualsExpression : EqualsExpression<Expression> {
     public CodeEqualsExpression() { }
@@ -136,5 +161,9 @@
 
   [StorableClass]
-  [PushExpression(StackTypes.Char, "CHAR.=", StackTypes.Boolean)]
+  [PushExpression(
+    StackTypes.Char,
+    "CHAR.=",
+    "Pushes TRUE onto the BOOLEAN stack if the top two CHAR items are equal, or FALSE otherwise.",
+    StackTypes.Boolean)]
   public class CharEqualsExpression : EqualsExpression<char> {
     public CharEqualsExpression() { }
@@ -152,5 +181,9 @@
 
   [StorableClass]
-  [PushExpression(StackTypes.String, "STRING.=", StackTypes.Boolean)]
+  [PushExpression(
+    StackTypes.String,
+    "STRING.=",
+    "Pushes TRUE onto the BOOLEAN stack if the top two STRING items are equal, or FALSE otherwise.",
+    StackTypes.Boolean)]
   public class StringEqualsExpression : EqualsExpression<string> {
     public StringEqualsExpression() { }
@@ -168,5 +201,9 @@
 
   [StorableClass]
-  [PushExpression(StackTypes.IntegerVector, "INTEGER[].=", StackTypes.Boolean)]
+  [PushExpression(
+    StackTypes.IntegerVector,
+    "INTEGER[].=",
+    "Pushes TRUE onto the BOOLEAN stack if the top two INTEGER[] items are equal, or FALSE otherwise.",
+    StackTypes.Boolean)]
   public class IntegerVectorEqualsExpression : EqualsExpression<long> {
     public IntegerVectorEqualsExpression() { }
@@ -184,5 +221,9 @@
 
   [StorableClass]
-  [PushExpression(StackTypes.FloatVector, "FLOAT[].=", StackTypes.Boolean)]
+  [PushExpression(
+    StackTypes.FloatVector,
+    "FLOAT[].=",
+    "Pushes TRUE onto the BOOLEAN stack if the top two FLOAT[] items are equal, or FALSE otherwise.",
+    StackTypes.Boolean)]
   public class FloatVectorEqualsExpression : EqualsExpression<double> {
     public FloatVectorEqualsExpression() { }
@@ -200,5 +241,9 @@
 
   [StorableClass]
-  [PushExpression(StackTypes.BooleanVector, "BOOLEAN[].=", StackTypes.Boolean)]
+  [PushExpression(
+    StackTypes.BooleanVector,
+    "BOOLEAN[].=",
+    "Pushes TRUE onto the BOOLEAN stack if the top two BOOLEAN[] items are equal, or FALSE otherwise.",
+    StackTypes.Boolean)]
   public class BooleanVectorEqualsExpression : EqualsExpression<bool> {
     public BooleanVectorEqualsExpression() { }
@@ -216,5 +261,9 @@
 
   [StorableClass]
-  [PushExpression(StackTypes.StringVector, "STRING[].=", StackTypes.Boolean)]
+  [PushExpression(
+    StackTypes.StringVector,
+    "STRING[].=",
+    "Pushes TRUE onto the BOOLEAN stack if the top two STRING[] items are equal, or FALSE otherwise.",
+    StackTypes.Boolean)]
   public class StringVectorEqualsExpression : EqualsExpression<string> {
     public StringVectorEqualsExpression() { }
Index: /branches/PushGP/HeuristicLab.PushGP/HeuristicLab.Problems.ProgramSynthesis/Push/Expressions/ExecExpressions.cs
===================================================================
--- /branches/PushGP/HeuristicLab.PushGP/HeuristicLab.Problems.ProgramSynthesis/Push/Expressions/ExecExpressions.cs	(revision 15031)
+++ /branches/PushGP/HeuristicLab.PushGP/HeuristicLab.Problems.ProgramSynthesis/Push/Expressions/ExecExpressions.cs	(revision 15032)
@@ -15,5 +15,10 @@
   /// </summary>
   [StorableClass]
-  [PushExpression(StackTypes.Exec, "EXEC.IF", StackTypes.Boolean, execIn: 2)]
+  [PushExpression(
+    StackTypes.Exec,
+    "EXEC.IF",
+    "If the top item of the BOOLEAN stack is TRUE then this removes the second item on the EXEC stack, leaving the first item to be executed. If it is false then it removes the first item, leaving the second to be executed.",
+    StackTypes.Boolean,
+    execIn: 2)]
   public class ExecIfExpression : StatelessExpression {
     public ExecIfExpression() { }
@@ -34,8 +39,11 @@
 
   /// <summary>
-  ///     Inserts beneath the top item of the EXEC stack a new item of the form
-  ///     "( EXEC.Y <TopItem> )".
-  /// </summary>
-  [PushExpression(StackTypes.Exec, "EXEC.Y", execIn: 1)]
+  /// Inserts beneath the top item of the EXEC stack a new item of the form "( EXEC.Y <TopItem> )".
+  /// </summary>
+  [PushExpression(
+    StackTypes.Exec,
+    "EXEC.Y",
+    "Inserts beneath the top item of the EXEC stack a new item of the form \"( EXEC.Y <TopItem> )\"",
+    execIn: 1)]
   [StorableClass]
   public class ExecYExpression : StatelessExpression {
@@ -66,7 +74,11 @@
 
   /// <summary>
-  ///     Removes the second item on the EXEC stack.
-  /// </summary>
-  [PushExpression(StackTypes.Exec, "EXEC.K", execIn: 2)]
+  /// Removes the second item on the EXEC stack.
+  /// </summary>
+  [PushExpression(
+    StackTypes.Exec,
+    "EXEC.K",
+    "Removes the second item on the EXEC stack.",
+    execIn: 2)]
   [StorableClass]
   public class ExecKExpression : StatelessExpression {
@@ -86,9 +98,13 @@
 
   /// <summary>
-  ///     Pops 3 items from the EXEC stack, which we will call A, B, and C
-  ///     (with A being the first one popped). Then pushes a list containing B and C back onto the EXEC stack, followed by
-  ///     another instance of C, followed by another instance of A.
-  /// </summary>
-  [PushExpression(StackTypes.Exec, "EXEC.S", execIn: 3)]
+  /// Pops 3 items from the EXEC stack, which we will call A, B, and C
+  /// (with A being the first one popped). Then pushes a list containing B and C back onto the EXEC stack, followed by
+  /// another instance of C, followed by another instance of A.
+  /// </summary>
+  [PushExpression(
+    StackTypes.Exec,
+    "EXEC.S",
+    "Pops 3 items from the EXEC stack called A, B, and C. Then pushes a list containing B and C back onto the EXEC stack, followed by another instance of C, followed by another instance of A.",
+    execIn: 3)]
   [StorableClass]
   public class ExecSExpression : StatelessExpression {
@@ -121,10 +137,13 @@
 
   /// <summary>
-  ///     Does nothing.
+  /// Does nothing.
   /// </summary>
   ///
   [StorableClass]
   [Serializable]
-  [PushExpression(StackTypes.Exec, "EXEC.NOOP")]
+  [PushExpression(
+    StackTypes.Exec,
+    "EXEC.NOOP",
+    "Does nothing.")]
   public class ExecNoopExpression : StatelessExpression {
     public ExecNoopExpression() { }
@@ -141,5 +160,12 @@
   }
 
-  [PushExpression(StackTypes.Exec, "EXEC.WHILE", StackTypes.Boolean, execIn: 1)]
+  /// <summary>
+  /// Executes top EXEC item recursively as long top BOOLEAN is TRUE.
+  /// </summary>
+  [PushExpression(
+    StackTypes.Exec,
+    "EXEC.WHILE",
+    "Executes top EXEC item recursively as long top BOOLEAN is TRUE.",
+    StackTypes.Boolean, execIn: 1)]
   [StorableClass]
   public class ExecWhileExpression : StatelessExpression {
@@ -153,21 +179,22 @@
 
     public override void Eval(IInternalPushInterpreter interpreter) {
-      if (interpreter.BooleanStack.IsEmpty) {
+      if (interpreter.BooleanStack.IsEmpty ||
+          !interpreter.BooleanStack.Pop()) {
         interpreter.ExecStack.Pop();
         return;
       }
 
-      var booleanTop = interpreter.BooleanStack.Pop();
-
-      if (!booleanTop) {
-        interpreter.ExecStack.Pop();
-        return;
-      }
-
       interpreter.ExecStack.Push(this, interpreter.ExecStack.Top);
     }
   }
 
-  [PushExpression(StackTypes.Exec, "EXEC.DO*WHILE", execIn: 1)]
+  /// <summary>
+  /// Executes top EXEC item recursively until max. amount of eval. expressions is reached or top EXEC item removes the the recursive call.
+  /// </summary>
+  [PushExpression(
+    StackTypes.Exec,
+    "EXEC.DO*WHILE",
+    "Executes top EXEC item recursively until max. amount of eval. expressions is reached or top EXEC item removes the the recursive call.",
+    execIn: 1)]
   [StorableClass]
   public class ExecDoWhileExpression : StatelessExpression {
@@ -185,5 +212,13 @@
   }
 
-  [PushExpression(StackTypes.Exec, "EXEC.WHEN", StackTypes.Boolean, execIn: 1)]
+  /// <summary>
+  /// Top EXEC item is only executed, if top BOOLEAN is TRUE.
+  /// </summary>
+  [PushExpression(
+    StackTypes.Exec,
+    "EXEC.WHEN",
+    "Top EXEC item is only executed, if top BOOLEAN is TRUE.",
+    StackTypes.Boolean,
+    execIn: 1)]
   [StorableClass]
   public class ExecWhenExpression : StatelessExpression {
Index: /branches/PushGP/HeuristicLab.PushGP/HeuristicLab.Problems.ProgramSynthesis/Push/Expressions/ExpressionTable.cs
===================================================================
--- /branches/PushGP/HeuristicLab.PushGP/HeuristicLab.Problems.ProgramSynthesis/Push/Expressions/ExpressionTable.cs	(revision 15031)
+++ /branches/PushGP/HeuristicLab.PushGP/HeuristicLab.Problems.ProgramSynthesis/Push/Expressions/ExpressionTable.cs	(revision 15032)
@@ -60,7 +60,7 @@
         if (attribute.IsHidden) continue;
 
-        indexToNameTable.Add(indexToNameTable.Keys.Count, attribute.ExpressionName);
-        typeToNameTable.Add(type, attribute.ExpressionName);
-        nameToTypeTable.Add(attribute.ExpressionName, type);
+        indexToNameTable.Add(indexToNameTable.Keys.Count, attribute.Name);
+        typeToNameTable.Add(type, attribute.Name);
+        nameToTypeTable.Add(attribute.Name, type);
 
         if (!stackTypeToNamesTable.ContainsKey(attribute.StackType)) {
@@ -68,5 +68,5 @@
         }
 
-        stackTypeToNamesTable[attribute.StackType].Add(attribute.ExpressionName);
+        stackTypeToNamesTable[attribute.StackType].Add(attribute.Name);
 
         var dependencies = attribute.StackType | attribute.AdditionalStackDependencies;
@@ -75,5 +75,5 @@
         }
 
-        stackDependencyToNamesTable[dependencies].Add(attribute.ExpressionName);
+        stackDependencyToNamesTable[dependencies].Add(attribute.Name);
       }
 
@@ -98,7 +98,7 @@
         if (attribute.IsHidden) continue;
 
-        indexToNameTable.Add(indexToNameTable.Keys.Count, attribute.ExpressionName);
-        typeToNameTable.Add(type, attribute.ExpressionName);
-        nameToTypeTable.Add(attribute.ExpressionName, type);
+        indexToNameTable.Add(indexToNameTable.Keys.Count, attribute.Name);
+        typeToNameTable.Add(type, attribute.Name);
+        nameToTypeTable.Add(attribute.Name, type);
 
         if (!stackTypeToNamesTable.ContainsKey(attribute.StackType)) {
@@ -106,5 +106,5 @@
         }
 
-        stackTypeToNamesTable[attribute.StackType].Add(attribute.ExpressionName);
+        stackTypeToNamesTable[attribute.StackType].Add(attribute.Name);
 
         var dependencies = attribute.StackType | attribute.AdditionalStackDependencies;
@@ -113,5 +113,5 @@
         }
 
-        stackDependencyToNamesTable[dependencies].Add(attribute.ExpressionName);
+        stackDependencyToNamesTable[dependencies].Add(attribute.Name);
       }
 
Index: /branches/PushGP/HeuristicLab.PushGP/HeuristicLab.Problems.ProgramSynthesis/Push/Expressions/FloatExpressions.cs
===================================================================
--- /branches/PushGP/HeuristicLab.PushGP/HeuristicLab.Problems.ProgramSynthesis/Push/Expressions/FloatExpressions.cs	(revision 15031)
+++ /branches/PushGP/HeuristicLab.PushGP/HeuristicLab.Problems.ProgramSynthesis/Push/Expressions/FloatExpressions.cs	(revision 15032)
@@ -11,7 +11,10 @@
 
   /// <summary>
-  ///     Pushes the sum of the top two items.
-  /// </summary>
-  [PushExpression(StackTypes.Float, "FLOAT.+")]
+  /// Pushes the sum of the top two items.
+  /// </summary>
+  [PushExpression(
+    StackTypes.Float,
+    "FLOAT.+",
+    "Pushes the sum of the top two items.")]
   [StorableClass]
   public class FloatAddExpression : StatelessExpression {
@@ -37,7 +40,10 @@
 
   /// <summary>
-  ///     Pushes the difference of the top two items; that is, the second item minus the top item.
-  /// </summary>
-  [PushExpression(StackTypes.Float, "FLOAT.-")]
+  /// Pushes the difference of the top two items; that is, the second item minus the top item.
+  /// </summary>
+  [PushExpression(
+    StackTypes.Float,
+    "FLOAT.-",
+    "Pushes the difference of the top two items; that is, the second item minus the top item.")]
   [StorableClass]
   public class FloatSubtractExpression : StatelessExpression {
@@ -63,7 +69,10 @@
 
   /// <summary>
-  ///     Pushes the product of the top two items.
-  /// </summary>
-  [PushExpression(StackTypes.Float, "FLOAT.*")]
+  /// Pushes the product of the top two items.
+  /// </summary>
+  [PushExpression(
+    StackTypes.Float,
+    "FLOAT.*",
+    "Pushes the product of the top two items.")]
   [StorableClass]
   public class FloatMultiplyExpression : StatelessExpression {
@@ -89,8 +98,11 @@
 
   /// <summary>
-  ///     Pushes the quotient of the top two items; that is, the second item divided by the top item.
-  ///     If the top item is zero this acts as a NOOP.
-  /// </summary>
-  [PushExpression(StackTypes.Float, "FLOAT./")]
+  /// Pushes the quotient of the top two items; that is, the second item divided by the top item.
+  /// If the top item is zero this acts as a NOOP.
+  /// </summary>
+  [PushExpression(
+    StackTypes.Float,
+    "FLOAT./",
+    "Pushes the quotient of the top two items; that is, the second item divided by the top item. If the top item is zero this acts as a NOOP.")]
   [StorableClass]
   public class FloatDivideExpression : StatelessExpression {
@@ -116,11 +128,10 @@
 
   /// <summary>
-  ///     Pushes the second stack item modulo the top stack item. If the top item is zero this acts as a NOOP.
-  ///     The modulus is computed as the remainder of the quotient, where the quotient has first been truncated toward
-  ///     negative infinity.
-  ///     (This is taken from the definition for the generic MOD function in Common Lisp, which is described
-  ///     for example at http://www.lispworks.com/reference/HyperSpec/Body/f_mod_r.htm.)
-  /// </summary>
-  [PushExpression(StackTypes.Float, "FLOAT.%")]
+  /// Pushes the second stack item modulo the top stack item. If the top item is zero this acts as a NOOP.
+  /// </summary>
+  [PushExpression(
+    StackTypes.Float,
+    "FLOAT.%",
+    "Pushes the second stack item modulo the top stack item. If the top item is zero this acts as a NOOP.")]
   [StorableClass]
   public class FloatModuloExpression : StatelessExpression {
@@ -143,7 +154,10 @@
 
   /// <summary>
-  ///     Pushes the minimum of the top two items.
-  /// </summary>
-  [PushExpression(StackTypes.Float, "FLOAT.MIN")]
+  /// Pushes the minimum of the top two items.
+  /// </summary>
+  [PushExpression(
+    StackTypes.Float,
+    "FLOAT.MIN",
+    "Pushes the minimum of the top two items.")]
   [StorableClass]
   public class FloatMinExpression : StatelessExpression {
@@ -166,7 +180,10 @@
 
   /// <summary>
-  ///     Pushes the maximum of the top two items.
-  /// </summary>
-  [PushExpression(StackTypes.Float, "FLOAT.MAX")]
+  /// Pushes the maximum of the top two items.
+  /// </summary>
+  [PushExpression(
+    StackTypes.Float,
+    "FLOAT.MAX",
+    "Pushes the maximum of the top two items.")]
   [StorableClass]
   public class FloatMaxExpression : StatelessExpression {
@@ -189,7 +206,11 @@
 
   /// <summary>
-  ///     Pushes TRUE onto the BOOLEAN stack if the second item is less than the top item, or FALSE otherwise.
-  /// </summary>
-  [PushExpression(StackTypes.Float, "FLOAT.<", StackTypes.Boolean)]
+  /// Pushes TRUE onto the BOOLEAN stack if the second item is less than the top item, or FALSE otherwise.
+  /// </summary>
+  [PushExpression(
+    StackTypes.Float,
+    "FLOAT.<",
+    "Pushes TRUE onto the BOOLEAN stack if the second item is less than the top item, or FALSE otherwise.",
+    StackTypes.Boolean)]
   [StorableClass]
   public class FloatSmallerThanExpression : StatelessExpression {
@@ -213,7 +234,11 @@
 
   /// <summary>
-  ///     Pushes TRUE onto the BOOLEAN stack if the second item is less than the top item, or FALSE otherwise.
-  /// </summary>
-  [PushExpression(StackTypes.Float, "FLOAT.<=", StackTypes.Boolean)]
+  /// Pushes TRUE onto the BOOLEAN stack if the second item is less than the top item, or FALSE otherwise.
+  /// </summary>
+  [PushExpression(
+    StackTypes.Float,
+    "FLOAT.<=",
+    "Pushes TRUE onto the BOOLEAN stack if the second item is less than the top item, or FALSE otherwise.",
+    StackTypes.Boolean)]
   [StorableClass]
   public class FloatSmallerThanOrEqualExpression : StatelessExpression {
@@ -237,7 +262,11 @@
 
   /// <summary>
-  ///     Pushes TRUE onto the BOOLEAN stack if the second item is greater than the top item, or FALSE otherwise.
-  /// </summary>
-  [PushExpression(StackTypes.Float, "FLOAT.>", StackTypes.Boolean)]
+  /// Pushes TRUE onto the BOOLEAN stack if the second item is greater than the top item, or FALSE otherwise.
+  /// </summary>
+  [PushExpression(
+    StackTypes.Float,
+    "FLOAT.>",
+    "Pushes TRUE onto the BOOLEAN stack if the second item is greater than the top item, or FALSE otherwise.",
+    StackTypes.Boolean)]
   [StorableClass]
   public class FloatGreaterThanExpression : StatelessExpression {
@@ -261,7 +290,11 @@
 
   /// <summary>
-  ///     Pushes TRUE onto the BOOLEAN stack if the second item is greater than or equal to the top item, or FALSE otherwise.
-  /// </summary>
-  [PushExpression(StackTypes.Float, "FLOAT.>=", StackTypes.Boolean)]
+  /// Pushes TRUE onto the BOOLEAN stack if the second item is greater than or equal to the top item, or FALSE otherwise.
+  /// </summary>
+  [PushExpression(
+    StackTypes.Float,
+    "FLOAT.>=",
+    "Pushes TRUE onto the BOOLEAN stack if the second item is greater than or equal to the top item, or FALSE otherwise.",
+    StackTypes.Boolean)]
   [StorableClass]
   public class FloatGreaterThanOrEqualExpression : StatelessExpression {
@@ -285,7 +318,7 @@
 
   /// <summary>
-  ///     Pushes the sine of the top item.
-  /// </summary>
-  [PushExpression(StackTypes.Float, "FLOAT.SIN")]
+  /// Pushes the sine of the top item.
+  /// </summary>
+  [PushExpression(StackTypes.Float, "FLOAT.SIN", "Pushes the sine of the top item.")]
   [StorableClass]
   public class FloatSineExpression : StatelessExpression {
@@ -305,7 +338,7 @@
 
   /// <summary>
-  ///     Pushes the cosine of the top item.
-  /// </summary>
-  [PushExpression(StackTypes.Float, "FLOAT.COS")]
+  /// Pushes the cosine of the top item.
+  /// </summary>
+  [PushExpression(StackTypes.Float, "FLOAT.COS", "Pushes the cosine of the top item.")]
   public class FloatCosineExpression : StatelessExpression {
     public FloatCosineExpression() { }
@@ -324,7 +357,11 @@
 
   /// <summary>
-  ///     Pushes 1 if the top BOOLEAN is TRUE, or 0 if the top BOOLEAN is FALSE.
-  /// </summary>
-  [PushExpression(StackTypes.Float, "FLOAT.FROMBOOLEAN", StackTypes.Boolean)]
+  /// Pushes 1 if the top BOOLEAN is TRUE, or 0 if the top BOOLEAN is FALSE.
+  /// </summary>
+  [PushExpression(
+    StackTypes.Float,
+    "FLOAT.FROMBOOLEAN",
+    "Pushes 1 if the top BOOLEAN is TRUE, or 0 if the top BOOLEAN is FALSE.",
+    StackTypes.Boolean)]
   [StorableClass]
   public class FloatFromBooleanExpression : StatelessExpression {
@@ -346,7 +383,11 @@
 
   /// <summary>
-  ///     Pushes a floating point version of the top INTEGER.
-  /// </summary>
-  [PushExpression(StackTypes.Float, "FLOAT.FROMINTEGER", StackTypes.Integer)]
+  /// Pushes a floating point version of the top INTEGER.
+  /// </summary>
+  [PushExpression(
+    StackTypes.Float,
+    "FLOAT.FROMINTEGER",
+    "Pushes a floating point version of the top INTEGER.",
+    StackTypes.Integer)]
   [StorableClass]
   public class FloatFromIntegerExpression : StatelessExpression {
@@ -366,7 +407,11 @@
 
   /// <summary>
-  ///     Pushes the result of truncating the top CHAR.
-  /// </summary>
-  [PushExpression(StackTypes.Float, "FLOAT.FROMCHAR", StackTypes.Char)]
+  /// Pushes the result of truncating the top CHAR.
+  /// </summary>
+  [PushExpression(
+    StackTypes.Float,
+    "FLOAT.FROMCHAR",
+    "Pushes the result of truncating the top CHAR.",
+    StackTypes.Char)]
   [StorableClass]
   public class FloatFromCharExpression : StatelessExpression {
@@ -386,7 +431,11 @@
 
   /// <summary>
-  ///     Pushes the result of parsing the top STRING.
-  /// </summary>
-  [PushExpression(StackTypes.Float, "FLOAT.FROMSTRING", StackTypes.String)]
+  /// Pushes the result of parsing the top STRING.
+  /// </summary>
+  [PushExpression(
+    StackTypes.Float,
+    "FLOAT.FROMSTRING",
+    "Pushes the result of parsing the top STRING.",
+    StackTypes.String)]
   [StorableClass]
   public class FloatFromStringExpression : StatelessExpression {
@@ -411,7 +460,10 @@
 
   /// <summary>
-  ///     Pushes the result of increasing the top INTEGER by 1.
-  /// </summary>
-  [PushExpression(StackTypes.Float, "FLOAT.INC")]
+  /// Pushes the result of increasing the top INTEGER by 1.
+  /// </summary>
+  [PushExpression(
+    StackTypes.Float,
+    "FLOAT.INC",
+    "Pushes the result of increasing the top INTEGER by 1.")]
   [StorableClass]
   public class FloatIncExpression : StatelessExpression {
@@ -430,7 +482,10 @@
 
   /// <summary>
-  ///     Pushes the result of decreasing the top INTEGER by 1.
-  /// </summary>
-  [PushExpression(StackTypes.Float, "FLOAT.DEC")]
+  /// Pushes the result of decreasing the top INTEGER by 1.
+  /// </summary>
+  [PushExpression(
+    StackTypes.Float,
+    "FLOAT.DEC",
+    "Pushes the result of decreasing the top INTEGER by 1.")]
   [StorableClass]
   public class FloatDecExpression : StatelessExpression {
Index: /branches/PushGP/HeuristicLab.PushGP/HeuristicLab.Problems.ProgramSynthesis/Push/Expressions/FlushExpressions.cs
===================================================================
--- /branches/PushGP/HeuristicLab.PushGP/HeuristicLab.Problems.ProgramSynthesis/Push/Expressions/FlushExpressions.cs	(revision 15031)
+++ /branches/PushGP/HeuristicLab.PushGP/HeuristicLab.Problems.ProgramSynthesis/Push/Expressions/FlushExpressions.cs	(revision 15032)
@@ -9,5 +9,5 @@
 
   /// <summary>
-  ///     Empties the given stack.
+  /// Empties the given stack.
   /// </summary>
   /// <typeparam name="T">Stacktype</typeparam>
@@ -23,5 +23,8 @@
   }
 
-  [PushExpression(StackTypes.Integer, "INTEGER.FLUSH")]
+  [PushExpression(
+    StackTypes.Integer,
+    "INTEGER.FLUSH",
+    "Empties the INTEGER stack.")]
   [StorableClass]
   public class IntegerFlushExpression : FlushExpression<long> {
@@ -39,5 +42,8 @@
   }
 
-  [PushExpression(StackTypes.Float, "FLOAT.FLUSH")]
+  [PushExpression(
+    StackTypes.Float,
+    "FLOAT.FLUSH",
+    "Empties the FLOAT stack.")]
   [StorableClass]
   public class FloatFlushExpression : FlushExpression<double> {
@@ -55,5 +61,8 @@
   }
 
-  [PushExpression(StackTypes.Boolean, "BOOLEAN.FLUSH")]
+  [PushExpression(
+    StackTypes.Boolean,
+    "BOOLEAN.FLUSH",
+    "Empties the BOOLEAN stack.")]
   [StorableClass]
   public class BooleanFlushExpression : FlushExpression<bool> {
@@ -71,5 +80,8 @@
   }
 
-  [PushExpression(StackTypes.Name, "NAME.FLUSH")]
+  [PushExpression(
+    StackTypes.Name,
+    "NAME.FLUSH",
+    "Empties the NAME stack.")]
   [StorableClass]
   public class NameFlushExpression : FlushExpression<string> {
@@ -87,5 +99,8 @@
   }
 
-  [PushExpression(StackTypes.Exec, "EXEC.FLUSH")]
+  [PushExpression(
+    StackTypes.Exec,
+    "EXEC.FLUSH",
+    "Empties the EXEC stack.")]
   [StorableClass]
   public class ExecFlushExpression : FlushExpression<Expression> {
@@ -103,5 +118,8 @@
   }
 
-  [PushExpression(StackTypes.Code, "CODE.FLUSH")]
+  [PushExpression(
+    StackTypes.Code,
+    "CODE.FLUSH",
+    "Empties the CODE stack.")]
   [StorableClass]
   public class CodeFlushExpression : FlushExpression<Expression> {
@@ -119,5 +137,8 @@
   }
 
-  [PushExpression(StackTypes.Char, "CHAR.FLUSH")]
+  [PushExpression(
+    StackTypes.Char,
+    "CHAR.FLUSH",
+    "Empties the CHAR stack.")]
   [StorableClass]
   public class CharFlushExpression : FlushExpression<char> {
@@ -135,5 +156,8 @@
   }
 
-  [PushExpression(StackTypes.String, "STRING.FLUSH")]
+  [PushExpression(
+    StackTypes.String,
+    "STRING.FLUSH",
+    "Empties the STRING stack.")]
   [StorableClass]
   public class StringFlushExpression : FlushExpression<string> {
@@ -151,5 +175,8 @@
   }
 
-  [PushExpression(StackTypes.IntegerVector, "INTEGER[].FLUSH")]
+  [PushExpression(
+    StackTypes.IntegerVector,
+    "INTEGER[].FLUSH",
+    "Empties the INTEGER[] stack.")]
   [StorableClass]
   public class IntegerVectorFlushExpression : FlushExpression<IReadOnlyList<long>> {
@@ -167,5 +194,8 @@
   }
 
-  [PushExpression(StackTypes.FloatVector, "FLOAT[].FLUSH")]
+  [PushExpression(
+    StackTypes.FloatVector,
+    "FLOAT[].FLUSH",
+    "Empties the FLOAT[] stack.")]
   [StorableClass]
   public class FloatVectorFlushExpression : FlushExpression<IReadOnlyList<double>> {
@@ -183,5 +213,8 @@
   }
 
-  [PushExpression(StackTypes.BooleanVector, "BOOLEAN[].FLUSH")]
+  [PushExpression(
+    StackTypes.BooleanVector,
+    "BOOLEAN[].FLUSH",
+    "Empties the BOOLEAN[] stack.")]
   [StorableClass]
   public class BooleanVectorFlushExpression : FlushExpression<IReadOnlyList<bool>> {
@@ -199,5 +232,8 @@
   }
 
-  [PushExpression(StackTypes.StringVector, "STRING[].FLUSH")]
+  [PushExpression(
+    StackTypes.StringVector,
+    "STRING[].FLUSH",
+    "Empties the STRING[] stack.")]
   [StorableClass]
   public class StringVectorFlushExpression : FlushExpression<IReadOnlyList<string>> {
Index: /branches/PushGP/HeuristicLab.PushGP/HeuristicLab.Problems.ProgramSynthesis/Push/Expressions/IntegerExpressions.cs
===================================================================
--- /branches/PushGP/HeuristicLab.PushGP/HeuristicLab.Problems.ProgramSynthesis/Push/Expressions/IntegerExpressions.cs	(revision 15031)
+++ /branches/PushGP/HeuristicLab.PushGP/HeuristicLab.Problems.ProgramSynthesis/Push/Expressions/IntegerExpressions.cs	(revision 15032)
@@ -9,7 +9,10 @@
 
   /// <summary>
-  ///     Pushes the sum of the top two items.
-  /// </summary>
-  [PushExpression(StackTypes.Integer, "INTEGER.+")]
+  /// Pushes the sum of the top two items.
+  /// </summary>
+  [PushExpression(
+    StackTypes.Integer,
+    "INTEGER.+",
+    "Pushes the sum of the top two items.")]
   [StorableClass]
   public class IntegerAddExpression : StatelessExpression {
@@ -32,7 +35,10 @@
 
   /// <summary>
-  ///     Pushes the difference of the top two items; that is, the second item minus the top item.
-  /// </summary>
-  [PushExpression(StackTypes.Integer, "INTEGER.-")]
+  /// Pushes the difference of the top two items; that is, the second item minus the top item.
+  /// </summary>
+  [PushExpression(
+    StackTypes.Integer,
+    "INTEGER.-",
+    "Pushes the difference of the top two items; that is, the second item minus the top item.")]
   [StorableClass]
   public class IntegerSubtractExpression : StatelessExpression {
@@ -55,7 +61,10 @@
 
   /// <summary>
-  ///     Pushes the product of the top two items.
-  /// </summary>
-  [PushExpression(StackTypes.Integer, "INTEGER.*")]
+  /// Pushes the product of the top two items.
+  /// </summary>
+  [PushExpression(
+    StackTypes.Integer,
+    "INTEGER.*",
+    "Pushes the product of the top two items.")]
   [StorableClass]
   public class IntegerMultiplyExpression : StatelessExpression {
@@ -78,8 +87,11 @@
 
   /// <summary>
-  ///     Pushes the quotient of the top two items; that is, the second item divided by the top item.
-  ///     If the top item is zero this acts as a NOOP.
-  /// </summary>
-  [PushExpression(StackTypes.Integer, "INTEGER./")]
+  /// Pushes the quotient of the top two items; that is, the second item divided by the top item.
+  /// If the top item is zero this acts as a NOOP.
+  /// </summary>
+  [PushExpression(
+    StackTypes.Integer,
+    "INTEGER./",
+    "Pushes the quotient of the top two items; that is, the second item divided by the top item. If the top item is zero this acts as a NOOP.")]
   [StorableClass]
   public class IntegerDivideExpression : StatelessExpression {
@@ -102,10 +114,10 @@
 
   /// <summary>
-  ///     Pushes the second stack item modulo the top stack item. If the top item is zero this acts as a NOOP. The modulus is
-  ///     computed as the remainder of the quotient, where the quotient has first been truncated toward negative infinity. (This is taken
-  ///     from the definition for the generic MOD function in Common Lisp, which is described for example at
-  ///     http://www.lispworks.com/reference/HyperSpec/Body/f_mod_r.htm.)
-  /// </summary>
-  [PushExpression(StackTypes.Integer, "INTEGER.%")]
+  /// Pushes the second stack item modulo the top stack item. If the top item is zero this acts as a NOOP.
+  /// </summary>
+  [PushExpression(
+    StackTypes.Integer,
+    "INTEGER.%",
+    "Pushes the second stack item modulo the top stack item. If the top item is zero this acts as a NOOP.")]
   [StorableClass]
   public class IntegerModuloExpression : StatelessExpression {
@@ -128,7 +140,10 @@
 
   /// <summary>
-  ///     Pushes the minimum of the top two items.
-  /// </summary>
-  [PushExpression(StackTypes.Integer, "INTEGER.MIN")]
+  /// Pushes the minimum of the top two items.
+  /// </summary>
+  [PushExpression(
+    StackTypes.Integer,
+    "INTEGER.MIN",
+    "Pushes the minimum of the top two items.")]
   [StorableClass]
   public class IntegerMinExpression : StatelessExpression {
@@ -151,7 +166,10 @@
 
   /// <summary>
-  ///     Pushes the maximum of the top two items.
-  /// </summary>
-  [PushExpression(StackTypes.Integer, "INTEGER.MAX")]
+  /// Pushes the maximum of the top two items.
+  /// </summary>
+  [PushExpression(
+    StackTypes.Integer,
+    "INTEGER.MAX",
+    "Pushes the maximum of the top two items.")]
   [StorableClass]
   public class IntegerMaxExpression : StatelessExpression {
@@ -174,7 +192,11 @@
 
   /// <summary>
-  ///     Pushes TRUE onto the BOOLEAN stack if the second item is less than the top item, or FALSE otherwise.
-  /// </summary>
-  [PushExpression(StackTypes.Integer, "INTEGER.<", StackTypes.Boolean)]
+  /// Pushes TRUE onto the BOOLEAN stack if the second item is less than the top item, or FALSE otherwise.
+  /// </summary>
+  [PushExpression(
+    StackTypes.Integer,
+    "INTEGER.<",
+    "Pushes TRUE onto the BOOLEAN stack if the second item is less than the top item, or FALSE otherwise.",
+    StackTypes.Boolean)]
   [StorableClass]
   public class IntegerSmallerThanExpression : StatelessExpression {
@@ -198,7 +220,11 @@
 
   /// <summary>
-  ///     Pushes TRUE onto the BOOLEAN stack if the second item is less than or equal to the top item, or FALSE otherwise.
-  /// </summary>
-  [PushExpression(StackTypes.Integer, "INTEGER.<=", StackTypes.Boolean)]
+  /// Pushes TRUE onto the BOOLEAN stack if the second item is less than or equal to the top item, or FALSE otherwise.
+  /// </summary>
+  [PushExpression(
+    StackTypes.Integer,
+    "INTEGER.<=",
+    "Pushes TRUE onto the BOOLEAN stack if the second item is less than or equal to the top item, or FALSE otherwise.",
+    StackTypes.Boolean)]
   [StorableClass]
   public class IntegerSmallerOrEqualToExpression : StatelessExpression {
@@ -222,7 +248,11 @@
 
   /// <summary>
-  ///     Pushes TRUE onto the BOOLEAN stack if the second item is greater than the top item, or FALSE otherwise.
-  /// </summary>
-  [PushExpression(StackTypes.Integer, "INTEGER.>", StackTypes.Boolean)]
+  /// Pushes TRUE onto the BOOLEAN stack if the second item is greater than the top item, or FALSE otherwise.
+  /// </summary>
+  [PushExpression(
+    StackTypes.Integer,
+    "INTEGER.>",
+    "Pushes TRUE onto the BOOLEAN stack if the second item is greater than the top item, or FALSE otherwise.",
+    StackTypes.Boolean)]
   [StorableClass]
   public class IntegerGreaterThanExpression : StatelessExpression {
@@ -247,7 +277,11 @@
 
   /// <summary>
-  ///     Pushes TRUE onto the BOOLEAN stack if the second item is greater than or equal to the top item, or FALSE otherwise.
-  /// </summary>
-  [PushExpression(StackTypes.Integer, "INTEGER.>=", StackTypes.Boolean)]
+  /// Pushes TRUE onto the BOOLEAN stack if the second item is greater than or equal to the top item, or FALSE otherwise.
+  /// </summary>
+  [PushExpression(
+    StackTypes.Integer,
+    "INTEGER.>=",
+    "Pushes TRUE onto the BOOLEAN stack if the second item is greater than or equal to the top item, or FALSE otherwise.",
+    StackTypes.Boolean)]
   [StorableClass]
   public class IntegerGreaterOrEqualToExpression : StatelessExpression {
@@ -271,7 +305,11 @@
 
   /// <summary>
-  ///     Pushes 1 if the top BOOLEAN is TRUE, or 0 if the top BOOLEAN is FALSE.
-  /// </summary>
-  [PushExpression(StackTypes.Integer, "INTEGER.FROMBOOLEAN", StackTypes.Boolean)]
+  /// Pushes 1 if the top BOOLEAN is TRUE, or 0 if the top BOOLEAN is FALSE.
+  /// </summary>
+  [PushExpression(
+    StackTypes.Integer,
+    "INTEGER.FROMBOOLEAN",
+    "Pushes 1 if the top BOOLEAN is TRUE, or 0 if the top BOOLEAN is FALSE.",
+    StackTypes.Boolean)]
   [StorableClass]
   public class IntegerFromBooleanExpression : StatelessExpression {
@@ -292,7 +330,11 @@
 
   /// <summary>
-  ///     Pushes the result of truncating the top FLOAT.
-  /// </summary>
-  [PushExpression(StackTypes.Integer, "INTEGER.FROMFLOAT", StackTypes.Float)]
+  /// Pushes the result of truncating the top FLOAT.
+  /// </summary>
+  [PushExpression(
+    StackTypes.Integer,
+    "INTEGER.FROMFLOAT",
+    "Pushes the result of truncating the top FLOAT.",
+    StackTypes.Float)]
   [StorableClass]
   public class IntegerFromFloatExpression : StatelessExpression {
@@ -312,7 +354,11 @@
 
   /// <summary>
-  ///     Pushes the result of truncating the top CHAR.
-  /// </summary>
-  [PushExpression(StackTypes.Integer, "INTEGER.FROMCHAR", StackTypes.Char)]
+  /// Pushes the result of truncating the top CHAR.
+  /// </summary>
+  [PushExpression(
+    StackTypes.Integer,
+    "INTEGER.FROMCHAR",
+    "Pushes the result of truncating the top CHAR.",
+    StackTypes.Char)]
   [StorableClass]
   public class IntegerFromCharExpression : StatelessExpression {
@@ -332,7 +378,11 @@
 
   /// <summary>
-  ///     Pushes the result of parsing the top STRING.
-  /// </summary>
-  [PushExpression(StackTypes.Integer, "INTEGER.FROMSTRING", StackTypes.String)]
+  /// Pushes the result of parsing the top STRING.
+  /// </summary>
+  [PushExpression(
+    StackTypes.Integer,
+    "INTEGER.FROMSTRING",
+    "Pushes the result of parsing the top STRING.",
+    StackTypes.String)]
   [StorableClass]
   public class IntegerFromStringExpression : StatelessExpression {
@@ -357,7 +407,10 @@
 
   /// <summary>
-  ///     Pushes the result of increasing the top INTEGER by 1.
-  /// </summary>
-  [PushExpression(StackTypes.Integer, "INTEGER.INC")]
+  /// Pushes the result of increasing the top INTEGER by 1.
+  /// </summary>
+  [PushExpression(
+    StackTypes.Integer,
+    "INTEGER.INC",
+    "Pushes the result of increasing the top INTEGER by 1.")]
   [StorableClass]
   public class IntegerIncExpression : StatelessExpression {
@@ -376,7 +429,10 @@
 
   /// <summary>
-  ///     Pushes the result of decreasing the top INTEGER by 1.
-  /// </summary>
-  [PushExpression(StackTypes.Integer, "INTEGER.DEC")]
+  /// Pushes the result of decreasing the top INTEGER by 1.
+  /// </summary>
+  [PushExpression(
+    StackTypes.Integer,
+    "INTEGER.DEC",
+    "Pushes the result of decreasing the top INTEGER by 1.")]
   [StorableClass]
   public class IntegerDecExpression : StatelessExpression {
Index: /branches/PushGP/HeuristicLab.PushGP/HeuristicLab.Problems.ProgramSynthesis/Push/Expressions/NameExpressions.cs
===================================================================
--- /branches/PushGP/HeuristicLab.PushGP/HeuristicLab.Problems.ProgramSynthesis/Push/Expressions/NameExpressions.cs	(revision 15031)
+++ /branches/PushGP/HeuristicLab.PushGP/HeuristicLab.Problems.ProgramSynthesis/Push/Expressions/NameExpressions.cs	(revision 15032)
@@ -30,11 +30,12 @@
 
   /// <summary>
-  ///     Sets a flag indicating that the next State encountered will be pushed onto the NAME stack (and not have its
-  ///     associated value
-  ///     pushed onto the EXEC stack), regardless of whether or not it has a definition. Upon encountering such a State and
-  ///     pushing it
-  ///     onto the NAME stack the flag will be cleared (whether or not the pushed State had a definition).
+  /// Sets a flag indicating that the next State encountered will be pushed onto the NAME stack (and not have its
+  /// associated value pushed onto the EXEC stack), regardless of whether or not it has a definition. Upon encountering such a State and
+  /// pushing it onto the NAME stack the flag will be cleared (whether or not the pushed State had a definition).
   /// </summary>
-  [PushExpression(StackTypes.Name, "NAME.QUOTE")]
+  [PushExpression(
+    StackTypes.Name,
+    "NAME.QUOTE",
+    "Sets a flag indicating that the next State encountered will be pushed onto the NAME stack")]
   [StorableClass]
   public class NameQuoteExpression : StatelessExpression {
@@ -53,7 +54,10 @@
 
   /// <summary>
-  ///     Pushes a randomly selected NAME that already has a definition.
+  /// Pushes a randomly selected NAME that already has a definition.
   /// </summary>
-  [PushExpression(StackTypes.Name, "NAME.RANDBOUNDNAME")]
+  [PushExpression(
+    StackTypes.Name,
+    "NAME.RANDBOUNDNAME",
+    "Pushes a randomly selected NAME that already has a definition.")]
   [StorableClass]
   public class NameRandBoundNameExpression : StatelessExpression {
Index: /branches/PushGP/HeuristicLab.PushGP/HeuristicLab.Problems.ProgramSynthesis/Push/Expressions/PopExpressions.cs
===================================================================
--- /branches/PushGP/HeuristicLab.PushGP/HeuristicLab.Problems.ProgramSynthesis/Push/Expressions/PopExpressions.cs	(revision 15031)
+++ /branches/PushGP/HeuristicLab.PushGP/HeuristicLab.Problems.ProgramSynthesis/Push/Expressions/PopExpressions.cs	(revision 15032)
@@ -20,5 +20,5 @@
 
   [StorableClass]
-  [PushExpression(StackTypes.Integer, "INTEGER.POP")]
+  [PushExpression(StackTypes.Integer, "INTEGER.POP", "Pops the top INTEGER item.")]
   public class IntegerPopExpression : PopExpression<long> {
     public IntegerPopExpression() { }
@@ -36,5 +36,5 @@
 
   [StorableClass]
-  [PushExpression(StackTypes.Float, "FLOAT.POP")]
+  [PushExpression(StackTypes.Float, "FLOAT.POP", "Pops the top FLOAT item.")]
   public class FloatPopExpression : PopExpression<double> {
     public FloatPopExpression() { }
@@ -52,5 +52,5 @@
 
   [StorableClass]
-  [PushExpression(StackTypes.Boolean, "BOOLEAN.POP")]
+  [PushExpression(StackTypes.Boolean, "BOOLEAN.POP", "Pops the top BOOLEAN item.")]
   public class BooleanPopExpression : PopExpression<bool> {
     public BooleanPopExpression() { }
@@ -68,5 +68,5 @@
 
   [StorableClass]
-  [PushExpression(StackTypes.Name, "NAME.POP")]
+  [PushExpression(StackTypes.Name, "NAME.POP", "Pops the top NAME item.")]
   public class NamePopExpression : PopExpression<string> {
     public NamePopExpression() { }
@@ -84,5 +84,5 @@
 
   [StorableClass]
-  [PushExpression(StackTypes.Exec, "EXEC.POP", execIn: 1)]
+  [PushExpression(StackTypes.Exec, "EXEC.POP", "Pops the top EXEC item.", execIn: 1)]
   public class ExecPopExpression : PopExpression<Expression> {
     public ExecPopExpression() { }
@@ -100,5 +100,5 @@
 
   [StorableClass]
-  [PushExpression(StackTypes.Code, "CODE.POP")]
+  [PushExpression(StackTypes.Code, "CODE.POP", "Pops the top CODE item.")]
   public class CodePopExpression : PopExpression<Expression> {
     public CodePopExpression() { }
@@ -116,5 +116,5 @@
 
   [StorableClass]
-  [PushExpression(StackTypes.Char, "CHAR.POP")]
+  [PushExpression(StackTypes.Char, "CHAR.POP", "Pops the top CHAR item.")]
   public class CharPopExpression : PopExpression<char> {
     public CharPopExpression() { }
@@ -132,5 +132,5 @@
 
   [StorableClass]
-  [PushExpression(StackTypes.String, "STRING.POP")]
+  [PushExpression(StackTypes.String, "STRING.POP", "Pops the top STRING item.")]
   public class StringPopExpression : PopExpression<string> {
     public StringPopExpression() { }
@@ -148,5 +148,5 @@
 
   [StorableClass]
-  [PushExpression(StackTypes.IntegerVector, "INTEGER[].POP")]
+  [PushExpression(StackTypes.IntegerVector, "INTEGER[].POP", "Pops the top INTEGER[] item.")]
   public class IntegerVectorPopExpression : PopExpression<IReadOnlyList<long>> {
     public IntegerVectorPopExpression() { }
@@ -164,5 +164,5 @@
 
   [StorableClass]
-  [PushExpression(StackTypes.FloatVector, "FLOAT[].POP")]
+  [PushExpression(StackTypes.FloatVector, "FLOAT[].POP", "Pops the top FLOAT[] item.")]
   public class FloatVectorPopExpression : PopExpression<IReadOnlyList<double>> {
     public FloatVectorPopExpression() { }
@@ -180,5 +180,5 @@
 
   [StorableClass]
-  [PushExpression(StackTypes.BooleanVector, "BOOLEAN[].POP")]
+  [PushExpression(StackTypes.BooleanVector, "BOOLEAN[].POP", "Pops the top BOOLEAN[] item.")]
   public class BooleanVectorPopExpression : PopExpression<IReadOnlyList<bool>> {
     public BooleanVectorPopExpression() { }
@@ -196,5 +196,5 @@
 
   [StorableClass]
-  [PushExpression(StackTypes.StringVector, "STRING[].POP")]
+  [PushExpression(StackTypes.StringVector, "STRING[].POP", "Pops the top STRING[] item.")]
   public class StringVectorPopExpression : PopExpression<IReadOnlyList<string>> {
     public StringVectorPopExpression() { }
Index: /branches/PushGP/HeuristicLab.PushGP/HeuristicLab.Problems.ProgramSynthesis/Push/Expressions/PrintExpressions.cs
===================================================================
--- /branches/PushGP/HeuristicLab.PushGP/HeuristicLab.Problems.ProgramSynthesis/Push/Expressions/PrintExpressions.cs	(revision 15031)
+++ /branches/PushGP/HeuristicLab.PushGP/HeuristicLab.Problems.ProgramSynthesis/Push/Expressions/PrintExpressions.cs	(revision 15032)
@@ -10,5 +10,5 @@
 
   [StorableClass]
-  [PushExpression(StackTypes.Print, "PRINT.NEWLINE")]
+  [PushExpression(StackTypes.Print, "PRINT.NEWLINE", "Pushes an empty string onto the PRINT STACK.")]
   public class PrintNewLineExpression : StatelessExpression {
     public PrintNewLineExpression() { }
@@ -63,5 +63,9 @@
 
   [StorableClass]
-  [PushExpression(StackTypes.Print, "PRINT.PRINTBOOLEAN", StackTypes.Boolean)]
+  [PushExpression(
+    StackTypes.Print,
+    "PRINT.PRINTBOOLEAN",
+    "Pushes the top BOOLEAN onto the PRINT stack.",
+    StackTypes.Boolean)]
   public class BooleanPrintExpression : PrintExpression<bool> {
     public BooleanPrintExpression() { }
@@ -79,5 +83,9 @@
 
   [StorableClass]
-  [PushExpression(StackTypes.Print, "PRINT.PRINTCHAR", StackTypes.Char)]
+  [PushExpression(
+    StackTypes.Print,
+    "PRINT.PRINTCHAR",
+    "Pushes the top CHAR onto the PRINT stack.",
+    StackTypes.Char)]
   public class CharPrintExpression : PrintExpression<char> {
     public CharPrintExpression() { }
@@ -95,5 +103,10 @@
 
   [StorableClass]
-  [PushExpression(StackTypes.Print, "PRINT.PRINTEXEC", StackTypes.Exec, execIn: 1)]
+  [PushExpression(
+    StackTypes.Print,
+    "PRINT.PRINTEXEC",
+    "Pushes the top BOOLEAN onto the EXEC stack.",
+    StackTypes.Exec,
+    execIn: 1)]
   public class ExecPrintExpression : PrintExpression<Expression> {
     public ExecPrintExpression() { }
@@ -111,5 +124,9 @@
 
   [StorableClass]
-  [PushExpression(StackTypes.Print, "PRINT.PRINTFLOAT", StackTypes.Float)]
+  [PushExpression(
+    StackTypes.Print,
+    "PRINT.PRINTFLOAT",
+    "Pushes the top FLOAT onto the PRINT stack.",
+    StackTypes.Float)]
   public class FloatPrintExpression : PrintExpression<double> {
     public FloatPrintExpression() { }
@@ -133,5 +150,9 @@
 
   [StorableClass]
-  [PushExpression(StackTypes.Print, "PRINT.PRINTINTEGER", StackTypes.Integer)]
+  [PushExpression(
+    StackTypes.Print,
+    "PRINT.PRINTINTEGER",
+    "Pushes the top INTEGER onto the PRINT stack.",
+    StackTypes.Integer)]
   public class IntegerPrintExpression : PrintExpression<long> {
     public IntegerPrintExpression() { }
@@ -149,5 +170,9 @@
 
   [StorableClass]
-  [PushExpression(StackTypes.Print, "PRINT.PRINTSTRING", StackTypes.String)]
+  [PushExpression(
+    StackTypes.Print,
+    "PRINT.PRINTSTRING",
+    "Pushes the top STRING onto the PRINT stack.",
+    StackTypes.String)]
   public class StringPrintExpression : PrintExpression<string> {
     public StringPrintExpression() { }
@@ -165,5 +190,9 @@
 
   [StorableClass]
-  [PushExpression(StackTypes.Print, "PRINT.PRINTINTEGERVECTOR", StackTypes.IntegerVector)]
+  [PushExpression(
+    StackTypes.Print,
+    "PRINT.PRINTINTEGERVECTOR",
+    "Pushes the top INTEGER[] onto the PRINT stack.",
+    StackTypes.IntegerVector)]
   public class IntegerVectorPrintExpression : PrintExpression<long> {
     public IntegerVectorPrintExpression() { }
@@ -181,5 +210,9 @@
 
   [StorableClass]
-  [PushExpression(StackTypes.Print, "PRINT.PRINTFLOATVECTOR", StackTypes.FloatVector)]
+  [PushExpression(
+    StackTypes.Print,
+    "PRINT.PRINTFLOATVECTOR",
+    "Pushes the top FLOAT[] onto the PRINT stack.",
+    StackTypes.FloatVector)]
   public class FloatVectorPrintExpression : PrintExpression<double> {
     public FloatVectorPrintExpression() { }
@@ -197,5 +230,9 @@
 
   [StorableClass]
-  [PushExpression(StackTypes.Print, "PRINT.PRINTSTRINGVECTOR", StackTypes.StringVector)]
+  [PushExpression(
+    StackTypes.Print,
+    "PRINT.PRINTSTRINGVECTOR",
+    "Pushes the top STRING[] onto the PRINT stack.",
+    StackTypes.StringVector)]
   public class StringVectorPrintExpression : PrintExpression<string> {
     public StringVectorPrintExpression() { }
@@ -213,5 +250,9 @@
 
   [StorableClass]
-  [PushExpression(StackTypes.Print, "PRINT.PRINTBOOLEANVECTOR", StackTypes.BooleanVector)]
+  [PushExpression(
+    StackTypes.Print,
+    "PRINT.PRINTBOOLEANVECTOR",
+    "Pushes the top BOOLEAN[] onto the PRINT stack.",
+    StackTypes.BooleanVector)]
   public class BooleanVectorPrintExpression : PrintExpression<bool> {
     public BooleanVectorPrintExpression() { }
Index: /branches/PushGP/HeuristicLab.PushGP/HeuristicLab.Problems.ProgramSynthesis/Push/Expressions/PushExpressions.cs
===================================================================
--- /branches/PushGP/HeuristicLab.PushGP/HeuristicLab.Problems.ProgramSynthesis/Push/Expressions/PushExpressions.cs	(revision 15031)
+++ /branches/PushGP/HeuristicLab.PushGP/HeuristicLab.Problems.ProgramSynthesis/Push/Expressions/PushExpressions.cs	(revision 15032)
@@ -49,5 +49,5 @@
   [StorableClass]
   [Serializable]
-  [PushExpression(StackTypes.Integer, "INTEGER.PUSH", isHidden: true)]
+  [PushExpression(StackTypes.Integer, "INTEGER.PUSH", "Pushes a specific integer onto the INTEGER stack", isHidden: true)]
   public class IntegerPushExpression : PushExpression<long> {
     [StorableConstructor]
@@ -78,5 +78,5 @@
   [StorableClass]
   [Serializable]
-  [PushExpression(StackTypes.Float, "FLOAT.PUSH", isHidden: true)]
+  [PushExpression(StackTypes.Float, "FLOAT.PUSH", "Pushes a specific float onto the FLOAT stack", isHidden: true)]
   public class FloatPushExpression : PushExpression<double> {
     [StorableConstructor]
@@ -107,5 +107,5 @@
   [StorableClass]
   [Serializable]
-  [PushExpression(StackTypes.Boolean, "BOOLEAN.PUSH", isHidden: true)]
+  [PushExpression(StackTypes.Boolean, "BOOLEAN.PUSH", "Pushes a specific boolean onto the BOOLEAN stack", isHidden: true)]
   public class BooleanPushExpression : PushExpression<bool> {
     [StorableConstructor]
@@ -136,5 +136,5 @@
   [StorableClass]
   [Serializable]
-  [PushExpression(StackTypes.Name, "NAME.PUSH", isHidden: true)]
+  [PushExpression(StackTypes.Name, "NAME.PUSH", "Pushes a specific name onto the NAME stack", isHidden: true)]
   public class NamePushExpression : PushExpression<string> {
     [StorableConstructor]
@@ -161,5 +161,5 @@
   [StorableClass]
   [Serializable]
-  [PushExpression(StackTypes.Exec, "EXEC.PUSH", isHidden: true)]
+  [PushExpression(StackTypes.Exec, "EXEC.PUSH", "Pushes a specific expression onto the EXEC stack", isHidden: true)]
   public class ExecPushExpression : PushExpression<Expression> {
     [StorableConstructor]
@@ -191,5 +191,5 @@
   [StorableClass]
   [Serializable]
-  [PushExpression(StackTypes.Char, "CHAR.PUSH", isHidden: true)]
+  [PushExpression(StackTypes.Char, "CHAR.PUSH", "Pushes a specific char onto the CHAR stack", isHidden: true)]
   public class CharPushExpression : PushExpression<char> {
     [StorableConstructor]
@@ -225,5 +225,5 @@
   [StorableClass]
   [Serializable]
-  [PushExpression(StackTypes.String, "STRING.PUSH", isHidden: true)]
+  [PushExpression(StackTypes.String, "STRING.PUSH", "Pushes a specific string onto the STRING stack", isHidden: true)]
   public class StringPushExpression : PushExpression<string> {
     [StorableConstructor]
@@ -258,5 +258,5 @@
   [StorableClass]
   [Serializable]
-  [PushExpression(StackTypes.IntegerVector, "INTEGER[].PUSH", isHidden: true)]
+  [PushExpression(StackTypes.IntegerVector, "INTEGER[].PUSH", "Pushes a specific integer vector onto the INTEGER[] stack", isHidden: true)]
   public class IntegerVectorPushExpression : VectorPushExpression<long> {
     [StorableConstructor]
@@ -289,5 +289,5 @@
   [StorableClass]
   [Serializable]
-  [PushExpression(StackTypes.FloatVector, "FLOAT[].PUSH", isHidden: true)]
+  [PushExpression(StackTypes.FloatVector, "FLOAT[].PUSH", "Pushes a specific float vector onto the FLOAT[] stack", isHidden: true)]
   public class FloatVectorPushExpression : VectorPushExpression<double> {
     [StorableConstructor]
@@ -319,5 +319,5 @@
   [StorableClass]
   [Serializable]
-  [PushExpression(StackTypes.BooleanVector, "BOOLEAN[].PUSH", isHidden: true)]
+  [PushExpression(StackTypes.BooleanVector, "BOOLEAN[].PUSH", "Pushes a specific boolean vector onto the BOOLEAN[] stack", isHidden: true)]
   public class BooleanVectorPushExpression : VectorPushExpression<bool> {
     [StorableConstructor]
@@ -349,5 +349,5 @@
   [StorableClass]
   [Serializable]
-  [PushExpression(StackTypes.StringVector, "STRING[].PUSH", isHidden: true)]
+  [PushExpression(StackTypes.StringVector, "STRING[].PUSH", "Pushes a specific string vector onto the STRING[] stack", isHidden: true)]
   public class StringVectorPushExpression : VectorPushExpression<string> {
     [StorableConstructor]
Index: /branches/PushGP/HeuristicLab.PushGP/HeuristicLab.Problems.ProgramSynthesis/Push/Expressions/RandExpressions.cs
===================================================================
--- /branches/PushGP/HeuristicLab.PushGP/HeuristicLab.Problems.ProgramSynthesis/Push/Expressions/RandExpressions.cs	(revision 15031)
+++ /branches/PushGP/HeuristicLab.PushGP/HeuristicLab.Problems.ProgramSynthesis/Push/Expressions/RandExpressions.cs	(revision 15032)
@@ -11,7 +11,10 @@
 
   /// <summary>
-  ///     Pushes a random NAME.
-  /// </summary>
-  [PushExpression(StackTypes.Name, "NAME.RAND")]
+  /// Pushes a random already defined name or a new one onto the NAME stack.
+  /// </summary>
+  [PushExpression(
+    StackTypes.Name,
+    "NAME.RAND",
+    "Pushes a random already defined name or a new one based on the Name-ERC-Options onto the NAME stack.")]
   [StorableClass]
   public class NameRandExpression : StatelessExpression {
@@ -31,7 +34,10 @@
 
   /// <summary>
-  ///     Pushes a random integer.
-  /// </summary>
-  [PushExpression(StackTypes.Integer, "INTEGER.RAND")]
+  /// Pushes a random integer.
+  /// </summary>
+  [PushExpression(
+    StackTypes.Integer,
+    "INTEGER.RAND",
+    "Pushes a random integer based on the Integer-ERC-Options  onto the INTEGER stack.")]
   [StorableClass]
   public class IntegerRandExpression : StatelessExpression {
@@ -51,7 +57,10 @@
 
   /// <summary>
-  ///     Pushes a random float.
-  /// </summary>
-  [PushExpression(StackTypes.Float, "FLOAT.RAND")]
+  ///  Pushes a random float.
+  /// </summary>
+  [PushExpression(
+    StackTypes.Float,
+    "FLOAT.RAND",
+    "Pushes a random float based on the Float-ERC-Options onto the FLOAT stack.")]
   [StorableClass]
   public class FloatRandExpression : StatelessExpression {
@@ -73,5 +82,8 @@
   ///     Pushes a random boolean.
   /// </summary>
-  [PushExpression(StackTypes.Boolean, "BOOLEAN.RAND")]
+  [PushExpression(
+    StackTypes.Boolean,
+    "BOOLEAN.RAND",
+    "Pushes a random boolean based on the Boolean-ERC-Options onto the BOOLEAN stack.")]
   [StorableClass]
   public class BooleanRandExpression : StatelessExpression {
@@ -93,5 +105,8 @@
   ///     Pushes random expressions onto the code stack.
   /// </summary>
-  [PushExpression(StackTypes.Code, "CODE.RAND")]
+  [PushExpression(
+    StackTypes.Code,
+    "CODE.RAND",
+    "Pushes a random code onto the CODE stack.")]
   [StorableClass]
   public class CodeRandExpression : StatelessExpression {
@@ -121,5 +136,8 @@
   ///     Pushes a random char.
   /// </summary>
-  [PushExpression(StackTypes.Char, "CHAR.RAND")]
+  [PushExpression(
+    StackTypes.Char,
+    "CHAR.RAND",
+    "Pushes a random char based on the Char-ERC-Options onto the CHAR stack.")]
   [StorableClass]
   public class CharRandExpression : StatelessExpression {
@@ -140,5 +158,8 @@
     ///     Pushes a random string.
     /// </summary>
-    [PushExpression(StackTypes.String, "STRING.RAND")]
+    [PushExpression(
+      StackTypes.String,
+      "STRING.RAND",
+      "Pushes a random string based on the String-ERC-Options onto the STRING stack.")]
     [StorableClass]
     public class StringRandExpression : StatelessExpression {
@@ -159,5 +180,8 @@
       ///     Pushes a random interger vector.
       /// </summary>
-      [PushExpression(StackTypes.IntegerVector, "INTEGER[].RAND")]
+      [PushExpression(
+        StackTypes.IntegerVector,
+        "INTEGER[].RAND",
+        "Pushes a random integer vector based on the Integer-Vector-ERC-Options onto the INTEGER[] stack.")]
       [StorableClass]
       public class IntegerVectorRandExpression : StatelessExpression {
@@ -179,5 +203,8 @@
       ///     Pushes a random float vector.
       /// </summary>
-      [PushExpression(StackTypes.FloatVector, "FLOAT[].RAND")]
+      [PushExpression(
+        StackTypes.FloatVector,
+        "FLOAT[].RAND",
+        "Pushes a random float vector based on the Float-Vector-ERC-Options onto the FLOAT[] stack.")]
       [StorableClass]
       public class FloatVectorRandExpression : StatelessExpression {
@@ -199,5 +226,8 @@
       ///     Pushes a random boolean vector.
       /// </summary>
-      [PushExpression(StackTypes.StringVector, "STRING[].RAND")]
+      [PushExpression(
+        StackTypes.StringVector,
+        "STRING[].RAND",
+        "Pushes a random string vector based on the String-Vector-ERC-Options onto the STRING[] stack.")]
       [StorableClass]
       public class StringVectorRandExpression : StatelessExpression {
Index: /branches/PushGP/HeuristicLab.PushGP/HeuristicLab.Problems.ProgramSynthesis/Push/Expressions/RotateExpressions.cs
===================================================================
--- /branches/PushGP/HeuristicLab.PushGP/HeuristicLab.Problems.ProgramSynthesis/Push/Expressions/RotateExpressions.cs	(revision 15031)
+++ /branches/PushGP/HeuristicLab.PushGP/HeuristicLab.Problems.ProgramSynthesis/Push/Expressions/RotateExpressions.cs	(revision 15032)
@@ -20,5 +20,8 @@
 
 
-  [PushExpression(StackTypes.Integer, "INTEGER.ROT")]
+  [PushExpression(
+    StackTypes.Integer,
+    "INTEGER.ROT",
+    "Rotates the top 3 items of the INTEGER stack clockwise.")]
   [StorableClass]
   public class IntegerRotateExpression : RotateExpression<long> {
@@ -36,5 +39,8 @@
   }
 
-  [PushExpression(StackTypes.Float, "FLOAT.ROT")]
+  [PushExpression(
+    StackTypes.Float,
+    "FLOAT.ROT",
+    "Rotates the top 3 items of the FLOAT stack clockwise.")]
   [StorableClass]
   public class FloatRotateExpression : RotateExpression<double> {
@@ -52,5 +58,8 @@
   }
 
-  [PushExpression(StackTypes.Boolean, "BOOLEAN.ROT")]
+  [PushExpression(
+    StackTypes.Boolean,
+    "BOOLEAN.ROT",
+    "Rotates the top 3 items of the BOOLEAN stack clockwise.")]
   [StorableClass]
   public class BooleanRotateExpression : RotateExpression<bool> {
@@ -68,5 +77,8 @@
   }
 
-  [PushExpression(StackTypes.Name, "NAME.ROT")]
+  [PushExpression(
+    StackTypes.Name,
+    "NAME.ROT",
+    "Rotates the top 3 items of the NAME stack clockwise.")]
   [StorableClass]
   public class NameRotateExpression : RotateExpression<string> {
@@ -84,5 +96,9 @@
   }
 
-  [PushExpression(StackTypes.Exec, "EXEC.ROT", execIn: 3)]
+  [PushExpression(
+    StackTypes.Exec,
+    "EXEC.ROT",
+    "Rotates the top 3 items of the EXEC stack clockwise.",
+    execIn: 3)]
   [StorableClass]
   public class ExecRotateExpression : RotateExpression<Expression> {
@@ -100,5 +116,8 @@
   }
 
-  [PushExpression(StackTypes.Code, "CODE.ROT")]
+  [PushExpression(
+    StackTypes.Code,
+    "CODE.ROT",
+    "Rotates the top 3 items of the CODE stack clockwise.")]
   [StorableClass]
   public class CodeRotateExpression : RotateExpression<Expression> {
@@ -116,5 +135,8 @@
   }
 
-  [PushExpression(StackTypes.Char, "CHAR.ROT")]
+  [PushExpression(
+    StackTypes.Char,
+    "CHAR.ROT",
+    "Rotates the top 3 items of the CHAR stack clockwise.")]
   [StorableClass]
   public class CharRotateExpression : RotateExpression<char> {
@@ -132,5 +154,8 @@
   }
 
-  [PushExpression(StackTypes.String, "STRING.ROT")]
+  [PushExpression(
+    StackTypes.String,
+    "STRING.ROT",
+    "Rotates the top 3 items of the STRING stack clockwise.")]
   [StorableClass]
   public class StringRotateExpression : RotateExpression<string> {
@@ -148,5 +173,8 @@
   }
 
-  [PushExpression(StackTypes.IntegerVector, "INTEGER[].ROT")]
+  [PushExpression(
+    StackTypes.IntegerVector,
+    "INTEGER[].ROT",
+    "Rotates the top 3 items of the INTEGER[] stack clockwise.")]
   [StorableClass]
   public class IntegerVectorRotateExpression : RotateExpression<IReadOnlyList<long>> {
@@ -164,5 +192,8 @@
   }
 
-  [PushExpression(StackTypes.FloatVector, "FLOAT[].ROT")]
+  [PushExpression(
+    StackTypes.FloatVector,
+    "FLOAT[].ROT",
+    "Rotates the top 3 items of the FLOAT[] stack clockwise.")]
   [StorableClass]
   public class FloatVectorRotateExpression : RotateExpression<IReadOnlyList<double>> {
@@ -180,5 +211,8 @@
   }
 
-  [PushExpression(StackTypes.BooleanVector, "BOOLEAN[].ROT")]
+  [PushExpression(
+    StackTypes.BooleanVector,
+    "BOOLEAN[].ROT",
+    "Rotates the top 3 items of the BOOLEAN[] stack clockwise.")]
   [StorableClass]
   public class BooleanVectorRotateExpression : RotateExpression<IReadOnlyList<bool>> {
@@ -196,5 +230,8 @@
   }
 
-  [PushExpression(StackTypes.StringVector, "STRING[].ROT")]
+  [PushExpression(
+    StackTypes.StringVector,
+    "STRING[].ROT",
+    "Rotates the top 3 items of the STRING[] stack clockwise.")]
   [StorableClass]
   public class StringVectorRotateExpression : RotateExpression<IReadOnlyList<string>> {
Index: /branches/PushGP/HeuristicLab.PushGP/HeuristicLab.Problems.ProgramSynthesis/Push/Expressions/ShoveExpressions.cs
===================================================================
--- /branches/PushGP/HeuristicLab.PushGP/HeuristicLab.Problems.ProgramSynthesis/Push/Expressions/ShoveExpressions.cs	(revision 15031)
+++ /branches/PushGP/HeuristicLab.PushGP/HeuristicLab.Problems.ProgramSynthesis/Push/Expressions/ShoveExpressions.cs	(revision 15032)
@@ -23,5 +23,8 @@
   }
 
-  [PushExpression(StackTypes.Integer, "INTEGER.SHOVE")]
+  [PushExpression(
+    StackTypes.Integer,
+    "INTEGER.SHOVE",
+    "Moves the top INTEGER item to a specific stack index, whereby the index is taken from the INTEGER stack.")]
   [StorableClass]
   public class IntegerShoveExpression : ShoveExpression<long> {
@@ -39,5 +42,9 @@
   }
 
-  [PushExpression(StackTypes.Float, "FLOAT.SHOVE", StackTypes.Integer)]
+  [PushExpression(
+    StackTypes.Float,
+    "FLOAT.SHOVE",
+    "Moves the top FLOAT item to a specific stack index, whereby the index is taken from the INTEGER stack.",
+    StackTypes.Integer)]
   [StorableClass]
   public class FloatShoveExpression : ShoveExpression<double> {
@@ -55,5 +62,9 @@
   }
 
-  [PushExpression(StackTypes.Boolean, "BOOLEAN.SHOVE", StackTypes.Integer)]
+  [PushExpression(
+    StackTypes.Boolean,
+    "BOOLEAN.SHOVE",
+    "Moves the top BOOLEAN item to a specific stack index, whereby the index is taken from the INTEGER stack.",
+    StackTypes.Integer)]
   [StorableClass]
   public class BooleanShoveExpression : ShoveExpression<bool> {
@@ -71,5 +82,9 @@
   }
 
-  [PushExpression(StackTypes.Name, "NAME.SHOVE", StackTypes.Integer)]
+  [PushExpression(
+    StackTypes.Name,
+    "NAME.SHOVE",
+    "Moves the top NAME item to a specific stack index, whereby the index is taken from the INTEGER stack.",
+    StackTypes.Integer)]
   [StorableClass]
   public class NameShoveExpression : ShoveExpression<string> {
@@ -87,5 +102,10 @@
   }
 
-  [PushExpression(StackTypes.Exec, "EXEC.SHOVE", StackTypes.Integer, execIn: 1)]
+  [PushExpression(
+    StackTypes.Exec,
+    "EXEC.SHOVE",
+    "Moves the top EXEC item to a specific stack index, whereby the index is taken from the INTEGER stack.",
+    StackTypes.Integer,
+    execIn: 1)]
   [StorableClass]
   public class ExecShoveExpression : ShoveExpression<Expression> {
@@ -103,5 +123,9 @@
   }
 
-  [PushExpression(StackTypes.Code, "CODE.SHOVE", StackTypes.Integer)]
+  [PushExpression(
+    StackTypes.Code,
+    "CODE.SHOVE",
+    "Moves the top CODE item to a specific stack index, whereby the index is taken from the INTEGER stack.",
+    StackTypes.Integer)]
   [StorableClass]
   public class CodeShoveExpression : ShoveExpression<Expression> {
@@ -119,5 +143,9 @@
   }
 
-  [PushExpression(StackTypes.Char, "CHAR.SHOVE", StackTypes.Integer)]
+  [PushExpression(
+    StackTypes.Char,
+    "CHAR.SHOVE",
+    "Moves the top CHAR item to a specific stack index, whereby the index is taken from the INTEGER stack.",
+    StackTypes.Integer)]
   [StorableClass]
   public class CharShoveExpression : ShoveExpression<char> {
@@ -135,5 +163,9 @@
   }
 
-  [PushExpression(StackTypes.String, "STRING.SHOVE", StackTypes.Integer)]
+  [PushExpression(
+    StackTypes.String,
+    "STRING.SHOVE",
+    "Moves the top STRING item to a specific stack index, whereby the index is taken from the INTEGER stack.",
+    StackTypes.Integer)]
   [StorableClass]
   public class StringShoveExpression : ShoveExpression<string> {
@@ -151,5 +183,9 @@
   }
 
-  [PushExpression(StackTypes.IntegerVector, "INTEGER[].SHOVE", StackTypes.Integer)]
+  [PushExpression(
+    StackTypes.IntegerVector,
+    "INTEGER[].SHOVE",
+    "Moves the top INTEGER[] item to a specific stack index, whereby the index is taken from the INTEGER stack.",
+    StackTypes.Integer)]
   [StorableClass]
   public class IntegerVectorShoveExpression : ShoveExpression<IReadOnlyList<long>> {
@@ -167,5 +203,9 @@
   }
 
-  [PushExpression(StackTypes.FloatVector, "FLOAT[].SHOVE", StackTypes.Integer)]
+  [PushExpression(
+    StackTypes.FloatVector,
+    "FLOAT[].SHOVE",
+    "Moves the top FLOAT[] item to a specific stack index, whereby the index is taken from the INTEGER stack.",
+    StackTypes.Integer)]
   [StorableClass]
   public class FloatVectorShoveExpression : ShoveExpression<IReadOnlyList<double>> {
@@ -183,5 +223,9 @@
   }
 
-  [PushExpression(StackTypes.BooleanVector, "BOOLEAN[].SHOVE", StackTypes.Integer)]
+  [PushExpression(
+    StackTypes.BooleanVector,
+    "BOOLEAN[].SHOVE",
+    "Moves the top BOOLEAN[] item to a specific stack index, whereby the index is taken from the INTEGER stack.",
+    StackTypes.Integer)]
   [StorableClass]
   public class BooleanVectorShoveExpression : ShoveExpression<IReadOnlyList<bool>> {
@@ -199,5 +243,9 @@
   }
 
-  [PushExpression(StackTypes.StringVector, "STRING[].SHOVE", StackTypes.Integer)]
+  [PushExpression(
+    StackTypes.StringVector,
+    "STRING[].SHOVE",
+    "Moves the top STRING[] item to a specific stack index, whereby the index is taken from the INTEGER stack.",
+    StackTypes.Integer)]
   [StorableClass]
   public class StringVectorShoveExpression : ShoveExpression<IReadOnlyList<string>> {
Index: /branches/PushGP/HeuristicLab.PushGP/HeuristicLab.Problems.ProgramSynthesis/Push/Expressions/StackdepthExpressions.cs
===================================================================
--- /branches/PushGP/HeuristicLab.PushGP/HeuristicLab.Problems.ProgramSynthesis/Push/Expressions/StackdepthExpressions.cs	(revision 15031)
+++ /branches/PushGP/HeuristicLab.PushGP/HeuristicLab.Problems.ProgramSynthesis/Push/Expressions/StackdepthExpressions.cs	(revision 15032)
@@ -30,5 +30,8 @@
 
   [StorableClass]
-  [PushExpression(StackTypes.Integer, "INTEGER.STACKDEPTH")]
+  [PushExpression(
+    StackTypes.Integer,
+    "INTEGER.STACKDEPTH",
+    "Pushes the stack depth onto the INTEGER stack.")]
   public class IntegerStackdepthExpression : StackdepthExpression<long> {
     public IntegerStackdepthExpression() { }
@@ -42,5 +45,9 @@
 
   [StorableClass]
-  [PushExpression(StackTypes.Float, "FLOAT.STACKDEPTH", StackTypes.Integer)]
+  [PushExpression(
+    StackTypes.Float,
+    "FLOAT.STACKDEPTH",
+    "Pushes the stack depth onto the INTEGER stack.",
+    StackTypes.Integer)]
   public class FloatStackdepthExpression : StackdepthExpression<double> {
     public FloatStackdepthExpression() { }
@@ -54,5 +61,9 @@
 
   [StorableClass]
-  [PushExpression(StackTypes.Boolean, "BOOLEAN.STACKDEPTH", StackTypes.Integer)]
+  [PushExpression(
+    StackTypes.Boolean,
+    "BOOLEAN.STACKDEPTH",
+    "Pushes the stack depth onto the INTEGER stack.",
+    StackTypes.Integer)]
   public class BooleanStackdepthExpression : StackdepthExpression<bool> {
     public BooleanStackdepthExpression() { }
@@ -66,5 +77,9 @@
 
   [StorableClass]
-  [PushExpression(StackTypes.Name, "NAME.STACKDEPTH", StackTypes.Integer)]
+  [PushExpression(
+    StackTypes.Name,
+    "NAME.STACKDEPTH",
+    "Pushes the stack depth onto the INTEGER stack.",
+    StackTypes.Integer)]
   public class NameStackdepthExpression : StackdepthExpression<string> {
     public NameStackdepthExpression() { }
@@ -78,5 +93,9 @@
 
   [StorableClass]
-  [PushExpression(StackTypes.Exec, "EXEC.STACKDEPTH", StackTypes.Integer)]
+  [PushExpression(
+    StackTypes.Exec,
+    "EXEC.STACKDEPTH",
+    "Pushes the stack depth onto the INTEGER stack.",
+    StackTypes.Integer)]
   public class ExecStackdepthExpression : StackdepthExpression<Expression> {
     public ExecStackdepthExpression() { }
@@ -90,5 +109,9 @@
 
   [StorableClass]
-  [PushExpression(StackTypes.Code, "CODE.STACKDEPTH", StackTypes.Integer)]
+  [PushExpression(
+    StackTypes.Code,
+    "CODE.STACKDEPTH",
+    "Pushes the stack depth onto the INTEGER stack.",
+    StackTypes.Integer)]
   public class CodeStackdepthExpression : StackdepthExpression<Expression> {
     public CodeStackdepthExpression() { }
@@ -102,5 +125,9 @@
 
   [StorableClass]
-  [PushExpression(StackTypes.Char, "CHAR.STACKDEPTH", StackTypes.Integer)]
+  [PushExpression(
+    StackTypes.Char,
+    "CHAR.STACKDEPTH",
+    "Pushes the stack depth onto the INTEGER stack.",
+    StackTypes.Integer)]
   public class CharStackdepthExpression : StackdepthExpression<char> {
     public CharStackdepthExpression() { }
@@ -114,5 +141,9 @@
 
   [StorableClass]
-  [PushExpression(StackTypes.String, "STRING.STACKDEPTH", StackTypes.Integer)]
+  [PushExpression(
+    StackTypes.String,
+    "STRING.STACKDEPTH",
+    "Pushes the stack depth onto the INTEGER stack.",
+    StackTypes.Integer)]
   public class StringStackdepthExpression : StackdepthExpression<string> {
     public StringStackdepthExpression() { }
@@ -126,5 +157,9 @@
 
   [StorableClass]
-  [PushExpression(StackTypes.IntegerVector, "INTEGER[].STACKDEPTH", StackTypes.Integer)]
+  [PushExpression(
+    StackTypes.IntegerVector,
+    "INTEGER[].STACKDEPTH",
+    "Pushes the stack depth onto the INTEGER stack.",
+    StackTypes.Integer)]
   public class IntegerVectorStackdepthExpression : StackdepthExpression<IReadOnlyList<long>> {
     public IntegerVectorStackdepthExpression() { }
@@ -138,5 +173,9 @@
 
   [StorableClass]
-  [PushExpression(StackTypes.FloatVector, "FLOAT[].STACKDEPTH", StackTypes.Integer)]
+  [PushExpression(
+    StackTypes.FloatVector,
+    "FLOAT[].STACKDEPTH",
+    "Pushes the stack depth onto the INTEGER stack.",
+    StackTypes.Integer)]
   public class FloatVectorStackdepthExpression : StackdepthExpression<IReadOnlyList<double>> {
     public FloatVectorStackdepthExpression() { }
@@ -149,5 +188,9 @@
 
   [StorableClass]
-  [PushExpression(StackTypes.BooleanVector, "BOOLEAN[].STACKDEPTH", StackTypes.Integer)]
+  [PushExpression(
+    StackTypes.BooleanVector,
+    "BOOLEAN[].STACKDEPTH",
+    "Pushes the stack depth onto the INTEGER stack.",
+    StackTypes.Integer)]
   public class BooleanVectorStackdepthExpression : StackdepthExpression<IReadOnlyList<bool>> {
     public BooleanVectorStackdepthExpression() { }
@@ -161,5 +204,9 @@
 
   [StorableClass]
-  [PushExpression(StackTypes.StringVector, "STRING[].STACKDEPTH", StackTypes.Integer)]
+  [PushExpression(
+    StackTypes.StringVector,
+    "STRING[].STACKDEPTH",
+    "Pushes the stack depth onto the INTEGER stack.",
+    StackTypes.Integer)]
   public class StringVectorStackdepthExpression : StackdepthExpression<IReadOnlyList<string>> {
     public StringVectorStackdepthExpression() { }
Index: /branches/PushGP/HeuristicLab.PushGP/HeuristicLab.Problems.ProgramSynthesis/Push/Expressions/StatelessExpression.cs
===================================================================
--- /branches/PushGP/HeuristicLab.PushGP/HeuristicLab.Problems.ProgramSynthesis/Push/Expressions/StatelessExpression.cs	(revision 15031)
+++ /branches/PushGP/HeuristicLab.PushGP/HeuristicLab.Problems.ProgramSynthesis/Push/Expressions/StatelessExpression.cs	(revision 15032)
@@ -25,5 +25,5 @@
       get
       {
-        return ExpressionTable.TypeToAttributeTable[GetType()].ExpressionName;
+        return ExpressionTable.TypeToAttributeTable[GetType()].Name;
       }
     }
Index: /branches/PushGP/HeuristicLab.PushGP/HeuristicLab.Problems.ProgramSynthesis/Push/Expressions/StringExpressions.cs
===================================================================
--- /branches/PushGP/HeuristicLab.PushGP/HeuristicLab.Problems.ProgramSynthesis/Push/Expressions/StringExpressions.cs	(revision 15031)
+++ /branches/PushGP/HeuristicLab.PushGP/HeuristicLab.Problems.ProgramSynthesis/Push/Expressions/StringExpressions.cs	(revision 15032)
@@ -12,6 +12,13 @@
   using Stack;
 
-  [StorableClass]
-  [PushExpression(StackTypes.String, "STRING.FROMINTEGER", StackTypes.Integer)]
+  /// <summary>
+  /// Stringifies and pushes the top INTEGER.,
+  /// </summary>
+  [StorableClass]
+  [PushExpression(
+    StackTypes.String,
+    "STRING.FROMINTEGER",
+    "Stringifies and pushes the top INTEGER.",
+    StackTypes.Integer)]
   public class StringFromIntegerExpression : StatelessExpression {
     public StringFromIntegerExpression() { }
@@ -30,5 +37,9 @@
 
   [StorableClass]
-  [PushExpression(StackTypes.String, "STRING.FROMFLOAT", StackTypes.Float)]
+  [PushExpression(
+    StackTypes.String,
+    "STRING.FROMFLOAT",
+    "Stringifies and pushes the top FLOAT.",
+    StackTypes.Float)]
   public class StringFromFloatExpression : StatelessExpression {
     public StringFromFloatExpression() { }
@@ -48,6 +59,13 @@
   }
 
-  [StorableClass]
-  [PushExpression(StackTypes.String, "STRING.FROMBOOLEAN", StackTypes.Boolean)]
+  /// <summary>
+  /// Stringifies and pushes the top BOOLEAN.
+  /// </summary>
+  [StorableClass]
+  [PushExpression(
+    StackTypes.String,
+    "STRING.FROMBOOLEAN",
+    "Stringifies and pushes the top BOOLEAN.",
+    StackTypes.Boolean)]
   public class StringFromBooleanExpression : StatelessExpression {
     public StringFromBooleanExpression() { }
@@ -65,6 +83,13 @@
   }
 
-  [StorableClass]
-  [PushExpression(StackTypes.String, "STRING.FROMCHAR", StackTypes.Char)]
+  /// <summary>
+  /// Stringifies and pushes the top CHAR.
+  /// </summary>
+  [StorableClass]
+  [PushExpression(
+    StackTypes.String,
+    "STRING.FROMCHAR",
+    "Stringifies and pushes the top CHAR.",
+    StackTypes.Char)]
   public class StringFromCharExpression : StatelessExpression {
     public StringFromCharExpression() { }
@@ -82,6 +107,12 @@
   }
 
-  [StorableClass]
-  [PushExpression(StackTypes.String, "STRING.CONCAT")]
+  /// <summary>
+  /// Concats the top 2 strings.
+  /// </summary>
+  [StorableClass]
+  [PushExpression(
+    StackTypes.String,
+    "STRING.CONCAT",
+    "Concats the top 2 strings.")]
   public class StringConcatExpression : StatelessExpression {
     public StringConcatExpression() { }
@@ -104,5 +135,9 @@
   /// </summary>
   [StorableClass]
-  [PushExpression(StackTypes.String, "STRING.CONJCHAR", StackTypes.Char)]
+  [PushExpression(
+    StackTypes.String,
+    "STRING.CONJCHAR",
+    "Conj top CHAR onto top STRING",
+    StackTypes.Char)]
   public class StringConjCharExpression : StatelessExpression {
     public StringConjCharExpression() { }
@@ -122,6 +157,13 @@
   }
 
-  [StorableClass]
-  [PushExpression(StackTypes.String, "STRING.TAKE", StackTypes.Integer)]
+  /// <summary>
+  /// Same as substring 0-n, whereby n is taken from the INTEGER stack.
+  /// </summary>
+  [StorableClass]
+  [PushExpression(
+    StackTypes.String,
+    "STRING.TAKE",
+    "Same as substring 0-n, whereby n is taken from the INTEGER stack.",
+    StackTypes.Integer)]
   public class StringTakeExpression : StatelessExpression {
     public StringTakeExpression() { }
@@ -145,6 +187,13 @@
   }
 
-  [StorableClass]
-  [PushExpression(StackTypes.String, "STRING.SUBSTRING", StackTypes.Integer)]
+  /// <summary>
+  /// Replaces top STRING with a substring from index A to B, whereby A and B are taken from the INTEGER STACK.
+  /// </summary>
+  [StorableClass]
+  [PushExpression(
+    StackTypes.String,
+    "STRING.SUBSTRING",
+    "Replaces top STRING with a substring from index A to B, whereby A and B are taken from the INTEGER STACK.",
+    StackTypes.Integer)]
   public class StringSubstringExpression : StatelessExpression {
     public StringSubstringExpression() { }
@@ -172,6 +221,12 @@
   }
 
-  [StorableClass]
-  [PushExpression(StackTypes.String, "STRING.FIRST")]
+  /// <summary>
+  /// Pushes first char of top STRING.
+  /// </summary>
+  [StorableClass]
+  [PushExpression(
+    StackTypes.String,
+    "STRING.FIRST",
+    "Pushes first char of top STRING.")]
   public class StringFirstExpression : StatelessExpression {
     public StringFirstExpression() { }
@@ -189,6 +244,12 @@
   }
 
-  [StorableClass]
-  [PushExpression(StackTypes.String, "STRING.LAST")]
+  /// <summary>
+  /// Pushes last char of top STRING.
+  /// </summary>
+  [StorableClass]
+  [PushExpression(
+    StackTypes.String,
+    "STRING.LAST",
+    "Pushes last char of top STRING.")]
   public class StringLastExpression : StatelessExpression {
     public StringLastExpression() { }
@@ -208,6 +269,13 @@
   }
 
-  [StorableClass]
-  [PushExpression(StackTypes.String, "STRING.NTH", StackTypes.Integer)]
+  /// <summary>
+  /// Pushes nth char of top STRING, whereby n is take from the INTEGER stack.
+  /// </summary>
+  [StorableClass]
+  [PushExpression(
+    StackTypes.String,
+    "STRING.NTH",
+    "Pushes nth char of top STRING, whereby n is take from the INTEGER stack.",
+    StackTypes.Integer)]
   public class StringNthExpression : StatelessExpression {
     public StringNthExpression() { }
@@ -229,6 +297,12 @@
   }
 
-  [StorableClass]
-  [PushExpression(StackTypes.String, "STRING.REST")]
+  /// <summary>
+  /// Removes first char of top STRING.
+  /// </summary>
+  [StorableClass]
+  [PushExpression(
+    StackTypes.String,
+    "STRING.REST",
+    "Removes first char of top STRING.")]
   public class StringRestExpression : StatelessExpression {
     public StringRestExpression() { }
@@ -247,6 +321,12 @@
   }
 
-  [StorableClass]
-  [PushExpression(StackTypes.String, "STRING.BUTLAST")]
+  /// <summary>
+  /// Removes last char of top STRING.
+  /// </summary>
+  [StorableClass]
+  [PushExpression(
+    StackTypes.String,
+    "STRING.BUTLAST",
+    "Removes last char of top STRING.")]
   public class StringButLastExpression : StatelessExpression {
     public StringButLastExpression() { }
@@ -265,6 +345,13 @@
   }
 
-  [StorableClass]
-  [PushExpression(StackTypes.String, "STRING.LENGTH", StackTypes.Integer)]
+  /// <summary>
+  /// Pushes length of top STRING onto the INTEGER stack.
+  /// </summary>
+  [StorableClass]
+  [PushExpression(
+    StackTypes.String,
+    "STRING.LENGTH",
+    "Pushes length of top STRING onto the INTEGER stack.",
+    StackTypes.Integer)]
   public class StringLengthExpression : StatelessExpression {
     public StringLengthExpression() { }
@@ -282,6 +369,12 @@
   }
 
-  [StorableClass]
-  [PushExpression(StackTypes.String, "STRING.REVERSE")]
+  /// <summary>
+  /// Reverses the top STRING.
+  /// </summary>
+  [StorableClass]
+  [PushExpression(
+    StackTypes.String,
+    "STRING.REVERSE",
+    "Reverses the top STRING.")]
   public class StringReverseExpression : StatelessExpression {
     public StringReverseExpression() { }
@@ -300,6 +393,12 @@
   }
 
-  [StorableClass]
-  [PushExpression(StackTypes.String, "STRING.PARSETOCHARS")]
+  /// <summary>
+  /// Maps every char of top STRING as separate string.
+  /// </summary>
+  [StorableClass]
+  [PushExpression(
+    StackTypes.String,
+    "STRING.PARSETOCHARS",
+    "Maps every char of top STRING as separate string.")]
   public class StringParseToCharsExpression : StatelessExpression {
     public StringParseToCharsExpression() { }
@@ -331,6 +430,12 @@
   }
 
-  [StorableClass]
-  [PushExpression(StackTypes.String, "STRING.SPLIT")]
+  /// <summary>
+  /// Splits top STRING by whitespace chars.
+  /// </summary>
+  [StorableClass]
+  [PushExpression(
+    StackTypes.String,
+    "STRING.SPLIT",
+    "Splits top STRING by whitespace chars.")]
   public class StringSplitExpression : StatelessExpression {
     public StringSplitExpression() { }
@@ -360,8 +465,12 @@
 
   /// <summary>
-  /// True if top string is empty
-  /// </summary>
-  [StorableClass]
-  [PushExpression(StackTypes.String, "STRING.EMPTYSTRING", StackTypes.Boolean)]
+  /// True if top string is empty.
+  /// </summary>
+  [StorableClass]
+  [PushExpression(
+    StackTypes.String,
+    "STRING.EMPTYSTRING",
+    "True if top STRING is empty.",
+    StackTypes.Boolean)]
   public class StringEmptyStringExpression : StatelessExpression {
     public StringEmptyStringExpression() { }
@@ -383,5 +492,9 @@
   /// </summary>
   [StorableClass]
-  [PushExpression(StackTypes.String, "STRING.CONTAINS", StackTypes.Boolean)]
+  [PushExpression(
+    StackTypes.String,
+    "STRING.CONTAINS",
+    "True if top STRING is a substring of second STRING, false otherwise.",
+    StackTypes.Boolean)]
   public class StringContainsExpression : StatelessExpression {
     public StringContainsExpression() { }
@@ -406,5 +519,9 @@
   /// </summary>
   [StorableClass]
-  [PushExpression(StackTypes.String, "STRING.CONTAINSCHAR", StackTypes.Boolean | StackTypes.Char)]
+  [PushExpression(
+    StackTypes.String,
+    "STRING.CONTAINSCHAR",
+    "True if the top CHAR is in the top STRING.",
+    StackTypes.Boolean | StackTypes.Char)]
   public class StringContainsCharExpression : StatelessExpression {
     public StringContainsCharExpression() { }
@@ -429,5 +546,9 @@
   /// </summary>
   [StorableClass]
-  [PushExpression(StackTypes.String, "STRING.INDEXOFCHAR", StackTypes.Integer | StackTypes.Char)]
+  [PushExpression(
+    StackTypes.String,
+    "STRING.INDEXOFCHAR",
+    "Puts on the INTEGER stack the index of the top CHAR in the top STRING.",
+    StackTypes.Integer | StackTypes.Char)]
   public class StringIndexOfCharExpression : StatelessExpression {
     public StringIndexOfCharExpression() { }
@@ -452,5 +573,9 @@
   /// </summary>
   [StorableClass]
-  [PushExpression(StackTypes.String, "STRING.OCCURRENCESOFCHAR", StackTypes.Integer | StackTypes.Char)]
+  [PushExpression(
+    StackTypes.String,
+    "STRING.OCCURRENCESOFCHAR",
+    "The number of times the top CHAR is in the top STRING.",
+    StackTypes.Integer | StackTypes.Char)]
   public class StringOccurrencesOfCharExpression : StatelessExpression {
     public StringOccurrencesOfCharExpression() { }
@@ -476,8 +601,11 @@
 
   /// <summary>
-  /// In third string on stack, replaces second string with first string
-  /// </summary>
-  [StorableClass]
-  [PushExpression(StackTypes.String, "STRING.REPLACE")]
+  /// In third STRING, replaces second string with first string
+  /// </summary>
+  [StorableClass]
+  [PushExpression(
+    StackTypes.String,
+    "STRING.REPLACE",
+    "In third STRING, replaces second STRING with first STRING.")]
   public class StringReplaceExpression : StatelessExpression {
     public StringReplaceExpression() { }
@@ -502,8 +630,11 @@
 
   /// <summary>
-  /// In third string on stack, replaces first occurrence of second string with first string
-  /// </summary>
-  [StorableClass]
-  [PushExpression(StackTypes.String, "STRING.REPLACEFIRST")]
+  /// In third STRING, replaces first occurrence of second string with first string
+  /// </summary>
+  [StorableClass]
+  [PushExpression(
+    StackTypes.String,
+    "STRING.REPLACEFIRST",
+    "In third STRING, replaces first occurrence of second STRING with first STRING")]
   public class StringReplaceFirstExpression : StatelessExpression {
     public StringReplaceFirstExpression() { }
@@ -533,8 +664,12 @@
 
   /// <summary>
-  /// In top string on stack, replaces all occurrences of second char with first char
-  /// </summary>
-  [StorableClass]
-  [PushExpression(StackTypes.String, "STRING.REPLACECHAR", StackTypes.Char)]
+  /// In top STRING, replaces all occurrences of second char with first char
+  /// </summary>
+  [StorableClass]
+  [PushExpression(
+    StackTypes.String,
+    "STRING.REPLACECHAR",
+    "In top STRING, replaces all occurrences of second CHAR with first CHAR.",
+    StackTypes.Char)]
   public class StringReplaceCharExpression : StatelessExpression {
     public StringReplaceCharExpression() { }
@@ -558,8 +693,12 @@
 
   /// <summary>
-  /// In top string on stack, replaces first occurrence of second char with first char
-  /// </summary>
-  [StorableClass]
-  [PushExpression(StackTypes.String, "STRING.REPLACEFIRSTCHAR", StackTypes.Char)]
+  /// In top STRING, replaces first occurrence of second char with first char
+  /// </summary>
+  [StorableClass]
+  [PushExpression(
+    StackTypes.String,
+    "STRING.REPLACEFIRSTCHAR",
+    "In top STRING, replaces first occurrence of second CHAR with first CHAR.",
+    StackTypes.Char)]
   public class StringReplaceFirstCharExpression : StatelessExpression {
     public StringReplaceFirstCharExpression() { }
@@ -592,8 +731,12 @@
 
   /// <summary>
-  /// In top string on stack, remove all occurrences of char
-  /// </summary>
-  [StorableClass]
-  [PushExpression(StackTypes.String, "STRING.REMOVECHAR", StackTypes.Char)]
+  /// In top STRING, remove all occurrences of char
+  /// </summary>
+  [StorableClass]
+  [PushExpression(
+    StackTypes.String,
+    "STRING.REMOVECHAR",
+    "In top STRING, remove all occurrences of top CHAR.",
+    StackTypes.Char)]
   public class StringRemoveCharExpression : StatelessExpression {
     public StringRemoveCharExpression() { }
@@ -617,5 +760,9 @@
   /// </summary>
   [StorableClass]
-  [PushExpression(StackTypes.String, "STRING.SETCHAR", StackTypes.Char | StackTypes.Integer)]
+  [PushExpression(
+    StackTypes.String,
+    "STRING.SETCHAR",
+    "Sets top CHAR at index in top STRING, whereby the index is taken from the INTEGER stack.",
+    StackTypes.Char | StackTypes.Integer)]
   public class StringSetCharExpression : StatelessExpression {
     public StringSetCharExpression() { }
@@ -651,5 +798,9 @@
   /// </summary>
   [StorableClass]
-  [PushExpression(StackTypes.String, "STRING.ITERATE", StackTypes.Exec | StackTypes.Char, execIn: 1)]
+  [PushExpression(
+    StackTypes.String,
+    "STRING.ITERATE",
+    "Iterates over the top STRING using the CODE on the EXEC stack.",
+    StackTypes.Exec | StackTypes.Char, execIn: 1)]
   public class StringIterateExpression : StatelessExpression {
     public StringIterateExpression() { }
Index: /branches/PushGP/HeuristicLab.PushGP/HeuristicLab.Problems.ProgramSynthesis/Push/Expressions/SwapExpressions.cs
===================================================================
--- /branches/PushGP/HeuristicLab.PushGP/HeuristicLab.Problems.ProgramSynthesis/Push/Expressions/SwapExpressions.cs	(revision 15031)
+++ /branches/PushGP/HeuristicLab.PushGP/HeuristicLab.Problems.ProgramSynthesis/Push/Expressions/SwapExpressions.cs	(revision 15032)
@@ -24,5 +24,8 @@
 
   [StorableClass]
-  [PushExpression(StackTypes.Integer, "INTEGER.SWAP")]
+  [PushExpression(
+    StackTypes.Integer,
+    "INTEGER.SWAP",
+    "Swaps the top two items on the stack.")]
   public class IntegerSwapExpression : SwapExpression<long> {
     public IntegerSwapExpression() { }
@@ -40,5 +43,8 @@
 
   [StorableClass]
-  [PushExpression(StackTypes.Float, "FLOAT.SWAP")]
+  [PushExpression(
+    StackTypes.Float,
+    "FLOAT.SWAP",
+    "Swaps the top two items on the stack.")]
   public class FloatSwapExpression : SwapExpression<double> {
     public FloatSwapExpression() { }
@@ -56,5 +62,8 @@
 
   [StorableClass]
-  [PushExpression(StackTypes.Boolean, "BOOLEAN.SWAP")]
+  [PushExpression(
+    StackTypes.Boolean,
+    "BOOLEAN.SWAP",
+    "Swaps the top two items on the stack.")]
   public class BooleanSwapExpression : SwapExpression<bool> {
     public BooleanSwapExpression() { }
@@ -72,5 +81,8 @@
 
   [StorableClass]
-  [PushExpression(StackTypes.Name, "NAME.SWAP")]
+  [PushExpression(
+    StackTypes.Name,
+    "NAME.SWAP",
+    "Swaps the top two items on the stack.")]
   public class NameSwapExpression : SwapExpression<string> {
     public NameSwapExpression() { }
@@ -88,5 +100,9 @@
 
   [StorableClass]
-  [PushExpression(StackTypes.Exec, "EXEC.SWAP", execIn: 2)]
+  [PushExpression(
+    StackTypes.Exec,
+    "EXEC.SWAP",
+    "Swaps the top two items on the stack.",
+    execIn: 2)]
   public class ExecSwapExpression : SwapExpression<Expression> {
     public ExecSwapExpression() { }
@@ -104,5 +120,8 @@
 
   [StorableClass]
-  [PushExpression(StackTypes.Code, "CODE.SWAP")]
+  [PushExpression(
+    StackTypes.Code,
+    "CODE.SWAP",
+    "Swaps the top two items on the stack.")]
   public class CodeSwapExpression : SwapExpression<Expression> {
     public CodeSwapExpression() { }
@@ -120,5 +139,8 @@
 
   [StorableClass]
-  [PushExpression(StackTypes.Char, "CHAR.SWAP")]
+  [PushExpression(
+    StackTypes.Char,
+    "CHAR.SWAP",
+    "Swaps the top two items on the stack.")]
   public class CharSwapExpression : SwapExpression<char> {
     public CharSwapExpression() { }
@@ -136,5 +158,8 @@
 
   [StorableClass]
-  [PushExpression(StackTypes.String, "STRING.SWAP")]
+  [PushExpression(
+    StackTypes.String,
+    "STRING.SWAP",
+    "Swaps the top two items on the stack.")]
   public class StringSwapExpression : SwapExpression<string> {
     public StringSwapExpression() { }
@@ -152,5 +177,8 @@
 
   [StorableClass]
-  [PushExpression(StackTypes.IntegerVector, "INTEGER[].SWAP")]
+  [PushExpression(
+    StackTypes.IntegerVector,
+    "INTEGER[].SWAP",
+    "Swaps the top two items on the stack.")]
   public class IntegerVectorSwapExpression : SwapExpression<IReadOnlyList<long>> {
     public IntegerVectorSwapExpression() { }
@@ -168,5 +196,8 @@
 
   [StorableClass]
-  [PushExpression(StackTypes.FloatVector, "FLOAT[].SWAP")]
+  [PushExpression(
+    StackTypes.FloatVector,
+    "FLOAT[].SWAP",
+    "Swaps the top two items on the stack.")]
   public class FloatVectorSwapExpression : SwapExpression<IReadOnlyList<double>> {
     public FloatVectorSwapExpression() { }
@@ -184,5 +215,8 @@
 
   [StorableClass]
-  [PushExpression(StackTypes.BooleanVector, "BOOLEAN[].SWAP")]
+  [PushExpression(
+    StackTypes.BooleanVector,
+    "BOOLEAN[].SWAP",
+    "Swaps the top two items on the stack.")]
   public class BooleanVectorSwapExpression : SwapExpression<IReadOnlyList<bool>> {
     public BooleanVectorSwapExpression() { }
@@ -200,5 +234,8 @@
 
   [StorableClass]
-  [PushExpression(StackTypes.StringVector, "STRING[].SWAP")]
+  [PushExpression(
+    StackTypes.StringVector,
+    "STRING[].SWAP",
+    "Swaps the top two items on the stack.")]
   public class StringVectorSwapExpression : SwapExpression<IReadOnlyList<string>> {
     public StringVectorSwapExpression() { }
Index: /branches/PushGP/HeuristicLab.PushGP/HeuristicLab.Problems.ProgramSynthesis/Push/Expressions/VectorButLastExpressions.cs
===================================================================
--- /branches/PushGP/HeuristicLab.PushGP/HeuristicLab.Problems.ProgramSynthesis/Push/Expressions/VectorButLastExpressions.cs	(revision 15031)
+++ /branches/PushGP/HeuristicLab.PushGP/HeuristicLab.Problems.ProgramSynthesis/Push/Expressions/VectorButLastExpressions.cs	(revision 15032)
@@ -30,5 +30,8 @@
 
   [StorableClass]
-  [PushExpression(StackTypes.IntegerVector, "INTEGER[].BUTLAST")]
+  [PushExpression(
+    StackTypes.IntegerVector,
+    "INTEGER[].BUTLAST",
+    "Takes the rest of the top item on the INTEGER[] stack.")]
   public class IntegerVectorButLastExpression : VectorButLastExpression<long> {
     public IntegerVectorButLastExpression() { }
@@ -46,5 +49,8 @@
 
   [StorableClass]
-  [PushExpression(StackTypes.FloatVector, "FLOAT[].BUTLAST")]
+  [PushExpression(
+    StackTypes.FloatVector,
+    "FLOAT[].BUTLAST",
+    "Takes the rest of the top item on the FLOAT[] stack.")]
   public class FloatVectorButLastExpression : VectorButLastExpression<double> {
     public FloatVectorButLastExpression() { }
@@ -62,5 +68,8 @@
 
   [StorableClass]
-  [PushExpression(StackTypes.BooleanVector, "BOOLEAN[].BUTLAST")]
+  [PushExpression(
+    StackTypes.BooleanVector,
+    "BOOLEAN[].BUTLAST",
+    "Takes the rest of the top item on the BOOLEAN[] stack.")]
   public class BooleanVectorButLastExpression : VectorButLastExpression<bool> {
     public BooleanVectorButLastExpression() { }
@@ -78,5 +87,8 @@
 
   [StorableClass]
-  [PushExpression(StackTypes.StringVector, "STRING[].BUTLAST")]
+  [PushExpression(
+    StackTypes.StringVector,
+    "STRING[].BUTLAST",
+    "Takes the rest of the top item on the STRING[] stack.")]
   public class StringVectorButLastExpression : VectorButLastExpression<string> {
     public StringVectorButLastExpression() { }
Index: /branches/PushGP/HeuristicLab.PushGP/HeuristicLab.Problems.ProgramSynthesis/Push/Expressions/VectorConcatExpressions.cs
===================================================================
--- /branches/PushGP/HeuristicLab.PushGP/HeuristicLab.Problems.ProgramSynthesis/Push/Expressions/VectorConcatExpressions.cs	(revision 15031)
+++ /branches/PushGP/HeuristicLab.PushGP/HeuristicLab.Problems.ProgramSynthesis/Push/Expressions/VectorConcatExpressions.cs	(revision 15032)
@@ -8,5 +8,5 @@
 
   /// <summary>
-  /// Concats two vectors on the type stack.
+  /// Concatinates two vectors on the type stack.
   /// </summary>
   [StorableClass]
@@ -33,5 +33,8 @@
 
   [StorableClass]
-  [PushExpression(StackTypes.IntegerVector, "INTEGER[].CONCAT")]
+  [PushExpression(
+    StackTypes.IntegerVector,
+    "INTEGER[].CONCAT",
+    "Concatenates the top two vectors on the INTEGER[] stack.")]
   public class IntegerVectorConcatExpression : VectorConcatExpression<long> {
     public IntegerVectorConcatExpression() { }
@@ -49,5 +52,8 @@
 
   [StorableClass]
-  [PushExpression(StackTypes.FloatVector, "FLOAT[].CONCAT")]
+  [PushExpression(
+    StackTypes.FloatVector,
+    "FLOAT[].CONCAT",
+    "Concatenates the top two vectors on the FLOAT[] stack.")]
   public class FloatVectorConcatExpression : VectorConcatExpression<double> {
     public FloatVectorConcatExpression() { }
@@ -65,5 +71,8 @@
 
   [StorableClass]
-  [PushExpression(StackTypes.BooleanVector, "BOOLEAN[].CONCAT")]
+  [PushExpression(
+    StackTypes.BooleanVector,
+    "BOOLEAN[].CONCAT",
+    "Concatenates the top two vectors on the BOOLEAN[] stack.")]
   public class BooleanVectorConcatExpression : VectorConcatExpression<bool> {
     public BooleanVectorConcatExpression() { }
@@ -81,5 +90,8 @@
 
   [StorableClass]
-  [PushExpression(StackTypes.StringVector, "STRING[].CONCAT")]
+  [PushExpression(
+    StackTypes.StringVector,
+    "STRING[].CONCAT",
+    "Concatenates the top two vectors on the STRING[] stack.")]
   public class StringVectorConcatExpression : VectorConcatExpression<string> {
     public StringVectorConcatExpression() { }
Index: /branches/PushGP/HeuristicLab.PushGP/HeuristicLab.Problems.ProgramSynthesis/Push/Expressions/VectorConjExpressions.cs
===================================================================
--- /branches/PushGP/HeuristicLab.PushGP/HeuristicLab.Problems.ProgramSynthesis/Push/Expressions/VectorConjExpressions.cs	(revision 15031)
+++ /branches/PushGP/HeuristicLab.PushGP/HeuristicLab.Problems.ProgramSynthesis/Push/Expressions/VectorConjExpressions.cs	(revision 15032)
@@ -29,5 +29,9 @@
 
   [StorableClass]
-  [PushExpression(StackTypes.IntegerVector, "INTEGER[].CONJ", StackTypes.Integer)]
+  [PushExpression(
+    StackTypes.IntegerVector,
+    "INTEGER[].CONJ",
+    "Conj's the top INTEGER onto the top item of the INTEGER[] stack.",
+    StackTypes.Integer)]
   public class IntegerVectorConjExpression : VectorConjExpression<long> {
     public IntegerVectorConjExpression() { }
@@ -45,5 +49,9 @@
 
   [StorableClass]
-  [PushExpression(StackTypes.FloatVector, "FLOAT[].CONJ", StackTypes.Float)]
+  [PushExpression(
+    StackTypes.FloatVector,
+    "FLOAT[].CONJ",
+    "Conj's the top FLOAT onto the top item of the FLOAT[] stack.",
+    StackTypes.Float)]
   public class FloatVectorConjExpression : VectorConjExpression<double> {
     public FloatVectorConjExpression() { }
@@ -61,5 +69,9 @@
 
   [StorableClass]
-  [PushExpression(StackTypes.StringVector, "STRING[].CONJ", StackTypes.String)]
+  [PushExpression(
+    StackTypes.StringVector,
+    "STRING[].CONJ",
+    "Conj's the top STRING onto the top item of the STRING[] stack.",
+    StackTypes.String)]
   public class StringVectorConjExpression : VectorConjExpression<string> {
     public StringVectorConjExpression() { }
@@ -77,5 +89,9 @@
 
   [StorableClass]
-  [PushExpression(StackTypes.BooleanVector, "BOOLEAN[].CONJ", StackTypes.Boolean)]
+  [PushExpression(
+    StackTypes.BooleanVector,
+    "BOOLEAN[].CONJ",
+    "Conj's the top BOOLEAN onto the top item of the BOOLEAN[] stack.",
+    StackTypes.Boolean)]
   public class BooleanVectorConjExpression : VectorConjExpression<bool> {
     public BooleanVectorConjExpression() { }
Index: /branches/PushGP/HeuristicLab.PushGP/HeuristicLab.Problems.ProgramSynthesis/Push/Expressions/VectorContainsExpressions.cs
===================================================================
--- /branches/PushGP/HeuristicLab.PushGP/HeuristicLab.Problems.ProgramSynthesis/Push/Expressions/VectorContainsExpressions.cs	(revision 15031)
+++ /branches/PushGP/HeuristicLab.PushGP/HeuristicLab.Problems.ProgramSynthesis/Push/Expressions/VectorContainsExpressions.cs	(revision 15032)
@@ -34,5 +34,9 @@
 
   [StorableClass]
-  [PushExpression(StackTypes.IntegerVector, "INTEGER[].CONTAINS", StackTypes.Integer | StackTypes.Boolean)]
+  [PushExpression(
+    StackTypes.IntegerVector,
+    "INTEGER[].CONTAINS",
+    "Tells whether the top INTEGER is in the top INTEGER[].",
+    StackTypes.Integer | StackTypes.Boolean)]
   public class IntegerVectorContainsExpression : VectorContainsExpression<long> {
     public IntegerVectorContainsExpression() { }
@@ -50,5 +54,9 @@
 
   [StorableClass]
-  [PushExpression(StackTypes.FloatVector, "FLOAT[].CONTAINS", StackTypes.Float | StackTypes.Boolean)]
+  [PushExpression(
+    StackTypes.FloatVector,
+    "FLOAT[].CONTAINS",
+    "Tells whether the top FLOAT is in the top FLOAT[].",
+    StackTypes.Float | StackTypes.Boolean)]
   public class FloatVectorContainsExpression : VectorContainsExpression<double> {
     public FloatVectorContainsExpression() { }
@@ -66,5 +74,9 @@
 
   [StorableClass]
-  [PushExpression(StackTypes.BooleanVector, "BOOLEAN[].CONTAINS", StackTypes.Boolean)]
+  [PushExpression(
+    StackTypes.BooleanVector,
+    "BOOLEAN[].CONTAINS",
+    "Tells whether the top BOOLEAN is in the top BOOLEAN[].",
+    StackTypes.Boolean)]
   public class BooleanVectorContainsExpression : VectorContainsExpression<bool> {
     public BooleanVectorContainsExpression() { }
@@ -82,5 +94,9 @@
 
   [StorableClass]
-  [PushExpression(StackTypes.StringVector, "STRING[].CONTAINS", StackTypes.String | StackTypes.Boolean)]
+  [PushExpression(
+    StackTypes.StringVector,
+    "STRING[].CONTAINS",
+    "Tells whether the top STRING is in the top STRING[].",
+    StackTypes.String | StackTypes.Boolean)]
   public class StringVectorContainsExpression : VectorContainsExpression<string> {
     public StringVectorContainsExpression() { }
Index: /branches/PushGP/HeuristicLab.PushGP/HeuristicLab.Problems.ProgramSynthesis/Push/Expressions/VectorEmptyExpressions.cs
===================================================================
--- /branches/PushGP/HeuristicLab.PushGP/HeuristicLab.Problems.ProgramSynthesis/Push/Expressions/VectorEmptyExpressions.cs	(revision 15031)
+++ /branches/PushGP/HeuristicLab.PushGP/HeuristicLab.Problems.ProgramSynthesis/Push/Expressions/VectorEmptyExpressions.cs	(revision 15032)
@@ -28,5 +28,9 @@
 
   [StorableClass]
-  [PushExpression(StackTypes.IntegerVector, "INTEGER[].EMPTYVECTOR", StackTypes.Boolean)]
+  [PushExpression(
+    StackTypes.IntegerVector,
+    "INTEGER[].EMPTYVECTOR",
+    "Pushes a BOOLEAN of whether the top INTEGER[] is empty.",
+    StackTypes.Boolean)]
   public class IntegerVectorEmptyVectorExpression : VectorEmptyVectorExpression<long> {
     public IntegerVectorEmptyVectorExpression() { }
@@ -44,5 +48,9 @@
 
   [StorableClass]
-  [PushExpression(StackTypes.FloatVector, "FLOAT[].EMPTYVECTOR", StackTypes.Boolean)]
+  [PushExpression(
+    StackTypes.FloatVector,
+    "FLOAT[].EMPTYVECTOR",
+    "Pushes a BOOLEAN of whether the top FLOAT[] is empty.",
+    StackTypes.Boolean)]
   public class FloatVectorEmptyVectorExpression : VectorEmptyVectorExpression<double> {
     public FloatVectorEmptyVectorExpression() { }
@@ -60,5 +68,9 @@
 
   [StorableClass]
-  [PushExpression(StackTypes.BooleanVector, "BOOLEAN[].EMPTYVECTOR", StackTypes.Boolean)]
+  [PushExpression(
+    StackTypes.BooleanVector,
+    "BOOLEAN[].EMPTYVECTOR",
+    "Pushes a BOOLEAN of whether the top BOOLEAN[] is empty.",
+    StackTypes.Boolean)]
   public class BooleanVectorEmptyVectorExpression : VectorEmptyVectorExpression<bool> {
     public BooleanVectorEmptyVectorExpression() { }
@@ -76,5 +88,9 @@
 
   [StorableClass]
-  [PushExpression(StackTypes.StringVector, "STRING[].EMPTYVECTOR", StackTypes.Boolean)]
+  [PushExpression(
+    StackTypes.StringVector,
+    "STRING[].EMPTYVECTOR",
+    "Pushes a BOOLEAN of whether the top STRING[] is empty.",
+    StackTypes.Boolean)]
   public class StringVectorEmptyVectorExpression : VectorEmptyVectorExpression<string> {
     public StringVectorEmptyVectorExpression() { }
Index: /branches/PushGP/HeuristicLab.PushGP/HeuristicLab.Problems.ProgramSynthesis/Push/Expressions/VectorFirstExpressions.cs
===================================================================
--- /branches/PushGP/HeuristicLab.PushGP/HeuristicLab.Problems.ProgramSynthesis/Push/Expressions/VectorFirstExpressions.cs	(revision 15031)
+++ /branches/PushGP/HeuristicLab.PushGP/HeuristicLab.Problems.ProgramSynthesis/Push/Expressions/VectorFirstExpressions.cs	(revision 15032)
@@ -28,5 +28,9 @@
 
   [StorableClass]
-  [PushExpression(StackTypes.IntegerVector, "INTEGER[].FIRST", StackTypes.Integer)]
+  [PushExpression(
+    StackTypes.IntegerVector,
+    "INTEGER[].FIRST",
+    "Pushes the first INTEGER of the top INTEGER[].",
+    StackTypes.Integer)]
   public class IntegerVectorFirstExpression : VectorFirstExpression<long> {
     public IntegerVectorFirstExpression() { }
@@ -44,5 +48,9 @@
 
   [StorableClass]
-  [PushExpression(StackTypes.FloatVector, "FLOAT[].FIRST", StackTypes.Float)]
+  [PushExpression(
+    StackTypes.FloatVector,
+    "FLOAT[].FIRST",
+    "Pushes the first FLOAT of the top FLOAT[].",
+    StackTypes.Float)]
   public class FloatVectorFirstExpression : VectorFirstExpression<double> {
     public FloatVectorFirstExpression() { }
@@ -60,5 +68,9 @@
 
   [StorableClass]
-  [PushExpression(StackTypes.BooleanVector, "BOOLEAN[].FIRST", StackTypes.Boolean)]
+  [PushExpression(
+    StackTypes.BooleanVector,
+    "BOOLEAN[].FIRST",
+    "Pushes the first BOOLEAN of the top BOOLEAN[].",
+    StackTypes.Boolean)]
   public class BooleanVectorFirstExpression : VectorFirstExpression<bool> {
     public BooleanVectorFirstExpression() { }
@@ -76,5 +88,9 @@
 
   [StorableClass]
-  [PushExpression(StackTypes.StringVector, "STRING[].FIRST", StackTypes.String)]
+  [PushExpression(
+    StackTypes.StringVector,
+    "STRING[].FIRST",
+    "Pushes the first BOOLEAN of the top BOOLEAN[].",
+    StackTypes.String)]
   public class StringVectorFirstExpression : VectorFirstExpression<string> {
     public StringVectorFirstExpression() { }
Index: /branches/PushGP/HeuristicLab.PushGP/HeuristicLab.Problems.ProgramSynthesis/Push/Expressions/VectorIndexOfExpressions.cs
===================================================================
--- /branches/PushGP/HeuristicLab.PushGP/HeuristicLab.Problems.ProgramSynthesis/Push/Expressions/VectorIndexOfExpressions.cs	(revision 15031)
+++ /branches/PushGP/HeuristicLab.PushGP/HeuristicLab.Problems.ProgramSynthesis/Push/Expressions/VectorIndexOfExpressions.cs	(revision 15032)
@@ -43,5 +43,9 @@
 
   [StorableClass]
-  [PushExpression(StackTypes.IntegerVector, "INTEGER[].INDEXOF", StackTypes.Integer)]
+  [PushExpression(
+    StackTypes.IntegerVector,
+    "INTEGER[].INDEXOF",
+    "Pushes the index of the top INTEGER in the top INTEGER[] onto the INTEGER stack.",
+    StackTypes.Integer)]
   public class IntegerVectorIndexOfExpression : VectorIndexOfExpression<long> {
     public IntegerVectorIndexOfExpression() { }
@@ -59,5 +63,9 @@
 
   [StorableClass]
-  [PushExpression(StackTypes.FloatVector, "FLOAT[].INDEXOF", StackTypes.Float | StackTypes.Integer)]
+  [PushExpression(
+    StackTypes.FloatVector,
+    "FLOAT[].INDEXOF",
+    "Pushes the index of the top FLOAT in the top FLOAT[] onto the INTEGER stack.",
+    StackTypes.Float | StackTypes.Integer)]
   public class FloatVectorIndexOfExpression : VectorIndexOfExpression<double> {
     public FloatVectorIndexOfExpression() { }
@@ -75,5 +83,9 @@
 
   [StorableClass]
-  [PushExpression(StackTypes.BooleanVector, "BOOLEAN[].INDEXOF", StackTypes.Boolean | StackTypes.Integer)]
+  [PushExpression(
+    StackTypes.BooleanVector,
+    "BOOLEAN[].INDEXOF",
+    "Pushes the index of the top BOOLEAN in the top BOOLEAN[] onto the INTEGER stack.",
+    StackTypes.Boolean | StackTypes.Integer)]
   public class BooleanVectorIndexOfExpression : VectorIndexOfExpression<bool> {
     public BooleanVectorIndexOfExpression() { }
@@ -91,5 +103,9 @@
 
   [StorableClass]
-  [PushExpression(StackTypes.StringVector, "STRING[].INDEXOF", StackTypes.String | StackTypes.String)]
+  [PushExpression(
+    StackTypes.StringVector,
+    "STRING[].INDEXOF",
+    "Pushes the index of the top STRING in the top STRING[] onto the INTEGER stack.",
+    StackTypes.String | StackTypes.Integer)]
   public class StringVectorIndexOfExpression : VectorIndexOfExpression<string> {
     public StringVectorIndexOfExpression() { }
Index: /branches/PushGP/HeuristicLab.PushGP/HeuristicLab.Problems.ProgramSynthesis/Push/Expressions/VectorIterateExpressions.cs
===================================================================
--- /branches/PushGP/HeuristicLab.PushGP/HeuristicLab.Problems.ProgramSynthesis/Push/Expressions/VectorIterateExpressions.cs	(revision 15031)
+++ /branches/PushGP/HeuristicLab.PushGP/HeuristicLab.Problems.ProgramSynthesis/Push/Expressions/VectorIterateExpressions.cs	(revision 15032)
@@ -62,5 +62,10 @@
 
   [StorableClass]
-  [PushExpression(StackTypes.IntegerVector, "INTEGER[].ITERATE", StackTypes.Integer | StackTypes.Exec, execIn: 1)]
+  [PushExpression(
+    StackTypes.IntegerVector,
+    "INTEGER[].ITERATE",
+    "Iterates in reverse order (due to performance reasons) over the top INTEGER[] using the top item of the EXEC stack.",
+    StackTypes.Integer | StackTypes.Exec,
+    execIn: 1)]
   public class IntegerVectorIterateExpression : VectorIterateExpression<long> {
     public IntegerVectorIterateExpression() { }
@@ -78,5 +83,9 @@
 
   [StorableClass]
-  [PushExpression(StackTypes.FloatVector, "FLOAT[].ITERATE", StackTypes.Float | StackTypes.Exec, execIn: 1)]
+  [PushExpression(
+    StackTypes.FloatVector,
+    "FLOAT[].ITERATE",
+    "Iterates in reverse order (due to performance reasons) over the top FLOAT[] using the top item of the EXEC stack.",
+    StackTypes.Float | StackTypes.Exec, execIn: 1)]
   public class FloatVectorIterateExpression : VectorIterateExpression<double> {
     public FloatVectorIterateExpression() { }
@@ -94,5 +103,9 @@
 
   [StorableClass]
-  [PushExpression(StackTypes.BooleanVector, "BOOLEAN[].ITERATE", StackTypes.Boolean | StackTypes.Exec, execIn: 1)]
+  [PushExpression(
+    StackTypes.BooleanVector,
+    "BOOLEAN[].ITERATE",
+    "Iterates in reverse order (due to performance reasons) over the top BOOLEAN[] using the top item of the EXEC stack.",
+    StackTypes.Boolean | StackTypes.Exec, execIn: 1)]
   public class BooleanVectorIterateExpression : VectorIterateExpression<bool> {
     public BooleanVectorIterateExpression() { }
@@ -110,5 +123,9 @@
 
   [StorableClass]
-  [PushExpression(StackTypes.StringVector, "STRING[].ITERATE", StackTypes.String | StackTypes.Exec, execIn: 1)]
+  [PushExpression(
+    StackTypes.StringVector,
+    "STRING[].ITERATE",
+    "Iterates in reverse order (due to performance reasons) over the top STRING[] using the top item of the EXEC stack.",
+    StackTypes.String | StackTypes.Exec, execIn: 1)]
   public class StringVectorIterateExpression : VectorIterateExpression<string> {
     public StringVectorIterateExpression() { }
Index: /branches/PushGP/HeuristicLab.PushGP/HeuristicLab.Problems.ProgramSynthesis/Push/Expressions/VectorLastExpressions.cs
===================================================================
--- /branches/PushGP/HeuristicLab.PushGP/HeuristicLab.Problems.ProgramSynthesis/Push/Expressions/VectorLastExpressions.cs	(revision 15031)
+++ /branches/PushGP/HeuristicLab.PushGP/HeuristicLab.Problems.ProgramSynthesis/Push/Expressions/VectorLastExpressions.cs	(revision 15032)
@@ -28,5 +28,9 @@
 
   [StorableClass]
-  [PushExpression(StackTypes.IntegerVector, "INTEGER[].LAST", StackTypes.Integer)]
+  [PushExpression(
+    StackTypes.IntegerVector,
+    "INTEGER[].LAST",
+    "Gets the last item from the top INTEGER[].",
+    StackTypes.Integer)]
   public class IntegerVectorLastExpression : VectorLastExpression<long> {
     public IntegerVectorLastExpression() { }
@@ -44,5 +48,9 @@
 
   [StorableClass]
-  [PushExpression(StackTypes.FloatVector, "FLOAT[].LAST", StackTypes.Float)]
+  [PushExpression(
+    StackTypes.FloatVector,
+    "FLOAT[].LAST",
+    "Gets the last item from the top FLOAT[].",
+    StackTypes.Float)]
   public class FloatVectorLastExpression : VectorLastExpression<double> {
     public FloatVectorLastExpression() { }
@@ -60,5 +68,9 @@
 
   [StorableClass]
-  [PushExpression(StackTypes.BooleanVector, "BOOLEAN[].LAST", StackTypes.Boolean)]
+  [PushExpression(
+    StackTypes.BooleanVector,
+    "BOOLEAN[].LAST",
+    "Gets the last item from the top BOOLEAN[].",
+    StackTypes.Boolean)]
   public class BooleanVectorLastExpression : VectorLastExpression<bool> {
     public BooleanVectorLastExpression() { }
@@ -76,5 +88,9 @@
 
   [StorableClass]
-  [PushExpression(StackTypes.StringVector, "STRING[].LAST", StackTypes.String)]
+  [PushExpression(
+    StackTypes.StringVector,
+    "STRING[].LAST",
+    "Gets the last item from the top STRING[].",
+    StackTypes.String)]
   public class StringVectorLastExpression : VectorLastExpression<string> {
     public StringVectorLastExpression() { }
Index: /branches/PushGP/HeuristicLab.PushGP/HeuristicLab.Problems.ProgramSynthesis/Push/Expressions/VectorLengthExpressions.cs
===================================================================
--- /branches/PushGP/HeuristicLab.PushGP/HeuristicLab.Problems.ProgramSynthesis/Push/Expressions/VectorLengthExpressions.cs	(revision 15031)
+++ /branches/PushGP/HeuristicLab.PushGP/HeuristicLab.Problems.ProgramSynthesis/Push/Expressions/VectorLengthExpressions.cs	(revision 15032)
@@ -28,5 +28,9 @@
 
   [StorableClass]
-  [PushExpression(StackTypes.IntegerVector, "INTEGER[].LENGTH", StackTypes.Integer)]
+  [PushExpression(
+    StackTypes.IntegerVector,
+    "INTEGER[].LENGTH",
+    "Pushes the length of the top INTEGER[] on the INTEGER stack",
+    StackTypes.Integer)]
   public class IntegerVectorLengthExpression : VectorLengthExpression<long> {
     public IntegerVectorLengthExpression() { }
@@ -44,5 +48,9 @@
 
   [StorableClass]
-  [PushExpression(StackTypes.FloatVector, "FLOAT[].LENGTH", StackTypes.Integer)]
+  [PushExpression(
+    StackTypes.FloatVector,
+    "FLOAT[].LENGTH",
+    "Pushes the length of the top FLOAT[] on the INTEGER stack",
+    StackTypes.Integer)]
   public class FloatVectorLengthExpression : VectorLengthExpression<double> {
     public FloatVectorLengthExpression() { }
@@ -60,5 +68,9 @@
 
   [StorableClass]
-  [PushExpression(StackTypes.BooleanVector, "BOOLEAN[].LENGTH", StackTypes.Integer)]
+  [PushExpression(
+    StackTypes.BooleanVector,
+    "BOOLEAN[].LENGTH",
+    "Pushes the length of the top BOOLEAN[] on the INTEGER stack",
+    StackTypes.Integer)]
   public class BooleanVectorLengthExpression : VectorLengthExpression<bool> {
     public BooleanVectorLengthExpression() { }
@@ -76,5 +88,9 @@
 
   [StorableClass]
-  [PushExpression(StackTypes.StringVector, "STRING[].LENGTH", StackTypes.Integer)]
+  [PushExpression(
+    StackTypes.StringVector,
+    "STRING[].LENGTH",
+    "Pushes the length of the top STRING[] on the INTEGER stack",
+    StackTypes.Integer)]
   public class StringVectorLengthExpression : VectorLengthExpression<string> {
     public StringVectorLengthExpression() { }
Index: /branches/PushGP/HeuristicLab.PushGP/HeuristicLab.Problems.ProgramSynthesis/Push/Expressions/VectorNthExpressions.cs
===================================================================
--- /branches/PushGP/HeuristicLab.PushGP/HeuristicLab.Problems.ProgramSynthesis/Push/Expressions/VectorNthExpressions.cs	(revision 15031)
+++ /branches/PushGP/HeuristicLab.PushGP/HeuristicLab.Problems.ProgramSynthesis/Push/Expressions/VectorNthExpressions.cs	(revision 15032)
@@ -42,5 +42,9 @@
 
   [StorableClass]
-  [PushExpression(StackTypes.IntegerVector, "INTEGER[].NTH", StackTypes.Integer)]
+  [PushExpression(
+    StackTypes.IntegerVector,
+    "INTEGER[].NTH",
+    "Pushes the nth item from the top INTEGER[] onto the INTEGER stack, whereby n is taken from the INTEGER stack.",
+    StackTypes.Integer)]
   public class IntegerVectorNthExpression : VectorNthExpression<long> {
     public IntegerVectorNthExpression() { }
@@ -58,5 +62,9 @@
 
   [StorableClass]
-  [PushExpression(StackTypes.FloatVector, "FLOAT[].NTH", StackTypes.Float | StackTypes.Integer)]
+  [PushExpression(
+    StackTypes.FloatVector,
+    "FLOAT[].NTH",
+    "Pushes the nth item from the top FLOAT[] onto the FLOAT stack, whereby n is taken from the INTEGER stack.",
+    StackTypes.Float | StackTypes.Integer)]
   public class FloatVectorNthExpression : VectorNthExpression<double> {
     public FloatVectorNthExpression() { }
@@ -74,5 +82,9 @@
 
   [StorableClass]
-  [PushExpression(StackTypes.BooleanVector, "BOOLEAN[].NTH", StackTypes.Boolean | StackTypes.Integer)]
+  [PushExpression(
+    StackTypes.BooleanVector,
+    "BOOLEAN[].NTH",
+    "Pushes the nth item from the top BOOLEAN[] onto the BOOLEAN stack, whereby n is taken from the INTEGER stack.",
+    StackTypes.Boolean | StackTypes.Integer)]
   public class BooleanVectorNthExpression : VectorNthExpression<bool> {
     public BooleanVectorNthExpression() { }
@@ -90,5 +102,9 @@
 
   [StorableClass]
-  [PushExpression(StackTypes.StringVector, "STRING[].NTH", StackTypes.String | StackTypes.Integer)]
+  [PushExpression(
+    StackTypes.StringVector,
+    "STRING[].NTH",
+    "Pushes the nth item from the top STRING[] onto the BOOLEAN stack, whereby n is taken from the INTEGER stack.",
+    StackTypes.String | StackTypes.Integer)]
   public class StringVectorNthExpression : VectorNthExpression<string> {
     public StringVectorNthExpression() { }
Index: /branches/PushGP/HeuristicLab.PushGP/HeuristicLab.Problems.ProgramSynthesis/Push/Expressions/VectorOccurrenceOfExpressions.cs
===================================================================
--- /branches/PushGP/HeuristicLab.PushGP/HeuristicLab.Problems.ProgramSynthesis/Push/Expressions/VectorOccurrenceOfExpressions.cs	(revision 15031)
+++ /branches/PushGP/HeuristicLab.PushGP/HeuristicLab.Problems.ProgramSynthesis/Push/Expressions/VectorOccurrenceOfExpressions.cs	(revision 15032)
@@ -40,5 +40,9 @@
 
   [StorableClass]
-  [PushExpression(StackTypes.IntegerVector, "INTEGER[].OCCURRENCEOF", StackTypes.Integer)]
+  [PushExpression(
+    StackTypes.IntegerVector,
+    "INTEGER[].OCCURRENCEOF",
+    "Pushes the amount of occurrences of the top INTEGER in the top INTEGER[] onto the INTEGER stack.",
+    StackTypes.Integer)]
   public class IntegerVectorOccurrenceOfExpression : VectorOccurrenceOfExpression<long> {
     public IntegerVectorOccurrenceOfExpression() { }
@@ -56,5 +60,9 @@
 
   [StorableClass]
-  [PushExpression(StackTypes.FloatVector, "FLOAT[].OCCURRENCEOF", StackTypes.Float | StackTypes.Integer)]
+  [PushExpression(
+    StackTypes.FloatVector,
+    "FLOAT[].OCCURRENCEOF",
+    "Pushes the amount of occurrences of the top FLOAT in the top FLOAT[] onto the INTEGER stack.",
+    StackTypes.Float | StackTypes.Integer)]
   public class FloatVectorOccurrenceOfExpression : VectorOccurrenceOfExpression<double> {
     public FloatVectorOccurrenceOfExpression() { }
@@ -72,5 +80,9 @@
 
   [StorableClass]
-  [PushExpression(StackTypes.BooleanVector, "BOOLEAN[].OCCURRENCEOF", StackTypes.Boolean | StackTypes.Integer)]
+  [PushExpression(
+    StackTypes.BooleanVector,
+    "BOOLEAN[].OCCURRENCEOF",
+    "Pushes the amount of occurrences of the top BOOLEAN in the top BOOLEAN[] onto the INTEGER stack.",
+    StackTypes.Boolean | StackTypes.Integer)]
   public class BooleanVectorOccurrenceOfExpression : VectorOccurrenceOfExpression<bool> {
     public BooleanVectorOccurrenceOfExpression() { }
@@ -88,5 +100,9 @@
 
   [StorableClass]
-  [PushExpression(StackTypes.StringVector, "STRING[].OCCURRENCEOF", StackTypes.String | StackTypes.Integer)]
+  [PushExpression(
+    StackTypes.StringVector,
+    "STRING[].OCCURRENCEOF",
+    "Pushes the amount of occurrences of the top STRING in the top STRING[] onto the INTEGER stack.",
+    StackTypes.String | StackTypes.Integer)]
   public class StringVectorOccurrenceOfExpression : VectorOccurrenceOfExpression<string> {
     public StringVectorOccurrenceOfExpression() { }
Index: /branches/PushGP/HeuristicLab.PushGP/HeuristicLab.Problems.ProgramSynthesis/Push/Expressions/VectorPushAllExpressions.cs
===================================================================
--- /branches/PushGP/HeuristicLab.PushGP/HeuristicLab.Problems.ProgramSynthesis/Push/Expressions/VectorPushAllExpressions.cs	(revision 15031)
+++ /branches/PushGP/HeuristicLab.PushGP/HeuristicLab.Problems.ProgramSynthesis/Push/Expressions/VectorPushAllExpressions.cs	(revision 15032)
@@ -29,5 +29,9 @@
 
   [StorableClass]
-  [PushExpression(StackTypes.IntegerVector, "INTEGER[].PUSHALL", StackTypes.Integer)]
+  [PushExpression(
+    StackTypes.IntegerVector,
+    "INTEGER[].PUSHALL",
+    "Pushes every item from the top INTEGER[] onto the INTEGER stack in reversed order.",
+    StackTypes.Integer)]
   public class IntegerVectorPushAllExpression : VectorPushAllExpression<long> {
     public IntegerVectorPushAllExpression() { }
@@ -45,5 +49,9 @@
 
   [StorableClass]
-  [PushExpression(StackTypes.FloatVector, "FLOAT[].PUSHALL", StackTypes.Float)]
+  [PushExpression(
+    StackTypes.FloatVector,
+    "FLOAT[].PUSHALL",
+    "Pushes every item from the top FLOAT[] onto the FLOAT stack in reversed order.",
+    StackTypes.Float)]
   public class FloatVectorPushAllExpression : VectorPushAllExpression<double> {
     public FloatVectorPushAllExpression() { }
@@ -61,5 +69,9 @@
 
   [StorableClass]
-  [PushExpression(StackTypes.BooleanVector, "BOOLEAN[].PUSHALL", StackTypes.Boolean)]
+  [PushExpression(
+    StackTypes.BooleanVector,
+    "BOOLEAN[].PUSHALL",
+    "Pushes every item from the top BOOLEAN[] onto the BOOLEAN stack in reversed order.",
+    StackTypes.Boolean)]
   public class BooleanVectorPushAllExpression : VectorPushAllExpression<bool> {
     public BooleanVectorPushAllExpression() { }
@@ -77,5 +89,9 @@
 
   [StorableClass]
-  [PushExpression(StackTypes.StringVector, "STRING[].PUSHALL", StackTypes.String)]
+  [PushExpression(
+    StackTypes.StringVector,
+    "STRING[].PUSHALL",
+    "Pushes every item from the top STRING[] onto the STRING stack in reversed order.",
+    StackTypes.String)]
   public class StringVectorPushAllExpression : VectorPushAllExpression<string> {
     public StringVectorPushAllExpression() { }
Index: /branches/PushGP/HeuristicLab.PushGP/HeuristicLab.Problems.ProgramSynthesis/Push/Expressions/VectorRemoveExpressions.cs
===================================================================
--- /branches/PushGP/HeuristicLab.PushGP/HeuristicLab.Problems.ProgramSynthesis/Push/Expressions/VectorRemoveExpressions.cs	(revision 15031)
+++ /branches/PushGP/HeuristicLab.PushGP/HeuristicLab.Problems.ProgramSynthesis/Push/Expressions/VectorRemoveExpressions.cs	(revision 15032)
@@ -30,5 +30,9 @@
 
   [StorableClass]
-  [PushExpression(StackTypes.IntegerVector, "INTEGER[].REMOVE", StackTypes.Integer)]
+  [PushExpression(
+    StackTypes.IntegerVector,
+    "INTEGER[].REMOVE",
+    "Removes all occurrences of the top INTEGER in the top INTEGER[].",
+    StackTypes.Integer)]
   public class IntegerVectorRemoveExpression : VectorRemoveExpression<long> {
     public IntegerVectorRemoveExpression() { }
@@ -46,5 +50,9 @@
 
   [StorableClass]
-  [PushExpression(StackTypes.FloatVector, "FLOAT[].REMOVE", StackTypes.Float)]
+  [PushExpression(
+    StackTypes.FloatVector,
+    "FLOAT[].REMOVE",
+    "Removes all occurrences of the top FLOAT in the top FLOAT[].",
+    StackTypes.Float)]
   public class FloatVectorRemoveExpression : VectorRemoveExpression<double> {
     public FloatVectorRemoveExpression() { }
@@ -62,5 +70,9 @@
 
   [StorableClass]
-  [PushExpression(StackTypes.BooleanVector, "BOOLEAN[].REMOVE", StackTypes.Boolean)]
+  [PushExpression(
+    StackTypes.BooleanVector,
+    "BOOLEAN[].REMOVE",
+    "Removes all occurrences of the top BOOLEAN in the top BOOLEAN[].",
+    StackTypes.Boolean)]
   public class BooleanVectorRemoveExpression : VectorRemoveExpression<bool> {
     public BooleanVectorRemoveExpression() { }
@@ -78,5 +90,9 @@
 
   [StorableClass]
-  [PushExpression(StackTypes.StringVector, "STRING[].REMOVE", StackTypes.String)]
+  [PushExpression(
+    StackTypes.StringVector,
+    "Removes all occurrences of the top STRING in the top STRING[].",
+    "STRING[].REMOVE",
+    StackTypes.String)]
   public class StringVectorRemoveExpression : VectorRemoveExpression<string> {
     public StringVectorRemoveExpression() { }
Index: /branches/PushGP/HeuristicLab.PushGP/HeuristicLab.Problems.ProgramSynthesis/Push/Expressions/VectorReplaceExpressions.cs
===================================================================
--- /branches/PushGP/HeuristicLab.PushGP/HeuristicLab.Problems.ProgramSynthesis/Push/Expressions/VectorReplaceExpressions.cs	(revision 15031)
+++ /branches/PushGP/HeuristicLab.PushGP/HeuristicLab.Problems.ProgramSynthesis/Push/Expressions/VectorReplaceExpressions.cs	(revision 15032)
@@ -38,5 +38,9 @@
 
   [StorableClass]
-  [PushExpression(StackTypes.IntegerVector, "INTEGER[].REPLACE", StackTypes.Integer)]
+  [PushExpression(
+    StackTypes.IntegerVector,
+    "INTEGER[].REPLACE",
+    "Replaces all occurrences of the second INTEGER with the INTEGER in the top INTEGER[].",
+    StackTypes.Integer)]
   public class IntegerVectorReplaceExpression : VectorReplaceExpression<long> {
     public IntegerVectorReplaceExpression() { }
@@ -54,5 +58,9 @@
 
   [StorableClass]
-  [PushExpression(StackTypes.FloatVector, "FLOAT[].REPLACE", StackTypes.Float)]
+  [PushExpression(
+    StackTypes.FloatVector,
+    "FLOAT[].REPLACE",
+    "Replaces all occurrences of the second FLOAT with the FLOAT in the top FLOAT[].",
+    StackTypes.Float)]
   public class FloatVectorReplaceExpression : VectorReplaceExpression<double> {
     public FloatVectorReplaceExpression() { }
@@ -70,5 +78,9 @@
 
   [StorableClass]
-  [PushExpression(StackTypes.BooleanVector, "BOOLEAN[].REPLACE", StackTypes.Boolean)]
+  [PushExpression(
+    StackTypes.BooleanVector,
+    "BOOLEAN[].REPLACE",
+    "Replaces all occurrences of the second BOOLEAN with the BOOLEAN in the top BOOLEAN[].",
+    StackTypes.Boolean)]
   public class BooleanVectorReplaceExpression : VectorReplaceExpression<bool> {
     public BooleanVectorReplaceExpression() { }
@@ -86,5 +98,9 @@
 
   [StorableClass]
-  [PushExpression(StackTypes.StringVector, "STRING[].REPLACE", StackTypes.String)]
+  [PushExpression(
+    StackTypes.StringVector,
+    "STRING[].REPLACE",
+    "Replaces all occurrences of the second STRING with the STRING in the top STRING[].",
+    StackTypes.String)]
   public class StringVectorReplaceExpression : VectorReplaceExpression<string> {
     public StringVectorReplaceExpression() { }
Index: /branches/PushGP/HeuristicLab.PushGP/HeuristicLab.Problems.ProgramSynthesis/Push/Expressions/VectorReplaceFirstExpressions.cs
===================================================================
--- /branches/PushGP/HeuristicLab.PushGP/HeuristicLab.Problems.ProgramSynthesis/Push/Expressions/VectorReplaceFirstExpressions.cs	(revision 15031)
+++ /branches/PushGP/HeuristicLab.PushGP/HeuristicLab.Problems.ProgramSynthesis/Push/Expressions/VectorReplaceFirstExpressions.cs	(revision 15032)
@@ -8,5 +8,5 @@
 
   /// <summary>
-  /// Replace first occurrences of the second lit-type item with the first lit-type item in the top type vector.
+  /// Replace first occurrence of the second lit-type item with the first lit-type item in the top type vector.
   /// </summary>
   /// <typeparam name="T"></typeparam>
@@ -44,5 +44,9 @@
 
   [StorableClass]
-  [PushExpression(StackTypes.IntegerVector, "INTEGER[].REPLACEFIRST", StackTypes.Integer)]
+  [PushExpression(
+    StackTypes.IntegerVector,
+    "INTEGER[].REPLACEFIRST",
+    "Replace first occurrence of the second INTEGER with the INTEGER in the top INTEGER[].",
+    StackTypes.Integer)]
   public class IntegerVectorReplaceFirstExpression : VectorReplaceFirstExpression<long> {
     public IntegerVectorReplaceFirstExpression() { }
@@ -60,5 +64,9 @@
 
   [StorableClass]
-  [PushExpression(StackTypes.FloatVector, "FLOAT[].REPLACEFIRST", StackTypes.Float)]
+  [PushExpression(
+    StackTypes.FloatVector,
+    "FLOAT[].REPLACEFIRST",
+    "Replace first occurrence of the second FLOAT with the FLOAT in the top FLOAT[].",
+    StackTypes.Float)]
   public class FloatVectorReplaceFirstExpression : VectorReplaceFirstExpression<double> {
     public FloatVectorReplaceFirstExpression() { }
@@ -76,5 +84,9 @@
 
   [StorableClass]
-  [PushExpression(StackTypes.BooleanVector, "BOOLEAN[].REPLACEFIRST", StackTypes.Boolean)]
+  [PushExpression(
+    StackTypes.BooleanVector,
+    "BOOLEAN[].REPLACEFIRST",
+    "Replace first occurrence of the second BOOLEAN with the BOOLEAN in the top BOOLEAN[].",
+    StackTypes.Boolean)]
   public class BooleanVectorReplaceFirstExpression : VectorReplaceFirstExpression<bool> {
     public BooleanVectorReplaceFirstExpression() { }
@@ -92,5 +104,9 @@
 
   [StorableClass]
-  [PushExpression(StackTypes.StringVector, "STRING[].REPLACEFIRST", StackTypes.String)]
+  [PushExpression(
+    StackTypes.StringVector,
+    "STRING[].REPLACEFIRST",
+    "Replace first occurrence of the second STRING with the STRING in the top STRING[].",
+    StackTypes.String)]
   public class StringVectorReplaceFirstExpression : VectorReplaceFirstExpression<string> {
     public StringVectorReplaceFirstExpression() { }
Index: /branches/PushGP/HeuristicLab.PushGP/HeuristicLab.Problems.ProgramSynthesis/Push/Expressions/VectorRestExpressions.cs
===================================================================
--- /branches/PushGP/HeuristicLab.PushGP/HeuristicLab.Problems.ProgramSynthesis/Push/Expressions/VectorRestExpressions.cs	(revision 15031)
+++ /branches/PushGP/HeuristicLab.PushGP/HeuristicLab.Problems.ProgramSynthesis/Push/Expressions/VectorRestExpressions.cs	(revision 15032)
@@ -47,5 +47,8 @@
 
   [StorableClass]
-  [PushExpression(StackTypes.IntegerVector, "INTEGER[].REST")]
+  [PushExpression(
+    StackTypes.IntegerVector,
+    "INTEGER[].REST",
+    "Removes the first item of the top INTEGER[].")]
   public class IntegerVectorRestExpression : VectorRestExpression<long> {
     public IntegerVectorRestExpression() { }
@@ -63,5 +66,8 @@
 
   [StorableClass]
-  [PushExpression(StackTypes.FloatVector, "FLOAT[].REST")]
+  [PushExpression(
+    StackTypes.FloatVector,
+    "FLOAT[].REST",
+    "Removes the first item of the top FLOAT[].")]
   public class FloatVectorRestExpression : VectorRestExpression<double> {
     public FloatVectorRestExpression() { }
@@ -79,5 +85,8 @@
 
   [StorableClass]
-  [PushExpression(StackTypes.BooleanVector, "BOOLEAN[].REST")]
+  [PushExpression(
+    StackTypes.BooleanVector,
+    "BOOLEAN[].REST",
+    "Removes the first item of the top BOOLEAN[].")]
   public class BooleanVectorRestExpression : VectorRestExpression<bool> {
     public BooleanVectorRestExpression() { }
@@ -95,5 +104,8 @@
 
   [StorableClass]
-  [PushExpression(StackTypes.StringVector, "STRING[].REST")]
+  [PushExpression(
+    StackTypes.StringVector,
+    "STRING[].REST",
+    "Removes the first item of the top STRING[].")]
   public class StringVectorRestExpression : VectorRestExpression<string> {
     public StringVectorRestExpression() { }
Index: /branches/PushGP/HeuristicLab.PushGP/HeuristicLab.Problems.ProgramSynthesis/Push/Expressions/VectorReverseExpressions.cs
===================================================================
--- /branches/PushGP/HeuristicLab.PushGP/HeuristicLab.Problems.ProgramSynthesis/Push/Expressions/VectorReverseExpressions.cs	(revision 15031)
+++ /branches/PushGP/HeuristicLab.PushGP/HeuristicLab.Problems.ProgramSynthesis/Push/Expressions/VectorReverseExpressions.cs	(revision 15032)
@@ -30,5 +30,8 @@
 
   [StorableClass]
-  [PushExpression(StackTypes.IntegerVector, "INTEGER[].REVERSE")]
+  [PushExpression(
+    StackTypes.IntegerVector,
+    "INTEGER[].REVERSE",
+    "Reverses the top INTEGER[].")]
   public class IntegerVectorReverseExpression : VectorReverseExpression<long> {
     public IntegerVectorReverseExpression() { }
@@ -46,5 +49,8 @@
 
   [StorableClass]
-  [PushExpression(StackTypes.FloatVector, "FLOAT[].REVERSE")]
+  [PushExpression(
+    StackTypes.FloatVector,
+    "FLOAT[].REVERSE",
+    "Reverses the top FLOAT[].")]
   public class FloatVectorReverseExpression : VectorReverseExpression<double> {
     public FloatVectorReverseExpression() { }
@@ -62,5 +68,8 @@
 
   [StorableClass]
-  [PushExpression(StackTypes.BooleanVector, "BOOLEAN[].REVERSE")]
+  [PushExpression(
+    StackTypes.BooleanVector,
+    "BOOLEAN[].REVERSE",
+    "Reverses the top BOOLEAN[].")]
   public class BooleanVectorReverseExpression : VectorReverseExpression<bool> {
     public BooleanVectorReverseExpression() { }
@@ -78,5 +87,8 @@
 
   [StorableClass]
-  [PushExpression(StackTypes.StringVector, "STRING[].REVERSE")]
+  [PushExpression(
+    StackTypes.StringVector,
+    "STRING[].REVERSE",
+    "Reverses the top STRING[].")]
   public class StringVectorReverseExpression : VectorReverseExpression<string> {
     public StringVectorReverseExpression() { }
Index: /branches/PushGP/HeuristicLab.PushGP/HeuristicLab.Problems.ProgramSynthesis/Push/Expressions/VectorSetExpressions.cs
===================================================================
--- /branches/PushGP/HeuristicLab.PushGP/HeuristicLab.Problems.ProgramSynthesis/Push/Expressions/VectorSetExpressions.cs	(revision 15031)
+++ /branches/PushGP/HeuristicLab.PushGP/HeuristicLab.Problems.ProgramSynthesis/Push/Expressions/VectorSetExpressions.cs	(revision 15032)
@@ -56,5 +56,9 @@
 
   [StorableClass]
-  [PushExpression(StackTypes.IntegerVector, "INTEGER[].SET", StackTypes.Integer)]
+  [PushExpression(
+    StackTypes.IntegerVector,
+    "INTEGER[].SET",
+    "Replaces in the top INTEGER[] item at index (from INTEGER stack) with the first INTEGER item.",
+    StackTypes.Integer)]
   public class IntegerVectorSetExpression : VectorSetExpression<long> {
     public IntegerVectorSetExpression() { }
@@ -72,5 +76,9 @@
 
   [StorableClass]
-  [PushExpression(StackTypes.FloatVector, "FLOAT[].SET", StackTypes.Float | StackTypes.Integer)]
+  [PushExpression(
+    StackTypes.FloatVector,
+    "FLOAT[].SET",
+    "Replaces in the top FLOAT[] item at index (from INTEGER stack) with the first FLOAT item.",
+    StackTypes.Float | StackTypes.Integer)]
   public class FloatVectorSetExpression : VectorSetExpression<double> {
     public FloatVectorSetExpression() { }
@@ -88,5 +96,9 @@
 
   [StorableClass]
-  [PushExpression(StackTypes.BooleanVector, "BOOLEAN[].SET", StackTypes.Boolean | StackTypes.Integer)]
+  [PushExpression(
+    StackTypes.BooleanVector,
+    "BOOLEAN[].SET",
+    "Replaces in the top BOOLEAN[] item at index (from INTEGER stack) with the first BOOLEAN item.",
+    StackTypes.Boolean | StackTypes.Integer)]
   public class BooleanVectorSetExpression : VectorSetExpression<bool> {
     public BooleanVectorSetExpression() { }
@@ -104,5 +116,9 @@
 
   [StorableClass]
-  [PushExpression(StackTypes.StringVector, "STRING[].SET", StackTypes.String | StackTypes.Integer)]
+  [PushExpression(
+    StackTypes.StringVector,
+    "STRING[].SET",
+    "Replaces in the top STRING[] item at index (from INTEGER stack) with the first STRING item.",
+    StackTypes.String | StackTypes.Integer)]
   public class StringVectorSetExpression : VectorSetExpression<string> {
     public StringVectorSetExpression() { }
Index: /branches/PushGP/HeuristicLab.PushGP/HeuristicLab.Problems.ProgramSynthesis/Push/Expressions/VectorSubExpressions.cs
===================================================================
--- /branches/PushGP/HeuristicLab.PushGP/HeuristicLab.Problems.ProgramSynthesis/Push/Expressions/VectorSubExpressions.cs	(revision 15031)
+++ /branches/PushGP/HeuristicLab.PushGP/HeuristicLab.Problems.ProgramSynthesis/Push/Expressions/VectorSubExpressions.cs	(revision 15032)
@@ -56,5 +56,9 @@
 
   [StorableClass]
-  [PushExpression(StackTypes.IntegerVector, "INTEGER[].SUB", StackTypes.Integer)]
+  [PushExpression(
+    StackTypes.IntegerVector,
+    "INTEGER[].SUB",
+    "Pushes the sub vector of the top INTEGER[].",
+    StackTypes.Integer)]
   public class IntegerVectorSubExpression : VectorSubExpression<long> {
     public IntegerVectorSubExpression() { }
@@ -72,5 +76,9 @@
 
   [StorableClass]
-  [PushExpression(StackTypes.FloatVector, "FLOAT[].SUB", StackTypes.Integer)]
+  [PushExpression(
+    StackTypes.FloatVector,
+    "FLOAT[].SUB",
+    "Pushes the sub vector of the top FLOAT[].",
+    StackTypes.Integer)]
   public class FloatVectorSubExpression : VectorSubExpression<double> {
     public FloatVectorSubExpression() { }
@@ -88,5 +96,9 @@
 
   [StorableClass]
-  [PushExpression(StackTypes.BooleanVector, "BOOLEAN[].SUB", StackTypes.Integer)]
+  [PushExpression(
+    StackTypes.BooleanVector,
+    "BOOLEAN[].SUB",
+    "Pushes the sub vector of the top BOOLEAN[].",
+    StackTypes.Integer)]
   public class BooleanVectorSubExpression : VectorSubExpression<bool> {
     public BooleanVectorSubExpression() { }
@@ -104,5 +116,9 @@
 
   [StorableClass]
-  [PushExpression(StackTypes.StringVector, "STRING[].SUB", StackTypes.Integer)]
+  [PushExpression(
+    StackTypes.StringVector,
+    "STRING[].SUB",
+    "Pushes the sub vector of the top STRING[].",
+    StackTypes.Integer)]
   public class StringVectorSubExpression : VectorSubExpression<string> {
     public StringVectorSubExpression() { }
Index: /branches/PushGP/HeuristicLab.PushGP/HeuristicLab.Problems.ProgramSynthesis/Push/Expressions/VectorTakeExpressions.cs
===================================================================
--- /branches/PushGP/HeuristicLab.PushGP/HeuristicLab.Problems.ProgramSynthesis/Push/Expressions/VectorTakeExpressions.cs	(revision 15031)
+++ /branches/PushGP/HeuristicLab.PushGP/HeuristicLab.Problems.ProgramSynthesis/Push/Expressions/VectorTakeExpressions.cs	(revision 15032)
@@ -58,5 +58,9 @@
 
   [StorableClass]
-  [PushExpression(StackTypes.IntegerVector, "INTEGER[].TAKE", StackTypes.Integer)]
+  [PushExpression(
+    StackTypes.IntegerVector,
+    "INTEGER[].TAKE",
+    "Takes the first n items of the top INTEGER[], where n is from the INTEGER stack.",
+    StackTypes.Integer)]
   public class IntegerVectorTakeExpression : VectorTakeExpression<long> {
     public IntegerVectorTakeExpression() { }
@@ -74,5 +78,9 @@
 
   [StorableClass]
-  [PushExpression(StackTypes.FloatVector, "FLOAT[].TAKE", StackTypes.Integer)]
+  [PushExpression(
+    StackTypes.FloatVector,
+    "FLOAT[].TAKE",
+    "Takes the first n items of the top FLOAT[], where n is from the INTEGER stack.",
+    StackTypes.Integer)]
   public class FloatVectorTakeExpression : VectorTakeExpression<double> {
     public FloatVectorTakeExpression() { }
@@ -90,5 +98,9 @@
 
   [StorableClass]
-  [PushExpression(StackTypes.BooleanVector, "BOOLEAN[].TAKE", StackTypes.Integer)]
+  [PushExpression(
+    StackTypes.BooleanVector,
+    "BOOLEAN[].TAKE",
+    "Takes the first n items of the top BOOLEAN[], where n is from the INTEGER stack.",
+    StackTypes.Integer)]
   public class BooleanVectorTakeExpression : VectorTakeExpression<bool> {
     public BooleanVectorTakeExpression() { }
@@ -106,5 +118,9 @@
 
   [StorableClass]
-  [PushExpression(StackTypes.StringVector, "STRING[].TAKE", StackTypes.Integer)]
+  [PushExpression(
+    StackTypes.StringVector,
+    "STRING[].TAKE",
+    "Takes the first n items of the top STRING[], where n is from the INTEGER stack.",
+    StackTypes.Integer)]
   public class StringVectorTakeExpression : VectorTakeExpression<string> {
     public StringVectorTakeExpression() { }
Index: /branches/PushGP/HeuristicLab.PushGP/HeuristicLab.Problems.ProgramSynthesis/Push/Expressions/YankDuplicateExpressions.cs
===================================================================
--- /branches/PushGP/HeuristicLab.PushGP/HeuristicLab.Problems.ProgramSynthesis/Push/Expressions/YankDuplicateExpressions.cs	(revision 15031)
+++ /branches/PushGP/HeuristicLab.PushGP/HeuristicLab.Problems.ProgramSynthesis/Push/Expressions/YankDuplicateExpressions.cs	(revision 15032)
@@ -11,6 +11,6 @@
 
   /// <summary>
-  ///     Pushes a copy of an indexed item "deep" in the stack onto the top of the stack, without removing the deep item.
-  ///     The index is taken from the INTEGER stack, and the indexing is done after the index is removed.
+  /// Pushes a copy of an indexed item "deep" in the stack onto the top of the stack, without removing the deep item.
+  /// The index is taken from the INTEGER stack, and the indexing is done after the index is removed.
   /// </summary>
   /// <typeparam name="T">Stacktype</typeparam>
@@ -33,5 +33,8 @@
 
   [StorableClass]
-  [PushExpression(StackTypes.Integer, "INTEGER.YANKDUP")]
+  [PushExpression(
+    StackTypes.Integer,
+    "INTEGER.YANKDUP",
+    "Pushes a copy of an indexed item \"deep\" in the stack onto the top of the stack, without removing the deep item.")]
   public class IntegerYankDuplicateExpression : YankDuplicateExpression<long> {
     public IntegerYankDuplicateExpression() { }
@@ -49,5 +52,9 @@
 
   [StorableClass]
-  [PushExpression(StackTypes.Float, "FLOAT.YANKDUP", StackTypes.Integer)]
+  [PushExpression(
+    StackTypes.Float,
+    "FLOAT.YANKDUP",
+    "Pushes a copy of an indexed item \"deep\" in the stack onto the top of the stack, without removing the deep item.",
+    StackTypes.Integer)]
   public class FloatYankDuplicateExpression : YankDuplicateExpression<double> {
     public FloatYankDuplicateExpression() { }
@@ -65,5 +72,9 @@
 
   [StorableClass]
-  [PushExpression(StackTypes.Boolean, "BOOLEAN.YANKDUP", StackTypes.Integer)]
+  [PushExpression(
+    StackTypes.Boolean,
+    "BOOLEAN.YANKDUP",
+    "Pushes a copy of an indexed item \"deep\" in the stack onto the top of the stack, without removing the deep item.",
+    StackTypes.Integer)]
   public class BooleanYankDuplicateExpression : YankDuplicateExpression<bool> {
     public BooleanYankDuplicateExpression() { }
@@ -81,5 +92,9 @@
 
   [StorableClass]
-  [PushExpression(StackTypes.Name, "NAME.YANKDUP", StackTypes.Integer)]
+  [PushExpression(
+    StackTypes.Name,
+    "NAME.YANKDUP",
+    "Pushes a copy of an indexed item \"deep\" in the stack onto the top of the stack, without removing the deep item.",
+    StackTypes.Integer)]
   public class NameYankDuplicateExpression : YankDuplicateExpression<string> {
     public NameYankDuplicateExpression() { }
@@ -97,5 +112,9 @@
 
   [StorableClass]
-  [PushExpression(StackTypes.Exec, "EXEC.YANKDUP", StackTypes.Integer, execIn: 0)]
+  [PushExpression(
+    StackTypes.Exec,
+    "EXEC.YANKDUP",
+    "Pushes a copy of an indexed item \"deep\" in the stack onto the top of the stack, without removing the deep item.",
+    StackTypes.Integer, execIn: 0)]
   public class ExecYankDuplicateExpression : YankDuplicateExpression<Expression> {
     public ExecYankDuplicateExpression() { }
@@ -113,5 +132,9 @@
 
   [StorableClass]
-  [PushExpression(StackTypes.Code, "CODE.YANKDUP", StackTypes.Integer)]
+  [PushExpression(
+    StackTypes.Code,
+    "CODE.YANKDUP",
+    "Pushes a copy of an indexed item \"deep\" in the stack onto the top of the stack, without removing the deep item.",
+    StackTypes.Integer)]
   public class CodeYankDuplicateExpression : YankDuplicateExpression<Expression> {
     public CodeYankDuplicateExpression() { }
@@ -129,5 +152,9 @@
 
   [StorableClass]
-  [PushExpression(StackTypes.Char, "CHAR.YANKDUP", StackTypes.Integer)]
+  [PushExpression(
+    StackTypes.Char,
+    "CHAR.YANKDUP",
+    "Pushes a copy of an indexed item \"deep\" in the stack onto the top of the stack, without removing the deep item.",
+    StackTypes.Integer)]
   public class CharYankDuplicateExpression : YankDuplicateExpression<char> {
     public CharYankDuplicateExpression() { }
@@ -145,5 +172,9 @@
 
   [StorableClass]
-  [PushExpression(StackTypes.String, "STRING.YANKDUP", StackTypes.Integer)]
+  [PushExpression(
+    StackTypes.String,
+    "STRING.YANKDUP",
+    "Pushes a copy of an indexed item \"deep\" in the stack onto the top of the stack, without removing the deep item.",
+    StackTypes.Integer)]
   public class StringYankDuplicateExpression : YankDuplicateExpression<string> {
     public StringYankDuplicateExpression() { }
@@ -161,5 +192,9 @@
 
   [StorableClass]
-  [PushExpression(StackTypes.IntegerVector, "INTEGER[].YANKDUP", StackTypes.Integer)]
+  [PushExpression(
+    StackTypes.IntegerVector,
+    "INTEGER[].YANKDUP",
+    "Pushes a copy of an indexed item \"deep\" in the stack onto the top of the stack, without removing the deep item.",
+    StackTypes.Integer)]
   public class IntegerVectorYankDuplicateExpression : YankDuplicateExpression<IReadOnlyList<long>> {
     public IntegerVectorYankDuplicateExpression() { }
@@ -177,5 +212,9 @@
 
   [StorableClass]
-  [PushExpression(StackTypes.FloatVector, "FLOAT[].YANKDUP", StackTypes.Integer)]
+  [PushExpression(
+    StackTypes.FloatVector,
+    "FLOAT[].YANKDUP",
+    "Pushes a copy of an indexed item \"deep\" in the stack onto the top of the stack, without removing the deep item.",
+    StackTypes.Integer)]
   public class FloatVectorYankDuplicateExpression : YankDuplicateExpression<IReadOnlyList<double>> {
     public FloatVectorYankDuplicateExpression() { }
@@ -193,5 +232,9 @@
 
   [StorableClass]
-  [PushExpression(StackTypes.BooleanVector, "BOOLEAN[].YANKDUP", StackTypes.Integer)]
+  [PushExpression(
+    StackTypes.BooleanVector,
+    "BOOLEAN[].YANKDUP",
+    "Pushes a copy of an indexed item \"deep\" in the stack onto the top of the stack, without removing the deep item.",
+    StackTypes.Integer)]
   public class BooleanVectorYankDuplicateExpression : YankDuplicateExpression<IReadOnlyList<bool>> {
     public BooleanVectorYankDuplicateExpression() { }
@@ -209,5 +252,9 @@
 
   [StorableClass]
-  [PushExpression(StackTypes.StringVector, "STRING[].YANKDUP", StackTypes.Integer)]
+  [PushExpression(
+    StackTypes.StringVector,
+    "STRING[].YANKDUP",
+    "Pushes a copy of an indexed item \"deep\" in the stack onto the top of the stack, without removing the deep item.",
+    StackTypes.Integer)]
   public class StringVectorYankDuplicateExpression : YankDuplicateExpression<IReadOnlyList<string>> {
     public StringVectorYankDuplicateExpression() { }
Index: /branches/PushGP/HeuristicLab.PushGP/HeuristicLab.Problems.ProgramSynthesis/Push/Expressions/YankExpressions.cs
===================================================================
--- /branches/PushGP/HeuristicLab.PushGP/HeuristicLab.Problems.ProgramSynthesis/Push/Expressions/YankExpressions.cs	(revision 15031)
+++ /branches/PushGP/HeuristicLab.PushGP/HeuristicLab.Problems.ProgramSynthesis/Push/Expressions/YankExpressions.cs	(revision 15032)
@@ -1,4 +1,3 @@
 ﻿namespace HeuristicLab.Problems.ProgramSynthesis.Push.Expressions {
-  using System;
   using System.Collections.Generic;
 
@@ -10,6 +9,6 @@
 
   /// <summary>
-  ///     Removes an indexed item from "deep" in the stack and pushes it on top of the stack.
-  ///     The index is taken from the INTEGER stack, and the indexing is done after the index is removed.
+  /// Removes an indexed item from "deep" in the stack and pushes it on top of the stack.
+  /// The index is taken from the INTEGER stack, and the indexing is done after the index is removed.
   /// </summary>
   /// <typeparam name="T">Stacktype</typeparam>
@@ -32,5 +31,8 @@
 
   [StorableClass]
-  [PushExpression(StackTypes.Integer, "INTEGER.YANK")]
+  [PushExpression(
+    StackTypes.Integer,
+    "INTEGER.YANK",
+    "Removes an indexed item from \"deep\" in the stack and pushes it on top of the stack.")]
   public class IntegerYankExpression : YankExpression<long> {
     public IntegerYankExpression() { }
@@ -48,5 +50,9 @@
 
   [StorableClass]
-  [PushExpression(StackTypes.Float, "FLOAT.YANK", StackTypes.Integer)]
+  [PushExpression(
+    StackTypes.Float,
+    "FLOAT.YANK",
+    "Removes an indexed item from \"deep\" in the stack and pushes it on top of the stack.",
+    StackTypes.Integer)]
   public class FloatYankExpression : YankExpression<double> {
     public FloatYankExpression() { }
@@ -64,5 +70,9 @@
 
   [StorableClass]
-  [PushExpression(StackTypes.Boolean, "BOOLEAN.YANK", StackTypes.Integer)]
+  [PushExpression(
+    StackTypes.Boolean,
+    "BOOLEAN.YANK",
+    "Removes an indexed item from \"deep\" in the stack and pushes it on top of the stack.",
+    StackTypes.Integer)]
   public class BooleanYankExpression : YankExpression<bool> {
     public BooleanYankExpression() { }
@@ -80,5 +90,9 @@
 
   [StorableClass]
-  [PushExpression(StackTypes.Name, "NAME.YANK", StackTypes.Integer)]
+  [PushExpression(
+    StackTypes.Name,
+    "NAME.YANK",
+    "Removes an indexed item from \"deep\" in the stack and pushes it on top of the stack.",
+    StackTypes.Integer)]
   public class NameYankExpression : YankExpression<string> {
     public NameYankExpression() { }
@@ -96,5 +110,10 @@
 
   [StorableClass]
-  [PushExpression(StackTypes.Exec, "EXEC.YANK", StackTypes.Integer, execIn: 0)]
+  [PushExpression(
+    StackTypes.Exec,
+    "EXEC.YANK",
+    "Removes an indexed item from \"deep\" in the stack and pushes it on top of the stack.",
+    StackTypes.Integer,
+    execIn: 0)]
   public class ExecYankExpression : YankExpression<Expression> {
     public ExecYankExpression() { }
@@ -112,5 +131,9 @@
 
   [StorableClass]
-  [PushExpression(StackTypes.Code, "CODE.YANK", StackTypes.Integer)]
+  [PushExpression(
+    StackTypes.Code,
+    "CODE.YANK",
+    "Removes an indexed item from \"deep\" in the stack and pushes it on top of the stack.",
+    StackTypes.Integer)]
   public class CodeYankExpression : YankExpression<Expression> {
     public CodeYankExpression() { }
@@ -128,5 +151,9 @@
 
   [StorableClass]
-  [PushExpression(StackTypes.Char, "CHAR.YANK", StackTypes.Integer)]
+  [PushExpression(
+    StackTypes.Char,
+    "CHAR.YANK",
+    "Removes an indexed item from \"deep\" in the stack and pushes it on top of the stack.",
+    StackTypes.Integer)]
   public class CharYankExpression : YankExpression<char> {
     public CharYankExpression() { }
@@ -144,5 +171,9 @@
 
   [StorableClass]
-  [PushExpression(StackTypes.String, "STRING.YANK", StackTypes.Integer)]
+  [PushExpression(
+    StackTypes.String,
+    "STRING.YANK",
+    "Removes an indexed item from \"deep\" in the stack and pushes it on top of the stack.",
+    StackTypes.Integer)]
   public class StringYankExpression : YankExpression<string> {
     public StringYankExpression() { }
@@ -160,5 +191,9 @@
 
   [StorableClass]
-  [PushExpression(StackTypes.IntegerVector, "INTEGER[].YANK", StackTypes.Integer)]
+  [PushExpression(
+    StackTypes.IntegerVector,
+    "INTEGER[].YANK",
+    "Removes an indexed item from \"deep\" in the stack and pushes it on top of the stack.",
+    StackTypes.Integer)]
   public class IntegerVectorYankExpression : YankExpression<IReadOnlyList<long>> {
     public IntegerVectorYankExpression() { }
@@ -176,5 +211,9 @@
 
   [StorableClass]
-  [PushExpression(StackTypes.FloatVector, "FLOAT[].YANK", StackTypes.Integer)]
+  [PushExpression(
+    StackTypes.FloatVector,
+    "FLOAT[].YANK",
+    "Removes an indexed item from \"deep\" in the stack and pushes it on top of the stack.",
+    StackTypes.Integer)]
   public class FloatVectorYankExpression : YankExpression<IReadOnlyList<double>> {
     public FloatVectorYankExpression() { }
@@ -192,5 +231,9 @@
 
   [StorableClass]
-  [PushExpression(StackTypes.BooleanVector, "BOOLEAN[].YANK", StackTypes.Integer)]
+  [PushExpression(
+    StackTypes.BooleanVector,
+    "BOOLEAN[].YANK",
+    "Removes an indexed item from \"deep\" in the stack and pushes it on top of the stack.",
+    StackTypes.Integer)]
   public class BooleanVectorYankExpression : YankExpression<IReadOnlyList<bool>> {
     public BooleanVectorYankExpression() { }
@@ -208,5 +251,9 @@
 
   [StorableClass]
-  [PushExpression(StackTypes.StringVector, "STRING[].YANK", StackTypes.Integer)]
+  [PushExpression(
+    StackTypes.StringVector,
+    "STRING[].YANK",
+    "Removes an indexed item from \"deep\" in the stack and pushes it on top of the stack.",
+    StackTypes.Integer)]
   public class StringVectorYankExpression : YankExpression<IReadOnlyList<string>> {
     public StringVectorYankExpression() { }
Index: /branches/PushGP/HeuristicLab.PushGP/HeuristicLab.Problems.ProgramSynthesis/Push/Interpreter/PooledPushInterpreter.cs
===================================================================
--- /branches/PushGP/HeuristicLab.PushGP/HeuristicLab.Problems.ProgramSynthesis/Push/Interpreter/PooledPushInterpreter.cs	(revision 15031)
+++ /branches/PushGP/HeuristicLab.PushGP/HeuristicLab.Problems.ProgramSynthesis/Push/Interpreter/PooledPushInterpreter.cs	(revision 15032)
@@ -15,5 +15,5 @@
     public override void Dispose() {
       base.Dispose();
-      Reset();
+      Clear();
       pool.Free(this);
     }
Index: /branches/PushGP/HeuristicLab.PushGP/HeuristicLab.Problems.ProgramSynthesis/Push/Interpreter/PushInterpreter.cs
===================================================================
--- /branches/PushGP/HeuristicLab.PushGP/HeuristicLab.Problems.ProgramSynthesis/Push/Interpreter/PushInterpreter.cs	(revision 15031)
+++ /branches/PushGP/HeuristicLab.PushGP/HeuristicLab.Problems.ProgramSynthesis/Push/Interpreter/PushInterpreter.cs	(revision 15032)
@@ -16,4 +16,5 @@
   public class PushInterpreter : IInternalPushInterpreter, IDisposable {
     private Task currentTask;
+    private Expression currentProgram;
 
     public PushInterpreter(IReadOnlyPushConfiguration config = null, IRandom random = null, InterpreterPoolContainer poolContainer = null) {
@@ -23,52 +24,16 @@
       // setting the capacity of the Stacks to max points ensures that there will be enough memory at runtime
       ExecStack = new PushStack<Expression>(Configuration.MaxPointsInProgram);
-
-      CodeStack = new PushStack<Expression> {
-        IsEnabled = Configuration.EnabledStacks[StackTypes.Code]
-      };
-
-      NameStack = new PushStack<string> {
-        IsEnabled = Configuration.EnabledStacks[StackTypes.Code]
-      };
-
-      BooleanStack = new PushStack<bool> {
-        IsEnabled = Configuration.EnabledStacks[StackTypes.Boolean]
-      };
-
-      IntegerStack = new PushStack<long> {
-        IsEnabled = Configuration.EnabledStacks[StackTypes.Integer]
-      };
-
-      FloatStack = new PushStack<double> {
-        IsEnabled = Configuration.EnabledStacks[StackTypes.Float]
-      };
-
-      CharStack = new PushStack<char> {
-        IsEnabled = Configuration.EnabledStacks[StackTypes.Char]
-      };
-
-      StringStack = new PushStack<string> {
-        IsEnabled = Configuration.EnabledStacks[StackTypes.String]
-      };
-
-      IntegerVectorStack = new PushStack<IReadOnlyList<long>> {
-        IsEnabled = Configuration.EnabledStacks[StackTypes.IntegerVector]
-      };
-
-      FloatVectorStack = new PushStack<IReadOnlyList<double>> {
-        IsEnabled = Configuration.EnabledStacks[StackTypes.FloatVector]
-      };
-
-      BooleanVectorStack = new PushStack<IReadOnlyList<bool>> {
-        IsEnabled = Configuration.EnabledStacks[StackTypes.BooleanVector]
-      };
-
-      StringVectorStack = new PushStack<IReadOnlyList<string>> {
-        IsEnabled = Configuration.EnabledStacks[StackTypes.StringVector]
-      };
-
-      PrintStack = new PushStack<string> {
-        IsEnabled = Configuration.EnabledStacks[StackTypes.Print]
-      };
+      CodeStack = new PushStack<Expression>();
+      NameStack = new PushStack<string>();
+      BooleanStack = new PushStack<bool>();
+      IntegerStack = new PushStack<long>();
+      FloatStack = new PushStack<double>();
+      CharStack = new PushStack<char>();
+      StringStack = new PushStack<string>();
+      IntegerVectorStack = new PushStack<IReadOnlyList<long>>();
+      FloatVectorStack = new PushStack<IReadOnlyList<double>>();
+      BooleanVectorStack = new PushStack<IReadOnlyList<bool>>();
+      StringVectorStack = new PushStack<IReadOnlyList<string>>();
+      PrintStack = new PushStack<string>();
 
       Stacks = new Dictionary<StackTypes, IPushStack> {
@@ -90,4 +55,6 @@
       CustomExpressions = new Dictionary<string, Expression>();
       PoolContainer = poolContainer ?? new InterpreterPoolContainer();
+
+      ConfigureStacks();
     }
 
@@ -187,4 +154,5 @@
     public void Run(Expression expression, bool stepwise = false) {
       IsPaused = stepwise;
+      currentProgram = expression;
 
       /* Push top expression so the loop is able to enter
@@ -267,10 +235,20 @@
     public void Reset() {
       ExecCounter = 0;
-
       IsAborted = false;
       IsPaused = false;
       currentTask = null;
+      currentProgram = null;
 
       Clear();
+      ConfigureStacks();
+    }
+
+    private void ConfigureStacks() {
+      foreach (var pair in this.Stacks) {
+        pair.Value.IsEnabled = Configuration.IsStackEnabled(pair.Key);
+      }
+
+      // exec stack must always be enabled
+      this.ExecStack.IsEnabled = true;
     }
 
@@ -288,6 +266,5 @@
     private void Run() {
       // if no stack which is modifies the exec stack is enabled, unroll loop due to performance reasons
-      if (!Configuration.EnabledStacks[StackTypes.Exec] &&
-          !Configuration.EnabledStacks[StackTypes.Code]) {
+      if (!Configuration.IsStackEnabled(StackTypes.Exec)) {
         while (CanRun(10))
           DoTenSteps();
Index: /branches/PushGP/HeuristicLab.PushGP/HeuristicLab.Problems.ProgramSynthesis/Push/Interpreter/PushInterpreterPool.cs
===================================================================
--- /branches/PushGP/HeuristicLab.PushGP/HeuristicLab.Problems.ProgramSynthesis/Push/Interpreter/PushInterpreterPool.cs	(revision 15031)
+++ /branches/PushGP/HeuristicLab.PushGP/HeuristicLab.Problems.ProgramSynthesis/Push/Interpreter/PushInterpreterPool.cs	(revision 15032)
@@ -14,5 +14,5 @@
 
     public PushInterpreterPool(IReadOnlyPushConfiguration config = null)
-      : this(Environment.ProcessorCount * 2, 1024, null, config) {
+      : this(Environment.ProcessorCount * 4, 1024, null, config) {
     }
 
@@ -34,4 +34,5 @@
       var interpreter = pool.Allocate();
       interpreter.Random = random ?? new MersenneTwister();
+      interpreter.Reset();
 
       return interpreter;
Index: /branches/PushGP/HeuristicLab.PushGP/HeuristicLab.Problems.ProgramSynthesis/Push/Problem/BenchmarkSuite/BenchmarkSuitePushSolutionView.cs
===================================================================
--- /branches/PushGP/HeuristicLab.PushGP/HeuristicLab.Problems.ProgramSynthesis/Push/Problem/BenchmarkSuite/BenchmarkSuitePushSolutionView.cs	(revision 15031)
+++ /branches/PushGP/HeuristicLab.PushGP/HeuristicLab.Problems.ProgramSynthesis/Push/Problem/BenchmarkSuite/BenchmarkSuitePushSolutionView.cs	(revision 15032)
@@ -120,5 +120,6 @@
           AutoSizeMode = DataGridViewAutoSizeColumnMode.Fill,
           CellTemplate = cellTemplate,
-          DefaultCellStyle = { Alignment = DataGridViewContentAlignment.MiddleRight }
+          DefaultCellStyle = { Alignment = DataGridViewContentAlignment.MiddleRight },
+          SortMode = DataGridViewColumnSortMode.Automatic
         };
 
@@ -133,4 +134,5 @@
           AutoSizeMode = DataGridViewAutoSizeColumnMode.Fill,
           CellTemplate = cellTemplate,
+          SortMode = DataGridViewColumnSortMode.Automatic
         };
 
@@ -138,5 +140,6 @@
           HeaderText = string.Format(OutputHeaderStringFormat, i + 1, headerTypeName),
           AutoSizeMode = DataGridViewAutoSizeColumnMode.Fill,
-          CellTemplate = cellTemplate
+          CellTemplate = cellTemplate,
+          SortMode = DataGridViewColumnSortMode.Automatic
         };
 
@@ -151,5 +154,6 @@
         HeaderText = AbsoluteDiffHeaderText,
         AutoSizeMode = DataGridViewAutoSizeColumnMode.ColumnHeader,
-        CellTemplate = cellTemplate
+        CellTemplate = cellTemplate,
+        SortMode = DataGridViewColumnSortMode.Automatic
       };
 
@@ -158,4 +162,5 @@
         AutoSizeMode = DataGridViewAutoSizeColumnMode.ColumnHeader,
         CellTemplate = cellTemplate,
+        SortMode = DataGridViewColumnSortMode.Automatic
       };
 
@@ -185,5 +190,5 @@
             var type = data.InputArgumentTypes[j];
             var offset = inputArgumentCountDict[type];
-            row.Cells[j].Value = ViewHelper.StringifyInput(type, offset, example, Separator);
+            row.Cells[j].Value = ViewHelper.StringifyInput(type, offset, Content.Config.FloatStringFormat, example, Separator);
             inputArgumentCountDict[type]++;
           }
@@ -193,5 +198,5 @@
             var type = data.OutputArgumentTypes[j];
             var offset = outputArgumentCountDict[type];
-            row.Cells[data.InputArgumentTypes.Length + j * 2].Value = ViewHelper.StringifyOutput(type, offset, example, Separator);
+            row.Cells[data.InputArgumentTypes.Length + j * 2].Value = ViewHelper.StringifyOutput(type, offset, Content.Config.FloatStringFormat, example, Separator);
             row.Cells[data.InputArgumentTypes.Length + j * 2 + 1].Value = StringifyResult(type, offset, pushInterpreter, example, Separator);
             outputArgumentCountDict[type]++;
Index: /branches/PushGP/HeuristicLab.PushGP/HeuristicLab.Problems.ProgramSynthesis/Push/Problem/BenchmarkSuite/PushBenchmarkSuiteProblem.cs
===================================================================
--- /branches/PushGP/HeuristicLab.PushGP/HeuristicLab.Problems.ProgramSynthesis/Push/Problem/BenchmarkSuite/PushBenchmarkSuiteProblem.cs	(revision 15031)
+++ /branches/PushGP/HeuristicLab.PushGP/HeuristicLab.Problems.ProgramSynthesis/Push/Problem/BenchmarkSuite/PushBenchmarkSuiteProblem.cs	(revision 15032)
@@ -5,4 +5,5 @@
 
   using HeuristicLab.BenchmarkSuite;
+  using HeuristicLab.BenchmarkSuite.Problems;
   using HeuristicLab.Problems.ProgramSynthesis.Push.Expressions;
 
@@ -18,4 +19,9 @@
       Parameters.Add(PushEvaluator.DataParameter);
       Parameters.Add(PushEvaluator.DataBoundsParameter);
+
+      if (PushEvaluator.Data == null) {
+        var defaultProblem = new NumberIO();
+        Load(defaultProblem.CreateProblemData());
+      }
     }
 
Index: /branches/PushGP/HeuristicLab.PushGP/HeuristicLab.Problems.ProgramSynthesis/Push/Problem/IndividualMapper.cs
===================================================================
--- /branches/PushGP/HeuristicLab.PushGP/HeuristicLab.Problems.ProgramSynthesis/Push/Problem/IndividualMapper.cs	(revision 15031)
+++ /branches/PushGP/HeuristicLab.PushGP/HeuristicLab.Problems.ProgramSynthesis/Push/Problem/IndividualMapper.cs	(revision 15032)
@@ -69,20 +69,22 @@
 
         var expressionType = expression.GetType();
-        close += random.NextBiased(0, config.MaxParenthesesClose, config.ParenthesesCloseBiasLevel);
 
+        if (config.ParenthesesCloseBiasLevel > 0) {
+          close += random.NextBiased(0, config.MaxParenthesesClose, config.ParenthesesCloseBiasLevel);
 
-        // check if expression requires additional blocks
-        if (ExpressionTable.TypeToAttributeTable.ContainsKey(expressionType)) {
-          var attr = ExpressionTable.TypeToAttributeTable[expressionType];
+          // check if expression requires additional blocks
+          if (ExpressionTable.TypeToAttributeTable.ContainsKey(expressionType)) {
+            var attr = ExpressionTable.TypeToAttributeTable[expressionType];
 
-          for (var blockIdx = 0u; blockIdx < attr.ExecIn && currentIndex < vector.Length; blockIdx++) {
-            if (close != 0) {
-              close--;
-              expressions.Add(PushProgram.Empty);
-            } else {
-              currentIndex++;
-              var subProgram = FromPlush(vector, ref currentIndex, ref close, depth + 1, config, random);
-              var subExpression = subProgram.Count == 1 ? subProgram.Expressions[0] : subProgram;
-              expressions.Add(subExpression);
+            for (var blockIdx = 0u; blockIdx < attr.ExecIn && currentIndex < vector.Length; blockIdx++) {
+              if (close != 0) {
+                close--;
+                expressions.Add(PushProgram.Empty);
+              } else {
+                currentIndex++;
+                var subProgram = FromPlush(vector, ref currentIndex, ref close, depth + 1, config, random);
+                var subExpression = subProgram.Count == 1 ? subProgram.Expressions[0] : subProgram;
+                expressions.Add(subExpression);
+              }
             }
           }
Index: /branches/PushGP/HeuristicLab.PushGP/HeuristicLab.Problems.ProgramSynthesis/Push/Problem/PushProblem.cs
===================================================================
--- /branches/PushGP/HeuristicLab.PushGP/HeuristicLab.Problems.ProgramSynthesis/Push/Problem/PushProblem.cs	(revision 15031)
+++ /branches/PushGP/HeuristicLab.PushGP/HeuristicLab.Problems.ProgramSynthesis/Push/Problem/PushProblem.cs	(revision 15032)
@@ -10,4 +10,5 @@
   using HeuristicLab.Data;
   using HeuristicLab.Encodings.IntegerVectorEncoding;
+  using HeuristicLab.Problems.ProgramSynthesis.Push.Analyzer;
   using HeuristicLab.Problems.ProgramSynthesis.Push.Expressions;
   using HeuristicLab.Problems.ProgramSynthesis.Push.Problem.BenchmarkSuite;
@@ -40,4 +41,5 @@
       InitParameters();
       InitEncoding();
+      InitOperators();
     }
 
@@ -85,4 +87,5 @@
     private const string InitProgramLengthParameterName = "InitProgramLength";
     private const string InitProgramLengthParameterDescription = "This is the initial size of a push program.";
+    private const string PushConfigurationParameterName = "PushConfiguration";
 
     public const string CasesScopeParameterName = "CaseQualities";
@@ -96,4 +99,9 @@
       }
 
+      if (!Parameters.ContainsKey(PushConfigurationParameterName))
+        Parameters.Add(new ValueParameter<IReadOnlyPushConfiguration>(PushConfigurationParameterName, config) {
+          Hidden = true
+        });
+
       if (!Parameters.ContainsKey(InitProgramLengthParameterName)) {
         Parameters.Add(new FixedValueParameter<IntValue>(
@@ -123,4 +131,8 @@
       Encoding.Bounds[0, 1] = config.EnabledExpressions.Count;
       Encoding.Length = config.MaxPointsInProgram;
+    }
+
+    private void InitOperators() {
+      Operators.Add(new PushExpressionFrequencyAnalyzer());
     }
 
Index: /branches/PushGP/HeuristicLab.PushGP/HeuristicLab.Problems.ProgramSynthesis/Push/Stack/IPushStackBase.cs
===================================================================
--- /branches/PushGP/HeuristicLab.PushGP/HeuristicLab.Problems.ProgramSynthesis/Push/Stack/IPushStackBase.cs	(revision 15031)
+++ /branches/PushGP/HeuristicLab.PushGP/HeuristicLab.Problems.ProgramSynthesis/Push/Stack/IPushStackBase.cs	(revision 15032)
@@ -5,5 +5,5 @@
   public interface IPushStack : IEnumerable {
     bool IsEmpty { get; }
-    bool IsEnabled { get; }
+    bool IsEnabled { get; set; }
     int Count { get; }
 
Index: /branches/PushGP/HeuristicLab.PushGP/HeuristicLab.Problems.ProgramSynthesis/Push/Stack/StackTypes.cs
===================================================================
--- /branches/PushGP/HeuristicLab.PushGP/HeuristicLab.Problems.ProgramSynthesis/Push/Stack/StackTypes.cs	(revision 15031)
+++ /branches/PushGP/HeuristicLab.PushGP/HeuristicLab.Problems.ProgramSynthesis/Push/Stack/StackTypes.cs	(revision 15032)
@@ -4,5 +4,5 @@
   // Be aware that it is assumed that this values are equal to HeuristicLab.BenchmarkSuite.DataTypes
   [Flags]
-  public enum StackTypes : ushort {
+  public enum StackTypes {
     None = 0x01, // Required to specify expression dependencies
     Integer = 0x02,
Index: /branches/PushGP/HeuristicLab.PushGP/HeuristicLab.Problems.ProgramSynthesis/Push/Views/ExpressionSelectionView.Designer.cs
===================================================================
--- /branches/PushGP/HeuristicLab.PushGP/HeuristicLab.Problems.ProgramSynthesis/Push/Views/ExpressionSelectionView.Designer.cs	(revision 15031)
+++ /branches/PushGP/HeuristicLab.PushGP/HeuristicLab.Problems.ProgramSynthesis/Push/Views/ExpressionSelectionView.Designer.cs	(revision 15032)
@@ -46,4 +46,5 @@
       this.expressionsTreeView.Location = new System.Drawing.Point(3, 16);
       this.expressionsTreeView.Name = "expressionsTreeView";
+      this.expressionsTreeView.ShowNodeToolTips = true;
       this.expressionsTreeView.Size = new System.Drawing.Size(321, 436);
       this.expressionsTreeView.TabIndex = 0;
Index: /branches/PushGP/HeuristicLab.PushGP/HeuristicLab.Problems.ProgramSynthesis/Push/Views/ExpressionSelectionView.cs
===================================================================
--- /branches/PushGP/HeuristicLab.PushGP/HeuristicLab.Problems.ProgramSynthesis/Push/Views/ExpressionSelectionView.cs	(revision 15031)
+++ /branches/PushGP/HeuristicLab.PushGP/HeuristicLab.Problems.ProgramSynthesis/Push/Views/ExpressionSelectionView.cs	(revision 15032)
@@ -5,5 +5,4 @@
 
 namespace HeuristicLab.Problems.ProgramSynthesis.Push.Views {
-  using System;
   using System.Collections.Generic;
   using System.Linq;
@@ -11,4 +10,5 @@
 
   using HeuristicLab.Problems.ProgramSynthesis.Push.Configuration;
+  using HeuristicLab.Problems.ProgramSynthesis.Push.Extensions;
 
   using Stack;
@@ -52,5 +52,5 @@
 
       if (e.Node.Parent == null) {
-        Content.SetStack(stackType, e.Node.Checked, true, false);
+        Content.SetStack(stackType, e.Node.Checked);
         SetStackNodeText(e.Node);
         foreach (var subNode in e.Node.Nodes.OfType<TreeNode>().Where(n => n.Checked != e.Node.Checked))
@@ -62,6 +62,5 @@
         // enable/disable stack if no or at least one expression is enabled
         if ((e.Node.Checked && !e.Node.Parent.Checked) ||
-            (!e.Node.Checked && !e.Node.Parent.Nodes.OfType<TreeNode>().Any(n => n.Checked))) {
-          Content.SetStack(stackType, e.Node.Checked, false, false);
+            (!e.Node.Checked && e.Node.Parent.Nodes.OfType<TreeNode>().All(n => !n.Checked))) {
           e.Node.Parent.Checked = e.Node.Checked;
         }
@@ -90,9 +89,12 @@
       expressionsTreeView.Nodes.Clear();
 
-      var treeNodes = GetTreeNodes(Content.EnabledExpressions).ToArray();
+      var treeNodes = GetTreeNodes(Content.EnabledExpressions)
+        .OrderBy(x => x.Text)
+        .ToArray();
+
       expressionsTreeView.Nodes.AddRange(treeNodes);
     }
 
-    private IEnumerable<TreeNode> GetTreeNodes(IList<string> enabledExpressions) {
+    private IEnumerable<TreeNode> GetTreeNodes(IReadOnlyList<string> enabledExpressions) {
       foreach (var stackType in ExpressionTable.StackTypeToNamesTable.Keys) {
         var stackTreeNode = new TreeNode {
@@ -107,4 +109,10 @@
 
         var expressionNodes = stackExpressions
+          .Where(name => {
+            var type = ExpressionTable.NameToTypeTable[name];
+            var attribute = ExpressionTable.TypeToAttributeTable[type];
+
+            return !attribute.IsHidden;
+          })
           .OrderBy(name => name)
           .Select(name => new TreeNode {
@@ -113,4 +121,11 @@
             Checked = enabledStackExpressions.Contains(name),
           }).ToArray();
+
+        foreach (var node in expressionNodes) {
+          var type = ExpressionTable.NameToTypeTable[node.Text];
+          var attribute = ExpressionTable.TypeToAttributeTable[type];
+
+          node.ToolTipText = attribute.Description;
+        }
 
         stackTreeNode.Nodes.AddRange(expressionNodes);
@@ -121,13 +136,14 @@
 
     private void SetStackNodeText(TreeNode node) {
-      var stackType = (StackTypes)node.Tag;
-      var stackExpressions = ExpressionTable.StackTypeToNamesTable[stackType];
+      var stackTypes = (StackTypes)node.Tag;
+      var stackExpressions = ExpressionTable.StackTypeToNamesTable[stackTypes];
       var enabledStackExpressions = Content.EnabledExpressions.Intersect(stackExpressions).ToList();
+      var stackNames = string.Join(", ", stackTypes.ToValues().Select(type => type.ToString()).OrderBy(x => x));
 
       node.Text = string.Format(
                 "{0} ({1}/{2})",
-                Enum.GetName(typeof(StackTypes), stackType),
+                stackNames,
                 enabledStackExpressions.Count,
-                ExpressionTable.StackTypeToNamesTable[stackType].Count);
+                stackExpressions.Count);
     }
   }
Index: /branches/PushGP/HeuristicLab.PushGP/HeuristicLab.Problems.ProgramSynthesis/Push/Views/ExpressionSelectionView.resx
===================================================================
--- /branches/PushGP/HeuristicLab.PushGP/HeuristicLab.Problems.ProgramSynthesis/Push/Views/ExpressionSelectionView.resx	(revision 15031)
+++ /branches/PushGP/HeuristicLab.PushGP/HeuristicLab.Problems.ProgramSynthesis/Push/Views/ExpressionSelectionView.resx	(revision 15032)
@@ -1,16 +1,16 @@
 ﻿<?xml version="1.0" encoding="utf-8"?>
 <root>
-  <!--
-    Microsoft ResX Schema
-
+  <!-- 
+    Microsoft ResX Schema 
+    
     Version 2.0
-
-    The primary goals of this format is to allow a simple XML format
-    that is mostly human readable. The generation and parsing of the
-    various data types are done through the TypeConverter classes
+    
+    The primary goals of this format is to allow a simple XML format 
+    that is mostly human readable. The generation and parsing of the 
+    various data types are done through the TypeConverter classes 
     associated with the data types.
-
+    
     Example:
-
+    
     ... ado.net/XML headers & schema ...
     <resheader name="resmimetype">text/microsoft-resx</resheader>
@@ -27,34 +27,34 @@
         <comment>This is a comment</comment>
     </data>
-
-    There are any number of "resheader" rows that contain simple
+                
+    There are any number of "resheader" rows that contain simple 
     name/value pairs.
-
-    Each data row contains a name, and value. The row also contains a
-    type or mimetype. Type corresponds to a .NET class that support
-    text/value conversion through the TypeConverter architecture.
-    Classes that don't support this are serialized and stored with the
+    
+    Each data row contains a name, and value. The row also contains a 
+    type or mimetype. Type corresponds to a .NET class that support 
+    text/value conversion through the TypeConverter architecture. 
+    Classes that don't support this are serialized and stored with the 
     mimetype set.
-
-    The mimetype is used for serialized objects, and tells the
-    ResXResourceReader how to depersist the object. This is currently not
+    
+    The mimetype is used for serialized objects, and tells the 
+    ResXResourceReader how to depersist the object. This is currently not 
     extensible. For a given mimetype the value must be set accordingly:
-
-    Note - application/x-microsoft.net.object.binary.base64 is the format
-    that the ResXResourceWriter will generate, however the reader can
+    
+    Note - application/x-microsoft.net.object.binary.base64 is the format 
+    that the ResXResourceWriter will generate, however the reader can 
     read any of the formats listed below.
-
+    
     mimetype: application/x-microsoft.net.object.binary.base64
-    value   : The object must be serialized with
+    value   : The object must be serialized with 
             : System.Runtime.Serialization.Formatters.Binary.BinaryFormatter
             : and then encoded with base64 encoding.
-
+    
     mimetype: application/x-microsoft.net.object.soap.base64
-    value   : The object must be serialized with
+    value   : The object must be serialized with 
             : System.Runtime.Serialization.Formatters.Soap.SoapFormatter
             : and then encoded with base64 encoding.
 
     mimetype: application/x-microsoft.net.object.bytearray.base64
-    value   : The object must be serialized into a byte array
+    value   : The object must be serialized into a byte array 
             : using a System.ComponentModel.TypeConverter
             : and then encoded with base64 encoding.
Index: /branches/PushGP/HeuristicLab.PushGP/HeuristicLab.Problems.ProgramSynthesis/Push/Views/PushDebuggerView.cs
===================================================================
--- /branches/PushGP/HeuristicLab.PushGP/HeuristicLab.Problems.ProgramSynthesis/Push/Views/PushDebuggerView.cs	(revision 15031)
+++ /branches/PushGP/HeuristicLab.PushGP/HeuristicLab.Problems.ProgramSynthesis/Push/Views/PushDebuggerView.cs	(revision 15032)
@@ -183,17 +183,16 @@
 
       foreach (StackTypes stackType in Enum.GetValues(typeof(StackTypes))) {
-        if (stackType != StackTypes.Exec &&
-            ExpressionTable.GetExpressionsByStackTypes(stackType).Intersect(config.EnabledExpressions).Any()) {
-
-          switch (stackType) {
-            case StackTypes.Code:
-              var treeView = CreatePushProgramTreeView(stackType);
-              debugPushProgramDict.Add(stackType, treeView);
-              break;
-            default:
-              var list = CreateDebugList(stackType);
-              debugListDict.Add(stackType, list);
-              break;
-          }
+        if (stackType == StackTypes.Exec || !config.IsStackEnabled(stackType))
+          continue;
+
+        switch (stackType) {
+          case StackTypes.Code:
+            var treeView = CreatePushProgramTreeView(stackType);
+            debugPushProgramDict.Add(stackType, treeView);
+            break;
+          default:
+            var list = CreateDebugList(stackType);
+            debugListDict.Add(stackType, list);
+            break;
         }
       }
Index: /branches/PushGP/HeuristicLab.PushGP/HeuristicLab.Problems.ProgramSynthesis/Push/Views/PushProgramTreeView.cs
===================================================================
--- /branches/PushGP/HeuristicLab.PushGP/HeuristicLab.Problems.ProgramSynthesis/Push/Views/PushProgramTreeView.cs	(revision 15031)
+++ /branches/PushGP/HeuristicLab.PushGP/HeuristicLab.Problems.ProgramSynthesis/Push/Views/PushProgramTreeView.cs	(revision 15032)
@@ -13,4 +13,6 @@
     public PushProgramTreeView() {
       InitializeComponent();
+
+      ShowNodeToolTips = true;
     }
 
@@ -28,5 +30,5 @@
       var node = new TreeNode {
         Text = GetNodeText(expression),
-        Tag = expression
+        Tag = expression,
       };
 
@@ -36,4 +38,9 @@
 
         node.Nodes.AddRange(subNodes);
+      } else {
+        var type = expression.GetType();
+        var attribute = ExpressionTable.TypeToAttributeTable[type];
+
+        node.ToolTipText = attribute.Description;
       }
 
