Index: branches/PushGP/HeuristicLab.PushGP/FeatureTests/DirtyList/PushList.cs
===================================================================
--- branches/PushGP/HeuristicLab.PushGP/FeatureTests/DirtyList/PushList.cs	(revision 14907)
+++ branches/PushGP/HeuristicLab.PushGP/FeatureTests/DirtyList/PushList.cs	(revision 14908)
@@ -13,5 +13,5 @@
       if (!IsEnabled) return;
 
-      this.items[items.Count - 1].Add(item);
+      items[items.Count - 1].Add(item);
     }
 
@@ -36,5 +36,5 @@
 
     public void Clear() {
-      this.items.Clear();
+      items.Clear();
     }
   }
Index: branches/PushGP/HeuristicLab.PushGP/FeatureTests/DirtyList/PushStack.cs
===================================================================
--- branches/PushGP/HeuristicLab.PushGP/FeatureTests/DirtyList/PushStack.cs	(revision 14907)
+++ branches/PushGP/HeuristicLab.PushGP/FeatureTests/DirtyList/PushStack.cs	(revision 14908)
@@ -22,6 +22,6 @@
 
     public PushStack(int capacity = 0) {
-      this.data = new List<T>(capacity);
-      this.IsEnabled = true;
+      data = new List<T>(capacity);
+      IsEnabled = true;
     }
 
@@ -32,5 +32,5 @@
       get
       {
-        return this.data.Capacity;
+        return data.Capacity;
       }
     }
@@ -40,5 +40,5 @@
       get
       {
-        return this.data[this.Count - 1];
+        return data[Count - 1];
       }
     }
@@ -48,5 +48,5 @@
       get
       {
-        return this.Count > 0 ? this.data[this.Count - 1] : default(T);
+        return Count > 0 ? data[Count - 1] : default(T);
       }
     }
@@ -56,5 +56,5 @@
       get
       {
-        return this.data[0];
+        return data[0];
       }
     }
@@ -64,5 +64,5 @@
       get
       {
-        return this.Count > 0 ? this.data[0] : default(T);
+        return Count > 0 ? data[0] : default(T);
       }
     }
@@ -72,5 +72,5 @@
       get
       {
-        return this.data.Count;
+        return data.Count;
       }
     }
@@ -80,5 +80,5 @@
       get
       {
-        return this.Count == 0;
+        return Count == 0;
       }
     }
@@ -93,33 +93,33 @@
 
     public void Add(T item) {
-      this.Push(item);
+      Push(item);
     }
 
     public void Clear() {
-      this.data.Clear();
+      data.Clear();
     }
 
     public bool Contains(T item) {
-      return this.data.Contains(item);
+      return data.Contains(item);
     }
 
     public void CopyTo(T[] array, int arrayIndex) {
-      this.data.CopyTo(array, arrayIndex);
+      data.CopyTo(array, arrayIndex);
     }
 
     public IEnumerator<T> GetEnumerator() {
-      return this.data.GetEnumerator();
+      return data.GetEnumerator();
     }
 
     public T ElementAt(int index) {
-      return this.data[index];
+      return data[index];
     }
 
     public T ReverseElementAt(int offset) {
-      return this.data[this.data.Count - 1 - offset];
+      return data[data.Count - 1 - offset];
     }
 
     public void SetTop(T value) {
-      this.data[this.Count - 1] = value;
+      data[Count - 1] = value;
     }
 
@@ -128,32 +128,32 @@
       get
       {
-        return this.data[key];
+        return data[key];
       }
       set
       {
-        this.data[key] = value;
+        data[key] = value;
       }
     }
 
     public void Swap(int count) {
-      var top = this.Top;
-      var bottomIndex = this.Count - count;
-
-      for (var i = this.Count - 1; i > bottomIndex; i--) this.data[i] = this.data[i - 1];
-
-      this.data[bottomIndex] = top;
+      var top = Top;
+      var bottomIndex = Count - count;
+
+      for (var i = Count - 1; i > bottomIndex; i--) data[i] = data[i - 1];
+
+      data[bottomIndex] = top;
     }
 
     public void Yank(int index) {
-      if (index == this.Count - 1) return;
-
-      var item = this.ElementAt(index);
-      this.data.RemoveAt(index);
-      this.data.Add(item);
+      if (index == Count - 1) return;
+
+      var item = ElementAt(index);
+      data.RemoveAt(index);
+      data.Add(item);
     }
 
     public T Pop() {
-      var value = this.data[this.Count - 1];
-      this.data.RemoveAt(this.Count - 1);
+      var value = data[Count - 1];
+      data.RemoveAt(Count - 1);
 
       return value;
@@ -161,6 +161,6 @@
 
     public T[] Pop(int count) {
-      var items = this.Peek(count);
-      this.Remove(count);
+      var items = Peek(count);
+      Remove(count);
 
       return items;
@@ -168,12 +168,12 @@
 
     public T Peek() {
-      return this.Top;
+      return Top;
     }
 
     public T[] Peek(int count) {
-      var startIndex = this.Count - count;
+      var startIndex = Count - count;
 
       var items = new T[count];
-      this.data.CopyTo(startIndex, items, 0, count);
+      data.CopyTo(startIndex, items, 0, count);
 
       return items;
@@ -181,73 +181,73 @@
 
     public void Push(T item) {
-      if (!this.IsEnabled) return;
-
-      this.data.Add(item);
+      if (!IsEnabled) return;
+
+      data.Add(item);
     }
 
     public void Push(T item1, T item2) {
-      if (!this.IsEnabled) return;
-
-      this.data.Add(item1);
-      this.data.Add(item2);
+      if (!IsEnabled) return;
+
+      data.Add(item1);
+      data.Add(item2);
     }
 
     public void Push(T item1, T item2, T item3) {
-      if (!this.IsEnabled) return;
-
-      this.data.Add(item1);
-      this.data.Add(item2);
-      this.data.Add(item3);
+      if (!IsEnabled) return;
+
+      data.Add(item1);
+      data.Add(item2);
+      data.Add(item3);
     }
 
     public void Push(T item1, T item2, T item3, T item4) {
-      if (!this.IsEnabled) return;
-
-      this.data.Add(item1);
-      this.data.Add(item2);
-      this.data.Add(item3);
-      this.data.Add(item4);
+      if (!IsEnabled) return;
+
+      data.Add(item1);
+      data.Add(item2);
+      data.Add(item3);
+      data.Add(item4);
     }
 
     public void PushResult(int count, Func<T[], T> templateFunc) {
-      if (!this.IsEnabled) return;
-
-      var startIndex = this.Count - count;
+      if (!IsEnabled) return;
+
+      var startIndex = Count - count;
       var items = new T[count];
 
-      this.data.CopyTo(startIndex, items, 0, count);
-      this.Remove(count - 1);
-
-      this.data[this.Count - 1] = templateFunc(items);
+      data.CopyTo(startIndex, items, 0, count);
+      Remove(count - 1);
+
+      data[Count - 1] = templateFunc(items);
     }
 
     public void Push(IReadOnlyList<T> items) {
-      if (!this.IsEnabled) return;
-
-      for (var i = 0; i < items.Count; i++) this.data.Add(items[i]);
+      if (!IsEnabled) return;
+
+      for (var i = 0; i < items.Count; i++) data.Add(items[i]);
     }
 
     public void Insert(int index, T item) {
-      if (!this.IsEnabled) return;
-
-      this.data.Insert(index, item);
+      if (!IsEnabled) return;
+
+      data.Insert(index, item);
     }
 
     public void Insert(int index, params T[] items) {
-      if (!this.IsEnabled) return;
-
-      this.data.InsertRange(index, items);
+      if (!IsEnabled) return;
+
+      data.InsertRange(index, items);
     }
 
     public void Insert(int index, IEnumerable<T> items) {
-      if (!this.IsEnabled) return;
-
-      this.data.InsertRange(index, items);
+      if (!IsEnabled) return;
+
+      data.InsertRange(index, items);
     }
 
     public bool Remove(T item) {
-      var index = this.Count - 1;
-      if ((this.Count > 0) && this.data[index].Equals(item)) {
-        this.data.RemoveAt(index);
+      var index = Count - 1;
+      if ((Count > 0) && data[index].Equals(item)) {
+        data.RemoveAt(index);
         return true;
       }
@@ -256,22 +256,22 @@
 
     public void RemoveTop() {
-      this.data.RemoveAt(this.Count - 1);
+      data.RemoveAt(Count - 1);
     }
 
     public void Remove(int count) {
-      for (var i = 0; i < count; i++) this.data.RemoveAt(this.Count - 1);
+      for (var i = 0; i < count; i++) data.RemoveAt(Count - 1);
     }
 
     public void RemoveAt(int index) {
-      this.data.RemoveAt(index);
+      data.RemoveAt(index);
     }
 
     public void RemoveAt(int index, int count) {
-      this.data.RemoveRange(index, count);
+      data.RemoveRange(index, count);
     }
 
     public bool TryPop(out T item) {
-      if (this.Count > 0) {
-        item = this.Pop();
+      if (Count > 0) {
+        item = Pop();
         return true;
       }
Index: branches/PushGP/HeuristicLab.PushGP/FeatureTests/DirtyList/PushStack3.cs
===================================================================
--- branches/PushGP/HeuristicLab.PushGP/FeatureTests/DirtyList/PushStack3.cs	(revision 14907)
+++ branches/PushGP/HeuristicLab.PushGP/FeatureTests/DirtyList/PushStack3.cs	(revision 14908)
@@ -22,6 +22,6 @@
 
     public PushStack3() {
-      this.data = new LinkedList<T>();
-      this.IsEnabled = true;
+      data = new LinkedList<T>();
+      IsEnabled = true;
     }
 
@@ -32,5 +32,5 @@
       get
       {
-        return this.data.Last.Value;
+        return data.Last.Value;
       }
     }
@@ -40,5 +40,5 @@
       get
       {
-        return this.Count > 0 ? Top : default(T);
+        return Count > 0 ? Top : default(T);
       }
     }
@@ -48,5 +48,5 @@
       get
       {
-        return this.data.First.Value;
+        return data.First.Value;
       }
     }
@@ -56,5 +56,5 @@
       get
       {
-        return this.Count > 0 ? Bottom : default(T);
+        return Count > 0 ? Bottom : default(T);
       }
     }
@@ -64,5 +64,5 @@
       get
       {
-        return this.data.Count;
+        return data.Count;
       }
     }
@@ -72,5 +72,5 @@
       get
       {
-        return this.Count == 0;
+        return Count == 0;
       }
     }
@@ -85,25 +85,25 @@
 
     public void Add(T item) {
-      this.Push(item);
+      Push(item);
     }
 
     public void Clear() {
-      this.data.Clear();
+      data.Clear();
     }
 
     public bool Contains(T item) {
-      return this.data.Contains(item);
+      return data.Contains(item);
     }
 
     public void CopyTo(T[] array, int arrayIndex) {
-      this.data.CopyTo(array, arrayIndex);
+      data.CopyTo(array, arrayIndex);
     }
 
     public IEnumerator<T> GetEnumerator() {
-      return this.data.GetEnumerator();
+      return data.GetEnumerator();
     }
 
     public T ElementAt(int index) {
-      return this.data.ElementAt(index);
+      return data.ElementAt(index);
     }
 
@@ -113,5 +113,5 @@
 
     public void SetTop(T value) {
-      this.data.Last.Value = value;
+      data.Last.Value = value;
     }
 
@@ -138,28 +138,28 @@
 
     public void Swap(int count) {
-      var topValue = this.Top;
-      var current = this.data.Last;
-      var bottomIndex = this.Count - count;
-
-
-      for (var i = this.Count - 1; i > bottomIndex; i--) {
+      var topValue = Top;
+      var current = data.Last;
+      var bottomIndex = Count - count;
+
+
+      for (var i = Count - 1; i > bottomIndex; i--) {
         current.Value = current.Previous.Value;
         current = current.Previous;
       }
 
-      this.data.Last.Value = topValue;
+      data.Last.Value = topValue;
     }
 
     public void Yank(int index) {
-      if (index == this.Count - 1) return;
-
-      var item = this.GetByIndex(index);
-      this.data.Remove(item);
-      this.data.AddLast(item);
+      if (index == Count - 1) return;
+
+      var item = GetByIndex(index);
+      data.Remove(item);
+      data.AddLast(item);
     }
 
     public T Pop() {
       var value = Top;
-      this.data.RemoveLast();
+      data.RemoveLast();
 
       return value;
@@ -178,10 +178,10 @@
 
     public T Peek() {
-      return this.Top;
+      return Top;
     }
 
     public T[] Peek(int count) {
       var items = new T[count];
-      var current = this.data.Last;
+      var current = data.Last;
 
       for (var i = 0; i < count; i++) {
@@ -194,35 +194,35 @@
 
     public void Push(T item) {
-      if (!this.IsEnabled) return;
-
-      this.data.AddLast(item);
+      if (!IsEnabled) return;
+
+      data.AddLast(item);
     }
 
     public void Push(T item1, T item2) {
-      if (!this.IsEnabled) return;
-
-      this.data.AddLast(item1);
-      this.data.AddLast(item2);
+      if (!IsEnabled) return;
+
+      data.AddLast(item1);
+      data.AddLast(item2);
     }
 
     public void Push(T item1, T item2, T item3) {
-      if (!this.IsEnabled) return;
-
-      this.data.AddLast(item1);
-      this.data.AddLast(item2);
-      this.data.AddLast(item3);
+      if (!IsEnabled) return;
+
+      data.AddLast(item1);
+      data.AddLast(item2);
+      data.AddLast(item3);
     }
 
     public void Push(T item1, T item2, T item3, T item4) {
-      if (!this.IsEnabled) return;
-
-      this.data.AddLast(item1);
-      this.data.AddLast(item2);
-      this.data.AddLast(item3);
-      this.data.AddLast(item4);
+      if (!IsEnabled) return;
+
+      data.AddLast(item1);
+      data.AddLast(item2);
+      data.AddLast(item3);
+      data.AddLast(item4);
     }
 
     public void PushResult(int count, Func<T[], T> templateFunc) {
-      if (!this.IsEnabled) return;
+      if (!IsEnabled) return;
 
       Push(templateFunc(Pop(count)));
@@ -230,26 +230,26 @@
 
     public void PushRange(IReadOnlyList<T> items) {
-      if (!this.IsEnabled) return;
-
-      for (var i = 0; i < items.Count; i++) this.data.AddLast(items[i]);
+      if (!IsEnabled) return;
+
+      for (var i = 0; i < items.Count; i++) data.AddLast(items[i]);
     }
 
     public void Insert(int index, T value) {
-      if (!this.IsEnabled) return;
+      if (!IsEnabled) return;
 
       var node = GetByIndex(index);
-      this.data.AddBefore(node, value);
+      data.AddBefore(node, value);
     }
 
     public bool Remove(T item) {
-      return this.data.Remove(item);
+      return data.Remove(item);
     }
 
     public void RemoveTop() {
-      this.data.RemoveLast();
+      data.RemoveLast();
     }
 
     public void Remove(int count) {
-      for (var i = 0; i < count; i++) this.data.RemoveLast();
+      for (var i = 0; i < count; i++) data.RemoveLast();
     }
 
@@ -257,5 +257,5 @@
       var node = GetByIndex(index);
 
-      this.data.Remove(node);
+      data.Remove(node);
     }
 
@@ -271,6 +271,6 @@
 
     public bool TryPop(out T item) {
-      if (this.Count > 0) {
-        item = this.Pop();
+      if (Count > 0) {
+        item = Pop();
         return true;
       }
Index: branches/PushGP/HeuristicLab.PushGP/HeuristicLab.Problem.ProgramSynthesis.BenchmarkSuite/Views/DataEditorView.cs
===================================================================
--- branches/PushGP/HeuristicLab.PushGP/HeuristicLab.Problem.ProgramSynthesis.BenchmarkSuite/Views/DataEditorView.cs	(revision 14907)
+++ branches/PushGP/HeuristicLab.PushGP/HeuristicLab.Problem.ProgramSynthesis.BenchmarkSuite/Views/DataEditorView.cs	(revision 14908)
@@ -150,5 +150,5 @@
       }
 
-      this.nameTextBox.Text = Content.Name;
+      nameTextBox.Text = Content.Name;
 
       var cellTemplate = new DataGridViewTextBoxCell();
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 14907)
+++ branches/PushGP/HeuristicLab.PushGP/HeuristicLab.Problems.ProgramSynthesis.Base/Erc/Boolean/BooleanRandomErcValue.cs	(revision 14908)
@@ -30,6 +30,6 @@
 
     public BooleanRandomErcValue(BooleanRandomErcValue origin, Cloner cloner) : base(origin, cloner) {
-      this.AllowFalse = origin.AllowFalse;
-      this.AllowTrue = origin.AllowTrue;
+      AllowFalse = origin.AllowFalse;
+      AllowTrue = origin.AllowTrue;
     }
 
@@ -61,7 +61,7 @@
 
     public override bool GetErcValue(IRandom random) {
-      if (!this.AllowTrue && !this.AllowFalse) throw new InvalidOperationException();
-      if (!this.AllowFalse) return true;
-      if (!this.AllowTrue) return false;
+      if (!AllowTrue && !AllowFalse) throw new InvalidOperationException();
+      if (!AllowFalse) return true;
+      if (!AllowTrue) return false;
 
       return random.NextDouble() >= 0.5;
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 14907)
+++ branches/PushGP/HeuristicLab.PushGP/HeuristicLab.Problems.ProgramSynthesis.Base/Erc/Float/FloatRangeErcValue.cs	(revision 14908)
@@ -26,17 +26,17 @@
     public IValueParameter<DoubleRange> RangeParameter
     {
-      get { return (IValueParameter<DoubleRange>)this.Parameters[RangeParameterName]; }
+      get { return (IValueParameter<DoubleRange>)Parameters[RangeParameterName]; }
     }
 
     public double Start
     {
-      get { return this.RangeParameter.Value.Start; }
-      set { this.RangeParameter.Value.Start = value; }
+      get { return RangeParameter.Value.Start; }
+      set { RangeParameter.Value.Start = value; }
     }
 
     public double End
     {
-      get { return this.RangeParameter.Value.End; }
-      set { this.RangeParameter.Value.End = value; }
+      get { return RangeParameter.Value.End; }
+      set { RangeParameter.Value.End = value; }
     }
 
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 14907)
+++ branches/PushGP/HeuristicLab.PushGP/HeuristicLab.Problems.ProgramSynthesis.Base/Erc/Integer/IntegerRangeErcValue.cs	(revision 14908)
@@ -26,22 +26,22 @@
     public IValueParameter<IntRange> RangeParameter
     {
-      get { return (IValueParameter<IntRange>)this.Parameters[RangeParameterName]; }
+      get { return (IValueParameter<IntRange>)Parameters[RangeParameterName]; }
     }
 
     public int Start
     {
-      get { return this.RangeParameter.Value.Start; }
-      set { this.RangeParameter.Value.Start = value; }
+      get { return RangeParameter.Value.Start; }
+      set { RangeParameter.Value.Start = value; }
     }
 
     public int End
     {
-      get { return this.RangeParameter.Value.End; }
-      set { this.RangeParameter.Value.End = value; }
+      get { return RangeParameter.Value.End; }
+      set { RangeParameter.Value.End = value; }
     }
 
     public override int GetErcValue(IRandom random) {
 
-      return this.Start < this.End ? random.Next(this.Start, this.End) : 0;
+      return Start < End ? random.Next(Start, End) : 0;
     }
 
Index: branches/PushGP/HeuristicLab.PushGP/HeuristicLab.Problems.ProgramSynthesis.Base/Generators/StringGenerator.cs
===================================================================
--- branches/PushGP/HeuristicLab.PushGP/HeuristicLab.Problems.ProgramSynthesis.Base/Generators/StringGenerator.cs	(revision 14907)
+++ branches/PushGP/HeuristicLab.PushGP/HeuristicLab.Problems.ProgramSynthesis.Base/Generators/StringGenerator.cs	(revision 14908)
@@ -18,8 +18,8 @@
 
     public string GetNext() {
-      var length = this.index < chars.Length ? 1 : (int)Math.Log(this.index, chars.Length) + 1;
+      var length = index < chars.Length ? 1 : (int)Math.Log(index, chars.Length) + 1;
       var result = new char[length];
-      var tmp = this.index;
-      this.index++;
+      var tmp = index;
+      index++;
 
       for (var i = length; i > 0; i--) {
Index: branches/PushGP/HeuristicLab.PushGP/HeuristicLab.Problems.ProgramSynthesis/Push/Attributes/PushExpressionAttriubte.cs
===================================================================
--- branches/PushGP/HeuristicLab.PushGP/HeuristicLab.Problems.ProgramSynthesis/Push/Attributes/PushExpressionAttriubte.cs	(revision 14907)
+++ branches/PushGP/HeuristicLab.PushGP/HeuristicLab.Problems.ProgramSynthesis/Push/Attributes/PushExpressionAttriubte.cs	(revision 14908)
@@ -11,7 +11,7 @@
 
     public PushExpressionAttribute(StackTypes stackType, string expressionName, StackTypes additionalStackDependencies = default(StackTypes)) {
-      this.StackType = stackType;
-      this.AdditionalStackDependencies = additionalStackDependencies;
-      this.ExpressionName = expressionName;
+      StackType = stackType;
+      AdditionalStackDependencies = additionalStackDependencies;
+      ExpressionName = expressionName;
     }
   }
Index: branches/PushGP/HeuristicLab.PushGP/HeuristicLab.Problems.ProgramSynthesis/Push/Data/List/SkipList.cs
===================================================================
--- branches/PushGP/HeuristicLab.PushGP/HeuristicLab.Problems.ProgramSynthesis/Push/Data/List/SkipList.cs	(revision 14907)
+++ branches/PushGP/HeuristicLab.PushGP/HeuristicLab.Problems.ProgramSynthesis/Push/Data/List/SkipList.cs	(revision 14908)
@@ -50,5 +50,5 @@
 
     public SkipListNode(T value) {
-      this.Value = value;
+      Value = value;
     }
 
@@ -62,9 +62,9 @@
 
     public virtual bool IsHeader() {
-      return this.GetType() == typeof(SkipListNodeHeader<T>);
+      return GetType() == typeof(SkipListNodeHeader<T>);
     }
 
     public virtual bool IsFooter() {
-      return this.GetType() == typeof(SkipListNodeFooter<T>);
+      return GetType() == typeof(SkipListNodeFooter<T>);
     }
   }
@@ -162,9 +162,9 @@
     /// </summary>
     protected void clearEmptyLevels() {
-      if (this.levels > 1) //more than one level, don't want to remove bottom level
+      if (levels > 1) //more than one level, don't want to remove bottom level
       {
-        SkipListNode<T> currentNode = this.topLeft;
-
-        while (currentNode != this.bottomLeft) //do not remove the bottom level
+        SkipListNode<T> currentNode = topLeft;
+
+        while (currentNode != bottomLeft) //do not remove the bottom level
         {
           if (currentNode.IsHeader() && currentNode.Next.IsFooter()) {
@@ -181,5 +181,5 @@
 
             //Update counters
-            this.levels--;
+            levels--;
 
             currentNode = belowNode; //scan down
@@ -197,5 +197,5 @@
 
       //Add levels to entire list if necessary
-      int newLevelCount = valueLevels - this.levels; //number of levels missing
+      int newLevelCount = valueLevels - levels; //number of levels missing
       while (newLevelCount > 0) {
         //Create new level
@@ -203,17 +203,17 @@
 
         //Link down
-        newLevel.Below = this.topLeft;
-        this.topLeft.Above = newLevel;
-        this.topLeft = newLevel; //update reference to most top-left node
+        newLevel.Below = topLeft;
+        topLeft.Above = newLevel;
+        topLeft = newLevel; //update reference to most top-left node
 
         //Update counters
         newLevelCount--;
-        this.levels++;
+        levels++;
       }
 
       //Insert the value in the proper position, creating as many levels as was randomly determined
-      SkipListNode<T> currentNode = this.topLeft;
+      SkipListNode<T> currentNode = topLeft;
       SkipListNode<T> lastNodeAbove = null; //keeps track of the upper-level nodes in a tower
-      int currentLevel = this.levels - 1;
+      int currentLevel = levels - 1;
 
       while (currentLevel >= 0 && currentNode != null) {
@@ -256,5 +256,5 @@
       }
 
-      this.size++; //update count
+      size++; //update count
     }
 
@@ -263,5 +263,5 @@
     /// </summary>
     public virtual SkipListNode<T> Find(T value) {
-      SkipListNode<T> foundNode = this.topLeft;
+      SkipListNode<T> foundNode = topLeft;
 
       //Look for the highest-level node with an element value matching the parameter value
@@ -286,6 +286,6 @@
     /// </summary>
     public virtual SkipListNode<T> FindLowest(T value) {
-      SkipListNode<T> valueNode = this.Find(value);
-      return this.FindLowest(valueNode);
+      SkipListNode<T> valueNode = Find(value);
+      return FindLowest(valueNode);
     }
 
@@ -309,6 +309,6 @@
     /// </summary>
     public virtual SkipListNode<T> FindHighest(T value) {
-      SkipListNode<T> valueNode = this.Find(value);
-      return this.FindHighest(valueNode);
+      SkipListNode<T> valueNode = Find(value);
+      return FindHighest(valueNode);
     }
 
@@ -332,5 +332,5 @@
     /// </summary>
     public virtual bool Contains(T value) {
-      return (this.Find(value) != null);
+      return (Find(value) != null);
     }
 
@@ -339,6 +339,6 @@
     /// </summary>
     public virtual bool Remove(T value) {
-      SkipListNode<T> valueNode = this.FindHighest(value);
-      return this.Remove(valueNode);
+      SkipListNode<T> valueNode = FindHighest(value);
+      return Remove(valueNode);
     }
 
@@ -352,5 +352,5 @@
         //Make sure node is top-level node in it's tower
         if (valueNode.Above != null)
-          valueNode = this.FindHighest(valueNode);
+          valueNode = FindHighest(valueNode);
 
         //---Delete nodes going down the tower
@@ -372,8 +372,8 @@
 
         //update counter
-        this.size--;
+        size--;
 
         //Clean up the Skip List by removing levels that are now empty
-        this.clearEmptyLevels();
+        clearEmptyLevels();
 
         return true;
@@ -385,5 +385,5 @@
     /// </summary>
     public virtual void Clear() {
-      SkipListNode<T> currentNode = this.Head;
+      SkipListNode<T> currentNode = Head;
 
       while (currentNode != null) {
@@ -391,5 +391,5 @@
 
         if (!currentNode.IsHeader() && !currentNode.IsFooter()) {
-          this.Remove(currentNode);
+          Remove(currentNode);
         }
 
@@ -409,5 +409,5 @@
     /// </summary>
     public virtual void CopyTo(T[] array, int startIndex) {
-      IEnumerator<T> enumerator = this.GetEnumerator();
+      IEnumerator<T> enumerator = GetEnumerator();
 
       for (int i = startIndex; i < array.Length; i++) {
@@ -423,6 +423,6 @@
     /// </summary>
     public virtual int GetHeight(T value) {
-      SkipListNode<T> valueNode = this.FindLowest(value);
-      return this.GetHeight(valueNode);
+      SkipListNode<T> valueNode = FindLowest(value);
+      return GetHeight(valueNode);
     }
 
@@ -459,5 +459,5 @@
     /// </summary>
     IEnumerator IEnumerable.GetEnumerator() {
-      return this.GetEnumerator();
+      return GetEnumerator();
     }
 
@@ -480,5 +480,5 @@
       object IEnumerator.Current
       {
-        get { return this.Current; }
+        get { return Current; }
       }
 
@@ -493,5 +493,5 @@
       public bool MoveNext() {
         if (current == null)
-          current = this.skipList.Head.Next; //Head is header node, start after
+          current = skipList.Head.Next; //Head is header node, start after
         else
           current = current.Next;
Index: branches/PushGP/HeuristicLab.PushGP/HeuristicLab.Problems.ProgramSynthesis/Push/Data/Pool/PooledList.cs
===================================================================
--- branches/PushGP/HeuristicLab.PushGP/HeuristicLab.Problems.ProgramSynthesis/Push/Data/Pool/PooledList.cs	(revision 14907)
+++ branches/PushGP/HeuristicLab.PushGP/HeuristicLab.Problems.ProgramSynthesis/Push/Data/Pool/PooledList.cs	(revision 14908)
@@ -7,5 +7,5 @@
   public class PooledList<T> : List<T>, IPooledObject {
     public void Reset() {
-      this.Clear();
+      Clear();
     }
   }
Index: branches/PushGP/HeuristicLab.PushGP/HeuristicLab.Problems.ProgramSynthesis/Push/Data/Pool/PooledObject.cs
===================================================================
--- branches/PushGP/HeuristicLab.PushGP/HeuristicLab.Problems.ProgramSynthesis/Push/Data/Pool/PooledObject.cs	(revision 14907)
+++ branches/PushGP/HeuristicLab.PushGP/HeuristicLab.Problems.ProgramSynthesis/Push/Data/Pool/PooledObject.cs	(revision 14908)
@@ -16,10 +16,10 @@
 
     public virtual void Dispose() {
-      this.resetor(this.item);
-      this.pool.Free(this);
+      resetor(item);
+      pool.Free(this);
     }
 
     public void Reset() {
-      this.resetor(this.item);
+      resetor(item);
     }
   }
Index: branches/PushGP/HeuristicLab.PushGP/HeuristicLab.Problems.ProgramSynthesis/Push/Data/Tree/TreeNode.cs
===================================================================
--- branches/PushGP/HeuristicLab.PushGP/HeuristicLab.Problems.ProgramSynthesis/Push/Data/Tree/TreeNode.cs	(revision 14907)
+++ branches/PushGP/HeuristicLab.PushGP/HeuristicLab.Problems.ProgramSynthesis/Push/Data/Tree/TreeNode.cs	(revision 14908)
@@ -15,9 +15,9 @@
 
     public void Add(T value) {
-      this.Children.Add(new TreeNode<T>(value));
+      Children.Add(new TreeNode<T>(value));
     }
 
     public void AddNode(TreeNode<T> node) {
-      this.Children.Add(node);
+      Children.Add(node);
     }
 
Index: branches/PushGP/HeuristicLab.PushGP/HeuristicLab.Problems.ProgramSynthesis/Push/Expressions/DefineExpressions.cs
===================================================================
--- branches/PushGP/HeuristicLab.PushGP/HeuristicLab.Problems.ProgramSynthesis/Push/Expressions/DefineExpressions.cs	(revision 14907)
+++ branches/PushGP/HeuristicLab.PushGP/HeuristicLab.Problems.ProgramSynthesis/Push/Expressions/DefineExpressions.cs	(revision 14908)
@@ -36,5 +36,5 @@
       if (interpreter.Configuration.TopLevelPushCode && (interpreter.CodeStack.Count < 2)) return false;
 
-      this.Eval(
+      Eval(
         interpreter.CodeStack,
         interpreter.NameStack,
@@ -53,5 +53,5 @@
       if (interpreter.ExecStack.Count < 2) return false;
 
-      var noop = this.Eval(
+      var noop = Eval(
         interpreter.ExecStack,
         interpreter.NameStack,
@@ -70,5 +70,5 @@
 
     public override bool Eval(IInternalPushInterpreter interpreter) {
-      return this.Eval(
+      return Eval(
         interpreter.FloatStack,
         interpreter.NameStack,
@@ -81,5 +81,5 @@
   public class IntegerDefineExpression : DefineExpression<long> {
     public override bool Eval(IInternalPushInterpreter interpreter) {
-      return this.Eval(
+      return Eval(
         interpreter.IntegerStack,
         interpreter.NameStack,
@@ -92,5 +92,5 @@
   public class BooleanDefineExpression : DefineExpression<bool> {
     public override bool Eval(IInternalPushInterpreter interpreter) {
-      return this.Eval(
+      return Eval(
         interpreter.BooleanStack,
         interpreter.NameStack,
Index: branches/PushGP/HeuristicLab.PushGP/HeuristicLab.Problems.ProgramSynthesis/Push/Expressions/DoCountExpressions.cs
===================================================================
--- branches/PushGP/HeuristicLab.PushGP/HeuristicLab.Problems.ProgramSynthesis/Push/Expressions/DoCountExpressions.cs	(revision 14907)
+++ branches/PushGP/HeuristicLab.PushGP/HeuristicLab.Problems.ProgramSynthesis/Push/Expressions/DoCountExpressions.cs	(revision 14908)
@@ -52,5 +52,5 @@
 
     public override bool Eval(IInternalPushInterpreter interpreter) {
-      return this.Eval(interpreter, interpreter.CodeStack);
+      return Eval(interpreter, interpreter.CodeStack);
     }
 
@@ -84,5 +84,5 @@
 
     public override bool Eval(IInternalPushInterpreter interpreter) {
-      return this.Eval(interpreter, interpreter.ExecStack);
+      return Eval(interpreter, interpreter.ExecStack);
     }
 
Index: branches/PushGP/HeuristicLab.PushGP/HeuristicLab.Problems.ProgramSynthesis/Push/Expressions/DoRangeExpressions.cs
===================================================================
--- branches/PushGP/HeuristicLab.PushGP/HeuristicLab.Problems.ProgramSynthesis/Push/Expressions/DoRangeExpressions.cs	(revision 14907)
+++ branches/PushGP/HeuristicLab.PushGP/HeuristicLab.Problems.ProgramSynthesis/Push/Expressions/DoRangeExpressions.cs	(revision 14908)
@@ -57,5 +57,5 @@
     public CodeDoRangeExpression(LoopState state) : base(state) { }
     public override bool Eval(IInternalPushInterpreter interpreter) {
-      return this.Eval(interpreter, interpreter.CodeStack);
+      return Eval(interpreter, interpreter.CodeStack);
     }
 
@@ -99,5 +99,5 @@
     public ExecDoRangeExpression(LoopState state) : base(state) { }
     public override bool Eval(IInternalPushInterpreter interpreter) {
-      return this.Eval(interpreter, interpreter.ExecStack);
+      return Eval(interpreter, interpreter.ExecStack);
     }
     protected override LoopExpression Clone(LoopState state, IInternalPushInterpreter interpreter) {
Index: branches/PushGP/HeuristicLab.PushGP/HeuristicLab.Problems.ProgramSynthesis/Push/Expressions/DoTimesExpressions.cs
===================================================================
--- branches/PushGP/HeuristicLab.PushGP/HeuristicLab.Problems.ProgramSynthesis/Push/Expressions/DoTimesExpressions.cs	(revision 14907)
+++ branches/PushGP/HeuristicLab.PushGP/HeuristicLab.Problems.ProgramSynthesis/Push/Expressions/DoTimesExpressions.cs	(revision 14908)
@@ -23,5 +23,5 @@
 
     protected override void PushIteration(IInternalPushInterpreter interpreter) {
-      var newState = LoopState.Create(interpreter.PoolContainer.LoopStatePool, State.Body, State.CurrentIndex + this.State.Incrementor, State.DestinationIndex, State.Incrementor);
+      var newState = LoopState.Create(interpreter.PoolContainer.LoopStatePool, State.Body, State.CurrentIndex + State.Incrementor, State.DestinationIndex, State.Incrementor);
       var nextLoopExpression = Clone(newState, interpreter);
 
@@ -30,5 +30,5 @@
 
     protected override void PushLastIteration(IInternalPushInterpreter interpreter) {
-      interpreter.ExecStack.Push(this.State.Body);
+      interpreter.ExecStack.Push(State.Body);
     }
   }
@@ -47,5 +47,5 @@
 
     public override bool Eval(IInternalPushInterpreter interpreter) {
-      return this.Eval(interpreter, interpreter.CodeStack);
+      return Eval(interpreter, interpreter.CodeStack);
     }
 
@@ -74,5 +74,5 @@
 
     public override bool Eval(IInternalPushInterpreter interpreter) {
-      return this.Eval(interpreter, interpreter.ExecStack);
+      return Eval(interpreter, interpreter.ExecStack);
     }
 
Index: branches/PushGP/HeuristicLab.PushGP/HeuristicLab.Problems.ProgramSynthesis/Push/Expressions/DuplicateExpressions.cs
===================================================================
--- branches/PushGP/HeuristicLab.PushGP/HeuristicLab.Problems.ProgramSynthesis/Push/Expressions/DuplicateExpressions.cs	(revision 14907)
+++ branches/PushGP/HeuristicLab.PushGP/HeuristicLab.Problems.ProgramSynthesis/Push/Expressions/DuplicateExpressions.cs	(revision 14908)
@@ -24,5 +24,5 @@
   public class IntegerDuplicateExpression : DuplicateExpression<long> {
     public override bool Eval(IInternalPushInterpreter interpreter) {
-      return this.Eval(interpreter.IntegerStack);
+      return Eval(interpreter.IntegerStack);
     }
   }
@@ -31,5 +31,5 @@
   public class FloatDuplicateExpression : DuplicateExpression<double> {
     public override bool Eval(IInternalPushInterpreter interpreter) {
-      return this.Eval(interpreter.FloatStack);
+      return Eval(interpreter.FloatStack);
     }
   }
@@ -38,5 +38,5 @@
   public class BooleanDuplicateExpression : DuplicateExpression<bool> {
     public override bool Eval(IInternalPushInterpreter interpreter) {
-      return this.Eval(interpreter.BooleanStack);
+      return Eval(interpreter.BooleanStack);
     }
   }
@@ -45,5 +45,5 @@
   public class NameDuplicateExpression : DuplicateExpression<string> {
     public override bool Eval(IInternalPushInterpreter interpreter) {
-      return this.Eval(interpreter.NameStack);
+      return Eval(interpreter.NameStack);
     }
   }
@@ -52,5 +52,5 @@
   public class ExecDuplicateExpression : DuplicateExpression<Expression> {
     public override bool Eval(IInternalPushInterpreter interpreter) {
-      return this.Eval(interpreter.ExecStack);
+      return Eval(interpreter.ExecStack);
     }
   }
@@ -59,5 +59,5 @@
   public class CodeDuplicateExpression : DuplicateExpression<Expression> {
     public override bool Eval(IInternalPushInterpreter interpreter) {
-      return this.Eval(interpreter.CodeStack);
+      return Eval(interpreter.CodeStack);
     }
   }
@@ -66,5 +66,5 @@
   public class IntegerVectorDuplicateExpression : DuplicateExpression<List<long>> {
     public override bool Eval(IInternalPushInterpreter interpreter) {
-      return this.Eval(interpreter.IntegerVectorStack);
+      return Eval(interpreter.IntegerVectorStack);
     }
   }
@@ -73,5 +73,5 @@
   public class FloatVectorDuplicateExpression : DuplicateExpression<List<double>> {
     public override bool Eval(IInternalPushInterpreter interpreter) {
-      return this.Eval(interpreter.FloatVectorStack);
+      return Eval(interpreter.FloatVectorStack);
     }
   }
@@ -80,5 +80,5 @@
   public class BooleanVectorDuplicateExpression : DuplicateExpression<List<bool>> {
     public override bool Eval(IInternalPushInterpreter interpreter) {
-      return this.Eval(interpreter.BooleanVectorStack);
+      return Eval(interpreter.BooleanVectorStack);
     }
   }
@@ -87,5 +87,5 @@
   public class StringVectorDuplicateExpression : DuplicateExpression<List<string>> {
     public override bool Eval(IInternalPushInterpreter interpreter) {
-      return this.Eval(interpreter.StringVectorStack);
+      return Eval(interpreter.StringVectorStack);
     }
   }
Index: branches/PushGP/HeuristicLab.PushGP/HeuristicLab.Problems.ProgramSynthesis/Push/Expressions/Expression.cs
===================================================================
--- branches/PushGP/HeuristicLab.PushGP/HeuristicLab.Problems.ProgramSynthesis/Push/Expressions/Expression.cs	(revision 14907)
+++ branches/PushGP/HeuristicLab.PushGP/HeuristicLab.Problems.ProgramSynthesis/Push/Expressions/Expression.cs	(revision 14908)
@@ -25,5 +25,5 @@
 
     public override string ToString() {
-      return this.StringRepresentation;
+      return StringRepresentation;
     }
 
Index: branches/PushGP/HeuristicLab.PushGP/HeuristicLab.Problems.ProgramSynthesis/Push/Expressions/LoopExpression.cs
===================================================================
--- branches/PushGP/HeuristicLab.PushGP/HeuristicLab.Problems.ProgramSynthesis/Push/Expressions/LoopExpression.cs	(revision 14907)
+++ branches/PushGP/HeuristicLab.PushGP/HeuristicLab.Problems.ProgramSynthesis/Push/Expressions/LoopExpression.cs	(revision 14908)
@@ -46,10 +46,10 @@
       var hash = 19;
 
-      if (this.Body != null)
-        hash = hash * 31 + this.Body.GetHashCode();
+      if (Body != null)
+        hash = hash * 31 + Body.GetHashCode();
 
-      hash = hash * 31 + this.CurrentIndex.GetHashCode();
-      hash = hash * 31 + this.DestinationIndex.GetHashCode();
-      hash = hash * 31 + this.Incrementor.GetHashCode();
+      hash = hash * 31 + CurrentIndex.GetHashCode();
+      hash = hash * 31 + DestinationIndex.GetHashCode();
+      hash = hash * 31 + Incrementor.GetHashCode();
 
       return hash;
@@ -64,8 +64,8 @@
     protected bool Eval(IInternalPushInterpreter interpreter, IPushStack<Expression> sourceStack, bool pushCurrentIndex = false) {
       // if not initialized
-      if (this.State.Body == null) {
-        if (this.HasInsufficientArguments(interpreter, sourceStack)) return false;
+      if (State.Body == null) {
+        if (HasInsufficientArguments(interpreter, sourceStack)) return false;
 
-        var state = this.InitState(interpreter, sourceStack);
+        var state = InitState(interpreter, sourceStack);
         var initLoopExpression = Clone(state, interpreter);
 
@@ -75,10 +75,10 @@
 
       // if loop end reached
-      if (this.State.DestinationIndex == this.State.CurrentIndex) {
-        this.PushLastIteration(interpreter);
+      if (State.DestinationIndex == State.CurrentIndex) {
+        PushLastIteration(interpreter);
         return true;
       }
 
-      this.PushIteration(interpreter);
+      PushIteration(interpreter);
 
       return true;
@@ -100,5 +100,5 @@
 
     protected virtual void PushIteration(IInternalPushInterpreter interpreter) {
-      interpreter.IntegerStack.Push(this.State.CurrentIndex);
+      interpreter.IntegerStack.Push(State.CurrentIndex);
 
       var newState = LoopState.Create(
Index: branches/PushGP/HeuristicLab.PushGP/HeuristicLab.Problems.ProgramSynthesis/Push/Expressions/PushExpressions.cs
===================================================================
--- branches/PushGP/HeuristicLab.PushGP/HeuristicLab.Problems.ProgramSynthesis/Push/Expressions/PushExpressions.cs	(revision 14907)
+++ branches/PushGP/HeuristicLab.PushGP/HeuristicLab.Problems.ProgramSynthesis/Push/Expressions/PushExpressions.cs	(revision 14908)
@@ -10,9 +10,9 @@
 
     protected bool Eval(IPushStack<T> stack) {
-      stack.Push(this.State);
+      stack.Push(State);
       return true;
     }
 
-    public override string StringRepresentation { get { return this.State.ToString(); } }
+    public override string StringRepresentation { get { return State.ToString(); } }
   }
 
Index: branches/PushGP/HeuristicLab.PushGP/HeuristicLab.Problems.ProgramSynthesis/Push/Expressions/PushProgram.cs
===================================================================
--- branches/PushGP/HeuristicLab.PushGP/HeuristicLab.Problems.ProgramSynthesis/Push/Expressions/PushProgram.cs	(revision 14907)
+++ branches/PushGP/HeuristicLab.PushGP/HeuristicLab.Problems.ProgramSynthesis/Push/Expressions/PushProgram.cs	(revision 14908)
@@ -43,5 +43,5 @@
     public int Count { get { return expressions.Count; } }
 
-    public IReadOnlyList<Expression> Expressions { get { return this.expressions; } }
+    public IReadOnlyList<Expression> Expressions { get { return expressions; } }
 
     public static PushProgram Create(IManagedPool<PushProgram> pool, IReadOnlyList<Expression> expressions) {
@@ -152,5 +152,5 @@
         return true;
 
-      if (this.GetType() != obj.GetType())
+      if (GetType() != obj.GetType())
         return false;
 
@@ -168,5 +168,5 @@
 
     public override bool Eval(IInternalPushInterpreter interpreter) {
-      interpreter.ExecStack.Push(this.expressions);
+      interpreter.ExecStack.Push(expressions);
       return true;
     }
@@ -184,5 +184,5 @@
       get
       {
-        return this.IsEmpty
+        return IsEmpty
             ? 1
             // + 1 because "this" is also counted
@@ -192,5 +192,5 @@
 
     public IEnumerable<Expression> DepthLast() {
-      foreach (var expr in this.expressions) {
+      foreach (var expr in expressions) {
         if (expr.IsProgram)
           foreach (var sub in ((PushProgram)expr).DepthLast())
@@ -226,5 +226,5 @@
 
     public IList<Expression> CopyExpressions() {
-      return new List<Expression>(this.expressions);
+      return new List<Expression>(expressions);
     }
 
@@ -233,5 +233,5 @@
 
       var copy = expressionListPool.Get();
-      copy.AddRange(this.expressions);
+      copy.AddRange(expressions);
 
       return copy;
@@ -241,5 +241,5 @@
       var maxDepth = 1;
       for (var i = 0; i < Count; i++) {
-        var expression = this.expressions[i];
+        var expression = expressions[i];
         if (!expression.IsProgram) continue;
         var expandExpression = (PushProgram)expression;
@@ -265,5 +265,5 @@
 
       for (var i = Count - 1; i >= 0; i--) {
-        var subExpression = this.expressions[i];
+        var subExpression = expressions[i];
 
         local_treeIndex[i] = next;
@@ -283,5 +283,5 @@
 
       for (var i = 0; i < Count; i++) {
-        hash = hash * 31 + this.expressions[i].GetHashCode();
+        hash = hash * 31 + expressions[i].GetHashCode();
       }
 
@@ -349,6 +349,6 @@
 
       return TreeIndex[mid] == index
-          ? resolver(parent, this, this.expressions[mid], mid, parentIndex)
-          : (this.expressions[mid + 1] as PushProgram).GetFromTree(index - TreeIndex[mid + 1], mid + 1,
+          ? resolver(parent, this, expressions[mid], mid, parentIndex)
+          : (expressions[mid + 1] as PushProgram).GetFromTree(index - TreeIndex[mid + 1], mid + 1,
               this, resolver);
     }
Index: branches/PushGP/HeuristicLab.PushGP/HeuristicLab.Problems.ProgramSynthesis/Push/Expressions/StatefulExpression.cs
===================================================================
--- branches/PushGP/HeuristicLab.PushGP/HeuristicLab.Problems.ProgramSynthesis/Push/Expressions/StatefulExpression.cs	(revision 14907)
+++ branches/PushGP/HeuristicLab.PushGP/HeuristicLab.Problems.ProgramSynthesis/Push/Expressions/StatefulExpression.cs	(revision 14908)
@@ -11,9 +11,9 @@
 
     protected StatefulExpression(T state) {
-      this.State = state;
+      State = state;
     }
 
     protected virtual int CalcHashCode() {
-      return this.State.GetHashCode();
+      return State.GetHashCode();
     }
 
@@ -22,5 +22,5 @@
       get
       {
-        if (stringRepresentation == null) stringRepresentation = this.State.ToString();
+        if (stringRepresentation == null) stringRepresentation = State.ToString();
         return stringRepresentation;
       }
@@ -31,11 +31,11 @@
         return true;
 
-      if (this.GetType() != obj.GetType())
+      if (GetType() != obj.GetType())
         return false;
 
       var other = (StatefulExpression<T>)obj;
 
-      return ReferenceEquals(this.State, other.State) ||
-             this.GetHashCode() == other.GetHashCode();
+      return ReferenceEquals(State, other.State) ||
+             GetHashCode() == other.GetHashCode();
     }
 
Index: branches/PushGP/HeuristicLab.PushGP/HeuristicLab.Problems.ProgramSynthesis/Push/Expressions/YankDuplicateExpressions.cs
===================================================================
--- branches/PushGP/HeuristicLab.PushGP/HeuristicLab.Problems.ProgramSynthesis/Push/Expressions/YankDuplicateExpressions.cs	(revision 14907)
+++ branches/PushGP/HeuristicLab.PushGP/HeuristicLab.Problems.ProgramSynthesis/Push/Expressions/YankDuplicateExpressions.cs	(revision 14908)
@@ -26,5 +26,5 @@
   public class IntegerYankDuplicateExpression : YankDuplicateExpression<long> {
     public override bool Eval(IInternalPushInterpreter interpreter) {
-      return this.Eval(interpreter.IntegerStack, interpreter.IntegerStack);
+      return Eval(interpreter.IntegerStack, interpreter.IntegerStack);
     }
   }
@@ -33,5 +33,5 @@
   public class FloatYankDuplicateExpression : YankDuplicateExpression<double> {
     public override bool Eval(IInternalPushInterpreter interpreter) {
-      return this.Eval(interpreter.FloatStack, interpreter.IntegerStack);
+      return Eval(interpreter.FloatStack, interpreter.IntegerStack);
     }
   }
@@ -40,5 +40,5 @@
   public class BooleanYankDuplicateExpression : YankDuplicateExpression<bool> {
     public override bool Eval(IInternalPushInterpreter interpreter) {
-      return this.Eval(interpreter.BooleanStack, interpreter.IntegerStack);
+      return Eval(interpreter.BooleanStack, interpreter.IntegerStack);
     }
   }
@@ -47,5 +47,5 @@
   public class NameYankDuplicateExpression : YankDuplicateExpression<string> {
     public override bool Eval(IInternalPushInterpreter interpreter) {
-      return this.Eval(interpreter.NameStack, interpreter.IntegerStack);
+      return Eval(interpreter.NameStack, interpreter.IntegerStack);
     }
   }
@@ -54,5 +54,5 @@
   public class ExecYankDuplicateExpression : YankDuplicateExpression<Expression> {
     public override bool Eval(IInternalPushInterpreter interpreter) {
-      return this.Eval(interpreter.ExecStack, interpreter.IntegerStack);
+      return Eval(interpreter.ExecStack, interpreter.IntegerStack);
     }
   }
@@ -61,5 +61,5 @@
   public class CodeYankDuplicateExpression : YankDuplicateExpression<Expression> {
     public override bool Eval(IInternalPushInterpreter interpreter) {
-      return this.Eval(interpreter.CodeStack, interpreter.IntegerStack);
+      return Eval(interpreter.CodeStack, interpreter.IntegerStack);
     }
   }
Index: branches/PushGP/HeuristicLab.PushGP/HeuristicLab.Problems.ProgramSynthesis/Push/Expressions/YankExpressions.cs
===================================================================
--- branches/PushGP/HeuristicLab.PushGP/HeuristicLab.Problems.ProgramSynthesis/Push/Expressions/YankExpressions.cs	(revision 14907)
+++ branches/PushGP/HeuristicLab.PushGP/HeuristicLab.Problems.ProgramSynthesis/Push/Expressions/YankExpressions.cs	(revision 14908)
@@ -27,5 +27,5 @@
   public class IntegerYankExpression : YankExpression<long> {
     public override bool Eval(IInternalPushInterpreter interpreter) {
-      return this.Eval(interpreter.IntegerStack, interpreter.IntegerStack);
+      return Eval(interpreter.IntegerStack, interpreter.IntegerStack);
     }
   }
@@ -34,5 +34,5 @@
   public class FloatYankExpression : YankExpression<double> {
     public override bool Eval(IInternalPushInterpreter interpreter) {
-      return this.Eval(interpreter.FloatStack, interpreter.IntegerStack);
+      return Eval(interpreter.FloatStack, interpreter.IntegerStack);
     }
   }
@@ -41,5 +41,5 @@
   public class BooleanYankExpression : YankExpression<bool> {
     public override bool Eval(IInternalPushInterpreter interpreter) {
-      return this.Eval(interpreter.BooleanStack, interpreter.IntegerStack);
+      return Eval(interpreter.BooleanStack, interpreter.IntegerStack);
     }
   }
@@ -48,5 +48,5 @@
   public class NameYankExpression : YankExpression<string> {
     public override bool Eval(IInternalPushInterpreter interpreter) {
-      return this.Eval(interpreter.NameStack, interpreter.IntegerStack);
+      return Eval(interpreter.NameStack, interpreter.IntegerStack);
     }
   }
@@ -55,5 +55,5 @@
   public class ExecYankExpression : YankExpression<Expression> {
     public override bool Eval(IInternalPushInterpreter interpreter) {
-      return this.Eval(interpreter.ExecStack, interpreter.IntegerStack);
+      return Eval(interpreter.ExecStack, interpreter.IntegerStack);
     }
   }
@@ -62,5 +62,5 @@
   public class CodeYankExpression : YankExpression<Expression> {
     public override bool Eval(IInternalPushInterpreter interpreter) {
-      return this.Eval(interpreter.CodeStack, interpreter.IntegerStack);
+      return Eval(interpreter.CodeStack, interpreter.IntegerStack);
     }
   }
Index: branches/PushGP/HeuristicLab.PushGP/HeuristicLab.Problems.ProgramSynthesis/Push/Interpreter/PushInterpreter.cs
===================================================================
--- branches/PushGP/HeuristicLab.PushGP/HeuristicLab.Problems.ProgramSynthesis/Push/Interpreter/PushInterpreter.cs	(revision 14907)
+++ branches/PushGP/HeuristicLab.PushGP/HeuristicLab.Problems.ProgramSynthesis/Push/Interpreter/PushInterpreter.cs	(revision 14908)
@@ -241,5 +241,5 @@
 
       IsPaused = false;
-      this.Run();
+      Run();
     }
 
@@ -360,5 +360,5 @@
 
     private Task InterpretAsync() {
-      currentTask = Task.Run(() => this.Run());
+      currentTask = Task.Run(() => Run());
 
       return currentTask;
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 14907)
+++ branches/PushGP/HeuristicLab.PushGP/HeuristicLab.Problems.ProgramSynthesis/Push/Problem/BenchmarkSuite/BenchmarkSuitePushSolutionView.cs	(revision 14908)
@@ -37,16 +37,16 @@
 
     ~BenchmarkSuitePushSolutionView() {
-      this.interpreter.Dispose();
+      interpreter.Dispose();
     }
 
     private void InitEvents() {
-      this.exampleComboBox.SelectedIndexChanged += this.SelectedExampleIndexChanged;
-      this.pushDebugger.OnReset += this.PushDebuggerReset;
+      exampleComboBox.SelectedIndexChanged += SelectedExampleIndexChanged;
+      pushDebugger.OnReset += PushDebuggerReset;
     }
 
     private void PushDebuggerReset(object sender, IPushInterpreter interpreter) {
-      if (this.exampleComboBox.SelectedIndex < 0) return;
-
-      var example = Evaluator.Data.Examples[this.exampleComboBox.SelectedIndex];
+      if (exampleComboBox.SelectedIndex < 0) return;
+
+      var example = Evaluator.Data.Examples[exampleComboBox.SelectedIndex];
 
       interpreter.BooleanStack.Push(example.InputBoolean);
@@ -62,5 +62,5 @@
 
     private void SelectedExampleIndexChanged(object sender, EventArgs e) {
-      this.pushDebugger.ResetDebugging();
+      pushDebugger.ResetDebugging();
     }
 
@@ -80,29 +80,29 @@
 
     protected override void OnContentChanged() {
-      if (this.Content == null) return;
-
-      this.Name = "Push Solution";
-      this.nameTextBox.Text = this.Name;
-
-      this.pool = new PushInterpreterPool(this.Content.Config);
-
-      if (this.interpreter != null) {
-        this.interpreter.Dispose();
-      }
-
-      this.interpreter = this.pool.Create(this.Content.Random);
-      this.UpdateExamples(Evaluator.Data);
-
-      if (this.exampleComboBox.SelectedIndex < 0) {
-        this.exampleComboBox.SelectedIndex = 0; // Triggers ResetDebugging via event
-      }
-
-      this.InitResultGrid();
-      this.pushDebugger.Content = this.Content;
+      if (Content == null) return;
+
+      Name = "Push Solution";
+      nameTextBox.Text = Name;
+
+      pool = new PushInterpreterPool(Content.Config);
+
+      if (interpreter != null) {
+        interpreter.Dispose();
+      }
+
+      interpreter = pool.Create(Content.Random);
+      UpdateExamples(Evaluator.Data);
+
+      if (exampleComboBox.SelectedIndex < 0) {
+        exampleComboBox.SelectedIndex = 0; // Triggers ResetDebugging via event
+      }
+
+      InitResultGrid();
+      pushDebugger.Content = Content;
     }
 
     private void InitResultGrid() {
-      this.resultsDataGrid.Columns.Clear();
-      this.resultsDataGrid.Rows.Clear();
+      resultsDataGrid.Columns.Clear();
+      resultsDataGrid.Rows.Clear();
 
       var cellTemplate = new DataGridViewTextBoxCell();
@@ -118,5 +118,5 @@
 
         column.DefaultCellStyle.Alignment = DataGridViewContentAlignment.MiddleRight;
-        this.resultsDataGrid.Columns.Add(column);
+        resultsDataGrid.Columns.Add(column);
       }
 
@@ -139,6 +139,6 @@
         outputColumn.DefaultCellStyle.Alignment = DataGridViewContentAlignment.MiddleRight;
 
-        this.resultsDataGrid.Columns.Add(estimatedOutputColumn);
-        this.resultsDataGrid.Columns.Add(outputColumn);
+        resultsDataGrid.Columns.Add(estimatedOutputColumn);
+        resultsDataGrid.Columns.Add(outputColumn);
       }
 
@@ -158,8 +158,8 @@
       relativeDiffColumn.DefaultCellStyle.Alignment = DataGridViewContentAlignment.MiddleRight;
 
-      this.resultsDataGrid.Columns.Add(absoluteDiffColumn);
-      this.resultsDataGrid.Columns.Add(relativeDiffColumn);
-
-      using (var pushInterpreter = this.pool.Create(this.Content.Random)) {
+      resultsDataGrid.Columns.Add(absoluteDiffColumn);
+      resultsDataGrid.Columns.Add(relativeDiffColumn);
+
+      using (var pushInterpreter = pool.Create(Content.Random)) {
         for (var i = 0; i < data.Examples.Length; i++) {
           var example = data.Examples[i];
@@ -169,5 +169,5 @@
 
           row.HeaderCell.Value = row.Index + 1;
-          row.CreateCells(this.resultsDataGrid);
+          row.CreateCells(resultsDataGrid);
 
           for (var j = 0; j < data.InputArgumentTypes.Length; j++) {
@@ -177,5 +177,5 @@
           for (var j = 0; j < data.OutputArgumentTypes.Length; j++) {
             row.Cells[data.InputArgumentTypes.Length + j * 2].Value = ViewHelper.StringifyOutput(data.OutputArgumentTypes[j], example, Separator);
-            row.Cells[data.InputArgumentTypes.Length + j * 2 + 1].Value = this.StringifyResult(data.OutputArgumentTypes[j], pushInterpreter, example, Separator);
+            row.Cells[data.InputArgumentTypes.Length + j * 2 + 1].Value = StringifyResult(data.OutputArgumentTypes[j], pushInterpreter, example, Separator);
           }
 
@@ -183,5 +183,5 @@
           row.Cells[data.TotalArgumentCount + 2].Value = relativeDiff + "%";
 
-          this.resultsDataGrid.Rows.Add(row);
+          resultsDataGrid.Rows.Add(row);
           pushInterpreter.Reset();
         }
@@ -192,8 +192,8 @@
       switch (type) {
         case ExampleArgumentType.Integer:
-        case ExampleArgumentType.IntegerVector: return interpreter.IntegerStack.IsEmpty ? EmptySign : string.Join(valueSeparator, interpreter.IntegerStack.Peek(this.GetCount(interpreter.IntegerStack, example.OutputInteger)));
+        case ExampleArgumentType.IntegerVector: return interpreter.IntegerStack.IsEmpty ? EmptySign : string.Join(valueSeparator, interpreter.IntegerStack.Peek(GetCount(interpreter.IntegerStack, example.OutputInteger)));
 
         case ExampleArgumentType.Float:
-        case ExampleArgumentType.FloatVector: return interpreter.FloatStack.IsEmpty ? EmptySign : string.Join(valueSeparator, interpreter.FloatStack.Peek(this.GetCount(interpreter.FloatStack, example.OutputFloat)).Select(d => d.ToString(CultureInfo.CurrentUICulture)));
+        case ExampleArgumentType.FloatVector: return interpreter.FloatStack.IsEmpty ? EmptySign : string.Join(valueSeparator, interpreter.FloatStack.Peek(GetCount(interpreter.FloatStack, example.OutputFloat)).Select(d => d.ToString(CultureInfo.CurrentUICulture)));
 
         case ExampleArgumentType.Boolean: return interpreter.BooleanStack.IsEmpty ? EmptySign : interpreter.BooleanStack.Top.ToString();
@@ -201,5 +201,5 @@
 
         case ExampleArgumentType.String:
-        case ExampleArgumentType.StringVector: return interpreter.StringStack.IsEmpty ? EmptySign : string.Join(valueSeparator, interpreter.StringStack.Peek(this.GetCount(interpreter.StringStack, example.OutputString)));
+        case ExampleArgumentType.StringVector: return interpreter.StringStack.IsEmpty ? EmptySign : string.Join(valueSeparator, interpreter.StringStack.Peek(GetCount(interpreter.StringStack, example.OutputString)));
         default: return string.Empty;
       }
@@ -211,5 +211,5 @@
 
     private void UpdateExamples(ProblemData data) {
-      this.exampleComboBox.Items.Clear();
+      exampleComboBox.Items.Clear();
       if (data == null) return;
 
@@ -220,5 +220,5 @@
 
       foreach (var str in stringRepresentations) {
-        this.exampleComboBox.Items.Add(str);
+        exampleComboBox.Items.Add(str);
       }
     }
Index: branches/PushGP/HeuristicLab.PushGP/HeuristicLab.Problems.ProgramSynthesis/Push/Problem/BenchmarkSuite/PushBenchmarkSuiteEvaluator.cs
===================================================================
--- branches/PushGP/HeuristicLab.PushGP/HeuristicLab.Problems.ProgramSynthesis/Push/Problem/BenchmarkSuite/PushBenchmarkSuiteEvaluator.cs	(revision 14907)
+++ branches/PushGP/HeuristicLab.PushGP/HeuristicLab.Problems.ProgramSynthesis/Push/Problem/BenchmarkSuite/PushBenchmarkSuiteEvaluator.cs	(revision 14908)
@@ -69,5 +69,5 @@
 
     public void LoadData(ProblemData data) {
-      this.Data = data;
+      Data = data;
 
       DataBounds.TrainingRange.Start = 0;
Index: branches/PushGP/HeuristicLab.PushGP/HeuristicLab.Problems.ProgramSynthesis/Push/Problem/PushProblem.cs
===================================================================
--- branches/PushGP/HeuristicLab.PushGP/HeuristicLab.Problems.ProgramSynthesis/Push/Problem/PushProblem.cs	(revision 14907)
+++ branches/PushGP/HeuristicLab.PushGP/HeuristicLab.Problems.ProgramSynthesis/Push/Problem/PushProblem.cs	(revision 14908)
@@ -72,6 +72,6 @@
 
     private void EnabledExpressionsChanged(object sender, EnabledExpressionsChangedEventArgs e) {
-      this.Encoding.Bounds[0, 1] = config.EnabledExpressions.Count;
-      this.Encoding.BoundsParameter.Value[0, 1] = config.EnabledExpressions.Count;
+      Encoding.Bounds[0, 1] = config.EnabledExpressions.Count;
+      Encoding.BoundsParameter.Value[0, 1] = config.EnabledExpressions.Count;
     }
 
@@ -228,5 +228,5 @@
     public IValueParameter<IntValue> MaxPointsInProgramParameter
     {
-      get { return (IValueParameter<IntValue>)this.Parameters[MaxPointsInProgramParameterName]; }
+      get { return (IValueParameter<IntValue>)Parameters[MaxPointsInProgramParameterName]; }
     }
 
@@ -250,5 +250,5 @@
     public IValueParameter<IntValue> MinPointsInProgramParameter
     {
-      get { return (IValueParameter<IntValue>)this.Parameters[MinPointsInProgramParameterName]; }
+      get { return (IValueParameter<IntValue>)Parameters[MinPointsInProgramParameterName]; }
     }
 
@@ -287,5 +287,5 @@
     public IValueParameter<BoolValue> TopLevelPushCodeParameter
     {
-      get { return (IValueParameter<BoolValue>)this.Parameters[TopLevelPushCodeParameterName]; }
+      get { return (IValueParameter<BoolValue>)Parameters[TopLevelPushCodeParameterName]; }
     }
 
@@ -305,5 +305,5 @@
     public IValueParameter<BoolValue> TopLevelPopCodeParameter
     {
-      get { return (IValueParameter<BoolValue>)this.Parameters[TopLevelPopCodeParameterName]; }
+      get { return (IValueParameter<BoolValue>)Parameters[TopLevelPopCodeParameterName]; }
     }
 
Index: branches/PushGP/HeuristicLab.PushGP/HeuristicLab.Problems.ProgramSynthesis/Push/Selector/LexicaseSelector.cs
===================================================================
--- branches/PushGP/HeuristicLab.PushGP/HeuristicLab.Problems.ProgramSynthesis/Push/Selector/LexicaseSelector.cs	(revision 14907)
+++ branches/PushGP/HeuristicLab.PushGP/HeuristicLab.Problems.ProgramSynthesis/Push/Selector/LexicaseSelector.cs	(revision 14908)
@@ -56,5 +56,5 @@
 
     public LexicaseSelector() {
-      this.Parameters.Add(new ScopeTreeLookupParameter<DoubleArray>(
+      Parameters.Add(new ScopeTreeLookupParameter<DoubleArray>(
         PushProblem.CaseQualitiesScopeParameterName,
         "The quality of every single training case for each individual."));
Index: branches/PushGP/HeuristicLab.PushGP/HeuristicLab.Problems.ProgramSynthesis/Push/Stack/PushStack.cs
===================================================================
--- branches/PushGP/HeuristicLab.PushGP/HeuristicLab.Problems.ProgramSynthesis/Push/Stack/PushStack.cs	(revision 14907)
+++ branches/PushGP/HeuristicLab.PushGP/HeuristicLab.Problems.ProgramSynthesis/Push/Stack/PushStack.cs	(revision 14908)
@@ -237,5 +237,5 @@
 
     public bool Remove(T item) {
-      return this.data.Remove(item);
+      return data.Remove(item);
     }
 
@@ -245,5 +245,5 @@
 
     public void Remove(int count) {
-      this.data.RemoveRange(this.Count - count, count);
+      data.RemoveRange(Count - count, count);
     }
 
Index: branches/PushGP/HeuristicLab.PushGP/HeuristicLab.Tests/HeuristicLab.Tests.csproj
===================================================================
--- branches/PushGP/HeuristicLab.PushGP/HeuristicLab.Tests/HeuristicLab.Tests.csproj	(revision 14907)
+++ branches/PushGP/HeuristicLab.PushGP/HeuristicLab.Tests/HeuristicLab.Tests.csproj	(revision 14908)
@@ -39,4 +39,8 @@
   </PropertyGroup>
   <ItemGroup>
+    <Reference Include="HeuristicLab.Collections-3.3, Version=3.3.0.0, Culture=neutral, PublicKeyToken=ba48961d6f65dcec, processorArchitecture=MSIL">
+      <SpecificVersion>False</SpecificVersion>
+      <HintPath>..\..\..\..\trunk\sources\bin\HeuristicLab.Collections-3.3.dll</HintPath>
+    </Reference>
     <Reference Include="HeuristicLab.Common-3.3, Version=3.3.0.0, Culture=neutral, PublicKeyToken=ba48961d6f65dcec, processorArchitecture=MSIL">
       <SpecificVersion>False</SpecificVersion>
@@ -73,4 +77,5 @@
     <Compile Include="Benchmark\DataTests.cs" />
     <Compile Include="Benchmark\RandomWalkTests.cs" />
+    <Compile Include="Erc\ErcTests.cs" />
     <Compile Include="Interpreter\Expressions\CommonTests.cs" />
     <Compile Include="Interpreter\Expressions\ExampleTests.cs" />
@@ -99,7 +104,5 @@
     </ProjectReference>
   </ItemGroup>
-  <ItemGroup>
-    <Folder Include="Interpreter\Generator\" />
-  </ItemGroup>
+  <ItemGroup />
   <Choose>
     <When Condition="'$(VisualStudioVersion)' == '10.0' And '$(IsCodedUITest)' == 'True'">
Index: branches/PushGP/HeuristicLab.PushGP/HeuristicLab.Tests/Interpreter/ExpressionTest.cs
===================================================================
--- branches/PushGP/HeuristicLab.PushGP/HeuristicLab.Tests/Interpreter/ExpressionTest.cs	(revision 14907)
+++ branches/PushGP/HeuristicLab.PushGP/HeuristicLab.Tests/Interpreter/ExpressionTest.cs	(revision 14908)
@@ -12,5 +12,5 @@
     [TestInitialize]
     public void BeforeTest() {
-      this.interpreter = new PushInterpreter(configuration);
+      interpreter = new PushInterpreter(configuration);
     }
 
@@ -22,15 +22,15 @@
       int? floatStack = 0,
       int? integerStack = 0) {
-      if (execStack.HasValue) Assert.AreEqual(execStack, this.interpreter.ExecStack.Count);
+      if (execStack.HasValue) Assert.AreEqual(execStack, interpreter.ExecStack.Count);
 
-      if (codeStack.HasValue) Assert.AreEqual(codeStack, this.interpreter.CodeStack.Count);
+      if (codeStack.HasValue) Assert.AreEqual(codeStack, interpreter.CodeStack.Count);
 
-      if (nameStack.HasValue) Assert.AreEqual(nameStack, this.interpreter.NameStack.Count);
+      if (nameStack.HasValue) Assert.AreEqual(nameStack, interpreter.NameStack.Count);
 
-      if (booleanStack.HasValue) Assert.AreEqual(booleanStack, this.interpreter.BooleanStack.Count);
+      if (booleanStack.HasValue) Assert.AreEqual(booleanStack, interpreter.BooleanStack.Count);
 
-      if (floatStack.HasValue) Assert.AreEqual(floatStack, this.interpreter.FloatStack.Count);
+      if (floatStack.HasValue) Assert.AreEqual(floatStack, interpreter.FloatStack.Count);
 
-      if (integerStack.HasValue) Assert.AreEqual(integerStack, this.interpreter.IntegerStack.Count);
+      if (integerStack.HasValue) Assert.AreEqual(integerStack, interpreter.IntegerStack.Count);
     }
   }
Index: branches/PushGP/HeuristicLab.PushGP/HeuristicLab.Tests/Interpreter/Expressions/BooleanExpressionTests.cs
===================================================================
--- branches/PushGP/HeuristicLab.PushGP/HeuristicLab.Tests/Interpreter/Expressions/BooleanExpressionTests.cs	(revision 14907)
+++ branches/PushGP/HeuristicLab.PushGP/HeuristicLab.Tests/Interpreter/Expressions/BooleanExpressionTests.cs	(revision 14908)
@@ -19,5 +19,5 @@
       get
       {
-        return this.interpreter.BooleanStack;
+        return interpreter.BooleanStack;
       }
     }
@@ -28,10 +28,10 @@
     [TestCategory("BooleanExpressionTest")]
     public void TestAnd() {
-      this.interpreter.BooleanStack.Push(true, false);
-      this.interpreter.Run(new BooleanAndExpression());
+      interpreter.BooleanStack.Push(true, false);
+      interpreter.Run(new BooleanAndExpression());
 
-      Assert.AreEqual(false, this.interpreter.BooleanStack.Top);
+      Assert.AreEqual(false, interpreter.BooleanStack.Top);
 
-      this.TestStackCounts(booleanStack: 1);
+      TestStackCounts(booleanStack: 1);
     }
 
@@ -41,5 +41,5 @@
     [TestCategory("BooleanExpressionTest")]
     public void TestAndWithInsufficientArguments() {
-      this.TestWithInsufficientArguments("AND", 1);
+      TestWithInsufficientArguments("AND", 1);
     }
 
@@ -49,10 +49,10 @@
     [TestCategory("BooleanExpressionTest")]
     public void TestOr() {
-      this.interpreter.BooleanStack.Push(true, false);
-      this.interpreter.Run(new BooleanOrExpression());
+      interpreter.BooleanStack.Push(true, false);
+      interpreter.Run(new BooleanOrExpression());
 
-      Assert.AreEqual(true, this.interpreter.BooleanStack.Top);
+      Assert.AreEqual(true, interpreter.BooleanStack.Top);
 
-      this.TestStackCounts(booleanStack: 1);
+      TestStackCounts(booleanStack: 1);
     }
 
@@ -62,5 +62,5 @@
     [TestCategory("BooleanExpressionTest")]
     public void TestOrWithInsufficientArguments() {
-      this.TestWithInsufficientArguments("OR", 1);
+      TestWithInsufficientArguments("OR", 1);
     }
 
@@ -70,10 +70,10 @@
     [TestCategory("BooleanExpressionTest")]
     public void TestNot() {
-      this.interpreter.BooleanStack.Push(true);
-      this.interpreter.Run(new BooleanNotExpression());
+      interpreter.BooleanStack.Push(true);
+      interpreter.Run(new BooleanNotExpression());
 
-      Assert.AreEqual(false, this.interpreter.BooleanStack.Top);
+      Assert.AreEqual(false, interpreter.BooleanStack.Top);
 
-      this.TestStackCounts(booleanStack: 1);
+      TestStackCounts(booleanStack: 1);
     }
 
@@ -83,5 +83,5 @@
     [TestCategory("BooleanExpressionTest")]
     public void TestNotWithInsufficientArguments() {
-      this.TestWithInsufficientArguments("NOT");
+      TestWithInsufficientArguments("NOT");
     }
 
@@ -91,10 +91,10 @@
     [TestCategory("BooleanExpressionTest")]
     public void TestFromFloat() {
-      this.interpreter.FloatStack.Push(2.0);
-      this.interpreter.Run(new BooleanFromFloatExpression());
+      interpreter.FloatStack.Push(2.0);
+      interpreter.Run(new BooleanFromFloatExpression());
 
-      Assert.AreEqual(true, this.interpreter.BooleanStack.Top);
+      Assert.AreEqual(true, interpreter.BooleanStack.Top);
 
-      this.TestStackCounts(booleanStack: 1);
+      TestStackCounts(booleanStack: 1);
     }
 
@@ -104,5 +104,5 @@
     [TestCategory("BooleanExpressionTest")]
     public void TestFromFloatWithInsufficientArguments() {
-      this.TestWithInsufficientArguments("FROMFLOAT");
+      TestWithInsufficientArguments("FROMFLOAT");
     }
 
@@ -112,10 +112,10 @@
     [TestCategory("BooleanExpressionTest")]
     public void TestFromInteger() {
-      this.interpreter.IntegerStack.Push(2);
-      this.interpreter.Run(new BooleanFromIntegerExpression());
+      interpreter.IntegerStack.Push(2);
+      interpreter.Run(new BooleanFromIntegerExpression());
 
-      Assert.AreEqual(true, this.interpreter.BooleanStack.Top);
+      Assert.AreEqual(true, interpreter.BooleanStack.Top);
 
-      this.TestStackCounts(booleanStack: 1);
+      TestStackCounts(booleanStack: 1);
     }
 
@@ -125,5 +125,5 @@
     [TestCategory("BooleanExpressionTest")]
     public void TestFromIntegerWithInsufficientArguments() {
-      this.TestWithInsufficientArguments("FROMINTEGER");
+      TestWithInsufficientArguments("FROMINTEGER");
     }
 
@@ -137,5 +137,5 @@
 
     protected override void CheckOtherStacksAreEmpty() {
-      this.TestStackCounts(booleanStack: null);
+      TestStackCounts(booleanStack: null);
     }
   }
Index: branches/PushGP/HeuristicLab.PushGP/HeuristicLab.Tests/Interpreter/Expressions/CodeExpressionTests.cs
===================================================================
--- branches/PushGP/HeuristicLab.PushGP/HeuristicLab.Tests/Interpreter/Expressions/CodeExpressionTests.cs	(revision 14907)
+++ branches/PushGP/HeuristicLab.PushGP/HeuristicLab.Tests/Interpreter/Expressions/CodeExpressionTests.cs	(revision 14908)
@@ -20,5 +20,5 @@
       get
       {
-        return this.interpreter.CodeStack;
+        return interpreter.CodeStack;
       }
     }
@@ -33,9 +33,9 @@
       var result = PushParser.Parse("( A B )");
 
-      this.interpreter.CodeStack.Push(second, first);
-      this.interpreter.Run(new CodeAppendExpression());
-
-      Assert.AreEqual(result, this.interpreter.CodeStack.Top);
-      this.CheckOtherStacksAreEmpty();
+      interpreter.CodeStack.Push(second, first);
+      interpreter.Run(new CodeAppendExpression());
+
+      Assert.AreEqual(result, interpreter.CodeStack.Top);
+      CheckOtherStacksAreEmpty();
     }
 
@@ -49,9 +49,9 @@
       var result = PushParser.Parse("( A 5 )");
 
-      this.interpreter.CodeStack.Push(second, first);
-      this.interpreter.Run(new CodeAppendExpression());
-
-      Assert.AreEqual(result, this.interpreter.CodeStack.Top);
-      this.CheckOtherStacksAreEmpty();
+      interpreter.CodeStack.Push(second, first);
+      interpreter.Run(new CodeAppendExpression());
+
+      Assert.AreEqual(result, interpreter.CodeStack.Top);
+      CheckOtherStacksAreEmpty();
     }
 
@@ -65,9 +65,9 @@
       var result = PushParser.Parse("( 4 5 )");
 
-      this.interpreter.CodeStack.Push(second, first);
-      this.interpreter.Run(new CodeAppendExpression());
-
-      Assert.AreEqual(result, this.interpreter.CodeStack.Top);
-      this.CheckOtherStacksAreEmpty();
+      interpreter.CodeStack.Push(second, first);
+      interpreter.Run(new CodeAppendExpression());
+
+      Assert.AreEqual(result, interpreter.CodeStack.Top);
+      CheckOtherStacksAreEmpty();
     }
 
@@ -80,12 +80,12 @@
       var result = PushParser.Parse("( A B C )");
 
-      this.interpreter.CodeStack.Push(list);
-      this.interpreter.Run(new CodeDuplicateExpression());
-
-      Assert.AreEqual(this.Stack.Count, 2);
-      Assert.AreEqual(this.Stack[0], list);
-      Assert.AreEqual(this.Stack[1], result);
-
-      this.CheckOtherStacksAreEmpty();
+      interpreter.CodeStack.Push(list);
+      interpreter.Run(new CodeDuplicateExpression());
+
+      Assert.AreEqual(Stack.Count, 2);
+      Assert.AreEqual(Stack[0], list);
+      Assert.AreEqual(Stack[1], result);
+
+      CheckOtherStacksAreEmpty();
     }
 
@@ -97,9 +97,9 @@
       var first = PushParser.Parse("( A )");
 
-      this.interpreter.CodeStack.Push(first);
-      this.interpreter.Run(new CodeAtomExpression());
-
-      Assert.AreEqual(false, this.interpreter.BooleanStack.Top);
-      this.TestStackCounts(booleanStack: 1);
+      interpreter.CodeStack.Push(first);
+      interpreter.Run(new CodeAtomExpression());
+
+      Assert.AreEqual(false, interpreter.BooleanStack.Top);
+      TestStackCounts(booleanStack: 1);
     }
 
@@ -111,9 +111,9 @@
       var first = PushParser.Parse("5");
 
-      this.interpreter.CodeStack.Push(first);
-      this.interpreter.Run(new CodeAtomExpression());
-
-      Assert.AreEqual(true, this.interpreter.BooleanStack.Top);
-      this.TestStackCounts(booleanStack: 1);
+      interpreter.CodeStack.Push(first);
+      interpreter.Run(new CodeAtomExpression());
+
+      Assert.AreEqual(true, interpreter.BooleanStack.Top);
+      TestStackCounts(booleanStack: 1);
     }
 
@@ -125,9 +125,9 @@
       var first = PushParser.Parse("INTEGER.+");
 
-      this.interpreter.CodeStack.Push(first);
-      this.interpreter.Run(new CodeAtomExpression());
-
-      Assert.AreEqual(true, this.interpreter.BooleanStack.Top);
-      this.TestStackCounts(booleanStack: 1);
+      interpreter.CodeStack.Push(first);
+      interpreter.Run(new CodeAtomExpression());
+
+      Assert.AreEqual(true, interpreter.BooleanStack.Top);
+      TestStackCounts(booleanStack: 1);
     }
 
@@ -140,9 +140,9 @@
       var result = PushParser.Parse("A");
 
-      this.interpreter.CodeStack.Push(first);
-      this.interpreter.Run(new CodeCarExpression());
-
-      Assert.AreEqual(result, this.interpreter.CodeStack.Top);
-      this.CheckOtherStacksAreEmpty();
+      interpreter.CodeStack.Push(first);
+      interpreter.Run(new CodeCarExpression());
+
+      Assert.AreEqual(result, interpreter.CodeStack.Top);
+      CheckOtherStacksAreEmpty();
     }
 
@@ -155,9 +155,9 @@
       var result = PushParser.Parse("5");
 
-      this.interpreter.CodeStack.Push(first);
-      this.interpreter.Run(new CodeCarExpression());
-
-      Assert.AreEqual(result, this.interpreter.CodeStack.Top);
-      this.CheckOtherStacksAreEmpty();
+      interpreter.CodeStack.Push(first);
+      interpreter.Run(new CodeCarExpression());
+
+      Assert.AreEqual(result, interpreter.CodeStack.Top);
+      CheckOtherStacksAreEmpty();
     }
 
@@ -170,9 +170,9 @@
       var result = PushParser.Parse("( B C )");
 
-      this.interpreter.CodeStack.Push(first);
-      this.interpreter.Run(new CodeCdrExpression());
-
-      Assert.AreEqual(result, this.interpreter.CodeStack.Top);
-      this.CheckOtherStacksAreEmpty();
+      interpreter.CodeStack.Push(first);
+      interpreter.Run(new CodeCdrExpression());
+
+      Assert.AreEqual(result, interpreter.CodeStack.Top);
+      CheckOtherStacksAreEmpty();
     }
 
@@ -185,9 +185,9 @@
       var result = PushParser.Parse("( )");
 
-      this.interpreter.CodeStack.Push(first);
-      this.interpreter.Run(new CodeCdrExpression());
-
-      Assert.AreEqual(result, this.interpreter.CodeStack.Top);
-      this.CheckOtherStacksAreEmpty();
+      interpreter.CodeStack.Push(first);
+      interpreter.Run(new CodeCdrExpression());
+
+      Assert.AreEqual(result, interpreter.CodeStack.Top);
+      CheckOtherStacksAreEmpty();
     }
 
@@ -201,9 +201,9 @@
       var result = PushParser.Parse("( A B C )");
 
-      this.interpreter.CodeStack.Push(second, first);
-      this.interpreter.Run(new CodeConsExpression());
-
-      Assert.AreEqual(result, this.interpreter.CodeStack.Top);
-      this.CheckOtherStacksAreEmpty();
+      interpreter.CodeStack.Push(second, first);
+      interpreter.Run(new CodeConsExpression());
+
+      Assert.AreEqual(result, interpreter.CodeStack.Top);
+      CheckOtherStacksAreEmpty();
     }
 
@@ -216,9 +216,9 @@
       var second = PushParser.Parse("( A B C )");
 
-      this.interpreter.CodeStack.Push(second, first);
-      this.interpreter.Run(new CodeContainsExpression());
-
-      Assert.AreEqual(true, this.interpreter.BooleanStack.Top);
-      this.TestStackCounts(booleanStack: 1);
+      interpreter.CodeStack.Push(second, first);
+      interpreter.Run(new CodeContainsExpression());
+
+      Assert.AreEqual(true, interpreter.BooleanStack.Top);
+      TestStackCounts(booleanStack: 1);
     }
 
@@ -231,9 +231,9 @@
       var second = PushParser.Parse("( A B C )");
 
-      this.interpreter.CodeStack.Push(second, first);
-      this.interpreter.Run(new CodeContainsExpression());
-
-      Assert.AreEqual(false, this.interpreter.BooleanStack.Top);
-      this.TestStackCounts(booleanStack: 1);
+      interpreter.CodeStack.Push(second, first);
+      interpreter.Run(new CodeContainsExpression());
+
+      Assert.AreEqual(false, interpreter.BooleanStack.Top);
+      TestStackCounts(booleanStack: 1);
     }
 
@@ -247,9 +247,9 @@
       var result = PushParser.Parse("( C ( A ) )");
 
-      this.interpreter.CodeStack.Push(second, first);
-      this.interpreter.Run(new CodeContainerExpression());
-
-      Assert.AreEqual(result, this.interpreter.CodeStack.Top);
-      this.CheckOtherStacksAreEmpty();
+      interpreter.CodeStack.Push(second, first);
+      interpreter.Run(new CodeContainerExpression());
+
+      Assert.AreEqual(result, interpreter.CodeStack.Top);
+      CheckOtherStacksAreEmpty();
     }
 
@@ -261,11 +261,11 @@
       var code = PushParser.Parse("( A )");
 
-      this.interpreter.CustomExpressions.Add("Test", code);
-      this.interpreter.NameStack.Push("Test");
-
-      this.interpreter.Run(new CodeDefinitionExpression());
-
-      Assert.AreEqual(code, this.interpreter.CodeStack.Top);
-      this.CheckOtherStacksAreEmpty();
+      interpreter.CustomExpressions.Add("Test", code);
+      interpreter.NameStack.Push("Test");
+
+      interpreter.Run(new CodeDefinitionExpression());
+
+      Assert.AreEqual(code, interpreter.CodeStack.Top);
+      CheckOtherStacksAreEmpty();
     }
 
@@ -278,9 +278,9 @@
       var program = new CodeDefinitionExpression();
 
-      this.interpreter.CustomExpressions.Add("Test1", code);
-      this.interpreter.NameStack.Push("Test2");
-      this.interpreter.Run(program);
-
-      this.TestStackCounts(nameStack: 1);
+      interpreter.CustomExpressions.Add("Test1", code);
+      interpreter.NameStack.Push("Test2");
+      interpreter.Run(program);
+
+      TestStackCounts(nameStack: 1);
     }
 
@@ -293,9 +293,9 @@
       var second = PushParser.Parse("( B C )");
 
-      this.interpreter.CodeStack.Push(second, first);
-      this.interpreter.Run(new CodeDiscrepancyExpression());
-
-      Assert.AreEqual(2, this.interpreter.IntegerStack.Top);
-      this.TestStackCounts(integerStack: 1);
+      interpreter.CodeStack.Push(second, first);
+      interpreter.Run(new CodeDiscrepancyExpression());
+
+      Assert.AreEqual(2, interpreter.IntegerStack.Top);
+      TestStackCounts(integerStack: 1);
     }
 
@@ -308,9 +308,9 @@
       var second = PushParser.Parse("( B A )");
 
-      this.interpreter.CodeStack.Push(second, first);
-      this.interpreter.Run(new CodeDiscrepancyExpression());
-
-      Assert.AreEqual(0, this.interpreter.IntegerStack.Top);
-      this.TestStackCounts(integerStack: 1);
+      interpreter.CodeStack.Push(second, first);
+      interpreter.Run(new CodeDiscrepancyExpression());
+
+      Assert.AreEqual(0, interpreter.IntegerStack.Top);
+      TestStackCounts(integerStack: 1);
     }
 
@@ -323,9 +323,9 @@
       var second = PushParser.Parse("( A A B D E )");
 
-      this.interpreter.CodeStack.Push(second, first);
-      this.interpreter.Run(new CodeDiscrepancyExpression());
-
-      Assert.AreEqual(3, this.interpreter.IntegerStack.Top);
-      this.TestStackCounts(integerStack: 1);
+      interpreter.CodeStack.Push(second, first);
+      interpreter.Run(new CodeDiscrepancyExpression());
+
+      Assert.AreEqual(3, interpreter.IntegerStack.Top);
+      TestStackCounts(integerStack: 1);
     }
 
@@ -338,9 +338,9 @@
       var second = PushParser.Parse("( A ( A ) B D E )");
 
-      this.interpreter.CodeStack.Push(second, first);
-      this.interpreter.Run(new CodeDiscrepancyExpression());
-
-      Assert.AreEqual(5, this.interpreter.IntegerStack.Top);
-      this.TestStackCounts(integerStack: 1);
+      interpreter.CodeStack.Push(second, first);
+      interpreter.Run(new CodeDiscrepancyExpression());
+
+      Assert.AreEqual(5, interpreter.IntegerStack.Top);
+      TestStackCounts(integerStack: 1);
     }
 
@@ -352,9 +352,9 @@
       var prog = PushParser.Parse("( 10 )");
 
-      this.interpreter.CodeStack.Push(prog);
-      this.interpreter.Run(new CodeDoExpression());
-
-      Assert.AreEqual(10, this.interpreter.IntegerStack.Top);
-      this.TestStackCounts(integerStack: 1);
+      interpreter.CodeStack.Push(prog);
+      interpreter.Run(new CodeDoExpression());
+
+      Assert.AreEqual(10, interpreter.IntegerStack.Top);
+      TestStackCounts(integerStack: 1);
     }
 
@@ -366,9 +366,9 @@
       var prog = PushParser.Parse("( 10 )");
 
-      this.interpreter.CodeStack.Push(prog);
-      this.interpreter.Run(new CodeDoXExpression());
-
-      Assert.AreEqual(10, this.interpreter.IntegerStack.Top);
-      this.TestStackCounts(integerStack: 1);
+      interpreter.CodeStack.Push(prog);
+      interpreter.Run(new CodeDoXExpression());
+
+      Assert.AreEqual(10, interpreter.IntegerStack.Top);
+      TestStackCounts(integerStack: 1);
     }
 
@@ -380,10 +380,10 @@
       var prog = PushParser.Parse("INTEGER.+");
 
-      this.interpreter.IntegerStack.Push(3);
-      this.interpreter.CodeStack.Push(prog);
-      this.interpreter.Run(new CodeDoCountExpression());
-
-      Assert.AreEqual(6, this.interpreter.IntegerStack.Top);
-      this.TestStackCounts(integerStack: 1);
+      interpreter.IntegerStack.Push(3);
+      interpreter.CodeStack.Push(prog);
+      interpreter.Run(new CodeDoCountExpression());
+
+      Assert.AreEqual(6, interpreter.IntegerStack.Top);
+      TestStackCounts(integerStack: 1);
     }
 
@@ -395,10 +395,10 @@
       var prog = PushParser.Parse("INTEGER.+");
 
-      this.interpreter.IntegerStack.Push(-1);
-      this.interpreter.CodeStack.Push(prog);
-      this.interpreter.Run(new CodeDoCountExpression());
-
-      Assert.AreEqual(-1, this.interpreter.IntegerStack.Top);
-      this.TestStackCounts(codeStack: 1, integerStack: 1);
+      interpreter.IntegerStack.Push(-1);
+      interpreter.CodeStack.Push(prog);
+      interpreter.Run(new CodeDoCountExpression());
+
+      Assert.AreEqual(-1, interpreter.IntegerStack.Top);
+      TestStackCounts(codeStack: 1, integerStack: 1);
     }
 
@@ -410,10 +410,10 @@
       var prog = PushParser.Parse("INTEGER.+");
 
-      this.interpreter.IntegerStack.Push(3, 5);
-      this.interpreter.CodeStack.Push(prog);
-      this.interpreter.Run(new CodeDoRangeExpression());
-
-      Assert.AreEqual(12, this.interpreter.IntegerStack.Top);
-      this.TestStackCounts(integerStack: 1);
+      interpreter.IntegerStack.Push(3, 5);
+      interpreter.CodeStack.Push(prog);
+      interpreter.Run(new CodeDoRangeExpression());
+
+      Assert.AreEqual(12, interpreter.IntegerStack.Top);
+      TestStackCounts(integerStack: 1);
     }
 
@@ -425,10 +425,10 @@
       var prog = PushParser.Parse("INTEGER.+");
 
-      this.interpreter.IntegerStack.Push(3, 3);
-      this.interpreter.CodeStack.Push(prog);
-      this.interpreter.Run(new CodeDoRangeExpression());
-
-      Assert.AreEqual(3, this.interpreter.IntegerStack.Top);
-      this.TestStackCounts(codeStack: 1, integerStack: 2);
+      interpreter.IntegerStack.Push(3, 3);
+      interpreter.CodeStack.Push(prog);
+      interpreter.Run(new CodeDoRangeExpression());
+
+      Assert.AreEqual(3, interpreter.IntegerStack.Top);
+      TestStackCounts(codeStack: 1, integerStack: 2);
     }
 
@@ -440,10 +440,10 @@
       var prog = PushParser.Parse("INTEGER.+");
 
-      this.interpreter.IntegerStack.Push(-3, -5);
-      this.interpreter.CodeStack.Push(prog);
-      this.interpreter.Run(new CodeDoRangeExpression());
-
-      Assert.AreEqual(-12, this.interpreter.IntegerStack.Top);
-      this.TestStackCounts(integerStack: 1);
+      interpreter.IntegerStack.Push(-3, -5);
+      interpreter.CodeStack.Push(prog);
+      interpreter.Run(new CodeDoRangeExpression());
+
+      Assert.AreEqual(-12, interpreter.IntegerStack.Top);
+      TestStackCounts(integerStack: 1);
     }
 
@@ -455,10 +455,10 @@
       var prog = PushParser.Parse("( INTEGER.DUP INTEGER.+ )");
 
-      this.interpreter.IntegerStack.Push(2, 3);
-      this.interpreter.CodeStack.Push(prog);
-      this.interpreter.Run(new CodeDoTimesExpression());
-
-      Assert.AreEqual(32, this.interpreter.IntegerStack.Top);
-      this.TestStackCounts(integerStack: 1);
+      interpreter.IntegerStack.Push(2, 3);
+      interpreter.CodeStack.Push(prog);
+      interpreter.Run(new CodeDoTimesExpression());
+
+      Assert.AreEqual(32, interpreter.IntegerStack.Top);
+      TestStackCounts(integerStack: 1);
     }
 
@@ -470,10 +470,10 @@
       var prog = PushParser.Parse("( INTEGER.DUP INTEGER.+ )");
 
-      this.interpreter.IntegerStack.Push(2, -3);
-      this.interpreter.CodeStack.Push(prog);
-      this.interpreter.Run(new CodeDoTimesExpression());
-
-      Assert.AreEqual(-3, this.interpreter.IntegerStack.Top);
-      this.TestStackCounts(codeStack: 1, integerStack: 2);
+      interpreter.IntegerStack.Push(2, -3);
+      interpreter.CodeStack.Push(prog);
+      interpreter.Run(new CodeDoTimesExpression());
+
+      Assert.AreEqual(-3, interpreter.IntegerStack.Top);
+      TestStackCounts(codeStack: 1, integerStack: 2);
     }
 
@@ -483,9 +483,9 @@
     [TestCategory("CodeExpressionTest")]
     public void TestNestedDoRange() {
-      this.interpreter.Run(
+      interpreter.Run(
         "( 0 2 CODE.QUOTE ( 1 INTEGER.+ 0 3 CODE.QUOTE ( 1 INTEGER.+ INTEGER.* ) CODE.DO*RANGE INTEGER.+ ) CODE.DO*RANGE )");
 
-      Assert.AreEqual(144, this.interpreter.IntegerStack.Top);
-      this.TestStackCounts(integerStack: 1);
+      Assert.AreEqual(144, interpreter.IntegerStack.Top);
+      TestStackCounts(integerStack: 1);
     }
 
@@ -495,9 +495,9 @@
     [TestCategory("CodeExpressionTest")]
     public void TestNestedDoCount() {
-      this.interpreter.Run(
+      interpreter.Run(
         "( 2 CODE.QUOTE ( 1 INTEGER.+ 3 CODE.QUOTE ( 1 INTEGER.+ INTEGER.* ) CODE.DO*COUNT INTEGER.+ ) CODE.DO*COUNT )");
 
-      Assert.AreEqual(144, this.interpreter.IntegerStack.Top);
-      this.TestStackCounts(integerStack: 1);
+      Assert.AreEqual(144, interpreter.IntegerStack.Top);
+      TestStackCounts(integerStack: 1);
     }
 
@@ -507,9 +507,9 @@
     [TestCategory("CodeExpressionTest")]
     public void TestNestedDoTimes() {
-      this.interpreter.Run(
+      interpreter.Run(
         "( 3 CODE.QUOTE ( 2 3 CODE.QUOTE ( 2 INTEGER.* ) CODE.DO*TIMES INTEGER.+ ) CODE.DO*TIMES )");
 
-      Assert.AreEqual(128, this.interpreter.IntegerStack.Top);
-      this.TestStackCounts(integerStack: 1);
+      Assert.AreEqual(128, interpreter.IntegerStack.Top);
+      TestStackCounts(integerStack: 1);
     }
 
@@ -522,10 +522,10 @@
       var result = PushParser.Parse("( D )");
 
-      this.interpreter.IntegerStack.Push(5);
-      this.interpreter.CodeStack.Push(prog);
-      this.interpreter.Run(new CodeExtractExpression());
-
-      Assert.AreEqual(result, this.interpreter.CodeStack.Top);
-      this.CheckOtherStacksAreEmpty();
+      interpreter.IntegerStack.Push(5);
+      interpreter.CodeStack.Push(prog);
+      interpreter.Run(new CodeExtractExpression());
+
+      Assert.AreEqual(result, interpreter.CodeStack.Top);
+      CheckOtherStacksAreEmpty();
     }
 
@@ -538,10 +538,10 @@
       var result = PushParser.Parse("5");
 
-      this.interpreter.IntegerStack.Push(3);
-      this.interpreter.CodeStack.Push(prog);
-      this.interpreter.Run(new CodeExtractExpression());
-
-      Assert.AreEqual(result, this.interpreter.CodeStack.Top);
-      this.CheckOtherStacksAreEmpty();
+      interpreter.IntegerStack.Push(3);
+      interpreter.CodeStack.Push(prog);
+      interpreter.Run(new CodeExtractExpression());
+
+      Assert.AreEqual(result, interpreter.CodeStack.Top);
+      CheckOtherStacksAreEmpty();
     }
 
@@ -554,10 +554,10 @@
       var result = PushParser.Parse("4.2");
 
-      this.interpreter.IntegerStack.Push(6);
-      this.interpreter.CodeStack.Push(prog);
-      this.interpreter.Run(new CodeExtractExpression());
-
-      Assert.AreEqual(result, this.interpreter.CodeStack.Top);
-      this.CheckOtherStacksAreEmpty();
+      interpreter.IntegerStack.Push(6);
+      interpreter.CodeStack.Push(prog);
+      interpreter.Run(new CodeExtractExpression());
+
+      Assert.AreEqual(result, interpreter.CodeStack.Top);
+      CheckOtherStacksAreEmpty();
     }
 
@@ -570,10 +570,10 @@
       var result = PushParser.Parse("FALSE");
 
-      this.interpreter.IntegerStack.Push(8);
-      this.interpreter.CodeStack.Push(prog);
-      this.interpreter.Run(new CodeExtractExpression());
-
-      Assert.AreEqual(result, this.interpreter.CodeStack.Top);
-      this.CheckOtherStacksAreEmpty();
+      interpreter.IntegerStack.Push(8);
+      interpreter.CodeStack.Push(prog);
+      interpreter.Run(new CodeExtractExpression());
+
+      Assert.AreEqual(result, interpreter.CodeStack.Top);
+      CheckOtherStacksAreEmpty();
     }
 
@@ -586,10 +586,10 @@
       var result = PushParser.Parse("INTEGER.+");
 
-      this.interpreter.IntegerStack.Push(7);
-      this.interpreter.CodeStack.Push(prog);
-      this.interpreter.Run(new CodeExtractExpression());
-
-      Assert.AreEqual(result, this.interpreter.CodeStack.Top);
-      this.CheckOtherStacksAreEmpty();
+      interpreter.IntegerStack.Push(7);
+      interpreter.CodeStack.Push(prog);
+      interpreter.Run(new CodeExtractExpression());
+
+      Assert.AreEqual(result, interpreter.CodeStack.Top);
+      CheckOtherStacksAreEmpty();
     }
 
@@ -600,9 +600,9 @@
     public void TestFromBoolean() {
       var result = PushParser.Parse("FALSE");
-      this.interpreter.BooleanStack.Push(false);
-      this.interpreter.Run(new CodeFromBooleanExpression());
-
-      Assert.AreEqual(result, this.interpreter.CodeStack.Top);
-      this.CheckOtherStacksAreEmpty();
+      interpreter.BooleanStack.Push(false);
+      interpreter.Run(new CodeFromBooleanExpression());
+
+      Assert.AreEqual(result, interpreter.CodeStack.Top);
+      CheckOtherStacksAreEmpty();
     }
 
@@ -613,9 +613,9 @@
     public void TestFromFloat() {
       var result = PushParser.Parse("4.1");
-      this.interpreter.FloatStack.Push(4.1);
-      this.interpreter.Run(new CodeFromFloatExpression());
-
-      Assert.AreEqual(result, this.interpreter.CodeStack.Top);
-      this.CheckOtherStacksAreEmpty();
+      interpreter.FloatStack.Push(4.1);
+      interpreter.Run(new CodeFromFloatExpression());
+
+      Assert.AreEqual(result, interpreter.CodeStack.Top);
+      CheckOtherStacksAreEmpty();
     }
 
@@ -626,9 +626,9 @@
     public void TestFromInteger() {
       var result = PushParser.Parse("4");
-      this.interpreter.IntegerStack.Push(4);
-      this.interpreter.Run(new CodeFromIntegerExpression());
-
-      Assert.AreEqual(result, this.interpreter.CodeStack.Top);
-      this.CheckOtherStacksAreEmpty();
+      interpreter.IntegerStack.Push(4);
+      interpreter.Run(new CodeFromIntegerExpression());
+
+      Assert.AreEqual(result, interpreter.CodeStack.Top);
+      CheckOtherStacksAreEmpty();
     }
 
@@ -639,9 +639,9 @@
     public void TestFromName() {
       var result = PushParser.Parse("A");
-      this.interpreter.NameStack.Push("A");
-      this.interpreter.Run(new CodeFromNameExpression());
-
-      Assert.AreEqual(result, this.interpreter.CodeStack.Top);
-      this.CheckOtherStacksAreEmpty();
+      interpreter.NameStack.Push("A");
+      interpreter.Run(new CodeFromNameExpression());
+
+      Assert.AreEqual(result, interpreter.CodeStack.Top);
+      CheckOtherStacksAreEmpty();
     }
 
@@ -654,10 +654,10 @@
       var second = PushParser.Parse("WAHR");
 
-      this.interpreter.BooleanStack.Push(true);
-      this.interpreter.CodeStack.Push(second, first);
-      this.interpreter.Run(new CodeIfExpression());
-
-      Assert.AreEqual("WAHR", this.interpreter.NameStack.Top);
-      this.TestStackCounts(nameStack: 1);
+      interpreter.BooleanStack.Push(true);
+      interpreter.CodeStack.Push(second, first);
+      interpreter.Run(new CodeIfExpression());
+
+      Assert.AreEqual("WAHR", interpreter.NameStack.Top);
+      TestStackCounts(nameStack: 1);
     }
 
@@ -670,10 +670,10 @@
       var second = PushParser.Parse("WAHR");
 
-      this.interpreter.BooleanStack.Push(false);
-      this.interpreter.CodeStack.Push(second, first);
-      this.interpreter.Run(new CodeIfExpression());
-
-      Assert.AreEqual("FALSCH", this.interpreter.NameStack.Top);
-      this.TestStackCounts(nameStack: 1);
+      interpreter.BooleanStack.Push(false);
+      interpreter.CodeStack.Push(second, first);
+      interpreter.Run(new CodeIfExpression());
+
+      Assert.AreEqual("FALSCH", interpreter.NameStack.Top);
+      TestStackCounts(nameStack: 1);
     }
 
@@ -687,10 +687,10 @@
       var result = PushParser.Parse("( A ( B ) ( E ) D )");
 
-      this.interpreter.IntegerStack.Push(2);
-      this.interpreter.CodeStack.Push(second, first);
-      this.interpreter.Run(new CodeInsertExpression());
-
-      Assert.AreEqual(result, this.interpreter.CodeStack.Top);
-      this.CheckOtherStacksAreEmpty();
+      interpreter.IntegerStack.Push(2);
+      interpreter.CodeStack.Push(second, first);
+      interpreter.Run(new CodeInsertExpression());
+
+      Assert.AreEqual(result, interpreter.CodeStack.Top);
+      CheckOtherStacksAreEmpty();
     }
 
@@ -704,10 +704,10 @@
       var result = PushParser.Parse("( A ( B ) ( E ) D )");
 
-      this.interpreter.IntegerStack.Push(-2);
-      this.interpreter.CodeStack.Push(second, first);
-      this.interpreter.Run(new CodeInsertExpression());
-
-      Assert.AreEqual(result, this.interpreter.CodeStack.Top);
-      this.CheckOtherStacksAreEmpty();
+      interpreter.IntegerStack.Push(-2);
+      interpreter.CodeStack.Push(second, first);
+      interpreter.Run(new CodeInsertExpression());
+
+      Assert.AreEqual(result, interpreter.CodeStack.Top);
+      CheckOtherStacksAreEmpty();
     }
 
@@ -721,10 +721,10 @@
       var result = PushParser.Parse("( A ( B ) ( E ) D )");
 
-      this.interpreter.IntegerStack.Push(10);
-      this.interpreter.CodeStack.Push(second, first);
-      this.interpreter.Run(new CodeInsertExpression());
-
-      Assert.AreEqual(result, this.interpreter.CodeStack.Top);
-      this.CheckOtherStacksAreEmpty();
+      interpreter.IntegerStack.Push(10);
+      interpreter.CodeStack.Push(second, first);
+      interpreter.Run(new CodeInsertExpression());
+
+      Assert.AreEqual(result, interpreter.CodeStack.Top);
+      CheckOtherStacksAreEmpty();
     }
 
@@ -738,9 +738,9 @@
       var result = PushParser.Parse("( A ( B ) )");
 
-      this.interpreter.CodeStack.Push(second, first);
-      this.interpreter.Run(new CodeListExpression());
-
-      Assert.AreEqual(result, this.interpreter.CodeStack.Top);
-      this.CheckOtherStacksAreEmpty();
+      interpreter.CodeStack.Push(second, first);
+      interpreter.Run(new CodeListExpression());
+
+      Assert.AreEqual(result, interpreter.CodeStack.Top);
+      CheckOtherStacksAreEmpty();
     }
 
@@ -753,9 +753,9 @@
       var second = PushParser.Parse("( B )");
 
-      this.interpreter.CodeStack.Push(second, first);
-      this.interpreter.Run(new CodeMemberExpression());
-
-      Assert.AreEqual(true, this.interpreter.BooleanStack.Top);
-      this.TestStackCounts(booleanStack: 1);
+      interpreter.CodeStack.Push(second, first);
+      interpreter.Run(new CodeMemberExpression());
+
+      Assert.AreEqual(true, interpreter.BooleanStack.Top);
+      TestStackCounts(booleanStack: 1);
     }
 
@@ -768,9 +768,9 @@
       var second = PushParser.Parse("( B )");
 
-      this.interpreter.CodeStack.Push(second, first);
-      this.interpreter.Run(new CodeMemberExpression());
-
-      Assert.AreEqual(false, this.interpreter.BooleanStack.Top);
-      this.TestStackCounts(booleanStack: 1);
+      interpreter.CodeStack.Push(second, first);
+      interpreter.Run(new CodeMemberExpression());
+
+      Assert.AreEqual(false, interpreter.BooleanStack.Top);
+      TestStackCounts(booleanStack: 1);
     }
 
@@ -783,9 +783,9 @@
       var second = PushParser.Parse("B");
 
-      this.interpreter.CodeStack.Push(second, first);
-      this.interpreter.Run(new CodeMemberExpression());
-
-      Assert.AreEqual(true, this.interpreter.BooleanStack.Top);
-      this.TestStackCounts(booleanStack: 1);
+      interpreter.CodeStack.Push(second, first);
+      interpreter.Run(new CodeMemberExpression());
+
+      Assert.AreEqual(true, interpreter.BooleanStack.Top);
+      TestStackCounts(booleanStack: 1);
     }
 
@@ -795,7 +795,7 @@
     [TestCategory("CodeExpressionTest")]
     public void TestNoop() {
-      this.interpreter.Run(new CodeNoopExpression());
-
-      this.CheckOtherStacksAreEmpty();
+      interpreter.Run(new CodeNoopExpression());
+
+      CheckOtherStacksAreEmpty();
     }
 
@@ -808,10 +808,10 @@
       var result = PushParser.Parse("A");
 
-      this.interpreter.IntegerStack.Push(3);
-      this.interpreter.CodeStack.Push(prog);
-      this.interpreter.Run(new CodeNthExpression());
-
-      Assert.AreEqual(result, this.interpreter.CodeStack.Top);
-      this.CheckOtherStacksAreEmpty();
+      interpreter.IntegerStack.Push(3);
+      interpreter.CodeStack.Push(prog);
+      interpreter.Run(new CodeNthExpression());
+
+      Assert.AreEqual(result, interpreter.CodeStack.Top);
+      CheckOtherStacksAreEmpty();
     }
 
@@ -824,10 +824,10 @@
       var result = PushParser.Parse("( )");
 
-      this.interpreter.IntegerStack.Push(3);
-      this.interpreter.CodeStack.Push(prog);
-      this.interpreter.Run(new CodeNthExpression());
-
-      Assert.AreEqual(result, this.interpreter.CodeStack.Top);
-      this.CheckOtherStacksAreEmpty();
+      interpreter.IntegerStack.Push(3);
+      interpreter.CodeStack.Push(prog);
+      interpreter.Run(new CodeNthExpression());
+
+      Assert.AreEqual(result, interpreter.CodeStack.Top);
+      CheckOtherStacksAreEmpty();
     }
 
@@ -840,10 +840,10 @@
       var result = PushParser.Parse("D");
 
-      this.interpreter.IntegerStack.Push(3);
-      this.interpreter.CodeStack.Push(prog);
-      this.interpreter.Run(new CodeNthExpression());
-
-      Assert.AreEqual(result, this.interpreter.CodeStack.Top);
-      this.CheckOtherStacksAreEmpty();
+      interpreter.IntegerStack.Push(3);
+      interpreter.CodeStack.Push(prog);
+      interpreter.Run(new CodeNthExpression());
+
+      Assert.AreEqual(result, interpreter.CodeStack.Top);
+      CheckOtherStacksAreEmpty();
     }
 
@@ -856,10 +856,10 @@
       var result = PushParser.Parse("D");
 
-      this.interpreter.IntegerStack.Push(13);
-      this.interpreter.CodeStack.Push(prog);
-      this.interpreter.Run(new CodeNthExpression());
-
-      Assert.AreEqual(result, this.interpreter.CodeStack.Top);
-      this.CheckOtherStacksAreEmpty();
+      interpreter.IntegerStack.Push(13);
+      interpreter.CodeStack.Push(prog);
+      interpreter.Run(new CodeNthExpression());
+
+      Assert.AreEqual(result, interpreter.CodeStack.Top);
+      CheckOtherStacksAreEmpty();
     }
 
@@ -872,10 +872,10 @@
       var result = PushParser.Parse("D");
 
-      this.interpreter.IntegerStack.Push(-3);
-      this.interpreter.CodeStack.Push(prog);
-      this.interpreter.Run(new CodeNthExpression());
-
-      Assert.AreEqual(result, this.interpreter.CodeStack.Top);
-      this.CheckOtherStacksAreEmpty();
+      interpreter.IntegerStack.Push(-3);
+      interpreter.CodeStack.Push(prog);
+      interpreter.Run(new CodeNthExpression());
+
+      Assert.AreEqual(result, interpreter.CodeStack.Top);
+      CheckOtherStacksAreEmpty();
     }
 
@@ -888,10 +888,10 @@
       var result = PushParser.Parse("D");
 
-      this.interpreter.IntegerStack.Push(2);
-      this.interpreter.CodeStack.Push(prog);
-      this.interpreter.Run(new CodeNthCdrExpression());
-
-      Assert.AreEqual(result, this.interpreter.CodeStack.Top);
-      this.CheckOtherStacksAreEmpty();
+      interpreter.IntegerStack.Push(2);
+      interpreter.CodeStack.Push(prog);
+      interpreter.Run(new CodeNthCdrExpression());
+
+      Assert.AreEqual(result, interpreter.CodeStack.Top);
+      CheckOtherStacksAreEmpty();
     }
 
@@ -904,10 +904,10 @@
       var result = PushParser.Parse("D");
 
-      this.interpreter.IntegerStack.Push(10);
-      this.interpreter.CodeStack.Push(prog);
-      this.interpreter.Run(new CodeNthCdrExpression());
-
-      Assert.AreEqual(result, this.interpreter.CodeStack.Top);
-      this.CheckOtherStacksAreEmpty();
+      interpreter.IntegerStack.Push(10);
+      interpreter.CodeStack.Push(prog);
+      interpreter.Run(new CodeNthCdrExpression());
+
+      Assert.AreEqual(result, interpreter.CodeStack.Top);
+      CheckOtherStacksAreEmpty();
     }
 
@@ -920,10 +920,10 @@
       var result = PushParser.Parse("D");
 
-      this.interpreter.IntegerStack.Push(-2);
-      this.interpreter.CodeStack.Push(prog);
-      this.interpreter.Run(new CodeNthCdrExpression());
-
-      Assert.AreEqual(result, this.interpreter.CodeStack.Top);
-      this.CheckOtherStacksAreEmpty();
+      interpreter.IntegerStack.Push(-2);
+      interpreter.CodeStack.Push(prog);
+      interpreter.Run(new CodeNthCdrExpression());
+
+      Assert.AreEqual(result, interpreter.CodeStack.Top);
+      CheckOtherStacksAreEmpty();
     }
 
@@ -936,10 +936,10 @@
       var result = PushParser.Parse("( )");
 
-      this.interpreter.IntegerStack.Push(3);
-      this.interpreter.CodeStack.Push(prog);
-      this.interpreter.Run(new CodeNthCdrExpression());
-
-      Assert.AreEqual(result, this.interpreter.CodeStack.Top);
-      this.CheckOtherStacksAreEmpty();
+      interpreter.IntegerStack.Push(3);
+      interpreter.CodeStack.Push(prog);
+      interpreter.Run(new CodeNthCdrExpression());
+
+      Assert.AreEqual(result, interpreter.CodeStack.Top);
+      CheckOtherStacksAreEmpty();
     }
 
@@ -952,10 +952,10 @@
       var result = PushParser.Parse("A");
 
-      this.interpreter.IntegerStack.Push(3);
-      this.interpreter.CodeStack.Push(prog);
-      this.interpreter.Run(new CodeNthCdrExpression());
-
-      Assert.AreEqual(result, this.interpreter.CodeStack.Top);
-      this.CheckOtherStacksAreEmpty();
+      interpreter.IntegerStack.Push(3);
+      interpreter.CodeStack.Push(prog);
+      interpreter.Run(new CodeNthCdrExpression());
+
+      Assert.AreEqual(result, interpreter.CodeStack.Top);
+      CheckOtherStacksAreEmpty();
     }
 
@@ -967,9 +967,9 @@
       var prog = PushParser.Parse("( )");
 
-      this.interpreter.CodeStack.Push(prog);
-      this.interpreter.Run(new CodeNullExpression());
-
-      Assert.AreEqual(true, this.interpreter.BooleanStack.Top);
-      this.TestStackCounts(booleanStack: 1);
+      interpreter.CodeStack.Push(prog);
+      interpreter.Run(new CodeNullExpression());
+
+      Assert.AreEqual(true, interpreter.BooleanStack.Top);
+      TestStackCounts(booleanStack: 1);
     }
 
@@ -981,9 +981,9 @@
       var prog = PushParser.Parse("A");
 
-      this.interpreter.CodeStack.Push(prog);
-      this.interpreter.Run(new CodeNullExpression());
-
-      Assert.AreEqual(false, this.interpreter.BooleanStack.Top);
-      this.TestStackCounts(booleanStack: 1);
+      interpreter.CodeStack.Push(prog);
+      interpreter.Run(new CodeNullExpression());
+
+      Assert.AreEqual(false, interpreter.BooleanStack.Top);
+      TestStackCounts(booleanStack: 1);
     }
 
@@ -996,9 +996,9 @@
       var second = PushParser.Parse("C");
 
-      this.interpreter.CodeStack.Push(second, first);
-      this.interpreter.Run(new CodePositionExpression());
-
-      Assert.AreEqual(2, this.interpreter.IntegerStack.Top);
-      this.TestStackCounts(integerStack: 1);
+      interpreter.CodeStack.Push(second, first);
+      interpreter.Run(new CodePositionExpression());
+
+      Assert.AreEqual(2, interpreter.IntegerStack.Top);
+      TestStackCounts(integerStack: 1);
     }
 
@@ -1010,8 +1010,8 @@
       var result = PushParser.Parse("A");
 
-      this.interpreter.Run("( CODE.QUOTE A )");
-
-      Assert.AreEqual(result, this.interpreter.CodeStack.Top);
-      this.CheckOtherStacksAreEmpty();
+      interpreter.Run("( CODE.QUOTE A )");
+
+      Assert.AreEqual(result, interpreter.CodeStack.Top);
+      CheckOtherStacksAreEmpty();
     }
 
@@ -1023,9 +1023,9 @@
       var prog = PushParser.Parse("( A ( B ( C ) ) ( D ) INTEGER.+ )");
 
-      this.interpreter.CodeStack.Push(prog);
-      this.interpreter.Run(new CodeSizeExpression());
-
-      Assert.AreEqual(4, this.interpreter.IntegerStack.Top);
-      this.TestStackCounts(integerStack: 1);
+      interpreter.CodeStack.Push(prog);
+      interpreter.Run(new CodeSizeExpression());
+
+      Assert.AreEqual(4, interpreter.IntegerStack.Top);
+      TestStackCounts(integerStack: 1);
     }
 
@@ -1040,9 +1040,9 @@
       var result = PushParser.Parse("( E B C D E B C D )");
 
-      this.interpreter.CodeStack.Push(third, second, first);
-      this.interpreter.Run(new CodeSubstitutionExpression());
-
-      Assert.AreEqual(result, this.interpreter.CodeStack.Top);
-      this.CheckOtherStacksAreEmpty();
+      interpreter.CodeStack.Push(third, second, first);
+      interpreter.Run(new CodeSubstitutionExpression());
+
+      Assert.AreEqual(result, interpreter.CodeStack.Top);
+      CheckOtherStacksAreEmpty();
     }
 
@@ -1060,5 +1060,5 @@
 
     protected override void CheckOtherStacksAreEmpty() {
-      this.TestStackCounts(codeStack: null);
+      TestStackCounts(codeStack: null);
     }
   }
Index: branches/PushGP/HeuristicLab.PushGP/HeuristicLab.Tests/Interpreter/Expressions/CommonTests.cs
===================================================================
--- branches/PushGP/HeuristicLab.PushGP/HeuristicLab.Tests/Interpreter/Expressions/CommonTests.cs	(revision 14907)
+++ branches/PushGP/HeuristicLab.PushGP/HeuristicLab.Tests/Interpreter/Expressions/CommonTests.cs	(revision 14908)
@@ -15,9 +15,9 @@
 
     protected virtual T[] Get2Different() {
-      return this.GetValues(2);
+      return GetValues(2);
     }
 
     protected virtual void Test(Expression expression) {
-      this.interpreter.Run(expression);
+      interpreter.Run(expression);
     }
 
@@ -29,17 +29,17 @@
     [TestCategory("CommonExpressionTest")]
     public virtual void TestEqualsTrue() {
-      var values = this.GetValues(1);
+      var values = GetValues(1);
       var merged = new[] { values[0], values[0] };
 
-      this.Stack.Push(merged);
-
-      var isBooleanStack = this.interpreter.BooleanStack.Count == 2;
-
-      this.Test(ExpressionTable.GetStatelessExpression(this.TypeName + ".="));
-
-      if (isBooleanStack) Assert.AreEqual(1, this.Stack.Count);
-      else Assert.AreEqual(0, this.Stack.Count);
-
-      Assert.IsTrue(this.interpreter.BooleanStack.Top);
+      Stack.Push(merged);
+
+      var isBooleanStack = interpreter.BooleanStack.Count == 2;
+
+      Test(ExpressionTable.GetStatelessExpression(TypeName + ".="));
+
+      if (isBooleanStack) Assert.AreEqual(1, Stack.Count);
+      else Assert.AreEqual(0, Stack.Count);
+
+      Assert.IsTrue(interpreter.BooleanStack.Top);
     }
 
@@ -49,14 +49,14 @@
     [TestCategory("CommonExpressionTest")]
     public virtual void TestEqualsFalse() {
-      var values = this.Get2Different();
-      this.Stack.Push(values);
-      var isBooleanStack = this.interpreter.BooleanStack.Count == 2;
-
-      this.Test(ExpressionTable.GetStatelessExpression(this.TypeName + ".="));
-
-      if (isBooleanStack) Assert.AreEqual(1, this.Stack.Count);
-      else Assert.AreEqual(0, this.Stack.Count);
-
-      Assert.IsFalse(this.interpreter.BooleanStack.Top);
+      var values = Get2Different();
+      Stack.Push(values);
+      var isBooleanStack = interpreter.BooleanStack.Count == 2;
+
+      Test(ExpressionTable.GetStatelessExpression(TypeName + ".="));
+
+      if (isBooleanStack) Assert.AreEqual(1, Stack.Count);
+      else Assert.AreEqual(0, Stack.Count);
+
+      Assert.IsFalse(interpreter.BooleanStack.Top);
     }
 
@@ -66,5 +66,5 @@
     [TestCategory("CommonExpressionTest")]
     public virtual void TestEqualsWithInsufficientArguments() {
-      this.TestWithInsufficientArguments("=", 1);
+      TestWithInsufficientArguments("=", 1);
     }
 
@@ -74,13 +74,13 @@
     [TestCategory("CommonExpressionTest")]
     public virtual void TestDuplicate() {
-      var values = this.GetValues(1);
-      this.Stack.Push(values);
-
-      this.Test(ExpressionTable.GetStatelessExpression(this.TypeName + ".DUP"));
-
-      Assert.AreEqual(this.Stack.Count, 2);
-      Assert.AreEqual(this.Stack[0], values[0]);
-      Assert.AreEqual(this.Stack[1], values[0]);
-      this.CheckOtherStacksAreEmpty();
+      var values = GetValues(1);
+      Stack.Push(values);
+
+      Test(ExpressionTable.GetStatelessExpression(TypeName + ".DUP"));
+
+      Assert.AreEqual(Stack.Count, 2);
+      Assert.AreEqual(Stack[0], values[0]);
+      Assert.AreEqual(Stack[1], values[0]);
+      CheckOtherStacksAreEmpty();
     }
 
@@ -90,10 +90,10 @@
     [TestCategory("CommonExpressionTest")]
     public virtual void TestPop() {
-      var values = this.GetValues(2);
-      this.Stack.Push(values);
-
-      this.Test(ExpressionTable.GetStatelessExpression(this.TypeName + ".POP"));
-
-      this.CheckOtherStacksAreEmpty();
+      var values = GetValues(2);
+      Stack.Push(values);
+
+      Test(ExpressionTable.GetStatelessExpression(TypeName + ".POP"));
+
+      CheckOtherStacksAreEmpty();
     }
 
@@ -103,14 +103,14 @@
     [TestCategory("CommonExpressionTest")]
     public virtual void TestSwap() {
-      var values = this.GetValues(3);
-      this.Stack.Push(values);
-
-      this.Test(ExpressionTable.GetStatelessExpression(this.TypeName + ".SWAP"));
-
-      Assert.AreEqual(values[0], this.Stack[2]);
-      Assert.AreEqual(values[1], this.Stack[0]);
-      Assert.AreEqual(values[2], this.Stack[1]);
-
-      this.CheckOtherStacksAreEmpty();
+      var values = GetValues(3);
+      Stack.Push(values);
+
+      Test(ExpressionTable.GetStatelessExpression(TypeName + ".SWAP"));
+
+      Assert.AreEqual(values[0], Stack[2]);
+      Assert.AreEqual(values[1], Stack[0]);
+      Assert.AreEqual(values[2], Stack[1]);
+
+      CheckOtherStacksAreEmpty();
     }
 
@@ -120,5 +120,5 @@
     [TestCategory("CommonExpressionTest")]
     public virtual void TestSwapWithInsufficientArguments() {
-      this.TestWithInsufficientArguments("SWAP", 1);
+      TestWithInsufficientArguments("SWAP", 1);
     }
 
@@ -138,5 +138,5 @@
       Assert.AreEqual(values[2], Stack[0]);
 
-      this.CheckOtherStacksAreEmpty();
+      CheckOtherStacksAreEmpty();
     }
 
@@ -146,5 +146,5 @@
     [TestCategory("CommonExpressionTest")]
     public virtual void TestRotateWithInsufficientArguments() {
-      this.TestWithInsufficientArguments("ROT", 2);
+      TestWithInsufficientArguments("ROT", 2);
     }
 
@@ -154,15 +154,15 @@
     [TestCategory("CommonExpressionTest")]
     public virtual void TestShove() {
-      var values = this.GetValues(3);
-      this.Stack.Push(values);
-
-      this.interpreter.IntegerStack.Push(1);
-      this.Test(ExpressionTable.GetStatelessExpression(this.TypeName + ".SHOVE"));
-
-      Assert.AreEqual(values[0], Stack[2]);
-      Assert.AreEqual(values[1], Stack[0]);
-      Assert.AreEqual(values[2], Stack[1]);
-
-      this.CheckOtherStacksAreEmpty();
+      var values = GetValues(3);
+      Stack.Push(values);
+
+      interpreter.IntegerStack.Push(1);
+      Test(ExpressionTable.GetStatelessExpression(TypeName + ".SHOVE"));
+
+      Assert.AreEqual(values[0], Stack[2]);
+      Assert.AreEqual(values[1], Stack[0]);
+      Assert.AreEqual(values[2], Stack[1]);
+
+      CheckOtherStacksAreEmpty();
     }
 
@@ -172,5 +172,5 @@
     [TestCategory("CommonExpressionTest")]
     public virtual void TestShoveWithInsufficientArguments() {
-      this.TestWithInsufficientArguments("SHOVE", 1);
+      TestWithInsufficientArguments("SHOVE", 1);
     }
 
@@ -180,15 +180,15 @@
     [TestCategory("CommonExpressionTest")]
     public virtual void TestShoveWithNegativeIndex() {
-      var values = this.GetValues(3);
-      this.Stack.Push(values);
-
-      this.interpreter.IntegerStack.Push(-1);
-      this.Test(ExpressionTable.GetStatelessExpression(this.TypeName + ".SHOVE"));
-
-      Assert.AreEqual(values[0], Stack[2]);
-      Assert.AreEqual(values[1], Stack[0]);
-      Assert.AreEqual(values[2], Stack[1]);
-
-      this.CheckOtherStacksAreEmpty();
+      var values = GetValues(3);
+      Stack.Push(values);
+
+      interpreter.IntegerStack.Push(-1);
+      Test(ExpressionTable.GetStatelessExpression(TypeName + ".SHOVE"));
+
+      Assert.AreEqual(values[0], Stack[2]);
+      Assert.AreEqual(values[1], Stack[0]);
+      Assert.AreEqual(values[2], Stack[1]);
+
+      CheckOtherStacksAreEmpty();
     }
 
@@ -198,15 +198,15 @@
     [TestCategory("CommonExpressionTest")]
     public virtual void TestYank() {
-      var values = this.GetValues(3);
-      this.Stack.Push(values);
-
-      this.interpreter.IntegerStack.Push(1);
-      this.Test(ExpressionTable.GetStatelessExpression(this.TypeName + ".YANK"));
-
-      Assert.AreEqual(values[0], Stack[2]);
-      Assert.AreEqual(values[1], Stack[0]);
-      Assert.AreEqual(values[2], Stack[1]);
-
-      this.CheckOtherStacksAreEmpty();
+      var values = GetValues(3);
+      Stack.Push(values);
+
+      interpreter.IntegerStack.Push(1);
+      Test(ExpressionTable.GetStatelessExpression(TypeName + ".YANK"));
+
+      Assert.AreEqual(values[0], Stack[2]);
+      Assert.AreEqual(values[1], Stack[0]);
+      Assert.AreEqual(values[2], Stack[1]);
+
+      CheckOtherStacksAreEmpty();
     }
 
@@ -216,5 +216,5 @@
     [TestCategory("CommonExpressionTest")]
     public virtual void TestYankWithInsufficientArguments() {
-      this.TestWithInsufficientArguments("YANK", 1);
+      TestWithInsufficientArguments("YANK", 1);
     }
 
@@ -224,15 +224,15 @@
     [TestCategory("CommonExpressionTest")]
     public virtual void TestYankWithNegativeIndex() {
-      var values = this.GetValues(3);
-      this.Stack.Push(values);
-
-      this.interpreter.IntegerStack.Push(-1);
-      this.Test(ExpressionTable.GetStatelessExpression(this.TypeName + ".YANK"));
-
-      Assert.AreEqual(values[0], Stack[2]);
-      Assert.AreEqual(values[1], Stack[0]);
-      Assert.AreEqual(values[2], Stack[1]);
-
-      this.CheckOtherStacksAreEmpty();
+      var values = GetValues(3);
+      Stack.Push(values);
+
+      interpreter.IntegerStack.Push(-1);
+      Test(ExpressionTable.GetStatelessExpression(TypeName + ".YANK"));
+
+      Assert.AreEqual(values[0], Stack[2]);
+      Assert.AreEqual(values[1], Stack[0]);
+      Assert.AreEqual(values[2], Stack[1]);
+
+      CheckOtherStacksAreEmpty();
     }
 
@@ -242,16 +242,16 @@
     [TestCategory("CommonExpressionTest")]
     public virtual void TestYankDuplicate() {
-      var values = this.GetValues(3);
-      this.Stack.Push(values);
-
-      this.interpreter.IntegerStack.Push(1);
-      this.Test(ExpressionTable.GetStatelessExpression(this.TypeName + ".YANKDUP"));
-
-      Assert.AreEqual(values[0], this.Stack[3]);
-      Assert.AreEqual(values[1], this.Stack[2]);
-      Assert.AreEqual(values[2], this.Stack[1]);
-      Assert.AreEqual(values[1], this.Stack[0]);
-
-      this.CheckOtherStacksAreEmpty();
+      var values = GetValues(3);
+      Stack.Push(values);
+
+      interpreter.IntegerStack.Push(1);
+      Test(ExpressionTable.GetStatelessExpression(TypeName + ".YANKDUP"));
+
+      Assert.AreEqual(values[0], Stack[3]);
+      Assert.AreEqual(values[1], Stack[2]);
+      Assert.AreEqual(values[2], Stack[1]);
+      Assert.AreEqual(values[1], Stack[0]);
+
+      CheckOtherStacksAreEmpty();
     }
 
@@ -261,5 +261,5 @@
     [TestCategory("CommonExpressionTest")]
     public virtual void TestYankDuplicateWithInsufficientArguments() {
-      this.TestWithInsufficientArguments("YANKDUP", 1);
+      TestWithInsufficientArguments("YANKDUP", 1);
     }
 
@@ -269,16 +269,16 @@
     [TestCategory("CommonExpressionTest")]
     public virtual void TestYankDuplicateWithNegativeIndex() {
-      var values = this.GetValues(3);
-      this.Stack.Push(values);
-
-      this.interpreter.IntegerStack.Push(-1);
-      this.Test(ExpressionTable.GetStatelessExpression(this.TypeName + ".YANKDUP"));
-
-      Assert.AreEqual(values[0], this.Stack[3]);
-      Assert.AreEqual(values[1], this.Stack[2]);
-      Assert.AreEqual(values[2], this.Stack[1]);
-      Assert.AreEqual(values[1], this.Stack[0]);
-
-      this.CheckOtherStacksAreEmpty();
+      var values = GetValues(3);
+      Stack.Push(values);
+
+      interpreter.IntegerStack.Push(-1);
+      Test(ExpressionTable.GetStatelessExpression(TypeName + ".YANKDUP"));
+
+      Assert.AreEqual(values[0], Stack[3]);
+      Assert.AreEqual(values[1], Stack[2]);
+      Assert.AreEqual(values[2], Stack[1]);
+      Assert.AreEqual(values[1], Stack[0]);
+
+      CheckOtherStacksAreEmpty();
     }
 
@@ -288,16 +288,16 @@
     [TestCategory("CommonExpressionTest")]
     public virtual void TestStackdpeth() {
-      var values = this.GetValues(3);
-      this.Stack.Push(values);
-
-      this.Test(ExpressionTable.GetStatelessExpression(this.TypeName + ".STACKDEPTH"));
+      var values = GetValues(3);
+      Stack.Push(values);
+
+      Test(ExpressionTable.GetStatelessExpression(TypeName + ".STACKDEPTH"));
 
       // if stack is integer stack
-      if (this.Stack.Count != values.Length) {
-        Assert.AreEqual(4, this.Stack.Count);
-        this.CheckOtherStacksAreEmpty();
+      if (Stack.Count != values.Length) {
+        Assert.AreEqual(4, Stack.Count);
+        CheckOtherStacksAreEmpty();
       } else {
-        Assert.AreEqual(3, this.Stack.Count);
-        Assert.AreEqual(values.Length, this.interpreter.IntegerStack.Top);
+        Assert.AreEqual(3, Stack.Count);
+        Assert.AreEqual(values.Length, interpreter.IntegerStack.Top);
       }
     }
@@ -305,25 +305,25 @@
     protected void TestWithInsufficientArguments(string instructionName, int argCount = 0) {
       for (var i = 0; i < argCount + 1; i++) {
-        var values = this.GetValues(i);
-        this.Stack.Push(values);
-
-        var fullInstructionName = string.Format(FullInstructionNameFormat, this.TypeName, instructionName);
-        this.Test(ExpressionTable.GetStatelessExpression(fullInstructionName));
-
-        for (var j = 0; j < i; j++) Assert.AreEqual(values[j], this.Stack.ReverseElementAt(j));
-
-        this.CheckOtherStacksAreEmpty();
-        this.interpreter.Clear();
+        var values = GetValues(i);
+        Stack.Push(values);
+
+        var fullInstructionName = string.Format(FullInstructionNameFormat, TypeName, instructionName);
+        Test(ExpressionTable.GetStatelessExpression(fullInstructionName));
+
+        for (var j = 0; j < i; j++) Assert.AreEqual(values[j], Stack.ReverseElementAt(j));
+
+        CheckOtherStacksAreEmpty();
+        interpreter.Clear();
       }
     }
 
     protected void TestWithNegativeIndex(string instructionName) {
-      var values = this.GetValues(3);
-      this.Stack.Push(values);
-
-      this.interpreter.IntegerStack.Push(-1);
-
-      var fullInstructionname = string.Format(FullInstructionNameFormat, this.TypeName, instructionName);
-      this.Test(ExpressionTable.GetStatelessExpression(fullInstructionname));
+      var values = GetValues(3);
+      Stack.Push(values);
+
+      interpreter.IntegerStack.Push(-1);
+
+      var fullInstructionname = string.Format(FullInstructionNameFormat, TypeName, instructionName);
+      Test(ExpressionTable.GetStatelessExpression(fullInstructionname));
 
       Assert.AreEqual(values[0], Stack[2]);
Index: branches/PushGP/HeuristicLab.PushGP/HeuristicLab.Tests/Interpreter/Expressions/ExampleTests.cs
===================================================================
--- branches/PushGP/HeuristicLab.PushGP/HeuristicLab.Tests/Interpreter/Expressions/ExampleTests.cs	(revision 14907)
+++ branches/PushGP/HeuristicLab.PushGP/HeuristicLab.Tests/Interpreter/Expressions/ExampleTests.cs	(revision 14908)
@@ -12,12 +12,12 @@
     [TestCategory("ExampleTest")]
     public void Example1() {
-      this.interpreter.Run("( 2 3 INTEGER.* 4.1 5.2 FLOAT.+ TRUE FALSE BOOLEAN.OR )");
-
-      Assert.AreEqual(6, this.interpreter.IntegerStack.Top);
-      Assert.AreEqual(9.3, this.interpreter.FloatStack.Top);
-      Assert.IsTrue(this.interpreter.BooleanStack.Top);
-      Assert.IsTrue(this.interpreter.CodeStack.IsEmpty);
-      Assert.IsTrue(this.interpreter.ExecStack.IsEmpty);
-      Assert.IsTrue(this.interpreter.NameStack.IsEmpty);
+      interpreter.Run("( 2 3 INTEGER.* 4.1 5.2 FLOAT.+ TRUE FALSE BOOLEAN.OR )");
+
+      Assert.AreEqual(6, interpreter.IntegerStack.Top);
+      Assert.AreEqual(9.3, interpreter.FloatStack.Top);
+      Assert.IsTrue(interpreter.BooleanStack.Top);
+      Assert.IsTrue(interpreter.CodeStack.IsEmpty);
+      Assert.IsTrue(interpreter.ExecStack.IsEmpty);
+      Assert.IsTrue(interpreter.NameStack.IsEmpty);
     }
 
@@ -26,12 +26,12 @@
     [TestCategory("ExampleTest")]
     public void Example2() {
-      this.interpreter.Run("( 5 1.23 INTEGER.+ ( 4 ) INTEGER.- 5.67 FLOAT.* )");
-
-      Assert.AreEqual(1, this.interpreter.IntegerStack.Top);
-      Assert.AreEqual(6.9741, this.interpreter.FloatStack.Top);
-      Assert.IsTrue(this.interpreter.CodeStack.IsEmpty);
-      Assert.IsTrue(this.interpreter.BooleanStack.IsEmpty);
-      Assert.IsTrue(this.interpreter.ExecStack.IsEmpty);
-      Assert.IsTrue(this.interpreter.NameStack.IsEmpty);
+      interpreter.Run("( 5 1.23 INTEGER.+ ( 4 ) INTEGER.- 5.67 FLOAT.* )");
+
+      Assert.AreEqual(1, interpreter.IntegerStack.Top);
+      Assert.AreEqual(6.9741, interpreter.FloatStack.Top);
+      Assert.IsTrue(interpreter.CodeStack.IsEmpty);
+      Assert.IsTrue(interpreter.BooleanStack.IsEmpty);
+      Assert.IsTrue(interpreter.ExecStack.IsEmpty);
+      Assert.IsTrue(interpreter.NameStack.IsEmpty);
     }
 
@@ -40,12 +40,12 @@
     [TestCategory("ExampleTest")]
     public void Example3() {
-      this.interpreter.Run("( 5 INTEGER.DUP INTEGER.+ )");
-
-      Assert.AreEqual(10, this.interpreter.IntegerStack.Top);
-      Assert.IsTrue(this.interpreter.CodeStack.IsEmpty);
-      Assert.IsTrue(this.interpreter.ExecStack.IsEmpty);
-      Assert.IsTrue(this.interpreter.NameStack.IsEmpty);
-      Assert.IsTrue(this.interpreter.BooleanStack.IsEmpty);
-      Assert.IsTrue(this.interpreter.FloatStack.IsEmpty);
+      interpreter.Run("( 5 INTEGER.DUP INTEGER.+ )");
+
+      Assert.AreEqual(10, interpreter.IntegerStack.Top);
+      Assert.IsTrue(interpreter.CodeStack.IsEmpty);
+      Assert.IsTrue(interpreter.ExecStack.IsEmpty);
+      Assert.IsTrue(interpreter.NameStack.IsEmpty);
+      Assert.IsTrue(interpreter.BooleanStack.IsEmpty);
+      Assert.IsTrue(interpreter.FloatStack.IsEmpty);
     }
 
@@ -54,12 +54,12 @@
     [TestCategory("ExampleTest")]
     public void Example4() {
-      this.interpreter.Run("( 5 CODE.QUOTE ( INTEGER.DUP INTEGER.+ ) CODE.DO )");
-
-      Assert.AreEqual(10, this.interpreter.IntegerStack.Top);
-      Assert.IsTrue(this.interpreter.CodeStack.IsEmpty);
-      Assert.IsTrue(this.interpreter.ExecStack.IsEmpty);
-      Assert.IsTrue(this.interpreter.NameStack.IsEmpty);
-      Assert.IsTrue(this.interpreter.BooleanStack.IsEmpty);
-      Assert.IsTrue(this.interpreter.FloatStack.IsEmpty);
+      interpreter.Run("( 5 CODE.QUOTE ( INTEGER.DUP INTEGER.+ ) CODE.DO )");
+
+      Assert.AreEqual(10, interpreter.IntegerStack.Top);
+      Assert.IsTrue(interpreter.CodeStack.IsEmpty);
+      Assert.IsTrue(interpreter.ExecStack.IsEmpty);
+      Assert.IsTrue(interpreter.NameStack.IsEmpty);
+      Assert.IsTrue(interpreter.BooleanStack.IsEmpty);
+      Assert.IsTrue(interpreter.FloatStack.IsEmpty);
     }
 
@@ -68,12 +68,12 @@
     [TestCategory("ExampleTest")]
     public void Example5() {
-      this.interpreter.Run("( DOUBLE CODE.QUOTE ( INTEGER.DUP INTEGER.+ ) CODE.DEFINE 5 DOUBLE )");
-
-      Assert.AreEqual(10, this.interpreter.IntegerStack.Top);
-      Assert.IsTrue(this.interpreter.CodeStack.IsEmpty);
-      Assert.IsTrue(this.interpreter.ExecStack.IsEmpty);
-      Assert.IsTrue(this.interpreter.NameStack.IsEmpty);
-      Assert.IsTrue(this.interpreter.BooleanStack.IsEmpty);
-      Assert.IsTrue(this.interpreter.FloatStack.IsEmpty);
+      interpreter.Run("( DOUBLE CODE.QUOTE ( INTEGER.DUP INTEGER.+ ) CODE.DEFINE 5 DOUBLE )");
+
+      Assert.AreEqual(10, interpreter.IntegerStack.Top);
+      Assert.IsTrue(interpreter.CodeStack.IsEmpty);
+      Assert.IsTrue(interpreter.ExecStack.IsEmpty);
+      Assert.IsTrue(interpreter.NameStack.IsEmpty);
+      Assert.IsTrue(interpreter.BooleanStack.IsEmpty);
+      Assert.IsTrue(interpreter.FloatStack.IsEmpty);
     }
 
@@ -82,12 +82,12 @@
     [TestCategory("ExampleTest")]
     public void Example6() {
-      this.interpreter.Run("( CODE.QUOTE ( INTEGER.DUP INTEGER.+ ) DOUBLE CODE.DEFINE 5 DOUBLE )");
-
-      Assert.AreEqual(10, this.interpreter.IntegerStack.Top);
-      Assert.IsTrue(this.interpreter.CodeStack.IsEmpty);
-      Assert.IsTrue(this.interpreter.ExecStack.IsEmpty);
-      Assert.IsTrue(this.interpreter.NameStack.IsEmpty);
-      Assert.IsTrue(this.interpreter.BooleanStack.IsEmpty);
-      Assert.IsTrue(this.interpreter.FloatStack.IsEmpty);
+      interpreter.Run("( CODE.QUOTE ( INTEGER.DUP INTEGER.+ ) DOUBLE CODE.DEFINE 5 DOUBLE )");
+
+      Assert.AreEqual(10, interpreter.IntegerStack.Top);
+      Assert.IsTrue(interpreter.CodeStack.IsEmpty);
+      Assert.IsTrue(interpreter.ExecStack.IsEmpty);
+      Assert.IsTrue(interpreter.NameStack.IsEmpty);
+      Assert.IsTrue(interpreter.BooleanStack.IsEmpty);
+      Assert.IsTrue(interpreter.FloatStack.IsEmpty);
     }
 
@@ -96,12 +96,12 @@
     [TestCategory("ExampleTest")]
     public void Example7() {
-      this.interpreter.Run("( DOUBLE EXEC.DEFINE ( INTEGER.DUP INTEGER.+ ) 5 DOUBLE )");
-
-      Assert.AreEqual(10, this.interpreter.IntegerStack.Top);
-      Assert.IsTrue(this.interpreter.CodeStack.IsEmpty);
-      Assert.IsTrue(this.interpreter.ExecStack.IsEmpty);
-      Assert.IsTrue(this.interpreter.NameStack.IsEmpty);
-      Assert.IsTrue(this.interpreter.BooleanStack.IsEmpty);
-      Assert.IsTrue(this.interpreter.FloatStack.IsEmpty);
+      interpreter.Run("( DOUBLE EXEC.DEFINE ( INTEGER.DUP INTEGER.+ ) 5 DOUBLE )");
+
+      Assert.AreEqual(10, interpreter.IntegerStack.Top);
+      Assert.IsTrue(interpreter.CodeStack.IsEmpty);
+      Assert.IsTrue(interpreter.ExecStack.IsEmpty);
+      Assert.IsTrue(interpreter.NameStack.IsEmpty);
+      Assert.IsTrue(interpreter.BooleanStack.IsEmpty);
+      Assert.IsTrue(interpreter.FloatStack.IsEmpty);
     }
 
@@ -110,17 +110,17 @@
     [TestCategory("ExampleTest")]
     public void Example8() {
-      this.configuration.TopLevelPushCode = true;
-
-      this.interpreter.IntegerStack.Push(5);
-      this.interpreter.Run(@"( CODE.QUOTE ( INTEGER.POP 1 )
+      configuration.TopLevelPushCode = true;
+
+      interpreter.IntegerStack.Push(5);
+      interpreter.Run(@"( CODE.QUOTE ( INTEGER.POP 1 )
                                            CODE.QUOTE ( CODE.DUP INTEGER.DUP 1 INTEGER.- CODE.DO INTEGER.* )
                                            INTEGER.DUP 2 INTEGER.< CODE.IF )");
 
-      Assert.AreEqual(120, this.interpreter.IntegerStack.Top);
-      Assert.IsTrue(this.interpreter.CodeStack.Count == 1);
-      Assert.IsTrue(this.interpreter.ExecStack.IsEmpty);
-      Assert.IsTrue(this.interpreter.NameStack.IsEmpty);
-      Assert.IsTrue(this.interpreter.BooleanStack.IsEmpty);
-      Assert.IsTrue(this.interpreter.FloatStack.IsEmpty);
+      Assert.AreEqual(120, interpreter.IntegerStack.Top);
+      Assert.IsTrue(interpreter.CodeStack.Count == 1);
+      Assert.IsTrue(interpreter.ExecStack.IsEmpty);
+      Assert.IsTrue(interpreter.NameStack.IsEmpty);
+      Assert.IsTrue(interpreter.BooleanStack.IsEmpty);
+      Assert.IsTrue(interpreter.FloatStack.IsEmpty);
     }
 
@@ -129,13 +129,13 @@
     [TestCategory("ExampleTest")]
     public void Example9() {
-      this.interpreter.IntegerStack.Push(5);
-      this.interpreter.Run("( 1 INTEGER.MAX 1 EXEC.DO*RANGE INTEGER.* )");
-
-      Assert.AreEqual(120, this.interpreter.IntegerStack.Top);
-      Assert.IsTrue(this.interpreter.CodeStack.IsEmpty);
-      Assert.IsTrue(this.interpreter.ExecStack.IsEmpty);
-      Assert.IsTrue(this.interpreter.NameStack.IsEmpty);
-      Assert.IsTrue(this.interpreter.BooleanStack.IsEmpty);
-      Assert.IsTrue(this.interpreter.FloatStack.IsEmpty);
+      interpreter.IntegerStack.Push(5);
+      interpreter.Run("( 1 INTEGER.MAX 1 EXEC.DO*RANGE INTEGER.* )");
+
+      Assert.AreEqual(120, interpreter.IntegerStack.Top);
+      Assert.IsTrue(interpreter.CodeStack.IsEmpty);
+      Assert.IsTrue(interpreter.ExecStack.IsEmpty);
+      Assert.IsTrue(interpreter.NameStack.IsEmpty);
+      Assert.IsTrue(interpreter.BooleanStack.IsEmpty);
+      Assert.IsTrue(interpreter.FloatStack.IsEmpty);
     }
 
@@ -144,13 +144,13 @@
     [TestCategory("ExampleTest")]
     public void Example10() {
-      this.interpreter.IntegerStack.Push(5);
-      this.interpreter.Run("( 1 INTEGER.MAX 1 EXEC.DO*RANGE ( 2 INTEGER.* ) )");
-
-      Assert.AreEqual(2, this.interpreter.IntegerStack.Top);
-      Assert.IsTrue(this.interpreter.CodeStack.IsEmpty);
-      Assert.IsTrue(this.interpreter.ExecStack.IsEmpty);
-      Assert.IsTrue(this.interpreter.NameStack.IsEmpty);
-      Assert.IsTrue(this.interpreter.BooleanStack.IsEmpty);
-      Assert.IsTrue(this.interpreter.FloatStack.IsEmpty);
+      interpreter.IntegerStack.Push(5);
+      interpreter.Run("( 1 INTEGER.MAX 1 EXEC.DO*RANGE ( 2 INTEGER.* ) )");
+
+      Assert.AreEqual(2, interpreter.IntegerStack.Top);
+      Assert.IsTrue(interpreter.CodeStack.IsEmpty);
+      Assert.IsTrue(interpreter.ExecStack.IsEmpty);
+      Assert.IsTrue(interpreter.NameStack.IsEmpty);
+      Assert.IsTrue(interpreter.BooleanStack.IsEmpty);
+      Assert.IsTrue(interpreter.FloatStack.IsEmpty);
     }
 
@@ -161,27 +161,27 @@
       var program = PushParser.Parse("( INTEGER.= CODE.QUOTE FLOAT.* CODE.QUOTE FLOAT./ CODE.IF )");
 
-      this.interpreter.IntegerStack.Push(1, 1);
-      this.interpreter.FloatStack.Push(2.1, 0.7);
-
-      this.interpreter.Run(program);
-
-      Assert.IsTrue(this.interpreter.IntegerStack.IsEmpty);
-      Assert.AreEqual(1.47, this.interpreter.FloatStack.Top, Delta);
-      Assert.IsTrue(this.interpreter.CodeStack.IsEmpty);
-      Assert.IsTrue(this.interpreter.ExecStack.IsEmpty);
-      Assert.IsTrue(this.interpreter.NameStack.IsEmpty);
-      Assert.IsTrue(this.interpreter.BooleanStack.IsEmpty);
-
-      this.interpreter.Clear();
-      this.interpreter.IntegerStack.Push(1, 2);
-      this.interpreter.FloatStack.Push(2.1, 0.7);
-      this.interpreter.Run(program);
-
-      Assert.IsTrue(this.interpreter.IntegerStack.IsEmpty);
-      Assert.AreEqual(3d, this.interpreter.FloatStack.Top, Delta);
-      Assert.IsTrue(this.interpreter.CodeStack.IsEmpty);
-      Assert.IsTrue(this.interpreter.ExecStack.IsEmpty);
-      Assert.IsTrue(this.interpreter.NameStack.IsEmpty);
-      Assert.IsTrue(this.interpreter.BooleanStack.IsEmpty);
+      interpreter.IntegerStack.Push(1, 1);
+      interpreter.FloatStack.Push(2.1, 0.7);
+
+      interpreter.Run(program);
+
+      Assert.IsTrue(interpreter.IntegerStack.IsEmpty);
+      Assert.AreEqual(1.47, interpreter.FloatStack.Top, Delta);
+      Assert.IsTrue(interpreter.CodeStack.IsEmpty);
+      Assert.IsTrue(interpreter.ExecStack.IsEmpty);
+      Assert.IsTrue(interpreter.NameStack.IsEmpty);
+      Assert.IsTrue(interpreter.BooleanStack.IsEmpty);
+
+      interpreter.Clear();
+      interpreter.IntegerStack.Push(1, 2);
+      interpreter.FloatStack.Push(2.1, 0.7);
+      interpreter.Run(program);
+
+      Assert.IsTrue(interpreter.IntegerStack.IsEmpty);
+      Assert.AreEqual(3d, interpreter.FloatStack.Top, Delta);
+      Assert.IsTrue(interpreter.CodeStack.IsEmpty);
+      Assert.IsTrue(interpreter.ExecStack.IsEmpty);
+      Assert.IsTrue(interpreter.NameStack.IsEmpty);
+      Assert.IsTrue(interpreter.BooleanStack.IsEmpty);
     }
 
@@ -192,27 +192,27 @@
       var program = PushParser.Parse("( INTEGER.= EXEC.IF FLOAT.* FLOAT./ )");
 
-      this.interpreter.IntegerStack.Push(1, 1);
-      this.interpreter.FloatStack.Push(2.1, 0.7);
-
-      this.interpreter.Run(program);
-
-      Assert.IsTrue(this.interpreter.IntegerStack.IsEmpty);
-      Assert.AreEqual(1.47, this.interpreter.FloatStack.Top, Delta);
-      Assert.IsTrue(this.interpreter.CodeStack.IsEmpty);
-      Assert.IsTrue(this.interpreter.ExecStack.IsEmpty);
-      Assert.IsTrue(this.interpreter.NameStack.IsEmpty);
-      Assert.IsTrue(this.interpreter.BooleanStack.IsEmpty);
-
-      this.interpreter.Clear();
-      this.interpreter.IntegerStack.Push(1, 2);
-      this.interpreter.FloatStack.Push(2.1, 0.7);
-      this.interpreter.Run(program);
-
-      Assert.IsTrue(this.interpreter.IntegerStack.IsEmpty);
-      Assert.AreEqual(3d, this.interpreter.FloatStack.Top, Delta);
-      Assert.IsTrue(this.interpreter.CodeStack.IsEmpty);
-      Assert.IsTrue(this.interpreter.ExecStack.IsEmpty);
-      Assert.IsTrue(this.interpreter.NameStack.IsEmpty);
-      Assert.IsTrue(this.interpreter.BooleanStack.IsEmpty);
+      interpreter.IntegerStack.Push(1, 1);
+      interpreter.FloatStack.Push(2.1, 0.7);
+
+      interpreter.Run(program);
+
+      Assert.IsTrue(interpreter.IntegerStack.IsEmpty);
+      Assert.AreEqual(1.47, interpreter.FloatStack.Top, Delta);
+      Assert.IsTrue(interpreter.CodeStack.IsEmpty);
+      Assert.IsTrue(interpreter.ExecStack.IsEmpty);
+      Assert.IsTrue(interpreter.NameStack.IsEmpty);
+      Assert.IsTrue(interpreter.BooleanStack.IsEmpty);
+
+      interpreter.Clear();
+      interpreter.IntegerStack.Push(1, 2);
+      interpreter.FloatStack.Push(2.1, 0.7);
+      interpreter.Run(program);
+
+      Assert.IsTrue(interpreter.IntegerStack.IsEmpty);
+      Assert.AreEqual(3d, interpreter.FloatStack.Top, Delta);
+      Assert.IsTrue(interpreter.CodeStack.IsEmpty);
+      Assert.IsTrue(interpreter.ExecStack.IsEmpty);
+      Assert.IsTrue(interpreter.NameStack.IsEmpty);
+      Assert.IsTrue(interpreter.BooleanStack.IsEmpty);
     }
 
@@ -221,13 +221,13 @@
     [TestCategory("ExampleTest")]
     public void Example13() {
-      this.interpreter.IntegerStack.Push(5);
-      this.interpreter.Run("( EXEC.Y ( ( FALSE 2 INTEGER.* ) EXEC.IF ( ) EXEC.POP ) )");
-
-      Assert.AreEqual(10, this.interpreter.IntegerStack.Top);
-      Assert.IsTrue(this.interpreter.CodeStack.IsEmpty);
-      Assert.IsTrue(this.interpreter.ExecStack.IsEmpty);
-      Assert.IsTrue(this.interpreter.NameStack.IsEmpty);
-      Assert.IsTrue(this.interpreter.BooleanStack.IsEmpty);
-      Assert.IsTrue(this.interpreter.FloatStack.IsEmpty);
+      interpreter.IntegerStack.Push(5);
+      interpreter.Run("( EXEC.Y ( ( FALSE 2 INTEGER.* ) EXEC.IF ( ) EXEC.POP ) )");
+
+      Assert.AreEqual(10, interpreter.IntegerStack.Top);
+      Assert.IsTrue(interpreter.CodeStack.IsEmpty);
+      Assert.IsTrue(interpreter.ExecStack.IsEmpty);
+      Assert.IsTrue(interpreter.NameStack.IsEmpty);
+      Assert.IsTrue(interpreter.BooleanStack.IsEmpty);
+      Assert.IsTrue(interpreter.FloatStack.IsEmpty);
     }
 
@@ -236,13 +236,13 @@
     [TestCategory("ExampleTest")]
     public void Example14() {
-      this.interpreter.IntegerStack.Push(5);
-      this.interpreter.Run("( EXEC.Y ( ( 2 INTEGER.* INTEGER.DUP 1000 INTEGER.< ) EXEC.IF ( ) EXEC.POP ) )");
-
-      Assert.AreEqual(1280, this.interpreter.IntegerStack.Top);
-      Assert.IsTrue(this.interpreter.CodeStack.IsEmpty);
-      Assert.IsTrue(this.interpreter.ExecStack.IsEmpty);
-      Assert.IsTrue(this.interpreter.NameStack.IsEmpty);
-      Assert.IsTrue(this.interpreter.BooleanStack.IsEmpty);
-      Assert.IsTrue(this.interpreter.FloatStack.IsEmpty);
+      interpreter.IntegerStack.Push(5);
+      interpreter.Run("( EXEC.Y ( ( 2 INTEGER.* INTEGER.DUP 1000 INTEGER.< ) EXEC.IF ( ) EXEC.POP ) )");
+
+      Assert.AreEqual(1280, interpreter.IntegerStack.Top);
+      Assert.IsTrue(interpreter.CodeStack.IsEmpty);
+      Assert.IsTrue(interpreter.ExecStack.IsEmpty);
+      Assert.IsTrue(interpreter.NameStack.IsEmpty);
+      Assert.IsTrue(interpreter.BooleanStack.IsEmpty);
+      Assert.IsTrue(interpreter.FloatStack.IsEmpty);
     }
 
@@ -251,7 +251,7 @@
     [TestCategory("ExampleTest")]
     public void Example15() {
-      this.interpreter.IntegerStack.Push(10);
-      this.interpreter.FloatStack.Push(2);
-      this.interpreter.Run(@"( ARG FLOAT.DEFINE
+      interpreter.IntegerStack.Push(10);
+      interpreter.FloatStack.Push(2);
+      interpreter.Run(@"( ARG FLOAT.DEFINE
                                      EXEC.Y (
                                        ARG FLOAT.*
@@ -262,10 +262,10 @@
                                    )");
 
-      Assert.AreEqual(1024, this.interpreter.FloatStack.Top, Delta);
-      Assert.AreEqual(1, this.interpreter.IntegerStack.Top);
-      Assert.IsTrue(this.interpreter.CodeStack.IsEmpty);
-      Assert.IsTrue(this.interpreter.ExecStack.IsEmpty);
-      Assert.IsTrue(this.interpreter.NameStack.IsEmpty);
-      Assert.IsTrue(this.interpreter.BooleanStack.IsEmpty);
+      Assert.AreEqual(1024, interpreter.FloatStack.Top, Delta);
+      Assert.AreEqual(1, interpreter.IntegerStack.Top);
+      Assert.IsTrue(interpreter.CodeStack.IsEmpty);
+      Assert.IsTrue(interpreter.ExecStack.IsEmpty);
+      Assert.IsTrue(interpreter.NameStack.IsEmpty);
+      Assert.IsTrue(interpreter.BooleanStack.IsEmpty);
     }
 
@@ -276,8 +276,8 @@
       var list = PushParser.Parse("( A B C )");
 
-      this.interpreter.CodeStack.Push(list);
-      this.interpreter.Run("( CODE.DUP 0 CODE.INSERT )");
-
-      var id = this.interpreter.CodeStack.Top.GetHashCode();
+      interpreter.CodeStack.Push(list);
+      interpreter.Run("( CODE.DUP 0 CODE.INSERT )");
+
+      var id = interpreter.CodeStack.Top.GetHashCode();
 
       if (id == default(int)) Assert.Fail();
Index: branches/PushGP/HeuristicLab.PushGP/HeuristicLab.Tests/Interpreter/Expressions/ExecExpressionTests.cs
===================================================================
--- branches/PushGP/HeuristicLab.PushGP/HeuristicLab.Tests/Interpreter/Expressions/ExecExpressionTests.cs	(revision 14907)
+++ branches/PushGP/HeuristicLab.PushGP/HeuristicLab.Tests/Interpreter/Expressions/ExecExpressionTests.cs	(revision 14908)
@@ -20,11 +20,11 @@
       get
       {
-        return this.interpreter.ExecStack;
+        return interpreter.ExecStack;
       }
     }
 
     protected override void Test(Expression expression) {
-      this.interpreter.Run(expression, true);
-      this.interpreter.Step();
+      interpreter.Run(expression, true);
+      interpreter.Step();
     }
 
@@ -34,9 +34,9 @@
     [TestCategory("ExecExpressionTest")]
     public void TestIfTrue() {
-      this.interpreter.BooleanStack.Push(true);
-      this.interpreter.Run("( EXEC.IF WAHR FALSCH )");
+      interpreter.BooleanStack.Push(true);
+      interpreter.Run("( EXEC.IF WAHR FALSCH )");
 
-      Assert.AreEqual("WAHR", this.interpreter.NameStack.Top);
-      this.TestStackCounts(nameStack: 1);
+      Assert.AreEqual("WAHR", interpreter.NameStack.Top);
+      TestStackCounts(nameStack: 1);
     }
 
@@ -46,9 +46,9 @@
     [TestCategory("ExecExpressionTest")]
     public void TestIfFalse() {
-      this.interpreter.BooleanStack.Push(false);
-      this.interpreter.Run("( EXEC.IF WAHR FALSCH )");
+      interpreter.BooleanStack.Push(false);
+      interpreter.Run("( EXEC.IF WAHR FALSCH )");
 
-      Assert.AreEqual("FALSCH", this.interpreter.NameStack.Top);
-      this.TestStackCounts(nameStack: 1);
+      Assert.AreEqual("FALSCH", interpreter.NameStack.Top);
+      TestStackCounts(nameStack: 1);
     }
 
@@ -80,11 +80,11 @@
       var result = PushParser.Parse("( B C )");
 
-      this.interpreter.ExecStack.Push(third, second, first);
-      this.Test(new ExecSExpression());
+      interpreter.ExecStack.Push(third, second, first);
+      Test(new ExecSExpression());
 
-      Assert.AreEqual(result, this.interpreter.ExecStack[2]);
-      Assert.AreEqual(third, this.interpreter.ExecStack[1]);
-      Assert.AreEqual(first, this.interpreter.ExecStack.Top);
-      this.TestStackCounts(3);
+      Assert.AreEqual(result, interpreter.ExecStack[2]);
+      Assert.AreEqual(third, interpreter.ExecStack[1]);
+      Assert.AreEqual(first, interpreter.ExecStack.Top);
+      TestStackCounts(3);
     }
 
@@ -97,10 +97,10 @@
       var result = PushParser.Parse("( EXEC.Y A )");
 
-      this.interpreter.ExecStack.Push(first);
-      this.Test(new ExecYExpression());
+      interpreter.ExecStack.Push(first);
+      Test(new ExecYExpression());
 
-      Assert.AreEqual(first, this.interpreter.ExecStack.Top);
-      Assert.AreEqual(result, this.interpreter.ExecStack[1]);
-      this.TestStackCounts(2);
+      Assert.AreEqual(first, interpreter.ExecStack.Top);
+      Assert.AreEqual(result, interpreter.ExecStack[1]);
+      TestStackCounts(2);
     }
 
@@ -110,9 +110,9 @@
     [TestCategory("ExecExpressionTest")]
     public void TestNestedDoRange() {
-      this.interpreter.Run(
+      interpreter.Run(
         "( 0 2 EXEC.DO*RANGE ( 1 INTEGER.+ 0 3 EXEC.DO*RANGE ( 1 INTEGER.+ INTEGER.* ) INTEGER.+ )");
 
-      Assert.AreEqual(144, this.interpreter.IntegerStack.Top);
-      this.TestStackCounts(integerStack: 1);
+      Assert.AreEqual(144, interpreter.IntegerStack.Top);
+      TestStackCounts(integerStack: 1);
     }
 
@@ -122,9 +122,9 @@
     [TestCategory("ExecExpressionTest")]
     public void TestNestedDoCount() {
-      this.interpreter.Run(
+      interpreter.Run(
         "( 2 EXEC.DO*COUNT ( 1 INTEGER.+ 3 EXEC.DO*COUNT ( 1 INTEGER.+ INTEGER.* ) INTEGER.+ )");
 
-      Assert.AreEqual(144, this.interpreter.IntegerStack.Top);
-      this.TestStackCounts(integerStack: 1);
+      Assert.AreEqual(144, interpreter.IntegerStack.Top);
+      TestStackCounts(integerStack: 1);
     }
 
@@ -134,8 +134,8 @@
     [TestCategory("ExecExpressionTest")]
     public void TestNestedDoTimes() {
-      this.interpreter.Run("( 3 EXEC.DO*TIMES ( 2 3 EXEC.DO*TIMES ( 2 INTEGER.* ) INTEGER.+ )");
+      interpreter.Run("( 3 EXEC.DO*TIMES ( 2 3 EXEC.DO*TIMES ( 2 INTEGER.* ) INTEGER.+ )");
 
-      Assert.AreEqual(128, this.interpreter.IntegerStack.Top);
-      this.TestStackCounts(integerStack: 1);
+      Assert.AreEqual(128, interpreter.IntegerStack.Top);
+      TestStackCounts(integerStack: 1);
     }
 
@@ -153,5 +153,5 @@
 
     protected override void CheckOtherStacksAreEmpty() {
-      this.TestStackCounts(null);
+      TestStackCounts(null);
     }
   }
Index: branches/PushGP/HeuristicLab.PushGP/HeuristicLab.Tests/Interpreter/Expressions/FloatExpressionTests.cs
===================================================================
--- branches/PushGP/HeuristicLab.PushGP/HeuristicLab.Tests/Interpreter/Expressions/FloatExpressionTests.cs	(revision 14907)
+++ branches/PushGP/HeuristicLab.PushGP/HeuristicLab.Tests/Interpreter/Expressions/FloatExpressionTests.cs	(revision 14908)
@@ -23,5 +23,5 @@
       get
       {
-        return this.interpreter.FloatStack;
+        return interpreter.FloatStack;
       }
     }
@@ -32,10 +32,10 @@
     [TestCategory("FloatExpressionTest")]
     public void TestAdd() {
-      this.interpreter.FloatStack.Push(5.3, 5.3);
-      this.interpreter.Run(new FloatAddExpression());
-
-      Assert.AreEqual(10.6, this.interpreter.FloatStack.Top, delta);
-
-      this.TestStackCounts(floatStack: 1);
+      interpreter.FloatStack.Push(5.3, 5.3);
+      interpreter.Run(new FloatAddExpression());
+
+      Assert.AreEqual(10.6, interpreter.FloatStack.Top, delta);
+
+      TestStackCounts(floatStack: 1);
     }
 
@@ -45,5 +45,5 @@
     [TestCategory("FloatExpressionTest")]
     public void TestAddWithInsufficientArguments() {
-      this.TestWithInsufficientArguments("+", 1);
+      TestWithInsufficientArguments("+", 1);
     }
 
@@ -53,10 +53,10 @@
     [TestCategory("FloatExpressionTest")]
     public void TestSubtract() {
-      this.interpreter.FloatStack.Push(10.2, 5.3);
-      this.interpreter.Run(new FloatSubtractExpression());
-
-      Assert.AreEqual(4.9, this.interpreter.FloatStack.Top, delta);
-
-      this.TestStackCounts(floatStack: 1);
+      interpreter.FloatStack.Push(10.2, 5.3);
+      interpreter.Run(new FloatSubtractExpression());
+
+      Assert.AreEqual(4.9, interpreter.FloatStack.Top, delta);
+
+      TestStackCounts(floatStack: 1);
     }
 
@@ -66,5 +66,5 @@
     [TestCategory("FloatExpressionTest")]
     public void TestSubractWithInsufficientArguments() {
-      this.TestWithInsufficientArguments("-", 1);
+      TestWithInsufficientArguments("-", 1);
     }
 
@@ -74,10 +74,10 @@
     [TestCategory("FloatExpressionTest")]
     public void TestMultiply() {
-      this.interpreter.FloatStack.Push(9.9, 3.3);
-      this.interpreter.Run(new FloatMultiplyExpression());
-
-      Assert.AreEqual(32.67, this.interpreter.FloatStack.Top, delta);
-
-      this.TestStackCounts(floatStack: 1);
+      interpreter.FloatStack.Push(9.9, 3.3);
+      interpreter.Run(new FloatMultiplyExpression());
+
+      Assert.AreEqual(32.67, interpreter.FloatStack.Top, delta);
+
+      TestStackCounts(floatStack: 1);
     }
 
@@ -87,5 +87,5 @@
     [TestCategory("FloatExpressionTest")]
     public void TestMultiplyWithInsufficientArguments() {
-      this.TestWithInsufficientArguments("*", 1);
+      TestWithInsufficientArguments("*", 1);
     }
 
@@ -95,10 +95,10 @@
     [TestCategory("FloatExpressionTest")]
     public void TestDivide() {
-      this.interpreter.FloatStack.Push(9.9, 3.3);
-      this.interpreter.Run(new FloatDivideExpression());
-
-      Assert.AreEqual(3.0, this.interpreter.FloatStack.Top, delta);
-
-      this.TestStackCounts(floatStack: 1);
+      interpreter.FloatStack.Push(9.9, 3.3);
+      interpreter.Run(new FloatDivideExpression());
+
+      Assert.AreEqual(3.0, interpreter.FloatStack.Top, delta);
+
+      TestStackCounts(floatStack: 1);
     }
 
@@ -108,5 +108,5 @@
     [TestCategory("FloatExpressionTest")]
     public void TestDivideWithInsufficientArguments() {
-      this.TestWithInsufficientArguments("/", 1);
+      TestWithInsufficientArguments("/", 1);
     }
 
@@ -116,10 +116,10 @@
     [TestCategory("FloatExpressionTest")]
     public void TestModulo() {
-      this.interpreter.FloatStack.Push(11.6, 5.3);
-      this.interpreter.Run(new FloatModuloExpression());
-
-      Assert.AreEqual(1, this.interpreter.FloatStack.Top, delta);
-
-      this.TestStackCounts(floatStack: 1);
+      interpreter.FloatStack.Push(11.6, 5.3);
+      interpreter.Run(new FloatModuloExpression());
+
+      Assert.AreEqual(1, interpreter.FloatStack.Top, delta);
+
+      TestStackCounts(floatStack: 1);
     }
 
@@ -129,5 +129,5 @@
     [TestCategory("FloatExpressionTest")]
     public void TestModuloWithInsufficientArguments() {
-      this.TestWithInsufficientArguments("%", 1);
+      TestWithInsufficientArguments("%", 1);
     }
 
@@ -137,10 +137,10 @@
     [TestCategory("FloatExpressionTest")]
     public void TestMin() {
-      this.interpreter.FloatStack.Push(10.2, 5.3);
-      this.interpreter.Run(new FloatMinExpression());
-
-      Assert.AreEqual(5.3, this.interpreter.FloatStack.Top, delta);
-
-      this.TestStackCounts(floatStack: 1);
+      interpreter.FloatStack.Push(10.2, 5.3);
+      interpreter.Run(new FloatMinExpression());
+
+      Assert.AreEqual(5.3, interpreter.FloatStack.Top, delta);
+
+      TestStackCounts(floatStack: 1);
     }
 
@@ -150,5 +150,5 @@
     [TestCategory("FloatExpressionTest")]
     public void TestMinWithInsufficientArguments() {
-      this.TestWithInsufficientArguments("MIN", 1);
+      TestWithInsufficientArguments("MIN", 1);
     }
 
@@ -158,10 +158,10 @@
     [TestCategory("FloatExpressionTest")]
     public void TestMax() {
-      this.interpreter.FloatStack.Push(10.3, 5.3);
-      this.interpreter.Run(new FloatMaxExpression());
-
-      Assert.AreEqual(10.3, this.interpreter.FloatStack.Top, delta);
-
-      this.TestStackCounts(floatStack: 1);
+      interpreter.FloatStack.Push(10.3, 5.3);
+      interpreter.Run(new FloatMaxExpression());
+
+      Assert.AreEqual(10.3, interpreter.FloatStack.Top, delta);
+
+      TestStackCounts(floatStack: 1);
     }
 
@@ -171,5 +171,5 @@
     [TestCategory("FloatExpressionTest")]
     public void TestMaxWithInsufficientArguments() {
-      this.TestWithInsufficientArguments("MAX", 1);
+      TestWithInsufficientArguments("MAX", 1);
     }
 
@@ -179,10 +179,10 @@
     [TestCategory("FloatExpressionTest")]
     public void TestSmallerThan() {
-      this.interpreter.FloatStack.Push(10.2, 5.3);
-      this.interpreter.Run(new FloatSmallerThanExpression());
-
-      Assert.AreEqual(false, this.interpreter.BooleanStack.Top);
-
-      this.TestStackCounts(booleanStack: 1);
+      interpreter.FloatStack.Push(10.2, 5.3);
+      interpreter.Run(new FloatSmallerThanExpression());
+
+      Assert.AreEqual(false, interpreter.BooleanStack.Top);
+
+      TestStackCounts(booleanStack: 1);
     }
 
@@ -192,5 +192,5 @@
     [TestCategory("FloatExpressionTest")]
     public void TestSmallerThanWithInsufficientArguments() {
-      this.TestWithInsufficientArguments("<", 1);
+      TestWithInsufficientArguments("<", 1);
     }
 
@@ -200,10 +200,10 @@
     [TestCategory("FloatExpressionTest")]
     public void TestGreaterThan() {
-      this.interpreter.FloatStack.Push(10.2, 5.3);
-      this.interpreter.Run(new FloatGreaterThanExpression());
-
-      Assert.AreEqual(true, this.interpreter.BooleanStack.Top);
-
-      this.TestStackCounts(booleanStack: 1);
+      interpreter.FloatStack.Push(10.2, 5.3);
+      interpreter.Run(new FloatGreaterThanExpression());
+
+      Assert.AreEqual(true, interpreter.BooleanStack.Top);
+
+      TestStackCounts(booleanStack: 1);
     }
 
@@ -213,5 +213,5 @@
     [TestCategory("FloatExpressionTest")]
     public void TestGreaterThanWithInsufficientArguments() {
-      this.TestWithInsufficientArguments(">", 1);
+      TestWithInsufficientArguments(">", 1);
     }
 
@@ -221,10 +221,10 @@
     [TestCategory("FloatExpressionTest")]
     public void TestFromBooleanTrue() {
-      this.interpreter.BooleanStack.Push(true);
-      this.interpreter.Run(new FloatFromBooleanExpression());
-
-      Assert.AreEqual(1d, this.interpreter.FloatStack.Top, delta);
-
-      this.TestStackCounts(floatStack: 1);
+      interpreter.BooleanStack.Push(true);
+      interpreter.Run(new FloatFromBooleanExpression());
+
+      Assert.AreEqual(1d, interpreter.FloatStack.Top, delta);
+
+      TestStackCounts(floatStack: 1);
     }
 
@@ -234,10 +234,10 @@
     [TestCategory("FloatExpressionTest")]
     public void TestFromBooleanFalse() {
-      this.interpreter.BooleanStack.Push(false);
-      this.interpreter.Run(new FloatFromBooleanExpression());
-
-      Assert.AreEqual(0d, this.interpreter.FloatStack.Top, delta);
-
-      this.TestStackCounts(floatStack: 1);
+      interpreter.BooleanStack.Push(false);
+      interpreter.Run(new FloatFromBooleanExpression());
+
+      Assert.AreEqual(0d, interpreter.FloatStack.Top, delta);
+
+      TestStackCounts(floatStack: 1);
     }
 
@@ -247,5 +247,5 @@
     [TestCategory("FloatExpressionTest")]
     public void TestFromBooleanWithInsufficientArguments() {
-      this.TestWithInsufficientArguments("FROMBOOLEAN");
+      TestWithInsufficientArguments("FROMBOOLEAN");
     }
 
@@ -255,10 +255,10 @@
     [TestCategory("FloatExpressionTest")]
     public void TestFromInteger() {
-      this.interpreter.IntegerStack.Push(5);
-      this.interpreter.Run(new FloatFromIntegerExpression());
-
-      Assert.AreEqual(5d, this.interpreter.FloatStack.Top, delta);
-
-      this.TestStackCounts(floatStack: 1);
+      interpreter.IntegerStack.Push(5);
+      interpreter.Run(new FloatFromIntegerExpression());
+
+      Assert.AreEqual(5d, interpreter.FloatStack.Top, delta);
+
+      TestStackCounts(floatStack: 1);
     }
 
@@ -268,5 +268,5 @@
     [TestCategory("FloatExpressionTest")]
     public void TestFromIntegerWithInsufficientArguments() {
-      this.TestWithInsufficientArguments("FROMINTEGER");
+      TestWithInsufficientArguments("FROMINTEGER");
     }
 
@@ -276,10 +276,10 @@
     [TestCategory("FloatExpressionTest")]
     public void TestSine() {
-      this.interpreter.FloatStack.Push(Math.PI / 2);
-      this.interpreter.Run(new FloatSineExpression());
-
-      Assert.AreEqual(1, this.interpreter.FloatStack.Top, delta);
-
-      this.TestStackCounts(floatStack: 1);
+      interpreter.FloatStack.Push(Math.PI / 2);
+      interpreter.Run(new FloatSineExpression());
+
+      Assert.AreEqual(1, interpreter.FloatStack.Top, delta);
+
+      TestStackCounts(floatStack: 1);
     }
 
@@ -289,5 +289,5 @@
     [TestCategory("FloatExpressionTest")]
     public void TestSineWithInsufficientArguments() {
-      this.TestWithInsufficientArguments("SIN");
+      TestWithInsufficientArguments("SIN");
     }
 
@@ -297,10 +297,10 @@
     [TestCategory("FloatExpressionTest")]
     public void TestCosine() {
-      this.interpreter.FloatStack.Push(Math.PI);
-      this.interpreter.Run(new FloatCosineExpression());
-
-      Assert.AreEqual(-1, this.interpreter.FloatStack.Top, delta);
-
-      this.TestStackCounts(floatStack: 1);
+      interpreter.FloatStack.Push(Math.PI);
+      interpreter.Run(new FloatCosineExpression());
+
+      Assert.AreEqual(-1, interpreter.FloatStack.Top, delta);
+
+      TestStackCounts(floatStack: 1);
     }
 
@@ -310,5 +310,5 @@
     [TestCategory("FloatExpressionTest")]
     public void TestCosineWithInsufficientArguments() {
-      this.TestWithInsufficientArguments("COS");
+      TestWithInsufficientArguments("COS");
     }
 
@@ -322,5 +322,5 @@
 
     protected override void CheckOtherStacksAreEmpty() {
-      this.TestStackCounts(floatStack: null);
+      TestStackCounts(floatStack: null);
     }
   }
Index: branches/PushGP/HeuristicLab.PushGP/HeuristicLab.Tests/Interpreter/Expressions/IntegerExpressionTests.cs
===================================================================
--- branches/PushGP/HeuristicLab.PushGP/HeuristicLab.Tests/Interpreter/Expressions/IntegerExpressionTests.cs	(revision 14907)
+++ branches/PushGP/HeuristicLab.PushGP/HeuristicLab.Tests/Interpreter/Expressions/IntegerExpressionTests.cs	(revision 14908)
@@ -19,5 +19,5 @@
       get
       {
-        return this.interpreter.IntegerStack;
+        return interpreter.IntegerStack;
       }
     }
@@ -28,10 +28,10 @@
     [TestCategory("IntegerExpressionTest")]
     public void TestAdd() {
-      this.interpreter.IntegerStack.Push(5, 5);
-      this.interpreter.Run(new IntegerAddExpression());
-
-      Assert.AreEqual(10, this.interpreter.IntegerStack.Top);
-
-      this.TestStackCounts(integerStack: 1);
+      interpreter.IntegerStack.Push(5, 5);
+      interpreter.Run(new IntegerAddExpression());
+
+      Assert.AreEqual(10, interpreter.IntegerStack.Top);
+
+      TestStackCounts(integerStack: 1);
     }
 
@@ -41,5 +41,5 @@
     [TestCategory("IntegerExpressionTest")]
     public void TestAddWithInsufficientArguments() {
-      this.TestWithInsufficientArguments("+", 1);
+      TestWithInsufficientArguments("+", 1);
     }
 
@@ -49,10 +49,10 @@
     [TestCategory("IntegerExpressionTest")]
     public void TestSubtract() {
-      this.interpreter.IntegerStack.Push(10, 5);
-      this.interpreter.Run(new IntegerSubtractExpression());
-
-      Assert.AreEqual(5, this.interpreter.IntegerStack.Top);
-
-      this.TestStackCounts(integerStack: 1);
+      interpreter.IntegerStack.Push(10, 5);
+      interpreter.Run(new IntegerSubtractExpression());
+
+      Assert.AreEqual(5, interpreter.IntegerStack.Top);
+
+      TestStackCounts(integerStack: 1);
     }
 
@@ -62,5 +62,5 @@
     [TestCategory("IntegerExpressionTest")]
     public void TestSubtractWithInsufficientArguments() {
-      this.TestWithInsufficientArguments("-", 1);
+      TestWithInsufficientArguments("-", 1);
     }
 
@@ -70,10 +70,10 @@
     [TestCategory("IntegerExpressionTest")]
     public void TestMultiply() {
-      this.interpreter.IntegerStack.Push(10, 5);
-      this.interpreter.Run(new IntegerMultiplyExpression());
-
-      Assert.AreEqual(50, this.interpreter.IntegerStack.Top);
-
-      this.TestStackCounts(integerStack: 1);
+      interpreter.IntegerStack.Push(10, 5);
+      interpreter.Run(new IntegerMultiplyExpression());
+
+      Assert.AreEqual(50, interpreter.IntegerStack.Top);
+
+      TestStackCounts(integerStack: 1);
     }
 
@@ -83,5 +83,5 @@
     [TestCategory("IntegerExpressionTest")]
     public void TestMultiplyWithInsufficientArguments() {
-      this.TestWithInsufficientArguments("*", 1);
+      TestWithInsufficientArguments("*", 1);
     }
 
@@ -91,10 +91,10 @@
     [TestCategory("IntegerExpressionTest")]
     public void TestDivide() {
-      this.interpreter.IntegerStack.Push(10, 5);
-      this.interpreter.Run(new IntegerDivideExpression());
-
-      Assert.AreEqual(2, this.interpreter.IntegerStack.Top);
-
-      this.TestStackCounts(integerStack: 1);
+      interpreter.IntegerStack.Push(10, 5);
+      interpreter.Run(new IntegerDivideExpression());
+
+      Assert.AreEqual(2, interpreter.IntegerStack.Top);
+
+      TestStackCounts(integerStack: 1);
     }
 
@@ -104,5 +104,5 @@
     [TestCategory("IntegerExpressionTest")]
     public void TestDivideWithInsufficientArguments() {
-      this.TestWithInsufficientArguments("/", 1);
+      TestWithInsufficientArguments("/", 1);
     }
 
@@ -112,10 +112,10 @@
     [TestCategory("IntegerExpressionTest")]
     public void TestModulo() {
-      this.interpreter.IntegerStack.Push(10, 5);
-      this.interpreter.Run(new IntegerModuloExpression());
-
-      Assert.AreEqual(0, this.interpreter.IntegerStack.Top);
-
-      this.TestStackCounts(integerStack: 1);
+      interpreter.IntegerStack.Push(10, 5);
+      interpreter.Run(new IntegerModuloExpression());
+
+      Assert.AreEqual(0, interpreter.IntegerStack.Top);
+
+      TestStackCounts(integerStack: 1);
     }
 
@@ -125,5 +125,5 @@
     [TestCategory("IntegerExpressionTest")]
     public void TestModuloWithInsufficientArguments() {
-      this.TestWithInsufficientArguments("%", 1);
+      TestWithInsufficientArguments("%", 1);
     }
 
@@ -133,10 +133,10 @@
     [TestCategory("IntegerExpressionTest")]
     public void TestMin() {
-      this.interpreter.IntegerStack.Push(10, 5);
-      this.interpreter.Run(new IntegerMinExpression());
-
-      Assert.AreEqual(5, this.interpreter.IntegerStack.Top);
-
-      this.TestStackCounts(integerStack: 1);
+      interpreter.IntegerStack.Push(10, 5);
+      interpreter.Run(new IntegerMinExpression());
+
+      Assert.AreEqual(5, interpreter.IntegerStack.Top);
+
+      TestStackCounts(integerStack: 1);
     }
 
@@ -146,5 +146,5 @@
     [TestCategory("IntegerExpressionTest")]
     public void TestMinWithInsufficientArguments() {
-      this.TestWithInsufficientArguments("MIN", 1);
+      TestWithInsufficientArguments("MIN", 1);
     }
 
@@ -154,10 +154,10 @@
     [TestCategory("IntegerExpressionTest")]
     public void TestMax() {
-      this.interpreter.IntegerStack.Push(10, 5);
-      this.interpreter.Run(new IntegerMaxExpression());
-
-      Assert.AreEqual(10, this.interpreter.IntegerStack.Top);
-
-      this.TestStackCounts(integerStack: 1);
+      interpreter.IntegerStack.Push(10, 5);
+      interpreter.Run(new IntegerMaxExpression());
+
+      Assert.AreEqual(10, interpreter.IntegerStack.Top);
+
+      TestStackCounts(integerStack: 1);
     }
 
@@ -167,5 +167,5 @@
     [TestCategory("IntegerExpressionTest")]
     public void TestMaxWithInsufficientArguments() {
-      this.TestWithInsufficientArguments("MAX", 1);
+      TestWithInsufficientArguments("MAX", 1);
     }
 
@@ -175,10 +175,10 @@
     [TestCategory("IntegerExpressionTest")]
     public void TestSmallerThan() {
-      this.interpreter.IntegerStack.Push(10, 5);
-      this.interpreter.Run(new IntegerSmallerThanExpression());
-
-      Assert.AreEqual(false, this.interpreter.BooleanStack.Top);
-
-      this.TestStackCounts(booleanStack: 1);
+      interpreter.IntegerStack.Push(10, 5);
+      interpreter.Run(new IntegerSmallerThanExpression());
+
+      Assert.AreEqual(false, interpreter.BooleanStack.Top);
+
+      TestStackCounts(booleanStack: 1);
     }
 
@@ -188,5 +188,5 @@
     [TestCategory("IntegerExpressionTest")]
     public void TestSmallerThanWithInsufficientArguments() {
-      this.TestWithInsufficientArguments("<", 1);
+      TestWithInsufficientArguments("<", 1);
     }
 
@@ -196,10 +196,10 @@
     [TestCategory("IntegerExpressionTest")]
     public void TestGreaterThan() {
-      this.interpreter.IntegerStack.Push(10, 5);
-      this.interpreter.Run(new IntegerGreaterThanExpression());
-
-      Assert.AreEqual(true, this.interpreter.BooleanStack.Top);
-
-      this.TestStackCounts(booleanStack: 1);
+      interpreter.IntegerStack.Push(10, 5);
+      interpreter.Run(new IntegerGreaterThanExpression());
+
+      Assert.AreEqual(true, interpreter.BooleanStack.Top);
+
+      TestStackCounts(booleanStack: 1);
     }
 
@@ -209,5 +209,5 @@
     [TestCategory("IntegerExpressionTest")]
     public void TestGreaterThanWithInsufficientArguments() {
-      this.TestWithInsufficientArguments(">", 1);
+      TestWithInsufficientArguments(">", 1);
     }
 
@@ -217,10 +217,10 @@
     [TestCategory("IntegerExpressionTest")]
     public void TestFromBooleanTrue() {
-      this.interpreter.BooleanStack.Push(true);
-      this.interpreter.Run(new IntegerFromBooleanExpression());
-
-      Assert.AreEqual(1, this.interpreter.IntegerStack.Top);
-
-      this.TestStackCounts(integerStack: 1);
+      interpreter.BooleanStack.Push(true);
+      interpreter.Run(new IntegerFromBooleanExpression());
+
+      Assert.AreEqual(1, interpreter.IntegerStack.Top);
+
+      TestStackCounts(integerStack: 1);
     }
 
@@ -230,5 +230,5 @@
     [TestCategory("IntegerExpressionTest")]
     public void TestFromBooleanWithInsufficientArguments() {
-      this.TestWithInsufficientArguments("FROMBOOLEAN");
+      TestWithInsufficientArguments("FROMBOOLEAN");
     }
 
@@ -238,10 +238,10 @@
     [TestCategory("IntegerExpressionTest")]
     public void TestFromBooleanFalse() {
-      this.interpreter.BooleanStack.Push(false);
-      this.interpreter.Run(new IntegerFromBooleanExpression());
-
-      Assert.AreEqual(0, this.interpreter.IntegerStack.Top);
-
-      this.TestStackCounts(integerStack: 1);
+      interpreter.BooleanStack.Push(false);
+      interpreter.Run(new IntegerFromBooleanExpression());
+
+      Assert.AreEqual(0, interpreter.IntegerStack.Top);
+
+      TestStackCounts(integerStack: 1);
     }
 
@@ -251,10 +251,10 @@
     [TestCategory("IntegerExpressionTest")]
     public void TestFromFloat() {
-      this.interpreter.FloatStack.Push(1.5);
-      this.interpreter.Run(new IntegerFromFloatExpression());
-
-      Assert.AreEqual(1, this.interpreter.IntegerStack.Top);
-
-      this.TestStackCounts(integerStack: 1);
+      interpreter.FloatStack.Push(1.5);
+      interpreter.Run(new IntegerFromFloatExpression());
+
+      Assert.AreEqual(1, interpreter.IntegerStack.Top);
+
+      TestStackCounts(integerStack: 1);
     }
 
@@ -264,5 +264,5 @@
     [TestCategory("IntegerExpressionTest")]
     public void TestFromFloatWithInsufficientArguments() {
-      this.TestWithInsufficientArguments("FROMFLOAT");
+      TestWithInsufficientArguments("FROMFLOAT");
     }
 
@@ -276,5 +276,5 @@
 
     protected override void CheckOtherStacksAreEmpty() {
-      this.TestStackCounts(integerStack: null);
+      TestStackCounts(integerStack: null);
     }
   }
Index: branches/PushGP/HeuristicLab.PushGP/HeuristicLab.Tests/Interpreter/Expressions/NameExpressionTests.cs
===================================================================
--- branches/PushGP/HeuristicLab.PushGP/HeuristicLab.Tests/Interpreter/Expressions/NameExpressionTests.cs	(revision 14907)
+++ branches/PushGP/HeuristicLab.PushGP/HeuristicLab.Tests/Interpreter/Expressions/NameExpressionTests.cs	(revision 14908)
@@ -20,5 +20,5 @@
       get
       {
-        return this.interpreter.NameStack;
+        return interpreter.NameStack;
       }
     }
@@ -29,10 +29,10 @@
     [TestCategory("NameExpressionTest")]
     public void TestRand() {
-      this.interpreter.Configuration.ErcOptions.NameErcOptions.IsEnabled = true;
-      this.interpreter.Run(new NameRandExpression());
+      interpreter.Configuration.ErcOptions.NameErcOptions.IsEnabled = true;
+      interpreter.Run(new NameRandExpression());
 
-      Assert.IsTrue(this.interpreter.NameStack.Count == 1);
+      Assert.IsTrue(interpreter.NameStack.Count == 1);
 
-      this.CheckOtherStacksAreEmpty();
+      CheckOtherStacksAreEmpty();
     }
 
@@ -42,13 +42,13 @@
     [TestCategory("NameExpressionTest")]
     public void TestRandomBound() {
-      this.interpreter.CustomExpressions.Add("c1", new CodeNoopExpression());
-      this.interpreter.CustomExpressions.Add("c2", new CodeNoopExpression());
-      this.interpreter.CustomExpressions.Add("c3", new CodeNoopExpression());
+      interpreter.CustomExpressions.Add("c1", new CodeNoopExpression());
+      interpreter.CustomExpressions.Add("c2", new CodeNoopExpression());
+      interpreter.CustomExpressions.Add("c3", new CodeNoopExpression());
 
-      this.interpreter.Run(new NameRandBoundNameExpression());
+      interpreter.Run(new NameRandBoundNameExpression());
 
-      Assert.IsTrue(this.interpreter.CustomExpressions.Keys.Contains(this.interpreter.NameStack.Top));
+      Assert.IsTrue(interpreter.CustomExpressions.Keys.Contains(interpreter.NameStack.Top));
 
-      this.CheckOtherStacksAreEmpty();
+      CheckOtherStacksAreEmpty();
     }
 
@@ -58,5 +58,5 @@
     [TestCategory("NameExpressionTest")]
     public void TestRandomBoundWithInsufficientArguments() {
-      this.TestWithInsufficientArguments("RANDBOUNDNAME");
+      TestWithInsufficientArguments("RANDBOUNDNAME");
     }
 
@@ -66,9 +66,9 @@
     [TestCategory("NameExpressionTest")]
     public void TestQuote() {
-      this.interpreter.Run(new NameQuoteExpression());
+      interpreter.Run(new NameQuoteExpression());
 
-      Assert.IsTrue(this.interpreter.IsNameQuoteFlagSet);
+      Assert.IsTrue(interpreter.IsNameQuoteFlagSet);
 
-      this.TestStackCounts();
+      TestStackCounts();
     }
 
@@ -83,5 +83,5 @@
 
     protected override void CheckOtherStacksAreEmpty() {
-      this.TestStackCounts(nameStack: null);
+      TestStackCounts(nameStack: null);
     }
   }
