Index: branches/2988_ModelsOfModels2/HeuristicLab.Problems.DataAnalysis.Symbolic/3.4/Interpreter/SymbolicDataAnalysisExpressionTreeBatchInterpreter.cs
===================================================================
--- branches/2988_ModelsOfModels2/HeuristicLab.Problems.DataAnalysis.Symbolic/3.4/Interpreter/SymbolicDataAnalysisExpressionTreeBatchInterpreter.cs	(revision 16722)
+++ branches/2988_ModelsOfModels2/HeuristicLab.Problems.DataAnalysis.Symbolic/3.4/Interpreter/SymbolicDataAnalysisExpressionTreeBatchInterpreter.cs	(revision 16899)
@@ -64,14 +64,14 @@
 
         switch (instr.opcode) {
-          case OpCodes.Variable: {
+          case OpCode.Variable: {
               LoadData(instr, rows, rowIndex, batchSize);
               break;
             }
-          case OpCodes.TreeModel: {
+          case OpCode.TreeModel: {
               SubTreeEvoluate(instr, rows, rowIndex, batchSize);
               break;
             }
 
-          case OpCodes.Add: {
+          case OpCode.Add: {
               Load(instr.buf, code[c].buf);
               for (int j = 1; j < n; ++j) {
@@ -81,5 +81,5 @@
             }
 
-          case OpCodes.Sub: {
+          case OpCode.Sub: {
               if (n == 1) {
                 Neg(instr.buf, code[c].buf);
@@ -93,5 +93,5 @@
             }
 
-          case OpCodes.Mul: {
+          case OpCode.Mul: {
               Load(instr.buf, code[c].buf);
               for (int j = 1; j < n; ++j) {
@@ -101,5 +101,5 @@
             }
 
-          case OpCodes.Div: {
+          case OpCode.Div: {
               if (n == 1) {
                 Inv(instr.buf, code[c].buf);
@@ -113,10 +113,10 @@
             }
 
-          case OpCodes.Square: {
+          case OpCode.Square: {
               Square(instr.buf, code[c].buf);
               break;
             }
 
-          case OpCodes.Root: {
+          case OpCode.Root: {
               Load(instr.buf, code[c].buf);
               Root(instr.buf, code[c + 1].buf);
@@ -124,19 +124,19 @@
             }
 
-          case OpCodes.SquareRoot: {
+          case OpCode.SquareRoot: {
               Sqrt(instr.buf, code[c].buf);
               break;
             }
 
-          case OpCodes.Cube: {
+          case OpCode.Cube: {
               Cube(instr.buf, code[c].buf);
               break;
             }
-          case OpCodes.CubeRoot: {
+          case OpCode.CubeRoot: {
               CubeRoot(instr.buf, code[c].buf);
               break;
             }
 
-          case OpCodes.Power: {
+          case OpCode.Power: {
               Load(instr.buf, code[c].buf);
               Pow(instr.buf, code[c + 1].buf);
@@ -144,38 +144,38 @@
             }
 
-          case OpCodes.Exp: {
+          case OpCode.Exp: {
               Exp(instr.buf, code[c].buf);
               break;
             }
 
-          case OpCodes.Log: {
+          case OpCode.Log: {
               Log(instr.buf, code[c].buf);
               break;
             }
 
-          case OpCodes.Sin: {
+          case OpCode.Sin: {
               Sin(instr.buf, code[c].buf);
               break;
             }
 
-          case OpCodes.Cos: {
+          case OpCode.Cos: {
               Cos(instr.buf, code[c].buf);
               break;
             }
 
-          case OpCodes.Tan: {
+          case OpCode.Tan: {
               Tan(instr.buf, code[c].buf);
               break;
             }
-          case OpCodes.Tanh: {
+          case OpCode.Tanh: {
               Tanh(instr.buf, code[c].buf);
               break;
             }
-          case OpCodes.Absolute: {
+          case OpCode.Absolute: {
               Absolute(instr.buf, code[c].buf);
               break;
             }
 
-          case OpCodes.AnalyticQuotient: {
+          case OpCode.AnalyticQuotient: {
               Load(instr.buf, code[c].buf);
               AnalyticQuotient(instr.buf, code[c + 1].buf);
@@ -213,5 +213,5 @@
       }
 
-      var code = Compile(tree, dataset, OpCodes.MapSymbolToOpCode, rows);
+      var code = Compile(tree, dataset, OpCode.MapSymbolToOpCode, rows);
       var remainingRows = rows.Length % BATCHSIZE;
       var roundedTotal = rows.Length - remainingRows;
