Index: branches/PushGP/HeuristicLab.PushGP/FeatureTests/Program.cs
===================================================================
--- branches/PushGP/HeuristicLab.PushGP/FeatureTests/Program.cs	(revision 14903)
+++ branches/PushGP/HeuristicLab.PushGP/FeatureTests/Program.cs	(revision 14905)
@@ -50,7 +50,83 @@
       //FlagsTest();
       //TestExpressionDependencies();
+      //TestSplitLogic();
 
       Console.WriteLine("\nPress any key to continue...");
       Console.ReadKey(false);
+    }
+
+    private static void TestSplitLogic() {
+      var sw = new Stopwatch();
+      var iMax = 100000000u;
+      var repeats = 10;
+      var or = new BooleanOrExpression();
+      var and = new BooleanAndExpression();
+      var ors = new Expression[iMax];
+      var ands = new Expression[iMax];
+      var booleans = new bool[iMax];
+
+      for (var i = 0u; i < iMax; i++) {
+        ors[i] = or;
+        ands[i] = and;
+        booleans[i] = i % 2 == 0;
+      }
+
+      var orsProgram = new PushProgram(ors);
+      var andsProgram = new PushProgram(ands);
+
+      using (var interpreter = new PushInterpreter()) {
+        for (var i = 0u; i < repeats; i++) {
+          interpreter.BooleanStack.Push(booleans);
+
+          sw.Start();
+          interpreter.Run(orsProgram);
+          sw.Stop();
+          interpreter.Reset();
+        }
+
+        Console.WriteLine("ors:\t" + sw.ElapsedTicks / repeats + " - " + sw.ElapsedMilliseconds);
+
+        sw.Reset();
+        interpreter.Reset();
+
+        for (var i = 0u; i < repeats; i++) {
+          interpreter.BooleanStack.Push(booleans);
+
+          sw.Start();
+          interpreter.Run(andsProgram);
+          sw.Stop();
+          interpreter.Reset();
+        }
+
+        Console.WriteLine("ands:\t" + sw.ElapsedTicks / repeats + " - " + sw.ElapsedMilliseconds);
+
+        sw.Reset();
+        interpreter.Reset();
+
+        for (var i = 0u; i < repeats; i++) {
+          interpreter.BooleanStack.Push(booleans);
+
+          sw.Start();
+          interpreter.Run(orsProgram);
+          sw.Stop();
+          interpreter.Reset();
+        }
+
+        Console.WriteLine("ors:\t" + sw.ElapsedTicks / repeats + " - " + sw.ElapsedMilliseconds);
+
+        sw.Reset();
+        interpreter.Reset();
+
+        for (var i = 0u; i < repeats; i++) {
+          interpreter.BooleanStack.Push(booleans);
+
+          sw.Start();
+          interpreter.Run(andsProgram);
+          sw.Stop();
+          interpreter.Reset();
+        }
+
+        Console.WriteLine("ands:\t" + sw.ElapsedTicks / repeats + " - " + sw.ElapsedMilliseconds);
+      }
     }
 
@@ -397,9 +473,20 @@
       };
 
-      config.DisableStack(StackTypes.Exec, true);
-      config.DisableStack(StackTypes.Code, true);
-      config.DisableStack(StackTypes.Float, true);
-
-      config.DisableExpression<ExecYExpression>();
+      config.DisableStack(StackTypes.Exec);
+      config.DisableStack(StackTypes.Code);
+      config.DisableStack(StackTypes.Float);
+
+      var errors = config.EnabledExpressions.Where(
+        name => {
+          var type = ExpressionTable.NameToTypeTable[name];
+          var attribute = ExpressionTable.TypeToAttributeTable[type];
+
+          return attribute.StackType == StackTypes.Exec
+              || attribute.AdditionalStackDependencies.HasFlag(StackTypes.Exec)
+              || attribute.StackType == StackTypes.Code
+              || attribute.AdditionalStackDependencies.HasFlag(StackTypes.Code)
+              || attribute.StackType == StackTypes.Float
+              || attribute.AdditionalStackDependencies.HasFlag(StackTypes.Float);
+        });
 
       var pool = new PushInterpreterPool(config);
Index: branches/PushGP/HeuristicLab.PushGP/HeuristicLab.Problem.ProgramSynthesis.BenchmarkSuite/Problems/CompareStringLengths.cs
===================================================================
--- branches/PushGP/HeuristicLab.PushGP/HeuristicLab.Problem.ProgramSynthesis.BenchmarkSuite/Problems/CompareStringLengths.cs	(revision 14903)
+++ branches/PushGP/HeuristicLab.PushGP/HeuristicLab.Problem.ProgramSynthesis.BenchmarkSuite/Problems/CompareStringLengths.cs	(revision 14905)
@@ -29,10 +29,9 @@
         ErcOptions = {
           ErcProbability = 0.05,
-          BooleanErcOptions = new BooleanErcOptions {
+          BooleanErcOptions = new BooleanErcOptions(
             new BooleanRandomErcValue {
               AllowTrue = true,
               AllowFalse = true
-            }
-          }
+            })
         }
       };
Index: branches/PushGP/HeuristicLab.PushGP/HeuristicLab.Problems.ProgramSynthesis.Base/Erc/Boolean/BooleanRandomErcValue.cs
===================================================================
--- branches/PushGP/HeuristicLab.PushGP/HeuristicLab.Problems.ProgramSynthesis.Base/Erc/Boolean/BooleanRandomErcValue.cs	(revision 14903)
+++ branches/PushGP/HeuristicLab.PushGP/HeuristicLab.Problems.ProgramSynthesis.Base/Erc/Boolean/BooleanRandomErcValue.cs	(revision 14905)
@@ -16,5 +16,5 @@
     public BooleanRandomErcValue() : this(false, true, true) { }
 
-    public BooleanRandomErcValue(bool isEnabled, bool allowTrue, bool allowFalse) {
+    public BooleanRandomErcValue(bool isEnabled, bool allowTrue, bool allowFalse, double weight = 1d) : base(isEnabled, weight) {
       if (!allowTrue && allowFalse) {
         throw new InvalidOperationException("true and false values are disabled");
@@ -22,5 +22,4 @@
 
       Name = "Boolean random";
-      IsEnabled = isEnabled;
       Parameters.Add(new FixedValueParameter<BoolValue>(AllowTrueParameterName, new BoolValue(allowTrue)));
       Parameters.Add(new FixedValueParameter<BoolValue>(AllowFalseParameterName, new BoolValue(allowFalse)));
Index: branches/PushGP/HeuristicLab.PushGP/HeuristicLab.Problems.ProgramSynthesis.Base/Erc/Char/CharErcOptions.cs
===================================================================
--- branches/PushGP/HeuristicLab.PushGP/HeuristicLab.Problems.ProgramSynthesis.Base/Erc/Char/CharErcOptions.cs	(revision 14903)
+++ branches/PushGP/HeuristicLab.PushGP/HeuristicLab.Problems.ProgramSynthesis.Base/Erc/Char/CharErcOptions.cs	(revision 14905)
@@ -3,13 +3,14 @@
 
   using Common;
+  using Core;
   using Persistence.Default.CompositeSerializers.Storable;
 
   [StorableClass]
   public class CharErcOptions : ErcOptionConvertible<char, int> {
-    public CharErcOptions() : base(Convert.ToChar) { }
+    public CharErcOptions() { }
 
     public CharErcOptions(params IWeightedErcValueItem<int>[] values) : this(true, values) { }
 
-    public CharErcOptions(bool isEnabled, params IWeightedErcValueItem<int>[] values) : base(Convert.ToChar, isEnabled, values) { }
+    public CharErcOptions(bool isEnabled, params IWeightedErcValueItem<int>[] values) : base(isEnabled, values) { }
 
     [StorableConstructor]
@@ -21,4 +22,8 @@
       return new CharErcOptions(this, cloner);
     }
+
+    public override char GetErcValue(IRandom random) {
+      return GetErcValue(random, Convert.ToChar);
+    }
   }
 }
Index: branches/PushGP/HeuristicLab.PushGP/HeuristicLab.Problems.ProgramSynthesis.Base/Erc/ConstantsErcValue.cs
===================================================================
--- branches/PushGP/HeuristicLab.PushGP/HeuristicLab.Problems.ProgramSynthesis.Base/Erc/ConstantsErcValue.cs	(revision 14903)
+++ branches/PushGP/HeuristicLab.PushGP/HeuristicLab.Problems.ProgramSynthesis.Base/Erc/ConstantsErcValue.cs	(revision 14905)
@@ -12,19 +12,14 @@
 
     private const string ConstantsParameterName = "Constants";
-    private readonly TArray array; // perf opt: reduce parameter getter usage
 
-    protected ConstantsWeightedErcValue(TArray array) {
-      this.array = array;
+    protected ConstantsWeightedErcValue(TArray array) : this(true, array) { }
+    protected ConstantsWeightedErcValue(bool isEnabled, TArray array, double weight = 1d) : base(isEnabled, weight) {
       Parameters.Add(new FixedValueParameter<TArray>(ConstantsParameterName, array));
     }
 
     [StorableConstructor]
-    protected ConstantsWeightedErcValue(bool deserializing)
-      : base(deserializing) {
-      array = ConstantsParameter.Value;
-    }
+    protected ConstantsWeightedErcValue(bool deserializing) : base(deserializing) { }
 
-    protected ConstantsWeightedErcValue(ConstantsWeightedErcValue<T, TArray> origin, Cloner cloner) : base(origin, cloner) {
-    }
+    protected ConstantsWeightedErcValue(ConstantsWeightedErcValue<T, TArray> origin, Cloner cloner) : base(origin, cloner) { }
 
     public IValueParameter<TArray> ConstantsParameter
@@ -39,6 +34,8 @@
 
     public override T GetErcValue(IRandom random) {
-      var x = random.Next(array.Length);
-      return array[x];
+      if (Constants.Length == 0) return default(T);
+
+      var x = random.Next(Constants.Length);
+      return Constants[x];
     }
   }
Index: branches/PushGP/HeuristicLab.PushGP/HeuristicLab.Problems.ProgramSynthesis.Base/Erc/ErcOption.cs
===================================================================
--- branches/PushGP/HeuristicLab.PushGP/HeuristicLab.Problems.ProgramSynthesis.Base/Erc/ErcOption.cs	(revision 14903)
+++ branches/PushGP/HeuristicLab.PushGP/HeuristicLab.Problems.ProgramSynthesis.Base/Erc/ErcOption.cs	(revision 14905)
@@ -1,4 +1,5 @@
 ﻿namespace HeuristicLab.Problems.ProgramSynthesis.Base.Erc {
   using HeuristicLab.Common;
+  using HeuristicLab.Core;
   using HeuristicLab.Persistence.Default.CompositeSerializers.Storable;
 
@@ -8,5 +9,5 @@
 
     protected ErcOption(bool isEnabled, params IWeightedErcValueItem<T>[] values)
-        : base(x => x, isEnabled, values) { }
+        : base(isEnabled, values) { }
 
     [StorableConstructor]
@@ -18,4 +19,8 @@
         : base(origin, cloner) {
     }
+
+    public override T GetErcValue(IRandom random) {
+      return GetErcValue(random, x => x);
+    }
   }
 }
Index: branches/PushGP/HeuristicLab.PushGP/HeuristicLab.Problems.ProgramSynthesis.Base/Erc/ErcOptionConvertible.cs
===================================================================
--- branches/PushGP/HeuristicLab.PushGP/HeuristicLab.Problems.ProgramSynthesis.Base/Erc/ErcOptionConvertible.cs	(revision 14903)
+++ branches/PushGP/HeuristicLab.PushGP/HeuristicLab.Problems.ProgramSynthesis.Base/Erc/ErcOptionConvertible.cs	(revision 14905)
@@ -1,4 +1,6 @@
 ﻿namespace HeuristicLab.Problems.ProgramSynthesis.Base.Erc {
   using System;
+  using System.Collections.Generic;
+  using System.Linq;
 
   using HeuristicLab.Common;
@@ -8,13 +10,18 @@
 
   [StorableClass]
-  public abstract class ErcOptionConvertible<TValue, TValueItem> : ItemCollection<IWeightedErcValueItem<TValueItem>>, IErcValueItem<TValue> {
-    private readonly Converter<TValueItem, TValue> converter;
+  public abstract class ErcOptionConvertible<TValue, TValueItem> : CheckedItemCollection<IWeightedErcValueItem<TValueItem>>, IErcValueItem<TValue> {
+    [Storable]
+    protected bool isEnabled;
 
-    protected ErcOptionConvertible(Converter<TValueItem, TValue> converter) : this(converter, false) { }
+    public event EventHandler<bool> EnabledChanged;
 
-    protected ErcOptionConvertible(Converter<TValueItem, TValue> converter, bool isEnabled, params IWeightedErcValueItem<TValueItem>[] values) {
-      this.converter = converter;
-      IsEnabled = isEnabled;
-      AddRange(values);
+    protected ErcOptionConvertible() : this(false, new IWeightedErcValueItem<TValueItem>[0]) { }
+
+    protected ErcOptionConvertible(bool isEnabled, params IWeightedErcValueItem<TValueItem>[] values) : base(values) {
+      this.isEnabled = isEnabled;
+      SetEnabledChangedHandler(values);
+
+      foreach (var value in values)
+        SetItemCheckedState(value, value.IsEnabled);
     }
 
@@ -24,15 +31,68 @@
     }
 
+    [StorableHook(HookType.AfterDeserialization)]
+    // ReSharper disable once UnusedMember.Local
+    private void AfterDeserialization() {
+      SetEnabledChangedHandler(list);
+    }
+
     protected ErcOptionConvertible(ErcOptionConvertible<TValue, TValueItem> origin, Cloner cloner)
       : base(origin, cloner) {
+      IsEnabled = origin.IsEnabled;
     }
 
-    public bool IsEnabled { get; set; }
+    private void SetEnabledChangedHandler(IEnumerable<IWeightedErcValueItem<TValueItem>> values) {
+      foreach (var item in values)
+        item.EnabledChanged += ErcValueItemEnabledChanged;
+    }
 
+    protected override void OnItemsAdded(IEnumerable<IWeightedErcValueItem<TValueItem>> items) {
+      base.OnItemsAdded(items);
+      SetEnabledChangedHandler(items);
+    }
 
-    public TValue GetErcValue(IRandom random) {
+    protected override void OnItemsRemoved(IEnumerable<IWeightedErcValueItem<TValueItem>> items) {
+      base.OnItemsRemoved(items);
+
+      foreach (var item in items)
+        item.EnabledChanged -= ErcValueItemEnabledChanged;
+    }
+
+    private void ErcValueItemEnabledChanged(object sender, bool state) {
+      SetItemCheckedState((IWeightedErcValueItem<TValueItem>)sender, state);
+    }
+
+    protected override void OnCheckedItemsChanged(IEnumerable<IWeightedErcValueItem<TValueItem>> items) {
+      base.OnCheckedItemsChanged(items);
+
+      foreach (var item in items) {
+        item.IsEnabled = ItemChecked(item);
+      }
+    }
+
+    public bool IsEnabled
+    {
+      get { return isEnabled; }
+      set
+      {
+        if (value == isEnabled)
+          return;
+
+        isEnabled = value;
+
+        if (EnabledChanged != null)
+          EnabledChanged(this, value);
+      }
+    }
+
+    public abstract TValue GetErcValue(IRandom random);
+
+    protected TValue GetErcValue(IRandom random, Converter<TValueItem, TValue> converter) {
       if (Count == 0 || !IsEnabled) return default(TValue);
 
-      var ercValueItem = list.RandomWeightedOrDefault(random);
+      var ercValueItem = list
+        .Where(item => item.IsEnabled)
+        .RandomWeightedOrDefault(random);
+
       return ercValueItem == null
         ? default(TValue)
Index: branches/PushGP/HeuristicLab.PushGP/HeuristicLab.Problems.ProgramSynthesis.Base/Erc/ErcOptions.cs
===================================================================
--- branches/PushGP/HeuristicLab.PushGP/HeuristicLab.Problems.ProgramSynthesis.Base/Erc/ErcOptions.cs	(revision 14903)
+++ branches/PushGP/HeuristicLab.PushGP/HeuristicLab.Problems.ProgramSynthesis.Base/Erc/ErcOptions.cs	(revision 14905)
@@ -1,4 +1,6 @@
 ﻿namespace HeuristicLab.Problems.ProgramSynthesis.Base.Erc {
+  using System;
   using System.Collections.Generic;
+  using System.Linq;
 
   using Boolean;
@@ -29,23 +31,68 @@
     public const string StringVectorParameterName = "StringVector";
 
+    [Storable]
+    private readonly ReadOnlyCheckedItemCollection<IValueParameter> ercOptions;
+    [Storable]
+    private readonly NamedItemCollection<IValueParameter> ercOptionParameters;
+    private IDictionary<IValueParameter, EventHandler<bool>> ercOptionEnabledChangedHandler;
+
     public ErcOptions() {
       Name = "ERC Options";
 
       Parameters.Add(new FixedValueParameter<PercentValue>(ProbabilityParameterName));
-      Parameters.Add(new ValueParameter<IntegerErcOptions>(IntegerParameterName));
-      Parameters.Add(new ValueParameter<FloatErcOptions>(FloatParameterName));
-      Parameters.Add(new ValueParameter<BooleanErcOptions>(BooleanParameterName));
-      Parameters.Add(new ValueParameter<StringErcOptions>(StringParameterName));
-      Parameters.Add(new ValueParameter<CharErcOptions>(CharParameterName));
-      Parameters.Add(new ValueParameter<StringErcOptions>(NameParameterName));
-      Parameters.Add(new ValueParameter<IntegerVectorErcOptions>(IntegerVectorParameterName));
-      Parameters.Add(new ValueParameter<FloatVectorErcOptions>(FloatVectorParameterName));
-      Parameters.Add(new ValueParameter<StringVectorErcOptions>(StringVectorParameterName));
+
+      ercOptionParameters = new NamedItemCollection<IValueParameter> {
+        new ValueParameter<IntegerErcOptions>(IntegerParameterName),
+        new ValueParameter<FloatErcOptions>(FloatParameterName),
+        new ValueParameter<BooleanErcOptions>(BooleanParameterName),
+        new ValueParameter<StringErcOptions>(StringParameterName),
+        new ValueParameter<CharErcOptions>(CharParameterName),
+        new ValueParameter<StringErcOptions>(NameParameterName),
+        new ValueParameter<IntegerVectorErcOptions>(IntegerVectorParameterName),
+        new ValueParameter<FloatVectorErcOptions>(FloatVectorParameterName),
+        new ValueParameter<StringVectorErcOptions>(StringVectorParameterName)
+      };
+
+      InitEnabledChangedHandlerDict(ercOptionParameters);
+
+      var optionsCollection = new CheckedItemCollection<IValueParameter>(ercOptionParameters);
+      ercOptions = new ReadOnlyCheckedItemCollection<IValueParameter>(optionsCollection);
+      Parameters.Add(new FixedValueParameter<ReadOnlyCheckedItemCollection<IValueParameter>>("Options", ercOptions));
+
+      ercOptions.CheckedItemsChanged += ErcOptionsCheckedItemsChanged;
+
+      DisableAllOptions();
     }
 
     [StorableConstructor]
-    public ErcOptions(bool deserializing) : base(deserializing) { }
-
-    public ErcOptions(ErcOptions origin, Cloner cloner) : base(origin, cloner) { }
+    protected ErcOptions(bool deserializing) : base(deserializing) { }
+
+    public ErcOptions(ErcOptions origin, Cloner cloner)
+      : base(origin, cloner) {
+      ercOptions = cloner.Clone(origin.ercOptions);
+      ercOptionParameters = cloner.Clone(origin.ercOptionParameters);
+
+      InitEnabledChangedHandlerDict(ercOptionParameters);
+    }
+
+    [StorableHook(HookType.AfterDeserialization)]
+    // ReSharper disable once UnusedMember.Local
+    private void AfterDeserialization() {
+      InitEnabledChangedHandlerDict(ercOptionParameters);
+    }
+
+    private void InitEnabledChangedHandlerDict(NamedItemCollection<IValueParameter> parameters) {
+      ercOptionEnabledChangedHandler = parameters
+        .ToDictionary<IValueParameter, IValueParameter, EventHandler<bool>>(
+          param => param,
+          param => (sender, state) => ercOptions.SetItemCheckedState(param, state));
+    }
+
+    private void ErcOptionsCheckedItemsChanged(object sender, Collections.CollectionItemsChangedEventArgs<IValueParameter> e) {
+      foreach (var item in e.Items) {
+        var ercItem = (IErcItem)item.Value;
+        ercItem.IsEnabled = ercOptions.ItemChecked(item);
+      }
+    }
 
     public IValueParameter<PercentValue> ErcProbabilityParameter
@@ -72,22 +119,22 @@
     public IValueParameter<IntegerErcOptions> IntegerErcOptionsParameter
     {
-      get { return (IValueParameter<IntegerErcOptions>)Parameters[IntegerParameterName]; }
+      get { return (IValueParameter<IntegerErcOptions>)ercOptionParameters[IntegerParameterName]; }
     }
 
     public IntegerErcOptions IntegerErcOptions
     {
-      get { return this.IntegerErcOptionsParameter.Value; }
-      set { this.IntegerErcOptionsParameter.Value = value; }
+      get { return IntegerErcOptionsParameter.Value; }
+      set { SetErcOptions(IntegerErcOptionsParameter, value); }
     }
 
     public IValueParameter<FloatErcOptions> FloatErcOptionsParameter
     {
-      get { return (IValueParameter<FloatErcOptions>)Parameters[FloatParameterName]; }
+      get { return (IValueParameter<FloatErcOptions>)ercOptionParameters[FloatParameterName]; }
     }
 
     public FloatErcOptions FloatErcOptions
     {
-      get { return this.FloatErcOptionsParameter.Value; }
-      set { this.FloatErcOptionsParameter.Value = value; }
+      get { return FloatErcOptionsParameter.Value; }
+      set { SetErcOptions(FloatErcOptionsParameter, value); }
     }
 
@@ -97,5 +144,5 @@
     public IValueParameter<CharErcOptions> CharErcOptionsParameter
     {
-      get { return (IValueParameter<CharErcOptions>)Parameters[CharParameterName]; }
+      get { return (IValueParameter<CharErcOptions>)ercOptionParameters[CharParameterName]; }
     }
 
@@ -103,10 +150,10 @@
     {
       get { return CharErcOptionsParameter.Value; }
-      set { CharErcOptionsParameter.Value = value; }
+      set { SetErcOptions(CharErcOptionsParameter, value); }
     }
 
     public IValueParameter<BooleanErcOptions> BooleanErcOptionsParameter
     {
-      get { return (IValueParameter<BooleanErcOptions>)Parameters[BooleanParameterName]; }
+      get { return (IValueParameter<BooleanErcOptions>)ercOptionParameters[BooleanParameterName]; }
     }
 
@@ -114,10 +161,10 @@
     {
       get { return BooleanErcOptionsParameter.Value; }
-      set { BooleanErcOptionsParameter.Value = value; }
+      set { SetErcOptions(BooleanErcOptionsParameter, value); }
     }
 
     public IValueParameter<StringErcOptions> StringErcOptionsParameter
     {
-      get { return (IValueParameter<StringErcOptions>)Parameters[StringParameterName]; }
+      get { return (IValueParameter<StringErcOptions>)ercOptionParameters[StringParameterName]; }
     }
 
@@ -125,10 +172,10 @@
     {
       get { return StringErcOptionsParameter.Value; }
-      set { StringErcOptionsParameter.Value = value; }
+      set { SetErcOptions(StringErcOptionsParameter, value); }
     }
 
     public IValueParameter<StringErcOptions> NameParameter
     {
-      get { return (IValueParameter<StringErcOptions>)Parameters[NameParameterName]; }
+      get { return (IValueParameter<StringErcOptions>)ercOptionParameters[NameParameterName]; }
     }
 
@@ -136,38 +183,38 @@
     {
       get { return NameParameter.Value; }
-      set { NameParameter.Value = value; }
-    }
-
-    public IValueParameter<IntegerVectorErcOptions> IntegerVectorParameter
-    {
-      get { return (IValueParameter<IntegerVectorErcOptions>)Parameters[IntegerVectorParameterName]; }
+      set { SetErcOptions(NameParameter, value); }
+    }
+
+    public IValueParameter<IntegerVectorErcOptions> IntegerVectorErcOptionsParameter
+    {
+      get { return (IValueParameter<IntegerVectorErcOptions>)ercOptionParameters[IntegerVectorParameterName]; }
     }
 
     public IntegerVectorErcOptions IntegerVectorErcOptions
     {
-      get { return IntegerVectorParameter.Value; }
-      set { IntegerVectorParameter.Value = value; }
-    }
-
-    public IValueParameter<StringVectorErcOptions> StringVectorParameter
-    {
-      get { return (IValueParameter<StringVectorErcOptions>)Parameters[StringVectorParameterName]; }
+      get { return this.IntegerVectorErcOptionsParameter.Value; }
+      set { SetErcOptions(this.IntegerVectorErcOptionsParameter, value); }
+    }
+
+    public IValueParameter<StringVectorErcOptions> StringVectorErcOptionsValueParameter
+    {
+      get { return (IValueParameter<StringVectorErcOptions>)ercOptionParameters[StringVectorParameterName]; }
     }
 
     public StringVectorErcOptions StringVectorErcOptions
     {
-      get { return StringVectorParameter.Value; }
-      set { StringVectorParameter.Value = value; }
-    }
-
-    public IValueParameter<FloatVectorErcOptions> FloatVectorParameter
-    {
-      get { return (IValueParameter<FloatVectorErcOptions>)Parameters[FloatVectorParameterName]; }
+      get { return this.StringVectorErcOptionsValueParameter.Value; }
+      set { SetErcOptions(this.StringVectorErcOptionsValueParameter, value); }
+    }
+
+    public IValueParameter<FloatVectorErcOptions> FloatVectorErcOptionsParameter
+    {
+      get { return (IValueParameter<FloatVectorErcOptions>)ercOptionParameters[FloatVectorParameterName]; }
     }
 
     public FloatVectorErcOptions FloatVectorErcOptions
     {
-      get { return FloatVectorParameter.Value; }
-      set { FloatVectorParameter.Value = value; }
+      get { return this.FloatVectorErcOptionsParameter.Value; }
+      set { SetErcOptions(this.FloatVectorErcOptionsParameter, value); }
     }
 
@@ -175,4 +222,29 @@
       return new ErcOptions(this, cloner);
     }
+
+    public void DisableAllOptions() {
+      SetOptionsState(false);
+    }
+
+    public void EnableAllOptions() {
+      SetOptionsState(true);
+    }
+
+    public void SetOptionsState(bool state) {
+      foreach (var param in this.ercOptions) {
+        this.ercOptions.SetItemCheckedState(param, state);
+      }
+    }
+
+    private void SetErcOptions(IValueParameter param, IErcItem value) {
+      if (ercOptionEnabledChangedHandler[param] != null && param.Value != null)
+        ((IErcItem)param.Value).EnabledChanged -= ercOptionEnabledChangedHandler[param];
+
+      param.Value = value;
+      ercOptions.SetItemCheckedState(param, value != null ? value.IsEnabled : false);
+
+      if (value != null)
+        value.EnabledChanged += ercOptionEnabledChangedHandler[param];
+    }
   }
 }
Index: branches/PushGP/HeuristicLab.PushGP/HeuristicLab.Problems.ProgramSynthesis.Base/Erc/Float/FloatRangeErcValue.cs
===================================================================
--- branches/PushGP/HeuristicLab.PushGP/HeuristicLab.Problems.ProgramSynthesis.Base/Erc/Float/FloatRangeErcValue.cs	(revision 14903)
+++ branches/PushGP/HeuristicLab.PushGP/HeuristicLab.Problems.ProgramSynthesis.Base/Erc/Float/FloatRangeErcValue.cs	(revision 14905)
@@ -10,12 +10,11 @@
     private const string RangeParameterName = "Range";
 
-    public FloatRangeErcValue() {
+    public FloatRangeErcValue() : this(false, 0d, 0d) { }
+
+    public FloatRangeErcValue(double start, double end) : this(true, start, end) { }
+
+    public FloatRangeErcValue(bool isEnabled, double start, double end, double weight = 1d) : base(isEnabled, weight) {
       Name = "Float range";
-      this.Parameters.Add(new FixedValueParameter<DoubleRange>(RangeParameterName));
-    }
-
-    public FloatRangeErcValue(double start, double end) : this() {
-      this.Start = start;
-      this.End = end;
+      Parameters.Add(new FixedValueParameter<DoubleRange>(RangeParameterName, new DoubleRange(start, end)));
     }
 
Index: branches/PushGP/HeuristicLab.PushGP/HeuristicLab.Problems.ProgramSynthesis.Base/Erc/FloatVector/FloatVectorConstantsErcValue.cs
===================================================================
--- branches/PushGP/HeuristicLab.PushGP/HeuristicLab.Problems.ProgramSynthesis.Base/Erc/FloatVector/FloatVectorConstantsErcValue.cs	(revision 14903)
+++ branches/PushGP/HeuristicLab.PushGP/HeuristicLab.Problems.ProgramSynthesis.Base/Erc/FloatVector/FloatVectorConstantsErcValue.cs	(revision 14905)
@@ -11,9 +11,9 @@
 
     public FloatVectorConstantsErcValue(params double[][] values)
-      : this(true, values) {
+      : this(true, 1d, values) {
     }
 
-    public FloatVectorConstantsErcValue(bool isEnabled, params double[][] values)
-      : base(isEnabled, values.Select(v => new DoubleArray(v)).ToArray()) {
+    public FloatVectorConstantsErcValue(bool isEnabled, double weight = 1d, params double[][] values)
+      : base(isEnabled, weight, values.Select(v => new DoubleArray(v)).ToArray()) {
       Name = "Float vector constants";
     }
Index: branches/PushGP/HeuristicLab.PushGP/HeuristicLab.Problems.ProgramSynthesis.Base/Erc/IErcItem.cs
===================================================================
--- branches/PushGP/HeuristicLab.PushGP/HeuristicLab.Problems.ProgramSynthesis.Base/Erc/IErcItem.cs	(revision 14905)
+++ branches/PushGP/HeuristicLab.PushGP/HeuristicLab.Problems.ProgramSynthesis.Base/Erc/IErcItem.cs	(revision 14905)
@@ -0,0 +1,10 @@
+﻿namespace HeuristicLab.Problems.ProgramSynthesis.Base.Erc {
+  using System;
+
+  using HeuristicLab.Core;
+
+  public interface IErcItem : IItem {
+    event EventHandler<bool> EnabledChanged;
+    bool IsEnabled { get; set; }
+  }
+}
Index: branches/PushGP/HeuristicLab.PushGP/HeuristicLab.Problems.ProgramSynthesis.Base/Erc/IErcValueItem.cs
===================================================================
--- branches/PushGP/HeuristicLab.PushGP/HeuristicLab.Problems.ProgramSynthesis.Base/Erc/IErcValueItem.cs	(revision 14903)
+++ branches/PushGP/HeuristicLab.PushGP/HeuristicLab.Problems.ProgramSynthesis.Base/Erc/IErcValueItem.cs	(revision 14905)
@@ -2,6 +2,5 @@
   using HeuristicLab.Core;
 
-  public interface IErcValueItem<T> : IItem {
-    bool IsEnabled { get; set; }
+  public interface IErcValueItem<T> : IErcItem {
     T GetErcValue(IRandom random);
   }
Index: branches/PushGP/HeuristicLab.PushGP/HeuristicLab.Problems.ProgramSynthesis.Base/Erc/Integer/IntegerConstantErcValue.cs
===================================================================
--- branches/PushGP/HeuristicLab.PushGP/HeuristicLab.Problems.ProgramSynthesis.Base/Erc/Integer/IntegerConstantErcValue.cs	(revision 14903)
+++ branches/PushGP/HeuristicLab.PushGP/HeuristicLab.Problems.ProgramSynthesis.Base/Erc/Integer/IntegerConstantErcValue.cs	(revision 14905)
@@ -17,6 +17,5 @@
     public IntegerConstantErcValue(bool deserializing) : base(deserializing) { }
 
-    public IntegerConstantErcValue(IntegerConstantErcValue origin, Cloner cloner) : base(origin, cloner) {
-    }
+    public IntegerConstantErcValue(IntegerConstantErcValue origin, Cloner cloner) : base(origin, cloner) { }
 
     public override IDeepCloneable Clone(Cloner cloner) {
Index: branches/PushGP/HeuristicLab.PushGP/HeuristicLab.Problems.ProgramSynthesis.Base/Erc/Integer/IntegerRangeErcValue.cs
===================================================================
--- branches/PushGP/HeuristicLab.PushGP/HeuristicLab.Problems.ProgramSynthesis.Base/Erc/Integer/IntegerRangeErcValue.cs	(revision 14903)
+++ branches/PushGP/HeuristicLab.PushGP/HeuristicLab.Problems.ProgramSynthesis.Base/Erc/Integer/IntegerRangeErcValue.cs	(revision 14905)
@@ -10,16 +10,15 @@
     private const string RangeParameterName = "Range";
 
-    public IntegerRangeErcValue() {
+    public IntegerRangeErcValue() : this(false, 0, 0) { }
+
+    public IntegerRangeErcValue(int start, int end) : this(true, start, end) { }
+
+    public IntegerRangeErcValue(bool isEnabled, int start, int end, double weight = 1d) : base(isEnabled, weight) {
       Name = "Integer range";
-      Parameters.Add(new FixedValueParameter<IntRange>(RangeParameterName));
-    }
-
-    public IntegerRangeErcValue(int start, int end) : this() {
-      Start = start;
-      End = end;
+      Parameters.Add(new FixedValueParameter<IntRange>(RangeParameterName, new IntRange(start, end)));
     }
 
     [StorableConstructor]
-    public IntegerRangeErcValue(bool deseralizing) : base(deseralizing) { }
+    protected IntegerRangeErcValue(bool deseralizing) : base(deseralizing) { }
 
     public IntegerRangeErcValue(IntegerRangeErcValue origin, Cloner cloner) : base(origin, cloner) { }
Index: branches/PushGP/HeuristicLab.PushGP/HeuristicLab.Problems.ProgramSynthesis.Base/Erc/IntegerVector/IntegerVectorConstantsErcValue.cs
===================================================================
--- branches/PushGP/HeuristicLab.PushGP/HeuristicLab.Problems.ProgramSynthesis.Base/Erc/IntegerVector/IntegerVectorConstantsErcValue.cs	(revision 14903)
+++ branches/PushGP/HeuristicLab.PushGP/HeuristicLab.Problems.ProgramSynthesis.Base/Erc/IntegerVector/IntegerVectorConstantsErcValue.cs	(revision 14905)
@@ -10,8 +10,8 @@
     public IntegerVectorConstantsErcValue() : this(new int[0][]) { }
 
-    public IntegerVectorConstantsErcValue(params int[][] values) : this(true, values) { }
+    public IntegerVectorConstantsErcValue(params int[][] values) : this(true, 1d, values) { }
 
-    public IntegerVectorConstantsErcValue(bool isEnabled, params int[][] values)
-      : base(isEnabled, values.Select(v => new IntArray(v)).ToArray()) {
+    public IntegerVectorConstantsErcValue(bool isEnabled, double weight = 1d, params int[][] values)
+      : base(isEnabled, weight, values.Select(v => new IntArray(v)).ToArray()) {
       Name = "Integer vector constants";
     }
Index: branches/PushGP/HeuristicLab.PushGP/HeuristicLab.Problems.ProgramSynthesis.Base/Erc/String/StringConstantErcValue.cs
===================================================================
--- branches/PushGP/HeuristicLab.PushGP/HeuristicLab.Problems.ProgramSynthesis.Base/Erc/String/StringConstantErcValue.cs	(revision 14903)
+++ branches/PushGP/HeuristicLab.PushGP/HeuristicLab.Problems.ProgramSynthesis.Base/Erc/String/StringConstantErcValue.cs	(revision 14905)
@@ -1,4 +1,3 @@
 ﻿namespace HeuristicLab.Problems.ProgramSynthesis.Base.Erc.String {
-  using System.Collections.Generic;
 
   using HeuristicLab.Common;
@@ -12,12 +11,12 @@
 
     private const string ConstantsParameterName = "Constants";
-    private readonly StringArray array; // perf opt: reduce parameter getter usage
 
-    public StringConstantErcValue() : this(new string[0]) { }
+    public StringConstantErcValue() : this(false, 1d) { }
 
-    public StringConstantErcValue(params string[] constants) {
+    public StringConstantErcValue(params string[] constants) : this(true, 1d, constants) { }
+
+    public StringConstantErcValue(bool isEnabled, double weight = 1d, params string[] constants) : base(isEnabled, weight) {
       Name = "String constants";
-      array = new StringArray(constants);
-      Parameters.Add(new FixedValueParameter<StringArray>(ConstantsParameterName, array));
+      Parameters.Add(new FixedValueParameter<StringArray>(ConstantsParameterName, new StringArray(constants)));
     }
 
@@ -34,5 +33,5 @@
     }
 
-    public IEnumerable<string> Constants
+    public StringArray Constants
     {
       get { return ConstantsParameter.Value; }
@@ -44,6 +43,8 @@
 
     public override string GetErcValue(IRandom random) {
-      var x = random.Next(array.Length);
-      return array[x];
+      if (Constants.Length == 0) return string.Empty;
+
+      var x = random.Next(Constants.Length);
+      return Constants[x];
     }
   }
Index: branches/PushGP/HeuristicLab.PushGP/HeuristicLab.Problems.ProgramSynthesis.Base/Erc/String/StringRandomErcValue.cs
===================================================================
--- branches/PushGP/HeuristicLab.PushGP/HeuristicLab.Problems.ProgramSynthesis.Base/Erc/String/StringRandomErcValue.cs	(revision 14903)
+++ branches/PushGP/HeuristicLab.PushGP/HeuristicLab.Problems.ProgramSynthesis.Base/Erc/String/StringRandomErcValue.cs	(revision 14905)
@@ -27,5 +27,7 @@
     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 StringRandomErcValue() {
+    public StringRandomErcValue() : base(false, 1d) { }
+
+    public StringRandomErcValue(bool isEnabled, double weight = 1d) : base(isEnabled, weight) {
       Name = "String random";
       Parameters.Add(new FixedValueParameter<BoolValue>(AllowLowercaseLettersParameterName, new BoolValue(true)));
Index: branches/PushGP/HeuristicLab.PushGP/HeuristicLab.Problems.ProgramSynthesis.Base/Erc/StringVector/StringVectorConstantsErcValue.cs
===================================================================
--- branches/PushGP/HeuristicLab.PushGP/HeuristicLab.Problems.ProgramSynthesis.Base/Erc/StringVector/StringVectorConstantsErcValue.cs	(revision 14903)
+++ branches/PushGP/HeuristicLab.PushGP/HeuristicLab.Problems.ProgramSynthesis.Base/Erc/StringVector/StringVectorConstantsErcValue.cs	(revision 14905)
@@ -15,12 +15,8 @@
     private const string ConstantsParameterName = "Constants";
 
-    private readonly StringArray[] arrays; // perf opt: avoid using parameter getter
+    public StringVectorConstantsErcValue() : this(false, 1d) { }
+    public StringVectorConstantsErcValue(params StringArray[] arrays) : this(true, 1d, arrays) { }
 
-    public StringVectorConstantsErcValue() : this(false, new StringArray[0]) { }
-
-    public StringVectorConstantsErcValue(params StringArray[] arrays) : this(true, arrays) { }
-
-    public StringVectorConstantsErcValue(bool isEnabled, params StringArray[] arrays) {
-      this.arrays = arrays;
+    public StringVectorConstantsErcValue(bool isEnabled, double weight = 1d, params StringArray[] arrays) : base(isEnabled, weight) {
       Name = "String vector constants";
       IsEnabled = isEnabled;
@@ -44,6 +40,6 @@
 
     public override IReadOnlyList<string> GetErcValue(IRandom random) {
-      // TODO: remove ToList when ValueTypeArray implements IReadOnlyList
-      return arrays.SampleRandom(random).ToList();
+      // TODO: remove ToArray when ValueTypeArray implements IReadOnlyList
+      return Constants.SampleRandom(random).ToArray();
     }
 
Index: branches/PushGP/HeuristicLab.PushGP/HeuristicLab.Problems.ProgramSynthesis.Base/Erc/VectorConstantsErcValue.cs
===================================================================
--- branches/PushGP/HeuristicLab.PushGP/HeuristicLab.Problems.ProgramSynthesis.Base/Erc/VectorConstantsErcValue.cs	(revision 14903)
+++ branches/PushGP/HeuristicLab.PushGP/HeuristicLab.Problems.ProgramSynthesis.Base/Erc/VectorConstantsErcValue.cs	(revision 14905)
@@ -15,10 +15,7 @@
     private const string ConstantsParameterName = "Constants";
 
-    private readonly TValue[] arrays; // perf opt: avoid using parameter getter
+    protected VectorConstantsErcValue(params TValue[] arrays) : this(true, 1d, arrays) { }
 
-    protected VectorConstantsErcValue(params TValue[] arrays) : this(true, arrays) { }
-
-    protected VectorConstantsErcValue(bool isEnabled, params TValue[] arrays) {
-      this.arrays = arrays;
+    protected VectorConstantsErcValue(bool isEnabled, double weight = 1d, params TValue[] arrays) : base(isEnabled, weight) {
       IsEnabled = isEnabled;
       Parameters.Add(new ValueParameter<ItemCollection<TValue>>(ConstantsParameterName, new ItemCollection<TValue>(arrays)));
@@ -42,5 +39,5 @@
     public override IReadOnlyList<T> GetErcValue(IRandom random) {
       // TODO: remove ToList when ValueTypeArray implements IReadOnlyList
-      return arrays.SampleRandom(random).ToList();
+      return Constants.SampleRandom(random).ToArray();
     }
   }
Index: branches/PushGP/HeuristicLab.PushGP/HeuristicLab.Problems.ProgramSynthesis.Base/Erc/WeightedErcValueItem.cs
===================================================================
--- branches/PushGP/HeuristicLab.PushGP/HeuristicLab.Problems.ProgramSynthesis.Base/Erc/WeightedErcValueItem.cs	(revision 14903)
+++ branches/PushGP/HeuristicLab.PushGP/HeuristicLab.Problems.ProgramSynthesis.Base/Erc/WeightedErcValueItem.cs	(revision 14905)
@@ -1,3 +1,5 @@
 ﻿namespace HeuristicLab.Problems.ProgramSynthesis.Base.Erc {
+  using System;
+
   using HeuristicLab.Common;
   using HeuristicLab.Core;
@@ -6,11 +8,17 @@
   using HeuristicLab.Persistence.Default.CompositeSerializers.Storable;
 
+  [StorableClass]
   public abstract class WeightedErcValueItem<T> : ParameterizedNamedItem, IWeightedErcValueItem<T> {
     private const string WeightParameterName = "Weight";
+
+    [Storable]
+    protected bool isEnabled;
+
+    public event EventHandler<bool> EnabledChanged;
 
     protected WeightedErcValueItem() : this(false, 1d) { }
 
     protected WeightedErcValueItem(bool isEnabled, double weigth) {
-      IsEnabled = isEnabled;
+      this.isEnabled = isEnabled;
       Parameters.Add(new FixedValueParameter<DoubleValue>(WeightParameterName, new DoubleValue(weigth)));
     }
@@ -19,5 +27,8 @@
     protected WeightedErcValueItem(bool deserializing) : base(deserializing) { }
 
-    protected WeightedErcValueItem(WeightedErcValueItem<T> origin, Cloner cloner) : base(origin, cloner) { }
+    protected WeightedErcValueItem(WeightedErcValueItem<T> origin, Cloner cloner)
+      : base(origin, cloner) {
+      isEnabled = origin.IsEnabled;
+    }
 
     public IValueParameter<DoubleValue> WeightParameter
@@ -32,5 +43,18 @@
     }
 
-    public bool IsEnabled { get; set; }
+    public bool IsEnabled
+    {
+      get { return isEnabled; }
+      set
+      {
+        if (value == isEnabled)
+          return;
+
+        isEnabled = value;
+
+        if (EnabledChanged != null)
+          EnabledChanged(this, value);
+      }
+    }
 
     public abstract T GetErcValue(IRandom random);
Index: branches/PushGP/HeuristicLab.PushGP/HeuristicLab.Problems.ProgramSynthesis.Base/HeuristicLab.Problems.ProgramSynthesis.Base.csproj
===================================================================
--- branches/PushGP/HeuristicLab.PushGP/HeuristicLab.Problems.ProgramSynthesis.Base/HeuristicLab.Problems.ProgramSynthesis.Base.csproj	(revision 14903)
+++ branches/PushGP/HeuristicLab.PushGP/HeuristicLab.Problems.ProgramSynthesis.Base/HeuristicLab.Problems.ProgramSynthesis.Base.csproj	(revision 14905)
@@ -76,4 +76,5 @@
     <Compile Include="Erc\ErcOption.cs" />
     <Compile Include="Erc\ErcOptionConvertible.cs" />
+    <Compile Include="Erc\IErcItem.cs" />
     <Compile Include="Erc\IReadOnlyErcOptions.cs" />
     <Compile Include="Erc\WeightedErcValueItem.cs" />
Index: branches/PushGP/HeuristicLab.PushGP/HeuristicLab.Problems.ProgramSynthesis/Push/Configuration/IEnabledExpressionsConfiguration.cs
===================================================================
--- branches/PushGP/HeuristicLab.PushGP/HeuristicLab.Problems.ProgramSynthesis/Push/Configuration/IEnabledExpressionsConfiguration.cs	(revision 14903)
+++ branches/PushGP/HeuristicLab.PushGP/HeuristicLab.Problems.ProgramSynthesis/Push/Configuration/IEnabledExpressionsConfiguration.cs	(revision 14905)
@@ -22,9 +22,9 @@
     IList<string> EnabledExpressions { get; }
 
-    void EnableStack(StackTypes types, bool enableExpressions = false);
-    void DisableStack(StackTypes type, bool disableExpressions = false);
-    void SetStack(StackTypes type, bool state, bool cascadeForExpressions = false);
+    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 EnableExpressionOfStack(StackTypes types);
-    void DisableExpressionOfStack(StackTypes types);
+    void DisableExpressionsOfStack(StackTypes types);
     void EnableExpression(string name, bool enableStackIfDisabled = false);
     void DisableExpression(string name, bool disableStackIfEnabled = false);
Index: branches/PushGP/HeuristicLab.PushGP/HeuristicLab.Problems.ProgramSynthesis/Push/Configuration/PushConfiguration.cs
===================================================================
--- branches/PushGP/HeuristicLab.PushGP/HeuristicLab.Problems.ProgramSynthesis/Push/Configuration/PushConfiguration.cs	(revision 14903)
+++ branches/PushGP/HeuristicLab.PushGP/HeuristicLab.Problems.ProgramSynthesis/Push/Configuration/PushConfiguration.cs	(revision 14905)
@@ -3,5 +3,4 @@
   using System.Collections.Generic;
   using System.Linq;
-  using Attributes;
   using Base.Erc;
   using Common;
@@ -174,14 +173,28 @@
 
         if (types.HasFlag(type))
-          EnableStack(type, true);
+          EnableStack(type, false, true);
       }
     }
 
     public void EnableExpressionOfStack(StackTypes types) {
-      var names = ExpressionTable.StackTypeToNamesTable[types]
-        .Except(EnabledExpressions)
-        .ToArray();
-
-      foreach (var name in names)
+      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);
 
@@ -191,10 +204,18 @@
     }
 
-    public void DisableExpressionOfStack(StackTypes types) {
-      var names = ExpressionTable.StackTypeToNamesTable[types]
-        .Intersect(EnabledExpressions)
-        .ToArray();
-
-      foreach (var name in names)
+    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);
 
@@ -241,10 +262,10 @@
 
     public void EnableExpression<T>(bool enableStackIfDisabled = false) where T : Expression {
-      var attribute = (PushExpressionAttribute)Attribute.GetCustomAttribute(typeof(T), typeof(PushExpressionAttribute));
+      var attribute = ExpressionTable.TypeToAttributeTable[typeof(T)];
       EnableExpression(attribute.ExpressionName, enableStackIfDisabled);
     }
 
     public void DisableExpression<T>(bool disableStackIfEnabled = false) where T : Expression {
-      var attribute = (PushExpressionAttribute)Attribute.GetCustomAttribute(typeof(T), typeof(PushExpressionAttribute));
+      var attribute = ExpressionTable.TypeToAttributeTable[typeof(T)];
       DisableExpression(attribute.ExpressionName, disableStackIfEnabled);
     }
@@ -260,21 +281,21 @@
     }
 
-    public void EnableStack(StackTypes type, bool enableExpressions = false) {
+    public void EnableStack(StackTypes type, bool enableExpressions = true, bool enableDependencies = true) {
       enabledStacks[type] = true;
 
-      if (enableExpressions)
-        EnableExpressionOfStack(type);
-    }
-
-    public void DisableStack(StackTypes type, bool disableExpressions = false) {
+      if (enableExpressions) EnableExpressionOfStack(type);
+      if (enableDependencies) EnableExpressionDependentOnStack(type);
+    }
+
+    public void DisableStack(StackTypes type, bool disableExpressions = true, bool disableDependencies = true) {
       enabledStacks[type] = false;
 
-      if (disableExpressions)
-        DisableExpressionOfStack(type);
-    }
-
-    public void SetStack(StackTypes type, bool state, bool cascadeForExpressions = false) {
-      if (state) EnableStack(type, cascadeForExpressions);
-      else DisableStack(type, cascadeForExpressions);
+      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);
     }
 
Index: branches/PushGP/HeuristicLab.PushGP/HeuristicLab.Problems.ProgramSynthesis/Push/Expressions/BooleanExpressions.cs
===================================================================
--- branches/PushGP/HeuristicLab.PushGP/HeuristicLab.Problems.ProgramSynthesis/Push/Expressions/BooleanExpressions.cs	(revision 14903)
+++ branches/PushGP/HeuristicLab.PushGP/HeuristicLab.Problems.ProgramSynthesis/Push/Expressions/BooleanExpressions.cs	(revision 14905)
@@ -11,8 +11,9 @@
   [PushExpression(StackTypes.Boolean, "BOOLEAN.AND")]
   public class BooleanAndExpression : StatelessExpression {
-    public override bool Eval(IInternalPushInterpreter interpreter) {
-      if (interpreter.BooleanStack.Count < 2)
-        return false;
+    public bool IsNoop(IInternalPushInterpreter interpreter) {
+      return interpreter.BooleanStack.Count < 2;
+    }
 
+    public void TryEval(IInternalPushInterpreter interpreter) {
       var first = interpreter.BooleanStack.Pop();
       var second = interpreter.BooleanStack.Top;
@@ -20,4 +21,11 @@
 
       interpreter.BooleanStack.SetTop(result);
+    }
+
+    public override bool Eval(IInternalPushInterpreter interpreter) {
+      if (IsNoop(interpreter))
+        return false;
+
+      TryEval(interpreter);
       return true;
     }
Index: branches/PushGP/HeuristicLab.PushGP/HeuristicLab.Problems.ProgramSynthesis/Push/Expressions/Expression.cs
===================================================================
--- branches/PushGP/HeuristicLab.PushGP/HeuristicLab.Problems.ProgramSynthesis/Push/Expressions/Expression.cs	(revision 14903)
+++ branches/PushGP/HeuristicLab.PushGP/HeuristicLab.Problems.ProgramSynthesis/Push/Expressions/Expression.cs	(revision 14905)
@@ -2,6 +2,4 @@
   using System;
   using System.Collections.Generic;
-
-  using HeuristicLab.Problems.ProgramSynthesis.Push.Attributes;
   using HeuristicLab.Problems.ProgramSynthesis.Push.Data.Pool;
 
@@ -10,5 +8,5 @@
   [Serializable]
   public abstract class Expression : IPooledObject {
-    public bool IsProgram { get { return this.GetType() == typeof(PushProgram); } }
+    public bool IsProgram { get { return GetType() == typeof(PushProgram); } }
 
     public static readonly IReadOnlyCollection<Expression> EmptyContainer = new Expression[0];
@@ -18,11 +16,9 @@
       get
       {
-        var attribute = (PushExpressionAttribute)Attribute.GetCustomAttribute(this.GetType(), typeof(PushExpressionAttribute));
-
-        return attribute != null
-          ? attribute.ExpressionName
-          : string.Empty;
+        return ExpressionTable.TypeToAttributeTable[GetType()].ExpressionName;
       }
     }
+
+    //public abstract bool IsNoop(IInternalPushInterpreter interpreter);
 
     public abstract bool Eval(IInternalPushInterpreter interpreter);
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 14903)
+++ branches/PushGP/HeuristicLab.PushGP/HeuristicLab.Problems.ProgramSynthesis/Push/Problem/BenchmarkSuite/PushBenchmarkSuiteProblem.cs	(revision 14905)
@@ -1,9 +1,7 @@
 ﻿namespace HeuristicLab.Problems.ProgramSynthesis.Push.Problem.BenchmarkSuite {
-  using System.Linq;
   using Common;
   using Configuration;
   using Core;
   using Encodings.IntegerVectorEncoding;
-  using Expressions;
   using HeuristicLab.BenchmarkSuite.Problems;
   using Instances;
@@ -46,10 +44,4 @@
       config.SetEnabledStacks((StackTypes)data.EnabledDataTypes);
 
-      // update enabled stack types
-      foreach (var stackType in ExpressionTable.StackTypeToNamesTable.Keys) {
-        var enable = config.EnabledExpressions.Intersect(ExpressionTable.StackTypeToNamesTable[stackType]).Any();
-        config.SetStack(stackType, enable);
-      }
-
       Encoding.Bounds[0, 0] = 0;
       Encoding.Bounds[0, 1] = config.EnabledExpressions.Count;
@@ -63,5 +55,5 @@
       IReadOnlyPushConfiguration config,
       IPushEvaluator evaluator) {
-      return new PushBenchmarkSuiteSolution(vector, bestQuality, random, config, (PushBenchmarkSuiteEvaluator)PushEvaluator.Clone());
+      return new PushBenchmarkSuiteSolution(vector, bestQuality, random, (IReadOnlyPushConfiguration)config.Clone(), (PushBenchmarkSuiteEvaluator)PushEvaluator.Clone());
     }
   }
Index: branches/PushGP/HeuristicLab.PushGP/HeuristicLab.Problems.ProgramSynthesis/Push/Views/ExpressionSelectionView.cs
===================================================================
--- branches/PushGP/HeuristicLab.PushGP/HeuristicLab.Problems.ProgramSynthesis/Push/Views/ExpressionSelectionView.cs	(revision 14903)
+++ branches/PushGP/HeuristicLab.PushGP/HeuristicLab.Problems.ProgramSynthesis/Push/Views/ExpressionSelectionView.cs	(revision 14905)
@@ -52,5 +52,5 @@
 
       if (e.Node.Parent == null) {
-        Content.SetStack(stackType, e.Node.Checked, true);
+        Content.SetStack(stackType, e.Node.Checked, true, false);
         SetStackNodeText(e.Node);
         foreach (var subNode in e.Node.Nodes.OfType<TreeNode>().Where(n => n.Checked != e.Node.Checked))
