Index: stable/HeuristicLab.ExtLibs/HeuristicLab.SimSharp/3.0.11/HeuristicLab.SimSharp-3.0.11/HeuristicLab.SimSharp-3.0.11.csproj
===================================================================
--- stable/HeuristicLab.ExtLibs/HeuristicLab.SimSharp/3.0.11/HeuristicLab.SimSharp-3.0.11/HeuristicLab.SimSharp-3.0.11.csproj	(revision 16281)
+++ stable/HeuristicLab.ExtLibs/HeuristicLab.SimSharp/3.0.11/HeuristicLab.SimSharp-3.0.11/HeuristicLab.SimSharp-3.0.11.csproj	(revision 16281)
@@ -0,0 +1,128 @@
+﻿<?xml version="1.0" encoding="utf-8"?>
+<Project ToolsVersion="12.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>{5C93CAF7-AE6A-4540-95B2-5DA6761A2677}</ProjectGuid>
+    <OutputType>Library</OutputType>
+    <AppDesignerFolder>Properties</AppDesignerFolder>
+    <RootNamespace>HeuristicLab.SimSharp</RootNamespace>
+    <AssemblyName>HeuristicLab.SimSharp-3.0.11</AssemblyName>
+    <TargetFrameworkVersion>v4.5</TargetFrameworkVersion>
+    <FileAlignment>512</FileAlignment>
+    <SignAssembly>true</SignAssembly>
+    <AssemblyOriginatorKeyFile>HeuristicLab.snk</AssemblyOriginatorKeyFile>
+  </PropertyGroup>
+  <PropertyGroup Condition=" '$(Configuration)|$(Platform)' == 'Debug|AnyCPU' ">
+    <DebugSymbols>true</DebugSymbols>
+    <DebugType>full</DebugType>
+    <Optimize>false</Optimize>
+    <OutputPath>$(SolutionDir)\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>$(SolutionDir)\bin\</OutputPath>
+    <DefineConstants>TRACE</DefineConstants>
+    <ErrorReport>prompt</ErrorReport>
+    <WarningLevel>4</WarningLevel>
+  </PropertyGroup>
+  <PropertyGroup Condition="'$(Configuration)|$(Platform)' == 'Debug|x64'">
+    <DebugSymbols>true</DebugSymbols>
+    <OutputPath>$(SolutionDir)\bin\</OutputPath>
+    <DefineConstants>DEBUG;TRACE</DefineConstants>
+    <DebugType>full</DebugType>
+    <PlatformTarget>x64</PlatformTarget>
+    <ErrorReport>prompt</ErrorReport>
+    <CodeAnalysisRuleSet>MinimumRecommendedRules.ruleset</CodeAnalysisRuleSet>
+  </PropertyGroup>
+  <PropertyGroup Condition="'$(Configuration)|$(Platform)' == 'Release|x64'">
+    <OutputPath>$(SolutionDir)\bin\</OutputPath>
+    <DefineConstants>TRACE</DefineConstants>
+    <Optimize>true</Optimize>
+    <DebugType>pdbonly</DebugType>
+    <PlatformTarget>x64</PlatformTarget>
+    <ErrorReport>prompt</ErrorReport>
+    <CodeAnalysisRuleSet>MinimumRecommendedRules.ruleset</CodeAnalysisRuleSet>
+  </PropertyGroup>
+  <PropertyGroup Condition="'$(Configuration)|$(Platform)' == 'Debug|x86'">
+    <DebugSymbols>true</DebugSymbols>
+    <OutputPath>$(SolutionDir)\bin\</OutputPath>
+    <DefineConstants>DEBUG;TRACE</DefineConstants>
+    <DebugType>full</DebugType>
+    <PlatformTarget>x86</PlatformTarget>
+    <ErrorReport>prompt</ErrorReport>
+    <CodeAnalysisRuleSet>MinimumRecommendedRules.ruleset</CodeAnalysisRuleSet>
+  </PropertyGroup>
+  <PropertyGroup Condition="'$(Configuration)|$(Platform)' == 'Release|x86'">
+    <OutputPath>$(SolutionDir)\bin\</OutputPath>
+    <DefineConstants>TRACE</DefineConstants>
+    <Optimize>true</Optimize>
+    <DebugType>pdbonly</DebugType>
+    <PlatformTarget>x86</PlatformTarget>
+    <ErrorReport>prompt</ErrorReport>
+    <CodeAnalysisRuleSet>MinimumRecommendedRules.ruleset</CodeAnalysisRuleSet>
+  </PropertyGroup>
+  <ItemGroup>
+    <Reference Include="System" />
+    <Reference Include="System.Core" />
+    <Reference Include="System.Xml.Linq" />
+    <Reference Include="System.Data.DataSetExtensions" />
+    <Reference Include="Microsoft.CSharp" />
+    <Reference Include="System.Data" />
+    <Reference Include="System.Xml" />
+  </ItemGroup>
+  <ItemGroup>
+    <None Include="Plugin.cs.frame" />
+    <Compile Include="Plugin.cs" />
+    <None Include="Properties\AssemblyInfo.cs.frame" />
+    <Compile Include="Properties\AssemblyInfo.cs" />
+  </ItemGroup>
+  <ItemGroup>
+    <None Include="HeuristicLab.snk" />
+  </ItemGroup>
+  <ItemGroup>
+    <ProjectReference Include="..\..\..\..\HeuristicLab.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="..\SimSharp-3.0.11\SimSharp-3.0.11.csproj">
+      <Project>{9fe9c740-7859-4d01-ad07-7d4e15a6320b}</Project>
+      <Name>SimSharp-3.0.11</Name>
+    </ProjectReference>
+  </ItemGroup>
+  <ItemGroup>
+    <Content Include="SimSharp-3.0.11 License.txt">
+      <CopyToOutputDirectory>PreserveNewest</CopyToOutputDirectory>
+    </Content>
+  </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>
+  <!-- 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: stable/HeuristicLab.ExtLibs/HeuristicLab.SimSharp/3.0.11/HeuristicLab.SimSharp-3.0.11/Plugin.cs.frame
===================================================================
--- stable/HeuristicLab.ExtLibs/HeuristicLab.SimSharp/3.0.11/HeuristicLab.SimSharp-3.0.11/Plugin.cs.frame	(revision 16281)
+++ stable/HeuristicLab.ExtLibs/HeuristicLab.SimSharp/3.0.11/HeuristicLab.SimSharp-3.0.11/Plugin.cs.frame	(revision 16281)
@@ -0,0 +1,31 @@
+﻿#region License Information
+/* HeuristicLab
+ * Copyright (C) 2002-2018 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.SimSharp {
+  [Plugin("HeuristicLab.SimSharp", "Transport plugin for the simulation framework Sim#", "3.0.11.$WCREV$")]
+  [PluginFile("HeuristicLab.SimSharp-3.0.11.dll", PluginFileType.Assembly)]
+  [PluginFile("SimSharp-3.0.11.dll", PluginFileType.Assembly)]
+  [PluginFile("SimSharp-3.0.11 License.txt", PluginFileType.License)]
+  public class HeuristicLabSimSharpPlugin : PluginBase {
+  }
+}
Index: stable/HeuristicLab.ExtLibs/HeuristicLab.SimSharp/3.0.11/HeuristicLab.SimSharp-3.0.11/Properties/AssemblyInfo.cs.frame
===================================================================
--- stable/HeuristicLab.ExtLibs/HeuristicLab.SimSharp/3.0.11/HeuristicLab.SimSharp-3.0.11/Properties/AssemblyInfo.cs.frame	(revision 16281)
+++ stable/HeuristicLab.ExtLibs/HeuristicLab.SimSharp/3.0.11/HeuristicLab.SimSharp-3.0.11/Properties/AssemblyInfo.cs.frame	(revision 16281)
@@ -0,0 +1,35 @@
+﻿using System.Reflection;
+using System.Runtime.InteropServices;
+
+// General Information about an assembly is controlled through the following 
+// set of attributes. Change these attribute values to modify the information
+// associated with an assembly.
+[assembly: AssemblyTitle("HeuristicLab.SimSharp-3.0.11")]
+[assembly: AssemblyDescription("Transport plugin for the simulation framework Sim#")]
+[assembly: AssemblyConfiguration("")]
+[assembly: AssemblyCompany("HEAL")]
+[assembly: AssemblyProduct("HeuristicLab")]
+[assembly: AssemblyCopyright("(c) 2002-2018 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("15bc80f5-e0b9-4481-bab1-289d1403f877")]
+
+// 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.0.11.0")]
+[assembly: AssemblyFileVersion("3.0.11.$WCREV$")]
Index: stable/HeuristicLab.ExtLibs/HeuristicLab.SimSharp/3.0.11/HeuristicLab.SimSharp-3.0.11/SimSharp-3.0.11 License.txt
===================================================================
--- stable/HeuristicLab.ExtLibs/HeuristicLab.SimSharp/3.0.11/HeuristicLab.SimSharp-3.0.11/SimSharp-3.0.11 License.txt	(revision 16281)
+++ stable/HeuristicLab.ExtLibs/HeuristicLab.SimSharp/3.0.11/HeuristicLab.SimSharp-3.0.11/SimSharp-3.0.11 License.txt	(revision 16281)
@@ -0,0 +1,705 @@
+Sim# integrates code from a third-party "BlueRaja". Below the license from that
+third party provider as well as Sim#'s own license are given.
+Sim# also uses FastRandom from Colin Green (sharpneat@gmail.com) which is also
+licensed under the GPL. 
+
+=== License of BlueRaja's Event Queue ===
+
+The MIT License (MIT)
+
+Copyright (c) 2013 Daniel "BlueRaja" Pflughoeft
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in
+all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+THE SOFTWARE.
+
+=== License of SimSharp and FastRandom ===
+
+                    GNU GENERAL PUBLIC LICENSE
+                       Version 3, 29 June 2007
+
+ Copyright (C) 2007 Free Software Foundation, Inc. <http://fsf.org/>
+ Everyone is permitted to copy and distribute verbatim copies
+ of this license document, but changing it is not allowed.
+
+                            Preamble
+
+  The GNU General Public License is a free, copyleft license for
+software and other kinds of works.
+
+  The licenses for most software and other practical works are designed
+to take away your freedom to share and change the works.  By contrast,
+the GNU General Public License is intended to guarantee your freedom to
+share and change all versions of a program--to make sure it remains free
+software for all its users.  We, the Free Software Foundation, use the
+GNU General Public License for most of our software; it applies also to
+any other work released this way by its authors.  You can apply it to
+your programs, too.
+
+  When we speak of free software, we are referring to freedom, not
+price.  Our General Public Licenses are designed to make sure that you
+have the freedom to distribute copies of free software (and charge for
+them if you wish), that you receive source code or can get it if you
+want it, that you can change the software or use pieces of it in new
+free programs, and that you know you can do these things.
+
+  To protect your rights, we need to prevent others from denying you
+these rights or asking you to surrender the rights.  Therefore, you have
+certain responsibilities if you distribute copies of the software, or if
+you modify it: responsibilities to respect the freedom of others.
+
+  For example, if you distribute copies of such a program, whether
+gratis or for a fee, you must pass on to the recipients the same
+freedoms that you received.  You must make sure that they, too, receive
+or can get the source code.  And you must show them these terms so they
+know their rights.
+
+  Developers that use the GNU GPL protect your rights with two steps:
+(1) assert copyright on the software, and (2) offer you this License
+giving you legal permission to copy, distribute and/or modify it.
+
+  For the developers' and authors' protection, the GPL clearly explains
+that there is no warranty for this free software.  For both users' and
+authors' sake, the GPL requires that modified versions be marked as
+changed, so that their problems will not be attributed erroneously to
+authors of previous versions.
+
+  Some devices are designed to deny users access to install or run
+modified versions of the software inside them, although the manufacturer
+can do so.  This is fundamentally incompatible with the aim of
+protecting users' freedom to change the software.  The systematic
+pattern of such abuse occurs in the area of products for individuals to
+use, which is precisely where it is most unacceptable.  Therefore, we
+have designed this version of the GPL to prohibit the practice for those
+products.  If such problems arise substantially in other domains, we
+stand ready to extend this provision to those domains in future versions
+of the GPL, as needed to protect the freedom of users.
+
+  Finally, every program is threatened constantly by software patents.
+States should not allow patents to restrict development and use of
+software on general-purpose computers, but in those that do, we wish to
+avoid the special danger that patents applied to a free program could
+make it effectively proprietary.  To prevent this, the GPL assures that
+patents cannot be used to render the program non-free.
+
+  The precise terms and conditions for copying, distribution and
+modification follow.
+
+                       TERMS AND CONDITIONS
+
+  0. Definitions.
+
+  "This License" refers to version 3 of the GNU General Public License.
+
+  "Copyright" also means copyright-like laws that apply to other kinds of
+works, such as semiconductor masks.
+
+  "The Program" refers to any copyrightable work licensed under this
+License.  Each licensee is addressed as "you".  "Licensees" and
+"recipients" may be individuals or organizations.
+
+  To "modify" a work means to copy from or adapt all or part of the work
+in a fashion requiring copyright permission, other than the making of an
+exact copy.  The resulting work is called a "modified version" of the
+earlier work or a work "based on" the earlier work.
+
+  A "covered work" means either the unmodified Program or a work based
+on the Program.
+
+  To "propagate" a work means to do anything with it that, without
+permission, would make you directly or secondarily liable for
+infringement under applicable copyright law, except executing it on a
+computer or modifying a private copy.  Propagation includes copying,
+distribution (with or without modification), making available to the
+public, and in some countries other activities as well.
+
+  To "convey" a work means any kind of propagation that enables other
+parties to make or receive copies.  Mere interaction with a user through
+a computer network, with no transfer of a copy, is not conveying.
+
+  An interactive user interface displays "Appropriate Legal Notices"
+to the extent that it includes a convenient and prominently visible
+feature that (1) displays an appropriate copyright notice, and (2)
+tells the user that there is no warranty for the work (except to the
+extent that warranties are provided), that licensees may convey the
+work under this License, and how to view a copy of this License.  If
+the interface presents a list of user commands or options, such as a
+menu, a prominent item in the list meets this criterion.
+
+  1. Source Code.
+
+  The "source code" for a work means the preferred form of the work
+for making modifications to it.  "Object code" means any non-source
+form of a work.
+
+  A "Standard Interface" means an interface that either is an official
+standard defined by a recognized standards body, or, in the case of
+interfaces specified for a particular programming language, one that
+is widely used among developers working in that language.
+
+  The "System Libraries" of an executable work include anything, other
+than the work as a whole, that (a) is included in the normal form of
+packaging a Major Component, but which is not part of that Major
+Component, and (b) serves only to enable use of the work with that
+Major Component, or to implement a Standard Interface for which an
+implementation is available to the public in source code form.  A
+"Major Component", in this context, means a major essential component
+(kernel, window system, and so on) of the specific operating system
+(if any) on which the executable work runs, or a compiler used to
+produce the work, or an object code interpreter used to run it.
+
+  The "Corresponding Source" for a work in object code form means all
+the source code needed to generate, install, and (for an executable
+work) run the object code and to modify the work, including scripts to
+control those activities.  However, it does not include the work's
+System Libraries, or general-purpose tools or generally available free
+programs which are used unmodified in performing those activities but
+which are not part of the work.  For example, Corresponding Source
+includes interface definition files associated with source files for
+the work, and the source code for shared libraries and dynamically
+linked subprograms that the work is specifically designed to require,
+such as by intimate data communication or control flow between those
+subprograms and other parts of the work.
+
+  The Corresponding Source need not include anything that users
+can regenerate automatically from other parts of the Corresponding
+Source.
+
+  The Corresponding Source for a work in source code form is that
+same work.
+
+  2. Basic Permissions.
+
+  All rights granted under this License are granted for the term of
+copyright on the Program, and are irrevocable provided the stated
+conditions are met.  This License explicitly affirms your unlimited
+permission to run the unmodified Program.  The output from running a
+covered work is covered by this License only if the output, given its
+content, constitutes a covered work.  This License acknowledges your
+rights of fair use or other equivalent, as provided by copyright law.
+
+  You may make, run and propagate covered works that you do not
+convey, without conditions so long as your license otherwise remains
+in force.  You may convey covered works to others for the sole purpose
+of having them make modifications exclusively for you, or provide you
+with facilities for running those works, provided that you comply with
+the terms of this License in conveying all material for which you do
+not control copyright.  Those thus making or running the covered works
+for you must do so exclusively on your behalf, under your direction
+and control, on terms that prohibit them from making any copies of
+your copyrighted material outside their relationship with you.
+
+  Conveying under any other circumstances is permitted solely under
+the conditions stated below.  Sublicensing is not allowed; section 10
+makes it unnecessary.
+
+  3. Protecting Users' Legal Rights From Anti-Circumvention Law.
+
+  No covered work shall be deemed part of an effective technological
+measure under any applicable law fulfilling obligations under article
+11 of the WIPO copyright treaty adopted on 20 December 1996, or
+similar laws prohibiting or restricting circumvention of such
+measures.
+
+  When you convey a covered work, you waive any legal power to forbid
+circumvention of technological measures to the extent such circumvention
+is effected by exercising rights under this License with respect to
+the covered work, and you disclaim any intention to limit operation or
+modification of the work as a means of enforcing, against the work's
+users, your or third parties' legal rights to forbid circumvention of
+technological measures.
+
+  4. Conveying Verbatim Copies.
+
+  You may convey verbatim copies of the Program's source code as you
+receive it, in any medium, provided that you conspicuously and
+appropriately publish on each copy an appropriate copyright notice;
+keep intact all notices stating that this License and any
+non-permissive terms added in accord with section 7 apply to the code;
+keep intact all notices of the absence of any warranty; and give all
+recipients a copy of this License along with the Program.
+
+  You may charge any price or no price for each copy that you convey,
+and you may offer support or warranty protection for a fee.
+
+  5. Conveying Modified Source Versions.
+
+  You may convey a work based on the Program, or the modifications to
+produce it from the Program, in the form of source code under the
+terms of section 4, provided that you also meet all of these conditions:
+
+    a) The work must carry prominent notices stating that you modified
+    it, and giving a relevant date.
+
+    b) The work must carry prominent notices stating that it is
+    released under this License and any conditions added under section
+    7.  This requirement modifies the requirement in section 4 to
+    "keep intact all notices".
+
+    c) You must license the entire work, as a whole, under this
+    License to anyone who comes into possession of a copy.  This
+    License will therefore apply, along with any applicable section 7
+    additional terms, to the whole of the work, and all its parts,
+    regardless of how they are packaged.  This License gives no
+    permission to license the work in any other way, but it does not
+    invalidate such permission if you have separately received it.
+
+    d) If the work has interactive user interfaces, each must display
+    Appropriate Legal Notices; however, if the Program has interactive
+    interfaces that do not display Appropriate Legal Notices, your
+    work need not make them do so.
+
+  A compilation of a covered work with other separate and independent
+works, which are not by their nature extensions of the covered work,
+and which are not combined with it such as to form a larger program,
+in or on a volume of a storage or distribution medium, is called an
+"aggregate" if the compilation and its resulting copyright are not
+used to limit the access or legal rights of the compilation's users
+beyond what the individual works permit.  Inclusion of a covered work
+in an aggregate does not cause this License to apply to the other
+parts of the aggregate.
+
+  6. Conveying Non-Source Forms.
+
+  You may convey a covered work in object code form under the terms
+of sections 4 and 5, provided that you also convey the
+machine-readable Corresponding Source under the terms of this License,
+in one of these ways:
+
+    a) Convey the object code in, or embodied in, a physical product
+    (including a physical distribution medium), accompanied by the
+    Corresponding Source fixed on a durable physical medium
+    customarily used for software interchange.
+
+    b) Convey the object code in, or embodied in, a physical product
+    (including a physical distribution medium), accompanied by a
+    written offer, valid for at least three years and valid for as
+    long as you offer spare parts or customer support for that product
+    model, to give anyone who possesses the object code either (1) a
+    copy of the Corresponding Source for all the software in the
+    product that is covered by this License, on a durable physical
+    medium customarily used for software interchange, for a price no
+    more than your reasonable cost of physically performing this
+    conveying of source, or (2) access to copy the
+    Corresponding Source from a network server at no charge.
+
+    c) Convey individual copies of the object code with a copy of the
+    written offer to provide the Corresponding Source.  This
+    alternative is allowed only occasionally and noncommercially, and
+    only if you received the object code with such an offer, in accord
+    with subsection 6b.
+
+    d) Convey the object code by offering access from a designated
+    place (gratis or for a charge), and offer equivalent access to the
+    Corresponding Source in the same way through the same place at no
+    further charge.  You need not require recipients to copy the
+    Corresponding Source along with the object code.  If the place to
+    copy the object code is a network server, the Corresponding Source
+    may be on a different server (operated by you or a third party)
+    that supports equivalent copying facilities, provided you maintain
+    clear directions next to the object code saying where to find the
+    Corresponding Source.  Regardless of what server hosts the
+    Corresponding Source, you remain obligated to ensure that it is
+    available for as long as needed to satisfy these requirements.
+
+    e) Convey the object code using peer-to-peer transmission, provided
+    you inform other peers where the object code and Corresponding
+    Source of the work are being offered to the general public at no
+    charge under subsection 6d.
+
+  A separable portion of the object code, whose source code is excluded
+from the Corresponding Source as a System Library, need not be
+included in conveying the object code work.
+
+  A "User Product" is either (1) a "consumer product", which means any
+tangible personal property which is normally used for personal, family,
+or household purposes, or (2) anything designed or sold for incorporation
+into a dwelling.  In determining whether a product is a consumer product,
+doubtful cases shall be resolved in favor of coverage.  For a particular
+product received by a particular user, "normally used" refers to a
+typical or common use of that class of product, regardless of the status
+of the particular user or of the way in which the particular user
+actually uses, or expects or is expected to use, the product.  A product
+is a consumer product regardless of whether the product has substantial
+commercial, industrial or non-consumer uses, unless such uses represent
+the only significant mode of use of the product.
+
+  "Installation Information" for a User Product means any methods,
+procedures, authorization keys, or other information required to install
+and execute modified versions of a covered work in that User Product from
+a modified version of its Corresponding Source.  The information must
+suffice to ensure that the continued functioning of the modified object
+code is in no case prevented or interfered with solely because
+modification has been made.
+
+  If you convey an object code work under this section in, or with, or
+specifically for use in, a User Product, and the conveying occurs as
+part of a transaction in which the right of possession and use of the
+User Product is transferred to the recipient in perpetuity or for a
+fixed term (regardless of how the transaction is characterized), the
+Corresponding Source conveyed under this section must be accompanied
+by the Installation Information.  But this requirement does not apply
+if neither you nor any third party retains the ability to install
+modified object code on the User Product (for example, the work has
+been installed in ROM).
+
+  The requirement to provide Installation Information does not include a
+requirement to continue to provide support service, warranty, or updates
+for a work that has been modified or installed by the recipient, or for
+the User Product in which it has been modified or installed.  Access to a
+network may be denied when the modification itself materially and
+adversely affects the operation of the network or violates the rules and
+protocols for communication across the network.
+
+  Corresponding Source conveyed, and Installation Information provided,
+in accord with this section must be in a format that is publicly
+documented (and with an implementation available to the public in
+source code form), and must require no special password or key for
+unpacking, reading or copying.
+
+  7. Additional Terms.
+
+  "Additional permissions" are terms that supplement the terms of this
+License by making exceptions from one or more of its conditions.
+Additional permissions that are applicable to the entire Program shall
+be treated as though they were included in this License, to the extent
+that they are valid under applicable law.  If additional permissions
+apply only to part of the Program, that part may be used separately
+under those permissions, but the entire Program remains governed by
+this License without regard to the additional permissions.
+
+  When you convey a copy of a covered work, you may at your option
+remove any additional permissions from that copy, or from any part of
+it.  (Additional permissions may be written to require their own
+removal in certain cases when you modify the work.)  You may place
+additional permissions on material, added by you to a covered work,
+for which you have or can give appropriate copyright permission.
+
+  Notwithstanding any other provision of this License, for material you
+add to a covered work, you may (if authorized by the copyright holders of
+that material) supplement the terms of this License with terms:
+
+    a) Disclaiming warranty or limiting liability differently from the
+    terms of sections 15 and 16 of this License; or
+
+    b) Requiring preservation of specified reasonable legal notices or
+    author attributions in that material or in the Appropriate Legal
+    Notices displayed by works containing it; or
+
+    c) Prohibiting misrepresentation of the origin of that material, or
+    requiring that modified versions of such material be marked in
+    reasonable ways as different from the original version; or
+
+    d) Limiting the use for publicity purposes of names of licensors or
+    authors of the material; or
+
+    e) Declining to grant rights under trademark law for use of some
+    trade names, trademarks, or service marks; or
+
+    f) Requiring indemnification of licensors and authors of that
+    material by anyone who conveys the material (or modified versions of
+    it) with contractual assumptions of liability to the recipient, for
+    any liability that these contractual assumptions directly impose on
+    those licensors and authors.
+
+  All other non-permissive additional terms are considered "further
+restrictions" within the meaning of section 10.  If the Program as you
+received it, or any part of it, contains a notice stating that it is
+governed by this License along with a term that is a further
+restriction, you may remove that term.  If a license document contains
+a further restriction but permits relicensing or conveying under this
+License, you may add to a covered work material governed by the terms
+of that license document, provided that the further restriction does
+not survive such relicensing or conveying.
+
+  If you add terms to a covered work in accord with this section, you
+must place, in the relevant source files, a statement of the
+additional terms that apply to those files, or a notice indicating
+where to find the applicable terms.
+
+  Additional terms, permissive or non-permissive, may be stated in the
+form of a separately written license, or stated as exceptions;
+the above requirements apply either way.
+
+  8. Termination.
+
+  You may not propagate or modify a covered work except as expressly
+provided under this License.  Any attempt otherwise to propagate or
+modify it is void, and will automatically terminate your rights under
+this License (including any patent licenses granted under the third
+paragraph of section 11).
+
+  However, if you cease all violation of this License, then your
+license from a particular copyright holder is reinstated (a)
+provisionally, unless and until the copyright holder explicitly and
+finally terminates your license, and (b) permanently, if the copyright
+holder fails to notify you of the violation by some reasonable means
+prior to 60 days after the cessation.
+
+  Moreover, your license from a particular copyright holder is
+reinstated permanently if the copyright holder notifies you of the
+violation by some reasonable means, this is the first time you have
+received notice of violation of this License (for any work) from that
+copyright holder, and you cure the violation prior to 30 days after
+your receipt of the notice.
+
+  Termination of your rights under this section does not terminate the
+licenses of parties who have received copies or rights from you under
+this License.  If your rights have been terminated and not permanently
+reinstated, you do not qualify to receive new licenses for the same
+material under section 10.
+
+  9. Acceptance Not Required for Having Copies.
+
+  You are not required to accept this License in order to receive or
+run a copy of the Program.  Ancillary propagation of a covered work
+occurring solely as a consequence of using peer-to-peer transmission
+to receive a copy likewise does not require acceptance.  However,
+nothing other than this License grants you permission to propagate or
+modify any covered work.  These actions infringe copyright if you do
+not accept this License.  Therefore, by modifying or propagating a
+covered work, you indicate your acceptance of this License to do so.
+
+  10. Automatic Licensing of Downstream Recipients.
+
+  Each time you convey a covered work, the recipient automatically
+receives a license from the original licensors, to run, modify and
+propagate that work, subject to this License.  You are not responsible
+for enforcing compliance by third parties with this License.
+
+  An "entity transaction" is a transaction transferring control of an
+organization, or substantially all assets of one, or subdividing an
+organization, or merging organizations.  If propagation of a covered
+work results from an entity transaction, each party to that
+transaction who receives a copy of the work also receives whatever
+licenses to the work the party's predecessor in interest had or could
+give under the previous paragraph, plus a right to possession of the
+Corresponding Source of the work from the predecessor in interest, if
+the predecessor has it or can get it with reasonable efforts.
+
+  You may not impose any further restrictions on the exercise of the
+rights granted or affirmed under this License.  For example, you may
+not impose a license fee, royalty, or other charge for exercise of
+rights granted under this License, and you may not initiate litigation
+(including a cross-claim or counterclaim in a lawsuit) alleging that
+any patent claim is infringed by making, using, selling, offering for
+sale, or importing the Program or any portion of it.
+
+  11. Patents.
+
+  A "contributor" is a copyright holder who authorizes use under this
+License of the Program or a work on which the Program is based.  The
+work thus licensed is called the contributor's "contributor version".
+
+  A contributor's "essential patent claims" are all patent claims
+owned or controlled by the contributor, whether already acquired or
+hereafter acquired, that would be infringed by some manner, permitted
+by this License, of making, using, or selling its contributor version,
+but do not include claims that would be infringed only as a
+consequence of further modification of the contributor version.  For
+purposes of this definition, "control" includes the right to grant
+patent sublicenses in a manner consistent with the requirements of
+this License.
+
+  Each contributor grants you a non-exclusive, worldwide, royalty-free
+patent license under the contributor's essential patent claims, to
+make, use, sell, offer for sale, import and otherwise run, modify and
+propagate the contents of its contributor version.
+
+  In the following three paragraphs, a "patent license" is any express
+agreement or commitment, however denominated, not to enforce a patent
+(such as an express permission to practice a patent or covenant not to
+sue for patent infringement).  To "grant" such a patent license to a
+party means to make such an agreement or commitment not to enforce a
+patent against the party.
+
+  If you convey a covered work, knowingly relying on a patent license,
+and the Corresponding Source of the work is not available for anyone
+to copy, free of charge and under the terms of this License, through a
+publicly available network server or other readily accessible means,
+then you must either (1) cause the Corresponding Source to be so
+available, or (2) arrange to deprive yourself of the benefit of the
+patent license for this particular work, or (3) arrange, in a manner
+consistent with the requirements of this License, to extend the patent
+license to downstream recipients.  "Knowingly relying" means you have
+actual knowledge that, but for the patent license, your conveying the
+covered work in a country, or your recipient's use of the covered work
+in a country, would infringe one or more identifiable patents in that
+country that you have reason to believe are valid.
+
+  If, pursuant to or in connection with a single transaction or
+arrangement, you convey, or propagate by procuring conveyance of, a
+covered work, and grant a patent license to some of the parties
+receiving the covered work authorizing them to use, propagate, modify
+or convey a specific copy of the covered work, then the patent license
+you grant is automatically extended to all recipients of the covered
+work and works based on it.
+
+  A patent license is "discriminatory" if it does not include within
+the scope of its coverage, prohibits the exercise of, or is
+conditioned on the non-exercise of one or more of the rights that are
+specifically granted under this License.  You may not convey a covered
+work if you are a party to an arrangement with a third party that is
+in the business of distributing software, under which you make payment
+to the third party based on the extent of your activity of conveying
+the work, and under which the third party grants, to any of the
+parties who would receive the covered work from you, a discriminatory
+patent license (a) in connection with copies of the covered work
+conveyed by you (or copies made from those copies), or (b) primarily
+for and in connection with specific products or compilations that
+contain the covered work, unless you entered into that arrangement,
+or that patent license was granted, prior to 28 March 2007.
+
+  Nothing in this License shall be construed as excluding or limiting
+any implied license or other defenses to infringement that may
+otherwise be available to you under applicable patent law.
+
+  12. No Surrender of Others' Freedom.
+
+  If conditions are imposed on you (whether by court order, agreement or
+otherwise) that contradict the conditions of this License, they do not
+excuse you from the conditions of this License.  If you cannot convey a
+covered work so as to satisfy simultaneously your obligations under this
+License and any other pertinent obligations, then as a consequence you may
+not convey it at all.  For example, if you agree to terms that obligate you
+to collect a royalty for further conveying from those to whom you convey
+the Program, the only way you could satisfy both those terms and this
+License would be to refrain entirely from conveying the Program.
+
+  13. Use with the GNU Affero General Public License.
+
+  Notwithstanding any other provision of this License, you have
+permission to link or combine any covered work with a work licensed
+under version 3 of the GNU Affero General Public License into a single
+combined work, and to convey the resulting work.  The terms of this
+License will continue to apply to the part which is the covered work,
+but the special requirements of the GNU Affero General Public License,
+section 13, concerning interaction through a network will apply to the
+combination as such.
+
+  14. Revised Versions of this License.
+
+  The Free Software Foundation may publish revised and/or new versions of
+the GNU General Public License from time to time.  Such new versions will
+be similar in spirit to the present version, but may differ in detail to
+address new problems or concerns.
+
+  Each version is given a distinguishing version number.  If the
+Program specifies that a certain numbered version of the GNU General
+Public License "or any later version" applies to it, you have the
+option of following the terms and conditions either of that numbered
+version or of any later version published by the Free Software
+Foundation.  If the Program does not specify a version number of the
+GNU General Public License, you may choose any version ever published
+by the Free Software Foundation.
+
+  If the Program specifies that a proxy can decide which future
+versions of the GNU General Public License can be used, that proxy's
+public statement of acceptance of a version permanently authorizes you
+to choose that version for the Program.
+
+  Later license versions may give you additional or different
+permissions.  However, no additional obligations are imposed on any
+author or copyright holder as a result of your choosing to follow a
+later version.
+
+  15. Disclaimer of Warranty.
+
+  THERE IS NO WARRANTY FOR THE PROGRAM, TO THE EXTENT PERMITTED BY
+APPLICABLE LAW.  EXCEPT WHEN OTHERWISE STATED IN WRITING THE COPYRIGHT
+HOLDERS AND/OR OTHER PARTIES PROVIDE THE PROGRAM "AS IS" WITHOUT WARRANTY
+OF ANY KIND, EITHER EXPRESSED OR IMPLIED, INCLUDING, BUT NOT LIMITED TO,
+THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
+PURPOSE.  THE ENTIRE RISK AS TO THE QUALITY AND PERFORMANCE OF THE PROGRAM
+IS WITH YOU.  SHOULD THE PROGRAM PROVE DEFECTIVE, YOU ASSUME THE COST OF
+ALL NECESSARY SERVICING, REPAIR OR CORRECTION.
+
+  16. Limitation of Liability.
+
+  IN NO EVENT UNLESS REQUIRED BY APPLICABLE LAW OR AGREED TO IN WRITING
+WILL ANY COPYRIGHT HOLDER, OR ANY OTHER PARTY WHO MODIFIES AND/OR CONVEYS
+THE PROGRAM AS PERMITTED ABOVE, BE LIABLE TO YOU FOR DAMAGES, INCLUDING ANY
+GENERAL, SPECIAL, INCIDENTAL OR CONSEQUENTIAL DAMAGES ARISING OUT OF THE
+USE OR INABILITY TO USE THE PROGRAM (INCLUDING BUT NOT LIMITED TO LOSS OF
+DATA OR DATA BEING RENDERED INACCURATE OR LOSSES SUSTAINED BY YOU OR THIRD
+PARTIES OR A FAILURE OF THE PROGRAM TO OPERATE WITH ANY OTHER PROGRAMS),
+EVEN IF SUCH HOLDER OR OTHER PARTY HAS BEEN ADVISED OF THE POSSIBILITY OF
+SUCH DAMAGES.
+
+  17. Interpretation of Sections 15 and 16.
+
+  If the disclaimer of warranty and limitation of liability provided
+above cannot be given local legal effect according to their terms,
+reviewing courts shall apply local law that most closely approximates
+an absolute waiver of all civil liability in connection with the
+Program, unless a warranty or assumption of liability accompanies a
+copy of the Program in return for a fee.
+
+                     END OF TERMS AND CONDITIONS
+
+            How to Apply These Terms to Your New Programs
+
+  If you develop a new program, and you want it to be of the greatest
+possible use to the public, the best way to achieve this is to make it
+free software which everyone can redistribute and change under these terms.
+
+  To do so, attach the following notices to the program.  It is safest
+to attach them to the start of each source file to most effectively
+state the exclusion of warranty; and each file should have at least
+the "copyright" line and a pointer to where the full notice is found.
+
+    <one line to give the program's name and a brief idea of what it does.>
+    Copyright (C) <year>  <name of author>
+
+    This program 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.
+
+    This program 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 this program.  If not, see <http://www.gnu.org/licenses/>.
+
+Also add information on how to contact you by electronic and paper mail.
+
+  If the program does terminal interaction, make it output a short
+notice like this when it starts in an interactive mode:
+
+    <program>  Copyright (C) <year>  <name of author>
+    This program comes with ABSOLUTELY NO WARRANTY; for details type `show w'.
+    This is free software, and you are welcome to redistribute it
+    under certain conditions; type `show c' for details.
+
+The hypothetical commands `show w' and `show c' should show the appropriate
+parts of the General Public License.  Of course, your program's commands
+might be different; for a GUI interface, you would use an "about box".
+
+  You should also get your employer (if you work as a programmer) or school,
+if any, to sign a "copyright disclaimer" for the program, if necessary.
+For more information on this, and how to apply and follow the GNU GPL, see
+<http://www.gnu.org/licenses/>.
+
+  The GNU General Public License does not permit incorporating your program
+into proprietary programs.  If your program is a subroutine library, you
+may consider it more useful to permit linking proprietary applications with
+the library.  If this is what you want to do, use the GNU Lesser General
+Public License instead of this License.  But first, please read
+<http://www.gnu.org/philosophy/why-not-lgpl.html>.
Index: stable/HeuristicLab.ExtLibs/HeuristicLab.SimSharp/3.0.11/SimSharp-3.0.11/Analysis/ContinuousStatistics.cs
===================================================================
--- stable/HeuristicLab.ExtLibs/HeuristicLab.SimSharp/3.0.11/SimSharp-3.0.11/Analysis/ContinuousStatistics.cs	(revision 16281)
+++ stable/HeuristicLab.ExtLibs/HeuristicLab.SimSharp/3.0.11/SimSharp-3.0.11/Analysis/ContinuousStatistics.cs	(revision 16281)
@@ -0,0 +1,72 @@
+﻿#region License Information
+/* SimSharp - A .NET port of SimPy, discrete event simulation framework
+Copyright (C) 2016  Heuristic and Evolutionary Algorithms Laboratory (HEAL)
+
+This program 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.
+
+This program 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 this program.  If not, see <http://www.gnu.org/licenses/>.*/
+#endregion
+
+using System;
+
+namespace SimSharp {
+  public sealed class ContinuousStatistics {
+    private readonly Environment env;
+
+    public int Count { get; private set; }
+    public double TotalTimeD { get; private set; }
+    public TimeSpan TotalTime { get { return env.ToTimeSpan(TotalTimeD); } }
+
+    public double Min { get; private set; }
+    public double Max { get; private set; }
+    public double Area { get; private set; }
+    public double Mean { get; private set; }
+    public double StdDev { get { return Math.Sqrt(Variance); } }
+    public double Variance { get { return (TotalTimeD > 0) ? variance / TotalTimeD : 0.0; } }
+
+    private double lastUpdateTime;
+    private double lastValue;
+    private double variance;
+
+    private bool firstSample;
+
+
+    public ContinuousStatistics(Environment env) {
+      this.env = env;
+      lastUpdateTime = env.NowD;
+    }
+
+    public void Update(double value) {
+      Count++;
+
+      if (!firstSample) {
+        Min = Max = Mean = value;
+        firstSample = true;
+      } else {
+        if (value < Min) Min = value;
+        if (value > Max) Max = value;
+
+        var duration = env.NowD - lastUpdateTime;
+        if (duration > 0) {
+          Area += (lastValue * duration);
+          var oldMean = Mean;
+          Mean = oldMean + (lastValue - oldMean) * duration / (duration + TotalTimeD);
+          variance = variance + (lastValue - oldMean) * (lastValue - Mean) * duration;
+          TotalTimeD += duration;
+        }
+      }
+
+      lastUpdateTime = env.NowD;
+      lastValue = value;
+    }
+  }
+}
Index: stable/HeuristicLab.ExtLibs/HeuristicLab.SimSharp/3.0.11/SimSharp-3.0.11/Collections/EventQueue-License.txt
===================================================================
--- stable/HeuristicLab.ExtLibs/HeuristicLab.SimSharp/3.0.11/SimSharp-3.0.11/Collections/EventQueue-License.txt	(revision 16281)
+++ stable/HeuristicLab.ExtLibs/HeuristicLab.SimSharp/3.0.11/SimSharp-3.0.11/Collections/EventQueue-License.txt	(revision 16281)
@@ -0,0 +1,21 @@
+﻿The MIT License (MIT)
+
+Copyright (c) 2013 Daniel "BlueRaja" Pflughoeft
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in
+all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+THE SOFTWARE.
Index: stable/HeuristicLab.ExtLibs/HeuristicLab.SimSharp/3.0.11/SimSharp-3.0.11/Collections/EventQueue.cs
===================================================================
--- stable/HeuristicLab.ExtLibs/HeuristicLab.SimSharp/3.0.11/SimSharp-3.0.11/Collections/EventQueue.cs	(revision 16281)
+++ stable/HeuristicLab.ExtLibs/HeuristicLab.SimSharp/3.0.11/SimSharp-3.0.11/Collections/EventQueue.cs	(revision 16281)
@@ -0,0 +1,287 @@
+﻿using System;
+using System.Collections;
+using System.Collections.Generic;
+
+namespace SimSharp {
+  /// <summary>
+  /// An implementation of a min-Priority Queue using a heap.  Has O(1) .Contains()!
+  /// See https://bitbucket.org/BlueRaja/high-speed-priority-queue-for-c/wiki/Getting%20Started for more information
+  /// </summary>
+  /// <remarks>
+  /// There are modifications so that the type is not generic anymore and can only hold values of type EventQueueNode
+  /// </remarks>
+  public sealed class EventQueue : IEnumerable<EventQueueNode> {
+    private int _numNodes;
+    private readonly EventQueueNode[] _nodes;
+    private long _numNodesEverEnqueued;
+
+    /// <summary>
+    /// Instantiate a new Priority Queue
+    /// </summary>
+    /// <param name="maxNodes">EventQueueNodehe max nodes ever allowed to be enqueued (going over this will cause an exception)</param>
+    public EventQueue(int maxNodes) {
+      _numNodes = 0;
+      _nodes = new EventQueueNode[maxNodes + 1];
+      _numNodesEverEnqueued = 0;
+    }
+
+    /// <summary>
+    /// Returns the number of nodes in the queue.  O(1)
+    /// </summary>
+    public int Count {
+      get {
+        return _numNodes;
+      }
+    }
+
+    /// <summary>
+    /// Returns the maximum number of items that can be enqueued at once in this queue.  Once you hit this number (ie. once Count == MaxSize),
+    /// attempting to enqueue another item will throw an exception.  O(1)
+    /// </summary>
+    public int MaxSize {
+      get {
+        return _nodes.Length - 1;
+      }
+    }
+
+    /// <summary>
+    /// Removes every node from the queue.  O(n) (So, don't do this often!)
+    /// </summary>
+#if AGGRESSIVE_INLINING
+        [System.Runtime.CompilerServices.MethodImpl(System.Runtime.CompilerServices.MethodImplOptions.AggressiveInlining)]
+#endif
+    public void Clear() {
+      Array.Clear(_nodes, 1, _numNodes);
+      _numNodes = 0;
+    }
+
+    /// <summary>
+    /// Returns (in O(1)!) whether the given node is in the queue.  O(1)
+    /// </summary>
+#if AGGRESSIVE_INLINING
+        [System.Runtime.CompilerServices.MethodImpl(System.Runtime.CompilerServices.MethodImplOptions.AggressiveInlining)]
+#endif
+    public bool Contains(EventQueueNode node) {
+      return (_nodes[node.QueueIndex] == node);
+    }
+
+    /// <summary>
+    /// Enqueue a node - .Priority must be set beforehand!  O(log n)
+    /// </summary>
+#if AGGRESSIVE_INLINING
+        [System.Runtime.CompilerServices.MethodImpl(System.Runtime.CompilerServices.MethodImplOptions.AggressiveInlining)]
+#endif
+    public EventQueueNode Enqueue(DateTime primaryPriority, Event @event, int secondaryPriority = 0) {
+      var node = new EventQueueNode {
+        PrimaryPriority = primaryPriority,
+        SecondaryPriority = secondaryPriority,
+        Event = @event,
+        QueueIndex = ++_numNodes,
+        InsertionIndex = _numNodesEverEnqueued++
+      };
+      _nodes[_numNodes] = node;
+      CascadeUp(_nodes[_numNodes]);
+      return node;
+    }
+
+#if AGGRESSIVE_INLINING
+        [System.Runtime.CompilerServices.MethodImpl(System.Runtime.CompilerServices.MethodImplOptions.AggressiveInlining)]
+#endif
+    private void Swap(EventQueueNode node1, EventQueueNode node2) {
+      //Swap the nodes
+      _nodes[node1.QueueIndex] = node2;
+      _nodes[node2.QueueIndex] = node1;
+
+      //Swap their indicies
+      int temp = node1.QueueIndex;
+      node1.QueueIndex = node2.QueueIndex;
+      node2.QueueIndex = temp;
+    }
+
+    //Performance appears to be slightly better when this is NOT inlined o_O
+    private void CascadeUp(EventQueueNode node) {
+      //aka Heapify-up
+      int parent = node.QueueIndex / 2;
+      while (parent >= 1) {
+        EventQueueNode parentNode = _nodes[parent];
+        if (HasHigherPriority(parentNode, node))
+          break;
+
+        //Node has lower priority value, so move it up the heap
+        Swap(node, parentNode); //For some reason, this is faster with Swap() rather than (less..?) individual operations, like in CascadeDown()
+
+        parent = node.QueueIndex / 2;
+      }
+    }
+
+#if AGGRESSIVE_INLINING
+        [System.Runtime.CompilerServices.MethodImpl(System.Runtime.CompilerServices.MethodImplOptions.AggressiveInlining)]
+#endif
+    private void CascadeDown(EventQueueNode node) {
+      //aka Heapify-down
+      EventQueueNode newParent;
+      int finalQueueIndex = node.QueueIndex;
+      while (true) {
+        newParent = node;
+        int childLeftIndex = 2 * finalQueueIndex;
+
+        //Check if the left-child is higher-priority than the current node
+        if (childLeftIndex > _numNodes) {
+          //This could be placed outside the loop, but then we'd have to check newParent != node twice
+          node.QueueIndex = finalQueueIndex;
+          _nodes[finalQueueIndex] = node;
+          break;
+        }
+
+        EventQueueNode childLeft = _nodes[childLeftIndex];
+        if (HasHigherPriority(childLeft, newParent)) {
+          newParent = childLeft;
+        }
+
+        //Check if the right-child is higher-priority than either the current node or the left child
+        int childRightIndex = childLeftIndex + 1;
+        if (childRightIndex <= _numNodes) {
+          EventQueueNode childRight = _nodes[childRightIndex];
+          if (HasHigherPriority(childRight, newParent)) {
+            newParent = childRight;
+          }
+        }
+
+        //If either of the children has higher (smaller) priority, swap and continue cascading
+        if (newParent != node) {
+          //Move new parent to its new index.  node will be moved once, at the end
+          //Doing it this way is one less assignment operation than calling Swap()
+          _nodes[finalQueueIndex] = newParent;
+
+          int temp = newParent.QueueIndex;
+          newParent.QueueIndex = finalQueueIndex;
+          finalQueueIndex = temp;
+        } else {
+          //See note above
+          node.QueueIndex = finalQueueIndex;
+          _nodes[finalQueueIndex] = node;
+          break;
+        }
+      }
+    }
+
+    /// <summary>
+    /// Returns true if 'higher' has higher priority than 'lower', false otherwise.
+    /// Note that calling HasHigherPriority(node, node) (ie. both arguments the same node) will return false
+    /// </summary>
+#if AGGRESSIVE_INLINING
+        [System.Runtime.CompilerServices.MethodImpl(System.Runtime.CompilerServices.MethodImplOptions.AggressiveInlining)]
+#endif
+    private bool HasHigherPriority(EventQueueNode higher, EventQueueNode lower) {
+      return (higher.PrimaryPriority < lower.PrimaryPriority ||
+          (higher.PrimaryPriority == lower.PrimaryPriority
+            && (higher.SecondaryPriority < lower.SecondaryPriority ||
+            (higher.SecondaryPriority == lower.SecondaryPriority
+              && higher.InsertionIndex < lower.InsertionIndex))));
+    }
+
+    /// <summary>
+    /// Removes the head of the queue (node with highest priority; ties are broken by order of insertion), and returns it.  O(log n)
+    /// </summary>
+    public EventQueueNode Dequeue() {
+      EventQueueNode returnMe = _nodes[1];
+      Remove(returnMe);
+      return returnMe;
+    }
+
+    /// <summary>
+    /// Returns the head of the queue, without removing it (use Dequeue() for that).  O(1)
+    /// </summary>
+    public EventQueueNode First {
+      get {
+        return _nodes[1];
+      }
+    }
+
+    /// <summary>
+    /// This method must be called on a node every time its priority changes while it is in the queue.  
+    /// <b>Forgetting to call this method will result in a corrupted queue!</b>
+    /// O(log n)
+    /// </summary>
+#if AGGRESSIVE_INLINING
+        [System.Runtime.CompilerServices.MethodImpl(System.Runtime.CompilerServices.MethodImplOptions.AggressiveInlining)]
+#endif
+    public void UpdatePriority(EventQueueNode node, DateTime primaryPriority, int secondaryPriority) {
+      node.PrimaryPriority = primaryPriority;
+      node.SecondaryPriority = secondaryPriority;
+      OnNodeUpdated(node);
+    }
+
+    internal void OnNodeUpdated(EventQueueNode node) {
+      //Bubble the updated node up or down as appropriate
+      int parentIndex = node.QueueIndex / 2;
+      EventQueueNode parentNode = _nodes[parentIndex];
+
+      if (parentIndex > 0 && HasHigherPriority(node, parentNode)) {
+        CascadeUp(node);
+      } else {
+        //Note that CascadeDown will be called if parentNode == node (that is, node is the root)
+        CascadeDown(node);
+      }
+    }
+
+    /// <summary>
+    /// Removes a node from the queue.  Note that the node does not need to be the head of the queue.  O(log n)
+    /// </summary>
+    public void Remove(EventQueueNode node) {
+      if (!Contains(node)) {
+        return;
+      }
+      if (_numNodes <= 1) {
+        _nodes[1] = null;
+        _numNodes = 0;
+        return;
+      }
+
+      //Make sure the node is the last node in the queue
+      bool wasSwapped = false;
+      EventQueueNode formerLastNode = _nodes[_numNodes];
+      if (node.QueueIndex != _numNodes) {
+        //Swap the node with the last node
+        Swap(node, formerLastNode);
+        wasSwapped = true;
+      }
+
+      _numNodes--;
+      _nodes[node.QueueIndex] = null;
+
+      if (wasSwapped) {
+        //Now bubble formerLastNode (which is no longer the last node) up or down as appropriate
+        OnNodeUpdated(formerLastNode);
+      }
+    }
+
+    public IEnumerator<EventQueueNode> GetEnumerator() {
+      for (int i = 1; i <= _numNodes; i++)
+        yield return _nodes[i];
+    }
+
+    IEnumerator IEnumerable.GetEnumerator() {
+      return GetEnumerator();
+    }
+
+    /// <summary>
+    /// <b>Should not be called in production code.</b>
+    /// Checks to make sure the queue is still in a valid state.  Used for testing/debugging the queue.
+    /// </summary>
+    public bool IsValidQueue() {
+      for (int i = 1; i < _nodes.Length; i++) {
+        if (_nodes[i] != null) {
+          int childLeftIndex = 2 * i;
+          if (childLeftIndex < _nodes.Length && _nodes[childLeftIndex] != null && HasHigherPriority(_nodes[childLeftIndex], _nodes[i]))
+            return false;
+
+          int childRightIndex = childLeftIndex + 1;
+          if (childRightIndex < _nodes.Length && _nodes[childRightIndex] != null && HasHigherPriority(_nodes[childRightIndex], _nodes[i]))
+            return false;
+        }
+      }
+      return true;
+    }
+  }
+}
Index: stable/HeuristicLab.ExtLibs/HeuristicLab.SimSharp/3.0.11/SimSharp-3.0.11/Collections/EventQueueNode.cs
===================================================================
--- stable/HeuristicLab.ExtLibs/HeuristicLab.SimSharp/3.0.11/SimSharp-3.0.11/Collections/EventQueueNode.cs	(revision 16281)
+++ stable/HeuristicLab.ExtLibs/HeuristicLab.SimSharp/3.0.11/SimSharp-3.0.11/Collections/EventQueueNode.cs	(revision 16281)
@@ -0,0 +1,40 @@
+﻿using System;
+
+namespace SimSharp {
+  public class EventQueueNode {
+    /// <summary>
+    /// The Priority to insert this node at. Must be set BEFORE adding a node to the queue.
+    /// </summary>
+    public DateTime PrimaryPriority { get; set; }
+
+    /// <summary>
+    /// An integer priority that will be used to distinguish nodes with the same
+    /// <see cref="PrimaryPriority"/> and before the <see cref="InsertionIndex"/> is used.
+    /// Must be set BEFORE adding a node to the queue.
+    /// </summary>
+    /// <remarks>
+    /// A lower value means higher priority, thus int.MinValue has highest priority.
+    /// </remarks>
+    public int SecondaryPriority { get; set; }
+
+    /// <summary>
+    /// The event that is associated with this node.
+    /// </summary>
+    public Event Event { get; set; }
+
+    /// <summary>
+    /// <b>Used by the priority queue - do not edit this value.</b>
+    /// Represents the order the node was inserted in
+    /// </summary>
+    /// <remarks>
+    /// This is unique among all inserted nodes and thus represents the third and final priority.
+    /// </remarks>
+    public long InsertionIndex { get; set; }
+
+    /// <summary>
+    /// <b>Used by the priority queue - do not edit this value.</b>
+    /// Represents the current position in the queue
+    /// </summary>
+    public int QueueIndex { get; set; }
+  }
+}
Index: stable/HeuristicLab.ExtLibs/HeuristicLab.SimSharp/3.0.11/SimSharp-3.0.11/Core/ActiveObject.cs
===================================================================
--- stable/HeuristicLab.ExtLibs/HeuristicLab.SimSharp/3.0.11/SimSharp-3.0.11/Core/ActiveObject.cs	(revision 16281)
+++ stable/HeuristicLab.ExtLibs/HeuristicLab.SimSharp/3.0.11/SimSharp-3.0.11/Core/ActiveObject.cs	(revision 16281)
@@ -0,0 +1,27 @@
+﻿#region License Information
+/* SimSharp - A .NET port of SimPy, discrete event simulation framework
+Copyright (C) 2016  Heuristic and Evolutionary Algorithms Laboratory (HEAL)
+
+This program 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.
+
+This program 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 this program.  If not, see <http://www.gnu.org/licenses/>.*/
+#endregion
+
+namespace SimSharp {
+  public abstract class ActiveObject<T> where T : Environment {
+    protected T Environment { get; private set; }
+
+    protected ActiveObject(T environment) {
+      Environment = environment;
+    }
+  }
+}
Index: stable/HeuristicLab.ExtLibs/HeuristicLab.SimSharp/3.0.11/SimSharp-3.0.11/Core/Environment.cs
===================================================================
--- stable/HeuristicLab.ExtLibs/HeuristicLab.SimSharp/3.0.11/SimSharp-3.0.11/Core/Environment.cs	(revision 16281)
+++ stable/HeuristicLab.ExtLibs/HeuristicLab.SimSharp/3.0.11/SimSharp-3.0.11/Core/Environment.cs	(revision 16281)
@@ -0,0 +1,420 @@
+﻿#region License Information
+/* SimSharp - A .NET port of SimPy, discrete event simulation framework
+Copyright (C) 2016  Heuristic and Evolutionary Algorithms Laboratory (HEAL)
+
+This program 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.
+
+This program 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 this program.  If not, see <http://www.gnu.org/licenses/>.*/
+#endregion
+
+using System;
+using System.Collections.Generic;
+using System.IO;
+
+namespace SimSharp {
+  /// <summary>
+  /// Environments hold the event queues, schedule and process events.
+  /// </summary>
+  public class Environment {
+    private const int InitialMaxEvents = 1024;
+    private object locker = new object();
+
+    /// <summary>
+    /// Describes the number of seconds that a logical step of 1 in the *D-API takes.
+    /// </summary>
+    protected double DefaultTimeStepSeconds { get; private set; }
+
+    /// <summary>
+    /// Calculates the logical date of the simulation by the amount of default steps
+    /// that have passed.
+    /// </summary>
+    public double NowD {
+      get { return (Now - StartDate).TotalSeconds / DefaultTimeStepSeconds; }
+    }
+
+    /// <summary>
+    /// The current simulation time as a calendar date.
+    /// </summary>
+    public DateTime Now { get; protected set; }
+
+    /// <summary>
+    /// The calendar date when the simulation started. This defaults to 1970-1-1 if
+    /// no other date has been specified in the overloaded constructor.
+    /// </summary>
+    public DateTime StartDate { get; protected set; }
+
+    /// <summary>
+    /// The random number generator that is to be used in all events in
+    /// order to produce reproducible results.
+    /// </summary>
+    protected IRandom Random { get; set; }
+
+    protected EventQueue ScheduleQ;
+    public Process ActiveProcess { get; set; }
+
+    public TextWriter Logger { get; set; }
+    public int ProcessedEvents { get; protected set; }
+
+    public Environment() : this(new DateTime(1970, 1, 1)) { }
+    public Environment(TimeSpan? defaultStep) : this(new DateTime(1970, 1, 1), defaultStep) { }
+    public Environment(int randomSeed, TimeSpan? defaultStep = null) : this(new DateTime(1970, 1, 1), randomSeed, defaultStep) { }
+    public Environment(DateTime initialDateTime, TimeSpan? defaultStep = null) {
+      DefaultTimeStepSeconds = (defaultStep ?? TimeSpan.FromSeconds(1)).Duration().TotalSeconds;
+      StartDate = initialDateTime;
+      Now = initialDateTime;
+      Random = new SystemRandom();
+      ScheduleQ = new EventQueue(InitialMaxEvents);
+      Logger = Console.Out;
+    }
+    public Environment(DateTime initialDateTime, int randomSeed, TimeSpan? defaultStep = null) {
+      DefaultTimeStepSeconds = (defaultStep ?? TimeSpan.FromSeconds(1)).Duration().TotalSeconds;
+      StartDate = initialDateTime;
+      Now = initialDateTime;
+      Random = new SystemRandom(randomSeed);
+      ScheduleQ = new EventQueue(InitialMaxEvents);
+      Logger = Console.Out;
+    }
+
+    public double ToDouble(TimeSpan span) {
+      return span.TotalSeconds / DefaultTimeStepSeconds;
+    }
+
+    public TimeSpan ToTimeSpan(double span) {
+      return TimeSpan.FromSeconds(DefaultTimeStepSeconds * span);
+    }
+
+    /// <summary>
+    /// Creates a new process from an event generator. The process is automatically
+    /// scheduled to be started at the current simulation time.
+    /// </summary>
+    /// <param name="generator">The generator function that represents the process.</param>
+    /// <param name="priority">The priority to rank events at the same time (smaller value = higher priority).</param>
+    /// <returns>The scheduled process that was created.</returns>
+    public Process Process(IEnumerable<Event> generator, int priority = 0) {
+      return new Process(this, generator, priority);
+    }
+
+    /// <summary>
+    /// Creates and returns a new timeout.
+    /// </summary>
+    /// <param name="delay">The time after which the timeout is fired.</param>
+    /// <param name="priority">The priority to rank events at the same time (smaller value = higher priority).</param>
+    /// <returns>The scheduled timeout event that was created.</returns>
+    public Timeout TimeoutD(double delay, int priority = 0) {
+      return Timeout(TimeSpan.FromSeconds(DefaultTimeStepSeconds * delay), priority);
+    }
+
+    /// <summary>
+    /// Creates and returns a new timeout.
+    /// </summary>
+    /// <param name="delay">The time after which the timeout is fired.</param>
+    /// <param name="priority">The priority to rank events at the same time (smaller value = higher priority).</param>
+    /// <returns>The scheduled timeout event that was created.</returns>
+    public Timeout Timeout(TimeSpan delay, int priority = 0) {
+      return new Timeout(this, delay, priority: priority);
+    }
+
+    public virtual void Reset(int randomSeed) {
+      ProcessedEvents = 0;
+      Now = StartDate;
+      Random = new SystemRandom(randomSeed);
+      ScheduleQ = new EventQueue(InitialMaxEvents);
+    }
+
+    public virtual void ScheduleD(double delay, Event @event) {
+      Schedule(TimeSpan.FromSeconds(DefaultTimeStepSeconds * delay), @event);
+    }
+
+    /// <summary>
+    /// Schedules an event to occur at the same simulation time as the call was made.
+    /// </summary>
+    /// <param name="event">The event that should be scheduled.</param>
+    /// <param name="priority">The priority to rank events at the same time (smaller value = higher priority).</param></param>
+    public virtual void Schedule(Event @event, int priority = 0) {
+      lock (locker) {
+        DoSchedule(Now, @event, priority);
+      }
+    }
+
+    /// <summary>
+    /// Schedules an event to occur after a certain (positive) delay.
+    /// </summary>
+    /// <exception cref="ArgumentException">
+    /// Thrown when <paramref name="delay"/> is negative.
+    /// </exception>
+    /// <param name="delay">The (positive) delay after which the event should be fired.</param>
+    /// <param name="event">The event that should be scheduled.</param>
+    /// <param name="priority">The priority to rank events at the same time (smaller value = higher priority).</param>
+    public virtual void Schedule(TimeSpan delay, Event @event, int priority = 0) {
+      if (delay < TimeSpan.Zero)
+        throw new ArgumentException("Negative delays are not allowed in Schedule(TimeSpan, Event).");
+      lock (locker) {
+        var eventTime = Now + delay;
+        DoSchedule(eventTime, @event, priority);
+      }
+    }
+
+    protected virtual EventQueueNode DoSchedule(DateTime date, Event @event, int priority = 0) {
+      if (ScheduleQ.MaxSize == ScheduleQ.Count) {
+        // the capacity has to be adjusted, there are more events in the queue than anticipated
+        var oldSchedule = ScheduleQ;
+        ScheduleQ = new EventQueue(ScheduleQ.MaxSize * 2);
+        foreach (var e in oldSchedule) ScheduleQ.Enqueue(e.PrimaryPriority, e.Event, e.SecondaryPriority);
+      }
+      return ScheduleQ.Enqueue(date, @event, priority);
+    }
+
+    public virtual object RunD(double? until = null) {
+      if (!until.HasValue) return Run();
+      return Run(Now + TimeSpan.FromSeconds(DefaultTimeStepSeconds * until.Value));
+    }
+
+    public virtual object Run(TimeSpan span) {
+      return Run(Now + span);
+    }
+
+    public virtual object Run(DateTime until) {
+      if (until <= Now) throw new InvalidOperationException("Simulation end date must lie in the future.");
+      var stopEvent = new Event(this);
+      var node = DoSchedule(until, stopEvent);
+      // stop event is always the first to execute at the given time
+      node.InsertionIndex = -1;
+      ScheduleQ.OnNodeUpdated(node);
+      return Run(stopEvent);
+    }
+
+    public virtual object Run(Event stopEvent = null) {
+      if (stopEvent != null) {
+        if (stopEvent.IsProcessed) return stopEvent.Value;
+        stopEvent.AddCallback(StopSimulation);
+      }
+
+      try {
+        var stop = ScheduleQ.Count == 0;
+        while (!stop) {
+          Step();
+          ProcessedEvents++;
+          lock (locker) {
+            stop = ScheduleQ.Count == 0;
+          }
+        }
+      } catch (StopSimulationException e) { return e.Value; }
+      if (stopEvent == null) return null;
+      if (!stopEvent.IsTriggered) throw new InvalidOperationException("No scheduled events left but \"until\" event was not triggered.");
+      return stopEvent.Value;
+    }
+
+    public virtual void Step() {
+      Event evt;
+      lock (locker) {
+        var next = ScheduleQ.Dequeue();
+        Now = next.PrimaryPriority;
+        evt = next.Event;
+      }
+      evt.Process();
+    }
+
+    public virtual double PeekD() {
+      lock (locker) {
+        if (ScheduleQ.Count == 0) return double.MaxValue;
+        return (Peek() - StartDate).TotalSeconds / DefaultTimeStepSeconds;
+      }
+    }
+
+    public virtual DateTime Peek() {
+      lock (locker) {
+        return ScheduleQ.Count > 0 ? ScheduleQ.First.PrimaryPriority : DateTime.MaxValue;
+      }
+    }
+
+    protected virtual void StopSimulation(Event @event) {
+      throw new StopSimulationException(@event.Value);
+    }
+
+    public virtual void Log(string message, params object[] args) {
+      if (Logger != null)
+        Logger.WriteLine(message, args);
+    }
+
+    #region Random number distributions
+    protected static readonly double NormalMagicConst = 4 * Math.Exp(-0.5) / Math.Sqrt(2.0);
+
+    public double RandUniform(double a, double b) {
+      return a + (b - a) * Random.NextDouble();
+    }
+
+    public TimeSpan RandUniform(TimeSpan a, TimeSpan b) {
+      return TimeSpan.FromSeconds(RandUniform(a.TotalSeconds, b.TotalSeconds));
+    }
+
+    public double RandTriangular(double low, double high) {
+      var u = Random.NextDouble();
+      if (u > 0.5)
+        return high + (low - high) * Math.Sqrt(((1.0 - u) / 2));
+      return low + (high - low) * Math.Sqrt(u / 2);
+    }
+
+    public TimeSpan RandTriangular(TimeSpan low, TimeSpan high) {
+      return TimeSpan.FromSeconds(RandTriangular(low.TotalSeconds, high.TotalSeconds));
+    }
+
+    public double RandTriangular(double low, double high, double mode) {
+      var u = Random.NextDouble();
+      var c = (mode - low) / (high - low);
+      if (u > c)
+        return high + (low - high) * Math.Sqrt(((1.0 - u) * (1.0 - c)));
+      return low + (high - low) * Math.Sqrt(u * c);
+    }
+
+    public TimeSpan RandTriangular(TimeSpan low, TimeSpan high, TimeSpan mode) {
+      return TimeSpan.FromSeconds(RandTriangular(low.TotalSeconds, high.TotalSeconds, mode.TotalSeconds));
+    }
+
+    /// <summary>
+    /// Returns a number that is exponentially distributed given a certain mean.
+    /// </summary>
+    /// <remarks>
+    /// Unlike in other APIs here the mean should be given and not the lambda parameter.
+    /// </remarks>
+    /// <param name="mean">The mean(!) of the distribution is 1 / lambda.</param>
+    /// <returns>A number that is exponentially distributed</returns>
+    public double RandExponential(double mean) {
+      return -Math.Log(1 - Random.NextDouble()) * mean;
+    }
+
+    /// <summary>
+    /// Returns a timespan that is exponentially distributed given a certain mean.
+    /// </summary>
+    /// <remarks>
+    /// Unlike in other APIs here the mean should be given and not the lambda parameter.
+    /// </remarks>
+    /// <param name="mean">The mean(!) of the distribution is 1 / lambda.</param>
+    /// <returns>A number that is exponentially distributed</returns>
+    public TimeSpan RandExponential(TimeSpan mean) {
+      return TimeSpan.FromSeconds(RandExponential(mean.TotalSeconds));
+    }
+
+    public double RandNormal(double mu, double sigma) {
+      double z, zz, u1, u2;
+      do {
+        u1 = Random.NextDouble();
+        u2 = 1 - Random.NextDouble();
+        z = NormalMagicConst * (u1 - 0.5) / u2;
+        zz = z * z / 4.0;
+      } while (zz > -Math.Log(u2));
+      return mu + z * sigma;
+    }
+
+    public TimeSpan RandNormal(TimeSpan mu, TimeSpan sigma) {
+      return TimeSpan.FromSeconds(RandNormal(mu.TotalSeconds, sigma.TotalSeconds));
+    }
+
+    public double RandNormalPositive(double mu, double sigma) {
+      double val;
+      do {
+        val = RandNormal(mu, sigma);
+      } while (val <= 0);
+      return val;
+    }
+
+    public TimeSpan RandNormalPositive(TimeSpan mu, TimeSpan sigma) {
+      return TimeSpan.FromSeconds(RandNormalPositive(mu.TotalSeconds, sigma.TotalSeconds));
+    }
+
+    public double RandNormalNegative(double mu, double sigma) {
+      double val;
+      do {
+        val = RandNormal(mu, sigma);
+      } while (val >= 0);
+      return val;
+    }
+
+    public TimeSpan RandNormalNegative(TimeSpan mu, TimeSpan sigma) {
+      return TimeSpan.FromSeconds(RandNormalNegative(mu.TotalSeconds, sigma.TotalSeconds));
+    }
+
+    public double RandLogNormal(double mu, double sigma) {
+      return Math.Exp(RandNormal(mu, sigma));
+    }
+
+    public TimeSpan RandLogNormal(TimeSpan mu, TimeSpan sigma) {
+      return TimeSpan.FromSeconds(RandLogNormal(mu.TotalSeconds, sigma.TotalSeconds));
+    }
+
+    public double RandCauchy(double x0, double gamma) {
+      return x0 + gamma * Math.Tan(Math.PI * (Random.NextDouble() - 0.5));
+    }
+
+    public TimeSpan RandCauchy(TimeSpan x0, TimeSpan gamma) {
+      return TimeSpan.FromSeconds(RandCauchy(x0.TotalSeconds, gamma.TotalSeconds));
+    }
+
+    public double RandWeibull(double alpha, double beta) {
+      return alpha * Math.Pow(-Math.Log(1 - Random.NextDouble()), 1 / beta);
+    }
+
+    public TimeSpan RandWeibull(TimeSpan mu, TimeSpan sigma) {
+      return TimeSpan.FromSeconds(RandWeibull(mu.TotalSeconds, sigma.TotalSeconds));
+    }
+    #endregion
+
+    #region Random timeouts
+    public Timeout TimeoutUniformD(double a, double b) {
+      return new Timeout(this, ToTimeSpan(RandUniform(a, b)));
+    }
+
+    public Timeout TimeoutUniform(TimeSpan a, TimeSpan b) {
+      return new Timeout(this, RandUniform(a, b));
+    }
+
+    public Timeout TimeoutTriangularD(double low, double high) {
+      return new Timeout(this, ToTimeSpan(RandTriangular(low, high)));
+    }
+
+    public Timeout TimeoutTriangular(TimeSpan low, TimeSpan high) {
+      return new Timeout(this, RandTriangular(low, high));
+    }
+
+    public Timeout TimeoutTriangularD(double low, double high, double mode) {
+      return new Timeout(this, ToTimeSpan(RandTriangular(low, high, mode)));
+    }
+
+    public Timeout TimeoutTriangular(TimeSpan low, TimeSpan high, TimeSpan mode) {
+      return new Timeout(this, RandTriangular(low, high, mode));
+    }
+
+    public Timeout TimeoutExponentialD(double mean) {
+      return new Timeout(this, ToTimeSpan(RandExponential(mean)));
+    }
+
+    public Timeout TimeoutExponential(TimeSpan mean) {
+      return new Timeout(this, RandExponential(mean));
+    }
+
+    public Timeout TimeoutNormalPositiveD(double mu, double sigma) {
+      return new Timeout(this, ToTimeSpan(RandNormalPositive(mu, sigma)));
+    }
+
+    public Timeout TimeoutNormalPositive(TimeSpan mu, TimeSpan sigma) {
+      return new Timeout(this, RandNormalPositive(mu, sigma));
+    }
+
+    public Timeout TimeoutLogNormalD(double mu, double sigma) {
+      return new Timeout(this, ToTimeSpan(RandLogNormal(mu, sigma)));
+    }
+
+    public Timeout TimeoutLogNormal(TimeSpan mu, TimeSpan sigma) {
+      return new Timeout(this, RandLogNormal(mu, sigma));
+    }
+    #endregion
+  }
+}
Index: stable/HeuristicLab.ExtLibs/HeuristicLab.SimSharp/3.0.11/SimSharp-3.0.11/Core/Events/AllOf.cs
===================================================================
--- stable/HeuristicLab.ExtLibs/HeuristicLab.SimSharp/3.0.11/SimSharp-3.0.11/Core/Events/AllOf.cs	(revision 16281)
+++ stable/HeuristicLab.ExtLibs/HeuristicLab.SimSharp/3.0.11/SimSharp-3.0.11/Core/Events/AllOf.cs	(revision 16281)
@@ -0,0 +1,30 @@
+﻿#region License Information
+/* SimSharp - A .NET port of SimPy, discrete event simulation framework
+Copyright (C) 2016  Heuristic and Evolutionary Algorithms Laboratory (HEAL)
+
+This program 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.
+
+This program 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 this program.  If not, see <http://www.gnu.org/licenses/>.*/
+#endregion
+
+using System.Collections.Generic;
+
+namespace SimSharp {
+  public class AllOf : Condition {
+    public AllOf(Environment environment, params Event[] events) : base(environment, events) { }
+    public AllOf(Environment environment, IEnumerable<Event> events) : base(environment, events) { }
+
+    protected override bool Evaluate() {
+      return FiredEvents.Count == Events.Count;
+    }
+  }
+}
Index: stable/HeuristicLab.ExtLibs/HeuristicLab.SimSharp/3.0.11/SimSharp-3.0.11/Core/Events/AnyOf.cs
===================================================================
--- stable/HeuristicLab.ExtLibs/HeuristicLab.SimSharp/3.0.11/SimSharp-3.0.11/Core/Events/AnyOf.cs	(revision 16281)
+++ stable/HeuristicLab.ExtLibs/HeuristicLab.SimSharp/3.0.11/SimSharp-3.0.11/Core/Events/AnyOf.cs	(revision 16281)
@@ -0,0 +1,30 @@
+﻿#region License Information
+/* SimSharp - A .NET port of SimPy, discrete event simulation framework
+Copyright (C) 2016  Heuristic and Evolutionary Algorithms Laboratory (HEAL)
+
+This program 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.
+
+This program 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 this program.  If not, see <http://www.gnu.org/licenses/>.*/
+#endregion
+
+using System.Collections.Generic;
+
+namespace SimSharp {
+  public class AnyOf : Condition {
+    public AnyOf(Environment environment, params Event[] events) : base(environment, events) { }
+    public AnyOf(Environment environment, IEnumerable<Event> events) : base(environment, events) { }
+
+    protected override bool Evaluate() {
+      return FiredEvents.Count > 0 || Events.Count == 0;
+    }
+  }
+}
Index: stable/HeuristicLab.ExtLibs/HeuristicLab.SimSharp/3.0.11/SimSharp-3.0.11/Core/Events/Condition.cs
===================================================================
--- stable/HeuristicLab.ExtLibs/HeuristicLab.SimSharp/3.0.11/SimSharp-3.0.11/Core/Events/Condition.cs	(revision 16281)
+++ stable/HeuristicLab.ExtLibs/HeuristicLab.SimSharp/3.0.11/SimSharp-3.0.11/Core/Events/Condition.cs	(revision 16281)
@@ -0,0 +1,97 @@
+﻿#region License Information
+/* SimSharp - A .NET port of SimPy, discrete event simulation framework
+Copyright (C) 2016  Heuristic and Evolutionary Algorithms Laboratory (HEAL)
+
+This program 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.
+
+This program 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 this program.  If not, see <http://www.gnu.org/licenses/>.*/
+#endregion
+
+using System;
+using System.Collections.Generic;
+using System.Collections.Specialized;
+
+namespace SimSharp {
+  /// <summary>
+  /// Conditions are events that execute when any or all of its sub-events are executed.
+  /// </summary>
+  public abstract class Condition : Event {
+
+    public new OrderedDictionary Value {
+      get { return (OrderedDictionary)base.Value; }
+      set { base.Value = value; }
+    }
+
+    protected List<Event> Events { get; private set; }
+
+    protected List<Event> FiredEvents { get; private set; }
+
+    protected Condition(Environment environment, params Event[] events)
+      : this(environment, (IEnumerable<Event>)events) { }
+    protected Condition(Environment environment, IEnumerable<Event> events)
+      : base(environment) {
+      CallbackList.Add(CollectValues);
+      Events = new List<Event>(events);
+      FiredEvents = new List<Event>();
+
+      foreach (var @event in Events) {
+        if (Environment != @event.Environment)
+          throw new ArgumentException("It is not allowed to mix events from different environments");
+        if (@event.IsProcessed) Check(@event);
+        else @event.AddCallback(Check);
+      }
+
+      if (IsAlive && Evaluate())
+        Succeed();
+    }
+
+    protected void Check(Event @event) {
+      if (IsTriggered || IsProcessed) {
+        if (!@event.IsOk) throw new InvalidOperationException(
+@"Errors that happen after the condition has been triggered will not be
+handled by the condition and cause the simulation to crash.");
+        return;
+      }
+      FiredEvents.Add(@event);
+
+      if (!@event.IsOk)
+        Fail(@event.Value);
+      else if (Evaluate()) {
+        Succeed();
+      }
+    }
+
+    protected virtual IEnumerable<KeyValuePair<object, object>> GetValues() {
+      var values = new List<KeyValuePair<object, object>>();
+      foreach (var e in Events) {
+        var condition = e as Condition;
+        if (condition != null) {
+          values.AddRange(condition.GetValues());
+        } else if (e.IsProcessed) {
+          values.Add(new KeyValuePair<object, object>(e, e.Value));
+        }
+      }
+      return values;
+    }
+
+    protected virtual void CollectValues(Event @event) {
+      if (@event.IsOk) {
+        var value = new OrderedDictionary();
+        foreach (var v in GetValues())
+          value.Add(v.Key, v.Value);
+        Value = value;
+      }
+    }
+
+    protected abstract bool Evaluate();
+  }
+}
Index: stable/HeuristicLab.ExtLibs/HeuristicLab.SimSharp/3.0.11/SimSharp-3.0.11/Core/Events/Event.cs
===================================================================
--- stable/HeuristicLab.ExtLibs/HeuristicLab.SimSharp/3.0.11/SimSharp-3.0.11/Core/Events/Event.cs	(revision 16281)
+++ stable/HeuristicLab.ExtLibs/HeuristicLab.SimSharp/3.0.11/SimSharp-3.0.11/Core/Events/Event.cs	(revision 16281)
@@ -0,0 +1,200 @@
+﻿#region License Information
+/* SimSharp - A .NET port of SimPy, discrete event simulation framework
+Copyright (C) 2016  Heuristic and Evolutionary Algorithms Laboratory (HEAL)
+
+This program 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.
+
+This program 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 this program.  If not, see <http://www.gnu.org/licenses/>.*/
+#endregion
+
+using System;
+using System.Collections.Generic;
+
+namespace SimSharp {
+  /// <summary>
+  /// The base class for all events in SimSharp.
+  /// An event can be in one of three states at any time:
+  ///  - Alive: The event object exists, but is neither scheduled to
+  ///           be executed, nor is it already executed.
+  ///  - Triggered: The event has been put in the event queue and is
+  ///               going to be executed.
+  ///  - Processed: The event has been executed.
+  /// 
+  /// Usually, the event is alive until its Trigger, Succeed, or Fail
+  /// method have been called. Then it becomes triggered. When the
+  /// Environment progresses to the event and executes its callbacks
+  /// the event becomes processed.
+  /// </summary>
+  public class Event {
+    protected internal Environment Environment { get; private set; }
+    protected List<Action<Event>> CallbackList { get; set; }
+
+    /// <summary>
+    /// The value property can be used to return arbitrary data from a
+    /// process or an event. It also represents the interrupt cause to
+    /// a process.
+    /// </summary>
+    public object Value { get; protected set; }
+
+    /// <summary>
+    /// The IsOk flag indicates if the event succeeded or failed. An event
+    /// that failed indicates to a waiting process that the action could
+    /// not be performed and that the faulting situation must be handled.
+    /// Typically, interrupting a process sets the IsOk flag to false.
+    /// </summary>
+    public bool IsOk { get; protected set; }
+    /// <summary>
+    /// An event is alive when it is not triggered and not processed. That
+    /// is, when it exists in memory without being scheduled. Typically,
+    /// a Process is alive until its last event has been processed and the
+    /// process event itself is to be processed.
+    /// </summary>
+    public bool IsAlive { get { return !IsTriggered && !IsProcessed; } }
+    /// <summary>
+    /// An event becomes processed when its callbacks have been executed.
+    /// Events may only be processed once and an exception will be thrown
+    /// if they are to be processed multiple times.
+    /// </summary>
+    public bool IsProcessed { get; protected set; }
+    /// <summary>
+    /// An event becomes triggered when it is placed into the event queue.
+    /// That is, when its callbacks are going to be executed.
+    /// An even that is triggered may later not be failed or retriggered.
+    /// </summary>
+    public bool IsTriggered { get; protected set; }
+
+    public Event(Environment environment) {
+      Environment = environment;
+      CallbackList = new List<Action<Event>>();
+    }
+
+    /// <summary>
+    /// This method schedules the event right now. It takes the IsOk state
+    /// and uses the <see cref="Value"/> of the given <paramref name="@event"/>.
+    /// Thus if the given event fails, this event will also be triggered as
+    /// failing.
+    /// </summary>
+    /// <exception cref="InvalidOperationException">
+    /// Thrown when the event has already been triggered.
+    /// </exception>
+    /// <remarks>
+    /// The signature of this method allows it to be used as a callback.
+    /// </remarks>
+    /// <param name="event">The event that triggers this event.</param>
+    /// <param name="priority">The priority to rank events at the same time (smaller value = higher priority).</param>
+    public virtual void Trigger(Event @event, int priority = 0) {
+      if (IsTriggered)
+        throw new InvalidOperationException("Event has already been triggered.");
+      IsOk = @event.IsOk;
+      Value = @event.Value;
+      IsTriggered = true;
+      Environment.Schedule(this, priority);
+    }
+
+    /// <summary>
+    /// This method schedules the event right now. It sets IsOk state to true
+    /// and optionally uses also the value. If urgent is given, the event may
+    /// be scheduled as urgent. Urgent events are placed in a separate event
+    /// queue. The callbacks of urgent events are executed before normal events.
+    /// </summary>
+    /// <exception cref="InvalidOperationException">
+    /// Thrown when the event has already been triggered.
+    /// </exception>
+    /// <param name="value">The value that the event should use.</param>
+    /// <param name="priority">The priority to rank events at the same time (smaller value = higher priority).</param>
+    public virtual void Succeed(object value = null, int priority = 0) {
+      if (IsTriggered)
+        throw new InvalidOperationException("Event has already been triggered.");
+      IsOk = true;
+      Value = value;
+      IsTriggered = true;
+      Environment.Schedule(this, priority);
+    }
+
+    /// <summary>
+    /// This method schedules the event right now. It sets IsOk state to false
+    /// and optionally uses also the value. If urgent is given, the event may
+    /// be scheduled as urgent. Urgent events are placed in a separate event
+    /// queue. The callbacks of urgent events are executed before normal events.
+    /// </summary>
+    /// <exception cref="InvalidOperationException">
+    /// Thrown when the event has already been triggered.
+    /// </exception>
+    /// <param name="value">The value that the event should use.</param>
+    /// <param name="priority">The priority to rank events at the same time (smaller value = higher priority).</param>
+    public virtual void Fail(object value = null, int priority = 0) {
+      if (IsTriggered)
+        throw new InvalidOperationException("Event has already been triggered.");
+      IsOk = false;
+      Value = value;
+      IsTriggered = true;
+      Environment.Schedule(this, priority);
+    }
+
+    /// <summary>
+    /// This method adds a callback to the list of callbacks. Callbacks will be
+    /// executed in the order they have been added.
+    /// </summary>
+    /// <param name="callback">The callback to execute when the event is being
+    /// processed.</param>
+    public virtual void AddCallback(Action<Event> callback) {
+      if (IsProcessed) throw new InvalidOperationException("Event is already processed.");
+      CallbackList.Add(callback);
+    }
+
+    /// <summary>
+    /// This method adds a range of callbacks to the list of callbacks. Callbacks
+    /// will be executed in the order they have been added.
+    /// </summary>
+    /// <param name="callbacks">The callbacks to execute when the event is being
+    /// processed.</param>
+    public virtual void AddCallbacks(IEnumerable<Action<Event>> callbacks) {
+      if (IsProcessed) throw new InvalidOperationException("Event is already processed.");
+      CallbackList.AddRange(callbacks);
+    }
+
+    /// <summary>
+    /// This method removes a callback to the list of callbacks.
+    /// </summary>
+    /// <remarks>
+    /// It is not checked if the callback has actually been added before and
+    /// no exception will be thrown if it had not been present.
+    /// </remarks>
+    /// <param name="callback">The callback to remove.</param>
+    public virtual void RemoveCallback(Action<Event> callback) {
+      if (IsProcessed) throw new InvalidOperationException("Event is already processed.");
+      CallbackList.Remove(callback);
+    }
+
+    /// <summary>
+    /// This method processes the event, that is, it calls all the callbacks.
+    /// When it finishes it will be marked IsProcessed and cannot be processed
+    /// again.
+    /// </summary>
+    /// <exception cref="InvalidOperationException">When the event has already
+    /// been processed.</exception>
+    public virtual void Process() {
+      if (IsProcessed) throw new InvalidOperationException("Event has already been processed.");
+      IsProcessed = true;
+      foreach (var callback in CallbackList)
+        callback(this);
+      CallbackList = null;
+    }
+
+    public static Condition operator &(Event event1, Event event2) {
+      return new AllOf(event1.Environment, event1, event2);
+    }
+    public static Condition operator |(Event event1, Event event2) {
+      return new AnyOf(event1.Environment, event1, event2);
+    }
+  }
+}
Index: stable/HeuristicLab.ExtLibs/HeuristicLab.SimSharp/3.0.11/SimSharp-3.0.11/Core/Events/Process.cs
===================================================================
--- stable/HeuristicLab.ExtLibs/HeuristicLab.SimSharp/3.0.11/SimSharp-3.0.11/Core/Events/Process.cs	(revision 16281)
+++ stable/HeuristicLab.ExtLibs/HeuristicLab.SimSharp/3.0.11/SimSharp-3.0.11/Core/Events/Process.cs	(revision 16281)
@@ -0,0 +1,167 @@
+﻿#region License Information
+/* SimSharp - A .NET port of SimPy, discrete event simulation framework
+Copyright (C) 2016  Heuristic and Evolutionary Algorithms Laboratory (HEAL)
+
+This program 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.
+
+This program 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 this program.  If not, see <http://www.gnu.org/licenses/>.*/
+#endregion
+
+using System;
+using System.Collections.Generic;
+
+namespace SimSharp {
+  /// <summary>
+  /// A Process handles the iteration of events. Processes may define steps that
+  /// a certain entity in the simulation has to perform. Each time the process
+  /// should wait it yields an event and will be resumed when that event is processed.
+  /// </summary>
+  /// <remarks>
+  /// Since an iterator method does not have access to its process, the method can
+  /// retrieve the associated Process through the ActiveProcess property of the
+  /// environment. Each Process sets and resets that property during Resume.
+  /// </remarks>
+  public class Process : Event {
+    private readonly IEnumerator<Event> generator;
+    private Event target;
+    /// <summary>
+    /// Target is the event that is expected to be executed next in the process.
+    /// </summary>
+    public Event Target {
+      get { return target; }
+      protected set { target = value; }
+    }
+
+    /// <summary>
+    /// Sets up a new process.
+    /// The process places an initialize event into the event queue which starts
+    /// the process by retrieving events from the generator.
+    /// </summary>
+    /// <param name="environment">The environment in which the process lives.</param>
+    /// <param name="generator">The generator function of the process.</param>
+    /// <param name="priority">The priority if multiple processes are started at the same time.</param>
+    public Process(Environment environment, IEnumerable<Event> generator, int priority = 0)
+      : base(environment) {
+      this.generator = generator.GetEnumerator();
+      IsOk = true;
+      target = new Initialize(environment, this, priority);
+    }
+
+    /// <summary>
+    /// This interrupts a process and causes the IsOk flag to be set to false.
+    /// If a process is interrupted the iterator method needs to call HandleFault()
+    /// before continuing to yield further events.
+    /// </summary>
+    /// <exception cref="InvalidOperationException">This is thrown in three conditions:
+    ///  - If the process has already been triggered.
+    ///  - If the process attempts to interrupt itself.
+    ///  - If the process continues to yield events despite being faulted.</exception>
+    /// <param name="cause">The cause of the interrupt.</param>
+    /// <param name="priority">The priority to rank events at the same time (smaller value = higher priority).</param>
+    public virtual void Interrupt(object cause = null, int priority = 0) {
+      if (IsTriggered) throw new InvalidOperationException("The process has terminated and cannot be interrupted.");
+      if (Environment.ActiveProcess == this) throw new InvalidOperationException("A process is not allowed to interrupt itself.");
+
+      var interruptEvent = new Event(Environment);
+      interruptEvent.AddCallback(Resume);
+      interruptEvent.Fail(cause, priority);
+
+      if (Target != null)
+        Target.RemoveCallback(Resume);
+    }
+
+    protected virtual void Resume(Event @event) {
+      Environment.ActiveProcess = this;
+      while (true) {
+        if (@event.IsOk) {
+          if (generator.MoveNext()) {
+            if (IsTriggered) {
+              // the generator called e.g. Environment.ActiveProcess.Fail
+              Environment.ActiveProcess = null;
+              return;
+            }
+            if (!ProceedToEvent()) {
+              @event = target;
+              continue;
+            } else break;
+          } else if (!IsTriggered) {
+            Succeed(@event.Value);
+            break;
+          } else break;
+        } else {
+          /* Fault handling differs from SimPy as in .NET it is not possible to inject an
+         * exception into an enumerator and it is impossible to put a yield return inside
+         * a try-catch block. In SimSharp the Process will set IsOk and will then move to
+         * the next yield in the generator. However, if after this move IsOk is still false
+         * we know that the error was not handled. It is assumed the error is handled if
+         * HandleFault() is called on the environment's ActiveProcess which will reset the
+         * flag. */
+          IsOk = false;
+          Value = @event.Value;
+
+          if (generator.MoveNext()) {
+            if (IsTriggered) {
+              // the generator called e.g. Environment.ActiveProcess.Fail
+              Environment.ActiveProcess = null;
+              return;
+            }
+            // if we move next, but IsOk is still false
+            if (!IsOk) throw new InvalidOperationException("The process did not react to being faulted.");
+            // otherwise HandleFault was called and the fault was handled
+            if (ProceedToEvent()) break;
+          } else if (!IsTriggered) {
+            if (!IsOk) Fail(@event.Value);
+            else Succeed(@event.Value);
+            break;
+          } else break;
+        }
+      }
+      Environment.ActiveProcess = null;
+    }
+
+    protected virtual bool ProceedToEvent() {
+      target = generator.Current;
+      Value = target.Value;
+      if (target.IsProcessed) return false;
+      target.AddCallback(Resume);
+      return true;
+    }
+
+    /// <summary>
+    /// This method must be called to reset the IsOk flag of the process back to true.
+    /// The IsOk flag may be set to false if the process waited on an event that failed.
+    /// </summary>
+    /// <remarks>
+    /// In SimPy a faulting process would throw an exception which is then catched and
+    /// chained. In SimSharp catching exceptions from a yield is not possible as a yield
+    /// return statement may not throw an exception.
+    /// If a processes faulted the Value property may indicate a cause for the fault.
+    /// </remarks>
+    /// <returns>True if a faulting situation needs to be handled, false if the process
+    /// is okay and the last yielded event succeeded.</returns>
+    public virtual bool HandleFault() {
+      if (IsOk) return false;
+      IsOk = true;
+      return true;
+    }
+
+    private class Initialize : Event {
+      public Initialize(Environment environment, Process process, int priority)
+        : base(environment) {
+        CallbackList.Add(process.Resume);
+        IsOk = true;
+        IsTriggered = true;
+        environment.Schedule(this, priority);
+      }
+    }
+  }
+}
Index: stable/HeuristicLab.ExtLibs/HeuristicLab.SimSharp/3.0.11/SimSharp-3.0.11/Core/Events/Timeout.cs
===================================================================
--- stable/HeuristicLab.ExtLibs/HeuristicLab.SimSharp/3.0.11/SimSharp-3.0.11/Core/Events/Timeout.cs	(revision 16281)
+++ stable/HeuristicLab.ExtLibs/HeuristicLab.SimSharp/3.0.11/SimSharp-3.0.11/Core/Events/Timeout.cs	(revision 16281)
@@ -0,0 +1,46 @@
+﻿#region License Information
+/* SimSharp - A .NET port of SimPy, discrete event simulation framework
+Copyright (C) 2016  Heuristic and Evolutionary Algorithms Laboratory (HEAL)
+
+This program 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.
+
+This program 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 this program.  If not, see <http://www.gnu.org/licenses/>.*/
+#endregion
+
+using System;
+
+namespace SimSharp {
+  /// <summary>
+  /// Timeouts are simple events that are executed after a certain timespan has passed.
+  /// </summary>
+  public sealed class Timeout : Event {
+    /// <summary>
+    /// A timeout is an event that is executed after a certain timespan has passed.
+    /// </summary>
+    /// <remarks>
+    /// Timeout events are scheduled when they are created. They are always triggered
+    /// when they are created.
+    /// </remarks>
+    /// <param name="environment">The environment in which it is scheduled.</param>
+    /// <param name="delay">The timespan for the timeout.</param>
+    /// <param name="value">The value of the timeout.</param>
+    /// <param name="isOk">Whether the timeout should succeed or fail.</param>
+    /// <param name="priority">The priority to rank events at the same time (smaller value = higher priority).</param>
+    public Timeout(Environment environment, TimeSpan delay, object value = null, bool isOk = true, int priority = 0)
+      : base(environment) {
+      IsOk = isOk;
+      Value = value;
+      IsTriggered = true;
+      environment.Schedule(delay, this, priority);
+    }
+  }
+}
Index: stable/HeuristicLab.ExtLibs/HeuristicLab.SimSharp/3.0.11/SimSharp-3.0.11/Core/Exceptions/EmptyScheduleException.cs
===================================================================
--- stable/HeuristicLab.ExtLibs/HeuristicLab.SimSharp/3.0.11/SimSharp-3.0.11/Core/Exceptions/EmptyScheduleException.cs	(revision 16281)
+++ stable/HeuristicLab.ExtLibs/HeuristicLab.SimSharp/3.0.11/SimSharp-3.0.11/Core/Exceptions/EmptyScheduleException.cs	(revision 16281)
@@ -0,0 +1,32 @@
+﻿#region License Information
+/* SimSharp - A .NET port of SimPy, discrete event simulation framework
+Copyright (C) 2016  Heuristic and Evolutionary Algorithms Laboratory (HEAL)
+
+This program 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.
+
+This program 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 this program.  If not, see <http://www.gnu.org/licenses/>.*/
+#endregion
+
+using System;
+
+namespace SimSharp {
+  /// <summary>
+  /// An exception that is thrown to stop the simulation.
+  /// </summary>
+  public class StopSimulationException : Exception {
+    public object Value { get; private set; }
+    
+    public StopSimulationException(object value) {
+      Value = value;
+    }
+  }
+}
Index: stable/HeuristicLab.ExtLibs/HeuristicLab.SimSharp/3.0.11/SimSharp-3.0.11/Core/Preempted.cs
===================================================================
--- stable/HeuristicLab.ExtLibs/HeuristicLab.SimSharp/3.0.11/SimSharp-3.0.11/Core/Preempted.cs	(revision 16281)
+++ stable/HeuristicLab.ExtLibs/HeuristicLab.SimSharp/3.0.11/SimSharp-3.0.11/Core/Preempted.cs	(revision 16281)
@@ -0,0 +1,31 @@
+﻿#region License Information
+/* SimSharp - A .NET port of SimPy, discrete event simulation framework
+Copyright (C) 2016  Heuristic and Evolutionary Algorithms Laboratory (HEAL)
+
+This program 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.
+
+This program 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 this program.  If not, see <http://www.gnu.org/licenses/>.*/
+#endregion
+
+using System;
+
+namespace SimSharp {
+  public sealed class Preempted {
+    public Process By { get; private set; }
+    public DateTime UsageSince { get; private set; }
+
+    public Preempted(Process by, DateTime usageSince) {
+      By = by;
+      UsageSince = usageSince;
+    }
+  }
+}
Index: stable/HeuristicLab.ExtLibs/HeuristicLab.SimSharp/3.0.11/SimSharp-3.0.11/Core/Resources/Container.cs
===================================================================
--- stable/HeuristicLab.ExtLibs/HeuristicLab.SimSharp/3.0.11/SimSharp-3.0.11/Core/Resources/Container.cs	(revision 16281)
+++ stable/HeuristicLab.ExtLibs/HeuristicLab.SimSharp/3.0.11/SimSharp-3.0.11/Core/Resources/Container.cs	(revision 16281)
@@ -0,0 +1,93 @@
+﻿#region License Information
+/* SimSharp - A .NET port of SimPy, discrete event simulation framework
+Copyright (C) 2016  Heuristic and Evolutionary Algorithms Laboratory (HEAL)
+
+This program 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.
+
+This program 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 this program.  If not, see <http://www.gnu.org/licenses/>.*/
+#endregion
+
+using System;
+using System.Collections.Generic;
+using System.Linq;
+
+namespace SimSharp {
+  public class Container {
+    public double Level { get; protected set; }
+    public double Capacity { get; protected set; }
+    protected Environment Environment { get; private set; }
+
+    protected Queue<ContainerPut> PutQueue { get; private set; }
+    protected Queue<ContainerGet> GetQueue { get; private set; }
+
+    public Container(Environment environment, double capacity = double.MaxValue, double initial = 0) {
+      if (capacity <= 0) throw new ArgumentException("Capacity must be > 0", "capacity");
+      if (initial < 0) throw new ArgumentException("Initial must be >= 0", "initial");
+      if (initial > capacity) throw new ArgumentException("Initial must be <= capacity", "initial");
+      Environment = environment;
+      Capacity = capacity;
+      Level = initial;
+      PutQueue = new Queue<ContainerPut>();
+      GetQueue = new Queue<ContainerGet>();
+    }
+
+    public virtual ContainerPut Put(double amount) {
+      if (amount > Capacity) throw new ArgumentException("Cannot put more than capacity", "amount");
+      var put = new ContainerPut(Environment, TriggerGet, amount);
+      PutQueue.Enqueue(put);
+      TriggerPut();
+      return put;
+    }
+
+    public virtual ContainerGet Get(double amount) {
+      if (amount > Capacity) throw new ArgumentException("Cannot get more than capacity", "amount");
+      var get = new ContainerGet(Environment, TriggerPut, amount);
+      GetQueue.Enqueue(get);
+      TriggerGet();
+      return get;
+    }
+
+    protected virtual void DoPut(ContainerPut put) {
+      if (Capacity - Level >= put.Amount) {
+        Level += put.Amount;
+        put.Succeed();
+      }
+    }
+
+    protected virtual void DoGet(ContainerGet get) {
+      if (Level >= get.Amount) {
+        Level -= get.Amount;
+        get.Succeed();
+      }
+    }
+
+    protected virtual void TriggerPut(Event @event = null) {
+      while (PutQueue.Count > 0) {
+        var put = PutQueue.Peek();
+        DoPut(put);
+        if (put.IsTriggered) {
+          PutQueue.Dequeue();
+        } else break;
+      }
+    }
+
+    protected virtual void TriggerGet(Event @event = null) {
+      while (GetQueue.Count > 0) {
+        var get = GetQueue.Peek();
+        DoGet(get);
+        if (get.IsTriggered) {
+          GetQueue.Dequeue();
+        } else break;
+      }
+    }
+  }
+}
Index: stable/HeuristicLab.ExtLibs/HeuristicLab.SimSharp/3.0.11/SimSharp-3.0.11/Core/Resources/Events/ContainerGet.cs
===================================================================
--- stable/HeuristicLab.ExtLibs/HeuristicLab.SimSharp/3.0.11/SimSharp-3.0.11/Core/Resources/Events/ContainerGet.cs	(revision 16281)
+++ stable/HeuristicLab.ExtLibs/HeuristicLab.SimSharp/3.0.11/SimSharp-3.0.11/Core/Resources/Events/ContainerGet.cs	(revision 16281)
@@ -0,0 +1,36 @@
+﻿#region License Information
+/* SimSharp - A .NET port of SimPy, discrete event simulation framework
+Copyright (C) 2016  Heuristic and Evolutionary Algorithms Laboratory (HEAL)
+
+This program 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.
+
+This program 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 this program.  If not, see <http://www.gnu.org/licenses/>.*/
+#endregion
+
+using System;
+
+namespace SimSharp {
+  public class ContainerGet : Event {
+    public double Amount { get; protected set; }
+    public DateTime Time { get; private set; }
+    public Process Process { get; private set; }
+
+    public ContainerGet(Environment environment, Action<Event> callback, double amount)
+      : base(environment) {
+      if (amount <= 0) throw new ArgumentException("Amount must be > 0.", "amount");
+      Amount = amount;
+      CallbackList.Add(callback);
+      Time = environment.Now;
+      Process = environment.ActiveProcess;
+    }
+  }
+}
Index: stable/HeuristicLab.ExtLibs/HeuristicLab.SimSharp/3.0.11/SimSharp-3.0.11/Core/Resources/Events/ContainerPut.cs
===================================================================
--- stable/HeuristicLab.ExtLibs/HeuristicLab.SimSharp/3.0.11/SimSharp-3.0.11/Core/Resources/Events/ContainerPut.cs	(revision 16281)
+++ stable/HeuristicLab.ExtLibs/HeuristicLab.SimSharp/3.0.11/SimSharp-3.0.11/Core/Resources/Events/ContainerPut.cs	(revision 16281)
@@ -0,0 +1,36 @@
+﻿#region License Information
+/* SimSharp - A .NET port of SimPy, discrete event simulation framework
+Copyright (C) 2016  Heuristic and Evolutionary Algorithms Laboratory (HEAL)
+
+This program 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.
+
+This program 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 this program.  If not, see <http://www.gnu.org/licenses/>.*/
+#endregion
+
+using System;
+
+namespace SimSharp {
+  public class ContainerPut : Event {
+    public double Amount { get; protected set; }
+    public DateTime Time { get; private set; }
+    public Process Process { get; private set; }
+
+    public ContainerPut(Environment environment, Action<Event> callback, double amount)
+      : base(environment) {
+      if (amount <= 0) throw new ArgumentException("Amount must be > 0.", "amount");
+      Amount = amount;
+      CallbackList.Add(callback);
+      Time = environment.Now;
+      Process = environment.ActiveProcess;
+    }
+  }
+}
Index: stable/HeuristicLab.ExtLibs/HeuristicLab.SimSharp/3.0.11/SimSharp-3.0.11/Core/Resources/Events/FilterStoreGet.cs
===================================================================
--- stable/HeuristicLab.ExtLibs/HeuristicLab.SimSharp/3.0.11/SimSharp-3.0.11/Core/Resources/Events/FilterStoreGet.cs	(revision 16281)
+++ stable/HeuristicLab.ExtLibs/HeuristicLab.SimSharp/3.0.11/SimSharp-3.0.11/Core/Resources/Events/FilterStoreGet.cs	(revision 16281)
@@ -0,0 +1,30 @@
+﻿#region License Information
+/* SimSharp - A .NET port of SimPy, discrete event simulation framework
+Copyright (C) 2016  Heuristic and Evolutionary Algorithms Laboratory (HEAL)
+
+This program 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.
+
+This program 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 this program.  If not, see <http://www.gnu.org/licenses/>.*/
+#endregion
+
+using System;
+
+namespace SimSharp {
+  public class FilterStoreGet : StoreGet {
+    public Func<object, bool> Filter { get; private set; }
+
+    public FilterStoreGet(Environment environment, Action<Event> callback, Func<object, bool> filter)
+      : base(environment, callback) {
+      Filter = filter;
+    }
+  }
+}
Index: stable/HeuristicLab.ExtLibs/HeuristicLab.SimSharp/3.0.11/SimSharp-3.0.11/Core/Resources/Events/PreemptiveRequest.cs
===================================================================
--- stable/HeuristicLab.ExtLibs/HeuristicLab.SimSharp/3.0.11/SimSharp-3.0.11/Core/Resources/Events/PreemptiveRequest.cs	(revision 16281)
+++ stable/HeuristicLab.ExtLibs/HeuristicLab.SimSharp/3.0.11/SimSharp-3.0.11/Core/Resources/Events/PreemptiveRequest.cs	(revision 16281)
@@ -0,0 +1,30 @@
+﻿#region License Information
+/* SimSharp - A .NET port of SimPy, discrete event simulation framework
+Copyright (C) 2016  Heuristic and Evolutionary Algorithms Laboratory (HEAL)
+
+This program 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.
+
+This program 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 this program.  If not, see <http://www.gnu.org/licenses/>.*/
+#endregion
+
+using System;
+
+namespace SimSharp {
+  public sealed class PreemptiveRequest : PriorityRequest {
+    public bool Preempt { get; private set; }
+
+    public PreemptiveRequest(Environment environment, Action<Event> callback, Action<Event> disposeCallback, int priority = 1, bool preempt = false)
+      : base(environment, callback, disposeCallback, priority) {
+      Preempt = preempt;
+    }
+  }
+}
Index: stable/HeuristicLab.ExtLibs/HeuristicLab.SimSharp/3.0.11/SimSharp-3.0.11/Core/Resources/Events/PriorityRequest.cs
===================================================================
--- stable/HeuristicLab.ExtLibs/HeuristicLab.SimSharp/3.0.11/SimSharp-3.0.11/Core/Resources/Events/PriorityRequest.cs	(revision 16281)
+++ stable/HeuristicLab.ExtLibs/HeuristicLab.SimSharp/3.0.11/SimSharp-3.0.11/Core/Resources/Events/PriorityRequest.cs	(revision 16281)
@@ -0,0 +1,30 @@
+﻿#region License Information
+/* SimSharp - A .NET port of SimPy, discrete event simulation framework
+Copyright (C) 2016  Heuristic and Evolutionary Algorithms Laboratory (HEAL)
+
+This program 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.
+
+This program 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 this program.  If not, see <http://www.gnu.org/licenses/>.*/
+#endregion
+
+using System;
+
+namespace SimSharp {
+  public class PriorityRequest : Request {
+    public int Priority { get; private set; }
+
+    public PriorityRequest(Environment environment, Action<Event> callback, Action<Event> disposeCallback, int priority = 1)
+      : base(environment, callback, disposeCallback) {
+      Priority = priority;
+    }
+  }
+}
Index: stable/HeuristicLab.ExtLibs/HeuristicLab.SimSharp/3.0.11/SimSharp-3.0.11/Core/Resources/Events/Release.cs
===================================================================
--- stable/HeuristicLab.ExtLibs/HeuristicLab.SimSharp/3.0.11/SimSharp-3.0.11/Core/Resources/Events/Release.cs	(revision 16281)
+++ stable/HeuristicLab.ExtLibs/HeuristicLab.SimSharp/3.0.11/SimSharp-3.0.11/Core/Resources/Events/Release.cs	(revision 16281)
@@ -0,0 +1,31 @@
+﻿#region License Information
+/* SimSharp - A .NET port of SimPy, discrete event simulation framework
+Copyright (C) 2016  Heuristic and Evolutionary Algorithms Laboratory (HEAL)
+
+This program 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.
+
+This program 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 this program.  If not, see <http://www.gnu.org/licenses/>.*/
+#endregion
+
+using System;
+
+namespace SimSharp {
+  public sealed class Release : Event {
+    public Request Request { get; private set; }
+
+    public Release(Environment environment, Request request, Action<Event> callback)
+      : base(environment) {
+      Request = request;
+      CallbackList.Add(callback);
+    }
+  }
+}
Index: stable/HeuristicLab.ExtLibs/HeuristicLab.SimSharp/3.0.11/SimSharp-3.0.11/Core/Resources/Events/Request.cs
===================================================================
--- stable/HeuristicLab.ExtLibs/HeuristicLab.SimSharp/3.0.11/SimSharp-3.0.11/Core/Resources/Events/Request.cs	(revision 16281)
+++ stable/HeuristicLab.ExtLibs/HeuristicLab.SimSharp/3.0.11/SimSharp-3.0.11/Core/Resources/Events/Request.cs	(revision 16281)
@@ -0,0 +1,39 @@
+﻿#region License Information
+/* SimSharp - A .NET port of SimPy, discrete event simulation framework
+Copyright (C) 2016  Heuristic and Evolutionary Algorithms Laboratory (HEAL)
+
+This program 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.
+
+This program 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 this program.  If not, see <http://www.gnu.org/licenses/>.*/
+#endregion
+
+using System;
+
+namespace SimSharp {
+  public class Request : Event, IDisposable {
+    private readonly Action<Event> disposeCallback;
+    public DateTime Time { get; private set; }
+    public Process Process { get; private set; }
+
+    public Request(Environment environment, Action<Event> callback, Action<Event> disposeCallback)
+      : base(environment) {
+      CallbackList.Add(callback);
+      this.disposeCallback = disposeCallback;
+      Time = environment.Now;
+      Process = environment.ActiveProcess;
+    }
+
+    public virtual void Dispose() {
+      if (disposeCallback != null) disposeCallback(this);
+    }
+  }
+}
Index: stable/HeuristicLab.ExtLibs/HeuristicLab.SimSharp/3.0.11/SimSharp-3.0.11/Core/Resources/Events/ResourcePoolRequest.cs
===================================================================
--- stable/HeuristicLab.ExtLibs/HeuristicLab.SimSharp/3.0.11/SimSharp-3.0.11/Core/Resources/Events/ResourcePoolRequest.cs	(revision 16281)
+++ stable/HeuristicLab.ExtLibs/HeuristicLab.SimSharp/3.0.11/SimSharp-3.0.11/Core/Resources/Events/ResourcePoolRequest.cs	(revision 16281)
@@ -0,0 +1,30 @@
+﻿#region License Information
+/* SimSharp - A .NET port of SimPy, discrete event simulation framework
+Copyright (C) 2016  Heuristic and Evolutionary Algorithms Laboratory (HEAL)
+
+This program 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.
+
+This program 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 this program.  If not, see <http://www.gnu.org/licenses/>.*/
+#endregion
+
+using System;
+
+namespace SimSharp {
+  public class ResourcePoolRequest : Request {
+    public Func<object, bool> Filter { get; private set; }
+
+    public ResourcePoolRequest(Environment environment, Action<Event> callback, Action<Event> disposeCallback, Func<object, bool> filter)
+      : base(environment, callback, disposeCallback) {
+      Filter = filter;
+    }
+  }
+}
Index: stable/HeuristicLab.ExtLibs/HeuristicLab.SimSharp/3.0.11/SimSharp-3.0.11/Core/Resources/Events/StoreGet.cs
===================================================================
--- stable/HeuristicLab.ExtLibs/HeuristicLab.SimSharp/3.0.11/SimSharp-3.0.11/Core/Resources/Events/StoreGet.cs	(revision 16281)
+++ stable/HeuristicLab.ExtLibs/HeuristicLab.SimSharp/3.0.11/SimSharp-3.0.11/Core/Resources/Events/StoreGet.cs	(revision 16281)
@@ -0,0 +1,33 @@
+﻿#region License Information
+/* SimSharp - A .NET port of SimPy, discrete event simulation framework
+Copyright (C) 2016  Heuristic and Evolutionary Algorithms Laboratory (HEAL)
+
+This program 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.
+
+This program 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 this program.  If not, see <http://www.gnu.org/licenses/>.*/
+#endregion
+
+using System;
+
+namespace SimSharp {
+  public class StoreGet : Event {
+    public DateTime Time { get; private set; }
+    public Process Process { get; private set; }
+
+    public StoreGet(Environment environment, Action<Event> callback)
+      : base(environment) {
+      CallbackList.Add(callback);
+      Time = environment.Now;
+      Process = environment.ActiveProcess;
+    }
+  }
+}
Index: stable/HeuristicLab.ExtLibs/HeuristicLab.SimSharp/3.0.11/SimSharp-3.0.11/Core/Resources/Events/StorePut.cs
===================================================================
--- stable/HeuristicLab.ExtLibs/HeuristicLab.SimSharp/3.0.11/SimSharp-3.0.11/Core/Resources/Events/StorePut.cs	(revision 16281)
+++ stable/HeuristicLab.ExtLibs/HeuristicLab.SimSharp/3.0.11/SimSharp-3.0.11/Core/Resources/Events/StorePut.cs	(revision 16281)
@@ -0,0 +1,35 @@
+﻿#region License Information
+/* SimSharp - A .NET port of SimPy, discrete event simulation framework
+Copyright (C) 2016  Heuristic and Evolutionary Algorithms Laboratory (HEAL)
+
+This program 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.
+
+This program 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 this program.  If not, see <http://www.gnu.org/licenses/>.*/
+#endregion
+
+using System;
+
+namespace SimSharp {
+  public class StorePut : Event {
+    public DateTime Time { get; private set; }
+    public Process Process { get; private set; }
+
+    public StorePut(Environment environment, Action<Event> callback, object value)
+      : base(environment) {
+      if (value == null) throw new ArgumentNullException("value", "Value to put in a Store cannot be null.");
+      CallbackList.Add(callback);
+      Value = value;
+      Time = environment.Now;
+      Process = environment.ActiveProcess;
+    }
+  }
+}
Index: stable/HeuristicLab.ExtLibs/HeuristicLab.SimSharp/3.0.11/SimSharp-3.0.11/Core/Resources/FilterStore.cs
===================================================================
--- stable/HeuristicLab.ExtLibs/HeuristicLab.SimSharp/3.0.11/SimSharp-3.0.11/Core/Resources/FilterStore.cs	(revision 16281)
+++ stable/HeuristicLab.ExtLibs/HeuristicLab.SimSharp/3.0.11/SimSharp-3.0.11/Core/Resources/FilterStore.cs	(revision 16281)
@@ -0,0 +1,111 @@
+﻿#region License Information
+/* SimSharp - A .NET port of SimPy, discrete event simulation framework
+Copyright (C) 2016  Heuristic and Evolutionary Algorithms Laboratory (HEAL)
+
+This program 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.
+
+This program 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 this program.  If not, see <http://www.gnu.org/licenses/>.*/
+#endregion
+
+using System;
+using System.Collections.Generic;
+using System.Linq;
+
+namespace SimSharp {
+  public class FilterStore {
+    public int Count { get { return Items.Count; } }
+    public int Capacity { get; protected set; }
+    protected Environment Environment { get; private set; }
+
+    protected Queue<StorePut> PutQueue { get; private set; }
+    protected LinkedList<FilterStoreGet> GetQueue { get; private set; }
+    protected List<object> Items { get; private set; }
+
+    public FilterStore(Environment environment, int capacity = int.MaxValue) {
+      if (capacity <= 0) throw new ArgumentException("Capacity must be > 0", "capacity");
+      Environment = environment;
+      Capacity = capacity;
+      PutQueue = new Queue<StorePut>();
+      GetQueue = new LinkedList<FilterStoreGet>();
+      Items = new List<object>();
+    }
+    public FilterStore(Environment environment, IEnumerable<object> items, int capacity = int.MaxValue) {
+      if (capacity <= 0) throw new ArgumentException("Capacity must be > 0", "capacity");
+      Environment = environment;
+      Capacity = capacity;
+      PutQueue = new Queue<StorePut>();
+      GetQueue = new LinkedList<FilterStoreGet>();
+      Items = new List<object>(items);
+      if (capacity < Items.Count) throw new ArgumentException("There are more initial items than there is capacity.", "items");
+    }
+
+    public virtual bool IsAvailable(Func<object, bool> filter) {
+      return Items.Any(filter);
+    }
+
+    public virtual StorePut Put(object item) {
+      var put = new StorePut(Environment, TriggerGet, item);
+      PutQueue.Enqueue(put);
+      TriggerPut();
+      return put;
+    }
+
+    public virtual FilterStoreGet Get(Func<object, bool> filter = null) {
+      if (filter == null) filter = _ => true;
+      var get = new FilterStoreGet(Environment, TriggerPut, filter);
+      GetQueue.AddLast(get);
+      TriggerGet();
+      return get;
+    }
+
+    protected virtual void DoPut(StorePut put) {
+      if (Items.Count < Capacity) {
+        Items.Add(put.Value);
+        put.Succeed();
+      }
+    }
+
+    protected virtual void DoGet(FilterStoreGet get) {
+      for (int i = 0; i < Items.Count; i++) {
+        var item = Items[i];
+        if (!get.Filter(item)) continue;
+        Items.RemoveAt(i);
+        get.Succeed(item);
+        return;
+      }
+    }
+
+    protected virtual void TriggerPut(Event @event = null) {
+      while (PutQueue.Count > 0) {
+        var put = PutQueue.Peek();
+        DoPut(put);
+        if (put.IsTriggered) {
+          PutQueue.Dequeue();
+        } else break;
+      }
+    }
+
+    protected virtual void TriggerGet(Event @event = null) {
+      var current = GetQueue.First;
+      while (current != null) {
+        var get = current.Value;
+        DoGet(get);
+        if (get.IsTriggered) {
+          var next = current.Next;
+          GetQueue.Remove(current);
+          current = next;
+        } else current = current.Next;
+        if (Items.Count == 0) break;
+      }
+    }
+  }
+}
Index: stable/HeuristicLab.ExtLibs/HeuristicLab.SimSharp/3.0.11/SimSharp-3.0.11/Core/Resources/PreemptiveResource.cs
===================================================================
--- stable/HeuristicLab.ExtLibs/HeuristicLab.SimSharp/3.0.11/SimSharp-3.0.11/Core/Resources/PreemptiveResource.cs	(revision 16281)
+++ stable/HeuristicLab.ExtLibs/HeuristicLab.SimSharp/3.0.11/SimSharp-3.0.11/Core/Resources/PreemptiveResource.cs	(revision 16281)
@@ -0,0 +1,129 @@
+﻿#region License Information
+/* SimSharp - A .NET port of SimPy, discrete event simulation framework
+Copyright (C) 2016  Heuristic and Evolutionary Algorithms Laboratory (HEAL)
+
+This program 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.
+
+This program 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 this program.  If not, see <http://www.gnu.org/licenses/>.*/
+#endregion
+
+using System;
+using System.Collections.Generic;
+using System.Linq;
+
+namespace SimSharp {
+  public class PreemptiveResource {
+
+    public int Capacity { get; protected set; }
+
+    public int InUse { get { return Users.Count; } }
+
+    public int Remaining { get { return Capacity - InUse; } }
+
+    protected Environment Environment { get; private set; }
+
+    protected SortedList<int, LinkedList<PreemptiveRequest>> RequestQueue { get; private set; }
+    protected Queue<Release> ReleaseQueue { get; private set; }
+    protected HashSet<Request> Users { get; private set; }
+
+    public PreemptiveResource(Environment environment, int capacity = 1) {
+      if (capacity <= 0) throw new ArgumentException("Capacity must be > 0.", "capacity");
+      Environment = environment;
+      Capacity = capacity;
+      RequestQueue = new SortedList<int, LinkedList<PreemptiveRequest>>();
+      ReleaseQueue = new Queue<Release>();
+      Users = new HashSet<Request>();
+    }
+
+    public virtual PreemptiveRequest Request(int priority = 1, bool preempt = false) {
+      var request = new PreemptiveRequest(Environment, TriggerRelease, DisposeCallback, priority, preempt);
+      if (!RequestQueue.ContainsKey(request.Priority))
+        RequestQueue.Add(request.Priority, new LinkedList<PreemptiveRequest>());
+      RequestQueue[request.Priority].AddLast(request);
+      TriggerRequest();
+      return request;
+    }
+
+    public virtual Release Release(PreemptiveRequest request) {
+      var release = new Release(Environment, request, TriggerRequest);
+      ReleaseQueue.Enqueue(release);
+      TriggerRelease();
+      return release;
+    }
+
+    protected void DisposeCallback(Event @event) {
+      var request = @event as PreemptiveRequest;
+      if (request != null) Release(request);
+    }
+
+    protected virtual void DoRequest(PreemptiveRequest request) {
+      if (Users.Count >= Capacity && request.Preempt) {
+        // Check if we can preempt another process
+        var oldest = Users.OfType<PreemptiveRequest>().Select((r, i) => new { Request = r, Index = i })
+          .OrderByDescending(x => x.Request.Priority)
+          .ThenByDescending(x => x.Request.Time)
+          .ThenByDescending(x => x.Request.Preempt)
+          .ThenByDescending(x => x.Index)
+          .First().Request;
+        if (oldest.Priority > request.Priority || (oldest.Priority == request.Priority
+            && (!oldest.Preempt && request.Preempt || (oldest.Preempt == request.Preempt
+              && oldest.Time > request.Time)))) {
+          Users.Remove(oldest);
+          oldest.Process.Interrupt(new Preempted(request.Process, oldest.Time));
+        }
+      }
+      if (Users.Count < Capacity) {
+        Users.Add(request);
+        request.Succeed();
+      }
+    }
+
+    protected virtual void DoRelease(Release release) {
+      if (!Users.Remove(release.Request)) {
+        var preemptRequest = release.Request as PreemptiveRequest;
+        if (preemptRequest != null) {
+          var current = RequestQueue[preemptRequest.Priority].First;
+          while (current != null && current.Value != release.Request)
+            current = current.Next;
+          if (current != null) RequestQueue[preemptRequest.Priority].Remove(current);
+        }
+      }
+      release.Succeed();
+    }
+
+    protected virtual void TriggerRequest(Event @event = null) {
+      foreach (var entry in RequestQueue) {
+        var requests = entry.Value;
+        var current = requests.First;
+        while (current != null) {
+          var request = current.Value;
+          DoRequest(request);
+          if (request.IsTriggered) {
+            var next = current.Next;
+            requests.Remove(current);
+            current = next;
+          } else current = current.Next;
+        }
+      }
+    }
+
+    protected virtual void TriggerRelease(Event @event = null) {
+      while (ReleaseQueue.Count > 0) {
+        var release = ReleaseQueue.Peek();
+        DoRelease(release);
+        if (release.IsTriggered) {
+          ReleaseQueue.Dequeue();
+        } else break;
+      }
+    }
+  }
+}
Index: stable/HeuristicLab.ExtLibs/HeuristicLab.SimSharp/3.0.11/SimSharp-3.0.11/Core/Resources/PriorityResource.cs
===================================================================
--- stable/HeuristicLab.ExtLibs/HeuristicLab.SimSharp/3.0.11/SimSharp-3.0.11/Core/Resources/PriorityResource.cs	(revision 16281)
+++ stable/HeuristicLab.ExtLibs/HeuristicLab.SimSharp/3.0.11/SimSharp-3.0.11/Core/Resources/PriorityResource.cs	(revision 16281)
@@ -0,0 +1,115 @@
+﻿#region License Information
+/* SimSharp - A .NET port of SimPy, discrete event simulation framework
+Copyright (C) 2016  Heuristic and Evolutionary Algorithms Laboratory (HEAL)
+
+This program 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.
+
+This program 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 this program.  If not, see <http://www.gnu.org/licenses/>.*/
+#endregion
+
+using System;
+using System.Collections.Generic;
+
+namespace SimSharp {
+  public class PriorityResource {
+
+    public int Capacity { get; protected set; }
+
+    public int InUse { get { return Users.Count; } }
+
+    public int Remaining { get { return Capacity - InUse; } }
+
+    protected Environment Environment { get; private set; }
+
+    protected SortedList<int, LinkedList<PriorityRequest>> RequestQueue { get; private set; }
+    protected Queue<Release> ReleaseQueue { get; private set; }
+    protected HashSet<Request> Users { get; private set; }
+
+    public PriorityResource(Environment environment, int capacity = 1) {
+      if (capacity <= 0) throw new ArgumentException("Capacity must be > 0.", "capacity");
+      Environment = environment;
+      Capacity = capacity;
+      RequestQueue = new SortedList<int, LinkedList<PriorityRequest>>();
+      ReleaseQueue = new Queue<Release>();
+      Users = new HashSet<Request>();
+    }
+
+    public virtual PriorityRequest Request(int priority = 1) {
+      var request = new PriorityRequest(Environment, TriggerRelease, DisposeCallback, priority);
+      if (!RequestQueue.ContainsKey(priority))
+        RequestQueue.Add(priority, new LinkedList<PriorityRequest>());
+      RequestQueue[priority].AddLast(request);
+      TriggerRequest();
+      return request;
+    }
+
+    public virtual Release Release(PriorityRequest request) {
+      var release = new Release(Environment, request, TriggerRequest);
+      ReleaseQueue.Enqueue(release);
+      TriggerRelease();
+      return release;
+    }
+
+    protected void DisposeCallback(Event @event) {
+      var request = @event as PriorityRequest;
+      if (request != null) Release(request);
+    }
+
+    protected virtual void DoRequest(Request request) {
+      if (Users.Count < Capacity) {
+        Users.Add(request);
+        request.Succeed();
+      }
+    }
+
+    protected virtual void DoRelease(Release release) {
+      if (!Users.Remove(release.Request)) {
+        var prioRequest = release.Request as PriorityRequest;
+        if (prioRequest != null) {
+          var current = RequestQueue[prioRequest.Priority].First;
+          while (current != null && current.Value != release.Request)
+            current = current.Next;
+          if (current != null) RequestQueue[prioRequest.Priority].Remove(current);
+        }
+      }
+      release.Succeed();
+    }
+
+    protected virtual void TriggerRequest(Event @event = null) {
+      foreach (var entry in RequestQueue) {
+        var cascade = false;
+        var requests = entry.Value;
+        while (requests.Count > 0) {
+          var req = requests.First.Value;
+          DoRequest(req);
+          if (req.IsTriggered) {
+            requests.RemoveFirst();
+          } else {
+            cascade = true;
+            break;
+          }
+        }
+        if (cascade) break;
+      }
+    }
+
+    protected virtual void TriggerRelease(Event @event = null) {
+      while (ReleaseQueue.Count > 0) {
+        var release = ReleaseQueue.Peek();
+        DoRelease(release);
+        if (release.IsTriggered) {
+          ReleaseQueue.Dequeue();
+        } else break;
+      }
+    }
+  }
+}
Index: stable/HeuristicLab.ExtLibs/HeuristicLab.SimSharp/3.0.11/SimSharp-3.0.11/Core/Resources/Resource.cs
===================================================================
--- stable/HeuristicLab.ExtLibs/HeuristicLab.SimSharp/3.0.11/SimSharp-3.0.11/Core/Resources/Resource.cs	(revision 16281)
+++ stable/HeuristicLab.ExtLibs/HeuristicLab.SimSharp/3.0.11/SimSharp-3.0.11/Core/Resources/Resource.cs	(revision 16281)
@@ -0,0 +1,104 @@
+﻿#region License Information
+/* SimSharp - A .NET port of SimPy, discrete event simulation framework
+Copyright (C) 2016  Heuristic and Evolutionary Algorithms Laboratory (HEAL)
+
+This program 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.
+
+This program 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 this program.  If not, see <http://www.gnu.org/licenses/>.*/
+#endregion
+
+using System;
+using System.Collections.Generic;
+
+namespace SimSharp {
+  public class Resource {
+
+    public int Capacity { get; protected set; }
+
+    public int InUse { get { return Users.Count; } }
+
+    public int Remaining { get { return Capacity - InUse; } }
+
+    protected Environment Environment { get; private set; }
+
+    protected LinkedList<Request> RequestQueue { get; private set; }
+    protected Queue<Release> ReleaseQueue { get; private set; }
+    protected HashSet<Request> Users { get; private set; }
+
+    public Resource(Environment environment, int capacity = 1) {
+      if (capacity <= 0) throw new ArgumentException("Capacity must > 0.", "capacity");
+      Environment = environment;
+      Capacity = capacity;
+      RequestQueue = new LinkedList<Request>();
+      ReleaseQueue = new Queue<Release>();
+      Users = new HashSet<Request>();
+    }
+
+    public virtual Request Request() {
+      var request = new Request(Environment, TriggerRelease, DisposeCallback);
+      RequestQueue.AddLast(request);
+      TriggerRequest();
+      return request;
+    }
+
+    public virtual Release Release(Request request) {
+      var release = new Release(Environment, request, TriggerRequest);
+      ReleaseQueue.Enqueue(release);
+      TriggerRelease();
+      return release;
+    }
+
+    protected virtual void DisposeCallback(Event @event) {
+      var request = @event as Request;
+      if (request != null) {
+        Release(request);
+      }
+    }
+
+    protected virtual void DoRequest(Request request) {
+      if (Users.Count < Capacity) {
+        Users.Add(request);
+        request.Succeed();
+      }
+    }
+
+    protected virtual void DoRelease(Release release) {
+      if (!Users.Remove(release.Request)) {
+        var current = RequestQueue.First;
+        while (current != null && current.Value != release.Request)
+          current = current.Next;
+        if (current != null) RequestQueue.Remove(current);
+      }
+      release.Succeed();
+    }
+
+    protected virtual void TriggerRequest(Event @event = null) {
+      while (RequestQueue.Count > 0) {
+        var request = RequestQueue.First.Value;
+        DoRequest(request);
+        if (request.IsTriggered) {
+          RequestQueue.RemoveFirst();
+        } else break;
+      }
+    }
+
+    protected virtual void TriggerRelease(Event @event = null) {
+      while (ReleaseQueue.Count > 0) {
+        var release = ReleaseQueue.Peek();
+        DoRelease(release);
+        if (release.IsTriggered) {
+          ReleaseQueue.Dequeue();
+        } else break;
+      }
+    }
+  }
+}
Index: stable/HeuristicLab.ExtLibs/HeuristicLab.SimSharp/3.0.11/SimSharp-3.0.11/Core/Resources/ResourcePool.cs
===================================================================
--- stable/HeuristicLab.ExtLibs/HeuristicLab.SimSharp/3.0.11/SimSharp-3.0.11/Core/Resources/ResourcePool.cs	(revision 16281)
+++ stable/HeuristicLab.ExtLibs/HeuristicLab.SimSharp/3.0.11/SimSharp-3.0.11/Core/Resources/ResourcePool.cs	(revision 16281)
@@ -0,0 +1,110 @@
+﻿#region License Information
+/* SimSharp - A .NET port of SimPy, discrete event simulation framework
+Copyright (C) 2016  Heuristic and Evolutionary Algorithms Laboratory (HEAL)
+
+This program 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.
+
+This program 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 this program.  If not, see <http://www.gnu.org/licenses/>.*/
+#endregion
+
+using System;
+using System.Collections.Generic;
+using System.Linq;
+
+namespace SimSharp {
+  public class ResourcePool {
+    protected static readonly Func<object, bool> TrueFunc = _ => true;
+
+    public int Capacity { get; protected set; }
+
+    public int InUse { get { return Capacity - Remaining; } }
+
+    public int Remaining { get { return Resources.Count; } }
+
+    protected Environment Environment { get; private set; }
+
+    protected LinkedList<ResourcePoolRequest> RequestQueue { get; private set; }
+    protected Queue<Release> ReleaseQueue { get; private set; }
+    protected List<object> Resources { get; private set; }
+
+    public ResourcePool(Environment environment, IEnumerable<object> resources) {
+      Environment = environment;
+      if (resources == null) throw new ArgumentNullException("resources");
+      Resources = new List<object>(resources);
+      Capacity = Resources.Count;
+      if (Capacity == 0) throw new ArgumentException("There must be at least one resource", "resources");
+      RequestQueue = new LinkedList<ResourcePoolRequest>();
+      ReleaseQueue = new Queue<Release>();
+    }
+
+    public virtual bool IsAvailable(Func<object, bool> filter) {
+      return Resources.Any(filter);
+    }
+
+    public virtual ResourcePoolRequest Request(Func<object, bool> filter = null) {
+      var request = new ResourcePoolRequest(Environment, TriggerRelease, DisposeCallback, filter ?? TrueFunc);
+      RequestQueue.AddLast(request);
+      TriggerRequest();
+      return request;
+    }
+
+    public virtual Release Release(Request request) {
+      var release = new Release(Environment, request, TriggerRequest);
+      ReleaseQueue.Enqueue(release);
+      TriggerRelease();
+      return release;
+    }
+
+    protected virtual void DisposeCallback(Event @event) {
+      var request = @event as Request;
+      if (request != null) Release(request);
+    }
+
+    protected virtual void DoRequest(ResourcePoolRequest request) {
+      foreach (var o in Resources) {
+        if (!request.Filter(o)) continue;
+        Resources.Remove(o);
+        request.Succeed(o);
+        return;
+      }
+    }
+
+    protected virtual void DoRelease(Release release) {
+      Resources.Add(release.Request.Value);
+      release.Succeed();
+    }
+
+    protected virtual void TriggerRequest(Event @event = null) {
+      var current = RequestQueue.First;
+      while (current != null) {
+        var request = current.Value;
+        DoRequest(request);
+        if (request.IsTriggered) {
+          var next = current.Next;
+          RequestQueue.Remove(current);
+          current = next;
+        } else current = current.Next;
+        if (Resources.Count == 0) break;
+      }
+    }
+
+    protected virtual void TriggerRelease(Event @event = null) {
+      while (ReleaseQueue.Count > 0) {
+        var release = ReleaseQueue.Peek();
+        DoRelease(release);
+        if (release.IsTriggered) {
+          ReleaseQueue.Dequeue();
+        } else break;
+      }
+    }
+  }
+}
Index: stable/HeuristicLab.ExtLibs/HeuristicLab.SimSharp/3.0.11/SimSharp-3.0.11/Core/Resources/Store.cs
===================================================================
--- stable/HeuristicLab.ExtLibs/HeuristicLab.SimSharp/3.0.11/SimSharp-3.0.11/Core/Resources/Store.cs	(revision 16281)
+++ stable/HeuristicLab.ExtLibs/HeuristicLab.SimSharp/3.0.11/SimSharp-3.0.11/Core/Resources/Store.cs	(revision 16281)
@@ -0,0 +1,91 @@
+﻿#region License Information
+/* SimSharp - A .NET port of SimPy, discrete event simulation framework
+Copyright (C) 2016  Heuristic and Evolutionary Algorithms Laboratory (HEAL)
+
+This program 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.
+
+This program 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 this program.  If not, see <http://www.gnu.org/licenses/>.*/
+#endregion
+
+using System;
+using System.Collections.Generic;
+using System.Linq;
+
+namespace SimSharp {
+  public class Store {
+    public int Count { get { return Items.Count; } }
+    public int Capacity { get; protected set; }
+    protected Environment Environment { get; private set; }
+
+    protected Queue<StorePut> PutQueue { get; private set; }
+    protected Queue<StoreGet> GetQueue { get; private set; }
+    protected List<object> Items { get; private set; }
+
+    public Store(Environment environment, int capacity = int.MaxValue) {
+      if (capacity <= 0) throw new ArgumentException("Capacity must be > 0", "capacity");
+      Environment = environment;
+      Capacity = capacity;
+      PutQueue = new Queue<StorePut>();
+      GetQueue = new Queue<StoreGet>();
+      Items = new List<object>();
+    }
+
+    public virtual StorePut Put(object item) {
+      var put = new StorePut(Environment, TriggerGet, item);
+      PutQueue.Enqueue(put);
+      TriggerPut();
+      return put;
+    }
+
+    public virtual StoreGet Get() {
+      var get = new StoreGet(Environment, TriggerPut);
+      GetQueue.Enqueue(get);
+      TriggerGet();
+      return get;
+    }
+
+    protected virtual void DoPut(StorePut put) {
+      if (Items.Count < Capacity) {
+        Items.Add(put.Value);
+        put.Succeed();
+      }
+    }
+
+    protected virtual void DoGet(StoreGet get) {
+      if (Items.Count > 0) {
+        var item = Items.First();
+        Items.RemoveAt(0);
+        get.Succeed(item);
+      }
+    }
+
+    protected virtual void TriggerPut(Event @event = null) {
+      while (PutQueue.Count > 0) {
+        var put = PutQueue.Peek();
+        DoPut(put);
+        if (put.IsTriggered) {
+          PutQueue.Dequeue();
+        } else break;
+      }
+    }
+
+    protected virtual void TriggerGet(Event @event = null) {
+      while (GetQueue.Count > 0) {
+        var get = GetQueue.Peek();
+        DoGet(get);
+        if (get.IsTriggered) {
+          GetQueue.Dequeue();
+        } else break;
+      }
+    }
+  }
+}
Index: stable/HeuristicLab.ExtLibs/HeuristicLab.SimSharp/3.0.11/SimSharp-3.0.11/Properties/AssemblyInfo.cs
===================================================================
--- stable/HeuristicLab.ExtLibs/HeuristicLab.SimSharp/3.0.11/SimSharp-3.0.11/Properties/AssemblyInfo.cs	(revision 16281)
+++ stable/HeuristicLab.ExtLibs/HeuristicLab.SimSharp/3.0.11/SimSharp-3.0.11/Properties/AssemblyInfo.cs	(revision 16281)
@@ -0,0 +1,53 @@
+﻿#region License Information
+/* SimSharp - A .NET port of SimPy, discrete event simulation framework
+Copyright (C) 2002-2018 Heuristic and Evolutionary Algorithms Laboratory (HEAL)
+
+This program 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.
+
+This program 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 this program.  If not, see <http://www.gnu.org/licenses/>.*/
+#endregion
+
+using System.Reflection;
+using System.Runtime.InteropServices;
+
+// General Information about an assembly is controlled through the following 
+// set of attributes. Change these attribute values to modify the information
+// associated with an assembly.
+[assembly: AssemblyTitle("SimSharp")]
+[assembly: AssemblyDescription("A .NET port of SimPy, discrete event simulation framework")]
+[assembly: AssemblyConfiguration("")]
+[assembly: AssemblyCompany("HEAL")]
+[assembly: AssemblyProduct("SimSharp")]
+[assembly: AssemblyCopyright("(c) 2002-2018 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("d51e9cc2-c26b-4df5-94f8-ca8f63f75db9")]
+
+// 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.0.11.0")]
+[assembly: AssemblyFileVersion("3.0.11.0")]
Index: stable/HeuristicLab.ExtLibs/HeuristicLab.SimSharp/3.0.11/SimSharp-3.0.11/Random/FastRandom.cs
===================================================================
--- stable/HeuristicLab.ExtLibs/HeuristicLab.SimSharp/3.0.11/SimSharp-3.0.11/Random/FastRandom.cs	(revision 16281)
+++ stable/HeuristicLab.ExtLibs/HeuristicLab.SimSharp/3.0.11/SimSharp-3.0.11/Random/FastRandom.cs	(revision 16281)
@@ -0,0 +1,413 @@
+﻿/* ***************************************************************************
+ * This file is part of SharpNEAT - Evolution of Neural Networks.
+ * 
+ * Copyright 2004-2006, 2009-2010 Colin Green (sharpneat@gmail.com)
+ *
+ * SharpNEAT 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.
+ *
+ * SharpNEAT 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 SharpNEAT.  If not, see <http://www.gnu.org/licenses/>.
+ */
+
+// ENHANCEMENT: Replace usages of this class with the superceding version from Math.Net.
+using System;
+
+namespace SimSharp {
+  /// <summary>
+  /// A fast random number generator for .NET
+  /// Colin Green, January 2005
+  /// 
+  /// Key points:
+  ///  1) Based on a simple and fast xor-shift pseudo random number generator (RNG) specified in: 
+  ///  Marsaglia, George. (2003). Xorshift RNGs.
+  ///  http://www.jstatsoft.org/v08/i14/paper
+  ///  
+  ///  This particular implementation of xorshift has a period of 2^128-1. See the above paper to see
+  ///  how this can be easily extened if you need a longer period. At the time of writing I could find no 
+  ///  information on the period of System.Random for comparison.
+  /// 
+  ///  2) Faster than System.Random. Up to 8x faster, depending on which methods are called.
+  /// 
+  ///  3) Direct replacement for System.Random. This class implements all of the methods that System.Random 
+  ///  does plus some additional methods. The like named methods are functionally equivalent.
+  ///  
+  ///  4) Allows fast re-initialisation with a seed, unlike System.Random which accepts a seed at construction
+  ///  time which then executes a relatively expensive initialisation routine. This provides a vast speed improvement
+  ///  if you need to reset the pseudo-random number sequence many times, e.g. if you want to re-generate the same
+  ///  sequence of random numbers many times. An alternative might be to cache random numbers in an array, but that 
+  ///  approach is limited by memory capacity and the fact that you may also want a large number of different sequences 
+  ///  cached. Each sequence can be represented by a single seed value (int) when using FastRandom.
+  ///  
+  ///  Notes.
+  ///  A further performance improvement can be obtained by declaring local variables as static, thus avoiding 
+  ///  re-allocation of variables on each call. However care should be taken if multiple instances of
+  ///  FastRandom are in use or if being used in a multi-threaded environment.
+  /// 
+  /// 
+  /// Colin Green, September 4th 2005
+  ///   - Added NextBytesUnsafe() - commented out by default.
+  ///   - Fixed bug in Reinitialise() - y,z and w variables were not being reset.
+  ///     
+  /// Colin Green, December 2008.
+  ///   - Fix to Next() - Was previously able to return int.MaxValue, contrary to the method's contract and comments.
+  ///   - Modified NextBool() to use _bitMask instead of a count of remaining bits. Also reset the bit buffer in Reinitialise().
+  ///    
+  /// Colin Green, 2011-08-31
+  ///   - Added NextByte() method.
+  ///   - Added new statically declared seedRng FastRandom to allow easy creation of multiple FastRandoms with different seeds 
+  ///     within a single clock tick.
+  ///     
+  /// Colin Green, 2011-10-04
+  ///  - Seeds are now hashed. Without this the first random sample for nearby seeds (1,2,3, etc.) are very similar 
+  ///    (have a similar bit pattern). Thanks to Francois Guibert for identifying this problem.
+  /// 
+  /// </summary>
+  public class FastRandom : IRandom {
+    #region Static Fields
+    /// <summary>
+    /// A static RNG that is used to generate seed values when constructing new instances of FastRandom.
+    /// This overcomes the problem whereby multiple FastRandom instances are instantiated within the same
+    /// tick count and thus obtain the same seed, that approach can result in extreme biases occuring 
+    /// in some cases depending on how the RNG is used.
+    /// </summary>
+    static readonly FastRandom __seedRng = new FastRandom((int)System.Environment.TickCount);
+    #endregion
+
+    #region Instance Fields
+
+    // The +1 ensures NextDouble doesn't generate 1.0
+    const double REAL_UNIT_INT = 1.0 / ((double)int.MaxValue + 1.0);
+    const double REAL_UNIT_UINT = 1.0 / ((double)uint.MaxValue + 1.0);
+    const uint Y = 842502087, Z = 3579807591, W = 273326509;
+
+    uint _x, _y, _z, _w;
+
+    #endregion
+
+    #region Constructors
+
+    /// <summary>
+    /// Initialises a new instance using a seed generated from the class's static seed RNG.
+    /// </summary>
+    public FastRandom() {
+      Reinitialise(__seedRng.NextInt());
+    }
+
+    /// <summary>
+    /// Initialises a new instance using an int value as seed.
+    /// This constructor signature is provided to maintain compatibility with
+    /// System.Random
+    /// </summary>
+    public FastRandom(int seed) {
+      Reinitialise(seed);
+    }
+
+    #endregion
+
+    #region Public Methods [Reinitialisation]
+
+    /// <summary>
+    /// Reinitialises using an int value as a seed.
+    /// </summary>
+    public void Reinitialise(int seed) {
+      // The only stipulation stated for the xorshift RNG is that at least one of
+      // the seeds x,y,z,w is non-zero. We fulfill that requirement by only allowing
+      // resetting of the x seed.
+
+      // The first random sample will be very closely related to the value of _x we set here. 
+      // Thus setting _x = seed will result in a close correlation between the bit patterns of the seed and
+      // the first random sample, therefore if the seed has a pattern (e.g. 1,2,3) then there will also be 
+      // a recognisable pattern across the first random samples.
+      //
+      // Such a strong correlation between the seed and the first random sample is an undesirable
+      // charactersitic of a RNG, therefore we significantly weaken any correlation by hashing the seed's bits. 
+      // This is achieved by multiplying the seed with four large primes each with bits distributed over the
+      // full length of a 32bit value, finally adding the results to give _x.
+      _x = (uint)((seed * 1431655781)
+                  + (seed * 1183186591)
+                  + (seed * 622729787)
+                  + (seed * 338294347));
+
+      _y = Y;
+      _z = Z;
+      _w = W;
+
+      _bitBuffer = 0;
+      _bitMask = 1;
+    }
+
+    #endregion
+
+    #region Public Methods [System.Random functionally equivalent methods]
+
+    /// <summary>
+    /// Generates a random int over the range 0 to int.MaxValue-1.
+    /// MaxValue is not generated in order to remain functionally equivalent to System.Random.Next().
+    /// This does slightly eat into some of the performance gain over System.Random, but not much.
+    /// For better performance see:
+    /// 
+    /// Call NextInt() for an int over the range 0 to int.MaxValue.
+    /// 
+    /// Call NextUInt() and cast the result to an int to generate an int over the full Int32 value range
+    /// including negative values. 
+    /// </summary>
+    public int Next() {
+      uint t = _x ^ (_x << 11);
+      _x = _y; _y = _z; _z = _w;
+      _w = (_w ^ (_w >> 19)) ^ (t ^ (t >> 8));
+
+      // Handle the special case where the value int.MaxValue is generated. This is outside of 
+      // the range of permitted values, so we therefore call Next() to try again.
+      uint rtn = _w & 0x7FFFFFFF;
+      if (rtn == 0x7FFFFFFF) {
+        return Next();
+      }
+      return (int)rtn;
+    }
+
+    /// <summary>
+    /// Generates a random int over the range 0 to upperBound-1, and not including upperBound.
+    /// </summary>
+    public int Next(int upperBound) {
+      if (upperBound < 0) {
+        throw new ArgumentOutOfRangeException("upperBound", upperBound, "upperBound must be >=0");
+      }
+
+      uint t = _x ^ (_x << 11);
+      _x = _y; _y = _z; _z = _w;
+
+      // ENHANCEMENT: Can we do this without converting to a double and back again?
+      // The explicit int cast before the first multiplication gives better performance.
+      // See comments in NextDouble.
+      return (int)((REAL_UNIT_INT * (int)(0x7FFFFFFF & (_w = (_w ^ (_w >> 19)) ^ (t ^ (t >> 8))))) * upperBound);
+    }
+
+    /// <summary>
+    /// Generates a random int over the range lowerBound to upperBound-1, and not including upperBound.
+    /// upperBound must be >= lowerBound. lowerBound may be negative.
+    /// </summary>
+    public int Next(int lowerBound, int upperBound) {
+      if (lowerBound > upperBound) {
+        throw new ArgumentOutOfRangeException("upperBound", upperBound, "upperBound must be >=lowerBound");
+      }
+
+      uint t = _x ^ (_x << 11);
+      _x = _y; _y = _z; _z = _w;
+
+      // The explicit int cast before the first multiplication gives better performance.
+      // See comments in NextDouble.
+      int range = upperBound - lowerBound;
+      if (range < 0) {   // If range is <0 then an overflow has occured and must resort to using long integer arithmetic instead (slower).
+        // We also must use all 32 bits of precision, instead of the normal 31, which again is slower.  
+        return lowerBound + (int)((REAL_UNIT_UINT * (double)(_w = (_w ^ (_w >> 19)) ^ (t ^ (t >> 8)))) * (double)((long)upperBound - (long)lowerBound));
+      }
+
+      // 31 bits of precision will suffice if range<=int.MaxValue. This allows us to cast to an int and gain
+      // a little more performance.
+      return lowerBound + (int)((REAL_UNIT_INT * (double)(int)(0x7FFFFFFF & (_w = (_w ^ (_w >> 19)) ^ (t ^ (t >> 8))))) * (double)range);
+    }
+
+    /// <summary>
+    /// Generates a random double. Values returned are over the range [0, 1). That is, inclusive of 0.0 and exclusive of 1.0.
+    /// </summary>
+    public double NextDouble() {
+      uint t = _x ^ (_x << 11);
+      _x = _y; _y = _z; _z = _w;
+
+      // Here we can gain a 2x speed improvement by generating a value that can be cast to 
+      // an int instead of the more easily available uint. If we then explicitly cast to an 
+      // int the compiler will then cast the int to a double to perform the multiplication, 
+      // this final cast is a lot faster than casting from a uint to a double. The extra cast
+      // to an int is very fast (the allocated bits remain the same) and so the overall effect 
+      // of the extra cast is a significant performance improvement.
+      //
+      // Also note that the loss of one bit of precision is equivalent to what occurs within 
+      // System.Random.
+      return REAL_UNIT_INT * (int)(0x7FFFFFFF & (_w = (_w ^ (_w >> 19)) ^ (t ^ (t >> 8))));
+    }
+
+    /// <summary>
+    /// Fills the provided byte array with random bytes.
+    /// This method is functionally equivalent to System.Random.NextBytes(). 
+    /// </summary>
+    public void NextBytes(byte[] buffer) {
+      // Fill up the bulk of the buffer in chunks of 4 bytes at a time.
+      uint x = this._x, y = this._y, z = this._z, w = this._w;
+      int i = 0;
+      uint t;
+      for (int bound = buffer.Length - 3; i < bound; ) {
+        // Generate 4 bytes. 
+        // Increased performance is achieved by generating 4 random bytes per loop.
+        // Also note that no mask needs to be applied to zero out the higher order bytes before
+        // casting because the cast ignores thos bytes. Thanks to Stefan Trosch�tz for pointing this out.
+        t = x ^ (x << 11);
+        x = y; y = z; z = w;
+        w = (w ^ (w >> 19)) ^ (t ^ (t >> 8));
+
+        buffer[i++] = (byte)w;
+        buffer[i++] = (byte)(w >> 8);
+        buffer[i++] = (byte)(w >> 16);
+        buffer[i++] = (byte)(w >> 24);
+      }
+
+      // Fill up any remaining bytes in the buffer.
+      if (i < buffer.Length) {
+        // Generate 4 bytes.
+        t = x ^ (x << 11);
+        x = y; y = z; z = w;
+        w = (w ^ (w >> 19)) ^ (t ^ (t >> 8));
+
+        buffer[i++] = (byte)w;
+        if (i < buffer.Length) {
+          buffer[i++] = (byte)(w >> 8);
+          if (i < buffer.Length) {
+            buffer[i++] = (byte)(w >> 16);
+            if (i < buffer.Length) {
+              buffer[i] = (byte)(w >> 24);
+            }
+          }
+        }
+      }
+      this._x = x; this._y = y; this._z = z; this._w = w;
+    }
+
+    ///// <summary>
+    ///// A version of NextBytes that uses a pointer to set 4 bytes of the byte buffer in one operation
+    ///// thus providing a nice speedup. The loop is also partially unrolled to allow out-of-order-execution,
+    ///// this results in about a x2 speedup on an AMD Athlon. Thus performance may vary wildly on different CPUs
+    ///// depending on the number of execution units available.
+    ///// 
+    ///// Another significant speedup is obtained by setting the 4 bytes by indexing pDWord (e.g. pDWord[i++]=_w)
+    ///// instead of dereferencing it (e.g. *pDWord++=_w).
+    ///// 
+    ///// Note that this routine requires the unsafe compilation flag to be specified and so is commented out by default.
+    ///// </summary>
+    ///// <param name="buffer"></param>
+    //      public unsafe void NextBytesUnsafe(byte[] buffer)
+    //      {
+    //          if(buffer.Length % 8 != 0)
+    //              throw new ArgumentException("Buffer length must be divisible by 8", "buffer");
+    //
+    //          uint _x=this._x, _y=this._y, _z=this._z, _w=this._w;
+    //          
+    //          fixed(byte* pByte0 = buffer)
+    //          {
+    //              uint* pDWord = (uint*)pByte0;
+    //              for(int i=0, len=buffer.Length>>2; i < len; i+=2) 
+    //              {
+    //                  uint t=(_x^(_x<<11));
+    //                  _x=_y; _y=_z; _z=_w;
+    //                  pDWord[i] = _w = (_w^(_w>>19))^(t^(t>>8));
+    //
+    //                  t=(_x^(_x<<11));
+    //                  _x=_y; _y=_z; _z=_w;
+    //                  pDWord[i+1] = _w = (_w^(_w>>19))^(t^(t>>8));
+    //              }
+    //          }
+    //
+    //          this._x=_x; this._y=_y; this._z=_z; this._w=_w;
+    //      }
+    #endregion
+
+    #region Public Methods [Methods not present on System.Random]
+
+    /// <summary>
+    /// Generates a uint. Values returned are over the full range of a uint, 
+    /// uint.MinValue to uint.MaxValue, inclusive.
+    /// 
+    /// This is the fastest method for generating a single random number because the underlying
+    /// random number generator algorithm generates 32 random bits that can be cast directly to 
+    /// a uint.
+    /// </summary>
+    public uint NextUInt() {
+      uint t = _x ^ (_x << 11);
+      _x = _y; _y = _z; _z = _w;
+      return _w = (_w ^ (_w >> 19)) ^ (t ^ (t >> 8));
+    }
+
+    /// <summary>
+    /// Generates a random int over the range 0 to int.MaxValue, inclusive. 
+    /// This method differs from Next() only in that the range is 0 to int.MaxValue
+    /// and not 0 to int.MaxValue-1.
+    /// 
+    /// The slight difference in range means this method is slightly faster than Next()
+    /// but is not functionally equivalent to System.Random.Next().
+    /// </summary>
+    public int NextInt() {
+      uint t = _x ^ (_x << 11);
+      _x = _y; _y = _z; _z = _w;
+      return (int)(0x7FFFFFFF & (_w = (_w ^ (_w >> 19)) ^ (t ^ (t >> 8))));
+    }
+
+    /// <summary>
+    /// Generates a random double. Values returned are over the range (0, 1). That is, exclusive of both 0.0 and 1.0.
+    /// </summary>
+    public double NextDoubleNonZero() {
+      uint t = _x ^ (_x << 11);
+      _x = _y; _y = _z; _z = _w;
+
+      // See notes on NextDouble(). Here we generate a random value from 0 to 0x7f ff ff fe, and add one
+      // to generate a random value from 1 to 0x7f ff ff ff.
+      return REAL_UNIT_INT * (int)((0x7FFFFFFE & (_w = (_w ^ (_w >> 19)) ^ (t ^ (t >> 8)))) + 1U);
+    }
+
+    // Buffer 32 bits in bitBuffer, return 1 at a time, keep track of how many have been returned
+    // with bitMask.
+    uint _bitBuffer;
+    uint _bitMask;
+
+    /// <summary>
+    /// Generates a single random bit.
+    /// This method's performance is improved by generating 32 bits in one operation and storing them
+    /// ready for future calls.
+    /// </summary>
+    public bool NextBool() {
+      if (0 == _bitMask) {
+        // Generate 32 more bits.
+        uint t = _x ^ (_x << 11);
+        _x = _y; _y = _z; _z = _w;
+        _bitBuffer = _w = (_w ^ (_w >> 19)) ^ (t ^ (t >> 8));
+
+        // Reset the bitMask that tells us which bit to read next.
+        _bitMask = 0x80000000;
+        return (_bitBuffer & _bitMask) == 0;
+      }
+
+      return (_bitBuffer & (_bitMask >>= 1)) == 0;
+    }
+
+    // Buffer of random bytes. A single UInt32 is used to buffer 4 bytes.
+    // _byteBufferState tracks how bytes remain in the buffer, a value of 
+    // zero  indicates that the buffer is empty.
+    uint _byteBuffer;
+    byte _byteBufferState;
+
+    /// <summary>
+    /// Generates a signle random byte with range [0,255].
+    /// This method's performance is improved by generating 4 bytes in one operation and storing them
+    /// ready for future calls.
+    /// </summary>
+    public byte NextByte() {
+      if (0 == _byteBufferState) {
+        // Generate 4 more bytes.
+        uint t = _x ^ (_x << 11);
+        _x = _y; _y = _z; _z = _w;
+        _byteBuffer = _w = (_w ^ (_w >> 19)) ^ (t ^ (t >> 8));
+        _byteBufferState = 0x4;
+        return (byte)_byteBuffer;  // Note. Masking with 0xFF is unnecessary.
+      }
+      _byteBufferState >>= 1;
+      return (byte)(_byteBuffer >>= 1);
+    }
+
+    #endregion
+  }
+}
Index: stable/HeuristicLab.ExtLibs/HeuristicLab.SimSharp/3.0.11/SimSharp-3.0.11/Random/IRandom.cs
===================================================================
--- stable/HeuristicLab.ExtLibs/HeuristicLab.SimSharp/3.0.11/SimSharp-3.0.11/Random/IRandom.cs	(revision 16281)
+++ stable/HeuristicLab.ExtLibs/HeuristicLab.SimSharp/3.0.11/SimSharp-3.0.11/Random/IRandom.cs	(revision 16281)
@@ -0,0 +1,28 @@
+﻿#region License Information
+/* SimSharp - A .NET port of SimPy, discrete event simulation framework
+Copyright (C) 2016  Heuristic and Evolutionary Algorithms Laboratory (HEAL)
+
+This program 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.
+
+This program 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 this program.  If not, see <http://www.gnu.org/licenses/>.*/
+#endregion
+
+namespace SimSharp {
+  public interface IRandom {
+    int Next();
+    int Next(int upperBound);
+    int Next(int lowerBound, int upperBound);
+    double NextDouble();
+
+    void Reinitialise(int seed);
+  }
+}
Index: stable/HeuristicLab.ExtLibs/HeuristicLab.SimSharp/3.0.11/SimSharp-3.0.11/Random/SystemRandom.cs
===================================================================
--- stable/HeuristicLab.ExtLibs/HeuristicLab.SimSharp/3.0.11/SimSharp-3.0.11/Random/SystemRandom.cs	(revision 16281)
+++ stable/HeuristicLab.ExtLibs/HeuristicLab.SimSharp/3.0.11/SimSharp-3.0.11/Random/SystemRandom.cs	(revision 16281)
@@ -0,0 +1,52 @@
+﻿#region License Information
+/* SimSharp - A .NET port of SimPy, discrete event simulation framework
+Copyright (C) 2016  Heuristic and Evolutionary Algorithms Laboratory (HEAL)
+
+This program 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.
+
+This program 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 this program.  If not, see <http://www.gnu.org/licenses/>.*/
+#endregion
+
+using System;
+
+namespace SimSharp {
+  public class SystemRandom : IRandom {
+    private Random random;
+
+    public SystemRandom() {
+      random = new Random();
+    }
+
+    public SystemRandom(int seed) {
+      random = new Random(seed);
+    }
+    public int Next() {
+      return random.Next();
+    }
+
+    public int Next(int upperBound) {
+      return random.Next(upperBound);
+    }
+
+    public int Next(int lowerBound, int upperBound) {
+      return random.Next(lowerBound, upperBound);
+    }
+
+    public double NextDouble() {
+      return random.NextDouble();
+    }
+
+    public void Reinitialise(int seed) {
+      random = new Random(seed);
+    }
+  }
+}
Index: stable/HeuristicLab.ExtLibs/HeuristicLab.SimSharp/3.0.11/SimSharp-3.0.11/SimSharp-3.0.11.csproj
===================================================================
--- stable/HeuristicLab.ExtLibs/HeuristicLab.SimSharp/3.0.11/SimSharp-3.0.11/SimSharp-3.0.11.csproj	(revision 16281)
+++ stable/HeuristicLab.ExtLibs/HeuristicLab.SimSharp/3.0.11/SimSharp-3.0.11/SimSharp-3.0.11.csproj	(revision 16281)
@@ -0,0 +1,133 @@
+﻿<?xml version="1.0" encoding="utf-8"?>
+<Project ToolsVersion="12.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>{9FE9C740-7859-4D01-AD07-7D4E15A6320B}</ProjectGuid>
+    <OutputType>Library</OutputType>
+    <AppDesignerFolder>Properties</AppDesignerFolder>
+    <RootNamespace>SimSharp</RootNamespace>
+    <AssemblyName>SimSharp-3.0.11</AssemblyName>
+    <TargetFrameworkVersion>v4.5</TargetFrameworkVersion>
+    <FileAlignment>512</FileAlignment>
+    <TargetFrameworkProfile />
+    <SignAssembly>true</SignAssembly>
+    <AssemblyOriginatorKeyFile>HeuristicLab.snk</AssemblyOriginatorKeyFile>
+  </PropertyGroup>
+  <PropertyGroup Condition=" '$(Configuration)|$(Platform)' == 'Debug|AnyCPU' ">
+    <PlatformTarget>AnyCPU</PlatformTarget>
+    <DebugSymbols>true</DebugSymbols>
+    <DebugType>full</DebugType>
+    <Optimize>false</Optimize>
+    <OutputPath>..\..\..\..\bin\</OutputPath>
+    <DefineConstants>DEBUG;TRACE</DefineConstants>
+    <ErrorReport>prompt</ErrorReport>
+    <WarningLevel>4</WarningLevel>
+  </PropertyGroup>
+  <PropertyGroup Condition="'$(Configuration)|$(Platform)' == 'Release|AnyCPU'">
+    <OutputPath>..\..\..\..\bin\</OutputPath>
+    <DefineConstants>TRACE</DefineConstants>
+    <Optimize>true</Optimize>
+    <DebugType>pdbonly</DebugType>
+    <PlatformTarget>AnyCPU</PlatformTarget>
+    <ErrorReport>prompt</ErrorReport>
+    <CodeAnalysisRuleSet>MinimumRecommendedRules.ruleset</CodeAnalysisRuleSet>
+    <DocumentationFile>
+    </DocumentationFile>
+  </PropertyGroup>
+  <PropertyGroup Condition="'$(Configuration)|$(Platform)' == 'Debug|x64'">
+    <DebugSymbols>true</DebugSymbols>
+    <OutputPath>..\..\..\..\bin\</OutputPath>
+    <DefineConstants>DEBUG;TRACE</DefineConstants>
+    <DebugType>full</DebugType>
+    <PlatformTarget>x64</PlatformTarget>
+    <ErrorReport>prompt</ErrorReport>
+    <CodeAnalysisRuleSet>MinimumRecommendedRules.ruleset</CodeAnalysisRuleSet>
+  </PropertyGroup>
+  <PropertyGroup Condition="'$(Configuration)|$(Platform)' == 'Release|x64'">
+    <OutputPath>..\..\..\..\bin\</OutputPath>
+    <DefineConstants>TRACE</DefineConstants>
+    <DocumentationFile>
+    </DocumentationFile>
+    <Optimize>true</Optimize>
+    <DebugType>pdbonly</DebugType>
+    <PlatformTarget>x64</PlatformTarget>
+    <ErrorReport>prompt</ErrorReport>
+    <CodeAnalysisRuleSet>MinimumRecommendedRules.ruleset</CodeAnalysisRuleSet>
+  </PropertyGroup>
+  <PropertyGroup Condition="'$(Configuration)|$(Platform)' == 'Debug|x86'">
+    <DebugSymbols>true</DebugSymbols>
+    <OutputPath>..\..\..\..\bin\</OutputPath>
+    <DefineConstants>DEBUG;TRACE</DefineConstants>
+    <DebugType>full</DebugType>
+    <PlatformTarget>x86</PlatformTarget>
+    <ErrorReport>prompt</ErrorReport>
+    <CodeAnalysisRuleSet>MinimumRecommendedRules.ruleset</CodeAnalysisRuleSet>
+  </PropertyGroup>
+  <PropertyGroup Condition="'$(Configuration)|$(Platform)' == 'Release|x86'">
+    <OutputPath>..\..\..\..\bin\</OutputPath>
+    <DefineConstants>TRACE</DefineConstants>
+    <DocumentationFile>
+    </DocumentationFile>
+    <Optimize>true</Optimize>
+    <DebugType>pdbonly</DebugType>
+    <PlatformTarget>x86</PlatformTarget>
+    <ErrorReport>prompt</ErrorReport>
+    <CodeAnalysisRuleSet>MinimumRecommendedRules.ruleset</CodeAnalysisRuleSet>
+  </PropertyGroup>
+  <ItemGroup>
+    <Reference Include="System" />
+    <Reference Include="System.Core" />
+  </ItemGroup>
+  <ItemGroup>
+    <Compile Include="Analysis\ContinuousStatistics.cs" />
+    <Compile Include="Collections\EventQueue.cs" />
+    <Compile Include="Collections\EventQueueNode.cs" />
+    <Compile Include="Core\ActiveObject.cs" />
+    <Compile Include="Core\Events\AnyOf.cs" />
+    <Compile Include="Core\Events\AllOf.cs" />
+    <Compile Include="Core\Resources\Container.cs" />
+    <Compile Include="Core\Environment.cs" />
+    <Compile Include="Core\Resources\Events\ResourcePoolRequest.cs" />
+    <Compile Include="Core\Resources\Events\FilterStoreGet.cs" />
+    <Compile Include="Core\Resources\Events\StorePut.cs" />
+    <Compile Include="Core\Resources\Events\StoreGet.cs" />
+    <Compile Include="Core\Resources\Events\ContainerGet.cs" />
+    <Compile Include="Core\Resources\Events\ContainerPut.cs" />
+    <Compile Include="Core\Events\Condition.cs" />
+    <Compile Include="Core\Events\Event.cs" />
+    <Compile Include="Core\Resources\Events\PreemptiveRequest.cs" />
+    <Compile Include="Core\Events\Process.cs" />
+    <Compile Include="Core\Resources\Events\Release.cs" />
+    <Compile Include="Core\Resources\Events\PriorityRequest.cs" />
+    <Compile Include="Core\Resources\Events\Request.cs" />
+    <Compile Include="Core\Events\Timeout.cs" />
+    <Compile Include="Core\Exceptions\EmptyScheduleException.cs" />
+    <Compile Include="Core\Preempted.cs" />
+    <Compile Include="Core\Resources\FilterStore.cs" />
+    <Compile Include="Core\Resources\PreemptiveResource.cs" />
+    <Compile Include="Core\Resources\PriorityResource.cs" />
+    <Compile Include="Core\Resources\Resource.cs" />
+    <Compile Include="Core\Resources\ResourcePool.cs" />
+    <Compile Include="Core\Resources\Store.cs" />
+    <Compile Include="Properties\AssemblyInfo.cs" />
+    <Compile Include="Random\FastRandom.cs" />
+    <Compile Include="Random\IRandom.cs" />
+    <Compile Include="Random\SystemRandom.cs" />
+  </ItemGroup>
+  <ItemGroup>
+    <Content Include="Collections\EventQueue-License.txt" />
+  </ItemGroup>
+  <ItemGroup>
+    <None Include="HeuristicLab.snk" />
+  </ItemGroup>
+  <Import Project="$(MSBuildToolsPath)\Microsoft.CSharp.targets" />
+  <!-- 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>
