Index: branches/MemPRAlgorithm/HeuristicLab 3.3.sln
===================================================================
--- branches/MemPRAlgorithm/HeuristicLab 3.3.sln	(revision 14470)
+++ branches/MemPRAlgorithm/HeuristicLab 3.3.sln	(revision 14471)
@@ -35,4 +35,5 @@
 		{E0B45023-CB84-48A1-A1B7-8295B64B7BAD} = {E0B45023-CB84-48A1-A1B7-8295B64B7BAD}
 		{C633FB23-BAE6-448E-BF5D-E1F9A839B5ED} = {C633FB23-BAE6-448E-BF5D-E1F9A839B5ED}
+		{9943FF23-8619-459C-B84A-E7FBDCBA04E6} = {9943FF23-8619-459C-B84A-E7FBDCBA04E6}
 		{CDA28124-ACD0-4231-8EB0-C510B361F84E} = {CDA28124-ACD0-4231-8EB0-C510B361F84E}
 		{14AB8D24-25BC-400C-A846-4627AA945192} = {14AB8D24-25BC-400C-A846-4627AA945192}
@@ -132,4 +133,5 @@
 		{BBF2CCC8-4D87-4297-8E18-8241FF93F966} = {BBF2CCC8-4D87-4297-8E18-8241FF93F966}
 		{59F354CB-FE13-4253-AED2-AD86372BEC27} = {59F354CB-FE13-4253-AED2-AD86372BEC27}
+		{4B76E2CB-A990-4959-B080-1D81D418D325} = {4B76E2CB-A990-4959-B080-1D81D418D325}
 		{D1EFA4CC-909F-41D5-9C1F-C3AF1957A372} = {D1EFA4CC-909F-41D5-9C1F-C3AF1957A372}
 		{7A2531CE-3F7C-4F13-BCCA-ED6DC27A7086} = {7A2531CE-3F7C-4F13-BCCA-ED6DC27A7086}
@@ -454,4 +456,6 @@
 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
+Project("{FAE04EC0-301F-11D3-BF4B-00C04F79EFBC}") = "HeuristicLab.Problems.Instances.DIMACS-3.3", "HeuristicLab.Problems.Instances.DIMACS\3.3\HeuristicLab.Problems.Instances.DIMACS-3.3.csproj", "{9943FF23-8619-459C-B84A-E7FBDCBA04E6}"
 EndProject
 Global
@@ -2217,4 +2221,16 @@
 		{4B76E2CB-A990-4959-B080-1D81D418D325}.Release|x86.ActiveCfg = Release|Any CPU
 		{4B76E2CB-A990-4959-B080-1D81D418D325}.Release|x86.Build.0 = Release|Any CPU
+		{9943FF23-8619-459C-B84A-E7FBDCBA04E6}.Debug|Any CPU.ActiveCfg = Debug|Any CPU
+		{9943FF23-8619-459C-B84A-E7FBDCBA04E6}.Debug|Any CPU.Build.0 = Debug|Any CPU
+		{9943FF23-8619-459C-B84A-E7FBDCBA04E6}.Debug|x64.ActiveCfg = Debug|Any CPU
+		{9943FF23-8619-459C-B84A-E7FBDCBA04E6}.Debug|x64.Build.0 = Debug|Any CPU
+		{9943FF23-8619-459C-B84A-E7FBDCBA04E6}.Debug|x86.ActiveCfg = Debug|Any CPU
+		{9943FF23-8619-459C-B84A-E7FBDCBA04E6}.Debug|x86.Build.0 = Debug|Any CPU
+		{9943FF23-8619-459C-B84A-E7FBDCBA04E6}.Release|Any CPU.ActiveCfg = Release|Any CPU
+		{9943FF23-8619-459C-B84A-E7FBDCBA04E6}.Release|Any CPU.Build.0 = Release|Any CPU
+		{9943FF23-8619-459C-B84A-E7FBDCBA04E6}.Release|x64.ActiveCfg = Release|Any CPU
+		{9943FF23-8619-459C-B84A-E7FBDCBA04E6}.Release|x64.Build.0 = Release|Any CPU
+		{9943FF23-8619-459C-B84A-E7FBDCBA04E6}.Release|x86.ActiveCfg = Release|Any CPU
+		{9943FF23-8619-459C-B84A-E7FBDCBA04E6}.Release|x86.Build.0 = Release|Any CPU
 	EndGlobalSection
 	GlobalSection(SolutionProperties) = preSolution
Index: branches/MemPRAlgorithm/HeuristicLab.Algorithms.MemPR/3.3/LinearLinkage/LinearLinkageMemPR.cs
===================================================================
--- branches/MemPRAlgorithm/HeuristicLab.Algorithms.MemPR/3.3/LinearLinkage/LinearLinkageMemPR.cs	(revision 14470)
+++ branches/MemPRAlgorithm/HeuristicLab.Algorithms.MemPR/3.3/LinearLinkage/LinearLinkageMemPR.cs	(revision 14471)
@@ -58,14 +58,14 @@
 
     protected override bool Eq(ISingleObjectiveSolutionScope<Encodings.LinearLinkageEncoding.LinearLinkage> a, ISingleObjectiveSolutionScope<Encodings.LinearLinkageEncoding.LinearLinkage> b) {
-      return a.Solution.SequenceEqual(b.Solution);
+      var s1 = a.Solution;
+      var s2 = b.Solution;
+      if (s1.Length != s2.Length) return false;
+      for (var i = 0; i < s1.Length; i++)
+        if (s1[i] != s2[i]) return false;
+      return true;
     }
 
     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;
+      return HammingSimilarityCalculator.CalculateSimilarity(a.Solution, b.Solution);
     }
 
@@ -94,4 +94,96 @@
     protected override int TabuWalk(ISingleObjectiveSolutionScope<Encodings.LinearLinkageEncoding.LinearLinkage> scope, int maxEvals, CancellationToken token, ISolutionSubspace<Encodings.LinearLinkageEncoding.LinearLinkage> subspace = null) {
       return 0;
+      /*Func<Encodings.LinearLinkageEncoding.LinearLinkage, IRandom, double> eval = new EvaluationWrapper<Encodings.LinearLinkageEncoding.LinearLinkage>(Context.Problem, scope).Evaluate;
+      var quality = scope.Fitness;
+      var lle = scope.Solution;
+      var random = Context.Random;
+      var evaluations = 0;
+      var maximization = Context.Problem.Maximization;
+      if (double.IsNaN(quality)) {
+        quality = eval(lle, random);
+        evaluations++;
+      }
+      Encodings.LinearLinkageEncoding.LinearLinkage bestOfTheWalk = null;
+      double bestOfTheWalkF = double.NaN;
+      var current = (Encodings.LinearLinkageEncoding.LinearLinkage)lle.Clone();
+      var currentF = quality;
+      var overallImprovement = false;
+      var tabu = new double[current.Length, current.Length];
+      for (var i = 0; i < current.Length; i++) {
+        for (var j = i; j < current.Length; j++) {
+          tabu[i, j] = tabu[j, i] = double.MaxValue;
+        }
+        tabu[i, current[i]] = currentF;
+      }
+
+      var steps = 0;
+      var stepsUntilBestOfWalk = 0;
+      for (var iter = 0; iter < int.MaxValue; iter++) {
+        var allTabu = true;
+        var bestOfTheRestF = double.NaN;
+        object bestOfTheRest = null;
+        var improved = false;
+        foreach () {
+          if (subspace != null && !(subspace[swap.Index1, 0] && subspace[swap.Index2, 0]))
+            continue;
+
+
+          var q = eval(current, random);
+          evaluations++;
+          if (FitnessComparer.IsBetter(maximization, q, quality)) {
+            overallImprovement = true;
+            quality = q;
+            for (var i = 0; i < current.Length; i++) lle[i] = current[i];
+          }
+          // check if it would not be an improvement to swap these into their positions
+          var isTabu = !FitnessComparer.IsBetter(maximization, q, tabu[swap.Index1, current[swap.Index1]])
+                    && !FitnessComparer.IsBetter(maximization, q, tabu[swap.Index2, current[swap.Index2]]);
+          if (!isTabu) allTabu = false;
+          if (FitnessComparer.IsBetter(maximization, q, currentF) && !isTabu) {
+            if (FitnessComparer.IsBetter(maximization, q, bestOfTheWalkF)) {
+              bestOfTheWalk = (Encodings.LinearLinkageEncoding.LinearLinkage)current.Clone();
+              bestOfTheWalkF = q;
+              stepsUntilBestOfWalk = steps;
+            }
+            steps++;
+            improved = true;
+            // perform the move
+            currentF = q;
+            // mark that to move them to their previous position requires to make an improvement
+            tabu[swap.Index1, current[swap.Index2]] = maximization ? Math.Max(q, tabu[swap.Index1, current[swap.Index2]])
+                                                                   : Math.Min(q, tabu[swap.Index1, current[swap.Index2]]);
+            tabu[swap.Index2, current[swap.Index1]] = maximization ? Math.Max(q, tabu[swap.Index2, current[swap.Index1]])
+                                                                   : Math.Min(q, tabu[swap.Index2, current[swap.Index1]]);
+          } else { // undo the move
+            if (!isTabu && FitnessComparer.IsBetter(maximization, q, bestOfTheRestF)) {
+              bestOfTheRest = swap;
+              bestOfTheRestF = q;
+            }
+            current[swap.Index2] = current[swap.Index1];
+            current[swap.Index1] = h;
+          }
+          if (evaluations >= maxEvals) break;
+        }
+        if (!allTabu && !improved && bestOfTheRest != null) {
+          tabu[bestOfTheRest.Index1, current[bestOfTheRest.Index1]] = maximization ? Math.Max(currentF, tabu[bestOfTheRest.Index1, current[bestOfTheRest.Index1]])
+                                                                                   : Math.Min(currentF, tabu[bestOfTheRest.Index1, current[bestOfTheRest.Index1]]);
+          tabu[bestOfTheRest.Index2, current[bestOfTheRest.Index2]] = maximization ? Math.Max(currentF, tabu[bestOfTheRest.Index2, current[bestOfTheRest.Index2]])
+                                                                                   : Math.Min(currentF, tabu[bestOfTheRest.Index2, current[bestOfTheRest.Index2]]);
+
+          var h = current[bestOfTheRest.Index1];
+          current[bestOfTheRest.Index1] = current[bestOfTheRest.Index2];
+          current[bestOfTheRest.Index2] = h;
+
+          currentF = bestOfTheRestF;
+          steps++;
+        } else if (allTabu) break;
+        if (evaluations >= maxEvals) break;
+      }
+      Context.IncrementEvaluatedSolutions(evaluations);
+      if (!overallImprovement && bestOfTheWalk != null) {
+        quality = bestOfTheWalkF;
+        for (var i = 0; i < current.Length; i++) lle[i] = bestOfTheWalk[i];
+      }
+      return stepsUntilBestOfWalk;*/
     }
 
Index: branches/MemPRAlgorithm/HeuristicLab.Encodings.LinearLinkageEncoding/3.3/HeuristicLab.Encodings.LinearLinkageEncoding-3.3.csproj
===================================================================
--- branches/MemPRAlgorithm/HeuristicLab.Encodings.LinearLinkageEncoding/3.3/HeuristicLab.Encodings.LinearLinkageEncoding-3.3.csproj	(revision 14470)
+++ branches/MemPRAlgorithm/HeuristicLab.Encodings.LinearLinkageEncoding/3.3/HeuristicLab.Encodings.LinearLinkageEncoding-3.3.csproj	(revision 14471)
@@ -182,4 +182,5 @@
     <Compile Include="Moves\Swap\Swap2MoveMaker.cs" />
     <Compile Include="ShakingOperators\LLEShakingOperator.cs" />
+    <Compile Include="SimilarityCalculators\HammingSimilarityCalculator.cs" />
     <None Include="HeuristicLab.snk" />
     <None Include="Plugin.cs.frame" />
Index: branches/MemPRAlgorithm/HeuristicLab.Encodings.LinearLinkageEncoding/3.3/SimilarityCalculators/HammingSimilarityCalculator.cs
===================================================================
--- branches/MemPRAlgorithm/HeuristicLab.Encodings.LinearLinkageEncoding/3.3/SimilarityCalculators/HammingSimilarityCalculator.cs	(revision 14471)
+++ branches/MemPRAlgorithm/HeuristicLab.Encodings.LinearLinkageEncoding/3.3/SimilarityCalculators/HammingSimilarityCalculator.cs	(revision 14471)
@@ -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;
+using HeuristicLab.Common;
+using HeuristicLab.Core;
+using HeuristicLab.Optimization.Operators;
+using HeuristicLab.Persistence.Default.CompositeSerializers.Storable;
+
+namespace HeuristicLab.Encodings.LinearLinkageEncoding {
+  [Item("Hamming Similarity Calculator for LinearLinkage", "Calculates the hamming similarity for two linear linkage encoded solutions.")]
+  [StorableClass]
+  public sealed class HammingSimilarityCalculator : SingleObjectiveSolutionSimilarityCalculator {
+
+    protected override bool IsCommutative {
+      get { return true; }
+    }
+
+    [StorableConstructor]
+    private HammingSimilarityCalculator(bool deserializing) : base(deserializing) { }
+    private HammingSimilarityCalculator(HammingSimilarityCalculator original, Cloner cloner) : base(original, cloner) { }
+    public HammingSimilarityCalculator() { }
+
+    public override IDeepCloneable Clone(Cloner cloner) {
+      return new HammingSimilarityCalculator(this, cloner);
+    }
+
+    public static double CalculateSimilarity(LinearLinkage left, LinearLinkage right) {
+      if (left.Length != right.Length) throw new ArgumentException("Comparing encodings of unequal length");
+      var dist = 0;
+      for (var i = 0; i < left.Length; i++) {
+        if (left[i] != right[i]) dist++;
+      }
+      return dist / (double)left.Length;
+    }
+
+    public override double CalculateSolutionSimilarity(IScope leftSolution, IScope rightSolution) {
+      var left = leftSolution.Variables[SolutionVariableName].Value as LinearLinkage;
+      var right = rightSolution.Variables[SolutionVariableName].Value as LinearLinkage;
+
+      return CalculateSimilarity(left, right);
+    }
+  }
+}
Index: branches/MemPRAlgorithm/HeuristicLab.Problems.GraphColoring/3.3/GraphColoringProblem.cs
===================================================================
--- branches/MemPRAlgorithm/HeuristicLab.Problems.GraphColoring/3.3/GraphColoringProblem.cs	(revision 14470)
+++ branches/MemPRAlgorithm/HeuristicLab.Problems.GraphColoring/3.3/GraphColoringProblem.cs	(revision 14471)
@@ -21,4 +21,6 @@
 
 using System;
+using System.Linq;
+using HeuristicLab.Analysis;
 using HeuristicLab.Common;
 using HeuristicLab.Core;
@@ -26,11 +28,15 @@
 using HeuristicLab.Encodings.LinearLinkageEncoding;
 using HeuristicLab.Optimization;
+using HeuristicLab.Optimization.Operators;
 using HeuristicLab.Parameters;
 using HeuristicLab.Persistence.Default.CompositeSerializers.Storable;
+using HeuristicLab.Problems.Instances;
 
 namespace HeuristicLab.Problems.GraphColoring {
+  public enum FitnessFunction { Prioritized, Penalized }
   [Item("Graph Coloring Problem (GCP)", "Attempts to find a coloring using a minimal number of colors that doesn't produce a conflict.")]
+  [Creatable(CreatableAttribute.Categories.CombinatorialProblems, Priority = 135)]
   [StorableClass]
-  public sealed class GraphColoringProblem : SingleObjectiveBasicProblem<LinearLinkageEncoding> {
+  public sealed class GraphColoringProblem : SingleObjectiveBasicProblem<LinearLinkageEncoding>, IProblemInstanceConsumer<GCPData> {
 
     public override bool Maximization {
@@ -38,7 +44,13 @@
     }
 
-    private IValueParameter<BoolMatrix> adjacencyMatrixParameter;
-    public IValueParameter<BoolMatrix> AdjacencyMatrixParameter {
-      get { return adjacencyMatrixParameter; }
+    [Storable]
+    private IValueParameter<IntMatrix> adjacencyListParameter;
+    public IValueParameter<IntMatrix> AdjacencyListParameter {
+      get { return adjacencyListParameter; }
+    }
+    [Storable]
+    private IValueParameter<EnumValue<FitnessFunction>> fitnessFunctionParameter;
+    public IValueParameter<EnumValue<FitnessFunction>> FitnessFunctionParameter {
+      get { return fitnessFunctionParameter; }
     }
 
@@ -47,19 +59,24 @@
     private GraphColoringProblem(GraphColoringProblem original, Cloner cloner)
       : base(original, cloner) {
-      adjacencyMatrixParameter = cloner.Clone(original.adjacencyMatrixParameter);
+      adjacencyListParameter = cloner.Clone(original.adjacencyListParameter);
+      fitnessFunctionParameter = cloner.Clone(original.fitnessFunctionParameter);
+      RegisterEventHandlers();
     }
     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];
-        }
+      Encoding = new LinearLinkageEncoding("lle");
+      Parameters.Add(adjacencyListParameter = new ValueParameter<IntMatrix>("Adjacency List", "The adjacency list that describes the (symmetric) edges in the graph with nodes from 0 to N-1."));
+      Parameters.Add(fitnessFunctionParameter = new ValueParameter<EnumValue<FitnessFunction>>("Fitness Function", "The function to use for evaluating the quality of a solution.", new EnumValue<FitnessFunction>(FitnessFunction.Prioritized)));
+
+      var imat = new IntMatrix(defaultInstance.Length, 2);
+      for (var i = 0; i < defaultInstance.Length; i++) {
+        imat[i, 0] = defaultInstance[i].Item1 - 1;
+        imat[i, 1] = defaultInstance[i].Item2 - 1;
       }
-      AdjacencyMatrixParameter.Value = matrix;
+      Encoding.Length = defaultInstanceNodes;
+      AdjacencyListParameter.Value = imat;
+      BestKnownQuality = 7;
+
+      InitializeOperators();
+      RegisterEventHandlers();
     }
 
@@ -68,22 +85,883 @@
     }
 
+    protected override void OnEncodingChanged() {
+      base.OnEncodingChanged();
+
+      Parameterize();
+    }
+
+    [StorableHook(HookType.AfterDeserialization)]
+    private void AfterDeserialization() {
+      RegisterEventHandlers();
+    }
+
+    private void RegisterEventHandlers() {
+      fitnessFunctionParameter.ValueChanged += FitnessFunctionParameterOnValueChanged;
+      fitnessFunctionParameter.Value.ValueChanged += FitnessFunctionOnValueChanged;
+    }
+
+    private void FitnessFunctionParameterOnValueChanged(object sender, EventArgs eventArgs) {
+      fitnessFunctionParameter.Value.ValueChanged += FitnessFunctionOnValueChanged;
+      OnReset();
+    }
+
+    private void FitnessFunctionOnValueChanged(object sender, EventArgs eventArgs) {
+      BestKnownQualityParameter.Value = null;
+      OnReset();
+    }
+
     public override double Evaluate(Individual individual, IRandom random) {
-      var matrix = adjacencyMatrixParameter.Value;
-      var lle = individual.LinearLinkage("lle");
-      var groups = lle.GetGroups();
+      var fitFun = FitnessFunctionParameter.Value.Value;
+      var adjList = adjacencyListParameter.Value;
+      var lle = individual.LinearLinkage(Encoding.Name).ToLLEe(); // LLE-e encoding uses the highest indexed member as group number
+
+      switch (fitFun) {
+        case FitnessFunction.Prioritized: {
+            var conflicts = 0;
+            var colors = lle.Distinct().Count();
+            for (var r = 0; r < adjList.Rows; r++) {
+              if (lle[adjList[r, 0]] == lle[adjList[r, 1]]) conflicts++; // both nodes are adjacent and have the same color (are in the same group)
+            }
+            // number of conflicts is the integer part of the quality
+            // number of colors constitutes the fractional part
+            // the number of fractional digits is defined by the maximum number of possible colors (each node its own color)
+            var mag = Math.Pow(10, -(int)Math.Ceiling(Math.Log10(lle.Length)));
+            // the value is e.g. 4.03 for 4 conflicts with 3 colors (and less than 100 nodes)
+            return conflicts + colors * mag;
+          }
+        case FitnessFunction.Penalized: {
+            // Fitness function from
+            // David S. Johnson, Cecilia R. Aragon, Lyle A. McGeoch, and Catherine Schevon. 1991.
+            // Optimization by simulated annealing: An experimental evaluation; part II, graph coloring and number partitioning.
+            // Operations Research 39(3), pp. 378–406.
+            // All local optima of this function correspond to legal colorings.
+            var colors = lle.GroupBy(x => x).ToDictionary(x => x.Key, x => new EvaluationHelper() { ColorCount = x.Count() });
+            for (var r = 0; r < adjList.Rows; r++) {
+              var color1 = lle[adjList[r, 0]];
+              var color2 = lle[adjList[r, 1]];
+              if (color1 == color2) colors[color1].ConflictCount++;
+            }
+            return 2 * colors.Sum(x => x.Value.ColorCount * x.Value.ConflictCount) - colors.Sum(x => x.Value.ColorCount * x.Value.ColorCount);
+          }
+        default: throw new InvalidOperationException(string.Format("Unknown fitness function {0}.", fitFun));
+      }
+    }
+
+    private class EvaluationHelper {
+      public int ColorCount { get; set; }
+      public int ConflictCount { get; set; }
+    }
+
+    public override void Analyze(Individual[] individuals, double[] qualities, ResultCollection results, IRandom random) {
+      var orderedIndividuals = individuals.Zip(qualities, (i, q) => new { Individual = i, Quality = q }).OrderBy(z => z.Quality);
+      var best = Maximization ? orderedIndividuals.Last().Individual.LinearLinkage(Encoding.Name) : orderedIndividuals.First().Individual.LinearLinkage(Encoding.Name);
+
+      var adjList = AdjacencyListParameter.Value;
+      var lle = best.ToLLEe();
       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 colors = lle.Distinct().Count();
+      for (var r = 0; r < adjList.Rows; r++) {
+        if (lle[adjList[r, 0]] == lle[adjList[r, 1]]) 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;
-    }
+      IResult res;
+      if (!results.TryGetValue("Best Solution Colors", out res)) {
+        res = new Result("Best Solution Colors", new IntValue(colors));
+        results.Add(res);
+      } else ((IntValue)res.Value).Value = colors;
+      if (!results.TryGetValue("Best Solution Conflicts", out res)) {
+        res = new Result("Best Solution Conflicts", new IntValue(conflicts));
+        results.Add(res);
+      } else ((IntValue)res.Value).Value = conflicts;
+    }
+
+    public void Load(GCPData data) {
+      Encoding.Length = data.Nodes;
+      AdjacencyListParameter.Value = new IntMatrix(data.Adjacencies);
+      if (FitnessFunctionParameter.Value.Value == FitnessFunction.Prioritized && data.BestKnownColors.HasValue) {
+        var mag = Math.Pow(10, -(int)Math.Ceiling(Math.Log10(data.Nodes)));
+        // the value is e.g. 4.03 for 4 conflicts with 3 colors (and less than 100 nodes)
+        BestKnownQuality = data.BestKnownColors.Value * mag;
+      } else BestKnownQualityParameter.Value = null;
+      Name = data.Name;
+      Description = data.Description;
+      OnReset();
+    }
+
+    private void InitializeOperators() {
+      Operators.Add(new HammingSimilarityCalculator());
+      Operators.Add(new QualitySimilarityCalculator());
+      Operators.Add(new PopulationSimilarityAnalyzer(Operators.OfType<ISolutionSimilarityCalculator>()));
+
+      Parameterize();
+    }
+
+    private void Parameterize() {
+      foreach (var simCalc in Operators.OfType<ISolutionSimilarityCalculator>()) {
+        simCalc.SolutionVariableName = Encoding.Name;
+        simCalc.QualityVariableName = Evaluator.QualityParameter.ActualName;
+      }
+    }
+
+    #region Default Instance (myciel6.col)
+    private static readonly int defaultInstanceNodes = 95;
+    private static readonly Tuple<int, int>[] defaultInstance = {
+Tuple.Create(1, 2),
+Tuple.Create(1, 4),
+Tuple.Create(1, 7),
+Tuple.Create(1, 9),
+Tuple.Create(1, 13),
+Tuple.Create(1, 15),
+Tuple.Create(1, 18),
+Tuple.Create(1, 20),
+Tuple.Create(1, 25),
+Tuple.Create(1, 27),
+Tuple.Create(1, 30),
+Tuple.Create(1, 32),
+Tuple.Create(1, 36),
+Tuple.Create(1, 38),
+Tuple.Create(1, 41),
+Tuple.Create(1, 43),
+Tuple.Create(1, 49),
+Tuple.Create(1, 51),
+Tuple.Create(1, 54),
+Tuple.Create(1, 56),
+Tuple.Create(1, 60),
+Tuple.Create(1, 62),
+Tuple.Create(1, 65),
+Tuple.Create(1, 67),
+Tuple.Create(1, 72),
+Tuple.Create(1, 74),
+Tuple.Create(1, 77),
+Tuple.Create(1, 79),
+Tuple.Create(1, 83),
+Tuple.Create(1, 85),
+Tuple.Create(1, 88),
+Tuple.Create(1, 90),
+Tuple.Create(2, 3),
+Tuple.Create(2, 6),
+Tuple.Create(2, 8),
+Tuple.Create(2, 12),
+Tuple.Create(2, 14),
+Tuple.Create(2, 17),
+Tuple.Create(2, 19),
+Tuple.Create(2, 24),
+Tuple.Create(2, 26),
+Tuple.Create(2, 29),
+Tuple.Create(2, 31),
+Tuple.Create(2, 35),
+Tuple.Create(2, 37),
+Tuple.Create(2, 40),
+Tuple.Create(2, 42),
+Tuple.Create(2, 48),
+Tuple.Create(2, 50),
+Tuple.Create(2, 53),
+Tuple.Create(2, 55),
+Tuple.Create(2, 59),
+Tuple.Create(2, 61),
+Tuple.Create(2, 64),
+Tuple.Create(2, 66),
+Tuple.Create(2, 71),
+Tuple.Create(2, 73),
+Tuple.Create(2, 76),
+Tuple.Create(2, 78),
+Tuple.Create(2, 82),
+Tuple.Create(2, 84),
+Tuple.Create(2, 87),
+Tuple.Create(2, 89),
+Tuple.Create(3, 5),
+Tuple.Create(3, 7),
+Tuple.Create(3, 10),
+Tuple.Create(3, 13),
+Tuple.Create(3, 16),
+Tuple.Create(3, 18),
+Tuple.Create(3, 21),
+Tuple.Create(3, 25),
+Tuple.Create(3, 28),
+Tuple.Create(3, 30),
+Tuple.Create(3, 33),
+Tuple.Create(3, 36),
+Tuple.Create(3, 39),
+Tuple.Create(3, 41),
+Tuple.Create(3, 44),
+Tuple.Create(3, 49),
+Tuple.Create(3, 52),
+Tuple.Create(3, 54),
+Tuple.Create(3, 57),
+Tuple.Create(3, 60),
+Tuple.Create(3, 63),
+Tuple.Create(3, 65),
+Tuple.Create(3, 68),
+Tuple.Create(3, 72),
+Tuple.Create(3, 75),
+Tuple.Create(3, 77),
+Tuple.Create(3, 80),
+Tuple.Create(3, 83),
+Tuple.Create(3, 86),
+Tuple.Create(3, 88),
+Tuple.Create(3, 91),
+Tuple.Create(4, 5),
+Tuple.Create(4, 6),
+Tuple.Create(4, 10),
+Tuple.Create(4, 12),
+Tuple.Create(4, 16),
+Tuple.Create(4, 17),
+Tuple.Create(4, 21),
+Tuple.Create(4, 24),
+Tuple.Create(4, 28),
+Tuple.Create(4, 29),
+Tuple.Create(4, 33),
+Tuple.Create(4, 35),
+Tuple.Create(4, 39),
+Tuple.Create(4, 40),
+Tuple.Create(4, 44),
+Tuple.Create(4, 48),
+Tuple.Create(4, 52),
+Tuple.Create(4, 53),
+Tuple.Create(4, 57),
+Tuple.Create(4, 59),
+Tuple.Create(4, 63),
+Tuple.Create(4, 64),
+Tuple.Create(4, 68),
+Tuple.Create(4, 71),
+Tuple.Create(4, 75),
+Tuple.Create(4, 76),
+Tuple.Create(4, 80),
+Tuple.Create(4, 82),
+Tuple.Create(4, 86),
+Tuple.Create(4, 87),
+Tuple.Create(4, 91),
+Tuple.Create(5, 8),
+Tuple.Create(5, 9),
+Tuple.Create(5, 14),
+Tuple.Create(5, 15),
+Tuple.Create(5, 19),
+Tuple.Create(5, 20),
+Tuple.Create(5, 26),
+Tuple.Create(5, 27),
+Tuple.Create(5, 31),
+Tuple.Create(5, 32),
+Tuple.Create(5, 37),
+Tuple.Create(5, 38),
+Tuple.Create(5, 42),
+Tuple.Create(5, 43),
+Tuple.Create(5, 50),
+Tuple.Create(5, 51),
+Tuple.Create(5, 55),
+Tuple.Create(5, 56),
+Tuple.Create(5, 61),
+Tuple.Create(5, 62),
+Tuple.Create(5, 66),
+Tuple.Create(5, 67),
+Tuple.Create(5, 73),
+Tuple.Create(5, 74),
+Tuple.Create(5, 78),
+Tuple.Create(5, 79),
+Tuple.Create(5, 84),
+Tuple.Create(5, 85),
+Tuple.Create(5, 89),
+Tuple.Create(5, 90),
+Tuple.Create(6, 11),
+Tuple.Create(6, 13),
+Tuple.Create(6, 15),
+Tuple.Create(6, 22),
+Tuple.Create(6, 25),
+Tuple.Create(6, 27),
+Tuple.Create(6, 34),
+Tuple.Create(6, 36),
+Tuple.Create(6, 38),
+Tuple.Create(6, 45),
+Tuple.Create(6, 49),
+Tuple.Create(6, 51),
+Tuple.Create(6, 58),
+Tuple.Create(6, 60),
+Tuple.Create(6, 62),
+Tuple.Create(6, 69),
+Tuple.Create(6, 72),
+Tuple.Create(6, 74),
+Tuple.Create(6, 81),
+Tuple.Create(6, 83),
+Tuple.Create(6, 85),
+Tuple.Create(6, 92),
+Tuple.Create(7, 11),
+Tuple.Create(7, 12),
+Tuple.Create(7, 14),
+Tuple.Create(7, 22),
+Tuple.Create(7, 24),
+Tuple.Create(7, 26),
+Tuple.Create(7, 34),
+Tuple.Create(7, 35),
+Tuple.Create(7, 37),
+Tuple.Create(7, 45),
+Tuple.Create(7, 48),
+Tuple.Create(7, 50),
+Tuple.Create(7, 58),
+Tuple.Create(7, 59),
+Tuple.Create(7, 61),
+Tuple.Create(7, 69),
+Tuple.Create(7, 71),
+Tuple.Create(7, 73),
+Tuple.Create(7, 81),
+Tuple.Create(7, 82),
+Tuple.Create(7, 84),
+Tuple.Create(7, 92),
+Tuple.Create(8, 11),
+Tuple.Create(8, 13),
+Tuple.Create(8, 16),
+Tuple.Create(8, 22),
+Tuple.Create(8, 25),
+Tuple.Create(8, 28),
+Tuple.Create(8, 34),
+Tuple.Create(8, 36),
+Tuple.Create(8, 39),
+Tuple.Create(8, 45),
+Tuple.Create(8, 49),
+Tuple.Create(8, 52),
+Tuple.Create(8, 58),
+Tuple.Create(8, 60),
+Tuple.Create(8, 63),
+Tuple.Create(8, 69),
+Tuple.Create(8, 72),
+Tuple.Create(8, 75),
+Tuple.Create(8, 81),
+Tuple.Create(8, 83),
+Tuple.Create(8, 86),
+Tuple.Create(8, 92),
+Tuple.Create(9, 11),
+Tuple.Create(9, 12),
+Tuple.Create(9, 16),
+Tuple.Create(9, 22),
+Tuple.Create(9, 24),
+Tuple.Create(9, 28),
+Tuple.Create(9, 34),
+Tuple.Create(9, 35),
+Tuple.Create(9, 39),
+Tuple.Create(9, 45),
+Tuple.Create(9, 48),
+Tuple.Create(9, 52),
+Tuple.Create(9, 58),
+Tuple.Create(9, 59),
+Tuple.Create(9, 63),
+Tuple.Create(9, 69),
+Tuple.Create(9, 71),
+Tuple.Create(9, 75),
+Tuple.Create(9, 81),
+Tuple.Create(9, 82),
+Tuple.Create(9, 86),
+Tuple.Create(9, 92),
+Tuple.Create(10, 11),
+Tuple.Create(10, 14),
+Tuple.Create(10, 15),
+Tuple.Create(10, 22),
+Tuple.Create(10, 26),
+Tuple.Create(10, 27),
+Tuple.Create(10, 34),
+Tuple.Create(10, 37),
+Tuple.Create(10, 38),
+Tuple.Create(10, 45),
+Tuple.Create(10, 50),
+Tuple.Create(10, 51),
+Tuple.Create(10, 58),
+Tuple.Create(10, 61),
+Tuple.Create(10, 62),
+Tuple.Create(10, 69),
+Tuple.Create(10, 73),
+Tuple.Create(10, 74),
+Tuple.Create(10, 81),
+Tuple.Create(10, 84),
+Tuple.Create(10, 85),
+Tuple.Create(10, 92),
+Tuple.Create(11, 17),
+Tuple.Create(11, 18),
+Tuple.Create(11, 19),
+Tuple.Create(11, 20),
+Tuple.Create(11, 21),
+Tuple.Create(11, 29),
+Tuple.Create(11, 30),
+Tuple.Create(11, 31),
+Tuple.Create(11, 32),
+Tuple.Create(11, 33),
+Tuple.Create(11, 40),
+Tuple.Create(11, 41),
+Tuple.Create(11, 42),
+Tuple.Create(11, 43),
+Tuple.Create(11, 44),
+Tuple.Create(11, 53),
+Tuple.Create(11, 54),
+Tuple.Create(11, 55),
+Tuple.Create(11, 56),
+Tuple.Create(11, 57),
+Tuple.Create(11, 64),
+Tuple.Create(11, 65),
+Tuple.Create(11, 66),
+Tuple.Create(11, 67),
+Tuple.Create(11, 68),
+Tuple.Create(11, 76),
+Tuple.Create(11, 77),
+Tuple.Create(11, 78),
+Tuple.Create(11, 79),
+Tuple.Create(11, 80),
+Tuple.Create(11, 87),
+Tuple.Create(11, 88),
+Tuple.Create(11, 89),
+Tuple.Create(11, 90),
+Tuple.Create(11, 91),
+Tuple.Create(12, 23),
+Tuple.Create(12, 25),
+Tuple.Create(12, 27),
+Tuple.Create(12, 30),
+Tuple.Create(12, 32),
+Tuple.Create(12, 46),
+Tuple.Create(12, 49),
+Tuple.Create(12, 51),
+Tuple.Create(12, 54),
+Tuple.Create(12, 56),
+Tuple.Create(12, 70),
+Tuple.Create(12, 72),
+Tuple.Create(12, 74),
+Tuple.Create(12, 77),
+Tuple.Create(12, 79),
+Tuple.Create(12, 93),
+Tuple.Create(13, 23),
+Tuple.Create(13, 24),
+Tuple.Create(13, 26),
+Tuple.Create(13, 29),
+Tuple.Create(13, 31),
+Tuple.Create(13, 46),
+Tuple.Create(13, 48),
+Tuple.Create(13, 50),
+Tuple.Create(13, 53),
+Tuple.Create(13, 55),
+Tuple.Create(13, 70),
+Tuple.Create(13, 71),
+Tuple.Create(13, 73),
+Tuple.Create(13, 76),
+Tuple.Create(13, 78),
+Tuple.Create(13, 93),
+Tuple.Create(14, 23),
+Tuple.Create(14, 25),
+Tuple.Create(14, 28),
+Tuple.Create(14, 30),
+Tuple.Create(14, 33),
+Tuple.Create(14, 46),
+Tuple.Create(14, 49),
+Tuple.Create(14, 52),
+Tuple.Create(14, 54),
+Tuple.Create(14, 57),
+Tuple.Create(14, 70),
+Tuple.Create(14, 72),
+Tuple.Create(14, 75),
+Tuple.Create(14, 77),
+Tuple.Create(14, 80),
+Tuple.Create(14, 93),
+Tuple.Create(15, 23),
+Tuple.Create(15, 24),
+Tuple.Create(15, 28),
+Tuple.Create(15, 29),
+Tuple.Create(15, 33),
+Tuple.Create(15, 46),
+Tuple.Create(15, 48),
+Tuple.Create(15, 52),
+Tuple.Create(15, 53),
+Tuple.Create(15, 57),
+Tuple.Create(15, 70),
+Tuple.Create(15, 71),
+Tuple.Create(15, 75),
+Tuple.Create(15, 76),
+Tuple.Create(15, 80),
+Tuple.Create(15, 93),
+Tuple.Create(16, 23),
+Tuple.Create(16, 26),
+Tuple.Create(16, 27),
+Tuple.Create(16, 31),
+Tuple.Create(16, 32),
+Tuple.Create(16, 46),
+Tuple.Create(16, 50),
+Tuple.Create(16, 51),
+Tuple.Create(16, 55),
+Tuple.Create(16, 56),
+Tuple.Create(16, 70),
+Tuple.Create(16, 73),
+Tuple.Create(16, 74),
+Tuple.Create(16, 78),
+Tuple.Create(16, 79),
+Tuple.Create(16, 93),
+Tuple.Create(17, 23),
+Tuple.Create(17, 25),
+Tuple.Create(17, 27),
+Tuple.Create(17, 34),
+Tuple.Create(17, 46),
+Tuple.Create(17, 49),
+Tuple.Create(17, 51),
+Tuple.Create(17, 58),
+Tuple.Create(17, 70),
+Tuple.Create(17, 72),
+Tuple.Create(17, 74),
+Tuple.Create(17, 81),
+Tuple.Create(17, 93),
+Tuple.Create(18, 23),
+Tuple.Create(18, 24),
+Tuple.Create(18, 26),
+Tuple.Create(18, 34),
+Tuple.Create(18, 46),
+Tuple.Create(18, 48),
+Tuple.Create(18, 50),
+Tuple.Create(18, 58),
+Tuple.Create(18, 70),
+Tuple.Create(18, 71),
+Tuple.Create(18, 73),
+Tuple.Create(18, 81),
+Tuple.Create(18, 93),
+Tuple.Create(19, 23),
+Tuple.Create(19, 25),
+Tuple.Create(19, 28),
+Tuple.Create(19, 34),
+Tuple.Create(19, 46),
+Tuple.Create(19, 49),
+Tuple.Create(19, 52),
+Tuple.Create(19, 58),
+Tuple.Create(19, 70),
+Tuple.Create(19, 72),
+Tuple.Create(19, 75),
+Tuple.Create(19, 81),
+Tuple.Create(19, 93),
+Tuple.Create(20, 23),
+Tuple.Create(20, 24),
+Tuple.Create(20, 28),
+Tuple.Create(20, 34),
+Tuple.Create(20, 46),
+Tuple.Create(20, 48),
+Tuple.Create(20, 52),
+Tuple.Create(20, 58),
+Tuple.Create(20, 70),
+Tuple.Create(20, 71),
+Tuple.Create(20, 75),
+Tuple.Create(20, 81),
+Tuple.Create(20, 93),
+Tuple.Create(21, 23),
+Tuple.Create(21, 26),
+Tuple.Create(21, 27),
+Tuple.Create(21, 34),
+Tuple.Create(21, 46),
+Tuple.Create(21, 50),
+Tuple.Create(21, 51),
+Tuple.Create(21, 58),
+Tuple.Create(21, 70),
+Tuple.Create(21, 73),
+Tuple.Create(21, 74),
+Tuple.Create(21, 81),
+Tuple.Create(21, 93),
+Tuple.Create(22, 23),
+Tuple.Create(22, 29),
+Tuple.Create(22, 30),
+Tuple.Create(22, 31),
+Tuple.Create(22, 32),
+Tuple.Create(22, 33),
+Tuple.Create(22, 46),
+Tuple.Create(22, 53),
+Tuple.Create(22, 54),
+Tuple.Create(22, 55),
+Tuple.Create(22, 56),
+Tuple.Create(22, 57),
+Tuple.Create(22, 70),
+Tuple.Create(22, 76),
+Tuple.Create(22, 77),
+Tuple.Create(22, 78),
+Tuple.Create(22, 79),
+Tuple.Create(22, 80),
+Tuple.Create(22, 93),
+Tuple.Create(23, 35),
+Tuple.Create(23, 36),
+Tuple.Create(23, 37),
+Tuple.Create(23, 38),
+Tuple.Create(23, 39),
+Tuple.Create(23, 40),
+Tuple.Create(23, 41),
+Tuple.Create(23, 42),
+Tuple.Create(23, 43),
+Tuple.Create(23, 44),
+Tuple.Create(23, 45),
+Tuple.Create(23, 59),
+Tuple.Create(23, 60),
+Tuple.Create(23, 61),
+Tuple.Create(23, 62),
+Tuple.Create(23, 63),
+Tuple.Create(23, 64),
+Tuple.Create(23, 65),
+Tuple.Create(23, 66),
+Tuple.Create(23, 67),
+Tuple.Create(23, 68),
+Tuple.Create(23, 69),
+Tuple.Create(23, 82),
+Tuple.Create(23, 83),
+Tuple.Create(23, 84),
+Tuple.Create(23, 85),
+Tuple.Create(23, 86),
+Tuple.Create(23, 87),
+Tuple.Create(23, 88),
+Tuple.Create(23, 89),
+Tuple.Create(23, 90),
+Tuple.Create(23, 91),
+Tuple.Create(23, 92),
+Tuple.Create(24, 47),
+Tuple.Create(24, 49),
+Tuple.Create(24, 51),
+Tuple.Create(24, 54),
+Tuple.Create(24, 56),
+Tuple.Create(24, 60),
+Tuple.Create(24, 62),
+Tuple.Create(24, 65),
+Tuple.Create(24, 67),
+Tuple.Create(24, 94),
+Tuple.Create(25, 47),
+Tuple.Create(25, 48),
+Tuple.Create(25, 50),
+Tuple.Create(25, 53),
+Tuple.Create(25, 55),
+Tuple.Create(25, 59),
+Tuple.Create(25, 61),
+Tuple.Create(25, 64),
+Tuple.Create(25, 66),
+Tuple.Create(25, 94),
+Tuple.Create(26, 47),
+Tuple.Create(26, 49),
+Tuple.Create(26, 52),
+Tuple.Create(26, 54),
+Tuple.Create(26, 57),
+Tuple.Create(26, 60),
+Tuple.Create(26, 63),
+Tuple.Create(26, 65),
+Tuple.Create(26, 68),
+Tuple.Create(26, 94),
+Tuple.Create(27, 47),
+Tuple.Create(27, 48),
+Tuple.Create(27, 52),
+Tuple.Create(27, 53),
+Tuple.Create(27, 57),
+Tuple.Create(27, 59),
+Tuple.Create(27, 63),
+Tuple.Create(27, 64),
+Tuple.Create(27, 68),
+Tuple.Create(27, 94),
+Tuple.Create(28, 47),
+Tuple.Create(28, 50),
+Tuple.Create(28, 51),
+Tuple.Create(28, 55),
+Tuple.Create(28, 56),
+Tuple.Create(28, 61),
+Tuple.Create(28, 62),
+Tuple.Create(28, 66),
+Tuple.Create(28, 67),
+Tuple.Create(28, 94),
+Tuple.Create(29, 47),
+Tuple.Create(29, 49),
+Tuple.Create(29, 51),
+Tuple.Create(29, 58),
+Tuple.Create(29, 60),
+Tuple.Create(29, 62),
+Tuple.Create(29, 69),
+Tuple.Create(29, 94),
+Tuple.Create(30, 47),
+Tuple.Create(30, 48),
+Tuple.Create(30, 50),
+Tuple.Create(30, 58),
+Tuple.Create(30, 59),
+Tuple.Create(30, 61),
+Tuple.Create(30, 69),
+Tuple.Create(30, 94),
+Tuple.Create(31, 47),
+Tuple.Create(31, 49),
+Tuple.Create(31, 52),
+Tuple.Create(31, 58),
+Tuple.Create(31, 60),
+Tuple.Create(31, 63),
+Tuple.Create(31, 69),
+Tuple.Create(31, 94),
+Tuple.Create(32, 47),
+Tuple.Create(32, 48),
+Tuple.Create(32, 52),
+Tuple.Create(32, 58),
+Tuple.Create(32, 59),
+Tuple.Create(32, 63),
+Tuple.Create(32, 69),
+Tuple.Create(32, 94),
+Tuple.Create(33, 47),
+Tuple.Create(33, 50),
+Tuple.Create(33, 51),
+Tuple.Create(33, 58),
+Tuple.Create(33, 61),
+Tuple.Create(33, 62),
+Tuple.Create(33, 69),
+Tuple.Create(33, 94),
+Tuple.Create(34, 47),
+Tuple.Create(34, 53),
+Tuple.Create(34, 54),
+Tuple.Create(34, 55),
+Tuple.Create(34, 56),
+Tuple.Create(34, 57),
+Tuple.Create(34, 64),
+Tuple.Create(34, 65),
+Tuple.Create(34, 66),
+Tuple.Create(34, 67),
+Tuple.Create(34, 68),
+Tuple.Create(34, 94),
+Tuple.Create(35, 47),
+Tuple.Create(35, 49),
+Tuple.Create(35, 51),
+Tuple.Create(35, 54),
+Tuple.Create(35, 56),
+Tuple.Create(35, 70),
+Tuple.Create(35, 94),
+Tuple.Create(36, 47),
+Tuple.Create(36, 48),
+Tuple.Create(36, 50),
+Tuple.Create(36, 53),
+Tuple.Create(36, 55),
+Tuple.Create(36, 70),
+Tuple.Create(36, 94),
+Tuple.Create(37, 47),
+Tuple.Create(37, 49),
+Tuple.Create(37, 52),
+Tuple.Create(37, 54),
+Tuple.Create(37, 57),
+Tuple.Create(37, 70),
+Tuple.Create(37, 94),
+Tuple.Create(38, 47),
+Tuple.Create(38, 48),
+Tuple.Create(38, 52),
+Tuple.Create(38, 53),
+Tuple.Create(38, 57),
+Tuple.Create(38, 70),
+Tuple.Create(38, 94),
+Tuple.Create(39, 47),
+Tuple.Create(39, 50),
+Tuple.Create(39, 51),
+Tuple.Create(39, 55),
+Tuple.Create(39, 56),
+Tuple.Create(39, 70),
+Tuple.Create(39, 94),
+Tuple.Create(40, 47),
+Tuple.Create(40, 49),
+Tuple.Create(40, 51),
+Tuple.Create(40, 58),
+Tuple.Create(40, 70),
+Tuple.Create(40, 94),
+Tuple.Create(41, 47),
+Tuple.Create(41, 48),
+Tuple.Create(41, 50),
+Tuple.Create(41, 58),
+Tuple.Create(41, 70),
+Tuple.Create(41, 94),
+Tuple.Create(42, 47),
+Tuple.Create(42, 49),
+Tuple.Create(42, 52),
+Tuple.Create(42, 58),
+Tuple.Create(42, 70),
+Tuple.Create(42, 94),
+Tuple.Create(43, 47),
+Tuple.Create(43, 48),
+Tuple.Create(43, 52),
+Tuple.Create(43, 58),
+Tuple.Create(43, 70),
+Tuple.Create(43, 94),
+Tuple.Create(44, 47),
+Tuple.Create(44, 50),
+Tuple.Create(44, 51),
+Tuple.Create(44, 58),
+Tuple.Create(44, 70),
+Tuple.Create(44, 94),
+Tuple.Create(45, 47),
+Tuple.Create(45, 53),
+Tuple.Create(45, 54),
+Tuple.Create(45, 55),
+Tuple.Create(45, 56),
+Tuple.Create(45, 57),
+Tuple.Create(45, 70),
+Tuple.Create(45, 94),
+Tuple.Create(46, 47),
+Tuple.Create(46, 59),
+Tuple.Create(46, 60),
+Tuple.Create(46, 61),
+Tuple.Create(46, 62),
+Tuple.Create(46, 63),
+Tuple.Create(46, 64),
+Tuple.Create(46, 65),
+Tuple.Create(46, 66),
+Tuple.Create(46, 67),
+Tuple.Create(46, 68),
+Tuple.Create(46, 69),
+Tuple.Create(46, 94),
+Tuple.Create(47, 71),
+Tuple.Create(47, 72),
+Tuple.Create(47, 73),
+Tuple.Create(47, 74),
+Tuple.Create(47, 75),
+Tuple.Create(47, 76),
+Tuple.Create(47, 77),
+Tuple.Create(47, 78),
+Tuple.Create(47, 79),
+Tuple.Create(47, 80),
+Tuple.Create(47, 81),
+Tuple.Create(47, 82),
+Tuple.Create(47, 83),
+Tuple.Create(47, 84),
+Tuple.Create(47, 85),
+Tuple.Create(47, 86),
+Tuple.Create(47, 87),
+Tuple.Create(47, 88),
+Tuple.Create(47, 89),
+Tuple.Create(47, 90),
+Tuple.Create(47, 91),
+Tuple.Create(47, 92),
+Tuple.Create(47, 93),
+Tuple.Create(48, 95),
+Tuple.Create(49, 95),
+Tuple.Create(50, 95),
+Tuple.Create(51, 95),
+Tuple.Create(52, 95),
+Tuple.Create(53, 95),
+Tuple.Create(54, 95),
+Tuple.Create(55, 95),
+Tuple.Create(56, 95),
+Tuple.Create(57, 95),
+Tuple.Create(58, 95),
+Tuple.Create(59, 95),
+Tuple.Create(60, 95),
+Tuple.Create(61, 95),
+Tuple.Create(62, 95),
+Tuple.Create(63, 95),
+Tuple.Create(64, 95),
+Tuple.Create(65, 95),
+Tuple.Create(66, 95),
+Tuple.Create(67, 95),
+Tuple.Create(68, 95),
+Tuple.Create(69, 95),
+Tuple.Create(70, 95),
+Tuple.Create(71, 95),
+Tuple.Create(72, 95),
+Tuple.Create(73, 95),
+Tuple.Create(74, 95),
+Tuple.Create(75, 95),
+Tuple.Create(76, 95),
+Tuple.Create(77, 95),
+Tuple.Create(78, 95),
+Tuple.Create(79, 95),
+Tuple.Create(80, 95),
+Tuple.Create(81, 95),
+Tuple.Create(82, 95),
+Tuple.Create(83, 95),
+Tuple.Create(84, 95),
+Tuple.Create(85, 95),
+Tuple.Create(86, 95),
+Tuple.Create(87, 95),
+Tuple.Create(88, 95),
+Tuple.Create(89, 95),
+Tuple.Create(90, 95),
+Tuple.Create(91, 95),
+Tuple.Create(92, 95),
+Tuple.Create(93, 95),
+Tuple.Create(94, 95)
+    };
+    #endregion
   }
 }
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 14470)
+++ branches/MemPRAlgorithm/HeuristicLab.Problems.GraphColoring/3.3/HeuristicLab.Problems.GraphColoring-3.3.csproj	(revision 14471)
@@ -58,4 +58,9 @@
   </ItemGroup>
   <ItemGroup>
+    <ProjectReference Include="..\..\HeuristicLab.Analysis\3.3\HeuristicLab.Analysis-3.3.csproj">
+      <Project>{887425B4-4348-49ED-A457-B7D2C26DDBF9}</Project>
+      <Name>HeuristicLab.Analysis-3.3</Name>
+      <Private>False</Private>
+    </ProjectReference>
     <ProjectReference Include="..\..\HeuristicLab.Collections\3.3\HeuristicLab.Collections-3.3.csproj">
       <Project>{958b43bc-cc5c-4fa2-8628-2b3b01d890b6}</Project>
@@ -91,4 +96,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.Problems.GraphColoring/3.3/Plugin.cs.frame
===================================================================
--- branches/MemPRAlgorithm/HeuristicLab.Problems.GraphColoring/3.3/Plugin.cs.frame	(revision 14470)
+++ branches/MemPRAlgorithm/HeuristicLab.Problems.GraphColoring/3.3/Plugin.cs.frame	(revision 14471)
@@ -25,4 +25,5 @@
   [Plugin("HeuristicLab.Problems.GraphColoring", "3.3.14.$WCREV$")]
   [PluginFile("HeuristicLab.Problems.GraphColoring-3.3.dll", PluginFileType.Assembly)]
+  [PluginDependency("HeuristicLab.Analysis", "3.3")]
   [PluginDependency("HeuristicLab.Collections", "3.3")]
   [PluginDependency("HeuristicLab.Common", "3.3")]
@@ -33,5 +34,7 @@
   [PluginDependency("HeuristicLab.Operators", "3.3")]
   [PluginDependency("HeuristicLab.Optimization", "3.3")]
+  [PluginDependency("HeuristicLab.Optimization.Operators", "3.3")]
   [PluginDependency("HeuristicLab.Parameters", "3.3")]
+  [PluginDependency("HeuristicLab.Problems.Instances", "3.3")]
   [PluginDependency("HeuristicLab.Persistence", "3.3")]
   public class HeuristicLabProblemsGraphColoringPlugin : PluginBase {
Index: branches/MemPRAlgorithm/HeuristicLab.Problems.Instances.DIMACS/3.3/GcolDataDescriptor.cs
===================================================================
--- branches/MemPRAlgorithm/HeuristicLab.Problems.Instances.DIMACS/3.3/GcolDataDescriptor.cs	(revision 14471)
+++ branches/MemPRAlgorithm/HeuristicLab.Problems.Instances.DIMACS/3.3/GcolDataDescriptor.cs	(revision 14471)
@@ -0,0 +1,35 @@
+﻿#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
+
+namespace HeuristicLab.Problems.Instances.DIMACS {
+  internal class GcolDataDescriptor : IDataDescriptor {
+    public string Name { get; internal set; }
+    public string Description { get; internal set; }
+
+    internal string InstanceIdentifier { get; set; }
+
+    internal GcolDataDescriptor(string name, string description, string instanceIdentifier) {
+      this.Name = name;
+      this.Description = description;
+      this.InstanceIdentifier = instanceIdentifier;
+    }
+  }
+}
Index: branches/MemPRAlgorithm/HeuristicLab.Problems.Instances.DIMACS/3.3/GcolInstanceProvider.cs
===================================================================
--- branches/MemPRAlgorithm/HeuristicLab.Problems.Instances.DIMACS/3.3/GcolInstanceProvider.cs	(revision 14471)
+++ branches/MemPRAlgorithm/HeuristicLab.Problems.Instances.DIMACS/3.3/GcolInstanceProvider.cs	(revision 14471)
@@ -0,0 +1,185 @@
+﻿#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.IO;
+using System.IO.Compression;
+using System.Linq;
+using System.Reflection;
+using System.Text.RegularExpressions;
+
+namespace HeuristicLab.Problems.Instances.DIMACS {
+  public class GcolInstanceProvider : ProblemInstanceProvider<GCPData> {
+
+    public override string Name {
+      get { return "DIMACS Graph Coloring"; }
+    }
+
+    public override string Description {
+      get { return "Graph Coloring problem instance library"; }
+    }
+
+    public override Uri WebLink {
+      get { return new Uri("https://turing.cs.hbg.psu.edu/txn131/graphcoloring.html"); }
+    }
+
+    public override string ReferencePublication {
+      get {
+        return string.Empty;
+      }
+    }
+
+    protected virtual string FileName { get { return "col"; } }
+
+    public override IEnumerable<IDataDescriptor> GetDataDescriptors() {
+      var instanceArchiveName = GetResourceName(FileName + @"\.zip");
+      if (String.IsNullOrEmpty(instanceArchiveName)) yield break;
+
+      using (var instanceStream = new ZipArchive(GetType().Assembly.GetManifestResourceStream(instanceArchiveName), ZipArchiveMode.Read)) {
+        foreach (var entry in instanceStream.Entries.Select(x => x.Name).OrderBy(x => x)) {
+          yield return new GcolDataDescriptor(Path.GetFileNameWithoutExtension(entry), GetDescription(), entry);
+        }
+      }
+    }
+
+    public override GCPData LoadData(IDataDescriptor id) {
+      var descriptor = (GcolDataDescriptor)id;
+      var instanceArchiveName = GetResourceName(FileName + @"\.zip");
+      using (var instancesZipFile = new ZipArchive(GetType().Assembly.GetManifestResourceStream(instanceArchiveName), ZipArchiveMode.Read)) {
+        var entry = instancesZipFile.GetEntry(descriptor.InstanceIdentifier);
+
+        using (var stream = entry.Open()) {
+          var parser = new Parser();
+          parser.Parse(stream);
+          var instance = Load(parser);
+          instance.Name = id.Name;
+          instance.Description = id.Description;
+          int bestknown;
+          if (bkq.TryGetValue(instance.Name, out bestknown))
+            instance.BestKnownColors = bestknown;
+          return instance;
+        }
+      }
+    }
+
+    public override bool CanImportData {
+      get { return true; }
+    }
+    public override GCPData ImportData(string path) {
+      var parser = new Parser();
+      parser.Parse(path);
+      var instance = Load(parser);
+      instance.Name = Path.GetFileName(path);
+      instance.Description = "Loaded from file \"" + path + "\" on " + DateTime.Now.ToString();
+      return instance;
+    }
+
+    private GCPData Load(Parser parser) {
+      var instance = new GCPData();
+      instance.Nodes = parser.Nodes;
+      var adjacencies = new int[parser.Edges, 2];
+      var i = 0;
+      foreach (var a in parser.AdjacencyList) {
+        adjacencies[i, 0] = a.Item1 - 1;
+        adjacencies[i, 1] = a.Item2 - 1;
+        i++;
+      }
+      instance.Adjacencies = adjacencies;
+      return instance;
+    }
+
+    private string GetDescription() {
+      return "Embedded instance of plugin version " + Assembly.GetExecutingAssembly().GetCustomAttributes(typeof(AssemblyFileVersionAttribute), true).Cast<AssemblyFileVersionAttribute>().First().Version + ".";
+    }
+
+    protected virtual string GetResourceName(string fileName) {
+      return Assembly.GetExecutingAssembly().GetManifestResourceNames()
+              .Where(x => Regex.Match(x, @".*\.Data\." + fileName).Success).SingleOrDefault();
+    }
+
+    private Dictionary<string, int> bkq = new Dictionary<string, int> {
+      { "fpsol2.i.1", 65 },
+      { "fpsol2.i.2", 30 },
+      { "fpsol2.i.3", 30 },
+      { "inithx.i.1", 54 },
+      { "inithx.i.2", 31 },
+      { "inithx.i.3", 31 },
+      { "le450_5a", 5 },
+      { "le450_5b", 5 },
+      { "le450_5c", 5 },
+      { "le450_5d", 5 },
+      { "le450_15a", 15 },
+      { "le450_15b", 15 },
+      { "le450_15c", 15 },
+      { "le450_15d", 15 },
+      { "le450_25a", 25 },
+      { "le450_25b", 25 },
+      { "le450_25c", 25 },
+      { "le450_25d", 25 },
+      { "mulsol.i.1", 49 },
+      { "mulsol.i.2", 31 },
+      { "mulsol.i.3", 31 },
+      { "mulsol.i.4", 31 },
+      { "mulsol.i.5", 31 },
+      { "zeroin.i.1", 49 },
+      { "zeroin.i.2", 30 },
+      { "zeroin.i.3", 30 },
+      { "anna", 11 },
+      { "david", 11 },
+      { "homer", 13 },
+      { "huck", 11 },
+      { "jean", 10 },
+      { "games120", 9 },
+      { "miles250", 8 },
+      { "miles500", 20 },
+      { "miles750", 31 },
+      { "miles1000", 42 },
+      { "miles1500", 73 },
+      { "queen5_5", 5 },
+      { "queen6_6", 7 },
+      { "queen7_7", 7 },
+      { "queen8_8", 9 },
+      { "queen8_12", 12 },
+      { "queen9_9", 10 },
+      { "queen11_11", 11 },
+      { "queen13_13", 13 },
+      { "myciel3", 4 },
+      { "myciel4", 5 },
+      { "myciel5", 6 },
+      { "myciel6", 7 },
+      { "myciel7", 8 },
+      { "mugg88_1", 4 },
+      { "mugg88_25", 4 },
+      { "mugg100_1", 4 },
+      { "mugg100_25", 4 },
+      { "1-Insertions_4", 4 },
+      { "2-Insertions_3", 4 },
+      { "2-Insertions_4", 4 },
+      { "3-Insertions_3", 4 },
+      { "4-Insertions_3", 3 },
+      { "qg.order30", 30 },
+      { "qg.order40", 40 },
+      { "qg.order60", 60 },
+      { "qg.order100", 100 }
+    };
+  }
+}
Index: branches/MemPRAlgorithm/HeuristicLab.Problems.Instances.DIMACS/3.3/HeuristicLab.Problems.Instances.DIMACS-3.3.csproj
===================================================================
--- branches/MemPRAlgorithm/HeuristicLab.Problems.Instances.DIMACS/3.3/HeuristicLab.Problems.Instances.DIMACS-3.3.csproj	(revision 14471)
+++ branches/MemPRAlgorithm/HeuristicLab.Problems.Instances.DIMACS/3.3/HeuristicLab.Problems.Instances.DIMACS-3.3.csproj	(revision 14471)
@@ -0,0 +1,96 @@
+﻿<?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>{9943FF23-8619-459C-B84A-E7FBDCBA04E6}</ProjectGuid>
+    <OutputType>Library</OutputType>
+    <AppDesignerFolder>Properties</AppDesignerFolder>
+    <RootNamespace>HeuristicLab.Problems.Instances.DIMACS</RootNamespace>
+    <AssemblyName>HeuristicLab.Problems.Instances.DIMACS-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.IO.Compression" />
+    <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="GcolDataDescriptor.cs" />
+    <Compile Include="GcolInstanceProvider.cs" />
+    <Compile Include="Parser.cs" />
+    <EmbeddedResource Include="Data\col.zip" />
+    <None Include="Plugin.cs.frame" />
+    <Compile Include="Plugin.cs" />
+    <None Include="Properties\AssemblyInfo.cs.frame" />
+    <Compile Include="Properties\AssemblyInfo.cs" />
+  </ItemGroup>
+  <ItemGroup>
+    <None Include="HeuristicLab.snk" />
+  </ItemGroup>
+  <ItemGroup>
+    <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.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.Instances.DIMACS/3.3/Parser.cs
===================================================================
--- branches/MemPRAlgorithm/HeuristicLab.Problems.Instances.DIMACS/3.3/Parser.cs	(revision 14471)
+++ branches/MemPRAlgorithm/HeuristicLab.Problems.Instances.DIMACS/3.3/Parser.cs	(revision 14471)
@@ -0,0 +1,82 @@
+﻿#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.IO;
+
+namespace HeuristicLab.Problems.Instances.DIMACS {
+  public class Parser {
+    public int Nodes { get; private set; }
+    public int Edges { get; private set; }
+    public ICollection<Tuple<int, int>> AdjacencyList { get { return edges; } }
+    private HashSet<Tuple<int, int>> edges;
+
+    public Parser() {
+      Reset();
+    }
+
+    public void Reset() {
+      Nodes = 0;
+      Edges = 0;
+      edges = new HashSet<Tuple<int, int>>();
+    }
+
+    public void Parse(string file) {
+      using (Stream stream = new FileStream(file, FileMode.Open, FileAccess.Read)) {
+        Parse(stream);
+      }
+    }
+
+    /// <summary>
+    /// Reads from the given stream data which is expected to be in the QAPLIB format.
+    /// </summary>
+    /// <remarks>
+    /// The stream is not closed or disposed. The caller has to take care of that.
+    /// </remarks>
+    /// <param name="stream">The stream to read data from.</param>
+    /// <returns>True if the file was successfully read or false otherwise.</returns>
+    public void Parse(Stream stream) {
+      char[] delim = new char[] { ' ', '\t' };
+      var reader = new StreamReader(stream);
+      var line = reader.ReadLine().Trim();
+      // skip comments
+      while (line.StartsWith("c", StringComparison.InvariantCultureIgnoreCase)) line = reader.ReadLine().Trim();
+
+      // p edge NODES EDGES
+      var split = line.Split(delim, StringSplitOptions.RemoveEmptyEntries);
+      Nodes = int.Parse(split[2]);
+      do {
+        line = reader.ReadLine();
+        if (string.IsNullOrEmpty(line)) break;
+        // e XX YY
+        split = line.Split(delim, StringSplitOptions.RemoveEmptyEntries);
+        var src = int.Parse(split[1]);
+        var tgt = int.Parse(split[2]);
+        Tuple<int, int> e = null;
+        if (src < tgt) e = Tuple.Create(src, tgt);
+        else if (src > tgt) e = Tuple.Create(tgt, src);
+        else continue; // src == tgt
+        if (edges.Add(e)) Edges++;
+      } while (!reader.EndOfStream);
+    }
+  }
+}
Index: branches/MemPRAlgorithm/HeuristicLab.Problems.Instances.DIMACS/3.3/Plugin.cs
===================================================================
--- branches/MemPRAlgorithm/HeuristicLab.Problems.Instances.DIMACS/3.3/Plugin.cs	(revision 14471)
+++ branches/MemPRAlgorithm/HeuristicLab.Problems.Instances.DIMACS/3.3/Plugin.cs	(revision 14471)
@@ -0,0 +1,30 @@
+﻿#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.Instances.DIMACS {
+  [Plugin("HeuristicLab.Problems.Instances.DIMACS", "Adds the DIMACS benchmark instances, e.g. graph coloring.", "3.3.14.14185")]
+  [PluginFile("HeuristicLab.Problems.Instances.DIMACS-3.3.dll", PluginFileType.Assembly)]
+  [PluginDependency("HeuristicLab.Common", "3.3")]
+  [PluginDependency("HeuristicLab.Problems.Instances", "3.3")]
+  public class HeuristicLabProblemsInstancesDIMACSPlugin : PluginBase { }
+}
Index: branches/MemPRAlgorithm/HeuristicLab.Problems.Instances.DIMACS/3.3/Plugin.cs.frame
===================================================================
--- branches/MemPRAlgorithm/HeuristicLab.Problems.Instances.DIMACS/3.3/Plugin.cs.frame	(revision 14471)
+++ branches/MemPRAlgorithm/HeuristicLab.Problems.Instances.DIMACS/3.3/Plugin.cs.frame	(revision 14471)
@@ -0,0 +1,30 @@
+﻿#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.Instances.DIMACS {
+  [Plugin("HeuristicLab.Problems.Instances.DIMACS", "Adds the DIMACS benchmark instances, e.g. graph coloring.", "3.3.14.$WCREV$")]
+  [PluginFile("HeuristicLab.Problems.Instances.DIMACS-3.3.dll", PluginFileType.Assembly)]
+  [PluginDependency("HeuristicLab.Common", "3.3")]
+  [PluginDependency("HeuristicLab.Problems.Instances", "3.3")]
+  public class HeuristicLabProblemsInstancesDIMACSPlugin : PluginBase { }
+}
Index: branches/MemPRAlgorithm/HeuristicLab.Problems.Instances.DIMACS/3.3/Properties/AssemblyInfo.cs
===================================================================
--- branches/MemPRAlgorithm/HeuristicLab.Problems.Instances.DIMACS/3.3/Properties/AssemblyInfo.cs	(revision 14471)
+++ branches/MemPRAlgorithm/HeuristicLab.Problems.Instances.DIMACS/3.3/Properties/AssemblyInfo.cs	(revision 14471)
@@ -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.Instances.DIMACS")]
+[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("9943ff23-8619-459c-b84a-e7fbdcba04e6")]
+
+// 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.14185")]
Index: branches/MemPRAlgorithm/HeuristicLab.Problems.Instances.DIMACS/3.3/Properties/AssemblyInfo.cs.frame
===================================================================
--- branches/MemPRAlgorithm/HeuristicLab.Problems.Instances.DIMACS/3.3/Properties/AssemblyInfo.cs.frame	(revision 14471)
+++ branches/MemPRAlgorithm/HeuristicLab.Problems.Instances.DIMACS/3.3/Properties/AssemblyInfo.cs.frame	(revision 14471)
@@ -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.Instances.DIMACS")]
+[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("9943ff23-8619-459c-b84a-e7fbdcba04e6")]
+
+// 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$")]
Index: branches/MemPRAlgorithm/HeuristicLab.Problems.Instances/3.3/HeuristicLab.Problems.Instances-3.3.csproj
===================================================================
--- branches/MemPRAlgorithm/HeuristicLab.Problems.Instances/3.3/HeuristicLab.Problems.Instances-3.3.csproj	(revision 14470)
+++ branches/MemPRAlgorithm/HeuristicLab.Problems.Instances/3.3/HeuristicLab.Problems.Instances-3.3.csproj	(revision 14471)
@@ -128,4 +128,5 @@
     <Compile Include="Types\DistanceHelper.cs" />
     <Compile Include="Types\OPData.cs" />
+    <Compile Include="Types\GCPData.cs" />
     <Compile Include="Types\VRP\MDCVRPTWData.cs" />
     <Compile Include="Types\VRP\MDCVRPData.cs" />
Index: branches/MemPRAlgorithm/HeuristicLab.Problems.Instances/3.3/Types/GCPData.cs
===================================================================
--- branches/MemPRAlgorithm/HeuristicLab.Problems.Instances/3.3/Types/GCPData.cs	(revision 14471)
+++ branches/MemPRAlgorithm/HeuristicLab.Problems.Instances/3.3/Types/GCPData.cs	(revision 14471)
@@ -0,0 +1,54 @@
+﻿#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
+
+namespace HeuristicLab.Problems.Instances {
+  /// <summary>
+  /// Describes instances of the graph coloring problem (GCP).
+  /// </summary>
+  public class GCPData {
+    /// <summary>
+    /// The name of the instance
+    /// </summary>
+    public string Name { get; set; }
+    /// <summary>
+    /// Optional! The description of the instance
+    /// </summary>
+    public string Description { get; set; }
+
+    /// <summary>
+    /// The number of nodes in the graph
+    /// </summary>
+    public int Nodes { get; set; }
+    /// <summary>
+    /// An Nx2 adjacency list with N = Nodes
+    /// </summary>
+    public int[,] Adjacencies { get; set; }
+
+    /// <summary>
+    /// Optional! An array of length N with N = |Nodes|
+    /// </summary>
+    public int[] BestKnownColoring { get; set; }
+    /// <summary>
+    /// Optional! The quality value of the <see cref="BestKnownColoring"/>
+    /// </summary>
+    public double? BestKnownColors { get; set; }
+  }
+}
