Index: /branches/MemPRAlgorithm/HeuristicLab 3.3.sln
===================================================================
--- /branches/MemPRAlgorithm/HeuristicLab 3.3.sln	(revision 14465)
+++ /branches/MemPRAlgorithm/HeuristicLab 3.3.sln	(revision 14466)
@@ -452,4 +452,6 @@
 EndProject
 Project("{FAE04EC0-301F-11D3-BF4B-00C04F79EFBC}") = "HeuristicLab.Algorithms.MemPR-3.3", "HeuristicLab.Algorithms.MemPR\3.3\HeuristicLab.Algorithms.MemPR-3.3.csproj", "{9D274421-6332-4FBC-AAE4-467ACE27C368}"
+EndProject
+Project("{FAE04EC0-301F-11D3-BF4B-00C04F79EFBC}") = "HeuristicLab.Problems.GraphColoring-3.3", "HeuristicLab.Problems.GraphColoring\3.3\HeuristicLab.Problems.GraphColoring-3.3.csproj", "{4B76E2CB-A990-4959-B080-1D81D418D325}"
 EndProject
 Global
@@ -2203,4 +2205,16 @@
 		{9D274421-6332-4FBC-AAE4-467ACE27C368}.Release|x86.ActiveCfg = Release|x86
 		{9D274421-6332-4FBC-AAE4-467ACE27C368}.Release|x86.Build.0 = Release|x86
+		{4B76E2CB-A990-4959-B080-1D81D418D325}.Debug|Any CPU.ActiveCfg = Debug|Any CPU
+		{4B76E2CB-A990-4959-B080-1D81D418D325}.Debug|Any CPU.Build.0 = Debug|Any CPU
+		{4B76E2CB-A990-4959-B080-1D81D418D325}.Debug|x64.ActiveCfg = Debug|Any CPU
+		{4B76E2CB-A990-4959-B080-1D81D418D325}.Debug|x64.Build.0 = Debug|Any CPU
+		{4B76E2CB-A990-4959-B080-1D81D418D325}.Debug|x86.ActiveCfg = Debug|Any CPU
+		{4B76E2CB-A990-4959-B080-1D81D418D325}.Debug|x86.Build.0 = Debug|Any CPU
+		{4B76E2CB-A990-4959-B080-1D81D418D325}.Release|Any CPU.ActiveCfg = Release|Any CPU
+		{4B76E2CB-A990-4959-B080-1D81D418D325}.Release|Any CPU.Build.0 = Release|Any CPU
+		{4B76E2CB-A990-4959-B080-1D81D418D325}.Release|x64.ActiveCfg = Release|Any CPU
+		{4B76E2CB-A990-4959-B080-1D81D418D325}.Release|x64.Build.0 = Release|Any CPU
+		{4B76E2CB-A990-4959-B080-1D81D418D325}.Release|x86.ActiveCfg = Release|Any CPU
+		{4B76E2CB-A990-4959-B080-1D81D418D325}.Release|x86.Build.0 = Release|Any CPU
 	EndGlobalSection
 	GlobalSection(SolutionProperties) = preSolution
Index: /branches/MemPRAlgorithm/HeuristicLab.Algorithms.MemPR/3.3/Binary/LocalSearch/ExhaustiveBitflipSubspace.cs
===================================================================
--- /branches/MemPRAlgorithm/HeuristicLab.Algorithms.MemPR/3.3/Binary/LocalSearch/ExhaustiveBitflipSubspace.cs	(revision 14465)
+++ /branches/MemPRAlgorithm/HeuristicLab.Algorithms.MemPR/3.3/Binary/LocalSearch/ExhaustiveBitflipSubspace.cs	(revision 14466)
@@ -22,4 +22,5 @@
 using System.Threading;
 using HeuristicLab.Algorithms.MemPR.Interfaces;
+using HeuristicLab.Algorithms.MemPR.Util;
 using HeuristicLab.Common;
 using HeuristicLab.Core;
@@ -48,5 +49,5 @@
 
     public void Optimize(TContext context) {
-      var evalWrapper = new EvaluationWrapper(context);
+      var evalWrapper = new EvaluationWrapper<BinaryVector>(context.Problem, context.Solution);
       var quality = context.Solution.Fitness;
       try {
@@ -59,24 +60,4 @@
       }
     }
-
-    public sealed class EvaluationWrapper {
-      private readonly TContext context;
-      private readonly ISingleObjectiveSolutionScope<BinaryVector> scope;
-      private readonly SingleEncodingIndividual individual;
-
-      public EvaluationWrapper(TContext context) {
-        this.context = context;
-        // don't clone the solution, which is thrown away again
-        var cloner = new Cloner();
-        cloner.RegisterClonedObject(context.Solution.Solution, null);
-        this.scope = (ISingleObjectiveSolutionScope<BinaryVector>)context.Solution.Clone(cloner);
-        this.individual = new SingleEncodingIndividual(context.Problem.Encoding, this.scope);
-      }
-
-      public double Evaluate(BinaryVector b) {
-        scope.Solution = b;
-        return context.Problem.Evaluate(individual, null);
-      }
-    }
   }
 }
Index: /branches/MemPRAlgorithm/HeuristicLab.Algorithms.MemPR/3.3/HeuristicLab.Algorithms.MemPR-3.3.csproj
===================================================================
--- /branches/MemPRAlgorithm/HeuristicLab.Algorithms.MemPR/3.3/HeuristicLab.Algorithms.MemPR-3.3.csproj	(revision 14465)
+++ /branches/MemPRAlgorithm/HeuristicLab.Algorithms.MemPR/3.3/HeuristicLab.Algorithms.MemPR-3.3.csproj	(revision 14466)
@@ -96,4 +96,12 @@
     <Compile Include="Binary\SolutionModel\Univariate\UnbiasedModelTrainer.cs" />
     <Compile Include="Interfaces\Interfaces.cs" />
+    <Compile Include="LinearLinkage\LinearLinkageMemPR.cs" />
+    <Compile Include="LinearLinkage\LinearLinkageSolutionSubspace.cs" />
+    <Compile Include="LinearLinkage\LinearLinkageMemPRContext.cs" />
+    <Compile Include="LinearLinkage\LocalSearch\ExhaustiveSubspace.cs" />
+    <Compile Include="LinearLinkage\LocalSearch\StaticAPI\ExhaustiveLocalSearch.cs" />
+    <Compile Include="LinearLinkage\SolutionModel\Univariate\StaticAPI\Trainer.cs" />
+    <Compile Include="LinearLinkage\SolutionModel\Univariate\UnbiasedModelTrainer.cs" />
+    <Compile Include="LinearLinkage\SolutionModel\Univariate\UnivariateSolutionModel.cs" />
     <Compile Include="MemPRAlgorithm.cs" />
     <Compile Include="Permutation\PermutationMemPR.cs" />
@@ -106,5 +114,4 @@
     <Compile Include="Permutation\LocalSearch\StaticAPI\Exhaustive2Opt.cs" />
     <Compile Include="Permutation\LocalSearch\StaticAPI\ExhaustiveSwap2.cs" />
-    <Compile Include="Permutation\SimilarityCalculator.cs" />
     <Compile Include="Permutation\SolutionModel\Univariate\StaticAPI\Trainer.cs" />
     <Compile Include="Permutation\SolutionModel\Univariate\UnbiasedModelTrainer.cs" />
@@ -155,4 +162,9 @@
       <Private>False</Private>
     </ProjectReference>
+    <ProjectReference Include="..\..\HeuristicLab.Encodings.LinearLinkageEncoding\3.3\HeuristicLab.Encodings.LinearLinkageEncoding-3.3.csproj">
+      <Project>{BE698769-975A-429E-828C-72BB2B6182C8}</Project>
+      <Name>HeuristicLab.Encodings.LinearLinkageEncoding-3.3</Name>
+      <Private>False</Private>
+    </ProjectReference>
     <ProjectReference Include="..\..\HeuristicLab.Encodings.PermutationEncoding\3.3\HeuristicLab.Encodings.PermutationEncoding-3.3.csproj">
       <Project>{dbecb8b0-b166-4133-baf1-ed67c3fd7fca}</Project>
@@ -163,4 +175,9 @@
       <Project>{23da7ff4-d5b8-41b6-aa96-f0561d24f3ee}</Project>
       <Name>HeuristicLab.Operators-3.3</Name>
+      <Private>False</Private>
+    </ProjectReference>
+    <ProjectReference Include="..\..\HeuristicLab.Optimization.Operators\3.3\HeuristicLab.Optimization.Operators-3.3.csproj">
+      <Project>{25087811-F74C-4128-BC86-8324271DA13E}</Project>
+      <Name>HeuristicLab.Optimization.Operators-3.3</Name>
       <Private>False</Private>
     </ProjectReference>
Index: /branches/MemPRAlgorithm/HeuristicLab.Algorithms.MemPR/3.3/Interfaces/Interfaces.cs
===================================================================
--- /branches/MemPRAlgorithm/HeuristicLab.Algorithms.MemPR/3.3/Interfaces/Interfaces.cs	(revision 14465)
+++ /branches/MemPRAlgorithm/HeuristicLab.Algorithms.MemPR/3.3/Interfaces/Interfaces.cs	(revision 14466)
@@ -22,4 +22,5 @@
 using System.Collections.Generic;
 using HeuristicLab.Algorithms.MemPR.Binary;
+using HeuristicLab.Algorithms.MemPR.LinearLinkage;
 using HeuristicLab.Algorithms.MemPR.Permutation;
 using HeuristicLab.Core;
@@ -95,4 +96,7 @@
     new PermutationSolutionSubspace Subspace { get; }
   }
+  public interface ILinearLinkageSubspaceContext : ISolutionSubspaceContext<Encodings.LinearLinkageEncoding.LinearLinkage> {
+    new LinearLinkageSolutionSubspace Subspace { get; }
+  }
 
 
Index: /branches/MemPRAlgorithm/HeuristicLab.Algorithms.MemPR/3.3/LinearLinkage/LinearLinkageMemPR.cs
===================================================================
--- /branches/MemPRAlgorithm/HeuristicLab.Algorithms.MemPR/3.3/LinearLinkage/LinearLinkageMemPR.cs	(revision 14466)
+++ /branches/MemPRAlgorithm/HeuristicLab.Algorithms.MemPR/3.3/LinearLinkage/LinearLinkageMemPR.cs	(revision 14466)
@@ -0,0 +1,209 @@
+﻿#region License Information
+/* HeuristicLab
+ * Copyright (C) 2002-2016 Heuristic and Evolutionary Algorithms Laboratory (HEAL)
+ *
+ * This file is part of HeuristicLab.
+ *
+ * HeuristicLab is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation, either version 3 of the License, or
+ * (at your option) any later version.
+ *
+ * HeuristicLab is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with HeuristicLab. If not, see <http://www.gnu.org/licenses/>.
+ */
+#endregion
+
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using System.Threading;
+using HeuristicLab.Algorithms.MemPR.Interfaces;
+using HeuristicLab.Algorithms.MemPR.Util;
+using HeuristicLab.Common;
+using HeuristicLab.Core;
+using HeuristicLab.Encodings.LinearLinkageEncoding;
+using HeuristicLab.Optimization;
+using HeuristicLab.Persistence.Default.CompositeSerializers.Storable;
+using HeuristicLab.PluginInfrastructure;
+using HeuristicLab.Random;
+
+namespace HeuristicLab.Algorithms.MemPR.LinearLinkage {
+  [Item("MemPR (linear linkage)", "MemPR implementation for linear linkage vectors.")]
+  [StorableClass]
+  [Creatable(CreatableAttribute.Categories.PopulationBasedAlgorithms, Priority = 999)]
+  public class LinearLinkageMemPR : MemPRAlgorithm<SingleObjectiveBasicProblem<LinearLinkageEncoding>, Encodings.LinearLinkageEncoding.LinearLinkage, LinearLinkageMemPRPopulationContext, LinearLinkageMemPRSolutionContext> {
+    private const double UncommonBitSubsetMutationProbabilityMagicConst = 0.05;
+    
+    [StorableConstructor]
+    protected LinearLinkageMemPR(bool deserializing) : base(deserializing) { }
+    protected LinearLinkageMemPR(LinearLinkageMemPR original, Cloner cloner) : base(original, cloner) { }
+    public LinearLinkageMemPR() {
+      foreach (var trainer in ApplicationManager.Manager.GetInstances<ISolutionModelTrainer<LinearLinkageMemPRPopulationContext>>())
+        SolutionModelTrainerParameter.ValidValues.Add(trainer);
+      
+      foreach (var localSearch in ApplicationManager.Manager.GetInstances<ILocalSearch<LinearLinkageMemPRSolutionContext>>()) {
+        LocalSearchParameter.ValidValues.Add(localSearch);
+      }
+    }
+
+    public override IDeepCloneable Clone(Cloner cloner) {
+      return new LinearLinkageMemPR(this, cloner);
+    }
+
+    protected override bool Eq(ISingleObjectiveSolutionScope<Encodings.LinearLinkageEncoding.LinearLinkage> a, ISingleObjectiveSolutionScope<Encodings.LinearLinkageEncoding.LinearLinkage> b) {
+      return a.Solution.SequenceEqual(b.Solution);
+    }
+
+    protected override double Dist(ISingleObjectiveSolutionScope<Encodings.LinearLinkageEncoding.LinearLinkage> a, ISingleObjectiveSolutionScope<Encodings.LinearLinkageEncoding.LinearLinkage> b) {
+      if (a.Solution.Length != b.Solution.Length) throw new ArgumentException("Comparing encodings of unequal length");
+      var dist = 0;
+      for (var i = 0; i < a.Solution.Length; i++) {
+        if (a.Solution[i] != b.Solution[i]) dist++;
+      }
+      return dist / (double)a.Solution.Length;
+    }
+
+    protected override ISingleObjectiveSolutionScope<Encodings.LinearLinkageEncoding.LinearLinkage> ToScope(Encodings.LinearLinkageEncoding.LinearLinkage code, double fitness = double.NaN) {
+      var creator = Problem.SolutionCreator as ILinearLinkageCreator;
+      if (creator == null) throw new InvalidOperationException("Can only solve linear linkage encoded problems with MemPR (linear linkage)");
+      return new SingleObjectiveSolutionScope<Encodings.LinearLinkageEncoding.LinearLinkage>(code, creator.LLEParameter.ActualName, fitness, Problem.Evaluator.QualityParameter.ActualName) {
+        Parent = Context.Scope
+      };
+    }
+
+    protected override ISolutionSubspace<Encodings.LinearLinkageEncoding.LinearLinkage> CalculateSubspace(IEnumerable<Encodings.LinearLinkageEncoding.LinearLinkage> solutions, bool inverse = false) {
+      var pop = solutions.ToList();
+      var N = pop[0].Length;
+      var subspace = new bool[N];
+      for (var i = 0; i < N; i++) {
+        var val = pop[0][i];
+        if (inverse) subspace[i] = true;
+        for (var p = 1; p < pop.Count; p++) {
+          if (pop[p][i] != val) subspace[i] = !inverse;
+        }
+      }
+      return new LinearLinkageSolutionSubspace(subspace);
+    }
+
+    protected override int TabuWalk(ISingleObjectiveSolutionScope<Encodings.LinearLinkageEncoding.LinearLinkage> scope, int maxEvals, CancellationToken token, ISolutionSubspace<Encodings.LinearLinkageEncoding.LinearLinkage> subspace = null) {
+      return 0;
+    }
+
+    protected override ISingleObjectiveSolutionScope<Encodings.LinearLinkageEncoding.LinearLinkage> Cross(ISingleObjectiveSolutionScope<Encodings.LinearLinkageEncoding.LinearLinkage> p1Scope, ISingleObjectiveSolutionScope<Encodings.LinearLinkageEncoding.LinearLinkage> p2Scope, CancellationToken token) {
+      var p1 = p1Scope.Solution;
+      var p2 = p2Scope.Solution;
+      var transfered = new bool[p1.Length];
+      var subspace = new bool[p1.Length];
+      var lleeChild = new int[p1.Length];
+      var lleep1 = p1.ToLLEe();
+      var lleep2 = p2.ToLLEe();
+      for (var i = p1.Length - 1; i >= 0; i--) {
+        // Step 1
+        subspace[i] = p1[i] != p2[i];
+        var p1IsEnd = p1[i] == i;
+        var p2IsEnd = p2[i] == i;
+        if (p1IsEnd & p2IsEnd) {
+          transfered[i] = true;
+        } else if (p1IsEnd | p2IsEnd) {
+          transfered[i] = Context.Random.NextDouble() < 0.5;
+        }
+        lleeChild[i] = i;
+
+        // Step 2
+        if (transfered[i]) continue;
+        var end1 = lleep1[i];
+        var end2 = lleep2[i];
+        var containsEnd1 = transfered[end1];
+        var containsEnd2 = transfered[end2];
+        if (containsEnd1 & containsEnd2) {
+          if (Context.Random.NextDouble() < 0.5) {
+            lleeChild[i] = end1;
+          } else {
+            lleeChild[i] = end2;
+          }
+        } else if (containsEnd1) {
+          lleeChild[i] = end1;
+        } else if (containsEnd2) {
+          lleeChild[i] = end2;
+        } else {
+          if (Context.Random.NextDouble() < 0.5) {
+            lleeChild[i] = lleeChild[p1[i]];
+          } else {
+            lleeChild[i] = lleeChild[p2[i]];
+          }
+        }
+      }
+      var child = new Encodings.LinearLinkageEncoding.LinearLinkage(lleeChild.Length);
+      child.FromLLEe(lleeChild);
+      
+      return ToScope(child);
+    }
+
+    protected override void Mutate(ISingleObjectiveSolutionScope<Encodings.LinearLinkageEncoding.LinearLinkage> offspring, CancellationToken token, ISolutionSubspace<Encodings.LinearLinkageEncoding.LinearLinkage> subspace = null) {
+      var lle = offspring.Solution;
+      var subset = subspace is LinearLinkageSolutionSubspace ? ((LinearLinkageSolutionSubspace)subspace).Subspace : null;
+      for (var i = 0; i < lle.Length - 1; i++) {
+        if (subset == null || subset[i]) continue; // mutation works against crossover so aims to mutate noTouch points
+        if (Context.Random.NextDouble() < UncommonBitSubsetMutationProbabilityMagicConst) {
+          subset[i] = true;
+          var index = Context.Random.Next(i, lle.Length);
+          for (var j = index - 1; j >= i; j--) {
+            if (lle[j] == index) index = j;
+          }
+          lle[i] = index;
+          index = i;
+          var idx2 = i;
+          for (var j = i - 1; j >= 0; j--) {
+            if (lle[j] == lle[index]) {
+              lle[j] = idx2;
+              index = idx2 = j;
+            } else if (lle[j] == idx2) idx2 = j;
+          }
+        }
+      }
+    }
+
+    protected override ISingleObjectiveSolutionScope<Encodings.LinearLinkageEncoding.LinearLinkage> Relink(ISingleObjectiveSolutionScope<Encodings.LinearLinkageEncoding.LinearLinkage> a, ISingleObjectiveSolutionScope<Encodings.LinearLinkageEncoding.LinearLinkage> b, CancellationToken token) {
+      var maximization = Context.Problem.Maximization;
+      if (double.IsNaN(a.Fitness)) {
+        Evaluate(a, token);
+        Context.IncrementEvaluatedSolutions(1);
+      }
+      if (double.IsNaN(b.Fitness)) {
+        Evaluate(b, token);
+        Context.IncrementEvaluatedSolutions(1);
+      }
+      var child = (ISingleObjectiveSolutionScope<Encodings.LinearLinkageEncoding.LinearLinkage>)a.Clone();
+      var cgroups = child.Solution.GetGroups().Select(x => new HashSet<int>(x)).ToList();
+      var g2 = b.Solution.GetGroups().ToList();
+      var order = Enumerable.Range(0, g2.Count).Shuffle(Context.Random).ToList();
+      ISingleObjectiveSolutionScope <Encodings.LinearLinkageEncoding.LinearLinkage> bestChild = null;
+      for (var j = 0; j < g2.Count; j++) {
+        var g = g2[order[j]];
+        var changed = false;
+        for (var k = j; k < cgroups.Count; k++) {
+          foreach (var f in g) if (cgroups[k].Remove(f)) changed = true;
+          if (cgroups[k].Count == 0) {
+            cgroups.RemoveAt(k);
+            k--;
+          }
+        }
+        cgroups.Insert(0, new HashSet<int>(g));
+        child.Solution.SetGroups(cgroups);
+        if (changed) {
+          Evaluate(child, token);
+          if (bestChild == null || FitnessComparer.IsBetter(maximization, child.Fitness, bestChild.Fitness)) {
+            bestChild = (ISingleObjectiveSolutionScope<Encodings.LinearLinkageEncoding.LinearLinkage>)child.Clone();
+          }
+        }
+      };
+      return bestChild;
+    }
+  }
+}
Index: /branches/MemPRAlgorithm/HeuristicLab.Algorithms.MemPR/3.3/LinearLinkage/LinearLinkageMemPRContext.cs
===================================================================
--- /branches/MemPRAlgorithm/HeuristicLab.Algorithms.MemPR/3.3/LinearLinkage/LinearLinkageMemPRContext.cs	(revision 14466)
+++ /branches/MemPRAlgorithm/HeuristicLab.Algorithms.MemPR/3.3/LinearLinkage/LinearLinkageMemPRContext.cs	(revision 14466)
@@ -0,0 +1,80 @@
+﻿#region License Information
+/* HeuristicLab
+ * Copyright (C) 2002-2016 Heuristic and Evolutionary Algorithms Laboratory (HEAL)
+ *
+ * This file is part of HeuristicLab.
+ *
+ * HeuristicLab is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation, either version 3 of the License, or
+ * (at your option) any later version.
+ *
+ * HeuristicLab is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with HeuristicLab. If not, see <http://www.gnu.org/licenses/>.
+ */
+#endregion
+
+using HeuristicLab.Algorithms.MemPR.Interfaces;
+using HeuristicLab.Common;
+using HeuristicLab.Core;
+using HeuristicLab.Encodings.LinearLinkageEncoding;
+using HeuristicLab.Optimization;
+using HeuristicLab.Parameters;
+using HeuristicLab.Persistence.Default.CompositeSerializers.Storable;
+
+namespace HeuristicLab.Algorithms.MemPR.LinearLinkage {
+  [Item("MemPR Population Context (linear linkage)", "MemPR population context for linear linkage encoded problems.")]
+  [StorableClass]
+  public sealed class LinearLinkageMemPRPopulationContext : MemPRPopulationContext<SingleObjectiveBasicProblem<LinearLinkageEncoding>, Encodings.LinearLinkageEncoding.LinearLinkage, LinearLinkageMemPRPopulationContext, LinearLinkageMemPRSolutionContext> {
+
+    [StorableConstructor]
+    private LinearLinkageMemPRPopulationContext(bool deserializing) : base(deserializing) { }
+    private LinearLinkageMemPRPopulationContext(LinearLinkageMemPRPopulationContext original, Cloner cloner)
+      : base(original, cloner) { }
+    public LinearLinkageMemPRPopulationContext() : base("LinearLinkageMemPRPopulationContext") { }
+    public LinearLinkageMemPRPopulationContext(string name) : base(name) { }
+
+    public override IDeepCloneable Clone(Cloner cloner) {
+      return new LinearLinkageMemPRPopulationContext(this, cloner);
+    }
+
+    public override LinearLinkageMemPRSolutionContext CreateSingleSolutionContext(ISingleObjectiveSolutionScope<Encodings.LinearLinkageEncoding.LinearLinkage> solution) {
+      return new LinearLinkageMemPRSolutionContext(this, solution);
+    }
+  }
+
+  [Item("MemPR Solution Context (linear linkage)", "MemPR solution context for linear linkage encoded problems.")]
+  [StorableClass]
+  public sealed class LinearLinkageMemPRSolutionContext : MemPRSolutionContext<SingleObjectiveBasicProblem<LinearLinkageEncoding>, Encodings.LinearLinkageEncoding.LinearLinkage, LinearLinkageMemPRPopulationContext, LinearLinkageMemPRSolutionContext>, ILinearLinkageSubspaceContext {
+
+    [Storable]
+    private IValueParameter<LinearLinkageSolutionSubspace> subspace;
+    public LinearLinkageSolutionSubspace Subspace {
+      get { return subspace.Value; }
+    }
+    ISolutionSubspace<Encodings.LinearLinkageEncoding.LinearLinkage> ISolutionSubspaceContext<Encodings.LinearLinkageEncoding.LinearLinkage>.Subspace {
+      get { return Subspace; }
+    }
+
+    [StorableConstructor]
+    private LinearLinkageMemPRSolutionContext(bool deserializing) : base(deserializing) { }
+    private LinearLinkageMemPRSolutionContext(LinearLinkageMemPRSolutionContext original, Cloner cloner)
+      : base(original, cloner) {
+
+    }
+    public LinearLinkageMemPRSolutionContext(LinearLinkageMemPRPopulationContext baseContext, ISingleObjectiveSolutionScope<Encodings.LinearLinkageEncoding.LinearLinkage> solution)
+      : base(baseContext, solution) {
+
+      Parameters.Add(subspace = new ValueParameter<LinearLinkageSolutionSubspace>("Subspace", new LinearLinkageSolutionSubspace(null)));
+    }
+
+    public override IDeepCloneable Clone(Cloner cloner) {
+      return new LinearLinkageMemPRSolutionContext(this, cloner);
+    }
+  }
+}
Index: /branches/MemPRAlgorithm/HeuristicLab.Algorithms.MemPR/3.3/LinearLinkage/LinearLinkageSolutionSubspace.cs
===================================================================
--- /branches/MemPRAlgorithm/HeuristicLab.Algorithms.MemPR/3.3/LinearLinkage/LinearLinkageSolutionSubspace.cs	(revision 14466)
+++ /branches/MemPRAlgorithm/HeuristicLab.Algorithms.MemPR/3.3/LinearLinkage/LinearLinkageSolutionSubspace.cs	(revision 14466)
@@ -0,0 +1,50 @@
+﻿#region License Information
+/* HeuristicLab
+ * Copyright (C) 2002-2016 Heuristic and Evolutionary Algorithms Laboratory (HEAL)
+ *
+ * This file is part of HeuristicLab.
+ *
+ * HeuristicLab is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation, either version 3 of the License, or
+ * (at your option) any later version.
+ *
+ * HeuristicLab is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with HeuristicLab. If not, see <http://www.gnu.org/licenses/>.
+ */
+#endregion
+
+using HeuristicLab.Algorithms.MemPR.Interfaces;
+using HeuristicLab.Common;
+using HeuristicLab.Core;
+using HeuristicLab.Persistence.Default.CompositeSerializers.Storable;
+
+namespace HeuristicLab.Algorithms.MemPR.LinearLinkage {
+  [Item("Solution subspace (linear linkage)", "")]
+  [StorableClass]
+  public sealed class LinearLinkageSolutionSubspace : Item, ISolutionSubspace<Encodings.LinearLinkageEncoding.LinearLinkage> {
+
+    [Storable]
+    private bool[] subspace;
+    public bool[] Subspace { get { return subspace; } }
+
+    [StorableConstructor]
+    private LinearLinkageSolutionSubspace(bool deserializing) : base(deserializing) { }
+    private LinearLinkageSolutionSubspace(LinearLinkageSolutionSubspace original, Cloner cloner)
+      : base(original, cloner) {
+      subspace = (bool[])original.subspace.Clone();
+    }
+    public LinearLinkageSolutionSubspace(bool[] subspace) {
+      this.subspace = subspace;
+    }
+
+    public override IDeepCloneable Clone(Cloner cloner) {
+      return new LinearLinkageSolutionSubspace(this, cloner);
+    }
+  }
+}
Index: /branches/MemPRAlgorithm/HeuristicLab.Algorithms.MemPR/3.3/LinearLinkage/LocalSearch/ExhaustiveSubspace.cs
===================================================================
--- /branches/MemPRAlgorithm/HeuristicLab.Algorithms.MemPR/3.3/LinearLinkage/LocalSearch/ExhaustiveSubspace.cs	(revision 14466)
+++ /branches/MemPRAlgorithm/HeuristicLab.Algorithms.MemPR/3.3/LinearLinkage/LocalSearch/ExhaustiveSubspace.cs	(revision 14466)
@@ -0,0 +1,62 @@
+﻿#region License Information
+/* HeuristicLab
+ * Copyright (C) 2002-2016 Heuristic and Evolutionary Algorithms Laboratory (HEAL)
+ *
+ * This file is part of HeuristicLab.
+ *
+ * HeuristicLab is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation, either version 3 of the License, or
+ * (at your option) any later version.
+ *
+ * HeuristicLab is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with HeuristicLab. If not, see <http://www.gnu.org/licenses/>.
+ */
+#endregion
+
+using System.Threading;
+using HeuristicLab.Algorithms.MemPR.Interfaces;
+using HeuristicLab.Algorithms.MemPR.Util;
+using HeuristicLab.Common;
+using HeuristicLab.Core;
+using HeuristicLab.Encodings.LinearLinkageEncoding;
+using HeuristicLab.Optimization;
+using HeuristicLab.Persistence.Default.CompositeSerializers.Storable;
+
+namespace HeuristicLab.Algorithms.MemPR.LinearLinkage.LocalSearch {
+  [Item("Exhaustive Local (Subspace) Search (linear linkage)", "", ExcludeGenericTypeInfo = true)]
+  [StorableClass]
+  public class ExhaustiveSubspace<TContext> : NamedItem, ILocalSearch<TContext>
+      where TContext : ISingleSolutionHeuristicAlgorithmContext<SingleObjectiveBasicProblem<LinearLinkageEncoding>, Encodings.LinearLinkageEncoding.LinearLinkage>, ILinearLinkageSubspaceContext {
+
+    [StorableConstructor]
+    protected ExhaustiveSubspace(bool deserializing) : base(deserializing) { }
+    protected ExhaustiveSubspace(ExhaustiveSubspace<TContext> original, Cloner cloner) : base(original, cloner) { }
+    public ExhaustiveSubspace() {
+      Name = ItemName;
+      Description = ItemDescription;
+    }
+
+    public override IDeepCloneable Clone(Cloner cloner) {
+      return new ExhaustiveSubspace<TContext>(this, cloner);
+    }
+
+    public void Optimize(TContext context) {
+      var evalWrapper = new EvaluationWrapper<Encodings.LinearLinkageEncoding.LinearLinkage>(context.Problem, context.Solution);
+      var quality = context.Solution.Fitness;
+      try {
+        var result = ExhaustiveLocalSearch.Optimize(context.Random, context.Solution.Solution, ref quality,
+          context.Problem.Maximization, evalWrapper.Evaluate, CancellationToken.None, context.Subspace.Subspace);
+        context.IncrementEvaluatedSolutions(result.Item1);
+        context.Iterations = result.Item2;
+      } finally {
+        context.Solution.Fitness = quality;
+      }
+    }
+  }
+}
Index: /branches/MemPRAlgorithm/HeuristicLab.Algorithms.MemPR/3.3/LinearLinkage/LocalSearch/StaticAPI/ExhaustiveLocalSearch.cs
===================================================================
--- /branches/MemPRAlgorithm/HeuristicLab.Algorithms.MemPR/3.3/LinearLinkage/LocalSearch/StaticAPI/ExhaustiveLocalSearch.cs	(revision 14466)
+++ /branches/MemPRAlgorithm/HeuristicLab.Algorithms.MemPR/3.3/LinearLinkage/LocalSearch/StaticAPI/ExhaustiveLocalSearch.cs	(revision 14466)
@@ -0,0 +1,212 @@
+﻿#region License Information
+/* HeuristicLab
+ * Copyright (C) 2002-2016 Heuristic and Evolutionary Algorithms Laboratory (HEAL)
+ *
+ * This file is part of HeuristicLab.
+ *
+ * HeuristicLab is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation, either version 3 of the License, or
+ * (at your option) any later version.
+ *
+ * HeuristicLab is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with HeuristicLab. If not, see <http://www.gnu.org/licenses/>.
+ */
+#endregion
+
+using System;
+using System.Linq;
+using System.Threading;
+using HeuristicLab.Algorithms.MemPR.Util;
+using HeuristicLab.Collections;
+using HeuristicLab.Core;
+
+namespace HeuristicLab.Algorithms.MemPR.LinearLinkage.LocalSearch {
+  public static class ExhaustiveLocalSearch {
+    public static Tuple<int, int> Optimize(IRandom random, Encodings.LinearLinkageEncoding.LinearLinkage solution, ref double quality, bool maximization, Func<Encodings.LinearLinkageEncoding.LinearLinkage, IRandom, double> eval, CancellationToken token, bool[] subspace = null) {
+      var evaluations = 0;
+      var current = solution;
+      if (double.IsNaN(quality)) {
+        quality = eval(current, random);
+        evaluations++;
+      }
+      var steps = 0;
+      // this dictionary holds the last relevant links
+      var links = new BidirectionalDictionary<int, int>();
+      for (var iter = 0; iter < int.MaxValue; iter++) {
+        var change = false;
+        // clear the dictionary before a new pass through the array is made
+        links.Clear();
+        for (var i = 0; i < current.Length; i++) {
+          if (subspace != null && !subspace[i]) {
+            links.RemoveBySecond(i);
+            links.Add(i, current[i]);
+            continue;
+          }
+          var isFirst = !links.ContainsSecond(i);
+          var pred = -1;
+          var keepLink = false;
+          if (!isFirst) {
+            pred = links.GetBySecond(i);
+            keepLink = subspace != null && !subspace[pred];
+          }
+          var next = current[i];
+          var isLast = next == i;
+
+          if (!keepLink) {
+            // try to insert current into each previous group
+            // first remove i from its group
+            var linksList = links.Where(x => x.Value != i).ToList();
+            if (linksList.Count > 0 && !isFirst) current[pred] = isLast ? pred : next;
+            for (var k = 0; k < linksList.Count; k++) {
+              var l = linksList[k];
+              current[l.Key] = i;
+              current[i] = Math.Max(i, l.Value);
+              var moveF = eval(current, random);
+              evaluations++;
+              if (FitnessComparer.IsBetter(maximization, moveF, quality)) {
+                steps++;
+                quality = moveF;
+                change = true;
+                links.RemoveBySecond(i);
+                links.SetByFirst(l.Key, i); // otherwise the link won't be removed
+                if (!isFirst) links.SetByFirst(pred, isLast ? pred : next);
+                next = current[i];
+                if (next == i) { isLast = true; }
+                pred = l.Key;
+                isFirst = false;
+                break;
+              } else { // undo
+                current[l.Key] = l.Value;
+                if (k == linksList.Count - 1) {
+                  // all attempts unsuccessful
+                  if (!isFirst) current[pred] = i; // undo - readd i to its group
+                  current[i] = next;
+                }
+              }
+            }
+          }
+
+          if (!isLast) {
+            // try to split group at this point
+            // this is safe even if keepLink was true
+            current[i] = i;
+            var moveF = eval(current, random);
+            evaluations++;
+            if (FitnessComparer.IsBetter(maximization, moveF, quality)) {
+              steps++;
+              quality = moveF;
+              change = true;
+              isLast = true;
+              next = i;
+              links.SetBySecond(i, i);
+              continue;
+            } else current[i] = next; // undo
+          }
+
+          if (isFirst && !isLast) {
+            // try merge with all terminated groups
+            foreach (var l in links.Where(x => x.Key == x.Value && (subspace == null || subspace[x.Key]))) {
+              current[l.Key] = i;
+              var moveF = eval(current, random);
+              evaluations++;
+              if (FitnessComparer.IsBetter(maximization, moveF, quality)) {
+                steps++;
+                quality = moveF;
+                change = true;
+                isFirst = false;
+                pred = l.Key;
+                links.SetByFirst(l.Key, i);
+                break;
+              } else {
+                current[l.Key] = l.Value;
+              }
+            }
+          } else if (!isFirst && !keepLink) {
+            // try to extract current into own group
+            current[pred] = isLast ? pred : next;
+            current[i] = i;
+            var moveF = eval(current, random);
+            evaluations++;
+            if (FitnessComparer.IsBetter(maximization, moveF, quality)) {
+              steps++;
+              links.SetByFirst(pred, current[pred]);
+              quality = moveF;
+              change = true;
+            } else { // undo
+              current[pred] = i;
+              current[i] = next;
+            }
+          }
+          links.RemoveBySecond(i);
+          links.Add(i, current[i]);
+          if (token.IsCancellationRequested) break;
+        }
+        if (!change || token.IsCancellationRequested) break;
+      }
+
+      return Tuple.Create(evaluations, steps);
+    }
+
+    public static Tuple<int, int> OptimizeSwapOnly(IRandom random, Encodings.LinearLinkageEncoding.LinearLinkage solution, ref double quality, bool maximization, Func<Encodings.LinearLinkageEncoding.LinearLinkage, IRandom, double> eval, CancellationToken token) {
+      var evaluations = 0;
+      var current = solution;
+      if (double.IsNaN(quality)) {
+        quality = eval(current, random);
+        evaluations++;
+      }
+      var groups = current.GetGroups().ToList();
+      var exclude = new bool[groups.Count, groups.Count];
+      var steps = 0;
+      for (var iter = 0; iter < int.MaxValue; iter++) {
+        var change = false;
+        for (var i = 0; i < groups.Count - 1; i++) {
+          for (var j = i + 1; j < groups.Count; j++) {
+            if (exclude[i, j]) continue;
+            var groupsChanged = false;
+            if (groups[i].Count == 1 && groups[j].Count == 1) continue; // groups are anonymous, swap has no effect
+            for (var x = 0; x < groups[i].Count; x++) {
+              for (var y = 0; y < groups[j].Count; y++) {
+                var a = groups[i][x];
+                var b = groups[j][y];
+                groups[i][x] = b;
+                groups[j][y] = a;
+                current.SetGroups(groups);
+                var moveF = eval(current, random);
+                evaluations++;
+                if (FitnessComparer.IsBetter(maximization, moveF, quality)) {
+                  steps++;
+                  quality = moveF;
+                  groupsChanged = true;
+                } else {
+                  // undo
+                  groups[i][x] = a;
+                  groups[j][y] = b;
+                  current.SetGroups(groups);
+                }
+              }
+            }
+            if (!groupsChanged) {
+              exclude[i, j] = true;
+            } else {
+              change = true;
+              for (var k = 0; k < groups.Count; k++) {
+                exclude[k, j] = false;
+                exclude[i, k] = false;
+              }
+            }
+            if (token.IsCancellationRequested) break;
+          }
+          if (token.IsCancellationRequested) break;
+        }
+        if (!change || token.IsCancellationRequested) break;
+      }
+      return Tuple.Create(evaluations, steps);
+    }
+  }
+}
Index: /branches/MemPRAlgorithm/HeuristicLab.Algorithms.MemPR/3.3/LinearLinkage/SolutionModel/Univariate/StaticAPI/Trainer.cs
===================================================================
--- /branches/MemPRAlgorithm/HeuristicLab.Algorithms.MemPR/3.3/LinearLinkage/SolutionModel/Univariate/StaticAPI/Trainer.cs	(revision 14466)
+++ /branches/MemPRAlgorithm/HeuristicLab.Algorithms.MemPR/3.3/LinearLinkage/SolutionModel/Univariate/StaticAPI/Trainer.cs	(revision 14466)
@@ -0,0 +1,34 @@
+﻿#region License Information
+/* HeuristicLab
+ * Copyright (C) 2002-2016 Heuristic and Evolutionary Algorithms Laboratory (HEAL)
+ *
+ * This file is part of HeuristicLab.
+ *
+ * HeuristicLab is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation, either version 3 of the License, or
+ * (at your option) any later version.
+ *
+ * HeuristicLab is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with HeuristicLab. If not, see <http://www.gnu.org/licenses/>.
+ */
+#endregion
+
+using System.Collections.Generic;
+using HeuristicLab.Algorithms.MemPR.Interfaces;
+using HeuristicLab.Core;
+
+namespace HeuristicLab.Algorithms.MemPR.LinearLinkage.SolutionModel.Univariate {
+  public static class Trainer {
+
+    public static ISolutionModel<Encodings.LinearLinkageEncoding.LinearLinkage> Train(IRandom random,
+        IEnumerable<Encodings.LinearLinkageEncoding.LinearLinkage> pop) {
+      return UnivariateModel.Create(random, pop);
+    }
+  }
+}
Index: /branches/MemPRAlgorithm/HeuristicLab.Algorithms.MemPR/3.3/LinearLinkage/SolutionModel/Univariate/UnbiasedModelTrainer.cs
===================================================================
--- /branches/MemPRAlgorithm/HeuristicLab.Algorithms.MemPR/3.3/LinearLinkage/SolutionModel/Univariate/UnbiasedModelTrainer.cs	(revision 14466)
+++ /branches/MemPRAlgorithm/HeuristicLab.Algorithms.MemPR/3.3/LinearLinkage/SolutionModel/Univariate/UnbiasedModelTrainer.cs	(revision 14466)
@@ -0,0 +1,51 @@
+﻿#region License Information
+/* HeuristicLab
+ * Copyright (C) 2002-2016 Heuristic and Evolutionary Algorithms Laboratory (HEAL)
+ *
+ * This file is part of HeuristicLab.
+ *
+ * HeuristicLab is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation, either version 3 of the License, or
+ * (at your option) any later version.
+ *
+ * HeuristicLab is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with HeuristicLab. If not, see <http://www.gnu.org/licenses/>.
+ */
+#endregion
+
+using System.Linq;
+using HeuristicLab.Algorithms.MemPR.Interfaces;
+using HeuristicLab.Common;
+using HeuristicLab.Core;
+using HeuristicLab.Optimization;
+using HeuristicLab.Persistence.Default.CompositeSerializers.Storable;
+
+namespace HeuristicLab.Algorithms.MemPR.LinearLinkage.SolutionModel.Univariate {
+  [Item("Unbiased Univariate Model Trainer (linear linkage)", "", ExcludeGenericTypeInfo = true)]
+  [StorableClass]
+  public class UniasedModelTrainer<TContext> : NamedItem, ISolutionModelTrainer<TContext>
+    where TContext : IPopulationBasedHeuristicAlgorithmContext<SingleObjectiveBasicProblem<Encodings.LinearLinkageEncoding.LinearLinkageEncoding>, Encodings.LinearLinkageEncoding.LinearLinkage>, ISolutionModelContext<Encodings.LinearLinkageEncoding.LinearLinkage> {
+    
+    [StorableConstructor]
+    protected UniasedModelTrainer(bool deserializing) : base(deserializing) { }
+    protected UniasedModelTrainer(UniasedModelTrainer<TContext> original, Cloner cloner) : base(original, cloner) { }
+    public UniasedModelTrainer() {
+      Name = ItemName;
+      Description = ItemDescription;
+    }
+
+    public override IDeepCloneable Clone(Cloner cloner) {
+      return new UniasedModelTrainer<TContext>(this, cloner);
+    }
+
+    public void TrainModel(TContext context) {
+      context.Model = Trainer.Train(context.Random, context.Population.Select(x => x.Solution));
+    }
+  }
+}
Index: /branches/MemPRAlgorithm/HeuristicLab.Algorithms.MemPR/3.3/LinearLinkage/SolutionModel/Univariate/UnivariateSolutionModel.cs
===================================================================
--- /branches/MemPRAlgorithm/HeuristicLab.Algorithms.MemPR/3.3/LinearLinkage/SolutionModel/Univariate/UnivariateSolutionModel.cs	(revision 14466)
+++ /branches/MemPRAlgorithm/HeuristicLab.Algorithms.MemPR/3.3/LinearLinkage/SolutionModel/Univariate/UnivariateSolutionModel.cs	(revision 14466)
@@ -0,0 +1,109 @@
+﻿#region License Information
+/* HeuristicLab
+ * Copyright (C) 2002-2016 Heuristic and Evolutionary Algorithms Laboratory (HEAL)
+ *
+ * This file is part of HeuristicLab.
+ *
+ * HeuristicLab is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation, either version 3 of the License, or
+ * (at your option) any later version.
+ *
+ * HeuristicLab is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with HeuristicLab. If not, see <http://www.gnu.org/licenses/>.
+ */
+#endregion
+
+using System;
+using System.Collections.Generic;
+using HeuristicLab.Algorithms.MemPR.Interfaces;
+using HeuristicLab.Common;
+using HeuristicLab.Core;
+using HeuristicLab.Data;
+using HeuristicLab.Persistence.Default.CompositeSerializers.Storable;
+
+namespace HeuristicLab.Algorithms.MemPR.LinearLinkage.SolutionModel.Univariate {
+  [Item("Univariate solution model (linear linkage)", "")]
+  [StorableClass]
+  public sealed class UnivariateModel : Item, ISolutionModel<Encodings.LinearLinkageEncoding.LinearLinkage> {
+    [Storable]
+    public IntMatrix Frequencies { get; set; }
+    [Storable]
+    public IRandom Random { get; set; }
+    [Storable]
+    public IntValue Maximum { get; set; }
+
+    [StorableConstructor]
+    private UnivariateModel(bool deserializing) : base(deserializing) { }
+    private UnivariateModel(UnivariateModel original, Cloner cloner)
+      : base(original, cloner) {
+      Frequencies = cloner.Clone(original.Frequencies);
+      Random = cloner.Clone(original.Random);
+    }
+    public UnivariateModel(IRandom random, int[,] frequencies, int max) {
+      Frequencies = new IntMatrix(frequencies);
+      Random = random;
+      Maximum = new IntValue(max);
+    }
+    public UnivariateModel(IRandom random, IntMatrix frequencies, int max) {
+      Frequencies = frequencies;
+      Random = random;
+      Maximum = new IntValue(max);
+    }
+
+    public override IDeepCloneable Clone(Cloner cloner) {
+      return new UnivariateModel(this, cloner);
+    }
+
+    public Encodings.LinearLinkageEncoding.LinearLinkage Sample() {
+      var N = Frequencies.Rows;
+      var centroid = new Encodings.LinearLinkageEncoding.LinearLinkage(N);
+      var dict = new Dictionary<int, int>();
+      for (var i = N - 1; i >= 0; i--) {
+        centroid[i] = i; // default be a cluster of your own
+        for (var j = i + 1; j < N; j++) {
+          // try to find a suitable link
+          if (Maximum.Value * Random.NextDouble() < Frequencies[i, j]) {
+            int pred;
+            if (dict.TryGetValue(j, out pred)) {
+              int tmp, k = pred;
+              while (dict.TryGetValue(k, out tmp)) {
+                if (k == tmp) break;
+                k = tmp;
+              }
+              centroid[i] = k;
+            } else centroid[i] = j;
+            dict[centroid[i]] = i;
+            break;
+          }
+        }
+      }
+      return centroid;
+    }
+
+    public static ISolutionModel<Encodings.LinearLinkageEncoding.LinearLinkage> Create(IRandom random, IEnumerable<Encodings.LinearLinkageEncoding.LinearLinkage> population) {
+      var iter = population.GetEnumerator();
+      if (!iter.MoveNext()) throw new ArgumentException("Cannot create solution model from empty population.");
+      var popSize = 1;
+      var N = iter.Current.Length;
+      var freq = new int[N, N];
+      do {
+        var current = iter.Current;
+        popSize++;
+        foreach (var g in current.GetGroups()) {
+          for (var i = 0; i < g.Count - 1; i++)
+            for (var j = i + 1; j < g.Count; j++) {
+              freq[g[i], g[j]]++;
+              freq[g[j], g[i]]++;
+            }
+        }
+      } while (iter.MoveNext());
+      return new UnivariateModel(random, freq, popSize);
+    }
+  }
+}
Index: /branches/MemPRAlgorithm/HeuristicLab.Algorithms.MemPR/3.3/Permutation/PermutationMemPR.cs
===================================================================
--- /branches/MemPRAlgorithm/HeuristicLab.Algorithms.MemPR/3.3/Permutation/PermutationMemPR.cs	(revision 14465)
+++ /branches/MemPRAlgorithm/HeuristicLab.Algorithms.MemPR/3.3/Permutation/PermutationMemPR.cs	(revision 14466)
@@ -72,5 +72,5 @@
 
     private static double Dist(Encodings.PermutationEncoding.Permutation a, Encodings.PermutationEncoding.Permutation b) {
-      return 1.0 - PermutationSimilarityCalculator.CalculateSimilarity(a, b);
+      return 1.0 - HammingSimilarityCalculator.CalculateSimilarity(a, b);
     }
 
Index: anches/MemPRAlgorithm/HeuristicLab.Algorithms.MemPR/3.3/Permutation/SimilarityCalculator.cs
===================================================================
--- /branches/MemPRAlgorithm/HeuristicLab.Algorithms.MemPR/3.3/Permutation/SimilarityCalculator.cs	(revision 14465)
+++ 	(revision )
@@ -1,91 +1,0 @@
-﻿#region License Information
-/* HeuristicLab
- * Copyright (C) 2002-2016 Heuristic and Evolutionary Algorithms Laboratory (HEAL)
- *
- * This file is part of HeuristicLab.
- *
- * HeuristicLab is free software: you can redistribute it and/or modify
- * it under the terms of the GNU General Public License as published by
- * the Free Software Foundation, either version 3 of the License, or
- * (at your option) any later version.
- *
- * HeuristicLab is distributed in the hope that it will be useful,
- * but WITHOUT ANY WARRANTY; without even the implied warranty of
- * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
- * GNU General Public License for more details.
- *
- * You should have received a copy of the GNU General Public License
- * along with HeuristicLab. If not, see <http://www.gnu.org/licenses/>.
- */
-#endregion
-
-using System;
-using HeuristicLab.Encodings.PermutationEncoding;
-
-namespace HeuristicLab.Algorithms.MemPR.Permutation {
-  public static class PermutationSimilarityCalculator {
-
-    public static double CalculateSimilarity(Encodings.PermutationEncoding.Permutation left, Encodings.PermutationEncoding.Permutation right) {
-      if (left == null || right == null)
-        throw new ArgumentException("Cannot calculate similarity because one of the provided solutions or both are null.");
-      if (left.PermutationType != right.PermutationType)
-        throw new ArgumentException("Cannot calculate similarity because the provided solutions have different types.");
-      if (left.Length != right.Length)
-        throw new ArgumentException("Cannot calculate similarity because the provided solutions have different lengths.");
-      if (object.ReferenceEquals(left, right)) return 1.0;
-
-      switch (left.PermutationType) {
-        case PermutationTypes.Absolute:
-          return CalculateAbsolute(left, right);
-        case PermutationTypes.RelativeDirected:
-          return CalculateRelativeDirected(left, right);
-        case PermutationTypes.RelativeUndirected:
-          return CalculateRelativeUndirected(left, right);
-        default:
-          throw new InvalidOperationException("unknown permutation type");
-      }
-    }
-
-    private static double CalculateAbsolute(Encodings.PermutationEncoding.Permutation left, Encodings.PermutationEncoding.Permutation right) {
-      double similarity = 0.0;
-      for (int i = 0; i < left.Length; i++)
-        if (left[i] == right[i]) similarity++;
-
-      return similarity / left.Length;
-    }
-
-    private static double CalculateRelativeDirected(Encodings.PermutationEncoding.Permutation left, Encodings.PermutationEncoding.Permutation right) {
-      int[] edgesR = CalculateEdgesVector(right);
-      int[] edgesL = CalculateEdgesVector(left);
-
-      double similarity = 0.0;
-      for (int i = 0; i < left.Length; i++) {
-        if (edgesL[i] == edgesR[i]) similarity++;
-      }
-
-      return similarity / left.Length;
-    }
-
-    private static double CalculateRelativeUndirected(Encodings.PermutationEncoding.Permutation left, Encodings.PermutationEncoding.Permutation right) {
-      int[] edgesR = CalculateEdgesVector(right);
-      int[] edgesL = CalculateEdgesVector(left);
-
-      double similarity = 0.0;
-      for (int i = 0; i < left.Length; i++) {
-        if ((edgesL[i] == edgesR[i]) || (edgesL[edgesR[i]] == i))
-          similarity++;
-      }
-
-      return similarity / left.Length;
-    }
-
-    private static int[] CalculateEdgesVector(Encodings.PermutationEncoding.Permutation permutation) {
-      // transform path representation into adjacency representation
-      int[] edgesVector = new int[permutation.Length];
-      for (int i = 0; i < permutation.Length - 1; i++)
-        edgesVector[permutation[i]] = permutation[i + 1];
-      edgesVector[permutation[permutation.Length - 1]] = permutation[0];
-      return edgesVector;
-    }
-  }
-}
Index: /branches/MemPRAlgorithm/HeuristicLab.Problems.GraphColoring/3.3/GraphColoringProblem.cs
===================================================================
--- /branches/MemPRAlgorithm/HeuristicLab.Problems.GraphColoring/3.3/GraphColoringProblem.cs	(revision 14466)
+++ /branches/MemPRAlgorithm/HeuristicLab.Problems.GraphColoring/3.3/GraphColoringProblem.cs	(revision 14466)
@@ -0,0 +1,89 @@
+﻿#region License Information
+/* HeuristicLab
+ * Copyright (C) 2002-2016 Heuristic and Evolutionary Algorithms Laboratory (HEAL)
+ *
+ * This file is part of HeuristicLab.
+ *
+ * HeuristicLab is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation, either version 3 of the License, or
+ * (at your option) any later version.
+ *
+ * HeuristicLab is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with HeuristicLab. If not, see <http://www.gnu.org/licenses/>.
+ */
+#endregion
+
+using System;
+using HeuristicLab.Common;
+using HeuristicLab.Core;
+using HeuristicLab.Data;
+using HeuristicLab.Encodings.LinearLinkageEncoding;
+using HeuristicLab.Optimization;
+using HeuristicLab.Parameters;
+using HeuristicLab.Persistence.Default.CompositeSerializers.Storable;
+
+namespace HeuristicLab.Problems.GraphColoring {
+  [Item("Graph Coloring Problem (GCP)", "Attempts to find a coloring using a minimal number of colors that doesn't produce a conflict.")]
+  [StorableClass]
+  public sealed class GraphColoringProblem : SingleObjectiveBasicProblem<LinearLinkageEncoding> {
+
+    public override bool Maximization {
+      get { return false; }
+    }
+
+    private IValueParameter<BoolMatrix> adjacencyMatrixParameter;
+    public IValueParameter<BoolMatrix> AdjacencyMatrixParameter {
+      get { return adjacencyMatrixParameter; }
+    }
+
+    [StorableConstructor]
+    private GraphColoringProblem(bool deserializing) : base(deserializing) { }
+    private GraphColoringProblem(GraphColoringProblem original, Cloner cloner)
+      : base(original, cloner) {
+      adjacencyMatrixParameter = cloner.Clone(original.adjacencyMatrixParameter);
+    }
+    public GraphColoringProblem() {
+      Encoding = new LinearLinkageEncoding("lle") { Length = 32 };
+      Parameters.Add(adjacencyMatrixParameter = new ValueParameter<BoolMatrix>("AdjacencyMatrix", "The matrix that describes whether two nodes are linked."));
+      
+      var rand = new System.Random(0);
+      var matrix = new BoolMatrix(32, 32);
+      for (var i = 0; i < 31; i++) {
+        for (var j = i + 1; j < 32; j++) {
+          matrix[i, j] = rand.NextDouble() < 0.2;
+          matrix[j, i] = matrix[i, j];
+        }
+      }
+      AdjacencyMatrixParameter.Value = matrix;
+    }
+
+    public override IDeepCloneable Clone(Cloner cloner) {
+      return new GraphColoringProblem(this, cloner);
+    }
+
+    public override double Evaluate(Individual individual, IRandom random) {
+      var matrix = adjacencyMatrixParameter.Value;
+      var lle = individual.LinearLinkage("lle");
+      var groups = lle.GetGroups();
+      var conflicts = 0;
+      var colors = 0;
+      foreach (var g in groups) {
+        colors++;
+        for (var i = 0; i < g.Count - 1; i++) {
+          for (var j = i + 1; j < g.Count; j++) {
+            if (matrix[g[i], g[j]]) conflicts++; // both nodes are adjacent and have the same color (are in the same group)
+          }
+        }
+      }
+
+      var mag = Math.Pow(10, -(int)Math.Ceiling(Math.Log10(matrix.Rows)));
+      return conflicts + colors * mag;
+    }
+  }
+}
Index: /branches/MemPRAlgorithm/HeuristicLab.Problems.GraphColoring/3.3/HeuristicLab.Problems.GraphColoring-3.3.csproj
===================================================================
--- /branches/MemPRAlgorithm/HeuristicLab.Problems.GraphColoring/3.3/HeuristicLab.Problems.GraphColoring-3.3.csproj	(revision 14466)
+++ /branches/MemPRAlgorithm/HeuristicLab.Problems.GraphColoring/3.3/HeuristicLab.Problems.GraphColoring-3.3.csproj	(revision 14466)
@@ -0,0 +1,137 @@
+﻿<?xml version="1.0" encoding="utf-8"?>
+<Project ToolsVersion="14.0" DefaultTargets="Build" xmlns="http://schemas.microsoft.com/developer/msbuild/2003">
+  <Import Project="$(MSBuildExtensionsPath)\$(MSBuildToolsVersion)\Microsoft.Common.props" Condition="Exists('$(MSBuildExtensionsPath)\$(MSBuildToolsVersion)\Microsoft.Common.props')" />
+  <PropertyGroup>
+    <Configuration Condition=" '$(Configuration)' == '' ">Debug</Configuration>
+    <Platform Condition=" '$(Platform)' == '' ">AnyCPU</Platform>
+    <ProjectGuid>{4B76E2CB-A990-4959-B080-1D81D418D325}</ProjectGuid>
+    <OutputType>Library</OutputType>
+    <AppDesignerFolder>Properties</AppDesignerFolder>
+    <RootNamespace>HeuristicLab.Problems.GraphColoring</RootNamespace>
+    <AssemblyName>HeuristicLab.Problems.GraphColoring-3.3</AssemblyName>
+    <TargetFrameworkVersion>v4.5</TargetFrameworkVersion>
+    <FileAlignment>512</FileAlignment>
+    <TargetFrameworkProfile />
+  </PropertyGroup>
+  <PropertyGroup Condition=" '$(Configuration)|$(Platform)' == 'Debug|AnyCPU' ">
+    <DebugSymbols>true</DebugSymbols>
+    <DebugType>full</DebugType>
+    <Optimize>false</Optimize>
+    <OutputPath>..\..\bin\</OutputPath>
+    <DefineConstants>DEBUG;TRACE</DefineConstants>
+    <ErrorReport>prompt</ErrorReport>
+    <WarningLevel>4</WarningLevel>
+  </PropertyGroup>
+  <PropertyGroup Condition=" '$(Configuration)|$(Platform)' == 'Release|AnyCPU' ">
+    <DebugType>pdbonly</DebugType>
+    <Optimize>true</Optimize>
+    <OutputPath>..\..\bin\</OutputPath>
+    <DefineConstants>TRACE</DefineConstants>
+    <ErrorReport>prompt</ErrorReport>
+    <WarningLevel>4</WarningLevel>
+  </PropertyGroup>
+  <PropertyGroup>
+    <SignAssembly>true</SignAssembly>
+  </PropertyGroup>
+  <PropertyGroup>
+    <AssemblyOriginatorKeyFile>HeuristicLab.snk</AssemblyOriginatorKeyFile>
+  </PropertyGroup>
+  <ItemGroup>
+    <Reference Include="System" />
+    <Reference Include="System.Core" />
+    <Reference Include="System.Xml.Linq" />
+    <Reference Include="System.Data.DataSetExtensions" />
+    <Reference Include="Microsoft.CSharp" />
+    <Reference Include="System.Data" />
+    <Reference Include="System.Net.Http" />
+    <Reference Include="System.Xml" />
+  </ItemGroup>
+  <ItemGroup>
+    <Compile Include="GraphColoringProblem.cs" />
+    <Compile Include="Plugin.cs" />
+    <None Include="Plugin.cs.frame" />
+    <None Include="Properties\AssemblyInfo.cs.frame" />
+    <Compile Include="Properties\AssemblyInfo.cs" />
+  </ItemGroup>
+  <ItemGroup>
+    <None Include="HeuristicLab.snk" />
+  </ItemGroup>
+  <ItemGroup>
+    <ProjectReference Include="..\..\HeuristicLab.Collections\3.3\HeuristicLab.Collections-3.3.csproj">
+      <Project>{958b43bc-cc5c-4fa2-8628-2b3b01d890b6}</Project>
+      <Name>HeuristicLab.Collections-3.3</Name>
+      <Private>False</Private>
+    </ProjectReference>
+    <ProjectReference Include="..\..\HeuristicLab.Common.Resources\3.3\HeuristicLab.Common.Resources-3.3.csproj">
+      <Project>{0e27a536-1c4a-4624-a65e-dc4f4f23e3e1}</Project>
+      <Name>HeuristicLab.Common.Resources-3.3</Name>
+      <Private>False</Private>
+    </ProjectReference>
+    <ProjectReference Include="..\..\HeuristicLab.Common\3.3\HeuristicLab.Common-3.3.csproj">
+      <Project>{a9ad58b9-3ef9-4cc1-97e5-8d909039ff5c}</Project>
+      <Name>HeuristicLab.Common-3.3</Name>
+      <Private>False</Private>
+    </ProjectReference>
+    <ProjectReference Include="..\..\HeuristicLab.Core\3.3\HeuristicLab.Core-3.3.csproj">
+      <Project>{C36BD924-A541-4A00-AFA8-41701378DDC5}</Project>
+      <Name>HeuristicLab.Core-3.3</Name>
+      <Private>False</Private>
+    </ProjectReference>
+    <ProjectReference Include="..\..\HeuristicLab.Data\3.3\HeuristicLab.Data-3.3.csproj">
+      <Project>{bbab9df5-5ef3-4ba8-ade9-b36e82114937}</Project>
+      <Name>HeuristicLab.Data-3.3</Name>
+      <Private>False</Private>
+    </ProjectReference>
+    <ProjectReference Include="..\..\HeuristicLab.Encodings.LinearLinkageEncoding\3.3\HeuristicLab.Encodings.LinearLinkageEncoding-3.3.csproj">
+      <Project>{be698769-975a-429e-828c-72bb2b6182c8}</Project>
+      <Name>HeuristicLab.Encodings.LinearLinkageEncoding-3.3</Name>
+      <Private>False</Private>
+    </ProjectReference>
+    <ProjectReference Include="..\..\HeuristicLab.Operators\3.3\HeuristicLab.Operators-3.3.csproj">
+      <Project>{23da7ff4-d5b8-41b6-aa96-f0561d24f3ee}</Project>
+      <Name>HeuristicLab.Operators-3.3</Name>
+      <Private>False</Private>
+    </ProjectReference>
+    <ProjectReference Include="..\..\HeuristicLab.Optimization\3.3\HeuristicLab.Optimization-3.3.csproj">
+      <Project>{14ab8d24-25bc-400c-a846-4627aa945192}</Project>
+      <Name>HeuristicLab.Optimization-3.3</Name>
+      <Private>False</Private>
+    </ProjectReference>
+    <ProjectReference Include="..\..\HeuristicLab.Parameters\3.3\HeuristicLab.Parameters-3.3.csproj">
+      <Project>{56f9106a-079f-4c61-92f6-86a84c2d84b7}</Project>
+      <Name>HeuristicLab.Parameters-3.3</Name>
+      <Private>False</Private>
+    </ProjectReference>
+    <ProjectReference Include="..\..\HeuristicLab.Persistence\3.3\HeuristicLab.Persistence-3.3.csproj">
+      <Project>{102bc7d3-0ef9-439c-8f6d-96ff0fdb8e1b}</Project>
+      <Name>HeuristicLab.Persistence-3.3</Name>
+      <Private>False</Private>
+    </ProjectReference>
+    <ProjectReference Include="..\..\HeuristicLab.PluginInfrastructure\3.3\HeuristicLab.PluginInfrastructure-3.3.csproj">
+      <Project>{94186a6a-5176-4402-ae83-886557b53cca}</Project>
+      <Name>HeuristicLab.PluginInfrastructure-3.3</Name>
+      <Private>False</Private>
+    </ProjectReference>
+    <ProjectReference Include="..\..\HeuristicLab.Problems.Instances\3.3\HeuristicLab.Problems.Instances-3.3.csproj">
+      <Project>{3540e29e-4793-49e7-8ee2-fea7f61c3994}</Project>
+      <Name>HeuristicLab.Problems.Instances-3.3</Name>
+      <Private>False</Private>
+    </ProjectReference>
+  </ItemGroup>
+  <Import Project="$(MSBuildToolsPath)\Microsoft.CSharp.targets" />
+  <PropertyGroup>
+    <PreBuildEvent>set Path=%25Path%25;$(ProjectDir);$(SolutionDir)
+set ProjectDir=$(ProjectDir)
+set SolutionDir=$(SolutionDir)
+set Outdir=$(Outdir)
+
+call PreBuildEvent.cmd</PreBuildEvent>
+  </PropertyGroup>
+  <!-- To modify your build process, add your task inside one of the targets below and uncomment it. 
+       Other similar extension points exist, see Microsoft.Common.targets.
+  <Target Name="BeforeBuild">
+  </Target>
+  <Target Name="AfterBuild">
+  </Target>
+  -->
+</Project>
Index: /branches/MemPRAlgorithm/HeuristicLab.Problems.GraphColoring/3.3/Plugin.cs.frame
===================================================================
--- /branches/MemPRAlgorithm/HeuristicLab.Problems.GraphColoring/3.3/Plugin.cs.frame	(revision 14466)
+++ /branches/MemPRAlgorithm/HeuristicLab.Problems.GraphColoring/3.3/Plugin.cs.frame	(revision 14466)
@@ -0,0 +1,39 @@
+﻿#region License Information
+/* HeuristicLab
+ * Copyright (C) 2002-2016 Heuristic and Evolutionary Algorithms Laboratory (HEAL)
+ *
+ * This file is part of HeuristicLab.
+ *
+ * HeuristicLab is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation, either version 3 of the License, or
+ * (at your option) any later version.
+ *
+ * HeuristicLab is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with HeuristicLab. If not, see <http://www.gnu.org/licenses/>.
+ */
+#endregion
+
+using HeuristicLab.PluginInfrastructure;
+
+namespace HeuristicLab.Problems.GraphColoring {
+  [Plugin("HeuristicLab.Problems.GraphColoring", "3.3.14.$WCREV$")]
+  [PluginFile("HeuristicLab.Problems.GraphColoring-3.3.dll", PluginFileType.Assembly)]
+  [PluginDependency("HeuristicLab.Collections", "3.3")]
+  [PluginDependency("HeuristicLab.Common", "3.3")]
+  [PluginDependency("HeuristicLab.Common.Resources", "3.3")]
+  [PluginDependency("HeuristicLab.Core", "3.3")]
+  [PluginDependency("HeuristicLab.Data", "3.3")]
+  [PluginDependency("HeuristicLab.Encodings.LinearLinkageEncoding", "3.3")]
+  [PluginDependency("HeuristicLab.Operators", "3.3")]
+  [PluginDependency("HeuristicLab.Optimization", "3.3")]
+  [PluginDependency("HeuristicLab.Parameters", "3.3")]
+  [PluginDependency("HeuristicLab.Persistence", "3.3")]
+  public class HeuristicLabProblemsGraphColoringPlugin : PluginBase {
+  }
+}
Index: /branches/MemPRAlgorithm/HeuristicLab.Problems.GraphColoring/3.3/Properties/AssemblyInfo.cs.frame
===================================================================
--- /branches/MemPRAlgorithm/HeuristicLab.Problems.GraphColoring/3.3/Properties/AssemblyInfo.cs.frame	(revision 14466)
+++ /branches/MemPRAlgorithm/HeuristicLab.Problems.GraphColoring/3.3/Properties/AssemblyInfo.cs.frame	(revision 14466)
@@ -0,0 +1,56 @@
+﻿#region License Information
+/* HeuristicLab
+ * Copyright (C) 2002-2016 Heuristic and Evolutionary Algorithms Laboratory (HEAL)
+ *
+ * This file is part of HeuristicLab.
+ *
+ * HeuristicLab is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation, either version 3 of the License, or
+ * (at your option) any later version.
+ *
+ * HeuristicLab is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with HeuristicLab. If not, see <http://www.gnu.org/licenses/>.
+ */
+#endregion
+
+using System.Reflection;
+using System.Runtime.InteropServices;
+
+// General Information about an assembly is controlled through the following 
+// set of attributes. Change these attribute values to modify the information
+// associated with an assembly.
+[assembly: AssemblyTitle("HeuristicLab.Problems.GraphColoring")]
+[assembly: AssemblyDescription("")]
+[assembly: AssemblyConfiguration("")]
+[assembly: AssemblyCompany("HEAL")]
+[assembly: AssemblyProduct("HeuristicLab")]
+[assembly: AssemblyCopyright("(c) 2002-2016 HEAL")]
+[assembly: AssemblyTrademark("")]
+[assembly: AssemblyCulture("")]
+
+// Setting ComVisible to false makes the types in this assembly not visible 
+// to COM components.  If you need to access a type in this assembly from 
+// COM, set the ComVisible attribute to true on that type.
+[assembly: ComVisible(false)]
+
+// The following GUID is for the ID of the typelib if this project is exposed to COM
+[assembly: Guid("4b76e2cb-a990-4959-b080-1d81d418d325")]
+
+// Version information for an assembly consists of the following four values:
+//
+//      Major Version
+//      Minor Version 
+//      Build Number
+//      Revision
+//
+// You can specify all the values or you can default the Build and Revision Numbers 
+// by using the '*' as shown below:
+// [assembly: AssemblyVersion("1.0.*")]
+[assembly: AssemblyVersion("3.3.0.0")]
+[assembly: AssemblyFileVersion("3.3.14.$WCREV$")]
