Index: /trunk/sources/HeuristicLab.CEDMA.DB.Interfaces/3.3/Ontology.cs
===================================================================
--- /trunk/sources/HeuristicLab.CEDMA.DB.Interfaces/3.3/Ontology.cs	(revision 1872)
+++ /trunk/sources/HeuristicLab.CEDMA.DB.Interfaces/3.3/Ontology.cs	(revision 1873)
@@ -91,7 +91,4 @@
     public static Entity PredicateInstanceOf {
       get { return new Entity(CedmaNameSpace + "InstanceOf"); }
-    }
-    public static Entity TypeGeneticProgrammingFunctionTree {
-      get { return new Entity(CedmaNameSpace + "FunctionTree"); }
     }
     public static Entity TypeDataSet {
Index: /trunk/sources/HeuristicLab.CEDMA.Server/3.3/DispatcherBase.cs
===================================================================
--- /trunk/sources/HeuristicLab.CEDMA.Server/3.3/DispatcherBase.cs	(revision 1872)
+++ /trunk/sources/HeuristicLab.CEDMA.Server/3.3/DispatcherBase.cs	(revision 1873)
@@ -61,6 +61,6 @@
       DataSet dataSet = new DataSet(store, dataSetEntity);
 
-      int targetVariable = SelectTargetVariable(dataSet, dataSet.Problem.AllowedTargetVariables.ToArray());
-      IAlgorithm selectedAlgorithm = SelectAlgorithm(dataSet, targetVariable, dataSet.Problem.LearningTask);
+      int targetVariable = SelectTargetVariable(dataSetEntity, dataSet.Problem.AllowedTargetVariables.ToArray());
+      IAlgorithm selectedAlgorithm = SelectAlgorithm(dataSetEntity, targetVariable, dataSet.Problem.LearningTask);
       string targetVariableName = dataSet.Problem.GetVariableName(targetVariable);
 
@@ -75,6 +75,6 @@
 
     public abstract Entity SelectDataSet(Entity[] datasets);
-    public abstract int SelectTargetVariable(DataSet dataSet, int[] targetVariables);
-    public abstract IAlgorithm SelectAlgorithm(DataSet dataSet, int targetVariable, LearningTask learningTask);
+    public abstract int SelectTargetVariable(Entity dataSet, int[] targetVariables);
+    public abstract IAlgorithm SelectAlgorithm(Entity dataSet, int targetVariable, LearningTask learningTask);
 
     private Execution CreateExecution(Problem problem, int targetVariable, IAlgorithm algorithm) {
Index: /trunk/sources/HeuristicLab.CEDMA.Server/3.3/Executer.cs
===================================================================
--- /trunk/sources/HeuristicLab.CEDMA.Server/3.3/Executer.cs	(revision 1872)
+++ /trunk/sources/HeuristicLab.CEDMA.Server/3.3/Executer.cs	(revision 1873)
@@ -129,5 +129,4 @@
     private void StoreResults(Execution finishedExecution, ProcessingEngine finishedEngine) {
       Entity model = new Entity(Ontology.CedmaNameSpace + Guid.NewGuid());
-      store.Add(new Statement(model, Ontology.PredicateInstanceOf, Ontology.TypeGeneticProgrammingFunctionTree));
       store.Add(new Statement(finishedExecution.DataSetEntity, Ontology.PredicateHasModel, model));
       StoreModelAttribute(model, Ontology.TargetVariable, finishedExecution.TargetVariable);
Index: /trunk/sources/HeuristicLab.CEDMA.Server/3.3/HeuristicLab.CEDMA.Server-3.3.csproj
===================================================================
--- /trunk/sources/HeuristicLab.CEDMA.Server/3.3/HeuristicLab.CEDMA.Server-3.3.csproj	(revision 1872)
+++ /trunk/sources/HeuristicLab.CEDMA.Server/3.3/HeuristicLab.CEDMA.Server-3.3.csproj	(revision 1873)
@@ -95,5 +95,4 @@
     <Compile Include="Execution.cs" />
     <Compile Include="Executer.cs" />
-    <Compile Include="RandomDispatcher.cs" />
     <Compile Include="Server.cs" />
     <Compile Include="ServerApplication.cs" />
@@ -106,4 +105,5 @@
       <DependentUpon>ServerForm.cs</DependentUpon>
     </Compile>
+    <Compile Include="SimpleDispatcher.cs" />
   </ItemGroup>
   <ItemGroup>
Index: unk/sources/HeuristicLab.CEDMA.Server/3.3/RandomDispatcher.cs
===================================================================
--- /trunk/sources/HeuristicLab.CEDMA.Server/3.3/RandomDispatcher.cs	(revision 1872)
+++ 	(revision )
@@ -1,78 +1,0 @@
-#region License Information
-/* HeuristicLab
- * Copyright (C) 2002-2008 Heuristic and Evolutionary Algorithms Laboratory (HEAL)
- *
- * This file is part of HeuristicLab.
- *
- * HeuristicLab is free software: you can redistribute it and/or modify
- * it under the terms of the GNU General Public License as published by
- * the Free Software Foundation, either version 3 of the License, or
- * (at your option) any later version.
- *
- * HeuristicLab is distributed in the hope that it will be useful,
- * but WITHOUT ANY WARRANTY; without even the implied warranty of
- * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
- * GNU General Public License for more details.
- *
- * You should have received a copy of the GNU General Public License
- * along with HeuristicLab. If not, see <http://www.gnu.org/licenses/>.
- */
-#endregion
-
-using System;
-using System.Collections.Generic;
-using System.Text;
-using System.Windows.Forms;
-using HeuristicLab.PluginInfrastructure;
-using System.Net;
-using System.ServiceModel;
-using HeuristicLab.CEDMA.DB.Interfaces;
-using HeuristicLab.CEDMA.DB;
-using System.ServiceModel.Description;
-using System.Linq;
-using HeuristicLab.CEDMA.Core;
-using HeuristicLab.GP.StructureIdentification;
-using HeuristicLab.Data;
-using HeuristicLab.Core;
-using HeuristicLab.Modeling;
-
-namespace HeuristicLab.CEDMA.Server {
-  public class RandomDispatcher : DispatcherBase {
-    private Random random;
-    public RandomDispatcher(IStore store)
-      : base(store) {
-      random = new Random();
-    }
-
-    public override IAlgorithm SelectAlgorithm(DataSet dataSet, int targetVariable, LearningTask learningTask) {
-      DiscoveryService ds = new DiscoveryService();
-      IAlgorithm[] algos = ds.GetInstances<IAlgorithm>();
-      switch (learningTask) {
-        case LearningTask.Regression: {
-            var regressionAlgos = algos.Where(a => (a as IClassificationAlgorithm) == null && (a as ITimeSeriesAlgorithm) == null);
-            if (regressionAlgos.Count() == 0) return null;
-            return regressionAlgos.ElementAt(random.Next(regressionAlgos.Count()));
-          }
-        case LearningTask.Classification: {
-            var classificationAlgos = algos.Where(a => (a as IClassificationAlgorithm) != null);
-            if (classificationAlgos.Count() == 0) return null;
-            return classificationAlgos.ElementAt(random.Next(classificationAlgos.Count()));
-          }
-        case LearningTask.TimeSeries: {
-            var timeSeriesAlgos = algos.Where(a => (a as ITimeSeriesAlgorithm) != null);
-            if (timeSeriesAlgos.Count() == 0) return null;
-            return timeSeriesAlgos.ElementAt(random.Next(timeSeriesAlgos.Count()));
-          }
-      }
-      return null;
-    }
-
-    public override Entity SelectDataSet(Entity[] datasets) {
-      return datasets[random.Next(datasets.Length)];
-    }
-
-    public override int SelectTargetVariable(DataSet dataSet, int[] targetVariables) {
-      return targetVariables[random.Next(targetVariables.Length)];
-    }
-  }
-}
Index: /trunk/sources/HeuristicLab.CEDMA.Server/3.3/ServerForm.cs
===================================================================
--- /trunk/sources/HeuristicLab.CEDMA.Server/3.3/ServerForm.cs	(revision 1872)
+++ /trunk/sources/HeuristicLab.CEDMA.Server/3.3/ServerForm.cs	(revision 1873)
@@ -63,5 +63,5 @@
 
     private void connectButton_Click(object sender, EventArgs e) {
-      dispatcher = new RandomDispatcher(store);
+      dispatcher = new SimpleDispatcher(store);
       executer = new Executer(dispatcher, store, gridAddress.Text);
       executer.Start();
Index: /trunk/sources/HeuristicLab.CEDMA.Server/3.3/SimpleDispatcher.cs
===================================================================
--- /trunk/sources/HeuristicLab.CEDMA.Server/3.3/SimpleDispatcher.cs	(revision 1873)
+++ /trunk/sources/HeuristicLab.CEDMA.Server/3.3/SimpleDispatcher.cs	(revision 1873)
@@ -0,0 +1,138 @@
+#region License Information
+/* HeuristicLab
+ * Copyright (C) 2002-2008 Heuristic and Evolutionary Algorithms Laboratory (HEAL)
+ *
+ * This file is part of HeuristicLab.
+ *
+ * HeuristicLab is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation, either version 3 of the License, or
+ * (at your option) any later version.
+ *
+ * HeuristicLab is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with HeuristicLab. If not, see <http://www.gnu.org/licenses/>.
+ */
+#endregion
+
+using System;
+using System.Collections.Generic;
+using System.Text;
+using System.Windows.Forms;
+using HeuristicLab.PluginInfrastructure;
+using System.Net;
+using System.ServiceModel;
+using HeuristicLab.CEDMA.DB.Interfaces;
+using HeuristicLab.CEDMA.DB;
+using System.ServiceModel.Description;
+using System.Linq;
+using HeuristicLab.CEDMA.Core;
+using HeuristicLab.GP.StructureIdentification;
+using HeuristicLab.Data;
+using HeuristicLab.Core;
+using HeuristicLab.Modeling;
+
+namespace HeuristicLab.CEDMA.Server {
+  public class SimpleDispatcher : DispatcherBase {
+    private Random random;
+    private IStore store;
+    private Dictionary<Entity, Dictionary<int, List<string>>> finishedAndDispatchedRuns;
+
+    public SimpleDispatcher(IStore store)
+      : base(store) {
+      this.store = store;
+      random = new Random();
+      finishedAndDispatchedRuns = new Dictionary<Entity, Dictionary<int, List<string>>>();
+      PopulateFinishedRuns();
+    }
+
+    public override IAlgorithm SelectAlgorithm(Entity dataSetEntity, int targetVariable, LearningTask learningTask) {
+      DiscoveryService ds = new DiscoveryService();
+      IAlgorithm[] algos = ds.GetInstances<IAlgorithm>();
+      IAlgorithm selectedAlgorithm = null;
+      switch (learningTask) {
+        case LearningTask.Regression: {
+            var regressionAlgos = algos.Where(a => (a as IClassificationAlgorithm) == null && (a as ITimeSeriesAlgorithm) == null);
+            selectedAlgorithm = ChooseDeterministic(dataSetEntity, targetVariable, regressionAlgos) ?? ChooseStochastic(regressionAlgos);
+            break;
+          }
+        case LearningTask.Classification: {
+            var classificationAlgos = algos.Where(a => (a as IClassificationAlgorithm) != null);
+            selectedAlgorithm = ChooseDeterministic(dataSetEntity, targetVariable, classificationAlgos) ?? ChooseStochastic(classificationAlgos);
+            break;
+          }
+        case LearningTask.TimeSeries: {
+            var timeSeriesAlgos = algos.Where(a => (a as ITimeSeriesAlgorithm) != null);
+            selectedAlgorithm = ChooseDeterministic(dataSetEntity, targetVariable, timeSeriesAlgos) ?? ChooseStochastic(timeSeriesAlgos);
+            break;
+          }
+      }
+      if (selectedAlgorithm != null) {
+        AddDispatchedRun(dataSetEntity, targetVariable, selectedAlgorithm.Name);
+      }
+      return selectedAlgorithm;
+    }
+
+    private IAlgorithm ChooseDeterministic(Entity dataSetEntity, int targetVariable, IEnumerable<IAlgorithm> algos) {
+      var deterministicAlgos = algos
+        .Where(a => (a as IStochasticAlgorithm) == null)
+        .Where(a => AlgorithmFinishedOrDispatched(dataSetEntity, targetVariable, a.Name) == false);
+
+      if (deterministicAlgos.Count() == 0) return null;
+      return deterministicAlgos.ElementAt(random.Next(deterministicAlgos.Count()));
+    }
+
+    private IAlgorithm ChooseStochastic(IEnumerable<IAlgorithm> regressionAlgos) {
+      var stochasticAlgos = regressionAlgos.Where(a => (a as IStochasticAlgorithm) != null);
+      if (stochasticAlgos.Count() == 0) return null;
+      return stochasticAlgos.ElementAt(random.Next(stochasticAlgos.Count()));
+    }
+
+    public override Entity SelectDataSet(Entity[] datasets) {
+      return datasets[random.Next(datasets.Length)];
+    }
+
+    public override int SelectTargetVariable(Entity dataSet, int[] targetVariables) {
+      return targetVariables[random.Next(targetVariables.Length)];
+    }
+
+    private void PopulateFinishedRuns() {
+      var result = store
+        .Query("?DataSet <" + Ontology.PredicateInstanceOf.Uri + "> <" + Ontology.TypeDataSet.Uri + "> ." + Environment.NewLine +
+        "?DataSet <" + Ontology.PredicateHasModel + "> ?Model ." + Environment.NewLine +
+        "?Model <" + Ontology.TargetVariable + "> ?TargetVariable ." + Environment.NewLine +
+        "?Model <" + Ontology.AlgorithmName + "> ?AlgoName .",
+        0, 1000)
+        .Select(x => new Resource[] { (Entity)x.Get("DataSet"), (Literal)x.Get("TargetVariable"), (Literal)x.Get("AlgoName") });
+
+      foreach (Resource[] row in result) {
+        Entity dataset = (Entity)row[0];
+        int targetVariable = (int)((Literal)row[1]).Value;
+        string algoName = (string)((Literal)row[2]).Value;
+        if (!AlgorithmFinishedOrDispatched(dataset, targetVariable, algoName))
+          AddDispatchedRun(dataset, targetVariable, algoName);
+      }
+    }
+
+    private void AddDispatchedRun(Entity dataSetEntity, int targetVariable, string algoName) {
+      if (!finishedAndDispatchedRuns.ContainsKey(dataSetEntity)) {
+        finishedAndDispatchedRuns[dataSetEntity] = new Dictionary<int, List<string>>();
+      }
+      if (!finishedAndDispatchedRuns[dataSetEntity].ContainsKey(targetVariable)) {
+        finishedAndDispatchedRuns[dataSetEntity][targetVariable] = new List<string>();
+      }
+      finishedAndDispatchedRuns[dataSetEntity][targetVariable].Add(algoName);
+    }
+
+    private bool AlgorithmFinishedOrDispatched(Entity dataSetEntity, int targetVariable, string algoName) {
+      return
+        finishedAndDispatchedRuns.ContainsKey(dataSetEntity) &&
+        finishedAndDispatchedRuns[dataSetEntity].ContainsKey(targetVariable) &&
+        finishedAndDispatchedRuns[dataSetEntity][targetVariable].Contains(algoName);
+    }
+  }
+}
Index: /trunk/sources/HeuristicLab.GP.StructureIdentification.Classification/3.3/HeuristicLabGPClassificationPlugin.cs
===================================================================
--- /trunk/sources/HeuristicLab.GP.StructureIdentification.Classification/3.3/HeuristicLabGPClassificationPlugin.cs	(revision 1872)
+++ /trunk/sources/HeuristicLab.GP.StructureIdentification.Classification/3.3/HeuristicLabGPClassificationPlugin.cs	(revision 1873)
@@ -34,5 +34,5 @@
   [Dependency(Dependency = "HeuristicLab.GP-3.3")]
   [Dependency(Dependency = "HeuristicLab.GP.StructureIdentification-3.3")]
-  [Dependency(Dependency = "HeuristicLab.Modeling-3.3")]
+  [Dependency(Dependency = "HeuristicLab.Modeling-3.2")]
   [Dependency(Dependency = "HeuristicLab.Operators-3.2")]
   [Dependency(Dependency = "HeuristicLab.Random-3.2")]
Index: /trunk/sources/HeuristicLab.GP.StructureIdentification/3.3/AlgorithmBase.cs
===================================================================
--- /trunk/sources/HeuristicLab.GP.StructureIdentification/3.3/AlgorithmBase.cs	(revision 1872)
+++ /trunk/sources/HeuristicLab.GP.StructureIdentification/3.3/AlgorithmBase.cs	(revision 1873)
@@ -136,4 +136,6 @@
       IOperator initialization = CreateInitialization();
       IOperator funLibInjector = CreateFunctionLibraryInjector();
+      IOperator treeEvaluatorInjector = new HL2TreeEvaluatorInjector();
+
       IOperator mainLoop = CreateMainLoop();
       mainLoop.Name = "Main loop";
@@ -157,4 +159,5 @@
       seq.AddSubOperator(globalInjector);
       seq.AddSubOperator(funLibInjector);
+      seq.AddSubOperator(treeEvaluatorInjector);
       seq.AddSubOperator(initialization);
       seq.AddSubOperator(mainLoop);
Index: /trunk/sources/HeuristicLab.GP.StructureIdentification/3.3/ConfigurableFunctionLibraryInjector.cs
===================================================================
--- /trunk/sources/HeuristicLab.GP.StructureIdentification/3.3/ConfigurableFunctionLibraryInjector.cs	(revision 1872)
+++ /trunk/sources/HeuristicLab.GP.StructureIdentification/3.3/ConfigurableFunctionLibraryInjector.cs	(revision 1873)
@@ -28,5 +28,4 @@
 using HeuristicLab.DataAnalysis;
 using HeuristicLab.Constraints;
-using StructId = HeuristicLab.GP.StructureIdentification;
 
 namespace HeuristicLab.GP.StructureIdentification {
@@ -66,77 +65,77 @@
       AddVariableInfo(new Core.VariableInfo(VARIABLES_ALLOWED, VARIABLES_ALLOWED + " allowed", typeof(BoolData), Core.VariableKind.New));
       GetVariableInfo(VARIABLES_ALLOWED).Local = true;
-      AddVariable(new Core.Variable(VARIABLES_ALLOWED,  new BoolData(true)));
+      AddVariable(new Core.Variable(VARIABLES_ALLOWED, new BoolData(true)));
 
       AddVariableInfo(new Core.VariableInfo(CONSTANTS_ALLOWED, CONSTANTS_ALLOWED + " allowed", typeof(BoolData), Core.VariableKind.New));
       GetVariableInfo(CONSTANTS_ALLOWED).Local = true;
-      AddVariable(new Core.Variable(CONSTANTS_ALLOWED,  new BoolData(true)));
+      AddVariable(new Core.Variable(CONSTANTS_ALLOWED, new BoolData(true)));
 
       AddVariableInfo(new Core.VariableInfo(ADDITION_ALLOWED, ADDITION_ALLOWED + " allowed", typeof(BoolData), Core.VariableKind.New));
       GetVariableInfo(ADDITION_ALLOWED).Local = true;
-      AddVariable(new Core.Variable(ADDITION_ALLOWED,  new BoolData(true)));
+      AddVariable(new Core.Variable(ADDITION_ALLOWED, new BoolData(true)));
 
       AddVariableInfo(new Core.VariableInfo(AVERAGE_ALLOWED, AVERAGE_ALLOWED + " allowed", typeof(BoolData), Core.VariableKind.New));
       GetVariableInfo(AVERAGE_ALLOWED).Local = true;
-      AddVariable(new Core.Variable(AVERAGE_ALLOWED,  new BoolData(true)));
+      AddVariable(new Core.Variable(AVERAGE_ALLOWED, new BoolData(true)));
 
       AddVariableInfo(new Core.VariableInfo(AND_ALLOWED, AND_ALLOWED + " allowed", typeof(BoolData), Core.VariableKind.New));
       GetVariableInfo(AND_ALLOWED).Local = true;
-      AddVariable(new Core.Variable(AND_ALLOWED,  new BoolData(true)));
+      AddVariable(new Core.Variable(AND_ALLOWED, new BoolData(true)));
 
       AddVariableInfo(new Core.VariableInfo(COSINUS_ALLOWED, COSINUS_ALLOWED + " allowed", typeof(BoolData), Core.VariableKind.New));
       GetVariableInfo(COSINUS_ALLOWED).Local = true;
-      AddVariable(new Core.Variable(COSINUS_ALLOWED,  new BoolData(true)));
+      AddVariable(new Core.Variable(COSINUS_ALLOWED, new BoolData(true)));
 
       AddVariableInfo(new Core.VariableInfo(DIVISION_ALLOWED, DIVISION_ALLOWED + " allowed", typeof(BoolData), Core.VariableKind.New));
       GetVariableInfo(DIVISION_ALLOWED).Local = true;
-      AddVariable(new Core.Variable(DIVISION_ALLOWED,  new BoolData(true)));
+      AddVariable(new Core.Variable(DIVISION_ALLOWED, new BoolData(true)));
 
       AddVariableInfo(new Core.VariableInfo(EQUAL_ALLOWED, EQUAL_ALLOWED + " allowed", typeof(BoolData), Core.VariableKind.New));
       GetVariableInfo(EQUAL_ALLOWED).Local = true;
-      AddVariable(new Core.Variable(EQUAL_ALLOWED,  new BoolData(true)));
+      AddVariable(new Core.Variable(EQUAL_ALLOWED, new BoolData(true)));
 
       AddVariableInfo(new Core.VariableInfo(EXPONENTIAL_ALLOWED, EXPONENTIAL_ALLOWED + " allowed", typeof(BoolData), Core.VariableKind.New));
       GetVariableInfo(EXPONENTIAL_ALLOWED).Local = true;
-      AddVariable(new Core.Variable(EXPONENTIAL_ALLOWED,  new BoolData(true)));
+      AddVariable(new Core.Variable(EXPONENTIAL_ALLOWED, new BoolData(true)));
 
       AddVariableInfo(new Core.VariableInfo(GREATERTHAN_ALLOWED, GREATERTHAN_ALLOWED + " allowed", typeof(BoolData), Core.VariableKind.New));
       GetVariableInfo(GREATERTHAN_ALLOWED).Local = true;
-      AddVariable(new Core.Variable(GREATERTHAN_ALLOWED,  new BoolData(true)));
+      AddVariable(new Core.Variable(GREATERTHAN_ALLOWED, new BoolData(true)));
 
       AddVariableInfo(new Core.VariableInfo(IFTHENELSE_ALLOWED, IFTHENELSE_ALLOWED + " allowed", typeof(BoolData), Core.VariableKind.New));
       GetVariableInfo(IFTHENELSE_ALLOWED).Local = true;
-      AddVariable(new Core.Variable(IFTHENELSE_ALLOWED,  new BoolData(true)));
+      AddVariable(new Core.Variable(IFTHENELSE_ALLOWED, new BoolData(true)));
 
       AddVariableInfo(new Core.VariableInfo(LESSTHAN_ALLOWED, LESSTHAN_ALLOWED + " allowed", typeof(BoolData), Core.VariableKind.New));
       GetVariableInfo(LESSTHAN_ALLOWED).Local = true;
-      AddVariable(new Core.Variable(LESSTHAN_ALLOWED,  new BoolData(true)));
+      AddVariable(new Core.Variable(LESSTHAN_ALLOWED, new BoolData(true)));
 
       AddVariableInfo(new Core.VariableInfo(LOGARTIHM_ALLOWED, LOGARTIHM_ALLOWED + " allowed", typeof(BoolData), Core.VariableKind.New));
       GetVariableInfo(LOGARTIHM_ALLOWED).Local = true;
-      AddVariable(new Core.Variable(LOGARTIHM_ALLOWED,  new BoolData(true)));
+      AddVariable(new Core.Variable(LOGARTIHM_ALLOWED, new BoolData(true)));
 
       AddVariableInfo(new Core.VariableInfo(MULTIPLICATION_ALLOWED, MULTIPLICATION_ALLOWED + " allowed", typeof(BoolData), Core.VariableKind.New));
       GetVariableInfo(MULTIPLICATION_ALLOWED).Local = true;
-      AddVariable(new Core.Variable(MULTIPLICATION_ALLOWED,  new BoolData(true)));
+      AddVariable(new Core.Variable(MULTIPLICATION_ALLOWED, new BoolData(true)));
 
       AddVariableInfo(new Core.VariableInfo(NOT_ALLOWED, NOT_ALLOWED + " allowed", typeof(BoolData), Core.VariableKind.New));
       GetVariableInfo(NOT_ALLOWED).Local = true;
-      AddVariable(new Core.Variable(NOT_ALLOWED,  new BoolData(true)));
+      AddVariable(new Core.Variable(NOT_ALLOWED, new BoolData(true)));
 
       AddVariableInfo(new Core.VariableInfo(POWER_ALLOWED, POWER_ALLOWED + " allowed", typeof(BoolData), Core.VariableKind.New));
       GetVariableInfo(POWER_ALLOWED).Local = true;
-      AddVariable(new Core.Variable(POWER_ALLOWED,  new BoolData(true)));
+      AddVariable(new Core.Variable(POWER_ALLOWED, new BoolData(true)));
 
       AddVariableInfo(new Core.VariableInfo(OR_ALLOWED, OR_ALLOWED + " allowed", typeof(BoolData), Core.VariableKind.New));
       GetVariableInfo(OR_ALLOWED).Local = true;
-      AddVariable(new Core.Variable(OR_ALLOWED,  new BoolData(true)));
+      AddVariable(new Core.Variable(OR_ALLOWED, new BoolData(true)));
 
       AddVariableInfo(new Core.VariableInfo(SIGNUM_ALLOWED, SIGNUM_ALLOWED + " allowed", typeof(BoolData), Core.VariableKind.New));
       GetVariableInfo(SIGNUM_ALLOWED).Local = true;
-      AddVariable(new Core.Variable(SIGNUM_ALLOWED,  new BoolData(true)));
+      AddVariable(new Core.Variable(SIGNUM_ALLOWED, new BoolData(true)));
 
       AddVariableInfo(new Core.VariableInfo(SINUS_ALLOWED, SINUS_ALLOWED + " allowed", typeof(BoolData), Core.VariableKind.New));
       GetVariableInfo(SINUS_ALLOWED).Local = true;
-      AddVariable(new Core.Variable(SINUS_ALLOWED,  new BoolData(true)));
+      AddVariable(new Core.Variable(SINUS_ALLOWED, new BoolData(true)));
 
       AddVariableInfo(new Core.VariableInfo(SQRT_ALLOWED, SQRT_ALLOWED + " allowed", typeof(BoolData), Core.VariableKind.New));
@@ -146,5 +145,5 @@
       AddVariableInfo(new Core.VariableInfo(SUBTRACTION_ALLOWED, SUBTRACTION_ALLOWED + " allowed", typeof(BoolData), Core.VariableKind.New));
       GetVariableInfo(SUBTRACTION_ALLOWED).Local = true;
-      AddVariable(new Core.Variable(SUBTRACTION_ALLOWED,  new BoolData(true)));
+      AddVariable(new Core.Variable(SUBTRACTION_ALLOWED, new BoolData(true)));
 
       AddVariableInfo(new Core.VariableInfo(TANGENS_ALLOWED, TANGENS_ALLOWED + " allowed", typeof(BoolData), Core.VariableKind.New));
@@ -154,10 +153,6 @@
       AddVariableInfo(new Core.VariableInfo(XOR_ALLOWED, XOR_ALLOWED + " allowed", typeof(BoolData), Core.VariableKind.New));
       GetVariableInfo(XOR_ALLOWED).Local = true;
-      AddVariable(new Core.Variable(XOR_ALLOWED,  new BoolData(true)));
-    }
-
-    //public override IView CreateView() {
-    //  return new ConfigurableFunctionLibraryInjectorView(this);
-    //}
+      AddVariable(new Core.Variable(XOR_ALLOWED, new BoolData(true)));
+    }
 
     public override IOperation Apply(IScope scope) {
@@ -180,5 +175,5 @@
       if (!((BoolData)GetVariable(DIVISION_ALLOWED).Value).Data)
         functionLibrary.GPOperatorGroup.RemoveOperator(FindOperator(functionLibrary.GPOperatorGroup, typeof(Division)));
-      if (!((BoolData)GetVariable(EQUAL_ALLOWED).Value).Data)                                                       
+      if (!((BoolData)GetVariable(EQUAL_ALLOWED).Value).Data)
         functionLibrary.GPOperatorGroup.RemoveOperator(FindOperator(functionLibrary.GPOperatorGroup, typeof(Equal)));
       if (!((BoolData)GetVariable(EXPONENTIAL_ALLOWED).Value).Data)
@@ -212,17 +207,13 @@
       if (!((BoolData)GetVariable(XOR_ALLOWED).Value).Data)
         functionLibrary.GPOperatorGroup.RemoveOperator(FindOperator(functionLibrary.GPOperatorGroup, typeof(Xor)));
-
-
       return null;
     }
 
-    private IFunction FindOperator(GPOperatorGroup g, Type t)  {
+    private IFunction FindOperator(GPOperatorGroup g, Type t) {
       foreach (IFunction func in g.Operators)
         if (func.GetType() == t)
           return func;
       return null;
-  }
-
-
+    }
   }
 }
Index: /trunk/sources/HeuristicLab.GP.StructureIdentification/3.3/OffSpringSelectionGpEditor.cs
===================================================================
--- /trunk/sources/HeuristicLab.GP.StructureIdentification/3.3/OffSpringSelectionGpEditor.cs	(revision 1872)
+++ /trunk/sources/HeuristicLab.GP.StructureIdentification/3.3/OffSpringSelectionGpEditor.cs	(revision 1873)
@@ -74,5 +74,5 @@
     protected virtual void SetDataBinding() {
       setRandomSeedRandomlyCheckBox.DataBindings.Add("Checked", OffspringSelectionGP, "SetSeedRandomly");
-      randomSeedTextBox.DataBindings.Add("Text", OffspringSelectionGP, "Seed");
+      randomSeedTextBox.DataBindings.Add("Text", OffspringSelectionGP, "RandomSeed");
       populationSizeTextBox.DataBindings.Add("Text", OffspringSelectionGP, "PopulationSize");
       maximumEvaluatedSolutionsTextBox.DataBindings.Add("Text", OffspringSelectionGP, "MaxEvaluatedSolutions");
Index: /trunk/sources/HeuristicLab.GP.StructureIdentification/3.3/StandardGP.cs
===================================================================
--- /trunk/sources/HeuristicLab.GP.StructureIdentification/3.3/StandardGP.cs	(revision 1872)
+++ /trunk/sources/HeuristicLab.GP.StructureIdentification/3.3/StandardGP.cs	(revision 1873)
@@ -142,5 +142,8 @@
 
     protected internal override IOperator CreateFunctionLibraryInjector() {
-      return new FunctionLibraryInjector();
+      ConfigurableFunctionLibraryInjector funLibInjector = new ConfigurableFunctionLibraryInjector();
+      funLibInjector.GetVariableValue<BoolData>("Xor", null, false).Data = false;
+      funLibInjector.GetVariableValue<BoolData>("Average", null, false).Data = false;
+      return funLibInjector;
     }
 
Index: /trunk/sources/HeuristicLab.GP.StructureIdentification/3.3/StandardGpEditor.cs
===================================================================
--- /trunk/sources/HeuristicLab.GP.StructureIdentification/3.3/StandardGpEditor.cs	(revision 1872)
+++ /trunk/sources/HeuristicLab.GP.StructureIdentification/3.3/StandardGpEditor.cs	(revision 1873)
@@ -73,5 +73,5 @@
     protected virtual void SetDataBinding() {
       setRandomSeedRandomlyCheckBox.DataBindings.Add("Checked", StandardGP, "SetSeedRandomly");
-      randomSeedTextBox.DataBindings.Add("Text", StandardGP, "Seed");
+      randomSeedTextBox.DataBindings.Add("Text", StandardGP, "RandomSeed");
       populationSizeTextBox.DataBindings.Add("Text", StandardGP, "PopulationSize");
       maximumGenerationsTextBox.DataBindings.Add("Text", StandardGP, "MaxGenerations");
Index: /trunk/sources/HeuristicLab.GP.StructureIdentification/3.3/TreeEvaluatorBase.cs
===================================================================
--- /trunk/sources/HeuristicLab.GP.StructureIdentification/3.3/TreeEvaluatorBase.cs	(revision 1872)
+++ /trunk/sources/HeuristicLab.GP.StructureIdentification/3.3/TreeEvaluatorBase.cs	(revision 1873)
@@ -124,5 +124,9 @@
     public override object Clone(IDictionary<Guid, object> clonedObjects) {
       TreeEvaluatorBase clone = (TreeEvaluatorBase)base.Clone(clonedObjects);
-      clone.dataset = (Dataset)dataset.Clone(clonedObjects);
+      if (!clonedObjects.ContainsKey(dataset.Guid)) {
+        clone.dataset = (Dataset)dataset.Clone(clonedObjects);
+      } else {
+        clone.dataset = (Dataset)clonedObjects[dataset.Guid];
+      }
       clone.estimatedValueMax = estimatedValueMax;
       clone.estimatedValueMin = estimatedValueMin;
Index: /trunk/sources/HeuristicLab.SupportVectorMachines/3.2/SupportVectorRegression.cs
===================================================================
--- /trunk/sources/HeuristicLab.SupportVectorMachines/3.2/SupportVectorRegression.cs	(revision 1872)
+++ /trunk/sources/HeuristicLab.SupportVectorMachines/3.2/SupportVectorRegression.cs	(revision 1873)
@@ -140,9 +140,9 @@
       ((ItemList<StringData>)collector.GetVariable("VariableNames").Value).Add(new StringData("Nu"));
       ((ItemList<StringData>)collector.GetVariable("VariableNames").Value).Add(new StringData("Cost"));
-      ((ItemList<StringData>)collector.GetVariable("VariableNames").Value).Add(new StringData("ValidationMSE"));
+      ((ItemList<StringData>)collector.GetVariable("VariableNames").Value).Add(new StringData("ValidationQuality"));
       modelProcessor.AddSubOperator(collector);
 
       BestSolutionStorer solStorer = new BestSolutionStorer();
-      solStorer.GetVariableInfo("Quality").ActualName = "ValidationMSE";
+      solStorer.GetVariableInfo("Quality").ActualName = "ValidationQuality";
       solStorer.GetVariableInfo("Maximization").Local = true;
       solStorer.GetVariableInfo("BestSolution").ActualName = "BestValidationSolution";
@@ -201,5 +201,5 @@
       mseEvaluator.Name = p + "MseEvaluator";
       mseEvaluator.GetVariableInfo("Values").ActualName = p + "Values";
-      mseEvaluator.GetVariableInfo("MSE").ActualName = p + "MSE";
+      mseEvaluator.GetVariableInfo("MSE").ActualName = p + "Quality";
       SimpleR2Evaluator r2Evaluator = new SimpleR2Evaluator();
       r2Evaluator.Name = p + "R2Evaluator";
