Index: branches/2864_PermutationProblems/HeuristicLab.Problems.Instances.LinearOrdering/3.3/HeuristicLab.Problems.Instances.LinearOrdering-3.3.csproj
===================================================================
--- branches/2864_PermutationProblems/HeuristicLab.Problems.Instances.LinearOrdering/3.3/HeuristicLab.Problems.Instances.LinearOrdering-3.3.csproj	(revision 15541)
+++ branches/2864_PermutationProblems/HeuristicLab.Problems.Instances.LinearOrdering/3.3/HeuristicLab.Problems.Instances.LinearOrdering-3.3.csproj	(revision 15541)
@@ -0,0 +1,106 @@
+﻿<?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>{648F0BF0-6301-448C-816F-DEB1E65EC73F}</ProjectGuid>
+    <OutputType>Library</OutputType>
+    <AppDesignerFolder>Properties</AppDesignerFolder>
+    <RootNamespace>HeuristicLab.Problems.Instances.LinearOrdering</RootNamespace>
+    <AssemblyName>HeuristicLab.Problems.Instances.LinearOrdering-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>..\..\..\..\trunk\sources\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="HeuristicLab.Common-3.3">
+      <HintPath>..\..\..\..\trunk\sources\bin\HeuristicLab.Common-3.3.dll</HintPath>
+    </Reference>
+    <Reference Include="HeuristicLab.PluginInfrastructure-3.3">
+      <HintPath>..\..\..\..\trunk\sources\bin\HeuristicLab.PluginInfrastructure-3.3.dll</HintPath>
+    </Reference>
+    <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="LOPDataDescriptor.cs" />
+    <Compile Include="LOPXLOLIBInstanceProvider.cs" />
+    <Compile Include="LOPSPECInstanceProvider.cs" />
+    <Compile Include="LOPSGBInstanceProvider.cs" />
+    <Compile Include="LOPRANDBInstanceProvider.cs" />
+    <Compile Include="LOPRANDA2InstanceProvider.cs" />
+    <Compile Include="LOPRANDA1InstanceProvider.cs" />
+    <Compile Include="LOPMBInstanceProvider.cs" />
+    <Compile Include="LOPIOInstanceProvider.cs" />
+    <Compile Include="LOPParser.cs" />
+    <Compile Include="Plugin.cs" />
+    <Compile Include="Properties\AssemblyInfo.cs" />
+  </ItemGroup>
+  <ItemGroup>
+    <EmbeddedResource Include="Data\IO.zip" />
+    <EmbeddedResource Include="Data\MB.zip" />
+    <EmbeddedResource Include="Data\RANDA1.zip" />
+    <EmbeddedResource Include="Data\RANDA2.zip" />
+    <EmbeddedResource Include="Data\RANDB.zip" />
+    <EmbeddedResource Include="Data\SGB.zip" />
+    <EmbeddedResource Include="Data\SPEC.zip" />
+    <EmbeddedResource Include="Data\XLOLIB.zip" />
+    <None Include="HeuristicLab.snk" />
+    <None Include="Plugin.cs.frame" />
+    <None Include="Properties\AssemblyInfo.cs.frame" />
+  </ItemGroup>
+  <ItemGroup>
+    <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>
+    </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/2864_PermutationProblems/HeuristicLab.Problems.Instances.LinearOrdering/3.3/LOPDataDescriptor.cs
===================================================================
--- branches/2864_PermutationProblems/HeuristicLab.Problems.Instances.LinearOrdering/3.3/LOPDataDescriptor.cs	(revision 15541)
+++ branches/2864_PermutationProblems/HeuristicLab.Problems.Instances.LinearOrdering/3.3/LOPDataDescriptor.cs	(revision 15541)
@@ -0,0 +1,42 @@
+﻿#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.Problems.Instances;
+
+namespace HeuristicLab.Problems.Instances.LinearOrdering
+{
+    internal class LOPDataDescriptor : IDataDescriptor
+    {
+        public string Name { get; internal set; }
+        public string Description { get; internal set; }
+
+        internal string InstanceIdentifier { get; set; }
+        internal string SolutionIdentifier { get; set; }
+
+        internal LOPDataDescriptor(string name, string description, string instanceIdentifier, string solutionIdentifier)
+        {
+            this.Name = name;
+            this.Description = description;
+            this.InstanceIdentifier = instanceIdentifier;
+            this.SolutionIdentifier = solutionIdentifier;
+        }
+    }
+}
Index: branches/2864_PermutationProblems/HeuristicLab.Problems.Instances.LinearOrdering/3.3/LOPIOInstanceProvider.cs
===================================================================
--- branches/2864_PermutationProblems/HeuristicLab.Problems.Instances.LinearOrdering/3.3/LOPIOInstanceProvider.cs	(revision 15541)
+++ branches/2864_PermutationProblems/HeuristicLab.Problems.Instances.LinearOrdering/3.3/LOPIOInstanceProvider.cs	(revision 15541)
@@ -0,0 +1,123 @@
+﻿#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.Problems.Instances.Types;
+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.LinearOrdering
+{
+    public class LOPIOInstanceProvider : ProblemInstanceProvider<LOPData>
+    {
+
+        public override string Name {
+            get { return "IO"; }
+        }
+
+        public override string Description {
+            get { return "Linear Ordering Problems IO test instances"; }
+        }
+
+        public override Uri WebLink {
+            get { return new Uri("http://www.optsicom.es/lolib/lop/IO.zip"); }
+        }
+
+        public override string ReferencePublication {
+            get { return String.Empty; }
+        }
+
+        public override IEnumerable<IDataDescriptor> GetDataDescriptors()
+        {
+            var instanceArchiveName = GetResourceName("IO.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 LOPDataDescriptor(Path.GetFileNameWithoutExtension(entry), GetDescription(), entry, null);
+                }
+            }
+        }
+
+        public override LOPData LoadData(IDataDescriptor id)
+        {
+            var descriptor = (LOPDataDescriptor)id;
+            var instanceArchiveName = GetResourceName("IO.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 LOPParser();
+                    parser.Parse(stream);
+                    return Load(parser);
+                }
+            }
+        }
+
+        public override bool CanImportData {
+            get { return true; }
+        }
+
+        public override LOPData ImportData(string path)
+        {
+            var parser = new LOPParser();
+            parser.Parse(path);
+            return Load(parser);
+        }
+
+        private LOPData Load(LOPParser parser)
+        {
+            var instance = new LOPData
+            {
+                Name = parser.Name,
+                Description = parser.Description,
+                Dimension = parser.Dimension,
+                Matrix = parser.Matrix,
+                BestKnownPermutation = parser.BestKnownPermutation,
+                BestKnownQuality = parser.BestKnownQuality
+            };
+            return instance;
+        }
+
+        public override bool CanExportData {
+            get { return false; }
+        }
+
+        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()
+              .SingleOrDefault(x => Regex.Match(x, @".*\.Data\." + fileName).Success);
+        }
+    }
+}
Index: branches/2864_PermutationProblems/HeuristicLab.Problems.Instances.LinearOrdering/3.3/LOPMBInstanceProvider.cs
===================================================================
--- branches/2864_PermutationProblems/HeuristicLab.Problems.Instances.LinearOrdering/3.3/LOPMBInstanceProvider.cs	(revision 15541)
+++ branches/2864_PermutationProblems/HeuristicLab.Problems.Instances.LinearOrdering/3.3/LOPMBInstanceProvider.cs	(revision 15541)
@@ -0,0 +1,122 @@
+﻿#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.Problems.Instances.Types;
+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.LinearOrdering
+{
+    public class LOPMBInstanceProvider : ProblemInstanceProvider<LOPData>
+    {
+
+        public override string Name {
+            get { return "MB"; }
+        }
+
+        public override string Description {
+            get { return "Linear Ordering Problems MB test instances"; }
+        }
+
+        public override Uri WebLink {
+            get { return new Uri("http://www.optsicom.es/lolib/lop/MB.zip"); }
+        }
+
+        public override string ReferencePublication {
+            get { return String.Empty; }
+        }
+
+        public override IEnumerable<IDataDescriptor> GetDataDescriptors()
+        {
+            var instanceArchiveName = GetResourceName("MB.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 LOPDataDescriptor(Path.GetFileNameWithoutExtension(entry), GetDescription(), entry, null);
+                }
+            }
+        }
+
+        public override LOPData LoadData(IDataDescriptor id)
+        {
+            var descriptor = (LOPDataDescriptor)id;
+            var instanceArchiveName = GetResourceName("MB.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 LOPParser();
+                    parser.Parse(stream);
+                    return Load(parser);
+                }
+            }
+        }
+
+        public override bool CanImportData {
+            get { return true; }
+        }
+        public override LOPData ImportData(string path)
+        {
+            var parser = new LOPParser();
+            parser.Parse(path);
+            return Load(parser);
+        }
+
+        private LOPData Load(LOPParser parser)
+        {
+            var instance = new LOPData
+            {
+                Name = parser.Name,
+                Description = parser.Description,
+                Dimension = parser.Dimension,
+                Matrix = parser.Matrix,
+                BestKnownPermutation = parser.BestKnownPermutation,
+                BestKnownQuality = parser.BestKnownQuality
+            };
+            return instance;
+        }
+
+        public override bool CanExportData {
+            get { return false; }
+        }
+        
+        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()
+              .SingleOrDefault(x => Regex.Match(x, @".*\.Data\." + fileName).Success);
+        }
+    }
+}
Index: branches/2864_PermutationProblems/HeuristicLab.Problems.Instances.LinearOrdering/3.3/LOPParser.cs
===================================================================
--- branches/2864_PermutationProblems/HeuristicLab.Problems.Instances.LinearOrdering/3.3/LOPParser.cs	(revision 15541)
+++ branches/2864_PermutationProblems/HeuristicLab.Problems.Instances.LinearOrdering/3.3/LOPParser.cs	(revision 15541)
@@ -0,0 +1,128 @@
+﻿#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.Globalization;
+using System.IO;
+using System.Linq;
+using System.Text;
+
+namespace HeuristicLab.Problems.Instances.LinearOrdering
+{
+    public class LOPParser
+    {
+        public string Name { get; set; }
+        public string Description { get; set; }
+        public int Dimension { get; set; }
+        public double[,] Matrix { get; set; }
+        public int[] BestKnownPermutation { get; set; }
+        public double? BestKnownQuality { get; set; }
+
+        public LOPParser()
+        {
+            Reset();
+        }
+
+        public void Reset()
+        {
+            Name = Description = String.Empty;
+            Dimension = 0;
+            BestKnownQuality = 0;
+            Matrix = null;
+            BestKnownPermutation = null;
+        }
+
+        public void Parse(string file)
+        {
+            using (Stream stream = new FileStream(file, FileMode.Open, FileAccess.Read))
+            {
+                Parse(stream);
+            }
+        }
+
+        public void Export(string file)
+        {
+            using (Stream stream = new FileStream(file, FileMode.Create, FileAccess.Write))
+            {
+                Export(stream);
+            }
+        }
+
+        public void Parse(Stream stream)
+        {
+            using (var reader = new StreamReader(stream, Encoding.UTF8, true, 4092, true))
+            {
+                Name = reader.ReadLine().Trim();
+                Description = reader.ReadLine().Trim();
+                BestKnownQuality = double.Parse(reader.ReadLine().Trim());
+                var delim = new char[] { ' ', '\t' };
+
+                Dimension = int.Parse(reader.ReadLine().Trim());
+                Matrix = new double[Dimension, Dimension];
+
+                for (int k = 0; k < Dimension; k++)
+                {
+                    if (reader.EndOfStream) throw new InvalidDataException("Unexpected End of Stream.");
+                    var valLine = reader.ReadLine();
+                    while (String.IsNullOrWhiteSpace(valLine)) valLine = reader.ReadLine();
+                    var vals = valLine.Split(delim, StringSplitOptions.RemoveEmptyEntries);
+
+
+                    for (int i = 0; i < Dimension; i++)
+                    {
+                        Matrix[k, i] = double.Parse(vals[i], CultureInfo.InvariantCulture.NumberFormat);
+                    }
+                }
+
+                while (!reader.EndOfStream)
+                {
+                    var vals = reader.ReadLine().Split(delim, StringSplitOptions.RemoveEmptyEntries);
+                    if (vals.Count() == Dimension) { BestKnownPermutation = vals.Select(val => Int32.Parse(val)).ToArray(); }
+                }
+            }
+        }
+
+        public void Export(Stream stream)
+        {
+            using (var writer = new StreamWriter(stream, Encoding.UTF8, 4092, true))
+            {
+                writer.WriteLine(Name);
+                writer.WriteLine(Description);
+                writer.WriteLine(BestKnownQuality);
+                writer.WriteLine(Dimension);
+
+                for (int k = 0; k < Dimension; k++)
+                {
+                    for (int i = 0; i < Dimension; i++)
+                    {
+                        writer.Write(Matrix[k, i] + '\t');
+                    }
+                    writer.WriteLine();
+                }
+
+                if (BestKnownPermutation != null) { 
+                    writer.WriteLine(BestKnownPermutation);
+                }
+                writer.Flush();
+            }
+        }
+    }
+}
Index: branches/2864_PermutationProblems/HeuristicLab.Problems.Instances.LinearOrdering/3.3/LOPRANDA1InstanceProvider.cs
===================================================================
--- branches/2864_PermutationProblems/HeuristicLab.Problems.Instances.LinearOrdering/3.3/LOPRANDA1InstanceProvider.cs	(revision 15541)
+++ branches/2864_PermutationProblems/HeuristicLab.Problems.Instances.LinearOrdering/3.3/LOPRANDA1InstanceProvider.cs	(revision 15541)
@@ -0,0 +1,122 @@
+﻿#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.Problems.Instances.Types;
+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.LinearOrdering
+{
+    public class LOPRANDA1InstanceProvider : ProblemInstanceProvider<LOPData>
+    {
+
+        public override string Name {
+            get { return "RANDA1"; }
+        }
+
+        public override string Description {
+            get { return "Linear Ordering Problems RANDA1 test instances"; }
+        }
+
+        public override Uri WebLink {
+            get { return new Uri("http://www.optsicom.es/lolib/lop/RANDA1.zip"); }
+        }
+
+        public override string ReferencePublication {
+            get { return String.Empty; }
+        }
+
+        public override IEnumerable<IDataDescriptor> GetDataDescriptors()
+        {
+            var instanceArchiveName = GetResourceName("RANDA1.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 LOPDataDescriptor(Path.GetFileNameWithoutExtension(entry), GetDescription(), entry, null);
+                }
+            }
+        }
+
+        public override LOPData LoadData(IDataDescriptor id)
+        {
+            var descriptor = (LOPDataDescriptor)id;
+            var instanceArchiveName = GetResourceName("RANDA1.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 LOPParser();
+                    parser.Parse(stream);
+                    return Load(parser);
+                }
+            }
+        }
+
+        public override bool CanImportData {
+            get { return true; }
+        }
+        public override LOPData ImportData(string path)
+        {
+            var parser = new LOPParser();
+            parser.Parse(path);
+            return Load(parser);
+        }
+
+        private LOPData Load(LOPParser parser)
+        {
+            var instance = new LOPData
+            {
+                Name = parser.Name,
+                Description = parser.Description,
+                Dimension = parser.Dimension,
+                Matrix = parser.Matrix,
+                BestKnownPermutation = parser.BestKnownPermutation,
+                BestKnownQuality = parser.BestKnownQuality
+            };
+            return instance;
+        }
+
+        public override bool CanExportData {
+            get { return false; }
+        }
+
+        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()
+              .SingleOrDefault(x => Regex.Match(x, @".*\.Data\." + fileName).Success);
+        }
+    }
+}
Index: branches/2864_PermutationProblems/HeuristicLab.Problems.Instances.LinearOrdering/3.3/LOPRANDA2InstanceProvider.cs
===================================================================
--- branches/2864_PermutationProblems/HeuristicLab.Problems.Instances.LinearOrdering/3.3/LOPRANDA2InstanceProvider.cs	(revision 15541)
+++ branches/2864_PermutationProblems/HeuristicLab.Problems.Instances.LinearOrdering/3.3/LOPRANDA2InstanceProvider.cs	(revision 15541)
@@ -0,0 +1,122 @@
+﻿#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.Problems.Instances.Types;
+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.LinearOrdering
+{
+    public class LOPRANDA2InstanceProvider : ProblemInstanceProvider<LOPData>
+    {
+
+        public override string Name {
+            get { return "RANDA2"; }
+        }
+
+        public override string Description {
+            get { return "Linear Ordering Problems RANDA2 test instances"; }
+        }
+
+        public override Uri WebLink {
+            get { return new Uri("http://www.optsicom.es/lolib/lop/RANDA2.zip"); }
+        }
+
+        public override string ReferencePublication {
+            get { return String.Empty; }
+        }
+
+        public override IEnumerable<IDataDescriptor> GetDataDescriptors()
+        {
+            var instanceArchiveName = GetResourceName("RANDA2.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 LOPDataDescriptor(Path.GetFileNameWithoutExtension(entry), GetDescription(), entry, null);
+                }
+            }
+        }
+
+        public override LOPData LoadData(IDataDescriptor id)
+        {
+            var descriptor = (LOPDataDescriptor)id;
+            var instanceArchiveName = GetResourceName("RANDA2.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 LOPParser();
+                    parser.Parse(stream);
+                    return Load(parser);
+                }
+            }
+        }
+
+        public override bool CanImportData {
+            get { return true; }
+        }
+        public override LOPData ImportData(string path)
+        {
+            var parser = new LOPParser();
+            parser.Parse(path);
+            return Load(parser);
+        }
+
+        private LOPData Load(LOPParser parser)
+        {
+            var instance = new LOPData
+            {
+                Name = parser.Name,
+                Description = parser.Description,
+                Dimension = parser.Dimension,
+                Matrix = parser.Matrix,
+                BestKnownPermutation = parser.BestKnownPermutation,
+                BestKnownQuality = parser.BestKnownQuality
+            };
+            return instance;
+        }
+
+        public override bool CanExportData {
+            get { return false; }
+        }
+        
+        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()
+              .SingleOrDefault(x => Regex.Match(x, @".*\.Data\." + fileName).Success);
+        }
+    }
+}
Index: branches/2864_PermutationProblems/HeuristicLab.Problems.Instances.LinearOrdering/3.3/LOPRANDBInstanceProvider.cs
===================================================================
--- branches/2864_PermutationProblems/HeuristicLab.Problems.Instances.LinearOrdering/3.3/LOPRANDBInstanceProvider.cs	(revision 15541)
+++ branches/2864_PermutationProblems/HeuristicLab.Problems.Instances.LinearOrdering/3.3/LOPRANDBInstanceProvider.cs	(revision 15541)
@@ -0,0 +1,122 @@
+﻿#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.Problems.Instances.Types;
+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.LinearOrdering
+{
+    public class LOPRANDBInstanceProvider : ProblemInstanceProvider<LOPData>
+    {
+
+        public override string Name {
+            get { return "RANDB"; }
+        }
+
+        public override string Description {
+            get { return "Linear Ordering Problems RANDB test instances"; }
+        }
+
+        public override Uri WebLink {
+            get { return new Uri("http://www.optsicom.es/lolib/lop/RANDB.zip"); }
+        }
+
+        public override string ReferencePublication {
+            get { return String.Empty; }
+        }
+
+        public override IEnumerable<IDataDescriptor> GetDataDescriptors()
+        {
+            var instanceArchiveName = GetResourceName("RANDB.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 LOPDataDescriptor(Path.GetFileNameWithoutExtension(entry), GetDescription(), entry, null);
+                }
+            }
+        }
+
+        public override LOPData LoadData(IDataDescriptor id)
+        {
+            var descriptor = (LOPDataDescriptor)id;
+            var instanceArchiveName = GetResourceName("RANDB.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 LOPParser();
+                    parser.Parse(stream);
+                    return Load(parser);
+                }
+            }
+        }
+
+        public override bool CanImportData {
+            get { return true; }
+        }
+        public override LOPData ImportData(string path)
+        {
+            var parser = new LOPParser();
+            parser.Parse(path);
+            return Load(parser);
+        }
+
+        private LOPData Load(LOPParser parser)
+        {
+            var instance = new LOPData
+            {
+                Name = parser.Name,
+                Description = parser.Description,
+                Dimension = parser.Dimension,
+                Matrix = parser.Matrix,
+                BestKnownPermutation = parser.BestKnownPermutation,
+                BestKnownQuality = parser.BestKnownQuality
+            };
+            return instance;
+        }
+
+        public override bool CanExportData {
+            get { return false; }
+        }
+
+        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()
+              .SingleOrDefault(x => Regex.Match(x, @".*\.Data\." + fileName).Success);
+        }
+    }
+}
Index: branches/2864_PermutationProblems/HeuristicLab.Problems.Instances.LinearOrdering/3.3/LOPSGBInstanceProvider.cs
===================================================================
--- branches/2864_PermutationProblems/HeuristicLab.Problems.Instances.LinearOrdering/3.3/LOPSGBInstanceProvider.cs	(revision 15541)
+++ branches/2864_PermutationProblems/HeuristicLab.Problems.Instances.LinearOrdering/3.3/LOPSGBInstanceProvider.cs	(revision 15541)
@@ -0,0 +1,122 @@
+﻿#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.Problems.Instances.Types;
+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.LinearOrdering
+{
+    public class LOPSGBInstanceProvider : ProblemInstanceProvider<LOPData>
+    {
+
+        public override string Name {
+            get { return "SGB"; }
+        }
+
+        public override string Description {
+            get { return "Linear Ordering Problems SGB test instances"; }
+        }
+
+        public override Uri WebLink {
+            get { return new Uri("http://www.optsicom.es/lolib/lop/SGB.zip"); }
+        }
+
+        public override string ReferencePublication {
+            get { return String.Empty; }
+        }
+
+        public override IEnumerable<IDataDescriptor> GetDataDescriptors()
+        {
+            var instanceArchiveName = GetResourceName("SGB.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 LOPDataDescriptor(Path.GetFileNameWithoutExtension(entry), GetDescription(), entry, null);
+                }
+            }
+        }
+
+        public override LOPData LoadData(IDataDescriptor id)
+        {
+            var descriptor = (LOPDataDescriptor)id;
+            var instanceArchiveName = GetResourceName("SGB.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 LOPParser();
+                    parser.Parse(stream);
+                    return Load(parser);
+                }
+            }
+        }
+
+        public override bool CanImportData {
+            get { return true; }
+        }
+        public override LOPData ImportData(string path)
+        {
+            var parser = new LOPParser();
+            parser.Parse(path);
+            return Load(parser);
+        }
+
+        private LOPData Load(LOPParser parser)
+        {
+            var instance = new LOPData
+            {
+                Name = parser.Name,
+                Description = parser.Description,
+                Dimension = parser.Dimension,
+                Matrix = parser.Matrix,
+                BestKnownPermutation = parser.BestKnownPermutation,
+                BestKnownQuality = parser.BestKnownQuality
+            };
+            return instance;
+        }
+
+        public override bool CanExportData {
+            get { return false; }
+        }
+        
+        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()
+              .SingleOrDefault(x => Regex.Match(x, @".*\.Data\." + fileName).Success);
+        }
+    }
+}
Index: branches/2864_PermutationProblems/HeuristicLab.Problems.Instances.LinearOrdering/3.3/LOPSPECInstanceProvider.cs
===================================================================
--- branches/2864_PermutationProblems/HeuristicLab.Problems.Instances.LinearOrdering/3.3/LOPSPECInstanceProvider.cs	(revision 15541)
+++ branches/2864_PermutationProblems/HeuristicLab.Problems.Instances.LinearOrdering/3.3/LOPSPECInstanceProvider.cs	(revision 15541)
@@ -0,0 +1,122 @@
+﻿#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.Problems.Instances.Types;
+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.LinearOrdering
+{
+    public class LOPSPECInstanceProvider : ProblemInstanceProvider<LOPData>
+    {
+
+        public override string Name {
+            get { return "SPEC"; }
+        }
+
+        public override string Description {
+            get { return "Linear Ordering Problems SPEC test instances"; }
+        }
+
+        public override Uri WebLink {
+            get { return new Uri("http://www.optsicom.es/lolib/lop/SPEC.zip"); }
+        }
+
+        public override string ReferencePublication {
+            get { return String.Empty; }
+        }
+
+        public override IEnumerable<IDataDescriptor> GetDataDescriptors()
+        {
+            var instanceArchiveName = GetResourceName("SPEC.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 LOPDataDescriptor(Path.GetFileNameWithoutExtension(entry), GetDescription(), entry, null);
+                }
+            }
+        }
+
+        public override LOPData LoadData(IDataDescriptor id)
+        {
+            var descriptor = (LOPDataDescriptor)id;
+            var instanceArchiveName = GetResourceName("SPEC.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 LOPParser();
+                    parser.Parse(stream);
+                    return Load(parser);
+                }
+            }
+        }
+
+        public override bool CanImportData {
+            get { return true; }
+        }
+        public override LOPData ImportData(string path)
+        {
+            var parser = new LOPParser();
+            parser.Parse(path);
+            return Load(parser);
+        }
+
+        private LOPData Load(LOPParser parser)
+        {
+            var instance = new LOPData
+            {
+                Name = parser.Name,
+                Description = parser.Description,
+                Dimension = parser.Dimension,
+                Matrix = parser.Matrix,
+                BestKnownPermutation = parser.BestKnownPermutation,
+                BestKnownQuality = parser.BestKnownQuality
+            };
+            return instance;
+        }
+
+        public override bool CanExportData {
+            get { return false; }
+        }
+        
+        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()
+              .SingleOrDefault(x => Regex.Match(x, @".*\.Data\." + fileName).Success);
+        }
+    }
+}
Index: branches/2864_PermutationProblems/HeuristicLab.Problems.Instances.LinearOrdering/3.3/LOPXLOLIBInstanceProvider.cs
===================================================================
--- branches/2864_PermutationProblems/HeuristicLab.Problems.Instances.LinearOrdering/3.3/LOPXLOLIBInstanceProvider.cs	(revision 15541)
+++ branches/2864_PermutationProblems/HeuristicLab.Problems.Instances.LinearOrdering/3.3/LOPXLOLIBInstanceProvider.cs	(revision 15541)
@@ -0,0 +1,122 @@
+﻿#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.Problems.Instances.Types;
+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.LinearOrdering
+{
+    public class LOPXLOLIBInstanceProvider : ProblemInstanceProvider<LOPData>
+    {
+
+        public override string Name {
+            get { return "XLOLIB"; }
+        }
+
+        public override string Description {
+            get { return "Linear Ordering Problems XLOLIB test instances"; }
+        }
+
+        public override Uri WebLink {
+            get { return new Uri("http://www.optsicom.es/lolib/lop/XLOLIB.zip"); }
+        }
+
+        public override string ReferencePublication {
+            get { return String.Empty; }
+        }
+
+        public override IEnumerable<IDataDescriptor> GetDataDescriptors()
+        {
+            var instanceArchiveName = GetResourceName("XLOLIB.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 LOPDataDescriptor(Path.GetFileNameWithoutExtension(entry), GetDescription(), entry, null);
+                }
+            }
+        }
+
+        public override LOPData LoadData(IDataDescriptor id)
+        {
+            var descriptor = (LOPDataDescriptor)id;
+            var instanceArchiveName = GetResourceName("XLOLIB.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 LOPParser();
+                    parser.Parse(stream);
+                    return Load(parser);
+                }
+            }
+        }
+
+        public override bool CanImportData {
+            get { return true; }
+        }
+        public override LOPData ImportData(string path)
+        {
+            var parser = new LOPParser();
+            parser.Parse(path);
+            return Load(parser);
+        }
+
+        private LOPData Load(LOPParser parser)
+        {
+            var instance = new LOPData
+            {
+                Name = parser.Name,
+                Description = parser.Description,
+                Dimension = parser.Dimension,
+                Matrix = parser.Matrix,
+                BestKnownPermutation = parser.BestKnownPermutation,
+                BestKnownQuality = parser.BestKnownQuality
+            };
+            return instance;
+        }
+
+        public override bool CanExportData {
+            get { return false; }
+        }
+        
+        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()
+              .SingleOrDefault(x => Regex.Match(x, @".*\.Data\." + fileName).Success);
+        }
+    }
+}
Index: branches/2864_PermutationProblems/HeuristicLab.Problems.Instances.LinearOrdering/3.3/Plugin.cs
===================================================================
--- branches/2864_PermutationProblems/HeuristicLab.Problems.Instances.LinearOrdering/3.3/Plugin.cs	(revision 15541)
+++ branches/2864_PermutationProblems/HeuristicLab.Problems.Instances.LinearOrdering/3.3/Plugin.cs	(revision 15541)
@@ -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.LinearOrdering {
+  [Plugin("HeuristicLab.Problems.Instances.LinearOrdering", "3.3.14.14965")]
+  [PluginFile("HeuristicLab.Problems.Instances.LinearOrdering-3.3.dll", PluginFileType.Assembly)]
+  [PluginDependency("HeuristicLab.Problems.Instances", "3.3")]
+  public class HeuristicLabProblemsInstancesLinearOrderingPlugin : PluginBase {
+  }
+}
Index: branches/2864_PermutationProblems/HeuristicLab.Problems.Instances.LinearOrdering/3.3/Plugin.cs.frame
===================================================================
--- branches/2864_PermutationProblems/HeuristicLab.Problems.Instances.LinearOrdering/3.3/Plugin.cs.frame	(revision 15541)
+++ branches/2864_PermutationProblems/HeuristicLab.Problems.Instances.LinearOrdering/3.3/Plugin.cs.frame	(revision 15541)
@@ -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.LinearOrdering {
+  [Plugin("HeuristicLab.Problems.Instances.LinearOrdering", "3.3.14.14965")]
+  [PluginFile("HeuristicLab.Problems.Instances.LinearOrdering-3.3.dll", PluginFileType.Assembly)]
+  [PluginDependency("HeuristicLab.Problems.Instances", "3.3")]
+  public class HeuristicLabProblemsInstancesLinearOrderingPlugin : PluginBase {
+  }
+}
Index: branches/2864_PermutationProblems/HeuristicLab.Problems.Instances.LinearOrdering/3.3/Properties/AssemblyInfo.cs
===================================================================
--- branches/2864_PermutationProblems/HeuristicLab.Problems.Instances.LinearOrdering/3.3/Properties/AssemblyInfo.cs	(revision 15541)
+++ branches/2864_PermutationProblems/HeuristicLab.Problems.Instances.LinearOrdering/3.3/Properties/AssemblyInfo.cs	(revision 15541)
@@ -0,0 +1,57 @@
+﻿#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.CompilerServices;
+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.LinearOrdering-3.3")]
+[assembly: AssemblyDescription("")]
+[assembly: AssemblyConfiguration("")]
+[assembly: AssemblyCompany("")]
+[assembly: AssemblyProduct("HeuristicLab.Problems.Instances.LinearOrdering-3.3")]
+[assembly: AssemblyCopyright("Copyright ©  2017")]
+[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("9412aa5f-d663-4af4-b58b-d90fabb343bf")]
+
+// 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.0")]
Index: branches/2864_PermutationProblems/HeuristicLab.Problems.Instances.LinearOrdering/3.3/Properties/AssemblyInfo.cs.frame
===================================================================
--- branches/2864_PermutationProblems/HeuristicLab.Problems.Instances.LinearOrdering/3.3/Properties/AssemblyInfo.cs.frame	(revision 15541)
+++ branches/2864_PermutationProblems/HeuristicLab.Problems.Instances.LinearOrdering/3.3/Properties/AssemblyInfo.cs.frame	(revision 15541)
@@ -0,0 +1,57 @@
+﻿#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.CompilerServices;
+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.LinearOrdering-3.3")]
+[assembly: AssemblyDescription("")]
+[assembly: AssemblyConfiguration("")]
+[assembly: AssemblyCompany("")]
+[assembly: AssemblyProduct("HeuristicLab.Problems.Instances.LinearOrdering-3.3")]
+[assembly: AssemblyCopyright("Copyright ©  2017")]
+[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("9412aa5f-d663-4af4-b58b-d90fabb343bf")]
+
+// 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/2864_PermutationProblems/HeuristicLab.Problems.Instances.PFSP/3.3/FSSPTAILIBInstanceProvider.cs
===================================================================
--- branches/2864_PermutationProblems/HeuristicLab.Problems.Instances.PFSP/3.3/FSSPTAILIBInstanceProvider.cs	(revision 15540)
+++ branches/2864_PermutationProblems/HeuristicLab.Problems.Instances.PFSP/3.3/FSSPTAILIBInstanceProvider.cs	(revision 15541)
@@ -40,5 +40,5 @@
         public override string Description
         {
-            get { return "Permutation Flowshop scheduling problems as defined by Taillard."; }
+            get { return "Permutation Flowshop Scheduling Problems (PFSP) as defined by Taillard."; }
         }
 
@@ -112,20 +112,7 @@
         public override bool CanExportData
         {
-            get { return true; }
+            get { return false; }
         }
-
-        public override void ExportData(FSSPData instance, string path)
-        {
-            var parser = new FSSPTAILIBParser
-            {
-                Name = instance.Name,
-                Description = instance.Description,
-                Jobs = instance.Jobs,
-                Machines = instance.Machines,
-                ProcessingTimes = instance.ProcessingTimes,
-            };
-            parser.Export(path);
-        }
-
+        
         private string GetDescription()
         {
Index: branches/2864_PermutationProblems/HeuristicLab.Problems.Instances.PFSP/3.3/FSSPTAILIBParser.cs
===================================================================
--- branches/2864_PermutationProblems/HeuristicLab.Problems.Instances.PFSP/3.3/FSSPTAILIBParser.cs	(revision 15540)
+++ branches/2864_PermutationProblems/HeuristicLab.Problems.Instances.PFSP/3.3/FSSPTAILIBParser.cs	(revision 15541)
@@ -67,12 +67,5 @@
             }
         }
-
-        /// <summary>
-        /// Reads from the given stream data which is expected to be in the JSSP ORLIB 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>
+      
         public void Parse(Stream stream)
         {
@@ -111,32 +104,29 @@
             }
         }
-
-        /// <summary>
-        /// Writes to the given stream data which is expected to be in the JSSP ORLIB 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 write data to.</param>
+    
         public void Export(Stream stream)
         {
-            //TODO: complete Export, seems as if it is just a dummy (copy-paste)-implementation
             using (var writer = new StreamWriter(stream, Encoding.UTF8, 4092, true))
             {
                 writer.WriteLine(Name);
                 writer.WriteLine(Description);
-                writer.WriteLine(Jobs.ToString(CultureInfo.InvariantCulture.NumberFormat) + " " + Machines.ToString(CultureInfo.InvariantCulture.NumberFormat));
-                for (int i = 0; i < Machines; i++)
+                writer.WriteLine(Jobs + '\t' + Machines);
+                writer.WriteLine(BestKnownQuality);
+
+                for (int k = 0; k < Machines; k++)
                 {
-                    for (int j = 0; j < Jobs; j++)
+                    for (int i = 0; i < Jobs; i++)
                     {
-                        writer.Write(ProcessingTimes[i, j] + " ");
+                        writer.Write(ProcessingTimes[k, i] + "\t");
                     }
                     writer.WriteLine();
+                }
+
+                if (BestKnownSchedule != null) {
+                    writer.WriteLine(BestKnownSchedule);
                 }
                 writer.Flush();
             }
         }
-
     }
 }
Index: branches/2864_PermutationProblems/HeuristicLab.Problems.Instances.PFSP/3.3/HeuristicLab.Problems.Instances.PFSP-3.3.csproj
===================================================================
--- branches/2864_PermutationProblems/HeuristicLab.Problems.Instances.PFSP/3.3/HeuristicLab.Problems.Instances.PFSP-3.3.csproj	(revision 15540)
+++ branches/2864_PermutationProblems/HeuristicLab.Problems.Instances.PFSP/3.3/HeuristicLab.Problems.Instances.PFSP-3.3.csproj	(revision 15541)
@@ -18,5 +18,5 @@
     <DebugType>full</DebugType>
     <Optimize>false</Optimize>
-    <OutputPath>..\..\bin\</OutputPath>
+    <OutputPath>..\..\..\..\trunk\sources\bin\</OutputPath>
     <DefineConstants>DEBUG;TRACE</DefineConstants>
     <ErrorReport>prompt</ErrorReport>
@@ -38,4 +38,10 @@
   </PropertyGroup>
   <ItemGroup>
+    <Reference Include="HeuristicLab.Common-3.3">
+      <HintPath>..\..\..\..\trunk\sources\bin\HeuristicLab.Common-3.3.dll</HintPath>
+    </Reference>
+    <Reference Include="HeuristicLab.PluginInfrastructure-3.3">
+      <HintPath>..\..\..\..\trunk\sources\bin\HeuristicLab.PluginInfrastructure-3.3.dll</HintPath>
+    </Reference>
     <Reference Include="System" />
     <Reference Include="System.Core" />
@@ -62,14 +68,6 @@
   </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>
-    </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>
-    </ProjectReference>
     <ProjectReference Include="..\..\HeuristicLab.Problems.Instances\3.3\HeuristicLab.Problems.Instances-3.3.csproj">
-      <Project>{3540E29E-4793-49E7-8EE2-FEA7F61C3994}</Project>
+      <Project>{3540e29e-4793-49e7-8ee2-fea7f61c3994}</Project>
       <Name>HeuristicLab.Problems.Instances-3.3</Name>
     </ProjectReference>
Index: branches/2864_PermutationProblems/HeuristicLab.Problems.Instances.PFSP/3.3/Properties/AssemblyInfo.cs
===================================================================
--- branches/2864_PermutationProblems/HeuristicLab.Problems.Instances.PFSP/3.3/Properties/AssemblyInfo.cs	(revision 15540)
+++ branches/2864_PermutationProblems/HeuristicLab.Problems.Instances.PFSP/3.3/Properties/AssemblyInfo.cs	(revision 15541)
@@ -1,3 +1,24 @@
-﻿using System.Reflection;
+﻿#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.CompilerServices;
 using System.Runtime.InteropServices;
@@ -34,3 +55,3 @@
 // [assembly: AssemblyVersion("1.0.*")]
 [assembly: AssemblyVersion("3.3.0.0")]
-[assembly: AssemblyFileVersion("3.3.14.14965")]
+[assembly: AssemblyFileVersion("3.3.14.15521")]
Index: branches/2864_PermutationProblems/HeuristicLab.Problems.Instances/3.3/HeuristicLab.Problems.Instances-3.3.csproj
===================================================================
--- branches/2864_PermutationProblems/HeuristicLab.Problems.Instances/3.3/HeuristicLab.Problems.Instances-3.3.csproj	(revision 15541)
+++ branches/2864_PermutationProblems/HeuristicLab.Problems.Instances/3.3/HeuristicLab.Problems.Instances-3.3.csproj	(revision 15541)
@@ -0,0 +1,184 @@
+﻿<?xml version="1.0" encoding="utf-8"?>
+<Project ToolsVersion="4.0" DefaultTargets="Build" xmlns="http://schemas.microsoft.com/developer/msbuild/2003">
+  <PropertyGroup>
+    <Configuration Condition=" '$(Configuration)' == '' ">Debug</Configuration>
+    <Platform Condition=" '$(Platform)' == '' ">AnyCPU</Platform>
+    <ProductVersion>8.0.30703</ProductVersion>
+    <SchemaVersion>2.0</SchemaVersion>
+    <ProjectGuid>{3540E29E-4793-49E7-8EE2-FEA7F61C3994}</ProjectGuid>
+    <OutputType>Library</OutputType>
+    <AppDesignerFolder>Properties</AppDesignerFolder>
+    <RootNamespace>HeuristicLab.Problems.Instances</RootNamespace>
+    <AssemblyName>HeuristicLab.Problems.Instances-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>..\..\..\..\trunk\sources\bin\</OutputPath>
+    <DefineConstants>DEBUG;TRACE</DefineConstants>
+    <ErrorReport>prompt</ErrorReport>
+    <WarningLevel>4</WarningLevel>
+    <Prefer32Bit>false</Prefer32Bit>
+  </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>
+    <Prefer32Bit>false</Prefer32Bit>
+  </PropertyGroup>
+  <PropertyGroup>
+    <SignAssembly>true</SignAssembly>
+  </PropertyGroup>
+  <PropertyGroup>
+    <AssemblyOriginatorKeyFile>HeuristicLab.snk</AssemblyOriginatorKeyFile>
+  </PropertyGroup>
+  <PropertyGroup Condition="'$(Configuration)|$(Platform)' == 'Debug|x64'">
+    <DebugSymbols>true</DebugSymbols>
+    <OutputPath>..\..\bin\</OutputPath>
+    <DefineConstants>DEBUG;TRACE</DefineConstants>
+    <DebugType>full</DebugType>
+    <PlatformTarget>x64</PlatformTarget>
+    <CodeAnalysisLogFile>..\..\bin\HeuristicLab.Problems.Instances-3.3.dll.CodeAnalysisLog.xml</CodeAnalysisLogFile>
+    <CodeAnalysisUseTypeNameInSuppression>true</CodeAnalysisUseTypeNameInSuppression>
+    <CodeAnalysisModuleSuppressionsFile>GlobalSuppressions.cs</CodeAnalysisModuleSuppressionsFile>
+    <ErrorReport>prompt</ErrorReport>
+    <CodeAnalysisRuleSet>MinimumRecommendedRules.ruleset</CodeAnalysisRuleSet>
+    <CodeAnalysisRuleSetDirectories>;C:\Program Files (x86)\Microsoft Visual Studio 10.0\Team Tools\Static Analysis Tools\\Rule Sets</CodeAnalysisRuleSetDirectories>
+    <CodeAnalysisIgnoreBuiltInRuleSets>true</CodeAnalysisIgnoreBuiltInRuleSets>
+    <CodeAnalysisRuleDirectories>;C:\Program Files (x86)\Microsoft Visual Studio 10.0\Team Tools\Static Analysis Tools\FxCop\\Rules</CodeAnalysisRuleDirectories>
+    <CodeAnalysisIgnoreBuiltInRules>true</CodeAnalysisIgnoreBuiltInRules>
+    <CodeAnalysisFailOnMissingRules>false</CodeAnalysisFailOnMissingRules>
+    <Prefer32Bit>false</Prefer32Bit>
+  </PropertyGroup>
+  <PropertyGroup Condition="'$(Configuration)|$(Platform)' == 'Release|x64'">
+    <OutputPath>..\..\bin\</OutputPath>
+    <DefineConstants>TRACE</DefineConstants>
+    <Optimize>true</Optimize>
+    <DebugType>pdbonly</DebugType>
+    <PlatformTarget>x64</PlatformTarget>
+    <CodeAnalysisLogFile>..\..\bin\HeuristicLab.Problems.Instances-3.3.dll.CodeAnalysisLog.xml</CodeAnalysisLogFile>
+    <CodeAnalysisUseTypeNameInSuppression>true</CodeAnalysisUseTypeNameInSuppression>
+    <CodeAnalysisModuleSuppressionsFile>GlobalSuppressions.cs</CodeAnalysisModuleSuppressionsFile>
+    <ErrorReport>prompt</ErrorReport>
+    <CodeAnalysisRuleSet>MinimumRecommendedRules.ruleset</CodeAnalysisRuleSet>
+    <CodeAnalysisRuleSetDirectories>;C:\Program Files (x86)\Microsoft Visual Studio 10.0\Team Tools\Static Analysis Tools\\Rule Sets</CodeAnalysisRuleSetDirectories>
+    <CodeAnalysisIgnoreBuiltInRuleSets>false</CodeAnalysisIgnoreBuiltInRuleSets>
+    <CodeAnalysisRuleDirectories>;C:\Program Files (x86)\Microsoft Visual Studio 10.0\Team Tools\Static Analysis Tools\FxCop\\Rules</CodeAnalysisRuleDirectories>
+    <CodeAnalysisIgnoreBuiltInRules>false</CodeAnalysisIgnoreBuiltInRules>
+    <CodeAnalysisFailOnMissingRules>false</CodeAnalysisFailOnMissingRules>
+    <Prefer32Bit>false</Prefer32Bit>
+  </PropertyGroup>
+  <PropertyGroup Condition="'$(Configuration)|$(Platform)' == 'Debug|x86'">
+    <DebugSymbols>true</DebugSymbols>
+    <OutputPath>..\..\bin\</OutputPath>
+    <DefineConstants>DEBUG;TRACE</DefineConstants>
+    <DebugType>full</DebugType>
+    <PlatformTarget>x86</PlatformTarget>
+    <CodeAnalysisLogFile>..\..\bin\HeuristicLab.Problems.Instances-3.3.dll.CodeAnalysisLog.xml</CodeAnalysisLogFile>
+    <CodeAnalysisUseTypeNameInSuppression>true</CodeAnalysisUseTypeNameInSuppression>
+    <CodeAnalysisModuleSuppressionsFile>GlobalSuppressions.cs</CodeAnalysisModuleSuppressionsFile>
+    <ErrorReport>prompt</ErrorReport>
+    <CodeAnalysisRuleSet>MinimumRecommendedRules.ruleset</CodeAnalysisRuleSet>
+    <CodeAnalysisRuleSetDirectories>;C:\Program Files (x86)\Microsoft Visual Studio 10.0\Team Tools\Static Analysis Tools\\Rule Sets</CodeAnalysisRuleSetDirectories>
+    <CodeAnalysisIgnoreBuiltInRuleSets>true</CodeAnalysisIgnoreBuiltInRuleSets>
+    <CodeAnalysisRuleDirectories>;C:\Program Files (x86)\Microsoft Visual Studio 10.0\Team Tools\Static Analysis Tools\FxCop\\Rules</CodeAnalysisRuleDirectories>
+    <CodeAnalysisIgnoreBuiltInRules>true</CodeAnalysisIgnoreBuiltInRules>
+    <CodeAnalysisFailOnMissingRules>false</CodeAnalysisFailOnMissingRules>
+    <Prefer32Bit>false</Prefer32Bit>
+  </PropertyGroup>
+  <PropertyGroup Condition="'$(Configuration)|$(Platform)' == 'Release|x86'">
+    <OutputPath>..\..\bin\</OutputPath>
+    <DefineConstants>TRACE</DefineConstants>
+    <Optimize>true</Optimize>
+    <DebugType>pdbonly</DebugType>
+    <PlatformTarget>x86</PlatformTarget>
+    <CodeAnalysisLogFile>..\..\bin\HeuristicLab.Problems.Instances-3.3.dll.CodeAnalysisLog.xml</CodeAnalysisLogFile>
+    <CodeAnalysisUseTypeNameInSuppression>true</CodeAnalysisUseTypeNameInSuppression>
+    <CodeAnalysisModuleSuppressionsFile>GlobalSuppressions.cs</CodeAnalysisModuleSuppressionsFile>
+    <ErrorReport>prompt</ErrorReport>
+    <CodeAnalysisRuleSet>MinimumRecommendedRules.ruleset</CodeAnalysisRuleSet>
+    <CodeAnalysisRuleSetDirectories>;C:\Program Files (x86)\Microsoft Visual Studio 10.0\Team Tools\Static Analysis Tools\\Rule Sets</CodeAnalysisRuleSetDirectories>
+    <CodeAnalysisIgnoreBuiltInRuleSets>false</CodeAnalysisIgnoreBuiltInRuleSets>
+    <CodeAnalysisRuleDirectories>;C:\Program Files (x86)\Microsoft Visual Studio 10.0\Team Tools\Static Analysis Tools\FxCop\\Rules</CodeAnalysisRuleDirectories>
+    <CodeAnalysisIgnoreBuiltInRules>false</CodeAnalysisIgnoreBuiltInRules>
+    <Prefer32Bit>false</Prefer32Bit>
+  </PropertyGroup>
+  <ItemGroup>
+    <Reference Include="HeuristicLab.Common-3.3">
+      <HintPath>..\..\..\..\trunk\sources\bin\HeuristicLab.Common-3.3.dll</HintPath>
+    </Reference>
+    <Reference Include="HeuristicLab.PluginInfrastructure-3.3">
+      <HintPath>..\..\..\..\trunk\sources\bin\HeuristicLab.PluginInfrastructure-3.3.dll</HintPath>
+    </Reference>
+    <Reference Include="Microsoft.CSharp" />
+    <Reference Include="System" />
+    <Reference Include="System.Core" />
+    <Reference Include="System.Data" />
+  </ItemGroup>
+  <ItemGroup>
+    <None Include="Plugin.cs.frame" />
+    <Compile Include="ProblemInstanceManager.cs" />
+    <Compile Include="IProblemInstanceExporter.cs" />
+    <Compile Include="Types\FSSPData.cs" />
+    <Compile Include="Types\LOPData.cs" />
+    <Compile Include="Types\PTSPData.cs" />
+    <Compile Include="Types\ATSPData.cs" />
+    <Compile Include="Types\JSSPData.cs" />
+    <Compile Include="Types\CTAPData.cs" />
+    <Compile Include="IDataDescriptor.cs" />
+    <Compile Include="Types\DistanceHelper.cs" />
+    <Compile Include="Types\OPData.cs" />
+    <Compile Include="Types\VRP\MDCVRPTWData.cs" />
+    <Compile Include="Types\VRP\MDCVRPData.cs" />
+    <Compile Include="Types\VRP\PDPTWData.cs" />
+    <Compile Include="Types\VRP\CVRPTWData.cs" />
+    <Compile Include="Types\VRP\VRPData.cs" />
+    <Compile Include="Types\VRP\CVRPData.cs" />
+    <Compile Include="Types\GQAPData.cs" />
+    <Compile Include="Types\VRP\IVRPData.cs" />
+    <Compile Include="Types\QAPData.cs" />
+    <Compile Include="Types\TSPData.cs" />
+    <Compile Include="IProblemInstanceConsumer.cs" />
+    <Compile Include="IProblemInstanceProvider.cs" />
+    <Compile Include="Plugin.cs" />
+    <Compile Include="ProblemInstanceProvider.cs" />
+    <Compile Include="Properties\AssemblyInfo.cs" />
+    <None Include="Properties\AssemblyInfo.cs.frame" />
+  </ItemGroup>
+  <ItemGroup>
+    <None Include="HeuristicLab.snk" />
+  </ItemGroup>
+  <Import Project="$(MSBuildToolsPath)\Microsoft.CSharp.targets" />
+  <PropertyGroup>
+    <PreBuildEvent Condition=" '$(OS)' == 'Windows_NT' ">set Path=%25Path%25;$(ProjectDir);$(SolutionDir)
+set ProjectDir=$(ProjectDir)
+set SolutionDir=$(SolutionDir)
+set Outdir=$(Outdir)
+
+call PreBuildEvent.cmd</PreBuildEvent>
+    <PreBuildEvent Condition=" '$(OS)' != 'Windows_NT' ">
+export ProjectDir=$(ProjectDir)
+export SolutionDir=$(SolutionDir)
+
+$SolutionDir/PreBuildEvent.sh
+</PreBuildEvent>
+  </PropertyGroup>
+  <PropertyGroup>
+    <PostBuildEvent>
+    </PostBuildEvent>
+  </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/2864_PermutationProblems/HeuristicLab.Problems.Instances/3.3/IDataDescriptor.cs
===================================================================
--- branches/2864_PermutationProblems/HeuristicLab.Problems.Instances/3.3/IDataDescriptor.cs	(revision 15541)
+++ branches/2864_PermutationProblems/HeuristicLab.Problems.Instances/3.3/IDataDescriptor.cs	(revision 15541)
@@ -0,0 +1,27 @@
+﻿#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 {
+  public interface IDataDescriptor {
+    string Name { get; }
+    string Description { get; }
+  }
+}
Index: branches/2864_PermutationProblems/HeuristicLab.Problems.Instances/3.3/IProblemInstanceConsumer.cs
===================================================================
--- branches/2864_PermutationProblems/HeuristicLab.Problems.Instances/3.3/IProblemInstanceConsumer.cs	(revision 15541)
+++ branches/2864_PermutationProblems/HeuristicLab.Problems.Instances/3.3/IProblemInstanceConsumer.cs	(revision 15541)
@@ -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
+
+using HeuristicLab.Common;
+
+namespace HeuristicLab.Problems.Instances {
+  public interface IProblemInstanceConsumer : IContent { }
+
+  public interface IProblemInstanceConsumer<in TData> : IProblemInstanceConsumer {
+    /// <summary>
+    /// Loads the given instance data.
+    /// </summary>
+    /// <exception cref="InvalidDataException">Thrown when the instance cannot be loaded.</exception>
+    /// <param name="data">The data of the instance.</param>
+    void Load(TData data);
+  }
+}
Index: branches/2864_PermutationProblems/HeuristicLab.Problems.Instances/3.3/IProblemInstanceExporter.cs
===================================================================
--- branches/2864_PermutationProblems/HeuristicLab.Problems.Instances/3.3/IProblemInstanceExporter.cs	(revision 15541)
+++ branches/2864_PermutationProblems/HeuristicLab.Problems.Instances/3.3/IProblemInstanceExporter.cs	(revision 15541)
@@ -0,0 +1,28 @@
+﻿#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 {
+  public interface IProblemInstanceExporter { }
+
+  public interface IProblemInstanceExporter<TData> : IProblemInstanceExporter {
+    TData Export();
+  }
+}
Index: branches/2864_PermutationProblems/HeuristicLab.Problems.Instances/3.3/IProblemInstanceProvider.cs
===================================================================
--- branches/2864_PermutationProblems/HeuristicLab.Problems.Instances/3.3/IProblemInstanceProvider.cs	(revision 15541)
+++ branches/2864_PermutationProblems/HeuristicLab.Problems.Instances/3.3/IProblemInstanceProvider.cs	(revision 15541)
@@ -0,0 +1,44 @@
+﻿#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.Common;
+
+namespace HeuristicLab.Problems.Instances {
+  public interface IProblemInstanceProvider : IContent {
+    string Name { get; }
+    string Description { get; }
+    Uri WebLink { get; }
+    string ReferencePublication { get; }
+  }
+
+  public interface IProblemInstanceProvider<TData> : IProblemInstanceProvider {
+    IEnumerable<IDataDescriptor> GetDataDescriptors();
+    TData LoadData(IDataDescriptor descriptor);
+
+    bool CanImportData { get; }
+    TData ImportData(string path);
+
+    bool CanExportData { get; }
+    void ExportData(TData instance, string path);
+  }
+}
Index: branches/2864_PermutationProblems/HeuristicLab.Problems.Instances/3.3/Plugin.cs
===================================================================
--- branches/2864_PermutationProblems/HeuristicLab.Problems.Instances/3.3/Plugin.cs	(revision 15541)
+++ branches/2864_PermutationProblems/HeuristicLab.Problems.Instances/3.3/Plugin.cs	(revision 15541)
@@ -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 {
+  [Plugin("HeuristicLab.Problems.Instances", "3.3.14.0")]
+  [PluginFile("HeuristicLab.Problems.Instances-3.3.dll", PluginFileType.Assembly)]
+  [PluginDependency("HeuristicLab.Common", "3.3")]
+  public class HeuristicLabProblemsInstancesPlugin : PluginBase {
+  }
+}
Index: branches/2864_PermutationProblems/HeuristicLab.Problems.Instances/3.3/Plugin.cs.frame
===================================================================
--- branches/2864_PermutationProblems/HeuristicLab.Problems.Instances/3.3/Plugin.cs.frame	(revision 15541)
+++ branches/2864_PermutationProblems/HeuristicLab.Problems.Instances/3.3/Plugin.cs.frame	(revision 15541)
@@ -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 {
+  [Plugin("HeuristicLab.Problems.Instances", "3.3.14.$WCREV$")]
+  [PluginFile("HeuristicLab.Problems.Instances-3.3.dll", PluginFileType.Assembly)]
+  [PluginDependency("HeuristicLab.Common", "3.3")]
+  public class HeuristicLabProblemsInstancesPlugin : PluginBase {
+  }
+}
Index: branches/2864_PermutationProblems/HeuristicLab.Problems.Instances/3.3/ProblemInstanceManager.cs
===================================================================
--- branches/2864_PermutationProblems/HeuristicLab.Problems.Instances/3.3/ProblemInstanceManager.cs	(revision 15541)
+++ branches/2864_PermutationProblems/HeuristicLab.Problems.Instances/3.3/ProblemInstanceManager.cs	(revision 15541)
@@ -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.Collections.Generic;
+using System.Linq;
+using HeuristicLab.PluginInfrastructure;
+
+namespace HeuristicLab.Problems.Instances {
+  public class ProblemInstanceManager {
+    public static IEnumerable<IProblemInstanceProvider> GetProviders(object item) {
+      var consumerTypes = item.GetType().GetInterfaces()
+        .Where(x => x.IsGenericType
+          && x.GetGenericTypeDefinition() == typeof(IProblemInstanceConsumer<>));
+
+      if (consumerTypes.Any()) {
+        var instanceTypes = consumerTypes
+          .Select(x => x.GetGenericArguments().First())
+          .Select(x => typeof(IProblemInstanceProvider<>).MakeGenericType(x));
+
+        var interfaceTypes = instanceTypes.Where(x => x.GetGenericArguments().First().IsInterface);
+        if (interfaceTypes.Any()) {
+          var concreteTypes = interfaceTypes.SelectMany(x => ApplicationManager.Manager.GetTypes(x.GetGenericArguments().First()));
+
+          if (concreteTypes.Any())
+            instanceTypes = instanceTypes.Union(concreteTypes.Select(x => typeof(IProblemInstanceProvider<>).MakeGenericType(x))).Distinct();
+        }
+
+        foreach (var type in instanceTypes) {
+          foreach (var provider in ApplicationManager.Manager.GetInstances(type))
+            yield return (IProblemInstanceProvider)provider;
+        }
+      }
+    }
+
+    public static IEnumerable<IDataDescriptor> GetDataDescriptors(IProblemInstanceProvider provider) {
+      IEnumerable<IDataDescriptor> descriptors = ((dynamic)provider).GetDataDescriptors();
+      return descriptors;
+    }
+
+    public static void LoadData(IProblemInstanceProvider provider, IDataDescriptor descriptor, IProblemInstanceConsumer consumer) {
+      ((dynamic)consumer).Load(((dynamic)provider).LoadData(descriptor));
+    }
+  }
+}
Index: branches/2864_PermutationProblems/HeuristicLab.Problems.Instances/3.3/ProblemInstanceProvider.cs
===================================================================
--- branches/2864_PermutationProblems/HeuristicLab.Problems.Instances/3.3/ProblemInstanceProvider.cs	(revision 15541)
+++ branches/2864_PermutationProblems/HeuristicLab.Problems.Instances/3.3/ProblemInstanceProvider.cs	(revision 15541)
@@ -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 System;
+using System.Collections.Generic;
+
+namespace HeuristicLab.Problems.Instances {
+  public abstract class ProblemInstanceProvider<TData> : IProblemInstanceProvider<TData> {
+    public abstract string Name { get; }
+    public abstract string Description { get; }
+    public abstract Uri WebLink { get; }
+    public abstract string ReferencePublication { get; }
+
+    public abstract IEnumerable<IDataDescriptor> GetDataDescriptors();
+
+    public abstract TData LoadData(IDataDescriptor descriptor);
+
+    public virtual bool CanImportData {
+      get { return false; }
+    }
+    public virtual TData ImportData(string path) {
+      throw new NotSupportedException();
+    }
+
+    public virtual bool CanExportData {
+      get { return false; }
+    }
+    public virtual void ExportData(TData instance, string path) {
+      throw new NotSupportedException();
+    }
+  }
+}
Index: branches/2864_PermutationProblems/HeuristicLab.Problems.Instances/3.3/Properties/AssemblyInfo.cs
===================================================================
--- branches/2864_PermutationProblems/HeuristicLab.Problems.Instances/3.3/Properties/AssemblyInfo.cs	(revision 15541)
+++ branches/2864_PermutationProblems/HeuristicLab.Problems.Instances/3.3/Properties/AssemblyInfo.cs	(revision 15541)
@@ -0,0 +1,57 @@
+﻿#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.CompilerServices;
+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")]
+[assembly: AssemblyDescription("Base plugin for making problem instances available to problems.")]
+[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("7c14407e-6980-465b-ba3a-4a916d48989b")]
+
+// 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.0")]
Index: branches/2864_PermutationProblems/HeuristicLab.Problems.Instances/3.3/Properties/AssemblyInfo.cs.frame
===================================================================
--- branches/2864_PermutationProblems/HeuristicLab.Problems.Instances/3.3/Properties/AssemblyInfo.cs.frame	(revision 15541)
+++ branches/2864_PermutationProblems/HeuristicLab.Problems.Instances/3.3/Properties/AssemblyInfo.cs.frame	(revision 15541)
@@ -0,0 +1,57 @@
+﻿#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.CompilerServices;
+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")]
+[assembly: AssemblyDescription("Base plugin for making problem instances available to problems.")]
+[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("7c14407e-6980-465b-ba3a-4a916d48989b")]
+
+// 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/2864_PermutationProblems/HeuristicLab.Problems.Instances/3.3/Types/ATSPData.cs
===================================================================
--- branches/2864_PermutationProblems/HeuristicLab.Problems.Instances/3.3/Types/ATSPData.cs	(revision 15541)
+++ branches/2864_PermutationProblems/HeuristicLab.Problems.Instances/3.3/Types/ATSPData.cs	(revision 15541)
@@ -0,0 +1,63 @@
+﻿#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>
+  /// Describe instances of the Asymmetric Traveling Salesman Problem (ATSP).
+  /// </summary>
+  public class ATSPData {
+    /// <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 cities.
+    /// </summary>
+    public int Dimension { get; set; }
+    /// <summary>
+    /// The distances are given in form of a distance matrix.
+    /// </summary>
+    public double[,] Distances { get; set; }
+    /// <summary>
+    /// Optional! A a matrix of dimension [N, 2] where each row is one of the cities
+    /// and the colmns represent x and y coordinates respectively.
+    /// </summary>
+    /// <remarks>
+    /// The coordinates are for display purposes only.
+    /// </remarks>
+    public double[,] Coordinates { get; set; }
+
+    /// <summary>
+    /// Optional! The best-known tour in path-encoding.
+    /// </summary>
+    public int[] BestKnownTour { get; set; }
+    /// <summary>
+    /// Optional! The quality of the best-known tour.
+    /// </summary>
+    public double? BestKnownQuality { get; set; }
+  }
+}
Index: branches/2864_PermutationProblems/HeuristicLab.Problems.Instances/3.3/Types/CTAPData.cs
===================================================================
--- branches/2864_PermutationProblems/HeuristicLab.Problems.Instances/3.3/Types/CTAPData.cs	(revision 15541)
+++ branches/2864_PermutationProblems/HeuristicLab.Problems.Instances/3.3/Types/CTAPData.cs	(revision 15541)
@@ -0,0 +1,70 @@
+﻿#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 Capacitated Task Assignment Problem (CTAP).
+  /// </summary>
+  public class CTAPData {
+    /// <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 M of processors
+    /// </summary>
+    public int Processors { get; set; }
+    /// <summary>
+    /// The number N of tasks
+    /// </summary>
+    public int Tasks { get; set; }
+    /// <summary>
+    /// An MxN Matrix with M = |Processors| and N = |Tasks|
+    /// </summary>
+    public double[,] ExecutionCosts { get; set; }
+    /// <summary>
+    /// An NxN Matrix with N = |Tasks|
+    /// </summary>
+    public double[,] CommunicationCosts { get; set; }
+    /// <summary>
+    /// An array of length N with N = |Tasks|
+    /// </summary>
+    public double[] MemoryRequirements { get; set; }
+    /// <summary>
+    /// An array of length M with M = |Processors|
+    /// </summary>
+    public double[] MemoryCapacities { get; set; }
+
+    /// <summary>
+    /// Optional! An array of length N with N = |Tasks|
+    /// </summary>
+    public int[] BestKnownAssignment { get; set; }
+    /// <summary>
+    /// Optional! The quality value of the <see cref="BestKnownAssignment"/>
+    /// </summary>
+    public double? BestKnownQuality { get; set; }
+  }
+}
Index: branches/2864_PermutationProblems/HeuristicLab.Problems.Instances/3.3/Types/DistanceHelper.cs
===================================================================
--- branches/2864_PermutationProblems/HeuristicLab.Problems.Instances/3.3/Types/DistanceHelper.cs	(revision 15541)
+++ branches/2864_PermutationProblems/HeuristicLab.Problems.Instances/3.3/Types/DistanceHelper.cs	(revision 15541)
@@ -0,0 +1,133 @@
+﻿#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;
+
+namespace HeuristicLab.Problems.Instances {
+  public enum DistanceMeasure { Direct, Euclidean, RoundedEuclidean, UpperEuclidean, Geo, Manhattan, Maximum, Att };
+
+  public static class DistanceHelper {
+    /// <summary>
+    /// If only the coordinates are given, can calculate the distance matrix.
+    /// </summary>
+    /// <returns>A full distance matrix between all cities.</returns>
+    public static double[,] GetDistanceMatrix(DistanceMeasure distanceMeasure, double[,] coordinates, double[,] distances, int dimension) {
+      if (distances != null) return distances;
+
+      distances = new double[dimension, dimension];
+      for (int i = 0; i < dimension - 1; i++)
+        for (int j = i + 1; j < dimension; j++) {
+          distances[i, j] = GetDistance(i, j, distanceMeasure, coordinates, distances);
+          distances[j, i] = distances[i, j];
+        }
+
+      return distances;
+    }
+
+    public static double GetDistance(DistanceMeasure distanceMeasure, double x1, double y1, double x2, double y2) {
+      switch (distanceMeasure) {
+        case DistanceMeasure.Att:
+          return AttDistance(x1, y1, x2, y2);
+        case DistanceMeasure.Direct:
+          throw new ArgumentException("Direct distance measure requires distance matrix for distance calculation.");
+        case DistanceMeasure.Euclidean:
+          return EuclideanDistance(x1, y1, x2, y2);
+        case DistanceMeasure.Geo:
+          return GeoDistance(x1, y1, x2, y2);
+        case DistanceMeasure.Manhattan:
+          return ManhattanDistance(x1, y1, x2, y2);
+        case DistanceMeasure.Maximum:
+          return MaximumDistance(x1, y1, x2, y2);
+        case DistanceMeasure.RoundedEuclidean:
+          return Math.Round(EuclideanDistance(x1, y1, x2, y2));
+        case DistanceMeasure.UpperEuclidean:
+          return Math.Ceiling(EuclideanDistance(x1, y1, x2, y2));
+        default:
+          throw new InvalidOperationException("Distance measure is not known.");
+      }
+    }
+
+    #region Private Helpers
+    private static double GetDistance(int i, int j, DistanceMeasure distanceMeasure, double[,] coordinates, double[,] distances) {
+      switch (distanceMeasure) {
+        case DistanceMeasure.Att:
+          return AttDistance(coordinates[i, 0], coordinates[i, 1], coordinates[j, 0], coordinates[j, 1]);
+        case DistanceMeasure.Direct:
+          return distances[i, j];
+        case DistanceMeasure.Euclidean:
+          return EuclideanDistance(coordinates[i, 0], coordinates[i, 1], coordinates[j, 0], coordinates[j, 1]);
+        case DistanceMeasure.Geo:
+          return GeoDistance(coordinates[i, 0], coordinates[i, 1], coordinates[j, 0], coordinates[j, 1]);
+        case DistanceMeasure.Manhattan:
+          return ManhattanDistance(coordinates[i, 0], coordinates[i, 1], coordinates[j, 0], coordinates[j, 1]);
+        case DistanceMeasure.Maximum:
+          return MaximumDistance(coordinates[i, 0], coordinates[i, 1], coordinates[j, 0], coordinates[j, 1]);
+        case DistanceMeasure.RoundedEuclidean:
+          return Math.Round(EuclideanDistance(coordinates[i, 0], coordinates[i, 1], coordinates[j, 0], coordinates[j, 1]));
+        case DistanceMeasure.UpperEuclidean:
+          return Math.Ceiling(EuclideanDistance(coordinates[i, 0], coordinates[i, 1], coordinates[j, 0], coordinates[j, 1]));
+        default:
+          throw new InvalidOperationException("Distance measure is not known.");
+      }
+    }
+
+    private static double AttDistance(double x1, double y1, double x2, double y2) {
+      return Math.Ceiling(Math.Sqrt(((x1 - x2) * (x1 - x2) + (y1 - y2) * (y1 - y2)) / 10.0));
+    }
+
+    private static double EuclideanDistance(double x1, double y1, double x2, double y2) {
+      return Math.Sqrt((x1 - x2) * (x1 - x2) + (y1 - y2) * (y1 - y2));
+    }
+
+    private const double PI = 3.141592;
+    private const double RADIUS = 6378.388;
+    private static double GeoDistance(double x1, double y1, double x2, double y2) {
+      double latitude1, longitude1, latitude2, longitude2;
+      double q1, q2, q3;
+      double length;
+
+      latitude1 = ConvertToRadian(x1);
+      longitude1 = ConvertToRadian(y1);
+      latitude2 = ConvertToRadian(x2);
+      longitude2 = ConvertToRadian(y2);
+
+      q1 = Math.Cos(longitude1 - longitude2);
+      q2 = Math.Cos(latitude1 - latitude2);
+      q3 = Math.Cos(latitude1 + latitude2);
+
+      length = (int)(RADIUS * Math.Acos(0.5 * ((1.0 + q1) * q2 - (1.0 - q1) * q3)) + 1.0);
+      return (length);
+    }
+
+    private static double ConvertToRadian(double x) {
+      return PI * (Math.Truncate(x) + 5.0 * (x - Math.Truncate(x)) / 3.0) / 180.0;
+    }
+
+    private static double ManhattanDistance(double x1, double y1, double x2, double y2) {
+      return Math.Round(Math.Abs(x1 - x2) + Math.Abs(y1 - y2), MidpointRounding.AwayFromZero);
+    }
+
+    private static double MaximumDistance(double x1, double y1, double x2, double y2) {
+      return Math.Max(Math.Round(Math.Abs(x1 - x2), MidpointRounding.AwayFromZero), Math.Round(Math.Abs(y1 - y2), MidpointRounding.AwayFromZero));
+    }
+    #endregion
+  }
+}
Index: branches/2864_PermutationProblems/HeuristicLab.Problems.Instances/3.3/Types/FSSPData.cs
===================================================================
--- branches/2864_PermutationProblems/HeuristicLab.Problems.Instances/3.3/Types/FSSPData.cs	(revision 15541)
+++ branches/2864_PermutationProblems/HeuristicLab.Problems.Instances/3.3/Types/FSSPData.cs	(revision 15541)
@@ -0,0 +1,19 @@
+﻿using System;
+using System.Collections.Generic;
+using System.Linq;
+using System.Text;
+using System.Threading.Tasks;
+
+namespace HeuristicLab.Problems.Instances
+{
+    public class FSSPData
+    {
+        public string Name { get; set; }
+        public string Description { get; set; }
+        public int Jobs { get; set; }
+        public int Machines { get; set; }
+        public double[,] ProcessingTimes { get; set; }
+        public int[] BestKnownSchedule { get; set; }
+        public double? BestKnownQuality { get; set; }
+    }
+}
Index: branches/2864_PermutationProblems/HeuristicLab.Problems.Instances/3.3/Types/GQAPData.cs
===================================================================
--- branches/2864_PermutationProblems/HeuristicLab.Problems.Instances/3.3/Types/GQAPData.cs	(revision 15541)
+++ branches/2864_PermutationProblems/HeuristicLab.Problems.Instances/3.3/Types/GQAPData.cs	(revision 15541)
@@ -0,0 +1,78 @@
+﻿#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 an instance of the Generalized Quadratic Assignment Problem (GQAP).
+  /// </summary>
+  public class GQAPData {
+    /// <summary>
+    /// The name of the instance.
+    /// </summary>
+    public string Name { get; set; }
+    /// <summary>
+    /// A description of the instance.
+    /// </summary>
+    public string Description { get; set; }
+
+    /// <summary>
+    /// |E| = The number of equipments are to be assigned in this instance.
+    /// </summary>
+    public int Equipments { get; set; }
+    /// <summary>
+    /// |L| = The number of locations that are available for the equipments.
+    /// </summary>
+    public int Locations { get; set; }
+    /// <summary>
+    /// Vector of length |E| that describes the space demand for the equipments.
+    /// </summary>
+    public double[] Demands { get; set; }
+    /// <summary>
+    /// Vector of length |L| that describes the space capacity for the locations.
+    /// </summary>
+    public double[] Capacities { get; set; }
+    /// <summary>
+    /// |E|x|E| matrix with the weights (flows) between the equipments. These describe the strength of the respective bonding.
+    /// </summary>
+    public double[,] Weights { get; set; }
+    /// <summary>
+    /// |L|x|L| matrix with the distances between the locations.
+    /// </summary>
+    public double[,] Distances { get; set; }
+    /// <summary>
+    /// |E|x|L| matrix that describes the costs of installing equipment x at location y.
+    /// </summary>
+    public double[,] InstallationCosts { get; set; }
+    /// <summary>
+    /// A factor that scales the weights.
+    /// </summary>
+    public double TransportationCosts { get; set; }
+
+    /// <summary>
+    /// Optional! The best-known assignment is a vector of length |E| with numbers ranging from 0 to |L| - 1
+    /// </summary>
+    public int[] BestKnownAssignment { get; set; }
+    /// <summary>
+    /// Optional! The quality of the best-known assignment.
+    /// </summary>
+    public double? BestKnownQuality { get; set; }
+  }
+}
Index: branches/2864_PermutationProblems/HeuristicLab.Problems.Instances/3.3/Types/JSSPData.cs
===================================================================
--- branches/2864_PermutationProblems/HeuristicLab.Problems.Instances/3.3/Types/JSSPData.cs	(revision 15541)
+++ branches/2864_PermutationProblems/HeuristicLab.Problems.Instances/3.3/Types/JSSPData.cs	(revision 15541)
@@ -0,0 +1,68 @@
+﻿#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 Job Shop Scheduling Problem (JSSP).
+  /// </summary>
+  public class JSSPData {
+    /// <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 jobs.
+    /// </summary>
+    public int Jobs { get; set; }
+    /// <summary>
+    /// The number of resources.
+    /// </summary>
+    public int Resources { get; set; }
+    /// <summary>
+    /// The first dimension lists the jobs, the second dimension the operations and the value denotes the processing time.
+    /// </summary>
+    public double[,] ProcessingTimes { get; set; }
+    /// <summary>
+    /// The first dimension lists the jobs, the second dimension the operations and the value denotes the resource that is demanded.
+    /// </summary>
+    public int[,] Demands { get; set; }
+    /// <summary>
+    /// Optional! Specifies the due dates for each job.
+    /// </summary>
+    public double[] DueDates { get; set; }
+
+    /// <summary>
+    /// Optional! The best-known schedule.
+    /// The first dimension lists the resources, the second dimension is the order and the value denotes the job
+    /// </summary>
+    public int[,] BestKnownSchedule { get; set; }
+    /// <summary>
+    /// Optional! The quality of the best-known schedule.
+    /// </summary>
+    public double? BestKnownQuality { get; set; }
+  }
+}
Index: branches/2864_PermutationProblems/HeuristicLab.Problems.Instances/3.3/Types/LOPData.cs
===================================================================
--- branches/2864_PermutationProblems/HeuristicLab.Problems.Instances/3.3/Types/LOPData.cs	(revision 15541)
+++ branches/2864_PermutationProblems/HeuristicLab.Problems.Instances/3.3/Types/LOPData.cs	(revision 15541)
@@ -0,0 +1,65 @@
+﻿#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.Text;
+using System.Threading.Tasks;
+
+namespace HeuristicLab.Problems.Instances.Types
+{
+    /// <summary>
+    /// Describes instances of the Linear Ordering Problem (LOP).
+    /// </summary>
+    public class LOPData
+    {
+        /// <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 size of the Matrix
+        /// </summary>
+        public int Dimension { get; set; }
+
+        /// <summary>
+        /// An NxN Matrix
+        /// </summary>
+        public double[,] Matrix { get; set; }
+
+        /// <summary>
+        /// Optional! The best known Permutation
+        /// </summary>
+        public int[] BestKnownPermutation { get; set; }
+
+        /// <summary>
+        /// Optional! The quality value of the <see cref="BestKnownPermutation"/>
+        /// </summary>
+        public double? BestKnownQuality { get; set; }
+    }
+}
Index: branches/2864_PermutationProblems/HeuristicLab.Problems.Instances/3.3/Types/OPData.cs
===================================================================
--- branches/2864_PermutationProblems/HeuristicLab.Problems.Instances/3.3/Types/OPData.cs	(revision 15541)
+++ branches/2864_PermutationProblems/HeuristicLab.Problems.Instances/3.3/Types/OPData.cs	(revision 15541)
@@ -0,0 +1,49 @@
+﻿#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.Types {
+  /// <summary>
+  /// Describes instances of the Orienteering Problem (OP).
+  /// </summary>
+  public class OPData : TSPData {
+    /// <summary>
+    /// The maximum distance constraint for a Orienteering solution.
+    /// </summary>
+    public double MaximumDistance { get; set; }
+    /// <summary>
+    /// The scores of the points.
+    /// </summary>
+    public double[] Scores { get; set; }
+    /// <summary>
+    /// The penalty for each visited vertex.
+    /// </summary>
+    public double PointVisitingCosts { get; set; }
+    /// <summary>
+    /// Index of the starting point
+    /// </summary>
+    public int StartingPoint { get; set; }
+    /// <summary>
+    /// Index of the ending point.
+    /// </summary>
+    public int TerminalPoint { get; set; }
+  }
+}
Index: branches/2864_PermutationProblems/HeuristicLab.Problems.Instances/3.3/Types/PTSPData.cs
===================================================================
--- branches/2864_PermutationProblems/HeuristicLab.Problems.Instances/3.3/Types/PTSPData.cs	(revision 15541)
+++ branches/2864_PermutationProblems/HeuristicLab.Problems.Instances/3.3/Types/PTSPData.cs	(revision 15541)
@@ -0,0 +1,12 @@
+﻿
+namespace HeuristicLab.Problems.Instances {
+  /// <summary>
+  /// Describes instances of the Probabilistic Traveling Salesman Problem (PTSP).
+  /// </summary>
+  public class PTSPData : TSPData {
+    /// <summary>
+    /// The probabilities for each of the cities to appear in a route.
+    /// </summary>
+    public double[] Probabilities { get; set; }
+  }
+}
Index: branches/2864_PermutationProblems/HeuristicLab.Problems.Instances/3.3/Types/QAPData.cs
===================================================================
--- branches/2864_PermutationProblems/HeuristicLab.Problems.Instances/3.3/Types/QAPData.cs	(revision 15541)
+++ branches/2864_PermutationProblems/HeuristicLab.Problems.Instances/3.3/Types/QAPData.cs	(revision 15541)
@@ -0,0 +1,58 @@
+﻿#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 Quadratic Assignment Problem (QAP).
+  /// </summary>
+  public class QAPData {
+    /// <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 facilities (and also the number of locations)
+    /// </summary>
+    public int Dimension { get; set; }
+    /// <summary>
+    /// An NxN Matrix with N = |Faciliies|
+    /// </summary>
+    public double[,] Distances { get; set; }
+    /// <summary>
+    /// An NxN Matrix with N = |Faciliies|
+    /// </summary>
+    public double[,] Weights { get; set; }
+
+    /// <summary>
+    /// Optional! An array of length N with N = |Facilities|
+    /// </summary>
+    public int[] BestKnownAssignment { get; set; }
+    /// <summary>
+    /// Optional! The quality value of the <see cref="BestKnownAssignment"/>
+    /// </summary>
+    public double? BestKnownQuality { get; set; }
+  }
+}
Index: branches/2864_PermutationProblems/HeuristicLab.Problems.Instances/3.3/Types/TSPData.cs
===================================================================
--- branches/2864_PermutationProblems/HeuristicLab.Problems.Instances/3.3/Types/TSPData.cs	(revision 15541)
+++ branches/2864_PermutationProblems/HeuristicLab.Problems.Instances/3.3/Types/TSPData.cs	(revision 15541)
@@ -0,0 +1,84 @@
+﻿#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;
+
+namespace HeuristicLab.Problems.Instances {
+  /// <summary>
+  /// Describes instances of the Traveling Salesman Problem (TSP).
+  /// </summary>
+  public class TSPData {
+    /// <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 cities.
+    /// </summary>
+    public int Dimension { get; set; }
+    /// <summary>
+    /// Specifies the distance measure that is to be used.
+    /// </summary>
+    public DistanceMeasure DistanceMeasure { get; set; }
+    /// <summary>
+    /// Optional! The distances are given in form of a distance matrix.
+    /// </summary>
+    /// <remarks>
+    /// Either this property or <see cref="Coordinates"/> needs to be specified.
+    /// </remarks>
+    public double[,] Distances { get; set; }
+    /// <summary>
+    /// Optional! A a matrix of dimension [N, 2] matrix where each row is one of the cities
+    /// and the colmns represent x and y coordinates respectively.
+    /// </summary>
+    /// <remarks>
+    /// Either this property or <see cref="Distances"/> needs to be specified.
+    /// 
+    /// If no distance matrix is given, the distances have to be calculated by the
+    /// specified distance measure. If a distance matrix is given in addtion to the
+    /// coordinates, the distance matrix takes precedence and the coordinates are
+    /// for display only.
+    /// </remarks>
+    public double[,] Coordinates { get; set; }
+
+    /// <summary>
+    /// Optional! The best-known tour in path-encoding.
+    /// </summary>
+    public int[] BestKnownTour { get; set; }
+    /// <summary>
+    /// Optional! The quality of the best-known tour.
+    /// </summary>
+    public double? BestKnownQuality { get; set; }
+
+    /// <summary>
+    /// If only the coordinates are given, can calculate the distance matrix.
+    /// </summary>
+    /// <returns>A full distance matrix between all cities.</returns>
+    public double[,] GetDistanceMatrix() {
+      return DistanceHelper.GetDistanceMatrix(DistanceMeasure, Coordinates, Distances, Dimension);
+    }
+  }
+}
Index: branches/2864_PermutationProblems/HeuristicLab.Problems.Instances/3.3/Types/VRP/CVRPData.cs
===================================================================
--- branches/2864_PermutationProblems/HeuristicLab.Problems.Instances/3.3/Types/VRP/CVRPData.cs	(revision 15541)
+++ branches/2864_PermutationProblems/HeuristicLab.Problems.Instances/3.3/Types/VRP/CVRPData.cs	(revision 15541)
@@ -0,0 +1,33 @@
+﻿#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 Capacitated Vehicle Routing Problem (CVRP).
+  /// </summary>
+  public class CVRPData: VRPData {
+    /// <summary>
+    /// The capacity of the vehicles, which is the same for all (homogeneous fleet).
+    /// </summary>
+    public double Capacity { get; set; }
+  }
+}
Index: branches/2864_PermutationProblems/HeuristicLab.Problems.Instances/3.3/Types/VRP/CVRPTWData.cs
===================================================================
--- branches/2864_PermutationProblems/HeuristicLab.Problems.Instances/3.3/Types/VRP/CVRPTWData.cs	(revision 15541)
+++ branches/2864_PermutationProblems/HeuristicLab.Problems.Instances/3.3/Types/VRP/CVRPTWData.cs	(revision 15541)
@@ -0,0 +1,41 @@
+﻿#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 Capacitated Vehicle Routing Problem with Time Windows (CVRPTW).
+  /// </summary>
+  public class CVRPTWData: CVRPData {
+    /// <summary>
+    /// The ready times of the customers and the depot
+    /// </summary>
+    public double[] ReadyTimes { get; set; }
+    /// <summary>
+    /// The service times of the customers and the depot
+    /// </summary>
+    public double[] ServiceTimes { get; set; }
+    /// <summary>
+    /// The due times of the customers and the depot
+    /// </summary>
+    public double[] DueTimes { get; set; }
+  }
+}
Index: branches/2864_PermutationProblems/HeuristicLab.Problems.Instances/3.3/Types/VRP/IVRPData.cs
===================================================================
--- branches/2864_PermutationProblems/HeuristicLab.Problems.Instances/3.3/Types/VRP/IVRPData.cs	(revision 15541)
+++ branches/2864_PermutationProblems/HeuristicLab.Problems.Instances/3.3/Types/VRP/IVRPData.cs	(revision 15541)
@@ -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 {
+  /// <summary>
+  /// Interface for VRP data
+  /// </summary>
+  public interface IVRPData {
+    string Name { get; set; }
+    string Description { get; set; }
+    int Dimension { get; set; }
+    double? BestKnownQuality { get; set; }
+    int[][] BestKnownTour { get; set; }
+    int[] BestKnownTourVehicleAssignment { get; set; }
+  }
+}
Index: branches/2864_PermutationProblems/HeuristicLab.Problems.Instances/3.3/Types/VRP/MDCVRPData.cs
===================================================================
--- branches/2864_PermutationProblems/HeuristicLab.Problems.Instances/3.3/Types/VRP/MDCVRPData.cs	(revision 15541)
+++ branches/2864_PermutationProblems/HeuristicLab.Problems.Instances/3.3/Types/VRP/MDCVRPData.cs	(revision 15541)
@@ -0,0 +1,41 @@
+﻿#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 Multi-Depot Capacitated Vehicle Routing Problem (MDCVRP).
+  /// </summary>
+  public class MDCVRPData: VRPData {
+    /// <summary>
+    /// The number of depots
+    /// </summary>
+    public int Depots { get; set; }
+    /// <summary>
+    /// The assignment of the vehicles to the depot.
+    /// </summary>
+    public int[] VehicleDepotAssignment { get; set; }
+    /// <summary>
+    /// The capacity of the vehicles, which is not the same for all (heterogeneous fleet).
+    /// </summary>
+    public double[] Capacity { get; set; }
+  }
+}
Index: branches/2864_PermutationProblems/HeuristicLab.Problems.Instances/3.3/Types/VRP/MDCVRPTWData.cs
===================================================================
--- branches/2864_PermutationProblems/HeuristicLab.Problems.Instances/3.3/Types/VRP/MDCVRPTWData.cs	(revision 15541)
+++ branches/2864_PermutationProblems/HeuristicLab.Problems.Instances/3.3/Types/VRP/MDCVRPTWData.cs	(revision 15541)
@@ -0,0 +1,41 @@
+﻿#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 Multi-Depot Capacitated Vehicle Routing Problem (MDCVRP).
+  /// </summary>
+  public class MDCVRPTWData: MDCVRPData {
+    /// <summary>
+    /// The ready times of the customers and the depot
+    /// </summary>
+    public double[] ReadyTimes { get; set; }
+    /// <summary>
+    /// The service times of the customers and the depot
+    /// </summary>
+    public double[] ServiceTimes { get; set; }
+    /// <summary>
+    /// The due times of the customers and the depot
+    /// </summary>
+    public double[] DueTimes { get; set; }
+  }
+}
Index: branches/2864_PermutationProblems/HeuristicLab.Problems.Instances/3.3/Types/VRP/PDPTWData.cs
===================================================================
--- branches/2864_PermutationProblems/HeuristicLab.Problems.Instances/3.3/Types/VRP/PDPTWData.cs	(revision 15541)
+++ branches/2864_PermutationProblems/HeuristicLab.Problems.Instances/3.3/Types/VRP/PDPTWData.cs	(revision 15541)
@@ -0,0 +1,33 @@
+﻿#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 Pickup and Delivery Problem with Time Windows (PDPTW).
+  /// </summary>
+  public class PDPTWData: CVRPTWData {
+    /// <summary>
+    /// The pickup and delivery locations of the requests
+    /// </summary>
+    public int[] PickupDeliveryLocations { get; set; }
+  }
+}
Index: branches/2864_PermutationProblems/HeuristicLab.Problems.Instances/3.3/Types/VRP/VRPData.cs
===================================================================
--- branches/2864_PermutationProblems/HeuristicLab.Problems.Instances/3.3/Types/VRP/VRPData.cs	(revision 15541)
+++ branches/2864_PermutationProblems/HeuristicLab.Problems.Instances/3.3/Types/VRP/VRPData.cs	(revision 15541)
@@ -0,0 +1,96 @@
+﻿#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 Vehicle Routing Problem (VRP).
+  /// </summary>
+  public class VRPData : IVRPData {
+    /// <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 customers and the depot
+    /// </summary>
+    public int Dimension { get; set; }
+    /// <summary>
+    /// The distance measure that is used to calculate the distance between
+    ///the coordinates if no <see cref="Distances"/> is given.
+    /// </summary>
+    public DistanceMeasure DistanceMeasure { get; set; }
+    /// <summary>
+    /// Optional! The maximum number of vehicles that can be used.
+    /// </summary>
+    /// <remarks>
+    /// If no number is given, but a maximum is required, it can be assumed that
+    /// the maximum number of vehicles is equal to the number of customers as
+    /// there cannot be more than one vehicle per customer.
+    /// </remarks>
+    public double? MaximumVehicles { get; set; }
+    /// <remarks>
+    /// Either Distances or the <see cref="Coordinates"/> need to be specified along
+    /// with a distance measure.
+    /// </remarks>
+    public double[,] Distances { get; set; }
+    /// <summary>
+    /// Optional! A a matrix of dimension [N, 2] where each row is either the customer
+    /// or the depot and the columns represent x and y coordinates respectively.
+    /// </summary>
+    /// <remarks>
+    /// Either <see cref="Distances"/> or the Coordinates need to be specified along
+    /// with a distance measure.
+    /// </remarks>
+    public double[,] Coordinates { get; set; }
+    /// <summary>
+    /// The demand vector that specifies how many goods need to be delivered.
+    /// The vector has to include the depot, but with a demand of 0.
+    /// </summary>
+    public double[] Demands { get; set; }
+
+    /// <summary>
+    /// Optional! The best-known solution as a list of tours in path-encoding.
+    /// </summary>
+    public int[][] BestKnownTour { get; set; }
+    /// <summary>
+    /// Optional! Specifies the used vehicle for a given tour.
+    /// </summary>
+    public int[] BestKnownTourVehicleAssignment { get; set; }
+    /// <summary>
+    /// Optional! The quality of the best-known solution.
+    /// </summary>
+    public double? BestKnownQuality { get; set; }
+
+    /// <summary>
+    /// If only the coordinates are given, can calculate the distance matrix.
+    /// </summary>
+    /// <returns>A full distance matrix between all cities.</returns>
+    public double[,] GetDistanceMatrix() {
+      return DistanceHelper.GetDistanceMatrix(DistanceMeasure, Coordinates, Distances, Dimension);
+    }
+  }
+}
Index: branches/2864_PermutationProblems/HeuristicLab.Problems.LinearOrdering/3.3/Evaluators/LOPEvaluator.cs
===================================================================
--- branches/2864_PermutationProblems/HeuristicLab.Problems.LinearOrdering/3.3/Evaluators/LOPEvaluator.cs	(revision 15540)
+++ branches/2864_PermutationProblems/HeuristicLab.Problems.LinearOrdering/3.3/Evaluators/LOPEvaluator.cs	(revision 15541)
@@ -36,9 +36,11 @@
     public abstract class LOPEvaluator : InstrumentedOperator, ILOPEvaluator
     {
-        public override bool CanChangeName {
+        public override bool CanChangeName
+        {
             get { return false; }
         }
 
-        public ILookupParameter<DoubleValue> QualityParameter {
+        public ILookupParameter<DoubleValue> QualityParameter
+        {
             get { return (ILookupParameter<DoubleValue>)Parameters["Quality"]; }
         }
Index: branches/2864_PermutationProblems/HeuristicLab.Problems.LinearOrdering/3.3/Evaluators/MatrixTriangulationEvaluator.cs
===================================================================
--- branches/2864_PermutationProblems/HeuristicLab.Problems.LinearOrdering/3.3/Evaluators/MatrixTriangulationEvaluator.cs	(revision 15540)
+++ branches/2864_PermutationProblems/HeuristicLab.Problems.LinearOrdering/3.3/Evaluators/MatrixTriangulationEvaluator.cs	(revision 15541)
@@ -31,5 +31,5 @@
 {
     /// <summary>
-    /// A base class for operators which evaluate LOP solutions given in Matrix representation.
+    /// A base class for operators which evaluates LOP solutions given in Matrix representation.
     /// </summary>
     [Item("MatrixTriangulationEvaluator", "A base class for operators which evaluate LOP solutions given in Matrix representation.")]
@@ -37,10 +37,9 @@
     public abstract class MatrixTriangulationEvaluator : LOPEvaluator, IMatrixTriangulationEvaluator
     {
-        private object locker = new object();
-
         public ILookupParameter<Permutation> PermutationParameter { get { return (ILookupParameter<Permutation>)Parameters["Permutation"]; } }
         public ILookupParameter<DoubleMatrix> MatrixParameter { get { return (ILookupParameter<DoubleMatrix>)Parameters["Matrix"]; } }
         public ILookupParameter<Permutation> BestKnownSolutionParameter { get { return (ILookupParameter<Permutation>)Parameters["BestKnownSolution"]; } }
         public ILookupParameter<DoubleValue> BestKnownQualityParameter { get { return (ILookupParameter<DoubleValue>)Parameters["BestKnownQuality"]; } }
+
         [StorableConstructor]
         protected MatrixTriangulationEvaluator(bool deserializing) : base(deserializing) { }
@@ -49,5 +48,5 @@
           : base()
         {
-            Parameters.Add(new LookupParameter<Permutation>("Permutation", "The TSP solution given in path representation which should be evaluated."));
+            Parameters.Add(new LookupParameter<Permutation>("Permutation", "The LOP solution given in path representation which should be evaluated."));
             Parameters.Add(new LookupParameter<DoubleMatrix>("Matrix", "The matrix which contains the distances between the cities."));
             Parameters.Add(new LookupParameter<Permutation>("BestKnownSolution", "The currently best known solution."));
@@ -58,20 +57,10 @@
         private void AfterDeserialization()
         {
-            // BackwardsCompatibility3.3
-            #region Backwards compatible code (remove with 3.4)
-            LookupParameter<DoubleMatrix> oldDistanceMatrixParameter = Parameters["Matrix"] as LookupParameter<DoubleMatrix>;
-            if (oldDistanceMatrixParameter != null)
-            {
-                Parameters.Remove(oldDistanceMatrixParameter);
-                Parameters.Add(new LookupParameter<DoubleMatrix>("Matrix", "The matrix which contains the distances between the cities."));
-                MatrixParameter.ActualName = oldDistanceMatrixParameter.ActualName;
-            }
-            #endregion
+
         }
 
         public static double Apply(MatrixTriangulationEvaluator evaluator, DoubleMatrix matrix, Permutation permut)
         {
-            double length = evaluator.CalculateUpperTriangle(matrix, permut);
-            return length;
+            return evaluator.CalculateUpperTriangle(matrix, permut);
         }
 
@@ -80,5 +69,5 @@
             Permutation p = PermutationParameter.ActualValue;
             DoubleMatrix c = MatrixParameter.ActualValue;
-            if (c == null) throw new InvalidOperationException("No coordinates were given.");
+            if (c == null) throw new InvalidOperationException("No matrix was given.");
 
             double upperTriangle = CalculateUpperTriangle(c, p);
Index: branches/2864_PermutationProblems/HeuristicLab.Problems.LinearOrdering/3.3/Evaluators/SuperdiagonalMatrixTriangulationEvaluator.cs
===================================================================
--- branches/2864_PermutationProblems/HeuristicLab.Problems.LinearOrdering/3.3/Evaluators/SuperdiagonalMatrixTriangulationEvaluator.cs	(revision 15541)
+++ branches/2864_PermutationProblems/HeuristicLab.Problems.LinearOrdering/3.3/Evaluators/SuperdiagonalMatrixTriangulationEvaluator.cs	(revision 15541)
@@ -0,0 +1,66 @@
+﻿#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.Common;
+using HeuristicLab.Core;
+using HeuristicLab.Data;
+using HeuristicLab.Encodings.PermutationEncoding;
+using HeuristicLab.Persistence.Default.CompositeSerializers.Storable;
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using System.Text;
+using System.Threading.Tasks;
+
+namespace HeuristicLab.Problems.LinearOrdering
+{
+    /// <summary>
+    /// An operator which evaluates LOP solutions given in matrix representation.
+    /// </summary>
+    [Item("SuperdiagonalMatrixTriangulationEvaluator", "An operator which evaluates LOP solutions given in matrix representation.")]
+    [StorableClass]
+    public sealed class SuperdiagonalMatrixTriangulationEvaluator : MatrixTriangulationEvaluator
+    {
+        [StorableConstructor]
+        private SuperdiagonalMatrixTriangulationEvaluator(bool deserializing) : base(deserializing) { }
+        private SuperdiagonalMatrixTriangulationEvaluator(SuperdiagonalMatrixTriangulationEvaluator original, Cloner cloner) : base(original, cloner) { }
+        public SuperdiagonalMatrixTriangulationEvaluator() : base() { }
+
+        public override IDeepCloneable Clone(Cloner cloner)
+        {
+            return new SuperdiagonalMatrixTriangulationEvaluator(this, cloner);
+        }
+
+        protected override double CalculateUpperTriangle(DoubleMatrix m, Permutation p)
+        {
+            double sum = 0;
+            for (int i = 1; i < m.Columns; i++)
+            {
+                for (int j = 0; j < i; j++)
+                {
+                    sum += m[p[j], p[i]];
+                }
+            }
+
+            return sum;
+        }
+    }
+}
Index: branches/2864_PermutationProblems/HeuristicLab.Problems.LinearOrdering/3.3/HeuristicLab.Problems.LinearOrdering-3.3.csproj
===================================================================
--- branches/2864_PermutationProblems/HeuristicLab.Problems.LinearOrdering/3.3/HeuristicLab.Problems.LinearOrdering-3.3.csproj	(revision 15540)
+++ branches/2864_PermutationProblems/HeuristicLab.Problems.LinearOrdering/3.3/HeuristicLab.Problems.LinearOrdering-3.3.csproj	(revision 15541)
@@ -18,5 +18,5 @@
     <DebugType>full</DebugType>
     <Optimize>false</Optimize>
-    <OutputPath>..\..\bin\</OutputPath>
+    <OutputPath>..\..\..\..\trunk\sources\bin\</OutputPath>
     <DefineConstants>DEBUG;TRACE</DefineConstants>
     <ErrorReport>prompt</ErrorReport>
@@ -38,4 +38,43 @@
   </PropertyGroup>
   <ItemGroup>
+    <Reference Include="HeuristicLab.Collections-3.3">
+      <HintPath>..\..\..\..\trunk\sources\bin\HeuristicLab.Collections-3.3.dll</HintPath>
+    </Reference>
+    <Reference Include="HeuristicLab.Common-3.3">
+      <HintPath>..\..\..\..\trunk\sources\bin\HeuristicLab.Common-3.3.dll</HintPath>
+    </Reference>
+    <Reference Include="HeuristicLab.Common.Resources-3.3">
+      <HintPath>..\..\..\..\trunk\sources\bin\HeuristicLab.Common.Resources-3.3.dll</HintPath>
+    </Reference>
+    <Reference Include="HeuristicLab.Core-3.3">
+      <HintPath>..\..\..\..\trunk\sources\bin\HeuristicLab.Core-3.3.dll</HintPath>
+    </Reference>
+    <Reference Include="HeuristicLab.Data-3.3">
+      <HintPath>..\..\..\..\trunk\sources\bin\HeuristicLab.Data-3.3.dll</HintPath>
+    </Reference>
+    <Reference Include="HeuristicLab.Encodings.IntegerVectorEncoding-3.3">
+      <HintPath>..\..\..\..\trunk\sources\bin\HeuristicLab.Encodings.IntegerVectorEncoding-3.3.dll</HintPath>
+    </Reference>
+    <Reference Include="HeuristicLab.Encodings.PermutationEncoding-3.3">
+      <HintPath>..\..\..\..\trunk\sources\bin\HeuristicLab.Encodings.PermutationEncoding-3.3.dll</HintPath>
+    </Reference>
+    <Reference Include="HeuristicLab.Encodings.ScheduleEncoding-3.3">
+      <HintPath>..\..\..\..\trunk\sources\bin\HeuristicLab.Encodings.ScheduleEncoding-3.3.dll</HintPath>
+    </Reference>
+    <Reference Include="HeuristicLab.Operators-3.3">
+      <HintPath>..\..\..\..\trunk\sources\bin\HeuristicLab.Operators-3.3.dll</HintPath>
+    </Reference>
+    <Reference Include="HeuristicLab.Optimization-3.3">
+      <HintPath>..\..\..\..\trunk\sources\bin\HeuristicLab.Optimization-3.3.dll</HintPath>
+    </Reference>
+    <Reference Include="HeuristicLab.Parameters-3.3">
+      <HintPath>..\..\..\..\trunk\sources\bin\HeuristicLab.Parameters-3.3.dll</HintPath>
+    </Reference>
+    <Reference Include="HeuristicLab.Persistence-3.3">
+      <HintPath>..\..\..\..\trunk\sources\bin\HeuristicLab.Persistence-3.3.dll</HintPath>
+    </Reference>
+    <Reference Include="HeuristicLab.PluginInfrastructure-3.3">
+      <HintPath>..\..\..\..\trunk\sources\bin\HeuristicLab.PluginInfrastructure-3.3.dll</HintPath>
+    </Reference>
     <Reference Include="System" />
     <Reference Include="System.Core" />
@@ -49,5 +88,5 @@
   </ItemGroup>
   <ItemGroup>
-    <Compile Include="Evaluators\AwesomeTriangulationEvaluator.cs" />
+    <Compile Include="Evaluators\SuperdiagonalMatrixTriangulationEvaluator.cs" />
     <Compile Include="Evaluators\MatrixTriangulationEvaluator.cs" />
     <Compile Include="Evaluators\LOPEvaluator.cs" />
@@ -59,65 +98,13 @@
   </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>
-    </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>
-    </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>
-    </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>
-    </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>
-    </ProjectReference>
-    <ProjectReference Include="..\..\HeuristicLab.Encodings.IntegerVectorEncoding\3.3\HeuristicLab.Encodings.IntegerVectorEncoding-3.3.csproj">
-      <Project>{DDFB14DD-2A85-493C-A52D-E69729BBAEB0}</Project>
-      <Name>HeuristicLab.Encodings.IntegerVectorEncoding-3.3</Name>
-    </ProjectReference>
-    <ProjectReference Include="..\..\HeuristicLab.Encodings.PermutationEncoding\3.3\HeuristicLab.Encodings.PermutationEncoding-3.3.csproj">
-      <Project>{DBECB8B0-B166-4133-BAF1-ED67C3FD7FCA}</Project>
-      <Name>HeuristicLab.Encodings.PermutationEncoding-3.3</Name>
-    </ProjectReference>
-    <ProjectReference Include="..\..\HeuristicLab.Encodings.ScheduleEncoding\3.3\HeuristicLab.Encodings.ScheduleEncoding-3.3.csproj">
-      <Project>{17F3EF80-B2C3-4B8D-A4D5-BE9CE3BA2606}</Project>
-      <Name>HeuristicLab.Encodings.ScheduleEncoding-3.3</Name>
-    </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>
-    </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>
-    </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>
-    </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>
-    </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>
-    </ProjectReference>
+    <None Include="HeuristicLab.snk" />
+    <None Include="Plugin.cs.frame" />
+    <None Include="Properties\AssemblyInfo.cs.frame" />
+  </ItemGroup>
+  <ItemGroup>
     <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>
     </ProjectReference>
-  </ItemGroup>
-  <ItemGroup>
-    <None Include="HeuristicLab.snk" />
-    <None Include="Plugin.cs.frame" />
-    <None Include="Properties\AssemblyInfo.cs.frame" />
   </ItemGroup>
   <Import Project="$(MSBuildToolsPath)\Microsoft.CSharp.targets" />
Index: branches/2864_PermutationProblems/HeuristicLab.Problems.LinearOrdering/3.3/Interfaces/ILOPEvaluator.cs
===================================================================
--- branches/2864_PermutationProblems/HeuristicLab.Problems.LinearOrdering/3.3/Interfaces/ILOPEvaluator.cs	(revision 15540)
+++ branches/2864_PermutationProblems/HeuristicLab.Problems.LinearOrdering/3.3/Interfaces/ILOPEvaluator.cs	(revision 15541)
@@ -28,5 +28,5 @@
 {
     /// <summary>
-    /// An evaluator for a Schedule
+    /// An evaluator for a Linear Ordering Problem Matrix
     /// </summary>
     public interface ILOPEvaluator : ISingleObjectiveEvaluator { }
Index: branches/2864_PermutationProblems/HeuristicLab.Problems.LinearOrdering/3.3/Interfaces/IMatrixTriangulationEvaluator.cs
===================================================================
--- branches/2864_PermutationProblems/HeuristicLab.Problems.LinearOrdering/3.3/Interfaces/IMatrixTriangulationEvaluator.cs	(revision 15540)
+++ branches/2864_PermutationProblems/HeuristicLab.Problems.LinearOrdering/3.3/Interfaces/IMatrixTriangulationEvaluator.cs	(revision 15541)
@@ -1,3 +1,24 @@
-﻿using HeuristicLab.Core;
+﻿#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.Core;
 using HeuristicLab.Data;
 using HeuristicLab.Encodings.PermutationEncoding;
Index: branches/2864_PermutationProblems/HeuristicLab.Problems.LinearOrdering/3.3/LinearOrderingProblem.cs
===================================================================
--- branches/2864_PermutationProblems/HeuristicLab.Problems.LinearOrdering/3.3/LinearOrderingProblem.cs	(revision 15540)
+++ branches/2864_PermutationProblems/HeuristicLab.Problems.LinearOrdering/3.3/LinearOrderingProblem.cs	(revision 15541)
@@ -21,5 +21,4 @@
 
 using System;
-using System.Drawing;
 using System.Linq;
 using HeuristicLab.Common;
@@ -30,8 +29,8 @@
 using HeuristicLab.Persistence.Default.CompositeSerializers.Storable;
 using HeuristicLab.PluginInfrastructure;
-using HeuristicLab.Problems.Instances;
 using HeuristicLab.Optimization;
 using System.Collections.Generic;
 using HeuristicLab.Problems.Instances.Types;
+using HeuristicLab.Problems.Instances;
 
 namespace HeuristicLab.Problems.LinearOrdering
@@ -60,9 +59,11 @@
 
         #region Parameter Properties
-        public OptionalValueParameter<Permutation> BestKnownSolutionParameter {
+        public OptionalValueParameter<Permutation> BestKnownSolutionParameter
+        {
             get { return (OptionalValueParameter<Permutation>)Parameters["BestKnownSolution"]; }
         }
 
-        public OptionalValueParameter<DoubleMatrix> MatrixParameter {
+        public OptionalValueParameter<DoubleMatrix> MatrixParameter
+        {
             get { return (OptionalValueParameter<DoubleMatrix>)Parameters["Matrix"]; }
         }
@@ -70,12 +71,15 @@
 
         #region Properties
-        public Permutation BestKnownSolution {
+        public Permutation BestKnownSolution
+        {
             get { return BestKnownSolutionParameter.Value; }
-            set {
+            set
+            {
                 BestKnownSolutionParameter.Value = value;
                 if (BestKnownSolutionChanged != null) { OnBestKnownSolutionChanged(); }
             }
         }
-        public DoubleMatrix Matrix {
+        public DoubleMatrix Matrix
+        {
             get { return MatrixParameter.Value; }
             set { MatrixParameter.Value = value; }
@@ -95,7 +99,9 @@
         [Obsolete]
         [Storable(Name = "operators")]
-        private IEnumerable<IOperator> oldOperators {
+        private IEnumerable<IOperator> oldOperators
+        {
             get { return null; }
-            set {
+            set
+            {
                 if (value != null && value.Any())
                     Operators.AddRange(value);
@@ -109,11 +115,10 @@
           : base(original, cloner)
         {
-            RegisterEventHandlers();
         }
         public LinearOrderingProblem()
-          : base(new AwesomeTriangulationEvaluator(), new RandomPermutationCreator())
+          : base(new SuperdiagonalMatrixTriangulationEvaluator(), new RandomPermutationCreator())
         {
             Parameters.Add(new OptionalValueParameter<Permutation>("BestKnownSolution", "The best known solution of this LOP instance."));
-            Parameters.Add(new OptionalValueParameter<DoubleMatrix>("Matrix", "The matrix which contains the jobs,machines and duration."));
+            Parameters.Add(new OptionalValueParameter<DoubleMatrix>("Matrix", "The matrix which contains the corresponding LOP-values"));
 
             Load(DefaultInstance);
@@ -124,11 +129,10 @@
             MaximizationParameter.Hidden = true;
 
-            SolutionCreator.PermutationParameter.ActualName = "PFSPOrder";
-            Evaluator.QualityParameter.ActualName = "Makespan";
+            SolutionCreator.PermutationParameter.ActualName = "LOPOrder";
+            Evaluator.QualityParameter.ActualName = "SuperDiagonale";
             ParameterizeSolutionCreator();
             ParameterizeEvaluator();
 
             InitializeOperators();
-            RegisterEventHandlers();
         }
 
@@ -141,41 +145,5 @@
         private void AfterDeserialization()
         {
-            RegisterEventHandlers();
-        }
-
-        private void RegisterEventHandlers()
-        {
-            SolutionCreator.PermutationParameter.ActualNameChanged += new EventHandler(SolutionCreator_PermutationParameter_ActualNameChanged);
-            Evaluator.QualityParameter.ActualNameChanged += new EventHandler(Evaluator_QualityParameter_ActualNameChanged);
-        }
-
-        private void Evaluator_QualityParameter_ActualNameChanged(object sender, EventArgs e)
-        {
-            //Nothing to do  ParameterizeAnalyzers();
-        }
-
-        private void SolutionCreator_PermutationParameter_ActualNameChanged(object sender, EventArgs e)
-        {
-            ParameterizeEvaluator();
-            //ParameterizeAnalyzers();
-            ParameterizeOperators();
-        }
-
-        #region Events
-        private void ScheduleEvaluator_QualityParameter_ActualNameChanged(object sender, EventArgs eventArgs)
-        {
-            ParameterizeOperators();
-        }
-
-        private void SolutionCreator_SchedulingEncodingParameter_ActualNameChanged(object sender, EventArgs eventArgs)
-        {
-            ParameterizeOperators();
-        }
-
-        private void ScheduleDecoder_ScheduleParameter_ActualNameChanged(object sender, EventArgs eventArgs)
-        {
-            ParameterizeOperators();
-        }
-        #endregion
+        }
 
         #region Problem Instance Handling
@@ -193,5 +161,5 @@
                 if (!permut.Contains(0)) { permut = permut.Select(v => v - 1).ToArray(); }
                 double bestKnownQuality = MatrixTriangulationEvaluator.Apply(
-                    new AwesomeTriangulationEvaluator(),
+                    new SuperdiagonalMatrixTriangulationEvaluator(),
                     new DoubleMatrix(data.Matrix),
                     new Permutation(PermutationTypes.Absolute, permut)
@@ -212,14 +180,8 @@
                 Description = Description,
                 BestKnownQuality = BestKnownQuality.Value,
-                //BestKnownPermutation = Matrix.row,
-                //Machines = Matrix.Columns
+                BestKnownPermutation = BestKnownSolution.ToArray(),
+                Dimension = Matrix.Rows,
+                Matrix = Matrix.CloneAsMatrix()
             };
-            for (int i = 0; i < Matrix.Rows; i++)
-            {
-                for (int j = 0; j < Matrix.Columns; j++)
-                {
-                    //result.ProcessingTimes[i, j] = Matrix[i, j];
-                }
-            }
 
             return result;
@@ -230,13 +192,5 @@
         private void InitializeOperators()
         {
-            var operators = new HashSet<IPermutationOperator>(new IPermutationOperator[] {
-                new OrderCrossover2(),
-                new InversionManipulator(),
-                new StochasticInversionMultiMoveGenerator()
-            }, new TypeEqualityComparer<IPermutationOperator>());
-
-            foreach (var op in ApplicationManager.Manager.GetInstances<IPermutationOperator>())
-                operators.Add(op);
-            Operators.AddRange(operators);
+            Operators.AddRange(ApplicationManager.Manager.GetInstances<IPermutationOperator>());
             ParameterizeOperators();
             UpdateMoveEvaluators();
@@ -294,5 +248,5 @@
         private void ParameterizeSolutionCreator()
         {
-            SolutionCreator.LengthParameter.Value = new IntValue(Matrix.Columns); //Jobs
+            SolutionCreator.LengthParameter.Value = new IntValue(Matrix.Columns);
 
             SolutionCreator.LengthParameter.Hidden = SolutionCreator.LengthParameter.Value != null;
@@ -302,5 +256,5 @@
         private void ParameterizeEvaluator()
         {
-            if (Evaluator is AwesomeTriangulationEvaluator)
+            if (Evaluator is IMatrixTriangulationEvaluator)
             {
                 IMatrixTriangulationEvaluator evaluator = (IMatrixTriangulationEvaluator)Evaluator;
Index: branches/2864_PermutationProblems/HeuristicLab.Problems.LinearOrdering/3.3/Plugin.cs
===================================================================
--- branches/2864_PermutationProblems/HeuristicLab.Problems.LinearOrdering/3.3/Plugin.cs	(revision 15540)
+++ branches/2864_PermutationProblems/HeuristicLab.Problems.LinearOrdering/3.3/Plugin.cs	(revision 15541)
@@ -1,3 +1,24 @@
-﻿using HeuristicLab.PluginInfrastructure;
+﻿#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.LinearOrdering
Index: branches/2864_PermutationProblems/HeuristicLab.Problems.LinearOrdering/3.3/Properties/AssemblyInfo.cs
===================================================================
--- branches/2864_PermutationProblems/HeuristicLab.Problems.LinearOrdering/3.3/Properties/AssemblyInfo.cs	(revision 15540)
+++ branches/2864_PermutationProblems/HeuristicLab.Problems.LinearOrdering/3.3/Properties/AssemblyInfo.cs	(revision 15541)
@@ -1,3 +1,24 @@
-﻿using System.Reflection;
+#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;
 
@@ -33,4 +54,4 @@
 // [assembly: AssemblyVersion("1.0.*")]
 [assembly: AssemblyVersion("3.3.0.0")]
-[assembly: AssemblyFileVersion("3.3.14.14965")]
+[assembly: AssemblyFileVersion("3.3.14.15521")]
 
Index: branches/2864_PermutationProblems/HeuristicLab.Problems.PFSP.Views/3.3/HeuristicLab.Problems.PFSP.Views-3.3.csproj
===================================================================
--- branches/2864_PermutationProblems/HeuristicLab.Problems.PFSP.Views/3.3/HeuristicLab.Problems.PFSP.Views-3.3.csproj	(revision 15540)
+++ branches/2864_PermutationProblems/HeuristicLab.Problems.PFSP.Views/3.3/HeuristicLab.Problems.PFSP.Views-3.3.csproj	(revision 15541)
@@ -19,5 +19,5 @@
     <DebugType>full</DebugType>
     <Optimize>false</Optimize>
-    <OutputPath>$(SolutionDir)\bin\</OutputPath>
+    <OutputPath>..\..\..\..\trunk\sources\bin\</OutputPath>
     <DefineConstants>DEBUG;TRACE</DefineConstants>
     <ErrorReport>prompt</ErrorReport>
@@ -108,4 +108,47 @@
   </PropertyGroup>
   <ItemGroup>
+    <Reference Include="HeuristicLab.Collections-3.3">
+      <HintPath>..\..\..\..\trunk\sources\bin\HeuristicLab.Collections-3.3.dll</HintPath>
+    </Reference>
+    <Reference Include="HeuristicLab.Common-3.3">
+      <HintPath>..\..\..\..\trunk\sources\bin\HeuristicLab.Common-3.3.dll</HintPath>
+    </Reference>
+    <Reference Include="HeuristicLab.Core-3.3">
+      <HintPath>..\..\..\..\trunk\sources\bin\HeuristicLab.Core-3.3.dll</HintPath>
+    </Reference>
+    <Reference Include="HeuristicLab.Core.Views-3.3">
+      <HintPath>..\..\..\..\trunk\sources\bin\HeuristicLab.Core.Views-3.3.dll</HintPath>
+    </Reference>
+    <Reference Include="HeuristicLab.Data-3.3">
+      <HintPath>..\..\..\..\trunk\sources\bin\HeuristicLab.Data-3.3.dll</HintPath>
+    </Reference>
+    <Reference Include="HeuristicLab.Encodings.PermutationEncoding-3.3">
+      <HintPath>..\..\..\..\trunk\sources\bin\HeuristicLab.Encodings.PermutationEncoding-3.3.dll</HintPath>
+    </Reference>
+    <Reference Include="HeuristicLab.Encodings.ScheduleEncoding-3.3">
+      <HintPath>..\..\..\..\trunk\sources\bin\HeuristicLab.Encodings.ScheduleEncoding-3.3.dll</HintPath>
+    </Reference>
+    <Reference Include="HeuristicLab.Encodings.ScheduleEncoding.Views-3.3">
+      <HintPath>..\..\..\..\trunk\sources\bin\HeuristicLab.Encodings.ScheduleEncoding.Views-3.3.dll</HintPath>
+    </Reference>
+    <Reference Include="HeuristicLab.MainForm-3.3">
+      <HintPath>..\..\..\..\trunk\sources\bin\HeuristicLab.MainForm-3.3.dll</HintPath>
+    </Reference>
+    <Reference Include="HeuristicLab.MainForm.WindowsForms-3.3">
+      <HintPath>..\..\..\..\trunk\sources\bin\HeuristicLab.MainForm.WindowsForms-3.3.dll</HintPath>
+    </Reference>
+    <Reference Include="HeuristicLab.Operators-3.3">
+      <HintPath>..\..\..\..\trunk\sources\bin\HeuristicLab.Operators-3.3.dll</HintPath>
+    </Reference>
+    <Reference Include="HeuristicLab.Optimization-3.3">
+      <HintPath>..\..\..\..\trunk\sources\bin\HeuristicLab.Optimization-3.3.dll</HintPath>
+    </Reference>
+    <Reference Include="HeuristicLab.Optimization.Views-3.3">
+      <HintPath>..\..\..\..\trunk\sources\bin\HeuristicLab.Optimization.Views-3.3.dll</HintPath>
+    </Reference>
+    <Reference Include="HeuristicLab.PluginInfrastructure-3.3, Version=3.3.0.0, Culture=neutral, PublicKeyToken=ba48961d6f65dcec, processorArchitecture=MSIL" />
+    <Reference Include="HeuristicLab.Problems.Instances-3.3">
+      <HintPath>..\..\..\..\trunk\sources\bin\HeuristicLab.Problems.Instances-3.3.dll</HintPath>
+    </Reference>
     <Reference Include="System" />
     <Reference Include="System.Core" />
@@ -116,5 +159,7 @@
   </ItemGroup>
   <ItemGroup>
-    <Compile Include="JobShopSchedulingProblemView.cs" />
+    <Compile Include="JobShopSchedulingProblemView.cs">
+      <SubType>UserControl</SubType>
+    </Compile>
     <Compile Include="JobShopSchedulingProblemView.Designer.cs">
       <DependentUpon>JobShopSchedulingProblemView.cs</DependentUpon>
@@ -129,83 +174,7 @@
   </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\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.Views\3.3\HeuristicLab.Core.Views-3.3.csproj">
-      <Project>{E226881D-315F-423D-B419-A766FE0D8685}</Project>
-      <Name>HeuristicLab.Core.Views-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>
-    </ProjectReference>
-    <ProjectReference Include="..\..\HeuristicLab.Encodings.PermutationEncoding\3.3\HeuristicLab.Encodings.PermutationEncoding-3.3.csproj">
-      <Project>{DBECB8B0-B166-4133-BAF1-ED67C3FD7FCA}</Project>
-      <Name>HeuristicLab.Encodings.PermutationEncoding-3.3</Name>
-    </ProjectReference>
-    <ProjectReference Include="..\..\HeuristicLab.Encodings.ScheduleEncoding.Views\3.3\HeuristicLab.Encodings.ScheduleEncoding.Views-3.3.csproj">
-      <Project>{0C378762-D5DB-488A-8931-2BA42B1B7CBF}</Project>
-      <Name>HeuristicLab.Encodings.ScheduleEncoding.Views-3.3</Name>
-      <Private>False</Private>
-    </ProjectReference>
-    <ProjectReference Include="..\..\HeuristicLab.Encodings.ScheduleEncoding\3.3\HeuristicLab.Encodings.ScheduleEncoding-3.3.csproj">
-      <Project>{17F3EF80-B2C3-4B8D-A4D5-BE9CE3BA2606}</Project>
-      <Name>HeuristicLab.Encodings.ScheduleEncoding-3.3</Name>
-      <Private>False</Private>
-    </ProjectReference>
-    <ProjectReference Include="..\..\HeuristicLab.MainForm.WindowsForms\3.3\HeuristicLab.MainForm.WindowsForms-3.3.csproj">
-      <Project>{AB687BBE-1BFE-476B-906D-44237135431D}</Project>
-      <Name>HeuristicLab.MainForm.WindowsForms-3.3</Name>
-      <Private>False</Private>
-    </ProjectReference>
-    <ProjectReference Include="..\..\HeuristicLab.MainForm\3.3\HeuristicLab.MainForm-3.3.csproj">
-      <Project>{3BD61258-31DA-4B09-89C0-4F71FEF5F05A}</Project>
-      <Name>HeuristicLab.MainForm-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>
-    </ProjectReference>
-    <ProjectReference Include="..\..\HeuristicLab.Optimization.Views\3.3\HeuristicLab.Optimization.Views-3.3.csproj">
-      <Project>{662B4B15-8F4D-4AE5-B3EB-D91C215F5AF2}</Project>
-      <Name>HeuristicLab.Optimization.Views-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.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>
-    </ProjectReference>
     <ProjectReference Include="..\..\HeuristicLab.Problems.PFSP\3.3\HeuristicLab.Problems.PFSP-3.3.csproj">
       <Project>{51650b00-4ca6-41ff-8cb6-165fcacc3b51}</Project>
       <Name>HeuristicLab.Problems.PFSP-3.3</Name>
-    </ProjectReference>
-    <ProjectReference Include="..\..\HeuristicLab.Problems.Scheduling\3.3\HeuristicLab.Problems.Scheduling-3.3.csproj">
-      <Project>{2BF1D639-1A74-44ED-AAAD-41ECD395AD93}</Project>
-      <Name>HeuristicLab.Problems.Scheduling-3.3</Name>
-      <Private>False</Private>
     </ProjectReference>
   </ItemGroup>
Index: branches/2864_PermutationProblems/HeuristicLab.Problems.PFSP.Views/3.3/JobShopSchedulingProblemView.cs
===================================================================
--- branches/2864_PermutationProblems/HeuristicLab.Problems.PFSP.Views/3.3/JobShopSchedulingProblemView.cs	(revision 15540)
+++ branches/2864_PermutationProblems/HeuristicLab.Problems.PFSP.Views/3.3/JobShopSchedulingProblemView.cs	(revision 15541)
@@ -31,5 +31,5 @@
 namespace HeuristicLab.Problems.PFSP.Views
 {
-    [View("JobShop Scheduling Problem View")]
+    [View("Permutation Flowshop Scheduling Problem View")]
     [Content(typeof(PermutationFlowshopSchedulingProblem), true)]
     public partial class JobShopSchedulingProblemView : ProblemView
Index: branches/2864_PermutationProblems/HeuristicLab.Problems.PFSP.Views/3.3/Plugin.cs
===================================================================
--- branches/2864_PermutationProblems/HeuristicLab.Problems.PFSP.Views/3.3/Plugin.cs	(revision 15540)
+++ branches/2864_PermutationProblems/HeuristicLab.Problems.PFSP.Views/3.3/Plugin.cs	(revision 15541)
@@ -23,5 +23,5 @@
 
 namespace HeuristicLab.Problems.PFSP.Views {
-  [Plugin("HeuristicLab.Problems.PFSP.Views", "3.3.14.14190")]
+  [Plugin("HeuristicLab.Problems.PFSP.Views", "3.3.14.15521")]
   [PluginFile("HeuristicLab.Problems.PFSP.Views-3.3.dll", PluginFileType.Assembly)]
   [PluginDependency("HeuristicLab.Collections", "3.3")]
Index: branches/2864_PermutationProblems/HeuristicLab.Problems.PFSP.Views/3.3/Properties/AssemblyInfo.cs
===================================================================
--- branches/2864_PermutationProblems/HeuristicLab.Problems.PFSP.Views/3.3/Properties/AssemblyInfo.cs	(revision 15540)
+++ branches/2864_PermutationProblems/HeuristicLab.Problems.PFSP.Views/3.3/Properties/AssemblyInfo.cs	(revision 15541)
@@ -41,5 +41,5 @@
 
 // The following GUID is for the ID of the typelib if this project is exposed to COM
-[assembly: Guid("ABF1DB5E-5774-48AB-B65A-5CF405C0E2A9")]
+[assembly: Guid("ABF1DB5E-5774-48AB-B65A-5CF405C0E2A8")]
 
 // Version information for an assembly consists of the following four values:
@@ -53,3 +53,3 @@
 // by using the '*' as shown below:
 [assembly: AssemblyVersion("3.3.0.0")]
-[assembly: AssemblyFileVersion("3.3.14.14190")]
+[assembly: AssemblyFileVersion("3.3.14.15521")]
Index: branches/2864_PermutationProblems/HeuristicLab.Problems.PFSP/3.3/Evaluators/CmaxMakeSpanEvaluator.cs
===================================================================
--- branches/2864_PermutationProblems/HeuristicLab.Problems.PFSP/3.3/Evaluators/CmaxMakeSpanEvaluator.cs	(revision 15541)
+++ branches/2864_PermutationProblems/HeuristicLab.Problems.PFSP/3.3/Evaluators/CmaxMakeSpanEvaluator.cs	(revision 15541)
@@ -0,0 +1,101 @@
+﻿#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.Common;
+using HeuristicLab.Core;
+using HeuristicLab.Data;
+using HeuristicLab.Encodings.PermutationEncoding;
+using HeuristicLab.Persistence.Default.CompositeSerializers.Storable;
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using System.Text;
+using System.Threading.Tasks;
+
+namespace HeuristicLab.Problems.PFSP
+{ /// <summary>
+  /// An operator which evaluates PFSP solutions given in path representation using the rounded Euclidean distance metric.
+  /// </summary>
+    [Item("CmaxMakeSpanEvaluator", "An operator which evaluates PFSP solutions given in matrix representation using Cmax")]
+    [StorableClass]
+    public sealed class CmaxMakeSpanEvaluator : MakeSpanEvaluator
+    {
+        [StorableConstructor]
+        private CmaxMakeSpanEvaluator(bool deserializing) : base(deserializing) { }
+        private CmaxMakeSpanEvaluator(CmaxMakeSpanEvaluator original, Cloner cloner) : base(original, cloner) { }
+        public CmaxMakeSpanEvaluator() : base() { }
+
+        public override IDeepCloneable Clone(Cloner cloner)
+        {
+            return new CmaxMakeSpanEvaluator(this, cloner);
+        }
+
+        protected override double CalculateMakespan(DoubleMatrix m, Permutation p)
+        {
+            DoubleMatrix calculatedTime = new DoubleMatrix(m.Rows, m.Columns);
+            double runtimeCur;
+            double runtimePrev = 0;
+
+            double runtimePrevMachine;
+            double runtimePrevJobOnThisMachine;
+
+            int[] permutation = p.ToArray();
+
+            for (var machineIdx = 0; machineIdx < m.Rows; machineIdx++)
+            {
+                for (var jobIdx = 0; jobIdx < m.Columns; jobIdx++)
+                {
+                    runtimeCur = m[machineIdx, permutation[jobIdx]];
+                    runtimePrev = 0;
+
+                    //Simply add to calculatedTimeMatrix
+                    if (jobIdx == 0 && machineIdx == 0)
+                    {
+                        //Take default (runtimePrev = 0)
+                    }
+                    //Add the time + the previous time
+                    else if (machineIdx == 0)
+                    {
+                        runtimePrev = calculatedTime[machineIdx, jobIdx - 1];
+                    }
+                    //Check the job-time from the previous machine and previos job and take the greater
+                    else if (jobIdx == 0)
+                    {
+                        runtimePrev = calculatedTime[machineIdx - 1, jobIdx];
+                    }
+                    //X X X X X
+                    //X O O O O
+                    //X O O O O
+                    //X O O O O
+                    else
+                    {
+                        runtimePrevMachine = calculatedTime[machineIdx - 1, jobIdx];
+                        runtimePrevJobOnThisMachine = calculatedTime[machineIdx, jobIdx - 1];
+                        runtimePrev = runtimePrevMachine > runtimePrevJobOnThisMachine ? runtimePrevMachine : runtimePrevJobOnThisMachine;
+                    }
+                    calculatedTime[machineIdx, jobIdx] = runtimeCur + runtimePrev;
+                }
+            }
+            //return the makespan(the total runtime from start till the last job is finished)
+            return calculatedTime[calculatedTime.Rows - 1, calculatedTime.Columns - 1];
+        }
+    }
+}
Index: branches/2864_PermutationProblems/HeuristicLab.Problems.PFSP/3.3/Evaluators/MakeSpanEvaluator.cs
===================================================================
--- branches/2864_PermutationProblems/HeuristicLab.Problems.PFSP/3.3/Evaluators/MakeSpanEvaluator.cs	(revision 15540)
+++ branches/2864_PermutationProblems/HeuristicLab.Problems.PFSP/3.3/Evaluators/MakeSpanEvaluator.cs	(revision 15541)
@@ -31,12 +31,10 @@
 {
     /// <summary>
-    /// A base class for operators which evaluate TSP solutions given in path representation using city coordinates.
+    /// A base class for operators which evaluate PFSP solutions given in matrix representation
     /// </summary>
-    [Item("MakeSpanEvaluator", "A base class for operators which evaluate TSP solutions given in path representation using city coordinates.")]
+    [Item("MakeSpanEvaluator", "A base class for operators which evaluate PFSP solutions given in matrix representation.")]
     [StorableClass]
     public abstract class MakeSpanEvaluator : PFSPEvaluator, IMakespanEvaluator
     {
-        private object locker = new object();
-
         public ILookupParameter<Permutation> PermutationParameter { get { return (ILookupParameter<Permutation>)Parameters["Permutation"]; } }
         public ILookupParameter<JobMatrix> JobMatrixParameter { get { return (ILookupParameter<JobMatrix>)Parameters["JobMatrix"]; } }
@@ -49,6 +47,6 @@
           : base()
         {
-            Parameters.Add(new LookupParameter<Permutation>("Permutation", "The TSP solution given in path representation which should be evaluated."));
-            Parameters.Add(new LookupParameter<JobMatrix>("JobMatrix", "The matrix which contains the distances between the cities."));
+            Parameters.Add(new LookupParameter<Permutation>("Permutation", "The PFSP solution given in matrix representation which should be evaluated."));
+            Parameters.Add(new LookupParameter<JobMatrix>("JobMatrix", "The matrix which contains the job-duration on the machines."));
             Parameters.Add(new LookupParameter<Permutation>("BestKnownSolution", "The currently best known solution."));
             Parameters.Add(new LookupParameter<DoubleValue>("BestKnownQuality", "The currently best known quality."));
@@ -56,22 +54,9 @@
 
         [StorableHook(HookType.AfterDeserialization)]
-        private void AfterDeserialization()
-        {
-            // BackwardsCompatibility3.3
-            #region Backwards compatible code (remove with 3.4)
-            LookupParameter<DoubleMatrix> oldDistanceMatrixParameter = Parameters["JobMatrix"] as LookupParameter<DoubleMatrix>;
-            if (oldDistanceMatrixParameter != null)
-            {
-                Parameters.Remove(oldDistanceMatrixParameter);
-                Parameters.Add(new LookupParameter<JobMatrix>("JobMatrix", "The matrix which contains the distances between the cities."));
-                JobMatrixParameter.ActualName = oldDistanceMatrixParameter.ActualName;
-            }
-            #endregion
-        }
+        private void AfterDeserialization() { }
 
         public static double Apply(MakeSpanEvaluator evaluator, DoubleMatrix matrix, Permutation tour)
         {
-            double length = evaluator.CalculateMakespan(matrix, tour);
-            return length;
+            return evaluator.CalculateMakespan(matrix, tour);
         }
 
@@ -80,5 +65,5 @@
             Permutation p = PermutationParameter.ActualValue;
             DoubleMatrix c = JobMatrixParameter.ActualValue;
-            if (c == null) throw new InvalidOperationException("No coordinates were given.");
+            if (c == null) throw new InvalidOperationException("No matrix was given.");
 
             double makespan = CalculateMakespan(c, p);
@@ -93,5 +78,5 @@
         }
 
-        protected abstract double CalculateMakespan(DoubleMatrix matrix, Permutation tour);
+        protected abstract double CalculateMakespan(DoubleMatrix matrix, Permutation perm);
     }
 }
Index: branches/2864_PermutationProblems/HeuristicLab.Problems.PFSP/3.3/Evaluators/PFSPEvaluator.cs
===================================================================
--- branches/2864_PermutationProblems/HeuristicLab.Problems.PFSP/3.3/Evaluators/PFSPEvaluator.cs	(revision 15540)
+++ branches/2864_PermutationProblems/HeuristicLab.Problems.PFSP/3.3/Evaluators/PFSPEvaluator.cs	(revision 15541)
@@ -30,7 +30,7 @@
 {
     /// <summary>
-    /// A base class for operators which evaluate TSP solutions.
+    /// A base class for operators which evaluate PFSP solutions.
     /// </summary>
-    [Item("PFSPEvaluator", "A base class for operators which evaluate TSP solutions.")]
+    [Item("PFSPEvaluator", "A base class for operators which evaluate PFSP solutions.")]
     [StorableClass]
     public abstract class PFSPEvaluator : InstrumentedOperator, IPFSPEvaluator
@@ -52,5 +52,5 @@
           : base()
         {
-            Parameters.Add(new LookupParameter<DoubleValue>("Quality", "The evaluated quality of the TSP solution."));
+            Parameters.Add(new LookupParameter<DoubleValue>("Quality", "The evaluated quality of the PFSP solution."));
         }
     }
Index: branches/2864_PermutationProblems/HeuristicLab.Problems.PFSP/3.3/HeuristicLab.Problems.PFSP-3.3.csproj
===================================================================
--- branches/2864_PermutationProblems/HeuristicLab.Problems.PFSP/3.3/HeuristicLab.Problems.PFSP-3.3.csproj	(revision 15540)
+++ branches/2864_PermutationProblems/HeuristicLab.Problems.PFSP/3.3/HeuristicLab.Problems.PFSP-3.3.csproj	(revision 15541)
@@ -18,5 +18,5 @@
     <DebugType>full</DebugType>
     <Optimize>false</Optimize>
-    <OutputPath>..\..\bin\</OutputPath>
+    <OutputPath>..\..\..\..\trunk\sources\bin\</OutputPath>
     <DefineConstants>DEBUG;TRACE</DefineConstants>
     <ErrorReport>prompt</ErrorReport>
@@ -38,4 +38,43 @@
   </PropertyGroup>
   <ItemGroup>
+    <Reference Include="HeuristicLab.Collections-3.3">
+      <HintPath>..\..\..\..\trunk\sources\bin\HeuristicLab.Collections-3.3.dll</HintPath>
+    </Reference>
+    <Reference Include="HeuristicLab.Common-3.3">
+      <HintPath>..\..\..\..\trunk\sources\bin\HeuristicLab.Common-3.3.dll</HintPath>
+    </Reference>
+    <Reference Include="HeuristicLab.Common.Resources-3.3">
+      <HintPath>..\..\..\..\trunk\sources\bin\HeuristicLab.Common.Resources-3.3.dll</HintPath>
+    </Reference>
+    <Reference Include="HeuristicLab.Core-3.3">
+      <HintPath>..\..\..\..\trunk\sources\bin\HeuristicLab.Core-3.3.dll</HintPath>
+    </Reference>
+    <Reference Include="HeuristicLab.Data-3.3">
+      <HintPath>..\..\..\..\trunk\sources\bin\HeuristicLab.Data-3.3.dll</HintPath>
+    </Reference>
+    <Reference Include="HeuristicLab.Encodings.IntegerVectorEncoding-3.3">
+      <HintPath>..\..\..\..\trunk\sources\bin\HeuristicLab.Encodings.IntegerVectorEncoding-3.3.dll</HintPath>
+    </Reference>
+    <Reference Include="HeuristicLab.Encodings.PermutationEncoding-3.3">
+      <HintPath>..\..\..\..\trunk\sources\bin\HeuristicLab.Encodings.PermutationEncoding-3.3.dll</HintPath>
+    </Reference>
+    <Reference Include="HeuristicLab.Encodings.ScheduleEncoding.Views-3.3">
+      <HintPath>..\..\..\..\trunk\sources\bin\HeuristicLab.Encodings.ScheduleEncoding.Views-3.3.dll</HintPath>
+    </Reference>
+    <Reference Include="HeuristicLab.Operators-3.3">
+      <HintPath>..\..\..\..\trunk\sources\bin\HeuristicLab.Operators-3.3.dll</HintPath>
+    </Reference>
+    <Reference Include="HeuristicLab.Optimization-3.3">
+      <HintPath>..\..\..\..\trunk\sources\bin\HeuristicLab.Optimization-3.3.dll</HintPath>
+    </Reference>
+    <Reference Include="HeuristicLab.Parameters-3.3">
+      <HintPath>..\..\..\..\trunk\sources\bin\HeuristicLab.Parameters-3.3.dll</HintPath>
+    </Reference>
+    <Reference Include="HeuristicLab.Persistence-3.3">
+      <HintPath>..\..\..\..\trunk\sources\bin\HeuristicLab.Persistence-3.3.dll</HintPath>
+    </Reference>
+    <Reference Include="HeuristicLab.PluginInfrastructure-3.3">
+      <HintPath>..\..\..\..\trunk\sources\bin\HeuristicLab.PluginInfrastructure-3.3.dll</HintPath>
+    </Reference>
     <Reference Include="System" />
     <Reference Include="System.Core" />
@@ -49,6 +88,5 @@
   </ItemGroup>
   <ItemGroup>
-    <Compile Include="Analyzers\BestPFSPSolutionAnalyzer.cs" />
-    <Compile Include="Evaluators\AwesomeMakeSpanEvaluator.cs" />
+    <Compile Include="Evaluators\CmaxMakeSpanEvaluator.cs" />
     <Compile Include="Evaluators\MakeSpanEvaluator.cs" />
     <Compile Include="Evaluators\PFSPEvaluator.cs" />
@@ -61,66 +99,15 @@
   </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>
-    </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>
-    </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>
-    </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>
-    </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>
-    </ProjectReference>
-    <ProjectReference Include="..\..\HeuristicLab.Encodings.IntegerVectorEncoding\3.3\HeuristicLab.Encodings.IntegerVectorEncoding-3.3.csproj">
-      <Project>{DDFB14DD-2A85-493C-A52D-E69729BBAEB0}</Project>
-      <Name>HeuristicLab.Encodings.IntegerVectorEncoding-3.3</Name>
-    </ProjectReference>
-    <ProjectReference Include="..\..\HeuristicLab.Encodings.PermutationEncoding\3.3\HeuristicLab.Encodings.PermutationEncoding-3.3.csproj">
-      <Project>{DBECB8B0-B166-4133-BAF1-ED67C3FD7FCA}</Project>
-      <Name>HeuristicLab.Encodings.PermutationEncoding-3.3</Name>
-    </ProjectReference>
-    <ProjectReference Include="..\..\HeuristicLab.Encodings.ScheduleEncoding\3.3\HeuristicLab.Encodings.ScheduleEncoding-3.3.csproj">
-      <Project>{17F3EF80-B2C3-4B8D-A4D5-BE9CE3BA2606}</Project>
-      <Name>HeuristicLab.Encodings.ScheduleEncoding-3.3</Name>
-    </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>
-    </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>
-    </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>
-    </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>
-    </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>
-    </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>
-    </ProjectReference>
-  </ItemGroup>
-  <ItemGroup>
     <None Include="HeuristicLab.snk" />
     <None Include="Plugin.cs.frame" />
     <None Include="Properties\AssemblyInfo.cs.frame" />
   </ItemGroup>
+  <ItemGroup>
+    <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>
+    </ProjectReference>
+  </ItemGroup>
+  <ItemGroup />
   <Import Project="$(MSBuildToolsPath)\Microsoft.CSharp.targets" />
   <PropertyGroup>
Index: branches/2864_PermutationProblems/HeuristicLab.Problems.PFSP/3.3/Interfaces/IMakespanEvaluator.cs
===================================================================
--- branches/2864_PermutationProblems/HeuristicLab.Problems.PFSP/3.3/Interfaces/IMakespanEvaluator.cs	(revision 15540)
+++ branches/2864_PermutationProblems/HeuristicLab.Problems.PFSP/3.3/Interfaces/IMakespanEvaluator.cs	(revision 15541)
@@ -1,3 +1,24 @@
-﻿using HeuristicLab.Core;
+﻿#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.Core;
 using HeuristicLab.Data;
 using HeuristicLab.Encodings.PermutationEncoding;
Index: branches/2864_PermutationProblems/HeuristicLab.Problems.PFSP/3.3/JobMatrix.cs
===================================================================
--- branches/2864_PermutationProblems/HeuristicLab.Problems.PFSP/3.3/JobMatrix.cs	(revision 15540)
+++ branches/2864_PermutationProblems/HeuristicLab.Problems.PFSP/3.3/JobMatrix.cs	(revision 15541)
@@ -27,26 +27,31 @@
 using HeuristicLab.Persistence.Default.CompositeSerializers.Storable;
 
-namespace HeuristicLab.Problems.PFSP {
-  [Item("JobMatrix", "Represents a matrix of a PFSP.")]
-  [StorableClass]
-  public sealed class JobMatrix : DoubleMatrix {
-    [StorableConstructor]
-    private JobMatrix(bool deserializing) : base(deserializing) { }
-    private JobMatrix(JobMatrix original, Cloner cloner) {
-      throw new NotSupportedException("Distance matrices cannot be cloned.");
+namespace HeuristicLab.Problems.PFSP
+{
+    [Item("JobMatrix", "Represents a matrix of a PFSP.")]
+    [StorableClass]
+    public sealed class JobMatrix : DoubleMatrix
+    {
+        [StorableConstructor]
+        private JobMatrix(bool deserializing) : base(deserializing) { }
+        private JobMatrix(JobMatrix original, Cloner cloner)
+        {
+            throw new NotSupportedException("Job matrices cannot be cloned.");
+        }
+
+        public JobMatrix() : base() { }
+        public JobMatrix(int rows, int columns) : base(rows, columns) { }
+        public JobMatrix(int rows, int columns, IEnumerable<string> columnNames) : base(rows, columns, columnNames) { }
+        public JobMatrix(int rows, int columns, IEnumerable<string> columnNames, IEnumerable<string> rowNames) : base(rows, columns, columnNames, rowNames) { }
+        public JobMatrix(double[,] elements) : base(elements) { }
+        public JobMatrix(double[,] elements, IEnumerable<string> columnNames) : base(elements, columnNames) { }
+        public JobMatrix(double[,] elements, IEnumerable<string> columnNames, IEnumerable<string> rowNames) : base(elements, columnNames, rowNames) { }
+
+        public override IDeepCloneable Clone(Cloner cloner)
+        {
+            // job matrices are not cloned for performance reasons
+            cloner.RegisterClonedObject(this, this);
+            return this;
+        }
     }
-    public JobMatrix() : base() { }
-    public JobMatrix(int rows, int columns) : base(rows, columns) { }
-    public JobMatrix(int rows, int columns, IEnumerable<string> columnNames) : base(rows, columns, columnNames) { }
-    public JobMatrix(int rows, int columns, IEnumerable<string> columnNames, IEnumerable<string> rowNames) : base(rows, columns, columnNames, rowNames) { }
-    public JobMatrix(double[,] elements) : base(elements) { }
-    public JobMatrix(double[,] elements, IEnumerable<string> columnNames) : base(elements, columnNames) { }
-    public JobMatrix(double[,] elements, IEnumerable<string> columnNames, IEnumerable<string> rowNames) : base(elements, columnNames, rowNames) { }
-
-    public override IDeepCloneable Clone(Cloner cloner) {
-      // distance matrices are not cloned for performance reasons
-      cloner.RegisterClonedObject(this, this);
-      return this;
-    }
-  }
 }
Index: branches/2864_PermutationProblems/HeuristicLab.Problems.PFSP/3.3/PermutationFlowshopSchedulingProblem.cs
===================================================================
--- branches/2864_PermutationProblems/HeuristicLab.Problems.PFSP/3.3/PermutationFlowshopSchedulingProblem.cs	(revision 15540)
+++ branches/2864_PermutationProblems/HeuristicLab.Problems.PFSP/3.3/PermutationFlowshopSchedulingProblem.cs	(revision 15541)
@@ -97,19 +97,4 @@
         }
 
-        // BackwardsCompatibility3.3
-        #region Backwards compatible code, remove with 3.4
-        [Obsolete]
-        [Storable(Name = "operators")]
-        private IEnumerable<IOperator> oldOperators
-        {
-            get { return null; }
-            set
-            {
-                if (value != null && value.Any())
-                    Operators.AddRange(value);
-            }
-        }
-        #endregion
-
         [StorableConstructor]
         private PermutationFlowshopSchedulingProblem(bool deserializing) : base(deserializing) { }
@@ -117,8 +102,7 @@
           : base(original, cloner)
         {
-            RegisterEventHandlers();
         }
         public PermutationFlowshopSchedulingProblem()
-          : base(new AwesomeMakeSpanEvaluator(), new RandomPermutationCreator())
+          : base(new CmaxMakeSpanEvaluator(), new RandomPermutationCreator())
         {
             Parameters.Add(new OptionalValueParameter<Permutation>("BestKnownSolution", "The best known solution of this FSSP instance."));
@@ -138,5 +122,4 @@
 
             InitializeOperators();
-            RegisterEventHandlers();
         }
 
@@ -147,43 +130,5 @@
 
         [StorableHook(HookType.AfterDeserialization)]
-        private void AfterDeserialization()
-        {
-            RegisterEventHandlers();
-        }
-
-        private void RegisterEventHandlers()
-        {
-            SolutionCreator.PermutationParameter.ActualNameChanged += new EventHandler(SolutionCreator_PermutationParameter_ActualNameChanged);
-            Evaluator.QualityParameter.ActualNameChanged += new EventHandler(Evaluator_QualityParameter_ActualNameChanged);
-        }
-
-        private void Evaluator_QualityParameter_ActualNameChanged(object sender, EventArgs e)
-        {
-            //Nothing to do  ParameterizeAnalyzers();
-        }
-
-        private void SolutionCreator_PermutationParameter_ActualNameChanged(object sender, EventArgs e)
-        {
-            ParameterizeEvaluator();
-            //ParameterizeAnalyzers();
-            ParameterizeOperators();
-        }
-
-        #region Events
-        private void ScheduleEvaluator_QualityParameter_ActualNameChanged(object sender, EventArgs eventArgs)
-        {
-            ParameterizeOperators();
-        }
-
-        private void SolutionCreator_SchedulingEncodingParameter_ActualNameChanged(object sender, EventArgs eventArgs)
-        {
-            ParameterizeOperators();
-        }
-
-        private void ScheduleDecoder_ScheduleParameter_ActualNameChanged(object sender, EventArgs eventArgs)
-        {
-            ParameterizeOperators();
-        }
-        #endregion
+        private void AfterDeserialization() { }
 
         #region Problem Instance Handling
@@ -202,5 +147,5 @@
                 if (!permut.Contains(0)) { permut = permut.Select(v => v - 1).ToArray(); }
                 double bestKnownQuality = MakeSpanEvaluator.Apply(
-                    new AwesomeMakeSpanEvaluator(),
+                    new CmaxMakeSpanEvaluator(),
                     new DoubleMatrix(data.ProcessingTimes),
                     new Permutation(PermutationTypes.Absolute, permut)
@@ -213,5 +158,4 @@
             ParameterizeSolutionCreator();
         }
-
         public FSSPData Export()
         {
@@ -251,19 +195,7 @@
         private void InitializeOperators()
         {
-            var operators = new HashSet<IPermutationOperator>(new IPermutationOperator[] {
-                new OrderCrossover2(),
-                new InversionManipulator(),
-                new StochasticInversionMultiMoveGenerator()
-            }, new TypeEqualityComparer<IPermutationOperator>());
-
-            foreach (var op in ApplicationManager.Manager.GetInstances<IPermutationOperator>())
-                operators.Add(op);
-            Operators.AddRange(operators);
-            Operators.Add(new BestTSPSolutionAnalyzer());
+            Operators.AddRange(ApplicationManager.Manager.GetInstances<IPermutationOperator>());
             ParameterizeOperators();
-            UpdateMoveEvaluators();
-        }
-
-
+        }
         private void ParameterizeOperators()
         {
@@ -306,19 +238,7 @@
             }
         }
-        #endregion
-
-        private void UpdateMoveEvaluators()
-        {
-            Operators.RemoveAll(x => x is ISingleObjectiveMoveEvaluator);
-            foreach (var op in ApplicationManager.Manager.GetInstances<ISingleObjectiveMoveEvaluator>())
-                Operators.Add(op);
-
-            ParameterizeOperators();
-            OnOperatorsChanged();
-        }
-
         private void ParameterizeSolutionCreator()
         {
-            SolutionCreator.LengthParameter.Value = new IntValue(JobMatrix.Columns); //Jobs
+            SolutionCreator.LengthParameter.Value = new IntValue(JobMatrix.Columns);
 
             SolutionCreator.LengthParameter.Hidden = SolutionCreator.LengthParameter.Value != null;
@@ -328,5 +248,5 @@
         private void ParameterizeEvaluator()
         {
-            if (Evaluator is AwesomeMakeSpanEvaluator)
+            if (Evaluator is CmaxMakeSpanEvaluator)
             {
                 IMakespanEvaluator evaluator = (IMakespanEvaluator)Evaluator;
@@ -335,4 +255,5 @@
             }
         }
+        #endregion
     }
 }
Index: branches/2864_PermutationProblems/HeuristicLab.Problems.PFSP/3.3/Plugin.cs
===================================================================
--- branches/2864_PermutationProblems/HeuristicLab.Problems.PFSP/3.3/Plugin.cs	(revision 15540)
+++ branches/2864_PermutationProblems/HeuristicLab.Problems.PFSP/3.3/Plugin.cs	(revision 15541)
@@ -1,3 +1,24 @@
-﻿using HeuristicLab.PluginInfrastructure;
+﻿#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.PFSP
Index: branches/2864_PermutationProblems/HeuristicLab.Problems.PFSP/3.3/Properties/AssemblyInfo.cs
===================================================================
--- branches/2864_PermutationProblems/HeuristicLab.Problems.PFSP/3.3/Properties/AssemblyInfo.cs	(revision 15540)
+++ branches/2864_PermutationProblems/HeuristicLab.Problems.PFSP/3.3/Properties/AssemblyInfo.cs	(revision 15541)
@@ -1,3 +1,24 @@
-﻿using System.Reflection;
+#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;
 
@@ -33,4 +54,4 @@
 // [assembly: AssemblyVersion("1.0.*")]
 [assembly: AssemblyVersion("3.3.0.0")]
-[assembly: AssemblyFileVersion("3.3.14.14965")]
+[assembly: AssemblyFileVersion("3.3.14.15521")]
 
Index: branches/2864_PermutationProblems/PermutationProblems.sln
===================================================================
--- branches/2864_PermutationProblems/PermutationProblems.sln	(revision 15540)
+++ branches/2864_PermutationProblems/PermutationProblems.sln	(revision 15541)
@@ -11,4 +11,8 @@
 EndProject
 Project("{FAE04EC0-301F-11D3-BF4B-00C04F79EFBC}") = "HeuristicLab.Problems.PFSP.Views-3.3", "HeuristicLab.Problems.PFSP.Views\3.3\HeuristicLab.Problems.PFSP.Views-3.3.csproj", "{F53AECD6-061C-4A62-B2DB-51E36EECBB79}"
+EndProject
+Project("{FAE04EC0-301F-11D3-BF4B-00C04F79EFBC}") = "HeuristicLab.Problems.Instances.LinearOrdering-3.3", "HeuristicLab.Problems.Instances.LinearOrdering\3.3\HeuristicLab.Problems.Instances.LinearOrdering-3.3.csproj", "{648F0BF0-6301-448C-816F-DEB1E65EC73F}"
+EndProject
+Project("{FAE04EC0-301F-11D3-BF4B-00C04F79EFBC}") = "HeuristicLab.Problems.Instances-3.3", "HeuristicLab.Problems.Instances\3.3\HeuristicLab.Problems.Instances-3.3.csproj", "{3540E29E-4793-49E7-8EE2-FEA7F61C3994}"
 EndProject
 Global
@@ -70,4 +74,28 @@
 		{F53AECD6-061C-4A62-B2DB-51E36EECBB79}.Release|x86.ActiveCfg = Release|x86
 		{F53AECD6-061C-4A62-B2DB-51E36EECBB79}.Release|x86.Build.0 = Release|x86
+		{648F0BF0-6301-448C-816F-DEB1E65EC73F}.Debug|Any CPU.ActiveCfg = Debug|Any CPU
+		{648F0BF0-6301-448C-816F-DEB1E65EC73F}.Debug|Any CPU.Build.0 = Debug|Any CPU
+		{648F0BF0-6301-448C-816F-DEB1E65EC73F}.Debug|x64.ActiveCfg = Debug|Any CPU
+		{648F0BF0-6301-448C-816F-DEB1E65EC73F}.Debug|x64.Build.0 = Debug|Any CPU
+		{648F0BF0-6301-448C-816F-DEB1E65EC73F}.Debug|x86.ActiveCfg = Debug|Any CPU
+		{648F0BF0-6301-448C-816F-DEB1E65EC73F}.Debug|x86.Build.0 = Debug|Any CPU
+		{648F0BF0-6301-448C-816F-DEB1E65EC73F}.Release|Any CPU.ActiveCfg = Release|Any CPU
+		{648F0BF0-6301-448C-816F-DEB1E65EC73F}.Release|Any CPU.Build.0 = Release|Any CPU
+		{648F0BF0-6301-448C-816F-DEB1E65EC73F}.Release|x64.ActiveCfg = Release|Any CPU
+		{648F0BF0-6301-448C-816F-DEB1E65EC73F}.Release|x64.Build.0 = Release|Any CPU
+		{648F0BF0-6301-448C-816F-DEB1E65EC73F}.Release|x86.ActiveCfg = Release|Any CPU
+		{648F0BF0-6301-448C-816F-DEB1E65EC73F}.Release|x86.Build.0 = Release|Any CPU
+		{3540E29E-4793-49E7-8EE2-FEA7F61C3994}.Debug|Any CPU.ActiveCfg = Debug|Any CPU
+		{3540E29E-4793-49E7-8EE2-FEA7F61C3994}.Debug|Any CPU.Build.0 = Debug|Any CPU
+		{3540E29E-4793-49E7-8EE2-FEA7F61C3994}.Debug|x64.ActiveCfg = Debug|x64
+		{3540E29E-4793-49E7-8EE2-FEA7F61C3994}.Debug|x64.Build.0 = Debug|x64
+		{3540E29E-4793-49E7-8EE2-FEA7F61C3994}.Debug|x86.ActiveCfg = Debug|x86
+		{3540E29E-4793-49E7-8EE2-FEA7F61C3994}.Debug|x86.Build.0 = Debug|x86
+		{3540E29E-4793-49E7-8EE2-FEA7F61C3994}.Release|Any CPU.ActiveCfg = Release|Any CPU
+		{3540E29E-4793-49E7-8EE2-FEA7F61C3994}.Release|Any CPU.Build.0 = Release|Any CPU
+		{3540E29E-4793-49E7-8EE2-FEA7F61C3994}.Release|x64.ActiveCfg = Release|x64
+		{3540E29E-4793-49E7-8EE2-FEA7F61C3994}.Release|x64.Build.0 = Release|x64
+		{3540E29E-4793-49E7-8EE2-FEA7F61C3994}.Release|x86.ActiveCfg = Release|x86
+		{3540E29E-4793-49E7-8EE2-FEA7F61C3994}.Release|x86.Build.0 = Release|x86
 	EndGlobalSection
 	GlobalSection(SolutionProperties) = preSolution
