Index: branches/Robocode/HeuristicLab.Problems.Robocode/Symbols/Logical Expressions/Logical Comparators/Conjunction.cs
===================================================================
--- branches/Robocode/HeuristicLab.Problems.Robocode/Symbols/Logical Expressions/Logical Comparators/Conjunction.cs	(revision 9565)
+++ branches/Robocode/HeuristicLab.Problems.Robocode/Symbols/Logical Expressions/Logical Comparators/Conjunction.cs	(revision 9630)
@@ -3,43 +3,35 @@
 using HeuristicLab.Persistence.Default.CompositeSerializers.Storable;
 
-namespace HeuristicLab.Problems.Robocode
-{
-    [StorableClass]
-    public class Conjunction : CodeNode
-    {
-        public override int MinimumArity { get { return 0; } }
-        public override int MaximumArity { get { return 0; } }
+namespace HeuristicLab.Problems.Robocode {
+  [StorableClass]
+  public class Conjunction : CodeNode {
+    public override int MinimumArity { get { return 0; } }
+    public override int MaximumArity { get { return 0; } }
 
-        [Storable]
-        public override string Prefix { get; set; }
+    [Storable]
+    public override string Prefix { get; set; }
 
-        [Storable]
-        public override string Suffix { get; set; }
+    [Storable]
+    public override string Suffix { get; set; }
 
-        [StorableConstructor]
-        private Conjunction(bool deserializing) : base(deserializing) { }
-        private Conjunction(Conjunction original, Cloner cloner)
-            : base(original, cloner)
-        {
-            this.Prefix = "&&";
-            this.Suffix = "";
-        }
+    [StorableConstructor]
+    private Conjunction(bool deserializing) : base(deserializing) { }
+    private Conjunction(Conjunction original, Cloner cloner)
+      : base(original, cloner) {
+    }
 
-        public Conjunction()
-            : base("Conjunction", "Conjunction comparator.")
-        {
-            this.Prefix = "&&";
-            this.Suffix = "";
-        }
+    public Conjunction()
+      : base("Conjunction", "Conjunction comparator.") {
+      this.Prefix = "&&";
+      this.Suffix = "";
+    }
 
-        public override IDeepCloneable Clone(Cloner cloner)
-        {
-            return new Conjunction(this, cloner);
-        }
+    public override IDeepCloneable Clone(Cloner cloner) {
+      return new Conjunction(this, cloner);
+    }
 
-        public override string Interpret(ISymbolicExpressionTreeNode node, System.Collections.Generic.IEnumerable<ISymbolicExpressionTreeNode> children)
-        {
-            return this.Prefix + " " + this.Suffix;
-        }
+    public override string Interpret(ISymbolicExpressionTreeNode node, System.Collections.Generic.IEnumerable<ISymbolicExpressionTreeNode> children) {
+      return this.Prefix + " " + this.Suffix;
     }
+  }
 }
Index: branches/Robocode/HeuristicLab.Problems.Robocode/Symbols/Logical Expressions/Logical Comparators/Disjunction.cs
===================================================================
--- branches/Robocode/HeuristicLab.Problems.Robocode/Symbols/Logical Expressions/Logical Comparators/Disjunction.cs	(revision 9565)
+++ branches/Robocode/HeuristicLab.Problems.Robocode/Symbols/Logical Expressions/Logical Comparators/Disjunction.cs	(revision 9630)
@@ -3,43 +3,35 @@
 using HeuristicLab.Persistence.Default.CompositeSerializers.Storable;
 
-namespace HeuristicLab.Problems.Robocode
-{
-    [StorableClass]
-    public class Disjunction : CodeNode
-    {
-        public override int MinimumArity { get { return 0; } }
-        public override int MaximumArity { get { return 0; } }
+namespace HeuristicLab.Problems.Robocode {
+  [StorableClass]
+  public class Disjunction : CodeNode {
+    public override int MinimumArity { get { return 0; } }
+    public override int MaximumArity { get { return 0; } }
 
-        [Storable]
-        public override string Prefix { get; set; }
+    [Storable]
+    public override string Prefix { get; set; }
 
-        [Storable]
-        public override string Suffix { get; set; }
+    [Storable]
+    public override string Suffix { get; set; }
 
-        [StorableConstructor]
-        private Disjunction(bool deserializing) : base(deserializing) { }
-        private Disjunction(Disjunction original, Cloner cloner)
-            : base(original, cloner)
-        {
-            this.Prefix = "||";
-            this.Suffix = "";
-        }
+    [StorableConstructor]
+    private Disjunction(bool deserializing) : base(deserializing) { }
+    private Disjunction(Disjunction original, Cloner cloner)
+      : base(original, cloner) {
+    }
 
-        public Disjunction()
-            : base("Disjunction", "Disjunction comparator.")
-        {
-            this.Prefix = "||";
-            this.Suffix = "";
-        }
+    public Disjunction()
+      : base("Disjunction", "Disjunction comparator.") {
+      this.Prefix = "||";
+      this.Suffix = "";
+    }
 
-        public override IDeepCloneable Clone(Cloner cloner)
-        {
-            return new Disjunction(this, cloner);
-        }
+    public override IDeepCloneable Clone(Cloner cloner) {
+      return new Disjunction(this, cloner);
+    }
 
-        public override string Interpret(ISymbolicExpressionTreeNode node, System.Collections.Generic.IEnumerable<ISymbolicExpressionTreeNode> children)
-        {
-            return this.Prefix + " " + this.Suffix;
-        }
+    public override string Interpret(ISymbolicExpressionTreeNode node, System.Collections.Generic.IEnumerable<ISymbolicExpressionTreeNode> children) {
+      return this.Prefix + " " + this.Suffix;
     }
+  }
 }
Index: branches/Robocode/HeuristicLab.Problems.Robocode/Symbols/Logical Expressions/Logical Comparators/Equal.cs
===================================================================
--- branches/Robocode/HeuristicLab.Problems.Robocode/Symbols/Logical Expressions/Logical Comparators/Equal.cs	(revision 9565)
+++ branches/Robocode/HeuristicLab.Problems.Robocode/Symbols/Logical Expressions/Logical Comparators/Equal.cs	(revision 9630)
@@ -3,43 +3,35 @@
 using HeuristicLab.Persistence.Default.CompositeSerializers.Storable;
 
-namespace HeuristicLab.Problems.Robocode
-{
-    [StorableClass]
-    public class Equal : CodeNode
-    {
-        public override int MinimumArity { get { return 0; } }
-        public override int MaximumArity { get { return 0; } }
+namespace HeuristicLab.Problems.Robocode {
+  [StorableClass]
+  public class Equal : CodeNode {
+    public override int MinimumArity { get { return 0; } }
+    public override int MaximumArity { get { return 0; } }
 
-        [Storable]
-        public override string Prefix { get; set; }
+    [Storable]
+    public override string Prefix { get; set; }
 
-        [Storable]
-        public override string Suffix { get; set; }
+    [Storable]
+    public override string Suffix { get; set; }
 
-        [StorableConstructor]
-        private Equal(bool deserializing) : base(deserializing) { }
-        private Equal(Equal original, Cloner cloner)
-            : base(original, cloner)
-        {
-            this.Prefix = "==";
-            this.Suffix = "";
-        }
+    [StorableConstructor]
+    private Equal(bool deserializing) : base(deserializing) { }
+    private Equal(Equal original, Cloner cloner)
+      : base(original, cloner) {
+    }
 
-        public Equal()
-            : base("Equal", "Equal comparator.")
-        {
-            this.Prefix = "==";
-            this.Suffix = "";
-        }
+    public Equal()
+      : base("Equal", "Equal comparator.") {
+      this.Prefix = "==";
+      this.Suffix = "";
+    }
 
-        public override IDeepCloneable Clone(Cloner cloner)
-        {
-            return new Equal(this, cloner);
-        }
+    public override IDeepCloneable Clone(Cloner cloner) {
+      return new Equal(this, cloner);
+    }
 
-        public override string Interpret(ISymbolicExpressionTreeNode node, System.Collections.Generic.IEnumerable<ISymbolicExpressionTreeNode> children)
-        {
-            return this.Prefix + " " + this.Suffix;
-        }
+    public override string Interpret(ISymbolicExpressionTreeNode node, System.Collections.Generic.IEnumerable<ISymbolicExpressionTreeNode> children) {
+      return this.Prefix + " " + this.Suffix;
     }
+  }
 }
Index: branches/Robocode/HeuristicLab.Problems.Robocode/Symbols/Logical Expressions/Logical Comparators/GreaterThan.cs
===================================================================
--- branches/Robocode/HeuristicLab.Problems.Robocode/Symbols/Logical Expressions/Logical Comparators/GreaterThan.cs	(revision 9565)
+++ branches/Robocode/HeuristicLab.Problems.Robocode/Symbols/Logical Expressions/Logical Comparators/GreaterThan.cs	(revision 9630)
@@ -3,43 +3,35 @@
 using HeuristicLab.Persistence.Default.CompositeSerializers.Storable;
 
-namespace HeuristicLab.Problems.Robocode
-{
-    [StorableClass]
-    public class GreaterThan : CodeNode
-    {
-        public override int MinimumArity { get { return 0; } }
-        public override int MaximumArity { get { return 0; } }
+namespace HeuristicLab.Problems.Robocode {
+  [StorableClass]
+  public class GreaterThan : CodeNode {
+    public override int MinimumArity { get { return 0; } }
+    public override int MaximumArity { get { return 0; } }
 
-        [Storable]
-        public override string Prefix { get; set; }
+    [Storable]
+    public override string Prefix { get; set; }
 
-        [Storable]
-        public override string Suffix { get; set; }
+    [Storable]
+    public override string Suffix { get; set; }
 
-        [StorableConstructor]
-        private GreaterThan(bool deserializing) : base(deserializing) { }
-        private GreaterThan(GreaterThan original, Cloner cloner)
-            : base(original, cloner)
-        {
-            this.Prefix = ">";
-            this.Suffix = "";
-        }
+    [StorableConstructor]
+    private GreaterThan(bool deserializing) : base(deserializing) { }
+    private GreaterThan(GreaterThan original, Cloner cloner)
+      : base(original, cloner) {
+    }
 
-        public GreaterThan()
-            : base("GreaterThan", "GreaterThan comparator.")
-        {
-            this.Prefix = ">";
-            this.Suffix = "";
-        }
+    public GreaterThan()
+      : base("GreaterThan", "GreaterThan comparator.") {
+      this.Prefix = ">";
+      this.Suffix = "";
+    }
 
-        public override IDeepCloneable Clone(Cloner cloner)
-        {
-            return new GreaterThan(this, cloner);
-        }
+    public override IDeepCloneable Clone(Cloner cloner) {
+      return new GreaterThan(this, cloner);
+    }
 
-        public override string Interpret(ISymbolicExpressionTreeNode node, System.Collections.Generic.IEnumerable<ISymbolicExpressionTreeNode> children)
-        {
-            return this.Prefix + " " + this.Suffix;
-        }
+    public override string Interpret(ISymbolicExpressionTreeNode node, System.Collections.Generic.IEnumerable<ISymbolicExpressionTreeNode> children) {
+      return this.Prefix + " " + this.Suffix;
     }
+  }
 }
Index: branches/Robocode/HeuristicLab.Problems.Robocode/Symbols/Logical Expressions/Logical Comparators/GreaterThanOrEqual.cs
===================================================================
--- branches/Robocode/HeuristicLab.Problems.Robocode/Symbols/Logical Expressions/Logical Comparators/GreaterThanOrEqual.cs	(revision 9565)
+++ branches/Robocode/HeuristicLab.Problems.Robocode/Symbols/Logical Expressions/Logical Comparators/GreaterThanOrEqual.cs	(revision 9630)
@@ -3,43 +3,35 @@
 using HeuristicLab.Persistence.Default.CompositeSerializers.Storable;
 
-namespace HeuristicLab.Problems.Robocode
-{
-    [StorableClass]
-    public class GreaterThanOrEqual : CodeNode
-    {
-        public override int MinimumArity { get { return 0; } }
-        public override int MaximumArity { get { return 0; } }
+namespace HeuristicLab.Problems.Robocode {
+  [StorableClass]
+  public class GreaterThanOrEqual : CodeNode {
+    public override int MinimumArity { get { return 0; } }
+    public override int MaximumArity { get { return 0; } }
 
-        [Storable]
-        public override string Prefix { get; set; }
+    [Storable]
+    public override string Prefix { get; set; }
 
-        [Storable]
-        public override string Suffix { get; set; }
+    [Storable]
+    public override string Suffix { get; set; }
 
-        [StorableConstructor]
-        private GreaterThanOrEqual(bool deserializing) : base(deserializing) { }
-        private GreaterThanOrEqual(GreaterThanOrEqual original, Cloner cloner)
-            : base(original, cloner)
-        {
-            this.Prefix = ">=";
-            this.Suffix = "";
-        }
+    [StorableConstructor]
+    private GreaterThanOrEqual(bool deserializing) : base(deserializing) { }
+    private GreaterThanOrEqual(GreaterThanOrEqual original, Cloner cloner)
+      : base(original, cloner) {
+    }
 
-        public GreaterThanOrEqual()
-            : base("GreaterThanOrEqual", "GreaterThanOrEqual comparator.")
-        {
-            this.Prefix = ">=";
-            this.Suffix = "";
-        }
+    public GreaterThanOrEqual()
+      : base("GreaterThanOrEqual", "GreaterThanOrEqual comparator.") {
+      this.Prefix = ">=";
+      this.Suffix = "";
+    }
 
-        public override IDeepCloneable Clone(Cloner cloner)
-        {
-            return new GreaterThanOrEqual(this, cloner);
-        }
+    public override IDeepCloneable Clone(Cloner cloner) {
+      return new GreaterThanOrEqual(this, cloner);
+    }
 
-        public override string Interpret(ISymbolicExpressionTreeNode node, System.Collections.Generic.IEnumerable<ISymbolicExpressionTreeNode> children)
-        {
-            return this.Prefix + " " + this.Suffix;
-        }
+    public override string Interpret(ISymbolicExpressionTreeNode node, System.Collections.Generic.IEnumerable<ISymbolicExpressionTreeNode> children) {
+      return this.Prefix + " " + this.Suffix;
     }
+  }
 }
Index: branches/Robocode/HeuristicLab.Problems.Robocode/Symbols/Logical Expressions/Logical Comparators/LessThan.cs
===================================================================
--- branches/Robocode/HeuristicLab.Problems.Robocode/Symbols/Logical Expressions/Logical Comparators/LessThan.cs	(revision 9565)
+++ branches/Robocode/HeuristicLab.Problems.Robocode/Symbols/Logical Expressions/Logical Comparators/LessThan.cs	(revision 9630)
@@ -3,43 +3,36 @@
 using HeuristicLab.Persistence.Default.CompositeSerializers.Storable;
 
-namespace HeuristicLab.Problems.Robocode
-{
-    [StorableClass]
-    public class LessThan : CodeNode
-    {
-        public override int MinimumArity { get { return 0; } }
-        public override int MaximumArity { get { return 0; } }
+namespace HeuristicLab.Problems.Robocode {
+  [StorableClass]
+  public class LessThan : CodeNode {
+    public override int MinimumArity { get { return 0; } }
+    public override int MaximumArity { get { return 0; } }
 
-        [Storable]
-        public override string Prefix { get; set; }
+    [Storable]
+    public override string Prefix { get; set; }
 
-        [Storable]
-        public override string Suffix { get; set; }
+    [Storable]
+    public override string Suffix { get; set; }
 
-        [StorableConstructor]
-        private LessThan(bool deserializing) : base(deserializing) { }
-        private LessThan(LessThan original, Cloner cloner)
-            : base(original, cloner)
-        {
-            this.Prefix = "<";
-            this.Suffix = "";
-        }
+    [StorableConstructor]
+    private LessThan(bool deserializing) : base(deserializing) { }
+    private LessThan(LessThan original, Cloner cloner)
+      : base(original, cloner) {
 
-        public LessThan()
-            : base("LessThan", "LessThan comparator.")
-        {
-            this.Prefix = "<";
-            this.Suffix = "";
-        }
+    }
 
-        public override IDeepCloneable Clone(Cloner cloner)
-        {
-            return new LessThan(this, cloner);
-        }
+    public LessThan()
+      : base("LessThan", "LessThan comparator.") {
+      this.Prefix = "<";
+      this.Suffix = "";
+    }
 
-        public override string Interpret(ISymbolicExpressionTreeNode node, System.Collections.Generic.IEnumerable<ISymbolicExpressionTreeNode> children)
-        {
-            return this.Prefix + " " + this.Suffix;
-        }
+    public override IDeepCloneable Clone(Cloner cloner) {
+      return new LessThan(this, cloner);
     }
+
+    public override string Interpret(ISymbolicExpressionTreeNode node, System.Collections.Generic.IEnumerable<ISymbolicExpressionTreeNode> children) {
+      return this.Prefix + " " + this.Suffix;
+    }
+  }
 }
Index: branches/Robocode/HeuristicLab.Problems.Robocode/Symbols/Logical Expressions/Logical Comparators/LessThanOrEqual.cs
===================================================================
--- branches/Robocode/HeuristicLab.Problems.Robocode/Symbols/Logical Expressions/Logical Comparators/LessThanOrEqual.cs	(revision 9565)
+++ branches/Robocode/HeuristicLab.Problems.Robocode/Symbols/Logical Expressions/Logical Comparators/LessThanOrEqual.cs	(revision 9630)
@@ -3,43 +3,35 @@
 using HeuristicLab.Persistence.Default.CompositeSerializers.Storable;
 
-namespace HeuristicLab.Problems.Robocode
-{
-    [StorableClass]
-    public class LessThanOrEqual : CodeNode
-    {
-        public override int MinimumArity { get { return 0; } }
-        public override int MaximumArity { get { return 0; } }
+namespace HeuristicLab.Problems.Robocode {
+  [StorableClass]
+  public class LessThanOrEqual : CodeNode {
+    public override int MinimumArity { get { return 0; } }
+    public override int MaximumArity { get { return 0; } }
 
-        [Storable]
-        public override string Prefix { get; set; }
+    [Storable]
+    public override string Prefix { get; set; }
 
-        [Storable]
-        public override string Suffix { get; set; }
+    [Storable]
+    public override string Suffix { get; set; }
 
-        [StorableConstructor]
-        private LessThanOrEqual(bool deserializing) : base(deserializing) { }
-        private LessThanOrEqual(LessThanOrEqual original, Cloner cloner)
-            : base(original, cloner)
-        {
-            this.Prefix = "<=";
-            this.Suffix = "";
-        }
+    [StorableConstructor]
+    private LessThanOrEqual(bool deserializing) : base(deserializing) { }
+    private LessThanOrEqual(LessThanOrEqual original, Cloner cloner)
+      : base(original, cloner) {
+    }
 
-        public LessThanOrEqual()
-            : base("LessThanOrEqual", "LessThanOrEqual comparator.")
-        {
-            this.Prefix = "<=";
-            this.Suffix = "";
-        }
+    public LessThanOrEqual()
+      : base("LessThanOrEqual", "LessThanOrEqual comparator.") {
+      this.Prefix = "<=";
+      this.Suffix = "";
+    }
 
-        public override IDeepCloneable Clone(Cloner cloner)
-        {
-            return new LessThanOrEqual(this, cloner);
-        }
+    public override IDeepCloneable Clone(Cloner cloner) {
+      return new LessThanOrEqual(this, cloner);
+    }
 
-        public override string Interpret(ISymbolicExpressionTreeNode node, System.Collections.Generic.IEnumerable<ISymbolicExpressionTreeNode> children)
-        {
-            return this.Prefix + " " + this.Suffix;
-        }
+    public override string Interpret(ISymbolicExpressionTreeNode node, System.Collections.Generic.IEnumerable<ISymbolicExpressionTreeNode> children) {
+      return this.Prefix + " " + this.Suffix;
     }
+  }
 }
Index: branches/Robocode/HeuristicLab.Problems.Robocode/Symbols/Logical Expressions/LogicalComparison.cs
===================================================================
--- branches/Robocode/HeuristicLab.Problems.Robocode/Symbols/Logical Expressions/LogicalComparison.cs	(revision 9565)
+++ branches/Robocode/HeuristicLab.Problems.Robocode/Symbols/Logical Expressions/LogicalComparison.cs	(revision 9630)
@@ -3,65 +3,55 @@
 using HeuristicLab.Persistence.Default.CompositeSerializers.Storable;
 
-namespace HeuristicLab.Problems.Robocode
-{
-    [StorableClass]
-    public class LogicalComparison : CodeNode
-    {
-        public override int MinimumArity { get { return 3; } }
-        public override int MaximumArity { get { return 3; } }
+namespace HeuristicLab.Problems.Robocode {
+  [StorableClass]
+  public class LogicalComparison : CodeNode {
+    public override int MinimumArity { get { return 3; } }
+    public override int MaximumArity { get { return 3; } }
 
-        [Storable]
-        public override string Prefix { get; set; }
+    [Storable]
+    public override string Prefix { get; set; }
 
-        [Storable]
-        public override string Suffix { get; set; }
+    [Storable]
+    public override string Suffix { get; set; }
 
-        [StorableConstructor]
-        private LogicalComparison(bool deserializing) : base(deserializing) { }
-        private LogicalComparison(LogicalComparison original, Cloner cloner)
-            : base(original, cloner)
-        {
-            this.Prefix = "(";
-            this.Suffix = ")";
+    [StorableConstructor]
+    private LogicalComparison(bool deserializing) : base(deserializing) { }
+    private LogicalComparison(LogicalComparison original, Cloner cloner)
+      : base(original, cloner) {
+    }
+
+    public LogicalComparison()
+      : base("LogicalComparison", "A LogicalComparison.") {
+      this.Prefix = "(";
+      this.Suffix = ")";
+    }
+
+    public override IDeepCloneable Clone(Cloner cloner) {
+      return new LogicalComparison(this, cloner);
+    }
+
+    public override string Interpret(ISymbolicExpressionTreeNode node, System.Collections.Generic.IEnumerable<ISymbolicExpressionTreeNode> children) {
+      ISymbolicExpressionTreeNode condition = null, lhs = null, rhs = null;
+      var enumerator = children.GetEnumerator();
+      int childCount = 0;
+      while (enumerator.MoveNext()) {
+        childCount++;
+        switch (childCount) {
+          case 1: condition = enumerator.Current; break;
+          case 2: lhs = enumerator.Current; break;
+          case 3: rhs = enumerator.Current; break;
+          default: throw new System.Exception("Unexpected number of children. Expected 3 children.");
         }
+      }
+      if (childCount < 3) throw new System.Exception("Unexpected number of children. Expected 3 children.");
 
-        public LogicalComparison()
-            : base("LogicalComparison", "A LogicalComparison.")
-        {
-            this.Prefix = "(";
-            this.Suffix = ")";
-        }
+      if (!(condition.Symbol is Conjunction || condition.Symbol is Disjunction))
+        throw new System.Exception("Unexpected first child for LogicalComparison of type: " +
+            condition.GetType().ToString() + ". Expected " + typeof(Conjunction).ToString() +
+            " or " + typeof(Disjunction).ToString() + ".");
 
-        public override IDeepCloneable Clone(Cloner cloner)
-        {
-            return new LogicalComparison(this, cloner);
-        }
+      // TODO Check children 2 & 3 for correct types
 
-        public override string Interpret(ISymbolicExpressionTreeNode node, System.Collections.Generic.IEnumerable<ISymbolicExpressionTreeNode> children)
-        {
-            ISymbolicExpressionTreeNode condition = null, lhs = null, rhs = null;
-            var enumerator = children.GetEnumerator();
-            int childCount = 0;
-            while (enumerator.MoveNext())
-            {
-                childCount++;
-                switch (childCount)
-                {
-                    case 1: condition = enumerator.Current; break;
-                    case 2: lhs = enumerator.Current; break;
-                    case 3: rhs = enumerator.Current; break;
-                    default: throw new System.Exception("Unexpected number of children. Expected 3 children.");
-                }
-            }
-            if (childCount < 3) throw new System.Exception("Unexpected number of children. Expected 3 children.");
-
-            if (!(condition.Symbol is Conjunction || condition.Symbol is Disjunction))
-                throw new System.Exception("Unexpected first child for LogicalComparison of type: " + 
-                    condition.GetType().ToString() + ". Expected " + typeof(Conjunction).ToString() + 
-                    " or " + typeof(Disjunction).ToString() + ".");
-
-            // TODO Check children 2 & 3 for correct types
-
-            string[] result = new string[]
+      string[] result = new string[]
             {
                 ((CodeNode)condition.Symbol).Interpret(condition, condition.Subtrees),
@@ -70,6 +60,6 @@
             };
 
-            return this.Prefix + " " + result[1] + " " + result[0] + " " + result[2] + " " + this.Suffix;
-        }
+      return this.Prefix + " " + result[1] + " " + result[0] + " " + result[2] + " " + this.Suffix;
     }
+  }
 }
Index: branches/Robocode/HeuristicLab.Problems.Robocode/Symbols/Logical Expressions/LogicalExpression.cs
===================================================================
--- branches/Robocode/HeuristicLab.Problems.Robocode/Symbols/Logical Expressions/LogicalExpression.cs	(revision 9565)
+++ branches/Robocode/HeuristicLab.Problems.Robocode/Symbols/Logical Expressions/LogicalExpression.cs	(revision 9630)
@@ -3,58 +3,50 @@
 using HeuristicLab.Persistence.Default.CompositeSerializers.Storable;
 
-namespace HeuristicLab.Problems.Robocode
-{
-    [StorableClass]
-    public class LogicalExpression : CodeNode
-    {
-        public override int MinimumArity { get { return 1; } }
-        public override int MaximumArity { get { return 1; } }
+namespace HeuristicLab.Problems.Robocode {
+  [StorableClass]
+  public class LogicalExpression : CodeNode {
+    public override int MinimumArity { get { return 1; } }
+    public override int MaximumArity { get { return 1; } }
 
-        [Storable]
-        public override string Prefix { get; set; }
+    [Storable]
+    public override string Prefix { get; set; }
 
-        [Storable]
-        public override string Suffix { get; set; }
+    [Storable]
+    public override string Suffix { get; set; }
 
-        [StorableConstructor]
-        private LogicalExpression(bool deserializing) : base(deserializing) { }
-        private LogicalExpression(LogicalExpression original, Cloner cloner)
-            : base(original, cloner)
-        {
-            this.Prefix = "";
-            this.Suffix = "";
-        }
+    [StorableConstructor]
+    private LogicalExpression(bool deserializing) : base(deserializing) { }
+    private LogicalExpression(LogicalExpression original, Cloner cloner)
+      : base(original, cloner) {
+    }
 
-        public LogicalExpression()
-            : base("LogicalExpression", "A LogicalExpression.")
-        {
-            this.Prefix = "";
-            this.Suffix = "";
-        }
+    public LogicalExpression()
+      : base("LogicalExpression", "A LogicalExpression.") {
+      this.Prefix = "";
+      this.Suffix = "";
+    }
 
-        public override IDeepCloneable Clone(Cloner cloner)
-        {
-            return new LogicalExpression(this, cloner);
-        }
+    public override IDeepCloneable Clone(Cloner cloner) {
+      return new LogicalExpression(this, cloner);
+    }
 
-        public override string Interpret(ISymbolicExpressionTreeNode node, System.Collections.Generic.IEnumerable<ISymbolicExpressionTreeNode> children)
-        {
-            var enumerator = children.GetEnumerator();
+    public override string Interpret(ISymbolicExpressionTreeNode node, System.Collections.Generic.IEnumerable<ISymbolicExpressionTreeNode> children) {
+      var enumerator = children.GetEnumerator();
 
-            if (!enumerator.MoveNext()) throw new System.Exception("LogicalExpression was not given a child.");
-            var symbol = enumerator.Current.Symbol;
+      if (!enumerator.MoveNext()) throw new System.Exception("LogicalExpression was not given a child.");
+      var symbol = enumerator.Current.Symbol;
 
-            if(!(symbol is LogicalValue || symbol is LogicalComparison || 
-                symbol is NumericalComparison || symbol is Negation))
-                throw new System.Exception("LogicalExpression was given a child of type " + symbol.GetType().ToString() +
-                    ". The expected child must be of type " + typeof(LogicalValue).ToString() + " or " + 
-                    typeof(LogicalComparison).ToString() + " or " + typeof(NumericalComparison).ToString() + " or " + 
-                    typeof(Negation).ToString() + ".");
+      if (!(symbol is LogicalValue || symbol is LogicalComparison ||
+          symbol is NumericalComparison || symbol is Negation))
+        throw new System.Exception("LogicalExpression was given a child of type " + symbol.GetType().ToString() +
+            ". The expected child must be of type " + typeof(LogicalValue).ToString() + " or " +
+            typeof(LogicalComparison).ToString() + " or " + typeof(NumericalComparison).ToString() + " or " +
+            typeof(Negation).ToString() + ".");
 
-            string result = ((CodeNode)symbol).Interpret(enumerator.Current, enumerator.Current.Subtrees);
-            if (enumerator.MoveNext()) throw new System.Exception("LogicalExpression was given more than one child.");
+      string result = ((CodeNode)symbol).Interpret(enumerator.Current, enumerator.Current.Subtrees);
+      if (enumerator.MoveNext()) throw new System.Exception("LogicalExpression was given more than one child.");
 
-            return this.Prefix + result + this.Suffix;
-        }
+      return this.Prefix + result + this.Suffix;
     }
+  }
 }
Index: branches/Robocode/HeuristicLab.Problems.Robocode/Symbols/Logical Expressions/LogicalValue.cs
===================================================================
--- branches/Robocode/HeuristicLab.Problems.Robocode/Symbols/Logical Expressions/LogicalValue.cs	(revision 9565)
+++ branches/Robocode/HeuristicLab.Problems.Robocode/Symbols/Logical Expressions/LogicalValue.cs	(revision 9630)
@@ -3,49 +3,40 @@
 using HeuristicLab.Persistence.Default.CompositeSerializers.Storable;
 
-namespace HeuristicLab.Problems.Robocode
-{
-    [StorableClass]
-    public class LogicalValue : CodeNode
-    {
-        public override int MinimumArity { get { return 0; } }
-        public override int MaximumArity { get { return 0; } }
+namespace HeuristicLab.Problems.Robocode {
+  [StorableClass]
+  public class LogicalValue : CodeNode {
+    public override int MinimumArity { get { return 0; } }
+    public override int MaximumArity { get { return 0; } }
 
-        [Storable]
-        public override string Prefix { get; set; }
+    [Storable]
+    public override string Prefix { get; set; }
 
-        [Storable]
-        public override string Suffix { get; set; }
+    [Storable]
+    public override string Suffix { get; set; }
 
-        [StorableConstructor]
-        private LogicalValue(bool deserializing) : base(deserializing) { }
-        private LogicalValue(LogicalValue original, Cloner cloner)
-            : base(original, cloner)
-        {
-            this.Prefix = "";
-            this.Suffix = "";
-        }
+    [StorableConstructor]
+    private LogicalValue(bool deserializing) : base(deserializing) { }
+    private LogicalValue(LogicalValue original, Cloner cloner)
+      : base(original, cloner) {
+    }
 
-        public LogicalValue()
-            : base("LogicalValue", "A LogicalValue.")
-        {
-            this.Prefix = "";
-            this.Suffix = "";
-        }
+    public LogicalValue()
+      : base("LogicalValue", "A LogicalValue.") {
+      this.Prefix = "";
+      this.Suffix = "";
+    }
 
-        public override ISymbolicExpressionTreeNode CreateTreeNode()
-        {
+    public override ISymbolicExpressionTreeNode CreateTreeNode() {
 
-            return new BooleanTreeNode();
-        }
+      return new BooleanTreeNode();
+    }
 
-        public override IDeepCloneable Clone(Cloner cloner)
-        {
-            return new LogicalValue(this, cloner);
-        }
+    public override IDeepCloneable Clone(Cloner cloner) {
+      return new LogicalValue(this, cloner);
+    }
 
-        public override string Interpret(ISymbolicExpressionTreeNode node, System.Collections.Generic.IEnumerable<ISymbolicExpressionTreeNode> children)
-        {
-            return " " + ((BooleanTreeNode)node).Value.ToString().ToLower() + " ";
-        }
+    public override string Interpret(ISymbolicExpressionTreeNode node, System.Collections.Generic.IEnumerable<ISymbolicExpressionTreeNode> children) {
+      return " " + ((BooleanTreeNode)node).Value.ToString().ToLower() + " ";
     }
+  }
 }
Index: branches/Robocode/HeuristicLab.Problems.Robocode/Symbols/Logical Expressions/Negation.cs
===================================================================
--- branches/Robocode/HeuristicLab.Problems.Robocode/Symbols/Logical Expressions/Negation.cs	(revision 9565)
+++ branches/Robocode/HeuristicLab.Problems.Robocode/Symbols/Logical Expressions/Negation.cs	(revision 9630)
@@ -3,57 +3,49 @@
 using HeuristicLab.Persistence.Default.CompositeSerializers.Storable;
 
-namespace HeuristicLab.Problems.Robocode
-{
-    [StorableClass]
-    public class Negation : CodeNode
-    {
-        public override int MinimumArity { get { return 1; } }
-        public override int MaximumArity { get { return 1; } }
+namespace HeuristicLab.Problems.Robocode {
+  [StorableClass]
+  public class Negation : CodeNode {
+    public override int MinimumArity { get { return 1; } }
+    public override int MaximumArity { get { return 1; } }
 
-        [Storable]
-        public override string Prefix { get; set; }
+    [Storable]
+    public override string Prefix { get; set; }
 
-        [Storable]
-        public override string Suffix { get; set; }
+    [Storable]
+    public override string Suffix { get; set; }
 
-        [StorableConstructor]
-        private Negation(bool deserializing) : base(deserializing) { }
-        private Negation(Negation original, Cloner cloner)
-            : base(original, cloner)
-        {
-            this.Prefix = "!(";
-            this.Suffix = ")";
-        }
+    [StorableConstructor]
+    private Negation(bool deserializing) : base(deserializing) { }
+    private Negation(Negation original, Cloner cloner)
+      : base(original, cloner) {
+    }
 
-        public Negation()
-            : base("Negation", "A Negation.")
-        {
-            this.Prefix = "!(";
-            this.Suffix = ")";
-        }
+    public Negation()
+      : base("Negation", "A Negation.") {
+      this.Prefix = "!(";
+      this.Suffix = ")";
+    }
 
-        public override IDeepCloneable Clone(Cloner cloner)
-        {
-            return new Negation(this, cloner);
-        }
+    public override IDeepCloneable Clone(Cloner cloner) {
+      return new Negation(this, cloner);
+    }
 
-        public override string Interpret(ISymbolicExpressionTreeNode node, System.Collections.Generic.IEnumerable<ISymbolicExpressionTreeNode> children)
-        {
-            var enumerator = children.GetEnumerator();
-            if (!enumerator.MoveNext()) throw new System.Exception("Negation was not given a child.");
-            
-            var symbol = enumerator.Current.Symbol;
-            if (!(symbol is LogicalValue || symbol is LogicalComparison ||
-                symbol is NumericalComparison || symbol is Negation))
-                throw new System.Exception("Negation was given a child of type " + symbol.GetType().ToString() +
-                    ". The expected child must be of type " + typeof(LogicalValue).ToString() + " or " +
-                    typeof(LogicalComparison).ToString() + " or " + typeof(NumericalComparison).ToString() + " or " +
-                    typeof(Negation).ToString() + ".");
+    public override string Interpret(ISymbolicExpressionTreeNode node, System.Collections.Generic.IEnumerable<ISymbolicExpressionTreeNode> children) {
+      var enumerator = children.GetEnumerator();
+      if (!enumerator.MoveNext()) throw new System.Exception("Negation was not given a child.");
 
-            string result = ((CodeNode)symbol).Interpret(enumerator.Current, enumerator.Current.Subtrees);
-            if (enumerator.MoveNext()) throw new System.Exception("LogicalExpression was given more than one child.");
+      var symbol = enumerator.Current.Symbol;
+      if (!(symbol is LogicalValue || symbol is LogicalComparison ||
+          symbol is NumericalComparison || symbol is Negation))
+        throw new System.Exception("Negation was given a child of type " + symbol.GetType().ToString() +
+            ". The expected child must be of type " + typeof(LogicalValue).ToString() + " or " +
+            typeof(LogicalComparison).ToString() + " or " + typeof(NumericalComparison).ToString() + " or " +
+            typeof(Negation).ToString() + ".");
 
-            return this.Prefix + result + this.Suffix;
-        }
+      string result = ((CodeNode)symbol).Interpret(enumerator.Current, enumerator.Current.Subtrees);
+      if (enumerator.MoveNext()) throw new System.Exception("LogicalExpression was given more than one child.");
+
+      return this.Prefix + result + this.Suffix;
     }
+  }
 }
Index: branches/Robocode/HeuristicLab.Problems.Robocode/Symbols/Logical Expressions/NumericalComparison.cs
===================================================================
--- branches/Robocode/HeuristicLab.Problems.Robocode/Symbols/Logical Expressions/NumericalComparison.cs	(revision 9565)
+++ branches/Robocode/HeuristicLab.Problems.Robocode/Symbols/Logical Expressions/NumericalComparison.cs	(revision 9630)
@@ -3,69 +3,59 @@
 using HeuristicLab.Persistence.Default.CompositeSerializers.Storable;
 
-namespace HeuristicLab.Problems.Robocode
-{
-    [StorableClass]
-    public class NumericalComparison : CodeNode
-    {
-        public override int MinimumArity { get { return 3; } }
-        public override int MaximumArity { get { return 3; } }
+namespace HeuristicLab.Problems.Robocode {
+  [StorableClass]
+  public class NumericalComparison : CodeNode {
+    public override int MinimumArity { get { return 3; } }
+    public override int MaximumArity { get { return 3; } }
 
-        [Storable]
-        public override string Prefix { get; set; }
+    [Storable]
+    public override string Prefix { get; set; }
 
-        [Storable]
-        public override string Suffix { get; set; }
+    [Storable]
+    public override string Suffix { get; set; }
 
-        [StorableConstructor]
-        private NumericalComparison(bool deserializing) : base(deserializing) { }
-        private NumericalComparison(NumericalComparison original, Cloner cloner)
-            : base(original, cloner)
-        {
-            this.Prefix = "(";
-            this.Suffix = ")";
+    [StorableConstructor]
+    private NumericalComparison(bool deserializing) : base(deserializing) { }
+    private NumericalComparison(NumericalComparison original, Cloner cloner)
+      : base(original, cloner) {
+    }
+
+    public NumericalComparison()
+      : base("NumericalComparison", "A NumericalComparison.") {
+      this.Prefix = "(";
+      this.Suffix = ")";
+    }
+
+    public override IDeepCloneable Clone(Cloner cloner) {
+      return new NumericalComparison(this, cloner);
+    }
+
+    public override string Interpret(ISymbolicExpressionTreeNode node, System.Collections.Generic.IEnumerable<ISymbolicExpressionTreeNode> children) {
+      ISymbolicExpressionTreeNode condition = null, lhs = null, rhs = null;
+      var enumerator = children.GetEnumerator();
+      int childCount = 0;
+      while (enumerator.MoveNext()) {
+        childCount++;
+        switch (childCount) {
+          case 1: condition = enumerator.Current; break;
+          case 2: lhs = enumerator.Current; break;
+          case 3: rhs = enumerator.Current; break;
+          default: throw new System.Exception("Unexpected number of children. Expected 3 children.");
         }
+      }
+      if (childCount < 3) throw new System.Exception("Unexpected number of children. Expected 3 children.");
 
-        public NumericalComparison()
-            : base("NumericalComparison", "A NumericalComparison.")
-        {
-            this.Prefix = "(";
-            this.Suffix = ")";
-        }
+      if (!(condition.Symbol is Equal || condition.Symbol is GreaterThan ||
+          condition.Symbol is GreaterThanOrEqual || condition.Symbol is LessThan || condition.Symbol is LessThanOrEqual))
+        throw new System.Exception("Unexpected first child for NumericalComparison of type: " +
+            condition.GetType().ToString() + ". Expected " + typeof(Equal).ToString() +
+            " or " + typeof(GreaterThan).ToString() +
+            " or " + typeof(GreaterThanOrEqual).ToString() +
+            " or " + typeof(LessThan).ToString() +
+            " or " + typeof(LessThanOrEqual).ToString() + ".");
 
-        public override IDeepCloneable Clone(Cloner cloner)
-        {
-            return new NumericalComparison(this, cloner);
-        }
+      // TODO Check children 2 & 3 for correct types
 
-        public override string Interpret(ISymbolicExpressionTreeNode node, System.Collections.Generic.IEnumerable<ISymbolicExpressionTreeNode> children)
-        {
-            ISymbolicExpressionTreeNode condition = null, lhs = null, rhs = null;
-            var enumerator = children.GetEnumerator();
-            int childCount = 0;
-            while (enumerator.MoveNext())
-            {
-                childCount++;
-                switch (childCount)
-                {
-                    case 1: condition = enumerator.Current; break;
-                    case 2: lhs = enumerator.Current; break;
-                    case 3: rhs = enumerator.Current; break;
-                    default: throw new System.Exception("Unexpected number of children. Expected 3 children.");
-                }
-            }
-            if (childCount < 3) throw new System.Exception("Unexpected number of children. Expected 3 children.");
-
-            if (!(condition.Symbol is Equal || condition.Symbol is GreaterThan ||
-                condition.Symbol is GreaterThanOrEqual || condition.Symbol is LessThan || condition.Symbol is LessThanOrEqual))
-                throw new System.Exception("Unexpected first child for NumericalComparison of type: " +
-                    condition.GetType().ToString() + ". Expected " + typeof(Equal).ToString() +
-                    " or " + typeof(GreaterThan).ToString() +
-                    " or " + typeof(GreaterThanOrEqual).ToString() +
-                    " or " + typeof(LessThan).ToString() +
-                    " or " + typeof(LessThanOrEqual).ToString() + ".");
-
-            // TODO Check children 2 & 3 for correct types
-
-            string[] result = new string[]
+      string[] result = new string[]
             {
                 ((CodeNode)condition.Symbol).Interpret(condition, condition.Subtrees),
@@ -74,6 +64,6 @@
             };
 
-            return this.Prefix + " " + result[1] + " " + result[0] + " " + result[2] + " " + this.Suffix;
-        }
+      return this.Prefix + " " + result[1] + " " + result[0] + " " + result[2] + " " + this.Suffix;
     }
+  }
 }
