Index: /branches/2521_ProblemRefactoring/HeuristicLab.Encodings.BinaryVectorEncoding/3.3/BinaryVectorEncoding.cs
===================================================================
--- /branches/2521_ProblemRefactoring/HeuristicLab.Encodings.BinaryVectorEncoding/3.3/BinaryVectorEncoding.cs	(revision 17543)
+++ /branches/2521_ProblemRefactoring/HeuristicLab.Encodings.BinaryVectorEncoding/3.3/BinaryVectorEncoding.cs	(revision 17544)
@@ -22,5 +22,7 @@
 using System;
 using System.Collections.Generic;
+using System.ComponentModel;
 using System.Linq;
+using HEAL.Attic;
 using HeuristicLab.Common;
 using HeuristicLab.Core;
@@ -28,5 +30,4 @@
 using HeuristicLab.Optimization;
 using HeuristicLab.Parameters;
-using HEAL.Attic;
 using HeuristicLab.PluginInfrastructure;
 
@@ -34,26 +35,15 @@
   [Item("BinaryVectorEncoding", "Describes a binary vector encoding.")]
   [StorableType("889C5E1A-3FBF-4AB3-AB2E-199A781503B5")]
-  public sealed class BinaryVectorEncoding : Encoding<BinaryVector> {
+  public sealed class BinaryVectorEncoding : Encoding<BinaryVector>, INotifyPropertyChanged {
     #region Encoding Parameters
-    [Storable]
-    private IFixedValueParameter<IntValue> lengthParameter;
-    public IFixedValueParameter<IntValue> LengthParameter {
-      get { return lengthParameter; }
-      set {
-        if (value == null) throw new ArgumentNullException("Length parameter must not be null.");
-        if (value.Value == null) throw new ArgumentNullException("Length parameter value must not be null.");
-        if (lengthParameter == value) return;
-
-        if (lengthParameter != null) Parameters.Remove(lengthParameter);
-        lengthParameter = value;
-        Parameters.Add(lengthParameter);
-        OnLengthParameterChanged();
-      }
-    }
+    [Storable] public IValueParameter<IntValue> LengthParameter { get; private set; }
     #endregion
 
     public int Length {
       get { return LengthParameter.Value.Value; }
-      set { LengthParameter.Value.Value = value; }
+      set {
+        if (Length == value) return;
+        LengthParameter.ForceValue(new IntValue(value, @readonly: LengthParameter.Value.ReadOnly));
+      }
     }
 
@@ -62,12 +52,12 @@
     [StorableHook(HookType.AfterDeserialization)]
     private void AfterDeserialization() {
-      RegisterParameterEvents();
       DiscoverOperators();
+      RegisterEventHandlers();
     }
     public override IDeepCloneable Clone(Cloner cloner) { return new BinaryVectorEncoding(this, cloner); }
     private BinaryVectorEncoding(BinaryVectorEncoding original, Cloner cloner)
       : base(original, cloner) {
-      lengthParameter = cloner.Clone(original.lengthParameter);
-      RegisterParameterEvents();
+      LengthParameter = cloner.Clone(original.LengthParameter);
+      RegisterEventHandlers();
     }
 
@@ -77,26 +67,22 @@
     public BinaryVectorEncoding(string name, int length)
       : base(name) {
-      lengthParameter = new FixedValueParameter<IntValue>(Name + ".Length", new IntValue(length));
-      Parameters.Add(lengthParameter);
+      Parameters.Add(LengthParameter = new ValueParameter<IntValue>(Name + ".Length", new IntValue(length, @readonly: true)) { ReadOnly = true });
+      
+      SolutionCreator = new RandomBinaryVectorCreator();
+      DiscoverOperators();
 
-      SolutionCreator = new RandomBinaryVectorCreator();
-      RegisterParameterEvents();
-      DiscoverOperators();
+      RegisterEventHandlers();
     }
 
-    private void OnLengthParameterChanged() {
-      RegisterLengthParameterEvents();
-      ConfigureOperators(Operators);
-    }
-    private void RegisterParameterEvents() {
-      RegisterLengthParameterEvents();
-    }
-    private void RegisterLengthParameterEvents() {
-      LengthParameter.ValueChanged += (o, s) => ConfigureOperators(Operators);
-      LengthParameter.Value.ValueChanged += (o, s) => ConfigureOperators(Operators);
+    private void RegisterEventHandlers() {
+      LengthParameter.ValueChanged += (_, __) => {
+        if (!LengthParameter.Value.ReadOnly) LengthParameter.Value.ValueChanged += (___, ____) => OnPropertyChanged(nameof(Length));
+        OnPropertyChanged(nameof(Length));
+      };
     }
 
     #region Operator Discovery
     private static readonly IEnumerable<Type> encodingSpecificOperatorTypes;
+
     static BinaryVectorEncoding() {
       encodingSpecificOperatorTypes = new List<Type>() {
@@ -169,4 +155,9 @@
     }
     #endregion
+
+    public event PropertyChangedEventHandler PropertyChanged;
+    private void OnPropertyChanged(string property) {
+      PropertyChanged?.Invoke(this, new PropertyChangedEventArgs(property));
+    }
   }
 }
Index: /branches/2521_ProblemRefactoring/HeuristicLab.Encodings.BinaryVectorEncoding/3.3/BinaryVectorMultiObjectiveProblem.cs
===================================================================
--- /branches/2521_ProblemRefactoring/HeuristicLab.Encodings.BinaryVectorEncoding/3.3/BinaryVectorMultiObjectiveProblem.cs	(revision 17543)
+++ /branches/2521_ProblemRefactoring/HeuristicLab.Encodings.BinaryVectorEncoding/3.3/BinaryVectorMultiObjectiveProblem.cs	(revision 17544)
@@ -26,5 +26,7 @@
 using HeuristicLab.Common;
 using HeuristicLab.Core;
+using HeuristicLab.Data;
 using HeuristicLab.Optimization;
+using HeuristicLab.Parameters;
 
 namespace HeuristicLab.Encodings.BinaryVectorEncoding {
@@ -33,8 +35,10 @@
     [Storable] protected IResultParameter<ParetoFrontScatterPlot<BinaryVector>> BestResultParameter { get; private set; }
     public IResultDefinition<ParetoFrontScatterPlot<BinaryVector>> BestResult { get { return BestResultParameter; } }
+    [Storable] protected ReferenceParameter<IntValue> DimensionRefParameter { get; private set; }
+    public IValueParameter<IntValue> DimensionParameter => DimensionRefParameter;
 
-    public int Length {
-      get { return Encoding.Length; }
-      set { Encoding.Length = value; }
+    public int Dimension {
+      get { return DimensionRefParameter.Value.Value; }
+      set { DimensionRefParameter.Value.Value = value; }
     }
 
@@ -49,4 +53,5 @@
       : base(original, cloner) {
       BestResultParameter = cloner.Clone(original.BestResultParameter);
+      DimensionRefParameter = cloner.Clone(original.DimensionRefParameter);
       RegisterEventHandlers();
     }
@@ -56,4 +61,5 @@
       EncodingParameter.ReadOnly = true;
       Parameters.Add(BestResultParameter = new ResultParameter<ParetoFrontScatterPlot<BinaryVector>>("Best Pareto Front", "The best Pareto front found."));
+      Parameters.Add(DimensionRefParameter = new ReferenceParameter<IntValue>("Dimension", "The dimension of the binary vector problem.", Encoding.LengthParameter));
 
       Operators.Add(new HammingSimilarityCalculator());
@@ -86,8 +92,12 @@
 
     private void RegisterEventHandlers() {
-      Encoding.LengthParameter.Value.ValueChanged += LengthParameter_ValueChanged;
+      DimensionRefParameter.Value.ValueChanged += DimensionParameter_Value_ValueChanged;
     }
 
-    protected virtual void LengthParameter_ValueChanged(object sender, EventArgs e) { }
+    private void DimensionParameter_Value_ValueChanged(object sender, EventArgs e) {
+      DimensionOnChanged();
+    }
+
+    protected virtual void DimensionOnChanged() { }
   }
 }
Index: /branches/2521_ProblemRefactoring/HeuristicLab.Encodings.BinaryVectorEncoding/3.3/BinaryVectorProblem.cs
===================================================================
--- /branches/2521_ProblemRefactoring/HeuristicLab.Encodings.BinaryVectorEncoding/3.3/BinaryVectorProblem.cs	(revision 17543)
+++ /branches/2521_ProblemRefactoring/HeuristicLab.Encodings.BinaryVectorEncoding/3.3/BinaryVectorProblem.cs	(revision 17544)
@@ -21,5 +21,4 @@
 #endregion
 
-using System;
 using System.Linq;
 using HEAL.Attic;
@@ -27,6 +26,8 @@
 using HeuristicLab.Common;
 using HeuristicLab.Core;
+using HeuristicLab.Data;
 using HeuristicLab.Optimization;
 using HeuristicLab.Optimization.Operators;
+using HeuristicLab.Parameters;
 
 namespace HeuristicLab.Encodings.BinaryVectorEncoding {
@@ -34,7 +35,8 @@
   public abstract class BinaryVectorProblem : SingleObjectiveProblem<BinaryVectorEncoding, BinaryVector> {
     [Storable] protected IResultParameter<ISingleObjectiveSolutionContext<BinaryVector>> BestResultParameter { get; private set; }
-    public IResultDefinition<ISingleObjectiveSolutionContext<BinaryVector>> BestResult { get { return BestResultParameter; } }
+    public IResultDefinition<ISingleObjectiveSolutionContext<BinaryVector>> BestResult => BestResultParameter;
+    [Storable] protected ReferenceParameter<IntValue> DimensionRefParameter { get; private set; }
 
-    public int Length {
+    public int Dimension {
       get { return Encoding.Length; }
       set { Encoding.Length = value; }
@@ -51,4 +53,5 @@
       : base(original, cloner) {
       BestResultParameter = cloner.Clone(original.BestResultParameter);
+      DimensionRefParameter = cloner.Clone(original.DimensionRefParameter);
       RegisterEventHandlers();
     }
@@ -58,4 +61,5 @@
       EncodingParameter.ReadOnly = true;
       Parameters.Add(BestResultParameter = new ResultParameter<ISingleObjectiveSolutionContext<BinaryVector>>("Best Solution", "The best solution."));
+      Parameters.Add(DimensionRefParameter = new ReferenceParameter<IntValue>("Dimension", "The dimension of the binary vector problem.", Encoding.LengthParameter));
 
       Operators.Add(new HammingSimilarityCalculator());
@@ -74,9 +78,4 @@
     }
 
-    protected override void OnEncodingChanged() {
-      base.OnEncodingChanged();
-      Parameterize();
-    }
-
     private void Parameterize() {
       foreach (var similarityCalculator in Operators.OfType<ISolutionSimilarityCalculator>()) {
@@ -87,8 +86,11 @@
 
     private void RegisterEventHandlers() {
-      Encoding.LengthParameter.Value.ValueChanged += LengthParameter_ValueChanged;
+      Encoding.PropertyChanged += (sender, args) => {
+        if (args.PropertyName == nameof(Encoding.Length))
+          DimensionOnChanged();
+      };
     }
 
-    protected virtual void LengthParameter_ValueChanged(object sender, EventArgs e) { }
+    protected virtual void DimensionOnChanged() { }
   }
 }
Index: /branches/2521_ProblemRefactoring/HeuristicLab.Encodings.IntegerVectorEncoding/3.3/IntegerVectorMultiObjectiveProblem.cs
===================================================================
--- /branches/2521_ProblemRefactoring/HeuristicLab.Encodings.IntegerVectorEncoding/3.3/IntegerVectorMultiObjectiveProblem.cs	(revision 17543)
+++ /branches/2521_ProblemRefactoring/HeuristicLab.Encodings.IntegerVectorEncoding/3.3/IntegerVectorMultiObjectiveProblem.cs	(revision 17544)
@@ -28,5 +28,7 @@
 using HeuristicLab.Common;
 using HeuristicLab.Core;
+using HeuristicLab.Data;
 using HeuristicLab.Optimization;
+using HeuristicLab.Parameters;
 
 namespace HeuristicLab.Encodings.IntegerVectorEncoding {
@@ -35,8 +37,10 @@
     [Storable] protected IResultParameter<ParetoFrontScatterPlot<IntegerVector>> BestResultParameter { get; private set; }
     public IResultDefinition<ParetoFrontScatterPlot<IntegerVector>> BestResult { get { return BestResultParameter; } }
+    [Storable] protected ReferenceParameter<IntValue> DimensionRefParameter { get; private set; }
+    public IValueParameter<IntValue> DimensionParameter => DimensionRefParameter;
 
-    public int Length {
-      get { return Encoding.Length; }
-      set { Encoding.Length = value; }
+    public int Dimension {
+      get { return DimensionRefParameter.Value.Value; }
+      set { DimensionRefParameter.Value.Value = value; }
     }
 
@@ -51,4 +55,5 @@
       : base(original, cloner) {
       BestResultParameter = cloner.Clone(original.BestResultParameter);
+      DimensionRefParameter = cloner.Clone(original.DimensionRefParameter);
       RegisterEventHandlers();
     }
@@ -58,4 +63,5 @@
       EncodingParameter.ReadOnly = true;
       Parameters.Add(BestResultParameter = new ResultParameter<ParetoFrontScatterPlot<IntegerVector>>("Best Pareto Front", "The best Pareto front found."));
+      Parameters.Add(DimensionRefParameter = new ReferenceParameter<IntValue>("Dimension", "The dimension of the integer vector problem.", Encoding.LengthParameter));
 
       Operators.Add(new HammingSimilarityCalculator());
@@ -88,8 +94,12 @@
 
     private void RegisterEventHandlers() {
-      Encoding.LengthParameter.Value.ValueChanged += LengthParameter_ValueChanged;
+      DimensionRefParameter.Value.ValueChanged += DimensionParameter_Value_ValueChanged;
     }
 
-    protected virtual void LengthParameter_ValueChanged(object sender, EventArgs e) { }
+    private void DimensionParameter_Value_ValueChanged(object sender, EventArgs e) {
+      DimensionOnChanged();
+    }
+
+    protected virtual void DimensionOnChanged() { }
   }
 }
Index: /branches/2521_ProblemRefactoring/HeuristicLab.Encodings.IntegerVectorEncoding/3.3/IntegerVectorProblem.cs
===================================================================
--- /branches/2521_ProblemRefactoring/HeuristicLab.Encodings.IntegerVectorEncoding/3.3/IntegerVectorProblem.cs	(revision 17543)
+++ /branches/2521_ProblemRefactoring/HeuristicLab.Encodings.IntegerVectorEncoding/3.3/IntegerVectorProblem.cs	(revision 17544)
@@ -28,6 +28,8 @@
 using HeuristicLab.Common;
 using HeuristicLab.Core;
+using HeuristicLab.Data;
 using HeuristicLab.Optimization;
 using HeuristicLab.Optimization.Operators;
+using HeuristicLab.Parameters;
 
 namespace HeuristicLab.Encodings.IntegerVectorEncoding {
@@ -36,8 +38,17 @@
     [Storable] protected IResultParameter<IntegerVector> BestResultParameter { get; private set; }
     public IResultDefinition<IntegerVector> BestResult { get => BestResultParameter; }
+    [Storable] protected ReferenceParameter<IntValue> DimensionRefParameter { get; private set; }
+    public IValueParameter<IntValue> DimensionParameter => DimensionRefParameter;
+    [Storable] protected ReferenceParameter<IntMatrix> BoundsRefParameter { get; private set; }
+    public IValueParameter<IntMatrix> BoundsParameter => BoundsRefParameter;
 
-    public int Length {
-      get { return Encoding.Length; }
-      set { Encoding.Length = value; }
+    public int Dimension {
+      get { return DimensionRefParameter.Value.Value; }
+      set { DimensionRefParameter.Value.Value = value; }
+    }
+
+    public IntMatrix Bounds {
+      get { return BoundsRefParameter.Value; }
+      set { BoundsRefParameter.Value = value; }
     }
 
@@ -52,4 +63,6 @@
       : base(original, cloner) {
       BestResultParameter = cloner.Clone(original.BestResultParameter);
+      DimensionRefParameter = cloner.Clone(original.DimensionRefParameter);
+      BoundsRefParameter = cloner.Clone(original.BoundsRefParameter);
       RegisterEventHandlers();
     }
@@ -59,4 +72,6 @@
       EncodingParameter.ReadOnly = true;
       Parameters.Add(BestResultParameter = new ResultParameter<IntegerVector>("Best Solution", "The best solution."));
+      Parameters.Add(DimensionRefParameter = new ReferenceParameter<IntValue>("Dimension", "The dimension of the integer vector problem.", Encoding.LengthParameter));
+      Parameters.Add(BoundsRefParameter = new ReferenceParameter<IntMatrix>("Bounds", "The bounding box and step sizes of the values.", Encoding.BoundsParameter));
 
       Operators.Add(new HammingSimilarityCalculator());
@@ -88,8 +103,19 @@
 
     private void RegisterEventHandlers() {
-      Encoding.LengthParameter.Value.ValueChanged += LengthParameter_ValueChanged;
+      DimensionRefParameter.Value.ValueChanged += DimensionParameter_Value_ValueChanged;
+      BoundsRefParameter.ValueChanged += BoundsParameter_ValueChanged;
     }
 
-    protected virtual void LengthParameter_ValueChanged(object sender, EventArgs e) { }
+    private void DimensionParameter_Value_ValueChanged(object sender, EventArgs e) {
+      DimensionOnChanged();
+    }
+
+    private void BoundsParameter_ValueChanged(object sender, EventArgs e) {
+      BoundsOnChanged();
+    }
+
+    protected virtual void DimensionOnChanged() { }
+
+    protected virtual void BoundsOnChanged() { }
   }
 }
Index: /branches/2521_ProblemRefactoring/HeuristicLab.Encodings.LinearLinkageEncoding/3.4/LinearLinkageMultiObjectiveProblem.cs
===================================================================
--- /branches/2521_ProblemRefactoring/HeuristicLab.Encodings.LinearLinkageEncoding/3.4/LinearLinkageMultiObjectiveProblem.cs	(revision 17543)
+++ /branches/2521_ProblemRefactoring/HeuristicLab.Encodings.LinearLinkageEncoding/3.4/LinearLinkageMultiObjectiveProblem.cs	(revision 17544)
@@ -28,12 +28,17 @@
 using HeuristicLab.Common;
 using HeuristicLab.Core;
+using HeuristicLab.Data;
 using HeuristicLab.Optimization;
+using HeuristicLab.Parameters;
 
 namespace HeuristicLab.Encodings.LinearLinkageEncoding {
   [StorableType("ad8b6097-a26b-440c-bfd4-92e5ecf17894")]
   public abstract class LinearLinkageMultiObjectiveProblem : MultiObjectiveProblem<LinearLinkageEncoding, LinearLinkage> {
-    public int Length {
-      get { return Encoding.Length; }
-      set { Encoding.Length = value; }
+    [Storable] protected ReferenceParameter<IntValue> DimensionRefParameter { get; private set; }
+    public IValueParameter<IntValue> DimensionParameter => DimensionRefParameter;
+
+    public int Dimension {
+      get { return DimensionRefParameter.Value.Value; }
+      set { DimensionRefParameter.Value.Value = value; }
     }
 
@@ -47,4 +52,5 @@
     protected LinearLinkageMultiObjectiveProblem(LinearLinkageMultiObjectiveProblem original, Cloner cloner)
       : base(original, cloner) {
+      DimensionRefParameter = cloner.Clone(original.DimensionRefParameter);
       RegisterEventHandlers();
     }
@@ -53,4 +59,6 @@
     protected LinearLinkageMultiObjectiveProblem(LinearLinkageEncoding encoding) : base(new LinearLinkageEncoding()) {
       EncodingParameter.ReadOnly = true;
+      Parameters.Add(DimensionRefParameter = new ReferenceParameter<IntValue>("Dimension", "The dimension of the linear linkage problem.", Encoding.LengthParameter));
+
 
       Operators.Add(new HammingSimilarityCalculator());
@@ -82,8 +90,12 @@
 
     private void RegisterEventHandlers() {
-      Encoding.LengthParameter.Value.ValueChanged += LengthParameter_ValueChanged;
+      DimensionRefParameter.Value.ValueChanged += DimensionParameter_Value_ValueChanged;
     }
 
-    protected virtual void LengthParameter_ValueChanged(object sender, EventArgs e) { }
+    private void DimensionParameter_Value_ValueChanged(object sender, EventArgs e) {
+      DimensionOnChanged();
+    }
+
+    protected virtual void DimensionOnChanged() { }
   }
 }
Index: /branches/2521_ProblemRefactoring/HeuristicLab.Encodings.LinearLinkageEncoding/3.4/LinearLinkageProblem.cs
===================================================================
--- /branches/2521_ProblemRefactoring/HeuristicLab.Encodings.LinearLinkageEncoding/3.4/LinearLinkageProblem.cs	(revision 17543)
+++ /branches/2521_ProblemRefactoring/HeuristicLab.Encodings.LinearLinkageEncoding/3.4/LinearLinkageProblem.cs	(revision 17544)
@@ -28,13 +28,18 @@
 using HeuristicLab.Common;
 using HeuristicLab.Core;
+using HeuristicLab.Data;
 using HeuristicLab.Optimization;
 using HeuristicLab.Optimization.Operators;
+using HeuristicLab.Parameters;
 
 namespace HeuristicLab.Encodings.LinearLinkageEncoding {
   [StorableType("fb4cfc7c-dc7c-4da6-843f-0dad7d3d7981")]
   public abstract class LinearLinkageProblem : SingleObjectiveProblem<LinearLinkageEncoding, LinearLinkage> {
-    public int Length {
-      get { return Encoding.Length; }
-      set { Encoding.Length = value; }
+    [Storable] protected ReferenceParameter<IntValue> DimensionRefParameter { get; private set; }
+    public IValueParameter<IntValue> DimensionParameter => DimensionRefParameter;
+
+    public int Dimension {
+      get { return DimensionRefParameter.Value.Value; }
+      set { DimensionRefParameter.Value.Value = value; }
     }
 
@@ -48,4 +53,5 @@
     protected LinearLinkageProblem(LinearLinkageProblem original, Cloner cloner)
       : base(original, cloner) {
+      DimensionRefParameter = cloner.Clone(original.DimensionRefParameter);
       RegisterEventHandlers();
     }
@@ -54,4 +60,5 @@
     protected LinearLinkageProblem(LinearLinkageEncoding encoding) : base(encoding) {
       EncodingParameter.ReadOnly = true;
+      Parameters.Add(DimensionRefParameter = new ReferenceParameter<IntValue>("Dimension", "The dimension of the linear linkage problem.", Encoding.LengthParameter));
 
       Operators.Add(new HammingSimilarityCalculator());
@@ -83,8 +90,12 @@
 
     private void RegisterEventHandlers() {
-      Encoding.LengthParameter.Value.ValueChanged += LengthParameter_ValueChanged;
+      DimensionRefParameter.Value.ValueChanged += DimensionParameter_Value_ValueChanged;
     }
 
-    protected virtual void LengthParameter_ValueChanged(object sender, EventArgs e) { }
+    private void DimensionParameter_Value_ValueChanged(object sender, EventArgs e) {
+      DimensionOnChanged();
+    }
+
+    protected virtual void DimensionOnChanged() { }
   }
 }
Index: /branches/2521_ProblemRefactoring/HeuristicLab.Encodings.PermutationEncoding/3.3/PermutationMultiObjectiveProblem.cs
===================================================================
--- /branches/2521_ProblemRefactoring/HeuristicLab.Encodings.PermutationEncoding/3.3/PermutationMultiObjectiveProblem.cs	(revision 17543)
+++ /branches/2521_ProblemRefactoring/HeuristicLab.Encodings.PermutationEncoding/3.3/PermutationMultiObjectiveProblem.cs	(revision 17544)
@@ -28,17 +28,17 @@
 using HeuristicLab.Common;
 using HeuristicLab.Core;
+using HeuristicLab.Data;
 using HeuristicLab.Optimization;
+using HeuristicLab.Parameters;
 
 namespace HeuristicLab.Encodings.PermutationEncoding {
   [StorableType("7bc5215b-c181-40d0-a758-d7c19a356e18")]
   public abstract class PermutationMultiObjectiveProblem : MultiObjectiveProblem<PermutationEncoding, Permutation> {
-    public int Length {
-      get { return Encoding.Length; }
-      set { Encoding.Length = value; }
-    }
+    [Storable] protected ReferenceParameter<IntValue> DimensionRefParameter { get; private set; }
+    public IValueParameter<IntValue> DimensionParameter => DimensionRefParameter;
 
-    public PermutationTypes Type {
-      get { return Encoding.Type; }
-      set { Encoding.Type = value; }
+    public int Dimension {
+      get { return DimensionRefParameter.Value.Value; }
+      set { DimensionRefParameter.Value.Value = value; }
     }
 
@@ -52,4 +52,5 @@
     protected PermutationMultiObjectiveProblem(PermutationMultiObjectiveProblem original, Cloner cloner)
       : base(original, cloner) {
+      DimensionRefParameter = cloner.Clone(original.DimensionRefParameter);
       RegisterEventHandlers();
     }
@@ -58,4 +59,5 @@
     protected PermutationMultiObjectiveProblem(PermutationEncoding encoding) : base(encoding) {
       EncodingParameter.ReadOnly = true;
+      Parameters.Add(DimensionRefParameter = new ReferenceParameter<IntValue>("Dimension", "The dimension of the permutation problem.", Encoding.LengthParameter));
 
       Operators.Add(new HammingSimilarityCalculator());
@@ -87,10 +89,12 @@
 
     private void RegisterEventHandlers() {
-      Encoding.LengthParameter.Value.ValueChanged += LengthParameter_ValueChanged;
-      Encoding.PermutationTypeParameter.Value.ValueChanged += TypeParameter_ValueChanged;
+      DimensionRefParameter.Value.ValueChanged += DimensionParameter_Value_ValueChanged;
     }
 
-    protected virtual void LengthParameter_ValueChanged(object sender, EventArgs e) { }
-    protected virtual void TypeParameter_ValueChanged(object sender, EventArgs e) { }
+    private void DimensionParameter_Value_ValueChanged(object sender, EventArgs e) {
+      DimensionOnChanged();
+    }
+
+    protected virtual void DimensionOnChanged() { }
   }
 }
Index: /branches/2521_ProblemRefactoring/HeuristicLab.Encodings.PermutationEncoding/3.3/PermutationProblem.cs
===================================================================
--- /branches/2521_ProblemRefactoring/HeuristicLab.Encodings.PermutationEncoding/3.3/PermutationProblem.cs	(revision 17543)
+++ /branches/2521_ProblemRefactoring/HeuristicLab.Encodings.PermutationEncoding/3.3/PermutationProblem.cs	(revision 17544)
@@ -28,18 +28,18 @@
 using HeuristicLab.Common;
 using HeuristicLab.Core;
+using HeuristicLab.Data;
 using HeuristicLab.Optimization;
 using HeuristicLab.Optimization.Operators;
+using HeuristicLab.Parameters;
 
 namespace HeuristicLab.Encodings.PermutationEncoding {
   [StorableType("aceff7a2-0666-4055-b698-6ea3628713b6")]
   public abstract class PermutationProblem : SingleObjectiveProblem<PermutationEncoding, Permutation> {
-    public int Length {
-      get { return Encoding.Length; }
-      set { Encoding.Length = value; }
-    }
+    [Storable] protected ReferenceParameter<IntValue> DimensionRefParameter { get; private set; }
+    public IValueParameter<IntValue> DimensionParameter => DimensionRefParameter;
 
-    public PermutationTypes Type {
-      get { return Encoding.Type; }
-      set { Encoding.Type = value; }
+    public int Dimension {
+      get { return DimensionRefParameter.Value.Value; }
+      set { DimensionRefParameter.Value.Value = value; }
     }
 
@@ -53,4 +53,5 @@
     protected PermutationProblem(PermutationProblem original, Cloner cloner)
       : base(original, cloner) {
+      DimensionRefParameter = cloner.Clone(original.DimensionRefParameter);
       RegisterEventHandlers();
     }
@@ -59,4 +60,5 @@
     protected PermutationProblem(PermutationEncoding encoding) : base(encoding) {
       EncodingParameter.ReadOnly = true;
+      Parameters.Add(DimensionRefParameter = new ReferenceParameter<IntValue>("Dimension", "The dimension of the permutation problem.", Encoding.LengthParameter));
 
       Operators.Add(new HammingSimilarityCalculator());
@@ -87,10 +89,12 @@
 
     private void RegisterEventHandlers() {
-      Encoding.LengthParameter.Value.ValueChanged += LengthParameter_ValueChanged;
-      Encoding.PermutationTypeParameter.Value.ValueChanged += TypeParameter_ValueChanged;
+      DimensionRefParameter.Value.ValueChanged += DimensionParameter_Value_ValueChanged;
     }
 
-    protected virtual void LengthParameter_ValueChanged(object sender, EventArgs e) { }
-    protected virtual void TypeParameter_ValueChanged(object sender, EventArgs e) { }
+    private void DimensionParameter_Value_ValueChanged(object sender, EventArgs e) {
+      DimensionOnChanged();
+    }
+
+    protected virtual void DimensionOnChanged() { }
   }
 }
Index: /branches/2521_ProblemRefactoring/HeuristicLab.Encodings.RealVectorEncoding/3.3/RealVectorMultiObjectiveProblem.cs
===================================================================
--- /branches/2521_ProblemRefactoring/HeuristicLab.Encodings.RealVectorEncoding/3.3/RealVectorMultiObjectiveProblem.cs	(revision 17543)
+++ /branches/2521_ProblemRefactoring/HeuristicLab.Encodings.RealVectorEncoding/3.3/RealVectorMultiObjectiveProblem.cs	(revision 17544)
@@ -28,12 +28,24 @@
 using HeuristicLab.Common;
 using HeuristicLab.Core;
+using HeuristicLab.Data;
 using HeuristicLab.Optimization;
+using HeuristicLab.Parameters;
 
 namespace HeuristicLab.Encodings.RealVectorEncoding {
   [StorableType("135697c1-1b2b-46b6-a518-1c6efae09475")]
   public abstract class RealVectorMultiObjectiveProblem : MultiObjectiveProblem<RealVectorEncoding, RealVector> {
-    public int Length {
-      get { return Encoding.Length; }
-      set { Encoding.Length = value; }
+    [Storable] protected ReferenceParameter<IntValue> DimensionRefParameter { get; private set; }
+    public IValueParameter<IntValue> DimensionParameter => DimensionRefParameter;
+    [Storable] protected ReferenceParameter<DoubleMatrix> BoundsRefParameter { get; private set; }
+    public IValueParameter<DoubleMatrix> BoundsParameter => BoundsRefParameter;
+
+    public int Dimension {
+      get { return DimensionRefParameter.Value.Value; }
+      set { DimensionRefParameter.Value.Value = value; }
+    }
+
+    public DoubleMatrix Bounds {
+      get { return BoundsRefParameter.Value; }
+      set { BoundsParameter.Value = value; }
     }
 
@@ -47,4 +59,6 @@
     protected RealVectorMultiObjectiveProblem(RealVectorMultiObjectiveProblem original, Cloner cloner)
       : base(original, cloner) {
+      DimensionRefParameter = cloner.Clone(original.DimensionRefParameter);
+      BoundsRefParameter = cloner.Clone(original.BoundsRefParameter);
       RegisterEventHandlers();
     }
@@ -53,4 +67,7 @@
     protected RealVectorMultiObjectiveProblem(RealVectorEncoding encoding) : base(encoding) {
       EncodingParameter.ReadOnly = true;
+      Parameters.Add(DimensionRefParameter = new ReferenceParameter<IntValue>("Dimension", "The dimension of the real vector problem.", Encoding.LengthParameter));
+      Parameters.Add(BoundsRefParameter = new ReferenceParameter<DoubleMatrix>("Bounds", "The bounding box of the values.", Encoding.BoundsParameter));
+
 
       Operators.Add(new HammingSimilarityCalculator());
@@ -82,8 +99,19 @@
 
     private void RegisterEventHandlers() {
-      Encoding.LengthParameter.Value.ValueChanged += LengthParameter_ValueChanged;
+      DimensionRefParameter.Value.ValueChanged += DimensionParameter_Value_ValueChanged;
+      BoundsRefParameter.ValueChanged += BoundsParameter_ValueChanged;
     }
 
-    protected virtual void LengthParameter_ValueChanged(object sender, EventArgs e) { }
+    private void DimensionParameter_Value_ValueChanged(object sender, EventArgs e) {
+      DimensionOnChanged();
+    }
+
+    private void BoundsParameter_ValueChanged(object sender, EventArgs e) {
+      BoundsOnChanged();
+    }
+
+    protected virtual void DimensionOnChanged() { }
+
+    protected virtual void BoundsOnChanged() { }
   }
 }
Index: /branches/2521_ProblemRefactoring/HeuristicLab.Encodings.RealVectorEncoding/3.3/RealVectorProblem.cs
===================================================================
--- /branches/2521_ProblemRefactoring/HeuristicLab.Encodings.RealVectorEncoding/3.3/RealVectorProblem.cs	(revision 17543)
+++ /branches/2521_ProblemRefactoring/HeuristicLab.Encodings.RealVectorEncoding/3.3/RealVectorProblem.cs	(revision 17544)
@@ -28,13 +28,25 @@
 using HeuristicLab.Common;
 using HeuristicLab.Core;
+using HeuristicLab.Data;
 using HeuristicLab.Optimization;
 using HeuristicLab.Optimization.Operators;
+using HeuristicLab.Parameters;
 
 namespace HeuristicLab.Encodings.RealVectorEncoding {
   [StorableType("7860a955-af16-459a-9cd8-51667e06d38e")]
   public abstract class RealVectorProblem : SingleObjectiveProblem<RealVectorEncoding, RealVector> {
-    public int Length {
-      get { return Encoding.Length; }
-      set { Encoding.Length = value; }
+    [Storable] protected ReferenceParameter<IntValue> DimensionRefParameter { get; private set; }
+    public IValueParameter<IntValue> DimensionParameter => DimensionRefParameter;
+    [Storable] protected ReferenceParameter<DoubleMatrix> BoundsRefParameter { get; private set; }
+    public IValueParameter<DoubleMatrix> BoundsParameter => BoundsRefParameter;
+
+    public int Dimension {
+      get { return DimensionRefParameter.Value.Value; }
+      set { DimensionRefParameter.Value.Value = value; }
+    }
+
+    public DoubleMatrix Bounds {
+      get { return BoundsRefParameter.Value; }
+      set { BoundsParameter.Value = value; }
     }
 
@@ -48,4 +60,6 @@
     protected RealVectorProblem(RealVectorProblem original, Cloner cloner)
       : base(original, cloner) {
+      DimensionRefParameter = cloner.Clone(original.DimensionRefParameter);
+      BoundsRefParameter = cloner.Clone(original.BoundsRefParameter);
       RegisterEventHandlers();
     }
@@ -54,4 +68,6 @@
     protected RealVectorProblem(RealVectorEncoding encoding) : base(encoding) {
       EncodingParameter.ReadOnly = true;
+      Parameters.Add(DimensionRefParameter = new ReferenceParameter<IntValue>("Dimension", "The dimension of the real vector problem.", Encoding.LengthParameter));
+      Parameters.Add(BoundsRefParameter = new ReferenceParameter<DoubleMatrix>("Bounds", "The bounding box of the values.", Encoding.BoundsParameter));
 
       Operators.Add(new HammingSimilarityCalculator());
@@ -83,8 +99,19 @@
 
     private void RegisterEventHandlers() {
-      Encoding.LengthParameter.Value.ValueChanged += LengthParameter_ValueChanged;
+      DimensionRefParameter.Value.ValueChanged += DimensionParameter_Value_ValueChanged;
+      BoundsRefParameter.ValueChanged += BoundsParameter_ValueChanged;
     }
 
-    protected virtual void LengthParameter_ValueChanged(object sender, EventArgs e) { }
+    private void DimensionParameter_Value_ValueChanged(object sender, EventArgs e) {
+      DimensionOnChanged();
+    }
+
+    private void BoundsParameter_ValueChanged(object sender, EventArgs e) {
+      BoundsOnChanged();
+    }
+
+    protected virtual void DimensionOnChanged() { }
+
+    protected virtual void BoundsOnChanged() { }
   }
 }
Index: /branches/2521_ProblemRefactoring/HeuristicLab.Problems.Binary/3.3/DeceptiveStepTrapProblem.cs
===================================================================
--- /branches/2521_ProblemRefactoring/HeuristicLab.Problems.Binary/3.3/DeceptiveStepTrapProblem.cs	(revision 17543)
+++ /branches/2521_ProblemRefactoring/HeuristicLab.Problems.Binary/3.3/DeceptiveStepTrapProblem.cs	(revision 17544)
@@ -22,4 +22,5 @@
 #endregion
 
+using System;
 using HEAL.Attic;
 using HeuristicLab.Common;
@@ -34,19 +35,6 @@
   [Creatable(CreatableAttribute.Categories.CombinatorialProblems, Priority = 230)]
   public class DeceptiveStepTrapProblem : DeceptiveTrapProblem {
-    [StorableConstructor]
-    protected DeceptiveStepTrapProblem(StorableConstructorFlag _) : base(_) { }
-    protected DeceptiveStepTrapProblem(DeceptiveStepTrapProblem original, Cloner cloner)
-      : base(original, cloner) {
-      RegisterParameterEvents();
-    }
-    public override IDeepCloneable Clone(Cloner cloner) {
-      return new DeceptiveStepTrapProblem(this, cloner);
-    }
-
-    private const string StepSizeParameterName = "Step Size";
-
-    public IFixedValueParameter<IntValue> StepSizeParameter {
-      get { return (IFixedValueParameter<IntValue>)Parameters[StepSizeParameterName]; }
-    }
+    [Storable] private int offset = -1;
+    [Storable] public IFixedValueParameter<IntValue> StepSizeParameter { get; private set; }
 
     public int StepSize {
@@ -56,7 +44,22 @@
 
     public DeceptiveStepTrapProblem() : base() {
-      Parameters.Add(new FixedValueParameter<IntValue>(StepSizeParameterName, "", new IntValue(2)));
+      Parameters.Add(StepSizeParameter = new FixedValueParameter<IntValue>("Step Size", "", new IntValue(2)));
+      offset = (TrapSize - StepSize) % StepSize;
+
       RegisterParameterEvents();
     }
+
+    protected override int TrapMaximum {
+      get { return (offset + TrapSize) / StepSize; }
+    }
+
+    protected override int Score(BinaryVector individual, int trapIndex, int trapSize) {
+      int partial = base.Score(individual, trapIndex, trapSize);
+      // introduce plateaus using integer division
+      return (offset + partial) / StepSize;
+    }
+
+    [StorableConstructor]
+    protected DeceptiveStepTrapProblem(StorableConstructorFlag _) : base(_) { }
 
     [StorableHook(HookType.AfterDeserialization)]
@@ -64,27 +67,26 @@
       RegisterParameterEvents();
     }
+    protected DeceptiveStepTrapProblem(DeceptiveStepTrapProblem original, Cloner cloner)
+      : base(original, cloner) {
+      offset = original.offset;
+      StepSizeParameter = cloner.Clone(original.StepSizeParameter);
+
+      RegisterParameterEvents();
+    }
+    public override IDeepCloneable Clone(Cloner cloner) {
+      return new DeceptiveStepTrapProblem(this, cloner);
+    }
 
     private void RegisterParameterEvents() {
-      TrapSizeParameter.Value.ValueChanged += (o, e) => { offset = -1; };
-      StepSizeParameter.Value.ValueChanged += (o, e) => { offset = -1; };
+      StepSizeParameter.Value.ValueChanged += StepSizeOnChanged;
     }
 
-
-    private int offset = -1;
-    private int Offset {
-      get {
-        if (offset == -1) offset = (TrapSize - StepSize) % StepSize;
-        return offset;
-      }
+    protected override void TrapSizeOnChanged(object sender, EventArgs e) {
+      base.TrapSizeOnChanged(sender, e);
+      offset = (TrapSize - StepSize) % StepSize;
     }
 
-    protected override int TrapMaximum {
-      get { return (Offset + TrapSize) / StepSize; }
-    }
-
-    protected override int Score(BinaryVector individual, int trapIndex, int trapSize) {
-      int partial = base.Score(individual, trapIndex, trapSize);
-      // introduce plateaus using integer division
-      return (Offset + partial) / StepSize;
+    private void StepSizeOnChanged(object sender, EventArgs e) {
+      offset = (TrapSize - StepSize) % StepSize;
     }
   }
Index: /branches/2521_ProblemRefactoring/HeuristicLab.Problems.Binary/3.3/DeceptiveTrapProblem.cs
===================================================================
--- /branches/2521_ProblemRefactoring/HeuristicLab.Problems.Binary/3.3/DeceptiveTrapProblem.cs	(revision 17543)
+++ /branches/2521_ProblemRefactoring/HeuristicLab.Problems.Binary/3.3/DeceptiveTrapProblem.cs	(revision 17544)
@@ -37,22 +37,15 @@
   [Creatable(CreatableAttribute.Categories.CombinatorialProblems, Priority = 230)]
   public class DeceptiveTrapProblem : BinaryVectorProblem {
-    [StorableConstructor]
-    protected DeceptiveTrapProblem(StorableConstructorFlag _) : base(_) { }
-    protected DeceptiveTrapProblem(DeceptiveTrapProblem original, Cloner cloner)
-      : base(original, cloner) {
-    }
-    public override IDeepCloneable Clone(Cloner cloner) {
-      return new DeceptiveTrapProblem(this, cloner);
-    }
-
-    private const string TrapSizeParameterName = "Trap Size";
-
-    public IFixedValueParameter<IntValue> TrapSizeParameter {
-      get { return (IFixedValueParameter<IntValue>)Parameters[TrapSizeParameterName]; }
-    }
+    [Storable] public IFixedValueParameter<IntValue> TrapSizeParameter { get; private set; }
+    [Storable] public IFixedValueParameter<IntValue> NumberOfTrapsParameter { get; private set; }
 
     public int TrapSize {
       get { return TrapSizeParameter.Value.Value; }
       set { TrapSizeParameter.Value.Value = value; }
+    }
+
+    public int NumberOfTraps {
+      get { return NumberOfTrapsParameter.Value.Value; }
+      set { NumberOfTrapsParameter.Value.Value = value; }
     }
 
@@ -63,6 +56,9 @@
     public DeceptiveTrapProblem() : base() {
       Maximization = true;
-      Parameters.Add(new FixedValueParameter<IntValue>(TrapSizeParameterName, "", new IntValue(7)));
-      Encoding.Length = 49;
+      Parameters.Add(TrapSizeParameter = new FixedValueParameter<IntValue>("Trap Size", "", new IntValue(7)));
+      Parameters.Add(NumberOfTrapsParameter = new FixedValueParameter<IntValue>("Number of Traps", "", new IntValue(7)));
+      Dimension = TrapSize * NumberOfTraps;
+
+      RegisterEventHandlers();
     }
 
@@ -83,5 +79,5 @@
 
     public override ISingleObjectiveEvaluationResult Evaluate(BinaryVector individual, IRandom random, CancellationToken cancellationToken) {
-      if (individual.Length != Length) throw new ArgumentException("The individual has not the correct length.");
+      if (individual.Length != Dimension) throw new ArgumentException("The individual has not the correct length.");
       int total = 0;
       var trapSize = TrapSize;
@@ -92,4 +88,34 @@
       return new SingleObjectiveEvaluationResult(quality);
     }
+
+    [StorableConstructor]
+    protected DeceptiveTrapProblem(StorableConstructorFlag _) : base(_) { }
+    [StorableHook(HookType.AfterDeserialization)]
+    private void AfterDeserialization() {
+      RegisterEventHandlers();
+    }
+    protected DeceptiveTrapProblem(DeceptiveTrapProblem original, Cloner cloner)
+      : base(original, cloner) {
+      TrapSizeParameter = cloner.Clone(original.TrapSizeParameter);
+      NumberOfTrapsParameter = cloner.Clone(original.NumberOfTrapsParameter);
+
+      RegisterEventHandlers();
+    }
+    public override IDeepCloneable Clone(Cloner cloner) {
+      return new DeceptiveTrapProblem(this, cloner);
+    }
+
+    private void RegisterEventHandlers() {
+      TrapSizeParameter.Value.ValueChanged += TrapSizeOnChanged;
+      NumberOfTrapsParameter.Value.ValueChanged += NumberOfTrapsOnChanged;
+    }
+
+    protected virtual void TrapSizeOnChanged(object sender, EventArgs e) {
+      Dimension = TrapSize * NumberOfTraps;
+    }
+
+    private void NumberOfTrapsOnChanged(object sender, EventArgs e) {
+      Dimension = TrapSize * NumberOfTraps;
+    }
   }
 }
Index: /branches/2521_ProblemRefactoring/HeuristicLab.Problems.Binary/3.3/HIFFProblem.cs
===================================================================
--- /branches/2521_ProblemRefactoring/HeuristicLab.Problems.Binary/3.3/HIFFProblem.cs	(revision 17543)
+++ /branches/2521_ProblemRefactoring/HeuristicLab.Problems.Binary/3.3/HIFFProblem.cs	(revision 17544)
@@ -27,4 +27,5 @@
 using HeuristicLab.Common;
 using HeuristicLab.Core;
+using HeuristicLab.Data;
 using HeuristicLab.Encodings.BinaryVectorEncoding;
 using HeuristicLab.Optimization;
@@ -35,17 +36,10 @@
   [Creatable(CreatableAttribute.Categories.CombinatorialProblems, Priority = 220)]
   public class HIFFProblem : BinaryVectorProblem {
-    [StorableConstructor]
-    protected HIFFProblem(StorableConstructorFlag _) : base(_) { }
-    protected HIFFProblem(HIFFProblem original, Cloner cloner)
-      : base(original, cloner) {
-    }
-    public override IDeepCloneable Clone(Cloner cloner) {
-      return new HIFFProblem(this, cloner);
-    }
 
     public HIFFProblem() : base() {
       Maximization = true;
-      Encoding.Length = 64;
+      DimensionRefParameter.ForceValue(new IntValue(64, @readonly: false));
     }
+
     // In the GECCO paper, Section 4.1
     public override ISingleObjectiveEvaluationResult Evaluate(BinaryVector individual, IRandom random, CancellationToken cancellationToken) {
@@ -87,4 +81,13 @@
       return new SingleObjectiveEvaluationResult(quality);
     }
+
+    [StorableConstructor]
+    protected HIFFProblem(StorableConstructorFlag _) : base(_) { }
+    protected HIFFProblem(HIFFProblem original, Cloner cloner)
+      : base(original, cloner) {
+    }
+    public override IDeepCloneable Clone(Cloner cloner) {
+      return new HIFFProblem(this, cloner);
+    }
   }
 }
Index: /branches/2521_ProblemRefactoring/HeuristicLab.Problems.Binary/3.3/OneMaxProblem.cs
===================================================================
--- /branches/2521_ProblemRefactoring/HeuristicLab.Problems.Binary/3.3/OneMaxProblem.cs	(revision 17543)
+++ /branches/2521_ProblemRefactoring/HeuristicLab.Problems.Binary/3.3/OneMaxProblem.cs	(revision 17544)
@@ -20,5 +20,4 @@
 #endregion
 
-using System;
 using System.Linq;
 using System.Threading;
@@ -26,4 +25,5 @@
 using HeuristicLab.Common;
 using HeuristicLab.Core;
+using HeuristicLab.Data;
 using HeuristicLab.Encodings.BinaryVectorEncoding;
 using HeuristicLab.Optimization;
@@ -37,14 +37,6 @@
     public OneMaxProblem() : base() {
       Maximization = true;
-      Encoding.Length = 10;
-      BestKnownQuality = Encoding.Length;
-    }
-
-    [StorableConstructor]
-    protected OneMaxProblem(StorableConstructorFlag _) : base(_) { }
-
-    protected OneMaxProblem(OneMaxProblem original, Cloner cloner) : base(original, cloner) { }
-    public override IDeepCloneable Clone(Cloner cloner) {
-      return new OneMaxProblem(this, cloner);
+      DimensionRefParameter.ForceValue(new IntValue(10, @readonly: false));
+      BestKnownQuality = Dimension;
     }
 
@@ -54,7 +46,14 @@
     }
 
-    protected override void LengthParameter_ValueChanged(object sender, EventArgs e) {
-      base.LengthParameter_ValueChanged(sender, e);
-      BestKnownQuality = Length;
+    [StorableConstructor]
+    protected OneMaxProblem(StorableConstructorFlag _) : base(_) { }
+    protected OneMaxProblem(OneMaxProblem original, Cloner cloner) : base(original, cloner) { }
+    public override IDeepCloneable Clone(Cloner cloner) {
+      return new OneMaxProblem(this, cloner);
+    }
+
+    protected override void DimensionOnChanged() {
+      base.DimensionOnChanged();
+      BestKnownQuality = Dimension;
     }
   }
Index: /branches/2521_ProblemRefactoring/HeuristicLab.Problems.ExternalEvaluation/3.4/ExternalEvaluationProblemInstances.cs
===================================================================
--- /branches/2521_ProblemRefactoring/HeuristicLab.Problems.ExternalEvaluation/3.4/ExternalEvaluationProblemInstances.cs	(revision 17543)
+++ /branches/2521_ProblemRefactoring/HeuristicLab.Problems.ExternalEvaluation/3.4/ExternalEvaluationProblemInstances.cs	(revision 17544)
@@ -41,14 +41,23 @@
   [StorableType("4ea0ded8-4451-4011-b88e-4d0680721b01")]
   public sealed class SingleObjectiveBinaryVectorExternalEvaluationProblem : ExternalEvaluationProblem<BinaryVectorEncoding, BinaryVector> {
+    [Storable] private ReferenceParameter<IntValue> DimensionRefParameter;
+    public IValueParameter<IntValue> DimensionParameter => DimensionRefParameter;
+
+    public int Dimension {
+      get => Encoding.Length;
+      set => Encoding.Length = value;
+    }
 
     [StorableConstructor]
     private SingleObjectiveBinaryVectorExternalEvaluationProblem(StorableConstructorFlag _) : base(_) { }
-    private SingleObjectiveBinaryVectorExternalEvaluationProblem(SingleObjectiveBinaryVectorExternalEvaluationProblem original, Cloner cloner) : base(original, cloner) { }
+    private SingleObjectiveBinaryVectorExternalEvaluationProblem(SingleObjectiveBinaryVectorExternalEvaluationProblem original, Cloner cloner)
+      : base(original, cloner) {
+      DimensionRefParameter = cloner.Clone(original.DimensionRefParameter);
+    }
 
     public SingleObjectiveBinaryVectorExternalEvaluationProblem()
       : base(new BinaryVectorEncoding()) {
-      var lengthParameter = new FixedValueParameter<IntValue>("Length", "The length of the vector.", new IntValue(10));
-      Parameters.Add(lengthParameter);
-      Encoding.LengthParameter = lengthParameter;
+      Parameters.Add(DimensionRefParameter = new ReferenceParameter<IntValue>("Dimension", "The dimension of the vector.", Encoding.LengthParameter));
+      DimensionRefParameter.ForceValue(new IntValue(Dimension, @readonly: false));
       // TODO: Add and parameterize additional operators, 
     }
@@ -64,14 +73,31 @@
   [StorableType("46465e8c-11d8-4d02-8c45-de41a08db7fa")]
   public sealed class SingleObjectiveIntegerVectorExternalEvaluationProblem : ExternalEvaluationProblem<IntegerVectorEncoding, IntegerVector> {
+    [Storable] private ReferenceParameter<IntValue> DimensionRefParameter;
+    public IValueParameter<IntValue> DimensionParameter => DimensionRefParameter;
+    [Storable] private ReferenceParameter<IntMatrix> BoundsRefParameter;
+    public IValueParameter<IntMatrix> BoundsParameter => BoundsRefParameter;
+
+    public int Dimension {
+      get => DimensionRefParameter.Value.Value;
+      set => DimensionRefParameter.Value.Value = value;
+    }
+
+    public IntMatrix Bounds {
+      get => BoundsRefParameter.Value;
+      set => BoundsRefParameter.Value = value;
+    }
 
     [StorableConstructor]
     private SingleObjectiveIntegerVectorExternalEvaluationProblem(StorableConstructorFlag _) : base(_) { }
-    private SingleObjectiveIntegerVectorExternalEvaluationProblem(SingleObjectiveIntegerVectorExternalEvaluationProblem original, Cloner cloner) : base(original, cloner) { }
+    private SingleObjectiveIntegerVectorExternalEvaluationProblem(SingleObjectiveIntegerVectorExternalEvaluationProblem original, Cloner cloner)
+      : base(original, cloner) {
+      DimensionRefParameter = cloner.Clone(original.DimensionRefParameter);
+      BoundsRefParameter = cloner.Clone(original.BoundsRefParameter);
+    }
 
     public SingleObjectiveIntegerVectorExternalEvaluationProblem()
       : base(new IntegerVectorEncoding()) {
-      var lengthParameter = new FixedValueParameter<IntValue>("Length", "The length of the vector.", new IntValue(10));
-      Parameters.Add(lengthParameter);
-      Encoding.LengthParameter = lengthParameter;
+      Parameters.Add(DimensionRefParameter = new ReferenceParameter<IntValue>("Dimension", "The dimension of the vector.", Encoding.LengthParameter));
+      Parameters.Add(BoundsRefParameter = new ReferenceParameter<IntMatrix>("Bounds", "The bounding box and step size of the elements.", Encoding.BoundsParameter));
       // TODO: Add and parameterize additional operators, 
     }
@@ -87,14 +113,31 @@
   [StorableType("637f091f-6601-494e-bafb-2a8ea474210c")]
   public sealed class SingleObjectiveRealVectorExternalEvaluationProblem : ExternalEvaluationProblem<RealVectorEncoding, RealVector> {
+    [Storable] private ReferenceParameter<IntValue> DimensionRefParameter;
+    public IValueParameter<IntValue> DimensionParameter => DimensionRefParameter;
+    [Storable] private ReferenceParameter<DoubleMatrix> BoundsRefParameter;
+    public IValueParameter<DoubleMatrix> BoundsParameter => BoundsRefParameter;
+
+    public int Dimension {
+      get => DimensionRefParameter.Value.Value;
+      set => DimensionRefParameter.Value.Value = value;
+    }
+
+    public DoubleMatrix Bounds {
+      get => BoundsRefParameter.Value;
+      set => BoundsRefParameter.Value = value;
+    }
 
     [StorableConstructor]
     private SingleObjectiveRealVectorExternalEvaluationProblem(StorableConstructorFlag _) : base(_) { }
-    private SingleObjectiveRealVectorExternalEvaluationProblem(SingleObjectiveRealVectorExternalEvaluationProblem original, Cloner cloner) : base(original, cloner) { }
+    private SingleObjectiveRealVectorExternalEvaluationProblem(SingleObjectiveRealVectorExternalEvaluationProblem original, Cloner cloner)
+      : base(original, cloner) {
+      DimensionRefParameter = cloner.Clone(original.DimensionRefParameter);
+      BoundsRefParameter = cloner.Clone(original.BoundsRefParameter);
+    }
 
     public SingleObjectiveRealVectorExternalEvaluationProblem()
       : base(new RealVectorEncoding()) {
-      var lengthParameter = new FixedValueParameter<IntValue>("Length", "The length of the vector.", new IntValue(10));
-      Parameters.Add(lengthParameter);
-      Encoding.LengthParameter = lengthParameter;
+      Parameters.Add(DimensionRefParameter = new ReferenceParameter<IntValue>("Dimension", "The dimension of the vector.", Encoding.LengthParameter));
+      Parameters.Add(BoundsRefParameter = new ReferenceParameter<DoubleMatrix>("Bounds", "The bounding box of the elements.", Encoding.BoundsParameter));
       // TODO: Add and parameterize additional operators, 
     }
@@ -110,14 +153,22 @@
   [StorableType("ad9d45f8-b97e-49a7-b3d2-487d9a2cbdf9")]
   public sealed class SingleObjectivePermutationExternalEvaluationProblem : ExternalEvaluationProblem<PermutationEncoding, Permutation> {
+    [Storable] private ReferenceParameter<IntValue> DimensionRefParameter;
+    public IValueParameter<IntValue> DimensionParameter => DimensionRefParameter;
+
+    public int Dimension {
+      get => DimensionRefParameter.Value.Value;
+      set => DimensionRefParameter.Value.Value = value;
+    }
 
     [StorableConstructor]
     private SingleObjectivePermutationExternalEvaluationProblem(StorableConstructorFlag _) : base(_) { }
-    private SingleObjectivePermutationExternalEvaluationProblem(SingleObjectivePermutationExternalEvaluationProblem original, Cloner cloner) : base(original, cloner) { }
+    private SingleObjectivePermutationExternalEvaluationProblem(SingleObjectivePermutationExternalEvaluationProblem original, Cloner cloner)
+      : base(original, cloner) {
+      DimensionRefParameter = cloner.Clone(original.DimensionRefParameter);
+    }
 
     public SingleObjectivePermutationExternalEvaluationProblem()
       : base(new PermutationEncoding()) {
-      var lengthParameter = new FixedValueParameter<IntValue>("Length", "The length of the permutation.", new IntValue(10));
-      Parameters.Add(lengthParameter);
-      Encoding.LengthParameter = lengthParameter;
+      Parameters.Add(DimensionRefParameter = new ReferenceParameter<IntValue>("Dimension", "The dimension of the vector.", Encoding.LengthParameter));
       // TODO: Add and parameterize additional operators, 
     }
@@ -140,4 +191,5 @@
     public SingleObjectiveSymbolicExpressionTreeExternalEvaluationProblem()
       : base(new SymbolicExpressionTreeEncoding()) {
+      // TODO: Change to ReferenceParameter
       var lengthParameter = new FixedValueParameter<IntValue>("TreeLength", "The total amount of nodes.", new IntValue(50));
       Parameters.Add(lengthParameter);
@@ -159,14 +211,22 @@
   [StorableType("945a35d9-89a8-4423-9ea0-21829ac68887")]
   public sealed class SingleObjectiveLinearLinkageExternalEvaluationProblem : ExternalEvaluationProblem<LinearLinkageEncoding, LinearLinkage> {
+    [Storable] private ReferenceParameter<IntValue> DimensionRefParameter;
+    public IValueParameter<IntValue> DimensionParameter => DimensionRefParameter;
+
+    public int Dimension {
+      get => DimensionRefParameter.Value.Value;
+      set => DimensionRefParameter.Value.Value = value;
+    }
 
     [StorableConstructor]
     private SingleObjectiveLinearLinkageExternalEvaluationProblem(StorableConstructorFlag _) : base(_) { }
-    private SingleObjectiveLinearLinkageExternalEvaluationProblem(SingleObjectiveLinearLinkageExternalEvaluationProblem original, Cloner cloner) : base(original, cloner) { }
+    private SingleObjectiveLinearLinkageExternalEvaluationProblem(SingleObjectiveLinearLinkageExternalEvaluationProblem original, Cloner cloner)
+      : base(original, cloner) {
+      DimensionRefParameter = cloner.Clone(original.DimensionRefParameter);
+    }
 
     public SingleObjectiveLinearLinkageExternalEvaluationProblem()
       : base(new LinearLinkageEncoding()) {
-      var lengthParameter = new FixedValueParameter<IntValue>("Length", "The length of the vector.", new IntValue(10));
-      Parameters.Add(lengthParameter);
-      Encoding.LengthParameter = lengthParameter;
+      Parameters.Add(DimensionRefParameter = new ReferenceParameter<IntValue>("Dimension", "The dimension of the vector.", Encoding.LengthParameter));
       // TODO: Add and parameterize additional operators, 
     }
@@ -199,14 +259,23 @@
   [StorableType("f14c7e88-b74d-4cad-ae55-83daf7b4c288")]
   public sealed class MultiObjectiveBinaryVectorExternalEvaluationProblem : MultiObjectiveExternalEvaluationProblem<BinaryVectorEncoding, BinaryVector> {
+    [Storable] private ReferenceParameter<IntValue> DimensionRefParameter;
+    public IValueParameter<IntValue> DimensionParameter => DimensionRefParameter;
+
+    public int Dimension {
+      get => Encoding.Length;
+      set => Encoding.Length = value;
+    }
 
     [StorableConstructor]
     private MultiObjectiveBinaryVectorExternalEvaluationProblem(StorableConstructorFlag _) : base(_) { }
-    private MultiObjectiveBinaryVectorExternalEvaluationProblem(MultiObjectiveBinaryVectorExternalEvaluationProblem original, Cloner cloner) : base(original, cloner) { }
+    private MultiObjectiveBinaryVectorExternalEvaluationProblem(MultiObjectiveBinaryVectorExternalEvaluationProblem original, Cloner cloner)
+      : base(original, cloner) {
+      DimensionRefParameter = cloner.Clone(original.DimensionRefParameter);
+    }
 
     public MultiObjectiveBinaryVectorExternalEvaluationProblem()
       : base(new BinaryVectorEncoding()) {
-      var lengthParameter = new FixedValueParameter<IntValue>("Length", "The length of the vector.", new IntValue(10));
-      Parameters.Add(lengthParameter);
-      Encoding.LengthParameter = lengthParameter;
+      Parameters.Add(DimensionRefParameter = new ReferenceParameter<IntValue>("Dimension", "The dimension of the vector.", Encoding.LengthParameter));
+      DimensionRefParameter.ForceValue(new IntValue(Dimension, @readonly: false));
       // TODO: Add and parameterize additional operators, 
     }
@@ -222,14 +291,31 @@
   [StorableType("90a82c2f-6c37-4ffd-8495-bee278c583d3")]
   public sealed class MultiObjectiveIntegerVectorExternalEvaluationProblem : MultiObjectiveExternalEvaluationProblem<IntegerVectorEncoding, IntegerVector> {
+    [Storable] private ReferenceParameter<IntValue> DimensionRefParameter;
+    public IValueParameter<IntValue> DimensionParameter => DimensionRefParameter;
+    [Storable] private ReferenceParameter<IntMatrix> BoundsRefParameter;
+    public IValueParameter<IntMatrix> BoundsParameter => BoundsRefParameter;
+
+    public int Dimension {
+      get => DimensionRefParameter.Value.Value;
+      set => DimensionRefParameter.Value.Value = value;
+    }
+
+    public IntMatrix Bounds {
+      get => BoundsRefParameter.Value;
+      set => BoundsRefParameter.Value = value;
+    }
 
     [StorableConstructor]
     private MultiObjectiveIntegerVectorExternalEvaluationProblem(StorableConstructorFlag _) : base(_) { }
-    private MultiObjectiveIntegerVectorExternalEvaluationProblem(MultiObjectiveIntegerVectorExternalEvaluationProblem original, Cloner cloner) : base(original, cloner) { }
+    private MultiObjectiveIntegerVectorExternalEvaluationProblem(MultiObjectiveIntegerVectorExternalEvaluationProblem original, Cloner cloner)
+      : base(original, cloner) {
+      DimensionRefParameter = cloner.Clone(original.DimensionRefParameter);
+      BoundsRefParameter = cloner.Clone(original.BoundsRefParameter);
+    }
 
     public MultiObjectiveIntegerVectorExternalEvaluationProblem()
       : base(new IntegerVectorEncoding()) {
-      var lengthParameter = new FixedValueParameter<IntValue>("Length", "The length of the vector.", new IntValue(10));
-      Parameters.Add(lengthParameter);
-      Encoding.LengthParameter = lengthParameter;
+      Parameters.Add(DimensionRefParameter = new ReferenceParameter<IntValue>("Dimension", "The dimension of the vector.", Encoding.LengthParameter));
+      Parameters.Add(BoundsRefParameter = new ReferenceParameter<IntMatrix>("Bounds", "The bounding box and step size of the elements.", Encoding.BoundsParameter));
       // TODO: Add and parameterize additional operators, 
     }
@@ -245,14 +331,31 @@
   [StorableType("38e1d068-d569-48c5-bad6-cbdd685b7c6b")]
   public sealed class MultiObjectiveRealVectorExternalEvaluationProblem : MultiObjectiveExternalEvaluationProblem<RealVectorEncoding, RealVector> {
+    [Storable] private ReferenceParameter<IntValue> DimensionRefParameter;
+    public IValueParameter<IntValue> DimensionParameter => DimensionRefParameter;
+    [Storable] private ReferenceParameter<DoubleMatrix> BoundsRefParameter;
+    public IValueParameter<DoubleMatrix> BoundsParameter => BoundsRefParameter;
+
+    public int Dimension {
+      get => DimensionRefParameter.Value.Value;
+      set => DimensionRefParameter.Value.Value = value;
+    }
+
+    public DoubleMatrix Bounds {
+      get => BoundsRefParameter.Value;
+      set => BoundsRefParameter.Value = value;
+    }
 
     [StorableConstructor]
     private MultiObjectiveRealVectorExternalEvaluationProblem(StorableConstructorFlag _) : base(_) { }
-    private MultiObjectiveRealVectorExternalEvaluationProblem(MultiObjectiveRealVectorExternalEvaluationProblem original, Cloner cloner) : base(original, cloner) { }
+    private MultiObjectiveRealVectorExternalEvaluationProblem(MultiObjectiveRealVectorExternalEvaluationProblem original, Cloner cloner)
+      : base(original, cloner) {
+      DimensionRefParameter = cloner.Clone(original.DimensionRefParameter);
+      BoundsRefParameter = cloner.Clone(original.BoundsRefParameter);
+    }
 
     public MultiObjectiveRealVectorExternalEvaluationProblem()
       : base(new RealVectorEncoding()) {
-      var lengthParameter = new FixedValueParameter<IntValue>("Length", "The length of the vector.", new IntValue(10));
-      Parameters.Add(lengthParameter);
-      Encoding.LengthParameter = lengthParameter;
+      Parameters.Add(DimensionRefParameter = new ReferenceParameter<IntValue>("Dimension", "The dimension of the vector.", Encoding.LengthParameter));
+      Parameters.Add(BoundsRefParameter = new ReferenceParameter<DoubleMatrix>("Bounds", "The bounding box of the elements.", Encoding.BoundsParameter));
       // TODO: Add and parameterize additional operators, 
     }
@@ -268,14 +371,22 @@
   [StorableType("f1b265b0-ac7c-4c36-b346-5b3f2c37694b")]
   public sealed class MultiObjectivePermutationExternalEvaluationProblem : MultiObjectiveExternalEvaluationProblem<PermutationEncoding, Permutation> {
+    [Storable] private ReferenceParameter<IntValue> DimensionRefParameter;
+    public IValueParameter<IntValue> DimensionParameter => DimensionRefParameter;
+
+    public int Dimension {
+      get => DimensionRefParameter.Value.Value;
+      set => DimensionRefParameter.Value.Value = value;
+    }
 
     [StorableConstructor]
     private MultiObjectivePermutationExternalEvaluationProblem(StorableConstructorFlag _) : base(_) { }
-    private MultiObjectivePermutationExternalEvaluationProblem(MultiObjectivePermutationExternalEvaluationProblem original, Cloner cloner) : base(original, cloner) { }
+    private MultiObjectivePermutationExternalEvaluationProblem(MultiObjectivePermutationExternalEvaluationProblem original, Cloner cloner)
+      : base(original, cloner) {
+      DimensionRefParameter = cloner.Clone(original.DimensionRefParameter);
+    }
 
     public MultiObjectivePermutationExternalEvaluationProblem()
       : base(new PermutationEncoding()) {
-      var lengthParameter = new FixedValueParameter<IntValue>("Length", "The length of the permutation.", new IntValue(10));
-      Parameters.Add(lengthParameter);
-      Encoding.LengthParameter = lengthParameter;
+      Parameters.Add(DimensionRefParameter = new ReferenceParameter<IntValue>("Dimension", "The dimension of the vector.", Encoding.LengthParameter));
       // TODO: Add and parameterize additional operators, 
     }
@@ -298,4 +409,5 @@
     public MultiObjectiveSymbolicExpressionTreeExternalEvaluationProblem()
       : base(new SymbolicExpressionTreeEncoding()) {
+      // TODO: Change to ReferenceParameter
       var lengthParameter = new FixedValueParameter<IntValue>("TreeLength", "The total amount of nodes.", new IntValue(50));
       Parameters.Add(lengthParameter);
@@ -317,14 +429,22 @@
   [StorableType("ed0c1129-651d-465f-87b0-f412f3e3b3d1")]
   public sealed class MultiObjectiveLinearLinkageExternalEvaluationProblem : MultiObjectiveExternalEvaluationProblem<LinearLinkageEncoding, LinearLinkage> {
+    [Storable] private ReferenceParameter<IntValue> DimensionRefParameter;
+    public IValueParameter<IntValue> DimensionParameter => DimensionRefParameter;
+
+    public int Dimension {
+      get => DimensionRefParameter.Value.Value;
+      set => DimensionRefParameter.Value.Value = value;
+    }
 
     [StorableConstructor]
     private MultiObjectiveLinearLinkageExternalEvaluationProblem(StorableConstructorFlag _) : base(_) { }
-    private MultiObjectiveLinearLinkageExternalEvaluationProblem(MultiObjectiveLinearLinkageExternalEvaluationProblem original, Cloner cloner) : base(original, cloner) { }
+    private MultiObjectiveLinearLinkageExternalEvaluationProblem(MultiObjectiveLinearLinkageExternalEvaluationProblem original, Cloner cloner)
+      : base(original, cloner) {
+      DimensionRefParameter = cloner.Clone(original.DimensionRefParameter);
+    }
 
     public MultiObjectiveLinearLinkageExternalEvaluationProblem()
       : base(new LinearLinkageEncoding()) {
-      var lengthParameter = new FixedValueParameter<IntValue>("Length", "The length of the vector.", new IntValue(10));
-      Parameters.Add(lengthParameter);
-      Encoding.LengthParameter = lengthParameter;
+      Parameters.Add(DimensionRefParameter = new ReferenceParameter<IntValue>("Dimension", "The dimension of the vector.", Encoding.LengthParameter));
       // TODO: Add and parameterize additional operators, 
     }
Index: /branches/2521_ProblemRefactoring/HeuristicLab.Problems.GraphColoring/3.3/GraphColoringProblem.cs
===================================================================
--- /branches/2521_ProblemRefactoring/HeuristicLab.Problems.GraphColoring/3.3/GraphColoringProblem.cs	(revision 17543)
+++ /branches/2521_ProblemRefactoring/HeuristicLab.Problems.GraphColoring/3.3/GraphColoringProblem.cs	(revision 17544)
@@ -83,5 +83,5 @@
         imat[i, 1] = defaultInstance[i].Item2 - 1;
       }
-      Encoding.Length = defaultInstanceNodes;
+      Dimension = defaultInstanceNodes;
       AdjacencyListParameter.Value = imat;
       BestKnownQualityParameter.Value = null;
@@ -121,6 +121,6 @@
       if (FitnessFunction == FitnessFunction.Prioritized
         && BestKnownColorsParameter.Value != null
-        && Encoding.Length > 0) {
-        var mag = Math.Pow(10, -(int)Math.Ceiling(Math.Log10(Encoding.Length)));
+        && Dimension > 0) {
+        var mag = Math.Pow(10, -(int)Math.Ceiling(Math.Log10(Dimension)));
         // the value is e.g. 0.051 for 0 conflicts with 51 colors (and less than 1000 nodes)
         BestKnownQuality = BestKnownColorsParameter.Value.Value * mag;
@@ -247,5 +247,5 @@
 
     public void Load(GCPData data) {
-      Encoding.Length = data.Nodes;
+      Dimension = data.Nodes;
       AdjacencyListParameter.Value = new IntMatrix(data.Adjacencies);
       if (data.BestKnownColoring != null) {
@@ -279,5 +279,5 @@
       instance.Name = Name;
       instance.Description = Description;
-      instance.Nodes = Encoding.Length;
+      instance.Nodes = Dimension;
       var adjList = AdjacencyListParameter.Value;
       instance.Adjacencies = new int[adjList.Rows, 2];
Index: /branches/2521_ProblemRefactoring/HeuristicLab.Problems.Knapsack/3.3/KnapsackProblem.cs
===================================================================
--- /branches/2521_ProblemRefactoring/HeuristicLab.Problems.Knapsack/3.3/KnapsackProblem.cs	(revision 17543)
+++ /branches/2521_ProblemRefactoring/HeuristicLab.Problems.Knapsack/3.3/KnapsackProblem.cs	(revision 17544)
@@ -91,4 +91,5 @@
       Parameters.Add(new OptionalValueParameter<BinaryVector>("BestKnownSolution", "The best known solution of this Knapsack instance."));
 
+      Dimension = Weights.Length;
       InitializeRandomKnapsackInstance();
 
@@ -125,6 +126,4 @@
       ValuesParameter.ValueChanged += ValuesParameter_ValueChanged;
       ValuesParameter.Value.Reset += ValuesValue_Reset;
-      // TODO: There is no even to detect if the parameter itself was changed
-      Encoding.LengthParameter.ValueChanged += Encoding_LengthParameter_ValueChanged;
     }
 
@@ -144,4 +143,14 @@
       Parameterize();
     }
+    protected override void DimensionOnChanged() {
+      base.DimensionOnChanged();
+      if (Weights.Length != Dimension) {
+        ((IStringConvertibleArray)WeightsParameter.Value).Length = Dimension;
+      }
+      if (Values.Length != Dimension) {
+        ((IStringConvertibleArray)ValuesParameter.Value).Length = Dimension;
+      }
+      Parameterize();
+    }
     private void Evaluator_QualityParameter_ActualNameChanged(object sender, EventArgs e) {
       Parameterize();
@@ -157,5 +166,5 @@
       if (WeightsParameter.Value != null && ValuesParameter.Value != null) {
         ((IStringConvertibleArray)ValuesParameter.Value).Length = Weights.Length;
-        Encoding.Length = Weights.Length;
+        Dimension = Weights.Length;
       }
       Parameterize();
@@ -168,14 +177,5 @@
       if (WeightsParameter.Value != null && ValuesParameter.Value != null) {
         ((IStringConvertibleArray)WeightsParameter.Value).Length = Values.Length;
-        Encoding.Length = Values.Length;
-      }
-      Parameterize();
-    }
-    private void Encoding_LengthParameter_ValueChanged(object sender, EventArgs e) {
-      if (Weights.Length != Encoding.Length) {
-        ((IStringConvertibleArray)WeightsParameter.Value).Length = Encoding.Length;
-      }
-      if (Values.Length != Encoding.Length) {
-        ((IStringConvertibleArray)ValuesParameter.Value).Length = Encoding.Length;
+        Dimension = Values.Length;
       }
       Parameterize();
@@ -271,4 +271,5 @@
 
       KnapsackCapacity = (int)Math.Round(0.7 * totalWeight);
+      Dimension = Weights.Length;
     }
   }
Index: /branches/2521_ProblemRefactoring/HeuristicLab.Problems.LinearAssignment/3.3/LinearAssignmentProblem.cs
===================================================================
--- /branches/2521_ProblemRefactoring/HeuristicLab.Problems.LinearAssignment/3.3/LinearAssignmentProblem.cs	(revision 17543)
+++ /branches/2521_ProblemRefactoring/HeuristicLab.Problems.LinearAssignment/3.3/LinearAssignmentProblem.cs	(revision 17544)
@@ -243,4 +243,5 @@
 
     private void Parameterize() {
+      if (Costs.Rows != Dimension) Dimension = Costs.Rows;
       foreach (var similarityCalculator in Operators.OfType<ISolutionSimilarityCalculator>()) {
         similarityCalculator.SolutionVariableName = Encoding.Name;
Index: /branches/2521_ProblemRefactoring/HeuristicLab.Problems.NK/3.3/NKLandscape.cs
===================================================================
--- /branches/2521_ProblemRefactoring/HeuristicLab.Problems.NK/3.3/NKLandscape.cs	(revision 17543)
+++ /branches/2521_ProblemRefactoring/HeuristicLab.Problems.NK/3.3/NKLandscape.cs	(revision 17544)
@@ -232,6 +232,7 @@
     }
 
-    protected override void LengthParameter_ValueChanged(object sender, EventArgs e) {
-      NrOfFitnessComponentsParameter.Value = new IntValue(Length);
+    protected override void DimensionOnChanged() {
+      base.DimensionOnChanged();
+      NrOfFitnessComponentsParameter.Value = new IntValue(Dimension);
     }
 
@@ -259,5 +260,5 @@
       if (InteractionInitializer != null)
         GeneInteractionsParameter.Value = InteractionInitializer.InitializeInterations(
-          Length,
+          Dimension,
           NrOfFitnessComponents.Value,
           NrOfInteractions.Value, random);
Index: /branches/2521_ProblemRefactoring/HeuristicLab.Problems.Orienteering/3.3/OrienteeringProblem.cs
===================================================================
--- /branches/2521_ProblemRefactoring/HeuristicLab.Problems.Orienteering/3.3/OrienteeringProblem.cs	(revision 17543)
+++ /branches/2521_ProblemRefactoring/HeuristicLab.Problems.Orienteering/3.3/OrienteeringProblem.cs	(revision 17544)
@@ -20,4 +20,5 @@
 #endregion
 
+using System;
 using System.Collections.Generic;
 using System.IO;
@@ -75,4 +76,5 @@
       Parameters.Add(BestOrienteeringSolutionParameter = new ResultParameter<OrienteeringSolution>("Best Orienteering Solution", "The best so far solution found."));
       Maximization = true;
+      Dimension = OrienteeringProblemData.Cities;
 
       InitializeOperators();
@@ -145,7 +147,10 @@
     }
 
-    protected override void OnEncodingChanged() {
-      base.OnEncodingChanged();
-      ParameterizeOperators();
+    private void RegisterEventHandlers() {
+      OrienteeringProblemDataParameter.ValueChanged += OrienteeringProblemDataParameterOnValueChanged;
+    }
+
+    private void OrienteeringProblemDataParameterOnValueChanged(object sender, EventArgs e) {
+      Dimension = OrienteeringProblemData.Cities;
     }
 
@@ -153,4 +158,9 @@
       base.OnEvaluatorChanged();
       ParameterizeOperators();
+    }
+    protected override void DimensionOnChanged() {
+      base.DimensionOnChanged();
+      if (Dimension != OrienteeringProblemData.Cities)
+        Dimension = OrienteeringProblemData.Cities;
     }
 
@@ -159,5 +169,4 @@
         OrienteeringProblemDataParameter = { ActualName = OrienteeringProblemDataParameter.Name }
       };
-
       Operators.Add(new OrienteeringLocalImprovementOperator() {
         OrienteeringProblemDataParameter = { ActualName = OrienteeringProblemDataParameter.Name }
Index: /branches/2521_ProblemRefactoring/HeuristicLab.Problems.PTSP/3.3/ProbabilisticTSP.cs
===================================================================
--- /branches/2521_ProblemRefactoring/HeuristicLab.Problems.PTSP/3.3/ProbabilisticTSP.cs	(revision 17543)
+++ /branches/2521_ProblemRefactoring/HeuristicLab.Problems.PTSP/3.3/ProbabilisticTSP.cs	(revision 17544)
@@ -70,10 +70,5 @@
 
       ProbabilisticTSPData = new ProbabilisticTSPData();
-      Encoding.Length = ProbabilisticTSPData.Cities;
-    }
-
-    protected override void OnEncodingChanged() {
-      base.OnEncodingChanged();
-      Encoding.Length = ProbabilisticTSPData.Cities;
+      Dimension = ProbabilisticTSPData.Cities;
     }
 
@@ -112,5 +107,5 @@
         throw new System.IO.InvalidDataException("The coordinates of the given instance are not in the right format, there need to be one row for each customer and two columns for the x and y coordinates.");
 
-      Encoding.Length = data.Dimension;
+      Dimension = data.Dimension;
       Name = data.Name;
       Description = data.Description;
Index: /branches/2521_ProblemRefactoring/HeuristicLab.Problems.QuadraticAssignment/3.3/QuadraticAssignmentProblem.cs
===================================================================
--- /branches/2521_ProblemRefactoring/HeuristicLab.Problems.QuadraticAssignment/3.3/QuadraticAssignmentProblem.cs	(revision 17543)
+++ /branches/2521_ProblemRefactoring/HeuristicLab.Problems.QuadraticAssignment/3.3/QuadraticAssignmentProblem.cs	(revision 17544)
@@ -102,5 +102,4 @@
       LowerBoundParameter = cloner.Clone(original.LowerBoundParameter);
       AverageQualityParameter = cloner.Clone(original.AverageQualityParameter);
-      RegisterEventHandlers();
     }
     public QuadraticAssignmentProblem()
@@ -133,5 +132,4 @@
 
       InitializeOperators();
-      RegisterEventHandlers();
     }
 
@@ -155,28 +153,8 @@
     }
 
-    [StorableHook(HookType.AfterDeserialization)]
-    private void AfterDeserialization() {
-      // BackwardsCompatibility3.3
-      #region Backwards compatible code, remove with 3.4
-      if (BestKnownSolutionsParameter == null)
-        BestKnownSolutionsParameter = (IValueParameter<ItemSet<Permutation>>)Parameters["BestKnownSolutions"];
-      if (BestKnownSolutionParameter == null)
-        BestKnownSolutionParameter = (IValueParameter<Permutation>)Parameters["BestKnownSolution"];
-      if (WeightsParameter == null)
-        WeightsParameter = (IValueParameter<DoubleMatrix>)Parameters["Weights"];
-      if (DistancesParameter == null)
-        DistancesParameter = (IValueParameter<DoubleMatrix>)Parameters["Distances"];
-      if (LowerBoundParameter == null)
-        LowerBoundParameter = (IValueParameter<DoubleValue>)Parameters["LowerBound"];
-      if (AverageQualityParameter == null)
-        AverageQualityParameter = (IValueParameter<DoubleValue>)Parameters["AverageQuality"];
-      #endregion
-      RegisterEventHandlers();
-    }
-
     #region Events
     protected override void OnEncodingChanged() {
       base.OnEncodingChanged();
-      Encoding.Length = Weights.Rows;
+      Dimension = Weights.Rows;
       Parameterize();
     }
@@ -191,10 +169,7 @@
     #endregion
 
-    private void RegisterEventHandlers() {
-      Encoding.LengthParameter.Value.ValueChanged += EncodingLengthOnChanged;
-    }
-
-    private void EncodingLengthOnChanged(object sender, EventArgs e) {
-      if (Encoding.Length != Weights.Rows) Encoding.Length = Weights.Rows;
+    protected override void DimensionOnChanged() {
+      base.DimensionOnChanged();
+      if (Dimension != Weights.Rows) Dimension = Weights.Rows;
     }
 
@@ -354,5 +329,5 @@
       Weights = weights;
       Distances = distances;
-      Encoding.Length = weights.Rows;
+      Dimension = weights.Rows;
 
       BestKnownQualityParameter.Value = null;
Index: /branches/2521_ProblemRefactoring/HeuristicLab.Problems.TestFunctions.MultiObjective/3.3/MultiObjectiveTestFunctionProblem.cs
===================================================================
--- /branches/2521_ProblemRefactoring/HeuristicLab.Problems.TestFunctions.MultiObjective/3.3/MultiObjectiveTestFunctionProblem.cs	(revision 17543)
+++ /branches/2521_ProblemRefactoring/HeuristicLab.Problems.TestFunctions.MultiObjective/3.3/MultiObjectiveTestFunctionProblem.cs	(revision 17544)
@@ -37,12 +37,6 @@
   public class MultiObjectiveTestFunctionProblem : RealVectorMultiObjectiveProblem, IProblemInstanceConsumer<MOTFData>, IMultiObjectiveProblemDefinition<RealVectorEncoding, RealVector> {
     #region Parameter Properties
-    public IFixedValueParameter<IntValue> ProblemSizeParameter {
-      get { return (IFixedValueParameter<IntValue>)Parameters["ProblemSize"]; }
-    }
     public IFixedValueParameter<IntValue> ObjectivesParameter {
       get { return (IFixedValueParameter<IntValue>)Parameters["Objectives"]; }
-    }
-    public IValueParameter<DoubleMatrix> BoundsParameter {
-      get { return (IValueParameter<DoubleMatrix>)Parameters["Bounds"]; }
     }
     public IValueParameter<IMultiObjectiveTestFunction> TestFunctionParameter {
@@ -52,15 +46,7 @@
 
     #region Properties
-    public int ProblemSize {
-      get { return ProblemSizeParameter.Value.Value; }
-      set { ProblemSizeParameter.Value.Value = value; }
-    }
     public new int Objectives {
       get { return ObjectivesParameter.Value.Value; }
       set { ObjectivesParameter.Value.Value = value; }
-    }
-    public DoubleMatrix Bounds {
-      get { return BoundsParameter.Value; }
-      set { BoundsParameter.Value = value; }
     }
     public IMultiObjectiveTestFunction TestFunction {
@@ -85,11 +71,7 @@
 
     public MultiObjectiveTestFunctionProblem() : base() {
-      Parameters.Add(new FixedValueParameter<IntValue>("ProblemSize", "The dimensionality of the problem instance (number of variables in the function).", new IntValue(2)));
       Parameters.Add(new FixedValueParameter<IntValue>("Objectives", "The dimensionality of the solution vector (number of objectives).", new IntValue(2)));
-      Parameters.Add(new ValueParameter<DoubleMatrix>("Bounds", "The bounds of the solution given as either one line for all variables or a line for each variable. The first column specifies lower bound, the second upper bound.", new DoubleMatrix(new double[,] { { -4, 4 } })));
       Parameters.Add(new ValueParameter<IMultiObjectiveTestFunction>("TestFunction", "The function that is to be optimized.", new Fonseca()));
 
-      Encoding.LengthParameter = ProblemSizeParameter;
-      Encoding.BoundsParameter = BoundsParameter;
       BestKnownFrontParameter.Hidden = true;
 
@@ -101,5 +83,4 @@
     private void RegisterEventHandlers() {
       TestFunctionParameter.ValueChanged += TestFunctionParameterOnValueChanged;
-      ProblemSizeParameter.Value.ValueChanged += ProblemSizeOnValueChanged;
       ObjectivesParameter.Value.ValueChanged += ObjectivesOnValueChanged;
     }
@@ -156,6 +137,13 @@
     }
 
+    protected override void DimensionOnChanged() {
+      base.DimensionOnChanged();
+      if (Dimension < TestFunction.MinimumSolutionLength || Dimension > TestFunction.MaximumSolutionLength)
+        Dimension = Math.Min(TestFunction.MaximumSolutionLength, Math.Max(TestFunction.MinimumSolutionLength, Dimension));
+      UpdateParameterValues();
+    }
+
     private void TestFunctionParameterOnValueChanged(object sender, EventArgs eventArgs) {
-      ProblemSize = Math.Max(TestFunction.MinimumSolutionLength, Math.Min(ProblemSize, TestFunction.MaximumSolutionLength));
+      Dimension = Math.Max(TestFunction.MinimumSolutionLength, Math.Min(Dimension, TestFunction.MaximumSolutionLength));
       Objectives = Math.Max(TestFunction.MinimumObjectives, Math.Min(Objectives, TestFunction.MaximumObjectives));
       Parameters.Remove(ReferencePointParameterName);
@@ -163,9 +151,4 @@
       UpdateParameterValues();
       OnReset();
-    }
-
-    private void ProblemSizeOnValueChanged(object sender, EventArgs eventArgs) {
-      ProblemSize = Math.Min(TestFunction.MaximumSolutionLength, Math.Max(TestFunction.MinimumSolutionLength, ProblemSize));
-      UpdateParameterValues();
     }
 
Index: /branches/2521_ProblemRefactoring/HeuristicLab.Problems.TestFunctions/3.3/SingleObjectiveTestFunctionProblem.cs
===================================================================
--- /branches/2521_ProblemRefactoring/HeuristicLab.Problems.TestFunctions/3.3/SingleObjectiveTestFunctionProblem.cs	(revision 17543)
+++ /branches/2521_ProblemRefactoring/HeuristicLab.Problems.TestFunctions/3.3/SingleObjectiveTestFunctionProblem.cs	(revision 17544)
@@ -42,10 +42,4 @@
 
     #region Parameter Properties
-    private IFixedValueParameter<IntValue> ProblemSizeParameter {
-      get { return (IFixedValueParameter<IntValue>)Parameters["ProblemSize"]; }
-    }
-    private IValueParameter<DoubleMatrix> BoundsParameter {
-      get { return (IValueParameter<DoubleMatrix>)Parameters["Bounds"]; }
-    }
     public OptionalValueParameter<RealVector> BestKnownSolutionParameter {
       get { return (OptionalValueParameter<RealVector>)Parameters["BestKnownSolution"]; }
@@ -57,12 +51,4 @@
 
     #region Properties
-    public int ProblemSize {
-      get { return ProblemSizeParameter.Value.Value; }
-      set { ProblemSizeParameter.Value.Value = value; }
-    }
-    public DoubleMatrix Bounds {
-      get { return BoundsParameter.Value; }
-      set { BoundsParameter.Value = value; }
-    }
     public ISingleObjectiveTestFunction TestFunction {
       get { return TestFunctionParameter.Value; }
@@ -79,12 +65,8 @@
     public SingleObjectiveTestFunctionProblem()
       : base(new RealVectorEncoding("Point")) {
-      Parameters.Add(new FixedValueParameter<IntValue>("ProblemSize", "The dimensionality of the problem instance (number of variables in the function).", new IntValue(2)));
-      Parameters.Add(new ValueParameter<DoubleMatrix>("Bounds", "The bounds of the solution given as either one line for all variables or a line for each variable. The first column specifies lower bound, the second upper bound.", new DoubleMatrix(new double[,] { { -100, 100 } })));
       Parameters.Add(new OptionalValueParameter<RealVector>("BestKnownSolution", "The best known solution for this test function instance."));
       Parameters.Add(new ValueParameter<ISingleObjectiveTestFunction>("TestFunction", "The function that is to be optimized.", new Ackley()));
       Maximization = TestFunction.Maximization;
 
-      Encoding.LengthParameter = ProblemSizeParameter;
-      Encoding.BoundsParameter = BoundsParameter;
       BestKnownQuality = TestFunction.BestKnownQuality;
 
@@ -105,6 +87,4 @@
       Evaluator.QualityParameter.ActualNameChanged += Evaluator_QualityParameter_ActualNameChanged;
       TestFunctionParameter.ValueChanged += TestFunctionParameterOnValueChanged;
-      ProblemSizeParameter.Value.ValueChanged += ProblemSizeOnValueChanged;
-      BoundsParameter.ValueChanged += BoundsParameterOnValueChanged;
     }
 
@@ -156,28 +136,29 @@
       Parameterize();
     }
+    protected override void DimensionOnChanged() {
+      base.DimensionOnChanged();
+      if (Dimension < TestFunction.MinimumProblemSize || Dimension > TestFunction.MaximumProblemSize)
+        Dimension = Math.Min(TestFunction.MaximumProblemSize, Math.Max(TestFunction.MinimumProblemSize, Dimension));
+    }
+    protected override void BoundsOnChanged() {
+      base.BoundsOnChanged();
+      Parameterize();
+    }
     private void Evaluator_QualityParameter_ActualNameChanged(object sender, EventArgs e) {
       Parameterize();
     }
     private void TestFunctionParameterOnValueChanged(object sender, EventArgs eventArgs) {
-      var problemSizeChange = ProblemSize < TestFunction.MinimumProblemSize
-                              || ProblemSize > TestFunction.MaximumProblemSize;
+      var problemSizeChange = Dimension < TestFunction.MinimumProblemSize
+                              || Dimension > TestFunction.MaximumProblemSize;
       if (problemSizeChange) {
-        ProblemSize = Math.Max(TestFunction.MinimumProblemSize, Math.Min(ProblemSize, TestFunction.MaximumProblemSize));
+        Dimension = Math.Max(TestFunction.MinimumProblemSize, Math.Min(Dimension, TestFunction.MaximumProblemSize));
       }
       BestKnownQuality = TestFunction.BestKnownQuality;
       Bounds = (DoubleMatrix)TestFunction.Bounds.Clone();
-      var bestSolution = TestFunction.GetBestKnownSolution(ProblemSize);
+      var bestSolution = TestFunction.GetBestKnownSolution(Dimension);
       BestKnownSolutionParameter.Value = bestSolution;
       Maximization = TestFunction.Maximization;
 
       OnReset();
-    }
-    private void ProblemSizeOnValueChanged(object sender, EventArgs eventArgs) {
-      if (ProblemSize < TestFunction.MinimumProblemSize
-        || ProblemSize > TestFunction.MaximumProblemSize)
-        ProblemSize = Math.Min(TestFunction.MaximumProblemSize, Math.Max(TestFunction.MinimumProblemSize, ProblemSize));
-    }
-    private void BoundsParameterOnValueChanged(object sender, EventArgs eventArgs) {
-      Parameterize();
     }
     #endregion
Index: /branches/2521_ProblemRefactoring/HeuristicLab.Problems.TravelingSalesman/3.3/TSP.cs
===================================================================
--- /branches/2521_ProblemRefactoring/HeuristicLab.Problems.TravelingSalesman/3.3/TSP.cs	(revision 17543)
+++ /branches/2521_ProblemRefactoring/HeuristicLab.Problems.TravelingSalesman/3.3/TSP.cs	(revision 17544)
@@ -76,5 +76,5 @@
       
       TSPData = new EuclideanTSPData();
-      Encoding.Length = TSPData.Cities;
+      Dimension = TSPData.Cities;
 
       InitializeOperators();
@@ -140,5 +140,5 @@
         throw new System.IO.InvalidDataException("The coordinates of the given instance are not in the right format, there need to be one row for each customer and two columns for the x and y coordinates.");
 
-      Encoding.Length = data.Dimension;
+      Dimension = data.Dimension;
       Name = data.Name;
       Description = data.Description;
@@ -212,5 +212,5 @@
     protected override void OnEncodingChanged() {
       base.OnEncodingChanged();
-      Encoding.Length = TSPData.Cities;
+      Dimension = TSPData.Cities;
       ParameterizeOperators();
     }
Index: /branches/2521_ProblemRefactoring/HeuristicLab.Tests/HeuristicLab-3.3/Samples/EsGriewankSampleTest.cs
===================================================================
--- /branches/2521_ProblemRefactoring/HeuristicLab.Tests/HeuristicLab-3.3/Samples/EsGriewankSampleTest.cs	(revision 17543)
+++ /branches/2521_ProblemRefactoring/HeuristicLab.Tests/HeuristicLab-3.3/Samples/EsGriewankSampleTest.cs	(revision 17544)
@@ -64,5 +64,5 @@
       SingleObjectiveTestFunctionProblem problem = new SingleObjectiveTestFunctionProblem();
 
-      problem.ProblemSize = 10;
+      problem.Dimension = 10;
       problem.TestFunction = new Griewank();
       problem.Encoding.SolutionCreator = new UniformRandomRealVectorCreator();
Index: /branches/2521_ProblemRefactoring/HeuristicLab.Tests/HeuristicLab-3.3/Samples/OSESGriewankSampleTest.cs
===================================================================
--- /branches/2521_ProblemRefactoring/HeuristicLab.Tests/HeuristicLab-3.3/Samples/OSESGriewankSampleTest.cs	(revision 17543)
+++ /branches/2521_ProblemRefactoring/HeuristicLab.Tests/HeuristicLab-3.3/Samples/OSESGriewankSampleTest.cs	(revision 17544)
@@ -63,5 +63,5 @@
       SingleObjectiveTestFunctionProblem problem = new SingleObjectiveTestFunctionProblem();
 
-      problem.ProblemSize = 10;
+      problem.Dimension = 10;
       problem.TestFunction = new Griewank();
       problem.Encoding.SolutionCreator = new UniformRandomRealVectorCreator();
Index: /branches/2521_ProblemRefactoring/HeuristicLab.Tests/HeuristicLab-3.3/Samples/SimulatedAnnealingRastriginSampleTest.cs
===================================================================
--- /branches/2521_ProblemRefactoring/HeuristicLab.Tests/HeuristicLab-3.3/Samples/SimulatedAnnealingRastriginSampleTest.cs	(revision 17543)
+++ /branches/2521_ProblemRefactoring/HeuristicLab.Tests/HeuristicLab-3.3/Samples/SimulatedAnnealingRastriginSampleTest.cs	(revision 17544)
@@ -62,5 +62,5 @@
       problem.Bounds = new DoubleMatrix(new double[,] { { -5.12, 5.12 } });
       problem.TestFunction= new Rastrigin();
-      problem.ProblemSize = 2;
+      problem.Dimension = 2;
       problem.Encoding.SolutionCreator = new UniformRandomRealVectorCreator();
       #endregion
Index: /branches/2521_ProblemRefactoring/HeuristicLab.Tests/HeuristicLab.Algorithms.ParameterlessPopulationPyramid-3.3/ParameterlessPopulationPyramidTest.cs
===================================================================
--- /branches/2521_ProblemRefactoring/HeuristicLab.Tests/HeuristicLab.Algorithms.ParameterlessPopulationPyramid-3.3/ParameterlessPopulationPyramidTest.cs	(revision 17543)
+++ /branches/2521_ProblemRefactoring/HeuristicLab.Tests/HeuristicLab.Algorithms.ParameterlessPopulationPyramid-3.3/ParameterlessPopulationPyramidTest.cs	(revision 17544)
@@ -60,10 +60,10 @@
     public void P3DeceptiveTrap() {
       var problem = new DeceptiveTrapProblem();
-      problem.Length = 49;
+      problem.NumberOfTraps = 7;
       problem.TrapSize = 7;
       DoRun(problem, 100, 123, 0.857142857142857, 50);
       DoRun(problem, 9876, 123, 0.918367346938776, 981);
       DoRun(problem, 20000, 987, 1, 19977);
-      problem.Length = 700;
+      problem.NumberOfTraps = 100;
       DoRun(problem, 100000, 987, 0.941428571428571, 96901);
     }
@@ -75,5 +75,5 @@
     public void P3DeceptiveStepTrap() {
       var problem = new DeceptiveStepTrapProblem();
-      problem.Length = 49;
+      problem.NumberOfTraps = 7;
       problem.TrapSize = 7;
       problem.StepSize = 2;
@@ -81,5 +81,5 @@
       DoRun(problem, 9876, 123, 0.785714285714286, 3489);
       DoRun(problem, 70000, 987, 1, 68292);
-      problem.Length = 700;
+      problem.NumberOfTraps = 100;
       DoRun(problem, 100000, 987, 0.76, 58711);
     }
@@ -91,8 +91,8 @@
     public void P3HIFF() {
       var problem = new HIFFProblem();
-      problem.Length = 32;
+      problem.Dimension = 32;
       DoRun(problem, 50, 12345, 0.375, 26);
       DoRun(problem, 1000, 12345, 1, 976);
-      problem.Length = 512;
+      problem.Dimension = 512;
       DoRun(problem, 1000, 54321, 0.17361111111111, 440);
       DoRun(problem, 130000, 54321, 1, 89214);
