Index: branches/CloningRefactoring/HeuristicLab.Operators/3.3/AlgorithmOperator.cs
===================================================================
--- branches/CloningRefactoring/HeuristicLab.Operators/3.3/AlgorithmOperator.cs	(revision 4656)
+++ branches/CloningRefactoring/HeuristicLab.Operators/3.3/AlgorithmOperator.cs	(revision 4662)
@@ -44,13 +44,13 @@
     }
 
+    [StorableConstructor]
+    protected AlgorithmOperator(bool deserializing) : base(deserializing) { }
+    protected AlgorithmOperator(AlgorithmOperator original, Cloner cloner)
+      : base(original, cloner) {
+      this.operatorGraph = cloner.Clone<OperatorGraph>(original.operatorGraph);
+    }
     protected AlgorithmOperator()
       : base() {
       operatorGraph = new OperatorGraph();
-    }
-
-    public override IDeepCloneable Clone(Cloner cloner) {
-      AlgorithmOperator clone = (AlgorithmOperator)base.Clone(cloner);
-      clone.operatorGraph = (OperatorGraph)cloner.Clone(operatorGraph);
-      return clone;
     }
 
Index: branches/CloningRefactoring/HeuristicLab.Operators/3.3/Assigner.cs
===================================================================
--- branches/CloningRefactoring/HeuristicLab.Operators/3.3/Assigner.cs	(revision 4656)
+++ branches/CloningRefactoring/HeuristicLab.Operators/3.3/Assigner.cs	(revision 4662)
@@ -23,4 +23,5 @@
 using HeuristicLab.Parameters;
 using HeuristicLab.Persistence.Default.CompositeSerializers.Storable;
+using HeuristicLab.Common;
 
 namespace HeuristicLab.Operators {
@@ -38,8 +39,17 @@
     }
 
+    [StorableConstructor]
+    private Assigner(bool deserializing) : base(deserializing) { }
+    private Assigner(Assigner original, Cloner cloner)
+      : base(original, cloner) {
+    }
     public Assigner()
       : base() {
       Parameters.Add(new LookupParameter<IItem>("LeftSide", "The parameter whose value gets assigned with a clone of the other parameter's value."));
       Parameters.Add(new ValueLookupParameter<IItem>("RightSide", "The parameter whose value is cloned and assigned to the value of the other parameter."));
+    }
+
+    public override IDeepCloneable Clone(Cloner cloner) {
+      return new Assigner(this, cloner);
     }
 
Index: branches/CloningRefactoring/HeuristicLab.Operators/3.3/CheckedMultiOperator.cs
===================================================================
--- branches/CloningRefactoring/HeuristicLab.Operators/3.3/CheckedMultiOperator.cs	(revision 4656)
+++ branches/CloningRefactoring/HeuristicLab.Operators/3.3/CheckedMultiOperator.cs	(revision 4662)
@@ -22,4 +22,5 @@
 using HeuristicLab.Core;
 using HeuristicLab.Persistence.Default.CompositeSerializers.Storable;
+using HeuristicLab.Common;
 
 namespace HeuristicLab.Operators {
@@ -37,4 +38,10 @@
       protected set { base.Operators = value; }
     }
+
+    [StorableConstructor]
+    protected CheckedMultiOperator(bool deserializing) : base(deserializing) { }
+    protected CheckedMultiOperator(CheckedMultiOperator<T> original, Cloner cloner)
+      : base(original, cloner) {
+    }
     /// <summary>
     /// Creates a new instance of CheckedMultiOperator
@@ -44,6 +51,4 @@
       Operators = new CheckedItemList<T>();
     }
-    [StorableConstructor]
-    protected CheckedMultiOperator(bool deserializing) : base(deserializing) { }
   }
 }
Index: branches/CloningRefactoring/HeuristicLab.Operators/3.3/CombinedOperator.cs
===================================================================
--- branches/CloningRefactoring/HeuristicLab.Operators/3.3/CombinedOperator.cs	(revision 4656)
+++ branches/CloningRefactoring/HeuristicLab.Operators/3.3/CombinedOperator.cs	(revision 4662)
@@ -43,5 +43,14 @@
     }
 
+    [StorableConstructor]
+    private CombinedOperator(bool deserializing) : base(deserializing) { }
+    private CombinedOperator(CombinedOperator original, Cloner cloner)
+      : base(original, cloner) {
+    }
     public CombinedOperator() : base() { }
+
+    public override IDeepCloneable Clone(Cloner cloner) {
+      return new CombinedOperator(this, cloner);
+    }
   }
 }
Index: branches/CloningRefactoring/HeuristicLab.Operators/3.3/Comparator.cs
===================================================================
--- branches/CloningRefactoring/HeuristicLab.Operators/3.3/Comparator.cs	(revision 4656)
+++ branches/CloningRefactoring/HeuristicLab.Operators/3.3/Comparator.cs	(revision 4662)
@@ -25,4 +25,5 @@
 using HeuristicLab.Parameters;
 using HeuristicLab.Persistence.Default.CompositeSerializers.Storable;
+using HeuristicLab.Common;
 
 namespace HeuristicLab.Operators {
@@ -50,4 +51,9 @@
     }
 
+    [StorableConstructor]
+    private Comparator(bool deserializing) : base(deserializing) { }
+    private Comparator(Comparator original, Cloner cloner)
+      : base(original, cloner) {
+    }
     public Comparator()
       : base() {
@@ -56,4 +62,8 @@
       Parameters.Add(new ValueParameter<Comparison>("Comparison", "The type of comparison.", new Comparison(Data.ComparisonType.Equal)));
       Parameters.Add(new LookupParameter<BoolValue>("Result", "The result of the comparison."));
+    }
+
+    public override IDeepCloneable Clone(Cloner cloner) {
+      return new Comparator(this, cloner);
     }
 
Index: branches/CloningRefactoring/HeuristicLab.Operators/3.3/ConditionalBranch.cs
===================================================================
--- branches/CloningRefactoring/HeuristicLab.Operators/3.3/ConditionalBranch.cs	(revision 4656)
+++ branches/CloningRefactoring/HeuristicLab.Operators/3.3/ConditionalBranch.cs	(revision 4662)
@@ -24,4 +24,5 @@
 using HeuristicLab.Parameters;
 using HeuristicLab.Persistence.Default.CompositeSerializers.Storable;
+using HeuristicLab.Common;
 
 namespace HeuristicLab.Operators {
@@ -50,4 +51,9 @@
     }
 
+    [StorableConstructor]
+    protected ConditionalBranch(bool deserializing) : base(deserializing) { }
+    protected ConditionalBranch(ConditionalBranch original, Cloner cloner)
+      : base(original, cloner) {
+    }
     public ConditionalBranch()
       : base() {
@@ -55,4 +61,8 @@
       Parameters.Add(new OperatorParameter("TrueBranch", "The operator which is executed if the condition is true."));
       Parameters.Add(new OperatorParameter("FalseBranch", "The operator which is executed if the condition is false."));
+    }
+
+    public override IDeepCloneable Clone(Cloner cloner) {
+      return new ConditionalBranch(this, cloner);
     }
 
Index: branches/CloningRefactoring/HeuristicLab.Operators/3.3/DoubleCounter.cs
===================================================================
--- branches/CloningRefactoring/HeuristicLab.Operators/3.3/DoubleCounter.cs	(revision 4656)
+++ branches/CloningRefactoring/HeuristicLab.Operators/3.3/DoubleCounter.cs	(revision 4662)
@@ -24,4 +24,5 @@
 using HeuristicLab.Parameters;
 using HeuristicLab.Persistence.Default.CompositeSerializers.Storable;
+using HeuristicLab.Common;
 
 namespace HeuristicLab.Operators {
@@ -43,8 +44,17 @@
     }
 
+    [StorableConstructor]
+    private DoubleCounter(bool deserializing) : base(deserializing) { }
+    private DoubleCounter(DoubleCounter original, Cloner cloner)
+      : base(original, cloner) {
+    }
     public DoubleCounter()
       : base() {
       Parameters.Add(new LookupParameter<DoubleValue>("Value", "The value which should be incremented."));
       Parameters.Add(new ValueLookupParameter<DoubleValue>("Increment", "The increment which is added to the value.", new DoubleValue(1)));
+    }
+
+    public override IDeepCloneable Clone(Cloner cloner) {
+      return new DoubleCounter(this, cloner);
     }
 
Index: branches/CloningRefactoring/HeuristicLab.Operators/3.3/EmptyOperator.cs
===================================================================
--- branches/CloningRefactoring/HeuristicLab.Operators/3.3/EmptyOperator.cs	(revision 4656)
+++ branches/CloningRefactoring/HeuristicLab.Operators/3.3/EmptyOperator.cs	(revision 4662)
@@ -22,4 +22,5 @@
 using HeuristicLab.Core;
 using HeuristicLab.Persistence.Default.CompositeSerializers.Storable;
+using HeuristicLab.Common;
 
 namespace HeuristicLab.Operators {
@@ -30,7 +31,16 @@
   [StorableClass]
   public sealed class EmptyOperator : SingleSuccessorOperator {
+    [StorableConstructor]
+    private EmptyOperator(bool deserializing) : base(deserializing) { }
+    private EmptyOperator(EmptyOperator original, Cloner cloner)
+      : base(original, cloner) {
+    }
     public EmptyOperator()
       : base() {
     }
+
+    public override IDeepCloneable Clone(Cloner cloner) {
+      return new EmptyOperator(this, cloner);
+    }
   }
 }
Index: branches/CloningRefactoring/HeuristicLab.Operators/3.3/IntCounter.cs
===================================================================
--- branches/CloningRefactoring/HeuristicLab.Operators/3.3/IntCounter.cs	(revision 4656)
+++ branches/CloningRefactoring/HeuristicLab.Operators/3.3/IntCounter.cs	(revision 4662)
@@ -24,4 +24,5 @@
 using HeuristicLab.Parameters;
 using HeuristicLab.Persistence.Default.CompositeSerializers.Storable;
+using HeuristicLab.Common;
 
 namespace HeuristicLab.Operators {
@@ -43,8 +44,17 @@
     }
 
+    [StorableConstructor]
+    private IntCounter(bool deserializing) : base(deserializing) { }
+    private IntCounter(IntCounter original, Cloner cloner)
+      : base(original, cloner) {
+    }
     public IntCounter()
       : base() {
       Parameters.Add(new LookupParameter<IntValue>("Value", "The value which should be incremented."));
       Parameters.Add(new ValueLookupParameter<IntValue>("Increment", "The increment which is added to the value.", new IntValue(1)));
+    }
+
+    public override IDeepCloneable Clone(Cloner cloner) {
+      return new IntCounter(this, cloner);
     }
 
Index: branches/CloningRefactoring/HeuristicLab.Operators/3.3/MultiOperator.cs
===================================================================
--- branches/CloningRefactoring/HeuristicLab.Operators/3.3/MultiOperator.cs	(revision 4656)
+++ branches/CloningRefactoring/HeuristicLab.Operators/3.3/MultiOperator.cs	(revision 4662)
@@ -51,4 +51,11 @@
     }
 
+    [StorableConstructor]
+    protected MultiOperator(bool deserializing) : base(deserializing) { }
+    protected MultiOperator(MultiOperator<T> original, Cloner cloner)
+      : base(original, cloner) {
+      this.operators = cloner.Clone<IItemList<T>>(original.operators);
+      Initialize();
+    }
     public MultiOperator()
       : base() {
@@ -57,8 +64,9 @@
     }
 
-    [StorableConstructor]
-    protected MultiOperator(bool deserializing) : base(deserializing) { }
-
     [StorableHook(HookType.AfterDeserialization)]
+    private void AfterDeserialization() {
+      Initialize();
+    }
+    
     private void Initialize() {
       if (operators != null) RegisterOperatorsEvents();
@@ -69,11 +77,4 @@
         opParam.ValueChanged += new EventHandler(opParam_ValueChanged);
       }
-    }
-
-    public override IDeepCloneable Clone(Cloner cloner) {
-      MultiOperator<T> clone = (MultiOperator<T>)base.Clone(cloner);
-      clone.operators = (IItemList<T>)cloner.Clone(operators);
-      clone.Initialize();
-      return clone;
     }
 
Index: branches/CloningRefactoring/HeuristicLab.Operators/3.3/Operator.cs
===================================================================
--- branches/CloningRefactoring/HeuristicLab.Operators/3.3/Operator.cs	(revision 4656)
+++ branches/CloningRefactoring/HeuristicLab.Operators/3.3/Operator.cs	(revision 4662)
@@ -85,4 +85,12 @@
     }
 
+    [StorableConstructor]
+    protected Operator(bool deserializing) : base(deserializing) { }
+    protected Operator(Operator original, Cloner cloner)
+      : base(original, cloner) {
+      this.canceled = original.canceled;
+      this.breakpoint = original.breakpoint;
+      this.executionContext = cloner.Clone<IExecutionContext>(original.executionContext);
+    }
     /// <summary>
     /// Initializes a new instance of <see cref="OperatorBase"/> setting the breakpoint flag and 
@@ -113,20 +121,4 @@
       canceled = false;
       breakpoint = false;
-    }
-    [StorableConstructor]
-    protected Operator(bool deserializing) : base(deserializing) { }
-
-    /// <summary>
-    /// Clones the current instance (deep clone).
-    /// </summary>
-    /// <remarks>Clones also sub operators, variables and variable infos.</remarks>
-    /// <param name="clonedObjects">Dictionary of all already cloned objects. (Needed to avoid cycles.)</param>
-    /// <returns>The cloned object as <see cref="OperatorBase"/>.</returns>
-    public override IDeepCloneable Clone(Cloner cloner) {
-      Operator clone = (Operator)base.Clone(cloner);
-      clone.canceled = canceled;
-      clone.breakpoint = breakpoint;
-      clone.executionContext = (IExecutionContext)cloner.Clone(executionContext);
-      return clone;
     }
 
Index: branches/CloningRefactoring/HeuristicLab.Operators/3.3/Placeholder.cs
===================================================================
--- branches/CloningRefactoring/HeuristicLab.Operators/3.3/Placeholder.cs	(revision 4656)
+++ branches/CloningRefactoring/HeuristicLab.Operators/3.3/Placeholder.cs	(revision 4662)
@@ -23,4 +23,5 @@
 using HeuristicLab.Parameters;
 using HeuristicLab.Persistence.Default.CompositeSerializers.Storable;
+using HeuristicLab.Common;
 
 namespace HeuristicLab.Operators {
@@ -35,7 +36,16 @@
     }
 
+    [StorableConstructor]
+    private Placeholder(bool deserializing) : base(deserializing) { }
+    private Placeholder(Placeholder original, Cloner cloner)
+      : base(original, cloner) {
+    }
     public Placeholder()
       : base() {
       Parameters.Add(new LookupParameter<IOperator>("Operator", "The operator which is retrieved from the scope or a parent execution context and applied on the current scope."));
+    }
+
+    public override IDeepCloneable Clone(Cloner cloner) {
+      return new Placeholder(this, cloner);
     }
 
Index: branches/CloningRefactoring/HeuristicLab.Operators/3.3/ScopeCleaner.cs
===================================================================
--- branches/CloningRefactoring/HeuristicLab.Operators/3.3/ScopeCleaner.cs	(revision 4656)
+++ branches/CloningRefactoring/HeuristicLab.Operators/3.3/ScopeCleaner.cs	(revision 4662)
@@ -23,4 +23,5 @@
 using HeuristicLab.Parameters;
 using HeuristicLab.Persistence.Default.CompositeSerializers.Storable;
+using HeuristicLab.Common;
 
 namespace HeuristicLab.Operators {
@@ -38,7 +39,16 @@
     }
 
+    [StorableConstructor]
+    private ScopeCleaner(bool deserializing) : base(deserializing) { }
+    private ScopeCleaner(ScopeCleaner original, Cloner cloner)
+      : base(original, cloner) {
+    }
     public ScopeCleaner()
       : base() {
       Parameters.Add(new ScopeParameter("CurrentScope", "The current scope whose variables and sub-scopes should be removed."));
+    }
+
+    public override IDeepCloneable Clone(Cloner cloner) {
+      return new ScopeCleaner(this, cloner);
     }
 
Index: branches/CloningRefactoring/HeuristicLab.Operators/3.3/SingleSuccessorOperator.cs
===================================================================
--- branches/CloningRefactoring/HeuristicLab.Operators/3.3/SingleSuccessorOperator.cs	(revision 4656)
+++ branches/CloningRefactoring/HeuristicLab.Operators/3.3/SingleSuccessorOperator.cs	(revision 4662)
@@ -23,4 +23,5 @@
 using HeuristicLab.Parameters;
 using HeuristicLab.Persistence.Default.CompositeSerializers.Storable;
+using HeuristicLab.Common;
 
 namespace HeuristicLab.Operators {
@@ -39,11 +40,14 @@
     }
 
+    [StorableConstructor]
+    protected SingleSuccessorOperator(bool deserializing) : base(deserializing) { }
+    protected SingleSuccessorOperator(SingleSuccessorOperator original, Cloner cloner)
+      : base(original, cloner) {
+    }
     public SingleSuccessorOperator()
       : base() {
       Parameters.Add(new OperatorParameter("Successor", "Operator which is executed next."));
     }
-    [StorableConstructor]
-    protected SingleSuccessorOperator(bool deserializing) : base(deserializing) { }
-
+    
     public override IOperation Apply() {
       if (Successor != null)
Index: branches/CloningRefactoring/HeuristicLab.Operators/3.3/StochasticBranch.cs
===================================================================
--- branches/CloningRefactoring/HeuristicLab.Operators/3.3/StochasticBranch.cs	(revision 4656)
+++ branches/CloningRefactoring/HeuristicLab.Operators/3.3/StochasticBranch.cs	(revision 4662)
@@ -24,4 +24,5 @@
 using HeuristicLab.Parameters;
 using HeuristicLab.Persistence.Default.CompositeSerializers.Storable;
+using HeuristicLab.Common;
 
 namespace HeuristicLab.Operators {
@@ -53,4 +54,9 @@
     }
 
+    [StorableConstructor]
+    protected StochasticBranch(bool deserializing) : base(deserializing) { }
+    protected StochasticBranch(StochasticBranch original, Cloner cloner)
+      : base(original, cloner) {
+    }
     public StochasticBranch()
       : base() {
@@ -59,4 +65,8 @@
       Parameters.Add(new OperatorParameter("FirstBranch", "The operator which is executed with the given probability."));
       Parameters.Add(new OperatorParameter("SecondBranch", "The operator which is executed if the first branch is not executed."));
+    }
+
+    public override IDeepCloneable Clone(Cloner cloner) {
+      return new StochasticBranch(this, cloner);
     }
 
Index: branches/CloningRefactoring/HeuristicLab.Operators/3.3/StochasticMultiBranch.cs
===================================================================
--- branches/CloningRefactoring/HeuristicLab.Operators/3.3/StochasticMultiBranch.cs	(revision 4656)
+++ branches/CloningRefactoring/HeuristicLab.Operators/3.3/StochasticMultiBranch.cs	(revision 4662)
@@ -28,4 +28,5 @@
 using HeuristicLab.Parameters;
 using HeuristicLab.Persistence.Default.CompositeSerializers.Storable;
+using HeuristicLab.Common;
 
 namespace HeuristicLab.Operators {
@@ -56,4 +57,7 @@
     [StorableConstructor]
     protected StochasticMultiBranch(bool deserializing) : base(deserializing) { }
+    protected StochasticMultiBranch(StochasticMultiBranch<T> original, Cloner cloner)
+      : base(original, cloner) {
+    }
     /// <summary>
     /// Initializes a new instance of <see cref="StochasticMultiOperator"/> with two parameters
@@ -143,4 +147,15 @@
   [StorableClass]
   public class StochasticMultiBranch : StochasticMultiBranch<IOperator> {
+    [StorableConstructor]
+    protected StochasticMultiBranch(bool deserializing) : base(deserializing) { }
+    protected StochasticMultiBranch(StochasticMultiBranch original, Cloner cloner)
+      : base(original, cloner) {
+    }
+    public StochasticMultiBranch() { }
+
+    public override IDeepCloneable Clone(Cloner cloner) {
+      return new StochasticMultiBranch(this, cloner);
+    }
+
     protected override bool CreateChildOperation {
       get { return false; }
Index: branches/CloningRefactoring/HeuristicLab.Operators/3.3/SubScopesCreator.cs
===================================================================
--- branches/CloningRefactoring/HeuristicLab.Operators/3.3/SubScopesCreator.cs	(revision 4656)
+++ branches/CloningRefactoring/HeuristicLab.Operators/3.3/SubScopesCreator.cs	(revision 4662)
@@ -24,4 +24,5 @@
 using HeuristicLab.Parameters;
 using HeuristicLab.Persistence.Default.CompositeSerializers.Storable;
+using HeuristicLab.Common;
 
 namespace HeuristicLab.Operators {
@@ -42,8 +43,17 @@
     }
 
+    [StorableConstructor]
+    protected SubScopesCreator(bool deserializing) : base(deserializing) { }
+    protected SubScopesCreator(SubScopesCreator original, Cloner cloner)
+      : base(original, cloner) {
+    }
     public SubScopesCreator()
       : base() {
       Parameters.Add(new ValueLookupParameter<IntValue>("NumberOfSubScopes", "The number of new and empty sub-scopes which should be added to the current scope."));
       Parameters.Add(new ScopeParameter("CurrentScope", "The current scope to which the new and empty sub-scopes are added."));
+    }
+
+    public override IDeepCloneable Clone(Cloner cloner) {
+      return new SubScopesCreator(this, cloner);
     }
 
Index: branches/CloningRefactoring/HeuristicLab.Operators/3.3/SubScopesMixer.cs
===================================================================
--- branches/CloningRefactoring/HeuristicLab.Operators/3.3/SubScopesMixer.cs	(revision 4656)
+++ branches/CloningRefactoring/HeuristicLab.Operators/3.3/SubScopesMixer.cs	(revision 4662)
@@ -25,4 +25,5 @@
 using HeuristicLab.Parameters;
 using HeuristicLab.Persistence.Default.CompositeSerializers.Storable;
+using HeuristicLab.Common;
 
 namespace HeuristicLab.Operators {
@@ -42,4 +43,9 @@
     }
 
+    [StorableConstructor]
+    protected SubScopesMixer(bool deserializing) : base(deserializing) { }
+    protected SubScopesMixer(SubScopesMixer original, Cloner cloner)
+      : base(original, cloner) {
+    }
     /// <summary>
     /// Initializes a new instance of <see cref="SubScopesMixer"/> with one variable infos 
@@ -49,4 +55,8 @@
       : base() {
       Parameters.Add(new ValueParameter<IntValue>("Partitions", "The number of equal-sized partitions.", new IntValue(2)));
+    }
+
+    public override IDeepCloneable Clone(Cloner cloner) {
+      return new SubScopesMixer(this, cloner);
     }
 
Index: branches/CloningRefactoring/HeuristicLab.Operators/3.3/SubScopesProcessor.cs
===================================================================
--- branches/CloningRefactoring/HeuristicLab.Operators/3.3/SubScopesProcessor.cs	(revision 4656)
+++ branches/CloningRefactoring/HeuristicLab.Operators/3.3/SubScopesProcessor.cs	(revision 4662)
@@ -27,4 +27,5 @@
 using HeuristicLab.Parameters;
 using HeuristicLab.Persistence.Default.CompositeSerializers.Storable;
+using HeuristicLab.Common;
 
 namespace HeuristicLab.Operators {
@@ -51,8 +52,17 @@
     }
 
+    [StorableConstructor]
+    private SubScopesProcessor(bool deserializing) : base(deserializing) { }
+    private SubScopesProcessor(SubScopesProcessor original, Cloner cloner)
+      : base(original, cloner) {
+    }
     public SubScopesProcessor()
       : base() {
       Parameters.Add(new ValueLookupParameter<BoolValue>("Parallel", "True if the operators should be applied in parallel on the sub-scopes, otherwise false.", new BoolValue(false)));
       Parameters.Add(new ValueParameter<IntValue>("Depth", "The number of steps to descend in the scope tree before applying operator.", new IntValue(1)));
+    }
+
+    public override IDeepCloneable Clone(Cloner cloner) {
+      return new SubScopesProcessor(this, cloner);
     }
 
Index: branches/CloningRefactoring/HeuristicLab.Operators/3.3/SubScopesRemover.cs
===================================================================
--- branches/CloningRefactoring/HeuristicLab.Operators/3.3/SubScopesRemover.cs	(revision 4656)
+++ branches/CloningRefactoring/HeuristicLab.Operators/3.3/SubScopesRemover.cs	(revision 4662)
@@ -24,4 +24,5 @@
 using HeuristicLab.Parameters;
 using HeuristicLab.Persistence.Default.CompositeSerializers.Storable;
+using HeuristicLab.Common;
 
 namespace HeuristicLab.Operators {
@@ -50,4 +51,9 @@
     }
 
+    [StorableConstructor]
+    private SubScopesRemover(bool deserializing) : base(deserializing) { }
+    private SubScopesRemover(SubScopesRemover original, Cloner cloner)
+      : base(original, cloner) {
+    }
     public SubScopesRemover()
       : base() {
@@ -55,4 +61,8 @@
       Parameters.Add(new ValueLookupParameter<IntValue>("SubScopeIndex", "The index of the sub-scope which should be removed. This parameter is ignored, if RemoveAllSubScopes is true."));
       Parameters.Add(new ScopeParameter("CurrentScope", "The current scope from which one or all sub-scopes should be removed."));
+    }
+
+    public override IDeepCloneable Clone(Cloner cloner) {
+      return new SubScopesRemover(this, cloner);
     }
 
Index: branches/CloningRefactoring/HeuristicLab.Operators/3.3/SubScopesSorter.cs
===================================================================
--- branches/CloningRefactoring/HeuristicLab.Operators/3.3/SubScopesSorter.cs	(revision 4656)
+++ branches/CloningRefactoring/HeuristicLab.Operators/3.3/SubScopesSorter.cs	(revision 4662)
@@ -24,4 +24,5 @@
 using HeuristicLab.Parameters;
 using HeuristicLab.Persistence.Default.CompositeSerializers.Storable;
+using HeuristicLab.Common;
 
 namespace HeuristicLab.Operators {
@@ -48,4 +49,9 @@
     }
 
+    [StorableConstructor]
+    private SubScopesSorter(bool deserializing) : base(deserializing) { }
+    private SubScopesSorter(SubScopesSorter original, Cloner cloner)
+      : base(original, cloner) {
+    }
     public SubScopesSorter()
       : base() {
@@ -53,4 +59,8 @@
       Parameters.Add(new ValueLookupParameter<BoolValue>("Descending", "True if the sub-scopes should be sorted in descending order, otherwise false."));
       Parameters.Add(new ScopeParameter("CurrentScope", "The current scope whose sub-scopes are sorted."));
+    }
+
+    public override IDeepCloneable Clone(Cloner cloner) {
+      return new SubScopesSorter(this, cloner);
     }
 
Index: branches/CloningRefactoring/HeuristicLab.Operators/3.3/UniformSubScopesProcessor.cs
===================================================================
--- branches/CloningRefactoring/HeuristicLab.Operators/3.3/UniformSubScopesProcessor.cs	(revision 4656)
+++ branches/CloningRefactoring/HeuristicLab.Operators/3.3/UniformSubScopesProcessor.cs	(revision 4662)
@@ -26,4 +26,5 @@
 using HeuristicLab.Parameters;
 using HeuristicLab.Persistence.Default.CompositeSerializers.Storable;
+using HeuristicLab.Common;
 
 namespace HeuristicLab.Operators {
@@ -57,4 +58,9 @@
     }
 
+    [StorableConstructor]
+    private UniformSubScopesProcessor(bool deserializing) : base(deserializing) { }
+    private UniformSubScopesProcessor(UniformSubScopesProcessor original, Cloner cloner)
+      : base(original, cloner) {
+    }
     public UniformSubScopesProcessor()
       : base() {
@@ -62,4 +68,8 @@
       Parameters.Add(new ValueLookupParameter<BoolValue>("Parallel", "True if the operator should be applied in parallel on all sub-scopes, otherwise false.", new BoolValue(false)));
       Parameters.Add(new ValueParameter<IntValue>("Depth", "The number of steps to descend in the scope tree before applying operator.", new IntValue(1)));
+    }
+
+    public override IDeepCloneable Clone(Cloner cloner) {
+      return new UniformSubScopesProcessor(this, cloner);
     }
 
Index: branches/CloningRefactoring/HeuristicLab.Operators/3.3/ValuesCollector.cs
===================================================================
--- branches/CloningRefactoring/HeuristicLab.Operators/3.3/ValuesCollector.cs	(revision 4656)
+++ branches/CloningRefactoring/HeuristicLab.Operators/3.3/ValuesCollector.cs	(revision 4662)
@@ -38,4 +38,11 @@
     }
 
+    [StorableConstructor]
+    protected ValuesCollector(bool deserializing) : base(deserializing) { }
+    protected ValuesCollector(ValuesCollector original, Cloner cloner)
+      : base(original, cloner) {
+      this.collectedValues = cloner.Clone<ParameterCollection>(original.collectedValues);
+      Initialize();
+    }
     public ValuesCollector()
       : base() {
@@ -43,19 +50,14 @@
       Initialize();
     }
-    [StorableConstructor]
-    protected ValuesCollector(bool deserializing) : base(deserializing) { }
 
     [StorableHook(HookType.AfterDeserialization)]
+    private void AfterDeserialization() {
+      Initialize();
+    }
+
     private void Initialize() {
       collectedValues.ItemsAdded += new CollectionItemsChangedEventHandler<IParameter>(collectedValues_ItemsAdded);
       collectedValues.ItemsRemoved += new CollectionItemsChangedEventHandler<IParameter>(collectedValues_ItemsRemoved);
       collectedValues.CollectionReset += new CollectionItemsChangedEventHandler<IParameter>(collectedValues_CollectionReset);
-    }
-
-    public override IDeepCloneable Clone(Cloner cloner) {
-      ValuesCollector clone = (ValuesCollector)base.Clone(cloner);
-      clone.collectedValues = (ParameterCollection)cloner.Clone(collectedValues);
-      clone.Initialize();
-      return clone;
     }
 
Index: branches/CloningRefactoring/HeuristicLab.Operators/3.3/VariableCreator.cs
===================================================================
--- branches/CloningRefactoring/HeuristicLab.Operators/3.3/VariableCreator.cs	(revision 4656)
+++ branches/CloningRefactoring/HeuristicLab.Operators/3.3/VariableCreator.cs	(revision 4662)
@@ -23,4 +23,5 @@
 using HeuristicLab.Parameters;
 using HeuristicLab.Persistence.Default.CompositeSerializers.Storable;
+using HeuristicLab.Common;
 
 namespace HeuristicLab.Operators {
@@ -38,7 +39,16 @@
     }
 
+    [StorableConstructor]
+    protected VariableCreator(bool deserializing) : base(deserializing) { }
+    protected VariableCreator(VariableCreator original, Cloner cloner)
+      : base(original, cloner) {
+    }
     public VariableCreator()
       : base() {
       Parameters.Add(new ScopeParameter("CurrentScope", "The current scope into which the parameter values are cloned."));
+    }
+
+    public override IDeepCloneable Clone(Cloner cloner) {
+      return new VariableCreator(this, cloner);
     }
 
