Index: branches/PushGP/HeuristicLab.Algorithms.PushGP/HeuristicLab.Algorithms.PushGP.Cli/Program.cs
===================================================================
--- branches/PushGP/HeuristicLab.Algorithms.PushGP/HeuristicLab.Algorithms.PushGP.Cli/Program.cs	(revision 14397)
+++ branches/PushGP/HeuristicLab.Algorithms.PushGP/HeuristicLab.Algorithms.PushGP.Cli/Program.cs	(revision 14398)
@@ -12,5 +12,6 @@
         static void Main(string[] args)
         {
-            Stepwise().Wait();
+            SimpleTest();
+            //Stepwise().Wait();
             //PerformanceTestInterpreter();
             //PerformanceTestCodeGenerator();
@@ -18,4 +19,13 @@
             Console.WriteLine("\nPress any key to continue...");
             Console.ReadKey();
+        }
+
+        static void SimpleTest()
+        {
+            var interpreter = new PushGPInterpreter();
+
+            interpreter.Interpret("5 INTEGER.DUP INTEGER.+");
+
+            interpreter.PrintStacks();
         }
 
Index: branches/PushGP/HeuristicLab.Algorithms.PushGP/HeuristicLab.Algorithms.PushGP/Data/ExpressionNode.cs
===================================================================
--- branches/PushGP/HeuristicLab.Algorithms.PushGP/HeuristicLab.Algorithms.PushGP/Data/ExpressionNode.cs	(revision 14398)
+++ branches/PushGP/HeuristicLab.Algorithms.PushGP/HeuristicLab.Algorithms.PushGP/Data/ExpressionNode.cs	(revision 14398)
@@ -0,0 +1,12 @@
+﻿using System;
+using System.Collections.Generic;
+using System.Linq;
+using System.Text;
+using System.Threading.Tasks;
+
+namespace HeuristicLab.Algorithms.PushGP.Data
+{
+    public class ExpressionNode
+    {
+    }
+}
Index: branches/PushGP/HeuristicLab.Algorithms.PushGP/HeuristicLab.Algorithms.PushGP/Data/ExpressionTree.cs
===================================================================
--- branches/PushGP/HeuristicLab.Algorithms.PushGP/HeuristicLab.Algorithms.PushGP/Data/ExpressionTree.cs	(revision 14398)
+++ branches/PushGP/HeuristicLab.Algorithms.PushGP/HeuristicLab.Algorithms.PushGP/Data/ExpressionTree.cs	(revision 14398)
@@ -0,0 +1,7 @@
+﻿namespace HeuristicLab.Algorithms.PushGP.Data
+{
+    public class ExpressionTree
+    {
+        public ExpressionNode Root { get; set; }
+    }
+}
Index: branches/PushGP/HeuristicLab.Algorithms.PushGP/HeuristicLab.Algorithms.PushGP/ExpressionTable.cs
===================================================================
--- branches/PushGP/HeuristicLab.Algorithms.PushGP/HeuristicLab.Algorithms.PushGP/ExpressionTable.cs	(revision 14397)
+++ branches/PushGP/HeuristicLab.Algorithms.PushGP/HeuristicLab.Algorithms.PushGP/ExpressionTable.cs	(revision 14398)
@@ -8,5 +8,5 @@
     public static class ExpressionTable
     {
-        private static Dictionary<string, Expression> expressionTable;
+        private static Dictionary<string, Expression> statelessExpressionTable;
         private static Dictionary<string, Func<Expression>> statefullExpressionFactory;
 
@@ -15,26 +15,27 @@
         static ExpressionTable()
         {
-            expressionTable = GetExperssionTable(e => e.ToString());
-            statefullExpressionFactory = GetStatefullExpressionFactory(e => e.ToString());
+            statelessExpressionTable = GetStatelessExperssionTable(e => e.StringRepresentation);
+            statefullExpressionFactory = GetStatefullExpressionFactory(e => e.StringRepresentation);
 
-            Count = expressionTable.Count + statefullExpressionFactory.Count;
+            Count = statelessExpressionTable.Count + statefullExpressionFactory.Count;
         }
 
-        private static Dictionary<string, Expression> GetExperssionTable(Func<Expression, string> keyFunc)
-        {
-            return GetExperssionTable(e => new KeyValuePair<string, Expression>(keyFunc(e), e));
-        }
-
-        private static Dictionary<string, Expression> GetExperssionTable(Func<Expression, KeyValuePair<string, Expression>> pairFunc)
+        private static Dictionary<string, Expression> GetStatelessExperssionTable(Func<Expression, string> keyFunc)
         {
             var dictionary = new Dictionary<string, Expression>();
-            var expressionTypes = GetExpressionTypes(filterStatefull: false);
+            var expressionTypes = GetExpressionTypes(typeof(StatelessExpression));
 
             foreach (var type in expressionTypes)
             {
-                var expression = (Expression)Activator.CreateInstance(type);
-                var pair = pairFunc(expression);
+                var expression = Activator.CreateInstance(type) as Expression;
+                var key = keyFunc(expression);
 
-                dictionary.Add(pair.Key, pair.Value);
+                try
+                {
+                    dictionary.Add(key, expression);
+                } catch(Exception e)
+                {
+                    Console.WriteLine(e);
+                }
             }
 
@@ -45,5 +46,5 @@
         {
             var dictionary = new Dictionary<string, Func<Expression>>();
-            var expressionTypes = GetExpressionTypes(filterStatefull: true);
+            var expressionTypes = GetExpressionTypes(typeof(StatefullExpression));
 
             foreach (var type in expressionTypes)
@@ -58,5 +59,12 @@
                 var key = keyFunc(expression);
 
-                dictionary.Add(key, creator);
+                try
+                {
+                    dictionary.Add(key, creator);
+                }
+                catch (Exception e)
+                {
+                    Console.WriteLine(e);
+                }
             }
 
@@ -64,17 +72,15 @@
         }
 
-        private static IEnumerable<Type> GetExpressionTypes(bool filterStatefull)
+        private static IEnumerable<Type> GetExpressionTypes(Type baseType)
         {
             return from domainAssembly in AppDomain.CurrentDomain.GetAssemblies()
                    from assemblyType in domainAssembly.GetTypes()
-                   let type = typeof(Expression)
                    where !assemblyType.IsAbstract &&
-                         assemblyType.IsSubclassOf(type) &&
-                         Attribute.IsDefined(assemblyType, typeof(StatefullExpressionAttribute)) == filterStatefull &&
+                         assemblyType.IsSubclassOf(baseType) &&
                          assemblyType.GetConstructor(Type.EmptyTypes) != null
                    select assemblyType;
         }
 
-        public static int StatelessCount { get { return expressionTable.Count; } }
+        public static int StatelessCount { get { return statelessExpressionTable.Count; } }
 
         public static int StatefullCount { get { return statefullExpressionFactory.Count; } }
@@ -83,5 +89,5 @@
         {
             return index < StatelessCount
-                ? expressionTable.ElementAt(index).Value
+                ? statelessExpressionTable.ElementAt(index).Value
                 : statefullExpressionFactory.ElementAt(index - StatelessCount).Value();
         }
@@ -102,5 +108,5 @@
         {
             Expression expression;
-            if (expressionTable.TryGetValue(symbol, out expression)) return expression;
+            if (statelessExpressionTable.TryGetValue(symbol, out expression)) return expression;
             else throw new NotSupportedException("Expression not supported: " + symbol);
         }
@@ -108,5 +114,5 @@
         public static bool TryGetStatelessExpression(string name, out Expression expression)
         {
-            return expressionTable.TryGetValue(name, out expression);
+            return statelessExpressionTable.TryGetValue(name, out expression);
         }
 
Index: branches/PushGP/HeuristicLab.Algorithms.PushGP/HeuristicLab.Algorithms.PushGP/Expressions/BooleanExpressions.cs
===================================================================
--- branches/PushGP/HeuristicLab.Algorithms.PushGP/HeuristicLab.Algorithms.PushGP/Expressions/BooleanExpressions.cs	(revision 14397)
+++ branches/PushGP/HeuristicLab.Algorithms.PushGP/HeuristicLab.Algorithms.PushGP/Expressions/BooleanExpressions.cs	(revision 14398)
@@ -8,9 +8,12 @@
     public class BooleanAndExpression : PushResultExpression<bool>
     {
-        public BooleanAndExpression() : base("BOOLEAN.AND") { }
+        protected override string InitStringRepresentation()
+        {
+            return "BOOLEAN.AND";
+        }
 
         public override void Eval(IInterpreter interpreter)
         {
-            this.Eval(interpreter.BooleanStack, 2, values => values[0] && values[1]);
+            Eval(interpreter.BooleanStack, 2, values => values[0] && values[1]);
         }
     }
@@ -21,9 +24,12 @@
     public class BooleanOrExpression : PushResultExpression<bool>
     {
-        public BooleanOrExpression() : base("BOOLEAN.OR") { }
+        protected override string InitStringRepresentation()
+        {
+            return "BOOLEAN.OR";
+        }
 
         public override void Eval(IInterpreter interpreter)
         {
-            this.Eval(interpreter.BooleanStack, 2, values => values[0] || values[1]);
+            Eval(interpreter.BooleanStack, 2, values => values[0] || values[1]);
         }
     }
@@ -34,9 +40,9 @@
     public class BooleanNotExpression : PushResultExpression<bool>
     {
-        public BooleanNotExpression() : base("BOOLEAN.NOT") { }
+        protected override string InitStringRepresentation() { return "BOOLEAN.NOT"; }
 
         public override void Eval(IInterpreter interpreter)
         {
-            this.Eval(interpreter.BooleanStack, 1, values => !values[0]);
+            Eval(interpreter.BooleanStack, 1, values => !values[0]);
         }
     }
@@ -45,7 +51,7 @@
     /// Pushes FALSE if the top FLOAT is 0.0, or TRUE otherwise.
     /// </summary>
-    public class BooleanFromFloatExpression : Expression
+    public class BooleanFromFloatExpression : StatelessExpression
     {
-        public BooleanFromFloatExpression() : base("BOOLEAN.FROMFLOAT") { }
+        protected override string InitStringRepresentation() { return "BOOLEAN.FROMFLOAT"; }
 
         public override void Eval(IInterpreter interpreter)
@@ -63,7 +69,7 @@
     /// Pushes FALSE if the top INTEGER is 0, or TRUE otherwise.
     /// </summary>
-    public class BooleanFromIntegerExpression : Expression
+    public class BooleanFromIntegerExpression : StatelessExpression
     {
-        public BooleanFromIntegerExpression() : base("BOOLEAN.FROMINTEGER") { }
+        protected override string InitStringRepresentation() { return "BOOLEAN.FROMINTEGER"; }
 
         public override void Eval(IInterpreter interpreter)
Index: branches/PushGP/HeuristicLab.Algorithms.PushGP/HeuristicLab.Algorithms.PushGP/Expressions/CodeExpressions.cs
===================================================================
--- branches/PushGP/HeuristicLab.Algorithms.PushGP/HeuristicLab.Algorithms.PushGP/Expressions/CodeExpressions.cs	(revision 14397)
+++ branches/PushGP/HeuristicLab.Algorithms.PushGP/HeuristicLab.Algorithms.PushGP/Expressions/CodeExpressions.cs	(revision 14398)
@@ -17,7 +17,10 @@
     /// manipulates the stack then this final pop may end up popping something else.
     /// </summary>
-    public class CodeDoExpression : Expression
-    {
-        public CodeDoExpression() : base("CODE.DO") { }
+    public class CodeDoExpression : StatelessExpression
+    {
+        protected override string InitStringRepresentation()
+        {
+            return "CODE.DO";
+        }
 
         public override void Eval(IInterpreter interpreter)
@@ -35,7 +38,10 @@
     /// Like CODE.DO but pops the stack before, rather than after, the recursive execution
     /// </summary>
-    public class CodeDoXExpression : Expression
-    {
-        public CodeDoXExpression() : base("CODE.DO*") { }
+    public class CodeDoXExpression : StatelessExpression
+    {
+        protected override string InitStringRepresentation()
+        {
+            return "CODE.DO*";
+        }
 
         public override void Eval(IInterpreter interpreter)
@@ -53,7 +59,10 @@
     /// Does nothing.
     /// </summary>
-    public class CodeNoopExpression : Expression
-    {
-        public CodeNoopExpression() : base("CODE.NOOP") { }
+    public class CodeNoopExpression : StatelessExpression
+    {
+        protected override string InitStringRepresentation()
+        {
+            return "CODE.NOOP";
+        }
 
         public override void Eval(IInterpreter interpreter)
@@ -67,7 +76,10 @@
     /// This can be implemented by moving the top item on the EXEC stack onto the CODE stack.
     /// </summary>
-    public class CodeQuoteExpression : Expression
-    {
-        public CodeQuoteExpression() : base("CODE.QUOTE") { }
+    public class CodeQuoteExpression : StatelessExpression
+    {
+        protected override string InitStringRepresentation()
+        {
+            return "CODE.QUOTE";
+        }
 
         public override void Eval(IInterpreter interpreter)
@@ -87,7 +99,10 @@
     /// (and the BOOLEAN value upon which the decision was made) are popped.
     /// </summary>
-    public class CodeIfExpression : Expression
-    {
-        public CodeIfExpression() : base("CODE.IF") { }
+    public class CodeIfExpression : StatelessExpression
+    {
+        protected override string InitStringRepresentation()
+        {
+            return "CODE.IF";
+        }
 
         public override void Eval(IInterpreter interpreter)
@@ -111,7 +126,10 @@
     /// literal (that is, something not surrounded by parentheses) then it is surrounded by parentheses first.
     /// </summary>
-    public class CodeAppendExpression : Expression
-    {
-        public CodeAppendExpression() : base("CODE.APPEND") { }
+    public class CodeAppendExpression : StatelessExpression
+    {
+        protected override string InitStringRepresentation()
+        {
+            return "CODE.APPEND";
+        }
 
         public override void Eval(IInterpreter interpreter)
@@ -130,28 +148,28 @@
             if (isFirstList)
             {
-                var list1 = first as ExecExpandExpression;
+                var expand1 = first as ExecExpandExpression;
 
                 if (isSecondList)
                 {
-                    var list2 = second as ExecExpandExpression;
-
-                    result = new List<Expression>(list2.Expressions.Length + list1.Expressions.Length);
-                    result.AddRange(list2.Expressions);
-                    result.AddRange(list1.Expressions);
+                    var expand2 = second as ExecExpandExpression;
+
+                    result = new List<Expression>(expand2.Expressions.Length + expand1.Expressions.Length);
+                    result.AddRange(expand2.Expressions);
+                    result.AddRange(expand1.Expressions);
                 }
                 else
                 {
-                    result = new List<Expression>(list1.Expressions.Length + 1);
+                    result = new List<Expression>(expand1.Expressions.Length + 1);
                     result.Add(second);
-                    result.AddRange(list1.Expressions);
+                    result.AddRange(expand1.Expressions);
                 }
             }
             else if (isSecondList)
             {
-                var list2 = second as ExecExpandExpression;
-
-                result = new List<Expression>(list2.Expressions.Length + 1);
+                var expand2 = second as ExecExpandExpression;
+
+                result = new List<Expression>(expand2.Expressions.Length + 1);
                 result.Add(first);
-                result.AddRange(list2.Expressions);
+                result.AddRange(expand2.Expressions);
             }
             else
@@ -168,7 +186,10 @@
     /// and FALSE otherwise (that is, if it is something surrounded by parentheses).
     /// </summary>
-    public class CodeAtomExpression : Expression
-    {
-        public CodeAtomExpression() : base("CODE.ATOM") { }
+    public class CodeAtomExpression : StatelessExpression
+    {
+        protected override string InitStringRepresentation()
+        {
+            return "CODE.ATOM";
+        }
 
         public override void Eval(IInterpreter interpreter)
@@ -189,7 +210,10 @@
     /// The name derives from the similar Lisp function; a more generic name would be "FIRST".
     /// </summary>
-    public class CodeCarExpression : Expression
-    {
-        public CodeCarExpression() : base("CODE.CAR") { }
+    public class CodeCarExpression : StatelessExpression
+    {
+        protected override string InitStringRepresentation()
+        {
+            return "CODE.CAR";
+        }
 
         public override void Eval(IInterpreter interpreter)
@@ -216,7 +240,10 @@
     /// the similar Lisp function; a more generic name would be "REST".
     /// </summary>
-    public class CodeCdrExpression : Expression
-    {
-        public CodeCdrExpression() : base("CODE.CDR") { }
+    public class CodeCdrExpression : StatelessExpression
+    {
+        protected override string InitStringRepresentation()
+        {
+            return "CODE.CDR";
+        }
 
         public override void Eval(IInterpreter interpreter)
@@ -230,7 +257,7 @@
             if (top.GetType() == typeof(ExecExpandExpression))
             {
-                var expression = top as ExecExpandExpression;
-
-                if (expression.Expressions.Length == 0)
+                var expand = top as ExecExpandExpression;
+
+                if (expand.IsEmpty)
                 {
                     return;
@@ -238,8 +265,8 @@
                 else
                 {
-                    var length = expression.Expressions.Length - 1;
+                    var length = expand.Expressions.Length - 1;
                     var newExpressions = new Expression[length];
 
-                    Array.Copy(expression.Expressions, 0, newExpressions, 0, length);
+                    Array.Copy(expand.Expressions, 0, newExpressions, 0, length);
 
                     expandExpression = new ExecExpandExpression(newExpressions);
@@ -260,7 +287,10 @@
     /// second piece of code is "X" then this pushes "( X A B )" (after popping the argument).
     /// </summary>
-    public class CodeConsExpression : Expression
-    {
-        public CodeConsExpression() : base("CODE.CONS") { }
+    public class CodeConsExpression : StatelessExpression
+    {
+        protected override string InitStringRepresentation()
+        {
+            return "CODE.CONS";
+        }
 
         public override void Eval(IInterpreter interpreter)
@@ -286,7 +316,10 @@
     /// and the second piece of code is "( A )" then this pushes ( C ( A ) ). Pushes an empty list if there is no such container.
     /// </summary>
-    public class CodeContainerExpression : Expression
-    {
-        public CodeContainerExpression() : base("CODE.CONTAINER") { }
+    public class CodeContainerExpression : StatelessExpression
+    {
+        protected override string InitStringRepresentation()
+        {
+            return "CODE.CONTAINER";
+        }
 
         public override void Eval(IInterpreter interpreter)
@@ -301,5 +334,5 @@
             var source = interpreter.CodeStack.Top;
 
-            var container = this.GetContainer(null, source as ExecExpandExpression, target);
+            var container = GetContainer(null, source as ExecExpandExpression, target);
             var result = container == null
                 ? ExecExpandExpression.Empty
@@ -330,7 +363,10 @@
     /// item anywhere (e.g. in a sub-list).
     /// </summary>
-    public class CodeContainsExpression : Expression
-    {
-        public CodeContainsExpression() : base("CODE.CONTAINS") { }
+    public class CodeContainsExpression : StatelessExpression
+    {
+        protected override string InitStringRepresentation()
+        {
+            return "CODE.CONTAINS";
+        }
 
         public override void Eval(IInterpreter interpreter)
@@ -352,7 +388,10 @@
     /// may then be executed with a call to CODE.DO or a similar instruction).
     /// </summary>
-    public class CodeDefinitionExpression : Expression
-    {
-        public CodeDefinitionExpression() : base("CODE.DEFINITION") { }
+    public class CodeDefinitionExpression : StatelessExpression
+    {
+        protected override string InitStringRepresentation()
+        {
+            return "CODE.DEFINITION";
+        }
 
         public override void Eval(IInterpreter interpreter)
@@ -385,7 +424,10 @@
     /// </list>
     /// </summary>
-    public class CodeDiscrepancyExpression : Expression
-    {
-        public CodeDiscrepancyExpression() : base("CODE.DISCREPANCY") { }
+    public class CodeDiscrepancyExpression : StatelessExpression
+    {
+        protected override string InitStringRepresentation()
+        {
+            return "CODE.DISCREPANCY";
+        }
 
         public override void Eval(IInterpreter interpreter)
@@ -401,5 +443,5 @@
             DetermineUniqueItems(expressions[1], firstItems);
 
-            var discrepancy = this.GetDiscrepancy(firstItems, secondItems);
+            var discrepancy = GetDiscrepancy(firstItems, secondItems);
 
             interpreter.IntegerStack.Push(discrepancy);
@@ -434,7 +476,7 @@
             if (source.GetType() == typeof(ExecExpandExpression))
             {
-                var list = source as ExecExpandExpression;
-
-                foreach (var e in list.Expressions)
+                var expand = source as ExecExpandExpression;
+
+                foreach (var e in expand.Expressions)
                 {
                     var id = e.GetHashCode();
@@ -464,7 +506,10 @@
     /// absolute value is taken in case it is negative) to ensure that it is within the meaningful range.
     /// </summary>
-    public class CodeExtractExpression : Expression
-    {
-        public CodeExtractExpression() : base("CODE.EXTRACT") { }
+    public class CodeExtractExpression : StatelessExpression
+    {
+        protected override string InitStringRepresentation()
+        {
+            return "CODE.EXTRACT";
+        }
 
         public override void Eval(IInterpreter interpreter)
@@ -488,7 +533,10 @@
     /// Pops the BOOLEAN stack and pushes the popped item (TRUE or FALSE) onto the CODE stack.
     /// </summary>
-    public class CodeFromBooleanExpression : Expression
-    {
-        public CodeFromBooleanExpression() : base("CODE.FROMBOOLEAN") { }
+    public class CodeFromBooleanExpression : StatelessExpression
+    {
+        protected override string InitStringRepresentation()
+        {
+            return "CODE.FROMBOOLEAN";
+        }
 
         public override void Eval(IInterpreter interpreter)
@@ -507,7 +555,10 @@
     /// Pops the FLOAT stack and pushes the popped item onto the CODE stack.
     /// </summary>
-    public class CodeFromFloatExpression : Expression
-    {
-        public CodeFromFloatExpression() : base("CODE.FROMFLOAT") { }
+    public class CodeFromFloatExpression : StatelessExpression
+    {
+        protected override string InitStringRepresentation()
+        {
+            return "CODE.FROMFLOAT";
+        }
 
         public override void Eval(IInterpreter interpreter)
@@ -526,7 +577,10 @@
     /// Pops the INTEGER stack and pushes the popped integer onto the CODE stack.
     /// </summary>
-    public class CodeFromIntegerExpression : Expression
-    {
-        public CodeFromIntegerExpression() : base("CODE.FROMINTEGER") { }
+    public class CodeFromIntegerExpression : StatelessExpression
+    {
+        protected override string InitStringRepresentation()
+        {
+            return "CODE.FROMINTEGER";
+        }
 
         public override void Eval(IInterpreter interpreter)
@@ -545,7 +599,10 @@
     /// Pops the NAME stack and pushes the popped item onto the CODE stack.
     /// </summary>
-    public class CodeFromNameExpression : Expression
-    {
-        public CodeFromNameExpression() : base("CODE.FROMNAME") { }
+    public class CodeFromNameExpression : StatelessExpression
+    {
+        protected override string InitStringRepresentation()
+        {
+            return "CODE.FROMNAME";
+        }
 
         public override void Eval(IInterpreter interpreter)
@@ -565,7 +622,10 @@
     /// by the top item of the INTEGER stack (and replacing whatever was there formerly).
     /// </summary>
-    public class CodeInsertExpression : Expression
-    {
-        public CodeInsertExpression() : base("CODE.INSERT") { }
+    public class CodeInsertExpression : StatelessExpression
+    {
+        protected override string InitStringRepresentation()
+        {
+            return "CODE.INSERT";
+        }
 
         public override void Eval(IInterpreter interpreter)
@@ -602,7 +662,10 @@
     /// matter what they contain.
     /// </summary>
-    public class CodeLengthExpression : Expression
-    {
-        public CodeLengthExpression() : base("CODE.LENGTH") { }
+    public class CodeLengthExpression : StatelessExpression
+    {
+        protected override string InitStringRepresentation()
+        {
+            return "CODE.LENGTH";
+        }
 
         public override void Eval(IInterpreter interpreter)
@@ -626,7 +689,10 @@
     /// Pushes a list of the top two items of the CODE stack onto the CODE stack.
     /// </summary>
-    public class CodeListExpression : Expression
-    {
-        public CodeListExpression() : base("CODE.LIST") { }
+    public class CodeListExpression : StatelessExpression
+    {
+        protected override string InitStringRepresentation()
+        {
+            return "CODE.LIST";
+        }
 
         public override void Eval(IInterpreter interpreter)
@@ -652,7 +718,10 @@
     /// (which is coerced to a list if necessary). Pushes FALSE onto the BOOLEAN stack otherwise.
     /// </summary>
-    public class CodeMemberExpression : Expression
-    {
-        public CodeMemberExpression() : base("CODE.MEMBER") { }
+    public class CodeMemberExpression : StatelessExpression
+    {
+        protected override string InitStringRepresentation()
+        {
+            return "CODE.MEMBER";
+        }
 
         public override void Eval(IInterpreter interpreter)
@@ -676,7 +745,10 @@
     /// modulo the length of the expression into which it is indexing.
     /// </summary>
-    public class CodeNthExpression : Expression
-    {
-        public CodeNthExpression() : base("CODE.NTH") { }
+    public class CodeNthExpression : StatelessExpression
+    {
+        protected override string InitStringRepresentation()
+        {
+            return "CODE.NTH";
+        }
 
         public override void Eval(IInterpreter interpreter)
@@ -693,9 +765,9 @@
             if (expression.GetType() == typeof(ExecExpandExpression))
             {
-                var subExpressions = (expression as ExecExpandExpression).Expressions;
-
-                nthExpression = subExpressions.Length == 0
+                var subExpression = expression as ExecExpandExpression;
+
+                nthExpression = subExpression.IsEmpty
                     ? ExecExpandExpression.Empty
-                    : subExpressions[subExpressions.Length - 1 - Math.Abs(n % subExpressions.Length)];
+                    : subExpression.Expressions[subExpression.Expressions.Length - 1 - Math.Abs(n % subExpression.Expressions.Length)];
             }
             else
@@ -714,7 +786,10 @@
     /// its first element.
     /// </summary>
-    public class CodeNthCdrExpression : Expression
-    {
-        public CodeNthCdrExpression() : base("CODE.NTHCDR") { }
+    public class CodeNthCdrExpression : StatelessExpression
+    {
+        protected override string InitStringRepresentation()
+        {
+            return "CODE.NTHCDR";
+        }
 
         public override void Eval(IInterpreter interpreter)
@@ -749,7 +824,10 @@
     /// Pushes TRUE onto the BOOLEAN stack if the top item of the CODE stack is an empty list, or FALSE otherwise.
     /// </summary>
-    public class CodeNullExpression : Expression
-    {
-        public CodeNullExpression() : base("CODE.NULL") { }
+    public class CodeNullExpression : StatelessExpression
+    {
+        protected override string InitStringRepresentation()
+        {
+            return "CODE.NULL";
+        }
 
         public override void Eval(IInterpreter interpreter)
@@ -768,7 +846,10 @@
     /// (which is coerced to a list if necessary). Pushes -1 if no match is found.
     /// </summary>
-    public class CodePositionExpression : Expression
-    {
-        public CodePositionExpression() : base("CODE.POSITION") { }
+    public class CodePositionExpression : StatelessExpression
+    {
+        protected override string InitStringRepresentation()
+        {
+            return "CODE.POSITION";
+        }
 
         public override void Eval(IInterpreter interpreter)
@@ -784,6 +865,6 @@
             if (first.GetType() == typeof(ExecExpandExpression))
             {
-                var list = first as ExecExpandExpression;
-                position = list.Expressions.Length - 1 - Array.FindIndex(list.Expressions, e => e.Equals(second));
+                var expand = first as ExecExpandExpression;
+                position = expand.Expressions.Length - 1 - Array.FindIndex(expand.Expressions, e => e.Equals(second));
             }
             else if (first.Equals(second))
@@ -800,7 +881,10 @@
     /// and pair of parentheses counts as a point.
     /// </summary>
-    public class CodeSizeExpression : Expression
-    {
-        public CodeSizeExpression() : base("CODE.SIZE") { }
+    public class CodeSizeExpression : StatelessExpression
+    {
+        protected override string InitStringRepresentation()
+        {
+            return "CODE.SIZE";
+        }
 
         public override void Eval(IInterpreter interpreter)
@@ -824,7 +908,10 @@
     /// cases with empty-list arguments. If any of these problematic possibilities occurs the stack is left unchanged.
     /// </summary>
-    public class CodeSubstitutionExpression : Expression
-    {
-        public CodeSubstitutionExpression() : base("CODE.SUBST") { }
+    public class CodeSubstitutionExpression : StatelessExpression
+    {
+        protected override string InitStringRepresentation()
+        {
+            return "CODE.SUBST";
+        }
 
         public override void Eval(IInterpreter interpreter)
Index: branches/PushGP/HeuristicLab.Algorithms.PushGP/HeuristicLab.Algorithms.PushGP/Expressions/DefineExpressions.cs
===================================================================
--- branches/PushGP/HeuristicLab.Algorithms.PushGP/HeuristicLab.Algorithms.PushGP/Expressions/DefineExpressions.cs	(revision 14397)
+++ branches/PushGP/HeuristicLab.Algorithms.PushGP/HeuristicLab.Algorithms.PushGP/Expressions/DefineExpressions.cs	(revision 14398)
@@ -10,9 +10,6 @@
     /// </summary>
     /// <typeparam name="T">Stacktype</typeparam>
-    public abstract class DefineExpression<T> : Expression
+    public abstract class DefineExpression<T> : StatelessExpression
     {
-        public DefineExpression(string stringRepresentation) : base(stringRepresentation)
-        { }
-
         protected void Eval(IStack<T> stack, IStack<string> nameStack, IDictionary<string, Expression> customExpressions, Func<T, Expression> creator)
         {
@@ -38,6 +35,7 @@
     public class CodeDefineExpression : DefineExpression<Expression>
     {
-        public CodeDefineExpression() : base("CODE.DEFINE")
+        protected override string InitStringRepresentation()
         {
+            return "CODE.DEFINE";
         }
 
@@ -48,5 +46,5 @@
                 return;
 
-            this.Eval(
+            Eval(
                 interpreter.CodeStack,
                 interpreter.NameStack,
@@ -60,6 +58,7 @@
     public class ExecDefineExpression : DefineExpression<Expression>
     {
-        public ExecDefineExpression() : base("EXEC.DEFINE")
+        protected override string InitStringRepresentation()
         {
+            return "EXEC.DEFINE";
         }
 
@@ -69,5 +68,5 @@
                 return;
 
-            this.Eval(
+            Eval(
                 interpreter.ExecStack,
                 interpreter.NameStack,
@@ -81,11 +80,12 @@
     public class FloatDefineExpression : DefineExpression<double>
     {
-        public FloatDefineExpression() : base("FLOAT.DEFINE")
+        protected override string InitStringRepresentation()
         {
+            return "FLOAT.DEFINE";
         }
 
         public override void Eval(IInterpreter interpreter)
         {
-            this.Eval(
+            Eval(
                 interpreter.FloatStack,
                 interpreter.NameStack,
@@ -97,11 +97,12 @@
     public class IntegerDefineExpression : DefineExpression<long>
     {
-        public IntegerDefineExpression() : base("INTEGER.DEFINE")
+        protected override string InitStringRepresentation()
         {
+            return "INTEGER.DEFINE";
         }
 
         public override void Eval(IInterpreter interpreter)
         {
-            this.Eval(
+            Eval(
                 interpreter.IntegerStack,
                 interpreter.NameStack,
@@ -113,11 +114,12 @@
     public class BooleanDefineExpression : DefineExpression<bool>
     {
-        public BooleanDefineExpression() : base("BOOLENA.DEFINE")
+        protected override string InitStringRepresentation()
         {
+            return "BOOLEAN.DEFINE";
         }
 
         public override void Eval(IInterpreter interpreter)
         {
-            this.Eval(
+            Eval(
                 interpreter.BooleanStack,
                 interpreter.NameStack,
Index: branches/PushGP/HeuristicLab.Algorithms.PushGP/HeuristicLab.Algorithms.PushGP/Expressions/DoCountExpressions.cs
===================================================================
--- branches/PushGP/HeuristicLab.Algorithms.PushGP/HeuristicLab.Algorithms.PushGP/Expressions/DoCountExpressions.cs	(revision 14397)
+++ branches/PushGP/HeuristicLab.Algorithms.PushGP/HeuristicLab.Algorithms.PushGP/Expressions/DoCountExpressions.cs	(revision 14398)
@@ -1,4 +1,5 @@
 ﻿using HeuristicLab.Algorithms.PushGP.Interpreter;
 using HeuristicLab.Algorithms.PushGP.Stack;
+using HeuristicLab.Common;
 
 namespace HeuristicLab.Algorithms.PushGP.Expressions
@@ -6,5 +7,9 @@
     public abstract class DoCountExpression : LoopExpression
     {
-        public DoCountExpression(string stringRepresentation) : base(stringRepresentation) { }
+        public DoCountExpression()
+        { }
+
+        public DoCountExpression(LoopExpression origin, Cloner cloner) : base(origin, cloner)
+        { }
 
         protected override bool HasInsufficientArguments(IInterpreter interpreter, IStack<Expression> sourceStack)
@@ -17,8 +22,8 @@
         protected override void InitState(IInterpreter interpreter, IStack<Expression> sourceStack)
         {
-            this.body = sourceStack.Pop();
-            this.destinationIndex = interpreter.IntegerStack.Top;
-            this.currentIndex = 1;
-            this.incrementor = 1;
+            body = sourceStack.Pop();
+            destinationIndex = interpreter.IntegerStack.Top;
+            currentIndex = 1;
+            incrementor = 1;
 
             interpreter.IntegerStack.SetTop(0);
@@ -34,12 +39,25 @@
     /// ( 0 '1 - IntegerArg>' CODE.QUOTE 'CodeArg' CODE.DO*RANGE )
     /// </summary>
-    [StatefullExpression]
     public class CodeDoCountExpression : DoCountExpression
     {
-        public CodeDoCountExpression() : base("CODE.DO*COUNT") { }
+        public CodeDoCountExpression()
+        { }
+
+        protected CodeDoCountExpression(CodeDoCountExpression origin, Cloner cloner) : base(origin, cloner)
+        { }
+
+        public override IDeepCloneable Clone(Cloner cloner)
+        {
+            return new CodeDoCountExpression(this, cloner);
+        }
+
+        protected override string InitStringRepresentation()
+        {
+            return "CODE.DO*COUNT";
+        }
 
         public override void Eval(IInterpreter interpreter)
         {
-            this.Eval(interpreter, interpreter.CodeStack);
+            Eval(interpreter, interpreter.CodeStack);
         }
     }
@@ -54,12 +72,25 @@
     /// ( 0 '1 - IntegerArg' EXEC.DO* RANGE'ExecArg' )
     /// </summary>
-    [StatefullExpression]
     public class ExecDoCountExpression : DoCountExpression
     {
-        public ExecDoCountExpression() : base("EXEC.DO*COUNT") { }
+        public ExecDoCountExpression()
+        { }
+
+        protected ExecDoCountExpression(ExecDoCountExpression origin, Cloner cloner) : base(origin, cloner)
+        { }
+
+        public override IDeepCloneable Clone(Cloner cloner)
+        {
+            return new ExecDoCountExpression(this, cloner);
+        }
+
+        protected override string InitStringRepresentation()
+        {
+            return "EXEC.DO*COUNT";
+        }
 
         public override void Eval(IInterpreter interpreter)
         {
-            this.Eval(interpreter, interpreter.ExecStack);
+            Eval(interpreter, interpreter.ExecStack);
         }
     }
Index: branches/PushGP/HeuristicLab.Algorithms.PushGP/HeuristicLab.Algorithms.PushGP/Expressions/DoRangeExpressions.cs
===================================================================
--- branches/PushGP/HeuristicLab.Algorithms.PushGP/HeuristicLab.Algorithms.PushGP/Expressions/DoRangeExpressions.cs	(revision 14397)
+++ branches/PushGP/HeuristicLab.Algorithms.PushGP/HeuristicLab.Algorithms.PushGP/Expressions/DoRangeExpressions.cs	(revision 14398)
@@ -1,4 +1,5 @@
 ﻿using HeuristicLab.Algorithms.PushGP.Interpreter;
 using HeuristicLab.Algorithms.PushGP.Stack;
+using HeuristicLab.Common;
 
 namespace HeuristicLab.Algorithms.PushGP.Expressions
@@ -6,5 +7,9 @@
     public abstract class DoRangeExpression : LoopExpression
     {
-        public DoRangeExpression(string stringRepresentation) : base(stringRepresentation) { }
+        public DoRangeExpression()
+        { }
+
+        public DoRangeExpression(LoopExpression origin, Cloner cloner) : base(origin, cloner)
+        { }
 
         protected override bool HasInsufficientArguments(IInterpreter interpreter, IStack<Expression> sourceStack)
@@ -17,9 +22,9 @@
         protected override void InitState(IInterpreter interpreter, IStack<Expression> sourceStack)
         {
-            this.body = sourceStack.Pop();
-            this.destinationIndex = interpreter.IntegerStack.Pop();
-            this.currentIndex = interpreter.IntegerStack.Top;
-            this.incrementor = this.destinationIndex < this.currentIndex ? -1 : 1;
-            this.currentIndex += this.incrementor;
+            body = sourceStack.Pop();
+            destinationIndex = interpreter.IntegerStack.Pop();
+            currentIndex = interpreter.IntegerStack.Top;
+            incrementor = destinationIndex < currentIndex ? -1 : 1;
+            currentIndex += incrementor;
         }
     }
@@ -38,12 +43,25 @@
     /// that is less than the specified current index.
     /// </summary>
-    [StatefullExpression]
     public class CodeDoRangeExpression : DoRangeExpression
     {
-        public CodeDoRangeExpression() : base("CODE.DO*RANGE") { }
+        public CodeDoRangeExpression()
+        { }
+
+        protected CodeDoRangeExpression(CodeDoRangeExpression origin, Cloner cloner) : base(origin, cloner)
+        { }
+
+        public override IDeepCloneable Clone(Cloner cloner)
+        {
+            return new CodeDoRangeExpression(this, cloner);
+        }
+
+        protected override string InitStringRepresentation()
+        {
+            return "CODE.DO*RANGE";
+        }
 
         public override void Eval(IInterpreter interpreter)
         {
-            this.Eval(interpreter, interpreter.CodeStack);
+            Eval(interpreter, interpreter.CodeStack);
         }
     }
@@ -63,12 +81,25 @@
     /// index that is less than the specified current index.
     /// </summary>
-    [StatefullExpression]
     public class ExecDoRangeExpression : DoRangeExpression
     {
-        public ExecDoRangeExpression() : base("EXEC.DO*RANGE") { }
+        public ExecDoRangeExpression()
+        { }
+
+        protected ExecDoRangeExpression(ExecDoRangeExpression origin, Cloner cloner) : base(origin, cloner)
+        { }
+
+        public override IDeepCloneable Clone(Cloner cloner)
+        {
+            return new ExecDoRangeExpression(this, cloner);
+        }
+
+        protected override string InitStringRepresentation()
+        {
+            return "EXEC.DO*RANGE";
+        }
 
         public override void Eval(IInterpreter interpreter)
         {
-            this.Eval(interpreter, interpreter.ExecStack);
+            Eval(interpreter, interpreter.ExecStack);
         }
     }
Index: branches/PushGP/HeuristicLab.Algorithms.PushGP/HeuristicLab.Algorithms.PushGP/Expressions/DoTimesExpressions.cs
===================================================================
--- branches/PushGP/HeuristicLab.Algorithms.PushGP/HeuristicLab.Algorithms.PushGP/Expressions/DoTimesExpressions.cs	(revision 14397)
+++ branches/PushGP/HeuristicLab.Algorithms.PushGP/HeuristicLab.Algorithms.PushGP/Expressions/DoTimesExpressions.cs	(revision 14398)
@@ -1,4 +1,5 @@
 ﻿using HeuristicLab.Algorithms.PushGP.Interpreter;
 using HeuristicLab.Algorithms.PushGP.Stack;
+using HeuristicLab.Common;
 
 namespace HeuristicLab.Algorithms.PushGP.Expressions
@@ -6,5 +7,9 @@
     public abstract class DoTimesExpression : LoopExpression
     {
-        public DoTimesExpression(string stringRepresentation) : base(stringRepresentation) { }
+        public DoTimesExpression()
+        { }
+
+        public DoTimesExpression(LoopExpression origin, Cloner cloner) : base(origin, cloner)
+        { }
 
         protected override bool HasInsufficientArguments(IInterpreter interpreter, IStack<Expression> sourceStack)
@@ -17,18 +22,18 @@
         protected override void InitState(IInterpreter interpreter, IStack<Expression> sourceStack)
         {
-            this.body = sourceStack.Pop();
-            this.destinationIndex = interpreter.IntegerStack.Pop();
-            this.currentIndex = 1;
-            this.incrementor = 1;
+            body = sourceStack.Pop();
+            destinationIndex = interpreter.IntegerStack.Pop();
+            currentIndex = 1;
+            incrementor = 1;
         }
 
         protected override void PushIteration(IInterpreter interpreter)
         {
-            interpreter.ExecStack.Push(this, this.body);
+            interpreter.ExecStack.Push(this, body);
         }
 
         protected override void PushLastIteration(IInterpreter interpreter)
         {
-            interpreter.ExecStack.Push(this.body);
+            interpreter.ExecStack.Push(body);
         }
     }
@@ -40,12 +45,26 @@
     /// in the call to CODE.DO*RANGE.
     /// </summary>
-    [StatefullExpression]
+
     public class CodeDoTimesExpression : DoTimesExpression
     {
-        public CodeDoTimesExpression() : base("CODE.DO*TIMES") { }
+        public CodeDoTimesExpression()
+        { }
+
+        protected CodeDoTimesExpression(CodeDoTimesExpression origin, Cloner cloner) : base(origin, cloner)
+        { }
+
+        public override IDeepCloneable Clone(Cloner cloner)
+        {
+            return new CodeDoTimesExpression(this, cloner);
+        }
+
+        protected override string InitStringRepresentation()
+        {
+            return "CODE.DO*TIMES";
+        }
 
         public override void Eval(IInterpreter interpreter)
         {
-            this.Eval(interpreter, interpreter.CodeStack);
+            Eval(interpreter, interpreter.CodeStack);
         }
     }
@@ -57,12 +76,26 @@
     /// pushed by EXEC.DO*RANGE, prior to the execution of the loop body.
     /// </summary>
-    [StatefullExpression]
+
     public class ExecDoTimesExpression : DoTimesExpression
     {
-        public ExecDoTimesExpression() : base("EXEC.DO*TIMES") { }
+        public ExecDoTimesExpression()
+        { }
+
+        protected ExecDoTimesExpression(ExecDoTimesExpression origin, Cloner cloner) : base(origin, cloner)
+        { }
+
+        public override IDeepCloneable Clone(Cloner cloner)
+        {
+            return new ExecDoTimesExpression(this, cloner);
+        }
+
+        protected override string InitStringRepresentation()
+        {
+            return "EXEC.DO*TIMES";
+        }
 
         public override void Eval(IInterpreter interpreter)
         {
-            this.Eval(interpreter, interpreter.ExecStack);
+            Eval(interpreter, interpreter.ExecStack);
         }
     }
Index: branches/PushGP/HeuristicLab.Algorithms.PushGP/HeuristicLab.Algorithms.PushGP/Expressions/DuplicateExpressions.cs
===================================================================
--- branches/PushGP/HeuristicLab.Algorithms.PushGP/HeuristicLab.Algorithms.PushGP/Expressions/DuplicateExpressions.cs	(revision 14397)
+++ branches/PushGP/HeuristicLab.Algorithms.PushGP/HeuristicLab.Algorithms.PushGP/Expressions/DuplicateExpressions.cs	(revision 14398)
@@ -9,9 +9,6 @@
     /// </summary>
     /// <typeparam name="T">Stacktype</typeparam>
-    public abstract class DuplicateExpression<T> : Expression
+    public abstract class DuplicateExpression<T> : StatelessExpression
     {
-        public DuplicateExpression(string stringRepresentation) : base(stringRepresentation)
-        { }
-
         public void Eval(IStack<T> stack)
         {
@@ -25,10 +22,9 @@
     public class IntegerDuplicateExpression : DuplicateExpression<long>
     {
-        public IntegerDuplicateExpression() : base("INTEGER.DUP")
-        { }
+        protected override string InitStringRepresentation() { return "INTEGER.DUP"; }
 
         public override void Eval(IInterpreter interpreter)
         {
-            this.Eval(interpreter.IntegerStack);
+            Eval(interpreter.IntegerStack);
         }
     }
@@ -36,10 +32,9 @@
     public class FloatDuplicateExpression : DuplicateExpression<double>
     {
-        public FloatDuplicateExpression() : base("FLOAT.DUP")
-        { }
+        protected override string InitStringRepresentation() { return "FLOAT.DUP"; }
 
         public override void Eval(IInterpreter interpreter)
         {
-            this.Eval(interpreter.FloatStack);
+            Eval(interpreter.FloatStack);
         }
     }
@@ -47,10 +42,9 @@
     public class BooleanDuplicateExpression : DuplicateExpression<bool>
     {
-        public BooleanDuplicateExpression() : base("BOOLEAN.DUP")
-        { }
+        protected override string InitStringRepresentation() { return "BOOLEAN.DUP"; }
 
         public override void Eval(IInterpreter interpreter)
         {
-            this.Eval(interpreter.BooleanStack);
+            Eval(interpreter.BooleanStack);
         }
     }
@@ -58,10 +52,9 @@
     public class NameDuplicateExpression : DuplicateExpression<string>
     {
-        public NameDuplicateExpression() : base("NAME.DUP")
-        { }
+        protected override string InitStringRepresentation() { return "NAME.DUP"; }
 
         public override void Eval(IInterpreter interpreter)
         {
-            this.Eval(interpreter.NameStack);
+            Eval(interpreter.NameStack);
         }
     }
@@ -69,10 +62,9 @@
     public class ExecDuplicateExpression : DuplicateExpression<Expression>
     {
-        public ExecDuplicateExpression() : base("EXEC.DUP")
-        { }
+        protected override string InitStringRepresentation() { return "EXEC.DUP"; }
 
         public override void Eval(IInterpreter interpreter)
         {
-            this.Eval(interpreter.ExecStack);
+            Eval(interpreter.ExecStack);
         }
     }
@@ -80,10 +72,9 @@
     public class CodeDuplicateExpression : DuplicateExpression<Expression>
     {
-        public CodeDuplicateExpression() : base("CODE.DUP")
-        { }
+        protected override string InitStringRepresentation() { return "CODE.DUP"; }
 
         public override void Eval(IInterpreter interpreter)
         {
-            this.Eval(interpreter.CodeStack);
+            Eval(interpreter.CodeStack);
         }
     }
Index: branches/PushGP/HeuristicLab.Algorithms.PushGP/HeuristicLab.Algorithms.PushGP/Expressions/ERCExpressions.cs
===================================================================
--- branches/PushGP/HeuristicLab.Algorithms.PushGP/HeuristicLab.Algorithms.PushGP/Expressions/ERCExpressions.cs	(revision 14397)
+++ branches/PushGP/HeuristicLab.Algorithms.PushGP/HeuristicLab.Algorithms.PushGP/Expressions/ERCExpressions.cs	(revision 14398)
@@ -1,5 +1,7 @@
-﻿using HeuristicLab.Algorithms.PushGP.Generators;
+﻿using System;
+using HeuristicLab.Algorithms.PushGP.Generators;
 using HeuristicLab.Algorithms.PushGP.Interpreter;
 using HeuristicLab.Algorithms.PushGP.Stack;
+using HeuristicLab.Common;
 using HeuristicLab.Core;
 using HeuristicLab.Random;
@@ -10,5 +12,6 @@
     {
         private readonly T value;
-        public ERCExpression(string stringRepresentation, T value) : base(stringRepresentation)
+
+        public ERCExpression(T value)
         {
             this.value = value;
@@ -17,5 +20,32 @@
         protected void Eval(IStack<T> stack)
         {
-            stack.Push(this.value);
+            stack.Push(value);
+        }
+
+        /// <summary>
+        /// Does not make sense
+        /// </summary>
+        /// <returns></returns>
+        protected override string InitStringRepresentation()
+        {
+            throw new NotImplementedException();
+        }
+
+        /// <summary>
+        /// Does not make sense
+        /// </summary>
+        /// <returns></returns>
+        protected override int InitId()
+        {
+            throw new NotImplementedException();
+        }
+
+        /// <summary>
+        /// Does not make sense
+        /// </summary>
+        /// <returns></returns>
+        public override IDeepCloneable Clone(Cloner cloner)
+        {
+            throw new NotImplementedException();
         }
     }
@@ -23,5 +53,5 @@
     public class IntegerERCExpression : ERCExpression<long>
     {
-        public IntegerERCExpression() : base("INTEGER.ERC", IntegerGenerator.RandomInteger())
+        public IntegerERCExpression() : base(IntegerGenerator.RandomInteger())
         {
         }
@@ -29,5 +59,5 @@
         public override void Eval(IInterpreter interpreter)
         {
-            this.Eval(interpreter.IntegerStack);
+            Eval(interpreter.IntegerStack);
         }
     }
@@ -37,5 +67,5 @@
         protected bool isInitialized = false;
 
-        public FloatERCExpression() : base("FLOAT.ERC", FloatGenerator.RandomFloat())
+        public FloatERCExpression() : base(FloatGenerator.RandomFloat())
         {
         }
@@ -43,5 +73,5 @@
         public override void Eval(IInterpreter interpreter)
         {
-            this.Eval(interpreter.FloatStack);
+            Eval(interpreter.FloatStack);
         }
     }
@@ -49,5 +79,5 @@
     public class BooleanERCExpression : ERCExpression<bool>
     {
-        public BooleanERCExpression() : base("BOOLEAN.ERC", BooleanGenerator.RandomBoolean())
+        public BooleanERCExpression() : base(BooleanGenerator.RandomBoolean())
         {
         }
@@ -55,5 +85,5 @@
         public override void Eval(IInterpreter interpreter)
         {
-            this.Eval(interpreter.BooleanStack);
+            Eval(interpreter.BooleanStack);
         }
     }
@@ -63,5 +93,5 @@
         private static IRandom random = new FastRandom();
 
-        public NameERCExpression() : base("NAME.ERC", NameGenerator.RandomName())
+        public NameERCExpression() : base(NameGenerator.RandomName())
         {
         }
@@ -69,5 +99,5 @@
         public override void Eval(IInterpreter interpreter)
         {
-            this.Eval(interpreter.NameStack);
+            Eval(interpreter.NameStack);
         }
     }
Index: branches/PushGP/HeuristicLab.Algorithms.PushGP/HeuristicLab.Algorithms.PushGP/Expressions/EqualsExpressions.cs
===================================================================
--- branches/PushGP/HeuristicLab.Algorithms.PushGP/HeuristicLab.Algorithms.PushGP/Expressions/EqualsExpressions.cs	(revision 14397)
+++ branches/PushGP/HeuristicLab.Algorithms.PushGP/HeuristicLab.Algorithms.PushGP/Expressions/EqualsExpressions.cs	(revision 14398)
@@ -8,9 +8,6 @@
     /// </summary>
     /// <typeparam name="T">Stacktype</typeparam>
-    public abstract class EqualsExpression<T> : Expression
+    public abstract class EqualsExpression<T> : StatelessExpression
     {
-        public EqualsExpression(string stringRepresentation) : base(stringRepresentation)
-        { }
-
         public void Eval(IStack<T> stack, IStack<bool> booleanStack)
         {
@@ -26,10 +23,9 @@
     public class IntegerEqualsExpression : EqualsExpression<long>
     {
-        public IntegerEqualsExpression() : base("INTEGER.=")
-        { }
+        protected override string InitStringRepresentation() { return "INTEGER.="; }
 
         public override void Eval(IInterpreter interpreter)
         {
-            this.Eval(interpreter.IntegerStack, interpreter.BooleanStack);
+            Eval(interpreter.IntegerStack, interpreter.BooleanStack);
         }
     }
@@ -37,10 +33,9 @@
     public class FloatEqualsExpression : EqualsExpression<double>
     {
-        public FloatEqualsExpression() : base("FLOAT.=")
-        { }
+        protected override string InitStringRepresentation() { return "FLOAT.="; }
 
         public override void Eval(IInterpreter interpreter)
         {
-            this.Eval(interpreter.FloatStack, interpreter.BooleanStack);
+            Eval(interpreter.FloatStack, interpreter.BooleanStack);
         }
     }
@@ -48,10 +43,9 @@
     public class BooleanEqualsExpression : EqualsExpression<bool>
     {
-        public BooleanEqualsExpression() : base("BOOLEAN.=")
-        { }
+        protected override string InitStringRepresentation() { return "BOOLEAN.="; }
 
         public override void Eval(IInterpreter interpreter)
         {
-            this.Eval(interpreter.BooleanStack, interpreter.BooleanStack);
+            Eval(interpreter.BooleanStack, interpreter.BooleanStack);
         }
     }
@@ -59,10 +53,9 @@
     public class NameEqualsExpression : EqualsExpression<string>
     {
-        public NameEqualsExpression() : base("NAME.=")
-        { }
+        protected override string InitStringRepresentation() { return "NAME.="; }
 
         public override void Eval(IInterpreter interpreter)
         {
-            this.Eval(interpreter.NameStack, interpreter.BooleanStack);
+            Eval(interpreter.NameStack, interpreter.BooleanStack);
         }
     }
@@ -70,10 +63,9 @@
     public class ExecEqualsExpression : EqualsExpression<Expression>
     {
-        public ExecEqualsExpression() : base("EXEC.=")
-        { }
+        protected override string InitStringRepresentation() { return "EXEC.="; }
 
         public override void Eval(IInterpreter interpreter)
         {
-            this.Eval(interpreter.ExecStack, interpreter.BooleanStack);
+            Eval(interpreter.ExecStack, interpreter.BooleanStack);
         }
     }
@@ -81,10 +73,9 @@
     public class CodeEqualsExpression : EqualsExpression<Expression>
     {
-        public CodeEqualsExpression() : base("CODE.=")
-        { }
+        protected override string InitStringRepresentation() { return "CODE.="; }
 
         public override void Eval(IInterpreter interpreter)
         {
-            this.Eval(interpreter.CodeStack, interpreter.BooleanStack);
+            Eval(interpreter.CodeStack, interpreter.BooleanStack);
         }
     }
Index: branches/PushGP/HeuristicLab.Algorithms.PushGP/HeuristicLab.Algorithms.PushGP/Expressions/ExecExpressions.cs
===================================================================
--- branches/PushGP/HeuristicLab.Algorithms.PushGP/HeuristicLab.Algorithms.PushGP/Expressions/ExecExpressions.cs	(revision 14397)
+++ branches/PushGP/HeuristicLab.Algorithms.PushGP/HeuristicLab.Algorithms.PushGP/Expressions/ExecExpressions.cs	(revision 14398)
@@ -8,5 +8,5 @@
 namespace HeuristicLab.Algorithms.PushGP.Expressions
 {
-    public class ExecExpandExpression : Expression
+    public class ExecExpandExpression : StatefullExpression
     {
         private const string prefix = "( ";
@@ -15,11 +15,14 @@
 
         public readonly Expression[] Expressions;
+        public readonly bool IsEmpty;
+
         private List<Expression> treeIndex;
 
         public static readonly Expression Empty = new ExecExpandExpression(new Expression[0]);
 
-        public ExecExpandExpression(Expression[] expressions) : base()
-        {
-            this.Expressions = expressions;
+        public ExecExpandExpression(Expression[] expressions)
+        {
+            Expressions = expressions;
+            IsEmpty = expressions.Length == 0;
         }
 
@@ -27,11 +30,13 @@
         public ExecExpandExpression(ExecExpandExpression original, Cloner cloner) : base(original, cloner)
         {
-            this.Expressions = new Expression[original.Expressions.Length];
-            Array.Copy(original.Expressions, this.Expressions, original.Expressions.Length);
+            Expressions = new Expression[original.Expressions.Length];
+            Array.Copy(original.Expressions, Expressions, original.Expressions.Length);
 
             if (original.treeIndex != null)
             {
-                this.treeIndex = original.treeIndex.Select(e => cloner.Clone(e)).ToList();
-            }
+                treeIndex = original.treeIndex.Select(e => cloner.Clone(e)).ToList();
+            }
+
+            IsEmpty = original.IsEmpty;
         }
 
@@ -54,40 +59,32 @@
         }
 
-        private string GetStringRepresentation()
-        {
-            if (this.StringRepresentation == null)
-            {
-                var sb = new StringBuilder();
-
-                sb.Append(prefix);
-
-                for (var i = this.Expressions.Length - 1; i >= 0; i--)
+        protected override string InitStringRepresentation()
+        {
+            var sb = new StringBuilder();
+
+            sb.Append(prefix);
+
+            for (var i = Expressions.Length - 1; i >= 0; i--)
+            {
+                sb.Append(Expressions[i].ToString() + delimiter);
+            }
+
+            sb.Append(postfix);
+
+            return sb.ToString();
+        }
+
+        protected override int InitId()
+        {
+            unchecked
+            {
+                var hash = 19;
+                foreach (var e in Expressions)
                 {
-                    sb.Append(this.Expressions[i].ToString() + delimiter);
+                    hash *= 31 + e.GetHashCode();
                 }
 
-                sb.Append(postfix);
-
-                this.StringRepresentation = sb.ToString();
-            }
-
-            return this.StringRepresentation;
-        }
-
-        private int GetId()
-        {
-            if (this.Id == default(int))
-            {
-                unchecked
-                {
-                    this.Id = 19;
-                    foreach (var e in Expressions)
-                    {
-                        this.Id *= 31 + e.GetHashCode();
-                    }
-                }
-            }
-
-            return this.Id;
+                return hash;
+            }
         }
 
@@ -97,4 +94,9 @@
         }
 
+        public override int GetHashCode()
+        {
+            return base.GetHashCode();
+        }
+
         public override bool Equals(object obj)
         {
@@ -111,20 +113,10 @@
             var other = obj as ExecExpandExpression;
 
-            return this.Expressions.SequenceEqual(other.Expressions);
-        }
-
-        public override int GetHashCode()
-        {
-            return this.GetId();
-        }
-
-        public override string ToString()
-        {
-            return this.GetStringRepresentation();
-        }
-
-        public override void Eval(IInterpreter interpreter)
-        {
-            interpreter.ExecStack.Push(this.Expressions);
+            return Expressions.SequenceEqual(other.Expressions);
+        }
+
+        public override void Eval(IInterpreter interpreter)
+        {
+            interpreter.ExecStack.Push(Expressions);
         }
 
@@ -137,7 +129,7 @@
             get
             {
-                this.BuildIndexIfNecessary();
-
-                return this.treeIndex.Count;
+                BuildIndexIfNecessary();
+
+                return treeIndex.Count;
             }
         }
@@ -150,30 +142,30 @@
         public Expression GetFromTree(int index)
         {
-            this.BuildIndexIfNecessary();
-
-            return this.treeIndex[index];
+            BuildIndexIfNecessary();
+
+            return treeIndex[index];
         }
 
         private void BuildIndexIfNecessary()
         {
-            if (this.treeIndex != null)
-                return;
-
-            this.treeIndex = new List<Expression>(this.Expressions.Length) { this };
-
-            for (var i = this.Expressions.Length - 1; i >= 0; i--)
-            {
-                var subExpression = this.Expressions[i];
+            if (treeIndex != null)
+                return;
+
+            treeIndex = new List<Expression>(Expressions.Length) { this };
+
+            for (var i = Expressions.Length - 1; i >= 0; i--)
+            {
+                var subExpression = Expressions[i];
 
                 if (subExpression.GetType() == typeof(ExecExpandExpression))
                 {
-                    var list = subExpression as ExecExpandExpression;
-
-                    list.BuildIndexIfNecessary();
-                    this.treeIndex.AddRange(list.treeIndex);
+                    var expand = subExpression as ExecExpandExpression;
+
+                    expand.BuildIndexIfNecessary();
+                    treeIndex.AddRange(expand.treeIndex);
                 }
                 else
                 {
-                    this.treeIndex.Add(subExpression);
+                    treeIndex.Add(subExpression);
                 }
 
@@ -188,7 +180,7 @@
     /// the BOOLEAN stack.
     /// </summary>
-    public class ExecIfExpression : Expression
-    {
-        public ExecIfExpression() : base("EXEC.IF") { }
+    public class ExecIfExpression : StatelessExpression
+    {
+        protected override string InitStringRepresentation() { return "EXEC.IF"; }
 
         public override void Eval(IInterpreter interpreter)
@@ -212,9 +204,7 @@
     /// "( EXEC.Y <TopItem> )".
     /// </summary>
-    public class ExecYExpression : Expression
-    {
-        public ExecYExpression() : base("EXEC.Y")
-        {
-        }
+    public class ExecYExpression : StatelessExpression
+    {
+        protected override string InitStringRepresentation() { return "EXEC.Y"; }
 
         public override void Eval(IInterpreter interpreter)
@@ -237,7 +227,7 @@
     /// The Push implementation of the "K combinator". Removes the second item on the EXEC stack.
     /// </summary>
-    public class ExecKExpression : Expression
-    {
-        public ExecKExpression() : base("EXEC.K") { }
+    public class ExecKExpression : StatelessExpression
+    {
+        protected override string InitStringRepresentation() { return "EXEC.K"; }
 
         public override void Eval(IInterpreter interpreter)
@@ -256,7 +246,7 @@
     /// another instance of C, followed by another instance of A.
     /// </summary>
-    public class ExecSExpression : Expression
-    {
-        public ExecSExpression() : base("EXEC.S") { }
+    public class ExecSExpression : StatelessExpression
+    {
+        protected override string InitStringRepresentation() { return "EXEC.S"; }
 
         public override void Eval(IInterpreter interpreter)
Index: branches/PushGP/HeuristicLab.Algorithms.PushGP/HeuristicLab.Algorithms.PushGP/Expressions/Expression.cs
===================================================================
--- branches/PushGP/HeuristicLab.Algorithms.PushGP/HeuristicLab.Algorithms.PushGP/Expressions/Expression.cs	(revision 14397)
+++ branches/PushGP/HeuristicLab.Algorithms.PushGP/HeuristicLab.Algorithms.PushGP/Expressions/Expression.cs	(revision 14398)
@@ -6,45 +6,64 @@
     public abstract class Expression : DeepCloneable
     {
-        public Expression() { }
+        private string stringRepresentation;
+        private int id;
 
-        public Expression(string stringRepresenation) : this(stringRepresenation, stringRepresenation.GetHashCode())
+        public Expression()
         { }
 
-        public Expression(string stringRepresenation, int id)
+        /// <summary>
+        /// Clone Constructor
+        /// </summary>
+        protected Expression(Expression origin, Cloner cloner)
         {
-            this.StringRepresentation = stringRepresenation;
-            this.Id = id;
+            stringRepresentation = origin.stringRepresentation;
+            id = origin.id;
         }
-
-        // copy constructor
-        public Expression(Expression original, Cloner cloner) : base(original, cloner)
-        {
-            this.StringRepresentation = original.StringRepresentation;
-            this.Id = original.Id;
-        }
-
-        protected int Id { get; set; }
-        protected string StringRepresentation { get; set; }
 
         public abstract void Eval(IInterpreter interpreter);
 
-        public override string ToString()
+        protected abstract int InitId();
+
+        protected abstract string InitStringRepresentation();
+
+        public string StringRepresentation
         {
-            return this.StringRepresentation;
+            get
+            {
+                if (stringRepresentation == null)
+                {
+                    stringRepresentation = InitStringRepresentation();
+                }
+
+                return stringRepresentation;
+            }
+        }
+
+        public int Id
+        {
+            get
+            {
+                if (id == default(int))
+                {
+                    id = InitId();
+                }
+
+                return id;
+            }
         }
 
         public override bool Equals(object obj)
         {
-            return obj != null && this.GetType() == obj.GetType();
+            return obj != null && (GetHashCode() == obj.GetHashCode() || GetType() == obj.GetType());
+        }
+
+        public override string ToString()
+        {
+            return StringRepresentation;
         }
 
         public override int GetHashCode()
         {
-            return this.Id;
-        }
-
-        public override IDeepCloneable Clone(Cloner cloner)
-        {
-            return this;
+            return Id;
         }
     }
Index: branches/PushGP/HeuristicLab.Algorithms.PushGP/HeuristicLab.Algorithms.PushGP/Expressions/FloatExpressions.cs
===================================================================
--- branches/PushGP/HeuristicLab.Algorithms.PushGP/HeuristicLab.Algorithms.PushGP/Expressions/FloatExpressions.cs	(revision 14397)
+++ branches/PushGP/HeuristicLab.Algorithms.PushGP/HeuristicLab.Algorithms.PushGP/Expressions/FloatExpressions.cs	(revision 14398)
@@ -9,10 +9,9 @@
     public class FloatAddExpression : PushResultExpression<double>
     {
-        public FloatAddExpression() : base("FLOAT.+")
-        { }
-
-        public override void Eval(IInterpreter interpreter)
-        {
-            this.Eval(interpreter.FloatStack, 2, values => values[0] + values[1]);
+        protected override string InitStringRepresentation() { return "FLOAT.+"; }
+
+        public override void Eval(IInterpreter interpreter)
+        {
+            Eval(interpreter.FloatStack, 2, values => values[0] + values[1]);
         }
     }
@@ -23,10 +22,9 @@
     public class FloatSubtractExpression : PushResultExpression<double>
     {
-        public FloatSubtractExpression() : base("FLOAT.-")
-        { }
-
-        public override void Eval(IInterpreter interpreter)
-        {
-            this.Eval(interpreter.FloatStack, 2, values => values[0] - values[1]);
+        protected override string InitStringRepresentation() { return "FLOAT.-"; }
+
+        public override void Eval(IInterpreter interpreter)
+        {
+            Eval(interpreter.FloatStack, 2, values => values[0] - values[1]);
         }
     }
@@ -37,10 +35,9 @@
     public class FloatMultiplyExpression : PushResultExpression<double>
     {
-        public FloatMultiplyExpression() : base("FLOAT.*")
-        { }
-
-        public override void Eval(IInterpreter interpreter)
-        {
-            this.Eval(interpreter.FloatStack, 2, values => values[0] * values[1]);
+        protected override string InitStringRepresentation() { return "FLOAT.*"; }
+
+        public override void Eval(IInterpreter interpreter)
+        {
+            Eval(interpreter.FloatStack, 2, values => values[0] * values[1]);
         }
     }
@@ -52,10 +49,9 @@
     public class FloatDivideExpression : PushResultExpression<double>
     {
-        public FloatDivideExpression() : base("FLOAT./")
-        { }
-
-        public override void Eval(IInterpreter interpreter)
-        {
-            this.Eval(interpreter.FloatStack, 2, values => values[0] / values[1], 0);
+        protected override string InitStringRepresentation() { return "FLOAT./"; }
+
+        public override void Eval(IInterpreter interpreter)
+        {
+            Eval(interpreter.FloatStack, 2, values => values[0] / values[1], 0);
         }
     }
@@ -69,10 +65,9 @@
     public class FloatModuloExpression : PushResultExpression<double>
     {
-        public FloatModuloExpression() : base("FLOAT.%")
-        { }
-
-        public override void Eval(IInterpreter interpreter)
-        {
-            this.Eval(interpreter.FloatStack, 2, values => values[0] % values[1], 0);
+        protected override string InitStringRepresentation() { return "FLOAT.%"; }
+
+        public override void Eval(IInterpreter interpreter)
+        {
+            Eval(interpreter.FloatStack, 2, values => values[0] % values[1], 0);
         }
     }
@@ -83,10 +78,9 @@
     public class FloatMinExpression : PushResultExpression<double>
     {
-        public FloatMinExpression() : base("FLOAT.MIN")
-        { }
-
-        public override void Eval(IInterpreter interpreter)
-        {
-            this.Eval(interpreter.FloatStack, 2, values => Math.Min(values[0], values[1]));
+        protected override string InitStringRepresentation() { return "FLOAT.MIN"; }
+
+        public override void Eval(IInterpreter interpreter)
+        {
+            Eval(interpreter.FloatStack, 2, values => Math.Min(values[0], values[1]));
         }
     }
@@ -97,10 +91,9 @@
     public class FloatMaxExpression : PushResultExpression<double>
     {
-        public FloatMaxExpression() : base("FLOAT.MAX")
-        { }
-
-        public override void Eval(IInterpreter interpreter)
-        {
-            this.Eval(interpreter.FloatStack, 2, values => Math.Max(values[0], values[1]));
+        protected override string InitStringRepresentation() { return "FLOAT.MAX"; }
+
+        public override void Eval(IInterpreter interpreter)
+        {
+            Eval(interpreter.FloatStack, 2, values => Math.Max(values[0], values[1]));
         }
     }
@@ -111,10 +104,9 @@
     public class FloatSmallerThanExpression : PushResultExpression<double>
     {
-        public FloatSmallerThanExpression() : base("FLOAT.<")
-        { }
-
-        public override void Eval(IInterpreter interpreter)
-        {
-            this.Eval(
+        protected override string InitStringRepresentation() { return "FLOAT.<"; }
+
+        public override void Eval(IInterpreter interpreter)
+        {
+            Eval(
                 interpreter.FloatStack,
                 interpreter.BooleanStack,
@@ -129,10 +121,9 @@
     public class FloatGreaterThanExpression : PushResultExpression<double>
     {
-        public FloatGreaterThanExpression() : base("FLOAT.>")
-        { }
-
-        public override void Eval(IInterpreter interpreter)
-        {
-            this.Eval(
+        protected override string InitStringRepresentation() { return "FLOAT.>"; }
+
+        public override void Eval(IInterpreter interpreter)
+        {
+            Eval(
                 interpreter.FloatStack,
                 interpreter.BooleanStack,
@@ -147,10 +138,9 @@
     public class FloatSineExpression : PushResultExpression<double>
     {
-        public FloatSineExpression() : base("FLOAT.SIN")
-        { }
-
-        public override void Eval(IInterpreter interpreter)
-        {
-            this.Eval(
+        protected override string InitStringRepresentation() { return "FLOAT.SIN"; }
+
+        public override void Eval(IInterpreter interpreter)
+        {
+            Eval(
                 interpreter.FloatStack,
                 1,
@@ -164,9 +154,9 @@
     public class FloatCosineExpression : PushResultExpression<double>
     {
-        public FloatCosineExpression() : base("FLOAT.COS") { }
-
-        public override void Eval(IInterpreter interpreter)
-        {
-            this.Eval(
+        protected override string InitStringRepresentation() { return "FLOAT.COS"; }
+
+        public override void Eval(IInterpreter interpreter)
+        {
+            Eval(
                 interpreter.FloatStack,
                 1,
@@ -178,7 +168,7 @@
     /// Pushes 1 if the top BOOLEAN is TRUE, or 0 if the top BOOLEAN is FALSE.
     /// </summary>
-    public class FloatFromBooleanExpression : Expression
-    {
-        public FloatFromBooleanExpression() : base("FLOAT.FROMBOOLEAN") { }
+    public class FloatFromBooleanExpression : StatelessExpression
+    {
+        protected override string InitStringRepresentation() { return "FLOAT.FROMBOOLEAN"; }
 
         public override void Eval(IInterpreter interpreter)
@@ -197,9 +187,7 @@
     /// Pushes a floating point version of the top INTEGER.
     /// </summary>
-    public class FloatFromIntegerExpression : Expression
-    {
-        public FloatFromIntegerExpression() : base("FLOAT.FROMINTEGER")
-        {
-        }
+    public class FloatFromIntegerExpression : StatelessExpression
+    {
+        protected override string InitStringRepresentation() { return "FLOAT.FROMINTEGER"; }
 
         public override void Eval(IInterpreter interpreter)
Index: branches/PushGP/HeuristicLab.Algorithms.PushGP/HeuristicLab.Algorithms.PushGP/Expressions/FlushExpressions.cs
===================================================================
--- branches/PushGP/HeuristicLab.Algorithms.PushGP/HeuristicLab.Algorithms.PushGP/Expressions/FlushExpressions.cs	(revision 14397)
+++ branches/PushGP/HeuristicLab.Algorithms.PushGP/HeuristicLab.Algorithms.PushGP/Expressions/FlushExpressions.cs	(revision 14398)
@@ -8,9 +8,6 @@
     /// </summary>
     /// <typeparam name="T">Stacktype</typeparam>
-    public abstract class FlushExpression<T> : Expression
+    public abstract class FlushExpression<T> : StatelessExpression
     {
-        public FlushExpression(string stringRepresentation) : base(stringRepresentation)
-        { }
-
         public void Eval(IStack<T> stack)
         {
@@ -21,10 +18,9 @@
     public class IntegerFlushExpression : FlushExpression<long>
     {
-        public IntegerFlushExpression() : base("INTEGER.FLUSH")
-        { }
+        protected override string InitStringRepresentation() { return "INTEGER.FLUSH"; }
 
         public override void Eval(IInterpreter interpreter)
         {
-            this.Eval(interpreter.IntegerStack);
+            Eval(interpreter.IntegerStack);
         }
     }
@@ -32,10 +28,9 @@
     public class FloatFlushExpression : FlushExpression<double>
     {
-        public FloatFlushExpression() : base("FLOAT.FLUSH")
-        { }
+        protected override string InitStringRepresentation() { return "FLOAT.FLUSH"; }
 
         public override void Eval(IInterpreter interpreter)
         {
-            this.Eval(interpreter.FloatStack);
+            Eval(interpreter.FloatStack);
         }
     }
@@ -43,10 +38,9 @@
     public class BooleanFlushExpression : FlushExpression<bool>
     {
-        public BooleanFlushExpression() : base("BOOLEAN.FLUSH")
-        { }
+        protected override string InitStringRepresentation() { return "BOOLEAN.FLUSH"; }
 
         public override void Eval(IInterpreter interpreter)
         {
-            this.Eval(interpreter.BooleanStack);
+            Eval(interpreter.BooleanStack);
         }
     }
@@ -54,10 +48,9 @@
     public class NameFlushExpression : FlushExpression<string>
     {
-        public NameFlushExpression() : base("NAME.FLUSH")
-        { }
+        protected override string InitStringRepresentation() { return "NAME.FLUSH"; }
 
         public override void Eval(IInterpreter interpreter)
         {
-            this.Eval(interpreter.NameStack);
+            Eval(interpreter.NameStack);
         }
     }
@@ -65,10 +58,9 @@
     public class ExecFlushExpression : FlushExpression<Expression>
     {
-        public ExecFlushExpression() : base("EXEC.FLUSH")
-        { }
+        protected override string InitStringRepresentation() { return "EXEC.FLUSH"; }
 
         public override void Eval(IInterpreter interpreter)
         {
-            this.Eval(interpreter.ExecStack);
+            Eval(interpreter.ExecStack);
         }
     }
@@ -76,10 +68,9 @@
     public class CodeFlushExpression : FlushExpression<Expression>
     {
-        public CodeFlushExpression() : base("CODE.FLUSH")
-        { }
+        protected override string InitStringRepresentation() { return "CODE.FLUSH"; }
 
         public override void Eval(IInterpreter interpreter)
         {
-            this.Eval(interpreter.CodeStack);
+            Eval(interpreter.CodeStack);
         }
     }
Index: branches/PushGP/HeuristicLab.Algorithms.PushGP/HeuristicLab.Algorithms.PushGP/Expressions/IntegerExpressions.cs
===================================================================
--- branches/PushGP/HeuristicLab.Algorithms.PushGP/HeuristicLab.Algorithms.PushGP/Expressions/IntegerExpressions.cs	(revision 14397)
+++ branches/PushGP/HeuristicLab.Algorithms.PushGP/HeuristicLab.Algorithms.PushGP/Expressions/IntegerExpressions.cs	(revision 14398)
@@ -9,9 +9,9 @@
     public class IntegerAddExpression : PushResultExpression<long>
     {
-        public IntegerAddExpression() : base("INTEGER.+") { }
+        protected override string InitStringRepresentation() { return "INTEGER.+"; }
 
         public override void Eval(IInterpreter interpreter)
         {
-            this.Eval(interpreter.IntegerStack, 2, values => values[0] + values[1]);
+            Eval(interpreter.IntegerStack, 2, values => values[0] + values[1]);
         }
     }
@@ -22,9 +22,9 @@
     public class IntegerSubtractExpression : PushResultExpression<long>
     {
-        public IntegerSubtractExpression() : base("INTEGER.-") { }
+        protected override string InitStringRepresentation() { return "INTEGER.-"; }
 
         public override void Eval(IInterpreter interpreter)
         {
-            this.Eval(interpreter.IntegerStack, 2, values => values[0] - values[1]);
+            Eval(interpreter.IntegerStack, 2, values => values[0] - values[1]);
         }
     }
@@ -35,9 +35,9 @@
     public class IntegerMultiplyExpression : PushResultExpression<long>
     {
-        public IntegerMultiplyExpression() : base("INTEGER.*") { }
+        protected override string InitStringRepresentation() { return "INTEGER.*"; }
 
         public override void Eval(IInterpreter interpreter)
         {
-            this.Eval(interpreter.IntegerStack, 2, values => values[0] * values[1]);
+            Eval(interpreter.IntegerStack, 2, values => values[0] * values[1]);
         }
     }
@@ -49,9 +49,9 @@
     public class IntegerDivideExpression : PushResultExpression<long>
     {
-        public IntegerDivideExpression() : base("INTEGER./") { }
+        protected override string InitStringRepresentation() { return "INTEGER./"; }
 
         public override void Eval(IInterpreter interpreter)
         {
-            this.Eval(interpreter.IntegerStack, 2, values => values[0] / values[1], 0);
+            Eval(interpreter.IntegerStack, 2, values => values[0] / values[1], 0);
         }
     }
@@ -65,9 +65,9 @@
     public class IntegerModuloExpression : PushResultExpression<long>
     {
-        public IntegerModuloExpression() : base("INTEGER.%") { }
+        protected override string InitStringRepresentation() { return "INTEGER.%"; }
 
         public override void Eval(IInterpreter interpreter)
         {
-            this.Eval(interpreter.IntegerStack, 2, values => values[0] % values[1], 0);
+            Eval(interpreter.IntegerStack, 2, values => values[0] % values[1], 0);
         }
     }
@@ -78,9 +78,9 @@
     public class IntegerMinExpression : PushResultExpression<long>
     {
-        public IntegerMinExpression() : base("INTEGER.MIN") { }
+        protected override string InitStringRepresentation() { return "INTEGER.MIN"; }
 
         public override void Eval(IInterpreter interpreter)
         {
-            this.Eval(interpreter.IntegerStack, 2, values => Math.Min(values[0], values[1]));
+            Eval(interpreter.IntegerStack, 2, values => Math.Min(values[0], values[1]));
         }
     }
@@ -91,9 +91,9 @@
     public class IntegerMaxExpression : PushResultExpression<long>
     {
-        public IntegerMaxExpression() : base("INTEGER.MAX") { }
+        protected override string InitStringRepresentation() { return "INTEGER.MAX"; }
 
         public override void Eval(IInterpreter interpreter)
         {
-            this.Eval(interpreter.IntegerStack, 2, values => Math.Max(values[0], values[1]));
+            Eval(interpreter.IntegerStack, 2, values => Math.Max(values[0], values[1]));
         }
     }
@@ -104,9 +104,9 @@
     public class IntegerSmallerThanExpression : PushResultExpression<long>
     {
-        public IntegerSmallerThanExpression() : base("INTEGER.<") { }
+        protected override string InitStringRepresentation() { return "INTEGER.<"; }
 
         public override void Eval(IInterpreter interpreter)
         {
-            this.Eval(
+            Eval(
                 interpreter.IntegerStack,
                 interpreter.BooleanStack,
@@ -121,9 +121,9 @@
     public class IntegerGreaterThanExpression : PushResultExpression<long>
     {
-        public IntegerGreaterThanExpression() : base("INTEGER.>") { }
+        protected override string InitStringRepresentation() { return "INTEGER.>"; }
 
         public override void Eval(IInterpreter interpreter)
         {
-            this.Eval(
+            Eval(
                 interpreter.IntegerStack,
                 interpreter.BooleanStack,
@@ -136,7 +136,7 @@
     /// Pushes 1 if the top BOOLEAN is TRUE, or 0 if the top BOOLEAN is FALSE.
     /// </summary>
-    public class IntegerFromBooleanExpression : Expression
+    public class IntegerFromBooleanExpression : StatelessExpression
     {
-        public IntegerFromBooleanExpression() : base("INTEGER.FROMBOOLEAN") { }
+        protected override string InitStringRepresentation() { return "INTEGER.FROMBOOLEAN"; }
 
         public override void Eval(IInterpreter interpreter)
@@ -155,7 +155,7 @@
     /// Pushes the result of truncating the top FLOAT.
     /// </summary>
-    public class IntegerFromFloatExpression : Expression
+    public class IntegerFromFloatExpression : StatelessExpression
     {
-        public IntegerFromFloatExpression() : base("INTEGER.FROMFLOAT") { }
+        protected override string InitStringRepresentation() { return "INTEGER.FROMFLOAT"; }
 
         public override void Eval(IInterpreter interpreter)
Index: branches/PushGP/HeuristicLab.Algorithms.PushGP/HeuristicLab.Algorithms.PushGP/Expressions/LoopExpression.cs
===================================================================
--- branches/PushGP/HeuristicLab.Algorithms.PushGP/HeuristicLab.Algorithms.PushGP/Expressions/LoopExpression.cs	(revision 14397)
+++ branches/PushGP/HeuristicLab.Algorithms.PushGP/HeuristicLab.Algorithms.PushGP/Expressions/LoopExpression.cs	(revision 14398)
@@ -1,30 +1,42 @@
 ﻿using HeuristicLab.Algorithms.PushGP.Interpreter;
 using HeuristicLab.Algorithms.PushGP.Stack;
+using HeuristicLab.Common;
 
 namespace HeuristicLab.Algorithms.PushGP.Expressions
 {
-    public abstract class LoopExpression : Expression
+    public abstract class LoopExpression : StatefullExpression
     {
-        public long destinationIndex;
-        public long currentIndex;
-        public long incrementor;
-        public bool pushCurrentIndex = false;
-        public Expression body;
+        protected long destinationIndex;
+        protected long currentIndex;
+        protected long incrementor;
+        protected Expression body;
 
-        public LoopExpression(string stringRepresentation) : base(stringRepresentation) { }
+        public LoopExpression()
+        { }
 
-        protected void Eval(IInterpreter interpreter, IStack<Expression> sourceStack)
+        /// <summary>
+        /// Clone constructor
+        /// </summary>
+        protected LoopExpression(LoopExpression origin, Cloner cloner) : base(origin, cloner)
+        {
+            destinationIndex = origin.destinationIndex;
+            currentIndex = origin.currentIndex;
+            incrementor = origin.incrementor;
+            body = origin.body;
+        }
+
+        protected void Eval(IInterpreter interpreter, IStack<Expression> sourceStack, bool pushCurrentIndex = false)
         {
             // if not initialized
             if (body == null)
             {
-                if (this.HasInsufficientArguments(interpreter, sourceStack))
+                if (HasInsufficientArguments(interpreter, sourceStack))
                 {
                     return;
                 }
 
-                this.InitState(interpreter, sourceStack);
+                InitState(interpreter, sourceStack);
 
-                interpreter.ExecStack.Push(this, this.body);
+                interpreter.ExecStack.Push(this, body);
 
                 return;
@@ -34,29 +46,29 @@
             if (destinationIndex == currentIndex)
             {
-                this.PushLastIteration(interpreter);
-                this.Clear();
+                PushLastIteration(interpreter);
+                Clear();
 
                 return;
             }
 
-            this.PushIteration(interpreter);
-            this.currentIndex += this.incrementor;
+            PushIteration(interpreter);
+            currentIndex += incrementor;
         }
 
         protected virtual void Clear()
         {
-            this.body = null;
+            body = null;
         }
 
         protected virtual void PushIteration(IInterpreter interpreter)
         {
-            interpreter.IntegerStack.Push(this.currentIndex);
-            interpreter.ExecStack.Push(this, this.body);
+            interpreter.IntegerStack.Push(currentIndex);
+            interpreter.ExecStack.Push(this, body);
         }
 
         protected virtual void PushLastIteration(IInterpreter interpreter)
         {
-            interpreter.IntegerStack.Push(this.currentIndex);
-            interpreter.ExecStack.Push(this.body);
+            interpreter.IntegerStack.Push(currentIndex);
+            interpreter.ExecStack.Push(body);
         }
 
@@ -71,11 +83,35 @@
 
             var isBodyEqual =
-                (this.body == null && other.body == null) ||
-                (this.body != null && other.body != null && this.body.Equals(other.body));
+                (body == null && other.body == null) ||
+                (body != null && other.body != null && body.Equals(other.body));
 
             return isBodyEqual &&
-                this.currentIndex == other.currentIndex &&
-                this.destinationIndex == other.destinationIndex &&
-                this.incrementor == other.incrementor;
+                currentIndex == other.currentIndex &&
+                destinationIndex == other.destinationIndex &&
+                incrementor == other.incrementor;
+        }
+
+        public override int GetHashCode()
+        {
+            return base.GetHashCode();
+        }
+
+        protected override int InitId()
+        {
+            unchecked
+            {
+                var hash = 19;
+
+                if (body != null)
+                {
+                    hash *= 31 + body.GetHashCode();
+                }
+
+                hash *= 31 + currentIndex.GetHashCode();
+                hash *= 31 + destinationIndex.GetHashCode();
+                hash *= 31 + incrementor.GetHashCode();
+
+                return hash;
+            }
         }
 
Index: branches/PushGP/HeuristicLab.Algorithms.PushGP/HeuristicLab.Algorithms.PushGP/Expressions/NameExpressions.cs
===================================================================
--- branches/PushGP/HeuristicLab.Algorithms.PushGP/HeuristicLab.Algorithms.PushGP/Expressions/NameExpressions.cs	(revision 14397)
+++ branches/PushGP/HeuristicLab.Algorithms.PushGP/HeuristicLab.Algorithms.PushGP/Expressions/NameExpressions.cs	(revision 14398)
@@ -1,4 +1,6 @@
-﻿using System.Linq;
+﻿using System;
+using System.Linq;
 using HeuristicLab.Algorithms.PushGP.Interpreter;
+using HeuristicLab.Common;
 using HeuristicLab.Core;
 using HeuristicLab.Random;
@@ -6,7 +8,16 @@
 namespace HeuristicLab.Algorithms.PushGP.Expressions
 {
-    public class NameDefineXExecExpression : Expression
+    public class NameDefineXExecExpression : StatefullExpression
     {
-        public NameDefineXExecExpression(string name) : base(name) { }
+        private readonly string name;
+        public NameDefineXExecExpression(string name)
+        {
+            this.name = name;
+        }
+
+        public NameDefineXExecExpression(NameDefineXExecExpression origin, Cloner cloner) : base(origin, cloner)
+        {
+            name = origin.name;
+        }
 
         public override void Eval(IInterpreter interpreter)
@@ -14,5 +25,5 @@
             Expression expression;
             if (!interpreter.IsNameQuoteFlagSet &&
-                interpreter.CustomExpressions.TryGetValue(this.StringRepresentation, out expression))
+                interpreter.CustomExpressions.TryGetValue(name, out expression))
             {
                 interpreter.ExecStack.Push(expression);
@@ -20,5 +31,5 @@
             else
             {
-                interpreter.NameStack.Push(this.StringRepresentation);
+                interpreter.NameStack.Push(name);
                 interpreter.IsNameQuoteFlagSet = false;
             }
@@ -32,5 +43,27 @@
             }
 
-            return this.StringRepresentation.Equals(obj.ToString());
+            var other = obj as NameDefineXExecExpression;
+
+            return name.Equals(other.name);
+        }
+
+        public override int GetHashCode()
+        {
+            return base.GetHashCode();
+        }
+
+        protected override string InitStringRepresentation()
+        {
+            return name;
+        }
+
+        protected override int InitId()
+        {
+            return name.GetHashCode();
+        }
+
+        public override IDeepCloneable Clone(Cloner cloner)
+        {
+            throw new NotImplementedException();
         }
     }
@@ -41,7 +74,10 @@
     /// onto the NAME stack the flag will be cleared (whether or not the pushed name had a definition).
     /// </summary>
-    public class NameQuoteExpression : Expression
+    public class NameQuoteExpression : StatelessExpression
     {
-        public NameQuoteExpression() : base("NAME.QUOTE") { }
+        protected override string InitStringRepresentation()
+        {
+            return "NAME.QUOTE";
+        }
 
         public override void Eval(IInterpreter interpreter)
@@ -54,9 +90,12 @@
     /// Pushes a randomly selected NAME that already has a definition.
     /// </summary>
-    public class NameRandBoundNameExpression : Expression
+    public class NameRandBoundNameExpression : StatelessExpression
     {
         private static IRandom rand = new FastRandom();
 
-        public NameRandBoundNameExpression() : base("NAME.RANDBOUNDNAME") { }
+        protected override string InitStringRepresentation()
+        {
+            return "NAME.RANDBOUNDNAME";
+        }
 
         public override void Eval(IInterpreter interpreter)
Index: branches/PushGP/HeuristicLab.Algorithms.PushGP/HeuristicLab.Algorithms.PushGP/Expressions/PopExpressions.cs
===================================================================
--- branches/PushGP/HeuristicLab.Algorithms.PushGP/HeuristicLab.Algorithms.PushGP/Expressions/PopExpressions.cs	(revision 14397)
+++ branches/PushGP/HeuristicLab.Algorithms.PushGP/HeuristicLab.Algorithms.PushGP/Expressions/PopExpressions.cs	(revision 14398)
@@ -4,10 +4,6 @@
 namespace HeuristicLab.Algorithms.PushGP.Expressions
 {
-    public abstract class PopExpression<T> : Expression
+    public abstract class PopExpression<T> : StatelessExpression
     {
-        public PopExpression(string stringRepresentation) : base(stringRepresentation)
-        {
-        }
-
         public void Eval(IStack<T> stack)
         {
@@ -21,11 +17,9 @@
     public class IntegerPopExpression : PopExpression<long>
     {
-        public IntegerPopExpression() : base("INTEGER.POP")
-        {
-        }
+        protected override string InitStringRepresentation() { return "INTEGER.POP"; }
 
         public override void Eval(IInterpreter interpreter)
         {
-            this.Eval(interpreter.IntegerStack);
+            Eval(interpreter.IntegerStack);
         }
     }
@@ -33,11 +27,9 @@
     public class FloatPopExpression : PopExpression<double>
     {
-        public FloatPopExpression() : base("FLOAT.POP")
-        {
-        }
+        protected override string InitStringRepresentation() { return "FLOAT.POP"; }
 
         public override void Eval(IInterpreter interpreter)
         {
-            this.Eval(interpreter.FloatStack);
+            Eval(interpreter.FloatStack);
         }
     }
@@ -45,11 +37,9 @@
     public class BooleanPopExpression : PopExpression<bool>
     {
-        public BooleanPopExpression() : base("BOOLEAN.POP")
-        {
-        }
+        protected override string InitStringRepresentation() { return "BOOLEAN.POP"; }
 
         public override void Eval(IInterpreter interpreter)
         {
-            this.Eval(interpreter.BooleanStack);
+            Eval(interpreter.BooleanStack);
         }
     }
@@ -57,11 +47,9 @@
     public class NamePopExpression : PopExpression<string>
     {
-        public NamePopExpression() : base("NAME.POP")
-        {
-        }
+        protected override string InitStringRepresentation() { return "NAME.POP"; }
 
         public override void Eval(IInterpreter interpreter)
         {
-            this.Eval(interpreter.NameStack);
+            Eval(interpreter.NameStack);
         }
     }
@@ -69,11 +57,9 @@
     public class ExecPopExpression : PopExpression<Expression>
     {
-        public ExecPopExpression() : base("EXEC.POP")
-        {
-        }
+        protected override string InitStringRepresentation() { return "EXEC.POP"; }
 
         public override void Eval(IInterpreter interpreter)
         {
-            this.Eval(interpreter.ExecStack);
+            Eval(interpreter.ExecStack);
         }
     }
@@ -81,11 +67,9 @@
     public class CodePopExpression : PopExpression<Expression>
     {
-        public CodePopExpression() : base("CODE.POP")
-        {
-        }
+        protected override string InitStringRepresentation() { return "CODE.POP"; }
 
         public override void Eval(IInterpreter interpreter)
         {
-            this.Eval(interpreter.CodeStack);
+            Eval(interpreter.CodeStack);
         }
     }
Index: branches/PushGP/HeuristicLab.Algorithms.PushGP/HeuristicLab.Algorithms.PushGP/Expressions/PushExpressions.cs
===================================================================
--- branches/PushGP/HeuristicLab.Algorithms.PushGP/HeuristicLab.Algorithms.PushGP/Expressions/PushExpressions.cs	(revision 14397)
+++ branches/PushGP/HeuristicLab.Algorithms.PushGP/HeuristicLab.Algorithms.PushGP/Expressions/PushExpressions.cs	(revision 14398)
@@ -5,9 +5,9 @@
 namespace HeuristicLab.Algorithms.PushGP.Expressions
 {
-    public abstract class PushExpression<T> : Expression
+    public abstract class PushExpression<T> : StatefullExpression
     {
         protected readonly T value;
 
-        public PushExpression(T value) : base(value.ToString(), value.GetHashCode())
+        public PushExpression(T value)
         {
             this.value = value;
@@ -17,10 +17,20 @@
         public PushExpression(PushExpression<T> expression, Cloner cloner) : base(expression, cloner)
         {
-            this.value = expression.value;
+            value = expression.value;
+        }
+
+        protected override int InitId()
+        {
+            return this.value.GetHashCode();
+        }
+
+        protected override string InitStringRepresentation()
+        {
+            return this.value.ToString();
         }
 
         protected void Eval(IStack<T> stack)
         {
-            stack.Push(this.value);
+            stack.Push(value);
         }
 
@@ -34,5 +44,10 @@
             var other = obj as PushExpression<T>;
 
-            return this.value.Equals(value);
+            return value.Equals(value);
+        }
+
+        public override int GetHashCode()
+        {
+            return base.GetHashCode();
         }
     }
@@ -49,5 +64,5 @@
         public override void Eval(IInterpreter interpreter)
         {
-            this.Eval(interpreter.IntegerStack);
+            Eval(interpreter.IntegerStack);
         }
 
@@ -69,5 +84,5 @@
         public override void Eval(IInterpreter interpreter)
         {
-            this.Eval(interpreter.FloatStack);
+            Eval(interpreter.FloatStack);
         }
 
@@ -89,5 +104,5 @@
         public override void Eval(IInterpreter interpreter)
         {
-            this.Eval(interpreter.BooleanStack);
+            Eval(interpreter.BooleanStack);
         }
 
@@ -109,5 +124,5 @@
         public override void Eval(IInterpreter interpreter)
         {
-            this.Eval(interpreter.NameStack);
+            Eval(interpreter.NameStack);
         }
 
@@ -129,5 +144,5 @@
         public override void Eval(IInterpreter interpreter)
         {
-            this.Eval(interpreter.ExecStack);
+            Eval(interpreter.ExecStack);
         }
 
Index: branches/PushGP/HeuristicLab.Algorithms.PushGP/HeuristicLab.Algorithms.PushGP/Expressions/PushResultExpression.cs
===================================================================
--- branches/PushGP/HeuristicLab.Algorithms.PushGP/HeuristicLab.Algorithms.PushGP/Expressions/PushResultExpression.cs	(revision 14397)
+++ branches/PushGP/HeuristicLab.Algorithms.PushGP/HeuristicLab.Algorithms.PushGP/Expressions/PushResultExpression.cs	(revision 14398)
@@ -4,9 +4,6 @@
 namespace HeuristicLab.Algorithms.PushGP.Expressions
 {
-    public abstract class PushResultExpression<T> : Expression
+    public abstract class PushResultExpression<T> : StatelessExpression
     {
-        public PushResultExpression(string stringRepresentation) : base(stringRepresentation)
-        { }
-
         protected void Eval(IStack<T> stack, int count, Func<T[], T> templateFunc)
         {
Index: branches/PushGP/HeuristicLab.Algorithms.PushGP/HeuristicLab.Algorithms.PushGP/Expressions/RandExpressions.cs
===================================================================
--- branches/PushGP/HeuristicLab.Algorithms.PushGP/HeuristicLab.Algorithms.PushGP/Expressions/RandExpressions.cs	(revision 14397)
+++ branches/PushGP/HeuristicLab.Algorithms.PushGP/HeuristicLab.Algorithms.PushGP/Expressions/RandExpressions.cs	(revision 14398)
@@ -7,9 +7,7 @@
     /// Pushes a random NAME.
     /// </summary>
-    public class NameRandExpression : Expression
+    public class NameRandExpression : StatelessExpression
     {
-        public NameRandExpression() : base("NAME.RAND")
-        {
-        }
+        protected override string InitStringRepresentation() { return "NAME.RAND"; }
 
         public override void Eval(IInterpreter interpreter)
@@ -24,9 +22,7 @@
     /// Pushes a random integer.
     /// </summary>
-    public class IntegerRandExpression : Expression
+    public class IntegerRandExpression : StatelessExpression
     {
-        public IntegerRandExpression() : base("INTEGER.RAND")
-        {
-        }
+        protected override string InitStringRepresentation() { return "INTEGER.RAND"; }
 
         public override void Eval(IInterpreter interpreter)
@@ -43,9 +39,7 @@
     /// Pushes a random float.
     /// </summary>
-    public class FloatRandExpression : Expression
+    public class FloatRandExpression : StatelessExpression
     {
-        public FloatRandExpression() : base("FLOAT.RAND")
-        {
-        }
+        protected override string InitStringRepresentation() { return "FLOAT.RAND"; }
 
         public override void Eval(IInterpreter interpreter)
@@ -62,9 +56,7 @@
     /// Pushes a random boolean.
     /// </summary>
-    public class BooleanRandExpression : Expression
+    public class BooleanRandExpression : StatelessExpression
     {
-        public BooleanRandExpression() : base("BOOLEAN.RAND")
-        {
-        }
+        protected override string InitStringRepresentation() { return "BOOLEAN.RAND"; }
 
         public override void Eval(IInterpreter interpreter)
@@ -79,9 +71,7 @@
     /// Pushes random expressions onto the code stack.
     /// </summary>
-    public class CodeRandExpression : Expression
+    public class CodeRandExpression : StatelessExpression
     {
-        public CodeRandExpression() : base("CODE.RAND")
-        {
-        }
+        protected override string InitStringRepresentation() { return "CODE.RAND"; }
 
         public override void Eval(IInterpreter interpreter)
Index: branches/PushGP/HeuristicLab.Algorithms.PushGP/HeuristicLab.Algorithms.PushGP/Expressions/RotateExpressions.cs
===================================================================
--- branches/PushGP/HeuristicLab.Algorithms.PushGP/HeuristicLab.Algorithms.PushGP/Expressions/RotateExpressions.cs	(revision 14397)
+++ branches/PushGP/HeuristicLab.Algorithms.PushGP/HeuristicLab.Algorithms.PushGP/Expressions/RotateExpressions.cs	(revision 14398)
@@ -4,9 +4,6 @@
 namespace HeuristicLab.Algorithms.PushGP.Expressions
 {
-    public abstract class RotateExpression<T> : Expression
+    public abstract class RotateExpression<T> : StatelessExpression
     {
-        public RotateExpression(string stringRepresentation) : base(stringRepresentation)
-        { }
-
         public void Eval(IStack<T> stack)
         {
@@ -20,10 +17,9 @@
     public class IntegerRotateExpression : RotateExpression<long>
     {
-        public IntegerRotateExpression() : base("INTEGER.ROT")
-        { }
+        protected override string InitStringRepresentation() { return "INTEGER.ROT"; }
 
         public override void Eval(IInterpreter interpreter)
         {
-            this.Eval(interpreter.IntegerStack);
+            Eval(interpreter.IntegerStack);
         }
     }
@@ -31,10 +27,9 @@
     public class FloatRotateExpression : RotateExpression<double>
     {
-        public FloatRotateExpression() : base("FLOAT.ROT")
-        { }
+        protected override string InitStringRepresentation() { return "FLOAT.ROT"; }
 
         public override void Eval(IInterpreter interpreter)
         {
-            this.Eval(interpreter.FloatStack);
+            Eval(interpreter.FloatStack);
         }
     }
@@ -42,10 +37,9 @@
     public class BooleanRotateExpression : RotateExpression<bool>
     {
-        public BooleanRotateExpression() : base("BOOLEAN.ROT")
-        { }
+        protected override string InitStringRepresentation() { return "BOOLEAN.ROT"; }
 
         public override void Eval(IInterpreter interpreter)
         {
-            this.Eval(interpreter.BooleanStack);
+            Eval(interpreter.BooleanStack);
         }
     }
@@ -53,10 +47,9 @@
     public class NameRotateExpression : RotateExpression<string>
     {
-        public NameRotateExpression() : base("NAME.ROT")
-        { }
+        protected override string InitStringRepresentation() { return "NAME.ROT"; }
 
         public override void Eval(IInterpreter interpreter)
         {
-            this.Eval(interpreter.NameStack);
+            Eval(interpreter.NameStack);
         }
     }
@@ -64,10 +57,9 @@
     public class ExecRotateExpression : RotateExpression<Expression>
     {
-        public ExecRotateExpression() : base("EXEC.ROT")
-        { }
+        protected override string InitStringRepresentation() { return "EXEC.ROT"; }
 
         public override void Eval(IInterpreter interpreter)
         {
-            this.Eval(interpreter.ExecStack);
+            Eval(interpreter.ExecStack);
         }
     }
@@ -75,10 +67,9 @@
     public class CodeRotateExpression : RotateExpression<Expression>
     {
-        public CodeRotateExpression() : base("CODE.ROT")
-        { }
+        protected override string InitStringRepresentation() { return "CODE.ROT"; }
 
         public override void Eval(IInterpreter interpreter)
         {
-            this.Eval(interpreter.CodeStack);
+            Eval(interpreter.CodeStack);
         }
     }
Index: branches/PushGP/HeuristicLab.Algorithms.PushGP/HeuristicLab.Algorithms.PushGP/Expressions/SetExpressions.cs
===================================================================
--- branches/PushGP/HeuristicLab.Algorithms.PushGP/HeuristicLab.Algorithms.PushGP/Expressions/SetExpressions.cs	(revision 14397)
+++ 	(revision )
@@ -1,69 +1,0 @@
-﻿using System;
-using System.Collections.Generic;
-using HeuristicLab.Algorithms.PushGP.Interpreter;
-using HeuristicLab.Algorithms.PushGP.Stack;
-
-namespace HeuristicLab.Algorithms.PushGP.Expressions
-{
-    /// <summary>
-    /// Binds the top of stack to the NAME on top of the NAME stack.
-    /// </summary>
-    /// <typeparam name="T">Stacktype</typeparam>
-    public abstract class SetExpressions<T> : Expression
-    {
-        public SetExpressions(string stringRepresentation) : base(stringRepresentation)
-        {
-        }
-
-        public void Eval(IStack<T> stack, IStack<string> nameStack, IDictionary<string, Expression> customExpressions, Func<T, Expression> creator)
-        {
-            if (stack.Count == 0 || nameStack.Count == 0)
-                return;
-
-            var name = nameStack.Pop();
-            var value = stack.Pop();
-            var expression = creator(value);
-
-            if (customExpressions.ContainsKey(name))
-            {
-                customExpressions[name] = expression;
-            }
-            else
-            {
-                customExpressions.Add(name, expression);
-            }
-        }
-    }
-
-    public class IntegerSetExpression : SetExpressions<long>
-    {
-        public IntegerSetExpression() : base("INTEGER.SET")
-        {
-        }
-
-        public override void Eval(IInterpreter interpreter)
-        {
-            this.Eval(
-                interpreter.IntegerStack,
-                interpreter.NameStack,
-                interpreter.CustomExpressions,
-                v => new IntegerPushExpression(v));
-        }
-    }
-
-    public class FloatSetExpression : SetExpressions<double>
-    {
-        public FloatSetExpression() : base("FLOAT.SET")
-        {
-        }
-
-        public override void Eval(IInterpreter interpreter)
-        {
-            this.Eval(
-                interpreter.FloatStack,
-                interpreter.NameStack,
-                interpreter.CustomExpressions,
-                v => new FloatPushExpression(v));
-        }
-    }
-}
Index: branches/PushGP/HeuristicLab.Algorithms.PushGP/HeuristicLab.Algorithms.PushGP/Expressions/ShoveExpressions.cs
===================================================================
--- branches/PushGP/HeuristicLab.Algorithms.PushGP/HeuristicLab.Algorithms.PushGP/Expressions/ShoveExpressions.cs	(revision 14397)
+++ branches/PushGP/HeuristicLab.Algorithms.PushGP/HeuristicLab.Algorithms.PushGP/Expressions/ShoveExpressions.cs	(revision 14398)
@@ -4,9 +4,6 @@
 namespace HeuristicLab.Algorithms.PushGP.Expressions
 {
-    public abstract class ShoveExpression<T> : Expression
+    public abstract class ShoveExpression<T> : StatelessExpression
     {
-        public ShoveExpression(string stringRepresentation) : base(stringRepresentation)
-        { }
-
         public void Eval(IStack<T> stack, IStack<long> integerStack, int count = 1)
         {
@@ -29,10 +26,9 @@
     public class IntegerShoveExpression : ShoveExpression<long>
     {
-        public IntegerShoveExpression() : base("INTEGER.SHOVE")
-        { }
+        protected override string InitStringRepresentation() { return "INTEGER.SHOVE"; }
 
         public override void Eval(IInterpreter interpreter)
         {
-            this.Eval(interpreter.IntegerStack, interpreter.IntegerStack, 2);
+            Eval(interpreter.IntegerStack, interpreter.IntegerStack, 2);
         }
     }
@@ -40,10 +36,9 @@
     public class FloatShoveExpression : ShoveExpression<double>
     {
-        public FloatShoveExpression() : base("FLOAT.SHOVE")
-        { }
+        protected override string InitStringRepresentation() { return "FLOAT.SHOVE"; }
 
         public override void Eval(IInterpreter interpreter)
         {
-            this.Eval(interpreter.FloatStack, interpreter.IntegerStack);
+            Eval(interpreter.FloatStack, interpreter.IntegerStack);
         }
     }
@@ -51,10 +46,9 @@
     public class BooleanShoveExpression : ShoveExpression<bool>
     {
-        public BooleanShoveExpression() : base("BOOLEAN.SHOVE")
-        { }
+        protected override string InitStringRepresentation() { return "BOOLEAN.SHOVE"; }
 
         public override void Eval(IInterpreter interpreter)
         {
-            this.Eval(interpreter.BooleanStack, interpreter.IntegerStack);
+            Eval(interpreter.BooleanStack, interpreter.IntegerStack);
         }
     }
@@ -62,10 +56,9 @@
     public class NameShoveExpression : ShoveExpression<string>
     {
-        public NameShoveExpression() : base("NAME.SHOVE")
-        { }
+        protected override string InitStringRepresentation() { return "NAME.SHOVE"; }
 
         public override void Eval(IInterpreter interpreter)
         {
-            this.Eval(interpreter.NameStack, interpreter.IntegerStack);
+            Eval(interpreter.NameStack, interpreter.IntegerStack);
         }
     }
@@ -73,10 +66,9 @@
     public class ExecShoveExpression : ShoveExpression<Expression>
     {
-        public ExecShoveExpression() : base("EXEC.SHOVE")
-        { }
+        protected override string InitStringRepresentation() { return "EXEC.SHOVE"; }
 
         public override void Eval(IInterpreter interpreter)
         {
-            this.Eval(interpreter.ExecStack, interpreter.IntegerStack);
+            Eval(interpreter.ExecStack, interpreter.IntegerStack);
         }
     }
@@ -84,10 +76,9 @@
     public class CodeShoveExpression : ShoveExpression<Expression>
     {
-        public CodeShoveExpression() : base("CODE.SHOVE")
-        { }
+        protected override string InitStringRepresentation() { return "CODE.SHOVE"; }
 
         public override void Eval(IInterpreter interpreter)
         {
-            this.Eval(interpreter.CodeStack, interpreter.IntegerStack);
+            Eval(interpreter.CodeStack, interpreter.IntegerStack);
         }
     }
Index: branches/PushGP/HeuristicLab.Algorithms.PushGP/HeuristicLab.Algorithms.PushGP/Expressions/StackdepthExpressions.cs
===================================================================
--- branches/PushGP/HeuristicLab.Algorithms.PushGP/HeuristicLab.Algorithms.PushGP/Expressions/StackdepthExpressions.cs	(revision 14397)
+++ branches/PushGP/HeuristicLab.Algorithms.PushGP/HeuristicLab.Algorithms.PushGP/Expressions/StackdepthExpressions.cs	(revision 14398)
@@ -8,9 +8,6 @@
     /// </summary>
     /// <typeparam name="T">Stacktype</typeparam>
-    public abstract class StackdepthExpression<T> : Expression
+    public abstract class StackdepthExpression<T> : StatelessExpression
     {
-        public StackdepthExpression(string stringRepresentation) : base(stringRepresentation)
-        { }
-
         public void Eval(IStack<T> stack, IStack<long> integerStack, bool incremental = false)
         {
@@ -28,10 +25,9 @@
     public class IntegerStackdepthExpression : StackdepthExpression<long>
     {
-        public IntegerStackdepthExpression() : base("INTEGER.STACKDEPTH")
-        { }
+        protected override string InitStringRepresentation() { return "INTEGER.STACKDEPTH"; }
 
         public override void Eval(IInterpreter interpreter)
         {
-            this.Eval(interpreter.IntegerStack, interpreter.IntegerStack, true);
+            Eval(interpreter.IntegerStack, interpreter.IntegerStack, true);
         }
     }
@@ -39,10 +35,9 @@
     public class FloatStackdepthExpression : StackdepthExpression<double>
     {
-        public FloatStackdepthExpression() : base("FLOAT.STACKDEPTH")
-        { }
+        protected override string InitStringRepresentation() { return "FLOAT.STACKDEPTH"; }
 
         public override void Eval(IInterpreter interpreter)
         {
-            this.Eval(interpreter.FloatStack, interpreter.IntegerStack);
+            Eval(interpreter.FloatStack, interpreter.IntegerStack);
         }
     }
@@ -50,10 +45,9 @@
     public class BooleanStackdepthExpression : StackdepthExpression<bool>
     {
-        public BooleanStackdepthExpression() : base("BOOLEAN.STACKDEPTH")
-        { }
+        protected override string InitStringRepresentation() { return "BOOLEAN.STACKDEPTH"; }
 
         public override void Eval(IInterpreter interpreter)
         {
-            this.Eval(interpreter.BooleanStack, interpreter.IntegerStack);
+            Eval(interpreter.BooleanStack, interpreter.IntegerStack);
         }
     }
@@ -61,10 +55,9 @@
     public class NameStackdepthExpression : StackdepthExpression<string>
     {
-        public NameStackdepthExpression() : base("NAME.STACKDEPTH")
-        { }
+        protected override string InitStringRepresentation() { return "NAME.STACKDEPTH"; }
 
         public override void Eval(IInterpreter interpreter)
         {
-            this.Eval(interpreter.NameStack, interpreter.IntegerStack);
+            Eval(interpreter.NameStack, interpreter.IntegerStack);
         }
     }
@@ -72,10 +65,9 @@
     public class ExecStackdepthExpression : StackdepthExpression<Expression>
     {
-        public ExecStackdepthExpression() : base("EXEC.STACKDEPTH")
-        { }
+        protected override string InitStringRepresentation() { return "EXEC.STACKDEPTH"; }
 
         public override void Eval(IInterpreter interpreter)
         {
-            this.Eval(interpreter.ExecStack, interpreter.IntegerStack);
+            Eval(interpreter.ExecStack, interpreter.IntegerStack);
         }
     }
@@ -83,10 +75,9 @@
     public class CodeStackdepthExpression : StackdepthExpression<Expression>
     {
-        public CodeStackdepthExpression() : base("CODE.STACKDEPTH")
-        { }
+        protected override string InitStringRepresentation() { return "CODE.STACKDEPTH"; }
 
         public override void Eval(IInterpreter interpreter)
         {
-            this.Eval(interpreter.CodeStack, interpreter.IntegerStack);
+            Eval(interpreter.CodeStack, interpreter.IntegerStack);
         }
     }
Index: branches/PushGP/HeuristicLab.Algorithms.PushGP/HeuristicLab.Algorithms.PushGP/Expressions/StatefullExpression.cs
===================================================================
--- branches/PushGP/HeuristicLab.Algorithms.PushGP/HeuristicLab.Algorithms.PushGP/Expressions/StatefullExpression.cs	(revision 14398)
+++ branches/PushGP/HeuristicLab.Algorithms.PushGP/HeuristicLab.Algorithms.PushGP/Expressions/StatefullExpression.cs	(revision 14398)
@@ -0,0 +1,13 @@
+﻿using HeuristicLab.Common;
+
+namespace HeuristicLab.Algorithms.PushGP.Expressions
+{
+    public abstract class StatefullExpression : Expression
+    {
+        protected StatefullExpression()
+        { }
+
+        protected StatefullExpression(StatefullExpression origin, Cloner cloner) : base(origin, cloner)
+        { }
+    }
+}
Index: branches/PushGP/HeuristicLab.Algorithms.PushGP/HeuristicLab.Algorithms.PushGP/Expressions/StatelessExpression.cs
===================================================================
--- branches/PushGP/HeuristicLab.Algorithms.PushGP/HeuristicLab.Algorithms.PushGP/Expressions/StatelessExpression.cs	(revision 14398)
+++ branches/PushGP/HeuristicLab.Algorithms.PushGP/HeuristicLab.Algorithms.PushGP/Expressions/StatelessExpression.cs	(revision 14398)
@@ -0,0 +1,17 @@
+﻿using HeuristicLab.Common;
+
+namespace HeuristicLab.Algorithms.PushGP.Expressions
+{
+    public abstract class StatelessExpression : Expression
+    {
+        protected override int InitId()
+        {
+            return StringRepresentation.GetHashCode();
+        }
+
+        public override IDeepCloneable Clone(Cloner cloner)
+        {
+            return this;
+        }
+    }
+}
Index: branches/PushGP/HeuristicLab.Algorithms.PushGP/HeuristicLab.Algorithms.PushGP/Expressions/SwapExpressions.cs
===================================================================
--- branches/PushGP/HeuristicLab.Algorithms.PushGP/HeuristicLab.Algorithms.PushGP/Expressions/SwapExpressions.cs	(revision 14397)
+++ branches/PushGP/HeuristicLab.Algorithms.PushGP/HeuristicLab.Algorithms.PushGP/Expressions/SwapExpressions.cs	(revision 14398)
@@ -8,9 +8,6 @@
     /// </summary>
     /// <typeparam name="T">Stacktype</typeparam>
-    public abstract class SwapExpression<T> : Expression
+    public abstract class SwapExpression<T> : StatelessExpression
     {
-        public SwapExpression(string stringRepresentation) : base(stringRepresentation)
-        { }
-
         public void Eval(IStack<T> stack)
         {
@@ -24,10 +21,9 @@
     public class IntegerSwapExpression : SwapExpression<long>
     {
-        public IntegerSwapExpression() : base("INTEGER.SWAP")
-        { }
+        protected override string InitStringRepresentation() { return "INTEGER.SWAP"; }
 
         public override void Eval(IInterpreter interpreter)
         {
-            this.Eval(interpreter.IntegerStack);
+            Eval(interpreter.IntegerStack);
         }
     }
@@ -35,10 +31,9 @@
     public class FloatSwapExpression : SwapExpression<double>
     {
-        public FloatSwapExpression() : base("FLOAT.SWAP")
-        { }
+        protected override string InitStringRepresentation() { return "FLOAT.SWAP"; }
 
         public override void Eval(IInterpreter interpreter)
         {
-            this.Eval(interpreter.FloatStack);
+            Eval(interpreter.FloatStack);
         }
     }
@@ -46,10 +41,9 @@
     public class BooleanSwapExpression : SwapExpression<bool>
     {
-        public BooleanSwapExpression() : base("BOOLEAN.SWAP")
-        { }
+        protected override string InitStringRepresentation() { return "BOOLEAN.SWAP"; }
 
         public override void Eval(IInterpreter interpreter)
         {
-            this.Eval(interpreter.BooleanStack);
+            Eval(interpreter.BooleanStack);
         }
     }
@@ -57,10 +51,9 @@
     public class NameSwapExpression : SwapExpression<string>
     {
-        public NameSwapExpression() : base("NAME.SWAP")
-        { }
+        protected override string InitStringRepresentation() { return "NAME.SWAP"; }
 
         public override void Eval(IInterpreter interpreter)
         {
-            this.Eval(interpreter.NameStack);
+            Eval(interpreter.NameStack);
         }
     }
@@ -68,10 +61,9 @@
     public class ExecSwapExpression : SwapExpression<Expression>
     {
-        public ExecSwapExpression() : base("EXEC.SWAP")
-        { }
+        protected override string InitStringRepresentation() { return "EXEC.SWAP"; }
 
         public override void Eval(IInterpreter interpreter)
         {
-            this.Eval(interpreter.ExecStack);
+            Eval(interpreter.ExecStack);
         }
     }
@@ -79,10 +71,9 @@
     public class CodeSwapExpression : SwapExpression<Expression>
     {
-        public CodeSwapExpression() : base("CODE.SWAP")
-        { }
+        protected override string InitStringRepresentation() { return "CODE.SWAP"; }
 
         public override void Eval(IInterpreter interpreter)
         {
-            this.Eval(interpreter.CodeStack);
+            Eval(interpreter.CodeStack);
         }
     }
Index: branches/PushGP/HeuristicLab.Algorithms.PushGP/HeuristicLab.Algorithms.PushGP/Expressions/YankDuplicateExpressions.cs
===================================================================
--- branches/PushGP/HeuristicLab.Algorithms.PushGP/HeuristicLab.Algorithms.PushGP/Expressions/YankDuplicateExpressions.cs	(revision 14397)
+++ branches/PushGP/HeuristicLab.Algorithms.PushGP/HeuristicLab.Algorithms.PushGP/Expressions/YankDuplicateExpressions.cs	(revision 14398)
@@ -9,9 +9,6 @@
     /// </summary>
     /// <typeparam name="T">Stacktype</typeparam>
-    public abstract class YankDuplicateExpression<T> : Expression
+    public abstract class YankDuplicateExpression<T> : StatelessExpression
     {
-        public YankDuplicateExpression(string stringRepresentation) : base(stringRepresentation)
-        { }
-
         public void Eval(IStack<T> stack, IStack<long> integerStack, int count = 1)
         {
@@ -35,10 +32,9 @@
     public class IntegerYankDuplicateExpression : YankDuplicateExpression<long>
     {
-        public IntegerYankDuplicateExpression() : base("INTEGER.YANKDUP")
-        { }
+        protected override string InitStringRepresentation() { return "INTEGER.YANKDUP"; }
 
         public override void Eval(IInterpreter interpreter)
         {
-            this.Eval(interpreter.IntegerStack, interpreter.IntegerStack, 2);
+            Eval(interpreter.IntegerStack, interpreter.IntegerStack, 2);
         }
     }
@@ -46,10 +42,9 @@
     public class FloatYankDuplicateExpression : YankDuplicateExpression<double>
     {
-        public FloatYankDuplicateExpression() : base("FLOAT.YANKDUP")
-        { }
+        protected override string InitStringRepresentation() { return "FLOAT.YANKDUP"; }
 
         public override void Eval(IInterpreter interpreter)
         {
-            this.Eval(interpreter.FloatStack, interpreter.IntegerStack);
+            Eval(interpreter.FloatStack, interpreter.IntegerStack);
         }
     }
@@ -57,10 +52,9 @@
     public class BooleanYankDuplicateExpression : YankDuplicateExpression<bool>
     {
-        public BooleanYankDuplicateExpression() : base("BOOLEAN.YANKDUP")
-        { }
+        protected override string InitStringRepresentation() { return "BOOLEAN.YANKDUP"; }
 
         public override void Eval(IInterpreter interpreter)
         {
-            this.Eval(interpreter.BooleanStack, interpreter.IntegerStack);
+            Eval(interpreter.BooleanStack, interpreter.IntegerStack);
         }
     }
@@ -68,10 +62,9 @@
     public class NameYankDuplicateExpression : YankDuplicateExpression<string>
     {
-        public NameYankDuplicateExpression() : base("NAME.YANKDUP")
-        { }
+        protected override string InitStringRepresentation() { return "NAME.YANKDUP"; }
 
         public override void Eval(IInterpreter interpreter)
         {
-            this.Eval(interpreter.NameStack, interpreter.IntegerStack);
+            Eval(interpreter.NameStack, interpreter.IntegerStack);
         }
     }
@@ -79,10 +72,9 @@
     public class ExecYankDuplicateExpression : YankDuplicateExpression<Expression>
     {
-        public ExecYankDuplicateExpression() : base("EXEC.YANKDUP")
-        { }
+        protected override string InitStringRepresentation() { return "EXEC.YANKDUP"; }
 
         public override void Eval(IInterpreter interpreter)
         {
-            this.Eval(interpreter.ExecStack, interpreter.IntegerStack);
+            Eval(interpreter.ExecStack, interpreter.IntegerStack);
         }
     }
@@ -90,10 +82,9 @@
     public class CodeYankDuplicateExpression : YankDuplicateExpression<Expression>
     {
-        public CodeYankDuplicateExpression() : base("CODE.YANKDUP")
-        { }
+        protected override string InitStringRepresentation() { return "CODE.YANKDUP"; }
 
         public override void Eval(IInterpreter interpreter)
         {
-            this.Eval(interpreter.CodeStack, interpreter.IntegerStack);
+            Eval(interpreter.CodeStack, interpreter.IntegerStack);
         }
     }
Index: branches/PushGP/HeuristicLab.Algorithms.PushGP/HeuristicLab.Algorithms.PushGP/Expressions/YankExpressions.cs
===================================================================
--- branches/PushGP/HeuristicLab.Algorithms.PushGP/HeuristicLab.Algorithms.PushGP/Expressions/YankExpressions.cs	(revision 14397)
+++ branches/PushGP/HeuristicLab.Algorithms.PushGP/HeuristicLab.Algorithms.PushGP/Expressions/YankExpressions.cs	(revision 14398)
@@ -9,9 +9,6 @@
     /// </summary>
     /// <typeparam name="T">Stacktype</typeparam>
-    public abstract class YankExpression<T> : Expression
+    public abstract class YankExpression<T> : StatelessExpression
     {
-        public YankExpression(string stringRepresentation) : base(stringRepresentation)
-        { }
-
         public void Eval(IStack<T> stack, IStack<long> integerStack, int count = 1)
         {
@@ -33,10 +30,9 @@
     public class IntegerYankExpression : YankExpression<long>
     {
-        public IntegerYankExpression() : base("INTEGER.YANK")
-        { }
+        protected override string InitStringRepresentation() { return "INTEGER.YANK"; }
 
         public override void Eval(IInterpreter interpreter)
         {
-            this.Eval(interpreter.IntegerStack, interpreter.IntegerStack, 2);
+            Eval(interpreter.IntegerStack, interpreter.IntegerStack, 2);
         }
     }
@@ -44,10 +40,9 @@
     public class FloatYankExpression : YankExpression<double>
     {
-        public FloatYankExpression() : base("FLOAT.YANK")
-        { }
+        protected override string InitStringRepresentation() { return "FLOAT.YANK"; }
 
         public override void Eval(IInterpreter interpreter)
         {
-            this.Eval(interpreter.FloatStack, interpreter.IntegerStack);
+            Eval(interpreter.FloatStack, interpreter.IntegerStack);
         }
     }
@@ -55,10 +50,9 @@
     public class BooleanYankExpression : YankExpression<bool>
     {
-        public BooleanYankExpression() : base("BOOLEAN.YANK")
-        { }
+        protected override string InitStringRepresentation() { return "BOOLEAN.YANK"; }
 
         public override void Eval(IInterpreter interpreter)
         {
-            this.Eval(interpreter.BooleanStack, interpreter.IntegerStack);
+            Eval(interpreter.BooleanStack, interpreter.IntegerStack);
         }
     }
@@ -66,10 +60,9 @@
     public class NameYankExpression : YankExpression<string>
     {
-        public NameYankExpression() : base("NAME.YANK")
-        { }
+        protected override string InitStringRepresentation() { return "NAME.YANK"; }
 
         public override void Eval(IInterpreter interpreter)
         {
-            this.Eval(interpreter.NameStack, interpreter.IntegerStack);
+            Eval(interpreter.NameStack, interpreter.IntegerStack);
         }
     }
@@ -77,10 +70,9 @@
     public class ExecYankExpression : YankExpression<Expression>
     {
-        public ExecYankExpression() : base("EXEC.YANK")
-        { }
+        protected override string InitStringRepresentation() { return "EXEC.YANK"; }
 
         public override void Eval(IInterpreter interpreter)
         {
-            this.Eval(interpreter.ExecStack, interpreter.IntegerStack);
+            Eval(interpreter.ExecStack, interpreter.IntegerStack);
         }
     }
@@ -88,10 +80,9 @@
     public class CodeYankExpression : YankExpression<Expression>
     {
-        public CodeYankExpression() : base("CODE.YANK")
-        { }
+        protected override string InitStringRepresentation() { return "CODE.YANK"; }
 
         public override void Eval(IInterpreter interpreter)
         {
-            this.Eval(interpreter.CodeStack, interpreter.IntegerStack);
+            Eval(interpreter.CodeStack, interpreter.IntegerStack);
         }
     }
Index: branches/PushGP/HeuristicLab.Algorithms.PushGP/HeuristicLab.Algorithms.PushGP/Generators/CodeGenerator.cs
===================================================================
--- branches/PushGP/HeuristicLab.Algorithms.PushGP/HeuristicLab.Algorithms.PushGP/Generators/CodeGenerator.cs	(revision 14397)
+++ branches/PushGP/HeuristicLab.Algorithms.PushGP/HeuristicLab.Algorithms.PushGP/Generators/CodeGenerator.cs	(revision 14398)
@@ -46,6 +46,6 @@
             if (points == 1)
             {
-                var index = random.Next(0, ExpressionTable.Count + this.interpreter.CustomExpressions.Count - 2);
-                return new[] { this.CreateExpression(index) };
+                var index = random.Next(0, ExpressionTable.Count + interpreter.CustomExpressions.Count - 2);
+                return new[] { CreateExpression(index) };
             }
             else
@@ -73,5 +73,5 @@
             return (index >= 0 && index < ExpressionTable.Count)
                 ? ExpressionTable.GetExpression(index)
-                : new NameDefineXExecExpression(this.interpreter.CustomExpressions.ElementAt(index - (ExpressionTable.Count - 1)).Key);
+                : new NameDefineXExecExpression(interpreter.CustomExpressions.ElementAt(index - (ExpressionTable.Count - 1)).Key);
         }
     }
Index: branches/PushGP/HeuristicLab.Algorithms.PushGP/HeuristicLab.Algorithms.PushGP/HeuristicLab.Algorithms.PushGP.csproj
===================================================================
--- branches/PushGP/HeuristicLab.Algorithms.PushGP/HeuristicLab.Algorithms.PushGP/HeuristicLab.Algorithms.PushGP.csproj	(revision 14397)
+++ branches/PushGP/HeuristicLab.Algorithms.PushGP/HeuristicLab.Algorithms.PushGP/HeuristicLab.Algorithms.PushGP.csproj	(revision 14398)
@@ -52,4 +52,6 @@
   </ItemGroup>
   <ItemGroup>
+    <Compile Include="Data\ExpressionNode.cs" />
+    <Compile Include="Data\ExpressionTree.cs" />
     <Compile Include="Exporter\Exporter.cs" />
     <Compile Include="Expressions\BooleanExpressions.cs" />
@@ -63,5 +65,6 @@
     <Compile Include="Expressions\EqualsExpressions.cs" />
     <Compile Include="Expressions\RandExpressions.cs" />
-    <Compile Include="Expressions\SetExpressions.cs" />
+    <Compile Include="Expressions\StatefullExpression.cs" />
+    <Compile Include="Expressions\StatelessExpression.cs" />
     <Compile Include="Expressions\YankDuplicateExpressions.cs" />
     <Compile Include="Expressions\YankExpressions.cs" />
@@ -82,5 +85,4 @@
     <Compile Include="Simplifier\ISimplifier.cs" />
     <Compile Include="Simplifier\RandomSimplifier.cs" />
-    <Compile Include="StateFullExpressionAttribute.cs" />
     <Compile Include="Generators\BooleanGenerator.cs" />
     <Compile Include="Generators\FloatGenerator.cs" />
Index: branches/PushGP/HeuristicLab.Algorithms.PushGP/HeuristicLab.Algorithms.PushGP/Interpreter/Configuration.cs
===================================================================
--- branches/PushGP/HeuristicLab.Algorithms.PushGP/HeuristicLab.Algorithms.PushGP/Interpreter/Configuration.cs	(revision 14397)
+++ branches/PushGP/HeuristicLab.Algorithms.PushGP/HeuristicLab.Algorithms.PushGP/Interpreter/Configuration.cs	(revision 14398)
@@ -8,26 +8,26 @@
         public Configuration()
         {
-            this.IsBooleanStackEnabled = true;
-            this.IsIntegerStackEnabled = true;
-            this.IsFloatStackEnabled = true;
-            this.IsCodeStackEnabled = true;
-            this.IsNameStackEnabled = true;
+            IsBooleanStackEnabled = true;
+            IsIntegerStackEnabled = true;
+            IsFloatStackEnabled = true;
+            IsCodeStackEnabled = true;
+            IsNameStackEnabled = true;
 
-            this.EvalPushLimit = 4096;
-            this.MaxPointsInProgram = 128;
-            this.MaxPointsInRandomExpression = 1024;
+            EvalPushLimit = 4096;
+            MaxPointsInProgram = 128;
+            MaxPointsInRandomExpression = 1024;
 
-            this.TopLevelPushCode = true;
-            this.TopLevelPopCode = false;
+            TopLevelPushCode = true;
+            TopLevelPopCode = false;
 
-            this.RandomSeedMax = 30081;
-            this.RandomSeedMin = 0;
-            this.RandomSeed = null;
+            RandomSeedMax = 30081;
+            RandomSeedMin = 0;
+            RandomSeed = null;
 
-            this.MinRandomInteger = -128;
-            this.MaxRandomInteger = 128;
-            this.MinRandomFloat = -128D;
-            this.MaxRandomFloat = 128D;
-            this.NewErcNameProbability = 0.5;
+            MinRandomInteger = -128;
+            MaxRandomInteger = 128;
+            MinRandomFloat = -128D;
+            MaxRandomFloat = 128D;
+            NewErcNameProbability = 0.5;
         }
 
Index: branches/PushGP/HeuristicLab.Algorithms.PushGP/HeuristicLab.Algorithms.PushGP/Interpreter/PushGPInterpreter.cs
===================================================================
--- branches/PushGP/HeuristicLab.Algorithms.PushGP/HeuristicLab.Algorithms.PushGP/Interpreter/PushGPInterpreter.cs	(revision 14397)
+++ branches/PushGP/HeuristicLab.Algorithms.PushGP/HeuristicLab.Algorithms.PushGP/Interpreter/PushGPInterpreter.cs	(revision 14398)
@@ -16,16 +16,16 @@
         public PushGPInterpreter(Configuration config = null)
         {
-            this.Configuration = config ?? new Configuration();
-
-            this.CodeStack = new PushGPStack<Expression>(128);
-            this.ExecStack = new PushGPStack<Expression>(128);
-            this.NameStack = new PushGPStack<string>(16);
-            this.BooleanStack = new PushGPStack<bool>(16);
-            this.IntegerStack = new PushGPStack<long>(16);
-            this.FloatStack = new PushGPStack<double>(16);
-
-            this.CustomExpressions = new Dictionary<string, Expression>();
-
-            this.CodeGenerator = new CodeGenerator(this);
+            Configuration = config ?? new Configuration();
+
+            CodeStack = new PushGPStack<Expression>(128);
+            ExecStack = new PushGPStack<Expression>(128);
+            NameStack = new PushGPStack<string>(16);
+            BooleanStack = new PushGPStack<bool>(16);
+            IntegerStack = new PushGPStack<long>(16);
+            FloatStack = new PushGPStack<double>(16);
+
+            CustomExpressions = new Dictionary<string, Expression>();
+
+            CodeGenerator = new CodeGenerator(this);
         }
 
@@ -35,6 +35,6 @@
         public bool IsPaused { get; private set; }
         public bool IsAborted { get; private set; }
-        public bool IsRunning { get { return this.ExecStack.Count > 0 && !IsPaused && !IsAborted && ExecCounter < Configuration.EvalPushLimit; } }
-        public bool IsCompleted { get { return this.ExecStack.Count == 0; } }
+        public bool IsRunning { get { return ExecStack.Count > 0 && !IsPaused && !IsAborted && ExecCounter < Configuration.EvalPushLimit; } }
+        public bool IsCompleted { get { return ExecStack.Count == 0; } }
         public bool CanStep { get { return !IsCompleted && !IsAborted && IsPaused; } }
 
@@ -54,23 +54,23 @@
         public void Reset()
         {
-            this.IsAborted = false;
-            this.IsPaused = false;
-            this.currentTask = null;
-
-            this.Clear();
+            IsAborted = false;
+            IsPaused = false;
+            currentTask = null;
+
+            Clear();
         }
 
         public void Clear()
         {
-            this.ExecCounter = 0;
-
-            this.ExecStack.Clear();
-            this.CodeStack.Clear();
-            this.NameStack.Clear();
-            this.BooleanStack.Clear();
-            this.IntegerStack.Clear();
-            this.FloatStack.Clear();
-
-            this.CustomExpressions.Clear();
+            ExecCounter = 0;
+
+            ExecStack.Clear();
+            CodeStack.Clear();
+            NameStack.Clear();
+            BooleanStack.Clear();
+            IntegerStack.Clear();
+            FloatStack.Clear();
+
+            CustomExpressions.Clear();
         }
 
@@ -78,5 +78,5 @@
         {
             var program = Encode(code);
-            this.Interpret(program);
+            Interpret(program);
         }
 
@@ -85,5 +85,5 @@
             var program = Encode(code);
 
-            this.currentTask = this.InterpretAsync(program, paused, token);
+            currentTask = InterpretAsync(program, paused, token);
 
             return currentTask;
@@ -92,6 +92,6 @@
         public Task InterpretAsync(Expression program, bool paused = false, CancellationToken token = default(CancellationToken))
         {
-            this.IsPaused = paused;
-            this.currentTask = Task.Run(() => this.Interpret(program), token);
+            IsPaused = paused;
+            currentTask = Task.Run(() => Interpret(program), token);
 
             return currentTask;
@@ -103,33 +103,33 @@
              * If the top expression is a single statement then the loop has nothing to do
              * Otherwise the expand expression will be evaluated and pushes code onto the EXEC stack */
-            this.ExecStack.Push(program);
-
-            if (this.Configuration.TopLevelPushCode)
-            {
-                this.CodeStack.Insert(0, program);
+            ExecStack.Push(program);
+
+            if (Configuration.TopLevelPushCode)
+            {
+                CodeStack.Insert(0, program);
             }
 
             // run top expression
-            this.ExecStack.Pop().Eval(this);
-
-            this.Interpret();
+            ExecStack.Pop().Eval(this);
+
+            Interpret();
         }
 
         private void Interpret()
         {
-            while (this.IsRunning)
-            {
-                this.DoStep();
-                this.ExecCounter++;
-            }
-
-            this.Finally();
+            while (IsRunning)
+            {
+                DoStep();
+                ExecCounter++;
+            }
+
+            Finally();
         }
 
         private void Finally()
         {
-            if (this.IsCompleted && this.Configuration.TopLevelPopCode && this.CodeStack.Count > 0)
-            {
-                this.CodeStack.Pop();
+            if (IsCompleted && Configuration.TopLevelPopCode && CodeStack.Count > 0)
+            {
+                CodeStack.Pop();
             }
         }
@@ -137,24 +137,24 @@
         private void DoStep()
         {
-            this.ExecStack.Pop().Eval(this);
+            ExecStack.Pop().Eval(this);
         }
 
         private Task InterpreteAsync()
         {
-            this.currentTask = Task.Run(() => this.Interpret());
-
-            return this.currentTask;
+            currentTask = Task.Run(() => Interpret());
+
+            return currentTask;
         }
 
         public async Task AbortAsync()
         {
-            if (this.IsAborted || this.IsCompleted)
+            if (IsAborted || IsCompleted)
                 return;
 
-            this.IsAborted = true;
-
-            if (this.currentTask != null)
-            {
-                await this.currentTask;
+            IsAborted = true;
+
+            if (currentTask != null)
+            {
+                await currentTask;
             }
         }
@@ -162,18 +162,18 @@
         public async Task AbortAndResetAsync()
         {
-            await this.AbortAsync();
-            this.Reset();
+            await AbortAsync();
+            Reset();
         }
 
         public async Task PauseAsync()
         {
-            if (this.IsPaused || this.IsCompleted)
+            if (IsPaused || IsCompleted)
                 return;
 
-            this.IsPaused = true;
-
-            if (this.currentTask != null)
-            {
-                await this.currentTask;
+            IsPaused = true;
+
+            if (currentTask != null)
+            {
+                await currentTask;
             }
         }
@@ -181,19 +181,19 @@
         public Task ResumeAsync()
         {
-            if (this.IsPaused || !this.IsAborted)
-            {
-                this.IsPaused = false;
-                return this.InterpreteAsync();
-            }
-
-            return this.currentTask;
+            if (IsPaused || !IsAborted)
+            {
+                IsPaused = false;
+                return InterpreteAsync();
+            }
+
+            return currentTask;
         }
 
         public void Step()
         {
-            if (this.CanStep)
-            {
-                this.DoStep();
-                this.Finally();
+            if (CanStep)
+            {
+                DoStep();
+                Finally();
             }
         }
@@ -203,5 +203,5 @@
             for (var i = 0; i < count; i++)
             {
-                this.Step();
+                Step();
             }
         }
@@ -229,10 +229,10 @@
         public void PrintStacks()
         {
-            this.PrintStack("EXEC", this.ExecStack);
-            this.PrintStack("CODE", this.CodeStack);
-            this.PrintStack("NAME", this.NameStack);
-            this.PrintStack("BOOLEAN", this.BooleanStack);
-            this.PrintStack("FLOAT", this.FloatStack);
-            this.PrintStack("INTEGER", this.IntegerStack);
+            PrintStack("EXEC", ExecStack);
+            PrintStack("CODE", CodeStack);
+            PrintStack("NAME", NameStack);
+            PrintStack("BOOLEAN", BooleanStack);
+            PrintStack("FLOAT", FloatStack);
+            PrintStack("INTEGER", IntegerStack);
         }
 
Index: branches/PushGP/HeuristicLab.Algorithms.PushGP/HeuristicLab.Algorithms.PushGP/Simplifier/RandomSimplifier.cs
===================================================================
--- branches/PushGP/HeuristicLab.Algorithms.PushGP/HeuristicLab.Algorithms.PushGP/Simplifier/RandomSimplifier.cs	(revision 14397)
+++ branches/PushGP/HeuristicLab.Algorithms.PushGP/HeuristicLab.Algorithms.PushGP/Simplifier/RandomSimplifier.cs	(revision 14398)
@@ -17,7 +17,8 @@
             var clone = program.Clone() as ExecExpandExpression;
 
-            for (var i = 0; i < this.Trys; i++)
+            for (var i = 0; i < Trys; i++)
             {
                 var index = rand.Next(0, clone.TotalCount - 1);
+
             }
 
Index: branches/PushGP/HeuristicLab.Algorithms.PushGP/HeuristicLab.Algorithms.PushGP/Stack/PushGPStack.cs
===================================================================
--- branches/PushGP/HeuristicLab.Algorithms.PushGP/HeuristicLab.Algorithms.PushGP/Stack/PushGPStack.cs	(revision 14397)
+++ branches/PushGP/HeuristicLab.Algorithms.PushGP/HeuristicLab.Algorithms.PushGP/Stack/PushGPStack.cs	(revision 14398)
@@ -20,14 +20,14 @@
         public PushGPStack(int capacity = 0)
         {
-            this.data = new List<T>();
-        }
-
-        public T Top { get { return this.data[Count - 1]; } }
-        public T TopOrDefault { get { return Count > 0 ? this.data[Count - 1] : default(T); } }
-        public T Bottom { get { return this.data[0]; } }
-        public T BottomOrDefault { get { return Count > 0 ? this.data[0] : default(T); } }
-        public int Count { get { return this.data.Count; } }
-        public int Capacity { get { return this.data.Capacity; } }
-        public bool IsEmpty { get { return this.Count == 0; } }
+            data = new List<T>();
+        }
+
+        public T Top { get { return data[Count - 1]; } }
+        public T TopOrDefault { get { return Count > 0 ? data[Count - 1] : default(T); } }
+        public T Bottom { get { return data[0]; } }
+        public T BottomOrDefault { get { return Count > 0 ? data[0] : default(T); } }
+        public int Count { get { return data.Count; } }
+        public int Capacity { get { return data.Capacity; } }
+        public bool IsEmpty { get { return Count == 0; } }
 
         public bool IsReadOnly { get { return false; } }
@@ -35,30 +35,30 @@
         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];
         }
 
@@ -66,42 +66,42 @@
         public T ReverseElementAt(int offset)
         {
-            return this.data[this.Count - 1 - offset];
+            return data[Count - 1 - offset];
         }
 
         public void SetTop(T value)
         {
-            this.data[Count - 1] = value;
+            data[Count - 1] = value;
         }
 
         public T this[int key]
         {
-            get { return this.data[key]; }
-            set { this.data[key] = value; }
+            get { return data[key]; }
+            set { 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)
         {
-            var item = this.ElementAt(index);
-            this.data.RemoveAt(index);
-            this.data.Add(item);
+            var item = ElementAt(index);
+            data.RemoveAt(index);
+            data.Add(item);
         }
 
         public T Pop()
         {
-            var value = this.data[Count - 1];
-            this.data.RemoveAt(Count - 1);
+            var value = data[Count - 1];
+            data.RemoveAt(Count - 1);
 
             return value;
@@ -113,6 +113,6 @@
 
             var items = new T[count];
-            this.data.CopyTo(startIndex, items, 0, count);
-            this.Remove(count);
+            data.CopyTo(startIndex, items, 0, count);
+            Remove(count);
 
             return items;
@@ -121,5 +121,5 @@
         public void Push(T item)
         {
-            this.data.Add(item);
+            data.Add(item);
         }
 
@@ -128,5 +128,5 @@
             for (var i = 0; i < items.Length; i++)
             {
-                this.data.Add((T)items[i]);
+                data.Add((T)items[i]);
             }
         }
@@ -137,8 +137,8 @@
             var items = new T[count];
 
-            this.data.CopyTo(startIndex, items, 0, count);
-            this.Remove(count - 1);
-
-            this.data[Count - 1] = templateFunc(items);
+            data.CopyTo(startIndex, items, 0, count);
+            Remove(count - 1);
+
+            data[Count - 1] = templateFunc(items);
         }
 
@@ -147,5 +147,5 @@
             for (var i = 0; i < items.Length; i++)
             {
-                this.data.Add(items[i]);
+                data.Add(items[i]);
             }
         }
@@ -153,20 +153,20 @@
         public void Push(IEnumerable<T> items)
         {
-            this.data.AddRange(items);
+            data.AddRange(items);
         }
 
         public void Insert(int index, T item)
         {
-            this.data.Insert(index, item);
+            data.Insert(index, item);
         }
 
         public void Insert(int index, params T[] items)
         {
-            this.data.InsertRange(index, items);
+            data.InsertRange(index, items);
         }
 
         public void Insert(int index, IEnumerable<T> items)
         {
-            this.data.InsertRange(index, items);
+            data.InsertRange(index, items);
         }
 
@@ -174,7 +174,7 @@
         {
             var index = Count - 1;
-            if (this.Count > 0 && this.data[index].Equals(item))
-            {
-                this.data.RemoveAt(index);
+            if (Count > 0 && data[index].Equals(item))
+            {
+                data.RemoveAt(index);
                 return true;
             }
@@ -187,5 +187,5 @@
         public void RemoveTop()
         {
-            this.data.RemoveAt(this.Count - 1);
+            data.RemoveAt(Count - 1);
         }
 
@@ -194,5 +194,5 @@
             for (var i = 0; i < count; i++)
             {
-                this.data.RemoveAt(Count - 1);
+                data.RemoveAt(Count - 1);
             }
         }
@@ -200,17 +200,17 @@
         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;
             }
@@ -224,10 +224,10 @@
         IEnumerator IEnumerable.GetEnumerator()
         {
-            return (this.data as IEnumerable).GetEnumerator();
+            return (data as IEnumerable).GetEnumerator();
         }
 
         public override string ToString()
         {
-            return string.Join(Delimiter, this.data);
+            return string.Join(Delimiter, data);
         }
     }
Index: branches/PushGP/HeuristicLab.Algorithms.PushGP/HeuristicLab.Algorithms.PushGP/StateFullExpressionAttribute.cs
===================================================================
--- branches/PushGP/HeuristicLab.Algorithms.PushGP/HeuristicLab.Algorithms.PushGP/StateFullExpressionAttribute.cs	(revision 14397)
+++ 	(revision )
@@ -1,11 +1,0 @@
-﻿using System;
-
-namespace HeuristicLab.Algorithms.PushGP
-{
-    /// <summary>
-    /// Marker attribute so the expression table knows which expression must be index during initialization
-    /// </summary>
-    public class StatefullExpressionAttribute : Attribute
-    {
-    }
-}
Index: branches/PushGP/HeuristicLab.Algorithms.PushGP/HeuristicLab.BenchmarkSuite/Problems/CountOdds.cs
===================================================================
--- branches/PushGP/HeuristicLab.Algorithms.PushGP/HeuristicLab.BenchmarkSuite/Problems/CountOdds.cs	(revision 14397)
+++ branches/PushGP/HeuristicLab.Algorithms.PushGP/HeuristicLab.BenchmarkSuite/Problems/CountOdds.cs	(revision 14398)
@@ -31,14 +31,14 @@
         protected override IEnumerable<List<int>> GenerateTest()
         {
-            foreach (var list in this.GetHardcodedTrainingSamples())
+            foreach (var list in GetHardcodedTrainingSamples())
                 yield return list;
 
-            foreach (var list in this.GetAllOdd(n: 100))
+            foreach (var list in GetAllOdd(n: 100))
                 yield return list;
 
-            foreach (var list in this.GetAllEven(n: 100))
+            foreach (var list in GetAllEven(n: 100))
                 yield return list;
 
-            foreach (var list in this.GetRandom(n: 1800))
+            foreach (var list in GetRandom(n: 1800))
                 yield return list;
         }
@@ -46,14 +46,14 @@
         protected override IEnumerable<List<int>> GenerateTraining()
         {
-            foreach (var list in this.GetHardcodedTrainingSamples())
+            foreach (var list in GetHardcodedTrainingSamples())
                 yield return list;
 
-            foreach (var list in this.GetAllOdd(n: 9))
+            foreach (var list in GetAllOdd(n: 9))
                 yield return list;
 
-            foreach (var list in this.GetAllEven(n: 9))
+            foreach (var list in GetAllEven(n: 9))
                 yield return list;
 
-            foreach (var list in this.GetRandom(n: 150))
+            foreach (var list in GetRandom(n: 150))
                 yield return list;
         }
Index: branches/PushGP/HeuristicLab.Algorithms.PushGP/HeuristicLab.Tests/Benchmark/ExampleConverter.cs
===================================================================
--- branches/PushGP/HeuristicLab.Algorithms.PushGP/HeuristicLab.Tests/Benchmark/ExampleConverter.cs	(revision 14397)
+++ branches/PushGP/HeuristicLab.Algorithms.PushGP/HeuristicLab.Tests/Benchmark/ExampleConverter.cs	(revision 14398)
@@ -1,4 +1,3 @@
-﻿using System;
-using System.Linq;
+﻿using System.Linq;
 
 namespace HeuristicLab.Tests.Benchmark
@@ -10,13 +9,11 @@
         private static readonly char[] arraySymbolTrim = new[] { '[', ']' };
 
-        public static Converter<string, long> Integer = new Converter<string, long>(GetInteger);
-        public static Converter<string, long[]> Integers = new Converter<string, long[]>(GetIntegers);
 
-        public static long GetInteger(string str)
+        public static long Integer(string str)
         {
             return long.Parse(str);
         }
 
-        public static long[] GetIntegers(string str)
+        public static long[] Integers(string str)
         {
             var values = str
@@ -30,5 +27,5 @@
             for (var i = 0; i < result.Length; i++)
             {
-                result[i] = GetInteger(values[i]);
+                result[i] = Integer(values[i]);
             }
 
Index: branches/PushGP/HeuristicLab.Algorithms.PushGP/HeuristicLab.Tests/Benchmark/Problem/CountOdds.cs
===================================================================
--- branches/PushGP/HeuristicLab.Algorithms.PushGP/HeuristicLab.Tests/Benchmark/Problem/CountOdds.cs	(revision 14397)
+++ branches/PushGP/HeuristicLab.Algorithms.PushGP/HeuristicLab.Tests/Benchmark/Problem/CountOdds.cs	(revision 14398)
@@ -17,11 +17,13 @@
         public CountOdds()
         {
-            this.Examples = this.GetExamples(ProblemFileName, ExampleConverter.Integers, ExampleConverter.Integer);
+            Examples = GetExamples(ProblemFileName, ExampleConverter.Integers, ExampleConverter.Integer);
         }
 
         [TestMethod]
+        [TestProperty("Time", "Medium")]
+        [TestCategory("ProblemTest")]
         public void RandomWalk()
         {
-            var limit = 1000;
+            var maxProgramSizeLimit = 1000;
             var iterations = 20000;
             var best = double.MaxValue;
@@ -39,8 +41,8 @@
 
                 var execCounter = 0;
-                var program = interpreter.CodeGenerator.RandomProgram(limit);
+                var program = interpreter.CodeGenerator.RandomProgram(maxProgramSizeLimit);
                 var results = new List<long>();
 
-                foreach (var example in this.Examples)
+                foreach (var example in Examples)
                 {
                     if (example.Input.Length > 0)
Index: branches/PushGP/HeuristicLab.Algorithms.PushGP/HeuristicLab.Tests/Interpreter/Expressions/BooleanExpressionTests.cs
===================================================================
--- branches/PushGP/HeuristicLab.Algorithms.PushGP/HeuristicLab.Tests/Interpreter/Expressions/BooleanExpressionTests.cs	(revision 14397)
+++ branches/PushGP/HeuristicLab.Algorithms.PushGP/HeuristicLab.Tests/Interpreter/Expressions/BooleanExpressionTests.cs	(revision 14398)
@@ -12,4 +12,7 @@
 
         [TestMethod]
+        [TestProperty("Time", "Short")]
+        [TestCategory("ExpressionTest")]
+        [TestCategory("BooleanExpressionTest")]
         public void TestAnd()
         {
@@ -19,14 +22,20 @@
             Assert.AreEqual(false, interpreter.BooleanStack.Top);
 
-            this.TestStackCounts(booleanStack: 1);
+            TestStackCounts(booleanStack: 1);
         }
 
         [TestMethod]
+        [TestProperty("Time", "Short")]
+        [TestCategory("ExpressionTest")]
+        [TestCategory("BooleanExpressionTest")]
         public void TestAndWithInsufficientArguments()
         {
-            this.TestWithInsufficientArguments("AND", 1);
+            TestWithInsufficientArguments("AND", 1);
         }
 
         [TestMethod]
+        [TestProperty("Time", "Short")]
+        [TestCategory("ExpressionTest")]
+        [TestCategory("BooleanExpressionTest")]
         public void TestOr()
         {
@@ -36,14 +45,20 @@
             Assert.AreEqual(true, interpreter.BooleanStack.Top);
 
-            this.TestStackCounts(booleanStack: 1);
+            TestStackCounts(booleanStack: 1);
         }
 
         [TestMethod]
+        [TestProperty("Time", "Short")]
+        [TestCategory("ExpressionTest")]
+        [TestCategory("BooleanExpressionTest")]
         public void TestOrWithInsufficientArguments()
         {
-            this.TestWithInsufficientArguments("OR", 1);
+            TestWithInsufficientArguments("OR", 1);
         }
 
         [TestMethod]
+        [TestProperty("Time", "Short")]
+        [TestCategory("ExpressionTest")]
+        [TestCategory("BooleanExpressionTest")]
         public void TestNot()
         {
@@ -53,14 +68,20 @@
             Assert.AreEqual(false, interpreter.BooleanStack.Top);
 
-            this.TestStackCounts(booleanStack: 1);
+            TestStackCounts(booleanStack: 1);
         }
 
         [TestMethod]
+        [TestProperty("Time", "Short")]
+        [TestCategory("ExpressionTest")]
+        [TestCategory("BooleanExpressionTest")]
         public void TestNotWithInsufficientArguments()
         {
-            this.TestWithInsufficientArguments("NOT");
+            TestWithInsufficientArguments("NOT");
         }
 
         [TestMethod]
+        [TestProperty("Time", "Short")]
+        [TestCategory("ExpressionTest")]
+        [TestCategory("BooleanExpressionTest")]
         public void TestFromFloat()
         {
@@ -70,14 +91,20 @@
             Assert.AreEqual(true, interpreter.BooleanStack.Top);
 
-            this.TestStackCounts(booleanStack: 1);
+            TestStackCounts(booleanStack: 1);
         }
 
         [TestMethod]
+        [TestProperty("Time", "Short")]
+        [TestCategory("ExpressionTest")]
+        [TestCategory("BooleanExpressionTest")]
         public void TestFromFloatWithInsufficientArguments()
         {
-            this.TestWithInsufficientArguments("FROMFLOAT");
+            TestWithInsufficientArguments("FROMFLOAT");
         }
 
         [TestMethod]
+        [TestProperty("Time", "Short")]
+        [TestCategory("ExpressionTest")]
+        [TestCategory("BooleanExpressionTest")]
         public void TestFromInteger()
         {
@@ -87,11 +114,14 @@
             Assert.AreEqual(true, interpreter.BooleanStack.Top);
 
-            this.TestStackCounts(booleanStack: 1);
+            TestStackCounts(booleanStack: 1);
         }
 
         [TestMethod]
+        [TestProperty("Time", "Short")]
+        [TestCategory("ExpressionTest")]
+        [TestCategory("BooleanExpressionTest")]
         public void TestFromIntegerWithInsufficientArguments()
         {
-            this.TestWithInsufficientArguments("FROMINTEGER");
+            TestWithInsufficientArguments("FROMINTEGER");
         }
 
@@ -110,5 +140,5 @@
         protected override void CheckOtherStacksAreEmpty()
         {
-            this.TestStackCounts(booleanStack: null);
+            TestStackCounts(booleanStack: null);
         }
     }
Index: branches/PushGP/HeuristicLab.Algorithms.PushGP/HeuristicLab.Tests/Interpreter/Expressions/CodeExpressionTests.cs
===================================================================
--- branches/PushGP/HeuristicLab.Algorithms.PushGP/HeuristicLab.Tests/Interpreter/Expressions/CodeExpressionTests.cs	(revision 14397)
+++ branches/PushGP/HeuristicLab.Algorithms.PushGP/HeuristicLab.Tests/Interpreter/Expressions/CodeExpressionTests.cs	(revision 14398)
@@ -16,8 +16,11 @@
         public CodeExpressionTests()
         {
-            this.cg = new CodeGenerator(interpreter);
-        }
-
-        [TestMethod]
+            cg = new CodeGenerator(interpreter);
+        }
+
+        [TestMethod]
+        [TestProperty("Time", "Short")]
+        [TestCategory("ExpressionTest")]
+        [TestCategory("CodeExpressionTest")]
         public void TestAppendLists()
         {
@@ -30,8 +33,11 @@
 
             Assert.AreEqual(result, interpreter.CodeStack.Top);
-            this.CheckOtherStacksAreEmpty();
-        }
-
-        [TestMethod]
+            CheckOtherStacksAreEmpty();
+        }
+
+        [TestMethod]
+        [TestProperty("Time", "Short")]
+        [TestCategory("ExpressionTest")]
+        [TestCategory("CodeExpressionTest")]
         public void TestAppendListAndLiteral()
         {
@@ -44,8 +50,11 @@
 
             Assert.AreEqual(result, interpreter.CodeStack.Top);
-            this.CheckOtherStacksAreEmpty();
-        }
-
-        [TestMethod]
+            CheckOtherStacksAreEmpty();
+        }
+
+        [TestMethod]
+        [TestProperty("Time", "Short")]
+        [TestCategory("ExpressionTest")]
+        [TestCategory("CodeExpressionTest")]
         public void TestAppendLiterals()
         {
@@ -58,8 +67,11 @@
 
             Assert.AreEqual(result, interpreter.CodeStack.Top);
-            this.CheckOtherStacksAreEmpty();
-        }
-
-        [TestMethod]
+            CheckOtherStacksAreEmpty();
+        }
+
+        [TestMethod]
+        [TestProperty("Time", "Short")]
+        [TestCategory("ExpressionTest")]
+        [TestCategory("CodeExpressionTest")]
         public void TestAtomList()
         {
@@ -70,8 +82,11 @@
 
             Assert.AreEqual(false, interpreter.BooleanStack.Top);
-            this.TestStackCounts(booleanStack: 1);
-        }
-
-        [TestMethod]
+            TestStackCounts(booleanStack: 1);
+        }
+
+        [TestMethod]
+        [TestProperty("Time", "Short")]
+        [TestCategory("ExpressionTest")]
+        [TestCategory("CodeExpressionTest")]
         public void TestAtomLiteral()
         {
@@ -82,8 +97,11 @@
 
             Assert.AreEqual(true, interpreter.BooleanStack.Top);
-            this.TestStackCounts(booleanStack: 1);
-        }
-
-        [TestMethod]
+            TestStackCounts(booleanStack: 1);
+        }
+
+        [TestMethod]
+        [TestProperty("Time", "Short")]
+        [TestCategory("ExpressionTest")]
+        [TestCategory("CodeExpressionTest")]
         public void TestAtomSingleInstruction()
         {
@@ -94,8 +112,11 @@
 
             Assert.AreEqual(true, interpreter.BooleanStack.Top);
-            this.TestStackCounts(booleanStack: 1);
-        }
-
-        [TestMethod]
+            TestStackCounts(booleanStack: 1);
+        }
+
+        [TestMethod]
+        [TestProperty("Time", "Short")]
+        [TestCategory("ExpressionTest")]
+        [TestCategory("CodeExpressionTest")]
         public void TestCarList()
         {
@@ -107,8 +128,11 @@
 
             Assert.AreEqual(result, interpreter.CodeStack.Top);
-            this.CheckOtherStacksAreEmpty();
-        }
-
-        [TestMethod]
+            CheckOtherStacksAreEmpty();
+        }
+
+        [TestMethod]
+        [TestProperty("Time", "Short")]
+        [TestCategory("ExpressionTest")]
+        [TestCategory("CodeExpressionTest")]
         public void TestCarNoList()
         {
@@ -120,8 +144,11 @@
 
             Assert.AreEqual(result, interpreter.CodeStack.Top);
-            this.CheckOtherStacksAreEmpty();
-        }
-
-        [TestMethod]
+            CheckOtherStacksAreEmpty();
+        }
+
+        [TestMethod]
+        [TestProperty("Time", "Short")]
+        [TestCategory("ExpressionTest")]
+        [TestCategory("CodeExpressionTest")]
         public void TestCdrList()
         {
@@ -133,8 +160,11 @@
 
             Assert.AreEqual(result, interpreter.CodeStack.Top);
-            this.CheckOtherStacksAreEmpty();
-        }
-
-        [TestMethod]
+            CheckOtherStacksAreEmpty();
+        }
+
+        [TestMethod]
+        [TestProperty("Time", "Short")]
+        [TestCategory("ExpressionTest")]
+        [TestCategory("CodeExpressionTest")]
         public void TestCdrNoList()
         {
@@ -146,8 +176,11 @@
 
             Assert.AreEqual(result, interpreter.CodeStack.Top);
-            this.CheckOtherStacksAreEmpty();
-        }
-
-        [TestMethod]
+            CheckOtherStacksAreEmpty();
+        }
+
+        [TestMethod]
+        [TestProperty("Time", "Short")]
+        [TestCategory("ExpressionTest")]
+        [TestCategory("CodeExpressionTest")]
         public void TestCons()
         {
@@ -160,8 +193,11 @@
 
             Assert.AreEqual(result, interpreter.CodeStack.Top);
-            this.CheckOtherStacksAreEmpty();
-        }
-
-        [TestMethod]
+            CheckOtherStacksAreEmpty();
+        }
+
+        [TestMethod]
+        [TestProperty("Time", "Short")]
+        [TestCategory("ExpressionTest")]
+        [TestCategory("CodeExpressionTest")]
         public void TestContainsTrue()
         {
@@ -173,8 +209,11 @@
 
             Assert.AreEqual(true, interpreter.BooleanStack.Top);
-            this.TestStackCounts(booleanStack: 1);
-        }
-
-        [TestMethod]
+            TestStackCounts(booleanStack: 1);
+        }
+
+        [TestMethod]
+        [TestProperty("Time", "Short")]
+        [TestCategory("ExpressionTest")]
+        [TestCategory("CodeExpressionTest")]
         public void TestContainsFalse()
         {
@@ -186,8 +225,11 @@
 
             Assert.AreEqual(false, interpreter.BooleanStack.Top);
-            this.TestStackCounts(booleanStack: 1);
-        }
-
-        [TestMethod]
+            TestStackCounts(booleanStack: 1);
+        }
+
+        [TestMethod]
+        [TestProperty("Time", "Short")]
+        [TestCategory("ExpressionTest")]
+        [TestCategory("CodeExpressionTest")]
         public void TestContainer()
         {
@@ -200,8 +242,11 @@
 
             Assert.AreEqual(result, interpreter.CodeStack.Top);
-            this.CheckOtherStacksAreEmpty();
-        }
-
-        [TestMethod]
+            CheckOtherStacksAreEmpty();
+        }
+
+        [TestMethod]
+        [TestProperty("Time", "Short")]
+        [TestCategory("ExpressionTest")]
+        [TestCategory("CodeExpressionTest")]
         public void TestDefinition()
         {
@@ -214,8 +259,11 @@
 
             Assert.AreEqual(code, interpreter.CodeStack.Top);
-            this.CheckOtherStacksAreEmpty();
-        }
-
-        [TestMethod]
+            CheckOtherStacksAreEmpty();
+        }
+
+        [TestMethod]
+        [TestProperty("Time", "Short")]
+        [TestCategory("ExpressionTest")]
+        [TestCategory("CodeExpressionTest")]
         public void TestDefinitionWithoutMatchingName()
         {
@@ -227,8 +275,11 @@
             interpreter.Interpret(program);
 
-            this.TestStackCounts(nameStack: 1);
-        }
-
-        [TestMethod]
+            TestStackCounts(nameStack: 1);
+        }
+
+        [TestMethod]
+        [TestProperty("Time", "Short")]
+        [TestCategory("ExpressionTest")]
+        [TestCategory("CodeExpressionTest")]
         public void TestDiscrepancy()
         {
@@ -240,8 +291,11 @@
 
             Assert.AreEqual(2, interpreter.IntegerStack.Top);
-            this.TestStackCounts(integerStack: 1);
-        }
-
-        [TestMethod]
+            TestStackCounts(integerStack: 1);
+        }
+
+        [TestMethod]
+        [TestProperty("Time", "Short")]
+        [TestCategory("ExpressionTest")]
+        [TestCategory("CodeExpressionTest")]
         public void TestDiscrepancyAllEqual()
         {
@@ -253,8 +307,11 @@
 
             Assert.AreEqual(0, interpreter.IntegerStack.Top);
-            this.TestStackCounts(integerStack: 1);
-        }
-
-        [TestMethod]
+            TestStackCounts(integerStack: 1);
+        }
+
+        [TestMethod]
+        [TestProperty("Time", "Short")]
+        [TestCategory("ExpressionTest")]
+        [TestCategory("CodeExpressionTest")]
         public void TestDiscrepancyComplex()
         {
@@ -266,8 +323,11 @@
 
             Assert.AreEqual(3, interpreter.IntegerStack.Top);
-            this.TestStackCounts(integerStack: 1);
-        }
-
-        [TestMethod]
+            TestStackCounts(integerStack: 1);
+        }
+
+        [TestMethod]
+        [TestProperty("Time", "Short")]
+        [TestCategory("ExpressionTest")]
+        [TestCategory("CodeExpressionTest")]
         public void TestDiscrepancWithLists()
         {
@@ -279,8 +339,11 @@
 
             Assert.AreEqual(5, interpreter.IntegerStack.Top);
-            this.TestStackCounts(integerStack: 1);
-        }
-
-        [TestMethod]
+            TestStackCounts(integerStack: 1);
+        }
+
+        [TestMethod]
+        [TestProperty("Time", "Short")]
+        [TestCategory("ExpressionTest")]
+        [TestCategory("CodeExpressionTest")]
         public void TestDo()
         {
@@ -291,8 +354,11 @@
 
             Assert.AreEqual(10, interpreter.IntegerStack.Top);
-            this.TestStackCounts(integerStack: 1);
-        }
-
-        [TestMethod]
+            TestStackCounts(integerStack: 1);
+        }
+
+        [TestMethod]
+        [TestProperty("Time", "Short")]
+        [TestCategory("ExpressionTest")]
+        [TestCategory("CodeExpressionTest")]
         public void TestDoX()
         {
@@ -303,8 +369,11 @@
 
             Assert.AreEqual(10, interpreter.IntegerStack.Top);
-            this.TestStackCounts(integerStack: 1);
-        }
-
-        [TestMethod]
+            TestStackCounts(integerStack: 1);
+        }
+
+        [TestMethod]
+        [TestProperty("Time", "Short")]
+        [TestCategory("ExpressionTest")]
+        [TestCategory("CodeExpressionTest")]
         public void TestDoCount()
         {
@@ -316,8 +385,11 @@
 
             Assert.AreEqual(6, interpreter.IntegerStack.Top);
-            this.TestStackCounts(integerStack: 1);
-        }
-
-        [TestMethod]
+            TestStackCounts(integerStack: 1);
+        }
+
+        [TestMethod]
+        [TestProperty("Time", "Short")]
+        [TestCategory("ExpressionTest")]
+        [TestCategory("CodeExpressionTest")]
         public void TestDoCountWithNegativeCounter()
         {
@@ -329,8 +401,11 @@
 
             Assert.AreEqual(-1, interpreter.IntegerStack.Top);
-            this.TestStackCounts(codeStack: 1, integerStack: 1);
-        }
-
-        [TestMethod]
+            TestStackCounts(codeStack: 1, integerStack: 1);
+        }
+
+        [TestMethod]
+        [TestProperty("Time", "Short")]
+        [TestCategory("ExpressionTest")]
+        [TestCategory("CodeExpressionTest")]
         public void TestDoRange()
         {
@@ -342,8 +417,11 @@
 
             Assert.AreEqual(12, interpreter.IntegerStack.Top);
-            this.TestStackCounts(integerStack: 1);
-        }
-
-        [TestMethod]
+            TestStackCounts(integerStack: 1);
+        }
+
+        [TestMethod]
+        [TestProperty("Time", "Short")]
+        [TestCategory("ExpressionTest")]
+        [TestCategory("CodeExpressionTest")]
         public void TestDoRangeWithEqualIndecators()
         {
@@ -355,8 +433,11 @@
 
             Assert.AreEqual(3, interpreter.IntegerStack.Top);
-            this.TestStackCounts(codeStack: 1, integerStack: 2);
-        }
-
-        [TestMethod]
+            TestStackCounts(codeStack: 1, integerStack: 2);
+        }
+
+        [TestMethod]
+        [TestProperty("Time", "Short")]
+        [TestCategory("ExpressionTest")]
+        [TestCategory("CodeExpressionTest")]
         public void TestDoRangeWithNegativeIndecators()
         {
@@ -368,8 +449,11 @@
 
             Assert.AreEqual(-12, interpreter.IntegerStack.Top);
-            this.TestStackCounts(integerStack: 1);
-        }
-
-        [TestMethod]
+            TestStackCounts(integerStack: 1);
+        }
+
+        [TestMethod]
+        [TestProperty("Time", "Short")]
+        [TestCategory("ExpressionTest")]
+        [TestCategory("CodeExpressionTest")]
         public void TestDoTimes()
         {
@@ -381,8 +465,11 @@
 
             Assert.AreEqual(32, interpreter.IntegerStack.Top);
-            this.TestStackCounts(integerStack: 1);
-        }
-
-        [TestMethod]
+            TestStackCounts(integerStack: 1);
+        }
+
+        [TestMethod]
+        [TestProperty("Time", "Short")]
+        [TestCategory("ExpressionTest")]
+        [TestCategory("CodeExpressionTest")]
         public void TestDoTimesWithNegativeCounter()
         {
@@ -394,8 +481,11 @@
 
             Assert.AreEqual(-3, interpreter.IntegerStack.Top);
-            this.TestStackCounts(codeStack: 1, integerStack: 2);
-        }
-
-        [TestMethod]
+            TestStackCounts(codeStack: 1, integerStack: 2);
+        }
+
+        [TestMethod]
+        [TestProperty("Time", "Short")]
+        [TestCategory("ExpressionTest")]
+        [TestCategory("CodeExpressionTest")]
         public void TestNestedDoRange()
         {
@@ -403,8 +493,11 @@
 
             Assert.AreEqual(144, interpreter.IntegerStack.Top);
-            this.TestStackCounts(integerStack: 1);
-        }
-
-        [TestMethod]
+            TestStackCounts(integerStack: 1);
+        }
+
+        [TestMethod]
+        [TestProperty("Time", "Short")]
+        [TestCategory("ExpressionTest")]
+        [TestCategory("CodeExpressionTest")]
         public void TestNestedDoCount()
         {
@@ -412,8 +505,11 @@
 
             Assert.AreEqual(144, interpreter.IntegerStack.Top);
-            this.TestStackCounts(integerStack: 1);
-        }
-
-        [TestMethod]
+            TestStackCounts(integerStack: 1);
+        }
+
+        [TestMethod]
+        [TestProperty("Time", "Short")]
+        [TestCategory("ExpressionTest")]
+        [TestCategory("CodeExpressionTest")]
         public void TestNestedDoTimes()
         {
@@ -421,8 +517,11 @@
 
             Assert.AreEqual(128, interpreter.IntegerStack.Top);
-            this.TestStackCounts(integerStack: 1);
-        }
-
-        [TestMethod]
+            TestStackCounts(integerStack: 1);
+        }
+
+        [TestMethod]
+        [TestProperty("Time", "Short")]
+        [TestCategory("ExpressionTest")]
+        [TestCategory("CodeExpressionTest")]
         public void TestExtract()
         {
@@ -435,8 +534,11 @@
 
             Assert.AreEqual(result, interpreter.CodeStack.Top);
-            this.CheckOtherStacksAreEmpty();
-        }
-
-        [TestMethod]
+            CheckOtherStacksAreEmpty();
+        }
+
+        [TestMethod]
+        [TestProperty("Time", "Short")]
+        [TestCategory("ExpressionTest")]
+        [TestCategory("CodeExpressionTest")]
         public void TestExtractInteger()
         {
@@ -449,8 +551,11 @@
 
             Assert.AreEqual(result, interpreter.CodeStack.Top);
-            this.CheckOtherStacksAreEmpty();
-        }
-
-        [TestMethod]
+            CheckOtherStacksAreEmpty();
+        }
+
+        [TestMethod]
+        [TestProperty("Time", "Short")]
+        [TestCategory("ExpressionTest")]
+        [TestCategory("CodeExpressionTest")]
         public void TestExtractFloat()
         {
@@ -463,8 +568,11 @@
 
             Assert.AreEqual(result, interpreter.CodeStack.Top);
-            this.CheckOtherStacksAreEmpty();
-        }
-
-        [TestMethod]
+            CheckOtherStacksAreEmpty();
+        }
+
+        [TestMethod]
+        [TestProperty("Time", "Short")]
+        [TestCategory("ExpressionTest")]
+        [TestCategory("CodeExpressionTest")]
         public void TestExtractBoolean()
         {
@@ -477,8 +585,11 @@
 
             Assert.AreEqual(result, interpreter.CodeStack.Top);
-            this.CheckOtherStacksAreEmpty();
-        }
-
-        [TestMethod]
+            CheckOtherStacksAreEmpty();
+        }
+
+        [TestMethod]
+        [TestProperty("Time", "Short")]
+        [TestCategory("ExpressionTest")]
+        [TestCategory("CodeExpressionTest")]
         public void TestExtractInstruction()
         {
@@ -491,8 +602,11 @@
 
             Assert.AreEqual(result, interpreter.CodeStack.Top);
-            this.CheckOtherStacksAreEmpty();
-        }
-
-        [TestMethod]
+            CheckOtherStacksAreEmpty();
+        }
+
+        [TestMethod]
+        [TestProperty("Time", "Short")]
+        [TestCategory("ExpressionTest")]
+        [TestCategory("CodeExpressionTest")]
         public void TestFromBoolean()
         {
@@ -502,8 +616,11 @@
 
             Assert.AreEqual(result, interpreter.CodeStack.Top);
-            this.CheckOtherStacksAreEmpty();
-        }
-
-        [TestMethod]
+            CheckOtherStacksAreEmpty();
+        }
+
+        [TestMethod]
+        [TestProperty("Time", "Short")]
+        [TestCategory("ExpressionTest")]
+        [TestCategory("CodeExpressionTest")]
         public void TestFromFloat()
         {
@@ -513,8 +630,11 @@
 
             Assert.AreEqual(result, interpreter.CodeStack.Top);
-            this.CheckOtherStacksAreEmpty();
-        }
-
-        [TestMethod]
+            CheckOtherStacksAreEmpty();
+        }
+
+        [TestMethod]
+        [TestProperty("Time", "Short")]
+        [TestCategory("ExpressionTest")]
+        [TestCategory("CodeExpressionTest")]
         public void TestFromInteger()
         {
@@ -524,8 +644,11 @@
 
             Assert.AreEqual(result, interpreter.CodeStack.Top);
-            this.CheckOtherStacksAreEmpty();
-        }
-
-        [TestMethod]
+            CheckOtherStacksAreEmpty();
+        }
+
+        [TestMethod]
+        [TestProperty("Time", "Short")]
+        [TestCategory("ExpressionTest")]
+        [TestCategory("CodeExpressionTest")]
         public void TestFromName()
         {
@@ -535,8 +658,11 @@
 
             Assert.AreEqual(result, interpreter.CodeStack.Top);
-            this.CheckOtherStacksAreEmpty();
-        }
-
-        [TestMethod]
+            CheckOtherStacksAreEmpty();
+        }
+
+        [TestMethod]
+        [TestProperty("Time", "Short")]
+        [TestCategory("ExpressionTest")]
+        [TestCategory("CodeExpressionTest")]
         public void TestIfTrue()
         {
@@ -549,8 +675,11 @@
 
             Assert.AreEqual("WAHR", interpreter.NameStack.Top);
-            this.TestStackCounts(nameStack: 1);
-        }
-
-        [TestMethod]
+            TestStackCounts(nameStack: 1);
+        }
+
+        [TestMethod]
+        [TestProperty("Time", "Short")]
+        [TestCategory("ExpressionTest")]
+        [TestCategory("CodeExpressionTest")]
         public void TestIfFalse()
         {
@@ -563,8 +692,11 @@
 
             Assert.AreEqual("FALSCH", interpreter.NameStack.Top);
-            this.TestStackCounts(nameStack: 1);
-        }
-
-        [TestMethod]
+            TestStackCounts(nameStack: 1);
+        }
+
+        [TestMethod]
+        [TestProperty("Time", "Short")]
+        [TestCategory("ExpressionTest")]
+        [TestCategory("CodeExpressionTest")]
         public void TestInsert()
         {
@@ -578,8 +710,11 @@
 
             Assert.AreEqual(result, interpreter.CodeStack.Top);
-            this.CheckOtherStacksAreEmpty();
-        }
-
-        [TestMethod]
+            CheckOtherStacksAreEmpty();
+        }
+
+        [TestMethod]
+        [TestProperty("Time", "Short")]
+        [TestCategory("ExpressionTest")]
+        [TestCategory("CodeExpressionTest")]
         public void TestInsertWithNegativeN()
         {
@@ -593,8 +728,11 @@
 
             Assert.AreEqual(result, interpreter.CodeStack.Top);
-            this.CheckOtherStacksAreEmpty();
-        }
-
-        [TestMethod]
+            CheckOtherStacksAreEmpty();
+        }
+
+        [TestMethod]
+        [TestProperty("Time", "Short")]
+        [TestCategory("ExpressionTest")]
+        [TestCategory("CodeExpressionTest")]
         public void TestInsertWithTooBigN()
         {
@@ -608,8 +746,11 @@
 
             Assert.AreEqual(result, interpreter.CodeStack.Top);
-            this.CheckOtherStacksAreEmpty();
-        }
-
-        [TestMethod]
+            CheckOtherStacksAreEmpty();
+        }
+
+        [TestMethod]
+        [TestProperty("Time", "Short")]
+        [TestCategory("ExpressionTest")]
+        [TestCategory("CodeExpressionTest")]
         public void TestList()
         {
@@ -622,8 +763,11 @@
 
             Assert.AreEqual(result, interpreter.CodeStack.Top);
-            this.CheckOtherStacksAreEmpty();
-        }
-
-        [TestMethod]
+            CheckOtherStacksAreEmpty();
+        }
+
+        [TestMethod]
+        [TestProperty("Time", "Short")]
+        [TestCategory("ExpressionTest")]
+        [TestCategory("CodeExpressionTest")]
         public void TestMemberTrue()
         {
@@ -635,8 +779,11 @@
 
             Assert.AreEqual(true, interpreter.BooleanStack.Top);
-            this.TestStackCounts(booleanStack: 1);
-        }
-
-        [TestMethod]
+            TestStackCounts(booleanStack: 1);
+        }
+
+        [TestMethod]
+        [TestProperty("Time", "Short")]
+        [TestCategory("ExpressionTest")]
+        [TestCategory("CodeExpressionTest")]
         public void TestMemberFalse()
         {
@@ -648,8 +795,11 @@
 
             Assert.AreEqual(false, interpreter.BooleanStack.Top);
-            this.TestStackCounts(booleanStack: 1);
-        }
-
-        [TestMethod]
+            TestStackCounts(booleanStack: 1);
+        }
+
+        [TestMethod]
+        [TestProperty("Time", "Short")]
+        [TestCategory("ExpressionTest")]
+        [TestCategory("CodeExpressionTest")]
         public void TestMemberIfNoList()
         {
@@ -661,16 +811,22 @@
 
             Assert.AreEqual(true, interpreter.BooleanStack.Top);
-            this.TestStackCounts(booleanStack: 1);
-        }
-
-        [TestMethod]
+            TestStackCounts(booleanStack: 1);
+        }
+
+        [TestMethod]
+        [TestProperty("Time", "Short")]
+        [TestCategory("ExpressionTest")]
+        [TestCategory("CodeExpressionTest")]
         public void TestNoop()
         {
             interpreter.Interpret(new CodeNoopExpression());
 
-            this.CheckOtherStacksAreEmpty();
-        }
-
-        [TestMethod]
+            CheckOtherStacksAreEmpty();
+        }
+
+        [TestMethod]
+        [TestProperty("Time", "Short")]
+        [TestCategory("ExpressionTest")]
+        [TestCategory("CodeExpressionTest")]
         public void TestNthIfNoList()
         {
@@ -683,8 +839,11 @@
 
             Assert.AreEqual(result, interpreter.CodeStack.Top);
-            this.CheckOtherStacksAreEmpty();
-        }
-
-        [TestMethod]
+            CheckOtherStacksAreEmpty();
+        }
+
+        [TestMethod]
+        [TestProperty("Time", "Short")]
+        [TestCategory("ExpressionTest")]
+        [TestCategory("CodeExpressionTest")]
         public void TestNthIfEmpty()
         {
@@ -697,8 +856,11 @@
 
             Assert.AreEqual(result, interpreter.CodeStack.Top);
-            this.CheckOtherStacksAreEmpty();
-        }
-
-        [TestMethod]
+            CheckOtherStacksAreEmpty();
+        }
+
+        [TestMethod]
+        [TestProperty("Time", "Short")]
+        [TestCategory("ExpressionTest")]
+        [TestCategory("CodeExpressionTest")]
         public void TestNth()
         {
@@ -711,8 +873,11 @@
 
             Assert.AreEqual(result, interpreter.CodeStack.Top);
-            this.CheckOtherStacksAreEmpty();
-        }
-
-        [TestMethod]
+            CheckOtherStacksAreEmpty();
+        }
+
+        [TestMethod]
+        [TestProperty("Time", "Short")]
+        [TestCategory("ExpressionTest")]
+        [TestCategory("CodeExpressionTest")]
         public void TestNthWithTooBigN()
         {
@@ -725,8 +890,11 @@
 
             Assert.AreEqual(result, interpreter.CodeStack.Top);
-            this.CheckOtherStacksAreEmpty();
-        }
-
-        [TestMethod]
+            CheckOtherStacksAreEmpty();
+        }
+
+        [TestMethod]
+        [TestProperty("Time", "Short")]
+        [TestCategory("ExpressionTest")]
+        [TestCategory("CodeExpressionTest")]
         public void TestNthWithNegativeN()
         {
@@ -739,8 +907,11 @@
 
             Assert.AreEqual(result, interpreter.CodeStack.Top);
-            this.CheckOtherStacksAreEmpty();
-        }
-
-        [TestMethod]
+            CheckOtherStacksAreEmpty();
+        }
+
+        [TestMethod]
+        [TestProperty("Time", "Short")]
+        [TestCategory("ExpressionTest")]
+        [TestCategory("CodeExpressionTest")]
         public void TestNthCdr()
         {
@@ -753,8 +924,11 @@
 
             Assert.AreEqual(result, interpreter.CodeStack.Top);
-            this.CheckOtherStacksAreEmpty();
-        }
-
-        [TestMethod]
+            CheckOtherStacksAreEmpty();
+        }
+
+        [TestMethod]
+        [TestProperty("Time", "Short")]
+        [TestCategory("ExpressionTest")]
+        [TestCategory("CodeExpressionTest")]
         public void TestNthCdrWithTooBigN()
         {
@@ -767,8 +941,11 @@
 
             Assert.AreEqual(result, interpreter.CodeStack.Top);
-            this.CheckOtherStacksAreEmpty();
-        }
-
-        [TestMethod]
+            CheckOtherStacksAreEmpty();
+        }
+
+        [TestMethod]
+        [TestProperty("Time", "Short")]
+        [TestCategory("ExpressionTest")]
+        [TestCategory("CodeExpressionTest")]
         public void TestNthCdrWithNegativeN()
         {
@@ -781,8 +958,11 @@
 
             Assert.AreEqual(result, interpreter.CodeStack.Top);
-            this.CheckOtherStacksAreEmpty();
-        }
-
-        [TestMethod]
+            CheckOtherStacksAreEmpty();
+        }
+
+        [TestMethod]
+        [TestProperty("Time", "Short")]
+        [TestCategory("ExpressionTest")]
+        [TestCategory("CodeExpressionTest")]
         public void TestNthCdrIfEmpty()
         {
@@ -795,8 +975,11 @@
 
             Assert.AreEqual(result, interpreter.CodeStack.Top);
-            this.CheckOtherStacksAreEmpty();
-        }
-
-        [TestMethod]
+            CheckOtherStacksAreEmpty();
+        }
+
+        [TestMethod]
+        [TestProperty("Time", "Short")]
+        [TestCategory("ExpressionTest")]
+        [TestCategory("CodeExpressionTest")]
         public void TestNthCdrIfNoList()
         {
@@ -809,8 +992,11 @@
 
             Assert.AreEqual(result, interpreter.CodeStack.Top);
-            this.CheckOtherStacksAreEmpty();
-        }
-
-        [TestMethod]
+            CheckOtherStacksAreEmpty();
+        }
+
+        [TestMethod]
+        [TestProperty("Time", "Short")]
+        [TestCategory("ExpressionTest")]
+        [TestCategory("CodeExpressionTest")]
         public void TestNullTrue()
         {
@@ -821,8 +1007,11 @@
 
             Assert.AreEqual(true, interpreter.BooleanStack.Top);
-            this.TestStackCounts(booleanStack: 1);
-        }
-
-        [TestMethod]
+            TestStackCounts(booleanStack: 1);
+        }
+
+        [TestMethod]
+        [TestProperty("Time", "Short")]
+        [TestCategory("ExpressionTest")]
+        [TestCategory("CodeExpressionTest")]
         public void TestNullFalse()
         {
@@ -833,8 +1022,11 @@
 
             Assert.AreEqual(false, interpreter.BooleanStack.Top);
-            this.TestStackCounts(booleanStack: 1);
-        }
-
-        [TestMethod]
+            TestStackCounts(booleanStack: 1);
+        }
+
+        [TestMethod]
+        [TestProperty("Time", "Short")]
+        [TestCategory("ExpressionTest")]
+        [TestCategory("CodeExpressionTest")]
         public void TestPosition()
         {
@@ -846,8 +1038,11 @@
 
             Assert.AreEqual(2, interpreter.IntegerStack.Top);
-            this.TestStackCounts(integerStack: 1);
-        }
-
-        [TestMethod]
+            TestStackCounts(integerStack: 1);
+        }
+
+        [TestMethod]
+        [TestProperty("Time", "Short")]
+        [TestCategory("ExpressionTest")]
+        [TestCategory("CodeExpressionTest")]
         public void TestQuote()
         {
@@ -857,8 +1052,11 @@
 
             Assert.AreEqual(result, interpreter.CodeStack.Top);
-            this.CheckOtherStacksAreEmpty();
-        }
-
-        [TestMethod]
+            CheckOtherStacksAreEmpty();
+        }
+
+        [TestMethod]
+        [TestProperty("Time", "Short")]
+        [TestCategory("ExpressionTest")]
+        [TestCategory("CodeExpressionTest")]
         public void TestSize()
         {
@@ -869,8 +1067,11 @@
 
             Assert.AreEqual(4, interpreter.IntegerStack.Top);
-            this.TestStackCounts(integerStack: 1);
-        }
-
-        [TestMethod]
+            TestStackCounts(integerStack: 1);
+        }
+
+        [TestMethod]
+        [TestProperty("Time", "Short")]
+        [TestCategory("ExpressionTest")]
+        [TestCategory("CodeExpressionTest")]
         public void TestSubstitude()
         {
@@ -884,5 +1085,5 @@
 
             Assert.AreEqual(result, interpreter.CodeStack.Top);
-            this.CheckOtherStacksAreEmpty();
+            CheckOtherStacksAreEmpty();
         }
 
@@ -910,5 +1111,5 @@
         protected override void CheckOtherStacksAreEmpty()
         {
-            this.TestStackCounts(codeStack: null);
+            TestStackCounts(codeStack: null);
         }
     }
Index: branches/PushGP/HeuristicLab.Algorithms.PushGP/HeuristicLab.Tests/Interpreter/Expressions/CommonTests.cs
===================================================================
--- branches/PushGP/HeuristicLab.Algorithms.PushGP/HeuristicLab.Tests/Interpreter/Expressions/CommonTests.cs	(revision 14397)
+++ branches/PushGP/HeuristicLab.Algorithms.PushGP/HeuristicLab.Tests/Interpreter/Expressions/CommonTests.cs	(revision 14398)
@@ -7,5 +7,5 @@
 {
 
-    public abstract class CommonTests<T> : InterpreterTest
+    public abstract class CommonTests<T> : ExpressionTest
     {
         protected const string FullInstructionNameFormat = "{0}.{1}";
@@ -17,10 +17,10 @@
         protected virtual T[] Get2Different()
         {
-            return this.GetValues(2);
+            return GetValues(2);
         }
 
         protected virtual void Test(Expression expression)
         {
-            this.interpreter.Interpret(expression);
+            interpreter.Interpret(expression);
         }
 
@@ -28,22 +28,25 @@
 
         [TestMethod]
+        [TestProperty("Time", "Short")]
+        [TestCategory("ExpressionTest")]
+        [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);
+            Stack.Push(merged);
 
             var isBooleanStack = interpreter.BooleanStack.Count == 2;
 
-            this.Test(ExpressionTable.GetStatelessExpression(this.TypeName + ".="));
+            Test(ExpressionTable.GetStatelessExpression(TypeName + ".="));
 
             if (isBooleanStack)
             {
-                Assert.AreEqual(1, this.Stack.Count);
+                Assert.AreEqual(1, Stack.Count);
             }
             else
             {
-                Assert.AreEqual(0, this.Stack.Count);
+                Assert.AreEqual(0, Stack.Count);
             }
 
@@ -52,19 +55,22 @@
 
         [TestMethod]
+        [TestProperty("Time", "Short")]
+        [TestCategory("ExpressionTest")]
+        [TestCategory("CommonExpressionTest")]
         public virtual void TestEqualsFalse()
         {
-            var values = this.Get2Different();
-            this.Stack.Push(values);
+            var values = Get2Different();
+            Stack.Push(values);
             var isBooleanStack = interpreter.BooleanStack.Count == 2;
 
-            this.Test(ExpressionTable.GetStatelessExpression(this.TypeName + ".="));
+            Test(ExpressionTable.GetStatelessExpression(TypeName + ".="));
 
             if (isBooleanStack)
             {
-                Assert.AreEqual(1, this.Stack.Count);
+                Assert.AreEqual(1, Stack.Count);
             }
             else
             {
-                Assert.AreEqual(0, this.Stack.Count);
+                Assert.AreEqual(0, Stack.Count);
             }
 
@@ -73,166 +79,214 @@
 
         [TestMethod]
+        [TestProperty("Time", "Short")]
+        [TestCategory("ExpressionTest")]
+        [TestCategory("CommonExpressionTest")]
         public virtual void TestEqualsWithInsufficientArguments()
         {
-            this.TestWithInsufficientArguments("=", 1);
-        }
-
-        [TestMethod]
+            TestWithInsufficientArguments("=", 1);
+        }
+
+        [TestMethod]
+        [TestProperty("Time", "Short")]
+        [TestCategory("ExpressionTest")]
+        [TestCategory("CommonExpressionTest")]
         public virtual void TestPop()
         {
-            var values = this.GetValues(2);
-            this.Stack.Push(values);
-
-            this.Test(ExpressionTable.GetStatelessExpression(this.TypeName + ".POP"));
-
-            this.CheckOtherStacksAreEmpty();
-        }
-
-        [TestMethod]
+            var values = GetValues(2);
+            Stack.Push(values);
+
+            Test(ExpressionTable.GetStatelessExpression(TypeName + ".POP"));
+
+            CheckOtherStacksAreEmpty();
+        }
+
+        [TestMethod]
+        [TestProperty("Time", "Short")]
+        [TestCategory("ExpressionTest")]
+        [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[0]);
-            Assert.AreEqual(values[2], this.Stack[1]);
-            Assert.AreEqual(values[1], this.Stack[2]);
-
-            this.CheckOtherStacksAreEmpty();
-        }
-
-        [TestMethod]
+            var values = GetValues(3);
+            Stack.Push(values);
+
+            Test(ExpressionTable.GetStatelessExpression(TypeName + ".SWAP"));
+
+            Assert.AreEqual(values[0], Stack[0]);
+            Assert.AreEqual(values[2], Stack[1]);
+            Assert.AreEqual(values[1], Stack[2]);
+
+            CheckOtherStacksAreEmpty();
+        }
+
+        [TestMethod]
+        [TestProperty("Time", "Short")]
+        [TestCategory("ExpressionTest")]
+        [TestCategory("CommonExpressionTest")]
         public virtual void TestSwapWithInsufficientArguments()
         {
-            this.TestWithInsufficientArguments("SWAP", 1);
-        }
-
-
-        [TestMethod]
+            TestWithInsufficientArguments("SWAP", 1);
+        }
+
+
+        [TestMethod]
+        [TestProperty("Time", "Short")]
+        [TestCategory("ExpressionTest")]
+        [TestCategory("CommonExpressionTest")]
         public virtual void TestRotate()
         {
-            var values = this.GetValues(4);
-            this.Stack.Push(values);
-
-            this.Test(ExpressionTable.GetStatelessExpression(this.TypeName + ".ROT"));
-
-            Assert.AreEqual(values[0], this.Stack[0]);
-            Assert.AreEqual(values[3], this.Stack[1]);
-            Assert.AreEqual(values[1], this.Stack[2]);
-            Assert.AreEqual(values[2], this.Stack[3]);
-
-            this.CheckOtherStacksAreEmpty();
-        }
-
-        [TestMethod]
+            var values = GetValues(4);
+            Stack.Push(values);
+
+            Test(ExpressionTable.GetStatelessExpression(TypeName + ".ROT"));
+
+            Assert.AreEqual(values[0], Stack[0]);
+            Assert.AreEqual(values[3], Stack[1]);
+            Assert.AreEqual(values[1], Stack[2]);
+            Assert.AreEqual(values[2], Stack[3]);
+
+            CheckOtherStacksAreEmpty();
+        }
+
+        [TestMethod]
+        [TestProperty("Time", "Short")]
+        [TestCategory("ExpressionTest")]
+        [TestCategory("CommonExpressionTest")]
         public virtual void TestRotateWithInsufficientArguments()
         {
-            this.TestWithInsufficientArguments("ROT", 2);
-        }
-
-        [TestMethod]
+            TestWithInsufficientArguments("ROT", 2);
+        }
+
+        [TestMethod]
+        [TestProperty("Time", "Short")]
+        [TestCategory("ExpressionTest")]
+        [TestCategory("CommonExpressionTest")]
         public virtual void TestShove()
         {
-            var values = this.GetValues(3);
-            this.Stack.Push(values);
+            var values = GetValues(3);
+            Stack.Push(values);
 
             interpreter.IntegerStack.Push(1);
-            this.Test(ExpressionTable.GetStatelessExpression(this.TypeName + ".SHOVE"));
-
-            Assert.AreEqual(values[0], this.Stack[0]);
-            Assert.AreEqual(values[2], this.Stack[1]);
-            Assert.AreEqual(values[1], this.Stack[2]);
-
-            this.CheckOtherStacksAreEmpty();
-        }
-
-        [TestMethod]
+            Test(ExpressionTable.GetStatelessExpression(TypeName + ".SHOVE"));
+
+            Assert.AreEqual(values[0], Stack[0]);
+            Assert.AreEqual(values[2], Stack[1]);
+            Assert.AreEqual(values[1], Stack[2]);
+
+            CheckOtherStacksAreEmpty();
+        }
+
+        [TestMethod]
+        [TestProperty("Time", "Short")]
+        [TestCategory("ExpressionTest")]
+        [TestCategory("CommonExpressionTest")]
         public virtual void TestShoveWithInsufficientArguments()
         {
-            this.TestWithInsufficientArguments("SHOVE", 1);
-        }
-
-        [TestMethod]
+            TestWithInsufficientArguments("SHOVE", 1);
+        }
+
+        [TestMethod]
+        [TestProperty("Time", "Short")]
+        [TestCategory("ExpressionTest")]
+        [TestCategory("CommonExpressionTest")]
         public virtual void TestShoveWithNegativeIndex()
         {
-            this.TestWithNegativeIndex("SHOVE");
-        }
-
-        [TestMethod]
+            TestWithNegativeIndex("SHOVE");
+        }
+
+        [TestMethod]
+        [TestProperty("Time", "Short")]
+        [TestCategory("ExpressionTest")]
+        [TestCategory("CommonExpressionTest")]
         public virtual void TestYank()
         {
-            var values = this.GetValues(3);
-            this.Stack.Push(values);
+            var values = GetValues(3);
+            Stack.Push(values);
 
             interpreter.IntegerStack.Push(1);
-            this.Test(ExpressionTable.GetStatelessExpression(this.TypeName + ".YANK"));
-
-            Assert.AreEqual(values[0], this.Stack[0]);
-            Assert.AreEqual(values[2], this.Stack[1]);
-            Assert.AreEqual(values[1], this.Stack[2]);
-
-            this.CheckOtherStacksAreEmpty();
-        }
-
-        [TestMethod]
+            Test(ExpressionTable.GetStatelessExpression(TypeName + ".YANK"));
+
+            Assert.AreEqual(values[0], Stack[0]);
+            Assert.AreEqual(values[2], Stack[1]);
+            Assert.AreEqual(values[1], Stack[2]);
+
+            CheckOtherStacksAreEmpty();
+        }
+
+        [TestMethod]
+        [TestProperty("Time", "Short")]
+        [TestCategory("ExpressionTest")]
+        [TestCategory("CommonExpressionTest")]
         public virtual void TestYankWithInsufficientArguments()
         {
-            this.TestWithInsufficientArguments("YANK", 1);
-        }
-
-        [TestMethod]
+            TestWithInsufficientArguments("YANK", 1);
+        }
+
+        [TestMethod]
+        [TestProperty("Time", "Short")]
+        [TestCategory("ExpressionTest")]
+        [TestCategory("CommonExpressionTest")]
         public virtual void TestYankWithNegativeIndex()
         {
-            this.TestWithNegativeIndex("YANK");
-        }
-
-        [TestMethod]
+            TestWithNegativeIndex("YANK");
+        }
+
+        [TestMethod]
+        [TestProperty("Time", "Short")]
+        [TestCategory("ExpressionTest")]
+        [TestCategory("CommonExpressionTest")]
         public virtual void TestYankDuplicate()
         {
-            var values = this.GetValues(3);
-            this.Stack.Push(values);
+            var values = GetValues(3);
+            Stack.Push(values);
 
             interpreter.IntegerStack.Push(1);
-            this.Test(ExpressionTable.GetStatelessExpression(this.TypeName + ".YANKDUP"));
-
-            Assert.AreEqual(values[0], this.Stack[0]);
-            Assert.AreEqual(values[1], this.Stack[1]);
-            Assert.AreEqual(values[2], this.Stack[2]);
-            Assert.AreEqual(values[1], this.Stack[3]);
-
-            this.CheckOtherStacksAreEmpty();
-        }
-
-        [TestMethod]
+            Test(ExpressionTable.GetStatelessExpression(TypeName + ".YANKDUP"));
+
+            Assert.AreEqual(values[0], Stack[0]);
+            Assert.AreEqual(values[1], Stack[1]);
+            Assert.AreEqual(values[2], Stack[2]);
+            Assert.AreEqual(values[1], Stack[3]);
+
+            CheckOtherStacksAreEmpty();
+        }
+
+        [TestMethod]
+        [TestProperty("Time", "Short")]
+        [TestCategory("ExpressionTest")]
+        [TestCategory("CommonExpressionTest")]
         public virtual void TestYankDuplicateWithInsufficientArguments()
         {
-            this.TestWithInsufficientArguments("YANKDUP", 1);
-        }
-
-        [TestMethod]
+            TestWithInsufficientArguments("YANKDUP", 1);
+        }
+
+        [TestMethod]
+        [TestProperty("Time", "Short")]
+        [TestCategory("ExpressionTest")]
+        [TestCategory("CommonExpressionTest")]
         public virtual void TestYankDuplicateWithNegativeIndex()
         {
-            this.TestWithNegativeIndex("YANKDUP");
-        }
-
-        [TestMethod]
+            TestWithNegativeIndex("YANKDUP");
+        }
+
+        [TestMethod]
+        [TestProperty("Time", "Short")]
+        [TestCategory("ExpressionTest")]
+        [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(3, Stack.Count);
                 Assert.AreEqual(values.Length, interpreter.IntegerStack.Top);
             }
@@ -243,16 +297,16 @@
             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));
+                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], this.Stack[j]);
+                    Assert.AreEqual(values[j], Stack[j]);
                 }
 
-                this.CheckOtherStacksAreEmpty();
+                CheckOtherStacksAreEmpty();
                 interpreter.Clear();
             }
@@ -261,13 +315,13 @@
         protected void TestWithNegativeIndex(string instructionName)
         {
-            var values = this.GetValues(1);
-            this.Stack.Push(values);
+            var values = GetValues(1);
+            Stack.Push(values);
 
             interpreter.IntegerStack.Push(-1);
 
-            var fullInstructionname = string.Format(FullInstructionNameFormat, this.TypeName, instructionName);
-            this.Test(ExpressionTable.GetStatelessExpression(fullInstructionname));
-
-            Assert.AreEqual(values[0], this.Stack[0]);
+            var fullInstructionname = string.Format(FullInstructionNameFormat, TypeName, instructionName);
+            Test(ExpressionTable.GetStatelessExpression(fullInstructionname));
+
+            Assert.AreEqual(values[0], Stack[0]);
         }
     }
Index: branches/PushGP/HeuristicLab.Algorithms.PushGP/HeuristicLab.Tests/Interpreter/Expressions/ExampleTests.cs
===================================================================
--- branches/PushGP/HeuristicLab.Algorithms.PushGP/HeuristicLab.Tests/Interpreter/Expressions/ExampleTests.cs	(revision 14397)
+++ branches/PushGP/HeuristicLab.Algorithms.PushGP/HeuristicLab.Tests/Interpreter/Expressions/ExampleTests.cs	(revision 14398)
@@ -5,12 +5,14 @@
 {
     [TestClass]
-    public class MixedExpressionTests : InterpreterTest
+    public class MixedExpressionTests : ExpressionTest
     {
         const double Delta = 0.00000001;
 
         [TestMethod]
+        [TestProperty("Time", "Short")]
+        [TestCategory("ExampleTest")]
         public void Example1()
         {
-            this.interpreter.Interpret("( 2 3 INTEGER.* 4.1 5.2 FLOAT.+ TRUE FALSE BOOLEAN.OR )");
+            interpreter.Interpret("( 2 3 INTEGER.* 4.1 5.2 FLOAT.+ TRUE FALSE BOOLEAN.OR )");
 
             Assert.AreEqual(6, interpreter.IntegerStack.Top);
@@ -23,7 +25,9 @@
 
         [TestMethod]
+        [TestProperty("Time", "Short")]
+        [TestCategory("ExampleTest")]
         public void Example2()
         {
-            this.interpreter.Interpret("( 5 1.23 INTEGER.+ ( 4 ) INTEGER.- 5.67 FLOAT.* )");
+            interpreter.Interpret("( 5 1.23 INTEGER.+ ( 4 ) INTEGER.- 5.67 FLOAT.* )");
 
             Assert.AreEqual(1, interpreter.IntegerStack.Top);
@@ -36,75 +40,87 @@
 
         [TestMethod]
+        [TestProperty("Time", "Short")]
+        [TestCategory("ExampleTest")]
         public void Example3()
         {
-            this.interpreter.Interpret("( 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);
-        }
-
-        [TestMethod]
+            interpreter.Interpret("( 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);
+        }
+
+        [TestMethod]
+        [TestProperty("Time", "Short")]
+        [TestCategory("ExampleTest")]
         public void Example4()
         {
-            this.interpreter.Interpret("( 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);
-        }
-
-        [TestMethod]
+            interpreter.Interpret("( 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);
+        }
+
+        [TestMethod]
+        [TestProperty("Time", "Short")]
+        [TestCategory("ExampleTest")]
         public void Example5()
         {
-            this.interpreter.Interpret("( 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);
-        }
-
-        [TestMethod]
+            interpreter.Interpret("( 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);
+        }
+
+        [TestMethod]
+        [TestProperty("Time", "Short")]
+        [TestCategory("ExampleTest")]
         public void Example6()
         {
-            this.interpreter.Interpret("( 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);
-        }
-
-        [TestMethod]
+            interpreter.Interpret("( 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);
+        }
+
+        [TestMethod]
+        [TestProperty("Time", "Short")]
+        [TestCategory("ExampleTest")]
         public void Example7()
         {
-            this.interpreter.Interpret("( 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);
-        }
-
-        [TestMethod]
+            interpreter.Interpret("( 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);
+        }
+
+        [TestMethod]
+        [TestProperty("Time", "Short")]
+        [TestCategory("ExampleTest")]
         public void Example8()
         {
-            this.interpreter.Configuration.TopLevelPushCode = true;
-
-            this.interpreter.IntegerStack.Push(5);
-            this.interpreter.Interpret(@"( CODE.QUOTE ( INTEGER.POP 1 )
+            interpreter.Configuration.TopLevelPushCode = true;
+
+            interpreter.IntegerStack.Push(5);
+            interpreter.Interpret(@"( CODE.QUOTE ( INTEGER.POP 1 )
                                            CODE.QUOTE ( CODE.DUP INTEGER.DUP 1 INTEGER.- CODE.DO INTEGER.* )
                                            INTEGER.DUP 2 INTEGER.< CODE.IF )");
@@ -119,8 +135,10 @@
 
         [TestMethod]
+        [TestProperty("Time", "Short")]
+        [TestCategory("ExampleTest")]
         public void Example9()
         {
-            this.interpreter.IntegerStack.Push(5);
-            this.interpreter.Interpret("( 1 INTEGER.MAX 1 EXEC.DO*RANGE INTEGER.* )");
+            interpreter.IntegerStack.Push(5);
+            interpreter.Interpret("( 1 INTEGER.MAX 1 EXEC.DO*RANGE INTEGER.* )");
 
             Assert.AreEqual(120, interpreter.IntegerStack.Top);
@@ -133,8 +151,10 @@
 
         [TestMethod]
+        [TestProperty("Time", "Short")]
+        [TestCategory("ExampleTest")]
         public void Example10()
         {
-            this.interpreter.IntegerStack.Push(5);
-            this.interpreter.Interpret("( 1 INTEGER.MAX 1 EXEC.DO*RANGE ( 2 INTEGER.* ) )");
+            interpreter.IntegerStack.Push(5);
+            interpreter.Interpret("( 1 INTEGER.MAX 1 EXEC.DO*RANGE ( 2 INTEGER.* ) )");
 
             Assert.AreEqual(2, interpreter.IntegerStack.Top);
@@ -147,12 +167,14 @@
 
         [TestMethod]
+        [TestProperty("Time", "Short")]
+        [TestCategory("ExampleTest")]
         public void Example11()
         {
             var program = PushGPInterpreter.Encode("( 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.Interpret(program);
+            interpreter.IntegerStack.Push(1, 1);
+            interpreter.FloatStack.Push(2.1, 0.7);
+
+            interpreter.Interpret(program);
 
             Assert.IsTrue(interpreter.IntegerStack.IsEmpty);
@@ -163,8 +185,8 @@
             Assert.IsTrue(interpreter.BooleanStack.IsEmpty);
 
-            this.interpreter.Clear();
-            this.interpreter.IntegerStack.Push(1, 2);
-            this.interpreter.FloatStack.Push(2.1, 0.7);
-            this.interpreter.Interpret(program);
+            interpreter.Clear();
+            interpreter.IntegerStack.Push(1, 2);
+            interpreter.FloatStack.Push(2.1, 0.7);
+            interpreter.Interpret(program);
 
             Assert.IsTrue(interpreter.IntegerStack.IsEmpty);
@@ -177,12 +199,14 @@
 
         [TestMethod]
+        [TestProperty("Time", "Short")]
+        [TestCategory("ExampleTest")]
         public void Example12()
         {
             var program = PushGPInterpreter.Encode("( INTEGER.= EXEC.IF FLOAT.* FLOAT./ )");
 
-            this.interpreter.IntegerStack.Push(1, 1);
-            this.interpreter.FloatStack.Push(2.1, 0.7);
-
-            this.interpreter.Interpret(program);
+            interpreter.IntegerStack.Push(1, 1);
+            interpreter.FloatStack.Push(2.1, 0.7);
+
+            interpreter.Interpret(program);
 
             Assert.IsTrue(interpreter.IntegerStack.IsEmpty);
@@ -193,8 +217,8 @@
             Assert.IsTrue(interpreter.BooleanStack.IsEmpty);
 
-            this.interpreter.Clear();
-            this.interpreter.IntegerStack.Push(1, 2);
-            this.interpreter.FloatStack.Push(2.1, 0.7);
-            this.interpreter.Interpret(program);
+            interpreter.Clear();
+            interpreter.IntegerStack.Push(1, 2);
+            interpreter.FloatStack.Push(2.1, 0.7);
+            interpreter.Interpret(program);
 
             Assert.IsTrue(interpreter.IntegerStack.IsEmpty);
@@ -207,22 +231,26 @@
 
         [TestMethod]
+        [TestProperty("Time", "Short")]
+        [TestCategory("ExampleTest")]
         public void Example13()
         {
-            this.interpreter.IntegerStack.Push(5);
-            this.interpreter.Interpret("( 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);
-        }
-
-        [TestMethod]
+            interpreter.IntegerStack.Push(5);
+            interpreter.Interpret("( 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);
+        }
+
+        [TestMethod]
+        [TestProperty("Time", "Short")]
+        [TestCategory("ExampleTest")]
         public void Example14()
         {
-            this.interpreter.IntegerStack.Push(5);
-            this.interpreter.Interpret("( EXEC.Y ( ( 2 INTEGER.* INTEGER.DUP 1000 INTEGER.< ) EXEC.IF ( ) EXEC.POP ) )");
+            interpreter.IntegerStack.Push(5);
+            interpreter.Interpret("( EXEC.Y ( ( 2 INTEGER.* INTEGER.DUP 1000 INTEGER.< ) EXEC.IF ( ) EXEC.POP ) )");
 
             Assert.AreEqual(1280, interpreter.IntegerStack.Top);
@@ -235,9 +263,11 @@
 
         [TestMethod]
+        [TestProperty("Time", "Short")]
+        [TestCategory("ExampleTest")]
         public void Example15()
         {
-            this.interpreter.IntegerStack.Push(10);
-            this.interpreter.FloatStack.Push(2);
-            this.interpreter.Interpret(@"( ARG FLOAT.DEFINE
+            interpreter.IntegerStack.Push(10);
+            interpreter.FloatStack.Push(2);
+            interpreter.Interpret(@"( ARG FLOAT.DEFINE
                                            EXEC.Y (
                                            ARG FLOAT.*
Index: branches/PushGP/HeuristicLab.Algorithms.PushGP/HeuristicLab.Tests/Interpreter/Expressions/ExecExpressionTests.cs
===================================================================
--- branches/PushGP/HeuristicLab.Algorithms.PushGP/HeuristicLab.Tests/Interpreter/Expressions/ExecExpressionTests.cs	(revision 14397)
+++ branches/PushGP/HeuristicLab.Algorithms.PushGP/HeuristicLab.Tests/Interpreter/Expressions/ExecExpressionTests.cs	(revision 14398)
@@ -15,8 +15,11 @@
         protected override void Test(Expression expression)
         {
-            this.interpreter.InterpretAsync(expression, true).Wait();
+            interpreter.InterpretAsync(expression, true).Wait();
         }
 
         [TestMethod]
+        [TestProperty("Time", "Short")]
+        [TestCategory("ExpressionTest")]
+        [TestCategory("ExecExpressionTest")]
         public void TestIfTrue()
         {
@@ -25,8 +28,11 @@
 
             Assert.AreEqual("WAHR", interpreter.NameStack.Top);
-            this.TestStackCounts(nameStack: 1);
+            TestStackCounts(nameStack: 1);
         }
 
         [TestMethod]
+        [TestProperty("Time", "Short")]
+        [TestCategory("ExpressionTest")]
+        [TestCategory("ExecExpressionTest")]
         public void TestIfFalse()
         {
@@ -35,8 +41,11 @@
 
             Assert.AreEqual("FALSCH", interpreter.NameStack.Top);
-            this.TestStackCounts(nameStack: 1);
+            TestStackCounts(nameStack: 1);
         }
 
         [TestMethod]
+        [TestProperty("Time", "Short")]
+        [TestCategory("ExpressionTest")]
+        [TestCategory("ExecExpressionTest")]
         public void TestK()
         {
@@ -46,12 +55,15 @@
 
             interpreter.ExecStack.Push(third, second, first);
-            this.Test(new ExecKExpression());
+            Test(new ExecKExpression());
 
             Assert.AreEqual(first, interpreter.ExecStack.Top);
             Assert.AreEqual(third, interpreter.ExecStack.Bottom);
-            this.TestStackCounts(execStack: 2);
+            TestStackCounts(execStack: 2);
         }
 
         [TestMethod]
+        [TestProperty("Time", "Short")]
+        [TestCategory("ExpressionTest")]
+        [TestCategory("ExecExpressionTest")]
         public void TestS()
         {
@@ -62,13 +74,16 @@
 
             interpreter.ExecStack.Push(third, second, first);
-            this.Test(new ExecSExpression());
+            Test(new ExecSExpression());
 
             Assert.AreEqual(result, interpreter.ExecStack.ReverseElementAt(2));
             Assert.AreEqual(third, interpreter.ExecStack.ReverseElementAt(1));
             Assert.AreEqual(first, interpreter.ExecStack.Top);
-            this.TestStackCounts(execStack: 3);
+            TestStackCounts(execStack: 3);
         }
 
         [TestMethod]
+        [TestProperty("Time", "Short")]
+        [TestCategory("ExpressionTest")]
+        [TestCategory("ExecExpressionTest")]
         public void TestY()
         {
@@ -77,12 +92,15 @@
 
             interpreter.ExecStack.Push(first);
-            this.Test(new ExecYExpression());
+            Test(new ExecYExpression());
 
             Assert.AreEqual(first, interpreter.ExecStack.Top);
             Assert.AreEqual(result, interpreter.ExecStack.ReverseElementAt(1));
-            this.TestStackCounts(execStack: 2);
+            TestStackCounts(execStack: 2);
         }
 
         [TestMethod]
+        [TestProperty("Time", "Short")]
+        [TestCategory("ExpressionTest")]
+        [TestCategory("ExecExpressionTest")]
         public void TestNestedDoRange()
         {
@@ -90,8 +108,11 @@
 
             Assert.AreEqual(144, interpreter.IntegerStack.Top);
-            this.TestStackCounts(integerStack: 1);
+            TestStackCounts(integerStack: 1);
         }
 
         [TestMethod]
+        [TestProperty("Time", "Short")]
+        [TestCategory("ExpressionTest")]
+        [TestCategory("ExecExpressionTest")]
         public void TestNestedDoCount()
         {
@@ -99,8 +120,11 @@
 
             Assert.AreEqual(144, interpreter.IntegerStack.Top);
-            this.TestStackCounts(integerStack: 1);
+            TestStackCounts(integerStack: 1);
         }
 
         [TestMethod]
+        [TestProperty("Time", "Short")]
+        [TestCategory("ExpressionTest")]
+        [TestCategory("ExecExpressionTest")]
         public void TestNestedDoTimes()
         {
@@ -108,5 +132,5 @@
 
             Assert.AreEqual(128, interpreter.IntegerStack.Top);
-            this.TestStackCounts(integerStack: 1);
+            TestStackCounts(integerStack: 1);
         }
 
@@ -134,5 +158,5 @@
         protected override void CheckOtherStacksAreEmpty()
         {
-            this.TestStackCounts(execStack: null);
+            TestStackCounts(execStack: null);
         }
     }
Index: branches/PushGP/HeuristicLab.Algorithms.PushGP/HeuristicLab.Tests/Interpreter/Expressions/FloatExpressionTests.cs
===================================================================
--- branches/PushGP/HeuristicLab.Algorithms.PushGP/HeuristicLab.Tests/Interpreter/Expressions/FloatExpressionTests.cs	(revision 14397)
+++ branches/PushGP/HeuristicLab.Algorithms.PushGP/HeuristicLab.Tests/Interpreter/Expressions/FloatExpressionTests.cs	(revision 14398)
@@ -14,4 +14,7 @@
 
         [TestMethod]
+        [TestProperty("Time", "Short")]
+        [TestCategory("ExpressionTest")]
+        [TestCategory("FloatExpressionTest")]
         public void TestAdd()
         {
@@ -21,14 +24,20 @@
             Assert.AreEqual(10.6, interpreter.FloatStack.Top, delta);
 
-            this.TestStackCounts(floatStack: 1);
-        }
-
-        [TestMethod]
+            TestStackCounts(floatStack: 1);
+        }
+
+        [TestMethod]
+        [TestProperty("Time", "Short")]
+        [TestCategory("ExpressionTest")]
+        [TestCategory("FloatExpressionTest")]
         public void TestAddWithInsufficientArguments()
         {
-            this.TestWithInsufficientArguments("+", 1);
-        }
-
-        [TestMethod]
+            TestWithInsufficientArguments("+", 1);
+        }
+
+        [TestMethod]
+        [TestProperty("Time", "Short")]
+        [TestCategory("ExpressionTest")]
+        [TestCategory("FloatExpressionTest")]
         public void TestSubtract()
         {
@@ -38,14 +47,20 @@
             Assert.AreEqual(4.9, interpreter.FloatStack.Top, delta);
 
-            this.TestStackCounts(floatStack: 1);
-        }
-
-        [TestMethod]
+            TestStackCounts(floatStack: 1);
+        }
+
+        [TestMethod]
+        [TestProperty("Time", "Short")]
+        [TestCategory("ExpressionTest")]
+        [TestCategory("FloatExpressionTest")]
         public void TestSubractWithInsufficientArguments()
         {
-            this.TestWithInsufficientArguments("-", 1);
-        }
-
-        [TestMethod]
+            TestWithInsufficientArguments("-", 1);
+        }
+
+        [TestMethod]
+        [TestProperty("Time", "Short")]
+        [TestCategory("ExpressionTest")]
+        [TestCategory("FloatExpressionTest")]
         public void TestMultiply()
         {
@@ -55,14 +70,20 @@
             Assert.AreEqual(32.67, interpreter.FloatStack.Top, delta);
 
-            this.TestStackCounts(floatStack: 1);
-        }
-
-        [TestMethod]
+            TestStackCounts(floatStack: 1);
+        }
+
+        [TestMethod]
+        [TestProperty("Time", "Short")]
+        [TestCategory("ExpressionTest")]
+        [TestCategory("FloatExpressionTest")]
         public void TestMultiplyWithInsufficientArguments()
         {
-            this.TestWithInsufficientArguments("*", 1);
-        }
-
-        [TestMethod]
+            TestWithInsufficientArguments("*", 1);
+        }
+
+        [TestMethod]
+        [TestProperty("Time", "Short")]
+        [TestCategory("ExpressionTest")]
+        [TestCategory("FloatExpressionTest")]
         public void TestDivide()
         {
@@ -72,14 +93,20 @@
             Assert.AreEqual(3.0, interpreter.FloatStack.Top, delta);
 
-            this.TestStackCounts(floatStack: 1);
-        }
-
-        [TestMethod]
+            TestStackCounts(floatStack: 1);
+        }
+
+        [TestMethod]
+        [TestProperty("Time", "Short")]
+        [TestCategory("ExpressionTest")]
+        [TestCategory("FloatExpressionTest")]
         public void TestDivideWithInsufficientArguments()
         {
-            this.TestWithInsufficientArguments("/", 1);
-        }
-
-        [TestMethod]
+            TestWithInsufficientArguments("/", 1);
+        }
+
+        [TestMethod]
+        [TestProperty("Time", "Short")]
+        [TestCategory("ExpressionTest")]
+        [TestCategory("FloatExpressionTest")]
         public void TestModulo()
         {
@@ -89,14 +116,20 @@
             Assert.AreEqual(1, interpreter.FloatStack.Top, delta);
 
-            this.TestStackCounts(floatStack: 1);
-        }
-
-        [TestMethod]
+            TestStackCounts(floatStack: 1);
+        }
+
+        [TestMethod]
+        [TestProperty("Time", "Short")]
+        [TestCategory("ExpressionTest")]
+        [TestCategory("FloatExpressionTest")]
         public void TestModuloWithInsufficientArguments()
         {
-            this.TestWithInsufficientArguments("%", 1);
-        }
-
-        [TestMethod]
+            TestWithInsufficientArguments("%", 1);
+        }
+
+        [TestMethod]
+        [TestProperty("Time", "Short")]
+        [TestCategory("ExpressionTest")]
+        [TestCategory("FloatExpressionTest")]
         public void TestMin()
         {
@@ -106,14 +139,20 @@
             Assert.AreEqual(5.3, interpreter.FloatStack.Top, delta);
 
-            this.TestStackCounts(floatStack: 1);
-        }
-
-        [TestMethod]
+            TestStackCounts(floatStack: 1);
+        }
+
+        [TestMethod]
+        [TestProperty("Time", "Short")]
+        [TestCategory("ExpressionTest")]
+        [TestCategory("FloatExpressionTest")]
         public void TestMinWithInsufficientArguments()
         {
-            this.TestWithInsufficientArguments("MIN", 1);
-        }
-
-        [TestMethod]
+            TestWithInsufficientArguments("MIN", 1);
+        }
+
+        [TestMethod]
+        [TestProperty("Time", "Short")]
+        [TestCategory("ExpressionTest")]
+        [TestCategory("FloatExpressionTest")]
         public void TestMax()
         {
@@ -123,14 +162,20 @@
             Assert.AreEqual(10.3, interpreter.FloatStack.Top, delta);
 
-            this.TestStackCounts(floatStack: 1);
-        }
-
-        [TestMethod]
+            TestStackCounts(floatStack: 1);
+        }
+
+        [TestMethod]
+        [TestProperty("Time", "Short")]
+        [TestCategory("ExpressionTest")]
+        [TestCategory("FloatExpressionTest")]
         public void TestMaxWithInsufficientArguments()
         {
-            this.TestWithInsufficientArguments("MAX", 1);
-        }
-
-        [TestMethod]
+            TestWithInsufficientArguments("MAX", 1);
+        }
+
+        [TestMethod]
+        [TestProperty("Time", "Short")]
+        [TestCategory("ExpressionTest")]
+        [TestCategory("FloatExpressionTest")]
         public void TestSmallerThan()
         {
@@ -140,14 +185,20 @@
             Assert.AreEqual(false, interpreter.BooleanStack.Top);
 
-            this.TestStackCounts(booleanStack: 1);
-        }
-
-        [TestMethod]
+            TestStackCounts(booleanStack: 1);
+        }
+
+        [TestMethod]
+        [TestProperty("Time", "Short")]
+        [TestCategory("ExpressionTest")]
+        [TestCategory("FloatExpressionTest")]
         public void TestSmallerThanWithInsufficientArguments()
         {
-            this.TestWithInsufficientArguments("<", 1);
-        }
-
-        [TestMethod]
+            TestWithInsufficientArguments("<", 1);
+        }
+
+        [TestMethod]
+        [TestProperty("Time", "Short")]
+        [TestCategory("ExpressionTest")]
+        [TestCategory("FloatExpressionTest")]
         public void TestGreaterThan()
         {
@@ -157,14 +208,20 @@
             Assert.AreEqual(true, interpreter.BooleanStack.Top);
 
-            this.TestStackCounts(booleanStack: 1);
-        }
-
-        [TestMethod]
+            TestStackCounts(booleanStack: 1);
+        }
+
+        [TestMethod]
+        [TestProperty("Time", "Short")]
+        [TestCategory("ExpressionTest")]
+        [TestCategory("FloatExpressionTest")]
         public void TestGreaterThanWithInsufficientArguments()
         {
-            this.TestWithInsufficientArguments(">", 1);
-        }
-
-        [TestMethod]
+            TestWithInsufficientArguments(">", 1);
+        }
+
+        [TestMethod]
+        [TestProperty("Time", "Short")]
+        [TestCategory("ExpressionTest")]
+        [TestCategory("FloatExpressionTest")]
         public void TestFromBooleanTrue()
         {
@@ -174,8 +231,11 @@
             Assert.AreEqual(1d, interpreter.FloatStack.Top, delta);
 
-            this.TestStackCounts(floatStack: 1);
-        }
-
-        [TestMethod]
+            TestStackCounts(floatStack: 1);
+        }
+
+        [TestMethod]
+        [TestProperty("Time", "Short")]
+        [TestCategory("ExpressionTest")]
+        [TestCategory("FloatExpressionTest")]
         public void TestFromBooleanFalse()
         {
@@ -185,14 +245,20 @@
             Assert.AreEqual(0d, interpreter.FloatStack.Top, delta);
 
-            this.TestStackCounts(floatStack: 1);
-        }
-
-        [TestMethod]
+            TestStackCounts(floatStack: 1);
+        }
+
+        [TestMethod]
+        [TestProperty("Time", "Short")]
+        [TestCategory("ExpressionTest")]
+        [TestCategory("FloatExpressionTest")]
         public void TestFromBooleanWithInsufficientArguments()
         {
-            this.TestWithInsufficientArguments("FROMBOOLEAN");
-        }
-
-        [TestMethod]
+            TestWithInsufficientArguments("FROMBOOLEAN");
+        }
+
+        [TestMethod]
+        [TestProperty("Time", "Short")]
+        [TestCategory("ExpressionTest")]
+        [TestCategory("FloatExpressionTest")]
         public void TestFromInteger()
         {
@@ -202,14 +268,20 @@
             Assert.AreEqual(5d, interpreter.FloatStack.Top, delta);
 
-            this.TestStackCounts(floatStack: 1);
-        }
-
-        [TestMethod]
+            TestStackCounts(floatStack: 1);
+        }
+
+        [TestMethod]
+        [TestProperty("Time", "Short")]
+        [TestCategory("ExpressionTest")]
+        [TestCategory("FloatExpressionTest")]
         public void TestFromIntegerWithInsufficientArguments()
         {
-            this.TestWithInsufficientArguments("FROMINTEGER");
-        }
-
-        [TestMethod]
+            TestWithInsufficientArguments("FROMINTEGER");
+        }
+
+        [TestMethod]
+        [TestProperty("Time", "Short")]
+        [TestCategory("ExpressionTest")]
+        [TestCategory("FloatExpressionTest")]
         public void TestSine()
         {
@@ -219,14 +291,20 @@
             Assert.AreEqual(1, interpreter.FloatStack.Top, delta);
 
-            this.TestStackCounts(floatStack: 1);
-        }
-
-        [TestMethod]
+            TestStackCounts(floatStack: 1);
+        }
+
+        [TestMethod]
+        [TestProperty("Time", "Short")]
+        [TestCategory("ExpressionTest")]
+        [TestCategory("FloatExpressionTest")]
         public void TestSineWithInsufficientArguments()
         {
-            this.TestWithInsufficientArguments("SIN");
-        }
-
-        [TestMethod]
+            TestWithInsufficientArguments("SIN");
+        }
+
+        [TestMethod]
+        [TestProperty("Time", "Short")]
+        [TestCategory("ExpressionTest")]
+        [TestCategory("FloatExpressionTest")]
         public void TestCosine()
         {
@@ -236,11 +314,14 @@
             Assert.AreEqual(-1, interpreter.FloatStack.Top, delta);
 
-            this.TestStackCounts(floatStack: 1);
-        }
-
-        [TestMethod]
+            TestStackCounts(floatStack: 1);
+        }
+
+        [TestMethod]
+        [TestProperty("Time", "Short")]
+        [TestCategory("ExpressionTest")]
+        [TestCategory("FloatExpressionTest")]
         public void TestCosineWithInsufficientArguments()
         {
-            this.TestWithInsufficientArguments("COS");
+            TestWithInsufficientArguments("COS");
         }
 
@@ -259,5 +340,5 @@
         protected override void CheckOtherStacksAreEmpty()
         {
-            this.TestStackCounts(floatStack: null);
+            TestStackCounts(floatStack: null);
         }
     }
Index: branches/PushGP/HeuristicLab.Algorithms.PushGP/HeuristicLab.Tests/Interpreter/Expressions/IntegerExpressionTests.cs
===================================================================
--- branches/PushGP/HeuristicLab.Algorithms.PushGP/HeuristicLab.Tests/Interpreter/Expressions/IntegerExpressionTests.cs	(revision 14397)
+++ branches/PushGP/HeuristicLab.Algorithms.PushGP/HeuristicLab.Tests/Interpreter/Expressions/IntegerExpressionTests.cs	(revision 14398)
@@ -12,4 +12,7 @@
 
         [TestMethod]
+        [TestProperty("Time", "Short")]
+        [TestCategory("ExpressionTest")]
+        [TestCategory("IntegerExpressionTest")]
         public void TestAdd()
         {
@@ -19,14 +22,20 @@
             Assert.AreEqual(10, interpreter.IntegerStack.Top);
 
-            this.TestStackCounts(integerStack: 1);
-        }
-
-        [TestMethod]
+            TestStackCounts(integerStack: 1);
+        }
+
+        [TestMethod]
+        [TestProperty("Time", "Short")]
+        [TestCategory("ExpressionTest")]
+        [TestCategory("IntegerExpressionTest")]
         public void TestAddWithInsufficientArguments()
         {
-            this.TestWithInsufficientArguments("+", 1);
-        }
-
-        [TestMethod]
+            TestWithInsufficientArguments("+", 1);
+        }
+
+        [TestMethod]
+        [TestProperty("Time", "Short")]
+        [TestCategory("ExpressionTest")]
+        [TestCategory("IntegerExpressionTest")]
         public void TestSubtract()
         {
@@ -36,14 +45,20 @@
             Assert.AreEqual(5, interpreter.IntegerStack.Top);
 
-            this.TestStackCounts(integerStack: 1);
-        }
-
-        [TestMethod]
+            TestStackCounts(integerStack: 1);
+        }
+
+        [TestMethod]
+        [TestProperty("Time", "Short")]
+        [TestCategory("ExpressionTest")]
+        [TestCategory("IntegerExpressionTest")]
         public void TestSubtractWithInsufficientArguments()
         {
-            this.TestWithInsufficientArguments("-", 1);
-        }
-
-        [TestMethod]
+            TestWithInsufficientArguments("-", 1);
+        }
+
+        [TestMethod]
+        [TestProperty("Time", "Short")]
+        [TestCategory("ExpressionTest")]
+        [TestCategory("IntegerExpressionTest")]
         public void TestMultiply()
         {
@@ -53,14 +68,20 @@
             Assert.AreEqual(50, interpreter.IntegerStack.Top);
 
-            this.TestStackCounts(integerStack: 1);
-        }
-
-        [TestMethod]
+            TestStackCounts(integerStack: 1);
+        }
+
+        [TestMethod]
+        [TestProperty("Time", "Short")]
+        [TestCategory("ExpressionTest")]
+        [TestCategory("IntegerExpressionTest")]
         public void TestMultiplyWithInsufficientArguments()
         {
-            this.TestWithInsufficientArguments("*", 1);
-        }
-
-        [TestMethod]
+            TestWithInsufficientArguments("*", 1);
+        }
+
+        [TestMethod]
+        [TestProperty("Time", "Short")]
+        [TestCategory("ExpressionTest")]
+        [TestCategory("IntegerExpressionTest")]
         public void TestDivide()
         {
@@ -70,14 +91,20 @@
             Assert.AreEqual(2, interpreter.IntegerStack.Top);
 
-            this.TestStackCounts(integerStack: 1);
-        }
-
-        [TestMethod]
+            TestStackCounts(integerStack: 1);
+        }
+
+        [TestMethod]
+        [TestProperty("Time", "Short")]
+        [TestCategory("ExpressionTest")]
+        [TestCategory("IntegerExpressionTest")]
         public void TestDivideWithInsufficientArguments()
         {
-            this.TestWithInsufficientArguments("/", 1);
-        }
-
-        [TestMethod]
+            TestWithInsufficientArguments("/", 1);
+        }
+
+        [TestMethod]
+        [TestProperty("Time", "Short")]
+        [TestCategory("ExpressionTest")]
+        [TestCategory("IntegerExpressionTest")]
         public void TestModulo()
         {
@@ -87,14 +114,20 @@
             Assert.AreEqual(0, interpreter.IntegerStack.Top);
 
-            this.TestStackCounts(integerStack: 1);
-        }
-
-        [TestMethod]
+            TestStackCounts(integerStack: 1);
+        }
+
+        [TestMethod]
+        [TestProperty("Time", "Short")]
+        [TestCategory("ExpressionTest")]
+        [TestCategory("IntegerExpressionTest")]
         public void TestModuloWithInsufficientArguments()
         {
-            this.TestWithInsufficientArguments("%", 1);
-        }
-
-        [TestMethod]
+            TestWithInsufficientArguments("%", 1);
+        }
+
+        [TestMethod]
+        [TestProperty("Time", "Short")]
+        [TestCategory("ExpressionTest")]
+        [TestCategory("IntegerExpressionTest")]
         public void TestMin()
         {
@@ -104,14 +137,20 @@
             Assert.AreEqual(5, interpreter.IntegerStack.Top);
 
-            this.TestStackCounts(integerStack: 1);
-        }
-
-        [TestMethod]
+            TestStackCounts(integerStack: 1);
+        }
+
+        [TestMethod]
+        [TestProperty("Time", "Short")]
+        [TestCategory("ExpressionTest")]
+        [TestCategory("IntegerExpressionTest")]
         public void TestMinWithInsufficientArguments()
         {
-            this.TestWithInsufficientArguments("MIN", 1);
-        }
-
-        [TestMethod]
+            TestWithInsufficientArguments("MIN", 1);
+        }
+
+        [TestMethod]
+        [TestProperty("Time", "Short")]
+        [TestCategory("ExpressionTest")]
+        [TestCategory("IntegerExpressionTest")]
         public void TestMax()
         {
@@ -121,14 +160,20 @@
             Assert.AreEqual(10, interpreter.IntegerStack.Top);
 
-            this.TestStackCounts(integerStack: 1);
-        }
-
-        [TestMethod]
+            TestStackCounts(integerStack: 1);
+        }
+
+        [TestMethod]
+        [TestProperty("Time", "Short")]
+        [TestCategory("ExpressionTest")]
+        [TestCategory("IntegerExpressionTest")]
         public void TestMaxWithInsufficientArguments()
         {
-            this.TestWithInsufficientArguments("MAX", 1);
-        }
-
-        [TestMethod]
+            TestWithInsufficientArguments("MAX", 1);
+        }
+
+        [TestMethod]
+        [TestProperty("Time", "Short")]
+        [TestCategory("ExpressionTest")]
+        [TestCategory("IntegerExpressionTest")]
         public void TestSmallerThan()
         {
@@ -138,14 +183,20 @@
             Assert.AreEqual(false, interpreter.BooleanStack.Top);
 
-            this.TestStackCounts(booleanStack: 1);
-        }
-
-        [TestMethod]
+            TestStackCounts(booleanStack: 1);
+        }
+
+        [TestMethod]
+        [TestProperty("Time", "Short")]
+        [TestCategory("ExpressionTest")]
+        [TestCategory("IntegerExpressionTest")]
         public void TestSmallerThanWithInsufficientArguments()
         {
-            this.TestWithInsufficientArguments("<", 1);
-        }
-
-        [TestMethod]
+            TestWithInsufficientArguments("<", 1);
+        }
+
+        [TestMethod]
+        [TestProperty("Time", "Short")]
+        [TestCategory("ExpressionTest")]
+        [TestCategory("IntegerExpressionTest")]
         public void TestGreaterThan()
         {
@@ -155,14 +206,20 @@
             Assert.AreEqual(true, interpreter.BooleanStack.Top);
 
-            this.TestStackCounts(booleanStack: 1);
-        }
-
-        [TestMethod]
+            TestStackCounts(booleanStack: 1);
+        }
+
+        [TestMethod]
+        [TestProperty("Time", "Short")]
+        [TestCategory("ExpressionTest")]
+        [TestCategory("IntegerExpressionTest")]
         public void TestGreaterThanWithInsufficientArguments()
         {
-            this.TestWithInsufficientArguments(">", 1);
-        }
-
-        [TestMethod]
+            TestWithInsufficientArguments(">", 1);
+        }
+
+        [TestMethod]
+        [TestProperty("Time", "Short")]
+        [TestCategory("ExpressionTest")]
+        [TestCategory("IntegerExpressionTest")]
         public void TestFromBooleanTrue()
         {
@@ -172,14 +229,20 @@
             Assert.AreEqual(1, interpreter.IntegerStack.Top);
 
-            this.TestStackCounts(integerStack: 1);
-        }
-
-        [TestMethod]
+            TestStackCounts(integerStack: 1);
+        }
+
+        [TestMethod]
+        [TestProperty("Time", "Short")]
+        [TestCategory("ExpressionTest")]
+        [TestCategory("IntegerExpressionTest")]
         public void TestFromBooleanWithInsufficientArguments()
         {
-            this.TestWithInsufficientArguments("FROMBOOLEAN");
-        }
-
-        [TestMethod]
+            TestWithInsufficientArguments("FROMBOOLEAN");
+        }
+
+        [TestMethod]
+        [TestProperty("Time", "Short")]
+        [TestCategory("ExpressionTest")]
+        [TestCategory("IntegerExpressionTest")]
         public void TestFromBooleanFalse()
         {
@@ -189,8 +252,11 @@
             Assert.AreEqual(0, interpreter.IntegerStack.Top);
 
-            this.TestStackCounts(integerStack: 1);
-        }
-
-        [TestMethod]
+            TestStackCounts(integerStack: 1);
+        }
+
+        [TestMethod]
+        [TestProperty("Time", "Short")]
+        [TestCategory("ExpressionTest")]
+        [TestCategory("IntegerExpressionTest")]
         public void TestFromFloat()
         {
@@ -200,11 +266,14 @@
             Assert.AreEqual(1, interpreter.IntegerStack.Top);
 
-            this.TestStackCounts(integerStack: 1);
-        }
-
-        [TestMethod]
+            TestStackCounts(integerStack: 1);
+        }
+
+        [TestMethod]
+        [TestProperty("Time", "Short")]
+        [TestCategory("ExpressionTest")]
+        [TestCategory("IntegerExpressionTest")]
         public void TestFromFloatWithInsufficientArguments()
         {
-            this.TestWithInsufficientArguments("FROMFLOAT");
+            TestWithInsufficientArguments("FROMFLOAT");
         }
 
@@ -223,5 +292,5 @@
         protected override void CheckOtherStacksAreEmpty()
         {
-            this.TestStackCounts(integerStack: null);
+            TestStackCounts(integerStack: null);
         }
     }
Index: branches/PushGP/HeuristicLab.Algorithms.PushGP/HeuristicLab.Tests/Interpreter/Expressions/NameExpressionTests.cs
===================================================================
--- branches/PushGP/HeuristicLab.Algorithms.PushGP/HeuristicLab.Tests/Interpreter/Expressions/NameExpressionTests.cs	(revision 14397)
+++ branches/PushGP/HeuristicLab.Algorithms.PushGP/HeuristicLab.Tests/Interpreter/Expressions/NameExpressionTests.cs	(revision 14398)
@@ -14,4 +14,7 @@
 
         [TestMethod]
+        [TestProperty("Time", "Short")]
+        [TestCategory("ExpressionTest")]
+        [TestCategory("NameExpressionTest")]
         public void TestRand()
         {
@@ -20,8 +23,11 @@
             Assert.IsTrue(interpreter.NameStack.Count == 1);
 
-            this.CheckOtherStacksAreEmpty();
+            CheckOtherStacksAreEmpty();
         }
 
         [TestMethod]
+        [TestProperty("Time", "Short")]
+        [TestCategory("ExpressionTest")]
+        [TestCategory("NameExpressionTest")]
         public void TestRandomBound()
         {
@@ -34,14 +40,20 @@
             Assert.IsTrue(interpreter.CustomExpressions.Keys.Contains(interpreter.NameStack.Top));
 
-            this.CheckOtherStacksAreEmpty();
+            CheckOtherStacksAreEmpty();
         }
 
         [TestMethod]
+        [TestProperty("Time", "Short")]
+        [TestCategory("ExpressionTest")]
+        [TestCategory("NameExpressionTest")]
         public void TestRandomBoundWithInsufficientArguments()
         {
-            this.TestWithInsufficientArguments("RANDBOUNDNAME");
+            TestWithInsufficientArguments("RANDBOUNDNAME");
         }
 
         [TestMethod]
+        [TestProperty("Time", "Short")]
+        [TestCategory("ExpressionTest")]
+        [TestCategory("NameExpressionTest")]
         public void TestQuote()
         {
@@ -50,5 +62,5 @@
             Assert.IsTrue(interpreter.IsNameQuoteFlagSet);
 
-            this.TestStackCounts();
+            TestStackCounts();
         }
 
@@ -68,5 +80,5 @@
         protected override void CheckOtherStacksAreEmpty()
         {
-            this.TestStackCounts(nameStack: null);
+            TestStackCounts(nameStack: null);
         }
     }
Index: branches/PushGP/HeuristicLab.Algorithms.PushGP/HeuristicLab.Tests/Interpreter/InterpreterTest.cs
===================================================================
--- branches/PushGP/HeuristicLab.Algorithms.PushGP/HeuristicLab.Tests/Interpreter/InterpreterTest.cs	(revision 14397)
+++ branches/PushGP/HeuristicLab.Algorithms.PushGP/HeuristicLab.Tests/Interpreter/InterpreterTest.cs	(revision 14398)
@@ -4,5 +4,5 @@
 namespace HeuristicLab.Tests.Interpreter
 {
-    public class InterpreterTest
+    public class ExpressionTest
     {
         protected PushGPInterpreter interpreter;
