Index: branches/HeuristicLab.Classification/HeuristicLab.Algorithms.DataAnalysis/3.3/CrossValidation.cs
===================================================================
--- branches/HeuristicLab.Classification/HeuristicLab.Algorithms.DataAnalysis/3.3/CrossValidation.cs	(revision 4536)
+++ branches/HeuristicLab.Classification/HeuristicLab.Algorithms.DataAnalysis/3.3/CrossValidation.cs	(revision 4542)
@@ -36,5 +36,4 @@
   [StorableClass]
   public sealed class CrossValidation : NamedItem, IOptimizer {
-    //TODO cloning, persistence, creation of clonedAlgs, execution logic, ...
     public CrossValidation()
       : base() {
@@ -44,22 +43,58 @@
       executionState = ExecutionState.Stopped;
       executionTime = TimeSpan.Zero;
-      Runs = new RunCollection();
+      runs = new RunCollection();
 
       algorithm = null;
       clonedAlgorithms = new ItemCollection<IAlgorithm>();
-      RegisterClonedAlgorithmEvents();
       readOnlyClonedAlgorithms = null;
 
       folds = new IntValue(1);
+      numberOfWorkers = new IntValue(1);
       samplesStart = new IntValue(0);
       samplesEnd = new IntValue(0);
-      numberOfWorkers = new IntValue(1);
-    }
+
+
+      RegisterEvents();
+    }
+
+    #region persistence and cloning
+    [StorableConstructor]
+    private CrossValidation(bool deserializing)
+      : base(deserializing) {
+    }
+    [StorableHook(HookType.AfterDeserialization)]
+    private void AfterDeserialization() {
+      RegisterEvents();
+    }
+
+    public override IDeepCloneable Clone(Cloner cloner) {
+      if (ExecutionState == ExecutionState.Started) throw new InvalidOperationException(string.Format("Clone not allowed in execution state \"{0}\".", ExecutionState));
+      CrossValidation clone = new CrossValidation(false);
+      cloner.RegisterClonedObject(this, clone);
+      clone.name = name;
+      clone.description = description;
+      clone.executionState = executionState;
+      clone.executionTime = executionTime;
+      clone.runs = (RunCollection)cloner.Clone(runs);
+      clone.algorithm = (IAlgorithm)cloner.Clone(algorithm);
+      clone.clonedAlgorithms = (ItemCollection<IAlgorithm>)cloner.Clone(clonedAlgorithms);
+      clone.folds = (IntValue)cloner.Clone(folds);
+      clone.numberOfWorkers = (IntValue)cloner.Clone(numberOfWorkers);
+      clone.samplesStart = (IntValue)cloner.Clone(samplesStart);
+      clone.samplesEnd = (IntValue)cloner.Clone(samplesEnd);
+      clone.RegisterEvents();
+      return clone;
+    }
+
+    #endregion
 
     #region properties
+    [Storable]
     private IAlgorithm algorithm;
     public IAlgorithm Algorithm {
       get { return algorithm; }
       set {
+        if (ExecutionState != ExecutionState.Prepared && ExecutionState != ExecutionState.Stopped)
+          throw new InvalidOperationException("Changing the algorithm is only allowed if the CrossValidation is stopped or prepared.");
         if (algorithm != value) {
           if (value != null && value.Problem != null && !(value.Problem is IDataAnalysisProblem))
@@ -67,10 +102,16 @@
           if (algorithm != null) DeregisterAlgorithmEvents();
           algorithm = value;
-          algorithm.Prepare(true);
-          if (algorithm != null) RegisterAlgorithmEvents();
+
+          if (algorithm != null) {
+            RegisterAlgorithmEvents();
+            algorithm.Prepare(true);
+          }
           OnAlgorithmChanged();
-        }
-      }
-    }
+          Prepare();
+        }
+      }
+    }
+
+    [Storable]
     private IDataAnalysisProblem cachedProblem;
     public IDataAnalysisProblem Problem {
@@ -81,4 +122,6 @@
       }
       set {
+        if (ExecutionState != ExecutionState.Prepared && ExecutionState != ExecutionState.Stopped)
+          throw new InvalidOperationException("Changing the problem is only allowed if the CrossValidation is stopped or prepared.");
         if (algorithm == null) throw new ArgumentNullException("Could not set a problem before an algorithm was set.");
         algorithm.Problem = value;
@@ -87,4 +130,5 @@
     }
 
+    [Storable]
     private ItemCollection<IAlgorithm> clonedAlgorithms;
     private ReadOnlyItemCollection<IAlgorithm> readOnlyClonedAlgorithms;
@@ -96,16 +140,20 @@
     }
 
+    [Storable]
     private IntValue folds;
     public IntValue Folds {
       get { return folds; }
     }
+    [Storable]
     private IntValue samplesStart;
     public IntValue SamplesStart {
       get { return samplesStart; }
     }
+    [Storable]
     private IntValue samplesEnd;
     public IntValue SamplesEnd {
       get { return samplesEnd; }
     }
+    [Storable]
     private IntValue numberOfWorkers;
     public IntValue NumberOfWorkers {
@@ -113,16 +161,10 @@
     }
 
+    [Storable]
     private RunCollection runs;
     public RunCollection Runs {
       get { return runs; }
-      private set {
-        if (value == null) throw new ArgumentNullException();
-        if (runs != value) {
-          if (runs != null) DeregisterRunsEvents();
-          runs = value;
-          if (runs != null) RegisterRunsEvents();
-        }
-      }
-    }
+    }
+    [Storable]
     private ExecutionState executionState;
     public ExecutionState ExecutionState {
@@ -146,4 +188,5 @@
     }
 
+    [Storable]
     private TimeSpan executionTime;
     public TimeSpan ExecutionTime {
@@ -162,6 +205,11 @@
 
     public void Prepare() {
+      if ((ExecutionState != ExecutionState.Prepared) && (ExecutionState != ExecutionState.Paused) && (ExecutionState != ExecutionState.Stopped))
+        throw new InvalidOperationException(string.Format("Prepare not allowed in execution state \"{0}\".", ExecutionState));
       clonedAlgorithms.Clear();
-      OnPrepared();
+      if (Algorithm != null) {
+        Algorithm.Prepare();
+        if (Algorithm.ExecutionState == ExecutionState.Prepared) OnPrepared();
+      }
     }
     public void Prepare(bool clearRuns) {
@@ -169,22 +217,104 @@
       Prepare();
     }
+
+    private bool startPending;
     public void Start() {
-      for (int i = 0; i < Folds.Value; i++) {
-        IAlgorithm clonedAlgorithm = (IAlgorithm)algorithm.Clone();
-        clonedAlgorithm.Name = algorithm.Name + " Fold " + i;
-        clonedAlgorithms.Add(clonedAlgorithm);
-      }
-      for (int i = 0; i < NumberOfWorkers.Value && i < clonedAlgorithms.Count; i++)
-        clonedAlgorithms.ElementAt(i).Start();
-      OnStarted();
-    }
+      if ((ExecutionState != ExecutionState.Prepared) && (ExecutionState != ExecutionState.Paused))
+        throw new InvalidOperationException(string.Format("Start not allowed in execution state \"{0}\".", ExecutionState));
+
+      if (Algorithm != null && !startPending) {
+        startPending = true;
+        //create cloned algorithms
+        if (clonedAlgorithms.Count == 0) {
+          for (int i = 0; i < Folds.Value; i++) {
+            IAlgorithm clonedAlgorithm = (IAlgorithm)algorithm.Clone();
+            clonedAlgorithm.Name = algorithm.Name + " Fold " + i;
+            clonedAlgorithms.Add(clonedAlgorithm);
+          }
+        }
+
+        //start prepared or paused cloned algorithms
+        int startedAlgorithms = 0;
+        foreach (IAlgorithm clonedAlgorithm in clonedAlgorithms) {
+          if (startedAlgorithms < NumberOfWorkers.Value) {
+            if (clonedAlgorithm.ExecutionState == ExecutionState.Prepared ||
+                clonedAlgorithm.ExecutionState == ExecutionState.Paused) {
+              clonedAlgorithm.Start();
+              startedAlgorithms++;
+            }
+          }
+        }
+        OnStarted();
+      }
+    }
+
+    private bool pausePending;
     public void Pause() {
-      OnPaused();
-    }
+      if (ExecutionState != ExecutionState.Started)
+        throw new InvalidOperationException(string.Format("Pause not allowed in execution state \"{0}\".", ExecutionState));
+      if (!pausePending) {
+        pausePending = true;
+        if (!startPending) PauseAllClonedAlgorithms();
+      }
+    }
+    private void PauseAllClonedAlgorithms() {
+      foreach (IAlgorithm clonedAlgorithm in ClonedAlgorithms) {
+        if (clonedAlgorithm.ExecutionState == ExecutionState.Started)
+          clonedAlgorithm.Pause();
+      }
+    }
+
+    private bool stopPending;
     public void Stop() {
-      OnStopped();
+      if ((ExecutionState != ExecutionState.Started) && (ExecutionState != ExecutionState.Paused))
+        throw new InvalidOperationException(string.Format("Stop not allowed in execution state \"{0}\".",
+                                                          ExecutionState));
+      if (!stopPending) {
+        stopPending = true;
+        if (!startPending) StopAllClonedAlgorithms();
+      }
+    }
+    private void StopAllClonedAlgorithms() {
+      foreach (IAlgorithm clonedAlgorithm in ClonedAlgorithms) {
+        if (clonedAlgorithm.ExecutionState == ExecutionState.Started ||
+            clonedAlgorithm.ExecutionState == ExecutionState.Paused)
+          clonedAlgorithm.Stop();
+      }
     }
 
     #region events
+    private void RegisterEvents() {
+      Folds.ValueChanged += new EventHandler(Folds_ValueChanged);
+      NumberOfWorkers.ValueChanged += new EventHandler(NumberOfWorkers_ValueChanged);
+      RegisterClonedAlgorithmsEvents();
+      RegisterRunsEvents();
+    }
+    private void Folds_ValueChanged(object sender, EventArgs e) {
+      if (ExecutionState != ExecutionState.Prepared)
+        throw new InvalidOperationException("Can not change number of folds if the execution state is not prepared.");
+    }
+    private void NumberOfWorkers_ValueChanged(object sender, EventArgs e) {
+      if (ExecutionState == ExecutionState.Started) {
+        int workers = numberOfWorkers.Value;
+        int runningWorkers = clonedAlgorithms.Count(alg => alg.ExecutionState == ExecutionState.Started);
+
+        foreach (IAlgorithm algorithm in clonedAlgorithms) {
+          if (algorithm.ExecutionState == ExecutionState.Prepared ||
+              algorithm.ExecutionState == ExecutionState.Paused) {
+            if (runningWorkers < workers) {
+              algorithm.Start();
+              runningWorkers++;
+            }
+          } else if (algorithm.ExecutionState == ExecutionState.Started) {
+            if (runningWorkers > workers) {
+              algorithm.Pause();
+              runningWorkers--;
+            }
+          }
+        }
+      }
+    }
+
+    #region template algorithms events
     public event EventHandler AlgorithmChanged;
     private void OnAlgorithmChanged() {
@@ -192,10 +322,13 @@
       if (handler != null) handler(this, EventArgs.Empty);
       OnProblemChanged();
+      if (Problem == null) ExecutionState = ExecutionState.Stopped;
     }
     private void RegisterAlgorithmEvents() {
       algorithm.ProblemChanged += new EventHandler(Algorithm_ProblemChanged);
+      algorithm.ExecutionStateChanged += new EventHandler(Algorithm_ExecutionStateChanged);
     }
     private void DeregisterAlgorithmEvents() {
       algorithm.ProblemChanged -= new EventHandler(Algorithm_ProblemChanged);
+      algorithm.ExecutionStateChanged -= new EventHandler(Algorithm_ExecutionStateChanged);
     }
     private void Algorithm_ProblemChanged(object sender, EventArgs e) {
@@ -218,8 +351,23 @@
     }
 
-    private void RegisterClonedAlgorithmEvents() {
+    private void Algorithm_ExecutionStateChanged(object sender, EventArgs e) {
+      switch (Algorithm.ExecutionState) {
+        case ExecutionState.Prepared: OnPrepared();
+          break;
+        case ExecutionState.Started: throw new InvalidOperationException("Algorithm template can not be started.");
+        case ExecutionState.Paused: throw new InvalidOperationException("Algorithm template can not be paused.");
+        case ExecutionState.Stopped: OnStopped();
+          break;
+      }
+    }
+    #endregion
+
+    #region clonedAlgorithms events
+    private void RegisterClonedAlgorithmsEvents() {
       clonedAlgorithms.ItemsAdded += new CollectionItemsChangedEventHandler<IAlgorithm>(ClonedAlgorithms_ItemsAdded);
       clonedAlgorithms.ItemsRemoved += new CollectionItemsChangedEventHandler<IAlgorithm>(ClonedAlgorithms_ItemsRemoved);
       clonedAlgorithms.CollectionReset += new CollectionItemsChangedEventHandler<IAlgorithm>(ClonedAlgorithms_CollectionReset);
+      foreach (IAlgorithm algorithm in clonedAlgorithms)
+        RegisterClonedAlgorithmEvents(algorithm);
     }
     private void ClonedAlgorithms_ItemsAdded(object sender, CollectionItemsChangedEventArgs<IAlgorithm> e) {
@@ -232,88 +380,72 @@
     }
     private void ClonedAlgorithms_CollectionReset(object sender, CollectionItemsChangedEventArgs<IAlgorithm> e) {
+      foreach (IAlgorithm algorithm in e.OldItems)
+        DeregisterClonedAlgorithmEvents(algorithm);
       foreach (IAlgorithm algorithm in e.Items)
         RegisterClonedAlgorithmEvents(algorithm);
-      foreach (IAlgorithm algorithm in e.OldItems)
-        DeregisterClonedAlgorithmEvents(algorithm);
     }
     private void RegisterClonedAlgorithmEvents(IAlgorithm algorithm) {
-      algorithm.ExceptionOccurred += new EventHandler<EventArgs<Exception>>(Algorithm_ExceptionOccurred);
-      algorithm.ExecutionTimeChanged += new EventHandler(Algorithm_ExecutionTimeChanged);
-      algorithm.Runs.ItemsAdded += new CollectionItemsChangedEventHandler<IRun>(Algorithm_Runs_Added);
-      algorithm.Paused += new EventHandler(Algorithm_Paused);
-      algorithm.Stopped += new EventHandler(Algorithm_Stopped);
+      algorithm.ExceptionOccurred += new EventHandler<EventArgs<Exception>>(ClonedAlgorithm_ExceptionOccurred);
+      algorithm.ExecutionTimeChanged += new EventHandler(ClonedAlgorithm_ExecutionTimeChanged);
+      algorithm.Started += new EventHandler(ClonedAlgorithm_Started);
+      algorithm.Paused += new EventHandler(ClonedAlgorithm_Paused);
+      algorithm.Stopped += new EventHandler(ClonedAlgorithm_Stopped);
     }
     private void DeregisterClonedAlgorithmEvents(IAlgorithm algorithm) {
-      algorithm.ExceptionOccurred -= new EventHandler<EventArgs<Exception>>(Algorithm_ExceptionOccurred);
-      algorithm.ExecutionTimeChanged += new EventHandler(Algorithm_ExecutionTimeChanged);
-      algorithm.Runs.ItemsAdded -= new CollectionItemsChangedEventHandler<IRun>(Algorithm_Runs_Added);
-      algorithm.Paused -= new EventHandler(Algorithm_Paused);
-      algorithm.Stopped -= new EventHandler(Algorithm_Stopped);
-    }
-    private void Algorithm_ExceptionOccurred(object sender, EventArgs<Exception> e) {
+      algorithm.ExceptionOccurred -= new EventHandler<EventArgs<Exception>>(ClonedAlgorithm_ExceptionOccurred);
+      algorithm.ExecutionTimeChanged -= new EventHandler(ClonedAlgorithm_ExecutionTimeChanged);
+      algorithm.Started -= new EventHandler(ClonedAlgorithm_Started);
+      algorithm.Paused -= new EventHandler(ClonedAlgorithm_Paused);
+      algorithm.Stopped -= new EventHandler(ClonedAlgorithm_Stopped);
+    }
+    private void ClonedAlgorithm_ExceptionOccurred(object sender, EventArgs<Exception> e) {
       OnExceptionOccurred(e.Value);
     }
-    private void Algorithm_ExecutionTimeChanged(object sender, EventArgs e) {
+    private void ClonedAlgorithm_ExecutionTimeChanged(object sender, EventArgs e) {
       OnExecutionTimeChanged();
     }
-    private void Algorithm_Runs_Added(object sender, CollectionItemsChangedEventArgs<IRun> e) {
-      throw new NotImplementedException("TODO added finished run to actual results if the cross validation is running");
-    }
-    private void Algorithm_Paused(object sender, EventArgs e) {
-      throw new NotImplementedException("TODO pause the cross validation if an algorithm no algorithm is running.");
-    }
-    private void Algorithm_Stopped(object sender, EventArgs e) {
-      throw new NotImplementedException("TODO stop the cross validation if all algorithms are stopped. and start remaining prepared algs");
-    }
-
-    public event EventHandler ExecutionStateChanged;
-    private void OnExecutionStateChanged() {
-      EventHandler handler = ExecutionStateChanged;
-      if (handler != null) handler(this, EventArgs.Empty);
-    }
-    public event EventHandler ExecutionTimeChanged;
-    private void OnExecutionTimeChanged() {
-      EventHandler handler = ExecutionTimeChanged;
-      if (handler != null) handler(this, EventArgs.Empty);
-    }
-    public event EventHandler Prepared;
-    private void OnPrepared() {
-      ExecutionState = ExecutionState.Prepared;
-      EventHandler handler = Prepared;
-      if (handler != null) handler(this, EventArgs.Empty);
-    }
-    public event EventHandler Started;
-    private void OnStarted() {
-      ExecutionState = ExecutionState.Started;
-      EventHandler handler = Started;
-      if (handler != null) handler(this, EventArgs.Empty);
-    }
-    public event EventHandler Paused;
-    private void OnPaused() {
-      ExecutionState = ExecutionState.Paused;
-      EventHandler handler = Paused;
-      if (handler != null) handler(this, EventArgs.Empty);
-    }
-    public event EventHandler Stopped;
-    private void OnStopped() {
-      ExecutionState = ExecutionState.Stopped;
-      EventHandler handler = Stopped;
-      if (handler != null) handler(this, EventArgs.Empty);
-    }
-    public event EventHandler<EventArgs<Exception>> ExceptionOccurred;
-    private void OnExceptionOccurred(Exception exception) {
-      EventHandler<EventArgs<Exception>> handler = ExceptionOccurred;
-      if (handler != null) handler(this, new EventArgs<Exception>(exception));
-    }
-
+
+    private readonly object locker = new object();
+    private void ClonedAlgorithm_Started(object sender, EventArgs e) {
+      lock (locker) {
+        if (startPending) {
+          int startedAlgorithms = clonedAlgorithms.Count(alg => alg.ExecutionState == ExecutionState.Started);
+          if (startedAlgorithms == NumberOfWorkers.Value ||
+             clonedAlgorithms.All(alg => alg.ExecutionState != ExecutionState.Prepared))
+            startPending = false;
+
+          if (pausePending) PauseAllClonedAlgorithms();
+          if (stopPending) StopAllClonedAlgorithms();
+        }
+      }
+    }
+
+    private void ClonedAlgorithm_Paused(object sender, EventArgs e) {
+      lock (locker) {
+        if (pausePending && clonedAlgorithms.All(alg => alg.ExecutionState != ExecutionState.Started))
+          OnPaused();
+      }
+    }
+
+    private void ClonedAlgorithm_Stopped(object sender, EventArgs e) {
+      lock (locker) {
+        if (!stopPending && ExecutionState == ExecutionState.Started) {
+          IAlgorithm preparedAlgorithm = clonedAlgorithms.Where(alg => alg.ExecutionState == ExecutionState.Prepared ||
+                                                                       alg.ExecutionState == ExecutionState.Paused).FirstOrDefault();
+          if (preparedAlgorithm != null) preparedAlgorithm.Start();
+        }
+        if (clonedAlgorithms.All(alg => alg.ExecutionState == ExecutionState.Stopped))
+          OnStopped();
+        else if (stopPending && clonedAlgorithms.All(alg => alg.ExecutionState == ExecutionState.Prepared || alg.ExecutionState == ExecutionState.Stopped))
+          OnStopped();
+      }
+    }
+    #endregion
+
+    #region run events
     private void RegisterRunsEvents() {
       runs.CollectionReset += new CollectionItemsChangedEventHandler<IRun>(Runs_CollectionReset);
       runs.ItemsAdded += new CollectionItemsChangedEventHandler<IRun>(Runs_ItemsAdded);
       runs.ItemsRemoved += new CollectionItemsChangedEventHandler<IRun>(Runs_ItemsRemoved);
-    }
-    private void DeregisterRunsEvents() {
-      runs.CollectionReset -= new CollectionItemsChangedEventHandler<IRun>(Runs_CollectionReset);
-      runs.ItemsAdded -= new CollectionItemsChangedEventHandler<IRun>(Runs_ItemsAdded);
-      runs.ItemsRemoved -= new CollectionItemsChangedEventHandler<IRun>(Runs_ItemsRemoved);
     }
     private void Runs_CollectionReset(object sender, CollectionItemsChangedEventArgs<IRun> e) {
@@ -348,4 +480,51 @@
     }
     #endregion
+    #endregion
+
+    #region event firing
+    public event EventHandler ExecutionStateChanged;
+    private void OnExecutionStateChanged() {
+      EventHandler handler = ExecutionStateChanged;
+      if (handler != null) handler(this, EventArgs.Empty);
+    }
+    public event EventHandler ExecutionTimeChanged;
+    private void OnExecutionTimeChanged() {
+      EventHandler handler = ExecutionTimeChanged;
+      if (handler != null) handler(this, EventArgs.Empty);
+    }
+    public event EventHandler Prepared;
+    private void OnPrepared() {
+      ExecutionState = ExecutionState.Prepared;
+      EventHandler handler = Prepared;
+      if (handler != null) handler(this, EventArgs.Empty);
+    }
+    public event EventHandler Started;
+    private void OnStarted() {
+      startPending = false;
+      ExecutionState = ExecutionState.Started;
+      EventHandler handler = Started;
+      if (handler != null) handler(this, EventArgs.Empty);
+    }
+    public event EventHandler Paused;
+    private void OnPaused() {
+      pausePending = false;
+      ExecutionState = ExecutionState.Paused;
+      EventHandler handler = Paused;
+      if (handler != null) handler(this, EventArgs.Empty);
+    }
+    public event EventHandler Stopped;
+    private void OnStopped() {
+      stopPending = false;
+      ExecutionState = ExecutionState.Stopped;
+      //TODO create run;
+      EventHandler handler = Stopped;
+      if (handler != null) handler(this, EventArgs.Empty);
+    }
+    public event EventHandler<EventArgs<Exception>> ExceptionOccurred;
+    private void OnExceptionOccurred(Exception exception) {
+      EventHandler<EventArgs<Exception>> handler = ExceptionOccurred;
+      if (handler != null) handler(this, new EventArgs<Exception>(exception));
+    }
+    #endregion
   }
 }
Index: branches/HeuristicLab.Classification/HeuristicLab.Algorithms.DataAnalysis/3.3/HeuristicLabAlgorithmsDataAnalysisPlugin.cs.frame
===================================================================
--- branches/HeuristicLab.Classification/HeuristicLab.Algorithms.DataAnalysis/3.3/HeuristicLabAlgorithmsDataAnalysisPlugin.cs.frame	(revision 4536)
+++ branches/HeuristicLab.Classification/HeuristicLab.Algorithms.DataAnalysis/3.3/HeuristicLabAlgorithmsDataAnalysisPlugin.cs.frame	(revision 4542)
@@ -26,5 +26,5 @@
   /// Plugin class for HeuristicLab.Algorithms.DataAnalysis plugin.
   /// </summary>
-  [Plugin("HeuristicLab.Algorithms.DataAnalysis", "3.3.0.$WCREV$")]
+  [Plugin("HeuristicLab.Algorithms.DataAnalysis", "3.3.1.$WCREV$")]
   [PluginFile("HeuristicLab.Algorithms.DataAnalysis-3.3.dll", PluginFileType.Assembly)]
   public class HeuristicLabAlgorithmsDataAnalysisPlugin : PluginBase {
Index: branches/HeuristicLab.Classification/HeuristicLab.Algorithms.DataAnalysis/3.3/Properties/AssemblyInfo.frame
===================================================================
--- branches/HeuristicLab.Classification/HeuristicLab.Algorithms.DataAnalysis/3.3/Properties/AssemblyInfo.frame	(revision 4536)
+++ branches/HeuristicLab.Classification/HeuristicLab.Algorithms.DataAnalysis/3.3/Properties/AssemblyInfo.frame	(revision 4542)
@@ -53,3 +53,3 @@
 // by using the '*' as shown below:
 [assembly: AssemblyVersion("3.3.0.0")]
-[assembly: AssemblyFileVersion("3.3.0.$WCREV$")]
+[assembly: AssemblyFileVersion("3.3.1.$WCREV$")]
