Merge branch 'master.upstream' into staging.upstream

146 files changed, 14619 insertions, 9545 deletions

diff --git a/.version b/.version
index 8e0b5950288..49aab0cba12 100644
--- a/.version
+++ b/.version
@@ -1 +1 @@
-15.07
\ No newline at end of file
+15.08
\ No newline at end of file
diff --git a/doc/package-notes.xml b/doc/package-notes.xml
index ecaf619472d..266a8092216 100644
--- a/doc/package-notes.xml
+++ b/doc/package-notes.xml
@@ -219,5 +219,131 @@ you should modify
 </section>
 -->
 
+<!--============================================================-->
+
+<section xml:id="sec-eclipse">
+
+  <title>Eclipse</title>
+
+  <para>
+    The Nix expressions related to the Eclipse platform and IDE are in
+    <link xlink:href="https://github.com/NixOS/nixpkgs/blob/master/pkgs/applications/editors/eclipse"><filename>pkgs/applications/editors/eclipse</filename></link>.
+  </para>
+
+  <para>
+    Nixpkgs provides a number of packages that will install Eclipse in
+    its various forms, these range from the bare-bones Eclipse
+    Platform to the more fully featured Eclipse SDK or Scala-IDE
+    packages and multiple version are often available. It is possible
+    to list available Eclipse packages by issuing the command:
+
+<screen>
+$ nix-env -f '&lt;nixpkgs&gt;' -qaP -A eclipses --description
+</screen>
+
+    Once an Eclipse variant is installed it can be run using the
+    <command>eclipse</command> command, as expected. From within
+    Eclipse it is then possible to install plugins in the usual manner
+    by either manually specifying an Eclipse update site or by
+    installing the Marketplace Client plugin and using it to discover
+    and install other plugins. This installation method provides an
+    Eclipse installation that closely resemble a manually installed
+    Eclipse.
+  </para>
+
+  <para>
+    If you prefer to install plugins in a more declarative manner then
+    Nixpkgs also offer a number of Eclipse plugins that can be
+    installed in an <emphasis>Eclipse environment</emphasis>. This
+    type of environment is created using the function
+    <varname>eclipseWithPlugins</varname> found inside the
+    <varname>nixpkgs.eclipses</varname> attribute set. This function
+    takes as argument <literal>{ eclipse, plugins ? [], jvmArgs ? []
+    }</literal> where <varname>eclipse</varname> is a one of the
+    Eclipse packages described above, <varname>plugins</varname> is a
+    list of plugin derivations, and <varname>jvmArgs</varname> is a
+    list of arguments given to the JVM running the Eclipse. For
+    example, say you wish to install the latest Eclipse Platform with
+    the popular Eclipse Color Theme plugin and also allow Eclipse to
+    use more RAM. You could then add
+
+<screen>
+packageOverrides = pkgs: {
+  myEclipse = with pkgs.eclipses; eclipseWithPlugins {
+    eclipse = eclipse-platform;
+    jvmArgs = [ "-Xmx2048m" ];
+    plugins = [ plugins.color-theme ];
+  };
+}
+</screen>
+
+    to your Nixpkgs configuration
+    (<filename>~/.nixpkgs/config.nix</filename>) and install it by
+    running <command>nix-env -f '&lt;nixpkgs&gt;' -iA
+    myEclipse</command> and afterward run Eclipse as usual. It is
+    possible to find out which plugins are available for installation
+    using <varname>eclipseWithPlugins</varname> by running
+
+<screen>
+$ nix-env -f '&lt;nixpkgs&gt;' -qaP -A eclipses.plugins --description
+</screen>
+  </para>
+
+  <para>
+    If there is a need to install plugins that are not available in
+    Nixpkgs then it may be possible to define these plugins outside
+    Nixpkgs using the <varname>buildEclipseUpdateSite</varname> and
+    <varname>buildEclipsePlugin</varname> functions found in the
+    <varname>nixpkgs.eclipses.plugins</varname> attribute set. Use the
+    <varname>buildEclipseUpdateSite</varname> function to install a
+    plugin distributed as an Eclipse update site. This function takes
+    <literal>{ name, src }</literal> as argument where
+    <literal>src</literal> indicates the Eclipse update site archive.
+    All Eclipse features and plugins within the downloaded update site
+    will be installed. When an update site archive is not available
+    then the <varname>buildEclipsePlugin</varname> function can be
+    used to install a plugin that consists of a pair of feature and
+    plugin JARs. This function takes an argument <literal>{ name,
+    srcFeature, srcPlugin }</literal> where
+    <literal>srcFeature</literal> and <literal>srcPlugin</literal> are
+    the feature and plugin JARs, respectively.
+  </para>
+
+  <para>
+    Expanding the previous example with two plugins using the above
+    functions we have
+<screen>
+packageOverrides = pkgs: {
+  myEclipse = with pkgs.eclipses; eclipseWithPlugins {
+    eclipse = eclipse-platform;
+    jvmArgs = [ "-Xmx2048m" ];
+    plugins = [
+      plugins.color-theme
+      (plugins.buildEclipsePlugin {
+        name = "myplugin1-1.0";
+        srcFeature = fetchurl {
+          url = "http://…/features/myplugin1.jar";
+          sha256 = "123…";
+        };
+        srcPlugin = fetchurl {
+          url = "http://…/plugins/myplugin1.jar";
+          sha256 = "123…";
+        };
+      });
+      (plugins.buildEclipseUpdateSite {
+        name = "myplugin2-1.0";
+        src = fetchurl {
+          stripRoot = false;
+          url = "http://…/myplugin2.zip";
+          sha256 = "123…";
+        };
+      });
+    ];
+  };
+}
+</screen>
+  </para>
+
+</section>
 
 </chapter>
diff --git a/lib/maintainers.nix b/lib/maintainers.nix
index c490b9ee979..5c0846fdc96 100644
--- a/lib/maintainers.nix
+++ b/lib/maintainers.nix
@@ -83,6 +83,7 @@
   eikek = "Eike Kettner <eike.kettner@posteo.de>";
   ellis = "Ellis Whitehead <nixos@ellisw.net>";
   emery = "Emery Hemingway <emery@vfemail.net>";
+  epitrochoid = "Mabry Cervin <mpcervin@uncg.edu>";
   ericbmerritt = "Eric Merritt <eric@afiniate.com>";
   ertes = "Ertugrul Söylemez <ertesx@gmx.de>";
   exlevan = "Alexey Levan <exlevan@gmail.com>";
diff --git a/nixos/doc/manual/release-notes/rl-unstable.xml b/nixos/doc/manual/release-notes/rl-unstable.xml
index c50df94bfd8..30da98faa33 100644
--- a/nixos/doc/manual/release-notes/rl-unstable.xml
+++ b/nixos/doc/manual/release-notes/rl-unstable.xml
@@ -36,14 +36,6 @@
 
 </para>
 
-<para>The following new services were added since the last release:
-
-<itemizedlist>
-<listitem><para><literal>brltty</literal></para></listitem>
-<listitem><para><literal>marathon</literal></para></listitem>
-<listitem><para><literal>tvheadend</literal></para></listitem>
-</itemizedlist>
-</para>
 
 <para>When upgrading from a previous release, please be aware of the
 following incompatible changes:
@@ -102,6 +94,17 @@ was accordingly renamed to <literal>electron</literal>
 
 <listitem>
   <para>
+    The VirtualBox host and guest options have been moved/renamed more
+    consistently and less confusing to be now found in
+    <literal>virtualisation.virtualbox.host.*</literal> instead of
+    <literal>services.virtualboxHost.*</literal> and
+    <literal>virtualisation.virtualbox.guest.*</literal> instead of
+    <literal>services.virtualboxGuest.*</literal>.
+  </para>
+</listitem>
+
+<listitem>
+  <para>
     Haskell packages can no longer be found by name, i.e. the commands
     <literal>nix-env -qa cabal-install</literal> and <literal>nix-env -i
     ghc</literal> will fail, even though we <emphasis>do</emphasis> ship
@@ -200,4 +203,26 @@ nix-env -f &quot;&lt;nixpkgs&gt;&quot; -iA haskellPackages.cabal-install
 </itemizedlist>
 </para>
 
+
+<para>The following new services were added since the last release:
+
+<itemizedlist>
+<listitem><para><literal>brltty</literal></para></listitem>
+<listitem><para><literal>marathon</literal></para></listitem>
+<listitem><para><literal>tvheadend</literal></para></listitem>
+</itemizedlist>
+</para>
+
+
+<para>Other notable improvements:
+
+<itemizedlist>
+  <listitem><para>The nixos and nixpkgs channels were unified,
+    so one <emphasis>can</emphasis> use <literal>nix-env -iA nixos.bash</literal>
+    instead of <literal>nix-env -iA nixos.pkgs.bash</literal>.
+    See <link xlink:href="https://github.com/NixOS/nixpkgs/commit/2cd7c1f198">the commit</link> for details.
+  </para></listitem>
+</itemizedlist>
+</para>
+
 </section>
diff --git a/nixos/modules/module-list.nix b/nixos/modules/module-list.nix
index 93d378aa95f..733f3c5d853 100644
--- a/nixos/modules/module-list.nix
+++ b/nixos/modules/module-list.nix
@@ -344,6 +344,7 @@
   ./services/networking/tlsdated.nix
   ./services/networking/tox-bootstrapd.nix
   ./services/networking/tvheadend.nix
+  ./services/networking/ubuntu-fan.nix
   ./services/networking/unbound.nix
   ./services/networking/unifi.nix
   ./services/networking/vsftpd.nix
diff --git a/nixos/modules/rename.nix b/nixos/modules/rename.nix
index a928f47f439..abecc065634 100644
--- a/nixos/modules/rename.nix
+++ b/nixos/modules/rename.nix
@@ -109,7 +109,14 @@ in zipModules ([]
 ++ obsolete [ "services" "xserver" "startOpenSSHAgent" ] [ "programs" "ssh" "startAgent" ]
 
 # VirtualBox
-++ obsolete [ "services" "virtualbox" "enable" ] [ "services" "virtualboxGuest" "enable" ]
+++ obsolete [ "services" "virtualbox" "enable" ] [ "virtualisation" "virtualbox" "guest" "enable" ]
+++ obsolete [ "services" "virtualboxGuest" "enable" ] [ "virtualisation" "virtualbox" "guest" "enable" ]
+++ obsolete [ "programs" "virtualbox" "enable" ] [ "virtualisation" "virtualbox" "host" "enable" ]
+++ obsolete [ "programs" "virtualbox" "addNetworkInterface" ] [ "virtualisation" "virtualbox" "host" "addNetworkInterface" ]
+++ obsolete [ "programs" "virtualbox" "enableHardening" ] [ "virtualisation" "virtualbox" "host" "enableHardening" ]
+++ obsolete [ "services" "virtualboxHost" "enable" ] [ "virtualisation" "virtualbox" "host" "enable" ]
+++ obsolete [ "services" "virtualboxHost" "addNetworkInterface" ] [ "virtualisation" "virtualbox" "host" "addNetworkInterface" ]
+++ obsolete [ "services" "virtualboxHost" "enableHardening" ] [ "virtualisation" "virtualbox" "host" "enableHardening" ]
 
 # Tarsnap
 ++ obsolete [ "services" "tarsnap" "config" ] [ "services" "tarsnap" "archives" ]
diff --git a/nixos/modules/services/monitoring/scollector.nix b/nixos/modules/services/monitoring/scollector.nix
index 179c587431e..8b97daf8881 100644
--- a/nixos/modules/services/monitoring/scollector.nix
+++ b/nixos/modules/services/monitoring/scollector.nix
@@ -20,9 +20,11 @@ let
           cfg.collectors)}
     '';
 
-  cmdLineOpts = concatStringsSep " " (
-    [ "-h=${cfg.bosunHost}" "-c=${collectors}" ] ++ cfg.extraOpts
-  );
+  conf = pkgs.writeText "scollector.toml" ''
+    Host = "${cfg.bosunHost}"
+    ColDir = "${collectors}"
+    ${cfg.extraConfig}
+  '';
 
 in {
 
@@ -92,6 +94,14 @@ in {
         '';
       };
 
+      extraConfig = mkOption {
+        type = types.lines;
+        default = "";
+        description = ''
+          Extra scollector configuration added to the end of scollector.toml
+        '';
+      };
+
     };
 
   };
@@ -108,7 +118,7 @@ in {
         PermissionsStartOnly = true;
         User = cfg.user;
         Group = cfg.group;
-        ExecStart = "${cfg.package}/bin/scollector ${cmdLineOpts}";
+        ExecStart = "${cfg.package}/bin/scollector -conf=${conf} ${lib.concatStringsSep " " cfg.extraOpts}";
       };
     };
 
diff --git a/nixos/modules/services/networking/ubuntu-fan.nix b/nixos/modules/services/networking/ubuntu-fan.nix
new file mode 100644
index 00000000000..2759a671b81
--- /dev/null
+++ b/nixos/modules/services/networking/ubuntu-fan.nix
@@ -0,0 +1,60 @@
+{ config, lib, pkgs, ... }:
+
+with lib;
+
+let
+
+  cfg = config.networking.ubuntu-fan;
+  modprobe = "${config.system.sbin.modprobe}/sbin/modprobe";
+
+in
+
+{
+
+  ###### interface
+
+  options = {
+
+    networking.ubuntu-fan = {
+
+      enable = mkEnableOption "Ubuntu FAN Networking";
+
+    };
+
+  };
+
+
+  ###### implementation
+
+  config = mkIf cfg.enable {
+
+    environment.systemPackages = [ pkgs.fanctl ];
+
+    systemd.services.ubuntu-fan = {
+      description = "Ubuntu FAN Networking";
+      wantedBy = [ "multi-user.target" ];
+      after = [ "network-online.target" ];
+      before = [ "docker.service" ];
+      restartIfChanged = false;
+      preStart = ''
+        if [ ! -f /proc/sys/net/fan/version ]; then
+          ${modprobe} ipip
+          if [ ! -f /proc/sys/net/fan/version ]; then
+            echo "The Ubuntu Fan Networking patches have not been applied to this kernel!" 1>&2
+            exit 1
+          fi
+        fi
+
+        mkdir -p /var/lib/ubuntu-fan
+      '';
+      serviceConfig = {
+        Type = "oneshot";
+        RemainAfterExit = true;
+        ExecStart = "${pkgs.fanctl}/bin/fanctl up -a";
+        ExecStop = "${pkgs.fanctl}/bin/fanctl down -a";
+      };
+    };
+
+  };
+
+}
diff --git a/nixos/modules/services/x11/desktop-managers/gnome3.nix b/nixos/modules/services/x11/desktop-managers/gnome3.nix
index fdee5fbc6c5..507c2d2da13 100644
--- a/nixos/modules/services/x11/desktop-managers/gnome3.nix
+++ b/nixos/modules/services/x11/desktop-managers/gnome3.nix
@@ -99,6 +99,7 @@ in {
     networking.networkmanager.enable = mkDefault true;
     services.upower.enable = config.powerManagement.enable;
     hardware.bluetooth.enable = mkDefault true;
+    services.xserver.displayManager.desktopManagerHandlesLidAndPower = false; # true doesn't make sense here, GNOME just doesn't handle it anymore
 
     fonts.fonts = [ pkgs.dejavu_fonts pkgs.cantarell_fonts ];
 
diff --git a/nixos/modules/virtualisation/virtualbox-guest.nix b/nixos/modules/virtualisation/virtualbox-guest.nix
index 6c4014fc4a1..642ea3154b1 100644
--- a/nixos/modules/virtualisation/virtualbox-guest.nix
+++ b/nixos/modules/virtualisation/virtualbox-guest.nix
@@ -6,7 +6,7 @@ with lib;
 
 let
 
-  cfg = config.services.virtualboxGuest;
+  cfg = config.virtualisation.virtualbox.guest;
   kernel = config.boot.kernelPackages;
 
 in
@@ -15,20 +15,11 @@ in
 
   ###### interface
 
-  options = {
-
-    services.virtualboxGuest = {
-
-      enable = mkOption {
-        default = false;
-        description = "Whether to enable the VirtualBox service and other guest additions.";
-      };
-
-    };
-
+  options.virtualisation.virtualbox.guest.enable = mkOption {
+    default = false;
+    description = "Whether to enable the VirtualBox service and other guest additions.";
   };
 
-
   ###### implementation
 
   config = mkIf cfg.enable {
diff --git a/nixos/modules/virtualisation/virtualbox-host.nix b/nixos/modules/virtualisation/virtualbox-host.nix
index fc113a08a35..00486df5c4b 100644
--- a/nixos/modules/virtualisation/virtualbox-host.nix
+++ b/nixos/modules/virtualisation/virtualbox-host.nix
@@ -3,7 +3,7 @@
 with lib;
 
 let
-  cfg = config.services.virtualboxHost;
+  cfg = config.virtualisation.virtualbox.host;
   virtualbox = config.boot.kernelPackages.virtualbox.override {
     inherit (cfg) enableHardening;
   };
@@ -11,12 +11,12 @@ let
 in
 
 {
-  options.services.virtualboxHost = {
+  options.virtualisation.virtualbox.host = {
     enable = mkOption {
       type = types.bool;
       default = false;
       description = ''
-        Whether to enable host-side support for VirtualBox.
+        Whether to enable VirtualBox.
 
         <note><para>
           In order to pass USB devices from the host to the guests, the user
diff --git a/nixos/release-small.nix b/nixos/release-small.nix
index 8e53064f99d..08ca4cfb3e4 100644
--- a/nixos/release-small.nix
+++ b/nixos/release-small.nix
@@ -43,7 +43,6 @@ in rec {
         simple;
       installer = {
         inherit (nixos'.tests.installer)
-          grub1
           lvm
           separateBoot
           simple;
diff --git a/nixos/tests/openssh.nix b/nixos/tests/openssh.nix
index 34f9fccb79b..390363b88e2 100644
--- a/nixos/tests/openssh.nix
+++ b/nixos/tests/openssh.nix
@@ -43,7 +43,7 @@ in {
   testScript = ''
     startAll;
 
-    my $key=`${pkgs.openssh}/bin/ssh-keygen -t dsa -f key -N ""`;
+    my $key=`${pkgs.openssh}/bin/ssh-keygen -t ed25519 -f key -N ""`;
 
     $server->waitForUnit("sshd");
 
@@ -52,8 +52,8 @@ in {
       $server->copyFileFromHost("key.pub", "/root/.ssh/authorized_keys");
 
       $client->succeed("mkdir -m 700 /root/.ssh");
-      $client->copyFileFromHost("key", "/root/.ssh/id_dsa");
-      $client->succeed("chmod 600 /root/.ssh/id_dsa");
+      $client->copyFileFromHost("key", "/root/.ssh/id_ed25519");
+      $client->succeed("chmod 600 /root/.ssh/id_ed25519");
 
       $client->waitForUnit("network.target");
       $client->succeed("ssh -o UserKnownHostsFile=/dev/null -o StrictHostKeyChecking=no server 'echo hello world' >&2");
diff --git a/nixos/tests/virtualbox.nix b/nixos/tests/virtualbox.nix
index 4895eb134dc..83a8b2835dc 100644
--- a/nixos/tests/virtualbox.nix
+++ b/nixos/tests/virtualbox.nix
@@ -31,7 +31,7 @@ import ./make-test.nix ({ pkgs, ... }: with pkgs.lib; let
       fsType = "vboxsf";
     };
 
-    services.virtualboxGuest.enable = true;
+    virtualisation.virtualbox.guest.enable = true;
 
     boot.initrd.kernelModules = [
       "af_packet" "vboxsf"
@@ -308,9 +308,9 @@ in {
       vmConfigs = mapAttrsToList mkVMConf vboxVMs;
     in [ ./common/user-account.nix ./common/x11.nix ] ++ vmConfigs;
     virtualisation.memorySize = 768;
-    services.virtualboxHost.enable = true;
+    virtualisation.virtualbox.host.enable = true;
     users.extraUsers.alice.extraGroups = let
-      inherit (config.services.virtualboxHost) enableHardening;
+      inherit (config.virtualisation.virtualbox.host) enableHardening;
     in lib.mkIf enableHardening (lib.singleton "vboxusers");
   };
 
diff --git a/pkgs/applications/audio/fmit/default.nix b/pkgs/applications/audio/fmit/default.nix
index 011f4f15f5d..f2328410be8 100644
--- a/pkgs/applications/audio/fmit/default.nix
+++ b/pkgs/applications/audio/fmit/default.nix
@@ -7,12 +7,12 @@
 assert alsaSupport -> alsaLib != null;
 assert jackSupport -> libjack2 != null;
 
-let version = "1.0.5"; in
+let version = "1.0.7"; in
 stdenv.mkDerivation {
   name = "fmit-${version}";
 
   src = fetchFromGitHub {
-    sha256 = "1p49ykg7mf62xrn08fqss8yr1nf53mm8w9zp2sgcy48bfsa9xbpy";
+    sha256 = "14dzrrxjskhqamhfqhzp6napvc1vyjxcc0v8id1iqzsfdn86xqm9";
     rev = "v${version}";
     repo = "fmit";
     owner = "gillesdegottex";
@@ -24,28 +24,20 @@ stdenv.mkDerivation {
 
   postPatch = ''
     substituteInPlace fmit.pro --replace '$$FMITVERSIONGITPRO' '${version}'
-    substituteInPlace distrib/fmit.desktop \
-      --replace "Icon=fmit" "Icon=$out/share/pixmaps/fmit.svg"
-    substituteInPlace src/main.cpp --replace "PREFIX" "\"$out\""
   '';
 
   configurePhase = ''
+    mkdir build
+    cd build
     qmake \
       CONFIG+=${stdenv.lib.optionalString alsaSupport "acs_alsa"} \
       CONFIG+=${stdenv.lib.optionalString jackSupport "acs_jack"} \
-      fmit.pro
+      PREFIX="$out" PREFIXSHORTCUT="$out" \
+      ../fmit.pro
   '';
 
   enableParallelBuilding = true;
 
-  installPhase = ''
-    install -D fmit $out/bin/fmit
-    install -Dm644 distrib/fmit.desktop $out/share/applications/fmit.desktop
-    install -Dm644 ui/images/fmit.svg $out/share/pixmaps/fmit.svg
-    mkdir -p $out/share/fmit
-    cp -R tr $out/share/fmit
-  '';
-
   meta = with stdenv.lib; {
     inherit version;
     description = "Free Musical Instrument Tuner";
diff --git a/pkgs/applications/audio/gjay/default.nix b/pkgs/applications/audio/gjay/default.nix
new file mode 100644
index 00000000000..9f023f34291
--- /dev/null
+++ b/pkgs/applications/audio/gjay/default.nix
@@ -0,0 +1,22 @@
+{ stdenv, fetchurl, pkgconfig, mpd_clientlib, dbus_glib, audacious, gtk, gsl
+, libaudclient }:
+
+stdenv.mkDerivation {
+  name = "gjay-0.3.2";
+
+  src = fetchurl {
+    url = "http://downloads.sourceforge.net/project/gjay/gjay-0.3.2.tar.gz";
+    sha256 = "1a1vv4r0vnxjdyl0jyv7gga3zfd5azxlwjm1l6hjrf71lb228zn8";
+  };
+
+  nativeBuildInputs = [ pkgconfig ];
+
+  buildInputs = [ mpd_clientlib dbus_glib audacious gtk gsl libaudclient ];
+
+  meta = with stdenv.lib; {
+    description = "Generates playlists such that each song sounds good following the previous song";
+    homepage = http://gjay.sourceforge.net/;
+    license = licenses.gpl2;
+    maintainers = with maintainers; [ pSub ];
+  };
+}
diff --git a/pkgs/applications/audio/gtkpod/default.nix b/pkgs/applications/audio/gtkpod/default.nix
index f01abb13e67..1b1bf437ce9 100644
--- a/pkgs/applications/audio/gtkpod/default.nix
+++ b/pkgs/applications/audio/gtkpod/default.nix
@@ -3,12 +3,12 @@
   libvorbis, hicolor_icon_theme, gdk_pixbuf }:
 
 stdenv.mkDerivation rec {
-  version = "2.1.4";
+  version = "2.1.5";
   name = "gtkpod-${version}";
 
   src = fetchurl {
     url = "mirror://sourceforge/gtkpod/${name}.tar.gz";
-    sha256 = "ba12b35f3f24a155b68f0ffdaf4d3c5c7d1b8df04843a53306e1c83fc811dfaa";
+    sha256 = "0xisrpx069f7bjkyc8vqxb4k0480jmx1wscqxr6cpq1qj6pchzd5";
   };
 
   propagatedUserEnvPkgs = [ gnome.gnome_themes_standard ];
diff --git a/pkgs/applications/audio/x42-plugins/default.nix b/pkgs/applications/audio/x42-plugins/default.nix
index 5603bc2fefc..1090ee4a61e 100644
--- a/pkgs/applications/audio/x42-plugins/default.nix
+++ b/pkgs/applications/audio/x42-plugins/default.nix
@@ -3,22 +3,17 @@
 , lv2, mesa, gtk2, cairo, pango, fftwFloat, zita-convolver }:
 
 stdenv.mkDerivation rec {
-  version = "2014-11-01";
+  version = "2015-07-02";
   name = "x42-plugins-${version}";
 
   src = fetchurl {
-    url = "http://gareus.org/misc/x42-plugins/x42-plugins-20141101.tar.xz";
-    sha256 = "0pjdhj58hb4n2053v92l7v7097fjm4xzrl8ks4g1hc7miy98ymdk";
+    url = "http://gareus.org/misc/x42-plugins/x42-plugins-20150702.tar.xz";
+    sha256 = "1mq0grabzbl9xsd53v2qajhr8nngk0d4lx9n0n3nwy95y2gmy6sm";
   };
 
   buildInputs = [ mesa_glu ftgl freefont_ttf libjack2 libltc libsndfile libsamplerate lv2 mesa gtk2 cairo pango fftwFloat pkgconfig  zita-convolver];
 
-  makeFlags = [ "PREFIX=$(out)" "FONTFILE=${freefont_ttf}/share/fonts/truetype/FreeSansBold.ttf" ];
-
-  # remove check for zita-convolver in /usr/
-  patchPhase = ''
-    sed -i "38,42d" convoLV2/Makefile
-  '';
+  makeFlags = [ "PREFIX=$(out)" "FONTFILE=${freefont_ttf}/share/fonts/truetype/FreeSansBold.ttf" "LIBZITACONVOLVER=${zita-convolver}/include/zita-convolver.h" ];
 
   meta = with stdenv.lib;
     { description = "Collection of LV2 plugins by Robin Gareus";
diff --git a/pkgs/applications/editors/eclipse/default.nix b/pkgs/applications/editors/eclipse/default.nix
index 3ec49897321..7d543c4ed55 100644
--- a/pkgs/applications/editors/eclipse/default.nix
+++ b/pkgs/applications/editors/eclipse/default.nix
@@ -2,6 +2,8 @@
 , freetype, fontconfig, libX11, libXext, libXrender, zlib
 , glib, gtk, libXtst, jre
 , webkitgtk2 ? null  # for internal web browser
+, buildEnv, writeText, runCommand
+, callPackage
 }:
 
 assert stdenv ? glibc;
@@ -334,4 +336,58 @@ in {
         };
     };
   };
+
+  eclipse-platform = buildEclipse {
+    name = "eclipse-platform-4.5";
+    description = "Eclipse platform";
+    sources = {
+      "x86_64-linux" = fetchurl {
+          url = "https://www.eclipse.org/downloads/download.php?r=1&nf=1&file=/eclipse/downloads/drops4/R-4.5-201506032000/eclipse-platform-4.5-linux-gtk-x86_64.tar.gz";
+          sha256 = "1510j41yr86pbzwf48kjjdd46nkpkh8zwn0hna0cqvsw1gk2vqcg";
+
+        };
+      "i686-linux" = fetchurl {
+          url = "https://www.eclipse.org/downloads/download.php?r=1&nf=1&file=/eclipse/downloads/drops4/R-4.5-201506032000/eclipse-platform-4.5-linux-gtk.tar.gz";
+          sha256 = "1f97jd3qbi3830y3djk8bhwzd9whsq8gzfdk996chxc55prn0qbd";
+        };
+    };
+  };
+
+  eclipseWithPlugins = { eclipse, plugins ? [], jvmArgs ? [] }:
+    let
+      # Gather up the desired plugins.
+      pluginEnv = buildEnv {
+        name = "eclipse-plugins";
+        paths =
+          with stdenv.lib;
+            filter (x: x ? isEclipsePlugin) (closePropagation plugins);
+      };
+
+      # Prepare the JVM arguments to add to the ini file. We here also
+      # add the property indicating the plugin directory.
+      dropinPropName = "org.eclipse.equinox.p2.reconciler.dropins.directory";
+      dropinProp = "-D${dropinPropName}=${pluginEnv}/eclipse/dropins";
+      jvmArgsText = stdenv.lib.concatStringsSep "\n" (jvmArgs ++ [dropinProp]);
+
+      # Prepare an eclipse.ini with the plugin directory.
+      origEclipseIni = builtins.readFile "${eclipse}/eclipse/eclipse.ini";
+      eclipseIniFile = writeText "eclipse.ini" ''
+        ${origEclipseIni}
+        ${jvmArgsText}
+      '';
+
+      # Base the derivation name on the name of the underlying
+      # Eclipse.
+      name = (stdenv.lib.meta.appendToName "with-plugins" eclipse).name;
+    in
+      runCommand name { buildInputs = [ makeWrapper ]; } ''
+        mkdir -p $out/bin
+        makeWrapper ${eclipse}/bin/eclipse $out/bin/eclipse \
+          --add-flags "--launcher.ini ${eclipseIniFile}"
+
+        ln -s ${eclipse}/share $out/
+      '';
+
+  plugins = callPackage ./plugins.nix { };
+
 }
diff --git a/pkgs/applications/editors/eclipse/plugins.nix b/pkgs/applications/editors/eclipse/plugins.nix
new file mode 100644
index 00000000000..284ea911724
--- /dev/null
+++ b/pkgs/applications/editors/eclipse/plugins.nix
@@ -0,0 +1,336 @@
+{ stdenv, fetchurl, fetchzip, unzip }:
+
+rec {
+
+  # A primitive builder of Eclipse plugins. This function is intended
+  # to be used when building more advanced builders.
+  buildEclipsePluginBase =  { name
+                            , buildInputs ? []
+                            , passthru ? {}
+                            , ... } @ attrs:
+    stdenv.mkDerivation (attrs // {
+      name = "eclipse-" + name;
+
+      buildInputs = buildInputs ++ [ unzip ];
+
+      passthru = {
+        isEclipsePlugin = true;
+      } // passthru;
+    });
+
+  # Helper for the common case where we have separate feature and
+  # plugin JARs.
+  buildEclipsePlugin = { name, srcFeature, srcPlugin, ... } @ attrs:
+    buildEclipsePluginBase (attrs // {
+      srcs = [ srcFeature srcPlugin ];
+
+      phases = [ "installPhase" ];
+
+      installPhase = ''
+        dropinDir="$out/eclipse/dropins/${name}"
+
+        mkdir -p $dropinDir/features
+        unzip ${srcFeature} -d $dropinDir/features/
+
+        mkdir -p $dropinDir/plugins
+        cp -v ${srcPlugin} $dropinDir/plugins/${name}.jar
+      '';
+
+    });
+
+  # Helper for the case where the build directory has the layout of an
+  # Eclipse update site, that is, it contains the directories
+  # `features` and `plugins`. All features and plugins inside these
+  # directories will be installed.
+  buildEclipseUpdateSite = { name, ... } @ attrs:
+    buildEclipsePluginBase (attrs // {
+      phases = [ "unpackPhase" "installPhase" ];
+
+      installPhase = ''
+        dropinDir="$out/eclipse/dropins/${name}"
+
+        # Install features.
+        cd features
+        for feature in *.jar; do
+          featureName=''${feature%.jar}
+          mkdir -p $dropinDir/features/$featureName
+          unzip $feature -d $dropinDir/features/$featureName
+        done
+        cd ..
+
+        # Install plugins.
+        mkdir -p $dropinDir/plugins
+
+        # A bundle should be unpacked if the manifest matches this
+        # pattern.
+        unpackPat="Eclipse-BundleShape:\\s*dir"
+
+        cd plugins
+        for plugin in *.jar ; do
+          pluginName=''${plugin%.jar}
+          manifest=$(unzip -p $plugin META-INF/MANIFEST.MF)
+
+          if [[ $manifest =~ $unpackPat ]] ; then
+            mkdir $dropinDir/plugins/$pluginName
+            unzip $plugin -d $dropinDir/plugins/$pluginName
+          else
+            cp -v $plugin $dropinDir/plugins/
+          fi
+        done
+        cd ..
+      '';
+    });
+
+  acejump = buildEclipsePlugin rec {
+    name = "acejump-${version}";
+    version = "1.0.0.201501181511";
+
+    srcFeature = fetchurl {
+      url = "https://tobiasmelcher.github.io/acejumpeclipse/features/acejump.feature_${version}.jar";
+      sha256 = "127xqrnns4h96g21c9zg0iblxprx3fg6fg0w5f413rf84415z884";
+    };
+
+    srcPlugin = fetchurl {
+      url = "https://tobiasmelcher.github.io/acejumpeclipse/plugins/acejump_${version}.jar";
+      sha256 = "0mz79ca32yryidd1wijirvnmfg4j5q4g84vdspdi56z0r4xrja13";
+    };
+
+    meta = with stdenv.lib; {
+      homepage = https://github.com/tobiasmelcher/EclipseAceJump;
+      description = "Provides fast jumps to text based on initial letter";
+      license = licenses.mit;
+      platforms = platforms.all;
+      maintainers = [ maintainers.rycee ];
+    };
+  };
+
+  anyedittools = buildEclipsePlugin rec {
+    name = "anyedit-${version}";
+    version = "2.4.15.201504172030";
+
+    srcFeature = fetchurl {
+      url = "http://andrei.gmxhome.de/eclipse/features/AnyEditTools_${version}.jar";
+      sha256 = "19hbwgqn02ghflbcp5cw3qy203mym5kwgzq4xrn0xcl8ckl5s2pp";
+    };
+
+    srcPlugin = fetchurl {
+      url = "http://dl.bintray.com/iloveeclipse/plugins/de.loskutov.anyedit.AnyEditTools_${version}.jar";
+      sha256 = "1i3ghf2mhdfhify30hlyxqmyqcp40pkd5zhsiyg6finn4w81sxv2";
+    };
+
+    meta = with stdenv.lib; {
+      homepage = http://andrei.gmxhome.de/anyedit/;
+      description = "Adds new tools to the context menu of text-based editors";
+      license = licenses.epl10;
+      platforms = platforms.all;
+      maintainers = [ maintainers.rycee ];
+    };
+  };
+
+  cdt = buildEclipseUpdateSite rec {
+    name = "cdt-${version}";
+    version = "8.7.0";
+
+    src = fetchzip {
+      stripRoot = false;
+      url = "http://www.eclipse.org/downloads/download.php?r=1&nf=1&file=/tools/cdt/releases/8.7/${name}.zip";
+      sha256 = "0qpcjcl6n98x7ys4qz8p1x5hhk2ydrgh8w3r1kqk0zc7liqrx7vg";
+    };
+
+    meta = with stdenv.lib; {
+      homepage = https://eclipse.org/cdt/;
+      description = "C/C++ development tooling";
+      license = licenses.epl10;
+      platforms = platforms.all;
+      maintainers = [ maintainers.bjornfor ];
+    };
+  };
+
+  checkstyle = buildEclipseUpdateSite rec {
+    name = "checkstyle-${version}";
+    version = "6.5.0.201504121610";
+
+    src = fetchzip {
+      stripRoot = false;
+      url = "mirror://sourceforge/project/eclipse-cs/Eclipse%20Checkstyle%20Plug-in/6.5.0/net.sf.eclipsecs-updatesite_6.5.0.201504121610-bin.zip";
+      sha256 = "1zikpkss0c3l460ipvznp22kpak8w31n7k6yk41nc1w49zflvcf0";
+    };
+
+    meta = with stdenv.lib; {
+      homepage = http://eclipse-cs.sourceforge.net/;
+      description = "Checkstyle integration into the Eclipse IDE";
+      license = licenses.lgpl21;
+      platforms = platforms.all;
+      maintainers = [ maintainers.rycee ];
+    };
+
+  };
+
+  color-theme = buildEclipsePlugin rec {
+    name = "color-theme-${version}";
+    version = "1.0.0.201410260308";
+
+    srcFeature = fetchurl {
+      url = "https://eclipse-color-theme.github.io/update/features/com.github.eclipsecolortheme.feature_${version}.jar";
+      sha256 = "128b9b1cib5ff0w1114ns5mrbrhj2kcm358l4dpnma1s8gklm8g2";
+    };
+
+    srcPlugin = fetchurl {
+      url = "https://eclipse-color-theme.github.io/update/plugins/com.github.eclipsecolortheme_${version}.jar";
+      sha256 = "0wz61909bhqwzpqwll27ia0cn3anyp81haqx3rj1iq42cbl42h0y";
+    };
+
+    meta = with stdenv.lib; {
+      homepage = http://eclipsecolorthemes.org/;
+      description = "Plugin to switch color themes conveniently and without side effects";
+      license = licenses.epl10;
+      platforms = platforms.all;
+      maintainers = [ maintainers.rycee ];
+    };
+  };
+
+  eclemma = buildEclipseUpdateSite rec {
+    name = "eclemma-${version}";
+    version = "2.3.2.201409141915";
+
+    src = fetchzip {
+      stripRoot = false;
+      url = "mirror://sourceforge/project/eclemma/01_EclEmma_Releases/2.3.2/eclemma-2.3.2.zip";
+      sha256 = "0w1kwcjh45p7msv5vpc8i6dsqwrnfmjama6vavpnxlji56jd3c43";
+    };
+
+    meta = with stdenv.lib; {
+      homepage = http://www.eclemma.org/;
+      description = "EclEmma is a free Java code coverage tool for Eclipse";
+      license = licenses.epl10;
+      platforms = platforms.all;
+      maintainers = [ maintainers.rycee ];
+    };
+  };
+
+  emacsplus = buildEclipsePlugin rec {
+    name = "emacsplus-${version}";
+    version = "4.2.0";
+
+    srcFeature = fetchurl {
+      url = "http://www.mulgasoft.com/emacsplus/e4/update-site/features/com.mulgasoft.emacsplus.feature_${version}.jar";
+      sha256 = "0wja3cd7gq8w25797fxnafvcncjnmlv8qkl5iwqj7zja2f45vka8";
+    };
+
+    srcPlugin = fetchurl {
+      url = "http://www.mulgasoft.com/emacsplus/e4/update-site/plugins/com.mulgasoft.emacsplus_${version}.jar";
+      sha256 = "08yw45nr90mlpdzim74vsvdaxj41sgpxcrqk5ia6l2dzvrqlsjs1";
+    };
+
+    meta = with stdenv.lib; {
+      homepage = http://www.mulgasoft.com/emacsplus/;
+      description = "Provides a more Emacs-like experience in the Eclipse text editors";
+      license = licenses.epl10;
+      platforms = platforms.all;
+      maintainers = [ maintainers.rycee ];
+    };
+  };
+
+  findbugs = buildEclipsePlugin rec {
+    name = "findbugs-${version}";
+    version = "3.0.1.20150306-5afe4d1";
+
+    srcFeature = fetchurl {
+      url = "http://findbugs.cs.umd.edu/eclipse/features/edu.umd.cs.findbugs.plugin.eclipse_${version}.jar";
+      sha256 = "1m9fav2xlb9wrx2d00lpnh2sy0w5yzawynxm6xhhbfdzd0vpfr9v";
+    };
+
+    srcPlugin = fetchurl {
+      url = "http://findbugs.cs.umd.edu/eclipse/plugins/edu.umd.cs.findbugs.plugin.eclipse_${version}.jar";
+      sha256 = "10p3mrbp9wi6jhlmmc23qv7frh605a23pqsc7w96569bsfb5wa8q";
+    };
+
+    meta = with stdenv.lib; {
+      homepage = http://findbugs.sourceforge.net/;
+      description = "Plugin that uses static analysis to look for bugs in Java code";
+      license = licenses.epl10;
+      platforms = platforms.all;
+      maintainers = [ maintainers.rycee ];
+    };
+  };
+
+  gnuarmeclipse = buildEclipseUpdateSite rec {
+    name = "gnuarmeclipse-${version}";
+    version = "2.8.1-201504061754";
+
+    src = fetchzip {
+      stripRoot = false;
+      url = "mirror://sourceforge/project/gnuarmeclipse/Current%20Releases/2.x/ilg.gnuarmeclipse.repository-${version}.zip";
+      sha256 = "08jsnyis1ry62cidr9sl11ylyxbkwh834nlhx6qp31gh1l439px9";
+    };
+
+    meta = with stdenv.lib; {
+      homepage = http://gnuarmeclipse.livius.net/;
+      description = "GNU ARM Eclipse Plug-ins";
+      license = licenses.epl10;
+      platforms = platforms.all;
+      maintainers = [ maintainers.bjornfor ];
+    };
+  };
+
+  jdt = buildEclipseUpdateSite rec {
+    name = "jdt-${version}";
+    version = "4.5";
+
+    src = fetchzip {
+      stripRoot = false;
+      url = "https://www.eclipse.org/downloads/download.php?r=1&nf=1&file=/eclipse/downloads/drops4/R-4.5-201506032000/org.eclipse.jdt-4.5.zip";
+      sha256 = "0zrdn26f7qsms2xfiyc049bhhh0czsbf989pgyq736b8hfmmh9iy";
+    };
+
+    meta = with stdenv.lib; {
+      homepage = https://www.eclipse.org/jdt/;
+      description = "Eclipse Java development tools";
+      license = licenses.epl10;
+      platforms = platforms.all;
+      maintainers = [ maintainers.rycee ];
+    };
+  };
+
+  scala = buildEclipseUpdateSite rec {
+    name = "scala-${version}";
+    version = "4.1.1";
+
+    src = fetchzip {
+      url = "http://download.scala-ide.org/sdk/lithium/e44/scala211/stable/update-site.zip";
+      sha256 = "0p2dbf56rw733dhsxy9hdwmbzqlk01j8f2hci21bsipq5w2144x6";
+    };
+
+    meta = with stdenv.lib; {
+      homepage = "http://scala-ide.org/";
+      description = "The Scala IDE for Eclipse";
+      license = licenses.bsd3;
+      platforms = platforms.all;
+      maintainers = [ maintainers.rycee ];
+    };
+  };
+
+  testng = buildEclipsePlugin rec {
+    name = "testng-${version}";
+    version = "6.9.5.201506120235";
+
+    srcFeature = fetchurl {
+      url = "http://beust.com/eclipse/features/org.testng.eclipse_6.9.5.201506120235.jar";
+      sha256 = "02imv0rw10pik55a7p00jin65shvhfpzgna02ky94yx7dlf9fyy9";
+    };
+
+    srcPlugin = fetchurl {
+      url = "http://beust.com/eclipse/plugins/org.testng.eclipse_6.9.5.201506120235.jar";
+      sha256 = "0ni1ky4p5l1qzph0np1qw9pcyhrvy6zmn9c8q1b5rm5xv1fcvji4";
+    };
+
+    meta = with stdenv.lib; {
+      homepage = http://testng.org/;
+      description = "Eclipse plugin for the TestNG testing framework";
+      license = licenses.asl20;
+      platforms = platforms.all;
+      maintainers = [ maintainers.rycee ];
+    };
+  };
+
+}
diff --git a/pkgs/applications/editors/emacs-24/default.nix b/pkgs/applications/editors/emacs-24/default.nix
index 487fccfa90d..178b2a306af 100644
--- a/pkgs/applications/editors/emacs-24/default.nix
+++ b/pkgs/applications/editors/emacs-24/default.nix
@@ -1,5 +1,5 @@
 { stdenv, fetchurl, ncurses, x11, libXaw, libXpm, Xaw3d
-, pkgconfig, gettext, gtk, libXft, dbus, libpng, libjpeg, libungif
+, pkgconfig, gettext, libXft, dbus, libpng, libjpeg, libungif
 , libtiff, librsvg, texinfo, gconf, libxml2, imagemagick, gnutls
 , alsaLib, cairo, acl, gpm
 , withX ? !stdenv.isDarwin
@@ -45,8 +45,8 @@ stdenv.mkDerivation rec {
     ++ stdenv.lib.optionals withX
       [ x11 libXaw Xaw3d libXpm libpng libjpeg libungif libtiff librsvg libXft
         imagemagick gconf ]
-    ++ stdenv.lib.optional (withX && withGTK2) [ gtk2 ]
-    ++ stdenv.lib.optional (withX && withGTK3) [ gtk3 ]
+    ++ stdenv.lib.optional (withX && withGTK2) gtk2
+    ++ stdenv.lib.optional (withX && withGTK3) gtk3
     ++ stdenv.lib.optional (stdenv.isDarwin && withX) cairo;
 
   configureFlags =
diff --git a/pkgs/applications/editors/vanubi/default.nix b/pkgs/applications/editors/vanubi/default.nix
index 189682ec4e3..de0236a50e8 100644
--- a/pkgs/applications/editors/vanubi/default.nix
+++ b/pkgs/applications/editors/vanubi/default.nix
@@ -3,11 +3,11 @@
 
 stdenv.mkDerivation rec {
   name = "vanubi-${version}";
-  version = "0.0.14";
+  version = "0.0.16";
 
   src = fetchurl {
     url = "https://github.com/vanubi/vanubi/archive/v${version}.tar.gz";
-    sha256 = "0cd45zm54j6xz1a31qllg2w7l77sncv7mrpfx9bjzdiqpmzsdypl";
+    sha256 = "145zxgaky5bcq5bxm4z7h0pvviq7k1nrgnf40q6nax6ik616ybjq";
   };
 
   buildInputs = [ pkgconfig vala which autoconf automake
diff --git a/pkgs/applications/graphics/openimageio/default.nix b/pkgs/applications/graphics/openimageio/default.nix
index de37482d51e..6bffa834ae0 100644
--- a/pkgs/applications/graphics/openimageio/default.nix
+++ b/pkgs/applications/graphics/openimageio/default.nix
@@ -20,9 +20,9 @@ stdenv.mkDerivation rec {
     "-DUSE_PYTHON=OFF"
   ];
 
-  buildPhase = ''
-    make ILMBASE_HOME=${ilmbase} OPENEXR_HOME=${openexr} USE_PYTHON=0 \
-      INSTALLDIR=$out dist_dir=
+  preBuild = ''
+    makeFlags="ILMBASE_HOME=${ilmbase} OPENEXR_HOME=${openexr} USE_PYTHON=0
+      INSTALLDIR=$out dist_dir="
   '';
 
   enableParallelBuilding = true;
diff --git a/pkgs/applications/misc/keepass/default.nix b/pkgs/applications/misc/keepass/default.nix
index f659e4f6c2d..950d16eeac8 100644
--- a/pkgs/applications/misc/keepass/default.nix
+++ b/pkgs/applications/misc/keepass/default.nix
@@ -2,11 +2,11 @@
 
 buildDotnetPackage rec {
   baseName = "keepass";
-  version = "2.29";
+  version = "2.30";
 
   src = fetchurl {
     url = "mirror://sourceforge/keepass/KeePass-${version}-Source.zip";
-    sha256 = "051s0aznyyhbpdbly6h5rs0ax0zvkp45dh93nmq6lwhicswjwn5m";
+    sha256 = "1r792cikgvzj4hrxiv7xd3gx2zmn16dbh4inj2zi6ny0gchkqg2a";
   };
 
   sourceRoot = ".";
diff --git a/pkgs/applications/misc/keepassx/2.0.nix b/pkgs/applications/misc/keepassx/2.0.nix
index 1c5f2c6e781..ff61ea5d010 100644
--- a/pkgs/applications/misc/keepassx/2.0.nix
+++ b/pkgs/applications/misc/keepassx/2.0.nix
@@ -1,10 +1,10 @@
 { stdenv, fetchurl, cmake, libgcrypt, qt4, xlibs, ... }:
 
 stdenv.mkDerivation {
-  name = "keepassx2-2.0alpha6";
+  name = "keepassx2-2.0beta1";
   src = fetchurl {
-    url = "https://github.com/keepassx/keepassx/archive/2.0-alpha6.tar.gz";
-    sha256 = "592f9995b13c4f84724fb24a0078162246397eedccd467daaf0fd3608151f2b0";
+    url = "https://github.com/keepassx/keepassx/archive/2.0-beta1.tar.gz";
+    sha256 = "1wnbk9laixz16lmchr1lnv8m9i6rkxv6slnx8f0fyczx90y97qdw";
   };
 
   buildInputs = [ cmake libgcrypt qt4 xlibs.libXtst ];
diff --git a/pkgs/applications/misc/lyx/default.nix b/pkgs/applications/misc/lyx/default.nix
index 27830b9baee..fcde5ed3abd 100644
--- a/pkgs/applications/misc/lyx/default.nix
+++ b/pkgs/applications/misc/lyx/default.nix
@@ -3,12 +3,12 @@
 }:
 
 stdenv.mkDerivation rec {
-  version = "2.1.3";
+  version = "2.1.4";
   name = "lyx-${version}";
 
   src = fetchurl {
     url = "ftp://ftp.lyx.org/pub/lyx/stable/2.1.x/${name}.tar.xz";
-    sha256 = "10jnqz7ilxppv60h0hpkq7wgc3fbcm3z19xhnqz9hwp3brz2xm9g";
+    sha256 = "0apkir1rw3msdpps0y0c8skr293h6c4l48c1vx0w4brz337lhdfi";
   };
 
   configureFlags = [
diff --git a/pkgs/applications/misc/synergy/cryptopp.patch b/pkgs/applications/misc/synergy/cryptopp.patch
deleted file mode 100644
index 1c296423acd..00000000000
--- a/pkgs/applications/misc/synergy/cryptopp.patch
+++ /dev/null
@@ -1,45 +0,0 @@
-diff -urN synergy-1.4.17-Source/CMakeLists.txt synergy-1.4.17-Source-fix/CMakeLists.txt
---- synergy-1.4.17-Source/CMakeLists.txt	2014-03-14 21:34:19.000000000 +0100
-+++ synergy-1.4.17-Source-fix/CMakeLists.txt	2014-04-11 13:37:18.839338710 +0200
-@@ -145,6 +145,9 @@
- 	check_type_size(long SIZEOF_LONG)
- 	check_type_size(short SIZEOF_SHORT)
- 
-+	# let's just assume cryptopp exists (provided by the Nix expression)
-+	list(APPEND libs cryptopp)
-+
- 	# pthread is used on both Linux and Mac
- 	check_library_exists("pthread" pthread_create "" HAVE_PTHREAD)
- 	if (HAVE_PTHREAD)
-@@ -317,7 +320,6 @@
- endif()
- 
- add_subdirectory(src)
--add_subdirectory(ext)
- 
- if (WIN32)
- 	# TODO:	consider using /analyze to uncover potential bugs in the source code.
-diff -urN synergy-1.4.17-Source/src/lib/io/CryptoMode_cryptopp.h synergy-1.4.17-Source-fix/src/lib/io/CryptoMode_cryptopp.h
---- synergy-1.4.17-Source/src/lib/io/CryptoMode_cryptopp.h	2014-02-28 13:36:45.000000000 +0100
-+++ synergy-1.4.17-Source-fix/src/lib/io/CryptoMode_cryptopp.h	2014-04-11 13:36:01.111985556 +0200
-@@ -25,6 +25,6 @@
- #	pragma GCC system_header
- #endif 
- 
--#include <cryptopp562/gcm.h>
--#include <cryptopp562/modes.h>
--#include <cryptopp562/aes.h>
-+#include <cryptopp/gcm.h>
-+#include <cryptopp/modes.h>
-+#include <cryptopp/aes.h>
-diff -urN synergy-1.4.17-Source/src/lib/io/CryptoStream_cryptopp.h synergy-1.4.17-Source-fix/src/lib/io/CryptoStream_cryptopp.h
---- synergy-1.4.17-Source/src/lib/io/CryptoStream_cryptopp.h	2014-02-28 13:36:45.000000000 +0100
-+++ synergy-1.4.17-Source-fix/src/lib/io/CryptoStream_cryptopp.h	2014-04-11 13:36:07.173013005 +0200
-@@ -25,5 +25,5 @@
- #	pragma GCC system_header
- #endif
- 
--#include <cryptopp562/osrng.h>
--#include <cryptopp562/sha.h>
-+#include <cryptopp/osrng.h>
-+#include <cryptopp/sha.h>
diff --git a/pkgs/applications/misc/synergy/default.nix b/pkgs/applications/misc/synergy/default.nix
index 0d3337b478f..c010047845f 100644
--- a/pkgs/applications/misc/synergy/default.nix
+++ b/pkgs/applications/misc/synergy/default.nix
@@ -1,38 +1,44 @@
 { stdenv, fetchFromGitHub, cmake, x11, libX11, libXi, libXtst, libXrandr
-, xinput, curl, cryptopp ? null, unzip }:
-
-assert stdenv.isLinux -> cryptopp != null;
+, xinput, curl, openssl, unzip }:
 
 with stdenv.lib;
 
 stdenv.mkDerivation rec {
   name = "synergy-${version}";
-  version = "1.6.3";
+  version = "1.7.4";
 
   src = fetchFromGitHub {
     owner = "synergy";
     repo = "synergy";
-    rev = version;
-    sha256 = "0n4zvz669vi2wyn6i6xhxp0j3nvjl4yzm441cqv6hb0d5k26wbcn";
+    rev = "v${version}-stable";
+    sha256 = "0pxj0qpnsaffpaxik8vc5rjfinmx8ab3b2lssrxkfbs7isskvs33";
   };
 
-  patches = optional stdenv.isLinux ./cryptopp.patch;
-
-  postPatch = (if stdenv.isLinux then ''
-    sed -i -e '/HAVE_X11_EXTENSIONS_XRANDR_H/c \
-      set(HAVE_X11_EXTENSIONS_XRANDR_H true)' CMakeLists.txt
-  '' else ''
-    ${unzip}/bin/unzip -d ext/cryptopp562 ext/cryptopp562.zip
-  '') + ''
+  postPatch = ''
     ${unzip}/bin/unzip -d ext/gmock-1.6.0 ext/gmock-1.6.0.zip
     ${unzip}/bin/unzip -d ext/gtest-1.6.0 ext/gtest-1.6.0.zip
+  ''
+    # We have XRRNotifyEvent (libXrandr), but with the upstream CMakeLists.txt
+    # it's not able to find it (it's trying to search the store path of libX11
+    # instead) and we don't get XRandR support, even though the CMake output
+    # _seems_ to say so:
+    #
+    #   Looking for XRRQueryExtension in Xrandr - found
+    #
+    # The relevant part however is:
+    #
+    #   Looking for XRRNotifyEvent - not found
+    #
+    # So let's force it:
+  + optionalString stdenv.isLinux ''
+    sed -i -e '/HAVE_X11_EXTENSIONS_XRANDR_H/c \
+      set(HAVE_X11_EXTENSIONS_XRANDR_H true)
+    ' CMakeLists.txt
   '';
 
-  buildInputs = [ cmake x11 libX11 libXi libXtst libXrandr xinput curl ]
-             ++ optional stdenv.isLinux cryptopp;
-
-  # At this moment make install doesn't work for synergy
-  # http://synergy-foss.org/spit/issues/details/3317/
+  buildInputs = [
+    cmake x11 libX11 libXi libXtst libXrandr xinput curl openssl
+  ];
 
   installPhase = ''
     mkdir -p $out/bin
@@ -45,8 +51,8 @@ stdenv.mkDerivation rec {
   checkPhase = "../bin/unittests";
 
   meta = {
-    description = "Tool to share the mouse keyboard and the clipboard between computers";
-    homepage = http://synergy-foss.org;
+    description = "Share one mouse and keyboard between multiple computers";
+    homepage = "http://synergy-project.org/";
     license = licenses.gpl2;
     maintainers = [ maintainers.aszlig ];
     platforms = platforms.all;
diff --git a/pkgs/applications/networking/browsers/chromium/source/build_fixes_46.patch b/pkgs/applications/networking/browsers/chromium/source/build_fixes_46.patch
new file mode 100644
index 00000000000..c0aeb5d3a56
--- /dev/null
+++ b/pkgs/applications/networking/browsers/chromium/source/build_fixes_46.patch
@@ -0,0 +1,14 @@
+diff --git a/chrome/test/data/webui_test_resources.grd b/chrome/test/data/webui_test_resources.grd
+index 6f8530d..f92a76a 100644
+--- a/chrome/test/data/webui_test_resources.grd
++++ b/chrome/test/data/webui_test_resources.grd
+@@ -6,9 +6,4 @@
+     </output>
+     <output filename="webui_test_resources.pak" type="data_package" />
+   </outputs>
+-  <release seq="1">
+-    <includes>
+-      <include name="IDR_WEBUI_TEST_I18N_PROCESS_CSS_TEST" file="webui/i18n_process_css_test.html" flattenhtml="true" allowexternalscript="true" type="BINDATA" />
+-    </includes>
+-  </release>
+ </grit>
diff --git a/pkgs/applications/networking/browsers/chromium/source/default.nix b/pkgs/applications/networking/browsers/chromium/source/default.nix
index 98445cedfdc..732568291d3 100644
--- a/pkgs/applications/networking/browsers/chromium/source/default.nix
+++ b/pkgs/applications/networking/browsers/chromium/source/default.nix
@@ -44,7 +44,11 @@ in stdenv.mkDerivation {
     done
   '';
 
-  patches = singleton ./nix_plugin_paths_44.patch;
+  patches =
+    if versionOlder version "45.0.0.0"
+    then singleton ./nix_plugin_paths_44.patch
+    else singleton ./nix_plugin_paths_46.patch ++
+         optional (!versionOlder version "46.0.0.0") ./build_fixes_46.patch;
 
   patchPhase = let
     diffmod = sym: "/^${sym} /{s/^${sym} //;${transform ""};s/^/${sym} /}";
diff --git a/pkgs/applications/networking/browsers/chromium/source/nix_plugin_paths_46.patch b/pkgs/applications/networking/browsers/chromium/source/nix_plugin_paths_46.patch
new file mode 100644
index 00000000000..7482be7062d
--- /dev/null
+++ b/pkgs/applications/networking/browsers/chromium/source/nix_plugin_paths_46.patch
@@ -0,0 +1,75 @@
+diff --git a/chrome/common/chrome_paths.cc b/chrome/common/chrome_paths.cc
+index 74bf041..5f34198 100644
+--- a/chrome/common/chrome_paths.cc
++++ b/chrome/common/chrome_paths.cc
+@@ -66,21 +66,14 @@ static base::LazyInstance<base::FilePath>
+     g_invalid_specified_user_data_dir = LAZY_INSTANCE_INITIALIZER;
+ 
+ // Gets the path for internal plugins.
+-bool GetInternalPluginsDirectory(base::FilePath* result) {
+-#if defined(OS_MACOSX) && !defined(OS_IOS)
+-  // If called from Chrome, get internal plugins from a subdirectory of the
+-  // framework.
+-  if (base::mac::AmIBundled()) {
+-    *result = chrome::GetFrameworkBundlePath();
+-    DCHECK(!result->empty());
+-    *result = result->Append("Internet Plug-Ins");
+-    return true;
+-  }
+-  // In tests, just look in the module directory (below).
+-#endif
+-
+-  // The rest of the world expects plugins in the module directory.
+-  return PathService::Get(base::DIR_MODULE, result);
++bool GetInternalPluginsDirectory(base::FilePath* result,
++                                 const std::string& ident) {
++  std::string full_env = std::string("NIX_CHROMIUM_PLUGIN_PATH_") + ident;
++  const char* value = getenv(full_env.c_str());
++  if (value == NULL)
++      return PathService::Get(base::DIR_MODULE, result);
++  else
++      *result = base::FilePath(value);
+ }
+ 
+ #if defined(OS_WIN)
+@@ -253,11 +246,11 @@ bool PathProvider(int key, base::FilePath* result) {
+       create_dir = true;
+       break;
+     case chrome::DIR_INTERNAL_PLUGINS:
+-      if (!GetInternalPluginsDirectory(&cur))
++      if (!GetInternalPluginsDirectory(&cur, "ALL"))
+         return false;
+       break;
+     case chrome::DIR_PEPPER_FLASH_PLUGIN:
+-      if (!GetInternalPluginsDirectory(&cur))
++      if (!GetInternalPluginsDirectory(&cur, "PEPPERFLASH"))
+         return false;
+       cur = cur.Append(kPepperFlashBaseDirectory);
+       break;
+@@ -314,7 +307,7 @@ bool PathProvider(int key, base::FilePath* result) {
+     // We currently need a path here to look up whether the plugin is disabled
+     // and what its permissions are.
+     case chrome::FILE_NACL_PLUGIN:
+-      if (!GetInternalPluginsDirectory(&cur))
++      if (!GetInternalPluginsDirectory(&cur, "NACL"))
+         return false;
+       cur = cur.Append(kInternalNaClPluginFileName);
+       break;
+@@ -349,7 +342,7 @@ bool PathProvider(int key, base::FilePath* result) {
+         cur = cur.DirName();
+       }
+ #else
+-      if (!GetInternalPluginsDirectory(&cur))
++      if (!GetInternalPluginsDirectory(&cur, "PNACL"))
+         return false;
+ #endif
+       cur = cur.Append(FILE_PATH_LITERAL("pnacl"));
+@@ -366,7 +359,7 @@ bool PathProvider(int key, base::FilePath* result) {
+     // In the component case, this is the source adapter. Otherwise, it is the
+     // actual Pepper module that gets loaded.
+     case chrome::FILE_WIDEVINE_CDM_ADAPTER:
+-      if (!GetInternalPluginsDirectory(&cur))
++      if (!GetInternalPluginsDirectory(&cur, "WIDEVINE"))
+         return false;
+       cur = cur.AppendASCII(kWidevineCdmAdapterFileName);
+       break;
diff --git a/pkgs/applications/networking/browsers/chromium/source/sources.nix b/pkgs/applications/networking/browsers/chromium/source/sources.nix
index c3cc9c3ed18..141b1635c4f 100644
--- a/pkgs/applications/networking/browsers/chromium/source/sources.nix
+++ b/pkgs/applications/networking/browsers/chromium/source/sources.nix
@@ -1,21 +1,21 @@
 # This file is autogenerated from update.sh in the parent directory.
 {
   dev = {
-    version = "45.0.2454.15";
-    sha256 = "1zg562cpn9ddai92jdjg3frhmvbhbkf71ysprwqa3rgbg6w8ipzj";
-    sha256bin32 = "1fcwzwb6zq7ld7fs0iws0d9jmxhjhdax4y744dx4d7bc77357x3m";
-    sha256bin64 = "0273dy5b1r9s9g8ixrafnxm8jnn4ha36r3b3ckdabm9y4pqwx54s";
+    version = "46.0.2478.0";
+    sha256 = "15h6gq9vzycamdx01cyz3dv8raprdrd4k97c8pigxbli3n18b41k";
+    sha256bin32 = "0q10zacsl82nadfvp59ppidai74pc53000qsh4ixdji3xqcbisk4";
+    sha256bin64 = "1v57w8n7dxw1yb20710f0mzkvil7apyikvfp0174xb2rbr1ipwng";
   };
   beta = {
-    version = "45.0.2454.15";
-    sha256 = "1zg562cpn9ddai92jdjg3frhmvbhbkf71ysprwqa3rgbg6w8ipzj";
-    sha256bin32 = "1scjirp54z08h36zs9z9yq4pxcximf00krlip9dkvxsxh65qiw5w";
-    sha256bin64 = "14l8lka8jci1d90vbz5kpl20mk98n1ak4mw667dkz89cch5gal4s";
+    version = "45.0.2454.26";
+    sha256 = "0ghgvll1q6nw1ds139nmabbilagffyln7k313w1yvn707wp7yg33";
+    sha256bin32 = "0611ad202vck0zi0jcldcr4j81kd9cnabsc9kssc6m46fy5rhhbk";
+    sha256bin64 = "0bwmpl7rq2nj0jf1xqx7n1mvx9kigbvpz2f8v0azwv4nb56p9c2q";
   };
   stable = {
-    version = "44.0.2403.130";
-    sha256 = "055lccfiqdqwcjnx9l9xgzcilm2m341rg66nfnnadqa490prnxrp";
-    sha256bin32 = "0yzjhqyw2aaiwfv395c75avizcg28f3bn9zkqk2p3ifcv231w15v";
-    sha256bin64 = "1dzwlrdvnqyz6rpcl3pavpvqsx6la1d04cvgca3iaanq5xcana8b";
+    version = "44.0.2403.155";
+    sha256 = "0g4z46vbqwnsbmhlbyqm3lm5dz6sxjz0m51cnxhxs850231738pb";
+    sha256bin32 = "11f8224b8p14py5abi78m74l5hsrhdhipcf2dw7bgqddhykzr4h6";
+    sha256bin64 = "1mhbga7s43qg13rv6ss0xsn8hkf9fdmgd293ymj564ih39l9bnbm";
   };
 }
diff --git a/pkgs/applications/networking/browsers/firefox/default.nix b/pkgs/applications/networking/browsers/firefox/default.nix
index c11eef3189b..171925169f3 100644
--- a/pkgs/applications/networking/browsers/firefox/default.nix
+++ b/pkgs/applications/networking/browsers/firefox/default.nix
@@ -16,14 +16,14 @@
 
 assert stdenv.cc ? libc && stdenv.cc.libc != null;
 
-let version = "39.0.3"; in
+let version = "40.0"; in
 
 stdenv.mkDerivation rec {
   name = "firefox-${version}";
 
   src = fetchurl {
     url = "http://ftp.mozilla.org/pub/mozilla.org/firefox/releases/${version}/source/firefox-${version}.source.tar.bz2";
-    sha1 = "e024e528317d6c531fb36a26d2ce3317d3510b42";
+    sha1 = "48483e5738182f8567e2b6d2e29bd6bc1812d3eb";
   };
 
   buildInputs =
diff --git a/pkgs/applications/networking/feedreaders/rsstail/default.nix b/pkgs/applications/networking/feedreaders/rsstail/default.nix
index 2d4b9741375..e6f6c162067 100644
--- a/pkgs/applications/networking/feedreaders/rsstail/default.nix
+++ b/pkgs/applications/networking/feedreaders/rsstail/default.nix
@@ -1,12 +1,12 @@
 { stdenv, fetchFromGitHub, cppcheck, libmrss }:
 
-let version = "1.9.1"; in
+let version = "2.0"; in
 stdenv.mkDerivation rec {
   name = "rsstail-${version}";
 
   src = fetchFromGitHub {
-    sha256 = "0jhf7vr7y56r751wy4ix80iwhgxhk6mbbin8gnx59i457gf6sjl1";
-    rev = "1220d63aaa233961636f859d9a406536fffb64f4";
+    sha256 = "0fbsyl5bdxr2g25ps7kd34sa0mzggklbg4v7qss68gh82zdp16ch";
+    rev = "69dc5e30439b89c037aa49c5af861f28df607c72";
     repo = "rsstail";
     owner = "flok99";
   };
@@ -28,14 +28,11 @@ stdenv.mkDerivation rec {
     ++ stdenv.lib.optional doCheck cppcheck;
 
   postPatch = ''
-    substituteInPlace Makefile --replace /usr $out
+    substituteInPlace Makefile --replace -liconv ""
   '';
 
+  makeFlags = "prefix=$(out)";
   enableParallelBuilding = true;
 
   doCheck = true;
-
-  preInstall = ''
-    mkdir -p $out/{bin,share/man/man1}
-  '';
 }
diff --git a/pkgs/applications/networking/instant-messengers/pidgin-plugins/pidgin-opensteamworks/default.nix b/pkgs/applications/networking/instant-messengers/pidgin-plugins/pidgin-opensteamworks/default.nix
new file mode 100644
index 00000000000..30d90ba302d
--- /dev/null
+++ b/pkgs/applications/networking/instant-messengers/pidgin-plugins/pidgin-opensteamworks/default.nix
@@ -0,0 +1,31 @@
+{ stdenv, fetchFromGitHub, pidgin, unzip, glib, json_glib, nss, nspr, libgnome_keyring } :
+
+stdenv.mkDerivation rec {
+  name = "pidgin-opensteamworks-1.5.1";
+
+  # Temporarily sourcing this from a mirror in my github account, until such time as the project is officially migrated away from the deprecated google code service
+  src = fetchFromGitHub {
+    owner = "Shados";
+    repo = "pidgin-opensteamworks";
+    rev = "4f0ea110a5bdba9d2b18ec8785b2edb276f0cccd";
+    sha256 = "0gcrc1yaf29yjfhpflpn451i7isw8zc7maw77g604815myc5k025";
+  };
+
+  preConfigure = "cd steam-mobile";
+  postInstall = ''
+    mkdir -p $out/lib/pidgin/
+    mkdir -p $out/share/pixmaps/pidgin/protocols/
+    cp libsteam.so $out/lib/pidgin/
+    unzip releases/icons.zip -d $out/share/pixmaps/pidgin/protocols/
+  '';
+
+  buildInputs = [ pidgin unzip glib json_glib nss nspr libgnome_keyring ];
+
+  meta = with stdenv.lib; {
+    homepage = https://code.google.com/p/pidgin-opensteamworks;
+    description = "Plugin for Pidgin 2.x which implements Steam Friends/Steam IM compatibility";
+    license = licenses.gpl3;
+    platforms = platforms.linux;
+    maintainters = with maintainers; [ arobyn ];
+  };
+}
diff --git a/pkgs/applications/networking/p2p/qbittorrent/default.nix b/pkgs/applications/networking/p2p/qbittorrent/default.nix
index f0e5a1c13e1..8ff11dba905 100644
--- a/pkgs/applications/networking/p2p/qbittorrent/default.nix
+++ b/pkgs/applications/networking/p2p/qbittorrent/default.nix
@@ -10,11 +10,11 @@ assert guiSupport -> (dbus_libs != null);
 with stdenv.lib;
 stdenv.mkDerivation rec {
   name = "qbittorrent-${version}";
-  version = "3.1.11";
+  version = "3.2.3";
 
   src = fetchurl {
     url = "mirror://sourceforge/qbittorrent/${name}.tar.xz";
-    sha256 = "0qvz8ifk01b9sw9x5yh3b5kmssx5yi026zvgvabdvfaqkvcmw43i";
+    sha256 = "05590ak4nnqkah8dy71cxf7mqv6phw0ih1719dm761mxf8vrz9w6";
   };
 
   nativeBuildInputs = [ pkgconfig which ];
@@ -23,14 +23,13 @@ stdenv.mkDerivation rec {
     ++ optional guiSupport dbus_libs;
 
   configureFlags = [
-    "--with-libboost-lib=${boost.lib}/lib"
-    "--with-libboost-inc=${boost.dev}/include"
+    "--with-boost-libdir=${boost.lib}/lib"
+    "--with-boost=${boost.dev}"
     (if guiSupport then "" else "--disable-gui")
     (if webuiSupport then "" else "--disable-webui")
   ] ++ optional debugSupport "--enable-debug";
 
-  # https://github.com/qbittorrent/qBittorrent/issues/1992 
-  enableParallelBuilding = false;
+  enableParallelBuilding = true;
 
   meta = {
     description = "Free Software alternative to µtorrent";
diff --git a/pkgs/applications/networking/sync/backintime/common.nix b/pkgs/applications/networking/sync/backintime/common.nix
index b6535ad7310..14fa69974e8 100644
--- a/pkgs/applications/networking/sync/backintime/common.nix
+++ b/pkgs/applications/networking/sync/backintime/common.nix
@@ -1,13 +1,13 @@
 {stdenv, fetchurl, makeWrapper, gettext, python3, python3Packages, rsync, cron, openssh, sshfsFuse, encfs }:
 
 stdenv.mkDerivation rec {
-  version = "1.1.4";
+  version = "1.1.6";
 
   name = "backintime-common-${version}";
 
   src = fetchurl {
     url = "https://launchpad.net/backintime/1.1/${version}/+download/backintime-${version}.tar.gz";
-    sha256 = "0w57b7xygwx83azz463fd4y7fxz0z6dy74f70ixhvhlsdpxw2ks3";
+    sha256 = "04yw1v6h959mmvc67mhh0km7vkxjzb7j1mniv5xfjdy27ryii1ig";
   };
 
   buildInputs = [ makeWrapper gettext python3 python3Packages.dbus python3Packages.keyring openssh cron rsync sshfsFuse encfs ];
diff --git a/pkgs/applications/office/gnumeric/default.nix b/pkgs/applications/office/gnumeric/default.nix
index e54dd591cfd..8e01d30c44f 100644
--- a/pkgs/applications/office/gnumeric/default.nix
+++ b/pkgs/applications/office/gnumeric/default.nix
@@ -1,21 +1,23 @@
 { stdenv, fetchurl, pkgconfig, intltool, perl, perlXMLParser
 , goffice, gnome3, makeWrapper, gtk3
+, python, pygobject3
 }:
 
 stdenv.mkDerivation rec {
-  name = "gnumeric-1.12.20";
+  name = "gnumeric-1.12.23";
 
   src = fetchurl {
     url = "mirror://gnome/sources/gnumeric/1.12/${name}.tar.xz";
-    sha256 = "1k915ks55a32fpqrr0rx6j8ml9bw0a07f11350qc1bvkx53i2jad";
+    sha256 = "0lcmw4jrfg9y2fhx13xw8w85vi7bcmgyn2sdjxi21xkh3szlqiq0";
   };
 
   configureFlags = "--disable-component";
 
-  # ToDo: optional libgda, python, introspection?
+  # ToDo: optional libgda, introspection?
   buildInputs = [
     pkgconfig intltool perl perlXMLParser
     goffice gtk3 makeWrapper gnome3.defaultIconTheme
+    python pygobject3
   ];
 
   enableParallelBuilding = true;
diff --git a/pkgs/applications/office/zim/default.nix b/pkgs/applications/office/zim/default.nix
index ac8059fc1d1..84a5680b1f4 100644
--- a/pkgs/applications/office/zim/default.nix
+++ b/pkgs/applications/office/zim/default.nix
@@ -9,12 +9,12 @@
 
 buildPythonPackage rec {
   name = "zim-${version}";
-  version = "0.62";
+  version = "0.63";
   namePrefix = "";
   
   src = fetchurl {
     url = "http://zim-wiki.org/downloads/${name}.tar.gz";
-    sha256 = "1hmx24jjazqvs3z6h10jl8wrqxyvvk0wc807v222vaf1sbmjmmhr";
+    sha256 = "077vf4h0hjmbk8bxj9l0z9rxcb3dw642n32lvfn6vjdna1qm910m";
   };
 
   propagatedBuildInputs = [ pythonPackages.sqlite3 pygtk /*pythonPackages.pyxdg*/ pygobject ];
diff --git a/pkgs/applications/science/math/cbc/default.nix b/pkgs/applications/science/math/cbc/default.nix
new file mode 100644
index 00000000000..aa749a25889
--- /dev/null
+++ b/pkgs/applications/science/math/cbc/default.nix
@@ -0,0 +1,26 @@
+{ lib, stdenv, fetchurl, zlib, bzip2 }:
+
+stdenv.mkDerivation {
+  name = "cbc-2.9.5";
+
+  src = fetchurl {
+    url = "http://www.coin-or.org/download/source/Cbc/Cbc-2.9.5.tgz";
+    sha256 = "0kmsg9qpajh5jhnql04m6akpdjzlppxfz99q320vw5bkzgl3i18w";
+  };
+
+  configureFlags = "-C";
+
+  enableParallelBuilding = true;
+
+  buildInputs = [ zlib bzip2 ];
+
+  # FIXME: move share/coin/Data to a separate output?
+
+  meta = {
+    homepage = https://projects.coin-or.org/Cbc;
+    license = lib.licenses.epl10;
+    maintainers = [ lib.maintainers.eelco ];
+    platforms = lib.platforms.linux;
+    description = "A mixed integer programming solver";
+  };
+}
diff --git a/pkgs/applications/virtualization/virt-manager/default.nix b/pkgs/applications/virtualization/virt-manager/default.nix
index 604cad4c066..a98ebe424c6 100644
--- a/pkgs/applications/virtualization/virt-manager/default.nix
+++ b/pkgs/applications/virtualization/virt-manager/default.nix
@@ -1,7 +1,7 @@
 { stdenv, fetchurl, pythonPackages, intltool, libxml2Python, curl, python
-, makeWrapper, virtinst, pyGtkGlade, pythonDBus, gnome_python, gtkvnc, vte
+, wrapGAppsHook, virtinst, pyGtkGlade, pythonDBus, gnome_python, gtkvnc, vte
 , gtk3, gobjectIntrospection, libvirt-glib, gsettings_desktop_schemas, glib
-, avahi, dconf, spiceSupport ? true, spice_gtk, libosinfo
+, avahi, dconf, spiceSupport ? true, spice_gtk, libosinfo, gnome3
 }:
 
 with stdenv.lib;
@@ -35,6 +35,8 @@ buildPythonPackage rec {
       glib
       gobjectIntrospection
       gsettings_desktop_schemas
+      gnome3.defaultIconTheme
+      wrapGAppsHook
     ];
 
   configurePhase = ''
@@ -46,15 +48,6 @@ buildPythonPackage rec {
   buildPhase = "true";
 
   postInstall = ''
-    # GI_TYPELIB_PATH is needed at runtime for GObject stuff to work
-    for file in "$out"/bin/*; do
-        wrapProgram "$file" \
-            --prefix GI_TYPELIB_PATH : $GI_TYPELIB_PATH \
-            --prefix GIO_EXTRA_MODULES : "${dconf}/lib/gio/modules" \
-            --prefix GSETTINGS_SCHEMA_DIR : $out/share/glib-2.0/schemas \
-            --prefix XDG_DATA_DIRS : "$out/share:${gtk3}/share:$GSETTINGS_SCHEMAS_PATH:\$XDG_DATA_DIRS"
-    done
-
     ${glib}/bin/glib-compile-schemas "$out"/share/glib-2.0/schemas
   '';
 
diff --git a/pkgs/applications/window-managers/bar/xft.nix b/pkgs/applications/window-managers/bar/xft.nix
new file mode 100644
index 00000000000..c671f1a4e03
--- /dev/null
+++ b/pkgs/applications/window-managers/bar/xft.nix
@@ -0,0 +1,26 @@
+{ stdenv, fetchgit, perl, libxcb, libXft }:
+
+let
+  version = "2015-07-23";
+in
+  stdenv.mkDerivation rec {
+    name = "bar-xft-git-${version}";
+
+    src = fetchgit {
+      url = "https://github.com/krypt-n/bar";
+      rev = "020a3e1848ce03287886e9ff80b0b443e9aed543";
+      sha256 = "1xzs37syhlwyjfxnk36qnij5bqa0mi53lf1k851viw4qai2bfkgr";
+    };
+
+    buildInputs = [ libxcb libXft perl ];
+
+    prePatch = ''sed -i "s@/usr@$out@" Makefile'';
+
+    meta = {
+      description = "A lightweight xcb based bar with XFT-support";
+      homepage = https://github.com/krypt-n/bar;
+      maintainers = [ stdenv.lib.maintainers.hiberno ];
+      license = "Custom";
+      platforms = stdenv.lib.platforms.linux;
+    };
+}
diff --git a/pkgs/applications/window-managers/bspwm/default.nix b/pkgs/applications/window-managers/bspwm/default.nix
index c17107ae97b..fbe7e33baad 100644
--- a/pkgs/applications/window-managers/bspwm/default.nix
+++ b/pkgs/applications/window-managers/bspwm/default.nix
@@ -1,12 +1,12 @@
 { stdenv, fetchurl, libxcb, libXinerama, sxhkd, xcbutil, xcbutilkeysyms, xcbutilwm }:
 
 stdenv.mkDerivation rec {
-  name = "bspwm-0.8.9";
+  name = "bspwm-0.9";
   
 
   src = fetchurl {
-    url = "https://github.com/baskerville/bspwm/archive/0.8.9.tar.gz";
-    sha256 = "750c76132914661d8d5edf7809e9b601977215d31e747dd780c60fd562913d55";
+    url = "https://github.com/baskerville/bspwm/archive/0.9.tar.gz";
+    sha256 = "1efb2db7b8a251bcc006d66a050cf66e9d311761c94890bebf91a32905042fde";
   };
 
   buildInputs = [ libxcb libXinerama xcbutil xcbutilkeysyms xcbutilwm ];
@@ -22,7 +22,7 @@ stdenv.mkDerivation rec {
   meta = {
     description = "A tiling window manager based on binary space partitioning";
     homepage = http://github.com/baskerville/bspwm;
-    maintainers = [ stdenv.lib.maintainers.meisternu ];
+    maintainers = [ stdenv.lib.maintainers.meisternu stdenv.lib.maintainers.epitrochoid ];
     license = stdenv.lib.licenses.bsd2;
     platforms = stdenv.lib.platforms.linux;
   };
diff --git a/pkgs/build-support/setup-hooks/wrap-gapps-hook.sh b/pkgs/build-support/setup-hooks/wrap-gapps-hook.sh
index e9fc7f7062d..3445c4b9cc1 100644
--- a/pkgs/build-support/setup-hooks/wrap-gapps-hook.sh
+++ b/pkgs/build-support/setup-hooks/wrap-gapps-hook.sh
@@ -22,7 +22,7 @@ wrapGAppsHook() {
   fi
 
   if [ -d "$prefix/share" ]; then
-    gappsWrapperArgs+=(--prefix XDG_DATA_DIRS : "$out/share")
+    gappsWrapperArgs+=(--prefix XDG_DATA_DIRS : "$prefix/share")
   fi
 
   for v in $wrapPrefixVariables GST_PLUGIN_SYSTEM_PATH_1_0 GI_TYPELIB_PATH GRL_PLUGIN_PATH; do
diff --git a/pkgs/data/documentation/man-pages/default.nix b/pkgs/data/documentation/man-pages/default.nix
index 71fca096c58..db1c16e4633 100644
--- a/pkgs/data/documentation/man-pages/default.nix
+++ b/pkgs/data/documentation/man-pages/default.nix
@@ -1,12 +1,12 @@
 { stdenv, fetchurl }:
 
-let version = "4.01"; in
+let version = "4.02"; in
 stdenv.mkDerivation rec {
   name = "man-pages-${version}";
 
   src = fetchurl {
     url = "mirror://kernel/linux/docs/man-pages/${name}.tar.xz";
-    sha256 = "116jp2rnsdlnb3cwnbfp0g053frcmchndwyrj714swl1lgabb56i";
+    sha256 = "1lqdzw6n3rqhd097lk5w16jcjhwfqs5zvi42hsbk3p92smswpaj8";
   };
 
   makeFlags = "MANDIR=$(out)/share/man";
diff --git a/pkgs/data/fonts/fira-mono/default.nix b/pkgs/data/fonts/fira-mono/default.nix
index 976fb68d79f..8299153aa2c 100644
--- a/pkgs/data/fonts/fira-mono/default.nix
+++ b/pkgs/data/fonts/fira-mono/default.nix
@@ -1,16 +1,16 @@
 { stdenv, fetchurl, unzip }:
 
 stdenv.mkDerivation rec {
-  name = "fira-mono-3.204";
+  name = "fira-mono-3.205";
 
   src = fetchurl {
-    url = http://www.carrois.com/downloads/fira_mono_3_2/FiraMonoFonts3204.zip;
-    sha256 = "0pnsw7b1i5vkwq0kny4lxzly4h8rlwkj610rykhax6zayfbnz62a";
+    url = http://www.carrois.com/downloads/fira_mono_3_2/FiraMonoFonts3205.zip;
+    sha256 = "0zd4wy8ksbz0qiiqgl9w7zyh34q8n983dyb44g5dfdcjakj09qlz";
   };
 
   buildInputs = [ unzip ];
   phases = [ "unpackPhase" "installPhase" ];
-  sourceRoot = "FiraMonoFonts3204";
+  sourceRoot = "FiraMonoFonts3205";
 
   installPhase = ''
     mkdir -p $out/share/fonts/opentype
diff --git a/pkgs/data/fonts/fira/default.nix b/pkgs/data/fonts/fira/default.nix
index b8db1132b7c..18373439ab0 100644
--- a/pkgs/data/fonts/fira/default.nix
+++ b/pkgs/data/fonts/fira/default.nix
@@ -1,16 +1,16 @@
 { stdenv, fetchurl, unzip }:
 
 stdenv.mkDerivation rec {
-  name = "fira-4.104";
+  name = "fira-4.105";
 
   src = fetchurl {
-    url = http://www.carrois.com/downloads/fira_4_1/FiraFonts4104.zip;
-    sha256 = "1i8l0x2wdx4pw7j52lgy8qcx0wqj0azwjiq0wa9kg26x78bdfk2d";
+    url = http://www.carrois.com/downloads/fira_4_1/FiraFonts4105.zip;
+    sha256 = "1857kpn7p7fc1xsmqx9589hk396ggwzd167yc3dmn1mh5dixibfz";
   };
 
   buildInputs = [unzip];
   phases = [ "unpackPhase" "installPhase" ];
-  sourceRoot = "FiraFonts4104";
+  sourceRoot = "FiraFonts4105";
 
   installPhase = ''
     mkdir -p $out/share/fonts/opentype
diff --git a/pkgs/data/fonts/pecita/default.nix b/pkgs/data/fonts/pecita/default.nix
index e28ac6c2618..3e5ad1655be 100644
--- a/pkgs/data/fonts/pecita/default.nix
+++ b/pkgs/data/fonts/pecita/default.nix
@@ -6,7 +6,7 @@ stdenv.mkDerivation rec {
 
   src = fetchurl {
     url = "http://pecita.eu/b/Pecita.otf";
-    sha256 = "11v5yzxa38fxpz8j3fc0v3l7py4i12avjnwrgkmd9clq9jhzk78s";
+    sha256 = "0agml1886jvb0j6jar8hjx4hfbz3n0msszyp625b96ilv09qrcyz";
   };
 
   phases = ["installPhase"];
diff --git a/pkgs/data/misc/geolite-legacy/default.nix b/pkgs/data/misc/geolite-legacy/default.nix
index 65339574dfb..6dccfa69638 100644
--- a/pkgs/data/misc/geolite-legacy/default.nix
+++ b/pkgs/data/misc/geolite-legacy/default.nix
@@ -8,7 +8,7 @@ let
 
   # Annoyingly, these files are updated without a change in URL. This means that
   # builds will start failing every month or so, until the hashes are updated.
-  version = "2015-08-05";
+  version = "2015-08-11";
 in
 stdenv.mkDerivation {
   name = "geolite-legacy-${version}";
@@ -27,10 +27,10 @@ stdenv.mkDerivation {
     "1fhi5vm4drfzyl29b491pr1xr2kbsr3izp9a7k5zm3zkqags2187";
   srcGeoIPASNum = fetchDB
     "asnum/GeoIPASNum.dat.gz" "GeoIPASNum.dat.gz"
-    "04qlh6zr8m5qxl2gcysb721bqlnqrxhngh128zj1w8rhqckjndgj";
+    "1h4wpqs16a1w16znbr2h15b16p5y43vp6qhj0bc7krq5qa484y2k";
   srcGeoIPASNumv6 = fetchDB
     "asnum/GeoIPASNumv6.dat.gz" "GeoIPASNumv6.dat.gz"
-    "06p9wnypnffsmqg5bszwygb73in4gc0h5l26wk0s43pdaldrdrx0";
+    "09qiy2grxnakapvz5xjw3ivbxc0id6srqyd46p68mcy7gwrggcv7";
 
   meta = with stdenv.lib; {
     inherit version;
diff --git a/pkgs/desktops/gnome-3/3.16/apps/gnome-characters/default.nix b/pkgs/desktops/gnome-3/3.16/apps/gnome-characters/default.nix
new file mode 100644
index 00000000000..0c18f926e6d
--- /dev/null
+++ b/pkgs/desktops/gnome-3/3.16/apps/gnome-characters/default.nix
@@ -0,0 +1,24 @@
+{ stdenv, fetchurl, pkgconfig, gnome3, gtk3, wrapGAppsHook
+, intltool, gjs, gdk_pixbuf, librsvg }:
+
+stdenv.mkDerivation rec {
+  name = "gnome-characters-${gnome3.version}.2";
+
+  src = fetchurl {
+    url = "mirror://gnome/sources/gnome-characters/${gnome3.version}/${name}.tar.xz";
+    sha256 = "1gs5k32lmjpi4scb2i7pfnbsy8pl0gb9w1aypyy83hy6ydinaqc4";
+  };
+
+  buildInputs = [
+    pkgconfig gtk3 wrapGAppsHook intltool gjs gdk_pixbuf
+    librsvg gnome3.defaultIconTheme
+  ];
+
+  meta = with stdenv.lib; {
+    homepage = https://wiki.gnome.org/Design/Apps/CharacterMap;
+    description = "Simple utility application to find and insert unusual characters";
+    maintainers = gnome3.maintainers;
+    license = licenses.gpl2;
+    platforms = platforms.linux;
+  };
+}
diff --git a/pkgs/desktops/gnome-3/3.16/apps/gnome-logs/default.nix b/pkgs/desktops/gnome-3/3.16/apps/gnome-logs/default.nix
new file mode 100644
index 00000000000..23c77395a82
--- /dev/null
+++ b/pkgs/desktops/gnome-3/3.16/apps/gnome-logs/default.nix
@@ -0,0 +1,24 @@
+{ stdenv, fetchurl, pkgconfig, gnome3, gtk3, wrapGAppsHook
+, intltool, itstool, libxml2, systemd, hicolor_icon_theme }:
+
+stdenv.mkDerivation rec {
+  name = "gnome-logs-${gnome3.version}.2";
+
+  src = fetchurl {
+    url = "mirror://gnome/sources/gnome-logs/${gnome3.version}/${name}.tar.xz";
+    sha256 = "0732jbvih5d678idvhlgqik9j9y594agwdx6gwap80459k1a6fg1";
+  };
+
+  buildInputs = [
+    pkgconfig gtk3 wrapGAppsHook intltool itstool libxml2
+    systemd hicolor_icon_theme
+  ];
+
+  meta = with stdenv.lib; {
+    homepage = https://wiki.gnome.org/Apps/Logs;
+    description = "A log viewer for the systemd journal";
+    maintainers = gnome3.maintainers;
+    license = licenses.gpl3;
+    platforms = platforms.linux;
+  };
+}
diff --git a/pkgs/desktops/gnome-3/3.16/apps/gnome-maps/default.nix b/pkgs/desktops/gnome-3/3.16/apps/gnome-maps/default.nix
new file mode 100644
index 00000000000..7ee2275df5a
--- /dev/null
+++ b/pkgs/desktops/gnome-3/3.16/apps/gnome-maps/default.nix
@@ -0,0 +1,28 @@
+{ stdenv, fetchurl, intltool, pkgconfig, gnome3, gtk3
+, gobjectIntrospection, gdk_pixbuf, librsvg
+, geoclue2, wrapGAppsHook, folks, libchamplain, gfbgraph, file, libsoup }:
+
+stdenv.mkDerivation rec {
+  name = "gnome-maps-${gnome3.version}.2";
+
+  src = fetchurl {
+    url = "mirror://gnome/sources/gnome-maps/${gnome3.version}/${name}.tar.xz";
+    sha256 = "15kwy2fy9v4zzjaqcifv4jaqcx1227bcdxgd6916ghrdzgj93mx7";
+  };
+
+  doCheck = true;
+
+  buildInputs = [ pkgconfig intltool gobjectIntrospection wrapGAppsHook
+                  gtk3 geoclue2 gnome3.gjs gnome3.libgee folks gfbgraph
+                  gnome3.geocode_glib libchamplain file libsoup
+                  gdk_pixbuf librsvg
+                  gnome3.gnome_online_accounts gnome3.defaultIconTheme ];
+
+  meta = with stdenv.lib; {
+    homepage = https://wiki.gnome.org/Apps/Maps;
+    description = "A map application for GNOME 3";
+    maintainers = gnome3.maintainers;
+    license = licenses.gpl2;
+    platforms = platforms.linux;
+  };
+}
diff --git a/pkgs/desktops/gnome-3/3.16/apps/gnome-weather/default.nix b/pkgs/desktops/gnome-3/3.16/apps/gnome-weather/default.nix
new file mode 100644
index 00000000000..fff9ea5c08b
--- /dev/null
+++ b/pkgs/desktops/gnome-3/3.16/apps/gnome-weather/default.nix
@@ -0,0 +1,24 @@
+{ stdenv, fetchurl, pkgconfig, gnome3, gtk3, wrapGAppsHook, gjs
+, libgweather, intltool, itstool, hicolor_icon_theme }:
+
+stdenv.mkDerivation rec {
+  name = "gnome-weather-${gnome3.version}.2";
+
+  src = fetchurl {
+    url = "mirror://gnome/sources/gnome-weather/${gnome3.version}/${name}.tar.xz";
+    sha256 = "14dx5zj9200qpsb7byfrjkw3144s0q0nmaw5c6ni7vpa8kmvbrac";
+  };
+
+  buildInputs = [
+    pkgconfig gtk3 wrapGAppsHook gjs intltool itstool
+    libgweather hicolor_icon_theme
+  ];
+
+  meta = with stdenv.lib; {
+    homepage = https://wiki.gnome.org/Apps/Weather;
+    description = "Access current weather conditions and forecasts";
+    maintainers = gnome3.maintainers;
+    license = licenses.gpl2;
+    platforms = platforms.linux;
+  };
+}
diff --git a/pkgs/desktops/gnome-3/3.16/apps/polari/default.nix b/pkgs/desktops/gnome-3/3.16/apps/polari/default.nix
new file mode 100644
index 00000000000..21ba8db37d4
--- /dev/null
+++ b/pkgs/desktops/gnome-3/3.16/apps/polari/default.nix
@@ -0,0 +1,27 @@
+{ stdenv, intltool, fetchurl, gdk_pixbuf, adwaita-icon-theme
+, telepathy_glib, gjs, itstool, telepathy_idle
+, pkgconfig, gtk3, glib, librsvg, gnome3, wrapGAppsHook }:
+
+stdenv.mkDerivation rec {
+  name = "polari-${gnome3.version}.1";
+
+  src = fetchurl {
+    url = "mirror://gnome/sources/polari/${gnome3.version}/${name}.tar.xz";
+    sha256 = "0w7hc5i78kq4dkyzpdb9byk4rhqa569cmbg09nh3qxn8ninscdqx";
+  };
+
+  propagatedUserEnvPkgs = [ telepathy_idle ];
+
+  buildInputs = [ pkgconfig gtk3 glib intltool itstool adwaita-icon-theme wrapGAppsHook
+                  telepathy_glib gjs gdk_pixbuf librsvg ];
+
+  enableParallelBuilding = true;
+
+  meta = with stdenv.lib; {
+    homepage = https://wiki.gnome.org/Apps/Polari;
+    description = "IRC chat client designed to integrate with the GNOME desktop";
+    maintainers = gnome3.maintainers;
+    license = licenses.gpl2;
+    platforms = platforms.linux;
+  };
+}
diff --git a/pkgs/desktops/gnome-3/3.16/core/gjs/default.nix b/pkgs/desktops/gnome-3/3.16/core/gjs/default.nix
index 2bb4364a19e..b736e1cd812 100644
--- a/pkgs/desktops/gnome-3/3.16/core/gjs/default.nix
+++ b/pkgs/desktops/gnome-3/3.16/core/gjs/default.nix
@@ -1,22 +1,23 @@
-{ fetchurl, stdenv, pkgconfig, gnome3, gobjectIntrospection, spidermonkey_24, pango }:
+{ fetchurl, stdenv, pkgconfig, gnome3, gtk3, gobjectIntrospection
+, spidermonkey_24, pango, readline, glib }:
 
 let
-  majorVersion = "1.42";
+  majorVersion = "1.43";
 in
 stdenv.mkDerivation rec {
-  name = "gjs-${majorVersion}.0";
+  name = "gjs-${majorVersion}.3";
 
   src = fetchurl {
     url = "mirror://gnome/sources/gjs/${majorVersion}/${name}.tar.xz";
-    sha256 = "0c9afb7d5be6ead5b68059596f08eb7c3902b1676ee9c8846aa8df09647dba13";
+    sha256 = "0khwm8l6m6x71rwf3q92d6scbhmrpiw7kqmj34nn588fb7a4vdc2";
   };
 
-  buildInputs = with gnome3;
-    [ gobjectIntrospection pkgconfig glib pango ];
+  buildInputs = [ gobjectIntrospection pkgconfig gtk3 glib pango readline ];
 
   propagatedBuildInputs = [ spidermonkey_24 ];
 
   meta = with stdenv.lib; {
+    maintainers = gnome3.maintainers;
     platforms = platforms.linux;
   };
 
diff --git a/pkgs/desktops/gnome-3/3.16/default.nix b/pkgs/desktops/gnome-3/3.16/default.nix
index 8be88e42db9..3f554dbac1c 100644
--- a/pkgs/desktops/gnome-3/3.16/default.nix
+++ b/pkgs/desktops/gnome-3/3.16/default.nix
@@ -30,16 +30,21 @@ let
     gnome-system-log gnome-system-monitor
     gnome_terminal gnome-user-docs bijiben evolution file-roller gedit
     gnome-clocks gnome-music gnome-tweak-tool gnome-photos
-    nautilus-sendto dconf-editor vinagre
+    nautilus-sendto dconf-editor vinagre gnome-weather gnome-logs
+    gnome-maps gnome-characters
   ];
 
   gamesPackages = with gnome3; [ swell-foop lightsoff iagno
-    tali quadrapassel
+    tali quadrapassel gnome-sudoku aisleriot five-or-more
+    four-in-a-row gnome-chess gnome-klotski gnome-mahjongg
+    gnome-mines gnome-nibbles gnome-robots gnome-tetravex
+    hitori gnome-taquin
   ];
 
   inherit (pkgs) glib gtk2 webkitgtk24x gtk3 gtkmm3 libcanberra;
   inherit (pkgs.gnome2) ORBit2;
   libsoup = pkgs.libsoup.override { gnomeSupport = true; };
+  libchamplain = pkgs.libchamplain.override { libsoup = libsoup; };
   orbit = ORBit2;
   gnome3 = self // { recurseForDerivations = false; };
   clutter = pkgs.clutter_1_22;
@@ -264,18 +269,28 @@ let
     spice_gtk = pkgs.spice_gtk.override { enableGTK3 = true; };
   };
 
+  gnome-characters = callPackage ./apps/gnome-characters { };
+
   gnome-clocks = callPackage ./apps/gnome-clocks { };
 
   gnome-documents = callPackage ./apps/gnome-documents { };
 
+  gnome-logs = callPackage ./apps/gnome-logs { };
+
+  gnome-maps = callPackage ./apps/gnome-maps { };
+
   gnome-music = callPackage ./apps/gnome-music { };
 
   gnome-photos = callPackage ./apps/gnome-photos {
     gegl = gegl_0_3;
   };
 
+  gnome-weather = callPackage ./apps/gnome-weather { };
+
   nautilus-sendto = callPackage ./apps/nautilus-sendto { };
 
+  polari = callPackage ./apps/polari { };
+
   # scrollkeeper replacement
   rarian = callPackage ./desktop/rarian { };
 
@@ -289,8 +304,36 @@ let
 
   gdl = callPackage ./devtools/gdl { };
 
+  gnome-devel-docs = callPackage ./devtools/gnome-devel-docs { };
+
 #### Games
 
+  aisleriot = callPackage ./games/aisleriot { };
+
+  five-or-more = callPackage ./games/five-or-more { };
+
+  four-in-a-row = callPackage ./games/four-in-a-row { };
+
+  gnome-chess = callPackage ./games/gnome-chess { };
+
+  gnome-klotski = callPackage ./games/gnome-klotski { };
+
+  gnome-mahjongg = callPackage ./games/gnome-mahjongg { };
+
+  gnome-mines = callPackage ./games/gnome-mines { };
+
+  gnome-nibbles = callPackage ./games/gnome-nibbles { };
+
+  gnome-robots = callPackage ./games/gnome-robots { };
+
+  gnome-sudoku = callPackage ./games/gnome-sudoku { };
+
+  gnome-taquin = callPackage ./games/gnome-taquin { };
+
+  gnome-tetravex = callPackage ./games/gnome-tetravex { };
+
+  hitori = callPackage ./games/hitori { };
+
   iagno = callPackage ./games/iagno { };
 
   lightsoff = callPackage ./games/lightsoff { };
diff --git a/pkgs/desktops/gnome-3/3.16/devtools/gnome-devel-docs/default.nix b/pkgs/desktops/gnome-3/3.16/devtools/gnome-devel-docs/default.nix
new file mode 100644
index 00000000000..0daa0405b69
--- /dev/null
+++ b/pkgs/desktops/gnome-3/3.16/devtools/gnome-devel-docs/default.nix
@@ -0,0 +1,20 @@
+{ stdenv, fetchurl, gnome3, intltool, itstool, libxml2 }:
+
+stdenv.mkDerivation rec {
+  name = "gnome-devel-docs-${gnome3.version}.2";
+
+  src = fetchurl {
+    url = "mirror://gnome/sources/gnome-devel-docs/${gnome3.version}/${name}.tar.xz";
+    sha256 = "1jkh40ya5mqss57p27b1hv77x5qis4zc377pyvzqa5wkzrvd0nls";
+  };
+
+  buildInputs = [ intltool itstool libxml2 ];
+
+  meta = with stdenv.lib; {
+    homepage = https://github.com/GNOME/gnome-devel-docs;
+    description = "Developer documentation for GNOME";
+    maintainers = gnome3.maintainers;
+    license = licenses.fdl12;
+    platforms = platforms.linux;
+  };
+}
diff --git a/pkgs/desktops/gnome-3/3.16/games/aisleriot/default.nix b/pkgs/desktops/gnome-3/3.16/games/aisleriot/default.nix
new file mode 100644
index 00000000000..94f4e5e4d04
--- /dev/null
+++ b/pkgs/desktops/gnome-3/3.16/games/aisleriot/default.nix
@@ -0,0 +1,25 @@
+{ stdenv, fetchurl, pkgconfig, gnome3, intltool, itstool, gtk3
+, wrapGAppsHook, gconf, librsvg, libxml2, desktop_file_utils
+, guile, libcanberra_gtk3 }:
+
+stdenv.mkDerivation rec {
+  name = "aisleriot-${gnome3.version}.2";
+
+  src = fetchurl {
+    url = "mirror://gnome/sources/aisleriot/${gnome3.version}/${name}.tar.xz";
+    sha256 = "0rncdg21ys7ik971yw75qbawq89mikbh4dq5mg2msmrl6xsgv0zl";
+  };
+
+  configureFlags = [ "--with-card-theme-formats=svg" ];
+
+  buildInputs = [ pkgconfig intltool itstool gtk3 wrapGAppsHook gconf
+                  librsvg libxml2 desktop_file_utils guile libcanberra_gtk3 ];
+
+  meta = with stdenv.lib; {
+    homepage = https://wiki.gnome.org/Apps/Aisleriot;
+    description = "A collection of patience games written in guile scheme";
+    maintainers = gnome3.maintainers;
+    license = licenses.gpl3Plus;
+    platforms = platforms.linux;
+  };
+}
diff --git a/pkgs/desktops/gnome-3/3.16/games/five-or-more/default.nix b/pkgs/desktops/gnome-3/3.16/games/five-or-more/default.nix
new file mode 100644
index 00000000000..26af4d7286a
--- /dev/null
+++ b/pkgs/desktops/gnome-3/3.16/games/five-or-more/default.nix
@@ -0,0 +1,24 @@
+{ stdenv, fetchurl, pkgconfig, gnome3, gtk3, wrapGAppsHook
+, librsvg, intltool, itstool, libxml2, hicolor_icon_theme }:
+
+stdenv.mkDerivation rec {
+  name = "five-or-more-${gnome3.version}.1";
+
+  src = fetchurl {
+    url = "mirror://gnome/sources/five-or-more/${gnome3.version}/${name}.tar.xz";
+    sha256 = "018723w2q0fijvxs1kafrxg39f6ank6x51nfbf3mhn9q7jz9k2g3";
+  };
+
+  buildInputs = [
+    pkgconfig gtk3 wrapGAppsHook librsvg intltool itstool libxml2
+    hicolor_icon_theme
+  ];
+
+  meta = with stdenv.lib; {
+    homepage = https://wiki.gnome.org/Apps/Five_or_more;
+    description = "Remove colored balls from the board by forming lines";
+    maintainers = gnome3.maintainers;
+    license = licenses.gpl2;
+    platforms = platforms.linux;
+  };
+}
diff --git a/pkgs/desktops/gnome-3/3.16/games/four-in-a-row/default.nix b/pkgs/desktops/gnome-3/3.16/games/four-in-a-row/default.nix
new file mode 100644
index 00000000000..bf15f9f2bbb
--- /dev/null
+++ b/pkgs/desktops/gnome-3/3.16/games/four-in-a-row/default.nix
@@ -0,0 +1,25 @@
+{ stdenv, fetchurl, pkgconfig, gnome3, gtk3, wrapGAppsHook
+, intltool, itstool, libcanberra_gtk3, librsvg, libxml2
+, hicolor_icon_theme }:
+
+stdenv.mkDerivation rec {
+  name = "four-in-a-row-${gnome3.version}.2";
+
+  src = fetchurl {
+    url = "mirror://gnome/sources/four-in-a-row/${gnome3.version}/${name}.tar.xz";
+    sha256 = "1bm5chsvpw0jg1xh9g2n1w5i0fvxs50aqkgmrla9cpawsvzfshmz";
+  };
+
+  buildInputs = [
+    pkgconfig gtk3 wrapGAppsHook intltool itstool libcanberra_gtk3 librsvg
+    libxml2 hicolor_icon_theme
+  ];
+
+  meta = with stdenv.lib; {
+    homepage = https://wiki.gnome.org/Apps/Four-in-a-row;
+    description = "Make lines of the same color to win";
+    maintainers = gnome3.maintainers;
+    license = licenses.gpl2;
+    platforms = platforms.linux;
+  };
+}
diff --git a/pkgs/desktops/gnome-3/3.16/games/gnome-chess/default.nix b/pkgs/desktops/gnome-3/3.16/games/gnome-chess/default.nix
new file mode 100644
index 00000000000..7161eb5cdaf
--- /dev/null
+++ b/pkgs/desktops/gnome-3/3.16/games/gnome-chess/default.nix
@@ -0,0 +1,24 @@
+{ stdenv, fetchurl, pkgconfig, gnome3, gtk3, wrapGAppsHook
+, intltool, itstool, librsvg, libxml2, hicolor_icon_theme }:
+
+stdenv.mkDerivation rec {
+  name = "gnome-chess-${gnome3.version}.2";
+
+  src = fetchurl {
+    url = "mirror://gnome/sources/gnome-chess/${gnome3.version}/${name}.tar.xz";
+    sha256 = "0j1vvf1myki3bafsqv52q59qk1nhf1636nrb15fpfvm88p3b8wwg";
+  };
+
+  buildInputs = [
+    pkgconfig gtk3 wrapGAppsHook intltool itstool librsvg libxml2
+    hicolor_icon_theme
+  ];
+
+  meta = with stdenv.lib; {
+    homepage = https://wiki.gnome.org/Apps/Chess;
+    description = "Play the classic two-player boardgame of chess";
+    maintainers = gnome3.maintainers;
+    license = licenses.gpl2;
+    platforms = platforms.linux;
+  };
+}
diff --git a/pkgs/desktops/gnome-3/3.16/games/gnome-klotski/default.nix b/pkgs/desktops/gnome-3/3.16/games/gnome-klotski/default.nix
new file mode 100644
index 00000000000..6afcc63e97f
--- /dev/null
+++ b/pkgs/desktops/gnome-3/3.16/games/gnome-klotski/default.nix
@@ -0,0 +1,24 @@
+{ stdenv, fetchurl, pkgconfig, gnome3, gtk3, wrapGAppsHook
+, librsvg, libxml2, intltool, itstool, hicolor_icon_theme }:
+
+stdenv.mkDerivation rec {
+  name = "gnome-klotski-${gnome3.version}.1";
+
+  src = fetchurl {
+    url = "mirror://gnome/sources/gnome-klotski/${gnome3.version}/${name}.tar.xz";
+    sha256 = "0a64935c7pp51jhaf29q9zlx3lamj7zrhyff7clvv0w8v1w6gpax";
+  };
+
+  buildInputs = [
+    pkgconfig gtk3 wrapGAppsHook intltool itstool librsvg libxml2
+    hicolor_icon_theme
+  ];
+
+  meta = with stdenv.lib; {
+    homepage = https://wiki.gnome.org/Apps/Klotski;
+    description = "Slide blocks to solve the puzzle";
+    maintainers = gnome3.maintainers;
+    license = licenses.gpl2;
+    platforms = platforms.linux;
+  };
+}
diff --git a/pkgs/desktops/gnome-3/3.16/games/gnome-mahjongg/default.nix b/pkgs/desktops/gnome-3/3.16/games/gnome-mahjongg/default.nix
new file mode 100644
index 00000000000..5b5bdae87c0
--- /dev/null
+++ b/pkgs/desktops/gnome-3/3.16/games/gnome-mahjongg/default.nix
@@ -0,0 +1,24 @@
+{ stdenv, fetchurl, pkgconfig, gnome3, gtk3, wrapGAppsHook
+, librsvg, intltool, itstool, libxml2, hicolor_icon_theme }:
+
+stdenv.mkDerivation rec {
+  name = "gnome-mahjongg-${gnome3.version}.1";
+
+  src = fetchurl {
+    url = "mirror://gnome/sources/gnome-mahjongg/${gnome3.version}/${name}.tar.xz";
+    sha256 = "1jbd3gbmxqf36as9xsiarad575l4rpcfv6w1pn192r02aj3hgipj";
+  };
+
+  buildInputs = [
+    pkgconfig gtk3 wrapGAppsHook librsvg intltool itstool libxml2
+    hicolor_icon_theme
+  ];
+
+  meta = with stdenv.lib; {
+    homepage = https://wiki.gnome.org/Apps/Mahjongg;
+    description = "Disassemble a pile of tiles by removing matching pairs";
+    maintainers = gnome3.maintainers;
+    license = licenses.gpl2;
+    platforms = platforms.linux;
+  };
+}
diff --git a/pkgs/desktops/gnome-3/3.16/games/gnome-mines/default.nix b/pkgs/desktops/gnome-3/3.16/games/gnome-mines/default.nix
new file mode 100644
index 00000000000..e9af6c0fe4d
--- /dev/null
+++ b/pkgs/desktops/gnome-3/3.16/games/gnome-mines/default.nix
@@ -0,0 +1,24 @@
+{ stdenv, fetchurl, pkgconfig, gnome3, gtk3, wrapGAppsHook
+, librsvg, intltool, itstool, libxml2, hicolor_icon_theme }:
+
+stdenv.mkDerivation rec {
+  name = "gnome-mines-${gnome3.version}.1";
+
+  src = fetchurl {
+    url = "mirror://gnome/sources/gnome-mines/${gnome3.version}/${name}.tar.xz";
+    sha256 = "0f0496nhirvpw4zk8bcl24rb2v20cm3gw8d5ybmch42mscmjrb0p";
+  };
+
+  buildInputs = [
+    pkgconfig gtk3 wrapGAppsHook librsvg intltool itstool libxml2
+    hicolor_icon_theme
+  ];
+
+  meta = with stdenv.lib; {
+    homepage = https://wiki.gnome.org/Apps/Mines;
+    description = "Clear hidden mines from a minefield";
+    maintainers = gnome3.maintainers;
+    license = licenses.gpl2;
+    platforms = platforms.linux;
+  };
+}
diff --git a/pkgs/desktops/gnome-3/3.16/games/gnome-nibbles/default.nix b/pkgs/desktops/gnome-3/3.16/games/gnome-nibbles/default.nix
new file mode 100644
index 00000000000..8fde848fe1f
--- /dev/null
+++ b/pkgs/desktops/gnome-3/3.16/games/gnome-nibbles/default.nix
@@ -0,0 +1,25 @@
+{ stdenv, fetchurl, pkgconfig, gnome3, gtk3, wrapGAppsHook
+, librsvg, libcanberra_gtk3, clutter_gtk, intltool, itstool
+, libxml2, hicolor_icon_theme }:
+
+stdenv.mkDerivation rec {
+  name = "gnome-nibbles-${gnome3.version}.1";
+
+  src = fetchurl {
+    url = "mirror://gnome/sources/gnome-nibbles/${gnome3.version}/${name}.tar.xz";
+    sha256 = "1384hc7vx3i1jkmc1pw1cjh61jymq9441ci1k06vjz62r9as1nmx";
+  };
+
+  buildInputs = [
+    pkgconfig gtk3 wrapGAppsHook intltool itstool libxml2
+    librsvg libcanberra_gtk3 hicolor_icon_theme clutter_gtk
+  ];
+
+  meta = with stdenv.lib; {
+    homepage = https://wiki.gnome.org/Apps/Nibbles;
+    description = "Guide a worm around a maze";
+    maintainers = gnome3.maintainers;
+    license = licenses.gpl2;
+    platforms = platforms.linux;
+  };
+}
diff --git a/pkgs/desktops/gnome-3/3.16/games/gnome-robots/default.nix b/pkgs/desktops/gnome-3/3.16/games/gnome-robots/default.nix
new file mode 100644
index 00000000000..a4f94518425
--- /dev/null
+++ b/pkgs/desktops/gnome-3/3.16/games/gnome-robots/default.nix
@@ -0,0 +1,25 @@
+{ stdenv, fetchurl, pkgconfig, gnome3, gtk3, wrapGAppsHook
+, librsvg, libcanberra_gtk3, intltool, itstool, libxml2
+, hicolor_icon_theme }:
+
+stdenv.mkDerivation rec {
+  name = "gnome-robots-${gnome3.version}.1";
+
+  src = fetchurl {
+    url = "mirror://gnome/sources/gnome-robots/${gnome3.version}/${name}.tar.xz";
+    sha256 = "0dhzl1rhn4ysp3s3j0lxsiw64acz0w1n1bljrfln9s07x8nj17nx";
+  };
+
+  buildInputs = [
+    pkgconfig gtk3 wrapGAppsHook intltool itstool librsvg libcanberra_gtk3
+    libxml2 hicolor_icon_theme
+  ];
+
+  meta = with stdenv.lib; {
+    homepage = https://wiki.gnome.org/Apps/Robots;
+    description = "Avoid the robots and make them crash into each other";
+    maintainers = gnome3.maintainers;
+    license = licenses.gpl2;
+    platforms = platforms.linux;
+  };
+}
diff --git a/pkgs/desktops/gnome-3/3.16/games/gnome-sudoku/default.nix b/pkgs/desktops/gnome-3/3.16/games/gnome-sudoku/default.nix
new file mode 100644
index 00000000000..eda3cf1f84e
--- /dev/null
+++ b/pkgs/desktops/gnome-3/3.16/games/gnome-sudoku/default.nix
@@ -0,0 +1,22 @@
+{ stdenv, fetchurl, pkgconfig, intltool, gtk3, gnome3, wrapGAppsHook
+, json_glib, qqwing, itstool, libxml2 }:
+
+stdenv.mkDerivation rec {
+  name = "gnome-sudoku-${gnome3.version}.0";
+
+  src = fetchurl {
+    url = "mirror://gnome/sources/gnome-sudoku/${gnome3.version}/${name}.tar.xz";
+    sha256 = "1b9xwldzjjpkwb2na9cbs8z4gv8dlj9dm574gybdz466190lrsxv";
+  };
+
+  buildInputs = [ pkgconfig intltool wrapGAppsHook gtk3 gnome3.libgee
+                  json_glib qqwing itstool libxml2 ];
+
+  meta = with stdenv.lib; {
+    homepage = https://wiki.gnome.org/Apps/Sudoku;
+    description = "Test your logic skills in this number grid puzzle";
+    maintainers = gnome3.maintainers;
+    license = licenses.gpl2;
+    platforms = platforms.linux;
+  };
+}
diff --git a/pkgs/desktops/gnome-3/3.16/games/gnome-taquin/default.nix b/pkgs/desktops/gnome-3/3.16/games/gnome-taquin/default.nix
new file mode 100644
index 00000000000..31b74cd285e
--- /dev/null
+++ b/pkgs/desktops/gnome-3/3.16/games/gnome-taquin/default.nix
@@ -0,0 +1,25 @@
+{ stdenv, fetchurl, pkgconfig, gnome3, gtk3, wrapGAppsHook
+, librsvg, libcanberra_gtk3, intltool, itstool, libxml2
+, hicolor_icon_theme }:
+
+stdenv.mkDerivation rec {
+  name = "gnome-taquin-${gnome3.version}.1";
+
+  src = fetchurl {
+    url = "mirror://gnome/sources/gnome-taquin/${gnome3.version}/${name}.tar.xz";
+    sha256 = "024a1ing1iclmyhi5vlps6xna84vgy7s098h9yvzq43fsahmx8pi";
+  };
+
+  buildInputs = [
+    pkgconfig gtk3 wrapGAppsHook librsvg libcanberra_gtk3
+    intltool itstool libxml2 hicolor_icon_theme
+  ];
+
+  meta = with stdenv.lib; {
+    homepage = https://wiki.gnome.org/Apps/Taquin;
+    description = "Move tiles so that they reach their places";
+    maintainers = gnome3.maintainers;
+    license = licenses.gpl3;
+    platforms = platforms.linux;
+  };
+}
diff --git a/pkgs/desktops/gnome-3/3.16/games/gnome-tetravex/default.nix b/pkgs/desktops/gnome-3/3.16/games/gnome-tetravex/default.nix
new file mode 100644
index 00000000000..37654f8fa33
--- /dev/null
+++ b/pkgs/desktops/gnome-3/3.16/games/gnome-tetravex/default.nix
@@ -0,0 +1,23 @@
+{ stdenv, fetchurl, pkgconfig, gnome3, gtk3, wrapGAppsHook
+, libxml2, intltool, itstool, hicolor_icon_theme }:
+
+stdenv.mkDerivation rec {
+  name = "gnome-tetravex-${gnome3.version}.0";
+
+  src = fetchurl {
+    url = "mirror://gnome/sources/gnome-tetravex/${gnome3.version}/${name}.tar.xz";
+    sha256 = "07cmcmrd5fj8vm682894gra2vj8jwx01n3ggjinl93yv4gwpplz9";
+  };
+
+  buildInputs = [
+    pkgconfig gtk3 wrapGAppsHook intltool itstool libxml2 hicolor_icon_theme
+  ];
+
+  meta = with stdenv.lib; {
+    homepage = https://wiki.gnome.org/Apps/Tetravex;
+    description = "Complete the puzzle by matching numbered tiles";
+    maintainers = gnome3.maintainers;
+    license = licenses.gpl2;
+    platforms = platforms.linux;
+  };
+}
diff --git a/pkgs/desktops/gnome-3/3.16/games/hitori/default.nix b/pkgs/desktops/gnome-3/3.16/games/hitori/default.nix
new file mode 100644
index 00000000000..d409ac1b3c3
--- /dev/null
+++ b/pkgs/desktops/gnome-3/3.16/games/hitori/default.nix
@@ -0,0 +1,24 @@
+{ stdenv, fetchurl, pkgconfig, gnome3, gtk3, wrapGAppsHook
+, libxml2, intltool, itstool, hicolor_icon_theme }:
+
+stdenv.mkDerivation rec {
+  name = "hitori-${gnome3.version}.1";
+
+  src = fetchurl {
+    url = "mirror://gnome/sources/hitori/${gnome3.version}/${name}.tar.xz";
+    sha256 = "07pm3xl05jgb8x151k1j2ap57dmfvk2nkz9dmqnn5iywfigsysd1";
+  };
+
+  buildInputs = [
+    pkgconfig gtk3 wrapGAppsHook intltool itstool libxml2
+    hicolor_icon_theme
+  ];
+
+  meta = with stdenv.lib; {
+    homepage = https://wiki.gnome.org/Apps/Hitori;
+    description = "GTK+ application to generate and let you play games of Hitori";
+    maintainers = gnome3.maintainers;
+    license = licenses.gpl2;
+    platforms = platforms.linux;
+  };
+}
diff --git a/pkgs/development/compilers/ghc/nokinds.nix b/pkgs/development/compilers/ghc/nokinds.nix
index 98e18706a16..ab270c16126 100644
--- a/pkgs/development/compilers/ghc/nokinds.nix
+++ b/pkgs/development/compilers/ghc/nokinds.nix
@@ -28,7 +28,7 @@ in
 
 stdenv.mkDerivation rec {
   version = "7.11.20150718";
-  name = "ghc-nokinds-${version}";
+  name = "ghc-${version}"; # We cannot add a "nokinds" tag here; see git comment for details.
   rev = "4cb79c85a4976c509a65a8638899391a60cd0962";
 
   src = fetchgit {
@@ -39,6 +39,8 @@ stdenv.mkDerivation rec {
 
   postUnpack = ''
     pushd ghc-${builtins.substring 0 7 rev}
+    echo ${version} >VERSION
+    echo ${rev} >GIT_COMMIT_ID
     patchShebangs .
     ./boot
     popd
diff --git a/pkgs/development/compilers/nim/default.nix b/pkgs/development/compilers/nim/default.nix
index 3da27d72814..6444b7feeb8 100644
--- a/pkgs/development/compilers/nim/default.nix
+++ b/pkgs/development/compilers/nim/default.nix
@@ -1,13 +1,13 @@
 { stdenv, fetchurl, unzip }:
 
 stdenv.mkDerivation rec {
-  name = "nim-0.11.0";
+  name = "nim-0.11.2";
 
   buildInputs = [ unzip ];
 
   src = fetchurl {
     url = "http://nim-lang.org/download/${name}.zip";
-    sha256 = "0l19rrp6nhwhr2z33np4x32c35iba0hhv6w3qwj1sk8bjfpvz4cw";
+    sha256 = "0ay8gkd8fki3d8kbnw2px7rjdlr54kyqh5n1rjhq4vjmqs2wg5s4";
   };
 
   buildPhase   = "sh build.sh";
diff --git a/pkgs/development/compilers/rustc/head.nix b/pkgs/development/compilers/rustc/head.nix
index 9d415eed0b4..d65258a3a08 100644
--- a/pkgs/development/compilers/rustc/head.nix
+++ b/pkgs/development/compilers/rustc/head.nix
@@ -1,16 +1,16 @@
 { stdenv, callPackage }:
 callPackage ./generic.nix {
-  shortVersion = "2015-07-28";
+  shortVersion = "2015-08-09";
   isRelease = false;
-  # src rev for 2015-07-28's nightly channel
-  srcRev = "8b835572b";
-  srcSha = "1qrw0vszr1zipsbp7gcm8kik73d2bfxwv6mniv81ygn9i7v76wfz";
-  snapshotHashLinux686 = "93f6216a35d3bed3cedf244c9aff4cd716336bd9";
-  snapshotHashLinux64 = "d8f4967fc71a153c925faecf95a7feadf7e463a4";
-  snapshotHashDarwin686 = "29852c4d4b5a851f16d627856a279cae5bf9bd01";
-  snapshotHashDarwin64 = "1a20259899321062a0325edb1d22990f05d18708";
-  snapshotDate = "2015-07-17";
-  snapshotRev = "d4432b3";
+  # src rev for 2015-08-09's nightly channel
+  srcRev = "a5d33d891";
+  srcSha = "1iivzk9ggjh7y89rbw275apw4rfmzh4jk50kf0milljhvf72660n";
+  snapshotHashLinux686 = "3459275cdf3896f678e225843fa56f0d9fdbabe8";
+  snapshotHashLinux64 = "e451e3bd6e5fcef71e41ae6f3da9fb1cf0e13a0c";
+  snapshotHashDarwin686 = "428944a7984c0988e77909d82ca2ef77d96a1fbd";
+  snapshotHashDarwin64 = "b0515bb7d2892b9a58282fc865fee11a885406d6";
+  snapshotDate = "2015-07-26";
+  snapshotRev = "a5c12f4";
   patches = [
     ./patches/head.patch
   ] ++ stdenv.lib.optional stdenv.needsPax ./patches/grsec.patch;
diff --git a/pkgs/development/haskell-modules/configuration-common.nix b/pkgs/development/haskell-modules/configuration-common.nix
index ed23b190ec6..5957ce812ac 100644
--- a/pkgs/development/haskell-modules/configuration-common.nix
+++ b/pkgs/development/haskell-modules/configuration-common.nix
@@ -259,14 +259,8 @@ self: super: {
   gtk = addBuildDepends super.gtk [pkgs.pkgconfig pkgs.gtk];
   gtksourceview3 = super.gtksourceview3.override { inherit (pkgs.gnome3) gtksourceview; };
 
-  # webkit does not recognize its system library build input any more.
-  webkit = markBroken super.webkit; # http://hydra.cryp.to/build/1041942/nixlog/1/raw
-  ghcjs-dom-hello = dontDistribute super.ghcjs-dom-hello;       # depends on broken webkit
-  ghcjs-dom = dontDistribute super.ghcjs-dom;                   # depends on broken webkit
-  jsaddle-hello = dontDistribute super.jsaddle-hello;           # depends on broken webkit
-  reflex-dom = dontDistribute super.reflex-dom;                 # depends on broken webkit
-
   # Need WebkitGTK, not just webkit.
+  webkit = super.webkit.override { webkit = pkgs.webkitgtk2; };
   webkitgtk3 = super.webkitgtk3.override { webkit = pkgs.webkitgtk24x; };
   webkitgtk3-javascriptcore = super.webkitgtk3-javascriptcore.override { webkit = pkgs.webkitgtk24x; };
   websnap = super.websnap.override { webkit = pkgs.webkitgtk24x; };
@@ -793,6 +787,7 @@ self: super: {
   singleton-nats = dontDistribute super.singleton-nats;
   singletons = markBroken super.singletons;
   units-attoparsec = dontDistribute super.units-attoparsec;
+  ihaskell-widgets = dontDistribute super.ihaskell-widgets;
 
   # https://github.com/anton-k/temporal-music-notation/issues/1
   temporal-music-notation = markBroken super.temporal-music-notation;
@@ -881,23 +876,6 @@ self: super: {
   # https://github.com/hspec/mockery/issues/6
   mockery = overrideCabal super.mockery (drv: { preCheck = "export TRAVIS=true"; });
 
-  # https://github.com/diagrams/diagrams-lib/issues/258
-  # https://github.com/diagrams/diagrams-lib/issues/259
-  diagrams-lib = markBroken super.diagrams-lib;
-  diagrams-cairo = dontDistribute super.diagrams-cairo;
-  diagrams-gtk = dontDistribute super.diagrams-gtk;
-  diagrams-html5 = dontDistribute super.diagrams-html5;
-  diagrams-pandoc = dontDistribute super.diagrams-pandoc;
-  diagrams-postscript = dontDistribute super.diagrams-postscript;
-  diagrams-rasterific = dontDistribute super.diagrams-rasterific;
-  diagrams-rubiks-cube = dontDistribute super.diagrams-rubiks-cube;
-  diagrams-svg = dontDistribute super.diagrams-svg;
-  halma = dontDistribute super.halma;
-  midi-music-box = dontDistribute super.midi-music-box;
-  potrace-diagrams = dontDistribute super.potrace-diagrams;
-  SVGFonts = dontDistribute super.SVGFonts;
-  yesod-media-simple = dontDistribute super.yesod-media-simple;
-
   # https://github.com/alphaHeavy/lzma-conduit/issues/5
   lzma-conduit = dontCheck super.lzma-conduit;
 
@@ -926,4 +904,7 @@ self: super: {
   # https://github.com/liyang/thyme/issues/36
   thyme = dontCheck super.thyme;
 
+  # https://github.com/aka-bash0r/multi-cabal/issues/4
+  multi-cabal = markBroken super.multi-cabal;
+
 }
diff --git a/pkgs/development/haskell-modules/hackage-packages.nix b/pkgs/development/haskell-modules/hackage-packages.nix
index 27345770034..11f0fd12969 100644
--- a/pkgs/development/haskell-modules/hackage-packages.nix
+++ b/pkgs/development/haskell-modules/hackage-packages.nix
@@ -9,7 +9,7 @@ self: {
      mkDerivation {
        pname = "3d-graphics-examples";
        version = "0.0.0.1";
-       sha256 = "13b7n9mdx7f6a2ghikc7xvscbj8wp0dxcbm5alinnic433sandy5";
+       sha256 = "c537abf41884456b2355a52ed61bb81cc9c5f4ee87cd089f50c69dde6ab2678d";
        isLibrary = false;
        isExecutable = true;
        executableHaskellDepends = [ base GLUT OpenGL random ];
@@ -24,7 +24,7 @@ self: {
      mkDerivation {
        pname = "3dmodels";
        version = "0.3.0";
-       sha256 = "00pp8g1b59950i5ik9ycimxd284vsv1hnfgxgg1mjvxwaj2pbyhr";
+       sha256 = "19fa758554bc6f59c37bfd390bc3d69b20d17a8dcca7194b0425a5b2c243f702";
        libraryHaskellDepends = [
          attoparsec base bytestring linear packer
        ];
@@ -40,7 +40,7 @@ self: {
      mkDerivation {
        pname = "4Blocks";
        version = "0.2";
-       sha256 = "1lya7320jf2cvd69prvjfwdlci2j17m21qcqaqxaczlrv4aykg6w";
+       sha256 = "dcbce915d9997ea63a5698e120ea095244461b7772e79b4cdb4c3809c438cad3";
        isLibrary = false;
        isExecutable = true;
        executableHaskellDepends = [
@@ -58,7 +58,7 @@ self: {
      mkDerivation {
        pname = "AAI";
        version = "0.2.0.1";
-       sha256 = "0vdq0hscpbl5a9bpf8fiykmyg2c3yvivb0mzcdy99ha0j1p4rwfh";
+       sha256 = "d0f14c6e9040c1947c63bf82b5e3f68389e7ebf4d12177575285aecb3404b86d";
        libraryHaskellDepends = [ base ];
        description = "Abstract Application Interface";
        license = stdenv.lib.licenses.mit;
@@ -71,7 +71,7 @@ self: {
      mkDerivation {
        pname = "ABList";
        version = "0.0.3";
-       sha256 = "06hj35k3lbcxh9yn70sa4bw0jafxmxyi2237d6r48dznk4a5fvq1";
+       sha256 = "016f571499f63744b2696708117dafdd2909f8224a83637d829d2d3a6619121a";
        libraryHaskellDepends = [ base linear newtype ];
        testHaskellDepends = [
          base HUnit QuickCheck test-framework test-framework-hunit
@@ -86,7 +86,7 @@ self: {
      mkDerivation {
        pname = "AC-Angle";
        version = "1.0";
-       sha256 = "0ra97a4im3w2cq3mf17j8skn6bajs7rw7d0mmvcwgb9jd04b0idm";
+       sha256 = "b545b0086832adc7d9ae15b4c3f3d1522d63a746f204570766828f1a893a4965";
        libraryHaskellDepends = [ base ];
        description = "Angles in degrees and radians";
        license = stdenv.lib.licenses.bsd3;
@@ -97,7 +97,7 @@ self: {
      mkDerivation {
        pname = "AC-Boolean";
        version = "1.1.0";
-       sha256 = "0id19wgp2jg2pf1gdhfzkyknjj19jii3pz0lva29x3lcck38rw2b";
+       sha256 = "4bf08cc6648c8e9e84da14fc3b6294294869a79fdfc1f682bbe249711f4fa145";
        libraryHaskellDepends = [ base ];
        description = "Handle Boolean values generatically";
        license = stdenv.lib.licenses.bsd3;
@@ -108,7 +108,7 @@ self: {
      mkDerivation {
        pname = "AC-BuildPlatform";
        version = "1.1.0";
-       sha256 = "0vlhakc6mc4zzyvb54rgmskkj8hp43zy35giimk0g7i5068r2czh";
+       sha256 = "f033919101259e07668df195e1ff20172239a7ae2f93b2b6ff9fb06ad854906e";
        libraryHaskellDepends = [ base ];
        description = "Detect which OS you're running on";
        license = stdenv.lib.licenses.bsd3;
@@ -120,7 +120,7 @@ self: {
      mkDerivation {
        pname = "AC-Colour";
        version = "1.1.6";
-       sha256 = "02v3b1pfhwnf3cl8kbxfkk0a7hdp0gqq5v4w9ka32zl1p007rz19";
+       sha256 = "29fc7c00b8817e31d44c9cec82f103b7c1a3c09caeaf89281bce72e86e58630b";
        libraryHaskellDepends = [ base ];
        description = "Efficient RGB colour types";
        license = stdenv.lib.licenses.bsd3;
@@ -131,7 +131,7 @@ self: {
      mkDerivation {
        pname = "AC-EasyRaster-GTK";
        version = "1.1.3";
-       sha256 = "082il76032biyan170p4qp13154nmkzil4v2wv7fmjn9z7v8w49b";
+       sha256 = "2b118ef6f9c9caeacee662131affac969430c2c5e48213acf2718901cca15120";
        libraryHaskellDepends = [ array base gtk ];
        description = "GTK+ pixel plotting";
        license = stdenv.lib.licenses.bsd3;
@@ -143,7 +143,7 @@ self: {
      mkDerivation {
        pname = "AC-HalfInteger";
        version = "1.2.1";
-       sha256 = "0wwnb7a6dmzgh122qg322mi3vpyk93xw52cql6dx18sqdbxyxdbb";
+       sha256 = "6bb5eefb6a58a3d09ba19889c2fb48d3df3d6215623c2c4480efd766d4599673";
        libraryHaskellDepends = [ base ];
        description = "Efficient half-integer type";
        license = stdenv.lib.licenses.bsd3;
@@ -155,7 +155,7 @@ self: {
      mkDerivation {
        pname = "AC-MiniTest";
        version = "1.1.1";
-       sha256 = "0ish59q50npljgmfrcffcyx6scf99xdncmy1kpwy1i5622r1kcps";
+       sha256 = "fab219b210a6c4e0f99dc157665b4fc9316dba67ceb1ecea93f45a50702a5047";
        libraryHaskellDepends = [ base transformers ];
        description = "A simple test framework";
        license = stdenv.lib.licenses.bsd3;
@@ -167,7 +167,7 @@ self: {
      mkDerivation {
        pname = "AC-PPM";
        version = "1.1.1";
-       sha256 = "0y2wzwfnlx50rzkdigmjy3dg5f91pmkf4gmnzjhs3r916d296gkq";
+       sha256 = "783e93443321e5a1a1fcb63ee266bd21b9f2daf0b2bed8e6cfa0746a1dff5c78";
        libraryHaskellDepends = [ base bytestring ];
        description = "Trivial package for writing PPM images";
        license = stdenv.lib.licenses.bsd3;
@@ -178,7 +178,7 @@ self: {
      mkDerivation {
        pname = "AC-Random";
        version = "0.1";
-       sha256 = "1c00pcz0c4l2sdaj61zcmw68ckmqb7xlfykv489xms7ak4xl8nc1";
+       sha256 = "8159443b99eae8da13227b7a47fb59b84e860cafec072355d38212063ebb00b0";
        libraryHaskellDepends = [ base ];
        description = "A pure Haskell PRNG";
        license = stdenv.lib.licenses.bsd3;
@@ -189,7 +189,7 @@ self: {
      mkDerivation {
        pname = "AC-Terminal";
        version = "1.0";
-       sha256 = "0d0vdqf7i49d2hsdm7x9ad88l7kfc1wvkzppzhs8k9xf4gbrvl43";
+       sha256 = "83d09dd723aea78934fcf7feb979606e1e8a5053a99fda34142d91781c6e1b34";
        libraryHaskellDepends = [ ansi-terminal base ];
        description = "Trivial wrapper over ansi-terminal";
        license = stdenv.lib.licenses.bsd3;
@@ -201,7 +201,7 @@ self: {
      mkDerivation {
        pname = "AC-VanillaArray";
        version = "1.1.2";
-       sha256 = "044kiwc5g2irky0k3fg9l2qqnvcnh9vdx0yz8m1awnkab6mk0i3v";
+       sha256 = "7b4430ab596a5aae4245df83de7682966d8bb1a0e9b931819f398a57188f9310";
        libraryHaskellDepends = [ base ghc-prim ];
        jailbreak = true;
        description = "Immutable arrays with plain integer indicies";
@@ -214,7 +214,7 @@ self: {
      mkDerivation {
        pname = "AC-Vector";
        version = "2.3.2";
-       sha256 = "04ahf6ldfhvzbml9xd6yplygn8ih7b8zz7cw03hkr053g5kzylay";
+       sha256 = "5e51ff6779a3803ce1009c9dffd13a3022fb3cbddeb49e685d7f43d7a8715011";
        libraryHaskellDepends = [ base ];
        description = "Efficient geometric vectors and transformations";
        license = stdenv.lib.licenses.bsd3;
@@ -225,7 +225,7 @@ self: {
      mkDerivation {
        pname = "AC-Vector-Fancy";
        version = "2.4.0";
-       sha256 = "0wcan2s75c89s1mxhcvvjgbpn8xqrhmwnfbsrszkzydw3x46465y";
+       sha256 = "be1862481fbcf93fbfce7a39cb2bccb8237bd7937b33d86bd009b172b4b08a71";
        libraryHaskellDepends = [ AC-Angle AC-Vector base ];
        description = "Fancy type-system stuff for AC-Vector";
        license = stdenv.lib.licenses.bsd3;
@@ -238,7 +238,7 @@ self: {
      mkDerivation {
        pname = "ACME";
        version = "0.0.0.1";
-       sha256 = "103mil8lixg0v2wjizy0pqyy9ywbmrk56mc0n37wwvz0qkjaqnds";
+       sha256 = "ba59ace4c4e06fcecfb080555366ae8bfbe43dbec0ff28b9d8e0f548118d7580";
        libraryHaskellDepends = [
          base list-extras mtl random random-shuffle void
        ];
@@ -258,7 +258,7 @@ self: {
      mkDerivation {
        pname = "ADPfusion";
        version = "0.4.1.1";
-       sha256 = "06ff9f4wdf7dr0v2cwhzsjn00bmaijgqznhnyf5fp9jyw8ffbbzp";
+       sha256 = "f7afe51ce25ea6eb8af316da8f9f8caa2e00acd41f722636c8edb8c6894bce19";
        isLibrary = true;
        isExecutable = true;
        libraryHaskellDepends = [
@@ -282,7 +282,7 @@ self: {
      mkDerivation {
        pname = "AERN-Basics";
        version = "2011.1.0.1";
-       sha256 = "1zzm6974mfwzswhx9dfh4w1qrlk44w5k8pajqmrgs8hwnx3k8awa";
+       sha256 = "8a2b3447b71c22fd72c5525d340b2764d28c0327d0b5d421d79fbb4a4e32f5ff";
        isLibrary = true;
        isExecutable = true;
        libraryHaskellDepends = [
@@ -304,7 +304,7 @@ self: {
      mkDerivation {
        pname = "AERN-Net";
        version = "0.2.1.1";
-       sha256 = "1h7yw85zp8dlyjfi5mr3zvb8cn3xbfxw19nqkz6r7v6s5hfg50qg";
+       sha256 = "0f83f21c2cdaec93cd9fd8a6c0bb5b7d5886d6fe23d7129df4b4a1fb0be2fec0";
        libraryHaskellDepends = [
          AERN-Real AERN-RnToRm base binary containers html stm time
        ];
@@ -322,7 +322,7 @@ self: {
      mkDerivation {
        pname = "AERN-Real";
        version = "2011.1.0.1";
-       sha256 = "1m8fc3agvm5r5vgzsxhjdmmxl679n68isa5cwbbfrv38c20s2p6v";
+       sha256 = "db5ca1816068ececd6e2ac281d91b1e918da6b6d1276fddf2eb9d4fdd4600ed5";
        libraryHaskellDepends = [
          AERN-Basics base criterion QuickCheck test-framework
          test-framework-quickcheck2
@@ -342,7 +342,7 @@ self: {
      mkDerivation {
        pname = "AERN-Real-Double";
        version = "2011.1.0.2";
-       sha256 = "0hwbw2nibgfddqfhbq8fcm1anibdfa9kgbbxnsbxvkkl6l52cbg2";
+       sha256 = "e22d260a3574cedd97b67dad3793726d45ab42650ee1051d6ecdbd15ade08b43";
        isLibrary = true;
        isExecutable = true;
        libraryHaskellDepends = [
@@ -367,7 +367,7 @@ self: {
      mkDerivation {
        pname = "AERN-Real-Interval";
        version = "2011.1.0.1";
-       sha256 = "1myh6r2cg4sg7k21y3p415pwm2vjfggi92631wzcjxk8ygcafbwv";
+       sha256 = "9b2fa7d8f36876c93e0fc38814df73728bca6f09e40e1fc43c4f93c74436d0d7";
        libraryHaskellDepends = [
          AERN-Basics AERN-Real base deepseq QuickCheck test-framework
          test-framework-quickcheck2
@@ -386,7 +386,7 @@ self: {
      mkDerivation {
        pname = "AERN-RnToRm";
        version = "0.5.0.1";
-       sha256 = "0rx93h1h303r4gf9jq32gl08lg4jkfc12kzjnjxampwx75b4lgjv";
+       sha256 = "5b3e4a56399ddfaabab4f24f11989b923c8a007d626099dc23798001031ca967";
        libraryHaskellDepends = [
          AERN-Real base binary containers directory filepath html QuickCheck
          time
@@ -406,7 +406,7 @@ self: {
      mkDerivation {
        pname = "AERN-RnToRm-Plot";
        version = "0.2.0.3";
-       sha256 = "0zpp0s90q2jhpagf6iswbmm6hyi0x2hns8vqd5swwa8d258avrbq";
+       sha256 = "78e5ad50110d29ce756978236da1e8207a686a5d5c47e39eba500a0c9206f77e";
        libraryHaskellDepends = [
          AERN-Real AERN-RnToRm base binary containers directory filepath
          glade glib gtk gtkglext mtl OpenGL stm time
@@ -425,7 +425,7 @@ self: {
      mkDerivation {
        pname = "AES";
        version = "0.2.9";
-       sha256 = "12n484dpjr08910ni1vvw030g9p37lz68l5lw0212rvklkva6wzc";
+       sha256 = "ec73a3f6a473671104e0b450643e3de3a60706e07b876841480864791b41c48a";
        revision = "1";
        editedCabalFile = "9e51c1b1687fe35ccd0f2983e861b5b0441399803ff76b192530984724a68d6f";
        libraryHaskellDepends = [
@@ -440,7 +440,7 @@ self: {
      mkDerivation {
        pname = "AGI";
        version = "1.3";
-       sha256 = "1h0hcdvdjs635inq96fpyh2g3d482ilpqn474vk1xkycww0xgsnv";
+       sha256 = "dbead701e7cccf1ee62687587c691488b4f104f4d799846d2cc368d9766310c0";
        libraryHaskellDepends = [
          base mtl network parsec random syb unix
        ];
@@ -455,7 +455,7 @@ self: {
      mkDerivation {
        pname = "ALUT";
        version = "2.4.0.0";
-       sha256 = "0g8rzzk54y8d567dvj32bq0h409ag0am196kkirsjd6f58vgjp0g";
+       sha256 = "0f5cf9362ace34a9739cd3a45015782a0102015e62c8dd8e290d7952e6ff193d";
        libraryHaskellDepends = [ base OpenAL StateVar transformers ];
        librarySystemDepends = [ freealut ];
        homepage = "https://github.com/haskell-openal/ALUT";
@@ -470,7 +470,7 @@ self: {
      mkDerivation {
        pname = "AMI";
        version = "0.1";
-       sha256 = "00w6kcikc5ac26786fwshwbh8ndj9aq1w7wz263j5rnhdf12irky";
+       sha256 = "7ee628826bd0e62287119f1f1eb04ab2590417879a3b838e114c1536239b8603";
        libraryHaskellDepends = [
          base bytestring containers mtl network pureMD5 stm
        ];
@@ -485,7 +485,7 @@ self: {
      mkDerivation {
        pname = "ANum";
        version = "0.1.1.0";
-       sha256 = "0ilgz1akz66cwwvxd8dkz2fq9gyplc4m206jpmp380ys5n37b4q9";
+       sha256 = "099375862dda03346ebdd2005109a3d7bf849df8b3a1d637e7cc983f55f88f46";
        libraryHaskellDepends = [ base ];
        homepage = "https://github.com/DanBurton/ANum#readme";
        description = "Num instance for Applicatives provided via the ANum newtype";
@@ -499,7 +499,7 @@ self: {
      mkDerivation {
        pname = "ASN1";
        version = "0.0.1.1";
-       sha256 = "188mf1k8p4h8ryngpcs6ldz9n2590h9wfxzxsj396is5r8rxscmh";
+       sha256 = "b032dd33ca45479386d4fd77c71304a9089b7ea346b3fbaccf08928b667015a1";
        libraryHaskellDepends = [
          base containers HUnit mtl NewBinary old-time pretty QuickCheck
        ];
@@ -513,7 +513,7 @@ self: {
      mkDerivation {
        pname = "AVar";
        version = "0.0.5.1";
-       sha256 = "0jggzjyms1w4p1ynv8m5yvya64kbxkjdis7wvy3lildmp0w0x0c7";
+       sha256 = "87810e38b8b5d14887dffce8d8e4ec6b12a3fcf6a5a26d7db884075dbdfcef49";
        libraryHaskellDepends = [ base ];
        description = "Mutable variables with Exception handling and concurrency support";
        license = stdenv.lib.licenses.bsd3;
@@ -524,7 +524,7 @@ self: {
      mkDerivation {
        pname = "AWin32Console";
        version = "1.1";
-       sha256 = "0il5bngj4919mmpm0rwmbx74ih3sfbqkaph6w12p49fs466sxkh1";
+       sha256 = "01ceae8d21da257245e0065e35f1727ac0484e5f9567506fad2924229f5d8546";
        libraryHaskellDepends = [ base regex-compat Win32 ];
        description = "A binding to a part of the ANSI escape code for the console";
        license = stdenv.lib.licenses.bsd3;
@@ -536,7 +536,7 @@ self: {
      mkDerivation {
        pname = "AbortT-monadstf";
        version = "1.0";
-       sha256 = "1ijv4bs299ijqbkspbg1kry627ra6p6qlkd74q4y2pvamrm4dn6f";
+       sha256 = "ced8466aae6a5fe10926a74d8acd352a1f617c9ee1adabe7c232a624f4225bc6";
        libraryHaskellDepends = [ AbortT-transformers base monads-tf ];
        homepage = "http://github.com/gcross/AbortT-transformers";
        description = "Monads-tf instances for the AbortT monad transformer";
@@ -548,7 +548,7 @@ self: {
      mkDerivation {
        pname = "AbortT-mtl";
        version = "1.0";
-       sha256 = "17rp4v5ibna9fplm526x31k8df8zwkm1imv71yqzpgcqcn48pps2";
+       sha256 = "42df8b886598bdfbb10f67d718eae41fb9866618dd8852e97549d915cb26379f";
        libraryHaskellDepends = [ AbortT-transformers base mtl ];
        jailbreak = true;
        homepage = "http://github.com/gcross/AbortT-mtl";
@@ -563,7 +563,7 @@ self: {
      mkDerivation {
        pname = "AbortT-transformers";
        version = "1.0.1.1";
-       sha256 = "00q3c2pr9rl2110624rndn7j2843rl62vh5569q96l2vzfpccgbp";
+       sha256 = "773dc6aefb5b50937032a5c02d0ccd8320218f6d361361400882e694af600303";
        libraryHaskellDepends = [ base transformers ];
        testHaskellDepends = [
          base HUnit QuickCheck test-framework test-framework-hunit
@@ -582,7 +582,7 @@ self: {
      mkDerivation {
        pname = "ActionKid";
        version = "0.1.1.0";
-       sha256 = "0dsfgclgx4kqjnvn54vvxcbn8l8jyy9gb06qp13hfm5l7lxfjzxq";
+       sha256 = "b87fe93a3db4540747b8d880f592f712516417eb7b9362b7957892fe287b4e37";
        isLibrary = true;
        isExecutable = true;
        libraryHaskellDepends = [
@@ -606,7 +606,7 @@ self: {
      mkDerivation {
        pname = "Adaptive";
        version = "0.23";
-       sha256 = "0n27d8dvk0qq68zp4l5bsj5y9xqmrk9d25psrrf29mmw1f43wp8c";
+       sha256 = "0c5d3e880bbcd6245ccefa16d1d2cc15f7e48bd4ab50723f321883b91b6a4758";
        isLibrary = true;
        isExecutable = true;
        libraryHaskellDepends = [ base ];
@@ -620,7 +620,7 @@ self: {
      mkDerivation {
        pname = "Adaptive-Blaisorblade";
        version = "0.23";
-       sha256 = "08iblifpyi569zh55ha5bi0nfibz0zlqiibwaimx2k1nd6n6yv5a";
+       sha256 = "aa6c6fac69364cd16b547cc588e9077f4567415c45c152e04fa6447f5da42b22";
        isLibrary = true;
        isExecutable = true;
        libraryHaskellDepends = [ base ];
@@ -634,7 +634,7 @@ self: {
      mkDerivation {
        pname = "Advgame";
        version = "0.1.2";
-       sha256 = "16grzya42pzn3zaahs77lw5n2ka138bs0g3vgi0qbxlvxwy5ikyy";
+       sha256 = "decf583cef9bf685417c7b3ca0171a414d610ba7e768a8d41ff65f4194fff999";
        isLibrary = false;
        isExecutable = true;
        executableHaskellDepends = [ base haskell98 mtl ];
@@ -651,7 +651,7 @@ self: {
      mkDerivation {
        pname = "AesonBson";
        version = "0.2.2";
-       sha256 = "1p7636bjczcwwi2c0cdzvpj95vx2fr27qnmh8pcs8hqgmisagq8s";
+       sha256 = "1ae1a774ac0f43a4d945b05a7c4476a2ef92e4ddbf31c044e49c7d269719e6dc";
        libraryHaskellDepends = [
          aeson attoparsec base bson unordered-containers vector
        ];
@@ -670,7 +670,7 @@ self: {
      mkDerivation {
        pname = "Agata";
        version = "0.2.1.1";
-       sha256 = "0v8gy2gdbn9133yki7s71a7ph50xzawdvciiahr463apbn6439hm";
+       sha256 = "15a6418c5d570d43325431b2ddb8fa1d14788f0a479f38fd1821d9d59ef00f6d";
        libraryHaskellDepends = [
          base containers mtl QuickCheck tagged template-haskell
        ];
@@ -692,9 +692,9 @@ self: {
      mkDerivation {
        pname = "Agda";
        version = "2.4.2.3";
-       sha256 = "09vvipvab6bys8g7cdka1iirs0wc0jzcyynncccgb614wd2yyvdw";
-       revision = "1";
-       editedCabalFile = "25fe17a2302a30f23a57bedf6bc66a8966f4d5f6b10353e2502e18ba98f80eeb";
+       sha256 = "bc6def45e32498f51863d67acfbe048c039d630c6a36761ed27e99a5f68d7b27";
+       revision = "2";
+       editedCabalFile = "b5ad21731b7a6ce714d403a5edb0b53951fe61926d47f7a21e29548602c0d763";
        isLibrary = true;
        isExecutable = true;
        libraryHaskellDepends = [
@@ -707,6 +707,7 @@ self: {
        libraryToolDepends = [ alex cpphs happy ];
        executableHaskellDepends = [ base directory filepath process ];
        executableToolDepends = [ emacs ];
+       jailbreak = true;
        postInstall = ''
          $out/bin/agda -c --no-main $(find $out/share -name Primitive.agda)
          $out/bin/agda-mode compile
@@ -721,7 +722,7 @@ self: {
      mkDerivation {
        pname = "Agda-executable";
        version = "2.3.0.1";
-       sha256 = "156nzvpmqi7yizjr4yym2ybc0iv4nqfp84qrpdxcha682k298ib1";
+       sha256 = "614594c414c828c87abb1913741db66447c09617d57b92e58ffe445ceffed694";
        isLibrary = false;
        isExecutable = true;
        executableHaskellDepends = [ Agda base ];
@@ -737,7 +738,7 @@ self: {
      mkDerivation {
        pname = "AhoCorasick";
        version = "0.0.3";
-       sha256 = "171im3xhrgdzhpxmi1350323apy58pisap0dskcibd3g4jmzslza";
+       sha256 = "ea53fdab246fb415d9d40d5ca5e345c55f35c400658458fb85bfbd0cfba8319c";
        libraryHaskellDepends = [
          array base hashable mtl unordered-containers
        ];
@@ -752,7 +753,7 @@ self: {
      mkDerivation {
        pname = "AlgorithmW";
        version = "0.1.1.0";
-       sha256 = "0avkxhw5hp00znhmqw3kqxx165ba5y5kgq8b9ahp679p0qf84a3c";
+       sha256 = "6c28821c06371d73a14a0be1378b2f6a15137ac773705ca1fd005c5838ec732b";
        isLibrary = false;
        isExecutable = true;
        executableHaskellDepends = [ base containers mtl pretty ];
@@ -768,7 +769,7 @@ self: {
      mkDerivation {
        pname = "AlignmentAlgorithms";
        version = "0.0.2.0";
-       sha256 = "110vhp7kdg9l5j3w19wbimmfpq4c05xgx680vb938r1pgpx9s76r";
+       sha256 = "d91c9dfa7d376434d2da0099fe7a018ce0eb6a8d8ba7c0872c34bd36cf851b84";
        libraryHaskellDepends = [
          ADPfusion base containers fmlist FormalGrammars GrammarProducts
          PrimitiveArray vector
@@ -785,7 +786,7 @@ self: {
      mkDerivation {
        pname = "Allure";
        version = "0.5.0.0";
-       sha256 = "0lmkfa6wk0hqin43lf6ll3227c4h7qvya7s6k6sfz8syy51ggqx7";
+       sha256 = "a7e3f742f15ea3efb499461fe5373e90b023c4a0d4383a888d1882c98d72b352";
        isLibrary = false;
        isExecutable = true;
        executableHaskellDepends = [
@@ -809,7 +810,7 @@ self: {
      mkDerivation {
        pname = "AndroidViewHierarchyImporter";
        version = "0.1.0.1";
-       sha256 = "1ksmxhriqy8z3fymnvhg7bwaj032nrsvq3gygfwkg3m8538v9xyc";
+       sha256 = "ccf7b4d128a88e37b97bfe0dbc75b66200a9f83a0f6e5bbd1b1f791c33ec55cf";
        isLibrary = false;
        isExecutable = true;
        executableHaskellDepends = [
@@ -827,7 +828,7 @@ self: {
      mkDerivation {
        pname = "Animas";
        version = "0.2";
-       sha256 = "01vpw9s93qq8c0zymp4qzv0ljn9jrnwi3x68qx9lcjr6spa0rkvm";
+       sha256 = "75cf0cd4d5264b4653c7c8f411b9cd325949c1fe98dcea3f6008e39174e27707";
        libraryHaskellDepends = [ base random ];
        homepage = "https://github.com/eamsden/Animas";
        description = "Updated version of Yampa: a library for programming hybrid systems";
@@ -840,7 +841,7 @@ self: {
      mkDerivation {
        pname = "Annotations";
        version = "0.2.1";
-       sha256 = "1iqcg47rklibps6xjs7zw76npycpa1jj3x68zz75np3r0fnwiqhj";
+       sha256 = "12e2c8ad03795c5bceffc8f421655097f96bcde1ff68d98dbe2bd2990f790cc7";
        libraryHaskellDepends = [ base mtl multirec parsec ];
        testHaskellDepends = [ base mtl multirec parsec ];
        description = "Constructing, analyzing and destructing annotated trees";
@@ -852,7 +853,7 @@ self: {
      mkDerivation {
        pname = "Ansi2Html";
        version = "0.9";
-       sha256 = "1dqq1rnx1w0cn4w11knmxvn7qy4lg4m39dgw4rs6r2pjqzgrwarh";
+       sha256 = "302b9edfc7f28a6c7426fcb5342a7994787ceceed5ce1038b10cf0d06d0e18b7";
        isLibrary = false;
        isExecutable = true;
        executableHaskellDepends = [ base mtl parsec xhtml ];
@@ -868,7 +869,7 @@ self: {
      mkDerivation {
        pname = "ApplePush";
        version = "0.1";
-       sha256 = "0dw52pj17fggi605zf4px852479yc6m6ksbidyw84lkys5dyll3r";
+       sha256 = "7950ea5bd17e5282b86f71e969aa613e1d220aea97b85f8089efb913e4158537";
        isLibrary = true;
        isExecutable = true;
        libraryHaskellDepends = [
@@ -885,7 +886,7 @@ self: {
      mkDerivation {
        pname = "AppleScript";
        version = "0.2.0.1";
-       sha256 = "1jmwixyv5msb3lmza7dljvm3l0x5mx8r93zr607sx9m5x9yhlsvr";
+       sha256 = "796b0a7deaa5a6ae0f30f98f9451afa5033aea96b41df52b1d4bd7b27d8fbcca";
        libraryHaskellDepends = [ base ];
        homepage = "https://github.com/reinerp/haskell-AppleScript";
        description = "Call AppleScript from Haskell, and then call back into Haskell";
@@ -898,7 +899,7 @@ self: {
      mkDerivation {
        pname = "ApproxFun-hs";
        version = "0.1.0.0";
-       sha256 = "1s7amy8ij5bgv8afbjdzqd3lflvhzrrh3cs3krl1rf73y8b1nqpy";
+       sha256 = "fe621b16f2e3b81c689e43b30173fe70534747c3bfc9e514da6f151991afeae8";
        libraryHaskellDepends = [ base vector ];
        jailbreak = true;
        homepage = "https://github.com/idontgetoutmuch/ApproxFun.hs";
@@ -911,7 +912,7 @@ self: {
      mkDerivation {
        pname = "ArrayRef";
        version = "0.1.3.1";
-       sha256 = "1yb209v3lab3knggplmwih1ww6qalf8v86j8ggv1gkhm5jkwz1yq";
+       sha256 = "d887cfa72c15ce17f67b481ab491a30a1bce038cbcd2fb9e9d63293a760262f9";
        libraryHaskellDepends = [ base ];
        homepage = "http://haskell.org/haskellwiki/Library/ArrayRef";
        description = "Unboxed references, dynamic arrays and more";
@@ -924,7 +925,7 @@ self: {
      mkDerivation {
        pname = "ArrowVHDL";
        version = "1.1";
-       sha256 = "1lv76m4qc1sabagllaagi7bpqf1mnmzsra333a77b6134mk2f9hb";
+       sha256 = "0b262766252398758e1a63a8ac7fb535387cd7894f294a9f5a4a0786493567d3";
        libraryHaskellDepends = [ base process ];
        jailbreak = true;
        homepage = "https://github.com/frosch03/arrowVHDL";
@@ -938,7 +939,7 @@ self: {
      mkDerivation {
        pname = "AspectAG";
        version = "0.3.6.1";
-       sha256 = "01pglvf38v5ii2w03kdlgngxbb3ih0j5bsilv5qwc9vrh2iwirhf";
+       sha256 = "0ee6c8a3807927c671d934ea55248071acd59f7db4cd01b888b16c34dca6ef06";
        revision = "1";
        editedCabalFile = "d5b68030eaf2111998f6d5774a1d26d5afb685fe6b087fe1aed7ef90084a0070";
        libraryHaskellDepends = [
@@ -959,7 +960,7 @@ self: {
      mkDerivation {
        pname = "AttoBencode";
        version = "0.3.1.0";
-       sha256 = "0rzzi4asfmkg8nqlxdyq3gwg0q10hqrnvlmq4fjcxvxgvz1ys9hb";
+       sha256 = "0b26edc3dfafefcea423b8d26d33862060f0f81bd8b74eb1456f56a71589ff67";
        libraryHaskellDepends = [
          attoparsec base blaze-builder blaze-textual bytestring containers
        ];
@@ -980,7 +981,7 @@ self: {
      mkDerivation {
        pname = "AttoJson";
        version = "0.5.10";
-       sha256 = "0mavq6akhx7pjdz15ckgnmgf8z9zhi5fm97lvjpjdfiggfy191d2";
+       sha256 = "a28514bc7b2fba26afdcf4a4ea4a843f7de45eb56fb2127e93f7743895c15b55";
        libraryHaskellDepends = [
          attoparsec base bytestring bytestring-show containers mtl
          utf8-string
@@ -995,7 +996,7 @@ self: {
      mkDerivation {
        pname = "Attrac";
        version = "0.1.3";
-       sha256 = "0spvvgkf33km969l524580kwn7y43rjm2k0lqp9bl60nbvlsw760";
+       sha256 = "c01caee95e1618bad2c5144c51651ec41fcb27408588429349758ee1e6dbfb6a";
        isLibrary = false;
        isExecutable = true;
        executableHaskellDepends = [
@@ -1013,7 +1014,7 @@ self: {
      mkDerivation {
        pname = "Aurochs";
        version = "0.1";
-       sha256 = "0n51j50qlpkgkq64n7w96qkv270lwxac1h7ariqq7w70zgdgiqf5";
+       sha256 = "c5e1f8dafbe0f08371cceac0c054e7141cb12736891f4b0c9e6f5e8a4191a158";
        isLibrary = false;
        isExecutable = true;
        executableHaskellDepends = [ base containers parsec pretty ];
@@ -1029,7 +1030,7 @@ self: {
      mkDerivation {
        pname = "AutoForms";
        version = "0.4.2";
-       sha256 = "14dd6s3j9w738dvhyhxb9q8w9m0xhd6fm0d40b3gzl5sjb6g16zf";
+       sha256 = "ee9bf0cc92bad0ffc602a481ea4c831dd4c4114eab430f7743e3f0248736ad91";
        libraryHaskellDepends = [
          array base haskell98 mtl syb-with-class template-haskell wx wxcore
        ];
@@ -1044,7 +1045,7 @@ self: {
      mkDerivation {
        pname = "AvlTree";
        version = "4.2";
-       sha256 = "0bw6856h75wks0mfvvqqm5i31sici1hacyl5zfj225jf9gn5q7dx";
+       sha256 = "bd1d5cec4b4e1621a4fb857aa660882cea3062a918efed2ad09397034d41862f";
        libraryHaskellDepends = [ base COrdering ];
        description = "Balanced binary trees using the AVL algorithm";
        license = stdenv.lib.licenses.bsd3;
@@ -1056,7 +1057,7 @@ self: {
      mkDerivation {
        pname = "BASIC";
        version = "0.1.5.0";
-       sha256 = "1ypq7m09ki5wbwkvmqdl7ch40cbdfhb91kq8n17im184r5liyxlc";
+       sha256 = "8c761f69c904851a4fb008cf9016746d3140203bb4e1ba275fbcc499403df8fa";
        libraryHaskellDepends = [ base containers llvm random timeit ];
        description = "Embedded BASIC";
        license = stdenv.lib.licenses.bsd3;
@@ -1071,7 +1072,7 @@ self: {
      mkDerivation {
        pname = "BCMtools";
        version = "0.1.1";
-       sha256 = "1693kg8hxr1jl8h0ri11dbrbyhyznipkvcp0cvvx9chn97761ys4";
+       sha256 = "44fb60ce4916b2d4f766e0b23d6fb4df43bff26a21c40c20a232e40ed19b2399";
        isLibrary = true;
        isExecutable = true;
        libraryHaskellDepends = [
@@ -1097,7 +1098,7 @@ self: {
      mkDerivation {
        pname = "BNFC";
        version = "2.8";
-       sha256 = "0d3zcxspxcpnifv3kqg8d6gp01wxybakcbw7jh69gqg8rzfmzgi1";
+       sha256 = "21be5fddcfe8e1970c94872f36d5f29d07709f69e8e139b68bf6b27e75677f34";
        isLibrary = true;
        isExecutable = true;
        libraryHaskellDepends = [ array base ];
@@ -1121,7 +1122,7 @@ self: {
      mkDerivation {
        pname = "BNFC-meta";
        version = "0.4.0.3";
-       sha256 = "10rfljhygdl75ibmj0xqj7qwdk0ppjr8iw4wmvzdpl28mqjshny2";
+       sha256 = "c25ba825ae48d0dbfeae9cf088b2bc17ccc6f191b80359572c87b6e7a1a42e83";
        libraryHaskellDepends = [
          alex-meta array base happy-meta haskell-src-meta syb
          template-haskell
@@ -1135,7 +1136,7 @@ self: {
      mkDerivation {
        pname = "Baggins";
        version = "1.0";
-       sha256 = "0mgxq8zqyfmwkvn91y91c2vjhrni3br0vgiih2ynlafnas1ji0bc";
+       sha256 = "6c81288356d6296abd8031be0df21ad16628b76021f990ec9ebc3a8f3fc2fd55";
        revision = "1";
        editedCabalFile = "654cbc7a4109bf3baaa2491f10a7f49d1831008129d4d5ef9e0e558a5a374098";
        libraryHaskellDepends = [ base cairo containers mtl ];
@@ -1153,7 +1154,7 @@ self: {
      mkDerivation {
        pname = "Bang";
        version = "0.1.1.0";
-       sha256 = "1y68k1xsx2fksz70z5b8wdf5brk3vqsc6sih2asp4f97nwlkm5fw";
+       sha256 = "dc953a29b7273972b512306ac334de63e6555ce368950fced7d389ae7b98c8f8";
        libraryHaskellDepends = [
          base bifunctors hmidi mtl stm time transformers
        ];
@@ -1172,7 +1173,7 @@ self: {
      mkDerivation {
        pname = "Barracuda";
        version = "1.0.2";
-       sha256 = "0i8b6g2jvwg5r5gi1q3fgckh675pc6viqdvncl4ycr4zf72r4jj3";
+       sha256 = "434a92c5719f64e6096576371cb761b71c03277b6ee0105fc9e5f12dc5330b45";
        isLibrary = true;
        isExecutable = true;
        libraryHaskellDepends = [
@@ -1198,7 +1199,7 @@ self: {
      mkDerivation {
        pname = "Befunge93";
        version = "0.1";
-       sha256 = "1hs4p5s30ml97yrr91ahy7275jh4vyvh2l5p0p3jvpfysvg9sl6l";
+       sha256 = "d4509dded6dedd2dc705b75001b7df04ca72c4f1508594b33f89563074b944c3";
        isLibrary = false;
        isExecutable = true;
        executableHaskellDepends = [ array base mtl random ];
@@ -1216,7 +1217,7 @@ self: {
      mkDerivation {
        pname = "BenchmarkHistory";
        version = "0.0.0.1";
-       sha256 = "07qdadcs76h7yd0k4hn3x3yqdiq7hp5lflxbxxlicx76k20fgl99";
+       sha256 = "29d1e78098e6741669efab5347cb8507c786fde8c3423241f3079aa359530d1f";
        isLibrary = true;
        isExecutable = true;
        libraryHaskellDepends = [
@@ -1232,7 +1233,7 @@ self: {
      mkDerivation {
        pname = "BerkeleyDB";
        version = "0.8.7";
-       sha256 = "0q1qc6rds05bkxl2m3anp7x75cwinp9nhy8j0g1vaj2scasvki62";
+       sha256 = "c2c4b9b5625a48b5c303127968d3b591b372fab9568d2a689fab00ddb2613860";
        libraryHaskellDepends = [ base bytestring extensible-exceptions ];
        librarySystemDepends = [ db ];
        homepage = "http://www.haskell.org/haskellwiki/BerkeleyDBXML";
@@ -1247,7 +1248,7 @@ self: {
      mkDerivation {
        pname = "BerkeleyDBXML";
        version = "0.7.2";
-       sha256 = "1ymdi5qi4hxaikqf8min830r1rs1z4bvy9bdybsq378v7mrgfihp";
+       sha256 = "1746f7723d1b9d81f5f26d25bf17f941e790c1403656e4f08caa43127189adfa";
        libraryHaskellDepends = [ base BerkeleyDB bytestring ];
        librarySystemDepends = [ db dbxml xercesc xqilla ];
        homepage = "http://www.haskell.org/haskellwiki/BerkeleyDBXML";
@@ -1262,7 +1263,7 @@ self: {
      mkDerivation {
        pname = "BerlekampAlgorithm";
        version = "0.1.0.0";
-       sha256 = "14wjpfr9d8fpgl1jkpm2123lprr3hf3a6smkaflzkgxqlgcrkmyr";
+       sha256 = "d9d799d9a3b8bff9a953b36aa3868323e74b8708a2de29037dd7a196b2bb9293";
        libraryHaskellDepends = [ base besout ];
        jailbreak = true;
        description = "Factorization of polynomials over finite field";
@@ -1274,7 +1275,7 @@ self: {
      mkDerivation {
        pname = "BigPixel";
        version = "1.3.0";
-       sha256 = "19fxxbgj67rz2fpxd6f307xd6p7blwynq6gcakjnc7kdq8ghfrgz";
+       sha256 = "ff65071fc26d1e66e554ec196c3da7eb5cd3fa01c399d6af133f1f23dfeadda5";
        isLibrary = false;
        isExecutable = true;
        executableHaskellDepends = [ array base bmp bytestring gloss ];
@@ -1288,7 +1289,7 @@ self: {
      mkDerivation {
        pname = "Binpack";
        version = "0.4.1";
-       sha256 = "0am0487l7njngp2k6h3qfbhjs61d9ir9rp8iw1r5448b20n4fxas";
+       sha256 = "5a75472c100b115272e011dd9c724c2d182de172784033c57d56da430f22a02a";
        libraryHaskellDepends = [ base ];
        description = "Common bin-packing heuristics";
        license = stdenv.lib.licenses.bsd3;
@@ -1304,7 +1305,7 @@ self: {
      mkDerivation {
        pname = "Biobase";
        version = "0.3.1.1";
-       sha256 = "1zrslhf3aiwc3y0b628j1w93z78v9apcjm2sxyw5qcq6r48zrmcc";
+       sha256 = "8cd5fc11c906335cb8ef5a54c9ae4a1b9d3f120f1209b3801f8c47351ca43aff";
        libraryHaskellDepends = [
          array base bytestring containers deepseq directory either-unwrap
          file-embed filemanip filepath ghc-prim HsTools mtl parsec
@@ -1323,7 +1324,7 @@ self: {
      mkDerivation {
        pname = "BiobaseBlast";
        version = "0.0.0.1";
-       sha256 = "1p7f2azq92shmxvs3n683mr5965qkmijbj4ya6333cd7nilwgl0f";
+       sha256 = "0ed0c769b4a7b13186519ec825639db89854721dc8d8a177af508b84bf12eedc";
        libraryHaskellDepends = [ array base BiobaseXNA containers ];
        homepage = "http://www.tbi.univie.ac.at/~choener/";
        description = "BLAST-related tools";
@@ -1336,7 +1337,7 @@ self: {
      mkDerivation {
        pname = "BiobaseDotP";
        version = "0.1.0.0";
-       sha256 = "0m7n3c2ly6kly146xrxzx41g3pv0cylrmzpdgv5c54x9gvb1hg7w";
+       sha256 = "fc3c18d67ea993c2ca7eedfe9aa96760dff102e9bfe76e48f0741a4f051bf654";
        libraryHaskellDepends = [ base bytestring iteratee ];
        homepage = "http://www.tbi.univie.ac.at/~choener/";
        description = "Vienna / DotBracket / ExtSS parsers";
@@ -1351,7 +1352,7 @@ self: {
      mkDerivation {
        pname = "BiobaseFR3D";
        version = "0.2.3.0";
-       sha256 = "1y8aqxb8gq4k4l0i2wcrn2yi6f7lcmbhbvs4n063r4hgda6xfgch";
+       sha256 = "903dd78d6a0f923c0cb044ef055765f43813bdb0997111012593e08756c70af9";
        libraryHaskellDepends = [
          base BiobaseXNA bytestring containers filemanip iteratee tuple
        ];
@@ -1369,7 +1370,7 @@ self: {
      mkDerivation {
        pname = "BiobaseFasta";
        version = "0.0.1.0";
-       sha256 = "035pr31mrmfhmpja8llw81jyxy11aba62bfph34gf3rsi96iylnw";
+       sha256 = "dc521f4d8a3a0ff7c880d72d61d45221f8ee65409c52a4e4add0d55cc3c8b70c";
        isLibrary = true;
        isExecutable = true;
        libraryHaskellDepends = [
@@ -1392,7 +1393,7 @@ self: {
      mkDerivation {
        pname = "BiobaseInfernal";
        version = "0.7.1.0";
-       sha256 = "19ga8qaqfp3jkd3mn8p1qrxv0frp4f4qkzhn0p0n8as6dlsifd2s";
+       sha256 = "5a3417356d462b64c10516fe898923373bb07bc6e1225b479b725c871546eaa5";
        libraryHaskellDepends = [
          attoparsec attoparsec-conduit base BiobaseXNA biocore bytestring
          bytestring-lexing conduit containers either-unwrap lens primitive
@@ -1410,7 +1411,7 @@ self: {
      mkDerivation {
        pname = "BiobaseMAF";
        version = "0.5.0.0";
-       sha256 = "0mwyyb7n232wgjipn9jsbqpcbxqms07adi5a6v14qaiynsjz4n1r";
+       sha256 = "3958f2a5b63e2a4cc236aac4a60ed015f7c52e5e5a267ba37c5c0c61cff29e57";
        libraryHaskellDepends = [ base bytestring containers iteratee ];
        homepage = "http://www.tbi.univie.ac.at/~choener/";
        description = "Multiple Alignment Format";
@@ -1425,7 +1426,7 @@ self: {
      mkDerivation {
        pname = "BiobaseTrainingData";
        version = "0.1.2.3";
-       sha256 = "0qqyj3y2ivxj4d1c4bl5mdi7xm649dvksl57ba0wl0awimi5xn2s";
+       sha256 = "5ad85e628d5c01ca815aa7503d774bc4d47e62ab852ec24223b2ef28fc901e63";
        isLibrary = true;
        isExecutable = true;
        libraryHaskellDepends = [
@@ -1448,7 +1449,7 @@ self: {
      mkDerivation {
        pname = "BiobaseTurner";
        version = "0.3.1.1";
-       sha256 = "1h6yn6nwl8ifbz8y1rq5xklhmnbbjibfi9qz4n79xmv7y9bgkbxf";
+       sha256 = "aeaff956f267d79e8e251fa7e856946bd90ae9ec05e7e0d15f2e22caadb1dec0";
        libraryHaskellDepends = [
          base BiobaseXNA bytestring bytestring-lexing conduit containers
          filepath lens primitive PrimitiveArray repa split vector
@@ -1469,7 +1470,7 @@ self: {
      mkDerivation {
        pname = "BiobaseTypes";
        version = "0.1.1.0";
-       sha256 = "1z3vhxqqyc1bn1byvld21psi7am8zwmxsa7aiqshppw5hqyslwvl";
+       sha256 = "7473aa3d8685df0b358eea28dd2bffa8aa13f50da2d1ed57b02b308f71877bfc";
        libraryHaskellDepends = [
          aeson base binary cereal cereal-text data-default deepseq hashable
          log-domain primitive PrimitiveArray QuickCheck stringable text
@@ -1491,7 +1492,7 @@ self: {
      mkDerivation {
        pname = "BiobaseVienna";
        version = "0.3.0.0";
-       sha256 = "0bv100rmr04w8wbzabihv43lxilr0b2rm97rx54bhln1sy0ih1wj";
+       sha256 = "92071881d7c152b848e9f9a49ac50299c64e07d9302ef517479c805c3300612f";
        libraryHaskellDepends = [
          base BiobaseTurner BiobaseXNA primitive PrimitiveArray vector
        ];
@@ -1510,7 +1511,7 @@ self: {
      mkDerivation {
        pname = "BiobaseXNA";
        version = "0.9.2.0";
-       sha256 = "1ck6yba372w3cbzgifcbfdd2m4nfyy7zd8zygkji3zbxymz2ak18";
+       sha256 = "284c257ef57dfd11e57cfea3f68ff7ce922a5a738bb9f8fe62838b33d4f266b2";
        isLibrary = true;
        isExecutable = true;
        libraryHaskellDepends = [
@@ -1530,7 +1531,7 @@ self: {
      mkDerivation {
        pname = "BirdPP";
        version = "1.1";
-       sha256 = "14wbnxjyg75vc7zwg42cpk8a1cb7gm4881c52yaq1bq053g5dsz2";
+       sha256 = "e2eb56de2800af809517850584487d67b1a0d0bc4c90c7ff61bb9ce765b78b93";
        isLibrary = false;
        isExecutable = true;
        executableHaskellDepends = [ base haskell98 ];
@@ -1547,7 +1548,7 @@ self: {
      mkDerivation {
        pname = "BitSyntax";
        version = "0.3.2";
-       sha256 = "1kz9s9g05b5qzw9p7vvyw8zmy9sx1wzn83ay6prdyv74x0wycjbl";
+       sha256 = "7449e639e8e46cdff2355e0d643f0f5d275f3fe27eef7313ffb8ac025ed2e9cf";
        libraryHaskellDepends = [
          base bytestring haskell98 QuickCheck template-haskell
        ];
@@ -1562,7 +1563,7 @@ self: {
      mkDerivation {
        pname = "Bitly";
        version = "0.1.0";
-       sha256 = "1pmmgg6n6pc0qvp5r4qxan32887132si0cayd0xh1g5v98fa9ari";
+       sha256 = "31aba41c4abbbc003b685e3110b518e1202486551d935ceec6805d63cd7bb5de";
        libraryHaskellDepends = [ base HTTP json2 ];
        homepage = "http://bitbucket.org/jetxee/hs-bitly/";
        description = "A library to access bit.ly URL shortener.";
@@ -1577,7 +1578,7 @@ self: {
      mkDerivation {
        pname = "BlastHTTP";
        version = "1.2.0";
-       sha256 = "0vhnwjgamc1zry8w7m6jb7ambz3lqqr00j05xymzwcapgwg8v9b5";
+       sha256 = "65a58d1e7f5731feabef05480032c674fc55d559d2d4c391cf3fb0aa9ee4166e";
        revision = "1";
        editedCabalFile = "7076650ad04d2c5945b96ec1a8d5db8ee680314d4dc4cff54f264316e7f69bba";
        libraryHaskellDepends = [
@@ -1596,7 +1597,7 @@ self: {
      mkDerivation {
        pname = "Blobs";
        version = "0.3";
-       sha256 = "09mpf3qwr38x0ljz4ziyhdcwl5j37i353wc2dkpc6hjki9p08rgl";
+       sha256 = "f465046e8a5342c3ee6c82f151463c4316ca59833e7ef225051d8dccf170b726";
        isLibrary = true;
        isExecutable = true;
        libraryHaskellDepends = [
@@ -1621,7 +1622,7 @@ self: {
      mkDerivation {
        pname = "BlogLiterately";
        version = "0.8.1.1";
-       sha256 = "02q0i2p892adpmi7p4hh8666qzrpi76bxwljf575hiaz018yixlb";
+       sha256 = "8bf6e851005f45584e7192f2becc89377f6c8c4110927b62bd4d8984ae88000b";
        isLibrary = true;
        isExecutable = true;
        libraryHaskellDepends = [
@@ -1644,7 +1645,7 @@ self: {
      mkDerivation {
        pname = "BlogLiterately-diagrams";
        version = "0.2.0.1";
-       sha256 = "190wny2ggqahsiv5ar23pndf3ngparb5mrrjp7his5crp6xvk66m";
+       sha256 = "d598b9bbb999151de1b932e75a5656f7d9e19abd43645576d450e1f784b71ca4";
        isLibrary = true;
        isExecutable = true;
        libraryHaskellDepends = [
@@ -1662,7 +1663,7 @@ self: {
      mkDerivation {
        pname = "BluePrintCSS";
        version = "0.1";
-       sha256 = "0ryjgi70isgfv3nw3djzvb1saky40xqy536h6sr3mfpy2iqnim0c";
+       sha256 = "0cd4687114feba3ab236d08ce27107c44fa5c3da5fb6c1edd8eee9084e7cd267";
        libraryHaskellDepends = [ base mtl ];
        homepage = "http://git.ierton.ru/?p=BluePrint.git;a=summary";
        description = "Html document layout library";
@@ -1674,7 +1675,7 @@ self: {
      mkDerivation {
        pname = "Blueprint";
        version = "0.1";
-       sha256 = "16cfmy4ndc15p6jdmyy08nqgv143dvs9xf4qg4mxa6x5r326pi94";
+       sha256 = "24c56bc4c8a51bd52b7998b89ef46e8384fdb045c0fbdaa4b925b06689af8e99";
        homepage = "http://github.com/gcross/Blueprint";
        description = "Preview of a new build system";
        license = stdenv.lib.licenses.bsd3;
@@ -1688,7 +1689,7 @@ self: {
      mkDerivation {
        pname = "Bookshelf";
        version = "0.4";
-       sha256 = "1h23ncphq717xqvg3bhij0ypmi6whm0aibhmiwak71sjkzv604in";
+       sha256 = "361260f69f528733158f15aea84085dcc47a3d9011aef136ee271c0c2fb343c0";
        isLibrary = false;
        isExecutable = true;
        executableHaskellDepends = [
@@ -1707,7 +1708,7 @@ self: {
      mkDerivation {
        pname = "Boolean";
        version = "0.2.3";
-       sha256 = "1lsm06y7hgjp9qmlr6csf24x3wgna7sbf8dgh6sfl2rhs7fn8kgn";
+       sha256 = "f64d64ddd1300beab481af21b7f451f6f1d189709a994c2b4e573e78bc0155d3";
        libraryHaskellDepends = [ base ];
        description = "Generalized booleans and numbers";
        license = stdenv.lib.licenses.bsd3;
@@ -1718,7 +1719,7 @@ self: {
      mkDerivation {
        pname = "BoundedChan";
        version = "1.0.3.0";
-       sha256 = "0vf4mlw08n056g5256cf46m5xsijng5gvjx7ccm4r132gznyl72k";
+       sha256 = "531ceaed7f62844c2a63a7cbfdcab332ea5eaa218e9922ca3305580438adc46d";
        libraryHaskellDepends = [ array base ];
        description = "Implementation of bounded channels";
        license = stdenv.lib.licenses.bsd3;
@@ -1731,7 +1732,7 @@ self: {
      mkDerivation {
        pname = "Bravo";
        version = "0.1.0.1";
-       sha256 = "16li42rl77jvhyp14fjic66c7d6qm2fjln93gyw4bqbykai291in";
+       sha256 = "368624a29a7ee145b87f23592a9da8d8b4c38c61513a12ae875b9e43b320919a";
        libraryHaskellDepends = [
          base haskell-src-exts haskell-src-meta mtl parsec syb
          template-haskell
@@ -1748,7 +1749,7 @@ self: {
      mkDerivation {
        pname = "BufferedSocket";
        version = "0.2.0.0";
-       sha256 = "0sgwglnzsqwz1k11jbzp7lpb29h9ap2mny2lv9m9nrlr0ydhcdqf";
+       sha256 = "0e37069b0799669b6ada54785bc5550926b12e3df72f19c20c9f63fd2d7dfc69";
        libraryHaskellDepends = [ base bytestring network text ];
        jailbreak = true;
        description = "A socker wrapper that makes the IO of sockets much cleaner";
@@ -1764,7 +1765,7 @@ self: {
      mkDerivation {
        pname = "Buster";
        version = "0.1.1";
-       sha256 = "12zchy3sqdcqdgbb7d29jrsqifz4hfdx94s514v2mmyzzr0m8xqd";
+       sha256 = "0d775441fedfd72a36094593d49b83e4bb88759649b4b3d66b9835ac8787ec8b";
        isLibrary = false;
        isExecutable = true;
        executableHaskellDepends = [
@@ -1790,7 +1791,7 @@ self: {
      mkDerivation {
        pname = "CBOR";
        version = "0.1.0.1";
-       sha256 = "03h8lp5sm8prbphq98c7ar93rl9yfy29pvwrkrskdjhx79pd1w6q";
+       sha256 = "d8f0d06e3a1dca36759e99ef9b84773ed13c525687a184e15df9a2aacba5080e";
        libraryHaskellDepends = [
          base binary binary-bits bytestring data-binary-ieee754
        ];
@@ -1809,7 +1810,7 @@ self: {
      mkDerivation {
        pname = "CC-delcont";
        version = "0.2";
-       sha256 = "0bl71vj1ypzplx92kz27hhbpnwnxkz5g2q86m4fcmjmp4fym8kc1";
+       sha256 = "814d54bd23b7caca1ca90661f1ca9fdd727b178447fc2952a7f75f1fe40e872e";
        libraryHaskellDepends = [ base mtl ];
        homepage = "http://code.haskell.org/~dolio/CC-delcont";
        description = "Delimited continuations and dynamically scoped variables";
@@ -1824,7 +1825,7 @@ self: {
      mkDerivation {
        pname = "CC-delcont-alt";
        version = "0.1.1.1";
-       sha256 = "0s6z5bcxmcx1vzgjc6r2i4898j6s3ngjjdqhggp893hmhpxlbgsv";
+       sha256 = "5bbf45fb85158e84ee7b1037299f1dda48941089221b26dfdfa1b3dad92adf68";
        libraryHaskellDepends = [
          base CC-delcont-cxe CC-delcont-exc CC-delcont-ref mtl
        ];
@@ -1839,7 +1840,7 @@ self: {
      mkDerivation {
        pname = "CC-delcont-cxe";
        version = "0.1.0.2";
-       sha256 = "1s6bql9r78yfzgarm3i4f2glhc5w8qq91adhs15cnqj6h7768a5c";
+       sha256 = "ac2864ce814662cb4ad0b0a9903046bc30489f70248e9ad5fbcea39313c5cbe8";
        libraryHaskellDepends = [ base mtl ];
        description = "A monad transformers for multi-prompt delimited control";
        license = stdenv.lib.licenses.bsd3;
@@ -1851,7 +1852,7 @@ self: {
      mkDerivation {
        pname = "CC-delcont-exc";
        version = "0.1.0.0";
-       sha256 = "07v388bzs8x9k1p677310rbh8baj1fdq3bhbqyvxqzx93kv8g381";
+       sha256 = "018d87f61ca97fdcb7c70bae819b0b522d045706619c636e98a923fd1742631f";
        libraryHaskellDepends = [ base mtl ];
        description = "A monad transformers for multi-prompt delimited control";
        license = stdenv.lib.licenses.bsd3;
@@ -1863,7 +1864,7 @@ self: {
      mkDerivation {
        pname = "CC-delcont-ref";
        version = "0.1.0.0";
-       sha256 = "0fzjr73id8rlrcmf0j3y1qn4jnc8incqhhkp9wl35lig20kqy82m";
+       sha256 = "55208f27102fd232284f774288998d8859492c0e7e48e02acb34a316c7c9f23b";
        libraryHaskellDepends = [ base mtl ];
        description = "A monad transformers for multi-prompt delimited control using refercence cells";
        license = stdenv.lib.licenses.bsd3;
@@ -1875,7 +1876,7 @@ self: {
      mkDerivation {
        pname = "CC-delcont-ref-tf";
        version = "0.1.0.2";
-       sha256 = "0zavw824xcr1jhmlpz9hmabhhi459y0s7z434lxalzha01j1wfih";
+       sha256 = "303a1e64000a7eaa3a2583fca3814f85440897aa30fd4b2b9421b34e04e25b7d";
        libraryHaskellDepends = [ base ref-tf transformers ];
        description = "A monad transformers for multi-prompt delimited control using refercence cells";
        license = stdenv.lib.licenses.bsd3;
@@ -1889,7 +1890,7 @@ self: {
      mkDerivation {
        pname = "CCA";
        version = "0.1.5.3";
-       sha256 = "05zv1vha31fgw4ddvrnbvk5pzhq8lkvfx1xrgja5ggy451zrs6aw";
+       sha256 = "5c199d7f28c4bf57947cb987eef6a408c37fcbdccbe6dd1ae1cf85a1e00efb17";
        isLibrary = true;
        isExecutable = true;
        libraryHaskellDepends = [ base ghc-prim syb template-haskell ];
@@ -1906,7 +1907,7 @@ self: {
      mkDerivation {
        pname = "CHXHtml";
        version = "0.2.0";
-       sha256 = "0pr2mvcnrz3240wnpd44g3pz9x8am6vhhfvl0lyl129kvc33v99q";
+       sha256 = "38a53d06db3389403d05743b08b7a90af5f4ef7884b46b392062fc6cd9ae225f";
        libraryHaskellDepends = [
          base bytestring hxt-regex-xmlschema utf8-string
        ];
@@ -1922,7 +1923,7 @@ self: {
      mkDerivation {
        pname = "CLASE";
        version = "2009.2.11";
-       sha256 = "10jab7jxlhppmqqw31g653l8jmz4vz8f9h9wr2i9fjf6bipvgfi3";
+       sha256 = "23bab76f5cc64997a2c83cc1e4d0dfe45789e828e685c131aef742dae5594a82";
        libraryHaskellDepends = [
          base containers filepath mtl parsec template-haskell
        ];
@@ -1937,7 +1938,7 @@ self: {
      mkDerivation {
        pname = "CLI";
        version = "0.1.0.0";
-       sha256 = "1g271n7z6xndqylwxwcaa1xscgd36wzb2apbmrilv42v7ii4aall";
+       sha256 = "942a45623c5b904d63aeeb2ab13e37a33da67b508af1cea9c7cd76f38f0d47bc";
        libraryHaskellDepends = [ base directory split time ];
        testHaskellDepends = [ base doctest ];
        jailbreak = true;
@@ -1952,7 +1953,7 @@ self: {
      mkDerivation {
        pname = "CMCompare";
        version = "0.0.1.5";
-       sha256 = "1ccjyn0cc8yx7fgnvsjap0swlxql3gdygb5mabzvkgk84zc3bh2b";
+       sha256 = "4bc035d82768beb9ff52b5ace7db1b1477ca35b84aea6d9f3bdd23c680f592b1";
        isLibrary = true;
        isExecutable = true;
        libraryHaskellDepends = [
@@ -1973,7 +1974,7 @@ self: {
      mkDerivation {
        pname = "CMQ";
        version = "0.0.12";
-       sha256 = "0zskbcjdd4s8bkll7jvb8qzyq8pa52li4db9r5wg16pd2l3m0fpb";
+       sha256 = "eb3a500715ed9af078c9693512a928ea22ec3f466bcb43e95c4893d6245b537f";
        libraryHaskellDepends = [
          base bytestring cereal containers iproute mtl network PSQueue stm
          time
@@ -1988,7 +1989,7 @@ self: {
      mkDerivation {
        pname = "COrdering";
        version = "2.3";
-       sha256 = "1lkav4wkyrraq1f6kyqfyjrxasgkayg4hmyv8a1gkr4h484b1cx8";
+       sha256 = "a8b3b0082290e4f98242db57489e57f369d5b3f40efb695cc02a673f39d96ad2";
        libraryHaskellDepends = [ base ];
        description = "An algebraic data type similar to Prelude Ordering";
        license = stdenv.lib.licenses.bsd3;
@@ -2000,7 +2001,7 @@ self: {
      mkDerivation {
        pname = "CPBrainfuck";
        version = "1.1";
-       sha256 = "041bm02xar8g6ppz6g0fdgs4ywavlcn4pqkncydx0lw5wp9ygwwn";
+       sha256 = "96f3e7d3e58553d09b6776e24b2ca35b714ff46b0e3cf3ef350f65d505a82b10";
        isLibrary = false;
        isExecutable = true;
        executableHaskellDepends = [ base haskell98 ];
@@ -2014,7 +2015,7 @@ self: {
      mkDerivation {
        pname = "CPL";
        version = "0.0.7";
-       sha256 = "1hm2slnvcp1fqdrgx505wkj3w511x9896h2hj9riyky6vg2mzgr7";
+       sha256 = "27bf5fc5dbc64f1f739250409350ea21143ee4e40594fe72c32e5cb62dd5a2c2";
        isLibrary = false;
        isExecutable = true;
        executableHaskellDepends = [
@@ -2030,7 +2031,7 @@ self: {
      mkDerivation {
        pname = "CSPM-CoreLanguage";
        version = "0.3.0.3";
-       sha256 = "0vr6zpdz5lnpkyzwhig72pv8ncvqdjyp1nn76zpx3v6xlpzrs3q2";
+       sha256 = "020f9dffa5ddecd1ef37c7da70bd6c78338bf615e745c8bf9fd7d2f2dbfd266f";
        libraryHaskellDepends = [ base ];
        description = "Definition of a FDR-compatible CSP core-language";
        license = stdenv.lib.licenses.bsd3;
@@ -2043,7 +2044,7 @@ self: {
      mkDerivation {
        pname = "CSPM-FiringRules";
        version = "0.4.3.0";
-       sha256 = "0rdggf00zq51j4af6rhk4ix8rbpd82piy2al4m6ymziwflv3b70m";
+       sha256 = "159c3536753cfeea4d2554091faf40edae8c7a241366e31491a1e00f807baf65";
        libraryHaskellDepends = [
          base containers CSPM-CoreLanguage mtl parallel-tree-search
          QuickCheck random tree-monad
@@ -2061,7 +2062,7 @@ self: {
      mkDerivation {
        pname = "CSPM-Frontend";
        version = "0.10.0.0";
-       sha256 = "0wmfk9givv604ajzkg60586lz08xqcx60bnqgslpfzkh458mz9z3";
+       sha256 = "e3a75f5121707e77a97ed82e603ac31d814f0d2ac0bcf9a522c0ec1d5f9aae72";
        libraryHaskellDepends = [
          array base containers dlist either ghc-prim mtl parsec2 prettyclass
          syb transformers
@@ -2080,7 +2081,7 @@ self: {
      mkDerivation {
        pname = "CSPM-Interpreter";
        version = "0.7.0.0";
-       sha256 = "0shf0bb4zqnxvclsavvxnsy697xbl5q1xjqww8makps6dirwk0qn";
+       sha256 = "1683c9736c46dfa92ae21ccb1e70a1ab9f64bcb67d6fa529dbdde24fd6020e6a";
        libraryHaskellDepends = [
          array base containers CSPM-CoreLanguage CSPM-Frontend mtl
          prettyclass syb
@@ -2098,7 +2099,7 @@ self: {
      mkDerivation {
        pname = "CSPM-ToProlog";
        version = "0.5.2.0";
-       sha256 = "0qy2zdxgdm9vacm2ickf1lvyj6wrcnpifaxgh25apg9j9v6g0h12";
+       sha256 = "2240f0cc4e32bdab8a80af2b17af65991be9370d6eb2282a533bd5f67afbc263";
        libraryHaskellDepends = [
          array base containers CSPM-Frontend ghc-prim pretty
        ];
@@ -2116,7 +2117,7 @@ self: {
      mkDerivation {
        pname = "CSPM-cspm";
        version = "0.8.0.0";
-       sha256 = "1lhfq8gjls2g3xwskwa7vx1kj6n83b4msx4fc6769li4r2xn1bc9";
+       sha256 = "89ad60bbc824d2648e618e745dc91ac81a3943df47f1a9791f4f682a1fc20ed2";
        isLibrary = true;
        isExecutable = true;
        libraryHaskellDepends = [
@@ -2142,7 +2143,7 @@ self: {
      mkDerivation {
        pname = "CTRex";
        version = "0.6";
-       sha256 = "0cjinznkvdrswbqrsha49b6hch7sjv2qq9xllx780klf01kdahi6";
+       sha256 = "2642d566008e4e804ea7b4278cc596fa4006cd4a44419df1e23ab73dedb75132";
        libraryHaskellDepends = [
          base containers hashable mtl unordered-containers
        ];
@@ -2163,7 +2164,7 @@ self: {
      mkDerivation {
        pname = "CV";
        version = "0.3.7";
-       sha256 = "0c200jn6q4y744k39jll7xw418js7y86vvihz49i8kk2316vakmr";
+       sha256 = "b94eb54d18624e1413f930ee6d903f5aa240783f94ca342621c7136cac044030";
        libraryHaskellDepends = [
          array base binary bindings-DSL carray containers deepseq directory
          filepath lazysmallcheck mtl mwc-random parallel parallel-io
@@ -2195,7 +2196,7 @@ self: {
      mkDerivation {
        pname = "Cabal";
        version = "1.18.1.6";
-       sha256 = "15nn6f8bnqzy7pqxb45hdf30qid2hw608dcqgmwrcfrd8zrrvylw";
+       sha256 = "9cfa9df3472d3b96797d9835040c87a2450c866bb090d5f13dfe63bb9033d696";
        libraryHaskellDepends = [
          array base bytestring containers deepseq directory filepath pretty
          process time unix
@@ -2220,7 +2221,7 @@ self: {
      mkDerivation {
        pname = "Cabal";
        version = "1.20.0.3";
-       sha256 = "0vq1xcwvvk74jkzp7386ldyrls8qszg3rj4l37fyq3fvjkqnx80v";
+       sha256 = "1ba06ef194db0decdd1994c83cded718699a7da3068d73ff94e4ccbd39eb016f";
        libraryHaskellDepends = [
          array base bytestring containers deepseq directory filepath pretty
          process time unix
@@ -2246,7 +2247,7 @@ self: {
      mkDerivation {
        pname = "Cabal";
        version = "1.22.4.0";
-       sha256 = "19nwapy5rvsrk8jc75ql5klp8hikzrwd3c5x07nisl73d2r8ssmr";
+       sha256 = "b96a8db268e3501ded01bdb0d178fe334274e92c1497c3249a59ef5cfc55dca6";
        libraryHaskellDepends = [
          array base binary bytestring containers deepseq directory filepath
          pretty process time unix
@@ -2272,7 +2273,7 @@ self: {
      mkDerivation {
        pname = "Cabal-ide-backend";
        version = "1.23.0.0";
-       sha256 = "07s9gkq2d4sz8nrjayrnb3gbjm58sp7gfl3hnl8n1gsxsfbl2cgw";
+       sha256 = "fc314197d35dbf6011b57050f7ced5a854b9de58367b25b3455f9326f07c491f";
        libraryHaskellDepends = [
          array base binary bytestring containers deepseq directory filepath
          pretty process time unix
@@ -2295,7 +2296,7 @@ self: {
      mkDerivation {
        pname = "CabalSearch";
        version = "0.0.2";
-       sha256 = "181k2rybbyhjmwf1fq69hiaf14a0rzcvnv4j9w03n2v7cal4k08b";
+       sha256 = "0b8149a862670b3b004f926cbbd9cf4091e05484c960171caf12fab57c1633a0";
        isLibrary = false;
        isExecutable = true;
        executableHaskellDepends = [
@@ -2312,7 +2313,7 @@ self: {
      mkDerivation {
        pname = "Capabilities";
        version = "0.1.0.0";
-       sha256 = "0nd5yvhbxmabs0890y9gjjiq37h8c3blpplv2m13k29zkijwad04";
+       sha256 = "0434c5659c3f893942159bde4bd760089e81a3942f799010d04bd5bee0f6a559";
        libraryHaskellDepends = [ base compdata directory free unix ];
        jailbreak = true;
        homepage = "https://github.com/Icelandjack/Capabilities";
@@ -2326,7 +2327,7 @@ self: {
      mkDerivation {
        pname = "Cardinality";
        version = "0.2";
-       sha256 = "01bp045vl08sixvi6h0i21vvmjirnyzlmwxx8yq5njbcxrgbq6dn";
+       sha256 = "b619bc5eee6c495bb047bdf34abfb739caba7710114013778f1a01ba0b017705";
        libraryHaskellDepends = [ base containers mtl ];
        description = "Measure container capacity. Use it to safely change container.";
        license = "LGPL";
@@ -2337,7 +2338,7 @@ self: {
      mkDerivation {
        pname = "CarneadesDSL";
        version = "1.3";
-       sha256 = "06ri47cfskvpm65zb63kjrwwhzlmcp2f0z99hqkfw216p85648a3";
+       sha256 = "4321620aba2608ee2686297de0c465957ec879967398f58ba9774fedd821311b";
        libraryHaskellDepends = [ base containers fgl parsec ];
        homepage = "http://www.cs.nott.ac.uk/~bmv/CarneadesDSL/";
        description = "An implementation and DSL for the Carneades argumentation model";
@@ -2350,7 +2351,7 @@ self: {
      mkDerivation {
        pname = "CarneadesIntoDung";
        version = "1.0";
-       sha256 = "0gmrc778zan5rrkb7rip61736rzx13abfzyjcj4bgdvc3fhih1rx";
+       sha256 = "3d0718a11b6cb7b78864d27fb7d408fd67334e3037e6b366cec5aa8fce61b93e";
        isLibrary = true;
        isExecutable = true;
        libraryHaskellDepends = [
@@ -2366,7 +2367,7 @@ self: {
      mkDerivation {
        pname = "Cascade";
        version = "0.1.0.0";
-       sha256 = "1ih8ydc29axckgidc5xvsdac5558gprscw667msh8qh41j9sshng";
+       sha256 = "cf42ad930c046204753dc670a6f37da894c254d3bb17d6e29bacab2458f308c6";
        libraryHaskellDepends = [ base comonad ghc-prim mtl void ];
        jailbreak = true;
        homepage = "http://github.com/rampion/Cascade";
@@ -2380,7 +2381,7 @@ self: {
      mkDerivation {
        pname = "Catana";
        version = "0.3";
-       sha256 = "10m7l701p3a2w0kxi2b93g2ii6s4s71zyjypqk3mi79siv8yilif";
+       sha256 = "2ed2e8d18e3a9d58c7c4d74bffc3d1449b18c51b6989d827e0428d1bc0a1a782";
        libraryHaskellDepends = [ base mtl ];
        description = "A monad for complex manipulation of a stream";
        license = stdenv.lib.licenses.bsd3;
@@ -2394,7 +2395,7 @@ self: {
      mkDerivation {
        pname = "Chart";
        version = "1.5.1";
-       sha256 = "0jm1wr2nb1r8rxqc564nmnclns160y7girc7j2ihvyhm0v34p59g";
+       sha256 = "2f954bc60615fa0da39087e5f88e0726684b99ad9698c270cf28876545e6a14a";
        libraryHaskellDepends = [
          array base colour data-default-class lens mtl old-locale
          operational time vector
@@ -2411,7 +2412,7 @@ self: {
      mkDerivation {
        pname = "Chart-cairo";
        version = "1.5.1";
-       sha256 = "1fwjgms76z2spgfw3kfmzivkgp6gdkx24mp5nb562kza4y6yjz7f";
+       sha256 = "ee7ce98d27ea4f61cab2e55622fa6ccfdc3777fcd5cdc1ddbb5a7c73747d92bb";
        libraryHaskellDepends = [
          array base cairo Chart colour data-default-class lens mtl
          old-locale operational time
@@ -2430,7 +2431,7 @@ self: {
      mkDerivation {
        pname = "Chart-diagrams";
        version = "1.5.1";
-       sha256 = "1slsq9p9mq9jxlyhpd90bh32s6fqvy149p4cb7ckygzd77r1aqxz";
+       sha256 = "bf6315f239ed3f3fd9598cdc4482dfd8192d065c20b50b3ded32e19a6ec29aea";
        libraryHaskellDepends = [
          base blaze-markup bytestring Chart colour containers
          data-default-class diagrams-core diagrams-lib diagrams-postscript
@@ -2450,7 +2451,7 @@ self: {
      mkDerivation {
        pname = "Chart-gtk";
        version = "1.5.1";
-       sha256 = "025snbbsnd2gsldw2j8r3vxh94jrv57h8z4qvkq3dwyh2mvq21lw";
+       sha256 = "9c06817715d0f336f0dc987c044fd9599204fb1e1949c11bd54f34abd7b2ba08";
        libraryHaskellDepends = [
          array base cairo Chart Chart-cairo colour data-default-class gtk
          mtl old-locale time
@@ -2467,7 +2468,7 @@ self: {
      mkDerivation {
        pname = "Chart-simple";
        version = "1.3.3";
-       sha256 = "0kk81jz4lciga8qc78gm9khw02n84snyclzf5lcmlz9rs50z3v5r";
+       sha256 = "b9ecf141d1397d5a192dee53e6ad26c80ac0e14cf5a1c330522f324abe0c684e";
        libraryHaskellDepends = [
          array base cairo Chart Chart-cairo Chart-gtk colour
          data-default-class gtk mtl old-locale time
@@ -2485,7 +2486,7 @@ self: {
      mkDerivation {
        pname = "ChasingBottoms";
        version = "1.3.0.13";
-       sha256 = "1fb86jd6cdz4rx3fj3r9n8d60kx824ywwy7dw4qnrdran46ja3pl";
+       sha256 = "f40e250db12ab76c31e1ed78ce3d11a84f601ab2290fe946cfe437669a3468b9";
        libraryHaskellDepends = [
          base containers mtl QuickCheck random syb
        ];
@@ -2501,7 +2502,7 @@ self: {
      mkDerivation {
        pname = "CheatSheet";
        version = "2.9";
-       sha256 = "1pw6sssdmxpsjclkhsaf1b06vlimi4w11rxy65ccyj8c9zgs2g23";
+       sha256 = "433ca1df4f0c49cf5831bee710388935d26dc00a4e69382993faf6dab4d686df";
        isLibrary = false;
        isExecutable = true;
        executableHaskellDepends = [ base containers directory ];
@@ -2515,7 +2516,7 @@ self: {
      mkDerivation {
        pname = "Checked";
        version = "0.0.0.2";
-       sha256 = "1mr323rhh3lr6a5ni60n2kxz2k57763a3rrf7c6i18hxs9d4w2s4";
+       sha256 = "440b4e5ad21da2100d3b2ee7a18639a74cf1fb141698688b32990e08f31023d7";
        libraryHaskellDepends = [ base text ];
        jailbreak = true;
        description = "Inbuilt checking for ultra reliable computing";
@@ -2527,7 +2528,7 @@ self: {
      mkDerivation {
        pname = "Chitra";
        version = "0.2.2";
-       sha256 = "0qf6a1xmpv29hpwcrn3acfvpcx0f95dq980mv5mijzfsznz4d43k";
+       sha256 = "739046befdda7d196bd915a0845b490e7476b7636ad8ccf88549ec5b7b50c661";
        isLibrary = false;
        isExecutable = true;
        executableHaskellDepends = [ base binary bytestring mtl network ];
@@ -2544,7 +2545,7 @@ self: {
      mkDerivation {
        pname = "ChristmasTree";
        version = "0.2.1.1";
-       sha256 = "1xng99msiyck127zv12cbksgyprwr6i6nwwjplc9c0jdfiisa9n8";
+       sha256 = "c826a563744d029618bd92736ba2c93c5ffff45c4c84fd8f0893f9a86b4acff6";
        libraryHaskellDepends = [
          base containers fgl template-haskell TTTAS uulib
        ];
@@ -2560,7 +2561,7 @@ self: {
      mkDerivation {
        pname = "CirruParser";
        version = "0.0.1";
-       sha256 = "111ccwiszrjy54y5hincyvjj97kmar9n26bbn902qa9jd9y9k3g9";
+       sha256 = "e98d997c6a32292c40b26b19615356759e24e5f6cc46583c295ee6af23672c84";
        libraryHaskellDepends = [ aeson base text vector ];
        homepage = "https://github.com/Cirru/parser.hs";
        description = "Cirru Parser in Haskell";
@@ -2572,7 +2573,7 @@ self: {
      mkDerivation {
        pname = "ClassLaws";
        version = "0.3.1.0";
-       sha256 = "1277vn384hpxd7xnzg0gpr7ilnw5cqhsi11c24g9zsfqa36llwgk";
+       sha256 = "f3714acd50d8e99f1e112c84a82166855b1a4fbe0fbc6ffb69fd428286dde788";
        libraryHaskellDepends = [ base ChasingBottoms mtl QuickCheck ];
        jailbreak = true;
        homepage = "http://wiki.portal.chalmers.se/cse/pmwiki.php/FP/ClassLaws";
@@ -2586,7 +2587,7 @@ self: {
      mkDerivation {
        pname = "ClassyPrelude";
        version = "0.1";
-       sha256 = "1yvkrzd3l7ijh3fqvkbzqv5vp4nv5z26fbxy91sfwh3zqlscpim9";
+       sha256 = "a9c6cb34c57f40ee7448be2f67c42fdb92bbcbc67fcd8ddd80321e3adacf73fb";
        libraryHaskellDepends = [ base strict ];
        description = "Prelude replacement using classes instead of concrete types where reasonable";
        license = stdenv.lib.licenses.bsd3;
@@ -2598,7 +2599,7 @@ self: {
      mkDerivation {
        pname = "Clean";
        version = "0.6";
-       sha256 = "0kr9i13ch2wbcnxchrnx562r8ar7kb84gmk3cqxc40x5w416205f";
+       sha256 = "ae006102e1a503c23a6663d647d09a272b948529dd66c8ba658b0bc84688294f";
        libraryHaskellDepends = [ base containers ];
        jailbreak = true;
        description = "A light, clean and powerful utility library";
@@ -2611,7 +2612,7 @@ self: {
      mkDerivation {
        pname = "Clipboard";
        version = "2.2.0.3";
-       sha256 = "0qpcfgpfgw426v4040ch63pc2zl7amd2ljapx4xv0j4hwc4rsqz3";
+       sha256 = "e3639d09e39048b03be957492a5a55877ec1ee30900102c83682f0e7ee73ec62";
        libraryHaskellDepends = [ base ];
        homepage = "http://haskell.org/haskellwiki/Clipboard";
        description = "System clipboard interface";
@@ -2625,7 +2626,7 @@ self: {
      mkDerivation {
        pname = "ClustalParser";
        version = "1.1.3";
-       sha256 = "1xblyxmwbhmfkm2d2a87qnryk6mg5n1zarzr9d3xjh9qx3mbbclb";
+       sha256 = "8bb2b5eae83841d9474bf967f5832daf9ae9b3c50729d1449daec2c56bf774f5";
        isLibrary = true;
        isExecutable = true;
        libraryHaskellDepends = [ base parsec vector ];
@@ -2643,7 +2644,7 @@ self: {
      mkDerivation {
        pname = "Coadjute";
        version = "0.1.1";
-       sha256 = "1crbs8dk93cff252c3nj2brdbjbfygpvlrm4lrp7vpnwfz2709b3";
+       sha256 = "632570c477dcde7d6ea6a466baeff36ec9d5f212d20e268a708e8d341bd22bb3";
        libraryHaskellDepends = [
          array base bytestring bytestring-csv containers directory fgl
          filepath mtl old-time pretty pureMD5 safe utf8-string
@@ -2660,7 +2661,7 @@ self: {
      mkDerivation {
        pname = "Codec-Compression-LZF";
        version = "0.2";
-       sha256 = "0jj2iaa632s60dckj8s46g4vrlqc8x9fndkq0kzk8rk4jzwlbwsn";
+       sha256 = "56f345f997646634ff047836eb52470cd3bcc9334423395903468b61948a424a";
        libraryHaskellDepends = [ base ];
        homepage = "http://www.cs.helsinki.fi/u/ekarttun/Codec-Compression-LZF/";
        description = "LZF compression bindings";
@@ -2672,7 +2673,7 @@ self: {
      mkDerivation {
        pname = "Codec-Image-DevIL";
        version = "0.2.3";
-       sha256 = "1kv3hns9f0bhfb723nj9szyz3zfqpvy02azzsiymzjz4ajhqmrsz";
+       sha256 = "5fe78aa154e4cb5f7dd4ff2b01fcbed8fdf1fdd749da21ce72700197b48563cf";
        libraryHaskellDepends = [ array base ];
        librarySystemDepends = [ libdevil ];
        description = "An FFI interface to the DevIL library";
@@ -2690,7 +2691,7 @@ self: {
      mkDerivation {
        pname = "Combinatorrent";
        version = "0.3.2";
-       sha256 = "0dx5pysxyk5c0fa33khjr86zgm43jz7nwhgl0w8jngyai8b1rbra";
+       sha256 = "2aaf1c168aca3f2b1107f4416ecf9783d4f70dca12ce319403ac4cdfb5bfa537";
        isLibrary = false;
        isExecutable = true;
        executableHaskellDepends = [
@@ -2710,7 +2711,7 @@ self: {
      mkDerivation {
        pname = "Command";
        version = "0.0.7";
-       sha256 = "043dwvjkc1m2cz0rgiib7gv19ds1vn4cmf27lyw68nmc0lcm2v3d";
+       sha256 = "6d6c511905ac5a64b8a747b8ca88dd41b714f63b2bc697c167a20636e5e66d10";
        libraryHaskellDepends = [ base directory process ];
        homepage = "https://github.com/tonymorris/command";
        description = "A replacement for System.Exit and System.Process";
@@ -2724,7 +2725,7 @@ self: {
      mkDerivation {
        pname = "Commando";
        version = "1.0.0.4";
-       sha256 = "1wfpxaj9j68knf1fp3zngxrc1acqvhzrzbblar4ckq9y5kxjwwsj";
+       sha256 = "52732efb2c3ee1c9485674ad9f3fdc98a9c0727ff68feb82b3131999a4ead7f1";
        isLibrary = true;
        isExecutable = true;
        libraryHaskellDepends = [
@@ -2750,7 +2751,7 @@ self: {
      mkDerivation {
        pname = "ComonadSheet";
        version = "0.3.0.0";
-       sha256 = "1jpxc5ymhjdk18nggw9fjr6dmqhlz0jwwailyw9i8yzs5dzbn67z";
+       sha256 = "ff18bb7e2bfa7b1413f7342ace25f814e2da4c962ef1f72c0ab349587d61fdca";
        libraryHaskellDepends = [
          applicative-numbers base comonad containers distributive
          IndexedList NestedFunctor PeanoWitnesses Stream Tape transformers
@@ -2769,7 +2770,7 @@ self: {
      mkDerivation {
        pname = "ConcurrentUtils";
        version = "0.4.2.0";
-       sha256 = "1bxw8jrniczwc0pprva7zp6kzzrp5cj05r19j024fbgfw6vq9xz4";
+       sha256 = "e4f784b7e1ee2d47049029e402242b37ff3fcdfd47ed7c2f60fcb368b344bcaf";
        libraryHaskellDepends = [
          array base binary bytestring containers crypto-random cryptohash
          network parallel process reexport-crypto-random RSA securemem
@@ -2786,7 +2787,7 @@ self: {
      mkDerivation {
        pname = "Concurrential";
        version = "0.5.0.0";
-       sha256 = "1fcl1ckinzv9c0iyfvhh3sm649jn7q8yv2r9vz99l139dw25l5vb";
+       sha256 = "6b175a046f69049ad2df298bed113e562662aa1e106ee72360697f1b270b94b9";
        libraryHaskellDepends = [ async base ];
        jailbreak = true;
        homepage = "http://github.com/avieth/Concurrential";
@@ -2801,7 +2802,7 @@ self: {
      mkDerivation {
        pname = "Condor";
        version = "0.3";
-       sha256 = "0vrflmjyc1h0mfvc07p3p3wqfscyza7pyxxp7bn1glprg6c9ph5p";
+       sha256 = "b7c09b9879f9d217ec3ab7777f8ffa9e6987f9b8e31ec0b6ab0006e665a52e6f";
        isLibrary = true;
        isExecutable = true;
        libraryHaskellDepends = [ base binary containers glider-nlp text ];
@@ -2823,7 +2824,7 @@ self: {
      mkDerivation {
        pname = "ConfigFile";
        version = "1.1.4";
-       sha256 = "057mw146bip9wzs7j4b5xr1x24d8w0kr4i3inri5m57jkwspn25f";
+       sha256 = "ae087b359ff2945a62b671449227e0a811d143ee651179f4e7e9c66548e0f514";
        isLibrary = true;
        isExecutable = true;
        libraryHaskellDepends = [ base containers MissingH mtl parsec ];
@@ -2837,7 +2838,7 @@ self: {
      mkDerivation {
        pname = "ConfigFileTH";
        version = "0.2";
-       sha256 = "1349vkrnl2z0cfcvdalqf77jajhz0izmnlsbiv84vvj23n04rj9h";
+       sha256 = "30c94c801d42ee4dd08e4b535b7f041f4a25cf7198aab69963e00b6af3dc898c";
        libraryHaskellDepends = [
          base ConfigFile parsec template-haskell
        ];
@@ -2850,7 +2851,7 @@ self: {
      mkDerivation {
        pname = "Configger";
        version = "0.1";
-       sha256 = "0fk7165abh4rw4jk6wy4f6y0qpakxlrs4mwrs3r2q7lz03jsyig2";
+       sha256 = "e245afe5009f1e2cf2d09957a233ed535d0cbc71c4733325e199c0a58a09673a";
        libraryHaskellDepends = [ base Dangerous MissingH mtl parsec ];
        description = "Parse config files";
        license = stdenv.lib.licenses.mit;
@@ -2862,7 +2863,7 @@ self: {
      mkDerivation {
        pname = "Configurable";
        version = "0.1.0.0";
-       sha256 = "1if0hff6fn7zjj1vh16gxf2kldibh1dkscm8n33d1admvpjpw9sb";
+       sha256 = "4b277ee5ddb5a9d0c6b0a8323d5b802b363a85ebcf04b88394ff58679c83c0c5";
        libraryHaskellDepends = [ base ];
        jailbreak = true;
        homepage = "https://github.com/tel/Configurable";
@@ -2875,7 +2876,7 @@ self: {
      mkDerivation {
        pname = "ConsStream";
        version = "0.1";
-       sha256 = "1ywhrj2wq24my4cji5fm5cwb3j4yjwzch9hxncr7k989smjdmjpz";
+       sha256 = "ffcada64d509a57932b31d26c83e979ec8b1382bd5952819f19508cc85cc90fb";
        libraryHaskellDepends = [ base Stream ];
        homepage = "github";
        description = "Trivial re-export of Wouter Swierstra's Stream package, avoiding module name clash";
@@ -2887,7 +2888,7 @@ self: {
      mkDerivation {
        pname = "Conscript";
        version = "0.1.0.0";
-       sha256 = "0hiz3wjnvfp9n440kmwq7a88k7m7vq5s49nq85v520j7qnf4y82n";
+       sha256 = "56204f9cc54702517641d826a20bdea79e89903a98d70908b1e9ba6d251f3f42";
        isLibrary = false;
        isExecutable = true;
        executableHaskellDepends = [ base process ];
@@ -2902,7 +2903,7 @@ self: {
      mkDerivation {
        pname = "ConstraintKinds";
        version = "1.3.0";
-       sha256 = "0rhy5wq3v5hdryjn8pcsgqy4k772agj1rgq3021pjki7n3zm3dza";
+       sha256 = "eab751ffb0274e79830003bf1ce453e29c493c7e9a5d64a5cf0d963d302f1e66";
        libraryHaskellDepends = [ base dlist ghc-prim vector ];
        jailbreak = true;
        description = "Repackages standard type classes with the ConstraintKinds extension";
@@ -2914,7 +2915,7 @@ self: {
      mkDerivation {
        pname = "Consumer";
        version = "1.2";
-       sha256 = "03ham35vh49h780h7dxb6zs85rkdlry0nwi8wp6p9iamw952xi6i";
+       sha256 = "d1c42e4ae255c574cde528720b7ca66de682f437abb703013a3011b8cba80a0e";
        libraryHaskellDepends = [ base mtl ];
        homepage = "http://src.seereason.com/ghc6103/haskell-consumer";
        description = "A monad and monad transformer for consuming streams";
@@ -2927,7 +2928,7 @@ self: {
      mkDerivation {
        pname = "ContArrow";
        version = "0.0.5";
-       sha256 = "1paj8wx2k86i5xb11scbyca4fb2fnxgln5d661mcwxvs0i91jj1b";
+       sha256 = "2b481952047a77ce6a30a6154b5fb74e2c4714f38be910562fd1a0293a4752dd";
        libraryHaskellDepends = [ arrows base ];
        jailbreak = true;
        description = "Control.Arrow.Transformer.Cont";
@@ -2939,7 +2940,7 @@ self: {
      mkDerivation {
        pname = "Contract";
        version = "0.1";
-       sha256 = "027dv53jrfk46dmiidnnrrdvhyin60i862znp414213w72yjrbhh";
+       sha256 = "10ae2cbd387c044102b9f60b832230367ab85bced6b6186b3364ba2c47d9ed08";
        libraryHaskellDepends = [ base template-haskell ];
        homepage = "http://www.cs.kent.ac.uk/~oc/contracts.html";
        description = "Practical typed lazy contracts";
@@ -2952,7 +2953,7 @@ self: {
      mkDerivation {
        pname = "Control-Engine";
        version = "1.1.0.1";
-       sha256 = "1jyj42xrja8ic3lajgrfmign9n2bdfkaplnlhzcifd5wf30qj6fa";
+       sha256 = "ca1989c170bc3417d987d4d2aba66b4bd8645fac2e3fa9e860112999bb20d2cb";
        libraryHaskellDepends = [ base BoundedChan stm ];
        homepage = "http://www.haskell.org/haskellwiki/Control-Engine";
        description = "A parallel producer/consumer engine (thread pool)";
@@ -2967,7 +2968,7 @@ self: {
      mkDerivation {
        pname = "Control-Monad-MultiPass";
        version = "0.1.0.0";
-       sha256 = "0pdayn1v9dw5600fgzlag2bqy1p68i4yzpxzqna9p7jk0iyvfy0i";
+       sha256 = "1178b77d04539e9b94c5bfdfef4944e6068f97788afee7003085b7b483f5aa5d";
        libraryHaskellDepends = [
          array base containers Control-Monad-ST2 mtl
        ];
@@ -2988,7 +2989,7 @@ self: {
      mkDerivation {
        pname = "Control-Monad-ST2";
        version = "0.1.0.1";
-       sha256 = "02nl4dbh7lk2gx5vacnn9mlcbs5j4b68jj0db94j51mqwj22y0zk";
+       sha256 = "f3032f84e4b88622495a0d4889cc22b2e8c5684dd632b54b7f62d2035723d40a";
        libraryHaskellDepends = [ array base QuickCheck SafeSemaphore ];
        testHaskellDepends = [
          array base mtl QuickCheck SafeSemaphore test-framework
@@ -3005,7 +3006,7 @@ self: {
      mkDerivation {
        pname = "CoreErlang";
        version = "0.0.2";
-       sha256 = "1wiwk4947h5x2swi9k6bh4zyhp849ibxhc5458kn5vipngrp4k78";
+       sha256 = "e84c72f3b337ee62272aa430d8574c045de83f81cbcc14b916bdc04312993cf2";
        libraryHaskellDepends = [ base parsec pretty ];
        homepage = "http://github.com/amtal/CoreErlang";
        description = "Manipulating Core Erlang source code";
@@ -3021,7 +3022,7 @@ self: {
      mkDerivation {
        pname = "CoreFoundation";
        version = "0.1";
-       sha256 = "0mra2aswl0gfic19l55i63a6il6i13caph56fdk8g7shcw3j605l";
+       sha256 = "b400230767509f876673a6c0abd808d1d068d430b1149a028bee01cab5122a57";
        libraryHaskellDepends = [
          base bytestring containers deepseq filepath network property-list
          tagged text time transformers vector
@@ -3039,7 +3040,7 @@ self: {
      mkDerivation {
        pname = "Coroutine";
        version = "0.1.0.0";
-       sha256 = "1cad9j7ivd6mfcff44773v8z3z2ilparxfikbnv0gab6csc9p1nw";
+       sha256 = "dc869b986666a907b65d33ba9ed5a551fcf1d11ee710e21c73d5b41d8f4c4db1";
        libraryHaskellDepends = [ base ];
        description = "Type-safe coroutines using lightweight session types";
        license = stdenv.lib.licenses.bsd3;
@@ -3053,7 +3054,7 @@ self: {
      mkDerivation {
        pname = "CouchDB";
        version = "1.2.2";
-       sha256 = "0imzpwrynr54as3bzx2222vqcnmmrzx6dis5qa2vmclf6yd8q1z8";
+       sha256 = "e8078c9a378eb2ba85c245c766facfb55a86b71042f4bf8656a464eb33bfbf46";
        libraryHaskellDepends = [
          base bytestring containers HTTP json mtl network network-uri
          utf8-string
@@ -3073,7 +3074,7 @@ self: {
      mkDerivation {
        pname = "Craft3e";
        version = "0.1.0.10";
-       sha256 = "1qrsjkwr1njdsyiryskdjmy6nhbbzin4r0ja7mib26injzmrx45p";
+       sha256 = "b7909eeb97361ab1623d4a824c6cfc6b416b7c956d6a9fa3d74dda90f9943ae3";
        isLibrary = true;
        isExecutable = true;
        libraryHaskellDepends = [
@@ -3091,7 +3092,7 @@ self: {
      mkDerivation {
        pname = "Crypto";
        version = "4.2.5.1";
-       sha256 = "0rmgl0a4k6ys2lc6d607g28c2p443a46dla903rz5aha7m9y1mba";
+       sha256 = "6ad5e0533d0aaaf2f30049d166881a845cc190780798661815da9b4914a0af66";
        isLibrary = true;
        isExecutable = true;
        libraryHaskellDepends = [
@@ -3113,7 +3114,7 @@ self: {
      mkDerivation {
        pname = "CurryDB";
        version = "0.1.1.0";
-       sha256 = "1mjgxbmwf37wqbdbhfbq3pj4mmgkf1w0lv49gagx1m5yny21q3l3";
+       sha256 = "830e1c84b7bed4d09f7a896c0a7870f3d54ae41d7839b8dac2fc0cc7ebea4fd6";
        isLibrary = true;
        isExecutable = true;
        libraryHaskellDepends = [
@@ -3142,7 +3143,7 @@ self: {
      mkDerivation {
        pname = "DAG-Tournament";
        version = "0.1";
-       sha256 = "1yyr63r6ziljvcxacs7zn66lnkzgmlvcr36ic60c3z1r2rd2nflk";
+       sha256 = "933a2b5a1639fcc18061d18ccc36adef4f4b8db1ff68a63adb92c66ff230d9fb";
        isLibrary = false;
        isExecutable = true;
        executableHaskellDepends = [
@@ -3163,7 +3164,7 @@ self: {
      mkDerivation {
        pname = "DAV";
        version = "1.0.7";
-       sha256 = "0bkwcgxisp1ipnc1v63z16mcw40dy6fxszjrr2b251sfah5h1ad8";
+       sha256 = "a8a9000b544e872296c8597edd9df10d10ceaa097f981d98bd315c1dfb637c2e";
        isLibrary = true;
        isExecutable = true;
        libraryHaskellDepends = [
@@ -3187,7 +3188,7 @@ self: {
      mkDerivation {
        pname = "DBlimited";
        version = "0.1.1";
-       sha256 = "1lic2ml1q16idg9rk2ky2xi030kln4m8nz1vyvy7w37qxhddvl2f";
+       sha256 = "4ed0dd1aecf80c7efcf63b7c8b2ab174820162177e8a99d36bd1041c68152cd2";
        isLibrary = false;
        isExecutable = true;
        executableHaskellDepends = [ base containers parsec ];
@@ -3202,7 +3203,7 @@ self: {
      mkDerivation {
        pname = "DBus";
        version = "0.5.1";
-       sha256 = "0l212yy40w8sjkv5m7rnd24fkihvnadv7szf10g9n5r34m4jb6lh";
+       sha256 = "909a25492523179b1e08eeebb39bb21bc6e98868369f5af6941a7140bc174150";
        libraryHaskellDepends = [ base bytestring ];
        homepage = "https://github.com/alexkay/hdbus";
        description = "D-Bus bindings";
@@ -3215,7 +3216,7 @@ self: {
      mkDerivation {
        pname = "DCFL";
        version = "0.1.6.0";
-       sha256 = "10f0c3y0y39rmvvvrvz426srb18wsv4qfzzx9r9zjac2m14b96jx";
+       sha256 = "5d9ab448a88229f9534efd7f87c9d61c8595b511e4efbcf7ae390d0ffc60c081";
        libraryHaskellDepends = [ base deepseq HUnit parallel random ];
        homepage = "https://github.com/Poincare/DCFL";
        description = "Communication Free Learning-based constraint solver";
@@ -3230,7 +3231,7 @@ self: {
      mkDerivation {
        pname = "DMuCheck";
        version = "0.3.0.2";
-       sha256 = "00dhky0hnda85lvrs155jgwxnpqfm36cqakj3wp0yrn2xlz383ad";
+       sha256 = "4d0d343eedc2660f2e1f722acccca80e5fdbf993a5049d372d48350b819fb001";
        isLibrary = false;
        isExecutable = true;
        executableHaskellDepends = [
@@ -3249,7 +3250,7 @@ self: {
      mkDerivation {
        pname = "DOM";
        version = "2.0.1";
-       sha256 = "13zj4jg78y5s05gfi3j83izxw6d2csbvznd7mq900zlv4xwddw2b";
+       sha256 = "4bf0d678279b7e0012aea7d9bf9766a219de7f1c488ee85e01ba78749e24f28f";
        libraryHaskellDepends = [ base mtl WebBits ];
        jailbreak = true;
        description = "DOM Level 2 bindings for the WebBits package";
@@ -3264,7 +3265,7 @@ self: {
      mkDerivation {
        pname = "DP";
        version = "0.1.1";
-       sha256 = "03gjwkzna2mf0a103g0kiwnbd9ra6hss6vm73i7vhl87zgrwsh8z";
+       sha256 = "1f41cdf3fb0751b84f1ca76ea335342aa7b62c8f13bc018202ae0a65ffe4f20d";
        libraryHaskellDepends = [
          array base containers list-tries mtl QuickCheck safe semiring
        ];
@@ -3284,7 +3285,7 @@ self: {
      mkDerivation {
        pname = "DPM";
        version = "0.3.0.0";
-       sha256 = "03rf2s9qinfahqsc870cxv5117g4hmqza2dbj7s5hi50sh32xkjc";
+       sha256 = "4cce2e06d4a04458f491ab09f57185e49d10caee0c1cc43486cad98893162e0f";
        isLibrary = true;
        isExecutable = true;
        libraryHaskellDepends = [
@@ -3309,7 +3310,7 @@ self: {
      mkDerivation {
        pname = "DRBG";
        version = "0.5.4";
-       sha256 = "03nkcrjkaj36bs4sasf1286ca3wam1ndahq3y88bib2q0h5psqdx";
+       sha256 = "bd617d0b0458acb810f20343d56ca88a0fc50c12c169a5895e6648356566d30e";
        libraryHaskellDepends = [
          base bytestring cereal cipher-aes128 crypto-api
          cryptohash-cryptoapi entropy mtl parallel prettyclass tagged
@@ -3332,7 +3333,7 @@ self: {
      mkDerivation {
        pname = "DSA";
        version = "1";
-       sha256 = "0js67dj7dls7ivvdw1hvxc1cw0rl4bvnfip16ygmgwg98344bfwl";
+       sha256 = "94bb45c840e9f1579f37e14667f7223403ce02eb1b06def68e47d376643b464b";
        libraryHaskellDepends = [
          base binary bytestring crypto-api crypto-pubkey-types ghc-prim
          integer-gmp SHA tagged
@@ -3357,7 +3358,7 @@ self: {
      mkDerivation {
        pname = "DSH";
        version = "0.12.0.1";
-       sha256 = "1m69phqjrb4wg6fji5plw1mghyz7jzzqixljaa5gb5s0cy5gfkfy";
+       sha256 = "de4df78a674097f58a5292f688ff97e77bf86ae0f496289d799cac2c31bcc9d4";
        isLibrary = true;
        isExecutable = true;
        libraryHaskellDepends = [
@@ -3381,7 +3382,7 @@ self: {
      mkDerivation {
        pname = "DSTM";
        version = "0.1.2";
-       sha256 = "084yscqbwypkb32avjm2b92a7s4qpvps3pjfgpy14sligww3hifb";
+       sha256 = "cb4538387f916a12fc7d4edea1efbe98e8a3445aa2caadc458f37abe30d39e20";
        isLibrary = true;
        isExecutable = true;
        libraryHaskellDepends = [
@@ -3400,7 +3401,7 @@ self: {
      mkDerivation {
        pname = "DTC";
        version = "1.1.0.1";
-       sha256 = "0m3697zw0j2l9fxx8flr83n8x03pva1hn74rgilgxdrsrifhds5l";
+       sha256 = "b4e8065dcc3ab7fe687c991c0b83da77808eec40993ad4bb4b5448c0ff496654";
        libraryHaskellDepends = [ base haskell-src-exts ];
        homepage = "https://github.com/Daniel-Diaz/DTC";
        description = "Data To Class transformation";
@@ -3413,7 +3414,7 @@ self: {
      mkDerivation {
        pname = "Dangerous";
        version = "0.3.2";
-       sha256 = "0pnywhva7s5xp9xlxk6h56n3fjflna6zhk5qdb8wax7i1qbp85vs";
+       sha256 = "7a1774170ef174c5d16ab84cf88db2d44937ac29d0cc4e7bbabde8a336e4de5e";
        libraryHaskellDepends = [ base MaybeT mtl ];
        description = "Monads for operations that can exit early and produce warnings";
        license = stdenv.lib.licenses.mit;
@@ -3428,7 +3429,7 @@ self: {
      mkDerivation {
        pname = "Dao";
        version = "0.1.0.2";
-       sha256 = "1f7svqvlywj0jgzssdgrhvbbfm0yjnq0qr2c7xqc501y6wr3msym";
+       sha256 = "d5eb3a32373e80c2703f4c640cb0951e54b7d686f935adff9340724f37defab8";
        isLibrary = true;
        isExecutable = true;
        libraryHaskellDepends = [
@@ -3456,7 +3457,7 @@ self: {
      mkDerivation {
        pname = "DarcsHelpers";
        version = "0.1";
-       sha256 = "02nqaphxd3xlh191wxpx3rcixms70v8d6h4a3lxg24d7lcyf82n3";
+       sha256 = "c30ae43ca3a711f13a1d8a40d3d00647d71e591efd761e5280b48fd6e155d80a";
        libraryHaskellDepends = [ base HaXml mtl parsec safe xml-parsec ];
        jailbreak = true;
        description = "Code used by Patch-Shack that seemed sensible to open for reusability";
@@ -3471,7 +3472,7 @@ self: {
      mkDerivation {
        pname = "Data-Hash-Consistent";
        version = "0.1.1";
-       sha256 = "1vblfzndfzb458j6ygfcq0mfzzc5c87gwpmcx31v10fxpqnfmm65";
+       sha256 = "c5d4ea2cbedd81b0c3e8ac5efe0e6285fdef2ac0cc3d6f242a647dd7ec7774ed";
        libraryHaskellDepends = [
          base bytestring digest utf8-string vector vector-algorithms
        ];
@@ -3485,7 +3486,7 @@ self: {
      mkDerivation {
        pname = "Data-Rope";
        version = "0.2";
-       sha256 = "0zvp9h06f2ylkn325d35cap3y67zpfyc70nqad3426p64p1xmnrw";
+       sha256 = "3cdbdac325e61a414653d882c3bcbbff183fae6265b422869dd40b67004c777f";
        libraryHaskellDepends = [ base bytestring unix ];
        description = "Ropes, an alternative to (Byte)Strings";
        license = "GPL";
@@ -3500,7 +3501,7 @@ self: {
      mkDerivation {
        pname = "DataTreeView";
        version = "0.1.1";
-       sha256 = "0z54kr79bjv8w1gnsrxq9vkwdhasdwzrsi48q7ndsg8x7k30gpdj";
+       sha256 = "b2dd07c63c1d3dddecc188449d3f6f5ac1c6e74eb8676d5fe068cb954e9ea47c";
        libraryHaskellDepends = [
          base bytestring containers deepseq glib gtk lifted-base ListLike
          MissingH monad-control mtl syb transformers-base
@@ -3519,7 +3520,7 @@ self: {
      mkDerivation {
        pname = "Deadpan-DDP";
        version = "0.9.3.0";
-       sha256 = "03vs4pvca80wwgfgm1a6hbincvsmlxyyz319ihk9pw22zqiq5qvs";
+       sha256 = "7ae38223fe42f09b268c298cef7da7556f66e3824685fadce31c20c5f6257a0f";
        isLibrary = true;
        isExecutable = true;
        libraryHaskellDepends = [
@@ -3544,7 +3545,7 @@ self: {
      mkDerivation {
        pname = "DebugTraceHelpers";
        version = "0.12";
-       sha256 = "0yjv3awhp3jsfqqn36xc0jpisp4hfypx3hkibad3yqrrn61bkzy8";
+       sha256 = "c8ffb982b139633f9a5a71c2d1af77905c1daf04ac9b6131765a8e0bb91a5b7a";
        libraryHaskellDepends = [ base mtl ];
        description = "Convenience functions and instances for Debug.Trace";
        license = "GPL";
@@ -3557,7 +3558,7 @@ self: {
      mkDerivation {
        pname = "Decimal";
        version = "0.4.2";
-       sha256 = "0qa2z2lq1hrvakhyhj624mg8sd05ikhb66zwpa6x9vcyji93dxf5";
+       sha256 = "c5f53652949eedd48dbafc1bb3e08c05348d5e25c248e8e1543bc380a9f84261";
        libraryHaskellDepends = [ base deepseq ];
        testHaskellDepends = [
          base deepseq HUnit QuickCheck test-framework test-framework-hunit
@@ -3573,7 +3574,7 @@ self: {
      mkDerivation {
        pname = "DecisionTree";
        version = "0.0";
-       sha256 = "14yprfh2b5x7dswp6kyaym3z2f32nqvgrfhvwsiv7brxq80cfvbd";
+       sha256 = "6d6dc700c23dafb3a3e61bbafc36b66238f147f5ca4f73b96ea79725a0cbd793";
        libraryHaskellDepends = [ base containers ];
        homepage = "http://page.mi.fu-berlin.de/~aneumann/decisiontree.html";
        description = "A very simple implementation of decision trees for discrete attributes";
@@ -3586,7 +3587,7 @@ self: {
      mkDerivation {
        pname = "DeepArrow";
        version = "0.4.0";
-       sha256 = "1jbvb8yk291iimpqi8h302r8554k4j2p3k42znzppv1wqrbhvjyc";
+       sha256 = "cccb0d57c63cec7bbffd82cc718524939482b20003a2886f8d3124313d5a7bc9";
        libraryHaskellDepends = [ base haskell-src mtl TypeCompose ];
        homepage = "http://haskell.org/haskellwiki/DeepArrow";
        description = "Arrows for \"deep application\"";
@@ -3600,7 +3601,7 @@ self: {
      mkDerivation {
        pname = "DefendTheKing";
        version = "0.3.1";
-       sha256 = "09wzab0343m55xq4dxfv0f9lwpd5v97mymd6408s6p82xa2vqlzw";
+       sha256 = "fc53bc85ea025da31120a6555f4fdaa55d4e9303dbf546702fa50e32c0529f27";
        isLibrary = false;
        isExecutable = true;
        executableHaskellDepends = [
@@ -3618,7 +3619,7 @@ self: {
      mkDerivation {
        pname = "DescriptiveKeys";
        version = "0.0.4";
-       sha256 = "0ywipcmnr3ysmx8m61yrymyn10lnizjfkk2q2scdfkrkgh7ayj7v";
+       sha256 = "fb48af0e7c334fd7981658cce9e48f9682607df5d9075351afda8f6c2bbb917b";
        libraryHaskellDepends = [ base containers xmonad xmonad-contrib ];
        homepage = "https://bitbucket.org/dibblego/descriptive-keys/";
        description = "A library for specifying xmonad key bindings with functionality";
@@ -3632,7 +3633,7 @@ self: {
      mkDerivation {
        pname = "Dflow";
        version = "0.0.1";
-       sha256 = "00gzs5fdybfrvqidw4qzk6i69qzq4jaljzhb49ah2hsv3gqjr1iq";
+       sha256 = "38862cf11b5b430155220b7e499524f8e364a2991f13de22ded92ddf5cd1ff01";
        libraryHaskellDepends = [ base containers QuickCheck stm time ];
        testHaskellDepends = [
          base HUnit QuickCheck test-framework test-framework-quickcheck2
@@ -3647,7 +3648,7 @@ self: {
      mkDerivation {
        pname = "Diff";
        version = "0.3.2";
-       sha256 = "13iqqmpadcm7fvqwbfrz94w030rvjh66w2bdls1253128ac2n0vz";
+       sha256 = "7f032b9842228c2282a66d096e0c943b830138493fbbc5f176a7b2a66ec5388e";
        revision = "1";
        editedCabalFile = "86ab9f6bcb253cabff2673437995faa4c130be7c3898df778b27a801c5361328";
        libraryHaskellDepends = [ array base pretty ];
@@ -3660,7 +3661,7 @@ self: {
      mkDerivation {
        pname = "DifferenceLogic";
        version = "0.1.0.4";
-       sha256 = "0ylpn6bksf6alxzk45cg88ff8xgffh88x3csvjlhb6zn8ik0w99a";
+       sha256 = "2a250e6644f69b05a9dc9a8d8e1074ee75e41c428f15327fa7ca383d97b1977a";
        libraryHaskellDepends = [
          base containers fgl FirstOrderTheory HUnit
        ];
@@ -3678,7 +3679,7 @@ self: {
      mkDerivation {
        pname = "DifferentialEvolution";
        version = "0.0.2";
-       sha256 = "0z16g40n369d2wqljnrkmpd18149ny8nh2pd13hkkjnq5n6k209w";
+       sha256 = "3c01318d2dd8ca39e108ed0a6891b7890414daad335b4931172d99610179267c";
        libraryHaskellDepends = [
          base deepseq fclabels mtl mwc-random parallel primitive vector
        ];
@@ -3696,7 +3697,7 @@ self: {
      mkDerivation {
        pname = "Digit";
        version = "0.0.3";
-       sha256 = "0cdsmy9km9wpywqprdymn9bd982ba859px2giswz41xh6pbjri8w";
+       sha256 = "1cc52cd735b007f2b98e4ff49b0a524ba0d456b2d5b77c31f797a73a93afba31";
        libraryHaskellDepends = [
          base HUnit QuickCheck test-framework test-framework-hunit
          test-framework-quickcheck2
@@ -3714,7 +3715,7 @@ self: {
      mkDerivation {
        pname = "DigitalOcean";
        version = "0.1.1.0";
-       sha256 = "09sh0j1dk366nkq3pwgsxi8zcka9p3f38bsw6nfzr7q4chjjblz4";
+       sha256 = "e4d3252564049ffc9d355c2f34dcb8494df651ecfaf13bf0b4c68cd982045027";
        libraryHaskellDepends = [
          aeson base bytestring containers exceptions lens mtl text
          transformers unordered-containers vector wreq
@@ -3730,7 +3731,7 @@ self: {
      mkDerivation {
        pname = "DimensionalHash";
        version = "0.1.5.2";
-       sha256 = "0bbg9w5n3b296g884y8qvgzsndqhzwh0mkn3dlp9nx4a7i321c97";
+       sha256 = "27b120463c8a749b2e6dc3ce0a20ff1037abffdb187982d03349ac610b4f6f2d";
        libraryHaskellDepends = [ base ];
        description = "An n-dimensional hash using Morton numbers";
        license = stdenv.lib.licenses.bsd3;
@@ -3742,7 +3743,7 @@ self: {
      mkDerivation {
        pname = "DirectSound";
        version = "0.0.0";
-       sha256 = "1x78y1na375nwgk4izsjprj3yrg0xbrhqv6nrzfbvbfdyqlf5kyz";
+       sha256 = "dfcfe228f6cdadbddccfd66c0cf3eae0653f64be52ff48e6e3b69ca16cf0e8f4";
        libraryHaskellDepends = [ base Win32 ];
        librarySystemDepends = [ dsound ];
        homepage = "http://code.haskell.org/~bkomuves/";
@@ -3759,7 +3760,7 @@ self: {
      mkDerivation {
        pname = "DisTract";
        version = "0.2.5";
-       sha256 = "0pnlk09jsallyparwdfcy7jmqjjiprp2pqlg9agp6xbw5xmnkzwb";
+       sha256 = "8bff696b2f7c75739f4a8fe22b6ebe514a5ce5f1cc359ed5f5942a2d1398d45e";
        isLibrary = true;
        isExecutable = true;
        libraryHaskellDepends = [
@@ -3779,7 +3780,7 @@ self: {
      mkDerivation {
        pname = "DiscussionSupportSystem";
        version = "0.11.0.3";
-       sha256 = "0iqcv3b06r9sqj1adxfq08vq5mlq4b7z88c2cw4qa7l9xw2p2js3";
+       sha256 = "434b7105ef891e8509678221f4cf2298d6823702d8f5a682c43a6503d6d80c47";
        libraryHaskellDepends = [
          base blaze-html blaze-markup html parsers
        ];
@@ -3795,7 +3796,7 @@ self: {
      mkDerivation {
        pname = "Dish";
        version = "0.0.0.5";
-       sha256 = "1xhz0yb8xrjdznvx5prpl7r8k73n78n6gmshqbraq5jdh3vcnisx";
+       sha256 = "5d47cbf6804d16acf2c250d7672c3a769c89f2a137dfd2b7fd4de68e96071ff6";
        isLibrary = true;
        isExecutable = true;
        libraryHaskellDepends = [ base bytestring ];
@@ -3811,7 +3812,7 @@ self: {
      mkDerivation {
        pname = "Dist";
        version = "0.3.0.0";
-       sha256 = "00h0cxlxk72k829w8cf2gi2y4v4qj9bdzdmvnphnvc9wz5pyiz26";
+       sha256 = "46fce86ff93cb16de1b5bbb6df5692986ce2457cc231c49340539cd969670002";
        libraryHaskellDepends = [ base containers MonadRandom ];
        testHaskellDepends = [ base containers MonadRandom ];
        homepage = "https://github.com/wyager/Dist";
@@ -3826,7 +3827,7 @@ self: {
      mkDerivation {
        pname = "DistanceTransform";
        version = "0.1.2";
-       sha256 = "0c77sbx6qls8wfhv0wbappbkgfab046ls8mqs32qj02k549s6fk5";
+       sha256 = "653aa31329530089c5d0b8224d0d014bb937d7bd6a71b0a1e348536cfad2e730";
        libraryHaskellDepends = [ base primitive vector ];
        testHaskellDepends = [
          base HUnit test-framework test-framework-hunit vector
@@ -3840,7 +3841,7 @@ self: {
      mkDerivation {
        pname = "DistanceUnits";
        version = "0.1.0.1";
-       sha256 = "0ls6rq4nqn3z9h9lagl8sff9q94zfm6gssa2jj1zfyfxl5869bas";
+       sha256 = "5aad6450a1dd79f783944269fd4c759f249c9cd3883e45134c7f586c09ce4653";
        libraryHaskellDepends = [ base ];
        homepage = "https://github.com/gambogi/DistanceUnits";
        description = "A comprehensive distance library";
@@ -3856,7 +3857,7 @@ self: {
      mkDerivation {
        pname = "DnaProteinAlignment";
        version = "0.0.0.1";
-       sha256 = "00c74anpm3varyf0man1i213dksxvh2p32xsp4rqijkbnxpkjbx3";
+       sha256 = "a32f396fb76bca8833b9ba8b7105dc5dcf368288c1aa0a9ccf6a8f7aad228701";
        isLibrary = true;
        isExecutable = true;
        libraryHaskellDepends = [
@@ -3882,7 +3883,7 @@ self: {
      mkDerivation {
        pname = "DocTest";
        version = "0.2.0.1";
-       sha256 = "1w9r50cyiz31fn4dmlh3qmmpv9qapxgg70c10a86m6sxdl75q827";
+       sha256 = "47205c0e6d5d9b6a90028181f35ebf0aa77d6bc503d2da887561fce8192839f1";
        isLibrary = false;
        isExecutable = true;
        executableHaskellDepends = [
@@ -3900,7 +3901,7 @@ self: {
      mkDerivation {
        pname = "Docs";
        version = "1.0.0";
-       sha256 = "1hjdznp29kwj9cca0jxr3dds9cnfbss6sgn52wym2380az3jcvnz";
+       sha256 = "df6e26c757000d513d17c53e6db45eceb2a45b1bb94ba0184b92cf24aefd4dc2";
        libraryHaskellDepends = [ base html ];
        homepage = "http://ddiaz.asofilak.es/packages/Docs.html";
        description = "Documentation types library";
@@ -3914,7 +3915,7 @@ self: {
      mkDerivation {
        pname = "DrHylo";
        version = "0.0.2";
-       sha256 = "1cs7zqz0yzdyj3vn38cfh1lj90xnxm24q8lml457f2yia4z7l6h7";
+       sha256 = "071a7a3e51d10b770aa195224c44edb6832469808ea161f790be7d0f3efe47b3";
        isLibrary = true;
        isExecutable = true;
        libraryHaskellDepends = [
@@ -3933,7 +3934,7 @@ self: {
      mkDerivation {
        pname = "DrIFT";
        version = "2.4.2";
-       sha256 = "1w0wfmrjifidl2qz998ig07afd4p6yp890lwl8as57bay490nakl";
+       sha256 = "742a0b12f16a9da215a29c8284ae379734a70e7811a5f4b1a02dba2873751cf0";
        isLibrary = true;
        isExecutable = true;
        libraryHaskellDepends = [ base ];
@@ -3951,7 +3952,7 @@ self: {
      mkDerivation {
        pname = "DrIFT-cabalized";
        version = "2.3.0";
-       sha256 = "0jk7qmlgjw69w38hm91bnyp8gyi1mjmrq4vyv7jv3y69rk0fi6wl";
+       sha256 = "949be8c0ccc9f8b1e5d97e139cabac21fa87aeb72ba40ad1e0c970f968c5674a";
        isLibrary = false;
        isExecutable = true;
        executableHaskellDepends = [ base old-time process random ];
@@ -3966,7 +3967,7 @@ self: {
      mkDerivation {
        pname = "Dung";
        version = "1.1";
-       sha256 = "1higdpqg599lfc92m7dd4zy98l9vjg5xr4n4qjv0wifszj8lrsgb";
+       sha256 = "ebe94c91fcda450eb6c4c492dccb933b5194fc27ad9d2a127334a5f2f06d2fc2";
        isLibrary = true;
        isExecutable = true;
        libraryHaskellDepends = [ base cmdargs containers parsec ];
@@ -3985,7 +3986,7 @@ self: {
      mkDerivation {
        pname = "Dust";
        version = "2.3.1";
-       sha256 = "0j2pm2ram7idh46mi6jv0whk4rx0bicvsvayrn3arnq65zk2mavj";
+       sha256 = "72ab2ae62f06dbac86cd5e6dbd595ca0673221075b9a580d812d9eaab2a85748";
        libraryHaskellDepends = [
          base binary bytestring cereal containers crypto-api directory
          Dust-crypto entropy ghc-prim network random random-extras random-fu
@@ -4011,7 +4012,7 @@ self: {
      mkDerivation {
        pname = "Dust-crypto";
        version = "0.1";
-       sha256 = "112prydwsjd32aiv3kg8wsxwaj95p6x7jhxcf118fxgrrg202z9w";
+       sha256 = "3c7d01c4cbf975874270ac4379bab92549c5bbe6e8cdb1a312a349cd9bcf5784";
        libraryHaskellDepends = [
          base binary bytestring cereal containers crypto-api cryptohash
          directory entropy ghc-prim network random random-extras random-fu
@@ -4036,7 +4037,7 @@ self: {
      mkDerivation {
        pname = "Dust-tools";
        version = "1.3.2";
-       sha256 = "1g1l7h5400f9qckhj4yw2zwwjjkqz5w1fgnc9gxa7rdl37wgxwn4";
+       sha256 = "c4f2fef819b4e5a3fa4bcc3e1778f9784ac9f917dc130927c3c901400a3c34bc";
        isLibrary = true;
        isExecutable = true;
        libraryHaskellDepends = [
@@ -4062,7 +4063,7 @@ self: {
      mkDerivation {
        pname = "Dust-tools-pcap";
        version = "1.3.1";
-       sha256 = "1swykscl17qy17qy38y6zc47sbiyaszh9m4qwn7d9sckfa6azsdr";
+       sha256 = "b9e9af8c7293e9d48ee598d404bf563e2e7d08fbc6a3e1f1091e9f40999e9eeb";
        isLibrary = false;
        isExecutable = true;
        executableHaskellDepends = [
@@ -4081,7 +4082,7 @@ self: {
      mkDerivation {
        pname = "DynamicTimeWarp";
        version = "0.1.0.0";
-       sha256 = "0m58bq2jvnr17kdapfydd063af6w5vdyzxad5izk0cj0gids5hk7";
+       sha256 = "67c2a25b7c4032307f2c4df5efdb2edc38350c68cdbbabda3c21db2d055ea854";
        isLibrary = true;
        isExecutable = true;
        libraryHaskellDepends = [ array base vector ];
@@ -4100,7 +4101,7 @@ self: {
      mkDerivation {
        pname = "DysFRP";
        version = "0.1";
-       sha256 = "1jw1s2imd2qhh9i0m7sm1zhy876bgp1pcrh4jcf5dilvqnhvv4j1";
+       sha256 = "4192bda1c59bc6561c93046676c37dcb1ce4e10f559f0a6282108b56a3d081cb";
        libraryHaskellDepends = [
          base contravariant mtl time transformers
        ];
@@ -4114,7 +4115,7 @@ self: {
      mkDerivation {
        pname = "DysFRP-Cairo";
        version = "0.1";
-       sha256 = "1pg6gwyrlvp6z08ab1qp783z9gm0xhnh337shf443f1bwbcz9m7f";
+       sha256 = "eed4f4d9e22bb8418883fa8c012deca0bef4073a1787a510f8e66e9a3d7fe6dd";
        libraryHaskellDepends = [ base cairo DysFRP gtk mtl ];
        homepage = "https://github.com/tilk/DysFRP";
        description = "dysFunctional Reactive Programming on Cairo";
@@ -4129,7 +4130,7 @@ self: {
      mkDerivation {
        pname = "DysFRP-Craftwerk";
        version = "0.1";
-       sha256 = "0rhm7ya1h43dwa83fcvnc8nd9da7ji6qlwzsa9ngv7pqvs7aamy1";
+       sha256 = "c157a58edef89efd6c52fa738a4d9447b5d42c6276333790e26d1018943f1566";
        libraryHaskellDepends = [
          base cairo containers craftwerk craftwerk-gtk DysFRP DysFRP-Cairo
          gtk
@@ -4145,7 +4146,7 @@ self: {
      mkDerivation {
        pname = "EEConfig";
        version = "1.0";
-       sha256 = "1bkkzj1d0j4nisdl9jfmadjx32w35ipdw3k12krhzzlf5aiwnrf1";
+       sha256 = "c165cba32a8efe0ff314610ede6e2c838bd16553d5c9449b8e9648d082fc73ae";
        libraryHaskellDepends = [ base containers ];
        description = "ExtremlyEasyConfig - Extremly Simple parser for config files";
        license = stdenv.lib.licenses.bsd3;
@@ -4158,8 +4159,8 @@ self: {
      }:
      mkDerivation {
        pname = "Earley";
-       version = "0.8.3";
-       sha256 = "0czdpgyxw3n0603hmd8kl8dnz9800df1lnkkf8a95cjd8nx3k8fv";
+       version = "0.9.0";
+       sha256 = "5ec955f00c872cc585bc2dd82fec137f53b095fde73a498e2a0ca7e0eb8140aa";
        isLibrary = true;
        isExecutable = true;
        libraryHaskellDepends = [ base ListLike ];
@@ -4176,7 +4177,7 @@ self: {
      mkDerivation {
        pname = "Ebnf2ps";
        version = "1.0.14";
-       sha256 = "0dv7lbw3nb3wyrrq8q4wd26i445ylwiixhhzdl574sw58mw60rk3";
+       sha256 = "6366607845856b720a6d1fc21e23a7be10128d689c608473f67c2c3bf8a26737";
        isLibrary = false;
        isExecutable = true;
        executableHaskellDepends = [
@@ -4193,7 +4194,7 @@ self: {
      mkDerivation {
        pname = "EdisonAPI";
        version = "1.2.2.1";
-       sha256 = "1r8xfsqz58s6x7026yrjafcbjkwsjg6fpcj6gbcpidw5hymymqfp";
+       sha256 = "d7e1eaab8785b778d97a46b2ebcc939a4fb99853327b23c0e946a3f2b1761de5";
        libraryHaskellDepends = [ base mtl ];
        homepage = "http://rwd.rdockins.name/edison/home/";
        description = "A library of efficent, purely-functional data structures (API)";
@@ -4207,7 +4208,7 @@ self: {
      mkDerivation {
        pname = "EdisonCore";
        version = "1.2.2.1";
-       sha256 = "0yj68glq50qkn2ckhhq7q5y5kbwb5lh08z1kgksc61wds22a87pz";
+       sha256 = "ff1ea484d08d07c3f47c337c04202d8baf597cc107433899b0138382e943467a";
        libraryHaskellDepends = [
          array base containers EdisonAPI mtl QuickCheck
        ];
@@ -4224,7 +4225,7 @@ self: {
      mkDerivation {
        pname = "EditTimeReport";
        version = "1.0";
-       sha256 = "11a922535h6jvg79cv03jz6sn93h7jhqfrf9wi9x8arak9l06j70";
+       sha256 = "e04803689a2a2bd453e4c96587a13c7024abcd97036c96cedbd2c0328a104985";
        isLibrary = false;
        isExecutable = true;
        executableHaskellDepends = [
@@ -4244,7 +4245,7 @@ self: {
      mkDerivation {
        pname = "EitherT";
        version = "0.2.0";
-       sha256 = "1vry479zdq1fw7bd4d373c7wf2gg0aibkyb03710w7z2x86chssw";
+       sha256 = "5c6bc80ceae21f0ec21960f9b9a202ef09c70f1b6734d2d6e12ee0f6d3213eef";
        revision = "1";
        editedCabalFile = "a1c6f78c9a4379af0738a6d4dee5d1781099c5c56acb0b39c45ad23b256e8c6e";
        libraryHaskellDepends = [
@@ -4268,7 +4269,7 @@ self: {
      mkDerivation {
        pname = "Elm";
        version = "0.13";
-       sha256 = "1l6p00h0717blwvia0gvqpsakq8jy44fxc6brr4qxs5g4yjcjnmh";
+       sha256 = "b05ac9a427afe88e49cecbb0ee08f112e1a9f4c5fb011537a7eb84032000d7d0";
        isLibrary = true;
        isExecutable = true;
        libraryHaskellDepends = [
@@ -4303,7 +4304,7 @@ self: {
      mkDerivation {
        pname = "Emping";
        version = "0.6";
-       sha256 = "131h71fgn0zbsmbqmvbfl57is0dbm37xsi5g87gpjgq0k2cq0nkr";
+       sha256 = "795a809998003f79df41af44ddcfa8ab011d4fa16eed8a57d5eb03fb5c38308c";
        isLibrary = false;
        isExecutable = true;
        executableHaskellDepends = [
@@ -4320,7 +4321,7 @@ self: {
      mkDerivation {
        pname = "Encode";
        version = "1.3.7";
-       sha256 = "141iddlpvjp6hqjx5c5dm3ldf7yk64iqbhaiv51np27y6pazfgb5";
+       sha256 = "653df7d535fe886b43d951c1852331d31fd7e8a8adb0d22586e6ca7d696b3190";
        isLibrary = true;
        isExecutable = true;
        libraryHaskellDepends = [ base Cabal containers mtl ];
@@ -4336,7 +4337,7 @@ self: {
      mkDerivation {
        pname = "EnumContainers";
        version = "0.1";
-       sha256 = "14ckpgaviny3c0d1jn3blkkpri0cm8ac264y7kak965knjccq0k8";
+       sha256 = "6802cc98b4b39834d53c9e18c114aa0cc47ce7a46b58191a60c3dbb8d5bb9391";
        libraryHaskellDepends = [ base containers deepseq ];
        jailbreak = true;
        description = "Simple Enum-class-based int containers";
@@ -4348,7 +4349,7 @@ self: {
      mkDerivation {
        pname = "EnumMap";
        version = "0.0.2";
-       sha256 = "1v3jp1l95kybvdlpvp6bd0ryihxrvlnpkqz7fl1n4vazhkqk6zjz";
+       sha256 = "5f7e33f1845f6d620375e7e3792dddb9c3e83368cbdc7d69dbcbcf9268b872ec";
        libraryHaskellDepends = [ base containers ];
        jailbreak = true;
        description = "More general IntMap replacement";
@@ -4363,7 +4364,7 @@ self: {
      mkDerivation {
        pname = "Eq";
        version = "1.1.3";
-       sha256 = "0hcfjzlirw11jl752g2jncb71i8sk2w3nqjm4ykc64f5awj1hi23";
+       sha256 = "4344182457c511c3a62755623bb8981ac57016b3523c510e9521f01ce9978e41";
        isLibrary = false;
        isExecutable = true;
        executableHaskellDepends = [
@@ -4381,7 +4382,7 @@ self: {
      mkDerivation {
        pname = "EqualitySolver";
        version = "0.1.0.2";
-       sha256 = "0ynzzl9mmn5hxkcndx60lnxn455nm065v7nk7rhpq1yigwz0cl1g";
+       sha256 = "2f50063e7fd1077c613ed39e5d0ca8b61462bba5c0f466d9ecb0d85a13fddf7a";
        libraryHaskellDepends = [
          base containers HUnit mtl union-find-array
        ];
@@ -4398,7 +4399,7 @@ self: {
      mkDerivation {
        pname = "EsounD";
        version = "0.2";
-       sha256 = "1d22k3836c92xd6qg5pvjhgrhbajd438z3pfjvi0bl2wdrkzddjr";
+       sha256 = "59b6f6676e5cd005e296ee8e8f0669522d981f94fb96874deb223133d09842b4";
        isLibrary = true;
        isExecutable = true;
        libraryHaskellDepends = [
@@ -4413,12 +4414,12 @@ self: {
      }) {};
 
   "EstProgress" = callPackage
-    ({ mkDerivation, base, mtl }:
+    ({ mkDerivation, ansi-terminal, base, mtl }:
      mkDerivation {
        pname = "EstProgress";
-       version = "0.2.0.0";
-       sha256 = "0xq2r7mbgs00hf1c8c2ffgsk7jjzd932br59rgkg06qym14dp3b3";
-       libraryHaskellDepends = [ base mtl ];
+       version = "0.3.0.0";
+       sha256 = "2371b9ee209aa190a95125fcd1a14a6d1e60d986c2554c149f0aeb21d894b197";
+       libraryHaskellDepends = [ ansi-terminal base mtl ];
        homepage = "http://alkalisoftware.net";
        description = "Methods for estimating the progress of functions";
        license = stdenv.lib.licenses.bsd3;
@@ -4434,7 +4435,7 @@ self: {
      mkDerivation {
        pname = "EtaMOO";
        version = "0.2.0.0";
-       sha256 = "0v7qq4d6zd3nr0856q3crivqqfq5q0rdppzf48jgzc9fzas6jl9n";
+       sha256 = "365169b4fa2eb1ff2422eedfdb32c0053b8c77cc6c605310c876b46f1ac1f86c";
        isLibrary = false;
        isExecutable = true;
        executableHaskellDepends = [
@@ -4457,7 +4458,7 @@ self: {
      mkDerivation {
        pname = "Etage";
        version = "0.1.12";
-       sha256 = "1ik8j7s1z64dpdg251m8dr7k7llkhxydlf6l6dhyv9ra55dg4n20";
+       sha256 = "4058f25a292aa7ed6133d438da7c8793d2334f6ea886225ebb8d981ff49168c6";
        libraryHaskellDepends = [
          base containers ghc mtl operational random SafeSemaphore time unix
        ];
@@ -4474,7 +4475,7 @@ self: {
      mkDerivation {
        pname = "Etage-Graph";
        version = "0.1.8";
-       sha256 = "0xzsvah4nhxv5hw8p0sv1pjy4p30xa3f2afs8jncx20n918mk9l2";
+       sha256 = "82a65951481688ceac44da29e186ea605ce2e50d5b838b382cbb434ba0dafa77";
        isLibrary = true;
        isExecutable = true;
        libraryHaskellDepends = [ base containers Etage fgl mtl ];
@@ -4493,7 +4494,7 @@ self: {
      mkDerivation {
        pname = "Eternal10Seconds";
        version = "0.2";
-       sha256 = "0kh1zjqr9cmx7xyfk2y3iwr3x3zvh3pb4ghfjz3xr2wwg2rmymxp";
+       sha256 = "b7575fb3789c8bdcc7970e3eb2ee80fb8f3e328fc38be97c3fbdb294b1fc014e";
        isLibrary = false;
        isExecutable = true;
        executableHaskellDepends = [ base haskell98 SDL SDL-mixer ];
@@ -4510,7 +4511,7 @@ self: {
      mkDerivation {
        pname = "Etherbunny";
        version = "0.3";
-       sha256 = "0cm98x626cqwri9qsfhwi6s50kg433a1p78y9na70z868p6n27nj";
+       sha256 = "d21e61cd45067d70944d1e9d1bd418e44d50b4891c3a8d53cc1c33234c47a932";
        isLibrary = true;
        isExecutable = true;
        libraryHaskellDepends = [
@@ -4531,7 +4532,7 @@ self: {
      mkDerivation {
        pname = "EuroIT";
        version = "2010.2.5";
-       sha256 = "1a6bvi0y1pnzpx0x3arrardgkbs0m8ssfwcyxf6fim87wcb0jcgv";
+       sha256 = "fb310916e307d5e88ceb9e71a735aa40aff95a5639abd141bfdfdee041dccba8";
        libraryHaskellDepends = [ base ];
        description = "Library for using euro currency, italian language";
        license = stdenv.lib.licenses.bsd3;
@@ -4546,7 +4547,7 @@ self: {
      mkDerivation {
        pname = "Euterpea";
        version = "1.0.0";
-       sha256 = "0cfcsrm47sb1z4zdmipipg9p31hzicwzpqdpa2m985j3hwm42vds";
+       sha256 = "ba6d412a87431694aa50b7e1fb398b1f8671d3bbf1c6da3ef961e9436ad6cc31";
        revision = "1";
        editedCabalFile = "61d418cc49621a3373fd25f547d2dd6b76b700dcc4b7e38b2f055b5c6f781afd";
        libraryHaskellDepends = [
@@ -4569,7 +4570,7 @@ self: {
      mkDerivation {
        pname = "EventSocket";
        version = "0.1";
-       sha256 = "03wf8msjcpj8bpnjr7f1wcbag018kap544jwz9a7vnllamps92xd";
+       sha256 = "ad8ba46f5594da7d54fa5c1252ae9a2880a716e3c19d2ced5d485e2675458e0f";
        libraryHaskellDepends = [
          base bytestring containers haskell98 mtl network
        ];
@@ -4587,7 +4588,7 @@ self: {
      mkDerivation {
        pname = "Extra";
        version = "1.46.3";
-       sha256 = "1xmwp9cp905nzx5x858wyacjpppn76mkfpkxksdhlq9zhmkp5yyh";
+       sha256 = "d0fb7267853f610a9b9e7d5e37ab39f6de2b99f21c15d44bffb6807459babcf6";
        libraryHaskellDepends = [
          base bytestring bzlib containers directory filepath HUnit mtl
          network-uri old-locale old-time pretty process pureMD5 QuickCheck
@@ -4606,7 +4607,7 @@ self: {
      mkDerivation {
        pname = "FComp";
        version = "1.0.2";
-       sha256 = "0hkmh3vjibbzkh004b4zig2rvvnh6l2cdqsmxbpyjbwqryzraxrn";
+       sha256 = "367795bfcf982fe9efea55e3c60435d0ee9dc58b9f2c02009c7fad28f7807542";
        isLibrary = true;
        isExecutable = true;
        libraryHaskellDepends = [
@@ -4630,7 +4631,7 @@ self: {
      mkDerivation {
        pname = "FM-SBLEX";
        version = "3.0.1";
-       sha256 = "1cb3qq8yqn19xpsjbczxs8rablkczaigs6hp2vypsjyw5s8sqza8";
+       sha256 = "487dac912edc4b7dfd16171afda2fa6cd2a532d2fdb325f5ed2958ec11c663b1";
        isLibrary = false;
        isExecutable = true;
        executableHaskellDepends = [ array base containers haskell98 ];
@@ -4645,7 +4646,7 @@ self: {
      mkDerivation {
        pname = "FModExRaw";
        version = "0.2.0.0";
-       sha256 = "0l2zhlxh88wy9y9gk1aa03yy65iw8zigr4pgp63mn2mqcrskfszl";
+       sha256 = "f46b377566b80a5b87b9ef92fce2473c16e3fd004a85f9924f9e23043b855f50";
        libraryHaskellDepends = [ base ];
        librarySystemDepends = [ fmodex64 ];
        homepage = "https://github.com/skypers/hsFModEx";
@@ -4659,7 +4660,7 @@ self: {
      mkDerivation {
        pname = "FPretty";
        version = "1.0";
-       sha256 = "1lc31mid1a9pqb9py9f6nvzvlixhngpficczvhpdxlws3fn9drga";
+       sha256 = "eae596ac1b9ad3de2edc9fb1e8eeb3b047baffb6c6257fd3c237a9d0620d83d1";
        libraryHaskellDepends = [ base containers ];
        homepage = "http://www.cs.kent.ac.uk/~oc/pretty.html";
        description = "Efficient simple pretty printing combinators";
@@ -4672,7 +4673,7 @@ self: {
      mkDerivation {
        pname = "FTGL";
        version = "2.1";
-       sha256 = "0b76798bxxivjrjx92qiv8ghsg3j8rhvfms8sl19ji6fip2h3fw2";
+       sha256 = "82bb01c58dce449902d54857b76146723c0d1fda118bd465963bf6be503ae62c";
        libraryHaskellDepends = [ base ];
        librarySystemDepends = [ ftgl ];
        description = "Portable TrueType font rendering for OpenGL using the Freetype2 library";
@@ -4686,7 +4687,7 @@ self: {
      mkDerivation {
        pname = "FTGL-bytestring";
        version = "2.0";
-       sha256 = "11y8g2gi4g6x639c9wfj2224f9vgaf88hdd1f981al53kzf7y2y2";
+       sha256 = "c20b7fdc9fa350155072a1358890536f27478410d2f1c4d230dd3c129f78c887";
        libraryHaskellDepends = [
          base bytestring StateVar-transformer transformers
        ];
@@ -4702,7 +4703,7 @@ self: {
      mkDerivation {
        pname = "FTPLine";
        version = "1.4.0.0";
-       sha256 = "0nnwfn4jxnxfr8q8gq16xn0ixjmw7dnxznsh8lbk41lwfsr9j4n5";
+       sha256 = "c51299b2769c0632174550dbdf6d3bbcca1e81ed26e08730caaedb2e8975dc5a";
        isLibrary = false;
        isExecutable = true;
        executableHaskellDepends = [
@@ -4720,7 +4721,7 @@ self: {
      mkDerivation {
        pname = "Facts";
        version = "0.1.2";
-       sha256 = "018g9qj6nmabjbl4rakqjp32vwfyak1wk5cx3s0amm53wnf2mz75";
+       sha256 = "e5fc2a9ce5a3d4aa801e9d95c9c354def12dc69578aa4ce8924b556b244e0f05";
        libraryHaskellDepends = [
          AC-Angle base containers digits QuickCheck template-haskell
        ];
@@ -4734,7 +4735,7 @@ self: {
      mkDerivation {
        pname = "FailureT";
        version = "15778.1";
-       sha256 = "1qhjqswx4qyfan3rpvvl1hgmf369krqprlr6x20hp34r2qw9s135";
+       sha256 = "65049d3816998c0b81e826d37c719ec90c571f0c74ef9b8755ce63d2b9c612e2";
        libraryHaskellDepends = [ base base-unicode-symbols mmtl ];
        description = "Failure Monad Transformer";
        license = stdenv.lib.licenses.publicDomain;
@@ -4748,7 +4749,7 @@ self: {
      mkDerivation {
        pname = "FastxPipe";
        version = "0.2.0.0";
-       sha256 = "1img1aivadrdljsixzll3qpdzvbjqy18mcwanli6w70ch556jsa9";
+       sha256 = "4969694a810c1c6e22b58ab38a82c772eddf2e1e94fe1eb5a42d37b5a30aafc6";
        libraryHaskellDepends = [
          attoparsec base blaze-builder bytestring pipes pipes-attoparsec
          pipes-bytestring
@@ -4763,7 +4764,7 @@ self: {
      mkDerivation {
        pname = "FenwickTree";
        version = "0.1.2.1";
-       sha256 = "0g7hhkim16wsjf8l79hqkiv1lain6jm8wpiml1iycra3n9i2s5ww";
+       sha256 = "9c172d62b24365e663a0355e8eaa34362a1a769c18a64391939a9b50e384f03c";
        libraryHaskellDepends = [ base QuickCheck template-haskell ];
        testHaskellDepends = [ base QuickCheck template-haskell ];
        homepage = "https://github.com/mgajda/FenwickTree";
@@ -4779,7 +4780,7 @@ self: {
      mkDerivation {
        pname = "FermatsLastMargin";
        version = "0.1";
-       sha256 = "07sryfn26afisrsgnzrp0vjshspa40pvl4214mzb5mdm9h5c63f8";
+       sha256 = "c80dc30a4cb5d5b27e254110ba2f20ea6aa8e506377ffb74d6d12923acf3591f";
        isLibrary = false;
        isExecutable = true;
        executableHaskellDepends = [
@@ -4799,7 +4800,7 @@ self: {
      mkDerivation {
        pname = "FerryCore";
        version = "0.4.6.4";
-       sha256 = "1dxhbrmcl36dg14lyihpy8fd8sdsmawh70fykllcjk3fh7a11wgp";
+       sha256 = "f7f110d4816e4cc9289dde8103b9aaba69d41cf217464f4978cd0cca6a5eb0b7";
        libraryHaskellDepends = [
          base containers HaXml mtl parsec pretty TableAlgebra
          template-haskell
@@ -4816,7 +4817,7 @@ self: {
      mkDerivation {
        pname = "FieldTrip";
        version = "0.2.7";
-       sha256 = "1161mz8443j1jr8pnkh6gz6w99cd16hk94ypsh8vzmpbfp40i5rb";
+       sha256 = "2b9708c875ebd6bf11d4d79334a1098da5c4cd7f064e7b5196410e42d0afc184";
        libraryHaskellDepends = [
          base GLUT graphicsFormats MemoTrie old-time OpenGL TypeCompose
          vector-space
@@ -4834,7 +4835,7 @@ self: {
      mkDerivation {
        pname = "FileManip";
        version = "0.3.3.1";
-       sha256 = "0dhl7zkyy4p0pgmraci82krph6hqrq1bwmx7wgm9agrnpdyg4dxi";
+       sha256 = "b137f27cbb363f95eae3a757be02ce181a78f314283295ebbbe012efe73f1436";
        libraryHaskellDepends = [
          base bytestring directory extensible-exceptions filepath mtl unix
        ];
@@ -4850,7 +4851,7 @@ self: {
      mkDerivation {
        pname = "FileManipCompat";
        version = "0.18";
-       sha256 = "0c017r7bzgf1mdbk0iyr2amhm41q89mcq69fkszskjhy4z9wl6v0";
+       sha256 = "601bcad3271ecaa9bf9e2e19cc6a4238900aab12d9473057abc1bdbf4e3e0130";
        libraryHaskellDepends = [
          base bytestring directory filepath mtl unix-compat
        ];
@@ -4866,7 +4867,7 @@ self: {
      mkDerivation {
        pname = "FilePather";
        version = "0.2.0";
-       sha256 = "1rwj8hqys01cn14d754wyl2vr19mvh4vsg2f3hrqjqiafkij90xd";
+       sha256 = "ad8324e3742a6289331c4e3cbd09dc3585bc05f59c94d348b02c00ed314492e7";
        libraryHaskellDepends = [
          base comonad comonad-transformers data-lens directory filepath mtl
          transformers
@@ -4883,7 +4884,7 @@ self: {
      mkDerivation {
        pname = "FileSystem";
        version = "1.0.0";
-       sha256 = "0qyzwpvajvqywbnfhj3vzb5xl4wjjywyqr4szywd8qwb7kly29w6";
+       sha256 = "8627e1e93c8b63d4b8ff9a64ecb9979213dacbfa7b48e8ece21e6fa9f6e5df63";
        libraryHaskellDepends = [
          base binary bytestring directory filepath mtl old-time
        ];
@@ -4901,7 +4902,7 @@ self: {
      mkDerivation {
        pname = "Finance-Quote-Yahoo";
        version = "0.8.0";
-       sha256 = "1d786xkrj0h270mfwxxkfxysmk78xkz2jdj8w1iin3hgy3ramifz";
+       sha256 = "dfc5aaf2f00f0e1b63e0483629feece8ccaa7d77b377ee2a380202996737e8b4";
        libraryHaskellDepends = [
          base bytestring http-conduit network old-locale time
        ];
@@ -4918,7 +4919,7 @@ self: {
      mkDerivation {
        pname = "Finance-Treasury";
        version = "0.1.2";
-       sha256 = "17wxdwj8162c0yawz4anjs6d3fjbhs3b05wk319acblksjx60sal";
+       sha256 = "546960bad4932ea652189317b086864bbad18c965691cf95074c9880246f9d9f";
        libraryHaskellDepends = [
          base containers HTTP HTTP-Simple hxt hxt-filter network old-locale
          time
@@ -4934,7 +4935,7 @@ self: {
      mkDerivation {
        pname = "FindBin";
        version = "0.0.5";
-       sha256 = "197xvn05yysmibm1p5wzxfa256lvpbknr5d1l2ws6g40w1kpk717";
+       sha256 = "279c7967e0803ca3b9a0a1956ce7ba9b9a2294eb9f971bea8a557b5f80ddfda4";
        libraryHaskellDepends = [ base directory filepath ];
        homepage = "https://github.com/audreyt/findbin";
        description = "Locate directory of original program";
@@ -4946,7 +4947,7 @@ self: {
      mkDerivation {
        pname = "FiniteMap";
        version = "0.1";
-       sha256 = "1kf638h5gsc8fklhaw2jiad1r0ssgj8zkfmzywp85lrx5z529gky";
+       sha256 = "7ebe24ca2f3dd3822ef7bfbaf9917c5a831c9a8a527005e97488e957201ac6cd";
        libraryHaskellDepends = [ base haskell98 ];
        description = "A finite map implementation, derived from the paper: Efficient sets: a balancing act, S. Adams, Journal of functional programming 3(4) Oct 1993, pp553-562";
        license = stdenv.lib.licenses.bsdOriginal;
@@ -4958,7 +4959,7 @@ self: {
      mkDerivation {
        pname = "FirstOrderTheory";
        version = "0.1.0.6";
-       sha256 = "1941ickx8aj3qbkry4gz8ni6snh26gkdrgabpx9z588518q4x27i";
+       sha256 = "f1884e300a05a1f253bf4bbddce633025a6da245ff119fe7c2432ad4278b81a4";
        libraryHaskellDepends = [ base containers Proper ];
        jailbreak = true;
        description = "Grammar and typeclass for first order theories";
@@ -4971,7 +4972,7 @@ self: {
      mkDerivation {
        pname = "FixedPoint-simple";
        version = "0.6.1";
-       sha256 = "0qfys17q3i56l20wzkpr8inq130j67kya022ynf0sgbc86avlrcn";
+       sha256 = "9665ba95416c3d0d9cf54200e5e731128c806d44f9cecf81a0a6c4814fd0de61";
        libraryHaskellDepends = [ base deepseq template-haskell ];
        homepage = "https://github.com/TomMD/FixedPoint";
        description = "Fixed point, large word, and large int numerical representations (types and common class instances)";
@@ -4985,7 +4986,7 @@ self: {
      mkDerivation {
        pname = "Flippi";
        version = "0.0.5";
-       sha256 = "1w25h3n3cnsl9dvr5s94jzf5qxyx0dl0v8dmqv2rkwwm7s2hdbl9";
+       sha256 = "89ae06853e95f399c5c6b5a10d6803dd775cdc9724e992774b545b36ec8045f0";
        isLibrary = false;
        isExecutable = true;
        executableHaskellDepends = [
@@ -5002,7 +5003,7 @@ self: {
      mkDerivation {
        pname = "Focus";
        version = "0.1.2";
-       sha256 = "1f1ch6mxgaam1i4ryd1av879y2f8wn3wmg47h23w2l0pvgmxgrj1";
+       sha256 = "41e6d7ebdb1750c1878087bcca87e5c8099f0eda2a349f490c55a9d7ab812cb8";
        libraryHaskellDepends = [ base MissingH split ];
        description = "Tools for focusing in on locations within numbers";
        license = stdenv.lib.licenses.mit;
@@ -5013,7 +5014,7 @@ self: {
      mkDerivation {
        pname = "Folly";
        version = "0.1.3.0";
-       sha256 = "0ygxgshgaddxfibl0paqm9sm4cq47247hr43awq8gib8zyg3amgi";
+       sha256 = "f155359eff68c5873057836478883804335275aa585d405774bd35f5a07efd79";
        isLibrary = true;
        isExecutable = true;
        libraryHaskellDepends = [ base containers ];
@@ -5031,7 +5032,7 @@ self: {
      mkDerivation {
        pname = "FontyFruity";
        version = "0.5.1.1";
-       sha256 = "064c9qq82r2kmsabciigyzp04hjqmpnc52xfshgiy77jq7k0jk2y";
+       sha256 = "5e4c09e6c1f21c1f1fd4ae8bc2ecad584202eef72f46b694ae536481304e8c18";
        libraryHaskellDepends = [
          base binary bytestring containers deepseq directory filepath text
          vector
@@ -5048,7 +5049,7 @@ self: {
      mkDerivation {
        pname = "ForSyDe";
        version = "3.1.1";
-       sha256 = "0ggwskyxpdrjny0rz61zdp20r5vzig8ggmqxf0qa8gljvvfp6bhp";
+       sha256 = "172e73ddde923ea430701dd7f7d08b7f970cc46d3f989f81b732b7dbfdd4fc3d";
        libraryHaskellDepends = [
          array base containers directory filepath mtl old-time
          parameterized-data pretty process random regex-posix
@@ -5065,7 +5066,7 @@ self: {
      mkDerivation {
        pname = "ForkableT";
        version = "0.1.0.2";
-       sha256 = "0lzrggy1j15cajb6k5qhz2s8ddngr3hhhsj781ya45fcx82mngvj";
+       sha256 = "723f5b05eacc15a27c40476a08e1c8cfb686b4f81097699654ac0419fc7bf953";
        libraryHaskellDepends = [ base monad-control mtl resourcet ];
        homepage = "https://github.com/exFalso/ForkableT/";
        description = "Forkable monad transformers";
@@ -5081,7 +5082,7 @@ self: {
      mkDerivation {
        pname = "FormalGrammars";
        version = "0.2.1.0";
-       sha256 = "10b7hcwzxnl31wdfdbakcaapihhnwx8lwj0znidvgkk7hyirnx2n";
+       sha256 = "56749ba38767ceb75bb41f484e51e716c278956253ade61a0f83dafe39836781";
        isLibrary = true;
        isExecutable = true;
        libraryHaskellDepends = [
@@ -5102,7 +5103,7 @@ self: {
      mkDerivation {
        pname = "Foster";
        version = "1.1.2";
-       sha256 = "0w4jnxk32c0pvrh2k7y93fckvrkcj3q8w4yi12zsgj9k1ic7yb6a";
+       sha256 = "ca2c7f580c33c9a7bf08d1138ef0906ce63d991bc99f2960de17303166b79270";
        isLibrary = false;
        isExecutable = true;
        executableHaskellDepends = [
@@ -5119,7 +5120,7 @@ self: {
      mkDerivation {
        pname = "FpMLv53";
        version = "0.1";
-       sha256 = "0h7vi940zrl2fqv8c2g0vj0gh9qfm2jf8c2drclx37zax5kb0r6p";
+       sha256 = "d764b066e9ea9fd129cb4d30e4a4a80e27f880dce00986367682e60f488afb40";
        libraryHaskellDepends = [ base HaXml ];
        homepage = "http://www.fpml.org/";
        description = "A binding for the Financial Products Markup Language (v5.3)";
@@ -5133,7 +5134,7 @@ self: {
      mkDerivation {
        pname = "Frames";
        version = "0.1.2.1";
-       sha256 = "0vw1fh0nqk3s5p08j4cnwb95jgzxk140wvszjlmr3ms9m0xcx61y";
+       sha256 = "3e98ce3aa849d7912b955f6f0e4898fd3f59d2e2961189c02d7a4c6c0174816f";
        isLibrary = true;
        isExecutable = true;
        libraryHaskellDepends = [
@@ -5149,7 +5150,7 @@ self: {
      mkDerivation {
        pname = "Frank";
        version = "0.3";
-       sha256 = "1p99ab5qgvyh13iy9wgv0a8lqx6s2mygx0s6z51m5mzi9nxf0qw1";
+       sha256 = "8163e0ba4df1d75243f94683fe7c15da744c9102fbf1e4e308d0ef87cb5229dd";
        isLibrary = false;
        isExecutable = true;
        executableHaskellDepends = [ base mtl newtype she void ];
@@ -5164,7 +5165,7 @@ self: {
      mkDerivation {
        pname = "FreeTypeGL";
        version = "0.0.4";
-       sha256 = "10sivjxppn138805iwka54cfby59nc39ja30nx2w3762fybz71af";
+       sha256 = "4e85f39777c29cc145b760289906b3a9f8e518296af258004223d87bbbdc5183";
        isLibrary = true;
        isExecutable = true;
        libraryHaskellDepends = [ base freetype2 OpenGL ];
@@ -5179,7 +5180,7 @@ self: {
      mkDerivation {
        pname = "FunGEn";
        version = "0.4.6.1";
-       sha256 = "0v9y9a82d2h34ai5hhwnalgfs5m2s909blr4f30dawgryn8gnbfp";
+       sha256 = "d72dfb90f5f971d5c07024d39540d2a216ed1e55964358a222038a26904a3e6d";
        isLibrary = true;
        isExecutable = true;
        libraryHaskellDepends = [ base GLUT OpenGL random ];
@@ -5198,7 +5199,7 @@ self: {
      mkDerivation {
        pname = "Fungi";
        version = "1.0.6";
-       sha256 = "181m78c0m1ldnkpng0sps9fbkpq5j4p57j0km34g5kwasxhmwfcc";
+       sha256 = "8c395e61d78acff2c8a813c8532e9105dfb95cd2578367efb48d860a183a35a0";
        isLibrary = false;
        isExecutable = true;
        executableHaskellDepends = [
@@ -5216,7 +5217,7 @@ self: {
      mkDerivation {
        pname = "GA";
        version = "1.0";
-       sha256 = "1nsmpph27yv0anrhhfqbpdqs2rrdbhm0jxzs3kk6ab32zb3ivhp2";
+       sha256 = "e2c21dc7fa622c65e61cfa77092a5c2d67a171bb0b3b08b35560fb23e0bd55db";
        libraryHaskellDepends = [ base directory random transformers ];
        homepage = "http://boegel.kejo.be";
        description = "Genetic algorithm library";
@@ -5228,7 +5229,7 @@ self: {
      mkDerivation {
        pname = "GGg";
        version = "0.1.0.2";
-       sha256 = "129z0391zm7v4ixwwq2irqhpb43s5pd0imgh3i9i5l9ahq9lk1h7";
+       sha256 = "07864913862ad112531cf0d508da2d7a907521ce5160ce7b24fbd41fd2003f89";
        isLibrary = false;
        isExecutable = true;
        executableHaskellDepends = [ base bimap ];
@@ -5243,7 +5244,7 @@ self: {
      mkDerivation {
        pname = "GHood";
        version = "0.0.4";
-       sha256 = "0ab6dngl8gjkj8wvjvrjijgqb59aq88c1ra2z92iqky2d0plrfca";
+       sha256 = "8ab94c2f68c24f1c45fa42e5c010c22a95859f8c326fb93992533e449f6d6629";
        libraryHaskellDepends = [ array base process ];
        homepage = "http://www.cs.kent.ac.uk/people/staff/cr3/toolbox/haskell/GHood";
        description = "A graphical viewer for Hood";
@@ -5256,7 +5257,7 @@ self: {
      mkDerivation {
        pname = "GLFW";
        version = "0.5.2.4";
-       sha256 = "1aac9xz943h3jjbx22kmvzmbzqw7k6cl2qsh1kr4nnx83pxrxz28";
+       sha256 = "48fc9efb1da85b4bf20c506341999987e3bfeadf750ad19794030e927e4f4ca9";
        libraryHaskellDepends = [ base OpenGL ];
        librarySystemDepends = [ libX11 mesa ];
        homepage = "http://haskell.org/haskellwiki/GLFW";
@@ -5269,7 +5270,7 @@ self: {
      mkDerivation {
        pname = "GLFW-OGL";
        version = "0.0";
-       sha256 = "118hpgdp8rb0jlvlibxcaia4jjjdrn8xpzyvj109piw63g44n910";
+       sha256 = "20244bc81b86c79b4090dbffdb91cd4d4a495454acaf483795606574dbbb1085";
        libraryHaskellDepends = [ base mtl OGL ];
        librarySystemDepends = [ libX11 libXrandr ];
        homepage = "http://haskell.org/haskellwiki/GLFW-OGL";
@@ -5286,7 +5287,7 @@ self: {
      mkDerivation {
        pname = "GLFW-b";
        version = "1.4.7.2";
-       sha256 = "1hjsv6yqkwqi18c1vha105jl56xjvb5dqwqs4bgjkk99qcqq70rd";
+       sha256 = "2d838331c329cd29df221a73dccadab29b42650141c11d180a11f389bdd95ac2";
        libraryHaskellDepends = [ base bindings-GLFW ];
        testHaskellDepends = [
          base bindings-GLFW HUnit test-framework test-framework-hunit
@@ -5302,7 +5303,7 @@ self: {
      mkDerivation {
        pname = "GLFW-b-demo";
        version = "1.0.6";
-       sha256 = "01qf0bsv3q60m3as763q49hd3nm5lkady48nc214zjsx31x8by59";
+       sha256 = "a9f8857a185dcb4f82601611dfd4a4a5dad160227898a3d5a8c0e0b1f5020e07";
        isLibrary = false;
        isExecutable = true;
        executableHaskellDepends = [
@@ -5318,7 +5319,7 @@ self: {
      mkDerivation {
        pname = "GLFW-task";
        version = "0.2.0";
-       sha256 = "110iwxp6xs3wj4bva8m6mgz7iq90zrcz2dnjlq3s2x3in2m4818p";
+       sha256 = "170544aab07174a107a6d236f159fe20e178feaba622b517917ce86e6ee71184";
        libraryHaskellDepends = [
          base GLFW monad-task OpenGL transformers
        ];
@@ -5333,7 +5334,7 @@ self: {
      mkDerivation {
        pname = "GLHUI";
        version = "1.1.0";
-       sha256 = "043xw36hrwzc6xdr5vlydbsv5m8675vnk8pfxycr7qixzwljn0aa";
+       sha256 = "4a012b29ff3de29399efeea269773906d5b2f56a9eee925b37ecf30ccde07d10";
        libraryHaskellDepends = [ base ];
        librarySystemDepends = [ libX11 mesa ];
        description = "Open OpenGL context windows in X11 with libX11";
@@ -5345,7 +5346,7 @@ self: {
      mkDerivation {
        pname = "GLMatrix";
        version = "0.1.0.1";
-       sha256 = "13n80rplyl73ahk8cxgvs9gf655l063sd55spx0zvhw774vvxwv4";
+       sha256 = "64f3be373987c3fd41bfba94a68701b414e35ed2fb75862654e3504f6f06c88e";
        libraryHaskellDepends = [ base OpenGLRaw ];
        jailbreak = true;
        homepage = "https://github.com/fiendfan1/GLMatrix";
@@ -5358,7 +5359,7 @@ self: {
      mkDerivation {
        pname = "GLURaw";
        version = "1.5.0.1";
-       sha256 = "1wf8nav298wsjl417vgp94wdvh38g8hxvb20iyivxhi0g1iw4lhv";
+       sha256 = "1b52c2637820c2bea38f40acdd217a68c0dd3849f7ed1308959aa324b6b2c8f1";
        libraryHaskellDepends = [ base OpenGLRaw transformers ];
        librarySystemDepends = [ freeglut mesa ];
        homepage = "http://www.haskell.org/haskellwiki/Opengl";
@@ -5373,7 +5374,7 @@ self: {
      mkDerivation {
        pname = "GLUT";
        version = "2.7.0.1";
-       sha256 = "0kcw8nf0k0ql220yy6sp3cf0vhij378j94l3ffrz3nynxq5xh7pv";
+       sha256 = "fb1ed80beed6dbf1b373839224d11932c20d1c1b571bef81101483099c459c4d";
        libraryHaskellDepends = [
          array base containers OpenGL OpenGLRaw StateVar transformers
        ];
@@ -5391,7 +5392,7 @@ self: {
      mkDerivation {
        pname = "GLUtil";
        version = "0.8.6";
-       sha256 = "15z6l1r4dn8jp5b7awzw16zxd3lh297iwab712ah0dx8m3hk0df3";
+       sha256 = "c33530e1a8a83700950867291e4f12908ed6bf09fc737556b912d94672a0e697";
        libraryHaskellDepends = [
          array base bytestring containers directory filepath JuicyPixels
          linear OpenGL OpenGLRaw transformers vector
@@ -5408,7 +5409,7 @@ self: {
      mkDerivation {
        pname = "GPX";
        version = "0.8.0";
-       sha256 = "08qvl4l81bgjx40nmlrmb0csxa3xjj4l0dbq9bzcq65p403xs1pk";
+       sha256 = "f306dd0720b718ccfe4a78354089947da8ae195835d36a01e9f2ad8028a11b23";
        libraryHaskellDepends = [
          base comonad comonad-transformers containers data-lens hxt newtype
          xsd
@@ -5427,7 +5428,7 @@ self: {
      mkDerivation {
        pname = "GPipe";
        version = "1.4.1";
-       sha256 = "0w1xgn7pmz9pgpimsmy3fx66dax37qkd5a5q0yk1fh396dxsybx3";
+       sha256 = "a32faf7b33694017a607b8a8d2263ea3ab664c77c3575de37d37fd7a8f7d3d70";
        libraryHaskellDepends = [
          base Boolean containers GLUT list-tries OpenGL transformers Vec
          Vec-Boolean
@@ -5444,7 +5445,7 @@ self: {
      mkDerivation {
        pname = "GPipe-Collada";
        version = "0.1.4";
-       sha256 = "0aqvyv50gx0qx7icp70pw73gr3p6y05dkn347nqx82jc9dyxjghw";
+       sha256 = "1c3ed97d4b4c0ad4b13d64d8d90af0e68efcc6e1179ccbe2e918f407caf61b2b";
        libraryHaskellDepends = [
          array base containers GPipe HaXml mtl Vec
        ];
@@ -5462,7 +5463,7 @@ self: {
      mkDerivation {
        pname = "GPipe-Examples";
        version = "0.1";
-       sha256 = "0ir32fx0mk5hmmqilv6z89453rqcsgbs13a6ln4cydlkw5lbgv1k";
+       sha256 = "33ecb768e19336cf88a5468da0d7d30ce7514842df6c1a71adb0cc0aba132347";
        isLibrary = false;
        isExecutable = true;
        executableHaskellDepends = [
@@ -5478,7 +5479,7 @@ self: {
      mkDerivation {
        pname = "GPipe-TextureLoad";
        version = "1.0.4";
-       sha256 = "1yf74k3yvpj42ynivlkacp5zwxwsx3yyfxb2436ljrv3339kjkb4";
+       sha256 = "644d39d318636749cd206275e7fde89a77fecb656ad21dad1744deedc724c7f9";
        libraryHaskellDepends = [ base bitmap GPipe stb-image ];
        homepage = "http://www.haskell.org/haskellwiki/GPipe";
        description = "Load GPipe textures from filesystem";
@@ -5493,7 +5494,7 @@ self: {
      mkDerivation {
        pname = "GTALib";
        version = "0.0.6";
-       sha256 = "10l72wn8wdgcvpbcj10hmib6z0175ihsgvmwpp9akx4d6vpf2dz8";
+       sha256 = "e837e1ee368df4a9d2bdbceea7612c27806f56ac1004c9d6ddec358e2c178782";
        libraryHaskellDepends = [
          base containers deepseq parallel template-haskell
        ];
@@ -5516,7 +5517,7 @@ self: {
      mkDerivation {
        pname = "Gamgine";
        version = "0.5";
-       sha256 = "131pgif3x61agk6an27p33bnqi45zlyiwxivxkxdbzi82wckr0w0";
+       sha256 = "80833c191728fed5faec3b761e3dfd85446cd718f708abcc7c2a983e5c7c378c";
        libraryHaskellDepends = [
          array base bytestring composition cpphs data-lens directory
          filepath GLFW-b ListZipper mtl OpenGLRaw parsec pretty-show
@@ -5534,7 +5535,7 @@ self: {
      mkDerivation {
        pname = "Ganymede";
        version = "0.0.0.5";
-       sha256 = "1fmb6fpdfk21yxrvlgdg32qymzirfbygsq6p4jvm925kvpwqbcwk";
+       sha256 = "93b385f9ddb38854b724d760fdfc7239feeab118af3dba73f7414cd7ae33abba";
        isLibrary = false;
        isExecutable = true;
        executableHaskellDepends = [
@@ -5552,7 +5553,7 @@ self: {
      mkDerivation {
        pname = "GaussQuadIntegration";
        version = "0.1";
-       sha256 = "0v91q0m90338qpxg4hnvb7n6vm1jap3y1rvn9kyzmnxh03rarpx2";
+       sha256 = "a2dfacf200b0dbfafd4c76e7e0c75532d46dec59db42f2fac5680c902ac0216d";
        libraryHaskellDepends = [ base ];
        description = "Non-adaptive Gaussian quadrature for numeric integraton";
        license = stdenv.lib.licenses.bsd3;
@@ -5563,7 +5564,7 @@ self: {
      mkDerivation {
        pname = "GeBoP";
        version = "1.7.4.1";
-       sha256 = "0cldjrk26p2llyhsp1rcvzbgz5qg8k898fvmdxkfc9ihc5lsxxf5";
+       sha256 = "c5f5ae69613026e6666f753b94d0440f97ffd6df2c87aba1a7545c2366968d32";
        isLibrary = false;
        isExecutable = true;
        executableHaskellDepends = [
@@ -5584,7 +5585,7 @@ self: {
      mkDerivation {
        pname = "GenI";
        version = "0.24.3";
-       sha256 = "0gmig362ayxxqgj4m6g1r1i6q5zfg6j8bmvsd7i9kmqn12nl3l0p";
+       sha256 = "17d041ad0816d799e2697ad785a479ee176c62c8e1994ae4c3bd7b25cc78b13e";
        isLibrary = true;
        isExecutable = true;
        libraryHaskellDepends = [
@@ -5614,7 +5615,7 @@ self: {
      mkDerivation {
        pname = "GenSmsPdu";
        version = "0.1";
-       sha256 = "1vs1m78lp87mccqs3i80zpl121yb063vqxx6a4sqzkfxzhvjvcbz";
+       sha256 = "7fb12d37fcddcd8f3551a677bc8701cb0711e8fd00c5a13163f5a04bd1a941ef";
        isLibrary = false;
        isExecutable = true;
        executableHaskellDepends = [ base haskell98 QuickCheck random ];
@@ -5630,7 +5631,7 @@ self: {
      mkDerivation {
        pname = "Genbank";
        version = "1.0.3";
-       sha256 = "14rbknlc1bxrld04i7dc5dklng5sp0b1rbiilndw5cair0d67brb";
+       sha256 = "2baf631ac851b1c29ba531ae1c16b8ba3c4b672bac9d4840a3b9afc0a89d2b93";
        isLibrary = true;
        isExecutable = true;
        libraryHaskellDepends = [
@@ -5646,7 +5647,7 @@ self: {
      mkDerivation {
        pname = "GeneralTicTacToe";
        version = "0.1.0.1";
-       sha256 = "0dng5shk5zs4j6lyjz971axrqziv6davpcyv509mz8fvdjn8q4kg";
+       sha256 = "6f128cac6cdba15f1328dbb3bb55333b7e9cbb0a277de9a99144ff32a12ecf36";
        isLibrary = false;
        isExecutable = true;
        executableHaskellDepends = [ base ];
@@ -5662,7 +5663,7 @@ self: {
      mkDerivation {
        pname = "GenericPretty";
        version = "1.2.1";
-       sha256 = "0bb70mic7srr7x8k83d1i0m0a32gm72zr78ccdf3ckchj9136php";
+       sha256 = "175e334292904d365c630c9dfcc5a94f0c052a88a10d34513f39ebc36205672d";
        libraryHaskellDepends = [ base ghc-prim pretty ];
        homepage = "https://github.com/RazvanRanca/GenericPretty";
        description = "A generic, derivable, haskell pretty printer";
@@ -5679,7 +5680,7 @@ self: {
      mkDerivation {
        pname = "GenussFold";
        version = "0.0.0.2";
-       sha256 = "1byshl3wa637nnvwxa80r9p1azgvgbczp5j77hpqaxacxkx1q0sm";
+       sha256 = "55031cfaec4c75852f3c4796fbd97afb7d156eca00a9ceb7b56718c50785daaf";
        isLibrary = true;
        isExecutable = true;
        libraryHaskellDepends = [
@@ -5702,7 +5703,7 @@ self: {
      mkDerivation {
        pname = "GeoIp";
        version = "0.3";
-       sha256 = "1q3km52w7qcrawbgaxvglb3x6rgc8f22c8rw8705lgcxxn9pjxm1";
+       sha256 = "a1767993ed9d3d5ac0413c23268443ec65d3c7a26f77f5165799e1c345a973e0";
        libraryHaskellDepends = [ base bytestring bytestring-mmap syb ];
        description = "Pure bindings for the MaxMind IP database";
        license = "unknown";
@@ -5714,7 +5715,7 @@ self: {
      mkDerivation {
        pname = "Geodetic";
        version = "0.4";
-       sha256 = "1nb0q5hs9qqgygw35rbvanbjf9l6vjxrl6l4jp9dqwlnl1kdd88q";
+       sha256 = "18a1d666a09672dcd295841a9abbdc86262797557be532f8f30fe3a461c160d9";
        libraryHaskellDepends = [ base ];
        homepage = "http://code.google.com/p/geodetic/";
        description = "Geodetic calculations";
@@ -5726,7 +5727,7 @@ self: {
      mkDerivation {
        pname = "GeomPredicates";
        version = "0.1";
-       sha256 = "19scirh2hy9y9kv16pcp44v31cs3868ig28r8blj39gdv4wqxwcy";
+       sha256 = "9ef18e39d9eda521e942198917914143b3303621975d13f64c3e7928608e4ca7";
        libraryHaskellDepends = [ base ];
        description = "Geometric predicates";
        license = stdenv.lib.licenses.bsd3;
@@ -5737,7 +5738,7 @@ self: {
      mkDerivation {
        pname = "GeomPredicates-SSE";
        version = "0.2";
-       sha256 = "18mdaf2j1svklka5ms9ihj07d9l92ivqjk0y8jv0l9ni44hrhxcq";
+       sha256 = "9875982121d1260ab6441e4c89771489a676808431e95ad4a473eb208553ada2";
        libraryHaskellDepends = [ base GeomPredicates ];
        description = "Geometric predicates (Intel SSE)";
        license = stdenv.lib.licenses.bsd3;
@@ -5749,7 +5750,7 @@ self: {
      mkDerivation {
        pname = "GiST";
        version = "0.0.1";
-       sha256 = "0ykvsjqpi7pd81857n2gqycgpnm0j8dxnpf345h7pgzrkz10qi9f";
+       sha256 = "2e450cc29ff9bf7b6021c35ddb1b92a0dafb98c74fd8535040ed9e78b1d47b7a";
        libraryHaskellDepends = [ base text ];
        jailbreak = true;
        description = "A Haskell implementation of a Generalized Search Tree (GiST)";
@@ -5761,7 +5762,7 @@ self: {
      mkDerivation {
        pname = "GiveYouAHead";
        version = "0.2.2.3";
-       sha256 = "10f9yl62gwnjmb0mbfffdzhwscpwpvq9gj52zsrz8w6z6sbkijbf";
+       sha256 = "6ec9389736df70f4b3fea2c897f0befc32cde16fceb955c1aad2f2270cf5c981";
        libraryHaskellDepends = [ base directory extra old-time process ];
        homepage = "https://github.com/Qinka/GiveYouAHead/";
        description = "to auto-do somethings";
@@ -5775,7 +5776,7 @@ self: {
      mkDerivation {
        pname = "Glob";
        version = "0.7.5";
-       sha256 = "0hdyi49zp2yr4h4wgngl8ajrss1p309c3pn0alj543yrh33bnqq0";
+       sha256 = "0063bbc680d90f522455c0dec1121837689da542f4d9c70924d98bfb1389be41";
        revision = "1";
        editedCabalFile = "219b9caf1aaf9c2ab69ac75242f6017f0cd804a3370e0d63ac48777888fd909b";
        libraryHaskellDepends = [
@@ -5791,7 +5792,7 @@ self: {
      mkDerivation {
        pname = "GlomeTrace";
        version = "0.3";
-       sha256 = "0n1290ls68fsky3a80fvfdq6bycvmpn3i3kmflq6yn45qa959f0k";
+       sha256 = "13b85492c285586f3075758e38ecad9bf9657073db01a4869fda21a329482258";
        libraryHaskellDepends = [ array base GlomeVec ];
        homepage = "http://www.haskell.org/haskellwiki/Glome";
        description = "Ray Tracing Library";
@@ -5804,7 +5805,7 @@ self: {
      mkDerivation {
        pname = "GlomeVec";
        version = "0.2";
-       sha256 = "08hyiadkbkmcsd1g51xvxqzp6l94hnqqbz4r6yk0zk29iawq8610";
+       sha256 = "201884b98a49cc0fa63799fc85b1852451733feebb87f242d3acce359b8a1e22";
        libraryHaskellDepends = [ array base ];
        libraryPkgconfigDepends = [ llvm ];
        homepage = "http://www.haskell.org/haskellwiki/Glome";
@@ -5819,7 +5820,7 @@ self: {
      mkDerivation {
        pname = "GlomeView";
        version = "0.3";
-       sha256 = "0plglb289gadk8mqxgqj8n25xa6dql2jl0b8cm9v7q5rwykx0kbq";
+       sha256 = "784dd0a7e7b9e0b3536568012a05c5cda85e844512bf8e2b9a4dbd84c4a28f5e";
        isLibrary = false;
        isExecutable = true;
        executableHaskellDepends = [
@@ -5836,7 +5837,7 @@ self: {
      mkDerivation {
        pname = "GoogleChart";
        version = "0.2";
-       sha256 = "0wfabsdn4agmg459srnknkwqb7ri5knj9npzgzhilybwrrqq46v9";
+       sha256 = "691b8271ce7c791ae17fffda24ed2c319f85f9b4d3669d0a79f529629b5eca71";
        libraryHaskellDepends = [ base ];
        homepage = "http://neugierig.org/software/darcs/browse/?r=google-chart;a=summary";
        description = "Generate web-based charts using the Google Chart API";
@@ -5850,7 +5851,7 @@ self: {
      mkDerivation {
        pname = "GoogleDirections";
        version = "0.3.0.1";
-       sha256 = "1x7k72iy8aa6r60p3hrqb8a4p5avyjh8czymrkarc3wpkc73bjb3";
+       sha256 = "63c9350e9b970f96d5ccd57f86a0f45b954b145a38c37181c94629e4a338f3f4";
        libraryHaskellDepends = [
          AttoJson base bytestring containers dataenc download-curl
        ];
@@ -5866,7 +5867,7 @@ self: {
      mkDerivation {
        pname = "GoogleSB";
        version = "0.1";
-       sha256 = "1gfjpxcjr9xqinha3wzdk101avjzyvji2xs5abkj9pj8lsrbh2w8";
+       sha256 = "880bb8b2a648de24e752457711e5f65f6e154098edf3a1a08db8a72c59bfd2bd";
        libraryHaskellDepends = [
          base binary Crypto haskell98 HTTP mtl network split
        ];
@@ -5880,7 +5881,7 @@ self: {
      mkDerivation {
        pname = "GoogleSuggest";
        version = "0.0.4";
-       sha256 = "1jqfd9zi4yp0kr506v71dlg5zgmvzqbxdsfjr2574ajx5xp2fjrb";
+       sha256 = "2b4b276e2f5d2a728ac8d2e9d617febbbe5f1e6de16c034a9ee07a127f6a0ecb";
        libraryHaskellDepends = [
          base dataenc download-curl utf8-string xml
        ];
@@ -5894,7 +5895,7 @@ self: {
      mkDerivation {
        pname = "GoogleTranslate";
        version = "0.0.5";
-       sha256 = "0hr0rjz7nx5rcy4h5pcbvh8sh9v4qvl9ffrqhnrcslh7ibvwbca6";
+       sha256 = "46b1c5f78a0752cdb285383b97e8c66427a811dc8bdd028967b9747bbecc2043";
        libraryHaskellDepends = [
          AttoJson base bytestring dataenc download-curl
        ];
@@ -5907,7 +5908,7 @@ self: {
      mkDerivation {
        pname = "GotoT-transformers";
        version = "1.0.0.1";
-       sha256 = "1w1w1p2cpndiilr002whm58bzqjh9cp9lw3jl7khdxh20c1dfzhy";
+       sha256 = "1e7ed7020302f606e7a172709a2e4b50e2bf50a9900b00328db1d9cbc40d3cf0";
        libraryHaskellDepends = [ base transformers ];
        jailbreak = true;
        homepage = "http://github.com/gcross/GotoT-transformers";
@@ -5924,7 +5925,7 @@ self: {
      mkDerivation {
        pname = "GrammarProducts";
        version = "0.1.1.0";
-       sha256 = "026sjppwk0g10zyw64rds1fifdi7d6p7jzri35cl6hxc33fqdiy3";
+       sha256 = "c3c786dd18ac43435919317f79ae692736175dd02d13c3fd07e181c9ef95da08";
        isLibrary = true;
        isExecutable = true;
        libraryHaskellDepends = [
@@ -5944,7 +5945,7 @@ self: {
      mkDerivation {
        pname = "Graph500";
        version = "0.4.0";
-       sha256 = "0lhn2r54488949gh5m5fgwrj2z30r9pf34860sikb6zq07gjz759";
+       sha256 = "a99c2fdf01f89b35a3060691e16eca607c21337faed4025f220921424a161652";
        isLibrary = true;
        isExecutable = true;
        libraryHaskellDepends = [
@@ -5962,7 +5963,7 @@ self: {
      mkDerivation {
        pname = "GraphHammer";
        version = "0.3";
-       sha256 = "0fga3g2y38ylvmkgi57h4j5brc7gjxh8d183qfa2vhx8i4sr3pzm";
+       sha256 = "f5df913589a8c32d94c30385866097efb0bc8a24f094f866ddd4a3e1c51bea39";
        libraryHaskellDepends = [
          array base containers Graph500 mtl stm time
        ];
@@ -5978,7 +5979,7 @@ self: {
      mkDerivation {
        pname = "GraphHammer-examples";
        version = "0.3";
-       sha256 = "18p1dr08nq8dnvghkshihzra0p9ja0qa9bxbkm561jkrdpk3zndv";
+       sha256 = "bbd93fe66d79ca604a9dabafa43050325da0f28711ea09dfb60d618b406ee1a2";
        isLibrary = true;
        isExecutable = true;
        executableHaskellDepends = [
@@ -5994,7 +5995,7 @@ self: {
      mkDerivation {
        pname = "GraphSCC";
        version = "1.0.4";
-       sha256 = "1wbcx3wb02adb7l4nchxla3laliz0h5q074vfw4z0ic833k977bq";
+       sha256 = "789d93e6188845f009779b1c800b043f524587a21d324be8594d09b0f8e86cf1";
        libraryHaskellDepends = [ array base containers ];
        description = "Tarjan's algorithm for computing the strongly connected components of a graph";
        license = stdenv.lib.licenses.bsd3;
@@ -6008,7 +6009,7 @@ self: {
      mkDerivation {
        pname = "Graphalyze";
        version = "0.14.1.0";
-       sha256 = "0pyrhpl06lsppr8ch21crinkax7fh0k18wfvgjinc8phkk6j5hz3";
+       sha256 = "e3c322cd9cf02266a37cdb71142680ee74356dcc2c08c850be575303e885d95f";
        libraryHaskellDepends = [
          array base bktrees containers directory fgl filepath graphviz
          old-locale pandoc process random text time
@@ -6025,7 +6026,7 @@ self: {
      mkDerivation {
        pname = "Grempa";
        version = "0.2.2";
-       sha256 = "0w0apbk8hw555cbpprvxpnxviyzmbsxzlc6qpf6w0cfsybkkiv1f";
+       sha256 = "2eec38e7f2da31c08dbbd830fabb5ef5fbb8bbbd7de77b172ba57088e6ba0a70";
        libraryHaskellDepends = [
          array base containers mtl QuickCheck template-haskell th-lift
        ];
@@ -6039,7 +6040,7 @@ self: {
      mkDerivation {
        pname = "GroteTrap";
        version = "0.5.1";
-       sha256 = "131i63paaapdbdnqvmacsfqbg1719xlbx8phjchw6zlh9njn727k";
+       sha256 = "f38863a54d907ec32193f0a2be684fe184b7b0d34cd58d6d5bed2aa5ee30318c";
        libraryHaskellDepends = [ base mtl parsec QuickCheck syb ];
        jailbreak = true;
        homepage = "http://www.haskell.org/haskellwiki/GroteTrap";
@@ -6056,7 +6057,7 @@ self: {
      mkDerivation {
        pname = "Grow";
        version = "1.1.0.3";
-       sha256 = "1vc4ln5fzvcv68qlanyw8mc6qchnjn1kj9rpz661n8ia1x8gkb3l";
+       sha256 = "74acf9500f2a221b8cf9372739839516326c5845dc5b4531329bedef8aa584ed";
        revision = "3";
        editedCabalFile = "e599aab8eefc612bbf1dbae0b60308305a9d3009dda186b228e4e8aeeda1f36a";
        libraryHaskellDepends = [
@@ -6078,7 +6079,7 @@ self: {
      mkDerivation {
        pname = "GrowlNotify";
        version = "0.4";
-       sha256 = "13m213d6l81k0iwjbbwg8n2xz960dhfnrs1il48xvlc8z25y6nh5";
+       sha256 = "055ae38bf888d1dd11a131e86c1d6cc0a4df85458faf25790433206ada08a28e";
        isLibrary = true;
        isExecutable = true;
        libraryHaskellDepends = [
@@ -6099,7 +6100,7 @@ self: {
      mkDerivation {
        pname = "Gtk2hsGenerics";
        version = "0.1";
-       sha256 = "1gj775yny73qvi3inc38c6yy1av503m5ilbz7ch0xx4a3ywnw5l9";
+       sha256 = "89166eb91f8af40e203b7fd158ea0065abe0bd6168301b47dc781c6f7d3947be";
        libraryHaskellDepends = [
          array base cairo containers glib gtk haskell98 mtl
        ];
@@ -6115,7 +6116,7 @@ self: {
      mkDerivation {
        pname = "GtkGLTV";
        version = "0.2.0";
-       sha256 = "1xkc3ga65prffjzlymimwmfnmvf0lc42h2rm4b72rlmm8316kmp2";
+       sha256 = "e2d669c240b5d22cce22350b2808a3c0ed6a5de535564fbf742edf62d41b6cf6";
        libraryHaskellDepends = [
          base bitmap bitmap-opengl gtk gtkglext GtkTV OpenGL stb-image time
        ];
@@ -6129,7 +6130,7 @@ self: {
      mkDerivation {
        pname = "GtkTV";
        version = "0.2.0";
-       sha256 = "0jxx8lgg533kjvq1sxr4jvqvxj9pcpabsy2mvbpsd2lwv2ffr618";
+       sha256 = "2898ec9cd89c8aa6efda5578bdd46537c9bef19624771df096738cf21e45bd4b";
        libraryHaskellDepends = [
          base gtk time TV TypeCompose vector-space
        ];
@@ -6145,7 +6146,7 @@ self: {
      mkDerivation {
        pname = "GuiHaskell";
        version = "0.1.1";
-       sha256 = "1rgyrbnlbvsqgd8m36fccq7qzxj2n682lz2rdq04j35zsgajyk11";
+       sha256 = "214c2fd5d3bf0c49006e597c2a90b142f68f0f66cc9951517b58ef45edcafee5";
        isLibrary = false;
        isExecutable = true;
        executableHaskellDepends = [
@@ -6163,7 +6164,7 @@ self: {
      mkDerivation {
        pname = "GuiTV";
        version = "0.4";
-       sha256 = "15mndbxm83q0d8ci3vj51zwrmzl0f5i5yqv0caw05vlzfsr4ib5i";
+       sha256 = "b1ac48b2769fee02b86260635f627180fe9af90f45ee11196a000f54fb6ab696";
        libraryHaskellDepends = [ base DeepArrow phooey TV TypeCompose ];
        homepage = "http://haskell.org/haskellwiki/GuiTV";
        description = "GUIs for Tangible Values";
@@ -6176,7 +6177,7 @@ self: {
      mkDerivation {
        pname = "HARM";
        version = "0.1.4";
-       sha256 = "0mld40jm0qnsr9flbip3s2lxwd43nhzs11v23bm5m2s83y6j33jn";
+       sha256 = "568e218d1f488b5aea1a6287a03fb48334dea9d0e3c6455dcada625025208d56";
        isLibrary = true;
        isExecutable = true;
        libraryHaskellDepends = [ array base ];
@@ -6194,7 +6195,7 @@ self: {
      mkDerivation {
        pname = "HAppS-Data";
        version = "0.9.3";
-       sha256 = "0df3bcvqpmjrg2c28jny20r52f3x7gf1wy7r8x71j9wrji56yg5j";
+       sha256 = "b23c6f4a949927194e47f9781edc3b7d38513210de4a24987859d68b375bc335";
        libraryHaskellDepends = [
          base binary bytestring containers HAppS-Util HaXml mtl pretty syb
          syb-with-class template-haskell
@@ -6212,7 +6213,7 @@ self: {
      mkDerivation {
        pname = "HAppS-IxSet";
        version = "0.9.3";
-       sha256 = "0wm3apqsqb2p9cqxikz9j6lzi66ya1sn1yplifqszg1v2lpdgb7b";
+       sha256 = "ebacd72e153bbcafb18bf4fa607550de98f8a991e9cfd8314b572cacf155a372";
        libraryHaskellDepends = [
          base containers HAppS-Data HAppS-State HAppS-Util hslogger mtl syb
          syb-with-class template-haskell
@@ -6230,7 +6231,7 @@ self: {
      mkDerivation {
        pname = "HAppS-Server";
        version = "0.9.3.1";
-       sha256 = "0f10qp2aiv036izzdpfpgmja5kqx68kccazkn1cdap636brjjcdh";
+       sha256 = "b03129f332c35cd558b0f32bc626321dcfa2647dd7ddf67f3403eca8c4c52038";
        libraryHaskellDepends = [
          base bytestring containers directory HAppS-Data HAppS-IxSet
          HAppS-State HAppS-Util HaXml hslogger html HTTP mtl network
@@ -6252,7 +6253,7 @@ self: {
      mkDerivation {
        pname = "HAppS-State";
        version = "0.9.3";
-       sha256 = "1r1ing4c8s91d9p41q7yv6v6xaqs9si438j7b5vnzxgwz0syd6ah";
+       sha256 = "5099e635f8fcf56f775947a241a24e1aab6eb6d9fee0406e6a2169c4c8b331e4";
        libraryHaskellDepends = [
          base binary bytestring containers directory filepath HAppS-Data
          HAppS-Util HaXml hslogger hspread mtl network old-locale old-time
@@ -6271,7 +6272,7 @@ self: {
      mkDerivation {
        pname = "HAppS-Util";
        version = "0.9.3";
-       sha256 = "0mg6p14xv6f9b1rb77mvadzchf6limcypi6z0di1n49pdqjhs4pr";
+       sha256 = "f9120d256e37111b6203dfc4eb598dd438c87e53bb9eb37258c999dd49b8e655";
        libraryHaskellDepends = [
          array base bytestring directory hslogger mtl old-time process
          template-haskell
@@ -6286,7 +6287,7 @@ self: {
      mkDerivation {
        pname = "HAppSHelpers";
        version = "0.11";
-       sha256 = "1hwxh60b26chcd466vlpxc7hx3smdnfl40mfxpyh8j1597v2aqa3";
+       sha256 = "436125f649254804fdedae02429d6d558f0e0feb976e6348639019b180819dc3";
        description = "OBSOLETE. Please use happstack-helpers";
        license = stdenv.lib.licenses.bsd3;
        hydraPlatforms = stdenv.lib.platforms.none;
@@ -6297,7 +6298,7 @@ self: {
      mkDerivation {
        pname = "HCL";
        version = "1.4";
-       sha256 = "0dzfnvdc1nm4f7q759xnq1lavi90axc7b6jd39sl898jbjg8wrrl";
+       sha256 = "34678e9e5c122544751a4d9a75585720c5ad68c0b6a772f071a4dac0dab6ee37";
        isLibrary = true;
        isExecutable = true;
        libraryHaskellDepends = [ base containers mtl QuickCheck random ];
@@ -6316,7 +6317,7 @@ self: {
      mkDerivation {
        pname = "HCard";
        version = "0.0";
-       sha256 = "0bvj1vc8m69bsnjz8xb4nbbpbd4xbqp4kfab0bmk6a4ixgnqk14b";
+       sha256 = "8b8489edeb912833eb024bb9492e5e9db475d7b26475f4a5d52b998ad80e722f";
        libraryHaskellDepends = [
          base mtl QuickCheck random random-shuffle
        ];
@@ -6331,7 +6332,7 @@ self: {
      mkDerivation {
        pname = "HCodecs";
        version = "0.5";
-       sha256 = "0mhp1alx0p9lzq3vm0k802f8ndm2386sshprn9zb8xq8bsd11gxi";
+       sha256 = "b1bf109a5e0877b47eb2f942ad0d1aa2368b9c006882ba07fe345dd0a90a1756";
        libraryHaskellDepends = [
          array base bytestring QuickCheck random
        ];
@@ -6348,7 +6349,7 @@ self: {
      mkDerivation {
        pname = "HDBC";
        version = "2.4.0.1";
-       sha256 = "1bfjffn44n8w0bvznjiqm4ckfs28nipachip98f125p784ff4gks";
+       sha256 = "7a3ee21c41e716111c4a3742a66eb448683719a9384afbf7021c5942ac73d2ad";
        isLibrary = true;
        isExecutable = true;
        libraryHaskellDepends = [
@@ -6365,7 +6366,7 @@ self: {
      mkDerivation {
        pname = "HDBC-mysql";
        version = "0.6.6.1";
-       sha256 = "1q50xynasb2h65g14ycz4s38fyz185yz1sp9rl02h4p940pz7w9m";
+       sha256 = "35f1f32f20e9122800cde9eaf07d41e17b8786269f79125e31502cadacefa0e0";
        libraryHaskellDepends = [ base bytestring HDBC time utf8-string ];
        homepage = "http://github.com/bos/hdbc-mysql";
        description = "MySQL driver for HDBC";
@@ -6380,7 +6381,7 @@ self: {
      mkDerivation {
        pname = "HDBC-odbc";
        version = "2.4.0.1";
-       sha256 = "1sdf5llz40q9cg0gi0rglnz6agamb7z4n5c6dhwwly902b6fxinv";
+       sha256 = "dbc6eecc122079ca396c86154bfe59553d65bea52f83f8c0630903f2292daee9";
        isLibrary = true;
        isExecutable = true;
        libraryHaskellDepends = [
@@ -6400,7 +6401,7 @@ self: {
      mkDerivation {
        pname = "HDBC-postgresql";
        version = "2.3.2.3";
-       sha256 = "1jv43rv3a0x7b7q5vzp07xffaf690gijx3rqnfv19fk63a7075j3";
+       sha256 = "4396038e1a66ba14b6b3388f2ee303c938e55c3fe0fe5df059a70335761e64cb";
        isLibrary = true;
        isExecutable = true;
        libraryHaskellDepends = [
@@ -6419,7 +6420,7 @@ self: {
      mkDerivation {
        pname = "HDBC-postgresql-hstore";
        version = "0.0.1.2";
-       sha256 = "0657a1qy51bihh9gvpwpqpm4gch68rw32plnjcfdbc37yjq5dj1d";
+       sha256 = "2dc856b0f467b0d51c93965e31784606b247eac597dffd12847185e27150a718";
        libraryHaskellDepends = [ attoparsec base containers HDBC text ];
        jailbreak = true;
        homepage = "https://bitbucket.org/dpwiz/hdbc-postgresql-hstore";
@@ -6432,7 +6433,7 @@ self: {
      mkDerivation {
        pname = "HDBC-session";
        version = "0.1.0.0";
-       sha256 = "1fxx0q9hnxwsivsg2qinm0n3lvf89r9b72cnhipjlpf36nin5x5w";
+       sha256 = "bcf462a335c35d2a6f849689b3524ec86d3a2ca83662f1f48e9a770b1306bdbb";
        libraryHaskellDepends = [ base HDBC ];
        homepage = "http://khibino.github.io/haskell-relational-record/";
        description = "Bracketed connection for HDBC";
@@ -6445,7 +6446,7 @@ self: {
      mkDerivation {
        pname = "HDBC-sqlite3";
        version = "2.3.3.1";
-       sha256 = "1spbhvwwyj4q7li33kvw1bsr6m1xbnxipga67s7cdgvyf2mxk0x7";
+       sha256 = "a783d9ab707ebfc68e3e46bd1bbb5d3d5493f50a7ccf31223d9848cff986ebea";
        isLibrary = true;
        isExecutable = true;
        libraryHaskellDepends = [ base bytestring HDBC mtl utf8-string ];
@@ -6463,7 +6464,7 @@ self: {
      mkDerivation {
        pname = "HDRUtils";
        version = "1.0.2";
-       sha256 = "0rkykxmqpqiclvxlvfd0v9rrvkkb25shyajdmajxisfqxl684y0g";
+       sha256 = "0f78820cedd8e9d8a5aa4d2a0f75116bce9d73daa0b94dfba62ce28b6b9f7e66";
        libraryHaskellDepends = [ array base colour containers mtl unix ];
        librarySystemDepends = [ pfstools ];
        jailbreak = true;
@@ -6478,7 +6479,7 @@ self: {
      mkDerivation {
        pname = "HERA";
        version = "0.2";
-       sha256 = "08lry7w4zb7j81q9d7rjpz0chcbr9laxi4h9dz327pfcgmy083sy";
+       sha256 = "5e0f047c7dccdd23c66f0992d8154d7931c8c0bf329f967040f2ac4ff8f19922";
        libraryHaskellDepends = [ base ];
        librarySystemDepends = [ mpfr ];
        license = stdenv.lib.licenses.bsd3;
@@ -6490,7 +6491,7 @@ self: {
      mkDerivation {
        pname = "HFuse";
        version = "0.2.4.5";
-       sha256 = "1894dk7flfdblyyrx0d1acznrdbjw41dnal45cqvrxz5vy4hd3p2";
+       sha256 = "e28e0689dfe5f7bc312b842adb02e172b56c3f53a1819ebda7ab39eace6c24a1";
        isLibrary = true;
        isExecutable = true;
        libraryHaskellDepends = [ base bytestring unix ];
@@ -6508,7 +6509,7 @@ self: {
      mkDerivation {
        pname = "HGL";
        version = "3.2.0.5";
-       sha256 = "0z8dfxg2x530lawx7gyv9d25wcfpwvbfmknq17d5wgkxz47j95wb";
+       sha256 = "8b97240ff97d3e5eda09d8ceead6e6d7315e444bdbbfd3b9a260942e5e770d7d";
        libraryHaskellDepends = [ array base X11 ];
        description = "A simple graphics library based on X11 or Win32";
        license = stdenv.lib.licenses.bsd3;
@@ -6523,7 +6524,7 @@ self: {
      mkDerivation {
        pname = "HGamer3D";
        version = "0.5.0";
-       sha256 = "00mkjpmygz3h7rq1y4b8r8gpg4qk52dah1q0h14f50cr2lxvq3b7";
+       sha256 = "670dbc3b159981e248800007a89a281393771fca68111f703e70fce7eb95b302";
        libraryHaskellDepends = [
          base HGamer3D-Audio HGamer3D-Common HGamer3D-Data
          HGamer3D-Graphics3D HGamer3D-InputSystem HGamer3D-Network
@@ -6541,7 +6542,7 @@ self: {
      mkDerivation {
        pname = "HGamer3D-API";
        version = "0.1.6";
-       sha256 = "14wji303z3frjr4rc675pcispbpbpm1ilj6g3cb1fxm5wmi30q5l";
+       sha256 = "b4603062e5a57617161bcf481a43bdebaeab23bbe518964996d98d3fc0889293";
        libraryHaskellDepends = [
          base haskell98 HGamer3D-Data HGamer3D-Ogre-Binding
          HGamer3D-SFML-Binding
@@ -6560,7 +6561,7 @@ self: {
      mkDerivation {
        pname = "HGamer3D-Audio";
        version = "0.5.0";
-       sha256 = "0zfzk0vjn2w127dxcsg64d8j6jw1an3i0a2v32sx05l6whrnhabd";
+       sha256 = "6d296833e48616d0b5185b28108755814b235123e669d6db11810b2b3798df7d";
        libraryHaskellDepends = [
          base containers HGamer3D-Common HGamer3D-Data HGamer3D-SFML-Binding
        ];
@@ -6575,7 +6576,7 @@ self: {
      mkDerivation {
        pname = "HGamer3D-Bullet-Binding";
        version = "0.2.1";
-       sha256 = "1ilj8p1gm56dffics90qj6gspnam56s84wvaig9s0cwjbwxqi4hy";
+       sha256 = "1e92883b5f9233a0d38b6a7382b42955d9ab9f911824cda273cd94fac24592c6";
        libraryHaskellDepends = [ base HGamer3D-Data ];
        homepage = "http://www.hgamer3d.org";
        description = "Windows Game Engine for the Haskell Programmer - Bullet Bindings";
@@ -6588,7 +6589,7 @@ self: {
      mkDerivation {
        pname = "HGamer3D-CAudio-Binding";
        version = "0.1.5";
-       sha256 = "1q69ffhnnh4iaghb1g8s6bqlsry7jy5sbp5vpg4lprnr4wna5ya1";
+       sha256 = "41f9a22c27d9e64bc9bbbbdca58b97c7674df1321abdb0e05391406ba173c9e0";
        libraryHaskellDepends = [ base haskell98 HGamer3D-Data ];
        librarySystemDepends = [ HGamer3DCAudio015 ];
        jailbreak = true;
@@ -6605,7 +6606,7 @@ self: {
      mkDerivation {
        pname = "HGamer3D-CEGUI-Binding";
        version = "0.5.0";
-       sha256 = "1lh7gajn69l8yh2lvv552spf31g4br05cvpb2cwrpkijcnq6x8d0";
+       sha256 = "a0a16eb06532ce9b3913eb6e56405ee485e1ae16a5ec4d05f4882663a57a07d2";
        libraryHaskellDepends = [ base HGamer3D-Data ];
        librarySystemDepends = [
          CEGUIBase CEGUIOgreRenderer hg3dcegui050
@@ -6624,7 +6625,7 @@ self: {
      mkDerivation {
        pname = "HGamer3D-Common";
        version = "0.5.0";
-       sha256 = "1klb8974hlsbjg06jwg1akl3pvbp6wr17apmdn69x8zarmb84skh";
+       sha256 = "706a8256cdeaa39e8c6df5aa13323777ed3be854e17169c0934b53484e428bce";
        libraryHaskellDepends = [
          base clock containers directory filepath FindBin HGamer3D-Data stm
          vect
@@ -6641,7 +6642,7 @@ self: {
      mkDerivation {
        pname = "HGamer3D-Data";
        version = "0.5.0";
-       sha256 = "0361153939v63qy204fxpajkgij7f8kfcz93y38jikqcz6nh7bgz";
+       sha256 = "ffad03adf90ccf28d1f0237de6267247c637a5badd11203c1e66a7914609c10c";
        libraryHaskellDepends = [
          base clock containers directory filepath FindBin stm vect
        ];
@@ -6655,7 +6656,7 @@ self: {
      mkDerivation {
        pname = "HGamer3D-Enet-Binding";
        version = "0.5.0";
-       sha256 = "0a5na073ysmcvr9nkbg7jgrkapzbd22wn7p09s2kpxzl9fr8axwd";
+       sha256 = "8d7785b24bf4f73b854ee01ecb8568eb5f35f393e7ad6953deac6a3f0e50b628";
        libraryHaskellDepends = [ base HGamer3D-Data ];
        librarySystemDepends = [ enet hg3denet050 ];
        homepage = "http://www.hgamer3d.org";
@@ -6671,7 +6672,7 @@ self: {
      mkDerivation {
        pname = "HGamer3D-GUI";
        version = "0.4.0";
-       sha256 = "006j6g6w990il30kgpwvls77hsmlbg2haiwckrpq3mcywxrhrbsd";
+       sha256 = "4daf0c73e79ed5816f9e8c4705c55bb46a788ea69bdf37c1a011a4c4cd33d200";
        libraryHaskellDepends = [
          base HGamer3D-CEGUI-Binding HGamer3D-Data HGamer3D-WinEvent split
        ];
@@ -6691,7 +6692,7 @@ self: {
      mkDerivation {
        pname = "HGamer3D-Graphics3D";
        version = "0.5.0";
-       sha256 = "1a6fizaf0l6271407z8kzlzd8yhh9ky2l9n10xcns0a1asvdkj5y";
+       sha256 = "bec8d9b65641016d5907c1262afc4c107ad43efd13fd034838c250e0d48fcea8";
        libraryHaskellDepends = [
          base containers directory filepath HGamer3D-CEGUI-Binding
          HGamer3D-Common HGamer3D-Data HGamer3D-Ogre-Binding
@@ -6710,7 +6711,7 @@ self: {
      mkDerivation {
        pname = "HGamer3D-InputSystem";
        version = "0.5.0";
-       sha256 = "1dpc5zncc9fayf3gqqpki7chimq5cjpvnpjswapllsmykginlyfh";
+       sha256 = "d0796ae39bbe6a4aafe25a5ebbaf6405d708d989f362fc86f3ca25c6ec2fecb6";
        libraryHaskellDepends = [
          base HGamer3D-Common HGamer3D-Data HGamer3D-SDL2-Binding
          HGamer3D-SFML-Binding
@@ -6728,7 +6729,7 @@ self: {
      mkDerivation {
        pname = "HGamer3D-Network";
        version = "0.5.0";
-       sha256 = "105m6k112qs96cih9jp0s9l24s671a3hlnsv4jm893mdk28zvznl";
+       sha256 = "d4fefd9198ad8e84aa245b5b0a870ac7682268d2e0ca042333496311c234b580";
        libraryHaskellDepends = [
          base HGamer3D-Common HGamer3D-Data HGamer3D-Enet-Binding
        ];
@@ -6745,7 +6746,7 @@ self: {
      mkDerivation {
        pname = "HGamer3D-OIS-Binding";
        version = "0.1.5";
-       sha256 = "1n00s6vpwyw8zcasqzg6ycgc98w6hh3sylxjh05w1pya9v853syf";
+       sha256 = "ceeb51d04ecadfc00b80b253af078486a3c41ef3e67dac15fb887b7eb7d100d8";
        libraryHaskellDepends = [
          base haskell98 HGamer3D-Data HGamer3D-Ogre-Binding
        ];
@@ -6765,7 +6766,7 @@ self: {
      mkDerivation {
        pname = "HGamer3D-Ogre-Binding";
        version = "0.5.0";
-       sha256 = "1m2mgqky2bswwskgkmp7xmnm4df5i3rdkshlxkhihglgx3z1wy1w";
+       sha256 = "3c781efee88f3e18e1ec14ead9f288c535526dede7d6f9a6e65c2fe1277e55d4";
        libraryHaskellDepends = [ base HGamer3D-Data mtl transformers ];
        librarySystemDepends = [
          hg3dogre050 OgreMain OgrePaging OgreProperty OgreRTShaderSystem
@@ -6786,7 +6787,7 @@ self: {
      mkDerivation {
        pname = "HGamer3D-SDL2-Binding";
        version = "0.5.0";
-       sha256 = "11j9gysd6sc8wvia7hgf3qvzbxmpqkj7hv65iza474yig2dcr5hh";
+       sha256 = "1096cc9a78d19343d48fc56c78e4c4b7f6f5371eeec1a3e2e68869d3b47f4986";
        libraryHaskellDepends = [
          base bytestring HGamer3D-Data utf8-string
        ];
@@ -6805,7 +6806,7 @@ self: {
      mkDerivation {
        pname = "HGamer3D-SFML-Binding";
        version = "0.5.0";
-       sha256 = "1087g60dxg8pzxvx7bh72ws5slf4mfqmya8cnv11vxl6hk04vc4v";
+       sha256 = "9bb04dc08486f61dc2b60c295fb1abc4515d341707aed377ff17bdde80790781";
        libraryHaskellDepends = [ base HGamer3D-Data ];
        librarySystemDepends = [
          hg3dsfml050 sfml-audio sfml-network sfml-system sfml-window
@@ -6823,7 +6824,7 @@ self: {
      mkDerivation {
        pname = "HGamer3D-WinEvent";
        version = "0.4.0";
-       sha256 = "0d3vjlgpzzb473dmhllxvi05lnh010vgfdbizlj4yxywrp6aas9a";
+       sha256 = "2a69a5cccddc774f24fd7135f73608005a5a40dc9d5258db3864fd7f1f957b34";
        libraryHaskellDepends = [
          base HGamer3D-Data HGamer3D-SDL2-Binding text
        ];
@@ -6842,7 +6843,7 @@ self: {
      mkDerivation {
        pname = "HGamer3D-Wire";
        version = "0.3.3";
-       sha256 = "0w5iafs9ldafc3kzq13alnk1ng766p9w97nak3aijpxfrc4m6z77";
+       sha256 = "e77c5309cbae5f19d598ca9ec4d335e63c1ba6a56a04fce7604e359ab453b170";
        libraryHaskellDepends = [
          base containers HGamer3D HGamer3D-Audio HGamer3D-Data HGamer3D-GUI
          HGamer3D-InputSystem HGamer3D-WinEvent mtl netwire transformers
@@ -6863,7 +6864,7 @@ self: {
      mkDerivation {
        pname = "HGraphStorage";
        version = "0.0.3";
-       sha256 = "1qbhzrw8sjxaz95b34w3w71dv79wlkmqjgvcsr79vxxfn4c83dfc";
+       sha256 = "ccb58118b1aef79d4ed66c3f89eba43c9dddc2e18393b14afaaa4b8d78fe70e1";
        libraryHaskellDepends = [
          base binary bytestring containers data-default directory filepath
          lifted-base monad-control monad-logger resourcet text transformers
@@ -6885,7 +6886,7 @@ self: {
      mkDerivation {
        pname = "HHDL";
        version = "0.1.0.0";
-       sha256 = "1215nz6l3bbkld2fqqsc494xw4qw4vqavznaqxgja2p60w9mwg0q";
+       sha256 = "183c5e1307e60a255fc7cafeadf0261c13de49224c63ec44a373ad41cdb72588";
        libraryHaskellDepends = [ base containers mtl template-haskell ];
        jailbreak = true;
        homepage = "http://thesz.mskhug.ru/svn/hhdl/hackage/hhdl/";
@@ -6899,7 +6900,7 @@ self: {
      mkDerivation {
        pname = "HJScript";
        version = "0.7.0";
-       sha256 = "0xvhzmsl1z6im36svjhcl4zlbnmpknlfn0m426cj5l06a3c5mfa8";
+       sha256 = "48b95ad85006d0229911a402eba89db7da453fa10ccaadcda8d1fc4075fd7077";
        libraryHaskellDepends = [ base HJavaScript hsp mtl text ];
        homepage = "http://patch-tag.com/r/nibro/hjscript";
        description = "HJScript is a Haskell EDSL for writing JavaScript programs";
@@ -6914,7 +6915,7 @@ self: {
      mkDerivation {
        pname = "HJVM";
        version = "0.1";
-       sha256 = "0ixzhgrb2jj7np8gmfwca724w5n26i5xalppm5idnhxw6k4jbklr";
+       sha256 = "99ce25c934bc43db62a9f752d54b34c2164ec4518cbbfad0b5474ab1f283bf47";
        libraryHaskellDepends = [
          base containers filepath haskell-src-exts mtl parsec process
          transformers
@@ -6935,7 +6936,7 @@ self: {
      mkDerivation {
        pname = "HJavaScript";
        version = "0.4.7";
-       sha256 = "0sb2wqbf6kml5d414xi6jk0gr31673djqxa5wg1mxl40vwn14pvh";
+       sha256 = "705f122cdf80d05ec3e345752cdb38268cfcc094267612482bb44ee316e66269";
        libraryHaskellDepends = [ base pretty ];
        description = "HJavaScript is an abstract syntax for a typed subset of JavaScript";
        license = stdenv.lib.licenses.bsd3;
@@ -6949,7 +6950,7 @@ self: {
      mkDerivation {
        pname = "HLearn-algebra";
        version = "1.1.0.1";
-       sha256 = "1k0a01cqaay4wp6i603yvcjpmap7inyjxiblqkbpifk9mwjxf15a";
+       sha256 = "aa04d725af69ba78d7c474c52ebd8de7aa7a25db7e0013cde5c42b8559000acc";
        libraryHaskellDepends = [
          base ConstraintKinds containers deepseq hashable MonadRandom
          parallel random template-haskell vector vector-heterogenous
@@ -6969,7 +6970,7 @@ self: {
      mkDerivation {
        pname = "HLearn-approximation";
        version = "1.1.0";
-       sha256 = "1gqrpnliy4jqjlhdhi7vygvq2lnfgwl2hr5hlkzgqmz2gjyib8vn";
+       sha256 = "76a315bd7ce257fcfea4b06428287fce5281f7f3fb44d8209558121fa9bd19bf";
        libraryHaskellDepends = [
          base ConstraintKinds containers heap HLearn-algebra
          HLearn-datastructures HLearn-distributions list-extras vector
@@ -6987,7 +6988,7 @@ self: {
      mkDerivation {
        pname = "HLearn-classification";
        version = "1.0.1.3";
-       sha256 = "11c1016nhhckmdrzlazz5b7iabl0iz0g2245bwws3alnnn74svhd";
+       sha256 = "0d6e4d8eb596aaa1395f8508f1c08f802e15cf2aff2bfa73ab9341684d008185";
        libraryHaskellDepends = [
          base binary bytestring ConstraintKinds containers deepseq dlist
          hashable HLearn-algebra HLearn-distributions list-extras logfloat
@@ -7006,7 +7007,7 @@ self: {
      mkDerivation {
        pname = "HLearn-datastructures";
        version = "1.1.0";
-       sha256 = "06kbscd7nbbb6dlsgyigyag851bbvhiz6p05gdawpb7y0fh8f3wb";
+       sha256 = "8b0f87a003feaccb557b055cf323dc6b85829ef22ffaa769336b2d7b1ad36b1a";
        libraryHaskellDepends = [
          base ConstraintKinds containers deepseq HLearn-algebra list-extras
          MonadRandom QuickCheck vector
@@ -7025,7 +7026,7 @@ self: {
      mkDerivation {
        pname = "HLearn-distributions";
        version = "1.1.0.2";
-       sha256 = "19v9askkccbv405bchq5h72jahsbivj2s31ajwi316kksan2iwzf";
+       sha256 = "eef328acd2739a3022972a0c2de48e4b4325c5810543b60a207b3136a75669a7";
        libraryHaskellDepends = [
          array base ConstraintKinds containers deepseq erf gamma graphviz
          HLearn-algebra HLearn-datastructures hmatrix list-extras
@@ -7045,7 +7046,7 @@ self: {
      mkDerivation {
        pname = "HList";
        version = "0.4.1.0";
-       sha256 = "0vbfq2jfdm3dn059flyzxrlhcw7hkni75fpi2gqcl5s6ha95ak10";
+       sha256 = "204c5592824617caf013f1ba72a29df0700669eedf53970ab06dd4e6a4c06e6d";
        libraryHaskellDepends = [
          array base ghc-prim mtl profunctors tagged template-haskell
        ];
@@ -7062,7 +7063,7 @@ self: {
      mkDerivation {
        pname = "HListPP";
        version = "0.2";
-       sha256 = "0jq2sdfg47dqf8gmmzm0049x4hsfh9prgfvxzplhrxsisknyhfr8";
+       sha256 = "283be8edd451f70ce9fd7dbb976f824e43d21301a0fe5a1f72b81df25cd3024b";
        isLibrary = true;
        isExecutable = true;
        executableHaskellDepends = [
@@ -7080,7 +7081,7 @@ self: {
      mkDerivation {
        pname = "HLogger";
        version = "0.0.1.0";
-       sha256 = "0amxyg9j6fh58g2wh9k0231mxmvi6j96z7ykd3rm3jzs96fhlncp";
+       sha256 = "97590a9d49facb51f368d39f6f923471d75ec3106026c8c543053a23d3f3bd2a";
        isLibrary = true;
        isExecutable = true;
        libraryHaskellDepends = [ base old-locale time ];
@@ -7097,7 +7098,7 @@ self: {
      mkDerivation {
        pname = "HMM";
        version = "0.2.1";
-       sha256 = "01y8l76c56gysynbilp32yq0wfc129hl24siw8s9fmpn98qa71s6";
+       sha256 = "4687a3304af6569734e2511341611281390eb017e3d2b8acd7fe99c2cca1c807";
        homepage = "https://github.com/mikeizbicki/hmm";
        description = "A hidden markov model library";
        license = stdenv.lib.licenses.bsd3;
@@ -7109,7 +7110,7 @@ self: {
      mkDerivation {
        pname = "HMap";
        version = "1.2.4";
-       sha256 = "087a7ykk84lxa0c75wid6bkjmd89krgyrilxgps1fzl142hyvl13";
+       sha256 = "23d0eda120817e17f47d9dc6ec5f9e09b52ae7322df27218509d1234a73fea20";
        libraryHaskellDepends = [ base hashable mtl unordered-containers ];
        homepage = "https://github.com/atzeus/HMap";
        description = "Fast heterogeneous maps and unconstrained typeable like functionality";
@@ -7124,7 +7125,7 @@ self: {
      mkDerivation {
        pname = "HNM";
        version = "0.1.2";
-       sha256 = "04325gwmlrx4iy9609vzaw2dhs4kg3ydr4r6af6rllrf500f6w9j";
+       sha256 = "3271e300282e539a8d532693dcfc789368d804577f2760928fa4675af92b6210";
        isLibrary = true;
        isExecutable = true;
        libraryHaskellDepends = [
@@ -7145,7 +7146,7 @@ self: {
      mkDerivation {
        pname = "HODE";
        version = "2008.10.27";
-       sha256 = "0fr3bivmlciicba1brhm86l8diadb765ff1s8g6ylygs8l7lingv";
+       sha256 = "fbd9480f45fa79eacd433a3857cc594dc586a84115e615d46231325a775c233b";
        libraryHaskellDepends = [ array base ];
        librarySystemDepends = [ ode ];
        description = "Binding to libODE";
@@ -7157,8 +7158,8 @@ self: {
     ({ mkDerivation, allocated-processor, base, opencv, vector-space }:
      mkDerivation {
        pname = "HOpenCV";
-       version = "0.3.0.1";
-       sha256 = "0v9pcbbfj254n6mryb16rplh6mgjizdm4c8qqdsb41gdpx1h59n6";
+       version = "0.4.0.1";
+       sha256 = "7e7be492466e675ceb60b823252fcb0e8a5d0847a76c680c2dfa2ea7e59cbec7";
        isLibrary = true;
        isExecutable = true;
        libraryHaskellDepends = [ allocated-processor base vector-space ];
@@ -7176,7 +7177,7 @@ self: {
      mkDerivation {
        pname = "HPDF";
        version = "1.4.6";
-       sha256 = "15v1mf58fqa25higf52jqlf3fw2fbggfm5v8a8v00zz6q0f3lzn9";
+       sha256 = "c97e3a1cc0e67f0036526897eade5b4e70371cc55214f7222c4261878aab6197";
        libraryHaskellDepends = [
          array base binary bytestring containers mtl random vector zlib
        ];
@@ -7193,7 +7194,7 @@ self: {
      mkDerivation {
        pname = "HPath";
        version = "0.0.2";
-       sha256 = "10hlqyhcpgnkiqwjwb3d10wrhzc82jcbz1qvxa0mzzif36rys1wk";
+       sha256 = "9307edb3192efe5f81ea1b87bf9814887d9839086d2c2e398ed3becba0c71482";
        isLibrary = true;
        isExecutable = true;
        libraryHaskellDepends = [
@@ -7216,7 +7217,7 @@ self: {
      mkDerivation {
        pname = "HPi";
        version = "0.4.0";
-       sha256 = "0d0r89a92lavbaf6svkqwd7fvc1q4kwbdvr0jvxarx2xgrhl342a";
+       sha256 = "4a9041617e5df4acfa9620efb6f82438b0ed4ee3786e6d9c5a5b519154421934";
        libraryHaskellDepends = [ base bytestring ];
        jailbreak = true;
        homepage = "https://github.com/WJWH/HPi";
@@ -7229,7 +7230,7 @@ self: {
      mkDerivation {
        pname = "HPlot";
        version = "0.3";
-       sha256 = "022642xp13fl34y854n4j7kxn0nyxhrz4gxgn3nfqs67m13bcsqy";
+       sha256 = "1e6bb646a8c768ececb0af3ff233ecde02dbe791c492823c19d48d70bb204608";
        isLibrary = true;
        isExecutable = true;
        libraryHaskellDepends = [ base glade glib gtk ];
@@ -7251,7 +7252,7 @@ self: {
      mkDerivation {
        pname = "HPong";
        version = "0.1.2";
-       sha256 = "0dzzq4ksny537b151g6c1jgj2ns143klhdjfbq84srs026pvpvzi";
+       sha256 = "f1efbbaf1140674d105e4e3648e720415b219f0cccbc50c23aa378ab27c1ff37";
        isLibrary = false;
        isExecutable = true;
        executableHaskellDepends = [
@@ -7270,7 +7271,7 @@ self: {
      mkDerivation {
        pname = "HROOT";
        version = "0.8";
-       sha256 = "0q6n5j1hzl8fk6a0ziqjzfi1515shqzqxx0argbvnhw85vjajvqf";
+       sha256 = "0e6fa9e42e8843bbd7cb0af48e3f86ba8412a2fb12c70f94990ed10f832cd660";
        revision = "1";
        editedCabalFile = "43058ba39e0517740c45b1087a39e4f84912c1a3c500504850395d4f2fda0917";
        libraryHaskellDepends = [
@@ -7288,7 +7289,7 @@ self: {
      mkDerivation {
        pname = "HROOT-core";
        version = "0.8";
-       sha256 = "1f40n224r640dp3g4x9kwnpcjpll3axs3pc71nqcch748bh0f60n";
+       sha256 = "161807e042e440c6b00d87dda1bb1a945ec9aee53375f2c66d80984c84b080b8";
        libraryHaskellDepends = [ base fficxx-runtime ];
        homepage = "http://ianwookim.org/HROOT";
        description = "Haskell binding to ROOT Core modules";
@@ -7301,7 +7302,7 @@ self: {
      mkDerivation {
        pname = "HROOT-graf";
        version = "0.8";
-       sha256 = "1jh2c6wrzajrzbkw77fsvjnj7nhrfx192hs9vlkd0aja2xy7z0bw";
+       sha256 = "7c817f7c174a2ad026dd494391427719da23addcda9dc3e7fa59aa9fb96102ca";
        libraryHaskellDepends = [
          base fficxx-runtime HROOT-core HROOT-hist
        ];
@@ -7316,7 +7317,7 @@ self: {
      mkDerivation {
        pname = "HROOT-hist";
        version = "0.8";
-       sha256 = "0yzlqg2nzw26j1a2i8zaihwd22bl7y9cbxxps99vy7fxph81ikh1";
+       sha256 = "01ce1810bcdd1dbf53d2b7f7c5923f7409d1388ceaa328549046f06fc5c3f47b";
        libraryHaskellDepends = [ base fficxx-runtime HROOT-core ];
        homepage = "http://ianwookim.org/HROOT";
        description = "Haskell binding to ROOT Hist modules";
@@ -7329,7 +7330,7 @@ self: {
      mkDerivation {
        pname = "HROOT-io";
        version = "0.8";
-       sha256 = "0sbh6jz24xv2pvh0m2f26aqj3fzkmyiqp8p4g1vcnh8jlisdn6k2";
+       sha256 = "621adb74a41241cb7678e4a28ba3aff3bb21b132c2890ae0be627722be347069";
        libraryHaskellDepends = [ base fficxx-runtime HROOT-core ];
        homepage = "http://ianwookim.org/HROOT";
        description = "Haskell binding to ROOT IO modules";
@@ -7342,7 +7343,7 @@ self: {
      mkDerivation {
        pname = "HROOT-math";
        version = "0.8";
-       sha256 = "0qmsvrhxzdw2n0lw8x06l2sbx36xm77nv55kpps1h60l4l0nmzwm";
+       sha256 = "95ff6a0125141818f4bdb3946dcfa9dd8cbeb4a00674c429b082b7df61deba62";
        libraryHaskellDepends = [ base fficxx-runtime HROOT-core ];
        homepage = "http://ianwookim.org/HROOT";
        description = "Haskell binding to ROOT Math modules";
@@ -7355,7 +7356,7 @@ self: {
      mkDerivation {
        pname = "HRay";
        version = "1.2.3";
-       sha256 = "0bg0b8260cd2l8q7ccijwqg1yz49mkifv1r0a5q1hrbsagvac4nf";
+       sha256 = "ce12a6f6537a651870512087ede2ac897c1f1ee632327630a2a23160045ae02d";
        isLibrary = false;
        isExecutable = true;
        executableHaskellDepends = [ array base directory haskell98 ];
@@ -7372,7 +7373,7 @@ self: {
      mkDerivation {
        pname = "HSFFIG";
        version = "1.1.3";
-       sha256 = "10zkg2lhvzxi6csyrah8kw3xd1da60im0whpg884hpnf5h220086";
+       sha256 = "060120042cce5e48107a1772502330aa85d6079f08aaec3533b1ff0da978f383";
        isLibrary = true;
        isExecutable = true;
        libraryHaskellDepends = [
@@ -7395,7 +7396,7 @@ self: {
      mkDerivation {
        pname = "HSGEP";
        version = "0.1.5";
-       sha256 = "16k853180smf2smw8ch3mzjv14imj9w2ssh61hcc23carhrsbg9p";
+       sha256 = "37bda533cc8a0dc1180c066a2d78923592b0e5af0332c4ab16ae6a80c228689a";
        isLibrary = true;
        isExecutable = true;
        libraryHaskellDepends = [
@@ -7416,7 +7417,7 @@ self: {
      mkDerivation {
        pname = "HSH";
        version = "2.1.2";
-       sha256 = "17ysn131xskx4s1g5kg08zy141q3q16bns4bsg3yjzvf6cjpz2kq";
+       sha256 = "788a7f25336e7fe9c7d38b68bb4cc0030712fc47e0cdf282267dea1e46b0da9f";
        isLibrary = true;
        isExecutable = true;
        libraryHaskellDepends = [
@@ -7436,7 +7437,7 @@ self: {
      mkDerivation {
        pname = "HSHHelpers";
        version = "0.24";
-       sha256 = "0mz25xak9fkircdxcpzrf3rym9l5ivhifk7dqm2xki3mv6fw214d";
+       sha256 = "8d04c19dd975c4d945c5ed4c17e18e85a6eaf370f95fd61bcb71ba34552fe257";
        libraryHaskellDepends = [
          base bytestring DebugTraceHelpers directory filepath HSH
          HStringTemplateHelpers MissingH mtl regex-pcre unix
@@ -7452,7 +7453,7 @@ self: {
      mkDerivation {
        pname = "HSlippyMap";
        version = "2.2";
-       sha256 = "17n1kpva97lwhwg2vs7875bfqlwcq6xpl2agqc53qb7j4153p559";
+       sha256 = "a9943b4a20f22c3c0ac34f097abbc18c53ec5639e8e82d1e879c9ea4f69dc19e";
        libraryHaskellDepends = [ base ];
        jailbreak = true;
        homepage = "https://github.com/j4/HSlippyMap";
@@ -7467,7 +7468,7 @@ self: {
      mkDerivation {
        pname = "HSmarty";
        version = "0.2.0.3";
-       sha256 = "07m7xpwv565cf78qyqkd6babpl2b7jnq88psv55jclzdqlsvv0rq";
+       sha256 = "3883bd35c5ed53264bd9fa2284ad3c4bd0bbd4326d628fd171ac98b2f9eda71e";
        libraryHaskellDepends = [
          aeson attoparsec attoparsec-expr base HTTP mtl scientific text
          unordered-containers vector
@@ -7486,7 +7487,7 @@ self: {
      mkDerivation {
        pname = "HSoundFile";
        version = "0.2.2";
-       sha256 = "0qlz17dzlysj36zz3s8dzwvfdr9rdfp6gnabc262iraidqapshzb";
+       sha256 = "eb437d156e51e5288c604bd967ae6b39e5e636ff0de9f1bf19527bfadb099f62";
        libraryHaskellDepends = [
          base binary bytestring filepath haskell98 mtl parallel
        ];
@@ -7504,7 +7505,7 @@ self: {
      mkDerivation {
        pname = "HStringTemplate";
        version = "0.8.3";
-       sha256 = "064x4d9vhzln1c8ka3saqdz6a8skn3xbhaxrf3rjwqgmjg4v3mk3";
+       sha256 = "63d6b1c993f5612ef370b92bb8fab05323657ec34a0f35110b967eb853239d18";
        libraryHaskellDepends = [
          array base blaze-builder bytestring containers deepseq directory
          filepath mtl old-locale parsec pretty syb template-haskell text
@@ -7521,7 +7522,7 @@ self: {
      mkDerivation {
        pname = "HStringTemplateHelpers";
        version = "0.0.14";
-       sha256 = "1dgr28hxm9zlxl13ms9mn63rbm5ya6bkyys6q0kbns2y2zwmkswh";
+       sha256 = "90eb59f9175e68bb26c0467b3f9751bed49587b135e93a02edf4a7da2112f9b5";
        libraryHaskellDepends = [
          base containers directory FileManipCompat filepath HSH
          HStringTemplate mtl safe strict
@@ -7537,7 +7538,7 @@ self: {
      mkDerivation {
        pname = "HSvm";
        version = "0.1.0.2.89";
-       sha256 = "1mb8kclb7631ihj356g5ddf758cnwz9y6r5ck72daa7vndz01aa9";
+       sha256 = "49a9007eb3fb28d5c499ac64e3d3e796a1725c6be59932248c6198b3289b68d5";
        libraryHaskellDepends = [ base containers ];
        description = "Haskell Bindings for libsvm";
        license = stdenv.lib.licenses.bsd3;
@@ -7555,7 +7556,7 @@ self: {
      mkDerivation {
        pname = "HTF";
        version = "0.13.0.0";
-       sha256 = "0lrc60ydqsizz3rdyijqywncr1bcj3b95mgn99bz5q4yb3l6dc54";
+       sha256 = "a4b066e8589ee0f2574af6d592d6906c85cc2cf75846dff2f83f6adc3c302c53";
        isLibrary = true;
        isExecutable = true;
        libraryHaskellDepends = [
@@ -7586,7 +7587,7 @@ self: {
      mkDerivation {
        pname = "HTTP";
        version = "4000.2.20";
-       sha256 = "0nyqdxr5ls2dxkf4a1f3x15xzwdm46ppn99nkcbhswlr6s3cq1s4";
+       sha256 = "4407cc863699720d179b36257baf21b5f1df4be8c30545dcec4d685a726fd85b";
        libraryHaskellDepends = [
          array base bytestring mtl network network-uri old-time parsec
        ];
@@ -7606,7 +7607,7 @@ self: {
      mkDerivation {
        pname = "HTTP-Simple";
        version = "0.2";
-       sha256 = "1294pn82fbskgfw2mh3ri31wab5l9y3j0g50dcx5sqbhz79pnj9w";
+       sha256 = "3c497bd3f970615d3a6ba03c20874fb42cc5c38879c02ab87b532f2790bd2489";
        libraryHaskellDepends = [ base HTTP network ];
        homepage = "http://www.b7j0c.org/content/haskell-http.html";
        description = "DEPRECATED Enable simple wrappers to Network.HTTP";
@@ -7621,7 +7622,7 @@ self: {
      mkDerivation {
        pname = "HTab";
        version = "1.6.3";
-       sha256 = "0c0igscng6gqhabmvvgappsbzbhkpybcx7vr8yd72pqh988ml4zv";
+       sha256 = "fb135a114a105f719a47799fce96bf13aebff4bdeaed5d9782f89967997e1130";
        isLibrary = false;
        isExecutable = true;
        executableHaskellDepends = [
@@ -7639,7 +7640,7 @@ self: {
      mkDerivation {
        pname = "HTicTacToe";
        version = "0.2";
-       sha256 = "0h3pr4lyx14zndwbas5ba8sg3s84sq19qhh6pcqpy4v2ajfyyfqc";
+       sha256 = "0c3bef9d5462137f31bb06429c02d604e9f13452ab68b578b39f84ee29c97740";
        isLibrary = false;
        isExecutable = true;
        executableHaskellDepends = [
@@ -7656,7 +7657,7 @@ self: {
      mkDerivation {
        pname = "HUnit";
        version = "1.2.5.2";
-       sha256 = "0hcs6qh8bqhip1kkjjnw7ccgcsmawdz5yvffjj5y8zd2vcsavx8a";
+       sha256 = "0af5ad34dba27de48b94ce6d5f7ee3aa6af6183bdc4a3967b811e28520369a41";
        libraryHaskellDepends = [ base deepseq ];
        homepage = "http://hunit.sourceforge.net/";
        description = "A unit testing framework for Haskell";
@@ -7668,7 +7669,7 @@ self: {
      mkDerivation {
        pname = "HUnit-Diff";
        version = "0.1";
-       sha256 = "0dlsx6qicnrqkhb52jbgh31f0y6lxh32yl5gr6bg3fnqr36vc6x6";
+       sha256 = "a61bb6cdc8d8baf196c9af502f06ecd478e0c2806f4951169c385b16b1e99a36";
        libraryHaskellDepends = [ ansi-terminal base Diff groom HUnit ];
        jailbreak = true;
        homepage = "https://github.com/dag/HUnit-Diff";
@@ -7685,7 +7686,7 @@ self: {
      mkDerivation {
        pname = "HUnit-Plus";
        version = "1.0.1";
-       sha256 = "0ph4560i8nb4ggbfc2yfam0mgfl21pnpgj0x0v9dh86lbfj9p4ki";
+       sha256 = "71929ba45bd420d8d2061dc877ed0d82ba574155ce0be6d67b6459148129045e";
        libraryHaskellDepends = [
          base bytestring Cabal cmdargs containers hashable hexpat hostname
          old-locale parsec time timeit
@@ -7705,7 +7706,7 @@ self: {
      mkDerivation {
        pname = "HUnit-approx";
        version = "1.0";
-       sha256 = "0svkjvcanjsi5bhn9b91jhig36np5imr3qyj6b1s5msm7wmlk3v1";
+       sha256 = "618f492b3f55d7a2c332d2e3916b2cd79af1229421ad64e12a514babd896736b";
        libraryHaskellDepends = [ base HUnit ];
        testHaskellDepends = [ base HUnit ];
        homepage = "https://github.com/goldfirere/HUnit-approx";
@@ -7722,7 +7723,7 @@ self: {
      mkDerivation {
        pname = "HXMPP";
        version = "0.0.1.0";
-       sha256 = "094j5bafrwr0d5sz3fidz7k328w6f4nqhja2c9gf89759nc470ss";
+       sha256 = "5a8343984de524e45e624249882d71862331e6f92dbaf1756920f3ecd42a9224";
        isLibrary = true;
        isExecutable = true;
        libraryHaskellDepends = [
@@ -7749,7 +7750,7 @@ self: {
      mkDerivation {
        pname = "HXQ";
        version = "0.19.0";
-       sha256 = "1k2lway8nfy6vwsxq7kmjh25q5diw8sy4hrqzn3irk6rlg7zh77l";
+       sha256 = "f41cf8cfa3d9cc1c87fd3843e235e2b1155c0494751edc35dfc63b8bbce254cc";
        libraryHaskellDepends = [
          array base haskeline haskell98 HTTP mtl regex-base regex-compat
          template-haskell
@@ -7765,7 +7766,7 @@ self: {
      mkDerivation {
        pname = "HaLeX";
        version = "1.2.1";
-       sha256 = "029khjgyay3pzydq7bj6rvlglmm66wj728y4fadqvh6yxr7ddc0s";
+       sha256 = "1ab0d64eeedec08d9b72c423712437a656fae8ce46ae839bff7778e59f843309";
        isLibrary = true;
        isExecutable = true;
        libraryHaskellDepends = [ base mtl ];
@@ -7780,7 +7781,7 @@ self: {
      mkDerivation {
        pname = "HaMinitel";
        version = "0.1.0.0";
-       sha256 = "0q7fq5z0wrk2qg9n715033yp25dpl73g6iqkbvxbg2ahp9caq458";
+       sha256 = "a810ac58ba5089b7fa5e1347f3c6a1b71571fd18a08463d3c362660e7ec1ee60";
        libraryHaskellDepends = [ base bytestring serialport stm ];
        jailbreak = true;
        homepage = "https://github.com/Zigazou/HaMinitel";
@@ -7793,7 +7794,7 @@ self: {
      mkDerivation {
        pname = "HaPy";
        version = "0.1.1.1";
-       sha256 = "0li04k27pkq7ci1dfx4sl022ivl4gjqy5ny25jszifwrx4n4pmwz";
+       sha256 = "9fd74b2ce999bbf8b52cc2dbe2b17c84ee2804a09a74d7426407cf7bc4242052";
        libraryHaskellDepends = [ base template-haskell th-lift ];
        homepage = "https://github.com/sakana/HaPy";
        description = "Haskell bindings for Python";
@@ -7811,7 +7812,7 @@ self: {
      mkDerivation {
        pname = "HaRe";
        version = "0.7.2.8";
-       sha256 = "19vldhyl1636g05yc1kg9ih3z9rlcvcl596slc1hqwkd564nld36";
+       sha256 = "66346a89296d720c03a3daa442d96634a73f604c6f06e60b786698403d6c74a7";
        isLibrary = true;
        isExecutable = true;
        libraryHaskellDepends = [
@@ -7847,7 +7848,7 @@ self: {
      mkDerivation {
        pname = "HaTeX";
        version = "3.16.1.1";
-       sha256 = "0xi89wclnkrl17jl3ymvsvg802aj201m4lp0rg9adgmrrdgz042p";
+       sha256 = "5710f05fcbb9bea6d2cbe052520310520980ded6bbfa41e509344f4b194f2876";
        libraryHaskellDepends = [
          base bytestring containers matrix parsec QuickCheck text
          transformers wl-pprint-extras
@@ -7867,7 +7868,7 @@ self: {
      mkDerivation {
        pname = "HaTeX-meta";
        version = "1.2.1";
-       sha256 = "1cfn823xfp4962x4ww3dawm017nkg00wxa20b8nbq3pmjjnpb2xl";
+       sha256 = "b48b75ad94f50ebc2c5a40a8ce0178d39e002a576d704eba30895cd78740d6b1";
        isLibrary = false;
        isExecutable = true;
        executableHaskellDepends = [
@@ -7887,7 +7888,7 @@ self: {
      mkDerivation {
        pname = "HaTeX-qq";
        version = "0.0.1.1";
-       sha256 = "1kjhdg9vm7n07zxgdkmqkgwpf2204hrjwslnyhg8i7f07cd3pdrl";
+       sha256 = "34b73b1a3bc09d881ef4966a2e3324400877f99bb8cef6fa3fc09ebad36b50ce";
        libraryHaskellDepends = [
          antiquoter base haskell-src-meta HaTeX template-haskell text
          uniplate
@@ -7904,7 +7905,7 @@ self: {
      mkDerivation {
        pname = "HaVSA";
        version = "0.1.0.2";
-       sha256 = "1hh324i7gvazlkm3vfmzah41h2hlxwb2k8g1z8dmfbif6pmp0apk";
+       sha256 = "f32a70eb352e2e571bfae1a12916ef140a180854bfba3deaa45fed77221103c2";
        isLibrary = true;
        isExecutable = true;
        libraryHaskellDepends = [ base logict ];
@@ -7925,7 +7926,7 @@ self: {
      mkDerivation {
        pname = "HaXml";
        version = "1.25.3";
-       sha256 = "1iq74dnxvannx9x1whqc3ixn93r4v5z7b4yv21n9q5963kpafj34";
+       sha256 = "6448a7ee1c26159c6c10db93757ed9248f647b1c0c431e7aead6aadd6d2307c7";
        isLibrary = true;
        isExecutable = true;
        libraryHaskellDepends = [
@@ -7944,7 +7945,7 @@ self: {
      mkDerivation {
        pname = "Hach";
        version = "0.1.2";
-       sha256 = "1bp7ngsh655x0iamb8bhn2sqkpg3p6mhg0n0fgqz5k4pjskjyavy";
+       sha256 = "7e2b2fa79697ccf2f173c08207abb9e3dd89b5b070a1555504bd1403f5b3e7ae";
        isLibrary = true;
        isExecutable = true;
        libraryHaskellDepends = [ base containers network old-locale ];
@@ -7962,7 +7963,7 @@ self: {
      mkDerivation {
        pname = "HackMail";
        version = "0.0.1";
-       sha256 = "1j8lw1c5asx40fag9gd6ni19c0z0q46f55yry5cj94v4s5m2gzbw";
+       sha256 = "7cfd276ad164932459f1d997e20cc1e0039642b4a6bdf49403a46b5558e014c9";
        isLibrary = true;
        isExecutable = true;
        libraryHaskellDepends = [
@@ -7984,7 +7985,7 @@ self: {
      mkDerivation {
        pname = "Haggressive";
        version = "0.1.0.4";
-       sha256 = "08f8i8bmnjv255xzpasa7drd83fh82qjm49mscn6dmiw6yp47vz1";
+       sha256 = "e1ef43ae373cd6662cd335912ab140d00dd4723b4aabfb7b29624b5b178ac821";
        libraryHaskellDepends = [
          base bytestring Cabal cassava containers directory HUnit PSQueue
          text tokenize tuple vector
@@ -8001,7 +8002,7 @@ self: {
      mkDerivation {
        pname = "HandlerSocketClient";
        version = "0.0.5";
-       sha256 = "1jp8cwlp6h1wvvkh71813i3lzxc7ckxzc7nvvcsjvcz0apxcl7vv";
+       sha256 = "7b1fcafa55e0b32d35dbdb1ef6fb6487f54f471c018503e7de3c40732967e8ca";
        libraryHaskellDepends = [ base bytestring network ];
        homepage = "https://github.com/wuxb45/HandlerSocket-Haskell-Client";
        description = "Haskell implementation of a HandlerSocket client (API)";
@@ -8015,7 +8016,7 @@ self: {
      mkDerivation {
        pname = "HandsomeSoup";
        version = "0.4.2";
-       sha256 = "1yzfrvivvxwlaiqwbjx27rxwq9mmnnpb512vwklzw7nyzg9xmqha";
+       sha256 = "0ae2dad3fbde1efee9e45b84b2aeb5b526cc7b3ea2cbc5715494f7bde3ceeefb";
        isLibrary = true;
        isExecutable = true;
        libraryHaskellDepends = [
@@ -8038,7 +8039,7 @@ self: {
      mkDerivation {
        pname = "HarmTrace";
        version = "2.2.0";
-       sha256 = "1l2w53ispw7sg1daxnynfc94njzm6w838a8ij7rpzd3nxa2b596v";
+       sha256 = "dba4b284ea76b47ff3911129341037f54b4b1273d6dbae5a78faf0abe3285cd0";
        isLibrary = true;
        isExecutable = true;
        libraryHaskellDepends = [
@@ -8066,7 +8067,7 @@ self: {
      mkDerivation {
        pname = "HarmTrace-Base";
        version = "1.4.0.1";
-       sha256 = "174a05473577vyyf6rz5bq3b9wrgmsbz23xdg945pfc78lb6n70j";
+       sha256 = "121c6b164587b95b487aad0ff197ae2ff3b4065ee567e3bcdfe7947148018a9c";
        libraryHaskellDepends = [
          base binary containers ghc-prim ListLike uu-parsinglib
        ];
@@ -8087,7 +8088,7 @@ self: {
      mkDerivation {
        pname = "HasGP";
        version = "0.1";
-       sha256 = "1sw5l74p2md4whq0c1xifcnwbb525i84n1razjxs7cpf8gicgggx";
+       sha256 = "fdbdc7e243eeb2a3bbfc2a074b502ca2acc52d73b1070630e4a45571c9a185eb";
        libraryHaskellDepends = [
          base haskell98 hmatrix hmatrix-special mtl parsec random
        ];
@@ -8105,7 +8106,7 @@ self: {
      mkDerivation {
        pname = "Haschoo";
        version = "0.1.2";
-       sha256 = "0jh506p0clwyb5wwrhlgbc5xp7w6smz5vky3lc8vhnwvwk324qcj";
+       sha256 = "926122c6e49b5bb811a3c3cf5d7ed5869fdb0b5b8fc2cc79599e5306ae01054a";
        isLibrary = false;
        isExecutable = true;
        executableHaskellDepends = [
@@ -8125,7 +8126,7 @@ self: {
      mkDerivation {
        pname = "Hashell";
        version = "1.0";
-       sha256 = "0yn525sr7i2nwf4y44va00aswnphn89072zaqjr2i0f1n1jjaxpl";
+       sha256 = "f4762565b0c18128b2c4ea8b0312b2f05aae15006a13e289e356c4937511c57a";
        isLibrary = false;
        isExecutable = true;
        executableHaskellDepends = [
@@ -8143,7 +8144,7 @@ self: {
      mkDerivation {
        pname = "HaskellForMaths";
        version = "0.4.8";
-       sha256 = "0yn2nj6irmj24j1djvnnq26i2lbf9g9x1wdhmcrk519glcn5k64j";
+       sha256 = "9298592ca32f853233abb0f1d0d34b6e51118dc0d66ed9822442d61c8db4c27a";
        libraryHaskellDepends = [ array base containers random ];
        homepage = "http://haskellformaths.blogspot.com/";
        description = "Combinatorics, group theory, commutative algebra, non-commutative algebra";
@@ -8155,7 +8156,7 @@ self: {
      mkDerivation {
        pname = "HaskellLM";
        version = "0.1.2";
-       sha256 = "0baqn15zdhlinf4v3c244005nb3wm63gpr0w6fy7g9gmn8a00scq";
+       sha256 = "98690014b2f5a577bc331ce4fb86a97c2c5b002044b0b189b391c2f64bb0582d";
        libraryHaskellDepends = [ base hmatrix ];
        description = "Pure Haskell implementation of the Levenberg-Marquardt algorithm";
        license = "GPL";
@@ -8166,7 +8167,7 @@ self: {
      mkDerivation {
        pname = "HaskellNN";
        version = "0.1.3";
-       sha256 = "0i5jqhkxna1kq361hh66830x4z5m782pp898g9ggfvdiwpp8phmr";
+       sha256 = "b9c28beee5b16df75e7a28a17b053ab57cd2c140c64018ccc03328db27c4b244";
        libraryHaskellDepends = [ base hmatrix random ];
        description = "High Performance Neural Network in Haskell";
        license = "GPL";
@@ -8180,7 +8181,7 @@ self: {
      mkDerivation {
        pname = "HaskellNet";
        version = "0.4.5";
-       sha256 = "1d34zknk8knjsw1w3bl91z8qc47vqb6mhfh6rq1rm93na616i3p5";
+       sha256 = "e58e68825176a49a03ce063a58cdc2fb1086d10f89aec103d7d24e34edfc64b4";
        libraryHaskellDepends = [
          array base base64-string bytestring cryptohash mime-mail mtl
          network old-time pretty text
@@ -8197,7 +8198,7 @@ self: {
      mkDerivation {
        pname = "HaskellNet-SSL";
        version = "0.3.0.0";
-       sha256 = "1n1jlnxp16dmfkw4yh1bsbylsk5c1kyixh3gi81202fjx3q9z2pf";
+       sha256 = "ee8a9ff0e8d20920028a6fc01efd0cac4c4dfdd22b404ff874b59970bba532d8";
        libraryHaskellDepends = [
          base bytestring connection data-default HaskellNet network tls
        ];
@@ -8215,7 +8216,7 @@ self: {
      mkDerivation {
        pname = "HaskellTorrent";
        version = "0.1.1";
-       sha256 = "0dy9irl085jw7wz6y50566rwsj05ymp8g2xp2444vg12ryd5dra1";
+       sha256 = "41e5569acf22bc4d0811b78b876ef50548cdb33105146f3e3f5c1604688ec937";
        isLibrary = false;
        isExecutable = true;
        executableHaskellDepends = [
@@ -8234,7 +8235,7 @@ self: {
      mkDerivation {
        pname = "HaskellTutorials";
        version = "0.0.0.1";
-       sha256 = "0gnf8x4dqz3bwyhrcn17qci2rzmms3r0cyr7cgf593jlkxiq287q";
+       sha256 = "f82081639f548e54dc63277b06f2d0b5fe2c22c3275896a1e76b7cdc4847ce3e";
        isLibrary = false;
        isExecutable = true;
        executableHaskellDepends = [ base cmdargs text ];
@@ -8251,7 +8252,7 @@ self: {
      mkDerivation {
        pname = "Haskelloids";
        version = "0.1.1";
-       sha256 = "0v171rzpbh4w5kxzbc9h2x4kha1ykw4vk69scfpmdz5iqih2bqz8";
+       sha256 = "e8e32560c4b1fc56af633a99b9099f3e2838491730b1f5fb2c9cc0757f0e276c";
        isLibrary = false;
        isExecutable = true;
        executableHaskellDepends = [
@@ -8274,7 +8275,7 @@ self: {
      mkDerivation {
        pname = "Hawk";
        version = "0.0.2";
-       sha256 = "0g7dgj3asxwcjg43nzhjp7agvnzv882xhgbrr7jnpdckywkgacgq";
+       sha256 = "f831f526f793b56be5c9793dd80542fbdbfdd4b9127e3bc8938c77ad867ced3c";
        libraryHaskellDepends = [
          base bytestring bytestring-trie cgi containers convertible
          data-default dataenc directory filepath hack HDBC HDBC-sqlite3
@@ -8299,7 +8300,7 @@ self: {
      mkDerivation {
        pname = "Hayoo";
        version = "1.2.3";
-       sha256 = "0bpkkdwgwf7xagp4rda1g07mdglzvl4hzq2jif7c3s8j7f6zq48c";
+       sha256 = "0c11fc8d3b12e9c18e8b52e00f09dd9fbe560f7841b54cee53fd38fe789bf32e";
        isLibrary = false;
        isExecutable = true;
        executableHaskellDepends = [
@@ -8321,7 +8322,7 @@ self: {
      mkDerivation {
        pname = "Hclip";
        version = "3.0.0.3";
-       sha256 = "0h6q44yv4m325gdwpvkxz31syy6qwdsixfanzr3fx1v5nbhm22af";
+       sha256 = "4e0951e1b26587ee46fe56b91e75e3d878afc3f87deecbdb2b6254b23d21d840";
        libraryHaskellDepends = [ base mtl process strict ];
        testHaskellDepends = [ base tasty tasty-hunit ];
        homepage = "https://github.com/jetho/Hclip";
@@ -8336,7 +8337,7 @@ self: {
      mkDerivation {
        pname = "Hedi";
        version = "0.1.1";
-       sha256 = "0z0sa658fngv68611k76ncf5j59v517xchhw2y84blj97fl6jkn9";
+       sha256 = "c94e69a83b49d24590171c42d64f283b15591cb3e6cc100c32fb59878a511a7c";
        isLibrary = true;
        isExecutable = true;
        libraryHaskellDepends = [
@@ -8358,7 +8359,7 @@ self: {
      mkDerivation {
        pname = "Hermes";
        version = "0.0.4";
-       sha256 = "0j5vg3rvf4hbvg6jan4im7ijqffy6k9dvijfwxjcn164qjzh6xb3";
+       sha256 = "637503bfc4c404cb64e74ec6ddd234de392ce3a9915825cddb0b12b7f378bb48";
        libraryHaskellDepends = [
          AES base bytestring cereal containers hslogger monads-tf network
          old-time random random-shuffle RSA SHA2 stm syb time transformers
@@ -8378,7 +8379,7 @@ self: {
      mkDerivation {
        pname = "Hieroglyph";
        version = "3.89";
-       sha256 = "0dkvvk3qwn72vn4kc0q2iv6raxslrxf0ypr0sn7i0fjds3cjxs6s";
+       sha256 = "dae82ed9d04d3a108fd5205f0f5ccf547795cd8e02033689dde2588ec7dc7b36";
        libraryHaskellDepends = [
          array base buster bytestring cairo colour containers glib GLUT gtk
          gtkglext IfElse mtl OpenGL parallel pretty random
@@ -8397,7 +8398,7 @@ self: {
      mkDerivation {
        pname = "HiggsSet";
        version = "0.1.1";
-       sha256 = "1k0qlpm4akzx820b0j3g3f562ailxa56sa41268xyq3046xdpyl1";
+       sha256 = "81fadbba216060df911181286d8aea342a618a1b6f48b08040fd4f45eaa518cc";
        libraryHaskellDepends = [
          base bytestring containers deepseq mtl text th-expand-syns TrieMap
          vector
@@ -8413,7 +8414,7 @@ self: {
      mkDerivation {
        pname = "Hipmunk";
        version = "5.2.0.17";
-       sha256 = "1yxs1v9pzb35g3zlvycsx762dk8swrbry7ajr50zlq667j20n4a8";
+       sha256 = "48110b843cc660fa41c9521d9f57e61acd26cce99af94dff7865ac7fd30ebafb";
        libraryHaskellDepends = [
          array base containers StateVar transformers
        ];
@@ -8429,7 +8430,7 @@ self: {
      mkDerivation {
        pname = "HipmunkPlayground";
        version = "5.2.1.1";
-       sha256 = "075am1d0hjbhnibk2x56fbh4ybw5pavfmqk2dz4yjw7yh264vcs7";
+       sha256 = "47b34d8c80fe70e9c96f62e2eab6ba852f4fe072a6743157b47049085aa8aa1c";
        isLibrary = false;
        isExecutable = true;
        executableHaskellDepends = [
@@ -8446,7 +8447,7 @@ self: {
      mkDerivation {
        pname = "Histogram";
        version = "0.1.0.2";
-       sha256 = "00f0a3lbpc7s70lzmnf9a7hjzc3yv8nfxcvz5nparr34x585zbxl";
+       sha256 = "b4af5f50e964e4acae2d7fb3ee2cda7eb02fe151c9d9fa2938fab0bbe850c001";
        libraryHaskellDepends = [ base containers gnuplot ];
        license = stdenv.lib.licenses.bsd3;
      }) {};
@@ -8458,7 +8459,7 @@ self: {
      mkDerivation {
        pname = "Hmpf";
        version = "0.1";
-       sha256 = "0lw2d9yv3zxqv20v96czx0msahbyk0rc5d68gj567dxnyb377yx7";
+       sha256 = "a7fb73c6f2b6b7638a7cc8b4c232987e41a52be89f99b481d8b8ffb17d6a8253";
        isLibrary = false;
        isExecutable = true;
        executableHaskellDepends = [
@@ -8477,7 +8478,7 @@ self: {
      mkDerivation {
        pname = "Hoed";
        version = "0.2.2";
-       sha256 = "0b6jljwn8dq2szhz3k9axfphv3yi0zq7rhligvlwa5p8hr49wblx";
+       sha256 = "9d2e9e4886e816c5e97e91c27cf007d18f0dafeb2acdf1e1d7023764b9a4d22c";
        isLibrary = true;
        isExecutable = true;
        libraryHaskellDepends = [
@@ -8494,7 +8495,7 @@ self: {
      mkDerivation {
        pname = "HoleyMonoid";
        version = "0.1.1";
-       sha256 = "1z3d80r6w8n7803q52xlp8mzpk87q1pr3mnz6dswp39q3gygr9fr";
+       sha256 = "d9a5fcfc1b388dcb7533dfd6916fc007cdfb2bbab48b820740c7226e32406dfc";
        libraryHaskellDepends = [ base ];
        homepage = "https://github.com/MedeaMelana/HoleyMonoid";
        description = "Monoids with holes";
@@ -8509,7 +8510,7 @@ self: {
      mkDerivation {
        pname = "Holumbus-Distribution";
        version = "0.1.1";
-       sha256 = "1mhljxyfv02pfy2lyh10nlv5x05qvv37ij9i6c8c17f5b5qcgc78";
+       sha256 = "e8b0c77059c59dc0103331c978c6deb8805e36b520404f85775780ed7c9714d6";
        isLibrary = true;
        isExecutable = true;
        libraryHaskellDepends = [
@@ -8531,7 +8532,7 @@ self: {
      mkDerivation {
        pname = "Holumbus-MapReduce";
        version = "0.1.1";
-       sha256 = "0dqwj7xpw1lidv7ixfm1wzfx6psrzl2q08x3scyiskpm3a2l67q8";
+       sha256 = "081f43851af54e1d3dd3a3238005fd595fd3dde7a1ba1ecf6e91067efb911c37";
        isLibrary = true;
        isExecutable = true;
        libraryHaskellDepends = [
@@ -8554,7 +8555,7 @@ self: {
      mkDerivation {
        pname = "Holumbus-Searchengine";
        version = "1.2.3";
-       sha256 = "1kx0j4f13fj6k3xlhh5cmlb7lz35vyqd0sp913yy8yc2h56ybbqq";
+       sha256 = "18afe54d818279e4fd08e96ad0b0df657c7a16adac4048fb9846ba111c91a0cf";
        libraryHaskellDepends = [
          base binary bytestring bzlib containers deepseq directory
          enummapset filepath hslogger hxt hxt-cache hxt-curl
@@ -8575,7 +8576,7 @@ self: {
      mkDerivation {
        pname = "Holumbus-Storage";
        version = "0.1.0";
-       sha256 = "1zs6m3rsxh3886idcn0qm056bzv9yllgf3n2qsfa97cpbzhah54q";
+       sha256 = "9814a8e05f979da49cc6c20ef728f569ff650aa81858d6a24168c0aef3a846ff";
        isLibrary = true;
        isExecutable = true;
        libraryHaskellDepends = [
@@ -8593,7 +8594,7 @@ self: {
      mkDerivation {
        pname = "Homology";
        version = "0.1.1";
-       sha256 = "12cqfy2vpshly1rgjclzpnhb094s5wr038ahh5agsx03x6mnsr9n";
+       sha256 = "36656dabe90374fd548150a101322f9a24b0a0bd9f32f972f014eabb85779889";
        libraryHaskellDepends = [ base containers vector ];
        homepage = "http://www.math.ucla.edu/~damek";
        description = "Compute the homology of a chain complex";
@@ -8608,7 +8609,7 @@ self: {
      mkDerivation {
        pname = "HongoDB";
        version = "0.0.1";
-       sha256 = "19dwxv7fjk2k55mxgsc2gjx5jp9vr77yg01292gdj1piwmxx459v";
+       sha256 = "3b15d27be5f106d99e482280e7cfc93b5d59ba7c82e9d76b29534ce9ceeebca5";
        libraryHaskellDepends = [
          attoparsec attoparsec-binary base blaze-builder bytestring
          directory enumerator hashable monad-control mtl unix
@@ -8626,7 +8627,7 @@ self: {
      mkDerivation {
        pname = "HostAndPort";
        version = "0.2.0";
-       sha256 = "1rjv6c7j6fdy6gnn1zr5jnfmiqiamsmjfw9h3bx119giw3sjb9hm";
+       sha256 = "15a625f5e0f1a510fa1a307127abae2ae2589d9525ff60ed33be39230f335be6";
        libraryHaskellDepends = [ base parsec ];
        testHaskellDepends = [ base doctest hspec ];
        homepage = "https://github.com/bacher09/hostandport";
@@ -8639,7 +8640,7 @@ self: {
      mkDerivation {
        pname = "Hricket";
        version = "0.1";
-       sha256 = "0cmmhljlgb23kr6v8as2cma3cpgr6zpkb11qg6hmq1ilbi363282";
+       sha256 = "028961465c34065ca179388435ef37f95d365465422bb44d9e43ac472585b532";
        isLibrary = false;
        isExecutable = true;
        executableHaskellDepends = [ base containers ];
@@ -8658,7 +8659,7 @@ self: {
      mkDerivation {
        pname = "Hs2lib";
        version = "0.6.3";
-       sha256 = "0yjkghshbdbajib35hy3qr8x608i9qi2pgffpi59118krcw6k8mn";
+       sha256 = "b6a26938cb1385904abccebd2b224e1101d351c6c3c33256946ab505357c537a";
        isLibrary = true;
        isExecutable = true;
        libraryHaskellDepends = [
@@ -8684,7 +8685,7 @@ self: {
      mkDerivation {
        pname = "HsASA";
        version = "0.2";
-       sha256 = "1kdf2yq3v8lr84h2pf1ydi6vrqfr685vbkxjz4ai5wd2mij8i361";
+       sha256 = "c18c8864aca2f11215f9b2cfb50b32d9e1bc4d6c3eb82b204199a23db017aecd";
        libraryHaskellDepends = [ array base random ];
        homepage = "http://repetae.net/recent/out/HsASA.html";
        description = "A haskell interface to Lester Ingber's adaptive simulating annealing code";
@@ -8696,7 +8697,7 @@ self: {
      mkDerivation {
        pname = "HsHaruPDF";
        version = "0.0.0";
-       sha256 = "1yifhxk1m3z2i7gaxgwlmk6cv2spbpx8fny4sn59ybca8wd9z7ps";
+       sha256 = "fa9e9f1a478a2d9f8ad5c45b87fa5d578bcdccac94bfaede89e28f1a66872efa";
        libraryHaskellDepends = [ base ];
        description = "Haskell binding to libharu (http://libharu.sourceforge.net/)";
        license = stdenv.lib.licenses.bsd3;
@@ -8710,7 +8711,7 @@ self: {
      mkDerivation {
        pname = "HsHyperEstraier";
        version = "0.4";
-       sha256 = "0q7nngghplw97q5cmayqkkixa5lbprilvkcv0260yaz7wg5xpqk8";
+       sha256 = "68e2dbcbe3e72b0f8c009bcd4d63be8b16d5e39cd8abca0a3e89d30bdfb3f660";
        libraryHaskellDepends = [
          base base-unicode-symbols bytestring network text
        ];
@@ -8727,7 +8728,7 @@ self: {
      mkDerivation {
        pname = "HsJudy";
        version = "0.2";
-       sha256 = "1ypdsjy7gn6b3ynn17fcpirgwq3017jahm3pj5fh4qr6zr1cljkh";
+       sha256 = "704aca42fe2663025d917754a8e4096060fe72bccc9d60ad1fcbd877bcd4edfa";
        libraryHaskellDepends = [ base bytestring containers ];
        librarySystemDepends = [ Judy ];
        homepage = "http://www.pugscode.org/";
@@ -8743,7 +8744,7 @@ self: {
      mkDerivation {
        pname = "HsOpenSSL";
        version = "0.11.1.1";
-       sha256 = "1hf4xgc2488hm0y9isrl7mxlacf1iazb6h1l1wz8dab8x5sf0qaa";
+       sha256 = "4a61e074e968a9863e0f3440b3be8ac131457b3d34eb983ca8102122d8ebc4c1";
        libraryHaskellDepends = [
          base bytestring network old-locale time
        ];
@@ -8761,7 +8762,7 @@ self: {
      mkDerivation {
        pname = "HsOpenSSL-x509-system";
        version = "0.1.0.2";
-       sha256 = "16r82d6mk5l1pb0vvc16d1cn5pi4wg9k83y7vr9gl9ackz345jgc";
+       sha256 = "ecc942c69f4c25fa52dec70f34d3e324de62596826b0bdc1ba8196594d13289b";
        libraryHaskellDepends = [ base bytestring HsOpenSSL unix ];
        homepage = "https://github.com/redneb/HsOpenSSL-x509-system";
        description = "Use the system's native CA certificate store with HsOpenSSL";
@@ -8773,7 +8774,7 @@ self: {
      mkDerivation {
        pname = "HsParrot";
        version = "0.0.2.20120717";
-       sha256 = "19f95cyxcyhsk2x13l7csahgnn8rs029s3hdlxp5z0d3a9vb41gd";
+       sha256 = "ed05b27652a3815f6ea70d0e9d04d01959fba0d2ecd011ba981a7ad63d2bc9a5";
        libraryHaskellDepends = [
          base bytestring HsSyck pretty pugs-DrIFT
        ];
@@ -8787,7 +8788,7 @@ self: {
      mkDerivation {
        pname = "HsPerl5";
        version = "0.0.6";
-       sha256 = "0czhibr8lw4mjinwszjp4nh1ifi1xgkynwbjs6l3k97dqfd8bw4v";
+       sha256 = "9bf0859ac3eda439a8d17271ebe7eb21ba18a025577ecd6d9495708af28af033";
        libraryHaskellDepends = [ base ];
        description = "Haskell interface to embedded Perl 5 interpreter";
        license = stdenv.lib.licenses.bsd3;
@@ -8799,7 +8800,7 @@ self: {
      mkDerivation {
        pname = "HsSVN";
        version = "0.4.3.3";
-       sha256 = "1yx4dzcjmykk4nzrh888jhikb8x635dpx7g27rgnlaiy5nid3pc7";
+       sha256 = "87ddd1a22d3e2a6a5f3ee29d7e5b19a6a3352394082198bf2573fa2ad96fa4fb";
        libraryHaskellDepends = [ base bytestring mtl stm ];
        jailbreak = true;
        homepage = "https://github.com/phonohawk/HsSVN";
@@ -8813,7 +8814,7 @@ self: {
      mkDerivation {
        pname = "HsSyck";
        version = "0.53";
-       sha256 = "17r4jwnkjinmzpw9m2crjwccdyv9wmpljnv1ldgljkr9p9mb5ywf";
+       sha256 = "8efbb26aba294f495fa3615b496fe569fbc6189799899af8fdd546392d97249f";
        libraryHaskellDepends = [
          base bytestring hashtables syb utf8-string
        ];
@@ -8826,7 +8827,7 @@ self: {
      mkDerivation {
        pname = "HsTools";
        version = "0.0.1.1";
-       sha256 = "0banfivx4xc0j3c1qmda31gvvrqqsg12fzizcpman2fvdlk7kn5l";
+       sha256 = "b4d879266ddb09abea653f7e27c2d318e7bd5f18aa551cd8908075d27774562d";
        libraryHaskellDepends = [ base ghc-prim ];
        description = "Haskell helper functions";
        license = stdenv.lib.licenses.bsd3;
@@ -8841,7 +8842,7 @@ self: {
      mkDerivation {
        pname = "Hsed";
        version = "0.2.2";
-       sha256 = "09v2gcazqlmw7j7sqzzzmsz1jr3mrnfy3p30w9hnp2g430w10r2a";
+       sha256 = "4a64103818e4896b61e260dce19dcd756419beaeff7fac8f3cbc52fc157b6227";
        isLibrary = true;
        isExecutable = true;
        libraryHaskellDepends = [
@@ -8863,7 +8864,7 @@ self: {
      mkDerivation {
        pname = "Hsmtlib";
        version = "2.8.8.8";
-       sha256 = "1zb5s5rwcqc90c3zv332k44p7l13ngp9nqci8qalnlbxbypx3hab";
+       sha256 = "4bc1d1af5f7d514b154691619beeb323d0730999628cfd07038961c673d165fd";
        revision = "1";
        editedCabalFile = "01f30561cce8648a656f075ba1e1f8c23144e7f10c6377a7949881dc513f8a89";
        libraryHaskellDepends = [
@@ -8883,7 +8884,7 @@ self: {
      mkDerivation {
        pname = "HueAPI";
        version = "0.2.5";
-       sha256 = "1yz0cjacywrv72hj9dqf9c3zqslhcfz68z149hhv49f7g7k5m64i";
+       sha256 = "91985ae679c725b2214c247c64be63906afc074b0eb724a1383b73cf9464e0fb";
        libraryHaskellDepends = [
          aeson base containers lens lens-aeson mtl transformers wreq
        ];
@@ -8899,7 +8900,7 @@ self: {
      mkDerivation {
        pname = "Hungarian-Munkres";
        version = "0.1.5";
-       sha256 = "0g2hgcrsfwqp4w3mzg6vwi7lypgqd0b6axaff81wbi27h9n8q4qd";
+       sha256 = "0d138c6c8247c4c503724e75651668f85d4f4fe4dbbc5f07271773a7337b503c";
        libraryHaskellDepends = [ base ];
        testHaskellDepends = [
          array base Munkres random tasty tasty-quickcheck
@@ -8913,7 +8914,7 @@ self: {
      mkDerivation {
        pname = "IDynamic";
        version = "0.1";
-       sha256 = "1p4h2hxwzp0bxkzh864vkqbwychi0j2c3rqck9vk5kfax5i1jfz8";
+       sha256 = "e83b1962e9cacd32779a0ce7c184041132cf179e9b1804ffec0bdccf3b1490dc";
        libraryHaskellDepends = [ base containers directory ];
        jailbreak = true;
        description = "Indexable, serializable form of Data.Dynamic";
@@ -8926,7 +8927,7 @@ self: {
      mkDerivation {
        pname = "IFS";
        version = "0.1.1";
-       sha256 = "1r2dbpsmmsgxb43ycsz54zxcyfwanp72r9ry645mjlshg4q360xr";
+       sha256 = "b9033330795053590b313ea72cceb58a3bcffa27e56be60759fde95af55d4de4";
        isLibrary = true;
        isExecutable = true;
        libraryHaskellDepends = [
@@ -8945,7 +8946,7 @@ self: {
      mkDerivation {
        pname = "INblobs";
        version = "0.1.1";
-       sha256 = "04il63xafq20jn3m4hahn93xxfrp6whrjvsz974zczxqm41ygb10";
+       sha256 = "20ace703a9b87ff6c9495f6f99213737bbde47b250415287954060a7fa303412";
        isLibrary = false;
        isExecutable = true;
        executableHaskellDepends = [
@@ -8963,7 +8964,7 @@ self: {
      mkDerivation {
        pname = "IOR";
        version = "0.1";
-       sha256 = "0iinsva0pwparpg4lkgx8mw8l49rnl1h3zzblp89nkqk5i7qhq8a";
+       sha256 = "0a61884f2c134f9bd0a5ebff0103b539118a7845fd4d4adecdeaf20bd4d63646";
        libraryHaskellDepends = [ base mtl ];
        description = "Region based resource management for the IO monad";
        license = stdenv.lib.licenses.bsd3;
@@ -8977,7 +8978,7 @@ self: {
      mkDerivation {
        pname = "IORefCAS";
        version = "0.2.0.1";
-       sha256 = "06vfck59x30mqa9h2ljd4r2cx1ks91b9gwcr928brp7filsq9fdb";
+       sha256 = "abb984358deedcbc904899f19756487a86ce44264d520193c2158c9eca646e1b";
        libraryHaskellDepends = [ base bits-atomic ghc-prim ];
        testHaskellDepends = [
          base bits-atomic ghc-prim HUnit QuickCheck time
@@ -8993,7 +8994,7 @@ self: {
      mkDerivation {
        pname = "IOSpec";
        version = "0.3";
-       sha256 = "0dwl2nx8fisl1syggwd3060wa50lj5nl9312x4q7pq153cxjppyy";
+       sha256 = "dedf2b3b1b25e07b30e9228c446d911414c58101a3f1f7bc0e544787ba159437";
        libraryHaskellDepends = [ base mtl QuickCheck Stream ];
        description = "A pure specification of the IO monad";
        license = stdenv.lib.licenses.bsd3;
@@ -9006,7 +9007,7 @@ self: {
      mkDerivation {
        pname = "IPv6Addr";
        version = "0.6.0.2";
-       sha256 = "0qzrida38n92ngrrnmjpdg3vinjjscijz8fsfr7lyffaw55k6pld";
+       sha256 = "8d5e334be1ca394f4f76daa12f23d352dab8c76b57569bf3b3225934548bf963";
        libraryHaskellDepends = [
          attoparsec base iproute network network-info random text
        ];
@@ -9023,7 +9024,7 @@ self: {
      mkDerivation {
        pname = "IcoGrid";
        version = "0.1.2";
-       sha256 = "0ryb2q5xfddcx2qg019jajac7xvaw2ci5wi094gbrqhhflj7wc8n";
+       sha256 = "16317e247510e2bc1e4920f21299e06af7c394543205f0b0e8ac35d70b16cb67";
        libraryHaskellDepends = [ array base GlomeVec ];
        jailbreak = true;
        homepage = "http://www.haskell.org/haskellwiki/IcoGrid";
@@ -9036,7 +9037,7 @@ self: {
      mkDerivation {
        pname = "IfElse";
        version = "0.85";
-       sha256 = "1kfx1bwfjczj93a8yqz1n8snqiq5655qgzwv1lrycry8wb1vzlwa";
+       sha256 = "8ad3bfc3e2c867e6330d9bff874b3105476c35b2e1638fd448f233e9f80addcd";
        libraryHaskellDepends = [ base mtl ];
        description = "Anaphoric and miscellaneous useful control-flow";
        license = stdenv.lib.licenses.bsd3;
@@ -9047,7 +9048,7 @@ self: {
      mkDerivation {
        pname = "Imlib";
        version = "0.1.2";
-       sha256 = "075x1vcrxdwknzbad05l08i5c79svf714yvv6990ffvsfykiilry";
+       sha256 = "3ed318a7777a3b0752327b7b128edb3a1d562202b480a6d6b793b79ed90ebd1c";
        libraryHaskellDepends = [ array base X11 ];
        librarySystemDepends = [ imlib2 ];
        license = stdenv.lib.licenses.bsd3;
@@ -9058,7 +9059,7 @@ self: {
      mkDerivation {
        pname = "ImperativeHaskell";
        version = "2.0.0.1";
-       sha256 = "06px87hc6gz7n372lvpbq0g2v2s0aghd3k5a1ajgn5hbxirhnpwb";
+       sha256 = "8b5f0b73ec0b16fba40aaaccd1e053408b2d1ec0eb6e2aceb0e73fc3e041fd1a";
        libraryHaskellDepends = [ base mtl template-haskell ];
        homepage = "https://github.com/mmirman/ImperativeHaskell";
        description = "A library for writing Imperative style haskell";
@@ -9071,7 +9072,7 @@ self: {
      mkDerivation {
        pname = "IndentParser";
        version = "0.2.1";
-       sha256 = "0l9k8md2n0vhjqlvxcaf43i4cv09lnbbbw8vfz7bkbzhbwirs32j";
+       sha256 = "520c9d235ff0afb9ce771bf1b596a5096c46e2204eb1be299670032b5a453351";
        libraryHaskellDepends = [ base parsec ];
        homepage = "http://www.cse.iitk.ac.in/~ppk";
        description = "Combinators for parsing indentation based syntatic structures";
@@ -9083,7 +9084,7 @@ self: {
      mkDerivation {
        pname = "IndexedList";
        version = "0.1.0.1";
-       sha256 = "1i7gv3iqjj4j026k0ywmksbpjyqxlgb0f6bq2v0p9pkrj5q3jxfm";
+       sha256 = "d57539709179de74c116781907d6a31d7b79979e957b308d00924889e3d8efc4";
        libraryHaskellDepends = [ base PeanoWitnesses ];
        jailbreak = true;
        homepage = "https://github.com/kwf/IndexedList";
@@ -9096,7 +9097,7 @@ self: {
      mkDerivation {
        pname = "InfixApplicative";
        version = "1.1";
-       sha256 = "03c0jlnlnqm6faiandfg0kzajffk03aazkrqwav3g4vc3cdqwfgp";
+       sha256 = "f7398e1b1b6c9337b6e238cfafd400d339a9fe04cf35aba272a6624b2d95800d";
        libraryHaskellDepends = [ base haskell98 ];
        description = "liftA2 for infix operators";
        license = stdenv.lib.licenses.bsd3;
@@ -9108,7 +9109,7 @@ self: {
      mkDerivation {
        pname = "Interpolation";
        version = "0.3.0";
-       sha256 = "046bx18mlgicp26391gvgzbi0wfwl9rddam3jdfz4lpxva4q9xhv";
+       sha256 = "1bf68489dafd52f25d93a3aad672a2dc7110d77ffb85348cb82c3e5a51e8cb10";
        libraryHaskellDepends = [
          base haskell-src-meta syb template-haskell
        ];
@@ -9121,7 +9122,7 @@ self: {
      mkDerivation {
        pname = "Interpolation-maxs";
        version = "0.3.0";
-       sha256 = "0dh8d681h47jngan89vxnf8yhm31vjv8ysf21w6gclzfcl521vgn";
+       sha256 = "f6ed200a65ee53f60c0fc2698fb6dc6154e891b37d2764d5b3f2101890690836";
        libraryHaskellDepends = [ base syb template-haskell ];
        description = "Multiline strings, interpolation and templating";
        license = "unknown";
@@ -9132,7 +9133,7 @@ self: {
      mkDerivation {
        pname = "IntervalMap";
        version = "0.4.0.1";
-       sha256 = "0cq0dmmawrss4jjkz3br0lhp37d4k7rd3cinbcyf0bf39dfk6mrf";
+       sha256 = "2e57335d4bc32de03c5b36b2d1f299a49d712105798d3fa5245a67ae6a6d0033";
        libraryHaskellDepends = [ base containers deepseq ];
        testHaskellDepends = [ base Cabal containers deepseq QuickCheck ];
        homepage = "http://www.chr-breitkopf.de/comp/IntervalMap";
@@ -9147,7 +9148,7 @@ self: {
      mkDerivation {
        pname = "Irc";
        version = "0.1.0.2";
-       sha256 = "0qh1j9zy0yfpzdjxn6mypsw555pq2gm5nzys08zj5ilqn5z2r2pi";
+       sha256 = "f18a2c7eb198c6223f02da7f5bea13f89652b8bebe1adb65fbd779e07f920162";
        libraryHaskellDepends = [
          base data-default mtl network transformers
        ];
@@ -9164,7 +9165,7 @@ self: {
      mkDerivation {
        pname = "IrrHaskell";
        version = "0.2";
-       sha256 = "1j0m4ib2r84kb7c0s3qpmv3cziq3a2mql4ga9rnqi5pqkqpz2xcc";
+       sha256 = "8c75f12f9ef896886d4eea118aab5003c7cfc6ae170f0dd85993a02c562415c8";
        libraryHaskellDepends = [ base random time ];
        description = "Haskell FRP binding to the Irrlicht game engine";
        license = "LGPL";
@@ -9179,7 +9180,7 @@ self: {
      mkDerivation {
        pname = "IsNull";
        version = "0.4.0.0";
-       sha256 = "06f03b9my7hix5fvcv9cc0saf9zfwgkvn3210vymlyc1rj450ykm";
+       sha256 = "757a5088cc81795afd06410cbbe7e3ee27a734602c6db65de9111e5fd31ac019";
        libraryHaskellDepends = [ base bytestring containers text ];
        testHaskellDepends = [
          base bytestring containers hspec HUnit QuickCheck
@@ -9200,7 +9201,7 @@ self: {
      mkDerivation {
        pname = "JSON-Combinator";
        version = "0.2.8";
-       sha256 = "0rdiva15wspaz33dh1g7x6llswsx1l4j51wqyvszzcjzifx2ly6q";
+       sha256 = "d8782aba8b5fb2fff5f6988722090d5d734da9e9e705d8c6f8ea6a5e82dab165";
        libraryHaskellDepends = [
          aeson attoparsec base bytestring bytestring-trie containers failure
          hjson json JSONb parsec text vector
@@ -9215,7 +9216,7 @@ self: {
      mkDerivation {
        pname = "JSON-Combinator-Examples";
        version = "0.0.1";
-       sha256 = "1s5grfgnklnwh55yn5mlg2ibdm7mx2i7hwqs7649gkapda054ywg";
+       sha256 = "8f7b52806a57cd9788391a7378a2e8f5d4b6a278b416eb4b81dcd2699fcbafe8";
        libraryHaskellDepends = [
          base bytestring json JSON-Combinator JSONb
        ];
@@ -9231,7 +9232,7 @@ self: {
      mkDerivation {
        pname = "JSONb";
        version = "1.0.8";
-       sha256 = "16gjdlajqvwvq1znyq3vqxfa9vq4xs0ywxpm93v0y1rgmzcfqzj7";
+       sha256 = "477eecd8af2f070ff648f576ee81ee04efa45cc77b606f7fc09b6f2c156df299";
        revision = "1";
        editedCabalFile = "47b2855a9c5769eadfdbb4eaddca6c66e6de21432d555162f2cc4dcde6e0861a";
        isLibrary = true;
@@ -9260,7 +9261,7 @@ self: {
      mkDerivation {
        pname = "JYU-Utils";
        version = "0.1.1.2";
-       sha256 = "1c3cxdzbdvmvy1qvy4xvg10zijm8vw48pgh9c8a6mykgncwq6pw9";
+       sha256 = "895f8339b36ffa6a146209be8b08dfa8caf84178bb13bf71f0bbeeb67eeb6cb0";
        libraryHaskellDepends = [
          array base binary bytestring containers deepseq directory filepath
          lazysmallcheck mtl mwc-random parallel process QuickCheck random
@@ -9277,7 +9278,7 @@ self: {
      mkDerivation {
        pname = "JackMiniMix";
        version = "0.1";
-       sha256 = "0ivqfk1rac1hv5j6nlsbpcm5yjqwpic34mdq9gf2m63lygqkbwqp";
+       sha256 = "17f335f1f374982adc4bb8553258bc1c4b5f2abb4b536b64d9303095c3747847";
        libraryHaskellDepends = [ base hosc ];
        homepage = "http://www.renickbell.net/doku.php?id=jackminimix";
        description = "control JackMiniMix";
@@ -9291,7 +9292,7 @@ self: {
      mkDerivation {
        pname = "Javasf";
        version = "0.0.1";
-       sha256 = "14v0skqf1s54jkscgdcxjh1yv5lcrc5ni44bizx0kw35vf07faah";
+       sha256 = "50297780db65f009fa8f8b90680bcb8c96ed03949db5c7f494a4e8e0f0d46093";
        isLibrary = false;
        isExecutable = true;
        executableHaskellDepends = [
@@ -9307,7 +9308,7 @@ self: {
      mkDerivation {
        pname = "Javav";
        version = "0.0.4";
-       sha256 = "06aiiq1bhl8gvhk2agk2rsmqrqf6ac5ym194bm5aq47hmdwi33h9";
+       sha256 = "098e1179abf010ac4a5d2485ea0b53c6e18cabce623e2526dc0f51b8028e5119";
        isLibrary = false;
        isExecutable = true;
        executableHaskellDepends = [ base ];
@@ -9323,7 +9324,7 @@ self: {
      mkDerivation {
        pname = "JsContracts";
        version = "0.5.3";
-       sha256 = "17l6kdpdc7lrpd9j4d2b6vklkpclshcjy6hzpi442b7pj96sn589";
+       sha256 = "0915ab4d92f72c4148bc1f1a2f19d494dd49e7364b342253bb991ed66e9b869e";
        isLibrary = true;
        isExecutable = true;
        libraryHaskellDepends = [
@@ -9349,7 +9350,7 @@ self: {
      mkDerivation {
        pname = "JsonGrammar";
        version = "1.0.2";
-       sha256 = "0baywdqdj0r73rfxm5zk51bgsl014s19j01wnzarfbhak8cpwcdf";
+       sha256 = "ae317e199a0a2e97d5b73c009982260150fd5628f397da5d1e2703d970e35e2d";
        libraryHaskellDepends = [
          aeson attoparsec base bytestring containers hashable
          language-typescript mtl semigroups stack-prism template-haskell
@@ -9372,7 +9373,7 @@ self: {
      mkDerivation {
        pname = "JuicyPixels";
        version = "3.2.5.3";
-       sha256 = "1knq5jbwggf59h8a6aa758387q71fpzcvssg8dsr84bqwqqg2dpw";
+       sha256 = "fc36f130e678119475434febcdfe75e1e083062a4729a3104cc5bdc7972cd8ce";
        libraryHaskellDepends = [
          base binary bytestring containers deepseq mtl primitive
          transformers vector zlib
@@ -9387,7 +9388,7 @@ self: {
      mkDerivation {
        pname = "JuicyPixels-canvas";
        version = "0.1.0.0";
-       sha256 = "0y791kwg9gc3nlz5sbpszd7wiqr5b5bwmgvafyjzk9xnlxlc7xcm";
+       sha256 = "95f5c368a7b6a7f9a5776abfca575925e3c84ffbfa2e5d3eb583bdf4f80ce978";
        libraryHaskellDepends = [ base containers JuicyPixels ];
        jailbreak = true;
        homepage = "http://eax.me/";
@@ -9400,7 +9401,7 @@ self: {
      mkDerivation {
        pname = "JuicyPixels-repa";
        version = "0.7";
-       sha256 = "0fn9i3w8s2ifyg0zsdryyw1nm0c5ybaq0c6jxcggs79x0ngi0mm5";
+       sha256 = "a556109f053d1dfd1eebd23080d5f285816a03f73e37fdc1f32e0a8df888c93a";
        libraryHaskellDepends = [
          base bytestring JuicyPixels repa vector
        ];
@@ -9414,7 +9415,7 @@ self: {
      mkDerivation {
        pname = "JuicyPixels-util";
        version = "0.2";
-       sha256 = "1b2rx5g8kd83hl50carr02mz21gvkasnsddw1f3pfvfsyfv3yyrc";
+       sha256 = "2c7b3fb6f3da6d77870bbc356db59afb05f1ab00392b060a8503b5895ee959ac";
        libraryHaskellDepends = [ base JuicyPixels vector ];
        homepage = "https://github.com/fumieval/JuicyPixels-util";
        description = "Convert JuicyPixel images into RGBA format, flip, trim and so on";
@@ -9428,7 +9429,7 @@ self: {
      mkDerivation {
        pname = "JunkDB";
        version = "0.1.1.0";
-       sha256 = "0g68khpfiwknqwwa7hv7db0563hsnd3hczfd0p4nx777xqrkh2dx";
+       sha256 = "bd093833eee79c6ec905cd7d0647b31a0e53c06a67c3a338c776f2e82e9cc83c";
        libraryHaskellDepends = [
          aeson base binary bytestring conduit data-default directory
          filepath mtl network resourcet
@@ -9444,7 +9445,7 @@ self: {
      mkDerivation {
        pname = "JunkDB-driver-gdbm";
        version = "0.1.1.0";
-       sha256 = "1q8sa4w60pv7mgf17zg8yjpjvbzrg2xlpn30myp66vq2kdv293jj";
+       sha256 = "528e24769b026f63aeaf60d84bbb78f9af2daff4e8fd13dcab675f6038511ae1";
        libraryHaskellDepends = [
          base bytestring conduit directory filepath JunkDB mtl resourcet
        ];
@@ -9460,7 +9461,7 @@ self: {
      mkDerivation {
        pname = "JunkDB-driver-hashtables";
        version = "0.1.1.0";
-       sha256 = "0385f0vpp4dy9r9cqh2rr7gpx07fazzqjk9bwrbs4nka4wfnqbv0";
+       sha256 = "602f6c1d276a5aa257e62b4d89ff57ee807edfc95940cc524ebe917b3770050d";
        libraryHaskellDepends = [
          base bytestring conduit hashable hashtables JunkDB mtl resourcet
        ];
@@ -9473,7 +9474,7 @@ self: {
      mkDerivation {
        pname = "JustParse";
        version = "2.1";
-       sha256 = "16il25s1fb4b6ih6njsqxx7p7x0fc0kcwa5vqn7n7knqph6vvjaa";
+       sha256 = "4ac9bd0dbcd8ce638fc5bb28ce26600ef4734fef584b6b60348b2c177411349a";
        libraryHaskellDepends = [ base ];
        homepage = "https://github.com/grantslatton/JustParse";
        description = "A simple and comprehensive Haskell parsing library";
@@ -9485,7 +9486,7 @@ self: {
      mkDerivation {
        pname = "KMP";
        version = "0.1.0.2";
-       sha256 = "14dpqfji00jq2rc09l8d1ivphpiwkryjk5sn6lrwxv8mcly3pvhn";
+       sha256 = "16ee3b3c6515edce33355697297d9e3c5e78770c0dd1045816580210a5c3b791";
        libraryHaskellDepends = [ array base ];
        testHaskellDepends = [ base Cabal ];
        homepage = "https://github.com/CindyLinz/Haskell-KMP";
@@ -9498,7 +9499,7 @@ self: {
      mkDerivation {
        pname = "KSP";
        version = "0.1";
-       sha256 = "19sjr9vavxnbv5yp2c01gy6iz1q2abllcsf378n15f3z064ffqn6";
+       sha256 = "c662e788017fb8122c3ac36946e95202871f8d7f0130717dd9cbf6ad76ca52a7";
        libraryHaskellDepends = [ base ];
        jailbreak = true;
        homepage = "https://github.com/frosch03/kerbal";
@@ -9511,7 +9512,7 @@ self: {
      mkDerivation {
        pname = "Kalman";
        version = "0.1.0.1";
-       sha256 = "1mzdaj6h21is3fwnckzq5zcxd4zqahsdppsx65bv5vdplsiadrw5";
+       sha256 = "85e7a6a2a6b7edb257315ddfdb3454f893d6d92ff84f66b91b3a06018d54edd7";
        libraryHaskellDepends = [ base hmatrix ];
        jailbreak = true;
        homepage = "https://github.com/idontgetoutmuch/Kalman";
@@ -9524,7 +9525,7 @@ self: {
      mkDerivation {
        pname = "KdTree";
        version = "0.2.1";
-       sha256 = "1vj1kbhyqh0xzwyr9v6fdyakx508vbf6n494z81yndisp115qi61";
+       sha256 = "c1445c42b83a36eb03fa24116bdcda08943e956fceec943dff1d40ece19a41ee";
        isLibrary = true;
        isExecutable = true;
        libraryHaskellDepends = [ base ];
@@ -9541,7 +9542,7 @@ self: {
      mkDerivation {
        pname = "Ketchup";
        version = "0.4.3";
-       sha256 = "1f5dnxfch3xrhxbgn74adzj7lalx1fpz3cicnhvvxj2aay62a7d1";
+       sha256 = "a11d258c574ac8be37b42cb2f1af0b9d2a7ae46f8a1cfb5687b90fc85cb7adb8";
        libraryHaskellDepends = [
          base base64-bytestring bytestring directory mime-types network text
        ];
@@ -9560,7 +9561,7 @@ self: {
      mkDerivation {
        pname = "KiCS";
        version = "0.9.3";
-       sha256 = "0z5ps5apr436dbm5wkfnpqksnqi3jsqmp2zkmy37crzzinlilzvn";
+       sha256 = "767f1aa98dff677686aff38b5bb1962362ab27bed64d5eea6a66907c55d1b77c";
        isLibrary = true;
        isExecutable = true;
        libraryHaskellDepends = [
@@ -9585,7 +9586,7 @@ self: {
      mkDerivation {
        pname = "KiCS-debugger";
        version = "0.1.1";
-       sha256 = "1hvdqil8lfybcp2j04ig03270q5fy29cbmg8jmv38dpcgjsx6mk1";
+       sha256 = "6156d3b57cec36347695e8d5c592f0ae6070c4002f1220c565cb3b8a68c46dc3";
        isLibrary = true;
        isExecutable = true;
        libraryHaskellDepends = [
@@ -9606,7 +9607,7 @@ self: {
      mkDerivation {
        pname = "KiCS-prophecy";
        version = "0.1.1";
-       sha256 = "0l278x2gavm0ndbm4k0197cwyvamz37vzy7nz35lb7n5sc5b2gsr";
+       sha256 = "593fb10ad3c59e45cbf8f6f8bfcff8556dcfd949014c5257b3a06ef544474750";
        isLibrary = true;
        isExecutable = true;
        libraryHaskellDepends = [ base filepath KiCS ];
@@ -9623,7 +9624,7 @@ self: {
      mkDerivation {
        pname = "Kleislify";
        version = "0.0.4";
-       sha256 = "0f7f6sxb774h9dx6xy6wbcrc5b2i27k9m5ay3hq9hqsjg86qmxyl";
+       sha256 = "d4f78a0d7a526398301c5e959ae61151acc2325bdcf86e7a4b909cb3ba36ee38";
        libraryHaskellDepends = [ base ];
        description = "Variants of Control.Arrow functions, specialised to kleislis.";
        license = stdenv.lib.licenses.bsd3;
@@ -9634,7 +9635,7 @@ self: {
      mkDerivation {
        pname = "Konf";
        version = "0.1.0.0";
-       sha256 = "113jxbaw8b17j91aakxli3r3zdvnx3gvf2m57sx5d7mfk2qx28r6";
+       sha256 = "2623d1b198ae9e56ba3ea50ab7dfe876b73ff288b44fa54292272cc4d5ea7284";
        libraryHaskellDepends = [ base containers parsec ];
        jailbreak = true;
        homepage = "http://www.gkayaalp.com/p/konf.html";
@@ -9650,7 +9651,7 @@ self: {
      mkDerivation {
        pname = "KyotoCabinet";
        version = "0.1";
-       sha256 = "1l7cpppjfz5nd8k67ss959g8sg5kbsfl4zy80a3yrlwbivyrg58n";
+       sha256 = "169597fd8e8bd3ec8702c87f429d5eb33c8d5e2a49eb63266ab67c27efbdecd0";
        libraryHaskellDepends = [ base bytestring extensible-exceptions ];
        librarySystemDepends = [ kyotocabinet ];
        homepage = "https://code.google.com/p/kyotocabinet-hs/";
@@ -9666,7 +9667,7 @@ self: {
      mkDerivation {
        pname = "L-seed";
        version = "0.2";
-       sha256 = "1dj4320fpwmlqv5jzzi7x218mrsacdmmk3czb1szzq44pmfmpy32";
+       sha256 = "62f85b5dbd84e0ff75589f8d596b634ae78a82e827fe2fcbc6b4f2eb801844b6";
        isLibrary = true;
        isExecutable = true;
        libraryHaskellDepends = [
@@ -9684,7 +9685,7 @@ self: {
      mkDerivation {
        pname = "LDAP";
        version = "0.6.10";
-       sha256 = "10lzag91slnkd1nnh0vs9nxwrsd1k5a05c2bw4fdfzqmyrfqfl20";
+       sha256 = "4050875df6157fd71ce14bb0025499a1e9ccbb4d7a03686d68d3521dd2539f82";
        isLibrary = true;
        isExecutable = true;
        libraryHaskellDepends = [ base ];
@@ -9701,7 +9702,7 @@ self: {
      mkDerivation {
        pname = "LRU";
        version = "0.1.1";
-       sha256 = "0yppxz78y5myh9f53yqz6naqj15vk2h7fl3h8h8dps72zw9c5aqn";
+       sha256 = "16abc212ffe2e8db1044705077a098bb048995351ffb515c82be168fceeff77a";
        libraryHaskellDepends = [ base containers QuickCheck ];
        homepage = "http://www.imperialviolet.org/lru";
        description = "Implements an LRU data structure";
@@ -9713,7 +9714,7 @@ self: {
      mkDerivation {
        pname = "LTree";
        version = "0.1";
-       sha256 = "0liqz3n2ycidwmg8iz7mbm0d087fcfgphvbip8bsn0hpwlf10dvw";
+       sha256 = "7c37101ce51702ab17ba716d789f63ee20d0405df5fc885ee52d322fecf83852";
        libraryHaskellDepends = [ base transformers ];
        description = "Tree with only leaves carrying the data";
        license = stdenv.lib.licenses.publicDomain;
@@ -9726,7 +9727,7 @@ self: {
      mkDerivation {
        pname = "LambdaCalculator";
        version = "0.1";
-       sha256 = "0b4na8jsiwjnvyg1pl356ryffk2sj0l5f2dsivn71ii1qqblagcz";
+       sha256 = "9f3d4517c621c670ec8eba095728905a4ce77c3665d01b9edf56f2a82552962c";
        isLibrary = false;
        isExecutable = true;
        executableHaskellDepends = [
@@ -9748,7 +9749,7 @@ self: {
      mkDerivation {
        pname = "LambdaHack";
        version = "0.5.0.0";
-       sha256 = "0vzra6020jmir6pqs26fnw2pgap7l10160v5admk7wnrrnfr91r5";
+       sha256 = "2587949dcdd9f2336b5365031340a0e7aa7705b7ce088dafc9b14a208051f96f";
        isLibrary = true;
        isExecutable = true;
        libraryHaskellDepends = [
@@ -9784,7 +9785,7 @@ self: {
      mkDerivation {
        pname = "LambdaINet";
        version = "0.2.0.0";
-       sha256 = "1hdl25dzv19gjr8dzpq1r267v3jj2c2yiskbg0kzdcrh4cj7jcwk";
+       sha256 = "933379242330b3f627786beae80513528e7d8cc801dfdf50962f85fd5b11b4c1";
        isLibrary = false;
        isExecutable = true;
        executableHaskellDepends = [
@@ -9804,7 +9805,7 @@ self: {
      mkDerivation {
        pname = "LambdaNet";
        version = "0.2.0.0";
-       sha256 = "06sg360vbayz1314djlg6z885yrknd7gz15s355kna21xjqydmz4";
+       sha256 = "e4d7e6b1ec41283b4b19ba84ff4eb333fb82d0378fca46c208dfabb581194f1b";
        libraryHaskellDepends = [
          base binary bytestring hmatrix random random-shuffle split
        ];
@@ -9822,7 +9823,7 @@ self: {
      mkDerivation {
        pname = "LambdaPrettyQuote";
        version = "0.0.0.8";
-       sha256 = "0rxh9gxsd0qh76nzib9pqgzh10gdc629ypnhbg8fjgdiaza7hyal";
+       sha256 = "547978d457b13de9d05bd05e9f8461ed8100ffc337adf8ad391083a6fb4bb067";
        libraryHaskellDepends = [
          base DebugTraceHelpers HUnit lambda-ast mtl parsec QuickCheck syb
          template-haskell test-framework test-framework-hunit
@@ -9846,7 +9847,7 @@ self: {
      mkDerivation {
        pname = "LambdaShell";
        version = "0.9.3";
-       sha256 = "1nqzlnw3fchgqn9bvlvbjma1m0wwssrip2mwb2kiv4rbhqdbfijv";
+       sha256 = "5b46b71a862b931da758bc8a1bb3d69c831a54956bd3bd92c50f3237b8a51fdb";
        isLibrary = false;
        isExecutable = true;
        executableHaskellDepends = [
@@ -9863,7 +9864,7 @@ self: {
      mkDerivation {
        pname = "LargeCardinalHierarchy";
        version = "0.0.1";
-       sha256 = "0agq2593h5yb9r3jqnycis9fdizwij3and61ljc4prnhhyxv48g2";
+       sha256 = "e221b2bb87d0e64b98a4c134ab868cfcc7e6928ecc5b2c474ecb17385211f829";
        libraryHaskellDepends = [ base ];
        jailbreak = true;
        description = "A transfinite cardinal arithmetic library including all known large cardinals";
@@ -9877,7 +9878,7 @@ self: {
      mkDerivation {
        pname = "Lastik";
        version = "0.7.0";
-       sha256 = "1bq8az2lrdqszn1aicvxj0spmwpxphvcvgkl6p0mnz8878hyxsdm";
+       sha256 = "b5e9ee213a087d5bc13574becd36bcfdf27a35907db3a882fd1ab74cc55708af";
        libraryHaskellDepends = [
          base bytestring containers directory filemanip filepath process
          pureMD5 SHA zip-archive
@@ -9895,7 +9896,7 @@ self: {
      mkDerivation {
        pname = "Lattices";
        version = "0.0.1";
-       sha256 = "1x1rxl1pc64ifjrlmqqgs0p71bqymc17ls7wlj6skk1sy7kys2f5";
+       sha256 = "c509ede7f13acca98da4fc687a02ab1eaf702ed00fe34ab37491187603ed39f4";
        libraryHaskellDepends = [ array base HaskellForMaths ];
        testHaskellDepends = [
          array base HaskellForMaths HUnit test-framework
@@ -9911,7 +9912,7 @@ self: {
      mkDerivation {
        pname = "LazyVault";
        version = "0.0.1";
-       sha256 = "1y80bzcjyk5gkzkgyn8h7sf0bg11qn4qr0qgvi640spppxqfqkjq";
+       sha256 = "584eec70bff76a404cdc0f838c89c521bc059c3e1059ffe69faf4c2fd95f00f9";
        isLibrary = false;
        isExecutable = true;
        executableHaskellDepends = [ base directory filepath unix ];
@@ -9926,7 +9927,7 @@ self: {
      mkDerivation {
        pname = "Level0";
        version = "1.0";
-       sha256 = "1kpz8qpm2xj5nm0sav5439flyj3zdx6ha9lgg3c7ky4sjqvwwzxv";
+       sha256 = "bb7fce37969af879d8788f26054d6f7f484f5d1aa46ca541b54576512f46ffce";
        isLibrary = false;
        isExecutable = true;
        executableHaskellDepends = [ base directory random SDL SDL-ttf ];
@@ -9942,7 +9943,7 @@ self: {
      mkDerivation {
        pname = "LibClang";
        version = "0.1.0";
-       sha256 = "12bbmgd9xh6l9c9z3r82j2csksbplha1zzzzzb8338kj81wp1pjb";
+       sha256 = "4bde70794072a231d0faffff1f14a477e9a9999002e5f1134bd4c09edaab6b89";
        libraryHaskellDepends = [ base greencard time ];
        homepage = "https://github.com/chetant/LibClang/issues";
        description = "Haskell bindings for libclang (a C++ parsing library)";
@@ -9957,7 +9958,7 @@ self: {
      mkDerivation {
        pname = "LibZip";
        version = "0.11.1";
-       sha256 = "04nzh9gqji20qhiiyy8i23cb4gy9qbdza5pkwicgghiqbyfrpk6f";
+       sha256 = "cecc9b9d5f38c2f758e4f316f5dbc2c93fb2d81011791f23c44044895f82df12";
        libraryHaskellDepends = [
          base bindings-libzip bytestring filepath mtl time utf8-string
        ];
@@ -9975,7 +9976,7 @@ self: {
      mkDerivation {
        pname = "Limit";
        version = "1.0";
-       sha256 = "1yd8c443ql17daicn3r9jiwxxjlpqnpnvkbxcszjha4i4ar94zq1";
+       sha256 = "017f92b222912828bf667dcd6dafc597cade7994290fcba26a27503c0861a8f9";
        libraryHaskellDepends = [ base ];
        description = "Wrapper for data that can be unbounded";
        license = stdenv.lib.licenses.mit;
@@ -9987,7 +9988,7 @@ self: {
      mkDerivation {
        pname = "LinearSplit";
        version = "0.2.1";
-       sha256 = "05rdlxsl5zpnczahaw2fdycqyryd3y7bccizjbn5sap23spwd7di";
+       sha256 = "b19dc6af1ee22a5dec923f32b68e1fcd678f996f4e7005d567f6fe4275a72d17";
        libraryHaskellDepends = [
          array base cmdargs haskell98 QuickCheck
        ];
@@ -10004,7 +10005,7 @@ self: {
      mkDerivation {
        pname = "LinkChecker";
        version = "0.1";
-       sha256 = "00wlyqclmzn03y86ba64pkc85kndnakgj8spv4vm7z0k8dsphnfq";
+       sha256 = "d85978754313fc5337d95723f9a6b2cdce82d8bcc4a865901fc0fe4a19f69403";
        isLibrary = false;
        isExecutable = true;
        executableHaskellDepends = [
@@ -10021,7 +10022,7 @@ self: {
      mkDerivation {
        pname = "List";
        version = "0.5.2";
-       sha256 = "1b7ar17d2sq6ibgbiqbsrhk2zlxcxiwfv2xsfbya5hs8nflzkp97";
+       sha256 = "27ddf9a9b348c3a2fc72ba8bed78ecacd32f26cc7ae1b8de8a066bd14ec8eaac";
        libraryHaskellDepends = [ base transformers ];
        homepage = "http://github.com/yairchu/generator/tree";
        description = "List monad transformer and class";
@@ -10035,7 +10036,7 @@ self: {
      mkDerivation {
        pname = "ListLike";
        version = "4.2.0";
-       sha256 = "1ih0kjr3n576l6abasa8pnjajml27rj8h7nx3kqv2fdm7l6lk6zg";
+       sha256 = "ef9b490d3db539b1f11cdd1e88643e8256a9a4bd4869b594a1e6143bb29c00c6";
        libraryHaskellDepends = [
          array base bytestring containers dlist fmlist text vector
        ];
@@ -10053,7 +10054,7 @@ self: {
      mkDerivation {
        pname = "ListTree";
        version = "0.2.1";
-       sha256 = "1ril13w2n1sgl44qwm1ydg94cvkm2qk55hsfv5bxbb6r99xc645m";
+       sha256 = "b510c37a4ad9acd557d94ec3522616756e46d26b3e548e09a14f072bf80834e6";
        libraryHaskellDepends = [
          base directory filepath List transformers
        ];
@@ -10068,7 +10069,7 @@ self: {
      mkDerivation {
        pname = "ListZipper";
        version = "1.2.0.2";
-       sha256 = "0z3izxpl21fxz43jpx7zqs965anb3gp5vidv3pwwznr88ss2j6a9";
+       sha256 = "491929b44628dbcff91dbbc55dee1bcbaa6292c6fff42b07f9dd05416fff717c";
        libraryHaskellDepends = [ base QuickCheck ];
        description = "Simple zipper for lists";
        license = stdenv.lib.licenses.bsd3;
@@ -10079,7 +10080,7 @@ self: {
      mkDerivation {
        pname = "Logic";
        version = "0.1.0.0";
-       sha256 = "0jplyy09i2rr5l8qzkyd41wwi7yj3sxlrz8f36ygdwxnwqfk2w01";
+       sha256 = "0170311de6b6f3f6bc190efd4cbb1ed29fc87920cdcf8f112d398b9880f7f44a";
        libraryHaskellDepends = [ base ];
        jailbreak = true;
        homepage = "http://gogotanaka.me/";
@@ -10101,7 +10102,7 @@ self: {
      mkDerivation {
        pname = "LogicGrowsOnTrees";
        version = "1.1.0.2";
-       sha256 = "1yqnrzcmx8ch9xcpg07if9cs4z1sdpyjfpgzkqkhv9i263pfgxpk";
+       sha256 = "f3f6e7ee3022a60d279eff5d27fd6d3a7ca25972f18077594f90a15ed9cf16fb";
        isLibrary = true;
        isExecutable = true;
        libraryHaskellDepends = [
@@ -10135,7 +10136,7 @@ self: {
      mkDerivation {
        pname = "LogicGrowsOnTrees-MPI";
        version = "1.0.0.1.1";
-       sha256 = "0sqlx06i9f3wxzpk7mivbnn2k4z5n141vbkn1bj886bk5srbrx92";
+       sha256 = "22f5bcb22e731984e40a76ae1d48b0e59329ac5d3bd633efef7cb8140de8146b";
        isLibrary = true;
        isExecutable = true;
        libraryHaskellDepends = [
@@ -10163,7 +10164,7 @@ self: {
      mkDerivation {
        pname = "LogicGrowsOnTrees-network";
        version = "1.0.0.3";
-       sha256 = "0r66pb35fpmgvkf41kxz289c9ylwv7jdf9bxbsrv7p4ylg83x2dn";
+       sha256 = "b6893ed0a39edcb3b35e7d25d7e4d99cfac41212bfcf40dcdcaf5e57c6bac664";
        isLibrary = true;
        isExecutable = true;
        libraryHaskellDepends = [
@@ -10193,7 +10194,7 @@ self: {
      mkDerivation {
        pname = "LogicGrowsOnTrees-processes";
        version = "1.0.0.2";
-       sha256 = "0d1kz5d83frn1591vgk33d0rw2s4z98lp993rnvhl3k5zqpr2svn";
+       sha256 = "766b912ffe650e0ab7cd23a54b51fa440b9e411b63be1d520936bb815af93334";
        isLibrary = true;
        isExecutable = true;
        libraryHaskellDepends = [
@@ -10222,7 +10223,7 @@ self: {
      mkDerivation {
        pname = "LslPlus";
        version = "0.4.3";
-       sha256 = "0dwsx23fibgj36181rfwfj1kl6sgdkf8bk4dd9cwia0rbjrl4qyk";
+       sha256 = "d36342b35c19a8c8596a8dcc85dc6c4f1b3a8374dce5808219f2ade886e89a37";
        isLibrary = false;
        isExecutable = true;
        executableHaskellDepends = [
@@ -10245,7 +10246,7 @@ self: {
      mkDerivation {
        pname = "Lucu";
        version = "0.7.0.3";
-       sha256 = "09vhz5gc9nmlwlxn6vk5whq6lpqbidqifx4i4lvp4n21gib64v9b";
+       sha256 = "2b6d62567c4158723725917417718b0b5f6a30e4656e633be5b4dac45ef97027";
        isLibrary = true;
        isExecutable = true;
        libraryHaskellDepends = [
@@ -10267,7 +10268,7 @@ self: {
      mkDerivation {
        pname = "MC-Fold-DP";
        version = "0.1.1.0";
-       sha256 = "0h76xsh4p4zbxnbk7hszwm1gj44p6349d4bkbixn7fyiyp4f0pvh";
+       sha256 = "705fe0c8f5d1bb637b5c739196c8309710f942e55fc33397edeb934ba0eee640";
        isLibrary = true;
        isExecutable = true;
        libraryHaskellDepends = [
@@ -10291,7 +10292,7 @@ self: {
      mkDerivation {
        pname = "MFlow";
        version = "0.4.5.9";
-       sha256 = "0mqsyx7wkfgvpppqgpjpvzwx79vj7lh4c8afzzj1hgh8z0ilb4ik";
+       sha256 = "33924523f8083e18e4ff4e2146203d72a7d3f9df57de87efbdfbb9c94ff71a57";
        libraryHaskellDepends = [
          base blaze-html blaze-markup bytestring case-insensitive
          clientsession conduit conduit-extra containers directory
@@ -10310,7 +10311,7 @@ self: {
      mkDerivation {
        pname = "MHask";
        version = "0.3.0.0";
-       sha256 = "0nlj914ahipyfqv1l7qr66pa0a8g4g6ks6mipc38z5f1jy0kjrva";
+       sha256 = "6a67398197c1958f06bbb11a3dcd230f29a0ae31191f1a3676fe46a84848925a";
        libraryHaskellDepends = [ base transformers ];
        jailbreak = true;
        homepage = "https://github.com/DanBurton/MHask#readme";
@@ -10324,7 +10325,7 @@ self: {
      mkDerivation {
        pname = "MSQueue";
        version = "0.0.1";
-       sha256 = "04yvf4a07cy47qzl9p8x45qbk2i6yapfps7hx85p589338s8b72y";
+       sha256 = "5e9c85341a23a1720beaf0e8ebaef2268ab970211ddd443f3ec4b3031471db13";
        libraryHaskellDepends = [ base ghc-prim monad-loops ref-mtl stm ];
        jailbreak = true;
        homepage = "https://github.com/Julek";
@@ -10340,7 +10341,7 @@ self: {
      mkDerivation {
        pname = "MagicHaskeller";
        version = "0.9.1";
-       sha256 = "1rr1gp808qwi0i84l6hmm03b8khnawz8qq606p5a351pd0mbxkak";
+       sha256 = "53cdbe2a683794a1ca35c0608c3e57164eb406a8151a4a5004916304d07d21e7";
        libraryHaskellDepends = [
          array base bytestring containers directory ghc ghc-paths
          haskell-src html mtl network old-time pretty random syb
@@ -10352,12 +10353,31 @@ self: {
        hydraPlatforms = stdenv.lib.platforms.none;
      }) {};
 
+  "MailchimpSimple" = callPackage
+    ({ mkDerivation, aeson, aeson-lens, base, bytestring, directory
+     , filepath, http-conduit, http-types, lens, text, time
+     , transformers, vector
+     }:
+     mkDerivation {
+       pname = "MailchimpSimple";
+       version = "0.1.0.0";
+       sha256 = "56d883bca6efde9bd9fd776d9bcf88a4f4cfba562a79687fed2bb47ea2a8eb78";
+       libraryHaskellDepends = [
+         aeson aeson-lens base bytestring directory filepath http-conduit
+         http-types lens text time transformers vector
+       ];
+       jailbreak = true;
+       homepage = "https://github.com/Dananji/MailchimpSimple";
+       description = "A Haskell library to handle mailing lists in MailchimpSimple using its JSON API";
+       license = stdenv.lib.licenses.bsd3;
+     }) {};
+
   "MaybeT" = callPackage
     ({ mkDerivation, base, mtl }:
      mkDerivation {
        pname = "MaybeT";
        version = "0.1.2";
-       sha256 = "0cmnfs22ldai0z172rdsvryzsh33a70yax21v03nhr92a4b62plr";
+       sha256 = "995e61165122656807d84174e5c1516340fd7ddeba6571c20751352a8476b632";
        revision = "1";
        editedCabalFile = "399ec60488680853ace716790b8ebaeee1a74da8a24ced5b5caaea4341b88580";
        libraryHaskellDepends = [ base mtl ];
@@ -10371,7 +10391,7 @@ self: {
      mkDerivation {
        pname = "MaybeT-monads-tf";
        version = "0.2.0.1";
-       sha256 = "034v9n6ldjn1hsv4rphvysbykm8x0jqa2prbw7k28fkp6m30j74x";
+       sha256 = "9d1c094635773a24e6e12b5fa1b0041dd5e997f61bde4cb686c1ca468d4d9b0c";
        libraryHaskellDepends = [ base monads-tf transformers ];
        jailbreak = true;
        description = "MaybeT monad transformer compatible with monads-tf (deprecated)";
@@ -10384,7 +10404,7 @@ self: {
      mkDerivation {
        pname = "MaybeT-transformers";
        version = "0.2";
-       sha256 = "189w8dpxyq7gksca6k08hb4vpanpz06c99akgzpcpjy0i7k22ily";
+       sha256 = "9e4621e689c0cbcbee7f53a5c40cf8d7aabbc982084ca3989eef60df6f433ca1";
        libraryHaskellDepends = [ base monads-fd transformers ];
        jailbreak = true;
        description = "MaybeT monad transformer using transformers instead of mtl";
@@ -10399,7 +10419,7 @@ self: {
      mkDerivation {
        pname = "MazesOfMonad";
        version = "1.0.9";
-       sha256 = "041kqz5j8xaa2ciyrfnwz6p9gcx4il5s6f34kzv9kp0s07hmn1q2";
+       sha256 = "02075be1011adc99f69f6438a30b8da4b397aef9dcbaec23134a7524cbc73310";
        isLibrary = false;
        isExecutable = true;
        executableHaskellDepends = [
@@ -10416,7 +10436,7 @@ self: {
      mkDerivation {
        pname = "MeanShift";
        version = "0.1";
-       sha256 = "0rnbg7w3qc3xsbzpw5is7w7qdjl2kqbr1acc744aggwlibazl59w";
+       sha256 = "3c15fad58a94bfa708398ca990179e82ca860f3f3a167effd27d303cf879cb66";
        libraryHaskellDepends = [ base vector ];
        jailbreak = true;
        description = "Mean shift algorithm";
@@ -10428,7 +10448,7 @@ self: {
      mkDerivation {
        pname = "Measure";
        version = "0.0.2";
-       sha256 = "1vy8ykjy9cpv661byqv21775zbyciqx2hf77c1nl58nn34x0s2ds";
+       sha256 = "ba090d3a19d6a2426d60e738283a8eccaf5fce096263bf8231fbb2e4e5f4c8ef";
        libraryHaskellDepends = [ base ];
        jailbreak = true;
        description = "A library for units of measurement";
@@ -10441,7 +10461,7 @@ self: {
      mkDerivation {
        pname = "MemoTrie";
        version = "0.6.2";
-       sha256 = "1g4b82s30bqkfids3iywf873nyn8h7l8rp8l3xl58smj5lbi3p4x";
+       sha256 = "9ddc11172db26a54681f14dd8ce881c87a3b0e72dcc7a15b74132f30b4408bbc";
        libraryHaskellDepends = [ base void ];
        homepage = "http://haskell.org/haskellwiki/MemoTrie";
        description = "Trie-based memo functions";
@@ -10455,7 +10475,7 @@ self: {
      mkDerivation {
        pname = "MetaHDBC";
        version = "0.1.4";
-       sha256 = "0l47v2cpbngxrq1r6p95rfcs16jqwr8l1sy4bcg9liazz50i8lyr";
+       sha256 = "d9531441f95f459a1e5bc4eb4051e6589aa099cb255d9303cefdd97599d88750";
        libraryHaskellDepends = [
          base convertible hashtables HDBC HDBC-odbc mtl template-haskell
        ];
@@ -10469,7 +10489,7 @@ self: {
      mkDerivation {
        pname = "MetaObject";
        version = "0.0.6.20110925";
-       sha256 = "0cgn13rpbqkywpiki6fcl76iwmc74d0f9ixki6dg7lrg49lhb67r";
+       sha256 = "f9980569222fd3f39a89b3c7e4402387551ecda1cc9938e3e57ee275f308f631";
        libraryHaskellDepends = [ base containers stringtable-atom ];
        description = "A meta-object system for Haskell based on Perl 6";
        license = stdenv.lib.licenses.bsd3;
@@ -10481,7 +10501,7 @@ self: {
      mkDerivation {
        pname = "Metrics";
        version = "0.1.2";
-       sha256 = "1ks5h3vlla2d86wvf2a4z1qifsinya2skq8ygdk45ynnwk735y4x";
+       sha256 = "9df832cee4d6fa42667b1ee1a985f2366a1771f84409b7b9414d284af78045cf";
        libraryHaskellDepends = [ base hstats ];
        homepage = "http://github.com/benhamner/Metrics/";
        description = "Evaluation metrics commonly used in supervised machine learning";
@@ -10496,7 +10516,7 @@ self: {
      mkDerivation {
        pname = "Mhailist";
        version = "0.0";
-       sha256 = "1vxsaw2kfrx6g5y57lchcs1xwj0jnanw9svg59mjnasw53z674ck";
+       sha256 = "939163fe285c2b2b6b2a6febc4adb21248de836690d1537c79a667370557baef";
        isLibrary = false;
        isExecutable = true;
        executableHaskellDepends = [
@@ -10516,7 +10536,7 @@ self: {
      mkDerivation {
        pname = "MiniAgda";
        version = "0.2014.9.12";
-       sha256 = "14h7ksd95wiixfmvrkxw3l13qdxhrhgkhmz00mcw04bdyzfmgr0n";
+       sha256 = "16e457ddf76d11c05905e057381fccb0373c021dbccfbcabeb31f2929a9e0792";
        isLibrary = false;
        isExecutable = true;
        executableHaskellDepends = [
@@ -10539,7 +10559,7 @@ self: {
      mkDerivation {
        pname = "MissingH";
        version = "1.3.0.1";
-       sha256 = "1cwdhgqqv2riqwhsgyrpmqyzvg19lx6zp1g7xdp4rikh7rkn03ds";
+       sha256 = "ba0d60673e70c64c6eebe785fb4da729bcfd3dae37fba721c7318b8df1838db3";
        libraryHaskellDepends = [
          array base containers directory filepath hslogger HUnit mtl network
          old-locale old-time parsec process random regex-compat time unix
@@ -10559,7 +10579,7 @@ self: {
      mkDerivation {
        pname = "MissingK";
        version = "0.0.0.2";
-       sha256 = "0cynzg5piy14g5j576kf79dh4zqa5pcpwnpfl0fdkyy1rqm50q03";
+       sha256 = "0360502acec1fbd91ca0ee5a7ed92d0a7f025b3a6e9a53647924f878cbfbd633";
        libraryHaskellDepends = [ base glib template-haskell ];
        homepage = "http://www.keera.es/blog/community/";
        description = "Useful types and definitions missing from other libraries";
@@ -10573,7 +10593,7 @@ self: {
      mkDerivation {
        pname = "MissingM";
        version = "0.0.4";
-       sha256 = "19kijf02jq8w3n2fvisb8xrws524sa690lbp9di6499xakkzyqxs";
+       sha256 = "ba63ffe7543d2562624b7751908cd24414cd73474bc7ed841d1c6129809371a6";
        libraryHaskellDepends = [ base ];
        testHaskellDepends = [
          base HUnit QuickCheck test-framework test-framework-hunit
@@ -10588,7 +10608,7 @@ self: {
      mkDerivation {
        pname = "MissingPy";
        version = "0.10.6";
-       sha256 = "0390ap25qj6a37jllsih39q5apgvwdjdw5m7jgfrllkp5bng6yj6";
+       sha256 = "467af3ec2a77529add93a716de64e3fb5d55701a306a4ae519ca485cc455200d";
        libraryHaskellDepends = [ anydbm base MissingH ];
        homepage = "http://github.com/softmechanics/missingpy";
        description = "Haskell interface to Python";
@@ -10601,7 +10621,7 @@ self: {
      mkDerivation {
        pname = "Modulo";
        version = "0.2.0.1";
-       sha256 = "1n90lfrvfr1ni7ninlxbs4wk0m7mibdpi9sy26ifih51nmk8nziq";
+       sha256 = "387e8b66b5a1c0e8a2115ea778db8af5543039d1ab531bed893664b7b3a320d9";
        libraryHaskellDepends = [ base numeric-prelude ];
        description = "Modular arithmetic via Numeric-Prelude";
        license = stdenv.lib.licenses.gpl2;
@@ -10612,7 +10632,7 @@ self: {
      mkDerivation {
        pname = "Moe";
        version = "0.1";
-       sha256 = "1nk767nywssg5p50wd6czcbhi61v5gcncyy3d59a90slzic8n5b3";
+       sha256 = "63158b58fc5483a45269c37b66d92b3b980817fbcc340eca2d4f6beeed3167da";
        isLibrary = true;
        isExecutable = true;
        libraryHaskellDepends = [ base GLUT random ];
@@ -10628,7 +10648,7 @@ self: {
      mkDerivation {
        pname = "MoeDict";
        version = "0.0.3";
-       sha256 = "0sf7qhw3z984mnprgq2jxqsx9z5v2q36hdb84fdn34rgjzrv3z9a";
+       sha256 = "2afdb1f3972f93619b236835680616bbfcd435ee52e097afad04a53f38c4c769";
        libraryHaskellDepends = [
          aeson base bytestring containers text unordered-containers
        ];
@@ -10644,7 +10664,7 @@ self: {
      mkDerivation {
        pname = "MonadCatchIO-mtl";
        version = "0.3.1.0";
-       sha256 = "0qarf73c8zq8dgvxdiwqybpjfy8gba9vf4k0skiwyk5iphilxhhq";
+       sha256 = "18c24e23bcb14ccfe3d46012b7935a0f7927eff298c7d6f76b087fc4c6715961";
        libraryHaskellDepends = [
          base extensible-exceptions MonadCatchIO-transformers
        ];
@@ -10659,7 +10679,7 @@ self: {
      mkDerivation {
        pname = "MonadCatchIO-mtl-foreign";
        version = "0.1";
-       sha256 = "0jfq5v1jigxl9mnnvpqph9ayq840s9nyb5srym04mbicri4gbjan";
+       sha256 = "56c9f548cc2cae4a40f55997e56dd28020ec558217df6d6d4db4bf28c32ed849";
        libraryHaskellDepends = [ base MonadCatchIO-mtl mtl primitive ];
        jailbreak = true;
        description = "Polymorphic combinators for working with foreign functions";
@@ -10674,7 +10694,7 @@ self: {
      mkDerivation {
        pname = "MonadCatchIO-transformers";
        version = "0.3.1.3";
-       sha256 = "1g840h7whsvgyrh4v58mdmsb7hinq785irbz6x9y08r1q8r9r90h";
+       sha256 = "10a49c32c22123e053377fe558d0c136c2b3746d15954d60f66f6bc80f0404bd";
        libraryHaskellDepends = [
          base extensible-exceptions monads-tf transformers
        ];
@@ -10689,7 +10709,7 @@ self: {
      mkDerivation {
        pname = "MonadCatchIO-transformers-foreign";
        version = "0.1";
-       sha256 = "070ifw78z2si3l1hqqvx236spdf61p3bf1qspd54fzq2dm89i1yw";
+       sha256 = "dc8798506d027f474abb1a07b7c60dc6b5abcd107d630c031d518b8f0e77111c";
        libraryHaskellDepends = [
          base MonadCatchIO-transformers primitive transformers
        ];
@@ -10707,7 +10727,7 @@ self: {
      mkDerivation {
        pname = "MonadCompose";
        version = "0.8.3.1";
-       sha256 = "0njvbz2cwc3339h87wxhl5kzb2v1ny5skqvhrsdzp95f1k8chnxa";
+       sha256 = "aa5bc8d00caea4fb9bce70e3a98bb7618bf567a1b0f383601a6330cec45f5b5a";
        libraryHaskellDepends = [
          base data-default ghc-prim mmorph monad-loops monad-products mtl
          parallel random transformers transformers-compat
@@ -10723,7 +10743,7 @@ self: {
      mkDerivation {
        pname = "MonadLab";
        version = "0.0.2";
-       sha256 = "1p8xhxxjhwr93as98pvp1z25ypgj7arka8bw75r0q46948h7nxf7";
+       sha256 = "c7757b2022c9100c72397c2135b33af25d5fc40f775f94b41a2973287b871ddd";
        isLibrary = true;
        isExecutable = true;
        libraryHaskellDepends = [ base parsec template-haskell ];
@@ -10739,7 +10759,7 @@ self: {
      mkDerivation {
        pname = "MonadPrompt";
        version = "1.0.0.5";
-       sha256 = "1nmy7dfzrkd8yfv5i9vlmjq9khnyi76ayvkzgcf783v5hfzcn4mh";
+       sha256 = "b012cbbe83650f741c7b7f6eafcc89dec299b0ac74a758b6f3a8cdfc5d3bbeda";
        libraryHaskellDepends = [ base mtl ];
        description = "MonadPrompt, implementation & examples";
        license = stdenv.lib.licenses.bsd3;
@@ -10752,7 +10772,7 @@ self: {
      mkDerivation {
        pname = "MonadRandom";
        version = "0.4";
-       sha256 = "14vgp2sml9jsras9l0488gy2siamcqf78y3vlr1my4lhhdx3ybyk";
+       sha256 = "d32f3f7a8390125f43a67b78741c6655452dfc4388009ab4ca5a265ab5b86f93";
        libraryHaskellDepends = [
          base mtl random transformers transformers-compat
        ];
@@ -10765,7 +10785,7 @@ self: {
      mkDerivation {
        pname = "MonadRandomLazy";
        version = "0.1";
-       sha256 = "1nsnv47mwka4bsmv7hvsx96s6w6qrzvfsn47fvcfy4fi88b56p2j";
+       sha256 = "525c531642d111efd8768758edf6cfd870a34dea7ac3b3ab5e444d5e0fd956db";
        libraryHaskellDepends = [ base MonadRandom mtl random ];
        description = "Lazy monad for psuedo random-number generation";
        license = stdenv.lib.licenses.bsd3;
@@ -10777,7 +10797,7 @@ self: {
      mkDerivation {
        pname = "MonadStack";
        version = "0.1.0.3";
-       sha256 = "0fsnc17dxmv3qnmz54gw3wy2camgp23ip9jfi543xqks0l8n7gcz";
+       sha256 = "9fbd6311057ae23e48894ea61b87b8af2a263c1ffc91f2abc563d7de4e60563b";
        libraryHaskellDepends = [ base mtl ];
        homepage = "https://github.com/bhurt/MonadStack";
        description = "Generalizing lift to monad stacks";
@@ -10789,7 +10809,7 @@ self: {
      mkDerivation {
        pname = "Monadius";
        version = "0.99";
-       sha256 = "0jq59nnnydllqpvg3h2d1ylz3g58hwi0m08lmw2bv0ajzgn5mc8x";
+       sha256 = "1db15aecfb5281bd04af14810a2287a8bcf1a90f4dc0f1f6c594366fad4d054b";
        isLibrary = false;
        isExecutable = true;
        executableHaskellDepends = [ array base directory GLUT OpenGL ];
@@ -10805,7 +10825,7 @@ self: {
      mkDerivation {
        pname = "Monaris";
        version = "0.1.8";
-       sha256 = "0myghw0w122n1czpaaqmpiyv0nragjkwnja8kb4agrwhcjfk3icb";
+       sha256 = "8bc5319d6490e7a7c89a4849cba77c2a5bb07dbc152b753f0b5688c00187cf57";
        isLibrary = false;
        isExecutable = true;
        executableHaskellDepends = [
@@ -10822,7 +10842,7 @@ self: {
      mkDerivation {
        pname = "Monatron";
        version = "0.3.1";
-       sha256 = "0250xqc5fgl8mg9yb0ykbfmxnyxacqbvi692irgfw89gf9vkh886";
+       sha256 = "06213877722f21ee5e8e2299b81766aa7bdbab5bd383e5d3ab883e5718eea008";
        libraryHaskellDepends = [ base ];
        description = "Monad transformer library with uniform liftings";
        license = stdenv.lib.licenses.bsd3;
@@ -10834,7 +10854,7 @@ self: {
      mkDerivation {
        pname = "Monatron-IO";
        version = "1.0";
-       sha256 = "0svdyfzv4xlwjnc61wwik8a60a5667lhsys49sgry65a1v2csnv0";
+       sha256 = "605bcdc40eaa189f9f4e447b0de931a62860149a91f36098959c76b2bff36d6b";
        libraryHaskellDepends = [ base Monatron transformers ];
        jailbreak = true;
        homepage = "https://github.com/kreuzschlitzschraubenzieher/Monatron-IO";
@@ -10848,7 +10868,7 @@ self: {
      mkDerivation {
        pname = "Monocle";
        version = "0.0.4";
-       sha256 = "1p8s2agsni56h7vlydbhy7qhi0qkwafpcrsfafrlg44gvpwff15y";
+       sha256 = "be04e7f8dd8f9047b3534e67769de2138308f1f170354ff781a644ab9f121add";
        libraryHaskellDepends = [ base containers haskell98 mtl ];
        description = "Symbolic computations in strict monoidal categories with LaTeX output";
        license = stdenv.lib.licenses.bsd3;
@@ -10860,7 +10880,7 @@ self: {
      mkDerivation {
        pname = "MorseCode";
        version = "0.0.5";
-       sha256 = "1dglyak17db7q9nd6s255w2zh8lh192vidyjvgvh53vbybymb20z";
+       sha256 = "1f8855fdf26b8f02f7dbd2b7b8450a9022f8052f4568d36cc267b513a6f2f4b5";
        libraryHaskellDepends = [ base containers split ];
        description = "Morse code";
        license = stdenv.lib.licenses.gpl3;
@@ -10873,7 +10893,7 @@ self: {
      mkDerivation {
        pname = "MuCheck";
        version = "0.3.0.4";
-       sha256 = "183p3fmzz5d67g8wmzgv8c8yyhs0cp7x3xig4cm9s98nhrsm1j0r";
+       sha256 = "19c850758616259d2a232ff6d1cf654043ef1143fbfdcad13ba695ffab1b77a0";
        libraryHaskellDepends = [
          base directory hashable haskell-src-exts hint mtl random syb
          temporary time
@@ -10892,7 +10912,7 @@ self: {
      mkDerivation {
        pname = "MuCheck-HUnit";
        version = "0.3.0.4";
-       sha256 = "05x5sfwlzzis29sps93ypsn53y2vs4cjmxifjqn7wd5lmhaxjbhj";
+       sha256 = "122ed915acb4347e2c962ef62a19d15bf851acbe7e247d75123afe4fb9d3a517";
        isLibrary = true;
        isExecutable = true;
        libraryHaskellDepends = [ base HUnit MuCheck ];
@@ -10907,7 +10927,7 @@ self: {
      mkDerivation {
        pname = "MuCheck-Hspec";
        version = "0.3.0.4";
-       sha256 = "0c8sd6ns8hnhc7577j0y7iqyhf7ld51zmrr3jgpckgpcghycw5mw";
+       sha256 = "bc16ce3c7cecbec9ee9323e7fa4369f438e8713c1ec873ca61d042a4ad691a31";
        isLibrary = true;
        isExecutable = true;
        libraryHaskellDepends = [ base hspec hspec-core MuCheck ];
@@ -10922,7 +10942,7 @@ self: {
      mkDerivation {
        pname = "MuCheck-QuickCheck";
        version = "0.3.0.4";
-       sha256 = "1q242vw70jccfj19jn6wx1fm74mshd60lay9ql4379mgcl2lf6qk";
+       sha256 = "131b470565afa63308c5c92b0a4c83ba92535de8dc589982748c4970f81644e0";
        isLibrary = true;
        isExecutable = true;
        libraryHaskellDepends = [ base MuCheck QuickCheck ];
@@ -10937,7 +10957,7 @@ self: {
      mkDerivation {
        pname = "MuCheck-SmallCheck";
        version = "0.3.0.4";
-       sha256 = "19brgllnbsbbg57jgwgd745iial53ykn7c329x9lq6gd82siavii";
+       sha256 = "316e15b540ed194c534f62b063a71f85aa180b39edf1274f796be965297d79a5";
        isLibrary = true;
        isExecutable = true;
        libraryHaskellDepends = [ base MuCheck smallcheck ];
@@ -10952,7 +10972,7 @@ self: {
      mkDerivation {
        pname = "Munkres";
        version = "0.1";
-       sha256 = "169mgcyls0dsifnbp615r4i3g64ga2vbczsiv4aq17d1nma8sw19";
+       sha256 = "29708d54b5a19d8015d9517fb6b6508f983722c92598bbac8bba014d3d7b3599";
        libraryHaskellDepends = [ array base ];
        description = "Munkres' assignment algorithm (hungarian method)";
        license = stdenv.lib.licenses.bsd3;
@@ -10963,7 +10983,7 @@ self: {
      mkDerivation {
        pname = "Munkres-simple";
        version = "0.1.0.1";
-       sha256 = "0k5v37qrhb8i5hfx9jvkggjmry2jrzw967s17l2x561qmm59c2rb";
+       sha256 = "2b0b964aad3898d2053d411f93f8cf52f85ce57b73cbd41d2c112d98f119bb4c";
        libraryHaskellDepends = [ array base bimap containers Munkres ];
        jailbreak = true;
        description = "Simple and typesafe layer over the Munkres package";
@@ -10979,7 +10999,7 @@ self: {
      mkDerivation {
        pname = "MusicBrainz";
        version = "0.2.4";
-       sha256 = "1f1x3iivxkn5d7w3xyh2q8mpn1mg24c1n6v8dvdsph745xszh8fj";
+       sha256 = "d221f8752fe4c0abdb6e681b1b1811af067b2bc202fa3ef869c5cebe631c3db8";
        libraryHaskellDepends = [
          aeson base bytestring conduit conduit-extra HTTP http-conduit
          http-types monad-control resourcet text time time-locale-compat
@@ -10995,7 +11015,7 @@ self: {
      mkDerivation {
        pname = "MusicBrainz-libdiscid";
        version = "0.5.0.0";
-       sha256 = "15fwpbh8yxv41k73j9q4v5d5c5rh3q2xfp7pc7b5mc3rxipw4pa5";
+       sha256 = "455dc26fec79b05ad661f75cd7051e3017565ad9042739ce0c64778fe0badc95";
        libraryHaskellDepends = [ base containers vector ];
        homepage = "https://github.com/atwupack/MusicBrainz-libdiscid";
        description = "Binding to libdiscid by MusicBrainz";
@@ -11007,7 +11027,7 @@ self: {
      mkDerivation {
        pname = "MyPrimes";
        version = "0.1.0.0";
-       sha256 = "1bwq0fwhkw4i2kjx9xbdfn0y86j9s78kyrw9vlxq7zmv4pddazly";
+       sha256 = "9e7ed5da25bbfe833bdd89673fd1d1491ae481756df5d4e51491f009b90398af";
        isLibrary = true;
        isExecutable = true;
        libraryHaskellDepends = [ base containers ];
@@ -11023,7 +11043,7 @@ self: {
      mkDerivation {
        pname = "NGrams";
        version = "1.1";
-       sha256 = "1niwh0ndkzgd38phx5527i14nb9swvybdjwjwbndkpb21x5j82nc";
+       sha256 = "cc0a244b0f62ddd9ece292cbb6fce63a2d4b423ca2940e2f1aedfdd92c803cda";
        isLibrary = false;
        isExecutable = true;
        executableHaskellDepends = [ base HCL HTTP network regex-compat ];
@@ -11039,7 +11059,7 @@ self: {
      mkDerivation {
        pname = "NTRU";
        version = "1.0.0.0";
-       sha256 = "0n96hxzv5b1zs0xkq5ksh0hp075ca46l8xd7cs2hdnmkmi6rwvha";
+       sha256 = "0a6e9e4dacb3da068566a775440d51ac1c7021807a163c3bd03facb27f872659";
        libraryHaskellDepends = [
          arithmoi base bytestring containers crypto-api polynomial random
          SHA split
@@ -11057,7 +11077,7 @@ self: {
      mkDerivation {
        pname = "NXT";
        version = "0.2.3";
-       sha256 = "1ka1k9dww84rxx8c45dab6f92cb8mx3fy3sskw07p3f4ahv9whi3";
+       sha256 = "23429e3654c48d7b009f5a0fef46af6831919c59aa15c250ef9920ce5b9a41cd";
        isLibrary = true;
        isExecutable = true;
        libraryHaskellDepends = [
@@ -11082,7 +11102,7 @@ self: {
      mkDerivation {
        pname = "NXTDSL";
        version = "0.4";
-       sha256 = "117ngz15j5chnyrhj1da3r4z11vqx5g70wan7zblwr3s6n006485";
+       sha256 = "05110380357a644ed73f5671705ee97887f0491eaa0509b3b7901559c27ff684";
        isLibrary = true;
        isExecutable = true;
        libraryHaskellDepends = [
@@ -11100,7 +11120,7 @@ self: {
      mkDerivation {
        pname = "NanoProlog";
        version = "0.3";
-       sha256 = "0wjjwzzc78sj7nsaq1hgxiwv0pc069mxns425lhmrlxcm0vf8fmn";
+       sha256 = "b63ae436a8acd35c212d8268db6b32805db079ec0f06acb43d52a3c3fee75272";
        isLibrary = true;
        isExecutable = true;
        libraryHaskellDepends = [ base containers ListLike uu-parsinglib ];
@@ -11119,7 +11139,7 @@ self: {
      mkDerivation {
        pname = "NaturalLanguageAlphabets";
        version = "0.0.1.0";
-       sha256 = "0s2dv9vsfy1j3v7n0j35y69sjmsjcps88idd7b3f6fnxbmwms3z2";
+       sha256 = "e20f5d795ddd3ae3c63aad4584f4655257a993f1654860cf1e3278a777da4d68";
        libraryHaskellDepends = [
          array attoparsec base bimaps bytestring deepseq file-embed hashable
          hashtables intern stringable system-filepath text
@@ -11136,7 +11156,7 @@ self: {
      mkDerivation {
        pname = "NaturalSort";
        version = "0.2.1";
-       sha256 = "1xjhmjxp7w0nxvphnfh2phfpg4aqhjyg2f8q99qqavf8cq2k3za9";
+       sha256 = "49fd310566c86d85714a1839f1bc845891771dbc023a0befee16f073bbac50f6";
        isLibrary = true;
        isExecutable = true;
        libraryHaskellDepends = [ base bytestring strict ];
@@ -11153,7 +11173,7 @@ self: {
      mkDerivation {
        pname = "Neks";
        version = "0.5.0.0";
-       sha256 = "083hkcgmrk42pyjm1xz1amdjpmccw0c72axmkk163ar6ir7aznc8";
+       sha256 = "88d9af4e8e26ab61c29cb52b7118e08cd52b5b55e1f750a5bf82cc5c1f9b7020";
        isLibrary = true;
        isExecutable = true;
        libraryHaskellDepends = [
@@ -11173,7 +11193,7 @@ self: {
      mkDerivation {
        pname = "NestedFunctor";
        version = "0.2.0.2";
-       sha256 = "1kmv20haxkqn1cwy9g59nmjpn5x1rng2rrd8y3gwxfdwn8blc735";
+       sha256 = "651c4617b2bcb9cedff0a8e52c9ecda1177b65b5a9bce4390b16cfae2010bbce";
        libraryHaskellDepends = [ base comonad distributive ];
        jailbreak = true;
        homepage = "https://github.com/kwf/NestedFunctor";
@@ -11186,7 +11206,7 @@ self: {
      mkDerivation {
        pname = "NestedSampling";
        version = "0.1.4";
-       sha256 = "1sdlnjnlbk5b04zyhr7574g2ghcivzvkxnm2aak4h9bik00gb1lv";
+       sha256 = "9b86f50098712548a652a2da3ef7df91c1271e39e564e83f01abcc45adb4b4e9";
        libraryHaskellDepends = [ base random vector ];
        homepage = "https://github.com/ijt/haskell_nested_sampling";
        description = "A port of John Skilling's nested sampling C code to Haskell";
@@ -11200,7 +11220,7 @@ self: {
      mkDerivation {
        pname = "NetSNMP";
        version = "0.3.2.0";
-       sha256 = "1z3d4qmwzg3hkx78z4fbdsdh6vxnw95fkvfxgzng4bq10y6d2bb8";
+       sha256 = "682dd18c07012ff2ec7fddede94ae2b66f039b6ecb918f4e9f70bccf2b266dfc";
        libraryHaskellDepends = [ base bytestring utf8-string ];
        librarySystemDepends = [ net_snmp ];
        testHaskellDepends = [ base bytestring HUnit process utf8-string ];
@@ -11218,7 +11238,7 @@ self: {
      mkDerivation {
        pname = "Network-NineP";
        version = "0.4.0";
-       sha256 = "1h6p1p16wvsi6pjpz2xdvbljd394bzpqqfiah7aq9d7f7zh7hzid";
+       sha256 = "2d7e78e03feeb484d5812a3a8cef5f248d26e9daad8b7fe535516f6ec20dd7c0";
        isLibrary = true;
        isExecutable = true;
        libraryHaskellDepends = [
@@ -11235,7 +11255,7 @@ self: {
      mkDerivation {
        pname = "NewBinary";
        version = "0.2.1";
-       sha256 = "0cp71hkx8cccx7jxf5qw1bxdylcc56v68mvjp0dn9hkh1idxplzq";
+       sha256 = "f8d3db5b0c70c2641bb8725764b6298c51dffa0a1c17d7e5e98c31d4270ce732";
        libraryHaskellDepends = [ array base integer ];
        jailbreak = true;
        description = "A binary I/O library";
@@ -11248,7 +11268,7 @@ self: {
      mkDerivation {
        pname = "NineP";
        version = "0.0.2.1";
-       sha256 = "1k6qdp4zmqjl2f6cqy1zzzl6ncb2m9r0qgh4c24i2h5kkxmm3cab";
+       sha256 = "4bb1516b9fb340118960043e0c72aa62316be8ff3f78cc8c1354e2fac96dd8cc";
        libraryHaskellDepends = [ base binary bytestring ];
        homepage = "http://9ph.googlecode.com";
        description = "9P2000 in pure Haskell";
@@ -11262,7 +11282,7 @@ self: {
      mkDerivation {
        pname = "Ninjas";
        version = "0.1.0.0";
-       sha256 = "0wz80cv7m7m4q6y6rd07y422b97hyhnb9yl6bj68pi1nxmjzcjhm";
+       sha256 = "154af665ed36c48b8c5c86fab42cf4f0a42504f107b46cbcc1a49e7a3603e873";
        isLibrary = false;
        isExecutable = true;
        executableHaskellDepends = [
@@ -11284,7 +11304,7 @@ self: {
      mkDerivation {
        pname = "NoSlow";
        version = "0.2";
-       sha256 = "1pr1v8xxnhd7yxbhjqhlkwlsfzbk425bmxn99d80w8p4biag104x";
+       sha256 = "9d80f0545ce4220e504bc9f6ba8a20737da7299f14620957f7a741db3bda21df";
        isLibrary = false;
        isExecutable = true;
        executableHaskellDepends = [
@@ -11303,7 +11323,7 @@ self: {
      mkDerivation {
        pname = "NoTrace";
        version = "0.2.0.1";
-       sha256 = "053w0j90sf16by9pqllgjxy6r57vzlq33fgwz4ywjn6bypw6009d";
+       sha256 = "2d0160f8f5cb58c93df9fcb93130fdfb946c7c978f527c935f26380d92047c14";
        libraryHaskellDepends = [ base ];
        testHaskellDepends = [ base ];
        jailbreak = true;
@@ -11317,7 +11337,7 @@ self: {
      mkDerivation {
        pname = "Noise";
        version = "1.0.6";
-       sha256 = "0sjyq8nilqhmlhbagi1ms2zh7fyhzci9w5hj3dyxpd2ccq1bbvyq";
+       sha256 = "d8efb502664cb4db7d1b12169e22fbd0bb03bfd035c4a716a415621a2dc25e6a";
        libraryHaskellDepends = [ array base data-default vector ];
        description = "A Haskell coherent noise generator based on libnoise";
        license = stdenv.lib.licenses.bsd3;
@@ -11331,7 +11351,7 @@ self: {
      mkDerivation {
        pname = "Nomyx";
        version = "0.7.6";
-       sha256 = "1zbrirplcgff9z75lmamh0i5749m22kvnwcr3s51wajnvh982qi3";
+       sha256 = "23628112dc562a1e8a1e9971bba710359153228055555ace4fce3d466f8e79fd";
        isLibrary = false;
        isExecutable = true;
        executableHaskellDepends = [
@@ -11357,7 +11377,7 @@ self: {
      mkDerivation {
        pname = "Nomyx-Core";
        version = "0.7.6";
-       sha256 = "16s60gap32kjs62zxjddppxyg9jhamzgm4d41mfg3vviadlacdrq";
+       sha256 = "3837a6685371eff15c0da491fa7e5550a6e7fbbdadc9fe85d1728a71d503469b";
        libraryHaskellDepends = [
          acid-state aeson base blaze-html blaze-markup bytestring data-lens
          data-lens-fd data-lens-template DebugTraceHelpers deepseq directory
@@ -11381,7 +11401,7 @@ self: {
      mkDerivation {
        pname = "Nomyx-Language";
        version = "0.7.6";
-       sha256 = "0na9nm6qnayip2lx3nd3if4c1iyp7zs89jp2dgb7zkmbiwvax3l9";
+       sha256 = "898eae368fabce7fd66be2ca84f43fd7c7c0888ba3d9d1a9b8d12b8b4db54959";
        libraryHaskellDepends = [
          base Boolean containers data-lens data-lens-fd data-lens-template
          DebugTraceHelpers ghc mtl old-locale random safe time
@@ -11401,7 +11421,7 @@ self: {
      mkDerivation {
        pname = "Nomyx-Rules";
        version = "0.1.0";
-       sha256 = "16kzpdvn57sdmpqkwswgixm6pnyi01vj44yvzczn9sy4azwd10q5";
+       sha256 = "0583d0f857c4eb643ffbdb13227700d1db6b6a8f8f6b3ef1ad4d9f6277bb7f9a";
        libraryHaskellDepends = [
          base containers ghc hint-server hslogger mtl old-locale safe stm
          time time-recurrence
@@ -11422,7 +11442,7 @@ self: {
      mkDerivation {
        pname = "Nomyx-Web";
        version = "0.7.6";
-       sha256 = "193v967bzhs0linqvh93w7viwdrlmsbdpnr8asigqhp5905zdjb7";
+       sha256 = "67c9f60b48e542fca25628dbdb96ae34371ef7e123c18d6da440c3bf8e497ba4";
        libraryHaskellDepends = [
          base blaze-html blaze-markup bytestring data-lens data-lens-fd fb
          filepath happstack-authenticate happstack-server hscolour mtl
@@ -11442,7 +11462,7 @@ self: {
      mkDerivation {
        pname = "NonEmpty";
        version = "0.1";
-       sha256 = "0nycv791c6b5bcaz5y9wm3wxn1p930p163qs1rpdiix04fnaxgxl";
+       sha256 = "b4bfaeac23a0c7d86e0e1a0f132e18e906dbf9a83cf9f2155b651916d2d9cc5b";
        libraryHaskellDepends = [ base ];
        description = "Library providing a non-empty list datatype, and total functions operating on it";
        license = stdenv.lib.licenses.bsd3;
@@ -11455,7 +11475,7 @@ self: {
      mkDerivation {
        pname = "NonEmptyList";
        version = "0.0.9";
-       sha256 = "09515y7ax4vndsj1828b6xxnnkml4vg9x29rn3lrw3rc65fi11x2";
+       sha256 = "a287105d312c0f9ee9b039899ede26b44e6b7b370b0914a46e7693ae8e2fa124";
        libraryHaskellDepends = [
          base category-extras QuickCheck Semigroup test-framework
          test-framework-hunit test-framework-quickcheck2
@@ -11471,7 +11491,7 @@ self: {
      mkDerivation {
        pname = "NumInstances";
        version = "1.4";
-       sha256 = "0ycnwn09izajv330l7a31mc0alifqmxjsn9qmfswwnbg6i4jmnyb";
+       sha256 = "cbdb2a49346f59ceb5ab38592d7bc52e5205580d431d0ac6d852fd9880e59679";
        libraryHaskellDepends = [ base ];
        homepage = "https://github.com/conal/NumInstances";
        description = "Instances of numeric classes for functions and tuples";
@@ -11483,7 +11503,7 @@ self: {
      mkDerivation {
        pname = "NumLazyByteString";
        version = "0.0.0.1";
-       sha256 = "17ca34hxaz9xk3ykkzp14n7wb31aiza12859k3rmvwhnq4j89jqs";
+       sha256 = "1acb8424c116f25df398a92011d48f2a8cc58f25e1fe39fd983d7dd521198a9d";
        libraryHaskellDepends = [ base binary bytestring ];
        description = "Num, Enum, Eq, Integral, Ord, Real, and Show instances for Lazy ByteStrings";
        license = stdenv.lib.licenses.bsd3;
@@ -11494,7 +11514,7 @@ self: {
      mkDerivation {
        pname = "NumberSieves";
        version = "0.1.2";
-       sha256 = "1w8y46ivli37rlhkdrnw13qv6f0m13a88w0qkfw949b09vdp2nw2";
+       sha256 = "825b71db4e602592b89b187084d4081538b3f108dce63621cd6744baa3211ef1";
        libraryHaskellDepends = [ array base ];
        homepage = "http://patch-tag.com/r/lpsmith/NumberSieves";
        description = "Number Theoretic Sieves: primes, factorization, and Euler's Totient";
@@ -11507,7 +11527,7 @@ self: {
      mkDerivation {
        pname = "Numbers";
        version = "0.2.1";
-       sha256 = "1z1v396lar6b0lyis3k5gn5kn17ndggm8j7qxnhirlpgm831fgg7";
+       sha256 = "e73d1706aaefd21ca1edf84854df6bf6043b8b7d650e1d3d05cb64454d1a3bfc";
        libraryHaskellDepends = [ base random ];
        homepage = "http://page.mi.fu-berlin.de/aneumann/numbers/index.html";
        description = "An assortment of number theoretic functions";
@@ -11521,7 +11541,7 @@ self: {
      mkDerivation {
        pname = "Nussinov78";
        version = "0.1.0.0";
-       sha256 = "1j9qmin7fqwfy69f7wi1is1nawhh46phda6na20am7r8cjzdnjsh";
+       sha256 = "504bdbbe64289faa8050d6a806af21107265838e21f2e392f18e63776cac38c9";
        isLibrary = true;
        isExecutable = true;
        libraryHaskellDepends = [
@@ -11539,7 +11559,7 @@ self: {
      mkDerivation {
        pname = "Nutri";
        version = "0.1";
-       sha256 = "1m7qx5zydz5jpk6a55k7rzchlwmkd91gsiqmn26qqn50ab3di35j";
+       sha256 = "b28cd8c652a0588c8db01547fd426ab3720ad9cf6796a2ccbcb2fce67fe9f8d4";
        libraryHaskellDepends = [ base ];
        jailbreak = true;
        homepage = "https://github.com/frosch03/Nutri";
@@ -11552,7 +11572,7 @@ self: {
      mkDerivation {
        pname = "OGL";
        version = "0.0.3";
-       sha256 = "1w8lpi2r315b4ry234gi4rq09j92zvhr9ibxwsig6544cbb5g8qm";
+       sha256 = "15a357d6628414f3a2e67dc594e1fe22c9047026f191217c26ab849145bc14f1";
        libraryHaskellDepends = [ base mtl ];
        homepage = "http://haskell.org/haskellwiki/OGL";
        description = "A context aware binding for the OpenGL graphics system";
@@ -11567,7 +11587,7 @@ self: {
      mkDerivation {
        pname = "OSM";
        version = "0.6.4";
-       sha256 = "1m606r0lc0hsniqn7krm2hpvhj7y6sq4qbjjj4g8n4hap6v4syr9";
+       sha256 = "297b4db6b90a128b1e91522e4cb036fe48b82f1435cf6371b41a02464136c0d4";
        libraryHaskellDepends = [
          base comonad-transformers containers data-lens hxt newtype
        ];
@@ -11582,7 +11602,7 @@ self: {
      mkDerivation {
        pname = "OTP";
        version = "0.0.0.1";
-       sha256 = "0vcxyfk1vx30cfngq5cv3lc34x0sxsirykhbi4ygw5pvd9ylzadb";
+       sha256 = "aba94f7d6afb16fe3c890b4e9fa3ee1a7432181d9b15fcac6360f41da6f39d6d";
        libraryHaskellDepends = [ base Crypto time ];
        testHaskellDepends = [ base Crypto time ];
        homepage = "https://github.com/matshch/OTP";
@@ -11595,7 +11615,7 @@ self: {
      mkDerivation {
        pname = "Object";
        version = "1.0";
-       sha256 = "05lrqq4008vnfs2x8kxlyrgdvxmzk04rqvn0w65b691bp3vwnbf9";
+       sha256 = "c92dcbf7b82b24b38ae1c06e9c0998bff6dd5ef6b44fd4857676230008c69916";
        libraryHaskellDepends = [ base containers ghc template-haskell ];
        homepage = "https://github.com/yokto/object";
        description = "Object oriented programming for haskell using multiparameter typeclasses";
@@ -11610,7 +11630,7 @@ self: {
      mkDerivation {
        pname = "ObjectIO";
        version = "1.0.1.1";
-       sha256 = "1f8ac7dk1ls6xla3w0wy2qr164kv67k5ilj7niakfr9x74mpp6jy";
+       sha256 = "5e9a7b2b393d653755b447d258e6317b121332169e033e14ed46d330db610ab9";
        librarySystemDepends = [
          comctl32 comdlg32 gdi32 kernel32 ole32 shell32 user32 winmm
          winspool
@@ -11626,7 +11646,7 @@ self: {
      mkDerivation {
        pname = "ObjectName";
        version = "1.1.0.0";
-       sha256 = "0kh5fb9ykag6rfsm3f0bx3w323s18w2cyry34w5xgli5ncqimadg";
+       sha256 = "afa91a31b325d2d70b27c367cf0447410f31f8e80bb851b5cbe6a9e9d372054e";
        libraryHaskellDepends = [ base transformers ];
        homepage = "https://github.com/svenpanne/ObjectName";
        description = "Explicitly handled object names";
@@ -11641,7 +11661,7 @@ self: {
      mkDerivation {
        pname = "Obsidian";
        version = "0.1.0.0";
-       sha256 = "14dbaj54i4li4hbc2bhl19ma9vgs97mfz8xfwvlndldb2kac4x01";
+       sha256 = "0174c2d414abd166e9e6aea3efea49faeda46a0a142ec116249192488a54ab91";
        libraryHaskellDepends = [
          base containers cuda language-c-quote mainland-pretty mtl
          mwc-random process rdtsc text value-supply vector
@@ -11657,7 +11677,7 @@ self: {
      mkDerivation {
        pname = "Octree";
        version = "0.5.4.2";
-       sha256 = "0q07jylv5ggvnp32h3b63pk1rcvvxh7bzi3dyx4ga2s0zwfaq1q2";
+       sha256 = "0207ac1cff400bf548f76dc4bf0eec7bb31ce61d660d28c6b5fbbdb2a9970760";
        libraryHaskellDepends = [ AC-Vector base QuickCheck ];
        testHaskellDepends = [ AC-Vector base markdown-unlit QuickCheck ];
        homepage = "https://github.com/mgajda/octree";
@@ -11670,7 +11690,7 @@ self: {
      mkDerivation {
        pname = "OddWord";
        version = "1.0.0.2";
-       sha256 = "1c4xbfkikyn1jh3qz0ycxzmx0zqfg5gliafb764942dvd851hljv";
+       sha256 = "5b52180a6abb09928839cba9485f790e7fd0ebefcc838f0794c1fa19a75b9db0";
        libraryHaskellDepends = [ base ];
        testHaskellDepends = [ base QuickCheck ];
        jailbreak = true;
@@ -11684,7 +11704,7 @@ self: {
      mkDerivation {
        pname = "Omega";
        version = "1.0.3";
-       sha256 = "05dax2r7rrdbsvxszxn13xcf24zq87xq8scxzvl2ccr2y29n0f5j";
+       sha256 = "b2386093f0223326e8fe9d6984fb41f813e1581fc1f6affbd6abe57cb2e8aa15";
        libraryHaskellDepends = [ base containers ];
        testHaskellDepends = [ base containers HUnit ];
        description = "Integer sets and relations using Presburger arithmetic";
@@ -11697,7 +11717,7 @@ self: {
      mkDerivation {
        pname = "OneTuple";
        version = "0.2.1";
-       sha256 = "1x52b68zh3k9lnps5s87kzan7dzvqp6mrwgayjq15w9dv6v78vsb";
+       sha256 = "4b6f74b6d92df112b0f4eaf15ccdc5fbb763d59f07e9a2afa5690ef89159a2f4";
        libraryHaskellDepends = [ base ];
        description = "Singleton Tuple";
        license = stdenv.lib.licenses.bsd3;
@@ -11710,7 +11730,7 @@ self: {
      mkDerivation {
        pname = "OpenAFP";
        version = "1.4.2";
-       sha256 = "0x8yrxyfwgzgp7158nrk4y3wzpfm9bnww0nfbbi9hajiqfd8ymc0";
+       sha256 = "80558f9ac3512a98e25ace02ceed4ad5ddcf8727335b54c2b9ef3fee7ccf1e75";
        libraryHaskellDepends = [
          array base binary bytestring containers directory hashable
          hashtables mtl process regex-compat
@@ -11729,7 +11749,7 @@ self: {
      mkDerivation {
        pname = "OpenAFP-Utils";
        version = "1.4.1.3";
-       sha256 = "160qlcjh0pgslql9f4zv2asw8kb9kl7wd6dk5958dv0n9p96pay0";
+       sha256 = "c0ab6bd24d16ec864a2ab399c60f9d694dc4b512fb139728a6fa5d0025a31898";
        isLibrary = false;
        isExecutable = true;
        executableHaskellDepends = [
@@ -11749,7 +11769,7 @@ self: {
      mkDerivation {
        pname = "OpenAL";
        version = "1.7.0.0";
-       sha256 = "111r78zx39nyfnpq2pmy440bi4ymr6i2difwfaislvmjq43plhjw";
+       sha256 = "5c427a07c1b26eaaa372dcc526a2c9d593b80021be5e81af75dea6d13f3a3984";
        libraryHaskellDepends = [
          base ObjectName OpenGL StateVar transformers
        ];
@@ -11764,7 +11784,7 @@ self: {
      mkDerivation {
        pname = "OpenCL";
        version = "1.0.3.4";
-       sha256 = "04cqddhn4b5m0rj2f6i3gr62yhlfgffmkplb4599sd3qbgx0g27x";
+       sha256 = "fd8807fa5b78349d52218bde599d7b8e422f4c7e231a276406b52c62616b9811";
        libraryHaskellDepends = [ base bytestring mtl ];
        librarySystemDepends = [ OpenCL ];
        libraryToolDepends = [ c2hs ];
@@ -11781,7 +11801,7 @@ self: {
      mkDerivation {
        pname = "OpenCLRaw";
        version = "1.0.1001";
-       sha256 = "1a9nlrmxp3jwc3hbj79xm35aypfby04qy01fk4vyrp19diiinl07";
+       sha256 = "07501b636c29dcec37992e008f09f0cb5dafcaa83d1db9e0605c8edb6ba636a9";
        libraryHaskellDepends = [ base bytestring mtl ];
        jailbreak = true;
        homepage = "http://vis.renci.org/jeff/opencl";
@@ -11795,7 +11815,7 @@ self: {
      mkDerivation {
        pname = "OpenCLWrappers";
        version = "0.1.0.3";
-       sha256 = "0xlm26jksp4jf1dhkpg4708r1ak5mjdc5x5fjp4fhizmzlk3348s";
+       sha256 = "1a913126fdf547e8c895aef4c29aac65aa901138e4dd095b70925c3da5119576";
        libraryHaskellDepends = [ base bytestring mtl ];
        jailbreak = true;
        homepage = "https://github.com/jkarlson/OpenCLWrappers";
@@ -11810,7 +11830,7 @@ self: {
      mkDerivation {
        pname = "OpenGL";
        version = "2.12.0.1";
-       sha256 = "1mcfb167jl75qc2hgylh83vf2jqizvyvkvhhb72adi2crc3zqz4b";
+       sha256 = "8b7cfc07cb4cc4a6c45910eeb9fdfe114be1f64090fa0705c3e550794c588ed5";
        libraryHaskellDepends = [
          base bytestring GLURaw ObjectName OpenGLRaw StateVar text
          transformers
@@ -11825,7 +11845,7 @@ self: {
      mkDerivation {
        pname = "OpenGLCheck";
        version = "1.0";
-       sha256 = "0zjgwd9h6jncvp7x4nn049878jagcajsc63ch5i1ynndnrr1cfar";
+       sha256 = "59391672b6cd5a1f62816c18a6a5624f49745022c05ad2cfddcc4a0353e34f7e";
        libraryHaskellDepends = [
          base checkers haskell98 OpenGL QuickCheck
        ];
@@ -11839,7 +11859,7 @@ self: {
      mkDerivation {
        pname = "OpenGLRaw";
        version = "2.5.1.0";
-       sha256 = "1kfq24mxg922ml3kkmym2qfpc56jbmrfbiix4rc2cxlwv05i191k";
+       sha256 = "33a4100bd89c762658263dc6e5725dd214761d16d5d73907ad42a4d72b11d8cd";
        libraryHaskellDepends = [ base transformers ];
        librarySystemDepends = [ mesa ];
        homepage = "http://www.haskell.org/haskellwiki/Opengl";
@@ -11852,7 +11872,7 @@ self: {
      mkDerivation {
        pname = "OpenGLRaw21";
        version = "2.0.0.2";
-       sha256 = "1kfgwwjnwl5dzwf8bpxcs4q241zap29pjhh4ih5k2cdrnbbn1bz1";
+       sha256 = "e1af60d7b2b931310b8c04427993b8ea072230d1acdf851cffad506e25e7cfcd";
        libraryHaskellDepends = [ OpenGLRaw ];
        description = "The intersection of OpenGL 2.1 and OpenGL 3.1 Core";
        license = "unknown";
@@ -11865,7 +11885,7 @@ self: {
      mkDerivation {
        pname = "OpenSCAD";
        version = "0.3.0.2";
-       sha256 = "04b7n6905qvvz8az8zhsjjg8jcf71y5yby7svy2mqzavq2azjm8x";
+       sha256 = "1d55f995c05b7d5c85dffaf8e58b0fc731899e941a7ef415fa7be30292b16711";
        libraryHaskellDepends = [
          base colour containers filepath semigroups
        ];
@@ -11884,7 +11904,7 @@ self: {
      mkDerivation {
        pname = "OpenVG";
        version = "0.7.0";
-       sha256 = "0ad96lbwcwl7vvk5vx1mmb0wj28c541jwd9nsm7l5na9qdxfhzvj";
+       sha256 = "727fe87ac349d9424fd536352e03290c09c9c1aa35f45de6de8772c61735a929";
        libraryHaskellDepends = [ base GLUT OpenGL OpenGLRaw OpenVGRaw ];
        homepage = "http://code.google.com/p/copperbox/";
        description = "OpenVG (ShivaVG-0.2.1) binding";
@@ -11897,7 +11917,7 @@ self: {
      mkDerivation {
        pname = "OpenVGRaw";
        version = "0.4.0";
-       sha256 = "1fdg5b8f2x36x6gmdkazkmhqgknagd0kzr70hydygsmqbf2im5x2";
+       sha256 = "a2971a855bb8eae79b87e0e43f417bcace87619d5fcd569fe96674e1d02aafb9";
        libraryHaskellDepends = [ base OpenGLRaw ];
        jailbreak = true;
        homepage = "http://code.google.com/p/copperbox/";
@@ -11911,7 +11931,7 @@ self: {
      mkDerivation {
        pname = "Operads";
        version = "1.0";
-       sha256 = "1b880lrzdxww3j19zspnj49ifsn89n0ac1h5xf7nn83847k8q2qk";
+       sha256 = "130b8ce62168206b8feb0506a6804dc86a171391f6ea9f821c9cf7f6330508ad";
        libraryHaskellDepends = [ array base containers mtl ];
        jailbreak = true;
        homepage = "http://math.stanford.edu/~mik/operads";
@@ -11925,7 +11945,7 @@ self: {
      mkDerivation {
        pname = "OptDir";
        version = "0.0.3";
-       sha256 = "1bb5s57d3wyr9rd275jl0sk85yisl1dpbz042yg7pksv5l0xal0q";
+       sha256 = "1850d5012d5bcf7b9e1704fc755ba03afa82a6065496235a4ed9f3d14ed165ad";
        libraryHaskellDepends = [ base hashable syb ];
        description = "The OptDir type for representing optimization directions";
        license = stdenv.lib.licenses.bsd3;
@@ -11938,7 +11958,7 @@ self: {
      mkDerivation {
        pname = "OrPatterns";
        version = "0.1";
-       sha256 = "0fkg2bnk7gh8lzf8i0bffj6qbbpq15sf8yw88rqpzghsz7xrr111";
+       sha256 = "21849cfbf91abe7f7146887be47409f8ae858d746e8188dca708be33ed126f3a";
        libraryHaskellDepends = [
          base containers haskell-src-exts haskell-src-meta mtl split syb
          template-haskell
@@ -11955,7 +11975,7 @@ self: {
      mkDerivation {
        pname = "OrchestrateDB";
        version = "1.0.0.3";
-       sha256 = "0d12jbdgpfkzax5c8djab6n611hcwi1bkphwmn5qmny43fb3wsaz";
+       sha256 = "5f693e961bc4db8a8bad1cdeb942e40c8660ac594a36c44a577fbafbda922234";
        libraryHaskellDepends = [
          aeson base bytestring HTTP http-conduit http-types lifted-base
        ];
@@ -11977,7 +11997,7 @@ self: {
      mkDerivation {
        pname = "OrderedBits";
        version = "0.0.0.2";
-       sha256 = "10scfjvng05vsx4clvzkfq128vf1qwwvc0zikkzx4b96pjxf80i2";
+       sha256 = "2202e4babc262dd2ff9cf103b639c7c16d240276f36fca48d7bb8067b7744c83";
        libraryHaskellDepends = [
          base bits primitive QuickCheck vector vector-algorithms
        ];
@@ -11995,7 +12015,7 @@ self: {
      mkDerivation {
        pname = "Ordinals";
        version = "0.0.0.2";
-       sha256 = "04xk74rl2d6vp1kn197hsbkkwdvwvqpjqg3kgkpkl2i0r90y8lsi";
+       sha256 = "5153e441ca200a3aef7c733c2c2fde7c373ee7d2f0a46067b8db34413339b313";
        libraryHaskellDepends = [ base ];
        homepage = "http://patch-tag.com/r/kyagrd/Ordinals/";
        description = "Ordinal arithmetic";
@@ -12007,7 +12027,7 @@ self: {
      mkDerivation {
        pname = "PArrows";
        version = "0.1.1";
-       sha256 = "08mkq72zv9ywp002vwjk7gl6pq6915zdd06sp4ap935aqdjrhn0p";
+       sha256 = "17589865c3aa8c7415b9da80d67e09c9e06be83b53f22d00b8dca7fdc5c1b322";
        libraryHaskellDepends = [ base containers ghc-prim mtl ];
        homepage = "http://www.cs.helsinki.fi/u/ekarttun/PArrows/";
        description = "Arrow parser combinators similar to Parsec";
@@ -12019,7 +12039,7 @@ self: {
      mkDerivation {
        pname = "PBKDF2";
        version = "0.3.1.5";
-       sha256 = "0ljacj31pmcwk4lk24p37761sb60ncwjnjbqhnfrgdjqnyj2bd62";
+       sha256 = "c2b425a4b758b6979d8578492b39b3c02c1dcc39e3123129999cd51b86644a52";
        revision = "1";
        editedCabalFile = "6e8829aa00d16484705a23417f548b237aa1bd152c864a7cfa6948996584db3e";
        libraryHaskellDepends = [ base binary bytestring Crypto random ];
@@ -12032,7 +12052,7 @@ self: {
      mkDerivation {
        pname = "PCLT";
        version = "0.1";
-       sha256 = "0k5abpdz066dsszkj39fd03slb279ddj4i8clnq4gafpa90xbg9q";
+       sha256 = "38bdd54152d7a947b0a50c45225b4b472caa07682e0d39bfd6cd18f0db5daa4c";
        libraryHaskellDepends = [
          base bytestring containers mtl utf8-string
        ];
@@ -12049,7 +12069,7 @@ self: {
      mkDerivation {
        pname = "PCLT-DB";
        version = "0.1.1";
-       sha256 = "0nb5mijpkbllrs9034d3a24drd95lvrhlx60ahcd73kmagh9rfqf";
+       sha256 = "0ebb9ce053758ed31854c0740af3a625b5dc8850a3910192ce94ae7965ac6559";
        libraryHaskellDepends = [
          base bytestring containers convertible HDBC HDBC-postgresql mtl
          PCLT
@@ -12065,7 +12085,7 @@ self: {
      mkDerivation {
        pname = "PDBtools";
        version = "0.0.3";
-       sha256 = "1i5hixmywy63pnh15zl7npfiwc7dvlnz6izjxg08cnvn8jyi026q";
+       sha256 = "d80810bd44765b86c0ebf247f32ddded301eddb587fe12a0bdc378ee6b8fb0c4";
        isLibrary = true;
        isExecutable = true;
        libraryHaskellDepends = [ base bytestring containers ];
@@ -12079,7 +12099,7 @@ self: {
      mkDerivation {
        pname = "PSQueue";
        version = "1.1";
-       sha256 = "1k291bh8j5vpcrn6vycww2blwg7jxx9yrfmrqdanz48gs4d8gq58";
+       sha256 = "a8e0871ad10f916f55c3b9baec53eff23c4e97e09cf96d6c66771789e00a49cc";
        libraryHaskellDepends = [ base ];
        description = "Priority Search Queue";
        license = stdenv.lib.licenses.bsd3;
@@ -12091,7 +12111,7 @@ self: {
      mkDerivation {
        pname = "PTQ";
        version = "0.0.7";
-       sha256 = "0pfd5y8plxicdchkbij0nqj6zwxw3fcy5cz1ji5bky9g3bmz9mhm";
+       sha256 = "15d6f4eb1a2ff9b94a94e1b3e2991bbcf36f24b640c635216b2c767a912fcd5d";
        isLibrary = false;
        isExecutable = true;
        executableHaskellDepends = [
@@ -12111,7 +12131,7 @@ self: {
      mkDerivation {
        pname = "PageIO";
        version = "0.0.3";
-       sha256 = "0pnnhwmlhjvpb3g94p2asbhy9arvlvcbch11m0hmy7w9m3zj9wjk";
+       sha256 = "53f224ffa8891f5f21a82140b6d8a63babe4e1d24a5c92de58774b482b87d65e";
        isLibrary = true;
        isExecutable = true;
        libraryHaskellDepends = [
@@ -12137,7 +12157,7 @@ self: {
      mkDerivation {
        pname = "Paillier";
        version = "0.1.0.3";
-       sha256 = "0jcb72shia5p0lpnr3qz57jlzjvnwh4642zwys5d3rg0rwnxigz2";
+       sha256 = "e2bfd82dcfe0e5d18af6fc0b6208e476cb4fe5291f8f6c2f05b7a808b5388b49";
        libraryHaskellDepends = [ base crypto-numbers crypto-random ];
        testHaskellDepends = [
          base crypto-numbers crypto-random HUnit QuickCheck test-framework
@@ -12155,7 +12175,7 @@ self: {
      mkDerivation {
        pname = "PandocAgda";
        version = "2.3.3.0.2";
-       sha256 = "1g39mxrfii8vm40cbb7vdfrx2rx9gm4s1xhp3zjkiyi7f979cbk0";
+       sha256 = "602e964e7227fa38e51f17f6a0497da967d1b36bfbacc500a91bc5e872af69bc";
        isLibrary = true;
        isExecutable = true;
        libraryHaskellDepends = [
@@ -12179,7 +12199,7 @@ self: {
      mkDerivation {
        pname = "Paraiso";
        version = "0.3.1.3";
-       sha256 = "177sinj5il7azsajf9fl65lml7pq792lnvwb07vln5my250ibwi9";
+       sha256 = "29f2154111be164bf7018b6f4b453af81e5a6931d4252795feead058a48dfa9c";
        libraryHaskellDepends = [
          array base containers control-monad-failure directory fgl filepath
          mtl numeric-prelude random text typelevel-tensor vector
@@ -12204,7 +12224,7 @@ self: {
      mkDerivation {
        pname = "Parry";
        version = "0.1.0.0";
-       sha256 = "0jy0pya7ahy0nzw1yizi1ll7q5kv4jxgn3n56qgcwv25rh374n4s";
+       sha256 = "9a587206cc456cce1e36c50efbba247b167c280df1471ff8b7c0437594bfc04b";
        libraryHaskellDepends = [
          base binary bytestring containers directory ghc-prim network
          old-locale process random RSA SafeSemaphore time unix
@@ -12220,7 +12240,7 @@ self: {
      mkDerivation {
        pname = "ParsecTools";
        version = "0.0.2.0";
-       sha256 = "11vshnbxfl8p38aix4h2b0vms8j58agwxbmhd9pkxai764sl6j7g";
+       sha256 = "ef4843353127aa3e6f6ab0aece9f4245225d375802921e151a1751d797857a87";
        libraryHaskellDepends = [ base parsec ];
        description = "Parsec combinators for more complex objects";
        license = stdenv.lib.licenses.gpl3;
@@ -12231,7 +12251,7 @@ self: {
      mkDerivation {
        pname = "ParserFunction";
        version = "0.1.0";
-       sha256 = "0l0j1mdycqsb5d32l7h0giwrj5yj54523gdn0bvim2vz67qrbxrq";
+       sha256 = "38f795f1317f8b1af702b6bd210a29d21799797c001e2a462b4b63e65b0d1250";
        libraryHaskellDepends = [ base containers parsec ];
        description = "Parse and evaluate mathematical expressions";
        license = stdenv.lib.licenses.bsd3;
@@ -12242,7 +12262,7 @@ self: {
      mkDerivation {
        pname = "PartialTypeSignatures";
        version = "0.1.0.1";
-       sha256 = "04c01bcfrb79av2j9bivlwanmycasn7gjnc9gb5jm6gkwyvgv0h3";
+       sha256 = "0382fdb6e7f3992acb7a8959f98ed58af96a15a73bae24c556e9acecd80a8011";
        libraryHaskellDepends = [ base containers syb template-haskell ];
        homepage = "http://code.haskell.org/~aavogt/PartialTypeSignatures";
        description = "emulate partial type signatures with template haskell";
@@ -12254,7 +12274,7 @@ self: {
      mkDerivation {
        pname = "PasswordGenerator";
        version = "0.1.0.0";
-       sha256 = "12lxylmpi2f1ahy6w1n7jmwn9kay4hajgr95xbnqqdzv4dw6whzw";
+       sha256 = "fc436e7823fb378cedea25e52715245ecd647995c7066e3c54c189782bf59d8a";
        libraryHaskellDepends = [ base QuickCheck ];
        jailbreak = true;
        homepage = "https://github.com/VictorDenisov/PasswordGenerator";
@@ -12267,7 +12287,7 @@ self: {
      mkDerivation {
        pname = "PastePipe";
        version = "1.8";
-       sha256 = "10gf9xkys704k89i9lajqcwqsihfxs314vjy35shhwgga5rjnslz";
+       sha256 = "9f6a2b7351ef710875195e6e1286ee0e468d39c352d114139a041ced674fee81";
        isLibrary = true;
        isExecutable = true;
        libraryHaskellDepends = [ base cmdargs HTTP network network-uri ];
@@ -12282,7 +12302,7 @@ self: {
      mkDerivation {
        pname = "Pathfinder";
        version = "0.5.10";
-       sha256 = "1k38p73jnkfcmmz94iqpzg2g6apsxflidvy8p9lwqyzfmg70brqf";
+       sha256 = "0ee705ceabee7bcc69bac8ef16a9ebfa2af3c4fb1747927eadcc4d2bc7b968cc";
        libraryHaskellDepends = [ base bytestring text ];
        librarySystemDepends = [ libxml2 ];
        description = "Relational optimiser and code generator";
@@ -12295,7 +12315,7 @@ self: {
      mkDerivation {
        pname = "Peano";
        version = "0.0.4";
-       sha256 = "0ss4p40gkqcw9bdh5iy0yar56gpsanrxld74q5dxvakrf8m6cqmz";
+       sha256 = "bf62662a7279aadd5bc1e434dab355fa3e53b2f2c0c702db4a9ce1f900b9446b";
        libraryHaskellDepends = [ base ];
        description = "simple Peano numbers";
        license = stdenv.lib.licenses.bsd3;
@@ -12306,7 +12326,7 @@ self: {
      mkDerivation {
        pname = "PeanoWitnesses";
        version = "0.1.0.0";
-       sha256 = "1g83jws23grl84gnq89rnppw6q7vsbhi9hk6lp5dq2n4818kamgg";
+       sha256 = "ef55355140c40adccaa566c214e1d2fb60c3efb539216c1f4134bf21349703bd";
        libraryHaskellDepends = [ base ];
        jailbreak = true;
        description = "GADT type witnesses for Peano-style natural numbers";
@@ -12320,7 +12340,7 @@ self: {
      mkDerivation {
        pname = "PerfectHash";
        version = "0.1.4";
-       sha256 = "1hj05lv8yj81nhpb01ljaqj9k7j6amw6lfx1azzjnwysmjj6ipkn";
+       sha256 = "76de68a4acda732bff57a13b6a7855469e9924569206b02eb401498f362d40c2";
        libraryHaskellDepends = [
          array base binary bytestring containers digest time
        ];
@@ -12336,7 +12356,7 @@ self: {
      mkDerivation {
        pname = "PermuteEffects";
        version = "0.2";
-       sha256 = "0lmmsvqbnw0k321254xfqlzmddvymy0mj50ax7caqj2fnarfgy4l";
+       sha256 = "94f8e7b2b24e48acd8e90a145981af7eb7563fc5ae932282181370bbf0d6b552";
        libraryHaskellDepends = [ base ReplicateEffects ];
        jailbreak = true;
        homepage = "https://github.com/MedeaMelana/PermuteEffects";
@@ -12355,7 +12375,7 @@ self: {
      mkDerivation {
        pname = "Phsu";
        version = "0.1.0.3";
-       sha256 = "12f6hqgxyf3svr53g0irn15q69wp9py1bxfw3a5inpkqzmrs04x9";
+       sha256 = "a913a073fd785e1b8b1adcf515fc4d9727834bb03982374ade7a38df1f86c689";
        isLibrary = false;
        isExecutable = true;
        executableHaskellDepends = [
@@ -12377,7 +12397,7 @@ self: {
      mkDerivation {
        pname = "Pipe";
        version = "2.1.2";
-       sha256 = "1453rjp5whl9vywiq8i86vjfa8ys1ppwabhvlibqwsbx804q9yhr";
+       sha256 = "19fa8409407d698e57a41b2ec5ef0dda23e5e43628221cb9df89425eaecca390";
        libraryHaskellDepends = [ base filepath process unix ];
        homepage = "http://iki.fi/matti.niemenmaa/pipe/";
        description = "Process piping library";
@@ -12390,7 +12410,7 @@ self: {
      mkDerivation {
        pname = "Piso";
        version = "0.1";
-       sha256 = "123hwav5bsadd2lmzgys4dwja1xrbn1c5w19063ak21y5415ci83";
+       sha256 = "03455602293e88a9860129f0c2825db907257923dabf5fa9684de955b6e27088";
        libraryHaskellDepends = [ base template-haskell ];
        homepage = "https://github.com/MedeaMelana/Piso";
        description = "Partial isomorphisms";
@@ -12404,7 +12424,7 @@ self: {
      mkDerivation {
        pname = "PlayHangmanGame";
        version = "0.2";
-       sha256 = "17avnaz6da80v5kgz0b3v0zq3y9p2d3mxxv5a09ggcmilbz4xwlg";
+       sha256 = "8ff24efea2b1b2f7125065f75e471337f9813fd86381ff66d900a966beb25b9d";
        isLibrary = false;
        isExecutable = true;
        executableHaskellDepends = [
@@ -12422,7 +12442,7 @@ self: {
      mkDerivation {
        pname = "PlayingCards";
        version = "0.3.0.0";
-       sha256 = "1wq4y6dfn93c8pyxbz5dwbd1c2lq78fbw6s2pdk6nvi0zgf5hp6k";
+       sha256 = "d35c58dcfb206e6b66bb421bbe1c3a980a16dae2adfcd5fd456c24eb9af104f3";
        libraryHaskellDepends = [
          base HUnit MonadRandom QuickCheck random-shuffle
        ];
@@ -12439,7 +12459,7 @@ self: {
      mkDerivation {
        pname = "Plot-ho-matic";
        version = "0.5.0.5";
-       sha256 = "0x8mq7368yjb1q4xmkj6iqrxkf81d0vslfdrhp8cr12k83ydg3g3";
+       sha256 = "e38dd7fc405384ccd085b939aa376801b9d9338e46ceda090e4b7a64c6c11575";
        isLibrary = true;
        isExecutable = true;
        libraryHaskellDepends = [
@@ -12458,7 +12478,7 @@ self: {
      mkDerivation {
        pname = "PlslTools";
        version = "0.0.2";
-       sha256 = "1kly1jfki4n9fhgkh2m9j9xj8182s92i7rsq81vcm6i3hd4fac94";
+       sha256 = "2431e54883239aca764058e71345d20205247b92a90a381f74c992389d0c9ece";
        isLibrary = false;
        isExecutable = true;
        executableHaskellDepends = [
@@ -12476,7 +12496,7 @@ self: {
      mkDerivation {
        pname = "Plural";
        version = "0.0.2";
-       sha256 = "047aw1pka7xsqnshbmirkxd80m92w96xfb0kpi1a22bx0kpgg58w";
+       sha256 = "1c95f7ee047d09a142bc132cd74de22255805a9f39d605b5c5ba1f356fe0ea10";
        libraryHaskellDepends = [ base containers regex-tdfa ];
        description = "Pluralize English words";
        license = stdenv.lib.licenses.gpl3;
@@ -12487,7 +12507,7 @@ self: {
      mkDerivation {
        pname = "Pollutocracy";
        version = "1.0";
-       sha256 = "036b114f6fas2w3kmbcb1ria2ymdgi1sc5iqkskfgbc1iizhm2wh";
+       sha256 = "908b0a7f8c81ade7a69e3816a6437cad7aa1620e8bad3a07175a39e34808cb0c";
        isLibrary = false;
        isExecutable = true;
        executableHaskellDepends = [ array base clock GLUT random ];
@@ -12500,7 +12520,7 @@ self: {
      mkDerivation {
        pname = "PortFusion";
        version = "1.2.1";
-       sha256 = "1n095a7ggkgvxdagn7wi1rnb3h766lah5avyrdxnv4g0kl143vvy";
+       sha256 = "7eef41029de0916d7bcb7eab021535e6c0b16c0e911ffb54ebfbcdf78e2a09d8";
        isLibrary = false;
        isExecutable = true;
        executableHaskellDepends = [ base bytestring network splice ];
@@ -12514,7 +12534,7 @@ self: {
      mkDerivation {
        pname = "PortMidi";
        version = "0.1.4";
-       sha256 = "00w4208dan87adyd8gm7izbs38mva7glbi7s9rbcdjdkiz486q8m";
+       sha256 = "156183c88fb3c9c6564efac445df51bba2a1d78fa73ed47c530759d510108403";
        libraryHaskellDepends = [ base ];
        librarySystemDepends = [ alsaLib ];
        homepage = "http://haskell.org/haskellwiki/PortMidi";
@@ -12527,7 +12547,7 @@ self: {
      mkDerivation {
        pname = "PostgreSQL";
        version = "0.2";
-       sha256 = "0p5q3yc8ymgzzlc600h4mb9w86ncrgjdbpqfi49b2jqvkcx5bwrr";
+       sha256 = "39f3553a9b1b4bb112890edfd5e4cbcc1ac4d3aa04026018fdff558f981fb85c";
        libraryHaskellDepends = [ base mtl ];
        description = "Thin wrapper over the C postgresql library";
        license = "unknown";
@@ -12543,7 +12563,7 @@ self: {
      mkDerivation {
        pname = "PrimitiveArray";
        version = "0.6.1.0";
-       sha256 = "1annz4pkz66jxcwzgq3b897vigf8b23aprv0vx1xyly9bbccdpcn";
+       sha256 = "96ddc6d85ac953df43df60e7ab8658c8bdb84f426be0f739ebd2983f2ff9d6aa";
        libraryHaskellDepends = [
          aeson base binary bits cereal deepseq OrderedBits primitive
          QuickCheck vector vector-binary-instances vector-th-unbox
@@ -12562,7 +12582,7 @@ self: {
      mkDerivation {
        pname = "Printf-TH";
        version = "0.1.1";
-       sha256 = "0n1gva510p69vy25zvjkzwqqz2gilbns1wnrzz2p22rjkkbrinvx";
+       sha256 = "7ddb98d79c320b71c5ffd9f2a0eda2f1898f31ff53ee5f84dfc95c108ada2f58";
        libraryHaskellDepends = [ base haskell98 pretty template-haskell ];
        license = "LGPL";
        hydraPlatforms = stdenv.lib.platforms.none;
@@ -12573,7 +12593,7 @@ self: {
      mkDerivation {
        pname = "PriorityChansConverger";
        version = "0.1";
-       sha256 = "0258ysarn6k5kxxwy4lz9ww2rdhg5mg7h6idfbfrszcgwkcp22a1";
+       sha256 = "410971d9e48f7d9ddd722d1a785e2d0fb62c384f9f12cf7b9f651a9b95f6a808";
        libraryHaskellDepends = [ base containers stm ];
        description = "Read single output from an array of inputs - channels with priorities";
        license = "LGPL";
@@ -12585,7 +12605,7 @@ self: {
      mkDerivation {
        pname = "ProbabilityMonads";
        version = "0.1.0";
-       sha256 = "0vmjg91yq4p0121ypjx4l1hh77j8xj6ha7awdvrjk5fjmz9xryh3";
+       sha256 = "03fadcd3afd29529f36e5c1d058dec489e0361a0a4cbeb8308e012ec437ab26e";
        libraryHaskellDepends = [ base MaybeT MonadRandom mtl ];
        description = "Probability distribution monads";
        license = stdenv.lib.licenses.bsd3;
@@ -12597,7 +12617,7 @@ self: {
      mkDerivation {
        pname = "PropLogic";
        version = "0.9.0.4";
-       sha256 = "1gr3xiwj5ggqlrvi2xi612sba0v7lwc3bz0w18knhh0gz60vslqy";
+       sha256 = "1e53bd81f90f4068270a1cfc3518a76703b5b40826761177a6f8bd2279ec23bf";
        isLibrary = true;
        isExecutable = true;
        libraryHaskellDepends = [ base old-time random ];
@@ -12612,7 +12632,7 @@ self: {
      mkDerivation {
        pname = "Proper";
        version = "0.5.2.0";
-       sha256 = "0y8jrvhnvb3nr8zi4hw8cm90nnz4lmcp3npvzsbz2wlkif5qf7k6";
+       sha256 = "661e878b8b9372f197fefbda7159a5e45b0b52658843123fca76ac6de1ce1279";
        isLibrary = true;
        isExecutable = true;
        libraryHaskellDepends = [ base containers syb ];
@@ -12628,7 +12648,7 @@ self: {
      mkDerivation {
        pname = "ProxN";
        version = "0.0.1";
-       sha256 = "0mx3kgkcbhppz2p6g8vb9yx27219ca2w7k36j60vfhszni1c4gid";
+       sha256 = "2d3ec242b45f43b7819166ccc38562298823ba4f6ba367aef8f7c2c5e69ba357";
        libraryHaskellDepends = [ base mtl ];
        homepage = "https://github.com/exFalso/ProxN";
        description = "Proximity sets in N dimensions";
@@ -12645,7 +12665,7 @@ self: {
      mkDerivation {
        pname = "Pugs";
        version = "6.2.13.20130611";
-       sha256 = "13advi8qykjslpg6kqilzdabz5076z6d69b66sf1ikyhjpc1j55i";
+       sha256 = "b11419d895d0cf189c366625d3cc370794bf54fb34e269dea55a4e8f51dc4d8d";
        isLibrary = false;
        isExecutable = true;
        executableHaskellDepends = [
@@ -12667,7 +12687,7 @@ self: {
      mkDerivation {
        pname = "Pup-Events";
        version = "1.0";
-       sha256 = "13zjhxq8q1qd7sbc17d73g6mfsfls6rl3ndawbcfjgj73b7xajyj";
+       sha256 = "d24bd5cf1a473ee9d8e2aad941b3d1d46957cd1ba79dc0963e0d078c7087f28f";
        isLibrary = true;
        isExecutable = true;
        libraryHaskellDepends = [
@@ -12686,7 +12706,7 @@ self: {
      mkDerivation {
        pname = "Pup-Events-Client";
        version = "1.1.4";
-       sha256 = "1b6vkjnk1yk7ra221njh1mm92jgzqh2hjbh67p2h4fz2jf202xvm";
+       sha256 = "7577018493e23b02c53d062e0905c4ff49916a0d50da2084ca67fa30ad9cdbac";
        libraryHaskellDepends = [
          base network parsec Pup-Events-PQueue stm transformers
        ];
@@ -12701,7 +12721,7 @@ self: {
      mkDerivation {
        pname = "Pup-Events-Demo";
        version = "1.3";
-       sha256 = "06cf18ccamaknkm2fcmj17ymdb2i3130q5bakbji4m8349bzhxxb";
+       sha256 = "ab77f85722035512e59a6a150c461851ac56fd09b23227eab45355c5180a8e19";
        isLibrary = false;
        isExecutable = true;
        executableHaskellDepends = [
@@ -12718,7 +12738,7 @@ self: {
      mkDerivation {
        pname = "Pup-Events-PQueue";
        version = "1.0";
-       sha256 = "0sngiqxzj5kif452s2hn3x1kv257815c5v19dp4wqazbyc373iwx";
+       sha256 = "9dc77106f3eb2bccc96d29ecc24a40a7883d431f160a2d0a717116f93b8ecf6a";
        libraryHaskellDepends = [ base stm ];
        description = "A networked event handling framework for hooking into other programs";
        license = stdenv.lib.licenses.gpl3;
@@ -12731,7 +12751,7 @@ self: {
      mkDerivation {
        pname = "Pup-Events-Server";
        version = "1.2";
-       sha256 = "18n4bzhwvx336dv4yb5pbicaxbzzhhd36951diwhgw4gf5ji80dn";
+       sha256 = "b6011465718ff007796ca124331a84ffafae585cb72c4f763363f4cde15fc4a2";
        libraryHaskellDepends = [
          base network parsec Pup-Events-PQueue stm transformers
        ];
@@ -12744,7 +12764,7 @@ self: {
      mkDerivation {
        pname = "QIO";
        version = "1.2";
-       sha256 = "1wm0n5r5nfgbd35ry4fn25bzfj83gn3xbrd14clpw4wqqq45rhx6";
+       sha256 = "a6c35c08c698137e2923a1e5d5877d0349f75711d6119fcb68eb395b72b1a0f2";
        libraryHaskellDepends = [ base containers mtl old-time random ];
        homepage = "http://www.cs.nott.ac.uk/~asg/QIO/";
        description = "The Quantum IO Monad is a library for defining quantum computations in Haskell";
@@ -12757,22 +12777,22 @@ self: {
      mkDerivation {
        pname = "QuadEdge";
        version = "0.2";
-       sha256 = "1f3wxc8ipb8ka02xq2snjs5wgl10mk528zjkpwdw5wf3fldhz037";
+       sha256 = "67800f1b75c3f1c21bbf537e24caac20d0c78b96560bdc055013ad1b11eb7cb8";
        libraryHaskellDepends = [ base random vector ];
        description = "QuadEdge structure for representing triangulations";
        license = stdenv.lib.licenses.bsd3;
      }) {};
 
   "QuadTree" = callPackage
-    ({ mkDerivation, base, composition, lens }:
+    ({ mkDerivation, base, composition, lens, QuickCheck }:
      mkDerivation {
        pname = "QuadTree";
-       version = "0.10.1";
-       sha256 = "0r4qv6xw03g79sn1889vv1rzpkcpjm9lmipvxdl0l1d8r8kvxdxw";
+       version = "0.11.0";
+       sha256 = "ce22be7f089d90babe9e46217cc99cb5da0c7771739423e7c6cec3b94da294e2";
        libraryHaskellDepends = [ base composition lens ];
-       jailbreak = true;
+       testHaskellDepends = [ base composition lens QuickCheck ];
        description = "QuadTree library for Haskell, with lens support";
-       license = stdenv.lib.licenses.gpl3;
+       license = stdenv.lib.licenses.bsd3;
      }) {};
 
   "QuasiText" = callPackage
@@ -12782,7 +12802,7 @@ self: {
      mkDerivation {
        pname = "QuasiText";
        version = "0.1.2.5";
-       sha256 = "10y2lirprxyh9m47qxq0plihc22xvmkhq6lfbx3i19vfvkbhnbwx";
+       sha256 = "9d2f0bd7dc6ea710475f8e1a0c67dd5d080623bd00777c484dd0f77c73a4c283";
        libraryHaskellDepends = [
          attoparsec base haskell-src-meta template-haskell text
        ];
@@ -12796,7 +12816,7 @@ self: {
      mkDerivation {
        pname = "QuickAnnotate";
        version = "0.6";
-       sha256 = "0xphlira6gxfs7md1b55vf9biqzw9v1kzmcs17x07xnzcy1y3dvb";
+       sha256 = "6bb7e18367dff603fa099ad53fc34efce3b892dba5acd0ead1ae3fa372a4f076";
        isLibrary = true;
        isExecutable = true;
        libraryHaskellDepends = [ base ];
@@ -12813,7 +12833,7 @@ self: {
      mkDerivation {
        pname = "QuickCheck";
        version = "1.2.0.1";
-       sha256 = "1gxpvbc0ab4n35b5zcbzng8qc7y3mzgym8cj42bci984f08y1bld";
+       sha256 = "8daee0117004a5c8962092a1eadfafc31f86d1b37fb15f5619962c05d8dab7bf";
        revision = "2";
        editedCabalFile = "8f06f07cae74e90cd5bdde3eed23b0e3293ad494f42f0f0cb77074fa3b7950d9";
        libraryHaskellDepends = [ base random ];
@@ -12830,7 +12850,7 @@ self: {
      mkDerivation {
        pname = "QuickCheck";
        version = "2.8.1";
-       sha256 = "0fvnfl30fxmj5q920l13641ar896d53z0z6z66m7c1366lvalwvh";
+       sha256 = "7073aa3635660476aa31df7cf0476926a1ac0231235020122eb276070675763b";
        libraryHaskellDepends = [
          base containers random template-haskell tf-random transformers
        ];
@@ -12847,7 +12867,7 @@ self: {
      mkDerivation {
        pname = "QuickCheck-GenT";
        version = "0.1.4";
-       sha256 = "07zsp1praq0g6mcpfli9r1dwhfgj2cl5a2dljm6cdc8nsjl6dz7x";
+       sha256 = "fdfc66a8d416b1c64c95b409552813f239c85bc829527759350f60956fb8fa1f";
        libraryHaskellDepends = [ base mtl QuickCheck random ];
        jailbreak = true;
        homepage = "https://github.com/nikita-volkov/QuickCheck-GenT";
@@ -12861,7 +12881,7 @@ self: {
      mkDerivation {
        pname = "QuickCheck-safe";
        version = "0.1.0.1";
-       sha256 = "0rxqd1n814b9mf6zg1i0g9d96ym9xqdgky7w7qf5bnnnpkk1ckc7";
+       sha256 = "874d16e6bcd6da551c3efcf8f91aeea97a935a7a2086f78dab6991806c68b867";
        revision = "3";
        editedCabalFile = "4e791ac9fa2f2e73029ab92d17e3ab93571ec5b1d5acda0ea1f340c5ee1346f6";
        libraryHaskellDepends = [ base QuickCheck ];
@@ -12875,7 +12895,7 @@ self: {
      mkDerivation {
        pname = "Quickson";
        version = "0.2";
-       sha256 = "1mr8ilcjlwxcpbblk6l6w022qbf4ngzd0q62fc9k1kjb0w1palbg";
+       sha256 = "6f517503074bce301373c260d0feb3c42d2c04e0869a49d7baac732a198d28d7";
        libraryHaskellDepends = [
          aeson attoparsec base bytestring either text
        ];
@@ -12892,7 +12912,7 @@ self: {
      mkDerivation {
        pname = "RANSAC";
        version = "0.1.0.1";
-       sha256 = "1frn3y0j4w337mfaakqw58d7p9pqhbi2fzk8blv6zilzvqmhbqqv";
+       sha256 = "1be3052bde9fc66f365d687e27e282f8a67b1a2a1c4fa55c3d637022811f36bb";
        libraryHaskellDepends = [ base random vector ];
        testHaskellDepends = [
          base HUnit lens linear test-framework test-framework-hunit vector
@@ -12906,7 +12926,7 @@ self: {
      mkDerivation {
        pname = "RBTree";
        version = "0.0.5";
-       sha256 = "0p46b105lixbxqjz8pwxf4asl4s7zdh2ss3nvgmp1rclqfg6cwrq";
+       sha256 = "3873669ec394e570ebdb76682d60fb4713aa15719d5ff425eeab475a4058865c";
        libraryHaskellDepends = [ base ];
        homepage = "git://github.com/wuxb45/Haskell-RBTree.git";
        description = "Pure haskell Red-Black-Tree implemetation";
@@ -12920,7 +12940,7 @@ self: {
      mkDerivation {
        pname = "RESTng";
        version = "0.1";
-       sha256 = "1fans0znb3i33n9cxd8w140n1sl8bdyl874cdrgc5wvlg6y3y4aj";
+       sha256 = "52113fbc7974f3c25e6e8c1c447d5b88ea6001091cb5ce921d238e653fd056b9";
        libraryHaskellDepends = [
          base HDBC HDBC-postgresql mtl old-time parsec redHandlers xhtml
          yuiGrid
@@ -12938,7 +12958,7 @@ self: {
      mkDerivation {
        pname = "RFC1751";
        version = "0.3.0.1";
-       sha256 = "1347cl0z5zw7f4dn6bjyf19pnfq06dzwpcl68z14zgxw0p58crka";
+       sha256 = "6a6686ca05bcbf4fc24786b2cb7f33003b7b53705e2e631b7187fff20165878c";
        libraryHaskellDepends = [ base binary bytestring ];
        testHaskellDepends = [
          base binary bytestring HUnit QuickCheck test-framework
@@ -12956,7 +12976,7 @@ self: {
      mkDerivation {
        pname = "RJson";
        version = "0.3.7";
-       sha256 = "04vlhcyikd4liy65xiy3xn4slkm5w4q3r8ir54s095zs9bq8jx1n";
+       sha256 = "367489f04afa9704342939a23c30e1a54eaa89edc3c75e8c8f94b4193d837413";
        libraryHaskellDepends = [
          array base bytestring containers iconv mtl parsec syb-with-class
        ];
@@ -12972,7 +12992,7 @@ self: {
      mkDerivation {
        pname = "RMP";
        version = "0.0.2";
-       sha256 = "0bcilw8z764p6idjj19kxk9if5l4pxyn7zszxjv0q3bfky1rd8ay";
+       sha256 = "5ea196839f6e0d0cb6ec5fff637dbf841617d3ec3305295b349798f311a7912d";
        isLibrary = true;
        isExecutable = true;
        libraryHaskellDepends = [ allocated-processor base ];
@@ -12994,7 +13014,7 @@ self: {
      mkDerivation {
        pname = "RNAFold";
        version = "1.99.3.4";
-       sha256 = "0r4y4rinrdr2xwfpnys5agm1awr3qr9im4cqczz1fzjz7r425m96";
+       sha256 = "26d522483e5f7e17fe6798911a53c6237315ea53457b7b1def22b76c63269e64";
        isLibrary = true;
        isExecutable = true;
        libraryHaskellDepends = [
@@ -13018,7 +13038,7 @@ self: {
      mkDerivation {
        pname = "RNAFoldProgs";
        version = "0.0.0.3";
-       sha256 = "1bmybm80fhw7xqjzny2iricicbzqsl33snpsjamfcr16a939wlwp";
+       sha256 = "97539e46522664e6aa92fa5a3d06d5f82f1659cc5178fb25ee874307505dbeae";
        isLibrary = false;
        isExecutable = true;
        executableHaskellDepends = [
@@ -13042,7 +13062,7 @@ self: {
      mkDerivation {
        pname = "RNAdesign";
        version = "0.1.2.2";
-       sha256 = "1qdfbwiydkh0974m7r4ashxhsbkss8k9d6kpc07vj4hspjf5v5ag";
+       sha256 = "4f955d9cbc1a12b90f60779a9626d27a2e0d3bd48ae453c94900cee6235faee1";
        isLibrary = true;
        isExecutable = true;
        libraryHaskellDepends = [
@@ -13064,7 +13084,7 @@ self: {
      mkDerivation {
        pname = "RNAdraw";
        version = "0.2.0.1";
-       sha256 = "1d85lps04b2sn23fzyn5hd8lj2lf7byqk7flj8p2b905hl3062dx";
+       sha256 = "bd0903068505a4252e92d49d89fd3a8e0a495183c5faef86b05a2c02f4a505b5";
        isLibrary = true;
        isExecutable = true;
        libraryHaskellDepends = [
@@ -13086,7 +13106,7 @@ self: {
      mkDerivation {
        pname = "RNAwolf";
        version = "0.4.0.0";
-       sha256 = "1s7ilg8814gglg4n64nk94b51fdzh2fm1y4k1mw8d81qd66y60vn";
+       sha256 = "7603e38d6938a086780d93f8509d80bfb9501649d31263c9a3ef9180d0a3f1e8";
        isLibrary = true;
        isExecutable = true;
        libraryHaskellDepends = [
@@ -13109,7 +13129,7 @@ self: {
      mkDerivation {
        pname = "RSA";
        version = "2.1.0.1";
-       sha256 = "0m74683bm34zd5r46ndb1h8jx1xp8wypfqm0gi3zmrv1rmm0j0hv";
+       sha256 = "1b02096acd61e7fa477ca062773d47b7872e110cab594372699f8cba0632e454";
        libraryHaskellDepends = [
          base binary bytestring crypto-api crypto-pubkey-types pureMD5 SHA
        ];
@@ -13128,7 +13148,7 @@ self: {
      mkDerivation {
        pname = "Raincat";
        version = "1.1.1.3";
-       sha256 = "1aalh68h6799mv4vyg30zpskl5jkn6x2j1jza7p4lrflyifxzar8";
+       sha256 = "28abdf5df4d4654aee515f0629bab153163af5fd603cbfc9ae291d03918154a9";
        isLibrary = false;
        isExecutable = true;
        executableHaskellDepends = [
@@ -13148,7 +13168,7 @@ self: {
      mkDerivation {
        pname = "Random123";
        version = "0.2.0";
-       sha256 = "18q6nf63qapypj10iifpc1qdaq7pndmv2p7jz0f96y113z33nqy4";
+       sha256 = "c4633bc61f2178931cf8f25cb16bb3f760d57060d7c50882bcfe2a3c8cb306a3";
        libraryHaskellDepends = [ array base data-dword random ];
        testHaskellDepends = [
          base HUnit QuickCheck random test-framework test-framework-hunit
@@ -13164,7 +13184,7 @@ self: {
      mkDerivation {
        pname = "RandomDotOrg";
        version = "0.2.1";
-       sha256 = "0rfarn424wsvvwvi7b1qzvzc63dxfqmlyrfd0hdcvmgkq5h2iy4c";
+       sha256 = "8cf82860c1f3d5cd1a04cd654f2b76bd0dc3fefe38ac1337df5b732288cdca65";
        libraryHaskellDepends = [ base HTTP-Simple network ];
        description = "Interface to random.org";
        license = stdenv.lib.licenses.publicDomain;
@@ -13176,7 +13196,7 @@ self: {
      mkDerivation {
        pname = "Randometer";
        version = "0.1.0.1";
-       sha256 = "1anj962cpgl06hipjfdygxlvq6adkdg3r0ghkwkzzf3dklmwzng6";
+       sha256 = "e6d9cf2b9d6db8ff279ff0813c5e9b4d19bc697fbe3979233480becb8449d2aa";
        isLibrary = false;
        isExecutable = true;
        executableHaskellDepends = [ base random-fu ];
@@ -13190,7 +13210,7 @@ self: {
      mkDerivation {
        pname = "Range";
        version = "0.1.0.0";
-       sha256 = "0759508s75zba89jjr56sqpm7idgwsxynmf9zl9hwrz9q11fxrqh";
+       sha256 = "10e7ee42c0e9670e13fdc955ebbbe6afc5532fd6a664291352eb97a31128a91c";
        libraryHaskellDepends = [ base ];
        jailbreak = true;
        description = "Data structure for managing ranges";
@@ -13202,7 +13222,7 @@ self: {
      mkDerivation {
        pname = "Ranged-sets";
        version = "0.3.0";
-       sha256 = "1am0lsd3yiyn7ayk9k4ff7zdj67m0pxjl10cxi5f9hgjj4y9380l";
+       sha256 = "14a0913c91f2c1e44aec0c042afb05f518d9fe718ecc34bd3ad6473f9aa6a0aa";
        libraryHaskellDepends = [ base HUnit QuickCheck ];
        homepage = "http://code.haskell.org/ranged-sets";
        description = "Ranged sets for Haskell";
@@ -13214,7 +13234,7 @@ self: {
      mkDerivation {
        pname = "Ranka";
        version = "0.1";
-       sha256 = "1df010121jdjbagc3gg906kydmwwpa7np1c0mx7w2v64mr7i2q1r";
+       sha256 = "3960114faec46cc14faf80856b8fba9cd7e6a701e9bdc19e5ab2c9200208c0b5";
        isLibrary = false;
        isExecutable = true;
        executableHaskellDepends = [
@@ -13234,7 +13254,7 @@ self: {
      mkDerivation {
        pname = "Rasenschach";
        version = "0.1.3.1";
-       sha256 = "0y90clz236lqhacv6ba4w3qx4fyd5yls9nh4chk8s945hr92jg57";
+       sha256 = "a73c29528685248d266404daa4a92fcd3bd2f1e0442db39982989a213e652079";
        isLibrary = false;
        isExecutable = true;
        executableHaskellDepends = [
@@ -13253,7 +13273,7 @@ self: {
      mkDerivation {
        pname = "Rasterific";
        version = "0.6.1";
-       sha256 = "1y9jciiaam0dn2falhxc0nb97vy35dfvv71xzc1bhiw4gn66n4rm";
+       sha256 = "35136b8c7d8447b802fb3d9cbd5d2bc3ef939605ac43aa9cb00d54a5626432f9";
        libraryHaskellDepends = [
          base bytestring containers dlist FontyFruity free JuicyPixels mtl
          primitive vector vector-algorithms
@@ -13267,7 +13287,7 @@ self: {
      mkDerivation {
        pname = "ReadArgs";
        version = "1.2.2";
-       sha256 = "1v6yr5zzrrj31prfzxxh1n27sfnkqpkw34v3a47rcnm444ba58a7";
+       sha256 = "47a1a21621a45a960f516393c1e7c5d33a7d840db0f7eff20d43e6fc7fc9deec";
        isLibrary = true;
        isExecutable = true;
        libraryHaskellDepends = [ base system-filepath text ];
@@ -13288,7 +13308,7 @@ self: {
      mkDerivation {
        pname = "Redmine";
        version = "0.0.6";
-       sha256 = "10lq9lhz3yyzkzwbi8rx060hmwh0c8cplydrfzdmd1653x8267z8";
+       sha256 = "e81f23501fc58456db77b9797a196200f20a81013da3b8f89fdffbf1214d9882";
        libraryHaskellDepends = [
          aeson base bytestring connection containers HTTP http-client-tls
          http-conduit http-types MissingH network old-locale old-time
@@ -13309,7 +13329,7 @@ self: {
      mkDerivation {
        pname = "Ref";
        version = "0.1.1.0";
-       sha256 = "15qikbjbydbabc26skhavshzrsaz17a71q8hfxqvi5ix2bhhz4hm";
+       sha256 = "15920fe1123d96b8717710e170d4095fe9fca1de0a4e6d045b6a35bfe49a1197";
        libraryHaskellDepends = [ base ghc-prim ];
        jailbreak = true;
        homepage = "https://bitbucket.org/carter/ref";
@@ -13325,7 +13345,7 @@ self: {
      mkDerivation {
        pname = "RefSerialize";
        version = "0.3.1.4";
-       sha256 = "1hl1jxdarqp59fs1sjvxpyhcazrnlm4iywysgkf3iqm56jfp2f6w";
+       sha256 = "dc38719d34a5e238dc7cda731f49a5367fc5a0bf7d4b1db44be5e2ac5a9781c2";
        libraryHaskellDepends = [
          base binary bytestring containers hashtables stringsearch
        ];
@@ -13340,7 +13360,7 @@ self: {
      mkDerivation {
        pname = "Referees";
        version = "0.0.0";
-       sha256 = "076pa25455jd4b0dbs9gfksaa1ww66yvnknki4yivc0pm60pnh7r";
+       sha256 = "f9407b81a917b01d3d89d34ebbbd319c07a5f4742fe9d5c0224d96428a50d71c";
        isLibrary = true;
        isExecutable = true;
        libraryHaskellDepends = [
@@ -13361,7 +13381,7 @@ self: {
      mkDerivation {
        pname = "RepLib";
        version = "0.5.3.3";
-       sha256 = "1772r6rfajcn622dxwy9z1bvv53l5xj6acbcv8n9p7h01fs52mpr";
+       sha256 = "f95651b40b009e9b2cda6c3165642f7494bd57f8c9f3de84309649e5b2c9e29c";
        libraryHaskellDepends = [ base containers mtl template-haskell ];
        jailbreak = true;
        homepage = "http://code.google.com/p/replib/";
@@ -13375,7 +13395,7 @@ self: {
      mkDerivation {
        pname = "ReplicateEffects";
        version = "0.3";
-       sha256 = "194nbnbrf5g3d2pch6z9zapzhi0i2z30vpgjj0h5x8bfwzpf1527";
+       sha256 = "4794e0eee76ea15e2090f2dd0dc6171144f8affae91bc8ae68e31597975d96a4";
        libraryHaskellDepends = [ base ];
        homepage = "https://github.com/MedeaMelana/ReplicateEffects";
        description = "Composable replication schemes of applicative functors";
@@ -13389,7 +13409,7 @@ self: {
      mkDerivation {
        pname = "ReviewBoard";
        version = "0.2.2";
-       sha256 = "1grcs7mily2gpxdzq1pcz1f71z2d8pz6paqrb8yv38nkckvm4j75";
+       sha256 = "e54852f764d3a2b13d5a19ab6bfe454dfc705cf8ec06fc5bbf4f781aebd12cbf";
        isLibrary = true;
        isExecutable = true;
        libraryHaskellDepends = [ base HTTP json mtl network random ];
@@ -13406,7 +13426,7 @@ self: {
      mkDerivation {
        pname = "RichConditional";
        version = "0.1.0.0";
-       sha256 = "065plckw5r16aalkf51y7hs2xjandad3hgfly795wakqfhdnrajw";
+       sha256 = "5caa6c1b74782a5ed2f1d43d389a6a56c92e343c3e1437a95226e4c227a3b718";
        libraryHaskellDepends = [ base ];
        jailbreak = true;
        homepage = "https://github.com/avieth/RichConditional";
@@ -13424,7 +13444,7 @@ self: {
      mkDerivation {
        pname = "Rlang-QQ";
        version = "0.3.1.0";
-       sha256 = "0rl3cmr7vfc8vk7132y40ib0l53v9yndw71bmp25zj24nkmha7hj";
+       sha256 = "121e05ebb444c85fc4ad2b1cdeac4f7b140a5604c48b11cedc88b97d72658366";
        libraryHaskellDepends = [
          array base binary bytestring Cabal containers data-binary-ieee754
          directory filepath haskell-src-meta HList lens mtl process repa SHA
@@ -13446,7 +13466,7 @@ self: {
      mkDerivation {
        pname = "RollingDirectory";
        version = "0.1";
-       sha256 = "0mw4hd99v8pp75ng75cv3vym5ld93f07mpkcbi2b6v12k68bxx4v";
+       sha256 = "9bf4be9099226cb3445c6cde7a801ba9d152fd1e9b95f36c39f7a29d52838457";
        isLibrary = false;
        isExecutable = true;
        executableHaskellDepends = [
@@ -13467,7 +13487,7 @@ self: {
      mkDerivation {
        pname = "RxHaskell";
        version = "0.2";
-       sha256 = "0pwxsvkpdr4vzr6cpgjmkr55ip6ns3gcv8pma7dwzg21myx9c3vl";
+       sha256 = "740f96baaf41bccfdb51f5a2cdded0d6dc584a9e55becb4cfe9be476e7d69d5f";
        libraryHaskellDepends = [ base containers stm transformers ];
        homepage = "https://github.com/jspahrsummers/RxHaskell";
        description = "Reactive Extensions for Haskell";
@@ -13483,7 +13503,7 @@ self: {
      mkDerivation {
        pname = "SBench";
        version = "0.2.0";
-       sha256 = "0ym9qdwwn180365hgvwi6djzbqvfiyqrd2fhywpvxihwxnlnhiam";
+       sha256 = "554568a9ed1cc6be2ff7d08996b18f6ee3f5653391ef078b190005cb79c3a97a";
        libraryHaskellDepends = [
          base bytestring cassava criterion deepseq directory filepath
          gnuplot hp2any-core parsec process utf8-string vector
@@ -13498,7 +13518,7 @@ self: {
      mkDerivation {
        pname = "SConfig";
        version = "0.2.0.0";
-       sha256 = "032s6szll58zavdnf6fsj2rhpdlizv3l46lh819bqjy1kbffv0yz";
+       sha256 = "df83eddc9ac14bbc5240901a42c7fe91b60bb390da1967db561f154abf365a0c";
        libraryHaskellDepends = [ base containers ];
        homepage = "https://github.com/fgaz/SConfig";
        description = "A simple config library";
@@ -13510,7 +13530,7 @@ self: {
      mkDerivation {
        pname = "SDL";
        version = "0.6.5.1";
-       sha256 = "1sa3zx3vrs1gbinxx33zwq0x2bsf3i964bff7419p7vzidn36k46";
+       sha256 = "864c336c8b7f9f9b0239ce2d62521c4e2fd101e67f8cde6d5c2fe8bc47ff43e9";
        revision = "1";
        editedCabalFile = "233e3fde4727ca7b597e0bf86619c6b862c32445191a37b7a536a3188634473e";
        libraryHaskellDepends = [ base ];
@@ -13524,7 +13544,7 @@ self: {
      mkDerivation {
        pname = "SDL-gfx";
        version = "0.6.0.1";
-       sha256 = "1ay72r29ybxf4icaqadly02xi03ifz82a8jz3xkvlk26c9bxl4c3";
+       sha256 = "8311da5762464cba671f5f2225d0777180d805f0b429ac5824ae2f9f4416c7ab";
        libraryHaskellDepends = [ base SDL ];
        description = "Binding to libSDL_gfx";
        license = stdenv.lib.licenses.bsd3;
@@ -13536,7 +13556,7 @@ self: {
      mkDerivation {
        pname = "SDL-image";
        version = "0.6.1.1";
-       sha256 = "1m02q2426qp8m8pzz2jkk4srk2vb3j3ickiaga5jx9rkkhz732zq";
+       sha256 = "f88b713e9c33a72e8b7a2a4e16871c6b8b993599538aff2faae8622388c002d4";
        libraryHaskellDepends = [ base SDL ];
        description = "Binding to libSDL_image";
        license = stdenv.lib.licenses.bsd3;
@@ -13548,7 +13568,7 @@ self: {
      mkDerivation {
        pname = "SDL-mixer";
        version = "0.6.1.1";
-       sha256 = "0md3238hx79mxb9a7l43kg3b3d28x4mqvj0hjsbsh15ajnvy9x2z";
+       sha256 = "5ff4e4b795aa04a8979610c88d2be948b4b1c69b83d0a3d2ea359d0ed110a355";
        libraryHaskellDepends = [ base SDL ];
        description = "Binding to libSDL_mixer";
        license = stdenv.lib.licenses.bsd3;
@@ -13560,7 +13580,7 @@ self: {
      mkDerivation {
        pname = "SDL-mpeg";
        version = "0.0.1";
-       sha256 = "0hx4977iynchnyd4b9ycbiw5qq07wk1a7dkisqx0a3x0ca4qirwj";
+       sha256 = "92e7888962a00f053ad671b6a3c2e407605c785ccca7459ab790591fcf49a443";
        libraryHaskellDepends = [ base SDL ];
        librarySystemDepends = [ smpeg ];
        description = "Binding to the SMPEG library";
@@ -13573,7 +13593,7 @@ self: {
      mkDerivation {
        pname = "SDL-ttf";
        version = "0.6.2.1";
-       sha256 = "1ld551jgrcs3c7n53zyzlkrxkf01rp81wwvf9ynkm0c5kgll779s";
+       sha256 = "3a9d43e99b85813aad4f6e731ed0cd01b8d9f3a4dfff51ec6143b3fc6428a5d1";
        libraryHaskellDepends = [ base SDL ];
        description = "Binding to libSDL_ttf";
        license = stdenv.lib.licenses.bsd3;
@@ -13585,7 +13605,7 @@ self: {
      mkDerivation {
        pname = "SDL2-ttf";
        version = "0.1.0";
-       sha256 = "03ng8kih285pvwj06jdwk4hkyyyb8j666pnvagnw5hsjhq60r8h6";
+       sha256 = "06a20c0c8652c3c2ed53db5e638c44cb7b3f2199bc490324dfb72001e344cf0e";
        libraryHaskellDepends = [ base SDL2 ];
        librarySystemDepends = [ SDL2 SDL2_ttf ];
        jailbreak = true;
@@ -13601,7 +13621,7 @@ self: {
      mkDerivation {
        pname = "SFML";
        version = "0.2.0.0";
-       sha256 = "1jz7wgrjc169slq7akf9sdgpfnl1cbiahig8hqck9p40ixn456k6";
+       sha256 = "669a426c8f80dc341986e845a8e262815a775fd3c94d7530d5c90426f3e3e7cb";
        libraryHaskellDepends = [ base ];
        librarySystemDepends = [
          csfml-audio csfml-graphics csfml-network csfml-system csfml-window
@@ -13619,7 +13639,7 @@ self: {
      mkDerivation {
        pname = "SFML-control";
        version = "0.2.0.2";
-       sha256 = "001h9y9395mz6fr58s1i8svn4pyy5iqbkzzsp19xdphh4w69za9g";
+       sha256 = "2fa99f0c2710ded653b8faffb9702cde5f62b746316854b233bf9634924f3000";
        libraryHaskellDepends = [ base mtl SFML template-haskell ];
        homepage = "https://github.com/SFML-haskell/SFML-control";
        description = "Higher level library on top of SFML";
@@ -13632,7 +13652,7 @@ self: {
      mkDerivation {
        pname = "SFont";
        version = "0.1.1";
-       sha256 = "077yvys00kp8lmkvc4mbynmkk9nn2ib5rh38bqcw0wnwsvl7140i";
+       sha256 = "119070e8d6dc72c0195e68c05c5614d6a639abf5ab12b667a5e84e00b4dffe1c";
        libraryHaskellDepends = [ array base SDL Sprig ];
        homepage = "http://liamoc.net/static/SFont";
        description = "SFont SDL Bitmap Fonts";
@@ -13645,7 +13665,7 @@ self: {
      mkDerivation {
        pname = "SG";
        version = "1.0";
-       sha256 = "0aj15lp5wbldaa9ndfvni1iq7kcrjv1syln9yz77jg6p8ndk61jv";
+       sha256 = "5b06339b45d73c79cef7c952afc39699cd83638876bb6693528d2e5e2e2d412a";
        libraryHaskellDepends = [ base mtl ];
        description = "Small geometry library for dealing with vectors and collision detection";
        license = stdenv.lib.licenses.bsd3;
@@ -13657,7 +13677,7 @@ self: {
      mkDerivation {
        pname = "SGdemo";
        version = "1.1";
-       sha256 = "0f7s8y5wq479i2yix2ik5ffsqkrb65pi31n6a03453kvk5jc7wv6";
+       sha256 = "66f3c364997b8e420650c686116f312b4fac9d2b338a1ebd88e910cc8b47fa38";
        isLibrary = false;
        isExecutable = true;
        executableHaskellDepends = [ base GLUT OpenGL SG ];
@@ -13674,7 +13694,7 @@ self: {
      mkDerivation {
        pname = "SHA";
        version = "1.6.4.2";
-       sha256 = "134ajm87fm4lpsw86m9q8apv20dw4bpk46raa389zr6bcdpifw64";
+       sha256 = "c470176f63cbe49fd0502a1b32ef22bc01b1af42385583b8be94547750958a8c";
        isLibrary = true;
        isExecutable = true;
        libraryHaskellDepends = [ array base binary bytestring ];
@@ -13692,7 +13712,7 @@ self: {
      mkDerivation {
        pname = "SHA2";
        version = "0.2.5";
-       sha256 = "1zs79a327x6myfam3p2vr8lmszcaqnkll2qz8n4sy835vz328j40";
+       sha256 = "804824c6df6520af89451f0b4aa7c58a7d5d29ca5bdc5195f3d5f423864a47ff";
        libraryHaskellDepends = [
          AES base bytestring monads-tf transformers
        ];
@@ -13707,7 +13727,7 @@ self: {
      mkDerivation {
        pname = "SMTPClient";
        version = "1.1.0";
-       sha256 = "07njj24c43iz33c641d5ish62h13lhpvn2mx5pv5i6s3fm3bxsfk";
+       sha256 = "d3e9be4675439b58f62dbd0abb2fa4234061a08ea50562d8183f0ec28890d21e";
        libraryHaskellDepends = [
          base containers extensible-exceptions hsemail network old-locale
          old-time
@@ -13723,7 +13743,7 @@ self: {
      mkDerivation {
        pname = "SNet";
        version = "0.1.0";
-       sha256 = "19ls2icg5vflznf9wn5b429x6blismcdxinh66vd8cr8hwgc8m99";
+       sha256 = "2955c41e872833d4b631d0c6de58d5912ed39320ab589e9cfdd4edf258149aa6";
        libraryHaskellDepends = [
          base bindings-DSL containers data-default lens mtl transformers
        ];
@@ -13742,7 +13762,7 @@ self: {
      mkDerivation {
        pname = "SQLDeps";
        version = "0.1";
-       sha256 = "1dx4vxrc7hjms3bx80bngwr5jxkb1v9hps09ayi0mqwhnfzq5vgp";
+       sha256 = "f7ed82bfb390e30aa25709e80bd30e6b7659327f7601d4d7d055c2c372dfa4b7";
        libraryHaskellDepends = [
          base hashable HDBC HDBC-sqlite3 mtl unordered-containers
        ];
@@ -13755,7 +13775,7 @@ self: {
      mkDerivation {
        pname = "STL";
        version = "0.3.0.2";
-       sha256 = "0papwfxp4y8rn1rqm0sw22lbfw6iaziziprh04z85isrwkfh8v43";
+       sha256 = "836c04dde459c7823e0130dff8e357d170b7a8105c838a73b0197972bbe3575d";
        libraryHaskellDepends = [ attoparsec base bytestring cereal text ];
        homepage = "http://github.com/bergey/STL";
        description = "STL 3D geometry format parsing and pretty-printing";
@@ -13767,7 +13787,7 @@ self: {
      mkDerivation {
        pname = "STMonadTrans";
        version = "0.3.3";
-       sha256 = "05d37ax0j8dp1h1w6pxkf1415mzn4gasdhn7gbsr8ay46iv1r4fr";
+       sha256 = "d9911c7634c42b94f57ac7c2a6d523f6d7124870b35fc3030cb72109ba3aa315";
        libraryHaskellDepends = [ array base mtl ];
        description = "A monad transformer version of the ST monad";
        license = stdenv.lib.licenses.bsd3;
@@ -13780,7 +13800,7 @@ self: {
      mkDerivation {
        pname = "SVG2Q";
        version = "0.3";
-       sha256 = "07cr20cdz4dk8c9j84j1wlzhg4qb4hmgyvh2nnlh4vc52bvvizmq";
+       sha256 = "b8feb8f712856d02a9b5026eff2a240b93073fe54112241343b391df1810991d";
        isLibrary = false;
        isExecutable = true;
        executableHaskellDepends = [
@@ -13801,7 +13821,7 @@ self: {
      mkDerivation {
        pname = "SVGFonts";
        version = "1.5.0.0";
-       sha256 = "0w1675cwd8gx65vh421abnl4z6jw7jaz3a43g04x0a5kgf1sfl76";
+       sha256 = "e650a7837bb328d0097883a8f1953c5c9a4fa85d2a08027731fda1c659392670";
        libraryHaskellDepends = [
          attoparsec base blaze-markup blaze-svg containers
          data-default-class diagrams-core diagrams-lib directory parsec
@@ -13816,7 +13836,7 @@ self: {
      mkDerivation {
        pname = "SVGPath";
        version = "1.1.2";
-       sha256 = "1a4rmp1rn6jv8nkab688i146ywiv4w6fp5bpm0slwgda2x0h6lp4";
+       sha256 = "e452034117aa3d4e35a87795eb0c273b726f48880899a5a6455b1a9bc3ad99a8";
        libraryHaskellDepends = [ base parsec ];
        description = "Parsing the path command of SVG";
        license = stdenv.lib.licenses.bsd3;
@@ -13829,7 +13849,7 @@ self: {
      mkDerivation {
        pname = "SWMMoutGetMB";
        version = "0.1.0.0";
-       sha256 = "069076ckklky3hw26ff82kqnambb7yfcwf76dwzp7cahp8fpvq6l";
+       sha256 = "d4e07d1dba50b1733f6fe638ce9c3f6b5565f114c83923381c7ed23999392019";
        libraryHaskellDepends = [
          base binary bytestring data-binary-ieee754 split
        ];
@@ -13846,7 +13866,7 @@ self: {
      mkDerivation {
        pname = "SableCC2Hs";
        version = "0.0.1.0";
-       sha256 = "1sngk170p5wyi3sgjkl74fr3k570fbfabhbg0dnp8z4iw53d8jfl";
+       sha256 = "d449d446e1917c746d036fc1a5dc72e09439b223874ef9f4889e970b4e98cfea";
        isLibrary = true;
        isExecutable = true;
        libraryHaskellDepends = [ array base containers ];
@@ -13864,7 +13884,7 @@ self: {
      mkDerivation {
        pname = "Safe";
        version = "0.1";
-       sha256 = "0ybi5r4635yjx41ig54bm426fbdzrivc5kn8fwqxmzm62ai0v623";
+       sha256 = "43980da212a6feda3177c8cec276ccbf2d6704a98b941703e9d29761482e7179";
        libraryHaskellDepends = [ base ];
        homepage = "http://www-users.cs.york.ac.uk/~ndm/projects/libraries.php";
        description = "Library for safe (pattern match free) functions";
@@ -13876,7 +13896,7 @@ self: {
      mkDerivation {
        pname = "SafeSemaphore";
        version = "0.10.1";
-       sha256 = "0rpg9j6fy70i0b9dkrip9d6wim0nac0snp7qzbhykjkqlcvvgr91";
+       sha256 = "21e5b737a378cae9e1faf85cab015316d4c84d4b37e6d9d202111cef8c4cef66";
        revision = "1";
        editedCabalFile = "1b168ec8de4b3958df15b33ba9ab60d8a651d9dd4ea36891d4c31ae81e7ec1cc";
        libraryHaskellDepends = [ base containers stm ];
@@ -13891,7 +13911,7 @@ self: {
      mkDerivation {
        pname = "Salsa";
        version = "0.2.0.2";
-       sha256 = "0915mwi1ksa85in03vzm5hqbvk6ih7l0zslg5cmy7j9fc0jhgwgd";
+       sha256 = "edf10725602ec9e32b2b8fea0fe881d1ccbd302cf5ef016c2c48e91922af2524";
        libraryHaskellDepends = [ base bytestring file-embed ];
        librarySystemDepends = [ glib mono ];
        homepage = "http://haskell.org/haskellwiki/Salsa";
@@ -13909,7 +13929,7 @@ self: {
      mkDerivation {
        pname = "Saturnin";
        version = "0.1.0.2";
-       sha256 = "0f6z17ry2n0qkgajiwip09r7dbcn72dkz7gh4igwk3n0igxlpqsr";
+       sha256 = "59e34bfb8bc08ec95f24f09d3f9b3896ad76720237f228d59b1858e1f309df38";
        isLibrary = true;
        isExecutable = true;
        libraryHaskellDepends = [
@@ -13930,7 +13950,7 @@ self: {
      mkDerivation {
        pname = "SciFlow";
        version = "0.2.0";
-       sha256 = "1cvh5c5mj5jy02ky2hjkf7bkjy9wx2187dmf9d71wby9ymklg8ng";
+       sha256 = "cfa24767f5c92f1e4e4baeb68382e83c7939d7715342e1a7005e16590b2b70b3";
        libraryHaskellDepends = [
          base bytestring data-default-class mtl shelly template-haskell text
          unordered-containers yaml
@@ -13946,7 +13966,7 @@ self: {
      mkDerivation {
        pname = "ScratchFs";
        version = "0.1.0.2";
-       sha256 = "0c410hnby7g5qdx1kj3shwxl0m910vl3rj3ayx6f5qsz5by5rczh";
+       sha256 = "f0b35cfc2a5fe3e24cf76ac83ce8062155403b877ac8197ac3e51dbf2c048130";
        isLibrary = false;
        isExecutable = true;
        executableHaskellDepends = [
@@ -13967,7 +13987,7 @@ self: {
      mkDerivation {
        pname = "Scurry";
        version = "0.0.3";
-       sha256 = "0iwlai8zspz08l3v7qf505mgfxn5v177kqa1x4xfssq7wzxawq8j";
+       sha256 = "1261aefae7076bed3ae941e1794ed8c576f76a01c5e1b30745e05ffd51549447";
        isLibrary = false;
        isExecutable = true;
        executableHaskellDepends = [
@@ -13985,7 +14005,7 @@ self: {
      mkDerivation {
        pname = "SegmentTree";
        version = "0.3";
-       sha256 = "1hagm0y9x2j1wcgk5ibxnlh2slnxfggn79cq20ws0zvd4yqw3231";
+       sha256 = "6188c1b1276d7fa0391098a563df73dd522d20b57dc5321fe3418a9e3ca84fc1";
        isLibrary = true;
        isExecutable = true;
        libraryHaskellDepends = [ base ];
@@ -14000,7 +14020,7 @@ self: {
      mkDerivation {
        pname = "Semantique";
        version = "0.3.0";
-       sha256 = "1l334lvm56xr7rw135l6nj7iz4h1yskl1fcrr5rdimlw7dyw2cr8";
+       sha256 = "2833c17d3b9cd6d872c999b940a7f601921f8fb4869611783eb99b52372563d0";
        isLibrary = false;
        isExecutable = true;
        executableHaskellDepends = [
@@ -14018,7 +14038,7 @@ self: {
      mkDerivation {
        pname = "Semigroup";
        version = "0.0.7";
-       sha256 = "1mdw1z50gr02j5hycki5rl95b1yk7xfrdk056ajw9ghw48s0jpx6";
+       sha256 = "a65f0934221cbec4a53205cc965d3fd3875512cd254ee6619102e407ca0fbcd5";
        libraryHaskellDepends = [ base bytestring containers mtl ];
        homepage = "https://bitbucket.org/dibblego/semigroup/";
        description = "A semigroup";
@@ -14030,7 +14050,7 @@ self: {
      mkDerivation {
        pname = "SeqAlign";
        version = "0.1.0.0";
-       sha256 = "0vk63ni1a93win8if032nps5y0xi245cmjqq2j4xfsdddg5bdln5";
+       sha256 = "c5d2b6ca6bad69d7891418cbca0a11b1035ff4b5620017918d7c2415a21d666e";
        libraryHaskellDepends = [ base bytestring vector ];
        description = "Sequence Alignment";
        license = stdenv.lib.licenses.bsd3;
@@ -14044,7 +14064,7 @@ self: {
      mkDerivation {
        pname = "SessionLogger";
        version = "0.3.0.0";
-       sha256 = "1zgjslf9p64aa7dwww44jq2f6iic1192ic98gmjsjj5ww8anl8c3";
+       sha256 = "83216a15e2bc48a9657d28b12852082c46e304968470cedb518a989b1cd5f2fd";
        libraryHaskellDepends = [
          base directory filepath hslogger mtl old-locale random time
        ];
@@ -14061,7 +14081,7 @@ self: {
      mkDerivation {
        pname = "ShellCheck";
        version = "0.3.8";
-       sha256 = "06k5adw28abdfpvfjq0zka05211w6nlbf1ry3d9hck3jcrqvg1f1";
+       sha256 = "c185b77166724c06531b3e07b7a8353c0451809a1f60e9f6756d29247853651a";
        isLibrary = true;
        isExecutable = true;
        libraryHaskellDepends = [
@@ -14085,7 +14105,7 @@ self: {
      mkDerivation {
        pname = "Shellac";
        version = "0.9.5.2";
-       sha256 = "1js9la0hziqsmb56q9kzfycda2sw3xm4kv2y5q2h3zlw5gzc5xli";
+       sha256 = "91f6c2fe2b9cfe01052e5eec496a1f5c0bd598777f266ccaaa1ac70f81a249cb";
        libraryHaskellDepends = [ base directory mtl unix ];
        homepage = "http://rwd.rdockins.name/shellac/home/";
        description = "A framework for creating shell envinronments";
@@ -14098,7 +14118,7 @@ self: {
      mkDerivation {
        pname = "Shellac-compatline";
        version = "0.9.5.2";
-       sha256 = "134m0krbd3vlswjxdfvv9xy9x962g7ksg1mqmmgczss9ph2dx08i";
+       sha256 = "1181de04bc49ebcf5eadb886a7e779c2a49e7c4f7bbbd625d7748fb6f204958c";
        libraryHaskellDepends = [ base Shellac Shellac-editline ];
        homepage = "http://rwd.rdockins.name/shellac/home/";
        description = "\"compatline\" backend module for Shellac";
@@ -14111,7 +14131,7 @@ self: {
      mkDerivation {
        pname = "Shellac-editline";
        version = "0.9.5.2";
-       sha256 = "14x4w4msh99c8vzhlv88ixb8yx43k178qz7504na68820389l9ah";
+       sha256 = "50259ad0000221a32c01e57c8c4e9883748f568f086d0aff462c25a82be1a493";
        libraryHaskellDepends = [ base editline Shellac ];
        homepage = "http://rwd.rdockins.name/shellac/home/";
        description = "Editline backend module for Shellac";
@@ -14124,7 +14144,7 @@ self: {
      mkDerivation {
        pname = "Shellac-haskeline";
        version = "0.2.0.2";
-       sha256 = "0q70d5arw1yg0f8b6p3k0g3i4jbh2d8rp1cchswd3ynhinzhrnqg";
+       sha256 = "0fdb0cbf8dd0fad1b8868c859b5113704912c703735cb39003cf079e5569e060";
        libraryHaskellDepends = [ base haskeline mtl Shellac ];
        jailbreak = true;
        description = "Haskeline backend module for Shellac";
@@ -14137,7 +14157,7 @@ self: {
      mkDerivation {
        pname = "Shellac-readline";
        version = "0.9.5.2";
-       sha256 = "0248zzp40gadcc4xkr5dmjc4phq0xz9j4sirdncnr62y3pi4zi0n";
+       sha256 = "16c44fe21d5e986c996d396a22d3ef00c34b98acade4d909634d3d40eeff8808";
        libraryHaskellDepends = [ base readline Shellac ];
        homepage = "http://rwd.rdockins.name/shellac/home/";
        description = "Readline backend module for Shellac";
@@ -14150,7 +14170,7 @@ self: {
      mkDerivation {
        pname = "ShowF";
        version = "0.1.1";
-       sha256 = "1nq4i4h43nfh86f6wgwng1ps6mcdl1ba96x9wsjl3qzn3blavyfh";
+       sha256 = "d0f9ade81af6e341a5e6a99ba456a08d55a36f78963f6e9c41d0d941208904db";
        libraryHaskellDepends = [ base ];
        homepage = "https://github.com/conal/ShowF/";
        description = "Show for * -> *";
@@ -14162,7 +14182,7 @@ self: {
      mkDerivation {
        pname = "Shrub";
        version = "0.1.0.0";
-       sha256 = "105rnyrqzagfgbfdxbdx4wqhvdfxkd8d5jaxkyqd1zyvf0chi858";
+       sha256 = "a8a0081970dbffd0b09f5dc9d2509bddb50d3127bdaddedc7aeea98fb3b7b980";
        libraryHaskellDepends = [ base ];
        description = "4-way trie fuzzy search";
        license = stdenv.lib.licenses.bsd3;
@@ -14173,7 +14193,7 @@ self: {
      mkDerivation {
        pname = "Shu-thing";
        version = "1.1.3";
-       sha256 = "185vcxd3qvii9k0134j634x6znvk7v83sj24a4dnw7jjsax0kqiv";
+       sha256 = "3be209bad2521e6e1b5144483dd03e73db6f3a19469211c04c316e3c5a67bba0";
        isLibrary = false;
        isExecutable = true;
        executableHaskellDepends = [ base GLUT ];
@@ -14187,7 +14207,7 @@ self: {
      mkDerivation {
        pname = "SimpleAES";
        version = "0.4.2";
-       sha256 = "0s85xgwrhldyr2w3kcn9f72yjajmpz3d4dizq9p9z97rx4qva4vj";
+       sha256 = "7213b531e9f9a49f6ec23f36d2c6bf552ae9c571c9b239b8c8be5198f9eb0569";
        libraryHaskellDepends = [ base binary bytestring mwc-random ];
        description = "Fast AES encryption/decryption for bytestrings";
        license = stdenv.lib.licenses.bsd3;
@@ -14198,7 +14218,7 @@ self: {
      mkDerivation {
        pname = "SimpleEA";
        version = "0.2.1";
-       sha256 = "0qimm9y138jjnzy5i6s5b7899rkxahk7p2kcwfry0gdq2pcb68vr";
+       sha256 = "7923b3d815b83de0b3e36c8a7b26547de694d059459b58fcb752a2117caa3562";
        libraryHaskellDepends = [
          base mersenne-random-pure64 MonadRandom
        ];
@@ -14213,7 +14233,7 @@ self: {
      mkDerivation {
        pname = "SimpleGL";
        version = "0.9.3";
-       sha256 = "0c674q5jiqvscc53m0z5vkmljla29pcll15gbvxr86pqxwmqm5hr";
+       sha256 = "19968a2beff81a94fb5eaf044ad94d425149ebdce5833a0a637ae3280b26c730";
        libraryHaskellDepends = [
          base GLFW JuicyPixels OpenGL SimpleH vector
        ];
@@ -14230,7 +14250,7 @@ self: {
      mkDerivation {
        pname = "SimpleH";
        version = "1.2";
-       sha256 = "0g05yplsm65xmx7brdcqy5kc8qcmzj96vywicwqpmigcv8pi9zmc";
+       sha256 = "acfe142fdaecc57a316791fb6d92fc9561c466f198b5bc4eafbd98aae9f5053c";
        libraryHaskellDepends = [
          base bytestring clock containers cpu directory filepath network
          time unix
@@ -14250,7 +14270,7 @@ self: {
      mkDerivation {
        pname = "SimpleLog";
        version = "0.1.0.3";
-       sha256 = "12fjdmaxcpgp13gr1s25ybb5fysvbcg40j9yb29wvpbmf67xrsbw";
+       sha256 = "7ce9dc8f7175ddcd93583e49401e5b5b7b57d6f245e890df08f75dd6556dd289";
        libraryHaskellDepends = [
          ansi-terminal attoparsec base bytestring containers directory
          ForkableT monad-control mtl old-locale resourcet semigroups stm
@@ -14267,7 +14287,7 @@ self: {
      mkDerivation {
        pname = "SizeCompare";
        version = "0.1";
-       sha256 = "0f53vggmc1ysi1rn8zd2kafi45w20d6j7iv1jgnrqy7izpah91a7";
+       sha256 = "478504d5fdf1789ced9361c7234d038217129d9aa27d647388da0756dfdba338";
        libraryHaskellDepends = [ base containers ];
        description = "Fast size comparison for standard containers";
        license = "GPL";
@@ -14280,7 +14300,7 @@ self: {
      mkDerivation {
        pname = "Smooth";
        version = "0.1.0.1";
-       sha256 = "0rwl5dw1vpgszhs7pjk146kp8h8n3ggvpby9y18fr7zsqgsckzcd";
+       sha256 = "8dfdc9f4c3fa9fec50f0c9afbbdf1b164174a72161ca7b34fcfadd1d782b9467";
        libraryHaskellDepends = [
          base containers DifferenceLogic FirstOrderTheory HUnit Proper
        ];
@@ -14295,7 +14315,7 @@ self: {
      mkDerivation {
        pname = "SmtLib";
        version = "0.1.0.0";
-       sha256 = "0wmdzl3anbbfqik2kl2wjy57cd9r3ix8h8g28rmzqbvlajrvqcv1";
+       sha256 = "6133bcb354742ffc6b46e221887a1c3935768a975cd02966c46e2dab06fdad72";
        libraryHaskellDepends = [ base parsec transformers ];
        jailbreak = true;
        homepage = "https://github.com/MfesGA/HsmtlibParser";
@@ -14311,7 +14331,7 @@ self: {
      mkDerivation {
        pname = "Snusmumrik";
        version = "0.0.1";
-       sha256 = "1f4d493hnv7fag9c2p2hnm0kc6b705z7mgdk4z6s4g24536j4ksk";
+       sha256 = "534f22cd28443ca2cd27b3bd7a7e0167193641b5505cc1d253ee6c0b47228db8";
        isLibrary = false;
        isExecutable = true;
        executableHaskellDepends = [
@@ -14335,7 +14355,7 @@ self: {
      mkDerivation {
        pname = "SoOSiM";
        version = "0.2.1.0";
-       sha256 = "0ghblkhf942gcidsvah8z6wigymzfng1010mp17pvacizamakcmp";
+       sha256 = "b7b2a9aafa91a97d4fb81504109e75bffa17b9f908aaad5b644f90e4e0a40b3e";
        libraryHaskellDepends = [
          base concurrent-supply containers monad-coroutine mtl stm
          transformers
@@ -14354,7 +14374,7 @@ self: {
      mkDerivation {
        pname = "SoccerFun";
        version = "0.5.2";
-       sha256 = "0xwgj4k1gn84sb8jc2nyxnvfp8sdmy4x5428fpvmn6n6ca8h6f17";
+       sha256 = "2738039162c61a5bf7754890d289af4da3ebb6edde0a26d1d204d91726918f77";
        isLibrary = true;
        isExecutable = true;
        libraryHaskellDepends = [
@@ -14375,7 +14395,7 @@ self: {
      mkDerivation {
        pname = "SoccerFunGL";
        version = "0.5.1";
-       sha256 = "1rzqibia10pl4yy64g5pqiqidhn109z0hlf38z3s57hx2zqqi9if";
+       sha256 = "2ea688f1171d9ea2c747c351087e02c1c21671c4b73c62bc27f482a0e28af8e7";
        isLibrary = true;
        isExecutable = true;
        libraryHaskellDepends = [
@@ -14394,7 +14414,7 @@ self: {
      mkDerivation {
        pname = "Sonnex";
        version = "0.1.0.3";
-       sha256 = "0fqaw4wh7ml35kl75qsvqsq17g5pndf7x6clcmqxpwayjn2syzda";
+       sha256 = "aa7daf85955ef1db716594997e5cb3b7bc13b0c65be372e82c83d60339e10a3b";
        libraryHaskellDepends = [ base ];
        testHaskellDepends = [ base QuickCheck ];
        jailbreak = true;
@@ -14410,7 +14430,7 @@ self: {
      mkDerivation {
        pname = "SourceGraph";
        version = "0.7.0.6";
-       sha256 = "03psglm6xyqvcgnbimidafy51kwpipk5q6s8ip5vhjm2d5makkhm";
+       sha256 = "15cea96a69a24ab8cb8d481b5ce68d97cf50bc532dd6b8ec631bfb6e2a7dfa0e";
        isLibrary = false;
        isExecutable = true;
        executableHaskellDepends = [
@@ -14430,7 +14450,7 @@ self: {
      mkDerivation {
        pname = "Southpaw";
        version = "0.1.0.2";
-       sha256 = "1zijb1b6ryrmq2230i1fr7iqz8iax9f2rwpy75fkggiknrd4xnpq";
+       sha256 = "f8da4e5ab633be375d39fef22c5cea2aa28fe3c92e443084c035fb6c565832fe";
        libraryHaskellDepends = [
          ALUT base bytestring cairo containers filepath GLFW-b gtk3
          JuicyPixels OpenAL OpenGL vector Win32
@@ -14445,7 +14465,7 @@ self: {
      mkDerivation {
        pname = "SpaceInvaders";
        version = "0.4.2";
-       sha256 = "1idy95ym336c19rcvvrm8j9lgf77bs10hhmrnw2jc55m1z93m683";
+       sha256 = "03993ad20fb5142605b7b94208825ee7b847934435efcd720acc8c517d49bec5";
        isLibrary = false;
        isExecutable = true;
        executableHaskellDepends = [ array base HGL random Yampa ];
@@ -14462,7 +14482,7 @@ self: {
      mkDerivation {
        pname = "SpacePrivateers";
        version = "0.1.0.0";
-       sha256 = "0gj709knv4lvz34900jigb1hiq35acbbl86iwa5yszibm8f0drkh";
+       sha256 = "70e6061caa2b7eed8be2d120ba165365e008c37a510290c8f89b926d6702473e";
        revision = "1";
        editedCabalFile = "b59d607892ad860616cef196c83ff54388204102eae597acf88467a2f54764bf";
        isLibrary = false;
@@ -14483,7 +14503,7 @@ self: {
      mkDerivation {
        pname = "SpinCounter";
        version = "0.0.1";
-       sha256 = "1rf9r69a2k3qfmy2nvwm3gdimncjglsv698rdc8i8gnjwrr0c1i2";
+       sha256 = "22060672e6d23e14116b1925b3357d92d91adb1b956f2b7c75784ca192c9c9e5";
        libraryHaskellDepends = [ base monad-loops ref-mtl stm ];
        jailbreak = true;
        homepage = "https://github.com/Julek";
@@ -14502,8 +14522,8 @@ self: {
      }:
      mkDerivation {
        pname = "Spock";
-       version = "0.7.12.0";
-       sha256 = "05vglqzf75dphxx2wnkxqn7aqcb19nh8g560zfpw56jrfbbmygwg";
+       version = "0.8.0.0";
+       sha256 = "04a0a66eb9cb6cc1528e3989e5b54378079ee9919412bc54015a3919603b7e3a";
        libraryHaskellDepends = [
          aeson base base64-bytestring bytestring case-insensitive containers
          directory hashable http-types hvect list-t monad-control mtl
@@ -14512,7 +14532,7 @@ self: {
          unordered-containers vault wai wai-extra warp
        ];
        testHaskellDepends = [
-         base hspec hspec-wai http-types reroute stm text wai
+         base bytestring hspec hspec-wai http-types reroute stm text wai
        ];
        homepage = "http://www.spock.li";
        description = "Another Haskell web framework for rapid development";
@@ -14524,7 +14544,7 @@ self: {
      mkDerivation {
        pname = "Spock-auth";
        version = "0.2.0.1";
-       sha256 = "1vcrl5dqjn0ri9ybza2yv80xvbv2iwrz5hj5rbhgy6i803ixlpx0";
+       sha256 = "a05fdae300281affe0ca45c2f2338f62afdd01da5ea8bf7c8a1958895ba199ed";
        libraryHaskellDepends = [ base http-types Spock text time ];
        jailbreak = true;
        homepage = "https://github.com/agrafix/Spock-auth";
@@ -14540,7 +14560,7 @@ self: {
      mkDerivation {
        pname = "Spock-digestive";
        version = "0.1.0.1";
-       sha256 = "13766v5y43jmdh7m3q1790ppw2chwg3g29dfh1zacxw7n1gmhlyl";
+       sha256 = "d453585fb08777a67e80ae25f1c6e390097e2f4827e0510f6c550ee2cb36e68c";
        libraryHaskellDepends = [
          base digestive-functors http-types mtl Spock text
          unordered-containers wai
@@ -14557,7 +14577,7 @@ self: {
      mkDerivation {
        pname = "Spock-worker";
        version = "0.2.1.3";
-       sha256 = "0pxh7ccqb6xpab0807vsfb65lk4bafa44fram1f4d84slggyn1a1";
+       sha256 = "4105ebdfa39aa0465ca82a3b4294538b4c5acc727a1f80c052b79b85193bb05f";
        libraryHaskellDepends = [
          base containers lifted-base mtl Spock stm text time transformers
          vector
@@ -14573,7 +14593,7 @@ self: {
      mkDerivation {
        pname = "SpreadsheetML";
        version = "0.1";
-       sha256 = "14d3fk0cal0svb2clbhbbk48fygwvb0k01aawfm72576mrz9mb18";
+       sha256 = "28ac9a7eaee61471aae34a0530c1dafc7987c85c0b2ecac4da1a50c5c074a391";
        libraryHaskellDepends = [ base xml ];
        description = "Write support for Excel's SpreadsheetML format";
        license = stdenv.lib.licenses.bsd3;
@@ -14584,7 +14604,7 @@ self: {
      mkDerivation {
        pname = "Sprig";
        version = "0.1.1";
-       sha256 = "06jxs1hc69viv38nvafhn8ilj3xn2j9k543abgd8p69gc95w1lbn";
+       sha256 = "76d1c04b622f998bda5b6a90329314b60f4923b2d0a96dd1d87127c360d05d1a";
        libraryHaskellDepends = [ base SDL ];
        homepage = "http://liamoc.net/static/Sprig";
        description = "Binding to Sprig";
@@ -14597,7 +14617,7 @@ self: {
      mkDerivation {
        pname = "Stasis";
        version = "0.0.1";
-       sha256 = "1pycmc30hg7vzf3addl0kdd74hpamzg3c1z4fj6fzr4542afhcq8";
+       sha256 = "0833e8942085e4ef8c74e40736deafea42725a9b80b6a686fbfb3c0806abccdf";
        isLibrary = true;
        isExecutable = true;
        libraryHaskellDepends = [ base containers ];
@@ -14613,7 +14633,7 @@ self: {
      mkDerivation {
        pname = "StateVar";
        version = "1.1.0.1";
-       sha256 = "1ap51cvwq61xckx5hw44l82ihbxvsq3263xr5hqg42c5qp67kbhf";
+       sha256 = "0eae79ccc58509f2302cb90f2306d6bb2f1805a2847058fa643d18cc370be5aa";
        libraryHaskellDepends = [ base stm transformers ];
        homepage = "https://github.com/haskell-opengl/StateVar";
        description = "State variables";
@@ -14625,7 +14645,7 @@ self: {
      mkDerivation {
        pname = "StateVar-transformer";
        version = "1.0.0.0";
-       sha256 = "1dbpxwjz6yf4ap20wm5ngvd0i0knkjsdahmd90ymddqj82v8w3d0";
+       sha256 = "a00d8eb64012b7563d48ad42d5b49c768208da7eb6540ec455c479f325ef77b5";
        libraryHaskellDepends = [ base mtl transformers ];
        homepage = "http://github.com/seagull-kamome/StateVar-transformer";
        description = "State variables";
@@ -14637,7 +14657,7 @@ self: {
      mkDerivation {
        pname = "StatisticalMethods";
        version = "0.0.0.1";
-       sha256 = "1h90i6crknxv23zryqi7mfzg65g1ydv62mza1hiri66jlmdahir6";
+       sha256 = "2647a85aa5d29898230cea576176f3e115f3beab27629fff10bbdb99998920c1";
        libraryHaskellDepends = [ base statistics tuple vector ];
        homepage = "http://www.tbi.univie.ac.at/~choener/Haskell/";
        description = "Collection of useful statistical methods";
@@ -14651,7 +14671,7 @@ self: {
      mkDerivation {
        pname = "Stomp";
        version = "0.1.1";
-       sha256 = "0fdibnhab5j03df70pfg9psk6ah80a91ds4nmlb0rdlldddbi3wn";
+       sha256 = "968fb85a6b94b60c16ad96e8169202082a33f54dcf5d705c1b4096a5a05db139";
        libraryHaskellDepends = [
          base binary bytestring network time utf8-string
        ];
@@ -14666,7 +14686,7 @@ self: {
      mkDerivation {
        pname = "Strafunski-ATermLib";
        version = "1.6.0.3";
-       sha256 = "1cicz4d5kyl9j4y3p79m3fk56vcqk3220a6y536dw525x6180dzw";
+       sha256 = "fc378082e94514decc28de2820c498986d53a61b359d3b3c9189fa591af92cb2";
        libraryHaskellDepends = [ base containers ];
        jailbreak = true;
        description = "An abstract data type designed for the exchange of tree-like data structures";
@@ -14680,7 +14700,7 @@ self: {
      mkDerivation {
        pname = "Strafunski-Sdf2Haskell";
        version = "1.0.0.2";
-       sha256 = "0h73yj74pl0k3p7vamqhw1jz36pvh8kfpw58gkmskdmkh7j6wb30";
+       sha256 = "602c6ee481b3b6a9eb7ca8f0eb2682fb9af165e01057b5cf1d13d04b8ef4e340";
        isLibrary = false;
        isExecutable = true;
        executableHaskellDepends = [
@@ -14698,7 +14718,7 @@ self: {
      mkDerivation {
        pname = "Strafunski-StrategyLib";
        version = "5.0.0.8";
-       sha256 = "09k9lcrrdzj6p7ywagc6mw17g4x9i743np36p4dkdp37q48j0mac";
+       sha256 = "4c552011c167dc361bb9665c3bc889a9937702af863dc5fdb946fe9633a36926";
        libraryHaskellDepends = [ base directory mtl syb transformers ];
        description = "Library for strategic programming";
        license = stdenv.lib.licenses.bsd3;
@@ -14711,7 +14731,7 @@ self: {
      mkDerivation {
        pname = "StrappedTemplates";
        version = "0.2.0.2";
-       sha256 = "0x0nsrzb2r9pwp353ksxwik48iw17whmsclfj07qrqxchdwrjy6h";
+       sha256 = "d078997983ace38c0f908e325d213f81474466e45dcf51c6e53765b17ed61674";
        libraryHaskellDepends = [
          base blaze-builder bytestring containers filemanip filepath mtl
          parsec text transformers
@@ -14728,7 +14748,7 @@ self: {
      mkDerivation {
        pname = "StrategyLib";
        version = "4.0.0.0";
-       sha256 = "1sskndywpm1gi4bs4i1gah73jk49inlscg4jzcqhq0phb8f886xk";
+       sha256 = "b31b841c5af0020c31fb923ca6a98d894c390e542f44a217892fd4cb7db353eb";
        libraryHaskellDepends = [ base mtl ];
        homepage = "http://naesten.dyndns.org:8080/repos/StrategyLib";
        license = stdenv.lib.licenses.unfree;
@@ -14739,7 +14759,7 @@ self: {
      mkDerivation {
        pname = "Stream";
        version = "0.4.7.2";
-       sha256 = "1l87l0kl4awzdyx6b28npwy6xf03r39d89iharsh06zgnd4y42wr";
+       sha256 = "990be249b3ef1b0075563026d4d2c803b86e3cbf168965ba6f9f2b4227a007d1";
        libraryHaskellDepends = [ base lazysmallcheck QuickCheck ];
        description = "A library for manipulating infinite lists";
        license = stdenv.lib.licenses.bsd3;
@@ -14750,7 +14770,7 @@ self: {
      mkDerivation {
        pname = "StrictBench";
        version = "0.1.1";
-       sha256 = "1l4l77rjhl5g9089kjyarsrvbvm43bk370ld50qp17dqhvisl73m";
+       sha256 = "751caae386b89d7031288d8233e61aa4eeb5b3cecacb991048af5028f33994d0";
        libraryHaskellDepends = [ base benchpress parallel ];
        homepage = "http://bonsaicode.wordpress.com/2009/06/07/strictbench-0-1/";
        description = "Benchmarking code through strict evaluation";
@@ -14766,7 +14786,7 @@ self: {
      mkDerivation {
        pname = "SuffixStructures";
        version = "0.0.1.0";
-       sha256 = "0s294s06pj95i6q8n1cxsgkdc7x98mvvr1qd720rxqd3y54n63lb";
+       sha256 = "8b0e6349f1a3e19e81380d87bc7745a91fd6e6d39d058bb08925c96b80264968";
        isLibrary = true;
        isExecutable = true;
        libraryHaskellDepends = [
@@ -14789,7 +14809,7 @@ self: {
      mkDerivation {
        pname = "SybWidget";
        version = "0.5.6";
-       sha256 = "0m3papl90fs3zmlqxsjn0cymk049352cl42bif2x7gij75cv2b68";
+       sha256 = "c82cb1593932bed3858b4b10ca44198980593d0356ea8e69fd433b90e8557754";
        libraryHaskellDepends = [
          base containers mtl syb-with-class template-haskell TypeCompose
        ];
@@ -14805,7 +14825,7 @@ self: {
      mkDerivation {
        pname = "SyntaxMacros";
        version = "1.0.3";
-       sha256 = "155vkv7kg026zc2crywdyna1df98mw41qm0sadqihaj49xk59vyc";
+       sha256 = "ccef54664f442a1871531a541c08af28b91694f58dfbcc04fb468037cf9ebb94";
        libraryHaskellDepends = [
          AspectAG base containers HList ListLike template-haskell TTTAS
          uu-parsinglib uulib
@@ -14824,7 +14844,7 @@ self: {
      mkDerivation {
        pname = "Sysmon";
        version = "0.1.2";
-       sha256 = "1zyp333vicjarcmip2q52nzfv948yl2q6qr3k3glp4v4m8f75ap3";
+       sha256 = "e3aa721caa64934bdf9823638305f588a4edbe15058b1b2bcb4ab2b8c718d7ff";
        libraryHaskellDepends = [
          base ConfigFile filepath fingertree Glob MissingH mtl old-locale
          pretty statistics template-haskell time vector
@@ -14842,7 +14862,7 @@ self: {
      mkDerivation {
        pname = "TBC";
        version = "0.0.3";
-       sha256 = "1063ckv034mb6s41xy8pr387y1hnknkyk4r29vmzdrm3pdcyzdn3";
+       sha256 = "c3b6ef59bba3e6f6eb4e2293e9a79d16067fd0c817f91e8836ab9201f664c380";
        isLibrary = true;
        isExecutable = true;
        libraryHaskellDepends = [
@@ -14863,7 +14883,7 @@ self: {
      mkDerivation {
        pname = "TBit";
        version = "0.4.2.3";
-       sha256 = "1by1wy2w3ankg1php7m911kc53q2dv5jfl8v1iwp3mb68s8b6wrs";
+       sha256 = "3a73b3904666d571790c1b5127cb6e028fc26608a99e0b6f78d3aac185e7c1af";
        libraryHaskellDepends = [
          base containers deepseq fgl free hmatrix integration list-extras
          mtl numeric-tools parallel
@@ -14880,7 +14900,7 @@ self: {
      mkDerivation {
        pname = "TCache";
        version = "0.12.0";
-       sha256 = "0marslz5jg66r3i2d0yjjrj11bpywpadcxs5k4j6782iczxybd7s";
+       sha256 = "fab4e5fb6751a06324994577d6d4e5feae106496d28326e2c8c63c593ed55955";
        libraryHaskellDepends = [
          base bytestring containers directory hashtables mtl old-time
          RefSerialize stm text
@@ -14894,7 +14914,7 @@ self: {
      mkDerivation {
        pname = "TTTAS";
        version = "0.6.0";
-       sha256 = "18p3rxh3g44ky5q4hjq53l4shg4gd8v68wra6bdxv8bjafxld1wp";
+       sha256 = "978746bb5372a1dddb322a7364366a8f3ca8091d054b4870f193903760cfe3a2";
        libraryHaskellDepends = [ base ];
        homepage = "http://www.cs.uu.nl/wiki/bin/view/Center/TTTAS";
        description = "Typed Transformations of Typed Abstract Syntax";
@@ -14906,7 +14926,7 @@ self: {
      mkDerivation {
        pname = "TV";
        version = "0.5.0";
-       sha256 = "0vz9j5vjypnkbzld18f6kczfj54disf43x5052s4n7gqzsjxpxvb";
+       sha256 = "6bf7dba5fef81d4bb428a0f4419c8e8d14e93e9bc6a1d0e85fd35e2f7791e96f";
        libraryHaskellDepends = [ base DeepArrow TypeCompose ];
        homepage = "http://haskell.org/haskellwiki/TV";
        description = "Tangible Values -- composable interfaces";
@@ -14920,7 +14940,7 @@ self: {
      mkDerivation {
        pname = "TYB";
        version = "0.2.3";
-       sha256 = "1rdwj6dg156i60i7s8xr310j0yza41jjqk6pmgx2giqjs122dz5n";
+       sha256 = "b6fc2644d012c727faabd74c2c6520ea7b204118b9237d2230d194f09a91bce5";
        libraryHaskellDepends = [
          array base containers mtl template-haskell transformers
        ];
@@ -14936,7 +14956,7 @@ self: {
      mkDerivation {
        pname = "TableAlgebra";
        version = "0.7.1";
-       sha256 = "1jqkjnyznklyiy2shm4c9gix267war1hmsjncdmailhca41fs4bz";
+       sha256 = "7f11ed02510cd2a86a6356ea0a4356fc18d1e34b8c54a8858f9e4efbbd9513cb";
        libraryHaskellDepends = [
          base containers HaXml mtl pretty template-haskell
        ];
@@ -14949,7 +14969,7 @@ self: {
      mkDerivation {
        pname = "Tables";
        version = "0.1.0.2";
-       sha256 = "02a6awbqwhmv7c74lgbp35ykqn31mgwp7ffd0j4rs42vv1a4ffkr";
+       sha256 = "793a4754d85b109d8904cdb973f9ab61583c7d19773d4a0e3bbb428e17574609";
        isLibrary = false;
        isExecutable = true;
        executableHaskellDepends = [ base cookbook ];
@@ -14964,7 +14984,7 @@ self: {
      mkDerivation {
        pname = "Tablify";
        version = "0.8.2";
-       sha256 = "10w3idjhrgmkrkjblrmb2wb2s2fg657nw5rmg5k147wrgrkzbsz3";
+       sha256 = "e3ebf5677e991f12667935176e4f31cf092d1617ab66bae4ccb3be0c658b8383";
        isLibrary = false;
        isExecutable = true;
        executableHaskellDepends = [ base parsec xhtml ];
@@ -14978,7 +14998,7 @@ self: {
      mkDerivation {
        pname = "Tainted";
        version = "0.1.0.2";
-       sha256 = "1mjr81z42qhwa6njlvlsslpzbbpiab88ns8g8amskwv159gk6mlb";
+       sha256 = "8b56335f2a61f3a9ab420f698bd052f1aef52fd59a6e2aad511c62417e4059d6";
        libraryHaskellDepends = [ base mtl ];
        homepage = "https://github.com/RossMeikleham/Tainted";
        description = "Tainted type, and associated operations";
@@ -14990,7 +15010,7 @@ self: {
      mkDerivation {
        pname = "Takusen";
        version = "0.8.7";
-       sha256 = "0mxck66rz6lplgcl3a3i0gaybc2ki0q7wfilhkp2f3h3m50fg7wy";
+       sha256 = "9e9fe740a9030e27ee84343a7e308853b0e5d50371a841d9a3979a9f8d99ac57";
        isLibrary = true;
        isExecutable = true;
        libraryHaskellDepends = [ base mtl old-time time ];
@@ -15005,7 +15025,7 @@ self: {
      mkDerivation {
        pname = "Tape";
        version = "0.4.0.0";
-       sha256 = "1d66l67cicn3q4a6glfxfkhc9cjm7vqi0bnyjad0bzyyv409j6bp";
+       sha256 = "77199900d9deff059a92de2e10f13e55b2c4e074ddd16714c1c3b2c88ea1c6b4";
        libraryHaskellDepends = [ base comonad distributive Stream ];
        jailbreak = true;
        homepage = "https://github.com/kwf/Tape";
@@ -15020,7 +15040,7 @@ self: {
      mkDerivation {
        pname = "TeaHS";
        version = "0.3.1";
-       sha256 = "1326lrpkw2gyn7y9px38gyzi2cnx87ki65r6mwds746d1s1zmmcn";
+       sha256 = "96d5fa830ecd90a31baf261713e741dd3211bf7f68f49bfcb1fe093e6fa6468c";
        libraryHaskellDepends = [
          array base containers mtl SDL SDL-image SDL-mixer SFont Sprig
        ];
@@ -15035,7 +15055,7 @@ self: {
      mkDerivation {
        pname = "Tensor";
        version = "1.1.0.1";
-       sha256 = "1q8infjcszbbfqybg1fv33fy33chyvj2nbj9d2sxvsixx57hm12m";
+       sha256 = "55840a4fe93deaddb568492e2be4f6908de1dd18db85b73c766b7dcda4b311e1";
        libraryHaskellDepends = [ base ];
        homepage = "https://github.com/svenpanne/Tensor";
        description = "Tensor data types";
@@ -15047,7 +15067,7 @@ self: {
      mkDerivation {
        pname = "TernaryTrees";
        version = "0.2.0.2";
-       sha256 = "06m4mi9cl16sfyn9wibb0ph32vhgf501adjq059s3hdlxr4acdwr";
+       sha256 = "9937a648eeb4c1a1530158361540710f6e31e0056b459eac77da04ca52aca41a";
        isLibrary = true;
        isExecutable = true;
        libraryHaskellDepends = [ base binary ];
@@ -15063,7 +15083,7 @@ self: {
      mkDerivation {
        pname = "TestExplode";
        version = "0.1.0.0";
-       sha256 = "0r4nwzwdila9p05g5y99rp06dbh1k2yl5jsc6yn6dwvxkvvdjcs1";
+       sha256 = "4133d9f69e7df366ac374ccb42bd9801ae66c0cd29f9f20ab849d1d8f8e79664";
        libraryHaskellDepends = [
          base containers directory fgl graphviz interpolatedstring-perl6 mtl
          process text
@@ -15079,7 +15099,7 @@ self: {
      mkDerivation {
        pname = "Theora";
        version = "1.0";
-       sha256 = "1gw97mxwb6ywc4qvfggjzsryl0m4g6g30ljx4xcvy6snfmgv00ig";
+       sha256 = "2f02b05f75561bbf59275d52309e79a402eab3fef23db73161dc9bc57b3d89bf";
        libraryHaskellDepends = [ base ];
        librarySystemDepends = [ ogg theora ];
        license = "GPL";
@@ -15091,7 +15111,7 @@ self: {
      mkDerivation {
        pname = "Thingie";
        version = "0.80";
-       sha256 = "0fl6pk2vp765gyzc4afjdg0lgbnh5v08gfbp0kzny4ng25bmxqwa";
+       sha256 = "8ae35e5711cf126fff0477b987c02ed0ae47c16bd229c2be7fc59cbbc5bc863a";
        libraryHaskellDepends = [ base cairo gtk mtl ];
        description = "Purely functional 2D drawing";
        license = stdenv.lib.licenses.bsd3;
@@ -15103,7 +15123,7 @@ self: {
      mkDerivation {
        pname = "ThreadObjects";
        version = "0.0";
-       sha256 = "0rpcv6kw351ykj36f83qdqygrhk4ylqlcgcswxl8gg1v33jaaqmz";
+       sha256 = "bf62a5e4183bbc8768e79a3d4631f564c2fc3c6e782067869c3e94c1a7d9ec66";
        libraryHaskellDepends = [ base ];
        description = "Mutable objects that reside in their own threads";
        license = stdenv.lib.licenses.gpl3;
@@ -15115,7 +15135,7 @@ self: {
      mkDerivation {
        pname = "Thrift";
        version = "0.6.0.1";
-       sha256 = "0yk496zql0jpyj83ybdzffc03sylf5pwn093k831m99j54l2r5yv";
+       sha256 = "db972c282932a51a069a2301cb6f71d4eb019873bf2d3f90f457028abf49647a";
        revision = "1";
        editedCabalFile = "56a8ab041685777391702f1475e5c2a3462b36765bd53de2e21e1f55aa5999d9";
        libraryHaskellDepends = [
@@ -15135,7 +15155,7 @@ self: {
      mkDerivation {
        pname = "TicTacToe";
        version = "0.0.1";
-       sha256 = "0542hripn5nlwdvnhkd9xzzh2b1x6alwnqxq877r92c7kqnlffw4";
+       sha256 = "843b472d9e878994cf41b863cba9323d2c01ffefa94d6877e3d4167b63868214";
        libraryHaskellDepends = [
          base containers HUnit QuickCheck test-framework
          test-framework-hunit test-framework-quickcheck2
@@ -15150,7 +15170,7 @@ self: {
      mkDerivation {
        pname = "TigerHash";
        version = "0.2";
-       sha256 = "02plz1y7lmvp3jpl5srsnx2nkl6yhhfn6pqj00szs688cahk2dik";
+       sha256 = "333631a1620819fd3500125f631d84ded06945b73aeb42af1c77577a7cf8f40a";
        libraryHaskellDepends = [ base binary bytestring dataenc ];
        description = "TigerHash with C implementation";
        license = stdenv.lib.licenses.gpl2;
@@ -15163,7 +15183,7 @@ self: {
      mkDerivation {
        pname = "TimePiece";
        version = "0.0.5";
-       sha256 = "1ylf4kzyf947szgib0ivkvygbinmy97nvy77d0crryzxdmccrzbj";
+       sha256 = "72fdcc586dfdfb9c1968e7f86d4ff2d5c6f5fc9e3b8215dfd78724e7ff248efa";
        isLibrary = true;
        isExecutable = true;
        libraryHaskellDepends = [
@@ -15184,7 +15204,7 @@ self: {
      mkDerivation {
        pname = "TinyLaunchbury";
        version = "1.0.1";
-       sha256 = "1xxadd8pqbgl0z8vrqn8fm6x0c9l2y3a7irjmjkh9750x6hdb4b9";
+       sha256 = "6991d5a0e9a09c04a7ac32c7a386173431d04d75c8e2bcd107f42d7c516baaf7";
        libraryHaskellDepends = [ base mtl ];
        description = "Simple implementation of call-by-need using Launchbury's semantics";
        license = stdenv.lib.licenses.bsd3;
@@ -15196,7 +15216,7 @@ self: {
      mkDerivation {
        pname = "TinyURL";
        version = "0.1.0";
-       sha256 = "0y8bl6w3ix2zjhm10wazgi70sr02ydc3hrwjbr6whk341n140wsh";
+       sha256 = "507340820d644cc84d5e92673858f302640d4e7c5f71102a945ff438b8a10b79";
        libraryHaskellDepends = [ base HTTP network ];
        description = "Use TinyURL to compress URLs";
        license = stdenv.lib.licenses.bsd3;
@@ -15208,7 +15228,7 @@ self: {
      mkDerivation {
        pname = "Titim";
        version = "0.2.3";
-       sha256 = "1s8zvb38r9pxh55d5206lijprc6xsqnr0j670sdjrw7n8gyn7vav";
+       sha256 = "5bed63fd43f6f02c9b06c748902dd6ddb07c65a40688d24a81fda68cc6da1fe9";
        isLibrary = false;
        isExecutable = true;
        executableHaskellDepends = [ base containers matrix random ];
@@ -15223,7 +15243,7 @@ self: {
      mkDerivation {
        pname = "Top";
        version = "1.7";
-       sha256 = "0ykicqwayja14z30hn5cy3c96sikqhbyrh0bcqykk9izwhxs339x";
+       sha256 = "3d8da13be43fa6393d660bc0ec17c4336a93d8f0ac5808c6274149af3866717a";
        isLibrary = true;
        isExecutable = true;
        libraryHaskellDepends = [ base containers mtl ];
@@ -15241,7 +15261,7 @@ self: {
      mkDerivation {
        pname = "Tournament";
        version = "0.0.1";
-       sha256 = "1yzgcsp3g5sfyxavq1firna5z5m9bnk9ddrbxxmpy1yydmj1n5jk";
+       sha256 = "53161b646dde077f6bef2bb796a65da9965f94cdd105bc55f74e9737ae66effb";
        libraryHaskellDepends = [ base containers mtl ];
        testHaskellDepends = [
          base containers mtl QuickCheck test-framework
@@ -15259,7 +15279,7 @@ self: {
      mkDerivation {
        pname = "TraceUtils";
        version = "0.1.0.2";
-       sha256 = "0la19yynd7bpswi9012hf0vl9c4fdnn8p6y0287xanmdcs9zqz16";
+       sha256 = "267cfc9366ad5ad50f12c09b8bac6d8eb044377050049022d7779d66bd4f4151";
        libraryHaskellDepends = [ base ];
        homepage = "https://github.com/Peaker/TraceUtils";
        description = "Functions that should have been in Debug.Trace";
@@ -15271,7 +15291,7 @@ self: {
      mkDerivation {
        pname = "TransformersStepByStep";
        version = "0.1.1.0";
-       sha256 = "1cd8sh6gi9zmvd70kzw1x9ycanfsyphjdy3r65xrph54ilwy511p";
+       sha256 = "3784e2398da4c09b7b3179f826e1f5da59c57cea81ff094edbf5a7f80cd4a8b1";
        isLibrary = false;
        isExecutable = true;
        executableHaskellDepends = [ base containers mtl ];
@@ -15285,7 +15305,7 @@ self: {
      mkDerivation {
        pname = "Transhare";
        version = "0.9";
-       sha256 = "04n1ld6h3q71iqnvwyabzj69vdy2x98w0drriyx13ykywbd31036";
+       sha256 = "668030dae27efa11ba8f3937c051eac2b79d8cfc4b79be2d8ee1e0014da3c112";
        libraryHaskellDepends = [ base containers ];
        description = "A library to apply transformation to containers so as to maximize sharing of unchanged subcomponents";
        license = stdenv.lib.licenses.bsd3;
@@ -15296,7 +15316,7 @@ self: {
      mkDerivation {
        pname = "TreeCounter";
        version = "0.0.2";
-       sha256 = "06ci4v8gflsgi73wrpqvhb7w3mdkbjgidhqf95yyk4wiga1mrzal";
+       sha256 = "54fd5c837a9193e97d490ec3169f5cb3d5c1cf821bdfccc7894f53f7d0269119";
        libraryHaskellDepends = [ base ref-mtl stm ];
        jailbreak = true;
        homepage = "https://github.com/Julek";
@@ -15309,7 +15329,7 @@ self: {
      mkDerivation {
        pname = "TreeStructures";
        version = "0.0.2";
-       sha256 = "1lcj166i8f7850fqjv7xqxdn6zwpdynzxn3bf243wdnwmnn5pysx";
+       sha256 = "5dfb5bacaddc363e88706bd8fead6f977f635bc7fd6c891d28e838148d0992d1";
        libraryHaskellDepends = [ base ];
        jailbreak = true;
        homepage = "http://www.github.com/bhickey/TreeStructures";
@@ -15322,7 +15342,7 @@ self: {
      mkDerivation {
        pname = "TreeT";
        version = "0.0";
-       sha256 = "0d1k4nblcnksh2j6b4v14r2xd2kn6cmqmyqhmy6wyz3kr0lyzxqd";
+       sha256 = "0df7ef29c8737ccf8daf10fb8a2b33768ad64526619365a4807a5a4697253334";
        libraryHaskellDepends = [ base containers transformers ];
        description = "Transformer for Data.Tree";
        license = stdenv.lib.licenses.publicDomain;
@@ -15333,7 +15353,7 @@ self: {
      mkDerivation {
        pname = "Treiber";
        version = "0.0.4";
-       sha256 = "09sd9p1y3zqkfahkp1vgdnlvgv1vnvdl7kdzccsd41h1h61fz3jd";
+       sha256 = "4d8eef82810106d23463bfcd43dbb63becb7a96d6f873ba17213ffe1c34d4d27";
        libraryHaskellDepends = [ base ghc-prim monad-loops ref-mtl stm ];
        jailbreak = true;
        homepage = "https://github.com/Julek";
@@ -15348,7 +15368,7 @@ self: {
      mkDerivation {
        pname = "TrendGraph";
        version = "0.1.0.1";
-       sha256 = "1rdlimlbdpa089knhnqzgxc8ngqag4m4w3r92jd95kwnmr8nizkp";
+       sha256 = "77fe6851ae96cf929a14290f4e2a790a3f8b587f1f5b68674240ddb6688db4e5";
        libraryHaskellDepends = [
          base containers diagrams-cairo diagrams-lib mtl
          optparse-applicative time
@@ -15367,7 +15387,7 @@ self: {
      mkDerivation {
        pname = "TrieMap";
        version = "4.1.0";
-       sha256 = "14wril1sa35cja66y7ah9qwr3bmsi985y7rlxyj12x2fv6dclpc4";
+       sha256 = "845dca9ad94e7411a4ef341f5f508abaae91394e501d6f8c92ac0ca5038d9993";
        libraryHaskellDepends = [
          base bytestring containers primitive template-haskell
          th-expand-syns transformers unpack-funcs vector
@@ -15384,7 +15404,7 @@ self: {
      mkDerivation {
        pname = "Twofish";
        version = "0.3.2";
-       sha256 = "1bv79582fxwgk255fhss6k8irb7mlbdvlvvx8jyzs16g3fyw1y5a";
+       sha256 = "aaf8c0bd1bcf04fdbd447d6fbadba2f5ac1cd1345a43578a988f7727504967af";
        libraryHaskellDepends = [
          array base binary bytestring cereal crypto-api largeword mtl tagged
        ];
@@ -15404,7 +15424,7 @@ self: {
      mkDerivation {
        pname = "TypeClass";
        version = "0.2.1";
-       sha256 = "0crymgw91xx0hblbmz488x39i2qzf9c15kv5x950ljmpyrhy5jhv";
+       sha256 = "1bcae261f6b74a0a4aea65cf1258721f8b98464788fcbae882a0f790f8ab3e33";
        isLibrary = false;
        isExecutable = true;
        executableHaskellDepends = [
@@ -15422,7 +15442,7 @@ self: {
      mkDerivation {
        pname = "TypeCompose";
        version = "0.9.10";
-       sha256 = "1wpldqdf6czl36fs4pvvj2z3kg1487sanqncp4rbmgrrhbfmqxxq";
+       sha256 = "b8775cdd8239bfba32b9cc62abf44124bc39be907b5fa29d19f433e31a6ef4f2";
        libraryHaskellDepends = [ base ];
        homepage = "https://github.com/conal/TypeCompose";
        description = "Type composition classes & instances";
@@ -15434,7 +15454,7 @@ self: {
      mkDerivation {
        pname = "TypeIlluminator";
        version = "0.0";
-       sha256 = "02ck7sik5wvh989k9ban1m2dlpfld0d0zs7sqb12m1f6wls7fghc";
+       sha256 = "0c3e7734e5c6852ac2c2fae80f1a68d45dda440d56ad34134a70f332a33e9309";
        isLibrary = false;
        isExecutable = true;
        executableHaskellDepends = [ base haskell98 ];
@@ -15449,7 +15469,7 @@ self: {
      mkDerivation {
        pname = "TypeNat";
        version = "0.4.0.0";
-       sha256 = "0v6xd98nwl7zg5q5xmlrgzsb3219vcwj8rfacdyzdb9xpq5l9dnv";
+       sha256 = "dbb6440bbe3dadf67d63ca652439db2988b1f47f99d65e7079ff506e516add6c";
        libraryHaskellDepends = [ base ];
        jailbreak = true;
        homepage = "https://github.com/avieth/TypeNat";
@@ -15463,7 +15483,7 @@ self: {
      mkDerivation {
        pname = "TypingTester";
        version = "0.2.0.0";
-       sha256 = "07qwvmdh5164v552qkk4fm66nlvb4dcv0wh5jircfgh7gsd60l6n";
+       sha256 = "d650609a7e073ec772940572b059236b536b4c75644e2c4ad9c484025bdd1c1f";
        isLibrary = false;
        isExecutable = true;
        executableHaskellDepends = [ base containers directory time ];
@@ -15479,7 +15499,7 @@ self: {
      mkDerivation {
        pname = "UISF";
        version = "0.3.0.2";
-       sha256 = "0i5kw450yk44kh25xbqzjwnjipzh81i20vk8il9ic2fh4d79va46";
+       sha256 = "86a89d4e23d00916138d686e206240f0df282d971faf5e049c844c0f0ae1b344";
        libraryHaskellDepends = [
          arrows base containers deepseq GLFW OpenGL stm transformers
        ];
@@ -15495,7 +15515,7 @@ self: {
      mkDerivation {
        pname = "UMM";
        version = "0.3.1";
-       sha256 = "0k9kvlkcznk6ydfcymzzh0a4j4zkl5iblvnx6fkmk8xah1qnkq5h";
+       sha256 = "b0e0697180aaa359a733dd6eba62a1f313491480ff57cf5cf366dacf26dd334d";
        isLibrary = false;
        isExecutable = true;
        executableHaskellDepends = [
@@ -15515,7 +15535,7 @@ self: {
      mkDerivation {
        pname = "URLT";
        version = "0.14";
-       sha256 = "14qlyrc3ins3lwhd2c8lyhm1j3v6nj4qgs5g9xys4w6hnndz2g3s";
+       sha256 = "7a3cf19bb5d070a27d4fafe88789b4660f192af41431d120a743db3858f61493";
        libraryHaskellDepends = [
          applicative-extras base Consumer happstack-server hsp hsx mtl
          QuickCheck regular template-haskell
@@ -15530,7 +15550,7 @@ self: {
      mkDerivation {
        pname = "URLb";
        version = "0.0.1";
-       sha256 = "1l62z7798bby4fbrz62ic802g8zah3flb2pmsd3ky7y5903s3nxr";
+       sha256 = "b9dba10748c51f3f47d3f58a45dd80eaa327006251989f97237e2d94cef9c2d0";
        libraryHaskellDepends = [ attoparsec base bytestring containers ];
        homepage = "http://github.com/solidsnack/URLb";
        description = "DEPRECATED A simple, liberal URL parser";
@@ -15544,7 +15564,7 @@ self: {
      mkDerivation {
        pname = "Unique";
        version = "0.4.2";
-       sha256 = "0riyn68bi6wxz2mhqlywva6a1ngfr4k3gglp12dkhcmllh5l3dc2";
+       sha256 = "82b5410ba4b432389b0897be3726c9eed9a08cdadc530cabf89d9bb890b13e66";
        libraryHaskellDepends = [
          base containers extra hashable unordered-containers
        ];
@@ -15559,8 +15579,8 @@ self: {
      }:
      mkDerivation {
        pname = "Unixutils";
-       version = "1.53";
-       sha256 = "0gh8fii9kc2nah5l0gv1pzlxdxgw962vgr1w9kc5wksf85hgyplr";
+       version = "1.54.1";
+       sha256 = "f9295529744cb2658364956f376ff506dc1876eb2b0148e5b09c1a4bc4732644";
        libraryHaskellDepends = [
          base bytestring directory exceptions filepath mtl process
          process-extras pureMD5 regex-tdfa unix zlib
@@ -15575,7 +15595,7 @@ self: {
      mkDerivation {
        pname = "Unixutils-shadow";
        version = "1.0.0";
-       sha256 = "11m8lgq2rjvh7j8si7sqixf4k4ns65jy0zp6apqp0xc23c1znyr7";
+       sha256 = "277bfb031b827570f155e67ee06531da92495c8f589fa8913c70cb2cf0a3a886";
        libraryHaskellDepends = [ base unix ];
        homepage = "http://src.seereason.com/haskell-unixutils-shadow";
        description = "A simple interface to shadow passwords (aka, shadow.h)";
@@ -15587,7 +15607,7 @@ self: {
      mkDerivation {
        pname = "Updater";
        version = "0.2";
-       sha256 = "03n2r02bgv9hzlvxypdy1mrvdmzrxlm717bf7qp9f9ky1sj3ixp4";
+       sha256 = "e4f638a40e7e26972e3e6e9d702aedf9d7b6730dbe5ddf37fd30edb704c8c20e";
        libraryHaskellDepends = [ base stm ];
        homepage = "https://github.com/yokto/Updater";
        description = "Monadic FRP library based on stm";
@@ -15599,7 +15619,7 @@ self: {
      mkDerivation {
        pname = "UrlDisp";
        version = "0.1.7";
-       sha256 = "1y21v5k7s9sj8z5r3czp5i80x40zvyqxzr1xl28ardwj5q5rrvzp";
+       sha256 = "f7ef9c0b2e92b7ac90a03de4dfb1df1f900e502cf7b391cb4752277d66d941f8";
        libraryHaskellDepends = [ base cgi MaybeT mtl ];
        jailbreak = true;
        homepage = "http://www.haskell.org/haskellwiki/UrlDisp";
@@ -15613,7 +15633,7 @@ self: {
      mkDerivation {
        pname = "Useful";
        version = "0.0.6";
-       sha256 = "01xb68qh29q6b0pdxvadqw7q1p855k14jdz1qjlhg6785n0qp954";
+       sha256 = "a4a48b812de89807a9c4e13749c22c05dd800fc74dedde2e580627013132ab07";
        libraryHaskellDepends = [ base containers random ];
        description = "Some useful functions and shorthands";
        license = stdenv.lib.licenses.bsd3;
@@ -15624,7 +15644,7 @@ self: {
      mkDerivation {
        pname = "UtilityTM";
        version = "0.0.4";
-       sha256 = "1mjy3w4sw32rbmm13yhmpidfsj91v3p58jvki16z0kzk3fswpa85";
+       sha256 = "05a9cbb51bf34ff04d88734b54eed82149ed5abc15fa116a5d590cae091f5ed6";
        libraryHaskellDepends = [ base ];
        homepage = "https://github.com/tonymorris/utility-tm";
        description = "Utility functions that are missing from the standard library";
@@ -15641,7 +15661,7 @@ self: {
      mkDerivation {
        pname = "VKHS";
        version = "0.5.4";
-       sha256 = "0621x6mqa1qplswirxnzpzn24520qvl5ii1wyvqm8nfb69sbqzpg";
+       sha256 = "ef7ebc7432cb5954f1f63cc458e8c6401422ecbfdff61cb9a6170785abe94118";
        isLibrary = true;
        isExecutable = true;
        libraryHaskellDepends = [
@@ -15662,7 +15682,7 @@ self: {
      mkDerivation {
        pname = "Validation";
        version = "0.2.0";
-       sha256 = "10smif8y5bgjiarag3ws131kwji32mlh6mqfnmmp20xf41fsm0z3";
+       sha256 = "e383aa5d20ae03716bb50e57036915234a3ec3089a8fa7b28af2ade2918b5583";
        libraryHaskellDepends = [
          base bifunctors semigroupoids semigroups
        ];
@@ -15677,7 +15697,7 @@ self: {
      mkDerivation {
        pname = "Vec";
        version = "1.0.5";
-       sha256 = "0hyk553pdn72zc1i82njz3md8ycmzfiwi799y08qr3fg0i8r88zm";
+       sha256 = "f523945104cf8d8c11f0299dc8a3fb9579d4eaf8d20a1403fbe2d8764729d343";
        libraryHaskellDepends = [ array base ghc-prim ];
        homepage = "http://github.net/sedillard/Vec";
        description = "Fixed-length lists and low-dimensional linear algebra";
@@ -15689,7 +15709,7 @@ self: {
      mkDerivation {
        pname = "Vec-Boolean";
        version = "1.0.6";
-       sha256 = "0zxxpychddmlrv7r190gn4dl282ak4qfk2d92l24qxi9fds1rshk";
+       sha256 = "13ea1c747329764c0415a989e930994a20411bb10fa490cfceb4b60699bfbd7f";
        libraryHaskellDepends = [ base Boolean Vec ];
        jailbreak = true;
        description = "Provides Boolean instances for the Vec package";
@@ -15702,7 +15722,7 @@ self: {
      mkDerivation {
        pname = "Vec-OpenGLRaw";
        version = "0.2.0.1";
-       sha256 = "0qsi1s8qp3fkr5alh2m7y1a1lm5xypjvmk174ywf0aga2y20bblm";
+       sha256 = "95ae058417ea29e0b82727ccbae5f5bd541a54f0a70a4855c9d38d8b910e5163";
        libraryHaskellDepends = [ base OpenGLRaw Vec ];
        homepage = "http://www.downstairspeople.org/darcs/Vec-opengl";
        description = "Instances and functions to interoperate Vec and OpenGL";
@@ -15715,7 +15735,7 @@ self: {
      mkDerivation {
        pname = "Vec-Transform";
        version = "1.1";
-       sha256 = "0jwi9kgij8xd0419nkksgffwcn94fz6ijdq8s29b771409a1pkfc";
+       sha256 = "cccd1b5402249cb392d0083719cd772459c69d7b7a4e9b0201ad2319df4c914b";
        homepage = "https://github.com/tobbebex/Vec-Transform";
        description = "This package is obsolete";
        license = stdenv.lib.licenses.bsd3;
@@ -15727,7 +15747,7 @@ self: {
      mkDerivation {
        pname = "VecN";
        version = "0.0.2";
-       sha256 = "1hv8idxv9gniwwjs67q75bbcc5ry9r05cxjmsxk0q54l8zscdss2";
+       sha256 = "42ebc6f44794140c66d7557656404e3e17c6d62a071fa325e7d1beb47b8b68c3";
        libraryHaskellDepends = [ base Peano ];
        description = "a simple peano-indexed vector type";
        license = stdenv.lib.licenses.bsd3;
@@ -15738,7 +15758,7 @@ self: {
      mkDerivation {
        pname = "ViennaRNA-bindings";
        version = "0.1.2.2";
-       sha256 = "06zz3svdsy6qzbj7s02sbifkprmm58r14ss46r6680c9ybw9w5l3";
+       sha256 = "83169ef8f28901644c36446b12322ab5e63b5d5c5a007de4fad878ddb61eff1b";
        libraryHaskellDepends = [ array base ];
        libraryToolDepends = [ c2hs ];
        homepage = "http://www.tbi.univie.ac.at/~choener/";
@@ -15751,7 +15771,7 @@ self: {
      mkDerivation {
        pname = "ViennaRNAParser";
        version = "1.2.5";
-       sha256 = "0kc3b49g52dh0a4q8v5ir7pwa0x8s6rclmqjhkj95v1070ag4w0f";
+       sha256 = "0e70f2143820ec92e4841257cab2d1a803c5efc9b16c848902b089f21259834d";
        libraryHaskellDepends = [ base parsec process ];
        testHaskellDepends = [ base hspec parsec ];
        description = "Libary for parsing ViennaRNA package output";
@@ -15763,7 +15783,7 @@ self: {
      mkDerivation {
        pname = "WAVE";
        version = "0.1.3";
-       sha256 = "1cgla9y1lwcsdad5qdspymd7s6skdw961fgzh02kvi7gjbrrcyi7";
+       sha256 = "277a96f392efc43d0580ffb960126f531b7d5af557375c9a6a9a711a7c52f4b1";
        isLibrary = true;
        isExecutable = true;
        libraryHaskellDepends = [ base bytestring ];
@@ -15781,7 +15801,7 @@ self: {
      mkDerivation {
        pname = "WL500gPControl";
        version = "0.3.4";
-       sha256 = "0gbjb432758wvd3p5brb4kjn037x6h30bzvn9f681pg0m1w52hgv";
+       sha256 = "fb415178a8e0dd808c4b76ff050634fd0c60e5242baf7247db1c95230659723d";
        isLibrary = false;
        isExecutable = true;
        executableHaskellDepends = [
@@ -15798,7 +15818,7 @@ self: {
      mkDerivation {
        pname = "WL500gPLib";
        version = "0.3.1";
-       sha256 = "15w065yg8hjhljgnmx88fnryhbh7dysmsqmpr9qnj96as7vrkwgs";
+       sha256 = "faf199f7d1ca246971cab7625db56f072ee8b37508f56a9fa45042f47c318097";
        isLibrary = true;
        isExecutable = true;
        libraryHaskellDepends = [ base curl mtl tagsoup ];
@@ -15815,7 +15835,7 @@ self: {
      mkDerivation {
        pname = "WMSigner";
        version = "0.1.0.0";
-       sha256 = "0im8rfyfnhq2s445cjm4xvnqqs8pgpavhmyk98jqshpfm9d1cd6q";
+       sha256 = "d834165aaaee428d254ad357b8d57d17698cedeea44a5608d10243ebbccba846";
        libraryHaskellDepends = [
          base base64-bytestring binary bytestring cryptohash directory lens
          mtl random split vector
@@ -15833,7 +15853,7 @@ self: {
      mkDerivation {
        pname = "WURFL";
        version = "0.1";
-       sha256 = "13vfszyfyxwz4zi8zilifd0jad1gwlr75x931q8qbpi1kwr7mivk";
+       sha256 = "73c77a329f21de85110e23f57232e52f3425417391c68fe2279f77effcd76e8f";
        libraryHaskellDepends = [ base haskell98 parsec ];
        description = "Convert the WURFL file into a Parsec parser";
        license = stdenv.lib.licenses.bsd3;
@@ -15845,7 +15865,7 @@ self: {
      mkDerivation {
        pname = "WXDiffCtrl";
        version = "0.0.1";
-       sha256 = "0vv8s483g3dkxyk833cjczj0a5zxiy9xh56kij6n0jjyzxb9bz0k";
+       sha256 = "13fc9556ff5e4a608d8cd314d8938ffd1705e467928d81a6efb38d3710d1686f";
        libraryHaskellDepends = [ base containers wx wxcore ];
        homepage = "http://wewantarock.wordpress.com";
        description = "WXDiffCtrl";
@@ -15860,7 +15880,7 @@ self: {
      mkDerivation {
        pname = "WashNGo";
        version = "2.12.0.1";
-       sha256 = "11d9cwqfpvf999a5fi3a3v5b4gdrszzgf4gbdhx63afy42ylbnfj";
+       sha256 = "d2d945bd20dea9613a6ceb11f7fed7b93db2ca1e6a4457544ac9edeb3067a985";
        isLibrary = true;
        isExecutable = true;
        libraryHaskellDepends = [
@@ -15881,7 +15901,7 @@ self: {
      mkDerivation {
        pname = "Weather";
        version = "0.1.0.4";
-       sha256 = "0g5rpz6gnf8hl7gpjc7nwci8x24yw02ps3jwjsi6js5yf3mlrxnv";
+       sha256 = "dbf64ceb70be6869a2965c0e7d05e09e888e22e3f63079dfa11039fbccbfb93c";
        libraryHaskellDepends = [
          aeson base bytestring HTTP text unordered-containers
        ];
@@ -15895,7 +15915,7 @@ self: {
      mkDerivation {
        pname = "WebBits";
        version = "2.2";
-       sha256 = "1frmnjbpgm76dzs1p4766fb6isqc3pxv4dnj8sdhnfliv5j0xv2z";
+       sha256 = "5fec0e64d9913a0b9b46d236b2fb1d0ceb689633e6901bf46fe6d47797b435bb";
        libraryHaskellDepends = [ base containers mtl parsec pretty syb ];
        homepage = "http://github.com/brownplt/webbits";
        description = "JavaScript analysis tools";
@@ -15909,7 +15929,7 @@ self: {
      mkDerivation {
        pname = "WebBits-Html";
        version = "1.0.2";
-       sha256 = "18dd52970cd27kra4l89vvrx2mrdbqd4w4f76xrq3142daxsagal";
+       sha256 = "543da5bb6a8284817337c7114e1a5e2d57d1f3de0951a2f23ca231709228ada1";
        libraryHaskellDepends = [
          base containers mtl parsec pretty syb WebBits
        ];
@@ -15927,7 +15947,7 @@ self: {
      mkDerivation {
        pname = "WebBits-multiplate";
        version = "0.0.0.1";
-       sha256 = "1j3difi3f1w6bgbnsvqw9cv88aikin22myli0lx29pqn7xhqsbv3";
+       sha256 = "632f8d613f16df243a0591fa2a848d332a84364b1c6f6dd75b860737a28b6dc8";
        libraryHaskellDepends = [
          base multiplate multiplate-simplified transformers WebBits
        ];
@@ -15945,7 +15965,7 @@ self: {
      mkDerivation {
        pname = "WebCont";
        version = "0.0.1";
-       sha256 = "1lr5iz0kqhr8w0c7038mlbysw1c3lbzfjis085n68ib104ykyyi6";
+       sha256 = "267a3f3d016145646c414047e9fea28305aefda2150d7018e028433cc18f25d3";
        libraryHaskellDepends = [
          applicative-extras base concatenative containers formlets
          happstack-server happstack-state happstack-util mtl utf8-string
@@ -15962,7 +15982,7 @@ self: {
      mkDerivation {
        pname = "WeberLogic";
        version = "0.1.2";
-       sha256 = "0nl79q3y2qi0xnkppxj8d9h96hfwrgb3gksm2x1zp9lq7836562z";
+       sha256 = "5f9862063a98a6fb431755cf37d6cbdc4193606a48f67ba7ed2062e1074e875a";
        isLibrary = true;
        isExecutable = true;
        libraryHaskellDepends = [ base parsec ];
@@ -15982,7 +16002,7 @@ self: {
      mkDerivation {
        pname = "Webrexp";
        version = "1.1.2";
-       sha256 = "1iv969gd4xmagw74i6fmw4d864zxlzi4yf0y9ns1nvijn7w7s5jb";
+       sha256 = "4b167df8b1326e1bb44d1e384fe2a7fd13831ae1d599480e7faa76d25e3269c7";
        isLibrary = true;
        isExecutable = true;
        libraryHaskellDepends = [
@@ -16011,7 +16031,7 @@ self: {
      mkDerivation {
        pname = "Wheb";
        version = "0.3.1.0";
-       sha256 = "13x204lz2azfrry38w791rni2d0g9xsg5lhajrkrgfhdn56yrzqs";
+       sha256 = "1affec4db10dba9767960ad2f2744f0f34116d0ee970347cceee2bf12901a28f";
        libraryHaskellDepends = [
          base blaze-builder bytestring case-insensitive containers cookie
          http-types mtl pwstore-fast stm text time transformers unix uuid
@@ -16033,7 +16053,7 @@ self: {
      mkDerivation {
        pname = "WikimediaParser";
        version = "0.1";
-       sha256 = "0rzpf8z414qvkbks16zizsxsinvbdxbm1n0dbav11p286791xx1j";
+       sha256 = "32f41ed23148dc10b65a0dd850576f6bdba8bbfef19ba0e79a1b93403e72f767";
        libraryHaskellDepends = [ base parsec ];
        description = "A parser for wikimedia style article markup";
        license = stdenv.lib.licenses.bsd3;
@@ -16047,7 +16067,7 @@ self: {
      mkDerivation {
        pname = "Win32";
        version = "2.3.1.0";
-       sha256 = "1y9z682gmgjkrc8lijkidrlwh5pr30zgpvx2sc3gnvn8krg6jnk8";
+       sha256 = "685a695e9ec86efb06d3a2effb3e18f916c8696e71ca4811cb53befa04323ff9";
        libraryHaskellDepends = [ base bytestring ];
        librarySystemDepends = [
          advapi32 gdi32 shell32 shfolder user32 winmm
@@ -16063,7 +16083,7 @@ self: {
      mkDerivation {
        pname = "Win32-dhcp-server";
        version = "0.3.1";
-       sha256 = "0mkxk822gcg1r61cf5wq9ayya51am4dy8v2xqm3ld30d7hss4dij";
+       sha256 = "3236a2353c0d8c4647c55d6ce41ba92a14e5bd4a9817c782c9e1b127049a7d56";
        libraryHaskellDepends = [ base text Win32 Win32-errors ];
        homepage = "http://github.com/mikesteele81/win32-dhcp-server";
        description = "Win32 DHCP Server Management API";
@@ -16076,7 +16096,7 @@ self: {
      mkDerivation {
        pname = "Win32-errors";
        version = "0.2.2.1";
-       sha256 = "1v7gm7vll1lq6d7d0y8vza7ilcw6i95jkprhy906awhqlhv3z031";
+       sha256 = "61803f36a418726540f230df294b8a86331a8ffa1b79d04e3398064af7a9efec";
        libraryHaskellDepends = [ base template-haskell text Win32 ];
        homepage = "http://github.com/mikesteele81/win32-errors";
        description = "Alternative error handling for Win32 foreign calls";
@@ -16089,7 +16109,7 @@ self: {
      mkDerivation {
        pname = "Win32-extras";
        version = "0.2.0.1";
-       sha256 = "00lrqvsa74mqv0k4yz00j2jdpmchkyhcicqv24z9a53iv1i0xp7h";
+       sha256 = "f0dc0e62d87114953e111bb3c8a09f90d5dba490007c4f26d8b892a3f4c69902";
        libraryHaskellDepends = [ base Win32 ];
        librarySystemDepends = [ imm32 msimg32 ];
        homepage = "http://hub.darcs.net/shelarcy/Win32-extras/";
@@ -16103,7 +16123,7 @@ self: {
      mkDerivation {
        pname = "Win32-junction-point";
        version = "0.2.1.1";
-       sha256 = "1pvlvhdp4wcz8kn5nldhrkryz03dmzyzvjbm8x1ri9kwq1icd941";
+       sha256 = "81a4c662c07ca698434775c9fdfdaf6d80eff3ccb0515bec449f71721bdc74df";
        libraryHaskellDepends = [ base text Win32 Win32-errors ];
        homepage = "http://github.com/mikesteele81/Win32-junction-point";
        description = "Support for manipulating NTFS junction points";
@@ -16116,7 +16136,7 @@ self: {
      mkDerivation {
        pname = "Win32-notify";
        version = "0.3.0.1";
-       sha256 = "0zzbb00rykl8y1prkcm3paaamhmdrqji34070b9zg7sg2pc5k4f4";
+       sha256 = "c49159d8154f9ff7d30207901125ceadc2aa94baa3b2996ff0884e9f0158eb7f";
        isLibrary = true;
        isExecutable = true;
        libraryHaskellDepends = [ base containers directory Win32 ];
@@ -16131,7 +16151,7 @@ self: {
      mkDerivation {
        pname = "Win32-security";
        version = "0.1.1";
-       sha256 = "0dh4z7a0mxwpqhx1cxvwwjc7w24mcrqc0bmg7bp86kd6zqz6rjly";
+       sha256 = "9eca6c3efea64d83ee3aaf2ec0706695087e98e47c77163ac497f70ad4f90436";
        isLibrary = true;
        isExecutable = true;
        libraryHaskellDepends = [ base text Win32 Win32-errors ];
@@ -16146,7 +16166,7 @@ self: {
      mkDerivation {
        pname = "Win32-services";
        version = "0.3";
-       sha256 = "07vby574s528g259zq8jby1327b6jqn4zlzs406ml99w1p02d9js";
+       sha256 = "5aa626c00d3c255a0d20fad34f2c96661d31825f12e19f8a7848144d4ef16b1f";
        libraryHaskellDepends = [ base Win32 Win32-errors ];
        librarySystemDepends = [ Advapi32 ];
        homepage = "http://github.com/mikesteele81/win32-services";
@@ -16162,7 +16182,7 @@ self: {
      mkDerivation {
        pname = "Win32-services-wrapper";
        version = "0.1.3.0";
-       sha256 = "1nihf12bcgahs5220pdny1kf54973qxh7llhzv5d9s9lxias2jyd";
+       sha256 = "cd4ba155ec34e9d4cafe90d2033b1e2791e266f0b65d2044d1503db6447030da";
        libraryHaskellDepends = [
          base directory filepath Win32 Win32-errors Win32-services
        ];
@@ -16178,7 +16198,7 @@ self: {
      mkDerivation {
        pname = "Wired";
        version = "0.3";
-       sha256 = "14zxf849r4k3mk5i5rakfjp2f216sz84ww4hfggq9cnr9w8j406j";
+       sha256 = "d20022114fd9b284df7390704ed0d7260827ae7453e512cbac63929c0872fd93";
        libraryHaskellDepends = [
          base chalmers-lava2000 containers mtl QuickCheck
        ];
@@ -16192,7 +16212,7 @@ self: {
      mkDerivation {
        pname = "WordNet";
        version = "1.1.0";
-       sha256 = "0b44xxkihafzsw25xx484xxw17zlzzqbj0bx8cs2nvf3p7jxd02k";
+       sha256 = "5380d6e5b9c36d2b34437d01b9f0fff49fc07b2788f45e04d7df291867ef842c";
        libraryHaskellDepends = [ array base containers filepath ];
        description = "Haskell interface to the WordNet database";
        license = stdenv.lib.licenses.bsd3;
@@ -16204,7 +16224,7 @@ self: {
      mkDerivation {
        pname = "WordNet-ghc74";
        version = "0.1.3";
-       sha256 = "1ab5wybawa3dfq89dn0g3zdhsqd03bcm3qky2d4z6irw7afdqrr8";
+       sha256 = "2867dc9c3a3c47f349137ee251d91aa0610ddb1f0fd89610766d28ae96e765a9";
        libraryHaskellDepends = [ array base containers filepath ];
        description = "Haskell interface to the WordNet database";
        license = stdenv.lib.licenses.bsd3;
@@ -16216,7 +16236,7 @@ self: {
      mkDerivation {
        pname = "Wordlint";
        version = "0.2.0.4";
-       sha256 = "08d02h4ynkwxqxxqzk8hfmdj9y7rg23biybb969pk0scgvg7iyd5";
+       sha256 = "a5f978de7e4c837993496bf9b88678f9f8245b7510cd8f7bc79d4feb0914a021";
        isLibrary = true;
        isExecutable = true;
        libraryHaskellDepends = [ base boxes cmdargs ];
@@ -16236,7 +16256,7 @@ self: {
      mkDerivation {
        pname = "Workflow";
        version = "0.8.3";
-       sha256 = "08r1s840771z1gy44dj3xc6ary7gk3ka3zvji5pmgzi998x4p6y8";
+       sha256 = "c89b4b3a4a29fe576f8972ffa1e698eff8ac0ceb433642fc0b3f9c0308d22123";
        revision = "1";
        editedCabalFile = "1be542eaf091e04c561a2a589f37330b0a65d6d3d5a44609c197a74e8385c64b";
        libraryHaskellDepends = [
@@ -16253,7 +16273,7 @@ self: {
      mkDerivation {
        pname = "WxGeneric";
        version = "0.8.1";
-       sha256 = "0lvbdmb1qwsz8bz0z715nzgbpshfckm4syk1ny52akkb4ddkrd60";
+       sha256 = "c0b43c5b236b4e258ab7617a4dea640eeabbdeb7259c0ffe425f731c566d6b53";
        libraryHaskellDepends = [
          base containers mtl SybWidget wx wxcore xtc
        ];
@@ -16268,7 +16288,7 @@ self: {
      mkDerivation {
        pname = "X11";
        version = "1.6.1.2";
-       sha256 = "1kzjcynm3rr83ihqx2y2d852jc49da4p18gv6jzm7g87z22x85jj";
+       sha256 = "5216d485f807bd53bf34fba170896a8930290a6ac28b8e611c28e751ad67f2cf";
        libraryHaskellDepends = [ base data-default ];
        librarySystemDepends = [ libX11 libXext libXrandr ];
        homepage = "https://github.com/haskell-pkg-janitors/X11";
@@ -16282,7 +16302,7 @@ self: {
      mkDerivation {
        pname = "X11-extras";
        version = "0.4";
-       sha256 = "1cpjr09gddcjd0wqwvaankv1zj7fyc6hbfdvar63f51g3vvw627a";
+       sha256 = "ea08c3f71e2f14374c56bbb9050df3eec81ff6b44a6d8e396892b5f612c8f2b2";
        revision = "1";
        editedCabalFile = "f7b315acd1fb4d44ee6312b2e8d397b7cda103cf5e9e8ca6867389ef6cadff3c";
        libraryHaskellDepends = [ base X11 ];
@@ -16298,7 +16318,7 @@ self: {
      mkDerivation {
        pname = "X11-rm";
        version = "0.2";
-       sha256 = "11jxlaad9jgjddd5v8ygy2rdrajrbm9dlp6f0mslvxa2wzn4v4r3";
+       sha256 = "23934dece742f54d7505ce5cda525d59aadcb2f0cfa35d5a6bf2c9d494a25d86";
        libraryHaskellDepends = [ base X11 ];
        description = "A binding to the resource management functions missing from X11";
        license = stdenv.lib.licenses.bsd3;
@@ -16310,7 +16330,7 @@ self: {
      mkDerivation {
        pname = "X11-xdamage";
        version = "0.1.2";
-       sha256 = "0r6dq9xx0v100162y7bvkj1l0lv5m697y35c659kgjj0mg8p9bjv";
+       sha256 = "5bae74d1ab40ca375331ac0c7f92a9655340839c7b1d2f4c00206cd07bc2cd64";
        libraryHaskellDepends = [ base X11 ];
        librarySystemDepends = [ Xdamage ];
        homepage = "http://darcs.haskell.org/X11-xdamage";
@@ -16324,7 +16344,7 @@ self: {
      mkDerivation {
        pname = "X11-xfixes";
        version = "0.1.1";
-       sha256 = "0wwhyqqybrjvy8mi5d5429wraky93xq348gr9ldhg2qj95hj13yk";
+       sha256 = "d38f206149128b071b4df92132701fc94f957912a4b4122bf25be6e531f69073";
        libraryHaskellDepends = [ base X11 ];
        librarySystemDepends = [ Xfixes ];
        homepage = "https://github.com/reacocard/x11-xfixes";
@@ -16338,7 +16358,7 @@ self: {
      mkDerivation {
        pname = "X11-xft";
        version = "0.3.1";
-       sha256 = "1lgqb0s2qfwwgbvwxhjbi23rbwamzdi0l0slfr20c3jpcbp3zfjf";
+       sha256 = "4eba3fee62570e06447654030a62fb55f19587884bc2cef77a9c3b2c3458f8d1";
        libraryHaskellDepends = [ base utf8-string X11 ];
        libraryPkgconfigDepends = [ libXft ];
        description = "Bindings to the Xft, X Free Type interface library, and some Xrender parts";
@@ -16350,7 +16370,7 @@ self: {
      mkDerivation {
        pname = "X11-xshape";
        version = "0.1.1";
-       sha256 = "19p71lc0hihfn0xzl29j01kd0zf9yalspwj7dava0ybc1rm3g62h";
+       sha256 = "5098376a0e6c79a0b66a47f2aba9f2c97dd066003209fa3bb00e4608180de7a6";
        libraryHaskellDepends = [ base X11 ];
        homepage = "http://darcs.haskell.org/X11-xshape";
        description = "A binding to the Xshape X11 extension library";
@@ -16362,7 +16382,7 @@ self: {
      mkDerivation {
        pname = "XAttr";
        version = "0.1.1";
-       sha256 = "16vap0rw026lgxfcqpdfsx7l26ik97rhkkv1mg2j61akydhijs67";
+       sha256 = "c7681961f3530523c5ab61cf09f349331a414fd7ae5dcc5c7fd408c033b86a9b";
        libraryHaskellDepends = [ base unix ];
        description = "Read, set, and list extended attributes";
        license = "GPL";
@@ -16373,7 +16393,7 @@ self: {
      mkDerivation {
        pname = "XInput";
        version = "0.1";
-       sha256 = "1kk0gccv83mw8463x29c7rpl5davmhk9vyf82i4rbksgrdzkhjh9";
+       sha256 = "094a387fcb4fcf954914c8f99d26ac5bb5426f3e2c893e0c41bc0eb4197b60ce";
        libraryHaskellDepends = [ base Win32 ];
        librarySystemDepends = [ xinput ];
        homepage = "http://code.fac9.com/xinput/";
@@ -16387,7 +16407,7 @@ self: {
      mkDerivation {
        pname = "XMMS";
        version = "0.1.1";
-       sha256 = "08l53b0wp6v9wjfn53xfa1vlh64bnqidajc4lzlk8p31km1c09qx";
+       sha256 = "1d27c0429d615c34e9a78449d522b68b18487750ae8f629de4699bcbc11a8522";
        libraryHaskellDepends = [ base containers ];
        librarySystemDepends = [ xmmsclient xmmsclient-glib ];
        homepage = "http://kawais.org.ua/XMMS/";
@@ -16403,7 +16423,7 @@ self: {
      mkDerivation {
        pname = "XMPP";
        version = "0.1.2";
-       sha256 = "03gypa9kln2v3zqyxszn4k2x364g8wj0hppsy10ywmandghsvn7b";
+       sha256 = "ebd8ade16b5655ee41f0fa5e0824478f98d1c524f6ebeef11f5b583a93bafe0d";
        libraryHaskellDepends = [
          base haskell98 hsdns mtl network parsec random utf8-string
        ];
@@ -16421,9 +16441,9 @@ self: {
      mkDerivation {
        pname = "XSaiga";
        version = "1.0.0.0";
-       sha256 = "0smf0ym26kv0fa34plnsndxp5hflc7w6g0wbkg6n4cy9bz4sgd4z";
-       revision = "3";
-       editedCabalFile = "a152097b5010d51d0192d2c1748dce912a050f3f705f5a4b86ffa7a2f726488f";
+       sha256 = "9fb4a7c95fc93362cd9b8b8367f861d4c1727bb3dad24b8672604f23aa07ae6a";
+       revision = "4";
+       editedCabalFile = "d4af61293d2d3a615e34002a517490a4ac748799aae15d2b0e6aaed14204693e";
        isLibrary = true;
        isExecutable = true;
        libraryHaskellDepends = [ base pretty ];
@@ -16442,7 +16462,7 @@ self: {
      mkDerivation {
        pname = "Xauth";
        version = "0.1";
-       sha256 = "1mvflp6y1nz9961gngbwk0b7wr8sx3p6296jfvvb6ln1kvm2scxs";
+       sha256 = "ba332dea9ec152b3f676d22461eee81a657e16987c3dfb8249e9dbe0cda56ed7";
        libraryHaskellDepends = [ base ];
        libraryPkgconfigDepends = [ libXau ];
        description = "A binding to the X11 authentication library";
@@ -16456,7 +16476,7 @@ self: {
      mkDerivation {
        pname = "Xec";
        version = "0.1.6";
-       sha256 = "1n3y232v9i5jzbshk2zw675g09snc45ni60acmi6kvfsk7nkmfw8";
+       sha256 = "88bb3aed99daed6962650a98680b615627f0ca31fc8b09f5fab2c4b4c5107ed8";
        isLibrary = false;
        isExecutable = true;
        executableHaskellDepends = [
@@ -16473,7 +16493,7 @@ self: {
      mkDerivation {
        pname = "XmlHtmlWriter";
        version = "0.0.0.1";
-       sha256 = "0dv5nvvqy6w0ndjyab4bwhjpw1hlx8xi4bv2jw4rl8v6y68bilk1";
+       sha256 = "61d2b890f166239a0997622f123bea14067e25e48b2ce565b3801b8ff7b66537";
        libraryHaskellDepends = [ base mtl transformers ];
        homepage = "http://github.com/mmirman/haskogeneous/tree/XmlHtmlWriter";
        description = "A library for writing XML and HTML";
@@ -16486,7 +16506,7 @@ self: {
      mkDerivation {
        pname = "Xorshift128Plus";
        version = "0.1.0.1";
-       sha256 = "11g1gipc9v81h5jzndr3j7j4mwr4lva9b52fd0hml4mrzf6vj2dx";
+       sha256 = "bd09b98dfbb9125a21684e9495d4a624f34ae4912337fb658101edc46e7ce185";
        libraryHaskellDepends = [ base ];
        homepage = "https://github.com/kanaihiroki/Xorshift128Plus";
        description = "Pure haskell implementation of xorshift128plus random number generator";
@@ -16501,7 +16521,7 @@ self: {
      mkDerivation {
        pname = "YACPong";
        version = "0.1";
-       sha256 = "1r2n1vbzq755p68fzb5f6fm1yjfq2c5jgx52ri9p5rlrwmfk3hw5";
+       sha256 = "85c3315de599e67253cca2f4270b13d8491faa33aeacef90b9a51cfcd70e56e4";
        isLibrary = false;
        isExecutable = true;
        executableHaskellDepends = [
@@ -16519,7 +16539,7 @@ self: {
      mkDerivation {
        pname = "YFrob";
        version = "0.4";
-       sha256 = "17pp79yr8jfmhx85vlr5kx7q5wha48p3ra7l4ligd583yxzvlnif";
+       sha256 = "2e5aba7ff70395f62225f4a83c2e220af2824f9f25d35d5087d549947d3af79e";
        libraryHaskellDepends = [ array base HGL Yampa ];
        homepage = "http://www.haskell.org/yampa/";
        description = "Yampa-based library for programming robots";
@@ -16542,7 +16562,7 @@ self: {
      mkDerivation {
        pname = "Yablog";
        version = "0.2.0";
-       sha256 = "0qa7m9y3dclr2r2vpd2cmpc58nib158hnr49hrdjvk00ncd4lyvk";
+       sha256 = "737b4a1ab300cc2d5b8689640b51092b5a54d8ad4cb4bb451699b2367caa4761";
        isLibrary = true;
        isExecutable = true;
        executableHaskellDepends = [
@@ -16570,7 +16590,7 @@ self: {
      mkDerivation {
        pname = "YamlReference";
        version = "0.9.3";
-       sha256 = "0nk7zw3ikv459hzrs0si06j4qf2yrgggsiv8vpm0r1lg5v5l3vng";
+       sha256 = "cfee41cb2e8f860ceadd6847fddecb5e384ca40151039d3f4c85ec1907ff675a";
        isLibrary = true;
        isExecutable = true;
        libraryHaskellDepends = [
@@ -16588,7 +16608,7 @@ self: {
      mkDerivation {
        pname = "Yampa";
        version = "0.10.2";
-       sha256 = "1pmszrbf1fxid4km0jdam8iqfba2mfyz8mzn6vxfb0da19vlz4cq";
+       sha256 = "98914f770aaa81e5fa36f657f4bdab422d8723aaaa49502769b1bbe056febade";
        libraryHaskellDepends = [ base deepseq random ];
        homepage = "http://www.haskell.org/haskellwiki/Yampa";
        description = "Library for programming hybrid systems";
@@ -16600,7 +16620,7 @@ self: {
      mkDerivation {
        pname = "Yampa-core";
        version = "0.2.0";
-       sha256 = "06mgmnj8zsnfzg3li3nw4a5lmiz0jkc4hxzilwhh1r84qiki72xp";
+       sha256 = "b78b1367c404e50021a7f17748d894e0c74a8b22dc8e48c7fbceea8fa4adaf1a";
        isLibrary = true;
        isExecutable = true;
        libraryHaskellDepends = [ base deepseq random vector-space ];
@@ -16618,7 +16638,7 @@ self: {
      mkDerivation {
        pname = "YampaSynth";
        version = "0.2";
-       sha256 = "028a7lrfyikvky52s19kffssnry1grnip3sm7z55bs5fazma1im1";
+       sha256 = "a1c6a0ea57aee855ca3f558f1b6d7ec167abb57333052d8a9f7b46ef323d0a09";
        isLibrary = false;
        isExecutable = true;
        executableHaskellDepends = [
@@ -16634,7 +16654,7 @@ self: {
      mkDerivation {
        pname = "Yocto";
        version = "0.1.0";
-       sha256 = "1krp17rw25b7a280rf3idpfzkx39kpfcjqwznz96y0d2sdqbhg6p";
+       sha256 = "d73cb870d3a2016fd2b79f63c9dc9d69f4f9dd6d71b80c90506715c1f30937cf";
        libraryHaskellDepends = [ base containers parsec ];
        homepage = "https://github.com/ajg/yocto";
        description = "A Minimal JSON Parser & Printer for Haskell";
@@ -16648,7 +16668,7 @@ self: {
      mkDerivation {
        pname = "Yogurt";
        version = "0.4.1";
-       sha256 = "04fzixjgsn0azx2dp352kipxdijfafsm5dnrcvxpxdxms35npffq";
+       sha256 = "d8b96bcbd0b5b77efb66d9b652b5534ec6d66f9ca28cdb44ff0a58fd648fdf11";
        libraryHaskellDepends = [
          base containers mtl network old-locale process readline regex-posix
          syb time
@@ -16666,7 +16686,7 @@ self: {
      mkDerivation {
        pname = "Yogurt-Standalone";
        version = "0.4";
-       sha256 = "151kamqwdwnhinvsmzdq9ckryyvnrf9ihzw6qm4j851y375452hl";
+       sha256 = "148a42ca193e142449c5867f1893cb767b9f274bb8fdaab78dd0f2c671553394";
        isLibrary = false;
        isExecutable = true;
        executableHaskellDepends = [
@@ -16685,7 +16705,7 @@ self: {
      mkDerivation {
        pname = "ZEBEDDE";
        version = "0.1.0.0";
-       sha256 = "1i85pah79342ivmcg73q305awbf9fi6gw4ckg9i019d6vmdg5d17";
+       sha256 = "27b4f25adda6a500627a9311fe4c74c92dae0a18789cc7ea8e828c74a0ba05c5";
        libraryHaskellDepends = [ base vect ];
        jailbreak = true;
        description = "Polymer growth simulation method";
@@ -16698,7 +16718,7 @@ self: {
      mkDerivation {
        pname = "ZFS";
        version = "0.0.2";
-       sha256 = "1mwpcgkw1cci2grhb8vl081wykkgsmfbanwapp10mrzzp0df1yzr";
+       sha256 = "f9fbe01ab8ffe70ac2bd8a5bb55cd56f4ecf030274a305f31391b1c0e76397d7";
        libraryHaskellDepends = [
          base CC-delcont containers mtl network unix
        ];
@@ -16713,7 +16733,7 @@ self: {
      mkDerivation {
        pname = "ZMachine";
        version = "0.0";
-       sha256 = "1s005k892z9651mr2jj0jdwpm8aa0y72vi405xi4h6czg52i4rb3";
+       sha256 = "63651245799f1948622f80c42d8e074aa17a7993404a916b28267d91d02c00e8";
        isLibrary = false;
        isExecutable = true;
        executableHaskellDepends = [ array base gtk mtl random ];
@@ -16727,7 +16747,7 @@ self: {
      mkDerivation {
        pname = "ZipFold";
        version = "0.1.4";
-       sha256 = "05cnpl9c6i0j8jqr4j43b32jgryv34gahimhp9g1m45idgnl2sn0";
+       sha256 = "c06a41ed6bb1901a5ebab046a81e19dbe727c558834892b1441244c312bd9615";
        libraryHaskellDepends = [ base TypeCompose ];
        homepage = "http://haskell.org/haskellwiki/ZipFold";
        description = "Zipping folds";
@@ -16739,7 +16759,7 @@ self: {
      mkDerivation {
        pname = "ZipperAG";
        version = "0.9";
-       sha256 = "0nl08r7s3r5hr5jag499fillca16wsb8yqz1dlzydvacqcklcxr9";
+       sha256 = "29774627c34cede63f6de1638f96e626284669742991a764c9b0e4a14f46805a";
        libraryHaskellDepends = [ base syz ];
        homepage = "www.di.uminho.pt/~prmartins";
        description = "An implementationg of Attribute Grammars using Functional Zippers";
@@ -16753,7 +16773,7 @@ self: {
      mkDerivation {
        pname = "Zora";
        version = "1.2.0";
-       sha256 = "1yni2yq8ynq9jhnzabyx0ahmvmvcyblc0swxy0n7qdzlz5rxzm3i";
+       sha256 = "71d4df73f9f4377c2cf09d6bc0e8f26cd75da102dd2ff52d94095b8fb017d1fa";
        libraryHaskellDepends = [
          base bytestring containers directory fgl graphviz random shelly
          text
@@ -16769,7 +16789,7 @@ self: {
      mkDerivation {
        pname = "Zwaluw";
        version = "0.1";
-       sha256 = "1crvcvni5gzpc1c6cnaqqp0gng1l9gk9d8ac23967nvp82xav7s1";
+       sha256 = "419fadba4077db63d2104ca196e64b343cfbc0c55859665860f7bf12ed663bb3";
        libraryHaskellDepends = [ base ];
        homepage = "https://github.com/MedeaMelana/Zwaluw";
        description = "Combinators for bidirectional URL routing";
@@ -16784,7 +16804,7 @@ self: {
      mkDerivation {
        pname = "a50";
        version = "0.5";
-       sha256 = "0jfnf0rq3rfic196zjwbaiamyis98zrr8d4zn2myjlgqlzhljzs0";
+       sha256 = "407f49e1a7f851e9abb09f3494f34749475f55548bcb6f5260d1e5813370d649";
        isLibrary = false;
        isExecutable = true;
        executableHaskellDepends = [
@@ -16800,7 +16820,7 @@ self: {
      mkDerivation {
        pname = "abacate";
        version = "0.0.0.0";
-       sha256 = "1lxsn3n77fk7jl8i76nffj1zngvi2s38y17s54ha29h8hrp3s3dg";
+       sha256 = "af0d3d6e860826a12029fa048f8616713ffb8374ce9a13119567ba73ecb0bad3";
        libraryHaskellDepends = [ base parsec text ];
        testHaskellDepends = [ base HUnit text ];
        jailbreak = true;
@@ -16815,7 +16835,7 @@ self: {
      mkDerivation {
        pname = "abc-puzzle";
        version = "0.2.1";
-       sha256 = "0i162j9wlpcisqzf9klqvag9hrs9v7araw4l16cvw0yrifvqzswd";
+       sha256 = "8deb8fb78bd903be9909947095d5d94967989eda98cee43ed6915dca93142644";
        isLibrary = false;
        isExecutable = true;
        executableHaskellDepends = [
@@ -16834,7 +16854,7 @@ self: {
      mkDerivation {
        pname = "abcBridge";
        version = "0.14";
-       sha256 = "1ki5h3058n3kpvaspl8g1vadprw6kb3xxyadb3a4k1irkfz8lfkf";
+       sha256 = "6e3a8abe9b398649d4584df9dec79a86e7dbd40e0fd1abd5be735854c08025ce";
        isLibrary = true;
        isExecutable = true;
        libraryHaskellDepends = [ aig base containers directory vector ];
@@ -16855,7 +16875,7 @@ self: {
      mkDerivation {
        pname = "abcnotation";
        version = "1.9.0";
-       sha256 = "0vmpgdqasnhj0fbb5wl7ikxmp6kzrlnbixp2yj4x93mh8vrrsk40";
+       sha256 = "804c9df346b08ed489f4e2f6b82ccd7f9a5bfb8c87f2b29603125aad707bb76e";
        libraryHaskellDepends = [
          base parsec prettify process semigroups
        ];
@@ -16871,7 +16891,7 @@ self: {
      mkDerivation {
        pname = "abeson";
        version = "0.1.0.1";
-       sha256 = "1g258gfk7sk8hsd4nixah0vj69rwphvv6aywsvdldm8pbw51sy1c";
+       sha256 = "2c781d0a5f17d546dbd6dc2bb337bc3c27233780aa474b9a8668ea33dd4345bc";
        revision = "1";
        editedCabalFile = "fc1839c19327f8fb9b36d2aa6dd133e3d391696183b3292894f9f7e1ca188727";
        libraryHaskellDepends = [
@@ -16889,7 +16909,7 @@ self: {
      mkDerivation {
        pname = "abstract-deque";
        version = "0.3";
-       sha256 = "18jwswjxwzc9bjiy4ds6hw2a74ki797jmfcifxd2ga4kh7ri1ah9";
+       sha256 = "09aa10f38193a8275a7791b92a4f3a7192a304874637e2a35c897dde25d75ca2";
        libraryHaskellDepends = [ array base containers random time ];
        homepage = "https://github.com/rrnewton/haskell-lockfree/wiki";
        description = "Abstract, parameterized interface to mutable Deques";
@@ -16903,7 +16923,7 @@ self: {
      mkDerivation {
        pname = "abstract-deque-tests";
        version = "0.3";
-       sha256 = "19gb5x5z3nvazdra3skm24c2g2byj0i4cjbzfwfghnb5q96gn5sz";
+       sha256 = "5f17fb4cc26559f81c777f494622907e8927181175eaa172fb6adbf14b2feba5";
        libraryHaskellDepends = [
          abstract-deque array base containers HUnit random test-framework
          test-framework-hunit time
@@ -16922,7 +16942,7 @@ self: {
      mkDerivation {
        pname = "abstract-par";
        version = "0.3.3";
-       sha256 = "0q6qsniw4wks2pw6wzncb1p1j3k6al5njnvm2v5n494hplwqg2i4";
+       sha256 = "248a8739bd902462cb16755b690b55660e196e58cc7e6ef8157a72c2a3d5d860";
        libraryHaskellDepends = [ base deepseq ];
        homepage = "https://github.com/simonmar/monad-par";
        description = "Type classes generalizing the functionality of the 'monad-par' library";
@@ -16934,7 +16954,7 @@ self: {
      mkDerivation {
        pname = "abstract-par-accelerate";
        version = "0.3.3";
-       sha256 = "0k1730mg2vyf21837fc459m8si1ffnbj78cdkbgglp2vn51f3nz4";
+       sha256 = "e4dbe142b15b5cfade9a8da12397752e448d6a2a84b9335010ce6ff12a18274c";
        libraryHaskellDepends = [
          abstract-par accelerate array base vector
        ];
@@ -16951,7 +16971,7 @@ self: {
      mkDerivation {
        pname = "abt";
        version = "0.1.1.0";
-       sha256 = "1hgbzzpxn6gcs3zjs8hqz065gqk2x6gzra2b1fw9lyb2x4lw42y9";
+       sha256 = "c90bc229e962799ab80b4ba8fc9fe962e2570cf818222dffd0ec19dbefffebc1";
        libraryHaskellDepends = [
          base profunctors transformers transformers-compat vinyl
        ];
@@ -16966,7 +16986,7 @@ self: {
      mkDerivation {
        pname = "ac-machine";
        version = "0.2.0.5";
-       sha256 = "00s2nvd85l00kpl45ipaq4ypa1ymaxmvnaf5mdvdladg4icl50i4";
+       sha256 = "2482425924af29da76abc529bb6b57d507753dc1eac642e89d00d082dab64203";
        libraryHaskellDepends = [
          base hashable unordered-containers vector
        ];
@@ -16980,7 +17000,7 @@ self: {
      mkDerivation {
        pname = "ac-machine-conduit";
        version = "0.1.0.0";
-       sha256 = "1nsnbvllwznbqycw33f09vfgqvqmqfkcbi367clm6k4v6rfswzl3";
+       sha256 = "837eae5d369b4c53293b66c4c5a6c3156ffcdc4ec08dc199c7cb7e4ee95e56db";
        libraryHaskellDepends = [ ac-machine base conduit text ];
        jailbreak = true;
        description = "Drive Aho-Corasick machines in Conduit pipelines";
@@ -16995,7 +17015,7 @@ self: {
      mkDerivation {
        pname = "accelerate";
        version = "0.15.1.0";
-       sha256 = "07bbam9za0g15vm0h0p9dypblw2f709v4qmvc52jcvmsv1drl3yv";
+       sha256 = "db0f9a5bd8ba6e264561bb62b213384e70baae6fe90208ea2ee101f553556b1d";
        libraryHaskellDepends = [
          array base containers fclabels ghc-prim hashable hashtables pretty
          template-haskell unordered-containers
@@ -17012,7 +17032,7 @@ self: {
      mkDerivation {
        pname = "accelerate-arithmetic";
        version = "0.0.1";
-       sha256 = "093j1wdabhws695hfb4cmj05ys6i4hkh0yppkszmhn5z4imlv741";
+       sha256 = "819c4d6b24bf5858bf9ef77a002724d1685f80ac8c2c074b329ac3a51a0f7224";
        libraryHaskellDepends = [
          accelerate accelerate-utility base QuickCheck utility-ht
        ];
@@ -17032,7 +17052,7 @@ self: {
      mkDerivation {
        pname = "accelerate-cublas";
        version = "0.0";
-       sha256 = "1dcra6qpva8sg5bdh6ilrfdg44h7p6dfh7vkrhifiim4vkvgh9sc";
+       sha256 = "4c27f8f6dca4c6e822cc731fe89ab90712f29acb341ad856791aa97db15199b5";
        isLibrary = true;
        isExecutable = true;
        libraryHaskellDepends = [
@@ -17059,7 +17079,7 @@ self: {
      mkDerivation {
        pname = "accelerate-cuda";
        version = "0.15.0.0";
-       sha256 = "1z8nfciwxm2f2vaddnhan5gi9i1l7qa9h9fsngmdh8d6wabxxidy";
+       sha256 = "bec5de97e2a621d8eab3da2598143e34c4145fb10adad6d4164ed4ce237316fd";
        revision = "2";
        editedCabalFile = "5ed199c4c1d360ed3eaee24df7016462ed1fb1313ff47d6828be546eec8708fc";
        libraryHaskellDepends = [
@@ -17081,7 +17101,7 @@ self: {
      mkDerivation {
        pname = "accelerate-cufft";
        version = "0.0";
-       sha256 = "12faz5z0k682381fgwav91wx5wny0n5jdzgnrajx3sxc8gpg5xd7";
+       sha256 = "a7f5f2ee43acebd1a5caf6fd268b05def2d279485bf1e7021a0299097ef9ca89";
        isLibrary = true;
        isExecutable = true;
        libraryHaskellDepends = [
@@ -17099,7 +17119,7 @@ self: {
      mkDerivation {
        pname = "accelerate-examples";
        version = "0.15.0.0";
-       sha256 = "1jfwb0ryb8idfjc1gccb1h67hl730qn455k5z5wna8aikfscy7rq";
+       sha256 = "381fcfb49b51216579f96596422c06e350780c0c8bb11798742da2e53358dcc9";
        revision = "1";
        editedCabalFile = "2cf8a02096ae9902b9336ce9d0665b3233abb20381d0cb4585efc53357d795cc";
        configureFlags = [ "-f-opencl" ];
@@ -17116,7 +17136,7 @@ self: {
      mkDerivation {
        pname = "accelerate-fft";
        version = "0.15.0.0";
-       sha256 = "0nxlw8z7bnr29vp24qbbwwmq9rj2q6jqqkmm46pp8dp582y4yk6v";
+       sha256 = "db4c4fbc40e53674af21b54e8ca5c142e6842be76b6122ee4e22db753ee2b45b";
        revision = "1";
        editedCabalFile = "c23b93ae20f528782aeb10b528fa2a7847cce5c1aa9db546f3b000d7f05f53ca";
        libraryHaskellDepends = [
@@ -17135,7 +17155,7 @@ self: {
      mkDerivation {
        pname = "accelerate-fftw";
        version = "0.0";
-       sha256 = "03ffsa6xshhrx8a4grld128g46x2nkkydwql8h7jw7b2igr7i1ks";
+       sha256 = "7a8678f28b621d2e0f4414f3e6e7b4a21bf290088de64714ea1942dd8dd2ce0d";
        libraryHaskellDepends = [
          accelerate accelerate-io base carray fft storable-complex
        ];
@@ -17154,7 +17174,7 @@ self: {
      mkDerivation {
        pname = "accelerate-fourier";
        version = "0.0";
-       sha256 = "0b7cm540im3z9ja7a68sbs5y0ayzbx5h4sbwr437f05qdwkg7b2q";
+       sha256 = "58acf3266fb8007706c97c69024b5fdf2be08b5e1a1975944c7fd40848a9ec2c";
        libraryHaskellDepends = [
          accelerate accelerate-arithmetic accelerate-utility base containers
          QuickCheck transformers utility-ht
@@ -17177,7 +17197,7 @@ self: {
      mkDerivation {
        pname = "accelerate-fourier-benchmark";
        version = "0.0";
-       sha256 = "1679sn9ajn6fmj9pdgjdr434vcgj05chvn2fld3sri16q3jbqrga";
+       sha256 = "ea65bce4c026c4ac47a34ed80d5901f2b14d06c94dbe7693acce58a992d5e998";
        isLibrary = false;
        isExecutable = true;
        executableHaskellDepends = [
@@ -17197,7 +17217,7 @@ self: {
      mkDerivation {
        pname = "accelerate-io";
        version = "0.15.0.0";
-       sha256 = "00p8jmxsgywhx30nd44pl6hdcr076y2s6z2fsam6sgrmgr0qx936";
+       sha256 = "66a48e417e353f6daad24e7ca385370764d6a0a1979066c1e890fba77b95e802";
        revision = "1";
        editedCabalFile = "5c3f8f7ebc03117652646329743ea251d281f72d81454e55538c27e87e8c0ecc";
        libraryHaskellDepends = [
@@ -17215,7 +17235,7 @@ self: {
      mkDerivation {
        pname = "accelerate-utility";
        version = "0.1";
-       sha256 = "1n5hyklil2x2x5bc5z7iq0yz4p8lab8xxdnlwzgjpn3lliq0vgpv";
+       sha256 = "fbbe0d70a474d82bdfe7d4b6ded152145df23dc0f1fcc256e9a20b1ae9f4b0d8";
        libraryHaskellDepends = [ accelerate base utility-ht ];
        jailbreak = true;
        homepage = "http://code.haskell.org/~thielema/accelerate-utility/";
@@ -17229,7 +17249,7 @@ self: {
      mkDerivation {
        pname = "accentuateus";
        version = "0.9.4";
-       sha256 = "16hgs81cs3zgbvsprh9lzvyxbh58g7rijf1d4j0dkrpnqnrvg0hy";
+       sha256 = "1e82b7b3c5f6e6d980242d3819f379a8c0d5fdfe34c17cf55eef0fcd02d20f9a";
        libraryHaskellDepends = [ base bytestring HTTP json network text ];
        jailbreak = true;
        homepage = "http://accentuate.us/";
@@ -17243,7 +17263,7 @@ self: {
      mkDerivation {
        pname = "access-time";
        version = "0.1.0.4";
-       sha256 = "13kg8mjrnif88r0w7b041x4vmzdm9aqrx4fskc3qv3smpq2q2ngs";
+       sha256 = "fa598105be558f8d079bda919eb14ab5fdba490f04acc34146c8459b65456f8e";
        libraryHaskellDepends = [ base filepath old-time time unix ];
        jailbreak = true;
        homepage = "http://www.github.com/batterseapower/access-time";
@@ -17259,7 +17279,7 @@ self: {
      mkDerivation {
        pname = "ace";
        version = "0.6";
-       sha256 = "0f07j2rj9ylvdrijwwlpx66mj503mhjfq1x2mylpxkr6kmjjniyk";
+       sha256 = "d3472b659d26cf7ea9afa207ec24ac0314598de997722e636e9bfa24b3900738";
        libraryHaskellDepends = [
          attoparsec base blaze-html blaze-markup data-default parsec text
        ];
@@ -17278,7 +17298,7 @@ self: {
      mkDerivation {
        pname = "acid-state";
        version = "0.12.4";
-       sha256 = "0mb2p29pi9dhby2bwn6zkg1nn3sf6vr7xzf6npx3738ffj3b2bad";
+       sha256 = "4d2db186740e8d33fab5c6fd7ef2364e0f6bc39bdf58be845fb0a57893b86255";
        libraryHaskellDepends = [
          array base bytestring cereal containers directory
          extensible-exceptions filepath mtl network safecopy stm
@@ -17296,7 +17316,7 @@ self: {
      mkDerivation {
        pname = "acid-state-tls";
        version = "0.9.2";
-       sha256 = "04w3r1x3msvsixmdlif99ly4k0py9bzb8pgi06j780zz5lpm1zpi";
+       sha256 = "f1fe502f2dff0374a401f15db4fe4afe82493c4dc945da6a8f7aeb3a7ac88313";
        libraryHaskellDepends = [
          acid-state base directory HsOpenSSL network safecopy
        ];
@@ -17311,7 +17331,7 @@ self: {
      mkDerivation {
        pname = "acl2";
        version = "0.0.1";
-       sha256 = "0bwlsdxk3lbir90xhar7xd83cwarqcm0a86gvwaghknpil2ay4cg";
+       sha256 = "8f11af048dd74ef814dfcf20052ac359713650eb272bd841ca71d1317bd3942f";
        libraryHaskellDepends = [ base process ];
        description = "Writing and calling ACL2 from Haskell";
        license = stdenv.lib.licenses.bsd3;
@@ -17322,7 +17342,7 @@ self: {
      mkDerivation {
        pname = "acme-all-monad";
        version = "0.1.0.0";
-       sha256 = "1qay7m16yjsjg8anbinkagb2v8r67k5wsppkrwyskn9jcb1wnbgv";
+       sha256 = "fb2dcbc36232d9a93dcff35ecdcb3c26a32dd653d3c665157a524b6f423d5ee1";
        libraryHaskellDepends = [ base transformers ];
        jailbreak = true;
        description = "A monad which is powerful enough to interpret any action";
@@ -17334,7 +17354,7 @@ self: {
      mkDerivation {
        pname = "acme-box";
        version = "0.0.0.0";
-       sha256 = "0n6mawj9kq6s84j4yxwqabhni7kzgvhmhxi9dw1mrwnxkh5ial8v";
+       sha256 = "1b51150b9cddf25c036f297658e17e7f9e68e15298774f2441dae0992457d558";
        isLibrary = true;
        isExecutable = true;
        libraryHaskellDepends = [ base ];
@@ -17350,7 +17370,7 @@ self: {
      mkDerivation {
        pname = "acme-cadre";
        version = "0.1";
-       sha256 = "1nclcq48r547rgmd4h0hf498z27d15lp4da9yb3a3sy7qk6m92bi";
+       sha256 = "718954cdc4c7eba1c6f24935726909ed888f12711040d2eacb87948c086694d9";
        libraryHaskellDepends = [ base ];
        description = "car, cdr and more";
        license = stdenv.lib.licenses.publicDomain;
@@ -17361,7 +17381,7 @@ self: {
      mkDerivation {
        pname = "acme-cofunctor";
        version = "0.1.0.0";
-       sha256 = "06ii13zfr5iqf0cxaw35mxjxx16q0n7mvbgnqv0gwyfmgm3vxv6m";
+       sha256 = "d5ecbe477dd579fec0c6f6ad5d8f05d884de65af6570d519703896ecfe08311a";
        libraryHaskellDepends = [ base ];
        homepage = "https://github.com/jaspervdj/acme-cofunctor";
        description = "A Cofunctor is a structure from category theory dual to Functor";
@@ -17373,7 +17393,7 @@ self: {
      mkDerivation {
        pname = "acme-colosson";
        version = "0.1";
-       sha256 = "0mfnav0wb0ks365n3kghaic6nasp3qaznhmsdccx35h164ixj9vc";
+       sha256 = "6c27d923310196d1196bba42fb151e572b6b5854f0cd618b197a82c5c156d655";
        libraryHaskellDepends = [ base random ];
        description = "Determines whether it is numberwang";
        license = stdenv.lib.licenses.bsd3;
@@ -17384,7 +17404,7 @@ self: {
      mkDerivation {
        pname = "acme-comonad";
        version = "0.1.0.0";
-       sha256 = "1sc0alwdgfls18y4q4y0qkbzqm4fgzd9yv6dwwnzw3472vsz2x8s";
+       sha256 = "1a75f1f516870cfe2de7cd6c9fda7f8e54fcd7c4c0134c3c0a9abad7385580e9";
        libraryHaskellDepends = [ base comonad ];
        jailbreak = true;
        description = "A more efficient dualization";
@@ -17396,7 +17416,7 @@ self: {
      mkDerivation {
        pname = "acme-cutegirl";
        version = "0.2.0.0";
-       sha256 = "1vvhfncnrq4pbzrgq45kannqv1c029b96lvi1qzwvzf513rqfb3z";
+       sha256 = "7f2c87f308c5fdcd3f0e715393561280858dad55b310fcf25f97e06c997570ef";
        isLibrary = true;
        isExecutable = true;
        libraryHaskellDepends = [ base ];
@@ -17411,7 +17431,7 @@ self: {
      mkDerivation {
        pname = "acme-dont";
        version = "1.1";
-       sha256 = "1kj3qjgn1rz093050z49w3js4is9p0g9pk5g7d7wvg28hpzk28n3";
+       sha256 = "c32231ff8548bccd4f3bafcc9b1eb84947a2e5e0897c50c048e0e7609fc443ce";
        libraryHaskellDepends = [ base ];
        description = "A don't construct";
        license = stdenv.lib.licenses.bsd3;
@@ -17422,19 +17442,31 @@ self: {
      mkDerivation {
        pname = "acme-flipping-tables";
        version = "0";
-       sha256 = "1xl5gwc67acg47fdkgrn7sjvvvnc4sjf5vifph0jb3c7gv93n757";
+       sha256 = "a71c3bd27e878d2501bc2eeee2a426cceebda53e36bfd9dc218fa963187f85f6";
        libraryHaskellDepends = [ base ];
        homepage = "http://github.com/jystic/acme-flipping-tables";
        description = "Stop execution with rage";
        license = stdenv.lib.licenses.bsd3;
      }) {};
 
+  "acme-grawlix" = callPackage
+    ({ mkDerivation, base }:
+     mkDerivation {
+       pname = "acme-grawlix";
+       version = "0.1.0.2";
+       sha256 = "56f3f73854e790aab0f41a209033f4b6893dc418cc8fef6a448b8fb046dc0c9c";
+       libraryHaskellDepends = [ base ];
+       homepage = "https://github.com/kadoban/acme-grawlix";
+       description = "More readable names for commonly used symbols";
+       license = stdenv.lib.licenses.bsd3;
+     }) {};
+
   "acme-hq9plus" = callPackage
     ({ mkDerivation, base }:
      mkDerivation {
        pname = "acme-hq9plus";
        version = "0.1";
-       sha256 = "0da4ysj74fmhcbbvxxfb6w97pr870518k90vwnc3z8kglj1ni187";
+       sha256 = "07856883a46fa23f98e51ba489420107e57b1237cbf5bed762b03a72a4f64435";
        libraryHaskellDepends = [ base ];
        homepage = "http://github.com/joeyadams/haskell-acme-hq9plus";
        description = "An embedded DSL for the HQ9+ programming language";
@@ -17449,7 +17481,7 @@ self: {
      mkDerivation {
        pname = "acme-http";
        version = "0.2.2";
-       sha256 = "1nmv8ilh783jrp6mxl308ybv032xi833awhsys7svma3l9v5i4gi";
+       sha256 = "f1915876a243d5ad8ff61a7235068a5d0cb0974760d05ecdcd72a0036944bbda";
        isLibrary = true;
        isExecutable = true;
        libraryHaskellDepends = [
@@ -17466,7 +17498,7 @@ self: {
      mkDerivation {
        pname = "acme-inator";
        version = "0.1.0.0";
-       sha256 = "1h1vdzqarrmb8sl6y6250h6fia4rxi9vz4i4sj7km7nyk3778zyk";
+       sha256 = "d37f74ce98de9e3a8fd42492bf53ec99a8e80c0445186fa846abe6acf06f3bc0";
        isLibrary = true;
        isExecutable = true;
        libraryHaskellDepends = [ base ];
@@ -17481,7 +17513,7 @@ self: {
      mkDerivation {
        pname = "acme-io";
        version = "0.1.0.1";
-       sha256 = "091czdcbydc75ndaw2ns8cncxa6ihlvclhrbcz9vp29kvhf483cb";
+       sha256 = "8b0d441cdc3389bbd3672b43ca3685d1a8ce2c43da0aae9a2d8735bf58fb2c24";
        libraryHaskellDepends = [ base ];
        jailbreak = true;
        homepage = "N/A";
@@ -17494,7 +17526,7 @@ self: {
      mkDerivation {
        pname = "acme-lolcat";
        version = "0.1.1";
-       sha256 = "08issbr9lgc2saqvgs80sxl1sgi7ig5jg6iykv1g1zl5k1kv2a32";
+       sha256 = "6228b1679885fef0c29e3e9a27cb8b273e1d68d700e9b7b1d2823d9af2d23a22";
        libraryHaskellDepends = [ base parsec random random-shuffle text ];
        homepage = "https://github.com/llelf/acme-lolcat";
        description = "LOLSPEAK translator";
@@ -17506,7 +17538,7 @@ self: {
      mkDerivation {
        pname = "acme-lookofdisapproval";
        version = "0.1";
-       sha256 = "194xvcab14bs3b3nrayxp4z3da60afxa9cmip58mkms5016kwhis";
+       sha256 = "3a423e4d0045d75951b9b1b2a4ba53c0a8363eb9ddab6cc71a7a91b014db9da4";
        libraryHaskellDepends = [ base ];
        homepage = "https://github.com/llelf/acme-lookofdisapproval";
        description = "Express your disapproval";
@@ -17518,7 +17550,7 @@ self: {
      mkDerivation {
        pname = "acme-memorandom";
        version = "0.0.3";
-       sha256 = "1l6kxmdb7fi47ldfpcqbl6h4dnzw6zw0ahxmvx6sxwxm3x4hynhi";
+       sha256 = "115a0f491fb5f3ae4ddfb54305f837fcdb46a0a10bb3eb1a3d24bab35aedd3d0";
        libraryHaskellDepends = [ base MemoTrie random ];
        homepage = "https://github.com/ion1/acme-memorandom";
        description = "Memoized random number generation";
@@ -17530,7 +17562,7 @@ self: {
      mkDerivation {
        pname = "acme-microwave";
        version = "0.1.0.2";
-       sha256 = "136lwxcimj241nq9l0x7icxk1q9xz826sg07d40yj87shir52j39";
+       sha256 = "6948517284fa20e90169073c6d04fa3de1303b8ba7039ab00d44c81a59e7d48c";
        libraryHaskellDepends = [ base ];
        description = "The eighth wonder of the world, kitchen math!";
        license = stdenv.lib.licenses.bsd3;
@@ -17541,7 +17573,7 @@ self: {
      mkDerivation {
        pname = "acme-miscorder";
        version = "0.1.0.0";
-       sha256 = "180fs64vlbxb2700qq8hzzz82kkmpknakkbk66ddkk1pdl7nm0j4";
+       sha256 = "44826a0f6d37ccd99a3173cda9ecbc754e81feff10610cc011ab2fba89d10ea0";
        libraryHaskellDepends = [ base random ];
        jailbreak = true;
        description = "Miscellaneous newtypes for orderings of discutable use";
@@ -17553,7 +17585,7 @@ self: {
      mkDerivation {
        pname = "acme-missiles";
        version = "0.3";
-       sha256 = "0nvkgdj04i21gq5k541an8zjz0hzzy7dpi384yrhcyh14jsxhqz5";
+       sha256 = "e563d8b524017a06b32768c4db8eff1f822f3fb22a90320b7e414402647b735b";
        libraryHaskellDepends = [ base stm ];
        description = "Cause serious international side effects";
        license = stdenv.lib.licenses.publicDomain;
@@ -17564,7 +17596,7 @@ self: {
      mkDerivation {
        pname = "acme-now";
        version = "1.0.0.1";
-       sha256 = "0lnrsndx7r00b7vgh9jmp5j635m4pb2bzx0lfhqidkzfc2llzwsm";
+       sha256 = "55f34fa960eecf16317414f4bfc4baa4966164b95526f8f65900e4d39bd5d952";
        libraryHaskellDepends = [ base time ];
        jailbreak = true;
        description = "An interface to the philosophical and metaphysical \"now\"";
@@ -17576,7 +17608,7 @@ self: {
      mkDerivation {
        pname = "acme-numbersystem";
        version = "0.3.0.0";
-       sha256 = "1p5rdssdmds6yqgv3yvlh835h180h9q9430j8i6qrhygqn8lmv87";
+       sha256 = "07ed4a91c5cfc38c4d44120c927082000558068274fbb11ff646b7dab46eb9dc";
        libraryHaskellDepends = [ base template-haskell ];
        jailbreak = true;
        description = "Define the less than and add and subtract for nats";
@@ -17589,7 +17621,7 @@ self: {
      mkDerivation {
        pname = "acme-omitted";
        version = "2.0.0.0";
-       sha256 = "0pj6jlm4i05m0nys8d66d0xfkhfz6gfa9122bsk64xcms5n0hxad";
+       sha256 = "4d75086cd1957562a65e4284a4dc33dfc1e93a68c634a4bd05b580482a95465e";
        libraryHaskellDepends = [ base ];
        testHaskellDepends = [ base hspec ];
        homepage = "https://github.com/joachifm/acme-omitted#readme";
@@ -17602,7 +17634,7 @@ self: {
      mkDerivation {
        pname = "acme-one";
        version = "0.0.2";
-       sha256 = "11sgx648g5594w8m8x8r25x7s61jyyxazp5dcfyglvhc7zlrrvbb";
+       sha256 = "6bed9ce93f0c6efabc63addcafbaf732187d7a111975541127a9948788e94f87";
        homepage = "https://github.com/ion1/acme-zero-one";
        description = "The identity element of package dependencies";
        license = stdenv.lib.licenses.publicDomain;
@@ -17613,7 +17645,7 @@ self: {
      mkDerivation {
        pname = "acme-operators";
        version = "0.2.0.0";
-       sha256 = "1wf12iphv12srygdvhy7xyja453dzjmm6kd9l2qp00fx986zd01w";
+       sha256 = "3c80f60d4add0170b1a0a94d53abfc6d14a2a4efc7c3dd9ecf5a840d6f14c1f1";
        libraryHaskellDepends = [ base ];
        homepage = "https://github.com/phadej/acme-operators#readme";
        description = "Operators of base, all in one place!";
@@ -17625,7 +17657,7 @@ self: {
      mkDerivation {
        pname = "acme-php";
        version = "0.0.3";
-       sha256 = "091ddg3441ac6hbzd84jzakll7nvz2r6mcfdwxy8d7rd8wx9jdyz";
+       sha256 = "df37993a472d9f867ce7cdb16ab2f8db1e4aa7fa92a0f617344c0542c66b2d24";
        libraryHaskellDepends = [ base ];
        description = "The flexibility of Haskell and the safety of PHP";
        license = stdenv.lib.licenses.bsd3;
@@ -17636,7 +17668,7 @@ self: {
      mkDerivation {
        pname = "acme-pointful-numbers";
        version = "0.1.2.4";
-       sha256 = "02gml2db5vigkwkx99lqzjkpfaqdc74x16bgdx62kf7r3nn37my9";
+       sha256 = "c9d733ac1df9b8294c6f6f99d0c9610d2b77a7fc98a6d4279f2feeb29aa0f509";
        libraryHaskellDepends = [ base split ];
        description = "Make more than one point in numeric literals";
        license = stdenv.lib.licenses.bsd3;
@@ -17647,7 +17679,7 @@ self: {
      mkDerivation {
        pname = "acme-realworld";
        version = "0.1.1";
-       sha256 = "0ffhichjhhic7d5cjypmd2zmcq0dpqiz5ygsw0y67v83hry0vf8r";
+       sha256 = "19b90d7c8603ed633ce0faf9f223be0d6056bf68f57ac94a3b2c4228218bd039";
        libraryHaskellDepends = [ base ];
        description = "Primitives for manipulating the state of the universe";
        license = stdenv.lib.licenses.bsd3;
@@ -17658,7 +17690,7 @@ self: {
      mkDerivation {
        pname = "acme-safe";
        version = "0.1.0.0";
-       sha256 = "0bmv45b3v45967gdvsy37xfw6x50qpl8234y20m3nc48f4nf0z68";
+       sha256 = "c87ce02c7188303b2a109e0c81e8c5a074c35d3fc3ebddde31a9903d5621bb2e";
        libraryHaskellDepends = [ acme-dont base ];
        homepage = "http://github.com/fgaz/acme-safe";
        description = "Safe versions of some infamous haskell functions such as fromJust";
@@ -17672,7 +17704,7 @@ self: {
      mkDerivation {
        pname = "acme-schoenfinkel";
        version = "0.1.1";
-       sha256 = "0jvbrivxpq8jb5rhz6j3pxx2g3d0ckviprp4iza31d6ik7cpk8ad";
+       sha256 = "4da179d999d1b430d48fe4e61bf764a08d277abf439a0f735912e1db77cc6b4b";
        libraryHaskellDepends = [ base ];
        testHaskellDepends = [
          base QuickCheck test-framework test-framework-quickcheck2
@@ -17688,7 +17720,7 @@ self: {
      mkDerivation {
        pname = "acme-strfry";
        version = "0.1";
-       sha256 = "1r6xnkyx22khzq6hlb8bk0fnbb6hlwbf12wajhx8vcxa7bkhh8lb";
+       sha256 = "8b2208e73aaab38d3a948a8be016a7d0ac651d980b2d0a0dfe700ad1fdb4dde4";
        libraryHaskellDepends = [ base bytestring ];
        jailbreak = true;
        homepage = "https://github.com/ehird/acme-strfry";
@@ -17701,7 +17733,7 @@ self: {
      mkDerivation {
        pname = "acme-stringly-typed";
        version = "1.0.0.0";
-       sha256 = "18wvsvdmbwh9dcawiy4f9pn4vg98kdq9zxc37sz7dpmaigimw16f";
+       sha256 = "ce045ee38baade76be3e83f59f709b28bd4dec4d8ef8c8156b09f255dbd69ba3";
        libraryHaskellDepends = [ base ];
        jailbreak = true;
        description = "Stringly Typed Programming";
@@ -17713,7 +17745,7 @@ self: {
      mkDerivation {
        pname = "acme-strtok";
        version = "0.1.0.3";
-       sha256 = "1anj8yygzcqkl4nwqwbrmwsqda84qcl8yzq7pgx2b7p895xcfa68";
+       sha256 = "c828c77a49e89e25fabb077f8f28c304a98635af7971cc2da113b3ffbc47d2aa";
        libraryHaskellDepends = [ base mtl ];
        description = "A Haskell port of the C/PHP strtok function";
        license = stdenv.lib.licenses.publicDomain;
@@ -17724,7 +17756,7 @@ self: {
      mkDerivation {
        pname = "acme-timemachine";
        version = "0.0.1.0";
-       sha256 = "1dfwn0n4hg6zs4ikz6jzkn2spwsvchs1jgq7662aq4ljyp7f1rvb";
+       sha256 = "6be7e0cef59212ac8431073f1934645bf3ab859d5f9a3f23d1df3c482cb0dcb5";
        libraryHaskellDepends = [ base ghc-prim mtl transformers ];
        description = "An easy way to perform and unperform IO and other stateful actions";
        license = stdenv.lib.licenses.bsd3;
@@ -17735,7 +17767,7 @@ self: {
      mkDerivation {
        pname = "acme-year";
        version = "2015";
-       sha256 = "1ymsxy51vi2i75jkq0hfm2ii8qp78c3g35ijma0ygcrq9mmm12rv";
+       sha256 = "3b8b506b4d38b3e781aa3296f10643e76214a3a80e023c653951c41d8aefbafa";
        libraryHaskellDepends = [ base ];
        testHaskellDepends = [ base time ];
        homepage = "http://github.com/joeyadams/hs-acme-year";
@@ -17748,7 +17780,7 @@ self: {
      mkDerivation {
        pname = "acme-zero";
        version = "0.0.2";
-       sha256 = "06d4hpda8qwwq9wzkgx6fpiq39l1md8sfm9hnvh4r95xyg5q53f6";
+       sha256 = "c68d82cbf3bda44ce0b63055a751ab81a681e375a6bff979c29c63a4da85a419";
        jailbreak = true;
        homepage = "https://github.com/ion1/acme-zero-one";
        description = "The absorbing element of package dependencies";
@@ -17761,7 +17793,7 @@ self: {
      mkDerivation {
        pname = "action-permutations";
        version = "0.0.0.1";
-       sha256 = "0rhlzpwshixpnqma7sk28f22dkwz39b6lcwnzmd31rcnz5cyw6d4";
+       sha256 = "a419ee59f996e5305afd96336a561a9fcf26844362eaa32ab6b747a8f9fd1466";
        libraryHaskellDepends = [ base ];
        description = "Execute a set of actions (e.g. parsers) in each possible order";
        license = stdenv.lib.licenses.bsd3;
@@ -17774,7 +17806,7 @@ self: {
      mkDerivation {
        pname = "active";
        version = "0.2.0.4";
-       sha256 = "1xm2y8knqhd883c41194h323vchv4hx57wl32l9f64kf7gdglag0";
+       sha256 = "e029fada3b6e12e3121583f2533a241bb23dc480248540d840a8416c27f2a2f6";
        libraryHaskellDepends = [
          base lens linear semigroupoids semigroups vector
        ];
@@ -17796,7 +17828,7 @@ self: {
      mkDerivation {
        pname = "activehs";
        version = "0.3.1";
-       sha256 = "03za0c24a22fy28mcm173r0cca6fk60jikp0pp817mrq6gpv62hc";
+       sha256 = "0c0ab3ef3338d713d0bde0ce288199ce28c6401e27545691f04e08450403ea0f";
        isLibrary = false;
        isExecutable = true;
        executableHaskellDepends = [
@@ -17817,7 +17849,7 @@ self: {
      mkDerivation {
        pname = "activehs-base";
        version = "0.3.0.3";
-       sha256 = "1q433by9ygs7rrjj8z76hg94zyh2cp4qiwsv7q1mywr5scfccn32";
+       sha256 = "6258c61cd325735f033e5bf388c96502fa4fd283e67c2465ce473f9ffc1a83e0";
        libraryHaskellDepends = [ base QuickCheck ];
        jailbreak = true;
        description = "Basic definitions for activehs";
@@ -17829,7 +17861,7 @@ self: {
      mkDerivation {
        pname = "activitystreams-aeson";
        version = "0.2.0.1";
-       sha256 = "1bprj41552zr1aj0k73c3skdhg8jb60rhcm9p9hjcmy2al9izsag";
+       sha256 = "4fe91f1355c2572661baa932988159123dd8a61e6c9c09a40af98b520291f9ae";
        libraryHaskellDepends = [
          aeson base text time unordered-containers
        ];
@@ -17843,7 +17875,7 @@ self: {
      mkDerivation {
        pname = "actor";
        version = "0.1.1";
-       sha256 = "1ic74yrfy6hk7217vh2ff6yacvf3dc5m1hjkcpfvxzdk5xhdv2b5";
+       sha256 = "6589dd602fb3fdbedd6553c2500b6bc36da6bc714ec07d8238131aefb22787c5";
        libraryHaskellDepends = [ base haskell98 stm time ];
        homepage = "http://sulzmann.blogspot.com/2008/10/actors-with-multi-headed-receive.html";
        description = "Actors with multi-headed receive clauses";
@@ -17859,7 +17891,7 @@ self: {
      mkDerivation {
        pname = "ad";
        version = "4.2.3";
-       sha256 = "0w9nd8llzcjb91x1d3mh5482pavbx1jpn8w2ahm6ydjwvijjd9r5";
+       sha256 = "25a72665dc5c366f2a5482237b65e86bab2b1029b08e167a484bb24f296a3671";
        libraryHaskellDepends = [
          array base comonad containers data-reify erf free nats reflection
          transformers
@@ -17876,7 +17908,7 @@ self: {
      mkDerivation {
        pname = "adaptive-containers";
        version = "0.3";
-       sha256 = "16h0zi55hf9g07xisbcmgkx72m9laiqykh2r9nh2siczx3sxi1qk";
+       sha256 = "1387d8f5e89f452da04d59c0e97154345571fa7c952d1dfb012f39584afc009a";
        libraryHaskellDepends = [ base ];
        homepage = "http://code.haskell.org/~dons/code/adaptive-containers";
        description = "Self optimizing container types";
@@ -17889,7 +17921,7 @@ self: {
      mkDerivation {
        pname = "adaptive-tuple";
        version = "0.2.0";
-       sha256 = "1kf4d3qf8nv61c7pajv234b2vil84c2cq40csnm456lg55qh53r1";
+       sha256 = "218f0271298f9a42aad50c10cc042388c62d1619624b750f0b665be4f068c4cd";
        libraryHaskellDepends = [ base template-haskell type-level ];
        homepage = "http://inmachina.net/~jwlato/haskell/";
        description = "Self-optimizing tuple types";
@@ -17903,7 +17935,7 @@ self: {
      mkDerivation {
        pname = "adb";
        version = "0.1.0.0";
-       sha256 = "17dxvdzmg3i8n0gbgbj0jyhm90w0dq7j27id8n24frild2w4c0d0";
+       sha256 = "a00146b86834664784452d1e210f6e808354a19740aeb71eb0288e577fdbbd9d";
        libraryHaskellDepends = [
          base bytestring cereal containers mtl network
        ];
@@ -17920,7 +17952,7 @@ self: {
      mkDerivation {
        pname = "adblock2privoxy";
        version = "1.3.3";
-       sha256 = "1iy0dmaw48nvgq4cqlx41n51almhz1w4k7rjpgsxqbsdnlwd8zdl";
+       sha256 = "b47dd438b54d2fdcf5bb329f4978f8b052158a0da453cc087edb22c2556dc0c7";
        isLibrary = false;
        isExecutable = true;
        executableHaskellDepends = [
@@ -17939,7 +17971,7 @@ self: {
      mkDerivation {
        pname = "addLicenseInfo";
        version = "0.1";
-       sha256 = "054kcm0ibh1qdkyci36w3yxwxln56hz1yvi7gskp636nzhw5sjrw";
+       sha256 = "3c4b5d38fcd60c73a77e276e1f3e34c5d2cebb1fdc8cc8fc6c38c01541659314";
        isLibrary = false;
        isExecutable = true;
        executableHaskellDepends = [ base process ];
@@ -17955,7 +17987,7 @@ self: {
      mkDerivation {
        pname = "adhoc-network";
        version = "1.0.3";
-       sha256 = "1whdrmxw13nr7bb95rhqaz3klgmcwx4ai51bz5yb38nldf4ac377";
+       sha256 = "e70ca6886bd4a2b17cf92b94a848e7ac3e3ac75718e692d63ad98ec07bcd0df2";
        libraryHaskellDepends = [
          base bytestring containers Crypto dataenc HaXml hsgnutls network
          old-locale parsec pkcs1 random time utf8-string xml-parsec
@@ -17973,7 +18005,7 @@ self: {
      mkDerivation {
        pname = "adict";
        version = "0.4.1";
-       sha256 = "07w3595cwlicvwg04w9i5sg1x9d3r8c64pq0yi5pmnza7jpd5vgq";
+       sha256 = "f8edd2ae3ceadb7a4bf4005f6218caa3a51e9e2e3171021edf2c52ce4a2a831f";
        libraryHaskellDepends = [
          array base binary containers dawg PSQueue vector
        ];
@@ -17995,7 +18027,7 @@ self: {
      mkDerivation {
        pname = "adjunctions";
        version = "4.2.1";
-       sha256 = "0vzlz2q6863ywnhvax3m5xq99x6bz1h47z7z8hmnqdfg5pa4r9k5";
+       sha256 = "65a64cd42dcf356c2b44fffc4360f8cbf494702f7574b5a1e57e1864b0f8f46f";
        libraryHaskellDepends = [
          array base comonad containers contravariant distributive free mtl
          profunctors semigroupoids semigroups tagged transformers void
@@ -18012,7 +18044,7 @@ self: {
      mkDerivation {
        pname = "adobe-swatch-exchange";
        version = "0.2.0";
-       sha256 = "0jc6xwh1m2hmpfclsi27233775kp4yk0wrkr498qx7fs6p7xflpv";
+       sha256 = "fb52d7cf35da9d8e512279660ea627779673c61047444d99bb158a1a20ef8649";
        isLibrary = true;
        isExecutable = true;
        libraryHaskellDepends = [
@@ -18036,7 +18068,7 @@ self: {
      mkDerivation {
        pname = "adp-multi";
        version = "0.2.3";
-       sha256 = "1lmmyxa22lm9a86w0gap8g676mnh5l1kxczbsv8ymb98fzcg6a27";
+       sha256 = "4728f3d87728adead1d6ebb33e032dd05673cc43573dc00d52a9522154f7b5d2";
        isLibrary = true;
        isExecutable = true;
        libraryHaskellDepends = [ array base containers htrace ];
@@ -18058,7 +18090,7 @@ self: {
      mkDerivation {
        pname = "adp-multi-monadiccp";
        version = "0.2.1";
-       sha256 = "13zlmhgyf46pcnrjwcrk7l6nmrkgqvycrajq3v7z72kjixakis6s";
+       sha256 = "dae838558f728af3cf1e58aaccfcc66fe66a0d3d33332eb365d710e71facf48f";
        isLibrary = true;
        isExecutable = true;
        libraryHaskellDepends = [ adp-multi base containers monadiccp ];
@@ -18083,7 +18115,7 @@ self: {
      mkDerivation {
        pname = "aeson";
        version = "0.7.0.6";
-       sha256 = "0vsf9msz9iv7xvsnys5c0kbkldb0pvhiai02vz50b0d1kdsk2mb4";
+       sha256 = "645531759ba18105cadf024415e1be60353ad704ac686ff5ee67c7f4754d4e6f";
        revision = "1";
        editedCabalFile = "8b87a1343dd8d93d98e48e530f2ec14f5949fcdc96c8ecc81458a1d20defd001";
        libraryHaskellDepends = [
@@ -18112,7 +18144,7 @@ self: {
      mkDerivation {
        pname = "aeson";
        version = "0.9.0.1";
-       sha256 = "1g7qdq7zpyvqwmh4sfhizqpb51cg24lrcj9vq5msz8k896y7vfcj";
+       sha256 = "92b97dbc4968a2af6bc13b499629118f85b22efe113a4d60e578fbfb0f6ef8bc";
        libraryHaskellDepends = [
          attoparsec base bytestring containers deepseq dlist ghc-prim
          hashable mtl scientific syb template-haskell text time transformers
@@ -18133,7 +18165,7 @@ self: {
      mkDerivation {
        pname = "aeson-applicative";
        version = "0.1.0.0";
-       sha256 = "0plbpln1glmf8a53f4nag1lx7sy8lcali6f1m526zifgak99p3qz";
+       sha256 = "1f8f9bd254cfc56f44a9c1994815a3c8ebd36978ca12378a42aed2172cbd8b5e";
        libraryHaskellDepends = [ aeson base text unordered-containers ];
        jailbreak = true;
        homepage = "https://github.com/gregwebs/aeson-applicative-dsl";
@@ -18149,7 +18181,7 @@ self: {
      mkDerivation {
        pname = "aeson-better-errors";
        version = "0.9.0";
-       sha256 = "00b9mjf636pfgg50961y86qbkpix19x5pvbzlha0mr0icqqaan76";
+       sha256 = "e658a5306611e40a14a47fed5b7a0a3ddeb9b0413e9804ca7bee9a619cac6901";
        libraryHaskellDepends = [
          aeson base bytestring dlist mtl scientific text transformers
          transformers-compat unordered-containers vector void
@@ -18166,7 +18198,7 @@ self: {
      mkDerivation {
        pname = "aeson-bson";
        version = "0.3.0";
-       sha256 = "0a4hrx56q1kfvf2ff9flsmrpgpvz3rshri9dpj4a9bf76ah04jn9";
+       sha256 = "c94a02a032c7ada488bc2dc50c751e7fdf7773d5d425e784db6e066c4acf9028";
        libraryHaskellDepends = [
          aeson array attoparsec base bson bytestring containers text
          unordered-containers vector
@@ -18184,7 +18216,7 @@ self: {
      mkDerivation {
        pname = "aeson-casing";
        version = "0.1.0.2";
-       sha256 = "07r19341n6k5pxk0xr7y5sylxgd9ryyhj7gx2irxhqsg9hn11yax";
+       sha256 = "5df9102c4c4f63d87314fd1d09bdcfa9bd4ebd2efee40e66bf651a1bc848211f";
        libraryHaskellDepends = [ aeson base ];
        testHaskellDepends = [
          aeson base tasty tasty-hunit tasty-quickcheck tasty-th
@@ -18202,7 +18234,7 @@ self: {
      mkDerivation {
        pname = "aeson-diff";
        version = "0.1.1.2";
-       sha256 = "00bmvdnqhw364i1j2f1n2didfzpgs93ia8djmmq81adgry73xmbq";
+       sha256 = "78d53e8ecfafa98070adb2211547d2ef7ed7621336382143246670886ddb7501";
        isLibrary = true;
        isExecutable = true;
        libraryHaskellDepends = [
@@ -18228,7 +18260,7 @@ self: {
      mkDerivation {
        pname = "aeson-lens";
        version = "0.5.0.0";
-       sha256 = "1pr8cxkx41wi7095cp1gpqrwadwx6azcrdi1kr1ik0fs6606dkks";
+       sha256 = "7ace668031da8119439e21b6ccbe329d37c533be2f5c5612389107d2676728df";
        libraryHaskellDepends = [
          aeson base bytestring lens text unordered-containers vector
        ];
@@ -18245,7 +18277,7 @@ self: {
      mkDerivation {
        pname = "aeson-native";
        version = "0.3.3.2";
-       sha256 = "1s5i88r8sdd7ayrpjw6f18273k6r0igk0sswb503hzvjagzmzffh";
+       sha256 = "d0b95fff53727f3840595c6b305f04d9cc71040ace7079b357a7358d3242b1e8";
        revision = "1";
        editedCabalFile = "c9519a30bce75564cfbe84aade5ffb99fad12ecea1c7d2c362cca2234b8ae497";
        libraryHaskellDepends = [
@@ -18267,7 +18299,7 @@ self: {
      mkDerivation {
        pname = "aeson-pretty";
        version = "0.7.2";
-       sha256 = "03ap81853qi8yd9kdgczllrrni23a6glsfxrwj8zab6ipjrbh234";
+       sha256 = "6408b8b2bcd12cf591e4b93b4d9f5143449b33a59fbd3653f328e2515040570d";
        isLibrary = true;
        isExecutable = true;
        libraryHaskellDepends = [
@@ -18282,21 +18314,21 @@ self: {
      }) {};
 
   "aeson-qq" = callPackage
-    ({ mkDerivation, aeson, attoparsec, base, ghc-prim
+    ({ mkDerivation, aeson, attoparsec, base, base-compat, ghc-prim
      , haskell-src-meta, hspec, parsec, scientific, template-haskell
      , text, vector
      }:
      mkDerivation {
        pname = "aeson-qq";
-       version = "0.8.0";
-       sha256 = "12vs3mh1a6j2r74xr11bpzb69i0k25dxplhvw15ph72kmhfbri7f";
+       version = "0.8.1";
+       sha256 = "2dcd2392902baac446e317621df509b09db9dca9b8c9187e53701226f18013fd";
        libraryHaskellDepends = [
-         aeson attoparsec base haskell-src-meta parsec scientific
-         template-haskell text vector
+         aeson attoparsec base base-compat haskell-src-meta parsec
+         scientific template-haskell text vector
        ];
        testHaskellDepends = [
-         aeson attoparsec base ghc-prim haskell-src-meta hspec parsec
-         scientific template-haskell text vector
+         aeson attoparsec base base-compat ghc-prim haskell-src-meta hspec
+         parsec scientific template-haskell text vector
        ];
        homepage = "http://github.com/zalora/aeson-qq";
        description = "JSON quasiquoter for Haskell";
@@ -18314,7 +18346,7 @@ self: {
      mkDerivation {
        pname = "aeson-schema";
        version = "0.3.0.7";
-       sha256 = "1r84ih3bhnzfl3hl6a4ph4x2l25ls11py3mrxqd04kcpyqzsll5g";
+       sha256 = "af50aa3ff6974d021aeeb90e7f43d0b4082a3a81972843e1a0ee5bb8068c04e5";
        libraryHaskellDepends = [
          aeson attoparsec base bytestring containers ghc-prim mtl QuickCheck
          regex-base regex-compat regex-pcre scientific syb template-haskell
@@ -18336,7 +18368,7 @@ self: {
      mkDerivation {
        pname = "aeson-serialize";
        version = "0.0.0";
-       sha256 = "010lbzm5ik2gdiqm8slnf9kwgbnz8ib03c901schrw5kildfxq51";
+       sha256 = "a1e0ee1a8db3f00c990e20b1015644dfaec76772966a54716c4fcc58ea5f1404";
        libraryHaskellDepends = [ aeson base cereal ];
        testHaskellDepends = [ aeson base cereal hspec HUnit ];
        description = "Simple serialization functions for aeson types";
@@ -18350,7 +18382,7 @@ self: {
      mkDerivation {
        pname = "aeson-smart";
        version = "0.2.0.0";
-       sha256 = "1r3262k6d7nskbnnam5rw5vq7i84347amz8lk6hrjn3c4bwacf35";
+       sha256 = "6538a6f8226c5899a19914fdaa0e1904c58377e1b95465ed9ada9e66a63062e4";
        libraryHaskellDepends = [
          aeson base data-default template-haskell text unordered-containers
          vector
@@ -18369,7 +18401,7 @@ self: {
      mkDerivation {
        pname = "aeson-streams";
        version = "0.1.0";
-       sha256 = "1mmkilvjrffzbf7d024kpc4i6b72f7dbq5hrkvrzr0q7dg1mg825";
+       sha256 = "45a057c36b0783fcf39e1916bcda71e22c1309bb9308d08e5bdfb92c378db3d6";
        libraryHaskellDepends = [
          aeson attoparsec base bytestring HsOpenSSL http-streams io-streams
        ];
@@ -18386,7 +18418,7 @@ self: {
      mkDerivation {
        pname = "aeson-t";
        version = "0.0.5";
-       sha256 = "1mpqkjxsg4bpmbkj8ys39g53knw851l428x83619bmvnlrj1fkkd";
+       sha256 = "6d4e1764a676d7958219a82341682888db39ca4b437b24e7aa7791a7bb9cf8d6";
        libraryHaskellDepends = [
          aeson base bytestring text unordered-containers vector
        ];
@@ -18405,7 +18437,7 @@ self: {
      mkDerivation {
        pname = "aeson-toolkit";
        version = "0.0.1";
-       sha256 = "07cb4f4zwm64x0q5z63gsskl80s6qbwnk4nl6x2jiardcl3k8cl3";
+       sha256 = "83323407652dab284537d49269f9c2460344a7d66f985f30e8c454fe89238b1d";
        libraryHaskellDepends = [ aeson base bytestring failure text ];
        testHaskellDepends = [ base hspec ];
        description = "A generalization of Aeson over Failure";
@@ -18419,7 +18451,7 @@ self: {
      mkDerivation {
        pname = "aeson-utils";
        version = "0.3.0.2";
-       sha256 = "07sbvmm158yqmw4hri9l66ag4r6l59x230gbjm9r97w4x0dlp0bi";
+       sha256 = "71814b1be8849f945395eb81217a2ad464f2943134c50c09afd8a3126add4b1f";
        libraryHaskellDepends = [
          aeson attoparsec base bytestring scientific text
        ];
@@ -18434,7 +18466,7 @@ self: {
      mkDerivation {
        pname = "affine-invariant-ensemble-mcmc";
        version = "0.2.0.0";
-       sha256 = "116ln9zf4n0xy95nyyb3kwhg7ds36m793ys5yd5ha74vqf48gvk5";
+       sha256 = "65ee8788c39b1c054bf345fb914e3543b7f3209f63796f4bf21d58e27eb2d484";
        libraryHaskellDepends = [
          base containers mwc-random primitive split vector
        ];
@@ -18452,7 +18484,7 @@ self: {
      mkDerivation {
        pname = "afis";
        version = "0.1.2";
-       sha256 = "0ppq3rbwszz3wczg0zgk8hjqplv2ck11bbq5xr8306s5n02ybcf9";
+       sha256 = "c9b1e505b0451b3050ee05af15c26462d38b2544f37df03ee3e37fcd571ef85e";
        libraryHaskellDepends = [
          base byteable bytestring crypto-random cryptohash packer
        ];
@@ -18473,7 +18505,7 @@ self: {
      mkDerivation {
        pname = "afv";
        version = "0.1.1";
-       sha256 = "06p2xp5myipjhyzqak4zwr755kc1l4qljdf2bxn8rg0m7rhy01vk";
+       sha256 = "7307e0613e15bc8c6c5fc2354931a181cd524ee69f4c85bf87f2465fcbede21a";
        isLibrary = false;
        isExecutable = true;
        executableHaskellDepends = [
@@ -18494,7 +18526,7 @@ self: {
      mkDerivation {
        pname = "agda-server";
        version = "0.1.1";
-       sha256 = "070xszykrazkisp1lsh2q1ri1i64lhd8psz8g4blv37zm899fpga";
+       sha256 = "ea5d9712aaff8c4d1779e8eb8b1aa4c4c41073c0026a1aae8ef3ab3cfdd71d1c";
        isLibrary = false;
        isExecutable = true;
        executableHaskellDepends = [
@@ -18515,7 +18547,7 @@ self: {
      mkDerivation {
        pname = "agentx";
        version = "0.2.0.0";
-       sha256 = "0pmnrij90xag46af4c5yws5g26pf77l5ck864f4cyw5g9acw67g6";
+       sha256 = "e61dc3994aaf70cf8823064d56e839ee1af18ae6be30e294214f759064ccb65e";
        isLibrary = true;
        isExecutable = true;
        libraryHaskellDepends = [
@@ -18537,7 +18569,7 @@ self: {
      mkDerivation {
        pname = "agum";
        version = "2.6";
-       sha256 = "1j2qlwnvg7rxjx8fk3y5n3wjkikv1d17p8grh4gzp4c5a7pn5kim";
+       sha256 = "35ce62ef518591fb1f81f9a17b420b7bc629f9b0c58fe950973d9fb72da758c8";
        isLibrary = true;
        isExecutable = true;
        libraryHaskellDepends = [ base containers ];
@@ -18551,7 +18583,7 @@ self: {
      mkDerivation {
        pname = "aig";
        version = "0.2.3";
-       sha256 = "0363wr5fnryz49ksj6mvwngpqi2bj7ldgyzh6hgvmvvdz5nmmxzr";
+       sha256 = "f9f75a6df96defba1f34f0fbd7e8914b447c9fe5bb1aa96722df67eb4ae6c30c";
        libraryHaskellDepends = [ base mtl QuickCheck vector ];
        description = "And-inverter graphs in Haskell";
        license = stdenv.lib.licenses.bsd3;
@@ -18564,7 +18596,7 @@ self: {
      mkDerivation {
        pname = "air";
        version = "2015.5.4";
-       sha256 = "1g9zzsxhmkiqpdmmapsvvh3vq5dp5gmmyr0x7ja59529xndslwaj";
+       sha256 = "5271aa9bed499454943c1d645feb2bb715bc07dc5b5f556bbb38ce0abbfe3fbd";
        libraryHaskellDepends = [
          array base bytestring containers directory filepath mtl text time
        ];
@@ -18580,7 +18612,7 @@ self: {
      mkDerivation {
        pname = "air-extra";
        version = "2015.5.4";
-       sha256 = "07k01yjr9kj5q0dr871w9jmf23sdd75xrwgldsrkpppfc8kvnd97";
+       sha256 = "2735bb2762eede3bb36ef4f1dccb694d0fe1aa4c3c1c941bc045ce94a50f601e";
        libraryHaskellDepends = [
          air array base bytestring containers directory filepath parallel
          parsec regexpr text time
@@ -18595,7 +18627,7 @@ self: {
      mkDerivation {
        pname = "air-spec";
        version = "2013.7.1";
-       sha256 = "0s4y2805nmfydzxgr5lnhmyzkb6rh9mx2kpvzqqgyh4jvccdnwfx";
+       sha256 = "dd71db18db9240ff30fefb4ed16b82d9acf97d859696fcfa6fde555b00129e68";
        libraryHaskellDepends = [ base hspec text ];
        homepage = "https://github.com/nfjinjing/air-spec";
        description = "air spec helper";
@@ -18607,7 +18639,7 @@ self: {
      mkDerivation {
        pname = "air-th";
        version = "2014.11.17";
-       sha256 = "0rhp56qvwiwlrs7pvpbslybvlp4xnllfjab6pap2chxgywas34pq";
+       sha256 = "f892a115f7af4326aeba6629e928b59d5cba97a77add7d8fce9447beb1291766";
        libraryHaskellDepends = [ air base template-haskell ];
        homepage = "https://github.com/nfjinjing/air-th";
        description = "air";
@@ -18623,7 +18655,7 @@ self: {
      mkDerivation {
        pname = "airbrake";
        version = "0.2.0.0";
-       sha256 = "03z5hjrdwv8kjsj1vhipqhfmc19mi5cnjkcvcm71b0gmnpd71shq";
+       sha256 = "18ea70dab5f581154e659b4d6959893505561dc437c21da496136ddeb284e50f";
        libraryHaskellDepends = [
          base blaze-markup bytestring directory exceptions filepath
          http-conduit monad-control network semigroups template-haskell text
@@ -18647,7 +18679,7 @@ self: {
      mkDerivation {
        pname = "airship";
        version = "0.3.0.0";
-       sha256 = "118valfn96mwdl8pfrvpqgp1rg9armcwlw2r4lvvzb6ci0nyp9n8";
+       sha256 = "c8a6eb2d88ccacbf37255970ca59cd2abd1ceec3776777116dbc9a641d551b85";
        isLibrary = true;
        isExecutable = true;
        libraryHaskellDepends = [
@@ -18675,7 +18707,7 @@ self: {
      mkDerivation {
        pname = "aivika";
        version = "4.3";
-       sha256 = "01vcjc6i040lp92xhxma6sp3iffam9d7nxqch6i64pajvd8cq97j";
+       sha256 = "f224cc50db525d62a2810c777b5aaacab938ae36aa76d845ba1410100d936c07";
        libraryHaskellDepends = [
          array base containers mtl random vector
        ];
@@ -18691,7 +18723,7 @@ self: {
      mkDerivation {
        pname = "aivika-experiment";
        version = "4.0.3";
-       sha256 = "1v0x37kmav87b3mxvribw6658glf5hbk7npipkabp1qbfz5sp7zv";
+       sha256 = "fb9fabcb770b87bbd4bcf1da33172c8e3e548ce12be6ddeb58076d55e7191dec";
        libraryHaskellDepends = [
          aivika base containers directory filepath mtl network-uri
          parallel-io split
@@ -18708,7 +18740,7 @@ self: {
      mkDerivation {
        pname = "aivika-experiment-cairo";
        version = "4.3.1";
-       sha256 = "0p54ssbl0ack51gwlj962x45954v4h22mqq6zqa5r8xrbcig2pdb";
+       sha256 = "ab5df1225bb9a35c14fe06e32a04249b945448172649ca5f2893294097d6a45c";
        libraryHaskellDepends = [
          aivika-experiment aivika-experiment-chart base Chart Chart-cairo
        ];
@@ -18725,7 +18757,7 @@ self: {
      mkDerivation {
        pname = "aivika-experiment-chart";
        version = "4.3.1";
-       sha256 = "18fagq4ddvqzi6r0c850yassgncicqy0plasfn262fmhgwflpa8n";
+       sha256 = "16a94b1d7fb03a6184755ad10b3c6691d9a7b5f2a02006b2891fefd6087ecaa1";
        libraryHaskellDepends = [
          aivika aivika-experiment array base Chart colour containers
          data-default-class filepath lens mtl split
@@ -18742,7 +18774,7 @@ self: {
      mkDerivation {
        pname = "aivika-experiment-diagrams";
        version = "4.3.1";
-       sha256 = "1plb44bcjnawg3fsb9crmlyzwzyiz802ldsk559ni9sb590ywr7n";
+       sha256 = "f664ee412a4ba768532953372a00fad17ffe3dad99a5a5dd785c59c916218bde";
        libraryHaskellDepends = [
          aivika-experiment aivika-experiment-chart base Chart Chart-diagrams
          containers filepath
@@ -18760,7 +18792,7 @@ self: {
      mkDerivation {
        pname = "aivika-transformers";
        version = "3.0";
-       sha256 = "1b9hkza735g1gxr3l73fz48y29fyph89j8114wzld3ydma2f6d1z";
+       sha256 = "3f34e384aacd8f463f2721209910bcde25e111f96e1c3a727fe19571d49f30ad";
        libraryHaskellDepends = [
          aivika array base containers mtl random vector
        ];
@@ -18779,7 +18811,7 @@ self: {
      mkDerivation {
        pname = "ajhc";
        version = "0.8.0.10";
-       sha256 = "1x2rc0gyyg7idc07hi64fvkv5h5a652kmcrczfxqyzbiyx2fjphs";
+       sha256 = "1a5ee944f7717d8fbbfb2cb33a4531aac0b2e776c44478006bf13cef1f6059f4";
        isLibrary = true;
        isExecutable = true;
        libraryHaskellDepends = [
@@ -18803,7 +18835,7 @@ self: {
      mkDerivation {
        pname = "al";
        version = "0.1.4";
-       sha256 = "1jr707fhsl1jvjidaznxj7xsi6br2v7gzckfhvcrmicd4i98yg1q";
+       sha256 = "383c8f52248dc59ad9866eb2ffce167999a8fb91dd7ed5a2dc32500ddd0127cb";
        libraryHaskellDepends = [ base mtl ];
        libraryPkgconfigDepends = [ openal ];
        libraryToolDepends = [ c2hs ];
@@ -18817,7 +18849,7 @@ self: {
      mkDerivation {
        pname = "alarmclock";
        version = "0.2.0.8";
-       sha256 = "1g06bnbp0y6dcz7zgbh828klk7xc1spwzw3ff6jpqh74cm82vq6f";
+       sha256 = "cee02d5065e4407ca5716ef0cfaf0eac9f49271208aef7cf67cd7870975d06bc";
        libraryHaskellDepends = [ base stm time unbounded-delays ];
        testHaskellDepends = [ base time ];
        homepage = "https://bitbucket.org/davecturner/alarmclock";
@@ -18830,7 +18862,7 @@ self: {
      mkDerivation {
        pname = "alea";
        version = "0.4.0.0";
-       sha256 = "1j18hqyrfyyhngla4dikdchi659bi7gj1lsl38r08645hf9n5395";
+       sha256 = "258d629383851804321a54d320df892b1513216b3336a2e8b3d07b973d8628c8";
        isLibrary = false;
        isExecutable = true;
        executableHaskellDepends = [ argparser base containers threefish ];
@@ -18847,7 +18879,7 @@ self: {
      mkDerivation {
        pname = "alex";
        version = "3.1.4";
-       sha256 = "17x13nbbr79xgdlzywjqw19vcl6iygjnssjnxnajgijkv764wknn";
+       sha256 = "d64e4eccd953c62795ed566a6de5f3d150b653e05872ff697b3d9dbc961da19f";
        isLibrary = false;
        isExecutable = true;
        executableHaskellDepends = [
@@ -18866,7 +18898,7 @@ self: {
      mkDerivation {
        pname = "alex-meta";
        version = "0.3.0.8";
-       sha256 = "1ja5y2dyil4h6j7q9dhrxzhry018fqc7vy3v5mrkvxyp7bhw1n9f";
+       sha256 = "2ed9c0e13ad7f73d732d7bf87d187628009fe1ef19b6848f3490d0e89bf045c9";
        libraryHaskellDepends = [
          array base containers haskell-src-meta QuickCheck template-haskell
        ];
@@ -18882,7 +18914,7 @@ self: {
      mkDerivation {
        pname = "alfred";
        version = "0.5";
-       sha256 = "1c6ak56g29wkas66x7yhg1zk039mp2mvlp7njixchhh2c4kx9fvn";
+       sha256 = "76bbd427610242c87a94f65cbaabb8350d307f78d09f6e8c569327f14c99cab0";
        revision = "1";
        editedCabalFile = "06e4b9ba672fc3d29452df70d2e9f9018ada5e8b62aa5890b9a70d9d937d6581";
        libraryHaskellDepends = [
@@ -18900,7 +18932,7 @@ self: {
      mkDerivation {
        pname = "algebra";
        version = "4.2";
-       sha256 = "1b74c55326qsnpyqzyhyq87j61wp3zrpsqhipgw8db8nm2lq9nhs";
+       sha256 = "1ada84a9a816ad86f8bb11627df31f9707230fc21efa8ffdb51a1b314a61e4ac";
        revision = "1";
        editedCabalFile = "621c4b71305b0a6a926f055608b5ca76c4c2360a523bcdf88d80fd10d20f4210";
        libraryHaskellDepends = [
@@ -18920,7 +18952,7 @@ self: {
      mkDerivation {
        pname = "algebra-dag";
        version = "0.1.1.1";
-       sha256 = "1pr6bbj67n13bw120l82zn5bj7bj0x00b754w852pbpij03fjay9";
+       sha256 = "c92be90690f1ae2b0ae2a49c054007721db98afd025120025f23d863e45a26df";
        libraryHaskellDepends = [
          aeson base containers fgl mtl parsec template-haskell transformers
        ];
@@ -18937,7 +18969,7 @@ self: {
      mkDerivation {
        pname = "algebra-sql";
        version = "0.3.0.0";
-       sha256 = "1wvm9qkixmyawwjd6ypshsmby7y7229zwidj3qhzkbmyi7p5sgzj";
+       sha256 = "f23f5dee89beaef9211eb245fe9310c71fbfaa86fa7ad324e7cad71e274e75f3";
        isLibrary = true;
        isExecutable = true;
        libraryHaskellDepends = [
@@ -18959,7 +18991,7 @@ self: {
      mkDerivation {
        pname = "algebraic";
        version = "0.1.0.2";
-       sha256 = "15gv6w9vz02960r6bd0k979vi6kj7pfxg705ajbrsd1pnwklfnwh";
+       sha256 = "905b4727b737349d9754059cd7dd3d729ab8d34913b46532304980bf1337fb95";
        libraryHaskellDepends = [ accelerate base ];
        jailbreak = true;
        homepage = "https://github.com/wdanilo/algebraic";
@@ -18973,7 +19005,7 @@ self: {
      mkDerivation {
        pname = "algebraic-classes";
        version = "0.6";
-       sha256 = "0i34n1lmnw12xrnaqvmiydnnlm8m8ky12chwb9jmnsf3klv8qm61";
+       sha256 = "c1548c369dc3695b655a1c3211fc4415556a6df3b16eac6cee22705b69b06444";
        libraryHaskellDepends = [ base syb template-haskell ];
        jailbreak = true;
        homepage = "https://github.com/sjoerdvisscher/algebraic-classes";
@@ -18986,7 +19018,7 @@ self: {
      mkDerivation {
        pname = "align";
        version = "0.1.1.2";
-       sha256 = "1bv7x687ga563kdnl23smrspljq32bkaarq4zdg071glqckrffq9";
+       sha256 = "093b9727c3f485035efb0467a5e612034b7a75ae7a086adb1ca6a87790e967af";
        libraryHaskellDepends = [ base containers transformers vector ];
        description = "Sequence alignment algorithms";
        license = stdenv.lib.licenses.bsd3;
@@ -18997,7 +19029,7 @@ self: {
      mkDerivation {
        pname = "align-text";
        version = "0.1.0.1";
-       sha256 = "1vn8l9lxih2w8bjkfl8j4xxi8p44c1gqia63gi143xk9s035rjh2";
+       sha256 = "02ca5c06d069f641427cc3a8885f60845c147b27125137e5425cc0d869a2c8ee";
        isLibrary = false;
        isExecutable = true;
        executableHaskellDepends = [ base optparse-applicative text ];
@@ -19012,7 +19044,7 @@ self: {
      mkDerivation {
        pname = "aligned-foreignptr";
        version = "0.1";
-       sha256 = "0hmnp08k04c0ag9fyp5sajg54r4gi57vrd9krk4g8y8fri0fgc00";
+       sha256 = "00b0e740cc0e79f4c8cc33b5bc4f898f64529e54ba5cefd25380113011b8b642";
        libraryHaskellDepends = [ base ];
        homepage = "http://code.haskell.org/~bkomuves/";
        description = "An aligned ForeignPtr type";
@@ -19024,7 +19056,7 @@ self: {
      mkDerivation {
        pname = "allocated-processor";
        version = "0.0.2";
-       sha256 = "0jhz3q0972snrgd9c7lr934ddkwllwgw6anj7ax8hj4zi0zc615m";
+       sha256 = "b504c33e889f4888ba3ad22ac31fa794cfd6c848991e96dacb568b93001e1f4a";
        libraryHaskellDepends = [ base vector-space ];
        description = "Functional combinators for monadic actions that require allocation and de-allocation";
        license = stdenv.lib.licenses.bsd3;
@@ -19035,7 +19067,7 @@ self: {
      mkDerivation {
        pname = "alloy";
        version = "1.2.1";
-       sha256 = "00bndi30yhd92vwij3dwhbj79dhv9n3l45bw01mfqak45gqbfwyv";
+       sha256 = "db73b7f02b642aec6a007c1542874d1bb674e482bc0d19f916a9410f466c7601";
        libraryHaskellDepends = [ base containers mtl syb vector ];
        description = "Generic programming library";
        license = stdenv.lib.licenses.bsd3;
@@ -19046,7 +19078,7 @@ self: {
      mkDerivation {
        pname = "alloy-proxy-fd";
        version = "1.0.0";
-       sha256 = "1fhk5ydnf0l0n579gqg5lfg2cc9z8xbgqsqzgkpcw0046kp53rjw";
+       sha256 = "5ce651ee340400ceee7c1f6bfc56473f31269ea3e5e1974eb18002679b2f13ba";
        libraryHaskellDepends = [ alloy base mtl ];
        description = "Some add-on instances for the Alloy library";
        license = stdenv.lib.licenses.bsd3;
@@ -19057,7 +19089,7 @@ self: {
      mkDerivation {
        pname = "almost-fix";
        version = "0.0.2";
-       sha256 = "03x715jcrsxfs2d08hsg3y5f6a4bnlzfxsmhzimvpdp9bw0psn90";
+       sha256 = "20597d015fe9b6bb6bfcb0eaee3eb58b28e38a1f4f43049ad0aeebcc6409a70f";
        libraryHaskellDepends = [ base ];
        description = "Recurse while a predicate is satisfied";
        license = stdenv.lib.licenses.bsd3;
@@ -19072,7 +19104,7 @@ self: {
      mkDerivation {
        pname = "alms";
        version = "0.6.7";
-       sha256 = "1xickrpjx2dn2pa5zcbjsfm5j6mqn54hpyzi7c6sv5i20hs2gamp";
+       sha256 = "b7aa2734042296ad0d3bf1fb0b49b1b81a59aad372b15fd415b6892e6f9e2cf6";
        isLibrary = false;
        isExecutable = true;
        executableHaskellDepends = [
@@ -19094,7 +19126,7 @@ self: {
      mkDerivation {
        pname = "alpha";
        version = "1.0.15";
-       sha256 = "1gc2kjyk75cxggy52w49j97q4gcn74q7f582q6kjb3gsp2pdrn09";
+       sha256 = "09d8dcaeb8fa8d25a7c10215773039963d824f92897051fc7b9d9533bd9c82bd";
        isLibrary = false;
        isExecutable = true;
        executableHaskellDepends = [
@@ -19117,7 +19149,7 @@ self: {
      mkDerivation {
        pname = "alpino-tools";
        version = "0.2.0";
-       sha256 = "1sh0mrlpfak5i20wqmz23ihphim4di802h02kyxj795gq8q6v61r";
+       sha256 = "39986d30c2afa423bb9f024001506ca44678611ce257cc8188652a7769ae00ea";
        isLibrary = true;
        isExecutable = true;
        libraryHaskellDepends = [
@@ -19141,7 +19173,7 @@ self: {
      mkDerivation {
        pname = "alsa";
        version = "0.4";
-       sha256 = "0zdnhi2wm7w6182k6mccm16x453g7kvbsqx2afnhfjpr3iaj69mg";
+       sha256 = "af2623551cf94a07ad53a263bdf63c6f14d24da88c5533050a869fca4584b67d";
        libraryHaskellDepends = [
          array base extensible-exceptions sample-frame
        ];
@@ -19158,7 +19190,7 @@ self: {
      mkDerivation {
        pname = "alsa-core";
        version = "0.5.0.1";
-       sha256 = "1avh4a419h9d2zsslg6j8hm87ppgsgqafz8ll037rk2yy1g4jl7b";
+       sha256 = "eb50495ef05ecc7c06a0147da7f0d3efde832a44d23caaf5172dc114882270ab";
        libraryHaskellDepends = [ base extensible-exceptions ];
        libraryPkgconfigDepends = [ alsaLib ];
        homepage = "http://www.haskell.org/haskellwiki/ALSA";
@@ -19173,7 +19205,7 @@ self: {
      mkDerivation {
        pname = "alsa-gui";
        version = "0.1";
-       sha256 = "0zcyjckdjhsj614iib3dzj9dfp8xj847jfqf4q1sk9311gscbzns";
+       sha256 = "dafec5f40b61a4a903260e3b7908921d5dd792fc6dac1849305243d926939e7d";
        isLibrary = false;
        isExecutable = true;
        executableHaskellDepends = [
@@ -19192,7 +19224,7 @@ self: {
      mkDerivation {
        pname = "alsa-midi";
        version = "0.4.0.1";
-       sha256 = "1dmc336irhw6wdny6f2za9n3gnd83i3pcfr7qfkm8fzq6kzkkjy3";
+       sha256 = "c3cb39ff34f83b54a7c3273b76471ca8d9376c525f38e36de386c31ccd18acb6";
        isLibrary = true;
        isExecutable = true;
        libraryHaskellDepends = [
@@ -19212,7 +19244,7 @@ self: {
      mkDerivation {
        pname = "alsa-mixer";
        version = "0.2.0.2";
-       sha256 = "11sc2n879a8rb9yz54cb8vg8rplgapbymzy785p7n7638xx877hk";
+       sha256 = "139e837a47c31c7b6e41c7ffead7558fde8cde468b91f27d5a19a97490154c87";
        libraryHaskellDepends = [ alsa-core base unix ];
        librarySystemDepends = [ alsaLib ];
        libraryToolDepends = [ c2hs ];
@@ -19228,7 +19260,7 @@ self: {
      mkDerivation {
        pname = "alsa-pcm";
        version = "0.6.0.3";
-       sha256 = "0rq0i17xhd0x7dnlhdf3i1fdvmyxrsbm0w0k9lrx20xpy4gw2zfs";
+       sha256 = "da7dc11ff1b703d1334d13705097ceddd7dd5c88c335486d3b1d34d84f880067";
        isLibrary = true;
        isExecutable = true;
        libraryHaskellDepends = [
@@ -19246,7 +19278,7 @@ self: {
      mkDerivation {
        pname = "alsa-pcm-tests";
        version = "0.1";
-       sha256 = "1bhrjf731jqs5297zcid5b6mmdh2njqx2hxssd077a4iqvm0c21k";
+       sha256 = "330806eac691a87340d3ba43d1b1b402b65acd2a2db27f92281acb308e9319ae";
        isLibrary = false;
        isExecutable = true;
        executableHaskellDepends = [ alsa base ];
@@ -19263,7 +19295,7 @@ self: {
      mkDerivation {
        pname = "alsa-seq";
        version = "0.6.0.5";
-       sha256 = "1ll42nlhjwgzan9h1vzyyyhilj9d41l3gavnbahhgbr8h9wb2f0j";
+       sha256 = "1238b1788228af07a15a76ab3768202d491aa1f7feef009355ff7109a91584d2";
        isLibrary = true;
        isExecutable = true;
        libraryHaskellDepends = [
@@ -19281,7 +19313,7 @@ self: {
      mkDerivation {
        pname = "alsa-seq-tests";
        version = "0.1";
-       sha256 = "0is11wdymarzm5zlilh572j1nw3akxma0czbswvgy391pj1a007s";
+       sha256 = "fa00a082bc210dff36d7eb33a06a9f6a701ba43805d2487fa93fabea1b0f4147";
        isLibrary = false;
        isExecutable = true;
        executableHaskellDepends = [ alsa base ];
@@ -19296,7 +19328,7 @@ self: {
      mkDerivation {
        pname = "altcomposition";
        version = "0.2.2.0";
-       sha256 = "0893802bwdmywl5jh5d6mdf7l4h4qyc5y53mp39xc5lx6dsiq1d9";
+       sha256 = "a9051c75339d16d6d3b875145f98c704127a5caba615280be5be36be04402321";
        libraryHaskellDepends = [ base composition ];
        homepage = "https://github.com/jcristovao/altcomposition";
        description = "Alternative combinators for unorthodox function composition";
@@ -19310,7 +19342,7 @@ self: {
      mkDerivation {
        pname = "alternative-io";
        version = "0.0.1";
-       sha256 = "01hypbci3hw2czkmx78ls51ycx518ich4k753jgv0z8ilrq8isch";
+       sha256 = "90e98870a6117db09f1ce54c025944a174e643d1149d5ee76782c311d9ba1e06";
        revision = "1";
        editedCabalFile = "982094590ae1e54131d4b1285eaec6d4160717a2864858f90a3511522fc591d6";
        libraryHaskellDepends = [
@@ -19325,7 +19357,7 @@ self: {
      mkDerivation {
        pname = "altfloat";
        version = "0.3.1";
-       sha256 = "1n0mxgl1jzap74sglw85l0595lhaj493bz46b90cnsqr5as9mal8";
+       sha256 = "88aa9ab42a196bcb405a86fc3512910ad2920aa00571fa3439577d19e8eb15d8";
        libraryHaskellDepends = [ base ghc-prim integer-gmp ];
        homepage = "http://repo.or.cz/w/altfloat.git";
        description = "Alternative floating point support for GHC";
@@ -19338,7 +19370,7 @@ self: {
      mkDerivation {
        pname = "alure";
        version = "0.1";
-       sha256 = "1nrlw8qdbgv3l99mlcql35zknyj767fgh3f53y2mjksrh0p61v8n";
+       sha256 = "16ed602e80594f59851fc50df8dc31477a3b7f1914335a53a263bfd530e234db";
        libraryHaskellDepends = [ base OpenAL ];
        librarySystemDepends = [ alure ];
        description = "A Haskell binding for ALURE";
@@ -19354,7 +19386,7 @@ self: {
      mkDerivation {
        pname = "amazon-emailer";
        version = "0.4.0.0";
-       sha256 = "0s8m16qbcz6jgxx83sx1swg2217bvv3q3pm8b7f2jsn33nihrzxx";
+       sha256 = "bdff0ca31dc36a29dc59a8de81c7deeb04211ed7a1eb817a7fd27cb6b0091569";
        isLibrary = false;
        isExecutable = true;
        executableHaskellDepends = [
@@ -19374,7 +19406,7 @@ self: {
      mkDerivation {
        pname = "amazon-emailer-client-snap";
        version = "0.1.1.1";
-       sha256 = "03am5nzacq2wd9jf46fnwmwq2ghfsh3yd9s0mzrrkskd26q1askb";
+       sha256 = "6b6a15b0116dea99f3af40a7e607d40e3e8179e5d619e2646a5c60a6be2d550d";
        libraryHaskellDepends = [
          base mtl snap snaplet-postgresql-simple text
        ];
@@ -19393,7 +19425,7 @@ self: {
      mkDerivation {
        pname = "amazon-products";
        version = "0.1.0.1";
-       sha256 = "10y86b3bzx6yk0478pixh3hh4nkkh0qlwwr0ac2fn6sh1hd6c7sl";
+       sha256 = "541f661a0c501beb045320734e3180735a02e1803d5e740898def4bfc632c883";
        isLibrary = true;
        isExecutable = true;
        libraryHaskellDepends = [
@@ -19421,7 +19453,7 @@ self: {
      mkDerivation {
        pname = "amazonka";
        version = "0.3.6";
-       sha256 = "1snzrclzs275gks19glrrayiysvywzwpzx6y5hnwmm48z4lh4gsb";
+       sha256 = "4b3f0229f988d4ca2d2cdef47ff9e77e6b1fbdca99be14f47ce508fd29cbdfea";
        libraryHaskellDepends = [
          amazonka-core base bytestring conduit conduit-extra cryptohash
          cryptohash-conduit exceptions http-conduit lens mmorph
@@ -19438,7 +19470,7 @@ self: {
      mkDerivation {
        pname = "amazonka-autoscaling";
        version = "0.3.6";
-       sha256 = "11dkcf0arjimvdzdin690811hs9klhr4xbhmjxcvqmwjr0z0sbb9";
+       sha256 = "692d0d3ec89257bc599715ae4e32a43369180202c9d8d87edb35caac8063b385";
        libraryHaskellDepends = [ amazonka-core base ];
        homepage = "https://github.com/brendanhay/amazonka";
        description = "Amazon Auto Scaling SDK";
@@ -19450,7 +19482,7 @@ self: {
      mkDerivation {
        pname = "amazonka-cloudformation";
        version = "0.3.6";
-       sha256 = "0m64p8xgwskv5vyzkkd5cxcwg5a7qa86a8sndan7yffap5b4nzq3";
+       sha256 = "037f4b56b9ca397fac6a56236590c24795c75967a5cdf9fd2e7b6afe3abac454";
        libraryHaskellDepends = [ amazonka-core base ];
        homepage = "https://github.com/brendanhay/amazonka";
        description = "Amazon CloudFormation SDK";
@@ -19462,7 +19494,7 @@ self: {
      mkDerivation {
        pname = "amazonka-cloudfront";
        version = "0.3.6";
-       sha256 = "09kl01agnmq24r1ip2f047ayrlf95x51nm80l3g40lx91n3mc7rp";
+       sha256 = "371f56870da95340dea000551b4a2fc9d1ecd521c0891b43260257fb54007426";
        libraryHaskellDepends = [ amazonka-core base ];
        homepage = "https://github.com/brendanhay/amazonka";
        description = "Amazon CloudFront SDK";
@@ -19474,7 +19506,7 @@ self: {
      mkDerivation {
        pname = "amazonka-cloudhsm";
        version = "0.3.6";
-       sha256 = "0m17yjilg4d7hm8d5mbs3bqsm9hlxcybk9b49bj06266jcd9rxff";
+       sha256 = "cef59c1a93c60803e44a64a5b93ceb14a6aaf11a7ad5d25085a79147a3f42754";
        libraryHaskellDepends = [ amazonka-core base ];
        homepage = "https://github.com/brendanhay/amazonka";
        description = "Amazon CloudHSM SDK";
@@ -19486,7 +19518,7 @@ self: {
      mkDerivation {
        pname = "amazonka-cloudsearch";
        version = "0.3.6";
-       sha256 = "1hyapllcv5g2s8qxmyigy2k0fha9k07dd2jax69hkwi2qv88cks5";
+       sha256 = "454f86d0c622f20993e94a8ad60e98494107a6f02ffada31d2e295cd28bdcac3";
        libraryHaskellDepends = [ amazonka-core base ];
        homepage = "https://github.com/brendanhay/amazonka";
        description = "Amazon CloudSearch SDK";
@@ -19498,7 +19530,7 @@ self: {
      mkDerivation {
        pname = "amazonka-cloudsearch-domains";
        version = "0.3.6";
-       sha256 = "0dfi0flb77zjbjzdsfybr0hxwwdh2qd1pc5pry88l57iibjhmxym";
+       sha256 = "d5f70ae58af1148a90cfb7b01b1a16b071de21c8cb3bddbe5cf29fb3a803d135";
        libraryHaskellDepends = [ amazonka-core base ];
        homepage = "https://github.com/brendanhay/amazonka";
        description = "Amazon CloudSearch Domain SDK";
@@ -19510,7 +19542,7 @@ self: {
      mkDerivation {
        pname = "amazonka-cloudtrail";
        version = "0.3.6";
-       sha256 = "07b47dy9r1f7dl5zq6z1zx1xa9q4qlack49zy8y48x1im90dnc9x";
+       sha256 = "3d31db40aa3174443cf23f91c914c50427d543ffe11bfc0b6dc7859c7c3b641d";
        libraryHaskellDepends = [ amazonka-core base ];
        homepage = "https://github.com/brendanhay/amazonka";
        description = "Amazon CloudTrail SDK";
@@ -19522,7 +19554,7 @@ self: {
      mkDerivation {
        pname = "amazonka-cloudwatch";
        version = "0.3.6";
-       sha256 = "14vx5v9iicxv768637v8smzwj04nhd80dcrwrxq3yqqlq9mbk9nk";
+       sha256 = "d3a6b96ac214633f70cf3cb30650839600c97fd5689f619039bbb318d32e7d93";
        libraryHaskellDepends = [ amazonka-core base ];
        homepage = "https://github.com/brendanhay/amazonka";
        description = "Amazon CloudWatch SDK";
@@ -19534,7 +19566,7 @@ self: {
      mkDerivation {
        pname = "amazonka-cloudwatch-logs";
        version = "0.3.6";
-       sha256 = "15xpyfifqm6c5s4ysak1y0sgn6h5g9bapl69s9dpacg7nfpajqvb";
+       sha256 = "6b63a9aeb3e731755bd2c9d0ab567a051afb34f0612aed892ecc54eca2f3b797";
        libraryHaskellDepends = [ amazonka-core base ];
        homepage = "https://github.com/brendanhay/amazonka";
        description = "Amazon CloudWatch Logs SDK";
@@ -19546,7 +19578,7 @@ self: {
      mkDerivation {
        pname = "amazonka-codedeploy";
        version = "0.3.6";
-       sha256 = "1cp99l1kjm0w0jb1c4brq00dy4mn53pycra5gvlvz9k210g72ndm";
+       sha256 = "b559711e0862a6bfe97e4565e6ef28b612df00c079111696041c5439034de9b2";
        libraryHaskellDepends = [ amazonka-core base ];
        homepage = "https://github.com/brendanhay/amazonka";
        description = "Amazon CodeDeploy SDK";
@@ -19558,7 +19590,7 @@ self: {
      mkDerivation {
        pname = "amazonka-cognito-identity";
        version = "0.3.6";
-       sha256 = "1ig50w3z85y8g7hiq1hahbv529kq5pfrcpqwsrpf1zwynl50jjkz";
+       sha256 = "7f4a090ab59effe06ed61c5f96dd2d782651f6820a061ce179c817f40707e5c5";
        libraryHaskellDepends = [ amazonka-core base ];
        homepage = "https://github.com/brendanhay/amazonka";
        description = "Amazon Cognito Identity SDK";
@@ -19570,7 +19602,7 @@ self: {
      mkDerivation {
        pname = "amazonka-cognito-sync";
        version = "0.3.6";
-       sha256 = "1m6nw80ls7rl55ci36y2xvw8a1wfqiv64wm3q4anzmyybl50s133";
+       sha256 = "63040d0a5dded76f15c1a3726276c48e0785f8eec29b115929341f4d01e2d6d4";
        libraryHaskellDepends = [ amazonka-core base ];
        homepage = "https://github.com/brendanhay/amazonka";
        description = "Amazon Cognito Sync SDK";
@@ -19582,7 +19614,7 @@ self: {
      mkDerivation {
        pname = "amazonka-config";
        version = "0.3.6";
-       sha256 = "0aa73cmlaydayvy6vxbxdz5br8a6hsns3dn3s06r4nzxxy7zmfzg";
+       sha256 = "efbbfa8feffd5b920dd0c3b6a1ad8646a1bcca6f7df56dfcf6aa79452b1b4729";
        libraryHaskellDepends = [ amazonka-core base ];
        homepage = "https://github.com/brendanhay/amazonka";
        description = "Amazon Config SDK";
@@ -19601,7 +19633,7 @@ self: {
      mkDerivation {
        pname = "amazonka-core";
        version = "0.3.6";
-       sha256 = "1l60z0fcfbyrhi7r4lfy2a6b2vwc4bn1swd6ddna19qyq9fn67l2";
+       sha256 = "821e635dc21ea7a06c6ba6711dec228c6fb18c12de51924f84d92fc71cf8c0d0";
        libraryHaskellDepends = [
          aeson attoparsec base base16-bytestring base64-bytestring
          bifunctors bytestring case-insensitive conduit conduit-extra
@@ -19623,7 +19655,7 @@ self: {
      mkDerivation {
        pname = "amazonka-datapipeline";
        version = "0.3.6";
-       sha256 = "0p0k76hiif5nd4kxm1ww6p0srjfmmq8q3xln4sbkq8ss448zfymh";
+       sha256 = "b07af711215a233c972696f68111aed5c9acc1359c87da2769b6b818a139135c";
        libraryHaskellDepends = [ amazonka-core base ];
        homepage = "https://github.com/brendanhay/amazonka";
        description = "Amazon Data Pipeline SDK";
@@ -19635,7 +19667,7 @@ self: {
      mkDerivation {
        pname = "amazonka-directconnect";
        version = "0.3.6";
-       sha256 = "0q258fxwklm5xwyzram3kdq3ylayk498a02xzs7v2vb2vd3pmdb6";
+       sha256 = "66b57a47db626db18ffe5d008512995e513f709ba3aafc3defa5d2c9bb434560";
        libraryHaskellDepends = [ amazonka-core base ];
        homepage = "https://github.com/brendanhay/amazonka";
        description = "Amazon Direct Connect SDK";
@@ -19647,7 +19679,7 @@ self: {
      mkDerivation {
        pname = "amazonka-dynamodb";
        version = "0.3.6";
-       sha256 = "1k6kzip69sjakcw1y7n0xjd0qjpbrk604fs4hng8n6az107vbdjq";
+       sha256 = "58b6b50f085f198b9e85443b02cccceb4a0c9aecc01e1f389b4aea646efcd3cc";
        libraryHaskellDepends = [ amazonka-core base ];
        homepage = "https://github.com/brendanhay/amazonka";
        description = "Amazon DynamoDB SDK";
@@ -19659,7 +19691,7 @@ self: {
      mkDerivation {
        pname = "amazonka-ec2";
        version = "0.3.6.1";
-       sha256 = "19gyqga1qp50jsi6pykykkivfz18357p6pd6fg84bir0j9d4vawy";
+       sha256 = "9eab4d5a9220c745d073a65d734f19287cb7e39c7efa6ba296a05c1cd4c3fea5";
        libraryHaskellDepends = [ amazonka-core base ];
        homepage = "https://github.com/brendanhay/amazonka";
        description = "Amazon Elastic Compute Cloud SDK";
@@ -19671,7 +19703,7 @@ self: {
      mkDerivation {
        pname = "amazonka-ecs";
        version = "0.3.6";
-       sha256 = "1md59pdqir5prlfwlmlgd78g6c9gq0dszm2lxpa3kbv9zxs1kgfr";
+       sha256 = "d9bd1974ff69af39d4ed54d4af1bc02f31f3d0698f56ca1dcdb7e488db4da5d5";
        libraryHaskellDepends = [ amazonka-core base ];
        homepage = "https://github.com/brendanhay/amazonka";
        description = "Amazon EC2 Container Service SDK";
@@ -19683,7 +19715,7 @@ self: {
      mkDerivation {
        pname = "amazonka-elasticache";
        version = "0.3.6";
-       sha256 = "0hapj08jj89gl934zgkfj2lg9bsc71y1mvdl5dmv4vk8qrwp912a";
+       sha256 = "4a847479c6686eb26b2bb4ed1a7c384caff4a8906ebe4f46a22f212911905741";
        libraryHaskellDepends = [ amazonka-core base ];
        homepage = "https://github.com/brendanhay/amazonka";
        description = "Amazon ElastiCache SDK";
@@ -19695,7 +19727,7 @@ self: {
      mkDerivation {
        pname = "amazonka-elasticbeanstalk";
        version = "0.3.6";
-       sha256 = "1bpixxvj4rdx3v07f2pdky0xbz0kz5p3afjazwv8w588sj2i6773";
+       sha256 = "e31c1385d408158e36ff4a3a356ef913fcd5819fed0a77c01ebd652277eff1ae";
        libraryHaskellDepends = [ amazonka-core base ];
        homepage = "https://github.com/brendanhay/amazonka";
        description = "Amazon Elastic Beanstalk SDK";
@@ -19707,7 +19739,7 @@ self: {
      mkDerivation {
        pname = "amazonka-elastictranscoder";
        version = "0.3.6";
-       sha256 = "1rfnzwl6z0ym2ln5nbcx6an2iiqcwnb3rjki2jnxpqkv6hj8d1p8";
+       sha256 = "e8868624347be2dbad1471ca3c96e50cc728ac329d2d5b2c15d5836f28ffd6e5";
        libraryHaskellDepends = [ amazonka-core base ];
        homepage = "https://github.com/brendanhay/amazonka";
        description = "Amazon Elastic Transcoder SDK";
@@ -19719,7 +19751,7 @@ self: {
      mkDerivation {
        pname = "amazonka-elb";
        version = "0.3.6";
-       sha256 = "0yriv45wrxw9jns17idiqwxxvh086g3bg2hclzaanzxllir4jb59";
+       sha256 = "a92c4972a4b47fabd4a70c8ab7c63308c0dd3bc7b1c513b49589f7cc0bd9317b";
        libraryHaskellDepends = [ amazonka-core base ];
        homepage = "https://github.com/brendanhay/amazonka";
        description = "Amazon Elastic Load Balancing SDK";
@@ -19731,7 +19763,7 @@ self: {
      mkDerivation {
        pname = "amazonka-emr";
        version = "0.3.6";
-       sha256 = "0pv0li7823alrgl9w1fjx9i02ndk4k12fbb6z5z50krypcxp8819";
+       sha256 = "2920743bbb3e4f507ef9662d27c224b3590162ead2059ee8cb540d814ea4605f";
        libraryHaskellDepends = [ amazonka-core base ];
        homepage = "https://github.com/brendanhay/amazonka";
        description = "Amazon Elastic MapReduce SDK";
@@ -19743,7 +19775,7 @@ self: {
      mkDerivation {
        pname = "amazonka-glacier";
        version = "0.3.6";
-       sha256 = "0i3j1yha1hjj7imqn6m42329p3637v09hbjampq0c500dvy1j5dl";
+       sha256 = "b41519fc6e001406f0ad4a2e98c03ec38c9bc410a41a8b6b3c52c2a0a00f7244";
        libraryHaskellDepends = [ amazonka-core base ];
        homepage = "https://github.com/brendanhay/amazonka";
        description = "Amazon Glacier SDK";
@@ -19755,7 +19787,7 @@ self: {
      mkDerivation {
        pname = "amazonka-iam";
        version = "0.3.6";
-       sha256 = "0nzs9xn70f2a0n3xdnprwdk0mwnr23cgq0rwwxc83gf08i19nl8j";
+       sha256 = "12519b4244c0bd8158e73c03fcd810d9f20a66e3f9dad687054a38706c4ffa5b";
        libraryHaskellDepends = [ amazonka-core base ];
        homepage = "https://github.com/brendanhay/amazonka";
        description = "Amazon Identity and Access Management SDK";
@@ -19767,7 +19799,7 @@ self: {
      mkDerivation {
        pname = "amazonka-importexport";
        version = "0.3.6";
-       sha256 = "1qcqzqg9sxqaf5kb3l91n7zp5brdpyv2mhy7da08wxb16f1v1r9x";
+       sha256 = "3de5b0833361758e806ac7c32ab6bf2daf72ffb121d1b166710a779d1efe98e1";
        libraryHaskellDepends = [ amazonka-core base ];
        homepage = "https://github.com/brendanhay/amazonka";
        description = "Amazon Import/Export SDK";
@@ -19779,7 +19811,7 @@ self: {
      mkDerivation {
        pname = "amazonka-kinesis";
        version = "0.3.6";
-       sha256 = "0r4s5qfpirapg2gsgk9gbyp3ap4pz3cpnz4wdidlc4ys9v4vfhay";
+       sha256 = "5e41b7c94eda13465b6c9c7c7bd9f8975c35ae5f2fcda79f7857e5781d2e9a64";
        libraryHaskellDepends = [ amazonka-core base ];
        homepage = "https://github.com/brendanhay/amazonka";
        description = "Amazon Kinesis SDK";
@@ -19791,7 +19823,7 @@ self: {
      mkDerivation {
        pname = "amazonka-kms";
        version = "0.3.6";
-       sha256 = "1x68jg5m79rapwvb6nb9xmf2hwdv34r63r0aar742igpjwssxzn9";
+       sha256 = "c9feae3597f745414e560ae4613219bb71285ced6959b336bf2aa753cb93c8f4";
        libraryHaskellDepends = [ amazonka-core base ];
        homepage = "https://github.com/brendanhay/amazonka";
        description = "Amazon Key Management Service SDK";
@@ -19803,7 +19835,7 @@ self: {
      mkDerivation {
        pname = "amazonka-lambda";
        version = "0.3.6";
-       sha256 = "1g6gf64k60zanmv787rsg8zxnv6vxzdwv3dibwm5b00fzw7cshlp";
+       sha256 = "9742cd0eff0e80552a5fb18dcddbefdb6cdb3f7a3a1f7476b5ea03338971cfbc";
        libraryHaskellDepends = [ amazonka-core base ];
        homepage = "https://github.com/brendanhay/amazonka";
        description = "Amazon Lambda SDK";
@@ -19815,7 +19847,7 @@ self: {
      mkDerivation {
        pname = "amazonka-ml";
        version = "0.3.6";
-       sha256 = "0ma60mdn14xs3999yg98dzlx96arlwrc9wsvgf0gq6s6c0gnrc04";
+       sha256 = "04b06c1f60461bfc807b5bf3c432a75999d4e96f283d9f521aba93605b054655";
        libraryHaskellDepends = [ amazonka-core base ];
        homepage = "https://github.com/brendanhay/amazonka";
        description = "Amazon Machine Learning SDK";
@@ -19827,7 +19859,7 @@ self: {
      mkDerivation {
        pname = "amazonka-opsworks";
        version = "0.3.6";
-       sha256 = "1d9qgazp4qk6lc4isggb0rm50crp0s1qmz6m0s3wwfdwd6lvhaql";
+       sha256 = "142bb8a969bc39ce8706d5fc8a83063733506a06eb3d1d09a3666272bf7a38b5";
        libraryHaskellDepends = [ amazonka-core base ];
        homepage = "https://github.com/brendanhay/amazonka";
        description = "Amazon OpsWorks SDK";
@@ -19839,7 +19871,7 @@ self: {
      mkDerivation {
        pname = "amazonka-rds";
        version = "0.3.6";
-       sha256 = "105xj8zrjha5yvpj8m0r7asy0hys17g1gglf95kgnkwdh9zhj3yl";
+       sha256 = "d40f097f828d4ffb66498ebe17de09da43e0b53a195424eff64541993f92bd80";
        libraryHaskellDepends = [ amazonka-core base ];
        homepage = "https://github.com/brendanhay/amazonka";
        description = "Amazon Relational Database Service SDK";
@@ -19851,7 +19883,7 @@ self: {
      mkDerivation {
        pname = "amazonka-redshift";
        version = "0.3.6";
-       sha256 = "195lawjhy6hmfwk05cm9wi2x8pn6f3zr8rhcvrwa0igg8xi39fpr";
+       sha256 = "f9ba346247ef45a078de0c6694ff70c65ed445e4a9b2022677151a0f2557b4a4";
        libraryHaskellDepends = [ amazonka-core base ];
        homepage = "https://github.com/brendanhay/amazonka";
        description = "Amazon Redshift SDK";
@@ -19863,7 +19895,7 @@ self: {
      mkDerivation {
        pname = "amazonka-route53";
        version = "0.3.6.1";
-       sha256 = "155d4yfc96x99mw8h89n2waj7ywx4hcw8izcx1sk1x96lcd6h9mw";
+       sha256 = "bc26681aa326f53075e8ec47c419249dfb231517362188784da99bc49c27ad94";
        libraryHaskellDepends = [ amazonka-core base ];
        homepage = "https://github.com/brendanhay/amazonka";
        description = "Amazon Route 53 SDK";
@@ -19875,7 +19907,7 @@ self: {
      mkDerivation {
        pname = "amazonka-route53-domains";
        version = "0.3.6";
-       sha256 = "13dykx5w35dj3fn7nqs3znisjzqczpsxxyyghh2kfsgfhxna0kqv";
+       sha256 = "1b4fa06c87ee69370584cffbdef5fd0c7fa9a3fd43637bac1bb295c14b9fbe8d";
        libraryHaskellDepends = [ amazonka-core base ];
        homepage = "https://github.com/brendanhay/amazonka";
        description = "Amazon Route 53 Domains SDK";
@@ -19887,7 +19919,7 @@ self: {
      mkDerivation {
        pname = "amazonka-s3";
        version = "0.3.6";
-       sha256 = "1q45d6g4wrfjmw9d65bvrin1p9vcfv5xyz47158p9zxm2cvpvcv9";
+       sha256 = "69b37d3713b5ff745109877cdfcb766ca71b6ccc7b15d312afd2654e9e6985e0";
        libraryHaskellDepends = [ amazonka-core base ];
        homepage = "https://github.com/brendanhay/amazonka";
        description = "Amazon Simple Storage Service SDK";
@@ -19899,7 +19931,7 @@ self: {
      mkDerivation {
        pname = "amazonka-sdb";
        version = "0.3.6";
-       sha256 = "1wswsirmjq1zvhppv4bk4h9k2b94hdl1w8q18c7mh5i4j6kx41lc";
+       sha256 = "8c06d2a7912416580f4301231e6883242d31132473917d2fdc3f605973d45cf3";
        libraryHaskellDepends = [ amazonka-core base ];
        homepage = "https://github.com/brendanhay/amazonka";
        description = "Amazon SimpleDB SDK";
@@ -19911,7 +19943,7 @@ self: {
      mkDerivation {
        pname = "amazonka-ses";
        version = "0.3.6";
-       sha256 = "1f7k13mpf1hs27li4fdfv4wsbckyljmhwf9i6r176h6lkkb24vxx";
+       sha256 = "bd6f22d69cd44073423631390eaba47eb2a539d9ae3912e9111a0677eb08f3b8";
        libraryHaskellDepends = [ amazonka-core base ];
        homepage = "https://github.com/brendanhay/amazonka";
        description = "Amazon Simple Email Service SDK";
@@ -19923,7 +19955,7 @@ self: {
      mkDerivation {
        pname = "amazonka-sns";
        version = "0.3.6";
-       sha256 = "00bln36dmxikxgjyib009i3y56nln4i4j58nj89sclc87mdbzbma";
+       sha256 = "aaaebf5a3d8851a6139216154922b1d49ae2474c00ace8e5eb33f6daccb07401";
        libraryHaskellDepends = [ amazonka-core base ];
        homepage = "https://github.com/brendanhay/amazonka";
        description = "Amazon Simple Notification Service SDK";
@@ -19935,7 +19967,7 @@ self: {
      mkDerivation {
        pname = "amazonka-sqs";
        version = "0.3.6";
-       sha256 = "04qz8d81xz5pj3ib7cpxrig61n70val2vgjjy3xc0wjki3sk7xw8";
+       sha256 = "88f733f5885372c0faf052be2da8dae0d8605eccfdb2b3e290b7fc1e50431f13";
        libraryHaskellDepends = [ amazonka-core base ];
        homepage = "https://github.com/brendanhay/amazonka";
        description = "Amazon Simple Queue Service SDK";
@@ -19947,7 +19979,7 @@ self: {
      mkDerivation {
        pname = "amazonka-ssm";
        version = "0.3.6";
-       sha256 = "1xzz82hxh0am6mgzgqx0w8lxm5q8d3zpny2qyyl7bjyjh8k7v370";
+       sha256 = "e08c7d2682d2cb75a8f758787bff680897da29e2a0e3f75f355501d8a140fff7";
        libraryHaskellDepends = [ amazonka-core base ];
        homepage = "https://github.com/brendanhay/amazonka";
        description = "Amazon Simple Systems Management Service SDK";
@@ -19959,7 +19991,7 @@ self: {
      mkDerivation {
        pname = "amazonka-storagegateway";
        version = "0.3.6";
-       sha256 = "1cjajpwf0lfvn3r62n7y4ly16496cn7qhs17grjxv3c9i8pikq2z";
+       sha256 = "5fe0192f8a898ddd657e2768888f652611133c25fe5861f2b0db51e0f8954ab2";
        libraryHaskellDepends = [ amazonka-core base ];
        homepage = "https://github.com/brendanhay/amazonka";
        description = "Amazon Storage Gateway SDK";
@@ -19971,7 +20003,7 @@ self: {
      mkDerivation {
        pname = "amazonka-sts";
        version = "0.3.6";
-       sha256 = "096av2p79b4vnb3zzmkbjspvxkcgzx77w96mrziggfj8mxh3x5f1";
+       sha256 = "c1953e60af48baf7e2cfd5247e4eff8fcdbeaf966bd6ffc7b29bac74aed8ca24";
        libraryHaskellDepends = [ amazonka-core base ];
        homepage = "https://github.com/brendanhay/amazonka";
        description = "Amazon Security Token Service SDK";
@@ -19983,7 +20015,7 @@ self: {
      mkDerivation {
        pname = "amazonka-support";
        version = "0.3.6";
-       sha256 = "0igaq8538vrbwn7pqap5500alx3lp1c37imq75gk9nx7q846gqy6";
+       sha256 = "c6e36708c2a7db345f39b8c63358b87474aa0028e52a7c8fe52b6f340ac2ea45";
        libraryHaskellDepends = [ amazonka-core base ];
        homepage = "https://github.com/brendanhay/amazonka";
        description = "Amazon Support SDK";
@@ -19995,7 +20027,7 @@ self: {
      mkDerivation {
        pname = "amazonka-swf";
        version = "0.3.6";
-       sha256 = "0mijdc797ybdz7g0nkyncahspsl0dpy3g8hkhcj2jdhhdbqn7qfc";
+       sha256 = "cce163f16a103629248313a237fc6d80eaaba162d64f0bdef96df9930e6b3256";
        libraryHaskellDepends = [ amazonka-core base ];
        homepage = "https://github.com/brendanhay/amazonka";
        description = "Amazon Simple Workflow Service SDK";
@@ -20007,7 +20039,7 @@ self: {
      mkDerivation {
        pname = "amazonka-workspaces";
        version = "0.3.6";
-       sha256 = "1hwlm2a5fn4hrqqv79iw39xrrgfhl1d1p6236lqqfdyycnq4x5wk";
+       sha256 = "93974eb065de3787313543981b5aa0d0bd9c7b1a3ca6b331ce90585794a894c3";
        libraryHaskellDepends = [ amazonka-core base ];
        homepage = "https://github.com/brendanhay/amazonka";
        description = "Amazon WorkSpaces SDK";
@@ -20024,7 +20056,7 @@ self: {
      mkDerivation {
        pname = "ampersand";
        version = "3.0.3";
-       sha256 = "0xasmdcsrnvyfw3q5jkd1cpmi26yj8c5ifzgmjy6qp6wpsldswqc";
+       sha256 = "0c73dda8bedc5c6cbcacefbb581892de88582f0b6dca8207777edbac59ab5a75";
        revision = "1";
        editedCabalFile = "42a4a0f82e5c10b76a8412ba625df82da44d7e28353a9efa5aad2b10e7cc9d2a";
        isLibrary = false;
@@ -20051,7 +20083,7 @@ self: {
      mkDerivation {
        pname = "amqp";
        version = "0.13.0";
-       sha256 = "1qnknyk8xizq5i94s9zv7prqqcpccigc92c6jqqh82y2yqz5xnjj";
+       sha256 = "52da5e3ef6c20b0431968689c45e64ec328cf33dfb274d522cf8c78ea6b7d3e2";
        isLibrary = true;
        isExecutable = true;
        libraryHaskellDepends = [
@@ -20078,7 +20110,7 @@ self: {
      mkDerivation {
        pname = "amqp-conduit";
        version = "0.2.0.0";
-       sha256 = "1mlapyp22bbnkz7ny2rs2da6a6nbs41j8ljsjlxv1x9cfnjzjayb";
+       sha256 = "cb2bf9a5752cf5b03b955a522403d1cb1a6554133a0b6fcf9f762d21aebf8ad6";
        libraryHaskellDepends = [
          amqp base conduit exceptions lifted-base monad-control mtl
          resourcet text transformers transformers-base
@@ -20097,7 +20129,7 @@ self: {
      mkDerivation {
        pname = "amrun";
        version = "0.0.0.5";
-       sha256 = "1y0azhsjarv26lkny1wckdz45bs87wbga29hbg6w59wc2gjkbxqz";
+       sha256 = "1ff735e5138ca7c2cd5b3009f5163f48af427e9b8c076f273562672535fc0af8";
        isLibrary = false;
        isExecutable = true;
        executableHaskellDepends = [ base deepseq parsec ];
@@ -20112,7 +20144,7 @@ self: {
      mkDerivation {
        pname = "analyze-client";
        version = "0.1.0.2";
-       sha256 = "12csrds628c3ff9giyc6q74jn1s2fbkdyagzbqcvnh3brnzsjvss";
+       sha256 = "5a6fa9bfcd6b40bb195eff29dfe67242072bc9c186f9f8927383216174cb9a89";
        libraryHaskellDepends = [
          base bytestring http-conduit MonadCatchIO-transformers mtl snap
          snap-core time
@@ -20129,7 +20161,7 @@ self: {
      mkDerivation {
        pname = "anansi";
        version = "0.4.8";
-       sha256 = "1fzrry9axri0wcff0zbxq0dbq0pxyq6x6bzw426xkm3ayzfd825a";
+       sha256 = "aa08d4dcf76ad4d98d20fc2fd30df6fd02bc1ac07d7de01ce320e6ae92cff9bb";
        isLibrary = true;
        isExecutable = true;
        libraryHaskellDepends = [
@@ -20152,7 +20184,7 @@ self: {
      mkDerivation {
        pname = "anansi-hscolour";
        version = "0.1.2";
-       sha256 = "0ffk44lacm3al96cmnacyi6pnhlzhw34jgn87fsfjcl516ffmfxw";
+       sha256 = "bcbbea9c098532e9b43bc83e4906879f427b4df44cd9ca4ca26a54a62821d339";
        libraryHaskellDepends = [
          anansi base bytestring containers hscolour monads-tf text
        ];
@@ -20168,7 +20200,7 @@ self: {
      mkDerivation {
        pname = "anansi-pandoc";
        version = "0.1.3";
-       sha256 = "13s370b35wmwvbp6a9afsbl62hswj4mdhnvcgigwjz6bcwxxxpxi";
+       sha256 = "b1dfde3b67cb7cc95f7c6c5bd82a915c4361e8d24e2565eedabcf2321638438f";
        libraryHaskellDepends = [
          anansi base bytestring containers monads-tf pandoc text
        ];
@@ -20187,7 +20219,7 @@ self: {
      mkDerivation {
        pname = "anatomy";
        version = "0.4";
-       sha256 = "0xza3xfzzbix9xf0vwwk4qz02h4iil3hglqspgdymhjbxfl68714";
+       sha256 = "241c64a8eb4bc2eadbbb1ad307078d9140013e2693f30d5c4f3daeff5d1fea77";
        isLibrary = true;
        isExecutable = true;
        libraryHaskellDepends = [
@@ -20214,7 +20246,7 @@ self: {
      mkDerivation {
        pname = "android-lint-summary";
        version = "0.2.1";
-       sha256 = "1sk2mfxfbj6bbsff89jch1x7rhag2yv5331qhal50qf1q7fvzgx1";
+       sha256 = "a1bfbfddc1c16150a882388c51b6174fc17c7a804c26e49c5ecbc8e5baab62ea";
        isLibrary = true;
        isExecutable = true;
        libraryHaskellDepends = [
@@ -20243,7 +20275,7 @@ self: {
      mkDerivation {
        pname = "angel";
        version = "0.6.2";
-       sha256 = "0n73w8lczsncagf2041lq1963mnsmw9albwy0n5qbhqx9030pzya";
+       sha256 = "caff0b06481dc3858b059e2faa12afdad66152c0341020dc53cceacf28e2e358";
        isLibrary = false;
        isExecutable = true;
        executableHaskellDepends = [
@@ -20266,7 +20298,7 @@ self: {
      mkDerivation {
        pname = "animalcase";
        version = "0.1.0.2";
-       sha256 = "0csbs9yrl8vhlgs7zax06shqlhcjs38q91wnkz5d3f6a4588lyqi";
+       sha256 = "117b8a5021cab8d1ca9f968784d1d092418aa136a0ab7ff4a370239a7dd24b33";
        libraryHaskellDepends = [ base bytestring text ];
        homepage = "https://github.com/ibotty/animalcase";
        description = "Convert camelCase to snake_case and vice versa";
@@ -20278,7 +20310,7 @@ self: {
      mkDerivation {
        pname = "annotated-wl-pprint";
        version = "0.6.0";
-       sha256 = "1rwjfw4fspyi564a847sb6k679sa6psajm2jybzpa1pvjq9z2a9x";
+       sha256 = "3d29f11396fb0675fff25254a9f4354aa763a659fa10a48829d15fed087792e7";
        libraryHaskellDepends = [ base ];
        homepage = "https://github.com/david-christiansen/annotated-wl-pprint";
        description = "The Wadler/Leijen Pretty Printer, with annotation support";
@@ -20290,7 +20322,7 @@ self: {
      mkDerivation {
        pname = "anonymous-sums";
        version = "0.4.0.0";
-       sha256 = "0jb7s6m7dblnydrzh5nsczr0kpqwy9gr346pcrxsaywz2gfjcrhi";
+       sha256 = "116626dd139f7ba57b66d790915ff21cdf09f267da16f873f396ae76aad16749";
        isLibrary = true;
        isExecutable = true;
        libraryHaskellDepends = [ base ];
@@ -20305,7 +20337,7 @@ self: {
      mkDerivation {
        pname = "anonymous-sums-tests";
        version = "0.4.0.0";
-       sha256 = "0a7f7d3xzn8nl9gyzr4wl7m83aszmw42nd0dj8b875khh7i01h0b";
+       sha256 = "0bc000e28170968316920d342b08af5fab81eaa19ce4ef5fa216d9df473bee28";
        libraryHaskellDepends = [ anonymous-sums base QuickCheck ];
        homepage = "http://www.github.com/massysett/anonymous-sums";
        description = "QuickCheck functions to accompany the anonymous-sums package";
@@ -20317,7 +20349,7 @@ self: {
      mkDerivation {
        pname = "ansi-terminal";
        version = "0.6.2.1";
-       sha256 = "1xmp8wpcyvqys777qpyfx99bhlnvmr7jil7r78j5n6fx3mkkhnln";
+       sha256 = "965a38671ddd195b243af9d0284faedb52b852eace5f7cced11e6fcf2e47b7f6";
        isLibrary = true;
        isExecutable = true;
        libraryHaskellDepends = [ base unix ];
@@ -20332,7 +20364,7 @@ self: {
      mkDerivation {
        pname = "ansi-wl-pprint";
        version = "0.6.7.2";
-       sha256 = "0x0pv7hq4q2n103pzzxghmgzmd3b5cwpnmkdbpzry222890w8ph1";
+       sha256 = "015ec4414242089fff5d6d567b392b6bb4fa5f85afff7f0708566082e1d91774";
        isLibrary = true;
        isExecutable = true;
        libraryHaskellDepends = [ ansi-terminal base ];
@@ -20350,7 +20382,7 @@ self: {
      mkDerivation {
        pname = "antagonist";
        version = "0.1.0.29";
-       sha256 = "1dkrjn07445kmdq09fwdlnk676dvjzrzkgcfwni661lr5kbrj7p9";
+       sha256 = "e91e99d72c990663a2e58ebdf9f397bb9963a6a58dbb0470abb31072809579b6";
        isLibrary = true;
        isExecutable = true;
        libraryHaskellDepends = [
@@ -20373,7 +20405,7 @@ self: {
      mkDerivation {
        pname = "antfarm";
        version = "0.1.0.0";
-       sha256 = "1s2lfd7va0nq5z0q4f37ig2spjpxigfhkhi067fz4y0n1zjc1isd";
+       sha256 = "4dc7c0e40f1678f2dd3120c209dd8bfdcaabc58b673882c12fd802b54f7354e8";
        isLibrary = true;
        isExecutable = true;
        libraryHaskellDepends = [
@@ -20398,7 +20430,7 @@ self: {
      mkDerivation {
        pname = "anticiv";
        version = "0.1.0.5";
-       sha256 = "0sxxa2kylgagbnlf7msrgfq98jaf26lvlas6afypnr15aavvlfzh";
+       sha256 = "f03bbab75225647bbd53462bbaa9114e4994b07b59d7e3a85d4f3deaa750bd6b";
        isLibrary = true;
        isExecutable = true;
        libraryHaskellDepends = [
@@ -20423,7 +20455,7 @@ self: {
      mkDerivation {
        pname = "antigate";
        version = "2.0.1";
-       sha256 = "0vd2f4kq2zkngyqpnw3lcvjkn8335gs9rdfr7kb8442p8dhps139";
+       sha256 = "69047d6143571082d63cd9b59cf42b63203be56674707bb17f767e812771a26d";
        libraryHaskellDepends = [
          base bytestring data-default deepseq exceptions failure http-client
          http-conduit resourcet safe text transformers
@@ -20439,7 +20471,7 @@ self: {
      mkDerivation {
        pname = "antimirov";
        version = "0.1.0";
-       sha256 = "0aay5fhw2r502hvdlh6svj6k88zh5wjinn8mk2a3md7zdaiji9iq";
+       sha256 = "38a628a36affb43a949815591b252ff023348ddcda40da3614a064c1a12b5e29";
        isLibrary = true;
        isExecutable = true;
        libraryHaskellDepends = [ base containers QuickCheck ];
@@ -20454,7 +20486,7 @@ self: {
      mkDerivation {
        pname = "antiquoter";
        version = "0.1.1.0";
-       sha256 = "1qv5iid7az7bn1jf6r7ffg5qqbcs8ypf78j4vrs5ajwp39jnbiiy";
+       sha256 = "3ec665651a974b5574de44a2e3ae479a2d8ccb73ee64e364b0eb7c755a8c65e3";
        libraryHaskellDepends = [ base syb template-haskell ];
        description = "Combinator library for quasi- and anti-quoting";
        license = stdenv.lib.licenses.bsd3;
@@ -20467,7 +20499,7 @@ self: {
      mkDerivation {
        pname = "antisplice";
        version = "0.17.1.0";
-       sha256 = "1f4872gmw1h2xl5jy9ajck5n4qmxdwk0f3v3bk1fxc9x8y5mscny";
+       sha256 = "de325d8b473db1eec25c630f07266fbd6262cb6452252f0bed02065e9f3888b8";
        libraryHaskellDepends = [
          base chatty chatty-utils haskeline mtl template-haskell text time
          transformers
@@ -20484,7 +20516,7 @@ self: {
      mkDerivation {
        pname = "antlrc";
        version = "0.0.2";
-       sha256 = "1hjk2cvn6j1ijvg3gnml46ysri672jnxmfyh09y1aqsrbimkw8gd";
+       sha256 = "ed213e6b5c5963157c02d0bbdaad14c7c4acbd21b4da37de96314863371353c2";
        isLibrary = true;
        isExecutable = true;
        libraryHaskellDepends = [ base haskell98 ];
@@ -20504,7 +20536,7 @@ self: {
      mkDerivation {
        pname = "anydbm";
        version = "1.0.7";
-       sha256 = "1rxk36r6i065m0qiq4g5xlrk2yjsds7j896cbddbsyddbzy10d6k";
+       sha256 = "d33410fc5fad79bd5a5bcc24248f6e5a7a3133ede5111c31a8c58068b219b3e7";
        isLibrary = true;
        isExecutable = true;
        libraryHaskellDepends = [ base containers MissingH mtl ];
@@ -20523,7 +20555,7 @@ self: {
      mkDerivation {
        pname = "aosd";
        version = "0.2.1";
-       sha256 = "0zma3ypjnqn8c9pk4zfyzzwn27l3wb6l6xnjjydn90fxsmpa1vh6";
+       sha256 = "06eea06ed5dd81649b97d27643cde2831e61f9ffde7d326f62c8622baf1faa7e";
        libraryHaskellDepends = [
          base bindings-DSL cairo colour monad-control pango transformers X11
        ];
@@ -20541,7 +20573,7 @@ self: {
      mkDerivation {
        pname = "ap-reflect";
        version = "0.2";
-       sha256 = "1ih0in9j26v96pjqr1wbjxl881xb2xsrcvhmn50wbv4iwxv7y222";
+       sha256 = "42087f76e791ecc541b1156e967517ab078468978b878ce535691b21938d00c6";
        libraryHaskellDepends = [ base ];
        homepage = "https://github.com/cmc-msu-ai/ap-reflect";
        description = "Partial evaluation reflection a la simple-reflect";
@@ -20556,7 +20588,7 @@ self: {
      mkDerivation {
        pname = "apache-md5";
        version = "0.6.1.4";
-       sha256 = "1dwnn200sjp2pvriii3y4srrms0gyicd6qp6kvc74yyad8pqhky8";
+       sha256 = "c84f882f6aca7b72d89ee662d358f40fe89ab3267ec418f3bee24a0d80b096b7";
        libraryHaskellDepends = [ base bytestring ];
        librarySystemDepends = [ openssl ];
        testHaskellDepends = [
@@ -20577,7 +20609,7 @@ self: {
      mkDerivation {
        pname = "apelsin";
        version = "1.2.3";
-       sha256 = "08a747p0dyjvgn5pjfvrb1hnh7vk2km8hbbyvjmnsxl89r5m992l";
+       sha256 = "54a4544b4e88766dabdc7e2d88ea14731f686158793b798b7d5bfa06ee214721";
        isLibrary = false;
        isExecutable = true;
        executableHaskellDepends = [
@@ -20599,7 +20631,7 @@ self: {
      mkDerivation {
        pname = "api-builder";
        version = "0.10.0.0";
-       sha256 = "0pzbp0grmnrc48h1cbsxsxzyjgnxzmf4d6cfi53ccq0v3yfybw9v";
+       sha256 = "3bf1e59d1f1b60c646898e99465cfddd3ee97fd75d2f1620222cdb9a1fb8eb5f";
        libraryHaskellDepends = [
          aeson base bifunctors bytestring HTTP http-client http-client-tls
          http-types text transformers
@@ -20608,6 +20640,7 @@ self: {
          aeson base bytestring Cabal containers hspec http-conduit text
          transformers
        ];
+       jailbreak = true;
        homepage = "https://github.com/intolerable/api-builder";
        description = "Library for easily building REST API wrappers in Haskell";
        license = stdenv.lib.licenses.bsd3;
@@ -20618,7 +20651,7 @@ self: {
      mkDerivation {
        pname = "api-opentheory-unicode";
        version = "1.2";
-       sha256 = "1mzbkrbdwcxr83bprk3gjrrg6sarl0vwv729xs8x5d1rfdiqlm88";
+       sha256 = "08558a637339b4d291ee499ccd37a05969f372966fcc7cd740b933de569eebd7";
        libraryHaskellDepends = [ base bytestring opentheory-unicode ];
        testHaskellDepends = [
          base bytestring directory opentheory-unicode
@@ -20638,7 +20671,7 @@ self: {
      mkDerivation {
        pname = "api-tools";
        version = "0.5.2";
-       sha256 = "0pd2kaii40isbnc1rgh0zkm2abrljipmq27nlgz3zbldbm1l5xw6";
+       sha256 = "86f742435d8dae3ffea3f6085c6f94342f25eafc00be1c985d3a0212a39aa25d";
        isLibrary = true;
        isExecutable = true;
        libraryHaskellDepends = [
@@ -20680,7 +20713,7 @@ self: {
      mkDerivation {
        pname = "apiary";
        version = "1.4.3";
-       sha256 = "1z6fgdkn3k4sbwk5jyz6yp9qwllhv2m9vq7z25fhmj41y3spgcsc";
+       sha256 = "4cb377f5f081c80a5d11ffe09daad890528ed3f5e67b59265f9acc61677bcefc";
        revision = "1";
        editedCabalFile = "024867d05ec04c0b83c41e948b80c56686cc170beed600daffa8d8c725e50a32";
        libraryHaskellDepends = [
@@ -20709,7 +20742,7 @@ self: {
      mkDerivation {
        pname = "apiary-authenticate";
        version = "1.4.0";
-       sha256 = "01yivdslscbri4gy19mma794v9v2gnf94wlvms8p1flrcw6xpns0";
+       sha256 = "40dbdb0d6799ba7091ae9b72929c7d62a74dd251b5a6e01f8979314d75dbd107";
        revision = "1";
        editedCabalFile = "724a8cbf0f2e57cd497b54de4401acda2877437053f13164dd23ba7b6c7d119b";
        libraryHaskellDepends = [
@@ -20730,7 +20763,7 @@ self: {
      mkDerivation {
        pname = "apiary-clientsession";
        version = "1.4.0";
-       sha256 = "1z96c4zfyyvrihr1al9zp6pwv4wxkfq02a1z63bxxrrfglrs3fx6";
+       sha256 = "a6bba1337d2ee7ded7303f2801b09b9d93cdafb93f5115328c797bef3e6126fd";
        revision = "1";
        editedCabalFile = "ac724d51a8bd867838bccb788a0db76f97cfe19b052d1247e38ba001561e4bfd";
        libraryHaskellDepends = [
@@ -20749,7 +20782,7 @@ self: {
      mkDerivation {
        pname = "apiary-cookie";
        version = "1.4.0";
-       sha256 = "017bxqavv4w5r2ghgmyhljqa4fyzl02v2sjwxi056s3phgrlrkrx";
+       sha256 = "3dcf4cf38377685340ec5c6ab105a0df3ba2b0a4d0d7079fc88593bd15eeeb04";
        revision = "2";
        editedCabalFile = "4edecbd2a1e6fb740815be85cc9c4836144338af88e6774348a1703e861a9771";
        libraryHaskellDepends = [
@@ -20766,7 +20799,7 @@ self: {
      mkDerivation {
        pname = "apiary-eventsource";
        version = "1.4.0";
-       sha256 = "0xh1pm1l59n4c48vbk3ls42fxh4lzr6p8k8rmij1hl58zrkgbjd7";
+       sha256 = "a7c9f566fea8501864ac194d744dfe94c0ee04d174ccb51161c4a64243bd0176";
        revision = "1";
        editedCabalFile = "368e1b555b07ff026b4753cab0364d0f70a4e2536166f756bde35f8ce9fb9ae6";
        libraryHaskellDepends = [ apiary base blaze-builder wai-extra ];
@@ -20783,7 +20816,7 @@ self: {
      mkDerivation {
        pname = "apiary-helics";
        version = "1.4.0";
-       sha256 = "1qm9fnhzafdja6fr20c7qhl6dmagmnzn23ni49ln5k55kbawfk8a";
+       sha256 = "0a4dc7d59aa5cc626922d10e61bfad4fd56628c48701919d51b239f5a175a9e2";
        revision = "1";
        editedCabalFile = "80ce4b1a9dd5c7a30099392219d0077b9281b9ceeabbb01843f12754df0b0827";
        libraryHaskellDepends = [
@@ -20804,7 +20837,7 @@ self: {
      mkDerivation {
        pname = "apiary-logger";
        version = "1.4.0";
-       sha256 = "0pf030sn4mf05avl11hs9kz6qi9667s2vavn3wsxp1anl9bghk48";
+       sha256 = "884cf856a25685db351f76ab2df43126456cfe4c1a8640b72ac055623518c05d";
        revision = "3";
        editedCabalFile = "03f6b1ac0e588631c2deed8459e527f935a74a86c15455c3f509270ba5bbd5f7";
        libraryHaskellDepends = [
@@ -20824,7 +20857,7 @@ self: {
      mkDerivation {
        pname = "apiary-memcached";
        version = "1.4.0";
-       sha256 = "1rwkj7byc84yism5sxphs1s231910ay8w7lap2cdg0y9k9f24gby";
+       sha256 = "7e3d225c9ac983d798b88a1e8ebc0221852174d0f0765daa8e9e20e6d79193e7";
        revision = "1";
        editedCabalFile = "7a332392add31b3f5ef9fcc2e69069de3a23bdbfdcfeececc47d2832ec767c29";
        libraryHaskellDepends = [
@@ -20844,7 +20877,7 @@ self: {
      mkDerivation {
        pname = "apiary-mongoDB";
        version = "1.4.0";
-       sha256 = "1srnkyw1i0vjarwqg13cmnwc0x0ab5m8scax9wd4scsmblpa75wd";
+       sha256 = "8d97a32e5d55334d1a4f5d318d6a590a74c0b8ad6c84877956728318b89f36eb";
        revision = "1";
        editedCabalFile = "e2578f19108129ed47946fa7369c86203610d5b447a6a7a8f1af5f2537d55a4b";
        libraryHaskellDepends = [
@@ -20864,7 +20897,7 @@ self: {
      mkDerivation {
        pname = "apiary-persistent";
        version = "1.4.0";
-       sha256 = "00jaiykbxj1lh8qgv4y0ma9awaj1ymrjskwr9ra5pmka1mrwbih9";
+       sha256 = "09c6c5730d6ad65b544e994f2d73f5412aae92aac093fd308234c8bea68f4a02";
        revision = "2";
        editedCabalFile = "7f1c18de1d41b15397df81d9a3377e109cc07f6efc07390584e0e2952d34e889";
        libraryHaskellDepends = [
@@ -20885,7 +20918,7 @@ self: {
      mkDerivation {
        pname = "apiary-purescript";
        version = "1.4.0";
-       sha256 = "0z1d2wqpa86bv6xkpiw696sn77fdq52vk2s8951v8qdffbxia3jz";
+       sha256 = "5f0e15fb72ae61b44349488bb945c1cd9d63b54986c73bbbd9cb207531172d7c";
        revision = "1";
        editedCabalFile = "9f716a5d9173c31c6472a4bf7decc34523bdc761540d440f5d0ad4f9521bf98c";
        libraryHaskellDepends = [
@@ -20904,7 +20937,7 @@ self: {
      mkDerivation {
        pname = "apiary-session";
        version = "1.4.0";
-       sha256 = "0jnppjykcrzdvlsli2ycyc11874dfqhwayny5p3x8nx9hnwxhk23";
+       sha256 = "434cd8b985a95bd4c72dde7ac521768d1c1402f3cc8b4835dded6736bdbcd74a";
        revision = "1";
        editedCabalFile = "8e4a0b590972ea4e1ab1252696b7339038c4d7206ae44d1f1397a67cdde077dd";
        libraryHaskellDepends = [
@@ -20922,7 +20955,7 @@ self: {
      mkDerivation {
        pname = "apiary-websockets";
        version = "1.4.0";
-       sha256 = "0nslzy0s24jn58jd1q4z2gf0h7n1y2xks7cw86i9ybdph697wpp1";
+       sha256 = "e15e7e9281b72d9fa2419c1d3dbbf0c11e08dc139fe0d0242a5612a181ff545b";
        revision = "1";
        editedCabalFile = "5162825445fc14b48d11a0a1f63d67e8d66a8c5aaeaf1e117a1f2302474d7581";
        libraryHaskellDepends = [
@@ -20942,7 +20975,7 @@ self: {
      mkDerivation {
        pname = "apis";
        version = "0.0.1";
-       sha256 = "07jvx1bsfiqk9l4l9k9yrsmvqm7dc2lb6p7h8p2bzqc3dqcqp67q";
+       sha256 = "f8988b196e83e1bfc445f05cb3a860ed54bcabce3ecd44094d1347a757e85b1e";
        libraryHaskellDepends = [
          aeson base containers deepseq directory ecma262 exceptions
          filemanip filepath hslogger hxt mtl opendatatable split
@@ -20966,7 +20999,7 @@ self: {
      mkDerivation {
        pname = "apotiki";
        version = "0.5.2";
-       sha256 = "1rih1lasky5sjdf3lz2qi2qya3iwbbxs658p77h1amqpsa7lsfp7";
+       sha256 = "e73a4d8fd2175715e0391715a3fb5a3c0ee5b188587c3a5c93baf8a9150d30e6";
        isLibrary = true;
        isExecutable = true;
        libraryHaskellDepends = [
@@ -20993,7 +21026,7 @@ self: {
      mkDerivation {
        pname = "app-lens";
        version = "0.1.0.0";
-       sha256 = "0gizjnc7x1ggryfrm4d87xiyjz9yw6c5y3zp23x40bgmw49zl318";
+       sha256 = "280cfa13e1f52d40fa10f70f5f98e13e7de9633fa8919a9dcfef857e98953f3e";
        revision = "2";
        editedCabalFile = "29d9e8cabf54f27b1ccf007530fe698c0895c0bb6a2a6da50b71fafd4c27bd6d";
        libraryHaskellDepends = [ base containers lens mtl ];
@@ -21011,7 +21044,7 @@ self: {
      mkDerivation {
        pname = "app-settings";
        version = "0.2.0.5";
-       sha256 = "17918i7k1wagmqxvkhww69w8ffybshfm6y1dd9iyg9x45qdrvr6k";
+       sha256 = "d3e49d1b2ea4a7e7636a2d78531dd4cb3b8778329cc3b93bae4ff1304f44219d";
        libraryHaskellDepends = [
          base containers directory mtl parsec text
        ];
@@ -21029,7 +21062,7 @@ self: {
      mkDerivation {
        pname = "appar";
        version = "0.1.4";
-       sha256 = "09jb9ij78fdkz2qk66rw99q19qnm504dpv0yq0pjsl6xwjmndsjq";
+       sha256 = "58ea66abe4dd502d2fc01eecdb0828d5e214704a3c1b33b1f8b33974644c4b26";
        libraryHaskellDepends = [ base bytestring ];
        description = "A simple applicative parser";
        license = stdenv.lib.licenses.bsd3;
@@ -21043,7 +21076,7 @@ self: {
      mkDerivation {
        pname = "appc";
        version = "0.0.6";
-       sha256 = "0qns7kjp9sjrpdx6vfkci9q6xinb0gwkb1a9ssw8xfbqqhf9ljms";
+       sha256 = "ba4a9a1cc478b98eb8d6498535f903cbc66e708a6cba6d7abb59ea74e53cda62";
        isLibrary = true;
        isExecutable = true;
        libraryHaskellDepends = [
@@ -21066,7 +21099,7 @@ self: {
      mkDerivation {
        pname = "applicative-extras";
        version = "0.1.8";
-       sha256 = "1svsf8mvb816nksg1dh4dz3cms2zx2hjprz2z7h3zidpxmzs0pr8";
+       sha256 = "285fa07fedb7c53fe0f9e2e72ba1e85fe8cac66f04b6f0f4b426a0b52b727aeb";
        libraryHaskellDepends = [ base ];
        homepage = "http://github.com/chriseidhof/applicative-extras/";
        description = "Instances for Applicative";
@@ -21080,7 +21113,7 @@ self: {
      mkDerivation {
        pname = "applicative-fail";
        version = "1.1.1";
-       sha256 = "11bk0svzdys8rgx6nzb80fkxz8mp6r0238ylmb5wzsnl8nc9y041";
+       sha256 = "81009f9845d4eacfcbaad4a3214036b7a2dfa703687d6bfacb48fbf6b7067385";
        libraryHaskellDepends = [
          base bifunctors dlist mtl transformers transformers-base
        ];
@@ -21097,7 +21130,7 @@ self: {
      mkDerivation {
        pname = "applicative-numbers";
        version = "0.1.3";
-       sha256 = "0rnjl7yz6nga4qi0jdvhf911yf1qk6gy2fm5236bsgc50d5wbaw0";
+       sha256 = "80abc54b03853dbdcc10a53ae19f9938381f42727037092226ea59f3fda1d266";
        libraryHaskellDepends = [ base ];
        homepage = "http://haskell.org/haskellwiki/applicative-numbers";
        description = "Applicative-based numeric instances";
@@ -21111,7 +21144,7 @@ self: {
      mkDerivation {
        pname = "applicative-parsec";
        version = "0.1.0.0";
-       sha256 = "12y2j9lpaqpjcr2a9fk4anlvc1cw5rimyx031b6xa5dx500phrrx";
+       sha256 = "3d67780128bd15d5cd0a03745f632e9c05b6a95564baa44466f262756992c28b";
        libraryHaskellDepends = [ base containers lens mtl text ];
        testHaskellDepends = [
          base mtl QuickCheck test-framework test-framework-quickcheck2
@@ -21127,7 +21160,7 @@ self: {
      mkDerivation {
        pname = "applicative-quoters";
        version = "0.1.0.8";
-       sha256 = "10m29d0938khjdazsmsvvncr5xndnpzpm1b7ymzb3b4b81xmcpgl";
+       sha256 = "f45d567b408bacb17ef567857affb5cdf69299dd5b57fd559370a291404ba282";
        libraryHaskellDepends = [ base haskell-src-meta template-haskell ];
        description = "Quasiquoters for idiom brackets and an applicative do-notation";
        license = stdenv.lib.licenses.bsd3;
@@ -21143,7 +21176,7 @@ self: {
      mkDerivation {
        pname = "approx-rand-test";
        version = "0.2.1";
-       sha256 = "17aww5sffw07wk8hlyf0qv26v0jkr5qzv45wxk4zhhyb453b9m41";
+       sha256 = "81d4b44621cb43f8c9ecbc90fd71c953826dc4c6c0790ad1e40770e774e15c9d";
        isLibrary = true;
        isExecutable = true;
        libraryHaskellDepends = [
@@ -21175,7 +21208,7 @@ self: {
      mkDerivation {
        pname = "approximate";
        version = "0.2.2.1";
-       sha256 = "1h09257l7rfy64fiwr4d1jyq6vcfhly3hrn314rkfp6rkzxpvh79";
+       sha256 = "e9c07dfb9fd95c373309c366383c858e6d83bd0c8d641e1d31dee5434f1109c0";
        libraryHaskellDepends = [
          base binary bytes cereal comonad deepseq ghc-prim hashable
          hashable-extras lens log-domain pointed safecopy semigroupoids
@@ -21194,7 +21227,7 @@ self: {
      mkDerivation {
        pname = "approximate-equality";
        version = "1.1.0.2";
-       sha256 = "0pxvyb5a6vh0isba81flv7wjlwfn091xrma7g6wzr08bvqmix883";
+       sha256 = "03a11e2bde0b81fcb97947d5dc4302d6712af9d9d405a4968e006ea3caf2bb5f";
        libraryHaskellDepends = [ base type-level-natural-number ];
        homepage = "http://github.com/gcross/approximate-equality";
        description = "Newtype wrappers for approximate equality";
@@ -21206,7 +21239,7 @@ self: {
      mkDerivation {
        pname = "ar-timestamp-wiper";
        version = "0.1.0";
-       sha256 = "1gk1z0dw7i0c3wql1zh8iri6573falmiz31s0widfz7dav45vkrz";
+       sha256 = "3fcf5dc856ed7cd722073a8c1f2b556e9c62628e08fe40311f0cc4c31bf861be";
        isLibrary = true;
        isExecutable = true;
        libraryHaskellDepends = [ base bytestring ];
@@ -21224,7 +21257,7 @@ self: {
      mkDerivation {
        pname = "arb-fft";
        version = "0.2.0.2";
-       sha256 = "1yxhafzv71xx2gva4b9slr26iqs6p1lh578x1774bv07ifqys6dp";
+       sha256 = "b719edb18b07ec45ce091d9d0269b846e36844a63a2da2f613bd87b3bf53b0fb";
        isLibrary = true;
        isExecutable = true;
        libraryHaskellDepends = [
@@ -21249,7 +21282,7 @@ self: {
      mkDerivation {
        pname = "arbb-vm";
        version = "0.1.1.20";
-       sha256 = "0k31ardnlg925vcrrl4n9w09867dbr68sdnc3bhs9xz1r9cdlkv8";
+       sha256 = "684fda58cae1f7a4e11acc368d4c5eed1894004f96d09cd92e223d6a5b56614c";
        libraryHaskellDepends = [
          base bytestring cereal containers directory mtl pretty
        ];
@@ -21270,7 +21303,7 @@ self: {
      mkDerivation {
        pname = "arbtt";
        version = "0.9.0.4";
-       sha256 = "02qz7qsk1kjavsdl8mq56blxzzjnnjlnyjvjnyfamq7j0rqzdq5v";
+       sha256 = "bbe0f67106f2e0aa9cb7724b6fa9b456fedfe9320557449bde4ace30353e1f0b";
        isLibrary = false;
        isExecutable = true;
        executableHaskellDepends = [
@@ -21298,7 +21331,7 @@ self: {
      mkDerivation {
        pname = "archive";
        version = "1.2.12";
-       sha256 = "0rdgrdmmsn4qijbbprw4dbppb5klgn9lw3fyizzcd79gsgz4s61r";
+       sha256 = "39184dfed32f9dc6fe8fde0d4e937d749675ef6a84e7bb968c98585d6bcbaf65";
        isLibrary = true;
        isExecutable = true;
        libraryHaskellDepends = [
@@ -21319,7 +21352,7 @@ self: {
      mkDerivation {
        pname = "archiver";
        version = "0.6.2.1";
-       sha256 = "19gvja890lhn9zr2aqjshwq5qqb95nynxrsw5wk4z2a417xj70j2";
+       sha256 = "428223fb0944894f262f5ce76ebd2d69615c30875a6225f24f1652909092fba5";
        isLibrary = true;
        isExecutable = true;
        libraryHaskellDepends = [ base curl HTTP network ];
@@ -21338,7 +21371,7 @@ self: {
      mkDerivation {
        pname = "archlinux";
        version = "1.3";
-       sha256 = "051pgn39f8xq80qf8g04j162n6zysvcdbj8a8m05x6vi6mbr9jx2";
+       sha256 = "a2cb945735719b5e40450ac9d5d8d6fe1b2b4c90043ce43040b82397867d3714";
        libraryHaskellDepends = [
          base Cabal containers directory filepath pretty
        ];
@@ -21356,7 +21389,7 @@ self: {
      mkDerivation {
        pname = "archlinux-web";
        version = "0.1";
-       sha256 = "1rzjkxxmf24hrmlc70s416akn6rbcly7152ly618dxgigvqnir48";
+       sha256 = "88e468f17ef1f58682f15494703c652b1b3b95094483c368cd9008577b9ff2e7";
        isLibrary = true;
        isExecutable = true;
        libraryHaskellDepends = [
@@ -21380,7 +21413,7 @@ self: {
      mkDerivation {
        pname = "archnews";
        version = "0.2";
-       sha256 = "1v7b6w2cqfy69kvsr09a1qv4zyz78khygmd9l9hqjlmj7w3x8gys";
+       sha256 = "da3fd4073fb2528961a2a9d5e7e144e7fb4f360e2a81acf74cc63bcc0437ebec";
        isLibrary = false;
        isExecutable = true;
        executableHaskellDepends = [
@@ -21398,7 +21431,7 @@ self: {
      mkDerivation {
        pname = "arff";
        version = "0.1.0";
-       sha256 = "1mwak4kl4ksg5vqya9abz02v0zgj6lbi6bzq2bd8jpnncazsxha5";
+       sha256 = "45c1aebf62d65e89da12f82f131735f27db005f84b25e5f12e4f4f4227998ad7";
        libraryHaskellDepends = [
          base binary bytestring bytestring-lexing bytestring-show old-locale
          time
@@ -21415,7 +21448,7 @@ self: {
      mkDerivation {
        pname = "argparser";
        version = "0.3.4";
-       sha256 = "0ypdj4mcm4yk5pswzwi9jk2w25f6qhiari8gam72za6ihyjwfig6";
+       sha256 = "e645c7a587d1a82f4e550fc5ac22c4c615c1c59429f2cff52dd393ca2a91ed7a";
        libraryHaskellDepends = [ base containers ];
        testHaskellDepends = [ base containers HTF HUnit ];
        description = "Command line parsing framework for console applications";
@@ -21430,7 +21463,7 @@ self: {
      mkDerivation {
        pname = "arguedit";
        version = "0.1.0.1";
-       sha256 = "17s6m9mjai439j8g0cd5pr2zb0224h1ckik9fg0rbd06zgxvfmq6";
+       sha256 = "0657b7fbfb06b495c17369c6c902244280f545bea531f0904c8344256baa469f";
        isLibrary = false;
        isExecutable = true;
        executableHaskellDepends = [
@@ -21452,7 +21485,7 @@ self: {
      mkDerivation {
        pname = "ariadne";
        version = "0.1.2.3";
-       sha256 = "02hyn3y4h7w4l5k48kp73al67lp8vzlymblb7al72w14r01ww8p3";
+       sha256 = "e322ce03c8247071a83a8baeeae9dfe8d263a81ae74e4466a1841f48fcb01e0a";
        isLibrary = false;
        isExecutable = true;
        executableHaskellDepends = [
@@ -21479,7 +21512,7 @@ self: {
      mkDerivation {
        pname = "arion";
        version = "0.1.0.8";
-       sha256 = "107rbbzmqg0zrgv3qb0pr8svmzh25a63dm0kn0hhyirkjzdyjgqw";
+       sha256 = "1c3fe9db9733470f21b013d4368c2a02feba35ca172c3cf6cb1f3c5cff5af980";
        isLibrary = false;
        isExecutable = true;
        executableHaskellDepends = [
@@ -21503,7 +21536,7 @@ self: {
      mkDerivation {
        pname = "arith-encode";
        version = "1.0.0";
-       sha256 = "1wqm2jcc2dac31gvad6pmnq0wbajpj488h93xl93vfipsbak0cm8";
+       sha256 = "a83230d5d237ba3d12ed23418488bc522d0eb0add734b55f184c35c1981415f3";
        libraryHaskellDepends = [
          arithmoi array base binary Cabal containers fgl hashable
          unordered-containers
@@ -21522,12 +21555,38 @@ self: {
      mkDerivation {
        pname = "arithmatic";
        version = "0.1.0.1";
-       sha256 = "1qa1yqi67l1cd3ggb67h9iji9ps3ma43fcddv0vmc1hin61xnzj8";
+       sha256 = "487edb83b111065637d8ad313788aa43df14654cf098f5de682cd06322f641e1";
        libraryHaskellDepends = [ base ];
        description = "Basic arithmatic in haskell";
        license = stdenv.lib.licenses.gpl3;
      }) {};
 
+  "arithmetic" = callPackage
+    ({ mkDerivation, base, opentheory, opentheory-bits
+     , opentheory-divides, opentheory-primitive, QuickCheck, random
+     }:
+     mkDerivation {
+       pname = "arithmetic";
+       version = "1.0";
+       sha256 = "1af6acf13de40f36d95b8d34e3ba47be559f32dd0f00f1f161b2aa0536b6d5a0";
+       isLibrary = true;
+       isExecutable = true;
+       libraryHaskellDepends = [
+         base opentheory opentheory-bits opentheory-divides
+         opentheory-primitive QuickCheck random
+       ];
+       executableHaskellDepends = [
+         base opentheory opentheory-bits opentheory-divides
+         opentheory-primitive QuickCheck random
+       ];
+       testHaskellDepends = [
+         base opentheory opentheory-bits opentheory-divides
+         opentheory-primitive QuickCheck random
+       ];
+       description = "Natural number arithmetic";
+       license = stdenv.lib.licenses.mit;
+     }) {};
+
   "arithmoi" = callPackage
     ({ mkDerivation, array, base, containers, ghc-prim, hspec
      , integer-gmp, mtl, random
@@ -21535,7 +21594,7 @@ self: {
      mkDerivation {
        pname = "arithmoi";
        version = "0.4.1.3";
-       sha256 = "1j8k0hqg5ddglw9lpbp3qg81s1g01sil1grizlrqfgwx0wj3jqif";
+       sha256 = "2e623924079d3f8733fd31bf40a30ee0051dd0c3e3ae4b13a7afb5f2300413c9";
        configureFlags = [ "-f-llvm" ];
        libraryHaskellDepends = [
          array base containers ghc-prim integer-gmp mtl random
@@ -21551,7 +21610,7 @@ self: {
      mkDerivation {
        pname = "armada";
        version = "0.1";
-       sha256 = "18ym9cs0mr4pr6pdgyk14rrwsxh1fa0xvqz3jg60lnxbgjlynvc1";
+       sha256 = "816deba97cab5b0acc93e3e3dd81720176cd732661fad7aec997e40a344bd5a3";
        isLibrary = false;
        isExecutable = true;
        executableHaskellDepends = [ base GLUT mtl OpenGL stm ];
@@ -21565,7 +21624,7 @@ self: {
      mkDerivation {
        pname = "arpa";
        version = "0.0.0.0";
-       sha256 = "13n878vafx1igw3q3v1c676iaidyqa4wk6z727vh7dagkkyl7653";
+       sha256 = "a39843fd9c4fb503f711e79bc989c2be4515cd312cec81077f3174a7363ac88e";
        isLibrary = true;
        isExecutable = true;
        libraryHaskellDepends = [ base ];
@@ -21581,7 +21640,7 @@ self: {
      mkDerivation {
        pname = "array";
        version = "0.5.1.0";
-       sha256 = "18hz1jcshdj6c10lsxq86rs6rbx77g91w4ay2s58h9j5rnkchjxq";
+       sha256 = "b84bc8a6cd4526888a165e111ed23ba7af6c743608774d41604636a8990c1fa2";
        libraryHaskellDepends = [ base ];
        description = "Mutable and immutable arrays";
        license = stdenv.lib.licenses.bsd3;
@@ -21596,7 +21655,7 @@ self: {
      mkDerivation {
        pname = "array-forth";
        version = "0.2.1.4";
-       sha256 = "03kjkpygi9jc8vrvnw9i8zwbfaihsl50bi39j0liclja442j9h5m";
+       sha256 = "b5c02405214a5216299069c4050ad5302ab7f8473171bbf3464ca6f8fc9d720e";
        isLibrary = true;
        isExecutable = true;
        libraryHaskellDepends = [
@@ -21619,7 +21678,7 @@ self: {
      mkDerivation {
        pname = "array-memoize";
        version = "0.6.0";
-       sha256 = "1p05vg8mdyad03aa7s1nrgw5xqgl80f6l7v0llhmi1q4xnrqrj3n";
+       sha256 = "76c88cb3ed04875821a5601f6a1c40f4e15ef8cb36e8a3d4004df956d1db05dc";
        libraryHaskellDepends = [ array base ];
        description = "Memoization combinators using arrays for finite sub-domains of functions";
        license = stdenv.lib.licenses.bsd3;
@@ -21630,7 +21689,7 @@ self: {
      mkDerivation {
        pname = "array-primops";
        version = "0.1.0.0";
-       sha256 = "11qwgs06ivfjhcjhihchg46hvpcrwmc7zz36630v9qyy2611q66x";
+       sha256 = "dd181c8211dee3b4c13066fc7f58e599dd0d0d7990c1082583d2ed68807e1c87";
        libraryHaskellDepends = [ base ghc-prim ];
        description = "Extra foreign primops for primitive arrays";
        license = stdenv.lib.licenses.bsd3;
@@ -21641,7 +21700,7 @@ self: {
      mkDerivation {
        pname = "array-utils";
        version = "0.3";
-       sha256 = "1gh7gmbm0djr78dqkf8q3ap9yk4gm3dq48k8jad9ssp3w19wpkan";
+       sha256 = "56cdcb53e0e36a9d9a92682282dba88f4c9fae1a18b9891b3a593650577d07be";
        libraryHaskellDepends = [ array base ];
        description = "Primitive functions for updating many elements in mutable arrays at once";
        license = stdenv.lib.licenses.bsd3;
@@ -21653,7 +21712,7 @@ self: {
      mkDerivation {
        pname = "arrow-improve";
        version = "0.1.0.0";
-       sha256 = "0ppl8v746lj41aqb0k2724vm4n32jxmz723qa0j860jvhkh2nww7";
+       sha256 = "87732be0845b028324507888f36b976258523711474cb0b00a445243ce46f45e";
        libraryHaskellDepends = [
          arrows base pointed profunctors semigroupoids
        ];
@@ -21669,7 +21728,7 @@ self: {
      mkDerivation {
        pname = "arrow-list";
        version = "0.7";
-       sha256 = "1n6m77hdkpjd12r0b8fwxiz3jz0j86cplgsk27m2raj86vr3dy1k";
+       sha256 = "33f836f23648aa2cea11533f7a9941127c397eecdca105b2084dded9e039d5d8";
        libraryHaskellDepends = [ base containers mtl ];
        homepage = "https://github.com/silkapp/arrow-list";
        description = "List arrows for Haskell";
@@ -21681,7 +21740,7 @@ self: {
      mkDerivation {
        pname = "arrowapply-utils";
        version = "0.2";
-       sha256 = "02zampc6cc5a9fvdvxkz2r6i5sxf5w0qilsvsx8jxiw4kprbghii";
+       sha256 = "31c2b7f29d84c72e51d75bd388012faeeb124d167ff6ddb64baa3066d8adea0b";
        libraryHaskellDepends = [ base ];
        description = "Utilities for working with ArrowApply instances more naturally";
        license = stdenv.lib.licenses.bsd3;
@@ -21693,7 +21752,7 @@ self: {
      mkDerivation {
        pname = "arrowp";
        version = "0.5.0.2";
-       sha256 = "0a0ss5q8ximbd6hr0agy1106jfvdm8cx50q7a9yaiqfxs20fy6lx";
+       sha256 = "9d1aef80d0dde1a87c520783d219aa6d3b694008fe2990a169abc68e70d11a28";
        isLibrary = false;
        isExecutable = true;
        executableHaskellDepends = [ array base containers haskell-src ];
@@ -21708,7 +21767,7 @@ self: {
      mkDerivation {
        pname = "arrows";
        version = "0.4.4.1";
-       sha256 = "1qpbpwsc3frjdngwjv3r58nfa0ik88cqh24ls47svigsz3c4n42v";
+       sha256 = "5b104bd8f8fac5ad0fd194088819423302e52c2a796cc99f6d32bbc134bfebe2";
        libraryHaskellDepends = [ base Stream ];
        homepage = "http://www.haskell.org/arrows/";
        description = "Arrow classes and transformers";
@@ -21720,7 +21779,7 @@ self: {
      mkDerivation {
        pname = "artery";
        version = "0.1.1";
-       sha256 = "1fs8jap2ndcj21qgpkzy9nbnabvp4ac0xm0vdwkjjdf7i4j5kaqr";
+       sha256 = "19ab592489c73529276f1bd40e9822772f65974dfecffb701092352bae9248bb";
        libraryHaskellDepends = [
          base containers profunctors transformers
        ];
@@ -21738,7 +21797,7 @@ self: {
      mkDerivation {
        pname = "arx";
        version = "0.2.1";
-       sha256 = "0w29sdzhc54jjl7d0f3irq2s0kisd66amf0li0h9x7r00j72lvwx";
+       sha256 = "9d6f2a8e04209f9e208814b8aa8c693a4ea005ce7138d00e959214067fd34970";
        isLibrary = true;
        isExecutable = true;
        libraryHaskellDepends = [
@@ -21760,7 +21819,7 @@ self: {
      mkDerivation {
        pname = "arxiv";
        version = "0.0.1";
-       sha256 = "1has8v40h8w4v393pgd4qk4fzgdw02y12zk2hspkic1q5bx33dxh";
+       sha256 = "b0b731fa2a38b038af86627e11bc00bcbdefc8c4a4bd3bd2d8842308c8465ac1";
        revision = "1";
        editedCabalFile = "746311e6003440248df63acd19e428cbdbf5c95cdd3ee0993d2c89c7b2ceada7";
        libraryHaskellDepends = [ base parsec split tagsoup ];
@@ -21774,7 +21833,7 @@ self: {
      mkDerivation {
        pname = "ascetic";
        version = "0.0.0.4";
-       sha256 = "1c5ip8q9b6xnvh3li03iilmqz33rrlis78zs0lh4jva67b37akqk";
+       sha256 = "134f75c63a466d492005faa3a323cd798c8f2b8d71804807dcb69b9530bab1b0";
        libraryHaskellDepends = [ base MissingH ];
        description = "Generic markup builder";
        license = stdenv.lib.licenses.mit;
@@ -21787,7 +21846,7 @@ self: {
      mkDerivation {
        pname = "ascii";
        version = "0.0.4.1";
-       sha256 = "1xpw2n3gskndg74ilrq8zngawlvc3mbsji3nx2aprar96hdlpvpv";
+       sha256 = "fbee4b1b3429ab7c95e87644a9571d6c53ae9efd08671ac979cd4efd8615fcf6";
        libraryHaskellDepends = [
          base blaze-builder bytestring case-insensitive hashable text
        ];
@@ -21805,7 +21864,7 @@ self: {
      mkDerivation {
        pname = "ascii-progress";
        version = "0.2.1.2";
-       sha256 = "0lnxph4zdhkhp2w4rvx85xdwy8lnnm81apvkrddbwfr405j4nf1w";
+       sha256 = "3c384b6401243bbe5acb735f1550b59622cf5b2fa8ef4cb8b870c2f609bcdd52";
        isLibrary = true;
        isExecutable = true;
        libraryHaskellDepends = [
@@ -21830,7 +21889,7 @@ self: {
      mkDerivation {
        pname = "ascii-vector-avc";
        version = "0.1.0.0";
-       sha256 = "09m7wcq207glaz3s824vakj42vdaxc334y5k9lsh095v2xp7pwz4";
+       sha256 = "e4f37b6e17bb2400354db3783206ebaa6d41e4549b08a4c757f41d2030e3a726";
        isLibrary = true;
        isExecutable = true;
        libraryHaskellDepends = [
@@ -21851,7 +21910,7 @@ self: {
      mkDerivation {
        pname = "ascii85-conduit";
        version = "0.1.0.0";
-       sha256 = "191qw61y3jrbwzv7nabvxr6dxxigyxflbw49f0q637psqzdblsl5";
+       sha256 = "856abadac7fa9e61307089f0455df72ff6de4cee7b297bf6e72bcbe183e138a4";
        libraryHaskellDepends = [ base bytestring conduit ];
        testHaskellDepends = [ base bytestring conduit hspec ];
        jailbreak = true;
@@ -21868,7 +21927,7 @@ self: {
      mkDerivation {
        pname = "asciidiagram";
        version = "1.1.1.1";
-       sha256 = "0nzg4m1nd41x6fyki5qva5jj80sl7jd1z1gd674v50zchkw71a9m";
+       sha256 = "35a970f884ec83b2c931ed851f9a3c54032465511b9738bd333d90664325ef5b";
        isLibrary = true;
        isExecutable = true;
        libraryHaskellDepends = [
@@ -21888,7 +21947,7 @@ self: {
      mkDerivation {
        pname = "asic";
        version = "1.2";
-       sha256 = "0w7pkfd0i46a6x2ivk659rx56v9nkjvlvnmiafy96y1cbfzkyffg";
+       sha256 = "cf393fbf5b2c7893bc53b1da4db79c366d537a4ec5cc1d4537ca90089a9bf770";
        isLibrary = false;
        isExecutable = true;
        executableHaskellDepends = [ asil base bytestring utf8-string ];
@@ -21906,7 +21965,7 @@ self: {
      mkDerivation {
        pname = "asil";
        version = "1.2";
-       sha256 = "1zprddksk91wfyl1597cdgdy2r46d7vxjfxxi80rhxbfkshs4qwx";
+       sha256 = "9d63a2a19e6e7598018abd3bd9f7698664e1db6beca412a8773ca4a9676bf9fe";
        libraryHaskellDepends = [
          array base binary bytestring containers data-binary-ieee754
          directory filepath haskell-src-exts mtl pretty utf8-string uuagc
@@ -21923,7 +21982,7 @@ self: {
      mkDerivation {
        pname = "asn1-data";
        version = "0.7.1";
-       sha256 = "10s7mxygw6w8a8mx090msvbl8pji8m68lsxxyr5bp7p887naia7r";
+       sha256 = "f9a8a8ec41e89ebb4af6bd6b8a4c45515e44d7d61524d02b52881bfe7caf4783";
        revision = "1";
        editedCabalFile = "6c8f01076a88b9ea0f2ce9b5fa2b09dc658332bd4dedfbc8d6e7fae25ea5ed1f";
        isLibrary = true;
@@ -21943,7 +22002,7 @@ self: {
      mkDerivation {
        pname = "asn1-encoding";
        version = "0.9.0";
-       sha256 = "02x3lzyl4gavl3lc2lrg8rknyvs6r2hf8kmm7xrmma5m857iks8p";
+       sha256 = "17e9194f41b5a85a733fb54ee4a0c8466f6f67462f53c1e8a05b3d42fda7a30b";
        libraryHaskellDepends = [
          asn1-types base bytestring hourglass mtl
        ];
@@ -21962,7 +22021,7 @@ self: {
      mkDerivation {
        pname = "asn1-parse";
        version = "0.9.1";
-       sha256 = "1pik647wjj1mpk2vj74kjdiblqmkk5s8yxf987maa9bjm2x8g071";
+       sha256 = "e18087baa87225a5ea41c9758f7499b362ba6293931cb9c5bc3548c90f3133de";
        libraryHaskellDepends = [
          asn1-encoding asn1-types base bytestring mtl
        ];
@@ -21976,7 +22035,7 @@ self: {
      mkDerivation {
        pname = "asn1-types";
        version = "0.3.0";
-       sha256 = "1am8nmfarv7ymy3rqm0js2i82v6n6qwz0lnzb1qdmy4ligcdm65r";
+       sha256 = "b998dad88b94f8da7058df52f03936d66c81a2d012549c87affeecac5cb5a8aa";
        libraryHaskellDepends = [ base bytestring hourglass ];
        homepage = "http://github.com/vincenthz/hs-asn1-types";
        description = "ASN.1 types";
@@ -21989,7 +22048,7 @@ self: {
      mkDerivation {
        pname = "asn1dump";
        version = "0.1.0";
-       sha256 = "05kdx00bkpp3f4x1i9j8kfbdnhsivx1njcfpcxxgw93jm5ng3lj7";
+       sha256 = "47d2f16ca97224fe7a67d7316943df5143db969b48a6183a71e3deb900e86d16";
        isLibrary = false;
        isExecutable = true;
        executableHaskellDepends = [
@@ -22005,7 +22064,7 @@ self: {
      mkDerivation {
        pname = "assembler";
        version = "0.0.1";
-       sha256 = "1crwfndk7qci5id132s9f57i3kslxcdcqpymsykm1460x5nd42qs";
+       sha256 = "1a0bd26ce9c09050a7d7d55fcc1aeb54cf114f71498b115a2c91e1339b753cb3";
        isLibrary = true;
        isExecutable = true;
        libraryHaskellDepends = [ base containers ghc-binary parsec ];
@@ -22023,7 +22082,7 @@ self: {
      mkDerivation {
        pname = "assert";
        version = "0.0.1.2";
-       sha256 = "0pycrpa9m8kif31jsbmb2cb4rbvm6qinmzhkdam1b5mbmmmg5q96";
+       sha256 = "26e1f26aadab9615aa6a13fe6a233675af4c1613ab2e2dc37071a29ad4cdcc5f";
        libraryHaskellDepends = [ base ];
        testHaskellDepends = [
          base bytestring Cabal directory filepath system-posix-redirect
@@ -22038,7 +22097,7 @@ self: {
      mkDerivation {
        pname = "assert-failure";
        version = "0.1.1.0";
-       sha256 = "09djlhhyn9w822a5r41y7gk4cqk74a2fy7skzml2bah2an166gm1";
+       sha256 = "a13e63825502aa2568fd531fef8422676246e63b3e905c94108827eb21a4b225";
        libraryHaskellDepends = [ base pretty-show text ];
        homepage = "https://github.com/Mikolaj/assert-failure";
        description = "Syntactic sugar improving 'assert' and 'error'";
@@ -22052,7 +22111,7 @@ self: {
      mkDerivation {
        pname = "assertions";
        version = "0.1.0.4";
-       sha256 = "1b2p6b6brk0b1hq264i20bpdhdaq4xdzcqp7gzvfy1s5q3zwjzj8";
+       sha256 = "487ec9ffc04507eff67fe762f65b275835d8ee02221223300c0bccbccc3257ac";
        libraryHaskellDepends = [ ansi-terminal base containers ];
        testHaskellDepends = [ base interpolate process ];
        description = "A simple testing framework";
@@ -22064,7 +22123,7 @@ self: {
      mkDerivation {
        pname = "assimp";
        version = "0.1";
-       sha256 = "0jhf76v08dh1bf65ln0az1b8bc8zi9gxb0bx273mi3jvprhns4zh";
+       sha256 = "f0136d61be5b8e58c7117d81d55f8a1fb18556f80a585a8c5b013604b6390e4a";
        libraryHaskellDepends = [ base haskell98 vect ];
        librarySystemDepends = [ assimp ];
        libraryToolDepends = [ c2hs ];
@@ -22078,7 +22137,7 @@ self: {
      mkDerivation {
        pname = "astar";
        version = "0.2.1";
-       sha256 = "0qgymyaawk0ml929d5lgfikmqbxyz4shs66wq9ch9d6r175cs5b8";
+       sha256 = "6815cdca09d9b40459c2dc180d35f9be2f5c67748f969644a2154cae94affe61";
        libraryHaskellDepends = [ base containers PSQueue ];
        description = "General A* search algorithm";
        license = stdenv.lib.licenses.bsd3;
@@ -22091,7 +22150,7 @@ self: {
      mkDerivation {
        pname = "astrds";
        version = "0.1.1";
-       sha256 = "1zb265z6m1py2jxhxzrq2kb3arw2riagajhh3vs0m54rkrak6szs";
+       sha256 = "fa6b33559e99940af41e104af554cc826735d61438ff0ebb14fe866a7e3162fd";
        isLibrary = false;
        isExecutable = true;
        executableHaskellDepends = [
@@ -22112,7 +22171,7 @@ self: {
      mkDerivation {
        pname = "astview";
        version = "0.1.4";
-       sha256 = "0lv4wbblv4r0vwfynswsxzyrl6qp45byjdmg4cs760qq3jj749zl";
+       sha256 = "f42772a41c1803733423af36e95721171b9afdef9a6beb1ddf20934dd7e26453";
        isLibrary = false;
        isExecutable = true;
        executableHaskellDepends = [
@@ -22129,7 +22188,7 @@ self: {
      mkDerivation {
        pname = "astview-utils";
        version = "0.1";
-       sha256 = "1rqqlngmcdd7i1gww95lyim971w8xv0hjg20h0j8av4y29pjxfyn";
+       sha256 = "d6bb2e6f129e6c852480403c09c1ee8887936af4b424ce5f88a735569fa518e7";
        libraryHaskellDepends = [ base containers syb ];
        description = "Interfacing between hint and astview";
        license = stdenv.lib.licenses.bsdOriginal;
@@ -22142,7 +22201,7 @@ self: {
      mkDerivation {
        pname = "async";
        version = "2.0.2";
-       sha256 = "0azx4qk65a9a2gvqsfmz3w89m6shzr2iz0i5lly2zvly4n2d6m6v";
+       sha256 = "db54d384259eee2f3ca525821f45fe509b9a101fbf3a8df7132aa9622626fd2b";
        libraryHaskellDepends = [ base stm ];
        testHaskellDepends = [
          base HUnit test-framework test-framework-hunit
@@ -22159,7 +22218,7 @@ self: {
      mkDerivation {
        pname = "async-extras";
        version = "0.1.2.0";
-       sha256 = "137vpkc4xlbmghbjmgdjxaqcji19cj1vxm64df9gxb7356d0rzyh";
+       sha256 = "d0ff0c9a29e3acfe926bc4d4be83642944c9b0eab2bd2a177c75d14ed8bcfb8c";
        libraryHaskellDepends = [
          async base lifted-async lifted-base monad-control SafeSemaphore stm
          transformers-base
@@ -22175,7 +22234,7 @@ self: {
      mkDerivation {
        pname = "async-manager";
        version = "0.1.1.0";
-       sha256 = "002w3n0ykn5ga7mwz9kjvr77izqnhklq5r3aczwjikvgkik9q6ck";
+       sha256 = "93199c669c6fcf28f9676ae482e98416ff784ede72a6cfeb51afd8e9811d5c00";
        isLibrary = true;
        isExecutable = true;
        libraryHaskellDepends = [ async base stm unordered-containers ];
@@ -22193,7 +22252,7 @@ self: {
      mkDerivation {
        pname = "async-pool";
        version = "0.9.0";
-       sha256 = "10952y60ivkx78skf7ds0dv8gp6bf3v47lays928vnpb8m5cr0rh";
+       sha256 = "3083cc4a45ebda8d44d25ed143f670cbdc877603ba1d37353a7dee088c172581";
        libraryHaskellDepends = [
          async base containers fgl monad-control stm transformers
          transformers-base
@@ -22211,7 +22270,7 @@ self: {
      mkDerivation {
        pname = "asynchronous-exceptions";
        version = "1.1.0.1";
-       sha256 = "0vfx2ikw61sic35n4ayy7rng6izpafksz7lh4xgkcmbg627vkm8s";
+       sha256 = "1ad5b98f306f55365f27909eafa753f747f36c3ede2b62cb605107c36714dd6d";
        libraryHaskellDepends = [ base ];
        jailbreak = true;
        homepage = "https://github.com/feuerbach/asynchronous-exceptions";
@@ -22224,7 +22283,7 @@ self: {
      mkDerivation {
        pname = "aterm";
        version = "0.1.0.1";
-       sha256 = "02aajiirz68wqyrcigfb4cym7j43cf3p0dn4awcw8simnqhfaskh";
+       sha256 = "706ae520b6356ac41957c43670876383c8533d23cbbdc8b2c71c999f63944a09";
        libraryHaskellDepends = [ array base containers ghc-prim ];
        homepage = "https://svn-agbkb.informatik.uni-bremen.de/Hets/trunk/atermlib";
        description = "serialisation for Haskell values with sharing support";
@@ -22236,7 +22295,7 @@ self: {
      mkDerivation {
        pname = "aterm-utils";
        version = "0.2.0.2";
-       sha256 = "0yyk2mdxrla0hwh1mn50x5mgqskkaw6i086gqqmprljr2668kkj0";
+       sha256 = "40ce898c1159d27c2bc6cf20100d57736afc6ae9a0d81a208740d1dc5b15d37b";
        isLibrary = true;
        isExecutable = true;
        libraryHaskellDepends = [ aterm base mtl transformers wl-pprint ];
@@ -22252,7 +22311,7 @@ self: {
      mkDerivation {
        pname = "atl";
        version = "15409.2";
-       sha256 = "1by20xr3s3f0rh1h9zfpcp1i8sn1qv6292mjvav108iws0dh4wq2";
+       sha256 = "0273021bd03c2210b6dab28a24ccc6c16a14c365d7fd0403ccc00d3d7207c2af";
        libraryHaskellDepends = [ base ];
        description = "Arrow Transformer Library";
        license = "LGPL";
@@ -22269,7 +22328,7 @@ self: {
      mkDerivation {
        pname = "atlassian-connect-core";
        version = "0.7.0.1";
-       sha256 = "16pf2ir84fx6x01mpp109qh9rf96fp57230qr4k4n7qms068dgpy";
+       sha256 = "febe860cd0151f4b26c9180c71ca7526b99c204e20dc5b03e8a63b827214ee9a";
        libraryHaskellDepends = [
          aeson atlassian-connect-descriptor base base64-bytestring
          bytestring case-insensitive cipher-aes configurator containers
@@ -22292,7 +22351,7 @@ self: {
      mkDerivation {
        pname = "atlassian-connect-descriptor";
        version = "0.4.0.2";
-       sha256 = "1pss2rkd1s4dmnym5w2sanhqgz2pv1n9zyq4n8jy8ihc4zgrcscp";
+       sha256 = "976996df270c46e425b204fb9f6cd857fc87a1555af052bdad8de8d066165adf";
        libraryHaskellDepends = [
          aeson base cases network network-uri text time-units
          unordered-containers
@@ -22313,7 +22372,7 @@ self: {
      mkDerivation {
        pname = "atmos";
        version = "0.2.0.0";
-       sha256 = "0qx5a6dzaxjw1flybpmbf3hf7xycg4x69283njszwijw23ak6sv6";
+       sha256 = "666b33d5105c46feb5b40389643a79ccf7e3e070abdee5a90b5c76f59b51a563";
        libraryHaskellDepends = [ base ];
        testHaskellDepends = [
          base HUnit test-framework test-framework-hunit
@@ -22327,7 +22386,7 @@ self: {
      mkDerivation {
        pname = "atmos-dimensional";
        version = "0.1.2";
-       sha256 = "19rlcp1zn3k838c5ixsn6i09nclfwvd9prbirxy5fmch0yjlp39d";
+       sha256 = "2d8d4ba5079055577ccf71e59bdae68e329b403456f758181a680efbc36534a7";
        libraryHaskellDepends = [ atmos base dimensional ];
        description = "dimensional wrapper on atmos package";
        license = stdenv.lib.licenses.bsd3;
@@ -22338,7 +22397,7 @@ self: {
      mkDerivation {
        pname = "atmos-dimensional-tf";
        version = "0.1.2";
-       sha256 = "05g2v7ppbcvaw0dk9f0z0gb7k33c4lk2cm2ziyqahxmwsz928khm";
+       sha256 = "154e24d2d7bc76a8b08f5f542626256c8c79d6031fb8341be06ab375efd9e215";
        libraryHaskellDepends = [ atmos base dimensional-tf ];
        description = "dimensional-tf wrapper on atmos package";
        license = stdenv.lib.licenses.bsd3;
@@ -22349,7 +22408,7 @@ self: {
      mkDerivation {
        pname = "atom";
        version = "1.0.13";
-       sha256 = "111lz39q12rvh2iigxakcnf2firxgbgm462id805n3z7rmg8f807";
+       sha256 = "0720875ecde70f5b006a511852df7a3d47279c6553f517a3803b8b80d3f83484";
        libraryHaskellDepends = [ base bimap containers mtl process syb ];
        homepage = "http://tomahawkins.org";
        description = "An EDSL for embedded hard realtime applications";
@@ -22363,7 +22422,7 @@ self: {
      mkDerivation {
        pname = "atom-basic";
        version = "0.2.2";
-       sha256 = "1n9illmrkrd1gr3imjvclzny8kjx7d0mak9yvyc129gfb9ap52cd";
+       sha256 = "8d8972555aee251198df3e4d55413b5d4ee4eda76ccb1a477ea1e5992ba531d9";
        libraryHaskellDepends = [
          base base64-bytestring bytestring network network-uri old-locale
          text time
@@ -22383,7 +22442,7 @@ self: {
      mkDerivation {
        pname = "atom-conduit";
        version = "0.1.0.0";
-       sha256 = "1jhd7036ga1sf1zgclc1m5gjzj5smf84rzvy5xac70wgcaa8iajk";
+       sha256 = "53aa8894628f83c3542f7eff4c90abbac82f5fa98151f67e703aa86706380dca";
        libraryHaskellDepends = [
          base conduit conduit-parse containers exceptions lens
          mono-traversable network-uri parsers text time timerep xml-conduit
@@ -22404,7 +22463,7 @@ self: {
      mkDerivation {
        pname = "atom-msp430";
        version = "0.5.3";
-       sha256 = "02h1g35f3bd3cjjhr28g63vk1mnghshq9586wa922rfl79jp6jcs";
+       sha256 = "9a4973653ad4652192e2069584a186cfd630f7300f890ca564a3ade1ca78010a";
        libraryHaskellDepends = [ atom base mtl ];
        homepage = "https://github.com/eightyeight/atom-msp430";
        description = "Convenience functions for using Atom with the MSP430 microcontroller family";
@@ -22417,7 +22476,7 @@ self: {
      mkDerivation {
        pname = "atomic-primops";
        version = "0.8";
-       sha256 = "0wb45yjflpih94i95s88hfl4mcddcjsabspnm6h20wxv0n09xqf0";
+       sha256 = "c0e19e8005bb7320a0a9f6eaa5b464adb14aa88308e9922249305eeaa42f6471";
        libraryHaskellDepends = [ base ghc-prim primitive ];
        homepage = "https://github.com/rrnewton/haskell-lockfree/wiki";
        description = "A safe approach to CAS and other atomic ops in Haskell";
@@ -22431,7 +22490,7 @@ self: {
      mkDerivation {
        pname = "atomic-primops-foreign";
        version = "0.6.2";
-       sha256 = "1pfdbrxx4s6n53lfhxghcalm8dif2r9zj45bipibvyiczz5xkkpm";
+       sha256 = "f5ced9cbff2cfabde28dab10f953162e3654a962f075e8e828d668d27b5ecddd";
        revision = "1";
        editedCabalFile = "fd1067adbd96e923226347dccaa9e3e221439702fe7824c86db44eb5b7f6c318";
        libraryHaskellDepends = [ base bits-atomic ];
@@ -22449,7 +22508,7 @@ self: {
      mkDerivation {
        pname = "atomic-primops-vector";
        version = "0.1.0.1";
-       sha256 = "0m4mlixiz7cs4hqrh7i6dzbsj55p0qh3m16nc94819wbzcgi3vq7";
+       sha256 = "07ef111ffb8ba7804862d6843a2006b714a9d76f261e9831249a9d1f7ba49554";
        libraryHaskellDepends = [ atomic-primops base primitive vector ];
        testHaskellDepends = [ base vector ];
        jailbreak = true;
@@ -22464,7 +22523,7 @@ self: {
      mkDerivation {
        pname = "atomic-write";
        version = "0.2.0.4";
-       sha256 = "1y09vyxv1fdlkzz7r27snrjhi19msqj06cjdwy7mgbjb6v7z46w9";
+       sha256 = "891bf2cf364bae578fe74d320324d635850865b6fa887cfe9fb4b9b0bbdf09f8";
        libraryHaskellDepends = [
          base bytestring directory filepath temporary text unix-compat
        ];
@@ -22484,7 +22543,7 @@ self: {
      mkDerivation {
        pname = "atomo";
        version = "0.4.0.2";
-       sha256 = "0hby64jd9zi518rnfk46ilipnp3x0ynkgqk2n0brf1873y88mwx8";
+       sha256 = "a8f38a901f07059717b062e237ad077d5c7b238d864c67330a25fed424317e41";
        isLibrary = true;
        isExecutable = true;
        libraryHaskellDepends = [
@@ -22508,7 +22567,7 @@ self: {
      mkDerivation {
        pname = "attempt";
        version = "0.4.0.1";
-       sha256 = "1gvq04ds62kk88r2210mxd1fggp6vf5p8j5hci9vqkkss1hy9rxh";
+       sha256 = "b0e7e461d07a4ebc5364b048748bdbe6bee742eb1504213242730aa31b0178bf";
        libraryHaskellDepends = [ base failure ];
        homepage = "http://github.com/snoyberg/attempt/tree/master";
        description = "Concrete data type for handling extensible exceptions as failures. (deprecated)";
@@ -22523,7 +22582,7 @@ self: {
      mkDerivation {
        pname = "atto-lisp";
        version = "0.2.2";
-       sha256 = "13lhdalam4gn9faa58c3c7nssdwp2y0jsfl1lnnvr3dx6wzp0jhc";
+       sha256 = "0c4a703f37bd8dbcada5813a2d81179737aded6183a1a2944bf691aaa86a908e";
        revision = "1";
        editedCabalFile = "feb39753d89c58abac767ed3fe5644428b5d15d83c69f7b26b282f3b9969f2fa";
        libraryHaskellDepends = [
@@ -22548,7 +22607,7 @@ self: {
      mkDerivation {
        pname = "attoparsec";
        version = "0.13.0.1";
-       sha256 = "0cprkr7bl4lrr80pz8mryb4rbfwdgpsrl7g0fbcaybhl8p5hm26f";
+       sha256 = "ce880acb45142eafd872e01d9af57d8dbb95c9f2b9a27f01ca9912ba4e9ef932";
        libraryHaskellDepends = [
          array base bytestring containers deepseq scientific text
          transformers
@@ -22568,7 +22627,7 @@ self: {
      mkDerivation {
        pname = "attoparsec-arff";
        version = "0.0";
-       sha256 = "1jf9065pqmdfshkd0cqiamhivs9an4slqx82n7yj0kkhdxw5lyq4";
+       sha256 = "047b5a786f704e20fdb102754c35b12ae91d61551133d026d4ae557c8b01c9c9";
        libraryHaskellDepends = [ attoparsec base bytestring ];
        description = "An ARFF file parser using Attoparsec";
        license = stdenv.lib.licenses.gpl2;
@@ -22579,7 +22638,7 @@ self: {
      mkDerivation {
        pname = "attoparsec-binary";
        version = "0.2";
-       sha256 = "02vswxsgayw50xli7mbacsjmk1diifzkfgnyfn9ck5mk41dl9rh5";
+       sha256 = "05e6445b20b396c99275de3e37bf8bb18559a5666ad5136907857bf574e77a0b";
        libraryHaskellDepends = [ attoparsec base bytestring ];
        description = "Binary processing extensions to Attoparsec";
        license = stdenv.lib.licenses.bsd3;
@@ -22590,7 +22649,7 @@ self: {
      mkDerivation {
        pname = "attoparsec-conduit";
        version = "1.1.0";
-       sha256 = "18xn3nzxfghcd88cana1jw85ijv0ysw3bp36fb6r5wsf6m79z01y";
+       sha256 = "3e809f4e354ef392cd7266dc35b8f660cb5810974159c5106a0c3ed7bf1db6a3";
        libraryHaskellDepends = [ base conduit ];
        homepage = "http://github.com/snoyberg/conduit";
        description = "Consume attoparsec parsers via conduit. (deprecated)";
@@ -22602,7 +22661,7 @@ self: {
      mkDerivation {
        pname = "attoparsec-csv";
        version = "0.1.0.1";
-       sha256 = "0zh1g9687nrdxksniq348jc04hbgf5kxbzqs0kggmz7qqw03iq0v";
+       sha256 = "1be03800c7f8fcfade041affd567716f4102984464e068f5ec2ddb834c7a017e";
        libraryHaskellDepends = [ attoparsec base text ];
        jailbreak = true;
        homepage = "https://github.com/robinbb/attoparsec-csv";
@@ -22616,7 +22675,7 @@ self: {
      mkDerivation {
        pname = "attoparsec-enumerator";
        version = "0.3.4";
-       sha256 = "127mj0v6342mzxnc73qki3k197vhwsff8qkf92gm5idyxdisg5dy";
+       sha256 = "be95a763ebbec5529f486e62e49ce6709f14e688138fc36cff5590613690f588";
        libraryHaskellDepends = [
          attoparsec base bytestring enumerator text
        ];
@@ -22630,7 +22689,7 @@ self: {
      mkDerivation {
        pname = "attoparsec-expr";
        version = "0.1.1.2";
-       sha256 = "0z25pc3rq98ysk92jclr90n35982a566sxri51yh1s9c24vd8k4d";
+       sha256 = "8d4cd436112ce9007d2831776d4c5102a5322c48993229d2d41e259c07bb457c";
        libraryHaskellDepends = [ attoparsec base ];
        description = "Port of parsec's expression parser to attoparsec";
        license = stdenv.lib.licenses.bsd3;
@@ -22643,7 +22702,7 @@ self: {
      mkDerivation {
        pname = "attoparsec-iteratee";
        version = "0.4.0";
-       sha256 = "1j57xhk34ghi1b2gnzrfbswv2nab5h0z52h3wvx9w8d97bbvqp2s";
+       sha256 = "5a5cbcd73aa9219efae6038af2012c4b59b1b95e2e7ffbc40a113e3226eca7c8";
        libraryHaskellDepends = [
          attoparsec base bytestring iteratee transformers
        ];
@@ -22661,7 +22720,7 @@ self: {
      mkDerivation {
        pname = "attoparsec-parsec";
        version = "0.1.3";
-       sha256 = "0mi3f1kwcss8m1679ymiydp1sb1xdyv1f6a0qx9d683p86qxrwzq";
+       sha256 = "f8f3dcb1417720d352c7401917b66f3d2c1d6ef3b1fa744ca8486bc667702356";
        libraryHaskellDepends = [ attoparsec base parsec text ];
        testHaskellDepends = [
          attoparsec base hspec markdown-unlit QuickCheck text
@@ -22675,7 +22734,7 @@ self: {
      mkDerivation {
        pname = "attoparsec-text";
        version = "0.8.5.3";
-       sha256 = "1qq42lp1sah80a6lnnafi6pwl61b4w4q4jk1pbb7pg5p06mmk315";
+       sha256 = "258c59ab01b7bc7bd6ba614a8209272b18caaf894e594b8d02082a1d2e1504e3";
        libraryHaskellDepends = [ array attoparsec base containers text ];
        jailbreak = true;
        homepage = "http://patch-tag.com/r/felipe/attoparsec-text/home";
@@ -22689,7 +22748,7 @@ self: {
      mkDerivation {
        pname = "attoparsec-text-enumerator";
        version = "0.2.0.1";
-       sha256 = "0cffcwji141js09r7avb15b08xl4s8cgk5vxyrqaq7zw40hhb1gz";
+       sha256 = "ff85052120fc1fac70f67d97f918d284760456096bab9313d03290102567ce31";
        libraryHaskellDepends = [ attoparsec-text base enumerator text ];
        jailbreak = true;
        description = "(deprecated)";
@@ -22702,7 +22761,7 @@ self: {
      mkDerivation {
        pname = "attoparsec-trans";
        version = "0.1.1.0";
-       sha256 = "0lsbl7hhirr13jmn6fc4g5443j73p4rxjgxvv967n5dsp7xrjaa7";
+       sha256 = "472999fbb9ba157b4cdabb3fd933b9e3c8414879843963ab1c21e708e1a14b53";
        libraryHaskellDepends = [ attoparsec base transformers ];
        homepage = "https://github.com/srijs/haskell-attoparsec-trans";
        description = "Interleaved effects for attoparsec parsers";
@@ -22714,7 +22773,7 @@ self: {
      mkDerivation {
        pname = "attosplit";
        version = "0.1.0.0";
-       sha256 = "01sh8k9n9040xqx1lbn74rcf59j54n5861d9db1y5cdy7qssxyg4";
+       sha256 = "e4f9ae353ebeb1e2c36aa905838a2545a6e25826c72e1a3aee808064d3445007";
        libraryHaskellDepends = [ attoparsec base bytestring ];
        jailbreak = true;
        homepage = "http://projects.haskell.org/attosplit";
@@ -22727,7 +22786,7 @@ self: {
      mkDerivation {
        pname = "atuin";
        version = "0.1.1";
-       sha256 = "1wmfnvl39amyfzkvpd3gysshyf10fjjb91zibalkqbq9pbsnfzjk";
+       sha256 = "537e67f5ba092f3ca95af187b4a47420380fb5f66fb4bbe777beaa34e8b6aef2";
        isLibrary = false;
        isExecutable = true;
        executableHaskellDepends = [
@@ -22744,7 +22803,7 @@ self: {
      mkDerivation {
        pname = "audacity";
        version = "0.0";
-       sha256 = "1vfp5x5b6z7lwjiv8jla5bdwbcbafdm31zs9kr555idzz1n8wmqz";
+       sha256 = "1f578e6cf8bfc5524a9e49ff306a736ab1c5db2a8a4ab4a3e4f47cb34a2fd7ed";
        isLibrary = true;
        isExecutable = true;
        libraryHaskellDepends = [ base deepseq utility-ht ];
@@ -22762,7 +22821,7 @@ self: {
      mkDerivation {
        pname = "audiovisual";
        version = "0.0";
-       sha256 = "0qjcsvv52l53iqyh7hkhwdsifqb943wjp1vn63qhqsrdaajazp3h";
+       sha256 = "70dcafa4522d6b0cf13076872bf92069611775e370c2033d8ea35051f6d64c62";
        libraryHaskellDepends = [
          base boundingboxes colors deepseq directory filepath free freetype2
          hashable JuicyPixels JuicyPixels-util lens linear mtl objective
@@ -22779,7 +22838,7 @@ self: {
      mkDerivation {
        pname = "augeas";
        version = "0.6.1";
-       sha256 = "08z6l97hi6clv3b34mz9zjc5rns02jx1zx9iqdsmjl2p7hcn7rs5";
+       sha256 = "45e763193c57505975c331f51fba1440db5c98fce95732d6d89499084fa2e623";
        isLibrary = true;
        isExecutable = true;
        libraryHaskellDepends = [ base bytestring directory unix ];
@@ -22800,7 +22859,7 @@ self: {
      mkDerivation {
        pname = "augur";
        version = "2008.11.17";
-       sha256 = "1jvbf3z9z6m40hprykxcc5xwbmwm6p5hwlyab0dimd8h2ar50xfr";
+       sha256 = "d97550b21210b51a1b58ca530ecb3595d7c57b61ac4f9f2f04a49a9ffe706bcb";
        isLibrary = false;
        isExecutable = true;
        executableHaskellDepends = [
@@ -22820,7 +22879,7 @@ self: {
      mkDerivation {
        pname = "aur";
        version = "3.0.0";
-       sha256 = "1sf76lysp8xchym78ha4glrw11hxic5g684mm8h6w0n05x1ywxcn";
+       sha256 = "9675ee432fc0026e20aa9520f30a8b1d86c0337d444174aa87aca3ab3d35c7e9";
        libraryHaskellDepends = [
          aeson aeson-pretty base filepath lens lens-aeson mtl text vector
          wreq
@@ -22839,7 +22898,7 @@ self: {
      mkDerivation {
        pname = "authenticate";
        version = "1.3.2.11";
-       sha256 = "1xkzaw9a338yclbm10cfa9cnjdjpmzif2qj4hprig45z5szqi4q4";
+       sha256 = "049388bf2ebf9017f3854462e1e2af57366959528e815017651e8da112577ff6";
        libraryHaskellDepends = [
          aeson attoparsec base blaze-builder bytestring case-insensitive
          conduit containers http-conduit http-types monad-control
@@ -22856,7 +22915,7 @@ self: {
      mkDerivation {
        pname = "authenticate-kerberos";
        version = "1.0.0";
-       sha256 = "06k8xi9n44xq63dpmcv4l0vg35y19dk5x1ibyay05w58k4kv4fdq";
+       sha256 = "b839b22799a8f002bcf22b865e664bc197f136a064b37adb30b8136253ec681a";
        libraryHaskellDepends = [ base process text ];
        homepage = "http://github.com/yesodweb/authenticate";
        description = "Authentication methods for Haskell web applications";
@@ -22868,7 +22927,7 @@ self: {
      mkDerivation {
        pname = "authenticate-ldap";
        version = "0.0.3";
-       sha256 = "1wsx43l7jl40jpzhiv2fjc1mnpsaaryrjpqaiyqsn3ahacsy4ly5";
+       sha256 = "c553e23553500dabb18f0a5f997d564a5f5b03934eec08ff95805079e8205df3";
        libraryHaskellDepends = [ base LDAP text transformers ];
        jailbreak = true;
        homepage = "http://github.com:mlitchard/authenticate-ldap";
@@ -22884,7 +22943,7 @@ self: {
      mkDerivation {
        pname = "authenticate-oauth";
        version = "1.5.1.1";
-       sha256 = "02y35yd4zmpy36yba2nzbvijhfw0wvijkiqmh7h9qjpbqvmib7zb";
+       sha256 = "eb9f15ebc6eb4a9ce08115c729e3e6803b28e35edf0ab5bc19fed64f9a2fc30b";
        libraryHaskellDepends = [
          base base64-bytestring blaze-builder bytestring crypto-pubkey-types
          data-default http-client http-types random RSA SHA time
@@ -22900,7 +22959,7 @@ self: {
      mkDerivation {
        pname = "authinfo-hs";
        version = "0.1.0.0";
-       sha256 = "1jv0y4y2ig8dx95xw3zbxc1h9mv3wi3r8xqx00llmf2qs6wgdlp5";
+       sha256 = "e5d2f6b8d158b84a29001d779447e463d70403ebeb0fde4bea0dbd283cf160cb";
        libraryHaskellDepends = [ attoparsec base network text ];
        homepage = "http://github.com/robgssp/authinfo-hs";
        description = "Password querying for .authinfo";
@@ -22915,7 +22974,7 @@ self: {
      mkDerivation {
        pname = "authoring";
        version = "0.3.4";
-       sha256 = "0jfxgrbkcqpfcvg1jk7ysd74bq7xjlvzqamnr3qg4ib9zg6yw0k4";
+       sha256 = "6402eecdfb6945f2f0c8b62afc3795fde0454ed3fe4c19de66ee6236577edd49";
        libraryHaskellDepends = [
          ansi-wl-pprint base citation-resolve containers data-default
          haskell-src-meta HaTeX lens mtl parsers safe template-haskell text
@@ -22935,7 +22994,7 @@ self: {
      mkDerivation {
        pname = "auto";
        version = "0.4.3.0";
-       sha256 = "13ic0sh45ixxg456yg3y47f6b3avqn2l5ds0jc933ldk0z0wsdn8";
+       sha256 = "c836cdc107b3d131129340b74285c55b8d65dc217e3c6f0a79bdc742a0062c8e";
        libraryHaskellDepends = [
          base base-orphans bytestring cereal containers deepseq MonadRandom
          profunctors random semigroups transformers
@@ -22950,7 +23009,7 @@ self: {
      mkDerivation {
        pname = "auto-update";
        version = "0.1.2.2";
-       sha256 = "1ns4c5mqhnm7hsiqxf1ivjs5fflyq92b16ldzrcl0p85631h0c3v";
+       sha256 = "7b3000c330055d4059fe8d9ab044c29e3a57b4dc31b88ea386a75a886b6144db";
        libraryHaskellDepends = [ base ];
        homepage = "https://github.com/yesodweb/wai";
        description = "Efficiently run periodic, on-demand actions";
@@ -22966,7 +23025,7 @@ self: {
      mkDerivation {
        pname = "autonix-deps";
        version = "0.3.0.0";
-       sha256 = "0mp2v6wdm4nlagg3z9xmxd9dfkchazgvbgdphm1nfqzkg8w7ralv";
+       sha256 = "9baa7c387af363674385b7bdb5df57904dd752ebb5a73fde53d492dab8d9e256";
        libraryHaskellDepends = [
          aeson aeson-pretty base bytestring conduit containers errors
          filepath lens libarchive-conduit mtl optparse-applicative process
@@ -22983,7 +23042,7 @@ self: {
      mkDerivation {
        pname = "autonix-deps-kf5";
        version = "0.3.0.0";
-       sha256 = "0njmgx2x6018ca1r2xvbi3pq0rigqm4fjkk33q5kzacvmv5ni461";
+       sha256 = "c19068cbae9ba93f0b1e634ee948c52f6680ef886b779183622800d3457f555a";
        isLibrary = true;
        isExecutable = true;
        libraryHaskellDepends = [
@@ -23002,7 +23061,7 @@ self: {
      mkDerivation {
        pname = "autoproc";
        version = "0.1.2";
-       sha256 = "0yrlaq2jr89ncla3cpj6ir8bamwdchxnr39vsvkm7qpan61f2x65";
+       sha256 = "c574e182b1eae253e7d63b8d6c3b648d57b5508e465e36146536a12c0556347b";
        isLibrary = true;
        isExecutable = true;
        libraryHaskellDepends = [ base directory mtl process unix ];
@@ -23017,7 +23076,7 @@ self: {
      mkDerivation {
        pname = "avahi";
        version = "0.1.1";
-       sha256 = "0b2bw0rp33g8s1y6hyqji3ycv26a4ixgjmkph93isnjxglfl6ah0";
+       sha256 = "002a431d7d5d5a1d47827756f97a24ca88cdfc88127b687cd0e88d7133e04b2c";
        libraryHaskellDepends = [ base dbus-core text ];
        description = "Minimal DBus bindings for Avahi daemon (http://avahi.org)";
        license = stdenv.lib.licenses.bsd3;
@@ -23029,7 +23088,7 @@ self: {
      mkDerivation {
        pname = "average";
        version = "0.6.1";
-       sha256 = "13qkgkwdcb09s69wzhd3b6dl1nm66lv2hqb51gmr4s64ylgf0a9h";
+       sha256 = "3029e01ef5c46892eb0b6561283635a6da409b59a3c1cf93d1092cd6f87c138f";
        revision = "1";
        editedCabalFile = "90c8c1d4ece76a1f1b43f1a6bef7ba15340a2bec8e2efbb465884d6b50b5d174";
        libraryHaskellDepends = [ base semigroups vector-space ];
@@ -23047,7 +23106,7 @@ self: {
      mkDerivation {
        pname = "avers";
        version = "0.0.9";
-       sha256 = "0zcgq4b20vvg2mqm9yqm4gvakafn9r8mghki8bn87xhk0w7h99km";
+       sha256 = "75a6040f0713f683ec4271c257514ed6a9a9f62315fb5471156f6f2016c18f7d";
        libraryHaskellDepends = [
          aeson attoparsec base base16-bytestring bytestring clock containers
          cryptohash filepath inflections MonadRandom mtl network network-uri
@@ -23072,7 +23131,7 @@ self: {
      mkDerivation {
        pname = "avl-static";
        version = "0.1.0.0";
-       sha256 = "13rl5wrpmbb4c0zsaymivi4d9qg2wl4lfw4nvkd81naqm3vskc10";
+       sha256 = "20b0a9f7a858d980dadc96704709e5e2e1d448dcb17aa53f6064ad7a332f348f";
        libraryHaskellDepends = [ base ];
        testHaskellDepends = [
          base QuickCheck test-framework test-framework-quickcheck2
@@ -23087,7 +23146,7 @@ self: {
      mkDerivation {
        pname = "avr-shake";
        version = "0.0.1.1";
-       sha256 = "0avj9idsk70c7gzkm18kcsvh3xhg57r8aifhdpyihzyvp87k61pn";
+       sha256 = "f606330fbadb7f18fd6dd04585f2290ff601b76613853aff3b0c9ca95b4c722b";
        libraryHaskellDepends = [ base dependent-sum mtl process shake ];
        homepage = "https://github.com/mokus0/avr-shake";
        description = "AVR Crosspack actions for shake build systems";
@@ -23101,7 +23160,7 @@ self: {
      mkDerivation {
        pname = "awesomium";
        version = "0.1.0.0";
-       sha256 = "0qd89nlw4rqdl8iya49rldyn5a36d64slcnw5pfh5c5aajh27aq2";
+       sha256 = "02ab23a054aab002dd2ddc32aa896966a8627da33911e523a20d67c2a94da861";
        libraryHaskellDepends = [
          aeson attoparsec awesomium-raw base containers text vector
        ];
@@ -23115,7 +23174,7 @@ self: {
      mkDerivation {
        pname = "awesomium-glut";
        version = "0.1.0.0";
-       sha256 = "175hgqix2j26579g0rrryl86w7qvla95nvf4lwfxsxxwqgcq3zpd";
+       sha256 = "edfe81d9c3bc77dd1da7c46d5b92a21b1f6e10f53967f0d2294648d1237eb09c";
        libraryHaskellDepends = [ awesomium awesomium-raw base GLUT ];
        description = "Utilities for using Awesomium with GLUT";
        license = stdenv.lib.licenses.gpl3;
@@ -23127,7 +23186,7 @@ self: {
      mkDerivation {
        pname = "awesomium-raw";
        version = "0.1.0.0";
-       sha256 = "0djilsrgb8y84ssslwawhw6lky7bqspz31qwjy9lkxywi5hwxnyb";
+       sha256 = "cbdbce6189dcf74993971c87f1afc6ebf8490d875c71aab526c8a3f5b2a65136";
        libraryHaskellDepends = [ base ];
        librarySystemDepends = [ awesomium ];
        libraryToolDepends = [ c2hs ];
@@ -23150,7 +23209,7 @@ self: {
      mkDerivation {
        pname = "aws";
        version = "0.12.1";
-       sha256 = "0aykch71qakmxn47i6h23h52dp41x7kwcibv527xg57ab71vm1bc";
+       sha256 = "6c85bac359ea94d78f287b45c6e7e981dc260a1c029a7888ed752a1c0e64d32b";
        isLibrary = true;
        isExecutable = true;
        libraryHaskellDepends = [
@@ -23178,7 +23237,7 @@ self: {
      mkDerivation {
        pname = "aws-cloudfront-signer";
        version = "1.1.0.2";
-       sha256 = "0cxh0b0g4lms2zpgw6q4k7bk2a7px8kafdr6qrbrcf7p3dkmzwd9";
+       sha256 = "a9f15f671bf7389657c62637a726eaf72831d799041bfeee17ba52f2c002b033";
        libraryHaskellDepends = [
          asn1-encoding asn1-types base base64-bytestring bytestring
          crypto-pubkey-types old-locale RSA time
@@ -23198,7 +23257,7 @@ self: {
      mkDerivation {
        pname = "aws-configuration-tools";
        version = "0.1.0.0";
-       sha256 = "0xqwhd15ijwf6h26hb1nl16813b1rfh1nx6qipslz6pw857vv53b";
+       sha256 = "6b94bd4f41fc9a4ff58dd8741ba0cb618d804ca0362c6804348ecb5842831c77";
        revision = "2";
        editedCabalFile = "536eacac6f54fbeb3e823d5b751eaa8cf1bb45a69f1d0bf54bdbff6245eb93e9";
        libraryHaskellDepends = [
@@ -23217,7 +23276,7 @@ self: {
      mkDerivation {
        pname = "aws-dynamodb-conduit";
        version = "0.1.0.6";
-       sha256 = "15svx7c8nld8bgwqwy5mwkbniz4c1ifw2rw427gwk7y2py1hq38p";
+       sha256 = "170d0c83bfc29fc9df118467c15d0c8cfc68d7e4b5788ef95ba8518bd8e95b97";
        libraryHaskellDepends = [
          aeson attoparsec-trans aws base bytestring conduit containers
          http-conduit http-types json-togo resourcet text transformers
@@ -23237,7 +23296,7 @@ self: {
      mkDerivation {
        pname = "aws-dynamodb-streams";
        version = "0.1.0.0";
-       sha256 = "0yqmijls71jyvic2saabj3kwnpaxmlj6mf4krcdli3626ra7w4r2";
+       sha256 = "22137e5436c28c481bcb93b86a24ad5d5dcbe7904b292d58dc5e86a3a98c157b";
        libraryHaskellDepends = [
          aeson attoparsec aws aws-general base base-unicode-symbols
          base16-bytestring base64-bytestring byteable bytestring
@@ -23261,7 +23320,7 @@ self: {
      mkDerivation {
        pname = "aws-ec2";
        version = "0.3.2";
-       sha256 = "0wgg05hnzjrlhzkc5giy5gdkiy4dg6hvgdq433ifld11vrpy152d";
+       sha256 = "4d94e06fde2134eae21804b7b7a1798df838db2b3ebec2e68734cb6f6101ef71";
        isLibrary = true;
        isExecutable = true;
        libraryHaskellDepends = [
@@ -23288,7 +23347,7 @@ self: {
      mkDerivation {
        pname = "aws-elastic-transcoder";
        version = "0.2.0.2";
-       sha256 = "02dygqqyal6s3ibjvgxng4vspld3c6mrgrwdhig8lfri2zdpqsw9";
+       sha256 = "896b7cdb17313b8a5e848de797ab61a3d1ab3779b6bf2d571cda50e5317ebe09";
        isLibrary = true;
        isExecutable = true;
        libraryHaskellDepends = [
@@ -23314,7 +23373,7 @@ self: {
      mkDerivation {
        pname = "aws-general";
        version = "0.2.2";
-       sha256 = "08sy37w162zqd6dqi8kkg0782nv00jsp48bnrmhwhmkhnd2arfrj";
+       sha256 = "32bbac44b37056c861cd762172b504605b810e7873a2889b69f80b13f8195e23";
        libraryHaskellDepends = [
          aeson attoparsec base base16-bytestring blaze-builder byteable
          bytestring case-insensitive cryptohash deepseq hashable http-types
@@ -23340,7 +23399,7 @@ self: {
      mkDerivation {
        pname = "aws-kinesis";
        version = "0.1.5";
-       sha256 = "0npiff5zrcs552y8lq3q6fgnwffqy11dvgs3yaygy0m99mgiaaiz";
+       sha256 = "3f2a155f4da902ffbcf243bfdd42f0d8396e9f3378608abc2845b3fc8b73f15a";
        libraryHaskellDepends = [
          aeson aws aws-general base base64-bytestring blaze-builder
          bytestring conduit conduit-extra deepseq http-conduit http-types
@@ -23368,7 +23427,7 @@ self: {
      mkDerivation {
        pname = "aws-kinesis-client";
        version = "0.4.0.2";
-       sha256 = "1vygs2qdnwjw8pygbsncc22cq9294hmlbzi2fysi3agva2qxzmwx";
+       sha256 = "9dd7dfb150fba911b57722fe452b244924cc8460cceaf5fc455c72dbb0d0cfef";
        revision = "1";
        editedCabalFile = "4bd055f19f3ced5d6f52eec169220d7c5159cfa521128a3118aedecc9c3ad2f3";
        isLibrary = true;
@@ -23400,7 +23459,7 @@ self: {
      mkDerivation {
        pname = "aws-kinesis-reshard";
        version = "0.1.0.1";
-       sha256 = "1v7i39sd6rizrrgxpqp3pnc45sry4glkb7yi0jx8qcxf2d8bklnn";
+       sha256 = "d6d2b95013ae338cba04d19f35e9233eeb4298bde3e2db5fce3f66d3741af1ec";
        isLibrary = true;
        isExecutable = true;
        libraryHaskellDepends = [
@@ -23431,7 +23490,7 @@ self: {
      mkDerivation {
        pname = "aws-lambda";
        version = "0.1.0.1";
-       sha256 = "1dy9q86yvrydw7h1l1n4ciai400w7czc26mizzfi4r369mqyan89";
+       sha256 = "0959e5714d666412ddffb11ac13e3b1c00125564c4061ae0e1cde7ed0dc2c9b7";
        libraryHaskellDepends = [
          aeson aws-general base base-unicode-symbols bytestring containers
          exceptions filepath http-client http-types lens lens-action
@@ -23453,7 +23512,7 @@ self: {
      mkDerivation {
        pname = "aws-performance-tests";
        version = "0.1.1";
-       sha256 = "1m9najkh21ww4xmddad8ksnfa3if8q955q1vf3m48f52r2dl81hw";
+       sha256 = "1c06449bc8a23844ea703be05212462e0ee5ac9ea8a9d66a279c0701a75436d5";
        isLibrary = true;
        isExecutable = true;
        libraryHaskellDepends = [
@@ -23478,7 +23537,7 @@ self: {
      mkDerivation {
        pname = "aws-route53";
        version = "0.1.2";
-       sha256 = "0qg0fzw5kb3xvldxc2sx7xgkwgspyscvs83sv3nrw91qjp6ypi18";
+       sha256 = "28c4ebcd9538249eedd87a20bd99f6573f3e5f3f5d0bd61bdd7dac59f877e061";
        libraryHaskellDepends = [
          aws base bytestring containers http-conduit http-types old-locale
          resourcet text time xml-conduit xml-hamlet
@@ -23498,7 +23557,7 @@ self: {
      mkDerivation {
        pname = "aws-sdk";
        version = "0.12.4";
-       sha256 = "0zmwfkfddiyyn264kay6m295fh23gii8axln1fjykbsdgd6yy5rb";
+       sha256 = "2b17ef4d7b4dafe9a50b967685627c43405792a8c6ab498cb0dec7d6dc74bc7e";
        libraryHaskellDepends = [
          base base64-bytestring bytestring conduit conduit-extra containers
          data-default http-conduit http-types iproute lifted-base
@@ -23525,7 +23584,7 @@ self: {
      mkDerivation {
        pname = "aws-sdk-text-converter";
        version = "0.3";
-       sha256 = "06a9sj9k1zpnzjcz8bd952fljwdn5r3vn5cg0vvc50bnidf99nfk";
+       sha256 = "d3d9945c8b7681c2f6068f15bb472eb671499d28a92df499fcf6fe3093d44919";
        libraryHaskellDepends = [
          base bytestring iproute old-locale safe strptime template-haskell
          text time
@@ -23548,7 +23607,7 @@ self: {
      mkDerivation {
        pname = "aws-sdk-xml-unordered";
        version = "0.3.1";
-       sha256 = "0f90l61npi6x59i81k2cjfklpjl5m52zj7ww04k3y5x5c7nj26nd";
+       sha256 = "cd1a21ed61a5173f26019c1ff945a985ca4ba7934ccc80622addc46b83a12039";
        libraryHaskellDepends = [
          aws-sdk-text-converter base conduit containers lifted-base mtl
          resourcet text unordered-containers xml-conduit xml-types
@@ -23571,7 +23630,7 @@ self: {
      mkDerivation {
        pname = "aws-sign4";
        version = "1.1.0.1";
-       sha256 = "1jw4dp8gg4lzski55iw5m5xihyx1cp33c334nlkd2xydrkk8rjhh";
+       sha256 = "10ca8ce6cccd77d126b5640c36c665a17b187ba985c752e2d49f92f7d06d84cb";
        libraryHaskellDepends = [
          aws base blaze-builder byteable bytestring case-insensitive
          cryptohash http-types old-locale safe time
@@ -23597,7 +23656,7 @@ self: {
      mkDerivation {
        pname = "aws-sns";
        version = "0.1";
-       sha256 = "1v1fjldn1bx65vv84zgx7np84pl4cr1wddngchkjxzci07ydrjpm";
+       sha256 = "f5cadcfc0191fd2e2764cfb6c64366845e82ae3dfd7d82f62ea6af601b952eec";
        libraryHaskellDepends = [
          aeson aws aws-general base blaze-builder bytestring conduit
          containers http-conduit http-types parsers QuickCheck resourcet
@@ -23621,7 +23680,7 @@ self: {
      mkDerivation {
        pname = "azure-acs";
        version = "0.0.1.1";
-       sha256 = "09gv4ym6nxx5854m40p06pxvxrqfhmadxlb0d72pji6hk180yg5l";
+       sha256 = "b43c0f5098d04479c56960d1de54850ee7befb35e002524941a5776baa27fb25";
        libraryHaskellDepends = [
          attoparsec base bytestring conduit conduit-extra connection
          http-conduit http-types network time
@@ -23639,7 +23698,7 @@ self: {
      mkDerivation {
        pname = "azure-service-api";
        version = "0.1.0.0";
-       sha256 = "09wb94k8f8wgcdx036x2fzixck7cbv739rrh299m7awbl4i3mfhg";
+       sha256 = "0fba3a22a18bab53531230e734ce5eec4cd6e377a29b017a638f238726498b27";
        libraryHaskellDepends = [
          base binary bytestring case-insensitive certificate
          crypto-pubkey-types http-conduit hxt hxt-xpath pretty resourcet tls
@@ -23660,7 +23719,7 @@ self: {
      mkDerivation {
        pname = "azure-servicebus";
        version = "0.1.6.0";
-       sha256 = "1ig8af14m11di9fis6s5hxmfqh7hc40c3bqyighnpi25xnv7mm13";
+       sha256 = "23d47ab6ed45c46be18b1eafc10061f040ec6a87451b1d5d8a2d844a8253e8c5";
        libraryHaskellDepends = [
          aeson async attoparsec azure-acs base bytestring case-insensitive
          conduit connection http-client http-conduit http-types network text
@@ -23681,7 +23740,7 @@ self: {
      mkDerivation {
        pname = "azurify";
        version = "0.4.0.5";
-       sha256 = "0nqkpizqiwv7wfs1bgl8q13aaqnc9wjh8gs6fyiklplnjdcpqf9g";
+       sha256 = "2f397c5993965e3aa377463f04254fcc62a546c088be15b4e367f3887fbc135b";
        isLibrary = true;
        isExecutable = true;
        libraryHaskellDepends = [
@@ -23709,8 +23768,8 @@ self: {
      }:
      mkDerivation {
        pname = "b-tree";
-       version = "0.1.1";
-       sha256 = "1c20w9rzyj2gnd18042pv41r45cv3zvd5h83igh6w2gz1z7hl821";
+       version = "0.1.2";
+       sha256 = "201ba85e9a14b13adc759734ef0cda7ec16d5efc64189eac59f206ed734745a4";
        libraryHaskellDepends = [
          base binary bytestring containers directory errors filepath lens
          mmap mtl pipes pipes-interleave transformers vector
@@ -23733,7 +23792,7 @@ self: {
      mkDerivation {
        pname = "b9";
        version = "0.5.8";
-       sha256 = "0r8gjgmy9v655kza2c6ilngr4glijizgjddq0125s11pd40hzhvi";
+       sha256 = "71c30f016937045d4400b835f97e94913e929fa5d130a1fe2cc5ece4eb930f65";
        isLibrary = true;
        isExecutable = true;
        libraryHaskellDepends = [
@@ -23759,7 +23818,7 @@ self: {
      mkDerivation {
        pname = "babylon";
        version = "0.3";
-       sha256 = "12cyn149dgd9wvnc7smqsfy15mzgyfg8l17y6qz0k4dyapp8fvhf";
+       sha256 = "0e6e87ee55be91093e36fe048a9ef3efd712bcd3b8eac3ece6a9bd9648b09e89";
        isLibrary = false;
        isExecutable = true;
        executableHaskellDepends = [
@@ -23776,7 +23835,7 @@ self: {
      mkDerivation {
        pname = "backdropper";
        version = "1.2";
-       sha256 = "1z5v0p2yfgln9sv41myr10cjq60xcaav0hfzc18bmmssl8x2yljy";
+       sha256 = "5e522f3aa25ad7ba5060df41b095621d182c1908d9d740b64e963ee7c505bbfc";
        isLibrary = true;
        isExecutable = true;
        executableHaskellDepends = [
@@ -23795,7 +23854,7 @@ self: {
      mkDerivation {
        pname = "backtracking-exceptions";
        version = "0.1.0.0";
-       sha256 = "1m4z4m4ncyswvbr12dsvl0gz5398jxy99zkh22xjrdmfgl8rx6p2";
+       sha256 = "e29a9e117daeb62cbb1070fe947c97288df21fa05b3711f2da5c7b6649259fd4";
        libraryHaskellDepends = [
          base either free kan-extensions mtl semigroupoids semigroups
          transformers
@@ -23811,7 +23870,7 @@ self: {
      mkDerivation {
        pname = "backward-state";
        version = "0.1.0.2";
-       sha256 = "1akxm0v23gnph5jxwi20wq4lk07vd2kpiqns550k499yw95vqyam";
+       sha256 = "5579bc4be23e25324129dae278a768fb804909e64044de6581d7be2136a87daa";
        libraryHaskellDepends = [ base transformers ];
        jailbreak = true;
        homepage = "https://github.com/luqui/backward-state";
@@ -23824,7 +23883,7 @@ self: {
      mkDerivation {
        pname = "bacteria";
        version = "1.1";
-       sha256 = "19y7p53b80lqfrs1b945l4pc73c54zivk8l6lffzznd7gmbc0mv5";
+       sha256 = "6557c0567da7d9ff9da386a2b9e327858dc32ea185a41574769802b446b9c7a7";
        isLibrary = false;
        isExecutable = true;
        executableHaskellDepends = [ base gd X11 ];
@@ -23838,7 +23897,7 @@ self: {
      mkDerivation {
        pname = "bag";
        version = "0.1";
-       sha256 = "18n7ggrfm39mn4rva661hkxj75gjx2p3jcm0hlzpcshxyk93iblr";
+       sha256 = "99ae38d2f41d6a763f85a03239aee8f29523fb84c118b533b1358deaf27bc7a2";
        libraryHaskellDepends = [ base ];
        description = "A simple stable bag";
        license = stdenv.lib.licenses.mit;
@@ -23855,7 +23914,7 @@ self: {
      mkDerivation {
        pname = "bake";
        version = "0.4";
-       sha256 = "1xxv78i2q9hiw30vkbcx09nabqv88g3a6k872ckm9wk8isrnw2zz";
+       sha256 = "ff0b6eb38e68f2542713074da3c64368e3a56c029dadb9c1e011262c223abbf7";
        isLibrary = true;
        isExecutable = true;
        libraryHaskellDepends = [
@@ -23884,7 +23943,7 @@ self: {
      mkDerivation {
        pname = "bamboo";
        version = "2010.2.25";
-       sha256 = "0v96ync9vkq7xyc5jmm7k7vfxpy4m1l2370m99wa8qlrpcffhrmi";
+       sha256 = "b166e81cbb9962a4784a159c2168a8c4dfeef699a7565998ef07cf9d98f5266d";
        libraryHaskellDepends = [
          base bytestring containers data-default directory filepath gravatar
          hack hack-contrib haskell98 mps mtl network old-locale old-time
@@ -23904,7 +23963,7 @@ self: {
      mkDerivation {
        pname = "bamboo-launcher";
        version = "2010.2.25";
-       sha256 = "1xp2k33jxbkf0maj3p3grv93c9vnjg6fzy6l8gg5dhil18834vdd";
+       sha256 = "ad6d32100a34c256de43d4f8efcc93762736d2ce6fdc2155056eae2ec798e2f6";
        isLibrary = false;
        isExecutable = true;
        executableHaskellDepends = [
@@ -23924,7 +23983,7 @@ self: {
      mkDerivation {
        pname = "bamboo-plugin-highlight";
        version = "2009.7.5";
-       sha256 = "0f8hpampawv0csqsb504hg97r7mimkcs9irm9i2m2b13w5fciaqc";
+       sha256 = "0cabc85ce1232c51454c35c7a4d9acb19e7cd2830494a5b166607375abba1039";
        libraryHaskellDepends = [
          bamboo base bytestring hack hack-contrib highlighting-kate hxt mps
          xhtml
@@ -23943,7 +24002,7 @@ self: {
      mkDerivation {
        pname = "bamboo-plugin-photo";
        version = "2009.7.5";
-       sha256 = "19ik80hcshmw8gpsb9gwngnwvriri10xx2v6xvrz0q25cxgwdjah";
+       sha256 = "50c9c65f674560f0f3ee668bde418839e6cdedb3fca5a5ef43bc42cd204033a6";
        libraryHaskellDepends = [
          base bytestring data-default directory filepath hack hack-contrib
          haskell98 hxt mps utf8-string xhtml
@@ -23962,7 +24021,7 @@ self: {
      mkDerivation {
        pname = "bamboo-theme-blueprint";
        version = "2010.2.25.1";
-       sha256 = "1wchvz2nm4klg11wjk3yb5yvqpa26c9lg6xc65k0dwxhy0cyd2zx";
+       sha256 = "fd8be619f0b0f3066631ac9b471333425dbc7d597e4cc9437874926ac5df90f1";
        libraryHaskellDepends = [
          bamboo base bytestring containers data-default gravatar hack
          hack-contrib hcheat mps network rss utf8-string xhtml
@@ -23983,7 +24042,7 @@ self: {
      mkDerivation {
        pname = "bamboo-theme-mini-html5";
        version = "2009.11.27";
-       sha256 = "02zh9jqq46gg3hrsfjfq2skajr4jni3cisak4nd3shl6aqapw9d6";
+       sha256 = "a6257e155686423d9a2553e9c846b49264a9a616d849a7331cef1982b14cf00b";
        libraryHaskellDepends = [
          bamboo base base64-string bytestring cgi containers data-default
          directory filepath gravatar hack hack-contrib haskell98 hcheat moe
@@ -24003,7 +24062,7 @@ self: {
      mkDerivation {
        pname = "bamse";
        version = "0.9.5";
-       sha256 = "1nykyywrqmf5nyszfg3acm0ydr9z8q78wc7bgabfmjwrnpq1dw68";
+       sha256 = "c8f016f0b599cbea967aeb308e0e463fe5e641656a3cf7b5b7c5559cb9f7d3db";
        isLibrary = true;
        isExecutable = true;
        libraryHaskellDepends = [
@@ -24020,7 +24079,7 @@ self: {
      mkDerivation {
        pname = "bamstats";
        version = "0.4";
-       sha256 = "0z8k47h492818yvgxggqw4gcb6m91pw70kpibf9s384vxcbj6r24";
+       sha256 = "44642317eb9ba0a1935bf14e70f80da99ac51ee1f8bdfeb647018944e021137d";
        isLibrary = true;
        isExecutable = true;
        executableHaskellDepends = [ base cmdargs samtools ];
@@ -24034,7 +24093,7 @@ self: {
      mkDerivation {
        pname = "bank-holidays-england";
        version = "0.1.0.3";
-       sha256 = "12k01aa0293izblgr7kszkilnw29716hddqfs9cq18h49gp6m7s5";
+       sha256 = "459f6aee4b04a28059d20eb7064d3849704be3fc7a9efce8fa712401940a608a";
        libraryHaskellDepends = [ base containers time ];
        testHaskellDepends = [ base containers hspec QuickCheck time ];
        homepage = "https://bitbucket.org/davecturner/bank-holidays-england";
@@ -24049,7 +24108,7 @@ self: {
      mkDerivation {
        pname = "banwords";
        version = "0.2.0.1";
-       sha256 = "13mnz060yi1j6gsxknn1ara34s4ymdswysypj8d94k1741jv89yn";
+       sha256 = "d627b46520274c921a92d76bcf75ab9e68325456c1dad9f53332440f0cf8b68e";
        libraryHaskellDepends = [
          attoparsec base bytestring data-default text vector
        ];
@@ -24067,7 +24126,7 @@ self: {
      mkDerivation {
        pname = "barchart";
        version = "0.1.1.1";
-       sha256 = "160ja5sdk0zdqc0ncsyldp4rmhc2g4zfa6xc7vbzf8gpqrcmzvgy";
+       sha256 = "feed5f59c6f721f7d73eac1be53e7982c19ac96dd46b6601c3ed83d974511298";
        isLibrary = true;
        isExecutable = true;
        libraryHaskellDepends = [ base csv diagrams filepath ];
@@ -24083,7 +24142,7 @@ self: {
      mkDerivation {
        pname = "barcodes-code128";
        version = "0.1.0";
-       sha256 = "14blxjhapn9g7cp7374f5s2nln7wgyb7a6z50gp04lnqf1aw6kmg";
+       sha256 = "af4ec35570d85202ee03e51b75967ffc586a852e8e9c712e3b2fd9aba0ec7491";
        libraryHaskellDepends = [ base bytestring HPDF ];
        jailbreak = true;
        description = "Generate Code 128 barcodes as PDFs";
@@ -24096,7 +24155,7 @@ self: {
      mkDerivation {
        pname = "barecheck";
        version = "0.2.0.8";
-       sha256 = "0hja4lrgv1faqaq41wzf1r88aw4pin8jh60k9n65yd0sxi1103a7";
+       sha256 = "470d1042ec1a345f8c4d131828918d977085500eeef340b0c2ca85fd32254a42";
        libraryHaskellDepends = [ base containers QuickCheck text time ];
        jailbreak = true;
        homepage = "http://github.com/massysett/barecheck";
@@ -24112,7 +24171,7 @@ self: {
      mkDerivation {
        pname = "barley";
        version = "0.3.0.2";
-       sha256 = "0igz39bxlw4p0fna1wf6g791pk7r1m7hfyib5rgmsdahzkkp7v2h";
+       sha256 = "50ec73e7fc50355d5f2e2b7a074f0df9cc1bd279c6f1a0ac039770da571aff45";
        isLibrary = false;
        isExecutable = true;
        executableHaskellDepends = [
@@ -24130,7 +24189,7 @@ self: {
      mkDerivation {
        pname = "barrie";
        version = "0.4.1";
-       sha256 = "10iraid6v333374mx9vinvaw6r1903ipa92xjxhl8qh4w7xmr9yv";
+       sha256 = "dba75cfbe104624461975d2475e3002964c3d5b671a75ec919638c6d5a543982";
        libraryHaskellDepends = [ base containers filepath glib gtk ];
        homepage = "http://thewhitelion.org/haskell/barrie";
        description = "Declarative Gtk GUI library";
@@ -24145,7 +24204,7 @@ self: {
      mkDerivation {
        pname = "barrier";
        version = "0.1.0";
-       sha256 = "1flhgx323dnqhh6gxmfv4m8qj2yysckrr9pzw0g7jisvk6pmcz4z";
+       sha256 = "9f7c56af995b47791ee0ffa69c27d3de0b895125dbd5fe0c84d8b621467f90ba";
        revision = "1";
        editedCabalFile = "2f75bd296d54424250895888d24eaec14bbdb35b355306306b6f8632052473bc";
        isLibrary = true;
@@ -24167,7 +24226,7 @@ self: {
      mkDerivation {
        pname = "barrier-monad";
        version = "0.1.0.1";
-       sha256 = "014nc21wnrklsvy5z7w4v9p9psn6bl210l7v97gj42cv6a8jk5nm";
+       sha256 = "d5962991329b0922df49fb5010045dc6ea9b6eda849f5ffcd67466cb83609604";
        libraryHaskellDepends = [ base comonad mtl transformers ];
        jailbreak = true;
        description = "Implementation of barrier monad, can use custom front/back type";
@@ -24180,7 +24239,7 @@ self: {
      mkDerivation {
        pname = "base";
        version = "4.8.1.0";
-       sha256 = "0rwya445hvnnzj3x5gsrmr72kr3yspd6w9mypxkrxxg19zfazjaj";
+       sha256 = "52c9afdc4fe1f59e67bfbe266edad57ee4294eae59bfd287fcd66e5808519e67";
        libraryHaskellDepends = [ ghc-prim rts ];
        description = "Basic libraries";
        license = stdenv.lib.licenses.bsd3;
@@ -24191,7 +24250,7 @@ self: {
      mkDerivation {
        pname = "base-compat";
        version = "0.8.2";
-       sha256 = "02m93hzgxg4bcnp7xcc2fdh2hrsc2h6fwl8hix5nx9k864kwf41q";
+       sha256 = "3810c7273168a66e4b8f1051ee0c144c6728607382b17eae658bbcfe3e1ca90a";
        libraryHaskellDepends = [ base unix ];
        testHaskellDepends = [ base hspec QuickCheck ];
        description = "A compatibility layer for base";
@@ -24203,7 +24262,7 @@ self: {
      mkDerivation {
        pname = "base-generics";
        version = "0.1.0.1";
-       sha256 = "19k6kl66p71pza23b1n5njmj97k1pdlcm6brl1danfaxlflsmcms";
+       sha256 = "bab2aaa9a35d39ab5aa07999ca68bb619e24abb4c5863584fa379c6b0c9d66a6";
        libraryHaskellDepends = [ base ];
        jailbreak = true;
        homepage = "https://github.com/HaskellZhangSong/base-generics";
@@ -24216,7 +24275,7 @@ self: {
      mkDerivation {
        pname = "base-io-access";
        version = "0.4.0.0";
-       sha256 = "0d0i8ndh2j42qf8ns9wprkjiffy3hyybgvs9nbf67yd50di6p263";
+       sha256 = "c3886b6203a5f963dcb249efb7bc87c33b17e5cc97276d91c38248019b451134";
        libraryHaskellDepends = [ base ];
        jailbreak = true;
        homepage = "https://github.com/bheklilr/base-io-access";
@@ -24229,7 +24288,7 @@ self: {
      mkDerivation {
        pname = "base-noprelude";
        version = "4.8.0.0";
-       sha256 = "0kxpkahlwvmy86g94rawhv6x3kl761xf4s78jv1cjzglsb28q0zl";
+       sha256 = "f4038cc4d2f47dc9c296e868e27a3087ced1cd865c65929e41be6e4ea19ab74f";
        libraryHaskellDepends = [ base ];
        jailbreak = true;
        homepage = "https://github.com/hvr/base-noprelude";
@@ -24241,8 +24300,8 @@ self: {
     ({ mkDerivation, base, ghc-prim, hspec, QuickCheck }:
      mkDerivation {
        pname = "base-orphans";
-       version = "0.4.2";
-       sha256 = "1mfmhvb7zvyi3m5660755ph7xk4fdvhki6ssfd3i2ghzas8g1v7a";
+       version = "0.4.3";
+       sha256 = "405b6499679805b5361277e4d101240ab7848ffc009621fc29bbae2519ebfc0d";
        libraryHaskellDepends = [ base ghc-prim ];
        testHaskellDepends = [ base hspec QuickCheck ];
        homepage = "https://github.com/haskell-compat/base-orphans#readme";
@@ -24255,7 +24314,7 @@ self: {
      mkDerivation {
        pname = "base-prelude";
        version = "0.1.19";
-       sha256 = "00mk7zpm3yb804h0gngvpjxhb2a6nds8qb8mwpn80s20x72083wb";
+       sha256 = "8b0f04c4e9406880ece5152d8c74b3468905bbbcfbd907200168f951ef3fb302";
        libraryHaskellDepends = [ base ];
        homepage = "https://github.com/nikita-volkov/base-prelude";
        description = "The most complete prelude formed from only the \"base\" package";
@@ -24267,7 +24326,7 @@ self: {
      mkDerivation {
        pname = "base-unicode-symbols";
        version = "0.2.2.4";
-       sha256 = "1afc5pchd3vw33bmjbjygkd0l5zh7glbsx4bfyxfscpc1x1l3y52";
+       sha256 = "a2f841430fec32edba778b74bde83bf0170ada7c5e2e59d7187c8f06d92dcca9";
        libraryHaskellDepends = [ base ];
        homepage = "http://haskell.org/haskellwiki/Unicode-symbols";
        description = "Unicode alternatives for common functions and operators";
@@ -24279,7 +24338,7 @@ self: {
      mkDerivation {
        pname = "base16-bytestring";
        version = "0.1.1.6";
-       sha256 = "0jf40m3yijqw6wd1rwwvviww46fasphaay9m9rgqyhf5aahnbzjs";
+       sha256 = "5afe65a152c5418f5f4e3579a5e0d5ca19c279dc9bf31c1a371ccbe84705c449";
        libraryHaskellDepends = [ base bytestring ghc-prim ];
        homepage = "http://github.com/bos/base16-bytestring";
        description = "Fast base16 (hex) encoding and decoding for ByteStrings";
@@ -24293,7 +24352,7 @@ self: {
      mkDerivation {
        pname = "base32-bytestring";
        version = "0.2.1.0";
-       sha256 = "0z0q3fw3jzprgxmq9b2iz98kf4hwl3nydrzlaiwk81aplisfdgkl";
+       sha256 = "74bee674a45705347954f4e7e6eda01c123751fa51ac846b7ff97e39b81b187c";
        libraryHaskellDepends = [ base bits-extras bytestring cpu ];
        testHaskellDepends = [ base bytestring hspec QuickCheck ];
        homepage = "https://github.com/pxqr/base32-bytestring";
@@ -24306,7 +24365,7 @@ self: {
      mkDerivation {
        pname = "base32string";
        version = "0.9.1";
-       sha256 = "0cpa6bvam4zd2l2hb3sdngj0dx482c9rkz4jj87n6pxsmq9id4wy";
+       sha256 = "9e931613aeba5f630f9292fc99131388f406e4b34d8f050515ed93aaf632ea32";
        libraryHaskellDepends = [ aeson base binary bytestring text ];
        testHaskellDepends = [ base binary bytestring hspec text ];
        homepage = "http://www.leonmergen.com/opensource.html";
@@ -24321,7 +24380,7 @@ self: {
      mkDerivation {
        pname = "base58-bytestring";
        version = "0.1.0";
-       sha256 = "1ls05nzswjr6aw0wwk3q7cpv1hf0lw7vk16a5khm6l21yfcgbny2";
+       sha256 = "c2dbf598f3415053e12cca84b90fa7c0c1b02f3b784cce0157264baebf2d40d3";
        libraryHaskellDepends = [ base bytestring ];
        testHaskellDepends = [
          base bytestring quickcheck-assertions quickcheck-instances tasty
@@ -24339,7 +24398,7 @@ self: {
      mkDerivation {
        pname = "base58address";
        version = "0.4";
-       sha256 = "0z15x9wx962ywkmh5lzfg4kq2jjmyzncbpayx2lkjnpdra4xgz7a";
+       sha256 = "eafcd789caed5a39a9e85eddc5ecf7554a812779eed302ebe45e98d479ea257c";
        libraryHaskellDepends = [
          base binary bytestring containers cryptohash
        ];
@@ -24357,7 +24416,7 @@ self: {
      mkDerivation {
        pname = "base58string";
        version = "0.10.0";
-       sha256 = "1260x4bkrizvnmylm237gpi92wazh31md9nf982sac3fsxyn0wiv";
+       sha256 = "3b72607dd76e30a5054acea656c3805f7191e27d67884a7db5fbc73c17e9c088";
        libraryHaskellDepends = [ aeson base binary bytestring text ];
        testHaskellDepends = [ base binary bytestring hspec text ];
        homepage = "http://www.leonmergen.com/opensource.html";
@@ -24372,7 +24431,7 @@ self: {
      mkDerivation {
        pname = "base64-bytestring";
        version = "1.0.0.1";
-       sha256 = "0l1v4ddjdsgi9nqzyzcxxj76rwar3lzx8gmwf2r54bqan3san9db";
+       sha256 = "ab25abf4b00a2f52b270bc3ed43f1d59f16c8eec9d7dffb14df1e9265b233b50";
        libraryHaskellDepends = [ base bytestring ];
        testHaskellDepends = [
          base bytestring containers HUnit QuickCheck test-framework
@@ -24390,7 +24449,7 @@ self: {
      mkDerivation {
        pname = "base64-conduit";
        version = "1.0.0.1";
-       sha256 = "07zhvn3fy60q04a5g5mzhkl17rap9jlh00vb4f6565bjha2k16g9";
+       sha256 = "e9993085827215538c236b0300a94c57e513e884bf965714011818ef86ddf01f";
        libraryHaskellDepends = [
          base base64-bytestring bytestring conduit
        ];
@@ -24409,7 +24468,7 @@ self: {
      mkDerivation {
        pname = "base64-string";
        version = "0.2";
-       sha256 = "0pkhrimabacsjalzq0y3a197fqfbspsbv8xszzg4vbb1fb59dj1y";
+       sha256 = "3ec896ca7261ad4ddeffbaa3bdf4d5cb61775250c303fca9929aa9a56acc705e";
        libraryHaskellDepends = [ base ];
        homepage = "http://urchin.earth.li/~ian/cabal/base64-string/";
        description = "Base64 implementation for String's";
@@ -24423,7 +24482,7 @@ self: {
      mkDerivation {
        pname = "base91";
        version = "2.1.0";
-       sha256 = "1lz9s7w5nlp4naj9jzwb73im0vbs5nlrddg18irjz64sgq3qd2nn";
+       sha256 = "d68a86077e9a982f7344e1b596a92d7a6d50e3388b7f99a4b2e4525bf8d1e9d3";
        isLibrary = true;
        isExecutable = true;
        libraryHaskellDepends = [ base mono-traversable ];
@@ -24443,7 +24502,7 @@ self: {
      mkDerivation {
        pname = "basex-client";
        version = "0.1.0.0";
-       sha256 = "189bmv479fmljy9w7nhc5mb7546iz8vahrmxffvgny51ywklk58n";
+       sha256 = "16954927f7a178fbb673bd66a836fad19072562d0cdac39397b4ba74c8ae2ba1";
        libraryHaskellDepends = [ base network pureMD5 utf8-string ];
        description = "A BaseX client for Haskell";
        license = stdenv.lib.licenses.mit;
@@ -24456,7 +24515,7 @@ self: {
      mkDerivation {
        pname = "bash";
        version = "0.1.8";
-       sha256 = "1wv7haxb4vvnh9i7y17m1d7qbpl92qjrnn022g6hyxbxzmpgsw60";
+       sha256 = "c070fd6efd7d750fcd1302589b251689de854f0bf5047f6282766fb2ba8267f3";
        libraryHaskellDepends = [
          base binary bytestring containers hxt-regex-xmlschema mtl SHA
          shell-escape
@@ -24471,7 +24530,7 @@ self: {
      mkDerivation {
        pname = "basic-lens";
        version = "0.0.0";
-       sha256 = "0qgd2066vgsrzglcmw1jd7lcrpxvrzch7bnyyfxzddwxj148mvnj";
+       sha256 = "d2ee8a48909db7f6bbf3deae03d9cfbbdfcce86932f0cae8fb59bf6d0c10ed61";
        revision = "1";
        editedCabalFile = "dcb1e49555431b94fedf161e3a2169213eea59167a34eb20b91be22baac9e170";
        libraryHaskellDepends = [ base ];
@@ -24487,7 +24546,7 @@ self: {
      mkDerivation {
        pname = "basic-prelude";
        version = "0.5.0";
-       sha256 = "1l8hc99sxm27gd93zq6v0l0x2rzl6fd9zp7snh14m4yriqrn5xfi";
+       sha256 = "d1f562338ed9934a02b4fadc9f9a33f467d10105dbe03f527b47d4ae536210d1";
        revision = "1";
        editedCabalFile = "2ddf5a9d3413a8e7c877c488f63451357fcde4d187f7c560f5281a0c4856fd0b";
        libraryHaskellDepends = [
@@ -24504,7 +24563,7 @@ self: {
      mkDerivation {
        pname = "basic-sop";
        version = "0.1.0.5";
-       sha256 = "0zmjd11jckaknkifyif4zq5833cs2kxpm98j43viqc09w63brcx3";
+       sha256 = "a3b3bc86e109301cf72012a57afb149a8d810afec445efe2b4534d264368b27e";
        libraryHaskellDepends = [
          base deepseq generics-sop QuickCheck text
        ];
@@ -24517,7 +24576,7 @@ self: {
      mkDerivation {
        pname = "baskell";
        version = "0.1.1";
-       sha256 = "1vb74crz57i4qmjl8k3gxr2abz9rmpw7yl5sm1pggnlfy9wcm15l";
+       sha256 = "b484ca78f28edaf76ea8ba507ff8ad39fda544ee6f4c4465c5249ef2332367ed";
        isLibrary = false;
        isExecutable = true;
        executableHaskellDepends = [
@@ -24534,7 +24593,7 @@ self: {
      mkDerivation {
        pname = "battlenet";
        version = "0.2.0.0";
-       sha256 = "1nzli8n6lpa9jahwp3awvpafzfkx4j02bwanilh30sxfyp0mlxxa";
+       sha256 = "aa775ac1f5ae6b30208d56f12580247dbaefd4dd5c8dcba192495d6a2c8af4db";
        libraryHaskellDepends = [
          aeson base containers http-conduit text
        ];
@@ -24549,7 +24608,7 @@ self: {
      mkDerivation {
        pname = "battlenet-yesod";
        version = "0.2.0.0";
-       sha256 = "056z84rha1nwjij3am16vfp4nwgp7xzqrhkvrx9s8p1vivyb80yz";
+       sha256 = "df03b4fc8e3b5ca453cf7bc28c7f3ff7714baedb2654356494dc06053341df14";
        libraryHaskellDepends = [
          base battlenet http-conduit text yesod-core
        ];
@@ -24571,7 +24630,7 @@ self: {
      mkDerivation {
        pname = "battleships";
        version = "1.0.0";
-       sha256 = "1rg96qikd687wndwj0pgvzg2ln4vh7x304cnyiisci2ka9763cld";
+       sha256 = "8db2614e525344a663f4961130fa819b582adedfef02c99be50799362336e9e5";
        isLibrary = true;
        isExecutable = true;
        libraryHaskellDepends = [
@@ -24603,7 +24662,7 @@ self: {
      mkDerivation {
        pname = "bayes-stack";
        version = "0.2.0.1";
-       sha256 = "1nz4lnnxdfgacnv6mjxsgq543zxmim4rxvxbpsfx8yypjp6lsx5l";
+       sha256 = "b4744dcd95d77bd49dbeabef9e498db5ff410a7ebacb6ab665eab9d6ada5e4db";
        libraryHaskellDepends = [
          base cereal containers deepseq digamma enummapset gamma ghc-prim
          logfloat mtl mwc-random pretty random-fu random-source rvar
@@ -24620,7 +24679,7 @@ self: {
      mkDerivation {
        pname = "bbdb";
        version = "0.4";
-       sha256 = "18f07dg0f7z7b8qwmyrcl1c48mgmprnj97va33dahvm0p0iw2039";
+       sha256 = "6900c123b8a06ea8da186a9f246dbef5554458a02cfbca315ae71f075e3bc0a1";
        libraryHaskellDepends = [ base mtl parsec ];
        homepage = "http://www.nadineloveshenry.com/haskell/database-bbdb.html";
        description = "Ability to read, write, and examine BBDB files";
@@ -24632,7 +24691,7 @@ self: {
      mkDerivation {
        pname = "bcrypt";
        version = "0.0.6";
-       sha256 = "032la7v7kp0k26s3lj006hgc7a99ylqpp5qi27jxnac10yjl5bi5";
+       sha256 = "25ae42a5078129dbe51111977b31f529a9c31e3400483ab41113dc79f651540c";
        libraryHaskellDepends = [ base bytestring entropy ];
        description = "Haskell bindings to the bcrypt password hash";
        license = stdenv.lib.licenses.bsd3;
@@ -24645,7 +24704,7 @@ self: {
      mkDerivation {
        pname = "bdd";
        version = "0.2.0.0";
-       sha256 = "17hwqksqkrriqrm7sx70jzmi3r8184p485y9i7cqbakdjapb5a4q";
+       sha256 = "98a8b2ae926daa85d989c917442e4101e511eb97e0747d6ac631e789f5c41c9e";
        libraryHaskellDepends = [ base HUnit mtl transformers ];
        testHaskellDepends = [
          base directory HUnit mtl process test-framework
@@ -24661,7 +24720,7 @@ self: {
      mkDerivation {
        pname = "bdelta";
        version = "0.1.1.1";
-       sha256 = "17zapldywid4xq0a6qdxh6hnk5igjjgplfydnr800xdpicicbrww";
+       sha256 = "9ce7c5228bb7750050b6cd3b7a9f942f9669a181bd61a300eea445ee1bbdea9f";
        libraryHaskellDepends = [ base bytestring ];
        homepage = "http://github.com/joeyadams/haskell-bytestring-delta";
        description = "Simple, fast binary diff/patch";
@@ -24673,7 +24732,7 @@ self: {
      mkDerivation {
        pname = "bdo";
        version = "1.0.1";
-       sha256 = "1mwc7l1n2gnw8yx5zphxlkgi6bkcw56qwifpy34wpa55x2lf6n82";
+       sha256 = "0259e3a8e8a5a8cbc9f0d7458e4de16c2e13dfa41dde5fba47dc3e61033d8cd7";
        isLibrary = true;
        isExecutable = true;
        libraryHaskellDepends = [ aeson base network text url ];
@@ -24690,7 +24749,7 @@ self: {
      mkDerivation {
        pname = "beamable";
        version = "0.1.1.1";
-       sha256 = "068d70ylk5b6jlg6j1c1nayb4a3mmf7r92blcgmdbjrz3ipqwg27";
+       sha256 = "473c8e6f1c3fcbd5ea637489948fab7528b2bcb28105691e956695493d380d19";
        libraryHaskellDepends = [
          base blaze-builder bytestring ghc-prim integer-gmp murmur-hash
        ];
@@ -24709,7 +24768,7 @@ self: {
      mkDerivation {
        pname = "beautifHOL";
        version = "0.11";
-       sha256 = "15k41z1p8h0b677wba4mqkfszwggkrfcp3n5hbdvdjfiqyx2hbzi";
+       sha256 = "f12f28bac7d1c9b6db82c58ecb5c9eeff1afddc495a8c5cf310b4074c30f6496";
        isLibrary = false;
        isExecutable = true;
        executableHaskellDepends = [ array base haskell98 mtl ];
@@ -24726,7 +24785,7 @@ self: {
      mkDerivation {
        pname = "bed-and-breakfast";
        version = "0.4.3";
-       sha256 = "0183770vkb5r9srxqr3fa4s601g10bx07b05hjr3b3nvc0ab9f6z";
+       sha256 = "dfb8b41460db8e35b28405ac03fa02e1056034516e64dcb34eb9acb9c1390305";
        revision = "1";
        editedCabalFile = "3efbed0b49112bb9addddcd87fdb8ffe58f14497c16a2aba9deb39e10dae0d4f";
        libraryHaskellDepends = [
@@ -24749,7 +24808,7 @@ self: {
      mkDerivation {
        pname = "bein";
        version = "0.3.3";
-       sha256 = "1sq6z2a9bddqh0kys10g495bfj7pcyibsvhfxfl279z53va7d6ch";
+       sha256 = "909976d41ee5a723a8eb0e6ebda267f748b74a220f04ed2780b8b59594f806eb";
        isLibrary = false;
        isExecutable = true;
        executableHaskellDepends = [
@@ -24768,7 +24827,7 @@ self: {
      mkDerivation {
        pname = "benchmark-function";
        version = "0.1.0.0";
-       sha256 = "1cdbaf001m79xbpfdf3gg2z8jgyf25xqwrkg6y7da2mvk3127c5b";
+       sha256 = "abb023c298bb0ad58e376f668e7b11ce3f89be786fb8e6eeeae9d4008053abb1";
        libraryHaskellDepends = [ base process random time ];
        homepage = "xy30.com";
        description = "Test the time it takes to run a haskell function";
@@ -24780,7 +24839,7 @@ self: {
      mkDerivation {
        pname = "benchpress";
        version = "0.2.2.6";
-       sha256 = "19ygaf2g4yqkfbc6bw6fmf9jsymbj1iallzvl0zw3vjx860rchfg";
+       sha256 = "cf419681415deec13fa0fb53aa6290ab7a2d93abcef065d872137bf28453cfa7";
        libraryHaskellDepends = [ base mtl time ];
        jailbreak = true;
        homepage = "http://github.com/tibbe/benchpress";
@@ -24793,7 +24852,7 @@ self: {
      mkDerivation {
        pname = "bencode";
        version = "0.6.0.0";
-       sha256 = "12pnh598k30ggs54f0pic19j7ji8f4xn7fydkdnlig79rvzgv3iv";
+       sha256 = "3b8efdfecee9bc486d9bcdbb633b7128ca235360f102478a7e0f8c895281f68a";
        libraryHaskellDepends = [
          base binary bytestring containers parsec
        ];
@@ -24808,7 +24867,7 @@ self: {
      mkDerivation {
        pname = "bencoding";
        version = "0.4.3.0";
-       sha256 = "0f6d3g88y7i4s5wa53771n0fbkbs4na8vpy51wk21b563smdcpcc";
+       sha256 = "8c5dd6aa1ea6ac20260fc5df8d94257acde5800de78ca278d1241e8fd01bcd38";
        libraryHaskellDepends = [
          attoparsec base bytestring deepseq ghc-prim mtl pretty text
        ];
@@ -24826,7 +24885,7 @@ self: {
      mkDerivation {
        pname = "berkeleydb";
        version = "2008.10.31";
-       sha256 = "1qqzxi011xmb4b09r1j5x1b7slgrazh19csfilk4a9f91zvq6l3p";
+       sha256 = "775083f70fc92545268d4eb314e057f9517d56e845869cc022abf61040ec1fe3";
        libraryHaskellDepends = [ base binary bytestring ];
        librarySystemDepends = [ db ];
        description = "Pretty BerkeleyDB v4 binding";
@@ -24843,7 +24902,7 @@ self: {
      mkDerivation {
        pname = "berp";
        version = "0.0.2";
-       sha256 = "066m1nyfwi1nivjmcnykjdypqzkm2zqfzb07zf6f9hiz9m4g6x09";
+       sha256 = "0974f3484d3fc2e48cfb07aceff017757e7c7d93d35b56e58e3644eebc0dd518";
        isLibrary = true;
        isExecutable = true;
        libraryHaskellDepends = [
@@ -24871,7 +24930,7 @@ self: {
      mkDerivation {
        pname = "bert";
        version = "1.2.2.4";
-       sha256 = "1vcbylvci91rqq5dxsa2gxc709klr0xkcflpdhcng69s6pihgsg4";
+       sha256 = "e4e907e3353a9967196c973a363bc8742670587f42e9de0ac639a4c836f58bed";
        libraryHaskellDepends = [
          base binary binary-conduit bytestring conduit conduit-extra
          containers mtl network parsec time unix void
@@ -24890,7 +24949,7 @@ self: {
      mkDerivation {
        pname = "besout";
        version = "0.2.0.1";
-       sha256 = "0bv68nn6ijf1wv57kwp4yj6s75g960pds0n9wihxwkr4hh5azls1";
+       sha256 = "41d3af0a84244fde61e4c902dd2e30e995a38df4e4f279cae6c1c968ac45662f";
        libraryHaskellDepends = [ base ];
        jailbreak = true;
        description = "Extended GCD of polynomials over F_p[x]";
@@ -24907,7 +24966,7 @@ self: {
      mkDerivation {
        pname = "bet";
        version = "0.1.2.3";
-       sha256 = "0gy12m81bc6vgzq4m0v134jbq5lw1210dxsq4s28c0www0kxj658";
+       sha256 = "a818d927e09c0386842658f70682089c16bc241961834af07fdbb0155015c13f";
        isLibrary = true;
        isExecutable = true;
        libraryHaskellDepends = [
@@ -24931,7 +24990,7 @@ self: {
      mkDerivation {
        pname = "betacode";
        version = "0.1.0.0";
-       sha256 = "0ry42sp40234c83iw7di37j3jfjfbszxcv4mzgqc54b1693mjq7b";
+       sha256 = "eb605947326191c2f0fb956cd6bf5e4e3a39e419b11d1e0762640840ae16c467";
        libraryHaskellDepends = [
          attoparsec base errors hashable text text-icu
        ];
@@ -24946,7 +25005,7 @@ self: {
      mkDerivation {
        pname = "between";
        version = "0.10.0.0";
-       sha256 = "10bj4v2451c9dri3r9c825xnr4lb8jhihr05nhc6m8fdvqnyqvsi";
+       sha256 = "516fec2ddecda16a18b4056418a1448b926c7b1188a53c626e898542c4267281";
        libraryHaskellDepends = [ base ];
        homepage = "https://github.com/trskop/between";
        description = "Function combinator \"between\" and derived combinators";
@@ -24958,7 +25017,7 @@ self: {
      mkDerivation {
        pname = "bf-cata";
        version = "1.1";
-       sha256 = "0f8pyd2j24x574xs73zhadsd058ib217vd12snkqzg6vg9l7vgzw";
+       sha256 = "fcbf7d687adbbc8fa7d522b47d82581115d07453f08fa33b39a5132145f31739";
        libraryHaskellDepends = [ base ];
        homepage = "http://www.cs.uu.nl/wiki/HUT/WebHome";
        license = "LGPL";
@@ -24971,7 +25030,7 @@ self: {
      mkDerivation {
        pname = "bff";
        version = "0.3.1.2";
-       sha256 = "1i5y7pki3hyhq2vyshzi40n7yx354p7wiflfig8qxc4h31nbwi2x";
+       sha256 = "5d44be6c1890b08ed18b8ebac8cf2565747f2c20f143edb7c0d0c311e73dbec4";
        isLibrary = true;
        isExecutable = true;
        libraryHaskellDepends = [
@@ -24989,7 +25048,7 @@ self: {
      mkDerivation {
        pname = "bff-mono";
        version = "0.2.3";
-       sha256 = "1qswfjrij01g7g85iiyxpvk1k5hgnf6ll7jcf6b33k6dawi3a4qr";
+       sha256 = "1913352257cdcc3196714c1e4a8db30f9619e6beddc758d03b2f0019b3745ce3";
        libraryHaskellDepends = [ base containers mtl ];
        homepage = "https://bitbucket.org/kztk/bff-mono/";
        description = "\"Bidirectionalization for Free\" for Monomorphic Transformations";
@@ -25001,7 +25060,7 @@ self: {
      mkDerivation {
        pname = "bgmax";
        version = "0.1.0.1";
-       sha256 = "0wg2dh3i50c4f1bc0csi3ppbz28scjfhcr0hqfd0cpfiaf79fs5s";
+       sha256 = "ba68978e53d15d069ac31064069d641a89bfee1d5133c05670848112076ce271";
        libraryHaskellDepends = [ attoparsec base bytestring time ];
        jailbreak = true;
        homepage = "http://github.com/jonpetterbergman/bgmax";
@@ -25016,7 +25075,7 @@ self: {
      mkDerivation {
        pname = "bgzf";
        version = "0.1.0.0";
-       sha256 = "1lmwb65ads6ip5v0h8z03nyzxr9556p13j1y34lhgsyk2lxwdkrv";
+       sha256 = "3bcfc63b15d3eb0729193ec811ae2925e5febd1de0230876b9d1e8a68a59bcd2";
        libraryHaskellDepends = [
          base bytestring mtl parallel pipes streaming-commons
        ];
@@ -25030,7 +25089,7 @@ self: {
      mkDerivation {
        pname = "bibtex";
        version = "0.1.0.4";
-       sha256 = "0y6jf52361d225a1jynq7ysnwihid3qivsjqv2hbf0f8sayi8ic0";
+       sha256 = "804514bdd2c801b7a0d858ea1df16811466eb53fd87a195411a205334471d278";
        isLibrary = true;
        isExecutable = true;
        libraryHaskellDepends = [ base latex parsec utility-ht ];
@@ -25046,7 +25105,7 @@ self: {
      mkDerivation {
        pname = "bidirectionalization-combined";
        version = "0.1.0.1";
-       sha256 = "0bclazwhg3ra7zv19xfx5rw2z3p8h8scw5r4m281524qzrkm9j6m";
+       sha256 = "d5c85467fe98881290a82417ce3482e88e2f782eddf514f63f2a8f07f957942d";
        isLibrary = false;
        isExecutable = true;
        executableHaskellDepends = [
@@ -25064,7 +25123,7 @@ self: {
      mkDerivation {
        pname = "bidispec";
        version = "0.1.3";
-       sha256 = "0y9hskhp1vcl92wrh3l7b1g6i7y9v4b06pl2qa9hhp9ladnvw7g4";
+       sha256 = "e41dbe6d53345d0893c2825e0316d9c99f685e58870e98b94894ed70e1d43079";
        libraryHaskellDepends = [ base bytestring mtl ];
        description = "Specification of generators and parsers";
        license = "LGPL";
@@ -25076,7 +25135,7 @@ self: {
      mkDerivation {
        pname = "bidispec-extras";
        version = "0.1";
-       sha256 = "0insqi63q6gvz39l0k584w583cw9m85vdx5dhpyx9qbb5zxyb0rm";
+       sha256 = "3583e5fb2f6be1d4fd85adf4b60baa89b3810a27a84c40d3f8fb193c4cc4da46";
        libraryHaskellDepends = [ base bytestring dataenc mtl ];
        jailbreak = true;
        description = "Extra helper functions for bidirectional specifications";
@@ -25088,7 +25147,7 @@ self: {
      mkDerivation {
        pname = "bifunctors";
        version = "5";
-       sha256 = "13990xdgx0n23qgi18ghhmsywj5zkr0a5bim0g8a4nzi0cx95ps1";
+       sha256 = "41df923a03f15ba2d00335aea2409ebf48ee7585f0a1101f1ec282fe5a07298d";
        libraryHaskellDepends = [ base semigroups tagged ];
        homepage = "http://github.com/ekmett/bifunctors/";
        description = "Bifunctors";
@@ -25102,7 +25161,7 @@ self: {
      mkDerivation {
        pname = "billboard-parser";
        version = "1.0.0.1";
-       sha256 = "1jhiq5w4z7axlqqm6pyl1d3g1vh7ykyy2z69d9ma8qzgm6v72l05";
+       sha256 = "055071b6a9ef63a46a6ac97ce1fdf407eef0460bd45f5331a65d9d4f78c111ca";
        isLibrary = true;
        isExecutable = true;
        libraryHaskellDepends = [
@@ -25128,7 +25187,7 @@ self: {
      mkDerivation {
        pname = "billeksah-forms";
        version = "1.0.0";
-       sha256 = "094sq2kn0xfvy146i7r89vf1by90nqaj4ki1fk3i2rw9glrv25ms";
+       sha256 = "ba16b1337d896711c774214e2215b620f915dc4e289f6848f0db7560a7c09a24";
        libraryHaskellDepends = [
          base billeksah-pane billeksah-services Cabal containers directory
          filepath glib gtk mtl parsec pretty transformers
@@ -25147,7 +25206,7 @@ self: {
      mkDerivation {
        pname = "billeksah-main";
        version = "1.0.0";
-       sha256 = "1dyg6qfvhzxh2d90gvb8j7djqa04c3aci7rfk3s1wdqz5rkxmnlx";
+       sha256 = "9ddada672e1f371ef4982e9fc8d46004282cdb9168ed075213b07fb81d36cfb7";
        isLibrary = false;
        isExecutable = true;
        executableHaskellDepends = [
@@ -25170,7 +25229,7 @@ self: {
      mkDerivation {
        pname = "billeksah-main-static";
        version = "1.0.0";
-       sha256 = "1g4zldnza6s2xvkqar4rgqirs4p8j2j4ssacg9x0zzc4njzklj7y";
+       sha256 = "fe483abfb484fd0f7a7a4c694da490e8129d237e996485e7ee421bf56da39fbc";
        isLibrary = false;
        isExecutable = true;
        executableHaskellDepends = [
@@ -25193,7 +25252,7 @@ self: {
      mkDerivation {
        pname = "billeksah-pane";
        version = "1.0.0";
-       sha256 = "1ckzjbdfi3y09qvq951xki3h7q3sah41j29mgpqk45rayzqmiavg";
+       sha256 = "6fab58f1f72a1732f17d35091908547ae003479c3d9484374ec08fe8da927fb2";
        libraryHaskellDepends = [
          base billeksah-services containers directory filepath glib gtk mtl
          parsec pretty time transformers
@@ -25212,7 +25271,7 @@ self: {
      mkDerivation {
        pname = "billeksah-services";
        version = "1.0.0";
-       sha256 = "00bsbrsnclwnayqzs24c5fdz9r6ankbhnnkbkzyd1fxsl7lrziwn";
+       sha256 = "96c79fe9a1babbd0fc9f6b5a0bd7b4cae4f49b2b8c08fdb157965366755e7a01";
        libraryHaskellDepends = [
          base containers directory filepath mtl parsec pretty transformers
        ];
@@ -25228,7 +25287,7 @@ self: {
      mkDerivation {
        pname = "bimap";
        version = "0.3.0";
-       sha256 = "1j9rrxzzggvajz8laf58nda9hgf5lqsqxxc556690yyliln0gii1";
+       sha256 = "21c6072c8dd47b908c2985f58e35a6c53d9854b3a83845d1976abff77fcf39c9";
        libraryHaskellDepends = [ base containers ];
        homepage = "https://github.com/joelwilliamson/bimap";
        description = "Bidirectional mapping between two key types";
@@ -25242,7 +25301,7 @@ self: {
      mkDerivation {
        pname = "bimap-server";
        version = "0.1.0.1";
-       sha256 = "0dgmiv1pzzrq22778a2l46knxfk5rh2vw331gcqhxx0jb23d3pq9";
+       sha256 = "09dfd1865812f40e317b610cbe05cc65ba6ea7215428748e1038ff7fc38ef535";
        libraryHaskellDepends = [
          aeson base bimap binary directory http-types unix wai warp
        ];
@@ -25259,7 +25318,7 @@ self: {
      mkDerivation {
        pname = "bimaps";
        version = "0.0.0.2";
-       sha256 = "1wipia9lil9r7lhsf9rk82k8ydy5c97qsixg0fia0ms5chmdr7qw";
+       sha256 = "1c9fdc2a644557a0a203af478d4f62c5378fa6403327a7213d39d148938a37f2";
        libraryHaskellDepends = [
          aeson base binary cereal containers deepseq hashable primitive
          QuickCheck storable-tuple unordered-containers vector
@@ -25278,7 +25337,7 @@ self: {
      mkDerivation {
        pname = "binary";
        version = "0.7.6.1";
-       sha256 = "0rqhz349w72h1bi79lga5x1d95g59h15srlahxbhfrmy2pycm1cg";
+       sha256 = "8f85cafc15be660757878a665d024ce595d4422fead174e20a501c9ec8f81067";
        libraryHaskellDepends = [ array base bytestring containers ];
        testHaskellDepends = [
          array base bytestring Cabal containers directory filepath HUnit
@@ -25296,7 +25355,7 @@ self: {
      mkDerivation {
        pname = "binary-bits";
        version = "0.5";
-       sha256 = "1577bd5q4lhw024v4hfil10iyx7v4cf72ldhxb8xhm27i80lllqn";
+       sha256 = "16534a018a4754d8d1eab051711c23fb741f41a0d141b289001c52824b5be794";
        libraryHaskellDepends = [ base binary bytestring ];
        testHaskellDepends = [
          base binary bytestring QuickCheck random test-framework
@@ -25311,7 +25370,7 @@ self: {
      mkDerivation {
        pname = "binary-communicator";
        version = "1.0.2.1";
-       sha256 = "02w5ybp5fdqwz1ffvfs3pfrpx67bzh75njgzr6iai1vrdyjisfkl";
+       sha256 = "743a1da56f7987a8a2c9ff495b0efceb987eb3bb43bbed5cf81c3757eef2850b";
        libraryHaskellDepends = [ base binary bytestring mtl ];
        jailbreak = true;
        description = "Flexible way to ease transmission of binary data";
@@ -25325,7 +25384,7 @@ self: {
      mkDerivation {
        pname = "binary-conduit";
        version = "1.2.3";
-       sha256 = "0ymhxyf754j1pki7ap2vay8f9j49rzsjzp5yr253sn5wpw3qg8fr";
+       sha256 = "d9a18707bfbc583d8ac8bedc2ff5cf89c8e490575b5c75e2bc4192729cefb07a";
        revision = "1";
        editedCabalFile = "9cb1c58171575429a65947d1ef7e22c1501b4ca9becc07904c7b4a5066345e29";
        libraryHaskellDepends = [
@@ -25345,7 +25404,7 @@ self: {
      mkDerivation {
        pname = "binary-derive";
        version = "0.1.0";
-       sha256 = "1rb4fpx5hlq661md7nrpgpmi7jjdq3r1ky6q9vxl6f72h085acvl";
+       sha256 = "7433551080e23843fb4ed8f819f2c04dca13eb7d37dbd36a30065358fa7564e5";
        libraryHaskellDepends = [ base binary ghc-prim ];
        jailbreak = true;
        description = "Automatic deriving of Binary using GHC.Generics";
@@ -25360,7 +25419,7 @@ self: {
      mkDerivation {
        pname = "binary-file";
        version = "0.15.24";
-       sha256 = "134iigqjwlkj85pdp95xl6ia6fxr9l516j9b0dpg3r0zqi1kzp7i";
+       sha256 = "f1dc3f43c41fe4f16e032b49130a4db93ba3a2a1bda4db6e4172522ef18b918c";
        libraryHaskellDepends = [
          base bytestring monads-tf peggy template-haskell
        ];
@@ -25377,7 +25436,7 @@ self: {
      mkDerivation {
        pname = "binary-generic";
        version = "0.2.1";
-       sha256 = "0c6gfa1wvrcw4frrqzrfnc5ydqlbs56jq7hnxgzg89mr510mfsgz";
+       sha256 = "ff69574128b926f4feeb161e2c4dd18be2e60bb32e7f9cb3239ce5cd8372cf30";
        libraryHaskellDepends = [
          base binary bytestring data-binary-ieee754 syb text
        ];
@@ -25391,7 +25450,7 @@ self: {
      mkDerivation {
        pname = "binary-indexed-tree";
        version = "0.1";
-       sha256 = "1csbmkwrcfcfydyl2ab6s5bz1fy4fgl14m63zdyi0vy3d17zbl4d";
+       sha256 = "8dd0f54f68c36f107dfbc35412e873c4bbf057d16629417df38e3996f9ac4bb3";
        libraryHaskellDepends = [ array base ];
        description = "Binary Indexed Trees (a.k.a. Fenwick Trees).";
        license = "LGPL";
@@ -25405,7 +25464,7 @@ self: {
      mkDerivation {
        pname = "binary-list";
        version = "1.1.1.0";
-       sha256 = "03fh5ipmmjzdyywm28m2kkbxn11yb4ygrs1q2igll1mbmpm2km6x";
+       sha256 = "ddd429eaadab064a5f1438e8fc3c593e04dbd79ca22251b9f7edcb5a6f2cd00d";
        libraryHaskellDepends = [
          base binary bytestring deepseq phantom-state transformers
        ];
@@ -25418,7 +25477,7 @@ self: {
      mkDerivation {
        pname = "binary-literal-qq";
        version = "1.0";
-       sha256 = "0kbxd2ryls1zhmfg831ls219fn58xa7dq1bca48v7n7075nmh1jm";
+       sha256 = "5506586d39e0d8b311516c05dc8eeaa8589782d0340cf45c853f68eab3687d4d";
        libraryHaskellDepends = [ base template-haskell ];
        description = "Extends Haskell with binary literals";
        license = stdenv.lib.licenses.bsd3;
@@ -25429,7 +25488,7 @@ self: {
      mkDerivation {
        pname = "binary-protocol";
        version = "1.0";
-       sha256 = "1hn6jc4j20z8ni7rpcyamam898yl6jy7zinrhy2rdjvx0p5br13h";
+       sha256 = "7084bcca057dcb968587d9c67fbc34d4a384aaaacab39b4fb4e803210993c6c2";
        libraryHaskellDepends = [ base binary bytestring mtl ];
        jailbreak = true;
        homepage = "http://github.com/gcross/binary-protocol";
@@ -25442,7 +25501,7 @@ self: {
      mkDerivation {
        pname = "binary-protocol-zmq";
        version = "0.2";
-       sha256 = "14jap6kc1jbr3i010qg2z8d0li09d3a88fwzwrlb750pn67x7amy";
+       sha256 = "beaad38fb11794b368e69f3b84d46809440a1afae26110401c79c9c0a6b94a92";
        isLibrary = true;
        isExecutable = true;
        libraryHaskellDepends = [
@@ -25461,7 +25520,7 @@ self: {
      mkDerivation {
        pname = "binary-search";
        version = "0.1";
-       sha256 = "02s81jpysgqnnk8c45y9xc2fhy59mm1k2wskrl4hzhdjlp4c65f3";
+       sha256 = "c315c3c8a5b2c10f09cd53733143ada978e804ebc917c2d0b4163fedaf0c480b";
        libraryHaskellDepends = [ base containers ];
        testHaskellDepends = [
          base directory doctest filepath hspec QuickCheck
@@ -25475,7 +25534,7 @@ self: {
      mkDerivation {
        pname = "binary-shared";
        version = "0.8.3";
-       sha256 = "1clqq0rqjw1v7y6glkjnfyga5gxh768flyw617g47z0qa181c0c3";
+       sha256 = "830116505018fc43de09867bea9039b0bfa29e77564efa8c3f3b708933c098b2";
        libraryHaskellDepends = [ base binary bytestring containers mtl ];
        homepage = "http://www.leksah.org";
        description = "Sharing for the binary package";
@@ -25487,7 +25546,7 @@ self: {
      mkDerivation {
        pname = "binary-state";
        version = "0.1.1";
-       sha256 = "06v3qxyl2mvwi3y29rxxf91b2vxvlh5gfznwlnzb4mxzd00aakgl";
+       sha256 = "f44da50068bf57b2bea5dc7ef70aa4bb6fb14272bde724fc887c57417dc7631b";
        libraryHaskellDepends = [ base binary bytestring containers mtl ];
        description = "Simple wrapper around Data.Binary, which adds StateT to Get/Put monads.";
        license = stdenv.lib.licenses.bsd3;
@@ -25501,7 +25560,7 @@ self: {
      mkDerivation {
        pname = "binary-store";
        version = "0.1.0.1";
-       sha256 = "1wjhc18zj6p5gy15y1b7gz0vlqdbwhmfyv82l55ggmzjv1qyv7rl";
+       sha256 = "349fed71d8f2d7f74aa1026def2ae4ab61bac17f67055f827fe51af9516050f2";
        libraryHaskellDepends = [
          base binary binary-list binary-transform bytestring bzlib deepseq
          reinterpret-cast
@@ -25522,7 +25581,7 @@ self: {
      mkDerivation {
        pname = "binary-streams";
        version = "0.1.0.1";
-       sha256 = "1kjf5ks9l7fs0fsmwk5bcyhxlrz22hi4315bqqx2jzyq6pnwf4mv";
+       sha256 = "bb12c7ed35d87f293ac6ab84412214e267daa167ab4c5eb503da1d9af42c4ece";
        libraryHaskellDepends = [ base binary bytestring io-streams ];
        testHaskellDepends = [
          base binary bytestring Cabal cabal-test-quickcheck io-streams
@@ -25539,7 +25598,7 @@ self: {
      mkDerivation {
        pname = "binary-strict";
        version = "0.4.8.2";
-       sha256 = "0cyrr45wpq5h4gg6qms54nmvhqpyj59d5bhlk316g4yjsf3484b7";
+       sha256 = "67114486d3d29367c29814aed25291fe62b8ab2545576cde23b0e0cb0bc9d933";
        libraryHaskellDepends = [ array base bytestring containers mtl ];
        jailbreak = true;
        homepage = "https://github.com/idontgetoutmuch/binary-low-level";
@@ -25555,7 +25614,7 @@ self: {
      mkDerivation {
        pname = "binary-typed";
        version = "0.3";
-       sha256 = "12yzgcrj528pss4jk753xmcrzv2qm70dacqjnx7460bcdsmyd6zy";
+       sha256 = "fe9be6ab6e6c01434eb71233d5c0a958ec9f59eda39c2989d6178922337bdf8b";
        libraryHaskellDepends = [ base binary bytestring murmur-hash ];
        testHaskellDepends = [
          base binary bytestring tasty tasty-hunit tasty-quickcheck
@@ -25570,7 +25629,7 @@ self: {
      mkDerivation {
        pname = "binarydefer";
        version = "1.2.2";
-       sha256 = "06q255kip3j31bmj01fqkikvjxbklvcaa1kv3al8v04nkqx6rg3p";
+       sha256 = "77bc6c3a9e96808da81a7b06a5d8a67375b9679cd80520eb0a438e1b6729021b";
        libraryHaskellDepends = [ base ];
        description = "Binary serialization with deferred loading";
        license = stdenv.lib.licenses.bsd3;
@@ -25584,7 +25643,7 @@ self: {
      mkDerivation {
        pname = "bind-marshal";
        version = "0.1";
-       sha256 = "13riawcdzwr97vmixvg2wf8aysxblzik2mvkrp2gqf9ywda9ksr6";
+       sha256 = "26eb9954e33e39fcc4cd735731e3a7ab6baf90e3e2ed1eeb3e29f3df1857318f";
        libraryHaskellDepends = [
          base bytestring containers deepseq ghc-prim monads-tf mtl
          numeric-prelude random stm strict transformers type-level-tf unix
@@ -25601,7 +25660,7 @@ self: {
      mkDerivation {
        pname = "binding-core";
        version = "0.2.2";
-       sha256 = "0qr7nr9cksy2cx2h8g2d485797hvv67197c654va0xwadkj5iviz";
+       sha256 = "3fee58e46c8a77a03629869d148ed91b9e740a224d3c044567c2ebc952b62763";
        revision = "1";
        editedCabalFile = "1aeacdf0ebf89a2f515ab0ef767ed86f44b4b22f740ac23d1afd76df391955c6";
        libraryHaskellDepends = [ base stm ];
@@ -25616,7 +25675,7 @@ self: {
      mkDerivation {
        pname = "binding-gtk";
        version = "0.2.1";
-       sha256 = "0l68n13w1khfqkc791l9mcnk3cb0565a9ysfn7b3hh5cjx8zi7vr";
+       sha256 = "799ff85197ac4038d6b14efba48a2960b1312dab898674d8c40ecec047b0c850";
        revision = "1";
        editedCabalFile = "9e435774bd5d6a7d9dd1e96dd9293d6a739f7ecde23838571d30866ac4628cb5";
        libraryHaskellDepends = [ base binding-core gtk mtl ];
@@ -25632,7 +25691,7 @@ self: {
      mkDerivation {
        pname = "binding-wx";
        version = "0.2.1";
-       sha256 = "07nbb6a0fmyhmx2dakkw4msxnv273hfcw3swdk3aczpfqlxd1r4i";
+       sha256 = "91e4d03ac5ee7ea6c66c5c0fce1c1c476cdb75257c4ed544afd057079459cb1e";
        revision = "1";
        editedCabalFile = "0307431866ac8b7f34ece32a684a3c70aa1b36ce74c05d815f249d1effe2efb2";
        libraryHaskellDepends = [ base binding-core stm wx wxcore ];
@@ -25647,7 +25706,7 @@ self: {
      mkDerivation {
        pname = "bindings";
        version = "0.1.2";
-       sha256 = "0zczf1yfjnfzdzv33j33vcc71zsf88a5qxsdmswxrpzika3rs6i0";
+       sha256 = "201a9d879af1dfdcb9ae4d775c14424eff7018db63c831f66fdf59e97c709f7d";
        libraryHaskellDepends = [ base ];
        description = "Deprecated package";
        license = stdenv.lib.licenses.bsd3;
@@ -25658,7 +25717,7 @@ self: {
      mkDerivation {
        pname = "bindings-DSL";
        version = "1.0.22";
-       sha256 = "0xkr1x3klpfwbh1yimah1dqmqcilifyblnf3kr6ay4gsvw74zkwr";
+       sha256 = "99cf4f0edffa11af4c9ec359babc8b34325c710b50d5e8035cdc5d3a470f7976";
        libraryHaskellDepends = [ base ];
        homepage = "https://github.com/jwiegley/bindings-dsl/wiki";
        description = "FFI domain specific language, on top of hsc2hs";
@@ -25670,7 +25729,7 @@ self: {
      mkDerivation {
        pname = "bindings-EsounD";
        version = "0.1.0.1";
-       sha256 = "0fl7gdh60k7wj3bnn5hpgsi0kkji857xb47spii7mrip5p4m8pff";
+       sha256 = "ce5d54c92d37e67a62bcfa90d54f4151ce09a27e17166bd790fc4c60607b873a";
        libraryHaskellDepends = [ base bindings-audiofile bindings-DSL ];
        libraryPkgconfigDepends = [ esound ];
        homepage = "http://cielonegro.org/Bindings-EsounD.html";
@@ -25687,7 +25746,7 @@ self: {
      mkDerivation {
        pname = "bindings-GLFW";
        version = "3.1.1.3";
-       sha256 = "0pzhlzx8h5g3cs7wr06zydabprlrf5sgdvdqmr2wg10azikxc12z";
+       sha256 = "5f04d667fc0a84c745aeb8edf6747199e6bb54f3df80cc8f66e31588faa7f05f";
        libraryHaskellDepends = [ base bindings-DSL ];
        librarySystemDepends = [
          libX11 libXcursor libXext libXfixes libXi libXinerama libXrandr
@@ -25709,7 +25768,7 @@ self: {
      mkDerivation {
        pname = "bindings-K8055";
        version = "0.1.2";
-       sha256 = "0daga3vh9x9gih25qgcsl0hafi4hw8h5x64ba6wbmywa9z3hrr20";
+       sha256 = "40e40cc74f8afbbab8518b985e20e29044a720a09a3d5c048c2ff504f7504f35";
        libraryHaskellDepends = [ base ];
        librarySystemDepends = [ K8055D ];
        homepage = "https://github.com/jputcu/bindings-K8055";
@@ -25723,7 +25782,7 @@ self: {
      mkDerivation {
        pname = "bindings-apr";
        version = "0.1";
-       sha256 = "0fw71z74pv8dxw301iss66kmarhlgwj2lpsy0skmlqfkg98zc96k";
+       sha256 = "d324f6517ad3615aa7065e5f2a247f146655a7315ac70006ef0ded4bce0f873b";
        libraryHaskellDepends = [ base bindings-DSL ];
        libraryPkgconfigDepends = [ apr-1 ];
        jailbreak = true;
@@ -25738,7 +25797,7 @@ self: {
      mkDerivation {
        pname = "bindings-apr-util";
        version = "0.1";
-       sha256 = "0sr041vpakklpf2mmy78wl5wl8yzfbwvsy07wlplmlh5rgjdm4wx";
+       sha256 = "9d93dae4cb05d24a2fe50778bdf972df23ca0be5e8f85a85bb744e757720206b";
        libraryHaskellDepends = [ base bindings-apr bindings-DSL ];
        libraryPkgconfigDepends = [ apr-util-1 ];
        jailbreak = true;
@@ -25753,7 +25812,7 @@ self: {
      mkDerivation {
        pname = "bindings-audiofile";
        version = "0.1.0.2";
-       sha256 = "0ls0iy33i0b86fg7hx23s1d8ypa16bdiw3l8nmsni3zgnn67w6mj";
+       sha256 = "b21a7e8cb5ef8f6875b5880e1edb32415d8f5ad04374789e33688138868f4053";
        libraryHaskellDepends = [ base bindings-DSL ];
        libraryPkgconfigDepends = [ audiofile ];
        homepage = "http://cielonegro.org/Bindings-AudioFile.html";
@@ -25768,7 +25827,7 @@ self: {
      mkDerivation {
        pname = "bindings-bfd";
        version = "1.2.0.0";
-       sha256 = "0c05zr3k0az2hfyfync8z2sgdxx6gskqdb1n548fjc986cx298q4";
+       sha256 = "04a3243a332831e9102936ac86a77ea6f7f6b4f88859efbc83e22b3047fe0530";
        libraryHaskellDepends = [ array base containers unix ];
        librarySystemDepends = [ bfd opcodes ];
        libraryToolDepends = [ alex happy ];
@@ -25784,7 +25843,7 @@ self: {
      mkDerivation {
        pname = "bindings-cctools";
        version = "3.6.1.0.1.0.0.1";
-       sha256 = "1k0p0m09ndk6c42h3yy230q86fnm0hzr1zjr3871f9hapvnvzqr8";
+       sha256 = "28e3bfedbe0a26170e1a59fe903f04d53a833018c2fb01056166369b400517cc";
        libraryHaskellDepends = [ bindings-DSL ];
        librarySystemDepends = [ dttools ];
        homepage = "http://bitbucket.org/badi/bindings-cctools";
@@ -25800,7 +25859,7 @@ self: {
      mkDerivation {
        pname = "bindings-codec2";
        version = "0.1.1.0";
-       sha256 = "0mpb79djfqi0had6rx20jsgahdfv23bnp0i25lbxv8vg72m3wdnn";
+       sha256 = "d6363eaa386fa3dd172d22826bd710db35a89e9640f46c9a822062275b3aeb56";
        revision = "1";
        editedCabalFile = "48e69a5b497247c96ab7a6ed3ff818bef596c712249819e63a84c4667ef5d0b1";
        isLibrary = true;
@@ -25819,7 +25878,7 @@ self: {
      mkDerivation {
        pname = "bindings-common";
        version = "1.3.4";
-       sha256 = "1zbm8v5xp4pay6h0y24ngf8nw96ab0zr754b9n2zczadiarccmcb";
+       sha256 = "8b55c6b28a4d7df6854d8b94933f58ca246e917b96080fa0f1ea92dbcb4675fd";
        libraryHaskellDepends = [ base ];
        description = "This package is obsolete. Look for bindings-DSL instead.";
        license = stdenv.lib.licenses.bsd3;
@@ -25831,7 +25890,7 @@ self: {
      mkDerivation {
        pname = "bindings-dc1394";
        version = "0.2.1";
-       sha256 = "06xg2amlcqldb7h0xaw8dvzq65npirsibbgmbr5n8s59rwa6hfwq";
+       sha256 = "983b6814cfa968644b5ef5ad15758ed71683ff6e88ab0ee0598d6246ab12af1b";
        libraryHaskellDepends = [ base bindings-DSL ];
        librarySystemDepends = [ dc1394 ];
        libraryToolDepends = [ c2hs ];
@@ -25846,7 +25905,7 @@ self: {
      mkDerivation {
        pname = "bindings-directfb";
        version = "0.1";
-       sha256 = "0mmba1h9in9xh590nmr1vb5ccqng3nwdc4q0b9d67v22cmc7fhpp";
+       sha256 = "f74277586542ec635a5a0013d6b81dcf62c6cada21570b52813dd9986050ab56";
        libraryHaskellDepends = [ base bindings-DSL bindings-posix ];
        libraryPkgconfigDepends = [ directfb ];
        description = "Low level bindings to DirectFB";
@@ -25858,7 +25917,7 @@ self: {
      mkDerivation {
        pname = "bindings-eskit";
        version = "0.0.1";
-       sha256 = "0j0fi74ky1qdvkgbapyq8fag2linawz3ndgzgi8lcci8lsby0n72";
+       sha256 = "e258e097a6283246517cff353b3e573652f19443d85fb5dedc0d073fc9890e48";
        libraryHaskellDepends = [ array base bindings-DSL ];
        librarySystemDepends = [ eskit ];
        libraryPkgconfigDepends = [ eskit ];
@@ -25874,7 +25933,7 @@ self: {
      mkDerivation {
        pname = "bindings-fann";
        version = "0.0.2";
-       sha256 = "1hryjj9aabaxrcgmr3i6sklbyb58djzsrlssidgll3vb0wwcgbq7";
+       sha256 = "07afc738076b0f4a5f8b5ad3acbf6ca82cbfe8d4268e5c1fcb5d2da592943ec3";
        libraryHaskellDepends = [ base bindings-DSL ];
        libraryPkgconfigDepends = [ fann ];
        description = "Low level bindings to FANN neural network library";
@@ -25887,7 +25946,7 @@ self: {
      mkDerivation {
        pname = "bindings-fluidsynth";
        version = "0.1.1";
-       sha256 = "04q5zxv4iyjb7zf7bhx19cfc8nhnqxmxnl1q63qszjysmlpy39g5";
+       sha256 = "e5a5e12faddacbaff1303850db6bc7165ac41c4ba1c375dc3f4bfa4876ff0513";
        libraryHaskellDepends = [ base bindings-DSL ];
        libraryPkgconfigDepends = [ fluidsynth ];
        homepage = "http://github.com/bgamari/bindings-fluidsynth";
@@ -25900,7 +25959,7 @@ self: {
      mkDerivation {
        pname = "bindings-friso";
        version = "0.1.0.0";
-       sha256 = "0wg120qrqqf2g38ifjkwj5cc42sdcdn2lrs93wrdq9dd7kldn79c";
+       sha256 = "2c1ddbe83cad25dc321f49672a6c634d0bc258917c4a17d178c2619c3110e171";
        libraryHaskellDepends = [ base bindings-DSL ];
        librarySystemDepends = [ friso ];
        description = "Low level bindings for friso";
@@ -25913,7 +25972,7 @@ self: {
      mkDerivation {
        pname = "bindings-glib";
        version = "0.1.5";
-       sha256 = "0jhifzbwbphlzz9ffv3pyjv27phvcvky1gczmi9kvfz761b9qgyx";
+       sha256 = "dd3f9c5630e7bb3d53ac9fbde0e7661bde23b6f4776ce7d2ff14dec5d777114a";
        libraryHaskellDepends = [ base bindings-DSL ];
        libraryPkgconfigDepends = [ glib ];
        description = "Low level bindings to GLib";
@@ -25925,7 +25984,7 @@ self: {
      mkDerivation {
        pname = "bindings-gobject";
        version = "0.4";
-       sha256 = "1r2cg06r068nfyppjs2kwfmam7vk5x0l4f865arrrgrqam3bs1av";
+       sha256 = "5b05bd465538bf9cb32a063942412f739faaaae3536879af771619900d784ce4";
        libraryHaskellDepends = [ base bindings-DSL bindings-glib ];
        libraryPkgconfigDepends = [ glib ];
        description = "Low level bindings supporting GObject and derived libraries";
@@ -25937,7 +25996,7 @@ self: {
      mkDerivation {
        pname = "bindings-gpgme";
        version = "0.1.6";
-       sha256 = "0mwlb1fk852pk6an3ay9mgxmxqf6f6bzm965agm80yhr2ab3iqhq";
+       sha256 = "18e2389612197a80ea53c5a4fa9771c6e15efbabc9ab6195995714345d589457";
        libraryHaskellDepends = [ base bindings-DSL ];
        librarySystemDepends = [ gpgme ];
        homepage = "http://bitbucket.org/mauricio/bindings-gpgme";
@@ -25950,7 +26009,7 @@ self: {
      mkDerivation {
        pname = "bindings-gsl";
        version = "0.2.1";
-       sha256 = "0yv0k6r2pd4bbq0qsf6wfx752qn0d2d0s3jfa633gy6sg97j2n3y";
+       sha256 = "7e58214f7adaf83786514e0e0d9a68c062514e77dc388d015e8bb42bb299607b";
        libraryHaskellDepends = [ base bindings-DSL ];
        libraryPkgconfigDepends = [ gsl ];
        description = "Low level bindings to GNU GSL";
@@ -25962,7 +26021,7 @@ self: {
      mkDerivation {
        pname = "bindings-gts";
        version = "0.1.1";
-       sha256 = "1niqkxw7wxircwgvd9z4q9j3jxswifhl0h88v3j35lbxhiz6v7kh";
+       sha256 = "709e6d7e847dd132e4d8084140a18b5c773964c2e4a7b61f6739767e789f38da";
        libraryHaskellDepends = [ base bindings-DSL bindings-glib ];
        libraryPkgconfigDepends = [ gts ];
        description = "Low level bindings supporting GTS, the GNU Triangulated Surface Library";
@@ -25975,7 +26034,7 @@ self: {
      mkDerivation {
        pname = "bindings-hamlib";
        version = "0.1.0.0";
-       sha256 = "1na9v5s5lqdnnj031zmqg3xfpsvy80gzr7qg0f3gsyyniww72xlz";
+       sha256 = "9f7671388fd67bfd86030f9ffc1f407eebebfa78b8fe3080b4b6615a74d949d9";
        revision = "1";
        editedCabalFile = "1eea9735be1dd9f54d91406fbf56da41b8d68a3760ada5e4fc4caf0658c997c9";
        isLibrary = true;
@@ -25993,7 +26052,7 @@ self: {
      mkDerivation {
        pname = "bindings-hdf5";
        version = "0.1";
-       sha256 = "0x6p1mwwnpcd5bd6iy4di11n7b45c4zp9d6l957mmhsyg24h2n79";
+       sha256 = "e9580189785ec35a4f49d4b4743f6185ac6343888df868da2a8d5dcb790dd774";
        libraryHaskellDepends = [ base bindings-DSL ];
        description = "Project bindings-* raw interface to HDF5 library";
        license = stdenv.lib.licenses.bsd3;
@@ -26005,7 +26064,7 @@ self: {
      mkDerivation {
        pname = "bindings-levmar";
        version = "1.1.0.3";
-       sha256 = "1da9n88wwjpm3ph7q73niv3cslpa0h8r0lsyfl35arymxfqpb4c0";
+       sha256 = "809175b1ebd5675506755e53901104ea52cdc68e761c7ce01df54ace11b249b5";
        libraryHaskellDepends = [ base bindings-DSL ];
        librarySystemDepends = [ blas lapack ];
        homepage = "https://github.com/basvandijk/bindings-levmar";
@@ -26018,7 +26077,7 @@ self: {
      mkDerivation {
        pname = "bindings-libcddb";
        version = "0.3";
-       sha256 = "1hygdr4w27igwc513vs7rc9i2xcmr1ndvbiwhkrdw2x0wsmz6yyy";
+       sha256 = "de7bf3abe6a00bdef2843caedd6cc895751113cb47ef110ae32f1ec1496ecfc3";
        libraryHaskellDepends = [ base bindings-DSL ];
        libraryPkgconfigDepends = [ libcddb ];
        homepage = "http://bitbucket.org/mauricio/bindings-libcddb";
@@ -26031,7 +26090,7 @@ self: {
      mkDerivation {
        pname = "bindings-libffi";
        version = "0.3";
-       sha256 = "1321hr92nsa7fljxxir8waj7i42m8dvz76h693vp4n3lqll9hcf9";
+       sha256 = "c9319828c5745872f748069af37743559078a4e228c7de257547692b5286418c";
        libraryHaskellDepends = [ base bindings-DSL ];
        libraryPkgconfigDepends = [ libffi ];
        description = "Low level bindings to libffi";
@@ -26043,7 +26102,7 @@ self: {
      mkDerivation {
        pname = "bindings-libftdi";
        version = "0.1";
-       sha256 = "07kabkvdjiskika9vddrf9vhknld1x9s4m3b89d9m6l4gb2ln76i";
+       sha256 = "d11c4bc57a849a9a5a426b54a2530f8dda097772b9b59dd48c5347d9f65c6a1e";
        libraryHaskellDepends = [ base bindings-DSL ];
        libraryPkgconfigDepends = [ libftdi libusb ];
        description = "Low level bindings to libftdi";
@@ -26056,7 +26115,7 @@ self: {
      mkDerivation {
        pname = "bindings-librrd";
        version = "0.2.0.1";
-       sha256 = "1dyhq06rs91g77c67lfnscn7l9fgbzikiqnv2d494jd60y1q8n8y";
+       sha256 = "1e59848307a649924813dbe238e35fcf257a2cd3d6d163d8392f249d0dc0d0b7";
        libraryHaskellDepends = [ base bindings-DSL ];
        libraryPkgconfigDepends = [ librrd ];
        homepage = "http://cielonegro.org/Bindings-librrd.html";
@@ -26072,7 +26131,7 @@ self: {
      mkDerivation {
        pname = "bindings-libstemmer";
        version = "0.1.0.0";
-       sha256 = "03plarpy0fpv9anqnaqwcji3vij2qrxd4qmli77jb5npmax20r92";
+       sha256 = "226520baaad79625cf89b462d27ac642c63da2641c2b8bad4afb3ae06f56f40e";
        libraryHaskellDepends = [
          base bindings-DSL resourcet transformers
        ];
@@ -26087,7 +26146,7 @@ self: {
      mkDerivation {
        pname = "bindings-libusb";
        version = "1.4.5.0";
-       sha256 = "0xnx9p6wqbwiaqigdnf7x6vd0qq7w9wm0vxsh93adpb5wdpjza66";
+       sha256 = "c6a82f6fe365dda64682ba6f5079e20763d0b6e9c7d9f62256912fcccd4ddd76";
        libraryHaskellDepends = [ base bindings-DSL ];
        libraryPkgconfigDepends = [ libusb ];
        homepage = "https://github.com/basvandijk/bindings-libusb";
@@ -26100,7 +26159,7 @@ self: {
      mkDerivation {
        pname = "bindings-libv4l2";
        version = "0.1";
-       sha256 = "0s31dh5g26nldb6aq6q4i6ypgajincw7n3d3vm838x3w320qvg2g";
+       sha256 = "4fbc8d81187c743450dda30d7b38b351aa77bd89041baccc6ad41af10a6c6168";
        libraryHaskellDepends = [ base bindings-DSL ];
        librarySystemDepends = [ v4l2 ];
        homepage = "https://gitorious.org/hsv4l2";
@@ -26114,7 +26173,7 @@ self: {
      mkDerivation {
        pname = "bindings-libzip";
        version = "0.11";
-       sha256 = "0hqkp4hvav67xqjfwbik3i06vq8f78jjzf37ncl6wwcw5w65hhrj";
+       sha256 = "3243580c2f9c716e28b367b82f253a0ee16d401c332eee24eec76cb521b91343";
        libraryHaskellDepends = [ base bindings-DSL ];
        libraryPkgconfigDepends = [ libzip ];
        homepage = "http://bitbucket.org/astanin/hs-libzip/";
@@ -26127,7 +26186,7 @@ self: {
      mkDerivation {
        pname = "bindings-linux-videodev2";
        version = "0.1";
-       sha256 = "1pqi8ks441m1s1md6nhjr7zhal5fv6s71xq4881zijd539qhq9dq";
+       sha256 = "b8250c711aa5c9f8034204f770b4d9ae5005ffc9125ad36ad0a10642f44411df";
        libraryHaskellDepends = [ base bindings-DSL ioctl ];
        homepage = "https://gitorious.org/hsv4l2";
        description = "bindings to Video For Linux Two (v4l2) kernel interfaces";
@@ -26140,7 +26199,7 @@ self: {
      mkDerivation {
        pname = "bindings-lxc";
        version = "0.2.0.1";
-       sha256 = "0w61xzx8krr1pfa9ys7akpra2r0njziysm3ri08fb98g75hp9942";
+       sha256 = "82a47461390fa5e510887954ede3971664a1f29dea689f94bb21e789faefc170";
        libraryHaskellDepends = [ base bindings-DSL ];
        librarySystemDepends = [ lxc ];
        jailbreak = true;
@@ -26154,7 +26213,7 @@ self: {
      mkDerivation {
        pname = "bindings-mmap";
        version = "1.0";
-       sha256 = "19qdf5z6mf8j8inlnax0nv1wiv4va27z4a303hpkbgda459093nd";
+       sha256 = "cd8e045221aabd352f1c6028f28f509becc8c3b6a02b4b6d4412b96a7e710da7";
        libraryHaskellDepends = [ bindings-posix ];
        description = "(deprecated) see bindings-posix instead";
        license = stdenv.lib.licenses.bsd3;
@@ -26165,7 +26224,7 @@ self: {
      mkDerivation {
        pname = "bindings-mpdecimal";
        version = "0.8.0.0";
-       sha256 = "18i68ivsrdndjpfnyq6dlmmkkx22v3rp619nm26af8ka3qai12j5";
+       sha256 = "458a10151e6a22a78ca8360573f3d842f4396ba5cd606fdd95cdb6ac774426a2";
        libraryHaskellDepends = [ base bindings-DSL ];
        jailbreak = true;
        homepage = "http://www.github.com/massysett/bindings-mpdecimal";
@@ -26181,7 +26240,7 @@ self: {
      mkDerivation {
        pname = "bindings-nettle";
        version = "0.4";
-       sha256 = "11fnyjxb6gvl2mfnsahzadd5xj0y1p25n98qbhrkzziaihsf01ph";
+       sha256 = "f006e0348c2afe3f335c18255bc40d1ec85e5a531f2a6d5d15743fb3baf4d685";
        libraryHaskellDepends = [ base bindings-DSL ];
        libraryPkgconfigDepends = [ nettle ];
        testHaskellDepends = [
@@ -26197,7 +26256,7 @@ self: {
      mkDerivation {
        pname = "bindings-parport";
        version = "0.0.4";
-       sha256 = "1q404clpqzv0gik80ycipl94hvj27397z5cw1cs7b0yxlypllg3j";
+       sha256 = "723c4aafa7dd8375340b9c957fd238426e4812bd917980667c607f7c292380e0";
        libraryHaskellDepends = [ base bindings-DSL ];
        description = "parport bindings";
        license = stdenv.lib.licenses.bsd3;
@@ -26208,7 +26267,7 @@ self: {
      mkDerivation {
        pname = "bindings-portaudio";
        version = "0.1";
-       sha256 = "0wcxq300ijfkf4zc7p4xwsd9wzhnlss0kxjf04fka01mf9bh3ai2";
+       sha256 = "22aa0157723500351d014ef609b4a6167e9e9ae69ddcc33e71d3c908c0c09d71";
        libraryHaskellDepends = [ base bindings-DSL ];
        libraryPkgconfigDepends = [ portaudio ];
        description = "Low-level bindings to portaudio library";
@@ -26220,7 +26279,7 @@ self: {
      mkDerivation {
        pname = "bindings-posix";
        version = "1.2.6";
-       sha256 = "1yza3qbf0f5gfpg79pb6xfpw37zg191nmxa4r6h9x4xb5na0rzff";
+       sha256 = "cefd0c942dab939ea0c944f56a430aef9fc1afeb66dd74de75af38e0161eeafb";
        libraryHaskellDepends = [ base bindings-DSL ];
        description = "Low level bindings to posix";
        license = stdenv.lib.licenses.bsd3;
@@ -26231,7 +26290,7 @@ self: {
      mkDerivation {
        pname = "bindings-potrace";
        version = "0.1";
-       sha256 = "0vb889f49li0lwy3zsji0f1cwzriizh9x6kg3r8676q5j08p7znd";
+       sha256 = "cdfe731190059b63501e6f9a9ee08f317fce820351ea3f3ca720d2445c42686d";
        libraryHaskellDepends = [ base bindings-DSL ];
        librarySystemDepends = [ potrace ];
        homepage = "https://github.com/rwbarton/bindings-potrace";
@@ -26244,7 +26303,7 @@ self: {
      mkDerivation {
        pname = "bindings-ppdev";
        version = "0.0.3";
-       sha256 = "18px429hplpabfhapwasbdgw8ynfm3vr5rf81pp173j1z0bv4ygq";
+       sha256 = "f879b217f8418e13ee0dc8e592f7a8ce7ac45f5b5af1aba05bead20b9320fda2";
        libraryHaskellDepends = [ base bindings-DSL ioctl ];
        description = "PPDev bindings";
        license = stdenv.lib.licenses.bsd3;
@@ -26257,7 +26316,7 @@ self: {
      mkDerivation {
        pname = "bindings-saga-cmd";
        version = "0.1.1.1";
-       sha256 = "11k56zsz1fg0hb0pqamq2hh3gczzqgj105qss5xrk0cgmsphhbmy";
+       sha256 = "be2e08afae8f81997bd11a1710e4c3ffb3372014b82a7cc182e0b9f0f5376586";
        isLibrary = true;
        isExecutable = true;
        libraryHaskellDepends = [
@@ -26276,7 +26335,7 @@ self: {
      mkDerivation {
        pname = "bindings-sane";
        version = "0.0.1";
-       sha256 = "0jxhc0x5hq6y7iznqlxbgnl37a7k8yki2ri475gyc158d47b0zm2";
+       sha256 = "a27eb00e69a804e65f39246611a747f3a833a87dab536c7f3cde60583a60b04b";
        libraryHaskellDepends = [ base bindings-DSL ];
        libraryPkgconfigDepends = [ saneBackends ];
        homepage = "http://floss.scru.org/bindings-sane";
@@ -26289,7 +26348,7 @@ self: {
      mkDerivation {
        pname = "bindings-sc3";
        version = "0.4.1";
-       sha256 = "07vp6hzjjrbh3j152mq8f1i6xh9m2r20a555y03p9fzdfrb5kixd";
+       sha256 = "adc7595676edbb7407f0a51405441635c16e6270085751821c7065293f34771f";
        libraryHaskellDepends = [ base bindings-DSL ];
        librarySystemDepends = [ scsynth ];
        homepage = "https://github.com/kaoskorobase/bindings-sc3/";
@@ -26303,7 +26362,7 @@ self: {
      mkDerivation {
        pname = "bindings-sipc";
        version = "1.1";
-       sha256 = "1r2akdkhw054k6vg9a7jpm9ck280lsfkizz7y6cqbn1hy463grkd";
+       sha256 = "6de6370cf130d88599f1e7ff389da60089c952bdf2a8f4b699a4000e679b4ae4";
        isLibrary = true;
        isExecutable = true;
        libraryHaskellDepends = [ base ];
@@ -26320,7 +26379,7 @@ self: {
      mkDerivation {
        pname = "bindings-sophia";
        version = "0.2.0.2";
-       sha256 = "0fiibm7nrsx9pzi2lvhhbw71bah6s22h3jvn417ng3lj6ghhzii6";
+       sha256 = "26c60fe133928e674f2076cb0185d006aa150e5f106e2ae2bfa9eb6c4f5d313a";
        libraryHaskellDepends = [ base bindings-DSL ];
        description = "Low-level bindings to sophia library";
        license = stdenv.lib.licenses.bsd3;
@@ -26331,7 +26390,7 @@ self: {
      mkDerivation {
        pname = "bindings-sqlite3";
        version = "1.0.3";
-       sha256 = "0f30a7xdx50gs7hdv16b3m2055f0ar5c2cani318iwympnrpgww1";
+       sha256 = "81f377b3bdd5f388c2885631c14a56c09502441dcb84dde0d10f94defa516038";
        libraryHaskellDepends = [ base bindings-DSL ];
        libraryPkgconfigDepends = [ sqlite ];
        description = "Low level bindings to sqlite3";
@@ -26343,7 +26402,7 @@ self: {
      mkDerivation {
        pname = "bindings-svm";
        version = "0.2.1";
-       sha256 = "1nnmyxn28qdfy2sclnxv2mf2d426vrzgs7f0vvqri6fkjnvmk11b";
+       sha256 = "2b8459b795d39998f1dec01dfd7ede4690265c15bb5bcab4f0ae61246cf7d5da";
        libraryHaskellDepends = [ base bindings-DSL ];
        homepage = "http://github.com/tanimoto/bindings-svm";
        description = "Low level bindings to libsvm";
@@ -26355,7 +26414,7 @@ self: {
      mkDerivation {
        pname = "bindings-uname";
        version = "0.1";
-       sha256 = "1lsw4dh5vgmfvrx62ns5kmngzlmjzbxkx43x5i2k5qlmzp1pa3hk";
+       sha256 = "130e75c3fd95e232452c7d903efbfab2d2ff6c9d455b617adeaebe5d60235cd3";
        libraryHaskellDepends = [ base ];
        description = "Low-level binding to POSIX uname(3)";
        license = stdenv.lib.licenses.publicDomain;
@@ -26366,7 +26425,7 @@ self: {
      mkDerivation {
        pname = "bindings-yices";
        version = "0.2";
-       sha256 = "13yfhx6krj59qij9yvcl4fr6znd28nbldbv0qfhf83h3h18araf9";
+       sha256 = "c9a9ac5080030ee4a0c360af469745a2d96fb223946d9f64c4a9c83c4d87ce8f";
        libraryHaskellDepends = [ base ];
        librarySystemDepends = [ gmp yices ];
        description = "Bindings to the Yices theorem prover";
@@ -26380,7 +26439,7 @@ self: {
      mkDerivation {
        pname = "binembed";
        version = "0.1.0.3";
-       sha256 = "163cs2qfj68dvbsyfg37hzb29jp0ylfpqlnhzjswm4j8mrcfsl3r";
+       sha256 = "7950ed58ae4892cab5fcd0527c1df5e0ca24d687673ce7f5da0d19e9b0d06c98";
        isLibrary = true;
        isExecutable = true;
        libraryHaskellDepends = [ base bytestring Cabal ];
@@ -26398,7 +26457,7 @@ self: {
      mkDerivation {
        pname = "binembed-example";
        version = "0.1.0.3";
-       sha256 = "06lw6jvg382k3wj8ybld05bj3nchb8dqk363a69mak3r5zxg43iy";
+       sha256 = "3e0ef2fa2f794c559351c38c891b5a90d92157018d2e8f241f53a0f1b6349c1a";
        isLibrary = false;
        isExecutable = true;
        executableHaskellDepends = [
@@ -26417,7 +26476,7 @@ self: {
      mkDerivation {
        pname = "bio";
        version = "0.5.3";
-       sha256 = "1vby3nbqbwza65jg5d0bmzh22i5s20cjbqdgaq9zasza7ywgkj22";
+       sha256 = "42c8f9b83fea6bf51356afe1251910ba4421e0af0bb4f26431eaf385971d7eed";
        isLibrary = true;
        isExecutable = true;
        libraryHaskellDepends = [
@@ -26439,7 +26498,7 @@ self: {
      mkDerivation {
        pname = "bioace";
        version = "0.0.1";
-       sha256 = "08k2w66gpysjk038pi50lc21gbn2dyp5z8ls0qhcmjqc59dn8hvg";
+       sha256 = "6f43645b2a0ccbca20069aa25fae6fc2ae1704a3a0c48b069852fbfb8ce16222";
        libraryHaskellDepends = [
          base bioalign biocore bytestring parsec
        ];
@@ -26453,7 +26512,7 @@ self: {
      mkDerivation {
        pname = "bioalign";
        version = "0.0.5";
-       sha256 = "006gg8ds6klrl9rc1csi247rf8gzlgn9mdi0jl4pjz5xmf0jw5dr";
+       sha256 = "b9152e81abbd7c79099520b69aeca3ff21970f1151b3c072a2994ea31b7acf00";
        libraryHaskellDepends = [ base biocore bytestring ];
        homepage = "https://patch-tag.com/r/dfornika/biophd/home";
        description = "Data structures and helper functions for calculating alignments";
@@ -26465,7 +26524,7 @@ self: {
      mkDerivation {
        pname = "biocore";
        version = "0.3.1";
-       sha256 = "06ml9p144bv0c9hv6pkcvhdgc0vw0jxzbqb834ilr38kjmrpsar1";
+       sha256 = "212b7d7395138d4c231968e1f5bb047c03f61adc6c5eb36162602f42c24db41a";
        libraryHaskellDepends = [ base bytestring stringable ];
        description = "A bioinformatics library";
        license = "LGPL";
@@ -26476,7 +26535,7 @@ self: {
      mkDerivation {
        pname = "biofasta";
        version = "0.0.3";
-       sha256 = "1l770sg2gcg7wl5yfrrk9nr7hgd5m0q158ad5nd8z7i5vsfah8b2";
+       sha256 = "6221a89cde259e8f9a2d4da11230a8a53d78b24d3367e70be5e7b1279e06e7d0";
        libraryHaskellDepends = [ base biocore bytestring ];
        homepage = "https://patch-tag.com/r/dfornika/biofasta/home";
        description = "Library for reading fasta sequence files";
@@ -26488,7 +26547,7 @@ self: {
      mkDerivation {
        pname = "biofastq";
        version = "0.1";
-       sha256 = "0453cb2sw6x9hx3z7w3fvymwi0l0s86wlvi6vvsh0jcwas3iirbl";
+       sha256 = "74e51887569c4900f5de266eca0dd28082c8abdf6ef0f34787a91baec562a310";
        libraryHaskellDepends = [ base biocore bytestring ];
        homepage = "http://biohaskell.org/";
        description = "A library for reading FASTQ files";
@@ -26502,7 +26561,7 @@ self: {
      mkDerivation {
        pname = "biophd";
        version = "0.0.8";
-       sha256 = "0p3xfv61xzz29qg660pcsgns7r5q1cybk3hdvdnwf0cqdc9fhxbl";
+       sha256 = "7475e8126b9801c76ddb0d8eb93c0bb8e4a3edd3ec02631e4ee2ff1ecc767d5c";
        libraryHaskellDepends = [
          base binary biocore bytestring parsec text time time-locale-compat
        ];
@@ -26519,7 +26578,7 @@ self: {
      mkDerivation {
        pname = "biopsl";
        version = "0.4";
-       sha256 = "1v9vg9gnrf606raqlzcd15irg60v3cf5m0yy5qsdyxm24102bgmj";
+       sha256 = "b2be254020a276df342ede835a1c1b1b989763098d7d8a5536c0b86c5f7a3bed";
        isLibrary = true;
        isExecutable = true;
        libraryHaskellDepends = [ base biocore bytestring ];
@@ -26536,7 +26595,7 @@ self: {
      mkDerivation {
        pname = "biosff";
        version = "0.3.7.1";
-       sha256 = "1mxsqxcf5sh37gpfqil499i9n8wi3sk5sl2cx6x6agbc0n726bwq";
+       sha256 = "982f238e056c3d65bae94c505da61e91239b624a8446ecee3b03eae258c7bad7";
        isLibrary = true;
        isExecutable = true;
        libraryHaskellDepends = [ array base binary biocore bytestring ];
@@ -26556,7 +26615,7 @@ self: {
      mkDerivation {
        pname = "biostockholm";
        version = "0.3.4";
-       sha256 = "04k7cl8fjsi2mv60p2qg2nmy86z2adw9gzjnkxffqsc1q85y4lz7";
+       sha256 = "e753e20bc28169ec5c9f56fe977853e21be4ab150f8b0bccae226ae910656712";
        libraryHaskellDepends = [
          attoparsec attoparsec-conduit base biocore blaze-builder
          blaze-builder-conduit bytestring conduit containers deepseq
@@ -26579,7 +26638,7 @@ self: {
      mkDerivation {
        pname = "bird";
        version = "0.0.19";
-       sha256 = "0w380dcpk8gp5cx24nh6xlnibd6pw93wmxcajl26p4kd5cxbgfqz";
+       sha256 = "1fbbb73a2b6d926b04958af5ca47e2d7b4152ded065a223a2bf7a17959036870";
        isLibrary = true;
        isExecutable = true;
        libraryHaskellDepends = [
@@ -26599,7 +26658,7 @@ self: {
      mkDerivation {
        pname = "bit-array";
        version = "0.1.0";
-       sha256 = "0v04drr3m3096shp70l4iwqzva45szjhfl1yzaqblvn49hky8kns";
+       sha256 = "da4ee4274cc46ebab0fa3e5007e5d785a8fd318f848273a136098c3a726e046c";
        libraryHaskellDepends = [ base loch-th numeric-qq placeholders ];
        testHaskellDepends = [ base directory doctest filepath ];
        jailbreak = true;
@@ -26616,7 +26675,7 @@ self: {
      mkDerivation {
        pname = "bit-vector";
        version = "0.2.0";
-       sha256 = "1h3hm1akbj2qzl3df877hfgz3fanhvrj6czxvjbpcalpf3d6h5z1";
+       sha256 = "e11768da70972a7697dcfd3323f38656b9f19f83e720d706fd58c83555a870c0";
        libraryHaskellDepends = [ base vector ];
        testHaskellDepends = [
          base QuickCheck tasty tasty-quickcheck tasty-th vector
@@ -26631,7 +26690,7 @@ self: {
      mkDerivation {
        pname = "bitarray";
        version = "0.0.1.1";
-       sha256 = "00nqd62cbh42qqqvcl6iv1i9kbv0f0mkiygv4j70wfh5cl86yzxj";
+       sha256 = "b27f6f1065053a0e8e24fbf9382b7060af9962d8d150b631c682c0c58469d802";
        libraryHaskellDepends = [ array base ];
        homepage = "http://code.haskell.org/~bkomuves/";
        description = "Mutable and immutable bit arrays";
@@ -26647,7 +26706,7 @@ self: {
      mkDerivation {
        pname = "bitcoin-api";
        version = "0.12.1";
-       sha256 = "0c1ydggik4k3vj93bqk53privyblkwhd32jizw25qk5j34axwy69";
+       sha256 = "c978de1519b24c5c04ff518ad1209f74f91df31d65e23592dc639219df6b3e30";
        libraryHaskellDepends = [
          aeson base base58string binary bitcoin-block bitcoin-script
          bitcoin-tx bitcoin-types bytestring hexstring lens lens-aeson text
@@ -26670,7 +26729,7 @@ self: {
      mkDerivation {
        pname = "bitcoin-api-extra";
        version = "0.9.1";
-       sha256 = "1z6pppjgq6sy4q78k176pnr6y3lq369brqf0pg90v0qggl0cc8y4";
+       sha256 = "c423c6007d0f830dd2bbc0e1bc9219980e6fb2bde684890e265e1bfce4bdd7fc";
        libraryHaskellDepends = [
          base binary bitcoin-api bitcoin-block bitcoin-tx bytestring conduit
          lens stm stm-chans stm-conduit text transformers
@@ -26691,7 +26750,7 @@ self: {
      mkDerivation {
        pname = "bitcoin-block";
        version = "0.13.1";
-       sha256 = "0nkx86fwv65x9vz6ni6qgz61afnvcifw2g92bnwdli8hww7prxfp";
+       sha256 = "d7f57c0fe71045dab85d223dc15d64db3a15cc7fd8446bfe4ebd98cd9d417d5a";
        libraryHaskellDepends = [
          base binary bitcoin-tx bitcoin-types bytestring cryptohash
          hexstring largeword lens
@@ -26713,7 +26772,7 @@ self: {
      mkDerivation {
        pname = "bitcoin-rpc";
        version = "0.5.0.1";
-       sha256 = "0bx54033w0yjb2isd7cvnd46qz3nqs7z6flw0mb1nkd81sdxbhp2";
+       sha256 = "e2c2d59b0ea84d1b56059c3af38fc6767c6c48b39b9da6a358d2033e0620a52f";
        libraryHaskellDepends = [
          aeson attoparsec base bytestring cereal containers ghc-prim HTTP
          mtl network text unix unordered-containers watchdog
@@ -26736,7 +26795,7 @@ self: {
      mkDerivation {
        pname = "bitcoin-script";
        version = "0.11.1";
-       sha256 = "0k3v35p6qpgh88gc5rqpcmh202xrn2rind9641dinwqqx631v31r";
+       sha256 = "398c1d86e918731b5b2026351bb3b0b90b20606517e7c21e42f05d6c6e197b4c";
        libraryHaskellDepends = [
          base base16-bytestring binary bytestring text
        ];
@@ -26753,7 +26812,7 @@ self: {
      mkDerivation {
        pname = "bitcoin-tx";
        version = "0.13.1";
-       sha256 = "006c55l6q6cknxw0k0kzr8vkv8azapfb4mkax6ac6rih6mjq5f1v";
+       sha256 = "3bb88265353066c394e96a56b2dc555fa13d37ca7f820978b793196c6829cc00";
        libraryHaskellDepends = [
          base binary bitcoin-script bitcoin-types bytestring cryptohash
          hexstring lens
@@ -26773,7 +26832,7 @@ self: {
      mkDerivation {
        pname = "bitcoin-types";
        version = "0.9.2";
-       sha256 = "02y4svhcsml37p78g4cm97kyigcakgf4hds4bxnp0r4ba1498bxp";
+       sha256 = "b72f9448508b64706d5f443748dc9b8abde8e749959187ce3d8356cde0d6c40b";
        libraryHaskellDepends = [
          base base58string binary bytestring hexstring text
        ];
@@ -26790,7 +26849,7 @@ self: {
      mkDerivation {
        pname = "bitly-cli";
        version = "0.1.2";
-       sha256 = "0g63lg3599clbn4xcg9kcak6hs4877dwj00607c5gyh5x4d2c21d";
+       sha256 = "2d08261ae905fa57d8010600c9db39886868a662333dd6895d94a554c6a3c33c";
        isLibrary = false;
        isExecutable = true;
        executableHaskellDepends = [
@@ -26808,7 +26867,7 @@ self: {
      mkDerivation {
        pname = "bitmap";
        version = "0.0.2";
-       sha256 = "1flrfbrsnlcal7qyvl1wb0p8c14w0mvvkmgs7d943jqnlh4gay5m";
+       sha256 = "b578f508a416cb41523bfad5b977059c04862e583cd0edf1a18a51abf37299ba";
        libraryHaskellDepends = [ base bytestring ];
        homepage = "http://code.haskell.org/~bkomuves/";
        description = "A library for handling and manipulating bitmaps (rectangular pixel arrays)";
@@ -26820,7 +26879,7 @@ self: {
      mkDerivation {
        pname = "bitmap-opengl";
        version = "0.0.1.5";
-       sha256 = "1wq1p0vvif750gpyh2kq3agzwga3hx0fq28irbw5dgrz462dd9pv";
+       sha256 = "fba6d684213fbf56f8ca1109ec4087433dfe9f1a780ae8ef03e5b8b837b801f3";
        libraryHaskellDepends = [ base bitmap OpenGL ];
        homepage = "http://code.haskell.org/~bkomuves/";
        description = "OpenGL support for Data.Bitmap.";
@@ -26834,7 +26893,7 @@ self: {
      mkDerivation {
        pname = "bitmaps";
        version = "0.2.6.3";
-       sha256 = "1cbfbbyvmdlfwn6pjhxkd8f4ajkp9cm18apzmrqffrj58gmzr1p0";
+       sha256 = "e086fceb434566e770aeff2a142a4b774a451c6ab343798de58eb6bafd5a6eb1";
        libraryHaskellDepends = [
          array base binary bitmap bytestring cereal containers monad-state
          stb-image string-class tagged zlib
@@ -26851,7 +26910,7 @@ self: {
      mkDerivation {
        pname = "bits";
        version = "0.4";
-       sha256 = "12s5yk47y0zqzqiyaw9jchyl3crf1id9dk67m638b070d46k29p6";
+       sha256 = "e626310d69e0808586a9c7cc965a0c2eb3413d643271e523fef8037fc8f4458b";
        libraryHaskellDepends = [ base bytes mtl transformers ];
        testHaskellDepends = [ base directory doctest filepath ];
        homepage = "http://github.com/analytics/bits";
@@ -26864,7 +26923,7 @@ self: {
      mkDerivation {
        pname = "bits-atomic";
        version = "0.1.3";
-       sha256 = "13fbakkwcdk63dm7r0mcsanm5mijp73c7x1kxpay2f03rxb39b70";
+       sha256 = "e0ac3456cf0338e1d5ed33f4c3c6b932d652add2ac827c6a1b6636c6e754cb8d";
        isLibrary = true;
        isExecutable = true;
        libraryHaskellDepends = [ base ];
@@ -26877,7 +26936,7 @@ self: {
      mkDerivation {
        pname = "bits-conduit";
        version = "0.2.0.0";
-       sha256 = "08hgl1pvwadnrgqcs1yl7lvqgh955swbscpay4chb097pqqggdrj";
+       sha256 = "32b7f730be27810519f1ea32bdb82e25c187373dd407cdf0cbb629be6fa00f22";
        libraryHaskellDepends = [ base bytestring conduit mtl ];
        testHaskellDepends = [ base bytestring conduit hspec HUnit mtl ];
        jailbreak = true;
@@ -26891,7 +26950,7 @@ self: {
      mkDerivation {
        pname = "bits-extras";
        version = "0.1.3";
-       sha256 = "0sy9dksmdx0773bsn8yi5hw4qpgn16g8aqqj888w1x75cbsxr997";
+       sha256 = "27a5dcf562e5f4c011421263859e09f65d4c382cd123abd73807f456f56cc96b";
        isLibrary = true;
        isExecutable = true;
        libraryHaskellDepends = [ base ];
@@ -26907,7 +26966,7 @@ self: {
      mkDerivation {
        pname = "bitset";
        version = "1.4.8";
-       sha256 = "0h912i3wb6v8sx0c4mlp0j65l3yhpdsk3my8zhif2jls2sxns988";
+       sha256 = "08256dbb169a4ae122fcc8d73175bbd00f5a8c049756c240d7689bc547142141";
        libraryHaskellDepends = [ base deepseq ghc-prim integer-gmp ];
        librarySystemDepends = [ gmp ];
        testHaskellDepends = [ base QuickCheck tasty tasty-quickcheck ];
@@ -26924,7 +26983,7 @@ self: {
      mkDerivation {
        pname = "bitspeak";
        version = "0.0.3";
-       sha256 = "02dyi59lp6blrvsc10ahjnra1vaz3kzb8h0jpk74k7n6flia8z1k";
+       sha256 = "337ca42275c69e49cebc1240b4fe1c5feda0b2955081c0f4ce74994b5389be09";
        isLibrary = false;
        isExecutable = true;
        executableHaskellDepends = [
@@ -26944,7 +27003,7 @@ self: {
      mkDerivation {
        pname = "bitstream";
        version = "0.2.0.4";
-       sha256 = "1j00r6jv9yp0h476gz7yalrlnxhkrdrl1w73d3zl98kyf207q2sy";
+       sha256 = "5e0b7c80707ea244ff68e3f04073cb13764b3355fefc670e81e0fab4a5c900c8";
        libraryHaskellDepends = [
          base base-unicode-symbols bytestring vector
        ];
@@ -26961,7 +27020,7 @@ self: {
      mkDerivation {
        pname = "bitstring";
        version = "0.0.0";
-       sha256 = "1ix2x4v76wq5148k1aax69cf8sk14cd0z362dz1d2qmj9qxsnsw8";
+       sha256 = "886bab3b4eb262d1c26fc28c0f1a23616ae458325da930110905737336e9a2c7";
        libraryHaskellDepends = [ base bytestring ];
        homepage = "http://code.haskell.org/~bkomuves/";
        description = "Lazy bit strings";
@@ -26982,7 +27041,7 @@ self: {
      mkDerivation {
        pname = "bittorrent";
        version = "0.0.0.3";
-       sha256 = "155bbqqn33mlavvcm6xfxs4dqij66jfhqxjmrjkyxvzd36yz0ann";
+       sha256 = "d62af0bd19edefeea7cc55760c9d344646dc88eeae9bcaf656b48e61315eab94";
        libraryHaskellDepends = [
          aeson base base16-bytestring base32-bytestring base64-bytestring
          bencoding binary binary-conduit bits-extras BoundedChan bytestring
@@ -27010,7 +27069,7 @@ self: {
      mkDerivation {
        pname = "bitvec";
        version = "0.1.0.1";
-       sha256 = "0zgg72qpxgcgjrr2lr702abibnm79h6knb3jcwdjcxssgb6l70q4";
+       sha256 = "048343cd7a5a77261b67722c3b0d4ca7da159712e0642a72968fbd7eb138ef7d";
        libraryHaskellDepends = [ base primitive vector ];
        testHaskellDepends = [
          base HUnit primitive QuickCheck test-framework test-framework-hunit
@@ -27026,7 +27085,7 @@ self: {
      mkDerivation {
        pname = "bitwise";
        version = "0.1.0.2";
-       sha256 = "195g09frdyyn3wsb4jyspdmz8dlmpymqdlbss6zyslkddkrs8hdf";
+       sha256 = "ae41a4f36c6d52edbfd17ad186abbf9536f46bbbda4bb2341fd6fb965d02afa4";
        libraryHaskellDepends = [ array base bytestring ];
        testHaskellDepends = [ base QuickCheck ];
        homepage = "http://code.mathr.co.uk/bitwise";
@@ -27036,22 +27095,23 @@ self: {
 
   "bitx-bitcoin" = callPackage
     ({ mkDerivation, aeson, base, bytestring, hspec, http-conduit
-     , network, record, scientific, split, text, time
+     , http-types, microlens, microlens-th, network, scientific, split
+     , text, time
      }:
      mkDerivation {
        pname = "bitx-bitcoin";
-       version = "0.2.0.2";
-       sha256 = "0m91zh2g6ahpzwgfhj2phhghylgjp6qksca741bdffkax7xd6x17";
+       version = "0.4.0.0";
+       sha256 = "6c04902ab1ce6600373ba1f477878a17c6cfe00c3417596a3c96f22dbbfe492f";
        libraryHaskellDepends = [
-         aeson base bytestring http-conduit network record scientific split
-         text time
+         aeson base bytestring http-conduit http-types microlens
+         microlens-th network scientific split text time
+       ];
+       testHaskellDepends = [
+         aeson base bytestring hspec microlens time
        ];
-       testHaskellDepends = [ aeson base bytestring hspec record time ];
-       jailbreak = true;
        homepage = "https://github.com/tebello-thejane/bitx-haskell";
        description = "A Haskell library for working with the BitX bitcoin exchange";
        license = stdenv.lib.licenses.publicDomain;
-       hydraPlatforms = stdenv.lib.platforms.none;
      }) {};
 
   "bk-tree" = callPackage
@@ -27059,7 +27119,7 @@ self: {
      mkDerivation {
        pname = "bk-tree";
        version = "0.1.1";
-       sha256 = "0av4gkh2vr9righ26hbagh8j30i8k4sp3af98lmwm5gf81vs5az4";
+       sha256 = "e4aba27740ee95ca2b45c9a9713599288221117c6a4123e08b39e52de07c642b";
        libraryHaskellDepends = [ base containers ];
        homepage = "https://github.com/bitonic/language-spelling";
        description = "BK-tree implementation";
@@ -27074,7 +27134,7 @@ self: {
      mkDerivation {
        pname = "bkr";
        version = "0.1.2";
-       sha256 = "1zi429ny66qp3ywlqfg7y0xk472vxh4z572a4c8rbzpx5lgiypxs";
+       sha256 = "ba5f1f1f2dfdfe9511234a9cf209ec5b1c323bf0e7394cb91f171be36d1224fe";
        isLibrary = true;
        isExecutable = true;
        libraryHaskellDepends = [
@@ -27097,7 +27157,7 @@ self: {
      mkDerivation {
        pname = "bktrees";
        version = "0.3.1";
-       sha256 = "1d2iz48n0ayn0hi9xa110pxy1mv5a4m21rmbpvs6ki1a7cv4ghn9";
+       sha256 = "c9c247363b2ac469f4beabe6202a5165d7e0fb0521a89e2204d62b6011f951b4";
        libraryHaskellDepends = [ array base containers ];
        description = "A set data structure with approximate searching";
        license = stdenv.lib.licenses.bsd3;
@@ -27108,7 +27168,7 @@ self: {
      mkDerivation {
        pname = "bla";
        version = "2009.10.20";
-       sha256 = "1zb076m4673jmvzazwjjmlw3nrnw0j22hiim6r90014sqcpb6xhp";
+       sha256 = "1776b32ec39a040052363546288404dc663b38ad52f2affeae721c43aa3960fd";
        isLibrary = false;
        isExecutable = true;
        executableHaskellDepends = [ base haskell98 unix ];
@@ -27126,7 +27186,7 @@ self: {
      mkDerivation {
        pname = "black-jewel";
        version = "0.0.0.1";
-       sha256 = "1ki6kdmc5ss0dp7jrhv9zx9a93f2p38q7i57n0y94awyv5772yla";
+       sha256 = "8a7a714ed99e2b923cb0a7c483d1b8c28da452ff69c32ccf6d40ebc26a9b26ce";
        isLibrary = false;
        isExecutable = true;
        executableHaskellDepends = [
@@ -27148,7 +27208,7 @@ self: {
      mkDerivation {
        pname = "blacktip";
        version = "0.1.0.1";
-       sha256 = "12s05l348q6xlhrwhh2i5v04i9bglvb00vpy25j5axdv5k8nwn62";
+       sha256 = "c2586ed12cbb75556411fe6e00d6a66fa548c02e5140c833a4dd6044062d408b";
        libraryHaskellDepends = [
          base bitwise bytestring deepseq deepseq-generics locators
          network-info safe split system-fileio system-filepath time
@@ -27164,7 +27224,7 @@ self: {
      mkDerivation {
        pname = "blakesum";
        version = "0.5";
-       sha256 = "15k3vf9jqcw1a9gyppkhn5ibj7ld8mb2irfhbwd3plj86xyxxa0g";
+       sha256 = "0fa8de7d3748d23b1a5fd0e52856458d1eb962b170deeb5f5281332c93db6396";
        libraryHaskellDepends = [ base bytestring text vector ];
        jailbreak = true;
        homepage = "https://github.com/killerswan/Haskell-BLAKE";
@@ -27180,7 +27240,7 @@ self: {
      mkDerivation {
        pname = "blakesum-demo";
        version = "0.5";
-       sha256 = "1d07005fd670p74vkyi9gg3wawyi21s37ww69fsrrgarf3i5p4m9";
+       sha256 = "a9925be27059bd9cb54b86f3337410d173c5c77b29fab9c9b9e098e60a0007b4";
        isLibrary = false;
        isExecutable = true;
        executableHaskellDepends = [
@@ -27201,7 +27261,7 @@ self: {
      mkDerivation {
        pname = "blank-canvas";
        version = "0.5";
-       sha256 = "05kfyjp9vncyzsvq018ilb8vh7fyzbc06nlx35jk3dzj6i6x5bgs";
+       sha256 = "faadd24d34f2b73165199d5a03d8fade1db8d1a2110580b7fe9ed99daef46e16";
        revision = "1";
        editedCabalFile = "a9d9c32056144a2e5b84e96dfb3a5334aa89dc616c759e523c538a6b950d5084";
        libraryHaskellDepends = [
@@ -27221,7 +27281,7 @@ self: {
      mkDerivation {
        pname = "blas";
        version = "0.7.6";
-       sha256 = "1q6fkw2bsppymy5wi7mgkl09caij52xplw64786548z9i95r0bli";
+       sha256 = "912e904b8ae923520c3ac4707abb28322a96009daf9ec88baffe5ebd049fcee0";
        libraryHaskellDepends = [ base ieee QuickCheck storable-complex ];
        jailbreak = true;
        homepage = "http://github.com/patperry/blas";
@@ -27235,7 +27295,7 @@ self: {
      mkDerivation {
        pname = "blas-hs";
        version = "0.1.1.0";
-       sha256 = "11mhjvqjnap4lj70f6lxjrjrdlkw8gnmd1lz4cfkjawq4w4npq40";
+       sha256 = "80e06b0927982b391d239f8656ed437cd29665969d1a078ea4e42a2bf196b086";
        libraryHaskellDepends = [ base storable-complex ];
        librarySystemDepends = [ blas ];
        testHaskellDepends = [ base vector ];
@@ -27250,7 +27310,7 @@ self: {
      mkDerivation {
        pname = "blastxml";
        version = "0.3.2";
-       sha256 = "0slqvv8729vlniwswwipw3yss9id6xvmd416kad1ij064g28j00c";
+       sha256 = "0c0089c42306c8189a9a26905677372d26adfde03772ae79b4742771d0de986a";
        libraryHaskellDepends = [
          base biocore bytestring parallel tagsoup
        ];
@@ -27264,7 +27324,7 @@ self: {
      mkDerivation {
        pname = "blaze";
        version = "0.0.2";
-       sha256 = "01n6cw3fjmlj5pmdy122ch4kbf6srvwlz356rr6nxfrm0ndcxp38";
+       sha256 = "68dcce9a0535bb6e4dcea68c4ff9cedab83509644204dfea2d9256e90667c606";
        description = "None";
        license = stdenv.lib.licenses.bsd3;
        hydraPlatforms = stdenv.lib.platforms.none;
@@ -27275,7 +27335,7 @@ self: {
      mkDerivation {
        pname = "blaze-bootstrap";
        version = "0.1.0.0";
-       sha256 = "1q1gwjg8xfp20lrlrlkdprny7j437fsnm5c9p5rv4549nyam7prw";
+       sha256 = "3cdf5395b78914b273b989956ab53b83c8e36dbe6dd24c3305e2ba8e9ee42fe0";
        libraryHaskellDepends = [ base blaze-html text ];
        jailbreak = true;
        homepage = "http://github.com/agrafix/blaze-bootstrap";
@@ -27291,7 +27351,7 @@ self: {
      mkDerivation {
        pname = "blaze-builder";
        version = "0.4.0.1";
-       sha256 = "1id3w33x9f7q5m3xpggmvzw03bkp94bpfyz81625bldqgf3yqdn1";
+       sha256 = "c136ec877bb8d1558409e87b77174977ae01f8dff5bddb472df8b8d4c7e0a3c5";
        libraryHaskellDepends = [ base bytestring deepseq text ];
        testHaskellDepends = [
          base bytestring HUnit QuickCheck test-framework
@@ -27307,7 +27367,7 @@ self: {
      mkDerivation {
        pname = "blaze-builder-conduit";
        version = "1.1.0";
-       sha256 = "0xxyn3lhcn1bkybhrl5dx68d0adf26ilf34gv0mxkwpfj7m7d3k3";
+       sha256 = "638e76ea91eef2d92bd88f0c47a311ae29d090e9add00c979f2b5806e9b0be77";
        libraryHaskellDepends = [ base conduit ];
        homepage = "http://github.com/snoyberg/conduit";
        description = "Convert streams of builders to streams of bytestrings. (deprecated)";
@@ -27321,7 +27381,7 @@ self: {
      mkDerivation {
        pname = "blaze-builder-enumerator";
        version = "0.2.1.0";
-       sha256 = "15mz4dfnngll61b1xv3hfazvzjfd8g9ym0hps1qiks1hl4c2kxah";
+       sha256 = "50f52918a130e81971d01782ead343cdc9bfbf7270ec1e5630943e6b5d23bf96";
        revision = "1";
        editedCabalFile = "28796d33301d22cfca6188f54699d9efd7721802bc5e9c88a394bec14c9c4fae";
        libraryHaskellDepends = [
@@ -27338,7 +27398,7 @@ self: {
      mkDerivation {
        pname = "blaze-from-html";
        version = "0.3.2.1";
-       sha256 = "1li3zxrgwj5rgk894d9zwfxnx5dfjzkvjlcyck2g7s0awfp2kq4s";
+       sha256 = "9ae029aee30ae8f3c4649e51b9e797ae956ebbe33f3592d07cb948fe72ff23d2";
        isLibrary = false;
        isExecutable = true;
        executableHaskellDepends = [
@@ -27357,7 +27417,7 @@ self: {
      mkDerivation {
        pname = "blaze-html";
        version = "0.8.1.0";
-       sha256 = "0cgddwdwjszhcd3grfxazvy6jwaxa90s8yw6ir9ji2apbdsw0vgv";
+       sha256 = "fb6dc0755b578928538e867ba441525d7169fcfeaabbfc4663f06bc91b6fed31";
        libraryHaskellDepends = [
          base blaze-builder blaze-markup bytestring text
        ];
@@ -27378,7 +27438,7 @@ self: {
      mkDerivation {
        pname = "blaze-html-contrib";
        version = "0.2.2";
-       sha256 = "0a10vzbd5l32y716nmgc49rj2gpyavl8fl1z4qs5drx9adwj50cf";
+       sha256 = "8e81227953a9e75634263f5087e856fe3e217322ec556bc2f162d0d2d6df2028";
        libraryHaskellDepends = [
          base blaze-html cgi data-default network safe text
        ];
@@ -27393,7 +27453,7 @@ self: {
      mkDerivation {
        pname = "blaze-html-hexpat";
        version = "0.1.0.0";
-       sha256 = "11bw5ywvi7dlz5inch3z0vlg936ch1rnp99bh4nmwskvszidd7kg";
+       sha256 = "6f9ed6e2d77b6a5e2d812ba56b7380cc8cf4e8067f406663f9b49db8b92f7c85";
        libraryHaskellDepends = [ base blaze-html bytestring hexpat text ];
        jailbreak = true;
        homepage = "https://github.com/jaspervdj/blaze-html-hexpat";
@@ -27409,7 +27469,7 @@ self: {
      mkDerivation {
        pname = "blaze-html-truncate";
        version = "0.3.0.0";
-       sha256 = "1czjqxaik1c9ialdwh8inh5iajl87lrnfa9rxnidzvfhc7ks9zbl";
+       sha256 = "74fda4e761d0eddfa2ed392967333d884a150bb41141dea88a89851955c7f2b3";
        libraryHaskellDepends = [
          base blaze-markup bytestring html-truncate tagsoup text
        ];
@@ -27426,7 +27486,7 @@ self: {
      mkDerivation {
        pname = "blaze-json";
        version = "0.2.1";
-       sha256 = "1jqrvv485qyscjppgq2kh6cvhd2lwwqq7gd69ynmrp3qllsc8x83";
+       sha256 = "0375c434a578dc5cad4fa6bd8331e75434b8998153e077af64dae382c8de19cb";
        libraryHaskellDepends = [
          base bytestring bytestring-builder containers data-default-class
          text
@@ -27449,7 +27509,7 @@ self: {
      mkDerivation {
        pname = "blaze-markup";
        version = "0.7.0.2";
-       sha256 = "0p3jsl7ng3fapvbp431cm1bckdwjgc1kmijyvxlgxn1l90l8l1p4";
+       sha256 = "e4068a284834d8fe68df5ec63a037b92b7c956a82c0c72d7beca8d670fd5725c";
        libraryHaskellDepends = [ base blaze-builder bytestring text ];
        testHaskellDepends = [
          base blaze-builder bytestring containers HUnit QuickCheck
@@ -27465,7 +27525,7 @@ self: {
      mkDerivation {
        pname = "blaze-svg";
        version = "0.3.4.1";
-       sha256 = "1bfxl2jwr622kgf4gz4gqpdrvscciqpfyzy6qad8j7w633xg8vrp";
+       sha256 = "376ff4fa18861f899ac2c67fef2e8e8ce99ddbc58ffc47dc9b4298cca5a0ddad";
        libraryHaskellDepends = [ base blaze-markup mtl ];
        homepage = "https://github.com/deepakjois/blaze-svg";
        description = "SVG combinator library";
@@ -27480,7 +27540,7 @@ self: {
      mkDerivation {
        pname = "blaze-textual";
        version = "0.2.1.0";
-       sha256 = "0bbcykkrlgdb6jaz72njriq9if6bzsx52jn26k093f5sn1d7jhhh";
+       sha256 = "1042795ab0bab891c034c24a51bafecbb89870ccd28af39534ab3d9ae7f46c2d";
        libraryHaskellDepends = [
          base blaze-builder bytestring ghc-prim integer-gmp old-locale text
          time vector
@@ -27501,7 +27561,7 @@ self: {
      mkDerivation {
        pname = "blaze-textual-native";
        version = "0.2.1.1";
-       sha256 = "1q3gdf4ljc5xhw8f72qkvi6insk2nwdfk28a00y1b58jmk8003sd";
+       sha256 = "4d0f00d0ac1295153c000a89e91ab7626a1b4ddc138be31087bd3049896b6fe0";
        libraryHaskellDepends = [
          base blaze-builder bytestring ghc-prim integer-gmp old-locale text
          time vector
@@ -27518,7 +27578,7 @@ self: {
      mkDerivation {
        pname = "blazeMarker";
        version = "0.1.0.0";
-       sha256 = "03gx3ylxz7xa86ngi33dm347ni6a4mcq4fizlx3majpfdk5fs38c";
+       sha256 = "0c0dedca6cee4a5547a73f3a825925ca447bc8a86d8cf8ac41aa9fdfa91ffd0d";
        libraryHaskellDepends = [ base blaze-html blaze-markup ];
        description = "...";
        license = stdenv.lib.licenses.mit;
@@ -27530,7 +27590,7 @@ self: {
      mkDerivation {
        pname = "blink1";
        version = "0.4";
-       sha256 = "0547wg4qk2xv5gzj1alaxk06j65dhmzhn6y48rjllyr4lc5bm2qj";
+       sha256 = "128bba0aa3247b4a6546c41b0b7f85ad1869c0ec8aaa20ff2bbb8b89c9e38714";
        isLibrary = true;
        isExecutable = true;
        libraryHaskellDepends = [ base unix ];
@@ -27546,7 +27606,7 @@ self: {
      mkDerivation {
        pname = "blip";
        version = "0.2.1";
-       sha256 = "0ilzdjfaq8dzfla0kxgkqbjsba0kbgkz8w5bzlhl0fw6rnaa0hn7";
+       sha256 = "c742a094cd863b4021fdab70f4e75b13a8a5e5c2f3f5091475bf21ac9c6c9f46";
        isLibrary = false;
        isExecutable = true;
        executableHaskellDepends = [
@@ -27566,7 +27626,7 @@ self: {
      mkDerivation {
        pname = "bliplib";
        version = "0.2.1";
-       sha256 = "0i5lh78yyj82g08ypyfp01kgc56p6c3nrl9fk49bp2yqpghv65qz";
+       sha256 = "1f17b3e1bbd88bbb12992ed16c0733d714f66600d7f9eb11780249efd181b444";
        libraryHaskellDepends = [
          base binary bytestring containers mtl pretty utf8-string
        ];
@@ -27581,7 +27641,7 @@ self: {
      mkDerivation {
        pname = "blocking-transactions";
        version = "0.1.0.5";
-       sha256 = "00xlj503h6073f9sk7a1p2b66nw2lryyvxxbawwz030mjdb6hgps";
+       sha256 = "fa3e685693150cf03957abf7ed7da6825b6396b8419da9931b0718384091b403";
        libraryHaskellDepends = [ base containers parallel ];
        homepage = "http://www.downstairspeople.org/git/blocking-transactions.git";
        description = "Composable, blocking transactions";
@@ -27596,7 +27656,7 @@ self: {
      mkDerivation {
        pname = "blogination";
        version = "0.5";
-       sha256 = "0bdhcjiz2b4zavmixvrl5la91s9z5pra05xk52118cjk4dcfdzfg";
+       sha256 = "cffde658235332148228b317a0f22d3fe990142d34ef1eeb569f2cf1a364b02d";
        isLibrary = true;
        isExecutable = true;
        libraryHaskellDepends = [
@@ -27619,7 +27679,7 @@ self: {
      mkDerivation {
        pname = "bloodhound";
        version = "0.7.0.1";
-       sha256 = "1r66nb6vbq1pbh2a97wmsk9iav16ac4ppj5yjv3s5l8qc0rydmjs";
+       sha256 = "5ad6e6336018d1a2c796bec87b0953266c15d3d4959fa4045c37e0b5cdb2c6e4";
        libraryHaskellDepends = [
          aeson base blaze-builder bytestring containers data-default-class
          exceptions http-client http-types mtl semigroups text time
@@ -27643,7 +27703,7 @@ self: {
      mkDerivation {
        pname = "bloomfilter";
        version = "2.0.1.0";
-       sha256 = "03vrmncg1c10a2wcg5skq30m1yiknn7nwxz2gblyyfaxglshspkc";
+       sha256 = "6c5e0d357d5d39efe97ae2776e8fb533fa50c1c05397c7b85020b0f098ad790f";
        libraryHaskellDepends = [ array base bytestring deepseq ];
        testHaskellDepends = [
          base bytestring QuickCheck random test-framework
@@ -27659,7 +27719,7 @@ self: {
      mkDerivation {
        pname = "bloxorz";
        version = "0.1.2";
-       sha256 = "0cryvs5ia52dkc232cl2crhf0qq7ncir5c3zvrgsbzcc2hnmyrww";
+       sha256 = "9c675f2d148cfda55fde7fb09223b30763e06066823231049b4d14158bde3e33";
        isLibrary = false;
        isExecutable = true;
        executableHaskellDepends = [ base GLFW OpenGL ];
@@ -27674,7 +27734,7 @@ self: {
      mkDerivation {
        pname = "blubber";
        version = "0.0.1";
-       sha256 = "0bc30pw6gvw7i6gh58hhkgx2j432zlh2wh4d41abnkjqygifsxsd";
+       sha256 = "4d77ede2f3584ebb54208d402e20fd621029fa9b10a2029f8987ef67f805832d";
        isLibrary = false;
        isExecutable = true;
        executableHaskellDepends = [
@@ -27693,7 +27753,7 @@ self: {
      mkDerivation {
        pname = "blubber-server";
        version = "0.0.1";
-       sha256 = "12f594sl2c2hrxr95bpv911x0bdfpmaflp29mhw2yln2vh64nhj5";
+       sha256 = "45424b0cdcc2522f38ac495cea54bdae2dd04348fbae9272cf5030413549c589";
        isLibrary = true;
        isExecutable = true;
        libraryHaskellDepends = [ base cereal containers random ];
@@ -27715,7 +27775,7 @@ self: {
      mkDerivation {
        pname = "bluetile";
        version = "0.6";
-       sha256 = "13xfnx08xgbfppr4cqmrqj82w192ll4m1x4kmv5jdpk02yb4zqa2";
+       sha256 = "42e14f961760de26cbae93f45009a522052e90c4b96246f2bd6ebd8e40b7ae8f";
        isLibrary = false;
        isExecutable = true;
        executableHaskellDepends = [
@@ -27734,7 +27794,7 @@ self: {
      mkDerivation {
        pname = "bluetileutils";
        version = "0.2";
-       sha256 = "1qna8rr50mmd90xp7pwhcknx12dv2n7w5pdsw28kpbxykljrszgm";
+       sha256 = "f57d9d259dbeaf3b91e0baddc28f15bb89d0ed6490df733b48ad56507246cae2";
        isLibrary = false;
        isExecutable = true;
        executableHaskellDepends = [ base gtk ];
@@ -27751,7 +27811,7 @@ self: {
      mkDerivation {
        pname = "blunt";
        version = "1.0.2";
-       sha256 = "1p0mwpjvrv9d0b0gp6s55zys9vcbhpjsjbi711f5x4dagdl0xkhc";
+       sha256 = "0cce0e687baa915e5c08272ea9e5858beda4fd2f459bfbc0022dedbce5e515dc";
        isLibrary = true;
        isExecutable = true;
        libraryHaskellDepends = [
@@ -27771,7 +27831,7 @@ self: {
      mkDerivation {
        pname = "bmp";
        version = "1.2.5.2";
-       sha256 = "0f88f2ynm1fpzbjijy5fa8blfrdv42h5h28hfjlpd4fp0h96in5x";
+       sha256 = "bdd8681204d79176a974100958a020bb65471752ae7819e5fad7856abd700839";
        libraryHaskellDepends = [ base binary bytestring ];
        homepage = "http://code.ouroborus.net/bmp";
        description = "Read and write uncompressed BMP image files";
@@ -27785,7 +27845,7 @@ self: {
      mkDerivation {
        pname = "board-games";
        version = "0.1.0.1";
-       sha256 = "12b5hzazqilwwj0535wrh6i9r6lxi7lbzl727470mvzlr8p8lkyz";
+       sha256 = "df4f8a2ecaf4ef0a0e39e2d0bfe8899d9a9ca28199975180e49c46fcd5876589";
        isLibrary = true;
        isExecutable = true;
        libraryHaskellDepends = [
@@ -27812,7 +27872,7 @@ self: {
      mkDerivation {
        pname = "bogre-banana";
        version = "0.0.1";
-       sha256 = "0zlrm911sbszxyffz18yf64935iv8s2yk3v8v6cwjij69haryvwi";
+       sha256 = "916f9f154c4646c999d9688fe985463b969188711e85ef9cef5f2f1d42aa997e";
        isLibrary = true;
        isExecutable = true;
        libraryHaskellDepends = [
@@ -27828,7 +27888,7 @@ self: {
      mkDerivation {
        pname = "bool-extras";
        version = "0.4.0";
-       sha256 = "008m43f04ncx2c24c241gzwjyyglw8rwpq2gsakqkw0nwz3czs61";
+       sha256 = "c1e8cfc6e716f089a7d24fe0cb33e2f4792ff97f81084604139d5902dc201501";
        libraryHaskellDepends = [ base ];
        homepage = "http://tom.lokhorst.eu/bool-extras";
        description = "A fold function for Bool";
@@ -27840,7 +27900,7 @@ self: {
      mkDerivation {
        pname = "boolean-list";
        version = "0.1.0.0";
-       sha256 = "0yr1szkaaz90nmawzrgfljv7hcd59xs7nr2fhc2rb4582crkykvp";
+       sha256 = "774f3f3313a8909505834e647b744fa53178b6a4eee5cf55b5207da5e6d7217b";
        libraryHaskellDepends = [ base bytestring HUnit ];
        homepage = "http://xy30.com";
        description = "convert numbers to binary coded lists";
@@ -27854,7 +27914,7 @@ self: {
      mkDerivation {
        pname = "boolean-normal-forms";
        version = "0.0.0.1";
-       sha256 = "11y26whzibxkcfck83lcrmxl34j7qp374wj6nzx2k3l65sdqm2ic";
+       sha256 = "2c8a8a9b2e868e29fab7467272c6c54792417bcd8c0e349963b3aff82137c287";
        libraryHaskellDepends = [ base cond containers ];
        testHaskellDepends = [
          base cond containers QuickCheck tasty tasty-quickcheck
@@ -27870,7 +27930,7 @@ self: {
      mkDerivation {
        pname = "boolexpr";
        version = "0.1";
-       sha256 = "14v894clplpcc1visqn337p7vmacj5hgx41vr60pwvflmv98d8xn";
+       sha256 = "b6a386d2aed46d7e81c93b90fe60914cd57dee19c3621d7760ecd24b19496893";
        libraryHaskellDepends = [ base parsec ];
        description = "Boolean expressions with various representations and search queries";
        license = stdenv.lib.licenses.bsd3;
@@ -27881,7 +27941,7 @@ self: {
      mkDerivation {
        pname = "bools";
        version = "0.1.1";
-       sha256 = "0057303m23p81v60jcsc3p7n2rs2rzrvbg5m18pc0fk95q2q2rim";
+       sha256 = "356681052e693ac02e0ab5bcb5f3cf426761cf1d4c3309cc0ee80e510718a700";
        description = "None";
        license = stdenv.lib.licenses.bsd3;
        hydraPlatforms = stdenv.lib.platforms.none;
@@ -27892,7 +27952,7 @@ self: {
      mkDerivation {
        pname = "boolsimplifier";
        version = "0.1.8";
-       sha256 = "13w2i7b2g9w5kzqnbjjdzf3r2dm7a4xxags02khhwlj1f8vsjvq9";
+       sha256 = "096fa9377241520ee114403fd53b51a7369187fb4dca65f19f85a727d689828f";
        libraryHaskellDepends = [ base containers ];
        description = "Simplification tools for simple propositional formulas";
        license = stdenv.lib.licenses.bsd3;
@@ -27906,7 +27966,7 @@ self: {
      mkDerivation {
        pname = "boomange";
        version = "0.1.3.1";
-       sha256 = "1sg1ldrglhca62xiak33k5023zrpmgg3aa8xpwn8l1323kwlkqm0";
+       sha256 = "a0e249f91c62048a2cbf1d2935deab37ff214099634c15bb308a41fa72a3e1e9";
        isLibrary = false;
        isExecutable = true;
        executableHaskellDepends = [
@@ -27921,7 +27981,7 @@ self: {
      mkDerivation {
        pname = "boomerang";
        version = "1.4.5";
-       sha256 = "03iaasyg2idvq25wzzjk2yr9lyql7bcgmfkycy1cy4ms5dg91k6q";
+       sha256 = "d8cc905e2bba12cf82677ebafad83a147b9ab21753fecf8bc0bb45f1bc562a0e";
        libraryHaskellDepends = [ base mtl template-haskell text ];
        description = "Library for invertible parsing and printing";
        license = stdenv.lib.licenses.bsd3;
@@ -27935,7 +27995,7 @@ self: {
      mkDerivation {
        pname = "boomslang";
        version = "0.0.4";
-       sha256 = "0yqqb4s5ld4fv7x17d5dp7z2dglrcmgb7fr4n8x4n2pysylxm9nh";
+       sha256 = "d0a6daa9d7fe0a4b3ab224bbb35e6599be26feb9adb413fad98e345a3459187b";
        isLibrary = false;
        isExecutable = true;
        executableHaskellDepends = [
@@ -27959,7 +28019,7 @@ self: {
      mkDerivation {
        pname = "borel";
        version = "0.18.0";
-       sha256 = "0daayl70l8afpf6l4822nz2cqjy2k8zbrj89apipjbynsq543453";
+       sha256 = "a390410ad6d62f79e35509c9bc3e9ac24bccc4b74220428dbb4e210a0ef54a35";
        libraryHaskellDepends = [
          aeson async attoparsec base bimap cassava ceilometer-common
          chevalier-common configurator containers errors hslogger lens
@@ -27987,7 +28047,7 @@ self: {
      mkDerivation {
        pname = "bot";
        version = "0.3";
-       sha256 = "0crs1c6v298zqkjzkdgicigx22gvp9xv7bjlynbyckvx0lrvfmrc";
+       sha256 = "2c57b733057d4fe697f554aeb37bbafb09d15f64f1b5f9e5c41f25b10d0b3a33";
        libraryHaskellDepends = [ arrows base Stream ];
        homepage = "http://haskell.org/haskellwiki/Bot";
        description = "bots for functional reactive programming";
@@ -28000,7 +28060,7 @@ self: {
      mkDerivation {
        pname = "botpp";
        version = "0.1";
-       sha256 = "0ir6h4zkj05na1gyf7h97s832jkphh33c9qjk2i290d0q9y8s4fw";
+       sha256 = "dc118d7cc2a08124a2981227360684774a31903e091ee75f50b600393f812647";
        isLibrary = true;
        isExecutable = true;
        libraryHaskellDepends = [ base bytestring ];
@@ -28017,7 +28077,7 @@ self: {
      mkDerivation {
        pname = "bound";
        version = "1.0.6";
-       sha256 = "0i1q6pv7d7vy9agb6yzj0mi8hq8154wv17qhwkf4jd87k07xv76v";
+       sha256 = "db9cdd0f98073549dce4109fb039290161886205f27bb39e4a7e9f76f6353844";
        libraryHaskellDepends = [
          base bifunctors binary bytes cereal comonad hashable
          hashable-extras prelude-extras profunctors transformers
@@ -28036,7 +28096,7 @@ self: {
      mkDerivation {
        pname = "bound-gen";
        version = "0.1.0.2";
-       sha256 = "1il4vb497d0195mhvra5djkn3mbdzd8dmcnffpqh1pv1pj8n8hwp";
+       sha256 = "97436491bc61df00f175ceb2da50fb6dd561a76c45e50d6b4901b493c8da84c6";
        libraryHaskellDepends = [ base bound monad-gen mtl ];
        description = "Unwrap Scope's with globally fresh values";
        license = stdenv.lib.licenses.mit;
@@ -28047,7 +28107,7 @@ self: {
      mkDerivation {
        pname = "bounded-tchan";
        version = "0.2.3";
-       sha256 = "12c78dz3y1ly05hckd9pf0j4fpknk383qyb5yrhps4sc2m3i9k9w";
+       sha256 = "3ccd1447154c137d61f665793cd098765e47247037b5c960019e063f7e438789";
        libraryHaskellDepends = [ base stm ];
        description = "Bounded Transactional channels (queues)";
        license = stdenv.lib.licenses.bsd3;
@@ -28058,7 +28118,7 @@ self: {
      mkDerivation {
        pname = "boundingboxes";
        version = "0.2.3";
-       sha256 = "0r3mffqxqadn8qklq3kr0ggirkficfj8ic1fxgki2zrc5jm4f2g8";
+       sha256 = "e80947aa2c2c7f11e7eb2eb088a463d1cd1cdf03790e4c2746b629dcb1737564";
        libraryHaskellDepends = [ base lens ];
        homepage = "https://github.com/fumieval/boundingboxes";
        description = "A generic boundingbox for an arbitrary vector";
@@ -28073,7 +28133,7 @@ self: {
      mkDerivation {
        pname = "bower-json";
        version = "0.7.0.0";
-       sha256 = "0vz9xxw2xr27lh70mqxfgvs43sr3sq88xf5vppcn2frsk1hnb7hs";
+       sha256 = "1a9e6561983a3b61d9bdbbb88e10d623eb41f47eaee30a0ea447e42e78efe96f";
        libraryHaskellDepends = [
          aeson aeson-better-errors base bytestring mtl scientific text
          transformers unordered-containers vector
@@ -28091,7 +28151,7 @@ self: {
      mkDerivation {
        pname = "boxes";
        version = "0.1.4";
-       sha256 = "1n7xiplzd3s1a39nizwjcgsh3wi2348mp21c3fk19v98ialfjgjf";
+       sha256 = "4e3ee9a88a28ed14a61b2c885b111922f201f56392ff68d350418ff6e98dfdd8";
        libraryHaskellDepends = [ base split ];
        testHaskellDepends = [ base QuickCheck split ];
        description = "2D text pretty-printing library";
@@ -28103,7 +28163,7 @@ self: {
      mkDerivation {
        pname = "bpann";
        version = "0.1.1";
-       sha256 = "02c8xyzs4kz9cx7ql48kq5cxf686vvd5mqrprkikynif9r4dk7w8";
+       sha256 = "889fd9484e2e5a3fe3cc37e35adade0619d759c113118a4f67e94fa2bfef8809";
        libraryHaskellDepends = [ base random split ];
        description = "backpropagation neuronal network";
        license = stdenv.lib.licenses.bsd3;
@@ -28114,7 +28174,7 @@ self: {
      mkDerivation {
        pname = "brainfuck";
        version = "0.1.0.2";
-       sha256 = "18xp0vlmh2n37x6rhczxw115cnips7vm9f560qsr395crqk5dzz9";
+       sha256 = "e9ff5626ceaca4913506a6b854f7d1375a5642e0fd33984d3fc30a58e906b7a3";
        isLibrary = true;
        isExecutable = true;
        libraryHaskellDepends = [ array base mtl ];
@@ -28128,7 +28188,7 @@ self: {
      mkDerivation {
        pname = "brainfuck-monad";
        version = "0.4.0";
-       sha256 = "14534i070l6w886sjp91yp9bfc2is5z6y7wzm8b6w4j9l78pfgmz";
+       sha256 = "bf3e77d1a149126e16aa9f1f6f7ed15130b7d2f5215da90d42dc50704024a390";
        libraryHaskellDepends = [ base ];
        description = "BrainFuck monad";
        license = stdenv.lib.licenses.bsd3;
@@ -28140,7 +28200,7 @@ self: {
      mkDerivation {
        pname = "brainfuck-tut";
        version = "0.7.0.0";
-       sha256 = "19x8mg15mscfrj1ppm32rzk8hhm4a2v498aq7sl3kkihrhp19x6j";
+       sha256 = "d2f4142ecc30ce39a83e58a144b650a44288e6cf62d47b83cc8ee95ac2aba8a7";
        isLibrary = true;
        isExecutable = true;
        libraryHaskellDepends = [ array base ];
@@ -28156,7 +28216,7 @@ self: {
      mkDerivation {
        pname = "break";
        version = "1.0.0";
-       sha256 = "15fqdha71i4ziv0ra8v2mfp0fviwgs27xlsvc0chb8icqf33y22m";
+       sha256 = "55083f86c32ca20519605bd37e847e3c6e07aeab622395c18e9fc470146cd895";
        libraryHaskellDepends = [ base mtl transformers ];
        description = "Break from a loop";
        license = stdenv.lib.licenses.bsd3;
@@ -28167,7 +28227,7 @@ self: {
      mkDerivation {
        pname = "breakout";
        version = "0.0.2";
-       sha256 = "04qs2r944jbb2i11dqlvrav8iaanrgp15jri0mq6nf8ccjldh3wr";
+       sha256 = "990fd8a8640c396b700531cb12eecb56a988b6ca9be21642146b494252161a13";
        isLibrary = false;
        isExecutable = true;
        executableHaskellDepends = [ base haskgame mtl SDL ];
@@ -28180,19 +28240,20 @@ self: {
   "breve" = callPackage
     ({ mkDerivation, aeson, base, binary, blaze-html, bytestring
      , configurator, cryptohash, directory, hashtables, http-types, mtl
-     , random, Spock, text, transformers, wai, wai-extra
+     , random, Spock, text, tls, transformers, wai, wai-extra
      , wai-middleware-static, warp, warp-tls, xdg-basedir
      }:
      mkDerivation {
        pname = "breve";
-       version = "0.4.0.0";
-       sha256 = "1ndzqwxj7dzff75mgjssh7sgrhxlicdwkcx8j71x52rxyav4aa0j";
+       version = "0.4.2.0";
+       sha256 = "51bcf984e0767649a336fe9658583e93326ffe039b9b0a83515d237d54902e61";
        isLibrary = false;
        isExecutable = true;
        executableHaskellDepends = [
          aeson base binary blaze-html bytestring configurator cryptohash
-         directory hashtables http-types mtl random Spock text transformers
-         wai wai-extra wai-middleware-static warp warp-tls xdg-basedir
+         directory hashtables http-types mtl random Spock text tls
+         transformers wai wai-extra wai-middleware-static warp warp-tls
+         xdg-basedir
        ];
        homepage = "https://github.com/rnhmjoj/breve";
        description = "a url shortener";
@@ -28204,7 +28265,7 @@ self: {
      mkDerivation {
        pname = "brians-brain";
        version = "0.0.1";
-       sha256 = "0a9gzclnqb28mm5gf2iiiby30qa0pwlwz3c115sim4lxpq60qran";
+       sha256 = "56650c0cbe9d921a7509818dcf29bf406130fc8a310af74aad482c6c29fb2f29";
        isLibrary = false;
        isExecutable = true;
        executableHaskellDepends = [ array base parallel random SDL ];
@@ -28214,6 +28275,27 @@ self: {
        hydraPlatforms = stdenv.lib.platforms.none;
      }) {};
 
+  "brick" = callPackage
+    ({ mkDerivation, base, containers, contravariant, data-default
+     , Diff, lens, template-haskell, text, text-zipper, transformers
+     , vector, vty
+     }:
+     mkDerivation {
+       pname = "brick";
+       version = "0.1";
+       sha256 = "b81c5276709795fd9fe14f2b456b36ee0f4ee399abaa2f738948492baf2fb230";
+       isLibrary = true;
+       isExecutable = true;
+       libraryHaskellDepends = [
+         base containers contravariant data-default Diff lens
+         template-haskell text text-zipper transformers vector vty
+       ];
+       executableHaskellDepends = [ base data-default lens text vty ];
+       homepage = "https://github.com/jtdaugherty/brick/";
+       description = "A declarative terminal user interface library";
+       license = stdenv.lib.licenses.bsd3;
+     }) {};
+
   "brillig" = callPackage
     ({ mkDerivation, base, binary, cmdargs, containers, directory
      , filepath, ListZipper, text
@@ -28221,7 +28303,7 @@ self: {
      mkDerivation {
        pname = "brillig";
        version = "0.3.1";
-       sha256 = "18gm24fd5ad6dgbqiwcs750rvq2v6lmclysd6acj2y8iybwcsg8n";
+       sha256 = "163dcdf8f211792199324d7bca2a355be09d41399af188d76ba6a9d21c11f5a1";
        isLibrary = true;
        isExecutable = true;
        libraryHaskellDepends = [
@@ -28241,7 +28323,7 @@ self: {
      mkDerivation {
        pname = "broadcast-chan";
        version = "0.1.0";
-       sha256 = "1dympzv8gwh31hd0x6ap29rm83rf2klkj34as2xjrayfs9kbp87s";
+       sha256 = "faa0bb66d2ceab2cbbd08a0c39e9142e0f54731257990e1a0c03f287f6bfd5b7";
        libraryHaskellDepends = [ base ];
        homepage = "https://github.com/merijn/broadcast-chan";
        description = "Broadcast channel type that avoids 0 reader space leaks";
@@ -28253,7 +28335,7 @@ self: {
      mkDerivation {
        pname = "broccoli";
        version = "0.4.1.0";
-       sha256 = "084nil9rfs3xpp4rk3qlwf6gsaljm57g7divfzd88dk9np6q5iwh";
+       sha256 = "90c782cdb5693684da773bb6f34ea9922afd8ce3148f99c9bd7d6897138d9620";
        libraryHaskellDepends = [ base containers stm time ];
        jailbreak = true;
        description = "Small library for interactive functional programs";
@@ -28265,7 +28347,7 @@ self: {
      mkDerivation {
        pname = "bsd-sysctl";
        version = "1.0.7";
-       sha256 = "18qs5s6sq6696w7y23fq6pd303j5bfh94lw86dz4z9hgdlmrx36y";
+       sha256 = "de8c9e2b6d0fa64f7e33885392a05b450e30da35d80de10f37c918ac8d2e1aa3";
        libraryHaskellDepends = [ base ];
        description = "Access to the BSD sysctl(3) interface";
        license = stdenv.lib.licenses.bsd3;
@@ -28280,7 +28362,7 @@ self: {
      mkDerivation {
        pname = "bson";
        version = "0.3.1";
-       sha256 = "1kihsjws8sqb44gvilh1zxrqn2bml8gxq2bbanxqb7nr4ymwfkiv";
+       sha256 = "3b4ec7ab27d99e85bb556b09dc1fa275098b73ff01d2b81f210b6ba4b9d430ce";
        libraryHaskellDepends = [
          base binary bytestring cryptohash data-binary-ieee754 mtl network
          text time
@@ -28300,7 +28382,7 @@ self: {
      mkDerivation {
        pname = "bson-generic";
        version = "0.0.8";
-       sha256 = "0r1gd6jxwzqana2b3i3xm8mx66lq4zkcir11c3v78g9fjyyhy7dh";
+       sha256 = "b01d0fbd972e3d74f66021e4c8e627981ad32baa7dc4b184b20a7fdea5692f64";
        libraryHaskellDepends = [ base bson ghc-prim text ];
        jailbreak = true;
        description = "Generic functionality for BSON";
@@ -28312,7 +28394,7 @@ self: {
      mkDerivation {
        pname = "bson-generics";
        version = "0.0.1";
-       sha256 = "03ifgmifk0dx6fzws1qlx3c1nslrkvwman5g3c4iag842bl03gxp";
+       sha256 = "b7bf01e812043d15091baf5855f99e996a1bd8e81407cdbf33bd81e9627d2e0e";
        libraryHaskellDepends = [ base bson ghc-prim ];
        jailbreak = true;
        description = "Generics functionality for BSON";
@@ -28327,7 +28409,7 @@ self: {
      mkDerivation {
        pname = "bson-mapping";
        version = "0.1.4.1";
-       sha256 = "0k91rkyh7lmq2iw2kmkl3lbzx4c46yzb2fp9pkag8yd05na2k9za";
+       sha256 = "eaa729942da079f4d4bce93ab1be378491fe171d74d6297814b8d203fdcc214d";
        libraryHaskellDepends = [
          base bson compact-string-fix template-haskell th-lift
        ];
@@ -28343,7 +28425,7 @@ self: {
      mkDerivation {
        pname = "bspack";
        version = "0.0.4";
-       sha256 = "0nzw1cs3nxb55yj3sy5afr6kycbm7xk26xpl0gvysgrd6bs0p8pb";
+       sha256 = "eba20bf4322d3fedf703f47623663f75313f4d76aa783da42f65753b340bfc5b";
        libraryHaskellDepends = [ base bytestring ghc-prim ];
        testHaskellDepends = [
          base bytestring mtl tasty tasty-hunit tasty-quickcheck
@@ -28358,7 +28440,7 @@ self: {
      mkDerivation {
        pname = "bsparse";
        version = "0.0.5";
-       sha256 = "12wn8jlqkb9d9vpdbwc3m288cgnr15cq4wv5fxlp7f10p3y42l2a";
+       sha256 = "4a5041fcb820b87369776573825909d93e8690a883f1d5ee4e2dad89a944968b";
        libraryHaskellDepends = [ base bytestring ];
        homepage = "https://github.com/vincenthz/hs-bsparse";
        description = "A simple unassuming parser for bytestring";
@@ -28373,7 +28455,7 @@ self: {
      mkDerivation {
        pname = "btree-concurrent";
        version = "0.1.5";
-       sha256 = "1xgw3ki3vypyxxiyzfjajjx1vzavyn1v9445cgbqwrr0n0wpkqm6";
+       sha256 = "a6e27939b020678ed7638590b483f55bfd1dba944abaef63effefa3de21cfcf5";
        libraryHaskellDepends = [
          array base base64-bytestring bytestring cereal containers directory
          filepath hashable mtl random snappy stm time
@@ -28394,7 +28476,7 @@ self: {
      mkDerivation {
        pname = "btrfs";
        version = "0.1.1.1";
-       sha256 = "1k1b8x0p0q43872c4x5dma2hs9dzkvr7n2dnb3w29ha7f24k8g8z";
+       sha256 = "1f3d34897047c124f858b6097bf29ebf250d85aaad74c2c44183607041472bcc";
        revision = "1";
        editedCabalFile = "1ef2b2d9f4768be3250cf2f971639c1a0e410e6bb9b035e922305c62c5f00887";
        isLibrary = true;
@@ -28413,7 +28495,7 @@ self: {
      mkDerivation {
        pname = "buffer-builder";
        version = "0.2.4.0";
-       sha256 = "1krhzcd6jwfi2rclkzrvmlzr8mz1kcll481w890yi64vb65j5cn2";
+       sha256 = "c2b2228b599b98e841423c2042299be157943fad3bff495916d171691afb30cf";
        libraryHaskellDepends = [
          base bytestring mtl text unordered-containers vector
        ];
@@ -28436,7 +28518,7 @@ self: {
      mkDerivation {
        pname = "buffer-builder-aeson";
        version = "0.2.0.3";
-       sha256 = "0i8jv5w016m8az6g809mf54wbkz1dci5w4c7w94rxl2xhsx7q98p";
+       sha256 = "17257cba865dd09e49e287115e226be1cfc549713501f4cc57a89a0078d91245";
        libraryHaskellDepends = [
          aeson base buffer-builder bytestring integer-gmp scientific
          unordered-containers vector
@@ -28459,7 +28541,7 @@ self: {
      mkDerivation {
        pname = "bugzilla";
        version = "0.2.1.1";
-       sha256 = "19ayjkaniksivm99lgl7bfjabig00y0gd3w9ssabksg7rfwajc5d";
+       sha256 = "ad30a9b8cbe7e9b994d6898ff68007e0c5a5a45b873e9a52dd51cf68d5945ea5";
        isLibrary = true;
        isExecutable = true;
        libraryHaskellDepends = [
@@ -28479,7 +28561,7 @@ self: {
      mkDerivation {
        pname = "buildable";
        version = "0.1.0.3";
-       sha256 = "1jrvgm2k6m8k9hj7h727pf357zydmhq1ndl1z39ag6294xd2rgpx";
+       sha256 = "fdbe2c5a274998a7d2f881361b30accdff5386bb471c78244c135533457d3bcb";
        libraryHaskellDepends = [ base bytestring containers dlist text ];
        jailbreak = true;
        description = "Typeclass for builders of linear data structures";
@@ -28493,7 +28575,7 @@ self: {
      mkDerivation {
        pname = "buildbox";
        version = "2.1.6.1";
-       sha256 = "15ddnbnm6wqm5dqf6f2qmxlxy5az0sxvml4rwghivcj0609lfc6i";
+       sha256 = "d13047133040b21de1e399d0babb065f15df69af5838e3702b157353edb2ad95";
        libraryHaskellDepends = [
          base bytestring containers directory mtl old-locale pretty process
          random stm time
@@ -28508,7 +28590,7 @@ self: {
      mkDerivation {
        pname = "buildbox-tools";
        version = "1.5.3.1";
-       sha256 = "0j1fsdmaxnl1zxgvxilznw5jfaaphij6wnhllb64f59kvhpqmy4f";
+       sha256 = "8ef88a2fdc331547cca2145a6e64845729270bb79fc6be5fff81daae6ad32e48";
        isLibrary = false;
        isExecutable = true;
        executableHaskellDepends = [ base buildbox parseargs ];
@@ -28530,7 +28612,7 @@ self: {
      mkDerivation {
        pname = "buildwrapper";
        version = "0.9.1";
-       sha256 = "1icm2vqimza6lslav01d11xq4v0p6dpymvx4md48ch8qbhdrn8r3";
+       sha256 = "23239b1b5c18418648aba4efea6f33176c827b082d80ada8a646fd1af11695c5";
        isLibrary = true;
        isExecutable = true;
        libraryHaskellDepends = [
@@ -28564,7 +28646,7 @@ self: {
      mkDerivation {
        pname = "bullet";
        version = "0.2.4";
-       sha256 = "0fksxkp6xq0q88g21b917qrg6pzzr1a00w5jjh45f4f9b3smibgn";
+       sha256 = "f6ad58f558c911570894b2700054c8ff5ff3323e21ad201e4218e06eeeec7a3a";
        libraryHaskellDepends = [ base vect ];
        libraryPkgconfigDepends = [ bullet ];
        libraryToolDepends = [ c2hs ];
@@ -28581,7 +28663,7 @@ self: {
      mkDerivation {
        pname = "bumper";
        version = "0.6.0.3";
-       sha256 = "1a6sqkdzq05az6yj3zmlcbx6bmhw4zjx2aijxfi481z3ifiy7z3w";
+       sha256 = "7cfce3a38be30744a2eb322ad1e5271cd665fa62b4fe21bdf9aa00fcdbc4daa8";
        isLibrary = false;
        isExecutable = true;
        executableHaskellDepends = [
@@ -28597,7 +28679,7 @@ self: {
      mkDerivation {
        pname = "burst-detection";
        version = "1.0";
-       sha256 = "1pgrqjdc4n97s7jsb9ddmjkw3qa4c28p4fp1ajyx5bfxdll44dwm";
+       sha256 = "953742286dddadd2bd54e13a72916044e1c1a7acada5a5e5d12759c29ac4f9dd";
        libraryHaskellDepends = [ base deepseq ];
        testHaskellDepends = [ base ];
        jailbreak = true;
@@ -28612,8 +28694,8 @@ self: {
      }:
      mkDerivation {
        pname = "bus-pirate";
-       version = "0.6.2";
-       sha256 = "1l2icqm9wm1q61nrhab9zininifwql304lgzfqbddvah6qx53iqd";
+       version = "0.6.3";
+       sha256 = "22db2acbd964175dce221dcff52e16ba346846c14e7772e20e320cde7798314a";
        libraryHaskellDepends = [
          base bytestring either errors serialport transformers
        ];
@@ -28629,7 +28711,7 @@ self: {
      mkDerivation {
        pname = "buster";
        version = "2.51";
-       sha256 = "12h77sa7z5ba6n2hx5kag51lp7q7hdmsd1cb006l7i46cq5b5zzg";
+       sha256 = "efffb20a6686c4430d008b85a66b83079f4b43796a960e85356a957f943e078a";
        libraryHaskellDepends = [
          base binary bytestring containers dataenc mtl old-locale parsec
          pretty time
@@ -28648,7 +28730,7 @@ self: {
      mkDerivation {
        pname = "buster-gtk";
        version = "2.0";
-       sha256 = "1ajmwdrx7cq5dh7zj0viipnhas0p910ax1yb37ina4nddrpx0gd1";
+       sha256 = "a13dd06f6ecd1265e319cb87ae4048176805ed8d7103f90f6c05b3d373e355aa";
        libraryHaskellDepends = [
          base binary buster bytestring containers dataenc gtk mtl old-locale
          parsec pretty time
@@ -28666,7 +28748,7 @@ self: {
      mkDerivation {
        pname = "buster-network";
        version = "1.2";
-       sha256 = "17nzw5ycdrw3f1cgwcg1vh1jk80528nl7ksmbmxg2mgndc89kg3i";
+       sha256 = "71bc99106bf655f17a5d55cf432d1205a02903dce131fe587083e7c67ce1df9e";
        libraryHaskellDepends = [
          base binary buster bytestring containers dataenc haxr HTTP mtl
          network old-locale pretty time
@@ -28686,7 +28768,7 @@ self: {
      mkDerivation {
        pname = "bustle";
        version = "0.5.1";
-       sha256 = "1mj8zxwjbp35pdslnssb9hz6mr3wapslfr3g265s5gk9kn8iqq06";
+       sha256 = "06601c919d69bea28b116f6447f5557ce46a3e4c4b6b4b75bb65dc2579ff48d6";
        isLibrary = false;
        isExecutable = true;
        executableHaskellDepends = [
@@ -28707,7 +28789,7 @@ self: {
      mkDerivation {
        pname = "bv";
        version = "0.3.0";
-       sha256 = "0r2bp39ilwq3zx38spbx5qrpccwm255ax2skab3i7jxjmf7yj025";
+       sha256 = "4500e98fabb2cb13c752538bae4a11953376332e7d5d8d46ff03731ad3b84b64";
        isLibrary = true;
        isExecutable = true;
        libraryHaskellDepends = [ base ];
@@ -28723,7 +28805,7 @@ self: {
      mkDerivation {
        pname = "byline";
        version = "0.2.0.0";
-       sha256 = "1194h9bhd1n9sxc224j22mir852b9c5ww2cq0sf9x8k3vlfpm1jl";
+       sha256 = "54867a1ddd63a29e9c069809ce0b4b4b1494631542122158d7c9860657822485";
        isLibrary = true;
        isExecutable = true;
        libraryHaskellDepends = [
@@ -28741,7 +28823,7 @@ self: {
      mkDerivation {
        pname = "bytable";
        version = "0.1.0.0";
-       sha256 = "0x4yh9li0pi2r9pjih000a143iw9kaz7r4z72510kv6kzkkcr9mn";
+       sha256 = "b6a6cce6fcd3ec094211e7937cbe9a89c741820200c0286fca225e1069829e74";
        libraryHaskellDepends = [ base bytestring word24 ];
        description = "data from/to ByteString";
        license = stdenv.lib.licenses.bsd3;
@@ -28753,7 +28835,7 @@ self: {
      mkDerivation {
        pname = "byteable";
        version = "0.1.1";
-       sha256 = "1qizg0kxxjqnd3cbrjhhidk5pbbciz0pb3z5kzikjjxnnnhk8fr4";
+       sha256 = "243b34a1b5b64b39e39fe58f75c18f6cad5b668b10cabcd86816cbde27783fe2";
        libraryHaskellDepends = [ base bytestring ];
        homepage = "http://github.com/vincenthz/hs-byteable";
        description = "Type class for sequence of bytes";
@@ -28765,7 +28847,7 @@ self: {
      mkDerivation {
        pname = "bytedump";
        version = "1.0";
-       sha256 = "1pf01mna3isx3i7m50yz3pw5ygz5sg8i8pshjb3yw8q41w2ba5xf";
+       sha256 = "ae17b5040f0423eec792505f14d1d3e53f5ff81ddf83524f1c5dc7a16c0dc0dd";
        isLibrary = true;
        isExecutable = true;
        libraryHaskellDepends = [ base bytestring ];
@@ -28779,7 +28861,7 @@ self: {
      mkDerivation {
        pname = "byteorder";
        version = "1.0.4";
-       sha256 = "06995paxbxk8lldvarqpb3ygcjbg4v8dk4scib1rjzwlhssvn85x";
+       sha256 = "bd20bbb586947f99c38a4c93d9d0266f49f6fc581767b51ba568f6d5d52d2919";
        libraryHaskellDepends = [ base ];
        homepage = "http://community.haskell.org/~aslatter/code/byteorder";
        description = "Exposes the native endianness or byte ordering of the system";
@@ -28794,7 +28876,7 @@ self: {
      mkDerivation {
        pname = "bytes";
        version = "0.15.0.1";
-       sha256 = "1qlqih83bx2vh5g15wffh4v9cfb5lv6jkj6i1xncd2imw5ynfi08";
+       sha256 = "0844677de1358ac66c0fd1c829cda66539963681cef1125e815bf435108c98e2";
        libraryHaskellDepends = [
          base binary bytestring cereal containers mtl text time transformers
          transformers-compat void
@@ -28810,7 +28892,7 @@ self: {
      mkDerivation {
        pname = "byteset";
        version = "0.1.1.0";
-       sha256 = "18dg863wbbjh95yial4gy6vi5spwygp0l7dfx6bj00lz4xdrqj8k";
+       sha256 = "13499c5b279f022097e9ae1d0aeef3fcea12b7f18f50157d4950aec58741afa1";
        libraryHaskellDepends = [ base binary ];
        description = "Set of bytes";
        license = stdenv.lib.licenses.bsd3;
@@ -28824,7 +28906,7 @@ self: {
      mkDerivation {
        pname = "bytestring";
        version = "0.10.6.0";
-       sha256 = "0xw924djdbs15r4dh2zyn209b0ji94si4ywliagjbg41gdmrl6r7";
+       sha256 = "271b9a6b7b81bc259f8a947b12354951829580b0fe0bd8482e41af261b118977";
        libraryHaskellDepends = [ base deepseq ghc-prim integer-gmp ];
        testHaskellDepends = [
          base byteorder deepseq directory dlist ghc-prim HUnit mtl
@@ -28842,7 +28924,7 @@ self: {
      mkDerivation {
        pname = "bytestring-arbitrary";
        version = "0.0.3";
-       sha256 = "1mxxgdak43wz7vzl2hbff9an7krqz4rhld9h173vvq6w2n8jnbi7";
+       sha256 = "272e2b9115dce0bdc70930350a33f938cf6355726e4141ff3e9f0f32557bbdd7";
        libraryHaskellDepends = [ base bytestring cryptohash QuickCheck ];
        testHaskellDepends = [ base bytestring cryptohash QuickCheck ];
        jailbreak = true;
@@ -28856,7 +28938,7 @@ self: {
      mkDerivation {
        pname = "bytestring-builder";
        version = "0.10.6.0.0";
-       sha256 = "1mkg24zl0rapb3gqzkyj5ibp07wx3yzd72hmfczssl0is63rjhww";
+       sha256 = "9c439987d11150ad3f73158ad3be1f9d1f70572cd2cf8fdf585765403f116fd6";
        libraryHaskellDepends = [ base bytestring deepseq ];
        description = "The new bytestring builder, packaged outside of GHC";
        license = stdenv.lib.licenses.bsd3;
@@ -28867,7 +28949,7 @@ self: {
      mkDerivation {
        pname = "bytestring-class";
        version = "0.0.0.1";
-       sha256 = "1z65br00rplhniaw9fg3phpxwf13acgycn5hnhyjfcyr962xp03x";
+       sha256 = "7d80db8549d933273db4b058e61f532338de2fbce3b9c455b490de0c405ec5fc";
        revision = "1";
        editedCabalFile = "e3aa2813d237dcd0a12bfd27293d8bf592cdf13bfdc01a4b609f34df238d0417";
        libraryHaskellDepends = [ base bytestring utf8-string ];
@@ -28884,7 +28966,7 @@ self: {
      mkDerivation {
        pname = "bytestring-conversion";
        version = "0.3.1";
-       sha256 = "1y2fhwz632sp7n0iw87lz2g8vks4jgxz2kw99kysgivxfd4fmdqk";
+       sha256 = "13b7ea48737dc7a7fd4c894ff1fb9344cf8d9ef8f4201e813d578b613e874ef8";
        libraryHaskellDepends = [
          attoparsec base bytestring case-insensitive double-conversion text
        ];
@@ -28901,7 +28983,7 @@ self: {
      mkDerivation {
        pname = "bytestring-csv";
        version = "0.1.2";
-       sha256 = "0x7qklb36jwxry1ih5x3jw7s861vlvd5g9h7yn7b2x64c0phyj0r";
+       sha256 = "19480f2f60c474b18ef507a657daa63b18a40f97a3171883cf9d4b33169df874";
        libraryHaskellDepends = [ array base bytestring dlist ];
        homepage = "http://code.haskell.org/~dons/code/bytestring-csv";
        description = "Parse CSV formatted data efficiently";
@@ -28914,7 +28996,7 @@ self: {
      mkDerivation {
        pname = "bytestring-delta";
        version = "0.1.0.1";
-       sha256 = "0iq59if3in08ssashk80wvh6yh1yr115387fi9kj952v6bzvzw1q";
+       sha256 = "38f0bfff325b9424678aeea05142c83e406fe0e6004da895d608d8385c4c0547";
        libraryHaskellDepends = [ base bytestring ];
        homepage = "http://github.com/joeyadams/haskell-bytestring-delta";
        description = "Simple, fast binary diff/patch";
@@ -28928,7 +29010,7 @@ self: {
      mkDerivation {
        pname = "bytestring-from";
        version = "0.3";
-       sha256 = "030jrpri4qmv8lr8ahgkbl3gghv2c00lfigx2wbrrv9hz74gkpn4";
+       sha256 = "c4def9c8f930ed9c1717fd4547016062c3f7065df341853245bb6212f3cd120c";
        libraryHaskellDepends = [ attoparsec base bytestring text ];
        testHaskellDepends = [
          base bytestring QuickCheck tasty tasty-quickcheck
@@ -28944,7 +29026,7 @@ self: {
      mkDerivation {
        pname = "bytestring-handle";
        version = "0.1.0.3";
-       sha256 = "0dakwnpymxj2nghqsnq09862czby8hy0xl8m74yzqdnd9ky22g0z";
+       sha256 = "1f3c21fc4ccd36fc3d3915d10e3c447e7d260c4a005b8de1b342f6eaafe55335";
        libraryHaskellDepends = [ base bytestring ];
        testHaskellDepends = [
          base bytestring HUnit QuickCheck test-framework
@@ -28960,7 +29042,7 @@ self: {
      mkDerivation {
        pname = "bytestring-lexing";
        version = "0.5.0.2";
-       sha256 = "0wrzniawhgpphc6yx1v972gyqxdbv0pizaz9bafahrshyb9svy81";
+       sha256 = "01f9add3f25067a89c5ae9ab1f2fd8ab75ec9f386987ee0d83f73ec855b43f73";
        libraryHaskellDepends = [ base bytestring ];
        homepage = "http://code.haskell.org/~wren/";
        description = "Parse and produce literals efficiently from strict or lazy bytestrings";
@@ -28972,7 +29054,7 @@ self: {
      mkDerivation {
        pname = "bytestring-mmap";
        version = "0.2.2";
-       sha256 = "1bv9xf4cpph1cbdwv6rbmq8ppi5wjpgd97lwln5l9ky5rvnaxg3v";
+       sha256 = "7bbcaeeccec5cf448ba59c9ed4de95bcc47b11ae2b9bcddb6201decb88eb69af";
        libraryHaskellDepends = [ base bytestring unix ];
        homepage = "http://code.haskell.org/~dons/code/bytestring-mmap/";
        description = "mmap support for strict ByteStrings";
@@ -28984,7 +29066,7 @@ self: {
      mkDerivation {
        pname = "bytestring-nums";
        version = "0.3.6";
-       sha256 = "1kg777gpqj05h5bj0637yky64bdx7x77hm7nq2rhpw4i1mh9gjmx";
+       sha256 = "bdca97600d91f00bb3c0f654784e3fbd2d62fcf4671820578105487cdf39e7cd";
        isLibrary = true;
        isExecutable = true;
        libraryHaskellDepends = [ base bytestring containers ];
@@ -28998,7 +29080,7 @@ self: {
      mkDerivation {
        pname = "bytestring-plain";
        version = "0.1.0.1";
-       sha256 = "057f9kyvj7cf2a53f6wqah0bw9cp67s7y3b6l6y78m24ipx8c56a";
+       sha256 = "ca1486fa8d445474bca1660d7ff4319725be0054981b378a128e1db9fd4cee14";
        libraryHaskellDepends = [
          base bytestring deepseq ghc-prim hashable
        ];
@@ -29014,7 +29096,7 @@ self: {
      mkDerivation {
        pname = "bytestring-progress";
        version = "1.0.5";
-       sha256 = "02j9gmvncap4xzvvmj0s84bkhf4xh8plw5saakiljxf6zi7hpdwq";
+       sha256 = "98b70b4ffcc67549e3544a174e2f829d383817411ac8baf7efe42a66777d490a";
        libraryHaskellDepends = [
          base bytestring terminal-progress-bar time
        ];
@@ -29030,7 +29112,7 @@ self: {
      mkDerivation {
        pname = "bytestring-read";
        version = "0.3.1";
-       sha256 = "0df6mb5fhfd1kgah5gv4q4ykxvl0y8hbqrdvm17nh33cxj2csj00";
+       sha256 = "0048cd84ec6c0c684fa8bb65bc20f280ee3e3dc164bf02d59ba139e8caaac635";
        revision = "1";
        editedCabalFile = "8a8b5f5c2f109a11df1cf47ffec170b810e02186f0406fd6c7f4155bfd2de0b6";
        libraryHaskellDepends = [ base bytestring types-compat ];
@@ -29047,7 +29129,7 @@ self: {
      mkDerivation {
        pname = "bytestring-rematch";
        version = "0.1.0.0";
-       sha256 = "01yk1pmsp6c89z4lf6p37g4jqbqz1d93g61gn4i99p8dijbg0pbh";
+       sha256 = "705df0968c0ddd9422b12f9837520b1f2f2cc93be31a47c94f8899abeb0dd307";
        libraryHaskellDepends = [ base bytestring ];
        testHaskellDepends = [ base bytestring hspec HUnit rematch ];
        jailbreak = true;
@@ -29062,7 +29144,7 @@ self: {
      mkDerivation {
        pname = "bytestring-short";
        version = "0.0.1.0";
-       sha256 = "034c63hw49sy4mg6xarf61d4f3shafj66v4sqky04sin460s28wv";
+       sha256 = "9b23a18121366a02fcc49a6c63a453500f475a302eab6e5e255e27c2e1308c0c";
        libraryHaskellDepends = [ base bytestring deepseq ];
        testHaskellDepends = [ base bytestring QuickCheck ];
        jailbreak = true;
@@ -29078,7 +29160,7 @@ self: {
      mkDerivation {
        pname = "bytestring-show";
        version = "0.3.5.6";
-       sha256 = "04h81a0bh2fvnkby1qafnydb29gzk6d4d311i2lbn7lm2vyjw919";
+       sha256 = "29242efd16951ebba888218c469a99ff25b19ab74ee1e0d7b4db09b8800a0812";
        libraryHaskellDepends = [
          array base binary bytestring containers integer-gmp
        ];
@@ -29092,7 +29174,7 @@ self: {
      mkDerivation {
        pname = "bytestring-trie";
        version = "0.2.4.1";
-       sha256 = "0qqklrvdcprchnl4bxr6w7zf6k5gncincl3kysm34gd04sszxr1g";
+       sha256 = "2fe4feb526a03d32aaf673506623b3af4ce3fee126f745a8852c5fd676a61363";
        libraryHaskellDepends = [ base binary bytestring ];
        homepage = "http://code.haskell.org/~wren/";
        description = "An efficient finite map from (byte)strings to values";
@@ -29104,7 +29186,7 @@ self: {
      mkDerivation {
        pname = "bytestringparser";
        version = "0.3";
-       sha256 = "1g99vbp14ki563lb41y1fxlgvdmrmq1y0xsk0ia1m438rdpnh2qd";
+       sha256 = "0d0b686fcb68901a54045377e003aeb9b6fd6877c107b2e830254e12eeda29bd";
        libraryHaskellDepends = [ base bytestring containers ];
        description = "Combinator parsing with Data.ByteString.Lazy";
        license = stdenv.lib.licenses.bsd3;
@@ -29116,7 +29198,7 @@ self: {
      mkDerivation {
        pname = "bytestringparser-temporary";
        version = "0.4.1";
-       sha256 = "019axq65hmgmszkc1lyyyy8rpv5xkjbf1pmgz1bz0hnc8lgv58pd";
+       sha256 = "eda2b21f45cc42f057f8afdee0969cbdec9b91f7ded3c0e6d7f555580cee2a05";
        libraryHaskellDepends = [ base bytestring containers ];
        description = "Combinator parsing with Data.ByteString.Lazy";
        license = stdenv.lib.licenses.bsd3;
@@ -29127,7 +29209,7 @@ self: {
      mkDerivation {
        pname = "bytestringreadp";
        version = "0.2";
-       sha256 = "07hx3072zg9y3kj6h99yl8fd3n115x4z8z411c1cpx1hj292d57f";
+       sha256 = "ee9426929030f4cb020b817cf4492f21d8d11ca23e2568e41c3ebd2f0e181d1e";
        libraryHaskellDepends = [ base bytestring ];
        description = "A ReadP style parser library for ByteString";
        license = stdenv.lib.licenses.bsd3;
@@ -29139,7 +29221,7 @@ self: {
      mkDerivation {
        pname = "bzlib";
        version = "0.5.0.5";
-       sha256 = "0zh130vw719a8d11q5qzc3ilzgv8cqyc2a7r1a131cv1fjnd1rwy";
+       sha256 = "9ee7d0ac7461b330820af928c13c6668bf4fe3601f171c42432a85c33718017e";
        libraryHaskellDepends = [ base bytestring ];
        librarySystemDepends = [ bzip2 ];
        description = "Compression and decompression in the bzip2 format";
@@ -29154,7 +29236,7 @@ self: {
      mkDerivation {
        pname = "bzlib-conduit";
        version = "0.2.1.3";
-       sha256 = "0jqg38zvxc0fpp74az0vm8klb88zwy076ncwzgq2zr0nrmr5cghm";
+       sha256 = "153e5672cd16e42ff0fb9c597380e71fa14527aa1b7c45cebd0eb0be3f1a0f4b";
        libraryHaskellDepends = [
          base bindings-DSL bytestring conduit conduit-extra data-default mtl
          resourcet
@@ -29174,7 +29256,7 @@ self: {
      mkDerivation {
        pname = "c-dsl";
        version = "0.3.1";
-       sha256 = "04hj3d26rp7ibv15n48y4xkfld3nnh6dqn8shxvw1h546z1316pw";
+       sha256 = "fc9a30c237a4c0c077871a59dc0cb47634ea66271e115bc25ef1dc6c441b1212";
        libraryHaskellDepends = [ base language-c ];
        description = "A higher level DSL on top of language-c";
        license = stdenv.lib.licenses.mit;
@@ -29185,7 +29267,7 @@ self: {
      mkDerivation {
        pname = "c-io";
        version = "0.1.0";
-       sha256 = "1za4wcrjrxqk8yqy1bddzxw8xxx0vlxyy31dj1glb5azx6qh7qp2";
+       sha256 = "e2e203b1e95f95455f902d0cef3bdda0f78e78ffadade0b14713f72c33e344fd";
        libraryHaskellDepends = [ base ];
        description = "C IO";
        license = stdenv.lib.licenses.bsd3;
@@ -29197,7 +29279,7 @@ self: {
      mkDerivation {
        pname = "c-storable-deriving";
        version = "0.1.2";
-       sha256 = "0cdy3fy8lpz5layc0qzixfpbx2jksl9smrf012l5rpl994dwc9x1";
+       sha256 = "a127c61b4989de5ca808c0e5aa13d5538abeaeebf163c0bca2e55f8abc1bbe31";
        libraryHaskellDepends = [ base ghc-prim ];
        homepage = "https://github.com/maurer/c-storable-deriving";
        description = "Generate C-like storable instances from datatypes";
@@ -29209,7 +29291,7 @@ self: {
      mkDerivation {
        pname = "c0check";
        version = "0.2";
-       sha256 = "0alzv8cdv5q6inhgp5zpms24460iqbgmwbc3l1fmf31p6jj802im";
+       sha256 = "350a80a434370c575da0832d5edfc211184284aef797fba08d0697dd18da9f2a";
        isLibrary = false;
        isExecutable = true;
        executableHaskellDepends = [ base c0parser ];
@@ -29222,7 +29304,7 @@ self: {
      mkDerivation {
        pname = "c0parser";
        version = "0.2";
-       sha256 = "0i6bsi30dkz51044r92gcgqr07bzbjfzgbr1z7p078j4016zb7cw";
+       sha256 = "9c9df54d0044a203eef921aff79d5c7f1d90f1634fa44c0808e5cf0646d4cb44";
        libraryHaskellDepends = [ base parsec ];
        description = "Simple C0 Parser";
        license = "GPL";
@@ -29233,7 +29315,7 @@ self: {
      mkDerivation {
        pname = "c10k";
        version = "0.5.0";
-       sha256 = "1i62ilk95p1vjyk7gl1fv7lwq6yk3ysfn3v1bbyfpabf97gzr0d9";
+       sha256 = "a981fcdf496ea9ebfc5a610febb41fd31bcce9d92ed077a6973bdc92268dc2c4";
        libraryHaskellDepends = [ base network unix ];
        homepage = "http://github.com/kazu-yamamoto/c10k";
        description = "C10k server library using prefork";
@@ -29248,7 +29330,7 @@ self: {
      mkDerivation {
        pname = "c2hs";
        version = "0.25.2";
-       sha256 = "0d1rgcwvz49v3h511dibiv6m06v8s179pg4sw386z17pz3a2hghm";
+       sha256 = "153e28d4f8f7846fd0e09abc9b4ed0681b50cd8e2bb6100a1c3b91bf397b3934";
        isLibrary = false;
        isExecutable = true;
        executableHaskellDepends = [
@@ -29272,7 +29354,7 @@ self: {
      mkDerivation {
        pname = "c2hsc";
        version = "0.6.5";
-       sha256 = "0c5hzi4nw9n3ir17swbwymkymnpiw958z8r2hw6656ijwqkxvzgd";
+       sha256 = "edfddd27e6329a620c8722a38f4ae2f1daea67f57c717d428ec3266e49fcb030";
        isLibrary = false;
        isExecutable = true;
        executableHaskellDepends = [
@@ -29292,7 +29374,7 @@ self: {
      mkDerivation {
        pname = "cab";
        version = "0.2.15";
-       sha256 = "0g2z9ypnkxbva2h96ihf0slwg2wz389pxr974vn69v2sblkzl9c9";
+       sha256 = "8925fa275d5aec64ec2627e57e131a9f8bc7a9060e4693a0507bf569af4f5f3c";
        isLibrary = true;
        isExecutable = true;
        libraryHaskellDepends = [
@@ -29315,7 +29397,7 @@ self: {
      mkDerivation {
        pname = "cabal-audit";
        version = "0.3.0.0";
-       sha256 = "02cfwka49fd399drv6rxb3hbxflpv6s1xfa7l759ihkp19d6ph9v";
+       sha256 = "3bc16b5a0a77c298caa147b91eb4d997babee0583d9b9d5b4aa3b944d4e48e09";
        isLibrary = false;
        isExecutable = true;
        executableHaskellDepends = [
@@ -29335,7 +29417,7 @@ self: {
      mkDerivation {
        pname = "cabal-bounds";
        version = "0.9.5";
-       sha256 = "0l4s0j75ianggpl3hbqrr3zp7v9jjgd5646ydqbcg040win20lzh";
+       sha256 = "f053206ce48080c7166ede1053da9332ed73ffc8192f38e87dcfaa588e049a50";
        isLibrary = true;
        isExecutable = true;
        libraryHaskellDepends = [
@@ -29359,7 +29441,7 @@ self: {
      mkDerivation {
        pname = "cabal-cargs";
        version = "0.7.7";
-       sha256 = "08f3fpfsjj4kk5flxgpjvqffifhfkhnf7i4n23adkf7w1rdw4nlz";
+       sha256 = "9f5ac25b0efcb8d9d41096c4e32c9c0ebae81cdef2be4e5d999348a9dd75c321";
        isLibrary = true;
        isExecutable = true;
        libraryHaskellDepends = [
@@ -29379,7 +29461,7 @@ self: {
      mkDerivation {
        pname = "cabal-constraints";
        version = "0.0.0.1";
-       sha256 = "06k43il8yiwbj6x3fhw64xdwq8d8qsmvvd1ycgml7vsry6cz6pdh";
+       sha256 = "b05df399f159ef43eb633eb4bdabc6a821cc5b27864337ba918b478f681c641a";
        isLibrary = false;
        isExecutable = true;
        executableHaskellDepends = [ base Cabal optparse-applicative ];
@@ -29398,7 +29480,7 @@ self: {
      mkDerivation {
        pname = "cabal-db";
        version = "0.1.12";
-       sha256 = "1phksjb1ahg0dbgsxsckgmqvvhrzvpn02c3w26gbiq9diindx267";
+       sha256 = "c788de6c8c2de1b89e117c3001ecdd3fc3bd717d93e9aedf6ae0411596d413de";
        isLibrary = false;
        isExecutable = true;
        executableHaskellDepends = [
@@ -29421,7 +29503,7 @@ self: {
      mkDerivation {
        pname = "cabal-debian";
        version = "4.30.2";
-       sha256 = "1vafxq1h2nispc7jdckxy2c746ikh60cscg9rrrbvs01wvjam9xw";
+       sha256 = "bca7aae4e601e8bd72cee931cd8081331a7298f07db2260fbb3a5a0103ee4eed";
        isLibrary = true;
        isExecutable = true;
        libraryHaskellDepends = [
@@ -29448,7 +29530,7 @@ self: {
      mkDerivation {
        pname = "cabal-dependency-licenses";
        version = "0.1.1.1";
-       sha256 = "11bp5gmm0j0w5pbd26qd7w05v1mkkxi5gf28rlx44dzic55xpkld";
+       sha256 = "8dcedb4b61f137423acd48b857629fb3865d003f0d1bd1d62d1c4850eb2b7785";
        isLibrary = false;
        isExecutable = true;
        executableHaskellDepends = [
@@ -29467,7 +29549,7 @@ self: {
      mkDerivation {
        pname = "cabal-dev";
        version = "0.9.2";
-       sha256 = "1372bpn8s7d7nm01ggp3m98ldrynidbchk3p14yrjysvxwr3l6q8";
+       sha256 = "081b3a32ef5b7b993d09774cc8568bd6e74651aae3be1740b5a71d8dec5de28c";
        isLibrary = false;
        isExecutable = true;
        executableHaskellDepends = [
@@ -29488,7 +29570,7 @@ self: {
      mkDerivation {
        pname = "cabal-dir";
        version = "0.1.0.4";
-       sha256 = "0kbq549bl18f1cd2q4w7nngsvnvgc3366xr7y37x5sw80rq5w5wg";
+       sha256 = "8f175e700688ebd2cff0277763c6606fdbad9fb587132c1a0b0e05ba1229784d";
        isLibrary = false;
        isExecutable = true;
        executableHaskellDepends = [ base Cabal directory filepath ];
@@ -29501,7 +29583,7 @@ self: {
      mkDerivation {
        pname = "cabal-file-th";
        version = "0.2.3";
-       sha256 = "0kawvb5n56rkq4453l6pia3wrr6jvvdwkghi6i176n1gm2zf2ri8";
+       sha256 = "2866e1bea82f5873423411bec9dbded2e4cc878ad7d05108c1339b62cbda5c4d";
        revision = "1";
        editedCabalFile = "50bc6cf5a335a2608ab1e5e59b73f184d3f48d91f49fec189701416ff3e1e37e";
        libraryHaskellDepends = [ base Cabal directory template-haskell ];
@@ -29516,7 +29598,7 @@ self: {
      mkDerivation {
        pname = "cabal-ghci";
        version = "0.3";
-       sha256 = "1x7fpvvmr2mq7l960wgsijhyrdaiq3lnnl3z6drklc5p73pms8w6";
+       sha256 = "86235def38b7303a73337f506be9c051b5eca18cfa7160123db88a5cf7beeef4";
        isLibrary = true;
        isExecutable = true;
        libraryHaskellDepends = [ base Cabal directory filepath ];
@@ -29536,7 +29618,7 @@ self: {
      mkDerivation {
        pname = "cabal-graphdeps";
        version = "0.1.2";
-       sha256 = "105q051bna299pf1ka0r9bmqsbpzcg9vmbi5ynmalancgjpnm29a";
+       sha256 = "2a896aaf7ccc2aaaaaf525aebad363ff2e8deb4a19a819dc4d4928bb4201b880";
        isLibrary = false;
        isExecutable = true;
        executableHaskellDepends = [
@@ -29555,8 +29637,8 @@ self: {
      }:
      mkDerivation {
        pname = "cabal-helper";
-       version = "0.3.8.0";
-       sha256 = "1l2ign8q4kdsnypqvjl8x152lkb0s1zfn08vshirz2qf4v5wxs3n";
+       version = "0.5.0.0";
+       sha256 = "9b7efb284a61e9064be77f3a273410a5432877f7cbf11e6e0233a1826339dcc8";
        isLibrary = true;
        isExecutable = true;
        libraryHaskellDepends = [
@@ -29567,7 +29649,7 @@ self: {
          base bytestring Cabal directory filepath process template-haskell
          temporary transformers utf8-string
        ];
-       testHaskellDepends = [ base extra unix ];
+       testHaskellDepends = [ base extra process unix ];
        description = "Simple interface to some of Cabal's configuration state used by ghc-mod";
        license = stdenv.lib.licenses.agpl3;
      }) {};
@@ -29582,7 +29664,7 @@ self: {
      mkDerivation {
        pname = "cabal-install";
        version = "1.18.1.0";
-       sha256 = "1r1shhvnpgxf91rmbv3wa1rkd24plbgr6bpz3aj80ir0z3zbdayn";
+       sha256 = "d6abb6fef8204780a41aff2e93dfa297883673507cec557348aebf6b37843ae4";
        revision = "1";
        editedCabalFile = "7f1c53bbf3a3906d0594e217d236e54acc015c67db88301dbadaf5008cb9ac4c";
        isLibrary = false;
@@ -29617,7 +29699,7 @@ self: {
      mkDerivation {
        pname = "cabal-install";
        version = "1.22.6.0";
-       sha256 = "1d5h7h2wjwc2s3dvsvzjgmmfrfl2312ym2h6kyjgm9wnaqw9w8wx";
+       sha256 = "9d239e385696a7faa49f068aea451882baec6a7df26fbddbd08271c9053cb0b4";
        isLibrary = false;
        isExecutable = true;
        executableHaskellDepends = [
@@ -29647,7 +29729,7 @@ self: {
      mkDerivation {
        pname = "cabal-install-bundle";
        version = "1.18.0.2.1";
-       sha256 = "0gsghmpn38idqivba8islfy5y1xhnhyjdyahdg7h7isc9kvq6isq";
+       sha256 = "584783f74c4cc703cf6b50f9263db4b0075fbca33a22b576c42da2616f854f3f";
        isLibrary = false;
        isExecutable = true;
        executableHaskellDepends = [
@@ -29668,7 +29750,7 @@ self: {
      mkDerivation {
        pname = "cabal-install-ghc72";
        version = "0.10.4";
-       sha256 = "1fgy79w5bzzhqpnwgfd9jis9w6ix5wwdbwr2g556rxvmqsgl7mmg";
+       sha256 = "afd6439fc675f76c4a7922f3d5382f3d1a9e7494a9b9c7edc5f0ff55783afeb9";
        isLibrary = false;
        isExecutable = true;
        executableHaskellDepends = [
@@ -29690,7 +29772,7 @@ self: {
      mkDerivation {
        pname = "cabal-install-ghc74";
        version = "0.10.4";
-       sha256 = "1ssk5h0hlv3aivzsr0iv90g683qkqmppc7glivhwfm6q1vkv9gmd";
+       sha256 = "adbeb4e70ed854c7e18ef41d766fc5130f641e483b82acff8e6a6c0a012c53eb";
        isLibrary = false;
        isExecutable = true;
        executableHaskellDepends = [
@@ -29709,7 +29791,7 @@ self: {
      mkDerivation {
        pname = "cabal-lenses";
        version = "0.4.5";
-       sha256 = "1v09n4mah5azb1hmc14ygiqwwm2an6ff2z2f9hw2c7jddbmays5n";
+       sha256 = "b668afea6a4d1e26384c4e7ce19cb14a54ce717c9e045661585f15a82ab109ec";
        libraryHaskellDepends = [ base Cabal lens unordered-containers ];
        jailbreak = true;
        description = "Lenses and traversals for the Cabal library";
@@ -29723,7 +29805,7 @@ self: {
      mkDerivation {
        pname = "cabal-macosx";
        version = "0.2.3";
-       sha256 = "0rvmb6lx2alr7f0v7nbv48xzg7wp4nrn03hdkjc4a4c97rai14i9";
+       sha256 = "299210553e891145989c0d0e60b325979ff73b227bd9b3813b992ad1a9597567";
        isLibrary = true;
        isExecutable = true;
        libraryHaskellDepends = [
@@ -29745,7 +29827,7 @@ self: {
      mkDerivation {
        pname = "cabal-meta";
        version = "0.4.1.3";
-       sha256 = "14k8nv2kg8n9ssz6jivvin56jjazsvp4xg7zi0z6hcawfmcdmzd6";
+       sha256 = "a6fdda58755c31683e88ffbc4eeed65f49698a8d7b4769bed6c9a237c5b66892";
        isLibrary = true;
        isExecutable = true;
        libraryHaskellDepends = [ base shelly system-filepath text ];
@@ -29767,7 +29849,7 @@ self: {
      mkDerivation {
        pname = "cabal-mon";
        version = "1.0.1";
-       sha256 = "1wngmf73dqyyf9nfbpwyg3mvbp32rqrhhp4kf9nylhawwkv7c8v0";
+       sha256 = "602376f6e45c41ea6d72935c0833ce62dcb5eb789edfe56c72dee3368eabcff2";
        isLibrary = false;
        isExecutable = true;
        executableHaskellDepends = [
@@ -29784,7 +29866,7 @@ self: {
      mkDerivation {
        pname = "cabal-nirvana";
        version = "0.2.2.1";
-       sha256 = "1clwhlqm1k9km29i9b2c2ys59nfspsffrixr2sz824gnd415x3lk";
+       sha256 = "938e5e0269f61181be16b9c7ec9cbedad954b4174cac1493a833cd5031859cb2";
        isLibrary = false;
        isExecutable = true;
        executableHaskellDepends = [
@@ -29800,7 +29882,7 @@ self: {
      mkDerivation {
        pname = "cabal-progdeps";
        version = "1.0";
-       sha256 = "0fz2hpm8fd49jhqdc9cwzvdq34b64zwn4ln8n77hxqx8rfw8zvif";
+       sha256 = "2eee8fb8cba8e30ecfb1c85262f927669181dbfe9c25d63094893487ea85e23b";
        isLibrary = false;
        isExecutable = true;
        executableHaskellDepends = [ base Cabal directory filepath ];
@@ -29816,7 +29898,7 @@ self: {
      mkDerivation {
        pname = "cabal-query";
        version = "0.1";
-       sha256 = "0j4n48ngwins8bl7g3mazwmbwgyjpp17mi77c9j1klfgx7fam6wa";
+       sha256 = "8a9baadce9cfd1196462e7c47ac2bdd23fbe2affaa8e77e842da46fe2c229648";
        libraryHaskellDepends = [
          base bytestring Cabal derive ghc MissingH mtl tar template-haskell
          uniplate
@@ -29835,7 +29917,7 @@ self: {
      mkDerivation {
        pname = "cabal-rpm";
        version = "0.9.6";
-       sha256 = "07ig7lwkf9lv10kacxcydpz3z6fhpmmpwcr6kq32xgh3larsf0g5";
+       sha256 = "e501a7b3a203be2e069e26337e6bbdd0993ffe6d9e75a626089b2637393d2f1e";
        isLibrary = false;
        isExecutable = true;
        executableHaskellDepends = [
@@ -29851,7 +29933,7 @@ self: {
      mkDerivation {
        pname = "cabal-scripts";
        version = "0.1.1";
-       sha256 = "1ajgx29hvcsdd6lwc78dyhsjm5ikx2zn0kdbwnzn1kggz2l08ls4";
+       sha256 = "445304a8f8efcd60bfe5ab4d60bfe833962a35f40d1dc6a9694db30d93e84faa";
        libraryHaskellDepends = [ base ];
        description = "Shell scripts for support of Cabal maintenance";
        license = stdenv.lib.licenses.bsd3;
@@ -29863,7 +29945,7 @@ self: {
      mkDerivation {
        pname = "cabal-setup";
        version = "1.2.1";
-       sha256 = "0k1lnixkmgdjn8d2akhj60133brs424y0cwwzwraq7awx03y72bm";
+       sha256 = "7589e307e85c1dac32ff9c33e089203aaf310230124e251ab2b2bd3a7bb4344c";
        isLibrary = false;
        isExecutable = true;
        executableHaskellDepends = [ base Cabal ];
@@ -29880,7 +29962,7 @@ self: {
      mkDerivation {
        pname = "cabal-sign";
        version = "0.4.1.0";
-       sha256 = "1b8yr4k0mapysgh96dxabpzxznd65v8yrcba0jk6wda3mwlm1nqk";
+       sha256 = "13db5029af43356ea6046ab1ecd12ea6d9dfff5daa3793e0d3feaa0a26c91ead";
        isLibrary = false;
        isExecutable = true;
        executableHaskellDepends = [
@@ -29898,7 +29980,7 @@ self: {
      mkDerivation {
        pname = "cabal-sort";
        version = "0.0.5.1";
-       sha256 = "1991k6p8vvagnm8wpmzy84088whkqls1q4rdgir4f2m7r0wxl414";
+       sha256 = "2410da39c8a70a47727c2d131c34c51372840041fed7cb51b54fed8dae9921a5";
        isLibrary = false;
        isExecutable = true;
        executableHaskellDepends = [
@@ -29919,7 +30001,7 @@ self: {
      mkDerivation {
        pname = "cabal-src";
        version = "0.3.0";
-       sha256 = "1x8fb7hly9cxhfacwrai1zam6737dgfhjs9g85826f2cp4vp0g29";
+       sha256 = "493c7037b94c382350412f6909dd6b671c53d50f5165ce94839d254fe1590ef5";
        isLibrary = false;
        isExecutable = true;
        executableHaskellDepends = [
@@ -29937,7 +30019,7 @@ self: {
      mkDerivation {
        pname = "cabal-test";
        version = "0.1";
-       sha256 = "11883q7zjy3l5qla5rvbmflm19kalvzqx7n1hprmiizr1kczh6ax";
+       sha256 = "5d19f8d90cf9c758f385c19e8effa66aa650a9ab6be7a2282e7478f90f1e0885";
        isLibrary = false;
        isExecutable = true;
        executableHaskellDepends = [
@@ -29955,7 +30037,7 @@ self: {
      mkDerivation {
        pname = "cabal-test-bin";
        version = "0.1.5";
-       sha256 = "1qjshg9r6vh964mwsj0spsxcl3sdvll2znjd2hq4lw71va4iwm87";
+       sha256 = "07551e89dae1704a30144dda2f28dd4d0fcababe1a48cd2b31096e93d3835ae2";
        isLibrary = true;
        isExecutable = true;
        libraryHaskellDepends = [ base directory filepath unix ];
@@ -29970,7 +30052,7 @@ self: {
      mkDerivation {
        pname = "cabal-test-compat";
        version = "0.2.0.0";
-       sha256 = "15lxyrza1n9saac1awjx482gi7wq3sshqf4ich6k9xkfj464lrdq";
+       sha256 = "b8654a0c916ef6340d6491380cb51e989ff804225d721598523ad9a07ef69d96";
        libraryHaskellDepends = [ base Cabal QuickCheck ];
        homepage = "http://twitter.com/khibino/";
        description = "Compatibility interface of cabal test-suite";
@@ -29982,7 +30064,7 @@ self: {
      mkDerivation {
        pname = "cabal-test-quickcheck";
        version = "0.1.6";
-       sha256 = "0rffvz3khxdfbl9rfk1q47xqv013dwmd4sy8cy7y833175j2zibi";
+       sha256 = "71c52f6439610ce48f67c86bd22a6f23808dfb21384c97135dae7538c7dfce65";
        libraryHaskellDepends = [ base Cabal QuickCheck ];
        homepage = "https://github.com/zmthy/cabal-test-quickcheck";
        description = "QuickCheck for Cabal";
@@ -29994,7 +30076,7 @@ self: {
      mkDerivation {
        pname = "cabal-uninstall";
        version = "0.1.6";
-       sha256 = "0ys1c8z8042vc7dzmis47w0q3qapyllmsdkpb1by22qmcnaavii2";
+       sha256 = "22c6ad9465150be1575877365d29f557e181013f44c7fadb615b10803e62417b";
        isLibrary = false;
        isExecutable = true;
        executableHaskellDepends = [ base directory filepath mtl process ];
@@ -30007,7 +30089,7 @@ self: {
      mkDerivation {
        pname = "cabal-upload";
        version = "0.4";
-       sha256 = "05k77hdx0sbgnn454vb6rc7mmrc3zby7s44x498i4ncrkivz90bz";
+       sha256 = "7f81f4779c99591251229d107dfcfa83e55a0fcb666d5288b56f69d01b3c6716";
        isLibrary = false;
        isExecutable = true;
        executableHaskellDepends = [ base filepath HTTP network ];
@@ -30024,7 +30106,7 @@ self: {
      mkDerivation {
        pname = "cabal2arch";
        version = "1.1";
-       sha256 = "0sk10z9lj291rpidlaydp7nvgl7adbp7gyf2nvqqhrshxnlqpc8z";
+       sha256 = "1fb18ba9ed506788f1b6c2f977ee6aead0b7edb9cd2bdae2cd210949d307616a";
        isLibrary = false;
        isExecutable = true;
        executableHaskellDepends = [
@@ -30042,7 +30124,7 @@ self: {
      mkDerivation {
        pname = "cabal2doap";
        version = "0.2";
-       sha256 = "1nqchq9mzq8k99agvafwa4vll7d3ahpkaifnjj2bnljqdkxlh9al";
+       sha256 = "542548fb6c5852bb8494d645352f54a31d4a3751dca9fd544a13e15f13860cdb";
        isLibrary = false;
        isExecutable = true;
        executableHaskellDepends = [
@@ -30060,7 +30142,7 @@ self: {
      mkDerivation {
        pname = "cabal2ebuild";
        version = "0.0.15.9";
-       sha256 = "11fp52hmzkrgcmkxzclmq6bbzxsn0ph78ib6wzzkza5j2c48ya2l";
+       sha256 = "54288f0813b2a83fffe7664574e00556f7bf96c195b2df67652fcf5fa128d785";
        isLibrary = true;
        isExecutable = true;
        libraryHaskellDepends = [ base Cabal directory filepath ];
@@ -30077,7 +30159,7 @@ self: {
      mkDerivation {
        pname = "cabal2ghci";
        version = "0.0.1.1";
-       sha256 = "1fg3pr25f78a6b8nqxvxki4z3fvgx4i6zkmpl992a0iarycqdrsg";
+       sha256 = "4fe78699cf2a022552a2b7ce6f22e96fbbf1499c7d776cd1320a1d5744bee3b9";
        isLibrary = false;
        isExecutable = true;
        executableHaskellDepends = [
@@ -30096,7 +30178,7 @@ self: {
      mkDerivation {
        pname = "cabal2nix";
        version = "1.73";
-       sha256 = "1nskcr8k5a8wm9q5is0b1kww574q2nq45f16agya8z44hgk97xiv";
+       sha256 = "3bf693e683847ca4fc5326b842b015989cc2f90c0be85870aa1ca932516653db";
        revision = "5";
        editedCabalFile = "54866b8081ddfc72761c1f38cc96df6782682058cd09b465300562910f57e2ea";
        isLibrary = false;
@@ -30119,7 +30201,7 @@ self: {
      mkDerivation {
        pname = "cabal2spec";
        version = "1.0";
-       sha256 = "08y8rwj86n7f3bqfv2ximlx8qas12zspiz6ix8gg01whsry43nsj";
+       sha256 = "52db417cd69007f01eead1fc78f517412b8c3aadb18bedf01aee588324cfc823";
        isLibrary = false;
        isExecutable = true;
        executableHaskellDepends = [
@@ -30139,7 +30221,7 @@ self: {
      mkDerivation {
        pname = "cabalQuery";
        version = "0.1.0.1";
-       sha256 = "195wsfh813z6pmba3lz2xgfcqijcql6xwqsggqb5rmzqxbkvk0bd";
+       sha256 = "6d81b9e7eaf8d75c167e4f63de0dc54c46ccdcebe2d3a156bde68f80a0d3bca4";
        isLibrary = true;
        isExecutable = true;
        libraryHaskellDepends = [ base Cabal pretty ];
@@ -30157,7 +30239,7 @@ self: {
      mkDerivation {
        pname = "cabalg";
        version = "0.2.9";
-       sha256 = "02brl9b1g3cyw5nmk0mih073kbszpc6g2nqgs0sh93h7y5naf5kp";
+       sha256 = "7716a76cf1078e0435d00f5bf10cbb5faf390e80b182596de19e8d1756a27909";
        isLibrary = true;
        isExecutable = true;
        libraryHaskellDepends = [ base directory filepath process ];
@@ -30174,7 +30256,7 @@ self: {
      mkDerivation {
        pname = "cabalgraph";
        version = "0.1";
-       sha256 = "1kgw1n22zh1ap6dfzhmh18d0wkr6ppd9b20r77f7q6m371hhbkvy";
+       sha256 = "7ecf056138a31a7cdc39198895dabd264f0e1a0ab0c2ef9ab92ac02f840dfccd";
        isLibrary = false;
        isExecutable = true;
        executableHaskellDepends = [
@@ -30191,7 +30273,7 @@ self: {
      mkDerivation {
        pname = "cabalmdvrpm";
        version = "0.0.1";
-       sha256 = "0pgkav4ifwkqh9idj8rpbnq3rw51i94dj1zw0wf7mv72bb32a0c6";
+       sha256 = "860125c65ae2ec7a1c07fc07d9488aa1f03cb05d3723d96282787217c956f35d";
        isLibrary = true;
        isExecutable = true;
        libraryHaskellDepends = [ base Cabal cabalrpmdeps haskell98 ];
@@ -30207,7 +30289,7 @@ self: {
      mkDerivation {
        pname = "cabalrpmdeps";
        version = "0.0.4";
-       sha256 = "19kzbwpb9gv9knz1dfvck8yb1kda5dg9rig5xrsd118wgq6xpkr1";
+       sha256 = "21cfdb0d7e1c85d074eee5c59c5e2baacdb03c9a6cbb16be9d69bfb42e5f7fa6";
        isLibrary = true;
        isExecutable = true;
        libraryHaskellDepends = [ base Cabal filepath haskell98 ];
@@ -30223,7 +30305,7 @@ self: {
      mkDerivation {
        pname = "cabalvchk";
        version = "0.3";
-       sha256 = "1ai2yz4whbjk9qfpyzjqkdypqknnzfdr1fdp5ii7h059na0q6iq2";
+       sha256 = "02478381b2a90078622cb7b9909bfbd64e7c7d9b587e7f1d4e532ec8c9f722aa";
        isLibrary = false;
        isExecutable = true;
        executableHaskellDepends = [ base Cabal ];
@@ -30238,7 +30320,7 @@ self: {
      mkDerivation {
        pname = "cabin";
        version = "0.1.0.3";
-       sha256 = "0wj1x6gsr5jlnq0l6xgwy2y64jlxna7bvx7vwk73znf572rswmxk";
+       sha256 = "b357aeb338c5d93fcee4fbf4bd8eb29d4a62bcf0fc754301b65496ac9fe94172";
        isLibrary = false;
        isExecutable = true;
        executableHaskellDepends = [
@@ -30254,7 +30336,7 @@ self: {
      mkDerivation {
        pname = "cabocha";
        version = "0.1.0.0";
-       sha256 = "0siqh3dly69b1kfm5y3q0sccqxx25hflwhizw6ga70icmvscwrwf";
+       sha256 = "8e67cef4ae2c82a39ee13f424e1d2ca277cc980678f852dd0c2b194fdb80386a";
        libraryHaskellDepends = [ base bytestring text ];
        librarySystemDepends = [ cabocha ];
        testHaskellDepends = [ base text-format ];
@@ -30263,6 +30345,21 @@ self: {
        hydraPlatforms = stdenv.lib.platforms.none;
      }) { cabocha = null;};
 
+  "cached-io" = callPackage
+    ({ mkDerivation, base, stm, time }:
+     mkDerivation {
+       pname = "cached-io";
+       version = "0.1.0.1";
+       sha256 = "76326e5acec346f27c258440b792e4899c6fb2fc364b1c217c73c5b72e3ce0b8";
+       isLibrary = true;
+       isExecutable = true;
+       libraryHaskellDepends = [ base stm time ];
+       executableHaskellDepends = [ base stm time ];
+       jailbreak = true;
+       description = "A simple library to cache a single IO action with timeout";
+       license = stdenv.lib.licenses.asl20;
+     }) {};
+
   "cached-traversable" = callPackage
     ({ mkDerivation, base, binary, bytestring, containers, directory
      , filepath, mtl
@@ -30270,7 +30367,7 @@ self: {
      mkDerivation {
        pname = "cached-traversable";
        version = "0.1.0.1";
-       sha256 = "05hlj6qdy0iqyi8z75h7fr9ijfhxngyr3v60q8y681acsgr54dv6";
+       sha256 = "663752f2d34c05643cc2c0ec91fdb31d3a1953760796f351f43802dfb0911416";
        libraryHaskellDepends = [
          base binary bytestring containers directory filepath mtl
        ];
@@ -30283,7 +30380,7 @@ self: {
      mkDerivation {
        pname = "caf";
        version = "0.0.3";
-       sha256 = "1yrl3ffkfwgs4kljx57m1ldam087s7iby2qs74c4crxkrcj0j7a8";
+       sha256 = "481d0924cbb3674618391a0bbfe2d10781aa1a0df5942ee924fa71379d1b34fb";
        libraryHaskellDepends = [ base ];
        homepage = "http://sites.google.com/site/cafwiki/";
        description = "A library of Concurrency Abstractions using Futures";
@@ -30295,7 +30392,7 @@ self: {
      mkDerivation {
        pname = "cafeteria-prelude";
        version = "0.1.0.0";
-       sha256 = "1iyasmd8zcg98vy7ffhxyyr664f02ird5z7rks9n67ixv7n60mrl";
+       sha256 = "345760ecd93d1e63939ef9fcd27214c01163b2f71d3a77fc46e9b18f5ad5cac7";
        libraryHaskellDepends = [ base ];
        homepage = "https://github.com/Scott-Fleischman/cafeteria-prelude";
        description = "Prelude subsets—take only what you want!";
@@ -30311,7 +30408,7 @@ self: {
      mkDerivation {
        pname = "caffegraph";
        version = "0.1.0.2";
-       sha256 = "1yz427ygabkycvngqw250ksl17nwi0fy52x2fy3x6apg79cw1ng2";
+       sha256 = "e2d9c0593aef2ad38777a28be21d88dc9e40f5044570fcec667e2ef5fc11e4fb";
        libraryHaskellDepends = [
          base bytestring containers fgl filepath graphviz language-lua lens
          mtl optparse-applicative process protocol-buffers
@@ -30329,7 +30426,7 @@ self: {
      mkDerivation {
        pname = "cairo";
        version = "0.13.1.0";
-       sha256 = "0vi7glzizi2nvv0p5wsdxlpkx3f1875jpij26k2j4h0h6z53z3kb";
+       sha256 = "6b8e3fca37104022c53442c62bcb41c18d3e2fed4df372c1de56c41f3f7d276e";
        libraryHaskellDepends = [
          array base bytestring mtl text utf8-string
        ];
@@ -30345,7 +30442,7 @@ self: {
      mkDerivation {
        pname = "cairo-appbase";
        version = "0.4";
-       sha256 = "1191j2587f1sy4d6z57df21xn00qdpv27clib7cyaqdy5jnv3zw2";
+       sha256 = "82ffb1ad2cbe61e5d95991b223f66d1800db8370ed946f1af13ab8838a902185";
        isLibrary = false;
        isExecutable = true;
        executableHaskellDepends = [ base cairo glib gtk ];
@@ -30361,7 +30458,7 @@ self: {
      mkDerivation {
        pname = "cake";
        version = "1.1.0.1";
-       sha256 = "168szg38gq0g0mppjszcsmsdygs8qy23w6xsz8gbg7dkh7izy1ba";
+       sha256 = "6a05ffe381b39db71efaba1b3e84c7483fdf74d5ec6b796f050fe087c6fb1a99";
        isLibrary = true;
        isExecutable = true;
        libraryHaskellDepends = [
@@ -30384,7 +30481,7 @@ self: {
      mkDerivation {
        pname = "cake3";
        version = "0.6.0";
-       sha256 = "0k045qqnivhmsvxas0zlmp9qgkb16917s4wk67l7mscgpi99fhdq";
+       sha256 = "b8419752bc8fe97ae83193137d423261cd87d3adf403adfad615ee68312e044c";
        isLibrary = true;
        isExecutable = true;
        libraryHaskellDepends = [
@@ -30411,7 +30508,7 @@ self: {
      mkDerivation {
        pname = "cakyrespa";
        version = "0.0.29";
-       sha256 = "1a2ypgkpzzp2hn14x35ava0p0k781s7mhldw29ppl1an7fs91fyx";
+       sha256 = "ddbb90b43b56057a6f12bc51588f0ee84c7081daaa8c4e8285e2fe7fe7bb5ea8";
        isLibrary = false;
        isExecutable = true;
        executableHaskellDepends = [
@@ -30428,7 +30525,7 @@ self: {
      mkDerivation {
        pname = "cal3d";
        version = "0.1";
-       sha256 = "1b4pajzpf879vns2kffkqgyk5sbsfrr3q2kv5ryvls8rgwcjc3q6";
+       sha256 = "060f26197f1969ba7d2e7b0a3c72767ae932fdc3d3b929b4dde92077bf5497ac";
        libraryHaskellDepends = [ base ];
        librarySystemDepends = [ cal3d ];
        homepage = "http://haskell.org/haskellwiki/Cal3d_animation";
@@ -30442,7 +30539,7 @@ self: {
      mkDerivation {
        pname = "cal3d-examples";
        version = "0.1";
-       sha256 = "1fj6v1dw1gyy6dx4ssiziahxf8j8vr4l35n3rm04g797wypswmw0";
+       sha256 = "8057aeafe7279d4740cdc3964149de4822d7a18a3f6a4d7a33debfc05bd846ba";
        isLibrary = false;
        isExecutable = true;
        executableHaskellDepends = [ base cal3d cal3d-opengl OpenGL SDL ];
@@ -30457,7 +30554,7 @@ self: {
      mkDerivation {
        pname = "cal3d-opengl";
        version = "0.1";
-       sha256 = "02na1ww5dw08n2y7v2vkgdvzw0zpiic5683jac7f2zvhcij68sf2";
+       sha256 = "c269646464707fe10e53722053588cf703fe777b738b7dbcb008f056380fca0a";
        libraryHaskellDepends = [ base cal3d OpenGL ];
        homepage = "http://haskell.org/haskellwiki/Cal3d_animation";
        description = "OpenGL rendering for the Cal3D animation library";
@@ -30470,7 +30567,7 @@ self: {
      mkDerivation {
        pname = "calc";
        version = "0.1";
-       sha256 = "1h3rqxj2df68knrb2rhp75rc92q9knsa7jp749j9h24258yr6qxw";
+       sha256 = "bc63933d2a8208986422e7caa3b49d098bc472391766b1b29dc8b82664c779c0";
        isLibrary = false;
        isExecutable = true;
        executableHaskellDepends = [ array base harpy haskell98 mtl ];
@@ -30484,7 +30581,7 @@ self: {
      mkDerivation {
        pname = "calculator";
        version = "0.3.1.1";
-       sha256 = "1k21wf4gnq8h1a8nk5xx41yibc3azscxgkm8ajmjnj1a5w71wm8c";
+       sha256 = "0c551e0e2f2a482bab54a8ced799fe6ab0157d20bd9769910a1061fb88e341cc";
        isLibrary = false;
        isExecutable = true;
        executableHaskellDepends = [ base containers haskeline parsec ];
@@ -30502,7 +30599,7 @@ self: {
      mkDerivation {
        pname = "caldims";
        version = "0.1.0";
-       sha256 = "0mlgxghah8mw0v17rywfj190kmc4jajpmjpgkpgfxdqzw8djyph0";
+       sha256 = "005e2f1be21fb7eede9defca7aa59284d50952908efb7cc206bc22a8e0eb8f56";
        isLibrary = true;
        isExecutable = true;
        libraryHaskellDepends = [
@@ -30523,7 +30620,7 @@ self: {
      mkDerivation {
        pname = "caledon";
        version = "3.2.1.0";
-       sha256 = "0mg3qn4zfsg5pvfp51zjvsy24mljkqh2f7bsjbz04zasx5852dz9";
+       sha256 = "e9375150e95a7d02fe927a1d27209e925622bcdef28772ddbee569f789c5e355";
        isLibrary = false;
        isExecutable = true;
        executableHaskellDepends = [
@@ -30547,7 +30644,7 @@ self: {
      mkDerivation {
        pname = "call";
        version = "0.2";
-       sha256 = "1hbzrhhx0cjgpxiq3200n38pl2m2y727zfmgfdfs45l1hqbvrldp";
+       sha256 = "b7d1bc17868116a25d73afba7fc4f1a20a7ad1b000888163bf4f32d021cc7fc1";
        isLibrary = true;
        isExecutable = true;
        libraryHaskellDepends = [
@@ -30571,7 +30668,7 @@ self: {
      mkDerivation {
        pname = "call-haskell-from-anything";
        version = "0.1.0.2";
-       sha256 = "0hav4kypy39lil49wrclrrajrwa5prmi7r7s6y9i3xshn1mhnjx1";
+       sha256 = "a14b0b6bb050f7119337fae4136bbe45f12c55ce94659e088d340d7ffd245b41";
        isLibrary = true;
        isExecutable = true;
        libraryHaskellDepends = [
@@ -30590,7 +30687,7 @@ self: {
      mkDerivation {
        pname = "camh";
        version = "0.0.2";
-       sha256 = "0xk1rxydncwfwj9cg4jwdgi8mlgwmk5nfk462pla26dqqg44aw2p";
+       sha256 = "577045c8c3b819a1e815864c67cbacfcd18ae26b5c92c792e48e33db7ccf6176";
        isLibrary = false;
        isExecutable = true;
        executableHaskellDepends = [ base bytestring Imlib terminfo ];
@@ -30607,7 +30704,7 @@ self: {
      mkDerivation {
        pname = "campfire";
        version = "0.2.1";
-       sha256 = "06m5d7b6dqmp3x09b1nib1rxjh1gvx84bhvfnydlb26093za71b4";
+       sha256 = "6485a3fe48c088459bb76ec34550df2f40d97358d18695401fb7e266d669a51a";
        libraryHaskellDepends = [
          aeson attoparsec base bytestring containers filepath
          http-enumerator http-types mtl old-locale process text time
@@ -30625,7 +30722,7 @@ self: {
      mkDerivation {
        pname = "canonical-filepath";
        version = "1.0.0.3";
-       sha256 = "0dg9d4v08gykbjmzafpakgwc51mq5d5m6ilmhp68czpl30sqjhwf";
+       sha256 = "8e43893518f47e86cc859546534b2bb886c2f89bea3af5ab5cd33f043669e935";
        libraryHaskellDepends = [ base deepseq directory filepath ];
        jailbreak = true;
        homepage = "http://github.com/nominolo/canonical-filepath";
@@ -30638,7 +30735,7 @@ self: {
      mkDerivation {
        pname = "canteven-config";
        version = "1.0.0.0";
-       sha256 = "1dkw0w43ajjgpczp8hmclr93v9scl75rlnsmxdjvwmv9phpj5559";
+       sha256 = "a994222fbc6957be65eb555b9acba14ca73d52a6ac42743fbb4f4a3508077cb6";
        libraryHaskellDepends = [ base unix yaml ];
        description = "A pattern for configuring programs";
        license = stdenv.lib.licenses.asl20;
@@ -30651,7 +30748,7 @@ self: {
      mkDerivation {
        pname = "canteven-log";
        version = "0.2.0.0";
-       sha256 = "15gfic3yzi4wc06s9zfpxs0ygxbhasarfn92dj7h0aqfgqa0wvff";
+       sha256 = "ce6d0e147e0e2b008f6c225997955670f5e781eed7fda40d609cc4ef078bee95";
        libraryHaskellDepends = [
          aeson base canteven-config directory filepath hslogger text yaml
        ];
@@ -30667,7 +30764,7 @@ self: {
      mkDerivation {
        pname = "cantor";
        version = "0.4";
-       sha256 = "16dx8v29gfwrrfb2lwkjlwbbp8n6jdpdcmwh15rrfx97rz4k0qz3";
+       sha256 = "e36330c9cf27759773099057d66e93c6a2bb16a772722a96cb99bb97c446bd99";
        isLibrary = false;
        isExecutable = true;
        executableHaskellDepends = [
@@ -30693,7 +30790,7 @@ self: {
      mkDerivation {
        pname = "cao";
        version = "0.1.1";
-       sha256 = "0rmq22fiaadpszckbj5k5gi4sr1jipinyrx9hwc21k5d185vsakd";
+       sha256 = "6d2abd0b0aadcc201887a9676fe38d32644de22bb3c835d9d7b729159d10b866";
        isLibrary = false;
        isExecutable = true;
        executableHaskellDepends = [
@@ -30712,7 +30809,7 @@ self: {
      mkDerivation {
        pname = "cap";
        version = "1.0.1";
-       sha256 = "1492x5hy5ljf0h40c045jd3w26f7jwqplgncka3dnw4mx9kq4g15";
+       sha256 = "253c8267ea9570db869acc3e7a3197c719c1479385000608044ed2e261e92291";
        isLibrary = false;
        isExecutable = true;
        executableHaskellDepends = [ array base containers haskell98 ];
@@ -30726,7 +30823,7 @@ self: {
      mkDerivation {
        pname = "capped-list";
        version = "1.2";
-       sha256 = "0sik7svknaam6fhlvb4p1ijwaiwrgssrdl9gmq1wmfx66g069xi9";
+       sha256 = "29f664c033a6bbca03ae2fd196b57e9947c5650c97ac4da13355293bb73e336a";
        libraryHaskellDepends = [ base ];
        description = "A list-like type for lazy sequences, with a user-defined termination value";
        license = stdenv.lib.licenses.bsd3;
@@ -30737,7 +30834,7 @@ self: {
      mkDerivation {
        pname = "capri";
        version = "0.1";
-       sha256 = "0hsrznygvn1b2qpc75591kzmcpqh7p5fhi1mw3ws2c75igjqbni7";
+       sha256 = "27da85e58be530a1f9e03544e8ca3d105f56ff0ca994c32e162bd8fdbcfd5943";
        isLibrary = false;
        isExecutable = true;
        executableHaskellDepends = [
@@ -30757,7 +30854,7 @@ self: {
      mkDerivation {
        pname = "caramia";
        version = "0.7.2.2";
-       sha256 = "1cvpyad7kmkndan1bfpfaav6lara8g78x02pgascrq8n73b2jcgs";
+       sha256 = "fa3129d63816e1ccb47a57808ece432a2b6ab652eeba15ac6a76d6799af277b3";
        isLibrary = true;
        isExecutable = true;
        libraryHaskellDepends = [
@@ -30780,7 +30877,7 @@ self: {
      mkDerivation {
        pname = "carboncopy";
        version = "0.1.2";
-       sha256 = "1wi06n0cdqkvyqqr9ji7nyjn09qqckskrzi3djcnxgwhwwp8da3i";
+       sha256 = "71a8862ee790bf6e996c23fe3cf564182760a5b727ca9431f67be2c6803520f2";
        isLibrary = false;
        isExecutable = true;
        executableHaskellDepends = [
@@ -30799,7 +30896,7 @@ self: {
      mkDerivation {
        pname = "carettah";
        version = "0.3.0";
-       sha256 = "1vjrppsqmlxajj7dxr13ynipp0adi6xxpqic5mma04sjgi3afrj2";
+       sha256 = "4266a7467c5213a06a2d2ce2dbbb894d817ba3f523e4de8e94aad38af5bd59ee";
        isLibrary = false;
        isExecutable = true;
        executableHaskellDepends = [
@@ -30818,7 +30915,7 @@ self: {
      mkDerivation {
        pname = "carray";
        version = "0.1.5.2";
-       sha256 = "0kjqxjnamhnpjjf2bgm1gnsy6jx1fjbn5mx394pyx1vq3lkfgfb0";
+       sha256 = "60b9e7261d7887ee2f49a3d7629774a14be3b57da1be259c94d7c2aaacec584e";
        libraryHaskellDepends = [
          array base binary bytestring ix-shapable syb
        ];
@@ -30833,7 +30930,7 @@ self: {
      mkDerivation {
        pname = "cartel";
        version = "0.14.2.6";
-       sha256 = "05m4b8gi5ysx73yzlhl27fx9i8fnlihxwsyh6a0702kzwgn40icc";
+       sha256 = "8c4540ece37f0a708032d06bde61a4d6a198ba3b8242fafd385dfb121f5aa416";
        isLibrary = true;
        isExecutable = true;
        libraryHaskellDepends = [
@@ -30856,7 +30953,7 @@ self: {
      mkDerivation {
        pname = "casadi-bindings";
        version = "2.3.0.1";
-       sha256 = "1a1644lwzarfcjgnhzyi7lp0xhxmzm80h6nini6bcgkm4g4c9h4q";
+       sha256 = "98c0c4c823753eb64cb4d11a0850fdb5c30e2e3dd17f689f642eabcf292126a8";
        libraryHaskellDepends = [
          base binary casadi-bindings-core casadi-bindings-internal cereal
          containers linear vector vector-binary-instances
@@ -30875,7 +30972,7 @@ self: {
      mkDerivation {
        pname = "casadi-bindings-control";
        version = "2.0.0.1";
-       sha256 = "03lpg9vp47db8wc4waajfh1z96f3nc1v29wqc9a58vrhfdnhp52w";
+       sha256 = "5c940b6d73306f5454629827b103b3c399f4037452294e1847ab1d72777a970e";
        libraryHaskellDepends = [
          base casadi-bindings-core casadi-bindings-internal vector
        ];
@@ -30891,7 +30988,7 @@ self: {
      mkDerivation {
        pname = "casadi-bindings-core";
        version = "2.3.0.1";
-       sha256 = "0agzm3bqb3fii626m40684g7hahj2mhv60xx0smhw78z978cqw57";
+       sha256 = "a770ccd0491f1d0eab06bd03b36115122a781e4106906a8489d18d85d7a8ff29";
        libraryHaskellDepends = [ base casadi-bindings-internal vector ];
        libraryPkgconfigDepends = [ casadi ];
        description = "autogenerated low level bindings to casadi";
@@ -30904,7 +31001,7 @@ self: {
      mkDerivation {
        pname = "casadi-bindings-internal";
        version = "0.1.3.0";
-       sha256 = "1kazy8xppydbl6gkdn1y1gv2lz38sif6i92crkxb476xz0fvmf00";
+       sha256 = "00b8ba1df8dd1cb2facc4ca4685cd4687c2af60b3ed8369fa1abf97b3bf25fcd";
        libraryHaskellDepends = [ base vector ];
        libraryPkgconfigDepends = [ casadi ];
        homepage = "http://github.com/ghorn/casadi-bindings";
@@ -30920,7 +31017,7 @@ self: {
      mkDerivation {
        pname = "casadi-bindings-ipopt-interface";
        version = "1.9.0.3";
-       sha256 = "1h1qpl8ch8riz614fssirlp5j3vzi39jjajwjnfqvgw7h8sdam2a";
+       sha256 = "4a54d5348287bf8d9d955c2a29d3887f0f592ecd516b4782f93123c810bd38c0";
        libraryHaskellDepends = [
          base casadi-bindings-core casadi-bindings-internal vector
        ];
@@ -30937,7 +31034,7 @@ self: {
      mkDerivation {
        pname = "casadi-bindings-snopt-interface";
        version = "1.9.0.3";
-       sha256 = "0sygbbvdrd1za6k9yf0yqxfd48imlhghzf6sy0dh77jmdhlb8asw";
+       sha256 = "5c2bb4286c559e031bf0dab80f1fa43522d25cc71e389fa6513fb4dcf65acf6b";
        libraryHaskellDepends = [
          base casadi-bindings-core casadi-bindings-internal vector
        ];
@@ -30954,7 +31051,7 @@ self: {
      mkDerivation {
        pname = "cascading";
        version = "0.1.0";
-       sha256 = "0w9zhaf4a09nl3b1sffllgf0zc10lzy38a8k4f7sbc0hr45wzj5y";
+       sha256 = "bec8cf0bc910b0a58f23132934fca720b00fdca3d4391dd6a03601459c823f71";
        libraryHaskellDepends = [
          base blaze-builder bytestring colour containers lens mtl text
          utf8-string web-routes
@@ -30970,7 +31067,7 @@ self: {
      mkDerivation {
        pname = "case-conversion";
        version = "0.1";
-       sha256 = "1njnhbqj1c0zxr0vkb7qh51764f3hscjqjq2yzgyy1shfrc1y1i4";
+       sha256 = "24061f58765007efdff7024b2c9986c311734281f8acb941ee1fb020f18256da";
        libraryHaskellDepends = [ base ];
        homepage = "www.xy30.com";
        description = "Convert between different cases";
@@ -30984,7 +31081,7 @@ self: {
      mkDerivation {
        pname = "case-insensitive";
        version = "1.2.0.4";
-       sha256 = "07nm40r9yw2p9qsfp3pjbsmyn4dabrxw34p48171zmccdd5hv0v3";
+       sha256 = "63830d4b6b8cd51f4e40e492c17b5eaa11ebab5ef28eeb344e57709f3220d51e";
        libraryHaskellDepends = [ base bytestring deepseq hashable text ];
        testHaskellDepends = [
          base bytestring HUnit test-framework test-framework-hunit text
@@ -30999,7 +31096,7 @@ self: {
      mkDerivation {
        pname = "cased";
        version = "0.1.0.0";
-       sha256 = "08xdc0mpp6b6inaxh6cr6ni08sy2ahfcbq8xbs3m4cfqbrqfd543";
+       sha256 = "8394e6705ed83152875e1de1c51c54c26b04a2359919d8958d66997b2b60ad23";
        libraryHaskellDepends = [ base text ];
        homepage = "https://github.com/jb55/cased";
        description = "Track string casing in its type";
@@ -31013,7 +31110,7 @@ self: {
      mkDerivation {
        pname = "cases";
        version = "0.1.2.1";
-       sha256 = "0p2dfnyj887bnp414psbmkin4ybmflvgr1q2npvcih2sxianywkd";
+       sha256 = "6d726f55ec5ac0c8f6b50287fc3675757962e3ac4b5f12c8b5eb2024bd754d5c";
        libraryHaskellDepends = [ attoparsec base-prelude loch-th text ];
        testHaskellDepends = [
          base HTF HUnit loch-th placeholders QuickCheck text
@@ -31031,7 +31128,7 @@ self: {
      mkDerivation {
        pname = "cash";
        version = "0.1.0.1";
-       sha256 = "0pwn33dpv5bgs74i8x6q47hsbl0jg68xwhjjiwyjdyl6sb3rfih7";
+       sha256 = "074697c7d286fa263d8f5242de917912d0a5e121d87414c9d16f957ddb18965f";
        libraryHaskellDepends = [
          base deepseq haskell98 HaXml network parallel pretty
        ];
@@ -31046,8 +31143,8 @@ self: {
     ({ mkDerivation, base, split }:
      mkDerivation {
        pname = "casing";
-       version = "0.1.0.0";
-       sha256 = "0d7frpz512gig2crpx3kxsnfwf3kbcklkann158wrzg8q02jhjhi";
+       version = "0.1.0.1";
+       sha256 = "9039e45dc21851b7b6e5e58c79603beb27a03a79588c3176150d5c83d6e077ac";
        libraryHaskellDepends = [ base split ];
        description = "Convert between various source code casing conventions";
        license = stdenv.lib.licenses.mit;
@@ -31061,7 +31158,7 @@ self: {
      mkDerivation {
        pname = "cassandra-cql";
        version = "0.5.0.2";
-       sha256 = "1nk0psvmzhvxls4h0p4blrm8qjn6lyh08bdxpiagpw6nrpvbda54";
+       sha256 = "a4a8b6f6cdd6f0fb54bcbd2d04a0a7c64a8c6aa68b5c0089a67dc35fb7be60da";
        libraryHaskellDepends = [
          base bytestring cereal containers cryptohash Decimal hslogger
          MonadCatchIO-transformers mtl network resource-pool stm text time
@@ -31076,7 +31173,7 @@ self: {
      mkDerivation {
        pname = "cassandra-thrift";
        version = "0.8.5.1";
-       sha256 = "0hmmi0g32nfwcny56sb4jw463jp7hiwj2hhv42bf8h9az30vjxwc";
+       sha256 = "8c77b9c1f82a41e496201b42217984e7ca610897646953bc65dc59311e88b542";
        libraryHaskellDepends = [ base bytestring containers Thrift ];
        homepage = "http://cassandra.apache.org/";
        description = "thrift bindings to the cassandra database";
@@ -31093,7 +31190,7 @@ self: {
      mkDerivation {
        pname = "cassava";
        version = "0.4.3.1";
-       sha256 = "1b62zx6fna0nx3qvs316bwc39l8qan9fpm82f1p28ipkyq0ym2g3";
+       sha256 = "e389ea01f6f346246e7002d5eb925518d134185f260cbdf1e81628eb4cffc2ac";
        libraryHaskellDepends = [
          array attoparsec base blaze-builder bytestring containers deepseq
          hashable text unordered-containers vector
@@ -31115,7 +31212,7 @@ self: {
      mkDerivation {
        pname = "cassava-conduit";
        version = "0.2.0";
-       sha256 = "09z7i147qs292xl3hqqi1x1kigrxdh5s8gzin12fgcpbyjggv30n";
+       sha256 = "168cfd9ef4ebb2e744b0f13fa40b6c3dbf38430f116338681749687c4888e727";
        libraryHaskellDepends = [
          array base bifunctors bytestring cassava conduit conduit-extra
          containers mtl
@@ -31134,7 +31231,7 @@ self: {
      mkDerivation {
        pname = "cassava-streams";
        version = "0.1.1.0";
-       sha256 = "08b144jm9805wqj68cgmh5j0bq03i439cpbxvq5m2k72m9s81kl7";
+       sha256 = "87ce8074aae24c510bde7d5d96068903e0056481f5316424e605a05425216121";
        isLibrary = true;
        isExecutable = true;
        libraryHaskellDepends = [
@@ -31156,7 +31253,7 @@ self: {
      mkDerivation {
        pname = "cassette";
        version = "0.1.0";
-       sha256 = "04qnk1s4bdj3wbbxdwzzvpnhkcgma8c4qfkg454ybg7f8kyv6h7x";
+       sha256 = "fd40b3fd44eebce549216f3a4c1852f5b109edddfff3d6d7e243b64574981613";
        libraryHaskellDepends = [ base ];
        description = "A combinator library for simultaneously defining parsers and pretty printers";
        license = stdenv.lib.licenses.bsd3;
@@ -31173,7 +31270,7 @@ self: {
      mkDerivation {
        pname = "cassy";
        version = "0.7.1";
-       sha256 = "0nm1xn7rkxqdap0k3lcl29jp7ajn5fypaqx3ag1zbyp8llc7xy0f";
+       sha256 = "0ef87e18a5e8faf5c353a36375bd2b56aa73651294d131c1550df7998feda15a";
        libraryHaskellDepends = [
          aeson async attoparsec base binary bytestring cassandra-thrift
          cereal conduit containers data-default errors exceptions mtl
@@ -31199,7 +31296,7 @@ self: {
      mkDerivation {
        pname = "castle";
        version = "0.1.0.1";
-       sha256 = "0h6dvc8lzlxkgkqkj3zwxjdmws29g4fsw7p6ysd7i54xqb8vy5ka";
+       sha256 = "6a16bfd1c29d94789af6e61eae1d7949685e9becfc0f39f17cb3d34f11dbcd40";
        isLibrary = false;
        isExecutable = true;
        executableHaskellDepends = [
@@ -31216,7 +31313,7 @@ self: {
      mkDerivation {
        pname = "casui";
        version = "0.3";
-       sha256 = "1vjhg9dxg23q0dqr07gbrg92h3m9r38d7jb3c4sxnw6gaj76f5gw";
+       sha256 = "fc15678e54cf70db356163c9d3d0c8a90e28d2cbeb1d9071037888d75b7a50ee";
        isLibrary = false;
        isExecutable = true;
        executableHaskellDepends = [ base gtk haskell98 mtl parsec ];
@@ -31231,7 +31328,7 @@ self: {
      mkDerivation {
        pname = "catamorphism";
        version = "0.5.1.0";
-       sha256 = "1lhqdr0l3wc59ms1i1xmwp6iy4n4xrd8pi0an0n0jgxw5j2sfbkq";
+       sha256 = "782ea7852cbc3f092cb00ac48b5aeec4121fcde5b58718744d85f141416e18d2";
        libraryHaskellDepends = [ base template-haskell ];
        homepage = "https://github.com/frerich/catamorphism";
        description = "A package exposing a helper function for generating catamorphisms";
@@ -31243,7 +31340,7 @@ self: {
      mkDerivation {
        pname = "catch-fd";
        version = "0.2.0.2";
-       sha256 = "05fvrkvqyj7xdn6vvdwhfbym7rg9fl7r7lzzcsr2cx59iqi23frx";
+       sha256 = "3dbb21228ea97426b266ffd3930f75e9e553fd7290b7bd8d6dfd488ff7ccdb15";
        libraryHaskellDepends = [ base mtl transformers ];
        jailbreak = true;
        homepage = "http://github.com/sonyandy/catch-fd";
@@ -31257,7 +31354,7 @@ self: {
      mkDerivation {
        pname = "categorical-algebra";
        version = "0.0.0.1";
-       sha256 = "1kx6195mfnw4aqmcd1m4s8z5l1s8zh69in00p9a0mxm3xj3pfvpl";
+       sha256 = "f46e7787eca3f60a54ba00d8980cfc48075a3ed2a486c62a56845b574b0aa6cf";
        libraryHaskellDepends = [ base newtype pointless-haskell void ];
        description = "Categorical Monoids and Semirings";
        license = stdenv.lib.licenses.bsd3;
@@ -31269,7 +31366,7 @@ self: {
      mkDerivation {
        pname = "categories";
        version = "1.0.7";
-       sha256 = "18ihv16g4w0s6n89c64j4998hbsgzhp5w9ph2gdkygq7f30cx7f2";
+       sha256 = "c29dcec070073f3fdb13f0265e2efc4f2f88522292189690351a70f24cd830a2";
        libraryHaskellDepends = [ base void ];
        homepage = "http://github.com/ekmett/categories";
        description = "Categories";
@@ -31288,7 +31385,7 @@ self: {
      mkDerivation {
        pname = "category-extras";
        version = "1.0.2";
-       sha256 = "168psp1qd80838b9945499qh99jidbl2gngcrjqk6hb0qsyhckcq";
+       sha256 = "984d06bdc6604133b1ccecd927e86a51a604714aa49094161a08a086c3d51799";
        libraryHaskellDepends = [
          adjunctions bifunctors categories comonad comonad-extras
          comonad-transformers comonads-fd contravariant distributive either
@@ -31309,7 +31406,7 @@ self: {
      mkDerivation {
        pname = "cautious-file";
        version = "1.0.2";
-       sha256 = "1sw5ngwrarq1lsd4c6v2wdmgbhkkq6kpybb62r8ccm11ddgn3yiq";
+       sha256 = "38fa615f6b2154c65016662d7fa7c173c2f56ae3621b469aa6016795f9b385eb";
        revision = "1";
        editedCabalFile = "c6183204fc6d4767c8b8c4b954f6908fd376054c28904866a90a66497970d893";
        libraryHaskellDepends = [
@@ -31327,7 +31424,7 @@ self: {
      mkDerivation {
        pname = "cayley-client";
        version = "0.1.3.0";
-       sha256 = "0wzpnylzlyx0lanjqg44b134s2irb55072dz5s8ljq76acg1jmfl";
+       sha256 = "d455191e53e66049912ebf89034a59390a4d4658843c2cada2a07bfaa9b7f773";
        libraryHaskellDepends = [
          aeson attoparsec base bytestring exceptions http-client
          http-conduit lens lens-aeson mtl text transformers
@@ -31347,7 +31444,7 @@ self: {
      mkDerivation {
        pname = "cblrepo";
        version = "0.17.1";
-       sha256 = "0yp2z0dpw19r6av71ghlp1pzal7276wlywsmjz5xmkggy04v1xnj";
+       sha256 = "d2f6b009f0efcddacb9755734fb939e250f56fb814be70b63239057e1bf8e27a";
        isLibrary = false;
        isExecutable = true;
        executableHaskellDepends = [
@@ -31367,7 +31464,7 @@ self: {
      mkDerivation {
        pname = "cci";
        version = "0.3.1";
-       sha256 = "0pvap67fn9kmjvn2qqq3x99k3mzrrsnb6q6fhawvyxv8drihsfc7";
+       sha256 = "87390d636e6877bfb982ce60b3accef9d73153ea03632cec967526eb8eb96a5f";
        isLibrary = true;
        isExecutable = true;
        libraryHaskellDepends = [ base bytestring ];
@@ -31386,7 +31483,7 @@ self: {
      mkDerivation {
        pname = "ccnx";
        version = "0.0.0";
-       sha256 = "18gnm6skzdnh6cis7l7v3d5813zn6irw6nywg6shffrn8v2y6xh7";
+       sha256 = "0776e3c546363b07b579dc5bc37334f68f804a1bfbd0a32333d0b63fb5a9f6a1";
        libraryHaskellDepends = [ base bytestring ];
        jailbreak = true;
        homepage = "http://tomahawkins.org";
@@ -31401,7 +31498,7 @@ self: {
      mkDerivation {
        pname = "cctools-workqueue";
        version = "3.6.1.0.1.0.0.1";
-       sha256 = "1nqczr2f4bv107sdhqnllqcaz413r4f69f9ypshig8jyxzpcdwn3";
+       sha256 = "c3f2c6eeef5ea217a1be3eb9641cc92390af18a6d462d8f401612fe244fe0cdb";
        libraryHaskellDepends = [
          bindings-cctools bytestring lens monad-loops unix
        ];
@@ -31419,7 +31516,7 @@ self: {
      mkDerivation {
        pname = "cedict";
        version = "0.2.5";
-       sha256 = "13nhwd07ly2ppgbakffr2cc2idacz0q5bahz0819jjascspm32vy";
+       sha256 = "7e8b51af665a499902021faa5530f84cb5281813d9b9a9d6bb57787a40e3d08e";
        isLibrary = true;
        isExecutable = true;
        libraryHaskellDepends = [
@@ -31438,7 +31535,7 @@ self: {
      mkDerivation {
        pname = "cef";
        version = "0.1.2";
-       sha256 = "0f5qj5xhmlys09i4vis3ricz0ym2hmdn53kgcb1qk23y0m4s94ci";
+       sha256 = "9191a449057e8889c3626f8e625b85a27af059cc43c74d6202dad30a7b91b838";
        libraryHaskellDepends = [ base bytestring text time ];
        testHaskellDepends = [ base directory doctest filepath ];
        homepage = "http://github.com/picussecurity/haskell-cef.git";
@@ -31455,7 +31552,7 @@ self: {
      mkDerivation {
        pname = "ceilometer-common";
        version = "0.2.3";
-       sha256 = "1zqqh7k627yw6vfcdihl2gw8hh3l9gxj283azmmcc9pm15grblps";
+       sha256 = "fad2955f09f526c66afd6a2021fb4b744088f81314c6c6dc36dc1f61e68118ff";
        libraryHaskellDepends = [
          base bimap binary bytestring containers foldl lens pipes siphash
          template-haskell text vaultaire-common
@@ -31476,7 +31573,7 @@ self: {
      mkDerivation {
        pname = "cellrenderer-cairo";
        version = "1.0.0.0";
-       sha256 = "05cdrq1mrrhfbsk1w1dg5qayan0h9m92r4gqgcpzfa9a073w78zw";
+       sha256 = "fca3c3c7012a29f72f7bf8912c524d1058e5152eaf051ea65e0ee65c03ce8d15";
        libraryHaskellDepends = [ base cairo glib gtk mtl ];
        libraryToolDepends = [ c2hs ];
        jailbreak = true;
@@ -31489,7 +31586,7 @@ self: {
      mkDerivation {
        pname = "cereal";
        version = "0.4.1.1";
-       sha256 = "15rhfn9hrjm01ksh9xpz9syxsp9vkvpp6b736iqq38wv2wb7416z";
+       sha256 = "df047216179ba3817134e32c73ef9e3b5dddbd4efff604f50ca0ca0c93753097";
        libraryHaskellDepends = [
          array base bytestring containers ghc-prim
        ];
@@ -31504,7 +31601,7 @@ self: {
      mkDerivation {
        pname = "cereal-conduit";
        version = "0.7.2.3";
-       sha256 = "0s1s8jm25wxj44x44vjz4kz5qblkyjaz7f8rw5i81bzam32afj9s";
+       sha256 = "3a49a7c4a8eaaf8062e119b9f395f4932e5cfe245f6e423a21b2f322aa443a68";
        libraryHaskellDepends = [
          base bytestring cereal conduit resourcet transformers
        ];
@@ -31521,7 +31618,7 @@ self: {
      mkDerivation {
        pname = "cereal-derive";
        version = "0.1.1";
-       sha256 = "04mlg1r2qvrwdzcfbf1aqs4bf9n2gc7cwv73fbhld2ji5naa6fwb";
+       sha256 = "8b3ba3942d518a46e172e36cce0e7bc226b788c62ab8e5d86f3c6f2c7278b412";
        libraryHaskellDepends = [ base cereal ghc-prim ];
        jailbreak = true;
        description = "Automatic deriving of Serialize using GHC.Generics";
@@ -31533,7 +31630,7 @@ self: {
      mkDerivation {
        pname = "cereal-enumerator";
        version = "0.3.1";
-       sha256 = "0lpsj4f7v4sgrr6lf8jl07xwj8j3i3wj23as0imswk71f7xwfnnk";
+       sha256 = "d35ac7fb71e14cae6b045a0d21f9884322c9fb015422474dce4f937d1c91fa52";
        libraryHaskellDepends = [ base bytestring cereal enumerator ];
        description = "Deserialize things with cereal and enumerator";
        license = stdenv.lib.licenses.publicDomain;
@@ -31545,7 +31642,7 @@ self: {
      mkDerivation {
        pname = "cereal-ieee754";
        version = "0.1";
-       sha256 = "1gr22ziz9bj4q3y8j1vg46m648zqvbajfdks8p64xc28ci25pw2s";
+       sha256 = "5af05b446448b04ecc457a3627d5daf82362aa216f0789fcc044aef4e31722bf";
        libraryHaskellDepends = [ array base cereal ];
        jailbreak = true;
        homepage = "http://github.com/jystic/cereal-ieee754";
@@ -31563,7 +31660,7 @@ self: {
      mkDerivation {
        pname = "cereal-plus";
        version = "0.4.0";
-       sha256 = "109y4ydhbl68rsi95fwck3gq1wvn9bpv0r9g9b7fm8wsgd06gipc";
+       sha256 = "ecc667407b9aa3eace4a2f65b0ef4a76f380df988cbb92a2cec8d0059b273e81";
        libraryHaskellDepends = [
          array base bytestring cereal containers errors hashable hashtables
          mmorph mtl stm text time unordered-containers vector
@@ -31585,7 +31682,7 @@ self: {
      mkDerivation {
        pname = "cereal-text";
        version = "0.1.0.1";
-       sha256 = "1wsp4zb6ib8fym4kaq6ixm7l2slljmz6waliab3dyb2zdl400spq";
+       sha256 = "f86a00086d5f2cdfc652912a6e7e95946a414fedd1603549f50ead68d62757f3";
        libraryHaskellDepends = [ base cereal text ];
        homepage = "https://github.com/ulikoehler/cereal-text";
        description = "Data.Text instances for the cereal serialization library";
@@ -31597,7 +31694,7 @@ self: {
      mkDerivation {
        pname = "cereal-vector";
        version = "0.2.0.1";
-       sha256 = "0czrb4l1n73cfxxlzbcqfa34qa3gw0m5w5mlz0rawylyqfk8a1pz";
+       sha256 = "ff0685a6c39e7aae32f8b4165e2ae06f284c867298ad4f7b776c1c1b2859f933";
        libraryHaskellDepends = [ base bytestring cereal vector ];
        testHaskellDepends = [ base cereal QuickCheck vector ];
        homepage = "https://github.com/acfoltzer/cereal-vector";
@@ -31613,7 +31710,7 @@ self: {
      mkDerivation {
        pname = "certificate";
        version = "1.3.9";
-       sha256 = "18g5rq7lpxmvmlnz610537w6mix6z6kxjrfj2ylbhkc81r5pn9g6";
+       sha256 = "e6257b4b0e884db8a817d265d9a7f9a6c76af8190504f32dadbbf64b0fcee5a1";
        isLibrary = true;
        isExecutable = true;
        libraryHaskellDepends = [
@@ -31633,7 +31730,7 @@ self: {
      mkDerivation {
        pname = "cf";
        version = "0.4.1";
-       sha256 = "1z8hqd06nrrbgmg2gpryalhnk4z0sxm7is46sgpy09x9p6xd0fqx";
+       sha256 = "1d3bd0bab9a927e0efd386e8786ad7e0936921553edf275e7d2b676b40c310fd";
        revision = "1";
        editedCabalFile = "9fd574edfce6ea014201ccc3591638de0574f251290bcf0f44a8a00338131692";
        libraryHaskellDepends = [ base ];
@@ -31654,7 +31751,7 @@ self: {
      mkDerivation {
        pname = "cfipu";
        version = "1.1.0.4";
-       sha256 = "1lwgqibxrs8n3czhpyg1halizsmz5jd8r2z8ham4pwi58815fzij";
+       sha256 = "327e57024225f24baa82e88b8c9a2cbfea1fa982e1f90b3f1b16e9dc57c48fd3";
        isLibrary = false;
        isExecutable = true;
        executableHaskellDepends = [
@@ -31674,7 +31771,7 @@ self: {
      mkDerivation {
        pname = "cflp";
        version = "2009.2.1";
-       sha256 = "01j4904fa8z2wmflqs3q1g3dg966dllbp2sbxxbghh0hhzwyg0vy";
+       sha256 = "7e83e7f9871040f856ef4b8bbb286dc6a4d7c60b78684c5de5e223e508484406";
        libraryHaskellDepends = [
          base containers control-monad-omega HUnit incremental-sat-solver
          level-monad logict MonadRandom mtl random stream-monad syb
@@ -31693,7 +31790,7 @@ self: {
      mkDerivation {
        pname = "cfopu";
        version = "1.0.0";
-       sha256 = "1vd1ilcdd1k081bg4nk1zazdsd9fbz7zzcz453ff0xxjp9xl1b3z";
+       sha256 = "7fac407bbab277e0dc28e4b3ffcf5f2e35ddbefa615af256406086d6188da1ed";
        isLibrary = false;
        isExecutable = true;
        executableHaskellDepends = [
@@ -31712,7 +31809,7 @@ self: {
      mkDerivation {
        pname = "cg";
        version = "0.0.9.0";
-       sha256 = "0slsckr1xyn1b3vb2xhd2diqhr9cdbkn9g5hfsy0q6sjiy979vpl";
+       sha256 = "f4ee74928f521b0cbc76b0bc64e76a2c658863130d76b1f658c1fa1ef2649a6a";
        isLibrary = false;
        isExecutable = true;
        executableHaskellDepends = [
@@ -31731,7 +31828,7 @@ self: {
      mkDerivation {
        pname = "cgen";
        version = "0.0.5";
-       sha256 = "18k9na7gwmnmn5gdin1qi041cb7w49xcgdnjjpc3dhmfiqnq41q8";
+       sha256 = "0807822d8eaec236d895d2b6c77a22fc2c16088838d8d85eb1d556fe8eb269a2";
        isLibrary = true;
        isExecutable = true;
        executableHaskellDepends = [
@@ -31752,7 +31849,7 @@ self: {
      mkDerivation {
        pname = "cgi";
        version = "3001.2.2.2";
-       sha256 = "0q1pxpa8gi42c0hsidcdkhk5xr5anfrvhqsn3iksr9c0rllhz193";
+       sha256 = "23850f29cd80a5ac671c5663b8b3b3aae45e269c8db5a8216082c487d4ed3760";
        libraryHaskellDepends = [
          base bytestring containers exceptions mtl multipart network
          network-uri old-locale old-time parsec xhtml
@@ -31767,7 +31864,7 @@ self: {
      mkDerivation {
        pname = "cgi-undecidable";
        version = "3000.0.0";
-       sha256 = "1xh3q0s7398gd3513ycxypnj0m9jn0kdbb7459dsb459kbvzdpab";
+       sha256 = "4bddf6f79aa990a55b2ae4acd526b0325520edf59df911ca680fa57134c003f6";
        libraryHaskellDepends = [ base cgi mtl ];
        description = "Undecidable instances for the cgi package";
        license = stdenv.lib.licenses.bsd3;
@@ -31778,7 +31875,7 @@ self: {
      mkDerivation {
        pname = "cgi-utils";
        version = "0.2.1";
-       sha256 = "0msljq31bz40hsrhhq9qhxrgmdlqq32l3ykcy4wviv8kmc3dic7p";
+       sha256 = "f7b0d806ab13edb839f16cfa41c5c098b6fa7287386108b38680fc1506965457";
        revision = "1";
        editedCabalFile = "df1cb1e658d9b79adde373fc31a1d7553a4803f8967c760abf233e75913ddd52";
        libraryHaskellDepends = [ base cgi containers mtl random ];
@@ -31797,7 +31894,7 @@ self: {
      mkDerivation {
        pname = "cgrep";
        version = "6.5.2";
-       sha256 = "021cwllz5cljb9j0klh3xn4jpg2vxfqwqyjm631gkpzndc9711wr";
+       sha256 = "998770126bf6dff9c230557accb1eb5bbc2b89ed03d209645a92b2f229e52c08";
        isLibrary = false;
        isExecutable = true;
        executableHaskellDepends = [
@@ -31815,7 +31912,7 @@ self: {
      mkDerivation {
        pname = "chain-codes";
        version = "0.3.0.0";
-       sha256 = "0vw6qwgcljxgrjrsgkpkdqqnpxvibnsc0c4h5kyg5p8h4avsk8k6";
+       sha256 = "66a2a9b72210ddf2fc2c9030c0b45d71f76b316ef3cea7b3ccaf4bca1ec7866f";
        libraryHaskellDepends = [ base containers JuicyPixels ];
        testHaskellDepends = [ base containers hspec JuicyPixels ];
        homepage = "http://github.com/Fuuzetsu/chain-codes";
@@ -31828,7 +31925,7 @@ self: {
      mkDerivation {
        pname = "chalk";
        version = "0.1.0.1";
-       sha256 = "0d9qp512ww5cpvv7pby4saqjxy9qyid3gf0gndqhglikcc0wayxy";
+       sha256 = "be7bc5016333d20771b30fb8375af438f92eb1d2c4af7bf6beac702e42b93835";
        libraryHaskellDepends = [ base ];
        jailbreak = true;
        homepage = "http://github.com/joom/chalk";
@@ -31843,7 +31940,7 @@ self: {
      mkDerivation {
        pname = "chalkboard";
        version = "1.9.0.16";
-       sha256 = "0786fxylzz73kgbyyy6pz5fhk7rfh4fnrbq0br7ghg74qka66sb9";
+       sha256 = "696963d4c4e43cf84e5e00af6c1d812e9f095df9d778efd79be3fc4f7d77061d";
        isLibrary = true;
        isExecutable = true;
        libraryHaskellDepends = [
@@ -31862,7 +31959,7 @@ self: {
      mkDerivation {
        pname = "chalkboard-viewer";
        version = "0.1";
-       sha256 = "1gvnp176j8gd0s6wzq10zpiqkn3wma99pwn3f78wgxm9rh588gh2";
+       sha256 = "023e840acca9f6c7d171c3f29b92aa7cd889e3fd20e0cf8d06ed21694eb876bf";
        libraryHaskellDepends = [ array base chalkboard GLUT OpenGL time ];
        jailbreak = true;
        homepage = "http://ittc.ku.edu/~andygill/chalkboard.php";
@@ -31876,7 +31973,7 @@ self: {
      mkDerivation {
        pname = "chalmers-lava2000";
        version = "1.5";
-       sha256 = "1xrzh1mqa6d3hwr7lfazfskh6bklbj3kv9vlm40n650l2l42arga";
+       sha256 = "ea6525081514146301a974a73d875c742e03a7765f397a3287a319856b803ff7";
        libraryHaskellDepends = [ array base process random ];
        homepage = "http://projects.haskell.org/chalmers-lava2000/Doc/tutorial.pdf";
        description = "Hardware description EDSL";
@@ -31888,7 +31985,7 @@ self: {
      mkDerivation {
        pname = "chan-split";
        version = "0.5.0";
-       sha256 = "1mzvrxcf263gs61hj7gafra1cqvpfbzy7rza7ql0xvnmj2g2ybrc";
+       sha256 = "2c2f2f9e90d5ee0e283eeae7e3ff727763165476ea1d0983d16f18e158cffbd7";
        libraryHaskellDepends = [ base stm ];
        homepage = "http://brandon.si/code/module-chan-split-released/";
        description = "Concurrent Chans as read/write pairs. Also provides generic Chan pair class.";
@@ -31900,7 +31997,7 @@ self: {
      mkDerivation {
        pname = "change-monger";
        version = "0.0";
-       sha256 = "071qc0nhg4431c32z4qh23fiw1bjd1jc4s0sgq5v8ymwz4rfy9a2";
+       sha256 = "4225ef32f9bc7ab40b7e1a68c2646872051edd1010932f060b8390072d60381c";
        isLibrary = true;
        isExecutable = true;
        libraryHaskellDepends = [ base process ];
@@ -31917,7 +32014,7 @@ self: {
      mkDerivation {
        pname = "charade";
        version = "0.1.1.2";
-       sha256 = "0vi82z2c3km5shyk3wwb07y3cqcnkvkgvbl1s36a50kbz65jrl64";
+       sha256 = "c4d02c8bf96b82a2ccd081aefde69e966136fc018bf3313dd4a5cec1c417286e";
        isLibrary = true;
        isExecutable = true;
        libraryHaskellDepends = [
@@ -31942,7 +32039,7 @@ self: {
      mkDerivation {
        pname = "charset";
        version = "0.3.7.1";
-       sha256 = "1gn0m96qpjww8hpp2g1as5yy0wcwy4iq73h3kz6g0yxxhcl5sh9x";
+       sha256 = "3d415d2883bd7bf0cc9f038e8323f19c71e07dd12a3c712f449ccb8b4daac0be";
        libraryHaskellDepends = [
          array base bytestring containers semigroups unordered-containers
        ];
@@ -31956,7 +32053,7 @@ self: {
      mkDerivation {
        pname = "charsetdetect";
        version = "1.0";
-       sha256 = "1w302v6pmi448k2rq2cc7wp1javsd9rgk7r7i43lxvbjhniydn7p";
+       sha256 = "f7d8e6a38572ed4e0789279ff9726a7a2b192e3f8c099cc54484c47acd1660f0";
        libraryHaskellDepends = [ base bytestring ];
        jailbreak = true;
        homepage = "http://www.github.com/batterseapower/charsetdetect";
@@ -31969,7 +32066,7 @@ self: {
      mkDerivation {
        pname = "charsetdetect-ae";
        version = "1.0.1";
-       sha256 = "0bvdnv608glim8yn4dvh3av7x0fxxp3z6719j0n005bygdfgjxna";
+       sha256 = "ca76f95c7b7e15002c90291cf3c7eddd817eb61a7037623daa913e04ccb66d2f";
        libraryHaskellDepends = [ base bytestring ];
        homepage = "http://github.com/Aelve/charsetdetect-ae";
        description = "Character set detection using Mozilla's Universal Character Set Detector";
@@ -31981,7 +32078,7 @@ self: {
      mkDerivation {
        pname = "chart-histogram";
        version = "1.0.0";
-       sha256 = "130jbbbb1spkbqapxys0bqr0spq6c03x1m259alg5wxnl8xnn4w5";
+       sha256 = "85136b3ba2b6f3f2a84a45d4d00760065f0d325e40fb7e155ef3eab0d65a128c";
        libraryHaskellDepends = [ base Chart ];
        jailbreak = true;
        description = "Easily render histograms with Chart";
@@ -31996,7 +32093,7 @@ self: {
      mkDerivation {
        pname = "chaselev-deque";
        version = "0.5.0.5";
-       sha256 = "1x2301faqkchkzrvbnganly341jilvg1fmx6lazgbs98cbazhn2d";
+       sha256 = "4d58f8d56228e9f5bea2a65717dea65106323cb5ead9b5f39f904dac5c0043f4";
        libraryHaskellDepends = [
          abstract-deque array atomic-primops base ghc-prim transformers
          vector
@@ -32021,7 +32118,7 @@ self: {
      mkDerivation {
        pname = "chatter";
        version = "0.5.2.0";
-       sha256 = "01594wp13kigqvr27112fmsrgz4cny4vlprqvyygp90k8mavxw8s";
+       sha256 = "1af1be554513a4fbbcdf385fba89b78cfc977575228423f2c62fce112e27a904";
        isLibrary = true;
        isExecutable = true;
        libraryHaskellDepends = [
@@ -32052,7 +32149,7 @@ self: {
      mkDerivation {
        pname = "chatty";
        version = "0.6.4.1";
-       sha256 = "02garbdwhg32f089xd18w1i5hr9cbmvzk6cjdsl48w976liwqglz";
+       sha256 = "9f3ecc2335277144a86e9299f9775d2c655862e028b49e1070623cc8dbcaea09";
        libraryHaskellDepends = [
          ansi-terminal base chatty-utils directory mtl process random setenv
          template-haskell text time transformers unix
@@ -32068,7 +32165,7 @@ self: {
      mkDerivation {
        pname = "chatty-text";
        version = "0.6.2.0";
-       sha256 = "0gfgzqpdjja3ddz3hkynm31p9ma3g16qxavqcwybmp3v6h1pa2l3";
+       sha256 = "830a7503347bdcba3c6778ab8e4d7843d574c3a8d64f387e6b4349d92efecf3d";
        libraryHaskellDepends = [ base chatty transformers ];
        homepage = "http://doomanddarkness.eu/pub/chatty";
        description = "Provides some classes and types for dealing with text, using the fundaments of Chatty";
@@ -32080,7 +32177,7 @@ self: {
      mkDerivation {
        pname = "chatty-utils";
        version = "0.7.3.2";
-       sha256 = "1d929y9zqj9mr99v691ymp0amy1x6nzkxjdaj3ylbgydjw1m3j8j";
+       sha256 = "12c9510397cdbf45fd90aac93ebf353df8aac0ad3e24b353ca3549fc934f22b5";
        libraryHaskellDepends = [ base mtl text transformers ];
        homepage = "http://doomanddarkness.eu/pub/chatty";
        description = "Some utilities every serious chatty-based application may need";
@@ -32095,7 +32192,7 @@ self: {
      mkDerivation {
        pname = "cheapskate";
        version = "0.1.0.4";
-       sha256 = "0drx1hlqvdcrij4097q6bxhbfcqm73jsqv1wwhd3hsnjdmr46ch2";
+       sha256 = "023243726dd26a381ae43c6cace5381533b7605f069f04888c99b58d290c3d37";
        isLibrary = true;
        isExecutable = true;
        libraryHaskellDepends = [
@@ -32115,7 +32212,7 @@ self: {
      mkDerivation {
        pname = "check-email";
        version = "1.0";
-       sha256 = "1drw8rspdc4a7jw2ql3fi1dcmw56ah5csf2bil6ii8ccq5vsbfyz";
+       sha256 = "dfbba577c18ca1180d8d4b38cd0a54a6f0ca5a886e502cb83c8ab07675463cb7";
        libraryHaskellDepends = [ base bytestring email-validate ];
        librarySystemDepends = [ resolv ];
        description = "Confirm whether an email is valid and probably existant";
@@ -32129,7 +32226,7 @@ self: {
      mkDerivation {
        pname = "check-pvp";
        version = "0.0.1";
-       sha256 = "18xhm11xwvy9cz149ddm3lj4gxb514jglwhdr50mkrdd4rw8w59f";
+       sha256 = "2e158e7826ade55941c90d72fa240965f547241db5b544c267c96fde43a8b0a3";
        isLibrary = false;
        isExecutable = true;
        executableHaskellDepends = [
@@ -32148,7 +32245,7 @@ self: {
      mkDerivation {
        pname = "checked";
        version = "0.1.0.1";
-       sha256 = "00l04qxdid2pi885ixnyh91bsigsmk5rxb0jw6dl6j1mlcq27smd";
+       sha256 = "adea2330a33548439be112ac9ecbacfa45bd4282def658108a57b4d83a268002";
        libraryHaskellDepends = [ base ];
        description = "Bounds-checking integer types";
        license = stdenv.lib.licenses.bsd3;
@@ -32160,7 +32257,7 @@ self: {
      mkDerivation {
        pname = "checkers";
        version = "0.4.3";
-       sha256 = "0ry5c9c1hcp9rgf2h3gy5ajjp96anhp2738hgzrvf9aj90hr6n60";
+       sha256 = "c0589321485225b7f37f108d232eb4caa42ba52afe0d28dccbe932185862c567";
        libraryHaskellDepends = [ array base QuickCheck random ];
        description = "Check properties on standard classes and data structures";
        license = stdenv.lib.licenses.bsd3;
@@ -32173,7 +32270,7 @@ self: {
      mkDerivation {
        pname = "chell";
        version = "0.4.0.1";
-       sha256 = "0lb95abzxl4a87nfqxsxpb3a39pd52cci43hcvj8615hyhqvs2jz";
+       sha256 = "5f0abd31f4b00483e4667090c89828eda6a1c6ba5d77ecec418ad0fe972a6951";
        libraryHaskellDepends = [
          ansi-terminal base bytestring options patience random
          template-haskell text transformers
@@ -32188,7 +32285,7 @@ self: {
      mkDerivation {
        pname = "chell-hunit";
        version = "0.2.1";
-       sha256 = "006l2j98gmgjrapyp00vz93hxlx9gwkdnxwh5nx293zp7vm27x00";
+       sha256 = "00f423ea3ef78f24ba2d9077db267fa9d30e47fa1b80ebafcaf2d5879214d400";
        libraryHaskellDepends = [ base chell HUnit ];
        homepage = "https://john-millikin.com/software/chell/";
        description = "HUnit support for the Chell testing library";
@@ -32200,7 +32297,7 @@ self: {
      mkDerivation {
        pname = "chell-quickcheck";
        version = "0.2.5";
-       sha256 = "02bkcnx5k6r5csdnnkvk4wfd0l36nxb87i1463ynw17n7ym9s4cs";
+       sha256 = "9a119daa3ff6046efd3024c48356b76650d01c27734f6b9b66259b59ba657309";
        libraryHaskellDepends = [ base chell QuickCheck random ];
        homepage = "https://john-millikin.com/software/chell/";
        description = "QuickCheck support for the Chell testing library";
@@ -32212,7 +32309,7 @@ self: {
      mkDerivation {
        pname = "chesshs";
        version = "0.2.1";
-       sha256 = "0dydib3rf735wljyqij2g03xi0yxfviga5ws708nhg64f4kv8cfv";
+       sha256 = "db31b42771c43c6811389a17f5e276dd83d807784246ec25e5651c97c78acd37";
        libraryHaskellDepends = [
          array attoparsec base bytestring containers
        ];
@@ -32229,7 +32326,7 @@ self: {
      mkDerivation {
        pname = "chevalier-common";
        version = "0.6.0";
-       sha256 = "0fg7cb5ds2ixk046isz6wala7azaxqlfsacb1p7l9j6din9mgzrs";
+       sha256 = "3aff57938dcdc844cf0d8b29ed28eeeaaba3a8e2e6eb6808983d0addca62e739";
        libraryHaskellDepends = [
          base bifunctors bytestring cereal locators mtl network network-uri
          protobuf text unordered-containers vaultaire-common zeromq4-haskell
@@ -32247,7 +32344,7 @@ self: {
      mkDerivation {
        pname = "chp";
        version = "2.2.0.1";
-       sha256 = "18z0836hxs4ix7mdjxvpb40i4s71dc1j3vpxfh0vj8mf5drpc942";
+       sha256 = "822476732bae22b90174fdee21036be1681201597777d9eae991e80ecd40e0a3";
        libraryHaskellDepends = [
          base containers deepseq extensible-exceptions pretty stm
        ];
@@ -32262,7 +32359,7 @@ self: {
      mkDerivation {
        pname = "chp-mtl";
        version = "1.0.0";
-       sha256 = "1x14xl9hm9n3zczj6xhffvpac09q5a13i94fhkq2kzj2s3rk1b4z";
+       sha256 = "9fac30f3d042fe29f0848ea438822a3801a6ee760e76233ffbc3a60a13ed24f4";
        libraryHaskellDepends = [ base chp chp-plus mtl ];
        jailbreak = true;
        homepage = "http://www.cs.kent.ac.uk/projects/ofa/chp/";
@@ -32278,7 +32375,7 @@ self: {
      mkDerivation {
        pname = "chp-plus";
        version = "1.3.1.2";
-       sha256 = "1875fqf24jwl5vf2cys7yc70k0c53pg74i041y1xbrczincaww0z";
+       sha256 = "1f70ae988d9fe5d5830f044472de1d8581090ef3477b26dc2e944b221c76e5a0";
        libraryHaskellDepends = [
          base chp containers deepseq extensible-exceptions HUnit pretty
          QuickCheck stm
@@ -32296,7 +32393,7 @@ self: {
      mkDerivation {
        pname = "chp-spec";
        version = "1.0.0";
-       sha256 = "0jil6p0cw8bbpzb0kf9lxljdnbbp0xyq7c6x7bfc7291kqkafgdi";
+       sha256 = "b13da7269e2189c3dc3addb0837d07772ddb24ed34b909d6bf6b21cec035344a";
        libraryHaskellDepends = [
          base containers deepseq mtl pretty TypeCompose
        ];
@@ -32312,7 +32409,7 @@ self: {
      mkDerivation {
        pname = "chp-transformers";
        version = "1.0.0";
-       sha256 = "0d4hcqpjxmns1fhq918s6z9f4bxlbjlkxzq5xkpqwjxpzy83wq23";
+       sha256 = "43603e90ffb74b8eefec05ff3ea95cb42fe2d2371a8584a10bdad62e2f669034";
        libraryHaskellDepends = [ base chp chp-plus transformers ];
        jailbreak = true;
        homepage = "http://www.cs.kent.ac.uk/projects/ofa/chp/";
@@ -32326,7 +32423,7 @@ self: {
      mkDerivation {
        pname = "chronograph";
        version = "0.2.0.1";
-       sha256 = "0qy2ahnp324jh0ybqwsa4nc3r2x1hkbrg6sl6f8dg1xnr0gpaag2";
+       sha256 = "e229751fc8b687d79033549b97d784a18b3c98254a73bc3c809288712d54c263";
        libraryHaskellDepends = [
          base deepseq ghc-prim thyme vector-space
        ];
@@ -32343,7 +32440,7 @@ self: {
      mkDerivation {
        pname = "chu2";
        version = "2012.11.20";
-       sha256 = "01q34kzhisb8ani3k5dfjaixa7j1vqg0nh8mbmnya52hr7p4sdiz";
+       sha256 = "3f364deec95014e56d5d15410b1ede411ed5a392ae9539a25568e908ff240307";
        libraryHaskellDepends = [
          base bytestring data-default hack2 hack2-handler-snap-server
          utf8-string
@@ -32360,7 +32457,7 @@ self: {
      mkDerivation {
        pname = "chuchu";
        version = "0.4.5";
-       sha256 = "04xyylp5gliwpps753xqn8r72708ygxcp08j0fypc64ykhv5pnqc";
+       sha256 = "0cdb5b369c9e1876bd031281cbfaf3081c7132b2b88f72f4bd3cd2572ef5be13";
        libraryHaskellDepends = [
          abacate ansi-wl-pprint base cmdargs lifted-base monad-control
          parsec text transformers
@@ -32380,7 +32477,7 @@ self: {
      mkDerivation {
        pname = "chunked-data";
        version = "0.2.0";
-       sha256 = "0wmjpb0vq0nqvy317gmzxqh8yqq1bx0h2r90vqfpq3cv3z4g784s";
+       sha256 = "9aa0f3c81f9b0d7c1dde206501415f01638f20eebfbe1386dfd802bcc1bab272";
        libraryHaskellDepends = [
          base blaze-builder bytestring containers mono-traversable
          semigroups text transformers vector
@@ -32395,7 +32492,7 @@ self: {
      mkDerivation {
        pname = "chunks";
        version = "2007.4.18";
-       sha256 = "0qdwilzhbnx5zgga65lcwd6kzwvsbvi8ybfw9i4d8ziz89190fkz";
+       sha256 = "7f3a9042423f7ed4484cdc2d8fe25e7af33f4de38c16a3defba5db053f8dbc61";
        libraryHaskellDepends = [ base haskell98 parsec template-haskell ];
        homepage = "http://www.wellquite.org/chunks/";
        description = "Simple template library with static safety";
@@ -32408,7 +32505,7 @@ self: {
      mkDerivation {
        pname = "chunky";
        version = "0.1.0.0";
-       sha256 = "12g5hvb5qpbmfn1389wj7sfkc4qp19vg24gpn6j225yfyk8ccik7";
+       sha256 = "6746c6d0f4ce1721a4b1f711f1760a1713369d3e9227348275755d5cd686e589";
        isLibrary = true;
        isExecutable = true;
        libraryHaskellDepends = [ base binary bytestring text ];
@@ -32424,7 +32521,7 @@ self: {
      mkDerivation {
        pname = "church-list";
        version = "0.0.2";
-       sha256 = "0xidwcn79acpg691n0xqk3q7xlprp9gibqkafn262zq24sks31xw";
+       sha256 = "bc87a1a726027f6184756ae2155fbaf9d27ef098b8031b927997a9742ce32d76";
        libraryHaskellDepends = [ base ];
        description = "Removed; please see fmlist";
        license = stdenv.lib.licenses.mit;
@@ -32436,7 +32533,7 @@ self: {
      mkDerivation {
        pname = "cil";
        version = "0.1.1";
-       sha256 = "0farjdyq6w33jm0qqdkfd6l7b8rr6k55dqfha643mj6nh1y904az";
+       sha256 = "5f11907c80d6c83a8851d0e156ca3439a375a8696e368c41956370837d935939";
        libraryHaskellDepends = [ base bytestring language-c ];
        jailbreak = true;
        homepage = "http://tomahawkins.org";
@@ -32450,7 +32547,7 @@ self: {
      mkDerivation {
        pname = "cinvoke";
        version = "0.1";
-       sha256 = "0niz7banhrkcwdfp6w5gwy1brz1c26mylnlavi5zxgawfq4d3sl2";
+       sha256 = "82ead108765cbdfe4bdc8a5aeaab112cfcbc82e7af70735de36c6668d53a3f5a";
        libraryHaskellDepends = [ base bytestring ];
        librarySystemDepends = [ cinvoke ];
        homepage = "http://haskell.org/haskellwiki/Library/cinvoke";
@@ -32464,7 +32561,7 @@ self: {
      mkDerivation {
        pname = "cio";
        version = "0.1.0";
-       sha256 = "0518cbfyjh13ghihvnxvbhlw4060cqw5047bdrflphmigwbvpplb";
+       sha256 = "8bdebb177fb1c24b5d6eeb10503866c000c2295cbbdb0d237c2340e9dd622814";
        libraryHaskellDepends = [ base monad-stm mtl parallel-io stm ];
        homepage = "https://github.com/nikita-volkov/cio";
        description = "A monad for concurrent IO on a thread pool";
@@ -32480,7 +32577,7 @@ self: {
      mkDerivation {
        pname = "cipher-aes";
        version = "0.2.11";
-       sha256 = "05ahz6kjq0fl1w66gpiqy0vndli5yx1pbsbw9ni3viwqas4p3cfk";
+       sha256 = "d3b171895698c73da24d7ce97543f725d26637f038de670c0fd4012ca7f95015";
        libraryHaskellDepends = [
          base byteable bytestring crypto-cipher-types securemem
        ];
@@ -32498,7 +32595,7 @@ self: {
      mkDerivation {
        pname = "cipher-aes128";
        version = "0.7.0.1";
-       sha256 = "0qknpgg7dimx2nm4bzig7vvzcq3kvbxjv5rb0s4f2ina4vwczbhq";
+       sha256 = "18aecff826ca46e188062b972dfbda7360f6f73e2ffe45aa15bdc676debb7662";
        isLibrary = true;
        isExecutable = true;
        libraryHaskellDepends = [
@@ -32517,7 +32614,7 @@ self: {
      mkDerivation {
        pname = "cipher-blowfish";
        version = "0.0.3";
-       sha256 = "0hb67gmiyqrknynz5am8nada1b1v47rqla87dw5nvfhxhl51fhcg";
+       sha256 = "8f41170a851dba6d0b6f07298af3213baca09ab2a8aaf2adb733631feb3b6641";
        libraryHaskellDepends = [
          base byteable bytestring crypto-cipher-types securemem vector
        ];
@@ -32538,7 +32635,7 @@ self: {
      mkDerivation {
        pname = "cipher-camellia";
        version = "0.0.2";
-       sha256 = "19z2mi1rvp8fsqjdbmrm1hdlxmx61yr55fyknmmn945qrlvx234d";
+       sha256 = "8d0cd137cdb890646bb5d3bb52b20fa6d74e1b0c35d7d524d60edd9d43ace2a7";
        libraryHaskellDepends = [
          base byteable bytestring crypto-cipher-types securemem vector
        ];
@@ -32559,7 +32656,7 @@ self: {
      mkDerivation {
        pname = "cipher-des";
        version = "0.0.6";
-       sha256 = "1isazxa2nr1y13y0danfk7wghy34rfpn3f43rw714nk2xk6vrwc5";
+       sha256 = "85f1bccdec625a120ecf83b861afcb6478f8f899ceaa06fc083e642b54ff4ac7";
        libraryHaskellDepends = [
          base byteable bytestring crypto-cipher-types securemem
        ];
@@ -32580,7 +32677,7 @@ self: {
      mkDerivation {
        pname = "cipher-rc4";
        version = "0.1.4";
-       sha256 = "0k9qf0cn5yxc4qlqikcm5yyrnkkvr6g3v7306cp8iwz7r4dp6zn6";
+       sha256 = "c67e731bc9e7f3882e33609c3d9ec97b4e9bbd2f95cd882926acfb621970384d";
        libraryHaskellDepends = [
          base byteable bytestring crypto-cipher-types
        ];
@@ -32598,7 +32695,7 @@ self: {
      mkDerivation {
        pname = "cipher-rc5";
        version = "0.1.0.1";
-       sha256 = "1ld4kdn0bd7ka448bl6df30iw3kd3mw7117qlwxyfzwbisdcsrif";
+       sha256 = "2e66cd9a8e8b7fe73ba7f88470781d6d0e1ec170cdd0850851f3b4056c9ba4d1";
        libraryHaskellDepends = [ base split ];
        jailbreak = true;
        homepage = "http://github.com/fegu/cipher-rc5";
@@ -32611,7 +32708,7 @@ self: {
      mkDerivation {
        pname = "circ";
        version = "0.0.4";
-       sha256 = "0n3m7kjyqic10dl06zic5qjb1yb1ff8jn9d1wchrarkprcw25knc";
+       sha256 = "ccce2238cb77669521e3a1252b917361f9b0242e2c7e0368038145ece53c7558";
        libraryHaskellDepends = [ base directory mtl ];
        description = "A Compiler IR Compiler";
        license = stdenv.lib.licenses.bsd3;
@@ -32622,7 +32719,7 @@ self: {
      mkDerivation {
        pname = "circle-packing";
        version = "0.1.0.4";
-       sha256 = "1sysyzhkjb7z4mn9hgxqiq0nd7ap3rs7w22swjrpnf8l1sv09xgv";
+       sha256 = "fbf504b60e14397bb3e45a087e741e579d66018eb83f986c25ff2c39e1f7daeb";
        libraryHaskellDepends = [ base ];
        description = "Simple heuristic for packing discs of varying radii in a circle";
        license = stdenv.lib.licenses.bsd3;
@@ -32633,7 +32730,7 @@ self: {
      mkDerivation {
        pname = "cirru-parser";
        version = "0.0.2";
-       sha256 = "11qnc8rbw9zxrsaa49x5wmkrnr0vi6pgb1j18nrn40sbbww95xrz";
+       sha256 = "3ff792385f4b0362b3454186f5ae891b649b67e5a527a294cefd27be32621687";
        libraryHaskellDepends = [ aeson base text vector ];
        homepage = "https://github.com/Cirru/parser.hs";
        description = "Cirru Parser in Haskell";
@@ -32649,7 +32746,7 @@ self: {
      mkDerivation {
        pname = "citation-resolve";
        version = "0.4.3";
-       sha256 = "1x561l7shkz1nh43xh2nj83pb183rah1swi0ql9n0wr9ykq1mh1l";
+       sha256 = "34c01af0f429736013c520721da0ca038575079256c03e08b4e14fa80f0da6f4";
        libraryHaskellDepends = [
          aeson base bytestring citeproc-hs containers curl data-default
          directory download-curl either lens mtl process safe text
@@ -32672,7 +32769,7 @@ self: {
      mkDerivation {
        pname = "citeproc-hs";
        version = "0.3.10";
-       sha256 = "1fb51v8hv8ik3a8grba2br6cfbj1b3y72lgjh4i75xh09i7xna0r";
+       sha256 = "1928db4f4c00f6722281f25171fc58412ec74c5e42adfc901a33a20dd10e65b9";
        libraryHaskellDepends = [
          base bytestring containers directory filepath hexpat hs-bibutils
          HTTP json mtl network network-uri old-locale pandoc-types parsec
@@ -32692,7 +32789,7 @@ self: {
      mkDerivation {
        pname = "citeproc-hs-pandoc-filter";
        version = "0.1";
-       sha256 = "1kwsmwm0yxvqdxxr7x13hmq4nm8a9plmsfkwbvfp13bbd4mwcxnj";
+       sha256 = "d276c62b696b8d70dd5e7c3a5de94d0a554b708523f4937b6f78770f2aaf9acf";
        isLibrary = false;
        isExecutable = true;
        executableHaskellDepends = [
@@ -32712,7 +32809,7 @@ self: {
      mkDerivation {
        pname = "cityhash";
        version = "0.3.0.1";
-       sha256 = "1nr0sqrvnsjkgyhlw55mnr69s5ddxk9f0bbpwkigqc7m457vkxi6";
+       sha256 = "26f6b94f21f530fce2e4772de0d2ecad159d4cb6b5144ea17f536abb33d620db";
        libraryHaskellDepends = [ base bytestring largeword ];
        testHaskellDepends = [
          base bytestring largeword QuickCheck test-framework
@@ -32730,7 +32827,7 @@ self: {
      mkDerivation {
        pname = "cjk";
        version = "0.1.0.1";
-       sha256 = "1r0rw33vqkhck0mfqz19plw9a71f56gdcjldrxl23178fps349vl";
+       sha256 = "742732f475e8842168cf8d4ad69e292e1c9538bd297cec2a980c4ebcc7e019e4";
        libraryHaskellDepends = [
          attoparsec base bytestring containers text text-icu
        ];
@@ -32748,7 +32845,7 @@ self: {
      mkDerivation {
        pname = "clac";
        version = "0.5.0";
-       sha256 = "1ajah3ma4ms2y2kg4wkasjycsqz728n6chx1lm1r3xaiv17akya8";
+       sha256 = "48f9a94ed851f59143a5a143662c12e763cdbcd46a72f2a6f04257a2ea804aaa";
        isLibrary = false;
        isExecutable = true;
        executableHaskellDepends = [
@@ -32772,7 +32869,7 @@ self: {
      mkDerivation {
        pname = "clafer";
        version = "0.4.0";
-       sha256 = "1xnjvqwdp7679hr6jkl6xnsrdidw494p1xr8mlng6gybflm8v9gn";
+       sha256 = "f6a58d2a75cb3ff32cad28f7704922bcc596b5ed864e69324cc79cdb38ded2f6";
        isLibrary = true;
        isExecutable = true;
        libraryHaskellDepends = [
@@ -32803,7 +32900,7 @@ self: {
      mkDerivation {
        pname = "claferIG";
        version = "0.4.0";
-       sha256 = "01ilmmhz1wd142qpclk1b5nksm6cacr07pdj5cl5prfv7y04k9nw";
+       sha256 = "dca649803fdbe55b282bb2dd033253cc543d6d59615276b120a1f1f061ad3406";
        isLibrary = true;
        isExecutable = true;
        libraryHaskellDepends = [
@@ -32833,7 +32930,7 @@ self: {
      mkDerivation {
        pname = "claferwiki";
        version = "0.4.0";
-       sha256 = "1in0lzph5h7v9z9b974ibzh0rq7j343q474i9zfkylmdd1aivdyh";
+       sha256 = "d0b71d5568ad523fdd4f911c820719f2e00ce05f919cb4d24ffbc002efa7c0c6";
        libraryHaskellDepends = [
          base clafer containers directory gitit MissingH mtl network
          network-uri process SHA split time transformers utf8-string
@@ -32849,7 +32946,7 @@ self: {
      mkDerivation {
        pname = "clanki";
        version = "1.2.5";
-       sha256 = "0s94zxgcxq230y80kfqgim9yci3wqbq85byyvp0f0kqadsn4wmv1";
+       sha256 = "61574eac6e0a4fe0c0dddeaf82f0c27c44e6538d0fbb09900743e0ce5eff2469";
        isLibrary = false;
        isExecutable = true;
        executableHaskellDepends = [
@@ -32869,7 +32966,7 @@ self: {
      mkDerivation {
        pname = "clash";
        version = "0.1.3.11";
-       sha256 = "047dhg6y7yvp5vdarylry0q4l29a4x2dkjilk6j624lxcc17gyhx";
+       sha256 = "1dfa7702639d1261a49934cad944272a094a30f099faacda2e77fbe3cd83ed10";
        libraryHaskellDepends = [
          base containers data-accessor data-accessor-template directory
          filepath ghc haskell98 pretty prettyclass template-haskell tfp
@@ -32892,7 +32989,7 @@ self: {
      mkDerivation {
        pname = "clash-ghc";
        version = "0.5.11";
-       sha256 = "1lwc47b2iw2l7djga11gp4xdikb8gycqv4fxz1cxrf23xzkg5ggg";
+       sha256 = "efbdf2e6ef43b8dc59f8dd918d997f68cdd83ab92f04f5643b54f028d6218cd3";
        isLibrary = false;
        isExecutable = true;
        executableHaskellDepends = [
@@ -32918,7 +33015,7 @@ self: {
      mkDerivation {
        pname = "clash-lib";
        version = "0.5.10";
-       sha256 = "039j561r7kgrd5b7z55axgjniwm5yi5y1y0azps4ipmvjsvalbdl";
+       sha256 = "b42daab696bbde48f4fd0af8e04bf4a5f268e5ebaa947f5669f9cd938329320d";
        libraryHaskellDepends = [
          aeson attoparsec base bytestring clash-prelude concurrent-supply
          containers deepseq directory errors fgl filepath hashable lens mtl
@@ -32938,7 +33035,7 @@ self: {
      mkDerivation {
        pname = "clash-prelude";
        version = "0.9.2";
-       sha256 = "1gl75mbqpv5g5dwg2c2vvqn36ydwhkcv7g6i8gjm41500dsrky0i";
+       sha256 = "11f8997503a00452e543d1bcb3d984bc79332cde5b30f1782bafec8b572d87be";
        libraryHaskellDepends = [
          array base data-default ghc-prim ghc-typelits-natnormalise
          integer-gmp lens QuickCheck singletons template-haskell th-lift
@@ -32955,7 +33052,7 @@ self: {
      mkDerivation {
        pname = "clash-prelude-quickcheck";
        version = "0.1.2.1";
-       sha256 = "1fn5wlg2lmxl6rs2ygnf0m88bgcjf62jpprbp425pqbq6lvhw70w";
+       sha256 = "1c1c0e373578e15b04b92bdf2b857192bd855005ce3e2f7436b4572a1ee5c5ba";
        libraryHaskellDepends = [ base clash-prelude QuickCheck ];
        jailbreak = true;
        description = "QuickCheck instances for various types in the CλaSH Prelude";
@@ -32970,7 +33067,7 @@ self: {
      mkDerivation {
        pname = "clash-systemverilog";
        version = "0.5.7";
-       sha256 = "0s8yqs4h5abamfrawfw95q9p0h8ni98pwyqr76nkvkrybxwykam5";
+       sha256 = "a5aae9795f3ecf3dad39197b7e518a164170132e893baeb2ab6aa90289c61e69";
        libraryHaskellDepends = [
          base clash-lib clash-prelude fgl lens mtl text unordered-containers
          wl-pprint-text
@@ -32988,7 +33085,7 @@ self: {
      mkDerivation {
        pname = "clash-verilog";
        version = "0.5.7";
-       sha256 = "04wa7y108hk2bn453dwrr1x71bvxx48hivdpqxsx0gyhya14143j";
+       sha256 = "72904082f2d03fd075c7b7ed0811e97daf707ac899b751885d624204823f8a13";
        libraryHaskellDepends = [
          base clash-lib clash-prelude fgl lens mtl text unordered-containers
          wl-pprint-text
@@ -33005,7 +33102,7 @@ self: {
      mkDerivation {
        pname = "clash-vhdl";
        version = "0.5.8";
-       sha256 = "08qplvnal8jjqy8rkivgn53n8qpzk232dslqxypx6ky6fks3bc0w";
+       sha256 = "1cb035f474c64fd3afef98ea268698ff626447b16fc79991c75222aaeca61723";
        libraryHaskellDepends = [
          base clash-lib clash-prelude fgl lens mtl text unordered-containers
          wl-pprint-text
@@ -33021,7 +33118,7 @@ self: {
      mkDerivation {
        pname = "classify";
        version = "2013.11.6.1";
-       sha256 = "03d4ygqhqbg4cvfjp8c5cyy0fkgf1fpzc1li45bqc555jrxwszwr";
+       sha256 = "997fcd7b96a5148657219106f6af0bee4d07bc6785a12bdd66e42d0cf1f3a40d";
        libraryHaskellDepends = [ base containers mtl ];
        description = "Library for classification of media files";
        license = stdenv.lib.licenses.publicDomain;
@@ -33034,7 +33131,7 @@ self: {
      mkDerivation {
        pname = "classy-parallel";
        version = "0.1.0.0";
-       sha256 = "0vfik37g2fwzc4p343hag5aidvi77396vfhfdx1207gahbzqf21v";
+       sha256 = "3b0887ff82ea1d20426f0eba6dd23827ee1655790a0e322e619f3bf1ce98d16d";
        libraryHaskellDepends = [
          base lifted-base monad-control parallel resourcet transformers
        ];
@@ -33054,7 +33151,7 @@ self: {
      mkDerivation {
        pname = "classy-prelude";
        version = "0.12.1.1";
-       sha256 = "04rxmh4jzj4j5dx9i8ndh9ibn01cjdi485n1xvjngx0gs7zqa2k7";
+       sha256 = "670a85ffd10ff467e5eec1164462932c00bb6282cda2987a2b92c82f09ac3d13";
        libraryHaskellDepends = [
          base basic-prelude bifunctors bytestring chunked-data containers
          dlist enclosed-exceptions exceptions ghc-prim hashable lifted-base
@@ -33078,7 +33175,7 @@ self: {
      mkDerivation {
        pname = "classy-prelude-conduit";
        version = "0.12.0.1";
-       sha256 = "1xv20i31f1za88kkdd00vin9shn9zxhqmwd0ln62cag4xfrmh9xi";
+       sha256 = "b12758b3ebe429268ca5a0f18a61ffc9429d6cdc00b4362742ea0717460462f7";
        libraryHaskellDepends = [
          base bytestring classy-prelude conduit conduit-combinators
          monad-control resourcet transformers void
@@ -33099,7 +33196,7 @@ self: {
      mkDerivation {
        pname = "classy-prelude-yesod";
        version = "0.12.0.1";
-       sha256 = "00pzlsbsdajzdlna1flrdd1lb98g0vx2b9757m8kfa37h6l443r2";
+       sha256 = "220f42a881672837513de5a425fa060fa545436b99baa02c6d5faaa697a6ff02";
        libraryHaskellDepends = [
          aeson base classy-prelude classy-prelude-conduit data-default
          http-conduit http-types persistent yesod yesod-newsfeed
@@ -33117,7 +33214,7 @@ self: {
      mkDerivation {
        pname = "clay";
        version = "0.10.1";
-       sha256 = "0m0ajbgypn9ki741x2bmcmpmpkccazv76wh8b9gha9483cl21f1v";
+       sha256 = "3bb820281b8824055f5a087273f6578ccd5b6f6575891ec88933d9ebdf920a54";
        revision = "1";
        editedCabalFile = "8ecb3c320c9470f2bf250552d7fac738520d90d28e8e90b11922d1c4940a0263";
        libraryHaskellDepends = [ base mtl text ];
@@ -33144,7 +33241,7 @@ self: {
      mkDerivation {
        pname = "clckwrks";
        version = "0.23.8";
-       sha256 = "0inhxyjs12990mngfx2n3m107wxnamgi4gby5lnvai5nz913qgzd";
+       sha256 = "ed3f3c42fab644b52d2d7e3d125f55b6f303421d5674f76c052989a0a5efd046";
        libraryHaskellDepends = [
          acid-state aeson aeson-qq attoparsec base blaze-html bytestring
          cereal containers directory filepath happstack-authenticate
@@ -33172,7 +33269,7 @@ self: {
      mkDerivation {
        pname = "clckwrks-cli";
        version = "0.2.14";
-       sha256 = "1dwvrxz2sjk61bbima9m70qv6gf4h4jx9yysmwnwpinmmqixwdi3";
+       sha256 = "2336de23aed5c6cb2dafdafbd42581c43db3313835a91ad70a664a2d7ecf9bb7";
        isLibrary = false;
        isExecutable = true;
        executableHaskellDepends = [
@@ -33192,7 +33289,7 @@ self: {
      mkDerivation {
        pname = "clckwrks-dot-com";
        version = "0.3.11";
-       sha256 = "0f39ws919qy00090l002k3g8dkcldq7rwayf0wyxg8mfycrnb700";
+       sha256 = "009c6533f3aea2d73d07ce2b9e0f6e94cd86de9802000a1200c0e31492e66938";
        isLibrary = false;
        isExecutable = true;
        executableHaskellDepends = [
@@ -33219,7 +33316,7 @@ self: {
      mkDerivation {
        pname = "clckwrks-plugin-bugs";
        version = "0.7.5";
-       sha256 = "0la4ivk8sbh8wq1g2nhxx522ir2idffz5818bghjf8qffmqa47fv";
+       sha256 = "db1da270750e2327e15b28a0f29d6b51e42844e91d5af102e6082e8de68e4451";
        libraryHaskellDepends = [
          acid-state attoparsec base cereal clckwrks clckwrks-plugin-page
          containers directory filepath happstack-authenticate happstack-hsp
@@ -33245,7 +33342,7 @@ self: {
      mkDerivation {
        pname = "clckwrks-plugin-ircbot";
        version = "0.6.14";
-       sha256 = "1lrh2929ia6326vf9lyd5jy1a3nnavl8f27f9faw35871p1my1r2";
+       sha256 = "22075fc30d0795c1954bee0887e856d60e15bc2ccdd3e4b611c3a898441230d3";
        libraryHaskellDepends = [
          acid-state attoparsec base blaze-html bytestring clckwrks
          containers directory filepath happstack-hsp happstack-server hsp
@@ -33269,7 +33366,7 @@ self: {
      mkDerivation {
        pname = "clckwrks-plugin-media";
        version = "0.6.13";
-       sha256 = "0j6ijdq3n011h4d0gxxpjs35kwppp2kyjkg0bjcdw752ppk4y14w";
+       sha256 = "9c044fe6bda21cde985ce04de9a7b8f7f2598696b7f7071a8121003b7093d148";
        libraryHaskellDepends = [
          acid-state attoparsec base blaze-html cereal clckwrks containers
          directory filepath gd happstack-server hsp ixset magic mtl reform
@@ -33294,7 +33391,7 @@ self: {
      mkDerivation {
        pname = "clckwrks-plugin-page";
        version = "0.4.0";
-       sha256 = "0j82xzdgpy97s4xf6vx3an5ssbybcixhasmh0ca9bjmv9iqkjkws";
+       sha256 = "9a4f39714cbbca951403b06a057b64cb2fad8b55a36fe33ad127f9fbdaef0249";
        libraryHaskellDepends = [
          acid-state aeson attoparsec base clckwrks containers directory
          filepath happstack-hsp happstack-server hsp hsx2hs ixset mtl
@@ -33316,7 +33413,7 @@ self: {
      mkDerivation {
        pname = "clckwrks-theme-bootstrap";
        version = "0.4.0";
-       sha256 = "08sdklr7nikngkdcls9dwy0ij4nqrb1n6dnkm3cw73iaifsl6klz";
+       sha256 = "9f4e43b58b2a8ec3d9a8d33663c3cad8121981e72d69cada7c76467b329d4d23";
        libraryHaskellDepends = [
          base clckwrks happstack-authenticate hsp hsx-jmacro hsx2hs jmacro
          mtl text web-plugins
@@ -33335,7 +33432,7 @@ self: {
      mkDerivation {
        pname = "clckwrks-theme-clckwrks";
        version = "0.5.0";
-       sha256 = "06szqp7mcak7ra1pzxzmj8hzhm1lmdr7nwjkxk1h8bba5ipcjwhv";
+       sha256 = "1b72c96e2c6a2d04c3ec53727b72ab3454f82192f5f77f83ca672a56cfc55f1b";
        libraryHaskellDepends = [
          base clckwrks containers happstack-authenticate hsp hsx2hs mtl text
          web-plugins
@@ -33351,7 +33448,7 @@ self: {
      mkDerivation {
        pname = "clckwrks-theme-geo-bootstrap";
        version = "0.1.1";
-       sha256 = "1qxik7hdz300n5lfb5xzh2md44b4xwwlr0c92y9x2na2xz41da7k";
+       sha256 = "f3a816c8ef4259d1931789814c39ef6411d2aa80bf97e568b1008cdfe099b1e3";
        libraryHaskellDepends = [ base clckwrks hsp text ];
        jailbreak = true;
        homepage = "http://divshot.github.com/geo-bootstrap/";
@@ -33365,7 +33462,7 @@ self: {
      mkDerivation {
        pname = "cld2";
        version = "0.1.0.1";
-       sha256 = "0fsjp0y5f17gv3k43vbxgx7w6i2l4ralrc6g1wb0xi0gp1vrm3hd";
+       sha256 = "0d8e9a77b80fc40e160fcfb04c55265444c34f7f7ded41e6d8ef04573cb8523b";
        revision = "1";
        editedCabalFile = "60506ceb359329f803a733a06f9a6060a31cab7e86dd4a8e3fd843953cb4cfbd";
        libraryHaskellDepends = [ base bytestring text ];
@@ -33380,7 +33477,7 @@ self: {
      mkDerivation {
        pname = "clean-home";
        version = "0.0.4";
-       sha256 = "0s894l3vjjkz94cvl5hv3vdpm934k7ila60kmr6acl7pvhppnc22";
+       sha256 = "42307b2fdcf750a64cae131845e39964a47adb1e1b16ba19497f4ab907250969";
        isLibrary = false;
        isExecutable = true;
        executableHaskellDepends = [
@@ -33396,7 +33493,7 @@ self: {
      mkDerivation {
        pname = "clean-unions";
        version = "0.1.1";
-       sha256 = "1y4cj15s6gjcazwk0iycyc2qs7chrqcvchf4g5h4xnf2x8ld4i21";
+       sha256 = "4144d228eac2d94e6079c441b619ce901d8d05f3cc4730f9574c3ea34b908cf8";
        libraryHaskellDepends = [ base ];
        homepage = "https://github.com/fumieval/clean-unions";
        description = "Open unions without need for Typeable";
@@ -33410,7 +33507,7 @@ self: {
      mkDerivation {
        pname = "cless";
        version = "0.3.0.0";
-       sha256 = "16v2hj2qxw7ij8aqhbx11fs4ss62d4d0jwi4mk0kc76yfdwl61hg";
+       sha256 = "0f06437973de1c36c1ac2472091a69c2684db40ba12f881592f1f08e8584629b";
        isLibrary = false;
        isExecutable = true;
        executableHaskellDepends = [
@@ -33428,7 +33525,7 @@ self: {
      mkDerivation {
        pname = "clevercss";
        version = "0.2.4";
-       sha256 = "0nnczd93j160747dc11z06ds81g938bw8lnqywg7mgylsfxalznl";
+       sha256 = "d47eaabad3d4bf7a1ef7d852c4171ae905a49b013f04d60e39c0043952fbcc5a";
        isLibrary = true;
        isExecutable = true;
        libraryHaskellDepends = [ base containers mtl parsec ];
@@ -33444,7 +33541,7 @@ self: {
      mkDerivation {
        pname = "cli";
        version = "0.0.4";
-       sha256 = "0iychwxbmnlywv7b7fpxym0ybcbk0aba9p0pvg8brs6llz2qrn9x";
+       sha256 = "3dd98cc5a7d4e8bcd0db17dca4960273b1e541f5fdbab3cee69edaba3a87cc47";
        isLibrary = true;
        isExecutable = true;
        libraryHaskellDepends = [ base containers ];
@@ -33460,7 +33557,7 @@ self: {
      mkDerivation {
        pname = "click-clack";
        version = "1.0.1";
-       sha256 = "0ngvdq0i82qxwawqb5pqa3fscnyv1kxc3ifc3qijnn5v4py9ydd8";
+       sha256 = "a8359ffc25bb582b231eccc5c1fa0cdb5ba6dd50f89685b9e21d0b14016efb59";
        isLibrary = false;
        isExecutable = true;
        executableHaskellDepends = [
@@ -33481,7 +33578,7 @@ self: {
      mkDerivation {
        pname = "clientsession";
        version = "0.9.1.1";
-       sha256 = "08h0461ydhfymw2pya472n81kx5rqp7awfgxlbz2r851rl5kqmn9";
+       sha256 = "c9563c0bcda1a02cfea2fd39aecec5b9f419901587287f05afdec1e683210022";
        isLibrary = true;
        isExecutable = true;
        libraryHaskellDepends = [
@@ -33508,7 +33605,7 @@ self: {
      mkDerivation {
        pname = "clifford";
        version = "0.1.0.14";
-       sha256 = "00xxvwa60ihrd24267hzs5ssjm6nrli39qlh9gm4fkdnrzif9r4r";
+       sha256 = "99e4e4e2cfb64d47ea4b90e23422cdd654a975d11f1e23886819466014dfbd03";
        isLibrary = true;
        isExecutable = true;
        libraryHaskellDepends = [
@@ -33535,7 +33632,7 @@ self: {
      mkDerivation {
        pname = "clippard";
        version = "0.1.1";
-       sha256 = "0qhi727irlkvi4ygx5qvd6h1zzz22588lymi39s0gcjir473a538";
+       sha256 = "6814350ec951b207741ab17a8a5011e2ff1fa0691b97fe3c897bd21c8f381162";
        libraryHaskellDepends = [ base process ];
        jailbreak = true;
        homepage = "https://github.com/Raynes/clippard";
@@ -33548,7 +33645,7 @@ self: {
      mkDerivation {
        pname = "clipper";
        version = "0.0.1";
-       sha256 = "0s4n8d07190yarkxpa2kjphkm6lw2ljgwcix3x6m3lxcxrvc3nr0";
+       sha256 = "20dbc176eeacd3514d1f3d32fe24159c9a3ae19553a8db67561ea47040439668";
        libraryHaskellDepends = [ base ];
        homepage = "https://github.com/chetant/clipper";
        description = "Haskell API to clipper (2d polygon union/intersection/xor/clipping API)";
@@ -33564,7 +33661,7 @@ self: {
      mkDerivation {
        pname = "clippings";
        version = "0.1.3";
-       sha256 = "0dm0cpqcv8r66zlwq7myjv7klpp43lbcwdgxs2zkg6mbsb2f1qvr";
+       sha256 = "79e3e0c4d2ab9a37bfd0fd35ce161de45e3acf96be1ecce93726a3cdf065a036";
        isLibrary = true;
        isExecutable = true;
        libraryHaskellDepends = [
@@ -33586,7 +33683,7 @@ self: {
      mkDerivation {
        pname = "clist";
        version = "0.1.0.0";
-       sha256 = "1jvkv6dwx2gm59vczmiagpxb0614fz63jzqrqm81bdai8yb0gpzd";
+       sha256 = "eddf07964751b51550c5197f39cc772418b0fa7d2ad6cf762af589ce9bd973cb";
        libraryHaskellDepends = [ base base-unicode-symbols peano ];
        homepage = "https://github.com/strake/clist.hs";
        description = "Counted list";
@@ -33598,7 +33695,7 @@ self: {
      mkDerivation {
        pname = "clock";
        version = "0.5.1";
-       sha256 = "1ncph7vi2q6ywwc8ysxl1ibw6i5dwfvln88ssfazk8jgpj4iyykw";
+       sha256 = "7c7a1f89bc4fa2f995d31a214bb7e3ad44c3570cb46b8f18e7de6011f78197d9";
        libraryHaskellDepends = [ base ];
        testHaskellDepends = [ base tasty tasty-quickcheck ];
        homepage = "https://github.com/corsis/clock";
@@ -33613,7 +33710,7 @@ self: {
      mkDerivation {
        pname = "clocked";
        version = "0.4.1.3";
-       sha256 = "1z9n4nisa73zlwch7arixg6633w3jmcqw5w97jf4p5559q874wi8";
+       sha256 = "287272104ea5944b9c3c89178e5995838f61cceb31ab0319a77f1ca5a32536fd";
        libraryHaskellDepends = [
          base clock containers MonadCatchIO-transformers transformers
        ];
@@ -33631,7 +33728,7 @@ self: {
      mkDerivation {
        pname = "clogparse";
        version = "0.2";
-       sha256 = "17n5rwi64wjyv2xcxm86bawgmnpfrg7fjzwr9l3bj5jg0ggbyrbx";
+       sha256 = "7d65bfde034f16b9064d997fe9cecbeedafab85a06d5cebad85e726222cfc59e";
        libraryHaskellDepends = [
          attoparsec base bytestring filepath text time timezone-olson
          timezone-series
@@ -33649,7 +33746,7 @@ self: {
      mkDerivation {
        pname = "clone-all";
        version = "0.1.0.0";
-       sha256 = "1mif1cqwpgp1wis7lplqrvv5aikdl0iv5ddazwgm6zgrxz645p09";
+       sha256 = "09dc42cceff97d531fffaab5b223a06d4655f6ce985e7a74e4e1becb310b2ed6";
        isLibrary = false;
        isExecutable = true;
        executableHaskellDepends = [
@@ -33668,7 +33765,7 @@ self: {
      mkDerivation {
        pname = "closure";
        version = "0.1.0.0";
-       sha256 = "1z9clkwjpj01g258h8bldlc759vwsgdlyppn29sr11kyani1zjwf";
+       sha256 = "8ecb1fa2557e86907512f65e4fdbd37ca772186d7421888a7801c82bf9a42cfd";
        libraryHaskellDepends = [ base hashable unordered-containers ];
        jailbreak = true;
        homepage = "http://github.com/tel/closure";
@@ -33686,7 +33783,7 @@ self: {
      mkDerivation {
        pname = "cloud-haskell";
        version = "0.2.0.0";
-       sha256 = "11i2r7zf3vvywsfnlcsgvnh2qf92wgc81sfmhkhfpdrpcd2zx606";
+       sha256 = "0698fe456337b7ebe084d5e980d8e322392ca0dd4f336a9de67eefe1fec92286";
        libraryHaskellDepends = [
          distributed-process distributed-process-async
          distributed-process-client-server distributed-process-execution
@@ -33708,7 +33805,7 @@ self: {
      mkDerivation {
        pname = "cloudfront-signer";
        version = "0.0.0.1";
-       sha256 = "1ikjrlb421rxsj4c7dl4dw8a3kls43gzn4mapg1y9b2bkd7q6ywz";
+       sha256 = "9f7b834f9b4bace4c3bbaa12fbdf209acea1106f84b6c388d43d074116cd72c6";
        libraryHaskellDepends = [
          asn1-encoding asn1-types base base64-bytestring bytestring
          crypto-pubkey-types old-locale RSA time
@@ -33727,7 +33824,7 @@ self: {
      mkDerivation {
        pname = "cloudyfs";
        version = "0.0.2";
-       sha256 = "0jfv3830kg3yp1vqqs75bmiwflv4y8ya86q575bsw1l695dc5lwg";
+       sha256 = "8fd3c25a498606ae5739051ba43cf26453c7635de5688c77b87ebc09061adb49";
        isLibrary = false;
        isExecutable = true;
        executableHaskellDepends = [
@@ -33745,7 +33842,7 @@ self: {
      mkDerivation {
        pname = "cltw";
        version = "1.1.4";
-       sha256 = "08nishc8ngmvx0pdksn4z8a6l8vdgm3jiyz3w6d302pwp566z4q9";
+       sha256 = "09936f4cb9fc0a309ae1e3fb28477d6d236a14fac4ead92ee8bb3e8b18d4d122";
        isLibrary = false;
        isExecutable = true;
        executableHaskellDepends = [ base curl mtl random tagsoup ];
@@ -33761,7 +33858,7 @@ self: {
      mkDerivation {
        pname = "clua";
        version = "0.3";
-       sha256 = "0xzhpjsb9nf8xw7fa111n5gki46gz67aiyd2wr1k50pzyjrvl3vv";
+       sha256 = "7b0fbab3f4ff823243e6a2f9a88ef9cf90385fb12104e50eefc8d9b4b4bcf077";
        isLibrary = false;
        isExecutable = true;
        executableHaskellDepends = [
@@ -33778,7 +33875,7 @@ self: {
      mkDerivation {
        pname = "cluss";
        version = "0.3";
-       sha256 = "1q5km2f8zwnzcwnzj0khnszsgrb1x53zp0ryjwz2nfx9ajvh7zgg";
+       sha256 = "effd03b754a93b2b3e973e83fb47e961e5a7bfb67002f92d67dff28f9ca8b3e0";
        libraryHaskellDepends = [ base template-haskell ];
        homepage = "https://github.com/Kinokkory/cluss";
        description = "simple alternative to type classes";
@@ -33794,7 +33891,7 @@ self: {
      mkDerivation {
        pname = "clustering";
        version = "0.2.1";
-       sha256 = "1jxrgb13zm8bqcsx39fp31lrpna3y0pn7ckcf9q6gljz327c4y2h";
+       sha256 = "5078c28e185fd26770726cb2632ff043d99b6918d7a5d135c30bd53fc27ab9cb";
        libraryHaskellDepends = [
          base binary containers matrices mwc-random parallel primitive
          vector
@@ -33815,7 +33912,7 @@ self: {
      mkDerivation {
        pname = "clustertools";
        version = "0.1.5";
-       sha256 = "0in6fqzr1aki2dhbkv3vlmw17vla5m39g6msaplk4vix5yjw7vkq";
+       sha256 = "78eec3a52f3d6e32e955ba9a97462d8aee1378a57becb9601371aa903f76c646";
        isLibrary = false;
        isExecutable = true;
        executableHaskellDepends = [
@@ -33834,7 +33931,7 @@ self: {
      mkDerivation {
        pname = "clutterhs";
        version = "0.1";
-       sha256 = "0mcl6pc0qjyijyqqlf1wh3548gn71kv6xy0jaqgrjddf20qlc8xl";
+       sha256 = "b423463110ae35991f5612f86ef60cc73e44ca803c388ab197d14b0cd8359455";
        libraryHaskellDepends = [
          array base cairo glib gtk haskell98 mtl X11
        ];
@@ -33852,7 +33949,7 @@ self: {
      mkDerivation {
        pname = "cmaes";
        version = "0.2.2";
-       sha256 = "060bmnkhbwrxhalfy5zxwjzbb6mp5ffj4r0qgkv6wp7bac2nnrp8";
+       sha256 = "e8666b0553eb5c6ef67c1864229d2bb79ab5bee4fd17efa8823df305a7ad0b18";
        libraryHaskellDepends = [ base mtl process safe strict syb ];
        testHaskellDepends = [
          base doctest doctest-prop mtl process random syb vector
@@ -33867,7 +33964,7 @@ self: {
      mkDerivation {
        pname = "cmark";
        version = "0.4.0.1";
-       sha256 = "1kimba33r0f2ify0sxy7x9npqarb9xaw8hih1z6vvf1bkjsji0v3";
+       sha256 = "638328b59c2bb8bdcd0f3042c4554f2b2b7c6deac7770dbc8bc2813c865a35ce";
        libraryHaskellDepends = [ base bytestring text ];
        testHaskellDepends = [ base HUnit text ];
        homepage = "https://github.com/jgm/commonmark-hs";
@@ -33880,7 +33977,7 @@ self: {
      mkDerivation {
        pname = "cmath";
        version = "0.3";
-       sha256 = "1hb92cgblmwp49lv0x0ib8g557mhjk6db7ihnim75ldii2f93dnm";
+       sha256 = "d5b6919c88b1d1726ab4309ed5cc94b09e521e5a1174b069229757ba1e1369c1";
        libraryHaskellDepends = [ base ];
        homepage = "http://code.haskell.org/~dons/code/cmath";
        description = "A binding to the standard C math library";
@@ -33895,7 +33992,7 @@ self: {
      mkDerivation {
        pname = "cmathml3";
        version = "0.1";
-       sha256 = "0mh6qzdlbfc1lfx7353p2qfa2j77xjlnnnnw3csmv125zha4y96d";
+       sha256 = "cd244f14fc45845d351bdc5a6ba9ece748a11c16779471baa381b945dbc70656";
        isLibrary = true;
        isExecutable = true;
        libraryHaskellDepends = [
@@ -33915,7 +34012,7 @@ self: {
      mkDerivation {
        pname = "cmd-item";
        version = "0.0.1.0";
-       sha256 = "1lawn0v32dn38xf3jaz70gks99llbq453zlf876pylinh5id7q62";
+       sha256 = "c2e0d3628136527fcd418efe51085e94a6a4e703e72b395c47c3363136b05cd1";
        libraryHaskellDepends = [ base containers templater text ];
        testHaskellDepends = [
          base hspec hspec-laws HUnit QuickCheck quickcheck-instances text
@@ -33932,7 +34029,7 @@ self: {
      mkDerivation {
        pname = "cmdargs";
        version = "0.10.13";
-       sha256 = "0vmz7f0ssrqlp6wzmc0mjqj4qczfgk58g0lr0yz7jamamlgpq4b6";
+       sha256 = "66117c1fadaa2a79be07998287ca7cee334c249615b0fab9b91467ad813bbf6e";
        isLibrary = true;
        isExecutable = true;
        libraryHaskellDepends = [
@@ -33950,7 +34047,7 @@ self: {
      mkDerivation {
        pname = "cmdargs-browser";
        version = "0.1.3";
-       sha256 = "1k0g2vh7sqkblzjsfvyhfiy1fcwkw0i10kgl4n2r68w7v52mmzd0";
+       sha256 = "a0fd5a45d98723938525f44d1022e09333177c74d06fa7e5a76b627de0160fcc";
        isLibrary = false;
        isExecutable = true;
        executableHaskellDepends = [
@@ -33969,7 +34066,7 @@ self: {
      mkDerivation {
        pname = "cmdlib";
        version = "0.3.6";
-       sha256 = "0mxk7yy3sglxc97my5lnphisg6fawifrbdbpz31h7ybiqccx4hsn";
+       sha256 = "5643d219c371f903c3f877b5955de4ca99a723bc96165f4f629d3e3dbc3fb357";
        isLibrary = true;
        isExecutable = true;
        libraryHaskellDepends = [ base mtl split syb transformers ];
@@ -33985,7 +34082,7 @@ self: {
      mkDerivation {
        pname = "cmdtheline";
        version = "0.2.3";
-       sha256 = "1jwbr34xgccjbz6nm58bdsg1vqyv87rh45yia5j36vlfbaclyb04";
+       sha256 = "042c4f995a8e6e336451d11702f341dbe31d9e6e0b956acd5f92b1d7c9c88bcb";
        libraryHaskellDepends = [
          base containers directory filepath parsec pretty process
          transformers
@@ -34006,7 +34103,7 @@ self: {
      mkDerivation {
        pname = "cml";
        version = "0.1.3";
-       sha256 = "1hym074a8akzg3c96b1yczmdw5pgn4g0ahqxsxhg8d0kf8lzi5ph";
+       sha256 = "f096f829721334f460d71d43051eb1ef16deea673e2c93d8787f2aa4c801d5c3";
        libraryHaskellDepends = [ base ];
        homepage = "http://code.haskell.org/cml/";
        description = "Events and Channels as in Concurrent ML";
@@ -34018,7 +34115,7 @@ self: {
      mkDerivation {
        pname = "cmonad";
        version = "0.1.1.1";
-       sha256 = "07adwhpsmg3q4nhifjpdjv2dy1m08n0qkvlssmbl3b6gklvb82sk";
+       sha256 = "530bb4369dcfac4157d59aee898145a006dfc496ed4a17a12578bcaa2fe44d1d";
        libraryHaskellDepends = [ array base ];
        description = "A library for C-like programming";
        license = stdenv.lib.licenses.bsd3;
@@ -34030,7 +34127,7 @@ self: {
      mkDerivation {
        pname = "cmu";
        version = "1.10";
-       sha256 = "0zlc6spb51s2k455s9mspqjjk8xm90wwjlj2nm7949ihkim4j5gy";
+       sha256 = "fe15496a9c3026924eb54252c93948b5a32925beba265d0a994287b2ae368c7e";
        isLibrary = true;
        isExecutable = true;
        libraryHaskellDepends = [ array base containers ];
@@ -34047,7 +34144,7 @@ self: {
      mkDerivation {
        pname = "cnc-spec-compiler";
        version = "0.2.0.1";
-       sha256 = "0nfqglz6szbi3s8xf5i87rnac7hc8cqfyrx2rs5ydb5i439s22b0";
+       sha256 = "6009a1d320b1ace68bcea267ef30430c1ea66c3e2816d7911e717d6d3e7dd859";
        isLibrary = false;
        isExecutable = true;
        executableHaskellDepends = [
@@ -34068,7 +34165,7 @@ self: {
      mkDerivation {
        pname = "cndict";
        version = "0.6.1";
-       sha256 = "0pi0n1chwv6y3ch7dw2smrllwsdiy6r295lmmsnfnbprc8w6gksq";
+       sha256 = "58cf673862f92eebacae959624b2f1b1694e69ae5af076201bde6c0e59b0205e";
        revision = "1";
        editedCabalFile = "6371863e768d5b9d01f80b10783bb7ab4530e8e168d0c0bcc0fcee2a4f1aa468";
        libraryHaskellDepends = [
@@ -34086,7 +34183,7 @@ self: {
      mkDerivation {
        pname = "code-builder";
        version = "0.1.3";
-       sha256 = "1ax4c19xkszahcxvwc1wa1hrgk6ajck5sbprbplsi1gc9jj4g7jm";
+       sha256 = "559e47a44cec85a8e95df92e5d2693cacc9761503c30be3b83eaebd95360a4ab";
        libraryHaskellDepends = [ base containers ];
        description = "Simple system for generating code";
        license = stdenv.lib.licenses.bsd3;
@@ -34100,7 +34197,7 @@ self: {
      mkDerivation {
        pname = "codec";
        version = "0.1.1";
-       sha256 = "0fkcbdas270gad7d3k40q96w68iwfb8jgi866x3dp4mf8wvsll9k";
+       sha256 = "3351aa3747ae92db463706c527d1723c22c34dc280ccd14e530f1ca1555b6c3a";
        libraryHaskellDepends = [
          aeson base binary binary-bits bytestring data-default-class mtl
          template-haskell text transformers unordered-containers
@@ -34121,7 +34218,7 @@ self: {
      mkDerivation {
        pname = "codec-libevent";
        version = "0.1.2";
-       sha256 = "17v7adxs65jq74ngid0iywg3p5pq5j2p9mznqwj7i53238l3p60l";
+       sha256 = "14983b281a62947824c7f6d774852cf8963b1ef711b4f82c395816a37b53679f";
        isLibrary = true;
        isExecutable = true;
        libraryHaskellDepends = [
@@ -34142,7 +34239,7 @@ self: {
      mkDerivation {
        pname = "codec-mbox";
        version = "0.2.0.0";
-       sha256 = "0kbn76g6ly1pjd9higi0k0f26hplm0jhz85b23inn0bjli14n2cl";
+       sha256 = "94094b42a472016be310aba00f25a8f442231c9820be08539337786a9e39764d";
        libraryHaskellDepends = [ base bytestring ];
        description = "A library to read and write mailboxes in mbox format";
        license = stdenv.lib.licenses.bsd3;
@@ -34155,7 +34252,7 @@ self: {
      mkDerivation {
        pname = "codecov-haskell";
        version = "0.4.0.2";
-       sha256 = "0y1vv9iayjvikjfp4y41m4gypybxd1lq3pv4154nvbjpfapmndsw";
+       sha256 = "5c375baf7257ae6d490964df8169687df9eb1fa98178729d9c714baf62da3b78";
        isLibrary = true;
        isExecutable = true;
        libraryHaskellDepends = [
@@ -34179,7 +34276,7 @@ self: {
      mkDerivation {
        pname = "codemonitor";
        version = "0.2";
-       sha256 = "14jywd60mxbj5q1srxj4igs1ah0ddf8ww5k4n5d9g7cp1b1yv1mc";
+       sha256 = "ac86edc30a979d975ab16416ce916b0d4015f48b44f6ac032e72f50a4ce35e92";
        isLibrary = false;
        isExecutable = true;
        executableHaskellDepends = [
@@ -34197,7 +34294,7 @@ self: {
      mkDerivation {
        pname = "codepad";
        version = "0.1";
-       sha256 = "03jvbbv4cgrmk0ihz34shd1ydv5jhl1h1xiwqrln60622jlh8mr1";
+       sha256 = "215704a914c2006369c63cf6000385b2ece643839a8c0f2398353f46f65a5b0e";
        revision = "1";
        editedCabalFile = "52fe2b461d77b36400724ddd77e6ec5a92cb9c1bbf5f97efb4cfe87adba3a07a";
        libraryHaskellDepends = [ base curl mtl network tagsoup ];
@@ -34217,7 +34314,7 @@ self: {
      mkDerivation {
        pname = "codex";
        version = "0.3.0.8";
-       sha256 = "1jlrap3qhgnsgdmp0nb2hf3bbjlajp6p4z2q2rl70l93v0v9xi02";
+       sha256 = "02c49e36d82351706816587c72cd958acab586836259706b7bda3e88c75599ca";
        isLibrary = true;
        isExecutable = true;
        libraryHaskellDepends = [
@@ -34241,7 +34338,7 @@ self: {
      mkDerivation {
        pname = "codo-notation";
        version = "0.5.2";
-       sha256 = "1bwfjg0bzph0vka1rx8m6f505l9dmj8nn6al9kmjkva18l05gsvq";
+       sha256 = "78eb57004541ed29eb4c54196b91ac2dd1028a3315f51cd4dc00debfc0938eaf";
        libraryHaskellDepends = [
          base comonad haskell-src-meta parsec template-haskell uniplate
        ];
@@ -34254,7 +34351,7 @@ self: {
      mkDerivation {
        pname = "cofunctor";
        version = "0.1.0.1";
-       sha256 = "0xn4k1c7l9z3g0slbwvlfg9kpfq8jbk0qf9363qz7azv7ks1149p";
+       sha256 = "379110f43cfbabf3f13023390ce69208bb3bd37374f3453578e3277a5898c476";
        libraryHaskellDepends = [ base ];
        description = "DEPRECATED: use the \"contravariant\" package";
        license = stdenv.lib.licenses.bsd3;
@@ -34269,7 +34366,7 @@ self: {
      mkDerivation {
        pname = "cognimeta-utils";
        version = "0.1.2";
-       sha256 = "00bq5qad7x8x0fac1gb8aq97zm4pylnk7n9bg4nkhyyvwnmjsy5l";
+       sha256 = "b4782dabe5db7b382d792bd9332df597d47f125668bdc094031df5d3142e7801";
        isLibrary = true;
        isExecutable = true;
        libraryHaskellDepends = [
@@ -34300,7 +34397,7 @@ self: {
      mkDerivation {
        pname = "coinbase-exchange";
        version = "0.2.0.2";
-       sha256 = "0mh95pfzdvfqy1frwsqi9fi1wgs1nk1xkzijh1pyjm2paqxzynn2";
+       sha256 = "c25aff3b565754e96f8032fed9c3b4413f1ea24b116b9e5df0d8edf6dd2d0956";
        isLibrary = true;
        isExecutable = true;
        libraryHaskellDepends = [
@@ -34331,7 +34428,7 @@ self: {
      mkDerivation {
        pname = "colada";
        version = "0.8.4.0";
-       sha256 = "16inmr2hp2racg85crrpwd45p1wgjhcp7w242nixc8dlwdy1lkz3";
+       sha256 = "e34f1a7ce3b421d6a31544f07319948f875b48e3376756d0632a8b0b45ae369a";
        isLibrary = true;
        isExecutable = true;
        libraryHaskellDepends = [
@@ -34357,7 +34454,7 @@ self: {
      mkDerivation {
        pname = "colchis";
        version = "0.2.0.3";
-       sha256 = "1fhamxm740r59q0sazs2np1b8hv74dhhbb4ah73m94im96729rbb";
+       sha256 = "6be5248e49359254c7818aac0561236743b4c2b5427fa5014e2503726aaf0aba";
        libraryHaskellDepends = [
          aeson base conceit network network-simple pipes pipes-aeson
          pipes-attoparsec pipes-network text transformers
@@ -34374,7 +34471,7 @@ self: {
      mkDerivation {
        pname = "collada-output";
        version = "0.6";
-       sha256 = "1k6k2ljz9x06j0nrpbbpcgd3axamf3cgr6jyslam0xkgxzsi7w7x";
+       sha256 = "fdf013f5ef6f765015d55e9afcd870557535da6377ad9b2d9006f4f42515d3cc";
        isLibrary = true;
        isExecutable = true;
        libraryHaskellDepends = [
@@ -34393,7 +34490,7 @@ self: {
      mkDerivation {
        pname = "collada-types";
        version = "0.3";
-       sha256 = "0aw1y3ylcnpj3wwh6w8168a4mmkiayav6swyh2fq3vfjlds91xc8";
+       sha256 = "88f59074a3d2ed819d809e6bb3955771d64a1432017103391ff25a46fdf0812b";
        libraryHaskellDepends = [
          base containers enumerable OpenGL tuple tuple-gen vector
        ];
@@ -34408,7 +34505,7 @@ self: {
      mkDerivation {
        pname = "collapse-util";
        version = "0.1.0.1";
-       sha256 = "02r4cz92wjm3hcih8jf5jvimw3ijwbp4x7iw90rkj05360ajikj7";
+       sha256 = "47ce281530a3003933483c9e4eeee2320e5ee396c549042383a34a2ed267240b";
        isLibrary = false;
        isExecutable = true;
        executableHaskellDepends = [ base ];
@@ -34423,7 +34520,7 @@ self: {
      mkDerivation {
        pname = "collection-json";
        version = "0.1.0.0";
-       sha256 = "1nzpa791s04r3qikn329r67a64gl9rnk389bk3blijx6q2r9xacc";
+       sha256 = "8ca99eb2c0a6cb48d7982ba1316d4ef411a38ec9490c3b231e99001dd251f7db";
        libraryHaskellDepends = [ aeson base bytestring text ];
        jailbreak = true;
        homepage = "https://github.com/danchoi/collection-json.hs";
@@ -34436,7 +34533,7 @@ self: {
      mkDerivation {
        pname = "collections";
        version = "0.3.1.1";
-       sha256 = "0a5km8k2jwjv4gfd2vf0jiq3f9cw47dgz8f3lspmpx2b0g2pac7g";
+       sha256 = "ef3075c5034bf45bafa6c3a1ffda219c25377094c06dd1dc235b722926aab328";
        libraryHaskellDepends = [
          array base bytestring containers QuickCheck
        ];
@@ -34451,7 +34548,7 @@ self: {
      mkDerivation {
        pname = "collections-api";
        version = "1.0.0.0";
-       sha256 = "0vgw1spiv6wnk11j3y45d95r3axgr1sgksb5lilnxdjj2pn4gp5l";
+       sha256 = "b4dc47ec1552b66e69a465e9f974c8afab914b6a85f8214398969b1daf0efc6d";
        libraryHaskellDepends = [ array base QuickCheck ];
        homepage = "http://code.haskell.org/collections/";
        description = "API for collection data structures";
@@ -34466,7 +34563,7 @@ self: {
      mkDerivation {
        pname = "collections-base-instances";
        version = "1.0.0.0";
-       sha256 = "0nw6wpzqsj33pnffsflc6ipjcx6lknzdnxgn4rm3vhrl5y9rgpzk";
+       sha256 = "f3df97932f34c33d6a26f675dbbe9dd474266f348c3aed9cbd63488dffe5865b";
        libraryHaskellDepends = [
          array base bytestring collections-api containers
        ];
@@ -34481,7 +34578,7 @@ self: {
      mkDerivation {
        pname = "colock";
        version = "0.2.2";
-       sha256 = "0h3y5c3c3711k2glmnydc1rlz9ff73iibcc8vf0zjzvvw9rz0xb1";
+       sha256 = "6175f073e27b7ff981db88b115e338cea54f7360cddb4a9f98219cc1062b7e40";
        libraryHaskellDepends = [ base unix ];
        description = "thread-friendly file locks that don't block the entire program";
        license = "LGPL";
@@ -34492,7 +34589,7 @@ self: {
      mkDerivation {
        pname = "colorize-haskell";
        version = "1.0.1";
-       sha256 = "1v4spa6vw9igjpd1dr595z5raz5fr8f485q5w9imrv8spms46xh3";
+       sha256 = "03764374bd1aed5c63e20517441ccaae7c95cb2fa9e416da952f26be8dba9aec";
        isLibrary = true;
        isExecutable = true;
        libraryHaskellDepends = [ ansi-terminal base haskell-lexer ];
@@ -34507,7 +34604,7 @@ self: {
      mkDerivation {
        pname = "colors";
        version = "0.3.0.2";
-       sha256 = "0gbdqn5wrh9711j5hs5ypbd3w7a3mh37g6aadqiq4m5n7jna6phm";
+       sha256 = "155ea3ac3cb65482236e4a997706ac431d3edababe6858640827c1cc8bc56d3d";
        revision = "1";
        editedCabalFile = "b49946d81e0089d4d80191523839f934802975ede3b9fd9521ead9e591142560";
        libraryHaskellDepends = [ base lens linear profunctors ];
@@ -34521,7 +34618,7 @@ self: {
      mkDerivation {
        pname = "colour";
        version = "2.3.3";
-       sha256 = "1qmn1778xzg07jg9nx4k1spdz2llivpblf6wwrps1qpqjhsac5cd";
+       sha256 = "8d15a63494f8e2a06fe6dc38baee8e948adfae0e93749b9e3ce0fd8ece09b6e2";
        libraryHaskellDepends = [ base ];
        homepage = "http://www.haskell.org/haskellwiki/Colour";
        description = "A model for human colour/color perception";
@@ -34535,7 +34632,7 @@ self: {
      mkDerivation {
        pname = "coltrane";
        version = "0.1.0.0";
-       sha256 = "131arfizyniapjvc9ds6l90z7gig98imhm17k1vza5wvgjqbb5fa";
+       sha256 = "ca95b5b07c9b17f57798275458234a2fbef341a246b7c4b6bc2a5affa3cb2a8c";
        libraryHaskellDepends = [
          base bytestring HTTP http-types HUnit mtl regex-compat text wai
          wai-extra warp
@@ -34552,7 +34649,7 @@ self: {
      mkDerivation {
        pname = "com";
        version = "1.2.3.1";
-       sha256 = "1y6zm63jyigf631f2b0bqw1yhmr6hifaspqivy7qy30brmr5a27m";
+       sha256 = "f5085572cd0b0c8f8fdf115fad5c842657e803c70b2ce1c230ee452f87a9dff8";
        description = "Haskell COM support library";
        license = stdenv.lib.licenses.bsd3;
        hydraPlatforms = stdenv.lib.platforms.none;
@@ -34563,7 +34660,7 @@ self: {
      mkDerivation {
        pname = "combinat";
        version = "0.2.7.0";
-       sha256 = "1rch5pk0sggmdr2wmqys5i5p1cjyqdymrngjf8a2721q6nycfjjz";
+       sha256 = "5f4ac7bc353888231472f2d95c7dc35eb2704b2cdae3ca456ef53d0de62d90e5";
        libraryHaskellDepends = [
          array base containers random transformers
        ];
@@ -34580,7 +34677,7 @@ self: {
      mkDerivation {
        pname = "combinat-diagrams";
        version = "0.1";
-       sha256 = "1m7b0qf583jgi65vg6lxvypvjal74p83iir03ma7cfrgw5s5mw2q";
+       sha256 = "58f05a74e12f3b76541d20c738d025872ab9afdf9d9ab78b894f0e541c06ebd4";
        libraryHaskellDepends = [
          array base colour combinat containers diagrams-core diagrams-lib
          transformers vector-space
@@ -34598,7 +34695,7 @@ self: {
      mkDerivation {
        pname = "combinator-interactive";
        version = "0.1.2";
-       sha256 = "0yxdy413pj6ah4d5qcpajbphfg02p0gxgs1x9salfa18fyflljc4";
+       sha256 = "84494a9d77282847954e3de8d71fb8023c07ef92ea325c1a81cac83b02f1ad7b";
        isLibrary = true;
        isExecutable = true;
        libraryHaskellDepends = [
@@ -34622,7 +34719,7 @@ self: {
      mkDerivation {
        pname = "combinatorial-problems";
        version = "0.0.5";
-       sha256 = "1k3isi62i66xbisn48b018w7fcfhwwng1f64ca530qkk600fg850";
+       sha256 = "a0a0e700307362308a62c4b8f02ce7d03177380a602162755cdd98284cd471cc";
        libraryHaskellDepends = [
          array base bytestring bytestring-lexing containers parsec random
        ];
@@ -34637,7 +34734,7 @@ self: {
      mkDerivation {
        pname = "combinatorics";
        version = "0.1.0";
-       sha256 = "101b3lycfav6wqdqjhs0v93vgy4g3pfn5xyimip0x3alq0q2ix9a";
+       sha256 = "2af52830c0548d0e6eacd1f762dd1d8ff8b747da4043891be6662bc73c1d2b80";
        libraryHaskellDepends = [ base ];
        homepage = "http://code.haskell.org/~wren/";
        description = "Efficient computation of common combinatoric functions";
@@ -34651,7 +34748,7 @@ self: {
      mkDerivation {
        pname = "combobuffer";
        version = "0.2";
-       sha256 = "1zsdi9c9my6nrxpqqsy584swp4zg8lckrymfig1ywisbdfzb8rjh";
+       sha256 = "5066b4be6b4b47eec38baefa3c1945ef93cb3541c56b8c6fcfd6f89a588a4dff";
        libraryHaskellDepends = [
          base containers template-haskell vector vector-space
        ];
@@ -34666,7 +34763,7 @@ self: {
      mkDerivation {
        pname = "command";
        version = "0.1.1";
-       sha256 = "0qj6i5r1iz3d8visqpd74xwkribxzs4p66b1vgp0i3jiqgfrn2hw";
+       sha256 = "1c0a9bddc3518e08eedb61197389fe7dc53c7927a75dace3466dfc1872894662";
        libraryHaskellDepends = [ base deepseq process ];
        homepage = "https://github.com/nh2/command";
        description = "Conveniently run shell commands";
@@ -34680,7 +34777,7 @@ self: {
      mkDerivation {
        pname = "command-qq";
        version = "0.3.0.0";
-       sha256 = "1bqfb4gc5ja9d9jygijqpf6014bmfcxnsvpv7c5n4f1z2aj07jy5";
+       sha256 = "c5cb03a4123f38620b3bfb6e6d3b737591008cbb58c6e7656a49c9c21e590eaf";
        libraryHaskellDepends = [ base process template-haskell text ];
        testHaskellDepends = [ base doctest hspec template-haskell text ];
        homepage = "http://biegunka.github.io/command-qq/";
@@ -34697,7 +34794,7 @@ self: {
      mkDerivation {
        pname = "commodities";
        version = "0.2.0";
-       sha256 = "0xf2vp7wb3qkxkrcwhcqpqfzg9345ws890rkmibvcd21jnczhg89";
+       sha256 = "093df899954134b657ac338384342f64a4f71dbe9841cef2ec138fc5cfddc275";
        libraryHaskellDepends = [
          base comonad containers distributive keys lens linear mtl numbers
          PSQueue semigroupoids semigroups text thyme transformers
@@ -34719,7 +34816,7 @@ self: {
      mkDerivation {
        pname = "commsec";
        version = "0.3.5";
-       sha256 = "1lshp876qm29370mpa3bh0gijcv317sf1y8vajixzz1083bkpngm";
+       sha256 = "f5d93bd74020fcdfa3541bf9e0f4096333191f806ba85bc11949546c0eba50d3";
        libraryHaskellDepends = [
          base bytestring cipher-aes128 crypto-api network
        ];
@@ -34736,7 +34833,7 @@ self: {
      mkDerivation {
        pname = "commsec-keyexchange";
        version = "0.3.3";
-       sha256 = "1c207fv429frkyb742n0r1z0kkvlwnkcxblfkrjm1lwqfkdx0prn";
+       sha256 = "365fd0db7498d350659e8eaecea6e574cf097ec8c00a72969fd92541b63b40b0";
        libraryHaskellDepends = [
          base bytestring cereal cipher-aes128 commsec crypto-api
          crypto-pubkey-types cryptohash-cryptoapi DRBG monadcryptorandom
@@ -34748,6 +34845,23 @@ self: {
        hydraPlatforms = stdenv.lib.platforms.none;
      }) {};
 
+  "commutative" = callPackage
+    ({ mkDerivation, base, QuickCheck, quickcheck-instances, random
+     , semigroups, tasty, tasty-hunit, tasty-quickcheck
+     }:
+     mkDerivation {
+       pname = "commutative";
+       version = "0.0.1.1";
+       sha256 = "b704a7b2dd4c39929f1aec71cf2a6f10d5c4f18842a60e49d9976cfffa4ec43b";
+       libraryHaskellDepends = [ base random semigroups ];
+       testHaskellDepends = [
+         base QuickCheck quickcheck-instances tasty tasty-hunit
+         tasty-quickcheck
+       ];
+       description = "Commutative binary operations";
+       license = stdenv.lib.licenses.mit;
+     }) {};
+
   "comonad" = callPackage
     ({ mkDerivation, base, containers, contravariant, directory
      , distributive, doctest, filepath, semigroups, tagged, transformers
@@ -34756,7 +34870,7 @@ self: {
      mkDerivation {
        pname = "comonad";
        version = "4.2.7.2";
-       sha256 = "0arvbaxgkawzdp38hh53akkahjg2aa3kj2b4ns0ni8a5ylg2cqmp";
+       sha256 = "b762261ef545a16881b66409398752e249a8e654a34088c66d9fabf9ba5a3b2b";
        libraryHaskellDepends = [
          base containers contravariant distributive semigroups tagged
          transformers transformers-compat
@@ -34774,7 +34888,7 @@ self: {
      mkDerivation {
        pname = "comonad-extras";
        version = "4.0";
-       sha256 = "0irlx6rbp0cq5njxssm5a21mv7v5yccchfpn7h9hzr9fgyaxsr62";
+       sha256 = "c264dd957f2ee50f133cf63ac818f3659f5d8350a56adda52d9881bbb2e93447";
        libraryHaskellDepends = [
          array base comonad containers distributive semigroupoids
          transformers
@@ -34791,7 +34905,7 @@ self: {
      mkDerivation {
        pname = "comonad-random";
        version = "0.1.2";
-       sha256 = "11jak28rpnnaswrlf2wgn91v096zkz1laq2cdhjfc7abgmkx9gay";
+       sha256 = "5ebdd4677d4b1de6246c4c6045c39fdf24b043b28f0b4733d7cada9b91984a86";
        libraryHaskellDepends = [ base category-extras random ];
        jailbreak = true;
        description = "Comonadic interface for random values";
@@ -34804,7 +34918,7 @@ self: {
      mkDerivation {
        pname = "comonad-transformers";
        version = "4.0";
-       sha256 = "13zzp6r6s6c80skniphwvzxhpazbyal5854m53139kgcw560rv6z";
+       sha256 = "dfec0c4ce1eccd34c228951454a8f2ebab0bfbdf1cde68a70688196db2b9ff8f";
        libraryHaskellDepends = [ base comonad ];
        homepage = "http://github.com/ekmett/comonad-transformers/";
        description = "This package has been merged into comonad 4.0";
@@ -34816,7 +34930,7 @@ self: {
      mkDerivation {
        pname = "comonads-fd";
        version = "4.0";
-       sha256 = "19xpv0dsz7w3a1sq1gdxwzglfal45vj2s22zb12g9mpk5rp3hw1s";
+       sha256 = "3a70386e2ef3d6f444585f082de42e842a47dfe7bdbd807550839faf1bd8b7a7";
        libraryHaskellDepends = [ base comonad ];
        homepage = "http://github.com/ekmett/comonads-fd/";
        description = "This package has been merged into comonad 4.0";
@@ -34828,7 +34942,7 @@ self: {
      mkDerivation {
        pname = "compact-map";
        version = "2008.11.9";
-       sha256 = "0rk2g5swblbbairwabv5azp6a7cjqywhv49prm1rz8mc361dd9by";
+       sha256 = "7ea5d68219aca29f43cd37910db9c7921d65ee57652fc573546bd1c575796266";
        libraryHaskellDepends = [
          array base binary bytestring containers
        ];
@@ -34842,7 +34956,7 @@ self: {
      mkDerivation {
        pname = "compact-string";
        version = "0.3.1";
-       sha256 = "02lqxl82jmw276mzxwsc0gmps1kb5i62im85bpjvzqwycbf3gnj8";
+       sha256 = "48da37dc629ee3bfe55d05d5284c2c6b067deb034cf3feab3982572910ed980a";
        libraryHaskellDepends = [ base bytestring ];
        homepage = "http://twan.home.fmf.nl/compact-string/";
        description = "Fast, packed and strict strings with Unicode support, based on bytestrings";
@@ -34855,7 +34969,7 @@ self: {
      mkDerivation {
        pname = "compact-string-fix";
        version = "0.3.2";
-       sha256 = "161z0lmrrqvy77ppdgz7m6nazcmlmy1azxa8rx0cgpqmyxzkf87n";
+       sha256 = "f620377ff715dfc740cf48f5af82afb4b2afaca9e7bf76ef397ee39c2b053f98";
        libraryHaskellDepends = [ base bytestring ];
        homepage = "http://twan.home.fmf.nl/compact-string/";
        description = "Same as compact-string except with a small fix so it builds on ghc-6.12";
@@ -34867,7 +34981,7 @@ self: {
      mkDerivation {
        pname = "compare-type";
        version = "0.1.1";
-       sha256 = "1s6p3ni8pqxbp08ci4w6y646wrh60s0g34figrwdcqrywscyicsb";
+       sha256 = "4bb3e899e63e63d6787ed191f1800606666e88f18693c810b8abe38ba21dd7e8";
        libraryHaskellDepends = [ base ];
        homepage = "https://github.com/Kinokkory/compare-type";
        description = "compare types of any kinds in haskell";
@@ -34883,7 +34997,7 @@ self: {
      mkDerivation {
        pname = "compdata";
        version = "0.10";
-       sha256 = "1538jdaww57vil32hvd6s13lfiwkczpjgym07ipwccw06cj49l8h";
+       sha256 = "10d14424338033c66f3ca0fa27ef6793474747d0a66d28068dfb14ce55936894";
        revision = "1";
        editedCabalFile = "09ef1d8f84ae93c4f212661d411542155b0da1c8202e8bf10bfc18d69001a82e";
        libraryHaskellDepends = [
@@ -34904,7 +35018,7 @@ self: {
      mkDerivation {
        pname = "compdata-automata";
        version = "0.9";
-       sha256 = "1hlv6a4ywlnr86pzrlffqbg55mfkrkkxn2yir6a28bdirgi69fkf";
+       sha256 = "6eba64e2cbb12d2494c9d10bdbe7ccd3d552dec2ced1fcaf41d952ee89329bc2";
        revision = "1";
        editedCabalFile = "f8bda15b8d1d1e56f64c37f39ac8ba1c7bf860c291adad3698041eee68146130";
        libraryHaskellDepends = [ base compdata containers projection ];
@@ -34921,7 +35035,7 @@ self: {
      mkDerivation {
        pname = "compdata-dags";
        version = "0.2";
-       sha256 = "0z5vjfm0c4bcixnh951mzc06977l3lcs0v8mz6pbn65qbvv0d27c";
+       sha256 = "ec8806f65eb818bbaef9156da0191df49c6400fb3594046d8f6c1106aa93bb7c";
        libraryHaskellDepends = [
          base compdata containers mtl unordered-containers vector
        ];
@@ -34943,7 +35057,7 @@ self: {
      mkDerivation {
        pname = "compdata-param";
        version = "0.9";
-       sha256 = "1b7kdg4g1mqpzy10wdxm90mbjfwmfpprkbb52ba9qbcg7scap4i4";
+       sha256 = "2492ab983e8f2d9cd41265ad99ef75953bb92a48b5370e82ff17d7f0c86bf3ac";
        libraryHaskellDepends = [
          base compdata mtl template-haskell transformers
        ];
@@ -34964,7 +35078,7 @@ self: {
      mkDerivation {
        pname = "compensated";
        version = "0.6.1";
-       sha256 = "026gq3ppk3id4bvkn3pdg6ljbl14gd8p4hg6i0rc13138b0mlxnh";
+       sha256 = "d0765ac142238cc03288e64172517b24d025a979ed0e3bf7222d8e79efc0cf08";
        libraryHaskellDepends = [
          base bifunctors binary bytes cereal comonad deepseq distributive
          generic-deriving hashable lens log-domain safecopy semigroupoids
@@ -34985,7 +35099,7 @@ self: {
      mkDerivation {
        pname = "competition";
        version = "0.2.0.0";
-       sha256 = "07c6b6yai8x9i8qndimzmyp5bzhwckis8kg207n152gnskk7i3zn";
+       sha256 = "f68f78e6d4f68912ec01e24da4e3641cfe55aeafbfc666318aa9a3a8bc59861d";
        libraryHaskellDepends = [ base filepath parsec ];
        jailbreak = true;
        homepage = "github.com/yanatan16/haskell-competition";
@@ -34998,7 +35112,7 @@ self: {
      mkDerivation {
        pname = "compilation";
        version = "0.0.0.3";
-       sha256 = "0a1pp1jafra1agsx2jizdb33afzg02w6jh4a4pyw5w71kzqfrril";
+       sha256 = "34e6ecf09fe1f0c2fd258a4069b800ef3b35c66a3f4ad1f5534165a764b83728";
        libraryHaskellDepends = [ base MissingH ];
        description = "Haskell functionality for quickly assembling simple compilers";
        license = stdenv.lib.licenses.gpl3;
@@ -35010,7 +35124,7 @@ self: {
      mkDerivation {
        pname = "complex-generic";
        version = "0.1.1";
-       sha256 = "15lqcwg3jp1whf086mlx9f5jv6sbkn53jrilhapalgcgs07nf8ll";
+       sha256 = "9422670fd08f3daaae823466398a9d4b9b2d8b4b9d568380833c5c391e679896";
        libraryHaskellDepends = [ base template-haskell ];
        homepage = "https://gitorious.org/complex-generic";
        description = "complex numbers with non-mandatory RealFloat";
@@ -35022,7 +35136,7 @@ self: {
      mkDerivation {
        pname = "complex-integrate";
        version = "1.0.0";
-       sha256 = "0q0ffpqir4f2ch7d7p2fxgb73n7dg7xf19rg78an7i7zdl430cfj";
+       sha256 = "d23130086dffc463153a2fa7e0fa79edd871d6eb4edcd30e64c2911cf1750e60";
        libraryHaskellDepends = [ base ];
        homepage = "https://github.com/hijarian/complex-integrate";
        description = "A simple integration function to integrate a complex-valued complex functions";
@@ -35036,7 +35150,7 @@ self: {
      mkDerivation {
        pname = "complexity";
        version = "0.1.3";
-       sha256 = "16crk93qyh0arcgqq2bx0i61cah2yhm8wwdr6sasma8y5hlw76lj";
+       sha256 = "929ac3292c1ea9aa9536b9718e2af4022a164c047d098c1fcb0a408f479a9999";
        libraryHaskellDepends = [
          base Chart colour data-accessor hstats parallel pretty time
          transformers
@@ -35052,7 +35166,7 @@ self: {
      mkDerivation {
        pname = "compose-trans";
        version = "0.1";
-       sha256 = "0p2fd0knfbfjk4s0aalzrsrzpxffrykmaprxyakbgs1lmp4jyq9z";
+       sha256 = "3f612fc9ad34e8b7a6f23d5f55a7cfcef5fbb3ce9f2a053499d22d6727684e5c";
        libraryHaskellDepends = [ base mtl ];
        description = "Composable monad transformers";
        license = stdenv.lib.licenses.bsd3;
@@ -35064,7 +35178,7 @@ self: {
      mkDerivation {
        pname = "composition";
        version = "1.0.1.1";
-       sha256 = "112ypxszskri2skj0qbf2a13j2kqnz2pbsrkyja32gs37ln7ca1p";
+       sha256 = "3728762c3d433f3194f433eb75c5b7780a3982126e6120a716314ffd75bf5e84";
        description = "Combinators for unorthodox function composition";
        license = stdenv.lib.licenses.bsd3;
      }) {};
@@ -35074,7 +35188,7 @@ self: {
      mkDerivation {
        pname = "composition-extra";
        version = "1.1.0";
-       sha256 = "1mkm0m08g9q6d8vfz33kj5lz0gnwlkmsnj4r5ar4p3slf2kaybz1";
+       sha256 = "e12fafa670548f4bb22a9948abeba4dc3ef06991738cef366a06a787400575d6";
        libraryHaskellDepends = [ base contravariant ];
        description = "Combinators for unorthodox structure composition";
        license = stdenv.lib.licenses.bsd3;
@@ -35088,7 +35202,7 @@ self: {
      mkDerivation {
        pname = "compressed";
        version = "3.10";
-       sha256 = "1y290n421knfh8k8zbcabhw24hb13xj9pkxx4h4v15yji97p5mcw";
+       sha256 = "9cd5724f8ad297b00924bdcf9b641f614122385c8aad8f2682cece20880549f8";
        revision = "1";
        editedCabalFile = "0ab968cb9d6a6da40cb91befc6051d91b77039f8f64442eecf7a61bd508f61bb";
        libraryHaskellDepends = [
@@ -35105,7 +35219,7 @@ self: {
      mkDerivation {
        pname = "compression";
        version = "0.1";
-       sha256 = "0cy7851i7dvn5aphg649jr3wmw9x57s29adk7qv0mvwz99fb4cpr";
+       sha256 = "f932b25c4a9fef0a363eb3a924f4293df1ca4796899807af2a76b7134341c733";
        libraryHaskellDepends = [ base mtl ];
        homepage = "http://urchin.earth.li/~ian/cabal/compression/";
        description = "Common compression algorithms";
@@ -35120,7 +35234,7 @@ self: {
      mkDerivation {
        pname = "compstrat";
        version = "0.1.0.2";
-       sha256 = "1jdxvyqkszwkry3vly65nh80519cpfw4ghzg1lsbnhyrbhvlchkg";
+       sha256 = "6f4246375cd943bb340defc347b8bb2c850210b4c578ba87cf937f3db1dfbdc9";
        libraryHaskellDepends = [
          base compdata mtl template-haskell th-expand-syns transformers
        ];
@@ -35138,7 +35252,7 @@ self: {
      mkDerivation {
        pname = "comptrans";
        version = "0.1.0.5";
-       sha256 = "05r07900bniy1gazvgj3wj4g07j33h493885bhh7gq1n1xilqgkm";
+       sha256 = "753e4c630f36e077205c05a191081c431ef088e443befdd50b3eda05403a2017";
        libraryHaskellDepends = [
          base compdata containers deepseq deepseq-generics ghc-prim lens
          template-haskell th-expand-syns
@@ -35157,7 +35271,7 @@ self: {
      mkDerivation {
        pname = "computational-algebra";
        version = "0.3.0.0";
-       sha256 = "09ljbspgwpg4g0fca8j10qmbc7194cjhv0l6svz2qr6zzhmb3l4x";
+       sha256 = "9dd0b12afcdf642cfed686820d2523291cb62a064122c51c78e45dfeae5e9226";
        libraryHaskellDepends = [
          algebra base containers equational-reasoning heaps lens monad-loops
          monomorphic peggy singletons sized-vector tagged type-natural
@@ -35174,7 +35288,7 @@ self: {
      mkDerivation {
        pname = "computations";
        version = "0.0.0.0";
-       sha256 = "1kyg3dmgq5z0217rxgljs3x7x3xvcdly2aqj2ky4h4kbw1h0r260";
+       sha256 = "c0880c60e06b1248fc14122be16963bb8f7efad092be9e4f10e017fc6a1bcfcf";
        libraryHaskellDepends = [ base ];
        homepage = "http://darcs.wolfgang.jeltsch.info/haskell/computations";
        description = "Advanced notions of computation";
@@ -35186,7 +35300,7 @@ self: {
      mkDerivation {
        pname = "concatenative";
        version = "1.0.1";
-       sha256 = "05xwqvcdnk8bsyj698ab9jxpa1nk23pf3m7wi9mwmw0q8n99fngd";
+       sha256 = "ed5997924518f0ca6b8afcd4e1ee10d30675bb4c4ba164a4d70b4ddbd8c6bc17";
        libraryHaskellDepends = [ base template-haskell ];
        homepage = "https://patch-tag.com/r/salazar/concatenative/snapshot/current/content/pretty";
        description = "A library for postfix control flow";
@@ -35200,7 +35314,7 @@ self: {
      mkDerivation {
        pname = "conceit";
        version = "0.3.2.0";
-       sha256 = "16pj90dnjn5v16ym2gglx895c9lc5qhrry4wydqyn4f0j7rm6drg";
+       sha256 = "2f3753f391c011eb71f39cf89c212e8c265612eaf43d51bd09bb58691b48f29a";
        libraryHaskellDepends = [
          base bifunctors exceptions mtl semigroupoids transformers void
        ];
@@ -35213,7 +35327,7 @@ self: {
      mkDerivation {
        pname = "concorde";
        version = "0.1";
-       sha256 = "0903lrj6bzajjdr01hbld1jm6vf7assn84hqk4kgrrs1mr3ykc20";
+       sha256 = "40b0e947ae41e7fc2699181264b556c76d53656874c100729352fd6564a60324";
        libraryHaskellDepends = [ base containers process safe temporary ];
        description = "Simple interface to the Concorde solver for the Traveling Salesperson Problem";
        license = stdenv.lib.licenses.bsd3;
@@ -35229,7 +35343,7 @@ self: {
      mkDerivation {
        pname = "concraft";
        version = "0.9.4";
-       sha256 = "17q7mhf0n9pnxhvwk3yy61ljfifz8nhld1xhhnn13fldq34663q3";
+       sha256 = "030f63c8c08dba11ac85b08746a145df45276930de8fc937ecf6260b1cac079f";
        isLibrary = true;
        isExecutable = true;
        libraryHaskellDepends = [
@@ -35253,7 +35367,7 @@ self: {
      mkDerivation {
        pname = "concraft-hr";
        version = "0.1.0.2";
-       sha256 = "0q2l2yqxk210ycw1alcps9x7l2f60g9sb0wan7d1d2fkbfhq3z41";
+       sha256 = "81fc81a15bd38916dab18a83a5d303c6097a7ad297511538f32088d9b1175460";
        isLibrary = true;
        isExecutable = true;
        libraryHaskellDepends = [
@@ -35276,7 +35390,7 @@ self: {
      mkDerivation {
        pname = "concraft-pl";
        version = "0.7.4";
-       sha256 = "0yhq3vdg7l0ibhv0pxj70jm5lrfjk3k0xd1p6ap6im4rh3xxvgw3";
+       sha256 = "83bfddfb8099d468ae3237b40ee698d2655aaa0447f60b365c11d0f3da1e187a";
        isLibrary = true;
        isExecutable = true;
        libraryHaskellDepends = [
@@ -35298,7 +35412,7 @@ self: {
      mkDerivation {
        pname = "concrete-relaxng-parser";
        version = "0.1.1";
-       sha256 = "1w4bg284fcnd15yg7097d8sh0rzxr76zlrr1bfj2dksw8ddy3jda";
+       sha256 = "aac9e15b435ccf26a45b2167facdc9fd6700356a2781f37c09cd324790788bf0";
        isLibrary = false;
        isExecutable = true;
        executableHaskellDepends = [
@@ -35316,7 +35430,7 @@ self: {
      mkDerivation {
        pname = "concrete-typerep";
        version = "0.1.0.2";
-       sha256 = "07wy8drg4723zdy2172jrcvd5ir2c4ggcfz1n33jhm9iv3cl2app";
+       sha256 = "f72a41d9d8315528c7b0e13bf61e6122c7d236cb529c207cfb431cf272439e1f";
        revision = "1";
        editedCabalFile = "cdcd034ff6ff0e8cf9313f312294e12494f3f021c4bf562b9c1365b91715ff4e";
        libraryHaskellDepends = [ base binary hashable ];
@@ -35335,7 +35449,7 @@ self: {
      mkDerivation {
        pname = "concurrent-barrier";
        version = "0.1.2";
-       sha256 = "13idx7w5k8rk3qqls3yn9xqwk116xsqb36ya3vxkb5x4q4vix3mv";
+       sha256 = "bb8e1e37c1a49735fb1eca9bb1b0ee2684c9714fd60f4d311e33a359f8e92d8e";
        libraryHaskellDepends = [ base ];
        homepage = "https://github.com/jsgf/concurrent-barrier";
        description = "Simple thread barriers";
@@ -35349,7 +35463,7 @@ self: {
      mkDerivation {
        pname = "concurrent-dns-cache";
        version = "0.0.1";
-       sha256 = "0awba7ar4iky211psq5d44snd5j75ddvl6klalriic4i5w41dhv2";
+       sha256 = "62c316082f91b0183355741aba5b2b4796663521ad607d43107e4692d5518b2b";
        isLibrary = true;
        isExecutable = true;
        libraryHaskellDepends = [
@@ -35372,7 +35486,7 @@ self: {
      mkDerivation {
        pname = "concurrent-extra";
        version = "0.7.0.9";
-       sha256 = "19bqm0brnbhhmp5nypi995p27mna7kd33xzw0kf7yx2w2p2kb1aw";
+       sha256 = "5c8535c5155c747fdc04fcf731da3ccad6236e49295e6fcbad102e9b17a878a5";
        libraryHaskellDepends = [ base stm unbounded-delays ];
        testHaskellDepends = [
          async base HUnit random stm test-framework test-framework-hunit
@@ -35391,7 +35505,7 @@ self: {
      mkDerivation {
        pname = "concurrent-machines";
        version = "0.1.0.0";
-       sha256 = "1rlxb9cjzjfzj3xj3m6cab3h6pqazi850lkglc6palamn6yd2vw4";
+       sha256 = "846fd1bcb15551750da36f525050fc0a5f03c752ccd421fb90dfc92f595a9de6";
        libraryHaskellDepends = [
          async base containers lifted-async machines monad-control
          semigroups time transformers transformers-base
@@ -35408,7 +35522,7 @@ self: {
      mkDerivation {
        pname = "concurrent-sa";
        version = "1.0.1";
-       sha256 = "1szvw0vih5jx2hvgb3h7mqh05im3pw687h7dshiy4ii5vs9pi6d6";
+       sha256 = "a6997893de2546e223d4edc0830cbfa3c60220ae078ef536145d161837e0fbeb";
        libraryHaskellDepends = [ base MonadRandom ];
        description = "Concurrent simulated annealing system";
        license = stdenv.lib.licenses.bsd3;
@@ -35419,7 +35533,7 @@ self: {
      mkDerivation {
        pname = "concurrent-split";
        version = "0.0.0.1";
-       sha256 = "0xriw08w70dj4gji4afa034q9vcgwymjw2j6gx1x7fwdpi04lzsb";
+       sha256 = "4b7f4a40bc8dbbd3437f460a2eabe78fed84c900ca2912e523b281c311e03177";
        libraryHaskellDepends = [ base ];
        description = "MVars and Channels with distinguished input and output side";
        license = stdenv.lib.licenses.bsd3;
@@ -35430,7 +35544,7 @@ self: {
      mkDerivation {
        pname = "concurrent-state";
        version = "0.6.0.0";
-       sha256 = "0b9lndzqm451j9wv2694gjd9w9j2vmhp32j57fqnq43pq8a1h1z6";
+       sha256 = "e6071814c277106cb13b458a7161dd42269e9a7c2419b17992a1908a7fb3342d";
        isLibrary = true;
        isExecutable = true;
        libraryHaskellDepends = [ base exceptions mtl stm transformers ];
@@ -35446,7 +35560,7 @@ self: {
      mkDerivation {
        pname = "concurrent-supply";
        version = "0.1.7.1";
-       sha256 = "050d1k4hvjjyap3w8spcx57lagnh77z131jbgsndpc9mjx8r4l5y";
+       sha256 = "be5092519735b1dbac7e4b8611fe39d03e454fe9ec6ac4c7555eca0dc90c0d14";
        libraryHaskellDepends = [ base ghc-prim hashable ];
        testHaskellDepends = [ base containers ];
        homepage = "http://github.com/ekmett/concurrent-supply/";
@@ -35459,7 +35573,7 @@ self: {
      mkDerivation {
        pname = "concurrentoutput";
        version = "0.2.0.2";
-       sha256 = "0fd372awmxrngbcb2phyzy3az9j2327kdhjnm7c5mm808vix67a8";
+       sha256 = "481dd3e34600d55ad8a956c2368f1842a6af86ff1e5eb1d87a36f7ca9538a339";
        libraryHaskellDepends = [ base ];
        description = "Ungarble output from several threads";
        license = stdenv.lib.licenses.bsd3;
@@ -35470,7 +35584,7 @@ self: {
      mkDerivation {
        pname = "cond";
        version = "0.4.1.1";
-       sha256 = "12xcjxli1scd4asr4zc77i5q9qka2100gx97hv3vv12l7gj7d703";
+       sha256 = "039c76e43b5484bdc78627f50740106ae2844b3c877d92b5228de9106997ac8b";
        libraryHaskellDepends = [ base ];
        homepage = "https://github.com/kallisti-dev/cond";
        description = "Basic conditional and boolean operators with monadic variants";
@@ -35484,7 +35598,7 @@ self: {
      mkDerivation {
        pname = "condor";
        version = "0.3";
-       sha256 = "0ahikfb6h2clkx3pi6a7gyp39jhv2am98vyyaknyd1nvfvxl96x7";
+       sha256 = "a79b44fb76db86e6ed54de6f94aa121bca34ae7f479978479f940968969b112a";
        isLibrary = true;
        isExecutable = true;
        libraryHaskellDepends = [ base binary containers glider-nlp text ];
@@ -35506,7 +35620,7 @@ self: {
      mkDerivation {
        pname = "condorcet";
        version = "0.0.1";
-       sha256 = "1raf8mrnfnn90ymcnyhqf1kzb9mpfsk83qlmajibjd8n94iq76nd";
+       sha256 = "cd9a8323491635b9a25495e281a676b7a6f56770187acbaa07c95a6773454ee5";
        libraryHaskellDepends = [ array base ];
        homepage = "http://neugierig.org/software/darcs/condorcet";
        description = "Library for Condorcet voting";
@@ -35519,7 +35633,7 @@ self: {
      mkDerivation {
        pname = "conductive-base";
        version = "0.3";
-       sha256 = "1jdslfnwyh7l10xhk9i0293p0qnw0xsd70d5xgpc6xlijhrsg8wp";
+       sha256 = "97a3a733949176c3eeeba581d37407dc6270471220a6093b08f440cfada3bac9";
        libraryHaskellDepends = [ array base containers random stm time ];
        homepage = "http://www.renickbell.net/doku.php?id=conductive-base";
        description = "a library for live coding and real-time musical applications";
@@ -35531,7 +35645,7 @@ self: {
      mkDerivation {
        pname = "conductive-clock";
        version = "0.2";
-       sha256 = "1plml14h5d31jr3bvjjgaxcdqssxqfwwnbz9c5gvjlds6lla145p";
+       sha256 = "b790a02835ba51b95f61e92fcbb9c35d6bdc58574fcabd469661b40249a095de";
        homepage = "http://www.renickbell.net/doku.php?id=conductive-clock";
        description = "a library for displaying musical time in a terminal-based clock";
        license = stdenv.lib.licenses.gpl3;
@@ -35545,7 +35659,7 @@ self: {
      mkDerivation {
        pname = "conductive-hsc3";
        version = "0.3.1";
-       sha256 = "1z037753mxkfqbqqrlkpg5a6z9afpjj16bfplsmbbx3r3vrxbkpa";
+       sha256 = "eaced5f31e79f4b5aaa6d72d13a4bc4ea56f547977d28cf1c26ef63aca3903fc";
        libraryHaskellDepends = [
          base conductive-base conductive-song containers directory filepath
          hosc hsc3 random
@@ -35562,7 +35676,7 @@ self: {
      mkDerivation {
        pname = "conductive-song";
        version = "0.2";
-       sha256 = "16bdsjv64fc3ydv230rja5q9rqzlr4vd9mh3jabiyahck44imrvi";
+       sha256 = "71e71a09990c2a1f979203d6d436c9f4e39c705132832176f3833962b6d46d99";
        libraryHaskellDepends = [ base conductive-base random ];
        homepage = "http://www.renickbell.net/doku.php?id=conductive-song";
        description = "a library of functions which are useful for composing music";
@@ -35577,7 +35691,7 @@ self: {
      mkDerivation {
        pname = "conduit";
        version = "1.2.4.1";
-       sha256 = "0g5rdcj0xbiz3x2pkmhwm67r9f0yncpnssv32s7k0w7qld46wri6";
+       sha256 = "26666e48a3f870308f16636b6d2fb31eb8948fa91cd679451f3fae0e246bb93c";
        libraryHaskellDepends = [
          base exceptions lifted-base mmorph mtl resourcet transformers
          transformers-base void
@@ -35599,7 +35713,7 @@ self: {
      mkDerivation {
        pname = "conduit";
        version = "1.2.5";
-       sha256 = "0iia5hc3rx813aayp839ixr377ajnrhfvpbjach266bk52scs05i";
+       sha256 = "b100cdb428731923205372dded60b6529d33728f69a0eb951a01f53c182c2a46";
        libraryHaskellDepends = [
          base exceptions lifted-base mmorph mtl resourcet transformers
          transformers-base
@@ -35618,7 +35732,7 @@ self: {
      mkDerivation {
        pname = "conduit-audio";
        version = "0.1";
-       sha256 = "1xmxnr7w8s3kmdv5h0y08rnp3sx5wvxqmkg1j7yjycp9z7hbmylb";
+       sha256 = "8bfabae0f9e9322ffd91e1cd8afbe6a5eb716d46c0035876ab7368c44fb6bdf6";
        revision = "1";
        editedCabalFile = "bf853ba8300deda982d278245bd268e91f444ca42185bd0d57eb9feae5ab066c";
        libraryHaskellDepends = [ base conduit vector ];
@@ -35634,7 +35748,7 @@ self: {
      mkDerivation {
        pname = "conduit-audio-lame";
        version = "0.1";
-       sha256 = "0i4nmb4yf2wlkl5da215ysj25gyaikfd292nc9gzmnxjgg1fx19w";
+       sha256 = "3c85eec27bb2dbfa5f625624d1dc8ccabf22a4f62508d50a9d940be7c9aa9644";
        revision = "1";
        editedCabalFile = "34e31416cde87ad1d75570612f3e95d8f54cbeac0539a6f85b93aebaf3979c1a";
        libraryHaskellDepends = [
@@ -35654,7 +35768,7 @@ self: {
      mkDerivation {
        pname = "conduit-audio-samplerate";
        version = "0.1";
-       sha256 = "04s5ld0nsgbjlgkj3f32xnwyah26m6j5qmjxycwgvxjp1siq2xsg";
+       sha256 = "4f7781a30e57f6fd38f35d565ca4a94640e5b9ed62b821e7a3723d6d41a34513";
        revision = "1";
        editedCabalFile = "c3601c344d95841d594827a61b1a7ad05042dec6f62ce9952e88b3d0fe814a63";
        libraryHaskellDepends = [
@@ -35674,7 +35788,7 @@ self: {
      mkDerivation {
        pname = "conduit-audio-sndfile";
        version = "0.1";
-       sha256 = "0v0vzc23c9wfc594pc91d3dw2sda26z1lrkdjjvf572771xysdbd";
+       sha256 = "6d35ed7b38479ce2b6946d661abe11aa69c1db6821b14b52618e273604fb1b6c";
        revision = "1";
        editedCabalFile = "f753b66e55fc5332463bc54a7077b9c503439cd03c7c1c799cd60751ab954a87";
        libraryHaskellDepends = [
@@ -35696,8 +35810,8 @@ self: {
      }:
      mkDerivation {
        pname = "conduit-combinators";
-       version = "1.0.2";
-       sha256 = "1yfck6syqqi5zlp41n3qs8w5ljg63jhg25m8irrcks35n9i541j5";
+       version = "1.0.3";
+       sha256 = "29c1f3dd854d11212474692c6c3a4158ed2929e8443ff2878eee5ea1ed6700bf";
        libraryHaskellDepends = [
          base base16-bytestring base64-bytestring bytestring chunked-data
          conduit conduit-extra filepath monad-control mono-traversable
@@ -35722,7 +35836,7 @@ self: {
      mkDerivation {
        pname = "conduit-connection";
        version = "0.1.0.1";
-       sha256 = "1z3i2s8xl02qb4wfnmqd92kzmbp2jb09msywnzgawyxs5aghy0n4";
+       sha256 = "c4020f9f2aba7baedeb7dceb9ac092e2aefaa7480d57eb38595800da911671fc";
        libraryHaskellDepends = [
          base bytestring conduit connection resourcet transformers
        ];
@@ -35744,7 +35858,7 @@ self: {
      mkDerivation {
        pname = "conduit-extra";
        version = "1.1.9.1";
-       sha256 = "18x01yll1jfv1p9kb7529k8gdh0lav4pbqcqkam2qr9jxxdy26rz";
+       sha256 = "3f1be15bef32652caa9a98e175c95614c0f6d04ca29c35d30ddbc940a90fa0a3";
        libraryHaskellDepends = [
          attoparsec base blaze-builder bytestring conduit directory filepath
          monad-control network primitive process resourcet stm
@@ -35767,7 +35881,7 @@ self: {
      mkDerivation {
        pname = "conduit-iconv";
        version = "0.1.1.0";
-       sha256 = "0bnak5dpqgdgybi62w1rbmr9brbcqv4i2v345x0m275gzsz0i84h";
+       sha256 = "90a008befeaf1c51412f646c11c9c66ce595725d397061e2f2af3d7c5b99ca2e";
        libraryHaskellDepends = [ base bytestring conduit ];
        testHaskellDepends = [
          base bytestring conduit mtl QuickCheck test-framework
@@ -35786,7 +35900,7 @@ self: {
      mkDerivation {
        pname = "conduit-network-stream";
        version = "0.2";
-       sha256 = "0ch0b23z7k4kxnbkvfd3gaxc7xrnlbjz7hv0pshp4k6xqg2bymv4";
+       sha256 = "6457bfc4c3dd4c72a1be60c3f3e5a236f7c3ba7aa3b93d97ed93ccf387580032";
        libraryHaskellDepends = [
          base bytestring conduit mtl network-conduit resourcet
        ];
@@ -35802,7 +35916,7 @@ self: {
      mkDerivation {
        pname = "conduit-parse";
        version = "0.1.0.0";
-       sha256 = "093qc82nrn8ziza1bfp4xnz8k0cpm39k868a3rq4dhah3s40gsv3";
+       sha256 = "63eb07881e50c146701e0a1934d3a8978189beede4ba15d48f1fd96c05627824";
        libraryHaskellDepends = [
          base conduit exceptions parsers text transformers
        ];
@@ -35821,7 +35935,7 @@ self: {
      mkDerivation {
        pname = "conduit-resumablesink";
        version = "0.1.1";
-       sha256 = "1bqdpnhqjh4dhvppsa8nlgja0jpdw48kxywz2999sp5hi53qxdfg";
+       sha256 = "cfb58e4789b05c9d52129ffb3e11e1ed4aa0e4a316297def868d4089a1bd0daf";
        libraryHaskellDepends = [ base conduit void ];
        testHaskellDepends = [
          base bytestring conduit hspec transformers void
@@ -35840,7 +35954,7 @@ self: {
      mkDerivation {
        pname = "conf";
        version = "0.1.1.0";
-       sha256 = "1mxrr14188ikizyxb06764qq1iwhnh19g150mz310q8yw6cypbfw";
+       sha256 = "dcadeb99e11e6110c6afa0849702b490c7803131c780d5fd8f33221448c8b9d7";
        libraryHaskellDepends = [ base haskell-src ];
        testHaskellDepends = [
          base HUnit test-framework test-framework-hunit test-framework-th
@@ -35855,7 +35969,7 @@ self: {
      mkDerivation {
        pname = "config-select";
        version = "0.0.1";
-       sha256 = "1b1fs42c5y5sixgag972m5hb6xwbwp1d64p0gadqg9mg1vknl34y";
+       sha256 = "9e0c6ae70eafa6879b7ae012d3c2e58b77b360a9e2a4a75e8fbaf8c204d12eac";
        isLibrary = false;
        isExecutable = true;
        executableHaskellDepends = [
@@ -35873,7 +35987,7 @@ self: {
      mkDerivation {
        pname = "config-value";
        version = "0.4.0.1";
-       sha256 = "0d9g6ih1rl0z4a2gf285f408vz7iysxwvw6kav280nvx99k2msb7";
+       sha256 = "67e92a664a7d5b80c456d3f0cdbbf6f1fc8d00710509f784221fd01c60342f35";
        libraryHaskellDepends = [ array base pretty text transformers ];
        libraryToolDepends = [ alex happy ];
        homepage = "https://github.com/glguy/config-value";
@@ -35890,7 +36004,7 @@ self: {
      mkDerivation {
        pname = "configifier";
        version = "0.0.5";
-       sha256 = "0k3r8i2mb06kvrqfln0birwd92bwx8m55wpahnbbzs35i35p60vz";
+       sha256 = "7f0373cb8865e8bf9685eaf2522aea7c89d4788e0b58ea70ded380554544794c";
        isLibrary = true;
        isExecutable = true;
        libraryHaskellDepends = [
@@ -35915,7 +36029,7 @@ self: {
      mkDerivation {
        pname = "configuration";
        version = "0.1.1";
-       sha256 = "1jqc5xpbxrlnpxk2yci861gpxl5c9vm9lffchrpp1hk8ag5wkxk1";
+       sha256 = "61f6c9cb5368c2706f86cc399aea4eacd07e5f3028322f66bf96e6be6e2f0ccb";
        libraryHaskellDepends = [ base containers ];
        description = "Simple data type for application configuration";
        license = stdenv.lib.licenses.bsd3;
@@ -35934,7 +36048,7 @@ self: {
      mkDerivation {
        pname = "configuration-tools";
        version = "0.2.13";
-       sha256 = "0rhr5c91bk853zlgld2im0sm0pcss0q6g82c92p85vwkdgrgxlz2";
+       sha256 = "e2d3fef26b93ef82ae484ca06730d09a5d5035a85134fae81f05cd15122b1966";
        libraryHaskellDepends = [
          aeson ansi-wl-pprint attoparsec base base-unicode-symbols
          base64-bytestring bytestring Cabal case-insensitive connection
@@ -35962,7 +36076,7 @@ self: {
      mkDerivation {
        pname = "configurator";
        version = "0.3.0.0";
-       sha256 = "1d1iq1knwiq6ia5g64rw5hqm6dakz912qj13r89737rfcxmrkfbf";
+       sha256 = "6eb9996b672e9f7112ca23482c42fa533553312c3c13f38a8a06476e67c031b4";
        libraryHaskellDepends = [
          attoparsec base bytestring directory hashable text unix-compat
          unordered-containers
@@ -35983,7 +36097,7 @@ self: {
      mkDerivation {
        pname = "confsolve";
        version = "0.5.4";
-       sha256 = "0984gcahddrzlvzsfsrkr8i8jijjg7j2m5namfv8zhdlkrny8h11";
+       sha256 = "2140e46d9eb4c18fb6abca962ae47952468922ca336ba7ffa63fb706157b0425";
        isLibrary = false;
        isExecutable = true;
        executableHaskellDepends = [
@@ -36000,7 +36114,7 @@ self: {
      mkDerivation {
        pname = "congruence-relation";
        version = "0.1.0.0";
-       sha256 = "1pj4kby5pba1xfz2fvv2lij7h2i8crf3qkhgs3rp4ziay0jkg18v";
+       sha256 = "1b853725f02a7e72f3d00f4e3c5c66280a7864a4626f27beeb41ad5bfc9a44de";
        libraryHaskellDepends = [ array base containers ];
        jailbreak = true;
        description = "Decidable congruence relations for Haskell: up to you whether this is a joke";
@@ -36012,7 +36126,7 @@ self: {
      mkDerivation {
        pname = "conjugateGradient";
        version = "2.2";
-       sha256 = "1is3j61ra1whjpm8rq89yj9rscqj1ipgqlnh1nwvyzi2nggl06ya";
+       sha256 = "ca1b40dfb3227ebfb90dd052fc6e0c12339d93f409e18cea95900795839143c7";
        libraryHaskellDepends = [ base containers random ];
        homepage = "http://github.com/LeventErkok/conjugateGradient";
        description = "Sparse matrix linear-equation solver";
@@ -36027,7 +36141,7 @@ self: {
      mkDerivation {
        pname = "conjure";
        version = "0.1";
-       sha256 = "02a33940rnwq5bzqx50fjy76q0z6nimsg2fk3q17ai4kvi0rw0p3";
+       sha256 = "e3029e41dc934475021ed389a76bb4e6036c8e970e948eff2a98db0c481a4309";
        isLibrary = true;
        isExecutable = true;
        libraryHaskellDepends = [
@@ -36044,7 +36158,7 @@ self: {
      mkDerivation {
        pname = "conlogger";
        version = "0.1.0.1";
-       sha256 = "1bxpn27spj4cq9cwg5b486xb35gmwb8hnrhq5g5dpmm7lxgijzh3";
+       sha256 = "037e195fa7a7d6dbca2b18660bd1e2f595b1ba416495c759c28cc8ab8fb0b7af";
        isLibrary = true;
        isExecutable = true;
        libraryHaskellDepends = [ base text ];
@@ -36063,7 +36177,7 @@ self: {
      mkDerivation {
        pname = "connection";
        version = "0.2.5";
-       sha256 = "090il95jnm7ihwvcx3s9v6iwnp37nnsdx15q7722l845g51d95c8";
+       sha256 = "8895d4427985202ac439b884deb4b5675ccba3d9498fce3687f1542b4ba21124";
        libraryHaskellDepends = [
          base byteable bytestring containers data-default-class network
          socks tls x509 x509-store x509-system x509-validation
@@ -36081,7 +36195,7 @@ self: {
      mkDerivation {
        pname = "connection-pool";
        version = "0.1.2.0";
-       sha256 = "12nr9vl884yj4yq9dyfc725zi6dw0amp65xlm9hjm7wffz6mc5az";
+       sha256 = "5f1556cd778e9f2a61aab41773ab02bc99f88b38ccf996b027d21384e84ed98a";
        libraryHaskellDepends = [
          base between data-default-class monad-control network resource-pool
          streaming-commons time transformers-base
@@ -36098,7 +36212,7 @@ self: {
      mkDerivation {
        pname = "consistent";
        version = "0.0.1";
-       sha256 = "003vnmh6mbjz08msnvnjfwwfsn8m15fa9apr5igkvscdqrr5hzd5";
+       sha256 = "a57d5872c68de93d5f2cf9aaa45c091559ed3877d26eab2b025fae6a60b57b00";
        libraryHaskellDepends = [
          base lifted-async lifted-base monad-control stm transformers
          transformers-base unordered-containers
@@ -36117,7 +36231,7 @@ self: {
      mkDerivation {
        pname = "console-program";
        version = "0.3.2.0";
-       sha256 = "1517vwn9l10hihw7ysj812x7cypf5gca468sdzgdlcwvqa8wsr3m";
+       sha256 = "7564cd91c29b33dade6f1a19a2d82bee7a76ba08486a7f388c10049a2cdf2794";
        libraryHaskellDepends = [
          ansi-terminal ansi-wl-pprint base containers directory fez-conf
          haskeline parsec parsec-extra split transformers utility-ht
@@ -36131,7 +36245,7 @@ self: {
      mkDerivation {
        pname = "const-math-ghc-plugin";
        version = "1.0.0.0";
-       sha256 = "1fcj3ssfyxnq4cmb3lr5cg7qkgnkhf1ra0469cbw61gr2fl3kzdl";
+       sha256 = "b4fd39a813f905c3174b8600958383d3be89cf6325d3b12a23d876efb41e92b9";
        libraryHaskellDepends = [ base containers ghc ];
        testHaskellDepends = [ base directory process ];
        homepage = "https://github.com/kfish/const-math-ghc-plugin";
@@ -36145,7 +36259,7 @@ self: {
      mkDerivation {
        pname = "constrained-categories";
        version = "0.2.1.1";
-       sha256 = "0m4c2kva0djxhiqnbxbnlrkq10wvzpbjbbvjv3mz9b550sxr6azy";
+       sha256 = "fe2b93bb06a5acf4ebd872af25d7fd9b838067a676f56571845d36a0f6148c54";
        libraryHaskellDepends = [ base tagged void ];
        homepage = "https://github.com/leftaroundabout/constrained-categories";
        description = "Constrained clones of the category-theory type classes, using ConstraintKinds";
@@ -36158,7 +36272,7 @@ self: {
      mkDerivation {
        pname = "constrained-normal";
        version = "1.0.2";
-       sha256 = "1mq0w2qndrjx9ap9dkyxvz91fbszsnwlhh4hnm9g2dx020fawgac";
+       sha256 = "4c3dae1c10a037f152b5904048b9d55f2f17d2dfddcf96ae4a5de666b1e000d7";
        libraryHaskellDepends = [ base ];
        homepage = "http://dx.doi.org/10.1145/2500365.2500602";
        description = "Normalised Deep Embeddings for Constrained Type-Class Instances";
@@ -36170,7 +36284,7 @@ self: {
      mkDerivation {
        pname = "constraints";
        version = "0.4.1.3";
-       sha256 = "1w3ssvg30rfkp1y20vx0fbq1c0md2wys2rh50mih7645djv56hyx";
+       sha256 = "dd4353b66c85980363050566a13d17ad0216f072a06f207cb8d36530ded67af0";
        libraryHaskellDepends = [ base ghc-prim newtype ];
        homepage = "http://github.com/ekmett/constraints/";
        description = "Constraint manipulation";
@@ -36182,7 +36296,7 @@ self: {
      mkDerivation {
        pname = "constructible";
        version = "0.1.0.1";
-       sha256 = "0d3x92h194y6q8qn11prj05gcnv01vmbvlcsvb1zxgp51qmv1aih";
+       sha256 = "30aab02b0ee5befec3da9ad1bdea0e605bf60a90f9866031c2c69314a0487d34";
        libraryHaskellDepends = [
          arithmoi base binary-search complex-generic
        ];
@@ -36196,7 +36310,7 @@ self: {
      mkDerivation {
        pname = "constructive-algebra";
        version = "0.3.0";
-       sha256 = "17ab0vkq5w3zwh76ws7b82wbc0871qdmvrxhxga78h3h0axjiz1x";
+       sha256 = "3dfc28bb02704074d4ebb0e75d1b0e0701b6b840eb686e0ee47ff082e7064b9d";
        libraryHaskellDepends = [ base QuickCheck type-level ];
        jailbreak = true;
        description = "A library of constructive algebra";
@@ -36213,7 +36327,7 @@ self: {
      mkDerivation {
        pname = "consul-haskell";
        version = "0.2.1";
-       sha256 = "13c3yqn5nsx7r0hkgdwka6fis2ypg54k4damv3c22rdjyids17x7";
+       sha256 = "a79fa05bf4b26521d8d85535324979d70b1d9d5193b73721c8a76b5b2cf6838d";
        libraryHaskellDepends = [
          aeson base base64-bytestring bytestring http-client http-types
          lifted-async lifted-base monad-control network stm text
@@ -36236,7 +36350,7 @@ self: {
      mkDerivation {
        pname = "consumers";
        version = "1.0";
-       sha256 = "1f7jn9lja9fsznjz7d3wfhbd0dc8whcx9jl74jl39mv20k2sdhib";
+       sha256 = "2bc2a6c50462d734a82487cad419e48835d016747cb4f3a5fdda252569b2f2b8";
        libraryHaskellDepends = [
          base containers exceptions hpqtypes lifted-base lifted-threads log
          monad-control mtl stm time transformers-base
@@ -36251,7 +36365,7 @@ self: {
      mkDerivation {
        pname = "container-classes";
        version = "0.0.0.0";
-       sha256 = "18mx50mp9pv1a33kcwmckz6r4a0j6rlc1165ivn9cj8iiwpmd6pv";
+       sha256 = "fb9a562f8f114996ec8ec584c06836122892cd9fac7236c75061df742b28bda2";
        libraryHaskellDepends = [ base ];
        description = "Generic classes for interacting with different container types";
        license = stdenv.lib.licenses.bsd3;
@@ -36262,7 +36376,7 @@ self: {
      mkDerivation {
        pname = "containers";
        version = "0.4.2.1";
-       sha256 = "10xjyxlx6raz5jx17wyw7zqif3bp3xsbzb1756l263g91gd20rsm";
+       sha256 = "556720da0be90d23a82927acbf741f770d17f13fdcf313ba2c5f65d369f7b283";
        revision = "2";
        editedCabalFile = "4cdf787be0b51ffe34f02055117470f87d03c2f6567cd53d908b048c5fc970c8";
        libraryHaskellDepends = [ array base deepseq ];
@@ -36279,7 +36393,7 @@ self: {
      mkDerivation {
        pname = "containers";
        version = "0.5.6.3";
-       sha256 = "1kcd55nl0vzi99i8sr8fmc5j25fv7m0a9hd3nihnq1pd64pfciqn";
+       sha256 = "1647e62e31ed066c61b4a3c1a4403ddb15210bab0e658d624af16f406d298dcd";
        libraryHaskellDepends = [ array base deepseq ghc-prim ];
        testHaskellDepends = [
          array base ChasingBottoms deepseq ghc-prim HUnit QuickCheck
@@ -36296,7 +36410,7 @@ self: {
      mkDerivation {
        pname = "containers-benchmark";
        version = "1.1.0.0";
-       sha256 = "11h88lgwgiyacv9b9k96aih95ydjq1i4ny03z0zw8iyd3c0yi7m0";
+       sha256 = "a09ee8011bcd47c43ff803784b62c0b2f992605426cdb4d266cac7c71f450886";
        isLibrary = false;
        isExecutable = true;
        executableHaskellDepends = [
@@ -36313,7 +36427,7 @@ self: {
      mkDerivation {
        pname = "containers-deepseq";
        version = "0.1.0.1";
-       sha256 = "0l9d7hj66fygpsbjw6wy4l11c9cw739lvkrypapwihav7jzva541";
+       sha256 = "8114b5bf3c5bc1c8afba3ecf4dd3389c251602259e1b2e97becf3b63243c2d51";
        libraryHaskellDepends = [ base containers deepseq ];
        description = "Provide orphan NFData instances for containers as needed. (deprecated)";
        license = stdenv.lib.licenses.bsd3;
@@ -36324,7 +36438,7 @@ self: {
      mkDerivation {
        pname = "containers-unicode-symbols";
        version = "0.3.1.1";
-       sha256 = "0ccv7rqkykfk5wmr73mc0kwrnwyzakgp5x495dgwn5nila3g4ma6";
+       sha256 = "4655f286a2d116cb5f2b89f472df54df739bf904ac8e932b2fd34d3f713e9b31";
        libraryHaskellDepends = [ base base-unicode-symbols containers ];
        homepage = "http://haskell.org/haskellwiki/Unicode-symbols";
        description = "Unicode alternatives for common functions and operators";
@@ -36340,7 +36454,7 @@ self: {
      mkDerivation {
        pname = "context-free-grammar";
        version = "0.1.0";
-       sha256 = "11s6v8h39iq0wy4p4y8cwpr8fjhphql07s38rgbm8qsq1hj9f3a1";
+       sha256 = "410d97240c586354d7cb68e8032886174a87f2e50c797289e700c73420da4687";
        libraryHaskellDepends = [
          array base containers control-monad-omega dlist mtl pretty
          template-haskell
@@ -36360,7 +36474,7 @@ self: {
      mkDerivation {
        pname = "context-stack";
        version = "0.1.0.1";
-       sha256 = "0y51xlva4364658bgbchcasbq5pka2ixlvhdf9g38xwlmhfg736x";
+       sha256 = "dd8cf31cac9477345e720d6edaa350f316bcb46290adb75031c40ca236eda178";
        libraryHaskellDepends = [
          base classy-prelude mtl unordered-containers
        ];
@@ -36378,7 +36492,7 @@ self: {
      mkDerivation {
        pname = "continue";
        version = "0.2.0";
-       sha256 = "0iyqwqbzmk8v4j6xdmfir8mdxjgzl1dh76c9ngwzyccpv7xbz59a";
+       sha256 = "2a95bffad99731fff9b38999035ba0ffc9de2acad1d5d68d241bcdfa17e6d847";
        libraryHaskellDepends = [
          base bifunctors monad-control mtl semigroupoids transformers
          transformers-base
@@ -36394,7 +36508,7 @@ self: {
      mkDerivation {
        pname = "continued-fractions";
        version = "0.9.1.1";
-       sha256 = "0gqp1yazmmmdf04saa306jdsf8r5s98fll9rnm8ff6jzr87nvnnh";
+       sha256 = "d0da6d0fca5f1ae750b53951ea50d22523a79b346028a50970add6fa950f173f";
        libraryHaskellDepends = [ base ];
        homepage = "/dev/null";
        description = "Continued fractions";
@@ -36410,7 +36524,7 @@ self: {
      mkDerivation {
        pname = "continuum";
        version = "0.1.0.7";
-       sha256 = "0viqn05l4xjwb3w2qbldxmwv0dj1bzwbvjcgczj1clhdx2zdgfx6";
+       sha256 = "a6bbd7bee80d5216e4678fc9bdf85f4136b079ed8d2e2cf8585c76420bb0386e";
        isLibrary = true;
        isExecutable = true;
        libraryHaskellDepends = [
@@ -36433,7 +36547,7 @@ self: {
      mkDerivation {
        pname = "continuum-client";
        version = "0.1.0.0";
-       sha256 = "0qv7dz2h3aay4ak5nz38wp3wrrk2zzg2g58xdlglvml08hpxsf7k";
+       sha256 = "f338dd2f4480d64d1f6d1d9527deff62e6ccc7e5687c5ba6225ea901c56f6763";
        libraryHaskellDepends = [
          base bytestring cereal containers mtl nanomsg-haskell time
        ];
@@ -36448,7 +36562,7 @@ self: {
      mkDerivation {
        pname = "contravariant";
        version = "1.3.2";
-       sha256 = "0fb6az12604vwvfhnmvxfin68n0fb2jcvrliv3vvrmfnfq3axfjj";
+       sha256 = "52baae0676d6d5bcf7d891e6cda4580e58646c747d570bdde69b0023c2576639";
        libraryHaskellDepends = [
          base semigroups StateVar transformers transformers-compat void
        ];
@@ -36462,7 +36576,7 @@ self: {
      mkDerivation {
        pname = "control-bool";
        version = "0.2.1";
-       sha256 = "10amxm1ff7xhd8g66n65wkbb8d17n77v1nmwxkbzhrask398asp4";
+       sha256 = "e46a85d2985a65f8d7ecbcdab0cfb12734b4d6e4c558631e6ab01fe742ed5581";
        libraryHaskellDepends = [ base ];
        homepage = "https://github.com/fumieval/control-bool";
        description = "Useful combinators for boolean expressions";
@@ -36474,7 +36588,7 @@ self: {
      mkDerivation {
        pname = "control-event";
        version = "1.2.1.1";
-       sha256 = "0hwsidsxnzi4b3aphn3f7lsf1z508ql6cnhfq6zbqfsvcynm7565";
+       sha256 = "c59453ad675b3bbcbec10e5a662846a0fce0343d6e5878d558247edb758b9a43";
        libraryHaskellDepends = [ base containers stm time ];
        description = "Event scheduling system";
        license = stdenv.lib.licenses.bsd3;
@@ -36486,7 +36600,7 @@ self: {
      mkDerivation {
        pname = "control-monad-attempt";
        version = "0.3.0.1";
-       sha256 = "140n27vdbyjz5qycrwlrmyd7s48fxcl6msl16g7czg40k5y23j5s";
+       sha256 = "bac8217c9980bccfce3381ea6a28eb0e117d9aaf99f2cc3c2e5ffad5f6111690";
        libraryHaskellDepends = [ attempt base transformers ];
        jailbreak = true;
        homepage = "http://github.com/snoyberg/control-monad-attempt";
@@ -36502,7 +36616,7 @@ self: {
      mkDerivation {
        pname = "control-monad-exception";
        version = "0.11.2";
-       sha256 = "0vdms5if6c04459ksix5q38l9cflgc5bwnchd422fp2qfji5j14p";
+       sha256 = "970459a274585c2704699059be0a7bd4b144d1c0a5473d53210430e362d1b56d";
        libraryHaskellDepends = [
          base failure lifted-base monad-control monadloc transformers
          transformers-base
@@ -36519,7 +36633,7 @@ self: {
      mkDerivation {
        pname = "control-monad-exception-monadsfd";
        version = "0.10.3";
-       sha256 = "1izyxqry863jg9i88gcs7cib39q9c2mnm74mxdyl1d84kj1hrnim";
+       sha256 = "35da0c839c04b5407deb959c6aab6009a7b1223b9a3d84627a7218e433eefec7";
        libraryHaskellDepends = [
          base control-monad-exception monads-fd transformers
        ];
@@ -36535,7 +36649,7 @@ self: {
      mkDerivation {
        pname = "control-monad-exception-monadstf";
        version = "0.10.3";
-       sha256 = "1qj4y71g5p6b4aa5wn5fp4i5c9iw0pdrqs9yvzr6f41v6knw16za";
+       sha256 = "ea9bc0ed343b1067f2df3e699cdb053c265622b9ae585e9422cbdcf2c2f144e2";
        libraryHaskellDepends = [
          base control-monad-exception monads-tf transformers
        ];
@@ -36549,7 +36663,7 @@ self: {
      mkDerivation {
        pname = "control-monad-exception-mtl";
        version = "0.10.3";
-       sha256 = "1wwqn3xcd2fspfd2cnf9cym0cbbgvlajr3pkx7f2v3b37mx6blni";
+       sha256 = "d1d2657a3d638d2ddce9f38e2c15dd6f2d06aa67c959269abbda89c6fab098f3";
        libraryHaskellDepends = [ base control-monad-exception mtl ];
        homepage = "http://pepeiborra.github.com/control-monad-exception";
        description = "MTL instances for the EMT exceptions monad transformer";
@@ -36562,7 +36676,7 @@ self: {
      mkDerivation {
        pname = "control-monad-failure";
        version = "0.7.0.1";
-       sha256 = "1g304wb1fhx81iw2vv7nv6cp2qmy69frwiv3vax85lxw03s4nlkq";
+       sha256 = "78524bf400bcd382bada63479e5d32be627199d9f6ec2d780ca84317162760bc";
        libraryHaskellDepends = [ base failure transformers ];
        jailbreak = true;
        homepage = "http://github.com/pepeiborra/control-monad-failure";
@@ -36576,7 +36690,7 @@ self: {
      mkDerivation {
        pname = "control-monad-failure-mtl";
        version = "0.7.1";
-       sha256 = "0j9i85vq033789vx2589mfqwk954hqy1wla527ssbyf05k6vkn8j";
+       sha256 = "12d9b9cd2cc0f9a5f51145511e3c86a4a4c9b1ab0915d17742670c8077413149";
        libraryHaskellDepends = [ base failure mtl ];
        jailbreak = true;
        homepage = "http://github.com/pepeiborra/control-monad-failure";
@@ -36590,7 +36704,7 @@ self: {
      mkDerivation {
        pname = "control-monad-free";
        version = "0.5.3";
-       sha256 = "1igwawcdpg8irayjax1xdrlpa9587k1v4y28ib3xfb7yk0xv7vk1";
+       sha256 = "61eeb33b98fe2cd7c78a4878b2c33ca82475696e3d7425bdca11bddb1857fcc5";
        libraryHaskellDepends = [ base deepseq transformers ];
        homepage = "http://github.com/pepeiborra/control-monad-free";
        description = "Free monads and monad transformers";
@@ -36602,7 +36716,7 @@ self: {
      mkDerivation {
        pname = "control-monad-free";
        version = "0.6.1";
-       sha256 = "11i297ngwb5ck23vsr84fh5qx4hn7fzm9ml90y79lwi97hyigagy";
+       sha256 = "fea9173d3c29729a8e0789d654bf3b16928e0b740465bd8798ac2cfeec492286";
        revision = "1";
        editedCabalFile = "d08dceee154098bee492a1c00ef699a2a3a0e8a3851c5d49ccd49d5645a501a4";
        libraryHaskellDepends = [ base prelude-extras transformers ];
@@ -36616,7 +36730,7 @@ self: {
      mkDerivation {
        pname = "control-monad-loop";
        version = "0.1";
-       sha256 = "003k4pp6wgn30m9ksbh8680f0klzsvd90wsl9jpqs9lpg14hi6zj";
+       sha256 = "f29b08497897268daf4c547390dad69f4ee00032082e3d5305c33e6eee257300";
        libraryHaskellDepends = [ base transformers transformers-base ];
        homepage = "https://github.com/joeyadams/haskell-control-monad-loop";
        description = "Simple monad transformer for imperative-style loops";
@@ -36628,7 +36742,7 @@ self: {
      mkDerivation {
        pname = "control-monad-omega";
        version = "0.3.1";
-       sha256 = "11hirysr76i01qj8rm22xjcrv2qwxgwjlrqqyd1dsnnvypn9hfrq";
+       sha256 = "383b98ecf5db5add42f318672af9eb1c8b9d99ec42d48c240e209a93b5cf1186";
        libraryHaskellDepends = [ base ];
        homepage = "http://github.com/luqui/control-monad-omega";
        description = "A breadth-first list monad";
@@ -36640,7 +36754,7 @@ self: {
      mkDerivation {
        pname = "control-monad-queue";
        version = "0.2";
-       sha256 = "15syy24v1a2h25j4ijddi9l0pmp84wq9hlryh18f1jvqm8apc8vs";
+       sha256 = "7a237615aa78cbe050803e53983027e8d60b688aadc948641150a8b089f05e97";
        libraryHaskellDepends = [ base ];
        description = "Reusable corecursive queues, via continuations";
        license = stdenv.lib.licenses.bsd3;
@@ -36651,7 +36765,7 @@ self: {
      mkDerivation {
        pname = "control-timeout";
        version = "0.1.2";
-       sha256 = "1g1x6c4dafckwcw48v83f3nm2sxv8kynwv8ib236ay913ycgayvg";
+       sha256 = "6f7bf5981f2179658658116d6efd44bb6b51ed70036d4438e39339d508333dbc";
        libraryHaskellDepends = [ base containers stm time ];
        description = "Timeout handling";
        license = stdenv.lib.licenses.bsd3;
@@ -36662,7 +36776,7 @@ self: {
      mkDerivation {
        pname = "contstuff";
        version = "1.2.6";
-       sha256 = "0rw2bslajjch057fsxf881wi39bsd9y6196j0kb0lz47r0zn8003";
+       sha256 = "0300643fc8877c0ad604d2a4607c6a7aa5117940c875ed4e019049a9a85e8267";
        libraryHaskellDepends = [ base transformers ];
        homepage = "http://haskell.org/haskellwiki/Contstuff";
        description = "Fast, easy to use CPS-based monad transformers";
@@ -36674,7 +36788,7 @@ self: {
      mkDerivation {
        pname = "contstuff-monads-tf";
        version = "0.2.1";
-       sha256 = "0j4y76ar0m642jxcyrvlrxagawrlq637cvx3fqprw5sl5cslgxh5";
+       sha256 = "05f647352b54179e2f76a36f7686c13473f554cf7467cfba14c4549095399e48";
        libraryHaskellDepends = [ base contstuff monads-tf ];
        description = "ContStuff instances for monads-tf transformers (deprecated)";
        license = stdenv.lib.licenses.bsd3;
@@ -36686,7 +36800,7 @@ self: {
      mkDerivation {
        pname = "contstuff-transformers";
        version = "0.1.1";
-       sha256 = "0b5vskp1bxqpi4ffcxwjw6kr0jd6n8v8jlhf03p54ckfd5ym4ai6";
+       sha256 = "262a527d696e3252ee000e528936b2a64990a7e19277e61c8917f715eed4bb2c";
        libraryHaskellDepends = [ base contstuff transformers ];
        jailbreak = true;
        description = "Deprecated interface between contstuff 0.7.0 and the transformers package";
@@ -36699,7 +36813,7 @@ self: {
      mkDerivation {
        pname = "converge";
        version = "0.1.0.1";
-       sha256 = "0y28m7kgphknra0w2kzf0g4m2bdj604nr3f22xng46nl7kljbpvj";
+       sha256 = "72df25e93cd41af26c17c28d6c0930b22d51c903ee4fc181ca76c2fbe6a94878";
        libraryHaskellDepends = [ base ];
        homepage = "/dev/null";
        description = "Limit operations for converging sequences";
@@ -36710,8 +36824,8 @@ self: {
     ({ mkDerivation, base-prelude }:
      mkDerivation {
        pname = "conversion";
-       version = "1.1.0.1";
-       sha256 = "1bgads36prqw7m10hfmg9161d3hs5pa5qql9lbsny5hqvxsmb30d";
+       version = "1.1.1";
+       sha256 = "420411e16b58c7ea1ab522ea5171329270c885bfdbb8c403d8f65ee12405e61b";
        libraryHaskellDepends = [ base-prelude ];
        homepage = "https://github.com/nikita-volkov/conversion";
        description = "Universal converter between values of different types";
@@ -36723,7 +36837,7 @@ self: {
      mkDerivation {
        pname = "conversion-bytestring";
        version = "1.0.0.1";
-       sha256 = "1gsbfmp58qzhvnyl6jgy1pah954qaxi184clh31lzam9m1j44k3y";
+       sha256 = "7e4c4264a8a9aa4fc3809411146257989404d50dfe4943bdddf063546e754bbf";
        libraryHaskellDepends = [ base-prelude bytestring conversion ];
        homepage = "https://github.com/nikita-volkov/conversion-bytestring";
        description = "\"Conversion\" instances for the \"bytestring\" library";
@@ -36735,7 +36849,7 @@ self: {
      mkDerivation {
        pname = "conversion-case-insensitive";
        version = "1.0.0.0";
-       sha256 = "14mf5jincplqrdln6xja0c840mmj4khd5n3z5f4glgpnmk9r3dcp";
+       sha256 = "97b591d3acf63efa882b7fd8d2e024b2564010034a766369cb985e66a32cae92";
        libraryHaskellDepends = [ case-insensitive conversion ];
        homepage = "https://github.com/nikita-volkov/conversion-case-insensitive";
        description = "\"Conversion\" instances for the \"case-insensitive\" library";
@@ -36749,7 +36863,7 @@ self: {
      mkDerivation {
        pname = "conversion-text";
        version = "1.0.0.2";
-       sha256 = "0j7j0jww92v9gldh8hd35p51ka2mq4n26chfw6n4m034q3pjqpby";
+       sha256 = "7e5d2cefc064804aace10e32232cc155a819ca2da341041b7d698bc4b904f248";
        libraryHaskellDepends = [
          base-prelude bytestring conversion conversion-bytestring text
        ];
@@ -36765,7 +36879,7 @@ self: {
      mkDerivation {
        pname = "convertible";
        version = "1.1.1.0";
-       sha256 = "0v18ap1mccnndgxmbfgyjdicg8jlss01bd5fq8a576dr0h4sgyg9";
+       sha256 = "e9f9a70904b9995314c2aeb41580d654a2c76293feb955fb6bd63256c355286c";
        isLibrary = true;
        isExecutable = true;
        libraryHaskellDepends = [
@@ -36783,7 +36897,7 @@ self: {
      mkDerivation {
        pname = "convertible-ascii";
        version = "0.1.0.1";
-       sha256 = "0yzfq0r430ziclxn44k9x3jwl675gs3lafr5d1cb6y9j20fl1sjw";
+       sha256 = "5cea401d103279b35868253b45877ee518cae5e86912623b65f1834132c0ee7b";
        libraryHaskellDepends = [
          ascii base base-unicode-symbols blaze-builder bytestring
          convertible-text failure text
@@ -36802,7 +36916,7 @@ self: {
      mkDerivation {
        pname = "convertible-text";
        version = "0.4.0.2";
-       sha256 = "1wqpl9dms1rsd24d00f18l9sm601nm6kr7h4ig8y70jdzy8w73fz";
+       sha256 = "df8dc391ff4d82e3d18b049e3c4db50198aa1345c101d088683a075d5ba217f3";
        isLibrary = true;
        isExecutable = true;
        libraryHaskellDepends = [
@@ -36821,7 +36935,7 @@ self: {
      mkDerivation {
        pname = "cookbook";
        version = "3.0.0.1";
-       sha256 = "1mhj4g7bg6gi1wx8pshwl4n37vgqacnssh5hwskyaajy4gqz6hki";
+       sha256 = "7142f3f1235e2ae5a7e6b040ad2d53f8ed332ca11cea8b3a0ff199b7ce2312d6";
        libraryHaskellDepends = [ base directory strict ];
        description = "Tiered general-purpose libraries with domain-specific applications";
        license = stdenv.lib.licenses.bsd3;
@@ -36835,7 +36949,7 @@ self: {
      mkDerivation {
        pname = "cookie";
        version = "0.4.1.6";
-       sha256 = "0b6ym6fn29p5az4dwydy036lxj131kagrmgb93w4bbkqfkds8b9s";
+       sha256 = "3a2da4db7478ae45f848ebd5fcd40c23c84ecd00be79dec857e526619da9de2c";
        libraryHaskellDepends = [
          base blaze-builder bytestring data-default-class deepseq old-locale
          text time
@@ -36856,7 +36970,7 @@ self: {
      mkDerivation {
        pname = "coordinate";
        version = "0.0.19";
-       sha256 = "01f6dmyx2kqyzf1n06awcyx0ygqgy829snxw6bbxbvih9yhkjq2r";
+       sha256 = "596039a14f30eed5d732bc5b9d04f20f3f0fba675c196083fb1e4fd17d6dc605";
        libraryHaskellDepends = [ base lens radian tagged transformers ];
        testHaskellDepends = [
          base directory doctest filepath QuickCheck template-haskell
@@ -36874,7 +36988,7 @@ self: {
      mkDerivation {
        pname = "copilot";
        version = "2.1.2";
-       sha256 = "0mslkyyl5shcxh05i1vprzacaxxg3jjdqcfin475zv5gm5cn26vz";
+       sha256 = "7f1b6159a9afec5f0eb1d131dca41caf77c5d4cf77875800ec0cea42bd9f5457";
        isLibrary = true;
        isExecutable = true;
        libraryHaskellDepends = [
@@ -36898,7 +37012,7 @@ self: {
      mkDerivation {
        pname = "copilot-c99";
        version = "2.1.2";
-       sha256 = "0lvldfkksxxmf3mbchwxzj1a1yagdk7k3zbyid181gskvmkxnfzd";
+       sha256 = "ed3bdb67dd53bf80428b7efd31cf6c4ff9a082fc9d43b6ea70b5773da76b7453";
        isLibrary = true;
        isExecutable = true;
        libraryHaskellDepends = [
@@ -36921,7 +37035,7 @@ self: {
      mkDerivation {
        pname = "copilot-cbmc";
        version = "2.1.2";
-       sha256 = "02ng4iqsr5yp435fcqjjh9j5p93l4cixjdnqjx4fafhhfrv8g8a1";
+       sha256 = "41a1877676103ae54897d836d9232374a45b64825262e6ca20d797ac7124cf0a";
        libraryHaskellDepends = [
          base bytestring copilot-c99 copilot-core copilot-sbv directory
          pretty process
@@ -36938,7 +37052,7 @@ self: {
      mkDerivation {
        pname = "copilot-core";
        version = "2.1.2";
-       sha256 = "1gdq76c170sv58fb56ik8mam3f63dg0jk6myd5rv4sbh4z45xfs7";
+       sha256 = "47bb5ec8277069b27369be9a29c16bc3b8515545339ab21c2a5b83139839b8bd";
        libraryHaskellDepends = [
          base containers dlist mtl pretty pretty-ncols random
        ];
@@ -36954,7 +37068,7 @@ self: {
      mkDerivation {
        pname = "copilot-language";
        version = "2.1.2";
-       sha256 = "1099w6hk6v4rna02z4zsrwf1m883w6nxgycy5d8iamd4n2pk6bk3";
+       sha256 = "632e33afb0a45515512b9ef9d7ade103a11a1ccffa932f80b2996c33a1e12981";
        libraryHaskellDepends = [
          array base containers copilot-core data-reify ghc-prim mtl
        ];
@@ -36970,7 +37084,7 @@ self: {
      mkDerivation {
        pname = "copilot-libraries";
        version = "2.1.1";
-       sha256 = "0b69rfz4gvdvk9f9y7yns3hmh1m7akcrm3rcdi8rkhizykcnnsyj";
+       sha256 = "d26b6bd9f43fc299516c2c8f9ad954a70658e1d0d61f9f5c9abbed47becbc92c";
        libraryHaskellDepends = [
          array base containers copilot-language mtl parsec
        ];
@@ -36986,7 +37100,7 @@ self: {
      mkDerivation {
        pname = "copilot-sbv";
        version = "2.1.2";
-       sha256 = "1a4blmxrglp4fmrfnc7g3w0zhyl3fdx3lvaw2mi47wchqbqcgicr";
+       sha256 = "99c5c7f0c290f14362155c6d3a7a73837af8011fef30eb7275e4d2977ba58ba8";
        libraryHaskellDepends = [
          base containers copilot-core filepath pretty sbv
        ];
@@ -37002,7 +37116,7 @@ self: {
      mkDerivation {
        pname = "copr";
        version = "1.1.1";
-       sha256 = "0zgg60ri8yvz96gk08wdfn0445wqszigh2p0964nr2zdnffq5rnw";
+       sha256 = "dce6829db3ed8b6c8949e00af8e2d798174280758d23309f497f7b143330ef7d";
        revision = "1";
        editedCabalFile = "ef9fb8be7d257feae9e4647de62d489860e2bd6510e34a35465cf5b763fa2425";
        libraryHaskellDepends = [
@@ -37021,7 +37135,7 @@ self: {
      mkDerivation {
        pname = "core";
        version = "0.5";
-       sha256 = "1fqgfbd3in8l84250kda67paakz4sr2ywf5qzsy403546w7q9ccz";
+       sha256 = "9fb1840f37a40c40bcfeb838ee45d6e44fa5ee31aa4d50044114d938da720fbb";
        libraryHaskellDepends = [ base bytestring parsec pretty ];
        description = "External core parser and pretty printer";
        license = stdenv.lib.licenses.bsd3;
@@ -37033,7 +37147,7 @@ self: {
      mkDerivation {
        pname = "core-haskell";
        version = "0.6.4";
-       sha256 = "1wjmj2p8j6xw7cga01jsjgpi4dswrxif3j6mml48fq8a4k19zqxr";
+       sha256 = "b9e39fc2240a618708add5c8e162cf5c3712ef935a06a01e3bbc1b89ae9055f2";
        isLibrary = false;
        isExecutable = true;
        executableHaskellDepends = [
@@ -37053,7 +37167,7 @@ self: {
      mkDerivation {
        pname = "corebot-bliki";
        version = "0.2.2.0";
-       sha256 = "10pfz4bw1wh55c2cizd8jiwh8bkaqw9p773976vl52f0jrhns1qg";
+       sha256 = "0f076d6196c08942b739699c7313c76a2e047994a8fdc8042b05f2c017f9ee82";
        isLibrary = true;
        isExecutable = true;
        libraryHaskellDepends = [
@@ -37077,7 +37191,7 @@ self: {
      mkDerivation {
        pname = "coroutine-enumerator";
        version = "0.1.1";
-       sha256 = "1rjbhpy5vw1maawi47jsrnagqm19say9w1i31pgcpxl45vhrshp7";
+       sha256 = "e7429de12e84f6cbde0d23069ebcd22954fc94cd5a1e12b95235f05dfc854be6";
        libraryHaskellDepends = [ base enumerator monad-coroutine ];
        jailbreak = true;
        homepage = "http://trac.haskell.org/SCC/wiki/coroutine-enumerator";
@@ -37090,7 +37204,7 @@ self: {
      mkDerivation {
        pname = "coroutine-iteratee";
        version = "0.1.1";
-       sha256 = "1ycir4kwpcz34yg64cdb9q0jxv3ma12vrrs28cr5jm64jmi8m0wd";
+       sha256 = "8d838a6295c45459324342e7bc455075ec2e014eab31629e27e3b3cb27c991f9";
        libraryHaskellDepends = [ base iteratee monad-coroutine ];
        jailbreak = true;
        homepage = "http://trac.haskell.org/SCC/wiki/coroutine-iteratee";
@@ -37106,7 +37220,7 @@ self: {
      mkDerivation {
        pname = "coroutine-object";
        version = "0.3";
-       sha256 = "0q0rvcc7ipxwmikaxh0ymq1d65f2q1a2jrd1i553pdf8hwmv0k1r";
+       sha256 = "394cb02b87c8b53b4a89a1652954c0c215d302ae1ec0ae66acbcdf7818db1960";
        libraryHaskellDepends = [
          base bytestring cereal containers either lens mtl safecopy
          transformers transformers-free uuid
@@ -37122,7 +37236,7 @@ self: {
      mkDerivation {
        pname = "couch-hs";
        version = "0.1.6";
-       sha256 = "0mrx0mjh9kzk6nx53gn5hvhjgmhlwphxkl5yn9a1x17l62v3x6q7";
+       sha256 = "079b3eb630f4841e54b2bed0d9e1e514d627e186c5be51ba35f3cf0465053d57";
        isLibrary = true;
        isExecutable = true;
        libraryHaskellDepends = [
@@ -37146,7 +37260,7 @@ self: {
      mkDerivation {
        pname = "couchdb-conduit";
        version = "0.10.6";
-       sha256 = "0rp5pj56m9n20g5hjjw8gbx81lb2z0ckwpgpvyr2a5sgk6b7z2al";
+       sha256 = "54897f96994f1725b2dff75d3e19f862d180fa7a884b09cb03c2a66a8abce566";
        libraryHaskellDepends = [
          aeson attoparsec attoparsec-conduit base blaze-builder bytestring
          conduit containers data-default http-conduit http-types lifted-base
@@ -37177,7 +37291,7 @@ self: {
      mkDerivation {
        pname = "couchdb-enumerator";
        version = "0.3.7";
-       sha256 = "02h0a61dbchyjp0shpj0shsdfcggx0cm5psxgw9g67vv3v8f98pn";
+       sha256 = "f6a2e4d01e7b1ff3127f5ddf5219e8ef31d734d4405ea8c1951eb2d58251000a";
        libraryHaskellDepends = [
          aeson attoparsec attoparsec-enumerator base bytestring enumerator
          http-enumerator http-types lifted-base monad-control text
@@ -37202,7 +37316,7 @@ self: {
      mkDerivation {
        pname = "count";
        version = "0.0.1";
-       sha256 = "1az2vr1rjq4pfgzswwbwgfq4kcb8kq759vn5kl7ghzaqr7b6vkgx";
+       sha256 = "fdcd6dd6c9587df80e9dc5ee540e9e68b149b07b7c71aeff7397609943dee2ab";
        libraryHaskellDepends = [ base ];
        description = "Bijective mappings between values and possibly infinite prefixes of [0..]";
        license = stdenv.lib.licenses.bsd3;
@@ -37213,7 +37327,7 @@ self: {
      mkDerivation {
        pname = "countable";
        version = "0.2";
-       sha256 = "1az6pk1is587ggys6v1qh3yabnc63vr0fcd5bmvwx20c137yflik";
+       sha256 = "3352e7cf080c88ce775da53107f21e86d9a5fc80386ca3fd7b07151dc3bce6ab";
        libraryHaskellDepends = [ base ];
        homepage = "https://github.com/AshleyYakeley/countable";
        description = "Countable, Searchable, Finite, Empty classes";
@@ -37225,7 +37339,7 @@ self: {
      mkDerivation {
        pname = "counter";
        version = "0.1.0.1";
-       sha256 = "0pfg34ph6b7qb3wscvvnqdkqqzkjdjc8wynv35ikgf295bsf3kaz";
+       sha256 = "5fcde1f42a49b8376319db7a8e986c727e8c67c3766fa6f958f82c032f19cf5d";
        libraryHaskellDepends = [ base containers ];
        homepage = "https://github.com/wei2912/counter";
        description = "An object frequency counter";
@@ -37239,7 +37353,7 @@ self: {
      mkDerivation {
        pname = "country-codes";
        version = "0.1.2";
-       sha256 = "16729grgn4bgnh9nw51h3pil054bixqxfa8lxwfz8xf3b6lcm774";
+       sha256 = "e49ccaa859c375f41def1429d7718f8b1440e31d30146e13b46f11fbf24be298";
        isLibrary = true;
        isExecutable = true;
        libraryHaskellDepends = [ aeson base shakespeare text ];
@@ -37258,7 +37372,7 @@ self: {
      mkDerivation {
        pname = "courier";
        version = "0.1.0.15";
-       sha256 = "1aj9anrw7jfqx8s2xkdznqs212f54g6i2lcf79bgnkmxsbax252v";
+       sha256 = "5b14d1d5d2bd4efb563a8e5111cd23c5892034b6bfcd2e34ead8c9c3b35549aa";
        libraryHaskellDepends = [
          async base bytestring cereal containers hslogger network stm text
          uuid
@@ -37279,7 +37393,7 @@ self: {
      mkDerivation {
        pname = "court";
        version = "0.1.0.0";
-       sha256 = "0cpvm6cjfz203hajl8fj5gxc5hc7516v0bzz4d7hyih2kh21k6dn";
+       sha256 = "b69919049c02460f4f23ff2fb04d2887c1c2fa2bd2212a151c407c2799a9fb32";
        isLibrary = false;
        isExecutable = true;
        executableHaskellDepends = [
@@ -37300,7 +37414,7 @@ self: {
      mkDerivation {
        pname = "cpio-conduit";
        version = "0.7.0";
-       sha256 = "04zma03ivg9x5f1xkdpc828fk2lh6qrn7cig7gprci13id9yf2wg";
+       sha256 = "8f0be7538b234496ef3b2fb2633336908ae99040ecb6d9832b3dbd1d0750f513";
        libraryHaskellDepends = [
          base base16-bytestring binary bytestring conduit conduit-extra
        ];
@@ -37321,7 +37435,7 @@ self: {
      mkDerivation {
        pname = "cplusplus-th";
        version = "1.0.0.0";
-       sha256 = "0gmsn35rd6ij4ax4j626hg9pdb40ilj22zg0nxrnl6n1828a9rqj";
+       sha256 = "12e7a49040c11a6a73b7e07d21248d80ac76d383461849ba22329a96cbb0ba3e";
        libraryHaskellDepends = [
          base bytestring containers process template-haskell
        ];
@@ -37339,7 +37453,7 @@ self: {
      mkDerivation {
        pname = "cpphs";
        version = "1.19.2";
-       sha256 = "194hcvhjgm6rmbqp857y3j39lvl2p91mqrrgpi15jq00icnv4idv";
+       sha256 = "bb45b22d8b00605942bc2f675c43ba826e9a861cfe1474f1aad9d427e16690a4";
        isLibrary = true;
        isExecutable = true;
        libraryHaskellDepends = [
@@ -37360,7 +37474,7 @@ self: {
      mkDerivation {
        pname = "cprng-aes";
        version = "0.6.1";
-       sha256 = "1wr15kbmk1g3l8a75n0iwbzqg24ixv78slwzwb2q6rlcvq0jlnb4";
+       sha256 = "64592a01de8c6683c5e29f538dceee918887ffe211d87214a2e38559d72c21f3";
        libraryHaskellDepends = [
          base byteable bytestring cipher-aes crypto-random
        ];
@@ -37376,7 +37490,7 @@ self: {
      mkDerivation {
        pname = "cprng-aes-effect";
        version = "0.1.0.2";
-       sha256 = "0443h7jfpjvc6vmp3kfx0h6j2aynvgfznssz7lin9fmsxghlvsfb";
+       sha256 = "cbe94de1ebbaba64233d5f6bfbdddbd62b210d04ddcd71eb366ccbebe4818310";
        revision = "1";
        editedCabalFile = "b9752152bb1764da66976eaf18776b09dabf80eeb6f252bcee0da10fa0a1057e";
        libraryHaskellDepends = [
@@ -37394,7 +37508,7 @@ self: {
      mkDerivation {
        pname = "cpsa";
        version = "2.5.2";
-       sha256 = "0zm2waj17ak43rhri9rhvwy970dv22r0k42fzbm3n6gcl5h2mcq5";
+       sha256 = "05b32a60a1ec193beafa4e9009b210bb81933cdf30a798611e64aa13a4e2a27e";
        isLibrary = false;
        isExecutable = true;
        executableHaskellDepends = [ array base containers parallel ];
@@ -37408,7 +37522,7 @@ self: {
      mkDerivation {
        pname = "cpu";
        version = "0.1.2";
-       sha256 = "0x19mlanmkg96h6h1i04w2i631z84y4rbk22ki4zhgsajysgw9sn";
+       sha256 = "5627feb4974a3ff8499c42cc958927e88761a2e004c4000d34e9cd6a15ad2974";
        isLibrary = true;
        isExecutable = true;
        libraryHaskellDepends = [ base ];
@@ -37422,7 +37536,7 @@ self: {
      mkDerivation {
        pname = "cpuid";
        version = "0.2.3";
-       sha256 = "126xg98yaf3q61h85yrs1cm6wxlayf590l0a3h0gw6c282s8l6gq";
+       sha256 = "f8198ab4408219fe001c0a50908af38a766e2a0b3afb8260307838e5517add88";
        isLibrary = true;
        isExecutable = true;
        libraryHaskellDepends = [ base data-accessor enumset ];
@@ -37436,7 +37550,7 @@ self: {
      mkDerivation {
        pname = "cpuperf";
        version = "0.1.1";
-       sha256 = "1xnmrm3agkxziflvanihckg6q97z5w9gh7yv7mbbc7gqax3sz6l0";
+       sha256 = "809aaf4757f81db6563ddb1ff8122fff246cde64305ab5a98bbfcfa746cdd5f6";
        isLibrary = false;
        isExecutable = true;
        executableHaskellDepends = [ base mtl process ];
@@ -37451,7 +37565,7 @@ self: {
      mkDerivation {
        pname = "cpython";
        version = "3.3.0";
-       sha256 = "162m0dfgnicyv3jb9dqq6pmyymh1dim043kbmbg1hfhxjfrv17jj";
+       sha256 = "529eb0b3931d3a18deaa6b0e026a6c0156efeb3518b7b4e4d89e45fb5c035598";
        libraryHaskellDepends = [ base bytestring text ];
        libraryPkgconfigDepends = [ python3 ];
        libraryToolDepends = [ c2hs ];
@@ -37470,7 +37584,7 @@ self: {
      mkDerivation {
        pname = "cql";
        version = "3.0.5";
-       sha256 = "12v5hhlji9w73chxdhazpmhbaxmjs98lw1y6cm8p29bgxdi75q61";
+       sha256 = "c1e07262eb6f25715165c6074e51d2b276b560bd5fc1d6211b87a7282984658b";
        libraryHaskellDepends = [
          base bytestring cereal Decimal iproute network template-haskell
          text time transformers uuid vector
@@ -37494,7 +37608,7 @@ self: {
      mkDerivation {
        pname = "cql-io";
        version = "0.14.5";
-       sha256 = "0ks2sn3dfrr8ilvmw48hfz3140x9dsi79w6ci4vfksn1g5ndnpiy";
+       sha256 = "3e5edb6c79c1eae93689ccf074a26ea90312c67710115e378d2867d786d5424f";
        libraryHaskellDepends = [
          async auto-update base bytestring containers cql cryptohash
          data-default-class exceptions hashable iproute lens monad-control
@@ -37514,7 +37628,7 @@ self: {
      mkDerivation {
        pname = "cqrs";
        version = "0.9.0";
-       sha256 = "1r3wl6fwkqccnfhazq7dk4c2zmlirxrh3y7a7fjhxm9273g59f1b";
+       sha256 = "2bb854de3822d50ea53beaf80173cf91d62f1899ede0afa0b38ce1c99da17ce4";
        libraryHaskellDepends = [
          base bytestring conduit containers cqrs-types deepseq pool-conduit
          random SafeSemaphore stm transformers
@@ -37537,7 +37651,7 @@ self: {
      mkDerivation {
        pname = "cqrs-example";
        version = "0.9.1";
-       sha256 = "0yllvs64qaxpgqlwdv3hmi4gzl5qf2lbyy3r0whyi2kz53kwl03i";
+       sha256 = "7100cae7287f8ae821077978bfa870b8d0ff48ac70ecc6297eb72b4c8cde947a";
        isLibrary = false;
        isExecutable = true;
        executableHaskellDepends = [
@@ -37559,7 +37673,7 @@ self: {
      mkDerivation {
        pname = "cqrs-postgresql";
        version = "0.9.0";
-       sha256 = "0zannh06gbc5vm5cpx9015i7ssg38k5lwwyajxhxa1nckwynqmzb";
+       sha256 = "eb576c3d9fcc06d56197ca734ecb44e3697d620920f5cb4add85ad6700b4567d";
        libraryHaskellDepends = [
          base bytestring bytestring-lexing conduit cqrs-types old-locale
          pool-conduit postgresql-libpq text time transformers
@@ -37581,7 +37695,7 @@ self: {
      mkDerivation {
        pname = "cqrs-sqlite3";
        version = "0.9.0";
-       sha256 = "086g5z7ajr2x2didd0q8qcvnxdsf2gfrn27436gbj8y81cbg0fsh";
+       sha256 = "503bf0160bc823b99e19e4089bdd134eb76e37c30883d662135d64a9ce2fcf20";
        libraryHaskellDepends = [
          base bytestring conduit cqrs-types direct-sqlite pool-conduit text
          transformers
@@ -37603,7 +37717,7 @@ self: {
      mkDerivation {
        pname = "cqrs-test";
        version = "0.9.0";
-       sha256 = "1i47c2d7c64kp63spm12jkwg3g21i0z4n9z9gdwvmsr1s638k5gl";
+       sha256 = "f4958986d121ebba797be9274b3e8841bcf1f89422d4ab87b99318769a6087c4";
        libraryHaskellDepends = [
          base bytestring conduit cqrs-types hspec HUnit pool-conduit stm
          transformers
@@ -37621,7 +37735,7 @@ self: {
      mkDerivation {
        pname = "cqrs-types";
        version = "0.9.0";
-       sha256 = "1xxyy8zrx76x3vg54awhp9lz5qhg9x5cafhlqr45ilfz2rxjkzbg";
+       sha256 = "6ffd297b16dfd15848c6143ac54a4f0fe2f269ba902b52de1edd9c9e3ff2bef7";
        libraryHaskellDepends = [
          base base16-bytestring base64-bytestring bytestring conduit deepseq
          derive random
@@ -37639,7 +37753,7 @@ self: {
      mkDerivation {
        pname = "cr";
        version = "1.2";
-       sha256 = "107chyp8br2ryjqdf7100109k0wg3jawzva76wf4r6fndjr3gin1";
+       sha256 = "c1c637b26cd6994c1c3747edcf951c8f83994000201cd7b0f459e485ae87ec80";
        isLibrary = false;
        isExecutable = true;
        executableHaskellDepends = [
@@ -37656,7 +37770,7 @@ self: {
      mkDerivation {
        pname = "crack";
        version = "0.1";
-       sha256 = "0rfwvvb3q0a7z8is95yjh3wfvz818xyblp1hrwh8fwddppncrzrk";
+       sha256 = "33ffccecbdad718720cf305cba7c4701fdedf880d297a423fa47013cd6dedc65";
        libraryHaskellDepends = [ base ];
        librarySystemDepends = [ crack ];
        description = "A haskell binding to cracklib";
@@ -37669,7 +37783,7 @@ self: {
      mkDerivation {
        pname = "crackNum";
        version = "1.3";
-       sha256 = "06balzwvvpl69abfcq0gynv6zpy42aygvlicb9jsnrys2vyipv28";
+       sha256 = "48ec1bfd16da67ab655a2cd2fdbc12c4df6fb6f50f60e6964a86debdf9a76a19";
        isLibrary = true;
        isExecutable = true;
        libraryHaskellDepends = [ base data-binary-ieee754 ieee754 ];
@@ -37683,7 +37797,7 @@ self: {
      mkDerivation {
        pname = "craftwerk";
        version = "0.1";
-       sha256 = "0002n3fq3afmby843gfi0dnwm2saq29w6hnn6lzqhsalw33j97d3";
+       sha256 = "a39d24c7e05469883f35d642c393c04a8bca6d03d1bd41905fd5a981ddb00200";
        isLibrary = true;
        isExecutable = true;
        libraryHaskellDepends = [ base colour mtl vector-space ];
@@ -37699,7 +37813,7 @@ self: {
      mkDerivation {
        pname = "craftwerk-cairo";
        version = "0.1";
-       sha256 = "16in87l2v49k785fldm7fvprywg0v497kz29jr22y91q5j5gnm4z";
+       sha256 = "9f54fb8a2c38242f449649fc7912d9e0719fef76a736ea0a3a33912de841369a";
        libraryHaskellDepends = [ base cairo craftwerk mtl ];
        jailbreak = true;
        homepage = "http://mahrz.github.com/craftwerk.html";
@@ -37715,7 +37829,7 @@ self: {
      mkDerivation {
        pname = "craftwerk-gtk";
        version = "0.1";
-       sha256 = "18b63yh4p5ry38c3p6plyhk5j0gmmnyjw25r2dxdaddpnn051nff";
+       sha256 = "ced95080b5b735d57a13b9082ebdadf5015926f4f49a3b181a3e974ba01f66a1";
        isLibrary = true;
        isExecutable = true;
        libraryHaskellDepends = [
@@ -37733,7 +37847,7 @@ self: {
      mkDerivation {
        pname = "crc16";
        version = "0.1.1";
-       sha256 = "15x3xwq2vyg474m09jak1c2zx9w5acpfjgmy5jj4asxj33z9n7bz";
+       sha256 = "7f1d9bfe18b26b45a42cbe3ee92e5385a7fe050b53c9042a39e4f92d30efa397";
        libraryHaskellDepends = [ base bytestring ];
        description = "Calculate the crc16-ccitt";
        license = stdenv.lib.licenses.bsd3;
@@ -37745,7 +37859,7 @@ self: {
      mkDerivation {
        pname = "crc16-table";
        version = "0.1";
-       sha256 = "0x943wmcbj679kj7q2a2ipjycq17ajm71m487vkb8b6gdrdy8f2z";
+       sha256 = "5f38e45b6ecf2cb4e63e88d470aa542760e6e58d42097ce44cc7c8c52a1f2475";
        libraryHaskellDepends = [ array base ];
        description = "Compute CRC16 checksums using a lookup table";
        license = stdenv.lib.licenses.bsd3;
@@ -37761,7 +37875,7 @@ self: {
      mkDerivation {
        pname = "creatur";
        version = "5.9.8.2";
-       sha256 = "15cjk5hb4j7ydsis8fz7gag3sa17i6yr26pfbf8aqkw7iakmjqs9";
+       sha256 = "496359a78a874fac905bee1a91bd8927283d9e7ae73ba4a36efe48b260999295";
        libraryHaskellDepends = [
          array base bytestring cereal cond directory exceptions filepath
          gray-extended hdaemonize hsyslog MonadRandom mtl old-locale process
@@ -37785,7 +37899,7 @@ self: {
      mkDerivation {
        pname = "crf-chain1";
        version = "0.2.2";
-       sha256 = "0v0mmpvn9qma3xz92s13ywk9p5czxzshh2rf06hb2zqqq5m6iwhq";
+       sha256 = "18f2686ac1187fb1a0012e0b08f5ef9f959b26f72368917e1faae264f7ad156c";
        libraryHaskellDepends = [
          array base binary containers data-lens logfloat monad-codec
          parallel random sgd vector vector-binary vector-th-unbox
@@ -37805,7 +37919,7 @@ self: {
      mkDerivation {
        pname = "crf-chain1-constrained";
        version = "0.3.2";
-       sha256 = "02xf9q96rlmmfcdz45bpbsdi0ki7mdrdwzg2zph7b55jwsnb4fja";
+       sha256 = "4a3ab2ace6b29475e0fde27dde72ab274e109b5e7715f21b73b5d26c124eae0b";
        libraryHaskellDepends = [
          array base binary containers data-lens logfloat monad-codec
          parallel random sgd vector vector-binary vector-th-unbox
@@ -37824,7 +37938,7 @@ self: {
      mkDerivation {
        pname = "crf-chain2-generic";
        version = "0.3.0";
-       sha256 = "104r52rf5q84bm6977bsfm4djcz8c08warfkk4xmympb0cmxkhxy";
+       sha256 = "bec3d92b03eb565f3b99d365c51160e833d948757a9d934c5d04e1e2b2289980";
        libraryHaskellDepends = [
          array base binary comonad-transformers containers data-lens
          logfloat monad-codec parallel sgd vector vector-binary
@@ -37844,7 +37958,7 @@ self: {
      mkDerivation {
        pname = "crf-chain2-tiers";
        version = "0.2.4";
-       sha256 = "0sxa5rsla676x47a1l8cvypccyl8vi7y68fnbnrk7r20ahw6vxi1";
+       sha256 = "21f66d385440e433b35dd621e34fdc887ac6aedf0cd1a00ee9e61845752eaa6b";
        libraryHaskellDepends = [
          array base binary comonad containers data-lens logfloat monad-codec
          parallel sgd vector vector-binary vector-th-unbox
@@ -37863,7 +37977,7 @@ self: {
      mkDerivation {
        pname = "critbit";
        version = "0.2.0.0";
-       sha256 = "1xdgaj73ffvj1q1kyi62bifbazmzgamfwzdbdz0c339axw5dga82";
+       sha256 = "02a9d70aef2a8dc1c06fab7deeaa7abf7eb55c5cc2443f030e723b378e54aff5";
        libraryHaskellDepends = [
          array base bytestring deepseq text vector
        ];
@@ -37887,7 +38001,7 @@ self: {
      mkDerivation {
        pname = "criterion";
        version = "1.1.0.0";
-       sha256 = "0f1d8lxb9jhrhcm0gbqqimmq52q36b5h1nqznmjmxa75nqdx9vaw";
+       sha256 = "5cedd41bb6e5a85e65b51fdb00cb32038b826b8d18af072a8319cab43a452d38";
        isLibrary = true;
        isExecutable = true;
        libraryHaskellDepends = [
@@ -37916,7 +38030,7 @@ self: {
      mkDerivation {
        pname = "criterion-plus";
        version = "0.1.3";
-       sha256 = "127nqhp2gczbfqablvrrk92am4kpsnzhvyl4kcy98kdv313vcwdl";
+       sha256 = "b471b64718bb4d943c9b84fa0dbfd57792aa449a396fba1476ebb3272ec4f688";
        libraryHaskellDepends = [
          base criterion deepseq loch-th monad-control mtl
          optparse-applicative placeholders statistics string-conversions
@@ -37943,7 +38057,7 @@ self: {
      mkDerivation {
        pname = "criterion-to-html";
        version = "0.0.0.3";
-       sha256 = "010x56czgipw3p1cfkx07mlcy4yj6advq3zzgrxpmjhrxzsa89xn";
+       sha256 = "b627a4f4ef19ca7a7b7eff0fbc9b32d213cf683da04fc7c21dfcc6f799291d04";
        isLibrary = false;
        isExecutable = true;
        executableHaskellDepends = [
@@ -37960,7 +38074,7 @@ self: {
      mkDerivation {
        pname = "crockford";
        version = "0.2";
-       sha256 = "1fgsmf2k0v1j7b3gv06q9c65410qa2ivl59rwkm7j931wsymsg26";
+       sha256 = "463c5dbde6612479eae43915baa3501804520c4bd880fdc63a326c3085abfab9";
        libraryHaskellDepends = [ base digits QuickCheck safe ];
        description = "An implementation of Douglas Crockford's base32 encoding";
        license = stdenv.lib.licenses.bsd3;
@@ -37973,7 +38087,7 @@ self: {
      mkDerivation {
        pname = "crocodile";
        version = "0.1.2";
-       sha256 = "1krvcn5yb9i6jxwn2wwnpc8ylivhn27315a2sifn19f1l2vvy038";
+       sha256 = "6800bfb7a0c1a5605dd44295308eb07047ea11bb967361799726a6e58b653bcf";
        isLibrary = false;
        isExecutable = true;
        executableHaskellDepends = [
@@ -37994,7 +38108,7 @@ self: {
      mkDerivation {
        pname = "cron";
        version = "0.3.0";
-       sha256 = "18yadf94bzyhm5nab6lc8zagp39yv5k8cjjakhaxncgipcm30s9k";
+       sha256 = "3369302abbf131db159c4a4a8666d93e8dfbd4478c9aa56ca9d0ff45926bcaa3";
        libraryHaskellDepends = [
          attoparsec base mtl mtl-compat old-locale text time
        ];
@@ -38015,7 +38129,7 @@ self: {
      mkDerivation {
        pname = "cron-compat";
        version = "0.2.6";
-       sha256 = "0km70j3xfqvpra9mvbxpvpqd7arjjfcpazmilvmj6kjxk6cw7pfx";
+       sha256 = "ddddc399995d4e23eba6b17e75999332abd3f0ddb7af5d93ca7763d78704a74e";
        libraryHaskellDepends = [
          attoparsec base mtl mtl-compat old-locale text time
          transformers-compat
@@ -38035,7 +38149,7 @@ self: {
      mkDerivation {
        pname = "cruncher-types";
        version = "1.1.0";
-       sha256 = "0kp0vm8mvgn12kk5csyhzv6g6az43acl6iwjbhvfdfr2mqif2b9h";
+       sha256 = "302de122ae22bbe6365c924743991ae42bf3ccfed06b56e614c1be5d51dde04e";
        libraryHaskellDepends = [ aeson base containers lens text ];
        testHaskellDepends = [ base hlint ];
        homepage = "http://github.com/eval-so/cruncher-types";
@@ -38050,7 +38164,7 @@ self: {
      mkDerivation {
        pname = "crunghc";
        version = "0.1.1.1";
-       sha256 = "08341mvdca70nlkdi2im344hhkv62s278a1gkp02hj0zrixzfkqm";
+       sha256 = "154ff77bcc1f4828c09d2f28748416664f080919358ad826b5e028d6760d6420";
        isLibrary = false;
        isExecutable = true;
        executableHaskellDepends = [
@@ -38070,7 +38184,7 @@ self: {
      mkDerivation {
        pname = "crypto-api";
        version = "0.13.2";
-       sha256 = "1vc27qcgbg7hf50rkqhlrs58zn1888ilh4b6wrrm07bnm48xacak";
+       sha256 = "5331d511a9761d5073e6661148234228d88f8ace14e2994171f0bcf5183e82ed";
        libraryHaskellDepends = [
          base bytestring cereal entropy tagged transformers
        ];
@@ -38087,7 +38201,7 @@ self: {
      mkDerivation {
        pname = "crypto-api-tests";
        version = "0.3";
-       sha256 = "0w3j43jdrlj28jryp18hc6q84nkl2yf4vs1hhgrsk7gb9kfyqjpl";
+       sha256 = "f44aecdd4ceb9da9f38330e84d9c17745a82b0611085ebb34442d2dce4207270";
        libraryHaskellDepends = [
          base bytestring cereal crypto-api directory filepath HUnit
          QuickCheck test-framework test-framework-hunit
@@ -38105,7 +38219,7 @@ self: {
      mkDerivation {
        pname = "crypto-cipher-benchmarks";
        version = "0.0.5";
-       sha256 = "1ddyz0fn3srvm37afbiw86lv0z7iwrmnhazgvk0gg5n3ic57anhq";
+       sha256 = "185a750a8bc396f7c0dcef2b686be6f17cb0a9413c2ea7cea83beb611df8beb5";
        libraryHaskellDepends = [
          base byteable bytestring criterion crypto-cipher-types mtl pretty
          securemem
@@ -38124,7 +38238,7 @@ self: {
      mkDerivation {
        pname = "crypto-cipher-tests";
        version = "0.0.11";
-       sha256 = "19wqignlq90qwpam01hnmmrxaxh5lkax9l1l6rlbi4a07nvp1dnz";
+       sha256 = "dfb670b73d4091b8683634d0d4d5a40576d573ad160650d5e518244ced8b98a7";
        libraryHaskellDepends = [
          base byteable bytestring crypto-cipher-types HUnit mtl QuickCheck
          securemem test-framework test-framework-hunit
@@ -38144,7 +38258,7 @@ self: {
      mkDerivation {
        pname = "crypto-cipher-types";
        version = "0.0.9";
-       sha256 = "03qa1i1kj07pfrxsi7fiaqnnd0vi94jd4jfswbmnm4gp1nvzcwr0";
+       sha256 = "2073f6b70df7916aebe2da49d224497183662d56d19da87b76f70039430c0a0f";
        libraryHaskellDepends = [ base byteable bytestring securemem ];
        homepage = "http://github.com/vincenthz/hs-crypto-cipher";
        description = "Generic cryptography cipher types";
@@ -38159,7 +38273,7 @@ self: {
      mkDerivation {
        pname = "crypto-classical";
        version = "0.1.0";
-       sha256 = "06x694ia1alw53a282krzmkbcr1xbvn5nmgfqbgysgpz5ky931wg";
+       sha256 = "8f8791fc2cff3eeddfc2ee555bec5e3d64b666fd790a24d4289caaa02249a61b";
        libraryHaskellDepends = [
          base bytestring containers crypto-numbers crypto-random lens
          modular-arithmetic QuickCheck random random-shuffle text
@@ -38178,7 +38292,7 @@ self: {
      mkDerivation {
        pname = "crypto-conduit";
        version = "0.5.5";
-       sha256 = "0zd4smj3rk2x1msl8z8f5y01x4b87rhgm45g26g6c3dsdasn1lyf";
+       sha256 = "ced360b56aba0d669e11af90fa603e68911e802f0e7d44750d5dcc3c64d5a47d";
        libraryHaskellDepends = [
          base bytestring cereal conduit conduit-extra crypto-api resourcet
          transformers
@@ -38200,7 +38314,7 @@ self: {
      mkDerivation {
        pname = "crypto-numbers";
        version = "0.2.7";
-       sha256 = "19l9y5jzvqrqfam13xin9m9ca0s5ql86yv0cjn6dzkydx4byn2j2";
+       sha256 = "420aeb17e9cdcfdf8c950c6c6f10c54503c5524d36f611aa7238e3fd65f189a6";
        revision = "1";
        editedCabalFile = "2b493386b7605b70a67f751d6496e9feff8ef319a5294b122a3ff3895a8453ca";
        libraryHaskellDepends = [
@@ -38223,7 +38337,7 @@ self: {
      mkDerivation {
        pname = "crypto-pubkey";
        version = "0.2.8";
-       sha256 = "0vmmx2fqq2xc3xfavy22i2nyynpk88jhmjr62qgxw5w5qgsz5k60";
+       sha256 = "c0ccf2f5c38517de1f1626cb0a2542f35aefad8842f8ad5c1fac0b8c9de8b56e";
        libraryHaskellDepends = [
          base byteable bytestring crypto-numbers crypto-pubkey-types
          crypto-random cryptohash
@@ -38247,7 +38361,7 @@ self: {
      mkDerivation {
        pname = "crypto-pubkey-openssh";
        version = "0.2.7";
-       sha256 = "0ndb1crjl3xbd18bfs3ipqbzn120mpqnn27jfi4vjqf5ak48b444";
+       sha256 = "849085c854c561b94974f2086bf1ad4004fb17be7168b75068ab0f2a330bab59";
        libraryHaskellDepends = [
          asn1-encoding asn1-types attoparsec base base64-bytestring
          bytestring cereal crypto-pubkey-types pem
@@ -38267,7 +38381,7 @@ self: {
      mkDerivation {
        pname = "crypto-pubkey-types";
        version = "0.4.3";
-       sha256 = "0q0wlzjmpx536h1zcdzrpxjkvqw8abj8z0ci38138kpch4igbnby";
+       sha256 = "7ed9f52281ec4e34021a91818fe45288e33d65bff937f60334a3f45be5a71c60";
        libraryHaskellDepends = [ asn1-encoding asn1-types base ];
        homepage = "http://github.com/vincenthz/hs-crypto-pubkey-types";
        description = "Generic cryptography Public keys algorithm types";
@@ -38279,7 +38393,7 @@ self: {
      mkDerivation {
        pname = "crypto-random";
        version = "0.0.9";
-       sha256 = "0139kbbb2h7vshf68y3fvjda29lhj7jjwl4vq78w4y8k8hc7l2hp";
+       sha256 = "170a7a18441379c2d1c19b502ee5919026a19adc6e78641cd4fb40b1d69a6904";
        libraryHaskellDepends = [ base bytestring securemem unix vector ];
        homepage = "http://github.com/vincenthz/hs-crypto-random";
        description = "Simple cryptographic random related types";
@@ -38291,7 +38405,7 @@ self: {
      mkDerivation {
        pname = "crypto-random-api";
        version = "0.2.0";
-       sha256 = "0z49kwgjj7rz235642q64hbkgp0zl6ipn29xd19yb75xc5q7gsan";
+       sha256 = "56e9777061bd9ce553683d097ba3a11fdc371724060b62ca103f1f291f9f897c";
        libraryHaskellDepends = [ base bytestring entropy ];
        homepage = "http://github.com/vincenthz/hs-crypto-random-api";
        description = "Simple random generators API for cryptography related code";
@@ -38305,7 +38419,7 @@ self: {
      mkDerivation {
        pname = "crypto-random-effect";
        version = "0.2.0.4.1";
-       sha256 = "1gj40r6i79jvsghyv4nqm3yrjlby9fkxxhzp0lkr5j1b9b3b2xwr";
+       sha256 = "9977b1c64a2bc8922705f7c3dea74b7e5199fda8d892ede1d35ba6134d0644be";
        revision = "1";
        editedCabalFile = "f217573816b1efe3fcc9b1dcbd6325015bc9a87872200547f56a80ec2b959c31";
        libraryHaskellDepends = [
@@ -38325,7 +38439,7 @@ self: {
      mkDerivation {
        pname = "crypto-totp";
        version = "0.1.0.1";
-       sha256 = "0vkjkyaxp0rb4n2p7gdbbswm32gvbsbqnb6xs9hh4rncfaghpqds";
+       sha256 = "bae10b9f72cc660261d2dd2c8b975efb8951b95eabbd7385252b83db959f726e";
        libraryHaskellDepends = [
          base bytestring cereal containers cryptohash tagged unix
        ];
@@ -38340,7 +38454,7 @@ self: {
      mkDerivation {
        pname = "cryptocipher";
        version = "0.6.2";
-       sha256 = "0ip3a2as0df6drl29sryayxx22sx55v6bs60s2fh3i1nxqnydf9l";
+       sha256 = "34b9e62dee36c4019dd0c0e86576295d0bd1bb573eeb24686ec635a09550e346";
        libraryHaskellDepends = [
          base cipher-aes cipher-blowfish cipher-camellia cipher-des
          cipher-rc4 crypto-cipher-types
@@ -38357,7 +38471,7 @@ self: {
      mkDerivation {
        pname = "cryptohash";
        version = "0.11.6";
-       sha256 = "0dyzcaxr8vhzqq9hj4240rxpi87h4ps87yz09klz723shls26f6s";
+       sha256 = "da382334857a88f3e94ce0fb83f425f0a0787b0644100913c61f6e94bb62df37";
        libraryHaskellDepends = [ base byteable bytestring ghc-prim ];
        testHaskellDepends = [
          base byteable bytestring HUnit QuickCheck tasty tasty-hunit
@@ -38375,7 +38489,7 @@ self: {
      mkDerivation {
        pname = "cryptohash-conduit";
        version = "0.1.1";
-       sha256 = "1kmlskgb0jx8hkzdncr24aqir9k1kyfcb2rypvkdld1yin4nslga";
+       sha256 = "ea516d898d3e34dae6be3e8bc59c9f61a61cb1222233dbfe84a84bb0ded4b4ce";
        libraryHaskellDepends = [
          base bytestring conduit conduit-extra cryptohash resourcet
          transformers
@@ -38392,7 +38506,7 @@ self: {
      mkDerivation {
        pname = "cryptohash-cryptoapi";
        version = "0.1.3";
-       sha256 = "0wj53p32js8lfg0i8akrljpash0jdiyv2vcqpmjbd4dq2fx81w2n";
+       sha256 = "56f080ba13b891b664bd986db17d6c1240adaea4792a14c173146929c61d4572";
        libraryHaskellDepends = [
          base bytestring cereal crypto-api cryptohash tagged
        ];
@@ -38411,7 +38525,7 @@ self: {
      mkDerivation {
        pname = "cryptol";
        version = "2.2.4";
-       sha256 = "07aai72kg66skdnbydy25a07124znvrixbw91gk4n9430gsvv26z";
+       sha256 = "df88bdf50383244be60b89af1ef3b69f8870802ac237bf6c9bda9837c5894a1d";
        isLibrary = true;
        isExecutable = true;
        libraryHaskellDepends = [
@@ -38438,7 +38552,7 @@ self: {
      mkDerivation {
        pname = "cryptonite";
        version = "0.6";
-       sha256 = "0lzqmhslq1pwj6pp82l3vdnnxbqvh0bqjyl02x2yp6sp72mcq5m0";
+       sha256 = "a016ccaa38579beb4517807a8917801baf6e6ddb830a74af91fc064c35acf853";
        libraryHaskellDepends = [
          base bytestring deepseq ghc-prim integer-gmp memory
        ];
@@ -38460,7 +38574,7 @@ self: {
      mkDerivation {
        pname = "cryptsy-api";
        version = "0.2.1";
-       sha256 = "1knnzh77y4rr7ka2nfwr99z61v2pvx2p1mzji06ac0mjk2n80ybs";
+       sha256 = "7a7980ac98b202a60c88f2d77045df57ec607e4a993b2bd43c39137f0efcd6ce";
        libraryHaskellDepends = [
          aeson base bytestring deepseq either http-client http-client-tls
          old-locale pipes-attoparsec pipes-http text time transformers
@@ -38477,7 +38591,7 @@ self: {
      mkDerivation {
        pname = "crystalfontz";
        version = "0.1";
-       sha256 = "14mh098kgckncips17bdsbg08q78xk1114174zq860z4znmc1gxv";
+       sha256 = "bbbfc0aafde40383f027279010c2ece86004ded26d9da06f6476b2375102b092";
        libraryHaskellDepends = [ base crc16-table MaybeT serialport ];
        description = "Control Crystalfontz LCD displays";
        license = stdenv.lib.licenses.bsd3;
@@ -38489,7 +38603,7 @@ self: {
      mkDerivation {
        pname = "cse-ghc-plugin";
        version = "0.1.1";
-       sha256 = "123x10ircbj8lrsqapf6cb9b3ibjgp1q8l862a3i6i0ak7ash49f";
+       sha256 = "2e11a8d5990a44138712065184c37d72c5b1d262c65d8575a6482e9623087d88";
        libraryHaskellDepends = [ base ghc ];
        homepage = "http://thoughtpolice.github.com/cse-ghc-plugin";
        description = "Compiler plugin for common subexpression elimination";
@@ -38502,7 +38616,7 @@ self: {
      mkDerivation {
        pname = "csound-catalog";
        version = "0.2.2";
-       sha256 = "0rrd0gk6z16ydpn90i4siy3p7d1qxb14q022r3mqmj792c1v6z5p";
+       sha256 = "b77cb30313e9c88aebc842004cc2ea38b473878f9a4490ec6dde846fe6032d67";
        libraryHaskellDepends = [ base csound-expression transformers ];
        homepage = "https://github.com/anton-k/csound-catalog";
        description = "a gallery of Csound instruments";
@@ -38518,7 +38632,7 @@ self: {
      mkDerivation {
        pname = "csound-expression";
        version = "4.8.2";
-       sha256 = "1zhx4smvs8xnqfcv2hxhq57n16cl3sycz659viw8l6v8f36ibj5i";
+       sha256 = "b1c815cd70681b8a78dca998cfbc1e9499604fc1b043b199c3b623bdab261dfe";
        libraryHaskellDepends = [
          base Boolean colour csound-expression-dynamic
          csound-expression-opcodes csound-expression-typed data-default
@@ -38537,7 +38651,7 @@ self: {
      mkDerivation {
        pname = "csound-expression-dynamic";
        version = "0.1.4.3";
-       sha256 = "1rzfah8d7j7s45w6zvrs5sabplcapx6njaimkmvfj9dby2brxprw";
+       sha256 = "3cdf9e97f0ab25e9769d352a694dbf8ad1bb942e3aef6f7821fac8d31054eee7";
        libraryHaskellDepends = [
          array base Boolean containers data-default data-fix data-fix-cse
          transformers wl-pprint
@@ -38554,7 +38668,7 @@ self: {
      mkDerivation {
        pname = "csound-expression-opcodes";
        version = "0.0.3";
-       sha256 = "0f7nwrnrpsi31q9vaxy2yihripzqjzp6683qy94ljkmxmfnm9sb5";
+       sha256 = "65e954adabbd4e4949f2782063ee97f8df9861f4c277b5130e23ea9b6de6f638";
        libraryHaskellDepends = [
          base csound-expression-dynamic csound-expression-typed transformers
        ];
@@ -38571,7 +38685,7 @@ self: {
      mkDerivation {
        pname = "csound-expression-typed";
        version = "0.0.7.7";
-       sha256 = "1z9hvkgl6lqwrdhngq79425s2frhkg4llkcpsar21d5ld4fhzfdl";
+       sha256 = "b4b90f1d69b4b420b2d2974d4ac99b303ba18b20e9e06761cb1c5343dfdc30fd";
        libraryHaskellDepends = [
          base Boolean colour containers csound-expression-dynamic
          data-default deepseq ghc-prim stable-maps temporal-media
@@ -38588,7 +38702,7 @@ self: {
      mkDerivation {
        pname = "csound-sampler";
        version = "0.0.6.2";
-       sha256 = "0qgz3k6cw5hzp5la051xnmg3697p7yfdamn8r6mp7ca4fai311h0";
+       sha256 = "008630a27244b173abc9c856d59c3ff724335eb53d14a068b91f16cecc1cff61";
        libraryHaskellDepends = [ base csound-expression transformers ];
        homepage = "https://github.com/anton-k/csound-sampler";
        description = "A musical sampler based on Csound";
@@ -38601,7 +38715,7 @@ self: {
      mkDerivation {
        pname = "csp";
        version = "1.0";
-       sha256 = "0skz2yx8armbr0x7vhixxkbm7qbspg38723x98k6kysz7n5nzw2c";
+       sha256 = "4cf06f8b3d5ffb69264a7d8883c6bb7ae153d7ec3dc27d3ac8ab6685ba177f6a";
        libraryHaskellDepends = [ base containers mtl nondeterminism ];
        description = "Discrete constraint satisfaction problem (CSP) solvers";
        license = "LGPL";
@@ -38614,7 +38728,7 @@ self: {
      mkDerivation {
        pname = "cspmchecker";
        version = "1.0.0";
-       sha256 = "1yz94yvggw6a7fh2p7fszyp02nnk7labbl6z079gqn3smayzfs31";
+       sha256 = "6168f7bdaa7a58fcd201dfd0b5143dd35a01aeffda9d2ba03bcaf0f7b627e9fb";
        isLibrary = false;
        isExecutable = true;
        executableHaskellDepends = [
@@ -38631,19 +38745,37 @@ self: {
      mkDerivation {
        pname = "css";
        version = "0.2";
-       sha256 = "150gdsf059x658z6cbclrydzbynw06nhrpf4i1l9gwb6siarvjv9";
+       sha256 = "69cb9d55d466f1976888c4dd0cad01dcfaf59bcf942d663e2aa6a7029c6e0f94";
        libraryHaskellDepends = [ base mtl text ];
        description = "Minimal monadic CSS DSL";
        license = stdenv.lib.licenses.bsd3;
        hydraPlatforms = stdenv.lib.platforms.none;
      }) {};
 
+  "css-syntax" = callPackage
+    ({ mkDerivation, attoparsec, base, bytestring, directory, hspec
+     , scientific, text
+     }:
+     mkDerivation {
+       pname = "css-syntax";
+       version = "0.0.2";
+       sha256 = "9ee149c46c3f76d46943bf7b374be79535aaec393b3a5dc2f176636c76382115";
+       libraryHaskellDepends = [
+         attoparsec base bytestring scientific text
+       ];
+       testHaskellDepends = [
+         attoparsec base bytestring directory hspec scientific text
+       ];
+       description = "This package implments a parser for the CSS syntax";
+       license = stdenv.lib.licenses.mit;
+     }) {};
+
   "css-text" = callPackage
     ({ mkDerivation, attoparsec, base, hspec, QuickCheck, text }:
      mkDerivation {
        pname = "css-text";
        version = "0.1.2.1";
-       sha256 = "1xi1n2f0g8y43p95lynhcg50wxbq7hqfzbfzm7fy8mn7gvd920nw";
+       sha256 = "dc0291da7ec756e4dda9dfadef303c78750eca63d07a5ad21dc4a3079cb021f6";
        libraryHaskellDepends = [ attoparsec base text ];
        testHaskellDepends = [ attoparsec base hspec QuickCheck text ];
        homepage = "http://www.yesodweb.com/";
@@ -38656,7 +38788,7 @@ self: {
      mkDerivation {
        pname = "csv";
        version = "0.1.2";
-       sha256 = "00767ai09wm7f0yzmpqck3cpgxncpr9djnmmz5l17ajz69139x4c";
+       sha256 = "8cf43442325faa1368f9b55ad952beccf677d9980cdffa3d70a7f204a23ae600";
        libraryHaskellDepends = [ base filepath parsec ];
        description = "CSV loader and dumper";
        license = stdenv.lib.licenses.mit;
@@ -38672,7 +38804,7 @@ self: {
      mkDerivation {
        pname = "csv-conduit";
        version = "0.6.6";
-       sha256 = "12sxxv92qblsa63zdnl80a8yk01b4cvk9k6h58w82bvcy5m0aabk";
+       sha256 = "7329056af16c2f81382ad0cc3437232b80e9910288daf687519a2e2cd2ee5d8b";
        isLibrary = true;
        isExecutable = true;
        libraryHaskellDepends = [
@@ -38702,7 +38834,7 @@ self: {
      mkDerivation {
        pname = "csv-enumerator";
        version = "0.10.2.0";
-       sha256 = "0n1zc9rwzj9w39nmjfn65qawj19b6zay3d62ss2crnxbgqnh07gh";
+       sha256 = "f01d002d7eabdbcc84d6c2b4e1d5372b05c9152ec63a596d1a3cc9cf73623f58";
        libraryHaskellDepends = [
          attoparsec attoparsec-enumerator base bytestring containers
          directory enumerator safe transformers unix-compat
@@ -38719,7 +38851,7 @@ self: {
      mkDerivation {
        pname = "csv-nptools";
        version = "0.4.1";
-       sha256 = "0898553pikxjgmycdyiw92bbmzxgbl4dl8029qljyjzlzlasj7by";
+       sha256 = "7e1da915fdf44b2f294e0220da085dafffba96483cfac67c7db2cf7847292821";
        isLibrary = false;
        isExecutable = true;
        executableHaskellDepends = [
@@ -38736,7 +38868,7 @@ self: {
      mkDerivation {
        pname = "csv-to-qif";
        version = "0.3.2";
-       sha256 = "1mfy19fvi92zzzqn70ga2p5csmc8qm0qnkn3vyl41ic6f69vm73x";
+       sha256 = "7d9cba937186c540a8dfc34e8b41c58855cdca15ea8163f1ff5fa4b85d0aded5";
        isLibrary = false;
        isExecutable = true;
        executableHaskellDepends = [
@@ -38753,7 +38885,7 @@ self: {
      mkDerivation {
        pname = "ctemplate";
        version = "0.1";
-       sha256 = "02xsw0zpg728cq018w6zjgbzk6d7px62mapn40gir9c0hi6rqlx8";
+       sha256 = "a8539c4d8480a51c1f20f6aa2a4cbfa799f9d793df70140066489c773fe0ba0b";
        libraryHaskellDepends = [ base bytestring ];
        librarySystemDepends = [ ctemplate ];
        homepage = "http://darcs.imperialviolet.org/ctemplate";
@@ -38767,7 +38899,7 @@ self: {
      mkDerivation {
        pname = "ctkl";
        version = "0.27.0.0";
-       sha256 = "0sqrg04zlwq62jggjvrd1dq7a2alwx2190w6b19d3jn51n0s907m";
+       sha256 = "f580a4810dc5cad1525886831444e7540975700b2d6ff99e140673fa0978196b";
        libraryHaskellDepends = [ array base ];
        jailbreak = true;
        description = "packaging of Manuel Chakravarty's CTK Light for Hackage";
@@ -38780,7 +38912,7 @@ self: {
      mkDerivation {
        pname = "ctpl";
        version = "0.1.0.1";
-       sha256 = "1mbqgbig5n8rrkxmrdbcl8qafa2r58c2pial2b67yr6cw08v0srv";
+       sha256 = "3b6bb011e0cc647fcc1254c52b182a5928a730a26cb55cfbcc19d9f2e27a78d5";
        libraryHaskellDepends = [ base chatty-text chatty-utils ];
        jailbreak = true;
        description = "A programming language for text modification";
@@ -38795,7 +38927,7 @@ self: {
      mkDerivation {
        pname = "ctrie";
        version = "0.1.0.2";
-       sha256 = "11ylwjmp015ppisczggzj1x7mfg1bfg4g4qg0s91xrrgms78r014";
+       sha256 = "24808c8eae2fe71e92060f93479e5be1b97a7a90ffbdcf74bcb70470abe4d487";
        libraryHaskellDepends = [ atomic-primops base hashable primitive ];
        testHaskellDepends = [
          base containers hashable QuickCheck test-framework
@@ -38813,7 +38945,7 @@ self: {
      mkDerivation {
        pname = "cube";
        version = "0.2.0";
-       sha256 = "0shclcwnh1az40ckvmhpw93xbhrr19wfhhvclcnv2fijy29667yp";
+       sha256 = "d71f6392f0323ab12da36c43e8780a39c3d547e217d63d19205f056839a30c6a";
        isLibrary = true;
        isExecutable = true;
        libraryHaskellDepends = [ base bytestring cereal containers STL ];
@@ -38834,7 +38966,7 @@ self: {
      mkDerivation {
        pname = "cubical";
        version = "0.2.0";
-       sha256 = "1n44d39s3r5iakbhjf99w49gb1y8l1xl46lz40jkhx7k4knwb1fj";
+       sha256 = "d285c5ed24f3743825209f1a427ba0c887f512e1293909d754b1e4a1d36884d8";
        isLibrary = false;
        isExecutable = true;
        executableHaskellDepends = [
@@ -38853,7 +38985,7 @@ self: {
      mkDerivation {
        pname = "cubicbezier";
        version = "0.3.0";
-       sha256 = "1d5mr1xr1y7qnb65ybf6gncndzdz63di3gxrzwykks706ry475sr";
+       sha256 = "5997437c36e0e8393dffb9bf11db30bffd66997dc62d5fccb2f8f8907bc8b5b4";
        libraryHaskellDepends = [ base containers integration ];
        testHaskellDepends = [ base parsec tasty tasty-hunit ];
        description = "Efficient manipulating of 2D cubic bezier curves";
@@ -38865,7 +38997,7 @@ self: {
      mkDerivation {
        pname = "cubicspline";
        version = "0.1.1";
-       sha256 = "0n4c80vjf8sh5wf1n0qp9z8v8z7mj7rfygjg5a02sz0s6l7q1i8s";
+       sha256 = "1ac5800f351a7c2d802a4f3eeff291f57cb4d14f17031b1c2f50232737408c58";
        libraryHaskellDepends = [ base hmatrix safe ];
        description = "Natural cubic spline interpolation";
        license = stdenv.lib.licenses.bsd3;
@@ -38878,7 +39010,7 @@ self: {
      mkDerivation {
        pname = "cublas";
        version = "0.2.1.0";
-       sha256 = "02x8a9varkj770cl4nnb0mf4qh519gf9mv51awinlaikyz932q1w";
+       sha256 = "3c6031d2f7332a6a2357a1ec9adc4ba1404c5c05cb5a42193847ceac7652a80b";
        libraryHaskellDepends = [
          base cuda filepath language-c storable-complex template-haskell
        ];
@@ -38895,7 +39027,7 @@ self: {
      mkDerivation {
        pname = "cuboid";
        version = "0.14.2";
-       sha256 = "08l8qf98d5p9d5qyj3kh35rzp8fih77bd2pras4dkn7an39pmr6b";
+       sha256 = "cbe47ad3b0ead8d98856f98ab6ce81d1a1fb7319700ee97169e9968692c38822";
        isLibrary = false;
        isExecutable = true;
        executableHaskellDepends = [ base GLUT Yampa ];
@@ -38908,7 +39040,7 @@ self: {
      mkDerivation {
        pname = "cuda";
        version = "0.6.6.2";
-       sha256 = "10c2nn0qhhznajpkjvmxivz3w6zr96fpsych53hnvpi2g6a332k1";
+       sha256 = "618a31947922de6de12890797d9d49f91b3efe8ebd6e39af54f6438881b58281";
        isLibrary = true;
        isExecutable = true;
        libraryHaskellDepends = [ base bytestring ];
@@ -38926,7 +39058,7 @@ self: {
      mkDerivation {
        pname = "cudd";
        version = "0.1.0.2";
-       sha256 = "0zhsj4qrvk1q1rj55nsysznv11m1x31dg7gxmgp5wdsk8l18w02r";
+       sha256 = "59008e024553375eeeabfd9dd7c2e8a186b0edd75edb52640e38cc9d31911a7e";
        libraryHaskellDepends = [ array base mtl transformers ];
        librarySystemDepends = [ cudd dddmp epd mtr st util ];
        libraryToolDepends = [ c2hs ];
@@ -38942,7 +39074,7 @@ self: {
      mkDerivation {
        pname = "cufft";
        version = "0.1.2.1";
-       sha256 = "1qkrp2dwfpivf5j42a7wij61010a3rmldxng4j8ivkrc7vllv76j";
+       sha256 = "d29c4de93e2ccf1d9124cff6466b1e0a04108c8cfc284164713b5ec79bb879e2";
        libraryHaskellDepends = [ base cuda ];
        libraryToolDepends = [ c2hs ];
        homepage = "http://github.com/robeverest/cufft";
@@ -38955,7 +39087,7 @@ self: {
      mkDerivation {
        pname = "curl";
        version = "1.3.8";
-       sha256 = "0vj4hpaa30jz7c702xpsfvqaqdxz28zslsqnsfx6bf6dpwvck1wh";
+       sha256 = "9087c936bfcdb865bad3166baa3f12bf37acf076fa76010e3b5f82a1d485446e";
        libraryHaskellDepends = [ base bytestring containers ];
        librarySystemDepends = [ curl ];
        description = "Haskell binding to libcurl";
@@ -38967,7 +39099,7 @@ self: {
      mkDerivation {
        pname = "curl-aeson";
        version = "0.0.4";
-       sha256 = "1fpi448f6bgf3rbw3zxf7r9nwyhv9q67zan5sixnad1y7lqxivrx";
+       sha256 = "3defd8313d3e34657bd4c5aa7f0c4e1b7a6e533eaeffc1571eee2de31021f1ba";
        libraryHaskellDepends = [ aeson base curl text utf8-string ];
        homepage = "https://github.com/zouppen/haskell-curl-aeson";
        description = "Communicate with HTTP service using JSON";
@@ -38979,7 +39111,7 @@ self: {
      mkDerivation {
        pname = "curlhs";
        version = "0.1.6";
-       sha256 = "1yh7rfk9ppglpjymzzi2yc44g9bp0irnl2yvj77y55djdkmckq3b";
+       sha256 = "6be0c9ea6cb295e2cf91db0b6a730477a54708f322fe5fbdbcf4dd9ba6cb07fa";
        revision = "1";
        editedCabalFile = "ac8dbe0348ce66746774f019fe62dbdaf40a200bed62f5b7fb0ecb9bd11cfa1c";
        libraryHaskellDepends = [ base bytestring rtld time ];
@@ -38995,7 +39127,7 @@ self: {
      mkDerivation {
        pname = "currency";
        version = "0.2.0.0";
-       sha256 = "0yj1x7zmkmwr9az55i9gvf84m7i3b4qi80p8qk9hszzlv7rigmdw";
+       sha256 = "bcd517f3d9f47f0dd3c4e802143159239e4a90db2fc552be4a99d759ffe9417a";
        libraryHaskellDepends = [
          base containers hashable iso3166-country-codes
        ];
@@ -39009,7 +39141,7 @@ self: {
      mkDerivation {
        pname = "current-locale";
        version = "0.2.0.1";
-       sha256 = "18lg46fzpz207bd60hbcas6ippw0wnsc8n93pnz775ks5y7apyr5";
+       sha256 = "25fbab8e2f7a9673bebd2359c4b4e580df1b8d566c4160da3a40fcfb9d218fa2";
        libraryHaskellDepends = [ base old-locale process split ];
        homepage = "https://github.com/koterpillar/current-locale";
        description = "Get the current system locale in System.Locale format";
@@ -39023,7 +39155,7 @@ self: {
      mkDerivation {
        pname = "curry-base";
        version = "0.2.9";
-       sha256 = "0sdwygsbqmvcbzi7zsr0jd02s2r19pc7zsk4b6hjxv4vzjc9f120";
+       sha256 = "40049798fc9bec2ea15964ea7fd84d210b2d409320eb7fe25f6c57bcf4f3bc69";
        libraryHaskellDepends = [
          base containers directory filepath mtl old-time pretty syb
        ];
@@ -39040,7 +39172,7 @@ self: {
      mkDerivation {
        pname = "curry-frontend";
        version = "0.2.12";
-       sha256 = "1igys4i7wwj1ildkf4is66gq22zsjg158kv3ald5xiilwkmvfc4h";
+       sha256 = "9030b7ebe434c65e1a55634f54c293fa0b819f313a12371b8d41727e22d1fec5";
        isLibrary = true;
        isExecutable = true;
        libraryHaskellDepends = [ filepath ];
@@ -39060,7 +39192,7 @@ self: {
      mkDerivation {
        pname = "cursedcsv";
        version = "0.1.2";
-       sha256 = "045lfyhpwjgcdw3wxj2klq0aqn555f5r4w95fr06vsq5pxspnnvc";
+       sha256 = "6c5b7b75bf05eb6d40762571928b2ba558ac00a653c8ce076fec497ea177b410";
        isLibrary = false;
        isExecutable = true;
        executableHaskellDepends = [
@@ -39080,7 +39212,7 @@ self: {
      mkDerivation {
        pname = "curve25519";
        version = "0.2.1";
-       sha256 = "1kfs7cjxig0rk17nb7dzi189msww90yw0066rlalw01kff5w2hdy";
+       sha256 = "be41c18b7333004e15cdc600c03d489ceb9a5088bf9d654f9819bcd8253bdacd";
        libraryHaskellDepends = [ base bytestring crypto-api ];
        testHaskellDepends = [
          base bytestring crypto-api DRBG HUnit QuickCheck tagged
@@ -39099,7 +39231,7 @@ self: {
      mkDerivation {
        pname = "curves";
        version = "1.1.0.1";
-       sha256 = "0zmy9an40wnxjhqjhlvsg0jy4bqqby6hl8ckjcm0406988ma8mi6";
+       sha256 = "2656a42a42c900022a9393210a8d5f182fe225787a53283194dd7240ac4abe7e";
        libraryHaskellDepends = [
          base bytestring containers filepath HaXml JuicyPixels QuickCheck
        ];
@@ -39113,7 +39245,7 @@ self: {
      mkDerivation {
        pname = "custom-prelude";
        version = "0.2.2.0";
-       sha256 = "00lkpkl79kznib0s6xm644f3k13dv59x5z06ccymvx6l6iqxyzn6";
+       sha256 = "c67edf7134d4f45d3d6306fcd253d96d84391c21a676a3c18af6cf74e8bc9302";
        libraryHaskellDepends = [ base basic-prelude monad-loops ];
        jailbreak = true;
        homepage = "https://github.com/ajnsit/custom-prelude";
@@ -39126,8 +39258,8 @@ self: {
      }:
      mkDerivation {
        pname = "cv-combinators";
-       version = "0.1.3";
-       sha256 = "1lak96kr1fpsrqcvgv9k0igd5w2f42hv20f2mw8cvr0q0xwzc9zb";
+       version = "0.2.0.2";
+       sha256 = "fdb44fb8ed7ecadb8702eb6b610b45245dcfbac98ddd6cdb5122d4e9f0d98e7e";
        isLibrary = true;
        isExecutable = true;
        libraryHaskellDepends = [
@@ -39145,7 +39277,7 @@ self: {
      mkDerivation {
        pname = "cyclotomic";
        version = "0.4.3";
-       sha256 = "14rfyxmqjrlirszk2mrqm030rya6cbcydbf7fl7if82y21qrfg0p";
+       sha256 = "173c9771105e20170f75c7ade6d96246f90c06a8385731bfce9166896bf72e93";
        libraryHaskellDepends = [ arithmoi base containers ];
        jailbreak = true;
        description = "A subfield of the complex numbers for exact calculation";
@@ -39161,7 +39293,7 @@ self: {
      mkDerivation {
        pname = "cypher";
        version = "0.8.1";
-       sha256 = "0f79791j9nczm80cifpc4iq5pqkhca67s94c5wqm0kiprlxblc53";
+       sha256 = "a330ba3acd374e50312f8c247d8c6270e25b7024ecbac800aa9fd924433ae938";
        libraryHaskellDepends = [
          aeson attoparsec base bytestring classy-parallel conduit
          http-conduit http-types resourcet text transformers
@@ -39177,14 +39309,14 @@ self: {
     ({ mkDerivation, async, attoparsec, base, binary, blaze-builder
      , bytestring, conduit, conduit-extra, containers
      , data-binary-ieee754, data-default, exceptions, free, hslogger
-     , mtl, network, QuickCheck, singletons, stm, tasty
+     , mtl, network, QuickCheck, singletons, stm, tasty, tasty-hunit
      , tasty-quickcheck, tasty-th, template-haskell, text, transformers
      , xml-conduit, xml-hamlet, xml-picklers, xml-types
      }:
      mkDerivation {
        pname = "d-bus";
-       version = "0.1.2";
-       sha256 = "176brypscws03sswda215ywc6l5hj6l5iw4vkfrcppzycdyh3yd2";
+       version = "0.1.3";
+       sha256 = "0e1eb50a1a1185bc898e87f93040f47b80d8a0beb132fb2c14a77b6720011f32";
        libraryHaskellDepends = [
          async attoparsec base binary blaze-builder bytestring conduit
          conduit-extra containers data-binary-ieee754 data-default
@@ -39193,7 +39325,7 @@ self: {
          xml-types
        ];
        testHaskellDepends = [
-         base binary bytestring mtl QuickCheck singletons tasty
+         base binary bytestring mtl QuickCheck singletons tasty tasty-hunit
          tasty-quickcheck tasty-th text xml-hamlet
        ];
        description = "Permissively licensed D-Bus client library";
@@ -39206,7 +39338,7 @@ self: {
      mkDerivation {
        pname = "d3js";
        version = "0.1.0.0";
-       sha256 = "0wrxvfgss9fiv1pwsdi1md0plc4mf9sadkhgm46dsfq16dwrp3q2";
+       sha256 = "028f9b7933013bdd0ca90fcea6747295307a41ab2136cd6fd8d125ad9fdb3d73";
        libraryHaskellDepends = [ base mtl random text ];
        jailbreak = true;
        homepage = "https://github.com/nebuta/d3js-haskell";
@@ -39219,7 +39351,7 @@ self: {
      mkDerivation {
        pname = "daemonize-doublefork";
        version = "0.1.1";
-       sha256 = "1g446qxff8ajv44341y0f9v39j8idmnn23lwi08gq3ps4qrz0py2";
+       sha256 = "c25ff03326fa0efc10889c0e616d6d11c9347672c0073208d95221e73a3684bc";
        libraryHaskellDepends = [ base directory unix ];
        homepage = "https://github.com/scvalex/daemonize-doublefork";
        description = "Start background daemons by double-forking";
@@ -39234,7 +39366,7 @@ self: {
      mkDerivation {
        pname = "daemons";
        version = "0.2.1";
-       sha256 = "0zf9831vl1hz606nsp0yhjg46wxzvwkd3hn9shjw5akk26sddi8p";
+       sha256 = "17c5d6b41173aac225d4c9c2d126dfbf73439e841e5c6d0d301f06bac340c97d";
        isLibrary = true;
        isExecutable = true;
        libraryHaskellDepends = [
@@ -39261,7 +39393,7 @@ self: {
      mkDerivation {
        pname = "dag";
        version = "0.1.0.2";
-       sha256 = "0khfyyzqzw7jj4n8p1k96wdrb2087jd380fzhlkmf0g7s4346pvp";
+       sha256 = "775f4306d1e701572785df01349a3c0888951b3769868b2c91f2f08fbff70e4e";
        libraryHaskellDepends = [ base constraints singletons ];
        testHaskellDepends = [
          base hspec QuickCheck quickcheck-instances
@@ -39278,7 +39410,7 @@ self: {
      mkDerivation {
        pname = "damnpacket";
        version = "0.6.0";
-       sha256 = "137ckcsy2a9f8xfw83rapl2msb6z0pdlsksay5qkymxcpfwrabyb";
+       sha256 = "cb2f95b9bbac573f71f14a4f4ddb05df2c5d05bd2a0fc45d472e29e1359bec8c";
        libraryHaskellDepends = [
          attoparsec base bytestring containers deepseq text
        ];
@@ -39297,7 +39429,7 @@ self: {
      mkDerivation {
        pname = "dao";
        version = "0.1.0.1";
-       sha256 = "0caas3ql32925rzsghb7rdrm17bw3hn84cizkl9dqmz6nwlhclk9";
+       sha256 = "69520629b7e657dc129d3f32822c1c7c9d5073cb67c1a77f2e228941f1d04a31";
        isLibrary = true;
        isExecutable = true;
        libraryHaskellDepends = [
@@ -39327,7 +39459,7 @@ self: {
      mkDerivation {
        pname = "dapi";
        version = "0.2.0.0";
-       sha256 = "0idi472qqks286fbw718vddk5kc3vxicrb8m38sllw6x663xnljz";
+       sha256 = "5f52db8731dd704a351a15adcc62df83cd325bdb281cbe9c41424f8cc521b145";
        isLibrary = false;
        isExecutable = true;
        executableHaskellDepends = [
@@ -39355,7 +39487,7 @@ self: {
      mkDerivation {
        pname = "darcs";
        version = "2.10.1";
-       sha256 = "157faxxzziaj79ln1qqvrii1vnafyknfbnmgl4y5krw06ys6bvzi";
+       sha256 = "f1ef65b43780e7593ca1afdae5ecf44ed91d62cc1be360693a52c5ff7b57ee94";
        configureFlags = [ "-fforce-char8-encoding" "-flibrary" ];
        isLibrary = true;
        isExecutable = true;
@@ -39394,7 +39526,7 @@ self: {
      mkDerivation {
        pname = "darcs-benchmark";
        version = "0.1.9";
-       sha256 = "1qwh4yas6alp65lwimh8xlz3i572nxn4iwqsppx7qqlj8kjhbyvj";
+       sha256 = "72fb05e54492627cfabd1af3486cb7e294383eed08d6c86931972aa3952790e3";
        isLibrary = false;
        isExecutable = true;
        executableHaskellDepends = [
@@ -39420,7 +39552,7 @@ self: {
      mkDerivation {
        pname = "darcs-beta";
        version = "2.7.99.2";
-       sha256 = "0jkgy8k2i7hhcl7dzm4zvbm0q189hhp4cza9aslslzcq15jsa225";
+       sha256 = "4508a56509987daaa956497d462e8409050ceada9fd4df0e65109e2826f26f4a";
        isLibrary = true;
        isExecutable = true;
        libraryHaskellDepends = [
@@ -39451,7 +39583,7 @@ self: {
      mkDerivation {
        pname = "darcs-buildpackage";
        version = "0.5.12";
-       sha256 = "0c82r7bgz8wj172q1n4dfz9kfn4466v7k159vlkfdqv7as0qj8qf";
+       sha256 = "0e2389815667e3e626dda98479b631845837d3778dd880c50992a3ffd6c90231";
        isLibrary = false;
        isExecutable = true;
        executableHaskellDepends = [
@@ -39471,7 +39603,7 @@ self: {
      mkDerivation {
        pname = "darcs-cabalized";
        version = "2.0.2.2";
-       sha256 = "1lc1v30zmlcrp6i22d3arghqhy9pjncddr34df6zd8s0r9wsi61d";
+       sha256 = "2d98a879ca40a3f68d6b64e4d69895377988e1cb6a3421a2b999d1fac1d881d1";
        isLibrary = false;
        isExecutable = true;
        executableHaskellDepends = [
@@ -39494,7 +39626,7 @@ self: {
      mkDerivation {
        pname = "darcs-fastconvert";
        version = "0.2.1";
-       sha256 = "1a49v3l9n5cqlmdpjj8mzz5v6b47my84id62ag7004ynr11vih9s";
+       sha256 = "3ac1b843c8d61300ce53c2b44890af872cb3cbff1549795ba598159be8d889a8";
        isLibrary = false;
        isExecutable = true;
        executableHaskellDepends = [
@@ -39513,7 +39645,7 @@ self: {
      mkDerivation {
        pname = "darcs-graph";
        version = "1.0";
-       sha256 = "01404plnjrds57lf7widss2piwpal9khl0gq22xkswj68zzfjcv6";
+       sha256 = "6633e9fe4746723dbb10f8010a67a2eaf27885d62df2e3e829ba6569e9258004";
        isLibrary = false;
        isExecutable = true;
        executableHaskellDepends = [
@@ -39532,7 +39664,7 @@ self: {
      mkDerivation {
        pname = "darcs-monitor";
        version = "0.4.2";
-       sha256 = "0rp6flaizbaxzr28fr82vaacl4wajh6zdqnwcbgyhwz5dj7rdanq";
+       sha256 = "d8aa968f6ce573e8df62dce2f60d948a13ca94da02658744fe5dad1f1575e666";
        isLibrary = false;
        isExecutable = true;
        executableHaskellDepends = [
@@ -39550,7 +39682,7 @@ self: {
      mkDerivation {
        pname = "darcs-scripts";
        version = "0.1.1";
-       sha256 = "06gs18s89nc5qyicfpkj0hz999l5pf4glhlanm2yhyd6lxbfgkba";
+       sha256 = "6acde756a7a679e845b58a42fa88bb85a6943e04725ec7a2c785d984340afa19";
        libraryHaskellDepends = [ base ];
        description = "Shell scripts for support of darcs workflow";
        license = stdenv.lib.licenses.bsd3;
@@ -39564,7 +39696,7 @@ self: {
      mkDerivation {
        pname = "darcs2dot";
        version = "0.1.0.1";
-       sha256 = "0r6hri2kpfq7r0c25qrlrj5y9pi2j76njvwsgrpnpm6p4gg151wk";
+       sha256 = "938712de23d7d46b6f7e9a6f69cd9122dee48bcc34e32218c807bb3b45ccd064";
        isLibrary = false;
        isExecutable = true;
        executableHaskellDepends = [
@@ -39588,7 +39720,7 @@ self: {
      mkDerivation {
        pname = "darcsden";
        version = "1.1.1";
-       sha256 = "1dz87a6a6bmi2sfk0q21syipgnhpg9fdlr86m7sdrlk4s9s1s0c5";
+       sha256 = "85011d74d264d2dcf4a90665da5c7a17da77a3d74160309d16b12ea38c3ae8b7";
        isLibrary = false;
        isExecutable = true;
        executableHaskellDepends = [
@@ -39615,7 +39747,7 @@ self: {
      mkDerivation {
        pname = "darcswatch";
        version = "0.4.4";
-       sha256 = "1gl0wplzlhb6ynacq7bv38ijhazpwr642zc0a2dixbpibchgxksf";
+       sha256 = "4ecffe205bf1ae1e9b50807d414ce6f72b28231a7b1dcc94f56641fae9e580be";
        isLibrary = false;
        isExecutable = true;
        executableHaskellDepends = [
@@ -39637,7 +39769,7 @@ self: {
      mkDerivation {
        pname = "darkplaces-demo";
        version = "0.1";
-       sha256 = "0map78fnnqm2nlh92xrxmg3fs9q2hb4pl87hyara41v2dvwlsj3f";
+       sha256 = "6e484df96e6207a2b2f2f0207ac9820227edc6ab3d779120b5a2626b1d3a5755";
        revision = "1";
        editedCabalFile = "d16b0f7e29060476084a0457d38e524e1965b05e591af570197f287d574a8d01";
        isLibrary = true;
@@ -39663,7 +39795,7 @@ self: {
      mkDerivation {
        pname = "darkplaces-rcon";
        version = "0.1";
-       sha256 = "0ngxjb6zja7l905ixkr0cjyan21m311wc5dqdzacw5j5w7119v75";
+       sha256 = "e5ec14c2e14516ced46fb815c643183508abbc6420cf1e0b48f428f9cd92fd59";
        libraryHaskellDepends = [
          base byteable bytestring cryptohash network time
        ];
@@ -39683,7 +39815,7 @@ self: {
      mkDerivation {
        pname = "darkplaces-rcon-util";
        version = "0.1.1";
-       sha256 = "1xv9906ag2vgkzbk66f9r6lr5j6qwlwss246hjl7iriq315dmqlg";
+       sha256 = "8fe2da4a1838e678a8848608ad39e5d8c892a9c9c91933d79f6f8ba70c4869f7";
        isLibrary = true;
        isExecutable = true;
        libraryHaskellDepends = [
@@ -39712,7 +39844,7 @@ self: {
      mkDerivation {
        pname = "darkplaces-text";
        version = "0.2.1";
-       sha256 = "12nsr005pk0v1nril61javh6nrjhqcvlif11mfhch8bvvcaiy4rm";
+       sha256 = "35131f15db7b21c8a0ab21b84837c350666be05632181ab30d1bcc5b00c8da8a";
        libraryHaskellDepends = [
          ansi-terminal array base bytestring text utf8-string vector
        ];
@@ -39731,7 +39863,7 @@ self: {
      mkDerivation {
        pname = "dash-haskell";
        version = "1.1.0.2";
-       sha256 = "1h22ay2cl5j2ngm2xi2hyvvprnmz48qcpzxiq9ldkzx8gg3gs36j";
+       sha256 = "d20cfdc67ba8ffd968c2b1ffcb3022bfda7cf7f650c42eeab34216ca845742c0";
        isLibrary = false;
        isExecutable = true;
        executableHaskellDepends = [
@@ -39749,7 +39881,7 @@ self: {
      mkDerivation {
        pname = "data-accessor";
        version = "0.2.2.6";
-       sha256 = "0668qgllmp2911ppsb0g9z95nq2x0h2cvzyyjlb6iwhnjzyyg7gf";
+       sha256 = "ee9de7fd9716f2681695deffcd04045d605bd24f0f2c7d6f0849dc4ae9c3c818";
        libraryHaskellDepends = [ array base containers transformers ];
        homepage = "http://www.haskell.org/haskellwiki/Record_access";
        description = "Utilities for accessing and manipulating fields of records";
@@ -39761,7 +39893,7 @@ self: {
      mkDerivation {
        pname = "data-accessor-monadLib";
        version = "0.0.1";
-       sha256 = "0l1ywmr4jry4cys7lq6k0w0nsdpqj1g5l3vsnxyf0ai1901zk18i";
+       sha256 = "1185f90348212ae07cb77a0f5a5e90f8366d0107d3607ab467c4674972e53e50";
        libraryHaskellDepends = [ base data-accessor monadLib ];
        jailbreak = true;
        description = "Accessor functions for monadLib's monads";
@@ -39773,7 +39905,7 @@ self: {
      mkDerivation {
        pname = "data-accessor-monads-fd";
        version = "0.2.0.3";
-       sha256 = "1yvfk55qra7f9ggcybw3j68xg9dzx2f07swj99v4f588gh32ixhz";
+       sha256 = "1ff628067c081547764a92eb039ce8bfa5d79191832fcfde4beea88c4b996efb";
        libraryHaskellDepends = [
          base data-accessor monads-fd transformers
        ];
@@ -39788,7 +39920,7 @@ self: {
      mkDerivation {
        pname = "data-accessor-monads-tf";
        version = "0.2.1.4";
-       sha256 = "12skayn01s8svfdr4h5am2y2dw7ax6s83pb7vy3jxyddywpm04mk";
+       sha256 = "b312502ff7adf92e87df67dd81b4e9eaf026bca8aa40929bdb1ae900ac57538b";
        libraryHaskellDepends = [
          base data-accessor monads-tf transformers
        ];
@@ -39803,7 +39935,7 @@ self: {
      mkDerivation {
        pname = "data-accessor-mtl";
        version = "0.2.0.4";
-       sha256 = "1i8lk0vy04giixng5addgj740cbvwlc7g62qgrmhfip0w9k93kqh";
+       sha256 = "10cf9166e2e046076b7e58987718e57b31408e7cada9f26c8ff111e0379814c5";
        libraryHaskellDepends = [ base data-accessor mtl ];
        homepage = "http://www.haskell.org/haskellwiki/Record_access";
        description = "Use Accessor to access state in mtl State monad class";
@@ -39816,7 +39948,7 @@ self: {
      mkDerivation {
        pname = "data-accessor-template";
        version = "0.2.1.12";
-       sha256 = "0pkr9qbvgysgsa28dpa77a21ghlgiykkcyl41gpr4s7jl9wjs107";
+       sha256 = "07042d79a2f26892ef0b847a36a78f8fc217843a47dd8684d24ffbb7174e795e";
        libraryHaskellDepends = [
          base data-accessor template-haskell utility-ht
        ];
@@ -39830,7 +39962,7 @@ self: {
      mkDerivation {
        pname = "data-accessor-transformers";
        version = "0.2.1.6";
-       sha256 = "1iawhp1h68ynr2axj12jrn47nf08mss0ar8blagp59yi8j7170fa";
+       sha256 = "ca81138e44d1a7729fa20b6505b4ae08387b88cd5204d995c8d62303c3855cc5";
        libraryHaskellDepends = [ base data-accessor transformers ];
        homepage = "http://www.haskell.org/haskellwiki/Record_access";
        description = "Use Accessor to access state in transformers State monad";
@@ -39842,7 +39974,7 @@ self: {
      mkDerivation {
        pname = "data-aviary";
        version = "0.4.0";
-       sha256 = "03jhlb7w98bwx5xa23as9i6id0qxcl4f7k9rql2cgcy8nxf7c2xn";
+       sha256 = "b60b765cb7c8b3c704c539cde308651d83164d4c5a0da17ae97ca1c4cfa2500e";
        libraryHaskellDepends = [ base ];
        homepage = "http://code.google.com/p/copperbox/";
        description = "Combinator birds";
@@ -39854,7 +39986,7 @@ self: {
      mkDerivation {
        pname = "data-binary-ieee754";
        version = "0.4.4";
-       sha256 = "02nzg1barhqhpf4x26mpzvk7jd29nali033qy01adjplv2z5m5sr";
+       sha256 = "59975abed8f4caa602f0780c10a9b2493479e6feb71ad189bb10c3ac5678df0a";
        libraryHaskellDepends = [ base binary ];
        homepage = "https://john-millikin.com/software/data-binary-ieee754/";
        description = "Parser/Serialiser for IEEE-754 floating-point values";
@@ -39866,7 +39998,7 @@ self: {
      mkDerivation {
        pname = "data-bword";
        version = "0.1";
-       sha256 = "1s0fid1b8fjazii4j9rsjfmfhyacacknvy374y7nixsdgl4xp44d";
+       sha256 = "8d90db097d4df7688f2767f86d27534c79e8aa933a274962fc4a3ab4428b0ee8";
        libraryHaskellDepends = [ base ghc-prim ];
        testHaskellDepends = [ base tasty tasty-quickcheck ];
        homepage = "https://github.com/mvv/data-bword";
@@ -39879,7 +40011,7 @@ self: {
      mkDerivation {
        pname = "data-carousel";
        version = "0.1.0.0";
-       sha256 = "1vp17428a2pw4g3y2ra22ll5vjnqwl2xwr2wfj8ppkxaj34a2nsh";
+       sha256 = "505ba1c890aacf7b91745c64de05e5d8ca5d28154265e1c723fc0a850439e1ee";
        revision = "1";
        editedCabalFile = "56aa17d4ad0390625d0694ff6f8e281720d96bdabc678cc10934ac9becc663ea";
        libraryHaskellDepends = [ base containers lens ];
@@ -39892,7 +40024,7 @@ self: {
      mkDerivation {
        pname = "data-category";
        version = "0.6.1";
-       sha256 = "1rkxwzigc4lw4hp593fwcxkhnd4jqwd7szwc2jgdz50bdc6k3jqc";
+       sha256 = "0ccb310d6b0b94df9e148c7f7d1ac792340b6767dc8d542e249c12f6e2e77de6";
        homepage = "http://github.com/sjoerdvisscher/data-category";
        description = "Category theory";
        license = stdenv.lib.licenses.bsd3;
@@ -39903,7 +40035,7 @@ self: {
      mkDerivation {
        pname = "data-cell";
        version = "1.0.0.2";
-       sha256 = "03liak61gr90i48rd4dlm5lhr8z9v02nn6kdy33sinbpm6313agr";
+       sha256 = "f9a91186a977d9a8c7f06d1a6b05d8e9a30c69a9b49196118920e517cc54910e";
        libraryHaskellDepends = [ base ];
        homepage = "https://github.com/zadarnowski/data-cell";
        description = "Generic cellular data representation library";
@@ -39915,7 +40047,7 @@ self: {
      mkDerivation {
        pname = "data-checked";
        version = "0.3";
-       sha256 = "0xjn7iqlsgi51h8gz4x40kc2qb5lwf6nw5kjwgkck1w5gjfd11yw";
+       sha256 = "dc87d09c7c8587c9e6e372166e8de3b42c2cd804a493ff100c253e4d713c5676";
        libraryHaskellDepends = [ base deepseq ];
        homepage = "https://github.com/mvv/data-checked";
        description = "Type-indexed runtime-checked properties";
@@ -39927,7 +40059,7 @@ self: {
      mkDerivation {
        pname = "data-clist";
        version = "0.0.7.4";
-       sha256 = "0vnrn8fcnibdbvwdf2smipnvmamgva0x7pszl4bykmh15ns417vn";
+       sha256 = "769f40b42d01d6e917a15fdfd381daafaabaed8d550bd7f85e6d45cb1cb2d96e";
        libraryHaskellDepends = [ base deepseq QuickCheck ];
        homepage = "https://github.com/sw17ch/data-clist";
        description = "Simple functional ring type";
@@ -39939,7 +40071,7 @@ self: {
      mkDerivation {
        pname = "data-concurrent-queue";
        version = "0.3.0.0";
-       sha256 = "0rmn4pq5pgvam78vxp4y7431jai8dklml322r4nw47jjc1m20kmv";
+       sha256 = "bb4e206a60521ec22dc9420c5ae96c282a1906399edcbed1a96abf5bf025b666";
        libraryHaskellDepends = [ base stm ];
        jailbreak = true;
        description = "A Library for directional queues";
@@ -39952,7 +40084,7 @@ self: {
      mkDerivation {
        pname = "data-cycle";
        version = "0.1.2";
-       sha256 = "1k7a2k4vvbwilayh5827na7fifaww66fnmd7mr9vzwmsw9g6q80g";
+       sha256 = "0f206c5ee2baf2bf53aea755eb8ce15cb9e88eb247a002bda291afbdc914eacc";
        libraryHaskellDepends = [
          base collections-api collections-base-instances
        ];
@@ -39969,7 +40101,7 @@ self: {
      mkDerivation {
        pname = "data-default";
        version = "0.5.3";
-       sha256 = "0d1hm0l9kim3kszshr4msmgzizrzha48gz2kb7b61p7n3gs70m7c";
+       sha256 = "ec5470f41bf6dc60d65953fc8788823ffff85fd59564a8bf9ea3c69928a83034";
        libraryHaskellDepends = [
          base data-default-class data-default-instances-base
          data-default-instances-containers data-default-instances-dlist
@@ -39984,7 +40116,7 @@ self: {
      mkDerivation {
        pname = "data-default-class";
        version = "0.0.1";
-       sha256 = "0ccgr3jllinchqhw3lsn73ic6axk4196if5274rr1rghls0fxj5d";
+       sha256 = "adc8ee80a6f0e5903339a2b8685220b32bc3e23856d3c12186cc464ae5c88f31";
        libraryHaskellDepends = [ base ];
        description = "A class for types with a default value";
        license = stdenv.lib.licenses.bsd3;
@@ -39998,7 +40130,7 @@ self: {
      mkDerivation {
        pname = "data-default-generics";
        version = "0.3";
-       sha256 = "0asjirn324ixyzkf5vhanyf7q9aj9zh693m55qln7dx3vdayn1yv";
+       sha256 = "db07eb55dba3b763292ea58e64e04f52257c9cb70aeee2e6f73d12316c8e522b";
        libraryHaskellDepends = [
          base bytestring containers dlist ghc-prim old-locale text time
          unordered-containers vector
@@ -40016,7 +40148,7 @@ self: {
      mkDerivation {
        pname = "data-default-instances-base";
        version = "0.0.1";
-       sha256 = "1832nq6by91f1iw73ycvkbgn8kpra83pvf2q61hy47xffh0zy4pb";
+       sha256 = "eb12ff0174ae1fe2613058b87d0752f94e64df9a9bf971780c2e24bf0cb662a0";
        libraryHaskellDepends = [ base data-default-class ];
        description = "Default instances for types in base";
        license = stdenv.lib.licenses.bsd3;
@@ -40027,7 +40159,7 @@ self: {
      mkDerivation {
        pname = "data-default-instances-containers";
        version = "0.0.1";
-       sha256 = "06h8xka031w752a7cjlzghvr8adqbl95xj9z5zc1b62w02phfpm5";
+       sha256 = "a55e07af005c9815d82f3fc95e125db82994377c9f4a769428878701d4ec081a";
        libraryHaskellDepends = [ base containers data-default-class ];
        description = "Default instances for types in containers";
        license = stdenv.lib.licenses.bsd3;
@@ -40038,7 +40170,7 @@ self: {
      mkDerivation {
        pname = "data-default-instances-dlist";
        version = "0.0.1";
-       sha256 = "0narkdqiprhgayjiawrr4390h4rq4pl2pb6mvixbv2phrc8kfs3x";
+       sha256 = "7d683711cbf08abd7adcd5ac2be825381308d220397315a5570fe61b719b5959";
        libraryHaskellDepends = [ base data-default-class dlist ];
        description = "Default instances for types in dlist";
        license = stdenv.lib.licenses.bsd3;
@@ -40049,7 +40181,7 @@ self: {
      mkDerivation {
        pname = "data-default-instances-old-locale";
        version = "0.0.1";
-       sha256 = "00h81i5phib741yj517p8mbnc48myvfj8axzsw44k34m48lv1lv0";
+       sha256 = "60d3b02922958c4908d7bf2b24ddf61511665745f784227d206745784b0c0802";
        libraryHaskellDepends = [ base data-default-class old-locale ];
        description = "Default instances for types in old-locale";
        license = stdenv.lib.licenses.bsd3;
@@ -40063,7 +40195,7 @@ self: {
      mkDerivation {
        pname = "data-dispersal";
        version = "1.0.0.2";
-       sha256 = "1x6wd4xah19isysk2b9waws3fyvzx3w6l917zyw0cvdzf1lkpbw6";
+       sha256 = "86af3b6970bf6d06b8ff27246af8e87f7b3734573c2d31b5d73105a83a69dcf4";
        libraryHaskellDepends = [
          AES array base binary bytestring entropy finite-field matrix
          secret-sharing syb vector
@@ -40085,7 +40217,7 @@ self: {
      mkDerivation {
        pname = "data-dword";
        version = "0.3";
-       sha256 = "0m4jmmdi5j6h0pa4d8ll6pv2qvsf3y3bk6kss0hfglcwaa5vvy73";
+       sha256 = "e3f8bd8b529cd1e720d07a9ab9861f4e6f2cf63594a246d405d0c8125bad9254";
        libraryHaskellDepends = [
          base data-bword ghc-prim hashable template-haskell
        ];
@@ -40103,7 +40235,7 @@ self: {
      mkDerivation {
        pname = "data-easy";
        version = "0.6.1";
-       sha256 = "01plc0cs3bgyq16j94qqvswwmi12iqfxyxgw9jipqgvi7vbf5h9v";
+       sha256 = "3bc1e2d63e713f7ca34cfc75df1d8e22c4cab9de1893244dc0feada11960f406";
        libraryHaskellDepends = [ base containers safe ];
        testHaskellDepends = [
          base containers directory errors haskell-src-exts hlint hspec HUnit
@@ -40121,7 +40253,7 @@ self: {
      mkDerivation {
        pname = "data-endian";
        version = "0.1";
-       sha256 = "0ilvpd3xw1nljxvl7jdrzzyfkfl7gykidvbjvc7px3bca5mlmf1r";
+       sha256 = "39b84a6b516c8d7e0fdb72ed16a77f87bae9fcffb9c9437797d406de47bb9b46";
        libraryHaskellDepends = [ base ];
        homepage = "https://github.com/mvv/data-endian";
        description = "Endian-sensitive data";
@@ -40133,7 +40265,7 @@ self: {
      mkDerivation {
        pname = "data-extra";
        version = "2.5.5";
-       sha256 = "0py4a3mzqga25y6y1sirvc9369n3b7y5kpm5f9m613yjlypv6pc1";
+       sha256 = "815db3afa7d28f606a72a5de59fc59c3263312db39eae08d2f423dfceb50c45f";
        description = "None";
        license = stdenv.lib.licenses.bsd3;
        hydraPlatforms = stdenv.lib.platforms.none;
@@ -40146,7 +40278,7 @@ self: {
      mkDerivation {
        pname = "data-filepath";
        version = "2.2.0.0";
-       sha256 = "1l71sg02rqgk7i6w401il7crx3ikdbxi5wbb6ida677pfdrpm7f7";
+       sha256 = "c79d7a7373f71ca35a346bf112fb6a338e9ed9a13100c24d3cf3e12cc0d3e1d0";
        libraryHaskellDepends = [
          base bifunctors ghc-prim semigroups split template-haskell
        ];
@@ -40163,7 +40295,7 @@ self: {
      mkDerivation {
        pname = "data-fin";
        version = "0.1.1.3";
-       sha256 = "02n3dr4gj73z549vwq5h7h1kvmx2j8vaxjcggpdlppps9wl6flry";
+       sha256 = "3e5367284ffade4bdb7d8fc9ae3692a2d73d033cb060be13297f1cf9486ec30a";
        libraryHaskellDepends = [
          base lazysmallcheck prelude-safeenum QuickCheck reflection
          smallcheck tagged
@@ -40179,7 +40311,7 @@ self: {
      mkDerivation {
        pname = "data-fin-simple";
        version = "0.1.0.0";
-       sha256 = "17qj3b3lkrakdk3vbs9nqc2pvqr81n43qxphcznfbkv91k1ygrp6";
+       sha256 = "e6e6e7c30c69cfe5ec67f0763c880d28e37d05c336e9b5c76c53e549c71a129f";
        libraryHaskellDepends = [ base ];
        testHaskellDepends = [ base doctest ];
        homepage = "https://github.com/seagull-kamome/data-fin-simple";
@@ -40192,7 +40324,7 @@ self: {
      mkDerivation {
        pname = "data-fix";
        version = "0.0.1";
-       sha256 = "09r08lrv92ka6p35wkbfhq9ywg7y5pmgszwbz8a20h31vjz1ffpr";
+       sha256 = "f93a17bedc61402014fa8b7ffdea2dfe3cee13866e4d5ec6356a8ab433452027";
        libraryHaskellDepends = [ base ];
        homepage = "https://github.com/anton-k/data-fix";
        description = "Fixpoint data types";
@@ -40204,7 +40336,7 @@ self: {
      mkDerivation {
        pname = "data-fix-cse";
        version = "0.0.2";
-       sha256 = "1xn6qnir5dss23y8d71dsy78sdk7hczwprxir8v6la15c43rf9p2";
+       sha256 = "e22697076125286a36cab1e7cb3f8367368d8ed72d9c86fc105ab792a3c5c6f6";
        libraryHaskellDepends = [ base containers data-fix transformers ];
        homepage = "https://github.com/anton-k/data-fix-cse";
        description = "Common subexpression elimination for the fixploint types";
@@ -40216,7 +40348,7 @@ self: {
      mkDerivation {
        pname = "data-flags";
        version = "0.0.3.1";
-       sha256 = "1s0djw1qarjn1fkyf21fd6pacfpfy4cvyw3wbd63ccaf9g0s1gs5";
+       sha256 = "45bfa0c14b4e31364c5b7c70bf19f1ee3aa6ae692e08e7a70b56668503970de8";
        libraryHaskellDepends = [ base template-haskell ];
        description = "A package for working with bit masks and flags in general";
        license = stdenv.lib.licenses.bsd3;
@@ -40227,7 +40359,7 @@ self: {
      mkDerivation {
        pname = "data-flagset";
        version = "1.0.0.0";
-       sha256 = "0ygvzrcb2vskjf203svk9wpv8lw4447rd218zvys4a0787ss1aw2";
+       sha256 = "82aba0f5410728a2fdfe2888960f218453b42f4f73eb018493536fb158fefb79";
        libraryHaskellDepends = [ base ];
        description = "An efficient data type for sets of flags";
        license = stdenv.lib.licenses.mit;
@@ -40238,7 +40370,7 @@ self: {
      mkDerivation {
        pname = "data-fresh";
        version = "0.2013.251.0";
-       sha256 = "1hz30myv78mw4sf19k1yg4qikrnxsa5ng0ff4naxyz1zyi2m87f1";
+       sha256 = "c11d5445f43f7cdf9525ce81678bd2dde61931793ecc149c26bca2b37d05e3c3";
        libraryHaskellDepends = [ base free transformers ];
        description = "Interface and functor transformers for fresh values";
        license = stdenv.lib.licenses.bsd3;
@@ -40251,7 +40383,7 @@ self: {
      mkDerivation {
        pname = "data-hash";
        version = "0.2.0.1";
-       sha256 = "1ghbqvc48gf9p8wiy71hdpaj7by3b9cw6wgwi3qqz8iw054xs5wi";
+       sha256 = "9117dd49013ca28ff188fc71c3595ac3af23d56d301c1f39bac93d44d8c60bbe";
        libraryHaskellDepends = [ array base containers ];
        testHaskellDepends = [
          base QuickCheck test-framework test-framework-quickcheck2
@@ -40269,7 +40401,7 @@ self: {
      mkDerivation {
        pname = "data-interval";
        version = "1.2.0";
-       sha256 = "139v825r0r4k8b8cmndpx6gfkdn55ygiwmq8r3fcgljajk99y4km";
+       sha256 = "75129fd2944ad2c7dcc808571e9f2fc5b6e99ee9b7d9cad0429364908b403b8d";
        libraryHaskellDepends = [
          base deepseq extended-reals hashable lattices
        ];
@@ -40286,7 +40418,7 @@ self: {
      mkDerivation {
        pname = "data-inttrie";
        version = "0.1.0";
-       sha256 = "00kzf3cw0y0848cprmx3i7g70rmr92hhfzn60a2x98vb8f7y3814";
+       sha256 = "24a0e18f436ba3d48502c67e07a148b96670de89a3d77c19220878c0d9707f02";
        libraryHaskellDepends = [ base ];
        homepage = "http://github.com/luqui/data-inttrie";
        description = "A lazy, infinite trie of integers";
@@ -40298,7 +40430,7 @@ self: {
      mkDerivation {
        pname = "data-ivar";
        version = "0.30";
-       sha256 = "1vnbmvihkrcknys33sam9zlb5qk5qqkxz6w3wamsbdmpp0q6zfb2";
+       sha256 = "62b96f30b8b7b6a5abe2839bdf27c665e2b2e84f55e931b4b793e509e3aecbee";
        libraryHaskellDepends = [ base containers ];
        description = "Write-once variables with concurrency support";
        license = stdenv.lib.licenses.bsd3;
@@ -40312,7 +40444,7 @@ self: {
      mkDerivation {
        pname = "data-kiln";
        version = "0.1.0.0";
-       sha256 = "13pkpmpjy787cjn1hcsl9r04w70nxrzdx8xrn9w6ifbzb2xj2iny";
+       sha256 = "de4621bb587fb96878b2b9a3de7eee161c4e404e543318ac64071d2f6fbdf38e";
        libraryHaskellDepends = [
          base containers data-fix IfElse mtl transformers
        ];
@@ -40327,7 +40459,7 @@ self: {
      mkDerivation {
        pname = "data-layout";
        version = "0.1.0.0";
-       sha256 = "1w8r4vw731dmam8vcidz9a4wb2swqd5djsf9vkkxihxnphh0a1x5";
+       sha256 = "a5070520bcb6c3d8e7dcc969d94ac35c8bc5894abf45b65155b58571f82619f1";
        libraryHaskellDepends = [ base bytestring vector ];
        homepage = "http://github.com/jystic/data-layout";
        description = "Read/write arbitrary binary layouts to a \"Data.Vector.Storable\".";
@@ -40341,7 +40473,7 @@ self: {
      mkDerivation {
        pname = "data-lens";
        version = "2.10.7";
-       sha256 = "0l70jzys2qb31cyq3nci97i01ncadkhizxvc9c3psxcd2n28l69v";
+       sha256 = "3b198a84158d757d074b6cf71fe16c8ad900e24991d9813d0b6361a1fd97e050";
        libraryHaskellDepends = [
          base comonad containers semigroupoids transformers
        ];
@@ -40355,7 +40487,7 @@ self: {
      mkDerivation {
        pname = "data-lens-fd";
        version = "2.0.5";
-       sha256 = "0r8cfgn6wx304b5ihmwgsxxjwalb7086wii655mgmb6cn3nirpyk";
+       sha256 = "d3df1cedb0ccacfa6a2926466e10388b2a2e7bd78f5718cb2260746eec730c65";
        libraryHaskellDepends = [
          base comonad data-lens mtl transformers
        ];
@@ -40369,7 +40501,7 @@ self: {
      mkDerivation {
        pname = "data-lens-ixset";
        version = "0.1.4";
-       sha256 = "0frzjfcp7w1ayfai1m07n0fpj3z1vbi971bc1kn1iarxhakny651";
+       sha256 = "a1186fa7823dab18ec0c6c8593e2dae10f791db007d41095f32af07399933f3b";
        libraryHaskellDepends = [ base data-lens ixset ];
        testHaskellDepends = [ QuickCheck ];
        jailbreak = true;
@@ -40384,7 +40516,7 @@ self: {
      mkDerivation {
        pname = "data-lens-light";
        version = "0.1.2.1";
-       sha256 = "038vfzb4vxk1qb0246l2kgv9br37wg59wnlhzyjpn97lypwlf68w";
+       sha256 = "1c1947f9f5f4247ba5ff905a9ecae367e495f69b821a22c0c261f64dd6771b0d";
        libraryHaskellDepends = [ base mtl template-haskell ];
        homepage = "https://github.com/feuerbach/data-lens-light";
        description = "Simple lenses, minimum dependencies";
@@ -40396,7 +40528,7 @@ self: {
      mkDerivation {
        pname = "data-lens-template";
        version = "2.1.9";
-       sha256 = "0dpj3a1dj5l5jll2f0flj3wss9h2jbsljihrwh68zbb92pcgb56g";
+       sha256 = "cf94f5d81569ad8f0ce4194649f5920226adf990d4012728958516d9821af236";
        libraryHaskellDepends = [ base data-lens template-haskell ];
        homepage = "http://github.com/roconnor/data-lens-template/";
        description = "Utilities for Data.Lens";
@@ -40408,7 +40540,7 @@ self: {
      mkDerivation {
        pname = "data-list-sequences";
        version = "0.1";
-       sha256 = "0r3y66lxgk0sdg500xnz0fvg4dvzvx47imnw0qkici22b9d92kv8";
+       sha256 = "684f915a5a4244162706dcd67848df7f37f2b603df7600ca6b1accd7a9317e64";
        libraryHaskellDepends = [ base ];
        homepage = "https://github.com/jkramer/data-list-sequences";
        description = "Utilities for working with sequences within lists";
@@ -40420,7 +40552,7 @@ self: {
      mkDerivation {
        pname = "data-map-multikey";
        version = "0.0.1.2";
-       sha256 = "04h4k2zn6w8rahzyr80hwf8mvsmzgbqh7aw2138sva874bsk9mkf";
+       sha256 = "6ed634f52207a9add10882ab03f17abfea5d91e310a0ec3f54197163bf980412";
        libraryHaskellDepends = [ base containers ];
        jailbreak = true;
        homepage = "http://github.com/jhickner/data-map-multikey";
@@ -40433,7 +40565,7 @@ self: {
      mkDerivation {
        pname = "data-memocombinators";
        version = "0.5.1";
-       sha256 = "1mvfc1xri3kgkx5q7za01bqg1x3bfvbgcffw5vwl6jmq4hh1sd5l";
+       sha256 = "b4341d2024b84a43f92edc39f6d6766bf4f0f00a40fd834b9f6f8e987b606ed7";
        libraryHaskellDepends = [ array base data-inttrie ];
        homepage = "http://github.com/luqui/data-memocombinators";
        description = "Combinators for building memo tables";
@@ -40445,7 +40577,7 @@ self: {
      mkDerivation {
        pname = "data-named";
        version = "0.5.2";
-       sha256 = "1mzwnbcb7ji4m6p4s68422gmpna06llbh2rhk6w048mgjxv4fhsx";
+       sha256 = "5d43477697af2202b899300bb8283540d95b9f1004194daea924cab3d8b2fcd7";
        libraryHaskellDepends = [ attoparsec base binary containers text ];
        homepage = "https://github.com/kawu/data-named";
        description = "Data types for named entities";
@@ -40458,7 +40590,7 @@ self: {
      mkDerivation {
        pname = "data-nat";
        version = "0.1.2";
-       sha256 = "1yzxkch0xzy76iyad0yshfnpvz38xklqdlyj8lgqnqsllw0vwh0m";
+       sha256 = "1540be01a754638b1f45d2d386e9ec68fc7dad83da83a67c34c7ff0e209bfdfb";
        libraryHaskellDepends = [ base semigroups ];
        jailbreak = true;
        homepage = "http://github.com/glehel/data-nat";
@@ -40472,7 +40604,7 @@ self: {
      mkDerivation {
        pname = "data-object";
        version = "0.3.1.9";
-       sha256 = "0z8m23kw8mj6hhy1r8y1vvlxxpwl273dhanszig2673a1sw0l98l";
+       sha256 = "14250ab80e6a1c235efcda2ad8c61194dfdee9dec1a31c3c844656c4e710157d";
        libraryHaskellDepends = [ base bytestring failure text time ];
        jailbreak = true;
        homepage = "http://github.com/snoyberg/data-object/tree/master";
@@ -40487,7 +40619,7 @@ self: {
      mkDerivation {
        pname = "data-object-json";
        version = "0.3.1.8";
-       sha256 = "06zkiqj4pkl5q4fmh816y4yj74rzwi2b91k542lxswjvfa3za3qk";
+       sha256 = "130ff587725b72dda9206586b444e43f93233df12620581dc185ce4b248ef31b";
        libraryHaskellDepends = [
          base bytestring bytestring-trie convertible-text data-object
          failure JSONb text
@@ -40506,7 +40638,7 @@ self: {
      mkDerivation {
        pname = "data-object-yaml";
        version = "0.3.4.2";
-       sha256 = "18a9r4wfpb7icjb6nji9iy3abq6sxafmsnfwqpnm1nn2nn3fm1ap";
+       sha256 = "5785ea86b5c2da50edc5dc595d9deadae0a5868f294a6b9664f1aceb38c949a1";
        isLibrary = true;
        isExecutable = true;
        libraryHaskellDepends = [
@@ -40525,7 +40657,7 @@ self: {
      mkDerivation {
        pname = "data-or";
        version = "1.0.0.5";
-       sha256 = "0wp6qqq6k1zbdw9bv9gkzdiz6y8wp8r7zsqbjh54c43j3i7vdvwx";
+       sha256 = "9defb64f1c7210460a940beb7f32ba1c79f363fbf3a5bd126feb876930c6e672";
        libraryHaskellDepends = [ base ];
        homepage = "http://code.haskell.org/~wren/";
        description = "A data type for non-exclusive disjunction";
@@ -40537,7 +40669,7 @@ self: {
      mkDerivation {
        pname = "data-ordlist";
        version = "0.4.7.0";
-       sha256 = "03a9ix1fcx08viwv2jg5ndw1qbkydyyrmjvqr9wasmcik9x1wv3g";
+       sha256 = "6f6c1e7a9a9155ad78ca78cb9abd6f7e2e1c78b3e549b179dc0874e6428f490d";
        libraryHaskellDepends = [ base ];
        description = "Set and bag operations on ordered lists";
        license = stdenv.lib.licenses.bsd3;
@@ -40548,7 +40680,7 @@ self: {
      mkDerivation {
        pname = "data-partition";
        version = "0.3.0.0";
-       sha256 = "05i8fg9q7fpc9jalhwbqpw6pfki2flqj4nqwgs3yfi0hvasvgjjb";
+       sha256 = "4bcab7b5da1044e7877e1c5b223175224e770dbf787148954cecba83d3732816";
        libraryHaskellDepends = [ base containers ];
        homepage = "https://github.com/luqui/data-partition";
        description = "A pure disjoint set (union find) data structure";
@@ -40560,7 +40692,7 @@ self: {
      mkDerivation {
        pname = "data-pprint";
        version = "0.2.4";
-       sha256 = "0r4q95pl9gmgc080psi3j87cg1v3cmm6gxnrps17j5sw1nqzb6v5";
+       sha256 = "659bf5b10d5c177982bed9f6676a656387c70e9223ea0b1060afbe446f499864";
        libraryHaskellDepends = [ base deepseq mtl parallel pretty time ];
        description = "Prettyprint and compare Data values";
        license = stdenv.lib.licenses.bsd3;
@@ -40571,7 +40703,7 @@ self: {
      mkDerivation {
        pname = "data-quotientref";
        version = "0.1";
-       sha256 = "0ylimakhw37klz2axg8qrdhwag34mfa1byb2z2mz2i8z0w4737j8";
+       sha256 = "489e7108071f45f1abf862f91594ab643cc561cb18bdaec4a7f30c0ea7aa917a";
        libraryHaskellDepends = [ base ];
        description = "Reference cells that need two independent indices to be accessed";
        license = stdenv.lib.licenses.bsd3;
@@ -40586,7 +40718,7 @@ self: {
      mkDerivation {
        pname = "data-r-tree";
        version = "0.0.5.0";
-       sha256 = "1zgwm020zxfhb70llch4y075rd6klwwnv9yn8mpgh0rm0ib7jvyy";
+       sha256 = "de6f7956043503f86e45d6a76d39a7d3b45c0ef004324ac159d0f50f04a8fcfd";
        libraryHaskellDepends = [ base binary deepseq ];
        testHaskellDepends = [
          base binary containers HUnit QuickCheck test-framework
@@ -40602,7 +40734,7 @@ self: {
      mkDerivation {
        pname = "data-ref";
        version = "0.0";
-       sha256 = "0bcizcf6i1hfpk7ry64si40mfdndgd8k0h9mzh873xp1v2qali7n";
+       sha256 = "f644aab0d8e1f67110fc354130517bcd365701899a189fcfbc0e86681cfb912d";
        libraryHaskellDepends = [ base stm transformers ];
        jailbreak = true;
        homepage = "http://www.haskell.org/haskellwiki/Mutable_variable";
@@ -40615,7 +40747,7 @@ self: {
      mkDerivation {
        pname = "data-reify";
        version = "0.6.1";
-       sha256 = "00mjv6dc3fwhbqzrll02qxilwpfypahkzcdqnv17c4nbjqg0ldb1";
+       sha256 = "61350a1e96cb1276c2b6b8b13fa1bade5d4e63c702509a3f5e90bbc19ad9b202";
        isLibrary = true;
        isExecutable = true;
        libraryHaskellDepends = [ base containers ];
@@ -40630,7 +40762,7 @@ self: {
      mkDerivation {
        pname = "data-reify-cse";
        version = "0.0.3";
-       sha256 = "0vjfpbp0maqwirvi8j21z9qbs396l76dk5npn8zxac56j0i6l62r";
+       sha256 = "59186a2290a630d53fb2d796d9cca1260dbd70fa414814778e1cab0aeeba4e6e";
        libraryHaskellDepends = [ base containers data-reify ];
        description = "Common Sub-Expression Elimination for graphs generated by Data.Reify.";
        license = stdenv.lib.licenses.bsd3;
@@ -40641,7 +40773,7 @@ self: {
      mkDerivation {
        pname = "data-rev";
        version = "0.1.0.1";
-       sha256 = "13bqp3vvsc6i6lcvw480i08fz2rm3f8varwyhvrp44dzv2q8zkl1";
+       sha256 = "81ce8fb0d8bf1172f3869e67b5911b358bef10880011be1935d130bdf7b8788d";
        libraryHaskellDepends = [ base bytestring containers text vector ];
        jailbreak = true;
        homepage = "https://github.com/jxv/data-rev";
@@ -40654,7 +40786,7 @@ self: {
      mkDerivation {
        pname = "data-rope";
        version = "0.3";
-       sha256 = "06sz6z0kd53av4acmgxh4668fsn588hx5k5qp752rrjf2nx9vww8";
+       sha256 = "88f39dba154ee62ccab9b8ccd22142c56a878c21b0bfca14d96a9436c1375f1b";
        libraryHaskellDepends = [ base bytestring bytestring-mmap unix ];
        description = "Ropes, an alternative to (Byte)Strings";
        license = "GPL";
@@ -40666,7 +40798,7 @@ self: {
      mkDerivation {
        pname = "data-size";
        version = "0.1.1.7";
-       sha256 = "0j1g39ha2fjgd960zd0gbhpznisw3qw07mbdacbx226bw50nwa7y";
+       sha256 = "fe286e41e1cb08d117536dd503381e5c47fb2f5c0fb40f4c6a4f3aa1601a2f48";
        libraryHaskellDepends = [
          base bytestring containers deepseq text
        ];
@@ -40679,7 +40811,7 @@ self: {
      mkDerivation {
        pname = "data-spacepart";
        version = "20090215.0";
-       sha256 = "0h6z4yibjbnzck2fvh9mnppz9j0lzgx8nzmzm08q5yzmzjydy3rk";
+       sha256 = "330fdfbcfcf5fb8211a8bf7e8bfafb14c8f4efb535c1edc464df2eb9a227df40";
        libraryHaskellDepends = [ base vector-space ];
        jailbreak = true;
        homepage = "http://code.haskell.org/data-spacepart";
@@ -40695,7 +40827,7 @@ self: {
      mkDerivation {
        pname = "data-store";
        version = "0.3.0.7";
-       sha256 = "0cv02d3fwyyyxjv3519k9wilaagxlcn8m2nfifrcq0q0qihxd1bd";
+       sha256 = "6d85d661c40003ccb28bce8a8a2ca3fd2945234f338532b6ecde7bee46136033";
        libraryHaskellDepends = [
          base cereal containers deepseq lens safecopy transformers
        ];
@@ -40718,7 +40850,7 @@ self: {
      mkDerivation {
        pname = "data-stringmap";
        version = "1.0.1.1";
-       sha256 = "0djbky5m6hxr04jgxi2cq3fsivja32nzn16zs8ffqgadxw030pa1";
+       sha256 = "415d3000ef4d3dec1cd2df04fbad184aeea8ddc04cc4fe2401b943538b9f4b36";
        libraryHaskellDepends = [ base binary containers deepseq ];
        testHaskellDepends = [
          base containers deepseq ghc-heap-view HUnit QuickCheck
@@ -40736,7 +40868,7 @@ self: {
      mkDerivation {
        pname = "data-structure-inferrer";
        version = "1.0";
-       sha256 = "0jkbysk1rmbkjvjizwx72h58amvnz4iyjbs0lcx6987m4fn456w9";
+       sha256 = "899b42ac23f5a0643aa3402fe923f97657850a14a7f31fe59673d51ca6f66b4a";
        isLibrary = false;
        isExecutable = true;
        executableHaskellDepends = [
@@ -40754,7 +40886,7 @@ self: {
      mkDerivation {
        pname = "data-tensor";
        version = "0.1.0.0";
-       sha256 = "0j6jsgj3lhx6ps3xs90vbgyvzmlr3sfl33r6rz34rvb29gs171n8";
+       sha256 = "c88613f44b62ed4cc6cf268f419d1e99d6bffd5b1b24dd87bea6433ae4d3d248";
        libraryHaskellDepends = [ base ];
        homepage = "https://bitbucket.org/tdammers/data-tensor";
        description = "Tensor and Group typeclasses";
@@ -40769,7 +40901,7 @@ self: {
      mkDerivation {
        pname = "data-textual";
        version = "0.3.0.2";
-       sha256 = "0c4qs923dj4jnvvkjvbij0c1yg922iw66140cq6wb1m4h6q31ia4";
+       sha256 = "44c530b081a486c50d668004637814223d1f1890716d39f7b692c83644d29830";
        libraryHaskellDepends = [
          base bytestring parsers text text-latin1 text-printer
        ];
@@ -40789,7 +40921,7 @@ self: {
      mkDerivation {
        pname = "data-timeout";
        version = "0.3";
-       sha256 = "1b6af2x19hb1kynsv7ypc2q6b71cazcg86gf1yhq0rr0fjj478ah";
+       sha256 = "50a143a474206780a10fee19f4d8572c9c65b060d79fadad9f61c114ba70caac";
        libraryHaskellDepends = [
          base data-textual parsers tagged text-printer transformers-base
        ];
@@ -40803,7 +40935,7 @@ self: {
      mkDerivation {
        pname = "data-transform";
        version = "0.1.0.0";
-       sha256 = "1mhcbwh4s414hq4cwljxxadazxfi382spfgkw38fz2xi08lbfsji";
+       sha256 = "516ab72802b18befd0e0f3b9ab051ad1f5af9aea5d52ce088624104d205f0cd6";
        libraryHaskellDepends = [ base containers mtl ];
        description = "Functions to transform data structures";
        license = stdenv.lib.licenses.bsd3;
@@ -40814,7 +40946,7 @@ self: {
      mkDerivation {
        pname = "data-treify";
        version = "0.3.4";
-       sha256 = "03xchr2h0f54rlcq285xaq5bakjq13mbjwz3xi3kfa6i71rr2rk9";
+       sha256 = "6966917338d1283747ece373b9ea08584eb50a56bd208119cda438004586ac0f";
        libraryHaskellDepends = [ base containers ty ];
        homepage = "http://ittc.ku.edu/~andygill/data-reify.php";
        description = "Reify a recursive data structure into an explicit graph";
@@ -40826,7 +40958,7 @@ self: {
      mkDerivation {
        pname = "data-type";
        version = "0.1.0";
-       sha256 = "1x3wsnilp9sxy061sfmyyg0f6b0k2lxvi0g4qf2gkldrz32c4qvj";
+       sha256 = "7263c2c4f8b9d1f984c3e481b83b15132ce3c0f3be3a1d0cf05da74ba3d57cf4";
        libraryHaskellDepends = [ base ];
        description = "Basic type wrangling types and classes";
        license = stdenv.lib.licenses.bsd3;
@@ -40838,7 +40970,7 @@ self: {
      mkDerivation {
        pname = "data-util";
        version = "0.4";
-       sha256 = "1ywp3h2zccknc2sr0b5zbf9ms2zph5qh8znswxc7bi5wynyk9z98";
+       sha256 = "28fd34bdf5bcc47558e7da7e047181f70b5d935bbf2c90b5607632f6051c97fb";
        libraryHaskellDepends = [ base ];
        jailbreak = true;
        homepage = "https://github.com/cutsea110/data-util";
@@ -40851,7 +40983,7 @@ self: {
      mkDerivation {
        pname = "data-variant";
        version = "0.28.0.5";
-       sha256 = "11ia37q28xz8a87xkc8yyvqqd3qzfvcbdnp2caxdbzvdnjbazhmk";
+       sha256 = "b3c2af96b46dffd5ba62e2dab6d8761f8f86f1f61eb1d90f52e87724f0192a86";
        libraryHaskellDepends = [ base safe ];
        homepage = "https://bitbucket.org/tdammers/data-variant";
        description = "A variant data type, useful for modeling dynamically-typed programming languages";
@@ -40866,7 +40998,7 @@ self: {
      mkDerivation {
        pname = "database-migrate";
        version = "0.2.0";
-       sha256 = "1hhx3851yzgq7cf397sifdbnznk0sfqf3blflxfl50yq68rmwbzy";
+       sha256 = "fe2f5e3332d883425da78eaee1b0d360da6f5773519f341c3bf87d1f0a1a1dc2";
        libraryHaskellDepends = [
          base bytestring cmdargs containers directory either filepath lens
          postgresql-simple text time transformers
@@ -40881,7 +41013,7 @@ self: {
      mkDerivation {
        pname = "database-study";
        version = "0.0.1";
-       sha256 = "1aqp7a46p758f1q99cn700mgc1dic896gpsih3vj2fmffqj42gd7";
+       sha256 = "a73d412476ae3a21f78051df671262b105f62a00c7b2947070a89c6b883a17ab";
        libraryHaskellDepends = [ base containers ];
        jailbreak = true;
        homepage = "http://dbs.informatik.uni-halle.de/Lehre/LP09/";
@@ -40897,7 +41029,7 @@ self: {
      mkDerivation {
        pname = "datadog";
        version = "0.1.0.1";
-       sha256 = "05hfpkaizbgqi998wa0l0hb8qph8y7gwyx05690ljr0883m5a663";
+       sha256 = "c31855ea4008644941320574cfdff1085e8c160414288e528af8ad1fd5bc0e16";
        libraryHaskellDepends = [
          aeson auto-update base buffer-builder bytestring lens lifted-base
          monad-control network old-locale text time transformers-base
@@ -40912,7 +41044,7 @@ self: {
      mkDerivation {
        pname = "dataenc";
        version = "0.14.0.7";
-       sha256 = "1wwgm7wakkz6v94lyxyd3yi21l3h28sss4xxdb3d770vmjhp1lzr";
+       sha256 = "f9d370a1ac1b9cd3c66abd13ad351270d020a21fcd774f49dae6cfa9f8a98ff3";
        isLibrary = true;
        isExecutable = true;
        libraryHaskellDepends = [ array base containers ];
@@ -40929,7 +41061,7 @@ self: {
      mkDerivation {
        pname = "dataflow";
        version = "0.6.1.0";
-       sha256 = "099n0mlx695zvazx7q53i474nzmdrqk38q8lrzf6qh440h60q7bx";
+       sha256 = "7d1d0c0c0484406cdccf14613426cead7e4b0e89a3e0d3bfdabf24d369053625";
        isLibrary = true;
        isExecutable = true;
        libraryHaskellDepends = [ base containers MissingH mtl parsec ];
@@ -40949,7 +41081,7 @@ self: {
      mkDerivation {
        pname = "datalog";
        version = "0.2.0.2";
-       sha256 = "1nfjmgf6j8a8602rmk7fg3kbkafiyd7lsnhvnwc95ms90icg0r86";
+       sha256 = "0665f0580449d79218b71b5a4d4ff3d1a9b9e678eecc9a0530482169dcabd2d9";
        isLibrary = true;
        isExecutable = true;
        libraryHaskellDepends = [
@@ -40977,7 +41109,7 @@ self: {
      mkDerivation {
        pname = "datapacker";
        version = "1.0.1";
-       sha256 = "10fj1z4wbr76wfnp9h1jzyd8afzn495r6xvbjiw55bimy0hasalg";
+       sha256 = "8f2aad20f035ae5278946b77934b22f63b859aff32c074ade3e6e4c5c90fd281";
        isLibrary = false;
        isExecutable = true;
        executableHaskellDepends = [
@@ -40993,7 +41125,7 @@ self: {
      mkDerivation {
        pname = "date-cache";
        version = "0.3.0";
-       sha256 = "0grhcbd0rhdn0cf1fz82x8pv8cmxfhndlcwyrax4mnnr3pql9kmb";
+       sha256 = "abce44f11dd9da4abaca9e33da2c74bd32b42fea027d171c03b6c10cda62303f";
        libraryHaskellDepends = [ base bytestring ];
        description = "Date cacher";
        license = stdenv.lib.licenses.bsd3;
@@ -41004,7 +41136,7 @@ self: {
      mkDerivation {
        pname = "dates";
        version = "0.2.2.0";
-       sha256 = "08d90fii0nmvmfxhhw4k5ja13jyxg79n527089lrc2r31l3wj40a";
+       sha256 = "0a10c9070d230b966942e08862d379ddcb11942c937008bbabbb5a10a303a921";
        libraryHaskellDepends = [
          base base-unicode-symbols parsec syb time
        ];
@@ -41022,7 +41154,7 @@ self: {
      mkDerivation {
        pname = "datetime";
        version = "0.3.1";
-       sha256 = "0jmxxmv5s9rch84ivfjhqxdqnvqqzvabjs152wyv47h5qmvpag1k";
+       sha256 = "333c7577c5051eb23d172568b9d4fe186f8b5bc750ba1d09822c275d76edbd4a";
        libraryHaskellDepends = [ base old-locale old-time time ];
        testHaskellDepends = [
          base HUnit old-locale old-time QuickCheck test-framework
@@ -41041,7 +41173,7 @@ self: {
      mkDerivation {
        pname = "datetime-sb";
        version = "0.2.4";
-       sha256 = "1p2pn0jdidqcvmmi80njqm9z4amn1qp05nlxbnz1svpp6nc7amjf";
+       sha256 = "4e56759835f76e1dbe5d9dda022e0eb62af253c5d202146bdd0cb7d824b057dc";
        libraryHaskellDepends = [ base old-locale old-time time ];
        testHaskellDepends = [
          base HUnit old-locale old-time QuickCheck test-framework
@@ -41059,7 +41191,7 @@ self: {
      mkDerivation {
        pname = "dawg";
        version = "0.11";
-       sha256 = "0xvkw5hp66r46v59ld0s7yi2jzvlcc4vc8ignadai9vqxayzm799";
+       sha256 = "299dfabdea78a7a89ab22f22b60963747f29a23f1a349aca36241b7361e17377";
        libraryHaskellDepends = [
          base binary containers mtl transformers vector vector-binary
        ];
@@ -41073,7 +41205,7 @@ self: {
      mkDerivation {
        pname = "dbcleaner";
        version = "0.1.1";
-       sha256 = "1n4al0fd577ldvaxca6nz181lp0b29z4slrjldx3m51nkxy1ficc";
+       sha256 = "8c45177c9f36943a7aa332534d7e120b5c1a50f8d628d6d56ef49cd21ca08ad8";
        libraryHaskellDepends = [ base postgresql-simple text ];
        testHaskellDepends = [ base hspec postgresql-simple text ];
        description = "Clean database tables automatically around hspec tests";
@@ -41085,7 +41217,7 @@ self: {
      mkDerivation {
        pname = "dbf";
        version = "0.0.0.2";
-       sha256 = "1pay47bbmxvishmczs3kgn19nzkfmmip3m51h4zlwydm5kxfc5n2";
+       sha256 = "c216e6fa2cb5794e3f81a1d47163ad6e7e9b827d73e8cf2ad471f7bad6215edd";
        libraryHaskellDepends = [
          base binary bytestring monad-loops rwlock
        ];
@@ -41101,7 +41233,7 @@ self: {
      mkDerivation {
        pname = "dbjava";
        version = "1.7";
-       sha256 = "06xz0a38sjjr64sz19lg0wzb73yz1msdlbg5s02ldd8n4b9yjk5f";
+       sha256 = "ae4ce9d32216b54605d0e52dda740ddf8fb33e078fa6f03531594a8d8602bf1b";
        isLibrary = true;
        isExecutable = true;
        libraryHaskellDepends = [
@@ -41125,7 +41257,7 @@ self: {
      mkDerivation {
        pname = "dbmigrations";
        version = "0.8.2";
-       sha256 = "031ibk22iyqzbkc6cy5ab5kmbhk68k5217szpw50vdp646rya21w";
+       sha256 = "3c08e5b321e6b60d0abf5f9f20ca4466c2556759aa7866d85c1ffb28c45c310c";
        isLibrary = true;
        isExecutable = true;
        libraryHaskellDepends = [
@@ -41156,7 +41288,7 @@ self: {
      mkDerivation {
        pname = "dbus";
        version = "0.10.10";
-       sha256 = "0s14yb2bbi5n9m3xkznm4nbb0hpj9hmiwl0ppqqiml5s7xhwas6d";
+       sha256 = "cd68c5613fbad01a31be17501e2b4cf242b09625d5fed9474db6c4b5c4f22468";
        libraryHaskellDepends = [
          base bytestring cereal containers libxml-sax network parsec random
          text transformers unix vector xml-types
@@ -41178,7 +41310,7 @@ self: {
      mkDerivation {
        pname = "dbus-client";
        version = "0.4.1";
-       sha256 = "0z7061kafjzd4jaws4xcp1xzh2kx559bgp7cmcjq55mbxr1rrsjq";
+       sha256 = "58ea9c43eeab968225abecdcb752297d0af87bb8ac13cd9524ed4ba76630e07c";
        libraryHaskellDepends = [
          base containers dbus-core monads-tf text transformers
        ];
@@ -41197,7 +41329,7 @@ self: {
      mkDerivation {
        pname = "dbus-core";
        version = "0.9.3";
-       sha256 = "110373yinimq0k7hl8wkk7g4hm3hj563dpa2y8ag2lpl9yydzgfa";
+       sha256 = "cabddfbc4ff452f114f242dd364c91705448de9993230acf04b8461bfd380384";
        libraryHaskellDepends = [
          base binary bytestring containers data-binary-ieee754 libxml-sax
          network parsec text unix vector xml-types
@@ -41216,7 +41348,7 @@ self: {
      mkDerivation {
        pname = "dbus-qq";
        version = "0.1.0";
-       sha256 = "0dg03nv7bsjydywhby0rv1a6jc90gf2885djxd8pb9aly2ncpjxx";
+       sha256 = "bdcbcbacf054a57551ebb21584847b20316954d819f805b96f5eea75b61de035";
        libraryHaskellDepends = [
          base containers dbus parsec template-haskell
        ];
@@ -41233,7 +41365,7 @@ self: {
      mkDerivation {
        pname = "dbus-th";
        version = "0.1.1.1";
-       sha256 = "0sxk7m8fdd7cx0n0lbcfz2bv28d0i8v0im50y1sciac7pi13q4bc";
+       sha256 = "6c113c42bc87a9c874f0a0d408368aa021b197f88e2d0a2ce8ecb4e6503db36b";
        libraryHaskellDepends = [
          base containers dbus syb template-haskell text
        ];
@@ -41248,7 +41380,7 @@ self: {
      mkDerivation {
        pname = "dclabel";
        version = "0.9.0.0";
-       sha256 = "0bnbqbjpbx98wjgsz7kgr5znljbwhd6lsb8m9ky7dmzqygzybvir";
+       sha256 = "39eee5fff3f8d776fc4c152d4d4d837c496a7fc96f9eaf9fe428f575e5c2cb2e";
        libraryHaskellDepends = [ base bytestring cereal containers ];
        testHaskellDepends = [
          base bytestring cereal containers QuickCheck quickcheck-instances
@@ -41265,7 +41397,7 @@ self: {
      mkDerivation {
        pname = "dclabel-eci11";
        version = "0.3";
-       sha256 = "1bfc9ip4fqzjzlzppkrnspnm6gc50f4rkf0wngnxyj7f79fvjr6k";
+       sha256 = "d364b95d3aee48dfedb31cb8998903853d53edd536cf7b3ffdf263476e4cccad";
        libraryHaskellDepends = [ base pretty QuickCheck ];
        description = "The Disjunction Category Label Format";
        license = stdenv.lib.licenses.bsd3;
@@ -41278,7 +41410,7 @@ self: {
      mkDerivation {
        pname = "ddc-base";
        version = "0.4.1.3";
-       sha256 = "1v3qkvfcajr8ljnrkmdpkhp6069b54fg168ryknq4b7rkl4piqfm";
+       sha256 = "d5e178099df92c82edf41999f01c292b19602e9cb7d599ada4284bc5dc9e78ec";
        libraryHaskellDepends = [
          base containers deepseq parsec transformers wl-pprint
        ];
@@ -41297,7 +41429,7 @@ self: {
      mkDerivation {
        pname = "ddc-build";
        version = "0.4.1.3";
-       sha256 = "15bjdr9g48p1ahga9qc1cgfbpr89551yaqx9psa44da0vy468fjs";
+       sha256 = "5a3a6488df40354294bea963e5432909e5bbdc6381e1a41e54e122f2526e7295";
        libraryHaskellDepends = [
          base containers ddc-base ddc-core ddc-core-eval ddc-core-flow
          ddc-core-llvm ddc-core-salt ddc-core-simpl ddc-core-tetra
@@ -41315,7 +41447,7 @@ self: {
      mkDerivation {
        pname = "ddc-code";
        version = "0.4.1.3";
-       sha256 = "1m904n1s2cszakjrlz81y1gplrgfv3np2ja0m6fapj9c2yyfmg6r";
+       sha256 = "d9bceabc172cc9ab9ca9404971edd8ee657a5ff0017d9ae5545f33a1832520d5";
        libraryHaskellDepends = [ base filepath ];
        jailbreak = true;
        homepage = "http://disciple.ouroborus.net";
@@ -41330,7 +41462,7 @@ self: {
      mkDerivation {
        pname = "ddc-core";
        version = "0.4.1.3";
-       sha256 = "15a51cgk3pqsbmy6hv0jrf8ldxmb0kvzd0pwkqa6141phk2g1dd5";
+       sha256 = "a5b5f0c484379060149efc82f6f704abf64691cb126c687c5d1adf311f0b4595";
        libraryHaskellDepends = [
          array base containers ddc-base deepseq directory mtl transformers
        ];
@@ -41348,7 +41480,7 @@ self: {
      mkDerivation {
        pname = "ddc-core-eval";
        version = "0.4.1.3";
-       sha256 = "0s11wzl75fa4pnjclgqdvymddk8srpknvpf6p3vkm2b09y0fryxd";
+       sha256 = "adfbec804f60893af7b8c6dd6de7cd1acdd6aadf0d3fcaa4bd44b972e8e72168";
        libraryHaskellDepends = [
          array base containers ddc-base ddc-core deepseq mtl transformers
        ];
@@ -41366,7 +41498,7 @@ self: {
      mkDerivation {
        pname = "ddc-core-flow";
        version = "0.4.1.3";
-       sha256 = "1szy9x5pc2l5ib8sbkajj6i7nfb46ypgi655wy0jrcnp7m2q22fy";
+       sha256 = "de0981453dd7b22c81e7a598f8ae3764397ba29152cda5d18a850a764b4ffeeb";
        libraryHaskellDepends = [
          array base containers ddc-base ddc-core ddc-core-salt
          ddc-core-simpl deepseq mtl transformers
@@ -41385,7 +41517,7 @@ self: {
      mkDerivation {
        pname = "ddc-core-llvm";
        version = "0.4.1.3";
-       sha256 = "0f0cby09lqhvw5ajm6q25qg57qbb4h3qvqwv30bzl6kw0884lkb5";
+       sha256 = "654d4a10027c1afa17189be38d07246be1531e2e029b2a55e11b629a805f0c38";
        libraryHaskellDepends = [
          array base containers ddc-base ddc-core ddc-core-salt
          ddc-core-simpl mtl transformers
@@ -41404,7 +41536,7 @@ self: {
      mkDerivation {
        pname = "ddc-core-salt";
        version = "0.4.1.3";
-       sha256 = "18cywxp3zp6aafpq8si1vvqy7lywwl31mdp58asyzcwi1g1v7y7q";
+       sha256 = "f8f8b3c30b91b3efb542e5b61a06e5dcd3e3f1de216a84af53cadc3f6ee79ea1";
        libraryHaskellDepends = [
          array base containers ddc-base ddc-core deepseq mtl transformers
        ];
@@ -41422,7 +41554,7 @@ self: {
      mkDerivation {
        pname = "ddc-core-simpl";
        version = "0.4.1.3";
-       sha256 = "0y3rxcl2h6dqmy367zfri1r21flcbygvrpa7sj8cr8gh128xwbbz";
+       sha256 = "7f2dde9108f0a1cc90d447ddbc9f5f8cba207288d9fd6386afb8192828eb7978";
        libraryHaskellDepends = [
          array base containers ddc-base ddc-core deepseq mtl transformers
        ];
@@ -41440,7 +41572,7 @@ self: {
      mkDerivation {
        pname = "ddc-core-tetra";
        version = "0.4.1.3";
-       sha256 = "01ax5dirrf8jk03316dw1cnrs9fl5qlm8k07nb0rzxwybm3wqdv2";
+       sha256 = "6237cc475d9ef79fc1b2074c54292ed4259d2d0bbc9930069812b99c632b5d05";
        libraryHaskellDepends = [
          array base containers ddc-base ddc-core ddc-core-salt
          ddc-core-simpl deepseq mtl transformers
@@ -41461,7 +41593,7 @@ self: {
      mkDerivation {
        pname = "ddc-driver";
        version = "0.4.1.3";
-       sha256 = "0iyvmifnj05v9r2sh867dm2vgm8hijsxf6bmzrksj1kcs36qwrrk";
+       sha256 = "33678ecdd06c06a967fe7519d7b58c10d5b7456dc720a8454ebb00695dacdb47";
        libraryHaskellDepends = [
          base containers ddc-base ddc-build ddc-core ddc-core-eval
          ddc-core-flow ddc-core-llvm ddc-core-salt ddc-core-simpl
@@ -41480,7 +41612,7 @@ self: {
      mkDerivation {
        pname = "ddc-interface";
        version = "0.4.1.3";
-       sha256 = "0pbsnxzlbx9xblqf9199wrl80aard59l3193gm8gzxx7ispfhs3f";
+       sha256 = "6e68e8ae8ea7f7ff507d238541536959298068e62985e4305d3df5457fb77a5d";
        libraryHaskellDepends = [ base containers ddc-base directory ];
        jailbreak = true;
        homepage = "http://disciple.ouroborus.net";
@@ -41495,7 +41627,7 @@ self: {
      mkDerivation {
        pname = "ddc-source-tetra";
        version = "0.4.1.3";
-       sha256 = "088lsavx4fhyxyxzxd4vj1880j19r4l4fvlb4dly42mbyfrg5jrs";
+       sha256 = "3acbf2b2f3ab0ae269238b6e4728c929488050909bb4febbef1e3ad2b7d21421";
        libraryHaskellDepends = [
          array base containers ddc-base ddc-core ddc-core-salt
          ddc-core-tetra deepseq mtl transformers
@@ -41517,7 +41649,7 @@ self: {
      mkDerivation {
        pname = "ddc-tools";
        version = "0.4.1.3";
-       sha256 = "1hg6hajqrb7sf8bvr27cabdxalwvkw8lm2igsx05p9wq4bpirz62";
+       sha256 = "c2fc1cef2298a75b40d72f8a4a119f9b53d5db52ec88bc1772faac8ca582e6c1";
        isLibrary = false;
        isExecutable = true;
        executableHaskellDepends = [
@@ -41540,7 +41672,7 @@ self: {
      mkDerivation {
        pname = "ddc-war";
        version = "0.4.1.3";
-       sha256 = "0y9h4z1drgwgmw9wjf8ga2kiagmfgppdy29l9cz0j4rjz3mm302y";
+       sha256 = "5e8051ebf83213093e4b3409dfee7dae3e15a7500f39c913af8fbfdcc2273079";
        isLibrary = false;
        isExecutable = true;
        executableHaskellDepends = [
@@ -41559,7 +41691,7 @@ self: {
      mkDerivation {
        pname = "ddci-core";
        version = "0.2.1.2";
-       sha256 = "1w4kcqivphc9gmj4xnkqx2hbzd3cmssww5hqgja1kh0b03q026w0";
+       sha256 = "801b01f0000bc019947c1816ceb5ae6cb4bfa0e878da4e647d89c1bb236693f0";
        isLibrary = false;
        isExecutable = true;
        executableHaskellDepends = [
@@ -41580,7 +41712,7 @@ self: {
      mkDerivation {
        pname = "dead-simple-json";
        version = "0.1.2";
-       sha256 = "10wp97pxhkvlk3lhknvsnwkl9p7lm1v7y1wk0nn55q68jx1b5zpr";
+       sha256 = "f9feb24297c8e052ac0593077f76a8f4dc4427b77adb09e998744fd8ef499783";
        libraryHaskellDepends = [
          base containers parsec template-haskell transformers vector
        ];
@@ -41600,7 +41732,7 @@ self: {
      mkDerivation {
        pname = "debian";
        version = "3.87.2";
-       sha256 = "135f0szbnn8xp5zzfmlqcpmsrswahgc4rlgviyznfx6c4j7hg519";
+       sha256 = "2994078f24cc7467bf8ffbd14cd8838aebaceb659856f77fb91d59bbbe06ae8c";
        isLibrary = true;
        isExecutable = true;
        libraryHaskellDepends = [
@@ -41624,7 +41756,7 @@ self: {
      mkDerivation {
        pname = "debian-binary";
        version = "0.0.1";
-       sha256 = "0k6blaq1p2phydl4pqlqg6kdicrfjhm6h27svws7dq8di3y274fq";
+       sha256 = "d89123fc880de17634dffa08682a942eb3d8a67998e24b68f3f08a1bb0a2cb4c";
        isLibrary = true;
        isExecutable = true;
        libraryHaskellDepends = [ base directory filepath HSH ];
@@ -41639,7 +41771,7 @@ self: {
      mkDerivation {
        pname = "debian-build";
        version = "0.7.2.1";
-       sha256 = "1x3jvrz5y85m9mnp5b8b85f4magbxa4r0yhkw30vgcljph6v7mfm";
+       sha256 = "d5d5b30dbc92b2b7c1e0137a9089eaeba94a5c410bad726d4db5205f7ede72f4";
        isLibrary = true;
        isExecutable = true;
        libraryHaskellDepends = [
@@ -41656,7 +41788,7 @@ self: {
      mkDerivation {
        pname = "debug-diff";
        version = "0.1";
-       sha256 = "19k9f92pjh52qnr31l0468hn2klkb8wszs7azwczvxzg8aq7krld";
+       sha256 = "8de679b042eff7fd19ffeae8af395a934e61213204d030b2c5a24079457269a6";
        libraryHaskellDepends = [ base groom process temporary ];
        description = "Display a colorized diff between two Haskell values";
        license = stdenv.lib.licenses.bsd3;
@@ -41667,7 +41799,7 @@ self: {
      mkDerivation {
        pname = "decepticons";
        version = "0.1.0.0";
-       sha256 = "1fnp2c2rdpihvxm5j22z1mrf8pnpcnasvfsrlg7lvg5m76md7k3v";
+       sha256 = "7bccd3aa39b5bc4dcfa359bbad9565d75ee4720d5f08596adf30de960513d7ba";
        libraryHaskellDepends = [ base comonad-transformers ];
        jailbreak = true;
        description = "The categorical dual of transformers";
@@ -41681,7 +41813,7 @@ self: {
      mkDerivation {
        pname = "decode-utf8";
        version = "1.2";
-       sha256 = "10mj871j5gd4d8v8341lr5lr9avxxfph58sjhmd9kgywc10grqph";
+       sha256 = "f0e2fc4060dcbf995a8552a302afeb7dab9469c9349081366aa4bd22c341b282";
        isLibrary = false;
        isExecutable = true;
        executableHaskellDepends = [
@@ -41696,7 +41828,7 @@ self: {
      mkDerivation {
        pname = "decoder-conduit";
        version = "0.0.1.1";
-       sha256 = "0z5krcl4xd385f7v2bsnfyr7zidqwfjvc6b432gbbn2vcrx966c7";
+       sha256 = "8719937a665bd8b59e186419b6a5e3b8c57fb277562fb18f2b68b44e28cbb37c";
        libraryHaskellDepends = [ base binary bytestring conduit ];
        jailbreak = true;
        homepage = "https://github.com/hansonkd/decoder-conduit";
@@ -41713,7 +41845,7 @@ self: {
      mkDerivation {
        pname = "dedukti";
        version = "1.1.4";
-       sha256 = "0b7328529m3xl8bj7sncv5rr13ld2aghgqkf55j4n15jagv6g72d";
+       sha256 = "4d9c67f653b2044b64296ee2079f128d8e9073d9ccea2317a27dd4240a12e32c";
        isLibrary = true;
        isExecutable = true;
        libraryHaskellDepends = [ time unix ];
@@ -41737,7 +41869,7 @@ self: {
      mkDerivation {
        pname = "deeplearning-hs";
        version = "0.1.0.2";
-       sha256 = "1cw29xisgykb20qv3jkpcpaiijicyzkfsgglrsbx1admfzbqv98d";
+       sha256 = "0da58dd777b5a9d097cef43dede6f72cca18d56577cab131106bfaa7634f82b3";
        isLibrary = true;
        isExecutable = true;
        libraryHaskellDepends = [
@@ -41762,7 +41894,7 @@ self: {
      mkDerivation {
        pname = "deepseq";
        version = "1.3.0.1";
-       sha256 = "068zka6rwprbzpx7yisi1ajsxdly23zaf2vjklx1wp66yypx54lp";
+       sha256 = "9792d2aff7c65c1e3a9d720ba7fe109eb6aea50a51477ffafd2b5f9e8d9a1f19";
        libraryHaskellDepends = [ array base ];
        jailbreak = true;
        description = "Deep evaluation of data structures";
@@ -41776,7 +41908,7 @@ self: {
      mkDerivation {
        pname = "deepseq";
        version = "1.4.1.1";
-       sha256 = "1gxk6bdqfplvq0lma2sjcxl8ibix5k60g71dncpvwsmc63mmi0ch";
+       sha256 = "908158eb30ac6abe2fb32d9c07cc2c3dae886867520b5529c09b5e87db32b3bf";
        libraryHaskellDepends = [ array base ];
        testHaskellDepends = [
          array base HUnit test-framework test-framework-hunit
@@ -41793,7 +41925,7 @@ self: {
      mkDerivation {
        pname = "deepseq-bounded";
        version = "0.8.0.0";
-       sha256 = "192hqyidgbrsig2yx7x9vdx180w1jfcqxsgg4wslwfwj7d3sa81f";
+       sha256 = "2e20a5473b923b4e3527efe98e99938103147adba99feec58b3aafd7a2c750a4";
        libraryHaskellDepends = [
          array base cpphs deepseq deepseq-generics generics-sop mtl parallel
          random syb
@@ -41816,7 +41948,7 @@ self: {
      mkDerivation {
        pname = "deepseq-generics";
        version = "0.1.1.2";
-       sha256 = "01pvigx8n9p8hwbzp2qiq6kzf7cxiam843jz2sjgliacmmp1v7l3";
+       sha256 = "839e1d6ead4c45faa4165f0e82aa8a9d1df7a7c1118bfb1787e8268bfa8bfb06";
        revision = "1";
        editedCabalFile = "3f52867fe9267876504d8ce20c77dcfb2ac6613af8c915017859b6022d3cc9fd";
        libraryHaskellDepends = [ base deepseq ghc-prim ];
@@ -41833,7 +41965,7 @@ self: {
      mkDerivation {
        pname = "deepseq-magic";
        version = "1.0.0.3";
-       sha256 = "15nisjmhcfippz153b8l8f291halkgbrync5c2v6xwkh07ibn7yp";
+       sha256 = "d71fbbe20170f26eb66085599fd79b54c190844314ad51c2bf373a06abd4d196";
        libraryHaskellDepends = [ base ];
        homepage = "https://github.com/ezyang/deepseq-magic";
        description = "Deep evaluation of data structures without NFData";
@@ -41845,7 +41977,7 @@ self: {
      mkDerivation {
        pname = "deepseq-th";
        version = "0.1.0.4";
-       sha256 = "12wk8higrp12b22zzz1b4ar1q5h7flk22bp2rvswsqri2zkbi965";
+       sha256 = "c5a4b8e6173163cdf5cee22e21267507161cb2222bfcff855822dcfc2244938b";
        libraryHaskellDepends = [ base deepseq template-haskell ];
        testHaskellDepends = [ base deepseq template-haskell ];
        jailbreak = true;
@@ -41859,7 +41991,7 @@ self: {
      mkDerivation {
        pname = "deepzoom";
        version = "0.1";
-       sha256 = "1hisk6yfq4182ak7d1mi1kmnwwlcl8w7gwc8wqkq4l8m3zfyij8k";
+       sha256 = "13c9e8dd1f15518227e688f17738a28c726eeb0cb18676a6122810ecbc993ac2";
        libraryHaskellDepends = [ base directory filepath hsmagick ];
        description = "A DeepZoom image slicer. Only known to work on 32bit Linux";
        license = stdenv.lib.licenses.bsd3;
@@ -41871,7 +42003,7 @@ self: {
      mkDerivation {
        pname = "defargs";
        version = "0.3";
-       sha256 = "1rz37w83awji034spyv4cnfbqb6r98r1bbvzh2i979qh5c5s6ckg";
+       sha256 = "6f32a30b2b10a793a2807faf15324ad92cbc9c6564fbabc900517235103fe3e7";
        libraryHaskellDepends = [ base cluss ];
        homepage = "https://github.com/Kinokkory/defargs";
        description = "default arguments in haskell";
@@ -41886,7 +42018,7 @@ self: {
      mkDerivation {
        pname = "definitive-base";
        version = "2.3";
-       sha256 = "126ln7k6k188xjnig60ksc425fp3hql5znb98h5c1w157jgg0sw9";
+       sha256 = "896bf09e3c25f0c00a4469d95f2886e3ba2208d3139817adec088569e6b1d488";
        libraryHaskellDepends = [
          array base bytestring containers deepseq ghc-prim GLURaw OpenGL
          OpenGLRaw primitive vector
@@ -41906,7 +42038,7 @@ self: {
      mkDerivation {
        pname = "definitive-filesystem";
        version = "1.2";
-       sha256 = "0bc098igiqzbm25bjaxdxm4jq17kc8bgz1ab0pgm0h5jvy1bf8id";
+       sha256 = "2d22b782dfb24050df054b85ff1662f3042c49edad2bb98aa8ebe3f8224a802d";
        revision = "1";
        editedCabalFile = "3a78d4d8aaa291ca95d889b62a979c4132bbe6f91073ab2bd9fdb0d55ed63121";
        libraryHaskellDepends = [
@@ -41930,7 +42062,7 @@ self: {
      mkDerivation {
        pname = "definitive-graphics";
        version = "1.2";
-       sha256 = "0ah19j2al9l6pbin821rsicidmg3rd4cc74r8qw095773sa98zyr";
+       sha256 = "d97f94941ee794043846991cc648cbe3d51659d4390864e3ba8626aa844c012a";
        revision = "1";
        editedCabalFile = "a6d867ea8098390daff40c088c81f854ca054f9a0c8b097f9194be329416baed";
        libraryHaskellDepends = [
@@ -41954,7 +42086,7 @@ self: {
      mkDerivation {
        pname = "definitive-parser";
        version = "2.1";
-       sha256 = "0sl77xgk7vjn69mx89k4f3yviz821mg01fga0klqplcccbkzknmh";
+       sha256 = "b0daf9e7628cd18be904eab9005e0d02fdb8fd706426d46b3256ee335f3f876a";
        libraryHaskellDepends = [
          array base bytestring containers cpu deepseq definitive-base
          ghc-prim GLURaw OpenGL OpenGLRaw primitive utf8-string vector
@@ -41973,7 +42105,7 @@ self: {
      mkDerivation {
        pname = "definitive-reactive";
        version = "1.0";
-       sha256 = "0gk39602k5yjxxgpd725dnvqhlcnaqgds7g0c8v1h509lc0d7xm3";
+       sha256 = "a3f6d300a30914183662e01ddd1e56965188b76d459c765fefd297298049633e";
        revision = "1";
        editedCabalFile = "8c3c6afcc4ce7569ede32c8006d1d66fb10448321159f875d1dec03419bd7797";
        libraryHaskellDepends = [
@@ -41995,7 +42127,7 @@ self: {
      mkDerivation {
        pname = "definitive-sound";
        version = "1.0";
-       sha256 = "01k4h7av4fhp4xchrcbnc1gnnbsh5ngasq55l16n3l438pr73vzj";
+       sha256 = "f2ef71f24583d0614da0a560ad9e2d502f6b5f6076b10c5927173ab2d5816406";
        revision = "1";
        editedCabalFile = "1491f0a01f47b84ea8f01a94492738a7f3b5fe7c68c805cca8701926cc443d71";
        libraryHaskellDepends = [
@@ -42016,7 +42148,7 @@ self: {
      mkDerivation {
        pname = "deiko-config";
        version = "0.5.0.0";
-       sha256 = "0zhi173mm905aqh52fsw1c9y3hxk07yc1g2s0rrjr75cdl7ssljy";
+       sha256 = "5e52ad0f6dac9c2c73065abcc0fc01b3c3e1130b5c3b51205605a45ac709117e";
        libraryHaskellDepends = [
          array base containers exceptions mtl parsec text transformers
        ];
@@ -42031,7 +42163,7 @@ self: {
      mkDerivation {
        pname = "deka";
        version = "0.6.0.2";
-       sha256 = "1l23b5v0wjg72vlnyxa87v3j2dxbld536ws8j03ddcwgqgws1fj4";
+       sha256 = "44baa0f9c38fb3d606904873334aa3ab3721c73e48756fe916e7490e765943d0";
        libraryHaskellDepends = [ base bytestring parsec transformers ];
        librarySystemDepends = [ mpdec ];
        jailbreak = true;
@@ -42048,7 +42180,7 @@ self: {
      mkDerivation {
        pname = "deka-tests";
        version = "0.6.0.2";
-       sha256 = "08226vca64v8brcgci8a3s5fnf4qy8g9drk3lzzd0dq6g8yvypy9";
+       sha256 = "c95fbf3d7a0637d0fea763e6961ef29838eb8a1e0a45f6585e6813a3d8364220";
        isLibrary = true;
        isExecutable = true;
        libraryHaskellDepends = [ base bytestring deka QuickCheck ];
@@ -42071,7 +42203,7 @@ self: {
      mkDerivation {
        pname = "delaunay";
        version = "0.1.0.2";
-       sha256 = "145a220kv3fk2lk6jpvqmmhwmbgiqzkcbsi5hynsg196chydxgvd";
+       sha256 = "6dbfde3c642685a7ad8725eac5e6c7f1adca61ad785f692615d38d3d8110aa90";
        libraryHaskellDepends = [
          AC-Vector base hashable unordered-containers
        ];
@@ -42087,7 +42219,7 @@ self: {
      mkDerivation {
        pname = "delicious";
        version = "0.3.4";
-       sha256 = "1dx2y2ggzcwcjs618jmg21342pcd0maqx8pj2hwv80zq6f5v0c50";
+       sha256 = "a030b08b33f803b43914f2a28e55058d5d414610af4a148c968cb3ff9ef0a2b7";
        libraryHaskellDepends = [
          base bytestring curl feed json nano-md5 xml
        ];
@@ -42104,7 +42236,7 @@ self: {
      mkDerivation {
        pname = "delimited-text";
        version = "0.3.0";
-       sha256 = "0mn6sv4nm3wbzq5cc9s9kb3xbm9jd5i059xr6qr9mqxa18j78c05";
+       sha256 = "053074240aaae39a3236b9a702626932d5d5c79a4927c60afe8b8f6ac9d6c656";
        libraryHaskellDepends = [
          attoparsec base binary bytestring bytestring-show
        ];
@@ -42120,7 +42252,7 @@ self: {
      mkDerivation {
        pname = "delta";
        version = "0.2.1.2";
-       sha256 = "0r2a2vffs3rn2xp56nhanyywzbm2wph5664spgj4lbsna6zgjnfj";
+       sha256 = "d259f9be51562f4ae4bb9a1853e0e5a2aecfbdb70a5a536e17360feddc164a64";
        revision = "2";
        editedCabalFile = "630e85a07132fe54b49c71f855b3d633982026d78120279e00888bc95a9d14dd";
        isLibrary = true;
@@ -42144,7 +42276,7 @@ self: {
      mkDerivation {
        pname = "delta-h";
        version = "0.0.3";
-       sha256 = "0ya0hgvpa9w41gswngg84yxhvll3fyr6b3h56p80yc5bldw700wg";
+       sha256 = "8f037078a3ab300fd035058e65b27783d20dbb27e83dcbf50b842775f7834079";
        isLibrary = true;
        isExecutable = true;
        libraryHaskellDepends = [
@@ -42164,7 +42296,7 @@ self: {
      mkDerivation {
        pname = "demarcate";
        version = "0.1.0";
-       sha256 = "130yk7461rwmjgzivsya10xzh0d0ca8pfkxh7fpll239r7xlbds3";
+       sha256 = "43b745fbc969084aaf3bb04f779162a001f83b08caeb1dff9395e760c8991e8c";
        libraryHaskellDepends = [ base free transformers ];
        testHaskellDepends = [ base hspec ];
        homepage = "https://github.com/fizruk/demarcate";
@@ -42178,7 +42310,7 @@ self: {
      mkDerivation {
        pname = "denominate";
        version = "0.5.0";
-       sha256 = "06jdr1236wlsmapwn6hdmjl41qlig7ck541lynyds0qd6ymcb9k1";
+       sha256 = "61a6c5aa370d03ddbcf5349032d97991e240a8ac0d1acbafaa9a723344c84d1a";
        isLibrary = true;
        isExecutable = true;
        libraryHaskellDepends = [ base directory filepath ];
@@ -42195,7 +42327,7 @@ self: {
      mkDerivation {
        pname = "dependent-map";
        version = "0.1.1.3";
-       sha256 = "1by83rrv8dfn5lxrpx3qzs1lg31fhnzlqy979h8ampyxd0w93pa4";
+       sha256 = "44dd913868dddfaa104c27794cbf852e8c4783fe78f49b3b2dd635b4731ec8af";
        libraryHaskellDepends = [ base containers dependent-sum ];
        homepage = "https://github.com/mokus0/dependent-map";
        description = "Dependent finite maps (partial dependent products)";
@@ -42207,7 +42339,7 @@ self: {
      mkDerivation {
        pname = "dependent-sum";
        version = "0.2.1.0";
-       sha256 = "1h6wsrh206k6q3jcfdxvlsswbm47x30psp6x30l2z0j9jyf7jpl3";
+       sha256 = "835e799c9749822f2818dd5c7dc1e887d4c5b5a6bb37c7e4c0661a2060d6dcc0";
        libraryHaskellDepends = [ base ];
        homepage = "https://github.com/mokus0/dependent-sum";
        description = "Dependent sum type";
@@ -42220,7 +42352,7 @@ self: {
      mkDerivation {
        pname = "dependent-sum-template";
        version = "0.0.0.4";
-       sha256 = "103jxzzw3drg7pkgmh39s7258zcwr8ixg8mijm6p33b87a8wdpwr";
+       sha256 = "99dfc6913a688d714d95b1a2d723ca9c7d54c4d169c0fae63d2fb7c1ffef7280";
        libraryHaskellDepends = [
          base dependent-sum template-haskell th-extras
        ];
@@ -42236,7 +42368,7 @@ self: {
      mkDerivation {
        pname = "depends";
        version = "0.0.1";
-       sha256 = "0y43bhxx5s4v72gc0y1cwfy2h4hyz9x5cab2fbkd7rvj5wn4w4gq";
+       sha256 = "f8114e2c2f72e7d3e6726229567afa1e1228bce32c78c09e389be8d23b5c8378";
        isLibrary = false;
        isExecutable = true;
        executableHaskellDepends = [
@@ -42258,7 +42390,7 @@ self: {
      mkDerivation {
        pname = "dephd";
        version = "0.1.6";
-       sha256 = "0qgqlnj7wkmjba5f2rql51g9jhak0ksx3xdmr25j3p6qwb43k5ih";
+       sha256 = "309639c8e2d8dc218bc8b5f5d1f5045341995e281467e18a5ab24e7ea4a5f861";
        isLibrary = false;
        isExecutable = true;
        executableHaskellDepends = [
@@ -42275,7 +42407,7 @@ self: {
      mkDerivation {
        pname = "dequeue";
        version = "0.1.5";
-       sha256 = "1z4c3hyk1lbjqm5is1d9qb6sxwv8i870ph7n2h51r631mhxbdnxl";
+       sha256 = "b4dbb63aac61981c0a14f6c00b0e8a68f3aecdc2a9051d4bc572d1303d1c8cfc";
        isLibrary = true;
        isExecutable = true;
        libraryHaskellDepends = [ base QuickCheck safe ];
@@ -42290,7 +42422,7 @@ self: {
      mkDerivation {
        pname = "derangement";
        version = "0.1.0";
-       sha256 = "13w257bndjpaz7fiz4g2w4v2bmlch07ay5pxxv5ifc4llh665ch0";
+       sha256 = "00b2620ca4943017cbeefd16af0e808cd62536e1e2911fddf9eaca66d729828f";
        libraryHaskellDepends = [ base fgl ];
        description = "Find derangements of lists";
        license = "GPL";
@@ -42302,7 +42434,7 @@ self: {
      mkDerivation {
        pname = "derivation-trees";
        version = "0.7.3";
-       sha256 = "05f77vkqzia91rywkg68ad24j98a7h9aqkd0568x2zmqcndzbisy";
+       sha256 = "5ec7f59b65b87ed19129a04dac123c0a25494453c8bcc97d0e49c58fe73ec715";
        libraryHaskellDepends = [
          applicative-extras base labeled-tree mtl
        ];
@@ -42320,7 +42452,7 @@ self: {
      mkDerivation {
        pname = "derive";
        version = "2.5.22";
-       sha256 = "0g2grz9y23n8g4wwjinx5cc70aawswl84i3njgj6l1fl29fk1yf2";
+       sha256 = "c2f9305d12d4056ae49376448228d75c2970182bdd46c93979c80ee1d3cf4f3c";
        isLibrary = true;
        isExecutable = true;
        libraryHaskellDepends = [
@@ -42337,7 +42469,7 @@ self: {
      mkDerivation {
        pname = "derive-IG";
        version = "0.1.1";
-       sha256 = "0bggj2jb3bbgxcz75v8q2yx29v88skiwjaj3fxkkynnv5zvrbgwr";
+       sha256 = "99bf95f72fdb5a3f6777432ac9e3d408ed24ba1718ed723eeb6fadb1a490ef2d";
        libraryHaskellDepends = [ base instant-generics template-haskell ];
        jailbreak = true;
        homepage = "http://github.com/konn/derive-IG";
@@ -42351,7 +42483,7 @@ self: {
      mkDerivation {
        pname = "derive-enumerable";
        version = "0.1.1.0";
-       sha256 = "08zhyn9xcmhrrnh7y2a1r7v4nmgm2af0d41ns0wjqais67rzsxsp";
+       sha256 = "5777fdf3313a2a2c39d03690069c12f5554bf6c941097fa0cd1956d693f5f023";
        libraryHaskellDepends = [ base data-default ];
        jailbreak = true;
        homepage = "https://github.com/mgoszcz2/derive-enumerable";
@@ -42366,7 +42498,7 @@ self: {
      mkDerivation {
        pname = "derive-gadt";
        version = "0.1.1";
-       sha256 = "0s6vb3b3chf1gy44a6zsi2z19d6snk12qlk4v8q2smipmj42v7d6";
+       sha256 = "a69d2d88ac37562d30da64522cc2b4dab414be88fa1b45887fc14136d658db68";
        isLibrary = true;
        isExecutable = true;
        libraryHaskellDepends = [
@@ -42389,7 +42521,7 @@ self: {
      mkDerivation {
        pname = "derive-topdown";
        version = "0.0.0.2";
-       sha256 = "0gdalqq1ks9jjp34kzavlx2ncpdad2pf6vdhx64yii5l2nl04r8p";
+       sha256 = "176502a815b4c4e889e9b06de3ae68aa5d6645a75bfd49c69532e91930a6aa3d";
        libraryHaskellDepends = [
          base derive mtl template-haskell template-haskell-util
        ];
@@ -42404,7 +42536,7 @@ self: {
      mkDerivation {
        pname = "derive-trie";
        version = "0.2.1";
-       sha256 = "11c378mh5razibd9ljffm5353v4plrgvkfb62p6029f04sf29jnc";
+       sha256 = "ccca249c26c02501cc1566b9b95fa697ec5146a9ce499ada8a5fe5022b3a8385";
        libraryHaskellDepends = [ array base containers template-haskell ];
        jailbreak = true;
        homepage = "http://github.com/baldo/derive-trie";
@@ -42420,7 +42552,7 @@ self: {
      mkDerivation {
        pname = "deriving-compat";
        version = "0.1";
-       sha256 = "1v503lj9dds1hwnqhmw8rfbj9337gcyqqzys1d93r7s0bs3glgf3";
+       sha256 = "c33dfa865e409f3c520bda7f8c3d7b678c2497cb8857882d8741b796241da0ec";
        libraryHaskellDepends = [
          base containers ghc-prim template-haskell
        ];
@@ -42435,7 +42567,7 @@ self: {
      mkDerivation {
        pname = "derp";
        version = "0.1.6";
-       sha256 = "0g8y98qjjampbwnxhvjzrs2jczh2mcwsacjq95jxpidgsld00shk";
+       sha256 = "136a001ad5afc5db65495832a539ab027e2685ce5f6ed82d5fb72a29314a1e3d";
        libraryHaskellDepends = [ base containers ];
        description = "Derivative Parsing";
        license = stdenv.lib.licenses.bsd3;
@@ -42446,7 +42578,7 @@ self: {
      mkDerivation {
        pname = "derp-lib";
        version = "0.0.0.1";
-       sha256 = "0j883w01k9scz6cfxljkw9s2kgs9f7vdxyyxxhlvvkgzb0050v0x";
+       sha256 = "1d6c500058ffcdbd29ecddfbdef67149bf2974e253d2ee98f94ca719001f0849";
        libraryHaskellDepends = [ base derp ];
        homepage = "http://darcsden.com/kyagrd/derp-lib";
        description = "combinators based on parsing with derivatives (derp) package";
@@ -42459,7 +42591,7 @@ self: {
      mkDerivation {
        pname = "descrilo";
        version = "0.1.0.3";
-       sha256 = "19x78lv6rd5i5xvqj92q5snly1579jiiw2fgmxzxza0km9j9yiw2";
+       sha256 = "82479f64aa13a8df7fafcf091ea34ca7044fad2e582489772fb1b46c3645a7a7";
        libraryHaskellDepends = [ base ];
        description = "Loads a list of items with fields";
        license = stdenv.lib.licenses.gpl3;
@@ -42472,7 +42604,7 @@ self: {
      mkDerivation {
        pname = "descriptive";
        version = "0.0.2";
-       sha256 = "0jh0l4assmqsmq9ajsbdl7vn8k6srl0z27kpxwzg1v0nmkkcl48p";
+       sha256 = "1711cae6ac16ecf03eef771ef101cdda4c64f7a16d69a912ae1a57ad15a1004a";
        revision = "3";
        editedCabalFile = "0aeae1dd5ab8c21ade57c1e036600b8162cd790823618a9c5894417ba68e2ea2";
        libraryHaskellDepends = [
@@ -42490,7 +42622,7 @@ self: {
      mkDerivation {
        pname = "descriptive";
        version = "0.9.4";
-       sha256 = "0bxskc4q6jzpvifnhh6zl77xic0fbni8abf9lipfr1xzarbwcpkr";
+       sha256 = "795ec65756bf87ec6ea4c92d85a25d0eb0d8cfa1df40685ddcf74b83099bba2f";
        libraryHaskellDepends = [
          aeson base bifunctors containers mtl scientific text transformers
          vector
@@ -42508,7 +42640,7 @@ self: {
      mkDerivation {
        pname = "despair";
        version = "0.0.2";
-       sha256 = "1dwhp1izikvj1qfz6shvnl4q519vgjpnfmkwkj8zp875dki87pnj";
+       sha256 = "d2de83e26ce5a0fb919c7c5667af7c3b858209b51b6af31d0e72cff863b890b7";
        libraryHaskellDepends = [ base random ];
        description = "Despair";
        license = stdenv.lib.licenses.bsd3;
@@ -42519,7 +42651,7 @@ self: {
      mkDerivation {
        pname = "deterministic-game-engine";
        version = "0.4.0";
-       sha256 = "1hdwr1vxfng3yc9mdnnsraapikq9kq1c07ik16csgp2ggnhgpprs";
+       sha256 = "3adffba07d4fdca79909331ec0029e09cf7895cadada5613f3e359d777c8bcc1";
        libraryHaskellDepends = [ base mtl ];
        testHaskellDepends = [ base hspec ];
        homepage = "https://github.com/TGOlson/deterministic-game-engine";
@@ -42534,7 +42666,7 @@ self: {
      mkDerivation {
        pname = "detrospector";
        version = "0.3";
-       sha256 = "0fsdbagj9zhbm6hh5rsjgz3iq1raxkljnr65ba506nwxmc052xcn";
+       sha256 = "96755100ab9d5b038a5ac5642be9ec2a071cc77f52e702a1a90bfe249f5a4d3b";
        isLibrary = false;
        isExecutable = true;
        executableHaskellDepends = [
@@ -42550,7 +42682,7 @@ self: {
      mkDerivation {
        pname = "deunicode";
        version = "0.1";
-       sha256 = "08skd630jj9h3mlxm86s7qkdrpcwhknk21dmlj69126dn67v159f";
+       sha256 = "2e95b08fb1cd88908ca4b50531ed849cdddc263edaa0da691d30490986695323";
        isLibrary = false;
        isExecutable = true;
        executableHaskellDepends = [ base bytestring utf8-string ];
@@ -42566,7 +42698,7 @@ self: {
      mkDerivation {
        pname = "devil";
        version = "0.1.1.0";
-       sha256 = "1n5rzm40srakb0jv8j9gin6m15x5l37knmdckc4xhwvliyvllrf4";
+       sha256 = "c4654ab78f7473d8099bac553bcfa0a597508d8d2f49b4255853650d48fdb9d8";
        isLibrary = false;
        isExecutable = true;
        executableHaskellDepends = [
@@ -42583,7 +42715,7 @@ self: {
      mkDerivation {
        pname = "dewdrop";
        version = "0.1";
-       sha256 = "1xi78d31hljbybpm3jzs4l3g35sdfhmmm7ksivjdi91gv9m88l0n";
+       sha256 = "1650846ada2fa4d8e48e7a9e5a2b744d97f10625facb51eff24b5218464327f6";
        libraryHaskellDepends = [
          base bytestring containers elf hdis86 syb
        ];
@@ -42598,7 +42730,7 @@ self: {
      mkDerivation {
        pname = "dfrac";
        version = "0.1.2.0";
-       sha256 = "1ybq5bnh85dbr9lfx5d6qw87x9qc8fs0yvbi1a6860an13lvrzy7";
+       sha256 = "c7ffbce9085601838c0a716d0fb4430ca77e10c7a695ee68caab1504ed2a78f9";
        libraryHaskellDepends = [ base scientific ];
        description = "A package for precise decimal arithmatic using rationals";
        license = stdenv.lib.licenses.mit;
@@ -42612,7 +42744,7 @@ self: {
      mkDerivation {
        pname = "dfsbuild";
        version = "1.0.2";
-       sha256 = "0nh5cvb8macw523iids072rs9kylkv8zrliraw1jrvmhsznkj05x";
+       sha256 = "bd0039edd7b0ee2c035739d2fcd19ed4cfa4b33840b71887289ca98ad666055a";
        isLibrary = false;
        isExecutable = true;
        executableHaskellDepends = [
@@ -42629,7 +42761,7 @@ self: {
      mkDerivation {
        pname = "dgim";
        version = "0.0.3";
-       sha256 = "1brffyfawrdgr2659hbda42mpn9jiiq474a0yd57kj7z0dzq25f6";
+       sha256 = "c615817f03ffc8794af3409143708c32d95b05516dc1548cc8af65ae9c772eaf";
        libraryHaskellDepends = [ base ];
        testHaskellDepends = [ base Cabal QuickCheck ];
        jailbreak = true;
@@ -42644,7 +42776,7 @@ self: {
      mkDerivation {
        pname = "dgs";
        version = "0.2";
-       sha256 = "100xlxqhy33kllyb4dy7q0bwwy5wn9w45qy1cb5f0yb0dqff1pnx";
+       sha256 = "dddee01c6e6079e0ca62c1e34278b2bc78ce17c0c737b23ca5730c0f71a71d80";
        libraryHaskellDepends = [ base HTTP mtl network split ];
        jailbreak = true;
        homepage = "http://www.dmwit.com/dgs";
@@ -42658,7 +42790,7 @@ self: {
      mkDerivation {
        pname = "dia-base";
        version = "0.1.1.3";
-       sha256 = "1kx7dczabfklqpvbz7zcf1hhha8vrcbv35xl82fips02x0065b75";
+       sha256 = "e5ac6200e802e81b9d40b497b117cb1b29086170ec9fbff6c574baa53e6ba7cf";
        libraryHaskellDepends = [ base deepseq ];
        description = "An EDSL for teaching Haskell with diagrams - data types";
        license = stdenv.lib.licenses.bsd3;
@@ -42671,7 +42803,7 @@ self: {
      mkDerivation {
        pname = "dia-functions";
        version = "0.2.1.4";
-       sha256 = "14hfapfnfl2m9g8b6mdcmmq2fbyqgg14s0sagxbb8hhz47pznc27";
+       sha256 = "4730fbef211f42b4567f4a034dc27bd82f2770adac55b3d04b555067dd550e92";
        libraryHaskellDepends = [
          base containers data-pprint deepseq dia-base mtl xhtml
        ];
@@ -42686,7 +42818,7 @@ self: {
      mkDerivation {
        pname = "diagrams";
        version = "1.3";
-       sha256 = "1f5cpa2qjpzq9m8d3066iixbq414zk0pv1vajghb214a1w9sqaf9";
+       sha256 = "c929ac130f8a04b1e0936a877dc1fc2410bc7a8cc680d1504df85f8985baacb8";
        libraryHaskellDepends = [
          diagrams-contrib diagrams-core diagrams-lib diagrams-svg
        ];
@@ -42705,7 +42837,7 @@ self: {
      mkDerivation {
        pname = "diagrams-builder";
        version = "0.7.1.1";
-       sha256 = "1klmmh144bdwrg3zs45l6yy1li64r60jygqspxzyzlm8pfgzvgah";
+       sha256 = "50bdfd9fbba8d2ef7fbf1a3f2f81c9c4441abc37b410fdc7cbbc2d4202ac95ce";
        configureFlags = [ "-fcairo" "-fps" "-frasterific" "-fsvg" ];
        isLibrary = true;
        isExecutable = true;
@@ -42733,7 +42865,7 @@ self: {
      mkDerivation {
        pname = "diagrams-cairo";
        version = "1.3.0.3";
-       sha256 = "0962kz1b45hycjij90yxq88wa5qsdll82h16agzf0pm16j8r4v5s";
+       sha256 = "ba6c929134a15ee0fe53264081286d1a17c511c2dd8324a3641e16b2c29fc224";
        libraryHaskellDepends = [
          base bytestring cairo colour containers data-default-class
          diagrams-core diagrams-lib filepath hashable JuicyPixels lens mtl
@@ -42753,7 +42885,7 @@ self: {
      mkDerivation {
        pname = "diagrams-canvas";
        version = "1.3.0.2";
-       sha256 = "1jklgvkmdhg5ari577jh5y7vr54wjdwyz2hql1n1icbfba5d6p0c";
+       sha256 = "0c5cd38a5a6eb1186ca0188aef79939c94bc8f2f509e536256e5c156e77e74ca";
        libraryHaskellDepends = [
          base blank-canvas cmdargs containers data-default-class
          diagrams-core diagrams-lib lens mtl NumInstances
@@ -42776,7 +42908,7 @@ self: {
      mkDerivation {
        pname = "diagrams-contrib";
        version = "1.3.0.4";
-       sha256 = "0mr4m4kl028jxrjldn38kq7zsph6vqwzdjhxd0rznzbwpsnvsnkf";
+       sha256 = "6e5abdadbe7c7dfb33681dcaf639de065efd0f9e68d84665ee12094027a92457";
        libraryHaskellDepends = [
          base circle-packing colour containers data-default
          data-default-class diagrams-core diagrams-lib diagrams-solve
@@ -42800,7 +42932,7 @@ self: {
      mkDerivation {
        pname = "diagrams-core";
        version = "1.3.0.2";
-       sha256 = "0lrzphpia24dk1mxv33c9f5iy18r5d0lfsw92422nhbs36dslyzm";
+       sha256 = "f57baa9b197a412b0411896b47412b19051f8b4b6c8cdd6b988d08152fbc3f53";
        libraryHaskellDepends = [
          adjunctions base containers distributive dual-tree lens linear
          monoid-extras mtl semigroups unordered-containers
@@ -42815,7 +42947,7 @@ self: {
      mkDerivation {
        pname = "diagrams-gtk";
        version = "1.3";
-       sha256 = "0kf340d63jzb0clw9kv2i8wdhprv5cialcfqbaxyhdvf0qswp8ms";
+       sha256 = "baa2cb35066e37e8bb5ad831aa222b3b5fd8388a62cfc42903ebcb611a20c34d";
        libraryHaskellDepends = [
          base cairo diagrams-cairo diagrams-lib gtk
        ];
@@ -42835,7 +42967,7 @@ self: {
      mkDerivation {
        pname = "diagrams-haddock";
        version = "0.3.0.6";
-       sha256 = "0pa83kd1b1fnj9plwmz8gsi2nm35ghdsxdxi4w4f7shsgc64nhrj";
+       sha256 = "32434b0c7b1aeae30827b1b7ae1b7c65542ba27ee8574e6f92d68515da1c485d";
        isLibrary = true;
        isExecutable = true;
        libraryHaskellDepends = [
@@ -42864,7 +42996,7 @@ self: {
      mkDerivation {
        pname = "diagrams-hsqml";
        version = "0.2.0.0";
-       sha256 = "0f84919h7k93nnzgr2k9jp08qsgs2dgzihavmz2g9q1c6d53q6v0";
+       sha256 = "601b3c4a332ce0f4c4af5bc1f85f13fa698cc095698afcbeb523cd0353480439";
        libraryHaskellDepends = [
          base colour containers diagrams-core diagrams-lib hsqml lens text
          transformers
@@ -42883,7 +43015,7 @@ self: {
      mkDerivation {
        pname = "diagrams-html5";
        version = "1.3.0.2";
-       sha256 = "18ifqv5xkk9cd86d3mir1qka2jy35vj4hqycq44z96hhp50yl29j";
+       sha256 = "3209ea41b9109af409c1cc6348e42ec34ba1260e39d6d10c6a2ccdd9cbc62ea2";
        libraryHaskellDepends = [
          base cmdargs containers data-default-class diagrams-core
          diagrams-lib lens mtl NumInstances optparse-applicative split
@@ -42900,22 +43032,19 @@ self: {
      , directory, distributive, dual-tree, exceptions, filepath
      , fingertree, fsnotify, hashable, intervals, JuicyPixels, lens
      , linear, monoid-extras, mtl, optparse-applicative, process
-     , semigroups, system-filepath, tagged, text, transformers
-     , unordered-containers
+     , semigroups, tagged, text, transformers, unordered-containers
      }:
      mkDerivation {
        pname = "diagrams-lib";
-       version = "1.3.0.2";
-       sha256 = "1gvvyzpzzdwzvrh452l6r2709qpbdzx1fi1ysvzalywi3gib69ds";
+       version = "1.3.0.3";
+       sha256 = "0cc9e5131c7eb0061963eac53e58ec91909f606652108515b1f2ca80492a7751";
        libraryHaskellDepends = [
          active adjunctions array base colour containers data-default-class
          diagrams-core diagrams-solve directory distributive dual-tree
          exceptions filepath fingertree fsnotify hashable intervals
          JuicyPixels lens linear monoid-extras mtl optparse-applicative
-         process semigroups system-filepath tagged text transformers
-         unordered-containers
+         process semigroups tagged text transformers unordered-containers
        ];
-       jailbreak = true;
        homepage = "http://projects.haskell.org/diagrams";
        description = "Embedded domain-specific language for declarative graphics";
        license = stdenv.lib.licenses.bsd3;
@@ -42929,7 +43058,7 @@ self: {
      mkDerivation {
        pname = "diagrams-pandoc";
        version = "0.1";
-       sha256 = "02dz0w2im68667v5k1ykdnl3cijvqfd5pgb7qqdyyizkgza88pb4";
+       sha256 = "645d84d47ff347ef1bc667bd5b9ac35b4636a86dd38759f63106991a0507bf09";
        isLibrary = false;
        isExecutable = true;
        executableHaskellDepends = [
@@ -42948,7 +43077,7 @@ self: {
      mkDerivation {
        pname = "diagrams-pdf";
        version = "0.3.1";
-       sha256 = "0wi38w0r1n1zm49r16vhmgg14v3pw7ca6wwb85y3zrbjmzfa37vy";
+       sha256 = "7e9fa1dcaf72e53f7c418b73a3d8e1776c12deab709b9013a93fd89001472372";
        libraryHaskellDepends = [
          base cmdargs colour diagrams-core diagrams-lib filepath HPDF lens
          monoid-extras mtl semigroups split vector-space
@@ -42969,7 +43098,7 @@ self: {
      mkDerivation {
        pname = "diagrams-pgf";
        version = "0.1.0.2";
-       sha256 = "1lwwr143nlvpxpkdvsbq4z4bs7qhbx636p6hi6w448xmbniq90rj";
+       sha256 = "328384a35db52342b889d05c334c5f101fbdc82778e9dde6ed77533b48c89cd3";
        libraryHaskellDepends = [
          base bytestring bytestring-builder colour containers diagrams-core
          diagrams-lib directory filepath hashable JuicyPixels mtl
@@ -42989,7 +43118,7 @@ self: {
      mkDerivation {
        pname = "diagrams-postscript";
        version = "1.3.0.2";
-       sha256 = "0cdhs5ia6jm89h1bxgqm1w9gkjqnw6g0nw13vjasj0fh08nayk7s";
+       sha256 = "fa4caf2c02d001a995dc23700b9ee116cbf9120f15bfbe024ca84aa362d1b031";
        libraryHaskellDepends = [
          base containers data-default-class diagrams-core diagrams-lib dlist
          filepath hashable lens monoid-extras mtl semigroups split
@@ -43006,7 +43135,7 @@ self: {
      mkDerivation {
        pname = "diagrams-qrcode";
        version = "1.2";
-       sha256 = "15c1h0izxi475b1n8q3dmg0kpp7dk0s4nifnxcq3lbq71jmsg8ll";
+       sha256 = "94a2a7ab0c072f3a30ebd6454b3498eddc3bc1ab6d6064c32a87c4fe23808195";
        libraryHaskellDepends = [
          array base colour diagrams-core diagrams-lib
        ];
@@ -43026,7 +43155,7 @@ self: {
      mkDerivation {
        pname = "diagrams-rasterific";
        version = "1.3.1.3";
-       sha256 = "1gkapj3n2xyy13a819zbckslvv8k5jkdlz7x2dzhcganra9gkcki";
+       sha256 = "71b2f992ca563d067f13fd7cdaa62c13ed4df564eba780d408de776187bc6abe";
        libraryHaskellDepends = [
          base bytestring containers data-default-class diagrams-core
          diagrams-lib filepath FontyFruity hashable JuicyPixels lens mtl
@@ -43042,7 +43171,7 @@ self: {
      mkDerivation {
        pname = "diagrams-rubiks-cube";
        version = "0.2.0.0";
-       sha256 = "1rymsiqwnd37mly5dlq5hkmy5vxvyvzwkn2rm2gwmxy3amk5g4db";
+       sha256 = "ab91576655c3f7ca9fa859d8c9fff6bbefe2eb8405d3563cad6734cb71d4d5e7";
        libraryHaskellDepends = [
          base data-default-class diagrams-lib lens
        ];
@@ -43056,7 +43185,7 @@ self: {
      mkDerivation {
        pname = "diagrams-solve";
        version = "0.1";
-       sha256 = "0jqc0mlswrp7iz7wg02fp9ggi04rb97bzlssvpv26z6i6ig3b5sf";
+       sha256 = "4e97355e34d17c23f6dd5ad3bf4e5a9980f85eba4e80c7cf8fe766ae69050c4b";
        libraryHaskellDepends = [ base ];
        homepage = "http://projects.haskell.org/diagrams";
        description = "Pure Haskell solver routines used by diagrams";
@@ -43073,7 +43202,7 @@ self: {
      mkDerivation {
        pname = "diagrams-svg";
        version = "1.3.1.4";
-       sha256 = "009xn6q9qwgi3l4v0rm79309i91m1s0jbng34bbli29s6vzwgjmz";
+       sha256 = "bfcac7ff363a8948d722e3d925810e35a498c048a766b0091df1719cb0b13d01";
        libraryHaskellDepends = [
          base base64-bytestring bytestring colour containers diagrams-core
          diagrams-lib directory filepath hashable JuicyPixels lens lucid-svg
@@ -43090,7 +43219,7 @@ self: {
      mkDerivation {
        pname = "diagrams-tikz";
        version = "0.6";
-       sha256 = "1qs4m1xy62pv6gjgip9vx2pwlv2gzjq1h86yiiq15yg4gcbn5fav";
+       sha256 = "5bb962177be4f912708cde2018b0fc4f6ccaafe83bddf8e433fb0ae37ba844e3";
        libraryHaskellDepends = [
          base diagrams-core diagrams-lib dlist mtl
        ];
@@ -43106,7 +43235,7 @@ self: {
      mkDerivation {
        pname = "dice";
        version = "0.1";
-       sha256 = "1rfx3vh983f3gc6si661zimhjl47ip30l3pvf7dysjirr3gffgz1";
+       sha256 = "e13fe7dec8394aeddb71fb0e0ac68d8750096bfcc198a80d7bc30d94e01edde5";
        isLibrary = true;
        isExecutable = true;
        libraryHaskellDepends = [ base parsec random-fu transformers ];
@@ -43121,7 +43250,7 @@ self: {
      mkDerivation {
        pname = "dice-entropy-conduit";
        version = "1.0.0.1";
-       sha256 = "01xwxajwyvv6ac48j9if6xsv05aqg1p02i7d25ivk1k56ky41l1s";
+       sha256 = "3ad040fc346586b96311ed44016e785815b075372e26890853666fcfa5eabc07";
        libraryHaskellDepends = [
          base bytestring conduit entropy transformers
        ];
@@ -43141,7 +43270,7 @@ self: {
      mkDerivation {
        pname = "dicom";
        version = "0.1.1.0";
-       sha256 = "16n6mx95zfg8pa6y2zlj20imssykcrjilas1dh9li4r377rz5sdb";
+       sha256 = "abe9f2f339239348136c412b1a6566d36b5d2310927ee18dbae8b95f52afc69a";
        libraryHaskellDepends = [
          base binary bytestring old-locale pretty safe time
        ];
@@ -43157,7 +43286,7 @@ self: {
      mkDerivation {
        pname = "dictparser";
        version = "0.3.0.0";
-       sha256 = "1wjxcn53h9rp8jancspb9yq4h26215b63pghw802wgh073vp9h0i";
+       sha256 = "11c074f738003e2e00e2f0dd615609c20848b04feb6a6695443727388a655df2";
        isLibrary = true;
        isExecutable = true;
        libraryHaskellDepends = [ base parsec split ];
@@ -43174,7 +43303,7 @@ self: {
      mkDerivation {
        pname = "diet";
        version = "0.0.1";
-       sha256 = "0qkyfmys5k6la10dvi8wsmw120xfarjblpkr33xiazll2m9845wh";
+       sha256 = "9017825215947e15fb18795eba6456ae031178d51cc5dd4050d4cca27d757e62";
        libraryHaskellDepends = [ base ];
        homepage = "https://github.com/tonymorris/diet";
        description = "Discrete Interval Encoding Tree";
@@ -43186,7 +43315,7 @@ self: {
      mkDerivation {
        pname = "diff-parse";
        version = "0.2.1";
-       sha256 = "0idwhxwhqd65sy0kfgwi8d942lpabyknwpyq9454y49dnn8k0lam";
+       sha256 = "55513091b52d114f0a49d85f6ea75fea52415243913f3781d7c5340c7987bc45";
        libraryHaskellDepends = [ attoparsec base text ];
        testHaskellDepends = [ attoparsec base hspec text ];
        jailbreak = true;
@@ -43201,7 +43330,7 @@ self: {
      mkDerivation {
        pname = "diff3";
        version = "0.2.0.3";
-       sha256 = "0zdfn1jhsq8pd23qpkhzr8wgiwbazfbq688bjnpc406i7gq88k78";
+       sha256 = "e84c84f03bd100c2ae950b218397fb6af1f838ca1fce8b876817610d65b0ae7d";
        libraryHaskellDepends = [ base Diff ];
        testHaskellDepends = [
          base QuickCheck test-framework test-framework-quickcheck2
@@ -43216,7 +43345,7 @@ self: {
      mkDerivation {
        pname = "diffarray";
        version = "0.1.1";
-       sha256 = "0p95i1xzp0bdm0zrdil79rfxfyz372y2qjdxyvxdzxvfb1mvalcm";
+       sha256 = "9551b56b586ef7dffaf6bd492cbc38e37bd75d4e87c6963fa86d81fb7b88255d";
        libraryHaskellDepends = [ array base ];
        description = "DiffArray";
        license = stdenv.lib.licenses.bsd3;
@@ -43229,7 +43358,7 @@ self: {
      mkDerivation {
        pname = "diffcabal";
        version = "0.1.1";
-       sha256 = "0ggla2i4jw24a3vdq2xyz70asp80s5jl5nkwms6ck4r69zm3mci6";
+       sha256 = "26b23aea4f2693c98cae7cda4265d1005dadc0f9be0bdcf650447049a250f43d";
        isLibrary = false;
        isExecutable = true;
        executableHaskellDepends = [
@@ -43250,7 +43379,7 @@ self: {
      mkDerivation {
        pname = "diffdump";
        version = "0.7.5";
-       sha256 = "08z1h3xf3j5xzhf08i9w7hvg05wvqcf13k50chx6av70f0cs2rvh";
+       sha256 = "7067a11970e06c653a64a0cc111cc39b17f0363c3c45041cfcbdc8e1fa80e123";
        isLibrary = false;
        isExecutable = true;
        executableHaskellDepends = [
@@ -43266,7 +43395,7 @@ self: {
      mkDerivation {
        pname = "digamma";
        version = "0.1";
-       sha256 = "0qij2pn107dfb9rl9rrd77l69wmfp9fghv9ysql2d7g5qdr306pd";
+       sha256 = "ed1a3072c3e59d2628d63e6df85cbaaef264e8392de744735aae1d10ec153262";
        libraryHaskellDepends = [ base polynomial ];
        jailbreak = true;
        homepage = "https://github.com/bgamari/digamma";
@@ -43279,7 +43408,7 @@ self: {
      mkDerivation {
        pname = "digest";
        version = "0.0.1.2";
-       sha256 = "04gy2zp8yzvv7j9bdfvmfzcz3sqyqa6rwslqcn4vyair2vmif5v4";
+       sha256 = "641717eb16392abf8965986a9e8dc21eebf1d97775bbb6923c7b7f8fee17fe11";
        libraryHaskellDepends = [ base bytestring ];
        librarySystemDepends = [ zlib ];
        description = "Various cryptographic hashes for bytestrings; CRC32 and Adler32 for now";
@@ -43291,7 +43420,7 @@ self: {
      mkDerivation {
        pname = "digest-pure";
        version = "0.0.3";
-       sha256 = "0rb5jkzn1d4z90hd47qh98mf4n90wvj0cqf3qfpj7ndvw52yy95w";
+       sha256 = "bc24ef45e1bbd923afc3c36106e4e62059e22a4a101fd220489fb460ff946565";
        libraryHaskellDepends = [ array base bytestring ];
        testHaskellDepends = [ array base bytestring digest QuickCheck ];
        homepage = "http://github.com/danieldk/digest-pure";
@@ -43306,7 +43435,7 @@ self: {
      mkDerivation {
        pname = "digestive-bootstrap";
        version = "0.1.0.0";
-       sha256 = "0c1hd3l29sci624r4gwp3ndzmancwdy9dp3gz2fmd4jniani3kzz";
+       sha256 = "ffcf11ad8a5692569df86fdc967ce3ccaafa9b1d973f92893091e924e8683030";
        libraryHaskellDepends = [
          base blaze-bootstrap blaze-html digestive-functors
          digestive-functors-blaze http-types text
@@ -43323,7 +43452,7 @@ self: {
      mkDerivation {
        pname = "digestive-foundation-lucid";
        version = "0.0.0.1";
-       sha256 = "1gpmmbf5s4kxf9xhbhf086b5n3kkr9ay2qlm6xlnf8cx1l9rn6bi";
+       sha256 = "71199b130d9d216769379562e155ca730e5b9641c0c1057b727d125ddcaaf5be";
        libraryHaskellDepends = [
          base digestive-functors digestive-functors-lucid http-types lucid
          lucid-foundation text
@@ -43341,7 +43470,7 @@ self: {
      mkDerivation {
        pname = "digestive-functors";
        version = "0.8.0.0";
-       sha256 = "0wlp4504dpv0diw6ln0j3f3dz3232dgcccyzlck92b27asvl3yq3";
+       sha256 = "03fb41b756472c9126a3df33c65e13438cdf861b12586a786c60df4640219772";
        libraryHaskellDepends = [
          base bytestring containers mtl old-locale text time
        ];
@@ -43363,7 +43492,7 @@ self: {
      mkDerivation {
        pname = "digestive-functors-aeson";
        version = "1.1.16";
-       sha256 = "0v01applw92imi3yr6drd1bqig1l1mlps1ia2i1dcln1sh31ms9y";
+       sha256 = "3ee91a06d4c152d642142a067d690d34bc885768b999ec47ac51244eef55016c";
        libraryHaskellDepends = [
          aeson base containers digestive-functors lens lens-aeson safe text
          vector
@@ -43384,7 +43513,7 @@ self: {
      mkDerivation {
        pname = "digestive-functors-blaze";
        version = "0.6.0.6";
-       sha256 = "1kx8d6w89cs9dr7fpfikv7mf0ql1lz854i492nwm64x3d016q6xi";
+       sha256 = "b11b6c0268a31353b915894452d0a78162e0ead933baeb4e6e49b384b869a8cf";
        libraryHaskellDepends = [
          base blaze-html blaze-markup digestive-functors text
        ];
@@ -43400,7 +43529,7 @@ self: {
      mkDerivation {
        pname = "digestive-functors-happstack";
        version = "0.6.1.1";
-       sha256 = "0d613rxwja327fb2dm79xh55vhpa4mg8c1ch4xzrgw3jcchykag5";
+       sha256 = "e5a9e9216372f0977f279005865e25eac25d0aece9d426963b6228c97b1ec134";
        libraryHaskellDepends = [
          base bytestring digestive-functors happstack-server text
        ];
@@ -43416,7 +43545,7 @@ self: {
      mkDerivation {
        pname = "digestive-functors-heist";
        version = "0.8.6.2";
-       sha256 = "0njdhyrwzvcla65j5za0h4n41f2n1sdnar7glcal343xsy2rl019";
+       sha256 = "29009a85d77d904115a3ef64659b0e56b8402c8140fd228b5194edcfb3874d5a";
        libraryHaskellDepends = [
          base blaze-builder digestive-functors heist mtl text xmlhtml
        ];
@@ -43430,7 +43559,7 @@ self: {
      mkDerivation {
        pname = "digestive-functors-hsp";
        version = "0.5.0";
-       sha256 = "00n1cxkrkd3ayl7pp6pr7nyx6zcwqpsqzflnnnf0f8dabrz4wzdc";
+       sha256 = "ac7d4e7e5eaa21079cb596ba8ff5c59c7dd3bd3df99a7b0ff56ab4996767c102";
        libraryHaskellDepends = [ base digestive-functors hsp hsx text ];
        libraryToolDepends = [ trhsx ];
        jailbreak = true;
@@ -43445,7 +43574,7 @@ self: {
      mkDerivation {
        pname = "digestive-functors-lucid";
        version = "0.0.0.3";
-       sha256 = "1f9vlyh20b4qr7q324mxpkn7wbfp3h80il79rwqd5s5n1xx8ryhm";
+       sha256 = "15fa8c7a0fb6e8d230cfe9d008101cd72d7eecbcbd1231f0c9982c20a0a73bb9";
        libraryHaskellDepends = [ base digestive-functors lucid text ];
        homepage = "http://github.com/jaspervdj/digestive-functors";
        description = "Lucid frontend for the digestive-functors library";
@@ -43459,7 +43588,7 @@ self: {
      mkDerivation {
        pname = "digestive-functors-scotty";
        version = "0.2.0.2";
-       sha256 = "0flm1akhx3fj8pli3nz9s7asah7cfm9afz99jx3f4rv7352saclp";
+       sha256 = "9732a545196767e24697297da75275ec40a5d5d1e9db11e945d28d0ea70a953a";
        libraryHaskellDepends = [
          base bytestring digestive-functors http-types scotty text wai
          wai-extra
@@ -43476,7 +43605,7 @@ self: {
      mkDerivation {
        pname = "digestive-functors-snap";
        version = "0.6.1.3";
-       sha256 = "11ah4rvi5fj9vjjzjw0m60s72qiizy1i4hnj44v88ajf2095aigh";
+       sha256 = "f0455512104e2a843621d2421283ff31627134301570f9a5dc49ba1277265085";
        libraryHaskellDepends = [
          base bytestring containers digestive-functors directory filepath
          mtl snap-core text
@@ -43493,7 +43622,7 @@ self: {
      mkDerivation {
        pname = "digit";
        version = "0.1.1";
-       sha256 = "18l6ca3kgp0g8zmai6jsq6pz7hjilcnyspvz95h9pqklhh2z32qk";
+       sha256 = "138bf1058474e29b60497f5fed2da351c2f3afc15a9aa8ea470fdc37876286a2";
        libraryHaskellDepends = [ base lens ];
        testHaskellDepends = [
          base directory doctest filepath QuickCheck
@@ -43510,7 +43639,7 @@ self: {
      mkDerivation {
        pname = "digitalocean-kzs";
        version = "0.1.0.3";
-       sha256 = "0w1gbh84sbaab4gn9avjqmwd29rzv0b2dyxqqg22vq1da8g3bzng";
+       sha256 = "cffe351e522de02dc4c3b8fb2616d83f27d178c572ab641f594a2d4d105c2f70";
        libraryHaskellDepends = [
          aeson base bytestring HTTP http-conduit http-types text
          transformers
@@ -43527,7 +43656,7 @@ self: {
      mkDerivation {
        pname = "digits";
        version = "0.2";
-       sha256 = "18s9k7kj0qvd4297msl0k6ziwfb5bl1gwnxlrl8b4rkqda4kf17l";
+       sha256 = "f40437896a7866b210cdb45bfe025d65391ebf9980ea7a92206d6320e79949a3";
        libraryHaskellDepends = [ base QuickCheck ];
        description = "Converts integers to lists of digits and back";
        license = stdenv.lib.licenses.bsd3;
@@ -43538,7 +43667,7 @@ self: {
      mkDerivation {
        pname = "dimensional";
        version = "0.13.0.2";
-       sha256 = "1gi8948q1kxnbc76v05swj0yr58j9lljxak6lyci529ny0ac4qlp";
+       sha256 = "9762c214f036891299a766aa2e294d1295ec81e4ba806d0e5bb6cf80114928be";
        libraryHaskellDepends = [ base numtype time ];
        homepage = "http://dimensional.googlecode.com/";
        description = "Statically checked physical dimensions";
@@ -43550,7 +43679,7 @@ self: {
      mkDerivation {
        pname = "dimensional-tf";
        version = "0.3.0.2";
-       sha256 = "1bqd7298y9ymykhi70pqgxwh1599xbq5x4v75mrki5kirh8gqc4x";
+       sha256 = "9d30fc10cc719638732d67935ef0ea299500797ff88213e1f4d5278f92380daf";
        libraryHaskellDepends = [ base numtype-tf time ];
        homepage = "http://dimensional.googlecode.com/";
        description = "Statically checked physical dimensions, implemented using type families";
@@ -43568,7 +43697,7 @@ self: {
      mkDerivation {
        pname = "dingo-core";
        version = "0.2.0";
-       sha256 = "1h0ir5h6nq2c8qk4irbcai87mxgiyahyi2lcxps959zja70pmqf5";
+       sha256 = "c5e17ac151f2a792f4ed8c8ae8a1f2f1f57a50546ce54826464c606b60c911c0";
        libraryHaskellDepends = [
          aeson attoparsec base base64-bytestring blaze-builder blaze-html
          blaze-textual bytestring conduit containers cookie deepseq fclabels
@@ -43590,7 +43719,7 @@ self: {
      mkDerivation {
        pname = "dingo-example";
        version = "0.2.0";
-       sha256 = "0mla83bijf077bx16r9rsvbyr8v684j1bfllfw7kswlgyz37rf4b";
+       sha256 = "8bb87cc6f78f723d0f7794ba15244166a3ecd7d6396513fa3a073819d7408a56";
        isLibrary = false;
        isExecutable = true;
        executableHaskellDepends = [
@@ -43611,7 +43740,7 @@ self: {
      mkDerivation {
        pname = "dingo-widgets";
        version = "0.2.0";
-       sha256 = "1d61l2c6vwpngffr5ynm3zrvn7as9zgsm3zg18ldq958s0mvdn8p";
+       sha256 = "17d9b62bd0a824dc280aef8faadf4f5a1dbbf31fd5fa929d7bf6f26d98a0c1b4";
        libraryHaskellDepends = [
          aeson base blaze-html bytestring containers dingo-core fclabels
          file-embed shakespeare-js template-haskell text transformers
@@ -43628,7 +43757,7 @@ self: {
      mkDerivation {
        pname = "diophantine";
        version = "0.2.1.0";
-       sha256 = "118r59mwvihzqsjd530x4pdnvqjk87b3jjdhx5avq31cfdbiyaj9";
+       sha256 = "492a1f57732c0cbc55e9b04939d64153e26ddb251d8cd2a4c61fc6cd6b2a1985";
        libraryHaskellDepends = [ array base ];
        libraryToolDepends = [ happy ];
        homepage = "https://github.com/llllllllll/Math.Diophantine";
@@ -43637,12 +43766,29 @@ self: {
        hydraPlatforms = stdenv.lib.platforms.none;
      }) {};
 
+  "diplomacy" = callPackage
+    ({ mkDerivation, base, containers, HUnit, parsec, transformers
+     , TypeNat
+     }:
+     mkDerivation {
+       pname = "diplomacy";
+       version = "0.1.0.0";
+       sha256 = "87bcb1b15d7470947a66f19a534ab145c185d928a3ade828fe2af2cee11cd87a";
+       libraryHaskellDepends = [
+         base containers HUnit parsec transformers TypeNat
+       ];
+       jailbreak = true;
+       homepage = "https://github.com/avieth/diplomacy";
+       description = "The board game Diplomacy, spoken in Haskell";
+       license = stdenv.lib.licenses.bsd3;
+     }) {};
+
   "direct-binary-files" = callPackage
     ({ mkDerivation, base, bytestring, mtl }:
      mkDerivation {
        pname = "direct-binary-files";
        version = "1.0";
-       sha256 = "0ci6av8sgrlsn12dbpvqf3imq9w1hm2ll5np2fz7gh9760vvdidr";
+       sha256 = "b9c5b6373027c177be13d7164a458581275ce37078dfd544b09ae6a7d1562632";
        libraryHaskellDepends = [ base bytestring mtl ];
        homepage = "http://ireneknapp.com/software/";
        description = "Serialization and deserialization monads for streams and ByteStrings";
@@ -43655,7 +43801,7 @@ self: {
      mkDerivation {
        pname = "direct-daemonize";
        version = "3.1";
-       sha256 = "0698l8zylkgafx8g91icysz6rq2lyrnd25blhday67s9vkdpbvxh";
+       sha256 = "b0ef75dbdc491fe355837415d16cf654e06cbef62c86f45077ea4dea3fa22819";
        libraryHaskellDepends = [ base unix ];
        homepage = "http://dankna.com/software/";
        description = "Library to switch to daemon mode using built-in OS facilities";
@@ -43669,7 +43815,7 @@ self: {
      mkDerivation {
        pname = "direct-fastcgi";
        version = "1.0.3";
-       sha256 = "049z23gkssk3h8sx9xr3baln3hz5cykf2zp9kzmvbk2n4ky8fs78";
+       sha256 = "e86887fc2456ccb5eb9fe97ee1a667e5c361a95a23f7d43582636a3ddf103f11";
        libraryHaskellDepends = [
          base bytestring containers mtl network utf8-string
        ];
@@ -43688,7 +43834,7 @@ self: {
      mkDerivation {
        pname = "direct-http";
        version = "0.6";
-       sha256 = "0aghfhg0nx2bqi56cw5hnnqxnjbziihn36yqpq12gyhnahwdfvpg";
+       sha256 = "ef6ed7385416fa2702bed89b61618c7f49dbb1b5b070664ac44b740b1e74f029";
        libraryHaskellDepends = [
          base bytestring containers direct-daemonize lifted-base
          monad-control mtl network old-locale SafeSemaphore time
@@ -43706,7 +43852,7 @@ self: {
      mkDerivation {
        pname = "direct-murmur-hash";
        version = "1.0.1";
-       sha256 = "09hv06hslz83gpqfxxv6bfg4i6l7pfv82jxab4lf8g964ciaa42q";
+       sha256 = "5810a52223263de42859aa4b81b6bb879a489e5b66f7eef07d037daaa1011b26";
        libraryHaskellDepends = [ base bytestring ];
        homepage = "http://ireneknapp.com/software/";
        description = "An implementation of the MurmurHash3 algorithm";
@@ -43718,7 +43864,7 @@ self: {
      mkDerivation {
        pname = "direct-plugins";
        version = "1.1";
-       sha256 = "03f7jrx0skqiirvpzzakk3wwwdjanjxpzv8j5nwpzvqpb4syshcr";
+       sha256 = "9941ed355917ef7fb92d12ed7fbbb44a36cef99853fd7f778e114f0d7a96c70d";
        libraryHaskellDepends = [ base ghc ghc-paths ];
        homepage = "http://dankna.com/software/";
        description = "Lightweight replacement for Plugins, specific to GHC";
@@ -43733,7 +43879,7 @@ self: {
      mkDerivation {
        pname = "direct-sqlite";
        version = "2.3.15";
-       sha256 = "0hlpc3j4crh9hnydcpp6fmiisq9ddn916bslm46x5q1ajvcw7v12";
+       sha256 = "22ecc3d9962ae0d20da9542f13926d2d611d6375e65ed6bc85096646e4609742";
        libraryHaskellDepends = [ base bytestring text ];
        testHaskellDepends = [
          base base16-bytestring bytestring directory HUnit text
@@ -43750,7 +43896,7 @@ self: {
      mkDerivation {
        pname = "directed-cubical";
        version = "0.1.2.0";
-       sha256 = "0wy6p5nymri7l1ldc6c34b9y4ncmzr2wpidbqjrmacxg07iypn3z";
+       sha256 = "7fd8ebe301af3355b3c4abc5cb45fe9559e2d3228319d668a027e6ea6db9c673";
        libraryHaskellDepends = [
          base bytestring containers deepseq hashable parallel QuickCheck
          unordered-containers vector
@@ -43766,7 +43912,7 @@ self: {
      mkDerivation {
        pname = "directory";
        version = "1.2.3.0";
-       sha256 = "1511nw0hgy6sg82xfimg8rbbf43vcqn6gw076m96b9zcy1dzijln";
+       sha256 = "96caf85bf0eca765523507f0672c667b10b75646af46d7057adaf80701b72194";
        libraryHaskellDepends = [ base filepath time unix ];
        testHaskellDepends = [ base filepath time unix ];
        description = "Platform-agnostic library for filesystem operations";
@@ -43782,7 +43928,7 @@ self: {
      mkDerivation {
        pname = "directory-layout";
        version = "0.7.4.1";
-       sha256 = "0hj7dfv5i2s1dk0rws2fg84crpxz1kgvrq68f373a6hwkbfhv89b";
+       sha256 = "2ba10ddd9a1c1a35ce70c8e0bcdf0cbfdfcc087a4e689ec16c418b58b66b4742";
        libraryHaskellDepends = [
          base bytestring command-qq containers directory filepath free hspec
          lens semigroups template-haskell text transformers unix
@@ -43802,7 +43948,7 @@ self: {
      mkDerivation {
        pname = "directory-tree";
        version = "0.12.0";
-       sha256 = "1idknm7fwci91fkwvzl35g0qd0jk1vb00ds2x82zjf2hdbkcc2gz";
+       sha256 = "ff09c6e66a5038f905ea423700d60e538286c12b83fecda70b2932ee4eb5b3c5";
        libraryHaskellDepends = [ base directory filepath ];
        testHaskellDepends = [ base directory filepath process ];
        homepage = "http://brandon.si/code/directory-tree-module-released/";
@@ -43817,7 +43963,7 @@ self: {
      mkDerivation {
        pname = "dirfiles";
        version = "0.1.0.9";
-       sha256 = "0jqavj2s28ffaql3mcgasxa8fg0bv0v6irr2a5334jqydksj0b96";
+       sha256 = "262d20f56c1e4b32465122e76836d80b3c8754d7eab13a2856ce21a185dc0a4b";
        libraryHaskellDepends = [
          aeson base containers hblock safecopy text time
          unordered-containers
@@ -43833,7 +43979,7 @@ self: {
      mkDerivation {
        pname = "dirstream";
        version = "1.0.0";
-       sha256 = "1hxmcc62h21zsy5bgm9m4d4q7vcgps168j2mp365d2wva56r87vw";
+       sha256 = "7c1f944d519b8b56ccb855486482be8fed83492335d5b78ad73f08280c63b5c3";
        libraryHaskellDepends = [
          base directory pipes pipes-safe system-fileio system-filepath unix
        ];
@@ -43846,7 +43992,7 @@ self: {
      mkDerivation {
        pname = "disassembler";
        version = "0.2.0.1";
-       sha256 = "1yg1mb9w679m1iml0rx2i6gq1ps8s56da4dvn2knvkgg7m1cr39c";
+       sha256 = "2c8dcc423defcd6da7b0bb11d54cd148df809f89a267406b0c351dc3d3aae1f9";
        libraryHaskellDepends = [ array base containers mtl parsec ];
        homepage = "https://github.com/mgrabmueller/disassembler";
        description = "Disassembler for X86 & AMD64 machine code";
@@ -43858,7 +44004,7 @@ self: {
      mkDerivation {
        pname = "discordian-calendar";
        version = "0.1";
-       sha256 = "0ykbfisrb6k8vsqx5avv99j0z4j4615hmql263h12jzhjxfzd22d";
+       sha256 = "4d88f65d97f04b11e03082e20a4b3044920f644a7babd2b1de689a9575746b7a";
        libraryHaskellDepends = [ base time ];
        jailbreak = true;
        homepage = "https://github.com/kallisti-dev/discordian-calendar";
@@ -43871,7 +44017,7 @@ self: {
      mkDerivation {
        pname = "discount";
        version = "0.1.1";
-       sha256 = "1q1lz9dgxp5kq0ngh7pagijmlc616vwrfrb14pjx2vc9s7yvg779";
+       sha256 = "e99cb7fdd1896dd1e525616597f936c1305a657cea1ef82cc0b3dcfe5afa34e0";
        libraryHaskellDepends = [ base bytestring text ];
        librarySystemDepends = [ markdown ];
        homepage = "http://github.com/lightquake/discount";
@@ -43887,7 +44033,7 @@ self: {
      mkDerivation {
        pname = "discrete-space-map";
        version = "0.0.4";
-       sha256 = "1dci1yk1xpndszwcxshdh6sz6ibzxk6l2726b550xx1wffakpmcq";
+       sha256 = "98d53b95733cf40e4a59461c41cdec7f45f3b5810deacef8d7cdde1ea60f91b5";
        libraryHaskellDepends = [
          adjunctions base comonad distributive keys semigroupoids
        ];
@@ -43904,7 +44050,7 @@ self: {
      mkDerivation {
        pname = "discrimination";
        version = "0.1";
-       sha256 = "11ddphyjqc1zhsr6l94hyvxmz68sbjfwaasms7ilf55x5h61g3l1";
+       sha256 = "818e170c2cbd1447e3d1552bc59d5c1a995ffbf690246ab2863f302c3dbcad85";
        libraryHaskellDepends = [
          array base containers contravariant deepseq ghc-prim primitive
          profunctors promises semigroups transformers vector void
@@ -43921,7 +44067,7 @@ self: {
      mkDerivation {
        pname = "disjoint-set";
        version = "0.2";
-       sha256 = "05m7liind4fdw5lw8a8381hm6rjzsqz86qzir79y30pj0axayc3z";
+       sha256 = "7f30afba02f282e1d3c9f163833ed65f665361400329c469e1cd916663a4a716";
        libraryHaskellDepends = [ base containers mtl transformers ];
        testHaskellDepends = [
          base containers HUnit mtl QuickCheck transformers
@@ -43937,7 +44083,7 @@ self: {
      mkDerivation {
        pname = "disjoint-sets-st";
        version = "0.1";
-       sha256 = "0yy4gp5jhfsj3gbk7gh3yplxkxxfsmrl84chp4wfr4v46ff9pc2m";
+       sha256 = "55b09b9c336493ec38b990114473d5aef7d9e9f503be33d71b523b28cb7dc47b";
        libraryHaskellDepends = [ array base ];
        homepage = "http://github.com/ppetr/disjoint-sets-st/";
        description = "Imperative ST/IO based disjoint set data structure";
@@ -43949,7 +44095,7 @@ self: {
      mkDerivation {
        pname = "disk-free-space";
        version = "0.1.0.1";
-       sha256 = "07rqj8k1vh3cykq9yidpjxhgh1f7vgmjs6y1nv5kq2217ff4yypi";
+       sha256 = "f17a4f9c3b41083ccbb6c11b2debdbc705f86097b7459ff0f46cc01d2692381f";
        revision = "2";
        editedCabalFile = "60ab6de6ad0e36274c675338a37c8985972a5a64db69dee7b4f88b797c9b401b";
        libraryHaskellDepends = [ base ];
@@ -43963,7 +44109,7 @@ self: {
      mkDerivation {
        pname = "dist-upload";
        version = "0.0.4";
-       sha256 = "1i9g4jqmmjydcvi07878k6yb5kvxab6dlw3j6nkjdn4mcsc50s71";
+       sha256 = "e16850986695d826a7357270dacc527dcfb2bc99e8a003e266cdcb5ab1242fc5";
        isLibrary = true;
        isExecutable = true;
        libraryHaskellDepends = [ base Cabal directory filepath process ];
@@ -43981,7 +44127,7 @@ self: {
      mkDerivation {
        pname = "distributed-process";
        version = "0.5.5";
-       sha256 = "0w3jwnfc8ca0sx9mshgbxr61pfbnp82ihy3ca5v1pkwz34dqd3f5";
+       sha256 = "c58d861b199fcf1b76516c781805ba76b91b4ceeeb415d53d74031c49ce57270";
        libraryHaskellDepends = [
          base binary bytestring containers data-accessor deepseq
          distributed-static ghc-prim hashable mtl network-transport random
@@ -44004,7 +44150,7 @@ self: {
      mkDerivation {
        pname = "distributed-process-async";
        version = "0.2.1";
-       sha256 = "0g28f2f5b28ra1gnm99yalah6rxqps4yvmi403nb0axw295pbmib";
+       sha256 = "2bd6754b12bc2bb0ec0024d6ed89beb8670315553ea56a5f501989559c70483c";
        libraryHaskellDepends = [
          base binary containers data-accessor deepseq distributed-process
          distributed-process-extras fingertree hashable mtl stm time
@@ -44032,7 +44178,7 @@ self: {
      mkDerivation {
        pname = "distributed-process-azure";
        version = "0.1.0";
-       sha256 = "0dc0izlsxzcr5jyiad5yvgs5sp5b6dqwr6gxxkk99p7h1wpd4r2g";
+       sha256 = "4f64d22e0ff0dc94e6ecfd99cc7133ab5c5df4dbbe3415bd2c99fdaee98f8035";
        isLibrary = true;
        isExecutable = true;
        libraryHaskellDepends = [
@@ -44060,7 +44206,7 @@ self: {
      mkDerivation {
        pname = "distributed-process-client-server";
        version = "0.1.2";
-       sha256 = "0wr0fxdg9114jd180p4lrjkashqcyxv69harj1ww5jc8dxdb3k2s";
+       sha256 = "5accb15a6f88c9c2799059c16476f70c43ada6cc945c8042932484f45a772073";
        libraryHaskellDepends = [
          base binary containers data-accessor deepseq distributed-process
          distributed-process-async distributed-process-extras fingertree
@@ -44093,7 +44239,7 @@ self: {
      mkDerivation {
        pname = "distributed-process-execution";
        version = "0.1.1";
-       sha256 = "1zm4mcicasf59s3zzca2m7hp4ialzmsmn6arjlz2mnrhcpbkg7ja";
+       sha256 = "4a9e37d76530db2a3e9559195b75fd544572e1a942b1ff874ec569c522aba4fe";
        libraryHaskellDepends = [
          base binary containers data-accessor deepseq distributed-process
          distributed-process-client-server distributed-process-extras
@@ -44127,7 +44273,7 @@ self: {
      mkDerivation {
        pname = "distributed-process-extras";
        version = "0.2.0";
-       sha256 = "0l8k1h0nx2pign82ydyzsjbkc8qw3vhhbrdggzfwvr3hamnjpqly";
+       sha256 = "9ee22b6d5570e4cddd7fafe505e11e1c233697d4df372f907df18a6e010c1351";
        libraryHaskellDepends = [
          base binary containers data-accessor deepseq distributed-process
          fingertree hashable mtl stm time transformers unordered-containers
@@ -44154,7 +44300,7 @@ self: {
      mkDerivation {
        pname = "distributed-process-monad-control";
        version = "0.5.1";
-       sha256 = "01sdzmb8izsycxshhsg0pbx0mgn10y41df1dj1s66ish0qszw07m";
+       sha256 = "f500fe350650476374902db8168807c1be0afabae0690875675eff8856fd4d07";
        libraryHaskellDepends = [
          base distributed-process monad-control transformers
          transformers-base
@@ -44172,7 +44318,7 @@ self: {
      mkDerivation {
        pname = "distributed-process-p2p";
        version = "0.1.3.2";
-       sha256 = "13m283cwlas0xzqxlrmnwmwimwy29hbvymavyqffd1b0k2m6ag31";
+       sha256 = "613c65aa986085e61cf65b55bf174cc2f31a79e5b666daf1ef402bcad940a28e";
        isLibrary = true;
        isExecutable = true;
        libraryHaskellDepends = [
@@ -44197,7 +44343,7 @@ self: {
      mkDerivation {
        pname = "distributed-process-platform";
        version = "0.1.0";
-       sha256 = "0bxfynvqkzvah7gbg74yzwpma8j32bamnyysj6dk39da0v880abm";
+       sha256 = "752980d006aaa5319b91da7b5bd5124322552fff9e9cb7de816aff89b7f5ae2f";
        isLibrary = true;
        isExecutable = true;
        libraryHaskellDepends = [
@@ -44231,7 +44377,7 @@ self: {
      mkDerivation {
        pname = "distributed-process-registry";
        version = "0.1.0";
-       sha256 = "0c2a5x70sfii053b11xfj2x7199vmmn1k759zylbd5qs129q7hw2";
+       sha256 = "82c38393081a97b6a8ffa99c196cad3ba570ba90ae87b04601313a0d4e2f4a30";
        libraryHaskellDepends = [
          base binary containers data-accessor deepseq distributed-process
          distributed-process-client-server distributed-process-extras
@@ -44261,7 +44407,7 @@ self: {
      mkDerivation {
        pname = "distributed-process-simplelocalnet";
        version = "0.2.3.0";
-       sha256 = "01871r4cj5zwcv63m95i622h0xxfjnflj33wvpxv1ii5z265rkjy";
+       sha256 = "5ece5c8cf825c6b0fbdd7c0c499d95ae77008530b1a43acc66fc17c9480e0705";
        isLibrary = true;
        isExecutable = true;
        libraryHaskellDepends = [
@@ -44287,7 +44433,7 @@ self: {
      mkDerivation {
        pname = "distributed-process-supervisor";
        version = "0.1.2";
-       sha256 = "1b2rskzjimb2s8xrz4iv4q3c10njjnycxy5bcy159m6hawz1hzj1";
+       sha256 = "417e183e57d0d4548267abf8cebc95d282c006263b929f3bd262d528ffd459ac";
        libraryHaskellDepends = [
          base binary containers data-accessor deepseq distributed-process
          distributed-process-client-server distributed-process-extras
@@ -44321,7 +44467,7 @@ self: {
      mkDerivation {
        pname = "distributed-process-task";
        version = "0.1.1";
-       sha256 = "04w1nhca59i6bzmwfi80mryf5pcsn0zmswq3s3ksqc6wy4mfzy1m";
+       sha256 = "35f8ef2af1dc30ace7d003735d3fb09adde27cae0045c7eb5f26a6a218b48113";
        libraryHaskellDepends = [
          base binary containers data-accessor deepseq distributed-process
          distributed-process-async distributed-process-client-server
@@ -44353,7 +44499,7 @@ self: {
      mkDerivation {
        pname = "distributed-process-tests";
        version = "0.4.1";
-       sha256 = "1jjj77pw39bbbf58j61hdcpr872ncd1k1z2ly75n96gklw9aikbb";
+       sha256 = "6bcda812a7f39964cbf154fc304363561c942f6b3018898a5b6ba5c1ef3952ca";
        libraryHaskellDepends = [
          ansi-terminal base binary bytestring distributed-process
          distributed-static HUnit network network-transport random rematch
@@ -44378,7 +44524,7 @@ self: {
      mkDerivation {
        pname = "distributed-process-zookeeper";
        version = "0.2.0.0";
-       sha256 = "1v8jm5i4kjds7xcmzrhxg9lcz49l9ip7mm8gwjz3f3lgdxm2ykxi";
+       sha256 = "b14f2f6a6f8f0e37bee40fd57a6e4c3491cf687a1de65f593fbac94962a912ed";
        isLibrary = true;
        isExecutable = true;
        libraryHaskellDepends = [
@@ -44406,7 +44552,7 @@ self: {
      mkDerivation {
        pname = "distributed-static";
        version = "0.3.2.0";
-       sha256 = "1zz18lgf39i8anw17qxacb6cicm1kq0yayx9a4inxpnch5xfvg4m";
+       sha256 = "95bced7a81ccde6e2351a97be5019ea1b2c8cc62aae313b85528a6e11e45e1ff";
        libraryHaskellDepends = [
          base binary bytestring containers deepseq rank1dynamic
        ];
@@ -44420,7 +44566,7 @@ self: {
      mkDerivation {
        pname = "distribution";
        version = "1.0.0.0";
-       sha256 = "0zh9ap3hhylpk7bsp54hm9gj5x8f8zvm5sg7nydmxnigyq0b3l4y";
+       sha256 = "9ed0b100f62fda5e9bb7e7e952f7470ef5225faa9094abd799977a08c755097e";
        libraryHaskellDepends = [
          array base containers MonadRandom random
        ];
@@ -44438,7 +44584,7 @@ self: {
      mkDerivation {
        pname = "distribution-plot";
        version = "1.0.0.0";
-       sha256 = "16k57dxg79x3i7j62ln063j4g4v4n5x80b12pajjrpxrmaffy79n";
+       sha256 = "361def9caab9df2ca5ba222c807ab1649347e430c05261e489a3a7f37a3b659a";
        libraryHaskellDepends = [
          base Chart Chart-cairo colour containers data-default-class
          distribution lens
@@ -44457,7 +44603,7 @@ self: {
      mkDerivation {
        pname = "distributive";
        version = "0.4.4";
-       sha256 = "0s2ln9jv7bh4ri2y31178pvjl8x6nik5d0klx7j2b77yjlsgblc2";
+       sha256 = "82d1f53495fe9c25e4e974825666b4a6232af7452784e145cc04aeb365b25468";
        libraryHaskellDepends = [
          base ghc-prim tagged transformers transformers-compat
        ];
@@ -44475,7 +44621,7 @@ self: {
      mkDerivation {
        pname = "diversity";
        version = "0.7.0.0";
-       sha256 = "04zmqsdpplps0xnhndpvfhxq2mfhnxbj1nzspw28ky7pcps1w621";
+       sha256 = "41181ef465f7f88904bffadb2057b7d055813b74fb360b6d07fad27b9bc6f513";
        isLibrary = true;
        isExecutable = true;
        libraryHaskellDepends = [
@@ -44496,7 +44642,7 @@ self: {
      mkDerivation {
        pname = "djinn";
        version = "2014.9.7";
-       sha256 = "1p9dvzb83nlrq8h4brdq5l9dm2zf28rjhsmi7nwmac79p5pk9y2g";
+       sha256 = "4ff8346fb9e93055b93db16a283312ee8bda122db8e54520c299da81d6df2ddd";
        isLibrary = false;
        isExecutable = true;
        executableHaskellDepends = [
@@ -44513,7 +44659,7 @@ self: {
      mkDerivation {
        pname = "djinn-ghc";
        version = "0.0.2.3";
-       sha256 = "190llfn8dvxkdan806nybn3d4psmnr1126zg8lmk8p5wd7nnm5fb";
+       sha256 = "cb956aed69bc5c342b45ef1b1142b6555fd2865dde1a80ac6ab3ef86aca314a4";
        libraryHaskellDepends = [
          async base containers djinn-lib ghc mtl transformers
        ];
@@ -44526,7 +44672,7 @@ self: {
      mkDerivation {
        pname = "djinn-lib";
        version = "0.0.1.2";
-       sha256 = "048hs27awl4j9lg04qbnpf8c51mzbgy2afckis19zcswmavi1zn0";
+       sha256 = "c0fe10b7aa5cb39f828e933925fc5bbf86c290bb7661021e4d9250ae8ed01011";
        libraryHaskellDepends = [ base containers mtl pretty ];
        homepage = "http://www.augustsson.net/Darcs/Djinn/";
        description = "Generate Haskell code from a type. Library extracted from djinn package.";
@@ -44538,7 +44684,7 @@ self: {
      mkDerivation {
        pname = "djinn-th";
        version = "0.0.1";
-       sha256 = "089b6z8hcv6q9y77zy8m96lc00r1ckzmff0mybp9l1akj7gwdpix";
+       sha256 = "3ddec6df9153059aeef2153857ff642103c0a84915f97f8e4fd86c06d1372b21";
        libraryHaskellDepends = [
          base containers logict template-haskell
        ];
@@ -44554,7 +44700,7 @@ self: {
      mkDerivation {
        pname = "dlist";
        version = "0.7.1.1";
-       sha256 = "1zayvxvkan2s2ixajdr3f5rn1gzhprzv6cww4cbpwjhzw0l7zc08";
+       sha256 = "08b07f28e01f4a7e17239c33b37fbef0bf6073712337a97a145a583577df5efd";
        libraryHaskellDepends = [ base deepseq ];
        testHaskellDepends = [ base Cabal QuickCheck ];
        homepage = "https://github.com/spl/dlist";
@@ -44567,7 +44713,7 @@ self: {
      mkDerivation {
        pname = "dlist-instances";
        version = "0.1";
-       sha256 = "0r1j7djywqd7c224wc9ixkplj3m2mbf9k3ra7n92ja2kfpksm615";
+       sha256 = "2598aae775532829923d2a8f99dcaaa20e49efec31314e8460a761ee653b3264";
        libraryHaskellDepends = [ base dlist semigroups ];
        homepage = "https://github.com/gregwebs/dlist-instances";
        description = "Difference lists instances";
@@ -44582,7 +44728,7 @@ self: {
      mkDerivation {
        pname = "dns";
        version = "2.0.0";
-       sha256 = "1jq12jdidgz9nrcpnr362n6rwvxywd5v7j4fi18bqaq2f67ybjay";
+       sha256 = "5ec9e58f71022bbc50888ec8b34be3be6f9e8d1566647b59b6e9bf169b1401cb";
        libraryHaskellDepends = [
          attoparsec base binary blaze-builder bytestring conduit
          conduit-extra containers iproute mtl network random resourcet
@@ -44604,7 +44750,7 @@ self: {
      mkDerivation {
        pname = "dnscache";
        version = "1.1.0";
-       sha256 = "0bwpfw7fsis0sqnqrgw13ifla17mcm2xk9b9jagjjqmim66d6zxb";
+       sha256 = "ab7fd38ca9b162299f9269a5d94565f504455d1c81bf8c2dd64047ed0e77972f";
        isLibrary = true;
        isExecutable = true;
        libraryHaskellDepends = [
@@ -44622,7 +44768,7 @@ self: {
      mkDerivation {
        pname = "dnsrbl";
        version = "0.0.3";
-       sha256 = "07xq52aqqmzq1f68m8spr7fyax0cqnpv9mh5m4x3klxm0iznv9xm";
+       sha256 = "b5a76d7f04b5d3393aa905d6b4afc50c74e5ddc957a38a8c0bf8578c9528b81f";
        libraryHaskellDepends = [ base containers hsdns HUnit network ];
        homepage = "http://www.pigscanfly.ca/~holden/dnsrbl/";
        description = "Asynchronous DNS RBL lookup";
@@ -44634,7 +44780,7 @@ self: {
      mkDerivation {
        pname = "dnssd";
        version = "0.1.0.0";
-       sha256 = "0gfyyr1wcxni0r0r9df6lkmv6gvi0qvwclwi9majzg10pas6dk2n";
+       sha256 = "56cc66b4ba20bc2f554d9153c63706713fb3eba4c6b5944106d176c643f6de3d";
        libraryHaskellDepends = [ base transformers ];
        librarySystemDepends = [ dns_sd ];
        jailbreak = true;
@@ -44654,7 +44800,7 @@ self: {
      mkDerivation {
        pname = "doc-review";
        version = "0.7.1";
-       sha256 = "0009gpm6hgjr78bsp0cd4skvhbms83j4j9axf6zns7pnfqvc6inf";
+       sha256 = "ce46c33676f61e6dbf715d2549e440ba2eb8a7268d81ab173a593e68ea7d0900";
        isLibrary = false;
        isExecutable = true;
        executableHaskellDepends = [
@@ -44678,7 +44824,7 @@ self: {
      mkDerivation {
        pname = "doccheck";
        version = "0.1.0.0";
-       sha256 = "055jns09s50iyzgk9m9d7gbxvnmgd4wxfb5axsxra8qnlfq331lb";
+       sha256 = "8b8631b0a3162395bbeeaa2cd73969afdaddd73b2dd534dff711149d80b6b214";
        isLibrary = false;
        isExecutable = true;
        executableHaskellDepends = [
@@ -44698,7 +44844,7 @@ self: {
      mkDerivation {
        pname = "docidx";
        version = "1.1.0";
-       sha256 = "0020pi4m0n6cvb6hdzhai5f9jidwc8dy6qq3pjs6g4dwql9igsb8";
+       sha256 = "68e91713c5bc9167b4bc0363e31b62bc45995c890afe06cddacc585049bc4000";
        isLibrary = false;
        isExecutable = true;
        executableHaskellDepends = [
@@ -44720,7 +44866,7 @@ self: {
      mkDerivation {
        pname = "docker";
        version = "0.2.0.2";
-       sha256 = "0iv36j8ixjbxlwbpw426lj5z39kwd3mrpb5qqw7c2nxkfp2dr0gi";
+       sha256 = "f181dcc475b35bc10ec7b8ac9beb687ca6f18ba446107e17a77dc91e91346347";
        libraryHaskellDepends = [
          aeson base bytestring containers data-default lens lens-aeson
          network-uri pipes pipes-bytestring pipes-http pipes-text text wreq
@@ -44748,7 +44894,7 @@ self: {
      mkDerivation {
        pname = "dockercook";
        version = "0.4.3.0";
-       sha256 = "0gsaw0qbbd3a017w82hwvmrv0ygxki2c8ls3b6hfc38a17ja68vc";
+       sha256 = "6c23a3e4090a0de6a0594353c4449cfd79b073dd1c0ac44f006ab4b530e04a3f";
        isLibrary = true;
        isExecutable = true;
        libraryHaskellDepends = [
@@ -44775,7 +44921,7 @@ self: {
      mkDerivation {
        pname = "dockerfile";
        version = "0.1.0.1";
-       sha256 = "0980w0fh5xb7azknnmph6rmnzswsjw360ga5ymds2valq2vc0ji9";
+       sha256 = "294ac0b6c0546da15bf5453d6006979aeb6f6b36f0566be75767f5021de00025";
        libraryHaskellDepends = [ base ];
        testHaskellDepends = [ base hspec ];
        description = "A simple DSL for describing and generating Dockerfile containers in Haskell";
@@ -44789,7 +44935,7 @@ self: {
      mkDerivation {
        pname = "docopt";
        version = "0.7.0.2";
-       sha256 = "0c62lz0xmrd3ycnpmw254jbc5s999nb0xzrrkbv3cj3n9zzcyzak";
+       sha256 = "537dcffe4f764836f69a39ff0e964d29e9c2962445f07a2df3a3e5dac1a7c230";
        libraryHaskellDepends = [
          base containers parsec template-haskell th-lift
        ];
@@ -44809,7 +44955,7 @@ self: {
      mkDerivation {
        pname = "doctest";
        version = "0.10.1";
-       sha256 = "1jbyhzbi2hfrfg7vbkpj6vriaap8cn99nnmzwcfscwaijz09jyrm";
+       sha256 = "357b99c0975171a61de3bf5a9b9265e82a15f336f2ceb5cf73d94111d7877ec9";
        isLibrary = true;
        isExecutable = true;
        libraryHaskellDepends = [
@@ -44834,7 +44980,7 @@ self: {
      mkDerivation {
        pname = "doctest-discover";
        version = "0.1.0.6";
-       sha256 = "1rgk831yf4gamb4m10bbcc2r4hhdh4ffjjr80smkfs95x3pi15d3";
+       sha256 = "a39510efe8256937ab06284be91c810d429205636b8150c9aaea11e7c340f3e5";
        isLibrary = true;
        isExecutable = true;
        libraryHaskellDepends = [
@@ -44858,7 +45004,7 @@ self: {
      mkDerivation {
        pname = "doctest-discover-configurator";
        version = "0.1.0.6";
-       sha256 = "1n2x8rp67ddifyahxcny0k7r514qa82lbxg13z7yg2kvmrfip7r8";
+       sha256 = "289f1b5dae7b8ae7cf1fe1f5450552988492cf04deb20e9577b1b5636e465dd8";
        revision = "1";
        editedCabalFile = "79f62a00ff10acba4f850730ed2ffe99d5637bdfdb48f6fc4b92f03fbbb20a45";
        isLibrary = true;
@@ -44882,7 +45028,7 @@ self: {
      mkDerivation {
        pname = "doctest-prop";
        version = "0.2.0.1";
-       sha256 = "1amfsq53s0bgal77g7hbsvbn1vlqh1jc3qvcjwv0achc6z65dc2a";
+       sha256 = "4ab056cc370c320536976ce3c1648098ee60d7d60b9e770e556f013d0ad6aeaa";
        libraryHaskellDepends = [ base HUnit QuickCheck ];
        testHaskellDepends = [ base doctest HUnit QuickCheck ];
        description = "Allow QuickCheck-style property testing within doctest";
@@ -44894,7 +45040,7 @@ self: {
      mkDerivation {
        pname = "dom-lt";
        version = "0.1.3";
-       sha256 = "0i51d8d49jpf7mhl6c2a4565d4vmh0x5f4kam46hn5ahb1v2nrga";
+       sha256 = "ea652b765850150b0da96a12573a807593564c214a3043613deeca441a6aa144";
        libraryHaskellDepends = [ array base containers ];
        description = "The Lengauer-Tarjan graph dominators algorithm";
        license = stdenv.lib.licenses.bsd3;
@@ -44907,7 +45053,7 @@ self: {
      mkDerivation {
        pname = "dom-selector";
        version = "0.2.0.1";
-       sha256 = "1nm3r79k4is5lh5fna4v710vhb0n5hpp3d21r0w6hmqizhdrkb22";
+       sha256 = "42ac991bfc11576838c841b4712f2c162cb841389b28eb0aa4454732d3c9a3da";
        libraryHaskellDepends = [
          base blaze-html containers html-conduit parsec QuickCheck
          template-haskell text th-lift xml-conduit
@@ -44928,7 +45074,7 @@ self: {
      mkDerivation {
        pname = "domain-auth";
        version = "0.2.1";
-       sha256 = "1b1kw4pkm1f5z5qwyfpppk5rjqzi4i7b2vx4zmb2cd9398dnkj4a";
+       sha256 = "8ac8691b4a23352656fda46fb14e24f16399cbbcf73acf71f9c5853a2fe133ac";
        libraryHaskellDepends = [
          appar base binary blaze-builder bytestring containers
          crypto-pubkey-types dns iproute network RSA SHA
@@ -44944,7 +45090,7 @@ self: {
      mkDerivation {
        pname = "dominion";
        version = "0.1.0.4";
-       sha256 = "13ypa09adkj7yilyxxf84rkpap5h4mmx4pwvc4x6121j77xz29dy";
+       sha256 = "be25f1fb393288603a619b5fd26b25b05c756726c8f5ee69f447cea61250d78f";
        isLibrary = true;
        isExecutable = true;
        libraryHaskellDepends = [
@@ -44970,7 +45116,7 @@ self: {
      mkDerivation {
        pname = "domplate";
        version = "0.1.0.1";
-       sha256 = "1njzjxz7mymjfismmv8rxkqb24m0gindbsiszbjgy1wm1lwrspb4";
+       sha256 = "645d9d390d9507ffe4fa3aead56c7ca012b1f0ec19ed5a7574b2fa7a7e975fda";
        libraryHaskellDepends = [
          base bytestring containers tagsoup text unordered-containers vector
          yaml
@@ -44985,7 +45131,7 @@ self: {
      mkDerivation {
        pname = "dot2graphml";
        version = "0.1.0.2";
-       sha256 = "1fwfwp24fdgir0m721c801xi8gkhz2y8s1r1gxdp7m1vl5d0xqii";
+       sha256 = "31e20e5aa13bd4735b7f21078dbcf8703e147b008805712ac8f13547c4e58ebb";
        isLibrary = false;
        isExecutable = true;
        executableHaskellDepends = [ base containers graphviz hxt text ];
@@ -45001,7 +45147,7 @@ self: {
      mkDerivation {
        pname = "dotenv";
        version = "0.1.0.8";
-       sha256 = "1hrr8w5hi6l8v85cwq5r6175al6waj0hmfkvnx8xib2rpby47px6";
+       sha256 = "a6df43fcba59acd851b77bba0a8154dc50554e30b960ce0ada889a080b4739c3";
        isLibrary = true;
        isExecutable = true;
        libraryHaskellDepends = [ base base-compat parsec ];
@@ -45025,7 +45171,7 @@ self: {
      mkDerivation {
        pname = "dotfs";
        version = "0.1.1.3";
-       sha256 = "0hj21rvjbn8hmb3kf4225ir57j75d8jyzhw2rw8kmjxw3w62l49f";
+       sha256 = "2e112a0c1fbccb3a11cf82c3ef256ae5c853722c421037c7aa10d925770e4242";
        isLibrary = true;
        isExecutable = true;
        libraryHaskellDepends = [
@@ -45052,7 +45198,7 @@ self: {
      mkDerivation {
        pname = "dotgen";
        version = "0.4.2";
-       sha256 = "148q93qsmqgr5pzdwvpjqfd6bdm1pwzcp2rblfwswx2x8c5f43fg";
+       sha256 = "cf0de20a435d74aeb9a32b8bcb3ebfa1b6659ac3f26edefe2df9e1aaf1481891";
        isLibrary = true;
        isExecutable = true;
        libraryHaskellDepends = [ base containers ];
@@ -45069,7 +45215,7 @@ self: {
      mkDerivation {
        pname = "double-conversion";
        version = "2.0.1.0";
-       sha256 = "034ji9jgf3jl0n5pp1nki3lsg173c3b9vniwnwp1q21iasqbawh0";
+       sha256 = "0072b5b05631081c2eb73cda9dd660e384a7e988d3867b8b05540ef7648a920c";
        libraryHaskellDepends = [
          base bytestring ghc-prim integer-gmp text
        ];
@@ -45086,7 +45232,7 @@ self: {
      mkDerivation {
        pname = "dove";
        version = "0.0.0";
-       sha256 = "19h3inxxxcblsbakm93mblhg8g68qc699c13cnska65ij50h3jwd";
+       sha256 = "8dcb014191b11835b56523b0940cc3c83cf4205d75a43ad5d274b1debb8d03a6";
        libraryHaskellDepends = [ acl2 base ];
        description = "The Dove verification language";
        license = stdenv.lib.licenses.bsd3;
@@ -45099,7 +45245,7 @@ self: {
      mkDerivation {
        pname = "dow";
        version = "0.2.5";
-       sha256 = "15vlydfw0yw49jha90zcxynwajnyxhqn32x9w7n58k3j0rkcrp9l";
+       sha256 = "34ddcc6606724c54ece1a98b6131ecde4ac5adefec83a4a04c847bc05df37497";
        isLibrary = false;
        isExecutable = true;
        executableHaskellDepends = [
@@ -45114,7 +45260,7 @@ self: {
      mkDerivation {
        pname = "download";
        version = "0.3.2";
-       sha256 = "0nhbfq8q9ckc5fnlg54l361p2jhkag9cz11v07kj9f1kwkm4d7w3";
+       sha256 = "839f46eae433b824e7013b84cfd253134a718319949447ad2b6cb28411760b5a";
        libraryHaskellDepends = [ base bytestring feed tagsoup xml ];
        homepage = "http://code.haskell.org/~dons/code/download";
        description = "High-level file download based on URLs";
@@ -45127,7 +45273,7 @@ self: {
      mkDerivation {
        pname = "download-curl";
        version = "0.1.4";
-       sha256 = "1wf3pf2k4i6jvpfsjlxdj6v53qd33jj1z1ipaf3p47glgx4xw3lm";
+       sha256 = "950ede497ff41d72875337861fa41ca3e151b691ad53a9ddddd2443285bbc3f1";
        libraryHaskellDepends = [ base bytestring curl feed tagsoup xml ];
        jailbreak = true;
        homepage = "http://code.haskell.org/~dons/code/download-curl";
@@ -45142,7 +45288,7 @@ self: {
      mkDerivation {
        pname = "download-media-content";
        version = "0.0.0.1";
-       sha256 = "1bj4310j3s26xd4ic6hm284dlk91npwilfbwvrk1zz8fas6yr6z6";
+       sha256 = "e69bec8d560efd1f66de7c391af9b5214dda0812151a1649eb46e821411844ae";
        isLibrary = false;
        isExecutable = true;
        executableHaskellDepends = [
@@ -45160,7 +45306,7 @@ self: {
      mkDerivation {
        pname = "dozenal";
        version = "0.1.0.0";
-       sha256 = "0sqvxyj3aybqvjlrz2a93lnp1vbjiqikysm575wizri2rd3vfj1l";
+       sha256 = "3448b747cb22e61f7939a56a3f238e72ed702d1d49899fa9dc787935a4ef1b6b";
        libraryHaskellDepends = [ base ];
        jailbreak = true;
        homepage = "https://github.com/siddhanathan/dozenal";
@@ -45176,7 +45322,7 @@ self: {
      mkDerivation {
        pname = "dozens";
        version = "0.1.1";
-       sha256 = "1hvsdc69ag4x8rp2pzr3cxjfbl4fh9bdj4bwlkfvpr755qdi45ky";
+       sha256 = "7e16121b2ee5e4bbdda47c11d956828ed0e5646723ff2b6e469d3c950c6b7ac3";
        revision = "1";
        editedCabalFile = "08e6297d7be6ec753261aa5cb8f265a6ba6c369f44d25f46f9784ae1d8a88e52";
        libraryHaskellDepends = [
@@ -45194,7 +45340,7 @@ self: {
      mkDerivation {
        pname = "dph-base";
        version = "0.7.0.1";
-       sha256 = "19rc0h94lgxyndaw41wgnc0prwffl780i6nqsn9b7byvgy97f15y";
+       sha256 = "be0477927fdbafb392d5d89a08d0a1cef17c01b38f07c255b3be3f4a12042ca7";
        libraryHaskellDepends = [
          array base ghc-prim pretty random vector
        ];
@@ -45211,7 +45357,7 @@ self: {
      mkDerivation {
        pname = "dph-examples";
        version = "0.7.0.5";
-       sha256 = "1qbj8hsgpmcx95qsqycb6cnfb5vfk9h3w1jyq4k02hf9g7gyvckz";
+       sha256 = "7fb2eddf79c9410126c15e063e609a6e97e52c338b79ac71499dd5fb344472e1";
        isLibrary = false;
        isExecutable = true;
        executableHaskellDepends = [
@@ -45232,7 +45378,7 @@ self: {
      mkDerivation {
        pname = "dph-lifted-base";
        version = "0.7.0.1";
-       sha256 = "1gp3l9bgpmly3h74hyfxi3yfm8v4r918800ca64q1b16019hk20k";
+       sha256 = "138809530026ac8089510c008442ca64a3eafc88dd79480e1c9ed6fb56a2e3be";
        libraryHaskellDepends = [
          array base containers dph-base dph-prim-par ghc pretty random
          template-haskell vector
@@ -45251,7 +45397,7 @@ self: {
      mkDerivation {
        pname = "dph-lifted-copy";
        version = "0.7.0.1";
-       sha256 = "11aaiarvrm5463b77r2jimw78pr39g8apjk7bim3d8rl3ija775q";
+       sha256 = "b89ca3641c34a3366a5c67caabd04b235f74788d52e473d630a4d4bcb38a4a85";
        libraryHaskellDepends = [
          array base dph-base dph-prim-par ghc random template-haskell vector
        ];
@@ -45269,7 +45415,7 @@ self: {
      mkDerivation {
        pname = "dph-lifted-vseg";
        version = "0.7.0.1";
-       sha256 = "0vkq7kyd65znzqxh32ql2lrm30vg1wy85bnjg8g08s9q9j3j6a45";
+       sha256 = "852823874c3869041e7ad2ae823c0f6f83513315148b013bfef617d3fc3c786e";
        libraryHaskellDepends = [
          array base containers dph-base dph-lifted-base dph-prim-par ghc
          pretty random template-haskell vector
@@ -45286,7 +45432,7 @@ self: {
      mkDerivation {
        pname = "dph-par";
        version = "0.5.1.99";
-       sha256 = "0csgd8ghbxv1vwp95dn98qv1zp8229fffm9j274bmjg857588i97";
+       sha256 = "274584ca29e8c9bac8113255e75c1202dd1f3646c9b6922edf61f7051f6a4f33";
        homepage = "http://www.haskell.org/haskellwiki/GHC/Data_Parallel_Haskell";
        description = "(deprecated)";
        license = stdenv.lib.licenses.bsd3;
@@ -45298,7 +45444,7 @@ self: {
      mkDerivation {
        pname = "dph-prim-interface";
        version = "0.7.0.1";
-       sha256 = "17m03gylc61d7mx26rz70kwmi014rv1g14683vraa1b77pci5h8j";
+       sha256 = "12c112d93d6705a5f21ec890f0c2ce248058f904e767237a3d2d1846fd1ba09e";
        libraryHaskellDepends = [ base dph-base random vector ];
        jailbreak = true;
        homepage = "http://www.haskell.org/haskellwiki/GHC/Data_Parallel_Haskell";
@@ -45313,7 +45459,7 @@ self: {
      mkDerivation {
        pname = "dph-prim-par";
        version = "0.7.0.1";
-       sha256 = "13x7ribvcm965pnzissj0cwk17r5f0ag1zs7w31za17kal3r91pp";
+       sha256 = "f786940755f304f5c3e047fff01470259f30390352ebf8ed2d2655b657cca78f";
        libraryHaskellDepends = [
          base dph-base dph-prim-interface dph-prim-seq old-time random
          vector
@@ -45332,7 +45478,7 @@ self: {
      mkDerivation {
        pname = "dph-prim-seq";
        version = "0.7.0.1";
-       sha256 = "1fz95qzvk2f7zg8am73vdbk14ms420vfvapz79piip0s4bv8cnqr";
+       sha256 = "195b86f6221adc186f3affaaed3610445712e66a7b9caad0fbc789b93f2ee9bb";
        libraryHaskellDepends = [
          base dph-base dph-prim-interface ghc-prim primitive random vector
        ];
@@ -45347,7 +45493,7 @@ self: {
      mkDerivation {
        pname = "dph-seq";
        version = "0.5.1.99";
-       sha256 = "10s6qq4ayh85wvhnyl7dfdr72a76irvg83s71lww8ig988599ygp";
+       sha256 = "f7f9940a42e945c4390d470ff4768ee628717273ed506fe1e60541af08c64683";
        homepage = "http://www.haskell.org/haskellwiki/GHC/Data_Parallel_Haskell";
        description = "(deprecated)";
        license = stdenv.lib.licenses.bsd3;
@@ -45361,7 +45507,7 @@ self: {
      mkDerivation {
        pname = "dpkg";
        version = "0.0.3";
-       sha256 = "1bqrj1vqqjnv3qcs1s7lbwyzry95fzxrhi6340zqv0ibvyqnaz5k";
+       sha256 = "b37c65b1df2b828d3f20c34498fb7725f9fc3d5ff4e8a0191edb4a8c779019af";
        libraryHaskellDepends = [
          base bindings-DSL bytestring monad-loops
        ];
@@ -45378,7 +45524,7 @@ self: {
      mkDerivation {
        pname = "drClickOn";
        version = "0.1";
-       sha256 = "10rcmqa2x5xlh5pqfsg9dagf2lmrwc2bby3zklzv3x4s3yqg2ar3";
+       sha256 = "232bf1b01f9af4b13f9d7ff8b504e3b952e19e6ae969876f81b4972e14ae2c83";
        libraryHaskellDepends = [ base containers ];
        homepage = "https://github.com/cwi-swat/monadic-frp";
        description = "Monadic FRP";
@@ -45391,7 +45537,7 @@ self: {
      mkDerivation {
        pname = "draw-poker";
        version = "0.1.0.1";
-       sha256 = "16b17qfj3bah468hqsksk2rhyl33m2vyqw0rrs1wyaz75yq35257";
+       sha256 = "a78832b02fe72bcf83ce1970ecb7a863500fb3987a6a0c912150ad211d3e6199";
        revision = "1";
        editedCabalFile = "62a11039e0b634f0b372c28d87f6fe84f40a33981211c9f2bc077135abcef629";
        isLibrary = true;
@@ -45409,7 +45555,7 @@ self: {
      mkDerivation {
        pname = "drawille";
        version = "0.1.0.5";
-       sha256 = "08zmy1r1qj7adhsp4z0mr7h0qvc9gaziacjqfl0629n5x2i7zddr";
+       sha256 = "b9b57fa2e8c526610075583215bf7a896d0ce0c9157c72356cea481c72f0f523";
        isLibrary = true;
        isExecutable = true;
        libraryHaskellDepends = [ base containers ];
@@ -45424,7 +45570,7 @@ self: {
      mkDerivation {
        pname = "drifter";
        version = "0.1.0.1";
-       sha256 = "1ldqlkxkshg4i1iqvjzq01cz9mxhyaszhybhq4kngd0rig3n1qhq";
+       sha256 = "18e260c78b19b46727c17079f8b5f2b0d7f45900f8cb8d6388e4413dfba4b8d1";
        libraryHaskellDepends = [
          base bytestring postgresql-simple text time
        ];
@@ -45444,7 +45590,7 @@ self: {
      mkDerivation {
        pname = "dropbox-sdk";
        version = "0.3.1";
-       sha256 = "1s0aki1ayjickkkwmn1mc38gnd257v24wy6yj9p05qm2g8gm7xy2";
+       sha256 = "c2f7531f7aa2e2026e92de784ec43e4534fbd06035d8cae79c2c4aaf429c0ae8";
        libraryHaskellDepends = [
          base blaze-builder bytestring case-insensitive certificate conduit
          HTTP http-conduit http-types json monad-control network old-locale
@@ -45465,7 +45611,7 @@ self: {
      mkDerivation {
        pname = "dropsolve";
        version = "0.1.2.1";
-       sha256 = "1nrvrcf51jdy5vhqbnrllb3y5rgrhg1qwsd05z24s38ra40whbgp";
+       sha256 = "f72dc80151190d4dc42fa0698ec383f9e5e2c7a234db85e12ebec9501ccb3bdb";
        isLibrary = false;
        isExecutable = true;
        executableHaskellDepends = [
@@ -45485,7 +45631,7 @@ self: {
      mkDerivation {
        pname = "ds-kanren";
        version = "0.2.0.1";
-       sha256 = "14sgqd55jnqahp0mi4x46a5903bnj2f2crlfrkyg9qds73wjj7fk";
+       sha256 = "d31d29f938bae1f4fccc8e66269c90760d908a32a49358c1850a5b594ac34f93";
        libraryHaskellDepends = [ base containers logict ];
        testHaskellDepends = [ base QuickCheck tasty tasty-quickcheck ];
        description = "A subset of the miniKanren language";
@@ -45503,7 +45649,7 @@ self: {
      mkDerivation {
        pname = "dsh-sql";
        version = "0.2.0.2";
-       sha256 = "00r1wbgbkpnza1jjd14vqr4hwgfkhnz7yivkx4bla5frfdlv5q58";
+       sha256 = "a8e0b26973d9154517e973477fbe85d33d0e49c69b84266550dfdeb9dee22103";
        isLibrary = true;
        isExecutable = true;
        libraryHaskellDepends = [
@@ -45528,7 +45674,7 @@ self: {
      mkDerivation {
        pname = "dsmc";
        version = "0.1.0.1";
-       sha256 = "0va22bx3fj80rl03mv3pnwvsdjkax41pp8qxyj3yiicbyi6zzaa5";
+       sha256 = "45a9ff4df48bc5e887f41da37b03e96acaa637b777ec3a00cd004937fa12426d";
        libraryHaskellDepends = [
          attoparsec base bytestring containers entropy hslogger mwc-random
          parallel primitive repa strict transformers vector
@@ -45546,7 +45692,7 @@ self: {
      mkDerivation {
        pname = "dsmc-tools";
        version = "0.1.0.1";
-       sha256 = "0wry1dwcf3dwd780aic3v6jlrdjplrsciw1rr582a78c7anasjr0";
+       sha256 = "204badac3a0c1d2550c939f0c874a657b64ca5d9834505d069bc0dc7780b3e73";
        isLibrary = false;
        isExecutable = true;
        executableHaskellDepends = [
@@ -45564,7 +45710,7 @@ self: {
      mkDerivation {
        pname = "dson";
        version = "0.3.0.0";
-       sha256 = "15pqja0q1lram7xi5xk8dlcfg5m1z0l4zscqw24wm50hmqpxi09d";
+       sha256 = "2d81d82fae1094ca89e098e94f28f8a196e7186d68f612fba92ad3808192f896";
        libraryHaskellDepends = [ base parsec ];
        jailbreak = true;
        homepage = "https://github.com/lcycon/hs-dson";
@@ -45577,7 +45723,7 @@ self: {
      mkDerivation {
        pname = "dson-parsec";
        version = "0.4.1.1";
-       sha256 = "1zflz9vhcz7psssn6hrizmwdmrvpagxhl0648k6f1n9xj50kp99y";
+       sha256 = "3ea53b41913dd9e0cc44c4000afb5377e7da78fd314363b5d6f77c0677fad4fd";
        libraryHaskellDepends = [ base parsec ];
        jailbreak = true;
        homepage = "https://github.com/alvare/dson-parsec";
@@ -45590,7 +45736,7 @@ self: {
      mkDerivation {
        pname = "dsp";
        version = "0.2.3";
-       sha256 = "1h7y3b2gwbkq97lv6f9a4zssyqs422g5zj2bi9mq1a5fzy5i4v4v";
+       sha256 = "9b6c128bffaea8806b8a4bc85f9e104463aff5272a39b3e949782efec41afec0";
        isLibrary = true;
        isExecutable = true;
        libraryHaskellDepends = [ array base random ];
@@ -45607,7 +45753,7 @@ self: {
      mkDerivation {
        pname = "dstring";
        version = "0.4.0.4";
-       sha256 = "15zy1dhfs87hxq1qm54ym0pdhvg7l76m7vy5y06dnksb1sblhaqm";
+       sha256 = "152b48970e4b4fdb0cf0c5ef53cda1e76dd82ea89e948a03eef020ed600bfe97";
        libraryHaskellDepends = [ base base-unicode-symbols dlist ];
        jailbreak = true;
        homepage = "https://github.com/basvandijk/dstring";
@@ -45623,7 +45769,7 @@ self: {
      mkDerivation {
        pname = "dtab";
        version = "1.0";
-       sha256 = "1zx5kpljjxyzbsg0hg8ml8mig1s9hggm2nlqmbfbxmldxh3pq1j3";
+       sha256 = "43067c07ec8dd6bedcaa985a51df834987172ba2153d089e5edf7729e99da5ff";
        revision = "2";
        editedCabalFile = "50fe31cffb6f7eab4428bf547fd0c7e7804a0f20c604692a18b213d4a54a0a7a";
        isLibrary = true;
@@ -45647,7 +45793,7 @@ self: {
      mkDerivation {
        pname = "dtd";
        version = "1.1.0.2";
-       sha256 = "11sqmsxw36rn2xkccr7zrmpzijpc3j0z1cxsjcfncnj3l5iaqryp";
+       sha256 = "d767ac62a1435a661d93bab3f0811ceccaf86fcdff64c66617369bc1bbae5887";
        libraryHaskellDepends = [
          attoparsec attoparsec-conduit base blaze-builder conduit containers
          lifted-base monad-control network resourcet text transformers
@@ -45667,7 +45813,7 @@ self: {
      mkDerivation {
        pname = "dtd-text";
        version = "0.1.2.0";
-       sha256 = "1czygz52aparm4qbkfsskm9qd5wirdpccjn66nh7d62d440j1as8";
+       sha256 = "48ab2001214d9876a035c64ac66ecb919786539d5abbb930a9595d25ca7ffeb3";
        libraryHaskellDepends = [
          attoparsec base containers dtd-types text xml-types
        ];
@@ -45682,7 +45828,7 @@ self: {
      mkDerivation {
        pname = "dtd-types";
        version = "0.3.0.1";
-       sha256 = "1w2ni9b8kn242grdqb4wxvgxqpkpp9qy66d57n33l5jghlg8b0s7";
+       sha256 = "4783851e854f163a863da519e371ba775edcdfee9c2cdcf21344d889568a56f0";
        libraryHaskellDepends = [ base text xml-types ];
        homepage = "http://projects.haskell.org/dtd/";
        description = "Basic types for representing XML DTDs";
@@ -45695,7 +45841,7 @@ self: {
      mkDerivation {
        pname = "dtrace";
        version = "0.1";
-       sha256 = "0qszlhll0cx0clydypg0r0g00v8ig1aasqp1ga0jnbfr7q7rwfrr";
+       sha256 = "393b9e0f3ed92d2b817ae162ad5478116d001ec8e05ddf3c65a0334029a45f63";
        isLibrary = true;
        isExecutable = true;
        libraryHaskellDepends = [ base ];
@@ -45710,7 +45856,7 @@ self: {
      mkDerivation {
        pname = "dtw";
        version = "1.0.1.0";
-       sha256 = "15qk8r958pssgwqhxffw45vm5bpvv9wfarv9spaplrnb3sm5bzhk";
+       sha256 = "13fe55aa1ecb667ad5d56967e578dafbae527721dcb90e317f5a5f5452461397";
        libraryHaskellDepends = [ base containers vector vector-space ];
        testHaskellDepends = [
          base containers QuickCheck test-framework
@@ -45727,7 +45873,7 @@ self: {
      mkDerivation {
        pname = "dual-tree";
        version = "0.2.0.6";
-       sha256 = "0zdmycfr7b2gf63r2w48ylhcywphz9v3z79im33q1wb7p7pjiacv";
+       sha256 = "9ba928efb967f180c7a8319d3f76faf072cf20f588709187714fac931df3b57d";
        libraryHaskellDepends = [ base monoid-extras newtype semigroups ];
        description = "Rose trees with cached and accumulating monoidal annotations";
        license = stdenv.lib.licenses.bsd3;
@@ -45740,7 +45886,7 @@ self: {
      mkDerivation {
        pname = "dump";
        version = "0.2.8";
-       sha256 = "0p0wwcxm2lgfbx82s226dprd8qa526pnrnpakxmdz5svd6ib0gh4";
+       sha256 = "043eb0a2695b97df6a9feada6caf114561d4f26d46082d505fee51513be31c5c";
        libraryHaskellDepends = [
          base haskell-src-meta interpolatedstring-perl6 template-haskell
          text
@@ -45766,7 +45912,7 @@ self: {
      mkDerivation {
        pname = "duplo";
        version = "1.8.1";
-       sha256 = "1k63904aly7qwx96vqys0yx4amys8y5dl9xb9hp4x7ymw0b6h43i";
+       sha256 = "71106816e0d59f4e2e4cab27da8a47da5745ba07dae36d52e7f878aa0848c3cc";
        isLibrary = true;
        isExecutable = true;
        libraryHaskellDepends = [
@@ -45801,7 +45947,7 @@ self: {
      mkDerivation {
        pname = "dvda";
        version = "0.4";
-       sha256 = "1q8avdmzqxnr63ak0i1n6n4cvc23qkrmqlii628mis7vzfcw2yp8";
+       sha256 = "e87ac199fbfbe858913031525cf3c443b0cd8835364430d530d976fc6bdb0ae1";
        libraryHaskellDepends = [
          base containers hashable hashtables mtl unordered-containers vector
        ];
@@ -45820,7 +45966,7 @@ self: {
      mkDerivation {
        pname = "dvdread";
        version = "0.1";
-       sha256 = "1lxqm9r4zcw364yzpqaaf4nrja5n88vlwa527ixifhc80x6ffx0m";
+       sha256 = "1574e74c078841177b3ca2284e3742b628992d714ae1fb3d3183b34f72aab8d3";
        libraryHaskellDepends = [ base bytestring mtl ];
        libraryPkgconfigDepends = [ dvdread ];
        libraryToolDepends = [ c2hs ];
@@ -45834,7 +45980,7 @@ self: {
      mkDerivation {
        pname = "dvi-processing";
        version = "0.3.1";
-       sha256 = "0dp6acmrvlns85nzbbh65vd6fjam04h11kxd9bk6j6hqa2qaqa43";
+       sha256 = "8328acb050181a69e64aadcf102001554967da2e06aef56d41dad29d2b53e636";
        libraryHaskellDepends = [ base bytestring filepath transformers ];
        jailbreak = true;
        description = "Read/write DVI and TFM file";
@@ -45846,7 +45992,7 @@ self: {
      mkDerivation {
        pname = "dvorak";
        version = "0.1.0.0";
-       sha256 = "1kxnzzm24kslsyy9fsjazfz14svbh9svh6f7rnf060as864vmj5g";
+       sha256 = "afc8ba89415a01039ccdc719b875826b6b12befb4a6a97bcd7544f22eaffb6cf";
        libraryHaskellDepends = [ base containers ];
        testHaskellDepends = [ base hspec QuickCheck ];
        homepage = "https://github.com/kvanberendonck/codec-dvorak";
@@ -45859,7 +46005,7 @@ self: {
      mkDerivation {
        pname = "dwarf";
        version = "0.23";
-       sha256 = "0h6bzh628cz0qnbk4aiz5859r9va99q307scbwzvs1wn3nm6dszl";
+       sha256 = "f4eb66aa1d9607bd3f5f4c1f30704a6aa79c0a2a3f2a3297c5e033240cfccb40";
        libraryHaskellDepends = [ base binary bytestring containers ];
        description = "Parser for DWARF debug format";
        license = stdenv.lib.licenses.bsd3;
@@ -45872,7 +46018,7 @@ self: {
      mkDerivation {
        pname = "dwarf-el";
        version = "0.2.1.1";
-       sha256 = "18ba03v1m7xbsgygjgfrzr9c7fah21lr3300mhvqipicdgrb691w";
+       sha256 = "3c24b3f26b2cde8837ac008c91691050b9c352fed93df9fcd3ab9f1af6006aa1";
        libraryHaskellDepends = [
          base binary bytestring containers transformers utf8-string
        ];
@@ -45887,7 +46033,7 @@ self: {
      mkDerivation {
        pname = "dwarfadt";
        version = "0.4";
-       sha256 = "15mzv6sa2qf0g9skwq4ij35l3lqbc4x3fzwj5hkx93f8pz2bj1hi";
+       sha256 = "1106b9c4bfc88dd4272c927f373a610bd341cb9091603e757ac061a1b4d9bf96";
        isLibrary = true;
        isExecutable = true;
        libraryHaskellDepends = [
@@ -45905,7 +46051,7 @@ self: {
      mkDerivation {
        pname = "dx9base";
        version = "0.1.1";
-       sha256 = "16gwlpxfgh78sx7cb2ryqklhz5smhwk51ma260d6rg082nhy5y3i";
+       sha256 = "71f8e2a11508bc6c1a3042d550268755970fe9c43e8bc54ed7e8c0e7faa5fc99";
        libraryHaskellDepends = [ base Win32 ];
        description = "Backend for a binding to the Microsoft DirectX 9 API";
        license = stdenv.lib.licenses.bsd3;
@@ -45917,7 +46063,7 @@ self: {
      mkDerivation {
        pname = "dx9d3d";
        version = "0.1.1.1";
-       sha256 = "1y9g53jajgnlrzzg5vzgx329mii9k396xai4b04hs6gndkdrwprj";
+       sha256 = "325f9edb6cf6190d095824aa6ed29829c69ac4e8efeff2fecfd43ea9e4282ff9";
        libraryHaskellDepends = [ base dx9base Win32 ];
        librarySystemDepends = [ d3d9 ];
        description = "A binding to the Microsoft DirectX 9 API";
@@ -45930,7 +46076,7 @@ self: {
      mkDerivation {
        pname = "dx9d3dx";
        version = "0.1.1";
-       sha256 = "1n5rbq7k1g5l9y5vkadypfksai9sfx2vimdsas1if9h3jnqvvf67";
+       sha256 = "c7b8bdb1950326178356bad5b845773a45a5a7bbbea9b98b4fb4bc300f5eb9d8";
        libraryHaskellDepends = [ base dx9base dx9d3d Win32 ];
        librarySystemDepends = [ d3dx9 ];
        description = "A binding to the Microsoft DirectX 9 D3DX API";
@@ -45946,7 +46092,7 @@ self: {
      mkDerivation {
        pname = "dynamic-cabal";
        version = "0.3.5";
-       sha256 = "0fkr3hps3v0ygcah4dpzfqyfxm0rj4knivbbarllzv86h042vwxw";
+       sha256 = "bcf32d088006ed4f69566bed68279119d4ee3c76ff3602157b1eeca12f1c793a";
        libraryHaskellDepends = [
          base containers data-default directory filepath ghc ghc-paths
          haskell-generate haskell-src-exts time void
@@ -45967,7 +46113,7 @@ self: {
      mkDerivation {
        pname = "dynamic-graph";
        version = "0.1.0.8";
-       sha256 = "1lh7wlzmm1nsbzy7ahkcajyfkg4v2vbyp0992570w32bn7nl4b5k";
+       sha256 = "b32c42edb14b0c0e4e112981ebd7169bbce9bc546c4275fc5fda865a3fe507d2";
        libraryHaskellDepends = [
          base cairo colour either GLFW-b GLUtil OpenGL pango pipes
          transformers
@@ -45983,7 +46129,7 @@ self: {
      mkDerivation {
        pname = "dynamic-linker-template";
        version = "0.1.0.4";
-       sha256 = "043d8kp4a5pskfyzihm7laa1h9jchdgzvc8v32ck0mxcrigicrgq";
+       sha256 = "f865165fccac573099181bb1fd5f834c261894a2a7c2f8bd9bfa1645ee446d10";
        libraryHaskellDepends = [ base containers template-haskell unix ];
        homepage = "http://github.com/hsyl20/dynamic-linker-template";
        description = "Automatically derive dynamic linking methods from a data type";
@@ -45997,7 +46143,7 @@ self: {
      mkDerivation {
        pname = "dynamic-loader";
        version = "0.0";
-       sha256 = "0cwmwf60gfcb1xzbx9yz870fxxpdwcd0kmj4pkz6zy8l53j3mqi0";
+       sha256 = "20e23ae42814f96ffebc44d6091ae3edf6eec041dfa7be7e0f8bb9078ce39533";
        libraryHaskellDepends = [
          base directory ghc-prim hashable hashtables time transformers
        ];
@@ -46011,7 +46157,7 @@ self: {
      mkDerivation {
        pname = "dynamic-mvector";
        version = "0.1.0.3";
-       sha256 = "1nydfmhkdgynng4pn7c6f3rqdx2b21j7sqnzkb477gkri58y6335";
+       sha256 = "650ce3518979be73c89adf627d64104bf486f370861d7bc9b3d6bf366175cddb";
        libraryHaskellDepends = [ base primitive vector ];
        homepage = "https://github.com/AndrasKovacs/dynamic-mvector";
        description = "A wrapper around MVector that enables pushing, popping and extending";
@@ -46025,7 +46171,7 @@ self: {
      mkDerivation {
        pname = "dynamic-object";
        version = "0.2.1";
-       sha256 = "1xzjwsdq4v08m66lph81h67sii7qkvni5pygmh3iblx7rybsvflb";
+       sha256 = "8bbaad97cfa7d31507accfdf12ed9ef8c4a88f8101c14b8da9086c829be6f2f7";
        libraryHaskellDepends = [
          base containers lens mtl QuickCheck text transformers
        ];
@@ -46047,7 +46193,7 @@ self: {
      mkDerivation {
        pname = "dynamic-plot";
        version = "0.1.0.1";
-       sha256 = "0yrkf28hsh992bd9cx3dpc69xg444n9j819ysqjfci7wwnvzxx31";
+       sha256 = "61f4feb7e5fc44e624d63e0524932584bc9e0cbb6d7496da1229410d9170337b";
        revision = "1";
        editedCabalFile = "bf93f06c056b95264f16bd647b64220d9dd81c421045b66a9a2d2005659cecf5";
        libraryHaskellDepends = [
@@ -46070,7 +46216,7 @@ self: {
      mkDerivation {
        pname = "dynamic-pp";
        version = "0.2.0";
-       sha256 = "03y9sl3xcnp1ixi4y0i1a7frd2bgfvnb0r4pqjs38bvjkz96bbdd";
+       sha256 = "adad65d29f722f34b4c49764b0ec766f8996dd5121024f628fe15ad607d5c90f";
        libraryHaskellDepends = [
          ansi-terminal base blaze-builder bytestring Cabal hashable
          unordered-containers utf8-string
@@ -46092,7 +46238,7 @@ self: {
      mkDerivation {
        pname = "dynamic-state";
        version = "0.2.0.0";
-       sha256 = "1dp0sp5cjk7rga9jkjdhl1alpj9g6g51zm57g58b64h070b9r82k";
+       sha256 = "53a09c16380012b35079a7d41fca332fc94b55a0b0c929937af94cc9cad5e0b6";
        libraryHaskellDepends = [
          base binary bytestring hashable unordered-containers
        ];
@@ -46114,7 +46260,7 @@ self: {
      mkDerivation {
        pname = "dynobud";
        version = "1.4.0.0";
-       sha256 = "1dmgi69gsh7rm385pykajlq73m3cfaw617gkj2nv0h4x11mdp0ms";
+       sha256 = "ba82db6a089d40b0ad90f39d60b8726cd47130956afa5bd0a8f940fd9289afb6";
        isLibrary = true;
        isExecutable = true;
        libraryHaskellDepends = [
@@ -46146,7 +46292,7 @@ self: {
      mkDerivation {
        pname = "dyre";
        version = "0.8.12";
-       sha256 = "10hnlysy4bjvvznk8v902mlk4jx95qf972clyi1l32xkqrf30972";
+       sha256 = "e224305cc6b38b4143f49489931c2ea94b326915206d34eddf5b2ee2b5a71682";
        libraryHaskellDepends = [
          base binary directory executable-path filepath ghc-paths io-storage
          process time unix xdg-basedir
@@ -46161,7 +46307,7 @@ self: {
      mkDerivation {
        pname = "dzen-utils";
        version = "0.1.1";
-       sha256 = "05s47s40amydwd6dc75rnaganx2qi2spx668p8x0xs0fdwnqvsf0";
+       sha256 = "c0e98d2d6f0ee80e3abac8987eb5885874ab9eb2b91cd64ce3cd5705883e4417";
        libraryHaskellDepends = [ base colour process ];
        description = "Utilities for creating inputs for dzen";
        license = "GPL";
@@ -46172,7 +46318,7 @@ self: {
      mkDerivation {
        pname = "eager-sockets";
        version = "0.1";
-       sha256 = "10g8w50hhw8ap6lvsv9apmmfaqvqjwzhnq4mx1npapb8cmsmzgdb";
+       sha256 = "abbd5f7565685d756de895600b3f977863e56abd2a6dbda9b90a710841e1e881";
        libraryHaskellDepends = [ base bytestring network ];
        jailbreak = true;
        description = "Socket operations with timeouts";
@@ -46186,7 +46332,7 @@ self: {
      mkDerivation {
        pname = "easy-api";
        version = "0.1.0.0";
-       sha256 = "0ch4vb7h499gfc2j60gfzj164f3s8rk9hw22g36ymiihsi3ipl1b";
+       sha256 = "2bd01b47d430c6eacd7842709866467a386282fcee012305732f2502cfda0432";
        libraryHaskellDepends = [
          aeson base bytestring either http-conduit mtl resourcet text
        ];
@@ -46202,7 +46348,7 @@ self: {
      mkDerivation {
        pname = "easy-file";
        version = "0.2.1";
-       sha256 = "0v75081bx4qzlqy29hh639nzlr7dncwza3qxbzm9njc4jarf31pz";
+       sha256 = "ff86e1b29284499bea5f1d0ff539b3ed64fa6d1a06c2243ca61f93be0202e56c";
        libraryHaskellDepends = [ base directory filepath time unix ];
        homepage = "http://github.com/kazu-yamamoto/easy-file";
        description = "Cross-platform File handling";
@@ -46216,7 +46362,7 @@ self: {
      mkDerivation {
        pname = "easyjson";
        version = "0.1.0.1";
-       sha256 = "19464q0xc3pk1jbf3p94ym97i90600dzhyy4ddv9xf4ligvgbsg2";
+       sha256 = "e2e9f5f68b94b89e766bc47bf81b0006a47852f524dde1960cf30ed6012686a4";
        libraryHaskellDepends = [
          base mtl parsec text unordered-containers vector
        ];
@@ -46232,7 +46378,7 @@ self: {
      mkDerivation {
        pname = "easyplot";
        version = "1.0";
-       sha256 = "18kndgvdj2apjpfga6fp7m16y1gx8zrwp3c5vfj03sx4v6jvciqk";
+       sha256 = "1347b6a5d9a4eb01a4db858dcbf347fd056f423dd719f5dc955709d9f66b76a2";
        libraryHaskellDepends = [ base process ];
        homepage = "http://hub.darcs.net/scravy/easyplot";
        description = "A tiny plotting library, utilizes gnuplot for plotting";
@@ -46246,7 +46392,7 @@ self: {
      mkDerivation {
        pname = "easyrender";
        version = "0.1.0.1";
-       sha256 = "147r2jw0vrld73637vw4k83v4xf8r1dl9cy6gcll9kkpkcck8lkn";
+       sha256 = "765234199b77ce44297bc6b3445bc8c875b2079a84ef33cc388de60db814f990";
        libraryHaskellDepends = [
          base bytestring containers mtl superdoc zlib
        ];
@@ -46262,7 +46408,7 @@ self: {
      mkDerivation {
        pname = "ebeats";
        version = "0.1.0";
-       sha256 = "0r3pl63fxrrfafwp3791xh0c47pb4jqqcm9lk52g0gaqg0s8x5qk";
+       sha256 = "13978e3478583df04499345586b124eb1ec200ec219d71b9532ee7ee86a17764";
        libraryHaskellDepends = [ base time ];
        jailbreak = true;
        description = "Time in ebeats";
@@ -46276,7 +46422,7 @@ self: {
      mkDerivation {
        pname = "ec2-signature";
        version = "3.1";
-       sha256 = "1yzyz2a4fm2q6r3nlfjqjmm4fabhl31mq8dgg9shfd3p7cm646g0";
+       sha256 = "e019622a3b773407757aaf215cc3a07029476a95583a6a473658544794f8fefb";
        libraryHaskellDepends = [
          base base64-bytestring bytestring http-types SHA
        ];
@@ -46296,7 +46442,7 @@ self: {
      mkDerivation {
        pname = "ecdsa";
        version = "0.2";
-       sha256 = "1300m9rszfjmwqbqb7x9clg6y3qwgwa9s38w72r6plhzbiqmy28n";
+       sha256 = "16095f715c1fd26bb2381c0d9d147f1c0f6f1e65a99f8517e655baaf73aa008c";
        libraryHaskellDepends = [
          base bytestring crypto-api crypto-pubkey-types hecc
        ];
@@ -46313,7 +46459,7 @@ self: {
      mkDerivation {
        pname = "ecma262";
        version = "0.0.0";
-       sha256 = "1hvi5adgqjkxq1y10d7jr39h4i63khmgrgmlfk09114flllnh8gm";
+       sha256 = "f5216829a58e8490c074b4befc2a9cc34402d3c8f234107cc07d4afc9a2a71c3";
        isLibrary = true;
        isExecutable = true;
        libraryHaskellDepends = [
@@ -46333,7 +46479,7 @@ self: {
      mkDerivation {
        pname = "ecu";
        version = "0.0.8";
-       sha256 = "1afb507ywpy2y29zmvywj25qw4gn1h5sd0k051jiw03yvdasn0wj";
+       sha256 = "9203ab55db7e001e65286082a60b0cf6118e8b90dceffa93f0c25fee0f28cba9";
        isLibrary = false;
        isExecutable = true;
        executableHaskellDepends = [
@@ -46351,7 +46497,7 @@ self: {
      mkDerivation {
        pname = "ed25519";
        version = "0.0.2.0";
-       sha256 = "0x08p2941g7f3xsg8jgy5j73v0dihg47j2i1hb53c7h4jhvc1fmj";
+       sha256 = "b2bac03694041e36ca82210a79c883b1813d8e2cfe49f4741feebc4092b80874";
        libraryHaskellDepends = [ base bytestring ];
        testHaskellDepends = [ base bytestring hlint QuickCheck ];
        homepage = "http://thoughtpolice.github.com/hs-ed25519";
@@ -46365,7 +46511,7 @@ self: {
      mkDerivation {
        pname = "ed25519-donna";
        version = "0.1";
-       sha256 = "1x7dmv53hj9j360rwyq379mfzsddbabyzpl37i5fmjwpy160c2r6";
+       sha256 = "260b064cf097cbea4a3c83deef975aade9ef6a3a037b9e8119324938caaeedf4";
        libraryHaskellDepends = [ base bytestring crypto-api ];
        jailbreak = true;
        homepage = "github.com/tommd/hs-ed25519-donna";
@@ -46380,7 +46526,7 @@ self: {
      mkDerivation {
        pname = "eddie";
        version = "1.0.0";
-       sha256 = "1zq2xadpl33mxdn99aim5rscwqgpy5w0lk7pa3k3h9x3d3c3qzxx";
+       sha256 = "bd7f3cd868a32738e650f74c0a78f1f761ce742e35aa946ceb750c7a9bea02ff";
        isLibrary = false;
        isExecutable = true;
        executableHaskellDepends = [
@@ -46401,7 +46547,7 @@ self: {
      mkDerivation {
        pname = "ede";
        version = "0.2.8.2";
-       sha256 = "0j0b0pn9apvpqxb0gnxxp51g32xc47jky4njb9jn0x59jssc1g1q";
+       sha256 = "38bcc0b496a97460655ad2123fe521ac8bf142b9bddb0756c7775f95ec050b48";
        libraryHaskellDepends = [
          aeson ansi-wl-pprint base bifunctors bytestring comonad directory
          filepath free lens mtl parsers scientific semigroups text
@@ -46420,7 +46566,7 @@ self: {
      mkDerivation {
        pname = "edenmodules";
        version = "1.2.0.0";
-       sha256 = "1wbasb9lsw2rycl2ibd8r9p3d9dl8gd75390qsc83znqx802ylxj";
+       sha256 = "b2532f00ead8fe8198c6208d72da43b4a5366ecaa8ad2828f359704dd3d26af1";
        libraryHaskellDepends = [ base containers deepseq parallel ];
        jailbreak = true;
        homepage = "http://www.mathematik.uni-marburg.de/~eden";
@@ -46434,7 +46580,7 @@ self: {
      mkDerivation {
        pname = "edenskel";
        version = "2.1.0.0";
-       sha256 = "1bf5zw1x4f6a801ig2b8b84kbnmp0asn804gkm18v9fjcchz3j9q";
+       sha256 = "38c9f12163d2a58d429d8f0064b502b7da35095a6889170340ca38d203ffc5ad";
        libraryHaskellDepends = [ base edenmodules parallel ];
        description = "Semi-explicit parallel programming skeleton library";
        license = stdenv.lib.licenses.bsd3;
@@ -46449,7 +46595,7 @@ self: {
      mkDerivation {
        pname = "edentv";
        version = "4.10.0";
-       sha256 = "0jkcva53vm8lm76z947xms8a2zkh9sn9951cwry8k7r132dmcn32";
+       sha256 = "6258569b18219f897ce62c9494ac4e707ea190aefd90f4cda914d53d8ada6c4a";
        isLibrary = false;
        isExecutable = true;
        executableHaskellDepends = [
@@ -46469,7 +46615,7 @@ self: {
      mkDerivation {
        pname = "edge";
        version = "0.9.0.2";
-       sha256 = "0rd95pw3b83zg50i29g6bvqh4dnz5ma9l3v5r1hhszmrkpyfvzkv";
+       sha256 = "7bfeedfc9db97e0d61c8650f9a542ddf3602f15ee6251141797fa035f82da965";
        isLibrary = false;
        isExecutable = true;
        executableHaskellDepends = [
@@ -46489,7 +46635,7 @@ self: {
      mkDerivation {
        pname = "edit-distance";
        version = "0.2.2.1";
-       sha256 = "0jkca97zyv23yyilp3jydcrzxqhyk27swhzh82llvban5zp8b21y";
+       sha256 = "3e8885ee2f56ad4da940f043ae8f981ee2fe336b5e8e4ba3f7436cff4f526c4a";
        libraryHaskellDepends = [ array base containers random ];
        testHaskellDepends = [
          array base containers QuickCheck random test-framework
@@ -46505,7 +46651,7 @@ self: {
      mkDerivation {
        pname = "edit-distance-vector";
        version = "1.0.0.2";
-       sha256 = "00j0lmj7wz5bm5z4v0v3bamf1pnrlmjkc2ysb5d16dqwi9768x85";
+       sha256 = "0575644e8a1c37135a59da0b3665a5d9dee0aa5a63834d7ea9ab7c7e64a54002";
        libraryHaskellDepends = [ base vector ];
        testHaskellDepends = [
          base QuickCheck quickcheck-instances vector
@@ -46520,7 +46666,7 @@ self: {
      mkDerivation {
        pname = "edit-lenses";
        version = "0.2";
-       sha256 = "1nrpbrq38q779s0fbzaxig2fdqgg9qg41vajx7lbhasal6aiclya";
+       sha256 = "ca531695a14a2bb8e8e952ed401e4eefe1e6c48b5dfde5804ee76034705e37db";
        libraryHaskellDepends = [
          base containers data-default lattices mtl
        ];
@@ -46534,7 +46680,7 @@ self: {
      mkDerivation {
        pname = "edit-lenses-demo";
        version = "0.1";
-       sha256 = "0dvxiwhbmknmg4w5dj202g8r0capvgy3rn6c757ci5nhcmr4lypc";
+       sha256 = "ec7a4a7265d096c84e39ccd83cfcdb573190d11340c8563879d5ceba208f7d37";
        isLibrary = false;
        isExecutable = true;
        executableHaskellDepends = [ base ];
@@ -46547,7 +46693,7 @@ self: {
      mkDerivation {
        pname = "editable";
        version = "1.0.0.2";
-       sha256 = "15jz0b913xd8yd3nzk4vrlj0vzbhjarl05h9j0mdcfgxns5j0yxi";
+       sha256 = "b17b208bb6fd39d62a90091640b39270fd0d24cd9bcc6f47f3a8f511d2025f96";
        libraryHaskellDepends = [ base text vty vty-ui ];
        jailbreak = true;
        homepage = "https://github.com/maxpow4h/editable";
@@ -46561,7 +46707,7 @@ self: {
      mkDerivation {
        pname = "editline";
        version = "0.2.1.1";
-       sha256 = "101zhzja14n8bhbrly7w2aywx3sxyzgyjdrmgpg4gn4alf4lzdlz";
+       sha256 = "9fb64f89a38ad847de7d3537e9dff75d8fcebd12fc789a175cc892a0e4873f80";
        libraryHaskellDepends = [ base ];
        jailbreak = true;
        homepage = "http://code.haskell.org/editline";
@@ -46577,7 +46723,7 @@ self: {
      mkDerivation {
        pname = "editor-open";
        version = "0.6.0.0";
-       sha256 = "0raj0s8v72kz63hqpqhf58sx0a8mcwi4ania40spjirdrsdx3i9g";
+       sha256 = "2fc5d19bce2d477935202a5a4522671529d0352a0ee28be1307f8ab391065265";
        isLibrary = true;
        isExecutable = true;
        libraryHaskellDepends = [
@@ -46599,7 +46745,7 @@ self: {
      mkDerivation {
        pname = "effect-handlers";
        version = "0.1.0.6";
-       sha256 = "0i7glghwh35pfyzznzabaf8fnadk00lpajmasw5h5ndjl2dmqzy9";
+       sha256 = "c97f5c9ba0b2d9020bd7aa4a752900b329eb90534b7dfbbf77b70cc8e1a3ef44";
        libraryHaskellDepends = [ base free kan-extensions mtl ];
        testHaskellDepends = [
          base hspec hspec-discover HUnit QuickCheck
@@ -46614,7 +46760,7 @@ self: {
      mkDerivation {
        pname = "effect-monad";
        version = "0.6.1";
-       sha256 = "0kbjsdiv2x84spbw4qrgk76xwwgqrqhasim83h2jjwvn4qdpyjw8";
+       sha256 = "884b7f1b26767329051ca846ad20cef871decd992f63c2d7d50475b163d3724d";
        libraryHaskellDepends = [ base ghc-prim type-level-sets ];
        description = "Embeds effect systems into Haskell using parameteric effect monads";
        license = stdenv.lib.licenses.bsd3;
@@ -46629,7 +46775,7 @@ self: {
      mkDerivation {
        pname = "effective-aspects";
        version = "0.1.0.0";
-       sha256 = "0hcczdc98w8mqhap20dm0dmxbmqrxa8xxs8mjx4lga7y2n6wq22i";
+       sha256 = "5108cc8d15fea847499715e9de91ea19d7d56b03b5017115c415719458fb8c41";
        libraryHaskellDepends = [
          base ghc-prim hashtables HUnit mtl QuickCheck
        ];
@@ -46652,7 +46798,7 @@ self: {
      mkDerivation {
        pname = "effective-aspects-mzv";
        version = "0.1.0.1";
-       sha256 = "03mignf38inf10l19mcsjgjb0935lm53b29xy39pkcycrpmp0ckj";
+       sha256 = "723270ebcdccb379d3f03d89354aa56524b0e4939ad5142808ce46349c7db10e";
        libraryHaskellDepends = [
          base ghc-prim hashtables HUnit mzv QuickCheck
        ];
@@ -46672,7 +46818,7 @@ self: {
      mkDerivation {
        pname = "effects";
        version = "0.2.2";
-       sha256 = "0ysz02qvw9gg271dsign11hs7cfsz7xfc4kjmggf10j86lcpi034";
+       sha256 = "64807819354882e0deab7212e6faf9dab1a36108f645ddc211ef25beb1005f7b";
        libraryHaskellDepends = [ base containers newtype void ];
        homepage = "http://github.com/sjoerdvisscher/effects";
        description = "Computational Effects";
@@ -46684,7 +46830,7 @@ self: {
      mkDerivation {
        pname = "effects-parser";
        version = "0.1";
-       sha256 = "0vjjld95kg02a4nr2a0lwlcwaq3867qvbbjk8b1g6fd3d1qj456r";
+       sha256 = "d914227168a339f3c24253aeb5f1316860c519e51428912d5102bc5952a3526e";
        libraryHaskellDepends = [ base effects ];
        homepage = "http://github.com/nybble41/effects-parser";
        description = "Parser Effect for the Control.Effects Library";
@@ -46696,7 +46842,7 @@ self: {
      mkDerivation {
        pname = "effin";
        version = "0.3.0.1";
-       sha256 = "0rckxjdkw5p4yy1kizj1z8kp7sxfxxhh9s7714jsn9in7lc4lsif";
+       sha256 = "2e6a4a183d3626ab2509e7e80461efaeeb7327fa41fe3883f7e4163e9bec9365";
        libraryHaskellDepends = [ base mtl ];
        homepage = "https://github.com/YellPika/effin";
        description = "A Typeable-free implementation of extensible effects";
@@ -46712,7 +46858,7 @@ self: {
      mkDerivation {
        pname = "egison";
        version = "3.5.9";
-       sha256 = "16d3c4r72f6hv8v7zbcqwjjc1c53895kxjn1m61d2fhz8gmb8yq0";
+       sha256 = "007bb4ea431f3ad182a9c1ca3e4b42a3b0c0a4e498ad7f36dad038713261a399";
        isLibrary = true;
        isExecutable = true;
        libraryHaskellDepends = [
@@ -46738,7 +46884,7 @@ self: {
      mkDerivation {
        pname = "egison-quote";
        version = "0.2";
-       sha256 = "1qmbivr4lp8m27ns5cz38fkkynfky9z73hqr173dhyvqccjamfgk";
+       sha256 = "f3b9aa2463787bd8c60919c3717ef2d3593fa743e3b3a2ed11155d4af28eabe2";
        libraryHaskellDepends = [
          base egison mtl parsec template-haskell
        ];
@@ -46756,7 +46902,7 @@ self: {
      mkDerivation {
        pname = "egison-tutorial";
        version = "3.5.9";
-       sha256 = "1ay9m7ibl2z19yq9pd3fwghbyki6cawg3w9x42dllncjrwxwlh4m";
+       sha256 = "9540ca3bcf92594a9b203df1f1b862264ebfe0e36eb49bb04fe10bbae2a9c9ab";
        isLibrary = false;
        isExecutable = true;
        executableHaskellDepends = [
@@ -46776,7 +46922,7 @@ self: {
      mkDerivation {
        pname = "ehaskell";
        version = "0.7";
-       sha256 = "0d7j20lrxy5qy1ybgywfjk0d0f6iin37nfw9zdbmhi1z2l89mmnj";
+       sha256 = "d2d69a10153f445857fb893b7b868dd138d0c0948efbb77cf0b8f89e2910f234";
        isLibrary = false;
        isExecutable = true;
        executableHaskellDepends = [
@@ -46796,7 +46942,7 @@ self: {
      mkDerivation {
        pname = "ehs";
        version = "0.7.0";
-       sha256 = "0kckic7v6gab6ksbdmnxbv41fm68zvhfcmvshln9hxmq2mgli11x";
+       sha256 = "3d84485f15b876982c857a57e6e0fec85417c85eddd6b6f4344b3db30f8b934d";
        revision = "3";
        editedCabalFile = "e27ea9e604b3868e61e330abcd605d550371ef7f2c27e12e60b1caad99458222";
        isLibrary = true;
@@ -46819,7 +46965,7 @@ self: {
      mkDerivation {
        pname = "eibd-client-simple";
        version = "0.0.4";
-       sha256 = "14nxahznqy6xfjgyi8d11b4hgrw431ywqc5hkz0lbpgxysgkc61d";
+       sha256 = "2d18369ff6fddd45c19fb030cc7d1884e707c90aa1a1e89f74dd786c3f54dd92";
        revision = "1";
        editedCabalFile = "5154a0f9083521b4c60cee92f2614b253961fd1e2dd9e7c5b541630df8597d80";
        libraryHaskellDepends = [
@@ -46839,7 +46985,7 @@ self: {
      mkDerivation {
        pname = "eigen";
        version = "2.1.6";
-       sha256 = "0287j907pasjb7w7bwr6snb4qic7j14msxhps445yjfkqa2arzfz";
+       sha256 = "dffdac84c2d3495f08d117765d499087454c96d526f375f85952ab7b40920709";
        libraryHaskellDepends = [
          base binary bytestring primitive transformers vector
        ];
@@ -46859,7 +47005,7 @@ self: {
      mkDerivation {
        pname = "either";
        version = "4.4.1";
-       sha256 = "1jq9b7mwljyqxmcs09bnqzza6710sfk2x444p3aagjlvq3mpvrci";
+       sha256 = "91e57debc09bcaa7d4b884902ea6d3201ca3fec77625a059edd84bcaeb5909cb";
        libraryHaskellDepends = [
          base bifunctors exceptions free mmorph monad-control MonadRandom
          mtl profunctors semigroupoids semigroups transformers
@@ -46875,7 +47021,7 @@ self: {
      mkDerivation {
        pname = "either-unwrap";
        version = "1.1";
-       sha256 = "0g1f5m7bcpnyg2sdvwx8x34ml6dqfrn326s8pbfciaqqf7wddayc";
+       sha256 = "ccabd6f87118abc8dcba481b316c76b8195ac9e8a8f3ddb478de5eb64e2d2e3c";
        libraryHaskellDepends = [ base ];
        homepage = "http://github.com/gcross/either-unwrap";
        description = "Functions for probing and unwrapping values inside of Either";
@@ -46887,7 +47033,7 @@ self: {
      mkDerivation {
        pname = "eithers";
        version = "0.2.0";
-       sha256 = "069w3qbyghs1w8wqimj54dwblq5rx1ylgflzzc4cwnjn0aqzgs45";
+       sha256 = "85e8f7b102565ace08fb9fba477de8b960ba782345d68839e241c3e7171e3c19";
        description = "None";
        license = stdenv.lib.licenses.bsd3;
        hydraPlatforms = stdenv.lib.platforms.none;
@@ -46901,7 +47047,7 @@ self: {
      mkDerivation {
        pname = "ekg";
        version = "0.4.0.8";
-       sha256 = "0cp88b5bf4bpjd6qzib00n7j76svwsykzizk52fk1dmknfx8h12v";
+       sha256 = "5b0488bab3b3b6309d28f3c73fbde65b9b238f0560c58f4d937711b7ca42e832";
        libraryHaskellDepends = [
          aeson base bytestring ekg-core ekg-json filepath network snap-core
          snap-server text time transformers unordered-containers
@@ -46919,7 +47065,7 @@ self: {
      mkDerivation {
        pname = "ekg-bosun";
        version = "1.0.4";
-       sha256 = "0cjwv99dbb1spfn25vdl4ikxr10s7yqr9ih36amvs02rnb47lx7f";
+       sha256 = "ee747ac8b25900bdab3203c694b13f1a84dc6724b4ed22acbb3aacd552da5c32";
        libraryHaskellDepends = [
          aeson base ekg-core http-client lens network network-uri old-locale
          text time unordered-containers vector wreq
@@ -46936,7 +47082,7 @@ self: {
      mkDerivation {
        pname = "ekg-carbon";
        version = "1.0.4";
-       sha256 = "0l1gg13wxyivcxcsmzq6wv7ma4vk6afxjmw7f9n9dc3zdga0v772";
+       sha256 = "e29c0dd46b7fb0966c728757d99d32731355cfe606ffaa59673bface47782f50";
        libraryHaskellDepends = [
          base ekg-core network network-carbon text time unordered-containers
          vector
@@ -46953,7 +47099,7 @@ self: {
      mkDerivation {
        pname = "ekg-core";
        version = "0.1.1.0";
-       sha256 = "07h6lwig1cwb526ack1g3f6w8irmaj4kibn11ihhdffk7avix8bv";
+       sha256 = "7ba11eb73ad3b906610cc1ae3889543547c48d1b2f4ca68c288bb3f022a7061e";
        libraryHaskellDepends = [
          base containers ghc-prim text unordered-containers
        ];
@@ -46968,7 +47114,7 @@ self: {
      mkDerivation {
        pname = "ekg-json";
        version = "0.1.0.0";
-       sha256 = "1nhqlajidg94zk6rs86ri5ar4cmkbdz04hwjp8qgam0vgpp5bi2j";
+       sha256 = "52c455ee7d1b54f530ba9243027e5bb332925589d9209dcdfc24bd16a5a218da";
        libraryHaskellDepends = [
          aeson base ekg-core text unordered-containers
        ];
@@ -46984,7 +47130,7 @@ self: {
      mkDerivation {
        pname = "ekg-log";
        version = "0.1.0.3";
-       sha256 = "1rgjpd0cksxxr1934k9xpzhyzsl54d7yp1mh65m85z7665kcjshw";
+       sha256 = "1c6ac96631e6fc826a31b086eb4f2385eaefe1bf3d4d3252c8bdebc940bbf2e5";
        libraryHaskellDepends = [
          aeson base bytestring directory ekg-core fast-logger filepath text
          time unix unordered-containers
@@ -47002,7 +47148,7 @@ self: {
      mkDerivation {
        pname = "ekg-push";
        version = "0.0.3";
-       sha256 = "1yxp0s3i87zc205bqkw8arq8n0y225gin94x98csldb9rd0k0s5y";
+       sha256 = "be683041cb6935aa194a9d241b5f11c2038b7056884fbc0a10ec1f148706b7fb";
        isLibrary = true;
        isExecutable = true;
        libraryHaskellDepends = [
@@ -47023,7 +47169,7 @@ self: {
      mkDerivation {
        pname = "ekg-rrd";
        version = "0.2.1.69";
-       sha256 = "172p0whjyql5in94rcpr6h13zilhd84qp54z8qvk23kg5jqaf43r";
+       sha256 = "7910a7b02c6f0e3137469f948b096a90c63f0234f9b24c928d85622f2107579c";
        libraryHaskellDepends = [
          base directory ekg-core mtl process text time unordered-containers
        ];
@@ -47044,7 +47190,7 @@ self: {
      mkDerivation {
        pname = "ekg-statsd";
        version = "0.2.0.3";
-       sha256 = "02sknwz5cqwy5byqjiyc6nfppmbmfnxndp3dcs4lz276221h91hn";
+       sha256 = "1686048310e6884f89666ddc66bb7575d57b9d35cc4789fd2a9e63563eb7530b";
        libraryHaskellDepends = [
          base bytestring ekg-core network text time unordered-containers
        ];
@@ -47058,7 +47204,7 @@ self: {
      mkDerivation {
        pname = "electrum-mnemonic";
        version = "0.1.2";
-       sha256 = "1lswfw72imi326146dyvva3w9g4v5725kj817q9bjgrfmzn2k2k3";
+       sha256 = "638a29ecaf2e3fb9123e01c959c4299bbcc487dadb3743821123d6280e775cd3";
        libraryHaskellDepends = [ base ];
        testHaskellDepends = [ base tasty tasty-quickcheck ];
        description = "easy to remember mnemonic for a high-entropy value";
@@ -47071,7 +47217,7 @@ self: {
      mkDerivation {
        pname = "elerea";
        version = "2.8.0";
-       sha256 = "1sc71775f787dh70ay9fm6x6npsn81yci9yr984ai87ddz023sab";
+       sha256 = "4be921c06feda0a8084ad9a7c87c40565f6bbaa92e79050e6c071d57ce0987e9";
        libraryHaskellDepends = [
          base containers transformers transformers-base
        ];
@@ -47084,7 +47230,7 @@ self: {
      mkDerivation {
        pname = "elerea-examples";
        version = "2.2.3";
-       sha256 = "17m52c6qa905wpfanllhnaizq6vv2hp0ldfmlv10b0hbzjs29bx1";
+       sha256 = "a1af24b4fc0b8205c2a6d5350a2e147b1bfca3b29052abdce50524850d13a59e";
        isLibrary = false;
        isExecutable = true;
        executableHaskellDepends = [ base elerea GLFW OpenGL ];
@@ -47097,7 +47243,7 @@ self: {
      mkDerivation {
        pname = "elerea-sdl";
        version = "0.1.1";
-       sha256 = "1dfbgnwn0jj3lv2fskc2k3m4h0crars2d1p0gpj265r4k58qis36";
+       sha256 = "66e8885199241723e47de086267456990148ea98824dedc4a6434a60b97dcbb5";
        libraryHaskellDepends = [ base elerea SDL ];
        homepage = "http://github.com/singpolyma/elerea-sdl";
        description = "Elerea FRP wrapper for SDL";
@@ -47109,7 +47255,7 @@ self: {
      mkDerivation {
        pname = "elevator";
        version = "0.2.3";
-       sha256 = "1m509dh5k9ci87g22gd2j8lfg4hm4wn156gvd86p3r636c5hbdw2";
+       sha256 = "82b7050b33c3e4710d6afb99122c271592e72892a23d21de4191a559604ba0d4";
        libraryHaskellDepends = [ base extensible transformers ];
        homepage = "https://github.com/fumieval/elevator";
        description = "Immediately lifts to a desired level";
@@ -47121,13 +47267,28 @@ self: {
      mkDerivation {
        pname = "elf";
        version = "0.27";
-       sha256 = "19ylk13ny2clwfgqv6r55h80ghlgzbwydzrfy1msyxcxn4zmdpjs";
+       sha256 = "5ade563fb19d75af6bf02effe6f9fa8fc207102c259b8d9fe394096f4798d4a7";
        libraryHaskellDepends = [ base binary bytestring ];
        homepage = "http://github.com/erikcharlebois/elf";
        description = "Parser for ELF object format";
        license = stdenv.lib.licenses.bsd3;
      }) {};
 
+  "elm-bridge" = callPackage
+    ({ mkDerivation, base, hspec, template-haskell }:
+     mkDerivation {
+       pname = "elm-bridge";
+       version = "0.1.0.0";
+       sha256 = "5eaaefea61b2a3e42c8da5dce5c310b349461261b7052500b2e0bd5e8c8a68d8";
+       revision = "1";
+       editedCabalFile = "705fd50300a9611e7be3908004980f1a82589bd82e1ea2f9bf1ec67396e86ca1";
+       libraryHaskellDepends = [ base template-haskell ];
+       testHaskellDepends = [ base hspec ];
+       homepage = "http://github.com/agrafix/elm-bridge";
+       description = "Derive Elm types from Haskell types";
+       license = stdenv.lib.licenses.bsd3;
+     }) {};
+
   "elm-build-lib" = callPackage
     ({ mkDerivation, base, bytestring, containers, elm-compiler
      , elm-core-sources, file-embed, template-haskell
@@ -47135,7 +47296,7 @@ self: {
      mkDerivation {
        pname = "elm-build-lib";
        version = "0.14.0.0";
-       sha256 = "12hhyjr3bshbz66zxl5jfs4s3qx6laqqwcim3kf8rj2vh12h6wj5";
+       sha256 = "45720345805bc88cdc1c35328eb1a2a6e3a18976b2d0fe8df90bea35b2f4108a";
        libraryHaskellDepends = [
          base bytestring containers elm-compiler elm-core-sources file-embed
          template-haskell
@@ -47159,7 +47320,7 @@ self: {
      mkDerivation {
        pname = "elm-compiler";
        version = "0.15";
-       sha256 = "1g3q1z6bji1vx36kfkn8qayidds29b0jkk7k70sip4055jr4jc5n";
+       sha256 = "b63049b22c05901b3538f3cc29c14a42b716bdc2c84e37cde83b44b9cc0f78bc";
        isLibrary = true;
        isExecutable = true;
        libraryHaskellDepends = [
@@ -47195,7 +47356,7 @@ self: {
      mkDerivation {
        pname = "elm-core-sources";
        version = "1.0.0";
-       sha256 = "1yr0csgz0hv25cz3jslap0adwvfcvv35bns32b9g0vyda1fm00x4";
+       sha256 = "a403505d50cd6ff0d21243db55c6decc6dde14b88a6a393e2b6243f09f6620fb";
        libraryHaskellDepends = [
          base bytestring containers file-embed template-haskell
        ];
@@ -47213,7 +47374,7 @@ self: {
      mkDerivation {
        pname = "elm-get";
        version = "0.1.3";
-       sha256 = "1did7vjd1h2kh5alndd2b63zi8b1m9hf6k1k75yxwvw6f6mz5i4q";
+       sha256 = "98c4f2ab71866fde7d39334ce360aa61a1f88759a2354b558153c0d0e43e2db6";
        isLibrary = true;
        isExecutable = true;
        libraryHaskellDepends = [
@@ -47239,7 +47400,7 @@ self: {
      mkDerivation {
        pname = "elm-init";
        version = "1.0.1.0";
-       sha256 = "0jvdln18dhsxly33ysy1vv1740ri1576x44jn10gjva432rp8rwx";
+       sha256 = "9d6774b318446df940b092906e4e09310372c2dec16b3f86a75dc38682a56d4b";
        isLibrary = false;
        isExecutable = true;
        executableHaskellDepends = [
@@ -47258,7 +47419,7 @@ self: {
      mkDerivation {
        pname = "elm-make";
        version = "0.1.2";
-       sha256 = "10yli9nxfyykkr3p2dma5zgblwgx2434axjj17a878xd0r4841sb";
+       sha256 = "4b07824806ada383d4095276450611fd71bade2faa3671479ed37bd76d8ad483";
        isLibrary = false;
        isExecutable = true;
        executableHaskellDepends = [
@@ -47283,7 +47444,7 @@ self: {
      mkDerivation {
        pname = "elm-package";
        version = "0.5";
-       sha256 = "08wsl42gf5wf9pmsnld38p2m675ljihpzkrvn3dzh6zf0dwblm5n";
+       sha256 = "b654ba7803ee1bf8dbb03bcf7f6194b41c53c545a351abeb4d8e17f704a19a23";
        isLibrary = true;
        isExecutable = true;
        libraryHaskellDepends = [
@@ -47315,7 +47476,7 @@ self: {
      mkDerivation {
        pname = "elm-reactor";
        version = "0.3.1";
-       sha256 = "0j8md3cqg7wrcx85s5hj8g812zvrr3y4833n0wc3dvfa3wlblpga";
+       sha256 = "ea5dba281fcaed361807760c44fcc8797f11d04312165d5067999f87d9681549";
        isLibrary = false;
        isExecutable = true;
        executableHaskellDepends = [
@@ -47339,7 +47500,7 @@ self: {
      mkDerivation {
        pname = "elm-repl";
        version = "0.4.1";
-       sha256 = "05fyk3q7243c8p4kw03jggrvp8qfgcfanr291bmgnn9s1lk0q253";
+       sha256 = "a3080c260d3a59fbea0a4964ab1c7b0ea3bbf37b72003ec9456c1071f098de15";
        isLibrary = false;
        isExecutable = true;
        executableHaskellDepends = [
@@ -47365,7 +47526,7 @@ self: {
      mkDerivation {
        pname = "elm-server";
        version = "0.11.0.1";
-       sha256 = "0nnkhmmm4cl6a314xxh5qwxkjsc3k3vcwdfar62578ykarxb53g1";
+       sha256 = "e18db27a56d3a35384c9ca35cef6988369393bc705f64ec2508632526b85d35a";
        isLibrary = false;
        isExecutable = true;
        executableHaskellDepends = [
@@ -47385,7 +47546,7 @@ self: {
      mkDerivation {
        pname = "elm-yesod";
        version = "0.2";
-       sha256 = "0hza3khwspwlqbyllh2w1083hh19hslc0lhdryq1bbs8bssird39";
+       sha256 = "69b41cb55e48af15b0cf0d52c0a88629403810085c404afdc2945fcde11cea43";
        libraryHaskellDepends = [
          base blaze-markup Elm shakespeare-js text yesod-core
        ];
@@ -47403,7 +47564,7 @@ self: {
      mkDerivation {
        pname = "elocrypt";
        version = "0.4.1";
-       sha256 = "1hssxqhm962hr41mvjnrs4h74121nmvlbww0g9nyk10mx71rcbcg";
+       sha256 = "8f2d96c3e91584e96d7a80f34577b541047220d1d9ca5d03c950985421ee5ac3";
        isLibrary = true;
        isExecutable = true;
        libraryHaskellDepends = [ base MonadRandom random ];
@@ -47424,7 +47585,7 @@ self: {
      mkDerivation {
        pname = "emacs-keys";
        version = "0.0.2.0";
-       sha256 = "12zxvjmlp06rjlhb7iaz7qrzb7cr1rgqg5ql5vv3lkz7z84h82ph";
+       sha256 = "f00a0409fae74f3af62e1497875f0e999df5333e5fc5b32095d9804babdcfd8b";
        libraryHaskellDepends = [
          base split template-haskell th-lift xkbcommon
        ];
@@ -47443,7 +47604,7 @@ self: {
      mkDerivation {
        pname = "email";
        version = "0.1.1.2";
-       sha256 = "144a53an7laivcc6zxawsjz8yijknswnlbrd8id87d6x6lbq1cw3";
+       sha256 = "83b3801735ddb4835a442d2f6ab9b653468fbed45cf56f18db51d163d5288a90";
        libraryHaskellDepends = [
          array base bytestring encoding HaskellNet hsemail old-locale
          old-time parsec process time
@@ -47462,7 +47623,7 @@ self: {
      mkDerivation {
        pname = "email-header";
        version = "0.2.0";
-       sha256 = "1kl7d1scxq6ygjdixl4xkhaa4d60zr8i92fkcw5qczk44la4wiyv";
+       sha256 = "db474e1425647e860b67d3891451fec034a2149c9dd01e9b7cdee0ce746887ce";
        libraryHaskellDepends = [
          attoparsec base base64-bytestring bytestring case-insensitive
          containers text text-icu time
@@ -47484,7 +47645,7 @@ self: {
      mkDerivation {
        pname = "email-postmark";
        version = "0.2";
-       sha256 = "17zby98j1glsslrndmxl6zwrc3q7ir9771yvfxijawp4wdx6nayy";
+       sha256 = "de2b6b7ae3e472256377db8773528e070f96f937b4d76633d59abe2051f2eb9f";
        libraryHaskellDepends = [
          aeson attoparsec base bytestring containers HTTP network
        ];
@@ -47502,7 +47663,7 @@ self: {
      mkDerivation {
        pname = "email-validate";
        version = "2.1.3";
-       sha256 = "1jw15hyj6p1155i3h5n4f728x33ym21ibpirkdiid0ksf6cpk5jv";
+       sha256 = "5b967999717a8216639b39de1583a87e8c8ec471c416386229215c233d2c81cb";
        libraryHaskellDepends = [ attoparsec base bytestring ghc-prim ];
        testHaskellDepends = [
          base bytestring HUnit QuickCheck test-framework
@@ -47521,7 +47682,7 @@ self: {
      mkDerivation {
        pname = "email-validator";
        version = "0.0.3";
-       sha256 = "0ai0fj7rpq9h0i0rznrsqwvqbkkry5dgq4hgg5jc8ma3j9gym87n";
+       sha256 = "f6a0ea5f924355c464790f12fc5af179ce8537c73adb9f410430e19b8f74202a";
        isLibrary = false;
        isExecutable = true;
        executableHaskellDepends = [
@@ -47542,7 +47703,7 @@ self: {
      mkDerivation {
        pname = "embeddock";
        version = "0.3.0.1";
-       sha256 = "01xyqwnyza1cpd7ky4kgr1z5m8w2ms395lj7xjwxh42jg65b1rfr";
+       sha256 = "d9e5b08a795210d8b9ec47d29286ae82a35a7ec86f123f4fbb2ca8ef2dc7be07";
        isLibrary = true;
        isExecutable = true;
        libraryHaskellDepends = [ base ];
@@ -47560,7 +47721,7 @@ self: {
      mkDerivation {
        pname = "embeddock-example";
        version = "0.1";
-       sha256 = "07xc7kdnlbfwr08zhgjphbcmn8ycilp6pna3nk4y0w2hw87g7db0";
+       sha256 = "60b5f30ee25070e0c9b443d96b2e8dcc235bd982573ef811c8dc2d6adb3cac1f";
        libraryHaskellDepends = [ base embeddock time ];
        homepage = "https://github.com/nushio3/embeddock-example";
        description = "Example of using embeddock";
@@ -47575,7 +47736,7 @@ self: {
      mkDerivation {
        pname = "embroidery";
        version = "0.1";
-       sha256 = "1vqksv7a12xzi6zp4b2qfnsb5gaarg5bhxanhbi4qkn1jmwy82yx";
+       sha256 = "dd0be47995c14e4ce2825675b8cacb4abdb2b475582c72bf89bf8ba0ced613ef";
        isLibrary = true;
        isExecutable = true;
        libraryHaskellDepends = [
@@ -47593,7 +47754,7 @@ self: {
      mkDerivation {
        pname = "emgm";
        version = "0.4";
-       sha256 = "0cpcwrb6wqwq371wqjmhzfhdwk3vfhjjgz4vgjsjvw6cdhbpw5p1";
+       sha256 = "e1167e176cccf02db57c9bfc2725747b4cdea0fbb04accc31998636e56e6ec32";
        libraryHaskellDepends = [ base ];
        testHaskellDepends = [ base HUnit QuickCheck syb ];
        jailbreak = true;
@@ -47608,7 +47769,7 @@ self: {
      mkDerivation {
        pname = "empty";
        version = "9";
-       sha256 = "0ap7qby3n5qiwf791z4li05h0l6p6xi899wkmg6x8z6bb8z9q2d9";
+       sha256 = "a9099c3e5acb7cd4cdab93a7846237d750000b8894fc908ee311173bfcc2e72a";
        description = "Ceci n'est pas une package";
        license = stdenv.lib.licenses.bsd3;
        hydraPlatforms = stdenv.lib.platforms.none;
@@ -47621,7 +47782,7 @@ self: {
      mkDerivation {
        pname = "enclosed-exceptions";
        version = "1.0.1.1";
-       sha256 = "16ax1kqdsk4apg642qxkm2hf9vb5hzmkd14zmkxra8ssp8rn28z5";
+       sha256 = "e5236133ba5a2395fbac9f8436eb8765ede4a0a8b36341ccbb8a4cddf00c5d99";
        libraryHaskellDepends = [
          async base deepseq lifted-base monad-control transformers
          transformers-base
@@ -47642,7 +47803,7 @@ self: {
      mkDerivation {
        pname = "encoding";
        version = "0.8";
-       sha256 = "0y2fx99vxrqpvjflpqgnbikxsc3p50sn5b5g97zivjr9bbck52ji";
+       sha256 = "518a32d95a29cb1dff49afac6235287730dd675cf6e14b9ddc17e7be53ea4e78";
        libraryHaskellDepends = [
          array base binary bytestring containers extensible-exceptions
          ghc-prim HaXml mtl regex-compat
@@ -47657,7 +47818,7 @@ self: {
      mkDerivation {
        pname = "endo";
        version = "0.2.0.1";
-       sha256 = "0szbv44sgsnbkcdmmsvbiy539iiyd608p513slfw1pbb240sabii";
+       sha256 = "312ea501116bddc01dd523948b80693ec6348a8f6beb5a1b9bcbeaa709d9eb6b";
        libraryHaskellDepends = [ base between transformers ];
        homepage = "https://github.com/trskop/endo";
        description = "Endomorphism utilities";
@@ -47672,7 +47833,7 @@ self: {
      mkDerivation {
        pname = "engine-io";
        version = "1.2.10";
-       sha256 = "02wc4fdwrnaw934bxk39bfndzn2rjdcaa3rifcj84ap750fx16h0";
+       sha256 = "009ad01d28e72a822473310fa5589359d8dfac5b69ccbec8485cd9cc9b238c0b";
        libraryHaskellDepends = [
          aeson async attoparsec base base64-bytestring bytestring either
          free monad-loops mwc-random stm stm-delay text transformers
@@ -47692,7 +47853,7 @@ self: {
      mkDerivation {
        pname = "engine-io-growler";
        version = "0.1.0.1";
-       sha256 = "1yk7cpg89nsmd9kvmxdrxcgyr8wilara4kw35hyxl4l2b9c9pwjc";
+       sha256 = "4cf29b585a8212da3d2c834fa2b2a291a3ec1febb9f5ba676a55db84de6567fa";
        libraryHaskellDepends = [
          base bytestring engine-io growler http-types mtl pipes
          pipes-attoparsec pipes-wai socket-io text transformers
@@ -47710,7 +47871,7 @@ self: {
      mkDerivation {
        pname = "engine-io-snap";
        version = "1.0.3";
-       sha256 = "0i2099b4drvzknz6ifi4dvgfibkqxfrz6w3a15k09nw3vxc14hbg";
+       sha256 = "6f411258df83db0466096a70f3b3eb78aee8de6e24ba68be9d7fe746564a4044";
        libraryHaskellDepends = [
          attoparsec-enumerator base bytestring containers engine-io
          MonadCatchIO-transformers snap-core unordered-containers websockets
@@ -47728,7 +47889,7 @@ self: {
      mkDerivation {
        pname = "engine-io-wai";
        version = "1.0.3";
-       sha256 = "0p296y3xnpx0wj6yd152y7i765x0pwg8rg2bpcz92hkcmz57gdz7";
+       sha256 = "e7b777caaf6c42913ebb4bbc8c1ebfa01773e2f1a284e68de4a05fdb8737495c";
        libraryHaskellDepends = [
          attoparsec base bytestring either engine-io http-types mtl text
          transformers transformers-compat unordered-containers wai
@@ -47746,7 +47907,7 @@ self: {
      mkDerivation {
        pname = "engine-io-yesod";
        version = "1.0.2";
-       sha256 = "15hjq128zn23kq5nlmpv7sbrhzhv1936psgf8aa7yxvx4xwy6baw";
+       sha256 = "5c2de379277d777f9442eee96b460a1b7e98973efb566a0b9e43d88f44c01296";
        libraryHaskellDepends = [
          base bytestring conduit conduit-extra engine-io http-types text
          unordered-containers wai wai-websockets websockets yesod-core
@@ -47759,7 +47920,7 @@ self: {
      mkDerivation {
        pname = "engineering-units";
        version = "0.0.1";
-       sha256 = "1jpipav3znxbj7ld5m53wv6pmv1nrcxprqm0m1p3ny9cmpnw3r9x";
+       sha256 = "3de5c1edad2c793b6ea8a0e27c3bcb36ec7acde6a3d4d2e891abdb3fb6baf1ca";
        libraryHaskellDepends = [ base ];
        description = "A numeric type for managing and automating engineering units";
        license = stdenv.lib.licenses.bsd3;
@@ -47770,7 +47931,7 @@ self: {
      mkDerivation {
        pname = "entropy";
        version = "0.3.7";
-       sha256 = "1vzg9fi597dbrcbjsr71y47rvmhiih7lg5rjnb297fzdlbmj1w0z";
+       sha256 = "1ff020eba2edbb93c4b23297470f8c11d69d0ff1e1642d17cbab9d54a24befef";
        libraryHaskellDepends = [ base bytestring unix ];
        homepage = "https://github.com/TomMD/entropy";
        description = "A platform independent entropy source";
@@ -47782,7 +47943,7 @@ self: {
      mkDerivation {
        pname = "enumerable";
        version = "0.0.3";
-       sha256 = "1v94y0a3rlkg3qlbv70d1zj2vjhssf1f89xlgb5cnsy9az07517q";
+       sha256 = "f88472c057c96bcbca7ab427e482d31aca2de40f0d9cbd281e6fd23c14f024ed";
        libraryHaskellDepends = [ base control-monad-omega tagged ];
        description = "A typeclass for enumerating all values a type";
        license = stdenv.lib.licenses.bsd3;
@@ -47795,7 +47956,7 @@ self: {
      mkDerivation {
        pname = "enumeration";
        version = "0.1.0";
-       sha256 = "17d7vm2nkyhxw2f0wk6llrw9y5kqzgqlgswv98wrpnpsspwmx0bk";
+       sha256 = "73815ef9d5fada9b394a9beb47f1fb78169f78a6d44c0e9ce01dfa6945dda79d";
        libraryHaskellDepends = [
          arith-encode arithmoi base binary Cabal containers heap
        ];
@@ -47813,7 +47974,7 @@ self: {
      mkDerivation {
        pname = "enumerator";
        version = "0.4.20";
-       sha256 = "02a75dggj295zkhgjry5cb43s6y6ydpjb5w6vgl7kd9b6ma11qik";
+       sha256 = "33e21054352bb579e8db8697256ff3c61b3dc862c567f9e0fc2509f95e2b4709";
        libraryHaskellDepends = [
          base bytestring containers text transformers
        ];
@@ -47827,7 +47988,7 @@ self: {
      mkDerivation {
        pname = "enumerator-fd";
        version = "0.1.0.2";
-       sha256 = "0xbrkv65m206qlvnjlbfb52kvjhw91rdnihwv3y31p2qj5zlz29p";
+       sha256 = "37894f7f9158dc30fcd81c46db72481cca3d45596e516937c506885acc9e7975";
        libraryHaskellDepends = [ base enumerator mtl ];
        homepage = "https://john-millikin.com/software/enumerator/";
        description = "Enumerator instances for monads-fd classes";
@@ -47839,7 +48000,7 @@ self: {
      mkDerivation {
        pname = "enumerator-tf";
        version = "0.1.1";
-       sha256 = "0s47j6pf05nwl105i2vwvsn18gis1v96gid85kj49ngb8ax0pjsp";
+       sha256 = "57cb0bba42ebd944e42ca8c567d20e3a3e14acde7c8b5840a0dc16e0ae918768";
        libraryHaskellDepends = [ base enumerator monads-tf ];
        homepage = "https://john-millikin.com/software/enumerator/";
        description = "Enumerator instances for monads-tf classes";
@@ -47851,7 +48012,7 @@ self: {
      mkDerivation {
        pname = "enumfun";
        version = "0.5.1.0";
-       sha256 = "1fq4zmhc825bmyslfm7kbsa29qq773cgrz4npj2bcfl0jkbl3ndc";
+       sha256 = "acd941d794803ab684bc96fcfcd83807e324945ef35447b5afab08c460fd04bb";
        libraryHaskellDepends = [ base enummapset-th ];
        jailbreak = true;
        homepage = "https://github.com/liyang/enumfun";
@@ -47868,7 +48029,7 @@ self: {
      mkDerivation {
        pname = "enummapmap";
        version = "0.7.0";
-       sha256 = "17rlynm46i3y76ms8s5ajkz50cj5m1anw83dizj281887qg63iwr";
+       sha256 = "99c7611e3e080524e48f6d206e55a8453250fe94aa68a4ab397e4443aaf5349f";
        libraryHaskellDepends = [
          base contravariant data-default deepseq ghc-prim lens safecopy
          semigroups
@@ -47888,7 +48049,7 @@ self: {
      mkDerivation {
        pname = "enummapset";
        version = "0.5.2.1";
-       sha256 = "019q0b1qm6bcp1ld67aklvq76wfx1qwzjbdywliv9g8ybwivaxqg";
+       sha256 = "0f77b5235f1ebdb423e5be2df9390edd7173f0a6531dd368b86c998ac3023805";
        libraryHaskellDepends = [ base containers deepseq ];
        homepage = "https://github.com/michalt/enummapset";
        description = "IntMap and IntSet with Enum keys/elements";
@@ -47900,7 +48061,7 @@ self: {
      mkDerivation {
        pname = "enummapset-th";
        version = "0.6.0.2";
-       sha256 = "1g6z60qalyf8iv41xdl409kmcjm406zccljkgl658y1x9rdi08gr";
+       sha256 = "f921105b4e3d78540c7d5352c6be01a44a56670284b61ec88ec879aa3030dfbc";
        libraryHaskellDepends = [
          base containers deepseq template-haskell
        ];
@@ -47914,7 +48075,7 @@ self: {
      mkDerivation {
        pname = "enumset";
        version = "0.0.4";
-       sha256 = "1dzwxi7i757zdf68v470n8dwn1g8kg51w3c1mwqyxwq85650805w";
+       sha256 = "bc00048a2908f3ee31af810d1eca9be805cb1bb2e0908d8c6bff94134fecfcb7";
        libraryHaskellDepends = [ base data-accessor storable-record ];
        description = "Sets of enumeration values represented by machine words";
        license = stdenv.lib.licenses.bsd3;
@@ -47928,7 +48089,7 @@ self: {
      mkDerivation {
        pname = "env-parser";
        version = "0.0.2.1";
-       sha256 = "13d6yi5jbdi84nccn3ffiw96v5knbz4madjfg980izxfrnbsl1rr";
+       sha256 = "3907aa97cdaeff08507a4e3655c95f76966d128fce0dcb982528b6254bf4a68d";
        libraryHaskellDepends = [
          aeson attoparsec base base16-bytestring base64-bytestring
          bytestring containers http-types mtl network old-locale text time
@@ -47946,7 +48107,7 @@ self: {
      mkDerivation {
        pname = "envparse";
        version = "0.2.1";
-       sha256 = "1pkxlda74wpl3f4xd5h69bcbgrw6q045hkdfj98dqd6z2czr2wcg";
+       sha256 = "8f71913f13df34dc5092ae4d5808c086e7b7d84a0696d6891bf4727254a37dde";
        libraryHaskellDepends = [ base containers ];
        testHaskellDepends = [ base containers hspec ];
        homepage = "https://supki.github.io/envparse";
@@ -47961,7 +48122,7 @@ self: {
      mkDerivation {
        pname = "envy";
        version = "0.2.0.0";
-       sha256 = "0hi9nlrr2g32f4cp3ibmdvmqmqhbyps5d9f0v7612fbxhimqrkbq";
+       sha256 = "78cd8c6b847d3911ccd9c0a556f4f50be28aeb6e75c5711971623c9133b52942";
        libraryHaskellDepends = [
          base bytestring containers mtl text time transformers
        ];
@@ -47978,7 +48139,7 @@ self: {
      mkDerivation {
        pname = "epanet-haskell";
        version = "2.0.12.4";
-       sha256 = "1jpz58zlkhgf2fl4fzicpdkqqdbwy3sw56dga8yvjmgv5zcqqshx";
+       sha256 = "1d6a8cd92ffb55b93d52af99c2f5f07c358c67bb2c7e47a813eec1493f2affca";
        libraryHaskellDepends = [ base ];
        jailbreak = true;
        homepage = "http://epanet.de/developer/haskell.html";
@@ -47991,7 +48152,7 @@ self: {
      mkDerivation {
        pname = "epass";
        version = "0.2.1";
-       sha256 = "0sg5pipzc4s9xq83ari7rigjbvhyh76kqnp57i98bs3k54ba53ym";
+       sha256 = "d58fa2162973e885523ce55a3ccd811eee255fcc27663510ee4913f66fbce569";
        libraryHaskellDepends = [ base stm time ];
        jailbreak = true;
        homepage = "http://github.com/baldo/epass";
@@ -48004,7 +48165,7 @@ self: {
      mkDerivation {
        pname = "epic";
        version = "0.9.3.3";
-       sha256 = "0ap8jr11sk8v2sdi03pahjhaxx3mc4ba7qbh3m8nsg0g5wr4962m";
+       sha256 = "559844322f0f3c6d511d70e1a3166175f4aea084ea0e109b161b4d1d4296e82a";
        isLibrary = true;
        isExecutable = true;
        libraryHaskellDepends = [ array base Cabal directory mtl process ];
@@ -48021,7 +48182,7 @@ self: {
      mkDerivation {
        pname = "epoll";
        version = "0.2.2";
-       sha256 = "0iz1x6lb5b71h4sgiacsnv5f8zj445v88a3rsra7vbza5g35nwnp";
+       sha256 = "d7725bc62beaaf7d54d67928847621447ee4cab69aa9f83481e1acb2a8e9e147";
        libraryHaskellDepends = [ base unix ];
        homepage = "http://github.com/twittner/epoll/";
        description = "epoll bindings";
@@ -48034,7 +48195,7 @@ self: {
      mkDerivation {
        pname = "eprocess";
        version = "1.7.2";
-       sha256 = "190qgsqj41dbkphjrgljif7q0zjm9ddp8wawc9wx8qklb897jrvj";
+       sha256 = "726779125a7462d479625c71745b4b557e808f8b92be2ce19dab0522b17e18a4";
        libraryHaskellDepends = [ base exceptions mtl ];
        description = "Basic Erlang-like process support for Haskell";
        license = stdenv.lib.licenses.bsd3;
@@ -48047,7 +48208,7 @@ self: {
      mkDerivation {
        pname = "epub";
        version = "0.0.7";
-       sha256 = "0h9j9qqdllkng13w978fpd44zxni5v0mpywh7yxz259hlihwmw22";
+       sha256 = "42f0ca61a43015f1bb3f90fb5bc12ed1f64f48bb0e9dc447787652da304e3241";
        isLibrary = true;
        isExecutable = true;
        libraryHaskellDepends = [
@@ -48064,7 +48225,7 @@ self: {
      mkDerivation {
        pname = "epub-metadata";
        version = "4.3";
-       sha256 = "0gw5mfysvfqk9daa4807qq4xh190a1pzxmwwi2xbnpz7m4kyffyk";
+       sha256 = "d33be727a9e75fbbba889cd7fe6f502005d809c60720a2544b13bbadbdab853f";
        libraryHaskellDepends = [
          base bytestring containers directory filepath hxt mtl regex-compat
          zip-archive
@@ -48085,7 +48246,7 @@ self: {
      mkDerivation {
        pname = "epub-tools";
        version = "2.7";
-       sha256 = "17r7p68mdrc7mla65xwb5g8inh94hncqkg09igha9fyhnax4m3dk";
+       sha256 = "b38d4abab2d0bba4e08b09bc89998524411bd12b8bf76214ad87e55691b9279f";
        isLibrary = false;
        isExecutable = true;
        executableHaskellDepends = [
@@ -48106,7 +48267,7 @@ self: {
      mkDerivation {
        pname = "epubname";
        version = "2.3.2";
-       sha256 = "1l3vi5z46x4m5h3x97hgr9g76i4s5scmpmpjzf97c1kddw31hlh3";
+       sha256 = "035218066f6d067692fbf2d65b992e9a44735eca0f9ed4072c9574437e897bd0";
        isLibrary = false;
        isExecutable = true;
        executableHaskellDepends = [
@@ -48123,7 +48284,7 @@ self: {
      mkDerivation {
        pname = "eq";
        version = "4.0.4";
-       sha256 = "1rdxmkmlgyinpih5p708k18j7qq0rj1c8gv240naa9gbkqg4qbq4";
+       sha256 = "042f4c1e9eeb25a52c20623fc482cc00e3235198089c5b60bc36fa47ebacbde5";
        libraryHaskellDepends = [ base semigroupoids ];
        homepage = "http://github.com/ekmett/eq/";
        description = "Leibnizian equality";
@@ -48137,7 +48298,7 @@ self: {
      mkDerivation {
        pname = "equal-files";
        version = "0.0.5.2";
-       sha256 = "07n9xdsi00nz9xwd0bqrdn2d03q7dzlrr13wlym5lgc15r7iwf8w";
+       sha256 = "1c391e4f2e813d5aaaa77c849ce96f070fd0846d192fd0784fdf021075ebc91e";
        isLibrary = false;
        isExecutable = true;
        executableHaskellDepends = [
@@ -48154,7 +48315,7 @@ self: {
      mkDerivation {
        pname = "equational-reasoning";
        version = "0.2.0.5";
-       sha256 = "1i8c3wn0z7binnz9p62c2mrvzgb305h797pnf5pvj9zk0iqxg21k";
+       sha256 = "3388d77104f327b96f71f69e74600163bdbf73154c989bbeb5719d0f2c1f0cc5";
        libraryHaskellDepends = [ base singletons template-haskell void ];
        description = "Proof assistant for Haskell using DataKinds & PolyKinds";
        license = stdenv.lib.licenses.bsd3;
@@ -48169,7 +48330,7 @@ self: {
      mkDerivation {
        pname = "equivalence";
        version = "0.3.1";
-       sha256 = "0zi053l03r5qcnpsphnq8xqazd0cbgj9n44hn47s1hagdra3j1bs";
+       sha256 = "7a0539546e4fc1a00fb190109be45b0cb4af7047d8c2abaf65b8e401e828207e";
        libraryHaskellDepends = [
          base containers mtl STMonadTrans transformers transformers-compat
        ];
@@ -48190,7 +48351,7 @@ self: {
      mkDerivation {
        pname = "erd";
        version = "0.1.3.0";
-       sha256 = "00cf1q7472kkl12z48dwnhixvyk99451by577qmfj0vhlnl1dc09";
+       sha256 = "09b016a8a57003e92a3ea7f8150a4969fadd23b4bc21f245a0738a430e0e8e01";
        isLibrary = false;
        isExecutable = true;
        executableHaskellDepends = [
@@ -48207,7 +48368,7 @@ self: {
      mkDerivation {
        pname = "erf";
        version = "2.0.0.0";
-       sha256 = "0dxk2r32ajmmc05vaxcp0yw6vgv4lkbmh8jcshncn98xgsfbgw14";
+       sha256 = "24f0b79c7e1d25cb2cd44c2258d7a464bf6db8079775b50b60b54a254616b337";
        libraryHaskellDepends = [ base ];
        description = "The error function, erf, and related functions";
        license = stdenv.lib.licenses.bsd3;
@@ -48218,7 +48379,7 @@ self: {
      mkDerivation {
        pname = "erf-native";
        version = "1.0.0.1";
-       sha256 = "0i031ws189rjl5gn44qpkfylx8kz7rdf3nzw9h0dmy2h86xbkckc";
+       sha256 = "6cb2b9ba4150f8da004cfcdbe15a3e7fa24ebd9b1713625fa1322714340f0344";
        libraryHaskellDepends = [ base polynomial ];
        homepage = "http://code.haskell.org/~mokus/erf-native";
        description = "Native Haskell implementation of the interface from the erf package";
@@ -48232,7 +48393,7 @@ self: {
      mkDerivation {
        pname = "erlang";
        version = "0.1";
-       sha256 = "14jvl8mqdaxavzlkwdxr227m4igmcckhakmy45h7bgcxi5qbkla4";
+       sha256 = "44d1b970899dbd756021be4e052763f545528f10b9373ee9dfaaab862ba25b92";
        libraryHaskellDepends = [
          base binary bytestring directory filepath nano-md5 network random
        ];
@@ -48247,7 +48408,7 @@ self: {
      mkDerivation {
        pname = "eros";
        version = "0.6.0.0";
-       sha256 = "0nr0c2qq30ji50pyjrklrb6a73i6qkqws7ywbfpa4pcd176xwlrw";
+       sha256 = "3c53decd098d5da2ae5bdc1fcdf1c4268ea3ccca7466e92f28518281b160205b";
        libraryHaskellDepends = [ aeson base bytestring containers text ];
        jailbreak = true;
        description = "A text censorship library";
@@ -48261,7 +48422,7 @@ self: {
      mkDerivation {
        pname = "eros-client";
        version = "0.5.0.1";
-       sha256 = "15pi4khibvfpxni4v3kz6f92s8s34kmkx4q7kwq1rxk5gb6p8rcb";
+       sha256 = "8b6574cd7a65f61c309f07933eeb2443232d92337f8e4da2edd7ed15e124f196";
        isLibrary = false;
        isExecutable = true;
        executableHaskellDepends = [
@@ -48280,7 +48441,7 @@ self: {
      mkDerivation {
        pname = "eros-http";
        version = "0.6.0.1";
-       sha256 = "1c7bwszjvbb3qnbvpjm0vin2x2z6dylplhs10hbhszkq2ypjjxyk";
+       sha256 = "d37729af17787e0d170441437aa96fe68b2e6cdca0cabb97c563ad2dbfe6ebb0";
        isLibrary = false;
        isExecutable = true;
        executableHaskellDepends = [
@@ -48297,7 +48458,7 @@ self: {
      mkDerivation {
        pname = "errno";
        version = "0.1";
-       sha256 = "0jix16b2c24pfbc3rig01nl68zdwpi28zzbciscalmq8lkpp10fa";
+       sha256 = "ca8170efa40857aa988e6cfd8f44bcbc7d64a80de0c53cd87297082696093d4a";
        libraryHaskellDepends = [ base mtl ];
        description = "a FFI utility";
        license = stdenv.lib.licenses.bsd3;
@@ -48308,7 +48469,7 @@ self: {
      mkDerivation {
        pname = "error-continuations";
        version = "0.1.0.0";
-       sha256 = "0rv59fhlfr03qis957mjgl4gyk1i5axfyvr680z3ykbfd3k5gc1s";
+       sha256 = "3ab057e6686e4d3f3e40266fefba2a314cff087db29e9274c4036447a14b6567";
        libraryHaskellDepends = [ base either mtl transformers ];
        jailbreak = true;
        homepage = "https://github.com/echatav/error-continuations";
@@ -48321,7 +48482,7 @@ self: {
      mkDerivation {
        pname = "error-list";
        version = "0.1.0.3";
-       sha256 = "0k0rpscg4h55215mgkd72yd5la3f2im21vlsgyg7v4pkrxd1cj1j";
+       sha256 = "3248165acff3927d9e7f9aee206a146e285a9a17a7cd574b10a540f298be194c";
        libraryHaskellDepends = [ base mtl text text-render ];
        homepage = "http://github.com/thinkpad20/error-list";
        description = "A useful type for collecting error messages";
@@ -48333,7 +48494,7 @@ self: {
      mkDerivation {
        pname = "error-loc";
        version = "0.1.0.0";
-       sha256 = "0ch7c537fp52yg3qmc1v9rs4y70cc0zyb3g3i0bmmhgdhxd90bm5";
+       sha256 = "a52e905a87edc15a1788e38de53f600c1c4f744e3bb08ac7f3a25c7746610732";
        libraryHaskellDepends = [ base template-haskell ];
        jailbreak = true;
        homepage = "https://github.com/joelteon/error-loc";
@@ -48346,7 +48507,7 @@ self: {
      mkDerivation {
        pname = "error-location";
        version = "0.1.5.5";
-       sha256 = "1gfi3jvag662xbsiv75ndb8p9s3c7j6lny15a9gqk8wd4l71myid";
+       sha256 = "2dfa1a0e258da3895f5225784b8d3c6ce874d16ab69c1df5eac298a7b61cd1bd";
        libraryHaskellDepends = [ base template-haskell ];
        homepage = "https://github.com/gregwebs/ErrorLocation.hs";
        description = "error functions that show file location information";
@@ -48360,7 +48521,7 @@ self: {
      mkDerivation {
        pname = "error-message";
        version = "1.1";
-       sha256 = "0xnz5l3r9x81pmb6nddzrrws1yqzdqydqkr2g1ib4pwmdwazf7f9";
+       sha256 = "c91df7156f955fb26278224fdc3c6e1ffba079cebf356b56bd01f594072ddf76";
        libraryHaskellDepends = [
          ansi-wl-pprint base containers either-unwrap InfixApplicative mtl
        ];
@@ -48376,7 +48537,7 @@ self: {
      mkDerivation {
        pname = "errorcall-eq-instance";
        version = "0.3.0";
-       sha256 = "0hqw82m8bbrxy5vgdwb83bhzdx070ibqrm9rshyja7cb808ahijm";
+       sha256 = "5546a810408b1d253dd439d58c570407f4f6e11a68f1f676f13daf85aa401c43";
        libraryHaskellDepends = [ base base-orphans ];
        testHaskellDepends = [ base hspec QuickCheck ];
        description = "An orphan Eq instance for ErrorCall";
@@ -48388,7 +48549,7 @@ self: {
      mkDerivation {
        pname = "errors";
        version = "1.4.7";
-       sha256 = "09g53dylwsw1phxq5zhkbq8pnpwqzipvqclmcrdypzkpwkmfncl7";
+       sha256 = "8732ebeae477feeb5b669532bc6ffc985f7b115e13fe823bbc816b4e7d1be525";
        libraryHaskellDepends = [ base either safe transformers ];
        description = "Simplified error-handling";
        license = stdenv.lib.licenses.bsd3;
@@ -48399,7 +48560,7 @@ self: {
      mkDerivation {
        pname = "errors";
        version = "2.0.0";
-       sha256 = "00s7vsqfvv23j3mpicrhspibbyzi5diqrdgajqx9n2snq8vxn9s5";
+       sha256 = "4527db37c2560b9b3a96eab58c632bf1fbb5e2d530b378eb9043ecedb0de4703";
        libraryHaskellDepends = [ base safe transformers ];
        description = "Simplified error-handling";
        license = stdenv.lib.licenses.bsd3;
@@ -48413,7 +48574,7 @@ self: {
      mkDerivation {
        pname = "ersatz";
        version = "0.3";
-       sha256 = "1hq6cdw1rvwc0289saz36x2imwwnj203hqk2lsbkbhyghdvqmpbr";
+       sha256 = "79dd8a7783cfc33597a6626238809096f31a4537e32b9d90008cef1c786306c3";
        revision = "3";
        editedCabalFile = "aafa6482bcf20d998dfc122b780b0378ec05187235252f4715e98bac02fc5b6c";
        isLibrary = true;
@@ -48440,7 +48601,7 @@ self: {
      mkDerivation {
        pname = "ersatz-toysat";
        version = "0.2.1.0";
-       sha256 = "1dpp4jl5mzc2z07f5670baxn95xvqgl9ynk0r0m83arpyp380fdq";
+       sha256 = "b83980c6f537ab812ac8605a9fe8c3bb9764bb5ae098e20ef882fd5aa824f7b6";
        isLibrary = true;
        isExecutable = true;
        libraryHaskellDepends = [
@@ -48460,7 +48621,7 @@ self: {
      mkDerivation {
        pname = "ert";
        version = "0.0.2.1";
-       sha256 = "0ica7vir4ragcc3xrkzlmhncnn0ddx8ky61cj32z7ginybfjq2ig";
+       sha256 = "2f0a2cddf236bef3c5902c183f516f0d58cb2cacf4cfdc07634f6592e33e8a45";
        isLibrary = true;
        isExecutable = true;
        libraryHaskellDepends = [
@@ -48483,7 +48644,7 @@ self: {
      mkDerivation {
        pname = "esotericbot";
        version = "0.0.6";
-       sha256 = "0r77y94ff210nqjga0xm2hrraa01dgjfaxs3ijrg11z6hfz523s7";
+       sha256 = "470f51be83e687f0b28c4377e5e46b0128953314b503f524b62008e748f2e764";
        isLibrary = true;
        isExecutable = true;
        libraryHaskellDepends = [
@@ -48509,8 +48670,8 @@ self: {
      }:
      mkDerivation {
        pname = "esqueleto";
-       version = "2.4.0";
-       sha256 = "1lihililzzryy93lka06cyv60sjjk91jlymsj68rkzz4238vh4z0";
+       version = "2.4.1";
+       sha256 = "12cc83bd2774906c29df20be8b77d11e0fc6efedadf208714494dc406cd8f7fd";
        libraryHaskellDepends = [
          base blaze-html bytestring conduit monad-logger persistent
          resourcet tagged text transformers unordered-containers
@@ -48530,7 +48691,7 @@ self: {
      mkDerivation {
        pname = "ess";
        version = "0.1.0.0";
-       sha256 = "0pxrs9vr6gc61md9q4rxdc5fikvjandqw2rygs0xamrqlna51bcq";
+       sha256 = "98ad5094a53857d5817e3e0b8e9b5572cfe80a6b3d139c5a0d863d9377d2b95f";
        libraryHaskellDepends = [ base ];
        jailbreak = true;
        homepage = "https://github.com/michaelochurch/ess";
@@ -48544,7 +48705,7 @@ self: {
      mkDerivation {
        pname = "estimator";
        version = "1.1.0.1";
-       sha256 = "1sf378qhmsxxazkk7nn1d7nvrq1ladsfvkzshqjwsnyl5pgj7sgq";
+       sha256 = "f8e923df2dd45bcd2586facfed745334e0bced69c1da33e757bdeb0a313ac3e9";
        libraryHaskellDepends = [
          ad base distributive lens linear reflection
        ];
@@ -48561,7 +48722,7 @@ self: {
      mkDerivation {
        pname = "estimators";
        version = "0.1.4";
-       sha256 = "0n7j2ay68m73f1mkfsxrrcs1rq0fpavwf58r50y7wirpm5f6agcy";
+       sha256 = "9e3d655ca937477e3c281915c7b7ba0ee01c34cbb96b376b70e35464bc12f258";
        libraryHaskellDepends = [
          base binary containers deepseq list-tries MonadRandom mtl pretty
          prettyclass QuickCheck text
@@ -48577,7 +48738,7 @@ self: {
      mkDerivation {
        pname = "estreps";
        version = "0.3.1";
-       sha256 = "100pqygnwclmpzjhzpz3j34y8v75d8ldxg76f9jys90gb41kggpi";
+       sha256 = "f1be3703590f24ed6572e6bcde286ae56ce4c990e3df0fe5bf95326e9fc71780";
        isLibrary = false;
        isExecutable = true;
        executableHaskellDepends = [
@@ -48597,7 +48758,7 @@ self: {
      mkDerivation {
        pname = "etcd";
        version = "1.0.5";
-       sha256 = "0bqz678mnpw2jpywz2m76923cyq864xn537a9zsqhm6c80gc0vwi";
+       sha256 = "916fc01e40cc5488f54fea8c623b31087b364432a78acffd95825f5bd1311f2f";
        revision = "1";
        editedCabalFile = "5cdbbc8d2aedc68e82e7c4d0cface390c3c68fb7ee7fb162d8123e42351f98fa";
        libraryHaskellDepends = [
@@ -48615,7 +48776,7 @@ self: {
      mkDerivation {
        pname = "eternal";
        version = "0.1.1";
-       sha256 = "151b9qcdyh0vixn0y4s9h54g1h0kk1hwcgh5xcx9qp7bgy0h8wv9";
+       sha256 = "697304817feb5c9c3aeb053ec6619813c0f0488149130f6c8f1b40df184e2b94";
        libraryHaskellDepends = [
          base base-unicode-symbols transformers utf8-string
        ];
@@ -48632,7 +48793,7 @@ self: {
      mkDerivation {
        pname = "ether";
        version = "0.3.0.0";
-       sha256 = "1k8g01ypck0w6sp6f3w3asdakzjg6k8m1sz58c2r5iz3z1v9b04m";
+       sha256 = "95809576f8e3c7920543e5eb50d1344ffea99a56830f67ae361c4c767d000fcd";
        libraryHaskellDepends = [
          base mmorph monad-control mtl newtype-generics template-haskell
          transformers transformers-base transformers-lift
@@ -48656,7 +48817,7 @@ self: {
      mkDerivation {
        pname = "ethereum-client-haskell";
        version = "0.0.4";
-       sha256 = "0dkvvs7bk4paqjmr1zihi14kp4cb28s33b18kd3a17lz1vd4qbfc";
+       sha256 = "cc2d4cda0e9f9ea0469b28ac3134128b913b498830fe90abc4ea92b98ede7b36";
        isLibrary = false;
        isExecutable = true;
        executableHaskellDepends = [
@@ -48683,7 +48844,7 @@ self: {
      mkDerivation {
        pname = "ethereum-merkle-patricia-db";
        version = "0.0.1";
-       sha256 = "0pxncaam139nl99wm1i7fcnnsy683p6inasz10knfd2jsxcz8yr8";
+       sha256 = "287bf459d752346727085f2b1bcd1dc8786d2d732786ca53a2368d509562b65f";
        libraryHaskellDepends = [
          ansi-wl-pprint base base16-bytestring binary bytestring cryptohash
          data-default ethereum-rlp leveldb-haskell nibblestring resourcet
@@ -48706,7 +48867,7 @@ self: {
      mkDerivation {
        pname = "ethereum-rlp";
        version = "0.0.1";
-       sha256 = "1hx5nhdy27kx67mwi8zjgqfxir0z7bp47xsw3a6hz40hj716n9r5";
+       sha256 = "25276bc29110900f8d1a5cf743ee3a1fe4d81d7ef2a3c8eb317d1ee11bb4a5c3";
        libraryHaskellDepends = [
          ansi-wl-pprint base base16-bytestring bytestring
        ];
@@ -48725,7 +48886,7 @@ self: {
      mkDerivation {
        pname = "ety";
        version = "0.1";
-       sha256 = "165vwca1q001pa9f09vfhf724kq5jnsip907c9dr6fncj9yjdp2p";
+       sha256 = "57dc267d92cc3a935b6207a41bb595054f228e836e27e092ba01001c14e3bb98";
        isLibrary = true;
        isExecutable = true;
        libraryHaskellDepends = [
@@ -48745,7 +48906,7 @@ self: {
      mkDerivation {
        pname = "euler";
        version = "0.9.2";
-       sha256 = "14ghmy5qblfgacc6b07jja6pssglf393j5hjypz0l0azd9w56kh5";
+       sha256 = "054e53786a5f010afef5121639d270f4697d8d92f280651853cfd1858baff091";
        libraryHaskellDepends = [ base ];
        testHaskellDepends = [
          base directory hlint hspec process regex-posix xml
@@ -48765,7 +48926,7 @@ self: {
      mkDerivation {
        pname = "euphoria";
        version = "0.6.0.1";
-       sha256 = "1bml75lj30y83bln5a7b36gcb9d6gci4vhmr8ins9nz6bc1l29m9";
+       sha256 = "a92641035be6dba46d44b9c24d227ba6a5c59e19eba862e91ac883216939b4ae";
        libraryHaskellDepends = [
          base containers data-default deepseq elerea enummapset-th hashable
          HUnit transformers unordered-containers
@@ -48786,7 +48947,7 @@ self: {
      mkDerivation {
        pname = "eurofxref";
        version = "0.2.1";
-       sha256 = "0zjf3rky2ww2nq4ryyz0069cv3ps1h29nwrgr2sk127bsik868x9";
+       sha256 = "a9238366d4eb8830b5c82f739b040cfa8ecd9201e07b9f09b68273e1671e4e7e";
        libraryHaskellDepends = [
          base bytestring conduit containers failure hexpat http-conduit
          http-types monad-control mtl time
@@ -48802,7 +48963,7 @@ self: {
      mkDerivation {
        pname = "event";
        version = "0.1.1";
-       sha256 = "191d72dbaddxl2ql2860145iwfsrx2jrbcsylfq7028vmzzxqqm6";
+       sha256 = "a662dcffaf1b0970b0a35eb395a5e8593b1e0b09c02041b1a0bd35b59a382da4";
        libraryHaskellDepends = [
          base containers semigroups transformers
        ];
@@ -48815,7 +48976,7 @@ self: {
      mkDerivation {
        pname = "event-driven";
        version = "0.0.2";
-       sha256 = "1jkrc1k0ixjs95fvj36gr08igpx5vqff5zc6bi9f04ldxqz4wbap";
+       sha256 = "572d4e3eee8d12e0525c86fde21cdea5df1711c8cf0cb95d495af608666079ca";
        libraryHaskellDepends = [ base monads-tf yjtools ];
        description = "library for event driven programming";
        license = stdenv.lib.licenses.bsd3;
@@ -48827,7 +48988,7 @@ self: {
      mkDerivation {
        pname = "event-handlers";
        version = "0.0.0.3";
-       sha256 = "1515v1khdkr145z5inrm2ardhpzfsbncpl5wmfd9nmilw97da9ld";
+       sha256 = "8d26d54ee234569b9aabbcd0cbecd2ee5fd8b21235db587e2121cf0667d82594";
        libraryHaskellDepends = [ base containers ];
        homepage = "http://code.haskell.org/~mokus/event-handlers";
        description = "Event handlers";
@@ -48841,7 +49002,7 @@ self: {
      mkDerivation {
        pname = "event-list";
        version = "0.1.1.2";
-       sha256 = "1nvc473rv9m6vr9l9d5x9v6h89819s822gwzilx8d5fj5i50nqzb";
+       sha256 = "eb630b4a2cd295863a8d9f3f21904e012504cd4ebdb44453dea6a69dc7216cdb";
        libraryHaskellDepends = [
          base non-negative QuickCheck transformers utility-ht
        ];
@@ -48860,7 +49021,7 @@ self: {
      mkDerivation {
        pname = "event-monad";
        version = "0.0.3";
-       sha256 = "1phs799i4da1nfgx530bp93n9xhzgnavilwlk8nz5vi3kd61gzf4";
+       sha256 = "c4fd174c9b23eef22d9a94d3b8957d1ff66447ba0b8cd29fb3413512533a1ade";
        libraryHaskellDepends = [
          base containers event-handlers haskell98 monad-loops mtl pretty
          prettyclass priority-queue stateref
@@ -48878,7 +49039,7 @@ self: {
      mkDerivation {
        pname = "eventloop";
        version = "0.4.1.1";
-       sha256 = "0d870kzcb08pc0ngrdkfibi0yq4zs5vcgg8acqpa8gdjaiksm8jg";
+       sha256 = "4fa2aa6754b23da42e660abdc776d19f600fe28a6eb6fc2c601781c5fe040735";
        libraryHaskellDepends = [
          aeson base bytestring network suspend text timers websockets
        ];
@@ -48896,7 +49057,7 @@ self: {
      mkDerivation {
        pname = "eventstore";
        version = "0.8.0.0";
-       sha256 = "0p1z7xs3412s2hnv7pc18y1gx65p5hf09038n96vl22kvc9d84ww";
+       sha256 = "9c13d412db5308ba4db26880041c2cb798fe824781ddb32d145a0432743f3f5c";
        libraryHaskellDepends = [
          aeson async attoparsec base bytestring cereal containers network
          protobuf random sodium stm text time unordered-containers uuid
@@ -48911,7 +49072,7 @@ self: {
      mkDerivation {
        pname = "every-bit-counts";
        version = "0.1";
-       sha256 = "0r959iyd5nsw3sj7p0gwsccdgaald9lwisg0lvq9qynyz09kh4vj";
+       sha256 = "72133813f8de7a9cf0a6e0e9c8696a54a9d718d3fc817ba41e5cdbd27c4c2565";
        libraryHaskellDepends = [ base haskell98 ];
        homepage = "http://research.microsoft.com/en-us/people/dimitris/pearl.pdf";
        description = "A functional pearl on encoding and decoding using question-and-answer strategies";
@@ -48925,8 +49086,8 @@ self: {
      }:
      mkDerivation {
        pname = "ewe";
-       version = "0.1.0.44";
-       sha256 = "0v313l0akvw9b3zn7xffy4ixz2c70i40k6kh4vdlrw8dvyv7zxk3";
+       version = "0.1.0.46";
+       sha256 = "ce3c9bea5cad4c5e7e1d2243d3f67530c47b60dc9602106e0046924c9429ff1a";
        isLibrary = false;
        isExecutable = true;
        executableHaskellDepends = [
@@ -48934,7 +49095,7 @@ self: {
        ];
        executableToolDepends = [ alex happy ];
        homepage = "http://github.com/jfcmacro/ewe";
-       description = "An language using in Programming Languages teaching";
+       description = "A language for teaching simple programming languages";
        license = stdenv.lib.licenses.bsd3;
        hydraPlatforms = stdenv.lib.platforms.none;
      }) {};
@@ -48946,7 +49107,7 @@ self: {
      mkDerivation {
        pname = "ex-pool";
        version = "0.2";
-       sha256 = "0da5grl2fdca24zhlngq2n16smdb4f5vvxqzc29ipsc3j7wkbmva";
+       sha256 = "6ad735f99183e91b93601ff7bd8b23ab556d8215f8590a3f118a3527687e4535";
        libraryHaskellDepends = [
          base exceptions hashable stm time transformers vector
        ];
@@ -48961,7 +49122,7 @@ self: {
      mkDerivation {
        pname = "exact-combinatorics";
        version = "0.2.0.8";
-       sha256 = "0pj7sh6s1kawk39hb42q1sx20g2rmzanpmr3zri9yvmb16qj5a1j";
+       sha256 = "32a822b109ab6e9f62fe23d76bd5af593c20ba0e589005d3985ccda00dd4475e";
        libraryHaskellDepends = [ base ];
        homepage = "http://code.haskell.org/~wren/";
        description = "Efficient exact computation of combinatoric functions";
@@ -48973,7 +49134,7 @@ self: {
      mkDerivation {
        pname = "exact-pi";
        version = "0.2.1.1";
-       sha256 = "1f8lxdaal7m4vw8akzwlhn0j3vw5bh983f02j842g1vzs3n47x3g";
+       sha256 = "6ff443ecd07f8727089202b881125c85ef21818594ffa910dfa41eaa54eb14b9";
        libraryHaskellDepends = [ base ];
        homepage = "https://github.com/dmcclean/exact-pi";
        description = "Exact rational multiples of pi (and integer powers of pi)";
@@ -48985,7 +49146,7 @@ self: {
      mkDerivation {
        pname = "exception-mailer";
        version = "0.4.1";
-       sha256 = "068zhr90gldin0f6xafqp1pncf6rhhm3gagnvn6r3p0kx060ia23";
+       sha256 = "43a8080ce813dc918dddf6a9372a84d938666fb8d8a96e1cb0b1d10752861f19";
        libraryHaskellDepends = [ base hslogger mime-mail text ];
        homepage = "https://github.com/drpowell/exception-mailer";
        description = "Catch all runtime exceptions and send an email";
@@ -48999,7 +49160,7 @@ self: {
      mkDerivation {
        pname = "exception-monads-fd";
        version = "0.2";
-       sha256 = "1wrhi9h2k068f0q0aqvpmlyx3318znm137xnvx7icf5shlpsilvi";
+       sha256 = "71d3a82f85ba38164fdfb69f11aafd288cd13dad7763053070c88029608a30f3";
        libraryHaskellDepends = [
          base exception-transformers monads-fd transformers
        ];
@@ -49016,7 +49177,7 @@ self: {
      mkDerivation {
        pname = "exception-monads-tf";
        version = "0.4";
-       sha256 = "0k9ada0g4nxwxggarpfcfdzg2zvxqdg9bkb4hv5v3qqanjmvb9hg";
+       sha256 = "0fa6b5abb40ae3b1cb8664cd955ec37d7ff17e73ccddacdeebbc5bf2806a2a4d";
        libraryHaskellDepends = [
          base exception-transformers monads-tf transformers
        ];
@@ -49029,7 +49190,7 @@ self: {
      mkDerivation {
        pname = "exception-mtl";
        version = "0.4";
-       sha256 = "1ya2xxl25afj2rxl2vziifrc91nzyg47vs06s0b65qjd7yz533j3";
+       sha256 = "438e51be3f4de26216d006e87dc8f3df86c4b28bf16f417b16d2a92268ef42f9";
        libraryHaskellDepends = [
          base exception-transformers mtl transformers
        ];
@@ -49044,7 +49205,7 @@ self: {
      mkDerivation {
        pname = "exception-transformers";
        version = "0.4.0.1";
-       sha256 = "1ay46wawrrsvii3b4kqxi2cg3b6r7wfw0l7d66il195qa6hh4sfq";
+       sha256 = "d86902a151b8a440a331ed50c01d3fd9acf198881d4fb2468c5be7cc1537c4ab";
        libraryHaskellDepends = [
          base stm transformers transformers-compat
        ];
@@ -49061,7 +49222,7 @@ self: {
      mkDerivation {
        pname = "exceptional";
        version = "0.3.0.0";
-       sha256 = "01lzx4ihdvyivjnkvn78hcdsk83dvm6iy9v5q1f28kd1iv96x1ns";
+       sha256 = "da866ed28ea14d245cc065271f4ddd6da0a91b83e8d83daddcd1ef0623e99f06";
        libraryHaskellDepends = [ base exceptions ];
        homepage = "https://github.com/";
        description = "Essentially the Maybe type with error messages";
@@ -49075,7 +49236,7 @@ self: {
      mkDerivation {
        pname = "exceptions";
        version = "0.8.0.2";
-       sha256 = "1x1bk1jf42k1gigiqqmkkh38z2ffhx8rsqiszdq3f94m2h6kw2h7";
+       sha256 = "070a3e0d1495243770fb3a629d5187ce898f069cb3621c5f7c610ae264982bf4";
        libraryHaskellDepends = [
          base mtl stm transformers transformers-compat
        ];
@@ -49096,7 +49257,7 @@ self: {
      mkDerivation {
        pname = "executable-hash";
        version = "0.2.0.2";
-       sha256 = "103s0095bb71wz3axhzw2w2nm5wfr01r9ypkdvbp22zhmq3xr1bj";
+       sha256 = "7285dc07aef00b71d76ef3fa9403c88e976a0517fcc3aec6e7e1ac5512007a80";
        isLibrary = true;
        isExecutable = true;
        libraryHaskellDepends = [
@@ -49115,7 +49276,7 @@ self: {
      mkDerivation {
        pname = "executable-path";
        version = "0.0.3";
-       sha256 = "1jg58qf19qz93c60ryglcavwdcysz4fd4qn8kpw5im9w9kniawlc";
+       sha256 = "8c7215ed4c3cd558f89dc862d21cf9dab3c6b762f4f90c0c1be9e3141c46e5c9";
        libraryHaskellDepends = [ base directory filepath unix ];
        homepage = "http://code.haskell.org/~bkomuves/";
        description = "Finding out the full path of the executable";
@@ -49128,7 +49289,7 @@ self: {
      mkDerivation {
        pname = "exhaustive";
        version = "1.1.1";
-       sha256 = "0bgzg2qhx91hd9711bxv6cr2qc7m23g29al4gb7yx20cs78bz1mg";
+       sha256 = "af86bfd0d10c88eecf7a84aa24de10f5302c3233bbaf104e6a30a40eb178ff2d";
        libraryHaskellDepends = [
          base generics-sop template-haskell transformers
        ];
@@ -49144,7 +49305,7 @@ self: {
      mkDerivation {
        pname = "exherbo-cabal";
        version = "0.1.0.3";
-       sha256 = "1i1p9pwzdf44cp8d1crq40g1hv84gpimywq5kdpz2nfgcnr17ans";
+       sha256 = "daaa13b265cf59f16f9b05735fe37d046d181e2038b3d0d06584b8f6f94d37c4";
        isLibrary = false;
        isExecutable = true;
        executableHaskellDepends = [
@@ -49160,7 +49321,7 @@ self: {
      mkDerivation {
        pname = "exif";
        version = "3000.0.0";
-       sha256 = "0w0l4xk3qwfiw10880729mwfdkx4xpfn9ffdw7fi5swyhinjh6wi";
+       sha256 = "911b286d849eeb12dde1cdb964ddeda4cfe6784de2008440e0d1713c66271470";
        libraryHaskellDepends = [ base ];
        librarySystemDepends = [ exif ];
        description = "A Haskell binding to a subset of libexif";
@@ -49173,7 +49334,7 @@ self: {
      mkDerivation {
        pname = "exists";
        version = "0.2";
-       sha256 = "1f7v2f7jmqx0nkl2wla88mnb21nava74b73rvsmfbj4kxmwchsgy";
+       sha256 = "fe69c878ed93c8e5aade799c458edaca06b16c4548512ee8b4a0e32a8f13fbb8";
        libraryHaskellDepends = [ base contravariant ];
        jailbreak = true;
        homepage = "http://github.com/glehel/exists";
@@ -49190,7 +49351,7 @@ self: {
      mkDerivation {
        pname = "exp-pairs";
        version = "0.1.3.0";
-       sha256 = "033sdkfg94m33qrkw0l3lbs6dm8ssxfdj3jg3p39w63q7va2c0hr";
+       sha256 = "190226d43e78189ec61d4f0ed95cd71ad566f4a283023e331ea392f4dc6c7a0c";
        libraryHaskellDepends = [
          base deepseq generic-deriving ghc-prim memoize wl-pprint
        ];
@@ -49209,7 +49370,7 @@ self: {
      mkDerivation {
        pname = "expand";
        version = "0.0.1";
-       sha256 = "0i8agr9np8pg40z58z8jz1fvq3vqjk2sx247dn33mvqyd03hnbss";
+       sha256 = "5a2f0b07681eef3a866d8788aec594780fbc5df8127d543e20efa26b537e0a45";
        libraryHaskellDepends = [
          AspectAG base HList murder uu-parsinglib
        ];
@@ -49226,7 +49387,7 @@ self: {
      mkDerivation {
        pname = "expat-enumerator";
        version = "0.1.0.3";
-       sha256 = "0alllaa9qj94jp99pyvbh4ckdvb43aba2l2jmigazqvbc9db03mx";
+       sha256 = "bd0eb05a626be3af5eac5250a1961a64ed3619816bfb9bd29524499c94a2942a";
        libraryHaskellDepends = [
          base bytestring enumerator hexpat text transformers xml-types
        ];
@@ -49244,7 +49405,7 @@ self: {
      mkDerivation {
        pname = "expiring-cache-map";
        version = "0.0.5.4";
-       sha256 = "0wbx9qp9ki9gwrc9qafpflkmyj1yiryak1di163mz0i3dv2w73h8";
+       sha256 = "088ec3c56e23825f8709b185a97c8e3e485f2775d7299c58e62fc5992e4e7d71";
        libraryHaskellDepends = [
          base containers hashable unordered-containers
        ];
@@ -49261,7 +49422,7 @@ self: {
      mkDerivation {
        pname = "expiring-mvar";
        version = "0.1";
-       sha256 = "0mkc7d346vdsjg83a253986w4pps53r262w1if91q16kx6qci7yy";
+       sha256 = "de9fc8b0e9d3041c928b810b23f228fa5ec20d4aa30835d093ba6d43463b6c56";
        libraryHaskellDepends = [ base ];
        description = "Create values which expire after a period of time";
        license = stdenv.lib.licenses.bsd3;
@@ -49272,7 +49433,7 @@ self: {
      mkDerivation {
        pname = "explain";
        version = "0.1.0.1";
-       sha256 = "14n8ic5mg2819s9bk4czwfxrkyz96c2lvnksv1hq5vwr579rvjx2";
+       sha256 = "a2cb9dd32999ef8261d87ada4d0533e9fb99bbe39f91b9924e0189570b8bc892";
        isLibrary = false;
        isExecutable = true;
        executableHaskellDepends = [
@@ -49290,7 +49451,7 @@ self: {
      mkDerivation {
        pname = "explicit-determinant";
        version = "0.1.0.0";
-       sha256 = "0g20kblzvhx53mi82frpx29x0nsfjrzsanqq8f6yw22lh47pbm4y";
+       sha256 = "9ed4750f815408ee8d43185ba57f964e5bd093e8373b81621da5c3fde99a403c";
        libraryHaskellDepends = [ base ];
        jailbreak = true;
        homepage = "https://github.com/jwaldmann/haskell-explicit-determinant";
@@ -49303,7 +49464,7 @@ self: {
      mkDerivation {
        pname = "explicit-exception";
        version = "0.1.7.3";
-       sha256 = "0f1p1llz6z4ag1wnf57mgm861cbw7va0g0m8klp6f6pnirdhlwz1";
+       sha256 = "e1730a5b8ef61a672e9da88207d43e7cb160507df5146779788a7cf3290d3738";
        isLibrary = true;
        isExecutable = true;
        libraryHaskellDepends = [ base transformers ];
@@ -49317,7 +49478,7 @@ self: {
      mkDerivation {
        pname = "explicit-iomodes";
        version = "0.6.0.5";
-       sha256 = "0irz1zy6iaipym73x343zvr6cqym6ci2vbjbyr564d29ymd6ldzd";
+       sha256 = "ed376a5af54934624af64bae2d2233d56366f2fe838c3e4ef537aa68fc0f3f47";
        libraryHaskellDepends = [ base base-unicode-symbols tagged ];
        jailbreak = true;
        homepage = "https://github.com/basvandijk/explicit-iomodes/";
@@ -49330,7 +49491,7 @@ self: {
      mkDerivation {
        pname = "explicit-iomodes-bytestring";
        version = "0.2.0.2";
-       sha256 = "0h3dlgkd2gx8zr3sh949nhqgrdg943dgpp4v1n599jjjpqpw16hj";
+       sha256 = "129ac02fbe52ca948a0d9bdcfbda20e9b5fc30b48924a847fea83fd1e6a36d40";
        libraryHaskellDepends = [ base bytestring explicit-iomodes ];
        jailbreak = true;
        homepage = "https://github.com/basvandijk/explicit-iomodes-bytestring/";
@@ -49343,7 +49504,7 @@ self: {
      mkDerivation {
        pname = "explicit-iomodes-text";
        version = "0.1.0.8";
-       sha256 = "12ny5wa1j1wp8fbg5k8zkv4a3axmssxcvfvhg3frsm4dych6hmyg";
+       sha256 = "cf576820f38d549ddd7870bbcdbad6b5aba1c89e1fcdf29643970719142fde8a";
        libraryHaskellDepends = [ base explicit-iomodes text ];
        jailbreak = true;
        homepage = "https://github.com/basvandijk/explicit-iomodes-text/";
@@ -49356,7 +49517,7 @@ self: {
      mkDerivation {
        pname = "explicit-sharing";
        version = "0.9";
-       sha256 = "0jshv56i60mzlfddvfkcx0j7rzqdlhy6h09bmqci15wzisvpvjpq";
+       sha256 = "f8ca7db78e9f971019ae2b01683ca40dff7c24e86cbadd9aa3bf02134dd9504b";
        libraryHaskellDepends = [
          base containers derive mtl template-haskell
        ];
@@ -49372,7 +49533,7 @@ self: {
      mkDerivation {
        pname = "explore";
        version = "0.0.7.2";
-       sha256 = "18x2gw9w2jzisyl2hsp2rlml6slnlbjpqbadqcbcm8pamnl7w1fc";
+       sha256 = "cc057ea8adeaa2ca16c34d2d7ce5a2966a432bcde26a28a8d7f14bc1137fa2a3";
        isLibrary = false;
        isExecutable = true;
        executableHaskellDepends = [ array base directory pngload ];
@@ -49390,7 +49551,7 @@ self: {
      mkDerivation {
        pname = "exposed-containers";
        version = "0.5.5.1";
-       sha256 = "09ck4hadxgdlqpgxr45jxr261mzkzihmwd5b02xi05z8034bhqk7";
+       sha256 = "6762b8c800e81710bb00ab345e61fcf3d76044eeb290dcdfc5b4bdde14249325";
        revision = "1";
        editedCabalFile = "25516f8a7288ce438b872a0d3054434c3ba48ce0ce8a57209ea6d78ce6e2665c";
        libraryHaskellDepends = [ array base deepseq ghc-prim ];
@@ -49409,7 +49570,7 @@ self: {
      mkDerivation {
        pname = "expression-parser";
        version = "0.1";
-       sha256 = "1ldp1f2c823byx4ag8jpmq9bhw26lq98fz7ljqslffs37pc098qs";
+       sha256 = "1aa304d83d433b473596f47c8712a64670b812ae57a2a748f76b08c4840bb7d1";
        libraryHaskellDepends = [ base ];
        description = "Generalization of parsec's expression parser";
        license = stdenv.lib.licenses.bsd3;
@@ -49422,7 +49583,7 @@ self: {
      mkDerivation {
        pname = "extcore";
        version = "1.0.2";
-       sha256 = "1dpn4dbbn5d3zqrhxkg8nvb97vp9pf61gwa46yf218nvwgqvx437";
+       sha256 = "6790bef1e3dba2209c3744f1178cbbe9ee93d6b6e8cd0e33fea315bb5623f6b6";
        libraryHaskellDepends = [
          array base bytestring containers directory filepath mtl parsec
          pretty syb
@@ -49441,7 +49602,7 @@ self: {
      mkDerivation {
        pname = "extemp";
        version = "0.0.1";
-       sha256 = "1vbazvs1ij4qfhzf38f7z75lx4mdxnkvcb79ngqc3h67844s90xy";
+       sha256 = "be83a40941c7c0c1f0b3e92cb6a7edad924ecbf9c7a1e13e7498c818f4fe6aed";
        isLibrary = false;
        isExecutable = true;
        executableHaskellDepends = [
@@ -49461,7 +49622,7 @@ self: {
      mkDerivation {
        pname = "extended-categories";
        version = "0.2.0";
-       sha256 = "1dg9zvqszlg5v3mygazzgm84qlkcmpryv3vv4x3zwrzi1g0idq72";
+       sha256 = "e2e016c10bf167fe47277b8fedf3ad6c524c507dffabe7ebd8e5d1aff1fee9b5";
        libraryHaskellDepends = [ base constraints ghc-prim tagged ];
        jailbreak = true;
        homepage = "github.com/ian-mi/extended-categories";
@@ -49478,7 +49639,7 @@ self: {
      mkDerivation {
        pname = "extended-reals";
        version = "0.2.1.0";
-       sha256 = "1a3vp51l07kj85p578y5bryalqv1a8b5766w0hrr85yp67y7wfdp";
+       sha256 = "b7397efc31d717943304dc985316526163aa7c5ec5a3536e41721e4043b97ba8";
        libraryHaskellDepends = [ base deepseq hashable ];
        testHaskellDepends = [
          base HUnit QuickCheck test-framework test-framework-hunit
@@ -49497,7 +49658,7 @@ self: {
      mkDerivation {
        pname = "extensible";
        version = "0.3.5";
-       sha256 = "0jff7vrmhj5sdd3migfi5p2bx35m6jbqlfai7rqpg0iqbxbp6pmy";
+       sha256 = "be5e73575f388277713e51398a9734b58cbec42dd1bd58476bba4858f33ece49";
        libraryHaskellDepends = [
          base constraints monad-skeleton profunctors tagged template-haskell
          transformers
@@ -49514,7 +49675,7 @@ self: {
      mkDerivation {
        pname = "extensible-data";
        version = "0.1.0.4";
-       sha256 = "143cl3w129mkvs410lx63v3x1dq2az8sk0hlcymaavnqik5maa6g";
+       sha256 = "cf2855cb8cd86ea5aa671482a9d15702b7d0c71ea6531088deb32611f8a06c90";
        libraryHaskellDepends = [
          base data-lens hashable template-haskell unordered-containers
        ];
@@ -49532,7 +49693,7 @@ self: {
      mkDerivation {
        pname = "extensible-effects";
        version = "1.11.0.0";
-       sha256 = "14f8x6gyq28n3lpap4f5bn290llj57my1k28km9r1nh14kxl1lp9";
+       sha256 = "e9d240fb2401da90539d48cce0eb29925290845dc591ab2e1d1609ec9fe9c891";
        libraryHaskellDepends = [
          base transformers transformers-base type-aligned void
        ];
@@ -49550,7 +49711,7 @@ self: {
      mkDerivation {
        pname = "extensible-exceptions";
        version = "0.1.1.4";
-       sha256 = "1273nqws9ij1rp1bsq5jc7k2jxpqa0svawdbim05lf302y0firbc";
+       sha256 = "6ce5e8801760385a408dab71b53550f87629e661b260bdc2cd41c6a439b6e388";
        libraryHaskellDepends = [ base ];
        description = "Extensible exceptions";
        license = stdenv.lib.licenses.bsd3;
@@ -49561,7 +49722,7 @@ self: {
      mkDerivation {
        pname = "external-sort";
        version = "0.2";
-       sha256 = "1i7q3wh2c4fyv6wn4smws8r382hnnppj39xys43h9pkqfis786r9";
+       sha256 = "291b74747478de0407d1bea721efb5160a3432d2bc6a62b9d9de1126201ff8c4";
        libraryHaskellDepends = [
          base binary bytestring EdisonAPI EdisonCore
        ];
@@ -49577,7 +49738,7 @@ self: {
      mkDerivation {
        pname = "extra";
        version = "1.4.1";
-       sha256 = "00fhy9l2cgfwj8873jf1iyz2fmhj1b3m0qlf38i4pd1yad8sfb70";
+       sha256 = "e02ca751533eb44b221a8e6250c70a125627be8fc1c9711092dc3d2668f2d001";
        libraryHaskellDepends = [
          base directory filepath process time unix
        ];
@@ -49596,7 +49757,7 @@ self: {
      mkDerivation {
        pname = "extractelf";
        version = "0.1.0.0";
-       sha256 = "13wbzqw0iz7xkqdrwan9xxl8vwqvhvwzlypps964v1s1bgabmpqj";
+       sha256 = "12dfbad45b41874d4cd2f77afaf9861bf38d68efc92a9e1b9efdfc0838fe8b8f";
        isLibrary = false;
        isExecutable = true;
        executableHaskellDepends = [
@@ -49620,7 +49781,7 @@ self: {
      mkDerivation {
        pname = "ez-couch";
        version = "0.7.0";
-       sha256 = "023wrrk7slrg8p547saspfvp771zqwdh7mnvwg1sag4a2j20b660";
+       sha256 = "c0980584148a3ca5c3e3dbd6031bc73f9c73b7bb5ae943ca452f537d66ce7c08";
        libraryHaskellDepends = [
          aeson attoparsec attoparsec-conduit base blaze-builder bytestring
          classy-prelude classy-prelude-conduit containers ghc-prim hashable
@@ -49640,7 +49801,7 @@ self: {
      mkDerivation {
        pname = "faceted";
        version = "0.0.2.0";
-       sha256 = "0apgad2rqpgxypm10n98agmfrlxydcawvsvyafdwj8jhynfycx03";
+       sha256 = "0374e69df55022c99b537eebcd156bbed3ecea53285910eaf5fd5d9c4553ef2a";
        libraryHaskellDepends = [ base free ];
        jailbreak = true;
        homepage = "http://github.com/haskell-faceted/haskell-faceted";
@@ -49656,7 +49817,7 @@ self: {
      mkDerivation {
        pname = "factory";
        version = "0.2.1.1";
-       sha256 = "07shidg02drvxpny0qgmshgliz0agw1app5xjs3d0z9zv3v5y1am";
+       sha256 = "55055ff6d83f7dd08696bddcab027f0afc481fd4f561e0eded3b37015e8b501f";
        isLibrary = true;
        isExecutable = true;
        libraryHaskellDepends = [
@@ -49676,7 +49837,7 @@ self: {
      mkDerivation {
        pname = "factual-api";
        version = "0.6.1";
-       sha256 = "1njijf5l277qndp5xmyqji0fcd84zxnn9vhz5v8nlqp3pfcilidp";
+       sha256 = "b7451a99bbe3626ad12e1fee646dff0435e64094d8d75e6eb3f81c418b9351da";
        libraryHaskellDepends = [
          aeson attoparsec base bytestring containers curl dataenc hoauth
          HTTP MissingH text unordered-containers utf8-string vector
@@ -49692,7 +49853,7 @@ self: {
      mkDerivation {
        pname = "fad";
        version = "1.1.0.1";
-       sha256 = "00n5m3fa14y882rnzw7pwc154bgp46rhvvj2cghldvybxmj61zgm";
+       sha256 = "f5fd6064edcbef46e16342ee0db321f72d5202e3f7f06fb340c893a0dca8c502";
        libraryHaskellDepends = [ base ];
        homepage = "http://github.com/bjornbm/fad";
        description = "Forward Automatic Differentiation";
@@ -49704,7 +49865,7 @@ self: {
      mkDerivation {
        pname = "failable-list";
        version = "0.2";
-       sha256 = "0bq0q9n4wnacjqs517i12kl56m16n5ff4gk8kamh87gqkd58w06x";
+       sha256 = "dd008e4a9bf81d04ab9a683ee25cb1265453e814219e5034964c594e6cc2002f";
        libraryHaskellDepends = [ base ];
        description = "A list-like type for lazy streams, which might terminate with an error";
        license = stdenv.lib.licenses.bsd3;
@@ -49715,7 +49876,7 @@ self: {
      mkDerivation {
        pname = "failure";
        version = "0.2.0.3";
-       sha256 = "0jimc2x46zq7wnmzfbnqi67jl8yhbvr0fa65ljlc9p3fns9mca3p";
+       sha256 = "77285693b66edcc4a8a4c52807f25ed0232a8f89d82ef7abe5077f43ba60354a";
        libraryHaskellDepends = [ base transformers ];
        homepage = "http://www.haskell.org/haskellwiki/Failure";
        description = "A simple type class for success/failure computations. (deprecated)";
@@ -49727,7 +49888,7 @@ self: {
      mkDerivation {
        pname = "fair-predicates";
        version = "0.1.1";
-       sha256 = "1z0c83gfmvwhzsj2iz422mxcyxc8jnic25i1vz6yp4xzv41ibmj6";
+       sha256 = "46d61503d9bf93ebcddf2116c1a2958875cf7a1582fc28a4fe90efeade400cfc";
        libraryHaskellDepends = [ base ];
        homepage = "http://sebfisch.github.com/fair-predicates";
        description = "Fair Predicates";
@@ -49739,7 +49900,7 @@ self: {
      mkDerivation {
        pname = "faker";
        version = "0.0.0.2";
-       sha256 = "1wl0jx3adibf7z8k3jadnr90jvkmf3zhkq34qpsifcl18zip8skq";
+       sha256 = "786a74e347813217f5c564e009ff70756e0952b64dc931d13f6ec5a6469780f2";
        libraryHaskellDepends = [ base gimlh random split ];
        homepage = "https://github.com/gazay/faker";
        description = "Pure Haskell library for generating fake data";
@@ -49753,7 +49914,7 @@ self: {
      mkDerivation {
        pname = "falling-turnip";
        version = "0.1.0.0";
-       sha256 = "035rjjjvwbjw4z6nlmiyxia5y91yiiw7902f9q6n5jimi5xk2hgk";
+       sha256 = "f341317b8935ca620d4e4e8074788c3e245f54ec3e566acd275c2ebea594b90c";
        isLibrary = false;
        isExecutable = true;
        executableHaskellDepends = [
@@ -49773,7 +49934,7 @@ self: {
      mkDerivation {
        pname = "fallingblocks";
        version = "0.1.4";
-       sha256 = "18h5d33hd4cs6dc508mzl7c46pxwrk2q0daabvg8m4fiwk5wzlr0";
+       sha256 = "20d3cfcbe4d1918ade5e4a3580c5ccbc5f43d8a1bf225058339a9106c76805a2";
        isLibrary = false;
        isExecutable = true;
        executableHaskellDepends = [
@@ -49793,7 +49954,7 @@ self: {
      mkDerivation {
        pname = "family-tree";
        version = "0.5.1";
-       sha256 = "0b2063f8yz7hwv7h0yisrgh6glr5h4s1cx0q75gfg2wgp2mr72s1";
+       sha256 = "418b93abb88f8be75e39187416348125d367e0cb3a7a00cfe6f07c8fdc30402c";
        libraryHaskellDepends = [
          base binary containers hashable intervals lens tables text time
          unordered-containers
@@ -49809,7 +49970,7 @@ self: {
      mkDerivation {
        pname = "farmhash";
        version = "0.1.0.3";
-       sha256 = "0zqyp55grrkl4x4bhn13ng635zpsnd7g6vj2dqmvn3dg4zhyigf6";
+       sha256 = "c6bde8e127af0dbb2b6e426ef34eb3fafe32ccb32358b8482774e6fc4ab91e7f";
        libraryHaskellDepends = [ base bytestring ];
        testHaskellDepends = [ base bytestring hspec QuickCheck ];
        homepage = "https://github.com/abhinav/farmhash";
@@ -49824,7 +49985,7 @@ self: {
      mkDerivation {
        pname = "fast-builder";
        version = "0.0.0.2";
-       sha256 = "07fnn282ldfmgkfnsdnjr11hx89jhw7waz573a7nx2a329r1p4pf";
+       sha256 = "ee921b721243896e8f1aa77cc50f8732a10e43c8d2366ddd7cd5352a90b0d61d";
        libraryHaskellDepends = [ base bytestring ghc-prim ];
        testHaskellDepends = [ base bytestring process QuickCheck stm ];
        homepage = "http://github.com/takano-akio/fast-builder";
@@ -49839,7 +50000,7 @@ self: {
      mkDerivation {
        pname = "fast-digits";
        version = "0.1.0.0";
-       sha256 = "1dhvlsjbp4qrgcr9xlzbaps59160j2zl98xl5nrz6rffypz0gi72";
+       sha256 = "e2c407fef5ce65f3b32db4a344bf90c08454f455ebd39e327b1993bba4a61bb6";
        libraryHaskellDepends = [ base integer-gmp ];
        testHaskellDepends = [
          base digits QuickCheck smallcheck tasty tasty-quickcheck
@@ -49857,7 +50018,7 @@ self: {
      mkDerivation {
        pname = "fast-logger";
        version = "2.4.0";
-       sha256 = "1hh5rll2q4dpshplyk0hciknvypx3v2hd102hf0f2z5h70d4xzsc";
+       sha256 = "4cff4e1a38b07ce18083028406c51efdfa6d6764104c4f2fd4b7112c28cd05c2";
        revision = "3";
        editedCabalFile = "af5edf5e05ecd782e1d87b9d5730c5a9eb1016ac01fb1a377dda1cd8e88a274b";
        libraryHaskellDepends = [
@@ -49874,7 +50035,7 @@ self: {
      mkDerivation {
        pname = "fast-math";
        version = "1.0.2";
-       sha256 = "15dyw88z9abiv6n40fz4g3jpj9v6qbxvqaf0ds32wh46igf1s425";
+       sha256 = "45101ddc8b86402e866ec029bcfbc2662779e578e43b40acd971a9f411e2be95";
        libraryHaskellDepends = [ base ];
        description = "Non IEEE-754 compliant compile-time floating-point optimisations";
        license = stdenv.lib.licenses.bsd3;
@@ -49887,7 +50048,7 @@ self: {
      mkDerivation {
        pname = "fast-tags";
        version = "1.1.0";
-       sha256 = "1m6v9jdla0r36l45gs3swycfgisl48hjq7x9rvfc08h4kd5mcmay";
+       sha256 = "5e55564b9b0422c0dccea91f2c212254c7e798e77ae85708352303459b4cdbd4";
        isLibrary = true;
        isExecutable = true;
        libraryHaskellDepends = [
@@ -49911,7 +50072,7 @@ self: {
      mkDerivation {
        pname = "fast-tagsoup";
        version = "1.0.7";
-       sha256 = "089karddj08z0lfr83r2x070j67i2s0aq2s1qi5i66vw335y91d8";
+       sha256 = "a885e4cb187c1b134bc4410bac8016f118090ee8220f941d051f01d95a563321";
        libraryHaskellDepends = [ base bytestring tagsoup text text-icu ];
        homepage = "https://github.com/vshabanov/fast-tagsoup";
        description = "Fast parser for tagsoup package";
@@ -49923,7 +50084,7 @@ self: {
      mkDerivation {
        pname = "fast-tagsoup-utf8-only";
        version = "1.0.5";
-       sha256 = "10svhgjvp1802jawr1s5chkincl2xhh6k0grm60f216jpasbvff4";
+       sha256 = "c4b9bdb4bad204e180a9f9816920ec82321b27644587cc95140085bbe5835b83";
        libraryHaskellDepends = [ base bytestring tagsoup text ];
        homepage = "https://github.com/exbb2/fast-tagsoup";
        description = "Fast parser for tagsoup package";
@@ -49937,7 +50098,7 @@ self: {
      mkDerivation {
        pname = "fasta";
        version = "0.7.2.1";
-       sha256 = "1jwx8h3z3zlrnandqgmgrkam4y0awm3k1mfzljf7pn9acq6nxhs4";
+       sha256 = "44c36e0d662ad97b9ca4dfd53047e50a7852d5ccaf3edcacb299fef107449dcb";
        libraryHaskellDepends = [
          base bytestring containers foldl lens parsec pipes pipes-bytestring
          pipes-group pipes-text split text
@@ -49953,7 +50114,7 @@ self: {
      mkDerivation {
        pname = "fastbayes";
        version = "0.2.0.0";
-       sha256 = "1nqrfrhw8gd3blfzrwbf7pm4wwqbxfaw640bzx62kwh7x2h6v3cm";
+       sha256 = "958d6da0e807f2294cff0b10c395eb0b734eea3d6ef1fc1d5da33dc4617619db";
        libraryHaskellDepends = [ base hmatrix vector ];
        jailbreak = true;
        homepage = "https://github.com/cscherrer/fastbayes";
@@ -49966,7 +50127,7 @@ self: {
      mkDerivation {
        pname = "fastcgi";
        version = "3001.0.2.4";
-       sha256 = "0lp17w098043xczwkah7h1x47wzrym7vv5adgla0aq9iybqay7xr";
+       sha256 = "b91faff0f2316105147d4d95bd4ff5f9f3437a8007aac93feb830094003fe152";
        revision = "1";
        editedCabalFile = "74cd87692a90492171802f25c034ef047f0b68aaa1b53303d4e50ce3ec30e98a";
        libraryHaskellDepends = [ base bytestring cgi ];
@@ -49983,7 +50144,7 @@ self: {
      mkDerivation {
        pname = "fastedit";
        version = "0.1.0.0";
-       sha256 = "0ax5wnbf75n39crd9bw0xf3g83zlh29pbhwapbc5q7315rjdfxfj";
+       sha256 = "d275d7642e611c5cd8ba8ac3759380f40ff486eb80afd4324bc396e396e5a52b";
        libraryHaskellDepends = [
          base base-prelude bytestring containers hashable safe
          unordered-containers
@@ -50004,7 +50165,7 @@ self: {
      mkDerivation {
        pname = "fastirc";
        version = "0.2.0";
-       sha256 = "0ddacpw19kh304j8js9ybwclkgyh8n5yy1r2xh48z9h3gas2zim4";
+       sha256 = "a4c62fb47a03a68f08ec2207ef8b45d0bf49195f3e6989240103ce14f865aa35";
        libraryHaskellDepends = [
          attoparsec base bytestring bytestring-show containers monadLib
          network-fancy
@@ -50019,7 +50180,7 @@ self: {
      mkDerivation {
        pname = "fault-tree";
        version = "0.0.0";
-       sha256 = "04m6hfj0sqhmq89fwfq4igz1rc0p3rzkhfg6fzsw5kyda2c8bbz0";
+       sha256 = "e0af859850cdcfc2f577e639387f1e17b01cfe8b043bee12c215620da483a612";
        libraryHaskellDepends = [ base yices ];
        homepage = "http://tomahawkins.org";
        description = "A fault tree analysis library";
@@ -50038,7 +50199,7 @@ self: {
      mkDerivation {
        pname = "fay";
        version = "0.23.1.8";
-       sha256 = "1772gdqka5hcgs2bq76bba9pca5xx32q3fg9vvkjqd5249rk5gv6";
+       sha256 = "66bf327322a2342ce7dee9b981c5e8bd2876935acb1cbc847e0c1635717be29c";
        isLibrary = true;
        isExecutable = true;
        libraryHaskellDepends = [
@@ -50059,7 +50220,7 @@ self: {
      mkDerivation {
        pname = "fay-base";
        version = "0.20.0.1";
-       sha256 = "17mfblr40jhn93vz6vn0n0xsk4lwf5d5cavfy5zy8sg4inp6dkjr";
+       sha256 = "59ce66ae8de469e47ff16e2b565a719c92a93bb0c06ef3f748164a40325dae9e";
        libraryHaskellDepends = [ base fay ];
        homepage = "https://github.com/faylang/fay/";
        description = "The base package for Fay";
@@ -50073,7 +50234,7 @@ self: {
      mkDerivation {
        pname = "fay-builder";
        version = "0.2.0.5";
-       sha256 = "18ii5dnzk866q79h43fspdz8dzg17mzfrykh3pl4p0q4qdnylv8i";
+       sha256 = "116dea6dc304834be81d70faec7e3de1fd867ebbda0d02d3c1c6a0f96d2b31a2";
        libraryHaskellDepends = [
          base Cabal data-default directory fay filepath safe split text
        ];
@@ -50086,7 +50247,7 @@ self: {
      mkDerivation {
        pname = "fay-dom";
        version = "0.5.0.1";
-       sha256 = "1zm6w6nccswaksr283alhnsss6xw4k7s61yp8ff4lg5127ff9wp0";
+       sha256 = "e0f2e4dc11a13c4a9c43d707a3cf24bc1badb585540d24b29e8a6bc6ace1a6fe";
        libraryHaskellDepends = [ fay-base ];
        homepage = "https://github.com/faylang/fay-dom";
        description = "DOM FFI wrapper library for Fay";
@@ -50098,7 +50259,7 @@ self: {
      mkDerivation {
        pname = "fay-geoposition";
        version = "0.1.0.1";
-       sha256 = "1qmkwfqgvj6a8fan1l3i18ggpl00vrfd2mhqj13g0gh9yhvgxv1q";
+       sha256 = "38ecfe36f4093ef046901856d15cde00d0fb1e0a71d0609543cac8fdb0e3b3e2";
        libraryHaskellDepends = [ fay-base fay-text ];
        homepage = "https://github.com/victoredwardocallaghan/fay-geoposition";
        description = "W3C compliant implementation of GeoPosition API";
@@ -50110,7 +50271,7 @@ self: {
      mkDerivation {
        pname = "fay-hsx";
        version = "0.2.0";
-       sha256 = "1mzjna8yc7jczgggpcgh9i6akiy72d60jczvmzxngh778z3g5zmi";
+       sha256 = "b1fef2c647e7c067fbaffb33094c13c7c7a94c4cf0b1fbdefb4c1ee691b2f2d7";
        libraryHaskellDepends = [ fay-base fay-jquery ];
        jailbreak = true;
        homepage = "http://www.happstack.com/";
@@ -50124,7 +50285,7 @@ self: {
      mkDerivation {
        pname = "fay-jquery";
        version = "0.6.0.3";
-       sha256 = "1x6i8y6xbz4nyzw59j3cqkhmjvgx9l4vdyh7jr0l1vv396ssnghf";
+       sha256 = "0e3eabb54963ef40419607fab6094dfd6d59e1c46cc854f8f796fcd58d47d1f4";
        libraryHaskellDepends = [ fay-base fay-text ];
        homepage = "https://github.com/faylang/fay-jquery";
        description = "jQuery bindings for Fay";
@@ -50136,7 +50297,7 @@ self: {
      mkDerivation {
        pname = "fay-ref";
        version = "0.1.0.0";
-       sha256 = "1dcifraih13zqwmm4xn57wfg63rdkiac81avyymid308r6p1x9cn";
+       sha256 = "96a51eaec9088c16abf75b05c4549c2d0ff31c3fc576522bc77f0418557691b5";
        libraryHaskellDepends = [ fay-base ];
        homepage = "https://github.com/A1kmm/fay-ref";
        description = "Like IORef but for Fay";
@@ -50148,7 +50309,7 @@ self: {
      mkDerivation {
        pname = "fay-text";
        version = "0.3.2.2";
-       sha256 = "1q1v8jzkccy9arq6jkz4ynpzm1691d1dv9wzyi4i5m6n0gl7aans";
+       sha256 = "da2a75e803d6d41249f49fa7dd420bc984faaff5e44f697056c93336bf443be0";
        libraryHaskellDepends = [ fay fay-base text ];
        homepage = "https://github.com/faylang/fay-text";
        description = "Fay Text type represented as JavaScript strings";
@@ -50160,7 +50321,7 @@ self: {
      mkDerivation {
        pname = "fay-uri";
        version = "0.2.0.0";
-       sha256 = "1vv4jgkz9cx8inbn6g6sn3a0nf1ak81qlj5li21sk2isj0yws1nr";
+       sha256 = "d906cd3d903a8aa98388b4488a039a2a380bd4b0da3c63978da8b3f4e79364ef";
        libraryHaskellDepends = [ fay-base ];
        homepage = "https://github.com/faylang/fay-uri";
        description = "Persistent FFI bindings for using jsUri in Fay";
@@ -50178,7 +50339,7 @@ self: {
      mkDerivation {
        pname = "fb";
        version = "1.0.11";
-       sha256 = "19kvsc6ap56b3h1z6wnjqmxgnqs7jqlhd3zx08h6nxkip3ddnzh5";
+       sha256 = "057edbdab871766b2002fd8f0629964763fb7ac5d272f3031ccb94ab0cd37ba6";
        libraryHaskellDepends = [
          aeson attoparsec base base16-bytestring base64-bytestring
          bytestring cereal conduit conduit-extra crypto-api cryptohash
@@ -50202,7 +50363,7 @@ self: {
      mkDerivation {
        pname = "fb-persistent";
        version = "0.3.5";
-       sha256 = "0idxwm4brbn73s8azxsys6lxg9c4vzs0b123h9lg4qs4ks5451hh";
+       sha256 = "1086428a9e4463f26882438405f4df84a5d7a9d15ef7af901ec7aebc48e5bd45";
        libraryHaskellDepends = [ base cereal fb persistent text time ];
        homepage = "https://github.com/prowdsponsor/fb-persistent";
        description = "Provides Persistent instances to Facebook types";
@@ -50216,7 +50377,7 @@ self: {
      mkDerivation {
        pname = "fca";
        version = "0.1.0.2";
-       sha256 = "1c38524r3mhy4m7s1cvfcn539xvf50x0z8a9fzk4x4pz5yq9c1vp";
+       sha256 = "770796b02fff924ee67749a10f3a286ef7348a656eb3a04f251ed691892868b0";
        libraryHaskellDepends = [
          base bytestring containers cryptohash hashable text
          unordered-containers
@@ -50233,7 +50394,7 @@ self: {
      mkDerivation {
        pname = "fcd";
        version = "1.0.0.0";
-       sha256 = "1z3vphn3vgvsq0mshhvsks03v79wnj9g6r8mmrwkiax126aqzqn6";
+       sha256 = "c6e28f9511a1ab3879ae1565f392b43c9d3d809e7a43a82bc07abf3d2cbc7bfc";
        isLibrary = true;
        isExecutable = true;
        libraryHaskellDepends = [
@@ -50252,7 +50413,7 @@ self: {
      mkDerivation {
        pname = "fckeditor";
        version = "0.1";
-       sha256 = "1yvsnk9awik143jh2268w1l5x70kmky60gac10fy2y1450dcn65x";
+       sha256 = "bd18cb1a282478e11d084c3d60fcac139c5e68e0c80801e5206146aed2b47afb";
        libraryHaskellDepends = [ base cgi HaXml xhtml ];
        jailbreak = true;
        homepage = "http://peteg.org/";
@@ -50267,7 +50428,7 @@ self: {
      mkDerivation {
        pname = "fclabels";
        version = "2.0.2.2";
-       sha256 = "0jvmmmky2h4i6lh0zj67j8rf1r1r1plv1s9y67jbs821266ffra8";
+       sha256 = "4865e78c114120bde4313ee9b0e90d39e4e03292c7c80f20359140e167ad754b";
        libraryHaskellDepends = [ base mtl template-haskell transformers ];
        testHaskellDepends = [
          base HUnit mtl template-haskell transformers
@@ -50282,7 +50443,7 @@ self: {
      mkDerivation {
        pname = "fclabels-monadlib";
        version = "0.2.1";
-       sha256 = "1j15fxrpwnjnbjkswsy6jxn8f0bj2nhcdsf5976i7rka7gsjzr3d";
+       sha256 = "6de42ff53b6ae613cd49c5e9c6a0157201876c97c66baea75c565a7e737725c8";
        libraryHaskellDepends = [ base fclabels monadLib ];
        jailbreak = true;
        description = "MonadLib monadic interface for the \"fclabels\" package";
@@ -50294,7 +50455,7 @@ self: {
      mkDerivation {
        pname = "fdo-notify";
        version = "0.3.1";
-       sha256 = "1n4zk1i7g34w0wk5zy8n4r63xbglxf62h8j78kv5fc2yn95l30vh";
+       sha256 = "7083414bb25e3057f6444722288cebf4ad3e4c2616f95f26079c8c7762989fd8";
        libraryHaskellDepends = [ base containers dbus ];
        homepage = "http://bitbucket.org/taejo/fdo-notify/";
        description = "Desktop Notifications client";
@@ -50308,7 +50469,7 @@ self: {
      mkDerivation {
        pname = "fdo-trash";
        version = "0.0.0.2";
-       sha256 = "04y29wmndyvrlrixj57m7jgx3z8qld0nvlggmg0rvia4p2dv82bk";
+       sha256 = "7309b49bb844c59dc1abefd16d41a318fdd19f3cf514d963a679fb662b4fc213";
        isLibrary = true;
        isExecutable = true;
        libraryHaskellDepends = [
@@ -50328,7 +50489,7 @@ self: {
      mkDerivation {
        pname = "feature-flags";
        version = "0.1.0.1";
-       sha256 = "1lssjgksq0k2dd7l5lmzxnr9f5zk3gbh386zfmcqgc4iczdzfk0f";
+       sha256 = "0e4cf7db6791b0875975dfa001d71bf31797b2edbfd2424f6b6202ace7935ad3";
        libraryHaskellDepends = [ base text ];
        homepage = "https://github.com/iand675/feature-flags";
        description = "A simple library for dynamically enabling and disabling functionality";
@@ -50340,7 +50501,7 @@ self: {
      mkDerivation {
        pname = "fec";
        version = "0.1.1";
-       sha256 = "04ryd1c06l45af6627vjvprhs0rk1rwl0k9gq0byr95ghvc6mk6d";
+       sha256 = "cdcc6ad886afa4ec17c02f4d40790e33030df3dd721f618c5385500358683e13";
        libraryHaskellDepends = [ base bytestring ];
        homepage = "http://allmydata.org/source/zfec";
        description = "Forward error correction of ByteStrings";
@@ -50354,7 +50515,7 @@ self: {
      mkDerivation {
        pname = "fedora-packages";
        version = "0.0.3";
-       sha256 = "14fpv76ndp755mysgbya2hgr35rg2hb6dsagmrq2j2mn06xmngqk";
+       sha256 = "133f5bbb01b60a2970ae4fe96616142f97911f14caafa77d2de5dc66cdd9d791";
        revision = "1";
        editedCabalFile = "b09d857e6d91527f8c9fbb8626e1610c5c7b994a6fcf30cd3328c668a6e8d33a";
        libraryHaskellDepends = [
@@ -50378,7 +50539,7 @@ self: {
      mkDerivation {
        pname = "feed";
        version = "0.3.9.7";
-       sha256 = "01ssy7a1525cw72igpk1xksyafs7can68gmb81kvlzw8fddl4s0l";
+       sha256 = "1468425b73887fba6740ab3e64ac62473be5f5ec61de17c5e1ac8812d4f15a07";
        libraryHaskellDepends = [
          base old-locale old-time time time-locale-compat utf8-string xml
        ];
@@ -50398,7 +50559,7 @@ self: {
      mkDerivation {
        pname = "feed-cli";
        version = "2009.7.5";
-       sha256 = "0gql641jmbldx6vhk37i2v41j2nq22lrihm48f97wirrxw7yjn61";
+       sha256 = "c158e90fef39477e9243a4c298a910d80a19c816f18c09b7e98dae2a0331143f";
        isLibrary = false;
        isExecutable = true;
        executableHaskellDepends = [
@@ -50418,7 +50579,7 @@ self: {
      mkDerivation {
        pname = "feed-crawl";
        version = "0.1.2.0";
-       sha256 = "0d3yfkiazzlypp3s85fqikwlli28ss27h0i215114vxsswmx1g7c";
+       sha256 = "ecbcd02bd7ba6f12420922027884d648444af98cd815a4c7bd9efeafe2747e34";
        libraryHaskellDepends = [
          base bytestring conduit connection http-conduit http-types hxt
          network-uri text transformers
@@ -50436,7 +50597,7 @@ self: {
      mkDerivation {
        pname = "feed2lj";
        version = "0.0.3.1";
-       sha256 = "0ym4f6d8fxl6j9kfqmp3ds36qj35nypxjmmqv6w96yz5y8ia3ynv";
+       sha256 = "dbfaa122f2e57b93b8d9b856d9afb765486c866ee356ec66928676879a71a47a";
        isLibrary = false;
        isExecutable = true;
        executableHaskellDepends = [
@@ -50454,7 +50615,7 @@ self: {
      mkDerivation {
        pname = "feed2twitter";
        version = "0.2.0";
-       sha256 = "1zhl7f5zlyv0l5h0zay66p532n1vywnirwxbc1c9fjaia7yv0rij";
+       sha256 = "3266b0fd515149975860abf31c2df73b5831ca35c6ab0f60a1607bfa8b3b14fe";
        isLibrary = true;
        isExecutable = true;
        libraryHaskellDepends = [
@@ -50476,7 +50637,7 @@ self: {
      mkDerivation {
        pname = "feldspar-compiler";
        version = "0.7";
-       sha256 = "0kkxjnbx4yn3k2s1gdxg4jj06fhdd2jprq8s4zyaybs8xcddgvhh";
+       sha256 = "10eed71aeb482faffc271ae17ca5680d3a03a424afb717b498c37ad297957d4e";
        libraryHaskellDepends = [
          base Cabal containers data-default directory feldspar-language
          filepath ghc-paths mtl plugins plugins-multistage pretty process
@@ -50503,7 +50664,7 @@ self: {
      mkDerivation {
        pname = "feldspar-language";
        version = "0.7";
-       sha256 = "0gzs2qdvpzcx4w89wpmwk2jnambvyl08afpk16989vcviq5ri51n";
+       sha256 = "3694980b8e9bed849209f33a8500f57b5565a598bc5e9e10279dfdbb1b16fa3f";
        libraryHaskellDepends = [
          array base containers data-default data-hash data-lens deepseq
          monad-par mtl patch-combinators QuickCheck random syntactic tagged
@@ -50528,7 +50689,7 @@ self: {
      mkDerivation {
        pname = "feldspar-signal";
        version = "0.0.1.0";
-       sha256 = "147y0fy5pzagk8pm8way8qnxv42mn5qh8kmzjf02laydzxrwvpxd";
+       sha256 = "addfcd73ffcd2b2a8093bf4e0471b15590dd2d465e71542f9a4ffd5bbc03fe90";
        libraryHaskellDepends = [
          base base-compat feldspar-compiler feldspar-compiler-shim
          feldspar-language imperative-edsl mainland-pretty monadic-edsl-priv
@@ -50547,7 +50708,7 @@ self: {
      mkDerivation {
        pname = "fen2s";
        version = "1.2";
-       sha256 = "01111rxpdd9pqpjs54krx4z67k3abjglw9zbvn5j97z9zdj5qr81";
+       sha256 = "01655c64fbe99f248bddeb274e9f5c6acc633ee97992a2e5c537b5767b0e2104";
        isLibrary = true;
        isExecutable = true;
        libraryHaskellDepends = [
@@ -50568,7 +50729,7 @@ self: {
      mkDerivation {
        pname = "fences";
        version = "0.1.1";
-       sha256 = "16qzqczr6nlbng16vby1c12a0apfjm4lmm0pgybi5xaziaq4c4db";
+       sha256 = "ab1146b08a5ff512977f17d44a4995ee2aa04460c1af6dc2b38b5a933fc31f9b";
        libraryHaskellDepends = [ base ];
        description = "To be written";
        license = stdenv.lib.licenses.gpl3;
@@ -50582,7 +50743,7 @@ self: {
      mkDerivation {
        pname = "fenfire";
        version = "0.1";
-       sha256 = "0sq4g0sdayk1lqzdhggwshl22gny5cjbv70cmr1p27q0wfwfbfff";
+       sha256 = "ceb9e5b8e3001f7143ae0c9cbd242bde3e2128d4fc3dd83ea6617ad53478046b";
        isLibrary = false;
        isExecutable = true;
        executableHaskellDepends = [
@@ -50600,7 +50761,7 @@ self: {
      mkDerivation {
        pname = "fez-conf";
        version = "1.0.3";
-       sha256 = "1gssbkwg9lqm3ajqkkcjnxjz8nhz855ki2hi5n2di3dappr73f0b";
+       sha256 = "0bb871f2bdaa8dd8842d118a384b411f5af465b792cd89a51a15d3f4f85c5abf";
        libraryHaskellDepends = [ base containers regex-compat ];
        homepage = "http://ui3.info/d/proj/fez-conf.html";
        description = "Simple functions for loading config files";
@@ -50612,7 +50773,7 @@ self: {
      mkDerivation {
        pname = "ffeed";
        version = "0.3.2";
-       sha256 = "1976v5m050lwp8v2vh1cm08pn6q9lbdkxhq10pql6fyzysn6qz62";
+       sha256 = "c27c6cacf6df3b43f10501c33edba2091b7b11a82cc02d36ba9c82026ad9e6a4";
        isLibrary = true;
        isExecutable = true;
        libraryHaskellDepends = [ base HTTP json network utf8-string ];
@@ -50631,7 +50792,7 @@ self: {
      mkDerivation {
        pname = "fficxx";
        version = "0.2.1";
-       sha256 = "1vjkwp0krs2762ww7vkl1g0dpaw6ifba7acjndmqbnvm3yl0ha0d";
+       sha256 = "0d2808a81f75db856bb392a9a3968b86abdbc00b74eec3b93047e83cc1e553ee";
        libraryHaskellDepends = [
          base bytestring Cabal containers data-default directory either
          errors filepath hashable HStringTemplate lens mtl process pureMD5
@@ -50646,7 +50807,7 @@ self: {
      mkDerivation {
        pname = "fficxx-runtime";
        version = "0.2.1";
-       sha256 = "0hcpc0db4mh3yx8yzbkllq9b04dd1qvr63ppz2qa9nq5zydb5pxk";
+       sha256 = "b3dfb29aff05dba4b0f8f70e93370ead11b012a674aeef51f70356b21a609741";
        libraryHaskellDepends = [ base ];
        description = "Runtime for fficxx-generated library";
        license = stdenv.lib.licenses.bsd3;
@@ -50659,7 +50820,7 @@ self: {
      mkDerivation {
        pname = "ffmpeg-light";
        version = "0.8.2";
-       sha256 = "13pkdsjsw1h6gscpp2jwly1w81jj3rpb27ssa0w7gi2qhjcg1inw";
+       sha256 = "dcc6f0988458c47738505a1fb16e1e5206c483a75c8a7b997e0606aea56ef38e";
        isLibrary = true;
        isExecutable = true;
        libraryHaskellDepends = [
@@ -50682,7 +50843,7 @@ self: {
      mkDerivation {
        pname = "ffmpeg-tutorials";
        version = "0.3.3";
-       sha256 = "134czpbzxw0mpnc5mz6j1l6vavdbhw5w3l4lg5zbc2gq1qg9ikqv";
+       sha256 = "1bcf981e0ef809b67e7994d0c10b87ab6db50d0dd2fc5a98bd15f0fed7fd8c8c";
        isLibrary = false;
        isExecutable = true;
        executableHaskellDepends = [
@@ -50702,7 +50863,7 @@ self: {
      mkDerivation {
        pname = "fft";
        version = "0.1.8.1";
-       sha256 = "00q1j6swi5y740n5dnbc73aw1nphsgyx7qnv59snqd48fcllhcww";
+       sha256 = "9c3348297388346c752adbe2d3fdd3f0dac0d5386cd9562c20c797c8b5910103";
        libraryHaskellDepends = [
          array base carray ix-shapable storable-complex syb
        ];
@@ -50718,7 +50879,7 @@ self: {
      mkDerivation {
        pname = "fftwRaw";
        version = "0.1.0.0";
-       sha256 = "1dkkn72g4arjamv647ba05j7aj95vvjy2wdd6g9xcc5w2ix45kr4";
+       sha256 = "24cf427a14bc30d6d333ad71e1e5de25497564016a1d627655322bf2c4b173b6";
        libraryHaskellDepends = [ base ];
        librarySystemDepends = [ fftw ];
        homepage = "https://github.com/adamwalker/haskell-fftw-simple";
@@ -50733,7 +50894,7 @@ self: {
      mkDerivation {
        pname = "fgl";
        version = "5.5.2.1";
-       sha256 = "1nfm3gkr6cccqhi1g46k2d0l99yw2vq7xjd1hxxzcci5gidp8bhc";
+       sha256 = "0c2e745b7c2532f67b87a1c97ef016dca7444113d3901722c48c3193e71bd5d9";
        libraryHaskellDepends = [
          array base containers deepseq transformers
        ];
@@ -50747,7 +50908,7 @@ self: {
      mkDerivation {
        pname = "fgl-arbitrary";
        version = "0.2.0.0";
-       sha256 = "1116c4r1ick3xjhwwq9b6i1082njmxj2aymgkqppabj3d0hv43c4";
+       sha256 = "840db22168432e752f9eaf7a2564afd20a0442342b61cea1ec63b21832612684";
        libraryHaskellDepends = [ base fgl QuickCheck ];
        testHaskellDepends = [ base containers fgl hspec QuickCheck ];
        description = "QuickCheck support for fgl";
@@ -50759,7 +50920,7 @@ self: {
      mkDerivation {
        pname = "fgl-extras-decompositions";
        version = "0.1.1.0";
-       sha256 = "0p9dv7hq312wjqzm2ha4rafnmd1vplzwd5vk5fmzypgl2a1cz42s";
+       sha256 = "5a90cf8212f45dffab2b7397c63fbd3bb46a9dca4441513f965c8481e1d92d5d";
        libraryHaskellDepends = [ base containers fgl ];
        homepage = "http://www.bioinf.uni-leipzig.de/~choener/";
        description = "Graph decomposition algorithms";
@@ -50771,7 +50932,7 @@ self: {
      mkDerivation {
        pname = "fgl-visualize";
        version = "0.1.0.1";
-       sha256 = "0vwafx0rggksg5i7cx4r2bs5wa6csb5p39vpix425zr3l6vggrxq";
+       sha256 = "b8e7f7b6a123ff22488f77a771cbd2cc285ef41299747662797abe9741778a6f";
        libraryHaskellDepends = [ base dotgen fgl ];
        description = "Convert FGL graphs to dot (graphviz) files";
        license = stdenv.lib.licenses.bsd3;
@@ -50786,7 +50947,7 @@ self: {
      mkDerivation {
        pname = "fibon";
        version = "0.2.0";
-       sha256 = "1jkawf65gdmyzmdw4xfk3jihahi3x7vsavjfy6rnl96bj15q4vzl";
+       sha256 = "f46f824b90cb246ab3f14e6ea5f7e9234205a31cd375c25bfdbeb6578ce36aca";
        isLibrary = false;
        isExecutable = true;
        executableHaskellDepends = [
@@ -50806,7 +50967,7 @@ self: {
      mkDerivation {
        pname = "fibonacci";
        version = "0.2.0.1";
-       sha256 = "18jqb4ynjsnpvydzpqzh7l5wyrjb3s3kxgc6a6ipwb6w2hygyf7k";
+       sha256 = "f338ff3c14dc2c7ea35186bd3e871e4b66cf0b3df0e3fb9bdfd76a693d5958a2";
        libraryHaskellDepends = [ base ];
        homepage = "http://github.com/sebfisch/fibonacci";
        description = "Fast computation of Fibonacci numbers";
@@ -50820,7 +50981,7 @@ self: {
      mkDerivation {
        pname = "fields";
        version = "0.1.0";
-       sha256 = "0xxri0a3y75ppywcm6py9zbffaawcycrv8gabflbl1m1z8n6jq6v";
+       sha256 = "db60692cfaa106baa85beaa19d99675c29e7d64ffe9acab8bfb71c3f1488b977";
        libraryHaskellDepends = [
          array base containers fclabels monads-fd transformers
        ];
@@ -50837,7 +50998,7 @@ self: {
      mkDerivation {
        pname = "fields-json";
        version = "0.2.2.3";
-       sha256 = "0wqci95ad339nd3lfbhc6v55c7zdkq714hw8igq5fwvbd8kq11d0";
+       sha256 = "a08580276a6b7357f08b8843120e9eed1f56ca360c2e4747b3698ca64a8a0c73";
        libraryHaskellDepends = [
          base base64-bytestring containers json mtl utf8-string
        ];
@@ -50850,7 +51011,7 @@ self: {
      mkDerivation {
        pname = "fieldwise";
        version = "0.1.0.0";
-       sha256 = "1mmlw5nk09w829gjp8lc0p280vdkh68rv05b1j55x99l7xywgvj7";
+       sha256 = "47eec77d3f34a55e8a0cab809d9181b36d80c4058ca22b5f128827306de1b4d6";
        libraryHaskellDepends = [ base template-haskell ];
        testHaskellDepends = [ base template-haskell ];
        jailbreak = true;
@@ -50864,7 +51025,7 @@ self: {
      mkDerivation {
        pname = "fig";
        version = "1.4.0";
-       sha256 = "03bxiicvfwia5g0whg454ph2s34n8firjcqhn6d7qvbim338hkxq";
+       sha256 = "b84f88c6a8716d7c9ab1103399a343960c2de025853cc8c12b2a72b7598c7d0d";
        libraryHaskellDepends = [ base containers parsec pretty ];
        homepage = "http://www.bergsoe.org/fig";
        description = "Manipulation of FIG files";
@@ -50876,7 +51037,7 @@ self: {
      mkDerivation {
        pname = "file-collection";
        version = "0.1.1.9";
-       sha256 = "06bcj143j85p8m519zn88z6qn4bg5ifrw5pv5yva5x49gc3jq6gc";
+       sha256 = "ec192c077b89f4a2b62ffb169e5d2c6f118bcd47c8fe144a45b7203948906c19";
        libraryHaskellDepends = [
          base bytestring clock directory zip-archive
        ];
@@ -50893,7 +51054,7 @@ self: {
      mkDerivation {
        pname = "file-command-qq";
        version = "0.1.0.5";
-       sha256 = "06bi4nnz1f3i79wza6bxbnglqzddpq3r4w581wdl3bq26b52d3ab";
+       sha256 = "4b8d26ca3202af411b0fa8709207bead7d4c9f5d7d19f5793a71b8f0ad257119";
        libraryHaskellDepends = [
          base parsec process system-filepath template-haskell text
        ];
@@ -50910,7 +51071,7 @@ self: {
      mkDerivation {
        pname = "file-embed";
        version = "0.0.8.2";
-       sha256 = "1gdxz9244wjhfigpsyaan81gyx6vanb8574xxi7944sj9pcgi74y";
+       sha256 = "9e9cf8d84d5213924eec9d9c829655db74ff02b24a797d5f7450724244fabdbd";
        libraryHaskellDepends = [
          base bytestring directory filepath template-haskell
        ];
@@ -50927,7 +51088,7 @@ self: {
      mkDerivation {
        pname = "file-location";
        version = "0.4.9";
-       sha256 = "1p0lz02pvlvq2781542ims3x5vcck35dw4g58bv16y96qarxwady";
+       sha256 = "be29deb3c2267913f642e511deca988cedd287ae519012d01178d37d05f814dc";
        libraryHaskellDepends = [
          base containers HUnit lifted-base template-haskell th-orphans
          transformers
@@ -50946,7 +51107,7 @@ self: {
      mkDerivation {
        pname = "filecache";
        version = "0.2.8";
-       sha256 = "0dkdjj29dqgdywzxc24l54v8xqxrqy65l43ig2qr3l381mqi87lf";
+       sha256 = "8e1e14710d68d091b17871105a8cc7b9e38e36299408d63ff7ede19684946d36";
        libraryHaskellDepends = [
          base exceptions hashable hinotify lens mtl stm strict-base-types
          unordered-containers
@@ -50967,7 +51128,7 @@ self: {
      mkDerivation {
        pname = "filediff";
        version = "2.0.0";
-       sha256 = "15a02dya0qhgxq98whxza268vqsrkw6b1ipdskw3hwnjp02hnc9p";
+       sha256 = "37310b05b8d27238f8d4edc6b00c9f59e38d8c50bf438e12ee0f62a07c134095";
        libraryHaskellDepends = [
          base bytestring data-default data-memocombinators directory either
          hashmap mtl rainbow tasty tasty-hunit text threads time
@@ -50987,7 +51148,7 @@ self: {
      mkDerivation {
        pname = "filelock";
        version = "0.1.0.1";
-       sha256 = "0qypjnbkfayqyaymx8qrq4abddlrlzanf6lqhfn9cqzcgzr6735d";
+       sha256 = "ad8c63f27fec6396ac83981a67d5a799b6b614c119a35ebdf2d82b379795d763";
        libraryHaskellDepends = [ base unix ];
        homepage = "http://github.com/takano-akio/filelock";
        description = "Portable interface to file locking (flock / LockFileEx)";
@@ -51001,7 +51162,7 @@ self: {
      mkDerivation {
        pname = "filemanip";
        version = "0.3.6.3";
-       sha256 = "0ilqr8jv41zxcj5qyicg29m8s30b9v70x6f9h2h2rw5ap8bxldl8";
+       sha256 = "8836da17baaaf02ca080c9990ece4e0b0c8d6a128f458f8b64fd07b225ca9846";
        libraryHaskellDepends = [
          base bytestring directory filepath mtl unix-compat
        ];
@@ -51015,7 +51176,7 @@ self: {
      mkDerivation {
        pname = "filepath";
        version = "1.4.0.0";
-       sha256 = "0a5hhgfxh91clkk6c9iipdd0y3wb9y6lx2hhraaaa73b8y83afx4";
+       sha256 = "a43b3590476b1ca594ca108a4e8d4f8b0f0f5abb312666e6a42c24d8dd83b028";
        libraryHaskellDepends = [ base ];
        testHaskellDepends = [ base QuickCheck ];
        jailbreak = true;
@@ -51029,7 +51190,7 @@ self: {
      mkDerivation {
        pname = "filepath-io-access";
        version = "0.1.0.0";
-       sha256 = "08rb2nafnh5vx7i6i3ddhq4h1s2ffgz8ailap5knr1xl7izgyywp";
+       sha256 = "977bff7e3cb4876c67b98a4685fe734ee8000986ad8d68e2e9bb40eb94152b23";
        libraryHaskellDepends = [ base base-io-access filepath ];
        jailbreak = true;
        description = "IO Access for filepath";
@@ -51043,7 +51204,7 @@ self: {
      mkDerivation {
        pname = "filepather";
        version = "0.3.0";
-       sha256 = "1gqnanmnhrpdw5iryf757qwj7j9izyzx1j4y74ydivxafz8w469v";
+       sha256 = "3b19c2d177aaefd83c399ec8d0bfff31c923393ee5389f63e1ed6668ab5516bf";
        libraryHaskellDepends = [
          base comonad comonad-transformers data-lens directory filepath mtl
          transformers
@@ -51061,7 +51222,7 @@ self: {
      mkDerivation {
        pname = "filestore";
        version = "0.6.1";
-       sha256 = "0mfllnnb1mqix1v65fyhd9jsvnrjbawd6l4h4012jk8401zwj280";
+       sha256 = "0009c97f00044d2902209050d3b85a32dbad656ad0bb6276e811d7b0aca5d455";
        libraryHaskellDepends = [
          base bytestring containers Diff directory filepath old-locale
          parsec process split time utf8-string xml
@@ -51081,7 +51242,7 @@ self: {
      mkDerivation {
        pname = "filesystem-conduit";
        version = "1.0.0.2";
-       sha256 = "05dsl3bgyjciq6sgmba0hki7imilrjq3ddp9ip5gxl9884j1f4a1";
+       sha256 = "411117244128d1feca8de9b636b0cc34d678e28440adfab4c19149ffd6a0ba15";
        libraryHaskellDepends = [
          base bytestring conduit containers system-fileio system-filepath
          text transformers unix
@@ -51104,7 +51265,7 @@ self: {
      mkDerivation {
        pname = "filesystem-enumerator";
        version = "0.1.1";
-       sha256 = "04cs5kz390g5qanwqps5kx1pd70b9vzaykn4c0yc0kxi16xlxyrc";
+       sha256 = "2cfb4ebb09b14fc03c60c44eaffe4e0b9c76439f455fccadc2e58134fe2c9a11";
        libraryHaskellDepends = [
          base enumerator system-fileio system-filepath transformers unix
        ];
@@ -51121,7 +51282,7 @@ self: {
      mkDerivation {
        pname = "filesystem-trees";
        version = "0.1.0.6";
-       sha256 = "1bnxhf9ppqwgcnpcanxj6ji8yi1i0pspzhjh3p3zyf57d7y6p8sh";
+       sha256 = "50a36bfc69a738ffc71d50c27ff50531448fa234b25bc5ae658fe37b9383ddae";
        libraryHaskellDepends = [
          base cond containers data-lens-light deepseq directory dlist
          filepath mtl unix
@@ -51136,7 +51297,7 @@ self: {
      mkDerivation {
        pname = "filtrable";
        version = "0.1.0.2";
-       sha256 = "0dfw08pqw4wlja1iavb8zz0rkr97hd7fg1v2akng8n7shmjhgbl5";
+       sha256 = "85ae076585fa58f4ec546287e74e8327e599c1ff686d15839294138e2f02dc35";
        libraryHaskellDepends = [ base ];
        homepage = "https://github.com/strake/filtrable.hs";
        description = "Class of filtrable containers";
@@ -51148,7 +51309,7 @@ self: {
      mkDerivation {
        pname = "final";
        version = "0.1";
-       sha256 = "189vby5ym6hcjpz6y9chlgkyzl8wnndqkhzk7s7qy8mksr3g66f9";
+       sha256 = "c919f346d6b3228f8f3ef3c3899bb51cd1efe7a390256ffe950c9aea8b5f3ba1";
        libraryHaskellDepends = [ base stm transformers ];
        homepage = "http://github.com/errge/final";
        description = "utility to add extra safety to monadic returns";
@@ -51165,7 +51326,7 @@ self: {
      mkDerivation {
        pname = "find-conduit";
        version = "0.4.4";
-       sha256 = "15p1aj8lckmvnrq8a8wz6sbs0d2qbcjgachf5sgpf2lv57hzxksz";
+       sha256 = "5fcffee1299b0a779f2e0e32f5245b5834a097369f238570b6bb4e469154e196";
        isLibrary = true;
        isExecutable = true;
        libraryHaskellDepends = [
@@ -51197,7 +51358,7 @@ self: {
      mkDerivation {
        pname = "fingertree";
        version = "0.1.1.0";
-       sha256 = "1w6x3kp3by5yjmam6wlrf9vap5l5rrqaip0djbrdp0fpf2imn30n";
+       sha256 = "160c5ba370d781dbf2920ddca870ce8596ab76729972535595bef835ee1cddf0";
        libraryHaskellDepends = [ base ];
        testHaskellDepends = [
          base HUnit QuickCheck test-framework test-framework-hunit
@@ -51212,7 +51373,7 @@ self: {
      mkDerivation {
        pname = "fingertree-psqueue";
        version = "0.3";
-       sha256 = "14kc0ijx44q7whniickjj3h9ag1pixn51dlxjs6n2ypaclcjz34z";
+       sha256 = "9f8c2f1965ea7a618d969db6506c8f373c95e09072b2182de40713d265046c92";
        libraryHaskellDepends = [ base fingertree ];
        description = "Implementation of priority search queues as finger trees";
        license = stdenv.lib.licenses.bsd3;
@@ -51223,7 +51384,7 @@ self: {
      mkDerivation {
        pname = "fingertree-tf";
        version = "0.1.0.0";
-       sha256 = "1ja8cqxpqhvssbcywph3zna946g1li5hlzsqab9lhg6vw0baakdn";
+       sha256 = "b64da516e0db3c48d352587f0a4ba4e1199294fd035eeed9d27a437c3b6648c9";
        libraryHaskellDepends = [ base ];
        description = "Generic finger-tree structure using type families";
        license = stdenv.lib.licenses.bsd3;
@@ -51238,7 +51399,7 @@ self: {
      mkDerivation {
        pname = "finite-field";
        version = "0.8.0";
-       sha256 = "0wlbq7dpb4545xdnqjqppp0cmjx9m8g1p6lydkvn7pj7dwar8lni";
+       sha256 = "d15294156f47de63f76c9e9a1b1eaaa9cbcac0bd174b6c5b2fa49075dbc18b72";
        libraryHaskellDepends = [
          base deepseq hashable template-haskell type-level-numbers
        ];
@@ -51256,7 +51417,7 @@ self: {
      mkDerivation {
        pname = "first-class-patterns";
        version = "0.3.2.2";
-       sha256 = "0da7mayn8lcizwjv06rafkgrsj257fhkj5xsxk7nx00n3aazzr68";
+       sha256 = "c8e4ff951a16806ecfecba1739a13b45489ddf742a1bb025ff915164bdaa4735";
        libraryHaskellDepends = [ base transformers ];
        homepage = "https://github.com/reinerp/first-class-patterns";
        description = "First class patterns and pattern matching, using type families";
@@ -51270,7 +51431,7 @@ self: {
      mkDerivation {
        pname = "firstify";
        version = "0.1";
-       sha256 = "1g851dgsxq9gfbsx4qas9vm844ay3g5vhfd1493fgpay0j7i5fnd";
+       sha256 = "cdba128f045edde74622a139b8cb1b5e1182ea4e5a61d2f5722fe1ae5f0b05bd";
        isLibrary = true;
        isExecutable = true;
        libraryHaskellDepends = [
@@ -51289,7 +51450,7 @@ self: {
      mkDerivation {
        pname = "fishfood";
        version = "0.0.1.3";
-       sha256 = "0bmp24mgg9y7ysnb1rig26cwgz1l40ca1fckzxh0yly0j9if062k";
+       sha256 = "5318e06292c0530f60ff93b9a0182034fcc799112fe6b0acf6c7a7f72a11b72e";
        isLibrary = false;
        isExecutable = true;
        executableHaskellDepends = [
@@ -51307,7 +51468,7 @@ self: {
      mkDerivation {
        pname = "fit";
        version = "0.5.1";
-       sha256 = "0y7jvczi0ldzjw9y102z1k4nyj7z8f6p8w368x5v0m308d0jw6db";
+       sha256 = "ab192e41436054b04b476670748d43ff486fc90c5f80e01397bf51103fdbf278";
        libraryHaskellDepends = [
          attoparsec base bytestring containers contravariant mtl text
        ];
@@ -51325,7 +51486,7 @@ self: {
      mkDerivation {
        pname = "fitsio";
        version = "0.2";
-       sha256 = "07zsd05ncq8rnrswk4kzg97sam8czibw2nhlrqxg8q1a5canisag";
+       sha256 = "4fe968152b2a60f43ace145ac157fc0c55a54f7a7f92c975b61961660b68fa1f";
        libraryHaskellDepends = [ base filepath mtl ];
        librarySystemDepends = [ cfitsio ];
        homepage = "http://github.com/esessoms/fitsio";
@@ -51341,7 +51502,7 @@ self: {
      mkDerivation {
        pname = "fix-imports";
        version = "1.0.4";
-       sha256 = "0j8yqqf61f2m4zri844gp6k80vkfzk1rby2miv90niz3hbciknj6";
+       sha256 = "46da19d982e3470bd28e55f895c3fc6e6e80a6b98f1014f32755b8601cc61e49";
        isLibrary = false;
        isExecutable = true;
        executableHaskellDepends = [
@@ -51357,7 +51518,7 @@ self: {
      mkDerivation {
        pname = "fix-parser-simple";
        version = "15320.3";
-       sha256 = "0ls5fxwq2lnb0rjqih4isfwiv0603ga12gxnf7w3rpqp5qhrhas8";
+       sha256 = "482b98212e17df3cf871b63f11d41bc0801db9d391c0886506cb528179774553";
        libraryHaskellDepends = [ base mmtl ];
        description = "Simple fix-expression parser";
        license = "LGPL";
@@ -51369,7 +51530,7 @@ self: {
      mkDerivation {
        pname = "fix-symbols-gitit";
        version = "0.1.0";
-       sha256 = "01fxzhd2wqzp0paba64q5psfc4qvc4b8i88rdkn6mxlkm21gkp6y";
+       sha256 = "dedcf982a893f66aec6c19a18816611b13e6f42d9818b5d405f7632e1afcdd05";
        libraryHaskellDepends = [ base containers gitit ];
        description = "Gitit plugin: Turn some Haskell symbols into pretty math symbols";
        license = stdenv.lib.licenses.bsd3;
@@ -51381,7 +51542,7 @@ self: {
      mkDerivation {
        pname = "fixed";
        version = "0.2.1.1";
-       sha256 = "1qhmwx8iqshns0crmr9d2f8hm65jxbcp3dvv0c39v34ra7if3a94";
+       sha256 = "24a9e1e251998c9d06037bb771d9eab2980a91132de59a19d0166a1c51e715e2";
        libraryHaskellDepends = [ base ];
        homepage = "http://github.com/ekmett/fixed";
        description = "Signed 15.16 precision fixed point arithmetic";
@@ -51393,7 +51554,7 @@ self: {
      mkDerivation {
        pname = "fixed-length";
        version = "0.1";
-       sha256 = "115j7bc6s45qn87hamy4w1ih247cxhyhrzaz244sw4qfkxypigkj";
+       sha256 = "72be787d9f0e13ae09115ffd0c3decec100163e0c457050fb2b8106dd83ab284";
        libraryHaskellDepends = [ base non-empty utility-ht ];
        homepage = "http://code.haskell.org/~thielema/fixed-length/";
        description = "Lists with statically known length based on non-empty package";
@@ -51405,7 +51566,7 @@ self: {
      mkDerivation {
        pname = "fixed-list";
        version = "0.1.6";
-       sha256 = "1gpv0p7xyzmrrq20irf0mpggnc0vm5hpq36j4vd1xlq6bplq1xmb";
+       sha256 = "abf680e95d06d31eda26d20c7c61a91b30fbdeadc0e50804ceb97edfcf05fbbe";
        libraryHaskellDepends = [ base ];
        homepage = "http://github.com/jvranish/FixedList/tree/master";
        description = "A fixed length list type";
@@ -51417,7 +51578,7 @@ self: {
      mkDerivation {
        pname = "fixed-point";
        version = "0.5.0.1";
-       sha256 = "010gx32av4cn5bqq1zrrcah50ay528vw01fvv1xhfpkrx1ll9wka";
+       sha256 = "6af24469e8795e077bd8db05c03712c52b50a06239ff80f12a9691adc4e80f04";
        libraryHaskellDepends = [ base ];
        jailbreak = true;
        description = "Binary fixed-point arithmetic";
@@ -51430,7 +51591,7 @@ self: {
      mkDerivation {
        pname = "fixed-point-vector";
        version = "0.5.0.1";
-       sha256 = "029mn44d1i794b1pbpa0zmf6b20zl0cvsf77mbfdkqnyx8986883";
+       sha256 = "03218312eadee2d9dcaae738bd19a01f88655cfd40dd75c322e9c4d008b13509";
        libraryHaskellDepends = [ base fixed-point vector ];
        jailbreak = true;
        description = "Unbox instances for the fixed-point package";
@@ -51443,7 +51604,7 @@ self: {
      mkDerivation {
        pname = "fixed-point-vector-space";
        version = "0.5.0.1";
-       sha256 = "10b29gqy3rpwd5wf2b65p0llm8ksyp1p7k43rm1n5g5z67wkd7dx";
+       sha256 = "bd9d36f931bfbc6243cd83cc73c3f57aa24a29b8c52ce17869fce6e1f14b6281";
        libraryHaskellDepends = [ base fixed-point vector-space ];
        jailbreak = true;
        description = "vector-space instances for the fixed-point package";
@@ -51458,7 +51619,7 @@ self: {
      mkDerivation {
        pname = "fixed-precision";
        version = "0.4.0";
-       sha256 = "1akgiark8svzkqx764iic10qpfixm0js8vwga0134d81ppcp58f6";
+       sha256 = "c6a172d9bd01353202508f6fa425a83dba8b41603112733a9e7f6b34b38a6faa";
        libraryHaskellDepends = [
          base hmpfr integer-gmp reflection tagged template-haskell
        ];
@@ -51474,7 +51635,7 @@ self: {
      mkDerivation {
        pname = "fixed-storable-array";
        version = "0.3.1.1";
-       sha256 = "0vb5h2v2qx19d7xibf7ksv2cha2pngh49mfpkh43f9vrwc6042ph";
+       sha256 = "f00a020ce3792737089cd7d544e0b35728c8c4d6f3b815fb6929742cb680656d";
        libraryHaskellDepends = [ array base tagged ];
        jailbreak = true;
        description = "Fixed-size wrapper for StorableArray, providing a Storable instance. Deprecated - use storable-static-array instead.";
@@ -51487,7 +51648,7 @@ self: {
      mkDerivation {
        pname = "fixed-vector";
        version = "0.8.0.0";
-       sha256 = "1hlg0rbi2phk7qr7nvjnazg344jqp5p13c3m8v5n01vw9bvjbnir";
+       sha256 = "39da25f74a7c0760cb4675b0116eb9581232de57566e7b323e135e1157068fc2";
        libraryHaskellDepends = [ base deepseq primitive ];
        testHaskellDepends = [ base doctest filemanip primitive ];
        jailbreak = true;
@@ -51502,7 +51663,7 @@ self: {
      mkDerivation {
        pname = "fixed-vector-binary";
        version = "0.6.0.0";
-       sha256 = "1yjyw9wc92laiwd9w8ng3456azicvf9a9wqk2v6liiksj3flw7hy";
+       sha256 = "1e1e4edd907ac648cd1613f3a492db2c7e650a19cf229e1a8f8a8ac478e25efa";
        libraryHaskellDepends = [ base binary fixed-vector ];
        testHaskellDepends = [
          base binary fixed-vector tasty tasty-quickcheck
@@ -51518,7 +51679,7 @@ self: {
      mkDerivation {
        pname = "fixed-vector-cereal";
        version = "0.6.0.0";
-       sha256 = "1kf3d0pfaif5fish1vc5z7d5ym23bwl80l8bg4bgpdw75cg2dnn6";
+       sha256 = "c6da261e2b87b7fb16790b5180285f43545fdaf985ed007574c545e52e68c3cd";
        libraryHaskellDepends = [ base cereal fixed-vector ];
        testHaskellDepends = [
          base cereal fixed-vector tasty tasty-quickcheck
@@ -51534,7 +51695,7 @@ self: {
      mkDerivation {
        pname = "fixed-vector-hetero";
        version = "0.3.1.0";
-       sha256 = "0x5fjggm0licrdd442pr1968zlzfb0ah4ib8s9yxcb2p6vc39lzv";
+       sha256 = "fbd334d836572cd67dd26845021558eed38f4c0af90a425acb2c5250df93ae74";
        libraryHaskellDepends = [
          base deepseq fixed-vector ghc-prim primitive transformers
        ];
@@ -51548,7 +51709,7 @@ self: {
      mkDerivation {
        pname = "fixedprec";
        version = "0.2.2.1";
-       sha256 = "0s921nhkmdglmcwzyr048r04dswc6hz7kvh9p4lvd8i2mxq0szgi";
+       sha256 = "f17d0d70af22a2b629b909ee793e348ceb4640460464ff39abf4b53aa10d2269";
        libraryHaskellDepends = [ base random ];
        description = "A fixed-precision real number type";
        license = stdenv.lib.licenses.bsd3;
@@ -51559,7 +51720,7 @@ self: {
      mkDerivation {
        pname = "fixedwidth-hs";
        version = "0.4.0.1";
-       sha256 = "0k4lidf95nb4a735331xdr77643b1yb15xllplxknbxxq9r2z3px";
+       sha256 = "fd8e2f72c2bd2f3b3bbd94f612960f6b10734e6e3d8c51c65164d9925c8b944c";
        isLibrary = true;
        isExecutable = true;
        libraryHaskellDepends = [ aeson attoparsec base bytestring text ];
@@ -51579,7 +51740,7 @@ self: {
      mkDerivation {
        pname = "fixhs";
        version = "0.1.4";
-       sha256 = "0kxfx3k2d8xy75s7cln3l1hiia5vjcr6k5almbpys63dkr3svcz2";
+       sha256 = "e2b3ad479e6d18edefaa5495693293bba81861a0c352767439bea326e6e8ae4f";
        isLibrary = true;
        isExecutable = true;
        libraryHaskellDepends = [
@@ -51601,7 +51762,7 @@ self: {
      mkDerivation {
        pname = "fixplate";
        version = "0.1.5";
-       sha256 = "0mmkkydvdiw4nawgw3w7a9gpcxc3wzzlhz2083hqa6sxhx8x3b29";
+       sha256 = "49acd151875d1b85e140407c48ffe78375765f52870ffeb8b284c7b69b9fb356";
        libraryHaskellDepends = [ base containers ];
        homepage = "http://code.haskell.org/~bkomuves/";
        description = "Uniplate-style generic traversals for optionally annotated fixed-point types";
@@ -51614,7 +51775,7 @@ self: {
      mkDerivation {
        pname = "fixpoint";
        version = "0.1.1";
-       sha256 = "05h1cw1gpnwk1qjlia4l27j375cva8pp75fzn99w2rxsv6khszpb";
+       sha256 = "eb7e0da7d9ba67c153b2df95732f529b9533e41194a848250e93dbfb02670116";
        libraryHaskellDepends = [ base ];
        homepage = "http://www.cse.unsw.edu.au/~rl/code/fixpoint.html";
        description = "Data types as fixpoints";
@@ -51626,7 +51787,7 @@ self: {
      mkDerivation {
        pname = "fixtime";
        version = "1.5.0.2";
-       sha256 = "1walxcyi1wrv28vgy318c88z3mprz6mc8qfhbjgxb156iwfv80w5";
+       sha256 = "8503b41d8fa684d59f5cd061c4aaf9f9d6f11162280cff36123bf3103deb54f1";
        libraryHaskellDepends = [ base time ];
        homepage = "https://github.com/pharpend/fixtime";
        description = "Some fixes to the time package";
@@ -51638,7 +51799,7 @@ self: {
      mkDerivation {
        pname = "fizz-buzz";
        version = "0.1.0.1";
-       sha256 = "169xaj7iczz0mnvd03pf95dcvy918jscpzap6z9y62kb0daskg4p";
+       sha256 = "97bca955036b0ae3d33757fdcbb44421f9cd5a49ee0ed0b6ade07f168f543d99";
        libraryHaskellDepends = [ base ];
        jailbreak = true;
        description = "Functional Fizz/Buzz";
@@ -51652,7 +51813,7 @@ self: {
      mkDerivation {
        pname = "flaccuraterip";
        version = "0.3.4";
-       sha256 = "0vx4fn1d8i2qh0q20vijhp7yc0zcvjdwk1v7f7ra0kbm4ygmi38h";
+       sha256 = "108d589f27754da0f2716787c99bdcec03e6cf85326e2030805844d48275a46f";
        isLibrary = false;
        isExecutable = true;
        executableHaskellDepends = [
@@ -51668,7 +51829,7 @@ self: {
      mkDerivation {
        pname = "flamethrower";
        version = "0.0.5.1";
-       sha256 = "10kfy1cnp721hgz6lbc28y7hkjhbv6gpk2jff6nk2avrfbaqqd8x";
+       sha256 = "1d358cd572792b31ad714e8a799fd90bca098f47822d6afe83419c6b59f06e82";
        libraryHaskellDepends = [ base template-haskell text ];
        jailbreak = true;
        homepage = "https://charmander.me/flamethrower/";
@@ -51681,7 +51842,7 @@ self: {
      mkDerivation {
        pname = "flamingra";
        version = "0.1.1.1";
-       sha256 = "1yfqgbjam33vrkic5xnb8pp76215jnacr6sj1xw1xqcbcs02bn3v";
+       sha256 = "7bd82580668be11e780f529bcc9495250873ee45cbf6c2e2cc7b8caae47ad8f9";
        isLibrary = true;
        isExecutable = true;
        libraryHaskellDepends = [ base ];
@@ -51699,7 +51860,7 @@ self: {
      mkDerivation {
        pname = "flat-mcmc";
        version = "0.1.0.0";
-       sha256 = "1fp5jga82kbkj77xhy4m4vsn7zqf6fr9fwram3a2ybqssicgs3z5";
+       sha256 = "e50ffd58d41a2f2fd4a82a7397b2330eff63f5269578d8cf91734d81d493e5ba";
        libraryHaskellDepends = [
          base monad-par monad-par-extras mtl mwc-random primitive vector
        ];
@@ -51716,7 +51877,7 @@ self: {
      mkDerivation {
        pname = "flexible-defaults";
        version = "0.0.1.1";
-       sha256 = "0cbp8hb7y29xz3hl780173cs6ca4df0r98fz7v3drqr46aq55ipl";
+       sha256 = "f4c652b03224e3dcc63edfa194816b4431a3d93801a043e1f83d097f16447731";
        libraryHaskellDepends = [
          base containers template-haskell th-extras transformers
        ];
@@ -51730,7 +51891,7 @@ self: {
      mkDerivation {
        pname = "flexible-time";
        version = "0.1.0.3";
-       sha256 = "179k0r58r5s0g1vfs7ab382iq7qf5xbrnmvx2y8p86pz8fcz7a8l";
+       sha256 = "14a9f39943ff1a7491177d579b572f0e1f1c051a4b1ded767840978c4a06339d";
        libraryHaskellDepends = [ base bytestring unix-time ];
        jailbreak = true;
        homepage = "https://github.com/tattsun/flexible-time";
@@ -51743,7 +51904,7 @@ self: {
      mkDerivation {
        pname = "flexible-unlit";
        version = "0.2013.314.0";
-       sha256 = "0jwsa2qfzw4rdj55axy7cw1p82314i28c16f7p7pjp53cwnsp02a";
+       sha256 = "4a80ab2d67a35c79cf3dce048644246108740367c777558a6c99f0efb0509a4b";
        isLibrary = true;
        isExecutable = true;
        libraryHaskellDepends = [ base text ];
@@ -51757,7 +51918,7 @@ self: {
      mkDerivation {
        pname = "flexiwrap";
        version = "0.1.0";
-       sha256 = "0vvl9w3i374k720sscbcsbha89fcfk1hcvdr0nk4y7gkp13xwdba";
+       sha256 = "6a35de47b8f31d4fa605b96d06c374cc25a4e0d26c31ad8138939c11074f746f";
        libraryHaskellDepends = [ base data-type mtl QuickCheck ];
        jailbreak = true;
        description = "Flexible wrappers";
@@ -51770,7 +51931,7 @@ self: {
      mkDerivation {
        pname = "flexiwrap-smallcheck";
        version = "0.0.1";
-       sha256 = "1dara0az10fxx46jmplf2l6a6x8qqjk00fxjzb9n10ndd4lxcsm3";
+       sha256 = "a36ad62969cd8260d3fab23b00a6c41875a30c158ede2a0de9dd81f0155059b5";
        libraryHaskellDepends = [
          base data-type flexiwrap mtl smallcheck
        ];
@@ -51787,7 +51948,7 @@ self: {
      mkDerivation {
        pname = "flickr";
        version = "0.3.3";
-       sha256 = "12fi34zl2ggbxf5gmfldplzi1pk9byf8rpn58ljw2fvz3qb8x6yl";
+       sha256 = "d49b8e161e7f3bc12545c5de8c9c5f69de103fbd8dbafa8aebeb3d413f19d189";
        isLibrary = true;
        isExecutable = true;
        libraryHaskellDepends = [
@@ -51804,7 +51965,7 @@ self: {
      mkDerivation {
        pname = "flippers";
        version = "1.0.1";
-       sha256 = "1swyj1f67giq7h9xcl6dzsw4ywk1jbl6avpihbv0q9g9hp6yzqp3";
+       sha256 = "e3e2efcd85e9250cf682f16e65e89261724fb8fecd50d6133c38be635c909eeb";
        revision = "1";
        editedCabalFile = "e908ada5c891a6ac39cefb7e41648606d1a5f1b1048281f93bd496c5f22d73b4";
        libraryHaskellDepends = [ base ];
@@ -51817,7 +51978,7 @@ self: {
      mkDerivation {
        pname = "flite";
        version = "0.1.2";
-       sha256 = "0ck44icwg6gzi9x5h5iszk59qnr0fhsj95ghk0lxm8aygavwq44d";
+       sha256 = "8d10ccb77a5ea1da2998f095243574205b9ccafc3a16587a8aff99c759246432";
        isLibrary = true;
        isExecutable = true;
        libraryHaskellDepends = [ array base containers haskell98 parsec ];
@@ -51837,7 +51998,7 @@ self: {
      mkDerivation {
        pname = "flo";
        version = "0.1";
-       sha256 = "1hxzdgnsfxallmw7z07hs4ax8pfn57hk55kyjxg8vnrj7i07bp9l";
+       sha256 = "34dd75403c32db8d5e977e9632e129d65dd415d1f0807f78a55475a7ed6bbfc3";
        isLibrary = true;
        isExecutable = true;
        libraryHaskellDepends = [
@@ -51858,7 +52019,7 @@ self: {
      mkDerivation {
        pname = "float-binstring";
        version = "0.2";
-       sha256 = "0dcxk1s13ppslqxd378yh92pzmxnmnhk1q07wl5ifcnfy5zamzdq";
+       sha256 = "b8fdaa7ef1ce32170be507e030a1adb6d77f45821e9dd13aa6fade1174989d35";
        libraryHaskellDepends = [ attoparsec base split text ];
        testHaskellDepends = [
          attoparsec base hspec HUnit QuickCheck split text
@@ -51873,7 +52034,7 @@ self: {
      mkDerivation {
        pname = "floating-bits";
        version = "0.3.0.0";
-       sha256 = "1cp2k9rks0g8i6lf6j3zrz7wxh42qmsqwvf26dkdqnnzi0aqkkxj";
+       sha256 = "b2cf891588df5adc6633c26d8e75c582c0cecfcf7f48e3a889e8013d739ae2b2";
        libraryHaskellDepends = [ base ];
        testHaskellDepends = [ base ];
        description = "Conversions between floating and integral values";
@@ -51886,7 +52047,7 @@ self: {
      mkDerivation {
        pname = "floatshow";
        version = "0.2.4";
-       sha256 = "1zsxjwgm8nkphnmsbz03yvplc2r02qybb387n910j4j6vya98khc";
+       sha256 = "0c4e9494df46120942b2078db53c16200b46eff603fca5ab85775a541f975dff";
        libraryHaskellDepends = [ array base integer-gmp ];
        homepage = "https://bitbucket.org/dafis/floatshow";
        description = "Alternative faster String representations for Double and Float, String representations for more general numeric types";
@@ -51900,7 +52061,7 @@ self: {
      mkDerivation {
        pname = "flock";
        version = "0.3.1.8";
-       sha256 = "1g1gf7qnlqkl57h28nzxnbzj7v2h73czffp5y7s7jm9vbihcwd4n";
+       sha256 = "9634ce605c3b5579f4f1e53af7d93850ec23ffb2fd5b24e02974626af1712fbc";
        libraryHaskellDepends = [
          base lifted-base monad-control transformers unix
        ];
@@ -51914,7 +52075,7 @@ self: {
      mkDerivation {
        pname = "flow";
        version = "1.0.1";
-       sha256 = "11i0p2f8zxpcpssga279hx8vy6a14xykmb8qxyfrrpvd6qg42i8y";
+       sha256 = "1e45411e366ddf9c9def18ad3a7d274119bf5187e908f5b4beecf68f9cb82086";
        libraryHaskellDepends = [ base ];
        testHaskellDepends = [ base doctest QuickCheck template-haskell ];
        homepage = "http://taylor.fausak.me/flow/";
@@ -51929,7 +52090,7 @@ self: {
      mkDerivation {
        pname = "flow2dot";
        version = "0.9.0.3";
-       sha256 = "1pf60wpwsvxxgqkz3zh2qlcyz9pyd8axi41y5y6pn77n9x8p2613";
+       sha256 = "231871514ff61c7b8d2f3e90d8156afea6ef19c502fef1277ebd6fcd2f07c6dd";
        isLibrary = true;
        isExecutable = true;
        libraryHaskellDepends = [
@@ -51950,7 +52111,7 @@ self: {
      mkDerivation {
        pname = "flowdock";
        version = "0.3.0.1";
-       sha256 = "1az9wwdng7i3jrjwizzz3690506b3vk1m8h2b96wf59r51qnpr6i";
+       sha256 = "d1e46b71283915c74d5a02a21ae61ecb80029219ffffc86596239e671be7e9ab";
        libraryHaskellDepends = [
          aeson base base64-bytestring bytestring http-client http-client-tls
          lens lens-action mtl network pipes pipes-aeson pipes-http
@@ -51972,7 +52133,7 @@ self: {
      mkDerivation {
        pname = "flowdock-api";
        version = "0.1.0.0";
-       sha256 = "0p0b0pabyykvli9l0jrcbfgpyq7dna3zilb4z0s1hb6mamfdn7ng";
+       sha256 = "cf1edb5c55d52c1834f864d1f887b2ed607f9f5b2c4b4053a47b7abfd4050b5c";
        isLibrary = true;
        isExecutable = true;
        libraryHaskellDepends = [
@@ -52006,7 +52167,7 @@ self: {
      mkDerivation {
        pname = "flower";
        version = "0.7.2";
-       sha256 = "0r9l3b91kyhf4ab8m2qv5jsfqf3k7x639bq1wjbf852imzl6138b";
+       sha256 = "0b8d60e8af5114e496e401af344c3f7338ecb42c1b8b8a96220efa19d21a3465";
        isLibrary = false;
        isExecutable = true;
        executableHaskellDepends = [
@@ -52024,7 +52185,7 @@ self: {
      mkDerivation {
        pname = "flowlocks-framework";
        version = "0.1.3.1";
-       sha256 = "1v9z302fg2fx6k9k7ci5128gxrrcgdqp40r7axk0yhrzc06b9wa8";
+       sha256 = "48f1b40c603f430f6657270372717b2ce7fe900825b233d334dd89e704183fed";
        libraryHaskellDepends = [ base containers syb ];
        testHaskellDepends = [ base QuickCheck ];
        description = "Generalized Flow Locks Framework";
@@ -52039,7 +52200,7 @@ self: {
      mkDerivation {
        pname = "flowsim";
        version = "0.3.5";
-       sha256 = "0l3222a2r2khhrfhzvd0iikqq1rlcwhvf785bwnwqygq35i1w6j3";
+       sha256 = "431a1e6219f879cc2d5f051db7216734078c678ca0ed0f5d86708a2c94106250";
        isLibrary = false;
        isExecutable = true;
        executableHaskellDepends = [
@@ -52057,7 +52218,7 @@ self: {
      mkDerivation {
        pname = "fltkhs";
        version = "0.1.0.2";
-       sha256 = "11p957d12ivrf9r76zf2khjd736fdnhaj7qp0x6fbwmda2ifrij3";
+       sha256 = "43c6eca250adf2e54c07171fa9a06dce8cd3249cc27d737272794711da29e986";
        isLibrary = true;
        isExecutable = true;
        libraryHaskellDepends = [ base bytestring ];
@@ -52077,7 +52238,7 @@ self: {
      mkDerivation {
        pname = "fluent-logger";
        version = "0.2.3.1";
-       sha256 = "0m97hljfrs5mh5pjbwvnw7b581y7w96qfyjr3d9p1aqbj6nsa6dp";
+       sha256 = "b719a5ad910bab70531b597a874de2c70754d6e176f3256f81b5e8ec24852755";
        libraryHaskellDepends = [
          base bytestring cereal containers messagepack network
          network-socket-options random stm text time vector
@@ -52098,7 +52259,7 @@ self: {
      mkDerivation {
        pname = "fluent-logger-conduit";
        version = "0.3.0.0";
-       sha256 = "0z21dg1y0rqfgvpvgci5kp3jh0kdx5v5paxdidwp8dd6v7y3ag9q";
+       sha256 = "383d35fcd9a63574798badab5b76e96d0228c79d25b2b7ef7e0e67e0c36b417c";
        libraryHaskellDepends = [
          base bytestring conduit fluent-logger resourcet transformers
        ];
@@ -52113,7 +52274,7 @@ self: {
      mkDerivation {
        pname = "fluidsynth";
        version = "0.2.0.0";
-       sha256 = "18r7q7sh35sr71ays0c9ic6f7vmrblpw25mz1y5v9sbk5x2lh64s";
+       sha256 = "9a1848452f73e9b48b0fbf16c12f5db9eee30c8b8901ed5538599701f5c127a3";
        libraryHaskellDepends = [ base bindings-DSL containers directory ];
        librarySystemDepends = [ fluidsynth ];
        jailbreak = true;
@@ -52128,7 +52289,7 @@ self: {
      mkDerivation {
        pname = "fmark";
        version = "0.1.1";
-       sha256 = "1bjkkd90mw1nbm5pyjh52dwhqa6xx3i3hhl2ys3qpk08mrw5r09l";
+       sha256 = "34815c78ae08cc8b87f6824238e2e8dd280c7913054a7f4b5d36f00a529b53ae";
        isLibrary = false;
        isExecutable = true;
        executableHaskellDepends = [
@@ -52145,7 +52306,7 @@ self: {
      mkDerivation {
        pname = "fmlist";
        version = "0.9";
-       sha256 = "1gzwmsrbxk22v7syf8zfvxphm23dmjzfpysz6qww3qvib8wm64aq";
+       sha256 = "581153395a71e3c139365ffbebbeac6d880a6fdfee23e7f5d942ccbeb2aefcbf";
        libraryHaskellDepends = [ base ];
        homepage = "https://github.com/sjoerdvisscher/fmlist";
        description = "FoldMap lists";
@@ -52157,7 +52318,7 @@ self: {
      mkDerivation {
        pname = "focus";
        version = "0.1.4";
-       sha256 = "0h6q48ybcch1p15f4x56ya4d8mn4dwzbfjx573dy6z3x12v7qi2n";
+       sha256 = "56447cb6087d7ce3db38a54bb73e6fc456d488f2a674e24ab80132b63c22d840";
        libraryHaskellDepends = [ base ];
        homepage = "https://github.com/nikita-volkov/focus";
        description = "A general abstraction for manipulating elements of container data structures";
@@ -52169,7 +52330,7 @@ self: {
      mkDerivation {
        pname = "fold-debounce";
        version = "0.2.0.0";
-       sha256 = "1nq0729wy3v29liwhy5rp706cpspv9jygh0pvxf398ng2plgfjmb";
+       sha256 = "ab4af7e815cfa2345cdf17c0e765da575f66c0b9b978c8234d620fcf933800db";
        libraryHaskellDepends = [ base data-default stm stm-delay time ];
        testHaskellDepends = [ base hspec stm time ];
        homepage = "https://github.com/debug-ito/fold-debounce";
@@ -52184,7 +52345,7 @@ self: {
      mkDerivation {
        pname = "fold-debounce-conduit";
        version = "0.1.0.0";
-       sha256 = "0d5yw44zbkissnw7f0zssrr3f3m8ymkskizvjp6rhsiyx3iafj5k";
+       sha256 = "b348a7e2e83e6a98cd95fbc7a967f5a80e3772d6fa0377b8d53acef509e1be34";
        libraryHaskellDepends = [
          base conduit fold-debounce resourcet stm transformers
          transformers-base
@@ -52204,7 +52365,7 @@ self: {
      mkDerivation {
        pname = "foldl";
        version = "1.1.1";
-       sha256 = "01zqlb3hh5jsq49ax08nkwvysqq4fgkxpz4sdcman9y9fnxgwjgg";
+       sha256 = "ef49feba75c927ab2a6b9afcdbe7730463ed379f1681ae12c15a1608c7a2f807";
        libraryHaskellDepends = [
          base bytestring containers mwc-random primitive profunctors text
          transformers vector
@@ -52221,7 +52382,7 @@ self: {
      mkDerivation {
        pname = "foldl-incremental";
        version = "0.2.0.0";
-       sha256 = "09xf9cba3j49z4bwfmad6q9gdnp3f1zn817q4px7hky2gln3bhzk";
+       sha256 = "f3c3352c7dc24f78fa25f804647f70e3daf612364d55c717f989c8a1164bae27";
        libraryHaskellDepends = [
          base containers deepseq foldl histogram-fill vector
        ];
@@ -52244,7 +52405,7 @@ self: {
      mkDerivation {
        pname = "folds";
        version = "0.6.3";
-       sha256 = "1p8vr71vqzn0h4j5rz3wh7fsvsaaig52ds7sx8r2c8klbdf91zd4";
+       sha256 = "a4fd905c5b74222632eafae826ca8b4ae9addd817cfc5c2481c07ebcc3c91bdd";
        configureFlags = [ "-f-test-hlint" ];
        libraryHaskellDepends = [
          base comonad contravariant lens pointed profunctors reflection
@@ -52265,7 +52426,7 @@ self: {
      mkDerivation {
        pname = "folds-common";
        version = "0.2.0.0";
-       sha256 = "1dcyh798ijq4ms8xr0jwfp4fy5i5l4czl7m3yvk2z6rkha9w1zmc";
+       sha256 = "acfec09382339b2fe6f6a31efa19a12516efc8755c82dc91ae04cb88d2819eb5";
        libraryHaskellDepends = [ base containers folds ];
        testHaskellDepends = [ base containers tasty tasty-quickcheck ];
        description = "A playground of common folds for folds";
@@ -52280,7 +52441,7 @@ self: {
      mkDerivation {
        pname = "follower";
        version = "0.0.1";
-       sha256 = "0iy8q06fpc03n4z6dcrl95vji67dia6bp30q42rrlqw6s9cwigsm";
+       sha256 = "55bfc859d286639ab320188cbb8c8aed9828774934b3663eb103b0eb0cc0c847";
        isLibrary = false;
        isExecutable = true;
        executableHaskellDepends = [
@@ -52298,7 +52459,7 @@ self: {
      mkDerivation {
        pname = "foma";
        version = "0.1.1.0";
-       sha256 = "1aiy4bizzx5g87lvlx8xy24rxvzh093mlaavxkcr542fq9ki8yb3";
+       sha256 = "63791467c24e9092d9ec5b295a4702f0ef9e89f01d75bae941aff4ffe3223eaa";
        libraryHaskellDepends = [ base ];
        librarySystemDepends = [ foma ];
        homepage = "http://github.com/joom/foma.hs";
@@ -52312,7 +52473,7 @@ self: {
      mkDerivation {
        pname = "font-opengl-basic4x6";
        version = "0.0.3";
-       sha256 = "0myjb8g3mis887l0jmr88nb757x0zcvhnanx02hxjbfb5iqx3cx9";
+       sha256 = "a9b3d1712ccb2dd9a100dd2a0b37fba09f729645285709e84148c73a1e5ad257";
        isLibrary = true;
        isExecutable = true;
        libraryHaskellDepends = [ base OpenGL ];
@@ -52328,7 +52489,7 @@ self: {
      mkDerivation {
        pname = "foo";
        version = "1.0";
-       sha256 = "1f1abijdfvnmkgbvw9q94k4p39pbqslmg9am1j1sjyxrag5y0vv8";
+       sha256 = "686fe0cb53b97ba9830c55a557a9c6eba671c9240927bed79bd56ed7645c2ab8";
        isLibrary = false;
        isExecutable = true;
        executableHaskellDepends = [
@@ -52347,7 +52508,7 @@ self: {
      mkDerivation {
        pname = "for-free";
        version = "0.1";
-       sha256 = "048m95sg8jq7kpr55iq5h93c7zbaqp5v340phb13v9yw2hv50sql";
+       sha256 = "146b503614dca73dc2821790b1cbc56afdc3468205c752f29d074bf474491511";
        libraryHaskellDepends = [
          base comonad comonad-transformers containers contravariant
          transformers
@@ -52365,7 +52526,7 @@ self: {
      mkDerivation {
        pname = "forbidden-fruit";
        version = "0.1.0";
-       sha256 = "0sxaa2lpz6j0ljz8kjxifvp4lk5x12w0ka9wjws4w7r8q9bld8dd";
+       sha256 = "ada14657c2281f4e34973ca909b808bd4c4aee76b1cb89bea4409a7fa950aa6b";
        libraryHaskellDepends = [
          base control-monad-loop hashable hashtables primitive transformers
          transformers-base vector
@@ -52386,7 +52547,7 @@ self: {
      mkDerivation {
        pname = "force-layout";
        version = "0.4.0.2";
-       sha256 = "0lncciqizp55if5ivlcbv5lqj21hlp2vfi40iagjswf2apxi0w0g";
+       sha256 = "0f7010fb55c2712d9f8a8044b7c5a530088969d98bd11d8b8ba5dc1f7164cc52";
        libraryHaskellDepends = [
          base containers data-default-class lens linear
        ];
@@ -52399,7 +52560,7 @@ self: {
      mkDerivation {
        pname = "fordo";
        version = "0.1";
-       sha256 = "0vlh5rfn3n8vi3gbfmpbw20jgv5skvcw187walgv6dns39pagsar";
+       sha256 = "59e9a76e1ada36b31f55fca0c0d99ebaec2781e0eb56b7de881bd9615d2e906e";
        isLibrary = false;
        isExecutable = true;
        executableHaskellDepends = [ base process transformers ];
@@ -52413,7 +52574,7 @@ self: {
      mkDerivation {
        pname = "forecast-io";
        version = "0.2.0.0";
-       sha256 = "17wsqrq1zq1p80gnrfsvks5bhickfqj5mh2prbzzkzb3s28l1mby";
+       sha256 = "7ed54091d063fdf9ffca57c05a24769345b88a9e5bbb6c1f4037e01f70c69a9f";
        libraryHaskellDepends = [ aeson base text ];
        homepage = "https://github.com/stormont/forecast-io";
        description = "A Haskell library for working with forecast.io data.";
@@ -52425,7 +52586,7 @@ self: {
      mkDerivation {
        pname = "foreign-storable-asymmetric";
        version = "0.0.1";
-       sha256 = "1pj30p7z5nq8j95z9c4kjv6spandfch3r0dvx3n8wsbh3270dvxj";
+       sha256 = "b2ef068e1870698eece8bb813c2073cdaaabcd9693b0f44b9208dbf2cf0543de";
        libraryHaskellDepends = [ base ];
        description = "Types and instances for implementing a Storable with different peek and poke";
        license = stdenv.lib.licenses.bsd3;
@@ -52436,7 +52597,7 @@ self: {
      mkDerivation {
        pname = "foreign-store";
        version = "0.2";
-       sha256 = "1p436dn6l5zjzizcsj0hn10s2n907gr7c8y89i4sm3h69lhqlw86";
+       sha256 = "06718a214d068eaa494cc82376f23b2059a141b01048cd7efcf2176a6c3383dc";
        libraryHaskellDepends = [ base ];
        homepage = "https://github.com/chrisdone/foreign-store";
        description = "Store a stable pointer in a foreign context to be retrieved later";
@@ -52448,7 +52609,7 @@ self: {
      mkDerivation {
        pname = "foreign-var";
        version = "0.1";
-       sha256 = "1rxfmzq9npj1170i85qhq5fhvvzb9j1wdi5lzmj57k4hlyxcwqjd";
+       sha256 = "4d62cebaa790cc5364fdb4c4c6834cebef0d5dc1101714c109415e9bf0afaee7";
        revision = "1";
        editedCabalFile = "f9c906434533279cfa8e2897c6eed6ed9c279f373efc5180bda76b704601fa1c";
        libraryHaskellDepends = [ base stm transformers ];
@@ -52462,7 +52623,7 @@ self: {
      mkDerivation {
        pname = "forger";
        version = "0.0.0.0";
-       sha256 = "1bykssfas1fz46qmiwhxs09xnnwp104hlmq08z9g1xh7qv8bh7iy";
+       sha256 = "3e1eb8d0c607f6f0d24700570a0908975bdb13d01df258b121df05ad9cd6d3af";
        isLibrary = true;
        isExecutable = true;
        libraryHaskellDepends = [ base ];
@@ -52478,7 +52639,7 @@ self: {
      mkDerivation {
        pname = "forkable-monad";
        version = "0.1.1";
-       sha256 = "0nxcjx3cf8bkl0cwkpgz5c6byld13kw2601q4157fmfa370bi11h";
+       sha256 = "3084b8c019ca55774a20380023f81ca151bf0c2bffddc919a07321c74697ac5b";
        libraryHaskellDepends = [ base transformers ];
        jailbreak = true;
        homepage = "http://code.google.com/p/forkable-monad/";
@@ -52495,7 +52656,7 @@ self: {
      mkDerivation {
        pname = "formal";
        version = "0.1.0";
-       sha256 = "0z8a5a9w7mg69c1x6h8825bhkll63gz6j85lbc0w59w1ag2x8865";
+       sha256 = "c520d4c55381a7c2015bb42069fe1b86d20957110841d3034be6d5c3932a0a7d";
        isLibrary = false;
        isExecutable = true;
        executableHaskellDepends = [
@@ -52514,7 +52675,7 @@ self: {
      mkDerivation {
        pname = "format";
        version = "0.1.0.0";
-       sha256 = "1vv9b0hif5hi3jkd1n6j85b5mkfkjyixldblm2l4qfgrj95igmph";
+       sha256 = "f0d6174b92f9394ca8a87435daa397d3cd5a5641d2d8d0a61c111617215869ef";
        libraryHaskellDepends = [ haskell2010 parsec ];
        testHaskellDepends = [ haskell2010 parsec QuickCheck ];
        jailbreak = true;
@@ -52531,7 +52692,7 @@ self: {
      mkDerivation {
        pname = "format-status";
        version = "0.2.0.0";
-       sha256 = "0dfmjp307c8685cdw41nmjmisf3aplyf177r973wyqcrifabvs2q";
+       sha256 = "58e8bd948b9961cfc749f99ce03cbd6a381dabac3610de584106b103c695d535";
        isLibrary = false;
        isExecutable = true;
        executableHaskellDepends = [
@@ -52551,7 +52712,7 @@ self: {
      mkDerivation {
        pname = "formattable";
        version = "0.1.1";
-       sha256 = "0brp1j21ll6g266zyzknqc20k5nf3na97fjbh66hjbsw6yxah5x7";
+       sha256 = "a717a8ba375c2f098d814bba93941dce960904c3767eff8d11cf501a840c372f";
        libraryHaskellDepends = [
          base bytestring data-default-class old-locale text time
        ];
@@ -52571,7 +52732,7 @@ self: {
      mkDerivation {
        pname = "formatting";
        version = "6.2.2";
-       sha256 = "04ilp8zkzkab3x4v5kczpa58k5jr67yg9fq4prj7xrj81kixgp2g";
+       sha256 = "4fdcd7e30c48e67e64be04bbf4fc315996898aba9fcdb2491f4bcd3f3fba3412";
        libraryHaskellDepends = [
          base clock old-locale scientific text text-format time
        ];
@@ -52589,7 +52750,7 @@ self: {
      mkDerivation {
        pname = "forml";
        version = "0.2";
-       sha256 = "1bqfw3h06mbznivg37840qnzjygflzp90wkyssnb1kjxi4bj1vbv";
+       sha256 = "7bed2017895dceb0acd67e7290eea7ee79f92d06049df176b47f5503e0e00eaf";
        isLibrary = false;
        isExecutable = true;
        executableHaskellDepends = [
@@ -52612,7 +52773,7 @@ self: {
      mkDerivation {
        pname = "formlets";
        version = "0.8";
-       sha256 = "0jx56vhrzcwca33rgp738plmssw95nv20rrzw5xrxcmdv26zp1w9";
+       sha256 = "8987fb8dd8adb29e7be13f6720b62d896b5de945e3dc97c7508cb39fe136a54b";
        libraryHaskellDepends = [
          applicative-extras base blaze-html bytestring haskell98 syb
          transformers xhtml
@@ -52631,7 +52792,7 @@ self: {
      mkDerivation {
        pname = "formlets-hsp";
        version = "2.3.1";
-       sha256 = "19m0nryrksh1cgsz7sx3gamjczw36hqfsbml05p6j7li3bk0fpw2";
+       sha256 = "825f07e61a911e696e01b42eed3034837f26ab7aa3ebf3f56301ea997db6a0a6";
        libraryHaskellDepends = [
          applicative-extras base formlets haskell98 hsp hsx mtl
        ];
@@ -52646,7 +52807,7 @@ self: {
      mkDerivation {
        pname = "forth-hll";
        version = "0.1.0.0";
-       sha256 = "1hmcicxnxcl99chidkbg1kspjzpxxcw8qh4lrwvmlpz2knzf11g3";
+       sha256 = "e385e0be9de25f5a37cf94408c38ebfd7e79f50c6fcd16214b89b26e3b8bacc2";
        libraryHaskellDepends = [ array-forth base free mtl ];
        jailbreak = true;
        description = "A simple eDSL for generating arrayForth code";
@@ -52659,7 +52820,7 @@ self: {
      mkDerivation {
        pname = "fountain";
        version = "0.1";
-       sha256 = "0mxzrvrag2qwn22llklmdkcf4icd8n9ifg1awd9q7ffll8a1a67p";
+       sha256 = "f7181514a2d4b98353e32a3c1793458d45e2d86c954e4a85b01c8ba7f2cebf57";
        libraryHaskellDepends = [ base containers random ];
        homepage = "http://tomahawkins.org";
        description = "A fountain codec";
@@ -52681,7 +52842,7 @@ self: {
      mkDerivation {
        pname = "fpco-api";
        version = "1.2.0.5";
-       sha256 = "1r80a6vimpy4nviskl62c4ivp2l8wrg3vhzgdg53nnfa5j6lmha2";
+       sha256 = "42c14a8d2cca593bca6befc33d5ee6888abb2361c2d0a9e3b6c4df1ab75100e5";
        isLibrary = true;
        isExecutable = true;
        libraryHaskellDepends = [
@@ -52709,7 +52870,7 @@ self: {
      mkDerivation {
        pname = "fpipe";
        version = "0.0.1";
-       sha256 = "1b6r19yy9wh5w8xb0ajjxsd2qyzjnkgyav1975qv92wwxslyxwr8";
+       sha256 = "28f3eea9ee9c8bb47139296ce5dfb4f27b2c9aee522ab03ae205f2e47d0ad9ac";
        libraryHaskellDepends = [ base ];
        description = "F#-style composition and application";
        license = stdenv.lib.licenses.bsd3;
@@ -52720,7 +52881,7 @@ self: {
      mkDerivation {
        pname = "fpnla";
        version = "0.1.1";
-       sha256 = "15qpfi3b9vnpm17q3y64nsrhlj5vi9rgrgysjfk98aw1gkj9mvv4";
+       sha256 = "64ef9ae47c812b94a693dabffc728abb480ab3b6c4f8814fa8d7eeb446741797";
        libraryHaskellDepends = [ base ];
        description = "A library for NLA operations";
        license = stdenv.lib.licenses.bsd3;
@@ -52735,7 +52896,7 @@ self: {
      mkDerivation {
        pname = "fpnla-examples";
        version = "0.1.1";
-       sha256 = "1p305r0jgcqrbny22ic1ziyav9yjy6v02wgna0sgh4p0c1wi7pb2";
+       sha256 = "62dd137960e012f83450f67101b6f1d2a7ad7cfc814521bc5d19b327412e60dc";
        libraryHaskellDepends = [
          accelerate array base deepseq fpnla hmatrix linear-algebra-cblas
          monad-par parallel repa vector
@@ -52759,7 +52920,7 @@ self: {
      mkDerivation {
        pname = "fptest";
        version = "0.2.2.0";
-       sha256 = "1wqca640h9qcrnwkqdw1pyl73c4nraglgwqgimkrgbkjlwpyn824";
+       sha256 = "4420eb2fa772ae97678d0ff3479fca96b071a8bf81373cb9cd0c270888510cf3";
        isLibrary = false;
        isExecutable = true;
        executableHaskellDepends = [
@@ -52784,7 +52945,7 @@ self: {
      mkDerivation {
        pname = "fquery";
        version = "0.2.1.5";
-       sha256 = "1v1qrbr5kz17haawrh0ksmjw7j4ks0x4kqzss5z1fbldl6axw97i";
+       sha256 = "f124de95a18d2e177ed1fae3493ad093c8c365d513c0cc958227fc59f2ca38ec";
        isLibrary = false;
        isExecutable = true;
        executableHaskellDepends = [
@@ -52800,7 +52961,7 @@ self: {
      mkDerivation {
        pname = "fractal";
        version = "0.0.1";
-       sha256 = "0iw5454mi0ms3w62m118rlqr6lr1j9mbxwfj26mlc5p38bq9k7ds";
+       sha256 = "ba9d99f042e31646ab11d2f1be6a9221539331cd28842a0c1fba825849218547";
        isLibrary = false;
        isExecutable = true;
        executableHaskellDepends = [ base ];
@@ -52808,12 +52969,24 @@ self: {
        license = stdenv.lib.licenses.bsd3;
      }) {};
 
+  "fractals" = callPackage
+    ({ mkDerivation, base, integer-gmp, QuickCheck }:
+     mkDerivation {
+       pname = "fractals";
+       version = "0.1.0.0";
+       sha256 = "3dbca177023352014cb5c61205a9a90a640a75a0557935126800e25f38f2424a";
+       libraryHaskellDepends = [ base ];
+       testHaskellDepends = [ base integer-gmp QuickCheck ];
+       description = "A collection of useful fractal curve encoders";
+       license = stdenv.lib.licenses.bsd3;
+     }) {};
+
   "fraction" = callPackage
     ({ mkDerivation, base, semigroups }:
      mkDerivation {
        pname = "fraction";
        version = "0.1.0.4";
-       sha256 = "0blvvsc1rbn45nwgmkhd28bdz0awi5mk6h48yqbqy3ajm2gvpvdf";
+       sha256 = "aeedbb9fa8520d8f17f68840336b895c81df16120dcefab82dc4ae1c98de9b2e";
        libraryHaskellDepends = [ base semigroups ];
        homepage = "http://darcs.wolfgang.jeltsch.info/haskell/fraction";
        description = "Fractions";
@@ -52825,7 +52998,7 @@ self: {
      mkDerivation {
        pname = "frag";
        version = "1.1.2";
-       sha256 = "1xgnp4cls8i61hyl4kcf3afri77jlcahwjvww498xl5d5frdiv90";
+       sha256 = "20edd8b22badd08e12e17c4b0e15a3f29c989d1a8e4d423d0c26224d19b9f6f5";
        isLibrary = false;
        isExecutable = true;
        executableHaskellDepends = [ array base GLUT OpenGL random ];
@@ -52844,7 +53017,7 @@ self: {
      mkDerivation {
        pname = "frame";
        version = "0.1";
-       sha256 = "0ldncqifcnk4d50qivgw62hcdy4nc23zr64q787azid0vb9vsdja";
+       sha256 = "4a36bdd3daa0c5af0e3a9898fc876096f8c6a030fced884169645ae62266b651";
        isLibrary = true;
        isExecutable = true;
        libraryHaskellDepends = [
@@ -52865,7 +53038,7 @@ self: {
      mkDerivation {
        pname = "frame-markdown";
        version = "0.1";
-       sha256 = "0wy1c9xgd6ykymqciga1sla83wfdwy17p88bygfp6pflbc0rw57g";
+       sha256 = "ef149e015bd45d73ddf30ba17b82e7cdf18114d541bdc870f5d39bf67a62c173";
        libraryHaskellDepends = [ base frame pandoc ];
        jailbreak = true;
        description = "A markdown to Frame GUI writer for Pandoc";
@@ -52877,7 +53050,7 @@ self: {
      mkDerivation {
        pname = "franchise";
        version = "0.0.6";
-       sha256 = "144fywp5fcix5i06wvwvzwsr19bgxpajx7bi7jw43hnm3rlcj4vr";
+       sha256 = "7913c9681ed5c241b83c719d2ed5ed6fa59035ff9b6f6e402c3d32572ef78e90";
        libraryHaskellDepends = [ base ];
        description = "A package for configuring and building Haskell software";
        license = stdenv.lib.licenses.bsd3;
@@ -52892,7 +53065,7 @@ self: {
      mkDerivation {
        pname = "free";
        version = "4.12.1";
-       sha256 = "0sr8phvrb4ny8j1wzq55rdn8q4br23q4pw2j276npr844825jr9p";
+       sha256 = "376559042204e56bcd1152f04bf01079118c6ccba5e0cf8344de929537bc286b";
        libraryHaskellDepends = [
          base bifunctors comonad distributive exceptions mtl prelude-extras
          profunctors semigroupoids semigroups template-haskell transformers
@@ -52909,7 +53082,7 @@ self: {
      mkDerivation {
        pname = "free-functors";
        version = "0.6.4.1";
-       sha256 = "1mc5y29j4khl222dwb9xcnfmn2jh3v47rkvkzwvlgrbg5bh81kzk";
+       sha256 = "f3cf80e02a6fe54737ff73cf7cc81e500a5b9d653d2dde8410144e2293f085d5";
        libraryHaskellDepends = [
          algebraic-classes base comonad constraints template-haskell
          transformers void
@@ -52929,7 +53102,7 @@ self: {
      mkDerivation {
        pname = "free-game";
        version = "1.1.81";
-       sha256 = "1z8l9k70rbcc9jbrnh7xhrnny6wd5l0jfb1a6ki7dnq6m5klivyp";
+       sha256 = "d7ef4867a906db76e2342a2c27012d8d1b6f6d86fd409b974c8cad0cce4c14fd";
        libraryHaskellDepends = [
          array base boundingboxes colors containers control-bool directory
          filepath free freetype2 GLFW-b hashable JuicyPixels
@@ -52950,7 +53123,7 @@ self: {
      mkDerivation {
        pname = "free-http";
        version = "0.1.1.3";
-       sha256 = "1gmafmi0mrmbm7a08cxiz96s43k4sc38wvzrnmcrqcl44a1n38fm";
+       sha256 = "d5a161832284329c59b5f96f8e06d3640ea24dfab13304d4a9abe60a6275aabe";
        libraryHaskellDepends = [
          base bytestring free http-client http-types mtl QuickCheck text
          time transformers
@@ -52967,7 +53140,7 @@ self: {
      mkDerivation {
        pname = "free-operational";
        version = "0.5.0.0";
-       sha256 = "0gim4m0l76sxxg6a8av1gl6qjpwxwdzyviij86d06v1150r08dmb";
+       sha256 = "ab36043228216c039a4132c6ed7fe39d5f890d7d612ba4cceb5d9b434125353e";
        libraryHaskellDepends = [
          base comonad-transformers free kan-extensions mtl transformers
        ];
@@ -52984,7 +53157,7 @@ self: {
      mkDerivation {
        pname = "free-theorems";
        version = "0.3.2.0";
-       sha256 = "1r0qz8h8fjb9akkhd3impr30gd0s5ky51dj667x0pf155b4lvx2w";
+       sha256 = "5cf44dc92a25b80bfa3146b650fc2c1ab40746be358e06e75469498720fa18e4";
        libraryHaskellDepends = [
          base containers haskell-src haskell-src-exts mtl pretty syb
        ];
@@ -53000,7 +53173,7 @@ self: {
      mkDerivation {
        pname = "free-theorems-counterexamples";
        version = "0.3.1.0";
-       sha256 = "1wq5lvnylw92qzv1q93liz4i3q2j8sbgwgaw8nw79q0x0cdvbbb3";
+       sha256 = "63adb51b031de074b8455c3dfe964652e011c98f74241cf6c72271eaeda605f3";
        isLibrary = true;
        isExecutable = true;
        libraryHaskellDepends = [
@@ -53020,7 +53193,7 @@ self: {
      mkDerivation {
        pname = "free-theorems-seq";
        version = "1.0";
-       sha256 = "1scqjv6hc2y0w1x9f8v8bwrl1dnz64hf5jgrdam12dxbsk6qjs6g";
+       sha256 = "cf6889cdd4ab3711aa6af9c9e22031dfb640335f6823977ae0c00b06cd9698e9";
        libraryHaskellDepends = [
          array base bytestring containers free-theorems haskell-src mtl
          old-locale old-time parsec pretty syb utf8-string xhtml
@@ -53038,7 +53211,7 @@ self: {
      mkDerivation {
        pname = "free-theorems-seq-webui";
        version = "1.0.0.2";
-       sha256 = "1bx7fg1ddycl9pgrlh2qij5vb6fqx79gl6lbm248c95xyygi3iy5";
+       sha256 = "c5c7119ff7bd248688a88b1afad2e9d899b58b8c58409adf4d94f9d6c273a7af";
        isLibrary = false;
        isExecutable = true;
        executableHaskellDepends = [
@@ -53057,7 +53230,7 @@ self: {
      mkDerivation {
        pname = "free-theorems-webui";
        version = "0.2.1.1";
-       sha256 = "1qxdfbzr52dw0qww03l86vpgmylznifqzvjarmgpkfr129szl7ba";
+       sha256 = "6a1dfa751221bb795fcd4aee8f5db49ffafaee36880ec03906bc8992ff72ade3";
        isLibrary = false;
        isExecutable = true;
        executableHaskellDepends = [
@@ -53077,7 +53250,7 @@ self: {
      mkDerivation {
        pname = "freekick2";
        version = "0.1.2";
-       sha256 = "1ybmffs05hgzn81szcd8nrz4f94qc64d9y2d2hkyq57djb87503j";
+       sha256 = "728072d092ed14ec27144df8d488619824477eb6a8b1af03b2ffc102b47375f9";
        isLibrary = false;
        isExecutable = true;
        executableHaskellDepends = [
@@ -53096,7 +53269,7 @@ self: {
      mkDerivation {
        pname = "freenect";
        version = "1.2";
-       sha256 = "11ggp90npdyfdmf8zhjk442zl0j0lni6hizhgc0409za9i6s1l5g";
+       sha256 = "afd0a04d4cea2740007bf04768a2a54002fa052153c28f5c6dceb76b41baef85";
        libraryHaskellDepends = [ base vector ];
        librarySystemDepends = [ freenect freenect_sync ];
        homepage = "https://github.com/chrisdone/freenect";
@@ -53112,7 +53285,7 @@ self: {
      mkDerivation {
        pname = "freesect";
        version = "0.8";
-       sha256 = "150ch1xmx3slmq7hb74z8sjrqhrsc9kl1zjn030fj6k6kphrwd88";
+       sha256 = "08359ee19d661ae9c00056fe4067623a439ca5469f9c050fae548f5e7b800c94";
        isLibrary = false;
        isExecutable = true;
        executableHaskellDepends = [
@@ -53132,7 +53305,7 @@ self: {
      mkDerivation {
        pname = "freesound";
        version = "0.1.0";
-       sha256 = "0a34qc62sjc355qfr3qz92nh27gmcyqk2jlhq77pjfdzv0ivigcy";
+       sha256 = "9ebdb823d8bf3979cfc1904a31b167f51d01ad481f8fec702983492d0cc36428";
        isLibrary = true;
        isExecutable = true;
        libraryHaskellDepends = [
@@ -53151,7 +53324,7 @@ self: {
      mkDerivation {
        pname = "freetype-simple";
        version = "0.1.0.1";
-       sha256 = "1qhiy896a10af9fnzcp4y0ra1c9l6fbcclrr3k74pn2qvvfybnss";
+       sha256 = "5adbe5ddde58d84bce1c3953c6963334b1a032f0e4b26f5d720a046512f211e2";
        libraryHaskellDepends = [
          base boundingboxes bytestring freetype2 linear
        ];
@@ -53166,7 +53339,7 @@ self: {
      mkDerivation {
        pname = "freetype2";
        version = "0.1.1";
-       sha256 = "16ayyqvbl278z68ssfbv2nvbyxs7585zmnk2w53vlxvj0k9zj66s";
+       sha256 = "da18f9d3047277ba47e162dafa0b2a4777bfb6157b39ad91f9e808ba36f65e99";
        isLibrary = true;
        isExecutable = true;
        libraryHaskellDepends = [ base ];
@@ -53179,7 +53352,7 @@ self: {
      mkDerivation {
        pname = "fresh";
        version = "0.1.1";
-       sha256 = "1441yv55bwmiwnr6jsccq91anq8vhc2a4ka0irn3i2i9cjzw0gkw";
+       sha256 = "7c3ec0bf64298a386c8e404da204831b61ab42c28c6969b2e5b1f255caf68190";
        libraryHaskellDepends = [ base containers haskell-src-exts syb ];
        homepage = "https://github.com/davidlazar/fresh";
        description = "Introduce fresh variables into Haskell source code";
@@ -53194,7 +53367,7 @@ self: {
      mkDerivation {
        pname = "friday";
        version = "0.2.2.0";
-       sha256 = "0cw8mghygbd76l2nf0s1n0n1a7ymh2hv4dfm11hkv0gcdrqrp9fr";
+       sha256 = "d9a59b716eec813d6108d535b2a180d51f152cb04103670535a7ade7e1ab8833";
        libraryHaskellDepends = [
          base convertible deepseq primitive ratio-int transformers vector
        ];
@@ -53213,7 +53386,7 @@ self: {
      mkDerivation {
        pname = "friday-devil";
        version = "0.1.1.1";
-       sha256 = "19g1h7palsaycv81fks9zbq979jdn7fqapxd6igxhkgzw73n69aj";
+       sha256 = "522563c7e1ff4dd85f34ad5f85ddb14da693f0fa494f17d0665e69aaee81e1a5";
        libraryHaskellDepends = [
          base bytestring convertible deepseq friday transformers vector
        ];
@@ -53228,7 +53401,7 @@ self: {
      mkDerivation {
        pname = "friendly-time";
        version = "0.4";
-       sha256 = "1x73jk9smga912nfyxa77j6yz74kyx8zdr4q6xj3sirp46qm5nh5";
+       sha256 = "05da52b12137473d643798e4f651f7939cef8d3c4775efac0849bdaad394e3f4";
        libraryHaskellDepends = [ base old-locale time ];
        testHaskellDepends = [ base hspec old-locale time ];
        description = "Print time information in friendly ways";
@@ -53240,7 +53413,7 @@ self: {
      mkDerivation {
        pname = "frisby";
        version = "0.2";
-       sha256 = "0isj9p7j33va1a4q78vnq32j9jdbjww596rxja235z4whicraf53";
+       sha256 = "a3389559849cfc3284923d9b543897abc924c5c076a383890a6a8f21cf4d5247";
        libraryHaskellDepends = [ array base containers mtl ];
        homepage = "http://repetae.net/computer/frisby/";
        description = "Linear time composable parser for PEG grammars";
@@ -53252,7 +53425,7 @@ self: {
      mkDerivation {
        pname = "frp-arduino";
        version = "0.1.0.3";
-       sha256 = "00659x5f5dq4lb25ss880cqggqc63i7wqik04qvzk1kq3dl9six5";
+       sha256 = "a5479d681b7886f937266046cc4f1c86e1f7300308695dc4a204b7e24a4fc500";
        libraryHaskellDepends = [ base containers mtl ];
        homepage = "http://github.com/frp-arduino/frp-arduino";
        description = "Arduino programming without the hassle of C";
@@ -53265,7 +53438,7 @@ self: {
      mkDerivation {
        pname = "frpnow";
        version = "0.13";
-       sha256 = "13dvyf1zwzvcpal7zp1jx5ns49a01jsjn3pz0iqdrph7qgll2aqr";
+       sha256 = "192b41e9c307dedc7004ff0e2bb50c4025a26de932dc7fa8ba6c7ffe83f3bb8d";
        libraryHaskellDepends = [ base containers mtl transformers ];
        homepage = "https://github.com/atzeus/FRPNow";
        description = "Principled practical FRP";
@@ -53278,7 +53451,7 @@ self: {
      mkDerivation {
        pname = "frpnow-gloss";
        version = "0.12";
-       sha256 = "1xywqcif16r3x4qckz3n6k5mp2pya4vj35h0jrh4rd1sspnhi99i";
+       sha256 = "31a508edd53ab44c60960096213751fe8a5bcb3476fcc930e9239be022c3dcf7";
        libraryHaskellDepends = [
          base containers frpnow gloss mtl transformers
        ];
@@ -53294,7 +53467,7 @@ self: {
      mkDerivation {
        pname = "frpnow-gtk";
        version = "0.11";
-       sha256 = "0yq9pgjlmzg5pzcky7z7n2ks82x92dp5pjacr6h3w8mdrhhhk80c";
+       sha256 = "0ca00921ccad223ea0c94cc95b6e13a90ba4a7b0e71f3fd9bfe5fd4ae5bb097b";
        libraryHaskellDepends = [
          base containers frpnow glib gtk mtl transformers
        ];
@@ -53308,7 +53481,7 @@ self: {
      mkDerivation {
        pname = "frquotes";
        version = "0.2.1";
-       sha256 = "0s5cb0m6xgf9zfch75nzk9b8lvghl4nc5dk35xkakq6ys3zizw6c";
+       sha256 = "ccf01fffd0dee0a9662f63b6c22ca1f06d8a569adf960399fbc9bd6e2a58ac68";
        isLibrary = true;
        isExecutable = true;
        libraryHaskellDepends = [ base ];
@@ -53322,7 +53495,7 @@ self: {
      mkDerivation {
        pname = "fs-events";
        version = "0.1";
-       sha256 = "0jw6cx9fzzs8r20acjq8nq8zjhwiwnvg1b0kc97c2sij1bhw6pw4";
+       sha256 = "845fc3e10a326ac14e6213acf0b6e59143f911b6084ba680c848ffef5267864b";
        libraryHaskellDepends = [ base ];
        homepage = "http://github.com/nkpart/fs-events";
        description = "A haskell binding to the FSEvents API";
@@ -53335,7 +53508,7 @@ self: {
      mkDerivation {
        pname = "fsharp";
        version = "0.0.4";
-       sha256 = "1scmvhbsn988x6j4a94ibg1c7adrxf8lzn06n9n1iv62bjd450m3";
+       sha256 = "a382429a5cc2ec186cb206d84f91ebb9a9c3c25b912445a4e90825ab17dc95e9";
        libraryHaskellDepends = [ base ];
        description = "some F# operators, high priority pipes";
        license = stdenv.lib.licenses.bsd3;
@@ -53348,7 +53521,7 @@ self: {
      mkDerivation {
        pname = "fsmActions";
        version = "0.4.4";
-       sha256 = "05713wj1s1307brqkbnapqi42dva55kcjgb8n3x6yirpfp6lhdsc";
+       sha256 = "4c3748cd7537476ffab0683dc966296a374122becaae89f33a60041d241fe114";
        libraryHaskellDepends = [
          base containers fgl filepath graphviz MissingH mtl parsec pretty
        ];
@@ -53366,7 +53539,7 @@ self: {
      mkDerivation {
        pname = "fsnotify";
        version = "0.2.1";
-       sha256 = "0asl313a52qx2w6dw25g845683xsl840bwjh118nkwi5v1xipkzb";
+       sha256 = "ebcf1b7bd825f269510850f20508a2ba0f640a41af08de0c171d8ba24618542b";
        libraryHaskellDepends = [
          async base containers directory filepath hinotify text time
          unix-compat
@@ -53387,7 +53560,7 @@ self: {
      mkDerivation {
        pname = "fst";
        version = "0.10.0.1";
-       sha256 = "190a89445fv006m5nv8g58h569rpw9s8jadqdy6m3ik43mnggzpy";
+       sha256 = "fefef76c1d64c6518d6fb8298974e2372753202a0f6d5baa0160bb4248420aa4";
        isLibrary = true;
        isExecutable = true;
        libraryHaskellDepends = [ array base mtl ];
@@ -53405,7 +53578,7 @@ self: {
      mkDerivation {
        pname = "fsutils";
        version = "0.1.2";
-       sha256 = "07lx4928d1fnjbpfmky4jhhk7sqj98b11vdbv4f67p3bwfn5lrp8";
+       sha256 = "e8665aace36bdc631cd9abed10164a12eb332194c4cfeaee92d6858644229d1e";
        libraryHaskellDepends = [ base directory filepath ];
        jailbreak = true;
        homepage = "https://github.com/Raynes/fsutils";
@@ -53420,7 +53593,7 @@ self: {
      mkDerivation {
        pname = "fswatcher";
        version = "0.1.2";
-       sha256 = "1b6pm3jfyi5lbrpjv8n6z970xs11h61hj1g5ph54fhsqd2wvmpc2";
+       sha256 = "82ddbab9685843470abce50509838121e80e4efac6a22d6f5eb444efe4a8d7ac";
        isLibrary = false;
        isExecutable = true;
        executableHaskellDepends = [
@@ -53439,7 +53612,7 @@ self: {
      mkDerivation {
        pname = "ftdi";
        version = "0.2.0.1";
-       sha256 = "1gnfbngn3jwva6nvrcrzmi2n2vy4k55yh41zvg0kyb61w7kgm4m8";
+       sha256 = "a892fae6e1c12c3fc1db3f10e84b99c46f6145ac3fb3bcad519bcb619f5dcebe";
        isLibrary = true;
        isExecutable = true;
        libraryHaskellDepends = [
@@ -53458,7 +53631,7 @@ self: {
      mkDerivation {
        pname = "ftp-conduit";
        version = "0.0.5";
-       sha256 = "0gb65g46nr9haysy3dbrylka08fsz81yn7aiwwingc6wlp7d76dg";
+       sha256 = "af99d3cea5dcb06723e7511deb03fada21a026f579b5e1b55730656bc82b663d";
        libraryHaskellDepends = [
          base byteorder bytestring conduit MissingH network transformers
          utf8-string
@@ -53477,7 +53650,7 @@ self: {
      mkDerivation {
        pname = "ftphs";
        version = "1.0.9.1";
-       sha256 = "1whvawaifhi5xgmiagdayjf7m6p6vs71mvc4a4csd4vzzjr0a2yf";
+       sha256 = "ce0b05b2fc7f93a6195184ed1a8edee69a7a9cf4aa3d15ebeb25421715571bf2";
        isLibrary = true;
        isExecutable = true;
        libraryHaskellDepends = [
@@ -53493,7 +53666,7 @@ self: {
      mkDerivation {
        pname = "ftree";
        version = "0.1.3";
-       sha256 = "1ma87jnwsgzlr7z6ac303i0qy9i2lywvjgb2zjv9qgnbkf18pg3m";
+       sha256 = "75bc8b829bcb3e9cb6fc623db9b9a722268f411c603065fec9f43fcdad3c48d5";
        libraryHaskellDepends = [ base ShowF type-unary ];
        homepage = "https://github.com/conal/ftree/";
        description = "Depth-typed functor-based trees, both top-down and bottom-up";
@@ -53507,7 +53680,7 @@ self: {
      mkDerivation {
        pname = "ftshell";
        version = "0.3.0.1";
-       sha256 = "1jrpb6dzq47xy6xvsisc7g1y53dc97s4l826f9sscxpdsrx3yp8r";
+       sha256 = "195d3f7ad6ed76a6757246204af449ac8de2c33b4c47bdbbf1fd10fc9b5937cb";
        isLibrary = false;
        isExecutable = true;
        executableHaskellDepends = [
@@ -53524,7 +53697,7 @@ self: {
      mkDerivation {
        pname = "fugue";
        version = "0.1";
-       sha256 = "0g0qy0lcixbjm5srmfl1dnci4m09zwqcs5dpknpnsdc4b4l3925r";
+       sha256 = "b98834285984356daf9db715cd30ff095412996d81ba9a75a972f5c828f0183c";
        libraryHaskellDepends = [ base ];
        description = "A recapitulated prelude with minimal dependencies and profligate exports";
        license = stdenv.lib.licenses.bsd3;
@@ -53535,7 +53708,7 @@ self: {
      mkDerivation {
        pname = "full-sessions";
        version = "0.6.2.1";
-       sha256 = "0irm1zrggjl9zrapzxfl3kj32d81k30c8nbmr3bf9ramjg65xm90";
+       sha256 = "20d55ecc9355e5e4d6c87559c4c098013531e41cd4f57f55fe89caf7f20f3547";
        libraryHaskellDepends = [ base ghc network ];
        homepage = "http://www.agusa.i.is.nagoya-u.ac.jp/person/sydney/full-sessions.html";
        description = "a monad for protocol-typed network programming";
@@ -53550,7 +53723,7 @@ self: {
      mkDerivation {
        pname = "full-text-search";
        version = "0.2.1.3";
-       sha256 = "0s537hzb21w506bp4i6v7k5sbk905s9950gihh99r0b7id185ppk";
+       sha256 = "f3de82428b67819c1284f18192922e20cda5cb3cdb447297018507b13e3ca368";
        isLibrary = true;
        isExecutable = true;
        libraryHaskellDepends = [ array base containers text vector ];
@@ -53570,7 +53743,7 @@ self: {
      mkDerivation {
        pname = "fullstop";
        version = "0.1.4";
-       sha256 = "10452kdl98igk2y48bb2ligj8nk7gpjcsf0nsiifvpjbfxv4gakc";
+       sha256 = "6caa4776774bdeed62d41638cde47d675a245fa4622d44bc982fa244db148580";
        isLibrary = true;
        isExecutable = true;
        libraryHaskellDepends = [ base split ];
@@ -53589,7 +53762,7 @@ self: {
      mkDerivation {
        pname = "funcmp";
        version = "1.8";
-       sha256 = "09kmfgl15d71fr5h66j2b0ngw69y8dp41d55lz35nrjxq3l3gz1k";
+       sha256 = "33fc37e8c05d665bc6a7a5b4406e433e19fe2c58421a034b76e1b412e8737526";
        libraryHaskellDepends = [ base filepath process ];
        homepage = "http://savannah.nongnu.org/projects/funcmp/";
        description = "Functional MetaPost";
@@ -53601,7 +53774,7 @@ self: {
      mkDerivation {
        pname = "function-combine";
        version = "0.1.0";
-       sha256 = "1m8bmqxb9kar3y8zv22qs2a6kzd636m5li1r2q4y6pps0nglv9i9";
+       sha256 = "29a64d9f05fa5ee3091639445aaa19a6fd6994d05888fd911f59cdb43aae0bd5";
        libraryHaskellDepends = [ base data-type ];
        description = "Combining functions";
        license = stdenv.lib.licenses.bsd3;
@@ -53613,7 +53786,7 @@ self: {
      mkDerivation {
        pname = "function-instances-algebra";
        version = "0.1";
-       sha256 = "0dxym6xrylngw8r5spi246nmi8fvvxxx776qismcr04zqshv7ygw";
+       sha256 = "fcf9b3a1c69f80ccaa8ed89cd37bdfdba158ad21225e5d32e2cf529fbba9be37";
        libraryHaskellDepends = [ base numeric-prelude ];
        jailbreak = true;
        homepage = "github.com/kreuzschlitzschraubenzieher/function-instances-algebra";
@@ -53626,7 +53799,7 @@ self: {
      mkDerivation {
        pname = "functional-arrow";
        version = "0.0";
-       sha256 = "1la9xqm5gs6a6cb18wyx9wr0nx6p5ryhczvb72d0zm6xrjrf0r5s";
+       sha256 = "ba64e0b2ccddd40f9a386b7f067d2ed7740b324fdd73141633cae8572aee49d1";
        libraryHaskellDepends = [ base HList ];
        jailbreak = true;
        description = "Combinators that allow for a more functional/monadic style of Arrow programming";
@@ -53639,7 +53812,7 @@ self: {
      mkDerivation {
        pname = "functor-apply";
        version = "0.11";
-       sha256 = "0jshf7and80p0gq26zz83xj4p3ff8lppa5252qg0646xsr06lfkr";
+       sha256 = "793a6a40d6dd10031e164514752f45ce8d4b641fe87f23f00317a066d571504b";
        homepage = "http://comonad.com/reader/";
        description = "This package has been subsumed by semigroupoids";
        license = stdenv.lib.licenses.bsd3;
@@ -53653,7 +53826,7 @@ self: {
      mkDerivation {
        pname = "functor-combo";
        version = "0.3.6";
-       sha256 = "1jlva6imjjpj9iww7dxiplw60vszjiw6456yq30zsqrb63sz2lk1";
+       sha256 = "6152f1f5302b63fdc1c0de146278945f6f6038bdb1b7c3794cf24a59a3519bca";
        libraryHaskellDepends = [
          base base-orphans containers data-inttrie lub type-unary
          TypeCompose
@@ -53667,7 +53840,7 @@ self: {
      mkDerivation {
        pname = "functor-infix";
        version = "0.0.3";
-       sha256 = "1hpk1q58kwxdpva57hylpqj4ywk6grsi4ks2cqg6lspprqfi60gy";
+       sha256 = "fe01131dcef76a6a1e66424f12757e66724f24bed4c353d4beadf3890a0ef3c2";
        libraryHaskellDepends = [ base template-haskell ];
        homepage = "https://github.com/fmap/functor-infix";
        description = "Infix operators for mapping over compositions of functors. Lots of them.";
@@ -53679,7 +53852,7 @@ self: {
      mkDerivation {
        pname = "functor-monadic";
        version = "0.1.0.3";
-       sha256 = "1qfrnny4qsn94n24q705z8d9gh9llz9nbyqbyy7hwh79bf1rkrcg";
+       sha256 = "8fe599835be9400e8ff70bfb65d3a734c1971afa051c4c8425c96a4cbcb5d9e1";
        libraryHaskellDepends = [ base ];
        homepage = "https://github.com/ombocomp/FunctorMonadic/";
        description = "Monad-style combinators for functors";
@@ -53691,7 +53864,7 @@ self: {
      mkDerivation {
        pname = "functorm";
        version = "1.0.1";
-       sha256 = "1aa4f6yp4vrrrs3rswhjxw2gij3mwn8yf299kgv42wd03xazyxrs";
+       sha256 = "3a77ff551fa07141f69b2909e791e575c8f804ef12729d87ce396f72bd7144a9";
        libraryHaskellDepends = [ base ];
        description = "Data.FunctorM (compatibility package)";
        license = stdenv.lib.licenses.bsd3;
@@ -53703,7 +53876,7 @@ self: {
      mkDerivation {
        pname = "functors";
        version = "0.1";
-       sha256 = "0nfnjxihn0nhj0rhi1wvqax1f95wskr3fwb7c2clz4lvsma6bfg6";
+       sha256 = "e6b96554d59b924f9960677137f2d4bc2417bac29b87083390d0020b6397d659";
        libraryHaskellDepends = [ base ];
        homepage = "https://github.com/aristidb/functors";
        description = "(.:) and friends, syntax for Functor and Applicative.";
@@ -53717,7 +53890,7 @@ self: {
      mkDerivation {
        pname = "funion";
        version = "0.0.2";
-       sha256 = "0pgl4fg29xg7g2pdyjqmi7qlpzcs25ggwg6d9y4fzbc7fzh31wxv";
+       sha256 = "bbf330e07787adef884fcd3cfe5e119afd4bf189154bdfae78e7f5249e23f45d";
        isLibrary = false;
        isExecutable = true;
        executableHaskellDepends = [
@@ -53735,7 +53908,7 @@ self: {
      mkDerivation {
        pname = "funpat";
        version = "0.1";
-       sha256 = "0zblrfg8mfbc1hzxb36hk2lb3c167xmpcvg8h595m9kjpdmj4ayw";
+       sha256 = "dc2b226bbb72a65a5281e86d766b3f26b0b1a898d08cd53f0c6cb98a9ecb747d";
        libraryHaskellDepends = [ base mtl ];
        jailbreak = true;
        description = "A generalization of pattern matching";
@@ -53749,7 +53922,7 @@ self: {
      mkDerivation {
        pname = "funsat";
        version = "0.6.2";
-       sha256 = "1hyyx3ivrhw5svklyl36qzbcd0wwx4978znvn42lsl53273ds5n3";
+       sha256 = "c316ddc611a3504d05b1db7e7412e99c83c6d6c766504fe7d685c3bce3e8dec3";
        isLibrary = true;
        isExecutable = true;
        libraryHaskellDepends = [
@@ -53766,12 +53939,27 @@ self: {
        hydraPlatforms = stdenv.lib.platforms.none;
      }) {};
 
+  "fusion" = callPackage
+    ({ mkDerivation, base, directory, doctest, filepath, pipes-safe
+     , transformers, void
+     }:
+     mkDerivation {
+       pname = "fusion";
+       version = "0.1.2";
+       sha256 = "b66f1d552ac2107574fd8faad1ac3c3b2f99d90aaac2a5f57d77b41a3272472b";
+       libraryHaskellDepends = [ base pipes-safe transformers void ];
+       testHaskellDepends = [ base directory doctest filepath ];
+       homepage = "https://github.com/jwiegley/fusion";
+       description = "Effectful streaming library based on shortcut fusion techniques";
+       license = stdenv.lib.licenses.bsd3;
+     }) {};
+
   "futun" = callPackage
     ({ mkDerivation, base, bytestring, network, unix }:
      mkDerivation {
        pname = "futun";
        version = "0.1.0.2";
-       sha256 = "1vfi30mlr0lds975wgq3197sv1qdwy6lvm6xaqwk28h5flmk28k1";
+       sha256 = "6122312b750522313956ddd44d8de70d87ad4f0a033f5e4ed28d824c2b18d1ed";
        isLibrary = false;
        isExecutable = true;
        executableHaskellDepends = [ base bytestring network unix ];
@@ -53785,7 +53973,7 @@ self: {
      mkDerivation {
        pname = "future";
        version = "2.0.0";
-       sha256 = "1gvv1m6sfxdc28h4rzp5dh6hrz6nfh031nhs192606v8wg78m3ri";
+       sha256 = "318f8acee3681b60440a1ada300074d6fc0c0d6ce5fe4c2012ac75a74d0d7bbf";
        libraryHaskellDepends = [ base ];
        homepage = "http://hackage.haskell.org/cgi-bin/hackage-scripts/package/future";
        description = "Supposed to mimics and enhance proposed C++ \"future\" features";
@@ -53798,7 +53986,7 @@ self: {
      mkDerivation {
        pname = "future-resource";
        version = "0.4.0.0";
-       sha256 = "10whksji6r1bilmj2fxcccg89zh7c08s2zfn07r6wj3xgschrckv";
+       sha256 = "7bb20c997e7d486ef201d67da1116007fe841e63ac3b212b8d2b6413a59e9083";
        libraryHaskellDepends = [ base transformers ];
        description = "realtime resource handling with manual concurrency";
        license = stdenv.lib.licenses.gpl3;
@@ -53811,7 +53999,7 @@ self: {
      mkDerivation {
        pname = "fuzzcheck";
        version = "0.1.1";
-       sha256 = "0qfr4f0b50l368b45yzwhqd4g2y1kvfrfj4hr84cdxcwdrwn9mpc";
+       sha256 = "ecd664796e9cf5c608ca904897dd9ec18b471a86fcfb4216328382b28023d961";
        libraryHaskellDepends = [
          base lifted-base monad-control QuickCheck random transformers
        ];
@@ -53828,7 +54016,7 @@ self: {
      mkDerivation {
        pname = "fuzzy";
        version = "0.1.0.0";
-       sha256 = "1jz9arrg33x64ygipk0115b7jfchxh20cy14177iwg0na8mpl2l2";
+       sha256 = "820a7a2b52163c1ecf0924780604ec903979560901cc1b9f27a68ff17256e9cb";
        libraryHaskellDepends = [ base monoid-subclasses ];
        testHaskellDepends = [ base HUnit ];
        homepage = "http://github.com/joom/fuzzy";
@@ -53844,7 +54032,7 @@ self: {
      mkDerivation {
        pname = "fuzzy-timings";
        version = "0.0.1";
-       sha256 = "1sm4g04y9n8r61q2sqa91n87hh32kpcn2r5zjlvdy7qxc11lrmj7";
+       sha256 = "47d64c43601d1fdf3695bf6461d99d624078900d49612d703019d9e40978a4ea";
        libraryHaskellDepends = [
          base containers glpk-hs mtl random time
        ];
@@ -53863,7 +54051,7 @@ self: {
      mkDerivation {
        pname = "fuzzytime";
        version = "0.7.7";
-       sha256 = "16ybyzki390g2172d3f48vyr1gr27grkvs1jjb6cblws34n5g2pr";
+       sha256 = "f98a572c199ad3c5cc9232e83df33b22bf90fd46c48d264e100fa411e7f7cb9b";
        isLibrary = true;
        isExecutable = true;
        libraryHaskellDepends = [ base ];
@@ -53882,7 +54070,7 @@ self: {
      mkDerivation {
        pname = "fwgl";
        version = "0.1.2.2";
-       sha256 = "1s4j1wgnncn6cmsarsc989zxz1qsqhsa722h7bv2k43093ww0nnh";
+       sha256 = "d05ac0f948609029f63a5088a334c41a87df7f4289e9ac7465c6326b1f0f92e8";
        libraryHaskellDepends = [
          base hashable transformers unordered-containers vector Yampa
        ];
@@ -53899,7 +54087,7 @@ self: {
      mkDerivation {
        pname = "fwgl-glfw";
        version = "0.1.0.5";
-       sha256 = "1y30mqayih5cd74dm90y7mbb9a0fw9sirzjlrmayvcm7aniyvmql";
+       sha256 = "14d7eda355a7b2ed55cd54fe1c75e20ea8b4563d1ea4dac869acc0e815ae60f8";
        libraryHaskellDepends = [
          base fwgl gl GLFW-b hashable JuicyPixels transformers
          unordered-containers vector Yampa
@@ -53917,7 +54105,7 @@ self: {
      mkDerivation {
        pname = "fwgl-javascript";
        version = "0.1.0.6";
-       sha256 = "0fxnnjp7403c29pjks739j0j92a1sldrrxg3sp4nrjb1ax01nia9";
+       sha256 = "49451b405761c96cc9d5e3f59c1bd5418924814ce3e8296f126c0072aeb4b63b";
        libraryHaskellDepends = [
          base fwgl ghcjs-base hashable unordered-containers Yampa
        ];
@@ -53933,7 +54121,7 @@ self: {
      mkDerivation {
        pname = "g-npm";
        version = "0.1.0";
-       sha256 = "1blr3xbqn8fa59av4kgfp2y3szky40v5qmw3k9gsr2barrvkjqz0";
+       sha256 = "e0633977ce6a89ac5f9a83575c36207e7e3dbcb8ee4db2552aca218b571f99ae";
        isLibrary = false;
        isExecutable = true;
        executableHaskellDepends = [ base HTTP json ];
@@ -53949,7 +54137,7 @@ self: {
      mkDerivation {
        pname = "gact";
        version = "0.2";
-       sha256 = "0p1rb24yldkjnkrygjb43g63vfgzq2bix7rrmiqyrdwb37s65ixq";
+       sha256 = "b8c762f4198bb7ec71ac399f1e97c0ffb93dcc1b64c9e7f3b47236ea8958395c";
        isLibrary = false;
        isExecutable = true;
        executableHaskellDepends = [
@@ -53965,7 +54153,7 @@ self: {
      mkDerivation {
        pname = "game-of-life";
        version = "0.1.0.4";
-       sha256 = "1d2hy2bb3dgzf3bj0p97hchsznzckirgws8cjm9qh5ba5mk0wl2z";
+       sha256 = "5f500e662d6a158853950c69fe729cecdbaf2183275d20d770ffb5b196f050b4";
        isLibrary = false;
        isExecutable = true;
        executableHaskellDepends = [ array base hscurses random text ];
@@ -53981,7 +54169,7 @@ self: {
      mkDerivation {
        pname = "game-probability";
        version = "1.1";
-       sha256 = "1wl29h702g79kwy4ca35x1q37aaj3rphf1i9vdm2hmd44bzrwvkk";
+       sha256 = "736e9eff22a455286adb2906076f1e52a93370e86528463c9fe93c010e4c82f2";
        libraryHaskellDepends = [ base containers probability random ];
        jailbreak = true;
        description = "Simple probability library for dice rolls, card games and similar";
@@ -53993,7 +54181,7 @@ self: {
      mkDerivation {
        pname = "game-tree";
        version = "0.1.0.0";
-       sha256 = "1g8gkp4g18dr6m0scilhgdwg0zh0f9a2q3b1sk0gh4m3jw6gj4m5";
+       sha256 = "a512f90c97a312f8c0d4610d2c5472007ef0787b9046a64135b9a1f0c89d0fbd";
        libraryHaskellDepends = [ base ];
        description = "Searching game trees with alpha-beta pruning";
        license = "GPL";
@@ -54004,7 +54192,7 @@ self: {
      mkDerivation {
        pname = "gameclock";
        version = "1.0.4";
-       sha256 = "192rn2d8bil8wqilnaqxba8nzq0fjlbf0innv6rdcjs1kxw1ga0l";
+       sha256 = "14a817789f414bd6b2d9d646e016950ee06f915a1d2b4b23e688c6859ab059a4";
        isLibrary = false;
        isExecutable = true;
        executableHaskellDepends = [ base cairo containers glib gtk time ];
@@ -54020,7 +54208,7 @@ self: {
      mkDerivation {
        pname = "gamma";
        version = "0.9.0.2";
-       sha256 = "09z4m0qsf1aa2al7x3gl7z3xy6r4m0xqhnz8b917dxa104zw6flq";
+       sha256 = "983ac33f0141f576425ae85b883ba8241bdfc73ff48d7ea8124a05a731a8e427";
        libraryHaskellDepends = [
          base continued-fractions converge template-haskell vector
        ];
@@ -54034,7 +54222,7 @@ self: {
      mkDerivation {
        pname = "gang-of-threads";
        version = "3.2.1";
-       sha256 = "0gj7ln0xq1a7zzxhyl636z854xfq714kmh2ld30ll0dskr701l1p";
+       sha256 = "37d0004e9eba014ac16854c03a4938d87552d037c3500ffbff4705dc81a5473e";
        libraryHaskellDepends = [ base containers mtl stm transformers ];
        description = "Non-deterministic parallelism with bags";
        license = stdenv.lib.licenses.bsd3;
@@ -54045,7 +54233,7 @@ self: {
      mkDerivation {
        pname = "garepinoh";
        version = "0.9.9.2.1";
-       sha256 = "1cylwaj62gmcjczw5g44k9x6g5bamgk88h2arbbripzphhaf7cm7";
+       sha256 = "a7b2e31484f7df98d7ca4a4084e6ab6a95677a9a84bcc23f93ac3e61a4e2d4b3";
        isLibrary = true;
        isExecutable = true;
        libraryHaskellDepends = [ base haskeline transformers ];
@@ -54061,7 +54249,7 @@ self: {
      mkDerivation {
        pname = "garsia-wachs";
        version = "1.2";
-       sha256 = "0mks5nwc19i0wsc5hhxh0ji2bh0224y3r89b3p9dfzzn64n3za6v";
+       sha256 = "dba83f2c31f67fd7d21d2ba13c3c1102c025a204b0435898e620a6c0b82d7a56";
        libraryHaskellDepends = [ base ];
        description = "A Functional Implementation of the Garsia-Wachs Algorithm";
        license = stdenv.lib.licenses.bsd3;
@@ -54074,7 +54262,7 @@ self: {
      mkDerivation {
        pname = "gbu";
        version = "0.1";
-       sha256 = "0zqgq5hr3vmajijf1vmc1s1lwilnymwvv493rra4fl0zy28k5cz6";
+       sha256 = "e6b33291f01f504754ce2391bd79f596464e830eaceee06494aaee9161c10f7f";
        libraryHaskellDepends = [
          base containers fgl Graphalyze haskell98 mtl regex-posix
        ];
@@ -54090,7 +54278,7 @@ self: {
      mkDerivation {
        pname = "gc-monitoring-wai";
        version = "0.1.2";
-       sha256 = "04i86mngz0s6x5j36vs2nrxivqayqjfa2ppk016r4ffs4mi7i4va";
+       sha256 = "6a93786225da39924d00f35ea19cc45ee11d7bb6426f3364e94683ff6c352812";
        libraryHaskellDepends = [
          aeson base blaze-builder conduit http-types text transformers
          unordered-containers wai
@@ -54106,7 +54294,7 @@ self: {
      mkDerivation {
        pname = "gconf";
        version = "0.13.0.2";
-       sha256 = "0xyxia19bfpi4pd118d33z8gi5cnyygs3idrby7zrmj69rnwj2lk";
+       sha256 = "930ac96d4e46d6fc8f5fb9c5a19ff79695f8d01fa3a110da25f1ba95828add77";
        libraryHaskellDepends = [ base glib text ];
        libraryPkgconfigDepends = [ GConf ];
        libraryToolDepends = [ gtk2hs-buildtools ];
@@ -54122,7 +54310,7 @@ self: {
      mkDerivation {
        pname = "gd";
        version = "3000.7.3";
-       sha256 = "1dkzv6zs00qi0jmblkw05ywizc8y3baz7pnz0lcqn1cs1mhcpbhl";
+       sha256 = "14aecb600d9a058b1905dfdef3d51a1eb11fb92f804fbaaa041103a0bfd97fb6";
        libraryHaskellDepends = [ base bytestring ];
        librarySystemDepends = [
          expat fontconfig freetype gd libjpeg libpng zlib
@@ -54139,7 +54327,7 @@ self: {
      mkDerivation {
        pname = "gdiff";
        version = "1.1";
-       sha256 = "1d0d8f8bfw7ld6a1d5y6syzdha5qsm909mqzd5gfqcbi2wnh8aqc";
+       sha256 = "0c2b042d177131ec5e691fd70452d5b828d8bed7c697169469f470b790430db4";
        libraryHaskellDepends = [ base ];
        homepage = "https://github.com/eelco/gdiff";
        description = "Generic diff and patch";
@@ -54153,7 +54341,7 @@ self: {
      mkDerivation {
        pname = "gdiff-ig";
        version = "0.1.1";
-       sha256 = "1ma9w9ypk078vvqwlfgkwcw962xha1g1fx4abji1b7km09p58jm2";
+       sha256 = "a24a546e02759e15a25c8a74175e50b00b9338e3f339caf1dee880797de249d5";
        libraryHaskellDepends = [
          array base ghc-prim instant-generics template-haskell
        ];
@@ -54170,7 +54358,7 @@ self: {
      mkDerivation {
        pname = "gdiff-th";
        version = "0.1.0.7";
-       sha256 = "1ihbz95k01giqbpbp1hddx71pkhz63pz5q4b71gv6z2vvvh34s2w";
+       sha256 = "5c6832e0de5b7cb35f388be0f2ef301fce1b4e6f0d86bbeec2f105304bfa0bc6";
        libraryHaskellDepends = [
          base containers gdiff mtl template-haskell th-expand-syns uniplate
        ];
@@ -54189,7 +54377,7 @@ self: {
      mkDerivation {
        pname = "gearbox";
        version = "1.0.0.3";
-       sha256 = "1j68vrb0fxschslh3q5i1afv0vx8q6qgv1bipfr3p77cqazp26zx";
+       sha256 = "fd1b71bfc2ec9c3bb2bb7185fdb0c1a86fb09d0ab1e001a9864c770756dec8c8";
        isLibrary = false;
        isExecutable = true;
        executableHaskellDepends = [ base GLUT OpenGLRaw Vec ];
@@ -54208,7 +54396,7 @@ self: {
      mkDerivation {
        pname = "geek";
        version = "1.1.1.0";
-       sha256 = "0n52s5azqqx06flfhsgbp5a63mpd4vd60y4rzrpa4jx13bydlp50";
+       sha256 = "a05cdafc1aa14ba26efe997860da26edd66154b9eb69e8a833a063fc55d1a258";
        libraryHaskellDepends = [
          aeson aeson-pretty air air-extra air-th base bytestring containers
          curl data-default directory filepath fsnotify Glob hack2
@@ -54228,7 +54416,7 @@ self: {
      mkDerivation {
        pname = "geek-server";
        version = "1.1";
-       sha256 = "1951jw8la59c7qvjpx8x898l7hnwc51c4264mmw0h402ik233bp2";
+       sha256 = "e2ae31c48c02100878adc408c24261dcc24351421df52b373e2c15451197a1a4";
        isLibrary = true;
        isExecutable = true;
        libraryHaskellDepends = [
@@ -54253,7 +54441,7 @@ self: {
      mkDerivation {
        pname = "gemstone";
        version = "0.3.0.1";
-       sha256 = "0y9ilxpkyb42iddks31k1f6vjkm78z6yaj2yd9ppis42r2advg40";
+       sha256 = "80bcdd94c882e8786f6a5e48e5cd47a74eb98d0b330c3d5b8b822c3f6fa73179";
        libraryHaskellDepends = [
          array base bitmap bitmap-opengl containers FTGL lens linear OpenGL
          random SDL SDL-image stb-image transformers
@@ -54272,7 +54460,7 @@ self: {
      mkDerivation {
        pname = "gencheck";
        version = "0.1.1";
-       sha256 = "1fa1p13zmqqhlcakcy73ypasn4ircg1x5p3q1p5mklvfjifphfir";
+       sha256 = "393a785d946ed359cb0d78dcd2c3633912abd5f5e3783615a310e3fa47b841b9";
        libraryHaskellDepends = [
          base combinat containers ieee754 memoize random template-haskell
          transformers
@@ -54288,7 +54476,7 @@ self: {
      mkDerivation {
        pname = "gender";
        version = "0.1.1.0";
-       sha256 = "0sfl3729v03s5ykd8ijv4yrf8lzja5hyaphsfgk96gcx3zvd1a0q";
+       sha256 = "18a8d0f61f9d3d93e6731a5ee56151f253e4b2275b46d4a62f7a809dc419d469";
        isLibrary = true;
        isExecutable = true;
        libraryHaskellDepends = [ attoparsec base text ];
@@ -54307,7 +54495,7 @@ self: {
      mkDerivation {
        pname = "genders";
        version = "0.1.0.1";
-       sha256 = "0jl1sqj9syp31qcn3x6c0pjwj5ligirsc67ahzw2chgpf09bwh8g";
+       sha256 = "0f41be1270f74126f887ea18a6737c9116c9e505ccf461190ee37a9d24d6814a";
        libraryHaskellDepends = [ base bytestring filepath vector ];
        librarySystemDepends = [ genders ];
        testHaskellDepends = [ base bytestring hspec network vector ];
@@ -54322,7 +54510,7 @@ self: {
      mkDerivation {
        pname = "general-prelude";
        version = "0.1.2";
-       sha256 = "0km8nrd7pili8s5fz68xpb6nw9mfk0phgwaxnflk6a78vz9ic76d";
+       sha256 = "cd1c16d3dfe82833a9b35df1072f98ae266ecdba1d99ef8a4691c67b5ab6a84e";
        libraryHaskellDepends = [
          base lens pointless-fun strict system-filepath
        ];
@@ -54336,7 +54524,7 @@ self: {
      mkDerivation {
        pname = "generator";
        version = "0.5.5";
-       sha256 = "1rwz2ribijj5hb2isg0yz6hb2mwyjhzfg0ys041yb43qlcbhkhdd";
+       sha256 = "adc10917a37890e50301da83e73e949e57b1a0f91e3c1dc58245cab862169fe7";
        libraryHaskellDepends = [ base List transformers ];
        homepage = "http://github.com/yairchu/generator/tree";
        description = "Python-generators notation for creation of monadic lists";
@@ -54348,7 +54536,7 @@ self: {
      mkDerivation {
        pname = "generators";
        version = "1.0.3";
-       sha256 = "0i51xx2hhjqjdvyzy2jza921jcfhy37azyp1cfaakvrj9kxl2w2q";
+       sha256 = "587041fb4c32efa99463e1faafcef0d0311944525f0afffd6e124b0845efa144";
        libraryHaskellDepends = [ base mtl random ];
        jailbreak = true;
        homepage = "http://liamoc.net/pdf/Generator.pdf";
@@ -54364,7 +54552,7 @@ self: {
      mkDerivation {
        pname = "generic-accessors";
        version = "0.4.1";
-       sha256 = "1qhik496296v42pjmlxxlimnw4z9p451ndc2fjvrid4g0knfzvg0";
+       sha256 = "e0edefec048fb498b77482351b0ab9e9136e6ba4bdd32aaf20db2461129911e2";
        libraryHaskellDepends = [ base linear spatial-math ];
        testHaskellDepends = [
          base HUnit QuickCheck test-framework test-framework-hunit
@@ -54380,7 +54568,7 @@ self: {
      mkDerivation {
        pname = "generic-aeson";
        version = "0.2.0.7";
-       sha256 = "06qczarf6vzd9wr9ad685v69hvd88zfv5lhry0zkka2bcdqc5wqz";
+       sha256 = "1ff3c270634ba8393ff019d2b2dd47a86d98cc2ec83495324fed6fe3b2fa0c1b";
        revision = "1";
        editedCabalFile = "f14b6017d6c92b2fc7a585bc81fd2ee286c8d73338cf1eb5964006bffeb70abd";
        libraryHaskellDepends = [
@@ -54396,7 +54584,7 @@ self: {
      mkDerivation {
        pname = "generic-binary";
        version = "1.0.1";
-       sha256 = "1h6xs56c351137mjc3hdba7yfcw8jy9dvzj0vdrgwm0dprn0xh29";
+       sha256 = "49c00e6cbe0d54fe72db40fedd92978833e78f5a0d0e26eb192194c14cd1ddc0";
        libraryHaskellDepends = [ base binary bytestring ghc-prim ];
        jailbreak = true;
        description = "Generic Data.Binary derivation using GHC generics.";
@@ -54409,7 +54597,7 @@ self: {
      mkDerivation {
        pname = "generic-church";
        version = "0.3.0.0";
-       sha256 = "1cw48dnw2nbnm3vr5xcsz7nma6g8dxvwvv7hwm63jikd9jgisnac";
+       sha256 = "4c591d9f4c6d46394ce5f0eccd776fe81955edf99af592f7a87659c16d4384b3";
        libraryHaskellDepends = [ base ];
        testHaskellDepends = [
          base HUnit test-framework test-framework-hunit
@@ -54424,7 +54612,7 @@ self: {
      mkDerivation {
        pname = "generic-deepseq";
        version = "2.0.1.1";
-       sha256 = "1yajkzp79ri5i7n5ynv0i6spxyg6kyi6qvqj46brlgjag98526iv";
+       sha256 = "3b1a51507a4a3e9a9721126f6ca29fe6f97eb589605b5fec8925e674ee9f52f9";
        revision = "1";
        editedCabalFile = "58ed9aeb48cc2a00e3122780fcbf2732c4d6fc46198434926a8b1bcc91d4a29b";
        libraryHaskellDepends = [ base ghc-prim ];
@@ -54437,7 +54625,7 @@ self: {
      mkDerivation {
        pname = "generic-deriving";
        version = "1.8.0";
-       sha256 = "1kc6lhdanls6kgpk8xv5xi14lz1sngcd8xn930hkf7ilq4kxkcr6";
+       sha256 = "26b3d927c1341e372118c976d4d8b33a7c4a42ec657734ef9b4653ab1aa486cd";
        libraryHaskellDepends = [ base ghc-prim template-haskell ];
        description = "Generic programming library for generalised deriving";
        license = stdenv.lib.licenses.bsd3;
@@ -54448,7 +54636,7 @@ self: {
      mkDerivation {
        pname = "generic-lucid-scaffold";
        version = "0.0.1";
-       sha256 = "13lry3hqqrqgk5z9dc6q6hr70iqky4ssra2l71y51gnrg1kprkrz";
+       sha256 = "3fcf7c6778d9be507c3854a8ac35f11347703234d8b0967e990f678ce1f0998e";
        libraryHaskellDepends = [ base lucid text ];
        description = "General-purpose web page scaffold for Lucid";
        license = stdenv.lib.licenses.mit;
@@ -54463,7 +54651,7 @@ self: {
      mkDerivation {
        pname = "generic-maybe";
        version = "0.3.0.4";
-       sha256 = "1gs89wzs3288l2p24pj5yi68xyy2kj3aczj31zk6v9xi3bwb73x1";
+       sha256 = "a18fb3f81ab1a76de60f437ea6869cc2fb8e4cf4455e22aea00889a13f4f48bf";
        libraryHaskellDepends = [ base ghc-prim ];
        testHaskellDepends = [
          base bytestring containers deepseq directory doctest filepath
@@ -54483,7 +54671,7 @@ self: {
      mkDerivation {
        pname = "generic-pretty";
        version = "0.1.0";
-       sha256 = "0mg7mdbxf3va0xl2j0kz5wzy3mg6nvxv68axfjvx1zij1yjlamn7";
+       sha256 = "c75645a50f32fed0b7745d21b3fbb6e6d5e13f2f7f022968076a0fd757abe755";
        libraryHaskellDepends = [
          ansi-wl-pprint base bytestring containers text vector
        ];
@@ -54500,7 +54688,7 @@ self: {
      mkDerivation {
        pname = "generic-server";
        version = "0.1";
-       sha256 = "0bl3gfqdw6sdwcailzkzmpz433cpxf6np9w9qnkwwa05xhcpd2k6";
+       sha256 = "668a7619ec0528cea7c589a76b8deb978d41fead7f7e1a15e34d1bdeb07b832e";
        libraryHaskellDepends = [ base bytestring network ];
        description = "Simple generic TCP/IP server";
        license = stdenv.lib.licenses.bsd3;
@@ -54511,7 +54699,7 @@ self: {
      mkDerivation {
        pname = "generic-storable";
        version = "0.1.0.0";
-       sha256 = "016gg232r453i7grbjg2hb69ww8jqgafnq32f38lv7l81dgzwfxj";
+       sha256 = "b23bfe5f0b889e4dd1706260ebd4c312719ecc82e2c995df89a3902c8678cf04";
        libraryHaskellDepends = [ base ghc-prim ];
        testHaskellDepends = [ base ghc-prim hspec QuickCheck ];
        jailbreak = true;
@@ -54525,7 +54713,7 @@ self: {
      mkDerivation {
        pname = "generic-tree";
        version = "15329.2";
-       sha256 = "1frwwa45kahflnw2cgs8nb8jfxgrxw0n9i7h9cakpqzgbywy9b28";
+       sha256 = "48ace4b95fefe33b154bf0c46401eff97527d1b2483f26b8a50eaa5988e23cbb";
        libraryHaskellDepends = [ base ];
        description = "Generic Tree data type";
        license = "LGPL";
@@ -54536,7 +54724,7 @@ self: {
      mkDerivation {
        pname = "generic-trie";
        version = "0.3.0.1";
-       sha256 = "09f4rasw8q2yi7dakcr21igy02vhgiasylw6lzsz225kl58vjwz7";
+       sha256 = "e773b951a1b308f1f5a78653af557c700be05f0c22b3a9da895e60c4b5cac425";
        libraryHaskellDepends = [ base containers transformers ];
        homepage = "http://github.com/glguy/tries";
        description = "A map, where the keys may be complex structured data";
@@ -54549,7 +54737,7 @@ self: {
      mkDerivation {
        pname = "generic-xml";
        version = "0.1";
-       sha256 = "08fy9wc90wcnr74wbr7q3pfr0bigrzhchx158p1ji3gagb2n2njd";
+       sha256 = "4d5a61c57aea8d28c3452574c8e0cf2f2e90dd1df8e4c5c9c9967190184fde21";
        libraryHaskellDepends = [
          base HaXml mtl syb-with-class template-haskell
        ];
@@ -54565,7 +54753,7 @@ self: {
      mkDerivation {
        pname = "generic-xmlpickler";
        version = "0.1.0.3";
-       sha256 = "11vbfsws5agqiv9x6pfh0z6kbvjx6i27wnp5dcjh40z4bz6bjdgy";
+       sha256 = "fe35b9cc5fe40302256be55a7e44345dee35cd07d05dd3d38ef8a9a2b9766b87";
        libraryHaskellDepends = [ base generic-deriving hxt text ];
        testHaskellDepends = [
          base hxt hxt-pickle-utils tasty tasty-hunit tasty-th
@@ -54580,7 +54768,7 @@ self: {
      mkDerivation {
        pname = "generics-sop";
        version = "0.1.1.2";
-       sha256 = "1r9icxwyh4pg952yaywk4nfj4j21klzf361z9z24avd6vw89p6v7";
+       sha256 = "679b9b10dfa66d45c44f3f98e13e9d4148229d25937be54549ef12e8796731e5";
        libraryHaskellDepends = [ base ghc-prim template-haskell ];
        description = "Generic Programming using True Sums of Products";
        license = stdenv.lib.licenses.bsd3;
@@ -54591,7 +54779,7 @@ self: {
      mkDerivation {
        pname = "genericserialize";
        version = "0.1";
-       sha256 = "0zpb5rq2zvfsb0wlp9q4cckjkz6sdrngpir49d0sr06pivh8s6cl";
+       sha256 = "94198de08ed780ac414b24c7fb6c6edafc29276304a74b3958daed2f702eeb7e";
        libraryHaskellDepends = [ base ];
        description = "Serialization library using Data.Generics";
        license = stdenv.lib.licenses.bsd3;
@@ -54603,7 +54791,7 @@ self: {
      mkDerivation {
        pname = "genetics";
        version = "0.0.2";
-       sha256 = "0rq1m7psvs2r35mnz7gwmsvzyd3jv44bqp0zhq8l7mq2pq2x7dhv";
+       sha256 = "1bb6d305be02d74311861f5cbc08d97234ffb7aefc9d6f6b1959e8adefa90167";
        isLibrary = false;
        isExecutable = true;
        executableHaskellDepends = [ base random-fu ];
@@ -54620,7 +54808,7 @@ self: {
      mkDerivation {
        pname = "geni-gui";
        version = "0.24.1";
-       sha256 = "1kng7bv8amch6bswhica6xhmavc0r5phg402lg76xwz7ywrsc6y3";
+       sha256 = "c31ba633f7e7f36ecea30290076fc9806d5561378a45c8f532905585f63acfce";
        isLibrary = true;
        isExecutable = true;
        libraryHaskellDepends = [
@@ -54643,7 +54831,7 @@ self: {
      mkDerivation {
        pname = "geni-util";
        version = "0.24.1.1";
-       sha256 = "1ydxg10s6bk02i3mikb8aqjai099874gby26q50lwf9xp04csbfk";
+       sha256 = "d32dcd08b83d394e41c146f8f5c8412981a8245668cd584714602ea34178bdf9";
        isLibrary = true;
        isExecutable = true;
        libraryHaskellDepends = [
@@ -54667,7 +54855,7 @@ self: {
      mkDerivation {
        pname = "geniconvert";
        version = "0.20";
-       sha256 = "0brnh6f8zdpn37fjdmnpbdvb75vmaf6iq7i9vpv4a8g7asc425wd";
+       sha256 = "8d17419856e72145f6dd291e1c8d537597b3765bd7d626dd19f6b68f9c81362f";
        isLibrary = false;
        isExecutable = true;
        executableHaskellDepends = [
@@ -54686,7 +54874,7 @@ self: {
      mkDerivation {
        pname = "genifunctors";
        version = "0.3";
-       sha256 = "16jsy5dyp1hqnk40nzjprkw3bfdbc92vkgzmwdds67ljh0jn6815";
+       sha256 = "2520632580921ea35be3f5bfb94562abb935f8cc577e0bc8b41886eb5bf15a9a";
        libraryHaskellDepends = [ base containers mtl template-haskell ];
        testHaskellDepends = [ base containers mtl template-haskell ];
        homepage = "https://github.com/danr/genifunctors";
@@ -54699,7 +54887,7 @@ self: {
      mkDerivation {
        pname = "geniplate";
        version = "0.6.0.5";
-       sha256 = "01cwyf5kql4hf76p1ssqpmhaxyl7rmnmqwv644wgd0j8km8b6szc";
+       sha256 = "ec6bb3509d4882f6382166735c6dcd87faae60bd58eb70cd7190503c8bf39c05";
        libraryHaskellDepends = [ base mtl template-haskell ];
        jailbreak = true;
        description = "Use Template Haskell to generate Uniplate-like functions";
@@ -54711,7 +54899,7 @@ self: {
      mkDerivation {
        pname = "geniplate-mirror";
        version = "0.7.1";
-       sha256 = "0wz7fp0cgf7xn37mmy91scacihnr0fcd6lpbi28yx4qss2hb1m30";
+       sha256 = "60d4b0a0d01a93ee9188eb52d39803d9c2c814d321f95acfb0fdb8c7c075e773";
        libraryHaskellDepends = [ base mtl template-haskell ];
        homepage = "https://github.com/danr/geniplate";
        description = "Use Template Haskell to generate Uniplate-like functions";
@@ -54725,7 +54913,7 @@ self: {
      mkDerivation {
        pname = "geniserver";
        version = "0.24.1.1";
-       sha256 = "1597ah64rqag20qx8dvjmdhhhsjzsfdq2f43y3jyy2cnzssj953c";
+       sha256 = "6c9424b5fe9609efe5f08338819bd35f6a0861ab7237d431104fe14c0c542795";
        isLibrary = true;
        isExecutable = true;
        libraryHaskellDepends = [
@@ -54746,7 +54934,7 @@ self: {
      mkDerivation {
        pname = "genprog";
        version = "0.1.0.2";
-       sha256 = "1a9b2h4swfwx5zwcyr2zdhxdxi9f68pwpglijxhxb5javjc4dppr";
+       sha256 = "f9de4698dc4a96d5619791becb2f322ec5de3a6c5f64cff82f9d3bae09142ba9";
        libraryHaskellDepends = [ base MonadRandom syb syz ];
        jailbreak = true;
        homepage = "http://github.com/jsnajder/genprog";
@@ -54759,7 +54947,7 @@ self: {
      mkDerivation {
        pname = "gentlemark";
        version = "1.0.0";
-       sha256 = "1cb9si5axwqi1d893vp6n2mr68isdxc9qp6dfygy0v6hci2spnmm";
+       sha256 = "b5daab4564d06ce09f77cd5c9c586f3a2293abb0e6ee91500b11f3ae4ad469b1";
        libraryHaskellDepends = [ base parsec transformers ];
        testHaskellDepends = [ base HUnit parsec transformers ];
        jailbreak = true;
@@ -54773,7 +54961,7 @@ self: {
      mkDerivation {
        pname = "geocalc";
        version = "1.0.0";
-       sha256 = "1bvbvrkxh8dvm796ilpp294qlacid6aap2ljdi9pmz1lkf20fxjg";
+       sha256 = "4f7607849b34fc7a536c928aab946991298a4912f7d268d2a9bb21d867de6baf";
        libraryHaskellDepends = [ base ];
        description = "Libary for calculating distances between two coordinates in WSG84";
        license = stdenv.lib.licenses.bsd3;
@@ -54786,7 +54974,7 @@ self: {
      mkDerivation {
        pname = "geodetic";
        version = "0.1.4";
-       sha256 = "07l6yha31l0ahd6jhlj09vclms8km4q82xq2mfx2a3lbv2kffcfz";
+       sha256 = "df31e7a6d88b0e25baab02778130a913e94ad94e4052284d830ad03014f4861e";
        libraryHaskellDepends = [ base coordinate lens optional radian ];
        testHaskellDepends = [
          base directory doctest filepath QuickCheck template-haskell
@@ -54803,7 +54991,7 @@ self: {
      mkDerivation {
        pname = "geodetics";
        version = "0.0.3";
-       sha256 = "15ax0cj6q2zhlxl0fjxb434v1npq6w7n8bdqsw3vz3s9ngsvbldg";
+       sha256 = "afd1b5f5b3498fbf07d7b82d640f37f8dab0c920ab4b0768a7f00b6c24035d95";
        libraryHaskellDepends = [ array base dimensional ];
        testHaskellDepends = [
          array base dimensional HUnit QuickCheck test-framework
@@ -54821,7 +55009,7 @@ self: {
      mkDerivation {
        pname = "geohash";
        version = "1.0.1";
-       sha256 = "1pdx4pnq893kkjmgg0bgh9bfvfqdvzfq5fi02zfyhw3h8h4k05v4";
+       sha256 = "64173009447070e8dd1720ba82dddf0dbbed56826f81f7aa9c732484ed25bddd";
        libraryHaskellDepends = [ array base ];
        description = "Geohash latitudes and longitudes";
        license = stdenv.lib.licenses.bsd3;
@@ -54834,7 +55022,7 @@ self: {
      mkDerivation {
        pname = "geoip2";
        version = "0.1.0.1";
-       sha256 = "0h6iivpxkc1k463cj5npzagzd01xddinpnbv8357d40617gihgrg";
+       sha256 = "2f3f18df09069076ca407bd96b636b3d80f69ffad716c9862133b0d9ef8ed140";
        libraryHaskellDepends = [
          base binary bytestring bytestring-mmap containers iproute
          reinterpret-cast text
@@ -54852,7 +55040,7 @@ self: {
      mkDerivation {
        pname = "geojson";
        version = "1.3.0";
-       sha256 = "18fr5n3nmxlr97b7s9a5x1dx91fcg2fjfhlpxpcglkpwpkhabnqs";
+       sha256 = "1adba5e0bcfc4efad8ed9742279d78cc85d45be845257dd64999f66a872dd9a1";
        libraryHaskellDepends = [
          aeson base lens semigroups text transformers validation vector
        ];
@@ -54871,7 +55059,7 @@ self: {
      mkDerivation {
        pname = "geom2d";
        version = "0.1.3.1";
-       sha256 = "1kz0cdxfc27412vzqv7vcywg9pba177ds6mpwknxlh049vcfrvh5";
+       sha256 = "05eeecd84e0440daede4b71addce096addf4b867fb6cfcb708e408e67a63e0cf";
        libraryHaskellDepends = [ base ieee754 QuickCheck ];
        testHaskellDepends = [ base ieee754 QuickCheck ];
        description = "package for geometry in euklidean 2d space";
@@ -54885,7 +55073,7 @@ self: {
      mkDerivation {
        pname = "getemx";
        version = "0.1";
-       sha256 = "1qgq465ck4z0mix3ari9n7a5qx5xc1zii4hmfsp093vx3qlc5nwm";
+       sha256 = "95dbc2281e7d8f04ae761592187f60bd745cd4b12966357aace093c98a21f8e1";
        isLibrary = false;
        isExecutable = true;
        executableHaskellDepends = [
@@ -54903,7 +55091,7 @@ self: {
      mkDerivation {
        pname = "getflag";
        version = "1.0";
-       sha256 = "0jsr8cmbnllcswdvf1rp11sc6cpjhwr22x7kx9sk3dw8bv772jjc";
+       sha256 = "4c4a71ce5e88b73175eaf374213287f232c374083707b71bd78c52bb2a43594b";
        libraryHaskellDepends = [ base ];
        description = "Command-line parser";
        license = stdenv.lib.licenses.mit;
@@ -54918,7 +55106,7 @@ self: {
      mkDerivation {
        pname = "getopt-generics";
        version = "0.10.0.1";
-       sha256 = "0x8vh0sng1m05blxr24ijrz16bsyvryxkk70jqkdvq173x5fj8lf";
+       sha256 = "8e22e94a1f27e0dd2696e0ccd97dde5e2f137e969188dce92aa0866735801b75";
        libraryHaskellDepends = [
          base base-compat base-orphans generics-sop tagged
        ];
@@ -54936,7 +55124,7 @@ self: {
      mkDerivation {
        pname = "getopt-simple";
        version = "0.1.0.2";
-       sha256 = "1pf40nc3jzprv4wn9h8mr0nhzxzilffgkapxg3k0qksfxydzv7pp";
+       sha256 = "f79efd9bef4e4f0ce678fdaaf99ca3f1f70f2dc815c16439d9f97e399805c4dd";
        libraryHaskellDepends = [ base containers ];
        homepage = "https://bitbucket.org/dpwiz/getopt-simple";
        description = "A \"System.Console.GetOpt\" wrapper to make simple use case easy.";
@@ -54953,7 +55141,7 @@ self: {
      mkDerivation {
        pname = "gf";
        version = "3.7";
-       sha256 = "13y01s94pq466jjzb3czxr93bdfh43mvypqp176n0zfp2v9496nb";
+       sha256 = "cb9a44d216d77d60cd09175fbfeb20d0b53552ee9f8df5a53486e04b920ec08f";
        isLibrary = true;
        isExecutable = true;
        libraryHaskellDepends = [
@@ -54983,7 +55171,7 @@ self: {
      mkDerivation {
        pname = "ggtsTC";
        version = "0.5";
-       sha256 = "0k5in0r3lwjr5yn4ayw5ssdvinh7zwzsx6pfjdj246ngx1r7ydxj";
+       sha256 = "b2377f72e8cf1a226493ee9aae3fff07dab89bd6857b45ac2f59723a32b0b14c";
        isLibrary = false;
        isExecutable = true;
        executableHaskellDepends = [ base containers parsec ];
@@ -55000,7 +55188,7 @@ self: {
      mkDerivation {
        pname = "ghc-core";
        version = "0.5.6";
-       sha256 = "11byidxq2mcqams9a7df0hwwlzir639mr1s556sw5rrbi7jz6d7c";
+       sha256 = "ec34f3e5892be7c2b52945875cd330397eca3904ae1d9574559855817b8b7e85";
        isLibrary = false;
        isExecutable = true;
        executableHaskellDepends = [
@@ -55018,7 +55206,7 @@ self: {
      mkDerivation {
        pname = "ghc-core-html";
        version = "0.1.4";
-       sha256 = "1yx22p9572zg2nvmlilbmraqjmws2x47hmin2l9xd0dnck5qhy35";
+       sha256 = "657888cb64b681d6131536567848179a578955ae8b465ab715ef8b53d215a2fb";
        isLibrary = false;
        isExecutable = true;
        executableHaskellDepends = [
@@ -55034,7 +55222,7 @@ self: {
      mkDerivation {
        pname = "ghc-datasize";
        version = "0.1.2";
-       sha256 = "0bjdcfrk3q0rsy9wmw0b01q0vmbi9jsw1bxl4l78azs7xpk9yl03";
+       sha256 = "03509fe6ed477f850e25b4afc0b54c71d50d70000bf0ca93d719e031b3634d2e";
        libraryHaskellDepends = [ base ghc-heap-view ];
        homepage = "http://felsin9.de/nnis/ghc-datasize";
        description = "Determine the size of data structures in GHC's memory";
@@ -55046,7 +55234,7 @@ self: {
      mkDerivation {
        pname = "ghc-dup";
        version = "0.1";
-       sha256 = "0aw4wnbzfw031xqmq0lpi4zz2md1f43nj921ni91mhdl5xgqcajm";
+       sha256 = "552a865f2fb4c11a52b44124690771a155f13f8997025c710f0370f797e5842b";
        libraryHaskellDepends = [ base ghc ];
        jailbreak = true;
        description = "Explicitly prevent sharing";
@@ -55060,7 +55248,7 @@ self: {
      mkDerivation {
        pname = "ghc-events";
        version = "0.4.4.0";
-       sha256 = "0vagr03rivl5ymcnkxnzb1x5b4cr6xknnkwmfliqfrc1hhjgcaxb";
+       sha256 = "ab2bf624848165872375954f6b67379991557a58dff66959f585ee9807c84f6d";
        isLibrary = true;
        isExecutable = true;
        libraryHaskellDepends = [
@@ -55084,7 +55272,7 @@ self: {
      mkDerivation {
        pname = "ghc-events-analyze";
        version = "0.2.1";
-       sha256 = "0lf063p2wj2d1hxb5hx4bcid3a3ni3g9x8sglm5q5kfbmdk7awj4";
+       sha256 = "44727566abcbcd824ba54fa39ede8876a8d1225ba4c3b23a0c4d482eee30c051";
        isLibrary = false;
        isExecutable = true;
        executableHaskellDepends = [
@@ -55105,7 +55293,7 @@ self: {
      mkDerivation {
        pname = "ghc-events-parallel";
        version = "0.5.0.1";
-       sha256 = "181qnh6mm3pmlalf17g2g87gj7hyzf5pxzvix1cmap2f31x4p6by";
+       sha256 = "7e994b7a184e5c5559e871ff7e8bfb1e1ef90e7ae29de0a8a2f58e5a0db438a0";
        isLibrary = true;
        isExecutable = true;
        libraryHaskellDepends = [
@@ -55129,7 +55317,7 @@ self: {
      mkDerivation {
        pname = "ghc-exactprint";
        version = "0.3.1";
-       sha256 = "07kyifdh8s7jjp1jsm9f823hr0axgpxv54fr0vg8k3ibhdrw5dj1";
+       sha256 = "41b6c273832b8e89de06d991b2fb7d5d810c87402e552dc395f268049b8b7e1e";
        isLibrary = true;
        isExecutable = true;
        libraryHaskellDepends = [
@@ -55149,7 +55337,7 @@ self: {
      mkDerivation {
        pname = "ghc-gc-tune";
        version = "0.3";
-       sha256 = "0ghp3f86m91zi6kl8zq157717s2p73nwdgln4aiclq830m72ys9w";
+       sha256 = "3c692f4e050361caa22296bec6ed3857e813ce29017f44a7893fa46a901b173e";
        isLibrary = false;
        isExecutable = true;
        executableHaskellDepends = [ base directory filepath process ];
@@ -55163,7 +55351,7 @@ self: {
      mkDerivation {
        pname = "ghc-generic-instances";
        version = "0.1.0.0";
-       sha256 = "0264ma0w85fwypnagd0l4zfs1wi1yk16rygn6fhpzgsxycwmg47h";
+       sha256 = "f0905739f35dbf7fa133f6f96cc2f421f2a0dd2714b4a7ecf5dc15c481aac408";
        libraryHaskellDepends = [ base ghc ];
        homepage = "https://github.com/alanz/ghc-generic-instances";
        description = "Derived instances of GHC.Generic of the GHC AST";
@@ -55177,7 +55365,7 @@ self: {
      mkDerivation {
        pname = "ghc-heap-view";
        version = "0.5.4";
-       sha256 = "02n414m1lb6lilrkmjss2pd1s7hd4lf2sga7ql2ahib69kygzhx1";
+       sha256 = "a1c3fffc4c6645a804c5473d2d1c250d1e1dda155acb3a338dd42c1a2a09c40a";
        libraryHaskellDepends = [
          base binary bytestring containers ghc template-haskell transformers
        ];
@@ -55194,7 +55382,7 @@ self: {
      mkDerivation {
        pname = "ghc-imported-from";
        version = "0.2.0.6";
-       sha256 = "0y9gln7lbp8xqg5apfwfs95z3faawd236wqz69q8j7riwfra9bqm";
+       sha256 = "15afa4b2e3311f8970321f733344e34ab9f14bd28ebbabcac31ddd458fa52f79";
        isLibrary = true;
        isExecutable = true;
        libraryHaskellDepends = [
@@ -55223,7 +55411,7 @@ self: {
      mkDerivation {
        pname = "ghc-make";
        version = "0.3.2";
-       sha256 = "10vbibmgssb1ichxha92q5mqlaglhkcv4xxiikq4mh3l3bgzw6bj";
+       sha256 = "7219fedf1a74c04af08cb177b2d984f4298a6bc12229d8218b6169fdea8a6b83";
        isLibrary = false;
        isExecutable = true;
        executableHaskellDepends = [
@@ -55239,7 +55427,7 @@ self: {
      mkDerivation {
        pname = "ghc-man-completion";
        version = "0.0.0.3";
-       sha256 = "08qyn6mpmkq1vdfrqhckfqc096jv21scss76x9zcss4hfbljfa0p";
+       sha256 = "172827e9729068cd7eeae668cd74105b9a04187693419c5ddb01cf7aabb11e23";
        isLibrary = false;
        isExecutable = true;
        executableHaskellDepends = [ base parsec process ];
@@ -55259,7 +55447,7 @@ self: {
      mkDerivation {
        pname = "ghc-mod";
        version = "5.2.1.2";
-       sha256 = "11wnrdb6blw169w6kd49ax9h1r9qkka5329lmdhimvki8amv8riv";
+       sha256 = "3b66b4ab4271ee1a61ab348951d49c38e500535789b469783281d36556cb9687";
        isLibrary = true;
        isExecutable = true;
        libraryHaskellDepends = [
@@ -55289,7 +55477,7 @@ self: {
      mkDerivation {
        pname = "ghc-mtl";
        version = "1.2.1.0";
-       sha256 = "0h6r6gip9nsjlsq88wj105hhqliy7ac2dmmndsfzbjz07b03cklk";
+       sha256 = "934e36c03ae0cbf59d6eb6d626983a3e520c6101417284b0a652db74e333d940";
        libraryHaskellDepends = [
          base exceptions extensible-exceptions ghc mtl
        ];
@@ -55306,7 +55494,7 @@ self: {
      mkDerivation {
        pname = "ghc-parmake";
        version = "0.1.8";
-       sha256 = "089ma8mjyvz61hr2907aihz8bh7h1pdmjrpm9smqmz8j5x72bsfc";
+       sha256 = "cce9254e2f12fd8aab4ef56659db0df0c0853e8cea8024320ce66f2f2b523521";
        isLibrary = true;
        isExecutable = true;
        libraryHaskellDepends = [
@@ -55331,7 +55519,7 @@ self: {
      mkDerivation {
        pname = "ghc-parser";
        version = "0.1.7.0";
-       sha256 = "0cb0d9szrimlflxh67ad74cqfi6yc2cr1bcl17c6b23ccnyqbq73";
+       sha256 = "e3e085bd656c8865d80994ad909960de448719394d1d033b75b4c6fc756a6031";
        libraryHaskellDepends = [ base ghc ];
        libraryToolDepends = [ cpphs happy ];
        homepage = "https://github.com/gibiansky/IHaskell";
@@ -55344,7 +55532,7 @@ self: {
      mkDerivation {
        pname = "ghc-paths";
        version = "0.1.0.9";
-       sha256 = "0ibrr1dxa35xx20cpp8jzgfak1rdmy344dfwq4vlq013c6w8z9mg";
+       sha256 = "afa68fb86123004c37c1dc354286af2d87a9dcfb12ddcb80e8bd0cd55bc87945";
        libraryHaskellDepends = [ base ];
        description = "Knowledge of GHC's installation directories";
        license = stdenv.lib.licenses.bsd3;
@@ -55357,7 +55545,7 @@ self: {
      mkDerivation {
        pname = "ghc-pkg-autofix";
        version = "0.2.0.1";
-       sha256 = "0rm7vksfzwkpby1b8k2v745d7bylxbgspjhhfvdxc40a3rix8sz7";
+       sha256 = "e76bd4631e0a10d6db7610caabdfead4afd30a395b4cb4825f77f2eff4dca766";
        isLibrary = false;
        isExecutable = true;
        executableHaskellDepends = [
@@ -55375,7 +55563,7 @@ self: {
      mkDerivation {
        pname = "ghc-pkg-lib";
        version = "0.3";
-       sha256 = "1m2ny3f5i1ihvpq0vigpzj701gzrbzdz5h7f41qn37ikp9a6kd5a";
+       sha256 = "aab46954ba339e617120eec0f2db5ff9bf008efcf7c50df0dd308658dcf056d4";
        libraryHaskellDepends = [
          base Cabal directory filepath ghc ghc-paths
        ];
@@ -55390,7 +55578,7 @@ self: {
      mkDerivation {
        pname = "ghc-prim";
        version = "0.4.0.0";
-       sha256 = "1w3hkl1xyfi67kh65gqn99pinxrfqjl2s08yg0010r907w3qys31";
+       sha256 = "61688f073f20651000781e012da8c42e771b6f4a16bf62e03c263adf039d70f0";
        libraryHaskellDepends = [ rts ];
        description = "GHC primitives";
        license = stdenv.lib.licenses.bsd3;
@@ -55401,7 +55589,7 @@ self: {
      mkDerivation {
        pname = "ghc-prof-flamegraph";
        version = "0.1.2.1";
-       sha256 = "0nzk3h65iqnmva7n2m00kknllqbmg95xav4g5rpizhridpivg9hb";
+       sha256 = "0ba6b7e36d31c31f6f2e8f6cd54b7a75614aed9c0054618fdad5e2580c1cf35b";
        isLibrary = true;
        isExecutable = true;
        libraryHaskellDepends = [ base ];
@@ -55415,7 +55603,7 @@ self: {
      mkDerivation {
        pname = "ghc-server";
        version = "1.2";
-       sha256 = "1hg5iddlh87hir5vqjby2bihah4xcyarsfcgff3gd8l2h7mqi2dn";
+       sha256 = "b68988eb8182a2f686738f399d95679d4005e3127e49bc4b8ef020485b8be5c1";
        description = "None";
        license = stdenv.lib.licenses.bsd3;
        hydraPlatforms = stdenv.lib.platforms.none;
@@ -55426,7 +55614,7 @@ self: {
      mkDerivation {
        pname = "ghc-simple";
        version = "0.1.2.1";
-       sha256 = "0hk3sii5d6mjry28gaipl45c6si82rhdsd43cq130fk9m0xzl9hf";
+       sha256 = "0e26fa3ba8693a3002668334dd6016286ac30aa137aa8784cfb29a5662d46342";
        libraryHaskellDepends = [ base ghc ghc-paths ];
        homepage = "https://github.com/valderman/ghc-simple";
        description = "Simplified interface to the GHC API";
@@ -55438,7 +55626,7 @@ self: {
      mkDerivation {
        pname = "ghc-srcspan-plugin";
        version = "0.2.1.0";
-       sha256 = "1cb669zhgibv9x7c924333kyzqa728031invr0smdnv0a2mgi2wi";
+       sha256 = "918bf8aa5060db5635c8dbc630001247e1efe7188388c44e4f7bc5077f3266b1";
        libraryHaskellDepends = [ array base containers ghc hpc ];
        description = "Generic GHC Plugin for annotating Haskell code with source location data";
        license = stdenv.lib.licenses.bsd3;
@@ -55449,7 +55637,7 @@ self: {
      mkDerivation {
        pname = "ghc-syb";
        version = "0.2.0.0";
-       sha256 = "0rwx7l89r5yfi1187c0zgx1ph2rsagyvrizb1c0vnbyrwhpbslh0";
+       sha256 = "0052bd2ee4d92fbb010bebc7bcfd533a0b78437f1fb0834288ce979c103d9d67";
        libraryHaskellDepends = [ base ghc ];
        jailbreak = true;
        homepage = "http://github.com/nominolo/ghc-syb";
@@ -55463,7 +55651,7 @@ self: {
      mkDerivation {
        pname = "ghc-syb-utils";
        version = "0.2.3";
-       sha256 = "0rxwdivpcppwzbqglbrz8rm9f4g1gmba9ij7p7aj3di9x37kzxky";
+       sha256 = "7ef63fcfe829b621d5b947c6a4567de111976a463f2ffaf0fafc5e76776cbc67";
        libraryHaskellDepends = [ base ghc syb ];
        homepage = "http://github.com/nominolo/ghc-syb";
        description = "Scrap Your Boilerplate utilities for the GHC API";
@@ -55475,7 +55663,7 @@ self: {
      mkDerivation {
        pname = "ghc-tcplugins-extra";
        version = "0.1";
-       sha256 = "1lr3x3vg5aw8fjwz7skcisqg2hsls16abxp8p4w4940qnw5zznkf";
+       sha256 = "6edaff0bb718904438b9e8f6a54cd05443f1b08e6ceaf3b97488abf2f6e823d3";
        libraryHaskellDepends = [ base ghc ];
        homepage = "http://www.clash-lang.org/";
        description = "Utilities for writing GHC type-checker plugins";
@@ -55487,7 +55675,7 @@ self: {
      mkDerivation {
        pname = "ghc-time-alloc-prof";
        version = "0.0.0";
-       sha256 = "0a3800pngsbjc0fxpbqps9caa7gp5956wfyh18ybarlpi0ah7d7r";
+       sha256 = "f9b40315889766b53c0ad03b6e4a2af71da558d217afdb1d6072e9672f006828";
        isLibrary = true;
        isExecutable = true;
        libraryHaskellDepends = [ attoparsec base containers text time ];
@@ -55503,7 +55691,7 @@ self: {
      mkDerivation {
        pname = "ghc-typelits-natnormalise";
        version = "0.3";
-       sha256 = "169imqq6hch4lamsgz8s3cnszysvxvw9xlgd5bjldq09zvpy7i8r";
+       sha256 = "19c5e3effe09e046e52aedd19ef8ee5bfbaf2d1b1afda7aba204326830ae3199";
        libraryHaskellDepends = [ base ghc ghc-tcplugins-extra ];
        testHaskellDepends = [ base tasty tasty-hunit ];
        homepage = "http://www.clash-lang.org/";
@@ -55519,7 +55707,7 @@ self: {
      mkDerivation {
        pname = "ghc-vis";
        version = "0.7.2.7";
-       sha256 = "0kxkmbp71yx5mskzpcyjd8s2yq01q1q6dxmqzmwg6naalcpcbswv";
+       sha256 = "9bebc52ea34a59f378fdb8f66670c001602f346ad2b3fba7aea5fb70eeaab34f";
        libraryHaskellDepends = [
          base cairo containers deepseq fgl ghc-heap-view graphviz gtk mtl
          svgcairo text transformers xdot
@@ -55535,7 +55723,7 @@ self: {
      mkDerivation {
        pname = "ghci-diagrams";
        version = "0.1.1";
-       sha256 = "1jlym5k2d43avkgw7ff3pdaad5j2q5yq803cy74bgy0z69x77v1w";
+       sha256 = "3cec737a321ff8b7c8f16c00847dc14296a654bbc3b9c3dfdc6a902666a99eca";
        libraryHaskellDepends = [ base cairo colour diagrams gtk ];
        jailbreak = true;
        description = "Display simple diagrams from ghci";
@@ -55549,7 +55737,7 @@ self: {
      mkDerivation {
        pname = "ghci-haskeline";
        version = "0.2";
-       sha256 = "01j2ryxxmd5zzdv1ayvzibi3njl3nbn0ypxmafvglrvn2zwnmsqy";
+       sha256 = "1eeb6af9177667fab653b55f0fecb2834a3be28a7f7b1576fbbfb4dabbcf4206";
        isLibrary = false;
        isExecutable = true;
        executableHaskellDepends = [
@@ -55568,7 +55756,7 @@ self: {
      mkDerivation {
        pname = "ghci-lib";
        version = "0.1.0.0";
-       sha256 = "06lg1czsr6k5h18aks33p2kbahiidhv7xsrv7n1fcvqsgglzgk3z";
+       sha256 = "7fccf7e97b1a6fe6823d3beb7e366c3142b5a6b863e8a95080659aac3f0b8f1a";
        libraryHaskellDepends = [ base ghc MissingH ];
        jailbreak = true;
        homepage = "http://github.com/gibiansky/IHaskell";
@@ -55583,7 +55771,7 @@ self: {
      mkDerivation {
        pname = "ghci-ng";
        version = "7.6.3.5";
-       sha256 = "01ghvv0y1qif19v8dlbspxyb9m5zag832sx2k3qyhqh8iccnr14x";
+       sha256 = "9d846c198b0862e8f198a26b31d053bfd4b47cbf7ad186760a2ee2e0c1def005";
        isLibrary = false;
        isExecutable = true;
        executableHaskellDepends = [
@@ -55602,7 +55790,7 @@ self: {
      mkDerivation {
        pname = "ghci-pretty";
        version = "0.0.2";
-       sha256 = "01syl5c6ana4m8d3jc5pbi64zf3c4l2x0r7jwkizm7kymszmbns5";
+       sha256 = "45db55bfae7e9efae3e4f264d005256cb84f4c5cb730391aaa44596558a15e07";
        libraryHaskellDepends = [ base hscolour ipprint ];
        homepage = "https://github.com/larskuhtz/ghci-pretty";
        description = "colored pretty-printing within ghci";
@@ -55617,7 +55805,7 @@ self: {
      mkDerivation {
        pname = "ghcid";
        version = "0.5";
-       sha256 = "1b5d70f1422lwn8xmcdn6b52qwqp3aax0h7q3zfnkv2ima18yk6l";
+       sha256 = "d44c8f82aa51ec69dd1ff840d0951a17732cca32b6b1da91e55408121c38adac";
        isLibrary = true;
        isExecutable = true;
        libraryHaskellDepends = [
@@ -55641,7 +55829,7 @@ self: {
      mkDerivation {
        pname = "ghcjs-codemirror";
        version = "0.0.0.1";
-       sha256 = "04x5h0i4fgyc2c5ihrnk0w3l1f3avvcl115zlnich93nillgbnfw";
+       sha256 = "dcd9f5288d7624c8a2a5bf8440d9de6ab8400707d366180b13cc3f472280a513";
        libraryHaskellDepends = [ base ];
        homepage = "https://github.com/ghcjs/CodeMirror";
        description = "Installs CodeMirror JavaScript files";
@@ -55649,27 +55837,29 @@ self: {
      }) {};
 
   "ghcjs-dom" = callPackage
-    ({ mkDerivation, base, ghcjs-base, mtl, text }:
+    ({ mkDerivation, base, glib, gtk3, text, transformers, webkitgtk3
+     }:
      mkDerivation {
        pname = "ghcjs-dom";
-       version = "0.1.1.3";
-       sha256 = "0pdxb2s7fflrh8sbqakv0qi13jkn3d0yc32xhg2944yfjg5fvlly";
-       libraryHaskellDepends = [ base ghcjs-base mtl text ];
-       jailbreak = true;
+       version = "0.2.1.0";
+       sha256 = "a99e19252bb56f4dc56a3778d81af006ce1f403e770ec0bc3f1ff409a37a7e81";
+       libraryHaskellDepends = [
+         base glib gtk3 text transformers webkitgtk3
+       ];
        description = "DOM library that supports both GHCJS and WebKitGTK";
        license = stdenv.lib.licenses.mit;
-       broken = true;
-     }) { ghcjs-base = null;};
+     }) {};
 
   "ghcjs-dom-hello" = callPackage
     ({ mkDerivation, base, ghcjs-dom, mtl }:
      mkDerivation {
        pname = "ghcjs-dom-hello";
        version = "1.2.0.0";
-       sha256 = "0jbn6nhaq7h01wh1limsb4xzgwp7i71922gql5mz916kv6wa2cgl";
+       sha256 = "f431a1b8d9d384f46ba1f80991c289e7f2f73b59ba461a200f001eaca0357649";
        isLibrary = false;
        isExecutable = true;
        executableHaskellDepends = [ base ghcjs-dom mtl ];
+       jailbreak = true;
        homepage = "https://github.com/ghcjs/ghcjs-dom-hello";
        description = "GHCJS DOM Hello World, an example package";
        license = stdenv.lib.licenses.mit;
@@ -55681,7 +55871,7 @@ self: {
      mkDerivation {
        pname = "ghcjs-websockets";
        version = "0.3.0.5";
-       sha256 = "1km7hdpa036hqxzddwxw23zaq1sjvbmjmqdp4fzdz62azp6g4ygq";
+       sha256 = "f879f2ccfd4a98dfbe23b7e12aebda5207acfe10bcf3d67ec7d00ca06e83a7ce";
        libraryHaskellDepends = [
          base base64-bytestring binary bytestring text
        ];
@@ -55700,7 +55890,7 @@ self: {
      mkDerivation {
        pname = "ghclive";
        version = "0.1.0.2";
-       sha256 = "0rnmv09sl5pj9y8hr7s8hwh23zfm4j8nsn524hpj73diwmzf5fh8";
+       sha256 = "08bae27ee5b18d232f24a2586d9124d5fd212087489f0c914ff216aa13d8d566";
        isLibrary = true;
        isExecutable = true;
        libraryHaskellDepends = [
@@ -55724,7 +55914,7 @@ self: {
      mkDerivation {
        pname = "ghczdecode";
        version = "0.1.0.1";
-       sha256 = "1yn6blszccmgv0zrq5cxv6kww47j7pwgywgy7piz6is44ab5s5l9";
+       sha256 = "89165d96224447f3e33dfe71fff83df210cea7d99d159c3fd8af32f6355dc6fa";
        isLibrary = false;
        isExecutable = true;
        executableHaskellDepends = [ base zenc ];
@@ -55741,7 +55931,7 @@ self: {
      mkDerivation {
        pname = "ght";
        version = "0.4.0.1";
-       sha256 = "03lrn3s79gxdn5fwh6cbp46k303662fnisjs7qp1yf8c66vxi8wc";
+       sha256 = "8ca3d8b7310c391f2e3e5aea689d306680310db98b19c85db1adbf74f4b0990e";
        isLibrary = true;
        isExecutable = true;
        libraryHaskellDepends = [
@@ -55762,7 +55952,7 @@ self: {
      mkDerivation {
        pname = "gimlh";
        version = "0.1.3.0";
-       sha256 = "1hxdgff1rw3yp3a2p26bj6034jgc458bdzma1xkbh9pahlhwhs2l";
+       sha256 = "5468c82185ea26b8660faafeb65021ec49328091cb882bd4b87ef01c9c7badc3";
        libraryHaskellDepends = [ base split ];
        homepage = "https://github.com/gazay/gimlh";
        description = "Haskell parser for GIML";
@@ -55778,7 +55968,7 @@ self: {
      mkDerivation {
        pname = "ginsu";
        version = "0.8.1.1";
-       sha256 = "0qvhdzmqi1pppfcfld27mjzbzj9h6yaz2n7b6inp0ybr80vm6x4w";
+       sha256 = "9c745337407979706d34eb58f1953730c9bfbeac4734ea98bbf78688eb6f7063";
        isLibrary = false;
        isExecutable = true;
        executableHaskellDepends = [
@@ -55800,7 +55990,7 @@ self: {
      mkDerivation {
        pname = "gio";
        version = "0.13.1.0";
-       sha256 = "1qxbdjznxz56jw108cc78lzwh1r4g8l2jcaz2bh2akc1nwhv2x5j";
+       sha256 = "b274b121b7814d25e0125f3129287a2407c83f458731040297a6fc6ebf6cabe3";
        libraryHaskellDepends = [
          array base bytestring containers glib mtl
        ];
@@ -55818,7 +56008,7 @@ self: {
      mkDerivation {
        pname = "gipeda";
        version = "0.1.2.1";
-       sha256 = "0wra67d2jdnx463vw8hf2yzzwmnkbs9791x5mgarlgc6zj68g926";
+       sha256 = "46a4878cfc863d9ad5aba58774925ed356febf170e22be8721dd3629da312a73";
        isLibrary = false;
        isExecutable = true;
        executableHaskellDepends = [
@@ -55839,7 +56029,7 @@ self: {
      mkDerivation {
        pname = "gist";
        version = "0.1";
-       sha256 = "1jgdhga0qjbc6kx1nr5yngcx560rlxiil3cnsmzh8mwazbs3yyl1";
+       sha256 = "817a3ff4fa8a57047fd5960d1a63a71998d2d9b3be641bfa346c490cd483edc9";
        isLibrary = false;
        isExecutable = true;
        executableHaskellDepends = [
@@ -55859,7 +56049,7 @@ self: {
      mkDerivation {
        pname = "git-all";
        version = "1.5.0";
-       sha256 = "0wfvfrmwn81myiaa5x4bw6ypyk0hljaaf3f7b9rnpxwk291dwc3z";
+       sha256 = "7f30de421293f76b735ac70da794a4104c7fbde18bf4a254f43520cb6b76db71";
        isLibrary = false;
        isExecutable = true;
        executableHaskellDepends = [
@@ -55894,7 +56084,7 @@ self: {
      mkDerivation {
        pname = "git-annex";
        version = "5.20150731";
-       sha256 = "18akv0xj4mf2ypzzd12briv0rw9ba7xw8k1qxvl10m9z4x6gvvm2";
+       sha256 = "a2eefd4c273f5510e8ee384cc4fb512bf10c76cc4b84f6fff5c255223bd853a1";
        configureFlags = [ "-fassistant" "-fproduction" ];
        isLibrary = false;
        isExecutable = true;
@@ -55938,7 +56128,7 @@ self: {
      mkDerivation {
        pname = "git-checklist";
        version = "1.0.0.0";
-       sha256 = "1q4fbvpdjca5k530dcm6yspsgzy60dx7nimar2fkm8s086qsf662";
+       sha256 = "c218a7b14140a33a9dc8aa467b7a03c6ffa7aff6a6b20646994531d9ee5e8ee0";
        isLibrary = false;
        isExecutable = true;
        executableHaskellDepends = [
@@ -55958,7 +56148,7 @@ self: {
      mkDerivation {
        pname = "git-date";
        version = "0.2.2";
-       sha256 = "0yld8p7jgq0ihz21nkmirz3ynwi0mgrlgzx727kim59hplm6xrcl";
+       sha256 = "94e56e2abd30951ae711a7ff47f3ab2072ebc7cfb14e1bc48711e027cf458d7a";
        libraryHaskellDepends = [ base bytestring time utf8-string ];
        testHaskellDepends = [
          base bytestring old-locale QuickCheck test-framework
@@ -55977,7 +56167,7 @@ self: {
      mkDerivation {
        pname = "git-embed";
        version = "0.1.0";
-       sha256 = "0yrx06ay25zsk90djr4mrqnn80xp3w6cmkciqavrmijf25fc5jvn";
+       sha256 = "76cbc25c114ec69ab7c291cdca0c1fb703642dce9564d9409afa17e195013d7b";
        libraryHaskellDepends = [
          base directory filepath process template-haskell
        ];
@@ -55993,7 +56183,7 @@ self: {
      mkDerivation {
        pname = "git-freq";
        version = "0.0.2";
-       sha256 = "1vi87kdb58d7yg5bc97nkz2lcnfxsmn4w66m2m52rbfi8xnqkl6l";
+       sha256 = "d4d0896d47d1ad2c4a15d5184e6cd5dd5946c59ff624b6caf3a7a1b2da3c28ee";
        isLibrary = false;
        isExecutable = true;
        executableHaskellDepends = [
@@ -56015,7 +56205,7 @@ self: {
      mkDerivation {
        pname = "git-gpush";
        version = "3.1.0.1";
-       sha256 = "13m95j227mvl7facqjlwcz11kd88ibhr7fwf5ph81wppyic8136g";
+       sha256 = "cf8c8058f4f7f280e02d8ebb93e18a08b519c2679c4acc943b74d723842ca98e";
        isLibrary = false;
        isExecutable = true;
        executableHaskellDepends = [
@@ -56039,7 +56229,7 @@ self: {
      mkDerivation {
        pname = "git-monitor";
        version = "3.1.1.4";
-       sha256 = "00byw8y9av60rwacp4006kv7qb9sc26j1f82cz1ngr42nfx9955c";
+       sha256 = "ac9494bab382e467c36702b9208d603a2d7cf6340090cb14cfc06c953ce27e01";
        isLibrary = false;
        isExecutable = true;
        executableHaskellDepends = [
@@ -56061,7 +56251,7 @@ self: {
      mkDerivation {
        pname = "git-object";
        version = "0.0.2";
-       sha256 = "1hwsl5n6im6b13iy1whvgd3avax9xb81maaan2vf3r474r3321jm";
+       sha256 = "550631462687e4e1b6b04aa91ad0eaa9abad467b1bf2e0e308cbd4686ca19ac3";
        libraryHaskellDepends = [
          attoparsec attoparsec-enumerator base bytestring directory
          enumerator filepath zlib-enum
@@ -56080,7 +56270,7 @@ self: {
      mkDerivation {
        pname = "git-repair";
        version = "1.20150106";
-       sha256 = "19hgrp2kjqhcw53rf9payiajzfz6d7jqf2m2mnmbjv2zpr9y74dp";
+       sha256 = "b791e353be5f6cb9aaada20a87e569e6bb2f55f4ea269747e10c6239c5cd0fa6";
        isLibrary = false;
        isExecutable = true;
        executableHaskellDepends = [
@@ -56102,7 +56292,7 @@ self: {
      mkDerivation {
        pname = "git-sanity";
        version = "0.1.0.0";
-       sha256 = "1yywxganjl7rj4lf3pp1fh4adjhp3110l4az1w76r3rywql6v8w2";
+       sha256 = "82a36d28e63e8f6c0e0f5f110a421817caa60874e1dee12891f95069d5ebdcfb";
        isLibrary = true;
        isExecutable = true;
        libraryHaskellDepends = [
@@ -56125,7 +56315,7 @@ self: {
      mkDerivation {
        pname = "git-vogue";
        version = "0.2.0.1";
-       sha256 = "1l1ly1wkfidpzxr68z0qyfyj0pq7wdn534m4ks0hvh45sp6v569c";
+       sha256 = "2c99b2cdd585c00d819ea492516ce3075f20bdf3187c6472ffb7453779f034d0";
        isLibrary = true;
        isExecutable = true;
        libraryHaskellDepends = [
@@ -56155,7 +56345,7 @@ self: {
      mkDerivation {
        pname = "gitcache";
        version = "0.2";
-       sha256 = "0vd580k1cxipycyyjpzhwvv6q70nf6fjfrsxp3gz3gy4iqzzssgy";
+       sha256 = "fe69fd3f8ec4bff1dfb85d67279d71161c6cf6e6f05fe93df33776162640a56d";
        isLibrary = false;
        isExecutable = true;
        executableHaskellDepends = [
@@ -56174,7 +56364,7 @@ self: {
      mkDerivation {
        pname = "gitdo";
        version = "0.1.0.0";
-       sha256 = "0krna2rqdscnrd86d7ipq4gad7dzk1w5lnk8757a13qnd5jqrxdl";
+       sha256 = "b4f58c6569168fa04e39685a5a7898bf9da61ec1379e6650cb96e986b350364f";
        isLibrary = false;
        isExecutable = true;
        executableHaskellDepends = [
@@ -56198,7 +56388,7 @@ self: {
      mkDerivation {
        pname = "github";
        version = "0.13.2";
-       sha256 = "1i07jwhkzaxia98a3fjnm3hynh4mjdhy9rzdh9chdlram5wqk87z";
+       sha256 = "ffa08979a92ad3065982ede7e461939540ebe1a856baa15052b1ab3f219707c4";
        libraryHaskellDepends = [
          aeson attoparsec base base16-bytestring byteable bytestring
          case-insensitive conduit containers cryptohash data-default failure
@@ -56225,7 +56415,7 @@ self: {
      mkDerivation {
        pname = "github-backup";
        version = "1.20150807";
-       sha256 = "19x8716wdhrj3nv4pgz4ncmnfnids8wjirkp3jkw5sd6fnx6q8sj";
+       sha256 = "52236cba75a6e9c2a71c77e62839d22d5a672bb3e4bf4bb61d32c3c64d38a8a7";
        isLibrary = false;
        isExecutable = true;
        executableHaskellDepends = [
@@ -56247,7 +56437,7 @@ self: {
      mkDerivation {
        pname = "github-post-receive";
        version = "1.2.0.1";
-       sha256 = "14vd9rnr3x3wasnc6w6d3kcs5dnka902n9cbxblqdryc8l7p360q";
+       sha256 = "1898710f45cce786e9ea8b252b4052d3b6a2d91ccd70c3ac567cf4916d4e6d93";
        libraryHaskellDepends = [
          aeson base bytestring containers email-validate http-types text wai
          wai-logger warp
@@ -56262,7 +56452,7 @@ self: {
      mkDerivation {
        pname = "github-types";
        version = "0.1.0.5";
-       sha256 = "0lymbga0rwhni0rrjdla6fz5a1gz8zclf421rdiz5cnnh8lbd97i";
+       sha256 = "f1a4b62882d6b2f263cb411047d947ff0555be338a3699338816f20cd45bd553";
        libraryHaskellDepends = [ aeson base text ];
        description = "Type definitions for objects used by the GitHub v3 API";
        license = "unknown";
@@ -56273,7 +56463,7 @@ self: {
      mkDerivation {
        pname = "github-utils";
        version = "0.1.0";
-       sha256 = "1d7g1rzaqg19bc41vqvcdxdi37z9h7ajy3khsqa4pwbfavj412a5";
+       sha256 = "458940e4566ef14b14d6700e2fd581e99f115b6f6ce31d085b293cac7e0eefb4";
        libraryHaskellDepends = [ base basic-prelude github text ];
        jailbreak = true;
        homepage = "https://github.com/greenrd/github-utils";
@@ -56288,7 +56478,7 @@ self: {
      mkDerivation {
        pname = "github-webhook-handler";
        version = "0.0.3";
-       sha256 = "1dwq1fccgnngh97kxyb3kp4f6xr8dsydlgkydl28lxkbwcapk39h";
+       sha256 = "308d7915e36b768a046d7e3edabc6e2877e3c89d63f93e4f82cfdac7980b98b7";
        libraryHaskellDepends = [
          aeson base bytestring cryptohash github-types text transformers
          uuid vector
@@ -56304,7 +56494,7 @@ self: {
      mkDerivation {
        pname = "github-webhook-handler-snap";
        version = "0.0.3";
-       sha256 = "0v9wman214rj81dfvkgng195s3gsvy5d7csshqwcw9x10giby9iy";
+       sha256 = "3e26bfe203a127ce38865ab3d38adffa0d5d5278f6cded5a40329320acaa3c6d";
        libraryHaskellDepends = [
          base bytestring case-insensitive github-types
          github-webhook-handler snap-core uuid
@@ -56320,7 +56510,7 @@ self: {
      mkDerivation {
        pname = "gitignore";
        version = "1.0.1";
-       sha256 = "03sjhlsp7xswciypp7sw9x0b3h6m7fvc2dk5k0a3bibflns2zgql";
+       sha256 = "14bf2fb4a56ec53514986536c1b63bd5c0b1404f5c9f7b7d645cf7733585520f";
        isLibrary = false;
        isExecutable = true;
        executableHaskellDepends = [
@@ -56346,7 +56536,7 @@ self: {
      mkDerivation {
        pname = "gitit";
        version = "0.11.1";
-       sha256 = "06wxy4hpbkbmlwrgnsxbr47k2a791094gzqsmlqzhsq6wa1bgfr9";
+       sha256 = "29bbb782e2066bf831ad1aff471208e928310fc9ab6bfb32a775cd7521f19d1b";
        isLibrary = true;
        isExecutable = true;
        libraryHaskellDepends = [
@@ -56376,7 +56566,7 @@ self: {
      mkDerivation {
        pname = "gitlib";
        version = "3.1.0.2";
-       sha256 = "05l5i2s0212sx3bzw6r9njanjv1q1gmqc7f6g1z1sy9fibyxcwah";
+       sha256 = "5071d6fd8a2e791d7e78c61d86eb0b386c6995b4291bfed7e85a0401b4888516";
        libraryHaskellDepends = [
          base base16-bytestring bytestring conduit conduit-combinators
          containers directory exceptions filepath hashable lifted-async
@@ -56398,7 +56588,7 @@ self: {
      mkDerivation {
        pname = "gitlib-cmdline";
        version = "3.1.0.2";
-       sha256 = "1dridps65mw06r9slza80vl21f5n1kq1if7gnwcrbagicvy45p0k";
+       sha256 = "13dc42fc66f1a99519b7efb818f00cb6b820e806487daa533680d762f46d31b7";
        libraryHaskellDepends = [
          base bytestring conduit conduit-combinators containers directory
          exceptions gitlib monad-control mtl old-locale parsec
@@ -56421,7 +56611,7 @@ self: {
      mkDerivation {
        pname = "gitlib-cross";
        version = "3.1.0";
-       sha256 = "0iack7kafbfa45s9k7ypbafapahrifh2grjdzyrhvzjg767l3i1h";
+       sha256 = "30c4418f394ffe0db3ff4de627a08b19aaab9c5ad79f997421ca2da7e6994c45";
        libraryHaskellDepends = [ base ];
        testHaskellDepends = [
          base gitlib gitlib-cmdline gitlib-libgit2 gitlib-test hspec
@@ -56444,7 +56634,7 @@ self: {
      mkDerivation {
        pname = "gitlib-libgit2";
        version = "3.1.0.5";
-       sha256 = "1xnzks7jwl7d0xf7qgz9gmqf4n1yn3qvjrs73prla8n063kgdh95";
+       sha256 = "25c1f6e630c02245f31d4767b9f1b03e58e2707de93f7c5c07ed502e8f9edff6";
        libraryHaskellDepends = [
          base bytestring conduit conduit-combinators containers directory
          exceptions fast-logger filepath gitlib hlibgit2 lifted-async
@@ -56473,7 +56663,7 @@ self: {
      mkDerivation {
        pname = "gitlib-s3";
        version = "3.1.0.1";
-       sha256 = "1vcx26dny7pj4lqn1rli3vqad2xh7vkqj86c6i7hyskilgbs6n8m";
+       sha256 = "1559a3d7a3716a0f4f34cc2089e73eb08ba6f01e91e6603125f21e6f9b119ded";
        libraryHaskellDepends = [
          aeson attempt aws base bifunctors binary bytestring conduit
          conduit-combinators data-default directory exceptions filepath
@@ -56496,7 +56686,7 @@ self: {
      mkDerivation {
        pname = "gitlib-sample";
        version = "3.1.0";
-       sha256 = "1px3yskxkr1kmgwfw1jdrbgjgkz8wxznz56g0gn3gqx63haxifmc";
+       sha256 = "acbad8151ca6e337ec03cf946f7fe7e8cf27dfca4d06eef8ab33e4d9a7f6a3df";
        libraryHaskellDepends = [
          base exceptions gitlib mtl transformers
        ];
@@ -56512,7 +56702,7 @@ self: {
      mkDerivation {
        pname = "gitlib-test";
        version = "3.1.0.3";
-       sha256 = "07r970d6m15gri6xim71kl2vvml85jlb0vc51zb67gfsd6iby2py";
+       sha256 = "fe0abfa269dabd63d60f856db0a82c88d6bd059de1d4d84dccaf846a1a38291f";
        libraryHaskellDepends = [
          base bytestring conduit conduit-combinators exceptions gitlib hspec
          hspec-expectations HUnit monad-control tagged text time
@@ -56530,7 +56720,7 @@ self: {
      mkDerivation {
        pname = "gitlib-utils";
        version = "1.2.0";
-       sha256 = "081vagmlf6lkh7qqr9y42nl8c1ds011s05a567dsw6ckf166wshn";
+       sha256 = "166a6e4c709319aedb314515a04300ba0586a815c4a78cf181931a47eb533b20";
        libraryHaskellDepends = [
          base bytestring conduit data-default failure gitlib hex lifted-base
          system-fileio system-filepath tagged text transformers
@@ -56547,8 +56737,8 @@ self: {
      }:
      mkDerivation {
        pname = "gitrev";
-       version = "1.0.0";
-       sha256 = "05jxzhpjzd9n5sdaa8d9y2zczs2v5w4n9718wl411ghvx54jhnfd";
+       version = "1.1.0";
+       sha256 = "aabc77851c0de49bd3495fb2cf933170a5d566a19cfb230e1cc758f5775de120";
        libraryHaskellDepends = [
          base directory filepath process template-haskell
        ];
@@ -56565,7 +56755,7 @@ self: {
      mkDerivation {
        pname = "gitson";
        version = "0.5.1";
-       sha256 = "175j2pkc3cb37h3vilb99i782as9yg68nacs2ysnp1m7hrxvvyjy";
+       sha256 = "5efabd7b86a7866bb5179a298bccf3492b814e4c69d1b8073c63b1c1e615b29c";
        libraryHaskellDepends = [
          aeson aeson-pretty base bytestring directory errors filepath flock
          monad-control process transformers
@@ -56586,7 +56776,7 @@ self: {
      mkDerivation {
        pname = "gl";
        version = "0.7.7";
-       sha256 = "0lsz8gq3cmkh6s9hhxnr3m95ibra9y63230jyqhwk9wamid2x2pg";
+       sha256 = "ef8a2e5aac8aa7c921f6120c318c4f2aaf58521dd976089336705636f0435f53";
        libraryHaskellDepends = [
          base containers directory filepath fixed half hxt split
          transformers
@@ -56601,7 +56791,7 @@ self: {
      mkDerivation {
        pname = "gl-capture";
        version = "0.1.0.0";
-       sha256 = "0pcan0fpb1mfwda69f8z8pdrdav79rdm31yvmrk98dca7al7k583";
+       sha256 = "039579a83a8a359466aedb87515b4e67ab96db451fb96454e3ae86751db08a5d";
        libraryHaskellDepends = [ base bytestring OpenGL ];
        description = "simple image capture from OpenGL";
        license = stdenv.lib.licenses.bsd3;
@@ -56612,7 +56802,7 @@ self: {
      mkDerivation {
        pname = "glade";
        version = "0.12.5.0";
-       sha256 = "0dbl7y5rdwzcham16iym9cikfyaphzr1rqcsni9ab6s2368a1vkr";
+       sha256 = "79eea09019429ba552b49ae11cf287577937234bd54713aa82ecf3968b3f7435";
        libraryHaskellDepends = [ base glib gtk ];
        libraryPkgconfigDepends = [ libglade ];
        libraryToolDepends = [ gtk2hs-buildtools ];
@@ -56628,7 +56818,7 @@ self: {
      mkDerivation {
        pname = "gladexml-accessor";
        version = "0.0";
-       sha256 = "06kzakvssmldjgx0s8qm0a3cd9glmwrdnh690sv708jcvg8x45y3";
+       sha256 = "c317d2d1db4c2270b606c940db32aff4a5c6860215230dfa938d56adf7547f1a";
        libraryHaskellDepends = [ base glade HaXml template-haskell ];
        description = "Automagically declares getters for widget handles in specified interface file";
        license = stdenv.lib.licenses.bsd3;
@@ -56643,7 +56833,7 @@ self: {
      mkDerivation {
        pname = "glambda";
        version = "1.0";
-       sha256 = "01bqh7g76a02qvzqm8di6ig84k0v7crd9aljsg339h7d3y7grxhf";
+       sha256 = "0ef6fc8e1fedc034c6d392aad4323b1b4c825e34b1a18affc6022873de817805";
        isLibrary = true;
        isExecutable = true;
        libraryHaskellDepends = [
@@ -56665,7 +56855,7 @@ self: {
      mkDerivation {
        pname = "glapp";
        version = "0.1.0.1";
-       sha256 = "076v7h0p91dj8hx110vm0li2njsc8p5dgcf6zxk721mdx5xkymhz";
+       sha256 = "1f563f7be9ad067166ffc6b1d7ca454c4b2b22057583103a44b28574013cdb1c";
        isLibrary = true;
        isExecutable = true;
        libraryHaskellDepends = [ base containers GLFW-b lens mtl OpenGL ];
@@ -56683,7 +56873,7 @@ self: {
      mkDerivation {
        pname = "glasso";
        version = "0.1.0";
-       sha256 = "1ibkvgfighkfn3v27cqy7wwhvlhmnbi1dvyycwbfba6rfy9w6gb8";
+       sha256 = "683dc39377d9a8e51667deef16e2b215d20d393f1eb323f6b06ec217dddb73c5";
        revision = "1";
        editedCabalFile = "abf1b0cb0b9cc8c106f833a2549e2be95111a58296d6cc01c39e18c03abef797";
        libraryHaskellDepends = [ base vector ];
@@ -56698,7 +56888,7 @@ self: {
      mkDerivation {
        pname = "glib";
        version = "0.13.2.1";
-       sha256 = "1pxc2a0hnjaryf3f8d410rnhxmc7byx6lwcypgqg4zma6r3qhqwp";
+       sha256 = "9763884736aa7ef2f0bb9e716aba5f87d50e6d068134e486f359490b8112acdf";
        libraryHaskellDepends = [
          base bytestring containers text utf8-string
        ];
@@ -56714,7 +56904,7 @@ self: {
      mkDerivation {
        pname = "glider-nlp";
        version = "0.1";
-       sha256 = "1i604gj3ssabr3dcas6gfh20d4psqwl1j4d7wk4p3gy0hvjvr8fb";
+       sha256 = "cba1bce586c0bf71c9e4a7111928c7fa92060474cf68c5dac84b693de423c0c4";
        libraryHaskellDepends = [ base containers text ];
        testHaskellDepends = [ base Cabal containers HUnit text ];
        jailbreak = true;
@@ -56729,7 +56919,7 @@ self: {
      mkDerivation {
        pname = "glintcollider";
        version = "0.0.2";
-       sha256 = "1xgx02cxvpc8sv99wl44lpzbv9cc87nnihbpalmddb71mwrmj4ji";
+       sha256 = "51125933afe1acd62a5577c168ed418ca5bdfea584509ed2d688dddd9900fdf5";
        isLibrary = false;
        isExecutable = true;
        executableHaskellDepends = [ base ppm split ];
@@ -56742,7 +56932,7 @@ self: {
      mkDerivation {
        pname = "gll";
        version = "0.2.0.3";
-       sha256 = "1w2z5071idac1jn367dymphqvayd580jlnhapmfrd3s40b6z6xaf";
+       sha256 = "4e75f3cd02448f965dbd0a5a2a012acdab8de1adbe1d33ac0c4cb5180e285ff0";
        libraryHaskellDepends = [ array base containers TypeCompose ];
        jailbreak = true;
        description = "GLL parser with simple combinator interface";
@@ -56757,7 +56947,7 @@ self: {
      mkDerivation {
        pname = "global";
        version = "0.2.1.0";
-       sha256 = "00d9qsh0n9yxr411mdisk602qiizy9h4wgz4k04mfr5x5g6cp418";
+       sha256 = "2890cbcc2bbd64570998e43f4e60f23f462c80993ab61a02c9dd270ba0c6a901";
        libraryHaskellDepends = [
          base haskell-src-exts haskell-src-exts-qq loch-th SafeSemaphore stm
          syntax-trees-fork-bairyn tagged template-haskell
@@ -56776,7 +56966,7 @@ self: {
      mkDerivation {
        pname = "global-config";
        version = "0.3.1";
-       sha256 = "1rp855j0rzx528x01q5wi2hah80bwqf5rrw7p8p8qzl39fhlpzqa";
+       sha256 = "0aff4ba14b837e8c2eba87e75c1ce60b20a8a088bce0003a12a5ff0c6429e8e6";
        libraryHaskellDepends = [
          base data-default global-variables transformers
        ];
@@ -56794,7 +56984,7 @@ self: {
      mkDerivation {
        pname = "global-lock";
        version = "0.1";
-       sha256 = "0b2sz9ag6wcr0amgrx08l7924brfansnh9rv64wg9s3nk4ni2sxp";
+       sha256 = "b76b112d9976e8f438313b2768b5552e2f22d2a108f4fcaa029971f354fa5a2c";
        libraryHaskellDepends = [ base ];
        description = "A global lock implemented without unsafePerformIO";
        license = stdenv.lib.licenses.bsd3;
@@ -56805,7 +56995,7 @@ self: {
      mkDerivation {
        pname = "global-variables";
        version = "1.0.1.1";
-       sha256 = "0fvhh6q6z114qyi5rhwzxhrlqfhx6af97187b49lyvx2k9zkzvzp";
+       sha256 = "f7ef3f7f9aa26f4f13590785939c321d3a4c33ec9fc35ca2c724846fb081703b";
        libraryHaskellDepends = [ base containers stm ];
        jailbreak = true;
        description = "Namespaced, global, and top-level mutable variables without unsafePerformIO";
@@ -56819,7 +57009,7 @@ self: {
      mkDerivation {
        pname = "glome-hs";
        version = "0.61";
-       sha256 = "069j4xvh5039xkg300h1cwa0lyvkycixasxr8zh4iqyl1g5bcvs8";
+       sha256 = "486fb6ca0bd4e348e047b96bd523f3737b0a1467010230deec69800277273219";
        isLibrary = true;
        isExecutable = true;
        libraryHaskellDepends = [
@@ -56844,7 +57034,7 @@ self: {
      mkDerivation {
        pname = "gloss";
        version = "1.9.2.1";
-       sha256 = "1fk7472lw4621gv64fv4mna8z1av15f7d0didpc9r22rdlkpa80l";
+       sha256 = "142075276d59889cd86db181765c095b858f94ad643b62f60bc2104ec52167ba";
        libraryHaskellDepends = [
          base bmp bytestring containers ghc-prim gloss-rendering GLUT OpenGL
        ];
@@ -56861,7 +57051,7 @@ self: {
      mkDerivation {
        pname = "gloss";
        version = "1.9.4.1";
-       sha256 = "1rdgcv9jmawzgvshnc6pgdl7f2p6a3f09jwjnhmkfxx3gdwr8q5i";
+       sha256 = "b16094797ba377372bb492cb04dc50e60a77687bd7300bf57e9fab2ad366afe5";
        libraryHaskellDepends = [
          base bmp bytestring containers ghc-prim gloss-rendering GLUT OpenGL
        ];
@@ -56875,7 +57065,7 @@ self: {
      mkDerivation {
        pname = "gloss-accelerate";
        version = "1.9.0.0";
-       sha256 = "13vr758nl712kpkc8nii05iv1zidsp55ihvaknqzn8zdhyk4dxrv";
+       sha256 = "3bf746a687ed23fbb19d6ac358cad52dfeb06301315ac4e69d221c6a5139798f";
        revision = "1";
        editedCabalFile = "cddab61d37317ec1a15ad7da65d909b8668b284dcf182a7a348d234bff7d30ff";
        libraryHaskellDepends = [ accelerate base gloss gloss-rendering ];
@@ -56888,7 +57078,7 @@ self: {
      mkDerivation {
        pname = "gloss-algorithms";
        version = "1.9.4.1";
-       sha256 = "0j8n0769690ikrqwbqp4ba6zz2l4i6211alic3l7mqc2h6rggjs0";
+       sha256 = "40cbf7b28182e17ae86091aa108489848aff8d5ae4e2c5719e112493cc011649";
        libraryHaskellDepends = [ base containers ghc-prim gloss ];
        homepage = "http://gloss.ouroborus.net";
        description = "Data structures and algorithms for working with 2D graphics";
@@ -56900,7 +57090,7 @@ self: {
      mkDerivation {
        pname = "gloss-banana";
        version = "0.1.0.4";
-       sha256 = "0zzpdryfcqvxpzv53ymsvkm2nza9ryvzqgf3n89pnvrni91avgj3";
+       sha256 = "43bead428a366f7b13b2c33dfcb7cf497d2beadcbafa51f6bf7d63e67c6ef77f";
        revision = "1";
        editedCabalFile = "232cec279cb20afd92056320c24d3d3041199b014981492ddbbe57eeff312a5a";
        libraryHaskellDepends = [ base gloss reactive-banana ];
@@ -56914,7 +57104,7 @@ self: {
      mkDerivation {
        pname = "gloss-devil";
        version = "0.2";
-       sha256 = "17gwy13z4lymm9dpj26q4ihcl198gqn9kpcjdw8lcgfcg4gxszsm";
+       sha256 = "557fdd1f79cc3d46116f92dd992c7e2805ca6024d808795baad553f247f0fc9d";
        libraryHaskellDepends = [ base bytestring gloss repa repa-devil ];
        description = "Display images in Gloss using libdevil for decoding";
        license = stdenv.lib.licenses.bsd3;
@@ -56929,7 +57119,7 @@ self: {
      mkDerivation {
        pname = "gloss-examples";
        version = "1.9.4.1";
-       sha256 = "02qsxxbrg8d4338mcj3ka3l2f9qyf3r515b32dm5iingjb8dn5ly";
+       sha256 = "9e16dbd092cfc6586a13639550f2701e2727e850734856d118a4a19757ef1a0b";
        isLibrary = false;
        isExecutable = true;
        executableHaskellDepends = [
@@ -56947,7 +57137,7 @@ self: {
      mkDerivation {
        pname = "gloss-game";
        version = "0.3.3.0";
-       sha256 = "01k9600f9lv65n9bi2v40gzcl14gg9cm27fxz8yk4kx1hk5hv980";
+       sha256 = "00a50dcb84a14f323dfadd1d51597a8f04cafe03648bb8922d66d3e400306906";
        libraryHaskellDepends = [ base gloss gloss-juicy ];
        homepage = "https://github.com/mchakravarty/gloss-game";
        description = "Gloss wrapper that simplifies writing games";
@@ -56960,7 +57150,7 @@ self: {
      mkDerivation {
        pname = "gloss-juicy";
        version = "0.2";
-       sha256 = "1y525ck3cqqg9zggd88ilzxv1pfcz801s0sdgprw3amzyxn71kqq";
+       sha256 = "18cf706cf7bfaac1f37d4d031d00faccddb0fba711a1f6de4f0f6336262ba2f8";
        isLibrary = true;
        isExecutable = true;
        libraryHaskellDepends = [
@@ -56981,7 +57171,7 @@ self: {
      mkDerivation {
        pname = "gloss-raster";
        version = "1.9.4.1";
-       sha256 = "0q6mqgmi3gx2yx8a3rq4nzk2mz2iidnzl26b5h4zhjgmgz8jawv9";
+       sha256 = "697325d17ff549f8092ccb08fa6d8b51fc2ae6b704e7a150f7a2bf11ebc3d560";
        libraryHaskellDepends = [
          base containers ghc-prim gloss gloss-rendering repa
        ];
@@ -56997,7 +57187,7 @@ self: {
      mkDerivation {
        pname = "gloss-raster-accelerate";
        version = "1.9.0.0";
-       sha256 = "0kgjbqharpl9an4kpciiy17chsdlzx5n4mgxp93yja4av8vik3i8";
+       sha256 = "288e1937da8a28e947bafd55624bffb469c84ef031b23b895589deac205ef24d";
        libraryHaskellDepends = [
          accelerate accelerate-cuda base gloss gloss-accelerate
        ];
@@ -57010,7 +57200,7 @@ self: {
      mkDerivation {
        pname = "gloss-rendering";
        version = "1.9.3.1";
-       sha256 = "1ns9x9fwkvxy0dwgdd3apv3p0d4857h3mkb3dx0rg9rs3wbapyzy";
+       sha256 = "fefbab161f3aa797416f63cd3ae029883470c7be6ab4f67803beefc95dea49db";
        libraryHaskellDepends = [
          base bmp bytestring containers GLUT OpenGL
        ];
@@ -57023,7 +57213,7 @@ self: {
      mkDerivation {
        pname = "gloss-sodium";
        version = "0.1.0.0";
-       sha256 = "0ygjqzb1pn092j0d0gcwhxdv940rdlvpaj1gxa347mdgvp4jb9za";
+       sha256 = "eaa725c9ddafd54386ea2f4875376d1990b45b879c3dd0801409d81bd6c7f279";
        libraryHaskellDepends = [ base gloss sodium ];
        jailbreak = true;
        homepage = "https://github.com/Twey/gloss-sodium";
@@ -57036,7 +57226,7 @@ self: {
      mkDerivation {
        pname = "glpk-hs";
        version = "0.3.5";
-       sha256 = "1nx0mcy009cj1h2fsz00qfpr9zawagwsp3w370251hdc5q6bw52p";
+       sha256 = "5714be0c2eacc1500438838fabf9535cfd94afc3007ced040c9225003caba0db";
        libraryHaskellDepends = [ array base containers deepseq mtl ];
        librarySystemDepends = [ glpk ];
        description = "Comprehensive GLPK linear programming bindings";
@@ -57051,7 +57241,7 @@ self: {
      mkDerivation {
        pname = "glue";
        version = "0.1.1.1";
-       sha256 = "1p93cv8c52dbw0lz48yjpfbrj48giyxrwmc9bymfpgjmynda4zab";
+       sha256 = "4b7da29af555beebaa5f89559ebb8f0f119997bbd223f229e0ab89c2d06623dd";
        isLibrary = true;
        isExecutable = true;
        libraryHaskellDepends = [
@@ -57076,7 +57266,7 @@ self: {
      mkDerivation {
        pname = "gluturtle";
        version = "0.0.58.1";
-       sha256 = "0jwkppf9ipm61g052r9m65awq3nsigf3q4m9bj2hmb3n9z75i1hp";
+       sha256 = "178658ce4f76ac0a855ca9123cdc8bda0ecc5531356551c00ba6de98dcbd934b";
        libraryHaskellDepends = [
          base convertible GLUT stm yjsvg yjtools
        ];
@@ -57091,7 +57281,7 @@ self: {
      mkDerivation {
        pname = "gmap";
        version = "0.1";
-       sha256 = "0kwx0zknxpda0pjf9hphniz33b9m0md54z8zx09vzkjq7lpljx7r";
+       sha256 = "f974492f3d58cebf13e81f7d525a0535ad317eb4f0c2e4e405aadd6ee7079d4f";
        libraryHaskellDepends = [
          array AvlTree base COrdering QuickCheck random
        ];
@@ -57107,7 +57297,7 @@ self: {
      mkDerivation {
        pname = "gmndl";
        version = "0.4.0.2";
-       sha256 = "04r7n24jnqgggi19d4l1lj1ag5jrh3zk2pvxwm5xfb7imlg37zm8";
+       sha256 = "a8fe331eadf12cd74be57d5f31ff805996a782a4819296427cef612b89b02713";
        isLibrary = false;
        isExecutable = true;
        executableHaskellDepends = [
@@ -57125,7 +57315,7 @@ self: {
      mkDerivation {
        pname = "gnome-desktop";
        version = "1.0.0.0";
-       sha256 = "0ipx8hka4ly3dc3dv6dnk2bq3hbiiahqqragdm1bqgy1plvwa5q6";
+       sha256 = "0617c537bdc13fbc426d4f658ca18a71c1819798b699dd066bc353a22644fd46";
        isLibrary = false;
        isExecutable = true;
        executableHaskellDepends = [
@@ -57142,7 +57332,7 @@ self: {
      mkDerivation {
        pname = "gnome-keyring";
        version = "0.3.1";
-       sha256 = "08fayi4ixqyzin7lxyx2s3yap377y6nrdf4fmv7bi895j2k642l8";
+       sha256 = "880a62a69025a1b8ceae8eb896adf1e78cabfcd0a2fb4e8f8ddfe31e49f4ca21";
        libraryHaskellDepends = [ base bytestring text time ];
        librarySystemDepends = [ gnome_keyring ];
        libraryPkgconfigDepends = [ gnome_keyring ];
@@ -57160,7 +57350,7 @@ self: {
      mkDerivation {
        pname = "gnomevfs";
        version = "0.11.0";
-       sha256 = "0g4dic9k1c4221v4kacc46sj2vra1jlnb4pn657zfwbkni8z0kmp";
+       sha256 = "b74ef051b47371f74f31f69265a90c2a6f21b5218ca949761082b030138b8d3c";
        libraryHaskellDepends = [
          array base containers glib gtk haskell98 mtl
        ];
@@ -57178,7 +57368,7 @@ self: {
      mkDerivation {
        pname = "gnuidn";
        version = "0.2.1";
-       sha256 = "1jii635wc3j1jnwwx24j9gg9xd91g2iw5967acn74p7db62lqx37";
+       sha256 = "67744c8559ed5c722c53c7a4c2a37821b59ede4b9288ceb995410ec6cb3031ca";
        libraryHaskellDepends = [ base bytestring text ];
        librarySystemDepends = [ libidn ];
        libraryPkgconfigDepends = [ libidn ];
@@ -57196,7 +57386,7 @@ self: {
      mkDerivation {
        pname = "gnuplot";
        version = "0.5.4";
-       sha256 = "1rx6gppgikjyd8ndlmc1yx3b4670184l80g8vrpcgjmbq23wjnmh";
+       sha256 = "b05ac987c0abcac76edee80144090ae018b246f78155da2c6a5ecef8ee7da6e7";
        isLibrary = true;
        isExecutable = true;
        libraryHaskellDepends = [
@@ -57214,7 +57404,7 @@ self: {
      mkDerivation {
        pname = "gnutls";
        version = "0.2";
-       sha256 = "1c5pm0d80wpgh2bkcgbvmc72agf89h8ghfnrn1m1x3fljbgzvrn0";
+       sha256 = "c0e6fddf92d48d1e6ab0d93af8104cc83d250eab7b3d369780ef72801aa8b7b0";
        libraryHaskellDepends = [ base bytestring monads-tf transformers ];
        librarySystemDepends = [ gnutls ];
        libraryPkgconfigDepends = [ gnutls ];
@@ -57228,7 +57418,7 @@ self: {
      mkDerivation {
        pname = "goa";
        version = "3.3";
-       sha256 = "0z1mhi2y4qm1lj6vfsmxf2gs5shfwdac3p9gqj89hx28mpc3rmzk";
+       sha256 = "f3d73cd8ad48749890c42fddc154e30eeaa29f70bd6ab78da4a162e24584357c";
        revision = "1";
        editedCabalFile = "5ae2bd1f4c29e22070fa32e5c126066813467ffe71a912148304d6f30d200137";
        libraryHaskellDepends = [ base directory filepath process ];
@@ -57244,7 +57434,7 @@ self: {
      mkDerivation {
        pname = "goatee";
        version = "0.3.0";
-       sha256 = "1py0cnmvqnjdf6bwwn8p6c78p9qnmk82932j7j6y2q91yhna6b2d";
+       sha256 = "4d2ca32cf42161e18d3c528c24d0ac16a78b0e331759ce97714d5abcab65c0df";
        libraryHaskellDepends = [
          base containers mtl parsec template-haskell
        ];
@@ -57262,7 +57452,7 @@ self: {
      mkDerivation {
        pname = "goatee-gtk";
        version = "0.3.0";
-       sha256 = "0wdspqs5pfa4axys87c8bci2s3y475fddjrdwh1kvc9vdsanb7xv";
+       sha256 = "bb9f65956e3bb13d03e42dcbd65c39c40f2d225b881da47d5744b95b34beba71";
        isLibrary = true;
        isExecutable = true;
        libraryHaskellDepends = [
@@ -57282,7 +57472,7 @@ self: {
      mkDerivation {
        pname = "gofer-prelude";
        version = "2.30.3";
-       sha256 = "1whl3fvwxh26nsb4l6brljsmwl891w5yxlsv69mdfvfb1rl7p64f";
+       sha256 = "8e987b680ecb6dd76a325bd3ee0b0f09515eb5a479194a96b646c0ceb71b14f2";
        libraryHaskellDepends = [ base ghc-prim ];
        homepage = "http://code.haskell.org/~dons/code/gofer-prelude";
        description = "The Gofer 2.30 standard prelude";
@@ -57295,7 +57485,7 @@ self: {
      mkDerivation {
        pname = "google-dictionary";
        version = "0.1.0.2";
-       sha256 = "12ib4y8cjg0dvvizy8yxgjaqvyawdy7vxmh1ab12b4yg40wwsg6g";
+       sha256 = "cf3ccd3920cf9325c25201d6be8f6f5cf98d957cdd23ffe3de0d3cc990272b8a";
        libraryHaskellDepends = [ aeson base bytestring HTTP lens mtl ];
        homepage = "https://github.com/mitchellwrosen/google-dictionary-api";
        description = "Simple interface to the google.com/dictionary API";
@@ -57306,15 +57496,16 @@ self: {
     ({ mkDerivation, aeson, base, bytestring, conduit, conduit-extra
      , directory, filepath, google-oauth2, hspec
      , hspec-expectations-lifted, http-conduit, http-types, load-env
-     , mtl, random, resourcet, text, time, timerep
+     , mtl, random, resourcet, text, time, unordered-containers
      }:
      mkDerivation {
        pname = "google-drive";
-       version = "0.3.1";
-       sha256 = "0fzz9dgb2l5zcfjrzf4bqv0dgjhy12r9i1h66y1mji2z0f9qj37y";
+       version = "0.4.0";
+       sha256 = "488f740df4c746f58ccb1bf7bcc46dc8d504006d76bcc62ec54b8213b72954d3";
        libraryHaskellDepends = [
          aeson base bytestring conduit conduit-extra directory filepath
-         http-conduit http-types mtl random resourcet text time timerep
+         http-conduit http-types mtl random resourcet text time
+         unordered-containers
        ];
        testHaskellDepends = [
          base bytestring conduit conduit-extra directory google-oauth2 hspec
@@ -57332,7 +57523,7 @@ self: {
      mkDerivation {
        pname = "google-html5-slide";
        version = "2011.0";
-       sha256 = "0wkblf0i4lfw6s8adf2clcqj3161863vbsq1cip3rcn9djqbimzl";
+       sha256 = "f4d7b8b06cc9b23c6e6401ebb58741c1842131a34cb8a69036dc511281a36b72";
        isLibrary = false;
        isExecutable = true;
        executableHaskellDepends = [
@@ -57352,7 +57543,7 @@ self: {
      mkDerivation {
        pname = "google-mail-filters";
        version = "0.0.1.1";
-       sha256 = "0cxslr062h536q4vgs16r2s1lm7x5m9lcy1hzif6mpnmvjzqsn11";
+       sha256 = "21588dbfdcd5de6a5cfc307846532dfd541ab4c826e8b70936a3406140a6ba33";
        libraryHaskellDepends = [
          base containers google-search old-locale text time xml-conduit
        ];
@@ -57370,7 +57561,7 @@ self: {
      mkDerivation {
        pname = "google-oauth2";
        version = "0.2.0";
-       sha256 = "15aqwbr8wb1ghzy0r0k3fvfr187d9s3zz21lp07ci9pyz8ln8z08";
+       sha256 = "087c6429fafea6c80eb83488ff874eeda090dd7663820cfc872f2c8ef2e25895";
        libraryHaskellDepends = [
          aeson base bytestring HTTP http-conduit
        ];
@@ -57387,7 +57578,7 @@ self: {
      mkDerivation {
        pname = "google-search";
        version = "0.1.0.1";
-       sha256 = "0nkpvp5zjf3mkhqv6z5xvrmr6b6d5zgmzlh67y7ssslp4620m5m7";
+       sha256 = "a7960a8421976aad8f3f06d25fdf2fcd2c936bdebd7cb3319c7538f9cbdd775a";
        libraryHaskellDepends = [ base free nats old-locale text time ];
        homepage = "https://github.com/liyang/google-search";
        description = "EDSL for Google and GMail search expressions";
@@ -57403,7 +57594,7 @@ self: {
      mkDerivation {
        pname = "googleplus";
        version = "0.3.1.1";
-       sha256 = "046fvrr8cg00wagx4vdx35l2xk8qbs7fbs0v5hj45h4jk9dnk2jg";
+       sha256 = "4f8a695b9a92c042242c1be8e58e5e18cd2e6819bd6dd29fe2003c8672dece10";
        libraryHaskellDepends = [
          aeson attoparsec base bytestring containers enumerator haskell98
          http-enumerator http-types mtl text time timerep transformers url
@@ -57415,6 +57606,26 @@ self: {
        hydraPlatforms = stdenv.lib.platforms.none;
      }) {};
 
+  "googlepolyline" = callPackage
+    ({ mkDerivation, base, bytestring, HUnit, QuickCheck
+     , test-framework, test-framework-hunit, test-framework-quickcheck2
+     , text
+     }:
+     mkDerivation {
+       pname = "googlepolyline";
+       version = "0.1.0.1";
+       sha256 = "b16915544bfe4656fdf6104e769df8bac4a3e6c5f4ffd0c622d09fffb5f68717";
+       libraryHaskellDepends = [ base bytestring text ];
+       testHaskellDepends = [
+         base bytestring HUnit QuickCheck test-framework
+         test-framework-hunit test-framework-quickcheck2 text
+       ];
+       jailbreak = true;
+       homepage = "https://github.com/lornap/googlepolyline";
+       description = "Google Polyline Encoder/Decoder";
+       license = stdenv.lib.licenses.mit;
+     }) {};
+
   "gopherbot" = callPackage
     ({ mkDerivation, base, HDBC, HDBC-postgresql, MissingH, network
      , parsec, unix
@@ -57422,7 +57633,7 @@ self: {
      mkDerivation {
        pname = "gopherbot";
        version = "0.1.0";
-       sha256 = "0qa4xs07975spf4pwc2y0hichn4x8l7kn2949v0j19gbd099vjng";
+       sha256 = "cfca9d1268eba520c14e24093b0f459d58c822045e307e89bbba9c7480ee4461";
        isLibrary = false;
        isExecutable = true;
        executableHaskellDepends = [
@@ -57441,7 +57652,7 @@ self: {
      mkDerivation {
        pname = "gpah";
        version = "0.0.2";
-       sha256 = "1zwz065fdg3k09nh976igr90p1qpb397fyi7jh941c512m70qbxr";
+       sha256 = "b92f0c4e15a1b0401294277a77d25817870b527ed19c046d0273bce68a019fff";
        isLibrary = false;
        isExecutable = true;
        executableHaskellDepends = [
@@ -57459,7 +57670,7 @@ self: {
      mkDerivation {
        pname = "gpcsets";
        version = "0.9.2.0";
-       sha256 = "1fm0k6n6fb5a3wvmb2l6k4zq3sdfxv16cb2y2zmjgxgj5n3gy9s8";
+       sha256 = "4827ff862df2f527eb175e2c66c2eeaee9813f99868a55371faa2c67ac99a0ba";
        libraryHaskellDepends = [ base ];
        description = "Generalized Pitch Class Sets for Haskell";
        license = stdenv.lib.licenses.bsd3;
@@ -57470,7 +57681,7 @@ self: {
      mkDerivation {
        pname = "gpolyline";
        version = "0.1.0.1";
-       sha256 = "01bsl7s8r33jgvk9lyca02awj43acii8spa6sskz19ivhm2adcr8";
+       sha256 = "28b3a644853ba6f0a7d6465d8d62646a10c995008a799ae67e728c8cf4a17a05";
        libraryHaskellDepends = [ base split ];
        homepage = "https://github.com/fegu/gpolyline";
        description = "Pure module for encoding/decoding Google Polyline";
@@ -57485,7 +57696,7 @@ self: {
      mkDerivation {
        pname = "gps";
        version = "1.2";
-       sha256 = "1krq6sv9qblwqlx7j6gb5qfv5zarxlyvaj6svhd4n8f7pr5w510r";
+       sha256 = "1984c24bbec7214b1adcda48b53ded59fdb21d2eeb19793ac59c2e9cb63638cf";
        libraryHaskellDepends = [
          base pretty prettyclass statistics text time vector
        ];
@@ -57506,7 +57717,7 @@ self: {
      mkDerivation {
        pname = "gps2htmlReport";
        version = "0.3.1";
-       sha256 = "1n6a1c6w3wmyaqan3ymlrk36h98yvy40wgwfdah4ayyxlsmvvxg8";
+       sha256 = "e8f5bdaba6dd7b45a06a8e3f0e88df1e2568c6ccb4fa611556bef2c10d0bcad8";
        isLibrary = true;
        isExecutable = true;
        libraryHaskellDepends = [
@@ -57528,7 +57739,7 @@ self: {
      mkDerivation {
        pname = "gpx-conduit";
        version = "0.1.1";
-       sha256 = "0ffb0npx0yb69qxdcdznxpw36zjp2za7vdpzy2r5l245y0xr7mj4";
+       sha256 = "44d6933bf085085ab2f0ffb67dd417577e33f8edf637d63a4e6679d0af05cb39";
        libraryHaskellDepends = [
          attoparsec base conduit filepath monad-control old-locale text time
          void xml-conduit xml-types
@@ -57546,7 +57757,7 @@ self: {
      mkDerivation {
        pname = "graceful";
        version = "0.1.1.5";
-       sha256 = "1kl4y01ny5w1y77r2jf830d7vd99by7frk106m2wc9nbl066mbhr";
+       sha256 = "19ae6a0ca0cb26c6453520ccec8e5f29b57d1a18c84991cff181176f03f084ce";
        libraryHaskellDepends = [ base directory network stm unix ];
        testHaskellDepends = [
          base directory filepath hspec network process stm unix
@@ -57563,7 +57774,7 @@ self: {
      mkDerivation {
        pname = "grammar-combinators";
        version = "0.2.7";
-       sha256 = "1z7i1270g919g1756wgfap2mfhvln13bhgya2pw4b9lbr5fphkdd";
+       sha256 = "ad4d785dc98ba645f815ca3fb846b0744357c555ee71534e7829a4078e08f1fc";
        libraryHaskellDepends = [
          base containers enumerable fgl graphviz MaybeT mtl multirec parsec
          template-haskell text uu-parsinglib
@@ -57580,7 +57791,7 @@ self: {
      mkDerivation {
        pname = "grapefruit-examples";
        version = "0.1.0.5";
-       sha256 = "0ad64jnp71gh7rj3rlfw7z67l5xnmc052g5q3slw3s6ga7spajlr";
+       sha256 = "994a75f551cfe8c1a91eb83c5100abb6177acc3fdcd13c643ef08573ad24a629";
        libraryHaskellDepends = [
          base colour containers fraction grapefruit-frp grapefruit-records
          grapefruit-ui
@@ -57598,7 +57809,7 @@ self: {
      mkDerivation {
        pname = "grapefruit-frp";
        version = "0.1.0.5";
-       sha256 = "155hmjflmzm463b00r1jjwbpjq8ilwss5xqwi6nz6lm3xbc2ddhm";
+       sha256 = "15b626d8eaa352f3ad891cf7a235a71161791797326400d630a4fe4a9dacb094";
        libraryHaskellDepends = [
          arrows base containers fingertree semigroups TypeCompose
        ];
@@ -57614,7 +57825,7 @@ self: {
      mkDerivation {
        pname = "grapefruit-records";
        version = "0.1.0.5";
-       sha256 = "02hyrbsz20fl9mnynval55xar175vgy77s23zaq66r3f8c6gf6h1";
+       sha256 = "011af70c436e6463b0fa43e873fcdbe584ac7a29546deb6d4dd401f1f5ca1e0a";
        libraryHaskellDepends = [ arrows base grapefruit-frp ];
        homepage = "http://grapefruit-project.org/";
        description = "A record system for Functional Reactive Programming";
@@ -57629,7 +57840,7 @@ self: {
      mkDerivation {
        pname = "grapefruit-ui";
        version = "0.1.0.5";
-       sha256 = "11xxvg2847vyzpw8i11a6mnflyr639hdwj51r9pfyaq95034q9jq";
+       sha256 = "58264c0628092bef6ecaa148de601a267bea6c352a8488f8fd7e1f82c4dbbd87";
        libraryHaskellDepends = [
          arrows base colour containers fraction grapefruit-frp
          grapefruit-records
@@ -57647,7 +57858,7 @@ self: {
      mkDerivation {
        pname = "grapefruit-ui-gtk";
        version = "0.1.0.5";
-       sha256 = "106svyjnv72f0ikcfxgq8zagqxcn52yc1f31kfgz9258mmdki49z";
+       sha256 = "3f91385bada888f49f9b61b8c0bc289675fcd447f875c766044e9c6da5dfda80";
        libraryHaskellDepends = [
          base colour containers fraction glib grapefruit-frp
          grapefruit-records grapefruit-ui gtk
@@ -57665,7 +57876,7 @@ self: {
      mkDerivation {
        pname = "graph-core";
        version = "0.2.2.0";
-       sha256 = "0czqcdg7w7al7gl339b9l15kn5n79zmdjbic3gn9mblnjb1666r9";
+       sha256 = "291b63c29296ae9aec1b2c2ed9ea4fc7163b4ba069a531e83b541d7e5e63f833";
        libraryHaskellDepends = [
          base containers deepseq hashable mtl QuickCheck safe
          unordered-containers vector
@@ -57686,7 +57897,7 @@ self: {
      mkDerivation {
        pname = "graph-generators";
        version = "0.1.2.0";
-       sha256 = "0iw22rmlhryc0z6k92lzdyjkc1qs98lj2509rk7qc7z0ghbhir9s";
+       sha256 = "3ae508177ce01f86cfcc091421294a1a0736a56f9f8a34cd07cc67486b168247";
        libraryHaskellDepends = [
          base containers fgl multiset mwc-random
        ];
@@ -57705,7 +57916,7 @@ self: {
      mkDerivation {
        pname = "graph-matchings";
        version = "0.1.0.0";
-       sha256 = "0dzkv13w06hkxg2vkbblpskvsq02c2ay06rw2j4vyjpw13hms5bv";
+       sha256 = "7b155de108fc4abf89143c1be095600260bda7be74adb9c5eb131ac047d8f337";
        libraryHaskellDepends = [ base containers fgl ];
        description = "An implementation of algorithms for matchings in graphs";
        license = stdenv.lib.licenses.lgpl21;
@@ -57716,7 +57927,7 @@ self: {
      mkDerivation {
        pname = "graph-rewriting";
        version = "0.7.6";
-       sha256 = "014zsw98ksylr4g1ax3xxlsh9jiybaz7xjapl2h88a8ma91da3jz";
+       sha256 = "5f0ed54252152984a0a057c97ebe5a3eca0435ed7d74151ec9d4eb8912d79f04";
        libraryHaskellDepends = [
          base base-unicode-symbols containers mtl
        ];
@@ -57734,7 +57945,7 @@ self: {
      mkDerivation {
        pname = "graph-rewriting-cl";
        version = "0.2.2";
-       sha256 = "0rwycs3vnzy9awm081h836136s2wjyk9qyhsx9j6z7y3lgsb2cr0";
+       sha256 = "2033b1f4a3c39f6f64ea1a7a9ca6975c683382190806042a57c97fbb87669e67";
        isLibrary = false;
        isExecutable = true;
        executableHaskellDepends = [
@@ -57755,7 +57966,7 @@ self: {
      mkDerivation {
        pname = "graph-rewriting-gl";
        version = "0.7.5";
-       sha256 = "0cynzhr226944w3sn13bdnl60z9fy87va5fjayd4g0as2168ikhy";
+       sha256 = "1ece884c105a81479a57d215b50ff22e7d60a86d6b04ab072724192132fcd633";
        libraryHaskellDepends = [
          AC-Vector base base-unicode-symbols containers GLUT graph-rewriting
          graph-rewriting-layout OpenGL
@@ -57775,7 +57986,7 @@ self: {
      mkDerivation {
        pname = "graph-rewriting-lambdascope";
        version = "0.5.6";
-       sha256 = "1qwy2mn22a5ppz3lrqz6czxrr3j26zxpp6lm3sf121k3a78c7vvp";
+       sha256 = "77efc3d0516306119c1e959a7bfb37428e9cfb67e6e34cc7bfb728216c159ee3";
        isLibrary = false;
        isExecutable = true;
        executableHaskellDepends = [
@@ -57797,7 +58008,7 @@ self: {
      mkDerivation {
        pname = "graph-rewriting-layout";
        version = "0.5.3";
-       sha256 = "09fscyaknd3nhqn7d3wa4j8n2yagmmfk661m41cqx5hlay60x5f5";
+       sha256 = "c5950e8c5714968e59203518335dad4f796191248a8f762c8676343b9567da25";
        libraryHaskellDepends = [
          AC-Vector base base-unicode-symbols graph-rewriting
        ];
@@ -57815,7 +58026,7 @@ self: {
      mkDerivation {
        pname = "graph-rewriting-ski";
        version = "0.6.4";
-       sha256 = "0jdfwcz427lx3r0alba1rphc6hj43mqygkdqmwn37yll4r1c62a4";
+       sha256 = "4409c3422694fa332cafb8cde7711d4442c3e0cd412daa401e9d1e413ee3ae49";
        isLibrary = false;
        isExecutable = true;
        executableHaskellDepends = [
@@ -57836,7 +58047,7 @@ self: {
      mkDerivation {
        pname = "graph-rewriting-strategies";
        version = "0.2.3";
-       sha256 = "0mimp7xbmnp9c2j8hr09qivc6kgfi4g63p071s560laddins39jr";
+       sha256 = "59a6a16d6c4d51608a0e07dc611e89ee4dc376c4096488a460e9dabafab93556";
        libraryHaskellDepends = [
          base base-unicode-symbols containers graph-rewriting
        ];
@@ -57855,7 +58066,7 @@ self: {
      mkDerivation {
        pname = "graph-rewriting-trs";
        version = "0.1.6";
-       sha256 = "1v8imc3ym0jjyhpw10xh36l060nvd0klp9llnmdnv8qkmy7pn8yg";
+       sha256 = "cf237b8faf13a36d5bb594a64b2768db0203a819b083c02ff45282ea07ab11ed";
        isLibrary = false;
        isExecutable = true;
        executableHaskellDepends = [
@@ -57878,7 +58089,7 @@ self: {
      mkDerivation {
        pname = "graph-rewriting-ww";
        version = "0.3.4";
-       sha256 = "169s5iy15q9ll12fjxizrc0l2q34rvqmxfpbcanc602cj3inav2w";
+       sha256 = "5c6c65e3904c00c3ac62ebba5ef1ce64604101cb3f76e944a034e1127c2c3a99";
        isLibrary = false;
        isExecutable = true;
        executableHaskellDepends = [
@@ -57897,7 +58108,7 @@ self: {
      mkDerivation {
        pname = "graph-serialize";
        version = "0.2";
-       sha256 = "1a9qq5gpyxg6j6ja3kjldnf11wywjvvxpwvgiahlsrmwfw2c8d74";
+       sha256 = "e434c40477bc664da18a6ff3dbf796dcf3109c6d54cea1a491e6757f5fc138a9";
        libraryHaskellDepends = [ array base bytestring containers ];
        homepage = "http://github.com/nominolo/graph-serialize";
        description = "Serialization of data structures with references";
@@ -57911,7 +58122,7 @@ self: {
      mkDerivation {
        pname = "graph-utils";
        version = "0.3.7";
-       sha256 = "06wl6i8z0gfndr96g5ps11h877rbwvi1d9cbbr3d2whvbcsyclsf";
+       sha256 = "4e53e6355b1b72d1465e8ba516e2e62b9f836008fa9667526ed63df05134941b";
        libraryHaskellDepends = [
          base containers fgl mtl parsec syb template-haskell
        ];
@@ -57929,7 +58140,7 @@ self: {
      mkDerivation {
        pname = "graph-visit";
        version = "0.1.0.2";
-       sha256 = "0afj0wqpk549n0xs4vqcblrxs1d6knmxcldfnmz5vy2da5zlfn0q";
+       sha256 = "1858477f514df85d7eb5ae51d6ab9da605dd335d0c6fa23bb08994793107d229";
        libraryHaskellDepends = [
          base containers data-lens data-lens-template mtl
        ];
@@ -57945,7 +58156,7 @@ self: {
      mkDerivation {
        pname = "graph-wrapper";
        version = "0.2.5.1";
-       sha256 = "04z1qbsf1c31r0mhn8bgr8hisffxacq3j61y4fym28idr8zqaqc3";
+       sha256 = "8361853fca2d2251bd233e18393053dd391d21ca6f210b2bc861b0e0f4c2e113";
        libraryHaskellDepends = [ array base containers ];
        testHaskellDepends = [
          array base containers deepseq hspec QuickCheck
@@ -57962,7 +58173,7 @@ self: {
      mkDerivation {
        pname = "graphbuilder";
        version = "0.1.0.0";
-       sha256 = "0zhjzb53qaj6dy6ncqjaxdfrs2hwfy4g9czybpsgnbniqm07i22b";
+       sha256 = "4b887840c5d12efbf45dfeb3f488771c0a9d5deb4a62668d6f462a3ccafa127e";
        libraryHaskellDepends = [ base containers mtl ];
        testHaskellDepends = [
          base containers mtl QuickCheck test-framework
@@ -57982,7 +58193,7 @@ self: {
      mkDerivation {
        pname = "graphene";
        version = "0.1.0.4";
-       sha256 = "09q57hqf3s29y3b6wn79wa9ksm5r2p75ww3kpwqmigvngy4sz006";
+       sha256 = "0680af897f76bf5831bf73705ece15b9543d93e2e9586ed6f049e8e1303c0527";
        libraryHaskellDepends = [
          base bifunctors containers hashable lens-family lens-family-core
          mtl transformers
@@ -58000,7 +58211,7 @@ self: {
      mkDerivation {
        pname = "graphics-drawingcombinators";
        version = "1.5.1";
-       sha256 = "0j0ilr54pdz61c78khy8bm37g89cvk1n56h5d6c55jabsv5gx3sf";
+       sha256 = "4e8ffecad64bc9529869059a62c3dc2ca177465dc8c3890e0be6b74b4aa61148";
        isLibrary = true;
        isExecutable = true;
        libraryHaskellDepends = [
@@ -58019,7 +58230,7 @@ self: {
      mkDerivation {
        pname = "graphics-formats-collada";
        version = "0.3.1";
-       sha256 = "1kfx1c2x8v2i7ckhjiqv7ghhn44w7fscghxkn1iqkp3mj1p3xvbv";
+       sha256 = "7bed3e6e9075dc8963b0b3c3c7b43b9c100be13b1b4709273b516cd4050bddcd";
        libraryHaskellDepends = [
          base bitmap-opengl containers hxt OpenGL stb-image transformers
        ];
@@ -58035,7 +58246,7 @@ self: {
      mkDerivation {
        pname = "graphicsFormats";
        version = "0.1";
-       sha256 = "0bcqj0n8qqaqfrn21qgkf8si5qgxl3qlsc8djy0rqhnfi2grb8nh";
+       sha256 = "d0a2959f88ce429c81970d314df1a0fde1123572f3e1206c7658618c2c90982d";
        libraryHaskellDepends = [ base haskell98 OpenGL QuickCheck ];
        description = "Classes for renderable objects";
        license = stdenv.lib.licenses.bsd3;
@@ -58049,7 +58260,7 @@ self: {
      mkDerivation {
        pname = "graphicstools";
        version = "0.2.2";
-       sha256 = "0hcz8w6yf7dls4sv0i5kihs22ysv0dl63q5bs5y4hgv6d747psp8";
+       sha256 = "e8ea7bc869663f487cd1abe06168035b7b21348cb344b035d1b41de70d479f41";
        isLibrary = true;
        isExecutable = true;
        libraryHaskellDepends = [
@@ -58069,7 +58280,7 @@ self: {
      mkDerivation {
        pname = "graphmod";
        version = "1.2.6";
-       sha256 = "02p1x44ywv2mb4l2dsz9z3ybnvv4nns3882lqm3nc8sw2hkib8z3";
+       sha256 = "e3a31527145c236647c5542034b4b5646fbbfcf8e9eb262859556cee09e9e10a";
        isLibrary = false;
        isExecutable = true;
        executableHaskellDepends = [
@@ -58085,7 +58296,7 @@ self: {
      mkDerivation {
        pname = "graphs";
        version = "0.6.0.1";
-       sha256 = "061n1k5v6izpa77wyxch3ym4hzs1k64a902x2250gi724mj3mjsk";
+       sha256 = "53cb3a6425e2c4078a105d80a48899417f48aa1f9075cfcf51f747b3cb0c3618";
        libraryHaskellDepends = [
          array base containers transformers void
        ];
@@ -58101,7 +58312,7 @@ self: {
      mkDerivation {
        pname = "graphtype";
        version = "0.2.0";
-       sha256 = "13nblgd4b3pwpw8idvbd54fq2lf233vj8gvsl0qr381lsvj69fbi";
+       sha256 = "71b964e4d634a09131a07a3f24f718c251811d296ded1611bffc8e45daa3cb8e";
        isLibrary = false;
        isExecutable = true;
        executableHaskellDepends = [
@@ -58121,7 +58332,7 @@ self: {
      mkDerivation {
        pname = "graphviz";
        version = "2999.17.0.2";
-       sha256 = "1zfndf5mpwx3nrgybxg5hy8n30zwsfx6jgp9468b0pp8c5h65j13";
+       sha256 = "23c8626061e85eb09021e93e69bad3fc83619187e5f5e55fb6a3f35b8b6bd6fd";
        isLibrary = true;
        isExecutable = true;
        libraryHaskellDepends = [
@@ -58147,7 +58358,7 @@ self: {
      mkDerivation {
        pname = "gravatar";
        version = "0.8.0";
-       sha256 = "1mzl08qzwzzhz6bvkz4qnrdnzsgvsmi2lnhzf743yzx4msn00q3g";
+       sha256 = "6f6000acaea47f3fc8711f5a2a62d5fbe96f5bb698fcb997f9f07ffe3102f4d7";
        libraryHaskellDepends = [
          base bytestring data-default HTTP pureMD5 text
        ];
@@ -58161,7 +58372,7 @@ self: {
      mkDerivation {
        pname = "gray-code";
        version = "0.3.1";
-       sha256 = "0b0pm24mxjsxg95q6yisr9pa0jfklsfw66cicryib42czvv083av";
+       sha256 = "5b0d04f6fe4c90157d669119c39da6d349a06eca3a7a834b7a5dcb5e89a8172c";
        libraryHaskellDepends = [ base ];
        testHaskellDepends = [ base QuickCheck ];
        homepage = "http://bitbucket.org/astanin/hs-gray-code";
@@ -58176,7 +58387,7 @@ self: {
      mkDerivation {
        pname = "gray-extended";
        version = "1.5.1";
-       sha256 = "1lami8ncp9d4k25vzb23gz9067ahp8vws378qb57hnkisfnn932q";
+       sha256 = "588c64add3715a78cac2e80ccd37ba501d03d27f43acbf8b98a4a5cb2c8a55d1";
        libraryHaskellDepends = [ base ];
        testHaskellDepends = [
          base QuickCheck test-framework test-framework-quickcheck2
@@ -58192,7 +58403,7 @@ self: {
      mkDerivation {
        pname = "greencard";
        version = "3.0.4.2";
-       sha256 = "1vl9p6mqss5r4jfqnjir7m1q7fhh9f204c99qd5y5d0j7yc26r5y";
+       sha256 = "be6423983f12b4e24bc3293102844b10ba83433d394a8b9d24b9688dabb989ee";
        isLibrary = true;
        isExecutable = true;
        libraryHaskellDepends = [ base ];
@@ -58208,7 +58419,7 @@ self: {
      mkDerivation {
        pname = "greencard-lib";
        version = "3.0.1";
-       sha256 = "1a8h36kclb5db7kfy1pb4h2pwy6a6wwnjpm21xzvc9fjx9vj44kd";
+       sha256 = "6d122277ead225b67f0fa25e693937ca787e0524eb06efe659ad2ccaa61910a9";
        libraryHaskellDepends = [ array base containers greencard pretty ];
        homepage = "http://www.haskell.org/greencard/";
        description = "A foreign function interface pre-processor library for Haskell";
@@ -58223,7 +58434,7 @@ self: {
      mkDerivation {
        pname = "greg-client";
        version = "1.0.2";
-       sha256 = "1p645qgn5i194mna20ariypxp0dci7lzyxhszmnyylpd0icyg4in";
+       sha256 = "3692e75904ed52ef6dfd1a76ffe989ac81dbaf8f5901a16c2529c4621f2ec4dc";
        libraryHaskellDepends = [
          base binary bytestring clock hostname network stm system-uuid time
        ];
@@ -58240,7 +58451,7 @@ self: {
      mkDerivation {
        pname = "grid";
        version = "7.8.4";
-       sha256 = "1jci2191l6k1qlch54id7z05zn9lp5lzyh7g6hm9s522z97lgb2k";
+       sha256 = "53ac474ffa42149d2a34ef40ff69b934d95fc03f2d920219c5611a1a521091c9";
        libraryHaskellDepends = [ base cereal containers ];
        testHaskellDepends = [
          base containers QuickCheck test-framework
@@ -58258,7 +58469,7 @@ self: {
      mkDerivation {
        pname = "gridland";
        version = "0.1.0.3";
-       sha256 = "0q5p73n6h5ngg992f1msdqzxds2baafjypdx53zf2rdhbqp4fdi9";
+       sha256 = "2936472e5eb065e1fe28bd5d2f9d524be8d63f6eba0627527acf1668ec38b760";
        isLibrary = true;
        isExecutable = true;
        libraryHaskellDepends = [
@@ -58277,7 +58488,7 @@ self: {
      mkDerivation {
        pname = "grm";
        version = "0.1.1";
-       sha256 = "1za45931c6avyqxb6dwiafl739fmwdk68kxpk13zkv0jwxxpp9px";
+       sha256 = "fda67b7be712ecf94798b74f6466e3d5a571a8539137b33af65b1916462a44fd";
        isLibrary = true;
        isExecutable = true;
        libraryHaskellDepends = [
@@ -58297,7 +58508,7 @@ self: {
      mkDerivation {
        pname = "groom";
        version = "0.1.2";
-       sha256 = "045hzpnf17rp1ib6q3gcznl9b7ivz5zmv0gh7qfg726kr8i030hf";
+       sha256 = "0e820122cad388f31c3ef0815d7ff93b9e95a8fdec0d6c560c379fe0ecfdb010";
        libraryHaskellDepends = [ base haskell-src-exts ];
        description = "Pretty printing for well-behaved Show instances";
        license = stdenv.lib.licenses.publicDomain;
@@ -58312,7 +58523,7 @@ self: {
      mkDerivation {
        pname = "groundhog";
        version = "0.7.0.3";
-       sha256 = "0n5c501wfyqcl1iy4017yyxp95kz7mb4lgc0mjjk9si36ixkww9r";
+       sha256 = "39713e7b3423ea34a5ac803d4a563d7f9674bbf72700e263a00c7bc70328ac58";
        revision = "1";
        editedCabalFile = "dcf9bbeaf0fd7e7ac0809902a54779097e8935a07b1e7e43c404bc683c17e7f0";
        libraryHaskellDepends = [
@@ -58333,7 +58544,7 @@ self: {
      mkDerivation {
        pname = "groundhog-inspector";
        version = "0.7.1.2";
-       sha256 = "14wxmn18z4022vkakyrdl7mz7zbdaa3dnwbb52ymg3f5r13lr7lh";
+       sha256 = "909e4c47c8c58d57bd286b71db86526dfdf3eba12dfba9e61602908f82ad9d93";
        isLibrary = true;
        isExecutable = true;
        libraryHaskellDepends = [
@@ -58358,7 +58569,7 @@ self: {
      mkDerivation {
        pname = "groundhog-mysql";
        version = "0.7.0.1";
-       sha256 = "01pnninva0va0pl9k7mjk2l7fm42978j9x82sj8z7cscshvl327f";
+       sha256 = "ee884137d44cb3f391d402f524d149825477a898b29e99e8056a03b56db4f606";
        libraryHaskellDepends = [
          base bytestring containers groundhog monad-control monad-logger
          mysql mysql-simple resource-pool text time transformers
@@ -58376,7 +58587,7 @@ self: {
      mkDerivation {
        pname = "groundhog-postgresql";
        version = "0.7.0.2";
-       sha256 = "18wdj51v6qqyqx10lvknr3irhs5qddvh301bx7l9cdcpkk1la81i";
+       sha256 = "312045c39c973596e8e92b8001776bb86898e3c8766e0a42c71e63b343918da3";
        libraryHaskellDepends = [
          attoparsec base blaze-builder bytestring containers groundhog
          monad-control monad-logger postgresql-libpq postgresql-simple
@@ -58394,7 +58605,7 @@ self: {
      mkDerivation {
        pname = "groundhog-sqlite";
        version = "0.7.0.1";
-       sha256 = "0lsm9yfapdpy4nf5bxrbjkvw9nwc82qfmyw1h9l3mc4b8nfp12dy";
+       sha256 = "be89709d458bb03a688281fbeab0408cdbc4f7942bf7559c25feb6ab9c4f5553";
        libraryHaskellDepends = [
          base bytestring containers direct-sqlite groundhog monad-control
          monad-logger resource-pool text transformers unordered-containers
@@ -58410,7 +58621,7 @@ self: {
      mkDerivation {
        pname = "groundhog-th";
        version = "0.7.0.1";
-       sha256 = "15g07rzw2jygzs5p9jflq6l2rjrmf03lj8pprzc4vgwvk04x233h";
+       sha256 = "700cd109989bbf4dd8cff72249077035cb2ca8c1d4c9748bfecf4bc17f3ee095";
        libraryHaskellDepends = [
          aeson base bytestring containers groundhog template-haskell text
          time unordered-containers yaml
@@ -58426,7 +58637,7 @@ self: {
      mkDerivation {
        pname = "group-with";
        version = "0.2.0.2";
-       sha256 = "0c7p3bj3b68h2zp0lzldfjwq7x2a38v0gnxyflisawdg61jnx8h6";
+       sha256 = "06a26e6530af71a52375bedb07361a4af483b9748d7e0aee17109935e41af730";
        libraryHaskellDepends = [ base containers ];
        testHaskellDepends = [
          base Cabal containers hspec hspec-expectations QuickCheck
@@ -58442,7 +58653,7 @@ self: {
      mkDerivation {
        pname = "groupoid";
        version = "0.1.0";
-       sha256 = "0gpjlq9f2il4vp7ihh1sf5g2jr1rbi5big5c6dhjk961n8b1dq0z";
+       sha256 = "1fe01616b2c1a4296133acbcb84a5c3964295e713a4018cfdd8446e112a6f23e";
        libraryHaskellDepends = [ base ];
        homepage = "http://code.google.com/p/copperbox/";
        description = "A Groupoid class";
@@ -58454,7 +58665,7 @@ self: {
      mkDerivation {
        pname = "groupoids";
        version = "4.0";
-       sha256 = "08la44c19pz2clws5mb939zc1d17cb6qy9qlh2n1634pl0zrawb6";
+       sha256 = "6671953fa0970c13ac8014278fcd6227b4c07e1a69d5a23965e2df1418218a22";
        libraryHaskellDepends = [ base semigroupoids ];
        homepage = "http://github.com/ekmett/groupoids/";
        description = "This package has been absorbed into semigroupoids 4.0";
@@ -58466,7 +58677,7 @@ self: {
      mkDerivation {
        pname = "groups";
        version = "0.4.0.0";
-       sha256 = "1kp8h3617cimya8nnadljyy4vk66dzl5nzfm900k2gh3ci8kja6k";
+       sha256 = "d328395164033e310148d57d5be86fc6cc4dbc97b4296b91f235b213cc80e8ce";
        libraryHaskellDepends = [ base ];
        description = "Haskell 98 groups";
        license = stdenv.lib.licenses.bsd3;
@@ -58482,7 +58693,7 @@ self: {
      mkDerivation {
        pname = "growler";
        version = "0.6.0";
-       sha256 = "0skykz2p0kcs8g1vq7832h7fnw193hpq4pplkcaxazg8z97k8q75";
+       sha256 = "e560344ffae87dd5159bf45e822f1c2970eb0e14031dbcc3439a4d70c59f7e6a";
        libraryHaskellDepends = [
          aeson base blaze-builder bytestring case-insensitive either
          http-types lens monad-control mtl pipes pipes-aeson pipes-wai
@@ -58502,7 +58713,7 @@ self: {
      mkDerivation {
        pname = "gruff";
        version = "0.3.4";
-       sha256 = "0is9bpaalyr78g0hfp6bbmny4w6w8a3aj9a041f82499hhy0vv0h";
+       sha256 = "10ec0d3c842911815c204025a98642dc70e26d5dcb5c07c143277baad45d4947";
        isLibrary = true;
        isExecutable = true;
        libraryHaskellDepends = [ base ruff ];
@@ -58523,7 +58734,7 @@ self: {
      mkDerivation {
        pname = "gruff-examples";
        version = "0.3.1";
-       sha256 = "02ygb88zxikf5ggw9ypyzganngk4dgfcszpkyzy6cwm47mksdzg7";
+       sha256 = "e7fda6673da47266fcf7f37ecddc6b643e6bd5fbfefac4df2b6ec6fe115acf0b";
        isLibrary = false;
        isExecutable = true;
        executableHaskellDepends = [
@@ -58541,7 +58752,7 @@ self: {
      mkDerivation {
        pname = "gsasl";
        version = "0.3.6";
-       sha256 = "0cgrw5ypkwp4mzj8m12q783jqng1jp1j7ny15704jmjxbq13cq3q";
+       sha256 = "786036025e5d5649c029c1db23c395e1592c073a58848ae4afe4f2797de1f931";
        libraryHaskellDepends = [ base bytestring transformers ];
        libraryPkgconfigDepends = [ gsasl ];
        homepage = "https://john-millikin.com/software/haskell-gsasl/";
@@ -58554,7 +58765,7 @@ self: {
      mkDerivation {
        pname = "gsc-weighting";
        version = "0.2.2";
-       sha256 = "0y80j5qk601c965assl8d91k9bpvzijn2z0w64n2ksij9lm6b8p5";
+       sha256 = "e5a2652a4d32ea292c311c7c6165fcfbae34436a886aad8a492c003371910079";
        libraryHaskellDepends = [ base hierarchical-clustering ];
        description = "Generic implementation of Gerstein/Sonnhammer/Chothia weighting";
        license = stdenv.lib.licenses.bsd3;
@@ -58565,7 +58776,7 @@ self: {
      mkDerivation {
        pname = "gsl-random";
        version = "0.5.0";
-       sha256 = "0bhwi2ianxazyxyp2siczk8rfdnj4dx3rfz5d82bag2xcbzcrbfj";
+       sha256 = "d2adccfe625d3cb5046ae5bb3c7a23d23697d1fc2c6a717df75f75aba2881c2e";
        libraryHaskellDepends = [ base vector ];
        homepage = "http://github.com/patperry/hs-gsl-random";
        description = "Bindings the the GSL random number generation facilities";
@@ -58578,7 +58789,7 @@ self: {
      mkDerivation {
        pname = "gsl-random-fu";
        version = "0.0.0.1";
-       sha256 = "1qf5m3zksn16mlgavrwbq6yd1mbyafy27qf1ws4nmkxl8ci0k48i";
+       sha256 = "1191092243b4cf6a89e6c1e123bc537ed5d0bcc18be7ad1ead26583dffa8c5e1";
        libraryHaskellDepends = [ base gsl-random random-fu ];
        homepage = "http://code.haskell.org/~mokus/gsl-random-fu";
        description = "Instances for using gsl-random with random-fu";
@@ -58593,7 +58804,7 @@ self: {
      mkDerivation {
        pname = "gsmenu";
        version = "3.0";
-       sha256 = "15ddm69fmk0nkkrs5g80amdvld2mq59ah58nbnk83mwkffpi484f";
+       sha256 = "8e2012af7393d781a65d1615a852c15534ba5b5500bda2f39c16ccea92a9ad95";
        isLibrary = false;
        isExecutable = true;
        executableHaskellDepends = [
@@ -58613,7 +58824,7 @@ self: {
      mkDerivation {
        pname = "gstreamer";
        version = "0.12.5.0";
-       sha256 = "0grg20wsvdyfpm2y3ykw7d3j7s2hlbs8psjwfy0yfz3839yvccy6";
+       sha256 = "c633b67d1a687ce781775cea8bf4a250e823473b7cfae145bdceb7ad39102f3f";
        libraryHaskellDepends = [
          array base bytestring directory glib mtl
        ];
@@ -58633,7 +58844,7 @@ self: {
      mkDerivation {
        pname = "gt-tools";
        version = "0.2.1";
-       sha256 = "1mkccxgnvgjxkbsdl6bcn61yv0zi20i8h9z11hqcfd3ibfnsw7bh";
+       sha256 = "701daead5b7134c7300ce127882210f183ed83b16c19daf49a5dbe6d5f676cd6";
        isLibrary = false;
        isExecutable = true;
        executableHaskellDepends = [
@@ -58651,7 +58862,7 @@ self: {
      mkDerivation {
        pname = "gtfs";
        version = "0.1";
-       sha256 = "0m0i13xpj9wz6ykngwfqi2vnrliwf0y1d2cxg9254dm865l5gvsi";
+       sha256 = "51ef576831a83652447a9d89163c703cd26cb788d8f167a7379f2779fb081154";
        libraryHaskellDepends = [
          base csv directory filepath rowrecord split
        ];
@@ -58667,7 +58878,7 @@ self: {
      mkDerivation {
        pname = "gtk";
        version = "0.13.9";
-       sha256 = "1mdz3s03y69713cr3grn8gawimykk8rs1f9vgch8a8q04ivhkq0j";
+       sha256 = "12e0097724002385207b3bb9a0339ad3d7c8d54336bf91d90827193f801ebfd5";
        libraryHaskellDepends = [
          array base bytestring cairo containers gio glib mtl pango text
        ];
@@ -58685,7 +58896,7 @@ self: {
      mkDerivation {
        pname = "gtk-helpers";
        version = "0.0.7";
-       sha256 = "0cx43z79r77ksicgz4ajg8b4hhllyfadcb46zdh6lg088zsgc6v7";
+       sha256 = "671bf6f447083c6a60fb862cd694f3944248167a5291ff58d4f39c9cce1fa433";
        libraryHaskellDepends = [
          array base gio glib gtk mtl process template-haskell
        ];
@@ -58699,7 +58910,7 @@ self: {
      mkDerivation {
        pname = "gtk-jsinput";
        version = "0.0.0";
-       sha256 = "0fjlk6z8j77l35k9cdzgbyf1w5wd0v0k1sry78vf7f6j4mvv8wb0";
+       sha256 = "6071b47725d2b8e3363a3eeb30c1068d171e9c5fef37966619f41c89be99543a";
        libraryHaskellDepends = [ base gtk json transformers ];
        homepage = "http://github.com/timthelion/gtk-jsinput";
        description = "A simple custom form widget for gtk which allows inputing of JSON values";
@@ -58713,7 +58924,7 @@ self: {
      mkDerivation {
        pname = "gtk-largeTreeStore";
        version = "0.0.1.0";
-       sha256 = "0nzddvm17gqkdjpkls4rd5lxshx8fwvn35b9r3njqqpm2yi5qci0";
+       sha256 = "20325ca217f5622cedc86995613777a843dd696999683aaf6c13bf13ea6eed5b";
        libraryHaskellDepends = [
          base containers glib gtk3 mtl nested-sets
        ];
@@ -58729,7 +58940,7 @@ self: {
      mkDerivation {
        pname = "gtk-mac-integration";
        version = "0.3.1.1";
-       sha256 = "02s5ksr8fkqlbwlq468v93w0is1xa73wswgxahyyvhh51wnqp3ax";
+       sha256 = "5d8d8b2d0f05c2ed3d54fd71cdc7513de808f8481b1982295f144f87b29e450b";
        libraryHaskellDepends = [ array base containers glib gtk mtl ];
        libraryPkgconfigDepends = [ gtk-mac-integration-gtk2 ];
        libraryToolDepends = [ gtk2hs-buildtools ];
@@ -58745,7 +58956,7 @@ self: {
      mkDerivation {
        pname = "gtk-serialized-event";
        version = "0.12.0";
-       sha256 = "0gh8kwd9758ws941xbxhrm3144pmnqln0md5r6vjbq7s1x54bsrf";
+       sha256 = "2eeb454a0ffae025b7c9a5556029b6f5121246cdb0af1e48d21c95931a9f083e";
        libraryHaskellDepends = [
          array base containers glib gtk haskell98 mtl
        ];
@@ -58761,7 +58972,7 @@ self: {
      mkDerivation {
        pname = "gtk-simple-list-view";
        version = "0.0.0";
-       sha256 = "1qqfhaap2996015h3jkgg9j3hyxrh88wn6kba29ys0q1h35f8yws";
+       sha256 = "9a7be4ca800103ed93506b1acb1182b97b38647a6fca014b0026257195820ee3";
        libraryHaskellDepends = [ base gtk ];
        homepage = "http://github.com/timthelion/gtk-simple-list-view";
        description = "A simple custom form widget for gtk which allows single LOC creation/updating of list views";
@@ -58773,7 +58984,7 @@ self: {
      mkDerivation {
        pname = "gtk-toggle-button-list";
        version = "0.0.0";
-       sha256 = "14hb7nxf4l0q7hab8dzll8dh5ccb4hhc8arywijdgdrz4i2s2706";
+       sha256 = "061ca145243fb7d764e43e2bc420248bb1021ba2f437b4143c1850e2ba3d0b92";
        libraryHaskellDepends = [ base gtk ];
        homepage = "http://github.com/timthelion/gtk-toggle-button-list";
        description = "A simple custom form widget for gtk which allows single LOC creation/updating of toggle button lists";
@@ -58785,7 +58996,7 @@ self: {
      mkDerivation {
        pname = "gtk-toy";
        version = "0.2.0";
-       sha256 = "0zf3k0c5h5wcgkqr8np5kvgz4c9nha86k5whsn4f1wk0ikj98dfq";
+       sha256 = "d83594e48c60f2e088d590976990823631f2df9ee55a94f17c8c17581898c37d";
        libraryHaskellDepends = [ base containers gtk ];
        jailbreak = true;
        description = "Convenient Gtk canvas with mouse and keyboard input";
@@ -58798,7 +59009,7 @@ self: {
      mkDerivation {
        pname = "gtk-traymanager";
        version = "0.1.5";
-       sha256 = "0hzl9pa5vx04vslb2visx35wwjagzzi1j5gyk5acy8pym8ly50hm";
+       sha256 = "1582e229aafe22cf5499fe1519e2ff4f49cecbe83a6eb1a8de04f45dd44df443";
        libraryHaskellDepends = [ base glib gtk ];
        libraryPkgconfigDepends = [ x11 ];
        homepage = "http://github.com/travitch/gtk-traymanager";
@@ -58813,7 +59024,7 @@ self: {
      mkDerivation {
        pname = "gtk2hs-buildtools";
        version = "0.13.0.4";
-       sha256 = "041mprflgqc74qb21czzy3m2nzj5mc3ji4i60f04dh2f2bac491a";
+       sha256 = "2a24c2d4124ec046800326922807ab457e2beaf0ffb320162687e1475dbe3510";
        isLibrary = false;
        isExecutable = true;
        executableHaskellDepends = [
@@ -58833,7 +59044,7 @@ self: {
      mkDerivation {
        pname = "gtk2hs-cast-glade";
        version = "0.10.1.1";
-       sha256 = "0azyf3h53r5dqvz66bbvqk9qp418v0mq0yzd1ia6pc6d7ypknkx6";
+       sha256 = "a64f3baf3fcdb06b540ced7b802bd828908bd3c47b2d63fec6ade451e070fe2b";
        libraryHaskellDepends = [
          base glade gtk gtk2hs-cast-glib hint template-haskell
        ];
@@ -58847,7 +59058,7 @@ self: {
      mkDerivation {
        pname = "gtk2hs-cast-glib";
        version = "0.10.1.1";
-       sha256 = "1bsz1zyz2hxf07q6xr232aciwxl3819jklj16hqqbfjwm4mzn2mp";
+       sha256 = "b70afb2ba95cba85313441d229534083761e991243e46ef001ae43f1fd0f5faf";
        libraryHaskellDepends = [ base glib ];
        description = "A type class for cast functions of Gtk2hs: glib package";
        license = "unknown";
@@ -58860,7 +59071,7 @@ self: {
      mkDerivation {
        pname = "gtk2hs-cast-gnomevfs";
        version = "0.10.1.2";
-       sha256 = "0fkrrsvagsn51rn0b16y8ac3fg509wrxqdfwsij9nbprcd8iz75g";
+       sha256 = "af9c1f5163f92e9b64d4dc35dc334fa03c379842de84056c0ec5eaa7b6ce793a";
        libraryHaskellDepends = [
          base gnomevfs gtk2hs-cast-glib gtk2hs-cast-th hint template-haskell
        ];
@@ -58876,7 +59087,7 @@ self: {
      mkDerivation {
        pname = "gtk2hs-cast-gtk";
        version = "0.10.1.2";
-       sha256 = "15d6c0mdd9nzpb310n19kyw0jqv019w17ncxxhg3wk90ckb43l3j";
+       sha256 = "72d041d664204d3e1eec9dd913780a606309b89f295810c6badfa6d62a60a695";
        libraryHaskellDepends = [
          base gtk gtk2hs-cast-glib gtk2hs-cast-th hint template-haskell
        ];
@@ -58892,7 +59103,7 @@ self: {
      mkDerivation {
        pname = "gtk2hs-cast-gtkglext";
        version = "0.10.1.2";
-       sha256 = "05m4h8wh820mwiarrysa4fkxj14l90ky89kv24irpa3vw27xnsm9";
+       sha256 = "a96adb8fe07ba89b23117b26e427489404d9a7234afb9c55e41508043982a416";
        libraryHaskellDepends = [
          base gtk2hs-cast-glib gtk2hs-cast-th gtkglext hint template-haskell
        ];
@@ -58908,7 +59119,7 @@ self: {
      mkDerivation {
        pname = "gtk2hs-cast-gtksourceview2";
        version = "0.10.1.2";
-       sha256 = "1fyca2kwjc4hk9jqshn9hzq4m7415kapdln1nv0rgxsd1iabjk81";
+       sha256 = "014db9540c4df797c1b6c1d276d52c819c4af087c9428d659a9030c9a750ccbb";
        libraryHaskellDepends = [
          base gtk2hs-cast-glib gtk2hs-cast-th gtksourceview2 hint
          template-haskell
@@ -58922,7 +59133,7 @@ self: {
      mkDerivation {
        pname = "gtk2hs-cast-th";
        version = "0.10.1.0";
-       sha256 = "19a7qb0dlfqw22fz7m94xyzbssvia106wlvy3brag5nhfza833px";
+       sha256 = "fd8e81d477d096a7f21a7e536e4050716bbdbeef24d5f39d101c3bdac0c247a5";
        libraryHaskellDepends = [ base hint template-haskell ];
        description = "A type class for cast functions of Gtk2hs: TH package";
        license = "unknown";
@@ -58933,7 +59144,7 @@ self: {
      mkDerivation {
        pname = "gtk2hs-hello";
        version = "1.1.0.0";
-       sha256 = "0km86yd8wkn85x8xr326a8pzrfmbrf0cpf6zz3sggk3kn4jrmbj4";
+       sha256 = "44ae9a25b173ccf7f4f8dfb8cb80cbabbafc2f52468cdc512fc84e8e9a37a84e";
        isLibrary = false;
        isExecutable = true;
        executableHaskellDepends = [ base glib gtk3 transformers ];
@@ -58948,7 +59159,7 @@ self: {
      mkDerivation {
        pname = "gtk2hs-rpn";
        version = "0.2.1";
-       sha256 = "01wikd60b48qcz6vk31kwfkpkf2za5laxbhdyns45s90lvr98rvi";
+       sha256 = "716794f2a620e942b4f50daeae68515fb879a7e3338cb9cd671891054c9b9107";
        libraryHaskellDepends = [ base cairo glib gtk mtl ];
        jailbreak = true;
        description = "Adds a module to gtk2hs allowing layouts to be defined using reverse polish notation";
@@ -58964,7 +59175,7 @@ self: {
      mkDerivation {
        pname = "gtk3";
        version = "0.14.0";
-       sha256 = "1j6nwjvjmzb144vbizraax0yf5bbkicg5hx2mm4z9ayacf58sm7c";
+       sha256 = "ec548d8a63caabf449ada2c3f2589c6b15e741572affb8362161fd2ab7e4d6c8";
        isLibrary = true;
        isExecutable = true;
        libraryHaskellDepends = [
@@ -58987,7 +59198,7 @@ self: {
      mkDerivation {
        pname = "gtk3-mac-integration";
        version = "0.3.2.0";
-       sha256 = "0m7659ca92w9yhd1fnraa255sx74qjagwsavd3navl41h687bzqj";
+       sha256 = "12ff75908181d0adec685b69fe94c4e4745d8a502a5b171af4898ba4582ae654";
        libraryHaskellDepends = [ array base containers glib gtk3 mtl ];
        libraryPkgconfigDepends = [ gtk-mac-integration-gtk3 ];
        libraryToolDepends = [ gtk2hs-buildtools ];
@@ -59004,7 +59215,7 @@ self: {
      mkDerivation {
        pname = "gtkglext";
        version = "0.12.5.0";
-       sha256 = "1xhalcb85cpswdpqxx64fxpmyqq7iakgaczjrbr25fp0h1glshhk";
+       sha256 = "13424d5f80e0ba22f2caf233f5a68a07635f6f77c4f48e6fe3fab28216a30af6";
        libraryHaskellDepends = [ base glib gtk pango ];
        libraryPkgconfigDepends = [ gtkglext ];
        libraryToolDepends = [ gtk2hs-buildtools ];
@@ -59022,7 +59233,7 @@ self: {
      mkDerivation {
        pname = "gtkimageview";
        version = "0.12.0";
-       sha256 = "0sdfb7gmgqh4dkc0a39abx84x7j7zs5z1l62nfzz22wsx1h641j3";
+       sha256 = "43066260e89a0bf1bfb3c2d0f08bfe479e4e505f2a0d05d86c04e257df59ae69";
        libraryHaskellDepends = [
          array base containers glib gtk haskell98 mtl
        ];
@@ -59042,7 +59253,7 @@ self: {
      mkDerivation {
        pname = "gtkrsync";
        version = "1.0.4";
-       sha256 = "0z7mwgmjpbmj2949bfrragyjr6s38vv9sz8zpy63ss9h7b5xn4xw";
+       sha256 = "bc13dbcb3a30693d8cbf1f7d9df646439b2cfd5339bb954812b2ae2bebe3f57c";
        isLibrary = false;
        isExecutable = true;
        executableHaskellDepends = [
@@ -59061,7 +59272,7 @@ self: {
      mkDerivation {
        pname = "gtksourceview2";
        version = "0.13.1.3";
-       sha256 = "1ji8sfkjggjxl4yrazm6n8gp74hlh3h28kjc9nfxka062bjmxfhf";
+       sha256 = "0eba5ee51206a8d99d4d4c4e24e0801492731fb2a67e953da15dbe27a7d328ca";
        libraryHaskellDepends = [
          array base containers glib gtk mtl text
        ];
@@ -59079,7 +59290,7 @@ self: {
      mkDerivation {
        pname = "gtksourceview3";
        version = "0.13.2.0";
-       sha256 = "0chn0rl5kkfi7y02h1x0gfkpbm4hfcl6pxrbdpfv20jk4m88a0qj";
+       sha256 = "12038550255302b1dd6d2bf76b287390d475a77ba00728803fd1cd5968061632";
        libraryHaskellDepends = [
          array base containers glib gtk3 mtl text
        ];
@@ -59095,7 +59306,7 @@ self: {
      mkDerivation {
        pname = "guarded-rewriting";
        version = "0.1";
-       sha256 = "04396pd4c4yqpw6ai5ciigva9l3acdz7yn4d5hvyks52khv5fsf9";
+       sha256 = "c96957369ca2e8e9372c8d587f7e636ad0a4f68b9195a80cbfd81346da356910";
        libraryHaskellDepends = [ base instant-generics ];
        homepage = "http://www.cs.uu.nl/wiki/GenericProgramming/GuardedRewriting";
        description = "Datatype-generic rewriting with preconditions";
@@ -59107,7 +59318,7 @@ self: {
      mkDerivation {
        pname = "guess-combinator";
        version = "0.1.1";
-       sha256 = "1xaj8zl6cbgks3r0asbnkz1ixq1hlglpjxdymj6ikyjq955sxmzj";
+       sha256 = "f2d7ae4b4958fa198dacbe7579e9a330e01ec39f766905f2d0f32d66e84752f5";
        libraryHaskellDepends = [ base HList ];
        homepage = "http://code.atnnn.com/project/guess";
        description = "Generate simple combinators given their type";
@@ -59120,7 +59331,7 @@ self: {
      mkDerivation {
        pname = "gulcii";
        version = "0.2.0.3";
-       sha256 = "0g86vgy0fhvmqvg1v1hxn6vrdcbq0n69fa0ysxvw7126ijrm5l29";
+       sha256 = "49d052b38c4684c377d71e28978c0578b196b7b11d861ddec6754307fcdb063d";
        isLibrary = false;
        isExecutable = true;
        executableHaskellDepends = [ base cairo containers filepath gtk ];
@@ -59135,7 +59346,7 @@ self: {
      mkDerivation {
        pname = "gutenberg-fibonaccis";
        version = "1.1.0";
-       sha256 = "0vvzlfnvh9r9jqf7v83d0piqpvl40sg0mswf9f41vncgzg0z79v2";
+       sha256 = "62a7f3c1fb8fd91d884b8eeb0a9e0684ee8be3056da07d1c962927b8ada37f6f";
        libraryHaskellDepends = [ base ];
        homepage = "https://github.com/justinhanekom/gutenberg-fibonaccis";
        description = "The first 1001 Fibonacci numbers, retrieved from the Gutenberg Project";
@@ -59147,7 +59358,7 @@ self: {
      mkDerivation {
        pname = "gyah-bin";
        version = "0.2.2.3";
-       sha256 = "19r2vsi5v43a3wq2vbfh2wfscmbzvcbyd1lqc2xdg4bbla9pf648";
+       sha256 = "88187793a26b91d7ba609886e617db7f55a61d17d0ad2d301f6a905da2de22a7";
        isLibrary = false;
        isExecutable = true;
        executableHaskellDepends = [ base extra GiveYouAHead ];
@@ -59163,7 +59374,7 @@ self: {
      mkDerivation {
        pname = "h-booru";
        version = "0.3.0.0";
-       sha256 = "0v2mcf35j4dr32j9n6rx10h7mx9d9f14bh70yphj01laxg240746";
+       sha256 = "861c40c4eb8a0620e1f5e0c045824b2df57a20083d1b9ba418b911598663556c";
        isLibrary = true;
        isExecutable = true;
        libraryHaskellDepends = [
@@ -59188,7 +59399,7 @@ self: {
      mkDerivation {
        pname = "h-gpgme";
        version = "0.3.0.0";
-       sha256 = "172awh918zldbivnn8jy24r30mxppgjvn2bz52phjxln02kcpm3x";
+       sha256 = "7dd4cba600967609af287f09bbe5bbb7573032115e226b775c8d7e1412e44a9c";
        libraryHaskellDepends = [
          base bindings-gpgme bytestring either time unix
        ];
@@ -59208,7 +59419,7 @@ self: {
      mkDerivation {
        pname = "h2048";
        version = "0.2.0.1";
-       sha256 = "1s8r476bhvmhpj914n4sjsa1z6dgf26m872rpzhlsyhw1rsxgcfr";
+       sha256 = "d9b1d7750e1c7a4de1bf591c548d70af991f94969a581292bcb06eb8cc2119e9";
        isLibrary = true;
        isExecutable = true;
        libraryHaskellDepends = [
@@ -59231,7 +59442,7 @@ self: {
      mkDerivation {
        pname = "hArduino";
        version = "0.9";
-       sha256 = "03wq0c9aqv3n27zcm74l2df75z3sr7kvyszgs0m2sn2680izl024";
+       sha256 = "4400fa234046582d2ad0ef6bbfe7c97afc725c13949ccafe11766cac1203980f";
        libraryHaskellDepends = [
          base bytestring containers mtl serialport time
        ];
@@ -59245,7 +59456,7 @@ self: {
      mkDerivation {
        pname = "hBDD";
        version = "0.0.3";
-       sha256 = "1jj8hj8wl95fy0n1qixhra4sqlmgddgn080plk7q7iv000qv67gk";
+       sha256 = "f31db3310060c783cfa41720605f6baf52ac89cab0471c2cf0ae24ca918448ca";
        libraryHaskellDepends = [ base ];
        description = "An abstraction layer for BDD libraries";
        license = "LGPL";
@@ -59258,7 +59469,7 @@ self: {
      mkDerivation {
        pname = "hBDD-CMUBDD";
        version = "0.0.3";
-       sha256 = "16pvi496qi3q2rrw08p6lndnsz6d6p65i8m10ldjlh143y8k9ga9";
+       sha256 = "49bd34911f24402a1b05a1a258cc35cd7c6d9ba5e622c0731678446c1289fb9a";
        libraryHaskellDepends = [ base containers deepseq hBDD unix ];
        librarySystemDepends = [ bdd mem ];
        libraryToolDepends = [ c2hs ];
@@ -59274,7 +59485,7 @@ self: {
      mkDerivation {
        pname = "hBDD-CUDD";
        version = "0.0.3";
-       sha256 = "1r94nj23pj134bd5b2mqk01g8xvbcn4ik2xs9yp01v1jg2clhjha";
+       sha256 = "0a4a48997832ec00ae4fba8b1989656b77f40298b88a55da2223c83b84b424e5";
        libraryHaskellDepends = [ base containers deepseq hBDD unix ];
        librarySystemDepends = [ cudd epd mtr st util ];
        libraryToolDepends = [ c2hs ];
@@ -59291,7 +59502,7 @@ self: {
      mkDerivation {
        pname = "hCsound";
        version = "0.4.2";
-       sha256 = "0z4zcf70jplm68k69kigj0kfx78r00y6fx6rjymzpvpbhppmyyd2";
+       sha256 = "a2795fef85ebeefbab97d974673c00199dee26902fce642632955e098e639f7c";
        libraryHaskellDepends = [ base monads-tf transformers vector ];
        librarySystemDepends = [ csound64 libsndfile ];
        libraryToolDepends = [ c2hs ];
@@ -59306,7 +59517,7 @@ self: {
      mkDerivation {
        pname = "hDFA";
        version = "0.0.2";
-       sha256 = "1ays1qy2zsl3h49ryr2y9dymfv1ak1m1d0jvarmqwg3nb49armhm";
+       sha256 = "15d6ac1259763c8e6b565b82166a982a6c577d4b5e649f138183ea2f3c0edaab";
        libraryHaskellDepends = [ base containers directory process ];
        description = "A simple library for representing and minimising DFAs";
        license = stdenv.lib.licenses.bsd3;
@@ -59318,7 +59529,7 @@ self: {
      mkDerivation {
        pname = "hF2";
        version = "0.2";
-       sha256 = "1y0731fsay2dp9m4b94w15m054vqsnnafz4k8jjqjvvrmwyfgicz";
+       sha256 = "9fc5e73caf796f89a544937ca7acd57893026a099ca4456aba4d78a55d1807f8";
        libraryHaskellDepends = [ base cereal vector ];
        description = "F(2^e) math for cryptography";
        license = stdenv.lib.licenses.bsd3;
@@ -59332,7 +59543,7 @@ self: {
      mkDerivation {
        pname = "hGelf";
        version = "0.1";
-       sha256 = "0jkgf0sm8xv204hrzpkplccfq88y5xyrm8y2b5gjfp473872jqxw";
+       sha256 = "bc63290e1a875c275f59c2a39a7d2f1e21ec18a377de9f210162775435706f4a";
        libraryHaskellDepends = [
          aeson base bytestring cereal network old-time pureMD5 QuickCheck
          text time zlib
@@ -59349,7 +59560,7 @@ self: {
      mkDerivation {
        pname = "hLLVM";
        version = "0.5.0.1";
-       sha256 = "0my2071si1x25q482rz48ihj6b9pg1vf6g722jdx8nbgri1x4wzz";
+       sha256 = "ff73d243cc6f59d49b14e23ce37678372d236144e46781082ea287a8c301c257";
        isLibrary = true;
        isExecutable = true;
        libraryHaskellDepends = [
@@ -59374,7 +59585,7 @@ self: {
      mkDerivation {
        pname = "hMollom";
        version = "0.4.0";
-       sha256 = "1grhkvmcdyi7gmmcqfqi3n78p4gbimzxa4mylj1f0j8iy5iycmg5";
+       sha256 = "e555e663f11149e082a4be12d57f8deb918b8e1d113bcc6a7d27fac6ea9e30bf";
        libraryHaskellDepends = [
          aeson attoparsec base bytestring Crypto dataenc ghc-prim HTTP mtl
          old-locale old-time pureMD5 random time
@@ -59390,23 +59601,23 @@ self: {
      , bifunctors, binary, binary-conduit, byteable, bytestring, bzlib
      , conduit, conduit-extra, containers, crypto-cipher-types
      , crypto-pubkey, crypto-random, cryptocipher, cryptohash
-     , data-default-class, errors, hashable, incremental-parser, ixset
-     , lens, monad-loops, nettle, network, network-uri, newtype
-     , old-locale, openpgp-asciiarmor, QuickCheck, quickcheck-instances
-     , resourcet, securemem, semigroups, split, tasty, tasty-hunit
-     , tasty-quickcheck, text, time, transformers, unordered-containers
-     , wl-pprint-extras, zlib
+     , data-default-class, errors, hashable, incremental-parser
+     , ixset-typed, lens, monad-loops, nettle, network, network-uri
+     , newtype, old-locale, openpgp-asciiarmor, QuickCheck
+     , quickcheck-instances, resourcet, securemem, semigroups, split
+     , tasty, tasty-hunit, tasty-quickcheck, text, time, transformers
+     , unordered-containers, wl-pprint-extras, zlib
      }:
      mkDerivation {
        pname = "hOpenPGP";
-       version = "2.1";
-       sha256 = "0jl2rciqgnhjw6q4xgdm2117vrj25l18hzl58fdls7j9bqlvrn5y";
+       version = "2.2";
+       sha256 = "21801a62585fea80bea3ecda11df0a7113923646d3d7856bc48db27b868fe0a0";
        libraryHaskellDepends = [
          aeson attoparsec base base64-bytestring bifunctors binary
          binary-conduit byteable bytestring bzlib conduit conduit-extra
          containers crypto-cipher-types crypto-pubkey crypto-random
          cryptocipher cryptohash data-default-class errors hashable
-         incremental-parser ixset lens monad-loops nettle network
+         incremental-parser ixset-typed lens monad-loops nettle network
          network-uri newtype old-locale openpgp-asciiarmor resourcet
          securemem semigroups split text time transformers
          unordered-containers wl-pprint-extras zlib
@@ -59416,7 +59627,7 @@ self: {
          bytestring bzlib conduit conduit-extra containers
          crypto-cipher-types crypto-pubkey crypto-random cryptocipher
          cryptohash data-default-class errors hashable incremental-parser
-         ixset lens monad-loops nettle network network-uri newtype
+         ixset-typed lens monad-loops nettle network network-uri newtype
          old-locale QuickCheck quickcheck-instances resourcet securemem
          semigroups split tasty tasty-hunit tasty-quickcheck text time
          transformers unordered-containers wl-pprint-extras zlib
@@ -59435,7 +59646,7 @@ self: {
      mkDerivation {
        pname = "hPDB";
        version = "1.2.0.4";
-       sha256 = "0fzr6y19x7c47y3jl68zcrjnlc8j3b0xnvvrpmqm15qznlrdh41s";
+       sha256 = "3a10d832b51f975071bd796fdbc11a12316a65661f192a873f849d9e8237f93b";
        libraryHaskellDepends = [
          AC-Vector base bytestring containers deepseq directory ghc-prim
          iterable mmap mtl Octree parallel QuickCheck tagged
@@ -59455,7 +59666,7 @@ self: {
      mkDerivation {
        pname = "hPDB-examples";
        version = "1.2.0.2";
-       sha256 = "1s1m09y3x8lpsdxs6ch77y1qipfy35swqwaj242aa0v5p8xs58wa";
+       sha256 = "8aa3a23bba6503a504115271cc7519dedd88833f0732a37bd397a23e7c0235e8";
        isLibrary = false;
        isExecutable = true;
        executableHaskellDepends = [
@@ -59480,7 +59691,7 @@ self: {
      mkDerivation {
        pname = "hPushover";
        version = "0.2";
-       sha256 = "14k3sdy2c0anfsw0hdir0l107ixlsnr90miwxrxdsckh40kz3ad3";
+       sha256 = "a3a9f127207032dd7aee3c5690b2d5b4c7030205393608b8765601267cd36392";
        libraryHaskellDepends = [
          aeson base bytestring http-conduit network text
        ];
@@ -59495,7 +59706,7 @@ self: {
      mkDerivation {
        pname = "hR";
        version = "0.1.1";
-       sha256 = "1kc03mgsxijszdvxw4qwq4fnd0ln61v08rk9y1k6kx9vyqc7bilc";
+       sha256 = "8cc67518f63bf56966f069660476309682661dc11c13de77fb5ac6ae5f1d80cd";
        libraryHaskellDepends = [ array base containers unix ];
        description = "R bindings and interface";
        license = stdenv.lib.licenses.bsd3;
@@ -59507,7 +59718,7 @@ self: {
      mkDerivation {
        pname = "hRESP";
        version = "0.1.0.0";
-       sha256 = "188rs1g2yacka8c4wbqkhwjrin95f3ribm8007lqsxiapaj1d89y";
+       sha256 = "3ea116a4ba2a768de90100d515f37025d9982587132f4e185293292f5ed019a1";
        libraryHaskellDepends = [ attoparsec base bytestring ];
        homepage = "https://github.com/yihuang/hresp";
        description = "haskell implementation of RESP (REdis Serialization Protocol)";
@@ -59522,7 +59733,7 @@ self: {
      mkDerivation {
        pname = "hS3";
        version = "0.5.9";
-       sha256 = "0nf71jb15gkkcrb0x83mmql6j55c6dnz3bl3yq1grphwn0jbmq3y";
+       sha256 = "7ee0ba24b01cdefc02f683aef16d33ac146928ae75a00e566673be12960cc759";
        isLibrary = true;
        isExecutable = true;
        libraryHaskellDepends = [
@@ -59541,7 +59752,7 @@ self: {
      mkDerivation {
        pname = "hSimpleDB";
        version = "0.3";
-       sha256 = "045mgg2b7wmkcziil8njb2wsy8pgzqcc46dwdrabxgbw1nzsfkaa";
+       sha256 = "4a4da7bf0d7cbdbe546ebc19c218feef22afb958d2221ae367b3f2b3c47bb510";
        libraryHaskellDepends = [
          base bytestring Crypto dataenc HTTP hxt network old-locale old-time
          utf8-string
@@ -59557,7 +59768,7 @@ self: {
      mkDerivation {
        pname = "hTalos";
        version = "0.2";
-       sha256 = "05l9nlrwpb9gwgj8z48paxx46lkasa82naiq7armi98salk1a9ip";
+       sha256 = "37261526551aa558b33a382a2b90d26a52437a5717918fe4e32fadcb33b58916";
        libraryHaskellDepends = [ base bytestring ];
        testHaskellDepends = [ base ];
        jailbreak = true;
@@ -59572,7 +59783,7 @@ self: {
      mkDerivation {
        pname = "hTensor";
        version = "0.8.2";
-       sha256 = "1nwzh68v2b11lph64432bjdrpxrr62cv4hdh935wml13mac3l2ly";
+       sha256 = "9e0a3a98aa23d0cacb48b041b2993039f79b9b5c621062e0a5212cb191819fdb";
        libraryHaskellDepends = [ base containers hmatrix random ];
        homepage = "http://perception.inf.um.es/tensor";
        description = "Multidimensional arrays and simple tensor computations";
@@ -59585,7 +59796,7 @@ self: {
      mkDerivation {
        pname = "hVOIDP";
        version = "1.0.2";
-       sha256 = "0r9a461k1rr0j9zgjfq1z37i6blv9rqf8pzb984h1nmlfqpnidnc";
+       sha256 = "ccb6682f76b4da00094aeb5fe4704e9b2e13cff8013bf97e9220e73083212a65";
        isLibrary = true;
        isExecutable = true;
        executableHaskellDepends = [ array base hmatrix ];
@@ -59601,7 +59812,7 @@ self: {
      mkDerivation {
        pname = "hXmixer";
        version = "0.3.0.0";
-       sha256 = "1n9wlg6inzvnyqkx61bpbgx744q25zpjhkihwbqv6569lgir1h4x";
+       sha256 = "9dc090e3a3c914b3f1e2304e28ef2f021372fa5b7705d327f6767f1bcda33cd9";
        revision = "2";
        editedCabalFile = "ba9345a3146b34d0101920f9efd6af7f435188dd7ae53b50d76cc0851f13014f";
        isLibrary = false;
@@ -59620,7 +59831,7 @@ self: {
      mkDerivation {
        pname = "haar";
        version = "0.1";
-       sha256 = "1xmz659lqr25c0xxkmly5w4fxgk9rqnms2sknd5ab8czqdgq6n1v";
+       sha256 = "3b58835fc39fa1a54ab3530b5d2dce69beee082f9ed6d93b6045644c5331bff6";
        libraryHaskellDepends = [ base split ];
        testHaskellDepends = [
          base QuickCheck test-framework test-framework-quickcheck2
@@ -59637,7 +59848,7 @@ self: {
      mkDerivation {
        pname = "hacanon-light";
        version = "2008.10.28";
-       sha256 = "0m0wfg74kmpz6ydldz5h9z5xd54957v1rprl9wal9sjr0pzl28a7";
+       sha256 = "472141ff0559ea44154f34df1cf6298994d6cb4fb0fc469b37ffd649ce731c54";
        libraryHaskellDepends = [ base mtl template-haskell ];
        description = "Template Haskell framework for automatic FFI code generation";
        license = stdenv.lib.licenses.bsd3;
@@ -59648,7 +59859,7 @@ self: {
      mkDerivation {
        pname = "hack";
        version = "2012.2.6";
-       sha256 = "0wrfa9fa6skl985fi2a6iv4m8kchg87w9x3k37nf3l8vaz95jmdr";
+       sha256 = "b95559d2571bd1e1ec1973f4c40f7a904d54c98e4689e80a4a746aa35c522e73";
        libraryHaskellDepends = [ base bytestring data-default ];
        homepage = "http://github.com/nfjinjing/hack/tree/master";
        description = "a Haskell Webserver Interface";
@@ -59663,7 +59874,7 @@ self: {
      mkDerivation {
        pname = "hack-contrib";
        version = "2010.9.28";
-       sha256 = "1r0g8fcwz6r4vrsadjyb5awjmfbqsskmc1c8xkfwv0knak1qq2p1";
+       sha256 = "e10a8cc3547682cdddec880556a7d678b92ab92acbcba674de249bcf99430fe4";
        libraryHaskellDepends = [
          ansi-wl-pprint base bytestring cgi containers data-default
          directory filepath hack haskell98 mps network old-locale old-time
@@ -59682,7 +59893,7 @@ self: {
      mkDerivation {
        pname = "hack-contrib-press";
        version = "0.1.2";
-       sha256 = "12v7xw448cxl93bnbzqkinlij74flffpif0x5jd51sndvpgsh12r";
+       sha256 = "5904a8dfddcdea509a2c1db8789da38e1c19a98d13ff65d748b4334408ef678b";
        libraryHaskellDepends = [
          base bytestring bytestring-class containers hack json mtl parsec
          press
@@ -59700,7 +59911,7 @@ self: {
      mkDerivation {
        pname = "hack-frontend-happstack";
        version = "2009.6.24.1";
-       sha256 = "1x4kaj4nk5lrgsm6pfxr6f8rvjyxhy0agqv9f810xh6s1r9pihw1";
+       sha256 = "81c378530edac00e027269e3a78087ddcb9d9133b9bb6baa7e999669895493f4";
        libraryHaskellDepends = [
          base bytestring containers hack happstack-server network
          utf8-string
@@ -59716,7 +59927,7 @@ self: {
      mkDerivation {
        pname = "hack-frontend-monadcgi";
        version = "0.0.3.1";
-       sha256 = "0m0af44jv03djn5i2lgrnnvvcdqx44qppfx76m1bwr7gv1vzm432";
+       sha256 = "6290fa77d8ef64be4235a7bb7b31211d37b6b7b5f951118b956d802d09710a54";
        libraryHaskellDepends = [ base bytestring cgi containers hack ];
        description = "Allows programs written against MonadCGI to run with any hack handler. (deprecated)";
        license = stdenv.lib.licenses.bsd3;
@@ -59727,7 +59938,7 @@ self: {
      mkDerivation {
        pname = "hack-handler-cgi";
        version = "0.2.0.2";
-       sha256 = "0pm8vs94dbaahqrdwfffwa1jb9ghyjnq48sirlw1dj2gcsa3np2x";
+       sha256 = "5d5c3b94664fc81638cd512382adf4f0a52583e2ce39de32864aad4692dea85e";
        libraryHaskellDepends = [ base bytestring hack ];
        jailbreak = true;
        homepage = "http://github.com/snoyberg/hack-handler-cgi/tree/master";
@@ -59742,7 +59953,7 @@ self: {
      mkDerivation {
        pname = "hack-handler-epoll";
        version = "0.1.3";
-       sha256 = "0q4cw789x8c93y53lwhr7g0hkli8x6qb9k0cg5pxln6cxxvi9p82";
+       sha256 = "02dd1477efcc58da6f790cccb4b0e928d209c13b19723a8a1f89a19ed0e18c60";
        libraryHaskellDepends = [
          base containers data-default epoll failure hack HTTP network unix
          utf8-string
@@ -59760,7 +59971,7 @@ self: {
      mkDerivation {
        pname = "hack-handler-evhttp";
        version = "2009.8.4";
-       sha256 = "1a09ls9jgakdx8ya6zd5z3ss2snb4pp0db1573hzmrhr37i2gklz";
+       sha256 = "9fce27e21919e6fae13825ac06ee25cb6aa1f5f8a57da33cea6daa2793a609a8";
        libraryHaskellDepends = [
          base bytestring bytestring-class containers data-default hack
          hack-contrib network
@@ -59777,7 +59988,7 @@ self: {
      mkDerivation {
        pname = "hack-handler-fastcgi";
        version = "0.2.0.1";
-       sha256 = "02slh33r9qy8q0vpi4s4vvf5lmb14ypk8bixdicvxakahjvxhanr";
+       sha256 = "d92ad8b7846aaabe596c3d2e34af2761555adcde44937837c0c8e394c780540b";
        libraryHaskellDepends = [ base bytestring hack hack-handler-cgi ];
        librarySystemDepends = [ fcgi ];
        jailbreak = true;
@@ -59794,7 +60005,7 @@ self: {
      mkDerivation {
        pname = "hack-handler-happstack";
        version = "2009.12.20";
-       sha256 = "10b3cp1gap59ialfl33dwhzw50nwrqg49zvv0v813q7rqk3nkhg4";
+       sha256 = "e4c169c7c4f9e011d0067bff441ecedc82c23fe46d0ceaa88aa95cf5c2656381";
        libraryHaskellDepends = [
          base bytestring cgi containers data-default hack happstack-server
          mtl network
@@ -59812,7 +60023,7 @@ self: {
      mkDerivation {
        pname = "hack-handler-hyena";
        version = "2010.3.15";
-       sha256 = "1p0zyki1iapz2xncq0l5bbas44pk5kb29kbb3bdxb4anb0m5jb2q";
+       sha256 = "582c592a585691d5db1a6bcd24d62cf312a2d55a8502cc6c17ffaa18e2f41fdc";
        libraryHaskellDepends = [
          base bytestring containers data-default hack hyena network
        ];
@@ -59827,7 +60038,7 @@ self: {
      mkDerivation {
        pname = "hack-handler-kibro";
        version = "2009.5.27";
-       sha256 = "0py30rp7r4hrazrfq3avpqcp1w8405pyfw1yxz7msb58yjppa792";
+       sha256 = "221d75aff4a82c5dcfef3e70e76f0104f17019be5b0decf25719927c6e06c35f";
        libraryHaskellDepends = [
          base cgi data-default hack kibro network
        ];
@@ -59844,7 +60055,7 @@ self: {
      mkDerivation {
        pname = "hack-handler-simpleserver";
        version = "0.2.2";
-       sha256 = "1p7igprgxkzkqhsy5n2qci75dbx2qxs1dcq8krghwj3isl6wds3y";
+       sha256 = "7ee8c60dd571480e5f9e08b31674c7a2af564e6458d8e235c4f3cffef27df1dc";
        libraryHaskellDepends = [
          base bytestring failure hack network web-encodings
        ];
@@ -59860,7 +60071,7 @@ self: {
      mkDerivation {
        pname = "hack-middleware-cleanpath";
        version = "0.0.1.1";
-       sha256 = "0107ajkiwkn33h56dz576y4dxl0sr2lkkcmjy6f9s2nzqp9ibin4";
+       sha256 = "c4c615d3c5df0a9d9cf1b2b239a9c81ad0de8837a7fc660a1cc34e1ea7540704";
        libraryHaskellDepends = [
          base bytestring hack split web-encodings
        ];
@@ -59877,7 +60088,7 @@ self: {
      mkDerivation {
        pname = "hack-middleware-clientsession";
        version = "0.0.1.1";
-       sha256 = "0h4l2lvshf9cqg43az9alq4rybhr4k07mhrila4fx7yjxslw871f";
+       sha256 = "2e1cc4a9eed29fee88a231c37ac024192e9f09a62a7d35c8c32c39a837159440";
        libraryHaskellDepends = [
          base clientsession hack old-locale predicates time web-encodings
        ];
@@ -59892,7 +60103,7 @@ self: {
      mkDerivation {
        pname = "hack-middleware-gzip";
        version = "0.0.0.1";
-       sha256 = "1x7526939h7g44yyscyk324gdb40cryyiffh13iinf8aw1rach70";
+       sha256 = "e040a672e00a391be308d0b9e87d6680acf68818d333ed3d21efc0349211e5f4";
        libraryHaskellDepends = [ base hack split zlib ];
        homepage = "http://github.com/snoyberg/hack-middleware-gzip/tree/master";
        description = "Automatic gzip compression of responses. (deprecated)";
@@ -59906,7 +60117,7 @@ self: {
      mkDerivation {
        pname = "hack-middleware-jsonp";
        version = "0.0.2.1";
-       sha256 = "0g7l441s0065f5dw2rj82m547nnc1i7cclx81kvgbpbi8q6hz0iw";
+       sha256 = "3c820f0d4671ddf5f60ca853c64e0cccda434a154866c15b71c500a00321f43c";
        libraryHaskellDepends = [
          base bytestring bytestring-class hack web-encodings
        ];
@@ -59921,7 +60132,7 @@ self: {
      mkDerivation {
        pname = "hack2";
        version = "2014.11.17";
-       sha256 = "1b6jzdisv58scyzb9pxhqrnz74sy0j96jkbbnf84wccwbwn4rf28";
+       sha256 = "48b84c2c5f9c314e90b36b4d6992045e93f36dc6b0dfb4be671a95ad63fbd2ac";
        libraryHaskellDepends = [ base bytestring data-default ];
        homepage = "https://github.com/nfjinjing/hack2";
        description = "a Haskell Webserver Interface (V2)";
@@ -59935,7 +60146,7 @@ self: {
      mkDerivation {
        pname = "hack2-contrib";
        version = "2015.5.4";
-       sha256 = "1vbdnbab5f090fp5zgviwbc2w33y7calgbh67fgxcaflhg0514vk";
+       sha256 = "739350c083d429d69f3b06ae47153b7e0c2ed8e271bf5fae0309b8b2d4b26ded";
        libraryHaskellDepends = [
          air base bytestring containers data-default directory filepath
          hack2 network-uri text time
@@ -59953,7 +60164,7 @@ self: {
      mkDerivation {
        pname = "hack2-contrib-extra";
        version = "2014.12.20";
-       sha256 = "1mxgvlr593cw523mknr5bcwf55544q04cz0nlpzgm5bg3336b5wl";
+       sha256 = "949765c6186f95fafea5167c460026a494e2385b25db5987289c8d5432ddafd7";
        libraryHaskellDepends = [
          air air-extra base bytestring cgi containers data-default directory
          filepath hack2 hack2-contrib network old-locale old-time time
@@ -59970,7 +60181,7 @@ self: {
      mkDerivation {
        pname = "hack2-handler-happstack-server";
        version = "2011.6.20";
-       sha256 = "115nrzf0626pc716n01qjhxs44c1awdd4q1c8kbax025cwac7kpx";
+       sha256 = "fdcec314674580aed6442c60d21a578111a23b9438006bc261d70803dccfb684";
        libraryHaskellDepends = [
          base bytestring cgi containers data-default enumerator hack2
          happstack-server mtl network
@@ -59991,7 +60202,7 @@ self: {
      mkDerivation {
        pname = "hack2-handler-mongrel2-http";
        version = "2011.10.31";
-       sha256 = "1pymar803n696yx3dwqpfwqlkg93ncff162p26mrs7iqn14v851w";
+       sha256 = "3c14b449b0381e9dab115798e01cb323bd49317717f336ba37c9d8015056d5df";
        libraryHaskellDepends = [
          aeson air attoparsec base blaze-builder blaze-textual bytestring
          containers data-default directory enumerator hack2 mtl network safe
@@ -60011,7 +60222,7 @@ self: {
      mkDerivation {
        pname = "hack2-handler-snap-server";
        version = "2015.3.9";
-       sha256 = "1qs5mncl44p410ni8hbpgvmv81158z62mcg66fmnnlrkwdr1bbh7";
+       sha256 = "07ae1572e333536bab33e6b12acc472504b4eb7e7741142d08e4124299ad45e3";
        libraryHaskellDepends = [
          air base blaze-builder bytestring case-insensitive containers
          data-default directory enumerator hack2 mtl network snap-core
@@ -60029,7 +60240,7 @@ self: {
      mkDerivation {
        pname = "hack2-handler-warp";
        version = "2012.5.25";
-       sha256 = "1p0lkhf95xkllfpcb9yibpa1rkam90bccmzj2aa60shd7v9qx9r5";
+       sha256 = "25a78ed33e0d6a609412f257c6164855cd1cd45dd1a7c5aea374f6921c9c14dc";
        libraryHaskellDepends = [
          air base data-default hack2 hack2-interface-wai warp
        ];
@@ -60047,7 +60258,7 @@ self: {
      mkDerivation {
        pname = "hack2-interface-wai";
        version = "2012.5.25";
-       sha256 = "18yyvb38axz18ac2q9z31qmqjd3d9yrzsgiv11wbf8ccdp2irm5w";
+       sha256 = "bcd41cc56d8c21b778083b3efdb34f6d34892b0ee3272c9842e17785c6dadea3";
        libraryHaskellDepends = [
          air base bytestring case-insensitive containers data-default hack2
          http-types mtl network safe wai
@@ -60065,7 +60276,7 @@ self: {
      mkDerivation {
        pname = "hackage-db";
        version = "1.22";
-       sha256 = "0rhh7w4929zkwzv10ika952yiw4dkffqd8f79f1bl76lz1la6cjd";
+       sha256 = "4d32a368f8d41cba824bc7a1869d9b8df0e845496a4610f6e7f32791083f1066";
        revision = "1";
        editedCabalFile = "b5277a8cbbfcfba81f29db4910003c2fa7e34c06bceb4f3e7318510e1ce74376";
        libraryHaskellDepends = [
@@ -60084,7 +60295,7 @@ self: {
      mkDerivation {
        pname = "hackage-diff";
        version = "0.1.0.0";
-       sha256 = "0kdc7ah1mn6xcaan56li9k7ccrcsjz3ysi04fp334l57kd3i105z";
+       sha256 = "bf8010479ba75032c6750444edc7979a65c6ce4c919a629562ddd81aa03aac4d";
        isLibrary = false;
        isExecutable = true;
        executableHaskellDepends = [
@@ -60109,7 +60320,7 @@ self: {
      mkDerivation {
        pname = "hackage-mirror";
        version = "0.1.0.0";
-       sha256 = "1iaaxdn4lsfrjksax8c9pawrjwj4sb6irqd4sfkdm3k9l2f8nqvg";
+       sha256 = "6f638b9ca0698edaa6d3a4e11ccdd2447299b9ba89a1aef494d9694a6ceb4ac5";
        revision = "1";
        editedCabalFile = "848ea26073e706a9303ec1baf811a74b65859ae649731a3b799b4fb8c558c1bc";
        isLibrary = true;
@@ -60137,7 +60348,7 @@ self: {
      mkDerivation {
        pname = "hackage-plot";
        version = "0.2.1";
-       sha256 = "11vlnmadnjz1q4iw4ay8gh1yclba7550mnxwakdryakws5v75am1";
+       sha256 = "a1aa7276d17c2a9fdb54bcdb0a4a396a51e6037cc82bc223c1e14bdb54b57487";
        isLibrary = false;
        isExecutable = true;
        executableHaskellDepends = [
@@ -60159,7 +60370,7 @@ self: {
      mkDerivation {
        pname = "hackage-proxy";
        version = "0.3.0.1";
-       sha256 = "1vicmj070nb76zcxfmkj4sv0rxrrl13r31psnsgb8azbmvs1s0yp";
+       sha256 = "d7031df4aeeb2bb49eb6fa869147a039f70cb6267256d7d93767597080ac2cee";
        isLibrary = false;
        isExecutable = true;
        executableHaskellDepends = [
@@ -60188,7 +60399,7 @@ self: {
      mkDerivation {
        pname = "hackage-server";
        version = "0.5.0";
-       sha256 = "1xsy2clsg53rhxgkb9vlan7dw7xqphm8gr1ajl8kq5ymfahnyd1i";
+       sha256 = "31346fa172d5173c11952ae4872abcb81fde8e5574a7355f877994a729135ef7";
        isLibrary = false;
        isExecutable = true;
        executableHaskellDepends = [
@@ -60220,7 +60431,7 @@ self: {
      mkDerivation {
        pname = "hackage-sparks";
        version = "0.5.1";
-       sha256 = "0b43vd1b18ksivxr7cfymzwcgs8rhwib2prn86wmwhghyx8a4qnw";
+       sha256 = "dc62a250f7f0415eb941365fb1228719e9c7f8afdeb193fb8e7aa2b042db832c";
        isLibrary = false;
        isExecutable = true;
        executableHaskellDepends = [
@@ -60238,7 +60449,7 @@ self: {
      mkDerivation {
        pname = "hackage2hwn";
        version = "0.5.1";
-       sha256 = "0vbp7c1g7dx119xxsn0f0fhk14l35jxmg7zdaqr1vcjhprj3nh6q";
+       sha256 = "d8403b64be50b21d3256ed9f57bb2c839230a1030e58dd7b0aa1b7f3023b776d";
        isLibrary = false;
        isExecutable = true;
        executableHaskellDepends = [ base download feed tagsoup ];
@@ -60253,7 +60464,7 @@ self: {
      mkDerivation {
        pname = "hackage2twitter";
        version = "0.2.1";
-       sha256 = "131hl59imxhql3hfp8m9363fgsgdywz1p8idrybncipyblwpsjgq";
+       sha256 = "f8497d395dfe466697cf2da21b3ef7ede9e78619a9a2ebe0a018f61a53a1308c";
        isLibrary = false;
        isExecutable = true;
        executableHaskellDepends = [ base feed feed2twitter ];
@@ -60270,7 +60481,7 @@ self: {
      mkDerivation {
        pname = "hackager";
        version = "1.2.0.1";
-       sha256 = "06lrsfs70zjhxqsz93wmhrmyq1v64kiq0580f9im9nw69w4yl4ax";
+       sha256 = "5d11ea094f86db546372001580e3246607ec6b86958ff435ee507e70b4d3991a";
        isLibrary = false;
        isExecutable = true;
        executableHaskellDepends = [
@@ -60289,7 +60500,7 @@ self: {
      mkDerivation {
        pname = "hackernews";
        version = "0.5.0.0";
-       sha256 = "1yj8wip52dagmdpziyyjs9hp7k1gdvwl6ynk5hr8c8wxapcj28bs";
+       sha256 = "7a2121d9559d2386322cd37a43f96e2fcc7361d2d2fbf86fab4f35516ee448fa";
        libraryHaskellDepends = [
          aeson attoparsec base bytestring either HsOpenSSL http-streams
          io-streams text time transformers
@@ -60305,7 +60516,7 @@ self: {
      mkDerivation {
        pname = "hackertyper";
        version = "0.1.0.1";
-       sha256 = "17c77f687874bfwahmzcz2v6k8z9p4fv555r5r1f38snsdi825gf";
+       sha256 = "ee158162d356a3e1422eb994b21db9e9a369b6f8ec57a8b85be4a0838c3b879d";
        isLibrary = false;
        isExecutable = true;
        executableHaskellDepends = [ base ];
@@ -60323,7 +60534,7 @@ self: {
      mkDerivation {
        pname = "hackport";
        version = "0.4.5";
-       sha256 = "18sv8kwhg0frsn6phg47hsm5vv84yaxxvk47sazgrb5hjl3qiam7";
+       sha256 = "a7aa880795b0acfcbed287ccddbbf204ed5daa86873c788dd5d98107f9445ba3";
        isLibrary = false;
        isExecutable = true;
        executableHaskellDepends = [
@@ -60348,7 +60559,7 @@ self: {
      mkDerivation {
        pname = "hactor";
        version = "1.2.0.0";
-       sha256 = "0jgnifwgfxapi8l0ds56xr7h66jprn1ynpwmvhafbyk84ymznf8y";
+       sha256 = "1e39fbab2768fae514dc955feb83cd571a034feea6e806288a5775f7b88bf649";
        libraryHaskellDepends = [
          base containers monad-control mtl resourcet stm stm-chans
          transformers-base
@@ -60365,7 +60576,7 @@ self: {
      mkDerivation {
        pname = "hactors";
        version = "0.0.3.1";
-       sha256 = "0nxcl3v9gnnyjzdpk30m2pmrhwcva9rky2dxrj4nnkr67ajm2dj0";
+       sha256 = "403651a53a264f6b89ccbd093f73529b7198eb15158c79db97deda97f6a0ac5b";
        libraryHaskellDepends = [ base stm ];
        jailbreak = true;
        homepage = "https://github.com/treep/hactors";
@@ -60380,7 +60591,7 @@ self: {
      mkDerivation {
        pname = "haddock";
        version = "2.16.1";
-       sha256 = "1mnnvc5jqp6n6rj7xw8wdm0z2xp9fndkz11c8p3vbljsrcqd3v26";
+       sha256 = "46ecd130cb5ad2b5c7452c843f9b75e976f1416d1cf17e6436d65c2c0bdbd6d6";
        isLibrary = false;
        isExecutable = true;
        executableHaskellDepends = [ base haddock-api ];
@@ -60399,7 +60610,7 @@ self: {
      mkDerivation {
        pname = "haddock-api";
        version = "2.15.0.2";
-       sha256 = "1gdmwid3qg86ql0828bp8g121psvmz11s0xivrzhiv8knxbqj8l7";
+       sha256 = "87228957b713ed087fdeb1031dc2af5bdf20c24377218100c5063d3c5ae4b5bd";
        libraryHaskellDepends = [
          array base bytestring Cabal containers deepseq directory filepath
          ghc ghc-paths haddock-library xhtml
@@ -60418,7 +60629,7 @@ self: {
      mkDerivation {
        pname = "haddock-api";
        version = "2.16.1";
-       sha256 = "1spd5axg1pdjv4dkdb5gcwjsc8gg37qi4mr2k2db6ayywdkis1p2";
+       sha256 = "e2061d67e3de2bb39a98225712f119ef21a62567afac361bd9b2ddf0ba2aedea";
        libraryHaskellDepends = [
          array base bytestring Cabal containers deepseq directory filepath
          ghc ghc-paths haddock-library xhtml
@@ -60435,7 +60646,7 @@ self: {
      mkDerivation {
        pname = "haddock-leksah";
        version = "2.6.0";
-       sha256 = "1a56nihkxybldk55g69v2aw6r4ipa9x86i0jr19fd23zxvancs8h";
+       sha256 = "106966d5ee7f88e652c81244837a5237926cb8123b9957ca6c74f93e61b4a6a8";
        isLibrary = true;
        isExecutable = true;
        executableHaskellDepends = [
@@ -60455,7 +60666,7 @@ self: {
      mkDerivation {
        pname = "haddock-library";
        version = "1.2.1";
-       sha256 = "0mhh2ppfhrvvi9485ipwbkv2fbgj35jvz3la02y3jlvg5ffs1c8g";
+       sha256 = "0fb1a09d2b6f5339bc008a8ebf6519f22d27f65cfcc682488a7b67e8ee151056";
        libraryHaskellDepends = [ base bytestring deepseq transformers ];
        testHaskellDepends = [
          base base-compat bytestring deepseq hspec QuickCheck transformers
@@ -60474,7 +60685,7 @@ self: {
      mkDerivation {
        pname = "haddocset";
        version = "0.3.2";
-       sha256 = "0ppbvmmiz07p8kyblkplzkki3kc4z8hlmxc9h18fj0xwr6dpfib7";
+       sha256 = "6745779bc9bc03e9508089f54a21fa84cd11e7fcf44ebafc44f7801f6bddeb5e";
        isLibrary = false;
        isExecutable = true;
        executableHaskellDepends = [
@@ -60496,7 +60707,7 @@ self: {
      mkDerivation {
        pname = "hadoop-formats";
        version = "0.2.1.1";
-       sha256 = "1w3869jz3mxhzdik5fwaha7dn9rhjg5w8g0qnznd4x45cnzxv5ga";
+       sha256 = "ea95ddbf658574d2ecb7183cc4cb933027db8e828abb3263fbb0d7f1653268f0";
        revision = "1";
        editedCabalFile = "59248cb9b3f28b9f003d694ee356a13ff1313c8edd3bf2963c154ce7e1de0553";
        libraryHaskellDepends = [ attoparsec base bytestring text vector ];
@@ -60516,7 +60727,7 @@ self: {
      mkDerivation {
        pname = "hadoop-rpc";
        version = "1.0.0.1";
-       sha256 = "1nm1xgb1ks57sbqg8x8aasr5l8lgdf4inr4ndgnnlsdjah6nbli1";
+       sha256 = "21d2650d54b2696aed6b96641b896b8f225ab2560a75f4f0d2a7e819d6eba1da";
        libraryHaskellDepends = [
          attoparsec base bytestring cereal exceptions hashable monad-loops
          network protobuf random socks stm text transformers unix
@@ -60538,7 +60749,7 @@ self: {
      mkDerivation {
        pname = "hadoop-tools";
        version = "0.7.2";
-       sha256 = "0grwi26xardg8fxvz7g10v9111bgph77s3pdrr58r9hqgm8lhx5v";
+       sha256 = "bb7448517d18a68c4aceed0e7d0ebc6f8510d206e19dbfbb43af65d58d883c3f";
        isLibrary = false;
        isExecutable = true;
        executableHaskellDepends = [
@@ -60562,7 +60773,7 @@ self: {
      mkDerivation {
        pname = "haeredes";
        version = "0.4.3";
-       sha256 = "0m6d75kgf40m3vnh148v2ysfhplspqbbqs8jha29ascap8xz7n47";
+       sha256 = "87d8f33bba8a699584821269bc16be9a5ee8b4171b9100ed1e1510f76639cd54";
        isLibrary = false;
        isExecutable = true;
        executableHaskellDepends = [
@@ -60584,7 +60795,7 @@ self: {
      mkDerivation {
        pname = "haggis";
        version = "0.1.2.1";
-       sha256 = "09mqs4y26w7f4729gvrpv9mh431xpdngas14ad86bbjf2ncvggjg";
+       sha256 = "4fbeb799154eae6550532468f56cbb3d0c026bda37ef97c421ee70233cd1b826";
        isLibrary = true;
        isExecutable = true;
        libraryHaskellDepends = [
@@ -60607,7 +60818,7 @@ self: {
      mkDerivation {
        pname = "haha";
        version = "0.3.1.1";
-       sha256 = "1vfsy6ks9rnynwvavakj90662vxgvk7y0vwpdga2k2fc8nkqjf10";
+       sha256 = "203889a745cc8929d46b976fe0cfdcaf6f610c4872aaad36b7dee6a4a7f1daed";
        isLibrary = true;
        isExecutable = true;
        libraryHaskellDepends = [ base containers time ];
@@ -60624,7 +60835,7 @@ self: {
      mkDerivation {
        pname = "hailgun";
        version = "0.4.0.3";
-       sha256 = "1c4fd116xhkw0hknzfyxyw7v62wjixcdbdidx804rs8g8f3c5p1c";
+       sha256 = "2cdcc286430fe94c00ea2db6d5588f920bb30ff7ddbb6f27047cc26e42688eb0";
        libraryHaskellDepends = [
          aeson base bytestring email-validate exceptions filepath
          http-client http-client-tls http-types tagsoup text time
@@ -60640,7 +60851,7 @@ self: {
      mkDerivation {
        pname = "hailgun-send";
        version = "0.1.1.1";
-       sha256 = "1cxvzg5bfwsdly9k24izwnk5gf9vvzisaj3m6ng647bm1fc598c6";
+       sha256 = "86a154980b751d629e357548a5e3df3bb957a6e53f123193a74d73b7cafbbbb3";
        isLibrary = false;
        isExecutable = true;
        executableHaskellDepends = [
@@ -60665,7 +60876,7 @@ self: {
      mkDerivation {
        pname = "hails";
        version = "0.11.2.1";
-       sha256 = "1s447iqgpxsx78zd873izyqhdq34dz1ikjcfw8m9r0rv5nkxkf7c";
+       sha256 = "ecb8d9a72d3b839c2ae28ec919c36f64e006b1ff711cd43e3a5df7fb703c84e8";
        isLibrary = true;
        isExecutable = true;
        libraryHaskellDepends = [
@@ -60701,7 +60912,7 @@ self: {
      mkDerivation {
        pname = "hails-bin";
        version = "0.1.1.1";
-       sha256 = "006qy5mkhh8zqy9mrpwjiym7klqma49zglwpjmx2ikmkkq9qnfvr";
+       sha256 = "793b8b139eb3ce287a9597d3f7135115d379aa8f92df5c93c71f41386bf1d800";
        isLibrary = false;
        isExecutable = true;
        executableHaskellDepends = [
@@ -60722,7 +60933,7 @@ self: {
      mkDerivation {
        pname = "hairy";
        version = "0.1.3";
-       sha256 = "19kgygj9d3m56xcfc1zm0ki2ncgifrrsrf90bvp9bykyixycplap";
+       sha256 = "57d1cb7c8f7efa95ee5e20b9ac7376f1312be204f507e65837a58e96e4f36fa6";
        isLibrary = true;
        isExecutable = true;
        libraryHaskellDepends = [
@@ -60752,7 +60963,7 @@ self: {
      mkDerivation {
        pname = "hakaru";
        version = "0.1.4";
-       sha256 = "033m28jckpqgc4izmyf4h60riy29mcvfhyw340z604miqg7ss2hf";
+       sha256 = "0e0aadcfc3b112603e20837be836ab49f8988181c4f9fa23610fdfc92412750c";
        libraryHaskellDepends = [
          aeson array base bytestring cassava containers directory hmatrix
          integration logfloat math-functions monad-loops mwc-random parallel
@@ -60779,7 +60990,7 @@ self: {
      mkDerivation {
        pname = "hake";
        version = "1.3.8.1";
-       sha256 = "0h0y466b664xyxi1hr8c7il4cslrmb1hyhsjzhvs55l33zb7591b";
+       sha256 = "2ba472d61f8396a237fc52430fc3aa996a46683c0c651862f79d18b38c211e40";
        isLibrary = true;
        isExecutable = true;
        libraryHaskellDepends = [ base filepath mtl time ];
@@ -60794,7 +61005,7 @@ self: {
      mkDerivation {
        pname = "hakismet";
        version = "0.1";
-       sha256 = "1ddmnzan16vn0fbp1fgsidahayihhr0vw8saypdqq7lnhqw8j9d4";
+       sha256 = "a425893886961e8cdbf54a23be4186307a05558bfab9709703769b60d5b7b5b5";
        libraryHaskellDepends = [ base HTTP network ];
        jailbreak = true;
        homepage = "https://code.reaktor42.de/projects/hakismet";
@@ -60810,7 +61021,7 @@ self: {
      mkDerivation {
        pname = "hako";
        version = "1.0.0";
-       sha256 = "1gcw15522yh0aa7xa793gda45qmq8my15id4ybivv3n16pcr7prm";
+       sha256 = "35df93d935c18ebde3f2a4c5127c45b8e242547b231dd58f52007a214a099cbd";
        libraryHaskellDepends = [
          base haskell-src-meta parsec template-haskell text transformers
        ];
@@ -60832,8 +61043,8 @@ self: {
      }:
      mkDerivation {
        pname = "hakyll";
-       version = "4.7.2.2";
-       sha256 = "1gy7j15qqh8m0wf8xkpb1hglahylwyy7vq6c4bm9arap3viak29c";
+       version = "4.7.2.3";
+       sha256 = "66b98d930b1312108bb690200985a273fcec2a39ff7b807f246b82c2609c28b1";
        isLibrary = true;
        isExecutable = true;
        libraryHaskellDepends = [
@@ -60852,7 +61063,7 @@ self: {
          pandoc pandoc-citeproc parsec process QuickCheck random regex-base
          regex-tdfa snap-core snap-server system-filepath tagsoup
          test-framework test-framework-hunit test-framework-quickcheck2 text
-         time
+         time time-locale-compat
        ];
        homepage = "http://jaspervdj.be/hakyll";
        description = "A static website compiler library";
@@ -60865,7 +61076,7 @@ self: {
      mkDerivation {
        pname = "hakyll-R";
        version = "0.1.0.3";
-       sha256 = "0sr0mpyhjr7ajg227rfylhv2950vip6zkryalxp39m1xv0dh2rb3";
+       sha256 = "6365011bd83dd4346ea7cae7f9cd8d1b942436a4dee523c493ea6409fdad206b";
        libraryHaskellDepends = [
          base directory filepath hakyll pandoc process
        ];
@@ -60882,7 +61093,7 @@ self: {
      mkDerivation {
        pname = "hakyll-agda";
        version = "0.1.10";
-       sha256 = "1621l7pw2rcyalp17dcjp1bk650rs8w1i3swnwrzr9wwi6nrx7qb";
+       sha256 = "0b9f9ead899ca7fc33b75c8f1838d219143357b892b5132e559e65c1efa14198";
        libraryHaskellDepends = [
          Agda base containers directory filepath hakyll mtl pandoc
          transformers xhtml
@@ -60898,7 +61109,7 @@ self: {
      mkDerivation {
        pname = "hakyll-blaze-templates";
        version = "0.1.1.0";
-       sha256 = "11dl3rqls2yxkmycx63xr1cix4adk6b29sbwr4v5n48bqamr7p1j";
+       sha256 = "32dc93abc20b115b36c97ce92496994d911e59c87d98ce7c9ddd0b4d711eb485";
        libraryHaskellDepends = [ base blaze-html blaze-markup hakyll ];
        jailbreak = true;
        description = "Blaze templates for Hakyll";
@@ -60911,7 +61122,7 @@ self: {
      mkDerivation {
        pname = "hakyll-contrib";
        version = "0.1.0.1";
-       sha256 = "0w23laiw6a5hxfq5hjq8vn3k7fx5l4yb9p8qcbm62zlycza1ci14";
+       sha256 = "244416d4679e7e61ea6218ddb43ca1a5bb3387dd084b58b0ebb028c3a3a24370";
        isLibrary = true;
        isExecutable = true;
        libraryHaskellDepends = [ base hakyll pandoc ];
@@ -60928,7 +61139,7 @@ self: {
      mkDerivation {
        pname = "hakyll-contrib-hyphenation";
        version = "0.1.0.3";
-       sha256 = "0mkbsivifggi64k97ssxb0dskzwf7h0sny4m8gmkdsvwqjhfdjam";
+       sha256 = "55c9e6a0c47ceb36eb439578ab013c8effa91b585deb932631f13d1777d46b56";
        libraryHaskellDepends = [ base hakyll hyphenation split tagsoup ];
        jailbreak = true;
        homepage = "https://bitbucket.org/rvlm/hakyll-contrib-hyphenation";
@@ -60944,7 +61155,7 @@ self: {
      mkDerivation {
        pname = "hakyll-contrib-links";
        version = "0.2.0.0";
-       sha256 = "0gzg88pcqxwj4qwr2qj24csjljvxcz3v9iclhz5f9g8dx41rkiy5";
+       sha256 = "c5c79903e90dbde4ca8794c5b4c7677d4b2a352342629139269277cc2e42ef3f";
        libraryHaskellDepends = [
          base binary containers hakyll pandoc pandoc-types parsec
        ];
@@ -60964,7 +61175,7 @@ self: {
      mkDerivation {
        pname = "hakyll-convert";
        version = "0.1.0.0";
-       sha256 = "1dvif26avp6fczhlg8pi591wp8d1z3kvjr745r5p17lzwpwy1rx3";
+       sha256 = "a3e7e0f9e59f9e704b2ee464b9e7f8a1a1cb432af1a247e167cedcad8c7071b7";
        isLibrary = true;
        isExecutable = true;
        libraryHaskellDepends = [
@@ -60985,7 +61196,7 @@ self: {
      mkDerivation {
        pname = "hakyll-elm";
        version = "0.2.1";
-       sha256 = "0bgwcxarsa40aylvg4cc7ha5y87xklkc4ifwd17l69l4xbb4iqpk";
+       sha256 = "f3e248d6ea8426434f68dc45c2269dfd205f143c8c91b7a95780289d5567fc2d";
        libraryHaskellDepends = [
          base blaze-html blaze-markup Elm hakyll mtl
        ];
@@ -61004,7 +61215,7 @@ self: {
      mkDerivation {
        pname = "halberd";
        version = "0.1.2.9";
-       sha256 = "1d8r1cz9q9mgw1abz8b8n6lnnc19g223hv3igznxfldbws7d6zrj";
+       sha256 = "327fd38ee6ab51d7ed7f716c38847829306ba9b168a1bf54e0af269c3e0b19b5";
        isLibrary = true;
        isExecutable = true;
        libraryHaskellDepends = [
@@ -61032,7 +61243,7 @@ self: {
      mkDerivation {
        pname = "half";
        version = "0.2.0.1";
-       sha256 = "0lwh5bv8pnp9fzq64z1fg1i4fv8h2lcchs1298agq881hcay19qw";
+       sha256 = "1ca7e015830121fc144a2268c81815106d4762782e7c62f077e9da8bf62a9053";
        revision = "1";
        editedCabalFile = "cfadc0b87a5d9c4cc9a3ab5d7a5524221ae88e962f812eb41beba7b39111ccce";
        libraryHaskellDepends = [ base ];
@@ -61049,7 +61260,7 @@ self: {
      mkDerivation {
        pname = "halfs";
        version = "2.0";
-       sha256 = "1k47q0vp0cmvmxz28hmv8dgniz9ks7h0wjjmdkjgvb77p8jj2akd";
+       sha256 = "6d2a2125bae7acfde46c554a0ee0d133fd685f43bb42247eafbb327037c087cc";
        isLibrary = true;
        isExecutable = true;
        libraryHaskellDepends = [
@@ -61071,7 +61282,7 @@ self: {
      mkDerivation {
        pname = "halipeto";
        version = "2.4.1";
-       sha256 = "1anyf6mh13rmj5a0lsayrcxzvm3zk0a2943pzkgz06y3aqgmcbdb";
+       sha256 = "ab2d561f56c31bf0dffc77902414987fd4fd3bcb5e690a5491358f00ab71deaa";
        libraryHaskellDepends = [ base directory HaXml pandoc ];
        jailbreak = true;
        homepage = "http://github.com/peti/halipeto";
@@ -61082,18 +61293,19 @@ self: {
 
   "halive" = callPackage
     ({ mkDerivation, base, bin-package-db, containers, directory
-     , filepath, foreign-store, fsnotify, ghc, ghc-paths, transformers
+     , filepath, foreign-store, fsnotify, ghc, ghc-paths, process
+     , transformers
      }:
      mkDerivation {
        pname = "halive";
-       version = "0.1.0.6";
-       sha256 = "0mwj3d45dynsygmblr2h8dj9bkl581zjxc66871rd02c7rj914ng";
+       version = "0.1.0.7";
+       sha256 = "1c0e073e4769fedec470f7518fb1e20eff8d5b7a56fe8a03ec186aaf5ae71398";
        isLibrary = true;
        isExecutable = true;
        libraryHaskellDepends = [ base containers foreign-store ];
        executableHaskellDepends = [
          base bin-package-db directory filepath fsnotify ghc ghc-paths
-         transformers
+         process transformers
        ];
        homepage = "https://github.com/lukexi/halive";
        description = "A live recompiler";
@@ -61110,7 +61322,7 @@ self: {
      mkDerivation {
        pname = "halma";
        version = "0.2.0.1";
-       sha256 = "04b0djijhmgwr79hkprikqxdzfxabavrvkwmb1pv9qybsa82j6sc";
+       sha256 = "4c1b2990d2cbe3b46f5895cf9db75aaabbdf3a9e31df09d3c9fc5528a36c6011";
        isLibrary = true;
        isExecutable = true;
        libraryHaskellDepends = [
@@ -61134,7 +61346,7 @@ self: {
      mkDerivation {
        pname = "haltavista";
        version = "0.1.0.1";
-       sha256 = "0l2qlibfxj8n7jqqqrbswx3fgislxz39075bhip07qx55193dx2f";
+       sha256 = "4ef4365228a5e3036e84ab1c90c6ef54c7e746e77a658cb13c16c9ee56a45850";
        isLibrary = false;
        isExecutable = true;
        executableHaskellDepends = [ base hint process ];
@@ -61147,7 +61359,7 @@ self: {
      mkDerivation {
        pname = "hamid";
        version = "0.10";
-       sha256 = "19792k9pwpkqwqznxm00nbq22swnayz7fv60ly0wsw5zmf1g6wv8";
+       sha256 = "6873f382abbf70cd81a7c06c77be57966b21f0b200d46e3fe6785e7ed314e9a4";
        libraryHaskellDepends = [ base HCodecs newtype ];
        description = "Binding to the OS level Midi services (fork of system-midi)";
        license = stdenv.lib.licenses.bsd3;
@@ -61158,7 +61370,7 @@ self: {
      mkDerivation {
        pname = "hamlet";
        version = "1.2.0";
-       sha256 = "0rla3ap3malk8j6mh07fr2aqvbscpy743wrfq3skgjv3j4jlpjfi";
+       sha256 = "d1c94b259163cb37f5c02ef3418ebf4caf8d95c8ee00588d4493aa3aae1a8a66";
        libraryHaskellDepends = [ base shakespeare ];
        homepage = "http://www.yesodweb.com/book/shakespearean-templates";
        description = "Haml-like template files that are compile-time checked (deprecated)";
@@ -61172,7 +61384,7 @@ self: {
      mkDerivation {
        pname = "hampp";
        version = "0.2.1";
-       sha256 = "0y7lsh16xrlgsgfsqw00ldcdcjwsy8cziw8p3g753k9m23can4wl";
+       sha256 = "9413abd81035cd51ce1b17f1f819f29a4bd658a30070acddd38fe66e02d4f478";
        isLibrary = false;
        isExecutable = true;
        executableHaskellDepends = [
@@ -61190,7 +61402,7 @@ self: {
      mkDerivation {
        pname = "hamtmap";
        version = "0.3";
-       sha256 = "04fr1wjlbmr0c9cp9ybdcirlgayw843klxi0lwl9b9pzwzn0glfl";
+       sha256 = "d4d107ece7ffa69528a720763a0741dcab4773646df974596220d745250fd911";
        libraryHaskellDepends = [ array base deepseq hashable ];
        homepage = "https://github.com/exclipy/pdata";
        description = "A purely functional and persistent hash map";
@@ -61205,7 +61417,7 @@ self: {
      mkDerivation {
        pname = "hamusic";
        version = "0.1.2.1";
-       sha256 = "1gfzydgnf8fffsl2f189gy81pb13dbf81i1a83laqsck6dhp60in";
+       sha256 = "36027361339369ace8402ac480dc6a23ac1b907f090527a876ce21675ff3dfbd";
        isLibrary = true;
        isExecutable = true;
        libraryHaskellDepends = [
@@ -61230,7 +61442,7 @@ self: {
      mkDerivation {
        pname = "handa-gdata";
        version = "0.7.0.3";
-       sha256 = "1rm61kzvy8vrqmpa82y98hdf3dhqxkq9yh583p0l48zfj28ljh91";
+       sha256 = "2141499190ee2342c11da8409ff0ec18b6e11a44c90ba46ec57923bfff0ca6e6";
        isLibrary = true;
        isExecutable = true;
        libraryHaskellDepends = [
@@ -61255,7 +61467,7 @@ self: {
      mkDerivation {
        pname = "handa-geodata";
        version = "0.2.0.1";
-       sha256 = "0x0ix66wcpv172rxk9daifirnrcbblkjlvlg762z4i7qhipjfi2n";
+       sha256 = "5644276f84f844f285398f6e2a275d8b659ba38baaa5d9b338615fc68de91174";
        isLibrary = true;
        isExecutable = true;
        libraryHaskellDepends = [
@@ -61274,7 +61486,7 @@ self: {
      mkDerivation {
        pname = "handle-like";
        version = "0.1.0.2";
-       sha256 = "1cn7423962fg21m75ww5gpg2kwbn1fb7y76hgfq9n6hhbnz8nd4m";
+       sha256 = "95348bbe5d101a9bb07bd01c7f960b76f129de7d85f3726a10cf09938620c7b2";
        libraryHaskellDepends = [ base bytestring ];
        description = "HandleLike class";
        license = stdenv.lib.licenses.bsd3;
@@ -61289,7 +61501,7 @@ self: {
      mkDerivation {
        pname = "handsy";
        version = "0.0.14";
-       sha256 = "1a2yzpj883wsn013cy2jvn6wjsqqyf5xn91nkw6f5cg4sd9znzmy";
+       sha256 = "be7efb53d3e4b1e20c9f3624db8bf3186bc98ddd52783602b09a0f84e4fd5ea8";
        libraryHaskellDepends = [
          base bytestring data-default-class operational process-extras retry
          shell-escape split transformers
@@ -61308,7 +61520,7 @@ self: {
      mkDerivation {
        pname = "hangman";
        version = "1.0.3";
-       sha256 = "0k86z27qiaz967hsdnb3sac5ybmnyzd4d2gxzvdngw8rcvcq3biy";
+       sha256 = "3eae81d96619f167dbfefd8946daf7b62e5f98d263d9a6e131e9ab888ff8064d";
        isLibrary = false;
        isExecutable = true;
        executableHaskellDepends = [ base mtl random utility-ht ];
@@ -61324,7 +61536,7 @@ self: {
      mkDerivation {
        pname = "hannahci";
        version = "0.1.4.2";
-       sha256 = "072f9zsfrs8g6nw83g6qzczzybngrhyrm1m2y7ha37vf0y9gdpn0";
+       sha256 = "c0def692076e9fa1e0f1a2869a3dcccf2eff3ffbd8bc81b8350fe9ecf44f4e1c";
        isLibrary = false;
        isExecutable = true;
        executableHaskellDepends = [
@@ -61345,7 +61557,7 @@ self: {
      mkDerivation {
        pname = "hans";
        version = "2.5.0.0";
-       sha256 = "19zmwwnccmr1smypm8xbxh1r0fcrd9967dqcrjw5mm9675v1iw0p";
+       sha256 = "17f018763926d55ab8cc0cb763526a99399003ecaba37a7dd52157c62ce7f5a7";
        isLibrary = true;
        isExecutable = true;
        libraryHaskellDepends = [
@@ -61366,7 +61578,7 @@ self: {
      mkDerivation {
        pname = "hans-pcap";
        version = "0.1.0.2";
-       sha256 = "10zj129s6l4gf9acvs1yahdwv5vqj9kqwshvfjdak3gbi7arw48s";
+       sha256 = "1a119ed589eb8da99a741b6a8e67927897cd1b543ee8cd54728f50a39308f283";
        libraryHaskellDepends = [ base bytestring hans pcap ];
        jailbreak = true;
        homepage = "https://github.com/tolysz/hans-pcap";
@@ -61380,7 +61592,7 @@ self: {
      mkDerivation {
        pname = "hans-pfq";
        version = "0.1.0.0";
-       sha256 = "07jspsi8y921n5m5ar93w4gqaff4mjx79ss416ccm4s1k4l2km0b";
+       sha256 = "0bd42928994193ca980944eb74baacc439851fe12365556ab141248fa2be5a1e";
        libraryHaskellDepends = [ base bytestring hans pfq ];
        jailbreak = true;
        homepage = "https://github.com/tolysz/hans-pfq";
@@ -61397,7 +61609,7 @@ self: {
      mkDerivation {
        pname = "hapistrano";
        version = "0.2.0.2";
-       sha256 = "1bw37wb7wwf6qagp5q0i9biy5cma6i0yvn7z051da3gnad89iil1";
+       sha256 = "81c6985053f60dd54201ffd8ed4134aab2e2e34a11e0729fc2c6717e163f83af";
        isLibrary = true;
        isExecutable = true;
        libraryHaskellDepends = [
@@ -61424,7 +61636,7 @@ self: {
      mkDerivation {
        pname = "happindicator";
        version = "0.0.4";
-       sha256 = "1d0ycpxmlz2ab8dzys7i6ihc3rbs43d0l5l2mxvshqbpj3j73643";
+       sha256 = "839871e4907761a877af82160ada207ae5c16034f168ff1b5a4a7c5afb651eb4";
        libraryHaskellDepends = [
          array base bytestring containers glib gtk mtl
        ];
@@ -61441,7 +61653,7 @@ self: {
      mkDerivation {
        pname = "happindicator3";
        version = "0.2.1";
-       sha256 = "09h3077s61krg814aw2whgc869m6ff96rrxfk6rjpjy71lkmcl92";
+       sha256 = "225156270dc7cb2bb399aee76c9273a62683d8835c7045027a7906a3cf010326";
        isLibrary = true;
        isExecutable = true;
        libraryHaskellDepends = [ base glib gtk3 ];
@@ -61459,7 +61671,7 @@ self: {
      mkDerivation {
        pname = "happraise";
        version = "0.1";
-       sha256 = "1vcbfil9wxhk7vrmrmkn094rb281h4a3mrzpw5gl1842dpp5hp1g";
+       sha256 = "2f5c58ee6d82a0405fe1f7e73a1481018995490276d65cf33e13769e68748bed";
        isLibrary = false;
        isExecutable = true;
        executableHaskellDepends = [ base directory filepath ];
@@ -61474,7 +61686,7 @@ self: {
      mkDerivation {
        pname = "happs-hsp";
        version = "0.1";
-       sha256 = "0l1gb0qhhmld77qyz8qclbqxnv0hvyvjhav78690z50kvpjpqrxx";
+       sha256 = "bd677ce5dd13940f9241672b28b7df106cdbf1a20ca3eff1398d560831582f50";
        libraryHaskellDepends = [
          base bytestring HAppS-Server hsp mtl plugins
        ];
@@ -61489,7 +61701,7 @@ self: {
      mkDerivation {
        pname = "happs-hsp-template";
        version = "0.2";
-       sha256 = "0591ipk9zzzznmhz5wpp3qk7fkirhcp801qnk399jsms66fc8378";
+       sha256 = "e80cc49c31ba6a99d2981607802e83394e77261ef7f2f261b5ffff9fe68d2115";
        libraryHaskellDepends = [
          base bytestring containers directory filepath HAppS-Server hinotify
          hsp mtl network plugins RJson
@@ -61509,7 +61721,7 @@ self: {
      mkDerivation {
        pname = "happs-tutorial";
        version = "0.9.5";
-       sha256 = "1pkk78npgrr6dar00n93j6fbbkjam6198lkxp3q4zpdqspz4qypn";
+       sha256 = "f67a4cfed5b8dd4ff0b87d529482a94aceb59c91235900b26a26e7772d3a73de";
        isLibrary = false;
        isExecutable = true;
        executableHaskellDepends = [
@@ -61530,7 +61742,7 @@ self: {
      mkDerivation {
        pname = "happstack";
        version = "7.0.2";
-       sha256 = "1dfmfyrynggf1ff6364kb9a53rm64zhirx6ispnhykwdf60zbm6r";
+       sha256 = "d9d4f581718d4f0fedd5d1f41ce127a6e651545a9398619c0bee3debb377d5b5";
        isLibrary = true;
        isExecutable = true;
        libraryHaskellDepends = [ base happstack-server ];
@@ -61548,7 +61760,7 @@ self: {
      mkDerivation {
        pname = "happstack-auth";
        version = "0.2.1.1";
-       sha256 = "0mfd2r88681dskn1l1gcbam8rvaqsry09zavywkm4kvmw8912vy4";
+       sha256 = "c46f1112e2754f5227f75bfd047cd658ed8caa5aec051aecd42d20835016cd55";
        libraryHaskellDepends = [
          base bytestring containers convertible happstack happstack-data
          happstack-ixset happstack-server happstack-state mtl old-time
@@ -61574,7 +61786,7 @@ self: {
      mkDerivation {
        pname = "happstack-authenticate";
        version = "2.1.4";
-       sha256 = "075bncl5mz7hi674gyhd9mrnf3xb8zn5frcy39dj5m7jrsrdy91z";
+       sha256 = "3f24dfb2cef2d4225b1a9e6557ec47ab0f67734d0dfa478e89f0fc5a28b3ab1c";
        libraryHaskellDepends = [
          acid-state aeson authenticate base base64-bytestring boomerang
          bytestring containers data-default filepath happstack-hsp
@@ -61597,7 +61809,7 @@ self: {
      mkDerivation {
        pname = "happstack-clientsession";
        version = "7.3.0";
-       sha256 = "1dh6l52mfd6p9y39lr0qax1gs7rxpamy21iwxca7ylbhlqyxfa2g";
+       sha256 = "4f28d73da670517f14eb3c06e1abba3d1ffd425718649a864fd7345745a106b6";
        libraryHaskellDepends = [
          base bytestring cereal clientsession happstack-server monad-control
          mtl safecopy transformers-base
@@ -61615,7 +61827,7 @@ self: {
      mkDerivation {
        pname = "happstack-contrib";
        version = "0.2.1";
-       sha256 = "0cqdfnjcmghw3wwny2brw51qbkvi8ps2crl8382sqwqq9gkw0l75";
+       sha256 = "e550c0e74b1873ac051a886626f44571cf8543e179096f391f1cbecaa4750d33";
        isLibrary = true;
        isExecutable = true;
        libraryHaskellDepends = [
@@ -61639,7 +61851,7 @@ self: {
      mkDerivation {
        pname = "happstack-data";
        version = "6.0.1";
-       sha256 = "0v2ln4mdnild72p02mzjn8mn5srvjixsjqjgkdqzshvxjnnm95l8";
+       sha256 = "889654ad957d43fd719b4f62a97b943beb622bb2f25701ae388d46db2ab1546c";
        isLibrary = true;
        isExecutable = true;
        libraryHaskellDepends = [
@@ -61661,7 +61873,7 @@ self: {
      mkDerivation {
        pname = "happstack-dlg";
        version = "0.1.2";
-       sha256 = "1zm8f224r0nwpykvil8s05lcswrw31iigcw9arnf4j362y03n2qp";
+       sha256 = "170b3b80176648e26c5689b31763183c73cd68011ad1b8a7bfdc824c8470a8fe";
        libraryHaskellDepends = [
          applicative-extras base bytestring containers formlets
          happstack-server mtl random template-haskell time xhtml
@@ -61683,7 +61895,7 @@ self: {
      mkDerivation {
        pname = "happstack-facebook";
        version = "0.30";
-       sha256 = "1rfd2rkizviq7pv6lmhkp0dmwwk2m25kz9vzczk3ycm57mk7ql8c";
+       sha256 = "0c517c663da5323fe6677fa73f8ba862725e1bb813566af63d38ee1f6716cde5";
        isLibrary = true;
        isExecutable = true;
        libraryHaskellDepends = [
@@ -61707,7 +61919,7 @@ self: {
      mkDerivation {
        pname = "happstack-fastcgi";
        version = "0.1.5";
-       sha256 = "0rvb041nx2f8azvfy1yysisjqrmsfbxnccn992v5q7zhlglcvj8h";
+       sha256 = "10c9cde8a3f01f5cb648c93266fb72ba662c75d4de07eff657c8896e03016b67";
        libraryHaskellDepends = [
          base bytestring cgi containers fastcgi happstack-server mtl
          utf8-string
@@ -61723,7 +61935,7 @@ self: {
      mkDerivation {
        pname = "happstack-fay";
        version = "0.2.0";
-       sha256 = "1mwx7ki35s6x3ypxl8sv611a2h4zxwd77ij95bydf5azzz9l6ys5";
+       sha256 = "457b43d3ff5f15d7fc2a49c6731aef9f40a142305b23daaf1fdde832e23c9dd7";
        libraryHaskellDepends = [
          aeson base fay happstack-fay-ajax happstack-server mtl
        ];
@@ -61739,7 +61951,7 @@ self: {
      mkDerivation {
        pname = "happstack-fay-ajax";
        version = "0.2.0";
-       sha256 = "0zdkvvmywnfvqg5jdvf29qczzxmprvspxj0r1vj46fd6vld53j4j";
+       sha256 = "92c8511adda63943e40e19c87ef5ceb7f6ff194ec2ed26cbc3db59eeebdeb37d";
        libraryHaskellDepends = [ fay-base fay-jquery ];
        jailbreak = true;
        homepage = "http://www.happstack.com/";
@@ -61756,7 +61968,7 @@ self: {
      mkDerivation {
        pname = "happstack-foundation";
        version = "0.5.8";
-       sha256 = "1sbqp78mgnc5rrnn35myd0izlh3w1nv5pgpg807w3cax2xakw3bh";
+       sha256 = "700d3e55175db1c10f40efbe5bb60d7c40fa2368be96616dce85d957d1b978e9";
        libraryHaskellDepends = [
          acid-state base happstack-hsp happstack-server hsp lifted-base
          monad-control mtl reform reform-happstack reform-hsp safecopy text
@@ -61773,7 +61985,7 @@ self: {
      mkDerivation {
        pname = "happstack-hamlet";
        version = "7.0.4";
-       sha256 = "1l12gyyqzblb9psk6692r9xw640jxzyxqldfyg2yrzz8y0zi649a";
+       sha256 = "2a11133ff0e8ffecc5f3ae51dcfdef1210c37bca221933f54d8bae8fbd7f22d0";
        libraryHaskellDepends = [ base happstack-server shakespeare text ];
        jailbreak = true;
        homepage = "http://www.happstack.com/";
@@ -61788,7 +62000,7 @@ self: {
      mkDerivation {
        pname = "happstack-heist";
        version = "7.2.4";
-       sha256 = "1ax1fyw9788iilmczqr6s1ryh2h9x2f6n9c8mqxjmq58zg1lc2d3";
+       sha256 = "a30946c3fba8e02a3bae88256b9ce8090ae873d026e3cf2a8d11a193b877a1ab";
        libraryHaskellDepends = [
          base blaze-builder bytestring either filepath happstack-server
          heist mtl text
@@ -61811,7 +62023,7 @@ self: {
      mkDerivation {
        pname = "happstack-helpers";
        version = "0.56";
-       sha256 = "0yrspdcgxj2izivwm7fy8msfbzlpdn3zv0j1z6b1smzydcbad202";
+       sha256 = "0288a6166bfe571d96f94182fd876d97fee57445de9dca77fc51c8fe58bb3a7b";
        libraryHaskellDepends = [
          base bytestring containers DebugTraceHelpers directory filepath
          happstack-data happstack-ixset happstack-server happstack-state
@@ -61833,7 +62045,7 @@ self: {
      mkDerivation {
        pname = "happstack-hsp";
        version = "7.3.5";
-       sha256 = "0p8hidcdrqj7n4b9a5gbc0ic279wjmxvjacn6b8nzcnridq3mif6";
+       sha256 = "c6c53a708bd9b26fd1329629b97b953c1dc12260eb159516b147e2dc588b105d";
        libraryHaskellDepends = [
          base bytestring happstack-server harp hsp hsx2hs mtl syb text
          utf8-string
@@ -61852,7 +62064,7 @@ self: {
      mkDerivation {
        pname = "happstack-hstringtemplate";
        version = "7.0.4";
-       sha256 = "1pcj6vixzrbdmqi2yxcxhjnj5rdwlyg4nzcjkgks01ilgpg7fsf4";
+       sha256 = "c46977de7d3406a0e79b927d4b9ea7bce522ad849d752f22ae6de5dfe33692dd";
        libraryHaskellDepends = [
          base bytestring happstack-server hslogger HStringTemplate mtl
        ];
@@ -61869,7 +62081,7 @@ self: {
      mkDerivation {
        pname = "happstack-ixset";
        version = "6.0.1";
-       sha256 = "1hnhn0iyfw5rknz17p7m1p3rrngr77zv3lkni8d35q50bzzyw8ni";
+       sha256 = "d122eeff5fa0e0321a8a76d2b1ff39f9d99cc70df5dc13be9db970e723b0d0c2";
        isLibrary = true;
        isExecutable = true;
        libraryHaskellDepends = [
@@ -61891,7 +62103,7 @@ self: {
      mkDerivation {
        pname = "happstack-jmacro";
        version = "7.0.10";
-       sha256 = "0kzp3dfy2qrd9bwq3lwnxvh1zibw7kib8w8rfqz36k0ywdwq8768";
+       sha256 = "c81c8479e31e4c333e761971b4e23c7cc51fe0ee96d381f94a2d63e15d1bf74f";
        libraryHaskellDepends = [
          base base64-bytestring bytestring cereal digest happstack-server
          jmacro text utf8-string wl-pprint-text
@@ -61906,7 +62118,7 @@ self: {
      mkDerivation {
        pname = "happstack-lite";
        version = "7.3.6";
-       sha256 = "1mvzpbmjgf5gv9ls5kmg0s6cr765jl701vy2kmbynjkg6jimjmp8";
+       sha256 = "e85659a3346f4aeb579dc2ef000e95c59ccc8c06afcea269daafb827ebba7fd7";
        libraryHaskellDepends = [
          base bytestring happstack-server mtl text
        ];
@@ -61922,7 +62134,7 @@ self: {
      mkDerivation {
        pname = "happstack-monad-peel";
        version = "0.1";
-       sha256 = "0v6lshy572pvzhgqphyrhw8w2wsgxp9mqz8p3lrxmcp3i7sgqbry";
+       sha256 = "3e2ffcf489e3b2da331d177d5cd3ed4f73c11187d9c38b1ffcfb8a533cd4d46c";
        libraryHaskellDepends = [
          base happstack-server monad-peel mtl transformers
        ];
@@ -61938,7 +62150,7 @@ self: {
      mkDerivation {
        pname = "happstack-plugins";
        version = "7.0.2";
-       sha256 = "07zh0gk77rbd1akzax29l7d6412sx5ghjhz640d6cbzxs39nlaif";
+       sha256 = "2e2a6ad3d0fd2f661a20e643095fe95a0462daa14974f5a70a6de573e603f01f";
        libraryHaskellDepends = [
          base happstack-server mtl plugins-auto template-haskell th-lift
        ];
@@ -61961,7 +62173,7 @@ self: {
      mkDerivation {
        pname = "happstack-server";
        version = "7.4.4";
-       sha256 = "1whyv6rb4b9x9m381fs8938n74dgq7hd9gpznwnlzh76ah2nanjf";
+       sha256 = "4e5a650554e6c04f2db7ffbed4e0c1af9163d14848bb80464d3d2db2b2d91ef2";
        libraryHaskellDepends = [
          base base64-bytestring blaze-html bytestring containers directory
          exceptions extensible-exceptions filepath hslogger html
@@ -61986,7 +62198,7 @@ self: {
      mkDerivation {
        pname = "happstack-server-tls";
        version = "7.1.6";
-       sha256 = "00fmgws8hc0v1lsmxlj478xdbmlpgaz581m9hqw5nfjljg8mi74w";
+       sha256 = "9c9c58d193543a5b3886a90654be7a97d6d53a3a44d25e350d1b3088347fd501";
        libraryHaskellDepends = [
          base bytestring extensible-exceptions happstack-server hslogger
          HsOpenSSL network sendfile time unix
@@ -62005,7 +62217,7 @@ self: {
      mkDerivation {
        pname = "happstack-server-tls-cryptonite";
        version = "0.1.1";
-       sha256 = "1y450dvdswkqcaqillrzlpizss9hlk2q61x1p715wfhrlmizlrjq";
+       sha256 = "5866fa63a5193a5ec2b9a10783c5a43069fde3a53f531ab1627872dd760385f8";
        libraryHaskellDepends = [
          base bytestring cryptonite data-default-class extensible-exceptions
          happstack-server hslogger network sendfile time tls unix
@@ -62022,7 +62234,7 @@ self: {
      mkDerivation {
        pname = "happstack-state";
        version = "6.1.4";
-       sha256 = "1xfp0546z70sfda0z7w7ns4jhgcbx3vmnz4vsnckzhgflzmdixq9";
+       sha256 = "09f7d8eaa7eec13f99d59b7c5bf7e88b3d2889b6879f0f54731a9c6f4801d7f5";
        isLibrary = true;
        isExecutable = true;
        libraryHaskellDepends = [
@@ -62044,7 +62256,7 @@ self: {
      mkDerivation {
        pname = "happstack-static-routing";
        version = "0.4.2";
-       sha256 = "0g8b94mfhajgs99rgvzfrlc19cxm5a0j6cgrrlrdhgfx7lggc9h2";
+       sha256 = "0226f61e3ddd3dd832cdf93123812ab5b31418cdeeef9753d24f2ae82a490b3d";
        libraryHaskellDepends = [
          base containers happstack-server list-tries transformers
        ];
@@ -62062,7 +62274,7 @@ self: {
      mkDerivation {
        pname = "happstack-util";
        version = "6.0.3";
-       sha256 = "0hqssd5wzir6rxn46q8r3hdp3nl7v5m7w322j39120xpg2bhiphh";
+       sha256 = "10de089778b70311d290420c7e6ad987da711b1c1961436ccf26c7cf4bd31a43";
        isLibrary = true;
        isExecutable = true;
        libraryHaskellDepends = [
@@ -62086,7 +62298,7 @@ self: {
      mkDerivation {
        pname = "happstack-yui";
        version = "7373.5.3";
-       sha256 = "178r3jqxmrdp0glp9p4baw8x7zk0w8j4m5l173rjnz9yxn53nyni";
+       sha256 = "d17a3b8aed3e7d2bf33881964a24e260fed311578bdc74e903b7e5dab11c199d";
        libraryHaskellDepends = [
          base boomerang bytestring containers directory happstack-jmacro
          happstack-server hsp interpolatedstring-perl6 jmacro mtl pretty
@@ -62105,7 +62317,7 @@ self: {
      mkDerivation {
        pname = "happy";
        version = "1.19.5";
-       sha256 = "1nj353q4z1g186fpjzf0dnsg71qhxqpamx8jy89rjjvv3p0kmw32";
+       sha256 = "62f03ac11d7b4b9913f212f5aa2eee1087f3b46dc07d799d41e1854ff02843da";
        revision = "1";
        editedCabalFile = "d6a01f50aab2c480799b7d19643c5bb01891e01ac97aa892ffec3e6029a1446c";
        isLibrary = false;
@@ -62124,7 +62336,7 @@ self: {
      mkDerivation {
        pname = "happy-meta";
        version = "0.2.0.8";
-       sha256 = "0hnj039vspqvym70c59y80ygb8ciz5bf18sqm0dbvzr5v2mixbag";
+       sha256 = "4fad1eabd825ffbd1aa858a3e056f991a1f53c403e15064ef51b5fbdd300d242";
        libraryHaskellDepends = [
          array base containers haskell-src-meta mtl template-haskell
        ];
@@ -62140,7 +62352,7 @@ self: {
      mkDerivation {
        pname = "happybara";
        version = "0.0.1";
-       sha256 = "1lp2awvj077d16gppir6nv9fx6d9g1k7w6j01bxkffy3q5x04xrv";
+       sha256 = "3b77027ac1c33b37fb0a401a7e6678a999eed2b626c77b9f09ed1c203757e2d2";
        libraryHaskellDepends = [
          aeson base filepath http-types lifted-base monad-control mtl text
          time transformers transformers-base
@@ -62161,7 +62373,7 @@ self: {
      mkDerivation {
        pname = "happybara-webkit";
        version = "0.0.1";
-       sha256 = "17446wkyljwd7nq6mhsj2v411zb9wsz833sczm4nzcigywvhx4fw";
+       sha256 = "dc910e37f72fb26f49fd4c8f81bee669fd10c81652c36ab03d8d4bea2737849c";
        libraryHaskellDepends = [
          aeson base bytestring case-insensitive data-default directory
          filepath happybara http-types lifted-base monad-control mtl network
@@ -62179,7 +62391,7 @@ self: {
      mkDerivation {
        pname = "happybara-webkit-server";
        version = "0.0.1";
-       sha256 = "0vh9ig9mvg12qgysk7gbqwiib3m2ciwi10asb1i0x25xjp585shi";
+       sha256 = "11ea82ca95bd880e62585a81107964a28e1523c7eb9da9fdc322bc5dd38b096e";
        libraryHaskellDepends = [ base directory filepath process ];
        jailbreak = true;
        homepage = "https://github.com/cstrahan/happybara/happybara-webkit-server";
@@ -62194,7 +62406,7 @@ self: {
      mkDerivation {
        pname = "har";
        version = "0.1.1.0";
-       sha256 = "0x51sqlybfq2pqv6nrhvf50yds3gs08sfih7zi9ijvn5dkrxx1z3";
+       sha256 = "e387def36cc56e1953fc0746a711d06fe8e641711b666b36be02bbe529d6a174";
        libraryHaskellDepends = [
          aeson base bytestring directory filepath text
        ];
@@ -62211,7 +62423,7 @@ self: {
      mkDerivation {
        pname = "harchive";
        version = "0.2";
-       sha256 = "10485indn9sszq3514gs547phb0kpikm8m6ykq1ns2kp0pmkgz9m";
+       sha256 = "35fd37eb05770a6d039ede545467bc132c780f29fa915006fe5a27db6c2c8880";
        isLibrary = false;
        isExecutable = true;
        executableHaskellDepends = [
@@ -62231,7 +62443,7 @@ self: {
      mkDerivation {
        pname = "hark";
        version = "0.2";
-       sha256 = "1wxwxx3l4zvb1jr19lckamb0gxywsq1f4n4ncb373vqdnwnrr8x4";
+       sha256 = "a4a39c2db70def71c6629658e202d6dcf707565593d114b20c6b7f4247efbcf3";
        isLibrary = false;
        isExecutable = true;
        executableHaskellDepends = [
@@ -62251,7 +62463,7 @@ self: {
      mkDerivation {
        pname = "haroonga";
        version = "0.1.7.1";
-       sha256 = "0j4668611qazzwb4w05v0xliw1w0a7kmlz0g2z9ixz0kywbfim2g";
+       sha256 = "4fd4e816f713fc1ed3170f7c5ae75180071e6907bb004e16ff5fe1100c328648";
        libraryHaskellDepends = [
          base bindings-DSL monad-control resourcet transformers
        ];
@@ -62267,7 +62479,7 @@ self: {
      mkDerivation {
        pname = "haroonga-httpd";
        version = "0.1.1.0";
-       sha256 = "1745b7khz1dn7n9w3z89na01jap62vbg1mb6c7i9n2mgwkkrys5g";
+       sha256 = "af689fe7e4af0a9be26166d5f0d616e62a1980b209fdc1933db6850fe759859c";
        isLibrary = false;
        isExecutable = true;
        executableHaskellDepends = [
@@ -62283,7 +62495,7 @@ self: {
      mkDerivation {
        pname = "harp";
        version = "0.4.1";
-       sha256 = "0q9q3rw9yqkryjf5vvm41ckycqjfaxnsrmc1p0kmdrlb4f4dgclz";
+       sha256 = "9fb2d788238be65627b881d5ac6d574e62e6270ba4ee5d9cf479629f781e3861";
        libraryHaskellDepends = [ base ];
        homepage = "https://github.com/seereason/harp";
        description = "HaRP allows pattern-matching with regular expressions";
@@ -62297,7 +62509,7 @@ self: {
      mkDerivation {
        pname = "harpy";
        version = "0.6.0.2";
-       sha256 = "1rlbakwqfjfr3d71jc6d5nyw5ms0y9wmb79p8jax45rxk1a8cfry";
+       sha256 = "3e3b8654983d17d29544379d5579f240d7c2bd2dcd30194e1bd94987f9548be6";
        libraryHaskellDepends = [
          array base containers disassembler mtl parsec pretty
          template-haskell
@@ -62312,7 +62524,7 @@ self: {
      mkDerivation {
        pname = "has";
        version = "0.5.0.1";
-       sha256 = "0zydwhr2ac66knmrlf0b9vsys61w6370g9rid2gag2dvmy7xqp2s";
+       sha256 = "5a5cdc8fafbb89a79e6831a707ce303c18edf54e0b389aab9dc6302532e4cd7f";
        isLibrary = true;
        isExecutable = true;
        libraryHaskellDepends = [ base QuickCheck ];
@@ -62327,7 +62539,7 @@ self: {
      mkDerivation {
        pname = "has-th";
        version = "0.1";
-       sha256 = "0yyrfd8mgxwyfgwcg61q7yj2cq2zj6zlk1l340y4vzj71r53qgc4";
+       sha256 = "843d3c4a0e47fe4d3c20838649bf915f6026a43f3898c7f8739ef7575173d97b";
        libraryHaskellDepends = [ base has template-haskell ];
        homepage = "http://github.com/chrisdone/has-th";
        description = "Template Haskell function for Has records";
@@ -62340,7 +62552,7 @@ self: {
      mkDerivation {
        pname = "hascal";
        version = "2.0.0.1";
-       sha256 = "1nq383fg2cn82rbmnp6kgzyk42fgp9xnqj84ypz0kf42954n4h1l";
+       sha256 = "344062494982b809fef504496c7bbacf0932fd7fd35c5b5716c832f1dc4003db";
        isLibrary = true;
        isExecutable = true;
        libraryHaskellDepends = [ base ];
@@ -62359,7 +62571,7 @@ self: {
      mkDerivation {
        pname = "hascat";
        version = "0.2";
-       sha256 = "04z9q3l2hwf7lii8d3cxbh7zh6cqbbmy07yv5bal4lvrnd1wqia7";
+       sha256 = "4745cc43b3795342d52adb1fe0eb5a9819f80f5c9d8d8662a4c77128e8c0e913";
        isLibrary = false;
        isExecutable = true;
        executableHaskellDepends = [
@@ -62380,7 +62592,7 @@ self: {
      mkDerivation {
        pname = "hascat-lib";
        version = "0.2";
-       sha256 = "0l2cixgnyv2xhbpvkzrrn1wxikx7gcmwpkwagkfzx27iy33xkrqj";
+       sha256 = "12e7d9c7f0f188fedd7c8acfcb2b7ba7cfd879b039ffb9ef825d6c6f5f8f4c50";
        libraryHaskellDepends = [
          base bytestring containers directory haskell98 HaXml html HTTP mtl
          network old-locale old-time parsec plugins xhtml
@@ -62398,7 +62610,7 @@ self: {
      mkDerivation {
        pname = "hascat-setup";
        version = "0.2";
-       sha256 = "058abyr70yr2130nbi64zhigglw207dh5anyxzw19c1qk4zmwsyi";
+       sha256 = "d16b5e3f9938b014f8efdeaa02db0182d3f722fcc4c465c108227b70b25f0a15";
        isLibrary = true;
        isExecutable = true;
        libraryHaskellDepends = [
@@ -62419,7 +62631,7 @@ self: {
      mkDerivation {
        pname = "hascat-system";
        version = "0.2";
-       sha256 = "1fabn71llrlxs5xlcpzkkvzjv7zibxlna0jvh6rkrz6pqyp1nd94";
+       sha256 = "24351baec7d7fc3cb3815b0265695ff19f2dff9ef35f467bd19d664ac3b14bb9";
        libraryHaskellDepends = [
          base bytestring containers hascat-lib HaXml HTTP mtl network
          old-time parsec plugins unix
@@ -62438,7 +62650,7 @@ self: {
      mkDerivation {
        pname = "hash";
        version = "0.2.0.1";
-       sha256 = "1ka6izpkz6gs4ag3xvnslxywi9344w3mh9rl968vq6ck203pv2rx";
+       sha256 = "3d8b7d07109319bc9149342758072764a4c87da7daee3e9e22fa993fef8f46cd";
        libraryHaskellDepends = [
          base bifunctors bytestring data-default generic-deriving hashable
          lens transformers
@@ -62459,7 +62671,7 @@ self: {
      mkDerivation {
        pname = "hashable";
        version = "1.2.3.3";
-       sha256 = "0kp4aj0x1iicz9qirpqxxqd8x5g1njbapxk1d90n406w3xykz4pw";
+       sha256 = "fc923f7d1fdc0062416a61f6ab96b4e1958e1aee1ddf1c71fa2cc6d08154e44e";
        libraryHaskellDepends = [
          base bytestring ghc-prim integer-gmp text
        ];
@@ -62479,7 +62691,7 @@ self: {
      mkDerivation {
        pname = "hashable-extras";
        version = "0.2.2";
-       sha256 = "118l23n78xs1faa0q42h996q210l2p9mzl85a73krljzsz8wkc1b";
+       sha256 = "2bb0c9d1d75fd23cc75105d15fd3151404814d4a50100c9472417774ec101485";
        libraryHaskellDepends = [
          base bifunctors bytestring hashable transformers
        ];
@@ -62496,7 +62708,7 @@ self: {
      mkDerivation {
        pname = "hashable-generics";
        version = "1.1.8";
-       sha256 = "1l5i4lasz32hsjvm9fbf7p9fy7s6bjy868w7rmpxci40qkz7ffhq";
+       sha256 = "183a77fec48044d66fcd872383bc5c461fefd23d6eb954b7d4508caf1525b1d0";
        libraryHaskellDepends = [ base ghc-prim hashable ];
        testHaskellDepends = [
          base ghc-prim hashable QuickCheck test-framework
@@ -62514,7 +62726,7 @@ self: {
      mkDerivation {
        pname = "hashable-time";
        version = "0.1.0.1";
-       sha256 = "1137cc7jyyn293g3nx9bs4mw4r8i7k9cq0rz5f5rs7j8997gkmbf";
+       sha256 = "6ed5f94e4a481e9d8b2b3f03ccd23c1165c22bd12b753bde48c27a2f0f636784";
        libraryHaskellDepends = [ base hashable time ];
        description = "Hashable instances for Data.Time";
        license = stdenv.lib.licenses.bsd3;
@@ -62527,7 +62739,7 @@ self: {
      mkDerivation {
        pname = "hashabler";
        version = "0.1.0.2";
-       sha256 = "0n3cw5vc48144kddz0krcm682bcigdafap81kdkvhq8alhc50532";
+       sha256 = "62145018a40a61b8679b015de5547b912d814c657982dfda242420c276e16c58";
        libraryHaskellDepends = [
          array base bytestring ghc-prim integer-gmp primitive
          template-haskell text
@@ -62544,7 +62756,7 @@ self: {
      mkDerivation {
        pname = "hashed-storage";
        version = "0.5.11";
-       sha256 = "0s8mnayxlvwrrii2l63b372yi5g08br6gpbgz2256d8y128mwjvk";
+       sha256 = "734b5e91081e355384f86fdd67f242e095e8c5196b182a62cc996fdabdb21569";
        isLibrary = true;
        isExecutable = true;
        libraryHaskellDepends = [
@@ -62561,7 +62773,7 @@ self: {
      mkDerivation {
        pname = "hashids";
        version = "1.0.2.1";
-       sha256 = "03q0fcxiw4yncmbdirnh6kaz9jhyxqy348dnrvgkbn4mzkh8fi2z";
+       sha256 = "5f4487e0fc95d835dfceb621323cee1ecaf4d534d0e6d85665d6131e3b73000f";
        libraryHaskellDepends = [ base bytestring containers split ];
        homepage = "http://hashids.org/";
        description = "Hashids generates short, unique, non-sequential ids from numbers";
@@ -62573,7 +62785,7 @@ self: {
      mkDerivation {
        pname = "hashmap";
        version = "1.3.0.1";
-       sha256 = "16scl1rbq0f18mggrj4lbhgkz7kzshsw9a523rjd8cjkdjz1ijwr";
+       sha256 = "99cb18be6c5332d4641ea2a8c435d47f9e3f1f5c94c8fc5e45c101bc72a04c9b";
        libraryHaskellDepends = [ base containers deepseq hashable ];
        homepage = "http://git.auryn.cz/haskell/hashmap/";
        description = "Persistent containers Map and Set based on hashing";
@@ -62587,7 +62799,7 @@ self: {
      mkDerivation {
        pname = "hashring";
        version = "0.0.0";
-       sha256 = "05q9iay0ygr79x8yikgbi99v74kagyrd68zvjx8qakfzqgs9a19j";
+       sha256 = "320595f4c3df4d855197fb23d3b27f6a92b3538aebcde8514f273f0fbc8a0917";
        libraryHaskellDepends = [ base containers hashable ];
        testHaskellDepends = [
          base QuickCheck test-framework test-framework-quickcheck2
@@ -62603,7 +62815,7 @@ self: {
      mkDerivation {
        pname = "hashtables";
        version = "1.2.0.2";
-       sha256 = "0dqq5ssgkqzplqf5dmc4l8cj28j5py7i6n6a069qn4cibvxfjaq1";
+       sha256 = "012be9fa5e91118b9301ca58138fbf45222119a284d5561ca6f7e3f9b42e1837";
        libraryHaskellDepends = [
          base ghc-prim hashable primitive vector
        ];
@@ -62618,7 +62830,7 @@ self: {
      mkDerivation {
        pname = "hashtables-plus";
        version = "0.2.0";
-       sha256 = "0g9jmc15g36iy0wmmsj74qwybh509j4lf8jzv3dws7c2j24kc7l7";
+       sha256 = "871e368990821dcddbd85f2247894ca0c0e5392647ea5a39f0d18c5702ab323d";
        libraryHaskellDepends = [
          base hashable hashtables loch-th placeholders
        ];
@@ -62633,7 +62845,7 @@ self: {
      mkDerivation {
        pname = "hasim";
        version = "0.1.2";
-       sha256 = "03wn142r0sh7adfghjqwb2mgq4rgkqs8nq2rx2jq717dr2xp987n";
+       sha256 = "f6a074bbc8ed8483a5e859608b349e2f13fcaa581c4bf85c53076a900509960f";
        libraryHaskellDepends = [ base containers mtl ];
        homepage = "http://huygens.functor.nl/hasim/";
        description = "Process-Based Discrete Event Simulation library";
@@ -62648,7 +62860,7 @@ self: {
      mkDerivation {
        pname = "hask";
        version = "0";
-       sha256 = "1c87jxafxpnlyblhdif4br61wqvnad0s6hvfhmzhx9y1jri3rb39";
+       sha256 = "69ac3c6296c1a70e7f856e43a3415376631e4c5ec4c506e9f2d4deee549707b1";
        revision = "1";
        editedCabalFile = "04abcba45a7fbaa11d7f3bd9834f1e70a30f356ae871e59ab472f20d4cd60026";
        libraryHaskellDepends = [
@@ -62667,7 +62879,7 @@ self: {
      mkDerivation {
        pname = "hask-home";
        version = "2009.3.18";
-       sha256 = "128hkd1yycjvbnvwjd2r2mxhjdnmfkghyf0fcslh9fxprqgrhk18";
+       sha256 = "284c981fceb7bb04a9660e380fdf74d536097b155934c9b75d5b32ef439b1089";
        isLibrary = false;
        isExecutable = true;
        executableHaskellDepends = [
@@ -62687,7 +62899,7 @@ self: {
      mkDerivation {
        pname = "haskades";
        version = "0.2.1";
-       sha256 = "19cglzgzxbg65qr7m68gnc6y45b7n0wl98pgd9jrk20sblrhc6p6";
+       sha256 = "e61a06335d1a8899656aefa24439b06715e20db30f997a322ee6adfedfa78fa5";
        isLibrary = false;
        isExecutable = true;
        executableHaskellDepends = [
@@ -62705,7 +62917,7 @@ self: {
      mkDerivation {
        pname = "haskakafka";
        version = "1.0.0";
-       sha256 = "0j1vii11lp91gydw3h0hb2b3lb85n9cji9m9rvb1d7svs91nhhk7";
+       sha256 = "67426843d25b9f16d6cea9a62859b2052d3a965810c0c19b7f215d1a428c3b48";
        libraryHaskellDepends = [
          base bytestring containers temporary unix
        ];
@@ -62726,7 +62938,7 @@ self: {
      mkDerivation {
        pname = "haskanoid";
        version = "0.1.5";
-       sha256 = "1k2y406kjxyv3sdpa50m6i15z2aiysy43xhjgln99v21x6rp08ia";
+       sha256 = "2a2270b3e941ec942c7d12f641bcf651895f42341514759b1edb77390d205ecc";
        isLibrary = false;
        isExecutable = true;
        executableHaskellDepends = [
@@ -62746,7 +62958,7 @@ self: {
      mkDerivation {
        pname = "haskarrow";
        version = "0.0";
-       sha256 = "01l90qningjlb4wn02avjy9lmi4ry4yxzw0a9sd29qbzfpnf3viy";
+       sha256 = "3eeee1ec757fe1249a4e0af0df3df199c44a93975b09603959543e1b2d068906";
        isLibrary = false;
        isExecutable = true;
        executableHaskellDepends = [
@@ -62764,7 +62976,7 @@ self: {
      mkDerivation {
        pname = "haskbot-core";
        version = "0.1";
-       sha256 = "0alqjgg2gvb9610s2b4fil5frknn5j8d6r558bfp1n6a0d51pz74";
+       sha256 = "e4fc1b4a03cad870dd42a564d3902cd6ceec0a8d8e2ca1413069ed27de93982a";
        libraryHaskellDepends = [
          aeson base bytestring connection containers http-conduit http-types
          monads-tf stm text wai warp
@@ -62789,7 +63001,7 @@ self: {
      mkDerivation {
        pname = "haskdeep";
        version = "0.2.0.1";
-       sha256 = "0ncx9wx9ldynqwq0zwljwqzskm5mrq8rx74np43pm9qxvjc9f5vx";
+       sha256 = "7d179798dc1da77a07b9969c9e11ceb5d4a93fe692f20f30c7d6379a3a4f9d59";
        isLibrary = false;
        isExecutable = true;
        executableHaskellDepends = [
@@ -62810,7 +63022,7 @@ self: {
      mkDerivation {
        pname = "haskdogs";
        version = "0.3.2";
-       sha256 = "0vl3c66ki9j9ncs2rapdn80kbfk0l3y97qwfraqlnjycdl10sm6r";
+       sha256 = "d9540d026dcc4b4bb1ca8ee393fca060ba3501b2edaa2c34b349a6388d61836e";
        isLibrary = false;
        isExecutable = true;
        executableHaskellDepends = [ base Cabal filepath HSH ];
@@ -62826,7 +63038,7 @@ self: {
      mkDerivation {
        pname = "haskeem";
        version = "0.7.16";
-       sha256 = "0fmglaiq2axpb9f4yyk53fpppc1ysqglqgjxhy78yl3r8mik836n";
+       sha256 = "d60c34634579508f8e875d3e4c1fd63eb07baf1b657a4f5c5ab72b81a3a2af3a";
        isLibrary = false;
        isExecutable = true;
        executableHaskellDepends = [
@@ -62846,7 +63058,7 @@ self: {
      mkDerivation {
        pname = "haskeline";
        version = "0.7.2.1";
-       sha256 = "09v4vy6nf23b13ws9whdqwv84mj1nhnla88rw2939qyqxb4a6mmf";
+       sha256 = "ae56a3c8ead8e33492e01921452db441568236c70df2a4f9086b08678ddf6427";
        configureFlags = [ "-fterminfo" ];
        libraryHaskellDepends = [
          base bytestring containers directory filepath terminfo transformers
@@ -62862,7 +63074,7 @@ self: {
      mkDerivation {
        pname = "haskeline-class";
        version = "0.6.2";
-       sha256 = "0xgdq2xgw2ccyfzkj5n36s5n6km5l947d2iy4y1qms8kbc05zmfl";
+       sha256 = "d4d55f005b13e98a83273e8a7648a2a54e638b36c31639bff38c09febac0ed75";
        libraryHaskellDepends = [ base haskeline mtl ];
        jailbreak = true;
        homepage = "http://community.haskell.org/~aslatter/code/haskeline-class";
@@ -62881,7 +63093,7 @@ self: {
      mkDerivation {
        pname = "haskell-aliyun";
        version = "0.1.0.0";
-       sha256 = "1id1l7arf3yq9mym6ds58k5wins57k71v8fgzyhxsg81657vh74a";
+       sha256 = "8a1cb84f31013ddda1ffcfa11dce3c45dbc8cb444537537d4dd80f97d5a1a1c5";
        libraryHaskellDepends = [
          aeson base base64-bytestring basic-prelude blaze-builder bytestring
          case-insensitive conduit Crypto data-default http-conduit
@@ -62904,7 +63116,7 @@ self: {
      mkDerivation {
        pname = "haskell-awk";
        version = "1.1.1";
-       sha256 = "0s6vzfsqh2wwsp98l8zpg6cvh7jwz5wha44idz3yavhmy6z08zgd";
+       sha256 = "ed7d04bef1156ee5c76f91100579f95c1eb89979f7238ad2d59c0b88b5fbdb68";
        isLibrary = true;
        isExecutable = true;
        libraryHaskellDepends = [
@@ -62931,7 +63143,7 @@ self: {
      mkDerivation {
        pname = "haskell-bcrypt";
        version = "0.3.1";
-       sha256 = "1w8crppmm02qw03n59s7dnqfhmqwmd44sj8qm38bf90fabl1wa7d";
+       sha256 = "ed281ee8520e24b7d0a818494d48ab1c57e8b06d47a76207e058805aefcd0cf1";
        libraryHaskellDepends = [ base bytestring ];
        homepage = "http://www.github.com/zbskii/haskell-bcrypt";
        description = "A bcrypt implementation for haskell";
@@ -62946,7 +63158,7 @@ self: {
      mkDerivation {
        pname = "haskell-brainfuck";
        version = "0.1.0.1";
-       sha256 = "12yhnlcif0jj9pmi3a098f1swvnww45rg2rpn6g82bkjzmd4sjr8";
+       sha256 = "284b4d5afd722e819eb1378b970be1dc6eae834309a811eb4d52021719b5d08b";
        isLibrary = true;
        isExecutable = true;
        libraryHaskellDepends = [ base bytestring mtl parsec ];
@@ -62968,7 +63180,7 @@ self: {
      mkDerivation {
        pname = "haskell-cnc";
        version = "0.1.3.200";
-       sha256 = "0x1kjdxbayq6z85w9fw6c4mpixzl60332wxgx4nh0ih9235jfdhd";
+       sha256 = "0d3627cb100946002de9af73310630f4f7782b6186bbc40bfa067bb57a933374";
        isLibrary = true;
        isExecutable = true;
        libraryHaskellDepends = [
@@ -62987,7 +63199,7 @@ self: {
      mkDerivation {
        pname = "haskell-coffee";
        version = "0.1.0.2";
-       sha256 = "1iz94kyq1xn3v89aay282qglv2sh41b04p8vaygwm22v1g4b4kk7";
+       sha256 = "674eb2c80b5b88ca9f571b5d025620508b4d1f164878a512dac3f680fd24e9c7";
        libraryHaskellDepends = [ base process ];
        description = "Simple CoffeeScript API";
        license = stdenv.lib.licenses.gpl3;
@@ -62999,7 +63211,7 @@ self: {
      mkDerivation {
        pname = "haskell-compression";
        version = "0.1.1";
-       sha256 = "0d0rfkl6ladsl0s033ny390nk5qkiwddg84di0d8hgxblqsxj11m";
+       sha256 = "3504d935a6ab3f881a888da0d71a8f139769411ade8e0134a0ba296ae8741934";
        isLibrary = true;
        isExecutable = true;
        libraryHaskellDepends = [
@@ -63017,7 +63229,7 @@ self: {
      mkDerivation {
        pname = "haskell-course-preludes";
        version = "0.0.0.4";
-       sha256 = "1r0vhaxcsszrcqnw70gz8xpfrqddmxf9kpka63gix1bjic4alzjn";
+       sha256 = "567eaa088b72851edf306ade995cafade1ec6e47ff81c32d66f96bcdba821be4";
        libraryHaskellDepends = [ base deepseq ];
        jailbreak = true;
        description = "Small modules for a Haskell course in which Haskell is taught by implementing Prelude functionality";
@@ -63033,7 +63245,7 @@ self: {
      mkDerivation {
        pname = "haskell-docs";
        version = "4.2.5";
-       sha256 = "09xagxs0br6781flp430syfn6yv36ri0y1yki8cakrn7ak722fq2";
+       sha256 = "023b21ce54c7e6a9188ad3070f6236637b639dd760904b5d40c7e405747faa27";
        isLibrary = true;
        isExecutable = true;
        libraryHaskellDepends = [
@@ -63059,7 +63271,7 @@ self: {
      mkDerivation {
        pname = "haskell-formatter";
        version = "1.0.0";
-       sha256 = "0mrcd57g3pnn11smgak51pikxxf5zsi7h06f270pmf2r1vv2977b";
+       sha256 = "eb9c24f60e59b87ac111ce0078a2fec5f53ee30d65aa577508d6def14e692c57";
        isLibrary = true;
        isExecutable = true;
        libraryHaskellDepends = [
@@ -63089,7 +63301,7 @@ self: {
      mkDerivation {
        pname = "haskell-ftp";
        version = "0.1.0.1";
-       sha256 = "0736kh5q63qgvq23k5w06ds9538cwymk64i5wdycxh35lz64qaip";
+       sha256 = "372a4ccca765c0ce7ce3251233abe70c8d92743380973904de0f0f830b9c661c";
        isLibrary = true;
        isExecutable = true;
        libraryHaskellDepends = [
@@ -63116,7 +63328,7 @@ self: {
      mkDerivation {
        pname = "haskell-generate";
        version = "0.2.3";
-       sha256 = "07j0z9jxxgbxfxz9bpy5w8nphrqsl5wyq1jysfhypfi7v87nv9an";
+       sha256 = "56a56d0fda27baeba1d35e06ec79a11a67782de2c5df957e777dbdde65fa401e";
        libraryHaskellDepends = [
          base containers haskell-src-exts template-haskell transformers
        ];
@@ -63131,7 +63343,7 @@ self: {
      mkDerivation {
        pname = "haskell-in-space";
        version = "0.1.1";
-       sha256 = "1rcz5s3xa0f9yalyqb540l47bzql8p18y2mmax1zr92m7sh7m274";
+       sha256 = "e4887aa03e55a4fc4357b50a8fc24514ff750805a42ceca9f2c901d5872e9fe5";
        isLibrary = false;
        isExecutable = true;
        executableHaskellDepends = [ base HGL random ];
@@ -63146,7 +63358,7 @@ self: {
      mkDerivation {
        pname = "haskell-lexer";
        version = "1.0";
-       sha256 = "11jv30msg4rym73lk6j21ky2510c3av8qxk5p4z63j4m283w9l46";
+       sha256 = "86d0c4071295c8613eb965768cb61a0c8422fc0c429a49c7a93e93a72b185b86";
        libraryHaskellDepends = [ base ];
        description = "A fully compliant Haskell 98 lexer";
        license = stdenv.lib.licenses.bsd3;
@@ -63157,7 +63369,7 @@ self: {
      mkDerivation {
        pname = "haskell-modbus";
        version = "0.3.2";
-       sha256 = "08bcw7g84509rak9xqn2g4pr1mk3a2clikgfdiafrsr7lff16gyf";
+       sha256 = "ce3f139ca327ebec546ceecd48995063d6902f79c2e29ea6ca091482dee16c21";
        libraryHaskellDepends = [ array base bytestring cereal ];
        testHaskellDepends = [ array base bytestring cereal hspec ];
        homepage = "http://www.github.com/jhickner/haskell-modbus";
@@ -63172,7 +63384,7 @@ self: {
      mkDerivation {
        pname = "haskell-mpi";
        version = "1.4.0";
-       sha256 = "1aw8jjvysdf3vsf6rcxnvwnqpiqmfrp88gryngakjjkxwzzh5an0";
+       sha256 = "c0aa02ffe77d4a39d5b33e3f846e7615c78b2ddfb6b36c9cdec335edb79488ab";
        isLibrary = true;
        isExecutable = true;
        libraryHaskellDepends = [
@@ -63197,7 +63409,7 @@ self: {
      mkDerivation {
        pname = "haskell-names";
        version = "0.5.3";
-       sha256 = "066mh4qgldh8nspinm97695zdhw5hkpz9mmrnc2a0y0wblggq5sm";
+       sha256 = "5517fc1e5d1c78a004b3b9d6f4ef8485c3f64b3227551bafb60836fa3081d518";
        libraryHaskellDepends = [
          aeson base bytestring Cabal containers data-lens-light filepath
          haskell-packages haskell-src-exts hse-cpp mtl tagged transformers
@@ -63224,7 +63436,7 @@ self: {
      mkDerivation {
        pname = "haskell-neo4j-client";
        version = "0.3.1.4";
-       sha256 = "171ar3vfhgijy79p0a4wqm0b8bisgqf8iqzm17yb5pwirlfm5hi6";
+       sha256 = "26c2521dcd91dfb2fc09f5e3881c7e3a2eb440c59c2870d3f1323ee8f6c82a9c";
        libraryHaskellDepends = [
          aeson base bytestring containers data-default hashable HTTP
          http-conduit http-types lifted-base mtl network-uri resourcet
@@ -63249,7 +63461,7 @@ self: {
      mkDerivation {
        pname = "haskell-openflow";
        version = "0.0.0.1";
-       sha256 = "1zrzkvw4i7jaz74g63k1yj1v2i9lsxgr8zj2b6p3srag1dwgnmkd";
+       sha256 = "6d56fb780b4f653dae59427e945fd73445b183f4610ef3c8f94a9e48f89e3fff";
        libraryHaskellDepends = [
          base bytestring cereal network network-info
        ];
@@ -63268,7 +63480,7 @@ self: {
      mkDerivation {
        pname = "haskell-packages";
        version = "0.3";
-       sha256 = "199srg8k8j2nirs83hx04r1hkwv83h4k73z1sji547f5w0zwnws0";
+       sha256 = "4073cb3fe0c51d52a2d4e18f33091c68f3094326a0c381748e564834d1cb3aa5";
        libraryHaskellDepends = [
          aeson base bytestring Cabal containers deepseq directory filepath
          haskell-src-exts hse-cpp mtl optparse-applicative tagged
@@ -63287,7 +63499,7 @@ self: {
      mkDerivation {
        pname = "haskell-pdf-presenter";
        version = "0.2.5";
-       sha256 = "11y3n7ldnlx8vq2qb42kn8fg6ikq42x28bm46ivydx7h3z0zf5s3";
+       sha256 = "4317f7c11ff0f4e67734a42e24ba207846f31cb253908505dea853dbe8b1c387";
        isLibrary = false;
        isExecutable = true;
        executableHaskellDepends = [
@@ -63313,7 +63525,7 @@ self: {
      mkDerivation {
        pname = "haskell-platform-test";
        version = "2010.2.0.0";
-       sha256 = "0ki6mppxk9a6lm0miagr4mpsbjx66gizc3qxl5vfp7wvbc977bwk";
+       sha256 = "93af73125b9b9feb76a11d0ff6e333a6cba56f25f9a95841a546a5d9efad264e";
        isLibrary = false;
        isExecutable = true;
        executableHaskellDepends = [
@@ -63339,7 +63551,7 @@ self: {
      mkDerivation {
        pname = "haskell-plot";
        version = "0.1.0.0";
-       sha256 = "0dwa2kz3sbnhc99kzhspf4hhid9q0c8irq8m9vr95l9kbq45avpi";
+       sha256 = "f16e55085e33d192f24e15e11c110338b508217157c33f5362d02e3dfe148a37";
        libraryHaskellDepends = [
          base Chart Chart-cairo Chart-gtk colour data-default lens
          math-functions vector
@@ -63355,7 +63567,7 @@ self: {
      mkDerivation {
        pname = "haskell-qrencode";
        version = "1.0.4";
-       sha256 = "1cq6fpz4vsx1kfnxnxnqz0pi5nzfg86s76vd0hcqvyqxnqbcd8hj";
+       sha256 = "12a2c616b61dfb8d19046d9ba30d7aeedb122ff8d876dbad9ba1eb4dfe7506b3";
        libraryHaskellDepends = [ base bytestring ];
        librarySystemDepends = [ qrencode ];
        homepage = "https://github.com/jamessanders/haskell-qrencode";
@@ -63370,7 +63582,7 @@ self: {
      mkDerivation {
        pname = "haskell-reflect";
        version = "0.9";
-       sha256 = "116vs8p9j0py3rxh0m53nanwsa99ga0lg9z3avn5r0clmpak9zyn";
+       sha256 = "d6ff34d5ad94815cec56e3a747817a2929cdadb2a354007b1efe02992ed2db84";
        libraryHaskellDepends = [
          base containers hint MonadCatchIO-mtl mtl parsec template-haskell
          transformers
@@ -63385,7 +63597,7 @@ self: {
      mkDerivation {
        pname = "haskell-rules";
        version = "0.1.0.1";
-       sha256 = "03d8c1gnxd923f3fqqw06w3ibnd20llfgd7s5jgkscc872i5ghz6";
+       sha256 = "e6c357a23888313d9f2cfab4e72805a2d91507378063ec861b22b56e5f60a80d";
        libraryHaskellDepends = [ base syb ];
        description = "A DSL for expressing natural deduction rules in Haskell";
        license = stdenv.lib.licenses.gpl3;
@@ -63399,7 +63611,7 @@ self: {
      mkDerivation {
        pname = "haskell-spacegoo";
        version = "0.2.0.1";
-       sha256 = "0g6ximrv5jwibklkyr74vy3qkx8mv4xbpc7f6w1qg9gnlylzmcqy";
+       sha256 = "1eb3faa9a7f6a5870337eeb0bb3ad915f58987dfe4643fe95c91cbb2738ddd3c";
        libraryHaskellDepends = [
          aeson base bytestring conduit conduit-extra mtl pretty pretty-show
          text vector vector-space
@@ -63413,7 +63625,7 @@ self: {
      mkDerivation {
        pname = "haskell-src";
        version = "1.0.2.0";
-       sha256 = "19lilhpwnjb7cks9fq1ipnc8f7dwxy0ri3dgjkdxs3i355byw99a";
+       sha256 = "2a25ee5729230edddb94af8d9881efbc1d8798bd316097f4646749cb2fa491a6";
        libraryHaskellDepends = [ array base pretty syb ];
        libraryToolDepends = [ happy ];
        description = "Support for manipulating Haskell source code";
@@ -63428,7 +63640,7 @@ self: {
      mkDerivation {
        pname = "haskell-src-exts";
        version = "1.15.0.1";
-       sha256 = "0xp5i06c478vn5m504ax5dfa7p5zc0kflbdkm2ijdzc779lpbx45";
+       sha256 = "85f475693a87fd26a3a8b32dea2660bfdca35c2b5d11506ab11b1dc20c88e576";
        libraryHaskellDepends = [ array base cpphs ghc-prim pretty ];
        libraryToolDepends = [ happy ];
        testHaskellDepends = [
@@ -63448,7 +63660,7 @@ self: {
      mkDerivation {
        pname = "haskell-src-exts";
        version = "1.16.0.1";
-       sha256 = "1h8gjw5g92rvvzadqzpscg73x7ajvs1wlphrh27afim3scdd8frz";
+       sha256 = "3f3bd41ad3a346a78e80195eca83de529d3ece63fa7edcd4df3b8bf40a970fc1";
        libraryHaskellDepends = [ array base cpphs ghc-prim pretty ];
        libraryToolDepends = [ happy ];
        testHaskellDepends = [
@@ -63467,7 +63679,7 @@ self: {
      mkDerivation {
        pname = "haskell-src-exts-qq";
        version = "0.6.1";
-       sha256 = "0cblv8fk369236szwzwmyaxaa8fkwia5r50zz5ghfbglb2xvwsmn";
+       sha256 = "b66abebb58f42d075ff91f945c54e4d321a5baf2957ffeb5192299311dda7431";
        libraryHaskellDepends = [
          base haskell-src-exts haskell-src-meta syb template-haskell
        ];
@@ -63482,7 +63694,7 @@ self: {
      mkDerivation {
        pname = "haskell-src-meta";
        version = "0.6.0.10";
-       sha256 = "0flcyimibz4flq66isshn2zsmzlly6sja6gfb0a0xn4ns4xpwpy1";
+       sha256 = "c15f7e3bd196d80e1458ee1925b5f194feaabfb050eb680ca68efc156bf48c3a";
        libraryHaskellDepends = [
          base haskell-src-exts pretty syb template-haskell th-orphans
        ];
@@ -63497,7 +63709,7 @@ self: {
      mkDerivation {
        pname = "haskell-src-meta-mwotton";
        version = "0.1.0";
-       sha256 = "04f0p3jxmvw1kqygvxihdr4dirapi6bdv2w213c2s771xbnx88nn";
+       sha256 = "d622d4edeae11c2dd808828bdd968957e5d8486e30f6fd3c9e81efdae5b8c011";
        libraryHaskellDepends = [
          base containers ghc-prim haskell-src-exts pretty syb
          template-haskell
@@ -63517,7 +63729,7 @@ self: {
      mkDerivation {
        pname = "haskell-token-utils";
        version = "0.0.0.6";
-       sha256 = "14nzlw9vqnp70xcwan6mjsr318p2sky5nsyqxw5iivggy7qspp9r";
+       sha256 = "39ddabf1f1efed180befd86b5bfcd4e2a230b296d558c55907e75abc13a7df92";
        libraryHaskellDepends = [
          base containers dual-tree ghc ghc-paths ghc-syb-utils
          haskell-src-exts monoid-extras mtl pretty rosezipper semigroups syb
@@ -63538,7 +63750,7 @@ self: {
      mkDerivation {
        pname = "haskell-type-exts";
        version = "0.1.0";
-       sha256 = "051lsg9j3dgkr2akannfaddawdhybvsnm6x6xafmdmwn31v73z98";
+       sha256 = "28fd71761896d7569deaa69b6af55e1e36ae5a53ce5a3595c8f3b521d3d33414";
        libraryHaskellDepends = [
          base containers haskell-src-exts pretty
        ];
@@ -63553,7 +63765,7 @@ self: {
      mkDerivation {
        pname = "haskell-typescript";
        version = "0.1.0.0";
-       sha256 = "0fv533nac6dlawgffr1kvn4xpv63hdcb4wgyqbbg2s6dg9a2hw38";
+       sha256 = "687028547acd68f1d6c2fe71b25883c3ecdb89dd3364e71e57b419a6ec18653b";
        libraryHaskellDepends = [ base process ];
        jailbreak = true;
        description = "Simple TypeScript API";
@@ -63565,7 +63777,7 @@ self: {
      mkDerivation {
        pname = "haskell-tyrant";
        version = "0.4";
-       sha256 = "1pqh1v0klpi8iq882l5gk0fsf87kabq6rw1wjwkiq6fvw8cc1l97";
+       sha256 = "27d1c018e2db191c27973cf06cf052f320a71d98af5081108e285e3ac10e10df";
        libraryHaskellDepends = [ base binary bytestring network ];
        homepage = "https://github.com/PeterScott/haskell-tyrant";
        description = "Haskell implementation of the Tokyo Tyrant binary protocol";
@@ -63580,7 +63792,7 @@ self: {
      mkDerivation {
        pname = "haskell-updater";
        version = "1.2.9";
-       sha256 = "0nd8xjlyr8zjrqj9mw6xpn3rxsj9vpb8khc6hq6dc5agmldl9z7a";
+       sha256 = "eafc441bad4f15d60c8686c189d6dd49ea9e87bdddf09a24cef2a3eca9eca859";
        isLibrary = false;
        isExecutable = true;
        executableHaskellDepends = [
@@ -63598,7 +63810,7 @@ self: {
      mkDerivation {
        pname = "haskell-xmpp";
        version = "1.0.2";
-       sha256 = "1z4x4mn0vry8mwq6ily668ignmf4s9m92fmga15dr83y7aq5wd59";
+       sha256 = "a9345eb03a7ea0dc4a50af3a916ad2c455fb2232c6d36830afc8e70d6c259dfc";
        isLibrary = true;
        isExecutable = true;
        libraryHaskellDepends = [
@@ -63616,7 +63828,7 @@ self: {
      mkDerivation {
        pname = "haskell2010";
        version = "1.1.2.0";
-       sha256 = "1s0avb08b5iwaym42jz783mk1az9kmjf3zmhfag0kzdw10qcnz4m";
+       sha256 = "957ccb3008bcfd099e72b0fee1649de9ab30eb40e74b41aa573c9685c0da0ae8";
        libraryHaskellDepends = [ array base ghc-prim ];
        jailbreak = true;
        homepage = "http://www.haskell.org/onlinereport/haskell2010/";
@@ -63632,7 +63844,7 @@ self: {
      mkDerivation {
        pname = "haskell98";
        version = "2.0.0.3";
-       sha256 = "1450bgkn7gasj6cmkxn4afs828fc9slrrp2lqsqs3jlryr94cpdx";
+       sha256 = "bd5d4652f699caa1b1c654dc9ca94ecc2181b453c4f65999915abd63e75ba090";
        libraryHaskellDepends = [
          array base directory old-locale old-time process time
        ];
@@ -63650,7 +63862,7 @@ self: {
      mkDerivation {
        pname = "haskell98libraries";
        version = "2.0.0.2";
-       sha256 = "1dcjwkvggvwrs8lv2pcxcz2kcz179nbca9q16mbk90qnznysr8i8";
+       sha256 = "28a2acbdfd16833457350127c5964d277c36c5679d5db129d299eff7f6e492b5";
        libraryHaskellDepends = [
          array base directory old-locale old-time process time
        ];
@@ -63667,7 +63879,7 @@ self: {
      mkDerivation {
        pname = "haskelldb";
        version = "2.2.4";
-       sha256 = "0f8c9bz25wzsc65czv0chxk93w947824axl7p821fljlrykcm45y";
+       sha256 = "be90caa6cf54521704ba877645043a24f19166870ceccf8a61faf322fe4a0c39";
        libraryHaskellDepends = [
          base containers directory mtl old-locale old-time pretty time
        ];
@@ -63681,7 +63893,7 @@ self: {
      mkDerivation {
        pname = "haskelldb-connect-hdbc";
        version = "0.1.0.0";
-       sha256 = "1l9ifff33xbgdr6fahnzz00nb7va2r0i3pncjd1j8bbnyya1w2kl";
+       sha256 = "740a1e94f7762d244393ccde1141166a9f6501f8df42e54c6e6ff5319c7331d1";
        libraryHaskellDepends = [ base containers haskelldb HDBC ];
        homepage = "http://twitter.com/khibino";
        description = "Bracketed HDBC session for HaskellDB";
@@ -63696,7 +63908,7 @@ self: {
      mkDerivation {
        pname = "haskelldb-connect-hdbc-catchio-mtl";
        version = "0.1.0.0";
-       sha256 = "1ssg96r7cphakis5c494m5lc3m5ksn1w03k554p0qx2kl1g885xw";
+       sha256 = "bc17845ea053740c2e29650ec083d5b3d4c168a9241156749c0a5e76b2494feb";
        libraryHaskellDepends = [
          base haskelldb haskelldb-connect-hdbc HDBC MonadCatchIO-mtl mtl
        ];
@@ -63713,7 +63925,7 @@ self: {
      mkDerivation {
        pname = "haskelldb-connect-hdbc-catchio-tf";
        version = "0.1.0.0";
-       sha256 = "16qab88ryli9jbinw9frhhzl0ph09dinzx40x9cr9a3db7wvphw4";
+       sha256 = "84c3bbf9596da89459ea80f46f634b005e403f84d9256ee39229529f115a0a9b";
        libraryHaskellDepends = [
          base haskelldb haskelldb-connect-hdbc HDBC
          MonadCatchIO-transformers transformers
@@ -63731,7 +63943,7 @@ self: {
      mkDerivation {
        pname = "haskelldb-connect-hdbc-catchio-transformers";
        version = "0.1.0.0";
-       sha256 = "0hbb6klc4azz6f5wi39l5736xq0b7wgja35fk9vmmn0lnf6iv5j7";
+       sha256 = "47961d8db314d85a779aae0c251f3f0be06ec629348dc88b33ff2bc2e8346b41";
        libraryHaskellDepends = [
          base haskelldb haskelldb-connect-hdbc HDBC
          MonadCatchIO-transformers transformers
@@ -63749,7 +63961,7 @@ self: {
      mkDerivation {
        pname = "haskelldb-connect-hdbc-lifted";
        version = "0.1.0.0";
-       sha256 = "1ysnha7bmrd3accrnbswr17nv6j4pj1mbshcphjkhdffcvxb82wa";
+       sha256 = "8a0bb4fa66ce353825bc0cea5583bc449a6d4fc85c2f9b1953a3e5ba8e8256fb";
        libraryHaskellDepends = [
          base haskelldb haskelldb-connect-hdbc HDBC lifted-base
          monad-control transformers-base
@@ -63765,7 +63977,7 @@ self: {
      mkDerivation {
        pname = "haskelldb-dynamic";
        version = "1.0.0";
-       sha256 = "0wdiywxjara2fwb1d548f9s0vcjxm1c38v4s05xqm5bz141l7a6a";
+       sha256 = "caa84303097f958a7b019a6c3458a85db20d747288941616774265253bf7b171";
        isLibrary = true;
        isExecutable = true;
        libraryHaskellDepends = [ base haskell98 haskelldb mtl plugins ];
@@ -63784,7 +63996,7 @@ self: {
      mkDerivation {
        pname = "haskelldb-flat";
        version = "1.0.1";
-       sha256 = "0f75am17zfpbxhg951gnjqmdfgi1q7byhw1xv1rz4k36kcg623x1";
+       sha256 = "a10f611e9b664cf273d83d70e8d7c1213ed72a96f685921eecebba7f4255e538";
        isLibrary = true;
        isExecutable = true;
        libraryHaskellDepends = [
@@ -63803,7 +64015,7 @@ self: {
      mkDerivation {
        pname = "haskelldb-hdbc";
        version = "2.2.2";
-       sha256 = "06vzzya6k1l74bm5ky7cbn6ch1wx5j5phnhi49bw17y3q632vd3f";
+       sha256 = "6eb42d86c1c39fc05722115a788b2c9d07c88c5decf859ea2287866994ff7f1b";
        libraryHaskellDepends = [
          base containers convertible haskelldb HDBC mtl old-time
        ];
@@ -63820,7 +64032,7 @@ self: {
      mkDerivation {
        pname = "haskelldb-hdbc-mysql";
        version = "0.1.1";
-       sha256 = "0nn8jjrsi62xqws00izh3qi2shlxa58l37q91x1xnd9fig7j0ai2";
+       sha256 = "222a20cf8b2e35db430f099f4151519d422d221ef0470034c75d98a8b394c85a";
        isLibrary = true;
        isExecutable = true;
        libraryHaskellDepends = [
@@ -63839,7 +64051,7 @@ self: {
      mkDerivation {
        pname = "haskelldb-hdbc-odbc";
        version = "2.1.2";
-       sha256 = "1y87iiil6k9ycsni70kvfcq50fiws8aqnhmk4018f6k6q1bx7q6p";
+       sha256 = "d7e0d357c0661a870220b3428b15d23c3a5030737b8213ad663e4d43638c07f9";
        isLibrary = true;
        isExecutable = true;
        libraryHaskellDepends = [
@@ -63858,7 +64070,7 @@ self: {
      mkDerivation {
        pname = "haskelldb-hdbc-postgresql";
        version = "2.1.2";
-       sha256 = "08cv3y22zvf0pf1cs57vrma3vp3b5fzzs6nsnvcnfnzsvacanh7g";
+       sha256 = "ef40ab98dafa5b67d9b6da1afdbf2b6bdc3d54cdfb14cd82bbc0ed2f841f9b21";
        isLibrary = true;
        isExecutable = true;
        libraryHaskellDepends = [
@@ -63878,7 +64090,7 @@ self: {
      mkDerivation {
        pname = "haskelldb-hdbc-sqlite3";
        version = "2.1.2";
-       sha256 = "0qdp2lzhk8ywb9pmppvvmwqkaagvrnyjiglahy6mb7rdfq89bas6";
+       sha256 = "46ab9510762d9f558d878abe28bdcdfb293531af7bdf5b6f5adca3093f15b761";
        isLibrary = true;
        isExecutable = true;
        libraryHaskellDepends = [
@@ -63895,7 +64107,7 @@ self: {
      mkDerivation {
        pname = "haskelldb-hsql";
        version = "1.0.0";
-       sha256 = "0j1aqix21pqcsw7skl897pd1ir6hg836g4zb2h5338h4gih6blx0";
+       sha256 = "a0d365607c04a2310a14eb9367067ad0e418da3d09d1a90fd70cdf207ac42a48";
        libraryHaskellDepends = [ base haskelldb hsql mtl old-time ];
        jailbreak = true;
        homepage = "https://github.com/m4dc4p/haskelldb";
@@ -63911,7 +64123,7 @@ self: {
      mkDerivation {
        pname = "haskelldb-hsql-mysql";
        version = "1.0.0";
-       sha256 = "09rlrv9jb2hw7jypglfqhgfx3b0bcp68iq2wk4jfqw74m4d34xkm";
+       sha256 = "7576321aa9e470ec24995ce088cc650bacd1dd83d8d177bd3c1c8a25d3ce3427";
        isLibrary = true;
        isExecutable = true;
        libraryHaskellDepends = [
@@ -63931,7 +64143,7 @@ self: {
      mkDerivation {
        pname = "haskelldb-hsql-odbc";
        version = "1.0.0";
-       sha256 = "18r7b4x43729c9l34gvbhgw2fwgq7llcb6cfwcp077f9ia0kgn6a";
+       sha256 = "cad837818ac99d032ee38e99c5283df87127f8836b3f326862499c413a5927a3";
        isLibrary = true;
        isExecutable = true;
        libraryHaskellDepends = [
@@ -63951,7 +64163,7 @@ self: {
      mkDerivation {
        pname = "haskelldb-hsql-oracle";
        version = "1.0.0";
-       sha256 = "0j26gm9bibnj2jl5fs3sf2m8b5gl05brf55bzxnxa1cb78dgbpx9";
+       sha256 = "a9dff51a3a8b05d56dffab14975701f49585aa707a6857a814d2aeb8527d4648";
        isLibrary = true;
        isExecutable = true;
        libraryHaskellDepends = [
@@ -63971,7 +64183,7 @@ self: {
      mkDerivation {
        pname = "haskelldb-hsql-postgresql";
        version = "1.0.0";
-       sha256 = "1d1vgw9q95h864gfv0n2gmdvnvkxjg4pdjmfpfj899xx1s0a0vsv";
+       sha256 = "5b6fa0800ebda784a4bbaeca76c9937d6ebb5b7dc282ed1e31089684137f3bb4";
        isLibrary = true;
        isExecutable = true;
        libraryHaskellDepends = [
@@ -63991,7 +64203,7 @@ self: {
      mkDerivation {
        pname = "haskelldb-hsql-sqlite";
        version = "1.0.0";
-       sha256 = "0hs8ympicys4p6lpfcvny3c183v4s25lk990yb4fzrpv0hy3bhhw";
+       sha256 = "1cc2353c04fbe6efc8f220a5498bd0640f14d8f0763377a9b9447b166ff54843";
        isLibrary = true;
        isExecutable = true;
        libraryHaskellDepends = [
@@ -64011,7 +64223,7 @@ self: {
      mkDerivation {
        pname = "haskelldb-hsql-sqlite3";
        version = "1.0.0";
-       sha256 = "11xlr2f7203wxg17696yjqgyzckavqjazc9brmdqpbrnplaqdrc5";
+       sha256 = "85e58615bd36af8b5bcd2bb1af24de6ab2ef1f96de2473c2eb7c00719cc8b487";
        isLibrary = true;
        isExecutable = true;
        libraryHaskellDepends = [
@@ -64029,7 +64241,7 @@ self: {
      mkDerivation {
        pname = "haskelldb-th";
        version = "2.1.0";
-       sha256 = "12whvz0qy9lqk1frfl5px9lhr1nwy519vj2z9c3g8nqjzscwzayb";
+       sha256 = "cbabcf99fe125bf4064b5fc89d42f1dc860c69eab750975d9898268fc1df908b";
        libraryHaskellDepends = [ base haskelldb mtl template-haskell ];
        jailbreak = true;
        homepage = "http://trac.haskell.org/haskelldb-th";
@@ -64042,7 +64254,7 @@ self: {
      mkDerivation {
        pname = "haskelldb-wx";
        version = "1.0.0";
-       sha256 = "01652m0bym80400navqlpdv5n0gfgnfzd1d0857f3kd13ksqk2hy";
+       sha256 = "1e8a89f51ca1cde14e41a085f69d7dee015b76bb146f6501200055bf4015c504";
        homepage = "https://github.com/m4dc4p/haskelldb";
        description = "HaskellDB support for WXHaskell";
        license = stdenv.lib.licenses.bsd3;
@@ -64058,7 +64270,7 @@ self: {
      mkDerivation {
        pname = "haskellscrabble";
        version = "1.1";
-       sha256 = "1wb9ncpzsacvwk8gmh8gzxm54viwlzsikj05lk14gpyp8xwhl54h";
+       sha256 = "90140a7947d7df47c2a405c819f5a73c6e526aff0fc1fad0e49b29fd2fb369f1";
        libraryHaskellDepends = [
          array arrows base containers errors mtl parsec QuickCheck random
          safe semigroups split transformers unordered-containers
@@ -64081,7 +64293,7 @@ self: {
      mkDerivation {
        pname = "haskellscript";
        version = "0.2.3";
-       sha256 = "0jrvvbpx35dhrwvknrxcwg1j1yi0mwzrnzrr2hsxja21drrqklf3";
+       sha256 = "c3d189736e4128d93514397f9b3faf20fa20c3e3ac673b37cfb095d1efda3b4b";
        isLibrary = false;
        isExecutable = true;
        executableHaskellDepends = [
@@ -64101,7 +64313,7 @@ self: {
      mkDerivation {
        pname = "haskelm";
        version = "0.1.12.0";
-       sha256 = "1bzp79fcq6gxy8pvspw4q71iakzvrbdwr3vjahd698ymfbj5ji8y";
+       sha256 = "1e4559e472d5a3641a54728fccdbcafb4f15c3c1845fbd2ff2fd19cc5c3af7af";
        isLibrary = true;
        isExecutable = true;
        libraryHaskellDepends = [
@@ -64131,7 +64343,7 @@ self: {
      mkDerivation {
        pname = "haskgame";
        version = "0.0.6";
-       sha256 = "061dhk7d9d8mnb1rs7077q383sqlby8s31ips8jjadkkhyxi5lvz";
+       sha256 = "7fd312bb8773362525d23786a1915f14eb81063e071c9dc3b215b5d4ce842d18";
        libraryHaskellDepends = [ base containers haskell98 SDL SDL-ttf ];
        homepage = "http://haskell.org/haskellwiki/HaskGame";
        description = "Haskell game library";
@@ -64146,7 +64358,7 @@ self: {
      mkDerivation {
        pname = "haskheap";
        version = "0.1.2";
-       sha256 = "1c2fgqq2i3s2v0xi04y8y6li41ilvi50zlf2ba843my9s3i8njqr";
+       sha256 = "194b8be2d0c9d741905ac2d10f4adc340612a9f1c813103bd8428f28307e4eb0";
        libraryHaskellDepends = [
          aeson base bytestring http-conduit http-types network old-locale
          text time unordered-containers
@@ -64166,7 +64378,7 @@ self: {
      mkDerivation {
        pname = "haskhol-core";
        version = "1.1.0";
-       sha256 = "0vlzybbplqggvgnj61yl0g2rak2qbsp7hly9srgr6wd6qm9l1nxx";
+       sha256 = "bddb4053c5a671935fd6c95378ae5e584c95c503d40723eddbef617ad7f29f6e";
        libraryHaskellDepends = [
          acid-state base containers deepseq filepath ghc-prim hashable mtl
          parsec pretty safecopy shelly template-haskell text text-show
@@ -64187,7 +64399,7 @@ self: {
      mkDerivation {
        pname = "haskintex";
        version = "0.5.0.3";
-       sha256 = "0gbsr3b832rb3gk6gx3s1lrjpv4kqcf62cz3wgjj5riscq1vg73k";
+       sha256 = "739cb703663ae622e5e3e333611cc393ec2b330d7af467e61b2b8b81d6c87a3d";
        isLibrary = true;
        isExecutable = true;
        libraryHaskellDepends = [
@@ -64207,7 +64419,7 @@ self: {
      mkDerivation {
        pname = "haskmon";
        version = "0.1.1.0";
-       sha256 = "1xsp0jd7n5rbky4giy3dik2hcsnkzwlj2mdr8v3ahr17cqj3sm74";
+       sha256 = "e4543d24662764a8c646b9552129ffd36a06c58c6df8f8889f2b177b9a0457f7";
        libraryHaskellDepends = [
          aeson base bytestring containers http-streams io-streams old-locale
          time vector
@@ -64227,7 +64439,7 @@ self: {
      mkDerivation {
        pname = "haskoin";
        version = "0.1.0.2";
-       sha256 = "0l3h2wvi56k0dcfjambqyjrd45hb7bj0brp8nzrrcfn7fbpyjg8c";
+       sha256 = "0c3de9ef72c73a96f3b7e8e605e43a0b16d2b2f47855251d6b609a1237177050";
        libraryHaskellDepends = [
          aeson base binary byteable bytestring containers cryptohash deepseq
          either json-rpc mtl pbkdf split text
@@ -64252,7 +64464,7 @@ self: {
      mkDerivation {
        pname = "haskoin-crypto";
        version = "0.0.1.1";
-       sha256 = "00argpj3qkaj8dcxbd46xsi1abjgr394li6ygyvna55508r1hd79";
+       sha256 = "e934183202a51465b77fde444ad2c84f2e15a2ee86b4d55943524d3ce47d5901";
        libraryHaskellDepends = [
          base binary byteable bytestring containers cryptohash haskoin-util
          mtl QuickCheck
@@ -64277,7 +64489,7 @@ self: {
      mkDerivation {
        pname = "haskoin-protocol";
        version = "0.0.1.1";
-       sha256 = "0r15csyylg5vd95z0spl5wkv6r8w7lpi983alsvlnkhv4dqnrg2v";
+       sha256 = "5bbc6c71231b4e4bb7a66aa0142f3d1c65b3272ff46af04b6abb3ceabd662564";
        libraryHaskellDepends = [
          base binary bytestring haskoin-crypto haskoin-util QuickCheck
        ];
@@ -64300,7 +64512,7 @@ self: {
      mkDerivation {
        pname = "haskoin-script";
        version = "0.0.1";
-       sha256 = "18lw5hxwvj4ichw1k4a35hjih7h0hd24khvl4m0yf2cq12m2gl11";
+       sha256 = "21d027aa089809e7412574c3494483001e18252c439119386491c8cd3b2c9ca2";
        libraryHaskellDepends = [
          base binary bytestring haskoin-crypto haskoin-protocol haskoin-util
          mtl QuickCheck
@@ -64325,7 +64537,7 @@ self: {
      mkDerivation {
        pname = "haskoin-util";
        version = "0.0.1.1";
-       sha256 = "0hh3vavqsp8pafw4nrv9py1kqcc1yx52zr80xsqzqjlsxq04fgfw";
+       sha256 = "dc3d4700ee9a4afcb1ee00e52f4af781313c83bf69674bb853175d8db7da0342";
        libraryHaskellDepends = [
          base binary bytestring either mtl QuickCheck
        ];
@@ -64351,7 +64563,7 @@ self: {
      mkDerivation {
        pname = "haskoin-wallet";
        version = "0.0.1";
-       sha256 = "18q110q93qc00mqzprs5wprzrl0jfw5fjpli73n99knqb127aq5s";
+       sha256 = "ba60754458d8ce94ec38915ee90a7712d0fcf3e545e7fb710580e191300801a3";
        isLibrary = true;
        isExecutable = true;
        libraryHaskellDepends = [
@@ -64388,7 +64600,7 @@ self: {
      mkDerivation {
        pname = "haskoon";
        version = "0.3.1.1";
-       sha256 = "1rf5w1mvpsiqim1h5hh6s2cxzh3c5gm1k3n6z4h2ryc1s7m2bl9l";
+       sha256 = "34d125ead181f92c20f9c68e19ea2b6cc0df99d006c202438d38eabb6be0c5e5";
        libraryHaskellDepends = [
          base bytestring cgi directory fastcgi filepath hslogger hsp hsx
          MaybeT MissingH mtl network regex-posix safe utf8-string
@@ -64405,7 +64617,7 @@ self: {
      mkDerivation {
        pname = "haskoon-httpspec";
        version = "0.5.0.1";
-       sha256 = "059hywia5fa15j2dpbzvnvjzv55bzgivy3ddxcrdskd85zx7lx6z";
+       sha256 = "df747afa2fa84ddd32ebad0dbfe3fbab94fde5b6fbafdb842c41b9a222f73015";
        libraryHaskellDepends = [
          base bidispec bytestring haskoon hslogger HTTP httpspec mtl network
        ];
@@ -64422,7 +64634,7 @@ self: {
      mkDerivation {
        pname = "haskoon-salvia";
        version = "0.4.0.2";
-       sha256 = "0d0s0zd9gr3xbssyk62l7w507prjnyak81czhnd6fgbfqx82d6hk";
+       sha256 = "139a2650c76e3d679a859f053495b732df030a3f5498e9b55e7de497da071a34";
        libraryHaskellDepends = [
          base bytestring cgi fclabels haskoon hslogger HTTP monads-fd mtl
          network salvia salvia-protocol transformers
@@ -64440,7 +64652,7 @@ self: {
      mkDerivation {
        pname = "haskore";
        version = "0.2.0.5";
-       sha256 = "0zvr7hwxnv01g626617yv7f0vwpmyqvlwbyc6yhb2mrlfqwdgbd0";
+       sha256 = "a0add738763457b1a037cc2f4e37f6f5f20ddcd9fe04638479016cdb393c797f";
        isLibrary = true;
        isExecutable = true;
        libraryHaskellDepends = [
@@ -64462,7 +64674,7 @@ self: {
      mkDerivation {
        pname = "haskore-realtime";
        version = "0.2";
-       sha256 = "0fhlfivp44py93gjlqrp370cjkvi0g79p156vayylds128hgpi5f";
+       sha256 = "aec4fb20124137eabddaa6849bce03714fc9c01937632adf48fe12727774143a";
        libraryHaskellDepends = [
          base bytestring data-accessor directory event-list haskore midi
          non-negative old-time process transformers unix utility-ht
@@ -64482,7 +64694,7 @@ self: {
      mkDerivation {
        pname = "haskore-supercollider";
        version = "0.3";
-       sha256 = "04rzbk1v8ay569npd8i1xv3aqx55jn8p6cvqpi6774afaxvb0qxy";
+       sha256 = "be63b076574e91734cbc7833739195a574acc6ee21a2766d32c52bb4c35c3f13";
        isLibrary = true;
        isExecutable = true;
        libraryHaskellDepends = [
@@ -64505,7 +64717,7 @@ self: {
      mkDerivation {
        pname = "haskore-synthesizer";
        version = "0.0.3.1";
-       sha256 = "0bdfn8s7gj39i3rr3xvi9xchi8zczqimb5gnkg0225m2zcfgvmy8";
+       sha256 = "c8d7fd1cfba21621c09bf6955523feeca308594f71f791f38869c87734b2ae2d";
        isLibrary = true;
        isExecutable = true;
        libraryHaskellDepends = [
@@ -64524,7 +64736,7 @@ self: {
      mkDerivation {
        pname = "haskore-vintage";
        version = "0.2";
-       sha256 = "1dpqs7xv3hvhla94v60q0fxfzgr4l3l69s7xc45rh712r9iws66n";
+       sha256 = "d618cd63ca221c980b61fde864e8a024bfefba0318984d92a270c3b1fbd1f8b6";
        libraryHaskellDepends = [ base ];
        homepage = "http://haskell.org/haskore/";
        description = "The February 2000 version of Haskore";
@@ -64539,7 +64751,7 @@ self: {
      mkDerivation {
        pname = "hasktags";
        version = "0.69.1";
-       sha256 = "1rpi9nrxizvzs7cxmykxvkbwd78144gwglk5f0rc19qyb0n80gr4";
+       sha256 = "243f802c581ea7c0327065d2c71f21019dc6d7dc7dfadad9d17fffd8b34df1e6";
        isLibrary = true;
        isExecutable = true;
        libraryHaskellDepends = [
@@ -64556,7 +64768,7 @@ self: {
      mkDerivation {
        pname = "haslo";
        version = "0.1.3";
-       sha256 = "0iizdi98w4k9kdizg9xwm2aca6mnn30frp15f8kyak3i194sk3kl";
+       sha256 = "748ea9490a714ce5277225dcecc0b0b61ac594a8bca7f7639b69128e526c3f46";
        isLibrary = true;
        isExecutable = true;
        libraryHaskellDepends = [ base mtl old-time wtk ];
@@ -64573,7 +64785,7 @@ self: {
      mkDerivation {
        pname = "hasloGUI";
        version = "0.1";
-       sha256 = "03avp9yn7ag1dc1wzk07sxkj3krqsrg3n44qcynxw9n1fmvk54lx";
+       sha256 = "9d92327775c126dead6798103b5ed638cf2167d707cccf036be1a9637dba5b0d";
        isLibrary = false;
        isExecutable = true;
        executableHaskellDepends = [
@@ -64590,7 +64802,7 @@ self: {
      mkDerivation {
        pname = "hasparql-client";
        version = "0.1";
-       sha256 = "1ln0kdm40y6l8sncrjl0mj9bpd30ffg3msaxyd6fq520ypyws9pm";
+       sha256 = "f526cdfdf54014ec4cf35de93a9e7360b4bb92ac80caccac46d478406a9bc0d2";
        libraryHaskellDepends = [ base HTTP monads-fd network xml ];
        homepage = "https://github.com/lhpaladin/HaSparql-Client";
        description = "This package enables to write SPARQL queries to remote endpoints";
@@ -64603,7 +64815,7 @@ self: {
      mkDerivation {
        pname = "haspell";
        version = "1.1.0";
-       sha256 = "08ihdjgjvr8mgxxw62xwymj1lyl33r6w3mhy9chlw7ijcsy44y21";
+       sha256 = "417842bc66321e4e214b1ed6c14d1e837a1a64f5bc0bc37b7f15e52d9f6c3022";
        libraryHaskellDepends = [ base bytestring ];
        librarySystemDepends = [ aspell ];
        homepage = "https://github.com/otters/haspell";
@@ -64619,8 +64831,8 @@ self: {
      }:
      mkDerivation {
        pname = "hasql";
-       version = "0.7.3.2";
-       sha256 = "1hhqs4acq8g3331av1lm6l7mmd0sswym278wsn3i0p9khyafpkcm";
+       version = "0.7.4";
+       sha256 = "c7172de28bf9fdecaff4f2f04b16bfc70994555ebe339c9b96995e224e9d694f";
        libraryHaskellDepends = [
          attoparsec base base-prelude either hasql-backend list-t mmorph
          monad-control mtl resource-pool template-haskell text transformers
@@ -64642,8 +64854,8 @@ self: {
      }:
      mkDerivation {
        pname = "hasql-backend";
-       version = "0.4.1.1";
-       sha256 = "13llpvppkj2k6kfhmqyllm3m2h8g7lvm6gy8y2bnqq8y5jw9xdm5";
+       version = "0.4.2";
+       sha256 = "541a37b288ec5300e9830416a764ef54cce82415b3678c08af526f569e88c20a";
        libraryHaskellDepends = [
          base-prelude bytestring either free list-t text transformers vector
        ];
@@ -64662,8 +64874,8 @@ self: {
      }:
      mkDerivation {
        pname = "hasql-postgres";
-       version = "0.10.4.0";
-       sha256 = "0s2ng84m7mals3wm3lzmhfd9xlh8fm231gklzjyh6q7z5yw4yszf";
+       version = "0.10.5";
+       sha256 = "114b137e00975e729a19f5d2195da2db7c9c5080fc8a76821c712a9304a6d29a";
        libraryHaskellDepends = [
          aeson attoparsec base-prelude bytestring either free hashable
          hashtables hasql-backend list-t loch-th mmorph placeholders
@@ -64688,7 +64900,7 @@ self: {
      mkDerivation {
        pname = "hasql-postgres-options";
        version = "0.1.4";
-       sha256 = "19jsi8r63phyjcwgvbbs30idl944dnl0iw15i0q2d501sa51ksf4";
+       sha256 = "c4e9198ad2019426308825f008a86d8424da22187aadfd38931ede61328a5aa6";
        libraryHaskellDepends = [
          base-prelude hasql-postgres optparse-applicative
        ];
@@ -64705,7 +64917,7 @@ self: {
      mkDerivation {
        pname = "hastache";
        version = "0.6.1";
-       sha256 = "0r5l8k157pgvz1ck4lfid5x05f2s0nlmwf33f4fj09b1kmk8k3wc";
+       sha256 = "8c8f89669d6125201d7163385ea9055ab8027a69d1513259f8fbdd53c244b464";
        revision = "2";
        editedCabalFile = "92cea66e7c2d33e62c5caac8eaaf0e716fa6e2146ef906360db4d5f72cd30091";
        isLibrary = true;
@@ -64733,7 +64945,7 @@ self: {
      mkDerivation {
        pname = "hastache-aeson";
        version = "0.1.0.0";
-       sha256 = "0b69ppgs0s8zjkrycz5iyd1wa92wr9wln3dvgzf736pbfhsgv2qi";
+       sha256 = "118bfd3474eb9a71dc7fbb0d4b79ca5c24c543f3b17ce6f3941f69a0dfbdc92c";
        libraryHaskellDepends = [
          aeson attoparsec base bytestring containers hastache text
          unordered-containers vector
@@ -64750,7 +64962,7 @@ self: {
      mkDerivation {
        pname = "haste";
        version = "0.1.1";
-       sha256 = "1vz36i74l1nnm34nn1rj3v8kprqa2piz3j5f58cccg2gvxl0abnj";
+       sha256 = "d22e0568df4f3cc6182aaec8f1e3150ae73bd11e32076bc9a8d6064a4e34e3ef";
        isLibrary = false;
        isExecutable = true;
        executableHaskellDepends = [ base curl filepath mtl ];
@@ -64770,7 +64982,7 @@ self: {
      mkDerivation {
        pname = "haste-compiler";
        version = "0.5.0.1";
-       sha256 = "14kqrkjhfxzg0gv4v2kzxh938085bmzg426vp2jrhzvf5dzypkh0";
+       sha256 = "00ceeb7f2b6e7f98a5b8db08f27e5d05013412ec7f8a4df603ef7707e5cc7892";
        configureFlags = [ "-fportable" ];
        isLibrary = true;
        isExecutable = true;
@@ -64800,7 +65012,7 @@ self: {
      mkDerivation {
        pname = "haste-markup";
        version = "0.0.1.0";
-       sha256 = "02rqm4qjaww2c622bqd1bb2mjb73w2s7d7pwvz94x03npxkf4hn1";
+       sha256 = "c142e266bf76804ed2dffc9e76b4e0e32c59c55aa1e125846182732531a9380b";
        libraryHaskellDepends = [
          base containers directory filepath haste-lib
        ];
@@ -64816,7 +65028,7 @@ self: {
      mkDerivation {
        pname = "haste-perch";
        version = "0.1.0.9";
-       sha256 = "1a92ahmphsr0dgj1jlp2cxpq5yy59b3avw3gzmv0jzrds41p3ic8";
+       sha256 = "88c57103d12d7f0976fd6ff0adc64ac5fb826f67e25219e46b206b782b5422a9";
        libraryHaskellDepends = [ base haste-compiler transformers ];
        homepage = "https://github.com/agocorona/haste-perch";
        description = "Create, navigate and modify the DOM tree with composable syntax, with the haste compiler";
@@ -64832,7 +65044,7 @@ self: {
      mkDerivation {
        pname = "hat";
        version = "2.9.0.0";
-       sha256 = "05sbgq1mliahdn4qj7flgw7klrm67r2mz7gxs03i6lx6mi3phm9f";
+       sha256 = "2e557847aca6531307d0fd9d5f453ea6663a0f7fd41d89896d50455a037e4b17";
        isLibrary = true;
        isExecutable = true;
        libraryHaskellDepends = [
@@ -64854,7 +65066,7 @@ self: {
      mkDerivation {
        pname = "hatex-guide";
        version = "1.3.1.0";
-       sha256 = "11wi053g9kybw0qa3wdfccyy0ka3xnnghgamaaf220r8hz49g25y";
+       sha256 = "be8897c8872803219c52553df8aced434de03d63aef1a130e0cbcff446019187";
        libraryHaskellDepends = [
          base blaze-html directory filepath HaTeX parsec text time
          transformers
@@ -64872,7 +65084,7 @@ self: {
      mkDerivation {
        pname = "hath";
        version = "0.2.3";
-       sha256 = "17ijsy0fmvaqq4ql7c2788kk3pi975pbi1g7ijh5fj0ybgxk5dww";
+       sha256 = "9cb732fb5b1e4857a08ce785b86e3929de31274247b04331c158edea80d7329e";
        isLibrary = false;
        isExecutable = true;
        executableHaskellDepends = [
@@ -64895,7 +65107,7 @@ self: {
      mkDerivation {
        pname = "hatt";
        version = "1.5.0.3";
-       sha256 = "0dgjia07v489wlk23hg84d1043rh71hl9yg7vdcih2jcj8pn00z4";
+       sha256 = "e403602f924c0a1859dbe7f9446138300f024223e8c12126e509917d808af235";
        isLibrary = true;
        isExecutable = true;
        libraryHaskellDepends = [
@@ -64918,7 +65130,7 @@ self: {
      mkDerivation {
        pname = "haverer";
        version = "0.3.0.0";
-       sha256 = "1p4llwjab7h2zg10585jp5a5bfrzmmkziq7in164wk15rb2z5y0p";
+       sha256 = "17f8f2c5ca254c4e4cb0f1e0f867ad3fbb5554b9b2a002c2fb029ea524a794dc";
        isLibrary = true;
        isExecutable = true;
        libraryHaskellDepends = [
@@ -64944,7 +65156,7 @@ self: {
      mkDerivation {
        pname = "hawitter";
        version = "0.4";
-       sha256 = "10qg24qkh17l9zqn47g64cg6hp48x7bjbcwigj35zpqcq71s9dxc";
+       sha256 = "acb7a4c3c10cdf5f867c91b325d7e9885c681e23e61d62f14ff4043831110f83";
        isLibrary = false;
        isExecutable = true;
        executableHaskellDepends = [
@@ -64966,7 +65178,7 @@ self: {
      mkDerivation {
        pname = "haxl";
        version = "0.2.0.0";
-       sha256 = "13nd291s04wyyx60cfs7x02dfpm4b9qn73h70c97gjq2s7l7y7qy";
+       sha256 = "1e1f7fe8d102cb771203078e63715aa45ed704e8473b064cf79e13a04312cd8e";
        libraryHaskellDepends = [
          aeson base bytestring containers directory filepath hashable HUnit
          pretty text time unordered-containers vector
@@ -64989,7 +65201,7 @@ self: {
      mkDerivation {
        pname = "haxl-facebook";
        version = "0.1.0.0";
-       sha256 = "0m8dycsh51sfrxhmajsaydgima4r0nc60yklv9w26302i176j2aq";
+       sha256 = "5809694e88020c2378da747a60980599a81a5ff34a4b5561cf4e870235f30d55";
        libraryHaskellDepends = [
          aeson async base conduit data-default fb hashable haxl
          http-client-tls http-conduit resourcet text time transformers
@@ -65013,7 +65225,7 @@ self: {
      mkDerivation {
        pname = "haxparse";
        version = "0.3.1.0";
-       sha256 = "12ksmhmk1yns8znh9srqm53q4by8dibdvkd9qhbihiwdyz137y6j";
+       sha256 = "d2f833c2f78d471817c4a9cddd566cc82f8247a938eb04ed47dafa302bac7a8a";
        isLibrary = true;
        isExecutable = true;
        libraryHaskellDepends = [
@@ -65041,7 +65253,7 @@ self: {
      mkDerivation {
        pname = "haxr";
        version = "3000.11.1.1";
-       sha256 = "0a4ad0h45a6jv1x19ss0p6krhq040164cvvaivf0zba5q4ifmffh";
+       sha256 = "d0b9ea22c145ad0fdc8e6a6f464c00046098a7b940eb147ad8d2a84220688a28";
        libraryHaskellDepends = [
          array base base-compat base64-bytestring blaze-builder bytestring
          HaXml HsOpenSSL http-streams http-types io-streams mtl mtl-compat
@@ -65058,7 +65270,7 @@ self: {
      mkDerivation {
        pname = "haxr-th";
        version = "3000.5";
-       sha256 = "1h1g4r7c5k3rja49ip4m21f2sscn06xjxharnlyazvvs6mzfysif";
+       sha256 = "2e6aef7e357aefaf3cb559c12ebb0196692d5c1095dc98889279ccc24e262fc0";
        libraryHaskellDepends = [ base haxr template-haskell ];
        jailbreak = true;
        homepage = "http://www.haskell.org/haxr/";
@@ -65073,7 +65285,7 @@ self: {
      mkDerivation {
        pname = "haxy";
        version = "1.0";
-       sha256 = "1fzdxk0vl7pd3k1dgxli6f721lfvwpb2zl354fl0zy5gimiky7fs";
+       sha256 = "da1d3f638daff80fa82365d02fd6e5dbd1208e3391f6d7c21ced1ebac1ecedbb";
        revision = "2";
        editedCabalFile = "1dfd6805d921438c33b5388de37716d320af9aff2d8067837f510d43c3cf5940";
        libraryHaskellDepends = [
@@ -65092,7 +65304,7 @@ self: {
      mkDerivation {
        pname = "hayland";
        version = "0.1.0.1";
-       sha256 = "0dpisbqfsay8lwpfihw5fmpzi2ajc8qshsawbr4r6x8indy4kdy0";
+       sha256 = "c0b7497cb3117593495e5c69a831625289f86f7585c3e82ea7c82bedf0d2f136";
        isLibrary = true;
        isExecutable = true;
        libraryHaskellDepends = [
@@ -65114,7 +65326,7 @@ self: {
      mkDerivation {
        pname = "hayoo-cli";
        version = "0.1.0.4";
-       sha256 = "05wfxpkpxma3ynla3wdgzq0raxqwg21fsa01qqpsh1ib7v462ls0";
+       sha256 = "405361c83e2b06a82fc60128ed82781c779501feaff1a1a8f543d57ee7ed8e17";
        isLibrary = false;
        isExecutable = true;
        executableHaskellDepends = [
@@ -65135,7 +65347,7 @@ self: {
      mkDerivation {
        pname = "hback";
        version = "0.0.3";
-       sha256 = "01wx4dls0ccl0q09hvydjhj0lfpqfd32z76rjgc89p5889czkm5j";
+       sha256 = "b2d4f95942a8dc84d893d99c2f4673f83a0a2494cd6f9800069431a069239d07";
        isLibrary = false;
        isExecutable = true;
        executableHaskellDepends = [
@@ -65156,7 +65368,7 @@ self: {
      mkDerivation {
        pname = "hbayes";
        version = "0.5";
-       sha256 = "1zhjhham5jyfwll8sp3kprp92l4whqfyys4jfl81gpb5igpgz039";
+       sha256 = "6980ffee8b65dd1710759268ef1d869c50916ebe735c8d28e5cecb52158412fe";
        libraryHaskellDepends = [
          array base binary boxes containers directory filepath gamma HUnit
          mtl mwc-random parsec pretty QuickCheck random split statistics
@@ -65175,7 +65387,7 @@ self: {
      mkDerivation {
        pname = "hbb";
        version = "0.4.0.2";
-       sha256 = "1whnsbv04b9hr3dc6a3xzv270q7ygk8x4i20mb092fr98klbk9wn";
+       sha256 = "96a7b9e844293b91c0aa4044d2d17cfe6070c4fe7d28c3dac8302d02f6d216f2";
        isLibrary = false;
        isExecutable = true;
        executableHaskellDepends = [
@@ -65192,7 +65404,7 @@ self: {
      mkDerivation {
        pname = "hbcd";
        version = "1.0";
-       sha256 = "1glld44m6h8yfh5h63w9q5isy238j0j312ycx43va1xa80x5r4dq";
+       sha256 = "b8915c3a40aa07b507e9cc8b3024906808af63c1890f030b741e4153096994be";
        libraryHaskellDepends = [ base bytestring Decimal digits split ];
        description = "Packed binary-coded decimal (BCD) serialization";
        license = stdenv.lib.licenses.mit;
@@ -65205,7 +65417,7 @@ self: {
      mkDerivation {
        pname = "hbeanstalk";
        version = "0.2.4";
-       sha256 = "13xcia1nnayhr22zi1wzgn8qs403ib4n2zikpxd3xnzy33yrgbzy";
+       sha256 = "feaf97fd18fedb3e5abf337e61c98a03108d917d9f87f885c8d02b6b838aac8f";
        libraryHaskellDepends = [
          attoparsec base blaze-builder bytestring containers network
        ];
@@ -65221,7 +65433,7 @@ self: {
      mkDerivation {
        pname = "hbeat";
        version = "0.1.2";
-       sha256 = "1lgsjwwpimvgczzgg2lvnf08hhcsnk5is52rm2lbmilky8ayhxjp";
+       sha256 = "5776e815f293c6baa8a859141dcbb49a418880b39b8af7fe676fd7783997fad1";
        isLibrary = false;
        isExecutable = true;
        executableHaskellDepends = [
@@ -65241,7 +65453,7 @@ self: {
      mkDerivation {
        pname = "hblas";
        version = "0.3.2.1";
-       sha256 = "05c2mqhwjq0r8jyaj0cncaxn4n5x27dd8z6lv8g8cdc7r749q59y";
+       sha256 = "3e159cc8c98735861edad47cd4da11bd5862bb629601a9bc441960c921ae8215";
        libraryHaskellDepends = [ base primitive storable-complex vector ];
        librarySystemDepends = [ blas lapack ];
        testHaskellDepends = [ base HUnit tasty tasty-hunit vector ];
@@ -65260,7 +65472,7 @@ self: {
      mkDerivation {
        pname = "hblock";
        version = "0.1.0.2";
-       sha256 = "0g8hj42ir3jcpmwf3pin2k4zdcf5p1f1sx1f8rj380qbyxgdrw3v";
+       sha256 = "7bf0dc5ef70b033464462e741d5cb8c5b1f6c91436dee178bd4c8e1c0591103d";
        libraryHaskellDepends = [
          aeson base blaze-markup bytestring cereal containers deepseq
          hashable path-pieces safecopy text unordered-containers uuid vector
@@ -65282,7 +65494,7 @@ self: {
      mkDerivation {
        pname = "hbro";
        version = "1.4.0.0";
-       sha256 = "08vw5j3a22gszbsjhjp13dkgvxj2875zjsx6w3w7c2dkjg4lijpr";
+       sha256 = "f9ca48c993b30976f8e0a66bf9cb4142f6fd661be14a28f5fafa09a1862c7c23";
        revision = "1";
        editedCabalFile = "331a844037ba6df7831151e45e40223eed66313dabef7dc0285a6e658747b15c";
        isLibrary = true;
@@ -65310,7 +65522,7 @@ self: {
      mkDerivation {
        pname = "hbro-contrib";
        version = "1.4.0.0";
-       sha256 = "0v7qxg1phac5m06raspaq6782iid7rnvkinkji0fs0yjigbblps2";
+       sha256 = "425fbad68bd203ed4094d3c6b96d3e2d46818ec1ea6a950da8852978c3ebf86c";
        libraryHaskellDepends = [
          aeson aeson-pretty base bytestring classy-prelude containers
          directory glib gtk3 hbro lens monad-control mtl network-uri pango
@@ -65328,7 +65540,7 @@ self: {
      mkDerivation {
        pname = "hburg";
        version = "1.1.2";
-       sha256 = "03gd0hgms5hmjvd1j533357h0gh7mh16vmlbbgdhzad1igq1lcfv";
+       sha256 = "db311af08ba1a90fdb5b8bd66d02ac073e004f19631419da9615165d1f04ed0d";
        isLibrary = false;
        isExecutable = true;
        executableHaskellDepends = [
@@ -65345,7 +65557,7 @@ self: {
      mkDerivation {
        pname = "hcc";
        version = "0.0.0";
-       sha256 = "04aczl9mh1gb25kggh2jj043az61gzzhxqfg9gb3lcjr5krrnh4p";
+       sha256 = "97409bf32c59323ad64bcfe10eff7fc17c35089052c0f76611eb055813fd4c11";
        isLibrary = false;
        isExecutable = true;
        executableHaskellDepends = [ base bytestring language-c ];
@@ -65360,7 +65572,7 @@ self: {
      mkDerivation {
        pname = "hcg-minus";
        version = "0.15";
-       sha256 = "04g0f4sr7904w3ynyl0gnbyi2sl0z7ziv5q15mfb6c7h0zl25d5r";
+       sha256 = "b9b422e807f030b35c2d01971dfff9806a11fdb20f506ffde004a4933571e011";
        libraryHaskellDepends = [ base colour ];
        homepage = "http://rd.slavepianos.org/t/hcg-minus";
        description = "haskell cg (minus)";
@@ -65374,7 +65586,7 @@ self: {
      mkDerivation {
        pname = "hcg-minus-cairo";
        version = "0.15";
-       sha256 = "002gh8adqzhcjfnqkbcnpzz8qiqbj9zkbk6jj11dnnxjigc4l2q9";
+       sha256 = "090b4ad88bb25bdb4290d2cc357f920b478cfebf96ad89ad930c7edc14824f00";
        libraryHaskellDepends = [
          base cairo colour filepath hcg-minus utf8-string
        ];
@@ -65388,7 +65600,7 @@ self: {
      mkDerivation {
        pname = "hcheat";
        version = "2010.1.16";
-       sha256 = "1fwgnp15kha9qb7iagd8n5ahjjhg194wbva5i436mb57fn86pya2";
+       sha256 = "42f96b9075a7ac6a068945edc5490a0f4a0955b1a83d15cfc249c159c2b58fbb";
        libraryHaskellDepends = [ base mps ];
        homepage = "http://github.com/nfjinjing/hcheat/";
        description = "A collection of code cheatsheet";
@@ -65403,7 +65615,7 @@ self: {
      mkDerivation {
        pname = "hchesslib";
        version = "0.1.0.0";
-       sha256 = "10785d9n87ddln1rvr19wnvcj401x3b53psdcf8vrwfaq930kjrv";
+       sha256 = "3bcb0946c2caf1bc91634ddf51d6e80110c9b6e529e49d83a5ad1d64532be880";
        libraryHaskellDepends = [ array attoparsec base containers text ];
        testHaskellDepends = [
          array attoparsec base containers hlint hspec QuickCheck text
@@ -65423,7 +65635,7 @@ self: {
      mkDerivation {
        pname = "hcltest";
        version = "0.3.7";
-       sha256 = "1hqx0khbxypq4hqq1hq0ybyadd7m6bpd6rzc3zya3w0s7kwk0dgd";
+       sha256 = "ed3530f93c1af0a1fc1fec67d3ee32f5b4a6fcf200c3803124f8fabee0041dc3";
        libraryHaskellDepends = [
          base bytestring directory dlist either filepath free lens mmorph
          monad-control mtl optparse-applicative process random-shuffle split
@@ -65443,7 +65655,7 @@ self: {
      mkDerivation {
        pname = "hcron";
        version = "0.0.0.3";
-       sha256 = "0ckq98aj6fgdgpwyy6ssydp4jazhhfshnalv71h2xx1z80m1ynq7";
+       sha256 = "075b1f2a403ff42e60389b2a0bb583f02b496ef35a1beff97ded3923154a7832";
        libraryHaskellDepends = [
          base bytestring containers directory mtl old-locale pretty process
          random stm time
@@ -65461,7 +65673,7 @@ self: {
      mkDerivation {
        pname = "hcube";
        version = "0.1.1";
-       sha256 = "1h1g05a8wnk2q65mm4mwywxhygr7fs0150q8ml33ik59mcc5v7fr";
+       sha256 = "d99d5d18aba9cc3806ad0883128076273f0f3bf7bc925a8bc1625a8e54012fc0";
        isLibrary = true;
        isExecutable = true;
        libraryHaskellDepends = [
@@ -65480,7 +65692,7 @@ self: {
      mkDerivation {
        pname = "hcwiid";
        version = "0.0.5";
-       sha256 = "0dn19kkd1da9yk6yk8mmpz927d1gsjyip9v4dibsvc1w4v49n94x";
+       sha256 = "9d249bc8263cb0ad576c64a71bbdd42fb423d2bfb5a2e9cdf449b5d0e64cc136";
        libraryHaskellDepends = [ base unix ];
        librarySystemDepends = [ bluetooth cwiid ];
        homepage = "https://github.com/ivanperez-keera/hcwiid";
@@ -65496,7 +65708,7 @@ self: {
      mkDerivation {
        pname = "hdaemonize";
        version = "0.5.0.1";
-       sha256 = "03daf8qb8x0503h5k2vr6r4lyv6fv1a5n6mhykx5872khl81d8ms";
+       sha256 = "baa2161085531c54faf4b01a5b54d8ce6c4f4936798b59e0000574b43072aa0d";
        libraryHaskellDepends = [
          base extensible-exceptions filepath hsyslog mtl unix
        ];
@@ -65512,7 +65724,7 @@ self: {
      mkDerivation {
        pname = "hdaemonize-buildfix";
        version = "0.4.5";
-       sha256 = "15k4z77caa5y1jix4llqdmqpx0j7iv9nx5lk3vc5hs8vl2ax86f6";
+       sha256 = "c619d495a01b6958d81e93966ed38e47827e716d9852d2a30cbe28c5cef96496";
        libraryHaskellDepends = [
          base extensible-exceptions filepath hsyslog mtl unix
        ];
@@ -65529,7 +65741,7 @@ self: {
      mkDerivation {
        pname = "hdbc-aeson";
        version = "0.1.3.2";
-       sha256 = "04bp1zxw5alazk241gbz7g1s4cr0gabb7c15irzzlkbjz5jsk6d5";
+       sha256 = "a599a965f9724dfa7f8e25b0b3967a2033a2c33b7fbd40c4fc8aaac2fb0f7711";
        libraryHaskellDepends = [
          aeson base convertible HDBC scientific text unordered-containers
          vector
@@ -65545,7 +65757,7 @@ self: {
      mkDerivation {
        pname = "hdbc-postgresql-hstore";
        version = "0.0.1.1";
-       sha256 = "034zsmqgavh4ns69f6j4a1afyqbd1b7h35macmf20vzxj0j0bawj";
+       sha256 = "92ab052490fd6f205c65aa9601cf0a6d61ef5450441a978cb6046ef570d59f0c";
        libraryHaskellDepends = [ attoparsec base containers HDBC text ];
        jailbreak = true;
        homepage = "http://bitbucket.com/dpwiz/hdbc-postgresql-hstore";
@@ -65558,7 +65770,7 @@ self: {
      mkDerivation {
        pname = "hdbc-tuple";
        version = "0.0.1";
-       sha256 = "155darl83c1b3gjkh7x8pwpj6v4nqfb389ix9vr39j7qw1pkjwdd";
+       sha256 = "ad71396fe0f8c834f24e3d263496c3966c232fbfa81f38e51b2bb0816856ad94";
        libraryHaskellDepends = [ base convertible HDBC typical ];
        description = "Type save tuples for HDBC";
        license = "GPL";
@@ -65575,7 +65787,7 @@ self: {
      mkDerivation {
        pname = "hdbi";
        version = "1.3.0";
-       sha256 = "0z8ivqs79lkqr2bji6nc5djd29ajag5r7d7caja482ksfq75wdc2";
+       sha256 = "82355e0e767a0a449454ecb493cb535225d1642bcc9a2897c878d27434de117d";
        libraryHaskellDepends = [
          attoparsec base blaze-builder bytestring containers Decimal deepseq
          old-locale stm template-haskell text time uuid
@@ -65602,7 +65814,7 @@ self: {
      mkDerivation {
        pname = "hdbi-conduit";
        version = "1.3.0";
-       sha256 = "1wrc38m8451vslvnmd4p128x9885dbjx5hzc566s06dw8wshfdgj";
+       sha256 = "f235073547bc19a08d29ecc3d2e56a05a1d4910897b46a37d53b14822a1a2cf3";
        libraryHaskellDepends = [
          base conduit hdbi resourcet transformers
        ];
@@ -65627,7 +65839,7 @@ self: {
      mkDerivation {
        pname = "hdbi-postgresql";
        version = "1.3.0";
-       sha256 = "1fjcp3ldc54bm8gj8l9ifjvdxx6h6lsswjspmwnzwfh1ahfrbg1x";
+       sha256 = "3dbc951d54013afe2daf574bae3535d0f4deb6743151241faa8b14d6e8b84cba";
        libraryHaskellDepends = [
          attoparsec base blaze-builder bytestring hdbi mtl old-locale
          postgresql-libpq postgresql-simple safe text time uuid
@@ -65653,7 +65865,7 @@ self: {
      mkDerivation {
        pname = "hdbi-sqlite";
        version = "1.3.0";
-       sha256 = "03vf5xv14hb6rwwaiv997a7j3s5rgp81cb60v0n013l20dqh1g04";
+       sha256 = "04bc007103828e002cd8c02c16d07db9e8218f3a29eda838cf664112762f6e0f";
        libraryHaskellDepends = [
          base blaze-builder bytestring direct-sqlite hdbi text
        ];
@@ -65676,7 +65888,7 @@ self: {
      mkDerivation {
        pname = "hdbi-tests";
        version = "1.3.0";
-       sha256 = "0rvrjcv890flsmq8v6bpgh8kvg0ix3x2n149kdg7xviy26liyjg5";
+       sha256 = "e5491fa9113eee7e5e9b89042bfae811bc3d117c77998d70d5d4818436937967";
        libraryHaskellDepends = [
          base bytestring containers Decimal hdbi HUnit ieee754 QuickCheck
          quickcheck-assertions quickcheck-instances stm test-framework
@@ -65696,7 +65908,7 @@ self: {
      mkDerivation {
        pname = "hdevtools";
        version = "0.1.1.9";
-       sha256 = "0cwgm4yws4irrrpk2jvgvgr74w7gn9ilcidb9flkxfh7kqwsjxac";
+       sha256 = "4c75a9399e07ba3ea94bab454663b2ef7072f2db6f4b316fce3912cd3da98f33";
        isLibrary = false;
        isExecutable = true;
        executableHaskellDepends = [
@@ -65715,7 +65927,7 @@ self: {
      mkDerivation {
        pname = "hdf";
        version = "0.15";
-       sha256 = "11nf9wlymdhydf0bhh9gdl0cdn0i4mbvx3hfdcmnxfvag5jmfbkk";
+       sha256 = "732e5765796abb6e2b6b0e8ebe572511d8c6006d2f41b8806b1eb6ea294fce86";
        libraryHaskellDepends = [
          base directory fgl fgl-visualize filepath hosc hsc3 murmur-hash
          process split transformers
@@ -65731,7 +65943,7 @@ self: {
      mkDerivation {
        pname = "hdigest";
        version = "1.0";
-       sha256 = "1wm9j8ncjfb0gscdz4zmkymrzykc6rqbcx7988r207l5s9q3043f";
+       sha256 = "6e103070d2851e203242e974b670366cfa9fab9ff593df987e6039c92c92a9f2";
        libraryHaskellDepends = [
          base cgi Crypto network parsec random time
        ];
@@ -65745,7 +65957,7 @@ self: {
      mkDerivation {
        pname = "hdirect";
        version = "0.21.0";
-       sha256 = "1v7yx9k0kib6527k49hf3s4jvdda7a0wgv09qhyjk6lyriyi3ny2";
+       sha256 = "c2db117dcc9e9a293dc409ecc7813aaab52d891e0e26328f2866c50966eafeec";
        isLibrary = true;
        isExecutable = true;
        libraryHaskellDepends = [ array base haskell98 pretty ];
@@ -65763,7 +65975,7 @@ self: {
      mkDerivation {
        pname = "hdis86";
        version = "0.2";
-       sha256 = "0qr8d4qbvkncv4im0iwwdr9khvkyy4ky8wnwxri1jqhylcq8vdks";
+       sha256 = "7ab68d30a31e621962eedc72e427f17e6e38536e9c475023d9cccebd30692863";
        libraryHaskellDepends = [ base bytestring containers QuickCheck ];
        homepage = "https://github.com/kmcallister/hdis86";
        description = "Interface to the udis86 disassembler for x86 and x86-64 / AMD64";
@@ -65776,7 +65988,7 @@ self: {
      mkDerivation {
        pname = "hdiscount";
        version = "0.1.0.0";
-       sha256 = "0z6kpsk57gjqwpvs5v6ikiirnyyg26mbrxx827bb1v27lhsy7py0";
+       sha256 = "c0dfe335a447ecb0d611a8f7bcaa11cf7b9b639cd1eca2f7e558be53a6bed37c";
        libraryHaskellDepends = [ base bytestring ];
        librarySystemDepends = [ markdown ];
        jailbreak = true;
@@ -65791,7 +66003,7 @@ self: {
      mkDerivation {
        pname = "hdm";
        version = "0.0.1";
-       sha256 = "1qgq4bwq2ip315j43f0pyhxah033bjrj3wrmvnzmc62s8k2rfvgh";
+       sha256 = "f06d97c5445a1856bfdd35f321b35c6300a83af417b8416409e34681f922f8e1";
        isLibrary = false;
        isExecutable = true;
        executableHaskellDepends = [ base directory process unix vty ];
@@ -65809,7 +66021,7 @@ self: {
      mkDerivation {
        pname = "hdocs";
        version = "0.4.4.0";
-       sha256 = "153rwd1f390j6sjfxx135h3bh80pb8zb5myws9q8d0jkrx2sl198";
+       sha256 = "2805aa45cf53828670d2dcd7b23e5a1720b8062c23f4eea43612a4e142e37994";
        isLibrary = true;
        isExecutable = true;
        libraryHaskellDepends = [
@@ -65836,7 +66048,7 @@ self: {
      mkDerivation {
        pname = "hdph";
        version = "0.0.1";
-       sha256 = "116499cr0pcc1gg7aniprlcp9vp8s61b4vk7rcm673nw3lay496a";
+       sha256 = "ca24e2151ddc8e632acb676eb282d1e8ee7419cd375a75de0b8c5d90594ac484";
        isLibrary = true;
        isExecutable = true;
        libraryHaskellDepends = [
@@ -65863,7 +66075,7 @@ self: {
      mkDerivation {
        pname = "hdph-closure";
        version = "0.0.1";
-       sha256 = "0rcmp5i7jvpghg8nql5wlidbyjs79cxxmdb6bq3xxk806gdj66d8";
+       sha256 = "a81923db3300cdde075e66b5da3b4b474bbf5aa4bc506cd183ef6e7962b99565";
        libraryHaskellDepends = [
          array base bytestring cereal containers deepseq template-haskell
        ];
@@ -65881,7 +66093,7 @@ self: {
      mkDerivation {
        pname = "headergen";
        version = "0.2.0.0";
-       sha256 = "1hc1pmbj9452k4a71iiazxg6id7caf783m08lqnf3flf77cdjxpa";
+       sha256 = "ea76d9d8398ebae12ca608d4818e53ecb4685eff2ac6701499a2902457bd81c1";
        isLibrary = false;
        isExecutable = true;
        executableHaskellDepends = [
@@ -65898,7 +66110,7 @@ self: {
      mkDerivation {
        pname = "heap";
        version = "1.0.2";
-       sha256 = "1xwgdx4m558m2xqmqnskkbja9s1lqm131xphjgk0yclsk0sv8was";
+       sha256 = "5a71b435989a320fe693f0f63042c534e8a4e49a535b5c7117159552496f8ff7";
        isLibrary = true;
        isExecutable = true;
        libraryHaskellDepends = [ base ];
@@ -65912,7 +66124,7 @@ self: {
      mkDerivation {
        pname = "heaps";
        version = "0.3.2.1";
-       sha256 = "1g4nf361qfjyymwpyiiq0qk5brrsr4wz1pncij69pwda919b3j6b";
+       sha256 = "cbc8b15248aaf19b8c8cccdef039c93ae755260638467f79f55e3a1ccc7096bc";
        libraryHaskellDepends = [ base ];
        testHaskellDepends = [ base directory doctest filepath ];
        jailbreak = true;
@@ -65926,7 +66138,7 @@ self: {
      mkDerivation {
        pname = "heapsort";
        version = "0.1.0";
-       sha256 = "0fzws9fjhqsygsbwj7nvj786j16264vqvqzc97dr73y72538k9qa";
+       sha256 = "0aa7894611c78f93db49ece38d3731c20469d091db1ec9977e5e63285dd2fc3b";
        isLibrary = true;
        isExecutable = true;
        executableHaskellDepends = [ array base QuickCheck ];
@@ -65942,7 +66154,7 @@ self: {
      mkDerivation {
        pname = "hebrew-time";
        version = "0.1.1";
-       sha256 = "0ckridxf4rvhhp0k1mckbbbpzfs32l4mwg7n9mrmsggldpl7x6f7";
+       sha256 = "c7997ee86df43d5d734df63c5e091543bb7fd75a93d530c1857067e27a8b7932";
        libraryHaskellDepends = [ base time ];
        testHaskellDepends = [
          base HUnit QuickCheck test-framework test-framework-hunit
@@ -65958,7 +66170,7 @@ self: {
      mkDerivation {
        pname = "hecc";
        version = "0.4.1.1";
-       sha256 = "1p7h9mlap8i0w2inhq944r0dgr27rzwk44igylil7gv0dgf4hsyx";
+       sha256 = "dd6b48dc6b60bf4323f52f1232f9cf47e4d74026246168a3e020a2ab684df0dc";
        libraryHaskellDepends = [ base cereal crypto-api hF2 ];
        description = "Elliptic Curve Cryptography for Haskell";
        license = stdenv.lib.licenses.bsd3;
@@ -65973,7 +66185,7 @@ self: {
      mkDerivation {
        pname = "hedis";
        version = "0.6.9";
-       sha256 = "0yciwxsnqc8d09356fisfb44nbzsnvi01aad86gbx4vhrdnw7n7a";
+       sha256 = "ead8c36dcb7093be9e414da900e2b6fa2f4bc8723a3a5346020d316c75e79179";
        libraryHaskellDepends = [
          attoparsec base BoundedChan bytestring bytestring-lexing mtl
          network resource-pool time vector
@@ -65991,7 +66203,7 @@ self: {
      mkDerivation {
        pname = "hedis-config";
        version = "0.0.2";
-       sha256 = "1ism20ddgcdsypbic6ikalvajq3918wm53ppiic68zaqfzwk9gk2";
+       sha256 = "62be34f977587d64588cf78e52390a6960a93655331a16d7f5bab1d71a1055c7";
        libraryHaskellDepends = [ aeson base hedis scientific text time ];
        homepage = "https://bitbucket.org/s9gf4ult/hedis-config";
        description = "Easy trivial configuration for Redis";
@@ -66005,7 +66217,7 @@ self: {
      mkDerivation {
        pname = "hedis-monadic";
        version = "0.0.4";
-       sha256 = "1540c4ra65y2kc97n7wxx7rdzf3dkaqqx7r4lwz4qpg3kzfi6q8w";
+       sha256 = "1c6113dd9fe35d4c3ea7249f8eb19a6db8dff2e99d1f7b129bc217a332618094";
        libraryHaskellDepends = [
          base hedis monad-control mtl transformers transformers-base
          transformers-compat
@@ -66023,7 +66235,7 @@ self: {
      mkDerivation {
        pname = "hedis-pile";
        version = "0.6.3";
-       sha256 = "0awwga4hvmfkkkqy68g4ja51szjifs1z20rav0kmbn3gn978248n";
+       sha256 = "1611814eb26fd85527d82a03f18376517e1d8a92e421e3f19cd3d50d897a9c2b";
        libraryHaskellDepends = [
          base binary bytestring hedis hedis-tags string-conversions
          transformers
@@ -66043,7 +66255,7 @@ self: {
      mkDerivation {
        pname = "hedis-simple";
        version = "0.1.0.0";
-       sha256 = "1dq7rpqg35caqj664q2ndqgd59mq7cfjahkaka5mlk1k5yjvz7av";
+       sha256 = "5b9dbfa52f334c5a8b9a6a42251d3bb8a6d21e6e5660628cc48a95f1f0cd07b7";
        libraryHaskellDepends = [ base bytestring either hedis mtl ];
        jailbreak = true;
        homepage = "http://github.com/sanetracker/hedis-simple";
@@ -66058,7 +66270,7 @@ self: {
      mkDerivation {
        pname = "hedis-tags";
        version = "0.2.3";
-       sha256 = "0d9jr26366xjjcc39ma36bs944d11xpw5izww9pw3lajsgdr0d1s";
+       sha256 = "3a3490dbd352d1c16fe2fcc7c26f0fa11192f43243d5341893b21b338cc83235";
        libraryHaskellDepends = [ base bytestring hedis ];
        testHaskellDepends = [
          base bytestring hedis HUnit lifted-base test-framework
@@ -66078,7 +66290,7 @@ self: {
      mkDerivation {
        pname = "hedn";
        version = "0.1.8.1";
-       sha256 = "12r7ndjq59q9pdnhziq7af4jkp2mgpq7qhnnzgv6w1z8v893b9r1";
+       sha256 = "21a73512dae8076ef6fbd6427cf07d55dc29895307c70f6dbb09a78265b3278b";
        libraryHaskellDepends = [
          attoparsec base bytestring containers deepseq mtl old-locale
          stringsearch text time utf8-string vector
@@ -66101,7 +66313,7 @@ self: {
      mkDerivation {
        pname = "hein";
        version = "0.1.0.5";
-       sha256 = "0z3c9pvhnfx9zizzwkyawvzvs4zl7i5w5zkrjpax8rkrh8ai1060";
+       sha256 = "c0801015827966d4d59579fec24b3cf413bdffe6ca4ffe7ffca93b0bf74d6c7c";
        isLibrary = false;
        isExecutable = true;
        executableHaskellDepends = [
@@ -66123,7 +66335,7 @@ self: {
      mkDerivation {
        pname = "heist";
        version = "0.14.1.1";
-       sha256 = "0hwf8d20lw4gn5mal8iqd62npr2859541h3md451hjlbwpjyqd19";
+       sha256 = "2934ece5e58b4a180a6975c0404a2a48e46b85693822aa6ab18f700a44438e43";
        revision = "1";
        editedCabalFile = "51f2aa86d7582ba504e26ead511da54db5350cf4bed7f13252c678c0cf19d400";
        libraryHaskellDepends = [
@@ -66144,7 +66356,7 @@ self: {
      mkDerivation {
        pname = "heist-aeson";
        version = "0.5";
-       sha256 = "1m0rwrb0gzsajnp5h0w7cf10jf6fram4mjkmny5hk0h5xwcn19dc";
+       sha256 = "aca56019ef0582098bb775ca4aaacace38098263870358ae954aff0756e619d4";
        libraryHaskellDepends = [
          aeson base blaze-builder bytestring containers heist monads-fd text
          vector xmlhtml
@@ -66159,7 +66371,7 @@ self: {
      mkDerivation {
        pname = "heist-async";
        version = "0.6.0.0";
-       sha256 = "16ab3cfs6fj66ssf6ypmx2yddq5an115wlmwybk3va0a7kbp58ll";
+       sha256 = "94a272d73c0aa83de6f2bc525e42b0aae0d6bce8f57ae3b436463aa31d1b4b99";
        libraryHaskellDepends = [
          base heist template-haskell text xmlhtml
        ];
@@ -66176,7 +66388,7 @@ self: {
      mkDerivation {
        pname = "helics";
        version = "0.5.1";
-       sha256 = "06kj42rmlzlw6zrilq9kc5whk0np5714wwn3nwbpv6fx4ginzg2c";
+       sha256 = "4cbc6fe323dd997d17b7c3724ec229d78209796133611af3379c7e5ab320721a";
        revision = "1";
        editedCabalFile = "698732187d22f634ca220584e3b4056415c873360a85bc0a4ab7c1e2c86fca3d";
        isLibrary = true;
@@ -66201,7 +66413,7 @@ self: {
      mkDerivation {
        pname = "helics-wai";
        version = "0.5.1";
-       sha256 = "10rb9l4sf31h59f5pwv54vqjnlm047mbq5gvhv5wblkh53ch1b31";
+       sha256 = "61ac00d92870d2c5cb86fb15bcea21a0522bf12665f35b5c2a300ca7094d2b83";
        isLibrary = true;
        isExecutable = true;
        libraryHaskellDepends = [
@@ -66218,7 +66430,7 @@ self: {
      mkDerivation {
        pname = "helisp";
        version = "0.1";
-       sha256 = "1j495j3kc43d34aviln6jrab3ydzsp1hrnk079p53mcnx2rpjz81";
+       sha256 = "017d79b3e896d5516e3a60da0cc3d5bff9b15496c6d2b815196d1036872c89c8";
        isLibrary = false;
        isExecutable = true;
        executableHaskellDepends = [ base containers mtl parsec process ];
@@ -66234,7 +66446,7 @@ self: {
      mkDerivation {
        pname = "helium";
        version = "1.8.1";
-       sha256 = "0vwk8h5fwl63pjcydwndqgpikfjdm37w7gjmmgac95gl66fc5h5j";
+       sha256 = "b2c0c29c31f495c4d4ab55bec3cfa84dba19efc3cdf2e699bcc350ee0a44936f";
        isLibrary = true;
        isExecutable = true;
        libraryHaskellDepends = [
@@ -66261,7 +66473,7 @@ self: {
      mkDerivation {
        pname = "hell";
        version = "2.1";
-       sha256 = "1kdxkk994g38bl2kcxcs0p9wn1rankn0jw14nlvy9z9appgxalnl";
+       sha256 = "d452d5dfbd2afde437b5247009ecb42a07cbd3059a7536055d683c92d29cbdcd";
        isLibrary = true;
        isExecutable = true;
        libraryHaskellDepends = [
@@ -66284,7 +66496,7 @@ self: {
      mkDerivation {
        pname = "hellage";
        version = "0.1.1";
-       sha256 = "1gqz042qycwhka6fyma6fb104mi8wd22nsbywrini3m3nib5ci75";
+       sha256 = "e5445656b4a38e6863e67e692b44e3285602c2724655ef8c9a90338f05011fbf";
        isLibrary = false;
        isExecutable = true;
        executableHaskellDepends = [
@@ -66306,7 +66518,7 @@ self: {
      mkDerivation {
        pname = "hellnet";
        version = "0.1.1";
-       sha256 = "0fb4r9nb39l1qr7xczgkx5i93cv4rqrin0fl22qq4h12ajvrp6m6";
+       sha256 = "a69a9bb754224082b110d4011b33ce64b39162e9f37dd64fc681a6b16cca6439";
        isLibrary = true;
        isExecutable = true;
        libraryHaskellDepends = [
@@ -66328,7 +66540,7 @@ self: {
      mkDerivation {
        pname = "hello";
        version = "1.0.0.2";
-       sha256 = "1x6q7frbrc4jdfx1qhxrydmdp5k7mm3lx504d7rhg6z2m6ibbh57";
+       sha256 = "a7c0b5a2a9e29b07f36904944e47ad6796db6af3b9431cba6b92b0bcb23bd8f4";
        isLibrary = false;
        isExecutable = true;
        executableHaskellDepends = [ base ];
@@ -66346,7 +66558,7 @@ self: {
      mkDerivation {
        pname = "helm";
        version = "0.7.1";
-       sha256 = "04smx6q2k4zj4gjvwy393s4abik9k108c5j31yy3dwksbbhhmygg";
+       sha256 = "eff90ae15a7af236bc0f431686409869c6a5881e6978bee523f29329b0e95513";
        libraryHaskellDepends = [
          base cairo containers cpu elerea filepath mtl pango random sdl2
          text time transformers
@@ -66369,7 +66581,7 @@ self: {
      mkDerivation {
        pname = "help-esb";
        version = "0.1.6";
-       sha256 = "0fy0dygx3hdkbdip7gppk25akjar0p2px0s5q7sl1lmzgkcl1016";
+       sha256 = "268040d97cbfd240f5c145837ec50559c9a98a98f7be73635bb3c1d19f6fc03b";
        libraryHaskellDepends = [
          aeson base bytestring containers MissingH network network-uri text
          uuid
@@ -66386,7 +66598,7 @@ self: {
      mkDerivation {
        pname = "hemkay";
        version = "0.2.0";
-       sha256 = "16f1nzpi20j7fza1rs1b89mhyni4162q2x4l3ixrnd82yjmcmc1l";
+       sha256 = "34b0caaaf402359b7b1c9474818509245a0f6b422be81cd477470211efb7c199";
        isLibrary = false;
        isExecutable = true;
        executableHaskellDepends = [
@@ -66402,7 +66614,7 @@ self: {
      mkDerivation {
        pname = "hemkay-core";
        version = "0.1.4";
-       sha256 = "0br41879jynw3dzb2hlb07m55zmzgyim6gi8i48bzimbi70c9z89";
+       sha256 = "09fdc4c089abc6bf1089283e53a37fbffe52ea018b42b17e1bdc7a990e0a242f";
        libraryHaskellDepends = [ array base binary bytestring ];
        description = "A device independent module music mixer";
        license = stdenv.lib.licenses.bsd3;
@@ -66418,7 +66630,7 @@ self: {
      mkDerivation {
        pname = "hemokit";
        version = "0.6.5";
-       sha256 = "104387q98qfhykmjkyhg08rji8pljlllp2j57ilhpb7ws9ik2g26";
+       sha256 = "463c3163d2fcac0b693c458a4b2995f4a22833020ffa29ebf4d06194f0418380";
        isLibrary = true;
        isExecutable = true;
        libraryHaskellDepends = [
@@ -66446,7 +66658,7 @@ self: {
      mkDerivation {
        pname = "hen";
        version = "0.1.3";
-       sha256 = "1ri6brxmc2m09jx2r9p47lgpfn8zkxy147hyyw3x2pw3g6cgsill";
+       sha256 = "9446fd9879835fd107f71e1e127c9f1f59771f3de4a62cba4ca00a567b5e26e6";
        libraryHaskellDepends = [
          base bitset exceptions mtl transformers uuid
        ];
@@ -66468,7 +66680,7 @@ self: {
      mkDerivation {
        pname = "henet";
        version = "1.3.9.3";
-       sha256 = "0pm5lnn7rc647ic404c8bmki9wfrkc0mdmmkng50vv0bm2d7z5aq";
+       sha256 = "58957f9aa80bec0dcab3b3d656019bd9f114675d881140583cc4b07caca5a55e";
        libraryHaskellDepends = [
          base bitset bytestring network typesafe-endian
        ];
@@ -66482,7 +66694,7 @@ self: {
      mkDerivation {
        pname = "hepevt";
        version = "0.5";
-       sha256 = "0b7syzfzbcznjb98hi4k8bp46ss08s9qg2763bnnm1b10i7km23z";
+       sha256 = "7f883a4f0461856aed1ae688879346406b43ee42934488d292f6b3f5ddf7fa2c";
        libraryHaskellDepends = [ bytestring haskell2010 lha ];
        description = "HEPEVT parser";
        license = stdenv.lib.licenses.mit;
@@ -66494,7 +66706,7 @@ self: {
      mkDerivation {
        pname = "her-lexer";
        version = "0.1.1";
-       sha256 = "1hbx48r8zdmyr5qjf0b3pagmamj8pibsp7ca7bxdgk4jz8pxv2my";
+       sha256 = "be8add2ffa92ccd7fa3a8a9dab57bc4856559fba63012771c9beb68f32227dc1";
        libraryHaskellDepends = [ base mtl split ];
        homepage = "http://personal.cis.strath.ac.uk/~conor/pub/she";
        description = "A lexer for Haskell source code";
@@ -66507,7 +66719,7 @@ self: {
      mkDerivation {
        pname = "her-lexer-parsec";
        version = "0.0.0";
-       sha256 = "1gkcd9ikaxjirxh8haq8b9a372n1dlaq63n9xzq9gsyazkxz7lgn";
+       sha256 = "f6d1f3fbfccaeb97f0efc90e83156dc18a33545a082b8860cf517635636a6cbe";
        libraryHaskellDepends = [ base her-lexer parsec transformers ];
        description = "Parsec frontend to \"her-lexer\" for Haskell source code";
        license = stdenv.lib.licenses.publicDomain;
@@ -66521,7 +66733,7 @@ self: {
      mkDerivation {
        pname = "herbalizer";
        version = "0.4.9";
-       sha256 = "1gm1ya1p1i734sxadbmj1zn6mbq1gssmzp897h5xjgb8vsa2fxs6";
+       sha256 = "46772794de683dd90b3c09dd5fb57e01af6aec0fb2aea6ba26e3c47083f2a1be";
        isLibrary = false;
        isExecutable = true;
        executableHaskellDepends = [
@@ -66540,7 +66752,7 @@ self: {
      mkDerivation {
        pname = "here";
        version = "1.2.7";
-       sha256 = "1fqjqzfg3fif67ic75pavsnfjb9lxk5cf82chxs2hrkx41gm4gr6";
+       sha256 = "263f525f207d662874874c20c7caec342de9acdeea96c3e2312ebaf1dcc712bb";
        libraryHaskellDepends = [
          base haskell-src-meta mtl parsec template-haskell
        ];
@@ -66554,7 +66766,7 @@ self: {
      mkDerivation {
        pname = "heredoc";
        version = "0.2.0.0";
-       sha256 = "0h0g2f7yscwl1ba1yn3jnz2drvd6ns9m910hwlmq3kdq3k39y3f9";
+       sha256 = "c90d9fc61cb8cd812be510845493b6a6eddcc4b772581fd40a9433ed8f130f40";
        libraryHaskellDepends = [ base template-haskell ];
        homepage = "http://hackage.haskell.org/package/heredoc";
        description = "multi-line string / here document using QuasiQuotes";
@@ -66570,7 +66782,7 @@ self: {
      mkDerivation {
        pname = "hermit";
        version = "1.0.0.0";
-       sha256 = "1m3dgp22ix3l64basv8bx0k9waagi0rckprpgqnfpxnir7cbhrkv";
+       sha256 = "7b66b8d8c9d1f6eb2c7e37dfc932884f299e26e80b6dad163174f428c47d6dd4";
        isLibrary = true;
        isExecutable = true;
        libraryHaskellDepends = [
@@ -66592,7 +66804,7 @@ self: {
      mkDerivation {
        pname = "hermit-syb";
        version = "0.1.0.0";
-       sha256 = "1970n7q88q76dnp2h7h8r1d6psq0d9pdvrim556rqiv8smwi661x";
+       sha256 = "3d181379d568479c4d2935e6dd6e6a00eb6b5ac8081e28ae6de66084f0b1e0a4";
        libraryHaskellDepends = [
          base containers ghc ghc-prim hermit syb template-haskell
        ];
@@ -66606,7 +66818,7 @@ self: {
      mkDerivation {
        pname = "heroku";
        version = "0.1.2.3";
-       sha256 = "1gldsdpnmj7ljrmyvjfwqdmhhml2yp27icl2qqj9pz42pllq4x2k";
+       sha256 = "53748229bd82fc9b24c682b278c4f58256086bc3dcc9ed6b96f4c86a6fd38dbe";
        libraryHaskellDepends = [ base network-uri text ];
        testHaskellDepends = [ base hspec network-uri text ];
        homepage = "https://github.com/gregwebs/haskell-heroku";
@@ -66621,7 +66833,7 @@ self: {
      mkDerivation {
        pname = "heroku-persistent";
        version = "0.1.0";
-       sha256 = "1ws4076dk4a8l2yz9mwfwqk57sm7y2ch2c5318agsm7hnwil7wbf";
+       sha256 = "6ef14323b7f054fd140aa3300199f0a7ea5326e68ed7f4bda04891d9cc0144f3";
        libraryHaskellDepends = [
          base bytestring heroku persistent-postgresql text
        ];
@@ -66639,7 +66851,7 @@ self: {
      mkDerivation {
        pname = "herringbone";
        version = "0.1.1";
-       sha256 = "1xpdz24dinm56z4gx51frw19j2169ms9jvasg8xixi944q34hwmk";
+       sha256 = "b37248062624c51e3b7a5a6d99744d26089902cf2e94fec837a5dad888f8edf6";
        libraryHaskellDepends = [
          base bytestring containers directory http-types mtl old-locale
          process process-listlike system-fileio system-filepath text time
@@ -66657,7 +66869,7 @@ self: {
      mkDerivation {
        pname = "herringbone-embed";
        version = "0.1.1";
-       sha256 = "02i0k29fg0nb4ax0yaw6bnrnb0v0rk2fy7lckd5f5bny557mk1h6";
+       sha256 = "0686594f29deaee24a9b8c1eefc4cc608365b35d862b0fba22cb82e79298200a";
        libraryHaskellDepends = [
          base bytestring file-embed herringbone system-fileio
          system-filepath template-haskell text
@@ -66674,7 +66886,7 @@ self: {
      mkDerivation {
        pname = "herringbone-wai";
        version = "0.1.1";
-       sha256 = "1kw0n89qqazyap9w315pa6k4smnw1pf8s82grbm8z9d9xyhk980f";
+       sha256 = "0ea034a1efa9a58feaca4f208ddc0ddc564da651b784c1d355fe2b8c13b280cf";
        libraryHaskellDepends = [
          base bytestring herringbone http-types system-fileio
          system-filepath text time wai wai-app-static
@@ -66691,7 +66903,7 @@ self: {
      mkDerivation {
        pname = "hesql";
        version = "0.8";
-       sha256 = "1xxmm5b3n8wj548lmf7hp05g7qwy0sq7mkh0g98n7z1iqdmfamwa";
+       sha256 = "8a57e56ac331fc63517a00ce7ab0069ee3f30ab8f0b84a112992233b56a9b5f7";
        isLibrary = false;
        isExecutable = true;
        executableHaskellDepends = [
@@ -66708,7 +66920,7 @@ self: {
      mkDerivation {
        pname = "hetero-map";
        version = "0.21";
-       sha256 = "1fnzj37kya5gqjchm3yq0709ay50n0spb24x5rxkxfbl0yy2nzk7";
+       sha256 = "677e2bbc0774b93e7b2e9d887535b0a07895c001d88f0a99c4af283fcf90dfba";
        libraryHaskellDepends = [ base ];
        homepage = "http://github.com/luqui/hetero-map";
        description = "Pure heterogeneous maps";
@@ -66721,7 +66933,7 @@ self: {
      mkDerivation {
        pname = "hetris";
        version = "0.2";
-       sha256 = "0sj0grykzb7xq7iz0nj27c4fzhcr9f0yshfcq81xq2wdmg09j8yx";
+       sha256 = "dd2399c0ab8d0bdc03c2cc41ed814b99c1ef083b425af0e3c1fdac3f7d7e406a";
        isLibrary = false;
        isExecutable = true;
        executableHaskellDepends = [ array base hscurses old-time random ];
@@ -66738,7 +66950,7 @@ self: {
      mkDerivation {
        pname = "heukarya";
        version = "0.2.0.2";
-       sha256 = "1ycfy29crdj8ch07wm77lfpg656vm2vl34mdqvsxfxijdxb23cxg";
+       sha256 = "afb321566f3276d7f5c6ad9241b7a8db14f3aea3e7547e006448b6cc92f08ef9";
        libraryHaskellDepends = [
          base containers deepseq parallel random text
        ];
@@ -66753,7 +66965,7 @@ self: {
      mkDerivation {
        pname = "hevolisa";
        version = "0.0.1";
-       sha256 = "1ys7xqdrnvwn6z2vgmh49zhfxj73pdmscblqcjk6qrwmpb2xha2s";
+       sha256 = "5a28d8c5ba95676ca664982ea66bbbe3c8eee04f04d6b7c537966f9b1bee47fb";
        isLibrary = false;
        isExecutable = true;
        executableHaskellDepends = [
@@ -66771,7 +66983,7 @@ self: {
      mkDerivation {
        pname = "hevolisa-dph";
        version = "0.0.1";
-       sha256 = "0jsynxd33r7d5s5vn204z4wdgm4cq6qyjs7afa77p94ni5m2p3kb";
+       sha256 = "6b8e2b6a8996a47b8e72ea68e9b1c18cd4d738f90408bb8b2eede4315ab75e4b";
        isLibrary = false;
        isExecutable = true;
        executableHaskellDepends = [
@@ -66787,7 +66999,7 @@ self: {
      mkDerivation {
        pname = "hex";
        version = "0.1.2";
-       sha256 = "1v31xiaivrrn0q2jz8919wvkjplv1kxna5ajhsj701fqxm1i5vhj";
+       sha256 = "12ee1243edd80570a486521565fb0c9b5e39374f21a12f050636e71d55ec61ec";
        libraryHaskellDepends = [ base bytestring ];
        description = "Convert strings into hexadecimal and back";
        license = stdenv.lib.licenses.bsd3;
@@ -66798,7 +67010,7 @@ self: {
      mkDerivation {
        pname = "hexdump";
        version = "0.1";
-       sha256 = "012hknn9qhwr3hn3dbyd9s7vvaz4i3bvimmxkb1jyfckw3wjcnhc";
+       sha256 = "0c5a26f9e093392fc39abdd6b8d788e4abbd8f4ecdaf362c1c99439cac9d5004";
        libraryHaskellDepends = [ base ];
        description = "A library for forming hexdumps";
        license = stdenv.lib.licenses.publicDomain;
@@ -66809,7 +67021,7 @@ self: {
      mkDerivation {
        pname = "hexif";
        version = "0.2.0.0";
-       sha256 = "1asv5vs694mcifffvm5a4gsplpz7frk3p3zr9lqqv1f172ql9lql";
+       sha256 = "14d344b138c1858d314df98f3b6676e75f7af523aad4ed9c8bac9264f42e5bab";
        libraryHaskellDepends = [ base binary bytestring filepath ];
        jailbreak = true;
        homepage = "http://www.github.com/hansroland/hexif";
@@ -66824,7 +67036,7 @@ self: {
      mkDerivation {
        pname = "hexpat";
        version = "0.20.9";
-       sha256 = "17cx8iafb07f2c8wmfmrfgpz9cjilciba6001klf42z039ghf72x";
+       sha256 = "5d1c075f1ae00be2e80c0018b522a351b2f4ef73b9baca1113ee80e554449d9d";
        libraryHaskellDepends = [
          base bytestring containers deepseq List text transformers
          utf8-string
@@ -66842,7 +67054,7 @@ self: {
      mkDerivation {
        pname = "hexpat-iteratee";
        version = "0.6";
-       sha256 = "10cqgrrqg518lhr9mk6gq48fgc0sjzwiakm2amhqgfflva3q0nqn";
+       sha256 = "165b8087dad4b9876155a24e15f9971ab0e710c1cfcc9a32a4289487737e9881";
        libraryHaskellDepends = [
          base bytestring containers extensible-exceptions hexpat iteratee
          List parallel transformers
@@ -66861,7 +67073,7 @@ self: {
      mkDerivation {
        pname = "hexpat-lens";
        version = "0.1.3";
-       sha256 = "0283zpzj1xsav50d4k66i90fhll89flqnb1jv0x7gxppv1460vfr";
+       sha256 = "d96d6048d8f7f6773ad8322c8ba94b8852e8408ac64cd240d94af720fffd0309";
        libraryHaskellDepends = [
          base bytestring deepseq hexpat hexpat-tagsoup lens
        ];
@@ -66877,7 +67089,7 @@ self: {
      mkDerivation {
        pname = "hexpat-pickle";
        version = "0.6";
-       sha256 = "1k01s49mz4xxfbw1b7ab0ian2m0d7w5awbwf4jyz5ykgxg11kz9m";
+       sha256 = "35fd19c2eb6ffaf2bd248e2fae0a3f0d546155044b9d15f872bd935f13d101cc";
        libraryHaskellDepends = [
          base bytestring containers extensible-exceptions hexpat text
          utf8-string
@@ -66894,7 +67106,7 @@ self: {
      mkDerivation {
        pname = "hexpat-pickle-generic";
        version = "0.1.7";
-       sha256 = "0l0h5n1afkg8zjq28h7aidsskdzf1i5lnz9jlq0hblwa9wamamis";
+       sha256 = "3a5655154f8ad30501a6327d4b4b0ceeb7a9758bea4024b0fce84da7822d1050";
        libraryHaskellDepends = [ base bytestring hexpat text ];
        testHaskellDepends = [
          base bytestring QuickCheck test-framework
@@ -66910,7 +67122,7 @@ self: {
      mkDerivation {
        pname = "hexpat-tagsoup";
        version = "0.1";
-       sha256 = "0481446ba5m0h8lxmp216gzll0wr77mhk6hvm087749fwjj597aj";
+       sha256 = "529d54a4e42e917310a81b9a09eb3999034aff3341dcda2982a016b50c210111";
        libraryHaskellDepends = [ base hexpat tagsoup ];
        description = "Parse (possibly malformed) HTML to hexpat tree";
        license = stdenv.lib.licenses.bsd3;
@@ -66922,7 +67134,7 @@ self: {
      mkDerivation {
        pname = "hexpr";
        version = "0.0.0.0";
-       sha256 = "0wpmbzxdl63r2p398101ywzfs7b4p4x8ds4zzqbhvhs2r0fsg5wv";
+       sha256 = "9b97a71dc842c30d17fe9fe8863ab9641ded3ef7010494c6157918dafa5ff572";
        libraryHaskellDepends = [
          base data-ref either mtl parsec transformers
        ];
@@ -66939,7 +67151,7 @@ self: {
      mkDerivation {
        pname = "hexquote";
        version = "0.1";
-       sha256 = "0fr0sn2k12yvbbwmldqkmwgg0qk6bfd6811h2dgpq77821y62hq8";
+       sha256 = "0843617c10e81c7c5f133004649a5b6662f01eaf13375af95adb8b3085d5203b";
        libraryHaskellDepends = [
          base bytestring containers parsec template-haskell
        ];
@@ -66955,7 +67167,7 @@ self: {
      mkDerivation {
        pname = "hexstring";
        version = "0.11.1";
-       sha256 = "0509h2fhrpcsjf7gffychf700xca4a5l937jfgdzywpm4bzdpn20";
+       sha256 = "40d8dbfe22f572ffdb73f28c448b228a75008e83cc3bf78e939add0c9d800914";
        libraryHaskellDepends = [
          aeson base base16-bytestring binary bytestring text
        ];
@@ -66976,7 +67188,7 @@ self: {
      mkDerivation {
        pname = "heyefi";
        version = "0.1.1.1";
-       sha256 = "0dm9dyn12jgpc317pk5z3rhhgw2hbmbxyfba97jzq34b5z6crz0f";
+       sha256 = "0efccccc2f8b0cfce5496a39df575d50f007611ebfcc7bc260f74911ac6fa936";
        isLibrary = false;
        isExecutable = true;
        executableHaskellDepends = [
@@ -67002,7 +67214,7 @@ self: {
      mkDerivation {
        pname = "hfann";
        version = "0.4.2";
-       sha256 = "09pr24riz63irvykn6csbnm28z35ikwzg52ksah1p7zrywmgq9as";
+       sha256 = "5a25fc2af7f99f1ba0d25394f7f98c657c24aa5d9a193bfdce71981f3311f926";
        isLibrary = true;
        isExecutable = true;
        libraryHaskellDepends = [ base ];
@@ -67022,7 +67234,7 @@ self: {
      mkDerivation {
        pname = "hfd";
        version = "0.0.2";
-       sha256 = "1n60h76hzkb4avnsl6lybq7ya4p4ghcdlplyml7fqwg7i20cak54";
+       sha256 = "a44cc58088e771ec0ead9e5eda187ce412e50f5e9e1aaaed5664cd0fcd81c0d8";
        isLibrary = false;
        isExecutable = true;
        executableHaskellDepends = [
@@ -67040,7 +67252,7 @@ self: {
      mkDerivation {
        pname = "hfiar";
        version = "2.1.1";
-       sha256 = "1jsq33cdpdd52yriky989vd8wlafi9dq1bxzild7sjw1mql69d71";
+       sha256 = "e1b46428ae814b7d1a8dbfaf805b8a4e518eda4e28f919b317a5b5dbd81858cb";
        isLibrary = true;
        isExecutable = true;
        libraryHaskellDepends = [ base eprocess mtl ];
@@ -67057,7 +67269,7 @@ self: {
      mkDerivation {
        pname = "hflags";
        version = "0.4";
-       sha256 = "17zzx273kmnwwazmmns78cllz3l7wad1gi7hizgcxi68j04blhd4";
+       sha256 = "a441ba0890c8c4cede8ff0c4179ae2878e4f294347db5abfe2dcd6398ee8ff9f";
        libraryHaskellDepends = [ base containers template-haskell text ];
        homepage = "http://github.com/errge/hflags";
        description = "Command line flag parser, very similar to Google's gflags";
@@ -67071,7 +67283,7 @@ self: {
      mkDerivation {
        pname = "hfoil";
        version = "0.2.0.2";
-       sha256 = "0jwnyfl1rcd2439738jgs0rgl0p09d1j877z84g0ax3xh7cm4zj1";
+       sha256 = "417e52d9817d74051e41ff1c24434be002fa32d04fa271d220a2b11ca8f3964b";
        isLibrary = true;
        isExecutable = true;
        libraryHaskellDepends = [
@@ -67088,7 +67300,7 @@ self: {
      mkDerivation {
        pname = "hfov";
        version = "1.0.2";
-       sha256 = "04qwmjxm06akvpakc5imcx0ls9zlsz74s4r9p7xzj0q5fv20z09l";
+       sha256 = "34810fc4760503f9fbb929134dced7f4274d4167351636d5dd531950bbac1c13";
        libraryHaskellDepends = [ base ];
        jailbreak = true;
        homepage = "https://github.com/nornagon/hfov";
@@ -67103,7 +67315,7 @@ self: {
      mkDerivation {
        pname = "hfractal";
        version = "0.4.2.5";
-       sha256 = "060qx7wmqhlavamxxyzjyn2ar1cigvfw5ww7c0r70ns54xm0rw5z";
+       sha256 = "bff00c6a27455b70326087f3c2dd7e9185ac84f5f2fbdeabda8a425cf9e91818";
        isLibrary = false;
        isExecutable = true;
        executableHaskellDepends = [
@@ -67121,7 +67333,7 @@ self: {
      mkDerivation {
        pname = "hfsevents";
        version = "0.1.5";
-       sha256 = "0hp9jjj59smfcs51d9zjhyvgdbn46l0rl0jr98wbzg3qya0vwj5k";
+       sha256 = "b348be81f278bcbf384a59029a0135c4aef6b687f2a7168a66aeea54a494e942";
        libraryHaskellDepends = [ base bytestring cereal mtl text unix ];
        homepage = "http://github.com/luite/hfsevents";
        description = "File/folder watching for OS X";
@@ -67134,7 +67346,7 @@ self: {
      mkDerivation {
        pname = "hfusion";
        version = "0.0.6.1";
-       sha256 = "05pisic8s6n2jqymyd2qjifr8kr824v3mflng1a0y4rp8pvbaj7r";
+       sha256 = "f948b5f64537130f547896ba3a3611284f945d9458345f3d96c21a8d58d4f116";
        libraryHaskellDepends = [
          base containers haskell-src mtl pretty syb
        ];
@@ -67151,7 +67363,7 @@ self: {
      mkDerivation {
        pname = "hg-buildpackage";
        version = "1.0.4";
-       sha256 = "0csibld3wrxi4jp35qqhfm17sw9fd5sca5rs9yd7i7l4jvsmfqhq";
+       sha256 = "186257f596849e789a4f3a17c574692e717d427510e332ae24b1673e1a5d5133";
        isLibrary = false;
        isExecutable = true;
        executableHaskellDepends = [
@@ -67168,7 +67380,7 @@ self: {
      mkDerivation {
        pname = "hgal";
        version = "2.0.0.2";
-       sha256 = "17qw8izy54042g56mp3hdbmqcyk95cdarg58xggniwd85q2l5dpi";
+       sha256 = "f1b642052ea8f168dfeba8bcac1a2b697a86eb6a70dc6aca130490e27f441c9f";
        libraryHaskellDepends = [ array base containers mtl ];
        description = "library for computation automorphism group and canonical labelling of a graph";
        license = "GPL";
@@ -67179,7 +67391,7 @@ self: {
      mkDerivation {
        pname = "hgalib";
        version = "0.2";
-       sha256 = "08a8lmh1rg3d1rmpfhcc2fzyc0kybqhzahx4hrvfrqjw7czcnmrw";
+       sha256 = "3c57cb3e3b5ce2ec7686a443f5215e7e02e6bf138c41776b0e6dbc1c60a54821";
        libraryHaskellDepends = [ array base haskell98 mtl ];
        description = "Haskell Genetic Algorithm Library";
        license = stdenv.lib.licenses.publicDomain;
@@ -67194,7 +67406,7 @@ self: {
      mkDerivation {
        pname = "hgdbmi";
        version = "0.2";
-       sha256 = "1gfmpk9a909vc8khf40lr32l3srqqrfbcprp28dp6g02id1xmck4";
+       sha256 = "64b2da438b023c731b12375fb65cc638eb41c5c814100727623b81a4d2bcd5bd";
        libraryHaskellDepends = [ base parsec process stm unix ];
        testHaskellDepends = [
          base directory HUnit process template-haskell temporary
@@ -67214,7 +67426,7 @@ self: {
      mkDerivation {
        pname = "hgearman";
        version = "0.1.0.2";
-       sha256 = "0bfipd7s6czp3aha0jx1yjzfzn8vywiswd07k68q2207j3br8yxk";
+       sha256 = "b37b94d79007088191990734ae23f71bd9efbef4a14ba0a01af733a34fbbd12d";
        libraryHaskellDepends = [
          base binary bytestring monad-control mtl network resource-pool
          transformers transformers-base unordered-containers
@@ -67228,7 +67440,7 @@ self: {
      mkDerivation {
        pname = "hgen";
        version = "1.4.0";
-       sha256 = "190zm0lkr2ymq91ka84a3v2lhxjv9yl43abqcyxj6c3cjqym9ib5";
+       sha256 = "65c5543d966c3023bb6778a941a84f5b7648c51e8a203543c2d58b3c29a81fa4";
        isLibrary = false;
        isExecutable = true;
        executableHaskellDepends = [
@@ -67245,7 +67457,7 @@ self: {
      mkDerivation {
        pname = "hgeometric";
        version = "0.0.2.2";
-       sha256 = "0l460mmbla7354dldil0d7qzba7dp4jhhsna0s27gdd9aad4flsd";
+       sha256 = "4d53479a52a9b5778406ca6a0825b9eda8f5f16980c6461b29e328ba6a058650";
        libraryHaskellDepends = [ base containers ];
        homepage = "ftp://ftp.cs.man.ac.uk/pub/toby/gpc/";
        description = "A geometric library with bindings to GPC";
@@ -67262,7 +67474,7 @@ self: {
      mkDerivation {
        pname = "hgeometry";
        version = "0.4.0.0";
-       sha256 = "00z6xna83j9klba6rj09cdiriqgn45cx15pw22zylywn0s8agc4d";
+       sha256 = "8db0a79006967beabf10fc96d05921f6e198636309c86cd4a233c98194ede603";
        libraryHaskellDepends = [
          base bifunctors bytestring containers data-clist fixed-vector
          hexpat lens linear mtl parsec random semigroups singletons text
@@ -67282,7 +67494,7 @@ self: {
      mkDerivation {
        pname = "hgettext";
        version = "0.1.30";
-       sha256 = "1pgzyd1nqzl7g88pcw7sncija5sd2k4zif9d8qfw96cw6m6kli96";
+       sha256 = "26453a4d359c99c41d462db9f8c9144d172523b3fa7076117a877e6c43f3ffdd";
        isLibrary = true;
        isExecutable = true;
        libraryHaskellDepends = [
@@ -67302,7 +67514,7 @@ self: {
      mkDerivation {
        pname = "hgithub";
        version = "0.1.0";
-       sha256 = "05dxbz9z457b5nl0wsv95pgah9b74agdfwziqf7x79j5q2qqjc2l";
+       sha256 = "543089b1c045a6d38fc3f173d79e226725a8de2d696b0ea82deb14f2d35fbd15";
        isLibrary = true;
        isExecutable = true;
        libraryHaskellDepends = [
@@ -67322,7 +67534,7 @@ self: {
      mkDerivation {
        pname = "hgl-example";
        version = "0.0.2";
-       sha256 = "0bigji3i3311wlphxa0g8lkls0i4cn05d2m57fcrdfan8rayjwxr";
+       sha256 = "b973e9554656b996993ba58a56806524024d27450fa80e2fe5218c1147942f2e";
        isLibrary = false;
        isExecutable = true;
        executableHaskellDepends = [
@@ -67342,7 +67554,7 @@ self: {
      mkDerivation {
        pname = "hgom";
        version = "0.6";
-       sha256 = "0amdfdp1xmh506lgfbb4war2spfb4gqls864q18psmvshcwlpsmv";
+       sha256 = "bbea4b39837a577d51c0c4204df123cb5d2db2e2642df7a80105d61e6e73ad2a";
        isLibrary = false;
        isExecutable = true;
        executableHaskellDepends = [
@@ -67359,7 +67571,7 @@ self: {
      mkDerivation {
        pname = "hgopher";
        version = "0.1.0.0";
-       sha256 = "0j6ybi8f5csa9rpbpy8dc9p6l6vf2qh2zk589a9nqj2phllz7mwf";
+       sha256 = "8ed7f3298557486c934aa8cc2f20166e1b6a6e620df9bb6e4e4ab3e2505cde48";
        libraryHaskellDepends = [ base bytestring network ];
        jailbreak = true;
        description = "Gopher server";
@@ -67371,7 +67583,7 @@ self: {
      mkDerivation {
        pname = "hharp";
        version = "0.1.1.0";
-       sha256 = "1f7k1jlc2ncxyxmc6rl603nw0lynqwv0dmj11hrcdmv282h4ff6s";
+       sha256 = "da3847a04062d7c6320c41d60636c7d653c0ed008666c36af79d59c1a80cf3b8";
        libraryHaskellDepends = [ base ];
        librarySystemDepends = [ harp ];
        jailbreak = true;
@@ -67389,7 +67601,7 @@ self: {
      mkDerivation {
        pname = "hi";
        version = "1.2.0.0";
-       sha256 = "16c3j7pc87mxk9rgk98bicl9jhvnyj2d9spfjvhiknpsixb847h9";
+       sha256 = "091e82568ffada19e196eeead484f4764399288b0ba5f9729abd1ec4ee918399";
        isLibrary = true;
        isExecutable = true;
        libraryHaskellDepends = [
@@ -67419,7 +67631,7 @@ self: {
      mkDerivation {
        pname = "hiccup";
        version = "0.40";
-       sha256 = "1skzr5ipxz61zrndwifkngw70zdf2yh5f8qpbmfzaq0bscrzdxg5";
+       sha256 = "e5f5f633d30b60f55d5d172357a017ae7d70f8b3d345de6cfec1fc7e63c97fea";
        isLibrary = false;
        isExecutable = true;
        executableHaskellDepends = [
@@ -67437,7 +67649,7 @@ self: {
      mkDerivation {
        pname = "hichi";
        version = "0.0.1";
-       sha256 = "1f5cqqw9zn1nji0k2vp0ln1fdbzv9iwjqiaw9vd77kz9pz7p0kvq";
+       sha256 = "784f70cfbfe9cf73da4e5c452c794cfbafe682a5e06e31419436d89f38c6acb8";
        isLibrary = false;
        isExecutable = true;
        executableHaskellDepends = [ array base bytestring mtl network ];
@@ -67453,7 +67665,7 @@ self: {
      mkDerivation {
        pname = "hid";
        version = "0.2.1";
-       sha256 = "18svis0bs4cilks71rih9m89mcdrll5hnjy18ccw81wj32cw9mdh";
+       sha256 = "b0d5c499189207c41943c14b0b0ba5b9b19a504d30e670f4a49111bd808e5ba3";
        libraryHaskellDepends = [ base bytestring transformers ];
        libraryPkgconfigDepends = [ hidapi-libusb ];
        libraryToolDepends = [ c2hs ];
@@ -67466,7 +67678,7 @@ self: {
      mkDerivation {
        pname = "hidapi";
        version = "0.1.3";
-       sha256 = "0ql6avpwi2m89rrglj9zk3fyi8vl91xswagqv8h24b2xgm7pw5i0";
+       sha256 = "20167e4f7d5d2c2220daf829ae7b4874a3e8dd983f49fa724ea88ac8ef568662";
        libraryHaskellDepends = [ base bytestring deepseq-generics ];
        librarySystemDepends = [ systemd ];
        homepage = "https://github.com/vahokif/haskell-hidapi";
@@ -67479,7 +67691,7 @@ self: {
      mkDerivation {
        pname = "hieraclus";
        version = "0.1.2.1";
-       sha256 = "11fjfmdjzvid0352d346p5xf44bl7dn8bd8pms5pi34xysdyr7pg";
+       sha256 = "ef9eec9bf69d8c788bae17b5856c3b7411e27ab9868c26ca002dee2f5b75d285";
        libraryHaskellDepends = [ base containers HUnit mtl multiset ];
        description = "Automated clustering of arbitrary elements in Haskell";
        license = stdenv.lib.licenses.bsd3;
@@ -67492,7 +67704,7 @@ self: {
      mkDerivation {
        pname = "hierarchical-clustering";
        version = "0.4.6";
-       sha256 = "1cfcrnxqczqzqgpyipsw9dwfw1j75zd11vpd12i533f3p44pzwbm";
+       sha256 = "75f17f09b9c38d51a208edee10da2f4706ee784b5cdfe8efc31f7f86bbcdccb1";
        libraryHaskellDepends = [ array base containers ];
        testHaskellDepends = [ base hspec HUnit QuickCheck ];
        description = "Fast algorithms for single, average/UPGMA and complete linkage clustering";
@@ -67506,7 +67718,7 @@ self: {
      mkDerivation {
        pname = "hierarchical-clustering-diagrams";
        version = "0.3.2";
-       sha256 = "06ncyzhql74ni746a9hzma1v0grw99vas4xglmyvgd6yhdwl08sr";
+       sha256 = "5923407983deb4b77da5af13ad764a3c3fb083aa1f2665c889961c8ae1f7cc1a";
        libraryHaskellDepends = [
          base diagrams-lib hierarchical-clustering
        ];
@@ -67525,12 +67737,35 @@ self: {
      mkDerivation {
        pname = "hierarchical-exceptions";
        version = "1.0.1";
-       sha256 = "1yzhw7kgz5iljm8ndh5kyr18367cl6l120m1gkn5x9hpsh9mlamm";
+       sha256 = "b52a5a13d417a65eec7ca10211a8a1ec988142f6b3c06651953496ffe6e1f0fb";
        libraryHaskellDepends = [ base template-haskell ];
        description = "Template Haskell functions to easily create exception hierarchies";
        license = stdenv.lib.licenses.asl20;
      }) {};
 
+  "hierarchy" = callPackage
+    ({ mkDerivation, base, directory, doctest, exceptions, filepath
+     , free, hspec, hspec-expectations, mmorph, monad-control, mtl
+     , pipes, semigroups, transformers, transformers-base
+     , transformers-compat
+     }:
+     mkDerivation {
+       pname = "hierarchy";
+       version = "0.3.1";
+       sha256 = "4ff6dcb89691dbf20de993964ad32904508f5b6569af1e83eaaaf73a271c9c5f";
+       libraryHaskellDepends = [
+         base exceptions free mmorph monad-control mtl pipes semigroups
+         transformers transformers-base transformers-compat
+       ];
+       testHaskellDepends = [
+         base directory doctest filepath hspec hspec-expectations mtl pipes
+         semigroups transformers
+       ];
+       homepage = "https://github.com/jwiegley/hierarchy";
+       description = "Pipes-based library for predicated traversal of generated trees";
+       license = stdenv.lib.licenses.bsd3;
+     }) {};
+
   "hiernotify" = callPackage
     ({ mkDerivation, base, directory, filepath, mtl, old-time, stm
      , timers-updatable
@@ -67538,7 +67773,7 @@ self: {
      mkDerivation {
        pname = "hiernotify";
        version = "2011.4.12";
-       sha256 = "1imgwi6b0cn9y4y7vgqsyfgsyxjvsl1wkmqmrf51jkfqasnqsqh5";
+       sha256 = "05628dad56d84d198acb15d7c903d55b76af9ff31abf7d3cf1c932b04ce4afc6";
        libraryHaskellDepends = [
          base directory filepath mtl old-time stm timers-updatable
        ];
@@ -67553,7 +67788,7 @@ self: {
      mkDerivation {
        pname = "highWaterMark";
        version = "0.1.1";
-       sha256 = "1bwvhrzvrf004lypf0zrx6q6k6fn5qwvlk45vppmnv65v9vq519p";
+       sha256 = "37858277dac56c5befdd854cba392ed69969b0e9f903773d2500b8bc7f869baf";
        isLibrary = false;
        isExecutable = true;
        executableHaskellDepends = [ base ghc ];
@@ -67571,7 +67806,7 @@ self: {
      mkDerivation {
        pname = "higher-leveldb";
        version = "0.3.0.0";
-       sha256 = "0lghf21l3s4fmwnp3dsndzxqhamgppczzydkvnqlmx1x9jk5g1b6";
+       sha256 = "668557a64c3df44ab1ddb3f9ffd9bdaf2a88fb6f56b7712daf8ee8418370f051";
        libraryHaskellDepends = [
          base bytestring cereal data-default leveldb-haskell lifted-base
          monad-control mtl resourcet transformers transformers-base
@@ -67590,7 +67825,7 @@ self: {
      mkDerivation {
        pname = "higherorder";
        version = "0.0";
-       sha256 = "06cqhk9jalyps4v9w6wmpy9jdj3piwsp0wl3fvkzwa5iydlyvisz";
+       sha256 = "5fc7ed69f3b128fee776837270358f77c82693bf951b9e36d1d75325d3849819";
        revision = "1";
        editedCabalFile = "c587250ea9c4828876f3837e82e5b1543e0dc2cc59bb4ec59ce0d947bae3d459";
        libraryHaskellDepends = [ base ];
@@ -67607,7 +67842,7 @@ self: {
      mkDerivation {
        pname = "highjson";
        version = "0.2.0.2";
-       sha256 = "07qz7zb53vbpb9ixrw0qwn5qhvgwzvrvfkp343a1cvbb42slpmkz";
+       sha256 = "7fd64bb5206b6d16d420e34eb7f3fefc6d888be518f0dc635a77ed51d63f1f1f";
        libraryHaskellDepends = [
          attoparsec base buffer-builder bytestring containers hashable hvect
          scientific text unordered-containers vector
@@ -67624,7 +67859,7 @@ self: {
      mkDerivation {
        pname = "highlight-versions";
        version = "0.1.3.5";
-       sha256 = "0nk7kdzzlyq2ml30mj661616h23zar3kqq8xd36lqs1ssr7nqnj7";
+       sha256 = "475a6c4fd63a684ccd681d613c47567f08688209c6c80a06ad027bfa7f9b675a";
        isLibrary = false;
        isExecutable = true;
        executableHaskellDepends = [
@@ -67641,7 +67876,7 @@ self: {
      mkDerivation {
        pname = "highlighter";
        version = "0.2.2";
-       sha256 = "1x381ngd2gg2ff2rj7dyqmhy1achly2wbssjhsrcm0p6sxqab21x";
+       sha256 = "3d88a570d7e682cab28652ebc585a790a9e061c5be1d998573e23dd19e0d68f4";
        isLibrary = true;
        isExecutable = true;
        libraryHaskellDepends = [
@@ -67661,7 +67896,7 @@ self: {
      mkDerivation {
        pname = "highlighter2";
        version = "0.2.5";
-       sha256 = "1gndzxi2i9hybqj6v14wflw8335v09q832knbx61hq9wcgq1hxwi";
+       sha256 = "917718f0633c61184c5f768a817002bb8c8138759c846d245e1ea62862ffcdbe";
        isLibrary = true;
        isExecutable = true;
        libraryHaskellDepends = [
@@ -67682,7 +67917,7 @@ self: {
      mkDerivation {
        pname = "highlighting-kate";
        version = "0.6";
-       sha256 = "16334fbiyq6017zbgc59qc00h0bk24xh4dcrbqx63dvf72ac37dk";
+       sha256 = "b39dc194386eb7613a5e9935023b1173010800c3a9b0b7fe09c0601f97236398";
        revision = "1";
        editedCabalFile = "7466b389fd27b0520d371b2b225cb6024e9b7dd371cffa78169c219ab449558b";
        configureFlags = [ "-fpcre-light" ];
@@ -67707,7 +67942,7 @@ self: {
      mkDerivation {
        pname = "hills";
        version = "0.1.1.0";
-       sha256 = "0fankar6p0m6n1ffis4ww5x9dqdbjh9py63jirbimpdcrzcxcym5";
+       sha256 = "a57ad6d9cfacdd1a578e72187f1394abe1967ae19ce8e85cb0a6826bb29a5639";
        isLibrary = false;
        isExecutable = true;
        executableHaskellDepends = [
@@ -67726,7 +67961,7 @@ self: {
      mkDerivation {
        pname = "himerge";
        version = "0.20";
-       sha256 = "0ivrl5wymqzwcn7vyr3anychlk35003ksxsvr463qz768vbcql00";
+       sha256 = "0050ccd646e67c3c0cc95b773d0700654c0a99b76a64bf8f65fce3ea79a17947";
        isLibrary = false;
        isExecutable = true;
        executableHaskellDepends = [
@@ -67747,7 +67982,7 @@ self: {
      mkDerivation {
        pname = "himg";
        version = "0.1.0.0";
-       sha256 = "09ya9966fn3ss7xxc1cd0izb5js35gwr2r1km881w4455sknl093";
+       sha256 = "23016aa72e85101e10aa336491f92b43cbb27e048d05d6fbd17a58674c4aca27";
        isLibrary = true;
        isExecutable = true;
        libraryHaskellDepends = [
@@ -67772,7 +68007,7 @@ self: {
      mkDerivation {
        pname = "himpy";
        version = "0.5.0";
-       sha256 = "0rpgvv9hq8ai6imhsbfw95igfyqnnzdgx9mw6cpd8ch5kb6wfqig";
+       sha256 = "2f62c7cd9a0532d42e33bca6fedab7167bf76249dc2d0d6b3451210cd3deef66";
        isLibrary = false;
        isExecutable = true;
        executableHaskellDepends = [
@@ -67795,7 +68030,7 @@ self: {
      mkDerivation {
        pname = "hindent";
        version = "4.5.4";
-       sha256 = "09pywkm5xjk6djfwml1frnl21zndw03wp47a30vcnqcqf2a3awi0";
+       sha256 = "20723594709861cb3618ea90cb07e0cdfe20a8cd2ed0ca9d6c66ca5eeae4fe26";
        isLibrary = true;
        isExecutable = true;
        libraryHaskellDepends = [
@@ -67822,7 +68057,7 @@ self: {
      mkDerivation {
        pname = "hinduce-associations-apriori";
        version = "0.0.0.0";
-       sha256 = "002ca2mxrmyvg1w5rr1n7ksc89qxqznasq0cw5grfr5h22pxs57z";
+       sha256 = "ff14ddaf10b064975fe10c60adecc71d27c4f43c36e45c7878dbd7dcab504c00";
        libraryHaskellDepends = [
          base containers deepseq hinduce-missingh parallel vector
        ];
@@ -67836,7 +68071,7 @@ self: {
      mkDerivation {
        pname = "hinduce-classifier";
        version = "0.0.0.1";
-       sha256 = "1cdx916xkpsy2ilsmmdkyqax2gb0cx6sgkydvjbiw7qibd76ylza";
+       sha256 = "ea536f4e5b111f1e97dccdcfa74d67603dd115f6b3d5aa69145edfd94d48bdb1";
        libraryHaskellDepends = [ base hinduce-missingh layout ];
        description = "Interface and utilities for classifiers";
        license = stdenv.lib.licenses.bsd3;
@@ -67850,7 +68085,7 @@ self: {
      mkDerivation {
        pname = "hinduce-classifier-decisiontree";
        version = "0.0.0.1";
-       sha256 = "1hdz4lbbpy2yc5j7chkagjvslsakmv3hbz2s7lpz0isfq7ls9idl";
+       sha256 = "b4c5a4e9c14e47f02f3d5afc05c7ae5369aab77c6a427664615ef8bb1625bfc1";
        libraryHaskellDepends = [
          base convertible hinduce-classifier hinduce-missingh layout
        ];
@@ -67867,7 +68102,7 @@ self: {
      mkDerivation {
        pname = "hinduce-examples";
        version = "0.0.0.2";
-       sha256 = "17jnrc8iji5byqbd08llwk0mw9yi1dq3biaszqp9jyinf50hcb4w";
+       sha256 = "9c2c064171367a992efe5ac535700bd1275ec1e49422d016f6ab441911cb569e";
        libraryHaskellDepends = [
          base containers convertible csv hinduce-associations-apriori
          hinduce-classifier hinduce-classifier-decisiontree hinduce-missingh
@@ -67883,7 +68118,7 @@ self: {
      mkDerivation {
        pname = "hinduce-missingh";
        version = "0.0.0.0";
-       sha256 = "1606fz8qhvwqidi798y3mxlmbmwn8yp3a4cl59j4i8s05vgbaj9z";
+       sha256 = "3f49b5de2e40a348642a941135ae4796d75569afc3a374628b986f88d1770698";
        libraryHaskellDepends = [ base ];
        homepage = "https://github.com/roberth/hinduce-missingh";
        description = "Utility functions";
@@ -67895,7 +68130,7 @@ self: {
      mkDerivation {
        pname = "hinotify";
        version = "0.3.8.1";
-       sha256 = "03c1f4d7x805zdiq2w26kl09xrfjw19saycdkhnixzv2qcr6xm1p";
+       sha256 = "37d46e32c362ff1e2d9c8d79a553e0d2e59e009d46708163fb05a07e1a71810d";
        libraryHaskellDepends = [ base containers directory unix ];
        testHaskellDepends = [ base directory ];
        homepage = "https://github.com/kolmodin/hinotify.git";
@@ -67910,7 +68145,7 @@ self: {
      mkDerivation {
        pname = "hinquire";
        version = "0.1.1";
-       sha256 = "1mm0qi1y2qkiknb5s2jbgc3zljda52mi4mmh0fh7z8ck5rnng1x1";
+       sha256 = "a187676d2e93a17fa003b05612ab28aa49fa077b4b0a5d969d7162e143c4a0d6";
        libraryHaskellDepends = [
          base bifunctors QuickCheck test-framework
          test-framework-quickcheck2 test-framework-th
@@ -67932,7 +68167,7 @@ self: {
      mkDerivation {
        pname = "hinstaller";
        version = "2008.2.16";
-       sha256 = "1ldfqx98w7inpj76xyi0drh2lykfjfq9r34hlbcw7mv4bgxp4l8c";
+       sha256 = "0c5172fb5b64d7c3d9a2908c9cb0936e7a2a606e20fa6e8ebc361e8e52c7aed1";
        libraryHaskellDepends = [
          base bytestring Cabal directory filepath process template-haskell
        ];
@@ -67948,7 +68183,7 @@ self: {
      mkDerivation {
        pname = "hint";
        version = "0.4.2.3";
-       sha256 = "1ds09bd369qmy2672vkhll8igbp63q83wdzwkpky4ab9pac3yayg";
+       sha256 = "cf2b3f98ba6929e2e79dfc373e101ee6ae1711a5706e718cf0152733da4a40b7";
        libraryHaskellDepends = [
          base directory exceptions extensible-exceptions filepath ghc
          ghc-mtl ghc-paths mtl random unix
@@ -67967,7 +68202,7 @@ self: {
      mkDerivation {
        pname = "hint-server";
        version = "1.4.2";
-       sha256 = "1rv6b0vlqs855m3bv047pvdkycmx2mv049cnp9iw8b97d0fsfyf5";
+       sha256 = "c579a71d68272dc463ba9625027615bd323fdbbe8780bd462d05694c375866e7";
        libraryHaskellDepends = [
          base eprocess exceptions hint monad-loops mtl
        ];
@@ -67980,7 +68215,7 @@ self: {
      mkDerivation {
        pname = "hinvaders";
        version = "0.1";
-       sha256 = "01v5szci7kbp3w2jsdcnzv9j3lbcl5bvn9ipcvp3v2xvfjik110h";
+       sha256 = "108430a374bb8b3dee663726bb57a16cd121d3fe96352d051f77cd13d9d76507";
        isLibrary = false;
        isExecutable = true;
        executableHaskellDepends = [ base haskell98 random ];
@@ -67995,7 +68230,7 @@ self: {
      mkDerivation {
        pname = "hinze-streams";
        version = "1.0";
-       sha256 = "137jjwcs3a9n2zybkqqfdy2m1a2ahpdcmficwfmn7ykdz487xcsq";
+       sha256 = "58b37e10f96dfa63abe32cbacada854aa850856f0ee3b9fc1736a9a11997f28c";
        libraryHaskellDepends = [ base haskell98 Stream ];
        homepage = "http://code.haskell.org/~dons/code/hinze-streams";
        description = "Streams and Unique Fixed Points";
@@ -68013,7 +68248,7 @@ self: {
      mkDerivation {
        pname = "hipbot";
        version = "0.5";
-       sha256 = "0acy9bp2dwszd01l514nx2crdxgb356k18pm9ravddljxr24n1hs";
+       sha256 = "1a064b44ee92b6b6554ef5a2304d19ebf59699e896844203685ff326ee4a9e29";
        revision = "1";
        editedCabalFile = "6ac1673be45c18dc010eeeef508a021ec9fef4e0a4e05864733f91aec8508ab8";
        libraryHaskellDepends = [
@@ -68036,7 +68271,7 @@ self: {
      mkDerivation {
        pname = "hipe";
        version = "0.2.0.0";
-       sha256 = "1y8awzmvrvixlba1ndvw5rwm8i38lj1yf4mcfm6h7pmmvpdvr5ah";
+       sha256 = "5095bcdbddb5de034d75ac12e783a4684454792e7c371bd4a23deebcebe70af9";
        libraryHaskellDepends = [
          base containers hgeometry hxt parsec split text text-format
        ];
@@ -68050,7 +68285,7 @@ self: {
      mkDerivation {
        pname = "hips";
        version = "0.1";
-       sha256 = "0m3ribabhpdkwavhywjpc8iqqa9bbdl19d7g3agm4f402gd3rmvr";
+       sha256 = "79d73cda138038529f1aefb414685b2b298c236257720fb7e2b35db8d48a7954";
        isLibrary = false;
        isExecutable = true;
        executableHaskellDepends = [
@@ -68068,7 +68303,7 @@ self: {
      mkDerivation {
        pname = "hircules";
        version = "0.4.1";
-       sha256 = "1i291m3i3c082nsgg7mx2xx2a0q97kdmyashz26i4varqkwhz7qx";
+       sha256 = "1d9f0ff9c4596d128df8502b5fdb3c0903257a17bd9ef7b41508b011470d49c4";
        isLibrary = false;
        isExecutable = true;
        executableHaskellDepends = [
@@ -68088,7 +68323,7 @@ self: {
      mkDerivation {
        pname = "hirt";
        version = "0.0.1.1";
-       sha256 = "0scn4gljgx0ig2fr4rfavk6k3pcychpxlasffd6gp2k1v3sb850v";
+       sha256 = "1b14b4f4d8618afb4c734e2bda2f649edd31cddcca65929d7811f427e9239669";
        isLibrary = false;
        isExecutable = true;
        executableHaskellDepends = [
@@ -68110,7 +68345,7 @@ self: {
      mkDerivation {
        pname = "hissmetrics";
        version = "0.5.1";
-       sha256 = "1rz0yxng4szhmjj1n6d36ljv3388ch8nih09yjrxk4l83zd6hc6d";
+       sha256 = "cd3068da1f8892d9b3f409c0681164088db12535a3191ba4acf06bf26cf7e0e7";
        libraryHaskellDepends = [
          base bytestring conduit http-conduit http-types text time
        ];
@@ -68129,7 +68364,7 @@ self: {
      mkDerivation {
        pname = "hist-pl";
        version = "0.3.2";
-       sha256 = "01c6k3f432yhcvcz7k4w29z7kbvhxlcnh57z1m47qbkymm5b4y7b";
+       sha256 = "eb78b24aad7e2e7c480dff146819ed70af797e129cccf3d966d08b41dc988605";
        isLibrary = true;
        isExecutable = true;
        libraryHaskellDepends = [
@@ -68153,7 +68388,7 @@ self: {
      mkDerivation {
        pname = "hist-pl-dawg";
        version = "0.2.1";
-       sha256 = "1ghhwabi46dimzfk79nkcnk8s4rlcyvqfcpr8ay7sfy7xns2ahjg";
+       sha256 = "4f4225b4edc73b7dbc42f93287b76734138da665d3a633ddafb1191297e210be";
        libraryHaskellDepends = [
          base binary containers dawg text text-binary
        ];
@@ -68169,7 +68404,7 @@ self: {
      mkDerivation {
        pname = "hist-pl-fusion";
        version = "0.5.3";
-       sha256 = "0ism9qw3g0x0r40qm6v0gj1b2fj5zdnfik7b4h0b0dqyi08m6sq3";
+       sha256 = "036b5311881e37b00024ebcce86cfb453ab1827c609b8a01c9a08337384e5547";
        libraryHaskellDepends = [
          base binary containers dawg hist-pl-dawg hist-pl-lexicon polimorf
          text text-binary
@@ -68187,7 +68422,7 @@ self: {
      mkDerivation {
        pname = "hist-pl-lexicon";
        version = "0.6.1";
-       sha256 = "1baq1a5l44q56msp2y2m9hyd5v841jkxm0cdlgi816fmc0768cqk";
+       sha256 = "1333640e60d59980e2a38d81daa70c04edd23c4c55787175350513428b0a58ad";
        libraryHaskellDepends = [
          base binary containers dawg directory filepath hist-pl-dawg
          hist-pl-types pipes text transformers
@@ -68203,7 +68438,7 @@ self: {
      mkDerivation {
        pname = "hist-pl-lmf";
        version = "0.1.0";
-       sha256 = "146vz15fig8k1wcvcw7fg64abxvg1nyarvhigz9jkzf5yngkzwvm";
+       sha256 = "75f33f9ff5c5fd29d37f11eeacbc0d6ff7a58879ee70b6190f13bde84af8db90";
        libraryHaskellDepends = [ base hist-pl-types polysoup text ];
        jailbreak = true;
        homepage = "https://github.com/kawu/hist-pl/tree/master/lmf";
@@ -68217,7 +68452,7 @@ self: {
      mkDerivation {
        pname = "hist-pl-transliter";
        version = "0.1.1";
-       sha256 = "146ywyh67a0hasgcpfmffrj8w1kg6anksaa3mm9f80k83shqhvrb";
+       sha256 = "2b6f88a11e6802e452ad43293dad326f068e6476aebacb9e5610a863a0e7de90";
        libraryHaskellDepends = [ base parsec ];
        homepage = "https://github.com/kawu/hist-pl/tree/master/transliter";
        description = "A simple EDSL for transliteration rules";
@@ -68229,7 +68464,7 @@ self: {
      mkDerivation {
        pname = "hist-pl-types";
        version = "0.1.0";
-       sha256 = "0i13aj1xcwap0k3w48vyiiganbvj93zydawmw3gw7m0kr6nl5l9v";
+       sha256 = "3bd142adc913d4c3dfe095abe6ff48722fab5e8c7e23c2c7045771d683542344";
        libraryHaskellDepends = [ base binary text text-binary ];
        jailbreak = true;
        homepage = "https://github.com/kawu/hist-pl/tree/master/types";
@@ -68244,7 +68479,7 @@ self: {
      mkDerivation {
        pname = "histogram-fill";
        version = "0.8.4.1";
-       sha256 = "0zamqza4ky90l27sjgv55rp7s1g4hs0k0qn2qza7lfwk991ijn9q";
+       sha256 = "385919434a933b7ad4c7c262308186e4057d6e2e653fa98fa020f949d4c7557d";
        libraryHaskellDepends = [
          base deepseq ghc-prim monad-primitive primitive vector
        ];
@@ -68258,7 +68493,7 @@ self: {
      mkDerivation {
        pname = "histogram-fill-binary";
        version = "0.6.2.1";
-       sha256 = "0bv70h1q8h50x3sr8ia6855vw0rrbvnzlnnh45k4i1dfadj6zsi2";
+       sha256 = "22ea6f6453ae85486621d05afaed5e3903be4b41464594f5e8a040840304672f";
        libraryHaskellDepends = [ base binary histogram-fill vector ];
        homepage = "https://github.com/Shimuuar/histogram-fill/";
        description = "Binary instances for histogram-fill package";
@@ -68270,7 +68505,7 @@ self: {
      mkDerivation {
        pname = "histogram-fill-cereal";
        version = "0.6.2.0";
-       sha256 = "17bnn6cb64333ak0qh841192jh2zwxg73rbc3zh5agp00wi23ism";
+       sha256 = "55c7212207e03e55e01f6ce5715ee75f4029520804410ca61a6310b398b1769d";
        libraryHaskellDepends = [ base cereal histogram-fill vector ];
        homepage = "http://bitbucket.org/Shimuuar/histogram-fill-cereal/";
        description = "Library for histograms creation";
@@ -68284,7 +68519,7 @@ self: {
      mkDerivation {
        pname = "historian";
        version = "0.0.1";
-       sha256 = "1lgajnq092jk4izy86qcw71ghxz6b8mprm4ha3ybrm5i2rlh12r6";
+       sha256 = "268b006916b1d4bcfc5090d47c2b5ae677f8c2e10c1be47f24538a04b095ead1";
        isLibrary = false;
        isExecutable = true;
        executableHaskellDepends = [
@@ -68305,7 +68540,7 @@ self: {
      mkDerivation {
        pname = "hit";
        version = "0.6.3";
-       sha256 = "0wg44vgd5jzi0r0vg8k5zrvlr7rcrb4nrp862c6y991941qv71nv";
+       sha256 = "db86b3712029a4e40d1306dd6cc9ca2c9f4c77fe65a2b74106f1cbd2de26e471";
        isLibrary = true;
        isExecutable = true;
        libraryHaskellDepends = [
@@ -68328,7 +68563,7 @@ self: {
      mkDerivation {
        pname = "hjcase";
        version = "0.2.0.0";
-       sha256 = "0d1pb24jqk2dj635hy1way9axr9719g1ppxmxr4jpbb0sj6xphjk";
+       sha256 = "53c2db8dd460ad2b49eeb5df1b5e0a27e5ae92573c785886914d4c2c89583734";
        libraryHaskellDepends = [
          aeson base bytestring HUnit test-framework test-framework-hunit
          text unordered-containers vector
@@ -68344,7 +68579,7 @@ self: {
      mkDerivation {
        pname = "hjpath";
        version = "3.0.1";
-       sha256 = "0wmzxwi24q7r0yxnalzqnn3k0bzf7wc4ql26dv94pvzir156kahj";
+       sha256 = "12aa694ac8f1ef4bd26e46504c183fee2f3087b5f85365bb07f9602222efbf72";
        libraryHaskellDepends = [ base containers hjson parsec ];
        homepage = "http://bitcheese.net/wiki/code/hjpath";
        description = "XPath-like syntax for querying JSON";
@@ -68358,7 +68593,7 @@ self: {
      mkDerivation {
        pname = "hjs";
        version = "0.2.1";
-       sha256 = "0gk4misxbkc2x8hh7ynrj1ma91fs0h6q702w6r0kjq136fh48zhi";
+       sha256 = "117e44a03323603941365c80830d04da85a46a90d9fa0321ea82cdd575ac643e";
        isLibrary = true;
        isExecutable = true;
        libraryHaskellDepends = [
@@ -68378,7 +68613,7 @@ self: {
      mkDerivation {
        pname = "hjsmin";
        version = "0.1.5.0";
-       sha256 = "1mzi7czzw1b8avkfzmsl79hqg57dcrcfp6klzx15drnbl7c1zn7l";
+       sha256 = "f4d81fd8a1cbe65642ff749aeb5866ed9487613a54d7efe6566805fe3f3bf1d7";
        isLibrary = true;
        isExecutable = true;
        libraryHaskellDepends = [
@@ -68403,7 +68638,7 @@ self: {
      mkDerivation {
        pname = "hjson";
        version = "1.3.2";
-       sha256 = "1r59g5ypqjsldflsddg7pzpa6j8jps5nwm4h9cwiw7qk734rjik8";
+       sha256 = "684699c938131f1e394b90546e8bbe1249a3eebfe7b5a6a96b544b7c7d79a9e4";
        libraryHaskellDepends = [ base containers parsec ];
        description = "JSON parsing library";
        license = stdenv.lib.licenses.bsd3;
@@ -68414,7 +68649,7 @@ self: {
      mkDerivation {
        pname = "hjson-query";
        version = "1.0.2";
-       sha256 = "0sj86rm5pz0q9079f5kjnpz51dxvvq72waaf8h64jzrrhkpz8mlx";
+       sha256 = "9d56f4ef84397f490c444e292e0edebbb750feb57216970e4818fc5b6a36486a";
        libraryHaskellDepends = [ base containers hjson ];
        description = "library for querying from JSON";
        license = stdenv.lib.licenses.bsd3;
@@ -68427,7 +68662,7 @@ self: {
      mkDerivation {
        pname = "hjsonpointer";
        version = "0.2.0.3";
-       sha256 = "13n0fzhd2fmy7k5iafmg3cxd2lmpsfvvbg1a0q793wz5f3glw0l3";
+       sha256 = "83024edf70e5f3910e062abcb5b7d3b752d13a1baf3a15cb3cbe3ad1e077c08e";
        libraryHaskellDepends = [
          aeson base text unordered-containers vector
        ];
@@ -68450,7 +68685,7 @@ self: {
      mkDerivation {
        pname = "hjsonschema";
        version = "0.6.0.1";
-       sha256 = "1m7fg179khkmyhnhqa32gbaf2dgg27i4n36fafqm60pyc5kzhz69";
+       sha256 = "c97cf86761fe0253b153ce0c4be211ef35e1d47a62280c2df475c2994e78eed4";
        libraryHaskellDepends = [
          aeson base bytestring file-embed hashable hjsonpointer http-client
          http-types regexpr scientific text unordered-containers vector
@@ -68474,7 +68709,7 @@ self: {
      mkDerivation {
        pname = "hlatex";
        version = "0.3";
-       sha256 = "03v8law4yfm63f44zyiqngjmpismk8clqisq4sl4gcp1yc1hn704";
+       sha256 = "041c0b03f3e1b247a82658474c199a55c75be5b338fa4f881ba63a4fb8a2680f";
        isLibrary = true;
        isExecutable = true;
        libraryHaskellDepends = [
@@ -68496,7 +68731,7 @@ self: {
      mkDerivation {
        pname = "hlbfgsb";
        version = "0.0.1.0";
-       sha256 = "0nar59rbi5zr6gi2k0f49f09fnxcmshnq9bb2dh973a4y3gcw6dx";
+       sha256 = "bd19cedef0448d9360136b256ca1aeac5b97804bc48129e233f997b8722a5959";
        libraryHaskellDepends = [ base vector ];
        librarySystemDepends = [ gfortran ];
        libraryToolDepends = [ gfortran ];
@@ -68516,7 +68751,7 @@ self: {
      mkDerivation {
        pname = "hlcm";
        version = "0.2.2";
-       sha256 = "14yqc02kfp2c9i22inma29cprqz9k8yx6c7m90kwimv4psv8766a";
+       sha256 = "ca9883b6be64d7c82748f530d33d9ae9e37c5912aada28444c4c5c370560d893";
        isLibrary = true;
        isExecutable = true;
        libraryHaskellDepends = [
@@ -68543,7 +68778,7 @@ self: {
      mkDerivation {
        pname = "hledger";
        version = "0.26";
-       sha256 = "1gixj6i99rqbn6ziwpni2scgv9sdd3yvxj6d3i1ivirmsx2rd3bm";
+       sha256 = "758d9645d735c71d431ccdc8befd684da7fd9816d15e1ebfb10be794a2913dbe";
        isLibrary = true;
        isExecutable = true;
        libraryHaskellDepends = [
@@ -68576,7 +68811,7 @@ self: {
      mkDerivation {
        pname = "hledger-chart";
        version = "0.16.1";
-       sha256 = "1yk563032ir98gqdvxazjjl1alg6q1pflzawh11pr3zrdnriracn";
+       sha256 = "96a91cb36df98f7c43805c7dea6ec0e65115a8945ff5ddf043294731c03065fa";
        isLibrary = false;
        isExecutable = true;
        executableHaskellDepends = [
@@ -68595,7 +68830,7 @@ self: {
      mkDerivation {
        pname = "hledger-diff";
        version = "0.2.0.4";
-       sha256 = "1p0b2xc2axsigmbc5lhl12acsjjvn0j8gjlwp3v4ggyanwyj686r";
+       sha256 = "d920233db7cabf47f6b89cca8724b05b4acd940814d2c2567d51772558170bdc";
        isLibrary = false;
        isExecutable = true;
        executableHaskellDepends = [ base hledger-lib time ];
@@ -68609,7 +68844,7 @@ self: {
      mkDerivation {
        pname = "hledger-interest";
        version = "1.4.4";
-       sha256 = "16knk1cwrpg5jn6vgcab7hqpjzg33ysz57x1f2glrmhhv1slmbfn";
+       sha256 = "d6ad4a75d810d64c9f70a19ff2b51fe37d79313c4bb1b78d95e5ddcc5998769a";
        isLibrary = false;
        isExecutable = true;
        executableHaskellDepends = [
@@ -68627,7 +68862,7 @@ self: {
      mkDerivation {
        pname = "hledger-irr";
        version = "0.1.1.7";
-       sha256 = "1gi7v5xsx1hv4lljlx19v4rwvnh7raglxzh4mgyiwlnwqybc2cr4";
+       sha256 = "2433c196c7dc521efdab04fe4e9fca07dacd33d929742a29251b86ae7bd927be";
        isLibrary = false;
        isExecutable = true;
        executableHaskellDepends = [
@@ -68647,7 +68882,7 @@ self: {
      mkDerivation {
        pname = "hledger-lib";
        version = "0.26";
-       sha256 = "0cm5d65kfxha6280q9iibrj4a0p5g6srfl28x1f8vay41xjg80nh";
+       sha256 = "d002f4640fc4ab8d5ce8485097b579e50245645e31260c90300a76378b69a532";
        libraryHaskellDepends = [
          array base base-compat blaze-markup bytestring cmdargs containers
          csv Decimal directory filepath HUnit mtl mtl-compat old-time parsec
@@ -68671,7 +68906,7 @@ self: {
      mkDerivation {
        pname = "hledger-vty";
        version = "0.16.1";
-       sha256 = "10aq9apxz6nrzvvynha0wkhy34dn8dybizr8assni6rns8ylh188";
+       sha256 = "0805483dd2369b68b55628ffb87c43b691e1e1e44041ebf7fed99adfaf4a5881";
        isLibrary = false;
        isExecutable = true;
        executableHaskellDepends = [
@@ -68696,7 +68931,7 @@ self: {
      mkDerivation {
        pname = "hledger-web";
        version = "0.26";
-       sha256 = "019r4jy0kss62ya883rgzkc6lkp14f0dfkdfiahpl4587fcvpxsi";
+       sha256 = "51f7bb993ba8107aa18aae4dd78023e14e6ad8fc2f0f84941746eb09bc243905";
        isLibrary = true;
        isExecutable = true;
        libraryHaskellDepends = [
@@ -68727,7 +68962,7 @@ self: {
      mkDerivation {
        pname = "hlibBladeRF";
        version = "0.1.0.6";
-       sha256 = "15k15afy04kld6ar317lk441js873fcyk8qh92r98hnhbpq3nrmw";
+       sha256 = "bc663bf05dd04294b24810a3e9991b0769190899f4849195697412e09d2a6196";
        libraryHaskellDepends = [ base bindings-DSL bytestring ];
        libraryPkgconfigDepends = [ libbladeRF ];
        testHaskellDepends = [ base hlint ];
@@ -68742,7 +68977,7 @@ self: {
      mkDerivation {
        pname = "hlibev";
        version = "0.4.0";
-       sha256 = "0416w0k5ahnj57gc6n15ihpsyznmm36s1sjkycl35l7s8bxdldyw";
+       sha256 = "dc37dafa42fad03228f353eaa0cda8d57eaf2f8c2558c3de29d2425526e02610";
        libraryHaskellDepends = [ base network ];
        librarySystemDepends = [ ev ];
        homepage = "http://github.com/aycanirican/hlibev";
@@ -68756,7 +68991,7 @@ self: {
      mkDerivation {
        pname = "hlibfam";
        version = "0.2";
-       sha256 = "10rxwfq2ppmqs3kjb8cq6l04g0qsxqy7w7ri7dj013kiz7rzk1yd";
+       sha256 = "cd87f9f3f9718e00643b311f7e3cee1a8347003598a125e7d0b8de2bb0e33d83";
        libraryHaskellDepends = [ base ];
        librarySystemDepends = [ fam ];
        description = "FFI interface to libFAM";
@@ -68769,7 +69004,7 @@ self: {
      mkDerivation {
        pname = "hlibgit2";
        version = "0.18.0.14";
-       sha256 = "0fxglcgi0iwj9xqgx1f3dixia9pqfzz0yq9iq7flaggpr9pvn3n0";
+       sha256 = "c00ebb6fcaf73d45ddc131610ffe77f826157b6cc385fe704f9247101fa3af3b";
        libraryHaskellDepends = [ base bindings-DSL zlib ];
        librarySystemDepends = [ openssl ];
        testHaskellDepends = [ base process ];
@@ -68782,7 +69017,7 @@ self: {
      mkDerivation {
        pname = "hlibsass";
        version = "0.1.4.0";
-       sha256 = "062qsg5mr0qsa5ah1d0xx7njkpn4j4g6x4sv3skgvgc9855gywr6";
+       sha256 = "2673ff4a4189bdfda61e5b936e1e91c4de29ede91db40055511a835ccbd35818";
        libraryHaskellDepends = [ base ];
        librarySystemDepends = [ sass ];
        testHaskellDepends = [ base hspec ];
@@ -68799,7 +69034,7 @@ self: {
      mkDerivation {
        pname = "hlint";
        version = "1.9.21";
-       sha256 = "14v3rdjjlml9nimdk7d5dvir2bw78ai49yylvms9lnzmw29s3546";
+       sha256 = "8694a193e0f55b9a74ddd4fb44a242872f91e36ea59dd96ab489562a65cb6393";
        isLibrary = true;
        isExecutable = true;
        libraryHaskellDepends = [
@@ -68817,7 +69052,7 @@ self: {
      mkDerivation {
        pname = "hlogger";
        version = "0.0.3.0";
-       sha256 = "1q3jsnxy7x0lv7wqfv9hlqnr22661k4agbb8yjbhj32fxyjqrn4f";
+       sha256 = "8ed88ca5ef4e0c0997f468ada7c80cc608912da6306d87f9d914f4e3bbd572e0";
        libraryHaskellDepends = [ base old-locale time ];
        homepage = "http://www.pontarius.org/sub-projects/hlogger/";
        description = "Simple, concurrent, extendable and easy-to-use logging library";
@@ -68832,7 +69067,7 @@ self: {
      mkDerivation {
        pname = "hlongurl";
        version = "0.9.3";
-       sha256 = "1njj7cvj9zjy0gghkr33bzwsv6lj27xvf56kicsr0pyyn76wplv5";
+       sha256 = "65d3cbcdb1de5f90358bd314b7fb11929aadf95f63e409df035efe24373b52da";
        isLibrary = true;
        isExecutable = true;
        libraryHaskellDepends = [ base curl json ];
@@ -68848,7 +69083,7 @@ self: {
      mkDerivation {
        pname = "hls";
        version = "0.15";
-       sha256 = "0h32fyvnqkxx8c9vfpdjvnqaxkvr8b15myjavxmnm6kwh7v2796l";
+       sha256 = "d4a423f6817c9a6a6bdf4afa5ac24279cfaeb0ddb25db71343bd4f6cb7776240";
        libraryHaskellDepends = [ base containers hcg-minus hps ];
        homepage = "http://rd.slavepianos.org/t/hls";
        description = "Haskell Lindenmayer Systems";
@@ -68860,7 +69095,7 @@ self: {
      mkDerivation {
        pname = "hlwm";
        version = "0.1.0.1";
-       sha256 = "1vp21440v9gq4mvnqnsw1ha72ywgc4hmp137pkpvs5p13ixyfrgi";
+       sha256 = "f165e77b1ce116bdefbc67845b21618f7b71140c5c5b6c7725f8a50d0809e2ee";
        revision = "1";
        editedCabalFile = "ce22b9186e03c83f13e56b33630f4af561b604c51374c23dc1ef4e24ced9a54e";
        isLibrary = true;
@@ -68881,7 +69116,7 @@ self: {
      mkDerivation {
        pname = "hly";
        version = "0.15";
-       sha256 = "192szfq39g3fdcdsxj4bsi13bfha8gjbqbixav3iywmdsgxp1hj8";
+       sha256 = "48c270fbd3ad721fc7563d2ebce4430aba3542d48bc8ae1b6b6ebc34b0fb5aa4";
        libraryHaskellDepends = [ base directory filepath hmt process ];
        homepage = "http://rd.slavepianos.org/t/hly";
        description = "Haskell LilyPond";
@@ -68896,7 +69131,7 @@ self: {
      mkDerivation {
        pname = "hmark";
        version = "1.2";
-       sha256 = "1s4ichb5dchcimcq9pvdddv2ibbdk2cb2b7p0l7p9s5lxn53bxgg";
+       sha256 = "eff5358aedb4e8740f05f72cb198986dad28766b6ddf84598d0cb256166491e8";
        isLibrary = true;
        isExecutable = true;
        libraryHaskellDepends = [
@@ -68914,7 +69149,7 @@ self: {
      mkDerivation {
        pname = "hmarkup";
        version = "3000.0.1";
-       sha256 = "0p6f1jd1b01dvzffiac17f8z0l403f54vrph8k9b3549lpjfh452";
+       sha256 = "a210e8e4a58994b1d244f0e64d8a1b8050f0913b81a9e8dcdf2d80159a0cce5c";
        libraryHaskellDepends = [
          base containers mtl network parsec xhtml
        ];
@@ -68930,7 +69165,7 @@ self: {
      mkDerivation {
        pname = "hmatrix";
        version = "0.16.1.5";
-       sha256 = "1da1iy2rzz51l69nixacsl7gqhkzld1w8z5h0klkha3mcnf1kkkq";
+       sha256 = "78ce199c65752838e904b07cc443a37f42fc0ed54cf56893a1a1fc9f858f41b5";
        libraryHaskellDepends = [
          array base binary bytestring deepseq random split storable-complex
          vector
@@ -68946,7 +69181,7 @@ self: {
      mkDerivation {
        pname = "hmatrix-banded";
        version = "0.0";
-       sha256 = "05jgm3hnlylnfhavcicjbhbxq929whm6mapggfwbxkzajhh0paaj";
+       sha256 = "52a90b2094eacfbeb87befaa6a2ae44924dc175c9245b61574967a6ae1a84f16";
        libraryHaskellDepends = [ base hmatrix transformers ];
        librarySystemDepends = [ lapack ];
        jailbreak = true;
@@ -68961,7 +69196,7 @@ self: {
      mkDerivation {
        pname = "hmatrix-csv";
        version = "0.1.0.2";
-       sha256 = "0cbnxzl9ymqnyrikwk13d660l3hmi4ln5zdx0q814k8b7hyvsnkb";
+       sha256 = "6b5abd3d3c0b4d121006bdfd622989150e0a8c69234c3e63f616579fe8ef7631";
        libraryHaskellDepends = [ base bytestring cassava hmatrix vector ];
        homepage = "https://github.com/grtlr/hmatrix-csv";
        description = "CSV encoding and decoding for hmatrix";
@@ -68973,7 +69208,7 @@ self: {
      mkDerivation {
        pname = "hmatrix-glpk";
        version = "0.4.1.0";
-       sha256 = "0jy00mblbqp7bx0nxmvzfpa94b21fbl4cam0mha673hzq11rfrxi";
+       sha256 = "b1679743c01f8e6314aca02a46e872412c92d4757fd76e415fe7e2455705c04b";
        libraryHaskellDepends = [ base containers hmatrix ];
        librarySystemDepends = [ glpk ];
        homepage = "https://github.com/albertoruiz/hmatrix";
@@ -68987,7 +69222,7 @@ self: {
      mkDerivation {
        pname = "hmatrix-gsl";
        version = "0.16.0.3";
-       sha256 = "07hg9rfrr1029n9q8xyicyh4rr9x4c02cqn1xxnks9p9qyccf4kg";
+       sha256 = "6f12c798c7e9263d6defc1622600233de54ca067d17784934d02849c5d4e0f1e";
        libraryHaskellDepends = [
          array base hmatrix process random vector
        ];
@@ -69002,7 +69237,7 @@ self: {
      mkDerivation {
        pname = "hmatrix-gsl-stats";
        version = "0.4.1";
-       sha256 = "113gi92xdck75zrllpncrnm72fj8wd2wcbf237jflkpbqcmzf8zq";
+       sha256 = "f823f72bc3eb4eeae419c22dc645e3483a71aacdcc5e4af32f67b2d6458a6f84";
        libraryHaskellDepends = [ base binary hmatrix storable-complex ];
        libraryPkgconfigDepends = [ gsl ];
        homepage = "http://code.haskell.org/hmatrix-gsl-stats";
@@ -69016,7 +69251,7 @@ self: {
      mkDerivation {
        pname = "hmatrix-mmap";
        version = "0.0.5";
-       sha256 = "03z1f1xqw4hqh41q6hh8p103cl7dg9hqcawqlinapfmkvw5mzy8d";
+       sha256 = "0df95f0bdfb3baab6ca4982b86617aed503640b8084283038118128e7b70e10f";
        libraryHaskellDepends = [ base hmatrix mmap ];
        homepage = "http://github.com/alanfalloon/hmatrix-mmap";
        description = "Memory map Vector from disk into memory efficiently";
@@ -69028,7 +69263,7 @@ self: {
      mkDerivation {
        pname = "hmatrix-nipals";
        version = "0.2";
-       sha256 = "0afmpwfi4hqz5bpcsm579mcvz1dx7vxqmqj2rb6axnw9512xyarj";
+       sha256 = "322bdf452889dbaeccca42e28afb3ebd85bf594da754cdee2a1f43121dbfd529";
        isLibrary = true;
        isExecutable = true;
        libraryHaskellDepends = [ base hmatrix ];
@@ -69042,7 +69277,7 @@ self: {
      mkDerivation {
        pname = "hmatrix-quadprogpp";
        version = "0.2.0.2";
-       sha256 = "02ysxyy7ixpnrghl0ignfmjy6j358i5xbmklmpxykkg27jgzvic3";
+       sha256 = "83c5fd9f3ce2cde9fbad74d6d54b446548e36575f64540e1cbf6f678bcefda0b";
        libraryHaskellDepends = [ base hmatrix vector ];
        librarySystemDepends = [ QuadProgpp ];
        description = "Bindings to the QuadProg++ quadratic programming library";
@@ -69055,7 +69290,7 @@ self: {
      mkDerivation {
        pname = "hmatrix-repa";
        version = "0.1.2.1";
-       sha256 = "0xx02kll13c2zw5x13p9746av2yhgpybfxi508qgi84drfa8caa8";
+       sha256 = "48298694cb8da0f830022576b7fc7dd08bad0c39e98ed00bff828d40e914a077";
        libraryHaskellDepends = [ base hmatrix repa vector ];
        homepage = "http://code.haskell.org/hmatrix-repa";
        description = "Adaptors for interoperability between hmatrix and repa";
@@ -69067,7 +69302,7 @@ self: {
      mkDerivation {
        pname = "hmatrix-special";
        version = "0.3.0.1";
-       sha256 = "1ziqzbfrk7xyah5n0cys1ccnmj2z91wxdamanv3y5v717zhdrqix";
+       sha256 = "3de2dce03fe1ece2c7b6aaaad679485fc86a190bda33600b54be9f99ddfa38fe";
        libraryHaskellDepends = [ base hmatrix hmatrix-gsl ];
        homepage = "https://github.com/albertoruiz/hmatrix";
        description = "Interface to GSL special functions";
@@ -69081,7 +69316,7 @@ self: {
      mkDerivation {
        pname = "hmatrix-static";
        version = "0.3.0.2";
-       sha256 = "1qjxj8k4cracinyyjpk0nr3c5n119v39kpxig78c11cjhvhm3zgi";
+       sha256 = "f1fd51e1869285c0d079b1df99c64e21d8c246b6605ee9bd8d4c654626925de2";
        libraryHaskellDepends = [
          array base haskell-src-meta hmatrix parsec template-haskell tfp
        ];
@@ -69097,7 +69332,7 @@ self: {
      mkDerivation {
        pname = "hmatrix-svdlibc";
        version = "0.3.1";
-       sha256 = "0mi41n31i4bjnqjnsmqs4mbrprg3sx4vx4wqixgyp3qk0jm6lijm";
+       sha256 = "55466aaa04138feb5f8f9893be49d7e3e59b57251a576d25b6729118860d2456";
        isLibrary = true;
        isExecutable = true;
        libraryHaskellDepends = [ base hmatrix ];
@@ -69114,7 +69349,7 @@ self: {
      mkDerivation {
        pname = "hmatrix-syntax";
        version = "0.1.2.1";
-       sha256 = "0qy5dx480hf9i03d16kylg2l8dsj10lzwfbik5ijqa4x3h7h038b";
+       sha256 = "0b0d000f1c9d282c63997139fe2908523744c5a37e9ad00688c94180486fc563";
        libraryHaskellDepends = [
          base haskell-src-exts haskell-src-meta hmatrix template-haskell
        ];
@@ -69132,7 +69367,7 @@ self: {
      mkDerivation {
        pname = "hmatrix-tests";
        version = "0.4.1.0";
-       sha256 = "0jrq9719japf9a7v14xbwqj4fs8y14wkji13jhyn00x1xpp4nkh3";
+       sha256 = "034e4beeeda103603d9423443939091e694724e6ab93b08f4aee2a99c249384b";
        libraryHaskellDepends = [
          base hmatrix hmatrix-gsl HUnit QuickCheck random
        ];
@@ -69150,7 +69385,7 @@ self: {
      mkDerivation {
        pname = "hmeap";
        version = "0.15";
-       sha256 = "19hip2xzlsgj1fd8y4l4zhn4lcj8n8qyrayn6idzvlskx4vca0bh";
+       sha256 = "7001c536e953d3fd5b34d6abec31b248324a2cfc84128f9a0bf269fabbb811a6";
        libraryHaskellDepends = [
          array base bytestring bytestring-lexing delimited-text parsec
        ];
@@ -69167,7 +69402,7 @@ self: {
      mkDerivation {
        pname = "hmeap-utils";
        version = "0.14";
-       sha256 = "1dnmvzy7vkx2rfbkkqapfpql8h0gm9sq0333r90hy5nsyl9hhbq8";
+       sha256 = "082f0813f5da160f41ca630c8075aa0f4044f17557e13997cba2cf7dfcdfd5b6";
        isLibrary = false;
        isExecutable = true;
        executableHaskellDepends = [
@@ -69188,7 +69423,7 @@ self: {
      mkDerivation {
        pname = "hmemdb";
        version = "0.4.0.0";
-       sha256 = "0zdz9nkianzviy0rn7fvzs01ymnz89p25kiis64rfvj3zwxk535w";
+       sha256 = "bc8c323bff436e9789d131ce226e42df561f80fedb1d9b818ffb5b15a74dbf7d";
        libraryHaskellDepends = [
          base binary containers monad-stm stm transformers
        ];
@@ -69201,7 +69436,7 @@ self: {
      mkDerivation {
        pname = "hmenu";
        version = "0.1.0.1";
-       sha256 = "0ym3nzyx1jwcc7m6qj8zchs2q73rj82d7f1r2rvykhns7ca20hrp";
+       sha256 = "374320143bdac2e9771639b8d30492791c2c34641f496cea618ccbd0fdb7a37a";
        isLibrary = false;
        isExecutable = true;
        executableHaskellDepends = [ base MissingH process ];
@@ -69216,7 +69451,7 @@ self: {
      mkDerivation {
        pname = "hmidi";
        version = "0.2.2.0";
-       sha256 = "1khqhw69c3bf3qj8pzxz876xisr099rgdgf2rr101x83h9hj8acb";
+       sha256 = "8b2924618203f50042cec2bdf6724a20ebd8cd41bfff8b241e6e0d960c8718ce";
        libraryHaskellDepends = [ base stm ];
        homepage = "http://code.haskell.org/~bkomuves/";
        description = "Binding to the OS level MIDI services";
@@ -69230,7 +69465,7 @@ self: {
      mkDerivation {
        pname = "hmk";
        version = "0.9.7.3";
-       sha256 = "08cq1lk1nkhkcjjjvkzy4xrr0gx6j2lpsv2vmj25kg6j9j33ilxh";
+       sha256 = "b0d338864cd2bc5984ac5b6c7da990a63f907327fecf2da564134e1b260d9821";
        isLibrary = true;
        isExecutable = true;
        libraryHaskellDepends = [ base containers ];
@@ -69252,7 +69487,7 @@ self: {
      mkDerivation {
        pname = "hmm";
        version = "0.2.1.1";
-       sha256 = "08gdicnhls8y180il2k51zrcra1acw8m1qw0s2nz5w57mhfnxq31";
+       sha256 = "61e06e1daca7f0f2add080e35011672aa8ccf20f650a1a010a1e690a2d8bed21";
        libraryHaskellDepends = [
          array base data-memocombinators list-extras logfloat
        ];
@@ -69269,7 +69504,7 @@ self: {
      mkDerivation {
        pname = "hmm-hmatrix";
        version = "0.0.1";
-       sha256 = "1kkikv3spnvqms59980p8aappw3wh26y9qs2c8ykia5fpz9zag4h";
+       sha256 = "903cf5d3bfaea8383d6242e3e48d807cf07b954217a0948aae78dbabc79e71ce";
        libraryHaskellDepends = [
          array base containers explicit-exception hmatrix lazy-csv non-empty
          random semigroups transformers utility-ht
@@ -69289,7 +69524,7 @@ self: {
      mkDerivation {
        pname = "hmp3";
        version = "1.5.2.1";
-       sha256 = "0kfqzydilajcpaazpbhmpv3h18n3lx839wxmcbjlzvjc78ajblb3";
+       sha256 = "63d125153a4cee4fe562b5f33450a7c3a200c7be15aefb95ba4c2a1a9bffd84d";
        isLibrary = false;
        isExecutable = true;
        executableHaskellDepends = [
@@ -69308,7 +69543,7 @@ self: {
      mkDerivation {
        pname = "hmpfr";
        version = "0.3.3.5";
-       sha256 = "00gqrmfwg7hk21iyfbma8h4ahpxgj21wi9fcxjdms506ahk7rwf4";
+       sha256 = "c4f17c265406145d9beccca5c88390af5fa80844aa2ee76310139ec75dcdf801";
        libraryHaskellDepends = [ base integer-gmp ];
        librarySystemDepends = [ mpfr ];
        homepage = "http://code.google.com/p/hmpfr/";
@@ -69326,7 +69561,7 @@ self: {
      mkDerivation {
        pname = "hmt";
        version = "0.15";
-       sha256 = "051kgsh9nl5f1nw8a24x7ds18g6ppzbhk3d9lf74nvvnccnzg3a9";
+       sha256 = "498df72d63766f4b8ea3a98d09d7bfd73c14743b9d0885b80dae509ba07e3314";
        libraryHaskellDepends = [
          array base bytestring colour containers data-ordlist directory
          filepath lazy-csv logict multiset-comb parsec permutation primes
@@ -69344,7 +69579,7 @@ self: {
      mkDerivation {
        pname = "hmt-diagrams";
        version = "0.15";
-       sha256 = "1g64b31bz31x0kiivazn20s22y2w7dz9f2gw5cnfkcnjd20k7glm";
+       sha256 = "95be338168d2b2e92c2bfc09977e3b5c78213410f6ab1de3043d8cbfc258c4bc";
        libraryHaskellDepends = [
          base cairo colour filepath hcg-minus hcg-minus-cairo hmt
          html-minimalist process xml
@@ -69361,7 +69596,7 @@ self: {
      mkDerivation {
        pname = "hmumps";
        version = "0.1.1";
-       sha256 = "06bixsd7vzfj0gwv0b2880p4xx3f9j7y1snindlnlcfr1qdp9jn2";
+       sha256 = "c2ca741b0ed9316a69b3d1eae08f4c6ef44e2e40482cb0f903d2fd7d9aee7119";
        isLibrary = false;
        isExecutable = true;
        executableHaskellDepends = [
@@ -69383,7 +69618,7 @@ self: {
      mkDerivation {
        pname = "hnetcdf";
        version = "0.3.0.0";
-       sha256 = "1309kzb5jrc9yy18bir3dy3r5xhmfnbd180ky9x4l3i1m4q5r31s";
+       sha256 = "3a8c5c30a9210e4a7af213a0d0967515f692876f23c78582f7896559d69f098c";
        isLibrary = true;
        isExecutable = true;
        libraryHaskellDepends = [
@@ -69413,7 +69648,7 @@ self: {
      mkDerivation {
        pname = "hnix";
        version = "0.2.1";
-       sha256 = "1y10w6ylgrdgy271a372f14rqdkvzlmpkjl08d5zg3r84jxhy6ia";
+       sha256 = "2a1a0fbb24288ff74b4380ca792bfd7b369c4970e20c158ef0afe547bde120f8";
        isLibrary = true;
        isExecutable = true;
        libraryHaskellDepends = [
@@ -69438,7 +69673,7 @@ self: {
      mkDerivation {
        pname = "hnn";
        version = "0.2.0.0";
-       sha256 = "13i2rs1ab7kh2mzf34hckkihpbrxpxzwfcdd529zd7dynhd3psjw";
+       sha256 = "5cea3b1ab4be9df69328ad31c77fbf3daf0be39c0c92e17e15709ea582ce228e";
        libraryHaskellDepends = [
          base binary bytestring hmatrix mwc-random random vector
          vector-binary-instances zlib
@@ -69454,7 +69689,7 @@ self: {
      mkDerivation {
        pname = "hnop";
        version = "0.1";
-       sha256 = "0sfw9gmcn7qclgsgzqm9zalyxhz0mig91fabcfq3g0r98krgjnr2";
+       sha256 = "225bf9f244298337b0634bb9905eace0c3eea9faa9e2fff4a30c1fcbea4bdc69";
        isLibrary = false;
        isExecutable = true;
        executableHaskellDepends = [ base ];
@@ -69467,7 +69702,7 @@ self: {
      mkDerivation {
        pname = "ho-rewriting";
        version = "0.1";
-       sha256 = "1hmnqck385mhk140kgf8882lfa91bmip4pxbjnfpf62dwh0z39a3";
+       sha256 = "43a5f101e44d18779d95ab5f72635d2129470542c8bd094898b0163426c3b6c2";
        libraryHaskellDepends = [
          base compdata containers mtl patch-combinators
        ];
@@ -69485,7 +69720,7 @@ self: {
      mkDerivation {
        pname = "hoauth";
        version = "0.3.5";
-       sha256 = "06vk3dv2dby7wadxg4qq2bzy10hl8ix2x4vpxggwd13xy3kpzjqp";
+       sha256 = "17cb7fe7f07d84c6dfeb77932e7a441482e0ff121893d79be2c7af26761b731b";
        libraryHaskellDepends = [
          base binary bytestring crypto-pubkey-types curl dataenc entropy mtl
          old-locale random RSA SHA time utf8-string
@@ -69502,7 +69737,7 @@ self: {
      mkDerivation {
        pname = "hoauth2";
        version = "0.4.8";
-       sha256 = "14rhhk9667asdvdri9xm6jr4blrj5q1mb1g54mi94sz1vqh9hj3f";
+       sha256 = "6e489820dee16b926225e58555032e32d345b234b5a798db6e5a1d63d2843093";
        isLibrary = true;
        isExecutable = true;
        libraryHaskellDepends = [
@@ -69524,7 +69759,7 @@ self: {
      mkDerivation {
        pname = "hob";
        version = "0.0.1.0";
-       sha256 = "1m2sxbw5il818g50b0650cm5vrb7njclk09m0na6i3amx3q10xjc";
+       sha256 = "4c7610f0e8558d68940535814999b467e55d2a03c58005ca4301d158f8ea5ad4";
        isLibrary = true;
        isExecutable = true;
        libraryHaskellDepends = [
@@ -69552,7 +69787,7 @@ self: {
      mkDerivation {
        pname = "hobbes";
        version = "0.2.2";
-       sha256 = "1pri63d59q918jv1hdp2ib06m6lzw9a2b6bjyn86b2qrrx2512xd";
+       sha256 = "ad8b5044cf198b6590f572992554e29f9a6ac08ae23618b64421e154da3031df";
        isLibrary = false;
        isExecutable = true;
        executableHaskellDepends = [
@@ -69573,7 +69808,7 @@ self: {
      mkDerivation {
        pname = "hobbits";
        version = "1.1.1";
-       sha256 = "0q668jvlpqs7y3l27fk9m96aa8rzhdkz8jf0whifdb2gahlhx9hs";
+       sha256 = "1aa60e29544face622e4c049f467833f23a54caa69ba23e8f047e34bb744c660";
        libraryHaskellDepends = [
          base deepseq haskell-src-exts haskell-src-meta mtl syb tagged
          template-haskell th-expand-syns transformers type-equality
@@ -69591,7 +69826,7 @@ self: {
      mkDerivation {
        pname = "hoe";
        version = "1.1.0";
-       sha256 = "0g8528jllh90f8zbrs229ms07lg7b397pm2zjccd6kriqpq1vfv0";
+       sha256 = "60bb1df0c5314fd318935fd47bd258e7d103744d42e8bc3e7220414a2512053d";
        isLibrary = false;
        isExecutable = true;
        executableHaskellDepends = [
@@ -69608,7 +69843,7 @@ self: {
      mkDerivation {
        pname = "hofix-mtl";
        version = "1.0";
-       sha256 = "1xlsddrdv56n7ww7a377jwz43xkkckl5zygghwxs9k88wxzskvvd";
+       sha256 = "6defa97fe708cda43b87eff95fe86473f6413e97e70c75383fd694dd726b9af6";
        libraryHaskellDepends = [ base mtl star-to-star template-haskell ];
        jailbreak = true;
        description = "defining @mtl@-ready monads as * -> * fixed-points";
@@ -69623,7 +69858,7 @@ self: {
      mkDerivation {
        pname = "hog";
        version = "0.1.1";
-       sha256 = "0mmp7ymmzvhpwmwjjnin9493a81vijai7hcyqwv9wrfhdjnykb1d";
+       sha256 = "2dace9ad6cd0659e36c79ec113958c3b20351249365a2979e517ee5fab3fb756";
        isLibrary = false;
        isExecutable = true;
        executableHaskellDepends = [
@@ -69642,7 +69877,7 @@ self: {
      mkDerivation {
        pname = "hogg";
        version = "0.4.1.2";
-       sha256 = "0djgbgahhrfdpxknqfjqkqwzy7ra3d7mnxyv6n76kpldalhihklw";
+       sha256 = "9c4e1821558dde698e35db775b4f1b2a1fff399e583a6c67bfcd6508d55b4f36";
        isLibrary = true;
        isExecutable = true;
        libraryHaskellDepends = [
@@ -69659,7 +69894,7 @@ self: {
      mkDerivation {
        pname = "hogre";
        version = "0.1.5";
-       sha256 = "0ndgnflcj885ylxf8q8l71cykrpm4j6svzqxlpdynf054safq174";
+       sha256 = "e404ec94260538ebdba51dffad8d24f5e6e959381461e43af50521c9a8b3af59";
        libraryHaskellDepends = [ base cgen ];
        librarySystemDepends = [ OgreMain ];
        libraryPkgconfigDepends = [ OGRE ];
@@ -69676,7 +69911,7 @@ self: {
      mkDerivation {
        pname = "hogre-examples";
        version = "0.1.4";
-       sha256 = "10zq4qch5bs0aawvs0zg3yyz41lykg1jrna5jqxlrvbq0wfz2s5g";
+       sha256 = "af68f11d0778ed4c3b9645d92cc39b9e06f2bd1fef03bdb95240af021926f883";
        isLibrary = false;
        isExecutable = true;
        executableHaskellDepends = [ base hogre ];
@@ -69692,7 +69927,7 @@ self: {
      mkDerivation {
        pname = "hois";
        version = "0.1.0.0";
-       sha256 = "0awb7dfa77y7n88ljkcdxs63g37qyc5xkr0j7lqwzx23q83a5c4k";
+       sha256 = "93b0a206c243f4cf313d12e4d90bf3f88c378cee8d4d4911b2c79fa35c3b8b2b";
        isLibrary = true;
        isExecutable = true;
        libraryHaskellDepends = [ base ];
@@ -69709,7 +69944,7 @@ self: {
      mkDerivation {
        pname = "hoist-error";
        version = "0.1.0.2";
-       sha256 = "1485adrlm52jm5afcwa7qnfy4b1679nqjhhlsjp264wqmm0h9l0z";
+       sha256 = "1fd00441ad981323aed41442896d3a262ce29dc54771e654a952944a73530591";
        revision = "2";
        editedCabalFile = "fca4ac245a1bddf638317290deb580d05d1539c6a700b02744ce61e259e2e879";
        libraryHaskellDepends = [ base either mtl ];
@@ -69722,7 +69957,7 @@ self: {
      mkDerivation {
        pname = "hold-em";
        version = "0.1.0.0";
-       sha256 = "1j2ql6izsd85skd6l9j1qfg7pj5rf513096s9bkvqip9bb4ibr4r";
+       sha256 = "99e415c95ae946bce74ada24304271b9c87b9ec341266adad40535fda3a158c8";
        libraryHaskellDepends = [ base random safe ];
        jailbreak = true;
        description = "An engine for Texas hold'em Poker";
@@ -69734,7 +69969,7 @@ self: {
      mkDerivation {
        pname = "hole";
        version = "0.1.1";
-       sha256 = "05ba87wk9b5i5b4gsfvsj16rv91dqsmzyys6b5fkssrxh2ika36c";
+       sha256 = "cc0c35a3803d6b3d5d59467bffabc62da49d4d907a3bfdc82ab1ac34f9416a15";
        libraryHaskellDepends = [ base containers ];
        description = "Higher kinded type removal";
        license = stdenv.lib.licenses.bsd3;
@@ -69746,7 +69981,7 @@ self: {
      mkDerivation {
        pname = "holey-format";
        version = "2.1.0";
-       sha256 = "13f6f647ykssqgdqw4fp7gnr2ardxbcn41ksgs15v5dx1n1xvan1";
+       sha256 = "c1aadd830dbd955d827e7a0662d9ea2d2b91ed3bd7118edbc35a4f7f8871c68d";
        description = "None";
        license = stdenv.lib.licenses.bsd3;
        hydraPlatforms = stdenv.lib.platforms.none;
@@ -69762,7 +69997,7 @@ self: {
      mkDerivation {
        pname = "holy-project";
        version = "0.2.0.0";
-       sha256 = "05lns2xkw44g2jf2fbrpzdi5iqzq7hxkhhv86ah08hr14qiyp3sg";
+       sha256 = "4f8feb2326214304a0326843383b3cf8e35862fb372f279c148f103ebbd09616";
        isLibrary = true;
        isExecutable = true;
        libraryHaskellDepends = [
@@ -69790,7 +70025,7 @@ self: {
      mkDerivation {
        pname = "homeomorphic";
        version = "0.1";
-       sha256 = "1wm15bdz02sjgpz2n266xd50q3p6mncnv8mhimky6ps1kmzb5r6c";
+       sha256 = "cce4b27e9d415fe3678db0a26d99ade60e0c4aebc6082bfe7d520bf0db2aa1f2";
        libraryHaskellDepends = [ base containers mtl QuickCheck ];
        homepage = "http://www-users.cs.york.ac.uk/~ndm/homeomorphic/";
        description = "Homeomorphic Embedding Test";
@@ -69803,7 +70038,7 @@ self: {
      mkDerivation {
        pname = "hommage";
        version = "0.0.6";
-       sha256 = "053zv30ghm7c9idb6za44zasnn88g85z4bzbdpfpixlkvcm4sbck";
+       sha256 = "932d4d2adb93f678dd6deb2ff20b7a0859abd527447db35a4cec54f8c0d87f14";
        libraryHaskellDepends = [
          array base directory haskell98 random time
        ];
@@ -69817,7 +70052,7 @@ self: {
      mkDerivation {
        pname = "hommage-ds";
        version = "0.0.5";
-       sha256 = "0gnwpzs6kwhf2wm0nqcgwqa1pp7xwbnqh337pr62w40i76g252v4";
+       sha256 = "648b229e3911102e4cbe670c88ede2fddc1b14e68f610b2a170ef269f4bfdc3e";
        libraryHaskellDepends = [
          array base DirectSound haskell98 hommage
        ];
@@ -69836,7 +70071,7 @@ self: {
      mkDerivation {
        pname = "homplexity";
        version = "0.4.3.0";
-       sha256 = "0xw3fkbzb3jqi5sr28a69ga632c30g4xwykgd0cq8imrz70jlvam";
+       sha256 = "556d2ac1f9b9468419686f7adec903838961d44b4621917589588ef5d7748377";
        isLibrary = false;
        isExecutable = true;
        executableHaskellDepends = [
@@ -69857,7 +70092,7 @@ self: {
      mkDerivation {
        pname = "honi";
        version = "0.1.0.0";
-       sha256 = "0g1w1i78a93d10zgdy9ixkflblx9xixa493hh2cc8jzznqsp5yfi";
+       sha256 = "d1f97235b6ff4bc498807024a27aeca9d345ddec31f9f63e086d24854e0c3c3c";
        libraryHaskellDepends = [ base bytestring text ];
        librarySystemDepends = [ freenect OpenNI2 ];
        testHaskellDepends = [ base hspec HUnit ];
@@ -69872,7 +70107,7 @@ self: {
      mkDerivation {
        pname = "honk";
        version = "1.3.0.0";
-       sha256 = "102jw5j89amgvz3k3b05plpw9pjkhg1rjpjpcvpxq11x8mfdxyhf";
+       sha256 = "0efade5c453d04dcef66575e99c38353dec42fbd05ac31c7dfafaa8464e15280";
        libraryHaskellDepends = [ base ];
        homepage = "https://lambda.xyz/honk/";
        description = "Cross-platform interface to the PC speaker";
@@ -69886,7 +70121,7 @@ self: {
      mkDerivation {
        pname = "hoobuddy";
        version = "0.1.0.1";
-       sha256 = "0l1q6h0irfv3275jajvylajm2rhkfmvi1kpfan6n6z5adibh9and";
+       sha256 = "cdaa04576caa7c638d55eece107775136651a5a27e4b25cb1163bb1c01343850";
        isLibrary = false;
        isExecutable = true;
        executableHaskellDepends = [
@@ -69904,7 +70139,7 @@ self: {
      mkDerivation {
        pname = "hood";
        version = "0.2.1";
-       sha256 = "1f98v1bqrmh6cmmbsmcsdm3f250imp4rk0zi34di8fzlyqfcf2yh";
+       sha256 = "d00bc71cf6f43b141b19f18399c9ad1114e1466d9a55bd6a6506d68c57d828b9";
        libraryHaskellDepends = [ array base ];
        homepage = "http://www.ittc.ku.edu/csdl/fpg/Hood";
        description = "Debugging by observing in place";
@@ -69916,7 +70151,7 @@ self: {
      mkDerivation {
        pname = "hood-off";
        version = "0.2";
-       sha256 = "15rj6qfyhihzc5svl3dwkn387x7bbkl5am7h0kj5jjj8hv2q1pnc";
+       sha256 = "ccde80c586484a59e404f05455e85cebf483869dbc0dba75611f46e81d363297";
        libraryHaskellDepends = [ base ];
        description = "Dummy package to disable Hood without having to remove all the calls to observe";
        license = stdenv.lib.licenses.bsd3;
@@ -69928,7 +70163,7 @@ self: {
      mkDerivation {
        pname = "hood2";
        version = "0.2.1";
-       sha256 = "0iyi1zljywamfaqc0mbd1xw3gn1hq0lcdgx688rr8zliw23jix02";
+       sha256 = "02f42887e0917e943342a6bfc628c030d837780f6d55c0b07255712fe90fd147";
        libraryHaskellDepends = [ array base ];
        homepage = "http://www.ittc.ku.edu/csdl/fpg/Hood";
        description = "Debugging by observing in place";
@@ -69942,7 +70177,7 @@ self: {
      mkDerivation {
        pname = "hoodie";
        version = "0.1.0.0";
-       sha256 = "1q3wpsqz833vypqnd7ljiraiyn1klxid35mh5vyizldk3i0qqf6w";
+       sha256 = "dc388c411cb3d11ffd2eb096d162a733581f558e929e66f1f57b0cf4b1be7ce0";
        isLibrary = false;
        isExecutable = true;
        executableHaskellDepends = [
@@ -69961,7 +70196,7 @@ self: {
      mkDerivation {
        pname = "hoodle";
        version = "0.4.0";
-       sha256 = "0ygmizbhag16ifdyp8gcvs0m9vinvirn8v7jfbi2m457bllmbsmq";
+       sha256 = "b8ea55295da7902ae272f26c6473dc36ee5481deeca1eb9b8b263c05d78ff579";
        isLibrary = true;
        isExecutable = true;
        libraryHaskellDepends = [
@@ -69982,7 +70217,7 @@ self: {
      mkDerivation {
        pname = "hoodle-builder";
        version = "0.3.0";
-       sha256 = "0g4a3gf1mgf5gyniif0i2b89dz416h28171mwx7k7ivjw23gjvm7";
+       sha256 = "a76ef986e072c7334fe7359c80043481fc96d01211b818ad7fc5bd1adc1b8a3c";
        libraryHaskellDepends = [
          base blaze-builder bytestring double-conversion hoodle-types lens
          strict text
@@ -70007,7 +70242,7 @@ self: {
      mkDerivation {
        pname = "hoodle-core";
        version = "0.15.0";
-       sha256 = "04007hbnv4n3dl2yngfjzl6vrqd40yk5h9lq0ws2z33k4xa3a3rk";
+       sha256 = "330f355427738c2f3407982658a607a4e1bc0dfdd23deb056dc3926d173c0010";
        libraryHaskellDepends = [
          aeson aeson-pretty array attoparsec base base64-bytestring binary
          bytestring cairo case-insensitive cereal configurator containers
@@ -70037,7 +70272,7 @@ self: {
      mkDerivation {
        pname = "hoodle-extra";
        version = "0.1";
-       sha256 = "1mqx4qia457n8v4pdyd8mc8h7ybzx5asxm2d4p9ws5g2q4ybmshy";
+       sha256 = "1eeaba3cc1e215cdd3254dd4ae55e97ff90311aba8f976c946f614a222261dd7";
        isLibrary = false;
        isExecutable = true;
        executableHaskellDepends = [
@@ -70061,7 +70296,7 @@ self: {
      mkDerivation {
        pname = "hoodle-parser";
        version = "0.3.0";
-       sha256 = "0qp7x6csacf4w9crvmyrs7qsm9caici95qiwm11zyzyz2k9nm52g";
+       sha256 = "4f946ad314df7fff43a83ce292228b8aa5aaf1d1d9d79d59e2c431a599e9e762";
        libraryHaskellDepends = [
          attoparsec base bytestring containers either hoodle-types lens mtl
          strict text transformers xournal-types
@@ -70082,7 +70317,7 @@ self: {
      mkDerivation {
        pname = "hoodle-publish";
        version = "0.2.0";
-       sha256 = "1nx2y4f000gid9mps0xxx4l6h0nh120568h9cl45gsp6qlw3sa5m";
+       sha256 = "b5283d38c5e6ea5708650922538008d0026828e9bd037d6b6af101001cf1a2db";
        isLibrary = true;
        isExecutable = true;
        libraryHaskellDepends = [
@@ -70109,7 +70344,7 @@ self: {
      mkDerivation {
        pname = "hoodle-render";
        version = "0.5.0";
-       sha256 = "0460j9flj5cnvgv6cnchc6am0r5sw81lp67qf45rgcyjpz9q424i";
+       sha256 = "910882d3bfd2b3970b71f8984b03e2ba64509561905966f6db9615495d92c010";
        libraryHaskellDepends = [
          base base64-bytestring bytestring cairo containers directory
          filepath gd gtk hashable hoodle-types lens monad-loops mtl poppler
@@ -70128,7 +70363,7 @@ self: {
      mkDerivation {
        pname = "hoodle-types";
        version = "0.3.0";
-       sha256 = "0mkx3n1sni43665dk5ify890wdfxamxvkx1h61kzsk3c3bazngr5";
+       sha256 = "253ffbd51a6c4cfd673030f4b97b55dd350e12f22e96d98a318344ab831d7d56";
        libraryHaskellDepends = [
          base bytestring cereal containers lens mtl strict text uuid
        ];
@@ -70148,7 +70383,7 @@ self: {
      mkDerivation {
        pname = "hoogle";
        version = "4.2.41";
-       sha256 = "1gm1sw7d88vzh53myqjzls2sxc3cnk1ni31dcagkj54khh0h7f56";
+       sha256 = "a6b80301849314399f622d8c68c3b46cb0ae85a65f625f47817f23d40ed7a1be";
        isLibrary = true;
        isExecutable = true;
        libraryHaskellDepends = [
@@ -70177,14 +70412,15 @@ self: {
      }:
      mkDerivation {
        pname = "hoogle-index";
-       version = "0.4.2";
-       sha256 = "12hsajans11csbhiz7d187hx17h7s736g26cvmnahx9lgmgjgada";
+       version = "0.4.3";
+       sha256 = "353175f271d6a4df1ad8434bb9b088bada47d8dfe2f624ed4f0d1c92c7d6c380";
        isLibrary = false;
        isExecutable = true;
        executableHaskellDepends = [
          base bytestring Cabal containers directory errors filepath hoogle
          optparse-applicative process temporary transformers
        ];
+       jailbreak = true;
        homepage = "http://github.com/bgamari/hoogle-index";
        description = "Easily generate Hoogle indices for installed packages";
        license = stdenv.lib.licenses.bsd3;
@@ -70195,20 +70431,26 @@ self: {
      mkDerivation {
        pname = "hooks-dir";
        version = "0.1.1.0";
-       sha256 = "0gwdqpml8kn8xxxaq628d4way29k2f31f5av49fx7qj150h5qs5b";
+       sha256 = "ab685c202841e2d35d225b151786133309af38694818ac7aefc84e44ebc58d3f";
        libraryHaskellDepends = [ base directory process text ];
        homepage = "https://github.com/ibotty/hooks-dir";
        description = "run executables in a directory as hooks";
        license = stdenv.lib.licenses.bsd3;
      }) {};
 
-  "hoopl_3_10_1_0" = callPackage
-    ({ mkDerivation, base, containers }:
+  "hoopl_3_10_2_0" = callPackage
+    ({ mkDerivation, base, containers, filepath, mtl, parsec
+     , test-framework, test-framework-hunit
+     }:
      mkDerivation {
        pname = "hoopl";
-       version = "3.10.1.0";
-       sha256 = "1m62dcgzd17xay2nd87607ryb6hswzhsgr9irzf705h5skgibxks";
+       version = "3.10.2.0";
+       sha256 = "6740814c774e51815e8260ae1b4ac8af6ab69f02e112904450f689c4792f1121";
        libraryHaskellDepends = [ base containers ];
+       testHaskellDepends = [
+         base containers filepath mtl parsec test-framework
+         test-framework-hunit
+       ];
        homepage = "http://ghc.cs.tufts.edu/hoopl/";
        description = "A library to support dataflow analysis and optimization";
        license = stdenv.lib.licenses.bsd3;
@@ -70224,7 +70466,7 @@ self: {
      mkDerivation {
        pname = "hoovie";
        version = "0.1.1";
-       sha256 = "1g486kj7pwfvdr0a0mpfjxv9hifrkbp7120hxcfyrhx2zjmmc449";
+       sha256 = "891056abfca2c3ec1deb108870ee9ad945987697ee56a0406edbf17be43488bc";
        isLibrary = false;
        isExecutable = true;
        executableHaskellDepends = [
@@ -70247,7 +70489,7 @@ self: {
      mkDerivation {
        pname = "hopencc";
        version = "0.1.0.0";
-       sha256 = "1ygldh3r09qzpws28mnmhm3ai7h162gsafdc7nwl2f10kjnpjhyw";
+       sha256 = "dc4379ad9c203841b93dac39a59f30019ea84685d5562434bf1f2790076cf4f9";
        libraryHaskellDepends = [ base bytestring utf8-string ];
        libraryPkgconfigDepends = [ opencc ];
        libraryToolDepends = [ c2hs ];
@@ -70266,7 +70508,7 @@ self: {
      mkDerivation {
        pname = "hopencl";
        version = "0.2.1";
-       sha256 = "1kdrjr1y5wfq8bb31bkh360pvgb7ryhn9awnqszbq5d4wdwplqk8";
+       sha256 = "68627a79e3a415bcbec696ab64a1cf67bd7d811970ae30d642d8f1e24396b9cd";
        libraryHaskellDepends = [ base bytestring ];
        librarySystemDepends = [ OpenCL ];
        libraryToolDepends = [ c2hs ];
@@ -70284,22 +70526,22 @@ self: {
     ({ mkDerivation, aeson, alex, ansi-wl-pprint, array, attoparsec
      , base, base16-bytestring, binary, binary-conduit, bytestring
      , conduit, conduit-extra, containers, crypto-pubkey, cryptohash
-     , directory, errors, fgl, graphviz, happy, hOpenPGP, ixset, lens
-     , monad-loops, old-locale, openpgp-asciiarmor, optparse-applicative
-     , resourcet, text, time, transformers, unordered-containers
-     , wl-pprint-extras, yaml
+     , directory, errors, fgl, graphviz, happy, hOpenPGP, ixset-typed
+     , lens, monad-loops, old-locale, openpgp-asciiarmor
+     , optparse-applicative, resourcet, text, time, transformers
+     , unordered-containers, wl-pprint-extras, yaml
      }:
      mkDerivation {
        pname = "hopenpgp-tools";
-       version = "0.15";
-       sha256 = "1qzp1lhbg9v6q7f8yq0abfwak80krmsdih86fpmfc6riiamfin7g";
+       version = "0.16";
+       sha256 = "16793bf1bc17f28dcd41a0e9c721c0b09abc0ab7ab761cb90eb66aeeb16916c2";
        isLibrary = false;
        isExecutable = true;
        executableHaskellDepends = [
          aeson ansi-wl-pprint array attoparsec base base16-bytestring binary
          binary-conduit bytestring conduit conduit-extra containers
          crypto-pubkey cryptohash directory errors fgl graphviz hOpenPGP
-         ixset lens monad-loops old-locale openpgp-asciiarmor
+         ixset-typed lens monad-loops old-locale openpgp-asciiarmor
          optparse-applicative resourcet text time transformers
          unordered-containers wl-pprint-extras yaml
        ];
@@ -70314,7 +70556,7 @@ self: {
      mkDerivation {
        pname = "hopenssl";
        version = "1.7";
-       sha256 = "1zs69kxwz5fnm62mdscbpfz78vwnda75gyx1vxmmlisfhfslprly";
+       sha256 = "9ee64bb5834e475a6bdfa1fb578e6a966f74bebb8be95685a9d695cffb4c46ff";
        libraryHaskellDepends = [ base bytestring mtl ];
        librarySystemDepends = [ openssl ];
        homepage = "http://github.com/peti/hopenssl";
@@ -70332,7 +70574,7 @@ self: {
      mkDerivation {
        pname = "hopfield";
        version = "0.1.0.2";
-       sha256 = "1cpr3540fdrqr39p6xhb64iz2fz8mzryd19515c55522s7xjk1zw";
+       sha256 = "fc8729fbd142945258092585e6f3afe83bf123310b7673d3c83837074819f9b2";
        isLibrary = true;
        isExecutable = true;
        libraryHaskellDepends = [
@@ -70362,7 +70604,7 @@ self: {
      mkDerivation {
        pname = "hopfield-networks";
        version = "0.1.0.0";
-       sha256 = "1d3jcjk6s7raack7rvm1jzyh2fvaha6xy7k97fmq4cx22fzb48sd";
+       sha256 = "4d23b2be13a23382ab3b691edf8d826a3b01fd97a1ee7c26532a1f6da66472b4";
        isLibrary = true;
        isExecutable = true;
        libraryHaskellDepends = [ base matrix MonadRandom split vector ];
@@ -70383,7 +70625,7 @@ self: {
      mkDerivation {
        pname = "hopfli";
        version = "0.2.1.0";
-       sha256 = "1rx5kvacnzm3qmc0z8n9fhrcrac059akzh9ccq0qswl7w9m4iby3";
+       sha256 = "c3af486ae287728d01662cc13f552a80a9cc3274c9a20f58c5a37ecbd49ea5e7";
        libraryHaskellDepends = [ base bytestring zlib ];
        testHaskellDepends = [ base bytestring hspec QuickCheck zlib ];
        jailbreak = true;
@@ -70399,7 +70641,7 @@ self: {
      mkDerivation {
        pname = "hoq";
        version = "0.3";
-       sha256 = "0h9cq1qzai1kbzc77bjlm0dbkrasfj0d21ydrh86kv9jd6gr7gb7";
+       sha256 = "67bd939f6932ed6910cccd07d180745ae5b91aa854ae73d85f3344f571c02c41";
        isLibrary = false;
        isExecutable = true;
        executableHaskellDepends = [
@@ -70417,7 +70659,7 @@ self: {
      mkDerivation {
        pname = "horizon";
        version = "0.1.1";
-       sha256 = "1qx27i0xlrgcrdzp6lc06skipj888cfdxwwfrd7fyig48jn3wyd4";
+       sha256 = "a4793eac44e445ef4ecb8ef3de1c4308c91ba7368051737fcbec65da413ca2e3";
        libraryHaskellDepends = [ AC-Angle base time ];
        jailbreak = true;
        homepage = "https://github.com/intractable/horizon";
@@ -70433,7 +70675,7 @@ self: {
      mkDerivation {
        pname = "hosc";
        version = "0.15";
-       sha256 = "1yp25n159p69r32y3x7iwc55l5q9qaamj2vyl1473x8ras5afdcf";
+       sha256 = "8e35a78a5619f57148a07e0b5995c209175a0ae3f1f4e1c5c8c9dc54822de2fa";
        libraryHaskellDepends = [
          base binary blaze-builder bytestring data-binary-ieee754 network
          time transformers
@@ -70454,7 +70696,7 @@ self: {
      mkDerivation {
        pname = "hosc-json";
        version = "0.15";
-       sha256 = "0sask4nr5njf9grzigldflrbp7460z55fsam1pc3wcnsa575hxhi";
+       sha256 = "1176584e51da323ed80d556957ca07869cbb32758dbef8f34b4eda922d995a69";
        libraryHaskellDepends = [
          aeson attoparsec base bifunctors bytestring hosc json text
          unordered-containers utf8-string vector
@@ -70472,7 +70714,7 @@ self: {
      mkDerivation {
        pname = "hosc-utils";
        version = "0.15";
-       sha256 = "0zk59ig52vqym4n47yl9jgv21gszcwwbc0qc9ff0080allp6ddml";
+       sha256 = "b4b6662ea50a20009c4b0c03b638675fbf20f69389fa432ca91e6f515e4c657e";
        isLibrary = false;
        isExecutable = true;
        executableHaskellDepends = [
@@ -70491,7 +70733,7 @@ self: {
      mkDerivation {
        pname = "hostname";
        version = "1.0";
-       sha256 = "0p6gm4328946qxc295zb6vhwhf07l1fma82vd0siylnsnsqxlhwv";
+       sha256 = "9b43dab1b6da521f35685b20555da00738c8e136eb972458c786242406a9cf5c";
        libraryHaskellDepends = [ base ];
        description = "A very simple package providing a cross-platform means of determining the hostname";
        license = stdenv.lib.licenses.bsd3;
@@ -70502,7 +70744,7 @@ self: {
      mkDerivation {
        pname = "hostname-validate";
        version = "1.0.0";
-       sha256 = "0my8g4kqf9mz7ii79ff53rwkx3yv9kkn4jbm60q4b7g1rzhb3bvz";
+       sha256 = "7fafb1e0cfe19d453030754962e74cdb8f3e791ec5b974623cbf26872779c857";
        libraryHaskellDepends = [ attoparsec base bytestring ];
        description = "Validate hostnames e.g. localhost or foo.co.uk.";
        license = stdenv.lib.licenses.bsd3;
@@ -70515,7 +70757,7 @@ self: {
      mkDerivation {
        pname = "hosts-server";
        version = "0.1.1";
-       sha256 = "1g5kga58c5iqm3svs2d0d2akkibxjnh0hc1jjhjf7dzxghg2paqy";
+       sha256 = "1eab2b1e7cfdb7e32494323008a0957dc5399568a009bdf5a83816868a7ab3bc";
        isLibrary = false;
        isExecutable = true;
        executableHaskellDepends = [
@@ -70535,7 +70777,7 @@ self: {
      mkDerivation {
        pname = "hothasktags";
        version = "0.3.4";
-       sha256 = "0pnp0xkqk2l29p5kr3kjmxl7hb8g1qd198n36vmfx1x8kc8bahdy";
+       sha256 = "be41b5109ba887eeea36c3a2141a0e0f2d7868af728e3ccb4d828a896707d75e";
        isLibrary = false;
        isExecutable = true;
        executableHaskellDepends = [
@@ -70552,7 +70794,7 @@ self: {
      mkDerivation {
        pname = "hotswap";
        version = "0.1.9.13";
-       sha256 = "1c614gvwypfqaj4gqsdimqq40i34w393vikq5hhy3d4qll2qp8hv";
+       sha256 = "1ba28b05a598b4e1212c78c63dd2e064444030aeb169fc8854d85dcff723c1b0";
        libraryHaskellDepends = [ base plugins ];
        jailbreak = true;
        homepage = "https://github.com/mikeplus64/hotswap";
@@ -70568,7 +70810,7 @@ self: {
      mkDerivation {
        pname = "hourglass";
        version = "0.2.9";
-       sha256 = "1xha17nwzxdjizbcp63d2142c6q051y77facs7xribgcl5iz2m4v";
+       sha256 = "9b54f163a1ecad98fbd14cb9737c28001b2648106d98cbd68fb2f5cfed090af6";
        libraryHaskellDepends = [ base deepseq ];
        testHaskellDepends = [
          base deepseq mtl old-locale tasty tasty-hunit tasty-quickcheck time
@@ -70583,7 +70825,7 @@ self: {
      mkDerivation {
        pname = "hourglass-fuzzy-parsing";
        version = "0.1.0.1";
-       sha256 = "188mw1z8n650y3qik98x2m70sr8q66x4l4pg34mirk6kg4mgzy37";
+       sha256 = "67f8ff2a79d3cc1c2b19ef124aba3118650d4e151da519f1f0a0188b7ee015a1";
        libraryHaskellDepends = [ base hourglass parsec ];
        homepage = "https://gitlab.com/doshitan/hourglass-fuzzy-parsing";
        description = "A small library for parsing more human friendly date/time formats";
@@ -70597,7 +70839,7 @@ self: {
      mkDerivation {
        pname = "hp2any-core";
        version = "0.11.2";
-       sha256 = "1gmw9bggw8hsp6pi0xgrryf0sqjb1aaxbwh85q5h72h4ixskwn1y";
+       sha256 = "3e583e758f048a030b2e08f2d5950a4b620d9ccff97510afb91a22fede4abcbe";
        libraryHaskellDepends = [
          attoparsec base bytestring containers directory filepath network
          old-locale process time
@@ -70616,7 +70858,7 @@ self: {
      mkDerivation {
        pname = "hp2any-graph";
        version = "0.5.4.2";
-       sha256 = "1yj1miqn265pxq2dfhx87s20vjnnxmsl3d9xdy88cbzglpx2v9il";
+       sha256 = "34a62dfaa5ef2f86906f3db54175edd6ca0d843ea843d704eeb7186171ac41fa";
        isLibrary = true;
        isExecutable = true;
        libraryHaskellDepends = [ base hp2any-core OpenGL ];
@@ -70639,7 +70881,7 @@ self: {
      mkDerivation {
        pname = "hp2any-manager";
        version = "0.4.6";
-       sha256 = "143j3ylvzyq1s2l357vzqrwdcgg6rqhnmv0awb3nvm66c9smaarv";
+       sha256 = "3b2b557562c6d46dc7e20aec6a21cee63dd678c67f9f32a8d001fbbfa91f7290";
        isLibrary = false;
        isExecutable = true;
        executableHaskellDepends = [
@@ -70657,7 +70899,7 @@ self: {
      mkDerivation {
        pname = "hp2html";
        version = "0.2";
-       sha256 = "11v0w5406d9lql5jaj2kwrvdgai9y76kbdlwpjnn2wjn36b8hdwa";
+       sha256 = "8a37889619567261adbc9cb635cdf129aad776e65348250bc534350348e16087";
        isLibrary = false;
        isExecutable = true;
        executableHaskellDepends = [ base containers filepath ];
@@ -70672,7 +70914,7 @@ self: {
      mkDerivation {
        pname = "hp2pretty";
        version = "0.6";
-       sha256 = "1bma881ljhwhzirj2q9rqf0bxx9xfy0ng2z9mrhdnaywnw4d8v4c";
+       sha256 = "8c6cd408b7dc2bdb60aee98b6781773df5be80c339612173fc9043490342aaae";
        isLibrary = false;
        isExecutable = true;
        executableHaskellDepends = [
@@ -70691,7 +70933,7 @@ self: {
      mkDerivation {
        pname = "hpack";
        version = "0.5.4";
-       sha256 = "1ghj80w5hx736hkr9z827s4f2fli5r4y0q3ka9ay706k5lj0g9xa";
+       sha256 = "aaa707242dd380e355527360e0492e913ae1883e02fd942734e37458384012be";
        isLibrary = true;
        isExecutable = true;
        libraryHaskellDepends = [
@@ -70718,7 +70960,7 @@ self: {
      mkDerivation {
        pname = "hpaco";
        version = "0.28.0.5";
-       sha256 = "03h634wwyj4d5ycvn7nmm94qcxwq9vayd7d9l44hqhka1ach4sx9";
+       sha256 = "a96b02990a6a420c09a1a99de6d54e98778649aad51ebb992f8d48cf3919060e";
        isLibrary = false;
        isExecutable = true;
        executableHaskellDepends = [
@@ -70738,7 +70980,7 @@ self: {
      mkDerivation {
        pname = "hpaco-lib";
        version = "0.28.0.5";
-       sha256 = "1n6lmkip1is6y4x5vivqv30if5di8cy35l6fs2kyg8wjxcqcsyqm";
+       sha256 = "157bcd30eb92a3e7a7d0ced0323c43b11517c1d878c75d3af146c770e3acd4d8";
        libraryHaskellDepends = [
          aeson base bytestring containers data-variant file-embed filepath
          mtl parsec safe split strict transformers
@@ -70757,7 +70999,7 @@ self: {
      mkDerivation {
        pname = "hpage";
        version = "0.12.2";
-       sha256 = "0sl2qh3l5vbijln2al7vmvxm4zhn3qsz8axvprs6jxjfbndmk78j";
+       sha256 = "129d599b5d4e766974bebb2bf4351e167e52fbaefb50252c9571ed4207c4826a";
        isLibrary = false;
        isExecutable = true;
        executableHaskellDepends = [
@@ -70777,7 +71019,7 @@ self: {
      mkDerivation {
        pname = "hpapi";
        version = "0.0.1.0";
-       sha256 = "0n07nr6mm9ssf632h30s6bqxsgvlfzpr39dhdl7vwrfyj2jvdg2s";
+       sha256 = "5abcb6a590de65be0f6db0a591ef77743fddf1321a0c2886715aa75a4db60758";
        libraryHaskellDepends = [ base ];
        librarySystemDepends = [ papi ];
        description = "Binding for the PAPI library";
@@ -70797,7 +71039,7 @@ self: {
      mkDerivation {
        pname = "hpaste";
        version = "1.2.0";
-       sha256 = "1p8dfqm93598zcnz1ksj8px6l8i7kfn9514d68gx7qxvd4xw0fnm";
+       sha256 = "d53ac03b69bbe3d31f328d8492ac9b27226afa4552cff02dfb2895912a760ddd";
        isLibrary = false;
        isExecutable = true;
        executableHaskellDepends = [
@@ -70823,7 +71065,7 @@ self: {
      mkDerivation {
        pname = "hpasteit";
        version = "0.3.3";
-       sha256 = "1jj5q1gpnajnafikwf9jmayvaimi5486fvi90fk8q4b3lg7z9awm";
+       sha256 = "95abf4cfa363118ca603296e671029b146b5bdaa32393ea353562a7b5fc045ca";
        isLibrary = false;
        isExecutable = true;
        executableHaskellDepends = [
@@ -70842,7 +71084,7 @@ self: {
      mkDerivation {
        pname = "hpc";
        version = "0.6.0.2";
-       sha256 = "1bqa9jmnjqk4jbvx2y90rz717hf2rhzbpmy9xqan97pyrkjz3rlm";
+       sha256 = "95e6f1e5ccfe9e6415eec9d7bb3eccc2c113cecf2079d1f792646269ab4c0aaf";
        libraryHaskellDepends = [
          base containers directory filepath time
        ];
@@ -70858,7 +71100,7 @@ self: {
      mkDerivation {
        pname = "hpc-coveralls";
        version = "0.9.0";
-       sha256 = "0ika073kkm8kivd0m2dhb7ysk5h7q9vsj02xf4azh3c4xpvw4086";
+       sha256 = "0601c2f7ed840df815715d00a977c20796a9fd59b0890ada8e13d539c7016a46";
        isLibrary = true;
        isExecutable = true;
        libraryHaskellDepends = [
@@ -70881,7 +71123,7 @@ self: {
      mkDerivation {
        pname = "hpc-strobe";
        version = "0.1";
-       sha256 = "1fgw4pf72684mi7s5pqvfj75s8y004rxf3ww377kyrlw1mb7405c";
+       sha256 = "ac0072560d9c663fcf199c0fd73301c0235d8e741bdfa24fac041971dc25fcb9";
        libraryHaskellDepends = [ base filepath hpc ];
        description = "Hpc-generated strobes for a running Haskell program";
        license = stdenv.lib.licenses.bsd3;
@@ -70894,7 +71136,7 @@ self: {
      mkDerivation {
        pname = "hpc-tracer";
        version = "0.3.1";
-       sha256 = "1mahyall1p96nc8z270002cdk8is9ahrd0zn0663w36ic158i3li";
+       sha256 = "918e884a60d10c3e8c01f68396a14a3aa2d99800001cf111b326dd40a9f250d5";
        isLibrary = false;
        isExecutable = true;
        executableHaskellDepends = [
@@ -70913,7 +71155,7 @@ self: {
      mkDerivation {
        pname = "hplayground";
        version = "0.1.3.1";
-       sha256 = "15yri40046lap05b762k4nk9nly8k6cbypic790zfmhj9ljjq1bv";
+       sha256 = "7b052c254d1256f7413a2c5ebf9899c8539ba6255398b30ab88a1a020089d997";
        libraryHaskellDepends = [
          base containers data-default haste-compiler haste-perch monads-tf
          transformers
@@ -70929,7 +71171,7 @@ self: {
      mkDerivation {
        pname = "hplaylist";
        version = "0.2";
-       sha256 = "01xkpsb8fjlifdz6fckwfawj1s5c4rs4slizcdr1hpij6mcdcg6y";
+       sha256 = "de3cd65835325e1872633f524d7426ace820b9727c32677e73914a8796beb307";
        isLibrary = false;
        isExecutable = true;
        executableHaskellDepends = [ base directory filepath process ];
@@ -70946,7 +71188,7 @@ self: {
      mkDerivation {
        pname = "hpodder";
        version = "1.1.6";
-       sha256 = "0gi94phkqxffxf3sq5al3cmn3zhc9vz6jql4hjsvz5nbhpdjhwda";
+       sha256 = "aa7128db85cb96bfb584846269fe4e0cfe612b1b5415ac87ebce753ce125293e";
        isLibrary = false;
        isExecutable = true;
        executableHaskellDepends = [
@@ -70970,7 +71212,7 @@ self: {
      mkDerivation {
        pname = "hpqtypes";
        version = "1.4.2";
-       sha256 = "0jmc7m47gidmhnf2dz7hqzlypw1l72n948naccab6j58hkn683kk";
+       sha256 = "730e64ec84a848b31463ca2292ac3834f0ebe9c7f0fc269c85b5c577483dac4a";
        isLibrary = true;
        isExecutable = true;
        libraryHaskellDepends = [
@@ -70998,7 +71240,7 @@ self: {
      mkDerivation {
        pname = "hprotoc";
        version = "2.1.4";
-       sha256 = "01848yssmpi0fgkgnlgwmcrmkmpdqc6yc19z91kj46sl187k2k8j";
+       sha256 = "124d310f0a541b2267483f05e60dc3edd65933abfc51fbe67320deaab5470405";
        isLibrary = true;
        isExecutable = true;
        libraryHaskellDepends = [
@@ -71027,7 +71269,7 @@ self: {
      mkDerivation {
        pname = "hprotoc-fork";
        version = "2.0.16.1";
-       sha256 = "1fbpdi4mcc66z3ina01dkqxhy8slcjs4irh03ll2msp6p5vdqw9r";
+       sha256 = "3971dc76b9e6ea2a281d00e648b46454230f3b9e2d0065e3f8c63056496c77b9";
        isLibrary = true;
        isExecutable = true;
        libraryHaskellDepends = [
@@ -71054,7 +71296,7 @@ self: {
      mkDerivation {
        pname = "hps";
        version = "0.15";
-       sha256 = "0kmmrjg93rr6cjmg5n821p00qr4m3q46nnyfhql2s2nf20p7kprh";
+       sha256 = "30df792e10ce0a2d2886ce5b6b081e95640cc00d02d9f2aa6426e7919eccb54e";
        isLibrary = true;
        isExecutable = true;
        libraryHaskellDepends = [ base hcg-minus ];
@@ -71071,7 +71313,7 @@ self: {
      mkDerivation {
        pname = "hps-cairo";
        version = "0.11";
-       sha256 = "1xyk0q6qiqcqd849km86jns4bcfmyrvikg0zw44929wlmlbf0hg7";
+       sha256 = "e741e016ad94279108e11fbc1977f6d5b145b49506d599086a98e1880d06d3f7";
        isLibrary = true;
        isExecutable = true;
        libraryHaskellDepends = [ base cairo gtk hps ];
@@ -71088,7 +71330,7 @@ self: {
      mkDerivation {
        pname = "hps-kmeans";
        version = "0.1.0.0";
-       sha256 = "0w1yyrv4k7fi016084j4k1lh6jgxg5502r83zszr9cjc6rraj8fc";
+       sha256 = "cc21a972364cb294bffe0365014a79fd490369984412044c00d19d4976f63e70";
        libraryHaskellDepends = [ base vector ];
        jailbreak = true;
        homepage = "http://stathacking.com/hps-kmeans";
@@ -71101,7 +71343,7 @@ self: {
      mkDerivation {
        pname = "hpuz";
        version = "1.1.2";
-       sha256 = "04k9hdbc3ipn9z0qzzpm6xsiv0bkr1v48sfs2haapawd49bw7rhk";
+       sha256 = "13e6c357228dabab1414da694476c873811d7537f5fe8fc14ff6c6c156836912";
        libraryHaskellDepends = [ array base bytestring parsec ];
        libraryToolDepends = [ c2hs ];
        homepage = "https://github.com/ccasin/hpuz";
@@ -71115,7 +71357,7 @@ self: {
      mkDerivation {
        pname = "hpygments";
        version = "0.1.3";
-       sha256 = "1hb9yslb94ynzlphsp0i4f547zqxblrj49hqy4d7zivdqp38lqla";
+       sha256 = "8a628ac6c56dc77f1af1182622335d1dff438a23115c0d2ffdd693b4a8f669c1";
        libraryHaskellDepends = [
          aeson base bytestring process process-extras
        ];
@@ -71131,7 +71373,7 @@ self: {
      mkDerivation {
        pname = "hpylos";
        version = "1.0";
-       sha256 = "1vdpy9x3bg43zj9rcrnkz0jfsd9mrp4k5y2hn6jb2ar2bvq0iwha";
+       sha256 = "0af208f05e222bb1a4b150f832c9cd3535ed24f8d3669693fc83bc357af2b7ed";
        isLibrary = false;
        isExecutable = true;
        executableHaskellDepends = [
@@ -71148,7 +71390,7 @@ self: {
      mkDerivation {
        pname = "hpyrg";
        version = "0.1.0.0";
-       sha256 = "00ddyiznx07qkh3s4qjls39x991fqxvdw2bj245ypbxpxsk9fvsw";
+       sha256 = "5c6f97a6eeb7afeb0b117209de76c72ea4d4d3d05462a2079cf8806e7ff4ad01";
        isLibrary = false;
        isExecutable = true;
        executableHaskellDepends = [
@@ -71167,7 +71409,7 @@ self: {
      mkDerivation {
        pname = "hquantlib";
        version = "0.0.2.5";
-       sha256 = "1n84j2bha8cgv38rl8jxsjiybwws2sc60x8pjmnkn83jpscgcqv0";
+       sha256 = "6063f698be72203b6d9517756098169af3e5a3d45d229ad1d88f2105979004d9";
        libraryHaskellDepends = [
          base containers hmatrix hmatrix-gsl hmatrix-special mersenne-random
          parallel statistics time vector vector-algorithms
@@ -71189,7 +71431,7 @@ self: {
      mkDerivation {
        pname = "hquery";
        version = "0.1.1.0";
-       sha256 = "0phlbbvkifw65ndjb4nc8ar0xx6z4sqn8xj41bg8qgr31ffpcjf8";
+       sha256 = "c849769d0b233f8cde0a447664b126dff40eb242cc92259b2d86bb38f75a145e";
        libraryHaskellDepends = [ base containers parsec text xmlhtml ];
        testHaskellDepends = [
          base bytestring filepath HUnit parsec test-framework
@@ -71204,7 +71446,7 @@ self: {
      mkDerivation {
        pname = "hranker";
        version = "0.1.1";
-       sha256 = "0hg2qjjr5pcnx62382r3d3rqvb3z7h1926lpym68869n4s19wz7d";
+       sha256 = "ed7c9e82263619844cf5971a91023c7fac8df368230b3484e996dd92a5c4e241";
        isLibrary = false;
        isExecutable = true;
        executableHaskellDepends = [ base HCL NonEmpty ];
@@ -71220,7 +71462,7 @@ self: {
      mkDerivation {
        pname = "hreader";
        version = "0.2.0";
-       sha256 = "1a0zllljfjpz6fwq2h0l5wwl1wg1v68n6r84fs70vnny0c3wl6hg";
+       sha256 = "0f1aca0703deda0d8e7604656391d9e1f140392f144081b933ff4a2729a51fa8";
        libraryHaskellDepends = [
          base exceptions hset mmorph monad-control mtl transformers-base
        ];
@@ -71234,7 +71476,7 @@ self: {
      mkDerivation {
        pname = "hricket";
        version = "0.5";
-       sha256 = "1zhp9w0rki3chb27jbzvwifsgcjxzczn3q7hh7g3d0akfbg1v47f";
+       sha256 = "ee901dde72538136de81f0e0613ffb5db2a75de4fb2f79c4826cc499014f17fe";
        isLibrary = false;
        isExecutable = true;
        executableHaskellDepends = [ base containers ];
@@ -71251,7 +71493,7 @@ self: {
      mkDerivation {
        pname = "hruby";
        version = "0.3.1.5";
-       sha256 = "1x9j3rc3kk64l8idkar35ap4y5kxh4abfssd2iphp8dqnjld3jxa";
+       sha256 = "aacbd1a8b4b8a10b6f144d6bb714817d164fae2a23abd922a2c4cc39581e32f5";
        libraryHaskellDepends = [
          aeson attoparsec base bytestring scientific stm text
          unordered-containers vector
@@ -71269,7 +71511,7 @@ self: {
      mkDerivation {
        pname = "hs-GeoIP";
        version = "0.3";
-       sha256 = "135bl4cjijq6mr485waz7aaxgkaji2fsdjhdy4v4756q6ahzcpwf";
+       sha256 = "8e5ff6a132d8944336f10dcaa69d8852cdd7953a5ff18248ae06cb2819a1ab8c";
        libraryHaskellDepends = [ base bytestring deepseq ];
        librarySystemDepends = [ GeoIP ];
        homepage = "http://github.com/ozataman/hs-GeoIP";
@@ -71283,7 +71525,7 @@ self: {
      mkDerivation {
        pname = "hs-bibutils";
        version = "5.5";
-       sha256 = "0pf5lh179rw9jkmw16ss3kiwydlj6zgfk868mjl5s57kx55z7ycm";
+       sha256 = "95f9f34be9f3145da8acc8a0e9de379236cfe31c5a9bc0eb9489e77402a4c55d";
        libraryHaskellDepends = [ base syb ];
        homepage = "http://istitutocolli.org/repos/hs-bibutils/";
        description = "Haskell bindings to bibutils, the bibliography conversion utilities";
@@ -71297,7 +71539,7 @@ self: {
      mkDerivation {
        pname = "hs-blake2";
        version = "0.0.2";
-       sha256 = "0i0yqci0z5gqmpgb0gk76grcd8mn7xql6gjalm78z6cl84vzsgh4";
+       sha256 = "043efd374194998f4ea54a3e43713fb6a2c6f233673eb0deadf8950f22c31e44";
        libraryHaskellDepends = [ base bytestring ];
        librarySystemDepends = [ b2 ];
        testHaskellDepends = [
@@ -71316,7 +71558,7 @@ self: {
      mkDerivation {
        pname = "hs-captcha";
        version = "1.0";
-       sha256 = "02dd7kli8nm01jxs0p8imqvbdr4yzqizi6bwyyr228p3wscbdsn8";
+       sha256 = "c8eab698e6e32221b2f77c99f823fe9ee4b636ae115da0bb0ca05a14e93cad09";
        libraryHaskellDepends = [ base bytestring gd random ];
        homepage = "http://www.dankna.com/software/";
        description = "Generate images suitable for use as CAPTCHAs in online web-form security";
@@ -71328,7 +71570,7 @@ self: {
      mkDerivation {
        pname = "hs-carbon";
        version = "0.1.1.0";
-       sha256 = "0frip4q5vxvdkc4f8bigpp066i53f4786cj2znyq21h65zndaq53";
+       sha256 = "a360d5ec2f060681bdfd4232830e71a34463c0bd2f2ee4089b6df75d30b9313b";
        libraryHaskellDepends = [ base deepseq mtl parallel random ];
        testHaskellDepends = [ base HUnit ];
        description = "A Haskell framework for parallel monte carlo simulations";
@@ -71342,7 +71584,7 @@ self: {
      mkDerivation {
        pname = "hs-carbon-examples";
        version = "0.0.0.1";
-       sha256 = "1hcg6z3slzry4lkxnv5bllmlfsr50hcyxmpz3qhsb487j9r76c2z";
+       sha256 = "5f307372920791a5211effd6ee1904256b472ba5ab6cdb27253e7faac7378fc1";
        isLibrary = false;
        isExecutable = true;
        executableHaskellDepends = [
@@ -71360,7 +71602,7 @@ self: {
      mkDerivation {
        pname = "hs-cdb";
        version = "0.1.1";
-       sha256 = "07pkz35mmk7qaa9ahfxmj4dddja23ksn7dm1fp8g9v8z8d9r9zl0";
+       sha256 = "80fe9453431fedf4d075a1b663f51c42c9d61a91b53ba89252f8cc5acbf8f31e";
        libraryHaskellDepends = [
          array base bytestring bytestring-mmap directory filepath mtl
        ];
@@ -71375,7 +71617,7 @@ self: {
      mkDerivation {
        pname = "hs-dotnet";
        version = "0.4.0";
-       sha256 = "1l2h1zv63c25k80gljnan3vg2r25a4b7byf5yryj3cjwa9xcg457";
+       sha256 = "a790c77a525cb2217df6c5f97516514564f1f6b0ca4afa009a45b061f60f50d0";
        libraryHaskellDepends = [ base ghc-prim ];
        librarySystemDepends = [ ole32 oleaut32 ];
        description = "Pragmatic .NET interop for Haskell";
@@ -71390,7 +71632,7 @@ self: {
      mkDerivation {
        pname = "hs-excelx";
        version = "0.6.0.0";
-       sha256 = "12hpfad8wn4r811md6269w10inx6nbipryhn8vdhbbcj9mmda3l5";
+       sha256 = "850ed56a4d92ad05db4616fa7ce3b2a6db08024f469856434099588e9a72178a";
        libraryHaskellDepends = [
          base bytestring containers mtl text time xml-conduit zip-archive
        ];
@@ -71404,7 +71646,7 @@ self: {
      mkDerivation {
        pname = "hs-ffmpeg";
        version = "0.3.4";
-       sha256 = "0j52drd3pb6ssgngfqxdsvvjjnx11nsmxwjsin6cmbv0nifpyq51";
+       sha256 = "a1607f5db460afca8c8d5af25eb50da15b29f7d6ad63f7ecd3daac3b5a6ea248";
        libraryHaskellDepends = [ base bytestring haskell98 ];
        jailbreak = true;
        homepage = "http://patch-tag.com/r/VasylPasternak/hs-ffmpeg";
@@ -71418,7 +71660,7 @@ self: {
      mkDerivation {
        pname = "hs-fltk";
        version = "0.2.5";
-       sha256 = "0nbxfy219mz0k27d16r3ir7hk0j450gxba9wrvrz1j17mr3gvqzx";
+       sha256 = "fde3fd46ae27c8f0f3ce3ca9d51f284482094f8e239bd08e98e0d71484777d59";
        libraryHaskellDepends = [ base ];
        librarySystemDepends = [ fltk fltk_images ];
        homepage = "http://www.cs.helsinki.fi/u/ekarttun/hs-fltk/";
@@ -71432,7 +71674,7 @@ self: {
      mkDerivation {
        pname = "hs-gchart";
        version = "0.4.1";
-       sha256 = "0nmykgdzkqidxv51bhlcn4zax4zfw26s4l65z3a3405si2s5x459";
+       sha256 = "a9905eb488ba0032d4f8c550a28de0ee93ae3eb18cc215caee2de2f9db9bbe5a";
        libraryHaskellDepends = [ base mtl ];
        homepage = "http://github.com/deepakjois/hs-gchart";
        description = "Haskell wrapper for the Google Chart API";
@@ -71447,7 +71689,7 @@ self: {
      mkDerivation {
        pname = "hs-gen-iface";
        version = "0.5.0";
-       sha256 = "1mvzpn7zpk5ffyyqh214yd315dcis8zmm9p4m5099bqhfr735kws";
+       sha256 = "9acf324e7610af9440a9e4a65a3fd291b51246f3240888bd77aeccfb8fbd7fd7";
        isLibrary = false;
        isExecutable = true;
        executableHaskellDepends = [
@@ -71465,7 +71707,7 @@ self: {
      mkDerivation {
        pname = "hs-gizapp";
        version = "0.1.0.3";
-       sha256 = "1j7ws3jm52n910p08432k60w09971bpcz4j5w48a305nz1dbkscm";
+       sha256 = "95e9b95af8b680a110e14592cfee0a2725c081996210042e08c98a52e5d0fcc8";
        libraryHaskellDepends = [
          base containers directory filepath parsec process
        ];
@@ -71479,7 +71721,7 @@ self: {
      mkDerivation {
        pname = "hs-inspector";
        version = "0.5.2.0";
-       sha256 = "0w9ijl56v0gnx6arz0vvrg740kkhw0vqgkzdvmgf22z9vn99fny8";
+       sha256 = "c85b9792dde90be15eddedcf8737e0704e40cecb7b839f95e9f6816d0a953171";
        libraryHaskellDepends = [ base haskell-src ];
        testHaskellDepends = [ base haskell-src hspec ];
        description = "Haskell source code analyzer";
@@ -71495,7 +71737,7 @@ self: {
      mkDerivation {
        pname = "hs-java";
        version = "0.3.4";
-       sha256 = "1qv6zwp9fws9s6502d9afwwbsh025xfpw4vsq8wgh2i0gvlskzq7";
+       sha256 = "07ffa9e97e200af838c27a137e5d2f0240bd38772a35018ad14973972eff66e3";
        libraryHaskellDepends = [
          array base binary binary-state bytestring containers
          control-monad-exception data-binary-ieee754 data-default directory
@@ -71511,7 +71753,7 @@ self: {
      mkDerivation {
        pname = "hs-json-rpc";
        version = "0.0.0.1";
-       sha256 = "0qlzylkplcb0bvh7pd8mwmc0pg69jjh8229a1hg3rhaix08mmj3c";
+       sha256 = "6cc85a11e851c13c1e0c2a0981a094c9bc0b58e515b57be05e60317a27f59f62";
        libraryHaskellDepends = [
          aeson base bytestring HTTP network text
        ];
@@ -71530,7 +71772,7 @@ self: {
      mkDerivation {
        pname = "hs-logo";
        version = "0.5.1";
-       sha256 = "0ypr4jpc12f771g3gsahbj0yjzd0ns8mmwjl90knwg267d712i13";
+       sha256 = "2344114e3b463c6e274854f25a91b6a07de9815c50e9375e38c789c0ae24f97a";
        isLibrary = false;
        isExecutable = true;
        executableHaskellDepends = [
@@ -71557,7 +71799,7 @@ self: {
      mkDerivation {
        pname = "hs-mesos";
        version = "0.20.3.0";
-       sha256 = "1d9mf35i5nwpnr5l5v75rrcwihfkpfy3ji9jwhk9k0g285bfr5dh";
+       sha256 = "b095ec5641e2819926e4324539bcbbd3c1c859cee5ec424bb697db12cb7035b5";
        isLibrary = true;
        isExecutable = true;
        libraryHaskellDepends = [
@@ -71579,7 +71821,7 @@ self: {
      mkDerivation {
        pname = "hs-nombre-generator";
        version = "0.2.1.0";
-       sha256 = "1bk278ni5bk8qcc8mbb7h26g9k5hcdl4h1ilrh8prc0kvngz8g4w";
+       sha256 = "9c3cf49fdd13b07c11cc3406486863b0ccf48c8067ad8a18c368ae122d3a62ae";
        isLibrary = false;
        isExecutable = true;
        executableHaskellDepends = [ base HandsomeSoup hxt random ];
@@ -71596,7 +71838,7 @@ self: {
      mkDerivation {
        pname = "hs-pgms";
        version = "0.1.0.1";
-       sha256 = "064sk0g8mzkqm80hfxg03qn6g1awydlw15ylikk3rs4wf7fclw30";
+       sha256 = "6070cadc719ce83ce68cd497c069f35c85672c1ee0750701aa78fe8a1e989a18";
        isLibrary = true;
        isExecutable = true;
        libraryHaskellDepends = [ array base MonadPrompt mtl random ];
@@ -71613,7 +71855,7 @@ self: {
      mkDerivation {
        pname = "hs-php-session";
        version = "0.0.9.3";
-       sha256 = "1xwdikiqy2dxyzr6wx51wy51vifsvshblx7kkhfqd7izjf87ww8f";
+       sha256 = "0e717e90933f9e861d9cf374baa0dedac51d8ae7a1746ef2f7bd098fe38c8df7";
        libraryHaskellDepends = [ base bytestring ];
        homepage = "https://github.com/elblake/hs-php-session";
        description = "PHP session and values serialization";
@@ -71625,7 +71867,7 @@ self: {
      mkDerivation {
        pname = "hs-pkg-config";
        version = "0.2.1.0";
-       sha256 = "09v2kp643asl3zpv8rbb8a7zv0h3bn5l4gxz44d71kly9qr3jkhh";
+       sha256 = "104e39324e9ece701a21bf3f428b5d0382fd8f426b65b4ef1f54ab41cc9d6227";
        revision = "1";
        editedCabalFile = "9337acf593d6f7e1d54f81886cb3736001a127e3b75ba01bd97a99d77565f784";
        libraryHaskellDepends = [ base data-default-class text ];
@@ -71643,7 +71885,7 @@ self: {
      mkDerivation {
        pname = "hs-pkpass";
        version = "0.4";
-       sha256 = "01jcl2ia8p29gg5yazpxm6cdxyskl6z895lmgh888qkf9jlzf5mf";
+       sha256 = "ae16f7a94c6e6284107c959684bea153fbde98a9fd7ee5cb7b495ca4a2a04c06";
        libraryHaskellDepends = [
          aeson attoparsec base bytestring conduit directory
          filesystem-conduit old-locale random shakespeare-text shelly
@@ -71662,7 +71904,7 @@ self: {
      mkDerivation {
        pname = "hs-re";
        version = "0.1.0";
-       sha256 = "0rx7shfjyi9k910mvzskykqxnijl8rrh08c0bkqlmqwisyhl7wbb";
+       sha256 = "6bf143a1d791e34af15c80210073465446dbf1f453ff5d414833452f1dd4a767";
        libraryHaskellDepends = [ array base regex-base regex-posix ];
        jailbreak = true;
        description = "Easy to use Regex";
@@ -71677,7 +71919,7 @@ self: {
      mkDerivation {
        pname = "hs-scrape";
        version = "0.1.0.0";
-       sha256 = "0w5zrd7xj3ccw4xkdsq20j1ki2j8sy3glzijsq5m2227szwv7y6v";
+       sha256 = "dbf8b3f9d74708510bd6327efa86d7488a38830402eb363be18c0dd94fcbbf70";
        libraryHaskellDepends = [
          base bytestring containers data-default exceptions hspec
          html-conduit lens retry safe text transformers url wreq xml-conduit
@@ -71698,7 +71940,7 @@ self: {
      mkDerivation {
        pname = "hs-twitter";
        version = "0.2.8";
-       sha256 = "1r8bd5q7d5mxmd6012mpp1yx353wzib174xd9v0mvkbb009b4mph";
+       sha256 = "f056b212006bcd5dc14ead931356fc7c94d17db8b78a004cabbd967670690be5";
        libraryHaskellDepends = [
          base HTTP json mime network old-locale old-time random utf8-string
        ];
@@ -71712,7 +71954,7 @@ self: {
      mkDerivation {
        pname = "hs-twitterarchiver";
        version = "0.2";
-       sha256 = "077mc8dn2f6x3s29pm80qi7mj6s2crdhky0vygzfqd8v23gmhqcg";
+       sha256 = "8f6158df101b35ecfef31bf8095b66421b594fc400d59b841edd38611b62f51c";
        isLibrary = false;
        isExecutable = true;
        executableHaskellDepends = [ base HTTP json mtl network pretty ];
@@ -71727,7 +71969,7 @@ self: {
      mkDerivation {
        pname = "hs-vcard";
        version = "0.1";
-       sha256 = "0qb7gsbki3ciqddxp9j46rnx64vv622n2p9vidv1b000wbmmrz15";
+       sha256 = "25fc5cebe2008015768b3b5d6185307b13d36d3644a6db5bc3918d38977e6761";
        libraryHaskellDepends = [ base old-locale time ];
        homepage = "http://qrcard.us/";
        description = "Implements the RFC 2426 vCard 3.0 spec";
@@ -71742,7 +71984,7 @@ self: {
      mkDerivation {
        pname = "hs2048";
        version = "0.1.0";
-       sha256 = "1hm9lwhq1b8i04gl3z2iw6g67slrjcrymp2fxxvykxgkff6dmkps";
+       sha256 = "faceda8c73f3f5e977ef4edcea339399ea639ee151fc411f0111ad8021a7a9c2";
        isLibrary = true;
        isExecutable = true;
        libraryHaskellDepends = [ base random ];
@@ -71764,7 +72006,7 @@ self: {
      mkDerivation {
        pname = "hs2bf";
        version = "0.6.2";
-       sha256 = "1lx0px0gicwry5i4rwgzz6jasjhp24f620w2iby9xpbvn6h3zflm";
+       sha256 = "95ba3fa0b17bdd9efc8a8203611c11174aada4f9fff14c62f199b3f840bfa0d3";
        isLibrary = false;
        isExecutable = true;
        executableHaskellDepends = [
@@ -71783,7 +72025,7 @@ self: {
      mkDerivation {
        pname = "hs2dot";
        version = "0.1.4";
-       sha256 = "0pfbclqpndlnxnvs630q8x272q13z9dfp35gp9dj6m527x78fapx";
+       sha256 = "fd2a874e3fa254235bbaaf8ceb5afa2360714447180ca3b7ed96367b3165cb5d";
        isLibrary = false;
        isExecutable = true;
        executableHaskellDepends = [
@@ -71801,7 +72043,7 @@ self: {
      mkDerivation {
        pname = "hsConfigure";
        version = "0.1.0.2";
-       sha256 = "199sza2jh3d5046yyb141b0jwh1m1p68hv4x3b5xz6vw9dzfbw3c";
+       sha256 = "6cf0e57e4b7c9bdfcb1a9d6c88cc0d35402ec10a242cef0d01a50d2885fa3aa5";
        revision = "2";
        editedCabalFile = "ab3264ebf799e07e40fd913b9061197b346a7d84145908566155231e62a45c02";
        libraryHaskellDepends = [ base directory filepath process unix ];
@@ -71817,7 +72059,7 @@ self: {
      mkDerivation {
        pname = "hsSqlite3";
        version = "0.1";
-       sha256 = "0wmsswccwcz2zd3zap0wsapzbya72cxdyzhlcch4akvwqcl9hz6a";
+       sha256 = "ca7c9828c37c4f452063147edf3a1347f9f5afd21c5cf547fbe233ce18d7ba72";
        libraryHaskellDepends = [
          base bindings-sqlite3 bytestring mtl utf8-string
        ];
@@ -71832,7 +72074,7 @@ self: {
      mkDerivation {
        pname = "hsXenCtrl";
        version = "0.2.0";
-       sha256 = "0zxmlyckp9c0i5s8vi62d3qvnilh8kl093ckqr7dchgmki4az7rp";
+       sha256 = "379faf489cf541d64ec6938d04e8449046bbf168c2c48d748980a53b99a7b57f";
        libraryHaskellDepends = [ array base bytestring dlist mtl ];
        librarySystemDepends = [ xenctrl ];
        jailbreak = true;
@@ -71850,7 +72092,7 @@ self: {
      mkDerivation {
        pname = "hsass";
        version = "0.3.0";
-       sha256 = "15x5f8zcikg1bh10sk5b2gqjfldgp4jdgwhl2k20i6h8mxjkpmdf";
+       sha256 = "aed53b65af089a08c41414f2d724b9af5127f113ab4c0d025ce1cdc83e72a597";
        libraryHaskellDepends = [
          base bytestring data-default-class filepath hlibsass monad-loops
          transformers
@@ -71868,7 +72110,7 @@ self: {
      mkDerivation {
        pname = "hsay";
        version = "1.1.0";
-       sha256 = "0qar7y4190dfv63jmzx8saxqxzh73spc2q3i6pqywdbv7zb6zvrl";
+       sha256 = "34ef6fd63f7b35eef1357160c1ae1e07fe8ebbd2a8ff2a87d9ae8114883f5961";
        isLibrary = false;
        isExecutable = true;
        executableHaskellDepends = [ base Hclip HTTP process unix ];
@@ -71884,7 +72126,7 @@ self: {
      mkDerivation {
        pname = "hsb2hs";
        version = "0.3.1";
-       sha256 = "1n7rj2q87j544d82alxhrsqhz4ix8qpwxpw3l2np7wjl0n101n4a";
+       sha256 = "8ad800820554f273ada083dfce2f463d920fb1ceb053255023a4c883b090f9d8";
        isLibrary = false;
        isExecutable = true;
        executableHaskellDepends = [
@@ -71901,7 +72143,7 @@ self: {
      mkDerivation {
        pname = "hsbackup";
        version = "0.1.1";
-       sha256 = "1g1lb43f7cdm5fjmdd64n9vl2nxlm8jpng94hyyldwv8a6x7555z";
+       sha256 = "bf9472ba5168f346bd87243d7b25aab45b4177b2c4b456a52bb5b1e3065934bc";
        isLibrary = false;
        isExecutable = true;
        executableHaskellDepends = [
@@ -71922,7 +72164,7 @@ self: {
      mkDerivation {
        pname = "hsbencher";
        version = "1.20.0.5";
-       sha256 = "1fqp0n106dnqik3p6fa60xkamls8wgg8c5sp2klgp36n3xflvy9h";
+       sha256 = "30f94d5d1fd68cfbe814571786dee348d3aa6607463973c78cd83603820517bb";
        libraryHaskellDepends = [
          async base bytestring containers data-default directory filepath
          GenericPretty io-streams mtl process random time unix
@@ -71943,7 +72185,7 @@ self: {
      mkDerivation {
        pname = "hsbencher-codespeed";
        version = "0.1.0.1";
-       sha256 = "1a3hac73mzd0q25b1xbdh121k33m12phpxfn6hh7qcg5yys2i8l5";
+       sha256 = "85a228b4f7e5317c2034d6f50baf08758c1944806df5b08ac0a0fd3a0e5370a8";
        libraryHaskellDepends = [
          base bytestring containers data-default directory filepath
          hsbencher HTTP http-conduit http-types json mtl network resourcet
@@ -71961,7 +72203,7 @@ self: {
      mkDerivation {
        pname = "hsbencher-fusion";
        version = "0.3.15.2";
-       sha256 = "0xp2jm5zvrx5sz2mniachd7hjmhmf0sv9as3dzln8693n6l1ak4r";
+       sha256 = "994c15a8b1231964e96f43abb435701556094f834c455bc5d7a5e7fd4b95e276";
        isLibrary = true;
        isExecutable = true;
        libraryHaskellDepends = [
@@ -71981,7 +72223,7 @@ self: {
      mkDerivation {
        pname = "hsc2hs";
        version = "0.67.20120610";
-       sha256 = "0kfvpsapgslxywpmqba5vcx79xmbj87dwg8fjjjk517x28wisivz";
+       sha256 = "7f471d3912fd8432a5940e3dde0e92abf6743adb452d5c2ff79dea7795bedb4d";
        isLibrary = false;
        isExecutable = true;
        executableHaskellDepends = [ base containers directory process ];
@@ -71999,7 +72241,7 @@ self: {
      mkDerivation {
        pname = "hsc3";
        version = "0.15.1";
-       sha256 = "1ad5q4rq82v7l556rinaiikglr1kjswi5raw0dxqwsfjbp8imbha";
+       sha256 = "0aae1ad15dd2698e7b035ce512b9963364fa668ccac66c4aa1670b8433c1a5a9";
        libraryHaskellDepends = [
          base binary bytestring containers data-default data-ordlist
          directory filepath hashable hosc network process random safe split
@@ -72016,7 +72258,7 @@ self: {
      mkDerivation {
        pname = "hsc3-auditor";
        version = "0.15";
-       sha256 = "02p4y06p08mizdrbvl52364szksrwnx28s992prw8b2ilav11563";
+       sha256 = "c39410b6a2512cc4f315296924bae559cfaf8919a2d0bd72fbb122700df0e40a";
        libraryHaskellDepends = [
          base filepath hmt hosc hsc3 hsc3-sf-hsndfile
        ];
@@ -72030,7 +72272,7 @@ self: {
      mkDerivation {
        pname = "hsc3-cairo";
        version = "0.14";
-       sha256 = "1f62mfjssky7igbp1nx2zf1azbih76m65xydnf5akp8pim7nzmis";
+       sha256 = "3ad66f4f8d17dda98ab3cdf762aa3930aeaf82fba2db70d78bc74fada5abc2b8";
        libraryHaskellDepends = [ base cairo gtk hosc hsc3 split ];
        jailbreak = true;
        homepage = "http://rd.slavepianos.org/?t=hsc3-cairo";
@@ -72046,7 +72288,7 @@ self: {
      mkDerivation {
        pname = "hsc3-data";
        version = "0.15";
-       sha256 = "0321rnajfiwldwwpns78im842hypykc1js7flnasld7al6m7487d";
+       sha256 = "ed2072aaa1ea34aa95a5ee6819d8f4d74341508de8687b396f94472795cd410c";
        libraryHaskellDepends = [
          base bifunctors Glob hcg-minus hmt hsc3-lang hsc3-plot
          hsc3-sf-hsndfile safe split SVGPath xml
@@ -72062,7 +72304,7 @@ self: {
      mkDerivation {
        pname = "hsc3-db";
        version = "0.15";
-       sha256 = "0sj3hq0d8dl4m6fn75lvyr78sg283p6y13lg8yi2yrgz74kn4zbl";
+       sha256 = "747d622739ff652fa2478f8ee0cd1d483c8d4ef69b96639da98436d40086436a";
        libraryHaskellDepends = [ base hsc3 safe ];
        homepage = "http://rd.slavepianos.org/t/hsc3-db";
        description = "Haskell SuperCollider Unit Generator Database";
@@ -72074,7 +72316,7 @@ self: {
      mkDerivation {
        pname = "hsc3-dot";
        version = "0.15";
-       sha256 = "1ck2g15zw23smry1xvn9ida8ln57vnvkxvr3khhp5didwisgm90m";
+       sha256 = "15a4fa74e42db672219c23ef3eb7dda7588a548bc9ee1e7cae7a08fe4b7862b2";
        libraryHaskellDepends = [ base directory filepath hsc3 process ];
        homepage = "http://rd.slavepianos.org/t/hsc3-dot";
        description = "haskell supercollider graph drawing";
@@ -72088,7 +72330,7 @@ self: {
      mkDerivation {
        pname = "hsc3-forth";
        version = "0.15";
-       sha256 = "0b3q6w1r12wv1fl05armkrprlkx2s7n08mimkxxndsd9kl6zl8lw";
+       sha256 = "9c22fa0d9da9e9667b9f355604ecd1a24f9a6f9e35ab02a80b9b8b900337782c";
        isLibrary = false;
        isExecutable = true;
        executableHaskellDepends = [
@@ -72111,7 +72353,7 @@ self: {
      mkDerivation {
        pname = "hsc3-graphs";
        version = "0.15";
-       sha256 = "1d59gl0shwkwi9581j7x7yy1j63acns9ccpwin4y5lwk0k5x6s38";
+       sha256 = "6868d3cb0493d3e2898dfc3296b4656a1819bc3ffdc8804a8a7c72a8017da9b4";
        isLibrary = true;
        isExecutable = true;
        libraryHaskellDepends = [
@@ -72142,7 +72384,7 @@ self: {
      mkDerivation {
        pname = "hsc3-lang";
        version = "0.15";
-       sha256 = "09qn9kb8h40cwhnjf4pl70i2vi7cn4pa4wkdwjbn07hrdpvxgihf";
+       sha256 = "0ec6d7f76d191e6097e46d72a22eb1ecc42d2238f412272de40c1088d64c1627";
        libraryHaskellDepends = [
          array base bifunctors bytestring containers data-default
          data-ordlist dlist hashable hmatrix-special hosc hsc3 MonadRandom
@@ -72161,7 +72403,7 @@ self: {
      mkDerivation {
        pname = "hsc3-lisp";
        version = "0.15";
-       sha256 = "1k45ipivvlfymvh6rzxsv1kfvd11spsn3skmsswg2vd76bcgh20x";
+       sha256 = "1d08f8d832a76df1b8d675ea61f5d521b4ed66d8baff6ce0aeded1bde38d85cc";
        isLibrary = false;
        isExecutable = true;
        executableHaskellDepends = [
@@ -72181,7 +72423,7 @@ self: {
      mkDerivation {
        pname = "hsc3-plot";
        version = "0.15";
-       sha256 = "1v5n4k54qp8ifwka2bhrq9w1kfzd3ldzhqyhvkcgl0z46xcf7lk3";
+       sha256 = "63d2e35837e403fad8dcd063f81b1dedbb1978c2192ea12677115d4cca24b6ec";
        libraryHaskellDepends = [
          base directory filepath hosc hsc3 hsc3-lang process split
          statistics vector
@@ -72200,7 +72442,7 @@ self: {
      mkDerivation {
        pname = "hsc3-process";
        version = "0.10.0";
-       sha256 = "1h769akpd5gsmmlzmhya3dh56rhpf4fkj0vl6zngahc5hl4s7qxc";
+       sha256 = "ace3a309858541f5ec377403391d71176653601bcac3fa69adfa9576a74ae6c0";
        isLibrary = true;
        isExecutable = true;
        libraryHaskellDepends = [
@@ -72218,7 +72460,7 @@ self: {
      mkDerivation {
        pname = "hsc3-rec";
        version = "0.14.1";
-       sha256 = "0m814vr41i0mm0c001vbih9i93048niljv3z8czaz32wysa8xpfl";
+       sha256 = "d4dd8e94f65c8caf3e437f6c49a345048c14138c6b070018a815c440f2260155";
        libraryHaskellDepends = [ base hsc3 ];
        jailbreak = true;
        homepage = "http://rd.slavepianos.org/?t=hsc3-rec";
@@ -72234,7 +72476,7 @@ self: {
      mkDerivation {
        pname = "hsc3-rw";
        version = "0.15";
-       sha256 = "1jcnw0a1nf4wwf5bz61bkpwd3jfgccfxmcqq06vy43pc98223z8p";
+       sha256 = "17fd21044aec0ee2b70118b3da1d63cfc9d1f89d2b98bf8ae39c381b14e096c9";
        libraryHaskellDepends = [
          base directory haskell-src-exts parsec polyparse split syb
          transformers
@@ -72254,7 +72496,7 @@ self: {
      mkDerivation {
        pname = "hsc3-server";
        version = "0.10.0";
-       sha256 = "00lw0mj76i2fqhx81d258mqdwqxy8313574i2i8vrjn0mn4bbg2p";
+       sha256 = "57bcb588adc0cabc5114919c32c240be63de704545b4803ac44e447364059c02";
        isLibrary = true;
        isExecutable = true;
        libraryHaskellDepends = [
@@ -72280,7 +72522,7 @@ self: {
      mkDerivation {
        pname = "hsc3-sf";
        version = "0.15";
-       sha256 = "1dg3gqhvi2rshfqnw7i89bd4bvqjvbk4f9g17x18swyrvgkz9wr7";
+       sha256 = "27f3f4e7dbd9738d423fe12547e6da12ef45da4a281e6eb1833a8bb8217ee3b5";
        libraryHaskellDepends = [ base bytestring hosc ];
        homepage = "http://rd.slavepianos.org/t/hsc3-sf";
        description = "Haskell SuperCollider SoundFile";
@@ -72294,7 +72536,7 @@ self: {
      mkDerivation {
        pname = "hsc3-sf-hsndfile";
        version = "0.15";
-       sha256 = "11ksss2g8a7lqpjqvdwj4j9y3kdc8algc9mhlyjmj38mgg4raa2i";
+       sha256 = "512895c97b150d59a5a7b026f6a842accde1932492b78de5c5f428f484d67a86";
        libraryHaskellDepends = [
          array base hsc3-sf hsndfile hsndfile-vector vector
        ];
@@ -72308,7 +72550,7 @@ self: {
      mkDerivation {
        pname = "hsc3-unsafe";
        version = "0.14";
-       sha256 = "0kywqx7x10hqzhq8by0f62aznrnq4y3013cxkccx1r0naajpz3yj";
+       sha256 = "d28f7fa55216e4d0199b9d8d008627d866fb95300ef88530fc1882d04fc7dc4f";
        libraryHaskellDepends = [ base hsc3 ];
        jailbreak = true;
        homepage = "http://rd.slavepianos.org/?t=hsc3-unsafe";
@@ -72324,7 +72566,7 @@ self: {
      mkDerivation {
        pname = "hsc3-utils";
        version = "0.15";
-       sha256 = "1pvg2z6n2r7jhwgwx9rv4q94jdj2ql3kgjh4smjq4xafnzzlyrix";
+       sha256 = "3d664fffb74e758265d504ca3707c542364912263ba7ce1f87f26461cd176fdf";
        isLibrary = true;
        isExecutable = true;
        libraryHaskellDepends = [
@@ -72345,7 +72587,7 @@ self: {
      mkDerivation {
        pname = "hscamwire";
        version = "0.2.1";
-       sha256 = "0alnwc170hd2dyq718nvfq5dsbnyp29j3z49w2w5k59pi9pnqybc";
+       sha256 = "6c796c6f8a379559b8e089fc2193b8de2edd0a76dba270b06fa2417002e3962a";
        libraryHaskellDepends = [ array base time unix ];
        librarySystemDepends = [ camwire_1394 dc1394_control raw1394 ];
        jailbreak = true;
@@ -72362,7 +72604,7 @@ self: {
      mkDerivation {
        pname = "hscassandra";
        version = "0.0.7";
-       sha256 = "06jr17karspq3qpan9iqh0zk2w3b2d7ghdvl8wd4hjz73yacw6f4";
+       sha256 = "c419ce941fe74b481a477437f84e136b70313f803826ab2e1ef8eaace609591a";
        libraryHaskellDepends = [
          base bytestring cassandra-thrift containers mtl network old-time
          Thrift
@@ -72378,7 +72620,7 @@ self: {
      mkDerivation {
        pname = "hscd";
        version = "0.0.3";
-       sha256 = "1wjf3gba1gfbd54d0r4xpkfq7lyvyamhfw21wnsnqsl4hvp335jr";
+       sha256 = "599631ee86846a6cb5e5417007abf2dbd383ddbc9d64d04869cbbda0d61b4ef2";
        isLibrary = true;
        isExecutable = true;
        libraryHaskellDepends = [ aeson base bytestring ghc-prim HTTP ];
@@ -72394,7 +72636,7 @@ self: {
      mkDerivation {
        pname = "hsclock";
        version = "1.0";
-       sha256 = "0g853fq9vv33nga05rhls6hk5h4gaby8mws0i8yq2iday6j576nf";
+       sha256 = "ce9a53a4f1aa45813d8a40f38afc528fc032a1d114e602d4b363ec9db01b053d";
        isLibrary = false;
        isExecutable = true;
        executableHaskellDepends = [ base cairo glib gtk old-time ];
@@ -72409,7 +72651,7 @@ self: {
      mkDerivation {
        pname = "hscolour";
        version = "1.23";
-       sha256 = "1c4i2zpami8g3w9949nm3f92g7xwh5c94vkx658zz7ihrjp7w5lp";
+       sha256 = "97167eaecc309eff51317d6e925881bc9f27921bd52692121f0fc5aaee1791b0";
        isLibrary = true;
        isExecutable = true;
        libraryHaskellDepends = [ base containers ];
@@ -72427,7 +72669,7 @@ self: {
      mkDerivation {
        pname = "hscope";
        version = "0.4.1";
-       sha256 = "1m5mp45pvf64pnpc3lsig382177vfc232bbm9g3a8q58jrwridy7";
+       sha256 = "c7b7987996a860a4c64b752d310473fb9c20d07851d3c1aebdc4b87d0bb9b5d4";
        isLibrary = false;
        isExecutable = true;
        executableHaskellDepends = [
@@ -72450,7 +72692,7 @@ self: {
      mkDerivation {
        pname = "hscrtmpl";
        version = "1.4";
-       sha256 = "1az51cv6wqjdkw0fqgi5s75rmfka3sly85022rhvk44w1vd45iii";
+       sha256 = "31c642da0e9c90b961160214e4a91e6aba9acbd1253eec009f4d626e360be5ab";
        isLibrary = false;
        isExecutable = true;
        executableHaskellDepends = [
@@ -72468,7 +72710,7 @@ self: {
      mkDerivation {
        pname = "hscuid";
        version = "1.2.0.0";
-       sha256 = "01dmxckv9rlgb87ms5xbysw2cc7prmfww8g2n98ncgnc0lh3pc5l";
+       sha256 = "b4b03b2005cc3e6651b2e221ce5dcdf73026b8f6ab175d0f5a8fe6b427ebb505";
        libraryHaskellDepends = [
          base formatting hostname random text time transformers unix
        ];
@@ -72484,7 +72726,7 @@ self: {
      mkDerivation {
        pname = "hscurses";
        version = "1.4.2.0";
-       sha256 = "0msf80475l3ncpnb1lcpnyscl1svmqg074ylb942rx7dbvck71bj";
+       sha256 = "728533d95eedf42c485ad493031eae5b07cab4b797d1b0ec6576d07208404e57";
        libraryHaskellDepends = [
          base exceptions mtl old-locale old-time unix
        ];
@@ -72498,7 +72740,7 @@ self: {
      mkDerivation {
        pname = "hscurses-fish-ex";
        version = "1.3.1";
-       sha256 = "1s7b2v3cl0nl2b55agn5wkvxn30f2bgp6mznkn33148vlbya1mzs";
+       sha256 = "fad7a0fca21b9130869df65773df120e0cdbf7e4c53e55ca12d402cac616ebe8";
        isLibrary = false;
        isExecutable = true;
        executableHaskellDepends = [ base hscurses random safe unix ];
@@ -72522,7 +72764,7 @@ self: {
      mkDerivation {
        pname = "hsdev";
        version = "0.1.4.2";
-       sha256 = "1l2pm2p0k2m8aln6an3kxswcalc7w72v7mxs5fzq0nfy60iphcys";
+       sha256 = "da33782330de5980bf2bbad7b3c5e18751c5b8ee7358652c55a88a09aea857d0";
        isLibrary = true;
        isExecutable = true;
        libraryHaskellDepends = [
@@ -72551,7 +72793,7 @@ self: {
      mkDerivation {
        pname = "hsdif";
        version = "0.14";
-       sha256 = "1wxms6z8mpyf4l1qqxi6gvscls3mwlj5aq6g3ldashzrmb7pcimm";
+       sha256 = "b54676cfaaf943ad1a1dcf605524e57568caf47e26768c0325cedf8abed1b5f3";
        libraryHaskellDepends = [ base bytestring hosc ];
        jailbreak = true;
        homepage = "http://rd.slavepianos.org/?t=hsdif";
@@ -72564,7 +72806,7 @@ self: {
      mkDerivation {
        pname = "hsdip";
        version = "0.1";
-       sha256 = "0hqwpcf2bcrj36wg02mxd2zdg07dqh4b5mv9yn295xp64snrdw84";
+       sha256 = "04f196ad26e6f69284f569d7b208c4ed80d7be68bd0af0b81932b3251cbb1c43";
        isLibrary = true;
        isExecutable = true;
        libraryHaskellDepends = [ base cairo containers HUnit parsec ];
@@ -72579,7 +72821,7 @@ self: {
      mkDerivation {
        pname = "hsdns";
        version = "1.6.1";
-       sha256 = "0s63acjy1n75k7gjm4kam7v5d4a5kn0aw178mygkqwr5frflghb4";
+       sha256 = "64c1475d7625733c9fafe804ae809d459156f6a96a922adf99e5d8e02553c368";
        libraryHaskellDepends = [ base containers network ];
        librarySystemDepends = [ adns ];
        homepage = "http://github.com/peti/hsdns";
@@ -72594,7 +72836,7 @@ self: {
      mkDerivation {
        pname = "hsdns-cache";
        version = "1.0.4";
-       sha256 = "1f0822kly602izwzxfi46w668k0jybn3khfacnxmc1744jpqr89i";
+       sha256 = "31a18caf24e40456bb65cac139ecf2124c640c3724bafef98f02184fa71008b8";
        libraryHaskellDepends = [
          base hsdns network SafeSemaphore text time unordered-containers
        ];
@@ -72609,7 +72851,7 @@ self: {
      mkDerivation {
        pname = "hse-cpp";
        version = "0.1";
-       sha256 = "0f1bgi1hnpnry1pm7jhi626afdvymzy7k0a70n07n41js46pjxd0";
+       sha256 = "a075790dd132107b8005478179fcaf7e37a78c3011ca536ff0d95e0b437c2b38";
        libraryHaskellDepends = [ base cpphs haskell-src-exts ];
        description = "Preprocess+parse haskell code";
        license = stdenv.lib.licenses.mit;
@@ -72622,7 +72864,7 @@ self: {
      mkDerivation {
        pname = "hsebaysdk";
        version = "0.3.0.0";
-       sha256 = "1bmkka53dxaizbiazici0i60qrqq2zbff95xqxlfp11v3cclcffg";
+       sha256 = "cf3946191b3b84eb68c7bd24e7d61718670c4c0491c5afe2fa51f5368a9ab3ae";
        libraryHaskellDepends = [
          aeson base bytestring http-client http-types text time transformers
          unordered-containers
@@ -72637,7 +72879,7 @@ self: {
      mkDerivation {
        pname = "hsemail";
        version = "1.7.7";
-       sha256 = "16wqrpzi5njv26za1rckn74jsqmyswndb6k38yz1567h1y4w7ai5";
+       sha256 = "25aac3890ff09812be47639ad52cd7be622dc9b193e5a0be115bda12ffcd989b";
        libraryHaskellDepends = [ base mtl old-time parsec ];
        testHaskellDepends = [ base doctest hspec old-time parsec ];
        homepage = "http://github.com/peti/hsemail";
@@ -72650,7 +72892,7 @@ self: {
      mkDerivation {
        pname = "hsemail-ns";
        version = "1.3.2";
-       sha256 = "03d0pnsba7yj5x7zrg8b80kxsnqn5g40vd2i717s1dnn3bd3vz4s";
+       sha256 = "9afc3dda1ad6b6a04f3851b40dc82b165bdd27400bbdfc4f2fd21fb5b4bda00d";
        libraryHaskellDepends = [ base mtl old-time parsec ];
        jailbreak = true;
        homepage = "http://patch-tag.com/r/hsemail-ns/home";
@@ -72666,7 +72908,7 @@ self: {
      mkDerivation {
        pname = "hsenv";
        version = "0.5";
-       sha256 = "1kjj9p8x6369g9ah9h86xlyvcm4jkahvlz2pvj1m73javbgyyf03";
+       sha256 = "0338efdfda4a8e5383dc577cbaa19a9254b63ded06c104557ac90cd3d14d52ce";
        isLibrary = false;
        isExecutable = true;
        executableHaskellDepends = [
@@ -72684,7 +72926,7 @@ self: {
      mkDerivation {
        pname = "hserv";
        version = "0.1.0.3";
-       sha256 = "1dvnkd3nwgdz9hq8zafvmn75hczsiflbf05j10nmrj8imhyh70j3";
+       sha256 = "4382033dac11c95c2d08b200b7a88bfa33588eaddba98f304cbf3d6e479b76b7";
        isLibrary = false;
        isExecutable = true;
        executableHaskellDepends = [ base cmdargs wai-app-static warp ];
@@ -72698,7 +72940,7 @@ self: {
      mkDerivation {
        pname = "hset";
        version = "1.1.0";
-       sha256 = "15ls3wkk29mf2nyrm80dcmg66q0dd0srgwyv46ix3zkaxs239mbl";
+       sha256 = "74d53484ee6afed1a321dbf39735680d60635e650da09abd15ae2631271f9a96";
        libraryHaskellDepends = [ base mtl ];
        testHaskellDepends = [ base HUnit mtl ];
        homepage = "https://bitbucket.org/s9gf4ult/hset";
@@ -72713,7 +72955,7 @@ self: {
      mkDerivation {
        pname = "hsexif";
        version = "0.6.0.4";
-       sha256 = "0k9a6d6c2n0x5g6vls4848gydnvw790lf1nyy5piz1rdzsd6bx3k";
+       sha256 = "73f4659afe2d871f6ff1de0647413a7cdbe61f228868bacd2b1d58c14c332a4d";
        libraryHaskellDepends = [
          base binary bytestring containers iconv text time
        ];
@@ -72730,7 +72972,7 @@ self: {
      mkDerivation {
        pname = "hsfacter";
        version = "0.2.1";
-       sha256 = "1j7pny0yjpx5qw2d9br723dyic4v09k1qbvrham57p9qxn9m5b0q";
+       sha256 = "18ac5293ed38dd53aa82792f1c66029bb0e8db1027afd404c7a55fe981b7f7c8";
        libraryHaskellDepends = [ base containers language-puppet text ];
        homepage = "http://lpuppet.banquise.net";
        description = "A small and ugly library that emulates the output of the puppet facter program";
@@ -72743,7 +72985,7 @@ self: {
      mkDerivation {
        pname = "hsfcsh";
        version = "0.0.1";
-       sha256 = "1fc1fk33wslfkpb83c3ax251h60d5zn2qiqyw81v19wd5r2a6kqc";
+       sha256 = "0c4fa3442e8da7b003e21e472cec2f0d18188ae86ab081d69d8e6a3ec67481b9";
        isLibrary = false;
        isExecutable = true;
        executableHaskellDepends = [
@@ -72760,7 +73002,7 @@ self: {
      mkDerivation {
        pname = "hsfilt";
        version = "0.1.0.0";
-       sha256 = "063k5f64734wvrl45nrp1yvh3bf51w3dzzf3jj4fmj1gjp07zy48";
+       sha256 = "88f87fc0952fc8ea8894c3fddf060fc5ad01b70f37db4268de9c8c438c2b7318";
        isLibrary = false;
        isExecutable = true;
        executableHaskellDepends = [ base ghc ];
@@ -72774,7 +73016,7 @@ self: {
      mkDerivation {
        pname = "hsgnutls";
        version = "0.2.3.2";
-       sha256 = "1nd3z8kb4qjaj0hic9b305c15a7g6sfx6dixz8pspvqg1x84cjnm";
+       sha256 = "d54a46500f0fefab2ffa3d36d39d36efa812580163251621904a62b226faa3d9";
        libraryHaskellDepends = [ base bytestring mtl old-time ];
        librarySystemDepends = [ gcrypt gnutls ];
        homepage = "http://www.cs.helsinki.fi/u/ekarttun/hsgnutls";
@@ -72788,7 +73030,7 @@ self: {
      mkDerivation {
        pname = "hsgnutls-yj";
        version = "0.2.3.3";
-       sha256 = "05dn7kvjxk2pnzv040hyw71nvr83jvdvajq4a9v76kcyjhhwiv0w";
+       sha256 = "1cecc821949e4d737652044bb5db9603e56dc3e11e0202f6b757cc2ef73cb615";
        libraryHaskellDepends = [ base bytestring mtl old-time ];
        librarySystemDepends = [ gcrypt gnutls ];
        homepage = "http://www.cs.helsinki.fi/u/ekarttun/hsgnutls";
@@ -72802,7 +73044,7 @@ self: {
      mkDerivation {
        pname = "hsgsom";
        version = "0.2.0";
-       sha256 = "1043lavrimaxmscayg4knx7ly0yc0gsb729pg72g897hc455r2dn";
+       sha256 = "b6895c0a61f024f4c4793789b3f403cc034f4fb7933caf98ae5dd598b7a28380";
        libraryHaskellDepends = [ base containers random stm time ];
        description = "An implementation of the GSOM clustering algorithm";
        license = stdenv.lib.licenses.bsd3;
@@ -72816,7 +73058,7 @@ self: {
      mkDerivation {
        pname = "hsgtd";
        version = "0.2";
-       sha256 = "0rsi54zhznqdycjkbkdblbfcx7lbvwdwvw0zlxqspyiz2px6lqc6";
+       sha256 = "86616afa153ffaab71a71ff0cd1bdf8b9ecedca2abcd3525f30ddb0f3f295167";
        isLibrary = false;
        isExecutable = true;
        executableHaskellDepends = [
@@ -72832,7 +73074,7 @@ self: {
      mkDerivation {
        pname = "hsharc";
        version = "0.14";
-       sha256 = "1mzi074iiz48pcy6rvgqz6ckm0zx115kmvax60bx9bfcanw686vf";
+       sha256 = "6e1b64b855ccadd417305ded3a4b08fd833a99f9f8ed6c3cbb88fc18c901f1d7";
        libraryHaskellDepends = [ base xml ];
        homepage = "http://rd.slavepianos.org/?t=hsharc";
        description = "Haskell SHARC bindings";
@@ -72847,7 +73089,7 @@ self: {
      mkDerivation {
        pname = "hsignal";
        version = "0.2.7.1";
-       sha256 = "1dzga1cgxrk7i65zrmpg22521islp4xzfc95ph7kla2acxzr6q0x";
+       sha256 = "1d60937f674a283a0fbc2531f73bb954c7208a10efd6fc8b8967e6fe5850efb7";
        libraryHaskellDepends = [
          array base binary bytestring hmatrix hmatrix-gsl hmatrix-gsl-stats
          hstatistics mtl storable-complex
@@ -72865,7 +73107,7 @@ self: {
      mkDerivation {
        pname = "hsilop";
        version = "0.1.1.0";
-       sha256 = "001wwlwxd3qb3mcpn0l5qmd7nvpy8qlrcr5j3s5111pgfi8ib0sn";
+       sha256 = "5683155174ef86108a1eb264962946fe6e7b5ac585027b591d0b8fd639e53c00";
        isLibrary = false;
        isExecutable = true;
        executableHaskellDepends = [ base haskeline ];
@@ -72882,7 +73124,7 @@ self: {
      mkDerivation {
        pname = "hsimport";
        version = "0.6.5";
-       sha256 = "10h19rdzqskjvaax30znqpvx765x0lj58wp1zgf8dv6mgvaz77zy";
+       sha256 = "fe9ff3d57ed5ec86dcfbe172542405bd98d3f7c5f683d195da726afc5b4e0182";
        isLibrary = true;
        isExecutable = true;
        libraryHaskellDepends = [
@@ -72905,7 +73147,7 @@ self: {
      mkDerivation {
        pname = "hsini";
        version = "0.4.2";
-       sha256 = "1zkrfc2zyhcwy7l1k8kn0k2qv6jkxw0d6h6bifzh6d5h01ws72mr";
+       sha256 = "b98aa37900b03403bf8bcb40d300ef539a8dc50476a219e8f19c41ff057379fe";
        libraryHaskellDepends = [ base bytestring containers mtl parsec ];
        testHaskellDepends = [
          base bytestring containers HUnit mtl parsec QuickCheck tasty
@@ -72920,7 +73162,7 @@ self: {
      mkDerivation {
        pname = "hskeleton";
        version = "0.1.1";
-       sha256 = "0f06xir28rzpwphk14gkpww8l7gbws4habhm26915idpnd4bva2w";
+       sha256 = "5ca8bd48b3b7c5129211152e0589e6eb1d8a38bff39130e1e5f7672472ec0638";
        libraryHaskellDepends = [ base Cabal ];
        description = "Skeleton for new Haskell programs";
        license = stdenv.lib.licenses.bsd3;
@@ -72932,7 +73174,7 @@ self: {
      mkDerivation {
        pname = "hslackbuilder";
        version = "0.0.2";
-       sha256 = "0j4wkw6hqajgwzik8flfzs2m5rlmy9blm98n5ym56svjypshl55q";
+       sha256 = "b8140af5f5726b53aa2f16a54a57f295e65285fe8e3a34e3e74f2a0c0d9f9c48";
        isLibrary = false;
        isExecutable = true;
        executableHaskellDepends = [
@@ -72949,7 +73191,7 @@ self: {
      mkDerivation {
        pname = "hslibsvm";
        version = "2.89.0.1";
-       sha256 = "00smw10j2ipw10133qc38famar5r6rkswj7bhvb9hdj2rrdyx6sf";
+       sha256 = "4e9bee5bce423698d686eb48ae6736b96455954383e1310208fc462141e05503";
        libraryHaskellDepends = [ base containers ];
        librarySystemDepends = [ svm ];
        description = "A FFI binding to libsvm";
@@ -72963,7 +73205,7 @@ self: {
      mkDerivation {
        pname = "hslinks";
        version = "0.6.1";
-       sha256 = "1dqicdvklkczn216qxb7gnjjgvgmr0s6iljyb33qhmmabrx5a7x1";
+       sha256 = "a11f557a5eaa5688c7585ed26834c8f5ed27a57d67756c82b09f4d3a776311b7";
        isLibrary = false;
        isExecutable = true;
        executableHaskellDepends = [
@@ -72980,7 +73222,7 @@ self: {
      mkDerivation {
        pname = "hslogger";
        version = "1.2.9";
-       sha256 = "0xml1xgkj4hjjxypnjiia7y330a0nh5fcnkwhmnrwsw7hckwqqmy";
+       sha256 = "be62cc2783876b9e6d857c5ae60ab4408131fc51314a7b7d971212395f0fb476";
        isLibrary = true;
        isExecutable = true;
        libraryHaskellDepends = [
@@ -72996,7 +73238,7 @@ self: {
      mkDerivation {
        pname = "hslogger-template";
        version = "2.0.3";
-       sha256 = "1q5g2jgx4yjzvbrc22qcxrb3r9cma64jg90wzx9yc19yxq0fa95k";
+       sha256 = "b324e500ee3e05e653ff1ca427895195a53c56ee0c0bc1f2da5f7ad29f14afe0";
        libraryHaskellDepends = [ base hslogger mtl template-haskell ];
        description = "Automatic generation of hslogger functions";
        license = stdenv.lib.licenses.publicDomain;
@@ -73007,7 +73249,7 @@ self: {
      mkDerivation {
        pname = "hslogger4j";
        version = "0.2";
-       sha256 = "0mypcdj8npygj9g8d276rhr2wagk96zc4rjimwx2ylw4qm0scv5n";
+       sha256 = "b66ca641c584532f3aaf5166c2be49f3292e32cce688865e92cf5f8b6463d757";
        libraryHaskellDepends = [ hslogger ];
        homepage = "http://hslogger4j.googlecode.com/";
        description = "DEPRECATED hslogger handlers for log4j's XMLLayout";
@@ -73026,7 +73268,7 @@ self: {
      mkDerivation {
        pname = "hslogstash";
        version = "0.3.7.1";
-       sha256 = "040564f4wxmdhglziahava5cbyhvwbiw1ifi1g3cfb9zna2xl8p6";
+       sha256 = "e622da85b23f2dc7c60bd1c5c0e3e21bfac58ada0aaaf8e983ad764e1c310510";
        libraryHaskellDepends = [
          aeson attoparsec base blaze-builder bytestring conduit containers
          data-default hedis http-conduit http-types iconv lens network
@@ -73050,7 +73292,7 @@ self: {
      mkDerivation {
        pname = "hslua";
        version = "0.4.0";
-       sha256 = "0l50ppvnavs3lc1vmrpxhlb3ffl772n1hk8mdi9w4ml64ninba3p";
+       sha256 = "77a865a3258656c2536c154d18ac38873a371685fde6ba03a3436f65f7bda050";
        revision = "2";
        editedCabalFile = "43f6956aba870857548523718d3d5645e422187964e5158d14a9c17d96671ccb";
        configureFlags = [ "-fsystem-lua" ];
@@ -73071,7 +73313,7 @@ self: {
      mkDerivation {
        pname = "hsmagick";
        version = "0.5";
-       sha256 = "1bfzbwddss0m0z4jf7i0b06pmxy9rvknpqnzhf0v5jggv5nr442p";
+       sha256 = "5710926dd9efc9b28183dfe26be7cec9f77a0d58201e27c9071568dd1a5fdfad";
        libraryHaskellDepends = [
          base bytestring directory filepath pretty process
        ];
@@ -73098,7 +73340,7 @@ self: {
      mkDerivation {
        pname = "hsmisc";
        version = "1.2";
-       sha256 = "1n2na14a5qaph0f457zvkjwr2zkbgh3mfli2ir5wkm7m1bm671aj";
+       sha256 = "528563ea0af5d4c94b8e225257077c6b7e91b99cfb9f421c8057e1a2485056d8";
        libraryHaskellDepends = [
          base containers mtl old-locale parsec time
        ];
@@ -73113,7 +73355,7 @@ self: {
      mkDerivation {
        pname = "hsmtpclient";
        version = "1.0";
-       sha256 = "08gbrwrc85in34nrgjm0zr5sjz2zbjc7hk2zlpvk1dq8x62a6wsg";
+       sha256 = "4f73a384e908b730f7a55f4c78985c5f7ca94bfea0ca972d193616c432cfeb21";
        libraryHaskellDepends = [ array base directory network old-time ];
        homepage = "http://code.google.com/p/hsmtpclient/";
        description = "Simple SMTP Client";
@@ -73126,7 +73368,7 @@ self: {
      mkDerivation {
        pname = "hsndfile";
        version = "0.7.1";
-       sha256 = "1254r811sspd7h8a4yr4ff3a6c39ywp1zjrkxbsczpxbyg9bdnv2";
+       sha256 = "62dbb6d2f3abdfcff4ea33cb1f2ef76930a38673247ba2103ced6a1d02caa488";
        libraryHaskellDepends = [ base ];
        librarySystemDepends = [ libsndfile ];
        libraryToolDepends = [ c2hs ];
@@ -73140,7 +73382,7 @@ self: {
      mkDerivation {
        pname = "hsndfile-storablevector";
        version = "0.5.2";
-       sha256 = "1n7jw14pnixiv1z50lb7yzwyyl3yd3gdfg5w0gx0m52pnmqiav9z";
+       sha256 = "3f6d1571b557940afa03bc3cd7de687e50eff9f76751507ed8b1477b49e0f2d8";
        libraryHaskellDepends = [ base hsndfile storablevector ];
        homepage = "http://haskell.org/haskellwiki/Hsndfile";
        description = "Haskell bindings for libsndfile (Data.StorableVector interface)";
@@ -73153,7 +73395,7 @@ self: {
      mkDerivation {
        pname = "hsndfile-vector";
        version = "0.5.2";
-       sha256 = "1598bf87llbiri1qh8zirhbsd94c9vhd41lf9vialqrykbmi3zig";
+       sha256 = "2ffe11eb9a3e63aae24e8e06d2e04e8ca4a617ccf1238843cc71517a905b2895";
        libraryHaskellDepends = [ base hsndfile vector ];
        homepage = "http://haskell.org/haskellwiki/Hsndfile";
        description = "Haskell bindings for libsndfile (Data.Vector interface)";
@@ -73167,7 +73409,7 @@ self: {
      mkDerivation {
        pname = "hsnock";
        version = "0.5.1";
-       sha256 = "1hh4lyrd2ki79q6pfz62icp3igzyljwa5bz8ba9vk4kxxawrnbhw";
+       sha256 = "1c2e9bb9ea7d92b9935ae8afa2b8a4febf382e8bc27c770d4e274ed1b2a704c2";
        isLibrary = true;
        isExecutable = true;
        libraryHaskellDepends = [ base parsec readline ];
@@ -73187,7 +73429,7 @@ self: {
      mkDerivation {
        pname = "hsnoise";
        version = "0.0.2";
-       sha256 = "0f8xpmzmg71l7qn1vjvzncsx8r7vfpzvlnlq0029ixf64gshbmzl";
+       sha256 = "f4d705f523c6f5980400985abaff75fb64d435b37fcb1d2c3e349c577fbd1d39";
        libraryHaskellDepends = [ base vector ];
        homepage = "https://github.com/colinhect/hsnoise";
        description = "A coherent 3d noise library";
@@ -73199,7 +73441,7 @@ self: {
      mkDerivation {
        pname = "hsns";
        version = "0.5.3";
-       sha256 = "0r3z9h5l4hxbjfcqsfk67jp2r964wgvrisk352lpx550vwd6chbf";
+       sha256 = "6e41661adfa0947ea92863ea98f7e3c4a42cae3c663a8d9993ab43420b4c7f64";
        isLibrary = false;
        isExecutable = true;
        executableHaskellDepends = [ base network pcap ];
@@ -73216,7 +73458,7 @@ self: {
      mkDerivation {
        pname = "hsnsq";
        version = "0.1.2.0";
-       sha256 = "0chmcyfar29rnsni47yx286a308rll098lxrr1zhyi7kxvh9j4fb";
+       sha256 = "cb1199e0eef3440f7fc8b9539400a51981a10c12dd1f12adb63989ac9c671532";
        libraryHaskellDepends = [
          aeson async attoparsec attoparsec-binary base bytestring containers
          hostname hslogger mtl network pipes pipes-attoparsec pipes-network
@@ -73234,7 +73476,7 @@ self: {
      mkDerivation {
        pname = "hsntp";
        version = "0.1";
-       sha256 = "0pw5l6z1yjjvcxgw71i00gfnjdqcvg09bsacazq9ahvnwsn4aayd";
+       sha256 = "cd2b45ace6764395f0574ce995c0db0c3769dd032086c35f675b4a1fbea1855f";
        isLibrary = true;
        isExecutable = true;
        libraryHaskellDepends = [ array base mtl network old-time random ];
@@ -73253,7 +73495,7 @@ self: {
      mkDerivation {
        pname = "hsoptions";
        version = "1.0.0.0";
-       sha256 = "1c4sigmagwbs3g5pj3as4f930mvba090p7cjq4cy8hbmv6cz0fn1";
+       sha256 = "c13af099d97541e419c1929d0b12506b573092235a0d79cb1b7af1a7ea8b9ab0";
        isLibrary = true;
        isExecutable = true;
        libraryHaskellDepends = [
@@ -73277,7 +73519,7 @@ self: {
      mkDerivation {
        pname = "hsp";
        version = "0.10.0";
-       sha256 = "1ayfywgrlmzivsq6lirmgvl65x1shf8041lzw2yh245rkmd91lsf";
+       sha256 = "4ed3905a9db91001bde09f060290833af462e87e35476ab0def1579a1ff7ceab";
        libraryHaskellDepends = [ base mtl text ];
        homepage = "http://hub.darcs.net/nibro/hsp";
        description = "Haskell Server Pages is a library for writing dynamic server-side web pages";
@@ -73289,7 +73531,7 @@ self: {
      mkDerivation {
        pname = "hsp-cgi";
        version = "0.4.4";
-       sha256 = "0m1xylqzmi2c1c92zk5bq6232id9fmjlx4s88ic2fvf5a389n11n";
+       sha256 = "36049bd050c56d27584448934e6575a9453184c1abcc2f120b4cc4fa31f53d54";
        libraryHaskellDepends = [ base containers harp hsp network ];
        homepage = "http://code.google.com/p/hsp";
        description = "Facilitates running Haskell Server Pages web pages as CGI programs";
@@ -73302,7 +73544,7 @@ self: {
      mkDerivation {
        pname = "hsparklines";
        version = "0.1.0";
-       sha256 = "10za4f07a5agg3zgy32fdz02vg9fl344qswhzj5mnx8wpnxmr3y6";
+       sha256 = "c68f5cbbbd1c755b8bfc906b4cc8a02ebd2dc06f4e0cfffe784f15758023ea83";
        libraryHaskellDepends = [ base bytestring dataenc gd ];
        homepage = "http://www.jasani.org/search/label/hsparklines";
        description = "Sparklines for Haskell";
@@ -73317,7 +73559,7 @@ self: {
      mkDerivation {
        pname = "hsparql";
        version = "0.2.6";
-       sha256 = "1vgdp4gz7zwh1n3iilg6kwdasfy4w48pjjgj6swr17k37irwzal4";
+       sha256 = "84aacf733c639e90b936f2497911e1c43bad1a9fe6d118870d90fff31fb9eded";
        libraryHaskellDepends = [
          base bytestring HTTP MissingH mtl network network-uri rdf4h text
          xml
@@ -73339,7 +73581,7 @@ self: {
      mkDerivation {
        pname = "hspear";
        version = "0.14";
-       sha256 = "1h3av9mpgsqfdrd817fz0isqrxn3lxmjyanw33dk9jax136ivi1h";
+       sha256 = "30c41dcd085dc934db18dc2a2f6ba7c3f68c7504df9d805a6e0eeb776bda6ac0";
        libraryHaskellDepends = [
          base bytestring bytestring-lexing split utf8-string zlib
        ];
@@ -73357,7 +73599,7 @@ self: {
      mkDerivation {
        pname = "hspec";
        version = "2.1.10";
-       sha256 = "0m51afa2n187jjx0fwarg11chakhv3z7fbmqq5rr7j60d9ix9ypq";
+       sha256 = "f8fad4636ac0c89373c1b82e77fed8702ac84278597107ba9407052b9453a154";
        libraryHaskellDepends = [
          base hspec-core hspec-discover hspec-expectations HUnit QuickCheck
          transformers
@@ -73377,7 +73619,7 @@ self: {
      mkDerivation {
        pname = "hspec-attoparsec";
        version = "0.1.0.2";
-       sha256 = "0r7v6x0k5r8jxl0rnsq8h3gqhbiimsic3kiphn6dxaw954zqnypa";
+       sha256 = "ea7a8b3f2989abde8c8537cec1a2ae312e88df80086b9b01ed12e5324137fb64";
        libraryHaskellDepends = [
          attoparsec base bytestring hspec-expectations text
        ];
@@ -73394,7 +73636,7 @@ self: {
      mkDerivation {
        pname = "hspec-checkers";
        version = "0.1.0";
-       sha256 = "043qzgjp9ch9wqm269dd87jn8wk5c90q25098hnz8ilv5pnywk6d";
+       sha256 = "cd4ceeed2d9b46f42d440914814162657264e541ad25232ae609b274e5fb7810";
        libraryHaskellDepends = [ base checkers hspec ];
        testHaskellDepends = [ base checkers hspec ];
        description = "Allows to use checkers properties from hspec";
@@ -73406,7 +73648,7 @@ self: {
      mkDerivation {
        pname = "hspec-contrib";
        version = "0.3.0";
-       sha256 = "006syw8xagfhsx06ws9ywig1qx5lk4cgl7sq6pbid1s64c72mxn4";
+       sha256 = "c4f62a0e23468716d735581ffa1899b4741c5ee43e696e40d7d03dd511f7da00";
        libraryHaskellDepends = [ base hspec-core HUnit ];
        testHaskellDepends = [ base hspec hspec-core HUnit QuickCheck ];
        homepage = "http://hspec.github.io/";
@@ -73423,7 +73665,7 @@ self: {
      mkDerivation {
        pname = "hspec-core";
        version = "2.1.10";
-       sha256 = "1q0fnag7lw54zf6aj55cckcfzs5ykpc841bczap6q9gnwrvpwbk8";
+       sha256 = "682e7e77e6f6256caefa6c0582d89dbee8efd864ac14a98cfba4707a9eb20ee0";
        libraryHaskellDepends = [
          ansi-terminal async base deepseq hspec-expectations HUnit
          QuickCheck quickcheck-io random setenv tf-random time transformers
@@ -73443,7 +73685,7 @@ self: {
      mkDerivation {
        pname = "hspec-discover";
        version = "2.1.10";
-       sha256 = "02qs0y7nn8wczjjs606d8ivixxib0024kny2al6mgvxyp524xcgg";
+       sha256 = "efb14e44b9beef570d55c2db4904002bf61e7744cd00a3a5fc8c236b8f071a0b";
        isLibrary = true;
        isExecutable = true;
        executableHaskellDepends = [ base directory filepath ];
@@ -73458,7 +73700,7 @@ self: {
      mkDerivation {
        pname = "hspec-expectations";
        version = "0.7.1";
-       sha256 = "0n52k7qwqc5awig08fvajvymb9bb235q6pp8w0cbcb9a96rwdjmg";
+       sha256 = "afcac6b3492a2db618e0e85e83cb106ba555fd966a3b045ee4aa30ccf199a258";
        libraryHaskellDepends = [ base HUnit ];
        homepage = "https://github.com/sol/hspec-expectations#readme";
        description = "Catchy combinators for HUnit";
@@ -73472,7 +73714,7 @@ self: {
      mkDerivation {
        pname = "hspec-expectations-lens";
        version = "0.4.0";
-       sha256 = "17c9qn525bmg113mw30sc35gm207rl0d6h156c7c1npnkyp1pw0k";
+       sha256 = "13f01bae9ff6dac00e332540d300cd0788faca601a0c5e4708afae228ac5899d";
        libraryHaskellDepends = [
          base hspec hspec-expectations HUnit lens
        ];
@@ -73487,7 +73729,7 @@ self: {
      mkDerivation {
        pname = "hspec-expectations-lifted";
        version = "0.5.0";
-       sha256 = "0c3fxgwxjwqgwpnlxlbp2amhk44m34iq2lxs1rxkp3vjwkqi2m8b";
+       sha256 = "0b5511f1e4728f3b7b0eba53812319959009ab1277d14eede50f73d9f9eb6e30";
        revision = "1";
        editedCabalFile = "43e88e0e7587ba1965ba3f2416500c239ad44ba19043bb249c6f307665e85208";
        libraryHaskellDepends = [ base hspec-expectations transformers ];
@@ -73503,7 +73745,7 @@ self: {
      mkDerivation {
        pname = "hspec-expectations-pretty";
        version = "0.1";
-       sha256 = "1x8xpc9b2m33sqwf7j643wjzja956m4vcdvaqrwlpxwqn887sxn5";
+       sha256 = "c5767d10b298f74b79c66a37b649352529f9251fc4c8e338d66354b112bb1df5";
        libraryHaskellDepends = [
          base deepseq hspec-expectations wl-pprint-extras wl-pprint-terminfo
        ];
@@ -73518,7 +73760,7 @@ self: {
      mkDerivation {
        pname = "hspec-experimental";
        version = "0.1.0";
-       sha256 = "197c9x25r41xmaq84xqhi0kizxi7as7jn7k9klj7pq9fmd9hcg7m";
+       sha256 = "f53c0653ab2ee17b249d691e2b8f5627f61f2788107782b0aa3d905c444feca4";
        libraryHaskellDepends = [ base hspec HUnit QuickCheck ];
        testHaskellDepends = [ base hspec-meta ];
        jailbreak = true;
@@ -73532,7 +73774,7 @@ self: {
      mkDerivation {
        pname = "hspec-jenkins";
        version = "0.1.1";
-       sha256 = "16aql0fyssc16z85isskccq93dj5i1pydblnf2q1np7z6pl1azy2";
+       sha256 = "c27f15e835ff5c1bb07096aee66f8845b691306353eb58d0378169ed1da05899";
        libraryHaskellDepends = [ base blaze-markup hspec ];
        homepage = "https://github.com/worksap-ate/hspec-jenkins";
        description = "Jenkins-friendly XML formatter for Hspec";
@@ -73544,7 +73786,7 @@ self: {
      mkDerivation {
        pname = "hspec-laws";
        version = "0.0.0";
-       sha256 = "15mcspn20znjxjsjqivrfvpndjd2i3kic5nyij13lfwyd3p2al0j";
+       sha256 = "125025ee689e3b3a828cde1616e788a2c966ef7679472cb5ecd27e20ecd5ac96";
        libraryHaskellDepends = [ base hspec QuickCheck ];
        testHaskellDepends = [ base hspec markdown-unlit QuickCheck ];
        description = "Document and test laws for standard type classes";
@@ -73559,7 +73801,7 @@ self: {
      mkDerivation {
        pname = "hspec-meta";
        version = "2.1.7";
-       sha256 = "0yh9yf9859cimd1qrh3bn65c89n16fpxzrcsily3xzr4miri7r7z";
+       sha256 = "ffe41373ac24ff3e3c8d9ae5dfaf33c126c48ab16bc08c43ab91a58292f3097a";
        isLibrary = true;
        isExecutable = true;
        libraryHaskellDepends = [
@@ -73579,7 +73821,7 @@ self: {
      mkDerivation {
        pname = "hspec-monad-control";
        version = "0.1.0.0";
-       sha256 = "07ry4nghrjbrlv6slv2a1m67r5ajdss7ifyzph0zwa96bjl1w124";
+       sha256 = "44041ea85c2629fe01bcdfbb78b46e52957c4c0d4a6caacda679c90c9f253e1f";
        libraryHaskellDepends = [
          base hspec-core monad-control transformers transformers-base
        ];
@@ -73595,7 +73837,7 @@ self: {
      mkDerivation {
        pname = "hspec-server";
        version = "0.4.1";
-       sha256 = "17bn5v3fqcmcd0qi4q9n9fj27kpw4iqyrjpjvvc4gwz1bc5bhf5q";
+       sha256 = "b838b80a5be1f347d8def2caec7124fcce23a44b3661123168ac32ecc62e769d";
        libraryHaskellDepends = [
          base containers hspec hspec-core hspec-expectations HUnit process
          regex-posix temporary transformers
@@ -73610,7 +73852,7 @@ self: {
      mkDerivation {
        pname = "hspec-shouldbe";
        version = "0.0.1";
-       sha256 = "0b4y84vqyx22kihr0sbbxzr6sdz99hi2rhyl09r8ddzkzqadfii3";
+       sha256 = "2346d714fef3b7867202d4c32c224ce9376df2ef6b6990619c42748f37419e2c";
        libraryHaskellDepends = [ hspec test-shouldbe ];
        description = "Convenience wrapper and utilities for hspec";
        license = stdenv.lib.licenses.mit;
@@ -73622,7 +73864,7 @@ self: {
      mkDerivation {
        pname = "hspec-smallcheck";
        version = "0.3.0";
-       sha256 = "1yybyrbbj0fv62cf8nh851rgbb8phyhpsm57mzn7s5vqz7lf7dxw";
+       sha256 = "bcb7e3e8f978177decafa7547da18717adf57228085ae49830db01b956f6cbfb";
        libraryHaskellDepends = [ base hspec smallcheck ];
        testHaskellDepends = [ base hspec QuickCheck smallcheck ];
        homepage = "http://hspec.github.io/";
@@ -73638,7 +73880,7 @@ self: {
      mkDerivation {
        pname = "hspec-snap";
        version = "0.3.3.0";
-       sha256 = "1ch58zz5yhvp4dq91ls05bgraf2p36aixl189zm3ipc9naidjrg4";
+       sha256 = "e465d9a2b289dd38ea4f28d01e9519573895df2a40d390702377435ffe4705b2";
        libraryHaskellDepends = [
          aeson base bytestring containers digestive-functors HandsomeSoup
          hspec hspec-core hxt lens mtl snap snap-core text transformers
@@ -73660,7 +73902,7 @@ self: {
      mkDerivation {
        pname = "hspec-test-framework";
        version = "0.1.0";
-       sha256 = "13rlyn4yibajj469hzvw6hmvm3lyra11fl73g49zc3nvcial5ldv";
+       sha256 = "bbd1425564db0ef61379e3501782ca9e8eba2b347c7f980c9152ade889f5348f";
        libraryHaskellDepends = [
          base hspec hspec-contrib hspec-core HUnit QuickCheck
        ];
@@ -73676,7 +73918,7 @@ self: {
      mkDerivation {
        pname = "hspec-test-framework-th";
        version = "0.1.0";
-       sha256 = "1apzvrbyksz5jai0i6x5y8lz1rpi2px5x9rwirhm1flbzvpdypma";
+       sha256 = "aa5edfeefe8bba50618e3ca75efa15f1e6f029f2a59b08a292e5ebe957deffaa";
        libraryHaskellDepends = [
          base hspec-test-framework language-haskell-extract template-haskell
        ];
@@ -73691,7 +73933,7 @@ self: {
      mkDerivation {
        pname = "hspec-test-sandbox";
        version = "0.1.0";
-       sha256 = "1kg7lpm1is5yxwcjhmdayxv8g52d2q215d9f8f8h33qvc7w0a8yp";
+       sha256 = "d72305f8611b8f0191432eb51204164d948776f7aa552819efbee818eaa5e7cd";
        libraryHaskellDepends = [ base hspec hspec-core test-sandbox ];
        testHaskellDepends = [ base hspec test-sandbox ];
        description = "Hspec convenience functions for use with test-sandbox";
@@ -73706,7 +73948,7 @@ self: {
      mkDerivation {
        pname = "hspec-wai";
        version = "0.6.3";
-       sha256 = "0vydfzpfwrld6wi47bk1d27hm5mz8hll3fc0ckzy7dyyzrgfnp4i";
+       sha256 = "915ceb5efedeb7e3ff6480b9412944bf960a8f6861ae4322378d66eeee77cd6f";
        libraryHaskellDepends = [
          base bytestring case-insensitive hspec-core hspec-expectations
          http-types text transformers wai wai-extra
@@ -73727,7 +73969,7 @@ self: {
      mkDerivation {
        pname = "hspec-wai-json";
        version = "0.6.1";
-       sha256 = "0sbw6iddywxdg4n8npnz6m0lmcf9nrq3ib7kckpx7shpq9khwgih";
+       sha256 = "303e0e67c217ead3ef64f3ac3870b6c9b14a4135df5e8b2c79ad73df5a347c69";
        libraryHaskellDepends = [
          aeson aeson-qq base bytestring case-insensitive hspec-wai
          template-haskell
@@ -73746,7 +73988,7 @@ self: {
      mkDerivation {
        pname = "hspec-webdriver";
        version = "1.0.2";
-       sha256 = "1wkdv129arxbfby1214a93sfqbi1kvkgvqpp4z6qzh45q74hhd9c";
+       sha256 = "2c3508c9c185c08fcd27f7e2fde69e212eecf4488a0411fc72ab679544d86df2";
        libraryHaskellDepends = [
          base data-default hashable hspec hspec-core HUnit lifted-base stm
          text transformers unordered-containers webdriver
@@ -73761,7 +74003,7 @@ self: {
      mkDerivation {
        pname = "hspec2";
        version = "0.6.1";
-       sha256 = "0zlvm7r46q8yhgx2kx9mfrf6x2f5amdbi3a59fh69dsqs4lbgmf4";
+       sha256 = "c4d5b728d158b764a04b458db85a55c5896e5c7635f529fa831e6143f2a99b7e";
        revision = "1";
        editedCabalFile = "d41ebaf2f80c6ae149a944cd77e31fce98c0eea45cf47a561c5c25d48e03107f";
        libraryHaskellDepends = [ base hspec hspec-discover ];
@@ -73775,7 +74017,7 @@ self: {
      mkDerivation {
        pname = "hspr-sh";
        version = "0.3";
-       sha256 = "1qnqg2gg93l5dp2nyvvaq7n58gsnljvbafbhfpvys48g5ry2dk7a";
+       sha256 = "eacc267c2e0f11edf7757039b5b6a4563f54ecc16a6f6fc56d858ef49e78d8e2";
        libraryHaskellDepends = [ base old-time ];
        homepage = "http://www.cs.chalmers.se/~d00nibro/hsp/";
        description = "Session handler for HSP";
@@ -73789,7 +74031,7 @@ self: {
      mkDerivation {
        pname = "hspread";
        version = "0.3.3";
-       sha256 = "1z7v5awagmhxyz4cl020s4gk4yxp0i62z3hqm9kwf73b3b69x2kf";
+       sha256 = "6e8a9ecc1a6b1cc767aa188e2f4c04b77b321fd14000cac8f71dd6a7b82afbfc";
        libraryHaskellDepends = [
          base binary bytestring containers extensible-exceptions network
        ];
@@ -73803,7 +74045,7 @@ self: {
      mkDerivation {
        pname = "hspresent";
        version = "0.2.2";
-       sha256 = "0x4f3y8l8vj1498bnw4fxw9nzf7q2y4vjys72j73h50c7hr83j07";
+       sha256 = "07c881323c0c14388e14477bb98917f8b86f13ef8e70bb5022416e44911f8e74";
        isLibrary = true;
        isExecutable = true;
        libraryHaskellDepends = [ array base bytestring vty ];
@@ -73822,7 +74064,7 @@ self: {
      mkDerivation {
        pname = "hsprocess";
        version = "0.3";
-       sha256 = "1g47g3i8fgknzyf7pp7g1mk2bfn7r7igm0c6j2v9fnahhrpj4a5z";
+       sha256 = "bf28226f86505997b6908681fae2c9c7ba25660defdc7b9cff763e87e27887bc";
        isLibrary = true;
        isExecutable = true;
        libraryHaskellDepends = [ base bytestring containers ];
@@ -73844,7 +74086,7 @@ self: {
      mkDerivation {
        pname = "hsql";
        version = "1.8.2";
-       sha256 = "0i53n42ynq22fzlz4kpmri4q4abmi4dz8bz0izn307is1pmk4bby";
+       sha256 = "7e2d32eb0d3a1e30ec8fe02ff41b8975298249ccf54ef2e9774260eb05b1a344";
        libraryHaskellDepends = [ base old-time ];
        description = "Database access from Haskell";
        license = stdenv.lib.licenses.bsd3;
@@ -73855,7 +74097,7 @@ self: {
      mkDerivation {
        pname = "hsql-mysql";
        version = "1.8.3";
-       sha256 = "0834jr5jrr1m7ap93wvmb5ir0906f7f7xx52x21i1l1jfpan34j9";
+       sha256 = "499261d57532d01083e8a2f47edc71062490635975f391ae3a35e42c4b966420";
        revision = "1";
        editedCabalFile = "e1bbb71ecb6e310acf23a93e4a5e0121c8bd332e7a81dfa5bfe27ae94cbf14ab";
        libraryHaskellDepends = [ base Cabal hsql ];
@@ -73870,7 +74112,7 @@ self: {
      mkDerivation {
        pname = "hsql-odbc";
        version = "1.8.2";
-       sha256 = "0lz9zjy1xgjjbabbi2hcrvsnfid6c78y2cb2703qjwr93xy54f1f";
+       sha256 = "2e38527c1f29738907386231e1d161a64567f5ce0c8ab8965a52be1ebcfce953";
        libraryHaskellDepends = [ base hsql old-time ];
        librarySystemDepends = [ unixODBC ];
        description = "A Haskell Interface to ODBC";
@@ -73882,7 +74124,7 @@ self: {
      mkDerivation {
        pname = "hsql-postgresql";
        version = "1.8.2";
-       sha256 = "0yj0jalpapjvpxmc79yd6bn93ax13pp87dipbg2c9mxf3p38jc9z";
+       sha256 = "3f3189c61daed7c4c45b37b683ee1da1ab91ec32cda7c36abf5b5e75a992407a";
        libraryHaskellDepends = [ base hsql old-time ];
        librarySystemDepends = [ postgresql ];
        description = "A Haskell Interface to PostgreSQL via the PQ library";
@@ -73894,7 +74136,7 @@ self: {
      mkDerivation {
        pname = "hsql-sqlite3";
        version = "1.8.2";
-       sha256 = "15f7f4f4k1afrpmkw2k6lyx1b81hlwvwv660yh0vm2vz269mxycl";
+       sha256 = "94f95e93117f8bba01f4c098cd37a730a015baa7660a3eebcd4e85491c71c795";
        libraryHaskellDepends = [ base hsql ];
        librarySystemDepends = [ sqlite ];
        description = "SQLite3 driver for HSQL";
@@ -73908,7 +74150,7 @@ self: {
      mkDerivation {
        pname = "hsqml";
        version = "0.3.3.0";
-       sha256 = "0m0g822182q45cvl3k7ir1c6g5wzwb1c9137g1c62f3npinb0kmz";
+       sha256 = "bf4eb06cbc76386158786784c4c2e29f976758c8f1cc41372b040b1484400f54";
        libraryHaskellDepends = [
          base containers filepath tagged text transformers
        ];
@@ -73927,8 +74169,8 @@ self: {
     ({ mkDerivation, base, hsqml, qt5, template-haskell, text }:
      mkDerivation {
        pname = "hsqml-datamodel";
-       version = "0.0.0.1";
-       sha256 = "16q92q00q96kyg41xh8smp5vvkvlfrps6nj7ds1y09msdqvihw9v";
+       version = "0.1.0.0";
+       sha256 = "354c225514ae632f5429f45a75975b7b7f6f2a245f7c57cd68567eacb2f2e21f";
        libraryHaskellDepends = [ base hsqml template-haskell text ];
        libraryPkgconfigDepends = [ qt5 ];
        homepage = "https://github.com/marcinmrotek/hsqml-datamodel";
@@ -73944,7 +74186,7 @@ self: {
      mkDerivation {
        pname = "hsqml-datamodel-vinyl";
        version = "0.1.0.0";
-       sha256 = "0jg3jl1h4jf92vazyf7wb88dhrl89zm9hh21hymzy3pnc5kssd91";
+       sha256 = "2135ad6761f60effab87414098ea4f8866d8105afc38ffd516c949020395e349";
        libraryHaskellDepends = [
          base exceptions hsqml-datamodel type-list vinyl
        ];
@@ -73960,7 +74202,7 @@ self: {
      mkDerivation {
        pname = "hsqml-demo-morris";
        version = "0.3.1.0";
-       sha256 = "0zkjcll4hgsv1ji4rd48fx95hn90vl9vvdzxbirqfaf40xai58md";
+       sha256 = "ada2125507c42987735cfdb7bd13dd205958527788b44ca20c5b3f482865727e";
        isLibrary = false;
        isExecutable = true;
        executableHaskellDepends = [
@@ -73980,7 +74222,7 @@ self: {
      mkDerivation {
        pname = "hsqml-demo-notes";
        version = "0.3.3.0";
-       sha256 = "0gjlsqlspchav6lvc4ld15192x70j8cyzw903dgla7g9sj8fg813";
+       sha256 = "23a0e790d4e91d455f1b20f1ef1992e0749142098d12b6a9d90ab2ab29d6543e";
        isLibrary = false;
        isExecutable = true;
        executableHaskellDepends = [
@@ -73996,7 +74238,7 @@ self: {
      mkDerivation {
        pname = "hsqml-demo-samples";
        version = "0.3.3.0";
-       sha256 = "072k2vc6wk8r2zn2isp37p9xhi8dbg15sy5hmpj868lzbq3mzyac";
+       sha256 = "4cf95f075e9f2283e4adb0785dc25b0d45d8d33de3ea28ec17194d6ed816531c";
        isLibrary = false;
        isExecutable = true;
        executableHaskellDepends = [ base hsqml OpenGL OpenGLRaw text ];
@@ -74014,7 +74256,7 @@ self: {
      mkDerivation {
        pname = "hsqml-morris";
        version = "0.2.0.0";
-       sha256 = "1qisi1r8lljgkwc9v5p3nqq6b78vdn9wyydsp31dxqnbd1lyg5ax";
+       sha256 = "5d95e76968cbe2dec2b8ba79cf936d1b9d6530b6e3969d189f4f528a72883ae2";
        isLibrary = false;
        isExecutable = true;
        executableHaskellDepends = [
@@ -74035,7 +74277,7 @@ self: {
      mkDerivation {
        pname = "hsreadability";
        version = "1.0.0.0";
-       sha256 = "0q4sqx7xjsa8jplrdzirdlh6170ckqags02idjknwpc48plarnaw";
+       sha256 = "5cd9ace845845d6ea76c5100fd149e0c9c60206d39fe96e9954869d94fc79a60";
        revision = "1";
        editedCabalFile = "e0b87a28497a4730024ce1459c7812d519027e8b90aa863dac85dd251558fa23";
        libraryHaskellDepends = [
@@ -74057,7 +74299,7 @@ self: {
      mkDerivation {
        pname = "hsshellscript";
        version = "3.3.3";
-       sha256 = "0g8qm1nx2dzsmkn2rp1vwqgvgqpxgjambnmq81qyky66d83mgbz1";
+       sha256 = "e1af57076ac6f8e97140b8da55957cfde2b71fe63bdc2cecacfa37d16da8183d";
        libraryHaskellDepends = [ base directory parsec random unix ];
        libraryToolDepends = [ c2hs ];
        homepage = "http://www.volker-wysk.de/hsshellscript/";
@@ -74070,7 +74312,7 @@ self: {
      mkDerivation {
        pname = "hssourceinfo";
        version = "0.0.2";
-       sha256 = "07g1wsm4131ymp4ym33fx8yfs0bsqn9as65lkyg21ajc0dz2j1qa";
+       sha256 = "0a07297e034caa209e9fb418ad92c57a01ed3cea6e8ceac9ad3e8c40aae6e11d";
        isLibrary = false;
        isExecutable = true;
        executableHaskellDepends = [
@@ -74088,7 +74330,7 @@ self: {
      mkDerivation {
        pname = "hssqlppp";
        version = "0.4.2";
-       sha256 = "083mczqb5ca52ly88xhmd8244q8j1iyf0kkxmgp4w13w6sa5lwzl";
+       sha256 = "f4735a94367c044eeeab7d4ee07c0c126142046a1576843c1545b1b2f0677520";
        libraryHaskellDepends = [
          base containers mtl parsec pretty syb template-haskell transformers
          uniplate
@@ -74110,7 +74352,7 @@ self: {
      mkDerivation {
        pname = "hstatistics";
        version = "0.2.5.2";
-       sha256 = "08bkffx3d87c3cb3zp0gdj10cw1cb2m55lbqkh6b6lvxjy26igvp";
+       sha256 = "77bf6884977d53b30c9c78d152aa582c7006826c0fdc3f161beca036ba737321";
        libraryHaskellDepends = [
          array base hmatrix hmatrix-gsl-stats random vector
        ];
@@ -74125,7 +74367,7 @@ self: {
      mkDerivation {
        pname = "hstats";
        version = "0.3";
-       sha256 = "04v03gha4p0i9ymjladmzpw8mwk72s60aihk50k2ixqja976y9hj";
+       sha256 = "12266f4e5212f72826281346058c1667f28af8fdb5292aab4f115ca2e01b6013";
        libraryHaskellDepends = [ base haskell98 ];
        homepage = "http://github.com/unmarshal/hstats/";
        description = "Statistical Computing in Haskell";
@@ -74138,7 +74380,7 @@ self: {
      mkDerivation {
        pname = "hstatsd";
        version = "0.1";
-       sha256 = "092q52yyb1xdji1y72bdcgvp8by2w1z9j717sl1gmh2p89cpjrs4";
+       sha256 = "446779594257c0fa02d5271c997ee0c22f74f7636d89e34394ad87e5bd285824";
        libraryHaskellDepends = [ base bytestring mtl network text ];
        homepage = "https://github.com/mokus0/hstatsd";
        description = "Quick and dirty statsd interface";
@@ -74152,7 +74394,7 @@ self: {
      mkDerivation {
        pname = "hstest";
        version = "0.0.1";
-       sha256 = "0afvl5b82alnbdj0l26scg1qy7rln94qk9an252p83zlg5nd16gd";
+       sha256 = "ed99d06c79f40f74451156a58949b2341f8fc363da080a645b962a8156a1db29";
        isLibrary = false;
        isExecutable = true;
        executableHaskellDepends = [
@@ -74170,7 +74412,7 @@ self: {
      mkDerivation {
        pname = "hstidy";
        version = "0.2";
-       sha256 = "1hjsdxl0vn42n5kfiq42yvrr3j31sjy9g7iwjlnj2x72jff79vxs";
+       sha256 = "baef749c93e274212d953c9e97bcd461c891f3f682e0e866b182d80d686f5ac2";
        isLibrary = false;
        isExecutable = true;
        executableHaskellDepends = [ base haskell-src-exts ];
@@ -74189,7 +74431,7 @@ self: {
      mkDerivation {
        pname = "hstorchat";
        version = "0.1.1.0";
-       sha256 = "1d87s6f6qgq7sbqzdgidnn3gxz9panhdk2mfhd7263hb9mrq1k3c";
+       sha256 = "6ccc80734d0b0e234e83ae8ad9a05537fdfe86b52dbef6f1d2073f6c9cd107b5";
        isLibrary = true;
        isExecutable = true;
        libraryHaskellDepends = [
@@ -74218,7 +74460,7 @@ self: {
      mkDerivation {
        pname = "hstradeking";
        version = "0.1.0";
-       sha256 = "10wyvfha6vngrj8h8i9dx1skyz3c4g1pcx13cafix5cpim6dr64w";
+       sha256 = "9c98dc4c8d97951e9d62237476c3236c7c3f75e82d450491cccf6ea3a0db9e83";
        isLibrary = true;
        isExecutable = true;
        libraryHaskellDepends = [
@@ -74242,7 +74484,7 @@ self: {
      mkDerivation {
        pname = "hstyle";
        version = "0.2.0.3";
-       sha256 = "1a63i54zd9ls1lii4p2qzpds3q8xbcl8w8b6m53ix3n6ikpa4n35";
+       sha256 = "6558a2ee8cc68e1e47a966218e285b1de1a1dbfd585c12230d9aa6f64989c3a8";
        isLibrary = false;
        isExecutable = true;
        executableHaskellDepends = [
@@ -74261,7 +74503,7 @@ self: {
      mkDerivation {
        pname = "hstzaar";
        version = "0.9.3";
-       sha256 = "1hjf5n7m5d9bnj1rwnsf2pvs6vcfvv2hf53a6pbyb63c4rgqzk2m";
+       sha256 = "55cc8f5f266c98e5d7356a1407c5de8e6da3f7154e5b9e83b42bb5528f2d4ec2";
        isLibrary = false;
        isExecutable = true;
        executableHaskellDepends = [
@@ -74284,7 +74526,7 @@ self: {
      mkDerivation {
        pname = "hsubconvert";
        version = "0.0.2";
-       sha256 = "1sl7dxqi47x937wivdlx5yg6a4niczcz22xs3flvgsrxbx1ahy9w";
+       sha256 = "3c79a8425f3debb7a91bba0bf1d967d112659e2f9db61df919a91f12716f87ea";
        isLibrary = false;
        isExecutable = true;
        executableHaskellDepends = [
@@ -74305,7 +74547,7 @@ self: {
      mkDerivation {
        pname = "hsverilog";
        version = "0.1.0";
-       sha256 = "1qk34zl1894ra9w0w2gzg8ivz230ymgyjghsd2cwn00fcsyafa7a";
+       sha256 = "ea28a7bc660e00cb99681a3ee95ff56088bf237aff090e7852992414e82763e2";
        libraryHaskellDepends = [
          base containers shakespeare text transformers
        ];
@@ -74322,7 +74564,7 @@ self: {
      mkDerivation {
        pname = "hswip";
        version = "0.3";
-       sha256 = "11nlpnfjnypz76m2padkz7ppjdir1vz3bp65s9wzphvnsmp3a681";
+       sha256 = "0119356ed576c3fb79d2c5dc35fe0e393679eff9b3a92baa39ff7a2b9dbdd486";
        libraryHaskellDepends = [ base haskell98 mtl ];
        librarySystemDepends = [ ncurses readline swipl ];
        description = "embedding prolog in haskell";
@@ -74336,7 +74578,7 @@ self: {
      mkDerivation {
        pname = "hsx";
        version = "0.10.5";
-       sha256 = "046428y16h6za41lwqkp5pnqfd74zw8jiz8xw7j7sq0rhylg134v";
+       sha256 = "9b8cf0a88719607de4e11dfd2811ffe43487ed2d77624e0351df40133c12c410";
        isLibrary = true;
        isExecutable = true;
        libraryHaskellDepends = [ base haskell-src-exts mtl utf8-string ];
@@ -74354,7 +74596,7 @@ self: {
      mkDerivation {
        pname = "hsx-jmacro";
        version = "7.3.6";
-       sha256 = "1fr60b57z2ri2pfs890xvrzrh4n75p2j4nmb7b819cf4rhgshgnh";
+       sha256 = "d03ea81fccc4b114d03aab5a22c52dc712987fde1d24a4dd15318b7fca0226bb";
        libraryHaskellDepends = [
          base happstack-hsp hsp jmacro mtl text wl-pprint-text
        ];
@@ -74369,7 +74611,7 @@ self: {
      mkDerivation {
        pname = "hsx-xhtml";
        version = "0.4.4";
-       sha256 = "1051fh4yjnsax60v4rfh5r87n660ygq033gmg710nm3gw57ihkl2";
+       sha256 = "824e184fe16f540bc279f58d01f0f3c0187b502ed065b281e94a5be90974a180";
        libraryHaskellDepends = [ base hsx mtl ];
        homepage = "http://code.google.com/hsp";
        description = "XHTML utilities to use together with HSX";
@@ -74384,7 +74626,7 @@ self: {
      mkDerivation {
        pname = "hsx2hs";
        version = "0.13.3.2";
-       sha256 = "1vpq6a1379h7lmxcmwdb0r81gda2zn4lv02xslrixszsb757l1ck";
+       sha256 = "93057aca59faeb1e33d55d804d89fd42b5175006abf1ca7aa507a6338232f8ee";
        isLibrary = true;
        isExecutable = true;
        libraryHaskellDepends = [
@@ -74401,7 +74643,7 @@ self: {
      mkDerivation {
        pname = "hsyscall";
        version = "0.4";
-       sha256 = "0ysi317vwgksaq78k31sb8s34rjjhl4w8ncvycfsmmdnv7cdg2ld";
+       sha256 = "8d8ad7d8d9b6d5aa1df39b59c40985526632345a3a8c890e567a3ebe4f18517b";
        libraryHaskellDepends = [ base ];
        homepage = "http://github.com/aycanirican/hsyscall";
        description = "FFI to syscalls";
@@ -74414,7 +74656,7 @@ self: {
      mkDerivation {
        pname = "hsyslog";
        version = "2.0";
-       sha256 = "02v698grn43bvikqhqiz9ys8x2amngdmhvl3i0ar9203p2x8q3pq";
+       sha256 = "f80e8cbab80388941588836e58dbb355898eb44f3f628867dc6b109b1f4a660b";
        libraryHaskellDepends = [ base ];
        testHaskellDepends = [ base doctest ];
        homepage = "http://github.com/peti/hsyslog";
@@ -74427,7 +74669,7 @@ self: {
      mkDerivation {
        pname = "hszephyr";
        version = "0.1";
-       sha256 = "0lgzricdq2vijmsqrwg93amxslmdwzj17c4ppmws3pcb54xj2fsr";
+       sha256 = "593b213b298bdda179bd97b013e4e7ad52ddab1ae9f18c7595710bdc58ccff51";
        libraryHaskellDepends = [ base bytestring mtl time ];
        librarySystemDepends = [ com_err zephyr ];
        description = "Simple libzephyr bindings";
@@ -74440,7 +74682,7 @@ self: {
      mkDerivation {
        pname = "htags";
        version = "1.0.1";
-       sha256 = "064ddzligzqimdhprgpgl1j0gf4xv53anaisx3fc88as104q8zjk";
+       sha256 = "537e8409085a21c4dce83a2aab46d99db80764a0efbe7c61ab11ff17e96f8d18";
        isLibrary = false;
        isExecutable = true;
        executableHaskellDepends = [
@@ -74457,7 +74699,7 @@ self: {
      mkDerivation {
        pname = "htar";
        version = "0.4.0.2";
-       sha256 = "15m57vq0hcfk2dqamh2c624icv3smcqjgswy58glcclxz7f8ly3z";
+       sha256 = "7f788adcf99d32461f2a9eeb2731ab7a6c1689304cc0aa7013d33108f03ea596";
        isLibrary = false;
        isExecutable = true;
        executableHaskellDepends = [
@@ -74474,7 +74716,7 @@ self: {
      mkDerivation {
        pname = "htiled";
        version = "0.1.2.0";
-       sha256 = "1g0fak4iwjii5zvn79hcdydrp4vs5c0nwwbf7v2m2gajw1r34fg9";
+       sha256 = "e9393272e0523d51c53e6e716e012b7a939b9b6f0ca663f72f314a1ec9540ebc";
        libraryHaskellDepends = [
          base base64-bytestring bytestring containers filepath hxt split
          zlib
@@ -74489,7 +74731,7 @@ self: {
      mkDerivation {
        pname = "htime";
        version = "0.3.1";
-       sha256 = "14y7ipbc6ic1qraxnrs4k0hrqh5c8ks1fsm8af6wm9x762bcfaxr";
+       sha256 = "b92bc79630a7a7ca8d53a86a17f444ac409c21984467db55c68145c3d68dc793";
        isLibrary = false;
        isExecutable = true;
        executableHaskellDepends = [ base process time ];
@@ -74502,7 +74744,7 @@ self: {
      mkDerivation {
        pname = "html";
        version = "1.0.1.2";
-       sha256 = "0q9hmfii62kc82ijlg238fxrzxhsivn42x5wd6ffcr9xldg4jd8c";
+       sha256 = "0c35495ea33d65e69c69bc7441ec8e1af69fbb43433c2aa3406c0a13a3ab3061";
        libraryHaskellDepends = [ base ];
        description = "HTML combinator library";
        license = stdenv.lib.licenses.bsd3;
@@ -74516,7 +74758,7 @@ self: {
      mkDerivation {
        pname = "html-conduit";
        version = "1.2.0";
-       sha256 = "0jj02s71a9fk9mrk7bqms93y1m2zz96jg4rd7jn486ln1w49c43m";
+       sha256 = "751096080f961a44ac3c2d93274dfa5fd4e047d215af33734dd325158e16404a";
        libraryHaskellDepends = [
          base bytestring conduit conduit-extra containers resourcet
          tagstream-conduit text transformers xml-conduit xml-types
@@ -74536,7 +74778,7 @@ self: {
      mkDerivation {
        pname = "html-email-validate";
        version = "0.2.0.0";
-       sha256 = "1bvdmaamxbldb8nndi5f330msj1d0mrj8lapvxqyr333bg3kwaix";
+       sha256 = "3d2a3ec75b638cec71df57512473052d485dc118aec4662d5a8dae5e95aa6daf";
        libraryHaskellDepends = [ attoparsec base text ];
        testHaskellDepends = [
          attoparsec base hspec QuickCheck regex-pcre-builtin text
@@ -74552,7 +74794,7 @@ self: {
      mkDerivation {
        pname = "html-entities";
        version = "1.1.0.0";
-       sha256 = "0zm0s5y875wp5mb3hrprrzfv5h7cs4zzxqv0y1dmrs3nk9yrah8n";
+       sha256 = "1641957d9a76e85c5bf060e3fe3fd1ecc0b2ddcff96638562d9797837cd1a07e";
        libraryHaskellDepends = [
          attoparsec base-prelude text unordered-containers
        ];
@@ -74571,7 +74813,7 @@ self: {
      mkDerivation {
        pname = "html-kure";
        version = "0.2.1";
-       sha256 = "1x72f3r6nayv03y0a7x5dyj2lnbli14nmqi5i7i8isqbngsvca0l";
+       sha256 = "1428b6f5b30beb88e28925e26a498874592aa46fa51f05fc00db2b6bf270e2f4";
        libraryHaskellDepends = [ base hxt kure ];
        homepage = "www.ittc.ku.edu/csdl/fpg/software/html-kure";
        description = "HTML rewrite engine, using KURE";
@@ -74583,7 +74825,7 @@ self: {
      mkDerivation {
        pname = "html-minimalist";
        version = "0.15";
-       sha256 = "06qhjb8c1x9wab77g493bbqqm068alkc4vn7c6dj810gdgxwgw5j";
+       sha256 = "b2f0c7fb6b0f04249b61c76ec22655c8808af15a239177ce523cf5c0d092101b";
        libraryHaskellDepends = [ base xml ];
        homepage = "http://rd.slavepianos.org/t/html-minimalist";
        description = "Minimalist haskell html library";
@@ -74595,7 +74837,7 @@ self: {
      mkDerivation {
        pname = "html-rules";
        version = "0.1.0.1";
-       sha256 = "1k0jqx1mlcar6z8ggrz3fv1nzilkwdxvg3gvsb3pg7nvbkhz5lpw";
+       sha256 = "fcd2f2e15cdb9e77c7d2fb8db77be393c66fc376e3e7f7d03759315a43c712cc";
        libraryHaskellDepends = [ base lens mtl tagsoup transformers ];
        jailbreak = true;
        homepage = "http://github.com/kylcarte/html-rules/";
@@ -74611,7 +74853,7 @@ self: {
      mkDerivation {
        pname = "html-tokenizer";
        version = "0.4.0.0";
-       sha256 = "0a44jxw90hk1i3h8j1vk8rjz3z91z9gdszyjbkngnpnfwrdhfrw7";
+       sha256 = "8767075be6ce5efbec5cd27fdd5efa21fdf16546730789e08861429078978428";
        libraryHaskellDepends = [
          attoparsec base-prelude case-insensitive conversion
          conversion-case-insensitive conversion-text text
@@ -74629,7 +74871,7 @@ self: {
      mkDerivation {
        pname = "html-truncate";
        version = "0.3.0.0";
-       sha256 = "1d66kdg81774b8isw1mfkl54sgmaz0n04n6shd5jjz18sjwyxp14";
+       sha256 = "24dceeb9d4287c294b83da58022cf8aa3e4d0a9dae06ae235ae49c805e9bc6b4";
        libraryHaskellDepends = [ base tagsoup ];
        homepage = "https://github.com/mruegenberg/html-truncate";
        description = "A HTML truncator";
@@ -74644,7 +74886,7 @@ self: {
      mkDerivation {
        pname = "html2hamlet";
        version = "0.3.0";
-       sha256 = "1n49dz59nlkvb4ax1h9cfq7nqcwlxcrm372x4373ig6xdzbckdmz";
+       sha256 = "bfb6c9d66fddbc38ce205d9c5133eb94336c0f762cc1d015597b529bca6f89d8";
        isLibrary = false;
        isExecutable = true;
        executableHaskellDepends = [
@@ -74661,7 +74903,7 @@ self: {
      mkDerivation {
        pname = "html5-entity";
        version = "0.2.0.3";
-       sha256 = "0bmmzshxanzw5y2y0hvgzz9yw18jqgv535i1xq2a5lf7w8wpj1if";
+       sha256 = "2e067939e2c7d1a204ee219651f6c31205eed3ff6f43e0852ffc5bd5a1feb52e";
        isLibrary = true;
        isExecutable = true;
        libraryHaskellDepends = [ base containers text ];
@@ -74675,7 +74917,7 @@ self: {
      mkDerivation {
        pname = "htodo";
        version = "0.0.4";
-       sha256 = "0av34wypj47h4aifwqjjdwihb5b5jly5hcr32jq64ld94b7r4l2m";
+       sha256 = "555092cf22a95162b0142333583c95659505236f5262eea222f010793d27632b";
        isLibrary = false;
        isExecutable = true;
        executableHaskellDepends = [ base HDBC HDBC-sqlite3 ];
@@ -74692,7 +74934,7 @@ self: {
      mkDerivation {
        pname = "htoml";
        version = "0.1.0.2";
-       sha256 = "0gv57isivg65wd05yxcyi2wv4ck2f153pkk2vblp6q1xh7d81asm";
+       sha256 = "55ab80da813d6073e9da62ce3b4a706232b2b9889e755f40e3c5bc1d753c653f";
        isLibrary = true;
        isExecutable = true;
        libraryHaskellDepends = [
@@ -74718,7 +74960,7 @@ self: {
      mkDerivation {
        pname = "htrace";
        version = "0.1";
-       sha256 = "0ar1w9p6ppag2vp8kw6byirhfdfs4r639pjh5icnyiiliz6jkvlx";
+       sha256 = "9dee29cd8f34466f592c50de344c26da350773f4cbf089ee164fdd6b6ee2212b";
        libraryHaskellDepends = [ base ];
        description = "Hierarchical tracing for debugging of lazy evaluation";
        license = stdenv.lib.licenses.bsd3;
@@ -74729,7 +74971,7 @@ self: {
      mkDerivation {
        pname = "hts";
        version = "0.15";
-       sha256 = "0l09skjsds4p9kdwrwrxg8hdd1ja7m2zmggf23dfimzm1jsij6y2";
+       sha256 = "c21b19b50cf5d7e8da10eebdfa453d4a86d6207a3df3ccdb4c97e8a6e5d40950";
        libraryHaskellDepends = [ base hmt xml ];
        homepage = "http://rd.slavepianos.org/t/hts";
        description = "Haskell Music Typesetting";
@@ -74744,7 +74986,7 @@ self: {
      mkDerivation {
        pname = "htsn";
        version = "0.1.1";
-       sha256 = "123h3x22652xfnc1szvclnhfnr5wb5ndx8ahyvramvgjr1mmxpp5";
+       sha256 = "e5de5e6bc8f2edaaf2f650a1de6c59bc64eba0a56c7f1d98755d1423441f7088";
        isLibrary = false;
        isExecutable = true;
        executableHaskellDepends = [
@@ -74764,7 +75006,7 @@ self: {
      mkDerivation {
        pname = "htsn-common";
        version = "0.0.2";
-       sha256 = "0ywp0683mna16znsqn6h6k5iihpzhj909hivgmlvfzkrn6plvc15";
+       sha256 = "25b04dafb1797eb7697d3bc2049284ffc218cb34d058aced3741d93a9001977b";
        libraryHaskellDepends = [
          ansi-terminal base hslogger transformers
        ];
@@ -74782,7 +75024,7 @@ self: {
      mkDerivation {
        pname = "htsn-import";
        version = "0.2.4";
-       sha256 = "1mm098a748dmwzzak0ciam7dq80l3iv4hvk8c1crr03dbybr8rq3";
+       sha256 = "036794975f6d809c5960686e48761c1420dc4e559181a9fee7b52172144aa0d6";
        isLibrary = false;
        isExecutable = true;
        executableHaskellDepends = [
@@ -74807,7 +75049,7 @@ self: {
      mkDerivation {
        pname = "http-accept";
        version = "0.2";
-       sha256 = "1ivwkwr9jgbf6m2dv4gaw5vxrz2vm5wzz65ncl5jpma6wimwh4ii";
+       sha256 = "3112c86be446d52b0b65b698ff79a95bfcdc77e1ea91dd44356e3d99329f7cc7";
        libraryHaskellDepends = [ base bytestring ];
        homepage = "https://github.com/singpolyma/http-accept";
        description = "Functions for working with HTTP Accept headers";
@@ -74819,7 +75061,7 @@ self: {
      mkDerivation {
        pname = "http-attoparsec";
        version = "0.1.1";
-       sha256 = "12l892fix11mrvm10awwvv31y59q5rb6gb0sqjp6l4p4ym9ngqa3";
+       sha256 = "43e16753f5e4126aaec41aac67562e38151fc6de9c2b10eace35841e9d48888a";
        libraryHaskellDepends = [ attoparsec base bytestring http-types ];
        jailbreak = true;
        homepage = "https://github.com/tlaitinen/http-attoparsec";
@@ -74837,8 +75079,8 @@ self: {
      }:
      mkDerivation {
        pname = "http-client";
-       version = "0.4.18.1";
-       sha256 = "0v0mmsbh8hgzkxyg7gkn3dlq5l21ljzbxr9c3wmmz6viwhhabfv9";
+       version = "0.4.19";
+       sha256 = "5e5db3a8dfb309c8dc99ba154e0176013f7c50547b60b758725a5f5927b5e3f8";
        libraryHaskellDepends = [
          array base base64-bytestring blaze-builder bytestring
          case-insensitive containers cookie data-default-class deepseq
@@ -74864,7 +75106,7 @@ self: {
      mkDerivation {
        pname = "http-client-auth";
        version = "0.1.0.1";
-       sha256 = "07scawz138qffcgw5lyxbxmwdm0czhylqy1rzm0ff59n8amr46j4";
+       sha256 = "441a92ab423615e740fd39784c3dfc0cd4c66b5fddd3c21f730ea3113e574c1f";
        libraryHaskellDepends = [
          base base64-string blaze-builder bytestring case-insensitive
          conduit crypto-conduit http-client http-conduit pureMD5 resourcet
@@ -74879,7 +75121,7 @@ self: {
      mkDerivation {
        pname = "http-client-conduit";
        version = "0.3.0";
-       sha256 = "0k2vq9y7kfbkhcsszjr74ahq5nw5z7dbzjhw1ixbigcr56axsd19";
+       sha256 = "2934dd952999bdb87a0c1ccabfdaf985db82a12227cbaf358373b9797cc25b4c";
        libraryHaskellDepends = [ base http-client ];
        homepage = "https://github.com/snoyberg/http-client";
        description = "Frontend support for using http-client with conduit (deprecated)";
@@ -74893,7 +75135,7 @@ self: {
      mkDerivation {
        pname = "http-client-lens";
        version = "0.1.0";
-       sha256 = "1n5q3wprhp8kwwq2n1v06l1a9k9p3z96rxv3kr6bbwga9lsb3jip";
+       sha256 = "37cab1344deaf1b54c9e63f76cd21f37cda4023560072b30e7135d982f1fb8d8";
        libraryHaskellDepends = [
          base bytestring http-client http-types lens network
        ];
@@ -74908,7 +75150,7 @@ self: {
      mkDerivation {
        pname = "http-client-multipart";
        version = "0.3.0.0";
-       sha256 = "18za6s3658hgm95rrygghrz0b643c7nkzaimb14v2hv82w3k9crg";
+       sha256 = "2fb33407176843b1495835aa3fed618398057e86eff99c4baa0fa2628636eaa3";
        libraryHaskellDepends = [ base http-client ];
        homepage = "https://github.com/snoyberg/http-client";
        description = "Generate multipart uploads for http-client. (deprecated)";
@@ -74922,7 +75164,7 @@ self: {
      mkDerivation {
        pname = "http-client-openssl";
        version = "0.2.0.1";
-       sha256 = "1mg2gn51ixb68wd8mm66kcj4627q6gj64810wsa1axy3jmk5qym3";
+       sha256 = "a37a5c6695c3771594e6202062e433f80843249bc6d48a1a4766f5188a7de2d5";
        libraryHaskellDepends = [ base HsOpenSSL http-client network ];
        testHaskellDepends = [
          base HsOpenSSL hspec http-client http-types
@@ -74939,7 +75181,7 @@ self: {
      mkDerivation {
        pname = "http-client-request-modifiers";
        version = "0.1";
-       sha256 = "1bd6r24gh0nxfj040q3x39nqnpkdqkri1wdlg3jf2h61cb5gli5r";
+       sha256 = "b944faca62c140e1e478b4f110f3c46d5e8b6d1a7d60408074dd02f888c8a6ad";
        libraryHaskellDepends = [
          base bytestring exceptions http-client http-media http-types
          network network-uri
@@ -74958,7 +75200,7 @@ self: {
      mkDerivation {
        pname = "http-client-streams";
        version = "0.3.1.0";
-       sha256 = "1q9w0l89a599l4955kb3156ysmlg7il9pz0x7kfl3bxly4gadf8z";
+       sha256 = "1fb9a61ef1b4af41dd3c1dfc9b683c8f56ed4d0963cd5212a129159510053ce1";
        libraryHaskellDepends = [
          base bytestring HsOpenSSL http-client http-client-openssl
          io-streams mtl transformers
@@ -74975,7 +75217,7 @@ self: {
      mkDerivation {
        pname = "http-client-tls";
        version = "0.2.2";
-       sha256 = "0a01r05h5fxswyn6k6cgqgak4scqjan72hyy5wbdqzzhl4rmh7j5";
+       sha256 = "451e5833a1f07fdc162fde4371ac92986932d5c38f9969ace7babb020bc80128";
        libraryHaskellDepends = [
          base bytestring connection data-default-class http-client network
          tls
@@ -74994,7 +75236,7 @@ self: {
      mkDerivation {
        pname = "http-common";
        version = "0.8.2.0";
-       sha256 = "14s5a178sb2vm5k00rs21760mds5dz2gs10k9iyn22h01mxyf599";
+       sha256 = "2915e77b0d000a617d4c1304fdc46f45b70acc0942670066a95b2c8d4e504593";
        libraryHaskellDepends = [
          base base64-bytestring blaze-builder bytestring case-insensitive
          directory mtl network text transformers unordered-containers
@@ -75014,8 +75256,8 @@ self: {
      }:
      mkDerivation {
        pname = "http-conduit";
-       version = "2.1.7.2";
-       sha256 = "0inw95a2vdmsffh3ns1kh8hr7xrx2pbgdrq0yv68bwf1v4sd1mfc";
+       version = "2.1.8";
+       sha256 = "550d86ea9ee6dd90994a460c5c85ddc861fb5c0f007304dc4a2e2035f980ea3d";
        libraryHaskellDepends = [
          base bytestring conduit http-client http-client-tls http-types
          lifted-base monad-control mtl resourcet transformers
@@ -75041,7 +75283,7 @@ self: {
      mkDerivation {
        pname = "http-conduit-browser";
        version = "2.0.0.0";
-       sha256 = "1swgsb14mwsfrwhw2ggydi2wm24hrqlisslh5q46qll7rl2gx19q";
+       sha256 = "3885fe04cd87526c082e906a1d29ce9088ca456cfe3dc121cf4ef34ac2d28feb";
        libraryHaskellDepends = [
          base bytestring conduit containers cookie data-default exceptions
          http-client http-conduit http-types lifted-base monad-control
@@ -75069,7 +75311,7 @@ self: {
      mkDerivation {
        pname = "http-conduit-downloader";
        version = "1.0.25";
-       sha256 = "0g393cmkbpb40in03zlyahxxwiy5i7zj7wg5zb92a0hkmjkgbrka";
+       sha256 = "6ae6f5a6ac130225d2fae5f123ff89c547de3b549efe016c0464dd352b1b693c";
        libraryHaskellDepends = [
          base bytestring conduit connection data-default HsOpenSSL
          http-client http-conduit http-types lifted-base mtl network
@@ -75088,7 +75330,7 @@ self: {
      mkDerivation {
        pname = "http-date";
        version = "0.0.6.1";
-       sha256 = "0dknh28kyarnzqrsc80ssalxjrq0qbv7ir49247p2grb7rh0dqgj";
+       sha256 = "f2e106603e2b3f710f1189e478f6c20067d9a9d21a20a633fe362b3f91807636";
        libraryHaskellDepends = [ array attoparsec base bytestring ];
        testHaskellDepends = [
          base bytestring doctest hspec old-locale time
@@ -75104,7 +75346,7 @@ self: {
      mkDerivation {
        pname = "http-encodings";
        version = "0.9.3";
-       sha256 = "0b29zqa2ybja73jip83qn1xhiinn1k64b6dmc39ccp48ip1xdnvn";
+       sha256 = "76dbd6c38d885cc6d260b59945cc0cd6c6087bb078a01be5384a2e2f14fe492c";
        revision = "2";
        editedCabalFile = "0370852e7250c2c2bb1575155286442cbfcdd03a7e494dcaa73305d4e84a6c76";
        libraryHaskellDepends = [
@@ -75126,7 +75368,7 @@ self: {
      mkDerivation {
        pname = "http-enumerator";
        version = "0.7.3.3";
-       sha256 = "10w2ppgb4kjl3h77iq7j9qh3gcl6a0fvbpidi2njd4pfhrq4lgs6";
+       sha256 = "463f4a7086ee9226ad882ddeb51d5086b237204ef2e0780e1c544eb2debd8283";
        isLibrary = true;
        isExecutable = true;
        libraryHaskellDepends = [
@@ -75150,7 +75392,7 @@ self: {
      mkDerivation {
        pname = "http-kit";
        version = "0.5.1";
-       sha256 = "1swnvsbaabk946pys9q9kr0bgdvalnznd59dw981sg7cywqdcz28";
+       sha256 = "487cd630f7ec3c1d50e22d9566bfa56ab7b7409e0927edaf21692ea596de96eb";
        libraryHaskellDepends = [
          base bytestring case-insensitive http-types
        ];
@@ -75168,7 +75410,7 @@ self: {
      mkDerivation {
        pname = "http-link-header";
        version = "0.2.0";
-       sha256 = "0vdmb0w7ppss8lffdghn9d2vjawn6nvhx7cx1dcvl4fllxfiaihc";
+       sha256 = "0c46155da7d411ba590b9d9d0eb735962bb9454b16bee61c455adf7b3858b56d";
        libraryHaskellDepends = [
          attoparsec base bytestring-conversion errors network-uri text
        ];
@@ -75187,7 +75429,7 @@ self: {
      mkDerivation {
        pname = "http-listen";
        version = "0.1.0.0";
-       sha256 = "1ccm4lzlngcw7hp4rvk2d85zg5725pj01mzavl3zx140i6w0psz0";
+       sha256 = "e0eb0bb8898084fe07ddead700e42de294f70b6a62ee4c2e3c9c3d4b3f2595b1";
        revision = "1";
        editedCabalFile = "3fcb0a5c155c41513cf81c4cd5058be331d56aed083a3f42892feef452a0cd8b";
        libraryHaskellDepends = [
@@ -75205,7 +75447,7 @@ self: {
      mkDerivation {
        pname = "http-media";
        version = "0.6.2";
-       sha256 = "0r3xghxhnwpc8gblcj6l5sq3lxzra7280vlph1s4xfqxknv69km7";
+       sha256 = "a7ce64b69d1dbb4e7480976e80c451f9773ab02ed44846d743ec720b3b7c7d64";
        libraryHaskellDepends = [
          base bytestring case-insensitive containers
        ];
@@ -75225,7 +75467,7 @@ self: {
      mkDerivation {
        pname = "http-monad";
        version = "0.1.1";
-       sha256 = "127fy54km9js02kp5ws9pyg2d1qc2ar1342g1w2p3h8086il6mp7";
+       sha256 = "e75643a34100c171050f4f9011b2120c87269ebf49f372a7005aa63a49f1ee88";
        isLibrary = true;
        isExecutable = true;
        libraryHaskellDepends = [
@@ -75247,7 +75489,7 @@ self: {
      mkDerivation {
        pname = "http-proxy";
        version = "0.0.12";
-       sha256 = "0k6qmr3xrky1w90if2jvzc9bgifxifxkwbymw8zndgxs976zpdig";
+       sha256 = "2fb6fbcd49babf663fe2d52f3ebb8bddc5b712fb5b0a1741e2c1cfdc47aed84c";
        libraryHaskellDepends = [
          base base64-bytestring blaze-builder blaze-builder-conduit
          bytestring bytestring-lexing case-insensitive conduit ghc-prim
@@ -75268,7 +75510,7 @@ self: {
      mkDerivation {
        pname = "http-querystring";
        version = "1.0";
-       sha256 = "0n21x8w9pggyp5lbgww70g7860k6n35csq669s9gvrmv1n22k7m6";
+       sha256 = "a69e29840dbbe6fd924ec660cdcab0660283ce0387f3b768b9febd9b38ea4158";
        libraryHaskellDepends = [ base bytestring containers http-types ];
        testHaskellDepends = [
          base bytestring containers doctest hspec http-types QuickCheck
@@ -75288,7 +75530,7 @@ self: {
      mkDerivation {
        pname = "http-reverse-proxy";
        version = "0.4.2";
-       sha256 = "10cd6h1n1fp55jpwcp4nnk64yslxy2cnm7rhzd25xvi5fkhfl61i";
+       sha256 = "3118eae07425ee5e44fb309f6a99f09d6a4fccb4965cc6af2ce5ba6003348d81";
        revision = "1";
        editedCabalFile = "3b7a6c0b55cd7eb98d3f020ac08cec7ca052b8ec716f76cfabdcbaef27645db7";
        libraryHaskellDepends = [
@@ -75314,7 +75556,7 @@ self: {
      mkDerivation {
        pname = "http-server";
        version = "1.0.6";
-       sha256 = "1da385swv7x92d8cpdz28bdp38a8h058svbbpnkqpvrs0m0lgm2w";
+       sha256 = "5cd44741053aef8ba7bd6b6d8d0a8048a171db42e2b7cb5013a99fcd754143b5";
        libraryHaskellDepends = [
          base HTTP mime network network-uri text unix url utf8-string
        ];
@@ -75328,7 +75570,7 @@ self: {
      mkDerivation {
        pname = "http-shed";
        version = "0.1";
-       sha256 = "0asb499rkxr3jzyv5abiqcjx7jdsxkqndcaiqrlx7sfb6f3rccdv";
+       sha256 = "bb31968733cbe9d369c651b166f1ecbac9d325c371a9b2fd9723f79953224b2b";
        isLibrary = true;
        isExecutable = true;
        libraryHaskellDepends = [ base network ];
@@ -75349,7 +75591,7 @@ self: {
      mkDerivation {
        pname = "http-streams";
        version = "0.8.3.3";
-       sha256 = "0cp2jdalg0vzikl6v4yhyflllv7yqskph5gp5ahirawhcj9rfi9z";
+       sha256 = "3f4597936490ab1ca12af71578a7c6fe6c4aa9f3d0936de88c7f83475593e232";
        libraryHaskellDepends = [
          aeson attoparsec base base64-bytestring blaze-builder bytestring
          case-insensitive directory HsOpenSSL http-common io-streams mtl
@@ -75376,7 +75618,7 @@ self: {
      mkDerivation {
        pname = "http-test";
        version = "0.2.4";
-       sha256 = "06y7nikmyr9jrcrnsqy63p1zv1nv0z1h1bmbryr4dkh5pisfmr83";
+       sha256 = "03e5ea74bc05ce46b2cfabae00c307db86fdc31dc6636d33cb32655f67b4c71b";
        isLibrary = true;
        isExecutable = true;
        libraryHaskellDepends = [
@@ -75398,7 +75640,7 @@ self: {
      mkDerivation {
        pname = "http-types";
        version = "0.8.6";
-       sha256 = "1q1ni88rs8d79xnk1x2jaf3848ygxlfhpvv4gw46k08lw29ihfxh";
+       sha256 = "b03b1893e0148169087f64ef0b1dedcf2382865352f4306d4fa7219d118a36e0";
        libraryHaskellDepends = [
          array base blaze-builder bytestring case-insensitive text
        ];
@@ -75416,7 +75658,7 @@ self: {
      mkDerivation {
        pname = "http-wget";
        version = "0.6.2.3";
-       sha256 = "1sbg4gpx8ikaxb15wflm7fnjnkr32fj07bva62z54dsm630s37fx";
+       sha256 = "dd9da1c130553752be306aaf03a413234f2bad3b953a5ec2ea6a46d4ef236fe9";
        libraryHaskellDepends = [ base failure process transformers ];
        jailbreak = true;
        homepage = "http://github.com/snoyberg/http-wget/tree/master";
@@ -75432,8 +75674,8 @@ self: {
      }:
      mkDerivation {
        pname = "http2";
-       version = "1.0.3";
-       sha256 = "075j4xhfmgiij431zn5mzmq6m40fj74l5f5wckqa22aq2ay19p8c";
+       version = "1.0.4";
+       sha256 = "727fc0d39a62b02b677189f9ef745e3c8fd574334736594139767940dc4647b7";
        isLibrary = true;
        isExecutable = true;
        libraryHaskellDepends = [
@@ -75459,7 +75701,7 @@ self: {
      mkDerivation {
        pname = "httpd-shed";
        version = "0.4.0.3";
-       sha256 = "064jy1mqhnf1hvq6s04wlhmp916rd522x58djb9qixv13vc8gzxh";
+       sha256 = "b0ff87d81e61f788d3920d952e4469d984742ba49c006df086c159886bf09218";
        isLibrary = true;
        isExecutable = true;
        libraryHaskellDepends = [ base network network-uri ];
@@ -75475,7 +75717,7 @@ self: {
      mkDerivation {
        pname = "https-everywhere-rules";
        version = "0.1.0";
-       sha256 = "170ynbjv8dz221rs26i4d0kwkv3h4ljmx5azslc9jj9lzgb42knp";
+       sha256 = "d74e41d6fb34499918d55f955e252570ecc92768241aa17310e237b4e5b21e9c";
        libraryHaskellDepends = [
          attoparsec base errors functor-infix http-client
          https-everywhere-rules-raw lens network pipes string-conversions
@@ -75498,7 +75740,7 @@ self: {
      mkDerivation {
        pname = "https-everywhere-rules-raw";
        version = "4.0";
-       sha256 = "0zm3znn42nzh9dlpjjn38nsz8rsb0gzl5rv6ngii1vfq534sddy6";
+       sha256 = "c6b7a6c928d8ed10e3b366e742ff034b67f4b545c34a79694bf05b41acfda37e";
        libraryHaskellDepends = [
          base directory filepath functor-infix text
        ];
@@ -75516,7 +75758,7 @@ self: {
      mkDerivation {
        pname = "httpspec";
        version = "0.3.0.1";
-       sha256 = "1vghkrs72cja9x2lqshh6nhsdp8f68s3wh7zljn86011h4widd5v";
+       sha256 = "bbb4163981210083aca4ff403e34320edda6a135106a4c454f4a3271749ef0ed";
        libraryHaskellDepends = [
          base bidispec bytestring cgi containers encoding filepath HTTP hxt
          hxthelper MissingH mtl network pretty safe
@@ -75531,7 +75773,7 @@ self: {
      mkDerivation {
        pname = "htune";
        version = "0.2";
-       sha256 = "1il1d8b7xyv59f7xim337zyh88s1qchsrdhrgmv322hqf73n6rh2";
+       sha256 = "026663c771180a31767d19b6ac21c3412304fd3f63d4d88f4b65fb7e166a81c6";
        isLibrary = false;
        isExecutable = true;
        executableHaskellDepends = [ alsa-pcm base carray fft gloss ];
@@ -75546,7 +75788,7 @@ self: {
      mkDerivation {
        pname = "htzaar";
        version = "0.0.2";
-       sha256 = "12g41q821yh43nslb96jpqyb58k1lz6g0a6vmqw202m0hv94npdb";
+       sha256 = "ab5d4bd286a00a2038aedb28f0cca761a2b23cbed2a445b51d04fa20100ee489";
        isLibrary = false;
        isExecutable = true;
        executableHaskellDepends = [ base OpenGL random SDL ];
@@ -75563,7 +75805,7 @@ self: {
      mkDerivation {
        pname = "hub";
        version = "1.9.0.1";
-       sha256 = "10hcaddk1mqzyl1fmzsvzqq141lg9a43295158ckmkbnx8i1rxv1";
+       sha256 = "61f71c22ea76cd3a192aa12431884a8f061230fe5bffea02f51fd7305b530c82";
        isLibrary = false;
        isExecutable = true;
        executableHaskellDepends = [
@@ -75580,7 +75822,7 @@ self: {
      mkDerivation {
        pname = "hubigraph";
        version = "0.3.2";
-       sha256 = "19mxblqy3bchhrk725x4kmpa9hidjzj0d0sqhx34smqw7v36x814";
+       sha256 = "24a06ec63e1c574d4687588306e4972dc2a46e9da41771668690ade1315dbda6";
        libraryHaskellDepends = [ base containers haxr mtl ];
        homepage = "http://ooxo.org/hubigraph/";
        description = "A haskell wrap for Ubigraph";
@@ -75594,7 +75836,7 @@ self: {
      mkDerivation {
        pname = "hubris";
        version = "0.0.3";
-       sha256 = "135q3nzchncbkx4bpx7p1glwnc9aw5j77f3xnr0d6llfba1bw79l";
+       sha256 = "341dbe825a8e52d340b67db87364e12a31cbe90bf7f4bb489f8b59c8be1db88c";
        isLibrary = true;
        isExecutable = true;
        libraryHaskellDepends = [
@@ -75618,7 +75860,7 @@ self: {
      mkDerivation {
        pname = "huffman";
        version = "1.0.1";
-       sha256 = "191llv4s64jrh8cma43r5z740avd5picja5fr45l4mi2gwmkx4s3";
+       sha256 = "43933e2b7f2256420bc9ae28c9e22d6d2b40ce2f79105519825912a3c9a634a4";
        libraryHaskellDepends = [ base containers fingertree ];
        description = "Pure Haskell implementation of the Huffman encoding algorithm";
        license = stdenv.lib.licenses.bsd3;
@@ -75631,7 +75873,7 @@ self: {
      mkDerivation {
        pname = "hugs2yc";
        version = "0.1.1";
-       sha256 = "1bmcdjwh08q84ijx7hdfraz0wqq0wwgf5pj0jlmdq5rbpb9c547a";
+       sha256 = "ea90c2d2ba2b17dc2a9540dee21ee700630ebecaaec1d36524082300b96cacae";
        libraryHaskellDepends = [
          base containers directory filepath mtl parsec uniplate ycextra
          yhccore
@@ -75651,7 +75893,7 @@ self: {
      mkDerivation {
        pname = "hulk";
        version = "0.2.0";
-       sha256 = "0vq0sb11kiiry67bh5ish1cwj8sf6rgf70p1zrm462zsqgv9wkk2";
+       sha256 = "624e9ef6c3fa0b436afee182e35e364e23c959803a16b88ef139c619c2d2006f";
        isLibrary = true;
        isExecutable = true;
        libraryHaskellDepends = [
@@ -75680,7 +75922,7 @@ self: {
      mkDerivation {
        pname = "hums";
        version = "0.7.0";
-       sha256 = "1wb9bn83lrn6cpp0gkpc7v40m9wlx8i8zqijm4dmd23zzmrlrxhr";
+       sha256 = "19f64c73fd7f88561ba932e28f22ea94a70ac83eecce07ee65c6663a905d69f1";
        isLibrary = false;
        isExecutable = true;
        executableHaskellDepends = [
@@ -75700,7 +75942,7 @@ self: {
      mkDerivation {
        pname = "hunit-gui";
        version = "0.1.4";
-       sha256 = "0wzy2gjxpqr0j2cfnl88ixccm8dv3z9cql1zpzr4ph6g37dc9w60";
+       sha256 = "c0f0c4da19cfc04bf2bf3f50ccd21fbba1ca588f0851eb989020e3dbe513fe73";
        isLibrary = true;
        isExecutable = true;
        libraryHaskellDepends = [ base cairo gtk haskell98 HUnit ];
@@ -75717,7 +75959,7 @@ self: {
      mkDerivation {
        pname = "hunit-parsec";
        version = "0.3";
-       sha256 = "089l8n1yjcf6sypr76r8p0djwpcqaa5xdk1d0m2k9piig9fnzr40";
+       sha256 = "80e46f5d7a31de3445052dccd68b52985d2e1bb8289b93afd7c631e983453421";
        libraryHaskellDepends = [ base HUnit parsec ];
        description = "An HUnit Testable instance for Parsec parser unit tests";
        license = stdenv.lib.licenses.bsd3;
@@ -75728,7 +75970,7 @@ self: {
      mkDerivation {
        pname = "hunit-rematch";
        version = "0.1.0.1";
-       sha256 = "1xj5f6l8nfanbf0xdwl2j2na45w5h0spi9a8pxqgpxx2rak145gs";
+       sha256 = "fa1512a6caa2f7fb70bf48a57835808517a2ac9082f2d6815b56398ba87145f6";
        libraryHaskellDepends = [ base HUnit rematch ];
        testHaskellDepends = [ base hspec HUnit rematch ];
        jailbreak = true;
@@ -75745,7 +75987,7 @@ self: {
      mkDerivation {
        pname = "hunp";
        version = "0.1";
-       sha256 = "0k07dbqrlnhg3a4yk25gc665z43hcl57kblr20mzryw0cf9zdsci";
+       sha256 = "91e9f6936380fbfc2b1099ae790a6570905f8c61af88e9891a0f5a9af16a074c";
        isLibrary = false;
        isExecutable = true;
        executableHaskellDepends = [
@@ -75769,7 +76011,7 @@ self: {
      mkDerivation {
        pname = "hunt-searchengine";
        version = "0.3.0.1";
-       sha256 = "1y8pq158jwdl3zq5f0xdgszihp8z181lhwd92d66ckw9nh0sllw6";
+       sha256 = "8653aa01b4894f664c13a97148030a1f5d18bf7ead0357f01fb471894ac017f9";
        libraryHaskellDepends = [
          aeson aeson-pretty base binary bytestring containers data-default
          data-r-tree data-stringmap deepseq dlist filepath hslogger
@@ -75799,7 +76041,7 @@ self: {
      mkDerivation {
        pname = "hunt-server";
        version = "0.3.0.2";
-       sha256 = "19bbn97pj01sbqbjkgh82hiwzxfybnnm29wj4irgicab0d72jvg6";
+       sha256 = "e66d294e034bb1f87224922751ad5ddef5cf231408be29175e3a00794fb26ba5";
        isLibrary = false;
        isExecutable = true;
        executableHaskellDepends = [
@@ -75824,7 +76066,7 @@ self: {
      mkDerivation {
        pname = "hunt-server-cli";
        version = "0.2.0.0";
-       sha256 = "1pmlg06jipmc99v7clz2q7x3bh4ndar55595fx729khnjrbiy9bz";
+       sha256 = "7f251f579616ce244e77259552b26a96c035fac1e25376764aacde280d78b4de";
        isLibrary = false;
        isExecutable = true;
        executableHaskellDepends = [
@@ -75845,7 +76087,7 @@ self: {
      mkDerivation {
        pname = "hurdle";
        version = "0.4.0";
-       sha256 = "13hg6v7vk72yiy0qhwm1f3ksm85vf56a3g5mm62kpbb0lcxvvqwf";
+       sha256 = "8ee3bd3ba360ad3b85a9b5bca14c71bba0aae770a17288818f5e9cb9cf360f8e";
        isLibrary = false;
        isExecutable = true;
        executableHaskellDepends = [
@@ -75866,7 +76108,7 @@ self: {
      mkDerivation {
        pname = "husk-scheme";
        version = "3.19";
-       sha256 = "1y8b15cgiky6kasx21q4gw4h40scyby4mkqynq96kaq2yrrayd5q";
+       sha256 = "b834af72f602ab6912b61ecf4afcf24c0302097f0407d1b59ac6cff858090bf9";
        isLibrary = true;
        isExecutable = true;
        libraryHaskellDepends = [
@@ -75890,7 +76132,7 @@ self: {
      mkDerivation {
        pname = "husk-scheme-libs";
        version = "0.0.1";
-       sha256 = "18c8ww2f7bgxbh33agcrpb36xgjn7zs509ji7q968hnwqnx9vgcj";
+       sha256 = "92bd9dbac5dc4264123e512650f43f56be6ec6ba993d35065cfdade304e788a1";
        libraryHaskellDepends = [
          array base containers husk-scheme json mtl transformers
        ];
@@ -75907,7 +76149,7 @@ self: {
      mkDerivation {
        pname = "husky";
        version = "0.4";
-       sha256 = "136sskjkb4nwsqdmgyly207zv4kv27bxf633p2wl869wcr6kkdbg";
+       sha256 = "6fb5394d663c1944b9b86318d7d7117b92fd0f109efa571bd6dc9235e5d4da8c";
        isLibrary = false;
        isExecutable = true;
        executableHaskellDepends = [
@@ -75928,7 +76170,7 @@ self: {
      mkDerivation {
        pname = "hutton";
        version = "1.0.0";
-       sha256 = "12rvlagd0n946x05wnyixd1b16ls9ynagccw2bc77fjqfb0d9shi";
+       sha256 = "11ead4c07258ba73d8129cb1a7ac4f9a9ab042ebd15b5e40372459d09ea23b8b";
        isLibrary = false;
        isExecutable = true;
        executableHaskellDepends = [
@@ -75947,7 +76189,7 @@ self: {
      mkDerivation {
        pname = "huttons-razor";
        version = "0.1.1.0";
-       sha256 = "1wwphyg2fm34gxn7s7a4q7p8fyab3c7am4fmw1x50gkrmkwgd72s";
+       sha256 = "5a9cf6f8ac793e507ae0d591aa0e1b4b7987eec1441d7d6c7f6454279e8797f3";
        isLibrary = false;
        isExecutable = true;
        executableHaskellDepends = [ base parsec parsec-numbers ];
@@ -75961,7 +76203,7 @@ self: {
      mkDerivation {
        pname = "huzzy";
        version = "0.1.5.5";
-       sha256 = "0i8h380nszd7hk7x6l7qx0ri6k12551li2m77gspzakcf47l6ldp";
+       sha256 = "b751430f716caa7ff53ba78a484329224c1333e8f850d3cf84a77d6d011a1045";
        libraryHaskellDepends = [ base easyplot ];
        jailbreak = true;
        description = "Fuzzy logic library with support for T1, IT2, GT2";
@@ -75974,7 +76216,7 @@ self: {
      mkDerivation {
        pname = "hvect";
        version = "0.2.0.0";
-       sha256 = "01iarjnwm5syhmf6552g3p9dc05nqc74r4nfmagajgv7fnlsf3ri";
+       sha256 = "310fa7a975673fa99eaace924c0ec3b600d6d21d4f94625c855e97caadcc2a06";
        libraryHaskellDepends = [ base ];
        testHaskellDepends = [ base HTF ];
        homepage = "https://github.com/agrafix/hvect";
@@ -75989,7 +76231,7 @@ self: {
      mkDerivation {
        pname = "hwall-auth-iitk";
        version = "0.1.0.1";
-       sha256 = "0ibxdyg9r5n3dc8szhb8fvdjsbgpbwdah2aahn0kagi1zxw24fl2";
+       sha256 = "823a2278ff213e3581854a09a81a5ff72d2ddb7668c1af116bc3969c9e6f7d45";
        isLibrary = false;
        isExecutable = true;
        executableHaskellDepends = [
@@ -76007,7 +76249,7 @@ self: {
      mkDerivation {
        pname = "hweblib";
        version = "0.6.3";
-       sha256 = "03dmx5irlsyb3b9zg2r6nz947sslizkn0nlk65ldb5n4m8my33hy";
+       sha256 = "1e8ee12baac496d56831935a60e78f54eb43d2b7268bf7d31acb6b9a63e9b50d";
        libraryHaskellDepends = [
          attoparsec base bytestring containers mtl text transformers
        ];
@@ -76026,7 +76268,7 @@ self: {
      mkDerivation {
        pname = "hws";
        version = "1.1.0.1";
-       sha256 = "0d0f0bwbfcmbm1jx6m90qxxjad2adz5k0k51i4jh5ylrfa9xfs7r";
+       sha256 = "f968d7937299fa022589a14c30cb6f4a34257bc72055d365a8ab32b7f8020e34";
        isLibrary = false;
        isExecutable = true;
        executableHaskellDepends = [
@@ -76046,7 +76288,7 @@ self: {
      mkDerivation {
        pname = "hwsl2";
        version = "0.3.2.0";
-       sha256 = "0y3k9xlhzvscbwzrhxgiqf9s3724zak1nbnf6lcaynpzk4p8jmm1";
+       sha256 = "a156892e99ff5aaf1835ce2e1ba6fa449ca193c3f175983f5f4cef0f694f7378";
        libraryHaskellDepends = [ base bytestring ];
        testHaskellDepends = [
          base bytestring Cabal cabal-test-quickcheck QuickCheck
@@ -76063,7 +76305,7 @@ self: {
      mkDerivation {
        pname = "hwsl2-bytevector";
        version = "0.1.0.0";
-       sha256 = "0kfsc85k4vgdbkryrw80rgpjzzbavwqqzqylc95h80vm7xnlg2p9";
+       sha256 = "e98a476d3f7503044b62d4e38f31df6afd2fefcb00f1ecf35ced6d320b62da4d";
        libraryHaskellDepends = [ base bytestring fingertree hwsl2 ];
        homepage = "https://github.com/srijs/hwsl2-haskell-bytevector";
        description = "A hashed byte-vector based on algebraic hashes and finger trees";
@@ -76075,7 +76317,7 @@ self: {
      mkDerivation {
        pname = "hwsl2-reducers";
        version = "0.1.0.0";
-       sha256 = "1q7phb2v11gfwlvm0f0jrsm7gc7ga9awd9cp0kkxm2k20mggrg7x";
+       sha256 = "fdbcfc5e05628adae70497a5c65552efb077aace12385037e5ee85b0c582f7e0";
        libraryHaskellDepends = [
          base bytestring hwsl2 reducers semigroups
        ];
@@ -76089,7 +76331,7 @@ self: {
      mkDerivation {
        pname = "hx";
        version = "0.4";
-       sha256 = "04wkgql6gs9glmp9kj5awis5b15vmwgkyqzi814k9514k3c7c1rb";
+       sha256 = "2b0776d8982494344940f1633f1fafbb845574e4aac8996ea52fe967287e9313";
        libraryHaskellDepends = [ base ];
        description = "Haskell extras (missing utility functions)";
        license = stdenv.lib.licenses.mit;
@@ -76102,7 +76344,7 @@ self: {
      mkDerivation {
        pname = "hxmppc";
        version = "0.2.3";
-       sha256 = "1fri1xcs95ynkf471hrkai0k8kvxhx77ra07yripycnlpa9fcwj9";
+       sha256 = "4972e692bad4327f63f607a87c4e877d4f34415433c370889bd697a4590f31bb";
        isLibrary = false;
        isExecutable = true;
        executableHaskellDepends = [
@@ -76125,7 +76367,7 @@ self: {
      mkDerivation {
        pname = "hxournal";
        version = "0.6.6.1";
-       sha256 = "1fk4cgk4ncf5v7k8hankwb49ablfcxj1rcw64ka6pz3jrz4sablq";
+       sha256 = "982ea5c9cf72fc6bd42486b31c64678e2e95c8e2d32a88e6d9c5314be66364ba";
        isLibrary = true;
        isExecutable = true;
        libraryHaskellDepends = [
@@ -76151,7 +76393,7 @@ self: {
      mkDerivation {
        pname = "hxt";
        version = "9.3.1.15";
-       sha256 = "0q35jqi3g5qfwzp2p2hm22lkmbmk08bx2qvpgq4731zm48y7ngkj";
+       sha256 = "723e7b3c22f58771087e7763d11702b3ae3aa910158a2beee70e973722966560";
        configureFlags = [ "-fnetwork-uri" ];
        libraryHaskellDepends = [
          base binary bytestring containers deepseq directory filepath HUnit
@@ -76170,7 +76412,7 @@ self: {
      mkDerivation {
        pname = "hxt-binary";
        version = "0.0.2";
-       sha256 = "1hbby0lcb9kis05zsf5rgyisa1qwryvv8zf91q9fi0j0d7s3rasw";
+       sha256 = "5cab3cf4694082e8120ec97db4b7cf1c07a5a37fb938fd0bd071a6c528f06bc1";
        libraryHaskellDepends = [
          base binary bytestring bzlib deepseq haskell98 hxt
        ];
@@ -76188,7 +76430,7 @@ self: {
      mkDerivation {
        pname = "hxt-cache";
        version = "9.1.0.1";
-       sha256 = "1ki3h9x186c6p1c6hnczr0a1idil6kfvs2jl9d9hmzp9rlmh2w7l";
+       sha256 = "f470012bcde9fe0a534b540abddd3434b61814c89f596858b88619147a8223ce";
        libraryHaskellDepends = [
          base binary bytestring containers deepseq directory filepath hxt
          SHA time unix
@@ -76203,7 +76445,7 @@ self: {
      mkDerivation {
        pname = "hxt-charproperties";
        version = "9.2.0.1";
-       sha256 = "1mml8wglvagqq891rchgli6r8rnkwrqhgsxfl6kb5403pzb18rp4";
+       sha256 = "e46614d6bf0390b2a6a1aeeb0771e6d366944da40fb21c12c2f8a94d1f47b4d6";
        libraryHaskellDepends = [ base ];
        homepage = "https://github.com/UweSchmidt/hxt";
        description = "Character properties and classes for XML and Unicode";
@@ -76215,7 +76457,7 @@ self: {
      mkDerivation {
        pname = "hxt-css";
        version = "0.1.0.1";
-       sha256 = "0z8qswykx0k965n2mfp87b6h8fixrydvjg98d8h37bclfsqzj15w";
+       sha256 = "bc04f9b17694ad33206a283db99bcf3d3a04cd3ae8ba2a6c3169823e3dd7187d";
        isLibrary = true;
        isExecutable = true;
        libraryHaskellDepends = [ base hxt parsec split ];
@@ -76229,7 +76471,7 @@ self: {
      mkDerivation {
        pname = "hxt-curl";
        version = "9.1.1.1";
-       sha256 = "1sn5ngzz5qszdb3anbpqbjdijz29gmrwjrg9vsmrqsdqz65wrhfd";
+       sha256 = "cdc1cc8bf9b8699cabdee965c9737d497c199b5cf82eabc66a5fe3f2ffb3c5ea";
        libraryHaskellDepends = [ base bytestring curl hxt parsec ];
        homepage = "https://github.com/UweSchmidt/hxt";
        description = "LibCurl interface for HXT";
@@ -76241,7 +76483,7 @@ self: {
      mkDerivation {
        pname = "hxt-expat";
        version = "9.1.1";
-       sha256 = "1mi2f2i31nqjqzwl82iypm1qngrpxp7lz506pjgqfbn840yc9n8h";
+       sha256 = "10d9c43c20c82e879fbc06944fcfed373f8b43bd3e0a44f9c712db30a27022d6";
        libraryHaskellDepends = [ base bytestring hexpat hxt ];
        homepage = "http://www.fh-wedel.de/~si/HXmlToolbox/index.html";
        description = "Expat parser for HXT";
@@ -76253,7 +76495,7 @@ self: {
      mkDerivation {
        pname = "hxt-extras";
        version = "0.4.1";
-       sha256 = "1bv8kcra2vgjbp7k0yczlrfbjh7ib2xixaqpnnd60hq84878nzb1";
+       sha256 = "617d8b0e220843609ab517ab1ebb58f140b95ca69f7930cf5df26da1329b68af";
        libraryHaskellDepends = [ base hxt ];
        homepage = "http://code.google.com/p/hxt-extras/";
        description = "Extra functions for HXT";
@@ -76267,7 +76509,7 @@ self: {
      mkDerivation {
        pname = "hxt-filter";
        version = "8.4.2";
-       sha256 = "0jxiph7c59dc2fy5c2ygii1xlcmh8s5zb8c0hwvjkj0hzfjznra0";
+       sha256 = "4065fba5fb10c829378780a1f58b46b032da438ccf0b56bc13aca5c20ebcb14b";
        libraryHaskellDepends = [
          base containers directory filepath haskell98 HTTP HUnit hxt network
          parsec process
@@ -76286,7 +76528,7 @@ self: {
      mkDerivation {
        pname = "hxt-http";
        version = "9.1.5.2";
-       sha256 = "02yxvzczv89j518b94wh8m4dsmnymzxgv9158m7w6lqxk41rv8bg";
+       sha256 = "6fa19d03991d53c34f4525a4fdfaafde56dd48459093b4502832a1fdd9dfdd0b";
        libraryHaskellDepends = [
          base bytestring HTTP hxt network network-uri parsec
        ];
@@ -76300,7 +76542,7 @@ self: {
      mkDerivation {
        pname = "hxt-pickle-utils";
        version = "0.1.0.3";
-       sha256 = "1id9459yphsbxqa0z89dhsmqqcgvk2axv91d05aw3n6r4ygs3nwx";
+       sha256 = "9ddba19f27d9d8c155012da4dd9598fb318cab862da10f14ee4bc3eb5321a9c5";
        libraryHaskellDepends = [ base hxt mtl ];
        homepage = "https://github.com/silkapp/hxt-pickle-utils";
        description = "Utility functions for using HXT picklers";
@@ -76314,7 +76556,7 @@ self: {
      mkDerivation {
        pname = "hxt-regex-xmlschema";
        version = "9.2.0.2";
-       sha256 = "1hkcd5p7rhv8z2vlcpd1gcdiyni28m8k8yd5fnxw8a9bvrnnfi27";
+       sha256 = "4744676dde2b29c4bb75a579345145225a1f1b7ba15d46b7f868c37c6e696cc2";
        libraryHaskellDepends = [
          base bytestring hxt-charproperties parsec text
        ];
@@ -76331,7 +76573,7 @@ self: {
      mkDerivation {
        pname = "hxt-relaxng";
        version = "9.1.5.5";
-       sha256 = "07s47z5xhd0pdzz8mr9vg78qxay450sm8ljycpprq7y7mgh2vzhf";
+       sha256 = "0efe2de0abc71f9cef655e52543528c4ab8ed1793be58afe6f1734d8cb3f441f";
        libraryHaskellDepends = [
          base containers hxt hxt-charproperties hxt-regex-xmlschema
          network-uri parsec
@@ -76348,7 +76590,7 @@ self: {
      mkDerivation {
        pname = "hxt-tagsoup";
        version = "9.1.3";
-       sha256 = "1rp499j6w3h9xfxqyw2fn05ffq3z0wg1r9h2c205m37mb8visq77";
+       sha256 = "e7601d375af58c5a806002a61c1e077f60e70ab04e708fbbeb090e6e644ae4e6";
        libraryHaskellDepends = [
          base hxt hxt-charproperties hxt-unicode tagsoup
        ];
@@ -76362,7 +76604,7 @@ self: {
      mkDerivation {
        pname = "hxt-unicode";
        version = "9.0.2.4";
-       sha256 = "0rj48cy8z4fl3zpg5bpa458kqr83adav6jnqv4i71dclpprj6n3v";
+       sha256 = "7b5823f3bd94b57022d9d84ab3555303653c5121eaaef2ee1fd4918f3c434466";
        libraryHaskellDepends = [ base hxt-charproperties ];
        homepage = "https://github.com/UweSchmidt/hxt";
        description = "Unicode en-/decoding functions for utf8, iso-latin-* and other encodings";
@@ -76375,7 +76617,7 @@ self: {
      mkDerivation {
        pname = "hxt-xpath";
        version = "9.1.2.2";
-       sha256 = "0wlq9s01icalnvjkkilx5zaqp3ff4v5limj1xy8i18qpzjspqdsh";
+       sha256 = "50377cb5fc17a31091ef41d648cb26ce8d8bd52f9dc639e5b654b118804e9872";
        libraryHaskellDepends = [
          base containers directory filepath hxt parsec
        ];
@@ -76391,7 +76633,7 @@ self: {
      mkDerivation {
        pname = "hxt-xslt";
        version = "9.1.1.1";
-       sha256 = "020k7zjwbad5j2zbc0cgp8f5lggws5jijlcwmi71p510n0f51y9j";
+       sha256 = "32f9501cb020941b4eac9c511965d1fc3d5a1cba8f01b6be90a5a9c5e53f1308";
        libraryHaskellDepends = [
          base containers directory filepath hxt hxt-xpath parsec
        ];
@@ -76405,7 +76647,7 @@ self: {
      mkDerivation {
        pname = "hxthelper";
        version = "0.2.2";
-       sha256 = "1il21mqmvvfdny5ksnyixj1wqhabvxqhccd6vj4dbzlvvf5yb6k1";
+       sha256 = "619ae58bdb9bfed588dca6310671df4b41cc83ecd15b3d8bb7cded5d710d82c6";
        libraryHaskellDepends = [ base bytestring encoding hxt mtl ];
        jailbreak = true;
        description = "Helper functions for HXT";
@@ -76418,7 +76660,7 @@ self: {
      mkDerivation {
        pname = "hxweb";
        version = "0.1";
-       sha256 = "0faiyflyhmn2y0bs920qgm9xkj9i69lzxhsg4rxffal989gi32z8";
+       sha256 = "e88b115f42892ae77a264fc3fe693231c9d9537d1888a417f0c256e8a9f35139";
        libraryHaskellDepends = [ base cgi fastcgi libxml mtl xslt ];
        description = "Minimal webframework using fastcgi, libxml2 and libxslt";
        license = stdenv.lib.licenses.bsd3;
@@ -76430,7 +76672,7 @@ self: {
      mkDerivation {
        pname = "hyahtzee";
        version = "0.2";
-       sha256 = "0zv9ycgf9sii59q86s04m6krjyjgmrqaxz4lyvwa58b7a886wcmv";
+       sha256 = "bb326e105267a1a2f8f694fcae70ae4f7a99a7a9046883702a31eae41ef3697f";
        isLibrary = false;
        isExecutable = true;
        executableHaskellDepends = [ base containers HUnit random ];
@@ -76447,7 +76689,7 @@ self: {
      mkDerivation {
        pname = "hyakko";
        version = "0.6.7";
-       sha256 = "1k81whay05mp9jb39gmb64l2xqxa90yrb7svbphj1cnsz0b76qwk";
+       sha256 = "93637316f8dab220e15d5b9f953d48aae32e2831abbe34964cb716e015e401cd";
        isLibrary = false;
        isExecutable = true;
        executableHaskellDepends = [
@@ -76466,7 +76708,7 @@ self: {
      mkDerivation {
        pname = "hybrid";
        version = "2.0";
-       sha256 = "05v69csnz7g9ikymnrmzjqhdwlrfsb44pbv8mzddgk6my9ddlb9w";
+       sha256 = "3c2dda5af2d5ccd7daaf68af4bc8d22e53de2096bf665bfd8ce99d6f354b6617";
        isLibrary = false;
        isExecutable = true;
        executableHaskellDepends = [
@@ -76483,7 +76725,7 @@ self: {
      mkDerivation {
        pname = "hybrid-vectors";
        version = "0.2";
-       sha256 = "0xdrna6jgn4l0idhv0bn6ic8m7g8pps23ky2f75zwgpqrkflnb41";
+       sha256 = "812c4bddccf83efecb71c2cf21f4bde89d8a583476810d5b0494d8278db2b975";
        revision = "1";
        editedCabalFile = "43a2c8cd2fa6abe7dc526dd99ef9d296394922a3d92ced8138072250fe75eb35";
        libraryHaskellDepends = [ base deepseq primitive vector ];
@@ -76497,7 +76739,7 @@ self: {
      mkDerivation {
        pname = "hydra-hs";
        version = "1.0.0.2";
-       sha256 = "18sxqangnl3gbb77dsg036ymsjj6w7zws2v43qnp3cfi0ksjxx8s";
+       sha256 = "1af52ef504d1b1712d1e640bcdffe1464a5dbd19e0e976ce5a6f50fbacc25da3";
        libraryHaskellDepends = [ base hmatrix ];
        librarySystemDepends = [ sixense_x64 ];
        testHaskellDepends = [ base ];
@@ -76518,7 +76760,7 @@ self: {
      mkDerivation {
        pname = "hydra-print";
        version = "0.1.0.3";
-       sha256 = "16cgp3a475pzy0zasvfv3cvkvgc84g6p960sykk7y4aki0n3769i";
+       sha256 = "3199332c8853117fe6f41a9874cd2388bd3d371bdb6dad3ef0ff9643d4b88f99";
        isLibrary = true;
        isExecutable = true;
        libraryHaskellDepends = [
@@ -76548,7 +76790,7 @@ self: {
      mkDerivation {
        pname = "hydrogen";
        version = "0.3.0.0";
-       sha256 = "0aq4svvwcys06mv172zz4yp624f6mnjg94lycj4r66xhm8m3fv4i";
+       sha256 = "916c372aaab01b9389649e92f4a4adc61161ae27ff8b137635407bc6f7d6042b";
        libraryHaskellDepends = [
          base bytestring containers mtl pretty text
        ];
@@ -76566,7 +76808,7 @@ self: {
      mkDerivation {
        pname = "hydrogen-cli";
        version = "0.14";
-       sha256 = "03hz4z964zg1b5nzywymrd1m3ss081rq6nnbqwcgbwabx6wd209b";
+       sha256 = "2b01d1b8e94bf1f518c7cb5a83734040eb5143cbd573ff6d59e17d62d2271f0e";
        isLibrary = false;
        isExecutable = true;
        executableHaskellDepends = [
@@ -76586,7 +76828,7 @@ self: {
      mkDerivation {
        pname = "hydrogen-cli-args";
        version = "0.17";
-       sha256 = "1wapq5lfyvm09sl9n7zhiaxpb8iapirvizq3ak9rl17vy4iz5xl4";
+       sha256 = "84f6f223f1fb049ad35403ffb873bc2aa275bb8af01f9ba84ea06eef68c157f1";
        libraryHaskellDepends = [
          base containers hydrogen-multimap hydrogen-prelude
        ];
@@ -76602,7 +76844,7 @@ self: {
      mkDerivation {
        pname = "hydrogen-data";
        version = "0.14";
-       sha256 = "0d9457sarii5z1m2p1jzfk1g1ix2bm0s3ghfw7gab1w74i3hlh88";
+       sha256 = "08410a47248787a5dee10ebea1415da2c7f0c2745f862b6af825c6acf4292435";
        libraryHaskellDepends = [ base hydrogen-parsing hydrogen-prelude ];
        jailbreak = true;
        homepage = "https://scravy.de/hydrogen-data/";
@@ -76616,7 +76858,7 @@ self: {
      mkDerivation {
        pname = "hydrogen-multimap";
        version = "0.3";
-       sha256 = "0ik68a85yxdz12sgfpqi7bagkhvm9qgvl2bgplm2anxjsxcqbi93";
+       sha256 = "23c58559d7b25b252abd6f09ba1f4e75c3f9d43a115ff7b408bf755f90426646";
        libraryHaskellDepends = [ base containers ghc-prim ];
        homepage = "https://scravy.de/hydrogen-multimap/";
        description = "Hydrogen Multimap";
@@ -76628,7 +76870,7 @@ self: {
      mkDerivation {
        pname = "hydrogen-parsing";
        version = "0.17";
-       sha256 = "0m9rliry031lr7bn4xkbjmar288zcrnpsbnjdyxs13v675bh7h29";
+       sha256 = "49c0035739668fa0bb6fd22e7d6d661f219155956b7662d7c9340ce073a43955";
        libraryHaskellDepends = [
          base containers hydrogen-prelude parsec
        ];
@@ -76648,7 +76890,7 @@ self: {
      mkDerivation {
        pname = "hydrogen-prelude";
        version = "0.20";
-       sha256 = "18g3r95ssg385zqzny3137ms0ppv7d33xgvc4gvxkijv8cgj1697";
+       sha256 = "2799201f435bc6d9f7236cbf3e463bfb5ea0eb196178fbf12f683cad4bcae3a1";
        libraryHaskellDepends = [
          array base binary bytestring cereal containers directory filepath
          hashable hydrogen-multimap hydrogen-version network process random
@@ -76665,7 +76907,7 @@ self: {
      mkDerivation {
        pname = "hydrogen-prelude-parsec";
        version = "0.17";
-       sha256 = "0hdvvp3kxc66y6bxzcrjqp7wc6s21isvfra0ps53j69jmnzqd2mh";
+       sha256 = "b08a86bfad3219398abe4065b7750c421bc6cfc532b3df97f1c6b03ec7ddbb41";
        libraryHaskellDepends = [ base hydrogen-prelude parsec ];
        jailbreak = true;
        homepage = "http://scravy.de/hydrogen-prelude-parsec/";
@@ -76681,7 +76923,7 @@ self: {
      mkDerivation {
        pname = "hydrogen-syntax";
        version = "0.17";
-       sha256 = "17j6iq2fh1s3vwkzd5js786abk1zkmj4dfg425d290k4nvdl08dv";
+       sha256 = "bb2140dbb66482245a11e4b946649d3fcca50c3a5a96f627df4307e8048e469e";
        libraryHaskellDepends = [
          base containers hydrogen-parsing hydrogen-prelude nicify parsec
          uuid
@@ -76698,7 +76940,7 @@ self: {
      mkDerivation {
        pname = "hydrogen-util";
        version = "0.8";
-       sha256 = "14z2nf2af0ydqr2sm4r4cn252qn0hbacdc4z1lhyjnin66djb1a8";
+       sha256 = "4885259b31365ae9210d9fb0c6d482c0625184652493aa45c6cd03a784b3e293";
        libraryHaskellDepends = [
          base containers hydrogen-prelude parsec time
        ];
@@ -76714,7 +76956,7 @@ self: {
      mkDerivation {
        pname = "hydrogen-version";
        version = "1.4";
-       sha256 = "04v39lvh0z0ig6igsz7ncfasag3j6pdbsa86gyp63n4g325fmf38";
+       sha256 = "68b8ea8a188fd861ae7f0629bdda35723ca59563f67cfda279117c00374d6313";
        libraryHaskellDepends = [ base ];
        homepage = "https://scravy.de/hydrogen-version/";
        description = "Hydrogen Version Type";
@@ -76729,7 +76971,7 @@ self: {
      mkDerivation {
        pname = "hyena";
        version = "0.1.0.1";
-       sha256 = "0899lw0vyvcw03ph4w717rxach2ncb69xfn9387j7fl0s01ch0ji";
+       sha256 = "5102c802d080ba230f1ac9ba9ecc625640a67a3ee17002ef009c6dbf01a72921";
        libraryHaskellDepends = [
          base bytestring containers directory extensible-exceptions filepath
          mtl network network-bytestring unix
@@ -76748,7 +76990,7 @@ self: {
      mkDerivation {
        pname = "hylolib";
        version = "1.4.0";
-       sha256 = "160k8lp6r2rbgj7qz3msa5sd5yxkdb5rjlhwd5lqbcxw2sry0vj2";
+       sha256 = "426ee0b316bcb38569691c5299cb6ab3fbd27451ba8e8f8f7c2b8b6c2e451398";
        libraryHaskellDepends = [
          array base containers mtl pretty QuickCheck random uniplate
        ];
@@ -76763,7 +77005,7 @@ self: {
      mkDerivation {
        pname = "hylotab";
        version = "1.2.1";
-       sha256 = "0xynx72xpb84g19gnsgq00gwj3ycfgk5qgd9j949b6k3fqr3n71w";
+       sha256 = "3c1c3b3276639a954892a93d5ce673cc0fc91f00f869fb527804addbc5e9d677";
        isLibrary = false;
        isExecutable = true;
        executableHaskellDepends = [ base hylolib mtl ];
@@ -76778,7 +77020,7 @@ self: {
      mkDerivation {
        pname = "hyloutils";
        version = "1.0";
-       sha256 = "1pn14f3hjcxa5bww0pg2irqmbvfs7f3vfwl8z87jmxfyydgffgnh";
+       sha256 = "d03ee75ef3def52a0ffa8872b7873bdaed55718ee25dc0f92aaa33098723c1de";
        isLibrary = false;
        isExecutable = true;
        executableHaskellDepends = [
@@ -76796,7 +77038,7 @@ self: {
      mkDerivation {
        pname = "hyperdrive";
        version = "0.1";
-       sha256 = "0hvgxsrq1aws5c97w1lrk87d74kn8796vmclkdxhajfammj6ccz9";
+       sha256 = "e9336664adca49057b9b94d56dd2417692d30e9a99067e122b9aab80b3ee6f43";
        isLibrary = true;
        isExecutable = true;
        libraryHaskellDepends = [
@@ -76816,7 +77058,7 @@ self: {
      mkDerivation {
        pname = "hyperfunctions";
        version = "0";
-       sha256 = "0q452g2qzlw961zwkdihwi8d8hknxavfgd8vkjdhiazx5anbqzkm";
+       sha256 = "757ebcac2afdab089b9c1bb5e7b6ea7642d450e430b6c97f3089d38fc5138560";
        libraryHaskellDepends = [
          adjunctions base distributive profunctors transformers
        ];
@@ -76835,7 +77077,7 @@ self: {
      mkDerivation {
        pname = "hyperloglog";
        version = "0.3.4";
-       sha256 = "122qdkg1xwyhbxll5zimp8w6j79i30102g3iqf41lrbrx0xllpag";
+       sha256 = "4f5d4a3be879651a88c3713c010218311d6938ba35fe42695fd0f31ede6c5888";
        libraryHaskellDepends = [
          approximate base binary bits bytes cereal cereal-vector comonad
          deepseq distributive hashable hashable-extras lens reflection
@@ -76857,7 +77099,7 @@ self: {
      mkDerivation {
        pname = "hyperpublic";
        version = "0.1.1";
-       sha256 = "07jz89x0daps5rkmccjprrbkwn5mzdskp2yv8asfnmcyir36lmzd";
+       sha256 = "ed576a468e9e55ebb442db8b3b75fbb5583e57ce573256672efaaa067a425f1e";
        libraryHaskellDepends = [
          aeson attoparsec base bytestring http-enumerator http-types
        ];
@@ -76873,7 +77115,7 @@ self: {
      mkDerivation {
        pname = "hyphenate";
        version = "0.1";
-       sha256 = "0pnp5d1a0hwn6jm8v6i7yygd831q2bvsz6qb9n8db8n17lfxikx4";
+       sha256 = "a4cfd81d3dc1a2d5904d0b9baff712380cd49ef7279a8daa349643a0422bd75e";
        libraryHaskellDepends = [ base containers ];
        homepage = "http://www.alpheccar.org";
        description = "Text hyphenation algorithm";
@@ -76887,7 +77129,7 @@ self: {
      mkDerivation {
        pname = "hyphenation";
        version = "0.6";
-       sha256 = "1xqj4na1gm40ssirc4k70r27bzxhg2dkiipp48a5hqwgq5k3crrg";
+       sha256 = "2f673666c18f63581422f7c6389b78b0ff754406671296a3d680d417942512f7";
        libraryHaskellDepends = [
          base bytestring containers unordered-containers zlib
        ];
@@ -76911,7 +77153,7 @@ self: {
      mkDerivation {
        pname = "hypher";
        version = "0.1.5";
-       sha256 = "0q5lpza6l4aqd85i1wxkkrdd3j9kk2k8xd0l6szpgkv87b41qfhk";
+       sha256 = "133a1cc83a68cf77bf3614b48ea69833c9d15a9eb3f3100b6a58116ad4bfb460";
        libraryHaskellDepends = [
          aeson base bytestring containers data-default hashable HTTP
          http-conduit http-types lifted-base monad-control mtl resourcet
@@ -76939,7 +77181,7 @@ self: {
      mkDerivation {
        pname = "hzk";
        version = "2.1.0";
-       sha256 = "1jcvha3wzf6wka1zpmsvg1j48jl85v1s4p0mryfhjqz7l9h3wkac";
+       sha256 = "4c4d3e60a2e763099dcf155ca2c32e884a4464785bd7fb839adcb8cf87829bc9";
        libraryHaskellDepends = [ base bytestring resource-pool time ];
        librarySystemDepends = [ zookeeper_mt ];
        testHaskellDepends = [
@@ -76960,7 +77202,7 @@ self: {
      mkDerivation {
        pname = "hzulip";
        version = "1.1.1.1";
-       sha256 = "1gxywjng4mv0g13yap2a0i62l8wlbncj8ajj87ca6p8aikrd6cm1";
+       sha256 = "a132d3f28c0a5da3d841522a24995d94232a4c044a5ce547786057f2ace4bebf";
        libraryHaskellDepends = [
          aeson base bytestring conduit exceptions http-client
          http-client-tls http-types lens lens-aeson mtl stm stm-conduit text
@@ -76984,7 +77226,7 @@ self: {
      mkDerivation {
        pname = "i18n";
        version = "0.3";
-       sha256 = "0l1z9acg1nnxs66w70vyhlj3wx2xg7w0lja59yp5awmh98815q1p";
+       sha256 = "37e012104ab07255ae4f45490af8795d743e24857e83c38dd1dddaf0984a3f50";
        libraryHaskellDepends = [
          array base containers directory filepath mtl old-locale old-time
          parsec utf8-string
@@ -77002,7 +77244,7 @@ self: {
      mkDerivation {
        pname = "iCalendar";
        version = "0.4.0.3";
-       sha256 = "0dbs9s68fpx67ngjnd1p8c9n421bzn6a034dr6i3bhg2cn0s01mw";
+       sha256 = "bc06a08165e2c135a2c98d0ca08cfd2b0862134337342b9f3da65f878c4e7a35";
        libraryHaskellDepends = [
          base base64-bytestring bytestring case-insensitive containers
          data-default mime mtl network network-uri old-locale parsec text
@@ -77018,7 +77260,7 @@ self: {
      mkDerivation {
        pname = "iException";
        version = "0.0.1";
-       sha256 = "0g9hh7v5m194wyj9c5vzsjjc10fia60c9p8si778yky4chvfvj7p";
+       sha256 = "f7c8ed3664c44f8fce891addc48051d181c0a4d47f1796a4e724855af681303d";
        libraryHaskellDepends = [ base interleavableIO mtl ];
        description = "Version of Control.Exception using InterleavableIO.";
        license = "unknown";
@@ -77032,7 +77274,7 @@ self: {
      mkDerivation {
        pname = "iap-verifier";
        version = "0.1.0.1";
-       sha256 = "0mf55kx2y5q8qldgqcq805r3565nxngjm7nwq4q2xy54s7m2fsha";
+       sha256 = "0a6a27ead1a4f82e30c1dc9e2a9fedb6983272010833fc1ac508172ffa2cc555";
        libraryHaskellDepends = [
          aeson base base64-bytestring bytestring conduit http-conduit
          monads-tf text transformers
@@ -77048,7 +77290,7 @@ self: {
      mkDerivation {
        pname = "ib-api";
        version = "0.1.0.1";
-       sha256 = "0zswsb7mvbm8zycb14sks2kvg4jy2wn3vc7z6lb00s0alm1v0srk";
+       sha256 = "336bb043a50a68001635ffb03d2c175e92b7a7d05393b098ffa8ae5dcfd25c7f";
        isLibrary = true;
        isExecutable = true;
        libraryHaskellDepends = [ attoparsec base bytestring network ];
@@ -77068,7 +77310,7 @@ self: {
      mkDerivation {
        pname = "iban";
        version = "0.1.1.0";
-       sha256 = "0rg4h2as5n324zf9y6jllz28s4wj687vdiqvrbnzlavl2kbx96vl";
+       sha256 = "749bd4d714742bfaedca1bc7b60f3292138dc4a7541a9fdc2762d8a29580e465";
        libraryHaskellDepends = [
          base containers iso3166-country-codes text unordered-containers
        ];
@@ -77085,7 +77327,7 @@ self: {
      mkDerivation {
        pname = "iconv";
        version = "0.4.1.3";
-       sha256 = "0m5m0ph5im443xcz60wm1zp98bnmf8l1b5gfllxwhjriwdl52hin";
+       sha256 = "36425168e3314bc83ba5ee95152872d52e94ee0f9503f3591f84d458e005b554";
        libraryHaskellDepends = [ base bytestring ];
        description = "String encoding conversion";
        license = stdenv.lib.licenses.bsd3;
@@ -77104,7 +77346,7 @@ self: {
      mkDerivation {
        pname = "ide-backend";
        version = "0.10.0";
-       sha256 = "18p079m9hfi4mbhyp8fhlhzlvhdpr9v82ih49s1630rxaf15z8r6";
+       sha256 = "26a35f82533d8361824e04468176cab7c14d3fa4d0a1ebe1aa243a986a3ae0a2";
        isLibrary = true;
        isExecutable = true;
        libraryHaskellDepends = [
@@ -77142,7 +77384,7 @@ self: {
      mkDerivation {
        pname = "ide-backend-common";
        version = "0.10.0";
-       sha256 = "1x230hvxr5n8d04q9cdjryalrp47q9vsamgd0qafw1x25ar1fxwl";
+       sha256 = "947717b22aa207ee1406ed55a577c287dc4c95cfb2b1840968c896dc370443f4";
        libraryHaskellDepends = [
          aeson async attoparsec base binary bytestring bytestring-trie
          containers crypto-api data-accessor directory filepath fingertree
@@ -77158,7 +77400,7 @@ self: {
      mkDerivation {
        pname = "ide-backend-rts";
        version = "0.1.3.1";
-       sha256 = "1zj1glpyhmgpkxy4n96aqqf3s1gl2irl8ksnx4i9y4nwvs06qzj0";
+       sha256 = "407e6c80dedc129f22e9564f447314f4053d1cc6ca244b7c9ff755e82f7d41fe";
        libraryHaskellDepends = [ base ];
        description = "RTS for the IDE backend";
        license = stdenv.lib.licenses.mit;
@@ -77174,7 +77416,7 @@ self: {
      mkDerivation {
        pname = "ide-backend-server";
        version = "0.10.0";
-       sha256 = "1kahc57f5jrz7869phzlbk6y3apwyh3j6k8b7xbyfcc4qwq6jgry";
+       sha256 = "3e3f6930c78431e7573f0b4d2307f4fcaae1cd5cf4c39b0c3a3fcbe24e6150cd";
        isLibrary = false;
        isExecutable = true;
        executableHaskellDepends = [
@@ -77197,7 +77439,7 @@ self: {
      mkDerivation {
        pname = "ideas";
        version = "1.3.1";
-       sha256 = "1rwvnxih9lb8hw3wvnv377z78szdq80qsrspnxbdqf37kfdw3fx0";
+       sha256 = "a0bbc19b9b6738dc56b757678d01c2ed6b74fe3963dbcd078768d10463b79be7";
        libraryHaskellDepends = [
          array base bytestring containers Diff directory exceptions filepath
          mtl multipart network old-locale old-time parsec QuickCheck random
@@ -77217,7 +77459,7 @@ self: {
      mkDerivation {
        pname = "ideas-math";
        version = "1.2";
-       sha256 = "1s3pryjzc7dkmfdfrysag1w1j752y29cga4040a8fag10n9w7rr2";
+       sha256 = "22e7c39305e12987142080a8c792f0a21c1978784afbec9aabb31df6a5cf77e8";
        isLibrary = false;
        isExecutable = true;
        executableHaskellDepends = [
@@ -77235,7 +77477,7 @@ self: {
      mkDerivation {
        pname = "idempotent";
        version = "0.1.2";
-       sha256 = "18jwk65mm50lqnbx9px4c8aa2x7n5dkrazzpzvdwq7cy4q614bj0";
+       sha256 = "402e120c269e1dccdbfef77f95672bf674a11462a4dfd497c514945a8b995ca2";
        libraryHaskellDepends = [ base containers ];
        testHaskellDepends = [ base containers hspec QuickCheck ];
        jailbreak = true;
@@ -77252,7 +77494,7 @@ self: {
      mkDerivation {
        pname = "identifiers";
        version = "0.4.0.0";
-       sha256 = "0lk58c465a77mshz1b8rdgpidkgr73xbh9q0hij5dqw8d32h958f";
+       sha256 = "0e9504c56888e35664840027b8fa38f9cd16ef6b19adf0a1aee7a86208436552";
        libraryHaskellDepends = [
          base binary cereal containers deepseq hashable ListLike text
          unordered-containers
@@ -77273,7 +77515,7 @@ self: {
      mkDerivation {
        pname = "idiii";
        version = "0.1.3.3";
-       sha256 = "11595aj56sjwk28grh6ldsbk5c6kgrirsc2xglfixw82vj7viw8h";
+       sha256 = "10f1b88fdc02f11e1d7d5d309d637ed3b032976ed4c0fc90985c6a53a42aa984";
        isLibrary = true;
        isExecutable = true;
        libraryHaskellDepends = [
@@ -77295,7 +77537,7 @@ self: {
      mkDerivation {
        pname = "idna";
        version = "0.3.0";
-       sha256 = "04w2mp9wa4mzdz4njx47j081jia8y000b46cw8vmx44fx8gv1zwp";
+       sha256 = "97ffb01fea8e905e37e2cc900500f04845191090877469c96fbf12c5d3ad8213";
        libraryHaskellDepends = [ base punycode stringprep text ];
        description = "Implements IDNA (RFC 3490)";
        license = stdenv.lib.licenses.bsd3;
@@ -77306,7 +77548,7 @@ self: {
      mkDerivation {
        pname = "idna2008";
        version = "0.0.1.0";
-       sha256 = "1pd62pr1hyk565mxc15f5lxyms58bywcqll5ya6cnzw20lv4lzlz";
+       sha256 = "9f7e4a3605827fcb8cf28552ccb85fa8e8ea3b2dae04d66b31657a18f215a6dd";
        libraryHaskellDepends = [ base punycode split ];
        jailbreak = true;
        description = "Converts Unicode hostnames into ASCII";
@@ -77327,7 +77569,7 @@ self: {
      mkDerivation {
        pname = "idris";
        version = "0.9.18.1";
-       sha256 = "0xd4kqnjdx427l26b07rrw9bnrxb8zrsqy93wayf4rmg6l8rymj8";
+       sha256 = "48569f1135af66e2bce22379acf347ab67bb12cff98065043d82f4262d9ea475";
        configureFlags = [ "-fffi" "-fgmp" ];
        isLibrary = true;
        isExecutable = true;
@@ -77354,7 +77596,7 @@ self: {
      mkDerivation {
        pname = "ieee";
        version = "0.7";
-       sha256 = "0ckhmy10l4kchr5bg1hlygrj86ij0wrj3r8in9g3c3jhh00dx3km";
+       sha256 = "758ede0080500e365eb211e5213307321a24f3f31486b74a866c120a82af7032";
        libraryHaskellDepends = [ base ];
        homepage = "http://github.com/patperry/hs-ieee";
        description = "Utilities for dealing with IEEE floating point numbers";
@@ -77366,7 +77608,7 @@ self: {
      mkDerivation {
        pname = "ieee-utils";
        version = "0.4.0";
-       sha256 = "0548m1xjvzf65kkklmqjr2f5h85zdfpvxmdbx5rcg33zi8aiqfgk";
+       sha256 = "f3391c158a7f8cc772e9abd5beaf6bbf20589cc812573ae72cc6fd2d7ba88814";
        libraryHaskellDepends = [ base ];
        description = "ieee-utils";
        license = stdenv.lib.licenses.bsd3;
@@ -77378,7 +77620,7 @@ self: {
      mkDerivation {
        pname = "ieee-utils-tempfix";
        version = "0.4.0.1";
-       sha256 = "0x0mkvnf3q4yfh7bi7hv6364gy0l57syzy9xgzyax8z94zh465c3";
+       sha256 = "831543e027e9a3aefc7f3df9eff52914f847cc301b9eb80e749ee0e1ec9e1574";
        libraryHaskellDepends = [ base ];
        description = "ieee-utils";
        license = stdenv.lib.licenses.bsd3;
@@ -77389,7 +77631,7 @@ self: {
      mkDerivation {
        pname = "ieee754";
        version = "0.7.6";
-       sha256 = "03s56h82n7hcwcn2dhd646prcf9wxj5jq49xqsnl7cnvi9768h2q";
+       sha256 = "5840644e8adbb243adc63d112c8bec3c3996af21a6c1262ce30c1e2b1034450f";
        libraryHaskellDepends = [ base ];
        homepage = "http://github.com/patperry/hs-ieee754";
        description = "Utilities for dealing with IEEE floating point numbers";
@@ -77401,7 +77643,7 @@ self: {
      mkDerivation {
        pname = "ieee754-parser";
        version = "0.1";
-       sha256 = "06pyzjd9imcnrffc0h4dwq46llkb9cmfk1nygmjgfz0y0f9481iv";
+       sha256 = "3b064492031e7cf7647dde86e92a4b6b526a08e68d40c09ccb96d5989afcfe1a";
        libraryHaskellDepends = [ base binary bytestring ];
        license = "GPL";
      }) {};
@@ -77411,7 +77653,7 @@ self: {
      mkDerivation {
        pname = "iff";
        version = "0.0.5";
-       sha256 = "1qy19d39zkf79z2j3mvimcnr48vpka5zj05g46fl4f9hz9xjiv16";
+       sha256 = "26ec287bfa3039429d21af00f98b9a7723922dab71d721c54fc7cd9f464bc1e3";
        libraryHaskellDepends = [ base binary bytestring ];
        homepage = "http://code.haskell.org/~thielema/iff/";
        description = "Constructing and dissecting IFF files";
@@ -77425,7 +77667,7 @@ self: {
      mkDerivation {
        pname = "ifscs";
        version = "0.2.0.0";
-       sha256 = "1675j66kmlfcwd8g0wanx4jfs3vnnvz8hpazskzng6ghvp4bam1q";
+       sha256 = "3854b5c8ddf09967ffd45f5d88feb6760fed24e95671f050e3ccd13a8d91e598";
        libraryHaskellDepends = [ base containers failure ];
        testHaskellDepends = [
          base HUnit test-framework test-framework-hunit
@@ -77443,8 +77685,8 @@ self: {
      }:
      mkDerivation {
        pname = "ig";
-       version = "0.3.1";
-       sha256 = "0ggr6h5inwwxvqs9qywiagi1c5bx1vky5h0zvhz0df88nbfd3d21";
+       version = "0.4";
+       sha256 = "ed03d66cd64476c6f0065251ad777cdbfb62a740802007218dd24f732fcf723e";
        libraryHaskellDepends = [
          aeson base base16-bytestring bytestring conduit conduit-extra
          crypto-api cryptohash cryptohash-cryptoapi data-default
@@ -77463,7 +77705,7 @@ self: {
      mkDerivation {
        pname = "ige-mac-integration";
        version = "0.1.0.1";
-       sha256 = "1949c5v3157xlwcmddawc79iagxlgy4l08skpkldi45amyy3jqn6";
+       sha256 = "c66239bcafaa90d8e8bc532340897fb43f15d3615cb55619a7fd9430766189a4";
        libraryHaskellDepends = [
          array base containers glib gtk haskell98 mtl
        ];
@@ -77483,7 +77725,7 @@ self: {
      mkDerivation {
        pname = "igraph";
        version = "0.1.1";
-       sha256 = "098b1y1iwmlpi3kspq4cd82cs0bbxvygghssjr986664lgv06hsd";
+       sha256 = "4d4303f6a3c4188352965ac3f7fcee6b01cd046a8ce0abe78897561e830f0b25";
        libraryHaskellDepends = [
          base containers hashable unordered-containers
        ];
@@ -77500,7 +77742,7 @@ self: {
      mkDerivation {
        pname = "igrf";
        version = "0.2.0.0";
-       sha256 = "04ipbhry1v3cpkflshqa9sp46px0k6g67n8apvdqykk5fsssdpm1";
+       sha256 = "a1dea6b576654e8fdbbe0ad9639e99a05f43ae4e0a434dddbc6cece0335c3712";
        revision = "1";
        editedCabalFile = "7d616cb461fb1406310675937e1e761f2d09757824dce8a92d235b7ef6ce1e4f";
        libraryHaskellDepends = [ ad base polynomial ];
@@ -77521,8 +77763,8 @@ self: {
      }:
      mkDerivation {
        pname = "ihaskell";
-       version = "0.6.4.0";
-       sha256 = "1jcksbc82csr11lpy5jakf7g6wj2w7mx27cp7knlbi65fsablsk5";
+       version = "0.6.4.1";
+       sha256 = "524cf3836857ba1762f895379b533352cf25a532ad8825f93f9842d9f235adbe";
        isLibrary = true;
        isExecutable = true;
        libraryHaskellDepends = [
@@ -77559,7 +77801,7 @@ self: {
      mkDerivation {
        pname = "ihaskell-aeson";
        version = "0.3.0.0";
-       sha256 = "0h2bbkqwl8mdyn24n0lphcjfrvmfq8ckincv3rncspp9h0v705m7";
+       sha256 = "a716703680e95ecd6c1e9bd93819c2aeeeec248397024b84f5ad22caf15c4b40";
        libraryHaskellDepends = [
          aeson aeson-pretty base bytestring here ihaskell text
        ];
@@ -77574,7 +77816,7 @@ self: {
      mkDerivation {
        pname = "ihaskell-basic";
        version = "0.3.0.0";
-       sha256 = "1vb4x6h6bs3liq1bbnhs3ns0zrk4czy63zmkp1q075g7fq1fh7hw";
+       sha256 = "1c1ee80276e7950370b8b3fe61fc6764e60fb41d1adab5028e74e865a0e964ed";
        libraryHaskellDepends = [ base ihaskell ];
        homepage = "http://www.github.com/gibiansky/IHaskell";
        description = "IHaskell display instances for basic types";
@@ -77587,7 +77829,7 @@ self: {
      mkDerivation {
        pname = "ihaskell-blaze";
        version = "0.3.0.0";
-       sha256 = "1il3iz1nksh5v753srvchrjdazf7dqsd3q59w7crzbyrlx81v97b";
+       sha256 = "eba41d50a7d9af9fd9e1a9e0d1346ec77dd564866c673dcad905ea69c38f83c6";
        libraryHaskellDepends = [ base blaze-html blaze-markup ihaskell ];
        homepage = "http://www.github.com/gibiansky/ihaskell";
        description = "IHaskell display instances for blaze-html types";
@@ -77602,7 +77844,7 @@ self: {
      mkDerivation {
        pname = "ihaskell-charts";
        version = "0.3.0.0";
-       sha256 = "0nlimyx953v1s4xgzdb9987i9bw1bdralkg2x6cp41kzqd49i4f3";
+       sha256 = "c3919848c37f067299e9e24daa725b81af140f4a69b5ff3ad1618f92baaf915a";
        libraryHaskellDepends = [
          base bytestring Chart Chart-cairo data-default-class directory
          ihaskell
@@ -77620,7 +77862,7 @@ self: {
      mkDerivation {
        pname = "ihaskell-diagrams";
        version = "0.3.0.0";
-       sha256 = "0w1jzsrn9lpgrwbr1wsy7kqvkdbq5v21fm67gxif0xrv6hgavzca";
+       sha256 = "8afdad1e343b77e0627fc75417c42e78b5b9f13c5ef39017cfefd264b3fe3270";
        libraryHaskellDepends = [
          active base bytestring diagrams diagrams-cairo diagrams-lib
          directory ihaskell text
@@ -77635,7 +77877,7 @@ self: {
      mkDerivation {
        pname = "ihaskell-display";
        version = "0.1.0.0";
-       sha256 = "1cbfhv9kg33dj28mn6mhhi363pz9jr2kw4ph64ga1fiawlj563l0";
+       sha256 = "800e5324e52abaa01e31f0123e4596e9df614684b01a5b91906d8c37d3866eb1";
        libraryHaskellDepends = [ base classy-prelude ihaskell ];
        jailbreak = true;
        homepage = "http://www.github.com/gibiansky/IHaskell";
@@ -77648,10 +77890,9 @@ self: {
     ({ mkDerivation, base, HaTeX, ihaskell, text }:
      mkDerivation {
        pname = "ihaskell-hatex";
-       version = "0.2.0.0";
-       sha256 = "02ynqhirz8bblcfaxksgxxqgnkmxqazj8imwxc2gbrw2v3p0i39s";
+       version = "0.2.1.0";
+       sha256 = "11999ba26d5d09a1f51f88907ca52dcbff9b7714e3f8b66d2bb150cd975a1525";
        libraryHaskellDepends = [ base HaTeX ihaskell text ];
-       jailbreak = true;
        homepage = "http://www.github.com/gibiansky/IHaskell";
        description = "IHaskell display instances for hatex";
        license = stdenv.lib.licenses.mit;
@@ -77664,7 +77905,7 @@ self: {
      mkDerivation {
        pname = "ihaskell-juicypixels";
        version = "0.3.0.0";
-       sha256 = "0apsll540z4hzzs39bqk14iadnr4rjp873q712la7lp2xnyf4k0y";
+       sha256 = "1e4ce2bcede2d2a3a808078f83aecc24dba6220913af34f4ff907c400aa5fa2a";
        libraryHaskellDepends = [
          base bytestring directory ihaskell JuicyPixels
        ];
@@ -77681,7 +77922,7 @@ self: {
      mkDerivation {
        pname = "ihaskell-magic";
        version = "0.3.0.0";
-       sha256 = "05jvyca163daqrmpb7fhk1wng04vk4bayffp0lp68sy3zskrjndl";
+       sha256 = "b45999a7fec36b642e05d739af16999b80677998d09d756bc6aa0d1314f35b16";
        libraryHaskellDepends = [
          base base64-bytestring bytestring ihaskell ipython-kernel magic
          text utf8-string
@@ -77699,7 +77940,7 @@ self: {
      mkDerivation {
        pname = "ihaskell-parsec";
        version = "0.3.0.0";
-       sha256 = "0n1awvn81228cci1q1rvy7p91zfl29byp5imkiwqbxswzz5sq8n4";
+       sha256 = "c422accbff5cf785799c3596eb5712d4fd90eef13b071c2263488880ece62a58";
        libraryHaskellDepends = [
          aeson base here ihaskell parsec random text unordered-containers
        ];
@@ -77715,7 +77956,7 @@ self: {
      mkDerivation {
        pname = "ihaskell-plot";
        version = "0.3.0.0";
-       sha256 = "17qp2ln9v4sv9i3biyxgyq0csqikxwm5gs612fn5zsl1ixznj1h1";
+       sha256 = "0106697f8f81ea5fac13c1e8572aef3362cd00f6affbb8464c5b939d2c15179f";
        libraryHaskellDepends = [ base bytestring ihaskell plot ];
        homepage = "http://www.github.com/gibiansky/ihaskell";
        description = "IHaskell display instance for Plot (from plot package)";
@@ -77731,7 +77972,7 @@ self: {
      mkDerivation {
        pname = "ihaskell-rlangqq";
        version = "0.3.0.0";
-       sha256 = "1w2ywl3m122d56cvgnhll6dpjw03y2jy3nc8v325291zhknrziaj";
+       sha256 = "52c59fed843f2451c4d888d9e1a5f00370799ba114dab799294d885007e55ef0";
        libraryHaskellDepends = [
          base base64-bytestring blaze-html bytestring directory filepath
          ihaskell ihaskell-blaze Rlang-QQ split stm template-haskell xformat
@@ -77741,6 +77982,27 @@ self: {
        hydraPlatforms = stdenv.lib.platforms.none;
      }) {};
 
+  "ihaskell-widgets" = callPackage
+    ({ mkDerivation, aeson, base, containers, ihaskell, ipython-kernel
+     , nats, scientific, singletons, text, unix, unordered-containers
+     , vector, vinyl
+     }:
+     mkDerivation {
+       pname = "ihaskell-widgets";
+       version = "0.1.0.0";
+       sha256 = "342a68d3fb3d6ec75e8fe249c6c99863c02f3c242b705a7659a63ce3ed586652";
+       revision = "1";
+       editedCabalFile = "94521ebd405d3a25cbdc349cbc1a29ee14032e9829f2da4cddec71b29e47a92e";
+       libraryHaskellDepends = [
+         aeson base containers ihaskell ipython-kernel nats scientific
+         singletons text unix unordered-containers vector vinyl
+       ];
+       jailbreak = true;
+       homepage = "http://www.github.com/gibiansky/IHaskell";
+       description = "IPython standard widgets for IHaskell";
+       license = stdenv.lib.licenses.mit;
+     }) {};
+
   "ihttp" = callPackage
     ({ mkDerivation, attoparsec, base, bytestring, containers
      , contstuff, enumerator, netlines, network
@@ -77748,7 +78010,7 @@ self: {
      mkDerivation {
        pname = "ihttp";
        version = "0.3.0";
-       sha256 = "1rcv92cdy3g9v3qgr3zvjjj0c4d7k99n7ya0mym0bjj79wj4r5zm";
+       sha256 = "f5974c244f47ca05aaaf40f963539aa71106a494fb8ffcf0d8e90ddf98489be5";
        isLibrary = true;
        isExecutable = true;
        libraryHaskellDepends = [
@@ -77767,7 +78029,7 @@ self: {
      mkDerivation {
        pname = "illuminate";
        version = "0.1";
-       sha256 = "16ijh2sadbayh3ldiagjq67xilhyv55qhqmmz8a73lbnlq3cphk5";
+       sha256 = "65c2cb06a676d17114fab562884bd91ed2d88fc1f2a9d8e8805eada6b480329a";
        isLibrary = true;
        isExecutable = true;
        libraryHaskellDepends = [
@@ -77787,7 +78049,7 @@ self: {
      mkDerivation {
        pname = "image-type";
        version = "0.1.0.0";
-       sha256 = "0xr55c5g4jn1y83qy7bqa5ww9r73vw9clgln9ld893vypmb91wks";
+       sha256 = "7af29056bd7e8f841a4d963eca12dfe3e4c47951781d8f07f2c14af20a2b2577";
        revision = "1";
        editedCabalFile = "47033c893690f2cea85ba867343f277a8e2594f9010a5466a39dc7f3c4d682f2";
        libraryHaskellDepends = [ base bytestring ];
@@ -77801,7 +78063,7 @@ self: {
      mkDerivation {
        pname = "imagefilters";
        version = "0.1";
-       sha256 = "1n7awx8wsm6z0sp54jri3sp403n14wzr08vjj4a422q1lf306l3y";
+       sha256 = "7e500386a3010b4114917223903f27c10e40ae1e314b52ae06df54cd51e7ead8";
        libraryHaskellDepends = [ base gd ];
        homepage = "https://github.com/tchannel/imagefilters";
        description = "Image Filters (contrast, brightness, gaussian blur, etc)";
@@ -77817,7 +78079,7 @@ self: {
      mkDerivation {
        pname = "imagemagick";
        version = "0.0.3.5";
-       sha256 = "0vwmx86wpxr1f5jrwlqpvrb94dbrm0jjdqq6bppfnfyppd3s1mmq";
+       sha256 = "b8d6a047bbd73bebee5d06e32625a879359256de17539e657121f7cb0dea956f";
        revision = "1";
        editedCabalFile = "9666a02ba8aef32515f97734c86453b3b9759c46c6a9306be9f20dbdb6b98203";
        isLibrary = true;
@@ -77844,7 +78106,7 @@ self: {
      mkDerivation {
        pname = "imagepaste";
        version = "0.2.0.1";
-       sha256 = "1k512mw4a2hm6nzz2sn00rmkf7fb7mj4a2lk1klr1wmlchwimvpv";
+       sha256 = "fbee1a3964b4f290e90c930a45643dcb1d376b06c06af1bf35150a457815a1cc";
        isLibrary = false;
        isExecutable = true;
        executableHaskellDepends = [
@@ -77864,7 +78126,7 @@ self: {
      mkDerivation {
        pname = "imagesize-conduit";
        version = "1.1";
-       sha256 = "06dc0453l7n3g05pg118y4smlzkl6p56zazpi4dr41dkg12pii9i";
+       sha256 = "31c5784578b305921b89f7ab6fca35747e5a35f12884770b78c31e3a0a01ac19";
        libraryHaskellDepends = [
          base bytestring conduit conduit-extra exceptions
        ];
@@ -77883,7 +78145,7 @@ self: {
      mkDerivation {
        pname = "imapget";
        version = "0.0.3";
-       sha256 = "0h6kbh3z78xm1rjphyv7zkjc5knd7v9agss0b9rzarm1z4qd2q5v";
+       sha256 = "bb60d130f9a166f5735a40eba7d23ecdcec2e4fc677b78650eb5a3f3075cd340";
        isLibrary = false;
        isExecutable = true;
        executableHaskellDepends = [
@@ -77902,7 +78164,7 @@ self: {
      mkDerivation {
        pname = "imbib";
        version = "1.0.0";
-       sha256 = "0x31wjd6maqixr3rbangaph0s5skp18fmb8xgm1a6jsky8k367vz";
+       sha256 = "7f1f3326f2534ba3427d1dadea50b853170de055cfaa9547ee11ab6a9ae46174";
        isLibrary = false;
        isExecutable = true;
        executableHaskellDepends = [
@@ -77923,7 +78185,7 @@ self: {
      mkDerivation {
        pname = "imgurder";
        version = "1.2";
-       sha256 = "156a3fq274112j3a6lqiprwhgrcrjp3izix2z1s9bbx3c04pwrjx";
+       sha256 = "5d667e0960a3af9574f8a2c71fc79599e50779be1153a38614219023b01bca94";
        isLibrary = true;
        isExecutable = true;
        libraryHaskellDepends = [
@@ -77948,7 +78210,7 @@ self: {
      mkDerivation {
        pname = "imm";
        version = "0.6.0.3";
-       sha256 = "0fhqb36xj2xr1hhfrhk1npms9lnvbh6fmvki9mmm3gqs06hb925l";
+       sha256 = "b488b4a0011abf516b4d71eeea0c5cdbd2a4ebb561c2ec200cb90bd9cd58183a";
        revision = "1";
        editedCabalFile = "c14d5caa0066c05d15589dfbb663c5397bcb6d12ab4477de1d7572e3a16b132d";
        isLibrary = true;
@@ -77974,7 +78236,7 @@ self: {
      mkDerivation {
        pname = "immortal";
        version = "0.2";
-       sha256 = "1si9zh309xh29qrxkhb0shwisjrsja2d9lpj17dwlzn0gv0i1672";
+       sha256 = "e29810c17ec07ecadb09f2d2d484923a4b1d39d460c1d9334e02f60406fc29ea";
        libraryHaskellDepends = [
          base lifted-base monad-control transformers-base
        ];
@@ -77994,7 +78256,7 @@ self: {
      mkDerivation {
        pname = "imparse";
        version = "0.0.0.3";
-       sha256 = "15bpz985d39az15jn8hd6wcil7ivsi3vcnxi5lcfs34i848rs9fg";
+       sha256 = "cf259d1141910ced182db15bb647d43b1e1a19370d222b4bf82a8d5650fa7795";
        isLibrary = true;
        isExecutable = true;
        libraryHaskellDepends = [
@@ -78020,7 +78282,7 @@ self: {
      mkDerivation {
        pname = "implicit";
        version = "0.0.3";
-       sha256 = "0zsd25gd0c4sp1ipjnsbn1gbdl6s0y2vy8n4nwn3dxgrv75cd1l9";
+       sha256 = "8986c6cad9f9f5362cb7c422bf8507dad0b65eb04b5b7963b89a30d05e114d7f";
        isLibrary = true;
        isExecutable = true;
        libraryHaskellDepends = [
@@ -78040,7 +78302,7 @@ self: {
      mkDerivation {
        pname = "implicit-params";
        version = "0.2.1";
-       sha256 = "1da01fnwxf1350ywawvl58qf479q2rz81wi9s8lvw2n3d75qpn8i";
+       sha256 = "11d98bcb69c30abe29d229f2807e16381de2302a7473c53d2823b8cead0b40b5";
        libraryHaskellDepends = [ base data-default-class ];
        homepage = "http://github.com/duairc/implicit-params";
        description = "Named and unnamed implicit parameters with defaults";
@@ -78052,7 +78314,7 @@ self: {
      mkDerivation {
        pname = "imports";
        version = "0.1.2.1";
-       sha256 = "1hm4dg07mw8cihkqziz827kwa3qqvgjg1y45r2lg66crsaanprgz";
+       sha256 = "ffe56b95d29919f3a8c885f8f0e4db180fc5e711e8c78f278c0cf17ac06ba4c2";
        libraryHaskellDepends = [ base directory filepath mtl ];
        testHaskellDepends = [ base directory filepath mtl ];
        jailbreak = true;
@@ -78066,7 +78328,7 @@ self: {
      mkDerivation {
        pname = "improve";
        version = "0.4.0";
-       sha256 = "0z8w7lgk263ickb4l3ajhvy1bjq38bbiiw6c048a3yn4h8kpg67a";
+       sha256 = "ea98772782c4faa11001ccf018d74203cb15fc86520d4ad6647118311f3d1c7d";
        libraryHaskellDepends = [ base mtl yices ];
        jailbreak = true;
        homepage = "http://github.com/tomahawkins/improve/wiki/ImProve";
@@ -78080,7 +78342,7 @@ self: {
      mkDerivation {
        pname = "inc-ref";
        version = "0.3.0.0";
-       sha256 = "0hr25bdwq2a1mj74wb8dvb95jyfqx13rz0h4makyb5kqlhxz40xl";
+       sha256 = "b403f23ba47896e5a7aa04829f47e8d87959d2da0d2d4e8eac4109ccdb2a2243";
        libraryHaskellDepends = [ base stm ];
        homepage = "https://github.com/jfischoff/inc-ref";
        description = "A STM reference useful for incremental computing";
@@ -78094,7 +78356,7 @@ self: {
      mkDerivation {
        pname = "inch";
        version = "0.2.0";
-       sha256 = "05f25yza05ib0xnkpfimhrb3nqyp5km85r1j9n6yh9k0cwdagndi";
+       sha256 = "b1d9a71a676026e88d4d32e482ea2cd7633b568635ba3b6d072b16a0be2fc215";
        isLibrary = false;
        isExecutable = true;
        executableHaskellDepends = [
@@ -78116,7 +78378,7 @@ self: {
      mkDerivation {
        pname = "include-file";
        version = "0.1.0.2";
-       sha256 = "0yrqvdp37wjw9j7vknzyiw4954yskxh75z8r3sic6qdmz17zv8ba";
+       sha256 = "6aa1fd4ff8b561c3a21e19fd72609fda9392088ffedbb98f4c5cf2336edb387b";
        libraryHaskellDepends = [ base bytestring template-haskell ];
        testHaskellDepends = [ base bytestring ];
        description = "Inclusion of files in executables at compile-time";
@@ -78131,7 +78393,7 @@ self: {
      mkDerivation {
        pname = "incremental-computing";
        version = "0.0.0.0";
-       sha256 = "0zdq122m0nq18igvdxis7lqgdflf6sc94m1aqypjwfkxy4qfvvq3";
+       sha256 = "03efed30f17d3a2eafc72a549298368ebaf6303d3af6b65f44015b508508b87d";
        libraryHaskellDepends = [
          base containers dlist fingertree order-maintenance transformers
        ];
@@ -78151,7 +78413,7 @@ self: {
      mkDerivation {
        pname = "incremental-parser";
        version = "0.2.3.4";
-       sha256 = "0n2318i4dzgcs9xcs80wcfbm9rc902w02nwqa30b3nrwl21cjag3";
+       sha256 = "e329c982a03cdbb1c050985b01b80089e55497631c20cd7ad2ecfd46220a4358";
        libraryHaskellDepends = [ base monoid-subclasses ];
        testHaskellDepends = [
          base checkers monoid-subclasses QuickCheck tasty tasty-quickcheck
@@ -78166,7 +78428,7 @@ self: {
      mkDerivation {
        pname = "incremental-sat-solver";
        version = "0.1.7";
-       sha256 = "1kic3q19lli8yd28szrngpfsqi50wc47k6597ay24zmiikhx4c2v";
+       sha256 = "5b30d2e18cb17e22bc3aa9987908e3a044acdd7d367f8d44f328529a021e2cce";
        libraryHaskellDepends = [ base containers mtl ];
        homepage = "http://github.com/sebfisch/incremental-sat-solver";
        description = "Simple, Incremental SAT Solving as a Library";
@@ -78181,7 +78443,7 @@ self: {
      mkDerivation {
        pname = "increments";
        version = "0.1.0.4";
-       sha256 = "0dsand1y9f215fsikwr2601zxrzxpv85aka6f0gaaf0657mr4x9i";
+       sha256 = "317592eb290638a51e70464d55d0befde7fe033022f319b52b41b8e443b34a37";
        libraryHaskellDepends = [
          base beamable bytestring containers ghc-prim
        ];
@@ -78202,7 +78464,7 @@ self: {
      mkDerivation {
        pname = "indentation";
        version = "0.2.1.1";
-       sha256 = "1wb5kv0wx25hhg08afsqpzkkc8c981pbhp8wrzdclb4105y4l4vj";
+       sha256 = "72134a7c01812ccadacf1c5db86e40892136e7bf583b85c083b088cec19e65f1";
        libraryHaskellDepends = [ base mtl parsec parsers trifecta ];
        testHaskellDepends = [ base parsec tasty tasty-hunit trifecta ];
        homepage = "https://bitbucket.org/mdmkolbe/indentation";
@@ -78215,7 +78477,7 @@ self: {
      mkDerivation {
        pname = "indentparser";
        version = "0.1";
-       sha256 = "141bzmhdk5x2bzjx9g7hcf5p07h4q2vzzxlda8vf3dcgxgpdc7aw";
+       sha256 = "5c1dd6eeeb8fb5e136528df6ffb7c0041e708b63f0bcd4e55fa297d960fd2b90";
        isLibrary = true;
        isExecutable = true;
        libraryHaskellDepends = [ base mtl parsec ];
@@ -78229,7 +78491,7 @@ self: {
      mkDerivation {
        pname = "indents";
        version = "0.3.3";
-       sha256 = "16lz21bp9j14xilnq8yym22p3saxvc9fsgfcf5awn2a6i6n527xn";
+       sha256 = "b61f51ac894609cb5571cc3ded12db5de97185a8de236c69ec24c87457109f9a";
        libraryHaskellDepends = [ base concatenative mtl parsec ];
        homepage = "http://patch-tag.com/r/salazar/indents";
        description = "indentation sensitive parser-combinators for parsec";
@@ -78241,7 +78503,7 @@ self: {
      mkDerivation {
        pname = "index-core";
        version = "1.0.2";
-       sha256 = "0sj69r9mavw1s17lhh7af9n5vrb60gk5lm6v593sp0rs77canldw";
+       sha256 = "bc51abd8393a83ab472adb545ae60366e55d6c72ea40484fd0816f55534e466a";
        revision = "1";
        editedCabalFile = "97808339bd2ac8a5c79ed99e716e2e8e941234421fde3930b370e0bbc734b063";
        libraryHaskellDepends = [ base ];
@@ -78256,7 +78518,7 @@ self: {
      mkDerivation {
        pname = "indexed";
        version = "0.1";
-       sha256 = "1dx5pyi5psjd2l26hc3wfsapnywdl0kqpw98b3jwc0xq4406ax12";
+       sha256 = "2274650021b803c6e55828f18b27a08d7b7b95767c306804154dea5ba2bfa5b7";
        libraryHaskellDepends = [ base ];
        homepage = "https://github.com/reinerp/indexed";
        description = "Haskell98 indexed functors, monads, comonads";
@@ -78269,7 +78531,7 @@ self: {
      mkDerivation {
        pname = "indexed-do-notation";
        version = "0.1";
-       sha256 = "10yvbhjjzg19lyw9ynn2j1cyms2k4hxly5hmw0ad416f8zxmisf9";
+       sha256 = "c9e958fb47ce04d214e015164f3b2453e8ea5990c25a9fb8a729bc2f255cdb83";
        libraryHaskellDepends = [
          base haskell-src-meta indexed template-haskell
        ];
@@ -78283,7 +78545,7 @@ self: {
      mkDerivation {
        pname = "indexed-extras";
        version = "0.1.1";
-       sha256 = "0mhzk2smcli5mk6ghcxpbnq58adryf42s50qmqrj72sxsfd7a09r";
+       sha256 = "3901759ad35d8b2333ae18142d88f3b92954b05db733f8ccac255256b5981f56";
        libraryHaskellDepends = [ base bifunctors indexed mtl pointed ];
        jailbreak = true;
        homepage = "https://github.com/reinerp/indexed-extras";
@@ -78296,7 +78558,7 @@ self: {
      mkDerivation {
        pname = "indexed-free";
        version = "0.3.1";
-       sha256 = "1172vxhyzyf061mnlb8dndnvycjk3shxhiqd8hdz42ipv223admx";
+       sha256 = "bd363584d8370af21b440d47d8a11e5332bf6db30d2d6a6b30c0f9ef61dfe284";
        libraryHaskellDepends = [ base indexed ];
        homepage = "https://github.com/fumieval/indexed-free";
        description = "indexed monads for free";
@@ -78308,7 +78570,7 @@ self: {
      mkDerivation {
        pname = "indian-language-font-converter";
        version = "0.2";
-       sha256 = "1dw0fy3v2hfvlaw371af2c288v4p0wyg43h88clswids3nh1lpn8";
+       sha256 = "c85e1aa01dba45ae2943080ef23c07976c8404134e8533b8a2db41b1877780b7";
        libraryHaskellDepends = [ base gtk HDBC HDBC-sqlite3 ];
        description = "Indian Language Font Converter";
        license = stdenv.lib.licenses.bsd3;
@@ -78319,7 +78581,7 @@ self: {
      mkDerivation {
        pname = "indices";
        version = "1.7.1";
-       sha256 = "1sy609gq9idk5x28wasd9i61jwhlpf9ls21jps1nw1dfymid41c5";
+       sha256 = "8505d262f5ae056e83be32084d93bb1472194c4c4d2b8e442fb3c5845f02c6eb";
        libraryHaskellDepends = [ base tagged template-haskell ];
        testHaskellDepends = [ base QuickCheck ];
        description = "Multi-dimensional statically bounded indices";
@@ -78334,7 +78596,7 @@ self: {
      mkDerivation {
        pname = "infer-upstream";
        version = "0.1.1.0";
-       sha256 = "11v8njjinjqzqfa5hggj0r1gki3hz6y7cxj5qfnzxa77hdav10fa";
+       sha256 = "ca81b05583e7a8feadc3457676bcf970c4f94206f23d5894c31f4b1ba5b46887";
        isLibrary = false;
        isExecutable = true;
        executableHaskellDepends = [
@@ -78355,7 +78617,7 @@ self: {
      mkDerivation {
        pname = "infernu";
        version = "0.0.0.1";
-       sha256 = "0m4azl5pxypnf3q9riwf1gkwlfwrw5dswgrr2y9j1myb812ag5qn";
+       sha256 = "1697a74440cbd7209317393fae5be1993bcae70b8ec79cf070f6fa7e0bfd8a54";
        isLibrary = true;
        isExecutable = true;
        libraryHaskellDepends = [
@@ -78373,7 +78635,7 @@ self: {
      mkDerivation {
        pname = "infinite-search";
        version = "0.12";
-       sha256 = "18sf9798nna155xix71lw68k19r7ayk9kmppjzd76yxa61r38g41";
+       sha256 = "813c347230aa7b73da97f7d699a65727a73091e1349c1e7b2941598bd2494ea3";
        libraryHaskellDepends = [ base ];
        homepage = "http://github.com/luqui/infinite-search";
        description = "Exhaustively searchable infinite sets";
@@ -78386,7 +78648,7 @@ self: {
      mkDerivation {
        pname = "infinity";
        version = "0.3";
-       sha256 = "1d2l6a4ngawm7zqgfwxd19rh3zwihivbgns39q44yjh1d5v0azab";
+       sha256 = "4b7d057669014a4f084e43dbb7768491ff01730aad73f7f03f95ab67893254b4";
        isLibrary = false;
        isExecutable = true;
        executableHaskellDepends = [
@@ -78402,7 +78664,7 @@ self: {
      mkDerivation {
        pname = "infix";
        version = "0.1.1";
-       sha256 = "156lcw4bvav9w41vggfjk84z41ppam31880wpislxwcsvc9jrd6q";
+       sha256 = "d8b42c13db9af14e75bc1c20144655f706f2099ad2bdb703e169abbd0867d494";
        libraryHaskellDepends = [ base containers haskell-src ];
        homepage = "http://www.cs.mu.oz.au/~bjpop/code.html";
        description = "Infix expression re-parsing (for HsParser library)";
@@ -78417,7 +78679,7 @@ self: {
      mkDerivation {
        pname = "inflections";
        version = "0.2.0.0";
-       sha256 = "16s2sj2417qmhdlzn7j51yf7fh50f5msgb50fsavw80845602x43";
+       sha256 = "8374014c210820be9576a0aca76b71a040779c0f451efb6983159f4084d4429b";
        libraryHaskellDepends = [ base containers parsec ];
        testHaskellDepends = [
          base containers HUnit parsec QuickCheck test-framework
@@ -78433,7 +78695,7 @@ self: {
      mkDerivation {
        pname = "inflist";
        version = "0.0.1";
-       sha256 = "0srw75ds7hic0sjs2fnj0hsqsygzvppgy17y8qmsjz9z14ryqncw";
+       sha256 = "9c59ec33093f7da92b46fe04ffeeddff798d3504d23aa1a5062cc2a35b393c6b";
        libraryHaskellDepends = [ base QuickCheck ];
        testHaskellDepends = [ base QuickCheck ];
        homepage = "https://bitbucket.org/eegg/inflist";
@@ -78452,7 +78714,7 @@ self: {
      mkDerivation {
        pname = "influxdb";
        version = "0.9.1.3";
-       sha256 = "0v092i592j5n31fl0vc5750pqjbgaj10n3dm314bkll6ld0gdbwx";
+       sha256 = "9daff640a386d2b94818b50d0b82546f497c4139856d405d18b648914a14096c";
        isLibrary = true;
        isExecutable = true;
        libraryHaskellDepends = [
@@ -78481,7 +78743,7 @@ self: {
      mkDerivation {
        pname = "informative";
        version = "0.1.0.20";
-       sha256 = "1xglpqwr4bc7rqaspq7w6pc9g5ilzvxfb6lfkji3inagg5xksl7n";
+       sha256 = "f6503d7b794fd938a29c8e9ae5fafe349697d835fce0ab15ce872d9239bef4f5";
        isLibrary = true;
        isExecutable = true;
        libraryHaskellDepends = [
@@ -78506,7 +78768,7 @@ self: {
      mkDerivation {
        pname = "ini";
        version = "0.3.1";
-       sha256 = "01iwf4ifdx3mrw1rybj4crip4hmjxhab250rv995dgbwldh1iyqb";
+       sha256 = "0bfb1860a37cbd5652da1914b114ecb242726366442e9f03cf75f4e622713c06";
        libraryHaskellDepends = [
          attoparsec base text unordered-containers
        ];
@@ -78521,7 +78783,7 @@ self: {
      mkDerivation {
        pname = "inilist";
        version = "0.2.0.0";
-       sha256 = "1rr71yajc6j0idsqgna8mbnawiv6iw1x8kswkv7x2l0ih89r6y3a";
+       sha256 = "6a789313821150d1cf9e5c4fd4038f6647aeecaa48d987758b401a26950f27e7";
        libraryHaskellDepends = [
          base bifunctors containers safe trifecta
        ];
@@ -78542,7 +78804,7 @@ self: {
      mkDerivation {
        pname = "inject";
        version = "0.1.0";
-       sha256 = "0rm81xkxfwbm98ywcwjnh1l9qkah3xma59l8z5l37b458hayxjqq";
+       sha256 = "18cbee154485ac3368f988a6a26a1f504d9c68805672c63d4a7571d7670fa866";
        isLibrary = true;
        isExecutable = true;
        libraryHaskellDepends = [ attoparsec base process text ];
@@ -78559,7 +78821,7 @@ self: {
      mkDerivation {
        pname = "inject-function";
        version = "0.2.1.0";
-       sha256 = "1iw82rzw2w3y40zndz3mxpa7k5ds8zs87ccvp228s4zva0mp5ddl";
+       sha256 = "b4b5722b50fb138d84b89bb183f447ba9579d4ed75fc663f207e70c17f1688c7";
        libraryHaskellDepends = [ base ];
        jailbreak = true;
        homepage = "https://github.com/skypers/inject-function";
@@ -78577,7 +78839,7 @@ self: {
      mkDerivation {
        pname = "inline-c";
        version = "0.5.4.3";
-       sha256 = "03b15dz0bm26bv9jkpjdgmqii3fw1ifj6zwmysibir50jxlbx9pk";
+       sha256 = "f3a6be6897a0e4b8a2f6957f235d0cdc8d18717d4dde29d35e46d4057e2b610d";
        isLibrary = true;
        isExecutable = true;
        libraryHaskellDepends = [
@@ -78600,7 +78862,7 @@ self: {
      mkDerivation {
        pname = "inline-c-cpp";
        version = "0.1.0.0";
-       sha256 = "0iba77p2ncxbg5sb4ks8f3lgp6zdnjhzvrr2ap3yg49is5b9f5rf";
+       sha256 = "2e179756d13191e7c75522e7fda1b4ed9bfbe870484fb27479ab332bee396a45";
        libraryHaskellDepends = [ base inline-c template-haskell ];
        testHaskellDepends = [ base ];
        description = "Lets you embed C++ code into Haskell";
@@ -78614,7 +78876,7 @@ self: {
      mkDerivation {
        pname = "inline-c-win32";
        version = "0.1";
-       sha256 = "14255dn7smmm1rpnjifn7gn2amcncnf3j45ah22bblyb4h27iikm";
+       sha256 = "75c6780424cbd3b58480aa10399c65965525ec3bd645696f0eb5567d6c2b4590";
        libraryHaskellDepends = [
          base containers inline-c template-haskell Win32
        ];
@@ -78628,7 +78890,7 @@ self: {
      mkDerivation {
        pname = "inquire";
        version = "0.1";
-       sha256 = "18qcjdwgn7a1lrdnqnh6sh1bzii0nvb5jv56qq5kri8m6qwc9wl8";
+       sha256 = "88f2c4383615c53c0bc6a66c59d6b620c6bf02d4065a6c5ba6411dfb78930ca3";
        isLibrary = false;
        isExecutable = true;
        executableHaskellDepends = [ aether base text ];
@@ -78643,7 +78905,7 @@ self: {
      mkDerivation {
        pname = "inserts";
        version = "0.1.2";
-       sha256 = "1m72ysfd2g2jszvcihh7zbfxvpj2a8qjq3ra4vs4bjzpja4kh477";
+       sha256 = "e710388992f7cb45f4262a0f2c315242deddddfa07c2c8f6d7523cd19cf6e2d4";
        libraryHaskellDepends = [ attoparsec base bytestring dlist ];
        jailbreak = true;
        homepage = "http://github.com/tel/inserts";
@@ -78658,7 +78920,7 @@ self: {
      mkDerivation {
        pname = "inspection-proxy";
        version = "0.1.0.3";
-       sha256 = "09mk2wd4bs31zhz0x8z3ajlk734r0rp5k07g0mfdy4bsvi2hdqiy";
+       sha256 = "3ee20645dc7a11df5c05ef80596e06998c33a954e3a30e3efc61e8451a17b326";
        isLibrary = false;
        isExecutable = true;
        executableHaskellDepends = [
@@ -78674,12 +78936,13 @@ self: {
      }:
      mkDerivation {
        pname = "instant-aeson";
-       version = "0.1.0.1";
-       sha256 = "18zxvd4sw13j4gn2f7r2xdy6p0xayjv3ks8j97j7vi6cdw9aqw2z";
+       version = "0.2";
+       sha256 = "98d43d18aec3de9bd52c9c162eabbc736d4a50ad27fd5a9ade54888b5f6ba222";
        libraryHaskellDepends = [ aeson base instant-generics ];
        testHaskellDepends = [
          aeson base instant-generics tasty tasty-quickcheck
        ];
+       homepage = "https://github.com/k0001/instant-aeson";
        description = "Generic Aeson instances through instant-generics";
        license = stdenv.lib.licenses.bsd3;
      }) {};
@@ -78690,12 +78953,13 @@ self: {
      }:
      mkDerivation {
        pname = "instant-bytes";
-       version = "0.1.0.1";
-       sha256 = "1g99yakjychx12amls2b6cfma0fzh0n9w4m2k03wqibk1aagl940";
+       version = "0.2";
+       sha256 = "e70cc805ca399ac0e413a30de053c5abbce7f4d2698f49976d299fdd2074f9f5";
        libraryHaskellDepends = [ base bytes instant-generics ];
        testHaskellDepends = [
          base bytes instant-generics tasty tasty-quickcheck
        ];
+       homepage = "https://github.com/k0001/instant-bytes";
        description = "Generic Serial instances through instant-generics";
        license = stdenv.lib.licenses.bsd3;
      }) {};
@@ -78704,9 +78968,10 @@ self: {
     ({ mkDerivation, base, deepseq, instant-generics }:
      mkDerivation {
        pname = "instant-deepseq";
-       version = "0.1.0.1";
-       sha256 = "1yv5zqv2fqj8b7qzx2004sa287mrvrswmghl13vsbj2whmdh0kjz";
+       version = "0.2";
+       sha256 = "606ffaffb09ad1bb1d766499a589b16531e9a4c7978734a349975248a4e60e21";
        libraryHaskellDepends = [ base deepseq instant-generics ];
+       homepage = "https://github.com/k0001/instant-deepseq";
        description = "Generic NFData instances through instant-generics";
        license = stdenv.lib.licenses.bsd3;
      }) {};
@@ -78716,7 +78981,7 @@ self: {
      mkDerivation {
        pname = "instant-generics";
        version = "0.5";
-       sha256 = "174avn0jjxv4h04m6k85gvv6x3kvrlwhcbhqg9ih0ps5mp7crmvr";
+       sha256 = "79d7cccead455f00637a182e0639cd7b8e6ef67e054d53098064772981dd8a9c";
        revision = "1";
        editedCabalFile = "c69a74fef28272e5e46a0e37711bb980ac07d2f3feeed3513da1cc572a1ab6bc";
        libraryHaskellDepends = [ base containers syb template-haskell ];
@@ -78729,9 +78994,10 @@ self: {
     ({ mkDerivation, base, hashable, instant-generics }:
      mkDerivation {
        pname = "instant-hashable";
-       version = "0.1.0.1";
-       sha256 = "1yaf24r68zh5vsp73747hbv2fdk9y9vgswj6lv22s52s8h6f1agj";
+       version = "0.2";
+       sha256 = "8bf851b902126e91845e28cf6443d119ce675724c2e664562f8dd76664403a77";
        libraryHaskellDepends = [ base hashable instant-generics ];
+       homepage = "https://github.com/k0001/instant-hashable";
        description = "Generic Hashable instances through instant-generics";
        license = stdenv.lib.licenses.bsd3;
      }) {};
@@ -78741,7 +79007,7 @@ self: {
      mkDerivation {
        pname = "instant-zipper";
        version = "0.0.0";
-       sha256 = "0gd5hzlm5rlmzba2dl37al711vp1nn2b30d36rvb2j8y90y8c44c";
+       sha256 = "8c10863c481e49b17636a381b184b5e1ee100e5567d026d4fa95e652e987a53d";
        revision = "1";
        editedCabalFile = "a0e15510d3e3eefaa18d20fbfce7a1840519e160e2a8a8b36c498a3664b9c037";
        libraryHaskellDepends = [ base instant-generics mtl ];
@@ -78756,7 +79022,7 @@ self: {
      mkDerivation {
        pname = "instinct";
        version = "0.1.0";
-       sha256 = "0wh95zjdv9j1n3ccg2j08av43qnb9vmiyvqvyi70p47dr481npl8";
+       sha256 = "885e1b10c9ed900b4ef41b6f1feb4ecbe241b642408ac7d8b041a6dde42f0972";
        libraryHaskellDepends = [ base containers mersenne-random vector ];
        description = "Fast artifical neural networks";
        license = stdenv.lib.licenses.bsd3;
@@ -78767,7 +79033,7 @@ self: {
      mkDerivation {
        pname = "instrument-chord";
        version = "0.1.0.9";
-       sha256 = "0gq79i1mqpbyvxm8cfpr2b8h0knbc6f2m3b3mnm0p3yvi2d642nb";
+       sha256 = "cb0a629a88db8f0baaad638d2a9c61cb4e00d112f93a866adf7e5d5c434c073f";
        libraryHaskellDepends = [ array base containers music-diatonic ];
        homepage = "https://github.com/xpika/chord";
        description = "Render Instrument Chords";
@@ -78781,7 +79047,7 @@ self: {
      mkDerivation {
        pname = "int-cast";
        version = "0.1.2.0";
-       sha256 = "0gfx3pg0n1jyn8z2q804iyc24ahi41sjr3h7v5ivzc3g57vi1ykb";
+       sha256 = "6bfa10f7296fb0bf63d9078e2c7520112a22988f04202c3eb25e060bde1ddd3d";
        libraryHaskellDepends = [ base ];
        testHaskellDepends = [
          base QuickCheck test-framework test-framework-quickcheck2
@@ -78797,7 +79063,7 @@ self: {
      mkDerivation {
        pname = "integer-gmp";
        version = "1.0.0.0";
-       sha256 = "0sh01sbib7z0bx934a7gq6583hdz8yncaxpfi9k8y4v18gm8j55f";
+       sha256 = "ae1489ea4361138f668aee76c5ac47bfc1818ac1ef2832525fe09f15970e006a";
        revision = "1";
        editedCabalFile = "5d63fab9a7c94b4e713d151bdc0c361228efbac2b7583dfa8e6c5370ecae5663";
        libraryHaskellDepends = [ ghc-prim ];
@@ -78810,7 +79076,7 @@ self: {
      mkDerivation {
        pname = "integer-pure";
        version = "1.0";
-       sha256 = "0lrhf6mw90bfph3hbyxv3n7g2n2xnjfq4qnhyhw4ml76k4yybmxa";
+       sha256 = "aad7e53d99e6d04a38f4d062829db45d58f18e1dbbfb0507bc6e81c4ab713053";
        homepage = "http://projects.haskell.org/~malcolm/integer-pure";
        description = "A pure-Haskell implementation of arbitrary-precision Integers";
        license = stdenv.lib.licenses.bsd3;
@@ -78822,7 +79088,7 @@ self: {
      mkDerivation {
        pname = "integration";
        version = "0.2.1";
-       sha256 = "0bsqad6q4kc0wykswwqykcn6nd4wj6yd9dzpg075h2n1mmg3h9qc";
+       sha256 = "0c27385eadc10a580e78f7b7d4bc919c346b2c9b1e73aea7e7804d824d53582f";
        libraryHaskellDepends = [ base parallel ];
        homepage = "https://github.com/ekmett/integration";
        description = "Fast robust numeric integration via tanh-sinh quadrature";
@@ -78837,7 +79103,7 @@ self: {
      mkDerivation {
        pname = "intel-aes";
        version = "0.2.1.1";
-       sha256 = "11cy9dlynlz9mgbs4w4xfjb9dx05dklfjl3gg2130si8q2kk3cm9";
+       sha256 = "a9b231a7c0286a3082786f50e9e86c05f49696749d70a2d7abe953eb694b9e85";
        libraryHaskellDepends = [
          base bytestring cereal crypto-api DRBG largeword process random
          rdtsc split tagged time unix
@@ -78854,7 +79120,7 @@ self: {
      mkDerivation {
        pname = "interchangeable";
        version = "0.2.0.0";
-       sha256 = "1r0gxwbl2k4i9r7jlbmabr1088q8nk1an4nhf79gsx2ybfdzlndh";
+       sha256 = "b059fa9b5b5e74fdd271d012abc2b4082304425eaa2e2a4f4e914c4117ef0fe4";
        libraryHaskellDepends = [ base containers ];
        homepage = "https://github.com/arowM/interchangeable";
        description = "A type class for interchangeable data";
@@ -78866,7 +79132,7 @@ self: {
      mkDerivation {
        pname = "interleavableGen";
        version = "0.0.1";
-       sha256 = "10clafccpg8xciqhj2hzbi4kixzprgp733396qf531nwakvnqpp2";
+       sha256 = "e25e6cf754dc86511c36698c71eecbf7f738495c1f0a0971641dbdcb98539481";
        isLibrary = false;
        isExecutable = true;
        executableHaskellDepends = [ base directory haskell-src hint mtl ];
@@ -78880,7 +79146,7 @@ self: {
      mkDerivation {
        pname = "interleavableIO";
        version = "0.0.1";
-       sha256 = "19jdrfr6n6yzvj1i8r7hhr3k6zkkbrs6pizqcbzhb0nvzzshmqa8";
+       sha256 = "48e10af5ffdb8205ff62f8c76b745e737e334786f0641483dcdf1b6bb2cb4da6";
        libraryHaskellDepends = [ base mtl ];
        description = "Use other Monads in functions that asks for an IO Monad";
        license = "unknown";
@@ -78892,7 +79158,7 @@ self: {
      mkDerivation {
        pname = "interleave";
        version = "1.0";
-       sha256 = "062ixqbrrmamwv3fj6vpfcxy35p37i1wpmsxk1gl9n06n0lg9a8c";
+       sha256 = "0ca9f428b006d8445f985dd7cb433ce396e13b73771be9c6e655d59c17ee5118";
        libraryHaskellDepends = [ base ];
        description = "Combinators for supporting interleaving of different behaviours";
        license = stdenv.lib.licenses.bsd3;
@@ -78903,7 +79169,7 @@ self: {
      mkDerivation {
        pname = "interlude";
        version = "0.1.2";
-       sha256 = "1yiv24n0mfjzbpm9p6djllhwck3brjz9adzyp6k4fpk430304k7s";
+       sha256 = "fa4c020618645e47a6b9fe3795becc6b4cc621a5b2999bea5d5fba0a2c113bfa";
        libraryHaskellDepends = [ base ];
        homepage = "http://malde.org/~ketil/";
        description = "Replaces some Prelude functions for enhanced error reporting";
@@ -78917,7 +79183,7 @@ self: {
      mkDerivation {
        pname = "intern";
        version = "0.9.1.4";
-       sha256 = "0snjar5mil9zsyy1ml13a8p1g2cvq62c5r8547i6z451w06j1zk0";
+       sha256 = "60fe200de0a1906fe22105e5c284c19b89172e5223d01abcd73fd1584b56d26a";
        libraryHaskellDepends = [
          array base bytestring hashable text unordered-containers
        ];
@@ -78933,7 +79199,7 @@ self: {
      mkDerivation {
        pname = "internetmarke";
        version = "0.0.3";
-       sha256 = "1gn6vvrnhck9f9hzs8igdg20gvrvjnba00bj191paw02kpzbgx7z";
+       sha256 = "fff4b7fe9d027075430a7201a096953bef07c46b2f22fd6172693268f3dec6be";
        isLibrary = false;
        isExecutable = true;
        executableHaskellDepends = [
@@ -78953,7 +79219,7 @@ self: {
      mkDerivation {
        pname = "interpol";
        version = "0.2.3";
-       sha256 = "11awkl6rgy33yl4qcnf7ns464c87xjk9hqcf10z8shjjbaadbz43";
+       sha256 = "83fcd5945a52428d3e088e6198a6ec07316288b6c7598609f563f8970d9d5c85";
        isLibrary = true;
        isExecutable = true;
        libraryHaskellDepends = [ base ];
@@ -78976,7 +79242,7 @@ self: {
      mkDerivation {
        pname = "interpolate";
        version = "0.1.0";
-       sha256 = "0wlc10qd1bq3xj64a3yq2gzds9kas9zyylkm9kxd46gy35fns6id";
+       sha256 = "2d1a6d5d19fe19d2fa4c7552ef7fd26a26ddfe13d80f458cec03afd030088c72";
        libraryHaskellDepends = [ base haskell-src-meta template-haskell ];
        testHaskellDepends = [
          base bytestring haskell-src-meta hspec QuickCheck
@@ -78993,7 +79259,7 @@ self: {
      mkDerivation {
        pname = "interpolatedstring-perl6";
        version = "1.0.0";
-       sha256 = "1lx125wzadvbicsaml9wrhxxplc4gd0i4wk3f1apb0kl5nnv5q35";
+       sha256 = "65e0b2ad2d7482755570637212417b84d1db3bcc3cd1aa348b6b37f57911a1d3";
        libraryHaskellDepends = [
          base bytestring haskell-src-meta template-haskell text
        ];
@@ -79007,7 +79273,7 @@ self: {
      mkDerivation {
        pname = "interpolatedstring-qq";
        version = "0.2";
-       sha256 = "1bqn9gqc43r158hyk35x8avsiqyd43vlpw2jkhpdfmr2wx29jprq";
+       sha256 = "385f9944e72257d72e9c52f04bf720cde3a8b742bd8ce9212a210fc2f04b16af";
        libraryHaskellDepends = [
          base haskell-src-meta-mwotton template-haskell
        ];
@@ -79022,7 +79288,7 @@ self: {
      mkDerivation {
        pname = "interpolatedstring-qq-mwotton";
        version = "0.1.1";
-       sha256 = "1cwhy4jwbl50nglfw0wfmdr3rrg33dqskw0wq06prx14x22yshbk";
+       sha256 = "7341ed85e824f47c0dc01cf0a9711be3e53c72ab8e03eee8b3a0d0c525f190b3";
        libraryHaskellDepends = [
          base haskell-src-meta-mwotton template-haskell
        ];
@@ -79037,7 +79303,7 @@ self: {
      mkDerivation {
        pname = "interpolation";
        version = "0.1";
-       sha256 = "1yip0fjhmd9gf9w7qi4yfpq38m51jn0i52zxil2hfc49r5aydlya";
+       sha256 = "cad3e655c9893007058dfd8b128195a15434f0759e447c78722fb50aa50337fa";
        isLibrary = true;
        isExecutable = true;
        libraryHaskellDepends = [ base utility-ht ];
@@ -79057,7 +79323,7 @@ self: {
      mkDerivation {
        pname = "intervals";
        version = "0.7.1";
-       sha256 = "03ra3jkch26x4crsq6nh2wnj51jrx7zmwafmq22xqrpsg7hpav92";
+       sha256 = "226d75e179fa66dc85c0d5295effe95986222d17d01aac3323dd08c8a61c2a0f";
        libraryHaskellDepends = [ array base distributive ghc-prim ];
        testHaskellDepends = [ base directory doctest filepath ];
        homepage = "http://github.com/ekmett/intervals";
@@ -79074,7 +79340,7 @@ self: {
      mkDerivation {
        pname = "intricacy";
        version = "0.5.5";
-       sha256 = "0jlqxd7nwh3yvy5pni3w4a19wvn2xdrhhhfm9xkf4cs2rqnz525q";
+       sha256 = "b888f22dce4233e2664fd5410873ebc26e9e82227c447b8bdf7e406e4feb984a";
        isLibrary = false;
        isExecutable = true;
        executableHaskellDepends = [
@@ -79095,7 +79361,7 @@ self: {
      mkDerivation {
        pname = "intset";
        version = "0.1.1.0";
-       sha256 = "044nw8z2ga46mal9pr64vsc714n4dibx0k2lwgnrkk49729c7lk0";
+       sha256 = "60d2c3923889cc99ede3544cd0576cc4927098dec4e49ba8aa86a8273ee29610";
        libraryHaskellDepends = [ base bits-extras bytestring deepseq ];
        testHaskellDepends = [
          base QuickCheck test-framework test-framework-quickcheck2
@@ -79115,7 +79381,7 @@ self: {
      mkDerivation {
        pname = "invariant";
        version = "0.2";
-       sha256 = "0zxzpbha3z4z23xmsbgajjxk477ad1v28ml3rry0102lpcpvl6j1";
+       sha256 = "411aba2fbb5480007cce8356247668ea1c32bb94ea2d5dfb109ffca1e0babf7f";
        libraryHaskellDepends = [
          array base bifunctors containers contravariant ghc-prim profunctors
          semigroups stm tagged template-haskell transformers
@@ -79132,7 +79398,7 @@ self: {
      mkDerivation {
        pname = "invertible-syntax";
        version = "0.2.1";
-       sha256 = "0kyi7gq0a792v4lwmpq8i56vzwk6g7cjc3lbpxch47jsqv8lfhbp";
+       sha256 = "774147d1c65a1e0259bf8b0e26d97966f2bf4d8908dfca29d9221d05f03bd14f";
        libraryHaskellDepends = [ base partial-isomorphisms ];
        homepage = "http://www.informatik.uni-marburg.de/~rendel/unparse";
        description = "Invertible syntax descriptions for both parsing and pretty printing";
@@ -79144,7 +79410,7 @@ self: {
      mkDerivation {
        pname = "io-capture";
        version = "0.3";
-       sha256 = "03kjjsz1i1viwngmq9mvkzd43490g93mbkcvgjvcway2z5prv06f";
+       sha256 = "ce809d6ff9c22bceb67c9bcd55477a209141da9fbb265c9fe5718718be96720e";
        libraryHaskellDepends = [ base unix ];
        description = "capture IO action's stdout and stderr";
        license = stdenv.lib.licenses.bsd3;
@@ -79157,7 +79423,7 @@ self: {
      mkDerivation {
        pname = "io-choice";
        version = "0.0.5";
-       sha256 = "19nr8kxcg98510cqgjn4c9sd8i9yz8fv4ryqg6lzzgpwqzkvx5ph";
+       sha256 = "f096bee7c7fcbeffa979d867b21dfa3e45d47462c4ca87190805a5c7fa44d9a6";
        libraryHaskellDepends = [
          base lifted-base monad-control template-haskell transformers
          transformers-base
@@ -79174,7 +79440,7 @@ self: {
      mkDerivation {
        pname = "io-manager";
        version = "0.1.0.2";
-       sha256 = "0f21h36z2ls0d6g31pcf4kcyfninaxws8w159zy33bwa19saf2mz";
+       sha256 = "bf0aa7740a8aaf31fc4f2570a47957365ae7d9248edd309e694053f1cd804138";
        isLibrary = true;
        isExecutable = true;
        libraryHaskellDepends = [ base containers ];
@@ -79188,7 +79454,7 @@ self: {
      mkDerivation {
        pname = "io-memoize";
        version = "1.1.1.0";
-       sha256 = "0ga85wdvz67jjx8qh6f687kfikcrfmp7winn13v6na7vlaqs2ly7";
+       sha256 = "c753a1b1a2fb286bf608d6467e6e7599cde8e641c619885197f298bf1b2f483d";
        libraryHaskellDepends = [ async base ];
        homepage = "https://github.com/DanBurton/io-memoize";
        description = "Memoize IO actions";
@@ -79200,7 +79466,7 @@ self: {
      mkDerivation {
        pname = "io-reactive";
        version = "0.1.1";
-       sha256 = "09iq8c86ql0hmzdf7i82lpdqa6nn6r0zy9lgryd6chkxd0kcpgvn";
+       sha256 = "76bfcb26687d42669acf8f26ff4136d61a85dba502c5e3daaf10506c10433826";
        isLibrary = true;
        isExecutable = true;
        libraryHaskellDepends = [ base ];
@@ -79215,7 +79481,7 @@ self: {
      mkDerivation {
        pname = "io-region";
        version = "0.1.1";
-       sha256 = "1w8m21zkhbhqr9lsdzwxfpy0jhb2ciybn3bvhyp3zlxkq9k3yc7f";
+       sha256 = "ee303f66c2b3d33fae877b0dbb7c64624109fc759dffa669ca182e387f1015f1";
        libraryHaskellDepends = [ base stm ];
        testHaskellDepends = [ base hspec transformers ];
        homepage = "https://github.com/Yuras/io-region/wiki";
@@ -79228,7 +79494,7 @@ self: {
      mkDerivation {
        pname = "io-storage";
        version = "0.3";
-       sha256 = "1ga9bd7iri6vlsxnjx765yy3bxc4lbz644wyw88yzvpjgz6ga3cs";
+       sha256 = "9a0df5cc7ff2eeef11e29e1362fea284f535bc2fe67469bba6dbc41c4f5b49bd";
        libraryHaskellDepends = [ base containers ];
        homepage = "http://github.com/willdonnelly/io-storage";
        description = "A key-value store in the IO monad";
@@ -79245,7 +79511,7 @@ self: {
      mkDerivation {
        pname = "io-streams";
        version = "1.3.2.0";
-       sha256 = "0gqj2adc3zlwz81wy38y8x4rihvhk4zm9xb0rd04a77nn15xlc0y";
+       sha256 = "1e30da4bb0f61c4540cb60f5543f9970c39849471e0dcf03fa9cfec19a12123f";
        configureFlags = [ "-fnointeractivetests" ];
        libraryHaskellDepends = [
          attoparsec base bytestring bytestring-builder network primitive
@@ -79268,7 +79534,7 @@ self: {
      mkDerivation {
        pname = "io-streams-http";
        version = "0.2.1.2";
-       sha256 = "0ra3z236d4mbw2vqlx4zxpa5z53a7k1j2pmkwf3075ghgdavrmk3";
+       sha256 = "63d6bc557bf0950386e3b35e21c33c6a945fd4ed9f748ab7e0ab926686f84365";
        libraryHaskellDepends = [
          base bytestring http-client http-client-tls io-streams mtl
          transformers
@@ -79282,7 +79548,7 @@ self: {
      mkDerivation {
        pname = "io-throttle";
        version = "0.1.0";
-       sha256 = "043plb9n606hkbdjddgk9kg12fzzs7ry063ckiky4zymy2vprcj9";
+       sha256 = "49b27cb7f0d57fe2679c6c18e0f3d1ff3b11de4cf3b526db9ad00063d3a27710";
        revision = "1";
        editedCabalFile = "c3903532515f76e374229ea572d11f7ab02a560062425f33649399c5ac61a16e";
        libraryHaskellDepends = [ base SafeSemaphore threads ];
@@ -79297,7 +79563,7 @@ self: {
      mkDerivation {
        pname = "ioctl";
        version = "0.0.1";
-       sha256 = "0rwh7mlwdd24ndzz4b4vd5b5daz9cga47m9nz6g75m03iyy237qs";
+       sha256 = "1a9f21bc8f03d4729ef936d543d463e9ab5656699b2cf27fb344b4c6693d9067";
        libraryHaskellDepends = [ base network unix ];
        description = "Type-safe I/O control package";
        license = stdenv.lib.licenses.mit;
@@ -79308,7 +79574,7 @@ self: {
      mkDerivation {
        pname = "iothread";
        version = "0.1.0.0";
-       sha256 = "1nvysb0nmx42q0ilr09nzbsmr7mbbclhgl0iikibhhfb34r2afx0";
+       sha256 = "a03b253219cb41b8e28c11d007295bab9e5cf5fa36814c23c082f46ac1d27edb";
        libraryHaskellDepends = [ base ];
        jailbreak = true;
        homepage = "https://github.com/tattsun/iothread";
@@ -79321,7 +79587,7 @@ self: {
      mkDerivation {
        pname = "iotransaction";
        version = "0.1";
-       sha256 = "0ylwrim2wfx3v03syd8v0iwf9kbw9154wlxsp8wc1d3n6sz7p1cc";
+       sha256 = "8c857bbe3676b4c038baba534e4a487ccde478041b35af07d8a33b2e6acc9c7a";
        libraryHaskellDepends = [ base ];
        homepage = "https://bitbucket.org/dshearer/iotransaction/";
        description = "Supports the automatic undoing of IO operations when an exception is thrown";
@@ -79336,7 +79602,7 @@ self: {
      mkDerivation {
        pname = "ip-quoter";
        version = "1.0.1.1";
-       sha256 = "1819742yjdl96k2z8s55a5x9xw9mg4lps1dq1f55zvc31afkdi4l";
+       sha256 = "94c4369d0a83ed5f8a0bb8057d297935f19e7a51a568f4c5348936e9053929a0";
        libraryHaskellDepends = [ base cpu network template-haskell ];
        testHaskellDepends = [ base cpu network tasty tasty-hunit ];
        homepage = "https://github.com/shlevy/ip-quoter";
@@ -79349,7 +79615,7 @@ self: {
      mkDerivation {
        pname = "ip6addr";
        version = "0.5.0.1";
-       sha256 = "08nwzas5r3b47chldc3dmwmwxam5dlmsyqqqmql7rjm87h645di4";
+       sha256 = "24b6420c3ca8ca7c28ae1863af2b6da5aace2baf6db046213b648d5cb4fadc22";
        isLibrary = false;
        isExecutable = true;
        executableHaskellDepends = [ base cmdargs IPv6Addr text ];
@@ -79365,7 +79631,7 @@ self: {
      mkDerivation {
        pname = "ipatch";
        version = "0.1.1";
-       sha256 = "19yf0b82ifplja05if38llfs38mzmxxald89jc2yzqzzkvws9ldq";
+       sha256 = "b8d1a4f99effe3ef05930935aa7aafbfa2a11da568b8588092f4ba28d002cea7";
        isLibrary = false;
        isExecutable = true;
        executableHaskellDepends = [
@@ -79385,7 +79651,7 @@ self: {
      mkDerivation {
        pname = "ipc";
        version = "0.0.5";
-       sha256 = "0d1w62181s21ks63548i3jdfk4k1rg0hssnhkm97ymkrlcz6w68d";
+       sha256 = "0d196e3ea379567f529dd06a0dc1cb6192e99a1c1191328c9e41e88082303c34";
        libraryHaskellDepends = [
          base binary bytestring dlist mtl network network-bytestring stm
        ];
@@ -79401,7 +79667,7 @@ self: {
      mkDerivation {
        pname = "ipcvar";
        version = "0.0.1";
-       sha256 = "085p03xk29wk03yfshpjvzkf2z79byhp9yy81vra1aci9nkgjr3n";
+       sha256 = "7664f9a64d91a9a0f20ec8fb74a15fe97ce1e6dff242edfc00932731fb00b720";
        libraryHaskellDepends = [ base binary bytestring directory unix ];
        testHaskellDepends = [ base hspec unix ];
        description = "Simple inter-process communication through IPCVars";
@@ -79416,7 +79682,7 @@ self: {
      mkDerivation {
        pname = "ipopt-hs";
        version = "0.5.0.0";
-       sha256 = "03cpn73ybkifkbl8dxbpyh17gv71jx9x53pkhi9wbfpqqz2ail9c";
+       sha256 = "2cd1a8c4c7f8bac55384f38ed25397e1ec7702f477f586e89a2ecee5c7b1970d";
        isLibrary = true;
        isExecutable = true;
        libraryHaskellDepends = [
@@ -79435,7 +79701,7 @@ self: {
      mkDerivation {
        pname = "ipprint";
        version = "0.5";
-       sha256 = "0h75k21blbnzvp5l20qsima557dx6zfrww79y7qsqf04pbd81j7s";
+       sha256 = "fac880daba0438acf1f1e9709edd37bd9d52548d1a0341cbdddf2eba8298e540";
        libraryHaskellDepends = [ base Extra haskell-src ];
        description = "Tiny helper for pretty-printing values in ghci console";
        license = stdenv.lib.licenses.bsd3;
@@ -79448,7 +79714,7 @@ self: {
      mkDerivation {
        pname = "iproute";
        version = "1.5.0";
-       sha256 = "0mr5dwzvsik5v59fy5lpnj6qabgc8cwbybil5hb6gqqvd0y26fz3";
+       sha256 = "e33b233c681be367162c342ebf3843ec2d858db49716ef52d96546bd3f6f2557";
        revision = "1";
        editedCabalFile = "f601b3319004e7b4a4636c89996ea78fd084e9b10d15d679d7ae58e822fe19b8";
        libraryHaskellDepends = [
@@ -79470,7 +79736,7 @@ self: {
      mkDerivation {
        pname = "iptables-helpers";
        version = "0.5.0";
-       sha256 = "13xv7g349ssgbz9c0g8q77hf52gp0v7nw9q665l697237jbvl57j";
+       sha256 = "f214ba973c439c64683106276ecf06f789e2e039183dc0d25f4feb44c63bbb8f";
        isLibrary = true;
        isExecutable = true;
        libraryHaskellDepends = [
@@ -79493,7 +79759,7 @@ self: {
      mkDerivation {
        pname = "iptadmin";
        version = "1.3.4";
-       sha256 = "1ksnypq95xaybsb3vvhmabrh8l3c2c3mcqz83a61md9c1vw3n94m";
+       sha256 = "95243bf80e2cb51a8c1ae8635607136c5004f35215ee3d965e5ef592f0f556cf";
        isLibrary = false;
        isExecutable = true;
        executableHaskellDepends = [
@@ -79517,8 +79783,8 @@ self: {
      }:
      mkDerivation {
        pname = "ipython-kernel";
-       version = "0.6.1.0";
-       sha256 = "1dmmrkph3myc67wp4ibx2l10dkxpkgzh7i4shbjbqag39ljb0q60";
+       version = "0.6.1.2";
+       sha256 = "1431c7442b9081dd9169348b36f0befafeedca8a773b8d5349518b39fde1e4e2";
        isLibrary = true;
        isExecutable = true;
        libraryHaskellDepends = [
@@ -79541,7 +79807,7 @@ self: {
      mkDerivation {
        pname = "irc";
        version = "0.6.1.0";
-       sha256 = "1q9p2qwfy9rsfyaja4x3gjr8ql2ka2ja5qv56b062bdkvzafl5iq";
+       sha256 = "3816ead4dfb32d61c03265e3a2a45053508cb27ca3132595773a27ef381637e1";
        libraryHaskellDepends = [ attoparsec base bytestring ];
        testHaskellDepends = [
          base bytestring HUnit QuickCheck test-framework
@@ -79556,7 +79822,7 @@ self: {
      mkDerivation {
        pname = "irc-bytestring";
        version = "0.1";
-       sha256 = "09n4y93x74wblbz89s1hwzmanwwi72cj0baz72485svarg55kid7";
+       sha256 = "a7c559cacb6aeb8288385f2d2099389173abeae730e884fea28b93d347f2c426";
        libraryHaskellDepends = [ attoparsec base bytestring ];
        homepage = "https://github.com/kallisti-dev/irc-bytestring";
        description = "serialization and parsing of IRC messages";
@@ -79571,7 +79837,7 @@ self: {
      mkDerivation {
        pname = "irc-client";
        version = "0.2.4.0";
-       sha256 = "137ix1x2qy92v5naaq3lz3iyvbxvf32gnsq09flddadx88d51vv6";
+       sha256 = "66ef501a42bda9d6a84b006bfbc470bbafede3f87460a56cd922792c7ae8f18c";
        libraryHaskellDepends = [
          base bytestring conduit data-default-class irc-conduit irc-ctcp
          old-locale stm stm-conduit text time transformers
@@ -79586,7 +79852,7 @@ self: {
      mkDerivation {
        pname = "irc-colors";
        version = "0.1";
-       sha256 = "1xl38bq1b6w7z8q0frra4h76lyk63bsy5i1qd34pdgwvikd2rkh0";
+       sha256 = "00ce2cda8c9bbf76c96838c4e2f51a667a6a0e242a670730fa879b15f04283f6";
        libraryHaskellDepends = [ base text ];
        description = "Colourize your IRC strings";
        license = stdenv.lib.licenses.bsd3;
@@ -79600,7 +79866,7 @@ self: {
      mkDerivation {
        pname = "irc-conduit";
        version = "0.1.2.0";
-       sha256 = "1mw418frhbnk7gncilvb2c3cj4fvzm5fvafq0p28vggxisda9bkp";
+       sha256 = "77aea49a8efdbd8dc405d8a9ed4afddb11c906136bd3c8ec3bd32e981d0a84d7";
        libraryHaskellDepends = [
          async base bytestring conduit conduit-extra connection irc irc-ctcp
          network-conduit-tls text time tls transformers x509-validation
@@ -79621,7 +79887,7 @@ self: {
      mkDerivation {
        pname = "irc-core";
        version = "1.1.0.1";
-       sha256 = "01n10wcnq4h2wpmxl1rh9zgqayk3mllbz563fg8qw1k01n7q9257";
+       sha256 = "a788848f0d60068ed173c394bf28ad637a85df4f3007daebe502126c1907c106";
        revision = "3";
        editedCabalFile = "a2be33ee630d69381c0103cf25743005688f53220d02552cc99ed7131eefdadf";
        isLibrary = true;
@@ -79636,6 +79902,7 @@ self: {
          network old-locale split stm text time tls transformers vty x509
          x509-store x509-system x509-validation
        ];
+       jailbreak = true;
        homepage = "https://github.com/glguy/irc-core";
        description = "An IRC client library and text client";
        license = stdenv.lib.licenses.bsd3;
@@ -79646,19 +79913,48 @@ self: {
      mkDerivation {
        pname = "irc-ctcp";
        version = "0.1.3.0";
-       sha256 = "16mp9dpp57id760zc932dszd5r1ncskwwxrp0djka5r1alddjz6n";
+       sha256 = "d67cd91a5521173565033777cea76636e4d2be6e6224f681392d9e726f4bb79a";
        libraryHaskellDepends = [ base bytestring text ];
        homepage = "https://github.com/barrucadu/irc-ctcp";
        description = "A CTCP encoding and decoding library for IRC clients";
        license = stdenv.lib.licenses.mit;
      }) {};
 
+  "irc-fun-bot" = callPackage
+    ({ mkDerivation, base, irc-fun-client, irc-fun-messages
+     , transformers
+     }:
+     mkDerivation {
+       pname = "irc-fun-bot";
+       version = "0.1.0.0";
+       sha256 = "58950b66db2841646fa172e9298a3a59094f2781793e9f26cd7077ab1782912c";
+       libraryHaskellDepends = [
+         base irc-fun-client irc-fun-messages transformers
+       ];
+       jailbreak = true;
+       homepage = "http://rel4tion.org/projects/irc-fun-bot/";
+       description = "Very simple library for writing fun IRC bots";
+       license = stdenv.lib.licenses.publicDomain;
+     }) {};
+
+  "irc-fun-client" = callPackage
+    ({ mkDerivation, base, irc-fun-messages, network }:
+     mkDerivation {
+       pname = "irc-fun-client";
+       version = "0.1.0.0";
+       sha256 = "fc1f8fb91d3fbabdebf2506999a1f98d055cd95a6362ccfa2f1442a29a14dccd";
+       libraryHaskellDepends = [ base irc-fun-messages network ];
+       homepage = "http://rel4tion.org/projects/irc-fun-client/";
+       description = "Another library for writing IRC clients";
+       license = stdenv.lib.licenses.publicDomain;
+     }) {};
+
   "irc-fun-color" = callPackage
     ({ mkDerivation, base }:
      mkDerivation {
        pname = "irc-fun-color";
        version = "0.1.0.0";
-       sha256 = "1zb3d3m17049g7cfnpnl8c1ldyhhwvxh99dbfx1xzyadg841i08a";
+       sha256 = "0a8118087a4df9df4377aba504fbe610fa460343d45eebd879898013ea6863fd";
        libraryHaskellDepends = [ base ];
        testHaskellDepends = [ base ];
        homepage = "http://rel4tion.org/projects/irc-fun-color/";
@@ -79666,6 +79962,20 @@ self: {
        license = stdenv.lib.licenses.publicDomain;
      }) {};
 
+  "irc-fun-messages" = callPackage
+    ({ mkDerivation, base, regex-applicative }:
+     mkDerivation {
+       pname = "irc-fun-messages";
+       version = "0.1.0.0";
+       sha256 = "4bebbf6790688f81ff3d777c03f7a7646af6c7ad2c23cd5bcd45d94cddfd22a0";
+       revision = "1";
+       editedCabalFile = "32bea454ad4ce55be98627138277c26a5de4abc73ccae3d196f8e5e653d4389a";
+       libraryHaskellDepends = [ base regex-applicative ];
+       homepage = "http://rel4tion.org/projects/irc-fun-messages/";
+       description = "Types and functions for working with the IRC protocol";
+       license = stdenv.lib.licenses.publicDomain;
+     }) {};
+
   "ircbot" = callPackage
     ({ mkDerivation, base, bytestring, containers, directory, filepath
      , irc, mtl, network, parsec, random, SafeSemaphore, stm, time, unix
@@ -79673,7 +79983,7 @@ self: {
      mkDerivation {
        pname = "ircbot";
        version = "0.6.4";
-       sha256 = "024wmkp08rni9frflpjl0p30ql6k1kj956j5dysz40xygajk8fmd";
+       sha256 = "ad3a34a57abe03f2b56f459a92e40cd3500cc605545eeab24bd16604eeac9c08";
        libraryHaskellDepends = [
          base bytestring containers directory filepath irc mtl network
          parsec random SafeSemaphore stm time unix
@@ -79688,7 +79998,7 @@ self: {
      mkDerivation {
        pname = "ircbouncer";
        version = "0.2.0";
-       sha256 = "1bn0m9x89pqknz8gn8gk9is6w6px4hznp3fqqb5dxwssmmjm99zm";
+       sha256 = "f5a75465ad5af3decac2d88d6b3f24fd1a6e744cf321fbd0b713df847aaac0ae";
        description = "None";
        license = stdenv.lib.licenses.bsd3;
        hydraPlatforms = stdenv.lib.platforms.none;
@@ -79699,7 +80009,7 @@ self: {
      mkDerivation {
        pname = "ireal";
        version = "0.2.1";
-       sha256 = "0i9850l0k1w7vmdx4cs35789rf6j4i1xalpyrinf8x85f6c8mfxa";
+       sha256 = "aabb8a98710575e46cccfe52d54324d2b89cd0294333d25bdd87870928282845";
        libraryHaskellDepends = [ base QuickCheck ];
        description = "Real numbers and intervals with relatively efficient exact arithmetic";
        license = stdenv.lib.licenses.bsd3;
@@ -79711,7 +80021,7 @@ self: {
      mkDerivation {
        pname = "iron-mq";
        version = "0.1.1.0";
-       sha256 = "1yi1ia4ii6xg17ndp0v47cix0ds6bbrsbf0pghcmx3y4b55v0dlr";
+       sha256 = "9936b04b59c48f5e197c17b8a5f35a4637d0233b6483dbec09af9b18898a21fa";
        libraryHaskellDepends = [ aeson base http-client lens text wreq ];
        jailbreak = true;
        homepage = "https://github.com/arnoblalam/iron_mq_haskell";
@@ -79726,7 +80036,7 @@ self: {
      mkDerivation {
        pname = "ironforge";
        version = "0.1.0.35";
-       sha256 = "1dx0ljvfll8vb9rjdvx41vm4mrybafjch83xk7xs5fpvijjfp47l";
+       sha256 = "f490eba48cfbbaa2fb997d20c8a453cbe74aea0ea4ef26735a1b51eab6a4a0b7";
        isLibrary = true;
        isExecutable = true;
        libraryHaskellDepends = [
@@ -79745,7 +80055,7 @@ self: {
      mkDerivation {
        pname = "is";
        version = "0.2";
-       sha256 = "1ihrrpypdjhsr42nd9chyq730kllx239igjpa12m14458lnrcb2h";
+       sha256 = "502c962d45859050455057be9886e8944e300ef690a56605c91aca76fdcd19c6";
        libraryHaskellDepends = [ base template-haskell ];
        testHaskellDepends = [ base template-haskell ];
        description = "Pattern predicates using TH";
@@ -79759,7 +80069,7 @@ self: {
      mkDerivation {
        pname = "isdicom";
        version = "0.0.2";
-       sha256 = "05f99nv4ydals0x1y39mswm3437s6bisdk63bgfzb89sgh0p9w1p";
+       sha256 = "37f074017c3aa1f5dd5bc3cca6e332fa0c322ad7350d1f3ad054354fb64dc915";
        isLibrary = true;
        isExecutable = true;
        libraryHaskellDepends = [ base directory filepath ];
@@ -79777,7 +80087,7 @@ self: {
      mkDerivation {
        pname = "isevaluated";
        version = "0.3.0.2";
-       sha256 = "10f09br33xy5ldl924kfnnlc5ilwq44hd17s2qdf9jm75q4sa7d5";
+       sha256 = "a51da5092ea7cae41a16fa840609c19cc6c2a8b56e129168a3c5f731f24ac081";
        libraryHaskellDepends = [ base vacuum ];
        jailbreak = true;
        description = "Check whether a value has been evaluated";
@@ -79790,7 +80100,7 @@ self: {
      mkDerivation {
        pname = "isiz";
        version = "0.0.1";
-       sha256 = "0k0nyiicz87lvay95vligf563k1dgx93zds0f0kzqxn20miq480s";
+       sha256 = "1a20826305c276fc277040b73f527f2dcc618a7b91ee92bcdaf4a0cf62f4164c";
        isLibrary = false;
        isExecutable = true;
        executableHaskellDepends = [ base gtk3 ];
@@ -79803,7 +80113,7 @@ self: {
      mkDerivation {
        pname = "islink";
        version = "0.1.0.0";
-       sha256 = "1mxfs8k0znc7v2iynjnhr4k5c9as4ip37ybvxnvjfqy4dld9rgyg";
+       sha256 = "cfbf9c1a6dc46327b7ed7bf9336e245a255626c9d04aeba3d887d90f26d2aed7";
        libraryHaskellDepends = [ base unordered-containers ];
        homepage = "https://github.com/redneb/islink";
        description = "Check if an HTML element is a link";
@@ -79817,7 +80127,7 @@ self: {
      mkDerivation {
        pname = "ismtp";
        version = "4.0.2";
-       sha256 = "0skyrp497p0gfh39j1ng7ahpbzfykfvykq720akafgnapgsfxkhm";
+       sha256 = "15ceeef4bbca3ea7a602e2e0e9b79bdefd75a13acf069906740fdc93c8cd7e6a";
        libraryHaskellDepends = [
          base bytestring containers contstuff dnscache enumerator
          lifted-base monad-control netlines network vector
@@ -79832,7 +80142,7 @@ self: {
      mkDerivation {
        pname = "iso3166-country-codes";
        version = "0.20140203.7";
-       sha256 = "1cfmrkrx5wdcr8rrwakhmv0a5bxipxc3l7p4z5nxzl5nrjrli79s";
+       sha256 = "3a9d48b3ccb6d0df6df9e41e3a58bfb1afa2c0ae702a9e33caacf1d2f3ccd5b1";
        libraryHaskellDepends = [ base ];
        description = "A datatype for ISO 3166 country codes";
        license = "LGPL";
@@ -79843,7 +80153,7 @@ self: {
      mkDerivation {
        pname = "iso639";
        version = "0.1.0.3";
-       sha256 = "1s15vb00nqxnmm59axapipib1snh6q5qhfdw7pgb9vdsz8i86jqj";
+       sha256 = "124b8322fabaedb4de3dbc39880b36d0eab0e28d5775954aadb6630bc0da25e8";
        libraryHaskellDepends = [ base ];
        homepage = "https://github.com/HugoDaniel/iso639";
        description = "ISO-639-1 language codes";
@@ -79857,7 +80167,7 @@ self: {
      mkDerivation {
        pname = "iso8583-bitmaps";
        version = "0.1.0.0";
-       sha256 = "0w6m8ygpy1g95zvmbzq9402rxh4dj48i5bhcdzc4s0kig239gzqd";
+       sha256 = "0dff97867871024dd86f0cae1211918dc09e052009ff55f72fe9057f9f47d570";
        libraryHaskellDepends = [
          base binary bytestring containers parsec syb template-haskell
          th-lift
@@ -79871,7 +80181,7 @@ self: {
      mkDerivation {
        pname = "iso8601-time";
        version = "0.1.3";
-       sha256 = "05qwpcj4whibj0bmdnq0wns9ks5v4fqnsyq7sl2v36pd11h9i9zv";
+       sha256 = "fba7986008ed9ab105d5077b6db123bbe899b4e500db5617902b424e24bb1c17";
        libraryHaskellDepends = [ base time ];
        testHaskellDepends = [ base hspec HUnit time ];
        homepage = "https://github.com/nh2/iso8601-time";
@@ -79886,7 +80196,7 @@ self: {
      mkDerivation {
        pname = "isohunt";
        version = "0.1.3";
-       sha256 = "189dmxczmr0kqh440ziyp6kxx6iza2yyq7cs05hic9w8lhpwa6pw";
+       sha256 = "fc1ac52fa488271661019a1decbd503f9adea7b93e7e4008c413e4fa59af2da1";
        libraryHaskellDepends = [
          aeson base bytestring data-default ghc-prim http-conduit text
          unordered-containers uri vector
@@ -79904,7 +80214,7 @@ self: {
      mkDerivation {
        pname = "itanium-abi";
        version = "0.1.0.0";
-       sha256 = "19ywiim8jjkpj2f7agvq98j4p7l1bw8lp2lmgimwq3bz17nrawwk";
+       sha256 = "937395ed097f0dcc6b7c958a4b115f819e4b244a783f759c90774a896a8cdca7";
        libraryHaskellDepends = [
          base boomerang text transformers unordered-containers
        ];
@@ -79923,7 +80233,7 @@ self: {
      mkDerivation {
        pname = "iter-stats";
        version = "0.1.0.4";
-       sha256 = "1pfvxxps319ynfpaqgkiyk7gbpi4l2rfqzqyw27jhzlxx860yq71";
+       sha256 = "e1600f0cea9d7e288fe01e7fecb2a024def5cef4713eacaeb33e85a16fefdbdd";
        libraryHaskellDepends = [ base heap iteratee ListLike mtl ];
        testHaskellDepends = [
          base heap HUnit iteratee ListLike mtl statistics test-framework
@@ -79943,7 +80253,7 @@ self: {
      mkDerivation {
        pname = "iterIO";
        version = "0.2.2";
-       sha256 = "0cq0awzl249m9kzgs0hzs49r2v29q4dhq3sbd818izvyqzfzz4zm";
+       sha256 = "f593ffddc77eff88026a4b0f0c1bc1496c9113d11f02fdfe4c3511413f570033";
        libraryHaskellDepends = [
          array attoparsec base bytestring containers filepath HsOpenSSL
          ListLike mtl network old-locale process stringsearch time unix
@@ -79961,7 +80271,7 @@ self: {
      mkDerivation {
        pname = "iterable";
        version = "3.0";
-       sha256 = "194718jpjwkv3ynlpgjlpvf0iqnj7dkd3zmci363gsa425i3vlbc";
+       sha256 = "6cd13d621144e937cc88acfed1663bd2e208dcbe54be4bad1f7b7279250a87a4";
        libraryHaskellDepends = [
          base mtl tagged template-haskell vector
        ];
@@ -79979,7 +80289,7 @@ self: {
      mkDerivation {
        pname = "iteratee";
        version = "0.8.9.6";
-       sha256 = "1yc5fqqb8warvgld3cymka7d2wmjydvfin5jy7zaazb7alf14q1p";
+       sha256 = "3760121c55677da5fef1b2d8e876f3b272d18e9ad5b3d1e8db5971b4307685f9";
        libraryHaskellDepends = [
          base bytestring containers exceptions ListLike monad-control
          parallel transformers transformers-base unix
@@ -80001,7 +80311,7 @@ self: {
      mkDerivation {
        pname = "iteratee-compress";
        version = "0.3.3.1";
-       sha256 = "1j5w3pfi8mx88wfg6fwrj5jccfp8spw0jwb4zh3yyzg1jacrpal4";
+       sha256 = "84aa9b9992e17def07fc647109f8d5e83ac66491993bf31c47a85714dd1dbcc8";
        libraryHaskellDepends = [ base bytestring iteratee mtl ];
        librarySystemDepends = [ bzip2 zlib ];
        description = "Enumeratees for compressing and decompressing streams";
@@ -80016,7 +80326,7 @@ self: {
      mkDerivation {
        pname = "iteratee-mtl";
        version = "0.5.0.0";
-       sha256 = "0a3f0m9lgc4ks18891a689bbb1c1kdrxswj42s5syvcq73y7v2h0";
+       sha256 = "008a7dfc38986daf8b164472dd739b8185b5564246858450d093b04753056e28";
        isLibrary = true;
        isExecutable = true;
        libraryHaskellDepends = [
@@ -80036,7 +80346,7 @@ self: {
      mkDerivation {
        pname = "iteratee-parsec";
        version = "0.0.6";
-       sha256 = "1saffq3pl20fph6jdss6yzdgfaqxwb2183gb3qxj6cwsrblzz628";
+       sha256 = "4898ffe9ca9a33233b1eeb0d14c4e21d2bf7daf746eb260dbc0e087a07764ee9";
        libraryHaskellDepends = [
          base iteratee ListLike parsec reference transformers
        ];
@@ -80051,7 +80361,7 @@ self: {
      mkDerivation {
        pname = "iteratee-stm";
        version = "0.1.2";
-       sha256 = "1916phr07ckvm571rspswqr93z22la0mkxghvzljr0vgd1zi4p0x";
+       sha256 = "1d5c127f686f832ce9dff0f55981a242fc9132e6faea1c4ea97bb20332bc26a4";
        libraryHaskellDepends = [
          base iteratee stm stm-chans transformers
        ];
@@ -80069,7 +80379,7 @@ self: {
      mkDerivation {
        pname = "iterio-server";
        version = "0.3";
-       sha256 = "1yz05y6i036irdbnsmhhr9lpcfk56ii6ls1fqdgh80h9giyi6c0n";
+       sha256 = "1630137d7c0902045fc32e686a6234653a7669ca10566d57cbd10c108d2fe0fb";
        libraryHaskellDepends = [
          base bytestring filepath iterIO ListLike monadIO mtl network split
          transformers unix
@@ -80086,7 +80396,7 @@ self: {
      mkDerivation {
        pname = "ivar-simple";
        version = "0.3.1";
-       sha256 = "1zn3nr0qmrnpr7jnpwgb4sancflbp9xmk2qyahl0d9vw7agqhwlm";
+       sha256 = "9572889f3a7ca70628541e8b597bba8b3a669526ebf16be5c9d7e68a41b6c3fe";
        libraryHaskellDepends = [ base ];
        description = "Write once concurrency primitives";
        license = stdenv.lib.licenses.mit;
@@ -80099,7 +80409,7 @@ self: {
      mkDerivation {
        pname = "ivor";
        version = "0.1.14.1";
-       sha256 = "0r9ykfkxpwsrhsvv691r361pf79a7y511hxy2mvd6ysz1441mych";
+       sha256 = "90f91a08095f7bd37615bec3108a3f2a1d7783193924b3b78659f3dba79b3e65";
        libraryHaskellDepends = [
          base binary containers directory haskell98 mtl parsec
        ];
@@ -80116,7 +80426,7 @@ self: {
      mkDerivation {
        pname = "ivory";
        version = "0.1.0.0";
-       sha256 = "1rn1akrsci0k5nbk4zipxznkdm0y3rvv9la5mnrr9mkj5zikj5sc";
+       sha256 = "4c1739e32f72d694b3ad45d1b4771e1ed436edef377e32972d1344a6f354c1e6";
        libraryHaskellDepends = [
          base containers monadLib parsec pretty template-haskell th-lift
        ];
@@ -80135,7 +80445,7 @@ self: {
      mkDerivation {
        pname = "ivory-backend-c";
        version = "0.1.0.1";
-       sha256 = "12rcaanxl86wna05x1gdkpfj90azn1z74cs3kfk9cp5g3g230ii4";
+       sha256 = "244630c41baf5c96a69b4333727eb05f8124dd9ded855e80b2dc20daad522c8b";
        libraryHaskellDepends = [
          base bytestring cmdlib containers directory filepath ivory
          ivory-opts language-c-quote mainland-pretty monadLib process srcloc
@@ -80154,7 +80464,7 @@ self: {
      mkDerivation {
        pname = "ivory-bitdata";
        version = "0.2.0.0";
-       sha256 = "03qqax98qr2qyidc71i81f70lbma1s2q5jikl3m4ni4wyj3gg1m3";
+       sha256 = "a386f786f49c444beaa033ca82850eaa2e0a8e0b2886c35af458648c5257180f";
        isLibrary = true;
        isExecutable = true;
        libraryHaskellDepends = [
@@ -80175,7 +80485,7 @@ self: {
      mkDerivation {
        pname = "ivory-examples";
        version = "0.1.0.2";
-       sha256 = "0jjcr72s616y8g4288fz506p1swrv06c2fmds28yd1rqc57g1mrm";
+       sha256 = "35d7f04e613887e691d0ad3ac10cd899eb700d28df2124c843de04a3c5c94c4a";
        isLibrary = false;
        isExecutable = true;
        executableHaskellDepends = [
@@ -80196,7 +80506,7 @@ self: {
      mkDerivation {
        pname = "ivory-hw";
        version = "0.1.0.0";
-       sha256 = "1sa0ayym7ng5q7i356n59p18qqpy9cr2xcsmgh96a7ni4srbrbsy";
+       sha256 = "5eafbcb226d11e65127c55b32e324bfe628cc24dc59a32e2c1e5d953bd5740e9";
        libraryHaskellDepends = [
          base filepath ivory ivory-backend-c ivory-bitdata
        ];
@@ -80213,7 +80523,7 @@ self: {
      mkDerivation {
        pname = "ivory-opts";
        version = "0.1.0.1";
-       sha256 = "08ywjwkd37dld6h355r6a36h72s94gai7hs2r4hj5nk5pm7k4s5z";
+       sha256 = "bf68324fbd65da2221c942c313d523498b03cd50269732a069b49dd12697dc23";
        libraryHaskellDepends = [
          base containers dlist fgl filepath ivory monadLib
        ];
@@ -80229,7 +80539,7 @@ self: {
      mkDerivation {
        pname = "ivory-quickcheck";
        version = "0.1.0.0";
-       sha256 = "0jbfpsmz8kq0h9gg5lm44pcdzhv8kv2rr554m4bic2bny94hnsjd";
+       sha256 = "4d6a0b49f276091617a9a4949cc59e68c3dfd825a4d2f25e82004ff4abbe6e49";
        libraryHaskellDepends = [ base ivory monadLib QuickCheck random ];
        jailbreak = true;
        homepage = "http://smaccmpilot.org/languages/ivory-introduction.html";
@@ -80243,7 +80553,7 @@ self: {
      mkDerivation {
        pname = "ivory-stdlib";
        version = "0.1.0.0";
-       sha256 = "1a3d9916rgrznr5ci79ki918xg6xxd81krn8irv9wbp8h8ird2xq";
+       sha256 = "b88b962382e82e9e768ec8e61950ebddbc8e428a339dc84ab63fbf6c424a6da8";
        libraryHaskellDepends = [ base filepath ivory ];
        jailbreak = true;
        homepage = "http://smaccmpilot.org/languages/ivory-introduction.html";
@@ -80259,7 +80569,7 @@ self: {
      mkDerivation {
        pname = "ivy-web";
        version = "0.2";
-       sha256 = "0m2wd8lh22nqyjiijw9ldl6l17fbkj7b4n0j5ymgrs3yx2mnnv1q";
+       sha256 = "386c6babe87ee8fcaa2f1258b28e9ccb9d400d6d347119a3f4d80a01296a5c54";
        libraryHaskellDepends = [
          base invertible-syntax partial-isomorphisms snap snap-core
        ];
@@ -80274,7 +80584,7 @@ self: {
      mkDerivation {
        pname = "ix-shapable";
        version = "0.1.0";
-       sha256 = "08ljlzywnw0h8ijwb6yh4r8l6z7bbknwxv9cjq7lkfx7m2vgy1sh";
+       sha256 = "5007ffb6a8a7bb490f962cedceed5ceb7c435126d09bc565441070cbfda79222";
        libraryHaskellDepends = [ array base ];
        description = "Reshape multi-dimensional arrays";
        license = stdenv.lib.licenses.bsd3;
@@ -80285,7 +80595,7 @@ self: {
      mkDerivation {
        pname = "ixdopp";
        version = "0.1.3";
-       sha256 = "1vknwznk42b33q4pmh6z620g761yf3cmsmrmhilgq42i5qhll4d4";
+       sha256 = "a4114a212e5110fc688435575dd9703e98f38030dfc07a091e630932ede776ee";
        isLibrary = false;
        isExecutable = true;
        executableHaskellDepends = [ base preprocessor-tools syb ];
@@ -80301,7 +80611,7 @@ self: {
      mkDerivation {
        pname = "ixmonad";
        version = "0.57";
-       sha256 = "1k8qfx9p6jw6gb4jsgq6y2bc6y6ah4h44gdgs0fxkrg371wyym7k";
+       sha256 = "f354ef7938e3e5d91dd0af3d422081ca78c396f0063f2dc97a864b73537718cd";
        libraryHaskellDepends = [ base ghc-prim ];
        description = "Embeds effect systems into Haskell using parameteric effect monads";
        license = stdenv.lib.licenses.bsd3;
@@ -80314,7 +80624,7 @@ self: {
      mkDerivation {
        pname = "ixset";
        version = "1.0.6";
-       sha256 = "097f9fkm9a2n67bzagr9h2v7acdn8h1ayv9c83n7nv1dh157bpyv";
+       sha256 = "dbdf754a802d6c7bec402c6daf0244b63175b680293ff5d73156a854a74bee24";
        libraryHaskellDepends = [
          base containers safecopy syb syb-with-class template-haskell
        ];
@@ -80331,7 +80641,7 @@ self: {
      mkDerivation {
        pname = "ixset-typed";
        version = "0.3";
-       sha256 = "0m6k5n755pfkx1grd5rbp1a9vlps6fdm25l91aa0wp5af1sakjmk";
+       sha256 = "b3caa97470aa5c0e940a8916519b33fad29d54b82b97965fe8d3dd528e2dd354";
        libraryHaskellDepends = [
          base containers deepseq safecopy syb template-haskell
        ];
@@ -80351,7 +80661,7 @@ self: {
      mkDerivation {
        pname = "iyql";
        version = "0.0.7";
-       sha256 = "1jb97jzm9w8z8jyswbcr3kdraam95by6bc1gpjddwn817dijf0q4";
+       sha256 = "040327633b0159de9abc2fb065fc2aa92a95db1c992daebd441ff154bf3c69c9";
        isLibrary = false;
        isExecutable = true;
        executableHaskellDepends = [
@@ -80371,7 +80681,7 @@ self: {
      mkDerivation {
        pname = "j2hs";
        version = "0.99.1";
-       sha256 = "0fls5krx9l0c7g755b4yyksiki45hbb6v7m0y6nsmpd217rggkb2";
+       sha256 = "62cdf7f209a2ddaaadf1a09e6dd68285c419f5f49eac52ce3b0cd0d4f32c9a3a";
        isLibrary = false;
        isExecutable = true;
        executableHaskellDepends = [
@@ -80393,7 +80703,7 @@ self: {
      mkDerivation {
        pname = "jack";
        version = "0.7.0.3";
-       sha256 = "12ap7xcgzmp5zwmqkwsgxplh5li21m7xngijr4mhnn9y33xc1lrk";
+       sha256 = "33d3c0fa183e590b2bc9323edb4f0d22d202e9ed4ff3892bffe5d6ff583f5789";
        isLibrary = true;
        isExecutable = true;
        libraryHaskellDepends = [
@@ -80411,7 +80721,7 @@ self: {
      mkDerivation {
        pname = "jack-bindings";
        version = "0.1.1";
-       sha256 = "1gmz2qiz7wzydj0rhswbfhwi0zbdcbps29l1lryzqxm8chfc9mbm";
+       sha256 = "75d5c41c64a876fc7da68126a1ef626d7d1039748b6b98816cfef3f32316bfbe";
        libraryHaskellDepends = [ base mtl ];
        libraryPkgconfigDepends = [ libjack2 ];
        libraryToolDepends = [ c2hs ];
@@ -80425,7 +80735,7 @@ self: {
      mkDerivation {
        pname = "jackminimix";
        version = "0.1";
-       sha256 = "03ysmgg5f3dsimskqw5vpnrv5jg4gf1gd0khmf0s1ilfm1jc1nfd";
+       sha256 = "cdd9c064a88ec6a081ab7082f6827be4c9b2b3bdbb703c758dba0d57deabda0f";
        libraryHaskellDepends = [ base hosc ];
        jailbreak = true;
        homepage = "http://www.renickbell.net/doku.php?id=jackminimix";
@@ -80439,7 +80749,7 @@ self: {
      mkDerivation {
        pname = "jacobi-roots";
        version = "0.2.0.4";
-       sha256 = "1skpw2jm5g0lylc79n5fk37d3lrvhwb3cmn50wcy4i5nnjvfdijc";
+       sha256 = "4cc6e6b6b4b644e21907c5563616873bd3d1ce98aed87418f514bc52a5e077ea";
        libraryHaskellDepends = [ base binary bytestring vector ];
        testHaskellDepends = [ base doctest ];
        homepage = "http://github.com/ghorn/jacobi-roots";
@@ -80454,7 +80764,7 @@ self: {
      mkDerivation {
        pname = "jail";
        version = "0.0.1.1";
-       sha256 = "0wxz3w5r1zc571ibyqskwk27ba1dafwwpr10psbsg44fj7ii3vvz";
+       sha256 = "7fef11e3918e90a797be20e4cbb9532da875c4e45363bf623885fd900b1fbf73";
        libraryHaskellDepends = [
          base containers directory monads-fd transformers
        ];
@@ -80468,7 +80778,7 @@ self: {
      mkDerivation {
        pname = "jailbreak-cabal";
        version = "1.3";
-       sha256 = "1i4a8azbq74r3pb4hvb816amy13z03afpq4jvyps3s399id6zhx2";
+       sha256 = "a2c36f5a4c69e8a1afdf92e0ebd4007f045f9509686d48d61d991cbcbe428ac4";
        revision = "2";
        editedCabalFile = "eb10d8166cc3a40e8d731ab1fba7d37ef57d155d6122c7234297ddbf776ec28a";
        isLibrary = false;
@@ -80484,7 +80794,7 @@ self: {
      mkDerivation {
        pname = "jalaali";
        version = "0.2.0";
-       sha256 = "025ryrz87bii3401nq0bhyigzrs6lkippds6r4h0qzpq4pg8l7m0";
+       sha256 = "a01e8ade25f87e0c20c946b77be3a446e7ffa2870b601b001931ae837ef6b908";
        libraryHaskellDepends = [ base ];
        testHaskellDepends = [ base ];
        jailbreak = true;
@@ -80501,7 +80811,7 @@ self: {
      mkDerivation {
        pname = "jalla";
        version = "0.2.0.1";
-       sha256 = "122lf1j9hs81yzj6hdv7a7q56846h1ggasbjgvjnk8r34d0xsl40";
+       sha256 = "8050dd412323a369e57e7269f55e80862053f051673768e4f701699864705488";
        libraryHaskellDepends = [
          base base-orphans convertible mtl QuickCheck random
        ];
@@ -80525,7 +80835,7 @@ self: {
      mkDerivation {
        pname = "jammittools";
        version = "0.5.0.1";
-       sha256 = "1qfa90hi0kcylfw3p4m2qx5n4ni14426ssffj63hixqrqcnz60gx";
+       sha256 = "fd01f32dc319f7088791ce696d0421215a624bc7a2923bb8a39e4d102148cae1";
        isLibrary = true;
        isExecutable = true;
        libraryHaskellDepends = [
@@ -80547,7 +80857,7 @@ self: {
      mkDerivation {
        pname = "jarfind";
        version = "0.1.0.3";
-       sha256 = "0cfxq8k0k8r3wf4siypb78rqx5c9m2cm899bpa0zz591hc0p6k0w";
+       sha256 = "1c4c7301832195ff81ba2b255499a889958e333aebfaa889e323a30926c2dd31";
        isLibrary = true;
        isExecutable = true;
        libraryHaskellDepends = [
@@ -80569,7 +80879,7 @@ self: {
      mkDerivation {
        pname = "java-bridge";
        version = "0.20130606.3";
-       sha256 = "16nm5jn5y3rs3g1m524gn8xqxw13973cmpllmylh6qdpqcz47457";
+       sha256 = "a790433ec3b76103a9af94decac64923f08e3bb28f8852c31b3a0f5fac2cd59a";
        isLibrary = true;
        isExecutable = true;
        libraryHaskellDepends = [
@@ -80590,7 +80900,7 @@ self: {
      mkDerivation {
        pname = "java-bridge-extras";
        version = "0.99";
-       sha256 = "0wjxm0h5xlsab7iphcabb66c7gjxy7hyb502inlj5zxq1ic5ghzv";
+       sha256 = "fbc357580cb8ff22a98d0294e5e1f15dbec38c594b3178e3594ad35e20a85d72";
        libraryHaskellDepends = [ base java-bridge transformers ];
        jailbreak = true;
        description = "Utilities for working with the java-bridge package";
@@ -80603,7 +80913,7 @@ self: {
      mkDerivation {
        pname = "java-character";
        version = "0.0.4";
-       sha256 = "1ms8m95mara3pp7qdg8jn2ajbq3zj8pnbs1b9jhpxbdkl5220768";
+       sha256 = "c81c2044a1b3ad7ea14c2be8652f927fe02595b012bd86cfbd4365554baa48d7";
        libraryHaskellDepends = [ base diet ];
        homepage = "https://github.com/tonymorris/java-character";
        description = "Functions to simulate Java's Character class";
@@ -80615,7 +80925,7 @@ self: {
      mkDerivation {
        pname = "java-reflect";
        version = "0.99";
-       sha256 = "1vdfq3c8chqhss6jiy139yrm45mij4kjdwxf2wrsfm4064j0n3wc";
+       sha256 = "8c0f0b24318054a73317aef3262791b11652b34f23f8288dd6104386d8c0aeed";
        libraryHaskellDepends = [ base containers hx java-bridge ];
        jailbreak = true;
        description = "Tools for reflecting on Java classes";
@@ -80630,7 +80940,7 @@ self: {
      mkDerivation {
        pname = "javasf";
        version = "0.1.0";
-       sha256 = "0k8si8rdhplfhfp5yq7rlkifj80401qyanfhv101h8amxg20m97w";
+       sha256 = "fca40ac4eb55211840d8d059e571000420e9e2a4f9605fae838e5ed8328a1a4d";
        isLibrary = false;
        isExecutable = true;
        executableHaskellDepends = [
@@ -80650,7 +80960,7 @@ self: {
      mkDerivation {
        pname = "javav";
        version = "0.1.1";
-       sha256 = "1kzhp9gim9jl78jw8gm9vzxciiz6m04pjamgx1pqbhkji3lkw55d";
+       sha256 = "ad143ee98872c2856fe8af2a7909a8e6c7c8fadfa93ec4253a54a61a5fbaf0cf";
        isLibrary = false;
        isExecutable = true;
        executableHaskellDepends = [ base ];
@@ -80670,7 +80980,7 @@ self: {
      mkDerivation {
        pname = "jcdecaux-vls";
        version = "0.1.0";
-       sha256 = "11army6p19xmdils32nxf5zbjh4fcsp075x7h3v2hbc08n6fkj8s";
+       sha256 = "1ac9e98c45802d28f680a79703ae668e40b97e71dd8aa1696cb5a7708daf5985";
        libraryHaskellDepends = [
          aeson base bytestring http-conduit text transformers
        ];
@@ -80687,7 +80997,7 @@ self: {
      mkDerivation {
        pname = "jdi";
        version = "0.0.3";
-       sha256 = "1jznizbnyg37lir155sq84dbsqcaavz061hj2a703w9x28s6pcnb";
+       sha256 = "cbb26b34123df1018e12120603fe568a61bd1a4158971272a4673c6fd78ff6cb";
        isLibrary = true;
        isExecutable = true;
        libraryHaskellDepends = [
@@ -80710,7 +81020,7 @@ self: {
      mkDerivation {
        pname = "jespresso";
        version = "1.0.2";
-       sha256 = "0wka2wq89x6vzhvr93wrlc8dp7shd8jic11camrgpqqsqk3j0pnd";
+       sha256 = "cd5e20c7c41ae3fb72552c0416256a509fdb10a3998f9437fcdbf48430176a72";
        isLibrary = true;
        isExecutable = true;
        libraryHaskellDepends = [
@@ -80741,7 +81051,7 @@ self: {
      mkDerivation {
        pname = "jmacro";
        version = "0.6.13";
-       sha256 = "0b7l4h3apkj41w69wg3ympflh2l53vbmyvs6xf20xn57d6p8lhn4";
+       sha256 = "c4428aae69a7d80e84eb466f5fd71e850a48ddad7e3c9e0c0f44ceab0624f42c";
        isLibrary = true;
        isExecutable = true;
        libraryHaskellDepends = [
@@ -80762,7 +81072,7 @@ self: {
      mkDerivation {
        pname = "jmacro-rpc";
        version = "0.3.2";
-       sha256 = "1nf5f62s749xsji2rg25dgj7mc668l3n7i7l9n1pjkn8gfwm6bx3";
+       sha256 = "a32f53b97bc84e79834df4c4630745c6b07ae46b45bc2ca2d43d91a38571c5d9";
        libraryHaskellDepends = [
          aeson attoparsec base blaze-html bytestring containers
          contravariant jmacro mtl scientific split text unordered-containers
@@ -80780,7 +81090,7 @@ self: {
      mkDerivation {
        pname = "jmacro-rpc-happstack";
        version = "0.3.2";
-       sha256 = "0r5h8hlsjppnhqdxa0dsrjkpv3pldbkv5v4dryd4km2v38yfxkcr";
+       sha256 = "99cdee3c1a5bd4499acf8decb2e76af48e7da7ccba01d51b86f65ea92944b064";
        libraryHaskellDepends = [
          aeson base blaze-html bytestring containers happstack-server jmacro
          jmacro-rpc mtl
@@ -80797,7 +81107,7 @@ self: {
      mkDerivation {
        pname = "jmacro-rpc-snap";
        version = "0.3";
-       sha256 = "1syzx2lw4r8knsqhsvilp04wb8a718379cmn0nhjqlwhpaja9bj8";
+       sha256 = "48aea4a4ba90532ca105b6b274060a47a1c509b8346e0db1b61365c2a9e8dfeb";
        libraryHaskellDepends = [
          aeson base bytestring containers jmacro jmacro-rpc mtl snap-core
        ];
@@ -80816,7 +81126,7 @@ self: {
      mkDerivation {
        pname = "jobqueue";
        version = "0.1.5";
-       sha256 = "0zfdh559qyzflrnh0gg23zfpw4vkp8qsx6syrblq2d0iknfybhir";
+       sha256 = "39c2e59d9d113481e9ca5e9bae31ba73137edd1fe23d006da6ee7b9c4a81cd7d";
        libraryHaskellDepends = [
          aeson attoparsec base bytestring containers data-default
          fast-logger HDBC HDBC-sqlite3 hslogger hzk lifted-base
@@ -80839,7 +81149,7 @@ self: {
      mkDerivation {
        pname = "join";
        version = "0.4";
-       sha256 = "0bx9cvdhhw7z30qgxwpl0j23z18sx7xyin2y7bwxvg5ga737j8qx";
+       sha256 = "1d2379c651afbcddf93a5ed8e8fbe91a853f8404f4f2fe3018ff7008db66a92f";
        libraryHaskellDepends = [ base haskell98 multisetrewrite stm ];
        homepage = "http://sulzmann.blogspot.com/2008/12/parallel-join-patterns-with-guards-and.html";
        description = "Parallel Join Patterns with Guards and Propagation";
@@ -80852,7 +81162,7 @@ self: {
      mkDerivation {
        pname = "joinlist";
        version = "0.3.0";
-       sha256 = "0hjlyyylbh471696v9b1jckm7d4gfp1ka978sr1j0005d03gwv35";
+       sha256 = "656cfe066805002043d6e82435c3758fb453279361a56d920987c045bdf75442";
        libraryHaskellDepends = [ base ];
        homepage = "http://code.google.com/p/copperbox/";
        description = "Join list - symmetric list type";
@@ -80867,7 +81177,7 @@ self: {
      mkDerivation {
        pname = "jonathanscard";
        version = "0.1.1";
-       sha256 = "0zwd5mdwamyl6xlflhj0yvp9k5yfrxggvv49d3hriz9z15f5v5g8";
+       sha256 = "e8955d5c093ffd98e16889ecfd5ecfce9799eef64042ea6837d457c55b2d8d7f";
        libraryHaskellDepends = [
          base bytestring containers HTTP json mtl network old-locale time
        ];
@@ -80883,7 +81193,7 @@ self: {
      mkDerivation {
        pname = "jort";
        version = "1.0.0";
-       sha256 = "1c1nr8pq4vyn4mvyqms2mq1sm42qgr2mrznn5rsv34rd1f75b2d3";
+       sha256 = "a389558e0b2d93b1752ed6fe5c457e5890aa03ae4257ec7725d66f822fca36b0";
        isLibrary = false;
        isExecutable = true;
        executableHaskellDepends = [ array base gtk ];
@@ -80904,7 +81214,7 @@ self: {
      mkDerivation {
        pname = "jose";
        version = "0.3.41.2";
-       sha256 = "0pamg1wkp85zpwnbsvmsszy7nxsifl3zhbxvfmh44n0b6d2wg4w5";
+       sha256 = "8593c745330b58426075bb2ff8077551777bfcd7ba6ebd2cbfbfa03b7978555d";
        libraryHaskellDepends = [
          aeson attoparsec base base64-bytestring bifunctors byteable
          bytestring crypto-pubkey crypto-pubkey-types crypto-random
@@ -80936,7 +81246,7 @@ self: {
      mkDerivation {
        pname = "jose-jwt";
        version = "0.6.2";
-       sha256 = "0fw3b34ghpjpm56iln1i46kr8dcj1yv8gmalgdl7ym7n9bvgrfzq";
+       sha256 = "f8bbfcf64af6547f687b54d587b60f923594a72131581a4da9575ef8c858833b";
        revision = "1";
        editedCabalFile = "5aa6637a051160937328c7ff477615ff8424212374f46e41386c705e4db425c0";
        libraryHaskellDepends = [
@@ -80961,7 +81271,7 @@ self: {
      mkDerivation {
        pname = "jpeg";
        version = "0.0.1.1";
-       sha256 = "1hnfapr21zpfyiywa4zzmwa518jzg73dnmaakrbvvpcmr4fvh9qx";
+       sha256 = "1d27b81dc995ddbd579e4a55dbc6795fa25014afff13c57df4eefe20f255cec2";
        libraryHaskellDepends = [ base mtl ];
        description = "A library for decoding JPEG files written in pure Haskell";
        license = stdenv.lib.licenses.bsd3;
@@ -80972,7 +81282,7 @@ self: {
      mkDerivation {
        pname = "js-flot";
        version = "0.8.3";
-       sha256 = "0yjyzqh3qzhy5h3nql1fckw0gcfb0f4wj9pm85nafpfqp2kg58hv";
+       sha256 = "1ba2f2a6b8d85da76c41f526c98903cbb107f8642e506c072c1e7e3c20fe5e7a";
        libraryHaskellDepends = [ base ];
        testHaskellDepends = [ base HTTP ];
        homepage = "https://github.com/ndmitchell/js-flot#readme";
@@ -80985,7 +81295,7 @@ self: {
      mkDerivation {
        pname = "js-good-parts";
        version = "0.0.7";
-       sha256 = "0i3r3xl8hi2a3d6hrj77vbfi54bkq4pidrjcz13vz4az9dvz6k75";
+       sha256 = "e54cf3774b5f91bf47f84ce6162fc1739112dddae7c80c4d1b4a4488681f7944";
        libraryHaskellDepends = [ base wl-pprint ];
        homepage = "https://github.com/sseefried/js-good-parts.git";
        description = "Javascript: The Good Parts -- AST & Pretty Printer";
@@ -80998,7 +81308,7 @@ self: {
      mkDerivation {
        pname = "js-jquery";
        version = "1.11.3";
-       sha256 = "0my2ncql2vkdhxcqiw4jly957zkjdvbbw9jhf2dk6ndfnp81jyrx";
+       sha256 = "3d7b19d0b5ae59339b705026bed66e72fe5392a792f08859876d6e4131b3c257";
        libraryHaskellDepends = [ base ];
        testHaskellDepends = [ base HTTP ];
        homepage = "https://github.com/ndmitchell/js-jquery#readme";
@@ -81007,20 +81317,21 @@ self: {
      }) {};
 
   "jsaddle" = callPackage
-    ({ mkDerivation, base, hslogger, lens, template-haskell, text
-     , transformers
+    ({ mkDerivation, base, glib, gtk3, hslogger, lens, template-haskell
+     , text, transformers, webkitgtk3, webkitgtk3-javascriptcore
      }:
      mkDerivation {
        pname = "jsaddle";
-       version = "0.2.0.6";
-       sha256 = "1ggnhv9lgsd330p1k6zvg20dbqb1ysh282nalxramqvn2yhmqsx4";
+       version = "0.2.1.0";
+       sha256 = "3aebcb9422803265598a027f1e8a63f0f41176a0efdb436bf502d61102754513";
        libraryHaskellDepends = [
-         base lens template-haskell text transformers
+         base lens template-haskell text transformers webkitgtk3
+         webkitgtk3-javascriptcore
        ];
        testHaskellDepends = [
-         base hslogger lens template-haskell text transformers
+         base glib gtk3 hslogger lens template-haskell text transformers
+         webkitgtk3 webkitgtk3-javascriptcore
        ];
-       jailbreak = true;
        description = "High level interface for webkit-javascriptcore";
        license = stdenv.lib.licenses.mit;
      }) {};
@@ -81030,7 +81341,7 @@ self: {
      mkDerivation {
        pname = "jsaddle-hello";
        version = "1.0.0.0";
-       sha256 = "07kgjp35vbwljhyz9i49fbvbj4d05gn8swzynb0hd02bbsl5i0dp";
+       sha256 = "b78158a85e4b8006c1b2fe738dec2ba011b9f67289c4f43d9494af5dc6956f1e";
        isLibrary = false;
        isExecutable = true;
        executableHaskellDepends = [ base ghcjs-dom jsaddle lens ];
@@ -81048,7 +81359,7 @@ self: {
      mkDerivation {
        pname = "jsc";
        version = "0.1.1.1";
-       sha256 = "18mvpncvsfv4gv7lx00g8aixjmhzp0yklxaajx45v2hsx0azn8zc";
+       sha256 = "ec23fb15e81a8a5d48974a753a3db81f56d9a3420f804ecf7e643bbd99bdbba2";
        libraryHaskellDepends = [
          base jmacro lens template-haskell text transformers webkitgtk3
          webkitgtk3-javascriptcore
@@ -81068,7 +81379,7 @@ self: {
      mkDerivation {
        pname = "jsmw";
        version = "0.1";
-       sha256 = "1r36w2h5007qln56gnyyd7w6bcqiymn1jw287z0waf4fhpy02ygq";
+       sha256 = "f87901fc858e38c5c13f4870196cf511b365f869dedb678aa5f80050a0e066e4";
        libraryHaskellDepends = [ base DOM mtl WebBits ];
        jailbreak = true;
        description = "Javascript Monadic Writer base package";
@@ -81083,7 +81394,7 @@ self: {
      mkDerivation {
        pname = "json";
        version = "0.9.1";
-       sha256 = "18l5027vc68hnnxrxlnyl59vkkg95a92m1zzms0dqiby2r6pxdcn";
+       sha256 = "96b57e4d167e45dc80aeff872a922ae9cdb953a1ded29ebbb51019b68f0085a2";
        libraryHaskellDepends = [
          array base bytestring containers mtl parsec pretty syb text
        ];
@@ -81098,7 +81409,7 @@ self: {
      mkDerivation {
        pname = "json-assertions";
        version = "1.0.7";
-       sha256 = "1x73szyqb6w1hnhb4ab8dfc7hwn12avj4304jnr8lyxjg08hfaqa";
+       sha256 = "0a2b071178b27b8ab295040c22b712c17278986b6829b2a085819b85fdd7e3f4";
        libraryHaskellDepends = [
          aeson base indexed indexed-free lens lens-aeson text
        ];
@@ -81116,7 +81427,7 @@ self: {
      mkDerivation {
        pname = "json-autotype";
        version = "1.0.7";
-       sha256 = "11x6am3hqzhai0dm02pk20l5pk5bpj434z8ic4b8lksnv8l5zq46";
+       sha256 = "86e05f28da564f8a1661117d3288bcabcc5b2810f30a501b880a7e0c4755a687";
        isLibrary = true;
        isExecutable = true;
        libraryHaskellDepends = [
@@ -81146,7 +81457,7 @@ self: {
      mkDerivation {
        pname = "json-b";
        version = "0.0.4";
-       sha256 = "0wcvaswgffzvhfq7v5lqxp6xhxajaabbxkqpqxp5vwcv5slkiags";
+       sha256 = "faa938a92e9bf15d6ec717cfbe96525275d8cded98967db083fb3bf7b8569b71";
        isLibrary = true;
        isExecutable = true;
        libraryHaskellDepends = [
@@ -81171,7 +81482,7 @@ self: {
      mkDerivation {
        pname = "json-builder";
        version = "0.3";
-       sha256 = "0k8b93bqi68c7nwq09cws8kfm84kd4k5lpy4z9ifks1jaiyj3vxm";
+       sha256 = "b5ef217d5432e8e962fac45f5a266993a0ea26d29c2580b93d0c9988d7480b4d";
        libraryHaskellDepends = [
          base blaze-builder blaze-textual bytestring containers text
          unordered-containers utf8-string vector
@@ -81189,7 +81500,7 @@ self: {
      mkDerivation {
        pname = "json-enumerator";
        version = "0.0.1.2";
-       sha256 = "08gwrm15pvvhhrkrncy6wr4fi5v55fdhc8byfrw5zd62hmx8xm9d";
+       sha256 = "2dd58e7a85c2b45f78767e21069b2b6597e848e6c6339b678670ef5b42cdfc21";
        libraryHaskellDepends = [
          base blaze-builder blaze-builder-enumerator bytestring containers
          enumerator json-types text transformers
@@ -81208,7 +81519,7 @@ self: {
      mkDerivation {
        pname = "json-extra";
        version = "0.1.0.1";
-       sha256 = "1wqn68brkjmix7xidcb7170ydpxwq1p48qqmm4w9ak0zkvm70fks";
+       sha256 = "7a3a70ea9e1f4c9538a91563446ec0bcdfe6c10967b116fbe9b1ca99173216f3";
        revision = "1";
        editedCabalFile = "76113c3d47cb5d8087ffe18e1b09eaa22cc8dcd07010537739c7f1e4dc6b0741";
        libraryHaskellDepends = [
@@ -81228,7 +81539,7 @@ self: {
      mkDerivation {
        pname = "json-fu";
        version = "0.1.1";
-       sha256 = "098ps56igr12wm9hai3agh2hdmvd00rzpdd5lw0ffjivjxxfh829";
+       sha256 = "4920e87a973b4ae700a7a5b5fb33006dd706057c6a440553e522e4174dd11725";
        libraryHaskellDepends = [
          aeson attoparsec base bytestring containers hashable mtl syb text
          time unordered-containers vector
@@ -81248,7 +81559,7 @@ self: {
      mkDerivation {
        pname = "json-python";
        version = "0.4.0.1";
-       sha256 = "0ga3clvmq20xlyx47bril651xg8rhq77s7nj6r1v836m3xwcb0y9";
+       sha256 = "c983c5781fd50cb44336d21e7d0e8619bd1e8aa131af43baa71d085c3765433d";
        libraryHaskellDepends = [
          aeson base bytestring containers pureMD5 template-haskell
        ];
@@ -81265,7 +81576,7 @@ self: {
      mkDerivation {
        pname = "json-qq";
        version = "0.4.1";
-       sha256 = "0rpfv0i4jhjkq39xcs3b89ms0w4il4l7f385msqj93qzj76is7m6";
+       sha256 = "a61e1dcd911f8f24b1ae050d7728a19170a06b426b68d6d3c053424922d8ee66";
        libraryHaskellDepends = [
          base haskell-src-meta parsec template-haskell
        ];
@@ -81280,21 +81591,21 @@ self: {
      , conduit-extra, deepseq, hashable, lifted-async, monad-control
      , monad-logger, mtl, QuickCheck, stm, stm-conduit, test-framework
      , test-framework-quickcheck2, text, transformers
-     , unordered-containers
+     , unordered-containers, vector
      }:
      mkDerivation {
        pname = "json-rpc";
-       version = "0.6.2.0";
-       sha256 = "1d9w18x9l0iyq5br1xgjaxkclcmrw56nlkifqkcv9fgsividhyw3";
+       version = "0.7.0.1";
+       sha256 = "e99da039bd589685ce9f396b6ef532a2640731c9e18d374cbe4aaf472530095f";
        libraryHaskellDepends = [
          aeson attoparsec base bytestring conduit conduit-extra deepseq
          hashable lifted-async monad-control monad-logger mtl QuickCheck stm
-         stm-conduit text transformers unordered-containers
+         stm-conduit text transformers unordered-containers vector
        ];
        testHaskellDepends = [
          aeson base bytestring conduit lifted-async monad-logger mtl
          QuickCheck stm stm-conduit test-framework
-         test-framework-quickcheck2 text unordered-containers
+         test-framework-quickcheck2 text transformers unordered-containers
        ];
        homepage = "https://github.com/xenog/json-rpc";
        description = "Fully-featured JSON-RPC 2.0 library";
@@ -81311,7 +81622,7 @@ self: {
      mkDerivation {
        pname = "json-rpc-client";
        version = "0.2.1.0";
-       sha256 = "1ma5vahbcfarbvc0m8n88i0hn9szbvanmfd81jmvwkamkqxxgmis";
+       sha256 = "3ad6d73b9e554dbeab0ca8b96ad55e5f270b4144c8a20ad85e5939b6a0da45d5";
        isLibrary = true;
        isExecutable = true;
        libraryHaskellDepends = [
@@ -81336,7 +81647,7 @@ self: {
      mkDerivation {
        pname = "json-rpc-server";
        version = "0.2.1.0";
-       sha256 = "1rbm8anj3lg3x7gky5nazxcsdwd5c48b1axphgcqzzy5hn8hsg2r";
+       sha256 = "593c0d9185c5ff8fd983b7abb01061a5f1a659ffca163fdfe9e3d121ad4275e5";
        isLibrary = true;
        isExecutable = true;
        libraryHaskellDepends = [
@@ -81360,7 +81671,7 @@ self: {
      mkDerivation {
        pname = "json-schema";
        version = "0.7.4.0";
-       sha256 = "073hs9wmpmv7b07s7by9r6hjcwn7bjhwyf256f2xiz4y355zljf5";
+       sha256 = "c549fa4b199efcd885334538cfa15cc77226a1c9c9afa30f5867d75b79d2701c";
        libraryHaskellDepends = [
          aeson base containers generic-aeson generic-deriving mtl scientific
          text time unordered-containers vector
@@ -81380,7 +81691,7 @@ self: {
      mkDerivation {
        pname = "json-sop";
        version = "0.1.0.4";
-       sha256 = "02x65fh0s3gl8adij8xg8mgqp7p3jj4yjhhvch51zgbhcflsb7cv";
+       sha256 = "9b9da5a96370bd1f0a641b42e98994e39e8b5f45af23199b42f40d0da02ba60b";
        libraryHaskellDepends = [
          aeson base generics-sop lens-sop tagged text time transformers
          unordered-containers vector
@@ -81397,7 +81708,7 @@ self: {
      mkDerivation {
        pname = "json-stream";
        version = "0.3.0.4";
-       sha256 = "01hmy7xxlh79mspcx3xgmqlndj8p2mqdjlakr3sl4p837xdkhv2d";
+       sha256 = "4d6c385b3f035d42f5c85351d9701517c96629aeaf8fceaeaee940dafbf11506";
        libraryHaskellDepends = [
          aeson base bytestring scientific text unordered-containers vector
        ];
@@ -81419,7 +81730,7 @@ self: {
      mkDerivation {
        pname = "json-togo";
        version = "0.1.1.0";
-       sha256 = "0aw0dkv1scllj56vj9q07a44vfs88f3k5x1m80y0mivlpz0280l3";
+       sha256 = "830224c0bf74c70a3c4035f432874348bb4d883a0027b94d9194321df66c802b";
        libraryHaskellDepends = [
          aeson attoparsec attoparsec-trans base bytestring scientific text
          transformers unordered-containers vector
@@ -81436,7 +81747,7 @@ self: {
      mkDerivation {
        pname = "json-tools";
        version = "0.5.0";
-       sha256 = "13iyhsq4010ypgmlsdkdk93w8dhg6v0cllsf0avfaxkdva9lrqkf";
+       sha256 = "6ee24c93da6d76e5b6024e53cac0360f36c4479a6d364debbb1e0440b0863e8e";
        isLibrary = false;
        isExecutable = true;
        executableHaskellDepends = [
@@ -81453,7 +81764,7 @@ self: {
      mkDerivation {
        pname = "json-types";
        version = "0.1";
-       sha256 = "088if9qv0didjyb6y1583viihjgc4nwr61qfjqdg9rzc2ya6vqdn";
+       sha256 = "b6e16d9417ece7f41a960e0793b925ec4918e31ea8046f96972d36b071721121";
        libraryHaskellDepends = [ base containers text ];
        description = "Basic types for representing JSON";
        license = stdenv.lib.licenses.mit;
@@ -81466,7 +81777,7 @@ self: {
      mkDerivation {
        pname = "json2";
        version = "0.8.3";
-       sha256 = "1w7x67cykbnr2h8jjjqd5whf7pq7vwk7r9g1q1i9g25b9b49i7r8";
+       sha256 = "289f98c84aab889762c0e1a57c26df07dfe3202f0d4b291114d9aee9d931fdf0";
        libraryHaskellDepends = [
          base blaze-builder bytestring containers json2-types mtl old-locale
          parsec pretty time utf8-string
@@ -81483,7 +81794,7 @@ self: {
      mkDerivation {
        pname = "json2-hdbc";
        version = "0.5.1";
-       sha256 = "1flbh68ymm39ccw5h9fiwy35qarn8zkxljmnjgg6fd39j8zbc3dj";
+       sha256 = "b20db63e92693467de93b64adae747362b5c86e7d12558386369d4ea91818bba";
        libraryHaskellDepends = [
          base containers HDBC json2 json2-types time utf8-string
        ];
@@ -81497,7 +81808,7 @@ self: {
      mkDerivation {
        pname = "json2-types";
        version = "0.1";
-       sha256 = "0gr5mfi68hvk8wajw6wbimmwxd0rgjwqrg3mjyfppkr1nwkyfzpr";
+       sha256 = "f97ee727b721cf7b9d9775bc8cb97c19b4ce6b8d8b1b2e1547734364a2ab253f";
        libraryHaskellDepends = [ base containers ];
        description = "Defined JSON data types and function for renders JSON to string";
        license = stdenv.lib.licenses.bsd3;
@@ -81508,7 +81819,7 @@ self: {
      mkDerivation {
        pname = "json2yaml";
        version = "0.3.2.3";
-       sha256 = "1ip9qgrzr59v3zxcj6l1dys0zbfj9s8fgdj4lv1grh7wbzdfz9dn";
+       sha256 = "b6a5efda5ffcc0fcc2a644b6e7904ed2ad0fb46f811ac9fa1f3b95fcf3c3e9c6";
        isLibrary = false;
        isExecutable = true;
        executableHaskellDepends = [ aeson base bytestring yaml ];
@@ -81524,7 +81835,7 @@ self: {
      mkDerivation {
        pname = "jsonresume";
        version = "0.1.0.1";
-       sha256 = "14kv1cbjh1m9ri0vjj015hx6bx6l7jv71gpfa6n0fg21hh5fl7a4";
+       sha256 = "441dea0a84413c07ac51eebe70b63cd4f4653a2c0148b941cca90628170b7b92";
        libraryHaskellDepends = [
          aeson base bytestring old-locale text time unordered-containers
        ];
@@ -81542,7 +81853,7 @@ self: {
      mkDerivation {
        pname = "jsonrpc-conduit";
        version = "0.2.6";
-       sha256 = "08mjwic7qbp241ydxiy5lm782igwd4ba27sii3csv4wdgdxgd3vy";
+       sha256 = "7e8ff67a7b8d93add988511fa11669fc45814ea5c5c7de7c20e22e7c58e4b222";
        isLibrary = true;
        isExecutable = true;
        libraryHaskellDepends = [
@@ -81565,7 +81876,7 @@ self: {
      mkDerivation {
        pname = "jsonschema-gen";
        version = "0.3.0.1";
-       sha256 = "18hc6a7ihjpnnnjsx4r403w2zx2nzxa4qvj4picdw83r4sgjvv2d";
+       sha256 = "4dec2d9f267920de58bc446e4c54ff56f42ff8002493aea5b5f64a188f320ca2";
        libraryHaskellDepends = [
          aeson base bytestring containers scientific tagged text time
          unordered-containers vector
@@ -81586,7 +81897,7 @@ self: {
      mkDerivation {
        pname = "jsonsql";
        version = "0.1.0.1";
-       sha256 = "1mr4xdwspza87kvaq4337k6hwzvrjxsr5bybdp1sv3x3fdg481ir";
+       sha256 = "3906445e73a38fadc36dcbaf927597797f0ecd3c6310acf63c48fdab79eb24d7";
        isLibrary = false;
        isExecutable = true;
        executableHaskellDepends = [
@@ -81608,7 +81919,7 @@ self: {
      mkDerivation {
        pname = "jsontsv";
        version = "0.1.5.0";
-       sha256 = "0qilhv14q51g3dzsxk0zp5fp2igy7m79lq1qsk1myrd6iyannxc5";
+       sha256 = "85756b958fa6655fc3d438609a4e3dfe45715db91fccae7f1b2f144cc2863462";
        isLibrary = false;
        isExecutable = true;
        executableHaskellDepends = [
@@ -81629,7 +81940,7 @@ self: {
      mkDerivation {
        pname = "jspath";
        version = "0.1";
-       sha256 = "072q6mipfaqf33w806chf2226zpay124lgph0wlgfdbhfd5118n7";
+       sha256 = "c7a2104a737035f72807f03e4a44f0ea7e238470901980f8180e2b776335581c";
        libraryHaskellDepends = [
          base bytestring bytestring-trie JSONb utf8-string
        ];
@@ -81645,7 +81956,7 @@ self: {
      mkDerivation {
        pname = "judy";
        version = "0.2.3";
-       sha256 = "1acw072v0lj2jkc6lffcigl1miy1r4wv52qxk6qql0wdg5ydjcjh";
+       sha256 = "5032d97c798d038ab1991d8bb239c9c1c71ae88bcc396ad8944252b0c5019ca9";
        libraryHaskellDepends = [ base bytestring ghc-prim ];
        librarySystemDepends = [ Judy ];
        testHaskellDepends = [ base hspec QuickCheck ];
@@ -81663,7 +81974,7 @@ self: {
      mkDerivation {
        pname = "jukebox";
        version = "0.1.4";
-       sha256 = "07galk5i5lq4dx1njd5851c7jz4qwhw8da76ggxd91f9xpvkmf9y";
+       sha256 = "3eb93af7edc985d4fa7be6a88638e4987c795828a83469436f04d312cba4ea1d";
        isLibrary = true;
        isExecutable = true;
        libraryHaskellDepends = [
@@ -81685,7 +81996,7 @@ self: {
      mkDerivation {
        pname = "jumpthefive";
        version = "0.0.1";
-       sha256 = "0ymp7hkkla7jxn3c7prsrcdl0mzkpqdm6ivq599qwx39rcnq6dpl";
+       sha256 = "f436832dcb69748e532a7847531bbef357401bcb3adfc386edf2283a273cb77a";
        isLibrary = true;
        isExecutable = true;
        libraryHaskellDepends = [ base parallel ];
@@ -81701,7 +82012,7 @@ self: {
      mkDerivation {
        pname = "jvm-parser";
        version = "0.2.1";
-       sha256 = "0rhixf1syrnhql3aqlvl9hcylaiyhca1yvismdzalkhbz0qdgvir";
+       sha256 = "39eed730f80b4eaa7eab3a6e1f14833e2aea194c7453ac06c5d066af83eb1166";
        libraryHaskellDepends = [
          array base binary bytestring containers data-binary-ieee754 fgl
          fingertree pretty zlib
@@ -81720,7 +82031,7 @@ self: {
      mkDerivation {
        pname = "jwt";
        version = "0.6.0";
-       sha256 = "02nb1nz7rrgqgr9dg01gi2kh29hpy4mlwpvk5ziqcg3zkb0gl60w";
+       sha256 = "1c18fac09a7f3c86e32f735f4e2bf1172601a7882f80d7527ef8e57cbe0dcb0a";
        libraryHaskellDepends = [
          aeson base base64-bytestring bytestring containers cryptohash
          data-default http-types network network-uri scientific semigroups
@@ -81745,7 +82056,7 @@ self: {
      mkDerivation {
        pname = "kademlia";
        version = "1.1.0.0";
-       sha256 = "0wjyslrhbms6cnm495g40yl6365h3vgjcka12lka8xdy89v3c0yy";
+       sha256 = "de03367642be75a42615414d26df1eb09861a807e49544aa6546d70533d55e72";
        libraryHaskellDepends = [
          base bytestring containers mtl network stm transformers
          transformers-compat
@@ -81767,7 +82078,7 @@ self: {
      mkDerivation {
        pname = "kafka-client";
        version = "0.7.0.1";
-       sha256 = "1577s3s9lf3rdw7xf7snfhiw53h6pg85l5h9l29av5fsg051ifai";
+       sha256 = "51b9180a78da95ad92a009165ad0bb068ec22374561fd70f6f79389af4d0e794";
        libraryHaskellDepends = [
          base bytestring cereal digest dlist network snappy time zlib
        ];
@@ -81788,7 +82099,7 @@ self: {
      mkDerivation {
        pname = "kan-extensions";
        version = "4.2.2";
-       sha256 = "0dqqlrzrhz8di5hp4kby3205inpj2r30bl75zyy24nq4hgans7g5";
+       sha256 = "e51d6dd583045b22bcffe5d0054616f2da5880187e4d7261890d7d987fa61837";
        libraryHaskellDepends = [
          adjunctions array base comonad containers contravariant
          distributive free mtl semigroupoids tagged transformers
@@ -81803,7 +82114,7 @@ self: {
      mkDerivation {
        pname = "kangaroo";
        version = "0.4.0";
-       sha256 = "1l7b71dhrxd2g3nbqg3h0n5dvgxr23av1cy1f0mvw347y91rx36x";
+       sha256 = "dd8c9e43f2870cbe2b70c1b3b0d510b9bfdd8a05703cbcec78a2f50c5b38ebd0";
        libraryHaskellDepends = [ array base ];
        jailbreak = true;
        homepage = "http://code.google.com/p/copperbox/";
@@ -81819,7 +82130,7 @@ self: {
      mkDerivation {
        pname = "kansas-comet";
        version = "0.3.1";
-       sha256 = "0xbapi4clmkighxh0jb12zpzgrz9sqyfpwdkvrj6cdq6i6a22qx1";
+       sha256 = "a16321948906376664deb3f1eb3cd6e9e7f7ef176149003b7c7156ca48bc6a75";
        libraryHaskellDepends = [
          aeson base containers data-default scotty stm text time
          transformers unordered-containers
@@ -81840,7 +82151,7 @@ self: {
      mkDerivation {
        pname = "kansas-lava";
        version = "0.2.4.3";
-       sha256 = "0i2k5jzirgn68g685azyjp2x96fd2mif56ghxvi566aa1qs5gw1v";
+       sha256 = "3bf057340e4a1953e2eef099e26215cd99d4c595feab82cc43c6be1cbf2c5344";
        revision = "1";
        editedCabalFile = "7b1860125ab2958d3831cb2536a6b939879f09951199649182bb848e70b583eb";
        isLibrary = true;
@@ -81865,7 +82176,7 @@ self: {
      mkDerivation {
        pname = "kansas-lava-cores";
        version = "0.1.2.2";
-       sha256 = "076hd8c59hivdirpf4y5vgdlvhq74lfd5zm6np34y8hblq6jyl0m";
+       sha256 = "15502f0da60b224fc6b5a6fed21c2507c34ddbdbc51377736c3bc254186ad01c";
        isLibrary = true;
        isExecutable = true;
        libraryHaskellDepends = [
@@ -81887,7 +82198,7 @@ self: {
      mkDerivation {
        pname = "kansas-lava-papilio";
        version = "0.3.1";
-       sha256 = "0n8ffiygl72cbqza0whmkhsqyg6d7flfdz1jvr22g68x3005r00y";
+       sha256 = "1e805c00181d992744de32fce6a83bcd3c8f359c1572a03e5e4c1cfa7c740e59";
        libraryHaskellDepends = [
          ansi-terminal base bytestring data-default directory filepath
          kansas-lava kansas-lava-cores netlist network sized-types
@@ -81904,7 +82215,7 @@ self: {
      mkDerivation {
        pname = "kansas-lava-shake";
        version = "0.1.2";
-       sha256 = "00xkrm724d7q5dmdgz41gm5s058b75rr4pgv3f6qkkx7g9qbd6d7";
+       sha256 = "a799b6707aa7cf898d1bfb5d9273390b15a04b7d81fcd76a2bf834224ecdb303";
        libraryHaskellDepends = [
          base containers directory filepath hastache kansas-lava shake
          temporary text
@@ -81921,7 +82232,7 @@ self: {
      mkDerivation {
        pname = "karakuri";
        version = "0.1.1";
-       sha256 = "0ys4kx4pq9xrb4gjg6syyim8mpfy3yzyyiw2mdc4vh9hmsny373c";
+       sha256 = "6c9ce1adae30c14d58ab8247efbf1fdedd8a6af45e9b271f59b9277c499f447b";
        libraryHaskellDepends = [
          base comonad containers minioperational mtl transformers
        ];
@@ -81938,7 +82249,7 @@ self: {
      mkDerivation {
        pname = "karver";
        version = "0.1.2";
-       sha256 = "0rbxhwxajcv8y6m0pz316r431jh5k8w3bcxqw117cnv6xkwgxpi1";
+       sha256 = "21defef8ec665b7642e0b8b335389a05ca30483661fc0baaf16833a93a877d65";
        libraryHaskellDepends = [
          aeson attoparsec base bytestring text unordered-containers vector
        ];
@@ -81957,7 +82268,7 @@ self: {
      mkDerivation {
        pname = "katt";
        version = "0.2.0.3";
-       sha256 = "1hvi23r9wgz77w6wl9nhpvkcbajm5m8kmy87pjmfgifj60d9cmhg";
+       sha256 = "0f56961a30d2c5e7aabc07f93a512d55aac5e6bed026ca0d3fe73f9ef21071c3";
        isLibrary = true;
        isExecutable = true;
        libraryHaskellDepends = [
@@ -81978,7 +82289,7 @@ self: {
      mkDerivation {
        pname = "kbq-gu";
        version = "0.2";
-       sha256 = "1skz1yllkwbpx4wd8w8q4zmqd3f62baaj5pja6dpqr2xviiv0j6g";
+       sha256 = "cf48b063dc5d647c9b51f216a9d412c68d86eb271871d438e977f149a90f7fea";
        isLibrary = false;
        isExecutable = true;
        executableHaskellDepends = [ base ];
@@ -81992,7 +82303,7 @@ self: {
      mkDerivation {
        pname = "kd-tree";
        version = "0.1.0";
-       sha256 = "0j9wlap9gx2szb5saa4pxm7mp2w132ki1p6mlcv0s0wy9rv6dnm7";
+       sha256 = "a7da66764e9e030d36a3d5dc10a718818b5b4fed9728a5cbfa5af497aea23c49";
        libraryHaskellDepends = [
          base lens linear vector vector-algorithms
        ];
@@ -82009,7 +82320,7 @@ self: {
      mkDerivation {
        pname = "kdesrc-build-extra";
        version = "0.1.0.2";
-       sha256 = "1n19jika26wgv7nhbbwnjjhmcbgqqag06k467r6q0s16ilp1p5nr";
+       sha256 = "d9961b2e8d2668804d3e864c039ec2f82d56a19496af05edd98f1ba1669429d8";
        isLibrary = false;
        isExecutable = true;
        executableHaskellDepends = [
@@ -82027,7 +82338,7 @@ self: {
      mkDerivation {
        pname = "kdt";
        version = "0.2.3";
-       sha256 = "0chxxl53jnnhfs02gxr2a3kzppmsnwrrfr1fjyx71lkvigwy71yk";
+       sha256 = "d387e3f98b7bd270ba972e649733b7badefbe75022f7278076d05a390aed1d32";
        libraryHaskellDepends = [ base deepseq deepseq-generics heap ];
        testHaskellDepends = [ base deepseq deepseq-generics QuickCheck ];
        homepage = "https://github.com/giogadi/kdt";
@@ -82040,7 +82351,7 @@ self: {
      mkDerivation {
        pname = "keera-callbacks";
        version = "0.1";
-       sha256 = "1xgxg30za69nfk8y83bmskjq2w3r3afg4gc507wkn91xdah93niq";
+       sha256 = "38da91a06a3d243bf901853df29c1a797081e5d4750de4d1743619f5c178fdf5";
        libraryHaskellDepends = [ base mtl ];
        description = "Mutable memory locations with callbacks";
        license = stdenv.lib.licenses.bsd3;
@@ -82053,7 +82364,7 @@ self: {
      mkDerivation {
        pname = "keera-hails-i18n";
        version = "0.0.3.3";
-       sha256 = "0aih2mxgyfnrfnvqqsdv5g7r4jgjg5cfqykgalcsb9wqv0gq6d4i";
+       sha256 = "9134831fd898a7a519556f7aec5879f24992cf2bbb698cb775d93aff7a15302a";
        libraryHaskellDepends = [
          base directory filepath glib hgettext MissingK setlocale
          utf8-string
@@ -82068,7 +82379,7 @@ self: {
      mkDerivation {
        pname = "keera-hails-mvc-controller";
        version = "0.0.3.3";
-       sha256 = "00qr5czm0hq3jxwp42fc50v6r458rm9qq9fpri4rhnc41il79nzb";
+       sha256 = "ebdb74680c84599849ccd7258c53cda8906c3628cc097279970343503f2b1903";
        libraryHaskellDepends = [ base ];
        homepage = "http://www.keera.es/blog/community/";
        description = "Haskell on Gtk rails - Gtk-based controller for MVC applications";
@@ -82082,7 +82393,7 @@ self: {
      mkDerivation {
        pname = "keera-hails-mvc-environment-gtk";
        version = "0.0.3.3";
-       sha256 = "0bk3191x8bsvmmnqyf7jzmrlg71q26z2kn4xfahdnpgxw3qskwmr";
+       sha256 = "b9f2a9f1e0fd5ddba0729dd829be11389c4773fdf2388f6dad5b2fd4430a632e";
        libraryHaskellDepends = [
          base keera-hails-mvc-model-protectedmodel keera-hails-mvc-view
          keera-hails-mvc-view-gtk
@@ -82099,7 +82410,7 @@ self: {
      mkDerivation {
        pname = "keera-hails-mvc-model-lightmodel";
        version = "0.0.3.4";
-       sha256 = "085qppi68qf8jbkp674ldikhr5z4nrffzqa9kgdm1dngrgsib190";
+       sha256 = "208515f5cbcfb650db9b49e1ef5cb6e4970c676c941c73e792c86164e2bdb820";
        libraryHaskellDepends = [
          base containers keera-hails-reactivevalues MissingK stm
          template-haskell
@@ -82117,7 +82428,7 @@ self: {
      mkDerivation {
        pname = "keera-hails-mvc-model-protectedmodel";
        version = "0.0.3.5";
-       sha256 = "14jm1116j3plzglxygjdymfy8z3p5k8zinnh8wazkxgc5y9kkcsx";
+       sha256 = "5db339932fecf5f91547d0daf8d12c777ce45df54d3edfe9fbf40e6942085592";
        libraryHaskellDepends = [
          base containers keera-hails-reactivevalues MissingK stm
          template-haskell
@@ -82132,7 +82443,7 @@ self: {
      mkDerivation {
        pname = "keera-hails-mvc-solutions-config";
        version = "0.0.3.3";
-       sha256 = "16c6nh5fqw2r42nxs3x27rqbpscypjzgqnprl99241giwcvy98x1";
+       sha256 = "a1a3e437e3f1052252a2f95afcbebc9ee9bb703ea20fddad205970ec0ab48699";
        libraryHaskellDepends = [ base directory filepath MissingK ];
        homepage = "http://www.keera.es/blog/community/";
        description = "Haskell on Gtk rails - Easy handling of configuration files";
@@ -82149,7 +82460,7 @@ self: {
      mkDerivation {
        pname = "keera-hails-mvc-solutions-gtk";
        version = "0.0.3.4";
-       sha256 = "01sksznn8rxv4ww3p99qm8dhjlpy03ygavp512zmyrpvydhp86mm";
+       sha256 = "b51a7461f3fb665fbf08e56ef5fc00fe52091baa38a53b3827bb6764edd75307";
        libraryHaskellDepends = [
          base gtk hslogger HTTP keera-hails-mvc-environment-gtk
          keera-hails-mvc-model-protectedmodel keera-hails-mvc-view
@@ -82166,7 +82477,7 @@ self: {
      mkDerivation {
        pname = "keera-hails-mvc-view";
        version = "0.0.3.3";
-       sha256 = "0jkwbpw23ba5z83nfk51hp8wsfkrbbiwr0f6bvx39wzz1v81n58p";
+       sha256 = "17151bd00efff334fa5ec681cce35a793acdd185a14c6707fa45ad21f85d7c4a";
        libraryHaskellDepends = [ base ];
        homepage = "http://www.keera.es/blog/community/";
        description = "Haskell on Gtk rails - Generic View for MVC applications";
@@ -82178,7 +82489,7 @@ self: {
      mkDerivation {
        pname = "keera-hails-mvc-view-gtk";
        version = "0.0.3.3";
-       sha256 = "1yz4drm0r1831acg9y8glg7hgiqwgc5nqkz4hfgqgfngqs94jx4z";
+       sha256 = "9f744992c6cfba879f83e44f6c0b7b1cc707cfa30ff9f4980a03850c6a6ee4fb";
        libraryHaskellDepends = [
          base gtk gtk-helpers keera-hails-mvc-view
        ];
@@ -82194,7 +82505,7 @@ self: {
      mkDerivation {
        pname = "keera-hails-reactive-fs";
        version = "0.0.3.4";
-       sha256 = "1yinlhp08xxdlbnm90gnwbr1h9sp8r741ihd8kihy1yfqzkp85cy";
+       sha256 = "9e1574e7c7ce070fe3440dc6404e46572718f2e2f68154eda2ad77042ea436fa";
        libraryHaskellDepends = [
          base directory fsnotify keera-hails-reactivevalues system-filepath
        ];
@@ -82211,7 +82522,7 @@ self: {
      mkDerivation {
        pname = "keera-hails-reactive-gtk";
        version = "0.0.3.6";
-       sha256 = "1i7l330y10vf35b61y9r5wij0gm871n4bc6lij56nx20msi66ch4";
+       sha256 = "043263a2ae40746b8a8cd4b0456c38a83e20232f39f96056196e83e0c118f4c4";
        libraryHaskellDepends = [
          base gtk gtk-helpers keera-hails-reactivevalues mtl transformers
        ];
@@ -82225,7 +82536,7 @@ self: {
      mkDerivation {
        pname = "keera-hails-reactive-network";
        version = "0.0.3.3";
-       sha256 = "1379djvy5nn6k67ds7mk9jjh03zd6sj0v8sf5agmk3pf5cyp0xa3";
+       sha256 = "4375703d2bee8e599f2a4ea30da436ed0f00a54cb31edd8e99c6dae2b76ce98c";
        libraryHaskellDepends = [
          base keera-hails-reactivevalues network
        ];
@@ -82240,7 +82551,7 @@ self: {
      mkDerivation {
        pname = "keera-hails-reactive-polling";
        version = "0.0.3.3";
-       sha256 = "1khkbhj94y6y5s2d56h718c8kh3y698wdryi2369mrw755dy6qh8";
+       sha256 = "0862e35b2987e79acc10d1e7c651327ec089180a079ad2842ede7892245c13ce";
        libraryHaskellDepends = [
          base keera-callbacks keera-hails-reactivevalues
        ];
@@ -82254,7 +82565,7 @@ self: {
      mkDerivation {
        pname = "keera-hails-reactive-wx";
        version = "0.0.3.3";
-       sha256 = "02ikqqfgwr3nrr18qdd1jshqm0dlnwbybqpzpj2ba7zbwpabd5bw";
+       sha256 = "7c95b6d4e5eb1fb584bcffe2e517b7b4818aa196a1358c42ce7664fe1cc6330a";
        libraryHaskellDepends = [
          base keera-hails-reactivevalues wx wxcore
        ];
@@ -82270,7 +82581,7 @@ self: {
      mkDerivation {
        pname = "keera-hails-reactive-yampa";
        version = "0.0.3.3";
-       sha256 = "1n1xyr9pc1sw9gypwhh1rfdjshg7x1kvwr6v3hp0837zvdcz8gw1";
+       sha256 = "813ff459dbff0c042e1cdb64be67e8e7412d9bcb01427efd4b5c077653f63dd8";
        libraryHaskellDepends = [
          base keera-callbacks keera-hails-reactivevalues time Yampa
        ];
@@ -82284,7 +82595,7 @@ self: {
      mkDerivation {
        pname = "keera-hails-reactivevalues";
        version = "0.0.3.4";
-       sha256 = "0qqp4ss0prl3z4bwrsd5jmbvdmhh7x3m846b58dd7ibb0bycp1pb";
+       sha256 = "eb86cbfc026bc5d31a2acb1054473f10d6b65795a5e9cc17f983e60bb4261763";
        libraryHaskellDepends = [ base contravariant ];
        homepage = "http://www.keera.es/blog/community/";
        description = "Haskell on Rails - Reactive Values";
@@ -82305,7 +82616,7 @@ self: {
      mkDerivation {
        pname = "keera-posture";
        version = "0.1.4.4";
-       sha256 = "0nlq68da3yfmp058j637xy25jjdwia8b1z49zf70rhdmyh8kvh60";
+       sha256 = "c0c03d11f4b5c10c8efb89fcb0908abc495984ef6718890ab8d5f9a11a32985a";
        isLibrary = false;
        isExecutable = true;
        executableHaskellDepends = [
@@ -82335,7 +82646,7 @@ self: {
      mkDerivation {
        pname = "keiretsu";
        version = "0.4.4";
-       sha256 = "0bwwsxav04dnipg5xvb8j4ncxbd5mw6r5gisn5avqjm34wr8y2b9";
+       sha256 = "69098f3227a34abc55b13abe920dafa5adce2c9168ed5ede8db611b055d79c2f";
        isLibrary = false;
        isExecutable = true;
        executableHaskellDepends = [
@@ -82362,7 +82673,7 @@ self: {
      mkDerivation {
        pname = "keter";
        version = "1.4.3.1";
-       sha256 = "0bsq6z7krisshcrkb528kixiw6liabb7chgk87088vn3gpwx048i";
+       sha256 = "1111d0f97dc36e84c041f34176d652911a1e7b9c48943533835ac73ccf37582f";
        isLibrary = true;
        isExecutable = true;
        libraryHaskellDepends = [
@@ -82391,7 +82702,7 @@ self: {
      mkDerivation {
        pname = "kevin";
        version = "0.11.0";
-       sha256 = "00hghd44h8d87kbf0j8ns78syz79a9sdwl454sb5n6ynq62fgwr1";
+       sha256 = "21f3e784c1d61b5b96268550de7452e97cafd1d11649e0d63ca8214848830f02";
        isLibrary = false;
        isExecutable = true;
        executableHaskellDepends = [
@@ -82409,7 +82720,7 @@ self: {
      mkDerivation {
        pname = "keycode";
        version = "0.1";
-       sha256 = "1cwj96mzxqagim3bcshzsrm2mxgmm8rrawy6hkvki9l55cggwbpv";
+       sha256 = "fb2efe1e2b85a638f784c6739533aaf5f52a6ad61f6ab6468d4fe1feab4992b3";
        libraryHaskellDepends = [ base containers ];
        homepage = "https://github.com/RyanGlScott/keycode";
        description = "Maps web browser keycodes to their corresponding keyboard keys";
@@ -82421,7 +82732,7 @@ self: {
      mkDerivation {
        pname = "keyring";
        version = "0.1.0.4";
-       sha256 = "1j7nynr7sksrqdn4zfp9ikwx6vvlimlhwhifbs68igfdn03gxnrd";
+       sha256 = "2ddbfe06b0cdbd888c5e2e420e698d746fd3f98ce9ba4f6cc3594f7db2f5f6c8";
        isLibrary = true;
        isExecutable = true;
        libraryHaskellDepends = [ base udbus ];
@@ -82439,7 +82750,7 @@ self: {
      mkDerivation {
        pname = "keys";
        version = "3.10.2";
-       sha256 = "1xmyhsqpz4rvm2i8f8xgd1wpj8qlps0lvbif1li73lzg13jiwps2";
+       sha256 = "425f1ee508efd371220d2eae4d81be1423797968af2387a2a83b937fb186bef6";
        libraryHaskellDepends = [
          array base comonad containers free hashable semigroupoids
          semigroups transformers unordered-containers
@@ -82460,7 +82771,7 @@ self: {
      mkDerivation {
        pname = "keystore";
        version = "0.7.0.1";
-       sha256 = "0hswqspbb0lmr33bz1d5f12fhs66i2ynynxii6qwcsrzjn77ps8j";
+       sha256 = "12e97b8e953f6bc6b189b15b6fbd88c668e84470a585bfc6c89582b5aec65c43";
        isLibrary = true;
        isExecutable = true;
        libraryHaskellDepends = [
@@ -82488,7 +82799,7 @@ self: {
      mkDerivation {
        pname = "keyvaluehash";
        version = "0.3.1.2";
-       sha256 = "1gph4cfx1xqjzhzx6nl2sfgqa6mk6a272a65gk5j43yjfh4s17gl";
+       sha256 = "f49da00974d20f22cb7cc528718432b31a859fd3825ad33ffc12f7d01d23f0be";
        libraryHaskellDepends = [
          array base binary bytestring derive directory filepath hashable
          mmap storable-record
@@ -82504,7 +82815,7 @@ self: {
      mkDerivation {
        pname = "keyword-args";
        version = "0.2.0.2";
-       sha256 = "18cj2l804d77mxzmdl2mai1a157yljskadqdlinmc9w9krhcx4jx";
+       sha256 = "5d92ce609e8927566da40d3735b5a4fe94a0425455d0567fafe73402101592a1";
        isLibrary = true;
        isExecutable = true;
        libraryHaskellDepends = [ base containers parsec ];
@@ -82524,7 +82835,7 @@ self: {
      mkDerivation {
        pname = "kibro";
        version = "0.5.0";
-       sha256 = "0yfyx4jyz0n3p2w6pca3nxc72s01240n3siy5sx883ldz706adls";
+       sha256 = "9a3665c0f98d0e84ba2e3eea61011101687158b743b16bb8b8c382ef25e9de79";
        description = "None";
        license = stdenv.lib.licenses.bsd3;
        hydraPlatforms = stdenv.lib.platforms.none;
@@ -82538,7 +82849,7 @@ self: {
      mkDerivation {
        pname = "kicad-data";
        version = "0.1.0.0";
-       sha256 = "02bgz21jw76kzn57z2a7njbwz366j5hpjimyn7dw05h3c64gf8h1";
+       sha256 = "0122f788610316c0dbb1be46796191c68ccf97b447897f8afdd31c2e83f86f09";
        libraryHaskellDepends = [
          base ieee754 lens-family parsec parsec-numbers pretty-compact
        ];
@@ -82560,7 +82871,7 @@ self: {
      mkDerivation {
        pname = "kickass-torrents-dump-parser";
        version = "0.0.1";
-       sha256 = "1bqv07v5sx0jaalnzyk703g08js6sb2snvpsk6ld5zr6iqm7k4wk";
+       sha256 = "9393792a8e26ffd2a899fa6eabc5d2464b04de0067fa6fa95212745df6011baf";
        libraryHaskellDepends = [ base bytestring cassava text vector ];
        testHaskellDepends = [
          base bytestring cassava hspec hspec-expectations string-qq text
@@ -82580,7 +82891,7 @@ self: {
      mkDerivation {
        pname = "kickchan";
        version = "0.1.0.4";
-       sha256 = "1gmp8d2gm275mc379rhyhyfk7r2z8d1mhaz0nikbg4wpczhqf0n7";
+       sha256 = "c70287e1679793b766b4e02b5843435fe4339d871ee67406abe588fa4443b7be";
        libraryHaskellDepends = [ base containers primitive vector ];
        testHaskellDepends = [
          base containers HUnit primitive QuickCheck test-framework
@@ -82598,7 +82909,7 @@ self: {
      mkDerivation {
        pname = "kif-parser";
        version = "0.0.3";
-       sha256 = "1d8abd4l8mcgcfqmm06zmd7yxvfls1kqkphx64bi6mmqzy8lcx3k";
+       sha256 = "73744691ffb8561317311dde8967d0d4edee4fabdf805ab1638f5544495b0ab5";
        isLibrary = false;
        isExecutable = true;
        executableHaskellDepends = [
@@ -82614,7 +82925,7 @@ self: {
      mkDerivation {
        pname = "kinds";
        version = "0.0.1.5";
-       sha256 = "169f2b0nn7mkjws6c5sb3mih2p6snhfq42bkfds3zxz01y53v2g5";
+       sha256 = "e5893d8a0fe0f73f74737309821db4da5c01631d4b17663497b31e6bc1122e99";
        libraryHaskellDepends = [ base ];
        homepage = "http://darcs.wolfgang.jeltsch.info/haskell/kinds";
        description = "Emulation of subkinds and subkind polymorphism";
@@ -82629,7 +82940,7 @@ self: {
      mkDerivation {
        pname = "kit";
        version = "0.7.12";
-       sha256 = "0557v1js7bzd9a00lq078csr66pdrr4kr9qiign2zwz03rrcaviw";
+       sha256 = "3c6ec5721ee0f32fec8b11a73c49ceed1a93354307600a804aedafa365d8a714";
        isLibrary = false;
        isExecutable = true;
        executableHaskellDepends = [
@@ -82648,7 +82959,7 @@ self: {
      mkDerivation {
        pname = "kmeans";
        version = "0.1.3";
-       sha256 = "02rc3bd2cp1fp0fxbzqiy34s5gn38j8hgviilz1584z05jhj97ix";
+       sha256 = "3d9e24a12ce01354c2a731ee079144c3bea2c9f011ffd51db82e5c26da1a2c0b";
        libraryHaskellDepends = [ base ];
        description = "K-means clustering algorithm";
        license = stdenv.lib.licenses.bsd3;
@@ -82661,7 +82972,7 @@ self: {
      mkDerivation {
        pname = "kmeans-par";
        version = "1.5.1";
-       sha256 = "087z1r9fljvysgl940qpnrf7any80fy33shmn8hbmn2kwgczn69c";
+       sha256 = "2c19fbd9e353d8ba20b215ea31bc03c85b755cb6170392e8d37e4bea520eff20";
        libraryHaskellDepends = [ base metric parallel semigroups vector ];
        testHaskellDepends = [
          base hspec metric normaldistribution parallel QuickCheck semigroups
@@ -82677,7 +82988,7 @@ self: {
      mkDerivation {
        pname = "kmeans-vector";
        version = "0.3.2";
-       sha256 = "1ckw3dmwwqzgbl0wcd6h435afjddqmim3y19p2wqcghxd2rk8bdv";
+       sha256 = "bb2d34b3681d3e86b9b829f85163c5ad49a7ca20d034c6015def63ce6b1b7cb2";
        isLibrary = true;
        isExecutable = true;
        libraryHaskellDepends = [ base mtl vector ];
@@ -82692,7 +83003,7 @@ self: {
      mkDerivation {
        pname = "knob";
        version = "0.1.1";
-       sha256 = "05qj7s04p5pbasivyxc06l0jbii250zjnvb3l1y2sfhglb7q8b4c";
+       sha256 = "8c2c84cfa20f3a2d7ca0636d2b3f2822c62501358075bfa356eb964b803e1217";
        libraryHaskellDepends = [ base bytestring transformers ];
        homepage = "https://john-millikin.com/software/knob/";
        description = "Memory-backed handles";
@@ -82706,7 +83017,7 @@ self: {
      mkDerivation {
        pname = "knots";
        version = "0.1.0.1";
-       sha256 = "1yv26gnf8aipjh6d6apszbx4jwvfa7cafnjz0frw73xagnd1z084";
+       sha256 = "04811f9a7daa8fc3b3035f5aa7d8516e7349fafafa2ad30c94372ae4ec3362fb";
        isLibrary = true;
        isExecutable = true;
        libraryHaskellDepends = [
@@ -82723,7 +83034,7 @@ self: {
      mkDerivation {
        pname = "koellner-phonetic";
        version = "0.0";
-       sha256 = "0r7gbgvs49y1nyq5z5f2sb4sjfr847l1vrbih2f5975i3hd9c9kg";
+       sha256 = "6f26961a1cb19c549c8071e51de821283ba9c9d2c2955fb0b7c127a2f75bef64";
        libraryHaskellDepends = [ base HUnit ];
        testHaskellDepends = [ base HUnit ];
        description = "\"map German words to code representing pronunciation\"";
@@ -82740,7 +83051,7 @@ self: {
      mkDerivation {
        pname = "kontrakcja-templates";
        version = "0.1";
-       sha256 = "020vcd04dxaxcd3bb9vwgw1qvxnz5gx590mjkbnnxrcjhl9yd9j8";
+       sha256 = "48a6e6138592e56eed9ab28254fa2bdff68d037f7ca7b546635df54640631b08";
        libraryHaskellDepends = [
          base bytestring containers directory HStringTemplate html MissingH
          mtl old-time parsec transformers utf8-string
@@ -82763,7 +83074,7 @@ self: {
      mkDerivation {
        pname = "koofr-client";
        version = "1.0.0.3";
-       sha256 = "1bz7akd7sssn1gzqfvr0y343771zk7dn1n3as0m93wg4ifpz1dia";
+       sha256 = "2ab6f0af8be4f1912ad06ad860db993f9c33c8f0206f87ff0b566b7dda54e7af";
        libraryHaskellDepends = [
          aeson base bytestring filepath http-client http-client-tls
          http-types mtl
@@ -82778,7 +83089,7 @@ self: {
      mkDerivation {
        pname = "korfu";
        version = "0.2";
-       sha256 = "1mwndf83yl57bawc6vk8983qca3yhcdiczj6q7n1rgv8qphnw0wz";
+       sha256 = "9f036ee1c568bf1cecc1467e161b837e2886074a686ec3b85aa7503f906b96d7";
        isLibrary = false;
        isExecutable = true;
        executableHaskellDepends = [
@@ -82796,7 +83107,7 @@ self: {
      mkDerivation {
        pname = "kqueue";
        version = "0.1.2.6";
-       sha256 = "1q25ahsxsxrj8l99skymzssklj11d5prsa09b23dmbgc4qw28lg8";
+       sha256 = "e851243826ecadda865809289d6f6921483ab5fed54f9d12453277dd355445e0";
        libraryHaskellDepends = [ base directory filepath mtl time unix ];
        libraryToolDepends = [ c2hs ];
        jailbreak = true;
@@ -82813,7 +83124,7 @@ self: {
      mkDerivation {
        pname = "kraken";
        version = "0.0.1";
-       sha256 = "1df6g65wrhzfz3kj9n4bcja09adr4qhl3kzv5vaxl37lbr9nwzr2";
+       sha256 = "227f6e535ef40cdad52efbcf412126b9a90494648bd824e7f8eec3cc8b79c6b5";
        libraryHaskellDepends = [
          aeson base bytestring http-client http-client-tls mtl
        ];
@@ -82830,7 +83141,7 @@ self: {
      mkDerivation {
        pname = "krpc";
        version = "0.6.1.0";
-       sha256 = "0ldhg4ahhfp4jy3ijssfmcwfg68dggw3biqmc4my2qrcgd2mvx29";
+       sha256 = "49f45d457b2c63e12b6115c735f87b0d99e738ab4e6b198797e43a081579b051";
        libraryHaskellDepends = [
          base bencoding bytestring containers data-default-class lifted-base
          monad-control monad-logger mtl network text transformers
@@ -82849,7 +83160,7 @@ self: {
      mkDerivation {
        pname = "ks-test";
        version = "0.1";
-       sha256 = "1xj9bnwiws3rnax3rlf67p8dh487w07xl99h81a9j1wjkqysldym";
+       sha256 = "d537aa3d9e92079954403025da0fe00711d8d03dc6d13cbab279681eb95d49f6";
        libraryHaskellDepends = [ base gamma random-fu roots vector ];
        description = "Kolmogorov distribution and Kolmogorov-Smirnov test";
        license = stdenv.lib.licenses.publicDomain;
@@ -82860,7 +83171,7 @@ self: {
      mkDerivation {
        pname = "ktx";
        version = "0.2";
-       sha256 = "1s7jw27p96spksja6ks2xdnhyds8diwc5y7h22bj6cq5kglskvxf";
+       sha256 = "aeefa9e99b0533239710f0f8c2786c48370f6deb424fa3a49e579b748fe0f2e8";
        libraryHaskellDepends = [ base bytestring OpenGL ];
        libraryPkgconfigDepends = [ egl glew ];
        homepage = "https://github.com/corngood/ktx";
@@ -82873,7 +83184,7 @@ self: {
      mkDerivation {
        pname = "kure";
        version = "2.16.10";
-       sha256 = "0xfnrp39w2ip9744898mfd63sbya8an72fx3nwj1s3vzdb1h3lhm";
+       sha256 = "15d201c36a7f0f1d24b7a33b71ac42ca2f3d4c73152544c849370a9ec6cdd675";
        libraryHaskellDepends = [ base dlist transformers ];
        homepage = "http://www.ittc.ku.edu/csdl/fpg/software/kure.html";
        description = "Combinators for Strategic Programming";
@@ -82885,7 +83196,7 @@ self: {
      mkDerivation {
        pname = "kure-your-boilerplate";
        version = "0.1.3";
-       sha256 = "0bfcmx1fz521vkc2lrbpyvaqcy4c29h5xp6wmyxvgrjjnq32ld1b";
+       sha256 = "2b342a06b652e6b7bbafdcdc5e60128c7886d5f677652ad8dc4194ef42afcc2d";
        libraryHaskellDepends = [ base kure template-haskell ];
        jailbreak = true;
        homepage = "http://ittc.ku.edu/~andygill/kure.php";
@@ -82899,7 +83210,7 @@ self: {
      mkDerivation {
        pname = "kyotocabinet";
        version = "0.1.3";
-       sha256 = "1wzwmfmh2cx3c9blnhk7ibsimwsnnxz9jpcdfdkgy5rb28wvvkyz";
+       sha256 = "dfcfbd39122b17ff66738d5d997eb756f31af58a67424b5762a33301ababfcf3";
        libraryHaskellDepends = [ base bytestring cereal ];
        librarySystemDepends = [ kyotocabinet ];
        description = "Mid level bindings to Kyoto Cabinet";
@@ -82911,7 +83222,7 @@ self: {
      mkDerivation {
        pname = "l-bfgs-b";
        version = "0.1.0.1";
-       sha256 = "0ypzkq2rpbmdjfqba72pl3wf6d4wz0z5vmy84dq5m38ij5mlb4y7";
+       sha256 = "c793456b91118d5a7023c8d75d3ef89c34e3f8a0571cb5b093adae9b059eff7a";
        libraryHaskellDepends = [ base vector ];
        librarySystemDepends = [ lbfgsb ];
        homepage = "http://nonempty.org/software/haskell-l-bfgs-b";
@@ -82925,7 +83236,7 @@ self: {
      mkDerivation {
        pname = "labeled-graph";
        version = "1.0.0.0";
-       sha256 = "060nvnlh1h8vxi6k2hsz79fn4xypangdj5v4q0kc6abyf9garf7r";
+       sha256 = "f9b8ac5e727e29c326c06417d99e55d777625d3a5f43314dec1bc100a9dd1618";
        libraryHaskellDepends = [ base labeled-tree ];
        description = "Labeled graph structure";
        license = stdenv.lib.licenses.bsd3;
@@ -82937,7 +83248,7 @@ self: {
      mkDerivation {
        pname = "labeled-tree";
        version = "1.0.0.0";
-       sha256 = "1cnnyic5z5y21hpxpmx66ph34mjyysckgiasmzg7yx202y2ih7s7";
+       sha256 = "471f18851740747fdeaf5ac53799f65e5632e035a6d7db2f0cc2975f58f4d6b2";
        libraryHaskellDepends = [ base ];
        description = "Labeled tree structure";
        license = stdenv.lib.licenses.bsd3;
@@ -82951,7 +83262,7 @@ self: {
      mkDerivation {
        pname = "laborantin-hs";
        version = "0.1.5.2";
-       sha256 = "18bgd9v4bh3wfh7p7xjzrsj130cppm6x55vzagcpn10cwqag41cs";
+       sha256 = "9a05f214e60c047bd9537f97d24dbd978111a4ce5ff6730f747cc045766a6fa1";
        isLibrary = true;
        isExecutable = true;
        libraryHaskellDepends = [
@@ -82976,7 +83287,7 @@ self: {
      mkDerivation {
        pname = "labyrinth";
        version = "0.5.0.0";
-       sha256 = "1yi53vg248j8ww08z2a5v3agci84q3m2d37h9mdbprciryh3hfcl";
+       sha256 = "943938a0cf91e5bb5a4df08c26eac00445f6d4d845898f00e7482222de1e25fa";
        libraryHaskellDepends = [
          base containers derive lens monad-loops MonadRandom mtl parsec
          random safecopy template-haskell transformers
@@ -83003,7 +83314,7 @@ self: {
      mkDerivation {
        pname = "labyrinth-server";
        version = "0.1.4.1";
-       sha256 = "00mx8zmwqawp2hh1a0v4r26w7wsji0iz7jwsh83742wimir316aw";
+       sha256 = "5c993072ac910b7206829acbf3238852f3c38dc86403152014972bcceb47bd02";
        isLibrary = false;
        isExecutable = true;
        executableHaskellDepends = [
@@ -83036,7 +83347,7 @@ self: {
      mkDerivation {
        pname = "lagrangian";
        version = "0.6.0.1";
-       sha256 = "07jlmfynnq42syim9k7hks6zmkzq2i62slvwwik8w2rg07ran72v";
+       sha256 = "5b1cabf2012f0b8e66e47c532d4c14f8cffa8d9ef0cc54a3d782606bbdab541e";
        libraryHaskellDepends = [
          ad base hmatrix nonlinear-optimization vector
        ];
@@ -83057,7 +83368,7 @@ self: {
      mkDerivation {
        pname = "laika";
        version = "0.1.3.1";
-       sha256 = "0brysrzz0cci6hqm5ldl7fk5zqhcjp7naifabks1zk3mzg8kr1x1";
+       sha256 = "a1873cd1fb75cc1ff45cca4565cf950ce25fa63bb4d15231349131f07fd63e2f";
        isLibrary = true;
        isExecutable = true;
        libraryHaskellDepends = [
@@ -83076,7 +83387,7 @@ self: {
      mkDerivation {
        pname = "lambda-ast";
        version = "0.0.12";
-       sha256 = "07i0fw7hvkzky9rwrnh4b3i35crbv4mkj0w001dwkgsh1flzh95f";
+       sha256 = "ae24f8a90b50bfc95b008003392bd92bb332e25804dacc73f2f3cf0d0f77201e";
        libraryHaskellDepends = [ base ];
        description = "Lambda Calculi Abstract Syntax Trees";
        license = stdenv.lib.licenses.bsd3;
@@ -83087,7 +83398,7 @@ self: {
      mkDerivation {
        pname = "lambda-bridge";
        version = "0.1";
-       sha256 = "0qiqw4av62fdf2b1qc64lvj84lkzcfpik7lvq81qk015pz58cbs3";
+       sha256 = "432f86cabf25808903c29b9e19af637f5282e4a6c4301c9670cd09b315e13862";
        isLibrary = true;
        isExecutable = true;
        libraryHaskellDepends = [ base ];
@@ -83103,7 +83414,7 @@ self: {
      mkDerivation {
        pname = "lambda-canvas";
        version = "0.1";
-       sha256 = "14wl1w1sc0j1yjfad5v00346ccxp0grfs1677hnjqwisashdac92";
+       sha256 = "2231d5a0563a722c2d3cc704edf203b73366c8006097a69cf44102a6030f9493";
        libraryHaskellDepends = [ base GLUT mtl OpenGL time ];
        jailbreak = true;
        description = "Educational drawing canvas for FP explorers";
@@ -83118,7 +83429,7 @@ self: {
      mkDerivation {
        pname = "lambda-devs";
        version = "0.4.0";
-       sha256 = "1j2j6clm35ffvdjlh7apydir06g7az40gsqvlcw8p4qbdk2z2vrh";
+       sha256 = "306ff1c56c0b938b38a31beb07c857e7199063f3571d4865dbce9551293352c8";
        isLibrary = true;
        isExecutable = true;
        libraryHaskellDepends = [
@@ -83143,7 +83454,7 @@ self: {
      mkDerivation {
        pname = "lambda-options";
        version = "0.8.0.0";
-       sha256 = "1z9gmps06w458v8i3zpkalby83p367r3z9i0c312jxl0zp51q891";
+       sha256 = "21211ccafd807629c26020a63ff231e30ee41755f3fe11d146857003f4ad2ffd";
        libraryHaskellDepends = [ base containers mtl read-bounded ];
        jailbreak = true;
        homepage = "https://github.com/thomaseding/lambda-options";
@@ -83156,7 +83467,7 @@ self: {
      mkDerivation {
        pname = "lambda-placeholders";
        version = "0.0.0.0";
-       sha256 = "0s3y55yqa5js1q3rfq8dgdip6rnjag4w5j5vdldghq9ax5yph3gd";
+       sha256 = "ed0d787de92a61f81a6dbbc8c2c953d26673637b0d6197070e5a16857d297e68";
        libraryHaskellDepends = [ base ];
        homepage = "https://github.com/mmirman/lambda-placeholders";
        description = "A library to emulate laceholders similar to Scala";
@@ -83168,7 +83479,7 @@ self: {
      mkDerivation {
        pname = "lambda-toolbox";
        version = "1.0.1";
-       sha256 = "1m11gdwq4nma3231043h5szplmask5152y2r9ayyrpacczddcbim";
+       sha256 = "352ed6da674cddecbd4a59785142995a557abf2e7010108618aa5a82797b21d4";
        isLibrary = false;
        isExecutable = true;
        executableHaskellDepends = [ base ];
@@ -83183,7 +83494,7 @@ self: {
      mkDerivation {
        pname = "lambda2js";
        version = "0.1";
-       sha256 = "0490yswk7zsyc2lskyqkwa98xsaj5a2cgw4pyxbg5920lyjqb3n8";
+       sha256 = "c88e85a5a740a4f256f797f0c7842a52e98e92e213fba9a9605eff33b9f62011";
        isLibrary = false;
        isExecutable = true;
        executableHaskellDepends = [ haskell2010 parsec ];
@@ -83198,7 +83509,7 @@ self: {
      mkDerivation {
        pname = "lambdaBase";
        version = "0.0.2.0";
-       sha256 = "19c2bxipilb2lag7qzk4ajlzqch574dbhqk9cna13ijsjiyq24nd";
+       sha256 = "cd12817d945ac61194656962b81a390532fca954647e7c9ea262d178635f82a5";
        libraryHaskellDepends = [ base parsec ];
        testHaskellDepends = [ base parsec ];
        license = stdenv.lib.licenses.mit;
@@ -83210,7 +83521,7 @@ self: {
      mkDerivation {
        pname = "lambdaFeed";
        version = "0.3.1";
-       sha256 = "0gji0jix99qbldqkclymnwf5pnmiszy0qka9m2wq8kyi09f3y4h8";
+       sha256 = "08123f5c02d14f84b9a8494d0cfcd7b1da5b1cb7d5533671a30ba7d4a304513e";
        isLibrary = false;
        isExecutable = true;
        executableHaskellDepends = [ base haskell98 html ];
@@ -83227,7 +83538,7 @@ self: {
      mkDerivation {
        pname = "lambdaLit";
        version = "0.1.1.0";
-       sha256 = "1xw1496q84wrzy1r3dwvwy04sb3184namnmdj5kspc5pmd8ipx0h";
+       sha256 = "10f41b51abb7b0ab6791addaaa2c41612c4d80e79bb79183ff9913844d2281f7";
        isLibrary = false;
        isExecutable = true;
        executableHaskellDepends = [
@@ -83247,7 +83558,7 @@ self: {
      mkDerivation {
        pname = "lambdabot";
        version = "5.0.3";
-       sha256 = "1kbrmxz5604jzcx9l6j4lmbb0xqz2cmj0f30nmpzdkmzsqv1hfj2";
+       sha256 = "423a1836d6bfcef66fb56038202b131f77b056a5441a9a3afb9200537eaf79cd";
        isLibrary = false;
        isExecutable = true;
        executableHaskellDepends = [
@@ -83271,7 +83582,7 @@ self: {
      mkDerivation {
        pname = "lambdabot-core";
        version = "5.0.3";
-       sha256 = "12gawsimdqch61rh4zwvzrx6pqx8yd645wqpki8dr56wnmbhbr03";
+       sha256 = "03e40557b5dc94dc509c17f3424cf3a8e36b7afe9b7f02733090e156a3e6ea89";
        libraryHaskellDepends = [
          base binary bytestring containers dependent-map dependent-sum
          dependent-sum-template directory edit-distance filepath haskeline
@@ -83297,7 +83608,7 @@ self: {
      mkDerivation {
        pname = "lambdabot-haskell-plugins";
        version = "5.0.3";
-       sha256 = "0iya4zipjjaqrld0a1v334praw1vnw186scfsi6inqdg314jc7x1";
+       sha256 = "a11f264918af611b4dd48e698302b73b70952f196307051acd584979e327ca47";
        libraryHaskellDepends = [
          array arrows base bytestring containers data-memocombinators
          directory filepath haskell-src-exts hoogle HTTP IOSpec
@@ -83319,7 +83630,7 @@ self: {
      mkDerivation {
        pname = "lambdabot-irc-plugins";
        version = "5.0.3";
-       sha256 = "1v4zh2yjdgy9ix6dmxdh8j5iqyrixaln78c5jgpiyjcwgi17blrw";
+       sha256 = "3cd375427c9c491fef9385a163a9ea317b1c8b44b0f5da4c8fc9bf26bd809fec";
        libraryHaskellDepends = [
          base bytestring containers directory filepath lambdabot-core
          lifted-base mtl network SafeSemaphore split time
@@ -83339,7 +83650,7 @@ self: {
      mkDerivation {
        pname = "lambdabot-misc-plugins";
        version = "5.0.1";
-       sha256 = "08dhwls7lgwrpyqzjxpg95cn80mqf3izrwnzbmygkp3my8xqxakp";
+       sha256 = "77aa8e3bf275dcf97c5ddff2fce370b802645949ef76f9b1bf993f7a34e5b021";
        libraryHaskellDepends = [
          base bytestring containers filepath hstatsd lambdabot-core
          lifted-base mtl network network-uri parsec process random random-fu
@@ -83360,7 +83671,7 @@ self: {
      mkDerivation {
        pname = "lambdabot-novelty-plugins";
        version = "5.0.3";
-       sha256 = "086y8p92a8g2zjjkxj1ny4s1dlza2dz1v64g3jg7p0dz1n1s1jpy";
+       sha256 = "fecaa0830dbf817b9e1c8f981d7e13ead31634f136c83ea5fce22125d245de20";
        libraryHaskellDepends = [
          base binary brainfuck bytestring containers dice directory
          lambdabot-core misfortune process random-fu regex-tdfa unlambda
@@ -83378,7 +83689,7 @@ self: {
      mkDerivation {
        pname = "lambdabot-reference-plugins";
        version = "5.0.3";
-       sha256 = "1yw1l0jl4iym2q2lfgzcmxm8865av37kf7zji0f7in2phqs3r1zz";
+       sha256 = "ff873c348657d8781c88f21f37cfd8aa18846aafec3f470516d5474225a081fb";
        libraryHaskellDepends = [
          base bytestring containers HTTP lambdabot-core mtl network
          network-uri oeis process regex-tdfa split tagsoup utf8-string
@@ -83395,7 +83706,7 @@ self: {
      mkDerivation {
        pname = "lambdabot-social-plugins";
        version = "5.0.1";
-       sha256 = "0ylp40j54whn4fsgxi0843mvs0gx286c5fm127ja1h7j6c74svkc";
+       sha256 = "6c6e4d0e33f2c0a0e411a1bac20c12fd01bdeb2008c4feb4231672522420977a";
        libraryHaskellDepends = [
          base binary bytestring containers lambdabot-core mtl split time
        ];
@@ -83409,7 +83720,7 @@ self: {
      mkDerivation {
        pname = "lambdabot-trusted";
        version = "5.0.2.1";
-       sha256 = "078yhq9d0vxgnc01hfa25kf4kdg4mymg9678jqmyk8csjy5gjw0h";
+       sha256 = "1070f98a979aa1e92b96e898f4aaafe4b549dc2c42391800b3af6fd012861e1d";
        libraryHaskellDepends = [ base oeis QuickCheck QuickCheck-safe ];
        homepage = "http://haskell.org/haskellwiki/Lambdabot";
        description = "Lambdabot trusted code";
@@ -83424,7 +83735,7 @@ self: {
      mkDerivation {
        pname = "lambdabot-utils";
        version = "4.2.2";
-       sha256 = "0mmz9rn6vv8xnavmz66g164h1liir3rzg1n7lmbcsgwcyhm925d7";
+       sha256 = "a715912af48c3fcd56a5c786f7f3c831d2008909cf985fb7b21ded6d6c4ebf56";
        revision = "3";
        editedCabalFile = "f54d43d6964d63f1d8796606419b512a6e7b87b1defe960748c27c7417f59a08";
        libraryHaskellDepends = [
@@ -83446,7 +83757,7 @@ self: {
      mkDerivation {
        pname = "lambdacat";
        version = "0.1.1";
-       sha256 = "18m7z0lmi26ib1n1wrql96wb5i229k8fk3iw4vavs9j59b4pz1br";
+       sha256 = "79857fc94a4526bdd5263c8ee9d04c42c4b2b84914671e6c58d1885829f8a7a2";
        isLibrary = true;
        isExecutable = true;
        libraryHaskellDepends = [
@@ -83469,7 +83780,7 @@ self: {
      mkDerivation {
        pname = "lambdacms-core";
        version = "0.3.0.2";
-       sha256 = "0m8piymzcciy4dqhxqxslpm1rbzasm1diasr8ab05r9lcrs1dn76";
+       sha256 = "e6d816746634e502964259abd842d5eaaf1ceaa5bae30e71233e32f6ab8f1755";
        libraryHaskellDepends = [
          base blaze-html bytestring containers data-default esqueleto
          file-embed friendly-time gravatar lists mime-mail old-locale
@@ -83491,7 +83802,7 @@ self: {
      mkDerivation {
        pname = "lambdacms-media";
        version = "0.4.0.0";
-       sha256 = "0vq32qppnasc24jrjh6c19hr2pxby65c5m5k90fk7afyms307b5c";
+       sha256 = "acac0386aedea9331d48b3d4c28af1ab5f91610acc409925114c2b7b2f16036f";
        libraryHaskellDepends = [
          base directory filepath lambdacms-core persistent shakespeare text
          time yesod yesod-form
@@ -83506,7 +83817,7 @@ self: {
      mkDerivation {
        pname = "lambdacube";
        version = "2008.12.25";
-       sha256 = "1qwwcbs7slddpjlz3dlyjr32xk66clcbxbnb6j1d5v5dz9mvjh3b";
+       sha256 = "6b40b96bfaadecd28234cbaebe1865c6cc2e46969eb6f1a9bcad517df4629ce3";
        isLibrary = false;
        isExecutable = true;
        executableHaskellDepends = [ base editline mtl pretty ];
@@ -83520,7 +83831,7 @@ self: {
      mkDerivation {
        pname = "lambdacube-bullet";
        version = "0.2.1";
-       sha256 = "1wnv8vgp100fdnx4g80d3gshbba9jni7rbjhhj8rx1mi0wcc1bcv";
+       sha256 = "9badc01807b1869e918450ae7ca29549ad05f51b0da047ba6d0e8070df46dbf2";
        libraryHaskellDepends = [
          base bullet lambdacube-engine mtl vector
        ];
@@ -83537,7 +83848,7 @@ self: {
      mkDerivation {
        pname = "lambdacube-core";
        version = "0.2.0";
-       sha256 = "001nw31h61dawh036yk4w9b35aha6c6xdmsl4vdipnr3kwykgk9l";
+       sha256 = "34cd373d9f23db1bdb2654d7d60d330aaa3256e2647a3300e4aa0503c3e03600";
        libraryHaskellDepends = [
          base bytestring bytestring-trie containers mtl vector
        ];
@@ -83553,7 +83864,7 @@ self: {
      mkDerivation {
        pname = "lambdacube-edsl";
        version = "0.2.0";
-       sha256 = "18lbkshc9wh7scb2bbvl565w6yryz7n1iy14r81cahnj7m68fj8m";
+       sha256 = "1549874c3dd242c502ca24f818ecf93e7bc38b2974af2516d307f2c4a09e8ba2";
        libraryHaskellDepends = [
          base bytestring bytestring-trie containers ghc-prim lambdacube-core
          mtl vector
@@ -83572,7 +83883,7 @@ self: {
      mkDerivation {
        pname = "lambdacube-engine";
        version = "0.2.4";
-       sha256 = "1xdp10nylndmfw16dywqrxj30g99rf9qbcx5qiglvzm1c1kxid3f";
+       sha256 = "6eb4d86760a1fe4d5fc4a5b38593cb293d3064cf98fb660277b559ea2d08b7f5";
        libraryHaskellDepends = [
          array base binary bitmap bytestring bytestring-trie containers
          directory filepath mtl OpenGLRaw stb-image uulib vect vector
@@ -83589,7 +83900,7 @@ self: {
      mkDerivation {
        pname = "lambdacube-examples";
        version = "0.2.2";
-       sha256 = "14l40ncbkblphmyn4prqiy2w70agcw830bpyawfdilf93bs340b9";
+       sha256 = "690132f41ac9d1d81c57fe2e3010674f81c3858f385f627d8597aeb998058492";
        isLibrary = false;
        isExecutable = true;
        executableHaskellDepends = [
@@ -83609,7 +83920,7 @@ self: {
      mkDerivation {
        pname = "lambdacube-gl";
        version = "0.2.0";
-       sha256 = "1r26gvpyfvk87wx1fpp6y5687q5y7pxzmjvm55r96m976200lz50";
+       sha256 = "a07c0a8030275593722975cbfafb3dbee0834cf1e65e173a3f686ee7ef7e46e4";
        libraryHaskellDepends = [
          base binary bitmap bytestring bytestring-trie containers
          lambdacube-core lambdacube-edsl language-glsl mtl OpenGLRaw
@@ -83629,7 +83940,7 @@ self: {
      mkDerivation {
        pname = "lambdacube-samples";
        version = "0.2.0";
-       sha256 = "0zl9d524a81vg3h7f9cbfi34b0hw452bd30xmgvg9ayfwxa842d1";
+       sha256 = "a1098254e7ceabf4f6ab1d8cb644211c824546748b2577e0783b20454469897e";
        isLibrary = false;
        isExecutable = true;
        executableHaskellDepends = [
@@ -83655,7 +83966,7 @@ self: {
      mkDerivation {
        pname = "lambdatwit";
        version = "0.1.0.0";
-       sha256 = "01mqmhnq70k3yg29z492x7d6mzpwlijdrrgf0zbz8c8mlgnm4ljx";
+       sha256 = "5d5252eda31531f4d707eee5dc64a4fcfe6adae922919fc4f36382832dacb806";
        isLibrary = false;
        isExecutable = true;
        executableHaskellDepends = [
@@ -83679,7 +83990,7 @@ self: {
      mkDerivation {
        pname = "lambdiff";
        version = "0.1";
-       sha256 = "0xlvz4r09vn1vdvs5wykry626hwcsg2zvdvl6jf6zrsq9331zcwy";
+       sha256 = "9eb31fc64858e76f9c3474b7fdc5d38c43238ccfd3f3a277dbc1ee0432f99b76";
        isLibrary = false;
        isExecutable = true;
        executableHaskellDepends = [
@@ -83699,7 +84010,7 @@ self: {
      mkDerivation {
        pname = "lame-tester";
        version = "1.2";
-       sha256 = "1wa7h48a7hfb748i4chl2lpizrqmsdydg9vbwjf8gmy5cwlh816y";
+       sha256 = "de04042967c5d7879ce46ba7d77cd315e71f2f151432121139cbc1a3108147f1";
        libraryHaskellDepends = [
          base bifunctors containers semigroups validation
        ];
@@ -83715,7 +84026,7 @@ self: {
      mkDerivation {
        pname = "language-asn1";
        version = "0.5";
-       sha256 = "14aiqk1l1d3bh7dcml4a85xg81583h3r30h5splw0lvcxmbggzp3";
+       sha256 = "e3fef756ed6c53c0e9d5058291071ca804f47a418ad0cada816bb440c3c45191";
        isLibrary = true;
        isExecutable = true;
        libraryHaskellDepends = [ base parsec syb ];
@@ -83729,7 +84040,7 @@ self: {
      mkDerivation {
        pname = "language-bash";
        version = "0.6.0";
-       sha256 = "07hb9hg4grmf01zlvfm583q9km4dxfgm4pkb9glihl3v7iqz21vs";
+       sha256 = "7a07f1713c7b5018e94b6b5e529feb8dd499f040a5ba4d7f00aee6471e4c0b1e";
        libraryHaskellDepends = [ base parsec pretty transformers ];
        jailbreak = true;
        homepage = "http://github.com/knrafto/language-bash/";
@@ -83746,7 +84057,7 @@ self: {
      mkDerivation {
        pname = "language-boogie";
        version = "0.2";
-       sha256 = "166n9x3gil42w26r7p9d1jq6iy0yi9zacijkfmxj2gkkswyyb91x";
+       sha256 = "3da4e53dd7733e217b755346a67e8a1ef868b00c2ddd938de082d0f8464fd698";
        isLibrary = true;
        isExecutable = true;
        libraryHaskellDepends = [
@@ -83771,7 +84082,7 @@ self: {
      mkDerivation {
        pname = "language-c";
        version = "0.4.7";
-       sha256 = "1r0jlncv6d6ai8kblrdq9gz8abx57b24y6hfh30xx20zdgccjvaz";
+       sha256 = "5f6dc9d86b1f88dec1800e1a4fc43aa52f85fe4bb865ba268aca34b399a512e4";
        libraryHaskellDepends = [
          array base bytestring containers directory filepath pretty process
          syb
@@ -83787,7 +84098,7 @@ self: {
      mkDerivation {
        pname = "language-c-comments";
        version = "0.3";
-       sha256 = "1rmciff72zpcq7pvbbxlsg2339dbk00k18vxp35sz8haql0jnrf2";
+       sha256 = "c2652b01c50aa2afcbb87da3300198aba531c4d3b4afb5efc1ec7e719c8bace6";
        libraryHaskellDepends = [ array base language-c ];
        libraryToolDepends = [ alex ];
        homepage = "http://github.com/ghulette/language-c-comments";
@@ -83803,7 +84114,7 @@ self: {
      mkDerivation {
        pname = "language-c-inline";
        version = "0.7.9.1";
-       sha256 = "0apxv1mcmglb3m06dchs25sc7bhgz6v4gv098yfb79qmjmsxpc33";
+       sha256 = "63b0db759515a7b39c4709ec47b6f90faec374111ab266401d8bbeca6ad8fd2a";
        libraryHaskellDepends = [
          array base containers filepath language-c-quote mainland-pretty
          template-haskell
@@ -83825,7 +84136,7 @@ self: {
      mkDerivation {
        pname = "language-c-quote";
        version = "0.11";
-       sha256 = "1v55pmzrsd7nvxdkik0fh5psbycx9cv4j5zwzlv872lzhfsr3lc7";
+       sha256 = "87d191b5839f8a8336fdfc1749364b9df9a56f810ecc385bdff6349d7fbda5ec";
        libraryHaskellDepends = [
          array base bytestring containers exception-mtl
          exception-transformers filepath haskell-src-meta mainland-pretty
@@ -83846,7 +84157,7 @@ self: {
      mkDerivation {
        pname = "language-cil";
        version = "0.2.2";
-       sha256 = "0b3yapn53bwaxia7b59kizzcxh1d3842as1cbkyzd096v8wsgwfa";
+       sha256 = "caf1a739da2681f6fd5c2c6825081a2dc0cefe8f33957554ec8aaf51ec557e2c";
        libraryHaskellDepends = [ base bool-extras ];
        jailbreak = true;
        homepage = "https://github.com/tomlokhorst/language-cil";
@@ -83859,7 +84170,7 @@ self: {
      mkDerivation {
        pname = "language-css";
        version = "0.0.3";
-       sha256 = "1g0mh08rz44533473isrqbfn6hp12np9dxm85cn5xpx68jl9ni9g";
+       sha256 = "2f459ba844a6df5e2c2ba8f696ae15e14263ddc259c771c81885909f118015bc";
        libraryHaskellDepends = [ base pretty ];
        description = "CSS 2.1 syntax";
        license = stdenv.lib.licenses.bsd3;
@@ -83870,7 +84181,7 @@ self: {
      mkDerivation {
        pname = "language-dot";
        version = "0.0.8";
-       sha256 = "0cjjfm7mcsl0x5by7gvbsdrr92x88i8sadb4pz6qh618sgrci7ax";
+       sha256 = "5d9dc8f2d3281888cdbf6435a55144a88b9473d36bbfe357e9806a564f755232";
        isLibrary = true;
        isExecutable = true;
        libraryHaskellDepends = [ base mtl parsec pretty ];
@@ -83887,7 +84198,7 @@ self: {
      mkDerivation {
        pname = "language-ecmascript";
        version = "0.17.0.1";
-       sha256 = "1yawnk6ylx7g9fgx2ib11dgkwkpaz2cy3iph84pxzgqw30yh9q4l";
+       sha256 = "94e0043d181cbfdf2f41f0c6e199f8ea4e3e5f0b6145d19f4bef74eacdb45cf9";
        libraryHaskellDepends = [
          base containers data-default-class Diff mtl parsec QuickCheck
          template-haskell testing-feat uniplate wl-pprint
@@ -83909,7 +84220,7 @@ self: {
      mkDerivation {
        pname = "language-ecmascript-analysis";
        version = "0.9.1";
-       sha256 = "04zc3iwls4hxlsa2c77an5q1h0xylndld02sn38sgykx6ibmmy9n";
+       sha256 = "36f95a57347dfaa7d1b05a80469ba5be031870b1ea1c2694a61d124d791cec13";
        libraryHaskellDepends = [
          base containers language-ecmascript parsec uniplate
        ];
@@ -83926,7 +84237,7 @@ self: {
      mkDerivation {
        pname = "language-eiffel";
        version = "0.1.2";
-       sha256 = "1v3m31ffx4pmgq92ahvlyzsh9hjvrdsmyzhd61qxzgpn3z9zzlcm";
+       sha256 = "95d1ffd31ff6bedf71300d7e5f75cb5bc204f5f7744325127ef592ee5c1875ec";
        libraryHaskellDepends = [
          array base binary bytestring containers deepseq derive ghc-prim
          hashable lens mtl parsec pretty text unordered-containers
@@ -83944,7 +84255,7 @@ self: {
      mkDerivation {
        pname = "language-fortran";
        version = "0.3";
-       sha256 = "0csp0nmiwb2kflahhnnjxa7gmam3k9c4ivvh2wg919x85yp7v40z";
+       sha256 = "1f907dae2fa8a7901e1770ef48589aa3aafa8eead25a081575532c1eab055733";
        libraryHaskellDepends = [ array base haskell-src parsec syb ];
        libraryToolDepends = [ alex happy ];
        description = "Fortran lexer and parser, language support, and extensions";
@@ -83956,7 +84267,7 @@ self: {
      mkDerivation {
        pname = "language-gcl";
        version = "0.2";
-       sha256 = "12yh49zh9wissms20rbvgzw5i5wlc8m1iqwkxg68f52g7mk6clrf";
+       sha256 = "2e5366663d4f1487cceb93e3182a62949758f87f7b652074d53af2047f22d08b";
        libraryHaskellDepends = [ base bifunctors parsers ];
        jailbreak = true;
        description = "Something similar to Dijkstra's guarded command language";
@@ -83970,7 +84281,7 @@ self: {
      mkDerivation {
        pname = "language-glsl";
        version = "0.2.0";
-       sha256 = "1wmfzif1cc3a8sls3swms9x54hm9ic8y301zav6fg4mr7xa4hqr3";
+       sha256 = "236348543fb992e7cc563f80e1118ba942527ad295eba1a9466a30165cfcaef2";
        isLibrary = true;
        isExecutable = true;
        libraryHaskellDepends = [ base parsec prettyclass ];
@@ -83987,7 +84298,7 @@ self: {
      mkDerivation {
        pname = "language-go";
        version = "0.8";
-       sha256 = "1p545115x73q4mzfja50f4lxal97ydvz9r3wq6pvcqls2xgvxzvc";
+       sha256 = "6cffbe5f179a62b6afc17ce4f477f32751d52971a028e97e25789c5e4228a4dc";
        libraryHaskellDepends = [ array base parsec utf8-string ];
        jailbreak = true;
        description = "A library for analysis and synthesis of Go code";
@@ -84000,7 +84311,7 @@ self: {
      mkDerivation {
        pname = "language-guess";
        version = "0.1.2";
-       sha256 = "0gdnkc1hb0mcn494vk9r7fw19hvaba807brwh6fna0sxyh2nx3p0";
+       sha256 = "e08e6e05f45d03659d813caf03905a6ac314b83b39cd4d12b1ac8205039bb63d";
        libraryHaskellDepends = [ base bytestring cereal containers ];
        description = "Guess at which language a text is written in using trigrams";
        license = stdenv.lib.licenses.bsd3;
@@ -84011,7 +84322,7 @@ self: {
      mkDerivation {
        pname = "language-haskell-extract";
        version = "0.2.4";
-       sha256 = "1nxcs7g8a1sp91bzpy4cj6s31k5pvc3gvig04cbrggv5cvjidnhl";
+       sha256 = "14da16e56665bf971723e0c5fd06dbb7cc30b4918cf8fb5748570785ded1acdb";
        libraryHaskellDepends = [ base regex-posix template-haskell ];
        homepage = "http://github.com/finnsson/template-helper";
        description = "Module to automatically extract functions from the local code";
@@ -84026,7 +84337,7 @@ self: {
      mkDerivation {
        pname = "language-java";
        version = "0.2.7";
-       sha256 = "1519grsjw0f4skldxs563qz07mmj1cg72ma0plmvzpas7inkikyf";
+       sha256 = "cecf386d3c5addbf2bbd4055711e0bb2d6033e1ea6e8dee8d4c4012e757e2994";
        libraryHaskellDepends = [ array base cpphs parsec pretty ];
        libraryToolDepends = [ alex ];
        testHaskellDepends = [
@@ -84046,7 +84357,7 @@ self: {
      mkDerivation {
        pname = "language-java-classfile";
        version = "0.2.0";
-       sha256 = "0pzlvzx5rv006mn88b15zvvrhf7h681xpl166368b92dc0x85gcf";
+       sha256 = "8ebd823a604da485cc3026d0db0332f03898f7fe252c846c3500ec5cfadff45f";
        libraryHaskellDepends = [
          array base binary bytestring containers data-binary-ieee754
          data-flags deepseq language-java LibZip mtl parsec utf8-string
@@ -84064,7 +84375,7 @@ self: {
      mkDerivation {
        pname = "language-javascript";
        version = "0.5.14.2";
-       sha256 = "0inm6yncl5dv9ij3fyk38c6mad8fm1vqs70rpqi1a7w2n5cbv1ia";
+       sha256 = "2a86bd58b1821f1522be191c8d77a80e35550d43637a37644cbb15caac37d546";
        libraryHaskellDepends = [
          array base blaze-builder bytestring containers mtl utf8-string
        ];
@@ -84087,7 +84398,7 @@ self: {
      mkDerivation {
        pname = "language-kort";
        version = "0.1.0.0";
-       sha256 = "0dhrzd470hfvkjpizgg9czgyz80nc9sq86r2zcimsch6rxmid0i0";
+       sha256 = "2082166bcf06325d23fb221b84756216a0efdf67e9bd1faf9cdb417048fb1936";
        libraryHaskellDepends = [
          base base64-bytestring bytestring random razom-text-util
          regex-applicative smaoin text text-position utf8-string
@@ -84109,7 +84420,7 @@ self: {
      mkDerivation {
        pname = "language-lua";
        version = "0.6.3.2";
-       sha256 = "0wnmybaqiwwxg8xcs7g1ffsmv8kmld7m6s0a8wp0lvhdil7d9xq6";
+       sha256 = "06f7d40e8d0d6e0a2e470a68534fa375a25db573e11dcd3a7a9df388d5f2d572";
        libraryHaskellDepends = [ array base deepseq mtl parsec safe ];
        libraryToolDepends = [ alex ];
        testHaskellDepends = [
@@ -84126,7 +84437,7 @@ self: {
      mkDerivation {
        pname = "language-mixal";
        version = "0.1";
-       sha256 = "0fgjkx003bn0bi4z6rgg8yvsl8k8almydh2lajkyp6zi5348vcv5";
+       sha256 = "65b38dc828f19beba75454c0e62b556822aab747ef65f3495cc0ae01409ff239";
        isLibrary = true;
        isExecutable = true;
        libraryHaskellDepends = [ base mtl parsec pretty ];
@@ -84144,7 +84455,7 @@ self: {
      mkDerivation {
        pname = "language-objc";
        version = "0.4.2.8";
-       sha256 = "0dqx8fzbh53kakbh62zmq3x4gx4p5zfwisi3z6n03mjyfv3wv6jv";
+       sha256 = "5b9acdc7765ed601acf923eac8dd2f97f447fac0f50b03d7547314b8be431d37";
        libraryHaskellDepends = [
          array base bytestring containers directory filepath newtype pretty
          process syb
@@ -84162,7 +84473,7 @@ self: {
      mkDerivation {
        pname = "language-openscad";
        version = "0.1.6";
-       sha256 = "0xbwd0arsxinszlmdql5d61w33mpqya8gybkllyb1v7xhqskjasr";
+       sha256 = "592b393586fdecb03ca573f98794c7b78ec1836985e256e9d736769d15687c75";
        isLibrary = true;
        isExecutable = true;
        libraryHaskellDepends = [ attoparsec base bytestring ];
@@ -84181,7 +84492,7 @@ self: {
      mkDerivation {
        pname = "language-pig";
        version = "0.3.0.1";
-       sha256 = "1lv8zm352him9rby1k0n90bklx8wlvr1w8anzmr54fmbd9ibx0f2";
+       sha256 = "c281be626aab3a5272fd56211ef2a61c753a174816cce0574e35425146fd68d3";
        libraryHaskellDepends = [
          base Cabal containers parsec pretty-tree
        ];
@@ -84208,7 +84519,7 @@ self: {
      mkDerivation {
        pname = "language-puppet";
        version = "1.1.3.1";
-       sha256 = "1h6zsslp3szc3m2ki273a6w47gf9fizyjh0xxby694cmhspknn90";
+       sha256 = "20593baf86959164fcea1d40e97f74c9bd43b851e38838451deceb71a9d6dfc0";
        isLibrary = true;
        isExecutable = true;
        libraryHaskellDepends = [
@@ -84244,7 +84555,7 @@ self: {
      mkDerivation {
        pname = "language-python";
        version = "0.5.0";
-       sha256 = "1z0m0lbvrcjyh04zr52wi1zhmb28m4s67zlvf2wc6qh0z9y4l7wy";
+       sha256 = "9e1f4a7cfa0062c3b8709bfe6334a948ac0a7f885c94fc09805eb2bc170515fc";
        libraryHaskellDepends = [
          array base containers monads-tf pretty transformers utf8-string
        ];
@@ -84259,7 +84570,7 @@ self: {
      mkDerivation {
        pname = "language-python-colour";
        version = "0.1";
-       sha256 = "1cspr1v0dm4lbjrb654n8lax9nvmj94a89cp3vqir8xccaxhggpz";
+       sha256 = "ffbe07bb62aca31cf11e9725a4489275dbd415459614b3b25c94d40676c857b3";
        isLibrary = false;
        isExecutable = true;
        executableHaskellDepends = [
@@ -84276,7 +84587,7 @@ self: {
      mkDerivation {
        pname = "language-python-test";
        version = "0.5.0";
-       sha256 = "0sxl2snzwi4v3fzfgdwy2fx1pih4qvh1z8s1qkkq346x76n4rgnv";
+       sha256 = "dbbe4cac39dd9081e7c441a31fe0c604c61bba139eb7e7be1b9b44fead16b46b";
        isLibrary = false;
        isExecutable = true;
        executableHaskellDepends = [ base language-python ];
@@ -84291,7 +84602,7 @@ self: {
      mkDerivation {
        pname = "language-sh";
        version = "0.0.3.1";
-       sha256 = "12yjynd1sib1mxx4jc28gs1k3r7kl1qv7xhanvn635dkcmswsd5k";
+       sha256 = "b334cd7565b39561ecb60af6b371a0f3e431837e4830497aaf61451d9af5d28b";
        libraryHaskellDepends = [
          base directory filepath mtl parsec pcre-light
        ];
@@ -84310,7 +84621,7 @@ self: {
      mkDerivation {
        pname = "language-slice";
        version = "0.3.0.0";
-       sha256 = "1d9g41z1nw327z5n7hj8gj0yfvmkj7hz7cpwhi4r32xa7x98hdzy";
+       sha256 = "fe3788523faa8b914984fcb2f3e191b36ee7817c48c263cb3f62701b7e202fb5";
        libraryHaskellDepends = [ base bytestring parsec transformers ];
        testHaskellDepends = [
          base bytestring HUnit parsec QuickCheck test-framework
@@ -84329,7 +84640,7 @@ self: {
      mkDerivation {
        pname = "language-spelling";
        version = "0.3.2";
-       sha256 = "05jgx1rcfb9aidrim2h9vr72c3m9hak2njkh04hkf4q3v1pv03ym";
+       sha256 = "d50fb06fd80313372101704a2ba682a90e264ede098a1a738b2a2dc772e84f16";
        libraryHaskellDepends = [
          array base bk-tree bytestring containers ListLike
          listlike-instances text tst vector
@@ -84350,7 +84661,7 @@ self: {
      mkDerivation {
        pname = "language-sqlite";
        version = "1.1";
-       sha256 = "1mpbp56xgqx6j4mfla00kvr9q6mysncjw57mphvrz86ificjw93m";
+       sha256 = "75242e5974d1a09f37bcf5142e99d5be1a9cf29e0028ea2a91a6e3d74db9ebd6";
        libraryHaskellDepends = [
          array base bytestring containers mtl template-haskell utf8-string
        ];
@@ -84367,7 +84678,7 @@ self: {
      mkDerivation {
        pname = "language-thrift";
        version = "0.4.0.0";
-       sha256 = "0al6a9j9hwla8kyfw30m9ylw4wzxv0nr3nvri8w9wnh6ckaf5j2w";
+       sha256 = "5cc8e2d464065a9e388a79db912dd8fd73c2a94f150ceefc448a72986452862a";
        libraryHaskellDepends = [
          base mtl parsers text trifecta wl-pprint
        ];
@@ -84385,7 +84696,7 @@ self: {
      mkDerivation {
        pname = "language-typescript";
        version = "0.0.4";
-       sha256 = "07lm3d4m7c6j2b5gywqm05189iwkh2zjiv5xwwmcw1fm2a63r2zd";
+       sha256 = "ed8b3c8c12d505ce2ae7bdec28bf8093c78442011573ffca12d2b053491b951e";
        libraryHaskellDepends = [ base containers parsec pretty ];
        homepage = "http://github.com/paf31/language-typescript";
        description = "A library for working with TypeScript Definition files";
@@ -84399,7 +84710,7 @@ self: {
      mkDerivation {
        pname = "largeword";
        version = "1.2.3";
-       sha256 = "1ldcsnnji6p84sn03j17pdcpg7vqn1xrhyn4wys0v5fyy0d383ln";
+       sha256 = "960e341af0de950db4e7c47a987bb0789f7759bb27c801ac26e89a28add5acd1";
        libraryHaskellDepends = [ base binary ];
        testHaskellDepends = [
          base binary bytestring HUnit QuickCheck test-framework
@@ -84418,7 +84729,7 @@ self: {
      mkDerivation {
        pname = "lat";
        version = "0.6";
-       sha256 = "0snzcck07v3w1qcgw2j6w7g4ydm59cprf3cqivl9qbgsjljl3zxn";
+       sha256 = "b6ff412595fa2d9ce88e980d972f4ba5364fdee1460afe180e7cec032663df6a";
        isLibrary = false;
        isExecutable = true;
        executableHaskellDepends = [
@@ -84439,7 +84750,7 @@ self: {
      mkDerivation {
        pname = "latest-npm-version";
        version = "0.3.1";
-       sha256 = "0z6jl0i9d9r4nifyn2h6pk8s3ni5zfmbc4gpaqim3hzzbh6kqrn0";
+       sha256 = "c0663c0d5cffc3512356f711b6aafb25daa1d1bc060aeb5db424a79622a0d27c";
        isLibrary = true;
        isExecutable = true;
        libraryHaskellDepends = [
@@ -84469,7 +84780,7 @@ self: {
      mkDerivation {
        pname = "latex";
        version = "0.1.0.3";
-       sha256 = "1linwqab6z2s91vdxr874vk7rg7gv1ckabsxwmlr80gnhdfgyhmp";
+       sha256 = "b742ff5c83f6019469e55d2f3559d8efbc7ce62607e5de76485a7cb314e636d2";
        libraryHaskellDepends = [ base containers utility-ht ];
        homepage = "http://www.haskell.org/haskellwiki/LaTeX";
        description = "Parse, format and process LaTeX files";
@@ -84483,7 +84794,7 @@ self: {
      mkDerivation {
        pname = "lattices";
        version = "1.3";
-       sha256 = "1jp63rh1girf9ka0lfi219wlisni8dsckf67h6413ihdxdh2mp3l";
+       sha256 = "74dc2a60eb0dc6118881c7b8c97443d1ea48790a223a0ad44c2ec717601ee6ca";
        libraryHaskellDepends = [
          base containers deepseq hashable unordered-containers
        ];
@@ -84498,7 +84809,7 @@ self: {
      mkDerivation {
        pname = "launchpad-control";
        version = "0.0.1.0";
-       sha256 = "0lbrrm5wfi3vgmvba9rvbzq78idq6z98psjfh5scjp8hg0qbf8q2";
+       sha256 = "0223b73078105dc974814eea8bd237b84574f05f3b27b5767d7b44c74bcd7951";
        isLibrary = true;
        isExecutable = true;
        libraryHaskellDepends = [
@@ -84515,7 +84826,7 @@ self: {
      mkDerivation {
        pname = "lax";
        version = "0.1.0.3";
-       sha256 = "12f0k2545nk50cvs3gd41dhsfls19xkhvn3avhmgx69y57mhalcy";
+       sha256 = "9e5105eb293e99fe2adc6ad80d674f4153a7610ba4bda1370365da428a98c089";
        libraryHaskellDepends = [ base ];
        homepage = "http://darcs.wolfgang.jeltsch.info/haskell/lax";
        description = "Lax arrows";
@@ -84527,7 +84838,7 @@ self: {
      mkDerivation {
        pname = "layers";
        version = "0.1";
-       sha256 = "1yn8swgxb908wslcnh04919m9rzy47dxgawns89zw5v1gbq3wmdf";
+       sha256 = "ae553ef07a6117fe13d296abd7db21fee75453480440cba8e608a4d51fd7c8fa";
        libraryHaskellDepends = [ base transformers ];
        jailbreak = true;
        homepage = "http://github.com/duairc/layers";
@@ -84543,7 +84854,7 @@ self: {
      mkDerivation {
        pname = "layers-game";
        version = "0.5";
-       sha256 = "01j1gq3jd8mm519p3drxfpd32mm1qmik39vijncrx64p7wii73k8";
+       sha256 = "688e13233f97989e999571a73163c5a15631da753db7715328b5a226077e4106";
        isLibrary = false;
        isExecutable = true;
        executableHaskellDepends = [
@@ -84560,7 +84871,7 @@ self: {
      mkDerivation {
        pname = "layout";
        version = "0.0.0.1";
-       sha256 = "04075x2f646ifaw9pxi5s6avp1vis1j524w9a2m3apyrz583cj0g";
+       sha256 = "0f483650f9d95f35aa5089135164d07187bb95d125f69bb872d110e3442f0710";
        libraryHaskellDepends = [ base convertible hinduce-missingh ];
        description = "Turn values into pretty text or markup";
        license = stdenv.lib.licenses.bsd3;
@@ -84572,7 +84883,7 @@ self: {
      mkDerivation {
        pname = "layout-bootstrap";
        version = "0.2.2";
-       sha256 = "0rm0w5l4g865ais4rg3vdfx6fyzp1dginlhlabvqclbjwwzkiyqi";
+       sha256 = "11fb383fe7725186f75214521b5f0bf77b67ba6b7bbc4c7454c5a04768e1a066";
        libraryHaskellDepends = [ base blaze-html containers text ];
        homepage = "https://bitbucket.org/dpwiz/layout-bootstrap";
        description = "Template and widgets for Bootstrap2 to use with Text.Blaze.Html5";
@@ -84585,7 +84896,7 @@ self: {
      mkDerivation {
        pname = "lazy-csv";
        version = "0.5.1";
-       sha256 = "17v495xnv38bx9zfjfa8dl3prj94lg74dhn1jzqrjq488gfwp2w8";
+       sha256 = "888bcbdd43886099f197c1c246cea324c97c076d4839e97eea0b8d6d7b49649f";
        isLibrary = true;
        isExecutable = true;
        libraryHaskellDepends = [ base bytestring ];
@@ -84600,7 +84911,7 @@ self: {
      mkDerivation {
        pname = "lazy-io";
        version = "0.1.0";
-       sha256 = "0fbvm8wwvp4xm4rq2mdfnrra7c88dps91j7ay2vn7iqmpdkcwly9";
+       sha256 = "c953ce66bb15c763b7f0eac890f46d08b1a372b6ae558133a99ddccd39aa7b39";
        libraryHaskellDepends = [ base ];
        homepage = "https://github.com/kawu/lazy-io";
        description = "Lazy IO";
@@ -84612,7 +84923,7 @@ self: {
      mkDerivation {
        pname = "lazyarray";
        version = "0.1.3";
-       sha256 = "0bc2n7x8fydmzc84yb5zbdaca1r4qwpk7zlvbgcycycr87fk7p7n";
+       sha256 = "f6dc33dd419979e6d95b9bfe332fc72407c5545bbf2c4f10fbb57987fab1822d";
        libraryHaskellDepends = [ array base ];
        description = "Efficient implementation of lazy monolithic arrays (lazy in indexes)";
        license = stdenv.lib.licenses.bsd3;
@@ -84624,7 +84935,7 @@ self: {
      mkDerivation {
        pname = "lazyio";
        version = "0.1.0.1";
-       sha256 = "16cl1yifcmfywqc7kgz9kmp0x6s4300ccgmcrzr4j4jgwcgl38bc";
+       sha256 = "6ca1411fe34f1249f2cfac3ec60018449b0e6e9de9bf7918e6de55e6a20f9499";
        isLibrary = true;
        isExecutable = true;
        libraryHaskellDepends = [ base transformers unsafe ];
@@ -84638,7 +84949,7 @@ self: {
      mkDerivation {
        pname = "lazysmallcheck";
        version = "0.6";
-       sha256 = "0lqggm75m1qd34lzqj3ibvnjwhjqvq16cab8zxm4yzn7j2sxzm4x";
+       sha256 = "9dd4dfb590c77e4f6aff68296602de58422eed5e7148fc29190d875a4e7d0f53";
        libraryHaskellDepends = [ base ];
        homepage = "http://www.cs.york.ac.uk/~mfn/lazysmallcheck/";
        description = "A library for demand-driven testing of Haskell programs";
@@ -84650,7 +84961,7 @@ self: {
      mkDerivation {
        pname = "lazysplines";
        version = "0.2";
-       sha256 = "0r6z3b6yaxsnz8cbfr815q97jlzsjrqszb2vvzwjyqbh6qqw006y";
+       sha256 = "de00c0313670612ff9df5bacaf7196fa5379122e0165b718fa5677e5cd1adf64";
        libraryHaskellDepends = [ base ];
        description = "Differential solving with lazy splines";
        license = stdenv.lib.licenses.bsd3;
@@ -84662,7 +84973,7 @@ self: {
      mkDerivation {
        pname = "lbfgs";
        version = "0.0.5";
-       sha256 = "0j69hq053ksypb5a3dcvnfa5pscvxhsnby1p5pj4bw6c209g8a06";
+       sha256 = "0628f41210ccf045e42d37f86535ec9be95b94b39bb5a1caba5ecf510086c948";
        libraryHaskellDepends = [ array base ];
        description = "L-BFGS optimization";
        license = "unknown";
@@ -84673,7 +84984,7 @@ self: {
      mkDerivation {
        pname = "lca";
        version = "0.3";
-       sha256 = "081fk0ci5vb84w4zwah6qwbr0i78v2pr6m6nn1y226vv5w3kakza";
+       sha256 = "ea4f35072f7b1b217cb0d65493afd8e8449017c7062afe092768ed1219982e20";
        libraryHaskellDepends = [ base ];
        testHaskellDepends = [ base doctest ];
        homepage = "http://github.com/ekmett/lca/";
@@ -84686,7 +84997,7 @@ self: {
      mkDerivation {
        pname = "lcs";
        version = "0.2";
-       sha256 = "1w8z80vqb86zl6ap4nd87kpl91qms8310k1d8r6qrxg2skm6gnxl";
+       sha256 = "b4db67ead4e2f58c4d462d4c1006d2158744ef3ca8597295a1dfa08537401ff1";
        libraryHaskellDepends = [ array base ];
        homepage = "http://urchin.earth.li/~ian/cabal/lcs/";
        description = "Find longest common sublist of two lists";
@@ -84701,7 +85012,7 @@ self: {
      mkDerivation {
        pname = "lda";
        version = "0.0.2";
-       sha256 = "125y7syfpwg6356h4rq34k45h115ywbz9yisvd741jf6aij23is2";
+       sha256 = "42c7216454c6c9404edb3afaf417f7250458c8240367024d19e6f1ebbc3ebe88";
        libraryHaskellDepends = [
          base containers ghc-prim mtl random-fu random-source rvar vector
        ];
@@ -84718,7 +85029,7 @@ self: {
      mkDerivation {
        pname = "ldap-client";
        version = "0.1.0";
-       sha256 = "18c33jfgwa7vdickxshyhmrqdpndy7ayjd3z0zqkjqa7awd0zcf4";
+       sha256 = "c4b10f1a57476139f1077f34e9d5f1cdde8673851eea3e596cfb28fe9c1c83a1";
        libraryHaskellDepends = [
          asn1-encoding asn1-types async base bytestring connection
          containers network semigroups stm text
@@ -84737,7 +85048,7 @@ self: {
      mkDerivation {
        pname = "ldif";
        version = "0.0.13";
-       sha256 = "0mf0cvjzgimrqf80g6hg75azv18930g5mrvjjxw70116mdpp718a";
+       sha256 = "0a85736fab260470789772e75a1e180985fd55390f9a0790c3b9c6f7e566c055";
        isLibrary = true;
        isExecutable = true;
        libraryHaskellDepends = [
@@ -84761,7 +85072,7 @@ self: {
      mkDerivation {
        pname = "leaf";
        version = "1.0.1.1";
-       sha256 = "1czk4d2xa2g7djdz669h1q6ciflzwxm4n05m9jv3d3z7r6fcch6z";
+       sha256 = "df40c69cc9e78f36b64cb5004b6ae79fbac80c0e3019f39b6ce709d54523f3b3";
        isLibrary = false;
        isExecutable = true;
        executableHaskellDepends = [
@@ -84781,7 +85092,7 @@ self: {
      mkDerivation {
        pname = "leaky";
        version = "0.4.0.0";
-       sha256 = "17cs1mszcfibfkcbwxdcn4pi3n6b84a23szv548vqxwypyrzlbf0";
+       sha256 = "c02dfab3bf9e77bc1129fbeb211441cbd8112fb1ac75bed8742b3af6750d9a9d";
        isLibrary = false;
        isExecutable = true;
        executableHaskellDepends = [
@@ -84799,7 +85110,7 @@ self: {
      mkDerivation {
        pname = "leankit-api";
        version = "0.4";
-       sha256 = "14ax9w72cdmbsgy879mwwi2g0345xzfvivrq8b7ngkr8dyfp72r7";
+       sha256 = "278b739d6f28cf67cf4238efb8ddef850cf044e4bca683fcd3ab36260e4f5d91";
        libraryHaskellDepends = [
          aeson base bytestring colour curl split
        ];
@@ -84812,7 +85123,7 @@ self: {
      mkDerivation {
        pname = "leapseconds-announced";
        version = "2015.0.0.1";
-       sha256 = "0k8khjfq1cr8wb2wgwwk7yv6461h7z6wf6qn21qd9zq9i22bpyhm";
+       sha256 = "15fabb848809ffd47010161bc7cd3f301862b63f93f3c7c5e228b3809d84134d";
        libraryHaskellDepends = [ base time ];
        testHaskellDepends = [ base QuickCheck time ];
        homepage = "https://github.com/bjornbm/leapseconds-announced";
@@ -84825,7 +85136,7 @@ self: {
      mkDerivation {
        pname = "learn";
        version = "0.1.1";
-       sha256 = "1i2rn4pmgbqxj0xsjqp5rh50lv6zgnblbjgwmqh5cxb3dsillvpj";
+       sha256 = "f26e4aa36e63755620aefcc945977ddf6c0a0acce562a93b901daf572fb159c4";
        libraryHaskellDepends = [ base containers ];
        description = "Learning Algorithms";
        license = stdenv.lib.licenses.bsd3;
@@ -84838,7 +85149,7 @@ self: {
      mkDerivation {
        pname = "learn-physics";
        version = "0.5";
-       sha256 = "0bh7p0pp4pspb5m4bfab5z3sfrywlw59yc7w11sa6ax29q9r9faq";
+       sha256 = "58b994134ea22ba37408fc309f0aa7dc67a7c72f4bb9456a59575f722fb8072e";
        libraryHaskellDepends = [
          base gloss gnuplot not-gloss spatial-math vector-space
        ];
@@ -84855,7 +85166,7 @@ self: {
      mkDerivation {
        pname = "learn-physics-examples";
        version = "0.5.0.1";
-       sha256 = "0fwmc7q59srasciijd7ws1bqay4cc7jhi1469my67kchg0n45q3k";
+       sha256 = "73e0422c7890cd637c4d868408e5618c788557d0fc341923d32aeb54f061953b";
        isLibrary = false;
        isExecutable = true;
        executableHaskellDepends = [
@@ -84874,7 +85185,7 @@ self: {
      mkDerivation {
        pname = "learning-hmm";
        version = "0.3.2.2";
-       sha256 = "1a2a97cflnlalcqr54ssbmy047i6y1xgswssy64hsr36g2lhywrs";
+       sha256 = "3a730fa97866640d89f15a73fd7af0261e027c5d5a939231a38a5aead8494aa8";
        libraryHaskellDepends = [
          base containers deepseq hmatrix random-fu random-source vector
        ];
@@ -84888,7 +85199,7 @@ self: {
      mkDerivation {
        pname = "leetify";
        version = "0.1.0.1";
-       sha256 = "106pr7rlma67dqqyfhknh9fb6r37lsj00qjx1dq3xx7yxp368nvr";
+       sha256 = "795b64c6edfef43e700b5d6200a4a66764b35c827642e7316ec7a84af3c9d780";
        isLibrary = false;
        isExecutable = true;
        executableHaskellDepends = [ base containers ];
@@ -84902,25 +85213,27 @@ self: {
     ({ mkDerivation, array, base, binary, binary-shared, blaze-html
      , bytestring, Cabal, conduit, containers, cpphs, deepseq, directory
      , executable-path, filepath, ghc, ghcjs-codemirror, ghcjs-dom, gio
-     , glib, gtk3, gtksourceview3, hamlet, haskell-src-exts, hlint
-     , hslogger, jsaddle, leksah-server, lens, ltk, monad-loops, mtl
-     , network, network-uri, old-time, parsec, pretty, pretty-show
-     , QuickCheck, regex-base, regex-tdfa, regex-tdfa-text, shakespeare
-     , stm, strict, text, time, transformers, unix, utf8-string, vado
-     , vcsgui, vcswrapper, webkitgtk3, webkitgtk3-javascriptcore
+     , glib, gtk3, gtksourceview3, haskell-src-exts, hlint, hslogger
+     , jsaddle, leksah-server, lens, ltk, monad-loops, mtl, network
+     , network-uri, old-time, parsec, pretty, pretty-show, QuickCheck
+     , regex-base, regex-tdfa, regex-tdfa-text, shakespeare, stm, strict
+     , text, time, transformers, unix, utf8-string, vado, vcsgui
+     , vcswrapper, webkitgtk3, webkitgtk3-javascriptcore
      }:
      mkDerivation {
        pname = "leksah";
-       version = "0.15.1.1";
-       sha256 = "0gjgaigkd34gzfvqhlxqqxcydh12064prnn0x653kb5ks8bq4qml";
+       version = "0.15.1.2";
+       sha256 = "4b90e8f41165afd439a7b3bb587e03c89eb908deec6ee0837af38f7eaf925fc7";
+       revision = "1";
+       editedCabalFile = "e97b32fd5b0bfc80e02961a66cbb505cae737e3bc8f4f88afd9602740fc21d66";
        isLibrary = true;
        isExecutable = true;
        libraryHaskellDepends = [
          array base binary binary-shared blaze-html bytestring Cabal conduit
          containers cpphs deepseq directory executable-path filepath ghc
-         ghcjs-codemirror gio glib gtk3 gtksourceview3 hamlet
-         haskell-src-exts hlint hslogger jsaddle leksah-server lens ltk mtl
-         network network-uri old-time parsec pretty pretty-show QuickCheck
+         ghcjs-codemirror gio glib gtk3 gtksourceview3 haskell-src-exts
+         hlint hslogger jsaddle leksah-server lens ltk mtl network
+         network-uri old-time parsec pretty pretty-show QuickCheck
          regex-base regex-tdfa regex-tdfa-text shakespeare stm strict text
          time transformers unix utf8-string vado vcsgui vcswrapper
          webkitgtk3 webkitgtk3-javascriptcore
@@ -84934,7 +85247,6 @@ self: {
          leksah-server ltk monad-loops QuickCheck stm text transformers
          webkitgtk3
        ];
-       jailbreak = true;
        homepage = "http://www.leksah.org";
        description = "Haskell IDE written in Haskell";
        license = "GPL";
@@ -84951,8 +85263,8 @@ self: {
      }:
      mkDerivation {
        pname = "leksah-server";
-       version = "0.15.0.6";
-       sha256 = "1pcf42hipc5q3n61pbd2sdgvhshl2ri261i94myb3fc13kbi90hb";
+       version = "0.15.0.7";
+       sha256 = "8d98649f6227f0fc3ad9aa169c74f435ec825a1333c57445860b9f8ff1ffc79d";
        isLibrary = true;
        isExecutable = true;
        libraryHaskellDepends = [
@@ -84985,7 +85297,7 @@ self: {
      mkDerivation {
        pname = "lendingclub";
        version = "0.1.1";
-       sha256 = "1r40qm7f45vgzdxnzlhpqhsi81rbwa2nss3gf1d5mqz32dscjwfx";
+       sha256 = "dd71c97413e3e35a5a706f686d85e22b071435c417d26f7bfb6f17e24ec580e4";
        libraryHaskellDepends = [
          aeson base blaze-builder bytestring HsOpenSSL http-streams
          io-streams mtl scientific text vector
@@ -85009,7 +85321,7 @@ self: {
      mkDerivation {
        pname = "lens";
        version = "4.12.3";
-       sha256 = "0898z1ws9sy77yfhvx5did0pibpp81yxz0jg418gdx3znd39vyj8";
+       sha256 = "48fa9d46b37ff4f650204f82df7d40f7ae78418badf40d9d3fc7eba479f82821";
        libraryHaskellDepends = [
          array base base-orphans bifunctors bytestring comonad containers
          contravariant distributive exceptions filepath free ghc-prim
@@ -85037,7 +85349,7 @@ self: {
      mkDerivation {
        pname = "lens-action";
        version = "0.2.0.1";
-       sha256 = "164fka3krz32zhxnhkylnkmgnx2qj4qvn6y1hfwwla4ddn0axm9n";
+       sha256 = "36d5ae806d8d28cab983c11bbb31915874fbeab4d44f683bfc62fc3c879a8e98";
        libraryHaskellDepends = [
          base comonad contravariant lens mtl profunctors semigroupoids
          semigroups transformers
@@ -85056,7 +85368,7 @@ self: {
      mkDerivation {
        pname = "lens-aeson";
        version = "1.0.0.4";
-       sha256 = "0zjl645y4bwg3pvld8z4vj9rdpdy6fja2cx63d85k37zp5n98y7v";
+       sha256 = "fb78946cb9ff8c59501ba633a1a433bedd9693dce4a346f71d8f2fe20b31547e";
        revision = "2";
        editedCabalFile = "f9ddeac68a237cb5dbe8ab7457fb7529bdeeb675c5e80bc122e196255072393d";
        libraryHaskellDepends = [
@@ -85077,7 +85389,7 @@ self: {
      mkDerivation {
        pname = "lens-datetime";
        version = "0.2.1";
-       sha256 = "1wqks7ynw3njlizdd9hvgrc1xjxcgcfck9ppj1lgg8wr3l2myi72";
+       sha256 = "e2445f051d99a3f76890f7a6c91c7baccb1e587e1ba6d67ea4d20e6efdd113f3";
        libraryHaskellDepends = [ base lens time ];
        homepage = "http://github.com/nilcons/lens-datetime";
        description = "Lenses for Data.Time.* types";
@@ -85091,7 +85403,7 @@ self: {
      mkDerivation {
        pname = "lens-family";
        version = "1.2.0";
-       sha256 = "0pbyx43ajx96nhcw4brml1r5azs1041k7nv4m94ak6x77n5sr4mb";
+       sha256 = "ab92ac8b3da79ba948aa64db330301417f5572a0352fc219b42675a906e97e5d";
        libraryHaskellDepends = [
          base containers lens-family-core mtl transformers
        ];
@@ -85104,7 +85416,7 @@ self: {
      mkDerivation {
        pname = "lens-family-core";
        version = "1.2.0";
-       sha256 = "0hxrbbc4azfafnr4ab2zxgic093wwg6gx5h1ggp4xks55d8rhraz";
+       sha256 = "5f6598512b45cf4eee7b0196fecce37c24c0e2eb5f2c45b275ca7d45d85ab943";
        libraryHaskellDepends = [ base containers transformers ];
        description = "Haskell 98 Lens Families";
        license = stdenv.lib.licenses.bsd3;
@@ -85115,7 +85427,7 @@ self: {
      mkDerivation {
        pname = "lens-family-th";
        version = "0.4.1.0";
-       sha256 = "084yng26xyhw6c6hij3p70zvjpvm1dlw6klphw51car9gi6dqkvm";
+       sha256 = "754fdc4c7c292b160a87974ec3690b755fb93f3877c8080d331cfa6ec4b39e20";
        revision = "1";
        editedCabalFile = "13c96ddf2d410ec4e6671c8412710b7cdbbfc837ff5be1d09a6dbb9ecdb9285d";
        libraryHaskellDepends = [ base template-haskell ];
@@ -85129,7 +85441,7 @@ self: {
      mkDerivation {
        pname = "lens-properties";
        version = "4.11";
-       sha256 = "0cg0n75ss5ayy31igwyz9yz2sh0smcaiidbbm1wkrk1krzbws31w";
+       sha256 = "3c0ccdd7cf33cc3c79a86bb51815ab1a402dbe4fdff317c3f05e15adcbb1e031";
        libraryHaskellDepends = [ base lens QuickCheck transformers ];
        homepage = "http://github.com/ekmett/lens/";
        description = "QuickCheck properties for lens";
@@ -85143,7 +85455,7 @@ self: {
      mkDerivation {
        pname = "lens-regex";
        version = "0.1.0";
-       sha256 = "0hjizjmvdngxn63gs7x87qidh71aqhvyigrnqlbfjqan76pb6m29";
+       sha256 = "4954b3ae395661e916c536bfe837c42a1cd8223ea81ffd86b1fdd9b6abfc5142";
        isLibrary = true;
        isExecutable = true;
        libraryHaskellDepends = [
@@ -85164,7 +85476,7 @@ self: {
      mkDerivation {
        pname = "lens-simple";
        version = "0.1.0.7";
-       sha256 = "08ynx0zhll603srdmgqf9pgdbzn4i9ry99hs7m35kwaj21whrq5q";
+       sha256 = "b8e00c791052f159463d1aa6e4738ac4fed5de4d0ebfdab21ec0500a3fe8d623";
        libraryHaskellDepends = [
          base lens-family lens-family-core lens-family-th mtl transformers
        ];
@@ -85178,7 +85490,7 @@ self: {
      mkDerivation {
        pname = "lens-sop";
        version = "0.1.0.2";
-       sha256 = "1b56q8qsg3w5gzra7bjf76mqinv8vpjrb6any7c3wdpjgvssly56";
+       sha256 = "a678aaf57ef2363ed8f1569995e5dd68db88ab394eaea3f27f858fa731c2a6ac";
        libraryHaskellDepends = [
          base fclabels generics-sop transformers
        ];
@@ -85191,7 +85503,7 @@ self: {
      mkDerivation {
        pname = "lens-text-encoding";
        version = "0.1.0.0";
-       sha256 = "1yxab87ci6gl0c5gsdd8pb780ai8lmxxa3fxkpl1shv1pw124fsv";
+       sha256 = "5b3b2202bf61431de89ddd0dd57ba5282a80cebaa835fd0a03f499c80e5aaafb";
        libraryHaskellDepends = [ base bytestring lens text ];
        jailbreak = true;
        homepage = "http://github.com/iand675/text-lens-encoding";
@@ -85204,7 +85516,7 @@ self: {
      mkDerivation {
        pname = "lens-time";
        version = "0.1.0.0";
-       sha256 = "1hrp9d6qja7yc3zj68w3hylgflyfsvh79m8daw9030yjdxm525za";
+       sha256 = "ea17516a6fd2830112570dd574e0d6ce53f7a887832323ff60fe28894d4b37c3";
        libraryHaskellDepends = [ base lens time ];
        jailbreak = true;
        description = "lens for Data.Time";
@@ -85216,7 +85528,7 @@ self: {
      mkDerivation {
        pname = "lenses";
        version = "0.1.7";
-       sha256 = "09p1ph5ih2dzrbn7h9wjnf4xch04g0amf8cc3q64g5a2clg3vjx4";
+       sha256 = "a4cb3d1e654295470c1e8c215715780440d689b3922778eccabf09180bbce126";
        libraryHaskellDepends = [ base mtl template-haskell ];
        homepage = "http://github.com/jvranish/Lenses/tree/master";
        description = "Simple Functional Lenses";
@@ -85228,7 +85540,7 @@ self: {
      mkDerivation {
        pname = "lensref";
        version = "0.2";
-       sha256 = "0dj43hqrv198dgfnngq4l8kwnksqcm6nydcr1z1a5gqz5s99m4bn";
+       sha256 = "76919a922e1fbfa2c20f99356f4d65584fcb27a2043f6bdd6b28859d311c4436";
        libraryHaskellDepends = [ base monad-control mtl transformers ];
        testHaskellDepends = [ base ];
        jailbreak = true;
@@ -85245,7 +85557,7 @@ self: {
      mkDerivation {
        pname = "lentil";
        version = "0.1.3.1";
-       sha256 = "19zjwkj9is5fdayvwf6w8r42z0lyrbj2lqqw822zr87xaq96r2g2";
+       sha256 = "e2896c1256fda0fc85401c632ae4ca9e822f4846dc38bebd6aaee898e4e4f2a7";
        isLibrary = false;
        isExecutable = true;
        executableHaskellDepends = [
@@ -85266,7 +85578,7 @@ self: {
      mkDerivation {
        pname = "level-monad";
        version = "0.4.1";
-       sha256 = "1l5jyhpvbcj4fmyggp8bjy4gx9igcydply3yb1s23fxdcz0b638a";
+       sha256 = "0a0db3c067adbb2174587e787a9b672fa6fe88970bddf77c7544b2b52ff4b2d0";
        libraryHaskellDepends = [ base fmlist ];
        homepage = "http://github.com/sebfisch/level-monad";
        description = "Non-Determinism Monad for Level-Wise Search";
@@ -85281,7 +85593,7 @@ self: {
      mkDerivation {
        pname = "leveldb-haskell";
        version = "0.6.3";
-       sha256 = "0vljwjcd9m63wk7zmkl2s6b6kpjn7hqmwwg0p2bjm0d7ras69pk5";
+       sha256 = "65de64b4caa7812a97b8e0715e313c56de6996d182cefacfe4c3d4d498e4926e";
        isLibrary = true;
        isExecutable = true;
        libraryHaskellDepends = [
@@ -85309,7 +85621,7 @@ self: {
      mkDerivation {
        pname = "leveldb-haskell-fork";
        version = "0.3.4.4";
-       sha256 = "021ckykw5wwkm8gpbqq1znis4rakqmri8bz8ldmm8cmlb3v3b6aq";
+       sha256 = "589935f658b432546ba3e82f1473c55365a2a3fd01e3751faa93f3c2a79f2c08";
        isLibrary = true;
        isExecutable = true;
        libraryHaskellDepends = [
@@ -85334,7 +85646,7 @@ self: {
      mkDerivation {
        pname = "levmar";
        version = "1.2.1.5";
-       sha256 = "09ambniwcvrss8s3f9rvgrq204d9y7baxiw52r3pp693spmwazkj";
+       sha256 = "727ec5ebd523997b471685c7aed6f1a91120707e3b273734d23a6fc6a35d5525";
        libraryHaskellDepends = [ base bindings-levmar hmatrix vector ];
        homepage = "https://github.com/basvandijk/levmar";
        description = "An implementation of the Levenberg-Marquardt algorithm";
@@ -85347,7 +85659,7 @@ self: {
      mkDerivation {
        pname = "levmar-chart";
        version = "0.2";
-       sha256 = "0ws9d2ipk67ir4b31rd7vakyglhrr290k400zpb24ny3vvdgcwaj";
+       sha256 = "5271f6dadec35b22d6fd00900992c819d2e7a7daa7e53016c9f19879a3684973";
        isLibrary = true;
        isExecutable = true;
        libraryHaskellDepends = [ base Chart colour data-accessor levmar ];
@@ -85366,8 +85678,8 @@ self: {
      }:
      mkDerivation {
        pname = "lexer-applicative";
-       version = "2.1";
-       sha256 = "1xryc4nnfs7vzvmdszksmzjmz0pi1gpip0qr3gf2lv0baayma7zj";
+       version = "2.1.0.1";
+       sha256 = "3e9612800e7d70f997e0d3396628b91133568b9e85e2c160834d1eb96acca49c";
        libraryHaskellDepends = [ base regex-applicative srcloc ];
        testHaskellDepends = [
          base deepseq regex-applicative srcloc tasty tasty-hunit
@@ -85387,7 +85699,7 @@ self: {
      mkDerivation {
        pname = "lgtk";
        version = "0.8.0.4";
-       sha256 = "1bph09i8znzv3c8sqbg2xbrdlpvlnx52psgyybwn0imqip81lmv5";
+       sha256 = "65571ad08db84660f9f2fee92b4ab7745fdaf2eae22dac111bfbdb8f6202f0ae";
        isLibrary = true;
        isExecutable = true;
        libraryHaskellDepends = [
@@ -85412,7 +85724,7 @@ self: {
      mkDerivation {
        pname = "lha";
        version = "0.1.2";
-       sha256 = "0a5h1d0sdnpy209k4zkmcrrxl4b000226hif098bqs9pngpbgki1";
+       sha256 = "21ceb7eeb33769bc50022e422304006011da7366757e321310fedaa6410bb028";
        libraryHaskellDepends = [ haskell2010 ];
        homepage = "https://github.com/bytbox/lha.hs";
        description = "Data structures for the Les Houches Accord";
@@ -85428,7 +85740,7 @@ self: {
      mkDerivation {
        pname = "lhae";
        version = "0.0.3";
-       sha256 = "120g8x0wbd5va2gqvkr5mx643g8r4hrfyqa68nm3apvfc9z7f8g3";
+       sha256 = "e321777e626e5f35aa454661ef322419bd414caf25cf8d9f50bbb4c541470f88";
        isLibrary = false;
        isExecutable = true;
        executableHaskellDepends = [
@@ -85453,7 +85765,7 @@ self: {
      mkDerivation {
        pname = "lhc";
        version = "0.10";
-       sha256 = "1x50k6lx9p36qxl0qn9zfyqlkgsq3wdzvcv7l6sn920hg5scvcr3";
+       sha256 = "23b3cd7479108864b5a167b3fd1b1f58bf49b1773f590c68c766dcd4a999a0f4";
        isLibrary = false;
        isExecutable = true;
        executableHaskellDepends = [
@@ -85473,7 +85785,7 @@ self: {
      mkDerivation {
        pname = "lhe";
        version = "0.5";
-       sha256 = "08725r5i71ni9ip4qbc5fr111j256rsii936yvxbd7kbbw4ap2a9";
+       sha256 = "4989ab085f6b9eb6faf666a418753645c8104276852d4c6e4cd186134b2ee220";
        libraryHaskellDepends = [ bytestring haskell2010 HaXml lha ];
        description = "Parser and writer for Les-Houches event files";
        license = stdenv.lib.licenses.mit;
@@ -85487,7 +85799,7 @@ self: {
      mkDerivation {
        pname = "lhs2TeX-hl";
        version = "0.1.4.5";
-       sha256 = "1mm6ikiv6zj025yh5abq3f8mqkw9302mfzd01xcihbh74bsdpi9l";
+       sha256 = "34c5dbf422072e18590fa07d570518894f5c911b78a9027d11407eb3e38ca6d6";
        isLibrary = false;
        isExecutable = true;
        executableHaskellDepends = [
@@ -85504,7 +85816,7 @@ self: {
      mkDerivation {
        pname = "lhs2html";
        version = "0.999999";
-       sha256 = "1cwvpn6cl0d5rs5x6q3c2pw4l4hpxz20sr717mggafzsj6j7cccv";
+       sha256 = "9b3176a491fa3bf55e3de1640dc4ef17124af8156c60d38bcea501ca8cbd9bb3";
        isLibrary = false;
        isExecutable = true;
        executableHaskellDepends = [ base directory filepath Glob ];
@@ -85519,7 +85831,7 @@ self: {
      mkDerivation {
        pname = "lhs2tex";
        version = "1.19";
-       sha256 = "03mhhkrqjjqmmh18im8di1cl6wqv30lsib5hv73f0wsnv5bhbbi4";
+       sha256 = "24ae0557d95673e0c6d9b0aca829181b734359880dd58802ac154b89f384b00e";
        isLibrary = false;
        isExecutable = true;
        executableHaskellDepends = [
@@ -85535,7 +85847,7 @@ self: {
      mkDerivation {
        pname = "lhslatex";
        version = "0.1.0.0";
-       sha256 = "0kgmx160i1rylgzh23qlg8ds0sq64yk1i3rah8kmgwabpnvds7f7";
+       sha256 = "c71dddb6bd4bf15727822a8f18a627066ba01b7a140f01ffa33e87084ce8f54d";
        isLibrary = false;
        isExecutable = true;
        executableHaskellDepends = [
@@ -85554,7 +85866,7 @@ self: {
      mkDerivation {
        pname = "libGenI";
        version = "0.16.1";
-       sha256 = "1n37pccmx0466425zcbdfpgivsrnqzwsm0nwcjv8lkg8jxjxrwmz";
+       sha256 = "bff2dc6597e84d8ab664dc82aaf9c736eb1ddf756db15f043186805e19bb67d8";
        libraryHaskellDepends = [
          base binary containers HUnit mtl parsec process QuickCheck
        ];
@@ -85571,7 +85883,7 @@ self: {
      mkDerivation {
        pname = "libarchive-conduit";
        version = "0.1.0.0";
-       sha256 = "022fnxxwz44cjzcldk3yg1xs77xqnrvkr9bv6hi7kdy120dk4p04";
+       sha256 = "045c321b10c1b77922347ba53c77b6b89fa37b787ecc46d9978c90cf7bb74e08";
        libraryHaskellDepends = [
          base bytestring conduit resourcet transformers
        ];
@@ -85588,7 +85900,7 @@ self: {
      mkDerivation {
        pname = "libconfig";
        version = "0.3.0.0";
-       sha256 = "152rvfyc6y9waxic9fw4hfb7w5qfcrr23hdv9jlvksg9yw8mnq12";
+       sha256 = "22605b11f7e9e9b9a94cbbc12172660e177e968384bbc462573c79c3bcdb5994";
        libraryHaskellDepends = [
          base binary cereal cereal-text deepseq hashable text text-binary
          transformers transformers-compat
@@ -85609,7 +85921,7 @@ self: {
      mkDerivation {
        pname = "libcspm";
        version = "1.0.0";
-       sha256 = "1v8w8i871a0fjyjqb8hr4yk9wli5v7djfpyjgg14rjb26v6yq79v";
+       sha256 = "3b1deccd3662c94cc27bd25f27dbd925529ea62719a285a5970ea87050441ced";
        libraryHaskellDepends = [
          array base bytestring containers deepseq directory filepath
          graph-wrapper hashable hashtables mtl pretty text value-supply
@@ -85629,7 +85941,7 @@ self: {
      mkDerivation {
        pname = "libexpect";
        version = "0.3.2";
-       sha256 = "0xpsc9a16biqg4z9b9wk9wqz6ypshw99xrksnxi8nlh3qn98lrsc";
+       sha256 = "4c678a92c503528b62b77ae69e1287fa7af3314f93a7953e79382e135462fa76";
        libraryHaskellDepends = [ base unix ];
        librarySystemDepends = [ expect tcl ];
        description = "Library for interacting with console applications via pseudoterminals";
@@ -85642,7 +85954,7 @@ self: {
      mkDerivation {
        pname = "libffi";
        version = "0.1";
-       sha256 = "0g7jnhng3j7z5517aaqga0144aamibsbpgm3yynwyfzkq1kp0f28";
+       sha256 = "48387067c0f33bcfadf7a3bebbf48a55294202500f2b754229ffc8f12cb4f23c";
        libraryHaskellDepends = [ base bytestring ];
        librarySystemDepends = [ ffi ];
        libraryPkgconfigDepends = [ libffi ];
@@ -85655,7 +85967,7 @@ self: {
      mkDerivation {
        pname = "libgit";
        version = "0.3.1";
-       sha256 = "08km9y2wqz426c5c6r49ar5snl8ss1w7d55yqivksdkwk3fn0k0x";
+       sha256 = "1d4c60dd987c363d77c4be947678d01a51ab4b568964c30a33827ccc854f7522";
        libraryHaskellDepends = [ base mtl process ];
        homepage = "https://github.com/vincenthz/hs-libgit";
        description = "Simple Git Wrapper";
@@ -85669,7 +85981,7 @@ self: {
      mkDerivation {
        pname = "libgraph";
        version = "1.5";
-       sha256 = "0pyync48lr2silvm3cdmn11zmv355hcmmaj6rm7lb365mqv444i1";
+       sha256 = "21124236aec58c454fcd46aa5a192c65ecfa43b0b5b151378d5a648a08b3de5f";
        libraryHaskellDepends = [
          array base containers monads-tf process union-find
        ];
@@ -85686,7 +85998,7 @@ self: {
      mkDerivation {
        pname = "libhbb";
        version = "0.4.1.0";
-       sha256 = "17wycfnp1f288fxq3vd9c206gcard3n59s0a0myy0hkl6xy281s8";
+       sha256 = "4807247c377442e07d050ae854ec6859b1678060a9ed81bb4348b870ad639e9f";
        isLibrary = true;
        isExecutable = true;
        libraryHaskellDepends = [
@@ -85714,7 +86026,7 @@ self: {
      mkDerivation {
        pname = "libjenkins";
        version = "0.8.1";
-       sha256 = "00h4wzzs6b3s9cv4bw2slj3c0ckb6p8gph7wzx8cgrxjyjqqx85z";
+       sha256 = "bfa08eb1f4b2e7c750fffcc0fbd0356b32c086a45af045364b7a2ca3ffe70402";
        libraryHaskellDepends = [
          async attoparsec base bytestring conduit containers free
          http-client http-conduit http-types monad-control mtl network
@@ -85742,7 +86054,7 @@ self: {
      mkDerivation {
        pname = "liblastfm";
        version = "0.5.1";
-       sha256 = "1bf508a1rqjb486wcwn0n36bm8lwnj3b4bg0826lp92zmaxiyxpy";
+       sha256 = "fe761fbbaa5fa44b8d40e02db286b49ca2baccb0c072c60d224be21c1402c5ad";
        libraryHaskellDepends = [
          aeson base bytestring cereal containers crypto-api http-client
          http-client-tls network-uri profunctors pureMD5 semigroups text
@@ -85763,7 +86075,7 @@ self: {
      mkDerivation {
        pname = "liblinear-enumerator";
        version = "0.1.2";
-       sha256 = "19x0y70fn2pr06qsz4z6s67sym7dw5x3qa3z6jf3nmwncsy64qi2";
+       sha256 = "226262bc6696573b9c347f283c7ae1ed54af8fd1e693afb101f90aebc0f1a0a7";
        libraryHaskellDepends = [
          base bindings-DSL enumerator mtl vector
        ];
@@ -85778,7 +86090,7 @@ self: {
      mkDerivation {
        pname = "libltdl";
        version = "0.1.0.3";
-       sha256 = "05a4l841w20l4a0wmbp93bb1vc4kmnbcv7pmnym5hrrd7daj2vzr";
+       sha256 = "f96f21553b2d6758aab7f59ecd96ad93b01dd61ae9aeca812214081e08a24415";
        isLibrary = true;
        isExecutable = true;
        libraryHaskellDepends = [ base ];
@@ -85797,7 +86109,7 @@ self: {
      mkDerivation {
        pname = "libmpd";
        version = "0.9.0.2";
-       sha256 = "1q6lcp9gfzvzcsigv6958ng9c44kq68qh4amnszjjji0jq0lvdjz";
+       sha256 = "5fb64d0196204a29bfb655118891c19310969e452599fda2667f7ff7d265d4e0";
        libraryHaskellDepends = [
          attoparsec base bytestring containers data-default-class filepath
          mtl network old-locale text time utf8-string
@@ -85816,7 +86128,7 @@ self: {
      mkDerivation {
        pname = "libnotify";
        version = "0.1.1.0";
-       sha256 = "1wc19v14agadj7dzi81lm3qzk2x33apaj5ylmg7x232k56xzfvr0";
+       sha256 = "206ff7bb29530cd1cfabd417a9ae1aa38bf9f1a834a0f8db914d3d45c24e81f1";
        libraryHaskellDepends = [ base bytestring glib gtk ];
        librarySystemDepends = [ libnotify ];
        description = "Bindings to libnotify library";
@@ -85830,7 +86142,7 @@ self: {
      mkDerivation {
        pname = "libnvvm";
        version = "1.0.0";
-       sha256 = "00vblp869zyk8gr33b846rnvn9axlsbldhx1gkj14xgrlyambdmx";
+       sha256 = "bdb65595a7f97512e47ca1c34697a65d25bb6d3604ad31f243d3ff64d0a56b03";
        libraryHaskellDepends = [ base bytestring cuda ];
        librarySystemDepends = [ nvvm ];
        libraryToolDepends = [ c2hs ];
@@ -85849,7 +86161,7 @@ self: {
      mkDerivation {
        pname = "liboleg";
        version = "2010.1.10.0";
-       sha256 = "1lv0il1psy8bfdxc76ivc5nlwga4m475gys1g0ia3wacdksgs7a6";
+       sha256 = "461dfdf46c4cf1a1227841fb570ea9443d4e6d613b9ac37a730b797d038d60d3";
        libraryHaskellDepends = [
          base CC-delcont containers mtl template-haskell unix
        ];
@@ -85864,7 +86176,7 @@ self: {
      mkDerivation {
        pname = "libpafe";
        version = "0.1.1.0";
-       sha256 = "1l2s98y805mgxnwy2jvrab65gz1aq5zf48rqk88nclb97w04lnws";
+       sha256 = "9a5b4a003f695166119a3823e27ec12afc57cc52794be1b9edaf16803c4a5ad0";
        libraryHaskellDepends = [ base transformers ];
        librarySystemDepends = [ pafe ];
        testHaskellDepends = [ base bytestring iconv transformers ];
@@ -85879,7 +86191,7 @@ self: {
      mkDerivation {
        pname = "libpq";
        version = "0.4.1";
-       sha256 = "11s8zaxq7qwzqdgyfd3v7sk6vf5cq3wzv2j02g0gnri9w45wf2i7";
+       sha256 = "270ac70be12966fbc013408afdf9c0acb86da63e7b34e75fc39fe383bbfa4887";
        libraryHaskellDepends = [ base bytestring unix ];
        librarySystemDepends = [ postgresql ];
        homepage = "http://github.com/tnarg/haskell-libpq";
@@ -85893,7 +86205,7 @@ self: {
      mkDerivation {
        pname = "librandomorg";
        version = "0.0.1.0";
-       sha256 = "07xg59f48jw78mjbx83bz1rc2fxvdnlb08cdfd7hwkj43a127kxn";
+       sha256 = "b6cf23821a444e0e4f738d21b0a86dbb3bc172f86ba0be6445874b445c2aaf1f";
        libraryHaskellDepends = [ base bytestring curl ];
        jailbreak = true;
        homepage = "https://github.com/supki/haskell-random.org";
@@ -85909,7 +86221,7 @@ self: {
      mkDerivation {
        pname = "librato";
        version = "0.2.0.1";
-       sha256 = "1l0q8kx0v563glplz5blg5scnvwf1aak04w08abxkrbfdjq6a8z4";
+       sha256 = "e42365b06c6ee5d99742801330950a8e6fcb747974954f2f7dc3940dfa4418d0";
        libraryHaskellDepends = [
          aeson attoparsec base bytestring either http-client http-conduit
          http-types mtl resourcet text unordered-containers uri-templater
@@ -85927,7 +86239,7 @@ self: {
      mkDerivation {
        pname = "libravatar";
        version = "0.1.0.1";
-       sha256 = "00rdnhxwp1h4ax3cwlmqa6digzl1b8br5ajg7k0dsydb9ik171x5";
+       sha256 = "a58713664cab79ddc03c4faa92175a81fe179b51b852ce46570486cb3bb42d03";
        libraryHaskellDepends = [
          base bytestring crypto-api dns network-uri pureMD5 random SHA url
          utf8-string
@@ -85944,7 +86256,7 @@ self: {
      mkDerivation {
        pname = "libssh2";
        version = "0.2.0.3";
-       sha256 = "0xfdhszz4j98spmzwxwcjnm3kzjkg76bwszmky0lmx9zmqirzakw";
+       sha256 = "7caa9f23ae3ff54a819ff56bbecc7953fe39aa958c77feebd52849f2bf86cd75";
        isLibrary = true;
        isExecutable = true;
        libraryHaskellDepends = [ base bytestring network syb time ];
@@ -85963,7 +86275,7 @@ self: {
      mkDerivation {
        pname = "libssh2-conduit";
        version = "0.1";
-       sha256 = "1zpcj6qwc4kpdcgdqlzspzwz99a990f3r5wpl13l54j8c1g0kc8h";
+       sha256 = "10b1095e6048924247a097973c1c4849a5f4f9bffa53dc1e6b7712c6b191ecfe";
        libraryHaskellDepends = [
          base conduit libssh2 monad-control stm transformers
        ];
@@ -85980,7 +86292,7 @@ self: {
      mkDerivation {
        pname = "libstackexchange";
        version = "0.3.0.0";
-       sha256 = "00v8hmk67dsb0j1bncc06fh46jkz4raf5a796l223mg6x0l3a828";
+       sha256 = "48203528e8e6d5210435e9a8e254267f4a43a0338031bb82044bb76366856803";
        libraryHaskellDepends = [
          aeson attoparsec base bytestring containers data-default
          http-conduit profunctors text
@@ -85997,7 +86309,7 @@ self: {
      mkDerivation {
        pname = "libsystemd-daemon";
        version = "0.1.0.1";
-       sha256 = "1rmzyca7ry30d6wvhv3k30jaksa3iw8kzk1rwp6gwclxizsvwgf0";
+       sha256 = "c03dbef58f9d32fecce539cc3f118f43e9a92418736cb8b96960f87c14f3bfe6";
        libraryHaskellDepends = [ base bytestring network utf8-string ];
        librarySystemDepends = [ systemd-daemon ];
        testHaskellDepends = [
@@ -86016,7 +86328,7 @@ self: {
      mkDerivation {
        pname = "libsystemd-journal";
        version = "1.3.3";
-       sha256 = "02d1zpmimmisjngkx9l23af51v18pdbc5mh7yljyw81lm39yzvfn";
+       sha256 = "d6edefd3a83420ee25f507d6c256bb28ec509c1a82a63e9f953ad61aebfda109";
        libraryHaskellDepends = [
          base bytestring hashable hsyslog pipes pipes-safe text transformers
          uniplate unix-bytestring unordered-containers uuid vector
@@ -86032,7 +86344,7 @@ self: {
      mkDerivation {
        pname = "libtagc";
        version = "0.12.0";
-       sha256 = "1f7r82cfrkxrqcrxk92y6zhk79qwpack2g67crww5q8hs7438vja";
+       sha256 = "4a6e34c8d110e1c27966c73c3199ba1ca733e1375ea4d933c3b9cfec9840f9b8";
        libraryHaskellDepends = [ base bytestring glib ];
        librarySystemDepends = [ taglib ];
        libraryPkgconfigDepends = [ taglib ];
@@ -86047,7 +86359,7 @@ self: {
      mkDerivation {
        pname = "libvirt-hs";
        version = "0.1";
-       sha256 = "0fgxvzzfw52s4hs838l0sr6lxln4bhqqhzzy6grww2fs27gjpb4c";
+       sha256 = "8cac2bdf11da09cef333fe7f88315cc4d24e4dd680a28134245a14eefedffd39";
        libraryHaskellDepends = [ base syb ];
        librarySystemDepends = [ virt ];
        libraryToolDepends = [ c2hs ];
@@ -86062,7 +86374,7 @@ self: {
      mkDerivation {
        pname = "libvorbis";
        version = "0.1.0.1";
-       sha256 = "0ykv2jv559yalypadwnvpzv87rksn24b4h8qi9x1x6r2x4kbwvrl";
+       sha256 = "346fbe26e9229b1e7a8a1841b288b07ae683f6bfdbf2a6aea7caa752b6147b7a";
        libraryHaskellDepends = [ base bytestring cpu ];
        homepage = "https://github.com/the-real-blackh/libvorbis";
        description = "Haskell binding for libvorbis, for decoding Ogg Vorbis audio files";
@@ -86074,7 +86386,7 @@ self: {
      mkDerivation {
        pname = "libxml";
        version = "0.1.1";
-       sha256 = "01zvk86kg726lf2vnlr7dxiz7g3xwi5a4ak9gcfbwyhynkzjmsfi";
+       sha256 = "d1e92affb41e7abe1c7b692aa24ae47dbcf3636f2753bb85a3469c370d9afb07";
        libraryHaskellDepends = [ base bytestring mtl ];
        librarySystemDepends = [ libxml2 ];
        description = "Binding to libxml2";
@@ -86089,7 +86401,7 @@ self: {
      mkDerivation {
        pname = "libxml-enumerator";
        version = "0.5";
-       sha256 = "0mqh454w1f3k75kcshdn848ynva938q6xm3a5yzcyf7nflzw75pg";
+       sha256 = "ef96c33f75f638cfbe2f6ad46e301a496deb1141b641cd663973b8c049211057";
        libraryHaskellDepends = [
          base bytestring enumerator libxml-sax text transformers xml-types
        ];
@@ -86104,7 +86416,7 @@ self: {
      mkDerivation {
        pname = "libxml-sax";
        version = "0.7.5";
-       sha256 = "0lbdq6lmiyrnzk6gkx09vvp928wj8qnqnqfzy14mfv0drj21f54r";
+       sha256 = "99141784cc0d6c5749f0df618b2d46922391eede09f4f9ccfc36fb58a9c16d51";
        libraryHaskellDepends = [ base bytestring text xml-types ];
        librarySystemDepends = [ libxml2 ];
        libraryPkgconfigDepends = [ libxml2 ];
@@ -86118,7 +86430,7 @@ self: {
      mkDerivation {
        pname = "libxslt";
        version = "0.1";
-       sha256 = "1szz8zkm1w8dbfgix3ii896sc4vljgivcgx8j7vpny4ci9sfmn5a";
+       sha256 = "aad8ea748a8c787bf791a83fb6e3937413a64d42318e1e9f5b0df150e747ffeb";
        libraryHaskellDepends = [ base bytestring libxml ];
        librarySystemDepends = [ xslt ];
        jailbreak = true;
@@ -86132,7 +86444,7 @@ self: {
      mkDerivation {
        pname = "life";
        version = "0.1";
-       sha256 = "0drsv1d0318yr7a0aa2j6kvsiyl8jj8h4z6wpdnrcyxw6z4qlssq";
+       sha256 = "586b8ac937bc7b966dbbdc7c02919488faa8f734522805d4c91e85015ad83a37";
        isLibrary = false;
        isExecutable = true;
        executableHaskellDepends = [ array base GLUT OpenGL random ];
@@ -86149,7 +86461,7 @@ self: {
      mkDerivation {
        pname = "lifted-async";
        version = "0.7.0.1";
-       sha256 = "0skfpgqlxni3bdn7pdg2732xkijmwsz655962wrbmflh987ms8y3";
+       sha256 = "c3235d0f4a90baba3217269562bee655c6d9c538e2b57b6c5b23da4ef1bb6e6a";
        libraryHaskellDepends = [
          async base constraints lifted-base monad-control transformers-base
        ];
@@ -86170,7 +86482,7 @@ self: {
      mkDerivation {
        pname = "lifted-base";
        version = "0.2.3.6";
-       sha256 = "1yz14a1rsgknwyl08n4kxrlc26hfwmb95a3c2drbnsgmhdyq7iap";
+       sha256 = "57c5837d83f569bb72136ca89256e50e1ac168ee935804a8e7763e9d8322e1fb";
        libraryHaskellDepends = [ base monad-control transformers-base ];
        testHaskellDepends = [
          base HUnit monad-control test-framework test-framework-hunit
@@ -86186,7 +86498,7 @@ self: {
      mkDerivation {
        pname = "lifted-threads";
        version = "1.0";
-       sha256 = "1sq071bn5z8ks2qj52bfx6n8bdx2chijh62ai3rz6lmjai6dazbz";
+       sha256 = "7f7dd54c54b252f3f3884a18282364a2b785ace96e8922b1d013fd62573800eb";
        libraryHaskellDepends = [
          base monad-control threads transformers-base
        ];
@@ -86202,7 +86514,7 @@ self: {
      mkDerivation {
        pname = "lifter";
        version = "0.1";
-       sha256 = "11c0j2mdrp4rvinl4iym9mfsqzh101yb5sf710vm8n7qih1fzcpc";
+       sha256 = "ecb2ef028cf858543708c7e9b27c00017eac5d4dd547426ddc99dcdcaa908085";
        isLibrary = false;
        isExecutable = true;
        executableHaskellDepends = [
@@ -86219,7 +86531,7 @@ self: {
      mkDerivation {
        pname = "ligature";
        version = "0.1.0.0";
-       sha256 = "03h30lbhppi9hmpsc8fhsrsad6w9sjs9n53lz76czz3iqaknkcrb";
+       sha256 = "2bb369a7c271fccfccf974149bb4d4899ba674d6d021a66f8529de0b1705030e";
        libraryHaskellDepends = [ base text ];
        jailbreak = true;
        description = "Expand ligatures in unicode text";
@@ -86231,7 +86543,7 @@ self: {
      mkDerivation {
        pname = "ligd";
        version = "0.2";
-       sha256 = "1hxfx514ar9hr9gqzzdgd7avfvlsvr7lv6hgza5k04b2xm73ysrp";
+       sha256 = "376b3f4eed6211308bfa0f9a4d4fde9a6eb7d569affd8f5fca30654542e9aec3";
        libraryHaskellDepends = [ base ];
        homepage = "https://github.com/spl/ligd";
        description = "Lightweight Implementation of Generics and Dynamics";
@@ -86245,7 +86557,7 @@ self: {
      mkDerivation {
        pname = "lighttpd-conf";
        version = "0.4";
-       sha256 = "085msb62wpqyc1sp4zbwbyn70k48p9k9cky9rxn93xm0gjsaydf8";
+       sha256 = "c835afb47ca0f6916ccfc94f9666ba884c70ac5f7c7d7275601e5f2eccd2b520";
        libraryHaskellDepends = [
          array base bytestring packedstring pretty template-haskell
        ];
@@ -86262,7 +86574,7 @@ self: {
      mkDerivation {
        pname = "lighttpd-conf-qq";
        version = "0.5";
-       sha256 = "1nd30inhh6wzq34rg76lq6m3wp0x3sc0l7jv37gw6dk3dnkwqh6q";
+       sha256 = "d840cca76d6336c3df195b1e0a981e1d5c3eaac1d49c97c9c09f1b086d04a3d9";
        libraryHaskellDepends = [
          array base bytestring haskell-src-exts lighttpd-conf
          template-haskell
@@ -86279,7 +86591,7 @@ self: {
      mkDerivation {
        pname = "lilypond";
        version = "1.9.0";
-       sha256 = "1nb6kkp5gbsbkjbbicyd49ckg2j9dm4a1l9ya4vp38br5j7dn4gw";
+       sha256 = "fc11db8e2c79a17137513ed1a0486d498a375922cdb3b8969c4baf57ee9c66d9";
        libraryHaskellDepends = [
          base data-default music-dynamics-literal music-pitch-literal
          prettify process semigroups vector-space
@@ -86296,7 +86608,7 @@ self: {
      mkDerivation {
        pname = "limp";
        version = "0.3.2.1";
-       sha256 = "0fx8q7ll47qc06laagiap0z4b5mbp958r3b9mc6qm1h9rhksimjk";
+       sha256 = "53d6a827cc09868a0dab698d8c4abaab96453eb82a3ea5a8010c1f42e9c1a83b";
        libraryHaskellDepends = [ base containers ];
        testHaskellDepends = [
          base containers QuickCheck tasty tasty-quickcheck tasty-th
@@ -86312,7 +86624,7 @@ self: {
      mkDerivation {
        pname = "limp-cbc";
        version = "0.3.2.1";
-       sha256 = "0q4az96nbwvm7jhrwvbjp87vzkb5nlp739jhkya6z0iq340cjxjy";
+       sha256 = "5e76c9001938826f949f50a6712eb565cdbf0fba726d9ea13c75f3654dfa8a60";
        libraryHaskellDepends = [ base containers limp vector ];
        libraryToolDepends = [ c2hs ];
        testHaskellDepends = [ base limp ];
@@ -86327,7 +86639,7 @@ self: {
      mkDerivation {
        pname = "lin-alg";
        version = "0.1.0.2";
-       sha256 = "19123k967mql69my6c19mnvp4qwa4b3bgimmlbhipqdljykj7pqc";
+       sha256 = "0cdf23a797b4e11be1a2b5c6b7c6228a6372b7ad2930e36b3214d763d21c22a4";
        libraryHaskellDepends = [ base NumInstances vector ];
        description = "Low-dimensional matrices and vectors for graphics and physics";
        license = stdenv.lib.licenses.bsd3;
@@ -86339,7 +86651,7 @@ self: {
      mkDerivation {
        pname = "linda";
        version = "0.1.2";
-       sha256 = "0d58i69hvry9vzr4i7f1yhhm99808vqw238hfjc3sr51plc1is45";
+       sha256 = "85e81818bda1643d9874100dc1f14600a55421f4c19d48f2dfc9e70d9389a834";
        libraryHaskellDepends = [ base hmatrix HUnit ];
        description = "LINear Discriminant Analysis";
        license = stdenv.lib.licenses.bsd3;
@@ -86350,7 +86662,7 @@ self: {
      mkDerivation {
        pname = "lindenmayer";
        version = "0.1.0.1";
-       sha256 = "07gz4lbvyzahffcp6f1f87zl20kf834iswh671vb8vxffigrz5y1";
+       sha256 = "c1979f5f74ae6fb4763806721dc9406e0241ff412e38739973507dbf1725ff1d";
        libraryHaskellDepends = [ base ];
        homepage = "https://github.com/reinh/hs-lindenmayer";
        description = "L-systems in Haskell";
@@ -86362,7 +86674,7 @@ self: {
      mkDerivation {
        pname = "line-break";
        version = "0.1.0.0";
-       sha256 = "01w5bk58n14vni6cb8rc4ri3hpgism1c78jk605927yf2llxnc14";
+       sha256 = "2430db2915ce1f910a3053a2c342d5f15d3862262ca3c54cb49b048bca5c8507";
        isLibrary = false;
        isExecutable = true;
        executableHaskellDepends = [ base ];
@@ -86375,7 +86687,7 @@ self: {
      mkDerivation {
        pname = "line2pdf";
        version = "0.0.7";
-       sha256 = "0x8kbjjd9i6gp0agdfsfgicj2z1g4jwj7axj4hq01c31wrzb6g95";
+       sha256 = "253db37ee661b0003024b2ab23b9242f7c21597c4ebbf614b8cfc4d4a45c1375";
        isLibrary = true;
        isExecutable = true;
        libraryHaskellDepends = [ base bytestring containers ];
@@ -86396,7 +86708,7 @@ self: {
      mkDerivation {
        pname = "linear";
        version = "1.19.1.3";
-       sha256 = "1hprmhs1nm6l81kpnnznz92l66j10z4asn3g3l9c47165q881592";
+       sha256 = "229580102e261cc2121d6f58adc807411a4345faf65b7b6740d4541b34acf9c2";
        libraryHaskellDepends = [
          adjunctions base binary bytes cereal containers deepseq
          distributive ghc-prim hashable lens reflection semigroupoids
@@ -86417,7 +86729,7 @@ self: {
      mkDerivation {
        pname = "linear-accelerate";
        version = "0.2";
-       sha256 = "0433mzw2cswk86nmj3gnygn3d07yq0sbmv2ylxbw8ri35yddjap6";
+       sha256 = "e62ad99a2f2366c457a75eecba34c0fe8036ecf3f60d59ad41936b26f8af6310";
        libraryHaskellDepends = [ accelerate base lens linear ];
        homepage = "http://github.com/ekmett/linear-accelerate/";
        description = "Instances to use linear vector spaces on accelerate backends";
@@ -86431,7 +86743,7 @@ self: {
      mkDerivation {
        pname = "linear-algebra-cblas";
        version = "0.1";
-       sha256 = "1wsan17zrlg4kr9dwk23ggfvylignnmg4sa62krri45s925kvh3i";
+       sha256 = "71c03d8b48ba9098f3144669f2aab52f52bfdd7b434cde529ee4d1fc4fb04af3";
        isLibrary = true;
        isExecutable = true;
        libraryHaskellDepends = [
@@ -86451,7 +86763,7 @@ self: {
      mkDerivation {
        pname = "linear-grammar";
        version = "0.0.2.1";
-       sha256 = "00vfhcqhg6azb1ay12n248l0bjg5g0c5y5ybz5rqf2jdlab7fg97";
+       sha256 = "273d7796a24d0a8773f9cb175f1878e5c9052822c28ae055585f990731836e03";
        libraryHaskellDepends = [ base containers QuickCheck ];
        testHaskellDepends = [ base containers hspec QuickCheck ];
        description = "A simple grammar for building linear equations and inclusive inequalities";
@@ -86463,7 +86775,7 @@ self: {
      mkDerivation {
        pname = "linear-maps";
        version = "0.6.1";
-       sha256 = "0671px94wvqg2yyc8qhjcwrv5k2ifwp5mrj7fkcwlwvg8w1bp19k";
+       sha256 = "3385bb02476f73cad97447e65a2e7751ccb233671262c4bc170f6f4e52bfe118";
        isLibrary = true;
        isExecutable = true;
        libraryHaskellDepends = [ base containers HUnit ];
@@ -86479,12 +86791,11 @@ self: {
      }:
      mkDerivation {
        pname = "linear-opengl";
-       version = "0.2.0.8";
-       sha256 = "18yy35pcl4jg0albh9dhngi7q4ak40fzr6ypa2piz2di4zqhfqp6";
+       version = "0.2.0.9";
+       sha256 = "d07378f189641577cb6229dd3812ba9786394c35a16bf21ab3d01b3b5640178d";
        libraryHaskellDepends = [
          base distributive lens linear OpenGL OpenGLRaw tagged
        ];
-       jailbreak = true;
        homepage = "http://www.github.com/bgamari/linear-opengl";
        description = "Isomorphisms between linear and OpenGL types";
        license = stdenv.lib.licenses.bsd3;
@@ -86495,7 +86806,7 @@ self: {
      mkDerivation {
        pname = "linear-vect";
        version = "0.1.1.0";
-       sha256 = "0i6z10pgqcykkygl6kq63phx5hvwi2d84j2f5vw4nrnic59sm9jy";
+       sha256 = "5ea6aa5361d1664bf82e4e48829a887cc3d2e11d064f439f9fd333fc2e08df44";
        libraryHaskellDepends = [ base random ];
        jailbreak = true;
        homepage = "https://github.com/capsjac/linear-vect";
@@ -86508,7 +86819,7 @@ self: {
      mkDerivation {
        pname = "linearEqSolver";
        version = "1.3";
-       sha256 = "0bszi1k27ag4yk31zxkn3jk3cqh1xzdcscm4nb6k4n0psf0qm2rp";
+       sha256 = "378b8a81d3175832cdb2a432cddaef016236a61c76f61fc6f4e4a92366885f2f";
        libraryHaskellDepends = [ base sbv ];
        homepage = "http://github.com/LeventErkok/linearEqSolver";
        description = "Use SMT solvers to solve linear systems over integers and rationals";
@@ -86520,7 +86831,7 @@ self: {
      mkDerivation {
        pname = "linearscan";
        version = "0.7.0";
-       sha256 = "13sfwkjg94q47lfxw5zddi8xpf4az07g88yq5pvgnh3vs5xggwip";
+       sha256 = "37f2f77ad17b40fbf62dd823f40ef88ab8db516ced17de1d3d0493f4e4e44e8f";
        libraryHaskellDepends = [
          base containers ghc-prim mtl transformers
        ];
@@ -86538,7 +86849,7 @@ self: {
      mkDerivation {
        pname = "linearscan-hoopl";
        version = "0.7.0";
-       sha256 = "1zvzgcj5yln6g3mqljgcyjpjj2visiigd7qwl70l1zclz5zcfynv";
+       sha256 = "db7ac77ef994fd40c1a11c9ff662d4710b29aff4ec498aeb78c6525f247b7fff";
        libraryHaskellDepends = [
          base containers free hoopl linearscan QuickCheck transformers
        ];
@@ -86558,7 +86869,7 @@ self: {
      mkDerivation {
        pname = "linebreak";
        version = "1.0.0.3";
-       sha256 = "1fds2mgsijfsc96dq95skn562iv2r341zr7v0qsz48y9fh97s3p7";
+       sha256 = "e70e7d1274c923f23506fbe41fc8c86247618a9dba24dc4c62dac9a85f15bab9";
        libraryHaskellDepends = [ base hyphenation ];
        homepage = "http://ariis.it/static/articles/linebreak/page.html";
        description = "breaks strings to fit width";
@@ -86570,7 +86881,7 @@ self: {
      mkDerivation {
        pname = "linguistic-ordinals";
        version = "0.1.0.0";
-       sha256 = "0adcdxf0lxc372j12fk87klyrgr3b42sas6f1smiyza4wicjp9h3";
+       sha256 = "03a62b59e4447d1fab0ece68a5055923bfece93c683a11a43883750a5c6fac29";
        libraryHaskellDepends = [ base text ];
        jailbreak = true;
        homepage = "http://github.com/argiopetech/linguistic-ordinals";
@@ -86584,7 +86895,7 @@ self: {
      mkDerivation {
        pname = "linkchk";
        version = "0.0.2";
-       sha256 = "0fzszn8nb5kglg4s5hk9k51vdkarlc08bdp67rbrj0cwfxpkn6wd";
+       sha256 = "8d1b3b6f779c0199573ee6b68500a359cdb6439969c2a2c9a36f966591fdfa3b";
        isLibrary = false;
        isExecutable = true;
        executableHaskellDepends = [
@@ -86601,7 +86912,7 @@ self: {
      mkDerivation {
        pname = "linkcore";
        version = "0.4.1";
-       sha256 = "0m1jwqa3vbiyzcdrn1h63dm0709j5xijm00j2x7dpwgn8k92iq81";
+       sha256 = "01e128d244f6f1db4e1712802a632f3281036a1b06069b1bfb3eae3d14e63254";
        isLibrary = false;
        isExecutable = true;
        executableHaskellDepends = [
@@ -86619,7 +86930,7 @@ self: {
      mkDerivation {
        pname = "linkedhashmap";
        version = "0.4.0.0";
-       sha256 = "1bv39g9vivr3j8arnpla39dhnwaja5l9da2yw580pzmw5bqi0wyq";
+       sha256 = "d87310f12abcfe0b50e15ea896685152710b5b1a8a5e9b159223efb8d34b63af";
        libraryHaskellDepends = [
          base containers deepseq hashable unordered-containers
        ];
@@ -86639,7 +86950,7 @@ self: {
      mkDerivation {
        pname = "linklater";
        version = "3.2.0.0";
-       sha256 = "15c6p63yd1g5if2nz9pig6kc0rvqpjixjs6zr2j9m16q0h6kgrfr";
+       sha256 = "d9e5370d04d8849aa4c8df68d9a3bc7867c0a679f1a66f858be585e687b98695";
        libraryHaskellDepends = [
          aeson base base-prelude bytestring containers http-types text wai
          wreq
@@ -86656,7 +86967,7 @@ self: {
      mkDerivation {
        pname = "linux-blkid";
        version = "0.2.0.0";
-       sha256 = "06f7zwb40zgps6503cyp65c68181gj3s9q1s6vh43y6najiimzqx";
+       sha256 = "1dff1aa354d6f841e0363ae0a4877c0105645831d7b3018ad1f77d4016ffc719";
        libraryHaskellDepends = [
          base monad-control transformers transformers-base
        ];
@@ -86672,7 +86983,7 @@ self: {
      mkDerivation {
        pname = "linux-cgroup";
        version = "0.1.1.2";
-       sha256 = "0dd1ii1n6y9frilnkxikzahp9xrh3i334i7syvd8fyxp51dpzgy1";
+       sha256 = "c1bf7f5b28b77b87daf6fa4432461c30f774a1fa33f66969cc2e7963438ca135";
        libraryHaskellDepends = [ base filepath ];
        jailbreak = true;
        description = "Very basic interface to the Linux CGroup Virtual Filesystem";
@@ -86684,7 +86995,7 @@ self: {
      mkDerivation {
        pname = "linux-evdev";
        version = "0.3.1";
-       sha256 = "1zx5m0446rkbbj43m1f110a7jvl7vd7wkhikqql608a0jzqr7bk0";
+       sha256 = "60ae93f19740216028c633c2c94fdb876e791408c1853a885c6b664308a8a5ff";
        libraryHaskellDepends = [ base bytestring time unix ];
        homepage = "http://github.com/bgamari/linux-evdev";
        description = "Bindings to Linux evdev input device interface";
@@ -86696,7 +87007,7 @@ self: {
      mkDerivation {
        pname = "linux-file-extents";
        version = "0.2.0.0";
-       sha256 = "1l4vznam1a8vf3nixhbmw38rpzkvmbka0cbdfdsgfrpn03kxjz3c";
+       sha256 = "6c7cd9e700f666f774736d31a0e6aa7bfe9bd1e075c11eed701ba95095fd9bd0";
        isLibrary = true;
        isExecutable = true;
        libraryHaskellDepends = [ base unix ];
@@ -86710,7 +87021,7 @@ self: {
      mkDerivation {
        pname = "linux-inotify";
        version = "0.2.0.1";
-       sha256 = "1970v1zkbp45amylmg79bbdfhk8kg6vzxjznd76gfl5kff2cv12r";
+       sha256 = "5984cd8473b350f7cc69f6cbfeb779134de8da5ae9bc4a7d5585dc357fd8e0a4";
        libraryHaskellDepends = [ base bytestring hashable unix ];
        description = "Thinner binding to the Linux Kernel's inotify interface";
        license = stdenv.lib.licenses.bsd3;
@@ -86721,7 +87032,7 @@ self: {
      mkDerivation {
        pname = "linux-kmod";
        version = "0.1.0.1";
-       sha256 = "1vqbibp93fw6r03v5q2cisya6m12xb12rad11myxrkbn29rjmhws";
+       sha256 = "9ac32a731276cddc7d0da1a92cc2ea2254a3bc8e4ce0b207c886bb91ee8a0bef";
        libraryHaskellDepends = [ base directory ];
        libraryPkgconfigDepends = [ libkmod ];
        homepage = "https://github.com/tensor5/linux-kmod";
@@ -86735,7 +87046,7 @@ self: {
      mkDerivation {
        pname = "linux-mount";
        version = "0.2.0.1";
-       sha256 = "12bwrniaxg6gm347jdgbf535pdz4z57pkyiwa98c903y9q9ssnyi";
+       sha256 = "d15bad134e7e80c450523cfa794ff9e4b75b4671eb3579c8a8cfbcaea2cd7c89";
        libraryHaskellDepends = [ base bytestring ];
        homepage = "https://github.com/tensor5/linux-mount";
        description = "Mount and unmount filesystems";
@@ -86747,7 +87058,7 @@ self: {
      mkDerivation {
        pname = "linux-namespaces";
        version = "0.1.2.0";
-       sha256 = "0yznnp9rdz15drm79pvbqbrbk2nczbkmlf00pb7rki7w1l9njp2q";
+       sha256 = "585c69130dfcc499cfba00385ae7facc8ab9f2c26bdf746a6e25fc96d3b5f67b";
        libraryHaskellDepends = [ base unix ];
        homepage = "https://github.com/redneb/hs-linux-namespaces";
        description = "Create new or enter an existing linux namespaces";
@@ -86761,7 +87072,7 @@ self: {
      mkDerivation {
        pname = "linux-perf";
        version = "0.3";
-       sha256 = "18akjagbqw2fswrnp4ifzivwdwsbny28kvnm0hfc1ysyy9id8511";
+       sha256 = "2114d462f25efbc01c04d5ee8984b74bf3c677fc2e926b33d74e70bc9e9253a1";
        isLibrary = true;
        isExecutable = true;
        libraryHaskellDepends = [
@@ -86785,7 +87096,7 @@ self: {
      mkDerivation {
        pname = "linux-ptrace";
        version = "0.1.2";
-       sha256 = "0hzniy9vlycbsqkrr9xxdgnx070h5v6jz4gqx7rc60a3q0hqn43m";
+       sha256 = "75108b21c04301c3f2e9f8912fcd2e101cd0ed6bbda79c27d68b79ba938ff643";
        libraryHaskellDepends = [
          base bytestring mmap posix-waitpid process template-haskell unix
        ];
@@ -86800,7 +87111,7 @@ self: {
      mkDerivation {
        pname = "linux-xattr";
        version = "0.1.1.0";
-       sha256 = "0rpq5sm557gm227id2rfsffgr47lrj4d4kpzh194d74dx2qkg5g6";
+       sha256 = "e69537b1e88d9c465280ff4ed288ccf490fc9cd32e8b168f10f59d52aa2ef866";
        libraryHaskellDepends = [ base bytestring ];
        homepage = "https://github.com/tensor5/linux-xattr";
        description = "Read, set and list extended attributes";
@@ -86814,7 +87125,7 @@ self: {
      mkDerivation {
        pname = "linx-gateway";
        version = "0.1.0.2";
-       sha256 = "0diacwvxpq2iyfzlcmdqrbfndhmlmgzq9hvxlyp12idlzwa9p1cq";
+       sha256 = "98859b14ffb44511aea77dc384ffabb4c266ddcab85546bff351e0db37672a36";
        isLibrary = true;
        isExecutable = true;
        libraryHaskellDepends = [ base binary bytestring network ];
@@ -86834,7 +87145,7 @@ self: {
      mkDerivation {
        pname = "lio";
        version = "0.11.5.0";
-       sha256 = "10miy18x1898dcq58bnk0md3ymw9ckh9j26grsr6w3jqnvw69712";
+       sha256 = "229c64f8b6580e6eb2cecf0899e06489573f5a05d32e54306b28a1d051f0b182";
        libraryHaskellDepends = [ base bytestring containers hashable ];
        description = "Labeled IO Information Flow Control Library";
        license = "GPL";
@@ -86847,7 +87158,7 @@ self: {
      mkDerivation {
        pname = "lio-eci11";
        version = "0.2";
-       sha256 = "11vl27kn0wdxndkwn3yvxd6kg9jv0lilxpvx2hkax37lq3x15rc8";
+       sha256 = "88e512fac0f48cae26147ddf4e23055ba6374debdb0fcb67b3bd7160e7117487";
        libraryHaskellDepends = [
          array base bytestring containers dclabel-eci11 directory filepath
          mtl old-time SHA time unix
@@ -86864,7 +87175,7 @@ self: {
      mkDerivation {
        pname = "lio-fs";
        version = "0.0.1.2";
-       sha256 = "1zzxsr0kg3bxm2wzhsqw2irk5myzshgqhr3fxi062hzw2rh0nqn9";
+       sha256 = "c9620b6016fc436140ec6e64881fd4dfd73273141c6bf8b9a87d8d3741d6fdff";
        libraryHaskellDepends = [
          base bytestring containers directory filepath lio SHA unix xattr
        ];
@@ -86880,7 +87191,7 @@ self: {
      mkDerivation {
        pname = "lio-simple";
        version = "0.0.2.2";
-       sha256 = "1nddiakk6b9biay6ijnc48dxcfgpi9vx4g6a8r9vz6cjh6mh0154";
+       sha256 = "a40400ab819299bf5346ca3cd2778af739d61b22ccca68bc8a2b2d33a78aadd9";
        isLibrary = true;
        isExecutable = true;
        libraryHaskellDepends = [
@@ -86903,7 +87214,7 @@ self: {
      mkDerivation {
        pname = "lipsum-gen";
        version = "0.1.0.2";
-       sha256 = "07bkxv6cmjf75jy31gbzs4nkjlynhkg8qv2idl71xilgzpnalk3c";
+       sha256 = "6c4caaecfd8fc61e0e6d516c8cde84d653392dd17fbd30bc2cc7c9caccee731d";
        libraryHaskellDepends = [ base QuickCheck ];
        jailbreak = true;
        description = "Generators for random sequences of English-like nonsense text";
@@ -86920,7 +87231,7 @@ self: {
      mkDerivation {
        pname = "liquid-fixpoint";
        version = "0.3.0.1";
-       sha256 = "00s5ch8i96nqjy2kq6y3i25mji3ld6z8121ngpbz87zbgp3zwhaw";
+       sha256 = "5c41fec77deb1ff4d77d368880be697444598b88c31b3c8597d89a1411644503";
        isLibrary = true;
        isExecutable = true;
        libraryHaskellDepends = [
@@ -86955,7 +87266,7 @@ self: {
      mkDerivation {
        pname = "liquidhaskell";
        version = "0.4.1.1";
-       sha256 = "1yxg6zii0mbsri5j37k2s976nyglijyjfgz9vwafiqdrca328z4s";
+       sha256 = "9a7c248662b9e1e814dfe93f27bd8cf4796b4ed2629e214bcc7a5510e337affb";
        isLibrary = true;
        isExecutable = true;
        libraryHaskellDepends = [
@@ -86987,7 +87298,7 @@ self: {
      mkDerivation {
        pname = "lispparser";
        version = "0.3.1";
-       sha256 = "1hj5fwmzxp2gw2gx86wa1fy36jmmh3sf8kd4acc8x0rghpmlw0w8";
+       sha256 = "88034eeb852f838e1853a44de4f480b54a33bc0b8a1bd49fe04fdcfe2b7745c2";
        libraryHaskellDepends = [ base parsec ];
        description = "Simple parser for LISP S-expressions";
        license = stdenv.lib.licenses.bsd3;
@@ -86998,7 +87309,7 @@ self: {
      mkDerivation {
        pname = "list-extras";
        version = "0.4.1.4";
-       sha256 = "15vjk6y3zwiffm1x8wlzv6203ykzm2phalqlq4zhmhcj2wd70viw";
+       sha256 = "3c6e701a1792c10a3fc1145305afa87ffa0184d99f72d443752ef23fbc997297";
        libraryHaskellDepends = [ base ];
        homepage = "http://code.haskell.org/~wren/";
        description = "Common not-so-common functions for lists";
@@ -87010,7 +87321,7 @@ self: {
      mkDerivation {
        pname = "list-fusion-probe";
        version = "0.1.0.3";
-       sha256 = "1djmh6bwnmp64vwq5f5j4f54ygrjkl56gp0la06yxknyvyn9k8jp";
+       sha256 = "57a299acdfdeceee0d5014dc670a9d323f4f8a23b2b882f926e656cb978155b6";
        libraryHaskellDepends = [ base ];
        testHaskellDepends = [ base tasty tasty-hunit ];
        description = "testing list fusion for success";
@@ -87022,7 +87333,7 @@ self: {
      mkDerivation {
        pname = "list-grouping";
        version = "0.1.1";
-       sha256 = "0w9f68cr4k0p8zl81y8ax19i6ypzks0y27hdlz71wwmgn5v2y63l";
+       sha256 = "74182f76b1af721ecea70d1ee1819eff7a1353e80af980e847174c9219322e71";
        libraryHaskellDepends = [ base ];
        homepage = "http://coder.bsimmons.name/blog/2009/08/list-grouping-module-released/";
        description = "Functions for grouping a list into sublists";
@@ -87034,7 +87345,7 @@ self: {
      mkDerivation {
        pname = "list-mux";
        version = "1.0";
-       sha256 = "147zb156g79a5p1w0b9vcvjy5x7nsrhng5rgjqq3cy3xpbam4nys";
+       sha256 = "da5b52d5ba7d783630962f976761d6f6f4e2e5663b2dc0c32d2a9d674a58ff90";
        libraryHaskellDepends = [ base ];
        jailbreak = true;
        homepage = "http://github.com/hellertime/list-mux";
@@ -87051,7 +87362,7 @@ self: {
      mkDerivation {
        pname = "list-remote-forwards";
        version = "0.0.1";
-       sha256 = "1bq5244ys4xy3pfj72dq399x0g57q41lrllbd5hgvk9z0j92lxys";
+       sha256 = "da772a92043fcdfd60698bd24c03c1a73cd0531ab88923dd1dbe13ed091105af";
        isLibrary = false;
        isExecutable = true;
        executableHaskellDepends = [
@@ -87075,7 +87386,7 @@ self: {
      mkDerivation {
        pname = "list-t";
        version = "0.4.5.1";
-       sha256 = "0mf1dv0pcbc2sgnimjkhmivl32ivjck7arhkq679s1ba5hc6np3a";
+       sha256 = "6a5c6b182c6a059d8ec113667526933b8a4177ac70ca1aedd3822d76c16ec155";
        libraryHaskellDepends = [
          base-prelude mmorph monad-control mtl transformers
          transformers-base
@@ -87094,7 +87405,7 @@ self: {
      mkDerivation {
        pname = "list-t-attoparsec";
        version = "0.4.0.2";
-       sha256 = "02sr57qpw8r38s9hb0wj0pik7x4rqgs51hl4s1mmnihgdflm0jb1";
+       sha256 = "614950a96b0f465b6bd084c250f4c399f433e305928305934623237ef129590b";
        libraryHaskellDepends = [
          attoparsec base-prelude either list-t text transformers
        ];
@@ -87110,22 +87421,21 @@ self: {
     ({ mkDerivation, base-prelude, case-insensitive, conversion
      , conversion-case-insensitive, conversion-text, either, hspec
      , html-entities, html-tokenizer, list-t, list-t-attoparsec
-     , list-t-text, mtl-prelude, text
+     , list-t-text, mtl-prelude, text, xml-types
      }:
      mkDerivation {
        pname = "list-t-html-parser";
-       version = "0.4.0.0";
-       sha256 = "1i243xa52ljqr79zccybx3x5nb58lvsfq4q99n2kk2qyhwyv7wb5";
+       version = "0.4.1.1";
+       sha256 = "42f9b2c5e77acfa154a56ac538b29888d943d451487a45a70040d32458c24f27";
        libraryHaskellDepends = [
          base-prelude case-insensitive conversion
          conversion-case-insensitive conversion-text either html-entities
-         html-tokenizer list-t mtl-prelude text
+         html-tokenizer list-t mtl-prelude text xml-types
        ];
        testHaskellDepends = [
-         base-prelude conversion conversion-text hspec html-tokenizer
-         list-t-attoparsec list-t-text text
+         base-prelude conversion conversion-text either hspec html-tokenizer
+         list-t-attoparsec list-t-text text xml-types
        ];
-       jailbreak = true;
        homepage = "https://github.com/nikita-volkov/list-t-html-parser";
        description = "Streaming HTML parser";
        license = stdenv.lib.licenses.mit;
@@ -87139,7 +87449,7 @@ self: {
      mkDerivation {
        pname = "list-t-http-client";
        version = "0.1.0.1";
-       sha256 = "02wxqsfixzv7ccznydp3vij7maqvxhsbailakij2fcfrf2acw3g2";
+       sha256 = "e20dce9470d93127649c8a46b534ec1bab7a64dce3366f3f6367ff1e9dc69d0b";
        libraryHaskellDepends = [
          base-prelude bytestring http-client list-t mtl-prelude
        ];
@@ -87155,7 +87465,7 @@ self: {
      mkDerivation {
        pname = "list-t-libcurl";
        version = "0.3.0.0";
-       sha256 = "1hcgxr87q7k6ixisj4p4gghm7nqb1l7bg361rcnqxf1145xmyyr5";
+       sha256 = "257b5f7b2121b88e2dcbc18cb70e0d0bdb53e17be412a9638f661e7c50ee8fc1";
        libraryHaskellDepends = [
          base base-prelude bytestring curlhs either list-t mtl-prelude
          resource-pool stm
@@ -87172,7 +87482,7 @@ self: {
      mkDerivation {
        pname = "list-t-text";
        version = "0.2.0.2";
-       sha256 = "1hsbisvmjprfzhqlhzmicxzyv67ylik0dazl4yjyilh8frjd7qlm";
+       sha256 = "95e2d3647608d2e8a527f4ab0666a4fe98ed7f67b17e4831fc2e5f59b78e4bc3";
        libraryHaskellDepends = [
          base-prelude bytestring list-t mtl-prelude text
        ];
@@ -87190,7 +87500,7 @@ self: {
      mkDerivation {
        pname = "list-tries";
        version = "0.6.1";
-       sha256 = "06li8zwhy3i3shgqrq4505af1b1dz9xpzx2lpx2has4p79bgd1mq";
+       sha256 = "b886f6563a97680545bf54f47f7bfa2dace0540185e08c1fd4230e0ff947911a";
        isLibrary = true;
        isExecutable = true;
        libraryHaskellDepends = [ base binary containers dlist ];
@@ -87205,7 +87515,7 @@ self: {
      mkDerivation {
        pname = "listlike-instances";
        version = "0.2.3.1";
-       sha256 = "0mkhnqn7wxspzxvivhaksxmxp7d6x9bazhl28nl9gck56bpa90sm";
+       sha256 = "5583a4ee3265b297a84582c2af56eaa69ddb6bd753c11d77ff57777e2cb67056";
        libraryHaskellDepends = [ base bytestring ListLike text vector ];
        jailbreak = true;
        homepage = "http://jwlato.webfactional.com/haskell/listlike-instances";
@@ -87219,7 +87529,7 @@ self: {
      mkDerivation {
        pname = "lists";
        version = "0.4.2";
-       sha256 = "0qjziksh6gl6v8rzvqajkcbakbby5j3i4z2jk6w6zs89b93rwnln";
+       sha256 = "965a9e475a09e96fb899527c12872c7eada9169b52e1fd33da863e03f58c5f62";
        libraryHaskellDepends = [ base list-extras split ];
        description = "Functions for dealing with lists";
        license = stdenv.lib.licenses.bsd3;
@@ -87230,7 +87540,7 @@ self: {
      mkDerivation {
        pname = "listsafe";
        version = "0.1.0.1";
-       sha256 = "0scd74fv6gzl7yi5ssb1z9kwwfyx9p39yqprnzbpvspvxm3k41qs";
+       sha256 = "1a073247edfbea7dd7b7f9629fc64ddd3bce67fa61695da23ff43fb31d398d69";
        libraryHaskellDepends = [ base exceptions ];
        homepage = "https://github.com/ombocomp/listsafe";
        description = "Safe wrappers for partial list functions, supporting MonadThrow";
@@ -87245,7 +87555,7 @@ self: {
      mkDerivation {
        pname = "lit";
        version = "0.1.0.5";
-       sha256 = "0xnbifi0g1kmxi88l9f77ypkgmdvhi69vy3fycbxwn926gc12v1r";
+       sha256 = "396c11d8332259de17f36ef89d4c84bbd537af3fc7258a50ec758607a28bcb76";
        isLibrary = false;
        isExecutable = true;
        executableHaskellDepends = [
@@ -87263,7 +87573,7 @@ self: {
      mkDerivation {
        pname = "literals";
        version = "1.0";
-       sha256 = "06n4svp0qss78l8827qmppmd63877wq01d6w9xagd10vn3c4hs2j";
+       sha256 = "526848d8b01b84f6544fdcb400303f070dd3eabd151f811045476b0ceed6c41a";
        libraryHaskellDepends = [ base ];
        description = "Non-overloaded functions for concrete literals";
        license = stdenv.lib.licenses.mit;
@@ -87281,7 +87591,7 @@ self: {
      mkDerivation {
        pname = "live-sequencer";
        version = "0.0.4";
-       sha256 = "04n8s2p772ylzfjpclbrq01im0j9rlp0xd37i8jshll7r51iz66l";
+       sha256 = "d4981f43c98752a8258a67b40e2ecd49821a03c0795176a5fbd48b73aed0c812";
        isLibrary = true;
        isExecutable = true;
        libraryHaskellDepends = [ base event-list non-negative ];
@@ -87304,7 +87614,7 @@ self: {
      mkDerivation {
        pname = "ll-picosat";
        version = "0.1.0.0";
-       sha256 = "0393ccnlink30492aw1gyv4jzd7rsckd8ymkm1wgbpma13vkf67h";
+       sha256 = "f01837f708aadef578a8b37ad426d3f9b42fc9f62f7025120163da482d63230d";
        libraryHaskellDepends = [ base ];
        librarySystemDepends = [ picosat ];
        jailbreak = true;
@@ -87317,7 +87627,7 @@ self: {
      mkDerivation {
        pname = "llrbtree";
        version = "0.1.1";
-       sha256 = "057bp1f1mpzlgg408b02x1bdzsixrrkcl1536nyvhp43rvxmgj61";
+       sha256 = "c1c857fbce835cb8bd35a304ca66ce3deadf56e8022c04c87bf4df1a5cb8eb14";
        libraryHaskellDepends = [ base ];
        description = "Purely functional sets and heaps";
        license = stdenv.lib.licenses.bsd3;
@@ -87331,7 +87641,7 @@ self: {
      mkDerivation {
        pname = "llsd";
        version = "0.2.0.0";
-       sha256 = "1v1yaaj02qk6z58kiz3g7dr9cik8141vv409cyxlzqv1k79rpzrg";
+       sha256 = "2fff9bd39961e34fbb670990bd0309684696723b6ffc3851f9666201a4523eec";
        isLibrary = true;
        isExecutable = true;
        libraryHaskellDepends = [
@@ -87353,7 +87663,7 @@ self: {
      mkDerivation {
        pname = "llvm";
        version = "3.2.0.2";
-       sha256 = "11k1m80vg9x6fgiyh9gxzl1i2i0l0jw9hbn3gs1d1dd7avzl9mrr";
+       sha256 = "39d744ff56a7b5d0827ec32e98b80414441103fdfd25e8e373a6a7b701aa6186";
        libraryHaskellDepends = [
          base bytestring containers directory llvm-base mtl process
          type-level
@@ -87374,7 +87684,7 @@ self: {
      mkDerivation {
        pname = "llvm-analysis";
        version = "0.3.0";
-       sha256 = "0jck1c9wy11wjss6aji64jw927mrncwd2nmnq65zq85r5hha3m8k";
+       sha256 = "13d5a1202cb920fc8bc1b65ad138b3b91e91b824264a65b4963c04cf130b9349";
        libraryHaskellDepends = [
          array base boomerang bytestring containers deepseq directory
          failure fgl filemanip filepath GenericPretty graphviz hashable
@@ -87395,7 +87705,7 @@ self: {
      mkDerivation {
        pname = "llvm-base";
        version = "3.2.0.2";
-       sha256 = "1f76nb85hnidp06v6lbl4aasac4h7ff9r8i054m8cnby2vc59r4n";
+       sha256 = "96e454d8167e59862a2920a29c9c3b9030a595227451b30db82d5a58d0b2e6b8";
        libraryHaskellDepends = [ base mtl ];
        homepage = "https://github.com/bos/llvm";
        description = "FFI bindings to the LLVM compiler toolkit";
@@ -87410,7 +87720,7 @@ self: {
      mkDerivation {
        pname = "llvm-base-types";
        version = "0.3.0";
-       sha256 = "142xc7w250y0nx60qnm4gc5hrqjm1bxk0nhgsp669g5kvxqcd3bn";
+       sha256 = "768dc670dfb3bc64ccd50f5a30fb0a55e20c0b7ba45a0c4cb7c08322f8615d90";
        libraryHaskellDepends = [
          base containers deepseq dwarf failure GenericPretty graphviz
          hashable pretty regex-tdfa text transformers unordered-containers
@@ -87426,7 +87736,7 @@ self: {
      mkDerivation {
        pname = "llvm-base-util";
        version = "3.0.1.0";
-       sha256 = "07q6dvwkg7h6qkwq0a7719g82anipj2pk0xid5p24pvzssa9z22w";
+       sha256 = "5c889f94d67f5f226e69b1837985bcd12a815e0ae72880f9c4069e37f96e061f";
        libraryHaskellDepends = [ base llvm-base ];
        homepage = "https://github.com/bos/llvm";
        description = "Utilities for bindings to the LLVM compiler toolkit";
@@ -87442,7 +87752,7 @@ self: {
      mkDerivation {
        pname = "llvm-data-interop";
        version = "0.3.0";
-       sha256 = "08kflxb0qannp6nb2sizz0bhl850dl1sszl1hk9l28m21r2akdy1";
+       sha256 = "c1b7a9440ea22241d384817ead036da0200a17f83f6ab1acb9d62a0c56a76e22";
        libraryHaskellDepends = [
          array base bytestring containers data-default deepseq dwarf
          hashable hashtables llvm-base-types loch-th mtl text transformers
@@ -87460,7 +87770,7 @@ self: {
      mkDerivation {
        pname = "llvm-extra";
        version = "0.6";
-       sha256 = "0nlh5l070zc7y1jpwnyxnc0223w8xaw0z92agmigiw6bm8vcs568";
+       sha256 = "c814cd36aacbf0f8627d4aa40fb8ea880f2100b3dd5b7e65f0877d70002d905a";
        isLibrary = true;
        isExecutable = true;
        libraryHaskellDepends = [
@@ -87477,7 +87787,7 @@ self: {
      mkDerivation {
        pname = "llvm-ffi";
        version = "3.0.0";
-       sha256 = "07hb4n7wk0gmprjps045cvhcyvmis0jp5f11jbk55y4mgn4jy0cv";
+       sha256 = "9b012f897d95f852e69221b87225d0b16ecfe06685007d65bef581c98f250b1e";
        isLibrary = true;
        isExecutable = true;
        libraryHaskellDepends = [ base ];
@@ -87498,7 +87808,7 @@ self: {
      mkDerivation {
        pname = "llvm-general";
        version = "3.4.5.4";
-       sha256 = "1zfixhvwagvznrvnxzrb9fzkswa43mj1nmbpmx87888q8z9m31j0";
+       sha256 = "408651d34718217450af77551b641d44713dbf4b2bff6e77b67f3fc537ecd1fd";
        libraryHaskellDepends = [
          array base bytestring containers llvm-general-pure mtl parsec
          setenv template-haskell transformers transformers-compat
@@ -87522,7 +87832,7 @@ self: {
      mkDerivation {
        pname = "llvm-general-pure";
        version = "3.4.5.4";
-       sha256 = "0kc4f431j65qfsa54a17y3m82a8xf3dmd3hzr8mj514jz4wv6jn5";
+       sha256 = "c54ab339f99284222bca1f8e56db701d2981eaf02728529476b818190671844d";
        libraryHaskellDepends = [
          base containers mtl parsec setenv template-haskell transformers
          transformers-compat
@@ -87544,7 +87854,7 @@ self: {
      mkDerivation {
        pname = "llvm-general-quote";
        version = "0.2.0.0";
-       sha256 = "02j3npamy5s6ircfd9njg0y25asbpxl6fpsxjpxy7k4v1y6c3b75";
+       sha256 = "e5acc18c0f9bcce3fb955d5f6768bf4bab223c78d2a6e6588e46175fd5b5430a";
        libraryHaskellDepends = [
          array base bytestring containers haskell-src-meta llvm-general-pure
          mainland-pretty mtl split srcloc syb symbol template-haskell
@@ -87568,7 +87878,7 @@ self: {
      mkDerivation {
        pname = "llvm-ht";
        version = "0.7.0.0";
-       sha256 = "1yn8wyp2jjjdggvf1jz7iras4f7fg2dq57ramr5prvcapc6r5yn6";
+       sha256 = "c6fa920dbb8aed7c4bae2a9f829b78ee38a2558ee7cbe0f67b4d4a29aee7c8fa";
        libraryHaskellDepends = [
          base bytestring directory mtl process type-level
        ];
@@ -87585,7 +87895,7 @@ self: {
      mkDerivation {
        pname = "llvm-pkg-config";
        version = "0.0";
-       sha256 = "1sfw901bhnwiam8mm7h50fb6rpqv7vs8j7bxdx6azcf02cmivx6w";
+       sha256 = "dcf41d2b13c0b1af4c6f7d1d89f43e1bdf6c9603059e5a5155915bb80248dce9";
        isLibrary = false;
        isExecutable = true;
        executableHaskellDepends = [
@@ -87601,7 +87911,7 @@ self: {
      mkDerivation {
        pname = "llvm-pretty";
        version = "0.3.1.1";
-       sha256 = "1qk3dlinhic9m8ahynqqi90y7ai728p10c4mkmj2w135wp8a8ran";
+       sha256 = "5665a4d0e565042e649d9530102e1227aae3418a185b0f15aa894568236d63e2";
        libraryHaskellDepends = [ base containers monadLib pretty ];
        description = "A pretty printing library inspired by the llvm binding";
        license = stdenv.lib.licenses.bsd3;
@@ -87615,7 +87925,7 @@ self: {
      mkDerivation {
        pname = "llvm-pretty-bc-parser";
        version = "0.1.3.1";
-       sha256 = "15h66zdkisjg1mrrchkyzknj0mq5xybjn41mrnfs3pzalnffsfqs";
+       sha256 = "1a3bed9ca5eadfa19dcd35102b97ef055720edfc7e4296730d4fea38db370696";
        isLibrary = true;
        isExecutable = true;
        libraryHaskellDepends = [
@@ -87640,7 +87950,7 @@ self: {
      mkDerivation {
        pname = "llvm-tf";
        version = "3.0.3.1";
-       sha256 = "0bkx86gv5f7w14hxny6h36balsklscxzm3qakv8f2ana0bk1sv09";
+       sha256 = "096c1de602ca2ae1d09e0a8ffa3bd3746aaa9619d078db2109fcb8b29f417d2e";
        isLibrary = true;
        isExecutable = true;
        libraryHaskellDepends = [
@@ -87661,7 +87971,7 @@ self: {
      mkDerivation {
        pname = "llvm-tools";
        version = "0.2.0.1";
-       sha256 = "1nyp0sgdqsaa2f2v7xgmm3s8mf2a170mzz2h3wwsi163ggvxwvhd";
+       sha256 = "0d6edef77bc384a8391f50fc5fc1094ab88af4a8f5f5b385134a69dc9e06d7db";
        isLibrary = true;
        isExecutable = true;
        libraryHaskellDepends = [
@@ -87683,7 +87993,7 @@ self: {
      mkDerivation {
        pname = "lmdb";
        version = "0.2.5";
-       sha256 = "0z8wj06b5ii0w6pls2jlqmd3mhyrplhxd1c6h1my1p0w45b2hmc0";
+       sha256 = "80552856211cdce06b808685d621bdd9c33a5ac5540a4dafe120c6b20c901c7d";
        libraryHaskellDepends = [ array base ];
        librarySystemDepends = [ lmdb ];
        homepage = "http://github.com/dmbarbour/haskell-lmdb";
@@ -87696,7 +88006,7 @@ self: {
      mkDerivation {
        pname = "load-env";
        version = "0.1.1";
-       sha256 = "05pxxplp96pcnzk61xcckxnxljl3hjl13ckn4xrr93zmlw49rqwg";
+       sha256 = "8fe39c08a7f58f94732776b211a884834ada6d9f8cf560e6b7ec9a74e9edfd16";
        libraryHaskellDepends = [ base directory parsec ];
        testHaskellDepends = [ base directory hspec HUnit parsec ];
        description = "Load environment variables from a file";
@@ -87708,7 +88018,7 @@ self: {
      mkDerivation {
        pname = "loadavg";
        version = "0.1";
-       sha256 = "13q2yxqyzkh099jwz32plmdc71p4w2gkajx5bbi3fkvl2gylqlk6";
+       sha256 = "66524cfd13744f37e25aa54b359fe0e486c35aa5578ccf654a00ceef71f7028f";
        libraryHaskellDepends = [ base ];
        description = "Load average parsing from /proc/loadavg and bindings to getloadavg (3)";
        license = stdenv.lib.licenses.bsd3;
@@ -87719,7 +88029,7 @@ self: {
      mkDerivation {
        pname = "local-address";
        version = "0.0.1";
-       sha256 = "1846lhs0jc8finxcp1hfgifzs7hwzzxvmmv03laxzl63p5h2k8x9";
+       sha256 = "a9a32960b9c3d0df151d60d7bafbff1c1efd5d7c0e86cbba8d0e310934a486a0";
        libraryHaskellDepends = [ base network ];
        homepage = "http://bitbucket.org/khibino/haskell-local-address";
        description = "Functions to get local interface address";
@@ -87733,7 +88043,7 @@ self: {
      mkDerivation {
        pname = "local-search";
        version = "0.0.7";
-       sha256 = "0xrp34m2qfbz458g7bxdkp2lvsm0hskwxfcrm1d8n8g150ddn2xf";
+       sha256 = "ae0bdb1a28e1218b5aa899b9cea786a0ea4dc59dadaff350217f392c2a193777";
        libraryHaskellDepends = [
          base combinatorial-problems containers erf random
        ];
@@ -87748,7 +88058,7 @@ self: {
      mkDerivation {
        pname = "located-base";
        version = "0.1.0.0";
-       sha256 = "0jb4ziagvbvgaihgw9ajsni0nylqbh5hw3q4dw561qmx2msjjfpj";
+       sha256 = "f23a297515bde2600a6f040f0e0b5c987a0ba2d55225fe60546faffd54fc6449";
        libraryHaskellDepends = [ base ];
        homepage = "http://github.com/gridaphobe/located-base";
        description = "Location-aware variants of partial functions";
@@ -87762,7 +88072,7 @@ self: {
      mkDerivation {
        pname = "locators";
        version = "0.2.4.2";
-       sha256 = "172fbxb51p09afsgp9g28zpbisxnf0wxdr3bwi6hwp40ac3363g4";
+       sha256 = "e40d330653805c0e4de46be4d63970b6ebb8ee47e2a5fbb45309dc50565f4e9c";
        libraryHaskellDepends = [
          base bytestring cereal containers cryptohash
        ];
@@ -87779,7 +88089,7 @@ self: {
      mkDerivation {
        pname = "loch";
        version = "0.2";
-       sha256 = "1dwv4v76i1fd60rrr0bla3wjz62x9dcgpd48p8z11lsjgpqarld3";
+       sha256 = "a3d1acf07d52d3103eba88b4fb584b5d982ff95074819c3330cd8568ce269bb7";
        isLibrary = true;
        isExecutable = true;
        libraryHaskellDepends = [ base ];
@@ -87794,7 +88104,7 @@ self: {
      mkDerivation {
        pname = "loch-th";
        version = "0.2.1";
-       sha256 = "1kfrjsgzq6wl749n2wm1fhwwigjxcd9lww7whiwjrbmhiz5ism3p";
+       sha256 = "77541dcb8fb0ae2c7984fc704e53635dbec83974a172611339941bfc9f96d9cd";
        libraryHaskellDepends = [ base pretty template-haskell ];
        homepage = "https://github.com/liskin/loch-th";
        description = "Support for precise error locations in source files (Template Haskell version)";
@@ -87809,7 +88119,7 @@ self: {
      mkDerivation {
        pname = "lock-file";
        version = "0.5.0.2";
-       sha256 = "1l4slkykw59p20kw9iqaa4pjczqx701a9z14nvbzwrmgs2acnki7";
+       sha256 = "274ecb94d0af66fed7b624fca402381d7f262f510ac7c4271037153efda49ad0";
        libraryHaskellDepends = [
          base data-default-class directory exceptions tagged-exception-core
          transformers
@@ -87832,7 +88142,7 @@ self: {
      mkDerivation {
        pname = "lockfree-queue";
        version = "0.2.3.1";
-       sha256 = "131s1w6bdd958pg42s2i62xvw4basagir45y3vhbvsp8p9a6lmra";
+       sha256 = "2a576a54bae8eabde01ebe901c9fd26a11bebb30516841de4525b5b60c0f3a8c";
        libraryHaskellDepends = [
          abstract-deque atomic-primops base bytestring ghc-prim
        ];
@@ -87853,7 +88163,7 @@ self: {
      mkDerivation {
        pname = "log";
        version = "0.2.2";
-       sha256 = "05izcd3qwwfwj5kl2k2pzjs8fk14hq10qls3a8m057gg4pd6nw1n";
+       sha256 = "36706bda25ef9d022a5243530c0286244c87b4fc574c416791dc718e47633f16";
        libraryHaskellDepends = [
          aeson aeson-pretty base bytestring deepseq exceptions hpqtypes
          monad-control monad-time mtl old-locale split stm text time
@@ -87873,7 +88183,7 @@ self: {
      mkDerivation {
        pname = "log-domain";
        version = "0.10.2";
-       sha256 = "0v91xilbgw0cym43fn5abz5ljrxz8anfj1w5x6nzp1qcqcwgwcg4";
+       sha256 = "e431fe38c30c87fbade98507e9ac42bf6749cb5faa583748f50cf0b768ec216d";
        libraryHaskellDepends = [
          base binary bytes cereal comonad deepseq distributive hashable
          hashable-extras safecopy semigroupoids semigroups vector
@@ -87894,7 +88204,7 @@ self: {
      mkDerivation {
        pname = "log-effect";
        version = "0.4.0.1";
-       sha256 = "05rx54bsypisw6k8xm87a4rssyb0lwx7xavwamb1ciiwmvg3j14m";
+       sha256 = "950439deae3c461656557cab7e3aa76079ad335107d58ea6e13a5eaf17293d17";
        libraryHaskellDepends = [
          base bytestring extensible-effects fast-logger time
        ];
@@ -87910,7 +88220,7 @@ self: {
      mkDerivation {
        pname = "log2json";
        version = "0.1";
-       sha256 = "0cidi9zkvqvdqpibr0jpnlk33kprmxwh016w0f86zg9cm3dfb5zf";
+       sha256 = "ee97e5daa82cbd6f9003dc040079aff9ce3126b55782bce2c56de33d7f8a2d32";
        isLibrary = true;
        isExecutable = true;
        executableHaskellDepends = [ base containers json parsec ];
@@ -87926,7 +88236,7 @@ self: {
      mkDerivation {
        pname = "logfloat";
        version = "0.13.3.2";
-       sha256 = "092c9xviq9gsr3q25q254x9kdl80lfssbwjyvi8rrv1300nw7h4c";
+       sha256 = "8cc0c32d0023ec9c51dc5ef2a5b5a300d136532745e022f0c8fa251c774f4c24";
        libraryHaskellDepends = [ array base ];
        homepage = "http://code.haskell.org/~wren/";
        description = "Log-domain floating point numbers";
@@ -87940,7 +88250,7 @@ self: {
      mkDerivation {
        pname = "logger";
        version = "0.1.0.0";
-       sha256 = "1v264iv34k13lz63ajci03iikc7ajqcl3dvcaxcv7m3h538km8vm";
+       sha256 = "75a33ad12870d4b359576cb7411996eab019e300914935cca7234c32762446ec";
        libraryHaskellDepends = [
          ansi-wl-pprint base containers lens mtl template-haskell time
          transformers unagi-chan
@@ -87959,7 +88269,7 @@ self: {
      mkDerivation {
        pname = "logging";
        version = "2.2.0";
-       sha256 = "0awcaj88754bppjmaay6lwmrmv0n53fppn2sjrnyi876r1ibr4qp";
+       sha256 = "1793bc62c8e6a0e86d965ad87bdd2816ec9a2ba7c62b55e5bd8b948390548c2b";
        libraryHaskellDepends = [
          base binary bytestring fast-logger lifted-base monad-control
          monad-logger old-locale pcre-light text time transformers
@@ -87974,7 +88284,7 @@ self: {
      mkDerivation {
        pname = "logging-facade";
        version = "0.1.0";
-       sha256 = "0zhdbjyj0j9by19rma9alxysrxnnl3s4kks4zk4bx0dg5xa0264y";
+       sha256 = "9e1801542faf81bec8fc44cf49f4a0d6f6ac7da72aa99a53f02b4920bd5c0d7e";
        libraryHaskellDepends = [ base template-haskell transformers ];
        testHaskellDepends = [ base hspec ];
        description = "Simple logging abstraction that allows multiple back-ends";
@@ -87988,7 +88298,7 @@ self: {
      mkDerivation {
        pname = "logging-facade-journald";
        version = "0.0.0";
-       sha256 = "151p7574v9mxiniwxa4lngm5g4viznw4kg9adnngc3pi5nnh1z7l";
+       sha256 = "f4fc00ad2df10ef6ac6d2abd49b8fd719357eab394a8cea38dbda64d4e393794";
        libraryHaskellDepends = [
          base libsystemd-journal logging-facade text unordered-containers
        ];
@@ -88008,7 +88318,7 @@ self: {
      mkDerivation {
        pname = "logic-TPTP";
        version = "0.4.3.0";
-       sha256 = "0hjznn92ippwgrsmklj02w2pf6dfylyiw1kifa4svjqwa9mx4hpv";
+       sha256 = "fb42d26b521ccbad897271061e3df5ae1977051740d259757efcde2892b55f42";
        libraryHaskellDepends = [
          ansi-wl-pprint array base containers mtl pointed QuickCheck syb
          transformers transformers-compat
@@ -88025,7 +88335,7 @@ self: {
      mkDerivation {
        pname = "logic-classes";
        version = "1.5.2";
-       sha256 = "05p291y7hw8cfp0s0pb2vm9zpfs092nr92axwz6f74bkfdhrafwj";
+       sha256 = "923b9561737391e3cce75d8994ad4840bbfb53dd625da0c1750c71787c48e216";
        libraryHaskellDepends = [
          applicative-extras base containers HUnit mtl pretty PropLogic
          safecopy set-extra syb template-haskell
@@ -88045,7 +88355,7 @@ self: {
      mkDerivation {
        pname = "logicst";
        version = "0.1.0.0";
-       sha256 = "061x6g92334m2776xclh8mcbjind3l595pggc0g7yi4qzs31zbdc";
+       sha256 = "acad1f86fe98447f1e60efdd920a1dcd46b9584590b26ece11958c21d2333d18";
        libraryHaskellDepends = [ base logict transformers ];
        homepage = "http://github.com/sonyandy/logicst";
        description = "Backtracking mutable references in the ST and IO monads";
@@ -88057,7 +88367,7 @@ self: {
      mkDerivation {
        pname = "logict";
        version = "0.6.0.2";
-       sha256 = "07hnirv6snnym2r7iijlfz00b60jpy2856zvqxh989q0in7bd0hi";
+       sha256 = "1182b68e8d00279460c7fb9b8284bf129805c07754c678b2a8de5a6d768e161e";
        libraryHaskellDepends = [ base mtl ];
        homepage = "http://code.haskell.org/~dolio/";
        description = "A backtracking logic-programming monad";
@@ -88069,7 +88379,7 @@ self: {
      mkDerivation {
        pname = "logsink";
        version = "0.1.0";
-       sha256 = "1yxzqx47017z0djm8bymz43pc8cccnpkawaisvvzb646j6nbrw93";
+       sha256 = "23f1bcac918698f5f7d6517135af658c217607f9d52f546503ff047048c7bffb";
        libraryHaskellDepends = [ base hsyslog logging-facade time ];
        testHaskellDepends = [ base hspec logging-facade ];
        description = "A logging framework for Haskell";
@@ -88084,7 +88394,7 @@ self: {
      mkDerivation {
        pname = "lojban";
        version = "0.3";
-       sha256 = "0pd31g21db8yh1mrnmy7r60lr0dbpwlxpwc0hli3y1wcr4fisnx6";
+       sha256 = "a65b1d1dc98c073f228580f1db29bfab814c81c9c7579b6b801ead16c40ba35d";
        revision = "1";
        editedCabalFile = "9d30c9c8f1aa80aea24ca606d74ee1b3a9af0ecde15a0e65b1150d483d6b1cfc";
        isLibrary = true;
@@ -88105,7 +88415,7 @@ self: {
      mkDerivation {
        pname = "lojbanParser";
        version = "0.1.9.2";
-       sha256 = "0axi63dvls9k87samaa0jihisfqyl92jbhmx1j9q73yjrn5wsk8j";
+       sha256 = "124dcd8bcdd28f83930cbdc22545a21e3b1d619440a9aaf4413369badb30b12b";
        isLibrary = true;
        isExecutable = true;
        libraryHaskellDepends = [ base ];
@@ -88120,7 +88430,7 @@ self: {
      mkDerivation {
        pname = "lojbanXiragan";
        version = "0.3";
-       sha256 = "1h7jmhs38v6mfas4nj22shm2dwphx46247sv3mia28xlzim3xdsp";
+       sha256 = "57b73e6afcb423a1621d5b1f220ce9f0f2262ad442484bb472d56c3434acf2c0";
        isLibrary = true;
        isExecutable = true;
        libraryHaskellDepends = [ base ];
@@ -88135,7 +88445,7 @@ self: {
      mkDerivation {
        pname = "lojysamban";
        version = "0.0.8.1";
-       sha256 = "0c571fk7kz4szpba85d7bf5awak5bc25r59kyx3xvyvk011y9hhd";
+       sha256 = "0dc2e4430073fbdd47f733955c045b652aae8a5ba715a4d6fd9afc79a60ba730";
        isLibrary = false;
        isExecutable = true;
        executableHaskellDepends = [ base lojbanParser yjtools ];
@@ -88152,7 +88462,7 @@ self: {
      mkDerivation {
        pname = "loli";
        version = "2011.6.24";
-       sha256 = "1m23dkxh2vah7d47arpqx5zdpwczm8k4jixzslmqbdizm9h933ja";
+       sha256 = "4a8e9160aa3fb6852bd5bf474926aa9ff1db7ee9f86675483b506d01fb6c43d4";
        libraryHaskellDepends = [
          base bytestring containers data-default hack hack-contrib mps mtl
          template utf8-string
@@ -88169,7 +88479,7 @@ self: {
      mkDerivation {
        pname = "loop";
        version = "0.2.0";
-       sha256 = "11ifqahlg9ky5klid1fhsyfvfb6w8yb0dsy43s0cxcmldbw3qv5x";
+       sha256 = "bd6c3cf86ab4b2ce801ec4eb069647dc2cb79dd7d08516e92c7ea647a1c22e86";
        libraryHaskellDepends = [ base ];
        testHaskellDepends = [ base hspec mtl ];
        homepage = "https://github.com/nh2/loop";
@@ -88182,7 +88492,7 @@ self: {
      mkDerivation {
        pname = "loop-effin";
        version = "0.1.1.0";
-       sha256 = "02x02m98ka1y8f1jjqwfwmsyx29g583gnr4jdm5syqxfr0dz6c52";
+       sha256 = "a230f31bc8ae63af4b6d9264fb062a2f89ee75e58e632983433ea8895215a00b";
        libraryHaskellDepends = [ base effin ];
        jailbreak = true;
        homepage = "https://github.com/konn/loop-effin";
@@ -88196,7 +88506,7 @@ self: {
      mkDerivation {
        pname = "loop-while";
        version = "1.0.0";
-       sha256 = "1yvw91gn1iyw72rbq455zzrbb3pq8ph9cv1c6800qzjyxx0694bd";
+       sha256 = "6d916440ef5e7e0c00322c6c96e045f88eb5f2ffa510bcb238dcc7605f487cfb";
        libraryHaskellDepends = [ base mtl ];
        jailbreak = true;
        description = "A monad transformer supporting various styles of while loop";
@@ -88210,7 +88520,7 @@ self: {
      mkDerivation {
        pname = "loops";
        version = "0.2.0.2";
-       sha256 = "1syx22gp2zra2dhwvmm2np6c1lvqk622a62k4xxjd8y1fs2ckks7";
+       sha256 = "47cfc98476c1a3267b27531825849978d3c0ccb5a2d6cd61132a7f719f10ddeb";
        libraryHaskellDepends = [ base primitive transformers vector ];
        testHaskellDepends = [ base tasty tasty-quickcheck ];
        description = "Fast imperative-style loops";
@@ -88224,7 +88534,7 @@ self: {
      mkDerivation {
        pname = "loopy";
        version = "0.0.1";
-       sha256 = "0gyd7l4i3vzv7swyqfywzwhsdxq3j5869c2id6hz6nm7db47wyy6";
+       sha256 = "c67b7ec86aa75af3a16951b064509103f7a621ffdc3becb93efbef11093dcd3f";
        isLibrary = false;
        isExecutable = true;
        executableHaskellDepends = [
@@ -88248,7 +88558,7 @@ self: {
      mkDerivation {
        pname = "lord";
        version = "2.20150122";
-       sha256 = "0kzvi4310mbz51zkgmm84qyxxpi4m5ww2bsrfkj73a45bn7z198j";
+       sha256 = "12a5f08f5d85a871e474592fc179a924dede3d26a8d6377f287f55100689fb4f";
        isLibrary = true;
        isExecutable = true;
        libraryHaskellDepends = [
@@ -88283,7 +88593,7 @@ self: {
      mkDerivation {
        pname = "lorem";
        version = "0.0.0.0";
-       sha256 = "1fx7z90k9y12rii0yxk58159paiix1qi8y4j0za4k4szylr8f5ni";
+       sha256 = "d1168732f55f9349d40792781471e831aa9b4a4065760f62cc22f83441faa7bb";
        isLibrary = true;
        isExecutable = true;
        libraryHaskellDepends = [ base ];
@@ -88299,7 +88609,7 @@ self: {
      mkDerivation {
        pname = "loris";
        version = "0.3.1";
-       sha256 = "19w1c3gsmy03y4a238yp844wgqcv9s53cwrcapv2yvn9xpchm2gq";
+       sha256 = "f8890ad9edc96e2ff6552c73368a4e9be1c70941d7a32114f103f8aadf6081a7";
        libraryHaskellDepends = [ base vector ];
        librarySystemDepends = [ loris ];
        libraryToolDepends = [ c2hs ];
@@ -88316,7 +88626,7 @@ self: {
      mkDerivation {
        pname = "loshadka";
        version = "0.2";
-       sha256 = "01jjbcgzpkh3mp729xahy2437hrg6wc2l1qnwcm069zrs3c1bdny";
+       sha256 = "deb615d8d0f927032ae316072a18372fc33388f050f524cead03cefb1f5b5206";
        isLibrary = false;
        isExecutable = true;
        executableHaskellDepends = [
@@ -88336,7 +88646,7 @@ self: {
      mkDerivation {
        pname = "lostcities";
        version = "0.2";
-       sha256 = "1avlq28k0jcfbnd0pfww80ixz5lvpp4jkf20dybjl7pfqyhj3s9p";
+       sha256 = "37e921a1c7ee1e2a976f40b829c9bd9b96df23409cbb0b9a5d8e493091c074ab";
        isLibrary = false;
        isExecutable = true;
        executableHaskellDepends = [
@@ -88354,7 +88664,7 @@ self: {
      mkDerivation {
        pname = "lowgl";
        version = "0.3.1.1";
-       sha256 = "1c354ddx9niimfnppbg43d0v2dfr5s9s5dkppi0sld06jxaakxc5";
+       sha256 = "85f5a954970634aa41bc77b6a2932ed935b1411be4ad7badab31dad45b2365b0";
        libraryHaskellDepends = [ base data-default gl linear vector ];
        jailbreak = true;
        description = "Basic gl wrapper and reference";
@@ -88366,7 +88676,7 @@ self: {
      mkDerivation {
        pname = "lrucache";
        version = "1.2.0.0";
-       sha256 = "05knlckzx261yxbz38rqq8vy86zj1np0w2l32cnib6714vhaj5sz";
+       sha256 = "5f17a9e026e198152d13830a0eae0df21be437c238a3f157f7c188fe27a37616";
        libraryHaskellDepends = [ base containers contravariant ];
        homepage = "http://github.com/chowells79/lrucache";
        description = "a simple, pure LRU cache";
@@ -88380,7 +88690,7 @@ self: {
      mkDerivation {
        pname = "ls-usb";
        version = "0.1.1";
-       sha256 = "08xaf27iirdxax7gjjjzvw4nv0qya6vz46826bzmp7f0i0rn88qk";
+       sha256 = "1323643388c09d5bff320219f2b7511e836d09df5f4af94e57bde5188f70aa23";
        isLibrary = false;
        isExecutable = true;
        executableHaskellDepends = [
@@ -88401,7 +88711,7 @@ self: {
      mkDerivation {
        pname = "lscabal";
        version = "0.1.1";
-       sha256 = "14j19jcmx20nhvb9a7im81j3wwkkx6lkb6b1kfizv8qkgnp0jd5j";
+       sha256 = "b23409ae7d13a3fda39b619935a9e973723e6440351e95d68616885e994c4192";
        isLibrary = false;
        isExecutable = true;
        executableHaskellDepends = [
@@ -88420,7 +88730,7 @@ self: {
      mkDerivation {
        pname = "lss";
        version = "0.1.0.0";
-       sha256 = "1r890sya0db0xvs9cm5ghhr6x55hkqplirv95km6y7py7hj69cjr";
+       sha256 = "59b264243cfe1e6fea2c69e7482f9eb0946e3284af5496f4ee6035a0bc0609e5";
        libraryHaskellDepends = [
          attoparsec base containers directory filepath language-css
          language-css-attoparsec text xmlhtml
@@ -88441,7 +88751,7 @@ self: {
      mkDerivation {
        pname = "lsystem";
        version = "1.2";
-       sha256 = "1wk41hsr7pp9azac3449xp0xv8kd31bwif3yw6cfw9jfg3g498xg";
+       sha256 = "afa344de784e26ee98e17eb8c857186da2ddc1ed8990c1d457e9de93350c64f2";
        isLibrary = false;
        isExecutable = true;
        executableHaskellDepends = [
@@ -88460,7 +88770,7 @@ self: {
      mkDerivation {
        pname = "ltext";
        version = "0.0.2.1";
-       sha256 = "0dr99prlsbzisaz8jbiw297fw1fysr9zq0g5ywc959ar3nki039f";
+       sha256 = "2e0d10a71d59a59218f7e501fc53d6de05ee4e123c2e89bed2f12f4df34d2937";
        isLibrary = true;
        isExecutable = true;
        libraryHaskellDepends = [
@@ -88483,13 +88793,12 @@ self: {
      }:
      mkDerivation {
        pname = "ltk";
-       version = "0.15.0.2";
-       sha256 = "19wnkl9acibs6kcnm0m02jhjxrn19sanf5z2w0kqwjbqlfcrcc4a";
+       version = "0.15.0.3";
+       sha256 = "86e0ed96110ad0b2be8d63828e4ab8429893e4c269b28a95f4e1d70c73bc05c2";
        libraryHaskellDepends = [
          base Cabal containers filepath ghc glib gtk3 mtl parsec pretty text
          transformers
        ];
-       jailbreak = true;
        homepage = "http://www.leksah.org";
        description = "Leksah tool kit";
        license = "GPL";
@@ -88500,7 +88809,7 @@ self: {
      mkDerivation {
        pname = "ltl";
        version = "0.0.0";
-       sha256 = "0h3jxngsdmakcr35zapxjaykjsqs44lxxk86d5i4rg0gi0i9qw3g";
+       sha256 = "6f709c22880fbc4c626906cdde29211a6b39bd92fdaa5f466653d5a69fed7240";
        libraryHaskellDepends = [ base vcd ];
        homepage = "http://tomahawkins.org";
        description = "Using linear temporal logic (LTL) to verify embedded software and hardware";
@@ -88514,7 +88823,7 @@ self: {
      mkDerivation {
        pname = "lua-bytecode";
        version = "0.1.0.0";
-       sha256 = "1cwpixaxxkfd8n714c8w82z97h3h8bqqqnh2wsn22cll168rb6zl";
+       sha256 = "f49b959109943221ace6025a8cf14270c093be401c31128e45cdcdde558f97b3";
        libraryHaskellDepends = [
          array base bytestring cereal containers hashable numeric-extras
          vector
@@ -88530,7 +88839,7 @@ self: {
      mkDerivation {
        pname = "luachunk";
        version = "0.1.0.0";
-       sha256 = "03a8adaz3m93wnfmrvsqbmc57h1d8h0a90spfj1cb7yrpz0pr3ck";
+       sha256 = "938d7cc1bfd99fc582745783a400442dc053585d58ef5c9de523d5f15553480d";
        libraryHaskellDepends = [
          attoparsec base binary bytestring custom-prelude ghc-prim pretty
          text
@@ -88549,7 +88858,7 @@ self: {
      mkDerivation {
        pname = "luautils";
        version = "0.1.4";
-       sha256 = "176szfrz1ydnin1zi50235j4f4l87j516yjddmqbmd834dzvk20d";
+       sha256 = "0d88b97f2303b5ba706d4d7a138a3c88124764190294f8838db6f9f0b3fbda9c";
        libraryHaskellDepends = [
          base binary bytestring containers hslua monad-loops text
        ];
@@ -88568,7 +88877,7 @@ self: {
      mkDerivation {
        pname = "lub";
        version = "0.1.7";
-       sha256 = "1dsm7cg0i930r5dn8591aabkl0p8b5l348pccdvi7p0g7asx451h";
+       sha256 = "3014d2b53a0fdc137763ec22326859e8023a97522115645bc960a4081e3b55b7";
        libraryHaskellDepends = [ base unamb ];
        homepage = "http://haskell.org/haskellwiki/lub";
        description = "information operators: least upper bound (lub) and greatest lower bound (glb)";
@@ -88583,7 +88892,7 @@ self: {
      mkDerivation {
        pname = "lucid";
        version = "2.9.2";
-       sha256 = "0r3bzh9pmcqsac5id064jcscn9x2pyfhpazdzvz0666smf4b9jah";
+       sha256 = "50c9b488abda1803fefeedab0b9dbfa227cb3493c480160b531ab37a13fc6b64";
        revision = "1";
        editedCabalFile = "62ded561d5846fbcbe77e7f491c5fed2f4beddbf5cda336685f3d980df525218";
        libraryHaskellDepends = [
@@ -88605,7 +88914,7 @@ self: {
      mkDerivation {
        pname = "lucid-foundation";
        version = "0.0.2.1";
-       sha256 = "10l6xvb3kmkjb9sq92ijwnnbpm3rmp6j8r8vf00kdxkgx84n1zqd";
+       sha256 = "0dff6009ea6ff63601701b6524cdad79d4bbace5328a84755a72d639d6ee8682";
        libraryHaskellDepends = [ base lucid text ];
        testHaskellDepends = [
          base hspec QuickCheck quickcheck-instances
@@ -88619,7 +88928,7 @@ self: {
      mkDerivation {
        pname = "lucid-svg";
        version = "0.5.0.0";
-       sha256 = "1p7ipdy0nmqfg1b038a1b5nd3xh2779d2gnw4h683mm5jcbf0mvj";
+       sha256 = "7257e01693a5d6810c24dc3ed1d23902f6d16c5941a10156780e570b7cbbf1dc";
        libraryHaskellDepends = [
          base blaze-builder lucid text transformers
        ];
@@ -88636,7 +88945,7 @@ self: {
      mkDerivation {
        pname = "lucienne";
        version = "0.0.2";
-       sha256 = "1dcvax756cqpqg6rrrjrd4sfr3ggvqdiwp42rb8fdrsi3v2skwrj";
+       sha256 = "32f3a9c51e51e7e6d0ca825c1e1bdeef8dec346959e69ccdc31733534e579bb5";
        isLibrary = false;
        isExecutable = true;
        executableHaskellDepends = [
@@ -88656,7 +88965,7 @@ self: {
      mkDerivation {
        pname = "luhn";
        version = "0.2";
-       sha256 = "0ix7x28kmd3iarydl709vqd041h0qx6kv582c8ca54z8ag7lzynz";
+       sha256 = "dffa4fcf53e893a2186202953d4dc70006021ade091cda7c5671b43a91e8a747";
        libraryHaskellDepends = [ base digits QuickCheck ];
        description = "An implementation of Luhn's check digit algorithm";
        license = stdenv.lib.licenses.bsd3;
@@ -88669,7 +88978,7 @@ self: {
      mkDerivation {
        pname = "lui";
        version = "0.0.6";
-       sha256 = "081451gpm20z8zl3y1mjy9015a461g7q99w7sjnr8alvd3pbhd6v";
+       sha256 = "db34b8ee689b2a94add487a784cf0b86a81240f2b2063fe8471f887a5f282420";
        libraryHaskellDepends = [
          base containers haskell98 haskgame MaybeT mtl SDL
        ];
@@ -88683,7 +88992,7 @@ self: {
      mkDerivation {
        pname = "luka";
        version = "2012.8.29";
-       sha256 = "00g7a80nlw1bgw6x2pqg1qn4786ra3bwbwbfm9b7iyhb101b7s9s";
+       sha256 = "3ae9b302080bfa7856aa6ef1c5d750d9a0432c0e0f5fd10d7f2b706a0152e701";
        libraryHaskellDepends = [ air base bytestring libffi ];
        librarySystemDepends = [ objc ];
        homepage = "https://github.com/nfjinjing/luka";
@@ -88697,7 +89006,7 @@ self: {
      mkDerivation {
        pname = "lushtags";
        version = "0.0.1";
-       sha256 = "0325c064nsczypapvwdchx7x5n69jxjbyjs90ah7q5ydxbjl6w9c";
+       sha256 = "2c7143e5eacd177ca002494bbf6497c9d8d24f87acf17dd5f59f694b0c60450c";
        isLibrary = false;
        isExecutable = true;
        executableHaskellDepends = [ base haskell-src-exts text vector ];
@@ -88712,7 +89021,7 @@ self: {
      mkDerivation {
        pname = "luthor";
        version = "0.0.1";
-       sha256 = "023kckpcdn6n5dyq0dip0132jp1w30hdx1qb5hbsd3js86j52a12";
+       sha256 = "222851a4415a8ea6172c0b87de20183c5c2946003736807d2bd6d8c6ee647308";
        libraryHaskellDepends = [ base mtl parsec ];
        testHaskellDepends = [ base mtl parsec ];
        jailbreak = true;
@@ -88732,7 +89041,7 @@ self: {
      mkDerivation {
        pname = "lvish";
        version = "1.1.4";
-       sha256 = "1s7i1jxb6m7ivk4nd60dy8hn4wgfhv1gcamvv6hgjvcw6rxn4k44";
+       sha256 = "844c627b369c6df9a0d9bb2af6c286ee716221f20d9866c9dcf154b3ba0cf1e8";
        revision = "2";
        editedCabalFile = "bb376e7ac0598a623c8222824a2ace2649a395be610f81912eb7193450aa3e7e";
        libraryHaskellDepends = [
@@ -88758,7 +89067,7 @@ self: {
      mkDerivation {
        pname = "lvmlib";
        version = "1.1";
-       sha256 = "1lr2qr817mb8qb7b3wvry9jpj3wjphj5s60rn3dyqibx8gny36bg";
+       sha256 = "6f99e1ed437d45ecdbb019185d24bc920f7965f279f3b1cec268d51350c622d3";
        isLibrary = true;
        isExecutable = true;
        libraryHaskellDepends = [
@@ -88778,7 +89087,7 @@ self: {
      mkDerivation {
        pname = "lvmrun";
        version = "1.0";
-       sha256 = "0wcf9brcvf4b7qcs51mngca3qxilk0x50h3dml28zg6lg93wwbfa";
+       sha256 = "ca2dce477ad4bc8f04ad6d40503a9834763c147bb686a2193e8bb8cdf24a8e71";
        isLibrary = false;
        isExecutable = true;
        homepage = "http://www.cs.uu.nl/wiki/bin/view/Helium/WebHome";
@@ -88791,7 +89100,7 @@ self: {
      mkDerivation {
        pname = "lxc";
        version = "0.3.1.1";
-       sha256 = "1mksram2nlb611b81yh5smvgr3dqxyabphrrpimspixwwl8173zr";
+       sha256 = "f98f1310e5bcc7ab6bbc39c3bb94efb88dfc76d505fa80560866512baaca7ad6";
        libraryHaskellDepends = [ base bindings-lxc mtl transformers ];
        jailbreak = true;
        homepage = "https://github.com/fizruk/lxc";
@@ -88806,7 +89115,7 @@ self: {
      mkDerivation {
        pname = "lye";
        version = "0.1.0.0";
-       sha256 = "1pmlxvnlwdsb51pjrkak1sakfh3nyk5lia5pqmr7larlm1n3dx9m";
+       sha256 = "35f5366ca8342b7a72c5b7a848cbf4764037950e53cd2c6f284b374eedeeb4de";
        isLibrary = false;
        isExecutable = true;
        executableHaskellDepends = [
@@ -88823,7 +89132,7 @@ self: {
      mkDerivation {
        pname = "lz4";
        version = "0.2.3.1";
-       sha256 = "1wck0sl7m873pqnpmn95vrp9jbr7awjdp9rrkqgj0nd3l6z65k4q";
+       sha256 = "98cc62bea1a359201f9e39a7db2457272f996ede25d97a2dbee3a07aa80693f1";
        libraryHaskellDepends = [ base bytestring cereal ];
        testHaskellDepends = [ base bytestring hspec HUnit QuickCheck ];
        homepage = "http://github.com/mwotton/lz4hs";
@@ -88839,7 +89148,7 @@ self: {
      mkDerivation {
        pname = "lzma-conduit";
        version = "1.1.3";
-       sha256 = "01pf7q56y4m377qcbfwdv767dhlvkhd4cs01bqcg9k667iy21fr4";
+       sha256 = "24bb207c3cc6ccf4185e0168461a9c9bc276ccd98dbbc5f039a3126f0a3eee06";
        libraryHaskellDepends = [
          base bindings-DSL bytestring conduit resourcet transformers
        ];
@@ -88861,7 +89170,7 @@ self: {
      mkDerivation {
        pname = "lzma-enumerator";
        version = "0.1.3";
-       sha256 = "0pzz8bf6310p23pmsa013i8vib0xsfvlkj7zp0w9xs2xsi4j7jk1";
+       sha256 = "61ca2349d45de89e38b8ffc849b7d31dacb8511c01285def10178461dc42ff5f";
        libraryHaskellDepends = [
          base bindings-DSL bytestring enumerator mtl
        ];
@@ -88884,7 +89193,7 @@ self: {
      mkDerivation {
        pname = "lzma-streams";
        version = "0.0.0.0";
-       sha256 = "0klgi097b8mky989hfzn3kk3r25yq1p0sjna4r68k7z9y143yzm2";
+       sha256 = "a27e3f48f0e99f894c26ca4a0d6ec0be883ce61cf63b9850f2b3a27512888f4e";
        libraryHaskellDepends = [ base bytestring io-streams ];
        librarySystemDepends = [ lzma ];
        testHaskellDepends = [
@@ -88903,7 +89212,7 @@ self: {
      mkDerivation {
        pname = "maam";
        version = "0.2.0.1";
-       sha256 = "1r6vp774gjb52bd1lmjx6xzh0pw82b060pl7bh8n0z58i67bvm9q";
+       sha256 = "38d5bd8e89a87c60115c875e60c012885f007f375d561ada1265c947ceb9dbe4";
        isLibrary = true;
        isExecutable = true;
        libraryHaskellDepends = [
@@ -88920,7 +89229,7 @@ self: {
      mkDerivation {
        pname = "mac";
        version = "0.1.0.0";
-       sha256 = "1ym5hk774y65mjxhp1vwa40ji2yjf4abqrpf3v9dknc28r64v8bi";
+       sha256 = "71a14d4c4682d9d9d21eee66bc1471d28b2801517c870bbbacc57872ce84a5fa";
        libraryHaskellDepends = [ base network transformers ];
        description = "Static Mandatory Access Control in Haskell";
        license = stdenv.lib.licenses.bsd3;
@@ -88931,7 +89240,7 @@ self: {
      mkDerivation {
        pname = "maccatcher";
        version = "2.1.5";
-       sha256 = "0z56rbfr8vijhjf3dcqd4kaxgx9bf3qgi9sm61yc3i6ra60w7byb";
+       sha256 = "cbafc38151d9c4c17c3055a7f8f0702bf5d7d5240db3369c84326e94ddcaa67c";
        isLibrary = true;
        isExecutable = true;
        libraryHaskellDepends = [ base binary parsec process ];
@@ -88946,7 +89255,7 @@ self: {
      mkDerivation {
        pname = "machinecell";
        version = "2.1.0";
-       sha256 = "10ywc93sihag844ifsimxz0vmr34i3a7rjpy63gs0ikkvr4vxs1g";
+       sha256 = "2fe8be49de7346a0df30feca7cd48864e4bac1ef356a1709414fc1a84762dc83";
        libraryHaskellDepends = [
          arrows base free mtl profunctors semigroups
        ];
@@ -88966,7 +89275,7 @@ self: {
      mkDerivation {
        pname = "machines";
        version = "0.5.1";
-       sha256 = "1dyvyy0yv9qha1ff2nfrl304vmmbi4hd881jyj3xpqhgc3zz8ab2";
+       sha256 = "6229f4ff600fe2db87f43220d42089abd64dc0a0d959e15c5010a7ed81f7dbb7";
        revision = "1";
        editedCabalFile = "c50d5fcc8b1b5635539169a5da097a25c7a7b7e9b8cc582abba3703014ba2d1d";
        libraryHaskellDepends = [
@@ -88987,7 +89296,7 @@ self: {
      mkDerivation {
        pname = "machines-directory";
        version = "0.2.0.6";
-       sha256 = "03faha5zbxikbrz40wb0qar8qyjkzaylnk78ba925vms57dwwxva";
+       sha256 = "6a77cedb29baee22925ae84c4bbdfa537a8cb2c26071407e5e33f6f58b82ca0d";
        libraryHaskellDepends = [
          base directory filepath machines machines-io transformers
        ];
@@ -89003,7 +89312,7 @@ self: {
      mkDerivation {
        pname = "machines-io";
        version = "0.2.0.6";
-       sha256 = "19xi9ia2f18nwqx58qb4l1hc2cv25jwcsl4qxd7snp4ynjyy6ln1";
+       sha256 = "c152e3bdb49e5cab4feb9850cdb82c6233c160a06461543ae6160527544cb1a7";
        libraryHaskellDepends = [
          base bytestring chunked-data machines transformers
        ];
@@ -89018,7 +89327,7 @@ self: {
      mkDerivation {
        pname = "machines-process";
        version = "0.2.0.4";
-       sha256 = "1v0jskb8m1s7cd51672v4fj9sjy5l1q01vm6qyvkrsabjp04lq4l";
+       sha256 = "94604ac0954be93cb7c7a6ee0070a0c54b9da4235b1c134a6347878ad6d412ec";
        libraryHaskellDepends = [
          base chunked-data machines machines-io process
        ];
@@ -89033,7 +89342,7 @@ self: {
      mkDerivation {
        pname = "machines-zlib";
        version = "0.1.0";
-       sha256 = "0ajdc7878vzam5zphdaw8zn8knzk8kq80y3yf84jwlakb6ihrv6d";
+       sha256 = "cdec0ca35953512e09727e7880f044f3db89ec475c35787fa9ea6f74d0614d2a";
        libraryHaskellDepends = [
          base basic-prelude machines streaming-commons
        ];
@@ -89048,7 +89357,7 @@ self: {
      mkDerivation {
        pname = "macho";
        version = "0.22";
-       sha256 = "13i8bap38ha8j0259kw4gfx18jxc4860awp3s9rz16i4q2vik0v2";
+       sha256 = "628319b7c0249af073d2e372050c22ac4b14ba7b84cf540490484134ae5a288e";
        libraryHaskellDepends = [ base binary bytestring ];
        homepage = "http://github.com/erikcharlebois/macho";
        description = "Parser for Mach-O object format";
@@ -89063,7 +89372,7 @@ self: {
      mkDerivation {
        pname = "maclight";
        version = "0.1.0.0";
-       sha256 = "0qf44jza8avq2yfsx2f0bdxbnda4lm3xq9qaivmslfbdfjy3mxv3";
+       sha256 = "63f73abc746d39aaeb8e0a27dc47a54435bb7a5bc089ae9d17782ba4be24c461";
        isLibrary = true;
        isExecutable = true;
        libraryHaskellDepends = [ base filemanip filepath parsec strict ];
@@ -89086,7 +89395,7 @@ self: {
      mkDerivation {
        pname = "macosx-make-standalone";
        version = "0.1.0.1";
-       sha256 = "04j5fpj4758bl8ksaqn4zz6dl8pg24ih65k1b0pg8qrar4275r14";
+       sha256 = "24e47204c92a63f42e586116032311ef22daccffc462a527a20b9543e4754512";
        isLibrary = false;
        isExecutable = true;
        executableHaskellDepends = [
@@ -89103,7 +89412,7 @@ self: {
      mkDerivation {
        pname = "mage";
        version = "1.1.0";
-       sha256 = "0fknvy48sanvq7vg5pxwbjsahpiby1hba5wf8w6rq2g3d0a1cjwz";
+       sha256 = "9f4b161468e3099c0d478e17b560f02b5ea8b45cbcdff2f6c1db2a8d88df763a";
        isLibrary = false;
        isExecutable = true;
        executableHaskellDepends = [ array base containers mtl random ];
@@ -89119,7 +89428,7 @@ self: {
      mkDerivation {
        pname = "magic";
        version = "1.1";
-       sha256 = "10p0gjjjwr1dda7hahwrwn5njbfhl67arq3v3nf1jr3vymlkn75j";
+       sha256 = "b21c3b69f57b64199c1d7be0ac8ea1d02d698be59943058f6a2d642ea57ce082";
        libraryHaskellDepends = [ base ];
        librarySystemDepends = [ magic ];
        description = "Interface to C file/magic library";
@@ -89132,7 +89441,7 @@ self: {
      mkDerivation {
        pname = "magma";
        version = "0.3.0.0";
-       sha256 = "0bk4a9kw2jxvvz81ppj6qh3kk8cbknnqmg6vvkd0kpn70rcx0hnv";
+       sha256 = "db42d05906c7de09dadcdbbc8aad9d8ba13907c446de1bd0dfbb4bc16752642e";
        libraryHaskellDepends = [ base deepseq profunctors semigroups ];
        jailbreak = true;
        homepage = "https://github.com/cutsea110/magma";
@@ -89149,7 +89458,7 @@ self: {
      mkDerivation {
        pname = "mahoro";
        version = "0.1.2";
-       sha256 = "0fmhms0415wawd539ipdj47gf27h2jjq2gpzhb0s21r6z63ayp7f";
+       sha256 = "ee5caf86f92607a1c182ff3e81a514f008f70e91edc6344ae38a974080aeb03a";
        isLibrary = false;
        isExecutable = true;
        executableHaskellDepends = [
@@ -89170,7 +89479,7 @@ self: {
      mkDerivation {
        pname = "maid";
        version = "2014.10.14";
-       sha256 = "1gss86263pzwvm14yx5lqzskrwc3z6521z9yp0mg8780qgr8h9sr";
+       sha256 = "592788f2c3001df42ab83efd208af983f13cf5c7b4744f42ddfcdf6184415abf";
        isLibrary = false;
        isExecutable = true;
        executableHaskellDepends = [
@@ -89191,7 +89500,7 @@ self: {
      mkDerivation {
        pname = "mailbox-count";
        version = "0.0.2";
-       sha256 = "1zd3vd0sj4pq8nhjn768rpfyn9a06a9c3j2fnhxsb9d800ilpvvf";
+       sha256 = "6eef4b2300a8a5a53bb44ec8c192324025ebddcdc81c2ba145f812a941dba3fd";
        isLibrary = false;
        isExecutable = true;
        executableHaskellDepends = [
@@ -89214,7 +89523,7 @@ self: {
      mkDerivation {
        pname = "mailchimp-subscribe";
        version = "1.0";
-       sha256 = "0c6sn7bpzw82iarpw40l88f58xrjl9gzdqx1xnbafzdyfhbrnzbi";
+       sha256 = "717d9b1774be7da796eda1e3f65fa23277541c4214107eb38a02f17fd7b1da30";
        isLibrary = false;
        isExecutable = true;
        executableHaskellDepends = [
@@ -89235,7 +89544,7 @@ self: {
      mkDerivation {
        pname = "mailgun";
        version = "0.1.0.4";
-       sha256 = "01xcr0dwbkpryavk054y52fdk9qis4s6df8d0yxz05kdl8b5nczq";
+       sha256 = "f8335b16a26d16f0bb070db96634d111a7d99c289e1430b7f2f9cec51bc8ac07";
        isLibrary = true;
        isExecutable = true;
        libraryHaskellDepends = [
@@ -89255,7 +89564,7 @@ self: {
      mkDerivation {
        pname = "mainland-pretty";
        version = "0.4.1.0";
-       sha256 = "0r8xhlbpws6wq305dv3z074d7492jif9dsscz4sjbwvh5dk4x1zl";
+       sha256 = "f4874e662b70f32535f94ceb965c942291d3c8017fec56c0c0dc687e17851d65";
        libraryHaskellDepends = [ base containers srcloc text ];
        homepage = "http://www.cs.drexel.edu/~mainland/";
        description = "Pretty printing designed for printing source code";
@@ -89269,7 +89578,7 @@ self: {
      mkDerivation {
        pname = "majordomo";
        version = "0.1.6";
-       sha256 = "1rjarfwjqlrq9cdgjv93v6jwg58984c0dwjk506svsr29ll0p1b1";
+       sha256 = "61850b284d22ebad0d2853f20618410995c7a5d9236df91a4b38532cb9cb4ae6";
        isLibrary = true;
        isExecutable = true;
        libraryHaskellDepends = [
@@ -89289,7 +89598,7 @@ self: {
      mkDerivation {
        pname = "majority";
        version = "1.1";
-       sha256 = "1442xw8i9jgk3hqavqikks98qs9l3i37lk63xyzpdgnlkfqapzka";
+       sha256 = "6afeabb09bd4be76bfefc34c7a461c34698c929e33e2ad301cf3c91411ef8290";
        libraryHaskellDepends = [ haskell2010 ];
        homepage = "https://github.com/niswegmann/majority";
        description = "Boyer-Moore Majority Vote Algorithm";
@@ -89304,7 +89613,7 @@ self: {
      mkDerivation {
        pname = "make-hard-links";
        version = "0.2";
-       sha256 = "0bynbrn7fnnw7s6wafaji5yf21zjsrdmdfyb7m97bk77ss0gprq2";
+       sha256 = "02e7fb80d6e7cc75523dcbbb565bd6f207e17c895239c58d3edc5a776c5ed62f";
        isLibrary = false;
        isExecutable = true;
        executableHaskellDepends = [
@@ -89322,7 +89631,7 @@ self: {
      mkDerivation {
        pname = "make-package";
        version = "1.2.0";
-       sha256 = "1502pggc0gcmsj6fhzkjcrbqydaxz4qivsmv57jm6cxpbypkyin3";
+       sha256 = "c3463faf5fb73353e529bbea1d31f95d358f5766727ee88cd4953dc0debb0294";
        isLibrary = false;
        isExecutable = true;
        executableHaskellDepends = [
@@ -89339,7 +89648,7 @@ self: {
      mkDerivation {
        pname = "makedo";
        version = "0.1";
-       sha256 = "0sc2fa45a046lw5x5z839gb1zk0d5nj663ghxajiclm6iw65kl2n";
+       sha256 = "56d0590c8fa65216a5eaf00d63a42d0dcc1fd64b03fdd20ba786005588728269";
        libraryHaskellDepends = [ base directory filepath HSH process ];
        jailbreak = true;
        homepage = "http://darcsden.com/kowey/makedo";
@@ -89352,7 +89661,7 @@ self: {
      mkDerivation {
        pname = "managed";
        version = "1.0.0";
-       sha256 = "06nb71pd68m5l6a48sz5kkrdif74phbg3y6bn9ydd00y515b9gn5";
+       sha256 = "c5beb44a281e80d67cb2cbf8f116bce4b8d8f29ce56b4494a1a522d36e38cb1a";
        libraryHaskellDepends = [ base transformers ];
        description = "A monad for managed values";
        license = stdenv.lib.licenses.bsd3;
@@ -89366,7 +89675,7 @@ self: {
      mkDerivation {
        pname = "manatee";
        version = "0.2.2";
-       sha256 = "1v44kml92i426hbinjmx00znyp7dwxa8qj0bmhb3hz0fwmgck1c3";
+       sha256 = "8385c95ee50e7c3816ac0b488c54e7ed5c6f3f00bd4a1b1734824491689d84ec";
        isLibrary = true;
        isExecutable = true;
        executableHaskellDepends = [
@@ -89390,7 +89699,7 @@ self: {
      mkDerivation {
        pname = "manatee-all";
        version = "0.2.2";
-       sha256 = "1l3s22svds27q8hyh9nsawpc11crcll3vrcbfy6dvk64s04mwr21";
+       sha256 = "41645e09d0c4ccdd8c778be53d28659985c02e57da26e821c247e8b6b5107ad0";
        isLibrary = true;
        isExecutable = true;
        libraryHaskellDepends = [
@@ -89412,7 +89721,7 @@ self: {
      mkDerivation {
        pname = "manatee-anything";
        version = "0.0.8";
-       sha256 = "1ag0272cv700yi7y539hz3r04hqfqq9mx3cacp4hix4wag25f0n8";
+       sha256 = "c80257c4539cf408c9658a8d5e13c60e4302f2f8308de24ff4009ccdc411e0a9";
        isLibrary = true;
        isExecutable = true;
        libraryHaskellDepends = [
@@ -89433,7 +89742,7 @@ self: {
      mkDerivation {
        pname = "manatee-browser";
        version = "0.1.1";
-       sha256 = "01blfcfynfbshznrz4arn89j7s063s7xhlkqnzbv42wqk04i083h";
+       sha256 = "7020100998980bb2d7b77852d88f1e06e82313b259919fed877a39eb1d737405";
        isLibrary = true;
        isExecutable = true;
        libraryHaskellDepends = [
@@ -89457,7 +89766,7 @@ self: {
      mkDerivation {
        pname = "manatee-core";
        version = "0.1.1";
-       sha256 = "05s5cd43a395jgyh4i01wzzzwha9rx9vrflwyr6lpz5nqnfp755v";
+       sha256 = "bb94739dc5b6fc4b4df69cbabc53cf4941feffe7014402fd93250d3548634517";
        libraryHaskellDepends = [
          array base binary bytestring Cabal cairo containers dataenc
          dbus-client dbus-core derive directory filepath gconf ghc ghc-paths
@@ -89480,7 +89789,7 @@ self: {
      mkDerivation {
        pname = "manatee-curl";
        version = "0.1.1";
-       sha256 = "0v525dcg6cs8mfrcbaxk9vx86gnd37c2z8gp9q8fck11616vckvn";
+       sha256 = "764fb64d30214ce6104ef7a12fd819cd3e83fa4eb3abc5b2ab4833f3582ba26c";
        isLibrary = true;
        isExecutable = true;
        libraryHaskellDepends = [
@@ -89502,7 +89811,7 @@ self: {
      mkDerivation {
        pname = "manatee-editor";
        version = "0.1.1";
-       sha256 = "0rd6xjc1hmvfchwjh32ij4sa36z0v6b1k81gnx7278qqsscmgl9y";
+       sha256 = "3ed15799d618a3234eb72fa01996d9e09ba13491510c2839646e571898eca665";
        isLibrary = true;
        isExecutable = true;
        libraryHaskellDepends = [
@@ -89523,7 +89832,7 @@ self: {
      mkDerivation {
        pname = "manatee-filemanager";
        version = "0.1.1";
-       sha256 = "06zrhycpsnfi8r3a071p6qlrqidddv004h10zcglb9ryhw0sh2p1";
+       sha256 = "e10aa801873ea7451ffb204002c06ead459c2936371ca04646d1597d9987f91b";
        isLibrary = true;
        isExecutable = true;
        libraryHaskellDepends = [
@@ -89544,7 +89853,7 @@ self: {
      mkDerivation {
        pname = "manatee-imageviewer";
        version = "0.1.1";
-       sha256 = "0yn32xsckvw96kxskfhgcqg98rffl07hkwfjzyd7cm221hwd9s0g";
+       sha256 = "0fe8d4380c4254769affd2f1090fa0ce65941e660fbaa9fb3489efc97417c37a";
        isLibrary = true;
        isExecutable = true;
        libraryHaskellDepends = [
@@ -89567,7 +89876,7 @@ self: {
      mkDerivation {
        pname = "manatee-ircclient";
        version = "0.1.1";
-       sha256 = "0l14r4mw5bwyjzs5m49sp3vdi2lzfgyjwhsb0q94l3937wb4abgy";
+       sha256 = "fe2d45163f230d4a12064b432efd739f8ad8f6b83a915af4979eafc22bc92450";
        isLibrary = true;
        isExecutable = true;
        libraryHaskellDepends = [
@@ -89589,7 +89898,7 @@ self: {
      mkDerivation {
        pname = "manatee-mplayer";
        version = "0.1.1";
-       sha256 = "1jg9ikshscpjyq73g125acqndd049ry8zw7h0gglsi63xbqpldz4";
+       sha256 = "e4377af1eac3444ddf03f0f08f7c4e04b46631534584370ef6f2320df58ce9c9";
        isLibrary = true;
        isExecutable = true;
        libraryHaskellDepends = [
@@ -89611,7 +89920,7 @@ self: {
      mkDerivation {
        pname = "manatee-pdfviewer";
        version = "0.1.1";
-       sha256 = "0k00drrk7mpbc8ak5cwzx245xf968186dkc12cxp7n2h2mccb456";
+       sha256 = "a690c5581550d8733b1381cd66504026b95e88e89fb3321562ebd633736e004c";
        isLibrary = true;
        isExecutable = true;
        libraryHaskellDepends = [
@@ -89631,7 +89940,7 @@ self: {
      mkDerivation {
        pname = "manatee-processmanager";
        version = "0.1.1";
-       sha256 = "1zxkfil6anh2v692ky9l6gf40784y2czbx8853xmypnhnvgr95ll";
+       sha256 = "949694dfb6d05e5ffb2808f5f599f0041d40dc3334f92992d9025a656874b3ff";
        isLibrary = true;
        isExecutable = true;
        libraryHaskellDepends = [
@@ -89652,7 +89961,7 @@ self: {
      mkDerivation {
        pname = "manatee-reader";
        version = "0.1.1";
-       sha256 = "07zkjg1q3gdqiw1pp0325pyvh84740mxvlf8k6sc6l1l258zpk90";
+       sha256 = "20cdfb51113450c3b499c8d1dd2b208720b8fd2d62807b038fb8bd81c393f31f";
        isLibrary = true;
        isExecutable = true;
        libraryHaskellDepends = [
@@ -89673,7 +89982,7 @@ self: {
      mkDerivation {
        pname = "manatee-template";
        version = "0.1.1";
-       sha256 = "0lcd3g7gp3fl4xpc51wgk0q9q1lijgnfdla521h7nqz84wcdfbcy";
+       sha256 = "9e2dd71827e8637b601045d1e6ec9391069c30988f87c26e27d48dfbce1b8d51";
        isLibrary = true;
        isExecutable = true;
        libraryHaskellDepends = [
@@ -89693,7 +90002,7 @@ self: {
      mkDerivation {
        pname = "manatee-terminal";
        version = "0.1.1";
-       sha256 = "1aj1pghad0jdm3biy9f4caahvpyby0ia3clrl8lg2rmp2j703wkd";
+       sha256 = "6df2018e14b766f128a299b2a122f0cbdf0d9562c4251fd7a84d82a6e0bb41aa";
        isLibrary = true;
        isExecutable = true;
        libraryHaskellDepends = [
@@ -89714,7 +90023,7 @@ self: {
      mkDerivation {
        pname = "manatee-welcome";
        version = "0.1.1";
-       sha256 = "1vwj91i05rwgqmral4v2mmcmlrqy54h816j8vi6d0ivs1693p308";
+       sha256 = "088c3b92097a47d04cdc489a8020291e675a59ad6213aa72c58fe702624892ef";
        isLibrary = true;
        isExecutable = true;
        libraryHaskellDepends = [
@@ -89732,7 +90041,7 @@ self: {
      mkDerivation {
        pname = "mancala";
        version = "0.1";
-       sha256 = "1vsrp69qhndagzlw5fg9chi0hhphfbjmlvarypqi3g9fgrdghn46";
+       sha256 = "8658f85a7e2ebd11f1f5596d5ae572f042082264e9b9c2e97faa598893b959ef";
        isLibrary = false;
        isExecutable = true;
        executableHaskellDepends = [ base ];
@@ -89749,8 +90058,8 @@ self: {
      }:
      mkDerivation {
        pname = "mandrill";
-       version = "0.2.2.1";
-       sha256 = "0fs9fid7d87cnx5wi513xjqkgq425pfd4v9dx82x2c0pvnyfdvhk";
+       version = "0.3.0.0";
+       sha256 = "f497b16900ead8851bec4d8529dfa2a0ba77397a8e7f95ef39d68928d64ffc09";
        libraryHaskellDepends = [
          aeson base base64-bytestring blaze-html bytestring containers
          email-validate http-client http-client-tls http-types lens mtl
@@ -89771,7 +90080,7 @@ self: {
      mkDerivation {
        pname = "mandulia";
        version = "0.7";
-       sha256 = "1wrpzai3482c9g7zfacmjszi6h073ip00fbq17nyc22z2zw4908s";
+       sha256 = "1a8144f8175f08e6ed097839006e1c074013bf969529f7cf4b4c2032a2fa37f3";
        isLibrary = false;
        isExecutable = true;
        executableHaskellDepends = [
@@ -89795,7 +90104,7 @@ self: {
      mkDerivation {
        pname = "mangopay";
        version = "1.11.4";
-       sha256 = "0yb6i97ihcywbgzqkrad72q33m7fgx903rqizlhb4nz4bkl8793d";
+       sha256 = "6da483e85ce45bb220fd11e701527feed431b0384de589ff5bdc33184f8a6679";
        isLibrary = true;
        isExecutable = true;
        libraryHaskellDepends = [
@@ -89831,7 +90140,7 @@ self: {
      mkDerivation {
        pname = "manifolds";
        version = "0.1.3.1";
-       sha256 = "1d1hcdv76bzw2pl6ik2kdprdjdv7nmbbxs31rgz93lzhpkn8dlpj";
+       sha256 = "f2d286ecbcf0d391fecb61e8be56b56737d9f26d53cc68e815fc2f73766330b4";
        libraryHaskellDepends = [
          base comonad constrained-categories containers deepseq hmatrix
          MemoTrie semigroups tagged transformers vector vector-algorithms
@@ -89851,7 +90160,7 @@ self: {
      mkDerivation {
        pname = "map-syntax";
        version = "0.2";
-       sha256 = "02v1dvq86qzbfbwbza4myj3a6a6a5p059fi5m3g548hmqk3v2p1r";
+       sha256 = "395cb1c7c4152252dea825ba54c02dca28a386f495a8bff872eb6383f06e610b";
        libraryHaskellDepends = [ base containers mtl ];
        testHaskellDepends = [
          base containers deepseq HUnit mtl QuickCheck test-framework
@@ -89868,7 +90177,7 @@ self: {
      mkDerivation {
        pname = "marionetta";
        version = "0.1.0.3";
-       sha256 = "0k25m5q8p592xrg2qa0mvm3749gllrj4cmmx2h1k5hssan68bk9g";
+       sha256 = "2fcd858c555ac3320314bd564664a6f4257246dd15282c5eee22958b70a9454c";
        isLibrary = false;
        isExecutable = true;
        executableHaskellDepends = [
@@ -89889,7 +90198,7 @@ self: {
      mkDerivation {
        pname = "markdown";
        version = "0.1.13.2";
-       sha256 = "15aiwjs006g8aajw88rgfvrpcwaxml9hnpz7jrhmdm2pqxfrkb8z";
+       sha256 = "1fad995dc757d4566196e75f0b13ad5d7176f3762f23c4a552e81900b4e45195";
        libraryHaskellDepends = [
          attoparsec base blaze-html blaze-markup conduit conduit-extra
          containers data-default text transformers xss-sanitize
@@ -89912,7 +90221,7 @@ self: {
      mkDerivation {
        pname = "markdown-kate";
        version = "0.1.2.1";
-       sha256 = "0zjqy163rxpjy0w3bn21j193qp04f7sdc8mfskaddqfks402h4i0";
+       sha256 = "20122800d1d3e1d6d4d4ae22d6f471045c3c529041d83538f0f2f63c4cf0587e";
        libraryHaskellDepends = [
          attoparsec attoparsec-conduit base blaze-html conduit containers
          data-default highlighting-kate text transformers xss-sanitize
@@ -89932,7 +90241,7 @@ self: {
      mkDerivation {
        pname = "markdown-pap";
        version = "0.0.1.10";
-       sha256 = "0cq0s9yixkg98vhsgiv1xjia2cn0b4q6gjl1wv0q7yrm26anaqcq";
+       sha256 = "986165951135fb83c1e681ca673059c032a1a2ec61c7a7e146e9cd1e7dd20033";
        libraryHaskellDepends = [ base monads-tf papillon ];
        description = "markdown parser with papillon";
        license = stdenv.lib.licenses.bsd3;
@@ -89946,7 +90255,7 @@ self: {
      mkDerivation {
        pname = "markdown-unlit";
        version = "0.2.0.1";
-       sha256 = "1bc3vcifv2xcddh8liq380c6sxarrs5pf21pfs9i4dx9rfl3hvhq";
+       sha256 = "186e38a8cba9371293763708778bce59756d184003478a606bac8bed22db83ad";
        isLibrary = true;
        isExecutable = true;
        libraryHaskellDepends = [ base ];
@@ -89965,7 +90274,7 @@ self: {
      mkDerivation {
        pname = "markdown2svg";
        version = "0.0.1.27";
-       sha256 = "0sman1849sfr0d56kifpyb0ba9pqghvmyhr3gchcd13qimp80395";
+       sha256 = "250d806e8d7884c6207b23435f377cf826b5c0f2d7c5694a03d9e94450b0aa6a";
        isLibrary = false;
        isExecutable = true;
        executableHaskellDepends = [
@@ -89982,7 +90291,7 @@ self: {
      mkDerivation {
        pname = "marked-pretty";
        version = "1.1.2.1";
-       sha256 = "01dsqdckrm93ydc5frsxj55vgj238213qr31n1iybjdmw5x2r0dl";
+       sha256 = "b4812c7ae1b5c9e563b061643c824043c8b74b915d675758f323d53c59c3ba05";
        libraryHaskellDepends = [ base deepseq ghc-prim ];
        testHaskellDepends = [ base ];
        homepage = "https://github.com/ku-fpg/marked-pretty";
@@ -89995,7 +90304,7 @@ self: {
      mkDerivation {
        pname = "markov";
        version = "0.1";
-       sha256 = "1ka44rvrl9ppshbjmk95997cna670bqwjsharcr9qsalp6pchmdf";
+       sha256 = "ae55c8aeb954699c32cb0a6ac9f102c728cb4e4a25cd2a17d4f7269a772644cd";
        libraryHaskellDepends = [ base ];
        description = "Simple interpreter for Markov's normal algorithms";
        license = stdenv.lib.licenses.bsd3;
@@ -90006,7 +90315,7 @@ self: {
      mkDerivation {
        pname = "markov-chain";
        version = "0.0.3.3";
-       sha256 = "1y9fjsf6dg6a9ha75w2szq4gi5fhq89l1r7wqb20hmadkcjjplx8";
+       sha256 = "a8d32b259b4d5508c4c2fce44013c2d095f808fe5af072144ccabc669c962ef9";
        libraryHaskellDepends = [ base containers random transformers ];
        homepage = "http://code.haskell.org/~thielema/markov-chain/";
        description = "Markov Chains for generating random sequences with a user definable behaviour";
@@ -90020,7 +90329,7 @@ self: {
      mkDerivation {
        pname = "markov-processes";
        version = "0.0.2";
-       sha256 = "1pd09fdy05l3drmpdd3rbid6g2vdyalrpc704xmacbp186hmnf38";
+       sha256 = "68385ba141e12ea66a27e0b09ba9f26d8b675a5c79b4766b6e8316e09b4ba0dd";
        libraryHaskellDepends = [
          base bifunctors memoize MonadRandom random
        ];
@@ -90037,7 +90346,7 @@ self: {
      mkDerivation {
        pname = "markup";
        version = "1.1.0";
-       sha256 = "0p037nq20vdbrvn29n3xlaval98fs0lml3y5h0j9fy04x6zcdkz8";
+       sha256 = "e8cfc6bee90478972480c50f5a29d00e25aab6a27dd824ecceab6d20b03d035c";
        libraryHaskellDepends = [
          base blaze-html blaze-markup comonad lucid mtl text transformers
          urlpath
@@ -90055,7 +90364,7 @@ self: {
      mkDerivation {
        pname = "markup-preview";
        version = "0.2.2.1";
-       sha256 = "09gfmh9hdzyjijkv2h5a6gfa9rfmba2642rhhh80wsw9y4rg8ns1";
+       sha256 = "415bf432f1896b0e1084300b62845ad5e5a4dc33aa40b1a78cd2ff0613acee25";
        isLibrary = false;
        isExecutable = true;
        executableHaskellDepends = [
@@ -90077,7 +90386,7 @@ self: {
      mkDerivation {
        pname = "marmalade-upload";
        version = "0.10";
-       sha256 = "0643l0xnm4rq6zfbbd01ps3z7qnw7crvpblg7n5rwigi0m1zl4n9";
+       sha256 = "c912fa4305f1459e8b3d8faebb333bdce2f387be01b4b5dc3738936a3ba08318";
        isLibrary = true;
        isExecutable = true;
        libraryHaskellDepends = [
@@ -90112,7 +90421,7 @@ self: {
      mkDerivation {
        pname = "marquise";
        version = "4.0.0";
-       sha256 = "1w2lvns840hdzyismdwv70s70qd2af2ms14y58nhp24yf6h58j7b";
+       sha256 = "eb4854a0719e880b2d2a9e045d8553a2617034389bb7aaa3ff0d0282b4dd54f0";
        isLibrary = true;
        isExecutable = true;
        libraryHaskellDepends = [
@@ -90143,7 +90452,7 @@ self: {
      mkDerivation {
        pname = "marxup";
        version = "3.0.0.1";
-       sha256 = "01yz9ry25k6kq1r8z3dbqj2xqm95wssfh2jhwarv3w3z65wa6x8n";
+       sha256 = "1675a378317ff0b1b3e2500ae8b4e62555dc85c4ab8d8f72c0d3cc227c4edf07";
        isLibrary = true;
        isExecutable = true;
        libraryHaskellDepends = [
@@ -90169,7 +90478,7 @@ self: {
      mkDerivation {
        pname = "masakazu-bot";
        version = "0.4.0.0";
-       sha256 = "1p9d2vy3c7yh1w1aczh3f4886q0hldrpisnkk40w62cqvjg7sig7";
+       sha256 = "e7457d9edc9809c30199d3ea7873a31060831071037ea6020fd01f36fc162ddd";
        isLibrary = false;
        isExecutable = true;
        executableHaskellDepends = [
@@ -90190,7 +90499,7 @@ self: {
      mkDerivation {
        pname = "mastermind";
        version = "2010.7.25.1";
-       sha256 = "0bxzjs19n2c7xd1v2hrzx6h1rrw6m8yax7kbcar0q766bv36qfmy";
+       sha256 = "be3a6cc65ec61c0cb2626b9eae3caa86e71ca0e93f43b143eb87099b8296bf2f";
        isLibrary = false;
        isExecutable = true;
        executableHaskellDepends = [ base random ];
@@ -90204,7 +90513,7 @@ self: {
      mkDerivation {
        pname = "matchers";
        version = "0.24.0.0";
-       sha256 = "171ncbch38nzy46lb6p9navaar1b492hgf4b9kbd3g6fsldvny64";
+       sha256 = "c478bb1bd5cebcd1d64c8bb80745222b64a5b6b2e99a450df1dfa201d962369c";
        libraryHaskellDepends = [ base bytestring prednote text ];
        librarySystemDepends = [ pcre ];
        jailbreak = true;
@@ -90222,7 +90531,7 @@ self: {
      mkDerivation {
        pname = "math-functions";
        version = "0.1.5.2";
-       sha256 = "12cznf7gwia1ki7xhvlhk5p8d09zrdvfgn07pkp4sfrwsc4vijcy";
+       sha256 = "9ec9b809d33c3b4deebc07d8e776cb3f81866e99906ed84f9c4145fe8eb39f89";
        libraryHaskellDepends = [
          base deepseq erf vector vector-th-unbox
        ];
@@ -90243,7 +90552,7 @@ self: {
      mkDerivation {
        pname = "mathblog";
        version = "0.5";
-       sha256 = "01iyzrwscqirhcr4622d0n16mr4p54qbvg5m2a0ns36j59xfd79g";
+       sha256 = "2f9de67a2ad20c6d8112b5bcbd302997e46a82054d084332833962a679fe3e06";
        isLibrary = false;
        isExecutable = true;
        executableHaskellDepends = [
@@ -90265,7 +90574,7 @@ self: {
      mkDerivation {
        pname = "mathgenealogy";
        version = "1.3.0";
-       sha256 = "1gbk1bv5v7s4mbs3cr30zhfnm3zrhxhly3791mar5807bqw86q5v";
+       sha256 = "bb6083385e07a092550de90c4f6187f98f6a1dfc606436f4aa449f5df60a73bd";
        isLibrary = false;
        isExecutable = true;
        executableHaskellDepends = [
@@ -90285,7 +90594,7 @@ self: {
      mkDerivation {
        pname = "mathlink";
        version = "2.0.1.1";
-       sha256 = "1agqbhl6r40swsvsllyx9vf9hc9a709wvg546rh6fn315waifqqk";
+       sha256 = "136317152f6158676036a4bccd13382a3198dc4edd53aab7e61a906c285cf8a9";
        libraryHaskellDepends = [
          array base containers haskell98 ix-shapable mtl
        ];
@@ -90302,7 +90611,7 @@ self: {
      mkDerivation {
        pname = "matlab";
        version = "0.2.0.0";
-       sha256 = "08kalclinzqxy5l7j115hz6h9nw1g7mf9rzmpz8dblbhbwvj4l7x";
+       sha256 = "fd5022375f70d1d5d0bff5e7e4ea7981db04cd8725047968f11d7f1b29a36a22";
        libraryHaskellDepends = [ array base Cabal filepath ];
        librarySystemDepends = [ eng mat mx ];
        jailbreak = true;
@@ -90318,7 +90627,7 @@ self: {
      mkDerivation {
        pname = "matrices";
        version = "0.4.2";
-       sha256 = "1mcv3ihaf15biai6m98jfgv31whgmwbzgagxyj3bfpnilslp98l6";
+       sha256 = "86a274a9a6d15eb786f4fda9f717af0ff230f67312a56aa28aab04a7601c9bd5";
        revision = "1";
        editedCabalFile = "6aabde42e016b428562ed0e983444308c23d79837f04453fe57f60a6cbc02fe4";
        libraryHaskellDepends = [ base primitive vector ];
@@ -90336,7 +90645,7 @@ self: {
      mkDerivation {
        pname = "matrix";
        version = "0.3.4.4";
-       sha256 = "03aaw60x8849rsrcqc8n0d3k8a6dp8naxnqfq2xq776q5zbbcrpv";
+       sha256 = "fb66b6d62fd89c83bbc00edbae2cbacd283447031631ccb2ce8920d481e14a0d";
        libraryHaskellDepends = [ base deepseq loop primitive vector ];
        testHaskellDepends = [ base QuickCheck tasty tasty-quickcheck ];
        description = "A native implementation of matrix operations";
@@ -90348,7 +90657,7 @@ self: {
      mkDerivation {
        pname = "matrix-market";
        version = "1.2";
-       sha256 = "1hzpjkmwr24073mf9i13rx3n23ri0b5vmvwx8k9lxbrg1821hy28";
+       sha256 = "487818040a2faf4ed3449defbacb02310f6147cf23c4e4ea388088cceb94f7c3";
        libraryHaskellDepends = [ base bytestring ];
        homepage = "http://stat.stanford.edu/~patperry/code/matrix-market";
        description = "Read and write NIST Matrix Market files";
@@ -90360,7 +90669,7 @@ self: {
      mkDerivation {
        pname = "matrix-market-pure";
        version = "0.2";
-       sha256 = "05jjf5wnxhbafrca1qfzlrxvysy5bff22mzk45pia5b9gwdhygn1";
+       sha256 = "c13e0f1b7f6915156f21f357219c5bc56bbf7ba6dfe1a058766ac16e79715216";
        libraryHaskellDepends = [ array base containers ];
        homepage = "http://bitbucket.org/jetxee/hs-matrix-market";
        description = "Pure and composable reader and writer of the Matrix Market format";
@@ -90374,7 +90683,7 @@ self: {
      mkDerivation {
        pname = "matsuri";
        version = "0.0.4";
-       sha256 = "15pjqyy9qs9bn2vfayl73h5maf01snv7rvq1acb3ly8pain36lh4";
+       sha256 = "0452336c5417793a165301ef7cb6d50138550b1c877ae5b6b02b699cbcc7f296";
        isLibrary = false;
        isExecutable = true;
        executableHaskellDepends = [
@@ -90394,7 +90703,7 @@ self: {
      mkDerivation {
        pname = "maude";
        version = "0.6.1";
-       sha256 = "0qadqpj5vzg84mqh29p6vr2ffih7y69ds0jdpxmr17am5bh3mhql";
+       sha256 = "14c33ae02a559d906bbf4d02dd92f10746e744dee626017125e8fd5de4c54d61";
        libraryHaskellDepends = [
          base directory filepath process process-extras temporary text xml
        ];
@@ -90412,7 +90721,7 @@ self: {
      mkDerivation {
        pname = "maxent";
        version = "0.7";
-       sha256 = "0vxfxlvcrmqcxplw6f2r7nljcam9iv92jy2nxa7x67ldyj7yxk28";
+       sha256 = "48ccee8ff48d1ed38fea567829d28ea92a26a93d5938c3e9ed0cd7cc36edae6f";
        libraryHaskellDepends = [
          ad base lagrangian nonlinear-optimization vector
        ];
@@ -90432,7 +90741,7 @@ self: {
      mkDerivation {
        pname = "maximal-cliques";
        version = "0.1.1";
-       sha256 = "1sbmykgb5lrd32rih09d8d0r5isz4nh5slfyd93dgln7ag3hb7bh";
+       sha256 = "709d05c753c7d2d7466ade515da0255fc79241432d0118b3182dd3b2def475e9";
        libraryHaskellDepends = [ base containers vector ];
        description = "Enumerate all maximal cliques of a graph";
        license = stdenv.lib.licenses.bsd3;
@@ -90446,7 +90755,7 @@ self: {
      mkDerivation {
        pname = "maxsharing";
        version = "1.0.2";
-       sha256 = "1a9z3bmdjl5mhn718bj8h95m4xlhiyimkz7z54d0dmcv6ryld4wx";
+       sha256 = "9d93467d369bd5061a29fffc59a38f9076524b82482e148e85b550d9ea1a3fa9";
        isLibrary = false;
        isExecutable = true;
        executableHaskellDepends = [
@@ -90466,7 +90775,7 @@ self: {
      mkDerivation {
        pname = "maybe-justify";
        version = "0.1.0.0";
-       sha256 = "0zgc3niz0vz4b3xcxj6s4fpxzizgkimllyd0r6vcafbl9ffv2a38";
+       sha256 = "6828b19d4b7439c5b6c9a0794a6b9cefc7dfaf23dac8cefa58e46ff0a31dec7d";
        libraryHaskellDepends = [ base ];
        testHaskellDepends = [ base tasty tasty-hunit ];
        description = "Simple higher order function for Maybe";
@@ -90480,7 +90789,7 @@ self: {
      mkDerivation {
        pname = "maybench";
        version = "0.2.4.1";
-       sha256 = "1iqfmvj9maa0f4gk66g0j1dv1prhac3vb0b225d9sw9bliwnb1br";
+       sha256 = "79856579a42b719d5a116281b5075330dfb05b90e019331f7140a99ae4ae0ec7";
        isLibrary = true;
        isExecutable = true;
        libraryHaskellDepends = [ base benchpress old-time process ];
@@ -90499,7 +90808,7 @@ self: {
      mkDerivation {
        pname = "mbox";
        version = "0.3.1";
-       sha256 = "13hq6h280wbc9xwbvdcq4qqrhbjnnzg824lk4zxkh4bvqpabjwni";
+       sha256 = "d172b9d4c57b1138fb27931281deb7562e98312698b5bd784f6c71800434188e";
        libraryHaskellDepends = [ base safe text time time-locale-compat ];
        description = "Read and write standard mailbox files";
        license = stdenv.lib.licenses.bsd3;
@@ -90512,7 +90821,7 @@ self: {
      mkDerivation {
        pname = "mbox-tools";
        version = "0.2.0.4";
-       sha256 = "1j0dl97skgbxq2gcd3w6jzsdd2yv1mw6z4fz61akcimzyn8c2lvh";
+       sha256 = "7053c190f5bf46365530df916f780ddb8bd6f497868fc69ec07dbda94fa20dc8";
        isLibrary = false;
        isExecutable = true;
        executableHaskellDepends = [
@@ -90530,7 +90839,7 @@ self: {
      mkDerivation {
        pname = "mcmaster-gloss-examples";
        version = "2013";
-       sha256 = "178f2n2r7m4jznkzhnqqslqf0czvz9h7cifhbdmvr1nihhgb532q";
+       sha256 = "588cb21e84d186bc6b5bd0457660fafb33e030d5185bf8a7fd92d49385150e9d";
        isLibrary = false;
        isExecutable = true;
        executableHaskellDepends = [ base gloss ];
@@ -90546,7 +90855,7 @@ self: {
      mkDerivation {
        pname = "mcmc-samplers";
        version = "0.1.1.1";
-       sha256 = "0pqc6i86b5vdhfw93x220k0x7dcfs77s7az6avaw7fn2q6xl1qli";
+       sha256 = "91e240bbc1c2bac3d556e6aba3cfd18eb5d3c10442f491b8836d976550340c5f";
        libraryHaskellDepends = [
          base containers hakaru hmatrix mwc-random primitive statistics
        ];
@@ -90561,7 +90870,7 @@ self: {
      mkDerivation {
        pname = "mcmc-synthesis";
        version = "0.1.2.2";
-       sha256 = "14z1x9dqnjj391nrlngs9s887yqh3arc7kfgk0m3d89vrkc185vq";
+       sha256 = "781714d8cc3ba1362a98cfcdc3b21a10fb83904efa599a6d48434a8b5beae193";
        libraryHaskellDepends = [ base MonadRandom ];
        jailbreak = true;
        description = "MCMC applied to probabilistic program synthesis";
@@ -90573,7 +90882,7 @@ self: {
      mkDerivation {
        pname = "mcpi";
        version = "0.0.1.2";
-       sha256 = "15ab4fl49nq398q49wz5fgphfb7xzbrf4j51rnd80qb30rm6xfl6";
+       sha256 = "86ba6e6a066361809acda148e2f2fafd2c07ef73e5f344304a03db44a8234b95";
        isLibrary = true;
        isExecutable = true;
        libraryHaskellDepends = [ base network split transformers ];
@@ -90590,7 +90899,7 @@ self: {
      mkDerivation {
        pname = "mdcat";
        version = "0.1.0.4";
-       sha256 = "0jynmcawrxwv6xfbwvz3915rsp2ssx9s8h7i3pgd5adlzqpws19l";
+       sha256 = "3405cd2ffeb4a9d2de1df140a453d75a5c9d4b48e36fbe5c379bf7cc15abd64b";
        isLibrary = true;
        isExecutable = true;
        libraryHaskellDepends = [
@@ -90611,7 +90920,7 @@ self: {
      mkDerivation {
        pname = "mdo";
        version = "0.0.1";
-       sha256 = "13i4lb74m69k6ij3rq0dqwghdazwmc60fs55prc1h3p7b0rz15mv";
+       sha256 = "bb96f03358e70e1858bea568070cabfcab061fc70de03c643433994acea2248e";
        isLibrary = false;
        isExecutable = true;
        executableHaskellDepends = [ base process ];
@@ -90624,7 +90933,7 @@ self: {
      mkDerivation {
        pname = "mecab";
        version = "0.4.0";
-       sha256 = "0z650y4fnxr4mk0i5s8axjbq14dcpgnrzkafbpg17vfhl2v5a3z3";
+       sha256 = "e30f55b6a0d0ed13de5d4ecd9fedbbac918097ec0ae912c1ac2477eb8807c57c";
        libraryHaskellDepends = [ base bytestring text ];
        librarySystemDepends = [ mecab ];
        jailbreak = true;
@@ -90639,7 +90948,7 @@ self: {
      mkDerivation {
        pname = "mecha";
        version = "0.1.1";
-       sha256 = "0y3rzif667kjaxmnf9d382lcbxf27y4ik02kisij125kc7yi6d21";
+       sha256 = "413413fd61b38820a38e538019893fc2f5c5a840a325676b57721e635cfc7978";
        isLibrary = true;
        isExecutable = true;
        libraryHaskellDepends = [ base ];
@@ -90655,7 +90964,7 @@ self: {
      mkDerivation {
        pname = "mediawiki";
        version = "0.2.6";
-       sha256 = "1wfrhii7zqrw6rmskab40h9zliidi34kd4n07rdkvf8f8nypwg1r";
+       sha256 = "393c7ebd450eb93d5b3ec09236c9882d46fa130464a9a96b363ce37f6284d9f1";
        isLibrary = true;
        isExecutable = true;
        libraryHaskellDepends = [ base HTTP mime network utf8-string xml ];
@@ -90677,7 +90986,7 @@ self: {
      mkDerivation {
        pname = "mediawiki2latex";
        version = "7.9.0.1";
-       sha256 = "0q708hh5280k5hknf1mh3nza7qvpszplcis90y0i78a2jd0x2r3w";
+       sha256 = "7c64d1419342a1138107494746efd777e3a3be1db00667272c1320512044e060";
        isLibrary = false;
        isExecutable = true;
        executableHaskellDepends = [
@@ -90701,7 +91010,7 @@ self: {
      mkDerivation {
        pname = "meep";
        version = "0.1.2.0";
-       sha256 = "1jr3zgja3m40ajygi1jqsxfwhsf7yf0lwblffd8z096w67pn4idr";
+       sha256 = "b94562ef31dc24f051738e2e4e81f3c769c85dd75886f8bc5480d4a1e4fb23cb";
        libraryHaskellDepends = [
          base bifunctors lens semigroupoids semigroups
        ];
@@ -90721,7 +91030,7 @@ self: {
      mkDerivation {
        pname = "mega-sdist";
        version = "0.2.10.4";
-       sha256 = "0x85l77q9zzi1gmcl9h3rrjbgyfynxqcczl636iah88wvdg7lplg";
+       sha256 = "8f5e7a5edb1c21a8a219867ec670b7def9b764ce0326caea0bf1ff84cfa10575";
        isLibrary = false;
        isExecutable = true;
        executableHaskellDepends = [
@@ -90740,7 +91049,7 @@ self: {
      mkDerivation {
        pname = "meldable-heap";
        version = "2.0.3";
-       sha256 = "1p75zjlls38sd1lma7w95mpmb9kdff19s2as6pz1ki1g20nnxdk3";
+       sha256 = "63b66e2d102fc419fe355a099d82736da6556f2d891f5569681a0d4da9fce5dc";
        libraryHaskellDepends = [ base ];
        homepage = "http://code.google.com/p/priority-queues/";
        description = "Asymptotically optimal, Coq-verified meldable heaps, AKA priority queues";
@@ -90754,7 +91063,7 @@ self: {
      mkDerivation {
        pname = "melody";
        version = "0.2";
-       sha256 = "1sbwd1xmgh94ll3xm7ancjsaalk2mphnr1l331zix5s3kqvy6g6p";
+       sha256 = "d73ce3379e43971e7f1883866ce1ad6252a5b464569dda07a524c1577b687ce9";
        isLibrary = true;
        isExecutable = true;
        libraryHaskellDepends = [
@@ -90777,7 +91086,7 @@ self: {
      mkDerivation {
        pname = "memcache";
        version = "0.1.0.0";
-       sha256 = "1x2lw802m02p9z28rsmvwczsax9f6vl16p9kwjq4zmn8ak0s74m5";
+       sha256 = "a592a3c154c8d64fb0e4335d13e8362e75a53fe3bbea8cc44f57802a00e254f4";
        revision = "1";
        editedCabalFile = "6e2508fa18aae99fee1c0aa41cc86e97d73ff504647b5265e54adf3566ca81e7";
        libraryHaskellDepends = [
@@ -90798,7 +91107,7 @@ self: {
      mkDerivation {
        pname = "memcache-conduit";
        version = "0.0.3";
-       sha256 = "1y1jysshvwddr3rymbzr9s6bq4pg7rd0bkk7ip4xwa8kpzf8k3pj";
+       sha256 = "f28e89dcbf1329dec98d67ce055a3eef12bc8c4ef9afeaf3c8adf10db5f632f8";
        isLibrary = true;
        isExecutable = true;
        libraryHaskellDepends = [
@@ -90823,7 +91132,7 @@ self: {
      mkDerivation {
        pname = "memcache-haskell";
        version = "0.0.10.1";
-       sha256 = "0j3fn59nz4iynlmhv3hxbfqip0rjj94fkb3kx8jax90jbnf7s6sc";
+       sha256 = "4c1b7d9c5d12a4ae24ea73ace9489232831bb15b1d8e0d2bb53e926f53b16e48";
        isLibrary = true;
        isExecutable = true;
        libraryHaskellDepends = [
@@ -90846,7 +91155,7 @@ self: {
      mkDerivation {
        pname = "memcached";
        version = "0.2.1";
-       sha256 = "1a6wzznhpz06c0y3wrjf5bskdd8myild8v0p0x1h0swhmy6di2yd";
+       sha256 = "cd8bd88caf906b004307176cd468f415b536f52a4e663e3c6006fc0bedffdca8";
        libraryHaskellDepends = [ base bytestring network utf8-light ];
        jailbreak = true;
        homepage = "http://github.com/olegkat/haskell-memcached";
@@ -90862,7 +91171,7 @@ self: {
      mkDerivation {
        pname = "memcached-binary";
        version = "0.2.0";
-       sha256 = "137vb065f744jq3avpraqryzspch78vc5krp0fw2zzcbk5cm92ad";
+       sha256 = "4d895459998bfd2fb80337cfc2363a905dfd7dc62adfad0696841c570c58fb8c";
        revision = "2";
        editedCabalFile = "663a104dc09413397f9640534b6d1a743835a395598f641d02ef0dbd44093530";
        libraryHaskellDepends = [
@@ -90882,7 +91191,7 @@ self: {
      mkDerivation {
        pname = "memexml";
        version = "0.0.2";
-       sha256 = "07cmjx10wbpfcblnd23rzdkma04nyjcpd1g58gp0phajj6xj4i7a";
+       sha256 = "ea4422bb9152c10bee43e5857699f496005567fb798866e962ee2e0e4297951d";
        revision = "1";
        editedCabalFile = "a1712ea7643a27f1fb40a771fdae76282818b5d317fe8da6a22e705b06bc3b3e";
        libraryHaskellDepends = [ base hxt ];
@@ -90897,7 +91206,7 @@ self: {
      mkDerivation {
        pname = "memo-ptr";
        version = "0.1.0.0";
-       sha256 = "1vy3673dvf0crs384vhi56i7bir9k8yk3cjcrcc7bn15qyclif19";
+       sha256 = "29b84899c725d87518cb4cb2313d9a29c775a229116e8286ce0cb8ddc631c3ef";
        libraryHaskellDepends = [ base containers ];
        description = "Pointer equality memoization";
        license = stdenv.lib.licenses.mit;
@@ -90908,7 +91217,7 @@ self: {
      mkDerivation {
        pname = "memo-sqlite";
        version = "0.1";
-       sha256 = "1gijza29wj79k8czfg4mghq7nqsbpyf1scnm9hmg2ykhnllpzvy3";
+       sha256 = "c3ef7f29b5707af12a4cd5321d9cbf4b637b307c953cf7199ae9489e84fa32be";
        libraryHaskellDepends = [ base direct-sqlite ];
        jailbreak = true;
        homepage = "https://gitorious.org/memo-sqlite";
@@ -90922,7 +91231,7 @@ self: {
      mkDerivation {
        pname = "memoize";
        version = "0.7";
-       sha256 = "1sqi9n9r2q3sh00isgj3rmayrlm970a2g9x389rlfb0kczixdnq4";
+       sha256 = "04dbd6e367132c477342a3a7271438a9d2ec55cd433e1d01807a6091934d11eb";
        libraryHaskellDepends = [ base template-haskell ];
        description = "A memoization library";
        license = stdenv.lib.licenses.bsd3;
@@ -90935,7 +91244,7 @@ self: {
      mkDerivation {
        pname = "memory";
        version = "0.7";
-       sha256 = "1yj1v4xr3y3inrn1rzlh1lfmgxi8p15k4qm48bac76qg3a2wh8z1";
+       sha256 = "e123c8851a0f9bc3d442a462324bb828f6571d0d90fe1c6cb671f8913bd941fa";
        libraryHaskellDepends = [ base bytestring deepseq ghc-prim ];
        testHaskellDepends = [ base tasty tasty-hunit tasty-quickcheck ];
        homepage = "https://github.com/vincenthz/hs-memory";
@@ -90948,7 +91257,7 @@ self: {
      mkDerivation {
        pname = "memscript";
        version = "0.0.2.0";
-       sha256 = "0vbmgvdjq4mxax39zr6anmb96pr2pgqlwmc4qbkrz2c7v8hg2mjb";
+       sha256 = "4b56f120da87899fe7c284554ef1bb225f9356b5cae49f4657bd122cdb7e756d";
        isLibrary = false;
        isExecutable = true;
        executableHaskellDepends = [ base readline ];
@@ -90962,7 +91271,7 @@ self: {
      mkDerivation {
        pname = "mersenne-random";
        version = "1.0.0.1";
-       sha256 = "193qz3wn7lz18aywddr9qyn8v08ifv2yxwr68c67p5mn8vr8mvmw";
+       sha256 = "bcee8af246b6967b0c4326f3eec57611818dacc729b7c6bd42e1d363f9f878a4";
        libraryHaskellDepends = [ base old-time ];
        homepage = "http://code.haskell.org/~dons/code/mersenne-random";
        description = "Generate high quality pseudorandom numbers using a SIMD Fast Mersenne Twister";
@@ -90974,7 +91283,7 @@ self: {
      mkDerivation {
        pname = "mersenne-random-pure64";
        version = "0.2.0.4";
-       sha256 = "0qh72ynfg1k4c70qxdzsa6f1x9wyxil2d9gi85c879wrc41k899h";
+       sha256 = "302534036199a7835841f1a52668ec9ea71e9c51fab78ec1616486e7ac170762";
        libraryHaskellDepends = [ base old-time random ];
        homepage = "http://code.haskell.org/~dons/code/mersenne-random-pure64/";
        description = "Generate high quality pseudorandom numbers purely using a Mersenne Twister";
@@ -90988,7 +91297,7 @@ self: {
      mkDerivation {
        pname = "messagepack";
        version = "0.4.0";
-       sha256 = "198rd9yy99zsgp48gmz3kxzljcpmbqh2gghzndn3q0n7cv0lls0i";
+       sha256 = "11684ac166c7023c6cb31fbe27205ef532497f9fe3d787c87dfaa7e47d6a19a5";
        libraryHaskellDepends = [ base bytestring cereal containers ];
        testHaskellDepends = [
          base bytestring cereal containers QuickCheck test-framework
@@ -91006,7 +91315,7 @@ self: {
      mkDerivation {
        pname = "messagepack-rpc";
        version = "0.2.0.0";
-       sha256 = "0lx0qyv41pylbz2580zvw4qw07pih4l9sbdd2h99gwkqjpjnc8x8";
+       sha256 = "a82366e59578f2971214ad2d9d2881f11ec031e1fb0354c45fd4df40b6c7a053";
        libraryHaskellDepends = [
          base bytestring cereal containers messagepack network-simple
        ];
@@ -91020,7 +91329,7 @@ self: {
      mkDerivation {
        pname = "messente";
        version = "0.1.0.1";
-       sha256 = "1yv2dspkn34yf61z8c09aijngjr96w30s2sjmhyv9c2c48ys6jc5";
+       sha256 = "8549a33d224cb0b43dac520b0d063729cb6765540930f483719e0c3baf6e62fb";
        libraryHaskellDepends = [
          base bytestring HTTP http-conduit network
        ];
@@ -91034,7 +91343,7 @@ self: {
      mkDerivation {
        pname = "meta-misc";
        version = "0.1.0.3";
-       sha256 = "0pxsg67r2z0f9zxr8m98sndlii0bixyxwgjkc31z5743ciw9ch0c";
+       sha256 = "0c40967864839cf2c360533ede7d8f0bc4489bd5285594fb4f0e7c918f79ba5f";
        libraryHaskellDepends = [ base loch-th template-haskell ];
        homepage = "https://github.com/bairyn/meta-misc";
        description = "Utility library providing miscellaneous meta-programming utilities";
@@ -91048,7 +91357,7 @@ self: {
      mkDerivation {
        pname = "meta-par";
        version = "0.3";
-       sha256 = "012blwbwxac2wikiydvjsa4b7f866wws3g33bczv8dzcx3123ljn";
+       sha256 = "56d221c2e8ec37b43f5b63bca1393706b9b388d272371f67e482a9ce17a74b04";
        libraryHaskellDepends = [
          abstract-deque abstract-par base bytestring containers deepseq mtl
          mwc-random transformers vector
@@ -91066,7 +91375,7 @@ self: {
      mkDerivation {
        pname = "meta-par-accelerate";
        version = "0.3.5";
-       sha256 = "0gl6bh2jqf697vl4cg88z39g6180bbha01h67qz46f1vcyvi0lwq";
+       sha256 = "985310b7673b38433e3e0606a0e05a0005f3d2f8083d46e83ec9382c055c863e";
        libraryHaskellDepends = [
          abstract-deque abstract-par abstract-par-accelerate accelerate
          array base meta-par QuickCheck transformers vector
@@ -91082,7 +91391,7 @@ self: {
      mkDerivation {
        pname = "metadata";
        version = "0.2.0.0";
-       sha256 = "148c7vgh8zxgy5fb0xflk0lzm5d233d1ynjncpiwi1bb9jzbdm3r";
+       sha256 = "79d4b6be4c6b85c8e365565a1fda18a295fa2998d475b05cf1af7f04df3e0c91";
        libraryHaskellDepends = [ base text time ];
        jailbreak = true;
        homepage = "http://github.com/cutsea110/metadata";
@@ -91095,7 +91404,7 @@ self: {
      mkDerivation {
        pname = "metamorphic";
        version = "0.1.2.3";
-       sha256 = "0pazw2kdsl8g4dax6bg0hfg7vp2nna6lrsnzdkixpins7ac95078";
+       sha256 = "e88092983adac6dbe36cdfea4c8db256dc7d9e83e02dd355230f51dda6e05f5d";
        libraryHaskellDepends = [ base ];
        homepage = "http://github.com/technogeeky/metamorphic";
        description = "metamorphisms: ana . cata or understanding folds and unfolds";
@@ -91107,7 +91416,7 @@ self: {
      mkDerivation {
        pname = "metaplug";
        version = "0.1.1";
-       sha256 = "086n9kqyi2jqki31jgylm0r63ahgvw3pf7mi5hln2m86a5x4ij4n";
+       sha256 = "96c8487a51065561292cb11e7707df0faa6132a8d43f19469c588ae8f14cd620";
        libraryHaskellDepends = [ base Cabal filepath ghc haskell98 ];
        description = "a tiny ghc api wrapper";
        license = stdenv.lib.licenses.bsd3;
@@ -91121,7 +91430,7 @@ self: {
      mkDerivation {
        pname = "metric";
        version = "0.2.0";
-       sha256 = "172drfn8p5yqyvka2jphhi1lfj5msv2xssa271lfb3w757br452d";
+       sha256 = "4d1492d729878fe568384269ddc5d6b548474384f04aa1e6f6d8978baccb4d9c";
        libraryHaskellDepends = [
          base data-default edit-distance hmatrix vector
        ];
@@ -91141,7 +91450,7 @@ self: {
      mkDerivation {
        pname = "metrics";
        version = "0.3.0.2";
-       sha256 = "00iwairgi9lvb4f8iz4d834v8vq1f4awr34nl72fbkqgccdq1whd";
+       sha256 = "0df2801b630fcfe5c4a1968ccc1571016fb4c9408dfc881c599ba6f872543c02";
        libraryHaskellDepends = [
          ansi-terminal base bytestring containers lens mtl mwc-random
          primitive text time unix unordered-containers vector
@@ -91159,7 +91468,7 @@ self: {
      mkDerivation {
        pname = "metricsd-client";
        version = "0.1";
-       sha256 = "1q807wvmj1q605257jj60h0j2wal6ypjiad9wkjmv836p3mis5q9";
+       sha256 = "09171debb866a05de5e4a9a928af37547121010446ca534401060759373f00e1";
        libraryHaskellDepends = [ base network ];
        jailbreak = true;
        description = "Client for the metrics aggregator Metricsd";
@@ -91171,7 +91480,7 @@ self: {
      mkDerivation {
        pname = "metronome";
        version = "0.1";
-       sha256 = "0gx0g8s5w99mhvip1v1kj03dhij3fhig1b8myha0zdssf2x6vjwc";
+       sha256 = "8ccb6dba705ab70f14f415adf022744346d8069033ec70e38635255e347aa03f";
        libraryHaskellDepends = [
          base data-lens data-lens-template hosc stm
        ];
@@ -91187,7 +91496,7 @@ self: {
      mkDerivation {
        pname = "mfsolve";
        version = "0.1.0";
-       sha256 = "1lvx3nlxhfmvh9xbi62hik8ypv4n28ax86nqzwkchb60k1djnagg";
+       sha256 = "ef292b5b98c02cc826ffd81ad4151296ecebd18c5098b87a82bb3ad8a91d7dd3";
        libraryHaskellDepends = [ base hashable unordered-containers ];
        testHaskellDepends = [ base tasty tasty-hunit ];
        description = "Equation solver and calculator à la metafont";
@@ -91199,7 +91508,7 @@ self: {
      mkDerivation {
        pname = "mgeneric";
        version = "0.0.0.2";
-       sha256 = "1pgmgssysl0nv9z4vvlmxjijl6y7jvy1b7ph30jnj3fmcrwdf6w3";
+       sha256 = "831bd77866d50d692518f09e15fc96c71b2aa3ec95ee4d7eda1650edb57ef5dd";
        libraryHaskellDepends = [
          base containers lens mtl template-haskell
        ];
@@ -91215,7 +91524,7 @@ self: {
      mkDerivation {
        pname = "mi";
        version = "0.0.1";
-       sha256 = "03virg707xxy330xq4g60fy1rvs1rq9w5p08yc5khzh64v1g3i2b";
+       sha256 = "4bc4f1c226067e380bf308dcc213ce41ef1cbc03e611dcc118bef703cecb710f";
        libraryHaskellDepends = [
          base haskell-src-meta parsec split template-haskell
        ];
@@ -91230,7 +91539,7 @@ self: {
      mkDerivation {
        pname = "microbench";
        version = "0.1";
-       sha256 = "05yphn77rxg7zqpn27292yvmah2634hqfx2mgfyp5yws5ickrvkg";
+       sha256 = "6fee3c592c9afb72bd7b5574872119464055b717491c612ffee7f57c8e85d717";
        libraryHaskellDepends = [ base time ];
        homepage = "http://neugierig.org/software/darcs/browse/?r=microbench;a=summary";
        description = "Microbenchmark Haskell code";
@@ -91247,7 +91556,7 @@ self: {
      mkDerivation {
        pname = "microformats2-parser";
        version = "0.1.1";
-       sha256 = "0n4clyzaw2a9vi0qcf6f2pdp7wckl3z84sfjqdj8k4dbp1qnwl55";
+       sha256 = "a5506e71b8ab918964c3d26982fea093f173db15ce388641dc4909aebea78c58";
        isLibrary = true;
        isExecutable = true;
        libraryHaskellDepends = [
@@ -91275,7 +91584,7 @@ self: {
      mkDerivation {
        pname = "microformats2-types";
        version = "0.4.1";
-       sha256 = "1p2s2g78bnqbcf0www0x11pz5nyxjfac7q7sbd2qfn1v777ylv7b";
+       sha256 = "eb6ceacf393b5887455bfae0c39493dddbf26f081d70ce81630bdb85ce135adc";
        libraryHaskellDepends = [
          aeson base data-default-class pandoc-types setters text time
        ];
@@ -91289,7 +91598,7 @@ self: {
      mkDerivation {
        pname = "microlens";
        version = "0.2.0.0";
-       sha256 = "08m0qcsazq690w1k6hd2h3z8w47bqc01s53j6qbf3jbfin28axbg";
+       sha256 = "6f7585848d6ec9e1163672141d00c3eb108efe80a241330307c9e0af34c3a022";
        libraryHaskellDepends = [ base ];
        homepage = "http://github.com/aelve/microlens";
        description = "A tiny part of the lens library which you can depend upon";
@@ -91301,7 +91610,7 @@ self: {
      mkDerivation {
        pname = "microlens-each";
        version = "0.1.0.0";
-       sha256 = "00bk2vriwh8aj2c6n5g2w84pfq0nssfa62iw97dm9c3zkp558wxj";
+       sha256 = "b27354ca9d7fb054db493c0aa39cd616607709e2e2156b98900a411ef3167301";
        libraryHaskellDepends = [ base microlens ];
        jailbreak = true;
        homepage = "http://github.com/aelve/microlens";
@@ -91314,7 +91623,7 @@ self: {
      mkDerivation {
        pname = "microlens-ghc";
        version = "0.1.0.1";
-       sha256 = "17kkh6dnxhr2j1a9nll5ia0y5rd68icxjjk4kqs0wml1whmhhg55";
+       sha256 = "a53c082be481560e349e644ad95944a6e5e2818a85529b549022c36e9b81739e";
        libraryHaskellDepends = [
          array base bytestring containers microlens
        ];
@@ -91330,7 +91639,7 @@ self: {
      mkDerivation {
        pname = "microlens-mtl";
        version = "0.1.3.1";
-       sha256 = "118ym5n1c6b2lg815hikzbwc4bnz8kz3j4flfxwq3m50dbn29vzc";
+       sha256 = "ecef24ec6aa0d4817977d41139fe44df2ec2f8fa33c212d0a36219166ca91e85";
        libraryHaskellDepends = [
          base microlens mtl transformers transformers-compat
        ];
@@ -91344,7 +91653,7 @@ self: {
      mkDerivation {
        pname = "microlens-th";
        version = "0.2.1.0";
-       sha256 = "1l4hxkq8z8h6pvld54bjlnzy5g30wr0akv1xjrjyk552mfi9gwvl";
+       sha256 = "74f397a2aba294e965963deca940e660bce2bfa57291d2e8be06a28ff0ec90d0";
        libraryHaskellDepends = [
          base containers microlens template-haskell
        ];
@@ -91358,7 +91667,7 @@ self: {
      mkDerivation {
        pname = "microtimer";
        version = "0.0.1.2";
-       sha256 = "09w8jn6g8fq3zsp2ahdrzv33mvayh8vladmc2wf8pbmpmdii0kap";
+       sha256 = "574d1063abb7ae8b1c17ac364537825eed3ac6feb94125aefe033bf48c958827";
        libraryHaskellDepends = [ base time ];
        homepage = "http://thoughtpolice.github.com/hs-microtimer";
        description = "A tiny library for benchmarking IO actions";
@@ -91374,7 +91683,7 @@ self: {
      mkDerivation {
        pname = "mida";
        version = "0.4.3";
-       sha256 = "0x71qih8r48kp2anvdnwfkja3sz8iigzprsqkaqi259mn58qd9ch";
+       sha256 = "90a58651b1351511b19a58e7fb5f8ce8eba1e474dcb66d95b813918c60c4e174";
        isLibrary = true;
        isExecutable = true;
        libraryHaskellDepends = [
@@ -91405,7 +91714,7 @@ self: {
      mkDerivation {
        pname = "midi";
        version = "0.2.1.5";
-       sha256 = "0vi9pslbix7wcbciv3nlk1v6v6f45xf1lq85nl8awhs488fhbl3z";
+       sha256 = "7fd0051d424443ae10b505611a5c2fc4996d7698d48e1dd962fcf4b8a8be296e";
        libraryHaskellDepends = [
          base binary bytestring event-list explicit-exception
          monoid-transformer non-negative QuickCheck random transformers
@@ -91425,7 +91734,7 @@ self: {
      mkDerivation {
        pname = "midi-alsa";
        version = "0.2.1";
-       sha256 = "13dc299d252nrll1vzp7pl1ncv0qw3xhz5b3kqnc8hb0g4mkkgpc";
+       sha256 = "ecbe392b796041c42c9e63950ffbe0186c6603bde7fe1d28cd5614d15212ac8d";
        libraryHaskellDepends = [
          alsa-seq base data-accessor midi utility-ht
        ];
@@ -91442,7 +91751,7 @@ self: {
      mkDerivation {
        pname = "midi-music-box";
        version = "0.0";
-       sha256 = "0hnlnjgn378mkrhky8fvpzs6i34s3n6lx81mf3hnxmb1vgwy2nmf";
+       sha256 = "ae5ae1f9db61d56ee17035a04e8d1d9a8c68f4bfdb213f619e159d619fb4d442";
        isLibrary = false;
        isExecutable = true;
        executableHaskellDepends = [
@@ -91460,7 +91769,7 @@ self: {
      mkDerivation {
        pname = "midi-util";
        version = "0.1.1.1";
-       sha256 = "1g8rhx1n6rhyi49x6rkim1bnv7rg6wc0x89dzkrbzyxm28hkvjfk";
+       sha256 = "d3c93d2112b5fbbff2fc2da10e18372f9f6d57a87166d313891e6663438719bd";
        revision = "1";
        editedCabalFile = "2c42b8e0940125f6354a9174ad5cb19da6fc0122b4947576e28abb753a7cff14";
        libraryHaskellDepends = [
@@ -91478,7 +91787,7 @@ self: {
      mkDerivation {
        pname = "midimory";
        version = "0.0.0.2";
-       sha256 = "13bfb2s6ybvspmmq427v55nb2csvcp4ijfgm9fvfh6cab2pm1dyz";
+       sha256 = "dfb750af588a19e8b64bf53919c9655b33b16c29fb08826bbd7a2f6fb4586e8d";
        isLibrary = false;
        isExecutable = true;
        executableHaskellDepends = [
@@ -91497,7 +91806,7 @@ self: {
      mkDerivation {
        pname = "midisurface";
        version = "0.1.0.0";
-       sha256 = "0i1g1hqr1jjjnrrkfgp0i9zm5cm6aza1kzqy2z8hmbqjdvyv21fz";
+       sha256 = "df05b1fd6e12af0ad1171eff19d457a6b2527f8ae03e3773b652ca90310c2f44";
        isLibrary = false;
        isExecutable = true;
        executableHaskellDepends = [
@@ -91517,7 +91826,7 @@ self: {
      mkDerivation {
        pname = "mighttpd";
        version = "0.4.3";
-       sha256 = "0xl6x4755x8sz2igqfp3mr5n29q7hb4v5b1mycah9vffk1bhi0yf";
+       sha256 = "ce83085798ceed0415f335acb2c9820727614baee33afca2f81af5520ee98676";
        isLibrary = false;
        isExecutable = true;
        executableHaskellDepends = [
@@ -91541,7 +91850,7 @@ self: {
      mkDerivation {
        pname = "mighttpd2";
        version = "3.2.9";
-       sha256 = "0gxdf9xkw1w4cdb8cdq1slj5x1ch39kxrqhnaxdkb8w4jdxqbj5p";
+       sha256 = "b7c8857b9384a3355b5716e2dc671a90855e24d5013786566384073e7b72ad3f";
        isLibrary = true;
        isExecutable = true;
        libraryHaskellDepends = [
@@ -91566,7 +91875,7 @@ self: {
      mkDerivation {
        pname = "mikmod";
        version = "0.2.0.0";
-       sha256 = "0wr671a7r20ysnry92qimdsdnf5gijbxzv382mb7w8fav88v5kvv";
+       sha256 = "7bcfb211daca217e561568ecdf978caf38db74ab118be4b3d51e887c54382673";
        libraryHaskellDepends = [ base bytestring ];
        jailbreak = true;
        homepage = "https://github.com/evanrinehart/mikmod";
@@ -91581,7 +91890,7 @@ self: {
      mkDerivation {
        pname = "miku";
        version = "2014.11.17";
-       sha256 = "1zfvi7v05cdp94cdrwxxhwkzqyliaakl16klk9zb0byvsg32ns3n";
+       sha256 = "76682bc6d3db2fb07e9a749a40a752917afc2787bdf3dc1849b7b102f689dbfd";
        libraryHaskellDepends = [
          air air-th base bytestring containers data-default hack2
          hack2-contrib mtl
@@ -91599,7 +91908,7 @@ self: {
      mkDerivation {
        pname = "milena";
        version = "0.2.0.0";
-       sha256 = "08nfjd1jn9cniksj8zrifaz3fjgnhzgydlswbz2h4lqv9kyqvvrm";
+       sha256 = "35ef8dfd4c1b5302c55f5cd3e6df87f64937be72317f24f58c96252b4393ce22";
        libraryHaskellDepends = [
          base bytestring cereal containers digest either lens mtl network
          random resource-pool transformers
@@ -91616,7 +91925,7 @@ self: {
      mkDerivation {
        pname = "mime";
        version = "0.4.0.2";
-       sha256 = "0x9qx8adradc5irfwfn4xs4j9pd228j1b3lpngap2qxabhz2iyp7";
+       sha256 = "e7fa283e5caa6371d5b3978e152412a2dd2489eec43aee722caca9dc14ea3875";
        libraryHaskellDepends = [ base text ];
        homepage = "https://github.com/GaloisInc/mime";
        description = "Working with MIME types";
@@ -91630,7 +91939,7 @@ self: {
      mkDerivation {
        pname = "mime-directory";
        version = "0.5.1";
-       sha256 = "1f54rbznv52m4h72yazr397k1d9jyb1i524pfl3d494swvn9b05r";
+       sha256 = "b98095ece69a24d20675978812c3f232b5304f1af92b2f0e2455946dffcaa4b8";
        libraryHaskellDepends = [
          base base64-string bytestring containers old-locale regex-pcre time
        ];
@@ -91647,7 +91956,7 @@ self: {
      mkDerivation {
        pname = "mime-mail";
        version = "0.4.9";
-       sha256 = "1l638jr7914227mg8854i6xgyhq403kb1zc2py77yb0xifm20534";
+       sha256 = "641420aa8b1d2c7f8ebf82fdb0e6000443ffba89a420f4ea11828474b244c3d0";
        libraryHaskellDepends = [
          base base64-bytestring blaze-builder bytestring filepath process
          random text
@@ -91667,7 +91976,7 @@ self: {
      mkDerivation {
        pname = "mime-mail-ses";
        version = "0.3.2.2";
-       sha256 = "1dzlfrpqw3bdqkwgp5i52azkp8lv2cgvrdvl1w39q484ra4by2y1";
+       sha256 = "c10bbf88ca04119c060f74b7bc1f139ba23bbf122596fbf8c46d0d8e6f76f4b7";
        libraryHaskellDepends = [
          base base64-bytestring byteable bytestring conduit cryptohash
          http-client http-conduit http-types mime-mail old-locale text time
@@ -91685,7 +91994,7 @@ self: {
      mkDerivation {
        pname = "mime-string";
        version = "0.4";
-       sha256 = "0v028cgqll918zdaa95myazlg7dnvb2cvvvm1iyyqw81grza3r61";
+       sha256 = "c1e4a17e7e0171ec7d0c75efcdc4dab69d47bff2b524a5da4721518a1f43026c";
        libraryHaskellDepends = [
          base base64-string bytestring iconv mtl network old-time
        ];
@@ -91699,7 +92008,7 @@ self: {
      mkDerivation {
        pname = "mime-types";
        version = "0.1.0.6";
-       sha256 = "090z3dp928243amnc6s8g10rk2h2bprk9y138q6wj3cpflzr72pw";
+       sha256 = "fc8a933f75970dc90d4623f834f35d028a994178481b66ab1a4420916e1b1f24";
        libraryHaskellDepends = [ base bytestring containers text ];
        homepage = "https://github.com/yesodweb/wai";
        description = "Basic mime-type handling types and functions";
@@ -91711,7 +92020,7 @@ self: {
      mkDerivation {
        pname = "mines";
        version = "0.1";
-       sha256 = "16s98hwskycl2bqv1n2bnivh8w8q3xhhj687hk8flcg9s9ny4s8k";
+       sha256 = "1369e26dd2e931ead084071909611f18710477b44bd8b0f11294f9a93944499b";
        isLibrary = false;
        isExecutable = true;
        executableHaskellDepends = [ base directory mtl random ];
@@ -91727,7 +92036,7 @@ self: {
      mkDerivation {
        pname = "minesweeper";
        version = "0.9.2.1";
-       sha256 = "1cbw136wl9rdcl4vbbz9i5w1mw33qhr0gzbww0qf63zfz2lg4gs2";
+       sha256 = "423ff2a8f8ee0fe330e07cfd0732c463f01a7889e9afb509652d27cacd087cb1";
        isLibrary = false;
        isExecutable = true;
        executableHaskellDepends = [
@@ -91745,7 +92054,7 @@ self: {
      mkDerivation {
        pname = "miniball";
        version = "0.1.0.2";
-       sha256 = "16fdzbfspxqi0h7v6gn25n065anvk9zm28236qvfwbvr9l2ki172";
+       sha256 = "e28438054d792fee36364320517f9adbaa62802dc23eb30f0411f7abddfacd99";
        libraryHaskellDepends = [ base vector ];
        homepage = "http://nonempty.org/software/haskell-miniball";
        description = "Bindings to Miniball, a smallest enclosing ball library";
@@ -91760,7 +92069,7 @@ self: {
      mkDerivation {
        pname = "miniforth";
        version = "0.1.0.1";
-       sha256 = "1f2scxg7j6zifqj6q2khxb8s49ilnk4r9qms72vysp1s5p76zk0g";
+       sha256 = "0fcc6fce2d3a5cedb738bae294c9b43426a2d1ea700a6c2476f11b795e675ab8";
        isLibrary = true;
        isExecutable = true;
        libraryHaskellDepends = [
@@ -91781,7 +92090,7 @@ self: {
      mkDerivation {
        pname = "minimal-configuration";
        version = "0.1.1";
-       sha256 = "06r710l30kf5aaz2k446z9fhc6zshdsssp1zwri0572r1jryzd43";
+       sha256 = "83b4efb30c599c0262e63f5cad7583fa1b065dfa869029be52c54d302808271b";
        revision = "1";
        editedCabalFile = "12049d8491610c2789c61e4736586d3fa8b1122c5c7657647c3de8d21073ef80";
        libraryHaskellDepends = [
@@ -91799,7 +92108,7 @@ self: {
      mkDerivation {
        pname = "minimorph";
        version = "0.1.6.0";
-       sha256 = "17ds0bjpyz7ngsq7nnlqix6yjfr6clr7xkwgpg4fysii7qvymbkz";
+       sha256 = "7faeea373e316aefc8bb8fcf7e3265263be94d8f985a7bb07ef67c7fe502ba9d";
        libraryHaskellDepends = [ base text ];
        testHaskellDepends = [
          base HUnit test-framework test-framework-hunit text
@@ -91814,7 +92123,7 @@ self: {
      mkDerivation {
        pname = "minimung";
        version = "0.1";
-       sha256 = "0i825bd751adfj22lkgc929jlgxjj16i81k8qqkhqh7ib131kqlf";
+       sha256 = "8ee2194658f1400c27c66806144d90b23f2a9348ec4d2a84744d8572da2a0245";
        isLibrary = false;
        isExecutable = true;
        executableHaskellDepends = [ base GLUT haskell98 unix ];
@@ -91828,7 +92137,7 @@ self: {
      mkDerivation {
        pname = "minions";
        version = "0.2.0.0";
-       sha256 = "1r7c07pa9lr7h32y1mgxrlrj6a4sf8kfwc7vvvrr6bjfwr3m54vl";
+       sha256 = "74935247e64e2e93f3defb30ee26729a282333cdfdd5e0c58027d3a4ee01ece4";
        isLibrary = false;
        isExecutable = true;
        executableHaskellDepends = [
@@ -91847,7 +92156,7 @@ self: {
      mkDerivation {
        pname = "minioperational";
        version = "0.4.9";
-       sha256 = "0kbfk3gpgzxi84kyjf7awdc2x579339zd7c42khlflhk6y88j95m";
+       sha256 = "b524899037135247e114849df6d318e9942e58e3ea38e92741b1ff77df986e4d";
        libraryHaskellDepends = [
          base containers elevator extensible mtl template-haskell
          transformers
@@ -91864,7 +92173,7 @@ self: {
      mkDerivation {
        pname = "miniplex";
        version = "0.3.4";
-       sha256 = "15rsg617wmh8cb0f2pkd5hyzrj96qjvar4p6nx21vlxr3b2plcg4";
+       sha256 = "e4317ac51ab9d31d44b7e692acb6c426c9fc3d2c6d5ee1c06208567e82793a97";
        isLibrary = true;
        isExecutable = true;
        libraryHaskellDepends = [
@@ -91884,7 +92193,7 @@ self: {
      mkDerivation {
        pname = "minirotate";
        version = "0.1.2.2";
-       sha256 = "15hgag1r0w6smilab7059z7bsn9i1czhdknma53rmj1ma2pd148y";
+       sha256 = "1e91d0ae5035c89a4751d5ce063f0b3159bdce4f059ca568acda7090c3530f96";
        isLibrary = false;
        isExecutable = true;
        executableHaskellDepends = [
@@ -91903,7 +92212,7 @@ self: {
      mkDerivation {
        pname = "minisat";
        version = "0.1.2";
-       sha256 = "089jam2cbwf4m16sgb9wh4zkgbmpfsg647lng3kyjs5d3m02i5dd";
+       sha256 = "ad9528401dad68e9e778961e629e76b7ae373f813cada74da8c4f1c544553221";
        libraryHaskellDepends = [ async base ];
        description = "A Haskell bundle of the Minisat SAT solver";
        license = stdenv.lib.licenses.bsd3;
@@ -91916,7 +92225,7 @@ self: {
      mkDerivation {
        pname = "ministg";
        version = "0.3";
-       sha256 = "05ddhr50pbqy0yjgcw0wgfjxlkgapg0zppqqyxfy5apr68zd02mm";
+       sha256 = "b50ad03e32f9aae25df718dffbc1bbea4ddaa57b1c70f6a4071eaf0b4a86ad15";
        isLibrary = false;
        isExecutable = true;
        executableHaskellDepends = [
@@ -91936,7 +92245,7 @@ self: {
      mkDerivation {
        pname = "miniutter";
        version = "0.4.4.2";
-       sha256 = "1nr08cm6qrww01sqxvr4bmkhxxihcl9sm8077gl25alj1s3gq21s";
+       sha256 = "3a08fc860e92aa22e83b07a0aa136530f60e675d24ef8e75009c676c2a4320db";
        libraryHaskellDepends = [
          base binary containers ghc-prim minimorph text
        ];
@@ -91954,7 +92263,7 @@ self: {
      mkDerivation {
        pname = "minst-idx";
        version = "0.1.2.2";
-       sha256 = "06ixg6bm55h1mjym3qp667gddy7f32inaxgyfbrh918zl283briv";
+       sha256 = "3be63590a01f8504f372fe7565a318eef8d6de31e6e251bdac01965297793d1a";
        libraryHaskellDepends = [ base binary bytestring vector ];
        testHaskellDepends = [ base binary directory hspec vector ];
        homepage = "https://github.com/kryoxide/minst-idx/";
@@ -91969,7 +92278,7 @@ self: {
      mkDerivation {
        pname = "mirror-tweet";
        version = "0.1.0.0";
-       sha256 = "07dz0c65xkb7kgr2rby7m3g5893rqsbyl2nmjhf4q2wqsypmiipa";
+       sha256 = "eac658afd7980b4c1c94d50aea97c6792454dea8c7af2cf29b67cd5e0c03bf1d";
        isLibrary = false;
        isExecutable = true;
        executableHaskellDepends = [
@@ -91991,7 +92300,7 @@ self: {
      mkDerivation {
        pname = "misfortune";
        version = "0.1.1.2";
-       sha256 = "0j93zqgqskrj2zc0vwsmwldidr6nkcxq2v3mmzv7l7l1bwhl8jxf";
+       sha256 = "ae4b44215f811e7af6af756c813b9bd6e4161be555f30dd817324f8d1ffe2349";
        isLibrary = true;
        isExecutable = true;
        libraryHaskellDepends = [
@@ -92009,7 +92318,7 @@ self: {
      mkDerivation {
        pname = "missing-foreign";
        version = "0.1.1";
-       sha256 = "11f8pknbarlj956nmalqhd2v704z7d7xbi61hs1q8vb2p36kc6wy";
+       sha256 = "9e1b36cdb8626d848386c1c4d54f3b9f80b3458398aa6a4d499266b5ecbcc885";
        libraryHaskellDepends = [ base ];
        description = "Convenience functions for FFI work";
        license = stdenv.lib.licenses.bsd3;
@@ -92020,7 +92329,7 @@ self: {
      mkDerivation {
        pname = "missing-py2";
        version = "1.0.1";
-       sha256 = "0daa310acml90r4f4qdjf3qns70gvx08mpjzw2h3v46vrwlacrmj";
+       sha256 = "b266a628cfdb903da0e05fde8a40df0f1c6df170b261e248068956a640184a35";
        libraryHaskellDepends = [ anydbm base MissingH ];
        testHaskellDepends = [
          anydbm base Cabal directory HUnit MissingH
@@ -92036,7 +92345,7 @@ self: {
      mkDerivation {
        pname = "mix-arrows";
        version = "1.2";
-       sha256 = "0m70l09bmr8b95d87rpz4vdircdar2rsvnamr2g07542wx024931";
+       sha256 = "61242240e78294039ec855d9adb3c8aab11cdb26ffe6835a490be5ba12a0e054";
        libraryHaskellDepends = [ base ];
        description = "Mixing effects of one arrow into another one";
        license = stdenv.lib.licenses.bsd3;
@@ -92048,7 +92357,7 @@ self: {
      mkDerivation {
        pname = "mixed-strategies";
        version = "0.1.0.0";
-       sha256 = "0vsldq2j2avj98fcz2lbydf4y23iwydr4jsvpbcvwlvqavgz1rkc";
+       sha256 = "6ce6f0df567853bed9ba5b4b929be771084f5cf38b8acf1c4a722b21056e546f";
        isLibrary = true;
        isExecutable = true;
        libraryHaskellDepends = [ array base containers simple-tabular ];
@@ -92066,7 +92375,7 @@ self: {
      mkDerivation {
        pname = "mkbndl";
        version = "0.2.1";
-       sha256 = "1qzfmf92sx5vq5jxrqhln1a6y8kayrip36izf5m8hryymxd4dard";
+       sha256 = "2dab465aafde67886a713f9a7163f66a226f54b014e2dc65c1bb742d92abeee3";
        isLibrary = false;
        isExecutable = true;
        executableHaskellDepends = [ base directory filepath haskell98 ];
@@ -92082,7 +92391,7 @@ self: {
      mkDerivation {
        pname = "mkcabal";
        version = "1.0.0";
-       sha256 = "1cmawm49i01xxvzgf67cin6s9hihfc3ihr6s5hn2makasfxbnryc";
+       sha256 = "cc67bbbad36aaa2a2c2cda6418077330c2a48d8dec18f7feee3d809848e5aab2";
        isLibrary = false;
        isExecutable = true;
        executableHaskellDepends = [
@@ -92099,7 +92408,7 @@ self: {
      mkDerivation {
        pname = "ml-w";
        version = "0.1.1";
-       sha256 = "04d0drqyaz075y6fs3rj6c2sp8ns1x4rfxqf1dbm2b31q09ycnl1";
+       sha256 = "815ae613c0612c51570b0e7797490fdaa2ab0533320fed8c2f077ce5716ea011";
        isLibrary = true;
        isExecutable = true;
        libraryHaskellDepends = [ base mtl parsec pretty ];
@@ -92114,7 +92423,7 @@ self: {
      mkDerivation {
        pname = "mlist";
        version = "0.0.2";
-       sha256 = "06mwmahyp781wigjva12kz7w75vjkkprl8k1yiqd1yd0162vp31k";
+       sha256 = "338cbb8509a0f9d070f461229aef9c7297c3cf9f22a82d5fe4019deba1aabc1a";
        libraryHaskellDepends = [ base haskell98 ];
        homepage = "http://haskell.org/haskellwiki/mlist";
        description = "Monadic List alternative to lazy I/O";
@@ -92127,7 +92436,7 @@ self: {
      mkDerivation {
        pname = "mmap";
        version = "0.5.9";
-       sha256 = "1y5mk3yf4b8r6rzmlx1xqn4skaigrqnv08sqq0v7r3nbw42bpz2q";
+       sha256 = "58fcbb04e1cb8e7c36c05823b02dce2faaa989c53d745a7f36192de2fc98b5f8";
        isLibrary = true;
        isExecutable = true;
        libraryHaskellDepends = [ base bytestring ];
@@ -92140,7 +92449,7 @@ self: {
      mkDerivation {
        pname = "mmorph";
        version = "1.0.4";
-       sha256 = "0k5zlzmnixfwcjrqvhgi3i6xg532b0gsjvc39v5jigw69idndqr2";
+       sha256 = "22e3665b4c86bf28cb4e836da91f586294d74d1cf1c18db364dcf568eba7bf4c";
        libraryHaskellDepends = [ base transformers ];
        description = "Monad morphisms";
        license = stdenv.lib.licenses.bsd3;
@@ -92151,7 +92460,7 @@ self: {
      mkDerivation {
        pname = "mmtl";
        version = "0.1";
-       sha256 = "0bb19l52s56y2dwyskvjwdal7387ii2dg9cc1l6f341y3695nj7l";
+       sha256 = "f4485b92193e90e10c0d8ca5d7448c078d4355e3724fed7913de142d0a4d612d";
        libraryHaskellDepends = [ base ];
        description = "Modular Monad transformer library";
        license = stdenv.lib.licenses.bsd3;
@@ -92163,7 +92472,7 @@ self: {
      mkDerivation {
        pname = "mmtl-base";
        version = "15321.1";
-       sha256 = "13hdaxpb9zds3yc2l3pl60h26541yvswprdc43swn05hzf6p01nq";
+       sha256 = "d806708dfbb000cbf520ace5cbf5f68114232030f40e2a981fbafdb46e570d8e";
        libraryHaskellDepends = [ base mmtl ];
        description = "MonadBase type-class for mmtl";
        license = stdenv.lib.licenses.bsd3;
@@ -92177,7 +92486,7 @@ self: {
      mkDerivation {
        pname = "moan";
        version = "0.2.0.2";
-       sha256 = "0fb0z3v4a8kblwx4xjs7xdkczpvcyz9la7071kz7q6cjl6w49i30";
+       sha256 = "60c444b8a192197cfe0c071c45d3f76cdfcf66eb47cb4e3aa76b2245f6f86039";
        libraryHaskellDepends = [
          base binary bytestring containers dawg regex-tdfa regex-tdfa-text
          tagset-positional text zlib
@@ -92196,7 +92505,7 @@ self: {
      mkDerivation {
        pname = "mockery";
        version = "0.3.2";
-       sha256 = "0m0lp2z63sgkylz5318j53r5hnrkp705qh7nqbb149ir4gy7g1bg";
+       sha256 = "6f8577fc23392612d6c2f6405cc0b9335b58f2281285513ef5f3e961beb81454";
        libraryHaskellDepends = [
          base bytestring directory filepath logging-facade temporary
        ];
@@ -92214,7 +92523,7 @@ self: {
      mkDerivation {
        pname = "modbus-tcp";
        version = "0.1";
-       sha256 = "1j0gkc6vrvydz0vcdm8bpiarl75zqh4k5z18s4903b6mqwpscslr";
+       sha256 = "996aa62fc7d5ac0112d128fc3209c4bf1c9a55bc0bd5c636f8cdefbc0d9b0fc8";
        libraryHaskellDepends = [
          base base-unicode-symbols bytestring cereal network
        ];
@@ -92231,7 +92540,7 @@ self: {
      mkDerivation {
        pname = "modelicaparser";
        version = "0.1.0.0";
-       sha256 = "0ifsgdqi3376z7xspjlx62hh3dah3dskqrar3s63pmw1cf9b6qfl";
+       sha256 = "d461b3926381d73b8c1e59653c751b50b501a1309dcaabfbf9e68c11717bda45";
        libraryHaskellDepends = [ base containers parsec ];
        testHaskellDepends = [
          ansi-terminal base containers filepath parsec QuickCheck
@@ -92249,7 +92558,7 @@ self: {
      mkDerivation {
        pname = "modsplit";
        version = "0.2.1";
-       sha256 = "0xm9vj78clawys9ascgm2fl8kqg5zmdfbkkb42d1d1h5z72cc55p";
+       sha256 = "b714c6c4f90586169a206bcee55afde5e189a813f531ad92f65c51868edca976";
        isLibrary = true;
        isExecutable = true;
        libraryHaskellDepends = [
@@ -92268,7 +92577,7 @@ self: {
      mkDerivation {
        pname = "modular-arithmetic";
        version = "1.2.1.1";
-       sha256 = "005pbkrszgkbm0qx9hzn1f72l9z07qhqypmcw72fi5i5hppr45av";
+       sha256 = "5b1592ef852596e8c4e1ac5e8f213ee0272a8e0bf6c3d431a86bbeaff35cb700";
        libraryHaskellDepends = [ base ];
        testHaskellDepends = [ base doctest Glob ];
        jailbreak = true;
@@ -92285,7 +92594,7 @@ self: {
      mkDerivation {
        pname = "modular-prelude";
        version = "0.3.0.0";
-       sha256 = "0hlmxm9xfnf55qz1nrljm0s4bhpa6x973h3qi2b7bl8pil423rkf";
+       sha256 = "6ee621088d17d175968878c0715237eac24534a892661b3e2ec559d753ed9542";
        libraryHaskellDepends = [
          base basic-prelude bytestring containers data-default hashable
          system-filepath text transformers unordered-containers vector
@@ -92302,7 +92611,7 @@ self: {
      mkDerivation {
        pname = "modular-prelude-classy";
        version = "0.1.0.0";
-       sha256 = "1izinrgd9a6sm57isg8jgs4wjidczwqcxl6vg5h4gy5zz9dg8xnx";
+       sha256 = "dd76f45afabff8476079dbd0ce30ffac45c9897e123d1d4fa9daa8d45eb6f1c7";
        libraryHaskellDepends = [ base classy-prelude modular-prelude ];
        jailbreak = true;
        homepage = "https://github.com/DanBurton/modular-prelude#readme";
@@ -92321,7 +92630,7 @@ self: {
      mkDerivation {
        pname = "module-management";
        version = "0.20.4";
-       sha256 = "185vky00i0cm7rd019xa87x1rld4j92fqcm4a4igpn13lh2y4nzq";
+       sha256 = "f85be205a423d8fb2251a432ec4492a4d11cfa41aaa7005a3e958108809fbba0";
        isLibrary = true;
        isExecutable = true;
        libraryHaskellDepends = [
@@ -92350,7 +92659,7 @@ self: {
      mkDerivation {
        pname = "modulespection";
        version = "0.1.2.2";
-       sha256 = "00172s9v4823q4f8mvln2v3m7zcri8vp2b7b8j1ank0sb9lbyjlf";
+       sha256 = "8e4abf685a1a4cab8244eb2c71378a99fd53c71696ee8a1cc14320b293162700";
        libraryHaskellDepends = [
          base exceptions filepath ghc ghc-paths template-haskell temporary
          transformers
@@ -92369,7 +92678,7 @@ self: {
      mkDerivation {
        pname = "modulo";
        version = "1.9.1";
-       sha256 = "1dxvfd8f7zx43zm9h5dd71ci768khhmh8660h3abazqhm7ws367c";
+       sha256 = "ec98a1f9a9107fb5d480c018042b841399135938ad1598ea1fa4ffe35073bbb7";
        isLibrary = true;
        isExecutable = true;
        libraryHaskellDepends = [
@@ -92388,7 +92697,7 @@ self: {
      mkDerivation {
        pname = "moe";
        version = "2015.5.4";
-       sha256 = "0yiyr8n0bw5wcc8jyrah2kf9jnj3x4h5kl3qprysx8ffhc6dx3r9";
+       sha256 = "298fde0c83cea1ae7dbe78d05920e9435a99dc1450652f1163bcf0052cca3e7a";
        libraryHaskellDepends = [
          air base bytestring data-default dlist mtl text
        ];
@@ -92405,8 +92714,8 @@ self: {
      }:
      mkDerivation {
        pname = "moesocks";
-       version = "0.1.0.12";
-       sha256 = "1f31qd4lgc2li9q7cf7zx700v23sln9wxfd7yaw0d2q0qmqj2zvi";
+       version = "0.1.0.14";
+       sha256 = "7b8548c3b91dbe0fc51304af356537b8af6586a487153ab3777ec804668d9fef";
        isLibrary = false;
        isExecutable = true;
        executableHaskellDepends = [
@@ -92428,7 +92737,7 @@ self: {
      mkDerivation {
        pname = "mohws";
        version = "0.2.1.3";
-       sha256 = "1na585nc16s3giq88kr5i8wlqc03i29blqsgqp40da6dyqiihqwf";
+       sha256 = "8e631823f6cda806c8c54f63ba928803304c398a254f84707c439bc06c4145d9";
        isLibrary = true;
        isExecutable = true;
        libraryHaskellDepends = [
@@ -92450,7 +92759,7 @@ self: {
      mkDerivation {
        pname = "monad-abort-fd";
        version = "0.4";
-       sha256 = "01ny9pq66cma3wai48mhzijk465h7ssrj253npyy2myxnj0y93zr";
+       sha256 = "f98fe481b4dd57e1fdb5a30899b53eb0183265fcb02212151faa3263f04dde06";
        libraryHaskellDepends = [
          base data-default monad-control mtl transformers transformers-abort
          transformers-base
@@ -92466,7 +92775,7 @@ self: {
      mkDerivation {
        pname = "monad-atom";
        version = "0.4.1";
-       sha256 = "16dnp6wz0s56gm58k6m5cv5c47hb2vz1m4a3pqvrg3j97y344c3q";
+       sha256 = "783042863f498e9737be43911afe160b1ec2ca66a59a894a7da668f0b9b9b699";
        libraryHaskellDepends = [ base containers ghc-prim mtl ];
        homepage = "https://bitbucket.org/gchrupala/lingo";
        description = "Monadically convert object to unique integers and back";
@@ -92479,7 +92788,7 @@ self: {
      mkDerivation {
        pname = "monad-atom-simple";
        version = "0.0.2";
-       sha256 = "1k4rcrdjjs52p9mnsbwp0gmb2inivhcqw044l56dbc080yxrk32j";
+       sha256 = "528c99bb0708b0d54ca184008e19dcd146b1ea03972f6d6bbaa268295b6699cc";
        libraryHaskellDepends = [ base containers ghc-prim mtl ];
        description = "Monadically map objects to unique ints";
        license = stdenv.lib.licenses.bsd3;
@@ -92491,7 +92800,7 @@ self: {
      mkDerivation {
        pname = "monad-bool";
        version = "0.2.0";
-       sha256 = "1f3n2wbd3lbsp2snsf9x4h09apw62hayhzjibakp6mqw6174444h";
+       sha256 = "9010424e301c5773a75a517ee81514865f9500243d396db5b87ad1d1161776b8";
        libraryHaskellDepends = [ base ];
        description = "This package has been removed";
        license = stdenv.lib.licenses.bsd3;
@@ -92506,7 +92815,7 @@ self: {
      mkDerivation {
        pname = "monad-classes";
        version = "0.3.1.1";
-       sha256 = "1n0ry7lq0vh9siaqxfdfavg67a99zmws5nvr1hjq8k212v36v40c";
+       sha256 = "0c906dc616414c84250c79dba279fd29a963de56aeb98e55d4096e80e9f119d8";
        libraryHaskellDepends = [
          base ghc-prim mmorph monad-control peano reflection transformers
          transformers-base transformers-compat
@@ -92525,7 +92834,7 @@ self: {
      mkDerivation {
        pname = "monad-codec";
        version = "0.2.0";
-       sha256 = "0jim6hk891jby2gch6f1k4262jm8fl9jgl808dj204ylz8w1475l";
+       sha256 = "b41c1238fad41320644300d1271375a84a610499c119c89ef04b86842634354a";
        libraryHaskellDepends = [ base binary containers data-lens mtl ];
        homepage = "https://github.com/kawu/monad-codec";
        description = "Monadic conversion between complex data structures and unique integers";
@@ -92539,7 +92848,7 @@ self: {
      mkDerivation {
        pname = "monad-control";
        version = "1.0.0.4";
-       sha256 = "07pn1p4m80wdd7gw62s4yny8rbvm60ka1q8qx5y1plznd8sbg179";
+       sha256 = "e984b7346af6d31b7ce918e1a0263075af8cbcf5440bc3df698d0354c90df61e";
        libraryHaskellDepends = [
          base stm transformers transformers-base transformers-compat
        ];
@@ -92555,7 +92864,7 @@ self: {
      mkDerivation {
        pname = "monad-coroutine";
        version = "0.9.0.1";
-       sha256 = "10b98w0xr7hbnawfz93qqkbcpvklgkpljxmv9drr40bd9bv33wij";
+       sha256 = "32f231f64a6d0192734bbb7649ef7c74eecbd6c478a4efb8b20b9edc01476981";
        libraryHaskellDepends = [
          base monad-parallel transformers transformers-compat
        ];
@@ -92571,7 +92880,7 @@ self: {
      mkDerivation {
        pname = "monad-exception";
        version = "0.1";
-       sha256 = "1mh19mxi6mlkvd083vjjdmdimdnk6n5yaj7v7xxgqycl5sazqkh8";
+       sha256 = "084efc952e9479fc7a3ffb48e58b35d3b61a5b6d52ee8140db9356137b4d01d6";
        libraryHaskellDepends = [
          base monad-control mtl-evil-instances transformers
          transformers-base
@@ -92589,7 +92898,7 @@ self: {
      mkDerivation {
        pname = "monad-extras";
        version = "0.5.11";
-       sha256 = "0rq44dk1fvfqkhng2yczyyz7jh6d6m0kjy58k02ady28f7j2r5vn";
+       sha256 = "76972ce47148f8a60498a878394135cd4079bef79f79f12c9cd86d1766230467";
        libraryHaskellDepends = [
          base mmorph monad-control stm transformers transformers-base
        ];
@@ -92603,7 +92912,7 @@ self: {
      mkDerivation {
        pname = "monad-fork";
        version = "0.1";
-       sha256 = "15xwavq4yc3xfif4isjh9m0q9h1bh7pmv2i3rh99sndmd34cdpwc";
+       sha256 = "8cdfc6c868b5599d12cc238a5def812bc084414d50ea485c747d304ff056bc97";
        libraryHaskellDepends = [ base monad-control ];
        jailbreak = true;
        description = "Type class for monads which support a fork operation";
@@ -92615,7 +92924,7 @@ self: {
      mkDerivation {
        pname = "monad-gen";
        version = "0.3.0.1";
-       sha256 = "0rc4r6sg29sjgh9xsk7q80h0lixhyxs60bszj5dnn8yf7w18b15y";
+       sha256 = "be8485023fce236b5b915f2f6074f7b0470a2040f84cdd137c5227f1b4c98465";
        libraryHaskellDepends = [ base mtl transformers ];
        description = "A simple monad for generating fresh integers";
        license = stdenv.lib.licenses.mit;
@@ -92626,7 +92935,7 @@ self: {
      mkDerivation {
        pname = "monad-interleave";
        version = "0.1";
-       sha256 = "09hpl7ah5ivsrx4xlk96d129n1j4wpx7kj6l95zwadyaz7rj9fp7";
+       sha256 = "e7ba24f3f9ca37c57f49d4c879fae544069b4468264dda49cf7ac702d5a11726";
        libraryHaskellDepends = [ base ];
        homepage = "http://github.com/patperry/monad-interleave";
        description = "Monads with an unsaveInterleaveIO-like operation";
@@ -92641,7 +92950,7 @@ self: {
      mkDerivation {
        pname = "monad-journal";
        version = "0.7.1";
-       sha256 = "1bfj9yy7hkixii31fbxdydjwx9ln6snm40w6l5vph2skcrms9bvr";
+       sha256 = "79afa46b66530b7877a1860352ad3696a6ce65f3ad2f17468c3d4e78bc4fd2ad";
        libraryHaskellDepends = [
          base either monad-control mtl transformers transformers-base
        ];
@@ -92657,7 +92966,7 @@ self: {
      mkDerivation {
        pname = "monad-levels";
        version = "0.1.0.1";
-       sha256 = "1v3i12h4c788yz93a2c9nxcczrhz8nwpq0057q7b1nad74g70lan";
+       sha256 = "5651701e394dd9b00e3e05007cb9451fe6cf58b7890935d2f7081d46a00871ec";
        libraryHaskellDepends = [
          base constraints transformers transformers-compat
        ];
@@ -92678,7 +92987,7 @@ self: {
      mkDerivation {
        pname = "monad-logger";
        version = "0.3.13.2";
-       sha256 = "1cp2npa5mzn3yss1di151ikw7hx4slc99cvx8gipdwp1696kqf61";
+       sha256 = "c1383c4d32e1f276e3437db39418d5a4c3c3670c25c416b4f6c3fe5ad4b5e2b2";
        libraryHaskellDepends = [
          base blaze-builder bytestring conduit conduit-extra exceptions
          fast-logger lifted-base monad-control monad-loops mtl resourcet stm
@@ -92696,7 +93005,7 @@ self: {
      mkDerivation {
        pname = "monad-logger-json";
        version = "0.1.0.0";
-       sha256 = "1ap98487lwgvgrrxkjskga86ckbv6rhn2n6pzp403343xx51r1qh";
+       sha256 = "10871c4aef838c01c8fdd7586161367b4d66907a53cbd9737efb717a1041e9aa";
        libraryHaskellDepends = [
          aeson base monad-logger template-haskell text
        ];
@@ -92712,7 +93021,7 @@ self: {
      mkDerivation {
        pname = "monad-logger-syslog";
        version = "0.1.1.1";
-       sha256 = "0hdm495knrdrl76xlsdp0sk6n0v6qnl9b6r6x9ac6s1p7j1w66vf";
+       sha256 = "6e1bc3833c3768c354ea269b95a8c566036ba606b769dacda1b9653b4b22b541";
        libraryHaskellDepends = [
          base bytestring fast-logger hsyslog monad-logger text transformers
        ];
@@ -92726,7 +93035,7 @@ self: {
      mkDerivation {
        pname = "monad-loops";
        version = "0.4.3";
-       sha256 = "062c2sn3hc8h50p1mhqkpyv6x8dydz2zh3ridvlfjq9nqimszaky";
+       sha256 = "7eaaaf6bc43661e9e86e310ff8c56fbea16eb6bf13c31a2e28103138ac164c18";
        libraryHaskellDepends = [ base ];
        testHaskellDepends = [ base tasty tasty-hunit ];
        homepage = "https://github.com/mokus0/monad-loops";
@@ -92739,7 +93048,7 @@ self: {
      mkDerivation {
        pname = "monad-loops-stm";
        version = "0.4";
-       sha256 = "0y7j2xpr1s7ggwm3vvpb5mlagsnxhq9qpncapibhk2pbf2d5r7as";
+       sha256 = "5a9d5c9a70eb8a0957bc8ad98b1386ddeaa7682debee3d2a7fefe8906f17f278";
        libraryHaskellDepends = [ base stm ];
        homepage = "https://github.com/mokus0/monad-loops-stm";
        description = "Monadic loops for STM";
@@ -92753,7 +93062,7 @@ self: {
      mkDerivation {
        pname = "monad-lrs";
        version = "0.0.2.1";
-       sha256 = "01i8hz50r3lf8r3rasl96blr6br3p1x6hvckhbi8aw61x507jmcg";
+       sha256 = "8f557940e9c17085e282936d687ab8232f93e932896a9547468e8e0cca872806";
        revision = "1";
        editedCabalFile = "dd714797826911e564a0e418307530fa99a8ba9ea91400517be2bb78b4e695c1";
        libraryHaskellDepends = [ base containers ];
@@ -92775,7 +93084,7 @@ self: {
      mkDerivation {
        pname = "monad-memo";
        version = "0.4.1";
-       sha256 = "07gid18rsja7gvk2ccsbwvpz223x59mdk9x9w36bz18cy2pw802c";
+       sha256 = "4c00c4aff00c85bfcce0a9a7d96a2a7d08f1efe64b3326e67e47499d5168f11d";
        libraryHaskellDepends = [
          array base containers mtl primitive transformers vector
        ];
@@ -92794,7 +93103,7 @@ self: {
      mkDerivation {
        pname = "monad-mersenne-random";
        version = "0.1";
-       sha256 = "03kbqbgv4npzfzn90jk4p17y8kb62sslby6q36819qkif1j76lq6";
+       sha256 = "065373647071e2149019d8f845b516664de44fb8644a90ec77ff5ab2dfc26b0e";
        libraryHaskellDepends = [ base mersenne-random-pure64 ];
        homepage = "http://code.haskell.org/~dons/code/monad-mersenne-random";
        description = "An efficient random generator monad, based on the Mersenne Twister";
@@ -92807,7 +93116,7 @@ self: {
      mkDerivation {
        pname = "monad-open";
        version = "0.1.0.0";
-       sha256 = "18h24zdvbffnwr2xh4qahakr80z8ly65pmksmk3ngjykxrvif2vx";
+       sha256 = "7d0b1777eed3cb67c7ac7ad65b8ca7e80394a7820a13d845e6d6b9b5db2702a2";
        libraryHaskellDepends = [ base exceptions mtl transformers ];
        jailbreak = true;
        description = "Open recursion for when you need it";
@@ -92819,7 +93128,7 @@ self: {
      mkDerivation {
        pname = "monad-ox";
        version = "0.3.0";
-       sha256 = "1x65jvh816a296y2ds8vysfzl83am4pwwrnap4zdg0prpcxfpwl8";
+       sha256 = "88f2eb3abbf982d73eb9ca66ce2fa96a20fa9df61be926bc49429980e096c5f4";
        libraryHaskellDepends = [ base containers mtl text vector ];
        homepage = "https://github.com/kawu/monad-ox";
        description = "Monad for observation extraction";
@@ -92835,7 +93144,7 @@ self: {
      mkDerivation {
        pname = "monad-par";
        version = "0.3.4.7";
-       sha256 = "12n27hs274nrfkpa6hx0gdkrc76wxzliqf53x6689idl363sdf13";
+       sha256 = "23b8a68719b4c5848ce9a3381ce9efdc1c96677ba043a3ee74d99223343cc28a";
        libraryHaskellDepends = [
          abstract-deque abstract-par array base containers deepseq
          monad-par-extras mtl mwc-random parallel
@@ -92858,7 +93167,7 @@ self: {
      mkDerivation {
        pname = "monad-par-extras";
        version = "0.3.3";
-       sha256 = "0bl4bd6jzdc5zm20q1g67ppkfh6j6yn8fwj6msjayj621cck67p2";
+       sha256 = "e21e33190bc248afa4ae467287ac37d24037ef3de6050c44fd85b52f4d5b842e";
        libraryHaskellDepends = [
          abstract-par base cereal deepseq mtl random transformers
        ];
@@ -92873,7 +93182,7 @@ self: {
      mkDerivation {
        pname = "monad-parallel";
        version = "0.7.1.4";
-       sha256 = "01sadhl3kv7gsx1m90fb76n2xh7b9awjc9071gzn0ab26d67a98b";
+       sha256 = "0b25754c33622960ff0b072426b94aebc02eac39cb815443d7efec39286c4a07";
        libraryHaskellDepends = [
          base parallel transformers transformers-compat
        ];
@@ -92889,7 +93198,7 @@ self: {
      mkDerivation {
        pname = "monad-parallel-progressbar";
        version = "0.1.0.1";
-       sha256 = "1pqi2alyvsflwy5ygp4cl5g90jg50ix61plqxvsldpdkzncmmk84";
+       sha256 = "04cd5a99fdb3dd46f5ee98de607a04e549905ea18cdce78be7d4e9eda91211df";
        libraryHaskellDepends = [
          base monad-parallel monadIO terminal-progress-bar
        ];
@@ -92903,7 +93212,7 @@ self: {
      mkDerivation {
        pname = "monad-param";
        version = "0.0.4";
-       sha256 = "08rm902kclapqh1iafjrsqspf0szhbx5jaqv6hh9p5zbg8ipdkhc";
+       sha256 = "0cce76237aeb979b20341b2b59fa825f037735d6593a1503c457513605483523";
        libraryHaskellDepends = [ base mtl stm ];
        homepage = "http://hackage.haskell.org/package/monad-param";
        description = "Parameterized monads";
@@ -92915,7 +93224,7 @@ self: {
      mkDerivation {
        pname = "monad-peel";
        version = "0.2";
-       sha256 = "1cg6j2qhh14ryn4766dwx57g50qalzcv79rx9ysdgkskkjs6fiix";
+       sha256 = "3d4667b49c53cfd7b44f3da7b3d9a70a83f24ee9bc197388f5990408b190e6b1";
        libraryHaskellDepends = [
          base extensible-exceptions transformers
        ];
@@ -92929,7 +93238,7 @@ self: {
      mkDerivation {
        pname = "monad-primitive";
        version = "0.1";
-       sha256 = "1vi6g65hdyq5vq78mfag0qljxgzb6vq83m82x3cpgjl7dr9k5h1x";
+       sha256 = "3dc032536e87ca77d9e802d581f036ebbf2e29064fb98a0ede05fb068b7926ee";
        libraryHaskellDepends = [ base primitive transformers ];
        homepage = "http://bitbucket.org/Shimuuar/monad-primitive";
        description = "Type class for monad transformers stack with pirimitive base monad";
@@ -92941,7 +93250,7 @@ self: {
      mkDerivation {
        pname = "monad-products";
        version = "4.0.0.1";
-       sha256 = "017cxiavxfw0f08sr0d6m3avla1lplmdj51rxpf1103ripq20r53";
+       sha256 = "a36420f08d798010dced3914d92abd3428bad5a8a681ac117080bbbe55ecec04";
        revision = "1";
        editedCabalFile = "fb4d07af0ad3081f3f2a252c99b777fafa6b3ece61ca81642f8a889ef370710e";
        libraryHaskellDepends = [ base semigroupoids ];
@@ -92955,7 +93264,7 @@ self: {
      mkDerivation {
        pname = "monad-ran";
        version = "0.1.0";
-       sha256 = "04y9s2b4hz2f8khr0q62xy0f6l2v896s7x03i3s18i14bwscqlax";
+       sha256 = "5d51cc345f244414f48803f4a34d425b50e380efc26090e1444e7c4896d0c913";
        libraryHaskellDepends = [ base ghc-prim mtl ];
        jailbreak = true;
        description = "Fast monads and monad transformers";
@@ -92968,7 +93277,7 @@ self: {
      mkDerivation {
        pname = "monad-resumption";
        version = "0.1.2.0";
-       sha256 = "09yz5cbvjlmqdlr25adxggpdz52jxyryyyrzix1pkdjr6aqpidkr";
+       sha256 = "79b678b13259b679438f3f7befb3ef5294dfee7bbda922326db852b9172bdf27";
        libraryHaskellDepends = [ base mmorph mtl transformers ];
        homepage = "https://github.com/igraves/resumption_monads";
        description = "Resumption and reactive resumption monads for Haskell";
@@ -92980,7 +93289,7 @@ self: {
      mkDerivation {
        pname = "monad-skeleton";
        version = "0.1.2.1";
-       sha256 = "0sg1yj4cp7ac26ydwhpc05j9bs3scaj25b9sb0xr1gw1qasnyi76";
+       sha256 = "e6446fb5c281bf903b583aad22a4627ae8956401ec42debc114c9dcb88f4e169";
        libraryHaskellDepends = [ base containers ghc-prim ];
        homepage = "https://github.com/fumieval/monad-skeleton";
        description = "An undead monad";
@@ -92992,7 +93301,7 @@ self: {
      mkDerivation {
        pname = "monad-st";
        version = "0.2.4";
-       sha256 = "1j67s07p5lsr81cjl0ch5d1q7zarmpak5kmnwckhavihg3l5m3bi";
+       sha256 = "718d5ae878306e0527e3b6ce32d5ad59fd83432b90012a594059d3720fd0c7c8";
        libraryHaskellDepends = [ base transformers ];
        homepage = "http://github.com/ekmett/monad-st";
        description = "Provides a MonadST class";
@@ -93006,7 +93315,7 @@ self: {
      mkDerivation {
        pname = "monad-state";
        version = "0.2.0.3";
-       sha256 = "1dh1dw7n39rb85wk4zq0hw2g9x81zyha033awv81l6xl8pjdxqxv";
+       sha256 = "bbe3dee445b41b1ad0e66a0ca0a0ff01f5f40487007f3279412ba7610f6f01b6";
        libraryHaskellDepends = [
          AbortT-transformers base fclabels monads-tf transformers
        ];
@@ -93020,7 +93329,7 @@ self: {
      mkDerivation {
        pname = "monad-statevar";
        version = "0.1";
-       sha256 = "08sr29qr02kfqja51ciqcpsf95wp3bypx64f4cwgpwh23xapr1fx";
+       sha256 = "dd857c551f02f2fb38238e987efd1a9797e4f46538b25094c46e0a9071125923";
        libraryHaskellDepends = [ base transformers ];
        testHaskellDepends = [ base stm ];
        homepage = "http://github.com/joeyadams/hs-monad-statevar";
@@ -93034,7 +93343,7 @@ self: {
      mkDerivation {
        pname = "monad-stlike-io";
        version = "0.2.2";
-       sha256 = "1lizwf31d8ha0xq644cfcn91l8sz8i4ldy12ig4ajfghxj2x4ad5";
+       sha256 = "a529d285ecf039a9c88b22f84649445f231a92658e116270070aa21686e33fd2";
        libraryHaskellDepends = [
          base bytestring containers deepseq monads-tf
        ];
@@ -93049,7 +93358,7 @@ self: {
      mkDerivation {
        pname = "monad-stlike-stm";
        version = "0.1.1";
-       sha256 = "007rsq9x0dq8xmiimgqb0v8k15xizx63qmc76b1b8a66nfsd9w56";
+       sha256 = "a6f0d4b4b3c628b4c23287553c4cffb19730d1060bbf1a63ed0837d013d6f900";
        libraryHaskellDepends = [ base monad-stlike-io stm ];
        homepage = "http://github.com/taruti/monad-stlike-stm";
        description = "ST-like monad capturing variables to regions and supporting STM";
@@ -93062,7 +93371,7 @@ self: {
      mkDerivation {
        pname = "monad-stm";
        version = "0.1.0.2";
-       sha256 = "09bbhbj9zg928j3dnvvxsrv8hw1c7s0vj0wffrhs810aqlf1m9xp";
+       sha256 = "b7a71a1cc50a04a461768e03b9813e2c708876d67d6fdb864422bd9fe4826b25";
        libraryHaskellDepends = [ base stm transformers ];
        description = "MonadSTM class analogous to MonadIO";
        license = stdenv.lib.licenses.bsd3;
@@ -93073,7 +93382,7 @@ self: {
      mkDerivation {
        pname = "monad-supply";
        version = "0.6";
-       sha256 = "1gg4r7fwaq2fa0lz8pz301mk3q16xpbs7qv54hhggxrv3i1h33ir";
+       sha256 = "398e01431c3bf7f7202465e3a3d7ed26e0316b00e35ff429504e60c5ddc9e4bd";
        libraryHaskellDepends = [ base mtl ];
        description = "Stateful supply monad";
        license = "unknown";
@@ -93084,7 +93393,7 @@ self: {
      mkDerivation {
        pname = "monad-task";
        version = "0.1.0";
-       sha256 = "01w3wqmsfl9w96kfpdiwfyghm2zjn70x78l436bzxfrcm1d3ayi8";
+       sha256 = "287a355aa82cbbfe971984a2d3c1b1f28b0a9f773cb6eba6493c51a72be68307";
        libraryHaskellDepends = [ base mtl transformers ];
        jailbreak = true;
        homepage = "http://github.com/ninegua/monad-task";
@@ -93097,7 +93406,7 @@ self: {
      mkDerivation {
        pname = "monad-time";
        version = "0.1";
-       sha256 = "1g3dqfwwmqwdpr3dcixxyw5akbdicx53i6d2s8921l2zbkm0hfnj";
+       sha256 = "d23a08ea5c5fd02012d2a299384a67b1ada90af7bd47d646be8de3cab9c36dbc";
        libraryHaskellDepends = [ base mtl time ];
        homepage = "https://github.com/scrive/monad-time";
        description = "Type class for monads which carry the notion of the current time";
@@ -93109,7 +93418,7 @@ self: {
      mkDerivation {
        pname = "monad-tx";
        version = "0.0.1";
-       sha256 = "0jv3pcmbm3bph42hhr4i0l3dchapixf5j5gd7ybs9j3bbk3yydk9";
+       sha256 = "6936efc75c6bc8a4973fed15595c8f5741d606059164080581778dba2abb634b";
        libraryHaskellDepends = [ base ];
        description = "A transactional state monad";
        license = stdenv.lib.licenses.bsd3;
@@ -93121,7 +93430,7 @@ self: {
      mkDerivation {
        pname = "monad-unify";
        version = "0.2.2";
-       sha256 = "1icl4jaa4vc4lb75m6wv4vjvf8b2xx7aziqhsg2pshizdkfxmgwp";
+       sha256 = "97bfdadd6c3f427dc5d310c7af4eef6221b7e5269b9b5acea2846da2942494c5";
        revision = "1";
        editedCabalFile = "7d585b29bfa558cf59d169421d1ec3363b6ef56b88cf6a9a082192d609676ce2";
        libraryHaskellDepends = [ base mtl unordered-containers ];
@@ -93139,7 +93448,7 @@ self: {
      mkDerivation {
        pname = "monad-unlift";
        version = "0.1.1.0";
-       sha256 = "1x86xpgirp97rda1y22129xf3fbkyb442jndpjsb9j1k4lplh7y2";
+       sha256 = "c21f482f2533c8b4b4bccd4a41c8f273b9e17a1241081f54cb27dd1cdfed06f5";
        libraryHaskellDepends = [
          base constraints exceptions monad-control mtl mutable-containers
          resourcet stm transformers transformers-base
@@ -93154,7 +93463,7 @@ self: {
      mkDerivation {
        pname = "monad-wrap";
        version = "0.1";
-       sha256 = "1hmigg0cbrsdvf6s0z2wn3s81q12qg3c30jjlsrw4jdfwv1qn13f";
+       sha256 = "6e048bc3e6ae49c2b3a65282c1c6c322e080f4b05c7ca08ddb4de7c5c07bb1c2";
        libraryHaskellDepends = [ base transformers ];
        description = "Wrap functions such as catch around different monads";
        license = stdenv.lib.licenses.bsd3;
@@ -93165,7 +93474,7 @@ self: {
      mkDerivation {
        pname = "monadIO";
        version = "0.10.1.4";
-       sha256 = "08158j978h69knbnzxkzv856sjhhw24h5lh7d8hx2lyhzbpnfarl";
+       sha256 = "342b67effad053d1216a07d20289e0104a6d0ada7ff66f979dc9407492442520";
        libraryHaskellDepends = [ base mtl stm ];
        description = "Overloading of concurrency variables";
        license = stdenv.lib.licenses.bsd3;
@@ -93176,7 +93485,7 @@ self: {
      mkDerivation {
        pname = "monadLib";
        version = "3.7.3";
-       sha256 = "17m9rj6spr5n9jlhwwvk8p40yrpwgz3j9kj3pjq7mpyrc1ssfd0q";
+       sha256 = "1834a77560d9df7ab0bc43ce24c77ffc660fc84573730ea94cb6e4ab8dcca99e";
        libraryHaskellDepends = [ base ];
        homepage = "http://wiki.github.com/yav/monadlib";
        description = "A collection of monad transformers";
@@ -93188,7 +93497,7 @@ self: {
      mkDerivation {
        pname = "monadLib-compose";
        version = "0.2";
-       sha256 = "14byhdcby094qpgmkblysnplz5r88xnfk7rnfddihzz4jgjzlvy1";
+       sha256 = "c16ffae593e47f185b73369fe96c4728974fafd59eae59dfc52401bf58837e91";
        libraryHaskellDepends = [ base monadLib ];
        jailbreak = true;
        homepage = "http://github.com/aristidb/monadLib-compose";
@@ -93201,7 +93510,7 @@ self: {
      mkDerivation {
        pname = "monadacme";
        version = "0.0.2";
-       sha256 = "1qam6k3gax2kf9zbf0q2mbsknkmx8y73i9qshbylj8wrpf896y97";
+       sha256 = "27799390bb992349fd821aa7388e47bd4e3bf5aa0203b77e725374f5c63455e1";
        libraryHaskellDepends = [ base ];
        description = "The Acme and AcmeT monads";
        license = stdenv.lib.licenses.bsd3;
@@ -93213,7 +93522,7 @@ self: {
      mkDerivation {
        pname = "monadbi";
        version = "0.1";
-       sha256 = "0r5hja34nalhvlc4x2rmhk9j1rsd363ilfjkd7y7cv4l8yzvifq7";
+       sha256 = "07bbb8bf47946c76fc69533a1a87194de720d384358b4e18dd902a4b8692b064";
        libraryHaskellDepends = [ base mtl ];
        homepage = "https://github.com/ajnsit/monadbi";
        description = "Extract underlying monads from monad transformers";
@@ -93227,7 +93536,7 @@ self: {
      mkDerivation {
        pname = "monadcryptorandom";
        version = "0.6.1";
-       sha256 = "0j99j0f2qwhslimfgslsdlv0xihsddas3i69pfnjwnsd9zg5pgj2";
+       sha256 = "42be5bde4f4d5b2eadbbc9c4a1556b1ac60e366d9aeae76aa41a722c1c902949";
        libraryHaskellDepends = [
          base bytestring crypto-api mtl tagged transformers
        ];
@@ -93241,7 +93550,7 @@ self: {
      mkDerivation {
        pname = "monadfibre";
        version = "0.1.2.1";
-       sha256 = "0vj84g5y0k903pz4lk12sa6l6c0f26dc42x62f1mqny8457r3ds6";
+       sha256 = "46b7914f21c85b5c8313a60bc29a110e30438dd2224c4afe1d204de0cb23486e";
        libraryHaskellDepends = [ base monadbi ];
        homepage = "https://github.com/ajnsit/monadfibre";
        description = "Monadic functions which provide Choice and Parallelism";
@@ -93253,7 +93562,7 @@ self: {
      mkDerivation {
        pname = "monadic-arrays";
        version = "0.2.1.4";
-       sha256 = "1vlqh0mqfkg1f47dhl5lw49b7xawlbyjmq7xpmmf16q3idxnkahh";
+       sha256 = "10aa697b8b039be06abdfde02afda25cf5b312e1b450d80e71e14d872b8098ee";
        libraryHaskellDepends = [ array base stm transformers ];
        homepage = "http://github.com/ekmett/monadic-arrays/";
        description = "Boxed and unboxed arrays for monad transformers";
@@ -93265,7 +93574,7 @@ self: {
      mkDerivation {
        pname = "monadiccp";
        version = "0.7.6";
-       sha256 = "083ppr53ac85r5ybndngsfwxgalj63giz32aa7wpcm629b9g4lxc";
+       sha256 = "ac53f2d24ac25476f9514a8c1fdf3092aad7b9d3cf36bb7cc90531354abe7720";
        libraryHaskellDepends = [
          base containers mtl parsec pretty random
        ];
@@ -93282,7 +93591,7 @@ self: {
      mkDerivation {
        pname = "monadiccp-gecode";
        version = "0.1.2";
-       sha256 = "1ylyzklcb37khrq8a11fzlyd0sa1nrhpd7cv470m23v7l1hc1wg0";
+       sha256 = "e0f1c060a0670f51c1219b9d7661b64169d03cfd2e04857086f38cc5e8fc9efa";
        libraryHaskellDepends = [ base containers monadiccp mtl ];
        librarySystemDepends = [
          gecodeint gecodekernel gecodesearch gecodeset gecodesupport
@@ -93299,7 +93608,7 @@ self: {
      mkDerivation {
        pname = "monadio-unwrappable";
        version = "0.3";
-       sha256 = "18hbi4vxj9lfcla11b17sb88ysskxavq00zmrjx62cpyzkp85yxh";
+       sha256 = "b0fb82eefcfe3261baccf50380b7ea536b8fd0d227ac1014658e26d937890ba2";
        libraryHaskellDepends = [ base monads-tf transformers ];
        description = "Reversibly allow monad transformer stacks to run in IO";
        license = stdenv.lib.licenses.bsd3;
@@ -93310,7 +93619,7 @@ self: {
      mkDerivation {
        pname = "monadlist";
        version = "0.0.2";
-       sha256 = "1zpxqp5zhcpk4358xqrapvkcfyazpdsdlrw3g14518y2kwnfifq6";
+       sha256 = "06bbe82c9fc2a35048788367da74bb5f79c7e6be2ae38eca20f332f8cbc5fdfe";
        libraryHaskellDepends = [ base ];
        description = "Monadic versions of list functions";
        license = stdenv.lib.licenses.bsd3;
@@ -93321,7 +93630,7 @@ self: {
      mkDerivation {
        pname = "monadloc";
        version = "0.7.1";
-       sha256 = "1a773nysrsj61ka7bdacb0i7dxlgb1fjz3x5w9c1w1dv7rmhynmj";
+       sha256 = "b25a0f6b3ebb051e58e2a58f2f5d588ff67622584cb575d40c46eaacbd1de7a8";
        libraryHaskellDepends = [ base template-haskell transformers ];
        homepage = "http://github.com/pepeiborra/monadloc";
        description = "A class for monads which can keep a monadic call trace";
@@ -93335,7 +93644,7 @@ self: {
      mkDerivation {
        pname = "monadloc-pp";
        version = "0.3.1";
-       sha256 = "0ch25kcz63xhinwd6mjqbhm282hfh280s3z910wnvdp3krgx0mpc";
+       sha256 = "ec56d05f9ee3b66d3908e90f0d90800e0a242a5c5856d3b88db00ff3d92c0232";
        isLibrary = false;
        isExecutable = true;
        executableHaskellDepends = [
@@ -93352,7 +93661,7 @@ self: {
      mkDerivation {
        pname = "monadplus";
        version = "1.4.2";
-       sha256 = "15b5320wdpmdp5slpphnc1x4rhjch3igw245dp2jxbqyvchdavin";
+       sha256 = "366ed520db1eaf2ec56d8508fee2804cc24c7a6016de4b75b9addec681186595";
        libraryHaskellDepends = [ base ];
        description = "Haskell98 partial maps and filters over MonadPlus";
        license = stdenv.lib.licenses.bsd3;
@@ -93363,7 +93672,7 @@ self: {
      mkDerivation {
        pname = "monads-fd";
        version = "0.2.0.0";
-       sha256 = "1iqr5p3va5sxmpvydwqz2src54j5njcyrzn9p5apc60nv7yv6x4c";
+       sha256 = "8c74b3fdd916187655b9c9feec99b44592c2b2161ff3e6f7ad5d17b5c72d19c7";
        libraryHaskellDepends = [ base mtl transformers ];
        jailbreak = true;
        description = "Monad classes, using functional dependencies";
@@ -93375,7 +93684,7 @@ self: {
      mkDerivation {
        pname = "monads-tf";
        version = "0.1.0.2";
-       sha256 = "0z07z2lfm3l93fx0qhfd98j76d1rksi5llq67l5v09pm8da4jvyb";
+       sha256 = "cb6f495443f526b00b3d06535aa29e393473244acd410cba1b898eeaa8f8077c";
        libraryHaskellDepends = [ base transformers ];
        description = "Monad classes, using type families";
        license = stdenv.lib.licenses.bsd3;
@@ -93386,7 +93695,7 @@ self: {
      mkDerivation {
        pname = "monadtransform";
        version = "0.0.2";
-       sha256 = "0i586zh6247jfmkw2x27j0aq47yz1c71irj9iwrlx1zrmvzak1yv";
+       sha256 = "db87a9feaef9874e338f49e6180e0bdf1f8215904774c16775f21061e037a844";
        libraryHaskellDepends = [ base transformers ];
        homepage = "https://github.com/tonymorris/monadtransform";
        description = "A type-class for transforming monads (homomorphism) in a transformer";
@@ -93401,7 +93710,7 @@ self: {
      mkDerivation {
        pname = "monarch";
        version = "0.10.0.0";
-       sha256 = "1a47hhlmllrm3k4ssr8rr3bgq1w7i6jpx07nyf0k8k9x5sgi1siv";
+       sha256 = "3bea109f2e3d4d3481f3f6807ea5898707fcd6c81965adc91c35535a298487a8";
        libraryHaskellDepends = [
          base binary bytestring containers lifted-base monad-control mtl
          network pool-conduit stm transformers transformers-base
@@ -93424,14 +93733,14 @@ self: {
      }:
      mkDerivation {
        pname = "mongoDB";
-       version = "2.0.5";
-       sha256 = "09ysw5sp7x8pyfsjj1qgfq3wm8l0cpxkv9g9x117iss04bfk0p3h";
+       version = "2.0.6";
+       sha256 = "d6b7699d98a9349b2711be23fce0c61fbf91b66e4625e937ca1b65c6b6f988c5";
        libraryHaskellDepends = [
          array base binary bson bytestring containers cryptohash hashtables
          lifted-base monad-control mtl network parsec random random-shuffle
          text transformers-base
        ];
-       testHaskellDepends = [ base hspec mtl old-locale time ];
+       testHaskellDepends = [ base hspec mtl old-locale text time ];
        homepage = "https://github.com/mongodb-haskell/mongodb";
        description = "Driver (client) for MongoDB, a free, scalable, fast, document DBMS";
        license = "unknown";
@@ -93444,7 +93753,7 @@ self: {
      mkDerivation {
        pname = "mongodb-queue";
        version = "0.4.0.1";
-       sha256 = "1y3c5ydf7595ai3h6iapc0dmls348vv1jmy4g8n5wfmwzy4li22s";
+       sha256 = "5a884889ffbc3a5e2c7ac45719f64664685a1b6057450347542595e39a2f6cf8";
        libraryHaskellDepends = [
          base data-default lifted-base monad-control mongoDB network text
          transformers
@@ -93468,7 +93777,7 @@ self: {
      mkDerivation {
        pname = "mongrel2-handler";
        version = "0.3.2";
-       sha256 = "1bv9i2b0pb50r7l7l43h26ng5rcs1iyymwndcwxji8dnmbnr4jdf";
+       sha256 = "ae4992edaab6a1283b67cdf2ea7d0c9ae5f2ac1170107ae8c9a0ac0b968869af";
        libraryHaskellDepends = [
          attoparsec base blaze-builder blaze-textual bytestring
          case-insensitive containers http-types text zeromq-haskell
@@ -93484,7 +93793,7 @@ self: {
      mkDerivation {
        pname = "monitor";
        version = "0.1.1";
-       sha256 = "06p9xj5y3xl4hcl57afqz4m4yc2vaah8i6f4smmhwmkzslg7svbs";
+       sha256 = "7a6d7d1ed57f560e6bd5c49988a0525b304f2af9d8a953288384f6e18bece91a";
        isLibrary = false;
        isExecutable = true;
        executableHaskellDepends = [ base filepath hinotify process ];
@@ -93497,7 +93806,7 @@ self: {
      mkDerivation {
        pname = "mono-foldable";
        version = "0.1.0.2";
-       sha256 = "1qnbw9pd06czwyj2xcsjdigg7bj8d23p3ljnnkgd3d0r67qxxlxm";
+       sha256 = "b5d3def13119b4d1deb456d271876848aef35e6c52b32ea4e79f19d06ee2cbe2";
        libraryHaskellDepends = [ base bytestring text vector ];
        jailbreak = true;
        homepage = "http://github.com/JohnLato/mono-foldable";
@@ -93515,7 +93824,7 @@ self: {
      mkDerivation {
        pname = "mono-traversable";
        version = "0.9.2.1";
-       sha256 = "1vs2nl3c0gdhaxxh013ri3l9n13yl9nawiynpsyq6zp495xq5hrl";
+       sha256 = "34c3827b49e47e83bdbed647ae6ca27e049be8887904007b57b03dc006b542ef";
        libraryHaskellDepends = [
          base bytestring comonad containers dlist dlist-instances hashable
          semigroupoids semigroups text transformers unordered-containers
@@ -93535,7 +93844,7 @@ self: {
      mkDerivation {
        pname = "monoid-extras";
        version = "0.4.0.1";
-       sha256 = "0jcyjqmk4s64j05qisvibmy87m5xi5n837wsivq7lml8lfyrj7yf";
+       sha256 = "ce1f99bda388567af08e9a9f816c89bdd4837c5d71eb880b90c468322b969e49";
        libraryHaskellDepends = [ base groups semigroupoids semigroups ];
        description = "Various extra monoid-related definitions and utilities";
        license = stdenv.lib.licenses.bsd3;
@@ -93546,7 +93855,7 @@ self: {
      mkDerivation {
        pname = "monoid-owns";
        version = "2010.5.29";
-       sha256 = "1n05f95yhn6jp7rdnlx686k1lsls4iilxdxnp41ds4afsypaclfk";
+       sha256 = "d351a6aed74e11dd02b9b6b74e63249a6a1aa641a653dbf2b9d258e84b7205d8";
        libraryHaskellDepends = [ base bytestring containers ];
        homepage = "http://github.com/nfjinjing/monoid-owns";
        description = "a practical monoid implementation";
@@ -93559,7 +93868,7 @@ self: {
      mkDerivation {
        pname = "monoid-record";
        version = "0.1";
-       sha256 = "14xs1nvf0ngx4jvinkhzq3ainhs159zx0396z88y21vvc8kw42i5";
+       sha256 = "250ac227627b07e111fa260dd07f2a41431bd5c01f4e1bb724fd59e0b60dba93";
        libraryHaskellDepends = [ base ];
        description = "Support for modifying record fields of monoidal type";
        license = stdenv.lib.licenses.bsd3;
@@ -93570,7 +93879,7 @@ self: {
      mkDerivation {
        pname = "monoid-statistics";
        version = "0.3.1";
-       sha256 = "0gfdjmx457r580lc40vpg8fkzd8n971b5vam96v6kzssg2cznqy3";
+       sha256 = "c363fb99785aff69b64955edb2c24916b53f1d7a7703c22840259f427a95cd3d";
        libraryHaskellDepends = [ base ];
        homepage = "https://bitbucket.org/Shimuuar/monoid-statistics";
        description = "Monoids for calculation of statistics of sample";
@@ -93584,7 +93893,7 @@ self: {
      mkDerivation {
        pname = "monoid-subclasses";
        version = "0.4.1.2";
-       sha256 = "0j9an1zq3dg02jz8skqkch01kg2ha59zja2729v8lpwxsd4sbi9x";
+       sha256 = "3dc5a549d39d5f8a76124728f9535150bc190064134f8dbe14e0b5817fb02a49";
        libraryHaskellDepends = [
          base bytestring containers primes text vector
        ];
@@ -93602,7 +93911,7 @@ self: {
      mkDerivation {
        pname = "monoid-transformer";
        version = "0.0.3";
-       sha256 = "1f06ppvv50w5pacm4bs89zwkydih626cgbd2z6xqbp8cmhg6dj4l";
+       sha256 = "94c8661eac0cdd85bbf9a2adc78c3030363ff94f482f5299ba8583b2f7bd06b8";
        libraryHaskellDepends = [ base ];
        description = "Monoid counterparts to some ubiquitous monad transformers";
        license = stdenv.lib.licenses.bsd3;
@@ -93615,7 +93924,7 @@ self: {
      mkDerivation {
        pname = "monoidal-containers";
        version = "0.1.2.2";
-       sha256 = "06yam4ljp4lm2rjaccykg8zx4hnmn0ly3fs24xjm4q45ldz7gwyb";
+       sha256 = "cbf3777ea3856052652742bbe129b0d542d23f7ad333a6641695922b29a9ca1b";
        libraryHaskellDepends = [
          base containers deepseq hashable lens newtype unordered-containers
        ];
@@ -93629,7 +93938,7 @@ self: {
      mkDerivation {
        pname = "monoidplus";
        version = "0.1.0.1";
-       sha256 = "1klgwv3sd9zmqpj157rypln51kcwml9b1fyaxnip0a1525h6c2s9";
+       sha256 = "490b666011252870a3edcabbb012ad9ccd502cbd3e9f12e4c5f5a7a6c7e68fce";
        libraryHaskellDepends = [
          base contravariant semigroups transformers
        ];
@@ -93646,7 +93955,7 @@ self: {
      mkDerivation {
        pname = "monoids";
        version = "0.3.2";
-       sha256 = "0yn15q0569mdm20wdbwydbb1vdzfdh1ismhwplwbvi2989h78kca";
+       sha256 = "8a4d74604249c4bd38bd1c561d036ceeb71dd66a9eafc681a8ad2653002ec17a";
        libraryHaskellDepends = [
          array base bytestring containers fingertree parallel text
        ];
@@ -93662,7 +93971,7 @@ self: {
      mkDerivation {
        pname = "monomorphic";
        version = "0.0.3.3";
-       sha256 = "0x7fig4ms5qqiah4847ghl13s2r1xv2372hj6xrhjw6bdfh85cln";
+       sha256 = "96b282a06bcb70097337128a33c4ee210b3d0285ef1044a08a18175dc98bee74";
        libraryHaskellDepends = [ base ];
        homepage = "https://github.com/konn/monomorphic";
        description = "Library to convert polymorphic datatypes to/from its monomorphic represetation";
@@ -93678,7 +93987,7 @@ self: {
      mkDerivation {
        pname = "montage";
        version = "0.1.1";
-       sha256 = "1yx2aagfxjgs9jwipbwa05aiqkm1xgxd0gwnc4qj6mwz9913zsl7";
+       sha256 = "87ea3f424a9f57233161963fd0faeba14e1c55018aaf1bb94cfac9ee9e52a2fb";
        libraryHaskellDepends = [
          aeson base bytestring containers ListLike old-locale pool-conduit
          protocol-buffers protocol-buffers-descriptor riak-bump safe
@@ -93702,7 +94011,7 @@ self: {
      mkDerivation {
        pname = "montage-client";
        version = "0.1.1";
-       sha256 = "18bgaw0i7zllabq8ys6p6qd8qga3xgxsfmgn88g4dijh6v6zf7pf";
+       sha256 = "ee1ef7cd3650c6461e42f655a7fbeb433d8c1a36d7688ff05294fe1301576fa1";
        libraryHaskellDepends = [
          aeson base bytestring containers ListLike mtl old-locale
          pool-conduit protocol-buffers protocol-buffers-descriptor riak-bump
@@ -93724,7 +94033,7 @@ self: {
      mkDerivation {
        pname = "monte-carlo";
        version = "0.6.1";
-       sha256 = "1zk8wyf9bzarnvsxh9a6diyssb78sfq1pl729gq113j0vibs8f0x";
+       sha256 = "1d38a457dc408e10f04be2d01bb0d3e82cad7d6c4625d8f5b659fd959ce768fe";
        libraryHaskellDepends = [
          base gsl-random primitive transformers vector
        ];
@@ -93747,7 +94056,7 @@ self: {
      mkDerivation {
        pname = "moo";
        version = "1.0";
-       sha256 = "02ah9v6h4ansd8kz76jnrx0yra9nz6ql92p5rm01pxri1gc7kn6w";
+       sha256 = "dcd879d80b31f71b40cde58a44b1f936a9ec41cf569af3276ada2a02cd4e5009";
        libraryHaskellDepends = [
          array base gray-code mersenne-random-pure64 monad-mersenne-random
          mtl random random-shuffle time
@@ -93769,7 +94078,7 @@ self: {
      mkDerivation {
        pname = "moonshine";
        version = "2.0.0.0";
-       sha256 = "1b8b7h9nk5nzk9q5ysg57q1rain36bxhvx4l7qwidsx30rdfs6qs";
+       sha256 = "1a1bed5a06a3eb16393e94f40dfb32c34695033ee5695f709adf9669133c0bad";
        libraryHaskellDepends = [
          aeson base bytestring canteven-config ekg ekg-core hslogger snap
          text time transformers yaml
@@ -93787,7 +94096,7 @@ self: {
      mkDerivation {
        pname = "morfette";
        version = "0.4.3";
-       sha256 = "149jp0s5nsa02zivlp868qqvvam59wwf6nkq79ynlqjsa4lanvay";
+       sha256 = "5e6dab28515a626a7d3a785ae3384fa5aabd3146065dbae31740695b34b83291";
        isLibrary = false;
        isExecutable = true;
        executableHaskellDepends = [
@@ -93808,7 +94117,7 @@ self: {
      mkDerivation {
        pname = "morfeusz";
        version = "0.4.2";
-       sha256 = "1lzl5ks7px1xibfa6y0wnfv2mk2w39hscrrynqn7a3gjnca00sx0";
+       sha256 = "a06b0014b3f20d752cb63e67a6611a5ccc2ab6b31c78a3dc8a3df47bf42cf4d3";
        libraryHaskellDepends = [
          base bytestring containers directory mtl text
        ];
@@ -93828,7 +94137,7 @@ self: {
      mkDerivation {
        pname = "morte";
        version = "1.2.1";
-       sha256 = "15zvk50qpp3ywkwqgpm4phdcspfszzwipxcf07lnxpk98i7ybc4g";
+       sha256 = "8fb0e54f4469de6ee9018ef51bf9ffda5dcd1abca4de87f9e47edc8b4199fb97";
        isLibrary = true;
        isExecutable = true;
        libraryHaskellDepends = [
@@ -93851,7 +94160,7 @@ self: {
      mkDerivation {
        pname = "mosaico-lib";
        version = "0.1.1.0";
-       sha256 = "1qcr3l1a422fh5226443dc8p6hvrr9wbhri6mk2pcw7zyfd5xr0b";
+       sha256 = "0be45e9af3ff7076c5ac2666b878ca794373116b83102344814e08a2021d99e1";
        libraryHaskellDepends = [
          base base-unicode-symbols colour diagrams-cairo diagrams-core
          diagrams-gtk diagrams-lib glib gtk JuicyPixels mtl split stm
@@ -93869,7 +94178,7 @@ self: {
      mkDerivation {
        pname = "mount";
        version = "0.2.1";
-       sha256 = "0rdlnz0xk6mil79a8ygfrwgdychsn6h1gbv6qn2nybzaw1zjf4z3";
+       sha256 = "e313277fe0ea2f6f85c566af17a0b11a32df1ecfee79a4d2a1b19ad9c1b7b465";
        libraryHaskellDepends = [ base bytestring ];
        description = "Mounts and umounts filesystems";
        license = "GPL";
@@ -93885,7 +94194,7 @@ self: {
      mkDerivation {
        pname = "mp";
        version = "0.2.2";
-       sha256 = "1klz2ykglgkvxs66j5iacjbx5cv5gq0y4d12g68ng2pcmpwc93ir";
+       sha256 = "398ec4f8adec8a6791792234e2017e65b3d297642a16698cee7b3efaa6179fce";
        revision = "1";
        editedCabalFile = "8c578611352448e5aea9a082fb0696e7bb890397214631a009351925db2f88b1";
        isLibrary = false;
@@ -93906,7 +94215,7 @@ self: {
      mkDerivation {
        pname = "mp3decoder";
        version = "0.0.1";
-       sha256 = "0kwjnbrmlp9a5wz3mgf76nd2ar32d3n1f4jmbfpsggcm7jdp1rmv";
+       sha256 = "bbe6709b3c95bda7af5b551217ec686264259a35c7bd3a3e2f2a5d5af3b2924f";
        isLibrary = false;
        isExecutable = true;
        executableHaskellDepends = [
@@ -93923,7 +94232,7 @@ self: {
      mkDerivation {
        pname = "mpdmate";
        version = "0.1";
-       sha256 = "02p6g8wgmmzxl3dnrvbj1msg972c40s300rfykqsg1g5wiqbllf2";
+       sha256 = "c251ba70e4e585a7f1f42e033034204c9cf4740d72ed6cdba0fdd7fa387ae60a";
        isLibrary = false;
        isExecutable = true;
        executableHaskellDepends = [
@@ -93940,7 +94249,7 @@ self: {
      mkDerivation {
        pname = "mpppc";
        version = "0.1.3";
-       sha256 = "1zcilskpslpqyrbwpabwbry4p3kpcfca94wchh9dkq9g8pg8laxi";
+       sha256 = "b12b8ade452fe1d912848c93a49863778e4b7c5e7ca9cb57f6f8527da7a691fd";
        libraryHaskellDepends = [
          ansi-terminal base bytestring split text
        ];
@@ -93957,7 +94266,7 @@ self: {
      mkDerivation {
        pname = "mpretty";
        version = "0.1.0.0";
-       sha256 = "0q4fi7jmdf3bvcqk6fc7194h59sjwf76ld8niwqczc30v8lyjq2n";
+       sha256 = "5660e929da60b0cf308f16356a8ee352a702490a87393331db6bb856e5898e60";
        libraryHaskellDepends = [
          ansi-terminal base containers data-lens-fd data-lens-template mtl
          orders text transformers
@@ -93975,7 +94284,7 @@ self: {
      mkDerivation {
        pname = "mprover";
        version = "0.0.0.0";
-       sha256 = "1b5vzhbn5jnpxc0bzbhdak51qhzv5hif0300jsrbi5ffyvcjqkss";
+       sha256 = "5a4f2cd9f6ce95b8b296000ce0222cfb431cca540daebf00ebd7ca6217fcbbac";
        isLibrary = false;
        isExecutable = true;
        executableHaskellDepends = [
@@ -93994,7 +94303,7 @@ self: {
      mkDerivation {
        pname = "mps";
        version = "2010.11.28";
-       sha256 = "1xhflvgwrjzj7qb69dn149lh32c7q9161zrzfs07ncs233y0w4lg";
+       sha256 = "8f120efc1842337b80763fff6042c28789016922c1b664163ef2cbccdfa60ef6";
        libraryHaskellDepends = [
          array base bytestring containers directory filepath monoid-owns
          old-locale old-time parallel parsec regexpr template-haskell time
@@ -94013,7 +94322,7 @@ self: {
      mkDerivation {
        pname = "mpvguihs";
        version = "0.1.1";
-       sha256 = "1nmc03s8h3khmvajyhwaniczq0r4wrinq2sjjp1c6gyc2nggxzyx";
+       sha256 = "ddfffe9e15cc3fc3c295520b6c63e62403fc59b48a432fd5ae700e88f400acda";
        isLibrary = false;
        isExecutable = true;
        executableHaskellDepends = [
@@ -94033,7 +94342,7 @@ self: {
      mkDerivation {
        pname = "mqtt-hs";
        version = "0.2.0";
-       sha256 = "0jvzr6qbmdxl11j8fwnbasgqgdfm395lm2gh2va9zfpk5xpx0mjg";
+       sha256 = "4f56d06f2ff3ba9fd416f0894a4b1ad5b5879f56cb72876408b4b7bab0c97f4b";
        revision = "1";
        editedCabalFile = "aa0a2e9ea99cfbed4646ac02625b66361f8175ae2d70efc041dc517119706439";
        libraryHaskellDepends = [
@@ -94054,7 +94363,7 @@ self: {
      mkDerivation {
        pname = "ms";
        version = "0.2.1";
-       sha256 = "0h70dkgzybbjm48ay9xqbvydf13a6q1zy99ln8kx4qlfdi4gsrnp";
+       sha256 = "d766fd486c8e62d227b23425ff03366a04d7fc5eb827af10a9722dffdf6ce040";
        libraryHaskellDepends = [
          base contravariant edit-distance lens profunctors semigroupoids
          semigroups vector
@@ -94076,7 +94385,7 @@ self: {
      mkDerivation {
        pname = "msgpack";
        version = "1.0.0";
-       sha256 = "0kk6nqn290sh0l0hhglccs0cqgk0fb3xdjzqz19yw9wb8aw01xh8";
+       sha256 = "08f600b8428b27ee53f8f8cbd6c772603ecc80668c3e0801055083242cb6664e";
        libraryHaskellDepends = [
          base binary blaze-builder bytestring containers data-binary-ieee754
          deepseq hashable mtl text unordered-containers vector
@@ -94097,7 +94406,7 @@ self: {
      mkDerivation {
        pname = "msgpack-aeson";
        version = "0.1.0.0";
-       sha256 = "1ygnki55cj6951y75snc4gnv4vsjp9pgwqg3jp7cy9bcss3msq3j";
+       sha256 = "72605d87d66c25cfce95e361fe6eba526fb2ed23ccea727c28c948564a9cf6f9";
        libraryHaskellDepends = [
          aeson base bytestring deepseq msgpack scientific text
          unordered-containers vector
@@ -94116,7 +94425,7 @@ self: {
      mkDerivation {
        pname = "msgpack-idl";
        version = "0.2.1";
-       sha256 = "0z28qikcfvfkj9xr87g13jlm2blqfxj3rfrg7hm2hfgv3qz4gkfz";
+       sha256 = "dfcd473e1efb39282a3c2fbb3c6477982e51a91ce11d947b92d36dc766c4487c";
        isLibrary = true;
        isExecutable = true;
        libraryHaskellDepends = [
@@ -94140,7 +94449,7 @@ self: {
      mkDerivation {
        pname = "msgpack-rpc";
        version = "1.0.0";
-       sha256 = "00m5hpj5cd521j3jzsaw49asbpxvka0x1zi2qs26si82wxgnpjkn";
+       sha256 = "76ca6b5fe702456d84c622fed0819abbdfa555225ce92f870ca23456e485a502";
        libraryHaskellDepends = [
          base binary binary-conduit bytestring conduit conduit-extra
          exceptions monad-control msgpack mtl network random text
@@ -94156,7 +94465,7 @@ self: {
      mkDerivation {
        pname = "msi-kb-backlit";
        version = "0.1.0.1";
-       sha256 = "1lq1a13h74dkhmh6mkg9mzksvzc2mjb8ynsbs9856z7079ifsdw4";
+       sha256 = "8437ed623ae07c5350d24b5b8f96ac82fdade7afe9cd6a6085b39103475001d3";
        isLibrary = false;
        isExecutable = true;
        executableHaskellDepends = [ base bytestring hid split ];
@@ -94169,7 +94478,7 @@ self: {
      mkDerivation {
        pname = "mstate";
        version = "0.2.7";
-       sha256 = "05rcpfang0biy16aglf6da44zp9zqy2x0zdsfl75mv1drkky6225";
+       sha256 = "4508e3e7cc2dec5a0e75ba7dd085c73fdd4f886ac6d1a74cf071816795bb2c17";
        libraryHaskellDepends = [ base monad-peel mtl stm ];
        description = "MState: A consistent State monad for concurrent applications";
        license = stdenv.lib.licenses.bsd3;
@@ -94182,7 +94491,7 @@ self: {
      mkDerivation {
        pname = "msu";
        version = "0.0.2";
-       sha256 = "0bqzzk7y3dj60r02xn3cjlq955jzsrvcbq63pvav0w952bvxvx5c";
+       sha256 = "acf4ddf7122571b0d5bec3e0c576d65f969230956cd82e400646b6e1cffc1f2f";
        isLibrary = false;
        isExecutable = true;
        executableHaskellDepends = [
@@ -94203,7 +94512,7 @@ self: {
      mkDerivation {
        pname = "mtgoxapi";
        version = "0.5.0.2";
-       sha256 = "1iyn2mq0fql952phmbs8578awrv5l6q9iqkmsaby2jp48mnwizji";
+       sha256 = "51fec86d45e44ae197d275e298b0a16567aed02948af0aaf288962077015d6c7";
        libraryHaskellDepends = [
          aeson attoparsec base base16-bytestring base64-bytestring
          bytestring curl either errors hashable HTTP ixset network SHA text
@@ -94226,7 +94535,7 @@ self: {
      mkDerivation {
        pname = "mtl";
        version = "2.1.3.1";
-       sha256 = "1xpn2wjmqbh2cg1yssc6749xpgcqlrrg4iilwqgkcjgvaxlpdbvp";
+       sha256 = "77af766957fb49361fe63446f272a698bddb13398669edc363022e5c2517f6f6";
        libraryHaskellDepends = [ base transformers ];
        jailbreak = true;
        homepage = "http://github.com/ekmett/mtl";
@@ -94239,7 +94548,7 @@ self: {
      mkDerivation {
        pname = "mtl";
        version = "2.2.1";
-       sha256 = "1icdbj2rshzn0m1zz5wa7v3xvkf6qw811p4s7jgqwvx1ydwrvrfa";
+       sha256 = "cae59d79f3a16f8e9f3c9adc1010c7c6cdddc73e8a97ff4305f6439d855c8dc5";
        libraryHaskellDepends = [ base transformers ];
        homepage = "http://github.com/ekmett/mtl";
        description = "Monad classes, using functional dependencies";
@@ -94251,7 +94560,7 @@ self: {
      mkDerivation {
        pname = "mtl-c";
        version = "0.1";
-       sha256 = "0n91jh07v87j2rbilyrip3inixb9a95i2j61g5hz42kiq5wj71gb";
+       sha256 = "eb852379c1710af26179c148114b5269f568e3b8317b1a5716f2a07d00942159";
        libraryHaskellDepends = [ base mtl ];
        homepage = "https://github.com/fumieval/mtl-c";
        description = "Very strict CPS'd transformers";
@@ -94263,7 +94572,7 @@ self: {
      mkDerivation {
        pname = "mtl-compat";
        version = "0.2.1.3";
-       sha256 = "15388p9ybdn6digk6cpdsw6havd0yva8vvwl3p7fnc9sb59wln34";
+       sha256 = "6458ca53593a31ebce1d94ef8dd4f6a06d050dd7ed32335f6cc6b6e5d3456894";
        revision = "1";
        editedCabalFile = "b4d1feef302a6fe59e77e822e61261eeaec449a6b56560ea8429bb1bc7dbccc6";
        libraryHaskellDepends = [ base mtl ];
@@ -94279,7 +94588,7 @@ self: {
      mkDerivation {
        pname = "mtl-evil-instances";
        version = "0.1";
-       sha256 = "1z10p0dmvjyadjc46nkzyqicfk0097ff2ni3fiypw9z5knsxhym4";
+       sha256 = "a47ad8b59de5277e7d74235ae1dc49004cc722f67f5a43986ccacb5d1bb820fc";
        libraryHaskellDepends = [
          base monad-control mtl transformers transformers-base
        ];
@@ -94293,7 +94602,7 @@ self: {
      mkDerivation {
        pname = "mtl-prelude";
        version = "1.0.3";
-       sha256 = "1qr0bwcg9rlj53gbnji969s86qh8laaiibkfy2msziqnp011108x";
+       sha256 = "1d811002b816c7afabf06eae1895a20862837432294abbde2892e6f4185f20e3";
        libraryHaskellDepends = [ base mtl transformers ];
        homepage = "https://github.com/nikita-volkov/mtl-prelude";
        description = "Reexports of most definitions from \"mtl\" and \"transformers\"";
@@ -94305,7 +94614,7 @@ self: {
      mkDerivation {
        pname = "mtl-prelude";
        version = "2.0.2";
-       sha256 = "1j42pdkiiqjkdmidgmgpfbwh2i8dwsc40labw4pm86qzsi0r8m2v";
+       sha256 = "5b549441d41f1b542fe14b514098e60d4501f972f7d5d7626d53e21867bb82c8";
        libraryHaskellDepends = [ base mtl transformers ];
        homepage = "https://github.com/nikita-volkov/mtl-prelude";
        description = "Reexports of most definitions from \"mtl\" and \"transformers\"";
@@ -94317,7 +94626,7 @@ self: {
      mkDerivation {
        pname = "mtl-tf";
        version = "0.1";
-       sha256 = "0qfmswdkj95bh6wkic8hh002wsxqlrylw45k6w9iyzv4saqnl22f";
+       sha256 = "4e086ab1d2647f1f1337b3104e7da6b86b2e008010b138b981ab24391bd7d561";
        libraryHaskellDepends = [ base ];
        description = "Monad transformer library using type families";
        license = stdenv.lib.licenses.bsd3;
@@ -94331,7 +94640,7 @@ self: {
      mkDerivation {
        pname = "mtl-unleashed";
        version = "0.3.1";
-       sha256 = "04kbm0lxfwv34991384blz8a4qjwl32jv0d3x6rvgpjlidphfi2l";
+       sha256 = "5444076f8b54deb7b3e9a3812dc5a05c62a2d0a78ba01152226373d729a86b12";
        libraryHaskellDepends = [
          base contravariant lens mtl profunctors tagged
        ];
@@ -94348,7 +94657,7 @@ self: {
      mkDerivation {
        pname = "mtlparse";
        version = "0.1.4.0";
-       sha256 = "1fl5rvmgk37bqgjzs3c2wh80pfhr0i4yakxbsaryg7piws7j6ygc";
+       sha256 = "ec79238fe6f19ee7b3d2ab4fe5490419ba0b10e4820dfde5c3eb8cf9eace85ba";
        libraryHaskellDepends = [ base mtl ];
        homepage = "http://homepage3.nifty.com/salamander/second/projects/mtlparse/";
        description = "parse library using mtl package";
@@ -94360,7 +94669,7 @@ self: {
      mkDerivation {
        pname = "mtlx";
        version = "0.1.6";
-       sha256 = "0s0cniqn1fb7rq14w3wjh7mkzkxpndj1h1wrgssxds6cs3vkk4dn";
+       sha256 = "b69139f7d0cce8d6b57e99071864b3b7cf3feb81920f4e02ce67b96071b40c68";
        libraryHaskellDepends = [ base mtl QuickCheck ];
        description = "Monad transformer library with type indexes, providing 'free' copies";
        license = stdenv.lib.licenses.bsd3;
@@ -94372,7 +94681,7 @@ self: {
      mkDerivation {
        pname = "mtp";
        version = "0.1.1.1";
-       sha256 = "164q7p81c5an4w3pqpfk94rgn0banfs2yp7fhbbckdyb2qymsbww";
+       sha256 = "9c2f5d3d16cbb7c9d682ee5c2fb4b36a01fb3249d35d7c0727561516d03d9898";
        libraryHaskellDepends = [ base filepath unix ];
        librarySystemDepends = [ mtp ];
        jailbreak = true;
@@ -94386,7 +94695,7 @@ self: {
      mkDerivation {
        pname = "mtree";
        version = "0.1";
-       sha256 = "1l4kjrmr5v8pkhf48w0ym6dlrsvaf21p3x5sykq1rxwp821cqglv";
+       sha256 = "9b3ecc824097f71cf0f4baf47183706aeb4c9ba91e70441c9c17ed926b9693d0";
        libraryHaskellDepends = [ base bifunctors ];
        description = "Tree with Meta and Content parameters";
        license = stdenv.lib.licenses.publicDomain;
@@ -94397,7 +94706,7 @@ self: {
      mkDerivation {
        pname = "mucipher";
        version = "0.6.0";
-       sha256 = "0bmdri4bni9whjgz4mxvkk9jbxkscci38l06gk2n5xiwyg1hwg0y";
+       sha256 = "1e3c0ec3f33cf662c57c06503422637af625d39cbb57f29f843c45bb48ccad2e";
        libraryHaskellDepends = [ base ];
        description = "A library to produce simple ciphers for use with lambdabot";
        license = "GPL";
@@ -94411,7 +94720,7 @@ self: {
      mkDerivation {
        pname = "mudbath";
        version = "0.0.3";
-       sha256 = "1bfsgsl09aajxa8ajps63zj348ccr8pswppj0dar5k8mr6nr6n3q";
+       sha256 = "785893adc915cd925503f25eae2fca8c2132e41f465fa990ea52a904a87edaad";
        isLibrary = false;
        isExecutable = true;
        executableHaskellDepends = [
@@ -94431,7 +94740,7 @@ self: {
      mkDerivation {
        pname = "muesli";
        version = "0.1.1.0";
-       sha256 = "0cysqy3g9zgvbzj9gnwlpqk63inkm26dvhhqx8qlzp1lan6f125w";
+       sha256 = "bc88e08c5534dc4f31ea18c2dd8ca8d3c66126be94db97e45ffbfdf486c7da33";
        libraryHaskellDepends = [
          base bytestring cereal containers directory filepath hashable mtl
          psqueues time
@@ -94449,7 +94758,7 @@ self: {
      mkDerivation {
        pname = "mueval";
        version = "0.9.1.1.2";
-       sha256 = "1h8a0lfbpgx9pjsmb0yld4n12z2nia5kkikjq1qqzk4m8rsknk70";
+       sha256 = "e04c3b754695cc8f71c072c6398b8a567c112c69d48355b5bca9bfbb1c050ac1";
        revision = "1";
        editedCabalFile = "5c6cf1e221928e15536f1dfa46942293acf7b470a442c619ef66529b78c59596";
        isLibrary = true;
@@ -94469,7 +94778,7 @@ self: {
      mkDerivation {
        pname = "multext-east-msd";
        version = "0.1.0.4";
-       sha256 = "1if1ip22y7w59lkyshn4ic4p46zrfs4kcdzzjai9l8xbscavgdl6";
+       sha256 = "86b6b715d3ab239aa292ff37368976f91b72098bc442ed274d851f2fc48dc1c5";
        libraryHaskellDepends = [ base ];
        jailbreak = true;
        homepage = "http://github.com/jsnajder/multex-east-msd";
@@ -94484,7 +94793,7 @@ self: {
      mkDerivation {
        pname = "multi-cabal";
        version = "0.1.0.0";
-       sha256 = "0qzphh4pmrdqanv9sjy0ipf3z775xvrvdyagd0291vv1mqkbbz3g";
+       sha256 = "6ffcb526ae61ef9004684ff9b6f3eee59c3fdc8dc04b9db655b8e57a0984f763";
        isLibrary = true;
        isExecutable = true;
        libraryHaskellDepends = [ aeson base filepath mtl ];
@@ -94506,7 +94815,7 @@ self: {
      mkDerivation {
        pname = "multiarg";
        version = "0.30.0.8";
-       sha256 = "18lq0q76a4vx5r28wrxwa3cb2gdx6hv8vylkky07dqccqgxdg5ss";
+       sha256 = "5a97d7fac38ce176809f93fa8d3634bd3db1d850bc678e442e7d13650e0698a2";
        isLibrary = true;
        isExecutable = true;
        libraryHaskellDepends = [ base ];
@@ -94526,7 +94835,7 @@ self: {
      mkDerivation {
        pname = "multifocal";
        version = "0.0.1";
-       sha256 = "0w47ffx8f8hw2a35kxjwi16l9bfgc0k2ac7r844123anmgv2wcfm";
+       sha256 = "d5312ef6ab560d110841f930252660cfad444d885cf65986121c2287ba738770";
        isLibrary = true;
        isExecutable = true;
        libraryHaskellDepends = [
@@ -94552,7 +94861,7 @@ self: {
      mkDerivation {
        pname = "multihash";
        version = "0.1.1";
-       sha256 = "09yjr7whddn60kyn25hzjjls1m5xi87nqzbkrb6vp4hlvmzm0b1g";
+       sha256 = "2f2c507fdd1492bbcdca737d6c0f8abdd4a0a9941f1661fd04c6b606f9c9d227";
        isLibrary = true;
        isExecutable = true;
        libraryHaskellDepends = [
@@ -94574,7 +94883,7 @@ self: {
      mkDerivation {
        pname = "multimap";
        version = "1.2.1";
-       sha256 = "0d3l5q4yvmywl6i9ip96zz0fvhjdh00mfbbniphbjxsi8wlwack3";
+       sha256 = "6332c529475177b9e08d762d5701804dc2edc0ff26dd98a2a1dcd7ed092e7434";
        libraryHaskellDepends = [ base containers ];
        homepage = "http://hub.darcs.net/scravy/multimap";
        description = "A multimap";
@@ -94586,7 +94895,7 @@ self: {
      mkDerivation {
        pname = "multipart";
        version = "0.1.2";
-       sha256 = "0g04jhyw1ib1s7c9bcldyyn4n90qd9x7dmvic4vgq57bgcqgnhz5";
+       sha256 = "e543fb307beb14fc366171d7767a6a18244bacf78db295d8d161c5c03d94043c";
        libraryHaskellDepends = [ base bytestring parsec ];
        homepage = "http://www.github.com/silkapp/multipart";
        description = "HTTP multipart split out of the cgi package";
@@ -94600,7 +94909,7 @@ self: {
      mkDerivation {
        pname = "multipart-names";
        version = "0.0.1";
-       sha256 = "17cw9lg1qi3rm38yh13n6gkb0grld4gc003hz49vdz8bx4gzfqxc";
+       sha256 = "ac63f71fe90bfdb613f97000c01e69343fb0e6337604e8d1a879441c1e4d9c9d";
        libraryHaskellDepends = [ base case-insensitive lens parsec ];
        testHaskellDepends = [
          base HUnit lens test-framework test-framework-hunit
@@ -94617,7 +94926,7 @@ self: {
      mkDerivation {
        pname = "multipass";
        version = "0.1.0.2";
-       sha256 = "0zs5sw9m5r8g9p29knrihqsvihwihr1ca28vb0283k5jik18aifm";
+       sha256 = "d54585c28cb2cc8104581b09c5428691c3b8358631db99c44d0fe55213d7457f";
        libraryHaskellDepends = [
          base binary containers ghc-prim hashable keys math-functions
          newtype unordered-containers
@@ -94634,7 +94943,7 @@ self: {
      mkDerivation {
        pname = "multiplate";
        version = "0.0.2";
-       sha256 = "02pqfkdcv4fn0pmxphg19b3fiazn4hpphfj8xgp77vpy2lczndsw";
+       sha256 = "5c37fb1915feee73eeeb483a782f24f6abe8c64ae1c1dbeb05d691cdda74f80a";
        libraryHaskellDepends = [ base transformers ];
        jailbreak = true;
        homepage = "http://haskell.org/haskellwiki/Multiplate";
@@ -94647,7 +94956,7 @@ self: {
      mkDerivation {
        pname = "multiplate-simplified";
        version = "0.0.0.2";
-       sha256 = "0xzjl3nsm6wgbqd6rjn0bf9jhiw6l6ql5gj5m8xqccv8363i5v2r";
+       sha256 = "59ec1287196833863baa45be42b1a1864728935bc0ca6c1a5e8f9baaeda0f277";
        libraryHaskellDepends = [ base multiplate transformers ];
        jailbreak = true;
        description = "Shorter, more generic functions for Multiplate";
@@ -94660,7 +94969,7 @@ self: {
      mkDerivation {
        pname = "multiplicity";
        version = "0.1.0";
-       sha256 = "1y0v06qnpna8sa0aw24i4s29yc49m3a7d8yrl6xiv1jrgycjcafc";
+       sha256 = "cc2926997f59861dbba1d9a376d4a889309f84269108ae80d248d96bb1011bf8";
        isLibrary = false;
        isExecutable = true;
        executableHaskellDepends = [
@@ -94676,7 +94985,7 @@ self: {
      mkDerivation {
        pname = "multirec";
        version = "0.7.5";
-       sha256 = "164a0rbka606d7d0l2p11j0zry0dlwkymig10wrkvckj7mh5yydz";
+       sha256 = "bf795f603d72b23d3307e1c5ea27a70df8fc810ce10a0ada6906183557068a98";
        libraryHaskellDepends = [ base template-haskell ];
        homepage = "http://www.cs.uu.nl/wiki/GenericProgramming/Multirec";
        description = "Generic programming for families of recursive datatypes";
@@ -94690,7 +94999,7 @@ self: {
      mkDerivation {
        pname = "multirec-alt-deriver";
        version = "0.1.3";
-       sha256 = "0hrzrzmgj1y784dvwiz20y842m4kk9rd9vhbwz8cazafs8gindfc";
+       sha256 = "cc351b1fd24e7dc5d0e70beed4729a9354419007e247be1b41c707f9eacf3f43";
        libraryHaskellDepends = [
          base containers mtl multirec syb template-haskell th-expand-syns
        ];
@@ -94705,7 +95014,7 @@ self: {
      mkDerivation {
        pname = "multirec-binary";
        version = "0.0.1";
-       sha256 = "1cj1rfjqxwc06vr5w12fqbcpjb0fjsphf8vp40sp2naizpvvnmzs";
+       sha256 = "fa57bbf7fd5159713520772307af960e2c79d9c24e045ef23680f18ea5cb41b2";
        libraryHaskellDepends = [ base binary multirec ];
        jailbreak = true;
        description = "Generic Data.Binary instances using MultiRec.";
@@ -94718,7 +95027,7 @@ self: {
      mkDerivation {
        pname = "multiset";
        version = "0.3.0";
-       sha256 = "0wpc2v55q6gwn70nlk2x5xd4dk9a8aw2ivl1gr0xhdp1dnn5dhcb";
+       sha256 = "8bc156ac6de136d8417e81ee28b8422acd465a2f5d4c6ac1b1fc195cca16ec72";
        libraryHaskellDepends = [ base containers ];
        description = "The Data.MultiSet container type";
        license = stdenv.lib.licenses.bsd3;
@@ -94729,7 +95038,7 @@ self: {
      mkDerivation {
        pname = "multiset-comb";
        version = "0.2.4";
-       sha256 = "0j7vxm67aws7dzlmdkvx2aja888jp22qdzz8hgmhvbpcr4p7lz99";
+       sha256 = "297d7a2ec9ecae0deb83e8ff8685b81221a4a4127dcf56e96f4773754cedfb48";
        revision = "1";
        editedCabalFile = "b6ecbed315e0578b665644b8a73ed1e348968e5a93bb1d491fb5a6faf79d7545";
        libraryHaskellDepends = [ base containers transformers ];
@@ -94742,7 +95051,7 @@ self: {
      mkDerivation {
        pname = "multisetrewrite";
        version = "0.6";
-       sha256 = "1chgdikgp70rkzw2k3wy7i276j5vb435vq26yl37lkh0im1bg5ay";
+       sha256 = "5e95b7428d004e7a06f546e05d0659bb4873443c9e8f29f89f199cfb666c0fb2";
        libraryHaskellDepends = [ base haskell98 stm ];
        homepage = "http://sulzmann.blogspot.com/2008/10/multi-set-rewrite-rules-with-guards-and.html";
        description = "Multi-set rewrite rules with guards and a parallel execution scheme";
@@ -94755,7 +95064,7 @@ self: {
      mkDerivation {
        pname = "multistate";
        version = "0.6.2.0";
-       sha256 = "0s8x0gb332724sd3vcp5yimxpbf85kvg327lg3bb77jvy6cfdzvj";
+       sha256 = "72ffe698f15b9eb3d678f488f1f62cc8addb6bf4e5b23d9a26e28831d6031d69";
        isLibrary = true;
        isExecutable = true;
        libraryHaskellDepends = [ base mtl tagged transformers ];
@@ -94773,7 +95082,7 @@ self: {
      mkDerivation {
        pname = "muon";
        version = "0.1.0.8";
-       sha256 = "0s11xvhawwrcr31f0khp0q6fimwjps12n992z35ldnh0kk3dmk9z";
+       sha256 = "3fcddac69c00da46cbf822252b82be92d7e80c06174ee0c2c82c73aee0ee2168";
        isLibrary = false;
        isExecutable = true;
        executableHaskellDepends = [
@@ -94793,7 +95102,7 @@ self: {
      mkDerivation {
        pname = "murder";
        version = "1.3.4";
-       sha256 = "0pr77j3br8knk26iknsa6hy076bx2bb6jgii3v6aqhv40ykcrv15";
+       sha256 = "25eccca6076443accc1e313e69d6127d99033c344adb198d9876a2bc863c275f";
        libraryHaskellDepends = [
          AspectAG base containers HList ListLike template-haskell TTTAS
          uu-parsinglib uulib
@@ -94810,7 +95119,7 @@ self: {
      mkDerivation {
        pname = "murmur-hash";
        version = "0.1.0.8";
-       sha256 = "01isk1gy1x75zksdmddcpp7mnx69wb96g1xv8gl3anvx9bfg9fbc";
+       sha256 = "6cb9f4dc4a7d5b35e843bb8767d2e2c9745bcfbdacb5daf4fce5f4e05f983a06";
        libraryHaskellDepends = [ base bytestring ];
        homepage = "http://github.com/nominolo/murmur-hash";
        description = "MurmurHash2 implementation for Haskell";
@@ -94825,7 +95134,7 @@ self: {
      mkDerivation {
        pname = "murmur3";
        version = "1.0.0";
-       sha256 = "1rdnfy37dmmrqpapdv9h22ki94mxrz1xdk5ibcj833q35868kjmq";
+       sha256 = "b8ca890c2a038f81245bb1ccd6c3cfbd9214a71030ed76d5c5b9d6768677b6e5";
        libraryHaskellDepends = [ base binary bytestring ];
        testHaskellDepends = [
          base base16-bytestring bytestring HUnit QuickCheck test-framework
@@ -94841,7 +95150,7 @@ self: {
      mkDerivation {
        pname = "murmurhash3";
        version = "1.0";
-       sha256 = "1hz6rf1qrzgixx19bn9hnp07jfb61wnrjq5bgqnd3px569afwdb2";
+       sha256 = "6235ee5432a5dfd12c7eab60992d0f663979c0b530d99542eff1fd8c83cbe6c3";
        libraryHaskellDepends = [ haskell2010 ];
        homepage = "https://github.com/niswegmann/murmurhash3";
        description = "32-bit non-cryptographic hashing";
@@ -94854,7 +95163,7 @@ self: {
      mkDerivation {
        pname = "music-articulation";
        version = "1.9.0";
-       sha256 = "0cxbhk25kn3hpkmb6h0brcf03yyi6kaz3i3l3lv2rzgfxv14a2pg";
+       sha256 = "ef0a45c2eeeefd2c361d74c4f1d534d1fb011ccb0b40b3eabc70d859c484ab33";
        libraryHaskellDepends = [ average base semigroups ];
        description = "Abstract representation of musical articulation";
        license = stdenv.lib.licenses.bsd3;
@@ -94865,7 +95174,7 @@ self: {
      mkDerivation {
        pname = "music-diatonic";
        version = "0.1.1";
-       sha256 = "19sflj0b5qslclqjwyacgc2pdplwr3mimmhf8ka7bbs70r557wbs";
+       sha256 = "7af1534a0647af75d4440ed61aebc89cde76057b4c792e316554e3b280a44ea7";
        libraryHaskellDepends = [ base ];
        description = "Implementation of basic western musical theory objects";
        license = stdenv.lib.licenses.bsd3;
@@ -94877,7 +95186,7 @@ self: {
      mkDerivation {
        pname = "music-dynamics";
        version = "1.9.0";
-       sha256 = "12a11qrdy4p0bczpg2zp8yqw4wdmgfhq5z9ffajlsib2xcs6y8s4";
+       sha256 = "44236f34eb62454da5722efd82a17bb571c2b147f78b773f5be012df320e4189";
        libraryHaskellDepends = [
          average base music-dynamics-literal semigroups
        ];
@@ -94890,7 +95199,7 @@ self: {
      mkDerivation {
        pname = "music-dynamics-literal";
        version = "1.9.0";
-       sha256 = "19bql45aqjfkhvpkfbvfcsc8p1mzg93n966r1yv5rwps6s2x86d5";
+       sha256 = "a519d48536faf25cb60fd99864477abf868b98666e2f37ef86d349ac0aa178a5";
        libraryHaskellDepends = [ base semigroups ];
        description = "Overloaded dynamics literals";
        license = stdenv.lib.licenses.bsd3;
@@ -94903,7 +95212,7 @@ self: {
      mkDerivation {
        pname = "music-graphics";
        version = "1.8.1";
-       sha256 = "1764qmb8pafddsclr5gl5ibqpi9wvwa96idn6iqx8d3jbpqc4fam";
+       sha256 = "5539c2f05d7234d47134b6459314df3cc58b572cf4954c996ecda98b56c5c49c";
        libraryHaskellDepends = [
          aeson base blaze-svg bytestring lens music-pitch music-preludes
          music-score process
@@ -94923,7 +95232,7 @@ self: {
      mkDerivation {
        pname = "music-parts";
        version = "1.9.0";
-       sha256 = "1kiz968kcwcyczxg5gl40c7bwgkn86l7qi0ak8p68bm4rmsw9id4";
+       sha256 = "a4c5c475cda42e642e9a0a447ca841763ebe0e0384bef2fa679e713691493fce";
        libraryHaskellDepends = [
          adjunctions aeson base bytestring cassava containers data-default
          lens monadplus music-dynamics music-pitch roman-numerals semigroups
@@ -94942,7 +95251,7 @@ self: {
      mkDerivation {
        pname = "music-pitch";
        version = "1.9.0";
-       sha256 = "1w5b62il0n8147a3sdvx9ndykfp56nf0kabwpw8khd29cmpff0bz";
+       sha256 = "7f01e76e6549343811bf7ca9099c35e5bae99b4d7d373dd421015940a330abf0";
        libraryHaskellDepends = [
          aeson base containers data-interval lens music-pitch-literal nats
          positive semigroups type-unary vector-space vector-space-points
@@ -94956,7 +95265,7 @@ self: {
      mkDerivation {
        pname = "music-pitch-literal";
        version = "1.9.0";
-       sha256 = "0vsvw7c29qvi69z9gy2zzq9bpajmjd5vs1kll7jw0qbsh28jsqql";
+       sha256 = "14632d91807a61c0e5a17406bd4b9355aabb12fe5ff8977e3271e324d8e15b6f";
        libraryHaskellDepends = [ base semigroups ];
        description = "Overloaded pitch literals";
        license = stdenv.lib.licenses.bsd3;
@@ -94973,7 +95282,7 @@ self: {
      mkDerivation {
        pname = "music-preludes";
        version = "1.9.0";
-       sha256 = "1fqw3rz0zrwa5a0l639b0bd6qxiq4zmqcrf0vkrgh03n65r2901q";
+       sha256 = "38802472317600f8f2dcc06586eb2738766cda022b0d43812a8ae70f7e1e1cbb";
        isLibrary = true;
        isExecutable = true;
        libraryHaskellDepends = [
@@ -95001,7 +95310,7 @@ self: {
      mkDerivation {
        pname = "music-score";
        version = "1.9.0";
-       sha256 = "10cysii04njrjd0qx14fwsjn91ycvfxcs3kvwnb8j24v3svcha10";
+       sha256 = "2028c8b61e9b088996e57b0ecdbadbcc8764a5e68e848e4193595a0262d49e81";
        libraryHaskellDepends = [
          adjunctions aeson average base base-orphans bifunctors colour
          comonad containers contravariant distributive HCodecs lens lilypond
@@ -95024,7 +95333,7 @@ self: {
      mkDerivation {
        pname = "music-sibelius";
        version = "1.9.0";
-       sha256 = "1yahz8z81ggcg303i2syzf6bsxq8dmzzzqs3fj89r5kq766275kz";
+       sha256 = "7f96238c3978969c907443e3ff7f6d0877bd8cfb5e8b38c078ecbd803efa50f9";
        libraryHaskellDepends = [
          aeson base bytestring lens monadplus music-articulation
          music-dynamics music-parts music-pitch music-pitch-literal
@@ -95043,7 +95352,7 @@ self: {
      mkDerivation {
        pname = "music-suite";
        version = "1.9.0";
-       sha256 = "1nss12cad2vjq2whz5kxsr1r63iwc4pnza0nnf2h2zai3gxzsnn6";
+       sha256 = "c65afdfb1b517d0185b316a86f2f613c0e9343d67d960fb9c0728ba698085adb";
        libraryHaskellDepends = [
          abcnotation lilypond music-articulation music-dynamics
          music-dynamics-literal music-parts music-pitch music-pitch-literal
@@ -95061,7 +95370,7 @@ self: {
      mkDerivation {
        pname = "music-util";
        version = "0.17";
-       sha256 = "0pv6mwdrk2kz3lr8r3jkc368zch46w4rn5dmqbjqm0ykfw1n3bqf";
+       sha256 = "0eaf610377d3838ae5c2b5159b093704b28fcc60538e8c321d7f8a991baf665f";
        isLibrary = false;
        isExecutable = true;
        executableHaskellDepends = [
@@ -95083,7 +95392,7 @@ self: {
      mkDerivation {
        pname = "musicbrainz-email";
        version = "1.0.0.0";
-       sha256 = "10salrdl4vfdy3x26564i8kdv6lx8py697v5n8q9ywqsd05dcrv2";
+       sha256 = "6267d60a681a739f30b2659f64fc459d9add268ac41423faf0cd6d425ba64a83";
        isLibrary = true;
        isExecutable = true;
        libraryHaskellDepends = [
@@ -95114,7 +95423,7 @@ self: {
      mkDerivation {
        pname = "musicxml";
        version = "0.1.2";
-       sha256 = "0sn8gzymf6xpdksd7v2xyb4y2iks2l09hyw0rch109lgrnsy5gp8";
+       sha256 = "e8bee2b5cd8f261020cb807b9800157a46e1c9f25decd3f46cb71b57fd7fc86a";
        libraryHaskellDepends = [
          base containers directory HaXml old-time pretty
        ];
@@ -95133,7 +95442,7 @@ self: {
      mkDerivation {
        pname = "musicxml2";
        version = "1.9.0";
-       sha256 = "07axlifkqf0dcqnxfb62x829ygc2y7didsh60x081zw429853fy8";
+       sha256 = "c8bb51501284ff80400706ea16dbf1823d9f04eac22cd72d660d383c5da45d1d";
        libraryHaskellDepends = [
          base data-default music-dynamics-literal music-pitch-literal nats
          reverse-apply semigroups type-unary xml
@@ -95150,7 +95459,7 @@ self: {
      mkDerivation {
        pname = "mustache-haskell";
        version = "0.1.0.5";
-       sha256 = "0mkj5ngcblm949wkxiq2qck3zak93r5zipppwgis59yg01cp79v2";
+       sha256 = "62a7735900cfa7a2e3e3f7def84b1e69aa3f26c302c73e7922a9d2c59e2d7256";
        isLibrary = true;
        isExecutable = true;
        libraryHaskellDepends = [
@@ -95175,7 +95484,7 @@ self: {
      mkDerivation {
        pname = "mustache2hs";
        version = "0.3";
-       sha256 = "1m15q6dy3hbbf5q302gw3y2znxf2mfz9pwbdyawg8bqiw81zahis";
+       sha256 = "3a42f503e2112ff4b8f26df19bbeabc275fb851ffc093070716bc1e19bc125d4";
        isLibrary = false;
        isExecutable = true;
        executableHaskellDepends = [
@@ -95195,7 +95504,7 @@ self: {
      mkDerivation {
        pname = "mutable-containers";
        version = "0.3.0";
-       sha256 = "1xsz214z5z1qrl5xy5gyq97bsh8b1li3kaz7cp6zm955bz43rv6c";
+       sha256 = "ccec3cc85fa5a4facd65e7ab39220d0b41bd4ec2fe15df0bcd38fcf249105ff7";
        libraryHaskellDepends = [
          base containers ghc-prim mono-traversable primitive vector
        ];
@@ -95214,7 +95523,7 @@ self: {
      mkDerivation {
        pname = "mutable-iter";
        version = "0.6.1";
-       sha256 = "08fqfkzb6b0pzzffkfcwigcm0s4hgadh7jl4pg6smjcyfjz9572f";
+       sha256 = "4e9c92be749ec9aacdbb84ca039b7a906850d98b9cb9e9dcff172cb3fe74d821";
        libraryHaskellDepends = [
          base iteratee MonadCatchIO-transformers transformers vector
        ];
@@ -95232,7 +95541,7 @@ self: {
      mkDerivation {
        pname = "mute-unmute";
        version = "0.2.0.0";
-       sha256 = "0nd1c4l2z7bflnghz7bbbahpfl2jj9mygpygxc7028axrrxj09af";
+       sha256 = "4e25207bce5d21010eebcfdfe76b92525077a15a6b9d0f9fa56e9d2f2861a159";
        isLibrary = false;
        isExecutable = true;
        executableHaskellDepends = [
@@ -95252,7 +95561,7 @@ self: {
      mkDerivation {
        pname = "mvc";
        version = "1.1.0";
-       sha256 = "115cg7xlkk0zj3qdhwm35397vbp1s28h3j0ipw2a9i9ap16d7x1i";
+       sha256 = "31f4d34cb82ac5a404bf11c80191d0e1ae7dd228a372d8f0901fcc49fb79ac84";
        libraryHaskellDepends = [
          async base contravariant foldl managed mmorph pipes
          pipes-concurrency transformers
@@ -95266,7 +95575,7 @@ self: {
      mkDerivation {
        pname = "mvc-updates";
        version = "1.2.0";
-       sha256 = "125bwc79qcmwb8dn8yqkrxlbqf3vwdzhjx66c69j2jbrp70061n6";
+       sha256 = "c60603c0b97949219361c674097fe37b38bc68cf137b641b5abc329c0ee3ab88";
        libraryHaskellDepends = [ async base foldl mvc ];
        jailbreak = true;
        description = "Concurrent and combinable updates";
@@ -95282,7 +95591,7 @@ self: {
      mkDerivation {
        pname = "mvclient";
        version = "0.4";
-       sha256 = "12ckzfb6wwa3865isxnzw7xmwh9f43ali0ab5mal6brs33zz0z53";
+       sha256 = "a37cf0ff183a2f43552d4b8148d5202e415efbe1df761d8b4143716e96fb9389";
        libraryHaskellDepends = [
          base base-unicode-symbols binary bytestring containers
          control-event Crypto data-binary-ieee754 hexpat http-enumerator
@@ -95302,7 +95611,7 @@ self: {
      mkDerivation {
        pname = "mwc-random";
        version = "0.13.3.2";
-       sha256 = "01jqmq52knlwskgyx7940c81dmgdivrj0sbi2h6l0ccbxiaf7c9c";
+       sha256 = "2cb1e354ec8b31400d14716920f38eedd5161003249deedfd49cda290aae5806";
        libraryHaskellDepends = [ base primitive time vector ];
        testHaskellDepends = [
          base HUnit QuickCheck statistics test-framework
@@ -95320,7 +95629,7 @@ self: {
      mkDerivation {
        pname = "mwc-random-monad";
        version = "0.7.3.1";
-       sha256 = "0h4ljwwhqg4yy513lqk2ix0m9q2hmk276hgfrc6n3ja6wqbpkwyh";
+       sha256 = "d0f37917e646c9610dcbee4173c4ac50e054418f62623a42f19e3c0c39979440";
        libraryHaskellDepends = [
          base monad-primitive mwc-random primitive transformers vector
        ];
@@ -95337,7 +95646,7 @@ self: {
      mkDerivation {
        pname = "myTestlll";
        version = "1.0.0";
-       sha256 = "1rd3pxc20xwb3j0q9ckygy59mks8p38vzmi4wfg8zp1dq92jmhy0";
+       sha256 = "c0c32a45c22ddc8f9ee324d6bfd1b848cf9a8a7f7eb284811c8b772058bfa3e5";
        revision = "4";
        editedCabalFile = "e554b67c3f8efd73e028328341e3b535dc4898b3d476524a40c236c4c2871e43";
        libraryHaskellDepends = [
@@ -95360,7 +95669,7 @@ self: {
      mkDerivation {
        pname = "mybitcoin-sci";
        version = "0.3";
-       sha256 = "1iy84z13i98wbkman7yp2y2821yzf3xxpcy10rh9bdskjijvgjnq";
+       sha256 = "d8cab7659453b7956006c1b3dbfb70df07818417d71fabea5c1ca538c227c8c7";
        libraryHaskellDepends = [
          base cgi curl directory mtl process split
        ];
@@ -95376,7 +95685,7 @@ self: {
      mkDerivation {
        pname = "myo";
        version = "0.1.0.0";
-       sha256 = "0sn3ic3h94ff57igs61l2cq82y6xxz87qflm8dykwwy721swq1qn";
+       sha256 = "1607cc7510c7733e7d43953a7cd0efdd788130133418fde229ce9104078bc36a";
        isLibrary = true;
        isExecutable = true;
        libraryHaskellDepends = [
@@ -95398,7 +95707,7 @@ self: {
      mkDerivation {
        pname = "mysnapsession";
        version = "0.4.1";
-       sha256 = "0871nq9nhpslni5kfldwiswhvpk1aajj7ikyiy9ikmcq16fb1z9m";
+       sha256 = "35fdb09c0998d519938f7ec623a55261de0db98ebc51374bb4545f6813b6e120";
        libraryHaskellDepends = [
          base bytestring cereal clientsession containers mtl random
          regex-posix snap snap-core time
@@ -95416,7 +95725,7 @@ self: {
      mkDerivation {
        pname = "mysnapsession-example";
        version = "0.4";
-       sha256 = "0lxzn8fn97f1j3fx97f46m16y25w7m1w84l59r75xisr662gc9lz";
+       sha256 = "9f26f6843159c75e4e4e8512c4433dbc086f4235c49dd4dd90c19d641db2bf53";
        isLibrary = false;
        isExecutable = true;
        executableHaskellDepends = [
@@ -95434,7 +95743,7 @@ self: {
      mkDerivation {
        pname = "mysql";
        version = "0.1.1.8";
-       sha256 = "115xz4khg4klrgjvv9dy83pv197b4y1zgw6fbpv8j88yr3qjmw4h";
+       sha256 = "90f02af1c81e2189f65dcef0f78327eba4b0ef40bea5bde5cb74920727f9bd84";
        libraryHaskellDepends = [ base bytestring containers ];
        librarySystemDepends = [ mysql ];
        homepage = "https://github.com/bos/mysql";
@@ -95449,7 +95758,7 @@ self: {
      mkDerivation {
        pname = "mysql-effect";
        version = "0.2.0.3";
-       sha256 = "11fpsh4w2zlqdqhk5snb276pcbx4p9g1igs94fympa9asfr2rxm3";
+       sha256 = "a3f62cb2d32aa95bbd2349bf185ebaa42f76cd11cbea32216e987ec109d4d785";
        revision = "1";
        editedCabalFile = "d4474591079b806b8e26d102824d46c7e4c239afb3479ea8d1e8cbd39f015718";
        libraryHaskellDepends = [
@@ -95469,7 +95778,7 @@ self: {
      mkDerivation {
        pname = "mysql-simple";
        version = "0.2.2.5";
-       sha256 = "132igmgrgkpc0g9063d593ha3iv40k5dd017nlb07sz0qs9hi8w6";
+       sha256 = "86a30893c6e0eb0316b52780d6ca0464c7a1e048a50d03d203ecce975f7d518c";
        libraryHaskellDepends = [
          attoparsec base base16-bytestring blaze-builder blaze-textual
          bytestring mysql old-locale pcre-light text time
@@ -95486,7 +95795,7 @@ self: {
      mkDerivation {
        pname = "mysql-simple-quasi";
        version = "1.0.0.2";
-       sha256 = "1ggqqjn83rx23qk7lzrcgj1arjhmhi85xfl7d2pz27rrjx2ywpn8";
+       sha256 = "c85eee4597391ff1af6887ba5e508415caac827c2c7f7a261ea2e781acc4f8bd";
        libraryHaskellDepends = [
          base haskell-src-meta mysql-simple template-haskell
        ];
@@ -95502,7 +95811,7 @@ self: {
      mkDerivation {
        pname = "mysql-simple-typed";
        version = "0.1.1.2";
-       sha256 = "19wnvmrb523n8xl5cp9kypcqcrs0xs8pwdk771y1bdin5ds9j095";
+       sha256 = "250199742b36b6157c3867367e91ee406786d9f5335d5668477688b272dd96a7";
        libraryHaskellDepends = [
          base mysql mysql-simple template-haskell typedquery utf8-string
        ];
@@ -95517,7 +95826,7 @@ self: {
      mkDerivation {
        pname = "mzv";
        version = "0.1.0.2";
-       sha256 = "044x87jzyqsg5npp3s0mncgcl0gv26h6hzhc7bbgjja95x16ma2l";
+       sha256 = "54a86a422f4949f9d63a0c7e68a011fb01ca1eb315e871af2d4f63ffe5419d10";
        libraryHaskellDepends = [ base transformers ];
        jailbreak = true;
        homepage = "http://github.com/ifigueroap/mzv";
@@ -95531,7 +95840,7 @@ self: {
      mkDerivation {
        pname = "n-m";
        version = "0.0.1";
-       sha256 = "189ybl8fb70cf24zhnjcmgrgkshrf2ziacklg9ixgvnbdp3abb7m";
+       sha256 = "f5aca5c66dcbeed7637a743215bf7019eaf9f2ab4c5af889700c9ce5105d3ea1";
        isLibrary = true;
        isExecutable = true;
        libraryHaskellDepends = [ base ];
@@ -95547,7 +95856,7 @@ self: {
      mkDerivation {
        pname = "nagios-check";
        version = "0.3.1";
-       sha256 = "17ww3n2y6cmjc3n05cra43csk60sm5s07q2mn3zq1sjiiq2cw82c";
+       sha256 = "4c20ce048e51ea80ffb055e00374a91a98a9d9202ab302ec60b232e3851d9c9f";
        libraryHaskellDepends = [
          base bifunctors exceptions mtl nagios-perfdata text
        ];
@@ -95564,7 +95873,7 @@ self: {
      mkDerivation {
        pname = "nagios-perfdata";
        version = "0.2.2";
-       sha256 = "159m45fvxgdabh7n24bkmg2901y3792afcrccqna1in3ha9vxd22";
+       sha256 = "42b4be9382c3c6a02c662c33a7443ac30790c4ab7311610f5caabdbe5d213595";
        libraryHaskellDepends = [
          attoparsec base bifunctors bytestring containers mtl
        ];
@@ -95584,7 +95893,7 @@ self: {
      mkDerivation {
        pname = "nagios-plugin-ekg";
        version = "0.1.1.0";
-       sha256 = "1rk6sphxn93kmayjs0y386g1llhgbw8jpwhfkhlrbv9c395gxkrh";
+       sha256 = "30cffe4a1a2ced95299c0ef22b115f0f521a9e41c3032dbdaa7324dbe1d566e6";
        isLibrary = true;
        isExecutable = true;
        libraryHaskellDepends = [
@@ -95608,7 +95917,7 @@ self: {
      mkDerivation {
        pname = "named-formlet";
        version = "0.2";
-       sha256 = "0wpjxn03cnxnn5x1706byl9d1129g9p1vkl1a1v9qw0afgzlj8y7";
+       sha256 = "c72349ff730a709c765081ce1d6e7a4984d012f5cb80137ab1b65b3680edf272";
        libraryHaskellDepends = [
          base blaze-html bytestring containers mtl text transformers
        ];
@@ -95621,7 +95930,7 @@ self: {
      mkDerivation {
        pname = "named-lock";
        version = "0.1";
-       sha256 = "1db12f2q395yk6pwz5gnb2q0kf4s868z8d1vvwa7vngnfc1h924i";
+       sha256 = "9188040373f6d97d14df3b34f491419ab809b058f695cfaf99bea481851361b5";
        libraryHaskellDepends = [ base containers ];
        jailbreak = true;
        homepage = "http://github.com/nominolo/named-lock";
@@ -95635,7 +95944,7 @@ self: {
      mkDerivation {
        pname = "named-records";
        version = "0.5";
-       sha256 = "0ykcmmnns63zjfd00kd9941c33l19n9c5b5xkin4n7r9v0qvirwr";
+       sha256 = "99e7b831d8291f4b6c9cbdacc2924d818ec10249a94d009a937f186d6dad6c7a";
        libraryHaskellDepends = [ base binary names template-haskell ];
        description = "Flexible records with named fields";
        license = stdenv.lib.licenses.mit;
@@ -95648,7 +95957,7 @@ self: {
      mkDerivation {
        pname = "namelist";
        version = "0.1.0";
-       sha256 = "0sfiqd1dh3frzwnqz4fjh0wg8m55cprqw8ywvcaszrp5gq3mj74s";
+       sha256 = "9a1c59077ee5e6af15dbdc238ef365a554f43880d2918f2dffd90dd842c3d169";
        libraryHaskellDepends = [
          base case-insensitive data-default-class parsec
        ];
@@ -95665,7 +95974,7 @@ self: {
      mkDerivation {
        pname = "names";
        version = "0.3.1";
-       sha256 = "0sjjp90zfrkjavj8fqyscnvc9d72mkvv8f7ajd47jba92mhwzr5g";
+       sha256 = "afe4cf6115492d794893ea38b4f7ace2b4c4b665da6387e4567266f741ba526a";
        libraryHaskellDepends = [ base template-haskell ];
        description = "Type level names";
        license = stdenv.lib.licenses.mit;
@@ -95676,7 +95985,7 @@ self: {
      mkDerivation {
        pname = "names-th";
        version = "0.1.0.1";
-       sha256 = "1bqbh6751lmiiwvdvry796lzzbjkk8x1lhylkh61l6ycdib2qxjq";
+       sha256 = "58762c566ccc1b1a0c9cd4431a3a9a53aeffa949c7e7dd368fb1d2508e810baf";
        libraryHaskellDepends = [ base containers template-haskell ];
        homepage = "http://khibino.github.io/haskell-relational-record/";
        description = "Manipulate name strings for TH";
@@ -95688,7 +95997,7 @@ self: {
      mkDerivation {
        pname = "nano-cryptr";
        version = "0.1.1.3";
-       sha256 = "1pqwzl8l48c4q83jhjj11jd3kwwa0ail2c6kv3k38kig9yvj7ff8";
+       sha256 = "c8b923b74f2f4e34e6d8d33041a3028af3399a0c414a2807c284214211fd1cdf";
        libraryHaskellDepends = [ base bytestring ];
        homepage = "http://github.com/chowells79/nano-cryptr";
        description = "A threadsafe binding to glibc's crypt_r function";
@@ -95701,7 +96010,7 @@ self: {
      mkDerivation {
        pname = "nano-hmac";
        version = "0.2.0";
-       sha256 = "0rrwa1c3mval1jm4siqyx1vk14ibifya62hni13cimcdafj35fnq";
+       sha256 = "d8ba32a4538dd5c84688160aa3bc8b2b923077e81e474daa0c54ed3a58503c67";
        libraryHaskellDepends = [ base bytestring ];
        librarySystemDepends = [ openssl ];
        homepage = "http://www.jasani.org/search/label/nano-hmac";
@@ -95715,7 +96024,7 @@ self: {
      mkDerivation {
        pname = "nano-md5";
        version = "0.1.2";
-       sha256 = "18db3y76w0kv2m7h3lrqxcag4lc7519b2j80113g6hhm1wxkpabk";
+       sha256 = "73a93b3b0f1542f346080049b152288751f214eb38d3014f157b026e8e1faba1";
        libraryHaskellDepends = [ base bytestring ];
        librarySystemDepends = [ openssl ];
        homepage = "http://code.haskell.org/~dons/code/nano-md5";
@@ -95731,7 +96040,7 @@ self: {
      mkDerivation {
        pname = "nanoAgda";
        version = "1.0.0";
-       sha256 = "034mwssj296xn7j123sqvfl9rv1bwnj1v5sw5l34481dk5zsi9sm";
+       sha256 = "55a7a87f992d2042062d5c971da4e52bec9ca8db580f11e4b1dd2421b5e6950c";
        isLibrary = false;
        isExecutable = true;
        executableHaskellDepends = [
@@ -95748,7 +96057,7 @@ self: {
      mkDerivation {
        pname = "nanocurses";
        version = "1.5.2";
-       sha256 = "04kgf3vvjdx6d1fmfzp0xy5x42zlg0ij59ayi1zhz8hkwsfn5g1m";
+       sha256 = "35bc629de613a20f7f885ea5222378f40bd28befe07e575d68a637b9f7706f12";
        libraryHaskellDepends = [ base bytestring unix ];
        librarySystemDepends = [ ncurses ];
        homepage = "http://www.cse.unsw.edu.au/~dons/hmp3.html";
@@ -95762,7 +96071,7 @@ self: {
      mkDerivation {
        pname = "nanomsg";
        version = "0.1.1";
-       sha256 = "06jb8s3jxjiz7r6dn8xx33xqd76f2r5q1mshsz41z4q0khf4wdp3";
+       sha256 = "e3364e1c9c00931fc8d750d7804b16ce9c86fb18bd23db4c3e3fca2e87464b1a";
        libraryHaskellDepends = [ base bytestring ];
        librarySystemDepends = [ nanomsg ];
        jailbreak = true;
@@ -95777,7 +96086,7 @@ self: {
      mkDerivation {
        pname = "nanomsg-haskell";
        version = "0.2.2";
-       sha256 = "1p4d0qdyqfg4qidcdcddjnyw4x2q8551ka6bsryz9b6dpj6kywch";
+       sha256 = "90713f8dbccdacf47dd6cba8194a415874c2bd95adb1c65ac4e439ec1b068ddc";
        libraryHaskellDepends = [ base binary bytestring ];
        librarySystemDepends = [ nanomsg ];
        testHaskellDepends = [
@@ -95795,7 +96104,7 @@ self: {
      mkDerivation {
        pname = "nanoparsec";
        version = "0.1.1";
-       sha256 = "00ghdzkzshk24g7v42hq7zq0dxsq8vjpkslj41dxdnx0zizwbn3m";
+       sha256 = "75d8c57ffca0dbd65b2092ea79e54658f706f03f180ab2cf236242fde76ff001";
        libraryHaskellDepends = [ base bytestring ListLike ];
        jailbreak = true;
        description = "An implementation of attoparsec-like parser around list-like";
@@ -95807,7 +96116,7 @@ self: {
      mkDerivation {
        pname = "nanospec";
        version = "0.2.1";
-       sha256 = "0jq2l1lmy4hcl6r975xcg86xr1y7jfxr3qn27ibsmjbzlnxdkjyv";
+       sha256 = "dbcbd9baa57fc9aa573cc2e291bb93c787dc0d7aac9793b2a10c125f69a0024b";
        libraryHaskellDepends = [ base ];
        testHaskellDepends = [ base hspec silently ];
        description = "A lightweight implementation of a subset of Hspec's API";
@@ -95819,7 +96128,7 @@ self: {
      mkDerivation {
        pname = "narc";
        version = "0.1.3";
-       sha256 = "1ng1rzj1lf6h9g3pk8gsz05bnck72rp5j62iwn82vlcw8pyk0fsc";
+       sha256 = "4c3b30fd459cd12d90e55118596e166732bb0af8faa179c74bd0381ae4cfe1d9";
        libraryHaskellDepends = [ base HDBC HUnit mtl QuickCheck random ];
        homepage = "http://ezrakilty.net/projects/narc";
        description = "Query SQL databases using Nested Relational Calculus embedded in Haskell";
@@ -95832,7 +96141,7 @@ self: {
      mkDerivation {
        pname = "nat";
        version = "0.3";
-       sha256 = "1v43c1dr72qn8mymnwcq6an8sqxjaxhac037k4gbv8z8bg18zmf5";
+       sha256 = "c5d58fc25be8a3bd1e996700a66057b2638dac3298715b7d45168b935b6083ec";
        libraryHaskellDepends = [ base ];
        description = "Lazy binary natural numbers";
        license = stdenv.lib.licenses.bsd3;
@@ -95845,7 +96154,7 @@ self: {
      mkDerivation {
        pname = "nationstates";
        version = "0.2.0.0";
-       sha256 = "07rs7c5pvq6x8icg5pzk613vazcnnl3rfrcsf3zw6i8gaxh0dq48";
+       sha256 = "88e00660570f45c3ff709a659707b5967db54730f3dff25844dde07d0b3b3a1f";
        libraryHaskellDepends = [
          base bytestring clock containers http-client http-client-tls
          http-types multiset transformers xml
@@ -95860,7 +96169,7 @@ self: {
      mkDerivation {
        pname = "nats";
        version = "1";
-       sha256 = "0r6s8l4s0yq3x2crrkv0b8zac13magfasr9v8hnq6rn1icsfhic0";
+       sha256 = "8045e8348bc166832d443b65addc537504a63e5a60cf9c99e8037ba00945da64";
        homepage = "http://github.com/ekmett/nats/";
        description = "Natural numbers";
        license = stdenv.lib.licenses.bsd3;
@@ -95873,7 +96182,7 @@ self: {
      mkDerivation {
        pname = "nats-queue";
        version = "0.1.2.0";
-       sha256 = "0gqgqf87dzja0yhfpazqbdpvia1jisarhnph9bxvb3mfl4is9sgf";
+       sha256 = "eee9a423a1ae8eb5fb4af05a98958e32a8b86f5bf8abeba0074afe7690c30f3f";
        libraryHaskellDepends = [
          aeson async base bytestring containers dequeue network network-uri
          random text
@@ -95894,7 +96203,7 @@ self: {
      mkDerivation {
        pname = "natural-number";
        version = "1.0";
-       sha256 = "1n8qgjbi4c50pwynlya4bjxd6lpwj00257drqk04mlrr3nw3gp5x";
+       sha256 = "bddc37b81d39d34ac0c4b99d220090fc52d3ba5c44796a3dbfa03012977c18d9";
        libraryHaskellDepends = [
          base type-equality type-level-natural-number
          type-level-natural-number-induction
@@ -95910,7 +96219,7 @@ self: {
      mkDerivation {
        pname = "natural-numbers";
        version = "0.1.2.0";
-       sha256 = "0cj9lnnlvry425bkixqv9fh5b9xhy7dmwcqsxprj6lamccvxspwn";
+       sha256 = "965fdd3763555123f3ed1a335edbf1b0a755a04b1bf7385711c4e74dada54932";
        libraryHaskellDepends = [ base ];
        homepage = "http://darcs.wolfgang.jeltsch.info/haskell/natural-numbers";
        description = "Natural numbers";
@@ -95922,7 +96231,7 @@ self: {
      mkDerivation {
        pname = "natural-sort";
        version = "0.1.2";
-       sha256 = "0l3bkbqzrlpdhzazqqlx71ah0m13ypa0981qvw3sn9q8d0sbfwkv";
+       sha256 = "7b72b734680827ab07df38a004d4f523540055389d62fcd587edd2fcf19a6b50";
        libraryHaskellDepends = [ base bytestring parsec text ];
        homepage = "https://john-millikin.com/software/natural-sort/";
        description = "User-friendly text collation";
@@ -95936,7 +96245,7 @@ self: {
      mkDerivation {
        pname = "natural-transformation";
        version = "0.2";
-       sha256 = "1fxgbjf74kdag42hscplc5sn63z0idz2z2yykk1jz4zp71wa0wdp";
+       sha256 = "b771a07838f7932fc39cde8b2f7e8be00f637561f4320d0579aa4d729c5cafbb";
        libraryHaskellDepends = [ base ];
        testHaskellDepends = [
          base containers quickcheck-instances tasty tasty-quickcheck
@@ -95951,7 +96260,7 @@ self: {
      mkDerivation {
        pname = "naturalcomp";
        version = "0.0.3";
-       sha256 = "1l594lkd3yb52lhh0raygvk3jlzwkcc2pmcqjmg02dmd6j6mw42x";
+       sha256 = "5d105e8d34ad36015e9598d52b189bfc5339e67e5e6500211565f9d12625a9d0";
        libraryHaskellDepends = [ base text utf8-string ];
        homepage = "not yet available";
        description = "Natural-order string comparison";
@@ -95963,7 +96272,7 @@ self: {
      mkDerivation {
        pname = "naturals";
        version = "0.2.0.2";
-       sha256 = "1ay291833dcah411zc3r4qjilaw8x13ljlnb5z40d1s7784djm16";
+       sha256 = "2654d9083a478706c82fcb524947e8882b1a252679b01f02818ab5315048c2ab";
        libraryHaskellDepends = [ base ];
        homepage = "frigidcode.com";
        description = "Constructors and related functions for natural numbers";
@@ -95978,7 +96287,7 @@ self: {
      mkDerivation {
        pname = "nbt";
        version = "0.5.1";
-       sha256 = "08184rn4mwxd2m2fnqvja23jpkzlkvb8d2vn8i4rqcil136wb6q0";
+       sha256 = "009bc5cd0834329c4944768b86d69ef4cf2b87507263eb4415adf34a6c262820";
        libraryHaskellDepends = [ array base bytestring cereal text ];
        testHaskellDepends = [
          array base bytestring cereal HUnit QuickCheck test-framework
@@ -95997,7 +96306,7 @@ self: {
      mkDerivation {
        pname = "nc-indicators";
        version = "0.3";
-       sha256 = "0w5nddirsib9vz96dpan9bgdg1mag9gaz7w7ix51l44ls9r8yn3m";
+       sha256 = "75588f72d294101a4a8f879faf5e7aaa86d7de4a56dd66d2df69459d636bb670";
        isLibrary = false;
        isExecutable = true;
        executableHaskellDepends = [
@@ -96016,7 +96325,7 @@ self: {
      mkDerivation {
        pname = "ncurses";
        version = "0.2.11";
-       sha256 = "08jr224i37jxrprka9c276sid6mw001m8r2krd6g8jscshwd5nzk";
+       sha256 = "f3dbd238d44c4bf44ccb5364540300bc9a16b539822535f3cd5d9e1189105922";
        libraryHaskellDepends = [ base containers text transformers ];
        librarySystemDepends = [ ncurses ];
        libraryToolDepends = [ c2hs ];
@@ -96030,7 +96339,7 @@ self: {
      mkDerivation {
        pname = "ndjson-conduit";
        version = "0.1.0.2";
-       sha256 = "0fxxnbccasyhxd5yykzkvrj09zci8is7yqfjw0wg11n1p00hzahj";
+       sha256 = "12aa0f01b8c186f038e0d2617f744491fd0464def34fef4bebd06bc5d8b2bd3b";
        libraryHaskellDepends = [
          aeson attoparsec base bytestring conduit
        ];
@@ -96044,7 +96353,7 @@ self: {
      mkDerivation {
        pname = "neat";
        version = "0.1.0";
-       sha256 = "0lh5clnlfkzd5d9zmm9r92wpzrp8g7x6ndml7wajr882s53dv6jk";
+       sha256 = "539add46d102a12c153fb4366bfa79e8e67fb94839d5fa532bed4f472d650552";
        isLibrary = true;
        isExecutable = true;
        libraryHaskellDepends = [ base filepath parsec ];
@@ -96061,7 +96370,7 @@ self: {
      mkDerivation {
        pname = "neat-interpolation";
        version = "0.2.2.1";
-       sha256 = "00xkhc25s675pcg5s3fiq3l57zsslc0vps44gmwwas4gnz27wdfy";
+       sha256 = "de357ec4b78f68c5797d84e8bb01a35aff53e8c0d10d5d1ebbe5185d0483b303";
        libraryHaskellDepends = [
          base base-prelude parsec template-haskell
        ];
@@ -96079,7 +96388,7 @@ self: {
      mkDerivation {
        pname = "needle";
        version = "0.1.0.1";
-       sha256 = "1p7hmja7mvdbd10jv7bzr5b9i18l9nghdcvvxpn9xvfm8ycz7yg2";
+       sha256 = "e2f9f39947d5ed9eeced7bb3069f4d14859856c97f9d2d4168abed7a94acf0dc";
        libraryHaskellDepends = [
          base containers haskell-src-meta mtl parsec parsec-extra
          template-haskell text vector
@@ -96098,7 +96407,7 @@ self: {
      mkDerivation {
        pname = "neet";
        version = "0.4.0.0";
-       sha256 = "1x0l6cpjc9pjirjndh47asmva8jx5wc6gq8vab1ik2090ph0w1v5";
+       sha256 = "65070ee005098819c3521be167182f5d22b5ab5687c066658ef226262f3314f4";
        libraryHaskellDepends = [
          base cereal containers graphviz MonadRandom multimap parallel
          random transformers
@@ -96116,7 +96425,7 @@ self: {
      mkDerivation {
        pname = "nehe-tuts";
        version = "0.2.4";
-       sha256 = "00zll88gk44l22lqxv47v4j5ipfapy5599ld8fcsvhk57nfcm2r0";
+       sha256 = "208bca9c3d65c2ad99438da6548abfcadd5824d987ec8ea9109490f910a2f403";
        isLibrary = false;
        isExecutable = true;
        executableHaskellDepends = [
@@ -96134,7 +96443,7 @@ self: {
      mkDerivation {
        pname = "neil";
        version = "0.9";
-       sha256 = "0cg4x4b2x81d3mbk8nhwqib3pr154hd0snh160bfbm3b31yfr19k";
+       sha256 = "3385ec7c186bd4e51630015a0d1a2425e43b56c41c5a34571d2da02e16e9e431";
        isLibrary = false;
        isExecutable = true;
        executableHaskellDepends = [
@@ -96151,7 +96460,7 @@ self: {
      mkDerivation {
        pname = "neither";
        version = "0.3.1.1";
-       sha256 = "192l840yb1pprfjjq7ax5xaraagl1pbmsidkg1yibp6r4azd61yf";
+       sha256 = "ce07d3be22d9dc157d78b3455dd70df42995552f5d1d2ca5cbf786e5014154a4";
        libraryHaskellDepends = [ base failure transformers ];
        jailbreak = true;
        homepage = "http://github.com/snoyberg/neither";
@@ -96166,7 +96475,7 @@ self: {
      mkDerivation {
        pname = "nemesis";
        version = "2015.5.4";
-       sha256 = "149fx29818cf9rxp1gp64w5l288l4whij7im5rfms3rlgj95w6ji";
+       sha256 = "511a5e927c340f5d5d2e351e1921271421410b27e6be707b4e8ea18092e82e91";
        libraryHaskellDepends = [
          air air-th base containers directory dlist Glob mtl process time
        ];
@@ -96182,7 +96491,7 @@ self: {
      mkDerivation {
        pname = "nemesis-titan";
        version = "2014.5.19";
-       sha256 = "183m6wz52lrf5kfwxz11ad7v5zazv4gcf1c2rcylh2ys6zda4xmd";
+       sha256 = "ad76a2da37da0b483dcb8205c71ed95ffdb24f5321fccedd2c2e53513e3775a0";
        libraryHaskellDepends = [
          air air-th base bytestring directory filepath hspec HStringTemplate
          nemesis random uuid
@@ -96201,7 +96510,7 @@ self: {
      mkDerivation {
        pname = "nerf";
        version = "0.5.3";
-       sha256 = "18rkjgk2r6784mjbdd2lydv9yac252xvj18m78bbaplnac1504ak";
+       sha256 = "5311500253965eb5163a1505b9bb2882299f76f354b4b66425e8982ce69333a3";
        isLibrary = true;
        isExecutable = true;
        libraryHaskellDepends = [
@@ -96224,7 +96533,7 @@ self: {
      mkDerivation {
        pname = "nero";
        version = "0.3.1";
-       sha256 = "1nmikqdxih91xhppn72a4xsrszj4050xl9winjsm62k5wdm9ld50";
+       sha256 = "a0349a6ae3650a53b5b49127da4101447e9d75274a1c7b2fec21c1d81b9eb1da";
        libraryHaskellDepends = [
          base bifunctors bytestring containers lens text
        ];
@@ -96244,7 +96553,7 @@ self: {
      mkDerivation {
        pname = "nero-wai";
        version = "0.3";
-       sha256 = "1jz2was51lfqiq1krrjljy7yl2z49nlj72x9dspc748dznizb8aw";
+       sha256 = "5ca1f5a3fd0d91c3ae6ea98b23a94de40bea8f9754e63c038ed8d150b4e2e2cb";
        libraryHaskellDepends = [
          base bytestring http-types lens nero text wai wai-extra
        ];
@@ -96259,7 +96568,7 @@ self: {
      mkDerivation {
        pname = "nero-warp";
        version = "0.3";
-       sha256 = "1ddr0hs9x7r74f5bb00fbi0z87cfkxp21m5ikp5qgyblqb09940s";
+       sha256 = "1a9094c0c274f987cb9db1d4206e9f8e1df4415c0e80b58a23279f9e3404b9b5";
        libraryHaskellDepends = [ base nero nero-wai warp ];
        homepage = "https://github.com/plutonbrb/nero-warp";
        description = "Run Nero server applications with Warp";
@@ -96277,7 +96586,7 @@ self: {
      mkDerivation {
        pname = "nested-routes";
        version = "3.2.0";
-       sha256 = "02mj54a797h9ywa0985xw8pspl953xgn813r6mz2apx0mk6gp1xg";
+       sha256 = "af87fbccaca05f257e357904645f1f25d1ab2fe2bda00414f7099e741429b20a";
        libraryHaskellDepends = [
          aeson attoparsec base blaze-html bytestring clay composition
          constraints containers http-media http-types lucid mtl poly-arity
@@ -96299,7 +96608,7 @@ self: {
      mkDerivation {
        pname = "nested-sets";
        version = "0.0.1.1";
-       sha256 = "0a3ppsl6x9yh2pvx7fyir1khdg99wlx9d9zjflamv3gcck3d8p4i";
+       sha256 = "915cd4c664ec8d5d1575f2a7963ae529bd0667c8d1bbd3f715d0a76ea8be7728";
        libraryHaskellDepends = [ base containers ];
        testHaskellDepends = [ base containers hspec ];
        description = "Nested set model implementation";
@@ -96313,7 +96622,7 @@ self: {
      mkDerivation {
        pname = "nestedmap";
        version = "0.1.0.3";
-       sha256 = "1his95sqzyr5xb7iihz62vp9y32smf5wy4ck81yrxdvkn6zvhajl";
+       sha256 = "542ab8bfb173b79e7d409311cf8bab5a0c9fee16e6c318cfea25fb8f75493ac2";
        libraryHaskellDepends = [ base base-unicode-symbols containers ];
        testHaskellDepends = [
          base base-unicode-symbols containers data-ordlist hspec QuickCheck
@@ -96330,7 +96639,7 @@ self: {
      mkDerivation {
        pname = "net-concurrent";
        version = "0.1.0";
-       sha256 = "0ar5y38nqgh10y23yxjcz0vlvdj2hcp2b2kq0srmbh17iw8d8906";
+       sha256 = "0624d4108f27c055b306788a252e8342b64d37f84c763f8407013e6cd1f0252b";
        libraryHaskellDepends = [
          base bytestring containers ghc-binary hslogger monad-loops network
        ];
@@ -96346,7 +96655,7 @@ self: {
      mkDerivation {
        pname = "netclock";
        version = "0.6";
-       sha256 = "0vskyczfhv9bszl2hnr6j9cvhkfampja5s41kh6i9wk8j9kpf9p8";
+       sha256 = "e82677679268f2140d9c81e8a2e4adca4db85992265b28e8d72b6de83ef3536f";
        libraryHaskellDepends = [ base bytestring hosc network ];
        homepage = "http://netclock.slab.org/";
        description = "Netclock protocol";
@@ -96363,7 +96672,7 @@ self: {
      mkDerivation {
        pname = "netcore";
        version = "1.0.0";
-       sha256 = "0biqhmfvszwmmnpgja6qk3k2s5ynx4l659zq9awrxr0637dc19a5";
+       sha256 = "45a5c0da1906e49eb94af8a76228e9d6172de698d828f9aead957fbd5d85382e";
        libraryHaskellDepends = [
          ansi-wl-pprint base bimap binary binary-strict bytestring
          containers fgl HList hslogger mtl multiset network parsec process
@@ -96389,7 +96698,7 @@ self: {
      mkDerivation {
        pname = "netlines";
        version = "1.0.0";
-       sha256 = "006ca49rhh09lz8did0sil2f0xp1ggk69d4dqb2kx12drijp1jgj";
+       sha256 = "f2c97065cc4d843ec5c28db464e67be176e0048d1ab4d8d0a70940981351cc00";
        isLibrary = true;
        isExecutable = true;
        libraryHaskellDepends = [
@@ -96408,7 +96717,7 @@ self: {
      mkDerivation {
        pname = "netlink";
        version = "0.1";
-       sha256 = "0w2iyxmmk53k8gg0i8g3339dkdlpjgj39ar0kmsrzhxa6nakclwn";
+       sha256 = "9653369535aac39f759d20ab34e49397b6d9d218e3a108de437394596bf75170";
        libraryHaskellDepends = [
          base bytestring cereal containers monad-loops unix
        ];
@@ -96424,7 +96733,7 @@ self: {
      mkDerivation {
        pname = "netlist";
        version = "0.3.1";
-       sha256 = "0f3fwgpg0p3ajgxfzbqr4z04ly5cdbhjxms5xbd0k2ixdwgyxm67";
+       sha256 = "c7d4ee1f6f3d8a09daea45d72ee16aac784ac02719afeffa936a5cf0eee36e38";
        libraryHaskellDepends = [ base binary containers syb ];
        description = "Netlist AST";
        license = stdenv.lib.licenses.bsd3;
@@ -96435,7 +96744,7 @@ self: {
      mkDerivation {
        pname = "netlist-to-vhdl";
        version = "0.3.2";
-       sha256 = "107pkkihj62qjkfwrnhwfscpph5r76lx6r3s0m3b0dbsf1jy2a61";
+       sha256 = "c128e165707a35b046057a64d3a939b9c07b99761cdaccdd94581809e39cf780";
        libraryHaskellDepends = [ base netlist pretty ];
        description = "Convert a Netlist AST to VHDL";
        license = stdenv.lib.licenses.bsd3;
@@ -96449,7 +96758,7 @@ self: {
      mkDerivation {
        pname = "netpbm";
        version = "1.0.1";
-       sha256 = "02gj7m7gmislrkpk0mn5qb66z77zqy2k3py5c965bcjm086pk3fc";
+       sha256 = "cc8d790d0255b2554c62c5df3185c7ff9c6fccc2c55630efcc54c7fa4e3df209";
        libraryHaskellDepends = [
          attoparsec attoparsec-binary base bytestring storable-record
          unordered-containers vector vector-th-unbox
@@ -96467,7 +96776,7 @@ self: {
      mkDerivation {
        pname = "netrc";
        version = "0.2.0.0";
-       sha256 = "11iax3ick0im397jyyjkny7lax9bgrlgk90a25dp2jsglkphfpls";
+       sha256 = "9a5e07efa44f4b715b110aa4f9687e2b75458fb7537a2f4f1a3582c9e2e82a86";
        revision = "1";
        editedCabalFile = "55e4e8785866fa2145f9b4de21522d4092a7c486845062915704b2917b8c4fbd";
        libraryHaskellDepends = [ base bytestring deepseq parsec ];
@@ -96486,7 +96795,7 @@ self: {
      mkDerivation {
        pname = "netspec";
        version = "0.2.0.0";
-       sha256 = "0qmca5pf6r0zam86a8wghs3ylsmvd4cxk9g3nlv2gc3vl3fb8caq";
+       sha256 = "5831b4dca07bb02736b5e3a5d91969bb6aea87868f236550551f64e36e51ac62";
        libraryHaskellDepends = [
          aeson base binary bytestring mtl network template-haskell text
          transformers
@@ -96503,7 +96812,7 @@ self: {
      mkDerivation {
        pname = "netstring-enumerator";
        version = "0.1.1";
-       sha256 = "1n1g8d8507i0k4i93wb4i6yh7j7l3r0d9dfgxwl02hsk1svk5hkm";
+       sha256 = "75c232b70e53430128efcfb5d4401ef4c803bd8964f1912299201e5050432fd8";
        libraryHaskellDepends = [
          base bytestring enumerator transformers
        ];
@@ -96522,7 +96831,7 @@ self: {
      mkDerivation {
        pname = "nettle";
        version = "0.1.1";
-       sha256 = "1l9515ks41b9rkcxv91d391lwl87k2ipl3j5qfjcdz1qaxrnjkyr";
+       sha256 = "d94f69735738fcc6a4c3450e7aa39807514e431a2da4ddd9cc6905a2670925d1";
        libraryHaskellDepends = [
          base byteable bytestring crypto-cipher-types securemem tagged
        ];
@@ -96544,7 +96853,7 @@ self: {
      mkDerivation {
        pname = "nettle-frp";
        version = "0.1.1";
-       sha256 = "0jkb9a3vci91gx1rj81jbanhf0xw7n4xk69a5nhy7b55vclv8lcr";
+       sha256 = "9951b429dba5ace3a12d2a99d9893dbc0307ad5a322099437f2145b6874a6b4a";
        libraryHaskellDepends = [
          base bimap binary bytestring containers mtl nettle-openflow network
          network-data random time
@@ -96562,7 +96871,7 @@ self: {
      mkDerivation {
        pname = "nettle-netkit";
        version = "0.2.0";
-       sha256 = "152i4mdmqfrbvzq4nfzl8vy2n3jczbn18wd2mjxng1130l86cylp";
+       sha256 = "977a661005238467bbaca27114ecfa4c0e2bfc46f43b4bf0df2b3b5c5b255194";
        libraryHaskellDepends = [
          base containers directory filepath mtl nettle-openflow unix
        ];
@@ -96578,7 +96887,7 @@ self: {
      mkDerivation {
        pname = "nettle-openflow";
        version = "0.2.0";
-       sha256 = "1jc9dpsz8s6ivmkmddxy7i8kyiqf93x8rhnxly357nxlgmsn5dgk";
+       sha256 = "f3b562757db4db5386a7ddc28cfa480e473f513cbeb75667ddd168f4f56d89c9";
        libraryHaskellDepends = [
          array base bimap binary binary-strict bytestring containers HList
          mtl network parsec syb
@@ -96595,7 +96904,7 @@ self: {
      mkDerivation {
        pname = "netwire";
        version = "5.0.1";
-       sha256 = "1izl4iarcc6z2j0d6gkcygpp63asajikn1p44p8ixwzx96xx578r";
+       sha256 = "199dd2bb49fdf31ed125e4063ba3545a0d73eff36c3ed38014df30965524f4c7";
        isLibrary = true;
        isExecutable = true;
        libraryHaskellDepends = [
@@ -96614,7 +96923,7 @@ self: {
      mkDerivation {
        pname = "netwire-input";
        version = "0.0.4";
-       sha256 = "1f0dczgnc1fibq5ypdzi1hgsahmbfmv783bliwh5x4j4vm81k0h6";
+       sha256 = "06821950dd44925e208f740d747675ab42a51f0cf1b7eb0b5ed10566df670db8";
        libraryHaskellDepends = [ base netwire ];
        homepage = "https://www.github.com/Mokosha/netwire-input";
        description = "Input handling abstractions for netwire";
@@ -96627,7 +96936,7 @@ self: {
      mkDerivation {
        pname = "netwire-input-glfw";
        version = "0.0.4";
-       sha256 = "163jd8bb0msy9r51s8qb6ypk25lax46kkbzq9wh2s4kvzribmdlg";
+       sha256 = "8fb6ba62fe7b122d204ff8af390de98a1631af370b231d4a4e5e57b0166a7298";
        isLibrary = true;
        isExecutable = true;
        libraryHaskellDepends = [
@@ -96645,7 +96954,7 @@ self: {
      mkDerivation {
        pname = "network";
        version = "2.6.2.1";
-       sha256 = "1yhvpd4wigz165jvyvw9zslx7lgqdj63jh3zv5s74b5ykdfa3zd3";
+       sha256 = "a3fda15c9bbe2c7274d97f40398c6cf8d1d3a9fe896fbf6531e1bfc849bb1bfa";
        libraryHaskellDepends = [ base bytestring unix ];
        testHaskellDepends = [
          base bytestring HUnit test-framework test-framework-hunit
@@ -96662,7 +96971,7 @@ self: {
      mkDerivation {
        pname = "network-address";
        version = "0.2.0";
-       sha256 = "0pz6x11naxzby14jxrm31j2jdd6gwqspbrx1hv5204rbf7lifib1";
+       sha256 = "614517e9712b1320ca86a1e77535e6cfb426850ca3e62e49f0eb776543e8e65f";
        isLibrary = true;
        isExecutable = true;
        libraryHaskellDepends = [ base Cabal ];
@@ -96685,7 +96994,7 @@ self: {
      mkDerivation {
        pname = "network-anonymous-i2p";
        version = "0.10.0";
-       sha256 = "0b7z7w105l1yd3xpnnl2z779m5zknf756cslksbbpsy16rn7kxfg";
+       sha256 = "cff5796c36c1ebbb969e5433538eb3f3979acef9825a7bfb683ed002023fff2c";
        libraryHaskellDepends = [
          attoparsec base bytestring exceptions mtl network
          network-attoparsec network-simple text transformers uuid
@@ -96709,7 +97018,7 @@ self: {
      mkDerivation {
        pname = "network-anonymous-tor";
        version = "0.9.2";
-       sha256 = "1zssb8npwnzj8mra8pkvshni7h36wqhddva9rrwbq480492sck1w";
+       sha256 = "3c4ca645220011bc78ce49edd620e666c0132dd47b5ea47245f25b7e2d5a5aff";
        isLibrary = true;
        isExecutable = true;
        libraryHaskellDepends = [
@@ -96737,7 +97046,7 @@ self: {
      mkDerivation {
        pname = "network-api-support";
        version = "0.2.0";
-       sha256 = "01ambd53cf2n4y3c1j62wav3jz09s5vml87gkg69bl6h1g63zls1";
+       sha256 = "41d33fcc0bd0d095cc9bef205a77d1097c39b6e2c2c8c086275638364a5b5505";
        libraryHaskellDepends = [
          aeson attoparsec base bytestring case-insensitive http-client
          http-client-tls http-types text time tls
@@ -96756,7 +97065,7 @@ self: {
      mkDerivation {
        pname = "network-attoparsec";
        version = "0.12.2";
-       sha256 = "1w08py367mmwfg5lff6y9s6hdpg1nbjf7v6vv9s19aw6saxak44p";
+       sha256 = "9790a9bad286ab1474dadbece3e4b2e1dd068d4ede3847cb73bcd66386bf08f0";
        libraryHaskellDepends = [
          attoparsec base bytestring enclosed-exceptions exceptions
          lifted-base monad-control mtl network transformers
@@ -96778,7 +97087,7 @@ self: {
      mkDerivation {
        pname = "network-bitcoin";
        version = "1.8.1";
-       sha256 = "0gw04wh24j4vpyvx0wy0bdhh3dkwdxrg2laq7vsvwlpzwgcny99h";
+       sha256 = "30256fd9e3ff52bef53e5851f1726f7cb601615bc073d0b7bf9b48222027803f";
        isLibrary = true;
        isExecutable = true;
        libraryHaskellDepends = [
@@ -96802,7 +97111,7 @@ self: {
      mkDerivation {
        pname = "network-builder";
        version = "0.1.0";
-       sha256 = "0faa3clz80158m9cy4mblnszla6k9hbf8bdwp5cam05dwmvsdcyw";
+       sha256 = "dcb3a677e5ad80aa58b9bc2de4164cd328fab5a5ab12cf52452500f4291b4a39";
        isLibrary = true;
        isExecutable = true;
        libraryHaskellDepends = [ aeson base bytestring shelly text yaml ];
@@ -96822,7 +97131,7 @@ self: {
      mkDerivation {
        pname = "network-bytestring";
        version = "0.1.3.4";
-       sha256 = "19m10mj9nqsa7s0syv9dyhqkhvmf2h7yna8n7bq0xkdp8m9l0g96";
+       sha256 = "263d405345b7cd0ef03a1629eb0f14ae6e3831f42d6daf813e4a639b6405a1a6";
        libraryHaskellDepends = [ base bytestring network unix ];
        jailbreak = true;
        homepage = "http://github.com/tibbe/network-bytestring";
@@ -96836,7 +97145,7 @@ self: {
      mkDerivation {
        pname = "network-carbon";
        version = "1.0.5";
-       sha256 = "0kb3gz8545dgi93ys9pk240vap7zjnl2npn1xryng2ijl7ssn9li";
+       sha256 = "9126abf5a1328a677deec15e2ba895ff5cb50111f326ed478aaf1552d07f634d";
        libraryHaskellDepends = [
          base bytestring network text time vector
        ];
@@ -96850,7 +97159,7 @@ self: {
      mkDerivation {
        pname = "network-conduit";
        version = "1.1.0";
-       sha256 = "06amxl8rg4zfnmgc1iyq5mxy9qihcqddqgqkbfvaf25mwr43992p";
+       sha256 = "57a43448e6b508a7b65b133fdc1a6630e2e47b2dd8c7c05eb5ee939711ed5519";
        libraryHaskellDepends = [ base conduit ];
        homepage = "http://github.com/snoyberg/conduit";
        description = "Stream socket data using conduits. (deprecated)";
@@ -96865,7 +97174,7 @@ self: {
      mkDerivation {
        pname = "network-conduit-tls";
        version = "1.2.0.1";
-       sha256 = "17d267sg74snq626kk8n9yy9njspjzivwjg60l69879z4nsvp200";
+       sha256 = "0088bbb5253f1d940c05e649bee397574b9bbc4f16cd6984c15693f3f431a29d";
        libraryHaskellDepends = [
          base bytestring conduit conduit-extra connection cprng-aes
          data-default monad-control network streaming-commons tls
@@ -96886,7 +97195,7 @@ self: {
      mkDerivation {
        pname = "network-connection";
        version = "0.1.1";
-       sha256 = "0v3dwq5vxmgknsiq2nddfj3gvvvaxdlfsnk0bxrqw9zzzdkpi0q1";
+       sha256 = "01837867fbff278e735f605aed68eb6aeffd8674ad5981a3b6f3d5be0be66d6c";
        libraryHaskellDepends = [
          base bytestring containers network network-bytestring stm
        ];
@@ -96901,7 +97210,7 @@ self: {
      mkDerivation {
        pname = "network-data";
        version = "0.5.3";
-       sha256 = "0zbwplzrr899lj0ig2nyq58cayy6f8pkn4wnqbrd1i50lhq61szz";
+       sha256 = "ffeb6030a4a0c4d0f2c296133b2f72c67bc550c1de8a1781a429a19c3fbd7c7d";
        libraryHaskellDepends = [ base bytestring cereal pretty ];
        description = "Library for network data structures and their serialization";
        license = stdenv.lib.licenses.bsd3;
@@ -96914,7 +97223,7 @@ self: {
      mkDerivation {
        pname = "network-dbus";
        version = "0.0";
-       sha256 = "024h0gfgn7hmfh90y74nf03kpvj5mg74a54lgb6clvxxfp8j64w9";
+       sha256 = "891323d175bd6fcacc7a941445ceab45ee3b0770961c0f1274151efbdc039008";
        libraryHaskellDepends = [
          base binary bytestring containers mtl network parsec unix
          utf8-string
@@ -96932,7 +97241,7 @@ self: {
      mkDerivation {
        pname = "network-dns";
        version = "1.0.0.1";
-       sha256 = "0gg1g1gnbi6dzw5anz3dam2gh09q948d3k7q84agkswa64c0azn8";
+       sha256 = "c87e0518318aebf91441f8ccd110493801f844556d7cab0affcdc4655f78e13d";
        libraryHaskellDepends = [
          base binary bytestring cereal containers data-textual hashable
          network-ip parsers tagged text-latin1 text-printer
@@ -96949,7 +97258,7 @@ self: {
      mkDerivation {
        pname = "network-enumerator";
        version = "0.1.5";
-       sha256 = "11hwgdw03a39k3akjy5qlg9zsb7z8qiikvdmcqr2dhj6ykmfwsvk";
+       sha256 = "736beeeaf446c2263266b5ed192346ff2cfdd3a3b87839d59869a801787b1c86";
        libraryHaskellDepends = [
          base bytestring enumerator network transformers
        ];
@@ -96963,7 +97272,7 @@ self: {
      mkDerivation {
        pname = "network-fancy";
        version = "0.2.3";
-       sha256 = "1b4hbwqbir3qw3hs1mxdqdz0lnagyqrp5r383b6cm7yvjy3q3if5";
+       sha256 = "c5c5818797db9fcacc1a68e47233f64f590a7ec3add7a0e1e078e4b8305f90ac";
        libraryHaskellDepends = [ base bytestring ];
        homepage = "http://github.com/taruti/network-fancy";
        description = "Networking support with a cleaner API";
@@ -96975,7 +97284,7 @@ self: {
      mkDerivation {
        pname = "network-house";
        version = "0.1.0.1";
-       sha256 = "0s9ysp28nd29q2g62w7ch5h7l2kxdjfqqbz4h70vg8py3zs5gfqn";
+       sha256 = "16bb57f41ffea2b7c181e42f8c9d6c7d0a7a6081ec70619ec049348bc4d53e69";
        libraryHaskellDepends = [ array base containers mtl ];
        homepage = "https://github.com/nh2/network-house";
        description = "data and parsers for Ethernet, TCP, UDP, IPv4, IPv6, ICMP, DHCP, TFTP";
@@ -96988,7 +97297,7 @@ self: {
      mkDerivation {
        pname = "network-info";
        version = "0.2.0.7";
-       sha256 = "0pa0051ji3sr8ax8z1gfgj8x0wvvr20i1zkxs28hq4hdsv1y4dpg";
+       sha256 = "ef36e2c3d60d120c91d07dfe1081c87b73d0917cee858fba42598f284301405d";
        libraryHaskellDepends = [ base ];
        homepage = "http://github.com/jystic/network-info";
        description = "Access the local computer's basic network configuration";
@@ -97000,7 +97309,7 @@ self: {
      mkDerivation {
        pname = "network-interfacerequest";
        version = "0.0.1";
-       sha256 = "0qa5rbbcw9axg7mj4kjj027hfsclnw85cj8nmi6jvrzq2yhhk56c";
+       sha256 = "cc9409a117f8e72d4dac16495610b79469078f00524e22eb795d25ced6ca4561";
        libraryHaskellDepends = [ base bytestring ioctl network ];
        jailbreak = true;
        description = "Haskell bindings for the ifreq structure";
@@ -97015,7 +97324,7 @@ self: {
      mkDerivation {
        pname = "network-ip";
        version = "0.2.1.1";
-       sha256 = "0abc07pi39drsldhk4znlq1j6cv0vxm7y8yyg2z4qanb3sy990iy";
+       sha256 = "3e8294bc1ecb2a4cbe78de237f6adf60332303a6f693091bd5b9a511ef016c29";
        libraryHaskellDepends = [
          base binary cereal data-default-class data-dword data-endian
          data-textual hashable parsers text-printer type-hint
@@ -97036,7 +97345,7 @@ self: {
      mkDerivation {
        pname = "network-metrics";
        version = "0.4";
-       sha256 = "0dvrjf84pdm42pxwc7fm4gvswc5nzmdsq7cr7ab8jyzvjqb8684c";
+       sha256 = "8c20831696fb7b89963a991dac5bfdb630aef723d51dc6fb15a4b64b90937937";
        libraryHaskellDepends = [
          base binary bytestring data-default network random time
        ];
@@ -97054,7 +97363,7 @@ self: {
      mkDerivation {
        pname = "network-minihttp";
        version = "0.2";
-       sha256 = "104jfksb0xagd8am3h390avqqr3k7qgxcd0znppz4hr0p9d681f5";
+       sha256 = "c505645aba2043f2efb51f34d61f3e73648cb70269c051156a4f75b0f4749280";
        libraryHaskellDepends = [
          base binary binary-strict bytestring containers filepath HsOpenSSL
          mtl network network-bytestring network-connection network-dns
@@ -97071,7 +97380,7 @@ self: {
      mkDerivation {
        pname = "network-msg";
        version = "0.5";
-       sha256 = "0ykphm5xljxml4ifx2v2f7f51kny170k552sy5l4f5paciv47a1g";
+       sha256 = "2fa8437664ea164768f15a9432c109dece50dc71628bee22a1b54bda4b85777a";
        libraryHaskellDepends = [ base binary bytestring network unix ];
        description = "Recvmsg and sendmsg bindings";
        license = "unknown";
@@ -97082,7 +97391,7 @@ self: {
      mkDerivation {
        pname = "network-multicast";
        version = "0.1.0";
-       sha256 = "12kswjqg4xv7gdjqabbyr7wvqkkzsyga3fjxnv9z9fdmil7xphhq";
+       sha256 = "18c2db0f8db5b9f4d3b65dbaa19ed77f4ebcf9c97e2d85657b6777f2b0e47a8a";
        libraryHaskellDepends = [ base network ];
        description = "Simple multicast library";
        license = stdenv.lib.licenses.publicDomain;
@@ -97095,7 +97404,7 @@ self: {
      mkDerivation {
        pname = "network-netpacket";
        version = "0.0.1";
-       sha256 = "12q3bqy57lj46m3l44zdk3sqkhbnqfd5cjp3qy1m5m5wxfdnmx56";
+       sha256 = "a6f46a9bebbcd45283c7e34a569ac376c189f598ed1342473544d2533c5e038b";
        libraryHaskellDepends = [
          base bytestring foreign-storable-asymmetric ioctl network
          network-interfacerequest
@@ -97112,7 +97421,7 @@ self: {
      mkDerivation {
        pname = "network-pgi";
        version = "0.0.1";
-       sha256 = "0s0rk3q1nlic2ibcpr0px0kb8gwp2hbnra5109l71q3dr713n2yw";
+       sha256 = "dc0b3bc2c96de0706802a1a86c1714973fb426e817e4cb56142c521bf0981968";
        libraryHaskellDepends = [
          attoparsec attoparsec-enumerator base bytestring enumerator tnet
        ];
@@ -97127,7 +97436,7 @@ self: {
      mkDerivation {
        pname = "network-protocol-xmpp";
        version = "0.4.8";
-       sha256 = "07hy8byhaakjwfidrvkjp07jn25aw21g8wcs93ni3njj0kh2jxza";
+       sha256 = "ea7729e00452da11ed489a71f482e0aa082b0fb872eedca2e3722a05fd421e1e";
        libraryHaskellDepends = [
          base bytestring gnuidn gnutls gsasl libxml-sax monads-tf network
          text transformers xml-types
@@ -97145,7 +97454,7 @@ self: {
      mkDerivation {
        pname = "network-rpca";
        version = "0.0.1";
-       sha256 = "1dhy4n0502rx66pansmgmjv8avwwbhvf23afhb98zqksqlkavdir";
+       sha256 = "39b6ad26c57ae28fd2824e0de1365c9c6f85b6acaf6aabae313d0b5080251eb6";
        libraryHaskellDepends = [
          array base binary binary-strict bytestring codec-libevent
          containers control-timeout network network-bytestring stm
@@ -97160,7 +97469,7 @@ self: {
      mkDerivation {
        pname = "network-server";
        version = "0.2.0";
-       sha256 = "0iijgw07b5g3rcd4va98pb4hdkk912c67y2d1lkz03bfyq75b6xk";
+       sha256 = "b39b550ef66e0df0270d4df863980869ce06c9ba28a94d1acbe39575007f3246";
        isLibrary = true;
        isExecutable = true;
        libraryHaskellDepends = [ base network unix ];
@@ -97177,7 +97486,7 @@ self: {
      mkDerivation {
        pname = "network-service";
        version = "0.1.0.0";
-       sha256 = "1js0p0i27fj8rjnq54pcq97bgvhdx7jpwj1ghqmdwpvhn8ds07p4";
+       sha256 = "e41ea01bb2705fde2a862f487ee5e90deeb74ec2ec9282adcc48ba2322b840cb";
        isLibrary = true;
        isExecutable = true;
        libraryHaskellDepends = [
@@ -97199,7 +97508,7 @@ self: {
      mkDerivation {
        pname = "network-simple";
        version = "0.4.0.4";
-       sha256 = "0qa3ax29ci7m01af0d2rvnx9m24q1d9zw727bzhc88k2g6k2xzah";
+       sha256 = "50fd2ea6796222c4e05f471cfe530b98889abadd5934e05400f5449644574361";
        libraryHaskellDepends = [
          base bytestring exceptions network transformers
        ];
@@ -97215,7 +97524,7 @@ self: {
      mkDerivation {
        pname = "network-simple-sockaddr";
        version = "0.2";
-       sha256 = "0c7jjdpzvbpg29njr1w0kn26m3pxa8q1z3sh7bfh933spnvqm52x";
+       sha256 = "5d948ab7bd7a8c04dd3a508f1f3052fd8e6a849d80872c6d12efaefd6f93f230";
        libraryHaskellDepends = [
          base bytestring directory exceptions network transformers
        ];
@@ -97231,7 +97540,7 @@ self: {
      mkDerivation {
        pname = "network-simple-tls";
        version = "0.2.1";
-       sha256 = "0hbpxbs357bxifksbqrlrdkwkkfaydxcf9wdla6kafaymhrxhc0k";
+       sha256 = "1330d833ac5e39358da28d27c77af3cacdc967cb34e3a5a78b7d9d32f4ea7741";
        libraryHaskellDepends = [
          base bytestring certificate cprng-aes exceptions network
          network-simple tls tls-extra transformers
@@ -97248,7 +97557,7 @@ self: {
      mkDerivation {
        pname = "network-socket-options";
        version = "0.2.0.1";
-       sha256 = "00qf22nwzsv8229gb7yqaaafiz573xl4v78mn1zf9ajvwzvwb63r";
+       sha256 = "7998c5f7e75baae47eb0159d4d681fa7fce89452d89ff5921068ebcfad100e03";
        libraryHaskellDepends = [ base network ];
        homepage = "https://github.com/joeyadams/haskell-network-socket-options";
        description = "Type-safe, portable alternative to getSocketOption/setSocketOption";
@@ -97262,7 +97571,7 @@ self: {
      mkDerivation {
        pname = "network-stream";
        version = "0.1.0";
-       sha256 = "1y7c2m8yrkb67iqqv6sjbxxmhlnv0s6k82lv9f6wk4mhckcsc5n1";
+       sha256 = "c116a6d964b092c98d4b9b0a348d06db52587b5f529b8d713c66cdec5115ecf8";
        libraryHaskellDepends = [
          base binary bytestring cereal enumerator network stm text
          transformers
@@ -97281,7 +97590,7 @@ self: {
      mkDerivation {
        pname = "network-topic-models";
        version = "0.2.0.1";
-       sha256 = "1l5m9f08aizrxxkv2dspv8swf558cch6vx4gyzs6qs6826v9q32b";
+       sha256 = "4b0c9cb611c8686cf4f78ff46d2063a814c735da5737b167eff94785804bb5d0";
        isLibrary = false;
        isExecutable = true;
        executableHaskellDepends = [
@@ -97303,7 +97612,7 @@ self: {
      mkDerivation {
        pname = "network-transport";
        version = "0.4.2.0";
-       sha256 = "0arwy5csrm33217rmnip6b0x61b6am1db6mj5phfysj0pz30viqf";
+       sha256 = "0ec70dc6bf406aefe02db29ad542556605d3c13237da9a4f1063d4ac59f13c2b";
        libraryHaskellDepends = [
          base binary bytestring deepseq hashable transformers
        ];
@@ -97321,7 +97630,7 @@ self: {
      mkDerivation {
        pname = "network-transport-amqp";
        version = "0.1.0.0";
-       sha256 = "1165xl5g8m423y4nvzwpihzrv6nc9y2dyr6dm4sqp6n1bw4dqqdq";
+       sha256 = "b861dc085fc19a8b35a9cd64df844fcc9a9d3f8c97ff6d891f8254f40aedc584";
        revision = "2";
        editedCabalFile = "724410b5035d55d170110908838d023a675306faf5fc056ed2a8d68beeb112d4";
        libraryHaskellDepends = [
@@ -97346,7 +97655,7 @@ self: {
      mkDerivation {
        pname = "network-transport-inmemory";
        version = "0.5.0";
-       sha256 = "1znc4xk6arzi6vr8pfv2vyvak377jpxzzq82r17kz4csdrbnbfw6";
+       sha256 = "86bb65576e9a913f4fc802e1fffb95e78ca9b6df62bb8bf236f167656627ccfe";
        libraryHaskellDepends = [
          base bytestring containers data-accessor network-transport stm
        ];
@@ -97365,7 +97674,7 @@ self: {
      mkDerivation {
        pname = "network-transport-tcp";
        version = "0.4.2";
-       sha256 = "0wh3d37cfmqbxa0x9c56miki7m9mpg0xv5rrn8fh562lfvcn89ls";
+       sha256 = "9a2664d9765498021db23997ddc1bb35d51367aca6b0d481ea0b57c7ce680372";
        libraryHaskellDepends = [
          base bytestring containers data-accessor network network-transport
        ];
@@ -97384,7 +97693,7 @@ self: {
      mkDerivation {
        pname = "network-transport-tests";
        version = "0.2.2.0";
-       sha256 = "0914sj3884sp5sxbm460x5frvl0ipn8v1jpkskhc9ajjx4v0s106";
+       sha256 = "06040d36e952aac4e0d4f3cab091bd11d09d5de9c090baba2e57138486d42424";
        libraryHaskellDepends = [
          ansi-terminal base bytestring containers mtl network-transport
          random
@@ -97404,7 +97713,7 @@ self: {
      mkDerivation {
        pname = "network-transport-zeromq";
        version = "0.2.1";
-       sha256 = "0bfznyxf893k0yf4cm53bmmcpyrs7llpf6fd077rccn37x1kj0ih";
+       sha256 = "300239433fc33296cf01cd1977293d3afbcb6a5da354469c077324e4bab7df2d";
        isLibrary = true;
        isExecutable = true;
        libraryHaskellDepends = [
@@ -97433,7 +97742,7 @@ self: {
      mkDerivation {
        pname = "network-uri";
        version = "2.6.0.3";
-       sha256 = "1pwbqb2rk4rnvllvdch42p5368xcvpkanp7bxckdhxya8zzwvhhg";
+       sha256 = "0fc2cdff47ca77d826ebeb5cabe6ddac2333ca1504b2b629dd369399c5c28bdf";
        libraryHaskellDepends = [ base deepseq parsec ];
        testHaskellDepends = [
          base HUnit test-framework test-framework-hunit
@@ -97449,7 +97758,7 @@ self: {
      mkDerivation {
        pname = "network-uri-static";
        version = "0.1.0.0";
-       sha256 = "16b8jn72g76zd2gxzimnnj77l42y430y862sxzdnsclsnc7w4fn9";
+       sha256 = "c93ac20fb39a326ddbef5a18e4c1205e107a8eb4b6c6df9f68df9c278e956899";
        libraryHaskellDepends = [ base network-uri template-haskell ];
        testHaskellDepends = [ base doctest ];
        homepage = "http://github.com/snakamura/network-uri-static";
@@ -97462,7 +97771,7 @@ self: {
      mkDerivation {
        pname = "network-wai-router";
        version = "0.3.0.1";
-       sha256 = "1fnqc1vbahy6zy632s9kam8bv7108bhmynyh2iwkqb7ybkkj37i9";
+       sha256 = "299e21e75cfe2c3c7914d05b5fe142209cbd50553369318cffc643b57660d8ba";
        libraryHaskellDepends = [ base wai ];
        description = "A routing library for wai";
        license = stdenv.lib.licenses.mit;
@@ -97473,7 +97782,7 @@ self: {
      mkDerivation {
        pname = "network-websocket";
        version = "0.3";
-       sha256 = "053qrlm2bd14mlcvlh64awsqsgn355nkr13k9h4dnfabafymkkbm";
+       sha256 = "75cd59bd534b39db084c73843c6d29c33e8d3557c440ba19ad24b4252acd7814";
        isLibrary = true;
        isExecutable = true;
        libraryHaskellDepends = [ base haskell98 network webserver ];
@@ -97491,7 +97800,7 @@ self: {
      mkDerivation {
        pname = "networked-game";
        version = "0.1.0.1";
-       sha256 = "12sy97cgqrsmqywh0cznp8wbsw8z2yahlfalsjy32qarcz44banz";
+       sha256 = "dfaa45c867596131bcd454390a95171f71bd38baf63300b9c75567fcd8495e8b";
        libraryHaskellDepends = [
          base binary bytestring containers network time transformers
        ];
@@ -97505,7 +97814,7 @@ self: {
      mkDerivation {
        pname = "newports";
        version = "1.1";
-       sha256 = "1paxqr8rm8lbp0896qsd7v76c0kahkk6fngpcdzswbrqpyqhwjwc";
+       sha256 = "8c4b0eb1bf382fae7f63f75967e6846a0266ce3e4d639310b88ba29a51c65ddd";
        isLibrary = false;
        isExecutable = true;
        executableHaskellDepends = [ base directory old-time ];
@@ -97522,7 +97831,7 @@ self: {
      mkDerivation {
        pname = "newsynth";
        version = "0.3.0.1";
-       sha256 = "1c65s4nwxzlmix0549chhvm5wj4rvxq92y5kfzd9h11jc4hxl7xs";
+       sha256 = "ba1fda2161320498da77b3789170df99485eea86902552408f95fece2dd1c5b0";
        isLibrary = true;
        isExecutable = true;
        libraryHaskellDepends = [
@@ -97545,7 +97854,7 @@ self: {
      mkDerivation {
        pname = "newt";
        version = "0.0.3.1";
-       sha256 = "0amhpvqqy8pan3vihjvpkd25jz3m4syavw4l15cvqny8mhrxbvpj";
+       sha256 = "f2eed533acc85bbc590994f0adbc26757c59449b774b18f7b0ea228ff1beb02a";
        isLibrary = true;
        isExecutable = true;
        libraryHaskellDepends = [
@@ -97568,7 +97877,7 @@ self: {
      mkDerivation {
        pname = "newtype";
        version = "0.2";
-       sha256 = "0ng4i5r73256gzwl6bw57h0abqixj783c3ggph1hk2wsplx0655p";
+       sha256 = "b714033abd9a8b0903bcef0d36d0913de2a5003c852f43f97fa688717289e459";
        libraryHaskellDepends = [ base ];
        description = "A typeclass and set of functions for working with newtypes";
        license = stdenv.lib.licenses.bsd3;
@@ -97581,7 +97890,7 @@ self: {
      mkDerivation {
        pname = "newtype-deriving";
        version = "0.1.2";
-       sha256 = "15ajk0vbh4habil8339naajy7l086cryqw52ifv1agjyn9kmlixa";
+       sha256 = "aa475a67b25e3e15b68ba270ec333308d0e3a552368d81685c0a12b836985295";
        libraryHaskellDepends = [
          base base-prelude monad-control template-haskell transformers
          transformers-base
@@ -97596,7 +97905,7 @@ self: {
      mkDerivation {
        pname = "newtype-generics";
        version = "0.4.1";
-       sha256 = "1qjzcmx5yj85cvdgglyg9f9ff7k9gvnyrb85n6bjzyh10q9n7vd5";
+       sha256 = "a5ed63130601fa2f97b105adeced7e691ee7924bcfd3f7da6605495f7a655fe2";
        libraryHaskellDepends = [ base ];
        testHaskellDepends = [ base hspec HUnit ];
        description = "A typeclass and set of functions for working with newtypes, with generics support";
@@ -97610,7 +97919,7 @@ self: {
      mkDerivation {
        pname = "newtype-th";
        version = "0.3.3";
-       sha256 = "1slgphymjxzbxxgsilfijkhiwapfy2gkhkby2dxqj107v4s0788k";
+       sha256 = "13a10334d90704897b137e4d389ff0ee2a1ee194d1d1a85fefeb77593dbc8fea";
        libraryHaskellDepends = [
          base haskell-src-meta newtype syb template-haskell
        ];
@@ -97626,7 +97935,7 @@ self: {
      mkDerivation {
        pname = "newtyper";
        version = "0.1";
-       sha256 = "1s1mzy1m3wpawv1ci85dl02105v550l1fdi5rxi5gqnxb0jrg4fs";
+       sha256 = "da91972558dde25762cf253617282865171004a0ada0c8c2e6eaf25183ff35e8";
        libraryHaskellDepends = [ base Kleislify newtype ];
        homepage = "https://github.com/techtangents/Newtyper";
        description = "Extra functions for the Control.Newtype typeclass";
@@ -97638,7 +97947,7 @@ self: {
      mkDerivation {
        pname = "nextstep-plist";
        version = "0.0.1";
-       sha256 = "0wld4nc6hcv642km60vvjyclsfwnpfavq59mqm8fm3a73al4csyw";
+       sha256 = "dc6b46a81a478dea50c53515bc95bb963b4d99977b0353a72066336898258d72";
        libraryHaskellDepends = [ base parsec pretty QuickCheck ];
        description = "NextStep style plist parser and printer";
        license = stdenv.lib.licenses.bsd3;
@@ -97649,7 +97958,7 @@ self: {
      mkDerivation {
        pname = "nf";
        version = "1.0.1.0";
-       sha256 = "1yrw6skp2n8fd874481bfalli8lcglakhdggdsj8dm036wpm935a";
+       sha256 = "aa8c542f3703d486a46eef3538157d8ca248a9722b20420e6a0e5971a7363cfb";
        libraryHaskellDepends = [ base deepseq ];
        homepage = "https://github.com/ezyang/nf";
        description = "NF data type to statically enforce normal form";
@@ -97663,7 +97972,7 @@ self: {
      mkDerivation {
        pname = "ngrams-loader";
        version = "0.1.0.1";
-       sha256 = "0z26mpk1q7hnx4vkcyfwy6pbm7nm76ydm04z3vk598q2ifq5vmpd";
+       sha256 = "edd65db08b02a354e61e9f80dabc39d59ebaaef1dc793637e9161e1ce6ad467c";
        isLibrary = true;
        isExecutable = true;
        libraryHaskellDepends = [
@@ -97684,7 +97993,7 @@ self: {
      mkDerivation {
        pname = "nibblestring";
        version = "0.0.3";
-       sha256 = "0ijcv7ph09mmllly09jgigwiq64m05c7qkq2riki3mbza2skxbrr";
+       sha256 = "39af3eb5507fd51167cc024f7c580195181cf98b4f26e029a5b52600efd94c46";
        libraryHaskellDepends = [
          ansi-wl-pprint base base16-bytestring bytestring
        ];
@@ -97702,7 +98011,7 @@ self: {
      mkDerivation {
        pname = "nicify";
        version = "1.2.1";
-       sha256 = "0qpm18md4jmfznfxqbi9aqvlqrgmiab7b477s11hwcb6y00kyfwk";
+       sha256 = "933b3f01f066310e43d0e79075968af5654c3756292edc9dfdae4ad22a0af562";
        isLibrary = false;
        isExecutable = true;
        executableHaskellDepends = [ base nicify-lib ];
@@ -97715,7 +98024,7 @@ self: {
      mkDerivation {
        pname = "nicify-lib";
        version = "1.0.1";
-       sha256 = "0cp76s0msf1i8a7pkzjl6qgi18n7zdya3pg90ml1dnidg5nzh9kx";
+       sha256 = "7d26f86d792dda166805e9dda17cfbc7a2101f3654fe798f4231385d8136e732";
        libraryHaskellDepends = [ base parsec transformers ];
        description = "Pretty print the standard output of default `Show` instances";
        license = stdenv.lib.licenses.mit;
@@ -97729,7 +98038,7 @@ self: {
      mkDerivation {
        pname = "nicovideo-translator";
        version = "0.1.0.0";
-       sha256 = "01qbmkr9h78iwyrgdijqyf06xl8wk2z9nn4v8dc5pb1gknlbp8wh";
+       sha256 = "90a3bba89d2fac5b58439b589bbe981cd16e80f358c6f6b2e7111d98f2ac0b07";
        isLibrary = true;
        isExecutable = true;
        libraryHaskellDepends = [
@@ -97751,7 +98060,7 @@ self: {
      mkDerivation {
        pname = "nikepub";
        version = "1.1.2";
-       sha256 = "1w7cvkh36p7i9n62rvfh6nlr8z16hds06fbr1lpvbc84ymci75v0";
+       sha256 = "60971359f504b1b52f0d7939037483267c94a935d0ed2c8c4df15c33e0dcecf0";
        isLibrary = false;
        isExecutable = true;
        executableHaskellDepends = [
@@ -97770,7 +98079,7 @@ self: {
      mkDerivation {
        pname = "nimber";
        version = "0.1.3";
-       sha256 = "0350fmddnfp09051i89fl5ibrxqy36cx5560l00cjssx2gs2dh8w";
+       sha256 = "1cc126f4135d6bc900a0c094d299191ef7bc62a12ea1180a48e03adb5a75a00c";
        libraryHaskellDepends = [ arithmoi base ];
        homepage = "http://andersk.mit.edu/haskell/nimber/";
        description = "Finite nimber arithmetic";
@@ -97782,7 +98091,7 @@ self: {
      mkDerivation {
        pname = "nitro";
        version = "0.2.2.5";
-       sha256 = "17aqzk1kq670fwawia0qjmd8ld1b0h8zh0w8j8x4y48hlzyb75xb";
+       sha256 = "ab97b3fca710114f3a928803f811042b348a5a9518a8c81577e0183cc3fc589d";
        libraryHaskellDepends = [ base bytestring ];
        jailbreak = true;
        homepage = "http://haskell.gonitro.io";
@@ -97801,7 +98110,7 @@ self: {
      mkDerivation {
        pname = "nixfromnpm";
        version = "0.1.0.7";
-       sha256 = "0pl00kiirpmhzsyr96gzkjrzps69vycpabrjjdq31ngckwqvjib1";
+       sha256 = "6145b9319fecd9307093322f7599dfc9e8fbb39cff9994bdfeb0de1ce304805e";
        isLibrary = true;
        isExecutable = true;
        libraryHaskellDepends = [
@@ -97829,7 +98138,7 @@ self: {
      mkDerivation {
        pname = "nixos-types";
        version = "1.5";
-       sha256 = "1q38cs0747fyf94y35cq734yzmsdcyfmmk5w6qv563jns55qj36c";
+       sha256 = "cc0c894bd1560e533636bccc5a9d674dd7efc9389895e14972de1d72806668e0";
        homepage = "http://hackage.haskell.org/package/cabal2nix";
        description = "this package is obsolete; see cabal2nix instead";
        license = stdenv.lib.licenses.bsd3;
@@ -97843,7 +98152,7 @@ self: {
      mkDerivation {
        pname = "nkjp";
        version = "0.4.0";
-       sha256 = "1i9q0xyfqi3cv29k8yflrg34hgblxfyj2dqr1zjg20jpymsfi06l";
+       sha256 = "d480e874f55702f1e40f193721bdeb743d48c6cbd4793493d86c44ec7c0738c5";
        isLibrary = true;
        isExecutable = true;
        libraryHaskellDepends = [
@@ -97861,7 +98170,7 @@ self: {
      mkDerivation {
        pname = "nlp-scores";
        version = "0.7.0";
-       sha256 = "0cxa6f4y3416hlal4wnqf0qpq82zj9x58nprnaw3s2kdxxav0d9m";
+       sha256 = "3535b055ef6d0a3db8b2f95a547a925f207c3170d8724215852690e18933aa33";
        libraryHaskellDepends = [ base containers strict ];
        homepage = "https://bitbucket.org/gchrupala/lingo";
        description = "Scoring functions commonly used for evaluation in NLP and IR";
@@ -97873,7 +98182,7 @@ self: {
      mkDerivation {
        pname = "nlp-scores-scripts";
        version = "0.2.0.0";
-       sha256 = "02jisx8slzzljv77d931b169hxq6i6ajg5ly9a37g13q9h75gd2c";
+       sha256 = "4cb4570e4c788477864a9e962795890677984c5861a476ce96f47faa51d7510a";
        isLibrary = false;
        isExecutable = true;
        executableHaskellDepends = [
@@ -97890,7 +98199,7 @@ self: {
      mkDerivation {
        pname = "nm";
        version = "1.0.1";
-       sha256 = "028p25pb2cqlvrydy87y26rinvypbq0lnphd59k3zaxvxxikqwf1";
+       sha256 = "c1713c63efbbab3f662a0d5e4b015ed76f1bb311fe20df7cde1433b16e111709";
        isLibrary = true;
        isExecutable = true;
        libraryHaskellDepends = [ base vector ];
@@ -97908,7 +98217,7 @@ self: {
      mkDerivation {
        pname = "nme";
        version = "0.2";
-       sha256 = "14qzc4af1pm1myjdfs7z4b1jxxj0gz9c4cl9qgpm06hjzvjjf8wm";
+       sha256 = "952327e5fe121a50efc38932c2d27f40f62ec322ff68d7a4afa1dee014611f93";
        libraryHaskellDepends = [ base bytestring utf8-string ];
        homepage = "https://github.com/singpolyma/NME-Haskell";
        description = "Bindings to the Nyctergatis Markup Engine";
@@ -97923,7 +98232,7 @@ self: {
      mkDerivation {
        pname = "nntp";
        version = "0.0.4";
-       sha256 = "1yg91zai4krxx7yqzskss19jjgh4nvc2vqzddvpwsdm07lri8g35";
+       sha256 = "653c14333da036cdef6eede32dd8b6043e2953d07aea8ffde93d4f12d50fe9f9";
        libraryHaskellDepends = [
          base bytestring monad-loops mtl network old-locale parsec time
        ];
@@ -97937,7 +98246,7 @@ self: {
      mkDerivation {
        pname = "no-role-annots";
        version = "1.1";
-       sha256 = "1kk9ii5w40di3azlqzbz4vkvwdz8apca0lh4jn94nvr3hns6l5s7";
+       sha256 = "47176ab485236f4b92950452a0d855e837bee7267f7d4cbf1ab101c24b8c69ce";
        libraryHaskellDepends = [ base template-haskell ];
        testHaskellDepends = [ base template-haskell ];
        homepage = "https://github.com/goldfirere/no-role-annots";
@@ -97950,7 +98259,7 @@ self: {
      mkDerivation {
        pname = "nofib-analyze";
        version = "7.10.1";
-       sha256 = "04n056gsxv61igdvdysqkxbsz1a5bvkzfnsbrz03ixjgaqg2whfl";
+       sha256 = "d4412e1e564ff638c0cf4b5bf7e75e4585af579f58fbb6db8bc1ecae9f29c012";
        isLibrary = false;
        isExecutable = true;
        executableHaskellDepends = [ array base containers regex-compat ];
@@ -97967,7 +98276,7 @@ self: {
      mkDerivation {
        pname = "noise";
        version = "0.0.1";
-       sha256 = "0h9aq4f8n1acmzhdq185y0adl35cf7avms6zvgsyf9lkx2msja0q";
+       sha256 = "1828a9abe89326e7f5dbdfe8bad571ac0cda14f00505dce0af4c058b1cc12a41";
        isLibrary = true;
        isExecutable = true;
        libraryHaskellDepends = [
@@ -97990,7 +98299,7 @@ self: {
      mkDerivation {
        pname = "non-empty";
        version = "0.2.1";
-       sha256 = "1p0jp44xlc77da5g5fq78vvgfv8r9z4m0axm36qbliv609rnp5g3";
+       sha256 = "e3956b73026647bab019b52b50c94f196df7f64607bbf28a6ae730da09b912dc";
        libraryHaskellDepends = [ base containers QuickCheck utility-ht ];
        homepage = "http://code.haskell.org/~thielema/non-empty/";
        description = "List-like structures with static restrictions on the number of elements";
@@ -98002,7 +98311,7 @@ self: {
      mkDerivation {
        pname = "non-negative";
        version = "0.1.1";
-       sha256 = "163g3j3xrx1jkrbg2wnha3yyxyg1mn7kabmbpg82y3rbl3ihy1p7";
+       sha256 = "e7060fe3a02b0f2fd0bbab2e358fade1f9eefd50d072f1569e32f4dc871c6f98";
        libraryHaskellDepends = [ base QuickCheck utility-ht ];
        testHaskellDepends = [ base QuickCheck utility-ht ];
        homepage = "http://code.haskell.org/~thielema/non-negative/";
@@ -98017,7 +98326,7 @@ self: {
      mkDerivation {
        pname = "nonce";
        version = "1.0.2";
-       sha256 = "1l4w6bdrwa42r90n6xzwr8lz2fdrn3m763ls311pnygajr4ih10h";
+       sha256 = "1004184996ea797b43189a0e73eab0b939f129cafc776341ca82289edb329cd0";
        libraryHaskellDepends = [
          base base64-bytestring bytestring cprng-aes crypto-random text
          transformers
@@ -98032,7 +98341,7 @@ self: {
      mkDerivation {
        pname = "nondeterminism";
        version = "1.0";
-       sha256 = "0hxfqrm51svmr9lk1i8l5ib5bi5zlc92q6k3qwnvkqz8qgb4w8i0";
+       sha256 = "20224ed6c3e8e3b92dc7631a2c12a3bfc455562c14c53069ca75eb506ac6ae43";
        libraryHaskellDepends = [ base containers mtl ];
        description = "A monad and monad transformer for nondeterministic computations";
        license = "LGPL";
@@ -98044,7 +98353,7 @@ self: {
      mkDerivation {
        pname = "nonfree";
        version = "0.1.0.1";
-       sha256 = "05jf3i9m58lwixd3mnj9ikgkrg1gdcxz7d8m5k5k5j3fdbbgbmqi";
+       sha256 = "11d7f5d66a6ec832cb2c15b5f33b6b2fbc3cdf8c49da3a5a8f9ca252531c4e16";
        libraryHaskellDepends = [ base ];
        description = "Free structures sans laws";
        license = stdenv.lib.licenses.mit;
@@ -98055,7 +98364,7 @@ self: {
      mkDerivation {
        pname = "nonlinear-optimization";
        version = "0.3.10";
-       sha256 = "11dq7fvysdb0szkg58f2wmx2vg6sa9qfj9kfv7wv6fl3386dnp7f";
+       sha256 = "ee5cdb0c1a833ab3f9d96e26e97052dabc2d7ae5c2a1f2e6d76035edb73bb885";
        libraryHaskellDepends = [ base primitive vector ];
        description = "Various iterative algorithms for optimization of nonlinear functions";
        license = "GPL";
@@ -98068,7 +98377,7 @@ self: {
      mkDerivation {
        pname = "nonlinear-optimization-ad";
        version = "0.2.1";
-       sha256 = "0k3iynppdvmm9asy1wddp8n3gmskh40dmcngqv8pgy5qx0bnx8jd";
+       sha256 = "4da26e17e8b8f877d1c6cfb2da008153d7372cbaadf1e0b54ab5ee76aff5714c";
        isLibrary = true;
        isExecutable = true;
        libraryHaskellDepends = [
@@ -98085,7 +98394,7 @@ self: {
      mkDerivation {
        pname = "noodle";
        version = "0.0.19";
-       sha256 = "08v5rz5skmaqxqj85l76kjxqmlhnf3vapgfdqd042cmh41zwznx0";
+       sha256 = "a0dbcf7f20b0324140c3cdbdabf67016d28abb9ce6d08224ee58d5a9cbcf6523";
        isLibrary = true;
        isExecutable = true;
        libraryHaskellDepends = [ base directory filepath ];
@@ -98101,7 +98410,7 @@ self: {
      mkDerivation {
        pname = "normaldistribution";
        version = "1.1.0.3";
-       sha256 = "1q7p0bx435amqb7r9qksix0mrbpnqsyfb44chjyz6xkgjj0s6yvd";
+       sha256 = "6d7ba381946f76f3bd848c90e5bcc6f6ae5c418f7ae294cfc2559541fa02f7e0";
        libraryHaskellDepends = [ base random ];
        homepage = "https://github.com/bjornbm/normaldistribution";
        description = "Minimum fuss normally distributed random values";
@@ -98116,7 +98425,7 @@ self: {
      mkDerivation {
        pname = "not-gloss";
        version = "0.7.5.0";
-       sha256 = "1r0mycb3ilz2k89vab08c1diz18mp03b5sds4ixmxfb0zqaz68lb";
+       sha256 = "8b22f315fe60b95e7b24bae9b206b815851f5b60082cb5139ae2d33816f315e4";
        libraryHaskellDepends = [
          base binary bmp bytestring cereal GLUT OpenGL OpenGLRaw
          spatial-math time vector vector-binary-instances
@@ -98132,7 +98441,7 @@ self: {
      mkDerivation {
        pname = "not-gloss-examples";
        version = "0.5.0";
-       sha256 = "0dszimvwb78ac1zfp25iy8lhnsq0grjs6zrsiyr1d80fj9kmg49y";
+       sha256 = "3e915767920ea016b28f3a7fa3657e006b0b29f2b188eb7e600a9dc5778d5f37";
        isLibrary = false;
        isExecutable = true;
        executableHaskellDepends = [
@@ -98148,7 +98457,7 @@ self: {
      mkDerivation {
        pname = "not-in-base";
        version = "0.1.1";
-       sha256 = "1mm1j0l3h8qxpk0bis4g1f6zp5407rkq2z5ldyr036frbvfwqaj5";
+       sha256 = "452accdd5ed99901b26fb47c81673e8094fb8d0b8fe8b8c0bc1d23382890a1d6";
        libraryHaskellDepends = [ base ];
        homepage = "http://github.com/finnsson/not-in-base";
        description = "Useful utility functions that only depend on base";
@@ -98160,7 +98469,7 @@ self: {
      mkDerivation {
        pname = "notcpp";
        version = "0.2.0.3";
-       sha256 = "15aa96zdz60x9wc9k8ad5qkc4bs5rbgm9xvsykf3ppyys2z449ca";
+       sha256 = "8a2542bed0dedf3bdcf47af754dfca452fc2262e4da199184f1d98dfbe494a95";
        libraryHaskellDepends = [ base template-haskell ];
        testHaskellDepends = [ base template-haskell ];
        description = "Avoiding the C preprocessor via cunning use of Template Haskell";
@@ -98174,7 +98483,7 @@ self: {
      mkDerivation {
        pname = "notmuch-haskell";
        version = "1.0.0.3";
-       sha256 = "0znbsvbjj3995mn04zaxgv0q90qplwjkwhwjkmz1k5jxajxgwwzj";
+       sha256 = "f273feba545d96197e9d92433e25a7178384c17e5d7d026c2d290d29d7d6cb7e";
        isLibrary = true;
        isExecutable = true;
        libraryHaskellDepends = [ base containers filepath time ];
@@ -98201,7 +98510,7 @@ self: {
      mkDerivation {
        pname = "notmuch-web";
        version = "0.2.0";
-       sha256 = "1jjk3fhzhpf9wrgk980rgp55kji5zjzdl0xyi4wgz3xvn1k8hrhs";
+       sha256 = "1a668866b0bb8fff3889be03dabefc25ca59ca7d19a0345fe6c95df8a11b53ca";
        isLibrary = true;
        isExecutable = true;
        libraryHaskellDepends = [
@@ -98233,7 +98542,7 @@ self: {
      mkDerivation {
        pname = "notzero";
        version = "0.0.10";
-       sha256 = "0g4l4b5f6m3da172k9n49zkcisbv88b3601zabb474l6a80zrz8p";
+       sha256 = "17fdfc0152869243d6523f003316427be9c8e64fc4a6294e506d54e3ca22943c";
        libraryHaskellDepends = [
          base bifunctors lens mtl semigroupoids semigroups transformers
        ];
@@ -98250,7 +98559,7 @@ self: {
      mkDerivation {
        pname = "np-extras";
        version = "0.3.0.1";
-       sha256 = "19mj868qpvaqmv8j83hcfyrspbg24bc2vdad3gp1wcrrpbj7ib0m";
+       sha256 = "15ac78e4ba39331eee1b4db52dd822e2adabb3770c0e24d1ae58ed8b9141b2a6";
        libraryHaskellDepends = [ base containers numeric-prelude primes ];
        description = "NumericPrelude extras";
        license = stdenv.lib.licenses.bsd3;
@@ -98263,7 +98572,7 @@ self: {
      mkDerivation {
        pname = "np-linear";
        version = "0.3.0.2";
-       sha256 = "00rmm36is8i6k1a0xyri61v09asc54fanlp5nai7k7vhp0wyfzz1";
+       sha256 = "e17fe739b8709f79a2b2e552ab1c294cab04763031fb0e549826221dcda83503";
        libraryHaskellDepends = [
          base binary containers numeric-prelude reflection tagged
        ];
@@ -98280,7 +98589,7 @@ self: {
      mkDerivation {
        pname = "nptools";
        version = "0.6.0";
-       sha256 = "1zipawfk8l98bszi1yviv7ph96x1z715d3nlzs3w2mzahir57h3d";
+       sha256 = "6dc0537284ea57c187fed48e56c2f9a19b04efd971fb10bf5e2851341d5737fe";
        isLibrary = false;
        isExecutable = true;
        executableHaskellDepends = [
@@ -98298,7 +98607,7 @@ self: {
      mkDerivation {
        pname = "nsis";
        version = "0.3";
-       sha256 = "0w7mip0dxpzdfdxj8gdk58zfz5n4aasd60ql546hx3yv5r65dbq3";
+       sha256 = "03af564c2edb8f0e0d291403d3b452c496ef3e2ab33d247b73eddfdec08df570";
        libraryHaskellDepends = [ base transformers uniplate ];
        testHaskellDepends = [
          base directory process transformers uniplate
@@ -98313,7 +98622,7 @@ self: {
      mkDerivation {
        pname = "nth-prime";
        version = "1.2";
-       sha256 = "0iq1658jfywni2yhk3aa1d4bnjjp8c9288bqfqxd8ayv87bvpirh";
+       sha256 = "30c7bbd741db2bd43a767821241243574abb480b4a8d09bd88967b2751310147";
        isLibrary = false;
        isExecutable = true;
        executableHaskellDepends = [
@@ -98331,7 +98640,7 @@ self: {
      mkDerivation {
        pname = "nthable";
        version = "0.1";
-       sha256 = "1qi1wq7wbnp3sv3c2v4185mnq80646vcsnqq16mqlshiy164wsly";
+       sha256 = "9e6a4e4cf0116a8aab09185bcdb62106206c6b41816cc1c6d6e3dac50fe621e2";
        libraryHaskellDepends = [ base type-level ];
        license = stdenv.lib.licenses.bsd3;
        hydraPlatforms = stdenv.lib.platforms.none;
@@ -98344,7 +98653,7 @@ self: {
      mkDerivation {
        pname = "ntp-control";
        version = "0.1";
-       sha256 = "14ns5lbvbdn0yrmfjp9rb4id19fxfd6dp68pgzm4lkh0xk0qnc4y";
+       sha256 = "9e308bc1ec004e4aea7f1799db4c73dda5d02259395de96af6c0b6b5172dda92";
        libraryHaskellDepends = [
          base bytestring bytestring-lexing cereal network old-locale time
        ];
@@ -98362,7 +98671,7 @@ self: {
      mkDerivation {
        pname = "null-canvas";
        version = "0.2.7";
-       sha256 = "1i6krgxlbdmv5md1p3n5mcw3sk24f5sk6y7yiznx8glxncxmfdll";
+       sha256 = "9436573bb39d3ed4ed8ffe78337571444c3d38abc58e1b5a2dbbb645fbcbd3c4";
        libraryHaskellDepends = [
          aeson base containers filepath scotty split stm text transformers
          wai-extra warp
@@ -98379,7 +98688,7 @@ self: {
      mkDerivation {
        pname = "number";
        version = "0.1.0.0";
-       sha256 = "1cl9s5qf7i0kixwqg27znmx4rvnckggpghs3hls77mq22igskd8p";
+       sha256 = "17b5a95f1402d773348543c377df9bccee4c7ab5ff8887798f13c4e370d189b2";
        libraryHaskellDepends = [ base ];
        description = "A library for real numbers";
        license = stdenv.lib.licenses.mit;
@@ -98390,7 +98699,7 @@ self: {
      mkDerivation {
        pname = "numbering";
        version = "0.2.1";
-       sha256 = "0hh4km2zbvs7rsb142f1rifqvwzajh0grgky2vyyyf48dk5plrlv";
+       sha256 = "9b667acb6c8838effd167ebefc0094eaf38d5dccc1091296ce47eff5459d0442";
        libraryHaskellDepends = [ base containers vector ];
        homepage = "https://github.com/DanielSchuessler/numbering";
        description = "Combinators for creating bijections from some type to the natural numbers";
@@ -98404,7 +98713,7 @@ self: {
      mkDerivation {
        pname = "numbers";
        version = "3000.2.0.1";
-       sha256 = "10z1bi5qbc81z5xx2v1ylwcpmcfl1ci7lxrswkgi0dd1wi8havbk";
+       sha256 = "736d0551e4a13510dfe43a777a220bd4b17a19a73e6cd17bf901b1854b5ce183";
        libraryHaskellDepends = [ base ];
        testHaskellDepends = [
          base QuickCheck test-framework test-framework-quickcheck2
@@ -98423,7 +98732,7 @@ self: {
      mkDerivation {
        pname = "numerals";
        version = "0.4";
-       sha256 = "1fkxlwf68bn353hs3622yqvlbndjnf263jbnh4q2rkj4xiirn4qm";
+       sha256 = "15139b63ec44ce2c308176c96184b3b2d94537f64298a1e128c32e641ca77dba";
        libraryHaskellDepends = [
          base base-unicode-symbols containers containers-unicode-symbols
          fingertree integer-gmp text
@@ -98447,7 +98756,7 @@ self: {
      mkDerivation {
        pname = "numerals-base";
        version = "0.3";
-       sha256 = "0qp9xhsqvs22siyfwjzffqc1kbpsanbxks3pbjfdcmbcwlq7hpg8";
+       sha256 = "e85d7830e56c55d69c5c77e8d99755faae191876ee4bee7cd442e88d35ece962";
        libraryHaskellDepends = [
          base base-unicode-symbols containers containers-unicode-symbols
          fingertree
@@ -98468,7 +98777,7 @@ self: {
      mkDerivation {
        pname = "numeric-extras";
        version = "0.0.3";
-       sha256 = "18jyjrk6iizz3sgkwgbh1rxf6zdf166bkgs7wia8b4z7f6261nzg";
+       sha256 = "efdb608471e7938554e447bfb98c09ae7de37a0e703d3e9f1effc76866965ea2";
        libraryHaskellDepends = [ base ];
        homepage = "http://github.com/ekmett/numeric-extras";
        description = "Useful tools from the C standard library";
@@ -98480,7 +98789,7 @@ self: {
      mkDerivation {
        pname = "numeric-limits";
        version = "0.1.0.0";
-       sha256 = "0lsi0my45lpd30vjbwdbzhisz8r3lryvg1c80qcmwipnxklnr5cb";
+       sha256 = "8b956ce9ecf6465e19068885b77da623a3af23fcabf1253718edd2427c055153";
        libraryHaskellDepends = [ base ];
        description = "Various floating point limit related constants";
        license = stdenv.lib.licenses.bsd3;
@@ -98493,7 +98802,7 @@ self: {
      mkDerivation {
        pname = "numeric-prelude";
        version = "0.4.2";
-       sha256 = "1i6qavz3av3dbf70li7yqsh184bl618l1sm9s9ia15srrkzsj9sk";
+       sha256 = "5327a9ffcc5997a062d2a9ea405130741114a0c6fe440a8e5b6d6c35fe56d8c4";
        revision = "1";
        editedCabalFile = "acbf128b14ff1177ed767ec9ebb89b1c3c0e998d5d031fdd0e4bc64ebc6bffe2";
        isLibrary = true;
@@ -98514,7 +98823,7 @@ self: {
      mkDerivation {
        pname = "numeric-qq";
        version = "0.1.2";
-       sha256 = "0zxiaiqzcg4z354wyvxl672ffswvhbqk6h6nvpgmydw84akpimcm";
+       sha256 = "95d578a72288375fdfddd64033f1829b6be7c431b46fcf49199f3cf67154b17f";
        libraryHaskellDepends = [
          base loch-th placeholders template-haskell
        ];
@@ -98531,7 +98840,7 @@ self: {
      mkDerivation {
        pname = "numeric-quest";
        version = "0.2.0.1";
-       sha256 = "110v2frn085pggjzl3l8wqgr4vcdd5h29x2wak2a59x16ngjg7ga";
+       sha256 = "ea9d279f35a1a7a2c4545cf42460698d6d921fe6880efae57bb72060b3131b84";
        revision = "1";
        editedCabalFile = "aae9d00f380bf447af5575311f566cd6960aafb7eec8c30abbab09a2fcff092e";
        libraryHaskellDepends = [ array base ];
@@ -98545,7 +98854,7 @@ self: {
      mkDerivation {
        pname = "numeric-tools";
        version = "0.2.0.1";
-       sha256 = "0frdsj90gqpa55ybjfkzfcda43bbwkqd2v26l6w35kyq1snqyhd3";
+       sha256 = "a3418fad0ed8cf32b8a1466cd1f0e46b0da21a737f3ab97c29eae20792d42d3b";
        libraryHaskellDepends = [ base ieee754 primitive vector ];
        testHaskellDepends = [ base HUnit ];
        homepage = "https://bitbucket.org/Shimuuar/numeric-tools";
@@ -98558,7 +98867,7 @@ self: {
      mkDerivation {
        pname = "numericpeano";
        version = "0.2.0.0";
-       sha256 = "1f9ar8kdwzi8xarzb7mrq204v1n3n8kh0fbqv06l9677vv1pc19v";
+       sha256 = "3b0576c3dee798440dd878390027b2c3864d80c0b99ef5b3ea287ede26ca2ab9";
        libraryHaskellDepends = [ base ];
        homepage = "https://github.com/ombocomp/numericpeano/";
        description = "Peano numbers with attendant bells and whistles";
@@ -98570,7 +98879,7 @@ self: {
      mkDerivation {
        pname = "nums";
        version = "1.2.0";
-       sha256 = "0bbl7f3qd26sa92k73qni3r1jwxxrfq5k19hcvh5rgdh5ig9d6v8";
+       sha256 = "689b965e2cb0bd5ce066308559b0cbbd7319f288168f334552da8886873b742d";
        description = "None";
        license = stdenv.lib.licenses.bsd3;
        hydraPlatforms = stdenv.lib.platforms.none;
@@ -98581,7 +98890,7 @@ self: {
      mkDerivation {
        pname = "numtype";
        version = "1.1";
-       sha256 = "1az10xcfl6qpyy9qnh8g2iqx53rxnjxzc1h8kl1gira6yv7g6857";
+       sha256 = "a720f3cef646e5f8029d0806f6bbb43d8fd271140f418b93f7171bea5807e1ab";
        libraryHaskellDepends = [ base ];
        homepage = "http://dimensional.googlecode.com/";
        description = "Type-level (low cardinality) integers";
@@ -98593,7 +98902,7 @@ self: {
      mkDerivation {
        pname = "numtype-dk";
        version = "0.5";
-       sha256 = "0gd1a5hf0bw4vc56f1n7y143bsjkdc97pysv4q1gxpwrnj1sgbxd";
+       sha256 = "adafa783b499dffe02265bfb7b126b53ea3548f0c706670adb842fe06051a13d";
        libraryHaskellDepends = [ base ];
        homepage = "https://github.com/bjornbm/numtype-dk";
        description = "Type-level integers, using TypeNats, Data Kinds, and Closed Type Families";
@@ -98605,7 +98914,7 @@ self: {
      mkDerivation {
        pname = "numtype-tf";
        version = "0.1.2";
-       sha256 = "00bnz9k4nq21z4vax37qjv6ra2jvlshk0jlici1w8y9rx39zrjyx";
+       sha256 = "ddcbfcd3e83979c44364914a30a1a65b0a95cd96f88cae36f941604b66fa7601";
        libraryHaskellDepends = [ base ];
        homepage = "http://dimensional.googlecode.com/";
        description = "Type-level (low cardinality) integers, implemented using type families";
@@ -98619,7 +98928,7 @@ self: {
      mkDerivation {
        pname = "nurbs";
        version = "0.1.0.0";
-       sha256 = "1rxg0d8j6srhw5mq0i6ma9dyqrx3h1c15pv3gj8brh8ghjw9z1wi";
+       sha256 = "91879fb8840fc1bc907c63df125880a367ec5b52d544806be1306b235103afe7";
        libraryHaskellDepends = [
          base base-unicode-symbols lens linear mtl
        ];
@@ -98643,7 +98952,7 @@ self: {
      mkDerivation {
        pname = "nvim-hs";
        version = "0.0.2";
-       sha256 = "0f551qr7dgn6p4slr0yyfw7v2c6j6w1haqzgc7n7phrgmnhvrhzp";
+       sha256 = "f7c3bca1ad2fc37bec61ef63050337d230b10f77de834c35b9c6be76320ea538";
        isLibrary = true;
        isExecutable = true;
        libraryHaskellDepends = [
@@ -98674,7 +98983,7 @@ self: {
      mkDerivation {
        pname = "nyan";
        version = "0.2";
-       sha256 = "02bcyb6ibb6m84d2r6pp05vbv9jv09v1lp35n18mn2vkrgwls649";
+       sha256 = "89184df9cb730b5b51b0655c1a76025ba6bd7601f79a2c1a41d5ac15cdf26c09";
        isLibrary = false;
        isExecutable = true;
        executableHaskellDepends = [ base bytestring mtl ncurses text ];
@@ -98689,7 +98998,7 @@ self: {
      mkDerivation {
        pname = "nymphaea";
        version = "0.3";
-       sha256 = "1nlnz7mvdkhcqp4v1fyfb6r6v18xpxi0ddqqp84dsqg6ahdypc13";
+       sha256 = "23b0eb1b54e661dd08ba18b70662bf1d856db259cebbb0c9c50cceb6ebf996da";
        isLibrary = false;
        isExecutable = true;
        executableHaskellDepends = [
@@ -98710,7 +99019,7 @@ self: {
      mkDerivation {
        pname = "oauthenticated";
        version = "0.1.3.4";
-       sha256 = "1l6qir6qnipq8295cljl66mhlws2rrqjvz9nsl7rq2ldqv711bbm";
+       sha256 = "75ad10cec68d0a9c0fd536fd2d71ce42730aab315452569240f8468b4d8ed8d0";
        libraryHaskellDepends = [
          aeson base base64-bytestring blaze-builder bytestring
          case-insensitive crypto-random cryptohash either exceptions
@@ -98727,7 +99036,7 @@ self: {
      mkDerivation {
        pname = "obdd";
        version = "0.3.2";
-       sha256 = "0dck1jaw2smvnc1cdjmxjchsxsjw14h98y58lm5z0ccl3rfjr1hw";
+       sha256 = "1c862c5d1e9431f04ba5a8789420095ceaae2193bdcac602b3bb6ac1950c9335";
        libraryHaskellDepends = [ array base containers mtl random ];
        homepage = "https://github.com/jwaldmann/haskell-obdd";
        description = "Ordered Reduced Binary Decision Diagrams";
@@ -98742,7 +99051,7 @@ self: {
      mkDerivation {
        pname = "oberon0";
        version = "0.0.2";
-       sha256 = "0w8ygppqr1mjklc0545z2n503ap5xzxmjw2xsmb0i85nmh6f95hv";
+       sha256 = "1b96e40cacb6a00856d55d7059fbefe5aa018a15bf9002189db2868cef7d1e71";
        isLibrary = true;
        isExecutable = true;
        libraryHaskellDepends = [
@@ -98768,7 +99077,7 @@ self: {
      mkDerivation {
        pname = "obj";
        version = "0.1.2";
-       sha256 = "0w9yyyd2i88lkhqlghnf7zkrx0sql5w8vwx67j9j1jr7d5zrad4z";
+       sha256 = "9f34957f6927cb20933ca6f38d78a158839ee73fcec247319c14a1289af73e71";
        libraryHaskellDepends = [
          array base binary bytestring checkers Codec-Image-DevIL containers
          directory filepath graphicsFormats haskell98 InfixApplicative
@@ -98787,7 +99096,7 @@ self: {
      mkDerivation {
        pname = "objectid";
        version = "0.1.0.2";
-       sha256 = "1cr9hzrkj8a6ggym8d6gyy0rmric93x8xwdjqfal10bg5s6d6vgs";
+       sha256 = "fa6dd38c2e6f814095c3b2f18efa482ce69a81f7cf3454fd7b462139f38729b3";
        libraryHaskellDepends = [
          base blaze-builder bytestring cereal cryptohash
        ];
@@ -98810,7 +99119,7 @@ self: {
      mkDerivation {
        pname = "objective";
        version = "1.0.5";
-       sha256 = "07v1srbzd2sxwfwi1jrq63jycr46hwq4wh6wi7sgdpla5m28mhyh";
+       sha256 = "d0c38a442d8adef6f489dc404e30878664e6e53038cb10b9e35d8bf657d6611f";
        libraryHaskellDepends = [
          base containers either exceptions free hashable monad-skeleton
          monad-stm mtl profunctors stm template-haskell transformers
@@ -98826,7 +99135,7 @@ self: {
      mkDerivation {
        pname = "observable-sharing";
        version = "0.2.1.2";
-       sha256 = "0f2da4bxid9ap21p0l6vf8czg84ifnzq1ljj1h4qy95ydv2bc0za";
+       sha256 = "ea03b6c46ebe248f090c52d280bf7591a0f71972db507083b82ab5d817514d38";
        libraryHaskellDepends = [ base containers ];
        homepage = "https://github.com/atzeus/observable-sharing";
        description = "Simple observable sharing";
@@ -98844,7 +99153,7 @@ self: {
      mkDerivation {
        pname = "octohat";
        version = "0.1.4.2";
-       sha256 = "0say5682zqv4ss6q9v4p171vprdl6aa7aaack1y0526qq7gj05l2";
+       sha256 = "821620dfc1d888027c984c29759432b4e5bbc30997ec848dd664e32f90295e69";
        isLibrary = true;
        isExecutable = true;
        libraryHaskellDepends = [
@@ -98872,7 +99181,7 @@ self: {
      mkDerivation {
        pname = "octopus";
        version = "0.0.2.1";
-       sha256 = "1p1sf694a5zryvb2i38ygd7fby54pqi0v5r3b24wcpwj43dy57ca";
+       sha256 = "8a9de2db20925fc6895823970d22bea4f8e54e7b1e8d28d6f6f9174592713adc";
        isLibrary = true;
        isExecutable = true;
        libraryHaskellDepends = [
@@ -98895,7 +99204,7 @@ self: {
      mkDerivation {
        pname = "oculus";
        version = "0.1.0.2";
-       sha256 = "04015wbh5j36gd66k7fn12nl92lq68d0c9dia8fz0pr8y3b7ims4";
+       sha256 = "44d778d6f0285ff01d52b125061a32988a44ad08d69d694c7b66c802172f0110";
        libraryHaskellDepends = [
          base either monads-tf transformers vect-floating
        ];
@@ -98916,7 +99225,7 @@ self: {
      mkDerivation {
        pname = "oeis";
        version = "0.3.6";
-       sha256 = "1q7ywczm2d5inrjqgz3j8vfk5sj2yixvwdkzlfs2whd0gadbcfa0";
+       sha256 = "4039b69a7aa0412eb4a37f36be7bf442ea32dd4672fc8765b6b134513fe3fee0";
        libraryHaskellDepends = [ base HTTP network network-uri ];
        testHaskellDepends = [
          base HUnit test-framework test-framework-hunit
@@ -98930,7 +99239,7 @@ self: {
      mkDerivation {
        pname = "off-simple";
        version = "0.1";
-       sha256 = "03sb2bmjw8v01908zkzmw8njsmqy5k2hcnv6ajbia7n8qawyhivj";
+       sha256 = "7247e8b9c2c81e159754665b06c52c1e572d2de2f5cf8f400a60232eeb124b0f";
        libraryHaskellDepends = [ base parsec3 vector ];
        jailbreak = true;
        homepage = "https://github.com/acfoltzer/off-simple";
@@ -98943,7 +99252,7 @@ self: {
      mkDerivation {
        pname = "ofx";
        version = "0.4.0.2";
-       sha256 = "0vhr2pydnfc0ma7w1qdn5p5yylzlj3n47fnm16mlbhlb5ydnjshg";
+       sha256 = "0f6a699b2f8bc245ab09d5ba43ec90f453efcb2db6e1c08faa8039dbfc15196e";
        libraryHaskellDepends = [ base parsec pretty time ];
        homepage = "http://www.github.com/massysett/ofx";
        description = "Parser for OFX data";
@@ -98959,7 +99268,7 @@ self: {
      mkDerivation {
        pname = "ohloh-hs";
        version = "0.0.2";
-       sha256 = "0nbk24ymkkjrapxa83qzhzl1m7zi3bxdc9jsjkbqvb7r9nz3jhyj";
+       sha256 = "d24339be4df9ac8dd7945a26d6fa1af19f1ae8871f0fa4fa5559ce593d117359";
        isLibrary = true;
        isExecutable = true;
        libraryHaskellDepends = [ base data-lens hxt text-format-simple ];
@@ -98983,7 +99292,7 @@ self: {
      mkDerivation {
        pname = "oi";
        version = "0.3.1";
-       sha256 = "14q8map7r2cc8jcfhczyb16br553h2m9xf40qm34l6pb9l1bzn2p";
+       sha256 = "57d8bf024deb1a4a46c580b89eaa80a394bc4c58fe33e898448c897caeaa0893";
        libraryHaskellDepends = [
          base comonad directory filepath parallel SafeSemaphore
        ];
@@ -98997,7 +99306,7 @@ self: {
      mkDerivation {
        pname = "ois-input-manager";
        version = "0.1.0.1";
-       sha256 = "1p34xybkf5079pq5hkildaz6skx06f6s3qg0k2i73jhh93q3ckiq";
+       sha256 = "384e36f04810ca71a298e0e1a18d33a04f6dbe6a344e58f04d07143797ef64dc";
        libraryHaskellDepends = [ base hogre ];
        librarySystemDepends = [ OIS ];
        jailbreak = true;
@@ -99011,7 +99320,7 @@ self: {
      mkDerivation {
        pname = "old-locale";
        version = "1.0.0.7";
-       sha256 = "0l3viphiszvz5wqzg7a45zp40grwlab941q5ay29iyw8p3v8pbyv";
+       sha256 = "dbaf8bf6b888fb98845705079296a23c3f40ee2f449df7312f7f7f1de18d7b50";
        libraryHaskellDepends = [ base ];
        description = "locale library";
        license = stdenv.lib.licenses.bsd3;
@@ -99022,7 +99331,7 @@ self: {
      mkDerivation {
        pname = "old-time";
        version = "1.1.0.3";
-       sha256 = "1h9b26s3kfh2k0ih4383w90ibji6n0iwamxp6rfp2lbq1y5ibjqw";
+       sha256 = "1ccb158b0f7851715d36b757c523b026ca1541e2030d02239802ba39b4112bc1";
        libraryHaskellDepends = [ base old-locale ];
        description = "Time library";
        license = stdenv.lib.licenses.bsd3;
@@ -99033,7 +99342,7 @@ self: {
      mkDerivation {
        pname = "old-version";
        version = "1.4.2";
-       sha256 = "1sqga2fmrc702k2grv2kw32wg0yy8qy94cs1jl6112xk6lb79qb3";
+       sha256 = "63e1741635b38b100c954133923c46de83c7c5e053ecfcc414e0b05c9d500feb";
        libraryHaskellDepends = [ base ];
        jailbreak = true;
        description = "Basic versioning library";
@@ -99048,7 +99357,7 @@ self: {
      mkDerivation {
        pname = "olwrapper";
        version = "0.4.1";
-       sha256 = "0cnkanaxsrsshk2y37sbvyyzc40k61r57zb0c3jarz583h3yzlai";
+       sha256 = "51d1ef071ca8fcace46060fd5372301310f6bddf4b9fe1c5845a67dd9555d332";
        revision = "1";
        editedCabalFile = "44d11ed6751baf0383e968d36adca3c1ab49450cb0e147c1496feba468087e90";
        isLibrary = true;
@@ -99073,7 +99382,7 @@ self: {
      mkDerivation {
        pname = "omaketex";
        version = "0.1.1.0";
-       sha256 = "0kq2j8pndzn3fjdklyh22vcg8am48i29gx4jq2i74p4gmdryavn9";
+       sha256 = "c96ee573ab8f5c72a2c092f4974444a42af4d816027a3a9b74c3fe662f92024f";
        isLibrary = false;
        isExecutable = true;
        executableHaskellDepends = [
@@ -99093,7 +99402,7 @@ self: {
      mkDerivation {
        pname = "omega";
        version = "1.5.2";
-       sha256 = "0v11j2gz98g5ng9dsfbr7k3a2xhw2xqa1qi1q8ad53sx2yhjv0ly";
+       sha256 = "9e822da1175d8fd214c221e2a070171c76a1c63c7939ddd2b3e5a1f49f90216c";
        isLibrary = false;
        isExecutable = true;
        executableHaskellDepends = [
@@ -99112,7 +99421,7 @@ self: {
      mkDerivation {
        pname = "omnicodec";
        version = "0.7";
-       sha256 = "18xkwsinfjvd20249bm3z0qvsi51j776ifqa6vkrrl186pwa8im7";
+       sha256 = "a746a4f83528d09ce7360abb68ce91a144bd31f8a3ae4404106d4b67a3e6b3a3";
        isLibrary = false;
        isExecutable = true;
        executableHaskellDepends = [
@@ -99132,7 +99441,7 @@ self: {
      mkDerivation {
        pname = "on-a-horse";
        version = "0.3";
-       sha256 = "18nbvdbdg05fmymbvvhig6invr6ald0gdadl666m4axc8m9n6pvg";
+       sha256 = "6f5f635345ac2b528d31b4a9f640a3cae46da37911eebdaaafae80d756dbcba2";
        libraryHaskellDepends = [
          arrows base bytestring case-insensitive containers cookie
          http-types mtl random safe split text time transformers utf8-string
@@ -99151,7 +99460,7 @@ self: {
      mkDerivation {
        pname = "on-demand-ssh-tunnel";
        version = "0.1.0.6";
-       sha256 = "0pmkaw3w69nf928z263my7q0l2zi2v4yx5w49warbgv66h00wgkz";
+       sha256 = "7f3e0e003466bf95154f8497eec916f10b0af0f17518f19148ce26c30757b35e";
        isLibrary = true;
        isExecutable = true;
        libraryHaskellDepends = [
@@ -99170,7 +99479,7 @@ self: {
      mkDerivation {
        pname = "one-liner";
        version = "0.5.1";
-       sha256 = "0nb3cix82nvs06v5mv1xa6076j5cvwyx2jrn7dmyrpf67a76kfh0";
+       sha256 = "00ba698e3ac6ddec6b3b364bd13ddfac487380513dec5ab6017a5b817a646359";
        libraryHaskellDepends = [
          base contravariant ghc-prim transformers
        ];
@@ -99187,7 +99496,7 @@ self: {
      mkDerivation {
        pname = "one-time-password";
        version = "1.0.0.1";
-       sha256 = "1kpwx8lpk764qva536v9x7xskjy94rj8xwwnhsqakps6r29c7qa0";
+       sha256 = "40e1c392c846dfa9b08696f38e6426c9cba9fbe9699b51d4c6c49c7929eafcce";
        libraryHaskellDepends = [
          base byteable bytestring cereal cryptohash time
        ];
@@ -99204,7 +99513,7 @@ self: {
      mkDerivation {
        pname = "oneOfN";
        version = "0.1.0.1";
-       sha256 = "05gycp2zvq08bjl9dx1lm3cjr12i50k3cwq4al34y1rlp2r531lk";
+       sha256 = "938651b2b834074f0655047336262851842cd9a834f496a85c08e0fdc565fe15";
        libraryHaskellDepends = [ base ];
        homepage = "https://github.com/mokus0/oneOfN";
        description = "Anonymous coproduct type";
@@ -99216,7 +99525,7 @@ self: {
      mkDerivation {
        pname = "oneormore";
        version = "0.1.0.3";
-       sha256 = "1lz429abk7qqwfya3wa1m5pcyyldagcmmc0ghjfbl8byhkaax63p";
+       sha256 = "7798aed4847e21ba9c840fb05ad9538d7acf6ea941f1a1bce3189fb95412e4d3";
        libraryHaskellDepends = [ base ];
        jailbreak = true;
        homepage = "https://github.com/thinkpad20/oneormore";
@@ -99230,7 +99539,7 @@ self: {
      mkDerivation {
        pname = "only";
        version = "0.0.6.0";
-       sha256 = "17c9yy0fshxhpdfqb6hi23kvnvvckcdmlr2dffpgx4cg9znh62s1";
+       sha256 = "410b03ed4f8f91feae734d645a1b9b6c6fbbe710119a855dbbb043ed80f7899d";
        isLibrary = false;
        isExecutable = true;
        executableHaskellDepends = [ base parsec regex-compat ];
@@ -99243,7 +99552,7 @@ self: {
      mkDerivation {
        pname = "onu-course";
        version = "1";
-       sha256 = "1d0yn5bj04ircxbi12rx80kds54zssmq4j9kqyk05nmv506x76k0";
+       sha256 = "609ad30d28bbda02a6c7334982abd69f14dd26403d8b10576739122057b11eb4";
        libraryHaskellDepends = [ base smallcheck ];
        description = "Code for the Haskell course taught at the Odessa National University in 2012";
        license = stdenv.lib.licenses.mit;
@@ -99255,7 +99564,7 @@ self: {
      mkDerivation {
        pname = "oo-prototypes";
        version = "0.1.0.0";
-       sha256 = "0xpm2adf47clhzpwd833w706mc5xfxwr2wp4aywigy11687f9bly";
+       sha256 = "9eaee40e3221f817b957e472917977bdb06ac0e163a0c6ef87941de29a12f576";
        libraryHaskellDepends = [ base ];
        homepage = "https://github.com/yi-editor/oo-prototypes";
        description = "Support for OO-like prototypes";
@@ -99271,7 +99580,7 @@ self: {
      mkDerivation {
        pname = "opaleye";
        version = "0.4.0.0";
-       sha256 = "1dzfxy5r2phqcnijvq74ardjg9p2mlkpidg95dd3v9qiz1ls71rk";
+       sha256 = "3387a369f811a73d5a2be9b57827ade2a6275b56e4e02da365185e918befeeb7";
        libraryHaskellDepends = [
          attoparsec base base16-bytestring bytestring case-insensitive
          contravariant postgresql-simple pretty product-profunctors
@@ -99297,7 +99606,7 @@ self: {
      mkDerivation {
        pname = "opaleye-sqlite";
        version = "0.0.1.0";
-       sha256 = "0r3ij02wkxq50hl70wn53fdr1qi5gigg4x3y0vabm53gabgxdbxq";
+       sha256 = "b8afd6df526f94bad4067e74f25e7c25e2909b1bc57270280405f7c905907164";
        libraryHaskellDepends = [
          base base16-bytestring bytestring case-insensitive contravariant
          direct-sqlite pretty product-profunctors profunctors semigroups
@@ -99317,7 +99626,7 @@ self: {
      mkDerivation {
        pname = "open-browser";
        version = "0.2.0.0";
-       sha256 = "093i475l9gyb5jyk2m6fdz1dw2jm545rlrbmwqz3vfdfy2ikcks3";
+       sha256 = "434f36a3f0aeb93d3ee675659a0b29550adec26fce5431bd2ccbbf44cb217124";
        isLibrary = true;
        isExecutable = true;
        libraryHaskellDepends = [ base process ];
@@ -99335,7 +99644,7 @@ self: {
      mkDerivation {
        pname = "open-pandoc";
        version = "1.5.1.1";
-       sha256 = "1k9d1r1z7q6lm8fha630rg2qfmwwnr9dv2ajvqwvrki2m6i9sczn";
+       sha256 = "f6339da2a922cebc39de5289dd52b69c5787c5cb6018051daad4e0f3430e2dcd";
        isLibrary = true;
        isExecutable = true;
        libraryHaskellDepends = [
@@ -99354,7 +99663,7 @@ self: {
      mkDerivation {
        pname = "open-typerep";
        version = "0.3.1";
-       sha256 = "1wx3rh7fzq5d4g45k4fjwv0yh5grcqpvzlf2ixkni20d9rhb0yzs";
+       sha256 = "fa7bb0604e0d8868678fc2d1bf2f66f915e8c1e6d29159c823ade0ef0ecca3f3";
        libraryHaskellDepends = [ base constraints mtl syntactic tagged ];
        testHaskellDepends = [ base ];
        homepage = "https://github.com/emilaxelsson/open-typerep";
@@ -99367,7 +99676,7 @@ self: {
      mkDerivation {
        pname = "open-union";
        version = "0.1.0.1";
-       sha256 = "1dkz7a5k86r74lnf891grn48q8agkmd81czfp1g4l4dnxslldsqw";
+       sha256 = "1ceb46a9eeb6114a5eb8eeb3805a9d4f218c88cd2f24e42c25271b348b3a7fb6";
        isLibrary = true;
        isExecutable = true;
        libraryHaskellDepends = [ base ];
@@ -99383,7 +99692,7 @@ self: {
      mkDerivation {
        pname = "open-witness";
        version = "0.1.1";
-       sha256 = "1i38lhy1wla0xqgcbyf06179r1hs6194wqd8gg26q491ddc0vp3l";
+       sha256 = "74dc0d586b21116cc47ba8614e52301a869c4e30c0f9c51eee40511e3ca468c4";
        libraryHaskellDepends = [ base mtl witness ];
        jailbreak = true;
        description = "open witnesses";
@@ -99396,7 +99705,7 @@ self: {
      mkDerivation {
        pname = "opencv-raw";
        version = "0.1.0.0";
-       sha256 = "040hjkqd2zqkd8zbnfv8wmyzkfgckiv4njryilx1gpyp7c6qxpwn";
+       sha256 = "96df8e0d3bd7df173a8d3e4b4b769cecb9f97de5683bbb3e6a137fd1f0941010";
        libraryHaskellDepends = [ base bindings-DSL Cabal vector ];
        libraryPkgconfigDepends = [ opencv ];
        jailbreak = true;
@@ -99411,7 +99720,7 @@ self: {
      mkDerivation {
        pname = "opendatatable";
        version = "0.0.0";
-       sha256 = "1bv729ljw07arz9fzg0nqj6fkpwkxkjds073cz3zr9in0a5b1531";
+       sha256 = "6194b08a0236a6fcc767e300dde4ec93dfe98cc416bcefd2cfea002e691267af";
        libraryHaskellDepends = [ base hxt template-haskell th-lift ];
        jailbreak = true;
        homepage = "https://github.com/fabianbergmark/OpenDataTable";
@@ -99426,7 +99735,7 @@ self: {
      mkDerivation {
        pname = "openexchangerates";
        version = "0.1.0.0";
-       sha256 = "0ci1hfdcf0msn3j5l42z4pnn9sw77r0a4anlqsrnl2vrcpfs3j8l";
+       sha256 = "14c9a1dd65790b6ab3c6d42aa2403e87eb64ed255f105ae4b0ba02c79a832132";
        libraryHaskellDepends = [
          aeson base containers currency errors HTTP network text
        ];
@@ -99443,7 +99752,7 @@ self: {
      mkDerivation {
        pname = "openflow";
        version = "0.3.0";
-       sha256 = "0dhg34s4imr1v6wlc567qg5929wa82my7jbhxm9hqq0882vb0sb2";
+       sha256 = "6269b0b64008600c53ed70c9e3ab408a2791cac3c71446b9d921d74834190f36";
        libraryHaskellDepends = [
          aeson base bimap binary bytestring containers deepseq-generics
          hashable network
@@ -99462,7 +99771,7 @@ self: {
      mkDerivation {
        pname = "opengles";
        version = "0.7.0";
-       sha256 = "0vzd1dfg772947h4wny1fsskgdfxk31q86n0p507vmd7pxz6m5dj";
+       sha256 = "b2956a7ebfa7d57d40b9c01a84c398ddb537b576c15b4ee021499cf35c0bed6f";
        libraryHaskellDepends = [
          base bytestring distributive future-resource ghc-prim lens linear
          packer vector
@@ -99481,7 +99790,7 @@ self: {
      mkDerivation {
        pname = "openid";
        version = "0.2.0.2";
-       sha256 = "0rhd2hz3ls9ifcrifxhd4qvd7axydnlk5gckxay55dp2lcfc4css";
+       sha256 = "5a33c21ca3e2b652bcea93bd32a96dbeabd336260d7617337331693a3e140d66";
        isLibrary = true;
        isExecutable = true;
        libraryHaskellDepends = [
@@ -99501,7 +99810,7 @@ self: {
      mkDerivation {
        pname = "openpgp";
        version = "0.6.1";
-       sha256 = "03sdl0nzxnqbg8cnkglxkbz5xh5s57n6qgdjdnd82sdz139ia69s";
+       sha256 = "3a1915d308bf69819a6db23d6cec29bac05efe9a9dbe69197a0bdbfe2da04d0f";
        libraryHaskellDepends = [
          base binary bytestring bzlib utf8-string zlib
        ];
@@ -99523,7 +99832,7 @@ self: {
      mkDerivation {
        pname = "openpgp-Crypto";
        version = "0.5";
-       sha256 = "0gsdzfg378j7s2kpryg43ajxcdk8s5szk0yq48qfvnlsbgrxz07r";
+       sha256 = "f980dff35b9adaed3022d883f975d16836d6a51ae4f97ca7d047a2339efb4d3f";
        libraryHaskellDepends = [
          base binary bytestring Crypto openpgp utf8-string
        ];
@@ -99546,7 +99855,7 @@ self: {
      mkDerivation {
        pname = "openpgp-asciiarmor";
        version = "0.1";
-       sha256 = "1xrv0n7n1n8izvxvqm8wmj6mkn5l6wcq18bxs9zd1q5riynmmm2w";
+       sha256 = "5cd45aad8fb9e0d07ed27da1801937b4d8598dac1c55bcfbfe11d9608f053bf7";
        libraryHaskellDepends = [
          attoparsec base base64-bytestring bytestring cereal
        ];
@@ -99569,7 +99878,7 @@ self: {
      mkDerivation {
        pname = "openpgp-crypto-api";
        version = "0.6.3";
-       sha256 = "18grb5jzf7n4670xww3ca2l05ck3lj2msynl57y5fjia8gfr8ijm";
+       sha256 = "554694dd432a4a57fc29d47a5d85a463b202a8506c70dec131c41ef76559f9a1";
        libraryHaskellDepends = [
          base binary bytestring cereal crypto-api cryptocipher cryptohash
          openpgp tagged transformers
@@ -99594,7 +99903,7 @@ self: {
      mkDerivation {
        pname = "opensoundcontrol-ht";
        version = "0.3";
-       sha256 = "154bviaqkh9a02li6f2351764wgy0b0lh4a4s0wg8ql7ml0fykza";
+       sha256 = "ea4fef00ad8762f438d0441148c102fe71624e28433813a9002ac18955dc8b94";
        libraryHaskellDepends = [
          base binary bytestring hosc process random transformers utility-ht
        ];
@@ -99610,7 +99919,7 @@ self: {
      mkDerivation {
        pname = "openssh-github-keys";
        version = "0.1.1.0";
-       sha256 = "0a7vfbw84p3iyggq92yhw2dcsmk1cycxaq3v1104i7ipr2kdm36a";
+       sha256 = "ca8cdaa6c8379e4840087b60d599676156cd9ae0d08b84dff3715c82f872fb28";
        isLibrary = true;
        isExecutable = true;
        libraryHaskellDepends = [ base octohat text ];
@@ -99632,7 +99941,7 @@ self: {
      mkDerivation {
        pname = "openssl-createkey";
        version = "0.1";
-       sha256 = "1p59wlkirz4dwyhsnzzzbvy2cwfizn2zky5sxrsmnrzfkbpx1ig5";
+       sha256 = "e5c5d0ef9aee675b75eebaf8f985fdd17126fc5eff7faba1e78dfc1c27e5a9dc";
        libraryHaskellDepends = [ base directory HsOpenSSL time unix ];
        description = "Create OpenSSL keypairs";
        license = stdenv.lib.licenses.bsd3;
@@ -99645,7 +99954,7 @@ self: {
      mkDerivation {
        pname = "openssl-streams";
        version = "1.2.1.0";
-       sha256 = "1jqrc9wxvw196vgcbhpazi9vldqs31jb6jxc529iy9k7vh4mk5m9";
+       sha256 = "a9965909dc67261f9328ac4bb364181a37ba53fceac2c5de3629f0dd796219cb";
        libraryHaskellDepends = [
          base bytestring HsOpenSSL io-streams network
        ];
@@ -99662,7 +99971,7 @@ self: {
      mkDerivation {
        pname = "opentheory";
        version = "1.200";
-       sha256 = "0fdxrpsw3c4p1y80xfab0cl5zhkjcp9dlylgxywzq5kcpqv07ifh";
+       sha256 = "d0c50336be6c16fcb9ef8f7adad26572c25f28034bb90e900f97b0c1f5cdbd39";
        libraryHaskellDepends = [ base opentheory-primitive QuickCheck ];
        testHaskellDepends = [ base opentheory-primitive QuickCheck ];
        homepage = "http://opentheory.gilith.com/?pkg=base";
@@ -99677,7 +99986,7 @@ self: {
      mkDerivation {
        pname = "opentheory-bits";
        version = "1.66";
-       sha256 = "1qjgrmi05ay4qss6w5ld4pmksb3lsscqpw0x2dcdkja1i5hfpwfj";
+       sha256 = "d2f1eb608941c9d958131df08b99d6742c3deb258d166eb4c6c4ab0262cd4fe2";
        libraryHaskellDepends = [
          base opentheory opentheory-primitive opentheory-probability
          QuickCheck
@@ -99695,7 +100004,7 @@ self: {
      mkDerivation {
        pname = "opentheory-byte";
        version = "1.126";
-       sha256 = "0zlfik0irikrwk706fdjqb10z5jck3ldlsw269mfwlz6s1d5j2qz";
+       sha256 = "1f0b595ad0e653ee6a32826bdae8984c960fc2c2b23903cee479c61cc18c8e7e";
        libraryHaskellDepends = [
          base opentheory opentheory-bits opentheory-primitive
          opentheory-probability QuickCheck
@@ -99713,7 +100022,7 @@ self: {
      mkDerivation {
        pname = "opentheory-char";
        version = "1.41";
-       sha256 = "0z0dg3bgck8yjn45a7i5ymx2gm9i5m9skmg0n1cg7p6hgdka9j9i";
+       sha256 = "31c9a4667bd0dcf358b0e0d5a9532d31d5277af5251e5588951e4df6d6780d7c";
        isLibrary = true;
        isExecutable = true;
        libraryHaskellDepends = [
@@ -99736,7 +100045,7 @@ self: {
      mkDerivation {
        pname = "opentheory-divides";
        version = "1.63";
-       sha256 = "1jax8103yhgmbwfzbpnis4nj6f90n3wizb2znvafd4pw2afs5mkv";
+       sha256 = "7bd6a29d12fc92e6d4b65fac1ff9b02039232dd1d1def51d5ff5413f40405dc9";
        libraryHaskellDepends = [
          base opentheory opentheory-primitive QuickCheck
        ];
@@ -99755,7 +100064,7 @@ self: {
      mkDerivation {
        pname = "opentheory-fibonacci";
        version = "1.69";
-       sha256 = "09rqz7fixh1k4ya1aci7v0wy0sz2m7j5cj66plcbvpv6p03yq1vv";
+       sha256 = "7b07ec07b866dfbd18bdc64856e4a9e26be039d8273215942733c01eddf93827";
        libraryHaskellDepends = [
          base opentheory opentheory-primitive opentheory-stream QuickCheck
        ];
@@ -99772,7 +100081,7 @@ self: {
      mkDerivation {
        pname = "opentheory-parser";
        version = "1.158";
-       sha256 = "0325g7m5z64dg8sihmcgi9rmkms6r76hf1d7927v08dl5xh4dlhi";
+       sha256 = "11d246602fb421b08f48a70507cdc946d759738a8f5518357a8d985fea79450c";
        libraryHaskellDepends = [
          base opentheory opentheory-primitive QuickCheck
        ];
@@ -99792,7 +100101,7 @@ self: {
      mkDerivation {
        pname = "opentheory-prime";
        version = "1.82";
-       sha256 = "1x6sir4abr34cghmhbyv5qfd847xbbxg88qaw1vs3sa5lhb5dm8s";
+       sha256 = "1ad55616a445e9a177e00a23f4fa5afd10d41c2edb2f58e16364e4a5488edaf4";
        libraryHaskellDepends = [
          base opentheory opentheory-divides opentheory-primitive
          opentheory-stream QuickCheck
@@ -99812,7 +100121,7 @@ self: {
      mkDerivation {
        pname = "opentheory-primitive";
        version = "1.7";
-       sha256 = "02lg02w4sds1489bfz4hwgnhd9l6a1l7r9pwjd3s16yj2hbmr6jn";
+       sha256 = "569a5c1714d29ba04793fca67c685086a606ede3907cb7122241374db8008f0a";
        libraryHaskellDepends = [ base QuickCheck random ];
        testHaskellDepends = [ base QuickCheck random ];
        homepage = "http://www.gilith.com/research/opentheory/";
@@ -99826,7 +100135,7 @@ self: {
      mkDerivation {
        pname = "opentheory-probability";
        version = "1.49";
-       sha256 = "0dszjszjdabgafpvxiailpgzm7y96f4a8zhjfhin3m36f3lb0dmy";
+       sha256 = "be36b0e87066d4612374127ea48833c99ffadfa551c5beaf536fa926bf965f37";
        libraryHaskellDepends = [
          base opentheory opentheory-primitive QuickCheck
        ];
@@ -99842,7 +100151,7 @@ self: {
      mkDerivation {
        pname = "opentheory-stream";
        version = "1.46";
-       sha256 = "0p27hvxxxl6x6g97llls8kry5vlmpi5b02x9x96v24m4clxj55wa";
+       sha256 = "8a97223b65a412b14deaa90bb04abc95eee2f3449a527ad233ddd0defb86475c";
        libraryHaskellDepends = [
          base opentheory opentheory-primitive QuickCheck
        ];
@@ -99859,7 +100168,7 @@ self: {
      mkDerivation {
        pname = "opentheory-unicode";
        version = "1.140";
-       sha256 = "1w916hc6qn8bf5z95b43aqm25mbivlg7b4q91g5s6gy3q1f4iqna";
+       sha256 = "cae2485cc0c33fa3cb0b0993751edd71d5222a5683ac927e710b596c183421f1";
        libraryHaskellDepends = [
          base opentheory opentheory-bits opentheory-byte opentheory-parser
          opentheory-primitive opentheory-probability QuickCheck
@@ -99879,7 +100188,7 @@ self: {
      mkDerivation {
        pname = "operational";
        version = "0.2.3.2";
-       sha256 = "1aj3jhiyz4190b0qmyp684b8lbzrp8jn56s898892rvbp0hxa0pd";
+       sha256 = "ed02d521b86b6791104a489b6225baf92f8a1641e6fa8ac1022990ef239443aa";
        isLibrary = true;
        isExecutable = true;
        libraryHaskellDepends = [ base mtl ];
@@ -99894,7 +100203,7 @@ self: {
      mkDerivation {
        pname = "operational-class";
        version = "0.3.0.0";
-       sha256 = "02z766b5a6fa7dgmw3qa1xryijf2im9n79gnjq0m5pd2hv5vja4b";
+       sha256 = "8b28b9cb86a2dd520196f6a563538dc2c9e8730f0a0f5e5f3bca19559631e70b";
        libraryHaskellDepends = [ base operational transformers ];
        homepage = "https://github.com/srijs/haskell-operational-class";
        description = "MonadProgram typeclass for the operational package";
@@ -99906,7 +100215,7 @@ self: {
      mkDerivation {
        pname = "opml";
        version = "0.4";
-       sha256 = "1bnr6lkcf2qs7pvrmd8a5xmklcg67l64b776hzclfvxqy1qil29x";
+       sha256 = "3d091a71f0b86f47d987e69c450c3de6313a6b2f0ab59af73d1a0bc72635d9ae";
        libraryHaskellDepends = [ base directory xml ];
        description = "Representing and handling OPML subscription information";
        license = stdenv.lib.licenses.bsd3;
@@ -99924,7 +100233,7 @@ self: {
      mkDerivation {
        pname = "opml-conduit";
        version = "0.3.0.0";
-       sha256 = "00kknysgzv1cbrgx1sgb2qg99lr3715mhdx2wcjsi65msk67ngiz";
+       sha256 = "3f3e7bccd4b598a825e3a237584b3823d3941e16ebe9d05f5e2cecffb4b77302";
        libraryHaskellDepends = [
          base case-insensitive conduit conduit-parse containers data-default
          exceptions hashable hashable-time lens mono-traversable
@@ -99949,7 +100258,7 @@ self: {
      mkDerivation {
        pname = "opn";
        version = "0.1.2";
-       sha256 = "0x53kvcpbd9fh00zs8wdkb3xsl8hf1bsqgl83ci17di1jyg3m4ch";
+       sha256 = "90913a9e9721b613221b883eac57701051ddc79a8d23fd01802eb575d99ea374";
        isLibrary = false;
        isExecutable = true;
        executableHaskellDepends = [
@@ -99968,7 +100277,7 @@ self: {
      mkDerivation {
        pname = "optimal-blocks";
        version = "0.1.0";
-       sha256 = "1863sh22yfy7i5ibqjsp3bzbaxjd7vwhy2j3r523qrcci0xs8n9b";
+       sha256 = "2b59a43b888c653c44c9430a0ff93e4d76b5fe1a574bbc6289c73b2f04d4c3a0";
        isLibrary = true;
        isExecutable = true;
        libraryHaskellDepends = [ base bytestring deepseq vector ];
@@ -99991,7 +100300,7 @@ self: {
      mkDerivation {
        pname = "optimization";
        version = "0.1.6";
-       sha256 = "182dwjs24m60waqqhvq42l9hpshwzr07bbb87jjpmhfjrlxf4xly";
+       sha256 = "9e76e23acdd2c17aa53c68ad7540fe1cea0b1315046f88b1e2c05422b4e44da0";
        libraryHaskellDepends = [
          ad base distributive linear semigroupoids vector
        ];
@@ -100009,7 +100318,7 @@ self: {
      mkDerivation {
        pname = "optimusprime";
        version = "0.0.1.20091117";
-       sha256 = "0642f9vv08qyqk3pjgin5k2sfv2ffhah9h9rc2xw6ahnygqbpbmf";
+       sha256 = "aeaebbf0f3162ac3bb6039c10415744e6ca7c52c363e79c7c41e23b077728218";
        isLibrary = false;
        isExecutable = true;
        executableHaskellDepends = [
@@ -100028,7 +100337,7 @@ self: {
      mkDerivation {
        pname = "optional";
        version = "0.0.1";
-       sha256 = "1i1nl81gg5fndf3vafirpmklikn4xpy791is6ff8j7pzys0qfj8g";
+       sha256 = "0f498781f6ff1e899c333a8674fcedc4ce4867bd393ab5876bd695f702a236c4";
        libraryHaskellDepends = [ base ];
        testHaskellDepends = [
          base directory doctest filepath QuickCheck
@@ -100043,7 +100352,7 @@ self: {
      mkDerivation {
        pname = "optional-args";
        version = "1.0.0";
-       sha256 = "0j49cp5y7gp9acvhw315lq92mgr35fwaw90vpxy0n9g541ls350z";
+       sha256 = "1f94a16920e5250b7cbf1b24aeb82b23bf2a12a6250c0e3753e9bee3cb658948";
        libraryHaskellDepends = [ base ];
        description = "Optional function arguments";
        license = stdenv.lib.licenses.bsd3;
@@ -100056,7 +100365,7 @@ self: {
      mkDerivation {
        pname = "options";
        version = "1.2.1.1";
-       sha256 = "0qjs0v1ny52w51n5582d4z8wy9h6n0zw1xb5dh686ff5wadflgi8";
+       sha256 = "283eea9ae2c539830c6c65f5c03fb00626cfd1274da0526c285c146fc3065a62";
        libraryHaskellDepends = [ base containers monads-tf transformers ];
        testHaskellDepends = [
          base chell chell-quickcheck containers monads-tf transformers
@@ -100071,7 +100380,7 @@ self: {
      mkDerivation {
        pname = "options-time";
        version = "1.0.1";
-       sha256 = "0rsmwalmnry71w23k6sg0a307xgb2s71j9s12zqqq380fw6c1bhm";
+       sha256 = "15aec00c77000d8cf1174127198e16ebf50386024f9b39040fc7675ba9e25567";
        libraryHaskellDepends = [ base options time ];
        testHaskellDepends = [ base chell options time ];
        homepage = "https://john-millikin.com/software/haskell-options/";
@@ -100086,7 +100395,7 @@ self: {
      mkDerivation {
        pname = "optparse-applicative";
        version = "0.10.0";
-       sha256 = "04hr6rzgc8h0c8fy748as3q7sc8vm94gvk0rw4gdj605z8hvaxcb";
+       sha256 = "8b75b521fa0518d91ee119ccfd48aa1b317df0d00a91e31d620022f67e361912";
        revision = "1";
        editedCabalFile = "20d6ce280b028a493a1920dcc22bb39bee10e9c788a58e03dcaeecba97afffb0";
        libraryHaskellDepends = [
@@ -100105,7 +100414,7 @@ self: {
      mkDerivation {
        pname = "optparse-applicative";
        version = "0.11.0.2";
-       sha256 = "0ni52ii9555jngljvzxn1ngicr6i2w647ww3rzhdrmng04y95iii";
+       sha256 = "31c6923c01cfd6dce0cf83f3430c17d164169f0db6ff2de9b3b294926214255a";
        libraryHaskellDepends = [
          ansi-wl-pprint base process transformers transformers-compat
        ];
@@ -100119,7 +100428,7 @@ self: {
      mkDerivation {
        pname = "optparse-declarative";
        version = "0.3.0";
-       sha256 = "1avy0g6jk34jbfp1xzqcyhb4j53knsbzx1pssl4b5f6nn981mbj8";
+       sha256 = "48ae1a50b2d6b8b208d5fa86fe97b673144916f40cff1eae5b928c29cd037eab";
        libraryHaskellDepends = [ base mtl ];
        homepage = "https://github.com/tanakh/optparse-declarative";
        description = "Declarative command line option parser";
@@ -100133,7 +100442,7 @@ self: {
      mkDerivation {
        pname = "optparse-simple";
        version = "0.0.3";
-       sha256 = "0zlcvxhx98k1akbv5fzsvwcrmb1rxsmmyaiwkhfrp5dxq6kg0is5";
+       sha256 = "4547f0a6c1bd959b1d9c3c2a5fabee39ac9a19dffabbb2d75461a2d461df8c7e";
        libraryHaskellDepends = [
          base either gitrev optparse-applicative template-haskell
          transformers
@@ -100148,7 +100457,7 @@ self: {
      mkDerivation {
        pname = "orc";
        version = "1.2.1.4";
-       sha256 = "0zl456v2mwa68k2lq7fx3ds6xr9vbrijq8q8ma5mm1kk9p9znr0x";
+       sha256 = "1d64fbd34d73865a8baa08232c635e3be56e741bdd1d4cc54446f12ab629847e";
        isLibrary = true;
        isExecutable = true;
        libraryHaskellDepends = [ base deepseq monadIO mtl process stm ];
@@ -100168,7 +100477,7 @@ self: {
      mkDerivation {
        pname = "orchestrate";
        version = "0.2.0.2";
-       sha256 = "09h9jqni25ysalw747xbf532m0gvy8najjwbn3jj7d3z50s0vf8z";
+       sha256 = "1fb90d34287fb423e5b08b4ba92cf2fb812a4671ab1f723855da17112d960926";
        libraryHaskellDepends = [
          aeson base bytestring case-insensitive data-default either errors
          http-client http-types lens mtl text transformers
@@ -100191,7 +100500,7 @@ self: {
      mkDerivation {
        pname = "orchid";
        version = "0.0.8";
-       sha256 = "1d3cfhhsv1qpiiin4cs9wxx2a6vwcj0iad746z7l1qzyxrhg4dkm";
+       sha256 = "7536f260eefee340cf37e4341581647c1b257ae7493362638c1787ad21746cb4";
        libraryHaskellDepends = [
          base bytestring containers encoding extensible-exceptions fclabels
          filestore hscolour mtl nano-md5 parsec process QuickCheck salvia
@@ -100210,7 +100519,7 @@ self: {
      mkDerivation {
        pname = "orchid-demo";
        version = "0.0.6";
-       sha256 = "1gfjmakfx8244q1yqbgp2ji9bh45ll8ixvxbdd961my30j7gh29z";
+       sha256 = "3f09f88e04c3d760526babef1e11a585c095a214f72dec032644a0eea6aad2bd";
        isLibrary = false;
        isExecutable = true;
        executableHaskellDepends = [
@@ -100228,7 +100537,7 @@ self: {
      mkDerivation {
        pname = "ord-adhoc";
        version = "0.0.0.1";
-       sha256 = "062wkfpww1ic3xiy26k22369azk5wjlpn5wm5xh1w75kc9crv263";
+       sha256 = "c3889d5962b31c1e602f95177ba9e4657e95cc10621ae1631f2c06ceaf9b5c18";
        libraryHaskellDepends = [ base void ];
        homepage = "https://github.com/fumieval/ord-adhoc/";
        description = "Creating Ord instances instantly";
@@ -100242,7 +100551,7 @@ self: {
      mkDerivation {
        pname = "order-maintenance";
        version = "0.0.1.0";
-       sha256 = "01j8caxlmzz04qabinq5kcjdsr1855lmcdsi9sqn9zf79s16q97k";
+       sha256 = "f3246c824ec7fd64b14e51375669292864dd249b05dbb81426e0ff4abb624806";
        libraryHaskellDepends = [ base containers transformers ];
        testHaskellDepends = [
          base Cabal cabal-test-quickcheck containers QuickCheck transformers
@@ -100260,7 +100569,7 @@ self: {
      mkDerivation {
        pname = "order-statistics";
        version = "0.1.1";
-       sha256 = "1df9b0q4rmgnd74q7pckcppyiygzba6f39vajkwb2pmxlfafcy7a";
+       sha256 = "ea78e694a3bd5eb1f8946aa7e18c5afff9e8ef6593dd83c969f6d54c3058c9b5";
        libraryHaskellDepends = [
          base containers math-functions statistics vector vector-space
        ];
@@ -100275,7 +100584,7 @@ self: {
      mkDerivation {
        pname = "ordered";
        version = "0.1";
-       sha256 = "0s0g5kgzdw7qjsdcddszjclamx9bi0369pkwhh0wncjg68a7mq69";
+       sha256 = "c9e07a14324f32cb01847cde6406882bf5aa28935fb7c69a96f8f0f6df2c0f68";
        libraryHaskellDepends = [ base ];
        description = "A definition of Posets";
        license = "unknown";
@@ -100286,7 +100595,7 @@ self: {
      mkDerivation {
        pname = "orders";
        version = "0.1.0.0";
-       sha256 = "1ry6flg5sh3hl1xpkqk67ayd4y0xx3j2pwcz26q1pgqn6m84plzr";
+       sha256 = "f9d34b503516bf1bb0119ff12be4e81d78d2bc3a66e2797ba070405d1e75c6e7";
        libraryHaskellDepends = [ base containers ];
        jailbreak = true;
        description = "basic orders";
@@ -100300,7 +100609,7 @@ self: {
      mkDerivation {
        pname = "ordrea";
        version = "0.3.0.0";
-       sha256 = "067nf69diqi00vswd7xarl55ps9v5cwqmph1w6nzjylnl0pjh811";
+       sha256 = "2120282fa0967af9ade101de8a392b3be95b0acdaa9fc6f50620e2d89271f618";
        libraryHaskellDepends = [ base containers transformers vector ];
        testHaskellDepends = [ base directory process split ];
        description = "Push-pull implementation of discrete-time FRP";
@@ -100312,7 +100621,7 @@ self: {
      mkDerivation {
        pname = "organize-imports";
        version = "0.3.0.0";
-       sha256 = "04d56k6x6psynk8lddbawc3kfa4yc66w4qgjag20grm4zd7y45ax";
+       sha256 = "5d15e24ffba4e607c453f261c28d619e283707e36ab546d1b45e5fd3cd34a511";
        isLibrary = false;
        isExecutable = true;
        executableHaskellDepends = [ attoparsec base text ];
@@ -100328,7 +100637,7 @@ self: {
      mkDerivation {
        pname = "orgmode";
        version = "0.1.0.0";
-       sha256 = "084dzafa8pm2hs346zk3x3agzzcxay7ca9r40s6sh61vfc6hbwg0";
+       sha256 = "e0f1050d733b18a88d062427c58e579dfdffd4e8637e438686a25ea49cfa8d20";
        libraryHaskellDepends = [
          base containers HStringTemplate parsec regex-posix syb text
        ];
@@ -100349,7 +100658,7 @@ self: {
      mkDerivation {
        pname = "orgmode-parse";
        version = "0.1.1.2";
-       sha256 = "1ys9gcydipjxn5ba7ndmz70ri218d6wivxrd7xvcsf4kncfks3xi";
+       sha256 = "b10f3d1db39338cd763f2df71db969288898c1f9b5d9a356b15dded83c7b49fb";
        libraryHaskellDepends = [
          aeson attoparsec base bytestring containers free hashable
          old-locale text thyme unordered-containers
@@ -100370,7 +100679,7 @@ self: {
      mkDerivation {
        pname = "origami";
        version = "0.0.4";
-       sha256 = "0q0dsyhpp63kkpjqvjksy1xnwp1f9yilgxrxgwcqrzdjzmgg4rzw";
+       sha256 = "fc67f25efdb2fd8c197f3df747a34f2e5c6e7bf07aca8de59d73987ba1d70d60";
        libraryHaskellDepends = [
          base bifunctors containers lens mtl pretty template-haskell
        ];
@@ -100390,7 +100699,7 @@ self: {
      mkDerivation {
        pname = "os-release";
        version = "0.2.1";
-       sha256 = "0ij6i1yp2rmbkr9jhr8i969xajw3kbfx0yb44s51gm3mcjb3g4la";
+       sha256 = "8a9237966475d4178a266479d0dd9a834bd59349116528539eab66717d884646";
        libraryHaskellDepends = [ base containers parsec transformers ];
        testHaskellDepends = [
          base containers hlint hspec parsec process regex-compat temporary
@@ -100408,7 +100717,7 @@ self: {
      mkDerivation {
        pname = "osc";
        version = "1.0.0.2";
-       sha256 = "0f7diw6nna7mq5rsn63jk9n230pnrr5ppi5dp8rcpniqry2gs1q3";
+       sha256 = "0307fd84cf38dacb32baadc47b4bcef682216c9a7218ab73c1f5286b0d8fed38";
        libraryHaskellDepends = [
          attoparsec base binary bytestring data-binary-ieee754 network
        ];
@@ -100425,7 +100734,7 @@ self: {
      mkDerivation {
        pname = "osdkeys";
        version = "0.0";
-       sha256 = "18pc2r5acb3b6dr7niib4fn8x2la6y3f5zlj3ibrxhl5c1q35j6y";
+       sha256 = "dec832706085c29e571c92fee286378a8a8eac232b467b72336b2ca64a16eca2";
        isLibrary = true;
        isExecutable = true;
        libraryHaskellDepends = [
@@ -100447,7 +100756,7 @@ self: {
      mkDerivation {
        pname = "osm-download";
        version = "0.4";
-       sha256 = "056ggv31nycgz59gkmibzmx0k5x8klb5bwlnbhdih8d71larbsb3";
+       sha256 = "63e995150da721181b5c96f255169da897097afd2bd6f952f98f791bc67ecf14";
        libraryHaskellDepends = [
          base bytestring conduit containers data-default directory gps
          http-conduit http-types monad-control monadIO mtl persistent
@@ -100465,7 +100774,7 @@ self: {
      mkDerivation {
        pname = "osx-ar";
        version = "0.11";
-       sha256 = "1d2lna7gvygiq062p2y1zy182wv3vkr0lda49y502ad6jf483xdn";
+       sha256 = "b6f5818893a629018a4f44350af2dc63738182ffc18b2b0cc0f1f9fd8eb254b4";
        libraryHaskellDepends = [ base binary bytestring containers ];
        description = "Parser for OS X static archive format";
        license = stdenv.lib.licenses.bsd3;
@@ -100479,7 +100788,7 @@ self: {
      mkDerivation {
        pname = "ot";
        version = "0.2.0.0";
-       sha256 = "0vf4lqc0mffnhz4a03jvs35rl1ygp2ipdmn3dyb5darsg941gsd3";
+       sha256 = "a3e917487a3aab56966fc3d676a3b8cf079acbd05b0ea0c887d6b90a18a6c46d";
        libraryHaskellDepends = [
          aeson attoparsec base binary either ghc mtl QuickCheck text
        ];
@@ -100499,7 +100808,7 @@ self: {
      mkDerivation {
        pname = "ottparse-pretty";
        version = "0.1.2.5";
-       sha256 = "1dwl9jbrhw5b7z2imlnkn8qjk36z06gqca4y9h8r85phsdkyzbm4";
+       sha256 = "a4aeef67d3f01694114c9e28869f01df8c2931b2d3d21ac53fab7098974c94b7";
        isLibrary = false;
        isExecutable = true;
        executableHaskellDepends = [
@@ -100514,7 +100823,7 @@ self: {
      mkDerivation {
        pname = "overture";
        version = "0.0.5";
-       sha256 = "0mv9iakq1yjawf7f0zckmxbzlcv2rlqngsllfsrcydi6lxazznzw";
+       sha256 = "fcdbff55a72636cfb27694ea6731cd6233fa57af937de08ee34afa80a78a6957";
        libraryHaskellDepends = [ base ];
        testHaskellDepends = [ base doctest ];
        jailbreak = true;
@@ -100529,7 +100838,7 @@ self: {
      mkDerivation {
        pname = "pack";
        version = "0.4.0";
-       sha256 = "19ps1dk855br5h9x72f26sjx8xnh4gmqb0cf5mi65jpp5zvp0zj9";
+       sha256 = "497e70f72ff7ca62622d8e8185eb23d076d4a536c289d3132c799582660bfaa6";
        libraryHaskellDepends = [
          array base bytestring lens transformers vector
        ];
@@ -100546,7 +100855,7 @@ self: {
      mkDerivation {
        pname = "package-o-tron";
        version = "0.1.0.0";
-       sha256 = "0r4zksyszbhywyyayjs1cn8d69cnm0p4y9xqir9nw1g4gkl23df8";
+       sha256 = "c8b521e87ce4056e538eb8274f2ea89625d39065414bafbce71eaeafbd9e9f64";
        isLibrary = true;
        isExecutable = true;
        libraryHaskellDepends = [ base filemanip filepath groom process ];
@@ -100562,7 +100871,7 @@ self: {
      mkDerivation {
        pname = "package-vt";
        version = "0.1.3.3";
-       sha256 = "0rsv60n6fd9kkjihdjzi7hadxj8yd6bd640w92y2wx1y9qxl8lhm";
+       sha256 = "1552443b4e3e742ebc481c10d396691ec9de143cf1cb06a39c3335672c305b67";
        isLibrary = false;
        isExecutable = true;
        executableHaskellDepends = [
@@ -100581,7 +100890,7 @@ self: {
      mkDerivation {
        pname = "packdeps";
        version = "0.4.0.3";
-       sha256 = "08an9nwg448d3w4yds67l02mgikmjmn52pvva3i386fv4hfkabhp";
+       sha256 = "172e351d24db1934e2507b5f516c9575c65705a0c7e8e6091f0d11f2b84d5621";
        isLibrary = true;
        isExecutable = true;
        libraryHaskellDepends = [
@@ -100602,7 +100911,7 @@ self: {
      mkDerivation {
        pname = "packed-dawg";
        version = "0.2.0.7";
-       sha256 = "03wf6pnv2l7aydxzv0gx073324iy5j7pbfh5nl3p5xdpr8y8il7y";
+       sha256 = "fed0883ccab7f57207b505ba758f2c3e1231c601fd81fd7bf3ea50b1ed358e0f";
        libraryHaskellDepends = [
          base binary deepseq mtl unordered-containers vector
          vector-binary-instances
@@ -100621,7 +100930,7 @@ self: {
      mkDerivation {
        pname = "packedstring";
        version = "0.1.0.1";
-       sha256 = "1x78pzzdlnpcmh9p37rlf8m5cxf3yqm2alf3whl4zpr9w25r0qj8";
+       sha256 = "4862908be029df4f28e4c351252af6c375562a72349f7113acec5adafebfe8f4";
        revision = "1";
        editedCabalFile = "cbc334ff8e721fb18b6799b28dc3e77addc7234aa553725b0af68375f75e0bcf";
        libraryHaskellDepends = [ array base ];
@@ -100638,7 +100947,7 @@ self: {
      mkDerivation {
        pname = "packer";
        version = "0.1.8";
-       sha256 = "1r7q54a1c6yb0gjd8hvxq1jw2fmgbhf5anfw47nzibs1bywjjgbi";
+       sha256 = "713d29b95f41aff8ed21dc59551c5caf3ac165c07d43d4e403cb1b161429f8e4";
        libraryHaskellDepends = [ base bytestring ghc-prim transformers ];
        testHaskellDepends = [
          base bytestring tasty tasty-hunit tasty-quickcheck
@@ -100655,7 +100964,7 @@ self: {
      mkDerivation {
        pname = "packunused";
        version = "0.1.1.4";
-       sha256 = "1ahb8wq7yxnfzwcvppk8cyhj9r51fz9ci1pwy0h4ql7iyc3z0vy8";
+       sha256 = "c86ff007f3f1504c20f0fc86c8d277a1e424a16768debb19ffce767f30470baa";
        revision = "1";
        editedCabalFile = "5ddb122ff2a1ac4e79226f31b4d8f7dab67bb5501d0e715d84dbfe36c845b772";
        isLibrary = false;
@@ -100674,7 +100983,7 @@ self: {
      mkDerivation {
        pname = "pacman-memcache";
        version = "0.1.0.3";
-       sha256 = "04jlfinds38kjy0qrk00a7ik5x7mkdwkb0cwmlzlif45x4zrhwfv";
+       sha256 = "db71983fe985b8483fad9c8135799bf5f432e35100cc8c8197130ddd6c745412";
        isLibrary = false;
        isExecutable = true;
        executableHaskellDepends = [ base deepseq directory-tree ];
@@ -100691,7 +101000,7 @@ self: {
      mkDerivation {
        pname = "padKONTROL";
        version = "0.1";
-       sha256 = "1sv7124ms2msqb2wb361xshykmh8cr4i85qayjak8y8q7bpzkdfd";
+       sha256 = "cdb5f9ef3a18793495f40a1714496608d6e9a1eec18cc5c5c2ba0a5d890867eb";
        libraryHaskellDepends = [
          base containers hmidi minioperational transformers
        ];
@@ -100708,7 +101017,7 @@ self: {
      mkDerivation {
        pname = "pagarme";
        version = "0.1.0.0";
-       sha256 = "1zkh8cx4bdgsyra7x9kzzdcckg65y1hacwq90w36gdl6i4hs7nj0";
+       sha256 = "40daa3218986b66706070973a660f0c5bcc958fb7fa67e54f6fab5453a4370fe";
        isLibrary = true;
        isExecutable = true;
        libraryHaskellDepends = [
@@ -100729,7 +101038,7 @@ self: {
      mkDerivation {
        pname = "pager";
        version = "0.1.1.0";
-       sha256 = "1wzfsindjxx61nca36hhldy0y33pgagg506ls9ldvrkvl4n4y7iy";
+       sha256 = "3e1e4f2ca17be6dd68d2d480f29e7a770c0f7ca3109aa1980da677d96cd4eef3";
        isLibrary = true;
        isExecutable = true;
        libraryHaskellDepends = [
@@ -100753,7 +101062,7 @@ self: {
      mkDerivation {
        pname = "pagerduty";
        version = "0.0.3.2";
-       sha256 = "0cdn5xmqpfl85nair2ns3dv690wgyfiapks0lnc3aqi8nnly7bws";
+       sha256 = "9aafe3a9b528623598a540cfaba2f38f8364761bda8a1c952d88ba8b6b2fb631";
        revision = "1";
        editedCabalFile = "016fff9ce8abfc6dec19a84ed7043a2d6f6692f2b0f20a845e98a347a1bc48ba";
        libraryHaskellDepends = [
@@ -100775,7 +101084,7 @@ self: {
      mkDerivation {
        pname = "pagure-hook-receiver";
        version = "0.1.0.0";
-       sha256 = "0qnnkxcad4843v6c1fqqkiip6cv82q5fckpn5v40sw2p9xk3lkcl";
+       sha256 = "944d3a664f57700dc82ef64ee60a16683373639c18bbc0cc1e0491a6589fd662";
        libraryHaskellDepends = [
          base containers scotty shelly text transformers unix
        ];
@@ -100789,7 +101098,7 @@ self: {
      mkDerivation {
        pname = "palette";
        version = "0.1.0.2";
-       sha256 = "1snhn4mz58ax5sd77kh1m4jicwdmlrf89j612rkz5bkavvks6rrr";
+       sha256 = "3967a3e7de6aaef26716c1c8845ca6b5711625a901ce739a2e5da1f22bb1d0ea";
        libraryHaskellDepends = [ array base colour containers ];
        homepage = "http://projects.haskell.org/diagrams";
        description = "Utilities for choosing and creating color schemes";
@@ -100801,7 +101110,7 @@ self: {
      mkDerivation {
        pname = "palindromes";
        version = "0.4";
-       sha256 = "1k0kvd8p1ivwmpmf8khwmb4vyk8z0di74xn5840zy9jhf1cwx4kn";
+       sha256 = "7692ce59705026ff0141c5767262031f4dbfc9aa1c4ee4eaad7cc77051db13cc";
        isLibrary = true;
        isExecutable = true;
        executableHaskellDepends = [ array base bytestring containers ];
@@ -100815,7 +101124,7 @@ self: {
      mkDerivation {
        pname = "pam";
        version = "0.1";
-       sha256 = "1lmkq12p18qavx2c7xrnha56017y0f21ri4l3cqal4fb8zy0g5nj";
+       sha256 = "d29607fc47cb11aa301b94c41c8403fe04608a8236f7c344df0aa37045c0b3d2";
        libraryHaskellDepends = [ base ];
        librarySystemDepends = [ pam ];
        libraryToolDepends = [ c2hs ];
@@ -100832,7 +101141,7 @@ self: {
      mkDerivation {
        pname = "panda";
        version = "2009.4.1";
-       sha256 = "0yn6ia1pql5fvj784a57ym74n5sd08n1g9djgapllw9lkf6r7hv7";
+       sha256 = "67c3938d9b34714aaf7ab2a5172c024d174b4ef5a728828edcae507c838ac67a";
        libraryHaskellDepends = [
          base cgi containers data-default directory filepath gravatar
          haskell98 hcheat kibro MissingH mps network old-locale old-time
@@ -100860,7 +101169,7 @@ self: {
      mkDerivation {
        pname = "pandoc";
        version = "1.15.0.6";
-       sha256 = "0ipdy5wl2qb8nvmdka9si17hvxn38xmv5pzpb9v5lvaj8a0rcl6r";
+       sha256 = "d950968142526d5a765af7dfb26b47c3f60d4f883aa9d9eab668614179f1ed46";
        configureFlags = [ "-fhttps" ];
        isLibrary = true;
        isExecutable = true;
@@ -100898,8 +101207,8 @@ self: {
      }:
      mkDerivation {
        pname = "pandoc-citeproc";
-       version = "0.7.2";
-       sha256 = "0dpr74alkz9vy5yc09bnqb968hcrqys2xlydjda1g3qsarjg7p9y";
+       version = "0.7.3";
+       sha256 = "72fc81d962812d037bb78c6d38d602ca2c6895f0436c8be94cb71600ed288e68";
        isLibrary = true;
        isExecutable = true;
        libraryHaskellDepends = [
@@ -100926,7 +101235,7 @@ self: {
      mkDerivation {
        pname = "pandoc-crossref";
        version = "0.1.2.4";
-       sha256 = "1ay54zkxxa22nz5sr40d6k4bam81hxh19583kffwqdcp0af23d7l";
+       sha256 = "f4b4219c029735cc9d9b03951460870155b5c8340d90accbb742a8dee727c5ab";
        isLibrary = false;
        isExecutable = true;
        executableHaskellDepends = [
@@ -100947,7 +101256,7 @@ self: {
      mkDerivation {
        pname = "pandoc-csv2table";
        version = "1.0.1";
-       sha256 = "0b4xszf9bzfhrjgy2cymryab58zhh4jwv9p8g2hiqgrxix8jr1qb";
+       sha256 = "0b872c518f3d3f1ca178e8a6cd2581f0a3b294cfd533e19fccd0fd95dcd79d2c";
        revision = "1";
        editedCabalFile = "0924cc418394f855f93486ee6fb3bae991112c3e63df74f95afa6c2d62b09299";
        isLibrary = true;
@@ -100963,10 +101272,9 @@ self: {
     ({ mkDerivation, base, containers, lens, pandoc-types }:
      mkDerivation {
        pname = "pandoc-lens";
-       version = "0.3.2";
-       sha256 = "1n0h3cf2yb5rmlfd0bbxlj3r8bm4h8yffd76fqsbw3s5jm0df4wb";
+       version = "0.3.3";
+       sha256 = "69502fc2630bb482ed4211b9966a0446403af59ee4cab78dd89cebe11b236cdc";
        libraryHaskellDepends = [ base containers lens pandoc-types ];
-       jailbreak = true;
        homepage = "http://github.com/bgamari/pandoc-lens";
        description = "Lenses for Pandoc documents";
        license = stdenv.lib.licenses.bsd3;
@@ -100979,7 +101287,7 @@ self: {
      mkDerivation {
        pname = "pandoc-placetable";
        version = "0.1.2";
-       sha256 = "0vq94j5jsq60p0wbml50hwqa2zpidbzx92cbb7d2ialqj7816zwb";
+       sha256 = "8b7f13d09198aa28da598b89d4ff6af17ea13087a0d0ba38b8c0602d8b24096f";
        isLibrary = false;
        isExecutable = true;
        executableHaskellDepends = [
@@ -100998,7 +101306,7 @@ self: {
      mkDerivation {
        pname = "pandoc-types";
        version = "1.12.4.5";
-       sha256 = "0yw7mkhx63320vqabql2iqnmkrwh1qs670sicqpcvv73dchdp8c7";
+       sha256 = "87a1db206be3eccd2e66518363340e90e7592d8e82e2a5f006620cd3e1ac877b";
        libraryHaskellDepends = [
          aeson base bytestring containers deepseq-generics ghc-prim syb
        ];
@@ -101012,7 +101320,7 @@ self: {
      mkDerivation {
        pname = "pandoc-unlit";
        version = "0.1.0";
-       sha256 = "0jdlfqhp7h6jsp9qq2ndnm8fs96m19cmmd5rnjpqb76ilg6kn7l9";
+       sha256 = "891e3bcda3d19c85afb4b9b45a590ad524ed50b5cd0a8cd3d5d2c0732176b449";
        isLibrary = false;
        isExecutable = true;
        executableHaskellDepends = [ base pandoc ];
@@ -101028,7 +101336,7 @@ self: {
      mkDerivation {
        pname = "pango";
        version = "0.13.1.0";
-       sha256 = "0s69ga5gn9grdqcfxkbnvk0f3malql3fnhzh9cwvpfzqk3hxn4hn";
+       sha256 = "1612dbe198f8bbbb394bf043eb06c554d5e1c0dc76cdee186ef925fb8a7ac968";
        libraryHaskellDepends = [
          array base cairo containers directory glib mtl pretty process text
        ];
@@ -101046,7 +101354,7 @@ self: {
      mkDerivation {
        pname = "papillon";
        version = "0.1.0.0";
-       sha256 = "02j3bydxzs39ljfnx1sgsn9ppw1cah81dfbws57yp9vdrcyq2ipf";
+       sha256 = "ee46813dcb6da7eb4fd17cb91610542cf07b93d54f876e9da469e8df9b5f430a";
        isLibrary = true;
        isExecutable = true;
        libraryHaskellDepends = [
@@ -101066,7 +101374,7 @@ self: {
      mkDerivation {
        pname = "pappy";
        version = "0.1.0.2";
-       sha256 = "14f4mv9xgqwmmyy3fg1miqdmi7a6bs3hixqk4z46r0pz44w6nlxd";
+       sha256 = "ad536b3821ff826cc82713f708875e469d581b8e353c37bcaf95e3d7d3aec491";
        isLibrary = false;
        isExecutable = true;
        executableHaskellDepends = [ base ];
@@ -101081,7 +101389,7 @@ self: {
      mkDerivation {
        pname = "para";
        version = "1.1";
-       sha256 = "0l5abmqi548s10f87m124ld4hhphhl1szljyc04a13fah4dsqjbh";
+       sha256 = "7049ac1b81ca8da008605ed2af0385f042481a2522d4831c081a9112715daa50";
        libraryHaskellDepends = [ base ];
        description = "Text paragraph formatting";
        license = stdenv.lib.licenses.bsd3;
@@ -101095,7 +101403,7 @@ self: {
      mkDerivation {
        pname = "paragon";
        version = "0.1.28";
-       sha256 = "1iz7fg7ziq3ffq1wac0z2m151rn4xmvd5kig04fdw1cy0x487c9c";
+       sha256 = "2cb18348079e05de1c012fced276edc4e65042151f30c503766ee0f8cf73e7c7";
        isLibrary = true;
        isExecutable = true;
        libraryHaskellDepends = [
@@ -101121,7 +101429,7 @@ self: {
      mkDerivation {
        pname = "parallel";
        version = "3.2.0.3";
-       sha256 = "1kbdzdz9s8jq0xysqgvxx1zvzqlxgj1sk476mciwcn327kpl0fhn";
+       sha256 = "163a40ef3c6258c623abe690a9837c9de2bf7fe87d3fac7d0758229d7efb6dcd";
        libraryHaskellDepends = [ array base containers deepseq ];
        jailbreak = true;
        description = "Parallel programming library";
@@ -101133,7 +101441,7 @@ self: {
      mkDerivation {
        pname = "parallel";
        version = "3.2.0.6";
-       sha256 = "0hp6vf4zxsw6vz6lj505xihmnfhgjp39c9q7nyzlgcmps3xx6a5r";
+       sha256 = "b928d3fbd0b7b247bfb7072796c6950f3a5b61ec051449cddf86ebfe89dbe642";
        libraryHaskellDepends = [ array base containers deepseq ];
        description = "Parallel programming library";
        license = stdenv.lib.licenses.bsd3;
@@ -101144,7 +101452,7 @@ self: {
      mkDerivation {
        pname = "parallel-io";
        version = "0.3.3";
-       sha256 = "0i86x3bf8pjlg6mdg1zg5lcrjpg75pbqs2mrgrbp4z4bkcmw051s";
+       sha256 = "3a14c02b9b8b7c72577eb90a8dd72de75d99192def87d7aa79545ee4d6e80645";
        revision = "1";
        editedCabalFile = "75eeeb51593fa2771c8dbc965ca09d830d62e08135870188a10446f842178bee";
        isLibrary = true;
@@ -101164,7 +101472,7 @@ self: {
      mkDerivation {
        pname = "parallel-tasks";
        version = "4.0.1.0";
-       sha256 = "0cng14pivk0cw3xax0z4j59s0vpbkm7hjycsb3cif6pfjbypsm3x";
+       sha256 = "7d547dfd92ee1a17d9589a79094f9deb6ea05391e483aefae00ccc1d2f09cf32";
        libraryHaskellDepends = [
          base bytestring cereal deepseq here old-locale stm time
          transformers vector vector-algorithms
@@ -101179,7 +101487,7 @@ self: {
      mkDerivation {
        pname = "parallel-tree-search";
        version = "0.4.1";
-       sha256 = "1x2k649q6gqz9z16vwg1j59ajf2wp59lfwb65g8819fz4rwimncr";
+       sha256 = "99d91a7926dfa580d02b66714753b95c38a95291e1f16dc24f1f3f83133153f4";
        libraryHaskellDepends = [ base parallel tree-monad ];
        homepage = "http://github.com/sebfisch/parallel-tree-search";
        description = "Parallel Tree Search";
@@ -101191,7 +101499,7 @@ self: {
      mkDerivation {
        pname = "parameterized-data";
        version = "0.1.5";
-       sha256 = "1zcfpapbgmzfrrwn8bq829scb89b52p1567xaw45d77z3hw24cq1";
+       sha256 = "013322381cff9c560857fd9812ae282ba1c57412082f6479ceeed7b7aeba8efd";
        libraryHaskellDepends = [ base template-haskell type-level ];
        homepage = "http://code.haskell.org/parameterized-data";
        description = "Parameterized data library implementing lightweight dependent types";
@@ -101204,7 +101512,7 @@ self: {
      mkDerivation {
        pname = "parco";
        version = "0.1";
-       sha256 = "0598hz6zqcn4lh5y3vr54z4jh4ampxnh8rq29k6p5vnmrpvn4lq4";
+       sha256 = "045362f7cdd5ee72cd4c0267046dbf551128c92725efe10ba4c432fccd872815";
        libraryHaskellDepends = [ base mtl ];
        description = "Generalised parser combinators";
        license = stdenv.lib.licenses.bsd3;
@@ -101216,7 +101524,7 @@ self: {
      mkDerivation {
        pname = "parco-attoparsec";
        version = "0.1";
-       sha256 = "0bc2gyvc1i3l3p702zs6hfkab7fmc7li5kh4mdzy3a91gzgsl3jh";
+       sha256 = "500eaadf7f21a9e17fab04ce12e961d59da5a683467f01ce1d74c4c0b67f822d";
        libraryHaskellDepends = [ attoparsec base mtl parco ];
        description = "Generalised parser combinators - Attoparsec interface";
        license = stdenv.lib.licenses.bsd3;
@@ -101228,7 +101536,7 @@ self: {
      mkDerivation {
        pname = "parco-parsec";
        version = "0.1";
-       sha256 = "0m3dsjay3av4y0v4j76wxybmk4mkjdhqq81w1wsfr173d4blgxf3";
+       sha256 = "c3f5471769e384ec340f3c208c6193b3925997efdc1c4936f064abe195d46d54";
        libraryHaskellDepends = [ base mtl parco parsec ];
        description = "Generalised parser combinators - Parsec interface";
        license = stdenv.lib.licenses.bsd3;
@@ -101242,7 +101550,7 @@ self: {
      mkDerivation {
        pname = "parcom-lib";
        version = "0.8.0.3";
-       sha256 = "0xkxkqswpkqr9xcpg52v845kkxg8z20r26yih8l2vwkym5cj49ab";
+       sha256 = "4b252259a97ef22d2882d11b9181f8e8f5390b415b9477594f19cfcb359e7d76";
        libraryHaskellDepends = [
          base bytestring containers mtl text transformers utf8-string word8
        ];
@@ -101262,7 +101570,7 @@ self: {
      mkDerivation {
        pname = "parconc-examples";
        version = "0.3.5";
-       sha256 = "05id69rb2cdzs1jf7zgv0gxgvbwm6x83s6ihdh9w1wnnpa7ykpap";
+       sha256 = "57dde98fbad6f2c0136c301a3d503795affdfa03fbfde364d0bf31b172322d16";
        isLibrary = false;
        isExecutable = true;
        executableHaskellDepends = [
@@ -101283,7 +101591,7 @@ self: {
      mkDerivation {
        pname = "parport";
        version = "0.0.0";
-       sha256 = "1d4fq67179n6flmi4ll0341cnnx6p7v44sj5xkk5vknm7qv1p5nx";
+       sha256 = "dd961b363ed5ce5de6ec456a42f6b9a65bcb02198052122b75c6a6138ec18eb4";
        libraryHaskellDepends = [ array base ];
        description = "Simply interfacing the parallel port on linux";
        license = "GPL";
@@ -101294,7 +101602,7 @@ self: {
      mkDerivation {
        pname = "parse-dimacs";
        version = "1.3";
-       sha256 = "0amh3h49xi65kx8l34cy5jkai1f0d9l1qxp4937f3cjf7afif0pj";
+       sha256 = "f202179d3a4eb2e1ce48e4761c686ac085a8a62c9e9141519fc5c49e081cb02a";
        libraryHaskellDepends = [ array base bytestring parsec ];
        description = "DIMACS CNF parser library";
        license = stdenv.lib.licenses.bsd3;
@@ -101307,7 +101615,7 @@ self: {
      mkDerivation {
        pname = "parse-help";
        version = "0.0";
-       sha256 = "1vy7v49nh60gkb7vsig87hv11cxn19xs2jjvd0xnnhdz0zm4z7yf";
+       sha256 = "ce9f4fea07bf416b3b685b4aa17b0ab6b310363ce845bdcf9a0f186813d9c7ef";
        libraryHaskellDepends = [
          attoparsec base containers data-default file-location
          template-haskell text th-lift
@@ -101325,7 +101633,7 @@ self: {
      mkDerivation {
        pname = "parseargs";
        version = "0.1.5.2";
-       sha256 = "0pzw7w1kr2rv6ffqgn93rypn37wy2r5k01p3y5256laaplm575am";
+       sha256 = "5595532abd4a515344f1e306304b169e9f61afcf23d9879d333b8b3c033ffc5f";
        isLibrary = true;
        isExecutable = true;
        libraryHaskellDepends = [ base containers ];
@@ -101342,7 +101650,7 @@ self: {
      mkDerivation {
        pname = "parsec";
        version = "3.1.9";
-       sha256 = "1ja20cmj6v336jy87c6h3jzjp00sdbakwbdwp11iln499k913xvi";
+       sha256 = "71f711d24c89581a43b8bc2d3ed56a1a802bbf1cd0b083bc34636c232b0342c9";
        libraryHaskellDepends = [ base bytestring mtl text ];
        testHaskellDepends = [
          base HUnit test-framework test-framework-hunit
@@ -101357,7 +101665,7 @@ self: {
      mkDerivation {
        pname = "parsec-extra";
        version = "0.1.0.5";
-       sha256 = "0x5lpkly8z26ygp0k8ddkybgmfi5n2vnf6sv3sjn3xm531xf6qy4";
+       sha256 = "c463e37a18a5f661a51e5b1b67b7b025bafa969fada109eef3467ce4e9bcb474";
        libraryHaskellDepends = [ base monads-tf parsec transformers ];
        description = "Some miscellaneous basic string parsers";
        license = stdenv.lib.licenses.bsd3;
@@ -101368,7 +101676,7 @@ self: {
      mkDerivation {
        pname = "parsec-numbers";
        version = "0.1.0";
-       sha256 = "1gzy4v3r02kvdxvgg1nj83mmb6aph2v4ilf9c7y6nbvi2x49l0bp";
+       sha256 = "77019a4817712f6bfc61c9d148b680579955eb40d286f7766f7b0a90c726febf";
        libraryHaskellDepends = [ base parsec ];
        description = "Utilities for parsing numbers from strings";
        license = stdenv.lib.licenses.bsd3;
@@ -101381,7 +101689,7 @@ self: {
      mkDerivation {
        pname = "parsec-parsers";
        version = "0.2";
-       sha256 = "1knmcciyq07vp06s3xh4hwz654n017863dh9hdp1mwm57vc43s3j";
+       sha256 = "72e841d83ea5f21a6e8309b661d009c092623e8704f6a10db8fb00ec2363d5ce";
        libraryHaskellDepends = [ base parsec parsers ];
        testHaskellDepends = [ base directory doctest filepath ];
        jailbreak = true;
@@ -101395,7 +101703,7 @@ self: {
      mkDerivation {
        pname = "parsec-permutation";
        version = "0.1.2.0";
-       sha256 = "0yfdgvw093kk5id9h6b566zniss26kw6rxnvsni6dgr4knzyx1xi";
+       sha256 = "b187eebf9d24bf66a2d5dbf66cf83442eb68bf316519985a2c738e04f87ecd79";
        libraryHaskellDepends = [ base parsec ];
        testHaskellDepends = [ base parsec QuickCheck ];
        description = "Applicative permutation parser for Parsec intended as a replacement for Text.Parsec.Perm.";
@@ -101407,7 +101715,7 @@ self: {
      mkDerivation {
        pname = "parsec-tagsoup";
        version = "0.1";
-       sha256 = "1pzspf5fimjlki5fn3lxz1kdpd9pf2ww8z9sf08zaiyfp4ms15n1";
+       sha256 = "c196a02bb9ce47f511703a7dc4b97037b5db66f89d0eeb4a9c54d6e88abbfadf";
        libraryHaskellDepends = [ base parsec tagsoup ];
        description = "Parsec parsers for Tagsoup tag streams";
        license = stdenv.lib.licenses.publicDomain;
@@ -101418,7 +101726,7 @@ self: {
      mkDerivation {
        pname = "parsec-utils";
        version = "0.1.0.0";
-       sha256 = "0pfdl9zsdzxcbjh37234djcbg6sdhqzx3fnin0b55hxn78k26ivi";
+       sha256 = "714723263ab6c35216b0d1bad13f864d9bb7986c648833a05cacffa67fa2cd5d";
        libraryHaskellDepends = [ base parsec ];
        description = "Utility functions and combinators for Text.Parsec";
        license = stdenv.lib.licenses.bsd3;
@@ -101429,7 +101737,7 @@ self: {
      mkDerivation {
        pname = "parsec1";
        version = "1.0.0.6";
-       sha256 = "0wwmghla8cqmmpwx9wwcmh39d9np9cgc1d0w3xf18k4adb1sg636";
+       sha256 = "6698a7c36a8a4c145c1f1cb4c01e4bd7a69606ac8cf3d4f9ad1533a4287c9573";
        libraryHaskellDepends = [ base ];
        homepage = "http://www.cs.uu.nl/~daan/parsec.html";
        description = "Portable monadic parser combinators";
@@ -101441,7 +101749,7 @@ self: {
      mkDerivation {
        pname = "parsec2";
        version = "1.0.0";
-       sha256 = "0iq5b5d0pdm49qnigss29vnxj3yjqa5rllp29dxl8df6393k6sk9";
+       sha256 = "696a33471ac635447b4be2529a8bc2d20fd9ed4e42eb172d4ea4b60b5a590547";
        libraryHaskellDepends = [ base ];
        homepage = "http://www.cs.uu.nl/~daan/parsec.html";
        description = "Monadic parser combinators";
@@ -101454,7 +101762,7 @@ self: {
      mkDerivation {
        pname = "parsec3";
        version = "1.0.1.8";
-       sha256 = "00p3kffqmsi6lvxbpa60nql3lgm9vnxsspp8m0jz2d2hfl7hadqf";
+       sha256 = "0e37050f755034f125a8e85eadbbdda93e3a28b6c0a8bbfaa626ea8a9d9be302";
        libraryHaskellDepends = [ base bytestring mtl text ];
        homepage = "http://www.cs.uu.nl/~daan/parsec.html";
        description = "Monadic parser combinators";
@@ -101466,7 +101774,7 @@ self: {
      mkDerivation {
        pname = "parsec3-numbers";
        version = "0.1.0";
-       sha256 = "0i7fvbhvvmf5nld51kv9v0vpb42dlnpivxcl7ll0zwa3gzks2cm5";
+       sha256 = "a532a1e77f43f10f283d94f51dafa54d907537d869cf501ab5c5d5bde1daee44";
        libraryHaskellDepends = [ base parsec ];
        description = "Utilities for parsing numbers from Char sequences";
        license = stdenv.lib.licenses.bsd3;
@@ -101477,7 +101785,7 @@ self: {
      mkDerivation {
        pname = "parsedate";
        version = "3000.0.0";
-       sha256 = "0gsylvm8srddmh3g3ysjgqqmgp0ddg6pdi2sz15v6nrvsqfabiip";
+       sha256 = "37c6a51cd63b5bb34bf85ac476cd6b0ddc57317e52fbf106acad658deaa65e3f";
        libraryHaskellDepends = [ base old-locale old-time parsec ];
        homepage = "http://www.cs.chalmers.se/~bringert/darcs/parsedate/doc/";
        description = "Data and time parsing for CalendarTime";
@@ -101489,7 +101797,7 @@ self: {
      mkDerivation {
        pname = "parseerror-eq";
        version = "0.1.0.1";
-       sha256 = "1w5hn50gwyq2qcax869nplmhrclpsxfy0ckij6ydlhmq22zh0l03";
+       sha256 = "035000bf10b842dabc917132e05dd797b20c2bbd3619d415c3027bfe40b1b0f0";
        libraryHaskellDepends = [ base parsec ];
        testHaskellDepends = [ base hspec parsec ];
        homepage = "https://github.com/stackbuilders/parseerror-eq";
@@ -101502,7 +101810,7 @@ self: {
      mkDerivation {
        pname = "parsek";
        version = "1.0.1.3";
-       sha256 = "184cbw9gz3vv2jbr2wzkygv25y70jayxd8d76pgpvjcaps4qqxp7";
+       sha256 = "e7768c89be8ac97ddf35a7a1d6bd92e0f822f6f3f3739197147b8fff125f8ca0";
        libraryHaskellDepends = [ base ];
        description = "Parallel Parsing Processes";
        license = stdenv.lib.licenses.gpl3;
@@ -101513,7 +101821,7 @@ self: {
      mkDerivation {
        pname = "parsely";
        version = "0.1";
-       sha256 = "16sg32qs1kq184wk6d83z20b9firh1kjmysqwd2aqaiyq37zjyyb";
+       sha256 = "cb7bf9cfc03e2aac44e358fb2a678039bab480f8033533394101cfa0b1184f9b";
        libraryHaskellDepends = [ base mtl parsec ];
        homepage = "http://naesten.dyndns.org:8080/repos/parsely";
        license = stdenv.lib.licenses.bsd3;
@@ -101525,7 +101833,7 @@ self: {
      mkDerivation {
        pname = "parser-helper";
        version = "0.1.0.0";
-       sha256 = "0cvdvphxlbyv5l9q5yc4b4kb59ghar2pmqx8pk387ffgz71r7ppb";
+       sha256 = "ebde93c3f9cfb983c6bca8e37a4556f0a5b2265984f982132ddb2fdae1dd6d33";
        isLibrary = false;
        isExecutable = true;
        executableHaskellDepends = [
@@ -101545,7 +101853,7 @@ self: {
      mkDerivation {
        pname = "parsergen";
        version = "0.2.0.7";
-       sha256 = "01yx4pa5x87nqz8k999jr7bnyfkjlgk660c53xkj5ipcvl4b9mfi";
+       sha256 = "d1d5b408ddecc622671f850163e6a3723a6fd7c932a534d1c7f6a05ed425dd07";
        libraryHaskellDepends = [
          base bytestring directory filepath parsec template-haskell
        ];
@@ -101568,7 +101876,7 @@ self: {
      mkDerivation {
        pname = "parsers";
        version = "0.12.2.1";
-       sha256 = "0wrzqx282ygc3m05nff2zkshgnx4lkws8d54qhkd9pjxja0fbjn7";
+       sha256 = "c7cae580925dded426c4a434a4f9a4a4db07f5fcc2395b401dec798144c73f73";
        libraryHaskellDepends = [
          attoparsec base charset containers parsec scientific text
          transformers unordered-containers
@@ -101590,7 +101898,7 @@ self: {
      mkDerivation {
        pname = "parsestar";
        version = "1.5";
-       sha256 = "0prbn7vi2bp66x4fs5cm8lz9qv4d1kpcd20mf24zwpa9siwyf4aq";
+       sha256 = "5811e779d4495dfe89701588c6ee0c8d6c9c3e459515ed4837e62e11f7b12b5f";
        isLibrary = true;
        isExecutable = true;
        libraryHaskellDepends = [
@@ -101612,7 +101920,7 @@ self: {
      mkDerivation {
        pname = "parsimony";
        version = "1.3";
-       sha256 = "0vbayvk989m85qfxxls74rn0v8ylb5l7lywp30sw2wybvi4r08lg";
+       sha256 = "8f229049dccb73c13518977b7a6859d4a30d6c2647d3de1d2ea82694e6f66a6d";
        libraryHaskellDepends = [ base bytestring text ];
        description = "Monadic parser combinators derived from Parsec";
        license = stdenv.lib.licenses.bsd3;
@@ -101623,7 +101931,7 @@ self: {
      mkDerivation {
        pname = "partial";
        version = "0.1.0.0";
-       sha256 = "0ybh0yz68gawbfswk1s498asc1z7qw6b8qys7rasw5i5iw6vjvr8";
+       sha256 = "286fb90d8f2516ae553eda63b40cc7e707a6154a4487c9b55b5c3d64be077079";
        revision = "1";
        editedCabalFile = "f49cbb0cfb2f101a006bb54ada3982ae85b6413d019fd92927ce259b3666e172";
        libraryHaskellDepends = [ base ];
@@ -101637,7 +101945,7 @@ self: {
      mkDerivation {
        pname = "partial-handler";
        version = "1.0.0.0";
-       sha256 = "1fmfiw38v77anh20xh5zzqxm2dcryyyismsagn09sc27jdgnnrzl";
+       sha256 = "f4676b5f9347309d807d4a571dbdf79935513bfebfc00e04b4ea9c8d068faeba";
        revision = "1";
        editedCabalFile = "2e1042c8b036ba686e544bfdd1302fd9f66f377010fa05739e7fc000d97fa597";
        libraryHaskellDepends = [ base ];
@@ -101651,7 +101959,7 @@ self: {
      mkDerivation {
        pname = "partial-isomorphisms";
        version = "0.2";
-       sha256 = "0wmlx1dp7i9rp3s5028gvqa7z0g1dkzlyd134kh04s1lx2hb94px";
+       sha256 = "fd92b4a0e8346802e02423344fff6ce1817f14de0f0950f4b839c5735be8b472";
        libraryHaskellDepends = [ base template-haskell ];
        homepage = "http://www.informatik.uni-marburg.de/~rendel/unparse";
        description = "Partial isomorphisms";
@@ -101665,7 +101973,7 @@ self: {
      mkDerivation {
        pname = "partial-lens";
        version = "0.0.1";
-       sha256 = "0s7p69fl1a3q4x2n9hf4540dcxjxjsj4knf2nal3wl1djh067ja8";
+       sha256 = "48c96300942d503ea8b2c2d949a4965d76d60029c4c164452778a8405d32f768";
        libraryHaskellDepends = [
          base comonad-transformers data-lens transformers
        ];
@@ -101680,7 +101988,7 @@ self: {
      mkDerivation {
        pname = "partial-uri";
        version = "0.2";
-       sha256 = "0n3rmajbmnydqk6jk36n83a6ra5p1dkdbd592ywjfq4jhmh98333";
+       sha256 = "630c946085926027b917a9b4d5660bb7a86cd440d68c29cdc4cddbbaa4aa7958";
        libraryHaskellDepends = [ base network-uri ];
        homepage = "https://github.com/singpolyma/partial-uri";
        description = "Datatype for passing around unresolved URIs";
@@ -101694,7 +102002,7 @@ self: {
      mkDerivation {
        pname = "partly";
        version = "1.0.0.2";
-       sha256 = "0s5cr0ysxv74dlziyf2ga29wawwlikqgb2njv8g1f1rb8i5n97gv";
+       sha256 = "fb9d644b442b07171edad28af5f08c9473c593504f381f3f6de4ecae3dc8ac68";
        isLibrary = true;
        isExecutable = true;
        libraryHaskellDepends = [ base binary bytestring ];
@@ -101719,7 +102027,7 @@ self: {
      mkDerivation {
        pname = "passage";
        version = "0.1";
-       sha256 = "11qrm27a1fn8p8z0q1400nd30sblm8pcn6znz4syg9jkmqhpn8ig";
+       sha256 = "2f227b21ae53a6e735f9f61bcb2eaa7469309a0580040c3ebac8baa08ea81987";
        libraryHaskellDepends = [
          array base containers directory filepath GraphSCC monadLib
          mwc-random pretty primitive process random
@@ -101734,7 +102042,7 @@ self: {
      mkDerivation {
        pname = "passwords";
        version = "0.1.0.6";
-       sha256 = "0x345pfa28abj152kkr1afnaraf4r8pj0216ack79brxvdhlk6li";
+       sha256 = "919a4961db3daf7426532608202fcac4a9acac5321cf294a904b21a1dc2d6474";
        libraryHaskellDepends = [ base containers MonadRandom random ];
        description = "Password generation/validation library";
        license = stdenv.lib.licenses.mit;
@@ -101745,7 +102053,7 @@ self: {
      mkDerivation {
        pname = "pastis";
        version = "0.1.2";
-       sha256 = "1425gzss5maqzrphrvvsw60lkapwg3wfjx10c59qkylx63k5ixjl";
+       sha256 = "54f658e6309dfa8953612074e9f878fcaa4981e17aef0c6ffe58d5a2f57f4590";
        libraryHaskellDepends = [ base HTTP network ];
        description = "Interface to the past.is URL shortening service";
        license = stdenv.lib.licenses.bsd3;
@@ -101757,7 +102065,7 @@ self: {
      mkDerivation {
        pname = "pasty";
        version = "0.1";
-       sha256 = "12pmqcpqa6gjph40w4ga53ij8b989igaf3r6jwxng67kmddkq22z";
+       sha256 = "5f083c5babf398673b97260fa75e4c282d24e328ea110e08bcf219852fc3f58a";
        isLibrary = false;
        isExecutable = true;
        executableHaskellDepends = [ base bytestring mtl ];
@@ -101772,7 +102080,7 @@ self: {
      mkDerivation {
        pname = "patch-combinators";
        version = "0.2.2";
-       sha256 = "007bxr6xfqjmbx4b9k3n3qw7jmrn298v8cqxvycfhy5924l9jyi6";
+       sha256 = "267a992811a978e898df1d33b45112365779381e76ccb4485f5562d74deeeb00";
        libraryHaskellDepends = [ base ];
        description = "A library for patching functions and data structures";
        license = stdenv.lib.licenses.bsd3;
@@ -101786,7 +102094,7 @@ self: {
      mkDerivation {
        pname = "patch-image";
        version = "0.1.0.1";
-       sha256 = "0ls3dlwgki483l1raaqb247by0kpzvqc54g1gmvr71zfgbfxrjl2";
+       sha256 = "82cadcdd7aee8793777de191c2f0fe7702bf0e110b2b95031d88c4f9386d4353";
        isLibrary = false;
        isExecutable = true;
        executableHaskellDepends = [
@@ -101807,7 +102115,7 @@ self: {
      mkDerivation {
        pname = "path";
        version = "0.5.2";
-       sha256 = "10ai0ygal1pipdi6221nhv0apgv8hzrra7jpgkn7nl62dbj2sl34";
+       sha256 = "64502de46ac2507bec7c571e95f38768bfabc08636086162bbf106aa9e075181";
        libraryHaskellDepends = [
          base exceptions filepath template-haskell
        ];
@@ -101821,7 +102129,7 @@ self: {
      mkDerivation {
        pname = "path-pieces";
        version = "0.2.0";
-       sha256 = "116zx2ryzywh2rd4q16a5vh04gw92as9vgfvraw3a66xn0m6g5y0";
+       sha256 = "c097672ab0dd1835b8cadbbd9db412893f02e02eca044c5a1690fbefb3e8df84";
        libraryHaskellDepends = [ base text time ];
        testHaskellDepends = [ base hspec HUnit QuickCheck text ];
        description = "Components of paths";
@@ -101833,7 +102141,7 @@ self: {
      mkDerivation {
        pname = "pathfinding";
        version = "0.1.0.0";
-       sha256 = "1d1vpkx4gl438b71mni80n46yrhz57z2hq2p9j2fkkpxj3k72y80";
+       sha256 = "007971e690fdcee9844c576028fe291f666f880528da1ace4283d047fabc3bb4";
        libraryHaskellDepends = [ base containers ];
        homepage = "https://github.com/rvion/pathfinding";
        description = "pathfinding in grid and graphs";
@@ -101845,7 +102153,7 @@ self: {
      mkDerivation {
        pname = "pathfindingcore";
        version = "1.2";
-       sha256 = "0x2bw79ym5rndhy5qd50gqv6fkqvp2zby4af2d5gdvsbm9fhv6c8";
+       sha256 = "88990d5daa4beff64a134e11bfbeb81b4f67367ea0345c3c6c3697ead3e14b74";
        libraryHaskellDepends = [ array base split ];
        testHaskellDepends = [ array base HUnit tasty tasty-hunit ];
        homepage = "http://github.com/TheBizzle";
@@ -101859,7 +102167,7 @@ self: {
      mkDerivation {
        pname = "pathtype";
        version = "0.5.4";
-       sha256 = "1ns5q3nrkl99xp4mrmk8wpvb9qzyvnw5cyjwh5rh76ykm2d5dbg7";
+       sha256 = "e7ad569aa8d39b0373815c7a56b8ddfee3b4f6e568d65cc9ed29d199edc045db";
        libraryHaskellDepends = [ base directory QuickCheck time ];
        homepage = "http://code.haskell.org/pathtype";
        description = "Type-safe replacement for System.FilePath etc";
@@ -101871,7 +102179,7 @@ self: {
      mkDerivation {
        pname = "patience";
        version = "0.1.1";
-       sha256 = "0qyv20gqy9pb1acy700ahv70lc6vprcwb26cc7fcpcs4scsc7irm";
+       sha256 = "35c7c334d344b3cbdc61cc88c559bedb300ace860a80e3990aeb268f1f10db63";
        libraryHaskellDepends = [ base containers ];
        description = "Patience diff and longest increasing subsequence";
        license = stdenv.lib.licenses.bsd3;
@@ -101882,7 +102190,7 @@ self: {
      mkDerivation {
        pname = "patronscraper";
        version = "0.0.0.1";
-       sha256 = "0agmgp3qvd710fcrqyfyvhck6yd311wxmmh5qd8lfgdm6597lhvi";
+       sha256 = "71437a5231b53d4751c305d6da7908a3793319dcde799c9903e1b48dc77df529";
        isLibrary = false;
        isExecutable = true;
        executableHaskellDepends = [ base HandsomeSoup hxt ];
@@ -101896,7 +102204,7 @@ self: {
      mkDerivation {
        pname = "pattern-arrows";
        version = "0.0.2";
-       sha256 = "13q7bj19hd60rnjfc05wxlyck8llxy11z3mns8kxg197wxrdkhkg";
+       sha256 = "6fc2d972e72785d727d2b68e1f82ef94a2c93cedbc00e6a4cdc03498825c078f";
        libraryHaskellDepends = [ base mtl ];
        homepage = "http://blog.functorial.com/posts/2013-10-27-Pretty-Printing-Arrows.html";
        description = "Arrows for Pretty Printing";
@@ -101910,7 +102218,7 @@ self: {
      mkDerivation {
        pname = "patterns";
        version = "0.1.1";
-       sha256 = "176si32zbrklf7wsspg0qdswd85ah0gl9k25ylx9qi2rr1vp18pv";
+       sha256 = "fba27077c859449c3af545cc441f80aaa0c675c3e05dadf97174e6f5c588da9c";
        libraryHaskellDepends = [
          base bytestring conduit containers mtl time utf8-string
          zeromq-haskell
@@ -101926,7 +102234,7 @@ self: {
      mkDerivation {
        pname = "paymill";
        version = "0.0.0";
-       sha256 = "1gw3mxh766wf5anyn84qcf8nn96fzd1ibcjg55bk9b1yw6dc1va0";
+       sha256 = "40edc09ae13eac3457294fb21543fbce246b91639820ebad2a8e1b7360af83bf";
        libraryHaskellDepends = [ base ];
        testHaskellDepends = [ base hspec ];
        description = "This is an unofficial client for the Paymill API";
@@ -101941,7 +102249,7 @@ self: {
      mkDerivation {
        pname = "paypal-adaptive-hoops";
        version = "0.11.0.2";
-       sha256 = "0z71j79wqxnixadpy47n30nrwhqya6qaadlwvrk9q60vrqvd21rm";
+       sha256 = "3507d136ce1b189c66de9c36a5b0511e439e2d18f6107f9bead176ccd391e17c";
        isLibrary = true;
        isExecutable = true;
        libraryHaskellDepends = [
@@ -101965,7 +102273,7 @@ self: {
      mkDerivation {
        pname = "paypal-api";
        version = "0.2";
-       sha256 = "0im96yxvbb78sb0b83yypcwsa27gnjbjxbfki5rdnpgbf2yr8k9h";
+       sha256 = "304d94bd70eb5ddb7289d3ad2e97b4ef08a539bbde0fb4c0d2e8acb5bb37a946";
        libraryHaskellDepends = [
          base bytestring conduit containers failure http-conduit http-types
          mtl old-locale text time wai
@@ -101982,7 +102290,7 @@ self: {
      mkDerivation {
        pname = "pb";
        version = "0.1.0";
-       sha256 = "03cb5diy7wvcd0gm09r4172mck0n4v5hxyc622r8k3phzvzq9zdf";
+       sha256 = "aefd84fffef08e89b21086f90ecb26164c56c5092427501f686cf3e3632b8b0d";
        isLibrary = false;
        isExecutable = true;
        executableHaskellDepends = [
@@ -101998,7 +102306,7 @@ self: {
      mkDerivation {
        pname = "pbc4hs";
        version = "0.1.1.5";
-       sha256 = "16dki82d9x6rpkbax090ax8ynwjxv31cvpzpy51ynq83kjg3v2z9";
+       sha256 = "e98b3d9e9c0361eb43f1f7dfcdc2d85d72eb51572081aed6bcd9f4d4048ab399";
        libraryHaskellDepends = [ base hslua string-qq ];
        jailbreak = true;
        homepage = "https://github.com/DavidFeng/pbc4hs";
@@ -102013,7 +102321,7 @@ self: {
      mkDerivation {
        pname = "pbkdf";
        version = "1.1.1.1";
-       sha256 = "1nbn8kan43i00g23g8aljxjpaxm9q1qhzxxdgks0mc4mr1f7bifx";
+       sha256 = "ddc5755cc895b00af47cadf70f71c0a97675659754a137c403200e62d54476d9";
        libraryHaskellDepends = [
          base binary byteable bytedump bytestring cryptohash utf8-string
        ];
@@ -102030,7 +102338,7 @@ self: {
      mkDerivation {
        pname = "pcap";
        version = "0.4.5.2";
-       sha256 = "0pydw62qqw61sxfd8x9vvwgpgl3zp6mqv8rm4c825ymzyipjxsg7";
+       sha256 = "e7e92e6ff4bffa22102335a38dabb97fd0771fdf3b75d45cd7c1708c85e1cd5f";
        libraryHaskellDepends = [ base bytestring network time ];
        homepage = "https://github.com/bos/pcap";
        description = "A system-independent interface for user-level packet capture";
@@ -102042,7 +102350,7 @@ self: {
      mkDerivation {
        pname = "pcap-conduit";
        version = "0.1";
-       sha256 = "07a6cwaq668a948njjybj9clbswmhz88xrwjkb42jg9gm1nh46kz";
+       sha256 = "7f1a026da82f3d29c89a92e78ed08795eb455992cb4b6911490a19831567461d";
        libraryHaskellDepends = [
          base bytestring conduit pcap transformers
        ];
@@ -102057,7 +102365,7 @@ self: {
      mkDerivation {
        pname = "pcap-enumerator";
        version = "0.5";
-       sha256 = "0v7ar3jbs54ibhrbbzmvajc7pc8h8dv56wr77w4vsbyz6xq4sqdb";
+       sha256 = "ab614d7037df2fbd093f277353764310b17b9854bbfeb5325c9114bde4c8ea6c";
        libraryHaskellDepends = [
          base bytestring enumerator pcap transformers
        ];
@@ -102074,7 +102382,7 @@ self: {
      mkDerivation {
        pname = "pcd-loader";
        version = "0.3.0.1";
-       sha256 = "1nwyv5c0x262b4j73560bnxhab07ky0cba8nrzdbmmwl2g72c8m7";
+       sha256 = "a72226ce1394d7badacf16a9c5809f072c05bb5dc094712459c2880e58d99edb";
        isLibrary = true;
        isExecutable = true;
        libraryHaskellDepends = [
@@ -102097,7 +102405,7 @@ self: {
      mkDerivation {
        pname = "pcf";
        version = "0.1.0.1";
-       sha256 = "1dmp9afylsf4n7gxa23wn25w8h89lqyhjlxa5g7gshrbwxkx7c55";
+       sha256 = "a5b0d367e72b43fdce2baa53093da60941c48bb07c08d5dfb1c469ea9d4ab7b6";
        libraryHaskellDepends = [
          base bound c-dsl containers monad-gen mtl prelude-extras
          transformers void
@@ -102113,7 +102421,7 @@ self: {
      mkDerivation {
        pname = "pcg-random";
        version = "0.1.3.1";
-       sha256 = "02sx8l51dks316n0df7h75igynb56ms8gs8siczbl5zrlrgycywi";
+       sha256 = "917be65fa6f917ba3e8b1ae98774356559ff6239f0b806ac0943cf160a455d0b";
        libraryHaskellDepends = [
          base bytestring entropy primitive random time
        ];
@@ -102130,7 +102438,7 @@ self: {
      mkDerivation {
        pname = "pcre-heavy";
        version = "0.2.2";
-       sha256 = "08cv6vmf5qpjky8zfrz3c5cczn5vrf30p5masyb3m625wm2sjjw3";
+       sha256 = "834ba945e545983a96d7aa960b86cbbbd8cf5861e367f7919ff2e2e2ea369b21";
        libraryHaskellDepends = [
          base bytestring pcre-light stringable template-haskell
        ];
@@ -102145,7 +102453,7 @@ self: {
      mkDerivation {
        pname = "pcre-less";
        version = "0.2.1";
-       sha256 = "1widnpz4r2az96lwxrq21vm21j9j7b4sn86kqn2iih3xs2dpwqf9";
+       sha256 = "c9617e9bd07dc01885c5d320abc93a32c920ea0e02e7cea9495f894cfeb52df2";
        libraryHaskellDepends = [ array base regex-pcre ];
        description = "Nicer interface to regex-pcre";
        license = stdenv.lib.licenses.bsd3;
@@ -102156,7 +102464,7 @@ self: {
      mkDerivation {
        pname = "pcre-light";
        version = "0.4.0.3";
-       sha256 = "0l1df2sk5qwf424bvb8mbdkr2xjg43fi92n5r22yd7vm1zz0jqvf";
+       sha256 = "6e6309fe0f759fe685c8c58a14dd204f7691675b15adbd88208ee332b5702d50";
        libraryHaskellDepends = [ base bytestring ];
        librarySystemDepends = [ pcre ];
        homepage = "https://github.com/Daniel-Diaz/pcre-light";
@@ -102169,7 +102477,7 @@ self: {
      mkDerivation {
        pname = "pcre-light-extra";
        version = "0.0.0";
-       sha256 = "1kjh36gglszd16rsh0rm2q5fxjlfipzld4hw0l2r23y0flbqkbvx";
+       sha256 = "7daf891775c00f9105051c9246ff8d8ecaee0a163503a8b309ed6bfa9e1950ce";
        libraryHaskellDepends = [ base bytestring pcre-light ];
        jailbreak = true;
        homepage = "http://github.com/urso/pcre-light-extra";
@@ -102184,7 +102492,7 @@ self: {
      mkDerivation {
        pname = "pcre-utils";
        version = "0.1.5";
-       sha256 = "0b6n3sls6r65kn7i9z607ck99sxw2xxh7frljc09cx73iy71ml69";
+       sha256 = "c9d01a8e8fe37496009334bb037b17bceb94263bc0fc148f9dc564a3a91ed62c";
        libraryHaskellDepends = [
          array attoparsec base bytestring mtl regex-pcre-builtin vector
        ];
@@ -102200,7 +102508,7 @@ self: {
      mkDerivation {
        pname = "pdf-toolbox-content";
        version = "0.0.3.3";
-       sha256 = "03kyp3nnbg4gchc4g9biavlf0hdjv77pc66jqngzjzmk8rh03k9c";
+       sha256 = "2ccd016046b37ef99fc5d21876cfd9b241e0e85671a54718648fbc65edb87e0e";
        libraryHaskellDepends = [
          attoparsec base base16-bytestring bytestring containers io-streams
          pdf-toolbox-core text
@@ -102217,7 +102525,7 @@ self: {
      mkDerivation {
        pname = "pdf-toolbox-core";
        version = "0.0.3.3";
-       sha256 = "006fp7cvq8r4l0iif2ihi0cq8pxl5mm8vf7ny4zhaniyyf52g68m";
+       sha256 = "1599278af33e5a053ff1f6b88d6a2db45f841988300a1723a02423bcd9b9ce00";
        libraryHaskellDepends = [
          attoparsec base bytestring containers errors io-streams scientific
          transformers zlib-bindings
@@ -102235,7 +102543,7 @@ self: {
      mkDerivation {
        pname = "pdf-toolbox-document";
        version = "0.0.5.1";
-       sha256 = "0qcnhdhxvrj9ypwyb3h7q7w6yn9jpzzrqrlhnas40lvjb9rc2yws";
+       sha256 = "9a7bc1725a725340b4b290669cffbf32596ff8c1078ee5f9f549e6dd61839661";
        libraryHaskellDepends = [
          base bytestring cipher-aes cipher-rc4 containers crypto-api
          cryptohash io-streams pdf-toolbox-content pdf-toolbox-core text
@@ -102254,7 +102562,7 @@ self: {
      mkDerivation {
        pname = "pdf-toolbox-viewer";
        version = "0.0.3.3";
-       sha256 = "02nnxvbd5l2wni9djqmdmqagb5k10dnc1k4crlkvrc8fa9rlajz2";
+       sha256 = "e24b4573520eb1bc27cd8cccc06c036196f514aead62d952b45cd0d2d6eed60a";
        isLibrary = false;
        isExecutable = true;
        executableHaskellDepends = [
@@ -102274,7 +102582,7 @@ self: {
      mkDerivation {
        pname = "pdf2line";
        version = "0.0.1";
-       sha256 = "07a9ddr4j5f4vhv1md32f0d3mwhx5p9lw0bwjikfhhqq49jvrpa5";
+       sha256 = "45ddbc65221843e866947c014ed32d1df23a1a7062b41a36dcc41549726b491d";
        isLibrary = false;
        isExecutable = true;
        executableHaskellDepends = [
@@ -102291,7 +102599,7 @@ self: {
      mkDerivation {
        pname = "pdfinfo";
        version = "1.5.4";
-       sha256 = "04894cwvcn910j2b0j95dc6i9v6xriqa0v97z3vyi9dhi9yiysls";
+       sha256 = "9a6a1f7d8ab0a5e8f7f8276da070ccddec140d6b2549b084042159b639230911";
        libraryHaskellDepends = [
          base mtl old-locale process-extras text time time-locale-compat
        ];
@@ -102305,7 +102613,7 @@ self: {
      mkDerivation {
        pname = "pdfsplit";
        version = "0.0.1";
-       sha256 = "00bnbfy3awl9vd9vvmh6ylfn2d882r3r1am6b6788b78lvznypxa";
+       sha256 = "aa5f6fffa6e82c848e59a6aa9047160835611df506d6bd53db897235bc5b7601";
        isLibrary = false;
        isExecutable = true;
        executableHaskellDepends = [
@@ -102324,7 +102632,7 @@ self: {
      mkDerivation {
        pname = "pdynload";
        version = "0.0.3";
-       sha256 = "0949nzk85fp9vs6v90cd6kxgg52pcaz2mfahv7416qpgp65hpw93";
+       sha256 = "23f10b8bb9ef6213c8d950b92abe625794f7fa348d81b48ddee9ba82e6b78924";
        libraryHaskellDepends = [
          base directory filepath ghc ghc-paths old-time process
        ];
@@ -102340,7 +102648,7 @@ self: {
      mkDerivation {
        pname = "peakachu";
        version = "0.3.1";
-       sha256 = "1wmlainnbrzpwrsr4qhw7m39s4crhc67xg1mxam0rfj9c1cnimxp";
+       sha256 = "b7d768596049ba0caaea35bc7e0c8399119d463d1c629275e6f7e7656d54b4f2";
        libraryHaskellDepends = [
          base derive GLUT List template-haskell time TypeCompose
        ];
@@ -102354,7 +102662,7 @@ self: {
      mkDerivation {
        pname = "peano";
        version = "0.1.0.1";
-       sha256 = "0yzcxrl41dacvx2wkyxjj7hgvz56l4qb59r4h9rmaqd7jcwx5z9i";
+       sha256 = "31fdd23993a76155738224a7b230a1a6fcfde091b2fbc945df4cb54068eeec7b";
        libraryHaskellDepends = [ base ];
        description = "Peano numbers";
        license = "unknown";
@@ -102365,7 +102673,7 @@ self: {
      mkDerivation {
        pname = "peano-inf";
        version = "0.6.5";
-       sha256 = "1w8rvlckqcy41ciq2csb2nf83l969nwvvrrlm0x1yzf5i6ibg33b";
+       sha256 = "6b8cb7a289c57d1f3aa834e7bdb94d26d1819c154b3381230bc4333c19dd19f1";
        libraryHaskellDepends = [ base containers lazysmallcheck ];
        description = "Lazy Peano numbers including observable infinity value";
        license = stdenv.lib.licenses.bsd3;
@@ -102379,7 +102687,7 @@ self: {
      mkDerivation {
        pname = "pec";
        version = "0.2.3";
-       sha256 = "110i4y93gm6b76and12vra8nr5q2dz20dvgpbpdgic3sv2ds16k0";
+       sha256 = "609aa09bd87ab0f8da5df7ed06c46f02976c91ca5b84669539cbd43792271184";
        isLibrary = true;
        isExecutable = true;
        libraryHaskellDepends = [
@@ -102400,7 +102708,7 @@ self: {
      mkDerivation {
        pname = "pecoff";
        version = "0.11";
-       sha256 = "0vb22jfl309k4a6b80015cyrs5cxls7vyf8faz7lrm7i0vj0vz1q";
+       sha256 = "38fc0de406f1d44ccf570e39bf8fa69d159d3d2b0100b48c223381419d14626d";
        libraryHaskellDepends = [ base binary bytestring containers ];
        description = "Parser for PE/COFF format";
        license = stdenv.lib.licenses.bsd3;
@@ -102413,7 +102721,7 @@ self: {
      mkDerivation {
        pname = "peg";
        version = "0.2";
-       sha256 = "0mh56nkn31dwpyrl238b06gyfwy3p7y90b9y6k639vpqkn9nnzcd";
+       sha256 = "8d7d6b939df8ee34cc343e2d90fcb9c373e79f010b0d41b3bfbc8561a7350556";
        isLibrary = false;
        isExecutable = true;
        executableHaskellDepends = [
@@ -102432,7 +102740,7 @@ self: {
      mkDerivation {
        pname = "peggy";
        version = "0.3.2";
-       sha256 = "1km847arc193wq6cdr38xvz1znbdmrgdyji2p9rs4j2p35rr6s6y";
+       sha256 = "de689373195748a273ba224adf5eae6dd91ffeee68e4c60ce6230596d521a8ce";
        isLibrary = true;
        isExecutable = true;
        libraryHaskellDepends = [
@@ -102453,7 +102761,7 @@ self: {
      mkDerivation {
        pname = "pell";
        version = "0.1.0.0";
-       sha256 = "0sxgliwhd0iplv3xd44a40vz8i2kmzvsq1a3zvbz4j77611hmnxd";
+       sha256 = "addb0a4330e748f2d7fe4305acf7af5344f437208a90d6c7a637820679a4af6b";
        libraryHaskellDepends = [ arithmoi base containers ];
        testHaskellDepends = [
          arithmoi base Cabal cabal-test-quickcheck containers primes
@@ -102473,7 +102781,7 @@ self: {
      mkDerivation {
        pname = "pem";
        version = "0.2.2";
-       sha256 = "162sk5sg22w21wqz5qv8kx6ibxp99v5p20g3nknhm1kddk3hha1p";
+       sha256 = "372808c76c6d860aedb4e30171cb4ee9f6154d9f68e3f2310f820bf174995a98";
        libraryHaskellDepends = [ base base64-bytestring bytestring mtl ];
        testHaskellDepends = [
          base bytestring HUnit QuickCheck test-framework
@@ -102489,7 +102797,7 @@ self: {
      mkDerivation {
        pname = "penn-treebank";
        version = "0.1.0.1";
-       sha256 = "12c5bzn3ac8783lny56n7rd8a1ik4ayfm1pr5v7gm7z53f7iz0qy";
+       sha256 = "1e831f8f1be59fface2ef986eabc223306855a3ed6146fe940073135ec5f8589";
        libraryHaskellDepends = [ base containers parsec ];
        description = "Tools for manipulating the Penn TreeBank";
        license = stdenv.lib.licenses.bsd3;
@@ -102505,7 +102813,7 @@ self: {
      mkDerivation {
        pname = "penny";
        version = "0.32.0.10";
-       sha256 = "0bzxihhi7cs8cqbnz7mf6sj12dyr267265asc010pgyffpjc22qi";
+       sha256 = "110bc1e475cebf0b02605a15238e11d93711a436ae9e6f176648b313218cfd2f";
        isLibrary = true;
        isExecutable = true;
        libraryHaskellDepends = [
@@ -102533,7 +102841,7 @@ self: {
      mkDerivation {
        pname = "penny-bin";
        version = "0.22.0.0";
-       sha256 = "0mdl8wpcy2yzscpww6vv5vhgiwy5xi0js1yxd7y4h5dmvhxsrr9l";
+       sha256 = "34e5ac3bdcb51548fc69dd072d41ecc5f3f8e02e7b1bce2fd3df0bcf2e47b455";
        isLibrary = false;
        isExecutable = true;
        executableHaskellDepends = [
@@ -102556,7 +102864,7 @@ self: {
      mkDerivation {
        pname = "penny-lib";
        version = "0.22.0.0";
-       sha256 = "0fy671xvia7kjlcrwpsv93gsnyz5wvcajlva98ykbh7cdkf56b17";
+       sha256 = "272c53dc6cecc0353d4a6a53a9d8e6e57babdf485b5f9e1995f3a8b87b38c63b";
        isLibrary = true;
        isExecutable = true;
        libraryHaskellDepends = [
@@ -102576,7 +102884,7 @@ self: {
      mkDerivation {
        pname = "peparser";
        version = "0.21";
-       sha256 = "1qy8hghpvp9idiq4ksn55n1dpx7823s7mjfvqfgrmhj0xl1b1y54";
+       sha256 = "a4f8b002ed40c29a9fc3dbc97af410e8f4db822dc5ea49706c31dd7de183c8e3";
        libraryHaskellDepends = [ base binary bytestring haskell98 ];
        homepage = "https://github.com/igraves/peparser-haskell";
        description = "A parser for PE object files";
@@ -102589,7 +102897,7 @@ self: {
      mkDerivation {
        pname = "perceptron";
        version = "0.1.0.3";
-       sha256 = "0w1vrsv43z92y6vsv9nzs2pjlqkhrxvzh53r2722530lzff34m78";
+       sha256 = "e854329cfb148c22c4117914f877cf70622aafd0dfa6adb7f122fd41b6ce3b70";
        libraryHaskellDepends = [ base ];
        jailbreak = true;
        description = "The perceptron learning algorithm";
@@ -102606,7 +102914,7 @@ self: {
      mkDerivation {
        pname = "perdure";
        version = "0.2.1";
-       sha256 = "04vj8kva5qmrf8r93xyf0qw8nx64j241pdc19s2ddvd21lq5wqkz";
+       sha256 = "7f625e300da2edd6844e81b51b8890c4748b3806cef7913272b9e2a2f6447213";
        isLibrary = true;
        isExecutable = true;
        libraryHaskellDepends = [
@@ -102634,7 +102942,7 @@ self: {
      mkDerivation {
        pname = "perm";
        version = "0.4.0.0";
-       sha256 = "0lf6smw3m32vwrga5y671z355w0vphp3n63cfnsirk1kiz5ik5rx";
+       sha256 = "3d9719cb8f33cc1cb5756c183b2ebc1bf052c60fc7f8a25ee65b8c3a78d5c651";
        libraryHaskellDepends = [ base catch-fd mtl transformers ];
        testHaskellDepends = [
          base HUnit mtl test-framework test-framework-hunit
@@ -102651,7 +102959,7 @@ self: {
      mkDerivation {
        pname = "permutation";
        version = "0.5.0.5";
-       sha256 = "005737s6k9dfpjmjf41m3k1wc31c2kql08ig7fd6npk22nhwmdai";
+       sha256 = "51b5caa115625e6b9a3b2f2240f1142c0cc6c31c351027abbcaea569f419a700";
        libraryHaskellDepends = [ base ghc-prim QuickCheck ];
        homepage = "https://github.com/spacekitteh/permutation";
        description = "A library for permutations and combinations";
@@ -102663,7 +102971,7 @@ self: {
      mkDerivation {
        pname = "permute";
        version = "1.0";
-       sha256 = "03g1d9h26f1id0pnaigy9xy1cv5pvzqcjrwgzn75xnnbm5c3y9ch";
+       sha256 = "90253f58a9cbda5e8efd8f67c9f0dfb76c167c4ffe45652f68313823606ae10d";
        libraryHaskellDepends = [ base mtl ];
        description = "Generalised permutation parser combinator";
        license = stdenv.lib.licenses.bsd3;
@@ -102675,7 +102983,7 @@ self: {
      mkDerivation {
        pname = "persist2er";
        version = "0.1.0.1";
-       sha256 = "096gjkmw06crywwwydyr67447xmp8x967dwh1gavlr0061skb72p";
+       sha256 = "579c3575300064bad50b90b7635247b7f643c831d937cf39f79919c0eb94cf24";
        isLibrary = false;
        isExecutable = true;
        executableHaskellDepends = [
@@ -102693,7 +103001,7 @@ self: {
      mkDerivation {
        pname = "persistable-record";
        version = "0.1.0.0";
-       sha256 = "1z03rixy03zp4l4ygb9jlj4p4x5vp20r5qq39hi8vn1x37j39x26";
+       sha256 = "46f434e4193dd88d224c03e39281b8bb747289a432ade70925f70fe07bcc03fc";
        libraryHaskellDepends = [
          array base containers dlist names-th template-haskell transformers
        ];
@@ -102714,7 +103022,7 @@ self: {
      mkDerivation {
        pname = "persistent";
        version = "2.2";
-       sha256 = "04l5394yrnm0d5cz7nq2phmsbm5vxbggn4wp8n0i0ms0y7blfh0p";
+       sha256 = "174047d7f140571081459713fbdeeabbd4a52bbc02dbf35969a0daec491a8512";
        libraryHaskellDepends = [
          aeson attoparsec base base64-bytestring blaze-html blaze-markup
          bytestring conduit containers exceptions fast-logger lifted-base
@@ -102739,7 +103047,7 @@ self: {
      mkDerivation {
        pname = "persistent-cereal";
        version = "0.1.0";
-       sha256 = "09akf8vpkn2jskf1vf9mq96sakqzr7mfs8hhri8qlbkwx3i5nr6f";
+       sha256 = "ce645be2e87c2e8a51cc1022edeac91f4fa54dc235b91ddcd452d87937725325";
        libraryHaskellDepends = [ base cereal persistent text ];
        jailbreak = true;
        homepage = "http://hub.darcs.net/co-dan/persistent-cereal";
@@ -102752,7 +103060,7 @@ self: {
      mkDerivation {
        pname = "persistent-equivalence";
        version = "0.3";
-       sha256 = "14nn01bbwskllbccgcnwnjwzyws6vppqv4l51n6pcvhwbphn18qz";
+       sha256 = "1fa360e15d1c6e768d0d85928defdd4673ffb9b4dcb2c7d8a2746abe5600d692";
        libraryHaskellDepends = [ array base diffarray ];
        jailbreak = true;
        description = "Persistent equivalence relations (aka union-find)";
@@ -102766,7 +103074,7 @@ self: {
      mkDerivation {
        pname = "persistent-hssqlppp";
        version = "0.1";
-       sha256 = "1p4fpa5qlkn2jmggszzmzg0bva8r8j0x7b2bidqyzlw2i9332ba2";
+       sha256 = "422d31468a82d3ef718b4bacd3814419a9bdc0fbf57ffd5e95c24e8a8bba8edc";
        libraryHaskellDepends = [
          base bytestring hssqlppp monad-control mtl persistent
          persistent-template template-haskell text th-lift
@@ -102781,7 +103089,7 @@ self: {
      mkDerivation {
        pname = "persistent-instances-iproute";
        version = "0.1.0.1";
-       sha256 = "0nmk138kv020aa0pw29l177rb6rji4rnmw4ndnkn1xvp8gh3w0yn";
+       sha256 = "d6033ee04377f760a76d96f06a3389329b95cf0934097e815240803dd108b35a";
        libraryHaskellDepends = [ base bytestring iproute persistent ];
        description = "Persistent instances for types in iproute";
        license = stdenv.lib.licenses.bsd3;
@@ -102794,7 +103102,7 @@ self: {
      mkDerivation {
        pname = "persistent-map";
        version = "0.3.5";
-       sha256 = "0an0j6xkxygxlvjj50fq356sc4njbniz9jzv6v2h9pihsmcckhvq";
+       sha256 = "78c3c958d530de04c536fbcbf4a35dd212a64d19d88122e5a6fdf93ebb91c02a";
        libraryHaskellDepends = [
          base binary containers directory EdisonAPI EdisonCore filepath LRU
          mtl stm-io-hooks
@@ -102814,7 +103122,7 @@ self: {
      mkDerivation {
        pname = "persistent-mongoDB";
        version = "2.1.2.2";
-       sha256 = "1ppjywipfp48dsahc4mf8p9vx99937yh552kq7dhalnd1yfcbcik";
+       sha256 = "33b2c59c0fcd5205dbc1539402fd1929a5bed345ae1206956e885c7723f7f2de";
        libraryHaskellDepends = [
          aeson attoparsec base bson bytestring cereal conduit containers
          monad-control mongoDB network path-pieces persistent resource-pool
@@ -102833,7 +103141,7 @@ self: {
      mkDerivation {
        pname = "persistent-mysql";
        version = "2.2";
-       sha256 = "09hajfvwgjkrmk1qmjfx3z6qkisv4gj0qjcmd1m8n9nb76bmdfz9";
+       sha256 = "e9bb569739cb268b6a6895490ce4235bc789cd1fddc98ac3ac79cac7b7930a26";
        libraryHaskellDepends = [
          aeson base blaze-builder bytestring conduit containers
          monad-control monad-logger mysql mysql-simple persistent resourcet
@@ -102853,7 +103161,7 @@ self: {
      mkDerivation {
        pname = "persistent-odbc";
        version = "0.2.0.1";
-       sha256 = "0rvcjl9p7pj0hrf0ghhj96ib2knhxnfi9nhc7cppn7gnja1x8ldp";
+       sha256 = "b751d48392f61d7b2f3b0cda149dedd04eb1a24912c2075c8640de7313956c67";
        isLibrary = true;
        isExecutable = true;
        libraryHaskellDepends = [
@@ -102875,7 +103183,7 @@ self: {
      mkDerivation {
        pname = "persistent-postgresql";
        version = "2.2";
-       sha256 = "0ydwc2jb8w3wma8f0v7i16pzglx0gv1ffikfvislw3c6wkangwby";
+       sha256 = "7ef167d5e4860d4e75dc6e46e7c27ea0d3f7af09f16ce090aa7c70b4a460bc79";
        libraryHaskellDepends = [
          aeson base blaze-builder bytestring conduit containers
          monad-control monad-logger persistent postgresql-libpq
@@ -102893,7 +103201,7 @@ self: {
      mkDerivation {
        pname = "persistent-protobuf";
        version = "0.1.5";
-       sha256 = "046dpasgv6bwcm17w0z9dz4bvaa622cdb8paj7j6accmsc4rvs9z";
+       sha256 = "3fe99d09d3953165e491eaa2d5981046a9bdc86fe9037e42657c99fdb4bacd10";
        libraryHaskellDepends = [
          base bytestring persistent protocol-buffers
          protocol-buffers-descriptor template-haskell text
@@ -102910,7 +103218,7 @@ self: {
      mkDerivation {
        pname = "persistent-ratelimit";
        version = "0.1.0.1";
-       sha256 = "13mvf0k4nkcdcz7gcvqsw3mrnbpvw0lvs94rff0y9q50cc6y36xd";
+       sha256 = "ad9be10d63a0e0e481739924bd29e0fb2e9bebe01a6ff6ce678d4d4b2670bb8e";
        libraryHaskellDepends = [ base time yesod ];
        jailbreak = true;
        homepage = "https://github.com/jprider63/persistent-ratelimit";
@@ -102927,7 +103235,7 @@ self: {
      mkDerivation {
        pname = "persistent-redis";
        version = "0.3.2";
-       sha256 = "0p5wjf4f201mpdwry188v1h9wf3fh1pvfsm663x4ipy3b1yc8b1k";
+       sha256 = "332cc47c58c3df48fa30a66ab76f806e389e60d808059f79bb3500e18893bc5c";
        libraryHaskellDepends = [
          aeson attoparsec base binary bytestring hedis monad-control mtl
          path-pieces persistent scientific text time transformers
@@ -102948,7 +103256,7 @@ self: {
      mkDerivation {
        pname = "persistent-refs";
        version = "0.4";
-       sha256 = "1lyhz0cywls91a6crjq5v8x4h4740s73h3blvbkr6fg26kh11cs6";
+       sha256 = "46b310e034e23993e7da740d388e06e410483ada05cbcc8c0a4953ee19f8d0d3";
        libraryHaskellDepends = [
          base containers mtl ref-fd transformers
        ];
@@ -102965,7 +103273,7 @@ self: {
      mkDerivation {
        pname = "persistent-sqlite";
        version = "2.2";
-       sha256 = "1567ja3f87syw6x6x6gl6xzdl3pl8ammlrqy2500gbgr7ni0a47i";
+       sha256 = "f11005a23df9ad0740111e675aab42f40eda7e37f4996ebae15e1fe48692c794";
        isLibrary = true;
        isExecutable = true;
        libraryHaskellDepends = [
@@ -102990,7 +103298,7 @@ self: {
      mkDerivation {
        pname = "persistent-template";
        version = "2.1.3.4";
-       sha256 = "0wi1mrcilz66jnlgz16crqlh4bibb03mj460bgg3af4f8zpwja2g";
+       sha256 = "4f28c9ef478e3835de5bc0105907582b2e0229cecc84ffa895c67c1a59ae2172";
        libraryHaskellDepends = [
          aeson base bytestring containers ghc-prim monad-control
          monad-logger path-pieces persistent tagged template-haskell text
@@ -103011,7 +103319,7 @@ self: {
      mkDerivation {
        pname = "persistent-vector";
        version = "0.1.1";
-       sha256 = "1l5v02pjb24gk4hw28knjp55l7z6jzcfiklfikd2nqbl7866c2j2";
+       sha256 = "420a660c3a74612bda8c8ecee8d897e61f5aca957622c121998f8825af00bbd0";
        libraryHaskellDepends = [ base deepseq ];
        testHaskellDepends = [
          base QuickCheck test-framework test-framework-quickcheck2
@@ -103031,7 +103339,7 @@ self: {
      mkDerivation {
        pname = "persistent-zookeeper";
        version = "0.2.0";
-       sha256 = "11s99wrxhyzyfg657dqma1v1vvdadskvrjybrya2zm8lp675ri9z";
+       sha256 = "3fc55c8eb914d52f94cfcbcbbca76eaaed1d765015b753cc73fe7bd8334f4987";
        libraryHaskellDepends = [
          aeson attoparsec base base64-bytestring binary bytestring conduit
          containers hzk monad-control mtl path-pieces persistent
@@ -103058,7 +103366,7 @@ self: {
      mkDerivation {
        pname = "persona";
        version = "0.1.0.0";
-       sha256 = "1w1m1m3kybk8cg8qn44l04i19i0zqgaz1i1k6666gvvrzk2rh7nh";
+       sha256 = "d01e98c5fc79ef678c3133c4f0d5c31fc414220194108bd163682e3f470d35f0";
        libraryHaskellDepends = [
          aeson base data-default-class jose lens network-uri text time
          unordered-containers
@@ -103077,7 +103385,7 @@ self: {
      mkDerivation {
        pname = "persona-idp";
        version = "0.1.0.2";
-       sha256 = "082ly9m0m0g9brgzma489i4b4pkqqy50gv0a6hn7pvyhpr901b6n";
+       sha256 = "d6ac0052bed0ef7b2c340aec078ac7785eb2484c88a8fa5f5ee9810a6af25420";
        isLibrary = false;
        isExecutable = true;
        executableHaskellDepends = [
@@ -103095,7 +103403,7 @@ self: {
      mkDerivation {
        pname = "pesca";
        version = "4.0.1";
-       sha256 = "12cwmjszbbqrd1f21jvwvp026ja3377c3p0wfrbrl34g23gnysgp";
+       sha256 = "f7696fdf108f0c9a57761cdcc1ce19434923c0dd7ccb205c6819aff5b5ac9c89";
        isLibrary = false;
        isExecutable = true;
        executableHaskellDepends = [ base process ];
@@ -103115,7 +103423,7 @@ self: {
      mkDerivation {
        pname = "peyotls";
        version = "0.1.6.5";
-       sha256 = "0dy641izw76cn1rslf7mbmbwhl5ajxjll95w4rg7pyvq2lq2qk9f";
+       sha256 = "2e4d2c301578fb7b5e26bc244a6597aa50c8575df538aa73b0cc1cfe6320c637";
        libraryHaskellDepends = [
          asn1-encoding asn1-types base bytable bytestring cipher-aes
          crypto-numbers crypto-pubkey crypto-pubkey-types crypto-random
@@ -103140,7 +103448,7 @@ self: {
      mkDerivation {
        pname = "pez";
        version = "0.1.0";
-       sha256 = "0w2m8i1h87v9l5lhz8mdllnrx62fk3isqhw3cvnv9rf6rk3zhv74";
+       sha256 = "e46cf8c7ccc6e5b4ed668343ace3984e989e2da5ada20f69a1691f0443445570";
        libraryHaskellDepends = [ base failure fclabels thrist ];
        testHaskellDepends = [
          base QuickCheck test-framework test-framework-quickcheck2
@@ -103159,7 +103467,7 @@ self: {
      mkDerivation {
        pname = "pg-harness";
        version = "0.2.1";
-       sha256 = "0ax6ch87jqbcy5il17n0kppy8pn44rj6ljksamh61sg438vcdhqf";
+       sha256 = "0ec3c6361ae4e96060557a4a6a6426c45ee4ef9dc09e4063f16c61791064a62b";
        isLibrary = true;
        isExecutable = true;
        libraryHaskellDepends = [ base bytestring HTTP ];
@@ -103178,7 +103486,7 @@ self: {
      mkDerivation {
        pname = "pg-harness-client";
        version = "0.3.1";
-       sha256 = "12z5354in4zswn219cvxhqbva76p2jsccmzdn5iyw5g401546lr2";
+       sha256 = "2253434a00e415ee63b1ed57c6b414d71cb517867db31484e5fa131b4919e58b";
        libraryHaskellDepends = [ base bytestring HTTP ];
        homepage = "https://github.com/BardurArantsson/pg-harness";
        description = "Client library for pg-harness-server";
@@ -103192,7 +103500,7 @@ self: {
      mkDerivation {
        pname = "pg-harness-server";
        version = "0.3.1";
-       sha256 = "0459i1x5hsxkihyb5a8ca947ngs0gg8866s77bcdsifjw6b3cb4a";
+       sha256 = "8a2c3696e1d245ddd83a471b83d07b403f7b48520ca9b23c8cb36b587a88a910";
        isLibrary = false;
        isExecutable = true;
        executableHaskellDepends = [
@@ -103213,7 +103521,7 @@ self: {
      mkDerivation {
        pname = "pgdl";
        version = "8.3";
-       sha256 = "0kbx9dgmy9pvcgcpsjplrpnqlk8x3icfpr0flincmzqkzxxzcaq5";
+       sha256 = "052bf67bff13ffca6ca40ee4eb581c1d4d8aedcdf44a7dd963fb265f5f4b7d4d";
        revision = "2";
        editedCabalFile = "9d6e976e130869b6761d870380b867c2501c43a1318a5f385687608c13a0ef72";
        isLibrary = false;
@@ -103232,7 +103540,7 @@ self: {
      mkDerivation {
        pname = "pgm";
        version = "0.1.4";
-       sha256 = "1s3kch1qsxrfzk9sa4b0jn9vzjhw7dvh1sajgnnz97gl5y0gydmv";
+       sha256 = "bb36ff802ff49df4ad7d52e900773b1ccabf93956011a5d3fc2e778d036473e8";
        libraryHaskellDepends = [ array base bytestring parsec ];
        homepage = "https://github.com/astanin/haskell-pgm";
        description = "Pure Haskell implementation of PGM image format";
@@ -103246,7 +103554,7 @@ self: {
      mkDerivation {
        pname = "pgp-wordlist";
        version = "0.1.0.1";
-       sha256 = "123d8fh1bd78iq4n00xc873zsnizczzdl372vkl87z4lpivfkpd3";
+       sha256 = "a3dde976bc94fc83e8dce20cdafe673f5afdc741ac0360098ee8b415a0436d88";
        libraryHaskellDepends = [ base bytestring containers text vector ];
        testHaskellDepends = [
          base bytestring HUnit tasty tasty-hunit tasty-quickcheck text
@@ -103265,7 +103573,7 @@ self: {
      mkDerivation {
        pname = "pgsql-simple";
        version = "0.1.2";
-       sha256 = "1z39g6bp748ya54in48vcg8z20c3skza82cv203rqy192nj01km5";
+       sha256 = "a5ce00a41529789c07109b09a4fed48301f1d1631b111b49511e9173977969fc";
        libraryHaskellDepends = [
          attoparsec base base16-bytestring binary blaze-builder
          blaze-textual bytestring containers MonadCatchIO-transformers mtl
@@ -103288,7 +103596,7 @@ self: {
      mkDerivation {
        pname = "pgstream";
        version = "0.1.0.3";
-       sha256 = "0zbasvi8392pa7ibd0q5072f1i7h0114v46rwhdfczsk1qzlnscg";
+       sha256 = "8f694b3f0e537fe61ae4d9904d4200f0c4e0c4010583b6e25157a481e2d66a7d";
        libraryHaskellDepends = [
          async attoparsec base blaze-builder bytestring conduit
          conduit-extra deepseq mtl parallel postgresql-binary
@@ -103307,7 +103615,7 @@ self: {
      mkDerivation {
        pname = "phantom-state";
        version = "0.2.0.2";
-       sha256 = "04fg0j79nkajsiw8n2yy62mwiw1r4fjy2jln5ng07h64pwyncdnm";
+       sha256 = "d536663dbfc4c0039e2d964ae1a52339f0c8ab30de0b8b78d4524d9b8e04cf11";
        libraryHaskellDepends = [ base transformers ];
        description = "Phantom State Transformer. Like State Monad, but without values.";
        license = stdenv.lib.licenses.bsd3;
@@ -103319,7 +103627,7 @@ self: {
      mkDerivation {
        pname = "phasechange";
        version = "0.1";
-       sha256 = "0i54myn9abrpzrs58llqgii9fhd9ns9hipnaj00dnqx2mfbg7pan";
+       sha256 = "56ddf396aba263db0090cade0893b6a94197627c98525474fe372f95acafa444";
        libraryHaskellDepends = [
          array base ghc-prim monad-st primitive vector
        ];
@@ -103337,7 +103645,7 @@ self: {
      mkDerivation {
        pname = "phash";
        version = "0.0.5";
-       sha256 = "1bndzncy52swvfk2p1imvxlbiv01qx9qi5mb68jmc22b1d99s6bv";
+       sha256 = "7b199d520b4b08562532ab968853c701ecb868df35862ba6db5c8be299fdcdae";
        libraryHaskellDepends = [ base ];
        librarySystemDepends = [ pHash ];
        testHaskellDepends = [
@@ -103358,7 +103666,7 @@ self: {
      mkDerivation {
        pname = "phone-push";
        version = "0.1.3";
-       sha256 = "0ndaddj3ssrdclzigdj0q04pwpdkbmhfc3rz8j7q9f4l7iv6yshi";
+       sha256 = "116a6f763c94b8848f443f0fe6605db35d7e09c040b6173f652d6b3d646baa59";
        libraryHaskellDepends = [
          base base16-bytestring binary bytestring conduit convertible
          HsOpenSSL http-conduit network time transformers
@@ -103374,7 +103682,7 @@ self: {
      mkDerivation {
        pname = "phonetic-code";
        version = "0.1.1.1";
-       sha256 = "0pjvjqxp37n901s16ys5qq5rzblamz8izvsd1992w06bcyrs36cw";
+       sha256 = "9c99a1b367cb002e520a4def1fd1af8aae9f0bc6457b137400c99e713b965b5e";
        libraryHaskellDepends = [ array base containers regex-compat ];
        homepage = "http://wiki.cs.pdx.edu/bartforge/phonetic-code";
        description = "Phonetic codes: Soundex and Phonix";
@@ -103388,7 +103696,7 @@ self: {
      mkDerivation {
        pname = "phooey";
        version = "2.0.0.1";
-       sha256 = "0aa0s7qmy78s4q1mjcnw0qiqlbmdmkmk2nbn6hkmw5fn29iq0iwj";
+       sha256 = "9247806312d6155e2734765931ebacad2e8a2306dc325903261a1d5ff1d14029";
        libraryHaskellDepends = [
          array base mtl reactive TypeCompose wx wxcore
        ];
@@ -103406,7 +103714,7 @@ self: {
      mkDerivation {
        pname = "photoname";
        version = "3.1";
-       sha256 = "0d44fzflpyw94rfyn9nw9pqklm01vw6nczava2kfj68sq12m94rp";
+       sha256 = "37935445c01a19e9a6505b7d660ddf01543af14ddc26eb5d2689fb4bdd778434";
        isLibrary = false;
        isExecutable = true;
        executableHaskellDepends = [
@@ -103427,7 +103735,7 @@ self: {
      mkDerivation {
        pname = "phraskell";
        version = "0.1.4";
-       sha256 = "1bczvnmbgc7qcpmlhrnmql4yn2grry2ys7hcg06sqzwr5qhl1k9k";
+       sha256 = "33cd40212e997fac0d780c1eed85cff909eb09c5d56648eb65f8b0b7aadd9fad";
        isLibrary = false;
        isExecutable = true;
        executableHaskellDepends = [ base mtl SDL transformers ];
@@ -103447,7 +103755,7 @@ self: {
      mkDerivation {
        pname = "phybin";
        version = "0.3";
-       sha256 = "1v6zcyfjnkgwc9kffi7lf15qb3j4wq2kclx26i1k9ssf6h7cs5g9";
+       sha256 = "e915cd0e344eeb344334a2533605e6448e854b70f444e76662fc4d2b9d67dfec";
        isLibrary = true;
        isExecutable = true;
        libraryHaskellDepends = [
@@ -103481,7 +103789,7 @@ self: {
      mkDerivation {
        pname = "pi-calculus";
        version = "0.0.5";
-       sha256 = "1w5krkss2qzzcqqmgqs369p5xnqyrm76vvsxd7mlhcdqaaj06n2q";
+       sha256 = "585803a452b83148eb695def6d4ecd1edb5e6e3243e3573166ff63a1f5ccb3f0";
        isLibrary = false;
        isExecutable = true;
        executableHaskellDepends = [
@@ -103503,7 +103811,7 @@ self: {
      mkDerivation {
        pname = "pia-forward";
        version = "0.1.0.1";
-       sha256 = "02ryfiibkbfx6zg1n0h8kvb4mkiai57cvllqcwp815x50rsrpd2r";
+       sha256 = "59b49b7506a597802e6798d2cd4e892ace4ad69e08021bde37ddadb962743e0b";
        revision = "1";
        editedCabalFile = "7ace7bfcb4b05c4099a28ec12b7e12682669ddfe6d4e5f68c4d74c05914b7582";
        isLibrary = false;
@@ -103528,7 +103836,7 @@ self: {
      mkDerivation {
        pname = "pianola";
        version = "0.1.1";
-       sha256 = "02y630yskx139l5yii45rf47w2a2v3x0pad59ac9qzjalv7s68aq";
+       sha256 = "5821a3cfa64a7e9c984aa5a90bfad842097e88cb85c4e80b4d23f4a93d18c60b";
        libraryHaskellDepends = [
          attoparsec attoparsec-iteratee base bytestring comonad
          comonad-transformers containers either errors filepath free
@@ -103547,7 +103855,7 @@ self: {
      mkDerivation {
        pname = "picologic";
        version = "0.1.1";
-       sha256 = "14wil9fqx7n7zk7ldhk336g9mbybcf0gljvwjrnra3r01yiz7f20";
+       sha256 = "40b8f3a30f200f956d967c4bfa8063cbaf9a9e1963c246cffcc79e8e5da29193";
        isLibrary = true;
        isExecutable = true;
        libraryHaskellDepends = [
@@ -103569,7 +103877,7 @@ self: {
      mkDerivation {
        pname = "picoparsec";
        version = "0.1.2.2";
-       sha256 = "1gf51clsfllfpmpm4bfzyicwk1zz3kymyi8zcdfm5y5rhg1yjcg9";
+       sha256 = "e931e9c383b9f8525d631f455ffd1cff87c959f4df2d526fbd8e52a7290bc5bd";
        libraryHaskellDepends = [
          array base bytestring containers deepseq monoid-subclasses
          scientific text
@@ -103589,7 +103897,7 @@ self: {
      mkDerivation {
        pname = "picosat";
        version = "0.1.3";
-       sha256 = "1ljgarjvhw7qi06bjykgbd17s27h73gdj21rpi5x4ddv9fb68k9p";
+       sha256 = "374d64964bbb35d24bbc3908d9de38f0087d425b6f7ab90c88f870b865564fd2";
        libraryHaskellDepends = [ base ];
        homepage = "https://github.com/sdiehl/haskell-picosat";
        description = "Bindings to the PicoSAT solver";
@@ -103601,7 +103909,7 @@ self: {
      mkDerivation {
        pname = "piet";
        version = "0.1";
-       sha256 = "0ab0msb12cj38qimxllwk0p0g9aggfxhgvdp2b5znxpixlr39cz9";
+       sha256 = "e9b33432edf176fbcb12b7ed07bb7b4fa5072e989cd25e234643321196ae6029";
        isLibrary = true;
        isExecutable = true;
        libraryHaskellDepends = [ array base containers Imlib mtl ];
@@ -103615,7 +103923,7 @@ self: {
      mkDerivation {
        pname = "piki";
        version = "0.5.2";
-       sha256 = "0rsc2anh20hlr2dfyh07dyrrfns0l1pibz6w129fp5l8m6h3xjin";
+       sha256 = "36ca3ea0a98896eb9208dcfc156fa0405b97b36f0740ef9ac8140201ad124c67";
        isLibrary = false;
        isExecutable = true;
        executableHaskellDepends = [ base mtl parsec text ];
@@ -103634,7 +103942,7 @@ self: {
      mkDerivation {
        pname = "pinboard";
        version = "0.6.5";
-       sha256 = "0xnxdnr2ifn0z78jzibg64znki2jppfy13fsl7s8vwrw0i5ys7a8";
+       sha256 = "481ded4b043cf38df4a1da8de0ddbd52c4693f316fc52fd1f9c0ba28b26ddd76";
        libraryHaskellDepends = [
          aeson base bytestring containers either haskell-src-exts HsOpenSSL
          http-streams http-types io-streams mtl network old-locale random
@@ -103650,7 +103958,7 @@ self: {
      mkDerivation {
        pname = "pipe-enumerator";
        version = "0.3.0.2";
-       sha256 = "0h6k00k85pn0jajk3rvvfnrfwlkllprhv00x0qd9zg9gg7lf7zkc";
+       sha256 = "6cfee3e8792fbd9f1a061d800df3a57452eeb2757be731a592c0de822600d340";
        libraryHaskellDepends = [ base enumerator pipes transformers ];
        homepage = "https://github.com/zadarnowski/pipe-enumerator";
        description = "A bidirectional bridge between pipes and iteratees";
@@ -103662,7 +103970,7 @@ self: {
      mkDerivation {
        pname = "pipeclip";
        version = "0.1.0.1";
-       sha256 = "1hmbhgnrq894jnm7gy6yc812nysvkrbjk6qqjmk7g7fsj46xpdfg";
+       sha256 = "cfb5db0d91da9d776695189b29579e5b7b2b0262def877aa9524219ced83abc2";
        isLibrary = false;
        isExecutable = true;
        executableHaskellDepends = [
@@ -103680,7 +103988,7 @@ self: {
      mkDerivation {
        pname = "pipes";
        version = "4.1.6";
-       sha256 = "0dbl9sa0ryclyxwm0zfmqvpx7ljmpnfccmnihxia35q471h50sid";
+       sha256 = "2d6a5060380497a16287d156c69cbd55d2d3efc6d57d5079f794f90c944e7435";
        libraryHaskellDepends = [ base mmorph mtl transformers ];
        testHaskellDepends = [
          base mtl QuickCheck test-framework test-framework-quickcheck2
@@ -103696,13 +104004,12 @@ self: {
      }:
      mkDerivation {
        pname = "pipes-aeson";
-       version = "0.4.1.3";
-       sha256 = "0c95fm4bj4y0dsar4r7n9irvhrcihylcp8k40khm2bqcad14pjjc";
+       version = "0.4.1.4";
+       sha256 = "59d9f8bd3078073d23591e66c94fc8258bc6c16465c7a80bd0ca9cc4fa449133";
        libraryHaskellDepends = [
          aeson attoparsec base bytestring pipes pipes-attoparsec
          pipes-bytestring pipes-parse transformers
        ];
-       jailbreak = true;
        homepage = "https://github.com/k0001/pipes-aeson";
        description = "Encode and decode JSON streams using Aeson and Pipes";
        license = stdenv.lib.licenses.bsd3;
@@ -103715,7 +104022,7 @@ self: {
      mkDerivation {
        pname = "pipes-async";
        version = "0.1.1";
-       sha256 = "1b0l3fnblfgwgcbd5brs5iwix4wix1ijx10ppwb8yb1wbqbmh8z2";
+       sha256 = "e22358175e3c2c8f16bf17842e63e891931e792c3aafd2167bfc39baac1b14ac";
        libraryHaskellDepends = [
          base lifted-async lifted-base monad-control pipes pipes-safe stm
          transformers-base
@@ -103736,7 +104043,7 @@ self: {
      mkDerivation {
        pname = "pipes-attoparsec";
        version = "0.5.1.2";
-       sha256 = "1qhhy86c89j6ial5y1j2lhgqx225qr33777jk8sxv021gkabsmlv";
+       sha256 = "9b56bdd47c4180dd359af29c3346c645888e1fa442065fa88a4626c40cf210e2";
        libraryHaskellDepends = [
          attoparsec base bytestring pipes pipes-parse text transformers
        ];
@@ -103756,7 +104063,7 @@ self: {
      mkDerivation {
        pname = "pipes-attoparsec-streaming";
        version = "0.1.0.0";
-       sha256 = "0alr94jjh583cdi19zrlacrc71dspy12lhq8h24hqiar6l2lr1d7";
+       sha256 = "a7854c053559450c898008432a82bfba85c3325334ff1462630315282549992a";
        isLibrary = true;
        isExecutable = true;
        libraryHaskellDepends = [
@@ -103777,7 +104084,7 @@ self: {
      mkDerivation {
        pname = "pipes-bgzf";
        version = "0.2.0.1";
-       sha256 = "04y0wzy8982g64xyxq6rl9xc63n0c8xl8mhyf0x4ivqxnn49iv23";
+       sha256 = "43ec9888b51def483a701e56443b62c00ec37aa2d9e0ee3b314fa084fce7c013";
        libraryHaskellDepends = [
          base bytestring mtl parallel pipes streaming-commons
        ];
@@ -103793,7 +104100,7 @@ self: {
      mkDerivation {
        pname = "pipes-binary";
        version = "0.4.0.4";
-       sha256 = "1c90vvdzbrp5x73iwpdcsi701v4krmqqxj0l9kyzfygvd242i56i";
+       sha256 = "d194288868fb79f7fd4c14c88e71cd93ec004ed4ac5d1ec7e9e5e6f5dbde20b1";
        libraryHaskellDepends = [
          base binary bytestring ghc-prim pipes pipes-bytestring pipes-parse
          transformers
@@ -103814,7 +104121,7 @@ self: {
      mkDerivation {
        pname = "pipes-bytestring";
        version = "2.1.1";
-       sha256 = "1zn8vbsq214x1dswaz1sb7vjjvwxjy5sg8cv67cdmac0l1rw5dmz";
+       sha256 = "bfb6c273a080a9dad8319ba1a78b979d6f29f7593a7cc5750b9d0481f5dac8fe";
        libraryHaskellDepends = [
          base bytestring pipes pipes-group pipes-parse transformers
        ];
@@ -103827,7 +104134,7 @@ self: {
      mkDerivation {
        pname = "pipes-cellular";
        version = "0.0.0.1";
-       sha256 = "0j0ayzvc9k3fmd9j37p41z50nqp4hwyywashcvng23qgp7m4ahdc";
+       sha256 = "ac4145eab90f0ff1ec66502bee3d87e4620bca0fe49e2153ab6eccc4f6f70a48";
        libraryHaskellDepends = [ base bytestring data-cell pipes ];
        homepage = "https://github.com/zadarnowski/pipes-cellular";
        description = "Pipes-based combinators for cellular data processing";
@@ -103840,7 +104147,7 @@ self: {
      mkDerivation {
        pname = "pipes-cellular-csv";
        version = "1.0.0.0";
-       sha256 = "1lzism9rrs1569lhbjl6b49c461igmpgvxq6pnnpfvnqbps56vc9";
+       sha256 = "896d53f45dd86e77adbd06f7fd6e7d3118c2125986ca05693225e89c53d5f1d3";
        libraryHaskellDepends = [
          base bytestring data-cell pipes pipes-cellular
        ];
@@ -103856,7 +104163,7 @@ self: {
      mkDerivation {
        pname = "pipes-cereal";
        version = "0.1.0.0";
-       sha256 = "04f538gyzvwxhqscsj9sywi6hz5k1fabjaga0vf861hlmv9agaa8";
+       sha256 = "48a9a7d2ae140683dc06ea29b9940bb37c6822f73a49cd34869defef1f1ac511";
        libraryHaskellDepends = [
          base bytestring cereal mtl pipes pipes-bytestring pipes-parse
        ];
@@ -103871,7 +104178,7 @@ self: {
      mkDerivation {
        pname = "pipes-cereal-plus";
        version = "0.4.0";
-       sha256 = "1x1qfl8s0lhvcz2hqh5dl5ilyixar995bqqzas721ni2skflbhqr";
+       sha256 = "19c345ddd422da208e561fe35552caaa474f63a1ad400cc5671b52a0117538f4";
        libraryHaskellDepends = [
          base bytestring cereal-plus errors mtl pipes pipes-bytestring text
        ];
@@ -103889,7 +104196,7 @@ self: {
      mkDerivation {
        pname = "pipes-cliff";
        version = "0.10.0.4";
-       sha256 = "0czgzmfl5rs0p63x24zr4pcl01a0wy93hx8wpin9k61yfx7bb4ix";
+       sha256 = "3d92b54e773e98996cbc1c753892e7400540d925f913d187b940e7425dfdef33";
        isLibrary = true;
        isExecutable = true;
        libraryHaskellDepends = [
@@ -103905,7 +104212,7 @@ self: {
      mkDerivation {
        pname = "pipes-concurrency";
        version = "2.0.3";
-       sha256 = "0jsfnlzl6yvhikgn6v361ld9aypv2h2nsz1q24dxfk953zvm2sp5";
+       sha256 = "e56a51f71f254dd71b11387c6d0514fb7a951a0d666c63df8c707b433fb54e4b";
        libraryHaskellDepends = [ base pipes stm ];
        testHaskellDepends = [ async base pipes stm ];
        description = "Concurrency for the pipes ecosystem";
@@ -103917,7 +104224,7 @@ self: {
      mkDerivation {
        pname = "pipes-conduit";
        version = "0.0.1";
-       sha256 = "1nzylhmi3f2m0xnqgx0m9g0p5pwl6xnidsz8ykzmv8wafrh60dh8";
+       sha256 = "08366060768aa35dfff4e8eb166d3794df72c14b15f4876d0755b8112ba4fedb";
        libraryHaskellDepends = [ base conduit mtl pipes-core ];
        jailbreak = true;
        homepage = "https://github.com/pcapriotti/pipes-extra";
@@ -103933,7 +104240,7 @@ self: {
      mkDerivation {
        pname = "pipes-core";
        version = "0.1.0";
-       sha256 = "1abzy45bjiy8lijg4a5xkwdh1k37c6m921y2s31x0yqgq79qlgyp";
+       sha256 = "d73f8ad3c10f7bd0c3d0c20791aa6167cc001b9fbd28f264a4c847b90af17fa9";
        libraryHaskellDepends = [
          base categories lifted-base monad-control transformers void
        ];
@@ -103948,7 +104255,7 @@ self: {
      mkDerivation {
        pname = "pipes-courier";
        version = "0.1.0.0";
-       sha256 = "1v2bm2cmzb6a7bmpv8byrb5x4k5pivp3s8ma6r6dwhldic294jgf";
+       sha256 = "ee4992048b8d42de4c36aa223dee8eb74cd2cbca7ea17deb3acaac5f99a84bec";
        libraryHaskellDepends = [ base courier pipes ];
        jailbreak = true;
        homepage = "http://github.com/kvanberendonck/pipes-courier";
@@ -103964,7 +104271,7 @@ self: {
      mkDerivation {
        pname = "pipes-csv";
        version = "1.4.0";
-       sha256 = "1q1gnfnkvlkk8lwllhyar7323k3jynh9rl6x9yks7lc3nqr1n16j";
+       sha256 = "d2041b32b683d1a3a74fddd09ca0f572cc21c6c9ca434a394573d23dadb32fe0";
        libraryHaskellDepends = [
          base blaze-builder bytestring cassava pipes unordered-containers
          vector
@@ -103983,7 +104290,7 @@ self: {
      mkDerivation {
        pname = "pipes-errors";
        version = "0.3";
-       sha256 = "1vbpchs3v08sc1rfa9fl89wzxg9ak823xjbkl0k37ycwwc36fn76";
+       sha256 = "e6586706e39cf93326a073c93e049a2abdfe7942d425e572601a813d346477ed";
        libraryHaskellDepends = [ base errors pipes ];
        jailbreak = true;
        homepage = "https://github.com/jdnavarro/pipes-errors";
@@ -103999,7 +104306,7 @@ self: {
      mkDerivation {
        pname = "pipes-extra";
        version = "0.2.0";
-       sha256 = "0yrbjs9y9s9a1q59138f7m0fsp8vsg0a31sfzgwfrg9pm2sfivfr";
+       sha256 = "d9ede8b4a837bdecf8fb4e87a1c0d31b5ded403d0e8d900a0e2ae9e493962b7b";
        isLibrary = true;
        isExecutable = true;
        libraryHaskellDepends = [
@@ -104022,7 +104329,7 @@ self: {
      mkDerivation {
        pname = "pipes-extras";
        version = "1.0.0";
-       sha256 = "1dwqvbmngiprdffi9l0vhrlchfrr8cl0dvzlb34pmczkm9rvq8xk";
+       sha256 = "b323bc73aaf3b37ac958f4ef062843393bc868861bd0149d6bf9c667ebda98b7";
        libraryHaskellDepends = [ base foldl pipes transformers ];
        testHaskellDepends = [
          base HUnit pipes test-framework test-framework-hunit transformers
@@ -104039,7 +104346,7 @@ self: {
      mkDerivation {
        pname = "pipes-fastx";
        version = "0.3.0.0";
-       sha256 = "0xds11gfacj7m5lz6cssaj4v5z73ycrdmn57f0qxzqdsc2kln9ii";
+       sha256 = "31264ba760bae1df3170a7d8da32f3e3fcb289545a33f369a94732e55e08ba75";
        libraryHaskellDepends = [
          attoparsec base bytestring pipes pipes-attoparsec pipes-bytestring
        ];
@@ -104047,12 +104354,39 @@ self: {
        license = stdenv.lib.licenses.bsd3;
      }) {};
 
+  "pipes-files" = callPackage
+    ({ mkDerivation, attoparsec, base, bytestring, directory, doctest
+     , exceptions, filepath, free, hierarchy, hspec, hspec-expectations
+     , mmorph, monad-control, mtl, pipes, pipes-safe, posix-paths
+     , process, regex-posix, semigroups, text, time, transformers
+     , transformers-base, transformers-compat, unix, unix-compat
+     }:
+     mkDerivation {
+       pname = "pipes-files";
+       version = "0.1.1";
+       sha256 = "a895f464790996ca19195fe605040520660087a36e8c6316fe6647bc23d516aa";
+       libraryHaskellDepends = [
+         attoparsec base bytestring directory exceptions filepath free
+         hierarchy mmorph monad-control mtl pipes pipes-safe posix-paths
+         regex-posix semigroups text time transformers transformers-base
+         transformers-compat unix unix-compat
+       ];
+       testHaskellDepends = [
+         base bytestring directory doctest filepath hierarchy hspec
+         hspec-expectations mtl pipes pipes-safe process semigroups text
+         transformers unix
+       ];
+       homepage = "https://github.com/jwiegley/pipes-files";
+       description = "Fast traversal of directory trees using pipes";
+       license = stdenv.lib.licenses.bsd3;
+     }) {};
+
   "pipes-group" = callPackage
     ({ mkDerivation, base, free, pipes, pipes-parse, transformers }:
      mkDerivation {
        pname = "pipes-group";
        version = "1.0.2";
-       sha256 = "01k1j0b7rg39lfh2zhxxnj1bclmaas69b9wiai89h5i1m6aanmp0";
+       sha256 = "e056ab94a9211698505491a7958c56aa52b682b4bdc32fa0a369bc7c16906106";
        libraryHaskellDepends = [
          base free pipes pipes-parse transformers
        ];
@@ -104067,7 +104401,7 @@ self: {
      mkDerivation {
        pname = "pipes-http";
        version = "1.0.2";
-       sha256 = "0hqab1pzcj11qwvc4dznis0qsyn1zc1d0riqxy6b5k04p9i2jbzk";
+       sha256 = "f32f2962ba04ccb28cef3866d002fbc17a8d818ef637c236c72148f66f580a43";
        libraryHaskellDepends = [
          base bytestring http-client http-client-tls pipes
        ];
@@ -104082,7 +104416,7 @@ self: {
      mkDerivation {
        pname = "pipes-illumina";
        version = "0.1.0.0";
-       sha256 = "19s6rkrfvmni914flq37fkbfs6angzl3c40bzg0ddivn4ada7jvn";
+       sha256 = "76cba39a2276c7d6c0fb0b1036e87f5619edd6746760ea4848d1d6edf2cc46a7";
        libraryHaskellDepends = [
          base bytestring directory filepath pipes pipes-bgzf
        ];
@@ -104096,7 +104430,7 @@ self: {
      mkDerivation {
        pname = "pipes-interleave";
        version = "0.2.1";
-       sha256 = "1xs48bxr4qjnwcmaajl3av4db87bxwm6nyffk3k5rks47lqmra3r";
+       sha256 = "79a85c313d44cf5ce698ce796b2aefeba0d5c856834aa52ae3566292fb4244f7";
        libraryHaskellDepends = [ base containers pipes ];
        homepage = "http://github.com/bgamari/pipes-interleave";
        description = "Interleave and merge streams of elements";
@@ -104108,7 +104442,7 @@ self: {
      mkDerivation {
        pname = "pipes-mongodb";
        version = "0.1.0.0";
-       sha256 = "0h4334fajrza7r8jrr78nqhs522kxnbzdj0gnbp7ndvzvx5ij888";
+       sha256 = "0821194bdf7f377beeb20fc8f697ed5388a221b6e8e42c513eea67a91c198340";
        libraryHaskellDepends = [ base monad-control mongoDB pipes ];
        testHaskellDepends = [ base monad-control mongoDB pipes text ];
        homepage = "http://github.com/jb55/pipes-mongodb";
@@ -104123,7 +104457,7 @@ self: {
      mkDerivation {
        pname = "pipes-network";
        version = "0.6.4";
-       sha256 = "1wabyv5j4q0wxiz8ry7dq3amlvfh4r0721pd2lksx7hj3a5qzm2p";
+       sha256 = "57d48f8b1a129eae2715ed06714026d06d5ad5c0edf88c7eec1c6022cbf64bf1";
        libraryHaskellDepends = [
          base bytestring network network-simple pipes pipes-safe
          transformers
@@ -104141,7 +104475,7 @@ self: {
      mkDerivation {
        pname = "pipes-network-tls";
        version = "0.2.1";
-       sha256 = "0k3w13s3vasd85mapa594xhi31mhdwqycxqnadidqy24q5s6zdhc";
+       sha256 = "0cb66f74c14478dc62531677e6316fb086116127a9a8ab6a414dab3df4087c4c";
        libraryHaskellDepends = [
          base bytestring network network-simple network-simple-tls pipes
          pipes-network pipes-safe tls transformers
@@ -104161,7 +104495,7 @@ self: {
      mkDerivation {
        pname = "pipes-p2p";
        version = "0.4";
-       sha256 = "1ls89dnz0aibmyy4mky7jl4ibirpfrs12yxmflarghv3j6rn0wnc";
+       sha256 = "cc7260b39163c3971575b57b11747637c7150995c7cf4abcaf2b2af06d4b48d3";
        libraryHaskellDepends = [
          async base binary bytestring errors exceptions mtl network
          network-simple-sockaddr pipes pipes-concurrency pipes-network
@@ -104178,7 +104512,7 @@ self: {
      mkDerivation {
        pname = "pipes-p2p-examples";
        version = "0.3";
-       sha256 = "08fdk005yrmr8mz3qlsfjys3pz9iidk53maylbgdk3nixk8plwwm";
+       sha256 = "95737ad1ecd18ed9dea25ed551668b31fd3bb4974e533c7e45b9665f0098cd21";
        isLibrary = false;
        isExecutable = true;
        executableHaskellDepends = [
@@ -104197,7 +104531,7 @@ self: {
      mkDerivation {
        pname = "pipes-parse";
        version = "3.0.3";
-       sha256 = "00sslgh1h1n114adc0k2w23wk19pzmf2mh5zn37w40jdganrhlpm";
+       sha256 = "f55298ad7a4d02c2cfb0bfc02a5cfd3785c987e06202d61409c10618e0a35a03";
        libraryHaskellDepends = [ base pipes transformers ];
        description = "Parsing infrastructure for the pipes ecosystem";
        license = stdenv.lib.licenses.bsd3;
@@ -104211,7 +104545,7 @@ self: {
      mkDerivation {
        pname = "pipes-postgresql-simple";
        version = "0.1.2.0";
-       sha256 = "12ij2msdwjzzc93mlvvizh6amam5ld9j1a0b9xsa2awdjd21mwc1";
+       sha256 = "81f11a44938d2ba1744f0ba82053a3a5aaaa0cfc716f5a4762ff4bde7415328a";
        libraryHaskellDepends = [
          async base bytestring exceptions mtl pipes pipes-concurrency
          pipes-safe postgresql-simple stm text transformers
@@ -104225,7 +104559,7 @@ self: {
      mkDerivation {
        pname = "pipes-rt";
        version = "0.5.0";
-       sha256 = "1wlgwil8ag6ax0kvammbqk7v2d8k6ygdqpjpys97zxrvy47dfc6r";
+       sha256 = "d930d70ef13bf77f92f6575edc9e371335b1cfc4ab56b527e8ca3c8568e48ff2";
        isLibrary = true;
        isExecutable = true;
        libraryHaskellDepends = [ base mwc-random pipes time ];
@@ -104242,7 +104576,7 @@ self: {
      mkDerivation {
        pname = "pipes-safe";
        version = "2.2.3";
-       sha256 = "19wr3q6skwdyd68k1r33w2mipfsgsg2982027faq7rnfw9lq2yyi";
+       sha256 = "d17b8169e2cee683953b020894c4d34fbb1babe063e4309169bef1a90d1e99a7";
        libraryHaskellDepends = [
          base containers exceptions monad-control mtl pipes transformers
          transformers-base
@@ -104258,7 +104592,7 @@ self: {
      mkDerivation {
        pname = "pipes-shell";
        version = "0.1.3";
-       sha256 = "0w49il312ns8pyl05144gznxfdchd0rnq8hprmjrgy8yp3v8j4v1";
+       sha256 = "611389f6b81ef99765cd17226c33689035d7ed7f848402a8bf485b11068d8970";
        libraryHaskellDepends = [
          async base bytestring pipes pipes-bytestring pipes-safe process stm
          stm-chans text
@@ -104280,7 +104614,7 @@ self: {
      mkDerivation {
        pname = "pipes-text";
        version = "0.0.0.16";
-       sha256 = "0db6xh10g4h1zy62aamcz59hykhlnq8d7qs24yp7lva8g0ymapyv";
+       sha256 = "db5f553d78486d7aae2742e3d310b6144e0f53f9ac2a258cff01920702ec6635";
        libraryHaskellDepends = [
          base bytestring pipes pipes-bytestring pipes-group pipes-parse
          pipes-safe streaming-commons text transformers
@@ -104297,7 +104631,7 @@ self: {
      mkDerivation {
        pname = "pipes-vector";
        version = "0.6.2";
-       sha256 = "11nibsshxgnr2jw8lh8q9aygbmpfsq7mf7kdvaqzyggmrdsns2wn";
+       sha256 = "960b6d75cbf53dffb1da6d1e570fd6eed6f5bc4a18418ab814d9be0eb55ed186";
        libraryHaskellDepends = [
          base monad-primitive pipes primitive transformers vector
        ];
@@ -104312,7 +104646,7 @@ self: {
      mkDerivation {
        pname = "pipes-wai";
        version = "3.0.2";
-       sha256 = "0wfab4nln9v91qprwm2ik9cz27m2qdhcw7qnndg4dhq47m7kvaw8";
+       sha256 = "88ab3d4f3d04c3465eb3161fce60c3a21ef1599a51549e2f0e69274b2d59ca71";
        libraryHaskellDepends = [
          base blaze-builder bytestring http-types pipes transformers wai
        ];
@@ -104328,7 +104662,7 @@ self: {
      mkDerivation {
        pname = "pipes-websockets";
        version = "0.0.0.0";
-       sha256 = "176gp747anh6a4wghkcj3jblb7ywhrp8c5wc7wrain77vn1sihk6";
+       sha256 = "66c2a883dde7d8a8323f8c17866e86dc9f45971c924df83851065a75c8b9cf9c";
        libraryHaskellDepends = [ base ];
        testHaskellDepends = [
          base QuickCheck test-framework test-framework-hunit
@@ -104347,7 +104681,7 @@ self: {
      mkDerivation {
        pname = "pipes-zeromq4";
        version = "0.2.0.0";
-       sha256 = "1zlj7vcn3ng11n80a9m37al7y322ph9grq5qxn022vpb82baxwr4";
+       sha256 = "24f3ae9640eb6e2180edb8e0fc12bc420c7fa83aa32605900de1d961d93e92fe";
        isLibrary = true;
        isExecutable = true;
        libraryHaskellDepends = [
@@ -104368,7 +104702,7 @@ self: {
      mkDerivation {
        pname = "pipes-zlib";
        version = "0.4.3";
-       sha256 = "04iiw0r1mnxl4myyp87wqhff6jm0g2246gwismi7jnwy7xmllsmc";
+       sha256 = "ac6a4a6b3f9e5b7962d5913f438478a04ae31cc4fca0eb7d25b4db1a32e03112";
        libraryHaskellDepends = [
          base bytestring pipes transformers zlib zlib-bindings
        ];
@@ -104384,7 +104718,7 @@ self: {
      mkDerivation {
        pname = "pisigma";
        version = "0.2.1";
-       sha256 = "1mz4cfhg8y7cv38ir2lzl7b2p1nfm8c4syvgzz4b9j98dxg694xz";
+       sha256 = "bf93645e6f28c9b4c8ff6f7b4d18aace862bd6a19f8a1cd1d8ec78f4a063e4d7";
        isLibrary = true;
        isExecutable = true;
        libraryHaskellDepends = [
@@ -104405,7 +104739,7 @@ self: {
      mkDerivation {
        pname = "pit";
        version = "0.3.1";
-       sha256 = "10qrhpxk8v5qrs4pq4ghj0dj3brsbiv61pb5vakpq031h7grfg8p";
+       sha256 = "173d97df8161007ca7da65dd60765c3aaf211b90f0117c89ceb86c34fb851983";
        isLibrary = true;
        isExecutable = true;
        libraryHaskellDepends = [
@@ -104427,7 +104761,7 @@ self: {
      mkDerivation {
        pname = "pkcs1";
        version = "1.0.2";
-       sha256 = "1598gj6r6mv3z68qir1rgjk4p73w0k2fwkkban04s97xf86a0669";
+       sha256 = "c918a00c72fd244d80556b4eeec4047c9c4ba67c39e48891f96357938d7c2895";
        libraryHaskellDepends = [ base bytestring random ];
        homepage = "http://sep07.mroot.net/";
        description = "RSA encryption with PKCS1 padding";
@@ -104439,7 +104773,7 @@ self: {
      mkDerivation {
        pname = "pkggraph";
        version = "0.1";
-       sha256 = "019mli0g65g7k4rsp2myxc7g6p6wykj85amvb2g2ipw117zpzkfz";
+       sha256 = "dfcd7fff0981df289e58bbaa82e4f4dc5cf30eebbe8aab3399e715f340a43505";
        isLibrary = false;
        isExecutable = true;
        executableHaskellDepends = [ base Cabal split ];
@@ -104453,7 +104787,7 @@ self: {
      mkDerivation {
        pname = "pktree";
        version = "0.2";
-       sha256 = "172dsg1krxqamq8ids9xwyfqidr9z0qq4nmbq4rk2x62g4q0960c";
+       sha256 = "0c98043079c2743133c1ab5a8231f829b7889de73de91611ae0af73cc3d34d9c";
        libraryHaskellDepends = [ base containers ];
        homepage = "https://github.com/singpolyma/pktree-haskell";
        description = "Implementation of the PKTree spatial index data structure";
@@ -104465,7 +104799,7 @@ self: {
      mkDerivation {
        pname = "placeholders";
        version = "0.1";
-       sha256 = "0ih35n2pw5gr9ggj2xz5zfcs4bdk200fdw6q9hdy3xna7maphak5";
+       sha256 = "652a78553dcaf6e11b4cd8f0e60010b32da299fbe57721df4bf9157e852d0346";
        libraryHaskellDepends = [ base template-haskell ];
        homepage = "http://github.com/ahammar/placeholders";
        description = "Placeholders for use while developing Haskell code";
@@ -104477,7 +104811,7 @@ self: {
      mkDerivation {
        pname = "plailude";
        version = "0.6.0";
-       sha256 = "13hqkz0p3c81d7v3qnbcf90cxyb15na9icfjch4hw0222i6kn21i";
+       sha256 = "31083b4d1442000e0964d2b198942d61f9ce40726c593cf66901b171c19f188e";
        libraryHaskellDepends = [ base bytestring mtl time unix ];
        jailbreak = true;
        homepage = "https://secure.plaimi.net/works/plailude";
@@ -104492,7 +104826,7 @@ self: {
      mkDerivation {
        pname = "planar-graph";
        version = "1.0.0.0";
-       sha256 = "1c7a168wkym50nh6a0vqfnqgj4hsk91d4x3w84ip0phcnig65iip";
+       sha256 = "37c6625eb40c5e7023417c74d2429a1a12f9b075780365a005a5fac99109eab0";
        libraryHaskellDepends = [
          attoparsec base blaze-builder bytestring containers data-clist
          deepseq
@@ -104508,7 +104842,7 @@ self: {
      mkDerivation {
        pname = "plat";
        version = "0.1.0.1";
-       sha256 = "06syff2yzrs7qvj8m1f7bgzd6qc834zl9qphv67q3ps5r2hy09qd";
+       sha256 = "0d27e0a1c845df818fd9f0e2443f198861d3fe5bc7858ae4c647e7ef85735e1b";
        libraryHaskellDepends = [
          base bytestring containers mtl utf8-string
        ];
@@ -104524,7 +104858,7 @@ self: {
      mkDerivation {
        pname = "playlists";
        version = "0.3.0.0";
-       sha256 = "1g49w0h3fms4ihxwbaq0bg0dzgqa1k83zrbnnd57svcr5qgi9clb";
+       sha256 = "8bb2141f2e996d7d4ab376e53fd00c0abfdfc05b00abc53b8c44573720e089bc";
        isLibrary = true;
        isExecutable = true;
        libraryHaskellDepends = [
@@ -104544,7 +104878,7 @@ self: {
      mkDerivation {
        pname = "plist";
        version = "0.0.6";
-       sha256 = "0xsx1pvlnqyidpvswisir9p9054r7fczi81nccflazijn3pr9rgb";
+       sha256 = "ebe594efb0327e451d6336a0f8993b9914906eca5147aef76dd1634bf70d5d77";
        libraryHaskellDepends = [ base base64-bytestring bytestring hxt ];
        description = "Generate and parse Mac OS X property list format";
        license = stdenv.lib.licenses.bsd3;
@@ -104558,7 +104892,7 @@ self: {
      mkDerivation {
        pname = "plivo";
        version = "0.2.0.0";
-       sha256 = "16q6jwnbzxhapmkzi2sn1k02z8gq11s9wp555fv7msv2if5axrp0";
+       sha256 = "e0e6ae8a8b62eb7ab62ba55c9e7408f8a12fc00c568bf867bd0af6bf2c97069b";
        revision = "1";
        editedCabalFile = "7ef78cd34067e8d72872b32bcad9d01537710c11efce159c990aeb4670e4efb3";
        libraryHaskellDepends = [
@@ -104579,7 +104913,7 @@ self: {
      mkDerivation {
        pname = "plot";
        version = "0.2.3.4";
-       sha256 = "1dclv0z94xpxmx80yzzppahq92cqjwaqr0g1ama0spywxhz6l7h3";
+       sha256 = "031e6a3eecdc5f0d5455e1818c1597988984a1baf77f0f50affd76923ed894b5";
        libraryHaskellDepends = [
          array base cairo colour hmatrix mtl pango transformers
        ];
@@ -104593,7 +104927,7 @@ self: {
      mkDerivation {
        pname = "plot-gtk";
        version = "0.2.0.2";
-       sha256 = "18p3jjrs1asd35q3fykfsrwx22d7rqczymbyxsaqwya5y0nv3ymn";
+       sha256 = "b6fab12df045798e95ee7e55ff19cea709d179d66e7a3770194daba0b394e3a2";
        libraryHaskellDepends = [ base glib gtk hmatrix mtl plot process ];
        homepage = "http://code.haskell.org/plot";
        description = "GTK plots and interaction with GHCi";
@@ -104607,7 +104941,7 @@ self: {
      mkDerivation {
        pname = "plot-gtk-ui";
        version = "0.1.0.0";
-       sha256 = "0q3f1rm1s22vrk19yzbflr1pwbl094lx5j8zbyhqqjvhpz491dx7";
+       sha256 = "a7b790c8bf704b8ca15f1fc9d22949802e7e43a66e7d9fc2cc5b081d6a0e6e60";
        libraryHaskellDepends = [
          base cairo colour fixed-vector gtk hmatrix plot text vector
        ];
@@ -104621,7 +104955,7 @@ self: {
      mkDerivation {
        pname = "plot-gtk3";
        version = "0.1.0.1";
-       sha256 = "0x7s9wb8r2sds25q9k6h8mvpfzgi90v497ccxskvb3qd0a1jv24f";
+       sha256 = "8e882d83020d8fb5a7ee8c9d443648f17d777745d0cc848bd04d8b8c164ffa74";
        libraryHaskellDepends = [
          base glib gtk3 hmatrix mtl plot process
        ];
@@ -104635,7 +104969,7 @@ self: {
      mkDerivation {
        pname = "plot-lab";
        version = "0.0.1.9";
-       sha256 = "1qa5mxq9j5m5zbvzsmrzg8jb9w9v8ik50c8w5ffddcrrqb9b8mcq";
+       sha256 = "9855b4d2c239b3d69c2b1c315066443bf1b4247a3f57fdf7faa5169970af45e1";
        isLibrary = false;
        isExecutable = true;
        executableHaskellDepends = [
@@ -104652,7 +104986,7 @@ self: {
      mkDerivation {
        pname = "plotserver-api";
        version = "0.22";
-       sha256 = "17vr3c9dnd1jabx66qih7z19mk0irrxzab51gl5gifcgdxlf4s3x";
+       sha256 = "7d68e2686f8fb9f80a7da12cf57bce11cc9ac23f306263fa523234db121b799f";
        libraryHaskellDepends = [ base curl split ];
        description = "Plotserver API";
        license = stdenv.lib.licenses.mit;
@@ -104665,7 +104999,7 @@ self: {
      mkDerivation {
        pname = "plugins";
        version = "1.5.4.0";
-       sha256 = "126lp2bbz9aa3pfi5dmbbzgsancdj1m26k7man96avixb21mzbi8";
+       sha256 = "28ae5f83583d6e659255f54c236a908d59a5df5fabb612dd1d4aa5bf96b8d488";
        libraryHaskellDepends = [
          array base Cabal containers directory filepath ghc ghc-paths
          ghc-prim haskell-src process random
@@ -104683,7 +105017,7 @@ self: {
      mkDerivation {
        pname = "plugins-auto";
        version = "0.0.4";
-       sha256 = "1gia9d45d7rb658wm6ihkfz36l4ph7w0hr0vnfw42s035aj5shy4";
+       sha256 = "c4435da42a036841b8b31b6408f881975033be9b309aca51312b9f56484b2abe";
        libraryHaskellDepends = [
          base containers filepath hinotify mtl plugins template-haskell
        ];
@@ -104700,7 +105034,7 @@ self: {
      mkDerivation {
        pname = "plugins-multistage";
        version = "0.6.1";
-       sha256 = "0kwibjp9r9gwkmi8i79cc217jhnqljcgdkvpsk7hclmaa7ir3caq";
+       sha256 = "58b191e351aa5206cfd477cff698a4d8427982602c9d88629dfca59cae5c914f";
        libraryHaskellDepends = [
          base directory ghc process template-haskell th-desugar
        ];
@@ -104717,7 +105051,7 @@ self: {
      mkDerivation {
        pname = "plumbers";
        version = "0.0.3";
-       sha256 = "1grw827jhxwka1zl0n5ycgrpc4ljw8bxg3psms8lsxfiiz6mwmq9";
+       sha256 = "09575ecd8fd1754d91aefa8ed717e2921276f363be58407f509377288f403cbf";
        libraryHaskellDepends = [ base template-haskell ];
        description = "Pointless plumbing combinators";
        license = stdenv.lib.licenses.bsd3;
@@ -104731,7 +105065,7 @@ self: {
      mkDerivation {
        pname = "ply-loader";
        version = "0.4.1";
-       sha256 = "0hi32n4gjvydahlclzc47qsnwqhzxxa7irc4qv6qbgpra4j6zqg1";
+       sha256 = "e1e16f2451f9be85cdc684e57854ef1f626e353e847dca2854cd6ff988152342";
        isLibrary = true;
        isExecutable = true;
        libraryHaskellDepends = [
@@ -104750,7 +105084,7 @@ self: {
      mkDerivation {
        pname = "png-file";
        version = "0.0.1.1";
-       sha256 = "18m5pqf2dx26spwjav9b67plha9f3bgn4wl6g6pckl0mmym3zm10";
+       sha256 = "20d43faaaf15d0c9ae79867262df1a2e2948ef312b6d25f9d546f4261cbea5a2";
        libraryHaskellDepends = [
          array base binary-file bytestring monads-tf template-haskell zlib
        ];
@@ -104767,7 +105101,7 @@ self: {
      mkDerivation {
        pname = "pngload";
        version = "0.1";
-       sha256 = "1j8zagi5xcb4spvq1r0wcnn211y2pryzf0r8z7h70ypqak7sy6ps";
+       sha256 = "fa1aafcf54f87a70e0f92803f77dbec28720ac651ce480f7d564b15ee2531fc9";
        libraryHaskellDepends = [
          array base bytestring haskell98 mtl parsec zlib
        ];
@@ -104781,7 +105115,7 @@ self: {
      mkDerivation {
        pname = "pngload-fixed";
        version = "1.0";
-       sha256 = "02ikfn7kl8jx5iffa2pv0n1z1c75qcg9aq94nrccfdp532wxr7bx";
+       sha256 = "7d9ddcb918e536c758b62461951ec3e5b0f08305fb0ae55c2c5d223a8f75330a";
        libraryHaskellDepends = [ array base bytestring mtl parsec zlib ];
        description = "Pure Haskell loader for PNG images";
        license = stdenv.lib.licenses.bsd3;
@@ -104793,7 +105127,7 @@ self: {
      mkDerivation {
        pname = "pnm";
        version = "0.1.0.0";
-       sha256 = "0h6wsqv6c36cmk30gs3rjdjbxxq9zih49pmzhj2dh9nyxsqbj2yw";
+       sha256 = "dc0bb9b0eede26d88484bfde4460fc09f7be649379e807c6accc0c6636d6dc40";
        libraryHaskellDepends = [ base bytestring ];
        description = "PNM image format header parsing and pretty printing";
        license = stdenv.lib.licenses.bsd3;
@@ -104810,7 +105144,7 @@ self: {
      mkDerivation {
        pname = "pocket-dns";
        version = "0.1.1";
-       sha256 = "1736gj66ljgarmdxwzc9m5aa9inkmgzfmn9sjcqlcs0kpp5faqsh";
+       sha256 = "5063e5cabd13684631933ad9eafeabd3c6a454a9897dde5bcdea496a8c7c669c";
        isLibrary = true;
        isExecutable = true;
        libraryHaskellDepends = [
@@ -104842,7 +105176,7 @@ self: {
      mkDerivation {
        pname = "pointed";
        version = "4.2.0.2";
-       sha256 = "0ynswx6ybl7b6vbrm2bd2zj2sbvsclhdi440lpv1aix5smd8m2jb";
+       sha256 = "4b8a8a5ad5a54715f6a58090d820657a2f2de4176d899ad736ebd0e54de7da7a";
        libraryHaskellDepends = [
          base comonad containers data-default-class hashable kan-extensions
          semigroupoids semigroups stm tagged transformers
@@ -104858,7 +105192,7 @@ self: {
      mkDerivation {
        pname = "pointedlist";
        version = "0.6.1";
-       sha256 = "16xsrzqql7i4z6a3xy07sqnbyqdmcar1jiacla58y4mvkkwb0g3l";
+       sha256 = "743cb0f89cbb128f8aa24c4519b262b561bf2cd607f83e94f9241e8af1cfba9b";
        libraryHaskellDepends = [ base binary ];
        description = "A zipper-like comonad which works as a list, tracking a position";
        license = stdenv.lib.licenses.bsd3;
@@ -104871,7 +105205,7 @@ self: {
      mkDerivation {
        pname = "pointfree";
        version = "1.1";
-       sha256 = "0lkwan8vi86jl72wfpdi0saac6rbx8z270r2nf3vp0468dqk25cf";
+       sha256 = "8e153171438680bb87b32283233eea2b1ba69406b15dc7c5a1d2a0b891557c52";
        isLibrary = true;
        isExecutable = true;
        libraryHaskellDepends = [
@@ -104895,7 +105229,7 @@ self: {
      mkDerivation {
        pname = "pointful";
        version = "1.0.6";
-       sha256 = "151cyy324g6cl5bdwcpbvcvpavj3x2592jbic1jq5q3fgahf5wqk";
+       sha256 = "13f3e2a07a6ee08265607149918ae8436e7537dbeb32de56a1cc3c2286f72c94";
        isLibrary = true;
        isExecutable = true;
        libraryHaskellDepends = [
@@ -104914,7 +105248,7 @@ self: {
      mkDerivation {
        pname = "pointless-fun";
        version = "1.1.0.6";
-       sha256 = "0m5hwd0mr7bmb2sbs1qa7l65xrr5h2wjznknsrk1ga08qkd5jp6h";
+       sha256 = "d05c59dac408a81766d676da2fb98025e75e0c3d0a07bdb458759d5c41e3b054";
        libraryHaskellDepends = [ base ];
        homepage = "http://code.haskell.org/~wren/";
        description = "Some common point-free combinators";
@@ -104926,7 +105260,7 @@ self: {
      mkDerivation {
        pname = "pointless-haskell";
        version = "0.0.9";
-       sha256 = "0f0bnd6dyi1ancdxd2hkszshws9d8jz8iamz5pir0i4nsj69mqyx";
+       sha256 = "dde39a8cd4964490e32dbfaa88be442d690ef5d7138ad61bb32a44df4cb30b38";
        libraryHaskellDepends = [ base GHood process syb ];
        homepage = "http://haskell.di.uminho.pt/wiki/Pointless+Haskell";
        description = "Pointless Haskell library";
@@ -104941,7 +105275,7 @@ self: {
      mkDerivation {
        pname = "pointless-lenses";
        version = "0.0.9";
-       sha256 = "1z09wbx9nrlpg0msq69zyaypp28rfm653l22g7q5xcn0wn4hfs0b";
+       sha256 = "0b680789e5c0b25ef07942d0514c7519897bbdf23f19ac2b7897669bfae209fc";
        libraryHaskellDepends = [
          base containers derive pointless-haskell process QuickCheck
        ];
@@ -104958,7 +105292,7 @@ self: {
      mkDerivation {
        pname = "pointless-rewrite";
        version = "0.0.3";
-       sha256 = "0dc37gw8p5zyi23g94llbq7vb5n09rgznjf24nhg28jw2vmf3f0n";
+       sha256 = "16b8e1ea165c22f1a025c249fb5f4ec096b50f5e9492f48688fe978bf83b8335";
        libraryHaskellDepends = [
          base containers mtl pointless-haskell pointless-lenses process
        ];
@@ -104972,7 +105306,7 @@ self: {
      mkDerivation {
        pname = "poker-eval";
        version = "0.3.1";
-       sha256 = "0v1is9jnpw1ij3b7h9figkjqk58dzc44v6vpdmxfmb80w0myihrv";
+       sha256 = "3bc3e82be000adea7a6d779b4d08fb0d9589e57cd12578d69031f06b65d2316c";
        libraryHaskellDepends = [ array base mtl random vector ];
        librarySystemDepends = [ poker-eval ];
        description = "Binding to libpoker-eval";
@@ -104987,7 +105321,7 @@ self: {
      mkDerivation {
        pname = "pokitdok";
        version = "4.1.0.2";
-       sha256 = "08pknbn79hihkil1vcpr7a8ilah3i5b6lnlc41bmprycyqz5vj1w";
+       sha256 = "3cc85d3ef6cce75b57208c5a6a5689032a1a913af9b21d689c30c274ecb2f322";
        libraryHaskellDepends = [
          aeson base base64-string bytestring case-insensitive directory hex
          HTTP http-client http-conduit http-types strict text time
@@ -105003,7 +105337,7 @@ self: {
      mkDerivation {
        pname = "polar";
        version = "0.0.1";
-       sha256 = "1f0anpxc57vxa5z0x4wrfay0g1sw2qwnz5nkz74y9vmh8vd99kkh";
+       sha256 = "70ce94da46b0eee4c9f9d3966f39165c8707bc7299930e7e517d9fc2fab50ab8";
        libraryHaskellDepends = [ base ];
        homepage = "http://space.k-hornz.de/polar";
        description = "Complex numbers in polar form";
@@ -105017,7 +105351,7 @@ self: {
      mkDerivation {
        pname = "polh-lexicon";
        version = "0.2.2";
-       sha256 = "0mnccx3xj568s3q82achf1pj57zqdpj9iskgh62w39xbqm7spivl";
+       sha256 = "74c7ab4fc5aba7c185816fea98e46df89f226f70902981f0d0c814d94767cc56";
        isLibrary = true;
        isExecutable = true;
        libraryHaskellDepends = [
@@ -105036,7 +105370,7 @@ self: {
      mkDerivation {
        pname = "polimorf";
        version = "0.7.3";
-       sha256 = "0vv7j1l0wnjwpd3hpxswq0k33izl0ck2njspcga885bkrd45lzdr";
+       sha256 = "b97d5a48cb731584d463574b2b2603f4c73126c05cf70b47bb5c5a0e6890676f";
        libraryHaskellDepends = [
          base binary containers text text-binary
        ];
@@ -105051,7 +105385,7 @@ self: {
      mkDerivation {
        pname = "poll";
        version = "0.0";
-       sha256 = "0v4cyrr506zqvxqbxkncss2pl2j38skl02p1vj6cjxcvlzb2y43p";
+       sha256 = "77102fd6a79b75c98cdce10a40a746430a7a85d6cccebe70dff81b5072f68c6c";
        libraryHaskellDepends = [ base enumset utility-ht ];
        description = "Bindings to poll.h";
        license = stdenv.lib.licenses.bsd3;
@@ -105064,7 +105398,7 @@ self: {
      mkDerivation {
        pname = "poly-arity";
        version = "0.0.4.1";
-       sha256 = "15yl8mqwahbrwl0hmz6lb4k7i48qgnxhav7xalj4q541ghd7cnwp";
+       sha256 = "975b761a7c81144c2455fd6c05bb7d1891782659d4fc0a01e57941c57145d497";
        revision = "2";
        editedCabalFile = "0bce1ff7388433830c7824530bb9c4fe3f4545bad44683dec2a5780028d870af";
        libraryHaskellDepends = [ base constraints HList ];
@@ -105080,7 +105414,7 @@ self: {
      mkDerivation {
        pname = "polyToMonoid";
        version = "0.1";
-       sha256 = "068acarrpd66682yjscm6l5k9kj9p8zxbf3hi76kz7gvkhkbsjj8";
+       sha256 = "484abd269cfb9d3fcd8970b8d53fba49ce340b359569e90532c6b49bb3620a19";
        libraryHaskellDepends = [ base ];
        description = "Polyvariadic functions mapping to a given monoid";
        license = stdenv.lib.licenses.bsd3;
@@ -105093,7 +105427,7 @@ self: {
      mkDerivation {
        pname = "polynomial";
        version = "0.7.2";
-       sha256 = "1w1zpa2l7l7yzqdgr142mqhf73mq8kiz7h3ydpd84n4vawjzz7z1";
+       sha256 = "e19fff25579b5882da6d7ec0f3e344b88ee320ae8284fc1afefed04385ba3ff0";
        libraryHaskellDepends = [
          base deepseq pretty vector vector-space vector-th-unbox
        ];
@@ -105107,7 +105441,7 @@ self: {
      mkDerivation {
        pname = "polynomials-bernstein";
        version = "1.1.1";
-       sha256 = "0pjdwi84gz5j1rij4m89nyljjafzjnakmf4yd6vj4xz54nmmygg6";
+       sha256 = "e63d5fab25e57722b7699eb83a9595df2929a9b7095522630eb2fc4750e44d5e";
        libraryHaskellDepends = [ base vector ];
        description = "A solver for systems of polynomial equations in bernstein form";
        license = "GPL";
@@ -105118,7 +105452,7 @@ self: {
      mkDerivation {
        pname = "polyparse";
        version = "1.11";
-       sha256 = "1z417f80b0jm4dgv25fk408p3d9mmcd1dlbya3ry0zdx4md09vrh";
+       sha256 = "30ef045a25bd7de0f3507ed1161aab35b5711120d315b15f23558205903b81fc";
        libraryHaskellDepends = [ base bytestring text ];
        homepage = "http://code.haskell.org/~malcolm/polyparse/";
        description = "A variety of alternative parser combinator libraries";
@@ -105133,7 +105467,7 @@ self: {
      mkDerivation {
        pname = "polyseq";
        version = "0.1.2.1";
-       sha256 = "1l31ynlkjkk2zzpsv194gv3pbl55liizvq4x16m5z52vzgszb570";
+       sha256 = "e094f5f5fb5b945faa099de0fd63a4a5d075c77e2485adefff624e39a9f561d0";
        isLibrary = true;
        isExecutable = true;
        libraryHaskellDepends = [
@@ -105151,7 +105485,7 @@ self: {
      mkDerivation {
        pname = "polysoup";
        version = "0.6";
-       sha256 = "1c7lmx7waj2p9gn9k0hsvnmzrxf3ryz5q7zr4770g3nj8yvbpyp2";
+       sha256 = "e2fabbb647d28e07ce21f91f5cbecfc3f5fcabdd1a8299ec4b5748c54faff4b0";
        libraryHaskellDepends = [
          base containers deepseq polyparse tagsoup
        ];
@@ -105166,7 +105500,7 @@ self: {
      mkDerivation {
        pname = "polytypeable";
        version = "0.1.0.0";
-       sha256 = "0vb2adm97ypi553lsjz7333q3dg9fmi0incrxlikqixk0f3ajaq8";
+       sha256 = "082ba98603b3473c23ed99d9086275e9b581c718e74b4d4729f1fa936a53626d";
        libraryHaskellDepends = [ base ];
        description = "Typeable for polymorphic types";
        license = stdenv.lib.licenses.bsd3;
@@ -105178,7 +105512,7 @@ self: {
      mkDerivation {
        pname = "polytypeable-utils";
        version = "0.1.0.0";
-       sha256 = "1hbpamgqsmsjkzjjva15f566yra77hwasp88b6y68nx9qa36a821";
+       sha256 = "41206586c2a95b64bc59085dad383c47656f4c7125a82de59f52578d5f5577c1";
        libraryHaskellDepends = [ base haskell98 polytypeable ];
        description = "Utilities for polytypeable";
        license = stdenv.lib.licenses.bsd3;
@@ -105190,7 +105524,7 @@ self: {
      mkDerivation {
        pname = "ponder";
        version = "0.0.1";
-       sha256 = "1nq4z063g429hxwf4vbyyr2b2s7sn325m0h6ggf793inlj48ci0h";
+       sha256 = "10448688a4368e74dc7b06825ac4b0fa68b144f67e6de278874990370cf804db";
        libraryHaskellDepends = [ base mtl ];
        jailbreak = true;
        homepage = "https://gihub.com/matt76k/ponder";
@@ -105205,7 +105539,7 @@ self: {
      mkDerivation {
        pname = "pontarius-mediaserver";
        version = "0.0.2.0";
-       sha256 = "00qyrbibav26x5ycipnyypybgjms2kxn38s3iy9gqzv0kmgsdxna";
+       sha256 = "caf6a65f9d607ffc928f43a361fb14bacab7fcf5dedec87ce9466cb5e2ca1e03";
        isLibrary = false;
        isExecutable = true;
        executableHaskellDepends = [
@@ -105235,7 +105569,7 @@ self: {
      mkDerivation {
        pname = "pontarius-xmpp";
        version = "0.4.2.2";
-       sha256 = "1krbr0vdza3s6w4sa119x591i5ryq9bmqfnacy665xr5si4bkzcv";
+       sha256 = "9bfdb948d425f7628c67ca3a5c57c23e971852e92904a509377aa8df36c82bcf";
        libraryHaskellDepends = [
          attoparsec base base64-bytestring binary bytestring conduit
          containers crypto-api crypto-random cryptohash cryptohash-cryptoapi
@@ -105266,7 +105600,7 @@ self: {
      mkDerivation {
        pname = "pontarius-xpmn";
        version = "0.0.1.0";
-       sha256 = "1nd228fgsxlqxql38wkvhq8k5d04bgknpx7i83qxrzj8kb6890dy";
+       sha256 = "be8184cc9a48fedcf140f1f46be75b04b43211867b723428ee9876fd1c12a2d9";
        libraryHaskellDepends = [
          base containers pontarius-xmpp random text xml-types
        ];
@@ -105282,7 +105616,7 @@ self: {
      mkDerivation {
        pname = "pony";
        version = "1.0";
-       sha256 = "0a8bya0kwk9d965awpg881bgzy9z1szcwsqqr0lfkd6bw3cb9fyy";
+       sha256 = "debbb4d8e0cbb4e928c8186bcebe0e3ff9ff5640e85dae8a492d4d3e81f20b29";
        isLibrary = false;
        isExecutable = true;
        executableHaskellDepends = [ base ];
@@ -105296,7 +105630,7 @@ self: {
      mkDerivation {
        pname = "pool";
        version = "0.1.2.1";
-       sha256 = "1fwwnwxk3kprr2z9y7bwa1qwxfkzwcb2n5l6vkq1c5s8gjls581c";
+       sha256 = "2ca0a2a97c481716f0dc86162b16e37fbace71507c1d9fbec8f9ce313bb79cbb";
        revision = "1";
        editedCabalFile = "c79e139723764f4d4ba584c6cf6f73174700271910b15ed0f25a150a53a8c951";
        libraryHaskellDepends = [ base monad-control transformers ];
@@ -105314,7 +105648,7 @@ self: {
      mkDerivation {
        pname = "pool-conduit";
        version = "0.1.2.3";
-       sha256 = "1myjbmbh0jm89ycx9d961mpgw8hp7al8wgnsls4p19gvr73gcbfv";
+       sha256 = "db2df6c6c9fba57089a6da3e8ea83a1722fe6e0d26b5d4994fa84a00575dd2d7";
        revision = "1";
        editedCabalFile = "b894f71054b3824a0a05753e8273efbc7c1dc48efa9c6d56625ba4411a74afa5";
        libraryHaskellDepends = [
@@ -105334,7 +105668,7 @@ self: {
      mkDerivation {
        pname = "pooled-io";
        version = "0.0.2";
-       sha256 = "0v7l0jvk2acqslb1inw6lgwbjraj73s396r160hw56slqxh5sgxl";
+       sha256 = "b43f5d60c7549bc22130219b34f4385265b9f8a386db1816d5982931b704f46c";
        isLibrary = true;
        isExecutable = true;
        libraryHaskellDepends = [
@@ -105351,7 +105685,7 @@ self: {
      mkDerivation {
        pname = "pop3-client";
        version = "0.1.4";
-       sha256 = "0kfcfxfwg5rjm7qx9r0ssdvkrvca95hflahrip1hi5wbplf224xv";
+       sha256 = "bb13211cbd8b9708c38d192aea60498aed3c77d31ae4d4f1a93297c75d77cc4d";
        libraryHaskellDepends = [ base mtl network ];
        homepage = "https://github.com/tmrudick/haskell-pop3-client/";
        description = "POP3 Client Library";
@@ -105363,7 +105697,7 @@ self: {
      mkDerivation {
        pname = "popenhs";
        version = "1.0.0";
-       sha256 = "01pb8g5zl99zccnjnkwklfgaz1pqjp1xrgz5b3qy45nclyln0bm4";
+       sha256 = "a42e60a9a7cc16e2f158e5bfdcc395f886af9ea3934f2b2d633f25facb43eb06";
        libraryHaskellDepends = [ base directory haskell98 unix ];
        homepage = "http://www.haskell.org/~petersen/haskell/popenhs/";
        description = "popenhs is a popen-like library for Haskell";
@@ -105378,7 +105712,7 @@ self: {
      mkDerivation {
        pname = "poppler";
        version = "0.13";
-       sha256 = "1fv0h2ixanzv5vy4l2ln23f9n8ghmgdxzlyx54hh69bwhrcg049s";
+       sha256 = "3a11f058867c25032129ddd3dfdbabf0219bdc10960a4afc2efb5bd5a38060bb";
        libraryHaskellDepends = [
          array base bytestring cairo containers glib gtk mtl
        ];
@@ -105396,7 +105730,7 @@ self: {
      mkDerivation {
        pname = "populate-setup-exe-cache";
        version = "1.0";
-       sha256 = "06z723fgqwvcxgxy63pqwmjb6xkcl69xmdry117f0i5rhy0aix3y";
+       sha256 = "7ef4a88087b944e04e083eb7da93a16c76b364e5f80ee3fbeb6c73fcdc10e71b";
        libraryHaskellDepends = [ base ];
        homepage = "https://github.com/mietek/populate-setup-exe-cache/";
        description = "Empty Cabal package";
@@ -105408,7 +105742,7 @@ self: {
      mkDerivation {
        pname = "portable-lines";
        version = "0.1";
-       sha256 = "1l94p3s56a3kfqc8fzqc52z12rhg3c8xsmgcw1i20dnl8aygalsh";
+       sha256 = "5053f5bc42d4362062e0ec55dd111b0f6611be280c7f871876732853f4b824d1";
        libraryHaskellDepends = [ base bytestring ];
        description = "Alternative 'lines' implementation that understands CR-LF and CR";
        license = stdenv.lib.licenses.bsd3;
@@ -105419,7 +105753,7 @@ self: {
      mkDerivation {
        pname = "portaudio";
        version = "0.2.4";
-       sha256 = "0vxlfn2462fmknj94sd5ajbm3lydy3z8mrqb3vgh47wwn0sq8sk3";
+       sha256 = "636a8435b09c1f02df1e0be78afef0cdd3519754a56992a49dd509438475b46f";
        libraryHaskellDepends = [ base containers ];
        librarySystemDepends = [ portaudio ];
        homepage = "http://code.haskell.org/portaudio";
@@ -105434,7 +105768,7 @@ self: {
      mkDerivation {
        pname = "porte";
        version = "0.0.4";
-       sha256 = "1cc7kbbz0vqh60acaxyn8b8pdmwx2w022sgvk1mw7p60s8jhng2d";
+       sha256 = "4d3c0b25d2c0dcc36b98fb692100179dd776d142d677c51430106ff0d79a87b1";
        isLibrary = true;
        isExecutable = true;
        libraryHaskellDepends = [
@@ -105450,7 +105784,7 @@ self: {
      mkDerivation {
        pname = "porter";
        version = "0.1";
-       sha256 = "0aw1gq7z3h5ag5vzl6crw7vijg9w25s0jvxr4rkniv4jk0wlfmnk";
+       sha256 = "d35647399892ec686726b96f0974113c3d19f7e19919fa7779aac0f10f7e812b";
        libraryHaskellDepends = [ haskell2010 ];
        description = "Implementation of the Porter stemming algorithm";
        license = stdenv.lib.licenses.bsd3;
@@ -105462,7 +105796,7 @@ self: {
      mkDerivation {
        pname = "ports";
        version = "0.4.3.2";
-       sha256 = "1ixyrg4k1f91v2r485r2fs8bgq373bhvg02mza5jdcb1amyfi7rm";
+       sha256 = "359fe87c5561b1268bfa5580b7e11a67e0b79076221744b2d821b930c9cbbec7";
        libraryHaskellDepends = [ base haskell98 unix ];
        homepage = "http://www.cse.unsw.edu.au/~chak/haskell/ports/";
        description = "The Haskell Ports Library";
@@ -105475,7 +105809,7 @@ self: {
      mkDerivation {
        pname = "ports-tools";
        version = "0.0.1";
-       sha256 = "0bs7b88qiczf59dliqhbxbzciv4xi07b6djspgpydigyrf5maac6";
+       sha256 = "8629558bcbfec5e6efbb5a36b30e889decc8feea0be2485b2aeeb388115a472f";
        libraryHaskellDepends = [ base directory process ];
        homepage = "http://github.com/ppenzin/hs-ports-tools/";
        description = "Library to interact with port tools on FreeBSD";
@@ -105487,7 +105821,7 @@ self: {
      mkDerivation {
        pname = "positive";
        version = "0.4.1";
-       sha256 = "034vlx889sgwvn7g2s1vl3w0nf1vs0c2c1gc0vn77wd9l1vw0hfg";
+       sha256 = "cf41c077a0a9f173ec06ec052618d03b380bf8a03b68f18eddfce98450a79b0c";
        libraryHaskellDepends = [ base nats semigroups ];
        description = "Positive integers";
        license = stdenv.lib.licenses.bsd3;
@@ -105500,7 +105834,7 @@ self: {
      mkDerivation {
        pname = "posix-acl";
        version = "0.2.0.0";
-       sha256 = "1qiq5bqq6bwdxrxc3i27jiq1ic5pn0309453a0y6vjwamrc8h7rv";
+       sha256 = "3b1f8858ae8acb6d3c50a3900406b0b7b018709447c4c17aee8d2f83f12a38e2";
        libraryHaskellDepends = [
          base bytestring containers lifted-base monad-control transformers
          transformers-base unix
@@ -105518,7 +105852,7 @@ self: {
      mkDerivation {
        pname = "posix-escape";
        version = "0.1";
-       sha256 = "0yrx8cr6qximfy0vh7qqljlkj27q9gksrnqmqbnj2hk5bsa5l48w";
+       sha256 = "1c115a945e654221edc215dbace74bf80839a9a4181fb8817735766c32433d7b";
        libraryHaskellDepends = [ base ];
        description = "Quote arguments to be passed through the Unix shell";
        license = stdenv.lib.licenses.bsd3;
@@ -105529,7 +105863,7 @@ self: {
      mkDerivation {
        pname = "posix-filelock";
        version = "0.1";
-       sha256 = "106rrbw4d0f13wcj19m6h0vy3v53j11bawqd3q4r0pcsypk53qmk";
+       sha256 = "b3e251e6f59a5d90091e0d73b54290a3ece13780a6a620191fc18146f8cad980";
        libraryHaskellDepends = [ base transformers unix ];
        homepage = "https://github.com/singpolyma/posix-filelock-haskell";
        description = "Nice wrapper around POSIX fcntl advisory locks";
@@ -105542,7 +105876,7 @@ self: {
      mkDerivation {
        pname = "posix-paths";
        version = "0.2.1.0";
-       sha256 = "187sq0rcdg06h64kkjdgqg32s8s51hd4cgf6hvajj1pgd9pyd1i0";
+       sha256 = "2086e66f6aef0629d586c63d461a0c45232dc6c3afc939898106bcc632c0faa0";
        libraryHaskellDepends = [ base bytestring unix ];
        testHaskellDepends = [
          base bytestring doctest HUnit QuickCheck unix
@@ -105556,7 +105890,7 @@ self: {
      mkDerivation {
        pname = "posix-pty";
        version = "0.2.0.1";
-       sha256 = "1f0jyhfl41fvnjc290lm7x4dik2bhymcfxzf0il1iza5rpcjabxa";
+       sha256 = "aa2f25d9cd45fd186804ee77c7aa874bccd8483f95822498b4db05421df412b8";
        libraryHaskellDepends = [ base bytestring process unix ];
        librarySystemDepends = [ util ];
        homepage = "https://bitbucket.org/merijnv/posix-pty";
@@ -105569,7 +105903,7 @@ self: {
      mkDerivation {
        pname = "posix-realtime";
        version = "0.0.0.3";
-       sha256 = "0g7mflyvhrypr8a5795vnqb5qlkg3w4nd3j8pnqql9dbmcbqc2aq";
+       sha256 = "58098617abab258ab1bd488e66091f6f525c16b6bba45314cad767b83d75f53c";
        libraryHaskellDepends = [ base unix ];
        description = "POSIX Realtime functionality";
        license = stdenv.lib.licenses.bsd3;
@@ -105580,7 +105914,7 @@ self: {
      mkDerivation {
        pname = "posix-timer";
        version = "0.3";
-       sha256 = "0z4j98pb46gzhi5i5pvxxm7an7am5i757p43cp2jv8pirx33k8zd";
+       sha256 = "eda33946cff1a22dc56583dc534e2c551dab4eed7ddf124b84ff19b22e4a927c";
        libraryHaskellDepends = [ base transformers-base unix ];
        homepage = "https://github.com/mvv/posix-timer";
        description = "Bindings to POSIX clock and timer functions";
@@ -105592,7 +105926,7 @@ self: {
      mkDerivation {
        pname = "posix-waitpid";
        version = "0.1";
-       sha256 = "1v3y3pg3gv0s26hdqc5fsar2j3vk4kpldkr23zxm14ncpz2w2dhk";
+       sha256 = "1336c1c5bfcc9250fb1f22cf46ef24730f29b2d2ae30dca0111aec37de1d7eec";
        libraryHaskellDepends = [ base unix ];
        description = "Low-level wrapping of POSIX waitpid(2)";
        license = stdenv.lib.licenses.mit;
@@ -105604,7 +105938,7 @@ self: {
      mkDerivation {
        pname = "possible";
        version = "0.1.0.5";
-       sha256 = "1iiyz3yf5rwcdawrbawdrx3fwrhb1s62ram6yavfwkvc7j9rfvzx";
+       sha256 = "fd6f97933c6c4feeb6f2a6aa2c8c0e0b66ee46cf8dab95b96a8ce7e2fcf83ec6";
        libraryHaskellDepends = [ base ];
        homepage = "https://github.com/tolysz/possible";
        description = "Three valued Data.Maybe";
@@ -105616,7 +105950,7 @@ self: {
      mkDerivation {
        pname = "post-mess-age";
        version = "0.1.0.0";
-       sha256 = "1rl7i37szwnqs6slhha3wv45mw9w9x6yxcrkbdcfvdc63x8nh74w";
+       sha256 = "9c1c68511f86b5ed585b33b3ee4d4f3cf15ac8e6434148b5d1d8f2afcf8887e6";
        libraryHaskellDepends = [ base ];
        description = "Send messages to a Handle concurrently without getting them mixed";
        license = stdenv.lib.licenses.bsd3;
@@ -105627,7 +105961,7 @@ self: {
      mkDerivation {
        pname = "postcodes";
        version = "0.1.1";
-       sha256 = "1z0d5pl11jymd0jj1k50si35lq2af3y0apiyz6mbi25zl5x49bi8";
+       sha256 = "28ae447aa1bf88b8aaf93e5e05fc704a605a46d4a0cc202568d5cb10e82d0dfc";
        libraryHaskellDepends = [ aeson base bytestring HTTP ];
        homepage = "https://github.com/mattyhall/haskell-postcodes";
        description = "A library that gets postcode information from the uk-postcodes.com";
@@ -105642,7 +105976,7 @@ self: {
      mkDerivation {
        pname = "postgresql-binary";
        version = "0.5.2.1";
-       sha256 = "02dzsh9d62pgrqsvjmdxyffr4cryk3sd2dg12jmygg94q5dfkm0m";
+       sha256 = "15d4e95ac124bde7ab14e135d1f4983e33929df3bd55b935ceef0ad312d4bf09";
        libraryHaskellDepends = [
          attoparsec base-prelude bytestring loch-th placeholders scientific
          text time transformers uuid
@@ -105664,7 +105998,7 @@ self: {
      mkDerivation {
        pname = "postgresql-config";
        version = "0.1.0";
-       sha256 = "1p5kzj2wsd3kigi9qavsqkxv9kfk4qbl809wqbdk4pd7y34ajab4";
+       sha256 = "6429a9c8f0a75d32dbc23c01441726d3cdb4fbc47a2b9ce28b7334cd85fcb3dc";
        libraryHaskellDepends = [
          aeson base bytestring monad-control mtl postgresql-simple
          resource-pool time
@@ -105679,7 +106013,7 @@ self: {
      mkDerivation {
        pname = "postgresql-copy-escape";
        version = "0.1";
-       sha256 = "063phxj8r3vy25awwwn47k9ac0s8z59igpgqrhb9gbfdq4ldrlpm";
+       sha256 = "f5d2dc28c1cdad9716ccf8dd1753f94803a6d23cc472ce55117e8f8c64877718";
        libraryHaskellDepends = [ base bytestring ];
        homepage = "https://github.com/joeyadams/hs-postgresql-copy-escape";
        description = "Format data to feed to a PostgreSQL COPY FROM statement";
@@ -105691,7 +106025,7 @@ self: {
      mkDerivation {
        pname = "postgresql-cube";
        version = "0.1.0.0";
-       sha256 = "0jla8rxnrk995qxyp5dgwm2d6yrcafyz5mj7yqr6v5jyzh6b59c3";
+       sha256 = "83a5b20cfc5e966d32f647d6f2bd532c7bd344e5af95eb3b2e29cd6c7b468a4a";
        libraryHaskellDepends = [ base bytestring postgresql-simple ];
        description = "Cube support for postgresql-simple";
        license = stdenv.lib.licenses.mit;
@@ -105702,7 +106036,7 @@ self: {
      mkDerivation {
        pname = "postgresql-libpq";
        version = "0.9.1.1";
-       sha256 = "0waqg245ly017j1qml4sc24896ax645bv8a2fghwwa46zvbsx0z4";
+       sha256 = "e483aed7fe8628cee17342a1bd0a315d998488609ad08a833c01785a88785871";
        libraryHaskellDepends = [ base bytestring ];
        librarySystemDepends = [ postgresql ];
        homepage = "http://github.com/lpsmith/postgresql-libpq";
@@ -105718,7 +106052,7 @@ self: {
      mkDerivation {
        pname = "postgresql-orm";
        version = "0.3.2";
-       sha256 = "1a81wrqzhpgdhs7i0znamkrrra2bksfwsh22yxv94qg6r7c2qp2p";
+       sha256 = "575c2cd8c9e6619276f74240cd9d9e4ba89cf3acca7e108f86ed5df871e601a9";
        isLibrary = true;
        isExecutable = true;
        libraryHaskellDepends = [
@@ -105748,7 +106082,7 @@ self: {
      mkDerivation {
        pname = "postgresql-query";
        version = "1.4.0";
-       sha256 = "0ba5sslcjmfvjm1s3sf1ym7lgzgxx0p5gzdgby1r2y20i5cswfsr";
+       sha256 = "593bae5989407891835faffd572ee8fdfd474ff5c1e9a14395db55c9a8d6452d";
        libraryHaskellDepends = [
          aeson attoparsec base blaze-builder bytestring containers
          data-default either exceptions file-embed haskell-src-meta hreader
@@ -105773,7 +106107,7 @@ self: {
      mkDerivation {
        pname = "postgresql-schema";
        version = "0.1.3";
-       sha256 = "17i4xpal7cf7km3p59p7m1cbc39rgkjwg6dkmhswnr669v40r350";
+       sha256 = "a08c0cc84ec664cb35acb399c7e57c390db658a8e7a672479dc7b143d5ed249e";
        revision = "1";
        editedCabalFile = "48c36bad1c6796bd2c7211e0002d2aafc5bb0c8dedde4ec9f8ece597335096ce";
        isLibrary = true;
@@ -105801,7 +106135,7 @@ self: {
      mkDerivation {
        pname = "postgresql-simple";
        version = "0.4.10.0";
-       sha256 = "0ar8rjd3fsk56ykf7ys3f14ld3771dknhvkfk08fq7054rilrir0";
+       sha256 = "20c74c6326051cec10986e6e68670be78c46497043fbe3a637656a379acc282b";
        libraryHaskellDepends = [
          aeson attoparsec base blaze-builder blaze-textual bytestring
          case-insensitive containers hashable postgresql-libpq scientific
@@ -105822,7 +106156,7 @@ self: {
      mkDerivation {
        pname = "postgresql-simple-migration";
        version = "0.1.3.0";
-       sha256 = "0qz75dgp346q6sbxwlfrqd9hpkh14krij2r8440nhb9qs4ccl2jz";
+       sha256 = "5f0aca18d1382d680121280b19f32401ce0b53c3d951de9736d890715f2be763";
        isLibrary = true;
        isExecutable = true;
        libraryHaskellDepends = [
@@ -105845,7 +106179,7 @@ self: {
      mkDerivation {
        pname = "postgresql-simple-sop";
        version = "0.1.0.7";
-       sha256 = "1hbfh4rp40h1h4m8dzr70zrfb24fckqwp5s6a7kc2fa7a9lw9g8r";
+       sha256 = "19bdc469524739c1e6514697cbf1648e88e5f20727ff862a8101027233816ec1";
        libraryHaskellDepends = [ base generics-sop postgresql-simple ];
        homepage = "https://github.com/openbrainsrc/postgresql-simple-sop";
        description = "Generic functions for postgresql-simple";
@@ -105859,7 +106193,7 @@ self: {
      mkDerivation {
        pname = "postgresql-simple-typed";
        version = "0.1.0.1";
-       sha256 = "0rgy0sx4fwcsr8ln14vhrp23hc1b67c07gw0hj5csrsjn40s0c2c";
+       sha256 = "4c30a001b15267cd8a8480bf03d8312b3038c4cd70936029ca9a7147ba06fe65";
        libraryHaskellDepends = [
          base postgresql-libpq postgresql-simple template-haskell
          transformers typedquery utf8-string
@@ -105877,7 +106211,7 @@ self: {
      mkDerivation {
        pname = "postgresql-simple-url";
        version = "0.1.0.1";
-       sha256 = "1878zcfgis931nn5pnbixzfj2sbp790rxq294cwjy6g1ab35w5ng";
+       sha256 = "cf165ec652e1192f392349e09e413a776921ddef71d95bac0d23e9f81cfbe8a0";
        libraryHaskellDepends = [
          base network-uri postgresql-simple split
        ];
@@ -105898,7 +106232,7 @@ self: {
      mkDerivation {
        pname = "postgresql-typed";
        version = "0.4.0";
-       sha256 = "0w3fbxwiqsl32g4hmkdxyw821nd14dv3i2pwykpx68c9w6vvlmx9";
+       sha256 = "a957bab7e18921d3eff4fc8a387623a1d92010f7bdcd0ac913836a1c795f6e70";
        libraryHaskellDepends = [
          aeson array attoparsec base binary bytestring containers cryptohash
          haskell-src-meta network old-locale postgresql-binary scientific
@@ -105926,7 +106260,7 @@ self: {
      mkDerivation {
        pname = "postgrest";
        version = "0.2.10.0";
-       sha256 = "0s1nmdpdjylqb6lmb9ijh83pfjyf8j6dkagl3rzl4dxc97w6fbpy";
+       sha256 = "fe2e67f849ac37427f1ef4a9d98c44ce4b77078232a655a959987ad96eab3668";
        isLibrary = true;
        isExecutable = true;
        libraryHaskellDepends = [
@@ -105973,7 +106307,7 @@ self: {
      mkDerivation {
        pname = "postie";
        version = "0.5.0.0";
-       sha256 = "1iqg7wirdcysjq4i7ah3lkzc2rzlbgvc7asq953zdir21g9jpqwk";
+       sha256 = "93e32bd30b22c7f6474958abc3f65bf467c1fea403aa130996dab396233f0fc7";
        isLibrary = true;
        isExecutable = true;
        libraryHaskellDepends = [
@@ -105995,7 +106329,7 @@ self: {
      mkDerivation {
        pname = "postmark";
        version = "0.1.1";
-       sha256 = "1jh1byixnc8mh3g4xb1w0nx9ghh5dchhqf1nxji869kbim2lqgaw";
+       sha256 = "5c3d4c458d6b2683a2ec36380c216b05c297ba053cac4ede801531dba35f01ca";
        isLibrary = true;
        isExecutable = true;
        libraryHaskellDepends = [
@@ -106016,7 +106350,7 @@ self: {
      mkDerivation {
        pname = "postmaster";
        version = "0.3";
-       sha256 = "1yzhblrqnd94gvcl4dzxx6glx1qyyvjy7gqa6ymqahcy8kh1v7ki";
+       sha256 = "719e1de0449e4185ab370abfe3e5f61e874e9fe9fd3742d97e24358b335df0fb";
        isLibrary = false;
        isExecutable = true;
        executableHaskellDepends = [
@@ -106035,7 +106369,7 @@ self: {
      mkDerivation {
        pname = "potato-tool";
        version = "0.1.0.2";
-       sha256 = "1d95y8nchzzy3zaq1dsm94b7nhrlxhwpq7yn9dr1nisz43f4j7bx";
+       sha256 = "7d1d49dc205f471b724bd61f7c39ec34437b164955b780d51ffe7fc82cf225b5";
        isLibrary = false;
        isExecutable = true;
        executableHaskellDepends = [ base binary bytestring split ];
@@ -106051,7 +106385,7 @@ self: {
      mkDerivation {
        pname = "potrace";
        version = "0.1.0.0";
-       sha256 = "1frxf3jzjyyp3bfj6b2mi29fxwcml4bya6sn4c5aizg741dhphng";
+       sha256 = "cfc20b5b20e7fda80a23561be517a195f1ee9288552c23dd1ad77bf9e5703dbb";
        libraryHaskellDepends = [
          base bindings-potrace bytestring containers data-default
          JuicyPixels vector
@@ -106065,7 +106399,7 @@ self: {
      mkDerivation {
        pname = "potrace-diagrams";
        version = "0.1.0.0";
-       sha256 = "0ys70a5k384czz0c6bpyy0cqrk35wa1yg6ph19smhm3ag9d8161v";
+       sha256 = "3b98805a7a6a5458750af09ae783e265cc8c19f0fe2ec3c0ff8ca0318b02477b";
        libraryHaskellDepends = [ base diagrams-lib JuicyPixels potrace ];
        homepage = "http://projects.haskell.org/diagrams/";
        description = "Potrace bindings for the diagrams library";
@@ -106077,7 +106411,7 @@ self: {
      mkDerivation {
        pname = "powermate";
        version = "0.1";
-       sha256 = "19qsi4g4v2dwagps3gq9grbin44rzk9ydpkpbwysc4gbizh1lrs0";
+       sha256 = "40671ae08feb11a63d5f77dee6d3fc99101b577e09bfa1ef53bc894d1e891aa7";
        libraryHaskellDepends = [ base directory network unix ];
        homepage = "http://neugierig.org/software/darcs/powermate/";
        description = "PowerMate bindings";
@@ -106090,7 +106424,7 @@ self: {
      mkDerivation {
        pname = "powerpc";
        version = "0.0.1";
-       sha256 = "0z3nqv8l9h0kwdaqb2vnk7vx5d0hmx02giv2k01llk7vznlkqqny";
+       sha256 = "de623ca9fdfb4c4a039862c72740af10b4d2f799768b8555e313c044d1c6767c";
        libraryHaskellDepends = [ base ];
        homepage = "http://tomahawkins.org";
        description = "Tools for PowerPC programs";
@@ -106103,7 +106437,7 @@ self: {
      mkDerivation {
        pname = "ppm";
        version = "2009.5.13";
-       sha256 = "0nzvxi1ybfxb1zqkbfqfic8j3mf3r6i2zdyjf7x41rz6m6lhqfcy";
+       sha256 = "9e390ca9a9e6e740fa71d2b72fa2c9c3d521118b0ebb35f10fabbbe543ecfb5b";
        libraryHaskellDepends = [ base mtl ];
        homepage = "http://github.com/nfjinjing/ppm/tree/master";
        description = "a tiny PPM image generator";
@@ -106115,7 +106449,7 @@ self: {
      mkDerivation {
        pname = "pqc";
        version = "0.8";
-       sha256 = "1n71qhlxn9js5cizyqdq9f7m08m5j0354871r8b47bnzdi2kqkc4";
+       sha256 = "844d3c456cdfae4316cae120520690a522508f4bb861ff232b5a26db29c4e1d8";
        libraryHaskellDepends = [ base QuickCheck random stm ];
        testHaskellDepends = [ base ChasingBottoms ];
        homepage = "http://hub.darcs.net/shelarcy/pqc";
@@ -106129,7 +106463,7 @@ self: {
      mkDerivation {
        pname = "pqueue";
        version = "1.3.0";
-       sha256 = "0nandznr9dmyvxxb4pfrcc21zyhbkn2q6ny0m60943kdmisf4401";
+       sha256 = "0110e274ac6d0e9280a9c05b83859d0bfa1f0463d95db27adfbeb694ed6f5659";
        libraryHaskellDepends = [ base deepseq ];
        description = "Reliable, persistent, fast priority queues";
        license = stdenv.lib.licenses.bsd3;
@@ -106142,7 +106476,7 @@ self: {
      mkDerivation {
        pname = "pqueue-mtl";
        version = "1.0.7";
-       sha256 = "0ikg11klbq25fjcbpyb7i7z9wyx9mf4hv262m14j741x4dk9ib6g";
+       sha256 = "cfac9866233d902349a8c2880d89aba97b9efe8967f9bb987445e04567086f46";
        libraryHaskellDepends = [
          base containers ghc-prim MaybeT mtl stateful-mtl uvector
        ];
@@ -106159,7 +106493,7 @@ self: {
      mkDerivation {
        pname = "practice-room";
        version = "0.0.2";
-       sha256 = "071arrk0wir2lwziw6p3cbq6ybjdf3gfc4d25sh21gpnk10ighp2";
+       sha256 = "e2c2174198f6be20a02ea211e6de704d2e6ff062e31a1e3fa722470e66ce2a1c";
        isLibrary = false;
        isExecutable = true;
        executableHaskellDepends = [
@@ -106178,7 +106512,7 @@ self: {
      mkDerivation {
        pname = "precis";
        version = "0.5.0";
-       sha256 = "0d0cl60p58i8w2ll8z826r94zx0svm7v578fy70r7i19pn64l6bd";
+       sha256 = "6d194a8cbd29c493c1f10e9db24fdd1af44f5236027d44a9e028a27281a10c34";
        isLibrary = true;
        isExecutable = true;
        libraryHaskellDepends = [
@@ -106199,7 +106533,7 @@ self: {
      mkDerivation {
        pname = "pred-trie";
        version = "0.2.0";
-       sha256 = "11d0673jhz8vb271wf0qsl8a480hzrghly07iqcmckybalr17ibs";
+       sha256 = "7ac5133255cb4f56198e07780a5ffe1020a210d518381e8e581b7d28c731a085";
        libraryHaskellDepends = [ base semigroups ];
        testHaskellDepends = [
          base hspec QuickCheck quickcheck-instances
@@ -106213,7 +106547,7 @@ self: {
      mkDerivation {
        pname = "predicates";
        version = "0.1";
-       sha256 = "0ly64xml5gbazyq07s409swgysvlwjc19w4x46yp1684ifv0gghf";
+       sha256 = "0ebe07b68b049970bd219df01498e4746bffb84e80e803b0ff6abd426b27c653";
        libraryHaskellDepends = [ base ];
        description = "A couple of convenience functions for forming predicates";
        license = stdenv.lib.licenses.bsd3;
@@ -106227,7 +106561,7 @@ self: {
      mkDerivation {
        pname = "prednote";
        version = "0.36.0.2";
-       sha256 = "1nm6r448vzl1gkkasjihaf31i57lx7pi627dxwf73slwxfz4j0wb";
+       sha256 = "8b0349beeb9cea711cefed0813efe9f494188653304aade67c81fe8d08c9a6da";
        libraryHaskellDepends = [
          base bytestring containers contravariant rainbow split text
          transformers
@@ -106248,7 +106582,7 @@ self: {
      mkDerivation {
        pname = "prednote-test";
        version = "0.26.0.4";
-       sha256 = "0amx13lnbx6x37adpjrxjac23qbx1xvsk82pn572kyp7pshn7ijj";
+       sha256 = "52c663a1bee7fa294eb157a0a9770f7de12198923dcbdbd419ddf465e908bd2a";
        isLibrary = true;
        isExecutable = true;
        libraryHaskellDepends = [
@@ -106272,7 +106606,7 @@ self: {
      mkDerivation {
        pname = "prefix-units";
        version = "0.1.0.2";
-       sha256 = "07b5s2bsqlaad06dgr5psidfgi1nmgc5c16j6kzayw9f4najjrav";
+       sha256 = "5b652995252e71affe34d20456d8ab36c4e75ad4b7e4d70c684a51ac97d0651d";
        revision = "1";
        editedCabalFile = "492d6b953a52678e44a880c5272c30175eed27c3f2bd4de82fc29eee4b4db00a";
        libraryHaskellDepends = [ base ];
@@ -106294,7 +106628,7 @@ self: {
      mkDerivation {
        pname = "prefork";
        version = "0.0.9";
-       sha256 = "0zraxygc8ybf93sw7lq60nynd5k1q65dns5kl4mdyflv3in8cfw8";
+       sha256 = "883b866c1c9b3adf2aa1b368db8ac1619666bd0506d3c3f5486e79c49eef2a7f";
        isLibrary = true;
        isExecutable = true;
        libraryHaskellDepends = [
@@ -106322,7 +106656,7 @@ self: {
      mkDerivation {
        pname = "pregame";
        version = "0.1.4.3";
-       sha256 = "0ls2fmg1xm10njwzz7nifndggq4bpi7ylx3n9aah8bn1hqwf8sy4";
+       sha256 = "c46be43886c12e04954a7674ea4fbc8be0f79a75d19effb9b420d41e5e754253";
        libraryHaskellDepends = [
          base bytestring cmdargs containers data-default lens mtl parallel
          safe stm text transformers tuple vector
@@ -106339,7 +106673,7 @@ self: {
      mkDerivation {
        pname = "prelude-extras";
        version = "0.4";
-       sha256 = "0mzsc9pzcamaa7i3g9hkajy35sbpqdjrflv6r98r8hhlr0yrdjan";
+       sha256 = "56c9963dc814429451ca66539765c377e932bc5413a637e251aa2af66f62fa57";
        libraryHaskellDepends = [ base ];
        homepage = "http://github.com/ekmett/prelude-extras";
        description = "Haskell 98 - higher order versions of Prelude classes";
@@ -106351,7 +106685,7 @@ self: {
      mkDerivation {
        pname = "prelude-generalize";
        version = "0.4";
-       sha256 = "0h452pn7zs97z5gv2p3x9pg61phphwcw5y5g1w38k3gihdvym8jl";
+       sha256 = "54a2ea7783f18d89060faff8c2198717de60de4d7d5cb15ff927e97fec158540";
        libraryHaskellDepends = [ base comonad logict transformers ];
        jailbreak = true;
        description = "Another kind of alternate Prelude file";
@@ -106364,7 +106698,7 @@ self: {
      mkDerivation {
        pname = "prelude-plus";
        version = "0.0.0.6";
-       sha256 = "139b0580f1gx4hj211c7lwcq5y6a0qpdzsaidvqbfq36h04w8kjv";
+       sha256 = "5b4ec409806660b7f06e51e9df2e06caf88219a78785202424fd050750012b8d";
        isLibrary = true;
        isExecutable = true;
        libraryHaskellDepends = [ base utf8-string ];
@@ -106378,7 +106712,7 @@ self: {
      mkDerivation {
        pname = "prelude-prime";
        version = "0.1";
-       sha256 = "1avj11a5bqn8sxizzh1fxhw3dvd55xsimbbhdwymxfn45vvfswr7";
+       sha256 = "2773edf62ec4ba5e3d6f70ad1a752fa5ed3638ec2ec0ff63d7c8e255540872ab";
        libraryHaskellDepends = [ base ];
        description = "A slightly better (but conservative) Prelude";
        license = stdenv.lib.licenses.mit;
@@ -106389,7 +106723,7 @@ self: {
      mkDerivation {
        pname = "prelude-safeenum";
        version = "0.1.1.2";
-       sha256 = "09wp6b7bvnp2wz0kigwm4vfca74phh3bbpqybqdgm60isfaz3yfl";
+       sha256 = "d4f9f195d31198fa1a5e1edfb50684971cc5dc2695bf38c1e7e2dabdce329727";
        libraryHaskellDepends = [ base ];
        homepage = "http://code.haskell.org/~wren/";
        description = "A redefinition of the Prelude's Enum class in order to render it safe";
@@ -106405,7 +106739,7 @@ self: {
      mkDerivation {
        pname = "preprocess-haskell";
        version = "0.0.1.1";
-       sha256 = "1jglriabjw44f9phx7ah87wwmri64a61v236dzs58snagzdiq84r";
+       sha256 = "99201cdb7fca6a54f46f66881d8c2226e6caf941509d0e6f728470b954ccf4c9";
        libraryHaskellDepends = [
          base base-unicode-symbols basic-prelude bytestring Cabal containers
          cpphs deepseq directory file-embed foldl haskell-src-exts here
@@ -106422,7 +106756,7 @@ self: {
      mkDerivation {
        pname = "preprocessor-tools";
        version = "1.0.1";
-       sha256 = "0ngfmvw6hvbr52i01n180ls4c8rx2wk2rka6g6igpvy9x2gwjin9";
+       sha256 = "c946c99fe8c9effba27946cd2c26173d2346340528d800a228796d68f8aeee59";
        libraryHaskellDepends = [ base mtl parsec syb ];
        homepage = "http://www.eecs.harvard.edu/~tov/pubs/haskell-session-types/";
        description = "A framework for extending Haskell's syntax via quick-and-dirty preprocessors";
@@ -106434,7 +106768,7 @@ self: {
      mkDerivation {
        pname = "presburger";
        version = "1.3.1";
-       sha256 = "15yhqc6gk14dsqr4b0x87i1xw0sc3iscw28grg4vmcspsjxil0l6";
+       sha256 = "86021abbd457b3bac9cb0f09ce741c4c03de433ca8834532d68d84f90cc3d097";
        revision = "1";
        editedCabalFile = "7c88061e13bab0e63240c05dad36b9518ad50d7ad4ade0f8911efa7826eb4b5d";
        libraryHaskellDepends = [ base containers pretty ];
@@ -106451,7 +106785,7 @@ self: {
      mkDerivation {
        pname = "present";
        version = "2.2";
-       sha256 = "1z9zvmszda7h1h4inq4b6ig9bd205mskqq85ns3rzsffxaj471p4";
+       sha256 = "e48643a4eacee99f87b605613c752d40b4955e348b601b090cf0a8f675dd3ffd";
        libraryHaskellDepends = [
          aeson atto-lisp base bytestring data-default mtl semigroups text
        ];
@@ -106464,7 +106798,7 @@ self: {
      mkDerivation {
        pname = "press";
        version = "0.1.2";
-       sha256 = "0aa3079az8bazyzqxxhx575vxr4a0p3wvlgh765w3k01vh6dkzgf";
+       sha256 = "eefdd90cdc01ccc18b39f0d1cdc7058ae4becb291df68ebfff6aa1afd2014329";
        libraryHaskellDepends = [ base containers json mtl parsec ];
        homepage = "http://github.com/bickfordb/text-press";
        description = "Text template library targeted at the web / HTML generation";
@@ -106481,7 +106815,7 @@ self: {
      mkDerivation {
        pname = "presto-hdbc";
        version = "0.1.0.3";
-       sha256 = "1353nh8pq3ja4pw1fps0a46rfizph47l7k5gqlnkbz8w8b41miap";
+       sha256 = "57c51ac8421cfd352dc5afcc430f81f747970d51405f17f8254a0e7c11b4a38c";
        libraryHaskellDepends = [
          aeson aeson-pretty base bytestring convertible either either-unwrap
          errors HDBC HTTP http-streams io-streams lens mtl network-uri safe
@@ -106497,7 +106831,7 @@ self: {
      mkDerivation {
        pname = "prettify";
        version = "1.0";
-       sha256 = "18bwgz2cgkd6n9gwpwipv2bc6d5501mflmr0r2akwy98q2gb9qg8";
+       sha256 = "e8e1b49ec028793e95c82057ea6a00a534c396d837f2cb5fb2a6cdc7c47f7ca1";
        libraryHaskellDepends = [ base containers semigroups ];
        description = "Haskell2010 structured text formatting";
        license = stdenv.lib.licenses.bsd3;
@@ -106508,7 +106842,7 @@ self: {
      mkDerivation {
        pname = "pretty";
        version = "1.1.3.2";
-       sha256 = "0k61v71c40dy4whvy1q1n3hs0xnhscg4svp0prcihn7s57j2spvi";
+       sha256 = "715f2de429fa581859bee06e4d1ed3d076a0e1b00107bf2127be01c2c2d9c14c";
        libraryHaskellDepends = [ base deepseq ghc-prim ];
        testHaskellDepends = [ base deepseq ghc-prim QuickCheck ];
        homepage = "http://github.com/haskell/pretty";
@@ -106521,7 +106855,7 @@ self: {
      mkDerivation {
        pname = "pretty-class";
        version = "1.0.1.1";
-       sha256 = "1qdfp2kpahzflq9a3idwmb0pqs4l7almxn5rbw5gp2pmdx81p3am";
+       sha256 = "558d1b506ff58afb0a5fb9d85ea93a94687cc1aabcc5a112a6ee4375a7b8aee1";
        libraryHaskellDepends = [ base pretty ];
        homepage = "https://github.com/ddssff/pretty-class";
        description = "Pretty printing class similar to Show";
@@ -106533,7 +106867,7 @@ self: {
      mkDerivation {
        pname = "pretty-compact";
        version = "1.0";
-       sha256 = "0k6yvdwcfhjp0dbfmc55xfncfry7b69hrp5rsaqm2iia3ahx0nan";
+       sha256 = "5659d0a11a2a4651b1d2b9dc0c9359c767c7aceba5b0ea56035742c778dbde4c";
        libraryHaskellDepends = [ base ];
        description = "Pretty-printing library";
        license = "GPL";
@@ -106544,7 +106878,7 @@ self: {
      mkDerivation {
        pname = "pretty-hex";
        version = "1.0";
-       sha256 = "0ylwkvvjvmpprha9nx83xb8gkhyanhk5fffc0r7lb96n4ch5z6pz";
+       sha256 = "ff9a5f2023d6a4454f06cc395726b4cac3f9d0ea03759b14ccf7d62df79e9c7a";
        libraryHaskellDepends = [ base bytestring ];
        description = "A library for hex dumps of ByteStrings";
        license = stdenv.lib.licenses.bsd3;
@@ -106555,7 +106889,7 @@ self: {
      mkDerivation {
        pname = "pretty-ncols";
        version = "0.1";
-       sha256 = "0bvd8wgjrj9g86b1z8m9mjzswibrmhasgajnkgr2dlizl5lg7faq";
+       sha256 = "58b9f368a13fd226f29b56aaa715ac7945aebfaca9a21f96412fc92c1f476d2f";
        libraryHaskellDepends = [ base pretty ];
        description = "A implementation of multi-column layout w/ Text.PrettyPrint";
        license = stdenv.lib.licenses.bsd3;
@@ -106568,7 +106902,7 @@ self: {
      mkDerivation {
        pname = "pretty-show";
        version = "1.6.8.2";
-       sha256 = "1s95nzjkmqb747s50i68c9s8p91cxgydzqkd2l5yjzdaygrvrhqv";
+       sha256 = "1bc3bcf3f3aa7de90b156de2dffceb2ca48b7462c84450f42167e13ae5b725e9";
        revision = "1";
        editedCabalFile = "3454673131f18cc65fb3fbca43d5d010f6b228abc0b7e501e67ef90ffded4218";
        isLibrary = true;
@@ -106588,7 +106922,7 @@ self: {
      mkDerivation {
        pname = "pretty-sop";
        version = "0.1.0.1";
-       sha256 = "1sv6lwzgj9jv7lx3lb868md5w93p77mzspgxgqcss1kr9q5xyfvm";
+       sha256 = "753bdf0b4e7906ad197efd5dfdeb3977245e5a45062d3a3a3d5b26f93ea766eb";
        libraryHaskellDepends = [ base generics-sop pretty-show ];
        description = "A generic pretty-printer using generics-sop";
        license = stdenv.lib.licenses.bsd3;
@@ -106599,7 +106933,7 @@ self: {
      mkDerivation {
        pname = "pretty-tree";
        version = "0.1.0.0";
-       sha256 = "0cf856qjacc0lmiina44s00i17ga2qrfr7wdlxhwiqdmpsh5g3fw";
+       sha256 = "dc8d57a0beb5e1c861a78d9fec3216ea9d1001d084281b63a5803125b129c831";
        libraryHaskellDepends = [ base boxes containers ];
        description = "Pretty-print trees";
        license = stdenv.lib.licenses.bsd3;
@@ -106610,7 +106944,7 @@ self: {
      mkDerivation {
        pname = "prettyFunctionComposing";
        version = "1.0.1";
-       sha256 = "0c39dyjlcrah1aq2rkk7zqysmzxqym6chv8x9zmifclvn5a4j98b";
+       sha256 = "0b254954b19b3217eb4f1d6dc84cf5b8ffaa3dfe67ce2cb00a506546a56f6930";
        libraryHaskellDepends = [ base ];
        description = "prettier function composition by (°)";
        license = stdenv.lib.licenses.bsd3;
@@ -106621,7 +106955,7 @@ self: {
      mkDerivation {
        pname = "prettyclass";
        version = "1.0.0.0";
-       sha256 = "11l9ajci7nh1r547hx8hgxrhq8mh5gdq30pdf845wvilg9p48dz5";
+       sha256 = "e537446e7a346e5e0872ed8281db2bb0220c737f10757848c901da1399548986";
        libraryHaskellDepends = [ base pretty ];
        description = "Pretty printing class similar to Show";
        license = stdenv.lib.licenses.bsd3;
@@ -106632,7 +106966,7 @@ self: {
      mkDerivation {
        pname = "prim-uniq";
        version = "0.1.0.1";
-       sha256 = "1zssi4zaihjaf3an10ar39d4qb155wcl1j66aymfrr9z2f2rf1gv";
+       sha256 = "fb059785133fe5ecaa57c6c840192f252c4c5a1a598160d5704ac2a83e895aff";
        libraryHaskellDepends = [ base dependent-sum primitive ];
        homepage = "https://github.com/mokus0/prim-uniq";
        description = "Opaque unique identifiers in primitive state monads";
@@ -106644,7 +106978,7 @@ self: {
      mkDerivation {
        pname = "primes";
        version = "0.2.1.0";
-       sha256 = "0ny6fzr967d1fifk050k95j9snnbjjif2bxf3v9s93k3zdc6bmkl";
+       sha256 = "74d66558fb638ea4d31eae2fe1a294cb5a9d64491314305d74a11d93f277c65b";
        libraryHaskellDepends = [ base ];
        homepage = "http://github.com/sebfisch/primes";
        description = "Efficient, purely functional generation of prime numbers";
@@ -106656,7 +106990,7 @@ self: {
      mkDerivation {
        pname = "primitive";
        version = "0.5.1.0";
-       sha256 = "0a8mf8k62xga5r5dd0fna1swqbx2r94c0mvqnc4mfq640zrsa5w8";
+       sha256 = "8817a5f307c4605709b37857c048caa22fcc7550d681d64a2eea756126721529";
        revision = "1";
        editedCabalFile = "ee8bf53215343bfc18dc8d310fd0e03ad3eaab8b85afdbc97dea3b047e0d98ec";
        libraryHaskellDepends = [ base ghc-prim ];
@@ -106671,7 +107005,7 @@ self: {
      mkDerivation {
        pname = "primitive";
        version = "0.6";
-       sha256 = "08lpsvrgdvqh8xw7f1wzkvwdnkizblbym8y2xpknk0y62f9g799l";
+       sha256 = "34a5f39213c68369e7edc2a3ea175d3f4edbf89e9f0777784710eff6f2d69722";
        libraryHaskellDepends = [ base ghc-prim transformers ];
        testHaskellDepends = [ base ghc-prim ];
        homepage = "https://github.com/haskell/primitive";
@@ -106688,7 +107022,7 @@ self: {
      mkDerivation {
        pname = "primula-board";
        version = "0.0.1";
-       sha256 = "0hh13i0idpwv509zavg92wwvp3s20vc1ivz7vfwa4kxp0h21phs9";
+       sha256 = "49c31b0404b74fa2b8dbe7ef18d806428fbb3917e96df513289bdf16411c0142";
        isLibrary = false;
        isExecutable = true;
        executableHaskellDepends = [
@@ -106709,7 +107043,7 @@ self: {
      mkDerivation {
        pname = "primula-bot";
        version = "0.0.2";
-       sha256 = "0j3xjlwvix81zxd38540jwb3vp438d72gmfxdhbypyi5f1qgx01x";
+       sha256 = "3d80fe707025faeb176cddd5274e4383dc3d16978014345aff01f5b839957d48";
        isLibrary = false;
        isExecutable = true;
        executableHaskellDepends = [
@@ -106729,7 +107063,7 @@ self: {
      mkDerivation {
        pname = "printf-mauke";
        version = "0.6.0";
-       sha256 = "1fyxm4bdhv27g83q21d0j59p7da8kgi8sfnsp39xb8gl4k0gd80z";
+       sha256 = "1fa0f6c024f4a1d5d3b8da3a8de29b48b5735391a00581077a476cd816a9ddbb";
        libraryHaskellDepends = [
          base bytestring containers data-default template-haskell
          utf8-string
@@ -106744,7 +107078,7 @@ self: {
      mkDerivation {
        pname = "printxosd";
        version = "0.1";
-       sha256 = "1myn6bp28d8nf92v9xf3iw5jvzwmrxbzf8px254hmzv8zvd5ki1i";
+       sha256 = "31c459dafe68ff0a4911fd22f757cf95ff2d0b8fc3f5b44572163524ee32d6d7";
        isLibrary = false;
        isExecutable = true;
        executableHaskellDepends = [ base xosd ];
@@ -106758,7 +107092,7 @@ self: {
      mkDerivation {
        pname = "priority-queue";
        version = "0.2.2";
-       sha256 = "0nsiil0yl32m80a1kpg3z0wd5fxwkpz2lzf66pa06iy24q0rz5lf";
+       sha256 = "8e969f0126c24703d435c67d2afe9dbcbbd238f8e3dd191440550cea018d515b";
        libraryHaskellDepends = [ base containers queue reord stateref ];
        jailbreak = true;
        homepage = "http://code.haskell.org/~mokus/priority-queue";
@@ -106773,7 +107107,7 @@ self: {
      mkDerivation {
        pname = "priority-sync";
        version = "0.2.1.1";
-       sha256 = "1ffg3ba6wfd72r2d86hq28y83qx80pdza939knay9hsnyw84vd6g";
+       sha256 = "cfb44d10f756c3e4959d6924f5db05a8e3813c12181ad44416a7396ed41acfb9";
        isLibrary = true;
        isExecutable = true;
        libraryHaskellDepends = [
@@ -106789,7 +107123,7 @@ self: {
      mkDerivation {
        pname = "privileged-concurrency";
        version = "0.3";
-       sha256 = "0r345189lympvin6xw6r8s04dldj94kv2703ilcazm0a6mgf0q67";
+       sha256 = "c760e05e350ad4af188d031cb12749b2d1468046d9f06e6cdcb77a9a50286464";
        libraryHaskellDepends = [ base stm ];
        description = "Provides privilege separated versions of the concurrency primitives";
        license = stdenv.lib.licenses.bsd3;
@@ -106802,7 +107136,7 @@ self: {
      mkDerivation {
        pname = "prizm";
        version = "0.3.1.2";
-       sha256 = "0n0pihi8f8y349lmy6hcv2z728isvwjlcggv9pnhm8d0k97la2b9";
+       sha256 = "6909454f9aa0a10aed4dfb3d4625df3a2271bed80c1a5f6922c32387228c1758";
        libraryHaskellDepends = [ base text ];
        testHaskellDepends = [
          base QuickCheck test-framework test-framework-hunit
@@ -106819,7 +107153,7 @@ self: {
      mkDerivation {
        pname = "probability";
        version = "0.2.4.1";
-       sha256 = "0nh73l03d7niz3a3h2y4i80mlp64ilfkx7krn57skzfi8drwnjvc";
+       sha256 = "6c4bcb7343d1fda94fb1799e3e1d8dc45c5a018ac40b38d4f8d19e36001d075a";
        libraryHaskellDepends = [
          base containers random transformers utility-ht
        ];
@@ -106836,7 +107170,7 @@ self: {
      mkDerivation {
        pname = "probable";
        version = "0.1.1";
-       sha256 = "1n6p7pharcq2cmfabh2ngfsy9mfqqs6qh57m0kygq13lbzwyy8wr";
+       sha256 = "9923eff95f7404fcfc04f514888dc6d8d5e4b57b56c0a55c6502b3ace03dd7d8";
        libraryHaskellDepends = [
          base mtl mwc-random primitive statistics transformers vector
        ];
@@ -106852,7 +107186,7 @@ self: {
      mkDerivation {
        pname = "proc";
        version = "0.0.9";
-       sha256 = "0p3cr4q34h81g77psypja4m0mgs9mwl51mfb5kdxj5xrsf2nd3la";
+       sha256 = "8a8e6685d3b917d9db2ccbd55028af49bf0a2a51f27a7dcf7901413230c96c5c";
        libraryHaskellDepends = [
          base containers directory filepath process regex-tdfa split strict
          xformat
@@ -106867,7 +107201,7 @@ self: {
      mkDerivation {
        pname = "process";
        version = "1.2.3.0";
-       sha256 = "1ib01nkh513v5ab7wa255jqpsnqjsjdmh8d9dz8inqw3f4ah97k1";
+       sha256 = "619e04157183631bd16fa921589bd4125b7db12c45287e962a7b8402a70d60c5";
        libraryHaskellDepends = [ base deepseq directory filepath unix ];
        testHaskellDepends = [ base ];
        description = "Process libraries";
@@ -106882,7 +107216,7 @@ self: {
      mkDerivation {
        pname = "process-conduit";
        version = "1.2.0.1";
-       sha256 = "0hnbywmjvk3y26sc9a0jfqzm04pg08zd2bflld1mvni02s89lvc8";
+       sha256 = "886d9a901620da5d43a3d42dd13e02ef12503f7612a8c4b4117ecc2d2bf7cb42";
        libraryHaskellDepends = [
          base bytestring conduit control-monad-loop mtl process resourcet
          shakespeare shakespeare-text template-haskell text
@@ -106901,7 +107235,7 @@ self: {
      mkDerivation {
        pname = "process-extras";
        version = "0.3.3.5";
-       sha256 = "18fyv47xhvw5881is2hk9a1x35fr21jvw36irlc5cxc3vfmnym6s";
+       sha256 = "da546fabdb83755618cdd10cbe6510d995d1834a130a1d0342856fd80fd9dea1";
        libraryHaskellDepends = [
          base bytestring deepseq ListLike process text
        ];
@@ -106917,7 +107251,7 @@ self: {
      mkDerivation {
        pname = "process-iterio";
        version = "0.0.0";
-       sha256 = "18kdj70fv4y5fnw7d8pd0mbvlwca1pm1f88z4ibpji0n4dja332z";
+       sha256 = "5f8ca1642316447957241f2117ea0d8a71ba5705eda276b875c593edc0916da2";
        libraryHaskellDepends = [
          base bytestring cpphs iterIO process transformers
        ];
@@ -106935,7 +107269,7 @@ self: {
      mkDerivation {
        pname = "process-leksah";
        version = "1.0.1.4";
-       sha256 = "1899ybhnsj22sir2l933lhkk9fpcgjbb4qd6gscnby28qcs5bwbv";
+       sha256 = "7bf15534c348f865997ea661b2967cecba3427a463242a72d442486de1f229a1";
        libraryHaskellDepends = [ base directory filepath unix ];
        jailbreak = true;
        description = "Process libraries";
@@ -106949,7 +107283,7 @@ self: {
      mkDerivation {
        pname = "process-listlike";
        version = "1.0";
-       sha256 = "0yaz90pfpx9kahwbvbvl2ir62imxxsq7v72i67ac2zv3585c427r";
+       sha256 = "f908c20a2a637fc1d431519c7db0eebd4661721474afbd385433f5eb2e485f79";
        revision = "3";
        editedCabalFile = "75f8f07195965b0a2ca36725792b095896801d4e4133c7c67a72600bdbeb63b1";
        libraryHaskellDepends = [
@@ -106969,7 +107303,7 @@ self: {
      mkDerivation {
        pname = "process-progress";
        version = "0.14";
-       sha256 = "0kdzb8m6fx0ah9i15fpcz6phzqd88g4djf0a5h0vi4d4qkib6kin";
+       sha256 = "364eb3e2c4a491b8012c0a38d9c843a8e10faff9ecba1262820a74672a5abf4d";
        libraryHaskellDepends = [
          base bytestring deepseq HUnit ListLike mtl process process-listlike
          text time unix utf8-string
@@ -106987,7 +107321,7 @@ self: {
      mkDerivation {
        pname = "process-qq";
        version = "0.2.0";
-       sha256 = "1495dc39kjf9mjvn7ag8hb95bsmhb18sd0ykg4mz7rrl0q03ig2a";
+       sha256 = "4abc38000634e7f32b79d383a65158b0ea55d282e8a963b7acc9c999066b2591";
        libraryHaskellDepends = [
          base bytestring enumerator mtl process shakespeare-text
          template-haskell text
@@ -107010,7 +107344,7 @@ self: {
      mkDerivation {
        pname = "process-streaming";
        version = "0.7.2.2";
-       sha256 = "0jmhl7jdrznbf9w9cpwh98apghhcnb9vadj94sjxfh288k21ckb3";
+       sha256 = "634d16c4444840d7a5264936b5d3b20cc277154a905f967872cbfedce4a1b04a";
        libraryHaskellDepends = [
          base bifunctors bytestring conceit containers contravariant foldl
          free pipes pipes-bytestring pipes-concurrency pipes-parse
@@ -107036,7 +107370,7 @@ self: {
      mkDerivation {
        pname = "processing";
        version = "1.2.0.1";
-       sha256 = "1axryd8453b2l4hbhqy5vkj29hqppsvk1sqxbawdhk3d3hs705pa";
+       sha256 = "ea1670341c6d4cd8b85a1deb30b7be17c324e4dcc563b820a1628d4250f3b9ab";
        libraryHaskellDepends = [
          base blaze-html containers directory filepath mainland-pretty
          multiset QuickCheck quickcheck-instances template-haskell text
@@ -107055,7 +107389,7 @@ self: {
      mkDerivation {
        pname = "processor-creative-kit";
        version = "0.1.0.1";
-       sha256 = "1jshzych1vbb24bm219sdpxkb2amvv11fbhqwf7iy4l1prg248h7";
+       sha256 = "0722225ebe81121f8fe3182e17c2de558935fb6d3a055117116bed0099ff50cb";
        libraryHaskellDepends = [
          array attoparsec base bytestring containers deepseq mtl
        ];
@@ -107069,7 +107403,7 @@ self: {
      mkDerivation {
        pname = "procrastinating-structure";
        version = "1.0.1";
-       sha256 = "126mp2mfmy9xg1kichl19ga6j3w1s0qpk3hqh47x5x5120qh63l3";
+       sha256 = "830e033110a1f4d20f81188e7931d0810f69d44b81421667783df9eaaab8d588";
        libraryHaskellDepends = [ base procrastinating-variable ];
        description = "Pure structures that can be incrementally created in impure code";
        license = "unknown";
@@ -107081,7 +107415,7 @@ self: {
      mkDerivation {
        pname = "procrastinating-variable";
        version = "1.0.2";
-       sha256 = "12px0nk7j74hyfzcvxacd9020gk3cd3ijqb7fjmmg8y33354jkc4";
+       sha256 = "844d49ca18c3a357ab746761194763633e20406a4cf5cdbef3901c79a605fd8a";
        libraryHaskellDepends = [ base ];
        homepage = "http://github.com/gcross/procrastinating-variable";
        description = "Haskell values that cannot be evaluated immediately";
@@ -107094,7 +107428,7 @@ self: {
      mkDerivation {
        pname = "procstat";
        version = "0.1.0.1";
-       sha256 = "1md75jc32nfnvs7ygf1mna00gl0wmimp2lkdcs9r9v0iy4b1hr5m";
+       sha256 = "b5641816f111ec9493666d52716bac1cd00780b235b8e78fded65931982ca7d5";
        libraryHaskellDepends = [ attoparsec base bytestring ];
        jailbreak = true;
        homepage = "http://closure.ath.cx/procstat";
@@ -107110,7 +107444,7 @@ self: {
      mkDerivation {
        pname = "proctest";
        version = "0.1.3.0";
-       sha256 = "02iz323arx9zwclvspgaaqz81bp6jdnj89pjm08n2gamg39zsbdn";
+       sha256 = "b62dfdd378553d6111a8f226246d93e6ae803e56ea5dbd29e33ff5ac86183f0a";
        isLibrary = true;
        isExecutable = true;
        libraryHaskellDepends = [ base bytestring HUnit process text ];
@@ -107128,7 +107462,7 @@ self: {
      mkDerivation {
        pname = "product-profunctors";
        version = "0.6.3";
-       sha256 = "0mkir3anyccjzcqjybnmx4ijz2h0qnps48pc5giaszmfs9nv7p18";
+       sha256 = "28dcb36dd2ae7eade22bec22a2afc5008a2f23e9d52e2f31fb92316fd5c87156";
        libraryHaskellDepends = [
          base contravariant profunctors template-haskell
        ];
@@ -107143,7 +107477,7 @@ self: {
      mkDerivation {
        pname = "prof2dot";
        version = "0.4.1";
-       sha256 = "1cf1ysnfpng7ijgsbnly5878wg7cp907cqpvf4yq9sd6nym8hcng";
+       sha256 = "cf3288aab7a6e9843d71fb627640baec3c8e0e2a9edaa59f8ce7d9ebacf6c1b1";
        isLibrary = false;
        isExecutable = true;
        executableHaskellDepends = [
@@ -107162,7 +107496,7 @@ self: {
      mkDerivation {
        pname = "prof2pretty";
        version = "0.1.0.0";
-       sha256 = "104frg0czfk4rgjxyf0xz7100j3y9ndvf01jgv3yibaq98v2h64r";
+       sha256 = "991828364a58ade8c77e3200b79b4d7e4800c2f91d38dfe5cb64bacfc0cb8e80";
        isLibrary = false;
        isExecutable = true;
        executableHaskellDepends = [
@@ -107180,7 +107514,7 @@ self: {
      mkDerivation {
        pname = "profiteur";
        version = "0.2.0.1";
-       sha256 = "17h690m78xsvbcxms2yxq7g9d1w5dx31q1m3a2m3i4gfwby1ndnf";
+       sha256 = "ce361bfce2ee9138aa50a3061c466f858796dec1dd0b5d3b5b5b77742a48069e";
        isLibrary = false;
        isExecutable = true;
        executableHaskellDepends = [
@@ -107197,7 +107531,7 @@ self: {
      mkDerivation {
        pname = "profunctor-extras";
        version = "4.0";
-       sha256 = "10j458liqlyz5s9gkg95c6aq7ap5fa7d8pc7hygy71nn87pm2g4a";
+       sha256 = "8a3c51ef41d686e39f87875dd48e72e5aa83956125bdf9922edf531c292a4482";
        libraryHaskellDepends = [ base profunctors ];
        homepage = "http://github.com/ekmett/profunctor-extras/";
        description = "This package has been absorbed into profunctors 4.0";
@@ -107211,7 +107545,7 @@ self: {
      mkDerivation {
        pname = "profunctors";
        version = "5.1.1";
-       sha256 = "0lw2ipacpnp9yqmi8zsp01pzpn5hwj8af3y0f3079mddrmw48gw7";
+       sha256 = "873f4478cdadd574c070c00fa790e4b0d8fb6f00577f142bf6e9dacbd48d8253";
        libraryHaskellDepends = [
          base comonad distributive tagged transformers
        ];
@@ -107225,7 +107559,7 @@ self: {
      mkDerivation {
        pname = "progress";
        version = "1.0";
-       sha256 = "0cac4v6k2nrpglnf3680y334kw4k0s6xfm86wrfyszl5sq2a7w94";
+       sha256 = "24f1a304d6857eed5de60655d78d0693f049c6f00099e12c7d375b31cd264c31";
        libraryHaskellDepends = [ base time ];
        description = "Simple progress tracking & projection library";
        license = stdenv.lib.licenses.bsd3;
@@ -107237,7 +107571,7 @@ self: {
      mkDerivation {
        pname = "progressbar";
        version = "0.0.1";
-       sha256 = "09yfspxcdp4y5chim2qmylfmjp0kdg4qg2w54kg3hir8f7kih3ns";
+       sha256 = "da0e18e771284738de24858b87c96b135c591df5158b1a212b9edcc6fad5ce27";
        isLibrary = true;
        isExecutable = true;
        libraryHaskellDepends = [ base io-reactive ];
@@ -107254,7 +107588,7 @@ self: {
      mkDerivation {
        pname = "progression";
        version = "0.5.0.2";
-       sha256 = "01s01v59hjy5i8dd9a1gxjpyw2qq3r81np7acn94wjh64c8rrmpa";
+       sha256 = "ead69c1123064a4e9265ea5c1b501e180beeafec2fa8d41a8ac54b98ca0e4007";
        libraryHaskellDepends = [
          base containers criterion directory filepath haskeline process
          txt-sushi
@@ -107273,7 +107607,7 @@ self: {
      mkDerivation {
        pname = "progressive";
        version = "0.1.0.1";
-       sha256 = "1psbgl19x2wwh4rcd4nsayrc1bq2g27qywr1m9jgmshcz1cinpbh";
+       sha256 = "705d1b59f80ceafa64aa21738f8f7802afc0b257da92c632819c8b9e027d4bdf";
        isLibrary = false;
        isExecutable = true;
        executableHaskellDepends = [
@@ -107292,7 +107626,7 @@ self: {
      mkDerivation {
        pname = "proj4-hs-bindings";
        version = "0.1";
-       sha256 = "0cwkjg1bm1swl103nsziyc71yqgvdq82ywgi2jnn7cj9lk4ihrah";
+       sha256 = "506518c9a449b263ad14f1712f106efb611f0ef3f16b3b40a05c87bac2939333";
        libraryHaskellDepends = [ base ghc-prim ];
        librarySystemDepends = [ proj ];
        description = "Haskell bindings for the Proj4 C dynamic library";
@@ -107308,7 +107642,7 @@ self: {
      mkDerivation {
        pname = "project-template";
        version = "0.2.0";
-       sha256 = "0433a2cmximz2jbg0m97h80pvmb7vafjvw3qzjpsncavg38xgaxf";
+       sha256 = "aeabd7d1785b31abaffc78f02d9dda67d57d01822755f09614bfc65e99506310";
        libraryHaskellDepends = [
          base base64-bytestring bytestring conduit conduit-extra containers
          directory filepath mtl resourcet text transformers
@@ -107327,7 +107661,7 @@ self: {
      mkDerivation {
        pname = "projection";
        version = "0.1";
-       sha256 = "0g9zrdp92w8ygrsmbw4600xaf8d17sm4pq68qd6z7hnf8zps22c1";
+       sha256 = "8109a1ef47cec2f34dc3c8e04baa3ea121a73a0086f055757e1e71916ecb3f3d";
        revision = "1";
        editedCabalFile = "805db4a9404200c6d8c00b7e96f95c9c71e3595b6601f75efed7237ad5bed30b";
        libraryHaskellDepends = [ base ];
@@ -107342,7 +107676,7 @@ self: {
      mkDerivation {
        pname = "prolog";
        version = "0.2.0.1";
-       sha256 = "073sd3rhcfqw9csm0qsbc57ix57dv3k5yjr9hcc33b9zq5y10sp0";
+       sha256 = "e06a107cc13fad311883294b5fe6d8ed941e4f614b6350354b1c3b06f3687a1c";
        libraryHaskellDepends = [
          base containers mtl parsec syb template-haskell th-lift
          transformers
@@ -107361,7 +107695,7 @@ self: {
      mkDerivation {
        pname = "prolog-graph";
        version = "0.1.0.2";
-       sha256 = "1w3wz0sn1qhw286g3arin30jvlldadw976xr7hp0afdvqicl3892";
+       sha256 = "22a14159c4bb39052e3cb99b9378538dd22dc1b031abf10c121ce26035f87cf0";
        isLibrary = false;
        isExecutable = true;
        executableHaskellDepends = [
@@ -107379,7 +107713,7 @@ self: {
      mkDerivation {
        pname = "prolog-graph-lib";
        version = "0.2.0.1";
-       sha256 = "02xa4hqmhmsv7vkdy3m3dr1w3z88kc8ly0jjn7q6pba5yarci7nr";
+       sha256 = "d99ec8b2f245ad6bf0b152024f119b08fdc1436ea30edfe63e5b57583124aa0b";
        libraryHaskellDepends = [ base fgl graphviz mtl prolog text ];
        homepage = "https://github.com/Erdwolf/prolog";
        description = "Generating images of resolution trees for Prolog queries";
@@ -107395,7 +107729,7 @@ self: {
      mkDerivation {
        pname = "prometheus-client";
        version = "0.1.0.1";
-       sha256 = "0bvp40rdlq8f6rh5v75pgqnmiwz85j960sfi22y7s0r5vykbgh5x";
+       sha256 = "bdc0b7a6df25037dbc10d16960922ce8f3582d7eb79c5d60360e61da3220772f";
        libraryHaskellDepends = [
          atomic-primops base bytestring containers mtl stm time transformers
          utf8-string
@@ -107414,7 +107748,7 @@ self: {
      mkDerivation {
        pname = "prometheus-metrics-ghc";
        version = "0.1.0.1";
-       sha256 = "15a7hli2fsjmgjnvhdsv1572nqj3i214b0r9bygdang4cjrjv10p";
+       sha256 = "17842db364e459d59e5f298345828843622b4e095b37b8ad7c556a2722854795";
        libraryHaskellDepends = [ base prometheus-client utf8-string ];
        testHaskellDepends = [ base doctest prometheus-client ];
        homepage = "https://github.com/fimad/prometheus-haskell";
@@ -107427,7 +107761,7 @@ self: {
      mkDerivation {
        pname = "promise";
        version = "0.1.0.0";
-       sha256 = "1hzsprmw15apc654n77ima1pgs9nj6287d412jb5z37154bd0nfg";
+       sha256 = "cf59d01629e18c5f961481b483849136e97783aaf11c4b8a615795c06bbefac3";
        libraryHaskellDepends = [ async base ];
        jailbreak = true;
        homepage = "http://github.com/jfischoff/promise";
@@ -107440,7 +107774,7 @@ self: {
      mkDerivation {
        pname = "promises";
        version = "0.2";
-       sha256 = "0fgczzjf93fvrfh9sgy49072c6qw27626qwla0qwl0wvfhaal7ah";
+       sha256 = "501daa14749b03ca3150946323cc111c1b260e48c43f9da0cbdb8de4e4ffec39";
        libraryHaskellDepends = [ base primitive ];
        homepage = "http://github.com/ekmett/promises/";
        description = "Lazy demand-driven promises";
@@ -107452,7 +107786,7 @@ self: {
      mkDerivation {
        pname = "prompt";
        version = "0.1.1.0";
-       sha256 = "13ayvs1irsa1hqy6y6ca99dr20vwvy9g10zjrqshvj48i5ra2j4g";
+       sha256 = "8f48a1728988c80d35cef283f092df7c03915b4a8a196f3c8641e91c83de5e8d";
        libraryHaskellDepends = [
          base mtl transformers transformers-compat
        ];
@@ -107468,7 +107802,7 @@ self: {
      mkDerivation {
        pname = "propane";
        version = "0.1";
-       sha256 = "1kzlwsxka72h3a612xi2s741hdx88qsib07kcralv2k76krqxlj4";
+       sha256 = "44d28ef334678a4d5566f380153546a83718c8d12276118c1a501c35bbe6f4cf";
        libraryHaskellDepends = [
          base colour containers directory filepath repa repa-devil spawn
        ];
@@ -107486,7 +107820,7 @@ self: {
      mkDerivation {
        pname = "propellor";
        version = "2.7.0";
-       sha256 = "12pfrv6n61bsg4cyylfr0kw82x36mwvnyvzdkr2lrka79i5l9a5w";
+       sha256 = "bca8444b4c47cd4c459eed6f6f37af667481f804d951ef19797a0563cdceee8a";
        isLibrary = true;
        isExecutable = true;
        libraryHaskellDepends = [
@@ -107509,7 +107843,7 @@ self: {
      mkDerivation {
        pname = "properties";
        version = "0.0.2";
-       sha256 = "04a35zxgps9rn6y86x3jf6gma6kjl8izmnyl45hz64cl9yb5dwwi";
+       sha256 = "91f356964f9411f36121d4dbfa23a2721a559f71727483bcb139e9fbfa2f4311";
        libraryHaskellDepends = [ base ];
        jailbreak = true;
        description = "check quickCheck properties in real time";
@@ -107525,7 +107859,7 @@ self: {
      mkDerivation {
        pname = "property-list";
        version = "0.1.0.5";
-       sha256 = "0wv97v6b7yfkwaz6mpw3l12q34k620jb1clz0j9a1kvysm1r005k";
+       sha256 = "b3009043d57ecfa092049fb2b0241066928145a083df6abee2d3f9b3cc3e6973";
        libraryHaskellDepends = [
          base base64-bytestring bytestring cereal containers free oneOfN
          recursion-schemes syb template-haskell text time time-locale-compat
@@ -107541,7 +107875,7 @@ self: {
      mkDerivation {
        pname = "proplang";
        version = "0.1";
-       sha256 = "1vm01qvd0jgcdpqx3p2h6gafhxi5x7bs8r5a6xsk4zz6cc1cbw4m";
+       sha256 = "95f0c50263e67f327537aa64a4d7e92576e8d43350dcd1f16dec49d0360ea0ee";
        libraryHaskellDepends = [ base glade glib gtk ];
        homepage = "http://www-users.cs.york.ac.uk/~ndm/proplang/";
        description = "A library for functional GUI development";
@@ -107554,7 +107888,7 @@ self: {
      mkDerivation {
        pname = "props";
        version = "0.1.2";
-       sha256 = "10bkbqhl15xgc9iglx0f9h218a2hcfg0wali2c6a17wvlpfcwjbx";
+       sha256 = "7d49cedca59b9fa00c13912a0e9e63502814044c0e74fa6262af9740215e7381";
        libraryHaskellDepends = [ base ];
        testHaskellDepends = [ base doctest QuickCheck ];
        homepage = "http://github.com/deviant-logic/props";
@@ -107570,7 +107904,7 @@ self: {
      mkDerivation {
        pname = "prosper";
        version = "0.1.1";
-       sha256 = "006h3i316s85f3d6qmwm9kajbxil1xcnqp11jfvv5ypnx2gdyhgb";
+       sha256 = "eb41df9ee8f6fab2b793215c6c590f34f625d54c95576cda70056913461cd000";
        libraryHaskellDepends = [
          aeson base bytestring cereal containers HsOpenSSL http-streams
          io-streams mtl text transformers vector
@@ -107585,7 +107919,7 @@ self: {
      mkDerivation {
        pname = "proteaaudio";
        version = "0.6.2";
-       sha256 = "10ayg0pr7vjffk8l114gwf098kpmamirk6cknw1xhpnr7hwr1mln";
+       sha256 = "96d690393cd95ed803b79399996355f54e9480e38f8440d1744eee932f785e81";
        libraryHaskellDepends = [ base ];
        librarySystemDepends = [ alsaLib ];
        libraryToolDepends = [ c2hs ];
@@ -107601,7 +107935,7 @@ self: {
      mkDerivation {
        pname = "protobuf";
        version = "0.2.1.0";
-       sha256 = "0i8hjrj6jycqmq7i1wl0kr9s17g4qfyc0gfwcbhbv70yxwf499di";
+       sha256 = "b1a5441cef1e9cbde062dc3dc0bcc3e49da0539e80f2100fae98796964961045";
        libraryHaskellDepends = [
          base bytestring cereal data-binary-ieee754 deepseq mtl text
          unordered-containers
@@ -107623,7 +107957,7 @@ self: {
      mkDerivation {
        pname = "protobuf-native";
        version = "1.0.0.1";
-       sha256 = "0k3cljm4r3jxlklkmfhv0362hg8095f1cq73mgdqkbqa5gwrk86r";
+       sha256 = "d9a099f92b0aaf89dbabe360165c49003d28cc001bba3ae9a45d8e4caaa46c4c";
        isLibrary = true;
        isExecutable = true;
        libraryHaskellDepends = [
@@ -107649,7 +107983,7 @@ self: {
      mkDerivation {
        pname = "protocol-buffers";
        version = "2.1.4";
-       sha256 = "0sn92mf0dl7w6cg25rhm492sl58pssshjyipadis4w4ww0kyp4md";
+       sha256 = "ad92eb27e09c70a26353377a09b5d61715aa452215e6221e33fcd0065c15c96a";
        libraryHaskellDepends = [
          array base binary bytestring containers directory filepath mtl
          parsec syb utf8-string
@@ -107664,7 +107998,7 @@ self: {
      mkDerivation {
        pname = "protocol-buffers-descriptor";
        version = "2.1.4";
-       sha256 = "1m07l890465ks53acmk9g3fzbm2h5l2pdfhp16hcmvvzxlaz2zvy";
+       sha256 = "7e7ff115ed7fefcaa00917ba76052d50d4f5dd786956a646d1b3180212a207d4";
        libraryHaskellDepends = [
          base bytestring containers protocol-buffers
        ];
@@ -107680,7 +108014,7 @@ self: {
      mkDerivation {
        pname = "protocol-buffers-descriptor-fork";
        version = "2.0.16";
-       sha256 = "1wn6yqs70n26j6z44yfmz4j4rwj2h1zfpysn56wzaq7bwsdb0bqb";
+       sha256 = "0b2fb09ae6eb60f5b92956fbeb7e8042f24c24f9d57942be9146587034f6c6f2";
        libraryHaskellDepends = [
          base bytestring containers protocol-buffers-fork
        ];
@@ -107697,7 +108031,7 @@ self: {
      mkDerivation {
        pname = "protocol-buffers-fork";
        version = "2.0.16";
-       sha256 = "061kc43dg3xdv81wmj4yjm1s6amrd8ql59nj7vff4vdb87v9nriz";
+       sha256 = "3f669bf641ab6de2dc3ed2a642316ab92aa343959ec8ca03daad8fd706613318";
        libraryHaskellDepends = [
          array base binary bytestring containers directory filepath mtl syb
          utf8-string
@@ -107715,7 +108049,7 @@ self: {
      mkDerivation {
        pname = "proton-haskell";
        version = "0.7";
-       sha256 = "1gn4h8xprq8gkngccyqbbqn8nidwlczlwckxzjgnb190yy3kd7hi";
+       sha256 = "119e3687f72085659ffc7d324e3fa3bc458b2c5e0b7bc69e9d0fe17c3b82c4be";
        libraryHaskellDepends = [ base containers directory filepath ];
        testHaskellDepends = [
          base containers directory filepath HUnit test-framework
@@ -107731,7 +108065,7 @@ self: {
      mkDerivation {
        pname = "prototype";
        version = "0.5.3";
-       sha256 = "1kzinhdy622gzg3mzfln15vgi890i2l3lkrgrw0n0yb08r2n53i7";
+       sha256 = "278e62454660796001cf2f4f3aa88820a1f8760996ba5fc7fb4f08e31bb4f1cf";
        libraryHaskellDepends = [ base monads-tf ];
        description = "prototype-based programming on Haskell";
        license = stdenv.lib.licenses.bsd3;
@@ -107745,7 +108079,7 @@ self: {
      mkDerivation {
        pname = "prove-everywhere-server";
        version = "0.1.1";
-       sha256 = "127ky7rj9d2bqaddcg99azm18m65ksxr26amq0r5prhym8kmc3jx";
+       sha256 = "5d0e5627aa1ee65b32c0551991bb9ec55414ea57293dd69ac24bb424f3f1f388";
        isLibrary = false;
        isExecutable = true;
        executableHaskellDepends = [
@@ -107765,7 +108099,7 @@ self: {
      mkDerivation {
        pname = "proxy-kindness";
        version = "0.1";
-       sha256 = "0wpzj6hnlxvgd7lfd2921mrk97aw7ljf77jry3my97zdapkxz8i7";
+       sha256 = "27a2dfe755ed9fe4ebf0599ee3243d5c9d34730d2289e6e8696f776aa191ff72";
        libraryHaskellDepends = [ base tagged ];
        jailbreak = true;
        homepage = "https://github.com/jberryman/proxy-kindness";
@@ -107782,7 +108116,7 @@ self: {
      mkDerivation {
        pname = "pseudo-boolean";
        version = "0.1.2.0";
-       sha256 = "13bgv7kkglajrvng7vcy7qv9x8xlm0nrv8in8zh5w5m6xl7i5wkz";
+       sha256 = "7ff2120feda6165ee04736a29d2da8b4a39e363e9eedf3ecce52d137e7d96f8d";
        libraryHaskellDepends = [
          attoparsec base bytestring bytestring-builder containers deepseq
          dlist hashable parsec
@@ -107801,7 +108135,7 @@ self: {
      mkDerivation {
        pname = "pseudo-trie";
        version = "0.0.4.3";
-       sha256 = "020jkgr6h1f4z14xbrl6zsqjqflkps03lh5102742bfsd58d9hvb";
+       sha256 = "6bc3d45069da2d418e00a1403a80be933a2cb1fe86e6d549f8c40568f29b1208";
        libraryHaskellDepends = [ base semigroups ];
        description = "A tagged rose-tree with short circuited unique leaves";
        license = stdenv.lib.licenses.bsd3;
@@ -107812,7 +108146,7 @@ self: {
      mkDerivation {
        pname = "pseudomacros";
        version = "0.0.2";
-       sha256 = "112g7qxn7vl5702gzx2kdg55rvvp9g0gc50dvcwlrgvrsvsdy6c9";
+       sha256 = "8919dff4d679bf4c39db0d14f6c04b77ef5cca6b53f4ff043885ee633b3e4f84";
        libraryHaskellDepends = [ base template-haskell time ];
        description = "cpp-style built-in macros using Template Haskell";
        license = stdenv.lib.licenses.bsd3;
@@ -107826,7 +108160,7 @@ self: {
      mkDerivation {
        pname = "psqueues";
        version = "0.2.0.2";
-       sha256 = "1mv86li4acx7jchlbh1nfyqyy9wqf7nifzmlph06wd1kvcs0cj73";
+       sha256 = "e3480634db33346e00bcb47e17ed719827efb17736c0452193a73345223568d7";
        libraryHaskellDepends = [ base deepseq ghc-prim hashable ];
        testHaskellDepends = [
          array base deepseq ghc-prim hashable HUnit QuickCheck tagged
@@ -107844,7 +108178,7 @@ self: {
      mkDerivation {
        pname = "pub";
        version = "2.0.2";
-       sha256 = "0ps4i5q4kzkla6gzr8amf2bql2y5g0gb4dbjf9w0q58yzzvpp2c8";
+       sha256 = "88897bf7ff1e150c78727235b21e78c50b8a977055a1fc9f5174fe497089445f";
        isLibrary = false;
        isExecutable = true;
        executableHaskellDepends = [
@@ -107863,7 +108197,7 @@ self: {
      mkDerivation {
        pname = "publicsuffix";
        version = "0.20150808";
-       sha256 = "1dcmi45vz9m4asf7i8bw6qigdcd2f7f48dmm2bq4w4dsjrp247dk";
+       sha256 = "b31d226e96ba114ef012b53644dc71a2b1f622367ca1789c56a4a6bf0b8995b5";
        libraryHaskellDepends = [ base filepath template-haskell ];
        testHaskellDepends = [ base hspec ];
        homepage = "https://github.com/wereHamster/publicsuffix-haskell/";
@@ -107878,7 +108212,7 @@ self: {
      mkDerivation {
        pname = "publicsuffixlist";
        version = "0.1";
-       sha256 = "0mbrmhgyjp8jms3fd3nq4knc4j97sw8ijrmnlfjs7qj8jw4vwzxk";
+       sha256 = "b37fbe099748e2a3a5a3b6661911d72749c2ec24d88ee686ae125de91fac7955";
        libraryHaskellDepends = [
          base bytestring cereal containers data-default text utf8-string
        ];
@@ -107898,7 +108232,7 @@ self: {
      mkDerivation {
        pname = "publicsuffixlistcreate";
        version = "0.0.2";
-       sha256 = "0v4arfixnfzpsi3hvik2s2lqqp61324bd98wc8ympqxlmldpbri3";
+       sha256 = "23e6751badb4e35b3d621ca5b68818c15c8ca9d062c60d47d4f73bdba3cb8a6c";
        libraryHaskellDepends = [
          base bytestring conduit containers data-default idna
          publicsuffixlist text
@@ -107922,7 +108256,7 @@ self: {
      mkDerivation {
        pname = "pubnub";
        version = "1.1.1";
-       sha256 = "0clcf5gsw34gpqycw652wq8ndmlzz48mf2gla0g7j815j21hrhv8";
+       sha256 = "68c30c83902520791e50f4095711f99fd66611e6a218ce3cbe8f0cae5f718c32";
        isLibrary = true;
        isExecutable = true;
        libraryHaskellDepends = [
@@ -107953,7 +108287,7 @@ self: {
      mkDerivation {
        pname = "pubsub";
        version = "0.11";
-       sha256 = "09xaycbzq50q1299r4s84nb8wjhqalimvipv8z135fifvgdsjpm8";
+       sha256 = "a85ea9dbdb2eba32c247fbc65d2355184a8e962548939c92081814fc17f3aa27";
        isLibrary = true;
        isExecutable = true;
        libraryHaskellDepends = [
@@ -107976,7 +108310,7 @@ self: {
      mkDerivation {
        pname = "puffytools";
        version = "0.0.0.1";
-       sha256 = "0pqqcs3plrhq6474j29lnwvc6fhr1wskb0ph8x64gzv9ly52dc9i";
+       sha256 = "31b1268aa769ff474c47f08235350f193ac336b73409490e3118667a8766185f";
        isLibrary = true;
        isExecutable = true;
        libraryHaskellDepends = [
@@ -108005,7 +108339,7 @@ self: {
      mkDerivation {
        pname = "pugixml";
        version = "0.3.2";
-       sha256 = "0pvvx7cd16a7cjp991l487p0vgpkdyv7ic64brz92bkjxgrpw94i";
+       sha256 = "91247ef3eb722e917e5ec4b078b66ff3be0dee41848694ae644799d0d8e97b5f";
        libraryHaskellDepends = [
          base bytestring data-default-class template-haskell
        ];
@@ -108022,7 +108356,7 @@ self: {
      mkDerivation {
        pname = "pugs-DrIFT";
        version = "2.2.3.20130611";
-       sha256 = "0c5h829zh8clggf53byng4gh5g0zxk3763w1nk0ihf2laak238c6";
+       sha256 = "86a121a652543818c1b4810f73c6ec1fbc021f79d6af51dc7b9421f89340b030";
        isLibrary = true;
        isExecutable = true;
        libraryHaskellDepends = [
@@ -108044,7 +108378,7 @@ self: {
      mkDerivation {
        pname = "pugs-HsSyck";
        version = "0.41";
-       sha256 = "108dfhd83yzmlhbgff6j0a40r6vx9aq9dcdd8swk4yib9gbvsrp1";
+       sha256 = "e166bdd74b2b7a32b946adb196b04a7d9b0c8802d238f716a4f5fb811a740d81";
        libraryHaskellDepends = [ base bytestring ];
        description = "Fast, lightweight YAML loader and dumper";
        license = "unknown";
@@ -108059,7 +108393,7 @@ self: {
      mkDerivation {
        pname = "pugs-compat";
        version = "0.0.6.20130611.0";
-       sha256 = "15pgg4z6clqgazi70jac280ib0d4rhz1hdqbg5i4kffziv2q6jsm";
+       sha256 = "554b83c58edfb94962790b37183ecca4811501124c4970e2570f53663e79ef96";
        libraryHaskellDepends = [
          array base bytestring containers directory mtl network process
          random regex-base regex-pcre-builtin stm stringtable-atom syb time
@@ -108075,7 +108409,7 @@ self: {
      mkDerivation {
        pname = "pugs-hsregex";
        version = "1.0";
-       sha256 = "1px8qvz7afws2w8scplxs4zm628anvh5ssbf0ba9hajh686h133i";
+       sha256 = "718c000d32502a98d4026e695de0b60a09533fd19d5ea611179a3b75fec6a8df";
        libraryHaskellDepends = [ array base haskell98 ];
        homepage = "http://repetae.net/john/computer/haskell/hsregex/";
        description = "Haskell PCRE binding";
@@ -108088,7 +108422,7 @@ self: {
      mkDerivation {
        pname = "pulse-simple";
        version = "0.1.14";
-       sha256 = "1as1cnx50mqmib5llzy2w218rg7dxmhz6nfa9kryfjzk0n5rshl4";
+       sha256 = "84429d8b05f34be7f34cca59f361ededbc8c82e0c27f4acb8a155750ba6541ab";
        libraryHaskellDepends = [ base bytestring ];
        librarySystemDepends = [ libpulseaudio ];
        description = "binding to Simple API of pulseaudio";
@@ -108102,7 +108436,7 @@ self: {
      mkDerivation {
        pname = "punkt";
        version = "0.1.1";
-       sha256 = "0hhrpkbgm56zs1ynd0ba37fv1vg2bxr79kfb2myjfxsnc6gr4h9b";
+       sha256 = "2b41929f615677277d15cbcd74725fe2edb0dd196a81667dd0df94fad6bc1942";
        libraryHaskellDepends = [
          array base mtl regex-tdfa regex-tdfa-text text unordered-containers
        ];
@@ -108122,7 +108456,7 @@ self: {
      mkDerivation {
        pname = "punycode";
        version = "2.0";
-       sha256 = "192jgfixnpxdj6jiiz92kx5bi6ij3c389b76q9f4vyfmvcajj1sr";
+       sha256 = "59072915dbd5f94d5cc2e6ac84061b329ab84a9f22fd18a591ad5fdba37b52a4";
        libraryHaskellDepends = [ base bytestring cereal mtl text ];
        testHaskellDepends = [
          base bytestring cereal encoding HUnit mtl QuickCheck text
@@ -108139,7 +108473,7 @@ self: {
      mkDerivation {
        pname = "puppetresources";
        version = "0.4.2";
-       sha256 = "064swfpxk7jhb81bi0v9l0r1hn0z2cafnzx7ijdr33xhikyc92rb";
+       sha256 = "2b8bc4fc8cb08f919b8ca77feb14131f581832a06983b8025a509ed9afe39a18";
        isLibrary = false;
        isExecutable = true;
        executableHaskellDepends = [
@@ -108159,7 +108493,7 @@ self: {
      mkDerivation {
        pname = "pure-cdb";
        version = "0.1.1";
-       sha256 = "1yjh7h02hkhx2vgvn7qfmfd3bp12ibpkf4znybsd2bfh0i1pzn0n";
+       sha256 = "16d87f4304d02dd1f4f2f61337ef8a22dc359aab0e1fbbdf161d4e28003c50fa";
        libraryHaskellDepends = [
          base binary bytestring containers directory mtl vector
        ];
@@ -108176,7 +108510,7 @@ self: {
      mkDerivation {
        pname = "pure-fft";
        version = "0.2.0";
-       sha256 = "1zzravfgxbx07c38pf0p73a9nzjk2pbq3hzfw8v9zkqj95b3l94i";
+       sha256 = "91243a564912cf9f36e2eec381d715537e9bd43817b88b063ba0affedc56f9ff";
        libraryHaskellDepends = [ base ];
        description = "Fast Fourier Transform";
        license = stdenv.lib.licenses.bsd3;
@@ -108187,7 +108521,7 @@ self: {
      mkDerivation {
        pname = "pure-io";
        version = "0.2.1";
-       sha256 = "0pzvkd8jxw859s187n972yaq5wmwi00cxwhivgffr7z29hr0zvx9";
+       sha256 = "a9ef0f324ce29fecdcdb11f2ce0088bcf282951727d983824e05f12e519bfb5f";
        libraryHaskellDepends = [ base containers mtl safe ];
        description = "Pure IO monad";
        license = stdenv.lib.licenses.bsd3;
@@ -108198,7 +108532,7 @@ self: {
      mkDerivation {
        pname = "pure-priority-queue";
        version = "0.14";
-       sha256 = "125vnkjx6n7pgflk9iqg7b6daw55a1rdfi9pfgp39ikfcx9vhb3p";
+       sha256 = "772cb853676ec634ee733745d77250a570d5cc3a0fc734a97bf758d3e5b4bb88";
        libraryHaskellDepends = [ base containers ];
        jailbreak = true;
        description = "A pure priority queue";
@@ -108212,7 +108546,7 @@ self: {
      mkDerivation {
        pname = "pure-priority-queue-tests";
        version = "0.12";
-       sha256 = "17x2drpmdppzxp3nnxq0vajxrzdnhpapk9rz9qcqaxbg934c7h3d";
+       sha256 = "6dc0c3c8486f7585194e3fa779d585b6fddca5da00776bc7edffde566f6ea29f";
        isLibrary = false;
        isExecutable = true;
        executableHaskellDepends = [
@@ -108232,7 +108566,7 @@ self: {
      mkDerivation {
        pname = "pure-zlib";
        version = "0.3";
-       sha256 = "1in93rx2y3zaahzpblwybskjrbwc0zrzh792ibi64jxvkrxjkyxn";
+       sha256 = "b6fb297b9ebb4b62e28a221df8f3078caf2ca75e9ed3753f54ea0f2f7a1ec9c6";
        libraryHaskellDepends = [
          base bytestring containers fingertree monadLib
        ];
@@ -108252,7 +108586,7 @@ self: {
      mkDerivation {
        pname = "pureMD5";
        version = "2.1.2.1";
-       sha256 = "1zsn949qk95bwx1fbyv84q0lhb4k18bgixl7nivfzsnmhr31fs37";
+       sha256 = "6768174686d5eaef76b487f6f8160a932c48012668fbe542e7aba489134956ff";
        libraryHaskellDepends = [
          base binary bytestring cereal crypto-api tagged
        ];
@@ -108271,7 +108605,7 @@ self: {
      mkDerivation {
        pname = "purescript";
        version = "0.7.2.0";
-       sha256 = "0drx0n1ac0sjnma7c15hsld1n6rwwl7r8fzcdibk73k5pfyz9a6k";
+       sha256 = "d3a8f4bdbb658e33576cec3b940fe53c1b1b1ad5b0047654b55203a682053d37";
        isLibrary = true;
        isExecutable = true;
        libraryHaskellDepends = [
@@ -108305,7 +108639,7 @@ self: {
      mkDerivation {
        pname = "purescript-bundle-fast";
        version = "0.1.0.1";
-       sha256 = "0s9db4nb5ppr3yznay7jlgydq68hcdn525cwnxkj41h8fv9sflfw";
+       sha256 = "dc51a7d37608062267b79c15516c631019dcfca3f27865bf1ff9deb22c592d69";
        isLibrary = false;
        isExecutable = true;
        executableHaskellDepends = [
@@ -108327,7 +108661,7 @@ self: {
      mkDerivation {
        pname = "push-notify";
        version = "0.1.0.1";
-       sha256 = "1ca9cs55yj1960cx7vha2w33nvqj89rhkdji555aaac3z302jgjs";
+       sha256 = "5a3e29c0f88329a54a2951b6097342126f3b06170aeed3193029485f8a6649b1";
        libraryHaskellDepends = [
          aeson async attoparsec-conduit base base16-bytestring bytestring
          cereal certificate conduit connection containers convertible
@@ -108350,7 +108684,7 @@ self: {
      mkDerivation {
        pname = "push-notify-ccs";
        version = "0.1.0.1";
-       sha256 = "1fgpzcbkcsb03lysml28a8w3c9l3nx4mirrn287g7y1kb4kx3bw0";
+       sha256 = "80afd1275933f8f30e1236e75849b7832636385248d0aa3d1d60693617fbf7b9";
        libraryHaskellDepends = [
          aeson async attoparsec base bytestring cprng-aes crypto-random
          data-default hslogger mtl network pontarius-xmpp push-notify retry
@@ -108370,7 +108704,7 @@ self: {
      mkDerivation {
        pname = "push-notify-general";
        version = "0.1.0.1";
-       sha256 = "0vyw3733xm2s3nxybav8an68mlagk8v3bb43qlz71hkjgjddvpdh";
+       sha256 = "b0dddd9a7c72c2703ec583ac35369a4fd18a8c5568abe5bb1d5ad43ec619dc6f";
        libraryHaskellDepends = [
          aeson base bytestring containers data-default hashable http-client
          http-conduit http-types push-notify push-notify-ccs text
@@ -108389,7 +108723,7 @@ self: {
      mkDerivation {
        pname = "pusher-haskell";
        version = "0.1.0.0";
-       sha256 = "0ymj27a3kmaddydd5zshj108fmzhlxasn9i4igzjaj308f1ygki6";
+       sha256 = "26cee78343604825ff8b2426ab55a7f05787409050ffd29a6f4dd539d411b27a";
        libraryHaskellDepends = [
          aeson base bytestring HTTP MissingH mtl SHA time
        ];
@@ -108410,7 +108744,7 @@ self: {
      mkDerivation {
        pname = "pushme";
        version = "1.5.0";
-       sha256 = "0cn350p0v6wb6c1n589c2l460c8pac41c645fja5xqxyyiiyni4d";
+       sha256 = "8d44eb63f4bee35e9474851816085317316008152ca16203338b9b0d2e28c332";
        isLibrary = false;
        isExecutable = true;
        executableHaskellDepends = [
@@ -108432,7 +108766,7 @@ self: {
      mkDerivation {
        pname = "putlenses";
        version = "0.1.3";
-       sha256 = "153hxffd1rg3m73kss0j3s7102lj6p84c95gvzyl0gmjpljfxffp";
+       sha256 = "d7b9ee24bdb23e40fddfaf2446d035920a108e1e12683dc7a9e3e5d09ceb7094";
        libraryHaskellDepends = [
          base containers ghc-prim lens mtl QuickCheck random safe split
          template-haskell transformers
@@ -108452,7 +108786,7 @@ self: {
      mkDerivation {
        pname = "puzzle-draw";
        version = "0.1.0.4";
-       sha256 = "0jbc24a959klaf3niri5ilq0jdqpxdg4fg79bjfdpg51na4xr3hi";
+       sha256 = "118edc89b2a1bcdb9c5ce93c475eeb173709308d25e668875374a69214116c49";
        isLibrary = true;
        isExecutable = true;
        libraryHaskellDepends = [
@@ -108480,7 +108814,7 @@ self: {
      mkDerivation {
        pname = "puzzle-draw-cmdline";
        version = "0.1.0.4";
-       sha256 = "0jv0gai689ba5f4c6kdfdlfx5dz000zzk0gdwlz5d9n9pxxfgzxf";
+       sha256 = "aeffe77abfc9a6563ee5ed81f93f00e0b7d21d6dae4dc3882b6a2564a27a604b";
        isLibrary = false;
        isExecutable = true;
        executableHaskellDepends = [
@@ -108500,7 +108834,7 @@ self: {
      mkDerivation {
        pname = "pvd";
        version = "1.1.1";
-       sha256 = "18hlsh3ndlybkiblcfqzjm1pa4myc01yzr9hx7p48yp86q519hvr";
+       sha256 = "79c3140a36e87a44eee930e5ef0360be127543951f3b46579ccbd36607d414a2";
        isLibrary = false;
        isExecutable = true;
        executableHaskellDepends = [
@@ -108521,7 +108855,7 @@ self: {
      mkDerivation {
        pname = "pwstore-cli";
        version = "0.4";
-       sha256 = "1cwb214bifiql2d4jacjl93swhy8yigzj72wbhv213c593bxg8jr";
+       sha256 = "59a2d7d748858d20365c5c1cf95ff4c843ae47a29229499aa038bab848108bb3";
        isLibrary = false;
        isExecutable = true;
        executableHaskellDepends = [
@@ -108543,7 +108877,7 @@ self: {
      mkDerivation {
        pname = "pwstore-fast";
        version = "2.4.4";
-       sha256 = "1cpvlwzg3qznhygrr78f75p65mnljd9v5cvnagfxjqppnrkay6bj";
+       sha256 = "7219af66b6f762d9dd5376b3b25393d4d6626e390e9d9c9f87f6e3f13ea7fbb2";
        libraryHaskellDepends = [
          base base64-bytestring binary byteable bytestring cryptohash random
        ];
@@ -108559,7 +108893,7 @@ self: {
      mkDerivation {
        pname = "pwstore-purehaskell";
        version = "2.1.4";
-       sha256 = "1g7lmlgw8iscbbs96r3a534cf46fyks49b1f9y7hv25ny4wp1p9c";
+       sha256 = "2cdd7039f1b6880d8f4f2eac44f4f4ce10c7c8286a6493f45a4c47c41fadf4bc";
        libraryHaskellDepends = [
          base base64-bytestring byteable bytestring random SHA
        ];
@@ -108573,7 +108907,7 @@ self: {
      mkDerivation {
        pname = "pxsl-tools";
        version = "1.0.1";
-       sha256 = "1q45l1grcja0mf1g90yxsdlr49gqrx27ycr6vln4hsqb5c0iqcfw";
+       sha256 = "dc311c012b0b6b482cdd26337f44cff8259269d3dd83f482ab4049965fa085e0";
        isLibrary = false;
        isExecutable = true;
        executableHaskellDepends = [ base containers mtl parsec ];
@@ -108589,7 +108923,7 @@ self: {
      mkDerivation {
        pname = "pyffi";
        version = "0.4.0.2";
-       sha256 = "0cpzl0d0hsdlm1786s75xsq3c93mm1sp7alr6xhihmnrsj71d58h";
+       sha256 = "1095168ed4d95618613799aa7375a8752436b0eee568834ea8b469081aa0ff32";
        libraryHaskellDepends = [
          aeson base bytestring containers pureMD5 template-haskell
        ];
@@ -108607,7 +108941,7 @@ self: {
      mkDerivation {
        pname = "pyfi";
        version = "0.4.0.4";
-       sha256 = "0xq5nhc11dkf2yvzcd129n0r7vpias091lzkll4f4cjsmljbxigw";
+       sha256 = "fcc5be24ad5a32e208a5f3d3908056f1ee93814d2234f6b7176eb61018b40577";
        libraryHaskellDepends = [
          aeson base bytestring containers pureMD5 template-haskell
        ];
@@ -108625,7 +108959,7 @@ self: {
      mkDerivation {
        pname = "python-pickle";
        version = "0.2.0";
-       sha256 = "0p7pmwqs9jfv6464106j0k22x6lij5rc5v74aqbfclx7iwp6lh75";
+       sha256 = "e5406a2e8fa753e61656e4ecc27291919a2ec404d280400c31dbc9a431aff75c";
        isLibrary = true;
        isExecutable = true;
        libraryHaskellDepends = [
@@ -108643,7 +108977,7 @@ self: {
      mkDerivation {
        pname = "qc-oi-testgenerator";
        version = "1.2.0.3";
-       sha256 = "13rga5haz26qvx3hznbl6ik55s8g7qi3nj7a6vhyx46vjhzwnsvg";
+       sha256 = "6f6bcb3f94db90eee136ea483b223e0fe952663474d90f47dfd888af60512f8f";
        libraryHaskellDepends = [
          base fclabels QuickCheck template-haskell
        ];
@@ -108658,7 +108992,7 @@ self: {
      mkDerivation {
        pname = "qd";
        version = "1.0.2.1";
-       sha256 = "0dhvdrpcbc6qiqna2kiaa0zbz7cgq7ziy2my6k85cbgv6k77p918";
+       sha256 = "28a47bce34fb2d56d034be0a1fffc18f9dbf3e502a4ea12c8ed8b0c56e6e1b36";
        libraryHaskellDepends = [ base floatshow ];
        librarySystemDepends = [ qd ];
        description = "double-double and quad-double number type via libqd";
@@ -108671,7 +109005,7 @@ self: {
      mkDerivation {
        pname = "qd-vec";
        version = "1.1";
-       sha256 = "0lj5kg0sjkck89phvi239xb2k7hxmxg9dh7yg2df2iaj4c2m2ync";
+       sha256 = "cc7a5105235245e19a78fec0965eaf1d9e29564f43c40d6f42934da9c19b4552";
        libraryHaskellDepends = [ base qd Vec ];
        description = "'Vec' instances for 'qd' types";
        license = stdenv.lib.licenses.bsd3;
@@ -108683,7 +109017,7 @@ self: {
      mkDerivation {
        pname = "qhull-simple";
        version = "0.1";
-       sha256 = "0g0abqc5z9nysm21c77kylkka1bvyn16ycinws1lcrjy53cb82sw";
+       sha256 = "5c0bb4d8285e664683e636326f82f57b053527f5f31c1644d5dea65f185e0a3c";
        libraryHaskellDepends = [ base vector ];
        librarySystemDepends = [ qhull ];
        homepage = "http://nonempty.org/software/haskell-qhull-simple";
@@ -108697,7 +109031,7 @@ self: {
      mkDerivation {
        pname = "qrcode";
        version = "0.1.2";
-       sha256 = "1wfnxlz6rqjcgnkaqq0wdn75jsh3b9hagb84c1ljnwqaw98n3a9d";
+       sha256 = "2da96151e20a732b696004ada7605a036a598e6d1c60aca67d4ce26c3eedd6f1";
        libraryHaskellDepends = [ array base containers mtl vector ];
        description = "QR Code library in pure Haskell";
        license = stdenv.lib.licenses.bsd3;
@@ -108711,7 +109045,7 @@ self: {
      mkDerivation {
        pname = "quadratic-irrational";
        version = "0.0.5";
-       sha256 = "1z9a1q8px4sx7fq9i1lwfx98kz0nv8zhkz5vsfn31krvd4xvkndz";
+       sha256 = "bfd9b93b693bcf30acd3bbfc093fda16fc8952779c8698b03b5d937e110e2afd";
        libraryHaskellDepends = [
          arithmoi base containers mtl transformers
        ];
@@ -108733,7 +109067,7 @@ self: {
      mkDerivation {
        pname = "quandl-api";
        version = "0.2.1.0";
-       sha256 = "01mjwg7myal3hc98s7v582ycabv7qx2j6lcsyvhxbmhzs1wl8sqf";
+       sha256 = "0e6b4479d01fd6d5e1f69a512345c7672fc5bc40651f8d1283832a5fcfe3b206";
        libraryHaskellDepends = [
          aeson base blaze-builder bytestring http-conduit http-types syb
          text time time-locale-compat unordered-containers
@@ -108750,7 +109084,7 @@ self: {
      mkDerivation {
        pname = "quantfin";
        version = "0.2.0.0";
-       sha256 = "0s9wmkngz31wrllffk3i8y66f60liajwhapih7mnriyfvqqsb6ra";
+       sha256 = "2a9ba531decec76ceb81f12ac8a58a1418678c47714ce728cd3c8cffecac3c69";
        isLibrary = true;
        isExecutable = true;
        libraryHaskellDepends = [
@@ -108771,7 +109105,7 @@ self: {
      mkDerivation {
        pname = "quantities";
        version = "0.3.0";
-       sha256 = "1c9ll27qwmzz8rfy7jlknzg56r0z2hij9aha3vwylv6iaynl4fr9";
+       sha256 = "293b42ad57d16ceaf91e0aaa2423141f6453deb793cae35d46ff578e8fa034b1";
        libraryHaskellDepends = [ base containers mtl parsec ];
        testHaskellDepends = [
          base containers doctest Glob hlint hspec mtl parsec process
@@ -108788,7 +109122,7 @@ self: {
      mkDerivation {
        pname = "quantum-arrow";
        version = "0.0.5";
-       sha256 = "19z5b0jwnz20g0203xd78cv8rgm92diyxard4mbj6dyrj2kkfgww";
+       sha256 = "9c3f37a790d9372357252dabee6313a9be8c3643a7f5010478407ccb2558e5a7";
        libraryHaskellDepends = [ base MonadRandom mtl QuickCheck random ];
        jailbreak = true;
        homepage = "http://github.com/luqui/quantum-arrow";
@@ -108804,7 +109138,7 @@ self: {
      mkDerivation {
        pname = "qudb";
        version = "0.0.1";
-       sha256 = "0cpvik35qv587k2qsd2rh7awlwll1gciv0nr7wjr79bn0q9df0cq";
+       sha256 = "9801d7120676a593253fd9821dd90b9472cad58159348dc53ca86c5cc68cfb32";
        isLibrary = false;
        isExecutable = true;
        executableHaskellDepends = [
@@ -108825,7 +109159,7 @@ self: {
      mkDerivation {
        pname = "quenya-verb";
        version = "0.0.1";
-       sha256 = "0zw15qym8r00m7kir9h9cys1rmszdqihfcvy6dw52f1pb6cp5vsx";
+       sha256 = "5def72995937385178337e3307236e5fd71cb46709a61ce7a90064543d2e817f";
        isLibrary = true;
        isExecutable = true;
        libraryHaskellDepends = [
@@ -108847,7 +109181,7 @@ self: {
      mkDerivation {
        pname = "querystring-pickle";
        version = "0.2.0";
-       sha256 = "18by7671q3sp38cii7j8b0jvdbbix4wyaa3wan77s0mfkdxzicrf";
+       sha256 = "2eb3f87b9bae027d8e557c28e539e971adb62558489e18191a570f1c8e397ea1";
        libraryHaskellDepends = [ base bytestring text ];
        testHaskellDepends = [
          base bytestring QuickCheck test-framework
@@ -108863,7 +109197,7 @@ self: {
      mkDerivation {
        pname = "questioner";
        version = "0.1.1.0";
-       sha256 = "05q64mslkbg017fpjx7ma2al6iz5zjrkyzipm8p86n8zcx3l1aw3";
+       sha256 = "83ab4047671f59832eaa377e3fb3fce547439550f57479dd09e0ad4975250617";
        isLibrary = true;
        isExecutable = true;
        libraryHaskellDepends = [
@@ -108880,7 +109214,7 @@ self: {
      mkDerivation {
        pname = "queue";
        version = "0.1.2";
-       sha256 = "0fx2svkj2sy2wd056lha9h20hy2z6gjspzl11jmv7i3rdwwfr6f7";
+       sha256 = "c799ec386f79c4b3ab0c81feabe5335f7808044c0a525340e3c26b21e7d6a23b";
        libraryHaskellDepends = [ base stm ];
        homepage = "http://code.haskell.org/~mokus/queue";
        description = "Abstraction typeclasses for queue-like things";
@@ -108892,7 +109226,7 @@ self: {
      mkDerivation {
        pname = "queuelike";
        version = "1.0.9";
-       sha256 = "0nvs9ln55wrczpn948i4z110rbfp0rv2wv8iz94lbyxhilhyjf1z";
+       sha256 = "3f38e9218db0fb4549fa116d2e7606d7ad0c42f8242292ecfd2cf3522c4d7a5b";
        libraryHaskellDepends = [ array base containers mtl stateful-mtl ];
        description = "A library of queuelike data structures, both functional and stateful";
        license = stdenv.lib.licenses.bsd3;
@@ -108904,7 +109238,7 @@ self: {
      mkDerivation {
        pname = "quick-generator";
        version = "0.3";
-       sha256 = "1bccyvm300bkm3n98ayjc3syfcakjnf26bs2mdqdjimdfw2f0g6n";
+       sha256 = "d63ce00477ad46d970ab422f239c955331e7f560d22b94eca8730130eaf68cad";
        libraryHaskellDepends = [ base QuickCheck ];
        description = "Generator random test data for QuickCheck";
        license = stdenv.lib.licenses.bsd3;
@@ -108915,7 +109249,7 @@ self: {
      mkDerivation {
        pname = "quickcheck-assertions";
        version = "0.2.0";
-       sha256 = "0h7pa84hzy3bhv1acf1rvvw3lza0m8shd8a0vykzpx8lnkxbl3v0";
+       sha256 = "600fbafab414f5fba7df40a10635aa407d3af8de3938a6c2866bf80f0952f740";
        libraryHaskellDepends = [ base ieee754 QuickCheck ];
        testHaskellDepends = [ base hspec ieee754 QuickCheck ];
        homepage = "https://github.com/s9gf4ult/quickcheck-assertions";
@@ -108930,7 +109264,7 @@ self: {
      mkDerivation {
        pname = "quickcheck-instances";
        version = "0.3.11";
-       sha256 = "041s6963czs1pz0fc9cx17lgd6p83czqy2nxji7bhxqxwl2j15h2";
+       sha256 = "02962005e51d77b84e94dd0a8f3f1be89af6e8099d25e6c0bf417f364c323a10";
        libraryHaskellDepends = [
          array base bytestring containers hashable old-time QuickCheck text
          time unordered-containers
@@ -108945,7 +109279,7 @@ self: {
      mkDerivation {
        pname = "quickcheck-io";
        version = "0.1.1";
-       sha256 = "16q3sqvxnaqmbb1zbda8f61mdlmmzxhrznqxab113lmg380nwfm2";
+       sha256 = "a23a6e011aafd211c2521ddb9f61ffb5d256837148b5f5c35a152bdb37d6039b";
        libraryHaskellDepends = [ base HUnit QuickCheck ];
        description = "Use HUnit assertions as QuickCheck properties";
        license = stdenv.lib.licenses.mit;
@@ -108958,7 +109292,7 @@ self: {
      mkDerivation {
        pname = "quickcheck-poly";
        version = "0.2.0.1";
-       sha256 = "0imigjsb6jy1k9xipi5b4b300cpv2l7hhd2iiqpn80dp10v7y5na";
+       sha256 = "ca167f3608b701642f8e5134080f15fb3200c622abc41b7b9ac14bb3b47cb146";
        libraryHaskellDepends = [
          base haskell98 hint MonadCatchIO-mtl QuickCheck regex-compat
          regex-tdfa
@@ -108973,7 +109307,7 @@ self: {
      mkDerivation {
        pname = "quickcheck-properties";
        version = "0.1";
-       sha256 = "0hr61w1wpah1p4h87iz17aby53ysa8waqsl0als8b69in0zyv29w";
+       sha256 = "3c89ed3fb03199853455806aac3852da8fe2973ae1c78320b901aacb030f2643";
        libraryHaskellDepends = [ base ];
        description = "QuickCheck properties for standard type classes";
        license = stdenv.lib.licenses.bsd3;
@@ -108984,7 +109318,7 @@ self: {
      mkDerivation {
        pname = "quickcheck-property-comb";
        version = "0.1.0.2";
-       sha256 = "0wqz2amhwf1djbwwdin142mzp94mxbzb12khznijissjdz38knp5";
+       sha256 = "e5da89c66f52eb28a3fd708ab0feea95a4fbab20c1c6c6f9922d380eab121f73";
        libraryHaskellDepends = [ base mtl QuickCheck ];
        jailbreak = true;
        homepage = "http://www.github.com/jfeltz/quickcheck-property-comb";
@@ -108999,7 +109333,7 @@ self: {
      mkDerivation {
        pname = "quickcheck-property-monad";
        version = "0.2.3";
-       sha256 = "12vg14xwhhsqwygrs5lylsg514am5sslqc15nbl8mwzzxix1w8xb";
+       sha256 = "ab231e7aecfff38ae8b225304cb52e5591509ea69e169d9fe75843c83b096f8b";
        libraryHaskellDepends = [ base either QuickCheck transformers ];
        testHaskellDepends = [
          base directory doctest filepath QuickCheck
@@ -109017,7 +109351,7 @@ self: {
      mkDerivation {
        pname = "quickcheck-regex";
        version = "0.0.3";
-       sha256 = "00h08l3qabj140zzcpj87hy9zb6cw1xj5w6xv6sq2m8yc3pdwi8n";
+       sha256 = "1645deee601e5581b5d9ddf0227be0ccac9f3c3c485ef63f20412e8507450002";
        libraryHaskellDepends = [
          base containers QuickCheck regex-genex regex-tdfa
        ];
@@ -109034,7 +109368,7 @@ self: {
      mkDerivation {
        pname = "quickcheck-relaxng";
        version = "0.0.2";
-       sha256 = "1wrndgvza9610ai02gkwab30hp8ngdknw8n2lx0mg6qajsiiy949";
+       sha256 = "89241fa3960a9b5741a7c2226e677b165d08c6527c3e01a202c124f5f76b36f3";
        libraryHaskellDepends = [
          base hxt hxt-relaxng QuickCheck quickcheck-regex
        ];
@@ -109049,7 +109383,7 @@ self: {
      mkDerivation {
        pname = "quickcheck-rematch";
        version = "0.1.0.0";
-       sha256 = "0pmw9441l36sprw9ngq6gn2yi4v427zd5n22s9zicfyiwi4qf5ba";
+       sha256 = "6a158749e4d13b167fd242d8d2fe116493e8857d063f9b78beda0c1a0849bc5e";
        libraryHaskellDepends = [ base QuickCheck rematch ];
        testHaskellDepends = [ base hspec HUnit QuickCheck rematch ];
        jailbreak = true;
@@ -109064,7 +109398,7 @@ self: {
      mkDerivation {
        pname = "quickcheck-script";
        version = "0.1.1.1";
-       sha256 = "157v4qcyk5c6hnmhmy5rsrfsj46m343nn2bvrqyb6r92wh70is5g";
+       sha256 = "afe8080ee42265b33cce7b096b0719d510a95dd6b9f80aab858695e91926fb94";
        isLibrary = false;
        isExecutable = true;
        executableHaskellDepends = [ base directory process QuickCheck ];
@@ -109078,7 +109412,7 @@ self: {
      mkDerivation {
        pname = "quickcheck-simple";
        version = "0.1.0.0";
-       sha256 = "0vnxyb3qz8i1rpmkga6151cld1jr3kiyv3xrhg814mhf1fmhb8xl";
+       sha256 = "b4a305ab0b0e5612d083b98fede31c5986465928c1a837ebcd21a28fc7f2dd6e";
        libraryHaskellDepends = [ base QuickCheck ];
        description = "Test properties and default-mains for QuickCheck";
        license = stdenv.lib.licenses.bsd3;
@@ -109089,7 +109423,7 @@ self: {
      mkDerivation {
        pname = "quickcheck-unicode";
        version = "1.0.0.1";
-       sha256 = "1a8nl6x7l9b22yx61wm0bh2n1xzb1hd5i5zgg1w4fpaivjnrrhi4";
+       sha256 = "24c29caddc515d477878ef97581a0cebf760055ca0f260ba1762257abaa116a9";
        libraryHaskellDepends = [ base QuickCheck ];
        homepage = "https://github.com/bos/quickcheck-unicode";
        description = "Generator and shrink functions for testing Unicode-related software";
@@ -109101,7 +109435,7 @@ self: {
      mkDerivation {
        pname = "quickcheck-webdriver";
        version = "0.1.0.7";
-       sha256 = "12jkj8jy4f0mix658pd8jfgwx268fs3bbqz90mac1vvag4c72i0h";
+       sha256 = "10447118796aefc05405e9e3b58676c888ce9f93a85d544c8f1538e22592538a";
        libraryHaskellDepends = [ base QuickCheck transformers webdriver ];
        jailbreak = true;
        description = "Utilities for using WebDriver with QuickCheck";
@@ -109115,7 +109449,7 @@ self: {
      mkDerivation {
        pname = "quicklz";
        version = "1.5.0.11";
-       sha256 = "17v9bfdp4ib9258r7001naqwss7l6v83by40va3gm3l418vj62qd";
+       sha256 = "0d0b23370a848efa86da80f835d036f468cdb1b201809351116945729b5b699f";
        libraryHaskellDepends = [ base bytestring ];
        testHaskellDepends = [
          base bytestring QuickCheck test-framework
@@ -109132,7 +109466,7 @@ self: {
      mkDerivation {
        pname = "quickpull";
        version = "0.4.2.2";
-       sha256 = "0vy5s3qa67kwj68rxqc0zhqizqpvqa1x0bg3dakq5pimrqhmb7d4";
+       sha256 = "a49d5521ce35de82a76ae32dd083c2fbe21f31fc80e19e91917c1ea3f0d0c56f";
        isLibrary = true;
        isExecutable = true;
        libraryHaskellDepends = [ base directory filepath QuickCheck ];
@@ -109152,7 +109486,7 @@ self: {
      mkDerivation {
        pname = "quickset";
        version = "0.1.0";
-       sha256 = "0xiw57wi9z567nmp4h0vfcw3sr9dciy29jadn47bvi3q278v7zdy";
+       sha256 = "befdb3d11178c4bd0eb14dc9247c642d653d38731b4072ab3da6fc14f9293c76";
        libraryHaskellDepends = [ base vector vector-algorithms ];
        description = "Very fast and memory-compact query-only set and map structures";
        license = stdenv.lib.licenses.bsd3;
@@ -109166,7 +109500,7 @@ self: {
      mkDerivation {
        pname = "quickspec";
        version = "0.9.6";
-       sha256 = "0prwzxsrvfqryl75rmma229d4y7ra61vc3d72kyqi4l44ga2ay21";
+       sha256 = "417825d423849288fd14a70db68351f978d29210aad65c0ef519bb9d75ff3c5f";
        libraryHaskellDepends = [
          array base containers ghc-prim QuickCheck random spoon transformers
        ];
@@ -109180,7 +109514,7 @@ self: {
      mkDerivation {
        pname = "quicktest";
        version = "0.1.3";
-       sha256 = "0nvh6jd155xrjzkkbsz5q8d08z50881vkdhmprm7fdxax1gvjc95";
+       sha256 = "2531b95fe8aa37776abe15b6b90342a07c041ac2e5eb35e797b997129a34705b";
        isLibrary = false;
        isExecutable = true;
        executableHaskellDepends = [
@@ -109197,7 +109531,7 @@ self: {
      mkDerivation {
        pname = "quickwebapp";
        version = "2.1.0.0";
-       sha256 = "0zwqfwwna1d588yk2i20nzryl56k2bh4nyg03ljszyhna16iclij";
+       sha256 = "3252164d5016faaf251de0794be012d314eaf3b74044313d42a505653977987f";
        libraryHaskellDepends = [ base bytestring http-types scotty text ];
        jailbreak = true;
        description = "A quick webapp generator for any file processing tool";
@@ -109209,7 +109543,7 @@ self: {
      mkDerivation {
        pname = "quiver";
        version = "0.0.0.11";
-       sha256 = "1pxnxdm84fqmxvv0l312q8nynpaiyf43jksa2qg1wkl53n0mm2fa";
+       sha256 = "ca895a811d854e1e1e164a4f3988f3515deb2dc2220c0af6ee153b826aebb6df";
        libraryHaskellDepends = [ base ];
        homepage = "https://github.com/zadarnowski/quiver";
        description = "Quiver finite stream processing library";
@@ -109221,7 +109555,7 @@ self: {
      mkDerivation {
        pname = "quiver-bytestring";
        version = "0.0.0.2";
-       sha256 = "17wjj1fg60g3km9d4kxfz7lk9bf4sfz0brsg8pb0h2xlw0zvm3wl";
+       sha256 = "948fba3fe0b40b08d6454fe705bed3c4ad34e9f9ae4fd2529de301f35c90929f";
        libraryHaskellDepends = [ base bytestring quiver ];
        homepage = "https://github.com/zadarnowski/quiver-bytestring";
        description = "Quiver combinators for bytestring streaming";
@@ -109233,7 +109567,7 @@ self: {
      mkDerivation {
        pname = "quiver-cell";
        version = "0.0.0.2";
-       sha256 = "10p11ljmwp7szw46saxa972xpjiyr5r19kia6ivaq98jqwcvi5af";
+       sha256 = "4e95b819c71225ac76342ace1472c93ecadbc549aa2b6d08fffa5c5e250de182";
        libraryHaskellDepends = [ base data-cell quiver ];
        homepage = "https://github.com/zadarnowski/quiver-cell";
        description = "Quiver combinators for cellular data processing";
@@ -109247,7 +109581,7 @@ self: {
      mkDerivation {
        pname = "quiver-csv";
        version = "0.0.0.3";
-       sha256 = "19wb16lbv0wr7w2qba6g2cdmzdhpyyjx1bjvrnz0cqbb4di9yscj";
+       sha256 = "92699f62236b6106becd5baed0a5f717b65f1b13cfa885053f9983bda8098ba7";
        libraryHaskellDepends = [
          base bytestring data-cell quiver quiver-bytestring
        ];
@@ -109261,7 +109595,7 @@ self: {
      mkDerivation {
        pname = "quiver-enumerator";
        version = "0.0.0.1";
-       sha256 = "0k0822yzlxkb6b46834hm3bad3x1gma1gqcjl9ryxpqsl73nc4mp";
+       sha256 = "b71266c7a11adfee73a292e117547da18fa6d6a8900c64c8326b76fabd10084c";
        libraryHaskellDepends = [ base enumerator quiver ];
        homepage = "https://github.com/zadarnowski/quiver-enumerator";
        description = "Bridge between Quiver and Iteratee paradigms";
@@ -109277,7 +109611,7 @@ self: {
      mkDerivation {
        pname = "quoridor-hs";
        version = "0.1.1.2";
-       sha256 = "1yha2rsphq2ar8c7p15dlg621d4ym46xgv70fga9mlq2r4zwy2lv";
+       sha256 = "9b0acf3fc902d39ad473e0ecd70da99eb420cca3ad847b18ca4a607875160afa";
        isLibrary = true;
        isExecutable = true;
        libraryHaskellDepends = [
@@ -109299,7 +109633,7 @@ self: {
      mkDerivation {
        pname = "rabocsv2qif";
        version = "1.1.5";
-       sha256 = "1vb9r2nmkhybx1ra2jpzfz5i6klgz2jz09zhg5wi95dnml82p33g";
+       sha256 = "6f8c2b10adb695147979f027f0a5f88f4e13cb77ff4aa172e8cbc359adc869ed";
        isLibrary = true;
        isExecutable = true;
        libraryHaskellDepends = [ base old-locale split time ];
@@ -109314,7 +109648,7 @@ self: {
      mkDerivation {
        pname = "rad";
        version = "0.1.6.3";
-       sha256 = "19g2lc3vmnapccdxf390cmkfl9bd3agcn01kk8ccd4lmaqn2c12d";
+       sha256 = "4d04262c569592c6189a3300cb9e1a6d25ea6665200dd71b6357d9ba07a3e2a5";
        libraryHaskellDepends = [ array base containers data-reify ];
        jailbreak = true;
        homepage = "http://comonad.com/reader/";
@@ -109330,7 +109664,7 @@ self: {
      mkDerivation {
        pname = "radian";
        version = "0.0.4";
-       sha256 = "1f53h9gcbmfga5khc67z81aysibcj5pqgi3iwa2shy5mfd10a86a";
+       sha256 = "ca20054273b578a885e271c4876f916c45ed5540ff18066751cfd5c55e82a3b8";
        libraryHaskellDepends = [ base lens ];
        testHaskellDepends = [
          base directory doctest filepath QuickCheck template-haskell
@@ -109346,7 +109680,7 @@ self: {
      mkDerivation {
        pname = "radium";
        version = "0.4.2";
-       sha256 = "1kwbv7qvpjwdcnj6l26dpyw0xl3irhd5igwda4xx509llc8j8n3s";
+       sha256 = "7a582411a33481d23b518dbf581acc71d00eb8bfcd086aa4658dcbbbf1d98bcf";
        libraryHaskellDepends = [ base containers parsec ];
        testHaskellDepends = [
          base Cabal containers hspec parsec QuickCheck
@@ -109364,7 +109698,7 @@ self: {
      mkDerivation {
        pname = "radium-formula-parser";
        version = "0.2";
-       sha256 = "1b2gmc27dj9fanbjh7h0902jjh3jz1ydc6qvp9p3rfskaf6854bf";
+       sha256 = "6e91828c5353bb3c6eba1b1bd67cf87240290548001e2897552ec97604ab4fac";
        libraryHaskellDepends = [ base containers parsec ];
        testHaskellDepends = [
          base Cabal containers hspec parsec QuickCheck
@@ -109381,7 +109715,7 @@ self: {
      mkDerivation {
        pname = "radix";
        version = "1.0.0.0";
-       sha256 = "1hkz0fd1w72g6wnx9dq7z249195kjlhalcd1y8z13gj6yqn1sl9s";
+       sha256 = "3a511d2cf646be113ef2a131aa2095b3a49088f807b7d42d374f1c1e9a037fc2";
        isLibrary = false;
        isExecutable = true;
        executableHaskellDepends = [ base filepath ];
@@ -109398,7 +109732,7 @@ self: {
      mkDerivation {
        pname = "rados-haskell";
        version = "3.1.0";
-       sha256 = "0xffgf95dss442sf6adh7yys39i0z64w155akjyzr9dp2jzr6f2k";
+       sha256 = "533893bf14b7a5fcbd9caa94c089f920a6a1bd3fb029e3b42044eb56927bce75";
        libraryHaskellDepends = [
          async base bytestring containers mtl uuid
        ];
@@ -109420,7 +109754,7 @@ self: {
      mkDerivation {
        pname = "rail-compiler-editor";
        version = "0.3.0.0";
-       sha256 = "0jjsa21a7f4hysbk9qvcxyyc2ncrmmjh02n7yyhjnfjgdp4sclwb";
+       sha256 = "8b53a6c96d4f3a2ba1f7c70a0065ad9959c1bcef6ce33497f690b8a382505a4a";
        isLibrary = true;
        isExecutable = true;
        libraryHaskellDepends = [
@@ -109443,7 +109777,7 @@ self: {
      mkDerivation {
        pname = "rainbow";
        version = "0.26.0.6";
-       sha256 = "1v0za967cp1205fkbwglf28yn2pslp7dvyqb3rbym3j7r3pby3zc";
+       sha256 = "ec0fbfeec8478eea571e0bfbddcea5fa0aeb9170f4f1355d01225c764c521fec";
        libraryHaskellDepends = [ base bytestring lens process text ];
        testHaskellDepends = [
          base bytestring lens process QuickCheck text
@@ -109460,7 +109794,7 @@ self: {
      mkDerivation {
        pname = "rainbow-tests";
        version = "0.20.0.4";
-       sha256 = "0cjq2m2zpk4j2f7gw65yqqvyc4kng1rsnq48fs4xcs6bdzw0zhlg";
+       sha256 = "8fc20ff86fcb68d689768860ab73787612e637c6be18fe8e1392ccfb45155832";
        libraryHaskellDepends = [
          barecheck base QuickCheck rainbow terminfo text
        ];
@@ -109478,7 +109812,7 @@ self: {
      mkDerivation {
        pname = "rainbox";
        version = "0.18.0.2";
-       sha256 = "1dczbs4y8yzvp132cfy0fl1jv2zf2nm6d3zn4j4pmy2p8cxs1g4v";
+       sha256 = "9bbca03b4357f87a8924f68f66aa15ee8b2d0375c03b2646b8fb7be4895e9fb5";
        libraryHaskellDepends = [
          base bytestring containers lens rainbow text
        ];
@@ -109496,7 +109830,7 @@ self: {
      mkDerivation {
        pname = "rake";
        version = "0.0.1";
-       sha256 = "0cn22xg7r80f61z8pf7i0rqqag4qx43rhlfpncgkv5b6vcrsafpn";
+       sha256 = "f63aa533db66953d1fb3d7519807e9983c857106f1b88b7e300ea07c5e17c232";
        libraryHaskellDepends = [ base containers text ];
        homepage = "http://github.com/toschoo/Haskell-Libs";
        description = "Rapid Automatic Keyword Extraction (RAKE)";
@@ -109510,7 +109844,7 @@ self: {
      mkDerivation {
        pname = "rakhana";
        version = "0.2.0.2";
-       sha256 = "10gk2wk8495y1zk148sqsm993dzi4z6a49nn717qccpc2qi4lw6k";
+       sha256 = "d3704a2216ec32864f38d626a2cc27f1b79152d5582312e60fbe24822617f381";
        libraryHaskellDepends = [
          attoparsec base bytestring containers lens mtl pipes scientific
          transformers vector zlib
@@ -109527,7 +109861,7 @@ self: {
      mkDerivation {
        pname = "ralist";
        version = "0.1.0.0";
-       sha256 = "0v2cg1d2wzjcygk78qcz1yfy9rcqw8yrplnnk6cax41qifhr5z5i";
+       sha256 = "b1fc92a18b3890ae9899d6d29b3de298e5e49d0f9f6174e6f34c7e2e5a784c6c";
        libraryHaskellDepends = [ base ];
        description = "Random access list with a list compatible interface";
        license = stdenv.lib.licenses.bsd3;
@@ -109539,7 +109873,7 @@ self: {
      mkDerivation {
        pname = "rallod";
        version = "0.0.1";
-       sha256 = "14fnk2q702qm0mh30r9kznbh4ikpv4fsd5mrnwphm5d06vmq6hq9";
+       sha256 = "094383eb36a0950a2fb7b996a61dd977460297fd3365306005150b70b098d691";
        libraryHaskellDepends = [ base haskell98 ];
        homepage = "http://github.com/moonmaster9000/rallod";
        description = "'$' in reverse";
@@ -109554,7 +109888,7 @@ self: {
      mkDerivation {
        pname = "raml";
        version = "0.1.0";
-       sha256 = "02c1rki7azfwfiawi29z5gp1zwfdx46rw17bifpklw7zya525pr9";
+       sha256 = "29df228af2ff703aaf8beb049e0de9cdf11fee2b3f89c85574dc7d75e2cc8109";
        libraryHaskellDepends = [
          aeson base bytestring text unordered-containers yaml
        ];
@@ -109568,7 +109902,7 @@ self: {
      mkDerivation {
        pname = "rand-vars";
        version = "0.1";
-       sha256 = "165jvx59vzmpxp7gw60ivfka77kgc1irwijikkwja7jb4dm4ay3x";
+       sha256 = "7d78456a234b1e25f99c51469e63606f9ea3a6db1118feceedb7fe9d4adfb298";
        libraryHaskellDepends = [ array base IntervalMap mtl random ];
        description = "Random variable library, with Functor, Applicative and Monad instances";
        license = stdenv.lib.licenses.bsd3;
@@ -109582,7 +109916,7 @@ self: {
      mkDerivation {
        pname = "randfile";
        version = "0.1.0.0";
-       sha256 = "11f72kfya4l41dihjvaz15hzipry281r8i6k6dzp5q3gq4valgyz";
+       sha256 = "df3faa36c16fe0727f33d3449403123edff861095f6d09630b8412e5dd14c785";
        isLibrary = false;
        isExecutable = true;
        executableHaskellDepends = [
@@ -109598,7 +109932,7 @@ self: {
      mkDerivation {
        pname = "random";
        version = "1.1";
-       sha256 = "0nis3lbkp8vfx8pkr6v7b7kr5m334bzb0fk9vxqklnp2aw8a865p";
+       sha256 = "b718a41057e25a3a71df693ab0fe2263d492e759679b3c2fea6ea33b171d3a5a";
        libraryHaskellDepends = [ base time ];
        testHaskellDepends = [ base ];
        description = "random number library";
@@ -109610,7 +109944,7 @@ self: {
      mkDerivation {
        pname = "random-access-list";
        version = "0.2";
-       sha256 = "1ymbs3f38l6ch0nphsy9pi32yb1a4hazn3grm9fl0dvgqw28xl8r";
+       sha256 = "19d18e04c76f37405daaf90dfb15242a2c2f46bcc96b782d80cc5034dcd0abfa";
        libraryHaskellDepends = [ array base containers ];
        description = "Random-access lists in Haskell";
        license = stdenv.lib.licenses.bsd3;
@@ -109622,7 +109956,7 @@ self: {
      mkDerivation {
        pname = "random-derive";
        version = "0.1.0.0";
-       sha256 = "08irzyg8cgigj009zp5hg33gdwranrdyyzrxhmwyib6fm5bmsj8p";
+       sha256 = "17495d57a9ceace879853d7fef5bb62af3f6c678b0dc9f00902f3e869eff3922";
        libraryHaskellDepends = [ base random template-haskell ];
        homepage = "https://github.com/frerich/random-derive";
        description = "A Template Haskell helper for deriving Random instances";
@@ -109634,7 +109968,7 @@ self: {
      mkDerivation {
        pname = "random-eff";
        version = "0.1.0.1";
-       sha256 = "1m28np0zfabp1n1d08przh35bxfr1l7d39kj4a5z61jkchmsaxyf";
+       sha256 = "ce77a52b645306f38b2272a6d10e0dd9f55506fcf922d0820d7729f7c1b548d4";
        libraryHaskellDepends = [ base extensible-effects random ];
        jailbreak = true;
        description = "A simple random generator library for extensible-effects";
@@ -109647,7 +109981,7 @@ self: {
      mkDerivation {
        pname = "random-effin";
        version = "0.1.1.0";
-       sha256 = "0p1n5dfdsp00q9mlhd7xcl93k5d0wji91p59858gmfx9xf8j0p0h";
+       sha256 = "105c2091eba9bbfa5041a9dc90a2e4a095391265fd34486bc2005cdd5c2b365c";
        libraryHaskellDepends = [ base effin random ];
        jailbreak = true;
        description = "A simple random generator library for effin";
@@ -109661,7 +109995,7 @@ self: {
      mkDerivation {
        pname = "random-extras";
        version = "0.19";
-       sha256 = "1b45s314rqkk0np460p3p0wrqvkv9dczifny8pp76ikksalfvgn0";
+       sha256 = "c0beeda8d2734673ee45debaf8594b7b6e9c39b8e30243ae0573e24cc2d085ac";
        libraryHaskellDepends = [
          array base containers random-fu random-source
        ];
@@ -109678,7 +110012,7 @@ self: {
      mkDerivation {
        pname = "random-fu";
        version = "0.2.6.2";
-       sha256 = "1j7zr7h860vjwlh9d9sj319xs44ly2vyzn3s72c5qc39r0yv00ng";
+       sha256 = "cf02b03dc869305c98387ad8efb7f09410dd531852a79620e5720383e0c9ffc8";
        libraryHaskellDepends = [
          base erf log-domain math-functions monad-loops mtl random-shuffle
          random-source rvar syb template-haskell transformers vector
@@ -109695,7 +110029,7 @@ self: {
      mkDerivation {
        pname = "random-hypergeometric";
        version = "0.1.0.0";
-       sha256 = "0jg4j2nwijb5ic9zl5y9miqhn881dmf0s49gj8f818as3mhvqlgh";
+       sha256 = "f051bc611d5aa1801c922f110d5c6d01210b71acc917fa138b65c9c8ad90e449";
        libraryHaskellDepends = [ base math-functions random-fu ];
        testHaskellDepends = [
          base Cabal cabal-test-quickcheck math-functions mwc-random
@@ -109713,7 +110047,7 @@ self: {
      mkDerivation {
        pname = "random-shuffle";
        version = "0.0.4";
-       sha256 = "0586bnlh0g2isc44jbjvafkcl4yw6lp1db8x6vr0pza0y08l8w2j";
+       sha256 = "52704411f040fd0bf2361dad162e35dc13caa6535b2e4908d3513c00a95d0615";
        libraryHaskellDepends = [ base MonadRandom random ];
        description = "Random shuffle implementation";
        license = stdenv.lib.licenses.bsd3;
@@ -109727,7 +110061,7 @@ self: {
      mkDerivation {
        pname = "random-source";
        version = "0.3.0.6";
-       sha256 = "0wsv41kpswqml04ym5bq2nan4i637f7h3fmvda2zy506xwxfrpzk";
+       sha256 = "f3dfec3aef0614ff856abbba018f3bc3446295157895ea09a015737d67205b73";
        libraryHaskellDepends = [
          base flexible-defaults mersenne-random-pure64 mtl mwc-random random
          stateref syb template-haskell th-extras
@@ -109742,7 +110076,7 @@ self: {
      mkDerivation {
        pname = "random-stream";
        version = "0.1.1";
-       sha256 = "0q191kz3hmjzrgs143nja5gcis07igb38f51mwqw64zx7vjqvx66";
+       sha256 = "c6f48de53efd13c331afa13834d68b07e8c85e51d20e12f4cb5f5638fe0c2960";
        libraryHaskellDepends = [ base binary bytestring random ];
        description = "An infinite stream of random data";
        license = stdenv.lib.licenses.bsd3;
@@ -109756,7 +110090,7 @@ self: {
      mkDerivation {
        pname = "randomgen";
        version = "0.1";
-       sha256 = "0y7yvsach0c27ahscxr36avjrq281pmg7w6cv2yj5kmbk7ddwlyi";
+       sha256 = "d153deda99abce22bdd8ccf0f3ea0d48e02cb7322377a6a13a8201c894defe78";
        isLibrary = false;
        isExecutable = true;
        executableHaskellDepends = [
@@ -109773,7 +110107,7 @@ self: {
      mkDerivation {
        pname = "randproc";
        version = "0.4";
-       sha256 = "0fb0239fwvn1n3rbdr03k4kx1igzbb638a1iq0ln1k1i1fpaayd7";
+       sha256 = "a779a5ae0b31cc6029c0312834cc5affc5d0279903e4b6f2b0c16eeed2106039";
        libraryHaskellDepends = [ base ];
        homepage = "http://www.haskell.org/haskellwiki/Random_Processes";
        description = "Data structures and support functions for working with random processes";
@@ -109785,7 +110119,7 @@ self: {
      mkDerivation {
        pname = "randsolid";
        version = "0.3";
-       sha256 = "0v7j6qqs16j281hn0330vcpkriqgyvl7087ll665c7dcqqh2bswk";
+       sha256 = "93eb2520c6ac1d568ca1f42070e8f60fc73c2fdb600c606140429aa03136f26c";
        isLibrary = false;
        isExecutable = true;
        executableHaskellDepends = [ base random X11 ];
@@ -109800,7 +110134,7 @@ self: {
      mkDerivation {
        pname = "range";
        version = "0.1.2.0";
-       sha256 = "028bigaq4vk5ykzf04f5hi3g37gxzzp6q24bjcb3gjfzcgy7z6ab";
+       sha256 = "4b997ffc63dfc93716938b086ceefffd9df14684c511e0fef4656e82d58b0b09";
        libraryHaskellDepends = [ base free parsec ];
        testHaskellDepends = [
          base Cabal free QuickCheck random test-framework
@@ -109816,7 +110150,7 @@ self: {
      mkDerivation {
        pname = "range-set-list";
        version = "0.0.7";
-       sha256 = "1qgw95gvbxar13ia6562ddz9zqd14ffyxwp9qi41w859prfc1728";
+       sha256 = "489cc05cbea9201e48c4e9f2ee9d23a1e19f7e6bc214a3e20859f5b55f49fce1";
        libraryHaskellDepends = [ base ];
        testHaskellDepends = [ base containers tasty tasty-quickcheck ];
        jailbreak = true;
@@ -109833,7 +110167,7 @@ self: {
      mkDerivation {
        pname = "range-space";
        version = "0.1.1.2";
-       sha256 = "06cl5kgyl1lccr78galqxp21nli2vkvlywy6394cnp14wqfz8r94";
+       sha256 = "2465f41de6245ccb481ac6734ff7dc22521bc4ed98aa874e668c06eadf2c9419";
        libraryHaskellDepends = [
          base semigroups vector-space vector-space-points
        ];
@@ -109853,7 +110187,7 @@ self: {
      mkDerivation {
        pname = "rangemin";
        version = "2.2.2";
-       sha256 = "01n1m3ibi44pjg04mg16j751fjzkspmnq8bzxz55qbyi22wshnwc";
+       sha256 = "8c5ba8b910d12f5ccaef7f216cebd5f34b17ca9126bc4ac0939790b8e2a8c106";
        libraryHaskellDepends = [ base containers primitive vector ];
        description = "Linear range-min algorithms";
        license = stdenv.lib.licenses.bsd3;
@@ -109865,7 +110199,7 @@ self: {
      mkDerivation {
        pname = "ranges";
        version = "0.2.4";
-       sha256 = "1ymvmvfvzkdxblg691g9n5y94gpiz782jgyvaisg5mydzj1s1fyv";
+       sha256 = "dbbba083fccdd7f27454db3f29d0f9f13e927cb1e985641e5dbdcdbfddaebbfa";
        libraryHaskellDepends = [ base containers ];
        description = "Ranges and various functions on them";
        license = stdenv.lib.licenses.bsd3;
@@ -109878,7 +110212,7 @@ self: {
      mkDerivation {
        pname = "rank1dynamic";
        version = "0.3.1.0";
-       sha256 = "0klfwglssp782p1brbfgjm30d2s3lpgd75iv7jq1pih598kkjsd5";
+       sha256 = "a56939274a05c61bb03c3b96d3dea5438b064695cfadbcc215e85cade9e38e4e";
        libraryHaskellDepends = [ base binary ghc-prim ];
        testHaskellDepends = [
          base HUnit test-framework test-framework-hunit
@@ -109896,7 +110230,7 @@ self: {
      mkDerivation {
        pname = "rascal";
        version = "1.1.6";
-       sha256 = "0q7afppkm5jd1p13fszzsfjpdz6g6bw1vd6wigcy3janxn5686rs";
+       sha256 = "3a1b648aed56c9e1d98bdcb41df832cffc76a5d3ff6b37c20d4d963aef75ea60";
        isLibrary = true;
        isExecutable = true;
        libraryHaskellDepends = [
@@ -109927,7 +110261,7 @@ self: {
      mkDerivation {
        pname = "rasterific-svg";
        version = "0.2.3.1";
-       sha256 = "00p3l8czj7l9jm6ibn9c6wb99v5j5x9ivgh3pamznqcri3lqy7kk";
+       sha256 = "731e8fe9889961fbabba03be1d532fb2ec9416372cd9154d95891ef919a2e302";
        isLibrary = true;
        isExecutable = true;
        libraryHaskellDepends = [
@@ -109948,7 +110282,7 @@ self: {
      mkDerivation {
        pname = "rate-limit";
        version = "1.1.1";
-       sha256 = "1d1dfj05vi8jr2cfy42a58wnm84zm6cmx7fabp2rb83qqm4l2riz";
+       sha256 = "3f664149c578a095c55dca9d5e99a99fa06a392a4a10ef98c812c55d80742db4";
        libraryHaskellDepends = [ base time-units ];
        homepage = "http://github.com/acw/rate-limit";
        description = "A basic library for rate-limiting IO actions";
@@ -109960,7 +110294,7 @@ self: {
      mkDerivation {
        pname = "ratio-int";
        version = "0.1.2";
-       sha256 = "06kqr4iyi184sa8y2vdkw5h0pvh5f8lwcqb8mbcn34lpqm961s7g";
+       sha256 = "efe86052c5979261d9aa6861c6297205ee0b60e1b36de191d20485e823c9781a";
        libraryHaskellDepends = [ base ];
        homepage = "https://github.com/RaphaelJ/ratio-int";
        description = "Fast specialisation of Data.Ratio for Int.";
@@ -109975,7 +110309,7 @@ self: {
      mkDerivation {
        pname = "raven-haskell";
        version = "0.1.0.0";
-       sha256 = "06pa03g9pxxv1qk34ckcgwp5wirj5ag1akml48k18la6p0a2r3mx";
+       sha256 = "bd8e2c14b84651142622b44e159e2a32475e2e7f6c3232260ebbf79bde00ea1a";
        libraryHaskellDepends = [
          aeson base bytestring http-conduit network old-locale random text
          time unordered-containers uuid
@@ -109996,7 +110330,7 @@ self: {
      mkDerivation {
        pname = "raven-haskell-scotty";
        version = "0.1.0.3";
-       sha256 = "0vllfasn4rky8r8fg3mpln8pdkxbcvrvx8wamn0xswfwf1rvcf6k";
+       sha256 = "d338b67370dc71dd81ad8aa3bef366abcf7691a5b78ee750467e6662b572946e";
        libraryHaskellDepends = [
          base bytestring case-insensitive mtl raven-haskell scotty text wai
        ];
@@ -110011,7 +110345,7 @@ self: {
      mkDerivation {
        pname = "raw-strings-qq";
        version = "1.0.2";
-       sha256 = "0wnifa97am2s9bqixlidw3nf8w14h2qkg3sn1rxzgvc3fws57jg9";
+       sha256 = "e9c953347783edf77b0e568f37b1802470e4ece02dd21ef14a5a54759272d172";
        libraryHaskellDepends = [ base template-haskell ];
        homepage = "https://github.com/23Skidoo/raw-strings-qq";
        description = "Raw string literals for Haskell";
@@ -110023,7 +110357,7 @@ self: {
      mkDerivation {
        pname = "rawstring-qm";
        version = "0.2.2.2";
-       sha256 = "0h3s62sn84skwx3p9lcycswydvg6rijig7pk3g7v4rvypfdlybz6";
+       sha256 = "e62f4f9bbb7e67b2cf1bf39e1765cce6ede6b9669ed17447e7531364b5307a40";
        libraryHaskellDepends = [ base bytestring template-haskell text ];
        homepage = "https://github.com/tolysz/rawstring-qm";
        description = "Simple raw string quotation and dictionary interpolation";
@@ -110037,7 +110371,7 @@ self: {
      mkDerivation {
        pname = "razom-text-util";
        version = "0.1.2.0";
-       sha256 = "0sfqc222pplsdmbrhwvbdf6pmqa18vgjd83rk7hqixzp6rk9h7pg";
+       sha256 = "ef1e986636f7f788e19979a026df4641e17a8d6b6b7398576d9ade2b8460d869";
        libraryHaskellDepends = [
          base regex-applicative smaoin text text-position
        ];
@@ -110052,7 +110386,7 @@ self: {
      mkDerivation {
        pname = "rbr";
        version = "0.8.6";
-       sha256 = "0q7b990k3ijjjwhnm1283k9vzmvypyg7mhvbzagvi74q0sgwyac7";
+       sha256 = "8729cf9f06989cb89ffa6bc37a9ebf7ed7bfd31c48846a219752c631414aeb60";
        isLibrary = false;
        isExecutable = true;
        executableHaskellDepends = [ base bio bytestring containers ];
@@ -110069,7 +110403,7 @@ self: {
      mkDerivation {
        pname = "rclient";
        version = "0.1.0.0";
-       sha256 = "1hdcbnkb184a1zfxsh4fxgff9znc5sw6503qbix67c45qiw25zhn";
+       sha256 = "16fe2278c485b0637a5c788062b82eccfee4dceb8e40dddd0f8aa0b0a65dacc1";
        libraryHaskellDepends = [
          base binary bytestring data-binary-ieee754 network QuickCheck split
        ];
@@ -110087,7 +110421,7 @@ self: {
      mkDerivation {
        pname = "rdf4h";
        version = "1.3.2";
-       sha256 = "09ya3d1svg6fj7jdm408gisv0cnn0c2i2c3pn07xggnn882s93bw";
+       sha256 = "7c8da40542d6bed70fb07730110503d632b0757c0890dae491cebcad431bca27";
        isLibrary = true;
        isExecutable = true;
        libraryHaskellDepends = [
@@ -110118,7 +110452,7 @@ self: {
      mkDerivation {
        pname = "rdioh";
        version = "0.2.1";
-       sha256 = "1k0djlhabycj4q7x85bj7n3k0rcyxn9b3k3ijb4za2vxj081qdj0";
+       sha256 = "40361c10907d0bf5c99271ccb192ed9e6530873d7215d40f2692f9a520950dcc";
        isLibrary = true;
        isExecutable = true;
        libraryHaskellDepends = [
@@ -110139,7 +110473,7 @@ self: {
      mkDerivation {
        pname = "rdtsc";
        version = "1.3.0.1";
-       sha256 = "0l6r5v6bgqf7lq9j6bf7w362bz7bv4xrsbz90ns60v4dyqjskjal";
+       sha256 = "54c9a925f68d6c60b405e92f9d3bd9ebfc25cce0c72d2313a6c7e1b7cc2ed950";
        libraryHaskellDepends = [ base ];
        homepage = "https://github.com/mgrabmueller/rdtsc";
        description = "Binding for the rdtsc machine instruction";
@@ -110151,7 +110485,7 @@ self: {
      mkDerivation {
        pname = "rdtsc-enolan";
        version = "0.1";
-       sha256 = "0v3x7ga4gx5q4gwh8xdhb2arlmjyilr9igz28wysy9qqlcdw775q";
+       sha256 = "b89cc31ba31827af3d47e2bf98328d5e569a9558b07504f923b8f447d43b7d6c";
        libraryHaskellDepends = [ base ];
        homepage = "http://code.haskell.org/rdtsc";
        description = "Binding to sources of high-efficiency, high-precision, monotonically increasing relative time";
@@ -110163,7 +110497,7 @@ self: {
      mkDerivation {
        pname = "re2";
        version = "0.1";
-       sha256 = "08mmbxj9dpnb56b6vh0lz7nimp3w3v9g2c6ypxgz8ahvlia0a4f5";
+       sha256 = "c5110554a41b2af45fbfde30f1d21e7cdc1aedf914c06d9629cbde96645fb522";
        libraryHaskellDepends = [ base bytestring vector ];
        testHaskellDepends = [ base bytestring chell vector ];
        homepage = "https://john-millikin.com/software/haskell-re2/";
@@ -110178,7 +110512,7 @@ self: {
      mkDerivation {
        pname = "react-haskell";
        version = "2.0.1";
-       sha256 = "0kjbicrvriliy50gy82b7rsrfk5p3iv20wwnhiaq9i16mbh2zj8j";
+       sha256 = "12c92fe0aa26c4845584967320761cb74c97753e4b20ff40f191c6bc338b4b4e";
        libraryHaskellDepends = [
          aeson base deepseq lens-family monads-tf text transformers
          unordered-containers void
@@ -110193,7 +110527,7 @@ self: {
      mkDerivation {
        pname = "reaction-logic";
        version = "2010.11.17";
-       sha256 = "0g1lbr0lsx71ddmd64q9lxx3gj63ncc7nqd12l4739wq495q57r0";
+       sha256 = "209f824b2298a7710815a1617b18b3c3c8377aa70913d36a6be1744d415e343c";
        isLibrary = true;
        isExecutable = true;
        libraryHaskellDepends = [ base mtl QuickCheck ];
@@ -110211,7 +110545,7 @@ self: {
      mkDerivation {
        pname = "reactive";
        version = "0.11.5";
-       sha256 = "1axhgggl1g8yjdvp817bnkj4xc23scc3i2k224k43942255sf71j";
+       sha256 = "321ca74b1182a4412611628a3818d343b04ee4b4eb047477931ebd40df7bb0ab";
        libraryHaskellDepends = [
          base category-extras checkers old-time QuickCheck random Stream
          TypeCompose unamb vector-space
@@ -110227,7 +110561,7 @@ self: {
      mkDerivation {
        pname = "reactive-bacon";
        version = "0.4.1";
-       sha256 = "0cic01yikwgalbprz8y0fs7i7c0pynxl7aivsfjgsl75wdpjsj3m";
+       sha256 = "75482d6fe3e550fda4d33baa43bbf517b0138f76c0a39fefa2eaf1197d002c32";
        libraryHaskellDepends = [ base old-time stm ];
        testHaskellDepends = [ base containers HUnit old-time stm ];
        homepage = "http://github.com/raimohanska/reactive-bacon";
@@ -110245,7 +110579,7 @@ self: {
      mkDerivation {
        pname = "reactive-balsa";
        version = "0.1.1";
-       sha256 = "14k65rjvyxwb4psa53qcz89jllabqv76vh4xwx2k6k5ssl6qfr3n";
+       sha256 = "7664870dd5ba4c3345e79dc06dcec64b512a13fa0c8fa2f4258b77bf652e6692";
        libraryHaskellDepends = [
          alsa-core alsa-seq base containers data-accessor
          data-accessor-transformers event-list extensible-exceptions midi
@@ -110267,7 +110601,7 @@ self: {
      mkDerivation {
        pname = "reactive-banana";
        version = "0.8.1.2";
-       sha256 = "1ak3i0r7y9d5pyb4q6jag804bkgiqj3az7cckj50ffvra2v37nga";
+       sha256 = "ead933b650793b078a9c8c9daf86c4f1cd45007a4a1a4c96bfa5257f328863aa";
        libraryHaskellDepends = [
          base containers hashable psqueues transformers unordered-containers
          vault
@@ -110288,7 +110622,7 @@ self: {
      mkDerivation {
        pname = "reactive-banana-sdl";
        version = "0.2.0";
-       sha256 = "067g8v7xhll416f47prifv0l2i8vr6aywbahhci8kwci75a1al6m";
+       sha256 = "d55015543991f1892283502dee95c91b4541c17631df439c098452d8cf46ef18";
        libraryHaskellDepends = [
          base data-lens data-lens-template reactive-banana SDL SDL-image
          SDL-ttf
@@ -110304,7 +110638,7 @@ self: {
      mkDerivation {
        pname = "reactive-banana-threepenny";
        version = "0.7.1.3";
-       sha256 = "1fb0bq7rcxsnga2hxh94h2rpp4kjh383z06qgk36m49pyvnbnl9a";
+       sha256 = "2a51bbecf637916ac67cd8803fd08072927bb38024c10e857a5677960f5e60b9";
        isLibrary = true;
        isExecutable = true;
        libraryHaskellDepends = [ base reactive-banana threepenny-gui ];
@@ -110320,7 +110654,7 @@ self: {
      mkDerivation {
        pname = "reactive-banana-wx";
        version = "0.8.0.4";
-       sha256 = "1r000r9svkf1sqxhg5mpawg9a7dkfndsyz242sbmfaxf94nrrscg";
+       sha256 = "8fe99c2d49ae2b579716447caf9b75b31d951e57b796073bd6c1cdad530600e4";
        configureFlags = [ "-f-buildexamples" ];
        isLibrary = true;
        isExecutable = true;
@@ -110339,7 +110673,7 @@ self: {
      mkDerivation {
        pname = "reactive-fieldtrip";
        version = "0.0.9";
-       sha256 = "092bxjnhbcyqlij8jc014c56k67ncp5wjm8kmwvn8argfplyscxg";
+       sha256 = "af33ede9752f2b6437af1355c9cb65f698690a2301308964a4d8b305adec4b24";
        libraryHaskellDepends = [
          base FieldTrip InfixApplicative reactive reactive-glut unamb
          vector-space
@@ -110357,7 +110691,7 @@ self: {
      mkDerivation {
        pname = "reactive-glut";
        version = "0.1.10";
-       sha256 = "164ivzgrnvqvx7r1jagsng9m47ql0jkayzahhcvs8wd78ksbbsfh";
+       sha256 = "d0e9b5f444a771a43783507dafa604141f52d3b3fa2919f2e91b6f9bdfdf9198";
        libraryHaskellDepends = [
          base GLUT old-time OpenGL reactive vector-space
        ];
@@ -110372,7 +110706,7 @@ self: {
      mkDerivation {
        pname = "reactive-haskell";
        version = "0.0.1";
-       sha256 = "115zjaymcx1dm7lwdqjq810j664a2kj8phrvjkhfkdsl95srqc85";
+       sha256 = "05319c754954b7e9e0943bc38be4148a1823414058e2c6e9a92d7456bd92bf84";
        libraryHaskellDepends = [ base ];
        description = "minimal fork of io-reactive";
        license = stdenv.lib.licenses.bsd3;
@@ -110383,7 +110717,7 @@ self: {
      mkDerivation {
        pname = "reactive-io";
        version = "0.1";
-       sha256 = "0s7a29cfzb2j5xvqykx1n5naci2np36zjs3qyq0i4yzjf3qprr63";
+       sha256 = "c3e47cf170f27b1201f67868f9cdb85644a66cb1a14f8f772f52acef5812ea68";
        libraryHaskellDepends = [ base transformers ];
        description = "IO-oriented FRP library";
        license = stdenv.lib.licenses.mit;
@@ -110394,7 +110728,7 @@ self: {
      mkDerivation {
        pname = "reactive-thread";
        version = "0.3.2.1";
-       sha256 = "1mydwb3p2c4xm7zfv7cwcyscq1wdcvs2az743s3j8gl8ggc1zs50";
+       sha256 = "a0e81fd87b883e24871ee47c25f4668d07ccb4679c9dedfea99d3071c7e2cdd7";
        isLibrary = true;
        isExecutable = true;
        libraryHaskellDepends = [ base monad-parallel stm transformers ];
@@ -110415,7 +110749,7 @@ self: {
      mkDerivation {
        pname = "reactor";
        version = "0.1.3";
-       sha256 = "0g57vkq8cgigy6383p5jk6bbp3l1vcihryz8sjwvr8hs4y96642f";
+       sha256 = "4e106392271aa2bcb9d4e8fb0c23db818ebb9699b2dc8186f12f3e86f0dca73c";
        libraryHaskellDepends = [
          array base bits-atomic comonad contravariant mtl semigroupoids
          transformers
@@ -110432,7 +110766,7 @@ self: {
      mkDerivation {
        pname = "read-bounded";
        version = "0.1.1.0";
-       sha256 = "19ynv5vxa5dnphv9kby0nfvq3wn6qpk7n5qv1x22ipkfxnxdw47k";
+       sha256 = "f310debaed6ede28440f1b177be6c5c6f281b7b3c0af9936bcb615d577d9d6a7";
        libraryHaskellDepends = [ base ];
        jailbreak = true;
        homepage = "https://github.com/thomaseding/read-bounded";
@@ -110445,7 +110779,7 @@ self: {
      mkDerivation {
        pname = "readable";
        version = "0.3.1";
-       sha256 = "1ja39cg26wy2fs00gi12x7iq5k8i366pbqi3p916skfa5jnkfc3h";
+       sha256 = "703037ad2cca4d6d42ba23e2758d1911cd82e3e922c4078076c273231e4b43c9";
        libraryHaskellDepends = [ base bytestring text ];
        homepage = "https://github.com/mightybyte/readable";
        description = "Reading from Text and ByteString";
@@ -110457,7 +110791,7 @@ self: {
      mkDerivation {
        pname = "readline";
        version = "1.0.3.0";
-       sha256 = "1sszlx34qa88fad3wlhd4rkb1my1nrpzvyd8vq7dn806j5sf3ff0";
+       sha256 = "c0b9e174910620db0edea8f9fd6fb6c1d7b066260d523e9a7208294c46a75feb";
        libraryHaskellDepends = [ base process ];
        librarySystemDepends = [ ncurses readline ];
        description = "An interface to the GNU readline library";
@@ -110469,7 +110803,7 @@ self: {
      mkDerivation {
        pname = "readline-statevar";
        version = "1.0.1.0";
-       sha256 = "1gfxs3wfdkkarxil2an5l58syrm2vajj0qpshzabzchni32yxic8";
+       sha256 = "88c5eec58816b2bfd487fa6220a5daa266af51a1c52a4163cf6acee6f8d0ddbd";
        libraryHaskellDepends = [ base readline StateVar ];
        jailbreak = true;
        description = "Readline with variables (setX/getY) wrapped in state vars";
@@ -110481,7 +110815,7 @@ self: {
      mkDerivation {
        pname = "readpyc";
        version = "0.2.1";
-       sha256 = "1icb7w3hgfczrr48x48lwvln05yaw3c9bxwrrfxc92h3q73v1rpp";
+       sha256 = "f7e6b0c7c1038ac4bacb99f795d8e0ca1760e9e614918e48ce9fb907073f8bc5";
        isLibrary = false;
        isExecutable = true;
        executableHaskellDepends = [ base bliplib parseargs ];
@@ -110495,7 +110829,7 @@ self: {
      mkDerivation {
        pname = "really-simple-xml-parser";
        version = "0.4.0.0";
-       sha256 = "1qmrfisnvm9a25a9ssg4r466yna69vzbwn7s7f4zql28cndg3syy";
+       sha256 = "deebf19a654850fc893bfa58befe4e46596f0cc9e4699d54112ad56d7574b9e2";
        libraryHaskellDepends = [ base parsec ];
        jailbreak = true;
        homepage = "http://website-ckkashyap.rhcloud.com";
@@ -110509,7 +110843,7 @@ self: {
      mkDerivation {
        pname = "reasonable-lens";
        version = "0.2.1.1";
-       sha256 = "0ic239ikxqsk4qjnyraka3jn4pjmmsgwqyga6zmqlw7z1kpgaxam";
+       sha256 = "5575f5ee0cff708aeb37ea79cc9fae555e62e55053656f252653e33e631a8245";
        libraryHaskellDepends = [ base mtl split template-haskell ];
        homepage = "https://github.com/tokiwoousaka/reasonable-lens";
        description = "Lens implementation. It is more small but adequately.";
@@ -110522,7 +110856,7 @@ self: {
      mkDerivation {
        pname = "reasonable-operational";
        version = "0.1.0.1";
-       sha256 = "18d49rzpygbsd17d9hz79bbgj6jznlx2jzhkw43gzw3rhvklwyh9";
+       sha256 = "097a4ee78679f0ff06e1137e293ab55f1af9d64ae7c3d44e687a3d7f7f4ea4a1";
        revision = "1";
        editedCabalFile = "963ed294ec0f951858022c25b9713b06e65d2a05098068a1183110e298b5c8cf";
        libraryHaskellDepends = [ base ];
@@ -110536,7 +110870,7 @@ self: {
      mkDerivation {
        pname = "recaptcha";
        version = "0.1.0.3";
-       sha256 = "18rqsqzni11nr2cvs7ah9k87w493d92c0gmc0n6fhfq6gay9ia19";
+       sha256 = "29a898bc7a063be88c05ac3ec0446a23117ed04c501dbd99c83684683fd638a3";
        libraryHaskellDepends = [ base HTTP network network-uri xhtml ];
        homepage = "http://github.com/jgm/recaptcha/tree/master";
        description = "Functions for using the reCAPTCHA service in web applications";
@@ -110550,7 +110884,7 @@ self: {
      mkDerivation {
        pname = "record";
        version = "0.4.0.2";
-       sha256 = "18j30j7dppm0lqf9p345bfz65cls15ka6jyflamwgig5h0dzz5mw";
+       sha256 = "bc96ff1b80e5c5c7aba2ce4ba366099ab262be5b858c9b1ca6a0dedb8e0443a2";
        libraryHaskellDepends = [
          base base-prelude basic-lens template-haskell transformers
        ];
@@ -110566,7 +110900,7 @@ self: {
      mkDerivation {
        pname = "record-aeson";
        version = "0.1.0.0";
-       sha256 = "023g63y478k7mq8kk5xcxa3civs3hdhlvdb0qh3amvvybpj3g4av";
+       sha256 = "5b9137e45d7eefaa06c460b54d618343efc886eaac973911ae67a243fc306f08";
        libraryHaskellDepends = [
          aeson base base-prelude record template-haskell
        ];
@@ -110586,7 +110920,7 @@ self: {
      mkDerivation {
        pname = "record-gl";
        version = "0.1.0.0";
-       sha256 = "0z0qwnzayarwlamig9g4zngq3mcddhl3pgalir811lxf3a3g1dqq";
+       sha256 = "18b7f0861aaed310508e54bd3b286c8dd5819ffde4a517aba23c2bafbee5187c";
        revision = "1";
        editedCabalFile = "6d2017f9112690ce717a1bb7dad9d2d4272b01b4bce8ee3ae79247f97f277d85";
        libraryHaskellDepends = [
@@ -110609,7 +110943,7 @@ self: {
      mkDerivation {
        pname = "record-preprocessor";
        version = "0.1.0.3";
-       sha256 = "0vfij2kj4lg9pvyrcq3x33vnibq441fc80cpd67c9ik9axgf0r3y";
+       sha256 = "7e64e05e5769c6c48e699701c45c2004af68f7187d6096fdbee95122a790d16d";
        isLibrary = true;
        isExecutable = true;
        executableHaskellDepends = [
@@ -110629,7 +110963,7 @@ self: {
      mkDerivation {
        pname = "record-syntax";
        version = "0.1.0.2";
-       sha256 = "177zy0j05yvpalflja5wpp0a45nplhpa9vq8ssfxw2nw9ydam637";
+       sha256 = "6798aa9a4fdc0ade9dd608efa42ea4d716a2c0bdbc28491d5577fb0224f0ff9c";
        libraryHaskellDepends = [
          base base-prelude conversion conversion-text haskell-src-exts
          parsec record template-haskell text transformers
@@ -110648,7 +110982,7 @@ self: {
      mkDerivation {
        pname = "records";
        version = "0.1.1.6";
-       sha256 = "1nzqqbqwgsr066ykmanyzmlv5nzdzpkkcla0lg8klyw6ck9ddk69";
+       sha256 = "c9ccd6d264867b3ad1a3405136e7fdeddbb269fddeaa3abd3120ebc7f1c2f8db";
        libraryHaskellDepends = [ base kinds type-functions ];
        homepage = "http://darcs.wolfgang.jeltsch.info/haskell/records";
        description = "A flexible record system";
@@ -110663,7 +110997,7 @@ self: {
      mkDerivation {
        pname = "records-th";
        version = "0.1.1.0";
-       sha256 = "1m6v52kmh1clcgah07jjjxvsfpbp6z8lkdd78wap0v3mqiv8mdcg";
+       sha256 = "8fb58a76c4756c701547a7b549d137775da77797521e00d563940558a728dbd4";
        libraryHaskellDepends = [
          aeson base data-default kinds records template-haskell text
          type-functions unordered-containers
@@ -110680,7 +111014,7 @@ self: {
      mkDerivation {
        pname = "recursion-schemes";
        version = "4.1.2";
-       sha256 = "1z64r20qgf7n5c2529cpwhklb3nkmw01p2llq903dqkplmbi7z9n";
+       sha256 = "36fd1357a577e23640c2948a1b00afd38e4527e4972551042bf6b88781c8c4fc";
        libraryHaskellDepends = [ base comonad free transformers ];
        homepage = "http://github.com/ekmett/recursion-schemes/";
        description = "Generalized bananas, lenses and barbed wire";
@@ -110694,7 +111028,7 @@ self: {
      mkDerivation {
        pname = "recursive-line-count";
        version = "0.1";
-       sha256 = "0iyacn4gb7v6ly0bdci34mrjkjc29mbplqc6bhfv8ksz74aaafyn";
+       sha256 = "d63ba514395f4fb41d5c86617a574d82c929732523b2b680a7669ff58865ca47";
        isLibrary = false;
        isExecutable = true;
        executableHaskellDepends = [
@@ -110713,7 +111047,7 @@ self: {
      mkDerivation {
        pname = "redHandlers";
        version = "0.1";
-       sha256 = "1llb81aqr0jlsajsmy20br5vqd6ap54bk17ipg8z3gmzd0wcf9c9";
+       sha256 = "8925c73868bfbef1d1bbf184b948b9ca34bc4b5e40f8aaa5d254828c55408bd2";
        libraryHaskellDepends = [
          array base bytestring cgi containers haskell98 MaybeT mtl network
          old-time parsec stm unix xhtml
@@ -110732,7 +111066,7 @@ self: {
      mkDerivation {
        pname = "reddit";
        version = "0.1.1.0";
-       sha256 = "1flsawdld5a4bs5crs352zc1r9ag3yn1indbzw7vgs2mmyiavg7k";
+       sha256 = "f3bcada2af55e8b70fffabd918ac1f4fa51cd81765e8cc8a5e4495461b579aba";
        libraryHaskellDepends = [
          aeson api-builder base bytestring data-default http-conduit
          http-types network stm text time transformers unordered-containers
@@ -110755,7 +111089,7 @@ self: {
      mkDerivation {
        pname = "redis";
        version = "0.14.1";
-       sha256 = "02r97k08n9gyrfmbm6qgb8dddivaiprp50hs79a5bnxvvl6vmq9b";
+       sha256 = "2be1ba0dddbbdb55543a1a8272f38d6ac7d61a5a0f9bbaaacbfe258bc03c290b";
        libraryHaskellDepends = [
          base bytestring concurrent-extra containers exceptions mtl network
          old-time utf8-string
@@ -110770,7 +111104,7 @@ self: {
      mkDerivation {
        pname = "redis-hs";
        version = "0.1.2";
-       sha256 = "1irayxwkdksc9v70g7il7zl7pmkrim2admcgjwcm9inyca7618wg";
+       sha256 = "8fa3608e62dec65419978fd5a6448d79d67be83f349e07ce4e4ccf3679f72ac7";
        libraryHaskellDepends = [ base bytestring network utf8-string ];
        homepage = "http://ohloh.net/p/redis-hs";
        description = "A simple Redis library for Haskell";
@@ -110787,7 +111121,7 @@ self: {
      mkDerivation {
        pname = "redis-io";
        version = "0.5.1";
-       sha256 = "13zj3d89drqdfq8202y982l7jp0nc3mmnmhwpxxfap0pb69n2s5m";
+       sha256 = "b568619359175ce57abf1c565beb60165c79a840c90b2010760de796501bf28f";
        libraryHaskellDepends = [
          attoparsec auto-update base bytestring containers exceptions
          iproute monad-control mtl network operational redis-resp
@@ -110811,7 +111145,7 @@ self: {
      mkDerivation {
        pname = "redis-resp";
        version = "0.3.2";
-       sha256 = "07lvgq2l2fahhc9z3hjjjpx3n4rzdxl2l2ww9brxnv23432xpz97";
+       sha256 = "27fddbc520436cdbf34a9c0b2a686f3f133bfa9552c2f11383503941057e9b1e";
        revision = "2";
        editedCabalFile = "6375e871f3ad78efa6e4780c4e5c026fa4694f27e32f3837679fff42f488877f";
        libraryHaskellDepends = [
@@ -110828,7 +111162,7 @@ self: {
      mkDerivation {
        pname = "redis-simple";
        version = "0.1.1";
-       sha256 = "0kzs5lc2y40dzx57k0klz0k9zijhi7mh0awi6rzhzd3h5z1gdr43";
+       sha256 = "83e4f6c22f70b40f7f36912b00eb8950c69f26f87482794aff0d102f182dfa4f";
        libraryHaskellDepends = [ base binary bytestring redis ];
        homepage = "http://github.com/jaspervdj/redis-simple";
        description = "Simple redis bindings for Haskell";
@@ -110842,7 +111176,7 @@ self: {
      mkDerivation {
        pname = "redo";
        version = "0.2.0";
-       sha256 = "18951sri8wix8aazd8hy8g2gzcpxw2x1ihzmn2prlf10zy1jcy4d";
+       sha256 = "8d782683ff20389aafb0f5c318bae0fdb2ffc4431ea2f695423d7214b30e25a1";
        isLibrary = false;
        isExecutable = true;
        executableHaskellDepends = [
@@ -110861,7 +111195,7 @@ self: {
      mkDerivation {
        pname = "reducers";
        version = "3.10.3.2";
-       sha256 = "1zfryrmz5ajahs4d6dj3fzzkqbgdzqz358jvj4rhqiwa61ylhb42";
+       sha256 = "822c487d308a470c33915ba2323efeed2d3cff774336d388864aaaf26bf6d9fd";
        libraryHaskellDepends = [
          array base bytestring containers fingertree hashable semigroupoids
          semigroups text transformers unordered-containers
@@ -110876,7 +111210,7 @@ self: {
      mkDerivation {
        pname = "reenact";
        version = "0.9";
-       sha256 = "19xw0w15ja8h5wxpz4x65vzvc7qxpn3k33p82pa2g3w9l9hlj2xw";
+       sha256 = "bc0b4961a2898f27d415e88e3187bd1d1fb6ff2ea6937f3b2f1029590207bca7";
        libraryHaskellDepends = [
          base hamid HCodecs stm time vector-space
        ];
@@ -110889,7 +111223,7 @@ self: {
      mkDerivation {
        pname = "reexport-crypto-random";
        version = "0.1.0.0";
-       sha256 = "0lraykl190x0cj65z495c11vi4pcg3g8gz1bdgdndf6662lp56x9";
+       sha256 = "a99b72a930c6b866db6b2bfc87de78ec92b8436025915f8c64a08314e8f42a53";
        libraryHaskellDepends = [ base crypto-api ];
        license = stdenv.lib.licenses.gpl2;
      }) {};
@@ -110899,7 +111233,7 @@ self: {
      mkDerivation {
        pname = "ref";
        version = "0.1.1.2";
-       sha256 = "109illgbz4g4a6qavgc4wvyxfjvjhyrxa2gpps67avmr1v90gihr";
+       sha256 = "19c607d20eb96e758cbef709d5b387724bd7fde684bdadb051e491bf1ea53181";
        libraryHaskellDepends = [ base ghc-prim ];
        jailbreak = true;
        homepage = "https://bitbucket.org/carter/ref";
@@ -110913,7 +111247,7 @@ self: {
      mkDerivation {
        pname = "ref-fd";
        version = "0.4";
-       sha256 = "1r8cj6v798chr3bp7x6qvsiz04xsj2iicpa6824b4fzzy5ixkj96";
+       sha256 = "26c9d963f1ff3bb28840465d16a390ba13f0a3ded8f473d7c890a174b6910ce5";
        libraryHaskellDepends = [ base stm transformers ];
        homepage = "http://www.cs.drexel.edu/~mainland/";
        description = "A type class for monads with references using functional dependencies";
@@ -110925,7 +111259,7 @@ self: {
      mkDerivation {
        pname = "ref-mtl";
        version = "0.3";
-       sha256 = "0wijkaf3qyp6qjz0cwyhb89z5jrcz792hx8m9a43xrp7v2f84080";
+       sha256 = "0001829cd8e7e63e884a157528d2f92ccbf2135ad07306bec4e67a3c9c9a3272";
        libraryHaskellDepends = [ base mtl stm transformers ];
        jailbreak = true;
        homepage = "http://www.eecs.harvard.edu/~mainland/";
@@ -110938,7 +111272,7 @@ self: {
      mkDerivation {
        pname = "ref-tf";
        version = "0.4";
-       sha256 = "049xpdn14py3r7hs4ikqdz7jgfsxi6vdsxgq0jfz69gzg4binc25";
+       sha256 = "45301b1779ff25f39d04f875ddb6895dbb27cf6f7846a2e1c9c35f126cbb3d11";
        libraryHaskellDepends = [ base stm transformers ];
        homepage = "http://www.cs.drexel.edu/~mainland/";
        description = "A type class for monads with references using type families";
@@ -110950,7 +111284,7 @@ self: {
      mkDerivation {
        pname = "refact";
        version = "0.3.0.1";
-       sha256 = "0nmlhx35g3kb5if6qnkmabgi5dj4b446vkd1n5df1vsiyaf65w11";
+       sha256 = "21f0629cf251efe05ab1a1cd6d085944b612df52755a6c5c2c6b8e574687b45a";
        libraryHaskellDepends = [ base ];
        description = "Specify refactorings to perform with apply-refact";
        license = stdenv.lib.licenses.bsd3;
@@ -110964,7 +111298,7 @@ self: {
      mkDerivation {
        pname = "refcount";
        version = "0.1.2";
-       sha256 = "1h1gprc4c784pf3wi2ri2hxk7pbh9y8bqc0xcryjcyjk3519ig16";
+       sha256 = "26bc984219537a267d661d30bc904f70dd333b14318bc887bb041d4658be2fc0";
        libraryHaskellDepends = [
          base hashable QuickCheck unordered-containers
        ];
@@ -110984,7 +111318,7 @@ self: {
      mkDerivation {
        pname = "reference";
        version = "0.1";
-       sha256 = "1gqbbiwhx5wq1g73m3apwyrrpapqzimincmw2b64fpkkykq66dq1";
+       sha256 = "013763f0f4735e47cc12bc321b6bfcf8aa9bb3e7578d3ace0b98970e795c0bbf";
        libraryHaskellDepends = [ base stm ];
        description = "A class for references in Haskell";
        license = stdenv.lib.licenses.mit;
@@ -110998,7 +111332,7 @@ self: {
      mkDerivation {
        pname = "references";
        version = "0.3.0.0";
-       sha256 = "0rw3r9sz39f3pw2zxq7n9ca9jccfrj6lnjs3frimh0xrmdi9bmjk";
+       sha256 = "53d69562abb903586376434b4b8dcc8e3199144bf6e0fe05bfc3a5f175ca8367";
        libraryHaskellDepends = [
          array base containers directory either filepath instance-control
          mtl template-haskell text transformers
@@ -111017,7 +111351,7 @@ self: {
      mkDerivation {
        pname = "refh";
        version = "0.1.1";
-       sha256 = "1fhvn4cjfq92hi422mcdq4xwb405cc4pvlax0bqvyw3bg9ngqz9m";
+       sha256 = "357dfc6c7a6b70bff1025dd17d09630590c53bc18d5521488422612719b11bba";
        isLibrary = false;
        isExecutable = true;
        executableHaskellDepends = [
@@ -111035,7 +111369,7 @@ self: {
      mkDerivation {
        pname = "refined";
        version = "0.1.0.0";
-       sha256 = "0072zc4x8v6b8vdfgxnm1k6hbhzvf1m4cdb65v8df3qngb603r5n";
+       sha256 = "b6e401cc7a160fd7d02e6635466a70fbc305cd0cd5f6e7da46cb6cd409fbe200";
        libraryHaskellDepends = [ base base-prelude template-haskell ];
        homepage = "https://github.com/nikita-volkov/refined";
        description = "Refinement types with static and runtime checking";
@@ -111047,7 +111381,7 @@ self: {
      mkDerivation {
        pname = "reflection";
        version = "2";
-       sha256 = "1hlrji6wyqr892a78px7wilhywyiqdfdmnr7zp4c641qks4rw6gf";
+       sha256 = "ee199e899e3810c3c8fd27dbda5cc3d1730f69e4a75f7494482863cf4d9499c2";
        libraryHaskellDepends = [ base template-haskell ];
        homepage = "http://github.com/ekmett/reflection";
        description = "Reifies arbitrary terms into types that can be reflected back into terms";
@@ -111060,7 +111394,7 @@ self: {
      mkDerivation {
        pname = "reflection-extras";
        version = "0.1.1.0";
-       sha256 = "1cnqd8hrcvjvcdrida0q3dxkkmp36qsfqhv0a5zr94b1y5zfrj4k";
+       sha256 = "93c8ec7ef16191947f516043ec3436e3d6397b1b18a81673635b6e96216ad8b2";
        libraryHaskellDepends = [
          aeson base constraints lens reflection tagged
        ];
@@ -111076,7 +111410,7 @@ self: {
      mkDerivation {
        pname = "reflection-without-remorse";
        version = "0.9.5";
-       sha256 = "1iz4k42hc8f11a6kg2db847zmq5qpfiwns1448s62jswc2xm0x0r";
+       sha256 = "197450bb605c4b6134222468cba3bbb8e0fa0f41ab89378d0ac121060599e4c7";
        libraryHaskellDepends = [ base type-aligned ];
        homepage = "https://github.com/atzeus/reflection-without-remorse";
        description = "Efficient free and operational monads";
@@ -111092,7 +111426,7 @@ self: {
      mkDerivation {
        pname = "reflex";
        version = "0.3";
-       sha256 = "1aw4pz0y0rpf7klsb232q0zi4zqcpkwrw0s3zrkq5iyhzaswfnyd";
+       sha256 = "cd5bc7b5fad0c78267fe43039ef9bc0c7f123fc06288a5e93cee66e0c1bf84ab";
        libraryHaskellDepends = [
          base containers dependent-map dependent-sum exception-transformers
          mtl primitive ref-tf semigroups template-haskell these transformers
@@ -111117,7 +111451,7 @@ self: {
      mkDerivation {
        pname = "reflex-dom";
        version = "0.2";
-       sha256 = "1pc6mz9c6nr4s5b2mhlyxjzzffh85cv1bgvyycmq04s6dmg0ndgx";
+       sha256 = "fd350b5e6d4613802bf37ebf15362b083af7bfec9ec22a56d1245bc3d2af86dd";
        libraryHaskellDepends = [
          aeson base bifunctors bytestring containers data-default
          dependent-map dependent-sum dependent-sum-template directory
@@ -111138,7 +111472,7 @@ self: {
      mkDerivation {
        pname = "reflex-dom-contrib";
        version = "0.1";
-       sha256 = "1xqw1i5wldfamjyav7fbw3001hdnbj4x3phlr216ybw3ndxrjklc";
+       sha256 = "8c4e997bb3832f6f82c814ded1895cb6c100c0e0cb9dadbcacca35ca4b0c1cf7";
        libraryHaskellDepends = [
          aeson base bifunctors bytestring containers data-default ghcjs-base
          ghcjs-dom http-types lens mtl readable reflex reflex-dom
@@ -111157,7 +111491,7 @@ self: {
      mkDerivation {
        pname = "reflex-gloss";
        version = "0.1.0.2";
-       sha256 = "18sbqryf6kxadgbvr6nh0f07897fq9fjj0h2w07xcdpp1ygg1nfg";
+       sha256 = "cfd9f09e0ff736d60fe00202295dc2ee24748003d09abcd76baa4fe37cc64ba3";
        libraryHaskellDepends = [
          base dependent-sum gloss reflex transformers
        ];
@@ -111171,7 +111505,7 @@ self: {
      mkDerivation {
        pname = "reform";
        version = "0.2.7";
-       sha256 = "0jjbcc88ffv6nqj0jbgb54bin0k5hh4w1i44xh3vdv00s7aj3abm";
+       sha256 = "75a921d5d100ecb607ec84c4c0098465021b1729eb2d0924b6663b8710634b4a";
        libraryHaskellDepends = [ base containers mtl text ];
        homepage = "http://www.happstack.com/";
        description = "reform is an HTML form generation and validation library";
@@ -111183,7 +111517,7 @@ self: {
      mkDerivation {
        pname = "reform-blaze";
        version = "0.2.4";
-       sha256 = "124hvgjhb2x6769qnwwjw30qmramh54pmggpqmj0dc8m473psfjy";
+       sha256 = "5e3a7dc72115b10664c5f7bd7a498155e58ac1e092738b9339a68b05e5db9088";
        libraryHaskellDepends = [
          base blaze-html blaze-markup reform text
        ];
@@ -111197,7 +111531,7 @@ self: {
      mkDerivation {
        pname = "reform-hamlet";
        version = "0.0.4";
-       sha256 = "1f8rh9wiax6g7kh1j0j2zmqr7n1ll9ijn2xqp1shhsq8vp30f8fg";
+       sha256 = "cf2107c6dd086b0875b8b80b2b63a234d89371fd420219e03ccf7415798219b9";
        libraryHaskellDepends = [
          base blaze-markup reform shakespeare text
        ];
@@ -111214,7 +111548,7 @@ self: {
      mkDerivation {
        pname = "reform-happstack";
        version = "0.2.5";
-       sha256 = "12asmp1bklk33rpbhwhpbvmnkssjll92l47qxywibnpdf0zc6xsc";
+       sha256 = "4c77c33e70edda15b9eff8102a12a552eb69eb5e1772b86e1e63d2b9c2ad5a89";
        libraryHaskellDepends = [
          base bytestring happstack-server mtl random reform text utf8-string
        ];
@@ -111228,7 +111562,7 @@ self: {
      mkDerivation {
        pname = "reform-hsp";
        version = "0.2.6";
-       sha256 = "0aigsrax7s5ys0w2kd52jqi3453q81f4yp6c1s84a383yqndyq1j";
+       sha256 = "3260df2cf6030d45900ecc5c4f5c407814322296a2b42938d0bee8d355d62f2a";
        libraryHaskellDepends = [ base hsp hsx2hs reform text ];
        homepage = "http://www.happstack.com/";
        description = "Add support for using HSP with Reform";
@@ -111242,7 +111576,7 @@ self: {
      mkDerivation {
        pname = "regex-applicative";
        version = "0.3.2.1";
-       sha256 = "19swnf6mqjxg7d1wxr4h9drjm51af4hj4ax712n8702xfvfb4jmz";
+       sha256 = "bf4ab2dc765d8083ac08a72b2221712a942a734b90e4ce433baf4b5c8db35ca7";
        libraryHaskellDepends = [ base containers transformers ];
        testHaskellDepends = [
          base containers smallcheck tasty tasty-hunit tasty-smallcheck
@@ -111253,12 +111587,24 @@ self: {
        license = stdenv.lib.licenses.mit;
      }) {};
 
+  "regex-applicative-text" = callPackage
+    ({ mkDerivation, base, regex-applicative, text }:
+     mkDerivation {
+       pname = "regex-applicative-text";
+       version = "0.1.0.0";
+       sha256 = "6f01deddcbba44441b12f7b4048e143f938a65e0c518f0c211e530a661a632d7";
+       libraryHaskellDepends = [ base regex-applicative text ];
+       homepage = "https://github.com/phadej/regex-applicative-text#readme";
+       description = "regex-applicative on text";
+       license = stdenv.lib.licenses.bsd3;
+     }) {};
+
   "regex-base" = callPackage
     ({ mkDerivation, array, base, bytestring, containers, mtl }:
      mkDerivation {
        pname = "regex-base";
        version = "0.93.2";
-       sha256 = "0y1j4h2pg12c853nzmczs263di7xkkmlnsq5dlp5wgbgl49mgp10";
+       sha256 = "20dc5713a16f3d5e2e6d056b4beb9cfdc4368cd09fd56f47414c847705243278";
        libraryHaskellDepends = [ array base bytestring containers mtl ];
        homepage = "http://sourceforge.net/projects/lazy-regex";
        description = "Replaces/Enhances Text.Regex";
@@ -111270,7 +111616,7 @@ self: {
      mkDerivation {
        pname = "regex-compat";
        version = "0.95.1";
-       sha256 = "0fwmima3f04p9y4h3c23493n1xj629ia2dxaisqm6rynljjv2z6m";
+       sha256 = "d57cb1a5a4d66753b18eaa37a1621246f660472243b001894f970037548d953b";
        libraryHaskellDepends = [ array base regex-base regex-posix ];
        homepage = "http://sourceforge.net/projects/lazy-regex";
        description = "Replaces/Enhances Text.Regex";
@@ -111282,7 +111628,7 @@ self: {
      mkDerivation {
        pname = "regex-compat-tdfa";
        version = "0.95.1.4";
-       sha256 = "1p90fn90yhp7fvljjdqjp41cszidcfz4pw7fwvzyx4739b98x8sg";
+       sha256 = "4fa38ed24ae390eeffe6eef04bbe632d7ecd02b9123729e976e7420f927520dd";
        libraryHaskellDepends = [ array base regex-base regex-tdfa ];
        homepage = "http://hub.darcs.net/shelarcy/regex-compat-tdfa";
        description = "Unicode Support version of Text.Regex, using regex-tdfa";
@@ -111297,7 +111643,7 @@ self: {
      mkDerivation {
        pname = "regex-deriv";
        version = "0.0.4";
-       sha256 = "0anj0az7q3fzdxknc83vci3nm5w0wj54w77xz2jphcbmn9ix9s4c";
+       sha256 = "8ce8d463b2753178a5f8fd1c4e8ae480976a47647b2066676fdf0d7cbe02d22a";
        libraryHaskellDepends = [
          base bitset bytestring containers deepseq dequeue ghc-prim hashable
          hashtables mtl parallel parsec regex-base
@@ -111313,7 +111659,7 @@ self: {
      mkDerivation {
        pname = "regex-dfa";
        version = "0.91";
-       sha256 = "1f846d86wg7yha29qinchpi3r5gv9795f384pqahbyc13wfky7dp";
+       sha256 = "b71d3f1d1f81f90515be040d57d249fb953ce285cc469c8482fe3c6e503304b9";
        libraryHaskellDepends = [ base mtl parsec regex-base ];
        homepage = "http://sourceforge.net/projects/lazy-regex";
        description = "Replaces/Enhances Text.Regex";
@@ -111328,7 +111674,7 @@ self: {
      mkDerivation {
        pname = "regex-easy";
        version = "0.1.0.0";
-       sha256 = "1062h3zd0bxak7rins7kk8n95ic04z5l9zqhg22h0iq5csapllf9";
+       sha256 = "c9517a9566054700857810ff44cb2780c5922c9af3681bf399aa2fd0fe80c280";
        libraryHaskellDepends = [
          array base bytestring regex-pcre string-conversions
        ];
@@ -111344,7 +111690,7 @@ self: {
      mkDerivation {
        pname = "regex-genex";
        version = "0.6.2";
-       sha256 = "1816zmlh1bmxykvjp1q2viqckjvcj2g9b11ggz31ja5xi2mwc9iq";
+       sha256 = "3826c6ab88bd2819c67f2f84959e906ccbc970dc02872bf7f4bdae0069fd26a0";
        isLibrary = true;
        isExecutable = true;
        libraryHaskellDepends = [
@@ -111363,7 +111709,7 @@ self: {
      mkDerivation {
        pname = "regex-parsec";
        version = "0.90";
-       sha256 = "0zf5cr10mxlxxd8fp4q4ix6ibxc5xx3ml3k043kx28f9vfdh2xnx";
+       sha256 = "dd76019bdbc921d1e720600e5a47ef85f5154d8f0493eb50eb9df60a4266c57d";
        libraryHaskellDepends = [ base parsec regex-base ];
        homepage = "http://sourceforge.net/projects/lazy-regex";
        description = "Replaces/Enhances Text.Regex";
@@ -111378,7 +111724,7 @@ self: {
      mkDerivation {
        pname = "regex-pcre";
        version = "0.94.4";
-       sha256 = "1h16w994g9s62iwkdqa7bar2n9cfixmkzz2rm8svm960qr57valf";
+       sha256 = "8eaa7d4ac6c0a4ba35aa59fc3f6b8f8e252bb25a47e136791446a74752e226c0";
        libraryHaskellDepends = [
          array base bytestring containers regex-base
        ];
@@ -111393,7 +111739,7 @@ self: {
      mkDerivation {
        pname = "regex-pcre-builtin";
        version = "0.94.4.8.8.35";
-       sha256 = "0y7as9wqlkykpipka2cfdhmcnin345q01pp0wsva8fwmvsavdl8b";
+       sha256 = "0bd1b695de953ba4b6e6e0de007021c346cb2a6c8e09356fbcd34f8a79d2ea78";
        libraryHaskellDepends = [
          array base bytestring containers regex-base
        ];
@@ -111409,7 +111755,7 @@ self: {
      mkDerivation {
        pname = "regex-pderiv";
        version = "0.1.3";
-       sha256 = "1jh7ksv3cgsjd0f51yyrs2kvji1wyi9qk2ysavh3w34nkgyxmg55";
+       sha256 = "a5bcdafd9b960c3ee056da8b8953f43c44b9a7d0d9fb501c68523f36b69e07ca";
        libraryHaskellDepends = [
          base bitset bytestring containers deepseq ghc-prim mtl parallel
          parsec regex-base
@@ -111425,7 +111771,7 @@ self: {
      mkDerivation {
        pname = "regex-posix";
        version = "0.95.2";
-       sha256 = "0gkhzhj8nvfn1ija31c7xnl6p0gadwii9ihyp219ck2arlhrj0an";
+       sha256 = "56019921cd4a4c9682b81ec614236fea816ba8ed8785a1640cd66d8b24fc703e";
        libraryHaskellDepends = [
          array base bytestring containers regex-base
        ];
@@ -111441,7 +111787,7 @@ self: {
      mkDerivation {
        pname = "regex-posix-unittest";
        version = "1.1";
-       sha256 = "0kcxsdn5lgmpfrkpkygr54jrnjqd93b12shb00n6j00rg7p755vx";
+       sha256 = "7d9772ee791900692c000b6a11d6480d4b9b2529f9f9796776b73e5a6cd39d4d";
        isLibrary = false;
        isExecutable = true;
        executableHaskellDepends = [
@@ -111458,7 +111804,7 @@ self: {
      mkDerivation {
        pname = "regex-tdfa";
        version = "1.2.0";
-       sha256 = "00gl9sx3hzd83lp38jlcj7wvzrda8kww7njwlm1way73m8aar0pw";
+       sha256 = "fc82ac14aae378c543a55cdac3f944aae5bff9918c4a342e1da87d38ba4ef401";
        revision = "1";
        editedCabalFile = "5489b69b9f0e8e181ee5134fd500bb0e2b4f914234c5223c59186035fb50478e";
        libraryHaskellDepends = [
@@ -111476,7 +111822,7 @@ self: {
      mkDerivation {
        pname = "regex-tdfa-rc";
        version = "1.1.8.3";
-       sha256 = "1vi11i23gkkjg6193ak90g55akj69bhahy542frkwb68haky4pp3";
+       sha256 = "e35ee2a782c82c3eb313a478a8e04a464e55ca0369aa91827972ce37440c21ee";
        libraryHaskellDepends = [
          array base bytestring containers ghc-prim mtl parsec regex-base
        ];
@@ -111490,7 +111836,7 @@ self: {
      mkDerivation {
        pname = "regex-tdfa-text";
        version = "1.0.0.2";
-       sha256 = "1p17xv3j2xd74iilyqwlqhkmyp26asq4k1pb0h2f0wdqqfr87bfd";
+       sha256 = "cdad83b2c3b871e00404eb8649b056465c5f27c494634f6324a77521c7ee27dc";
        revision = "2";
        editedCabalFile = "4b0e54f79540143c88adb071ea8e0aa3734a625db026a6a44ca2ef45b870b07c";
        libraryHaskellDepends = [ array base regex-base regex-tdfa text ];
@@ -111505,7 +111851,7 @@ self: {
      mkDerivation {
        pname = "regex-tdfa-unittest";
        version = "1.1";
-       sha256 = "1b9cca3l46qxvc5ck3z27dg6w1888pabkk0q752bzjqr3fc4nidc";
+       sha256 = "ac454b981b19cbbf443918ccb9d44508056e5e3be28fc90adb1d1b4287622cad";
        isLibrary = false;
        isExecutable = true;
        executableHaskellDepends = [
@@ -111522,7 +111868,7 @@ self: {
      mkDerivation {
        pname = "regex-tdfa-utf8";
        version = "1.0";
-       sha256 = "0i5di03v9dsvvhz8mdfx5qba8zcpim0fpx1cjg9gvz4gh0yhqf4k";
+       sha256 = "93380c3d808ffcfdd2932cf4eb408d977da4162eddb58a3edc5bb7b40788ad44";
        libraryHaskellDepends = [
          array base bytestring regex-base regex-tdfa utf8-string
        ];
@@ -111536,7 +111882,7 @@ self: {
      mkDerivation {
        pname = "regex-tre";
        version = "0.91";
-       sha256 = "1b7x0y8q1fvipnzh06by48f8l9l5ypm6yblpl35fzf641z3m9b7j";
+       sha256 = "f2ac54c70fc4b8efcaa0972e6feaf585268a1c227e1900bfbd71bb809107fdac";
        libraryHaskellDepends = [ base regex-base ];
        librarySystemDepends = [ tre ];
        homepage = "http://sourceforge.net/projects/lazy-regex";
@@ -111550,7 +111896,7 @@ self: {
      mkDerivation {
        pname = "regex-xmlschema";
        version = "0.1.5";
-       sha256 = "1dmhvnz6sj80kdnm2v7n0lvx8g9arhf9pqqzkn0rwzfhr2by0ss4";
+       sha256 = "446be097c8d07d9e819d1fe39b1ccc2a3dd43705f66c516d9b00496dbeddb0b6";
        libraryHaskellDepends = [ base haskell98 parsec ];
        jailbreak = true;
        homepage = "http://www.haskell.org/haskellwiki/Regular_expressions_for_XML_Schema";
@@ -111566,7 +111912,7 @@ self: {
      mkDerivation {
        pname = "regexchar";
        version = "0.9.0.12";
-       sha256 = "1f1yb3h43pr38c7j3zs2jmph33arc828q1hbsmlz2xh4krdrc0vc";
+       sha256 = "6c03965b9e0476f169d50b068c0462598d016f9542ff210f4323df41e0583eb8";
        isLibrary = true;
        isExecutable = true;
        libraryHaskellDepends = [
@@ -111585,7 +111931,7 @@ self: {
      mkDerivation {
        pname = "regexdot";
        version = "0.11.1.1";
-       sha256 = "1nrbqlxlkppi6q7w7ypq47saskxdx9a127dcwkl2azzz5082yf8j";
+       sha256 = "12392f1028ff7f25e8e4ac1d1154eaad4fadf421f8fac30f36f1de493bc52bdb";
        libraryHaskellDepends = [ base deepseq parallel parsec toolshed ];
        homepage = "http://functionalley.eu";
        description = "A polymorphic, POSIX, extended regex-engine";
@@ -111599,7 +111945,7 @@ self: {
      mkDerivation {
        pname = "regexp-tries";
        version = "0.2";
-       sha256 = "16spdq22dsblksvpd85cm6bmjd9053znphw6na1iy9pkmc491v1l";
+       sha256 = "34ec9008abf3261f83b286c36bff2820355997a9aca076b79e74e926046e579b";
        libraryHaskellDepends = [
          base containers derive-trie template-haskell weighted-regexp
        ];
@@ -111615,7 +111961,7 @@ self: {
      mkDerivation {
        pname = "regexpr";
        version = "0.5.4";
-       sha256 = "0136wp6hrnmj6pbdhp3a131dzz8bp1pbd92bpagpv1r6gwj16y5z";
+       sha256 = "bf7813247f26877d9fba4ba4b66eb80bfddfc2086a5cd8d635b2da0ccde56604";
        libraryHaskellDepends = [ base HUnit mtl mtlparse ];
        homepage = "http://homepage3.nifty.com/salamander/second/projects/regexpr/";
        description = "regular expression like Perl/Ruby in Haskell";
@@ -111627,7 +111973,7 @@ self: {
      mkDerivation {
        pname = "regexpr-symbolic";
        version = "0.5";
-       sha256 = "1cpwvb5mmcaqwy617m6cr25pcb4v4yxwzxng82bcrwkhjfdklsdr";
+       sha256 = "b9693a9b9370f2cc9640cff6cfbb279b2c768bc8ccd4138ce758b15acbdafcb2";
        libraryHaskellDepends = [ base ];
        jailbreak = true;
        homepage = "http://sulzmann.blogspot.com/2008/12/equality-containment-and-intersection.html";
@@ -111640,7 +111986,7 @@ self: {
      mkDerivation {
        pname = "regexqq";
        version = "0.6";
-       sha256 = "10vh4i7q9vf6b716hf2i9pv1dy6vlyrh8bybqh91i704a55m40f3";
+       sha256 = "c301524b51049c1812c4cb2f04b3a7dbf816f64d513868c259c6ed844f247083";
        libraryHaskellDepends = [
          base bytestring pcre-light template-haskell
        ];
@@ -111656,7 +112002,7 @@ self: {
      mkDerivation {
        pname = "regional-pointers";
        version = "0.7";
-       sha256 = "1v71k64is86yc19n96062wl8f382xna1vnm0spcmr9jx6x3wyqv2";
+       sha256 = "6263cf47375da65cd9d5a0da1d94ed020d8728170698645360de201d8999e1ec";
        libraryHaskellDepends = [
          base base-unicode-symbols regions transformers
        ];
@@ -111674,7 +112020,7 @@ self: {
      mkDerivation {
        pname = "regions";
        version = "0.11";
-       sha256 = "1l4wi4vziw0d0vaagbknf8bsvh4irqxls6qbhcg8ngpn62a0fa7p";
+       sha256 = "f728079430f63e8b1e830b1b4d3bce91c0ad177276aea7d4060df0f837899cd0";
        libraryHaskellDepends = [
          base base-unicode-symbols monad-control transformers
        ];
@@ -111692,7 +112038,7 @@ self: {
      mkDerivation {
        pname = "regions-monadsfd";
        version = "0.3.1.3";
-       sha256 = "13xyigw1f92bzppqrl96wbz36j9cwrsaxdb2vkg8sjjvnirly3h9";
+       sha256 = "090e4f73b45b4a8ddedc62b5ae74e62c4933fee226d18ceffd4b2417f88bbe8f";
        libraryHaskellDepends = [
          base-unicode-symbols monads-fd regions transformers
        ];
@@ -111709,7 +112055,7 @@ self: {
      mkDerivation {
        pname = "regions-monadstf";
        version = "0.3.1.7";
-       sha256 = "0r4fr3p2k4k8r1lw6la7h4al068xf5kzb8cgq5864rlkrgf53fxb";
+       sha256 = "abbb51dccb93666250c18fa1f567711d194015814751c369c8689229eec88e64";
        libraryHaskellDepends = [
          base-unicode-symbols monads-tf regions transformers
        ];
@@ -111725,7 +112071,7 @@ self: {
      mkDerivation {
        pname = "regions-mtl";
        version = "0.3.1.7";
-       sha256 = "1s0sr42k1kmwgmrnj5zcan0j9br8xrrm1vdnj6yhliqdfz41ifc0";
+       sha256 = "80b918c8770d470abd91b6ed5073ee28af248155ec1769737dbcce3005c91ae8";
        libraryHaskellDepends = [ base-unicode-symbols mtl regions ];
        jailbreak = true;
        homepage = "https://github.com/basvandijk/regions-mtl/";
@@ -111739,7 +112085,7 @@ self: {
      mkDerivation {
        pname = "regress";
        version = "0.1.1";
-       sha256 = "00b4n4gw5y0mpayb0zlkvz91nfrpbspz22kqhpvdnxbb4zcz7pnj";
+       sha256 = "d2def3d9276b75dbf685780af1af5e373b1bd2df937eb0bcba15f8c21fb16401";
        libraryHaskellDepends = [ ad base vector ];
        homepage = "https://github.com/alpmestan/regress";
        description = "Linear and logistic regression through automatic differentiation";
@@ -111751,7 +112097,7 @@ self: {
      mkDerivation {
        pname = "regular";
        version = "0.3.4.4";
-       sha256 = "112n3j27ac9lzs0lc3q12r6wmpkmfgdalv18h1qklhd5nh4j9wl5";
+       sha256 = "85f22409b4a5413a7180286caada7375deca4d16010f4681fe343175841c5684";
        libraryHaskellDepends = [ base template-haskell ];
        description = "Generic programming library for regular datatypes";
        license = stdenv.lib.licenses.bsd3;
@@ -111762,7 +112108,7 @@ self: {
      mkDerivation {
        pname = "regular-extras";
        version = "0.2.3";
-       sha256 = "0x1sbps0ccwpvf6fx1jnbjxylqsvvfzkkynliip9jyh6gkhm44vx";
+       sha256 = "7d1352e17c067a996e8cd4fa39bfdb5b63eabb5c5686ee8cdb973306f45d3a74";
        libraryHaskellDepends = [ base binary deepseq QuickCheck regular ];
        jailbreak = true;
        description = "Additional functions for regular: arbitrary, coarbitrary, and binary get/put";
@@ -111777,7 +112123,7 @@ self: {
      mkDerivation {
        pname = "regular-web";
        version = "0.1.1";
-       sha256 = "0f4lsly4497p7szibasin27hf2xy5cs8gp87vsbg6mlkk07bvysz";
+       sha256 = "5ffbbd0e989356f396de07dd87342bbe0b078fb051ab15bf3ef724423cd59438";
        libraryHaskellDepends = [
          applicative-extras base fclabels formlets json mtl regular xhtml
        ];
@@ -111793,7 +112139,7 @@ self: {
      mkDerivation {
        pname = "regular-xmlpickler";
        version = "0.2";
-       sha256 = "1qjx4xsidnpr2as3m2ir97ap5vc9cw6a0z332g53ifx9gskjli9f";
+       sha256 = "2e452aa77ea9bb38ca13637ca00c6789ed72d549398a3ab412f9da1675275de2";
        libraryHaskellDepends = [ base hxt regular text ];
        homepage = "http://github.com/silkapp/regular-xmlpickler";
        description = "Generic generation of HXT XmlPickler instances using Regular";
@@ -111805,7 +112151,7 @@ self: {
      mkDerivation {
        pname = "reheat";
        version = "0.1.5";
-       sha256 = "0m6s6r2d39g3qkjylsrhixk9l9sb2jv0ihxwjn7b0wz7585g2bdv";
+       sha256 = "bb2df10a2ae773b08e95bcc308b6144b279a668f306beae5c4e3a5d14436da54";
        isLibrary = false;
        isExecutable = true;
        executableHaskellDepends = [ base directory text vty vty-ui ];
@@ -111823,7 +112169,7 @@ self: {
      mkDerivation {
        pname = "rehoo";
        version = "0.3.1";
-       sha256 = "0pwmz1q2866yj8hxbvha4v1smhppkd3jsrrhbhmbxw137l54ijgf";
+       sha256 = "eec9480a3d23f0be2a5c30672d479bf7c2aac3260aeed52192de182470f8955f";
        isLibrary = false;
        isExecutable = true;
        executableHaskellDepends = [
@@ -111841,7 +112187,7 @@ self: {
      mkDerivation {
        pname = "rei";
        version = "0.3.0.0";
-       sha256 = "03dd4miy0r2mkh603f1p7f93mgxqhfkz8gfk6b4macqcw5pvi3vf";
+       sha256 = "6e8fb86fe10c3355c932d33df4a783b8bf3a923b37b8010c9c5564e06325ad0d";
        isLibrary = false;
        isExecutable = true;
        executableHaskellDepends = [
@@ -111859,7 +112205,7 @@ self: {
      mkDerivation {
        pname = "reified-records";
        version = "0.2.2";
-       sha256 = "0vg05idyiy3havw8rlsky7x4y34mpk6by9500r7rb921xgpdq70a";
+       sha256 = "0a1cdceeeb41a4954f06a024bfccbc950c4ffaf153d38cf85670f8e85b2ce06d";
        libraryHaskellDepends = [ base containers mtl ];
        jailbreak = true;
        homepage = "http://bitbucket.org/jozefg/reified-records";
@@ -111873,7 +112219,7 @@ self: {
      mkDerivation {
        pname = "reify";
        version = "0.1.1";
-       sha256 = "1bl4yv77i8c4w1y5lqr6b8xi1m4ym2phvdjwc9l95rx1vrxkqpk1";
+       sha256 = "615e3c7bdea1e79268625cb60dafa89ed4103b5a26635a7ce084a178cef684ae";
        isLibrary = true;
        isExecutable = true;
        libraryHaskellDepends = [ base ghc ];
@@ -111890,7 +112236,7 @@ self: {
      mkDerivation {
        pname = "reinterpret-cast";
        version = "0.1.0";
-       sha256 = "1r2k2fyfm5lknfdfs282l274bgaxf4j4dikk4hpwchjbj0n64m2n";
+       sha256 = "5654622c904b42c62f2473c64624715dbd458ea00209ed9ab39396eabc1353e4";
        libraryHaskellDepends = [ array base ];
        testHaskellDepends = [ base data-binary-ieee754 hspec loop ];
        homepage = "https://github.com/nh2/reinterpret-cast";
@@ -111903,7 +112249,7 @@ self: {
      mkDerivation {
        pname = "relacion";
        version = "0.1";
-       sha256 = "1jq3ii9j8s7q8fr7ac2pdr2l33jvzsyyq70cjd9q1spqa1v6k976";
+       sha256 = "e6a4697650f8ea8053930c1cecbdfe5b8e41456e573075b243f86824538c03cb";
        libraryHaskellDepends = [ array base containers ];
        homepage = "not available";
        description = "A relation data structure";
@@ -111915,7 +112261,7 @@ self: {
      mkDerivation {
        pname = "relation";
        version = "0.2.1";
-       sha256 = "03h6l8v3ppxbwg9ddgg121yx3i2v4vbcpwrv1vg3mgbw5pwq7x4c";
+       sha256 = "8cf483f92d7cbd3ade0e3bf3cbd6265bc4d17d10e1bdd6d2e3abdf3b36a2060e";
        libraryHaskellDepends = [ array base containers groom ];
        jailbreak = true;
        homepage = "https://www.github.com/d-day/relation/";
@@ -111931,7 +112277,7 @@ self: {
      mkDerivation {
        pname = "relational-postgresql8";
        version = "0.1.0.0";
-       sha256 = "1fmgb7qbcbyr5simy5x6fqnib3v3cq0vsz9i720snszs7a2k1z8f";
+       sha256 = "0efd30853afa6bab8138317dbd0166638f152d76a6175fa32ed92fb6f059afba";
        libraryHaskellDepends = [
          base containers HDBC names-th persistable-record relational-query
          relational-query-HDBC template-haskell time
@@ -111949,7 +112295,7 @@ self: {
      mkDerivation {
        pname = "relational-query";
        version = "0.5.1.1";
-       sha256 = "1gs2ip483paqw01wipd5x5vf27l1w887dv7ah0icgjshwg84ff1p";
+       sha256 = "373847d0e350cbc72280eaec7610e2811ee176e9a5ddc803e058dd81c88d42bf";
        libraryHaskellDepends = [
          array base bytestring containers dlist names-th persistable-record
          sql-words template-haskell text time time-locale-compat
@@ -111971,7 +112317,7 @@ self: {
      mkDerivation {
        pname = "relational-query-HDBC";
        version = "0.1.0.0";
-       sha256 = "1r5lj96w8cqcmma2kh46g8xyw0zz161nv1h9bwqia21vvis396vj";
+       sha256 = "729b3474dc3b0815315f09866d8309ff03ee3b7a86c02954ad0c33c44d92b4e4";
        libraryHaskellDepends = [
          base containers convertible HDBC HDBC-session names-th
          persistable-record relational-query relational-schemas
@@ -111987,7 +112333,7 @@ self: {
      mkDerivation {
        pname = "relational-record";
        version = "0.1.2.0";
-       sha256 = "00cb3yb4gin6kq7yz3jbkhm372z3vhq97h2l1xk0xja8xi8mfhn6";
+       sha256 = "c6425751ec48c90e660f54c09330dce38b332a9c4b8eef0f9ec6c647961f8b01";
        libraryHaskellDepends = [
          base relational-query relational-query-HDBC
        ];
@@ -112004,7 +112350,7 @@ self: {
      mkDerivation {
        pname = "relational-record-examples";
        version = "0.2.0.2";
-       sha256 = "0jpzn739xl1ylz6aja1czvkg4gjbgkag56pcja31mfx9xiv5jnmf";
+       sha256 = "ae5a5976eca9bb1a8692ec9af2d47c4b3ef2e6fe2c28a9cca73ed09ec6b1ff4a";
        isLibrary = false;
        isExecutable = true;
        executableHaskellDepends = [
@@ -112022,7 +112368,7 @@ self: {
      mkDerivation {
        pname = "relational-schemas";
        version = "0.1.0.2";
-       sha256 = "1267bv92z2k8s2cmn8sgw0i0vs3y2m8jyvnv969v15lrpsid1vvw";
+       sha256 = "7cefd0a2be9996b09349db6e2f51157ee80d22e04f235b99d0688a2fd25ec788";
        libraryHaskellDepends = [
          base bytestring containers persistable-record relational-query
          template-haskell time
@@ -112038,7 +112384,7 @@ self: {
      mkDerivation {
        pname = "relative-date";
        version = "0.0.1";
-       sha256 = "052rk17flm5zp70wcl7ki3ys47hnaa2d5c1vjsap7bfkcg4lff66";
+       sha256 = "c63847c963d3ad7395963bb0d28452161ea2fd88f350c6c1b9bf54ea4e985914";
        libraryHaskellDepends = [
          base concatenative datetime mtl parsec time
        ];
@@ -112052,7 +112398,7 @@ self: {
      mkDerivation {
        pname = "relit";
        version = "0.1.3";
-       sha256 = "03cnra0yfpijp65p1x0wv4fvc1p1l27lcb00k22ijrcy2mxqr9cg";
+       sha256 = "8fa58c7b159e65198598002c468fa0e106b61dd91cf4708bb9325ee781ca960d";
        libraryHaskellDepends = [ base regex-base template-haskell ];
        description = "Literal for regular expression";
        license = stdenv.lib.licenses.bsd3;
@@ -112063,7 +112409,7 @@ self: {
      mkDerivation {
        pname = "rematch";
        version = "0.2.0.0";
-       sha256 = "0law4al9hzn9qljfm8rwgmb15pzpcs8i44v1l6279977q0lxx5pr";
+       sha256 = "f996de29c0e7a47484a16113129166f7df12567d3ca3ea24c5c97e98a8225c51";
        libraryHaskellDepends = [ base ];
        testHaskellDepends = [ base hspec HUnit ];
        description = "A simple api for matchers";
@@ -112075,7 +112421,7 @@ self: {
      mkDerivation {
        pname = "rematch-text";
        version = "0.1.0.2";
-       sha256 = "0q8jf7128360waq6k369ykp0hfjwydkm7f8ykwzd8xflmgfiywfd";
+       sha256 = "cd711fddabd475d43e9f1eb95367f35c3a08eef4c98c69b0e2c00c24c2711261";
        libraryHaskellDepends = [ base rematch text ];
        testHaskellDepends = [ base hspec HUnit rematch text ];
        description = "`rematch` matchers for Data.Text";
@@ -112090,7 +112436,7 @@ self: {
      mkDerivation {
        pname = "remote";
        version = "0.1.1";
-       sha256 = "14awzhpc21pp4iq53vz4ib81ygxsnlnfppv723zy77z6jja08gf0";
+       sha256 = "c03d049494e69fe3ff1067dfeb2cb5ba3f1fd08ae4ef517024f706c12efc5c91";
        libraryHaskellDepends = [
          base binary bytestring containers directory filepath mtl network
          pureMD5 stm syb template-haskell time utf8-string
@@ -112105,7 +112451,7 @@ self: {
      mkDerivation {
        pname = "remote-debugger";
        version = "0.2.2";
-       sha256 = "1c6xh390963hk7q2qvhqb6yma5ma7hk39nxjikizwh7s2h9vi9k4";
+       sha256 = "64a6b81314fa40fee38cb2db34263caa1655bd59186e2cf099709804d280ddb0";
        isLibrary = false;
        isExecutable = true;
        executableHaskellDepends = [
@@ -112129,7 +112475,7 @@ self: {
      mkDerivation {
        pname = "remotion";
        version = "0.2.0";
-       sha256 = "0m7x5i00i6ai39yii6h5vzlsp1rnmprmddqllqja57kdy3q7v7na";
+       sha256 = "ca9e7df0f06d9ea224a614b756f3ad3687abe9df059a187d1a519908402cfd54";
        libraryHaskellDepends = [
          async base bytestring concurrent-extra containers directory errors
          filelock hashable hashtables lifted-async loch-th monad-control mtl
@@ -112157,7 +112503,7 @@ self: {
      mkDerivation {
        pname = "reord";
        version = "0.0.0.2";
-       sha256 = "07lxnfj0q565ydjzgcnb9dhjlrs7s1h6ybam7aic68lfd4p0hr7y";
+       sha256 = "fe64082e698e22c3a23a552d6f60d047672a614bcbb2f765f3c5140ca4b39d1e";
        libraryHaskellDepends = [ base ];
        description = "Ad-hoc Ord instances";
        license = stdenv.lib.licenses.publicDomain;
@@ -112170,7 +112516,7 @@ self: {
      mkDerivation {
        pname = "reorderable";
        version = "0.3.1";
-       sha256 = "1i81yran553jdsyx0bx5g72dg6v24yk3g6l40m1cd430f8yy8a6f";
+       sha256 = "ce28e43d726090c64205849a37a627629bd7c479a52fd0bd6e72946255f601c5";
        libraryHaskellDepends = [
          base constraints haskell-src-exts haskell-src-meta template-haskell
        ];
@@ -112187,7 +112533,7 @@ self: {
      mkDerivation {
        pname = "repa";
        version = "3.4.0.1";
-       sha256 = "197ab7z0fi50n3i8lkcxqazgnv39dv8dhndzihppsmfkil5y58l4";
+       sha256 = "84a2e20b8dd3557d2f8cbf59d8d06e696cfbbec29d4d8ae2b0a04407fe59eaa4";
        libraryHaskellDepends = [
          base bytestring ghc-prim QuickCheck template-haskell vector
        ];
@@ -112201,7 +112547,7 @@ self: {
      mkDerivation {
        pname = "repa-algorithms";
        version = "3.4.0.1";
-       sha256 = "0q8jwp1msg5icvcqxszh5c1190llwz17gxc7nmd1bkyca59j8w0l";
+       sha256 = "1470245351cccf155ab587f577c2e7948214022bf0eb8ed966b13c5dc3e51261";
        libraryHaskellDepends = [ base repa vector ];
        homepage = "http://repa.ouroborus.net";
        description = "Algorithms using the Repa array library";
@@ -112215,7 +112561,7 @@ self: {
      mkDerivation {
        pname = "repa-array";
        version = "4.1.0.1";
-       sha256 = "04bi2j2y5rrpkfzys6ma0d5fhsrapip0xb43gqsgcqz3rk89lank";
+       sha256 = "d32a9ad0cce363f6347e83ac0e6ebc2a6be84a03aa1aedbf9b37e7e285147111";
        libraryHaskellDepends = [
          base bytestring double-conversion mtl primitive repa-convert
          repa-eval repa-stream text vector
@@ -112232,7 +112578,7 @@ self: {
      mkDerivation {
        pname = "repa-bytestring";
        version = "3.0.0.1";
-       sha256 = "1q7kvm39iqabanrgyi438n8mfn1ikvpygralyakfc02rm2gpl0gb";
+       sha256 = "eb017a9fa85900e6a6f254e5e7ef9e31585791458344ffb2554be19846ddf3e0";
        libraryHaskellDepends = [ base repa ];
        jailbreak = true;
        homepage = "http://repa.ouroborus.net";
@@ -112248,7 +112594,7 @@ self: {
      mkDerivation {
        pname = "repa-convert";
        version = "4.2.0.1";
-       sha256 = "0y7xjcbrm2g3rgppb9lqbj4m1l7bvir12gjg11a18fkl1mzdh89l";
+       sha256 = "3421d87e0d743a1454084f3e1172dcebd050895c98a675efcbe3899a1793fd78";
        libraryHaskellDepends = [
          base bytestring double-conversion primitive repa-scalar vector
        ];
@@ -112262,7 +112608,7 @@ self: {
      mkDerivation {
        pname = "repa-devil";
        version = "0.3.2.6";
-       sha256 = "0f7xawg4qlfbf24lrjbpqzl3f3zf63f8g5b2gi17h0rpyw3cxhzy";
+       sha256 = "fec3ce06f7370378427c629587dc30ee0f37e8c777c94c8970cb514c1e57fd38";
        libraryHaskellDepends = [ base repa transformers ];
        librarySystemDepends = [ libdevil ];
        homepage = "https://github.com/RaphaelJ/repa-devil";
@@ -112275,7 +112621,7 @@ self: {
      mkDerivation {
        pname = "repa-eval";
        version = "4.0.0.1";
-       sha256 = "0vng0y835gma937q1996qghfzx06wabxf7ln8ckrwy5djzza8h9y";
+       sha256 = "3e41a4fe97ad789e2743961ed797e206f4efe0c326a580cf48aabe329007cf6e";
        libraryHaskellDepends = [ base ghc-prim ];
        jailbreak = true;
        homepage = "http://repa.ouroborus.net";
@@ -112290,7 +112636,7 @@ self: {
      mkDerivation {
        pname = "repa-examples";
        version = "3.4.0.1";
-       sha256 = "00v1z4kscvmnd4k7lsswzaxafkk7mbsy4ghdd503wpvr4fvslgaz";
+       sha256 = "5f3daab723795f3e40690d3ee2f5aa674ea7bafa5c6b7a2669b66ea627f96103";
        isLibrary = false;
        isExecutable = true;
        executableHaskellDepends = [
@@ -112309,7 +112655,7 @@ self: {
      mkDerivation {
        pname = "repa-fftw";
        version = "3.2.3.2";
-       sha256 = "0y05hjysf484nfdr2qs1mbs7znxi58q9f0kxfnkcbskijwxnj320";
+       sha256 = "400c693b9771eac5a6757d0297302ab1db7ff4aa4163919bb30411a7bd840578";
        libraryHaskellDepends = [ base carray fft repa storable-complex ];
        testHaskellDepends = [
          base repa tasty tasty-hunit tasty-quickcheck
@@ -112325,7 +112671,7 @@ self: {
      mkDerivation {
        pname = "repa-flow";
        version = "4.1.0.1";
-       sha256 = "0d3j4wc3f0rbxmmj2hq9m8m9hjnad6siard279xs7sd4qzwkcpg7";
+       sha256 = "e75d36f9c7a4e9a37b3aa26515b569ca4a982aaa0943216bed2b033718277234";
        libraryHaskellDepends = [
          base bytestring containers directory filepath primitive repa-array
          repa-eval repa-stream text vector
@@ -112344,7 +112690,7 @@ self: {
      mkDerivation {
        pname = "repa-io";
        version = "3.4.0.1";
-       sha256 = "06ks4gxsajnalxh9mpnl4pckxnyfc59823war3m74anb0pqcrbbl";
+       sha256 = "74adccf005cb2a72eac88a0f815261cedb3ed925d4de9a60a7ca4aa5fb237a1a";
        libraryHaskellDepends = [
          base binary bmp bytestring old-time repa vector
        ];
@@ -112358,7 +112704,7 @@ self: {
      mkDerivation {
        pname = "repa-linear-algebra";
        version = "0.1.0.0";
-       sha256 = "06lvp3sj6w4kvw6qhn5wcy2c2v7w15jaicw1pm14ssxhs4xl866g";
+       sha256 = "cf18443bd1b06b4d42bd81b3a86409fc6cc18467bc58880ddf937023f5b89b1a";
        libraryHaskellDepends = [ base hmatrix repa vector ];
        homepage = "https://github.com/marcinmrotek/repa-linear-algebra";
        description = "HMatrix operations for Repa";
@@ -112372,7 +112718,7 @@ self: {
      mkDerivation {
        pname = "repa-plugin";
        version = "1.0.0.1";
-       sha256 = "0s644rlk6sqz8sb2rwak42153xxsp5vjpqhlxnmbic0b7r67s8y9";
+       sha256 = "c9237d4c3e0bb0b8aaed14e22b77b9baf751822053f12c96461f6b336926c468";
        libraryHaskellDepends = [
          base containers ddc-base ddc-core ddc-core-flow ddc-core-simpl ghc
          mtl
@@ -112390,7 +112736,7 @@ self: {
      mkDerivation {
        pname = "repa-scalar";
        version = "4.2.0.1";
-       sha256 = "1mby4xa0i2jrzhiyvayif6bwxsmfz1ibvigxw8kwxjd5hqc0y6f6";
+       sha256 = "c6190f1886a5c9ce27e2fdc5bd62f8aeeace9771d1abed23fc598a0854277ed5";
        libraryHaskellDepends = [
          base bytestring double-conversion primitive vector
        ];
@@ -112404,7 +112750,7 @@ self: {
      mkDerivation {
        pname = "repa-series";
        version = "1.0.0.1";
-       sha256 = "1kldz4d4cv0vliqw78ywbcfgh0mw4i5cd93j0jdagvhsbhlxlp5k";
+       sha256 = "b35cda295c1aeea79a0472a4c64a24bc02f81c5bdca3c371a41b6c461af98dce";
        libraryHaskellDepends = [ base ghc ghc-prim vector ];
        jailbreak = true;
        description = "Series Expressionss API";
@@ -112419,7 +112765,7 @@ self: {
      mkDerivation {
        pname = "repa-sndfile";
        version = "3.2.3.3";
-       sha256 = "0pgrdhi7s1capainmd6hq1h8wjzppyr8fn93fzygwjpvnnhfggk8";
+       sha256 = "68bee7a0b5fb4afefc77235987b2bff74b8e60c0d0b46aa3ba8a057d226cf95d";
        isLibrary = true;
        isExecutable = true;
        libraryHaskellDepends = [ base hsndfile repa ];
@@ -112438,7 +112784,7 @@ self: {
      mkDerivation {
        pname = "repa-stream";
        version = "4.1.0.1";
-       sha256 = "17n48ixypx5a3anj212h4vxa6sqwk5yssjqyprb8lb3mnqfdlxmm";
+       sha256 = "b576da1cb6752c8a56be1e4bad7d991c6ba3fa26500421ad1aaaf4eb7b44c49e";
        libraryHaskellDepends = [ base mtl primitive vector ];
        jailbreak = true;
        homepage = "http://repa.ouroborus.net";
@@ -112453,7 +112799,7 @@ self: {
      mkDerivation {
        pname = "repa-v4l2";
        version = "0.2.0.0";
-       sha256 = "1d8spppfjbcb9smk735zxgpz1v1f5p1sm50nfzry68bdb1p29xnz";
+       sha256 = "dff6246e586d21e3f3771694aac32d2eecf0efebbf8c33ab4e8b2de9eebd1ab5";
        isLibrary = true;
        isExecutable = true;
        libraryHaskellDepends = [
@@ -112472,7 +112818,7 @@ self: {
      mkDerivation {
        pname = "repl";
        version = "1.1";
-       sha256 = "0q9gk76r9n8gyn8fwqfmywbrjhyqy0gz8blmmvrvwghyfscabnh9";
+       sha256 = "09daa598761e3ebef3ae952ef41ff0d8439917f7d561ee90f50fd994cd992f61";
        libraryHaskellDepends = [
          base ghc ghc-paths haskell-src-exts parsec
        ];
@@ -112492,7 +112838,7 @@ self: {
      mkDerivation {
        pname = "repl-toolkit";
        version = "0.5.0.0";
-       sha256 = "0m0jh734zfmxc2bfilb1ka12y3nhsm94hxcg0q6wwf6bxkl564vq";
+       sha256 = "781353e8eccb38ce0d068f754852d5d00e2f829a61d1e89660bdba4fc6811254";
        libraryHaskellDepends = [
          aeson base bytestring data-default directory exceptions filepath
          functor-monadic ListLike listsafe monad-loops mtl numericpeano
@@ -112508,7 +112854,7 @@ self: {
      mkDerivation {
        pname = "repline";
        version = "0.1.4.0";
-       sha256 = "16qi3lpgymn61nssv9k21v889xszycimp6i5602llnry6ks77bij";
+       sha256 = "32ae73f4343e5b4a0530259a5b23f35ff784d00e62a6adb50dc656ff2e1d119b";
        isLibrary = true;
        isExecutable = true;
        libraryHaskellDepends = [ base containers haskeline mtl ];
@@ -112526,7 +112872,7 @@ self: {
      mkDerivation {
        pname = "repo-based-blog";
        version = "0.0.1";
-       sha256 = "0ada0xqpkp6ch71sizf8fscvz6rjq95asmfgdvg8jj8gwpzvlncs";
+       sha256 = "9a59baffe50f4989de6ecf55ad4ac2329bbf9976c8fda8c381ccdc797107aa29";
        isLibrary = true;
        isExecutable = true;
        libraryHaskellDepends = [
@@ -112553,7 +112899,7 @@ self: {
      mkDerivation {
        pname = "repr";
        version = "0.4.1.3";
-       sha256 = "1y1zl81yjc9jrci83bm6bn8hrfqf6x25vxzkhrkydhhwcwqfqaj5";
+       sha256 = "452aec30671cc2e66786f3f75d44370ebb0c915da6ae8122cb3231e903a23ff8";
        libraryHaskellDepends = [
          base base-unicode-symbols dstring random string-combinators
        ];
@@ -112569,7 +112915,7 @@ self: {
      mkDerivation {
        pname = "repr-tree-syb";
        version = "0.1.0";
-       sha256 = "1kpxfvbmfv3zhn0fx7fznnppqxjz2f70g5n89hzkiqjz2am0ls5s";
+       sha256 = "ba680aaa125fe2383f4cc896078e135f767cafb5df9dee80857f6c57d776fdce";
        libraryHaskellDepends = [ base containers syb text ];
        jailbreak = true;
        homepage = "https://github.com/nikita-volkov/repr-tree-syb";
@@ -112585,7 +112931,7 @@ self: {
      mkDerivation {
        pname = "representable-functors";
        version = "3.2.0.2";
-       sha256 = "156rhm9hqxkwpv4ppg6647gz2q95mp61rx6ii0nk6i0ygmjvw1l2";
+       sha256 = "8206be657d1e44332d88d1f41cccad2561f1df21c6bc7bc9be7c760c5385d994";
        libraryHaskellDepends = [
          array base comonad comonad-transformers comonads-fd containers
          contravariant distributive free keys mtl semigroupoids semigroups
@@ -112603,7 +112949,7 @@ self: {
      mkDerivation {
        pname = "representable-profunctors";
        version = "3.2";
-       sha256 = "0bly94xix00krgl7iaxwb0l0bvykrm0zqz57m78p8j7pdmkr89wc";
+       sha256 = "8c2794676df74874d1a9a77cfc41cdd3ef052858bcab78e8cb13801e3b499e2e";
        libraryHaskellDepends = [ base ];
        homepage = "http://github.com/ekmett/representable-profunctors/";
        description = "This package has been absorbed into profunctor-extras";
@@ -112619,7 +112965,7 @@ self: {
      mkDerivation {
        pname = "representable-tries";
        version = "3.0.2";
-       sha256 = "07qjm04xf9qndyybph4mhjp65yjvz54pia4y8kj7wps75gjail2m";
+       sha256 = "55d0a8e42b475f7ee4449ea87849f95bfa62ae8495c0bbbc6f1627d709a8121f";
        libraryHaskellDepends = [
          adjunctions base bifunctors comonad comonad-transformers containers
          distributive keys mtl representable-functors semigroupoids
@@ -112637,7 +112983,7 @@ self: {
      mkDerivation {
        pname = "request-monad";
        version = "0.3.0.1";
-       sha256 = "1aqcsm9a3zd11k7d4nbvxsy7l35fr77z7gyhrl7rvflnixid29ws";
+       sha256 = "9a27d1628f96ba9d0fcdd0bff3cfc9ae0c7abcee7b59d2ce0ca1fda152d50cab";
        libraryHaskellDepends = [ base free mtl transformers ];
        jailbreak = true;
        homepage = "http://github.com/nahiluhmot/request-monad";
@@ -112653,7 +112999,7 @@ self: {
      mkDerivation {
        pname = "reroute";
        version = "0.3.0.2";
-       sha256 = "14xkkcgqbg7bddln849h2k0xrrj9hfvw2ikai81snz7dsf3mcnb8";
+       sha256 = "68595687d3ed7cab038a6a46c1b78349e6dcc114301164696bebbc851f9bb393";
        libraryHaskellDepends = [
          base deepseq graph-core hashable hvect mtl path-pieces regex-compat
          text transformers unordered-containers vector
@@ -112674,7 +113020,7 @@ self: {
      mkDerivation {
        pname = "reserve";
        version = "0.1.1";
-       sha256 = "152pngw3xrlyrq905a231hi9hg3pf5ddpcihwic496rng5hd5hj2";
+       sha256 = "42c2d26079369b4458e430b2db5a71773c98220c43a80212ce9ee63ef8b35794";
        isLibrary = false;
        isExecutable = true;
        executableHaskellDepends = [
@@ -112696,7 +113042,7 @@ self: {
      mkDerivation {
        pname = "resolve-trivial-conflicts";
        version = "0.3.0.2";
-       sha256 = "1d64hg2nwhqzm720w25xgb4wv2akg0kv3iwwh2ivc57zp525xpcq";
+       sha256 = "98dd5e44b9ff14b6a3809cc7b127785389cdc97abd080ec4a91f436ec583c4b4";
        isLibrary = false;
        isExecutable = true;
        executableHaskellDepends = [
@@ -112715,7 +113061,7 @@ self: {
      mkDerivation {
        pname = "resource-effect";
        version = "0.1.1";
-       sha256 = "085ila27irk7pflx4kgn1p364wx2hj9wlm2lvdq0ix25hv8afxnb";
+       sha256 = "cb76a7d08645f40870db5454ca9384a27362c60df64dd2a9bb67e67884a2b120";
        libraryHaskellDepends = [ base containers extensible-effects ];
        testHaskellDepends = [
          base containers extensible-effects HUnit mtl QuickCheck
@@ -112732,7 +113078,7 @@ self: {
      mkDerivation {
        pname = "resource-embed";
        version = "0.1.0.0";
-       sha256 = "1i33z3rr72s5z2k6j5c10vjy7nslgfn3xqgwf8w05n9m2pwhn2fv";
+       sha256 = "db090bf91535d9023872fce13eac7b54dbe3e506811569a6f8458b93f3f863c4";
        isLibrary = false;
        isExecutable = true;
        executableHaskellDepends = [ base bytestring directory ];
@@ -112749,7 +113095,7 @@ self: {
      mkDerivation {
        pname = "resource-pool";
        version = "0.2.3.2";
-       sha256 = "04mw8b9djb14zp4rdi6h7mc3zizh597ffiinfbr4m0m8psifw9w6";
+       sha256 = "8627eea2bea8824af2723646e74e2af0c73f583dd0c496c9fd242cd9d242bc12";
        libraryHaskellDepends = [
          base hashable monad-control stm time transformers transformers-base
          vector
@@ -112766,7 +113112,7 @@ self: {
      mkDerivation {
        pname = "resource-pool-catchio";
        version = "0.2.1.0";
-       sha256 = "0g9r6hnn01n3p2ikcfkfc4afh83pzam29zal3k2ivajpl3kramsw";
+       sha256 = "5c5795e7a057aa1dc51c54fd24aafa7720e814616e3a36a3b8c306602d34393d";
        libraryHaskellDepends = [
          base hashable MonadCatchIO-transformers stm time transformers
          transformers-base vector
@@ -112783,7 +113129,7 @@ self: {
      mkDerivation {
        pname = "resource-simple";
        version = "0.2";
-       sha256 = "0m6jdhnq0f9anjm9bqmz3v8d0k12nkp4nks7mvhw7hjbjnkgscni";
+       sha256 = "d132fda6954bc2c3e1ae474f4beeb4224cd0d01ebfe295aab42a39802d6cd254";
        libraryHaskellDepends = [
          base containers monad-control monad-fork mtl-evil-instances
          transformers transformers-base
@@ -112802,7 +113148,7 @@ self: {
      mkDerivation {
        pname = "resourcet";
        version = "1.1.6";
-       sha256 = "0zhsaaa4n8ry76vjih519a8npm2hrzk10d5asrgllcwpzmifl41y";
+       sha256 = "3e10ea62fd97334a5fd6aa3410e6cf50d46b914aa1c028b7393e234b94521a7e";
        libraryHaskellDepends = [
          base containers exceptions lifted-base mmorph monad-control mtl
          transformers transformers-base transformers-compat
@@ -112824,7 +113170,7 @@ self: {
      mkDerivation {
        pname = "respond";
        version = "1.1.0";
-       sha256 = "0j2xafk6rrspffmd0fxsmmz8gnmxxn3dxngh684nwj4030cg9m3r";
+       sha256 = "79d4f4181880486e0932f0d9de86edbdda877eadba3bd0aa7357e76ca6535d48";
        isLibrary = true;
        isExecutable = true;
        libraryHaskellDepends = [
@@ -112854,7 +113200,7 @@ self: {
      mkDerivation {
        pname = "rest-client";
        version = "0.5.0.3";
-       sha256 = "02lgdjn4800301w8cki2wyl65jzc4yp4gxrhz5lwv9jcy69gbkkb";
+       sha256 = "6bcef592f14ca6cd69f930f747ae27eccb62a8e7224e867800030044ac6c8f0a";
        libraryHaskellDepends = [
          aeson-utils base bytestring case-insensitive data-default
          exceptions http-conduit http-types hxt hxt-pickle-utils
@@ -112876,7 +113222,7 @@ self: {
      mkDerivation {
        pname = "rest-core";
        version = "0.36.0.5";
-       sha256 = "1xvhhj03kyv39w8s330gn3pxz4431xmcbiacf6y8a4d0nd6fw8qf";
+       sha256 = "0e23ee4cb3a01185bc714cc5c56a0f8390dfefb00f8ca1114f63fb39808470f7";
        libraryHaskellDepends = [
          aeson aeson-utils base bytestring case-insensitive errors fclabels
          hxt hxt-pickle-utils json-schema mtl mtl-compat multipart random
@@ -112901,7 +113247,7 @@ self: {
      mkDerivation {
        pname = "rest-example";
        version = "0.2.0.2";
-       sha256 = "13mq7zhjwp57rials06kkj8aq400wapldl5mc35h1xynm396xmpi";
+       sha256 = "f1d66ed2a8d6f700cb60b5d046afe20010ac909cd3004d55cca75c2ee13fb88e";
        isLibrary = true;
        isExecutable = true;
        libraryHaskellDepends = [
@@ -112929,7 +113275,7 @@ self: {
      mkDerivation {
        pname = "rest-gen";
        version = "0.17.1.2";
-       sha256 = "05imgbal0b6ab1i8b1896y1qm956ci7r0xx3qnkjbb6vxdl51vaa";
+       sha256 = "4aed5068ebdbac25a7c5a377904f64a6a48a83370985856258ca2c40d57a3516";
        libraryHaskellDepends = [
          aeson base blaze-html Cabal code-builder directory fclabels
          filepath hashable haskell-src-exts HStringTemplate hxt json-schema
@@ -112951,7 +113297,7 @@ self: {
      mkDerivation {
        pname = "rest-happstack";
        version = "0.2.10.8";
-       sha256 = "0n1rc1b9vdq83ilm2s9ac96jln89g0g0img1pwg991dbm30k3v7y";
+       sha256 = "feec31c1a8ab85941ebfe1d5081e7809592a4d622a6951691c08b79d56603958";
        libraryHaskellDepends = [
          base containers happstack-server mtl rest-core rest-gen utf8-string
        ];
@@ -112966,7 +113312,7 @@ self: {
      mkDerivation {
        pname = "rest-snap";
        version = "0.1.17.18";
-       sha256 = "0g8srn4b7nxyi98vn28q27li4mk7ypdgg9l66ba7z5h0bg8w2766";
+       sha256 = "c61cc1d15b00967fd43286a6f7daf5675612e9111809bb518abedbb388cd1a3d";
        libraryHaskellDepends = [
          base bytestring case-insensitive rest-core safe snap-core
          unordered-containers uri-encode utf8-string
@@ -112982,7 +113328,7 @@ self: {
      mkDerivation {
        pname = "rest-stringmap";
        version = "0.2.0.6";
-       sha256 = "0jjj0yam4d4w36lnxk0ci7ylb9ya48y0ag3b54k9ikyg0hps7rb6";
+       sha256 = "66e5a32f04cfcf9826296b3c053c22caa745fd890ccc6ea9199c34529507524a";
        libraryHaskellDepends = [
          aeson base containers hashable hxt json-schema tostring
          unordered-containers
@@ -112998,7 +113344,7 @@ self: {
      mkDerivation {
        pname = "rest-types";
        version = "1.14.0.1";
-       sha256 = "0chb91gb3xvfp7k4sbsp07ri2m5x26qj4q2bq0ldkxpk06jicmb4";
+       sha256 = "645516a501f3f6d928c04b6022b111bd5411f301572f4de6b96ef7b15e480b32";
        libraryHaskellDepends = [
          aeson base case-insensitive generic-aeson generic-xmlpickler hxt
          json-schema rest-stringmap text uuid
@@ -113015,7 +113361,7 @@ self: {
      mkDerivation {
        pname = "rest-wai";
        version = "0.1.0.8";
-       sha256 = "0r11y2rl0h2axnlqcqhdy7w0b3c207qbyhg60rr0rnm9vsqj5l5d";
+       sha256 = "add022b1dea9da0c7206e641bff001828d05f8f10d6286a9ed4a4040b3f02164";
        libraryHaskellDepends = [
          base bytestring case-insensitive containers http-types mime-types
          mtl rest-core text unordered-containers wai
@@ -113033,7 +113379,7 @@ self: {
      mkDerivation {
        pname = "restful-snap";
        version = "0.2";
-       sha256 = "16gqbk9wl2a1ivhq30yh584h7p2vd7qvwx1rprin47amqzn5b6gc";
+       sha256 = "ec9955ecc7551d6263be3974bef1695bdc03092ad08381e18e4109cad35cf899";
        libraryHaskellDepends = [
          base blaze-builder bytestring containers data-default
          digestive-functors errors heist lens mtl old-locale readable snap
@@ -113053,7 +113399,7 @@ self: {
      mkDerivation {
        pname = "restricted-workers";
        version = "0.1.1";
-       sha256 = "0lxipqp8nsgw07hmb4b8rfxlfmfhj0l7sg8k0042qscys92rzg9l";
+       sha256 = "34bd9f45d29e692c0800133d7d2890d05547bbcb689155e101fc698b2ebeb153";
        libraryHaskellDepends = [
          async base bytestring cereal data-default directory either filepath
          monad-control mtl network selinux stm text transformers
@@ -113071,7 +113417,7 @@ self: {
      mkDerivation {
        pname = "restyle";
        version = "0.1.0";
-       sha256 = "0hzkdg4f5h96zqznnrbjbxrzv17gz1zvd5g4a51rrpsgpngkax7x";
+       sha256 = "fd74359fbd4fdf9c4351e495b67ff8ef84fd735f72656b3ffe26c1e2c86bf343";
        isLibrary = true;
        isExecutable = true;
        libraryHaskellDepends = [ base ];
@@ -113087,7 +113433,7 @@ self: {
      mkDerivation {
        pname = "resumable-exceptions";
        version = "0.0.0.20100920";
-       sha256 = "06lzjf8dcbxks57x434n27146whryzzpwcn8bq2mclwfcrv9g3gs";
+       sha256 = "fa8d9776668e5356055ec8327efff7197243c211960cd24fd1b32fd690939f1a";
        libraryHaskellDepends = [ base mtl ];
        jailbreak = true;
        description = "A monad transformer for resumable exceptions";
@@ -113103,7 +113449,7 @@ self: {
      mkDerivation {
        pname = "rethinkdb";
        version = "2.0.0.0";
-       sha256 = "09digdn4a9vsmanpj6d2wn6kh59r05cfwjk4xq22iszzjrxami6d";
+       sha256 = "cdc4aa7a96ffeb2804ee644aee58013915388de5a21979adaa7a27456c7bb125";
        isLibrary = true;
        isExecutable = true;
        libraryHaskellDepends = [
@@ -113127,7 +113473,7 @@ self: {
      mkDerivation {
        pname = "rethinkdb-client-driver";
        version = "0.0.19";
-       sha256 = "0yzmypflg133dzy5yj2jmdk450zmr237prjvnaf9343jiy143nyi";
+       sha256 = "d1db41828f7290919cb25be67b86c8f5834266ab52485ffc6f638447ddf5f57b";
        libraryHaskellDepends = [
          aeson base binary bytestring hashable mtl network old-locale
          scientific template-haskell text time unordered-containers vector
@@ -113149,7 +113495,7 @@ self: {
      mkDerivation {
        pname = "rethinkdb-model";
        version = "0.1.0.2";
-       sha256 = "15993912bw3v09c6fiqnjcjcpd77px61kq276v1aaqdbahzpzw2q";
+       sha256 = "58f07f3f54ab61a5c23647e0194cbfe7b4cb249316476758027bf025421a2995";
        libraryHaskellDepends = [
          aeson base mtl rethinkdb text transformers unordered-containers
        ];
@@ -113169,7 +113515,7 @@ self: {
      mkDerivation {
        pname = "rethinkdb-wereHamster";
        version = "1.8.0.5";
-       sha256 = "0wkxf1iixy9rnl2rawima61qpjz77g4w08dd13q004g6c1n0h6kq";
+       sha256 = "781a086c60e61100f008ad21c0c93be7cb8b835135729505b539f91e63707d72";
        libraryHaskellDepends = [
          aeson attoparsec base bytestring containers data-default ghc-prim
          mtl network protocol-buffers protocol-buffers-descriptor text time
@@ -113187,7 +113533,7 @@ self: {
      mkDerivation {
        pname = "retry";
        version = "0.6";
-       sha256 = "1ry2zqs5361mg5ibnd6awjpl3nl3a6ha18m0v2f28hs9kw6dnsgj";
+       sha256 = "f269db0c9f4943249cd8a0a2a0a05183da41afe4ca34bb627935985134fec2e7";
        libraryHaskellDepends = [
          base data-default-class exceptions transformers
        ];
@@ -113206,7 +113552,7 @@ self: {
      mkDerivation {
        pname = "retryer";
        version = "0.1.0.1";
-       sha256 = "1rvblmzlsyfvvvjz71ngb8l412rrr943s7pp75gqjcxnklnlc97j";
+       sha256 = "f224462d9db633895f39f71e3d48ca398b40285acf86f3e5dedb794d7fa56be7";
        isLibrary = false;
        isExecutable = true;
        executableHaskellDepends = [ base optparse-applicative process ];
@@ -113221,7 +113567,7 @@ self: {
      mkDerivation {
        pname = "rev-state";
        version = "0.1";
-       sha256 = "1lsq7b225v86rwm2rnrnhn28asjh6r3zwbvdm5vl4sp46cr5i4cf";
+       sha256 = "8e91583233e46a4277a96d2ffe4736506a85848536db2c2acf06ed22c43a58d3";
        libraryHaskellDepends = [ base mtl ];
        homepage = "https://github.com/DanBurton/rev-state#readme";
        description = "Reverse State monad transformer";
@@ -113233,7 +113579,7 @@ self: {
      mkDerivation {
        pname = "revdectime";
        version = "0.1.1";
-       sha256 = "0lbf7dclcdvy56b7wjyq3iam757wf4vic4b5qyxd4bffk66q3asm";
+       sha256 = "55ab818d99ce2dd2bac76511163771fc9453551cd84b7e96297e3746593b6e51";
        isLibrary = false;
        isExecutable = true;
        executableHaskellDepends = [ base old-time ];
@@ -113246,7 +113592,7 @@ self: {
      mkDerivation {
        pname = "reverse-apply";
        version = "2.0.1";
-       sha256 = "0iw1j2xr5dy29a1bwcg7fqk3lv72izr0nhj31rn45w53py1367nb";
+       sha256 = "cb1e3382bfa3f0426c0e43420bf28fe26c3a2676e731be824ac2b792bb908147";
        libraryHaskellDepends = [ base ];
        description = "Standard version of the reverse apply operator";
        license = stdenv.lib.licenses.bsd3;
@@ -113259,7 +113605,7 @@ self: {
      mkDerivation {
        pname = "reverse-geocoding";
        version = "0.2.1";
-       sha256 = "089p1fv1ghznfsnhw1bdnwna3hcxmmqakw2qgzg91w5gifzaf18s";
+       sha256 = "1a05a7be8baff090de7f58f0a970ad9dc1a12cb76d050ead76f6c317b60b3721";
        libraryHaskellDepends = [
          aeson base iso3166-country-codes lens lens-aeson text wreq
        ];
@@ -113274,7 +113620,7 @@ self: {
      mkDerivation {
        pname = "reversi";
        version = "0.1.1";
-       sha256 = "1dddlldp55c6l7g5n2gi8r1r0f8r6r3ipq9mlx11d54j8wmvvlnz";
+       sha256 = "dfd2bd2b4792941642a735e11b47361939904346f1095bdea18695721ba5adb5";
        isLibrary = false;
        isExecutable = true;
        executableHaskellDepends = [ array base process ];
@@ -113288,7 +113634,7 @@ self: {
      mkDerivation {
        pname = "rewrite";
        version = "0.10";
-       sha256 = "10cbsjilc4nv4hi4ipb078hiy7afnjl20f9kcda15pmpmqxxywjg";
+       sha256 = "4f72df3baeb7de125463333920a8b44e1d1f213a60dd482224db1246a3d48b81";
        isLibrary = false;
        isExecutable = true;
        executableHaskellDepends = [
@@ -113306,7 +113652,7 @@ self: {
      mkDerivation {
        pname = "rewriting";
        version = "0.2.2";
-       sha256 = "0gnd8awqjnm905m29yldy3z7w7jvilj5svijz63lzmwbjknfh6bs";
+       sha256 = "7a19e8ec948bd74f87f9326e5d248d5b1e7efef08dfa246a01a95a89b942cd3e";
        libraryHaskellDepends = [ base containers regular ];
        description = "Generic rewriting library for regular datatypes";
        license = stdenv.lib.licenses.bsd3;
@@ -113320,7 +113666,7 @@ self: {
      mkDerivation {
        pname = "rex";
        version = "0.5.1";
-       sha256 = "18g09pg7hhj052v72vncjvy900h3xhza8hl2g3akad8asn9k6jl6";
+       sha256 = "864a3393d50a3535d5788242a43eec030290fc96cc6e71b628404278de4de0a1";
        libraryHaskellDepends = [
          base bytestring containers haskell-src-exts haskell-src-meta
          pcre-light template-haskell
@@ -113337,7 +113683,7 @@ self: {
      mkDerivation {
        pname = "rezoom";
        version = "0.0.4";
-       sha256 = "122hca6whzxqk3x7207k4clrrl2awy96pafq0gjwddqicny41jza";
+       sha256 = "eacb40bc6511b7c6e503d8a96b92e74ad09c2923f30071fa98b87fc88d625088";
        isLibrary = false;
        isExecutable = true;
        executableHaskellDepends = [
@@ -113354,7 +113700,7 @@ self: {
      mkDerivation {
        pname = "rfc3339";
        version = "1.0.5";
-       sha256 = "1p3nahcmsikrc5maf7qz45042h80m6xszx70154yq169rsqkvav0";
+       sha256 = "60ab3db1cec904ec4909e0f4afbba900414140211f1fa76a6179465d195476dc";
        libraryHaskellDepends = [ base timerep ];
        description = "Parse and display time according to RFC3339 (deprecated)";
        license = stdenv.lib.licenses.bsd3;
@@ -113366,7 +113712,7 @@ self: {
      mkDerivation {
        pname = "rfc5051";
        version = "0.1.0.3";
-       sha256 = "0av4c3qvwbkbzrjrrg601ay9pds7wscqqp2lc2z78mv2lllap3g3";
+       sha256 = "e38dab28a5625774be60545c8c99e647b79bbc0ac0bc9c65fe6b2ebef160642b";
        isLibrary = true;
        isExecutable = true;
        libraryHaskellDepends = [ base bytestring containers ];
@@ -113382,7 +113728,7 @@ self: {
      mkDerivation {
        pname = "rhythm-game-tutorial";
        version = "0.1.1";
-       sha256 = "08ddm1pxi7qdjz2mgvjvwdgxyskvac4ahi3jp2fd8z1sh68c7x7s";
+       sha256 = "faf4c390813a7cd49cb87244a808537b6adf5fe35bee57c5970d9fd86fa8ad21";
        isLibrary = false;
        isExecutable = true;
        executableHaskellDepends = [
@@ -113403,7 +113749,7 @@ self: {
      mkDerivation {
        pname = "riak";
        version = "0.8.0.0";
-       sha256 = "16ncq22vhg62p1v1ch1jc1z3xds1qsr536fg3awvp7a0a8vyq528";
+       sha256 = "4814ec3752409dbbb91acf9951b2c641b73e7e6032401676b8c23cb885c0cc9a";
        libraryHaskellDepends = [
          aeson attoparsec base binary blaze-builder bytestring containers
          monad-control network protocol-buffers-fork pureMD5 random
@@ -113426,7 +113772,7 @@ self: {
      mkDerivation {
        pname = "riak-protobuf";
        version = "0.19.0.0";
-       sha256 = "1954f8hgibmilqpf72pp2yf8nx9cm60gfk1ypmb99h69lf8d5x1y";
+       sha256 = "3ef4d290a3c9c09456bd3e4cf780a92c758b9c17f78ae32ea6b1aef82072a4a4";
        libraryHaskellDepends = [
          array base parsec protocol-buffers-descriptor-fork
          protocol-buffers-fork
@@ -113442,7 +113788,7 @@ self: {
      mkDerivation {
        pname = "richreports";
        version = "0.0.3.0";
-       sha256 = "0mik0m6nziwm6z517wkxdmjp92nh3qz1m8yk3x5897zafgs1y5kk";
+       sha256 = "73161ff473ea9f844a1fd3a31a3e1ed08a74656d7df213ca3795c76f4d053356";
        libraryHaskellDepends = [ ascetic base MissingH ];
        description = "Integrated pretty-printing and error/static analysis reporting";
        license = stdenv.lib.licenses.mit;
@@ -113456,8 +113802,8 @@ self: {
      }:
      mkDerivation {
        pname = "riemann";
-       version = "0.1.0.1";
-       sha256 = "0d36ff839g7y1lm8dg5j5s1vdxr1hqbyjxh7gsfjca00a0cgy5xa";
+       version = "0.1.0.2";
+       sha256 = "7399d2b85839ef9c44aab66ad3b2f3a35e6a893fd8f5ab1aa1626a0f04128708";
        libraryHaskellDepends = [
          base cereal containers data-default either errors lens network
          protobuf text time transformers
@@ -113479,7 +113825,7 @@ self: {
      mkDerivation {
        pname = "riff";
        version = "0.3.0.1";
-       sha256 = "1970bsg1ngc6mzsyj8mapzar0h1wkdb4skfz64d0ccdfpipp5hdb";
+       sha256 = "abc1726fbcae31061a31df4d4d569b3c4090d5bfaa22e9f5af863d1b9e5ee0a4";
        isLibrary = true;
        isExecutable = true;
        libraryHaskellDepends = [
@@ -113496,8 +113842,8 @@ self: {
     ({ mkDerivation, base, mtl, primitive, vector }:
      mkDerivation {
        pname = "ring-buffer";
-       version = "0.1.1";
-       sha256 = "03v2xxj1gd35738qrhxcl0d3bx6pps4l1singb0yg1smrx5nkpp7";
+       version = "0.1.2";
+       sha256 = "8fc8bd6234d0a3a5c427f4c263873f4bfe7ad5496563d318d31ed466524e766b";
        libraryHaskellDepends = [ base mtl primitive vector ];
        homepage = "http://github.com/bgamari/ring-buffer";
        description = "A concurrent, mutable ring-buffer";
@@ -113511,7 +113857,7 @@ self: {
      mkDerivation {
        pname = "riot";
        version = "1.20080618";
-       sha256 = "1dgdwr9d0jl3r78f4shx0ff22vqlq72n5w5whw3ppirm8ccxf0ms";
+       sha256 = "ba02d7194335c77b0787bcf062c5c1146f219c031d6ae2d0c9834ad052e6edb5";
        isLibrary = false;
        isExecutable = true;
        executableHaskellDepends = [
@@ -113534,7 +113880,7 @@ self: {
      mkDerivation {
        pname = "ripple";
        version = "0.3";
-       sha256 = "1y19kp63chg4ljcccq6cp9n3g26x6jyyhch3jqj04ya9c16cbypw";
+       sha256 = "fcfac54c6049790224960332e8bd34dd88376cbacc60c698a4e44136cc9d29f8";
        libraryHaskellDepends = [
          aeson attoparsec base base58address binary bytestring cereal
          crypto-api crypto-pubkey-types cryptohash-cryptoapi ecdsa errors
@@ -113554,7 +113900,7 @@ self: {
      mkDerivation {
        pname = "ripple-federation";
        version = "0.3";
-       sha256 = "0m7mlv8qmw257hnk9lngxvq3nskninl88f5hl77r7w8r5hbymf0s";
+       sha256 = "1ab8ea172c19f193cfa1b03884a88d766a3bf0eecfd2342d3c45f08ad1a6f554";
        libraryHaskellDepends = [
          aeson attoparsec base base58address blaze-builder bytestring errors
          http-streams http-types io-streams network-uri text unexceptionalio
@@ -113571,7 +113917,7 @@ self: {
      mkDerivation {
        pname = "risc386";
        version = "0.0.20130719";
-       sha256 = "0i0fkg4vys3n31jwazrajirywxmk7idjv2kz3nlb8kwriqc6d723";
+       sha256 = "439c66188e994fb4a81d7f8a2d5b3cb376ee73942a7fc565187668bfc99b0e44";
        isLibrary = false;
        isExecutable = true;
        executableHaskellDepends = [ array base containers mtl pretty ];
@@ -113588,7 +113934,7 @@ self: {
      mkDerivation {
        pname = "rivers";
        version = "0.1.0";
-       sha256 = "0x7r04mwxwnqckfk865dckml4am11zx80a9k5kc91kz5ikq1ns64";
+       sha256 = "c4681bf08ce5cf90d82c332980fa0fa12a42eb64ad1834dd64d8f2ce2b01f974";
        libraryHaskellDepends = [ base lazysmallcheck oeis QuickCheck ];
        jailbreak = true;
        homepage = "https://github.com/d-rive/rivers";
@@ -113602,7 +113948,7 @@ self: {
      mkDerivation {
        pname = "rivet";
        version = "0.1.0.0";
-       sha256 = "1hiwgn0xyl42y9cmmc25464y42w7grf68xv8cvjznwzv0v1v63cg";
+       sha256 = "8f0db3c306fb73fbe5666877645c7e870be2892145b05a59f28250df817d3cc2";
        isLibrary = false;
        isExecutable = true;
        executableHaskellDepends = [ base rivet-core rivet-simple-deploy ];
@@ -113619,7 +113965,7 @@ self: {
      mkDerivation {
        pname = "rivet-core";
        version = "0.1.0.1";
-       sha256 = "102zgb1ryfl341h8r9hxm9zbmg8jq67bkn57hxhnfsjxv7952x21";
+       sha256 = "417451d2d95d6a676187a7d8b98ec112bdba7eaa1da68c6020833a9fc37a5f80";
        libraryHaskellDepends = [
          base configurator directory directory-tree filepath
          postgresql-simple process shake template-haskell text time
@@ -113635,7 +113981,7 @@ self: {
      mkDerivation {
        pname = "rivet-migration";
        version = "0.1.0.1";
-       sha256 = "1vg6ns5scq5nqyj2w070hswynji8pqfh654qa3zjda2xhna5mnbd";
+       sha256 = "6dd95a94855da826ff509814031dbe284aebb986e0002ea4c7b660a68bb6e6ed";
        libraryHaskellDepends = [ base postgresql-simple text ];
        homepage = "https://github.com/dbp/rivet";
        description = "Postgresql migration support for project management tool";
@@ -113647,7 +113993,7 @@ self: {
      mkDerivation {
        pname = "rivet-simple-deploy";
        version = "0.1.0.0";
-       sha256 = "1003sm8mpnc7l7fbp1j08cvc55va54arp6j0qdg2cc2m8cy5bpxf";
+       sha256 = "aedf553c435530265ec3409a9b15296a97c236434086bbdca187d95b51d50380";
        libraryHaskellDepends = [ base configurator mtl rivet-core text ];
        homepage = "https://github.com/dbp/rivet";
        description = "Basic deployment support for project management tool";
@@ -113661,7 +114007,7 @@ self: {
      mkDerivation {
        pname = "rlglue";
        version = "0.2.2.0";
-       sha256 = "0672j0xjlhyyfq2fbvnfc0gahihpkkcfh7nnbwh1salgy0ykzhq0";
+       sha256 = "00c33f3df08f2a1d205fd61ee8d89c1746a81e60ceeee50476de432a3b90e218";
        isLibrary = true;
        isExecutable = true;
        libraryHaskellDepends = [
@@ -113684,7 +114030,7 @@ self: {
      mkDerivation {
        pname = "rmonad";
        version = "0.8.0.2";
-       sha256 = "1pamp8n88f1y4q0q83vmvbqbfva03prcfdqfj3x888mjwxgh6h8l";
+       sha256 = "1441035fe7b22284fa900e37c7f21d406db7f0da750f8401263e38842cba55dd";
        libraryHaskellDepends = [ base containers suitable transformers ];
        testHaskellDepends = [
          base containers HUnit test-framework test-framework-hunit
@@ -113701,7 +114047,7 @@ self: {
      mkDerivation {
        pname = "rncryptor";
        version = "0.0.2.1";
-       sha256 = "086cq7b7x0l98q5di2bpbv9vjrhl7b62nlzwchdl8pqb5w83345m";
+       sha256 = "b59031102f0b5f441b64fc532bcc3a1466b9d35e7789d80a4689827ed6c1cc20";
        isLibrary = true;
        isExecutable = true;
        libraryHaskellDepends = [
@@ -113723,7 +114069,7 @@ self: {
      mkDerivation {
        pname = "rng-utils";
        version = "0.2.1";
-       sha256 = "11yy6v0dbdf0cn823vlyd90zc5q5aw0zjzylpz5s9c94wsd4pjfa";
+       sha256 = "cac94b9ae624b1a4cbbfd47ff901570517f6416a9eee219065c0b5d5c036de87";
        libraryHaskellDepends = [ base bytestring mwc-random vector ];
        description = "RNG within an MVar for convenient concurrent use";
        license = stdenv.lib.licenses.bsd3;
@@ -113734,7 +114080,7 @@ self: {
      mkDerivation {
        pname = "robot";
        version = "1.4";
-       sha256 = "1vac4ks3kdyf9wdiiw224rz2nm5859np7cqjpl5mrb2h27bycv5c";
+       sha256 = "ac6ce6d71150ac5c0bbd12b3736d2aa8542b7e2642f0181b4fceb739f4244ced";
        libraryHaskellDepends = [
          base containers exceptions transformers xhb
        ];
@@ -113750,7 +114096,7 @@ self: {
      mkDerivation {
        pname = "robots-txt";
        version = "0.4.1.3";
-       sha256 = "051ibkbhqlpimajj8gl0m468rs6qhlgs15f5bcrhlngfs20jbfkq";
+       sha256 = "78ba2581d0ee590a335bc595a01f85d8e88c0ca9803e24a5aaf1520cd75c3114";
        libraryHaskellDepends = [
          attoparsec base bytestring old-locale time
        ];
@@ -113771,7 +114117,7 @@ self: {
      mkDerivation {
        pname = "rocksdb-haskell";
        version = "0.1.0";
-       sha256 = "1wi8mc0xzdd47r2vxa1x4gmbm4yikp4pyfj00ycnydvs4b2n3iad";
+       sha256 = "4dc561c5227a376f9907403a7fc99dd193baea233da8be453ea4b5df01ab28f2";
        libraryHaskellDepends = [
          base bytestring data-default filepath resourcet transformers
        ];
@@ -113788,7 +114134,7 @@ self: {
      mkDerivation {
        pname = "roguestar";
        version = "0.6.0.1";
-       sha256 = "0xnpji131pva54drxjqra5nkciqljf4x6zylm3snzs8s4c7klak6";
+       sha256 = "662a3a0f231ae96ff5a8d47fd389931447366d5119cb9e1b296adf304294d776";
        isLibrary = false;
        isExecutable = true;
        executableHaskellDepends = [
@@ -113808,7 +114154,7 @@ self: {
      mkDerivation {
        pname = "roguestar-engine";
        version = "0.6.0.1";
-       sha256 = "056080bzdmrn6k0c9lx2d69l2ygal275xlkd6y31sj2ax9yizqkv";
+       sha256 = "7be21f7dea4a481d86376dd25e8ea0ea79419369a2d3c4c03436d7f61740c014";
        isLibrary = false;
        isExecutable = true;
        executableHaskellDepends = [
@@ -113831,7 +114177,7 @@ self: {
      mkDerivation {
        pname = "roguestar-gl";
        version = "0.6.0.1";
-       sha256 = "1lajrc6ay1vk9rbi3x8mx56rrsxkihmapzfm7l8aav2jx0wwryzs";
+       sha256 = "fafbcc39e8526ca5103dd5fdab2a8cb3eb9c4de915f511574e7307af0ccb52d1";
        libraryHaskellDepends = [
          arrows base bytestring containers filepath GLUT MonadRandom mtl
          OpenGL priority-sync random rsagl rsagl-frp rsagl-math stm
@@ -113848,7 +114194,7 @@ self: {
      mkDerivation {
        pname = "roguestar-glut";
        version = "0.6.0.1";
-       sha256 = "13kg8mabh0y1a48zjx9f9k207i5qn0hkabjyg10ha5d0kf36xbyh";
+       sha256 = "d0af6e869ba0150541785e2e3521b0b8c403c44c2e75f91151c103b854456f8e";
        isLibrary = false;
        isExecutable = true;
        executableHaskellDepends = [ base GLUT roguestar-gl rsagl ];
@@ -113866,7 +114212,7 @@ self: {
      mkDerivation {
        pname = "rollbar";
        version = "0.3.1";
-       sha256 = "0hv9i38c0c1bv36xy4inq6dghn79bmjw1x0xgi5mlwf5lzzp2fv1";
+       sha256 = "613b71ffa7c5715a4b7c1df4c0655de958f89ac13612dfcdd82b30c0d0886943";
        libraryHaskellDepends = [
          aeson base basic-prelude http-conduit monad-control network text
          vector
@@ -113883,7 +114229,7 @@ self: {
      mkDerivation {
        pname = "roller";
        version = "0.1.3";
-       sha256 = "07bicx83h66xmy3i2jszl5awkxw6fvy9y5r3v4hq2rz86z09zw0s";
+       sha256 = "1af09fc037e8678121d923179ffc7686f7c955a15f4b1187afdd18385067711d";
        isLibrary = true;
        isExecutable = true;
        libraryHaskellDepends = [
@@ -113903,7 +114249,7 @@ self: {
      mkDerivation {
        pname = "rolling-queue";
        version = "0.1";
-       sha256 = "1l39dlq8pn38b48iwqgrnh83h74qkmm34l5m9a0rbg76s2z04c43";
+       sha256 = "833002bed0e6bc95814ab550326a9d981c3810b4f9611e115968d88b306d69d0";
        libraryHaskellDepends = [ base stm ];
        homepage = "https://github.com/joeyadams/haskell-rolling-queue";
        description = "Bounded channel for STM that discards old entries when full";
@@ -113915,7 +114261,7 @@ self: {
      mkDerivation {
        pname = "roman-numerals";
        version = "0.5.1.5";
-       sha256 = "10da5vls9l5i255bapms4b2r7dnwmxgsaa1cdll2lrmid5dikixr";
+       sha256 = "b9c7195b69b1662a286d2c28a55fafdcb693c522ba5eb54a11b1d0a4e92eaa81";
        libraryHaskellDepends = [
          base base-unicode-symbols bytestring text
        ];
@@ -113931,7 +114277,7 @@ self: {
      mkDerivation {
        pname = "romkan";
        version = "0.1.0.0";
-       sha256 = "094z59jbkpy6gv51kf990q4fgmjyylifc63ij4kcdm0hlhmrmdc8";
+       sha256 = "88b59a2ba410d4c626917118e622f55ed6e7080629b919ca7ec6dfb9642a9f24";
        libraryHaskellDepends = [ attoparsec base containers text ];
        testHaskellDepends = [
          attoparsec base containers HUnit test-framework
@@ -113947,7 +114293,7 @@ self: {
      mkDerivation {
        pname = "roots";
        version = "0.1.1.2";
-       sha256 = "0xzsz4w153mbkkkv07558xkv83fph4g98hvjf6iljwvbbp47l0j9";
+       sha256 = "49027ac85d6b7349a3717243941e81d70db46747a51cb0e79cab8e1238f9fa77";
        libraryHaskellDepends = [ base tagged ];
        homepage = "/dev/null";
        description = "Root-finding algorithms (1-dimensional)";
@@ -113959,7 +114305,7 @@ self: {
      mkDerivation {
        pname = "rope";
        version = "0.6.4";
-       sha256 = "1g77bv2mmfhy2mkb08k92m3f2jab6p2la2s7rfib2r1jy6lq5vhb";
+       sha256 = "0bee82a9f13264b1a2cb470b45c5354b49e146156922b066151eba5ac55ee7bc";
        libraryHaskellDepends = [
          base bytestring fingertree mtl utf8-string
        ];
@@ -113977,7 +114323,7 @@ self: {
      mkDerivation {
        pname = "rosa";
        version = "0.2.1.0";
-       sha256 = "0qnvv8vyijjgb51pw5zfcmxy96nnnfrsvbg8xrnmq3p34xc168gb";
+       sha256 = "eb21135827e30e5c6deee8adadb3b3d69ae47b65ee177e43594fcae837dadb62";
        isLibrary = false;
        isExecutable = true;
        executableHaskellDepends = [
@@ -113996,7 +114342,7 @@ self: {
      mkDerivation {
        pname = "rose-trees";
        version = "0.0.1.1";
-       sha256 = "0ii9jxyd7q0x30zyp1gal29msd81n5vj613mkxxavjlz9ar9gvgx";
+       sha256 = "fded97b24a9fcaad7a9f75042377b101355d93a0ea85eb3f181de0d37c972946";
        libraryHaskellDepends = [
          base containers data-default pseudo-trie semigroups transformers
        ];
@@ -114012,7 +114358,7 @@ self: {
      mkDerivation {
        pname = "rosezipper";
        version = "0.2";
-       sha256 = "1g6ppa8cappdbq9923lsac504dfjh0ks64gbm6qbihrc34f4zavc";
+       sha256 = "6cab4f1c192cc3b8b0a9eb11a32780d235020a539a0e91125eed5ec590bad7bc";
        libraryHaskellDepends = [ base containers ];
        description = "Generic zipper implementation for Data.Tree";
        license = stdenv.lib.licenses.bsd3;
@@ -114029,7 +114375,7 @@ self: {
      mkDerivation {
        pname = "roshask";
        version = "0.2.1";
-       sha256 = "12sa8ir9cl2gygayk3vhd00shv3wy3sqyhf4hh6arml5q7wz1f3m";
+       sha256 = "75b8f0f9c185d6ac0c84c4418ff5f07c6ca80168708fe9d5f34f509672444a8b";
        isLibrary = true;
        isExecutable = true;
        libraryHaskellDepends = [
@@ -114057,7 +114403,7 @@ self: {
      mkDerivation {
        pname = "rosso";
        version = "1.0";
-       sha256 = "0cz5kqpvq9qjkdy2x3y6aqia3armawjjsnv2pxifl0l6f9hhrvis";
+       sha256 = "3aee0c61728602ea62bf625b2d255735aba12256c68f2e7c9b1227bc2f9ee533";
        libraryHaskellDepends = [ base containers deepseq ];
        description = "General purpose utility library";
        license = stdenv.lib.licenses.bsd3;
@@ -114069,7 +114415,7 @@ self: {
      mkDerivation {
        pname = "rot13";
        version = "0.1.0.2";
-       sha256 = "0d9c0zfc92xfp5v5dp83w2897pg2gyz9n14xpggakwk6ynfmf6hd";
+       sha256 = "0d1a579df566f2a9debb9d049bbe7fe2dd9390e003dd5676b9ae8bc4dc072c35";
        libraryHaskellDepends = [ base bytestring ];
        testHaskellDepends = [ base hspec QuickCheck ];
        homepage = "https://github.com/kvanberendonck/codec-rot13";
@@ -114084,7 +114430,7 @@ self: {
      mkDerivation {
        pname = "rotating-log";
        version = "0.2";
-       sha256 = "1gqdfzdz3nwp6mjy61a49kwhcrykjl00aq9gq1v68li6z75zf85k";
+       sha256 = "b320f7cbf926526476c02f61050095d36706f94c4405e3653597dbf1db770dbf";
        libraryHaskellDepends = [
          base bytestring directory filepath old-locale time
        ];
@@ -114100,7 +114446,7 @@ self: {
      mkDerivation {
        pname = "rounding";
        version = "0.3.0";
-       sha256 = "1d2vaijcna8gwcrhsjpclqw4gjdvdpmnrlyszqzcxnqf0l206a6y";
+       sha256 = "de280304050edbce3efedad36ceb6dbbc94738a6ec4a0d33e30f29cb64545bb4";
        libraryHaskellDepends = [ array base numeric-extras ];
        jailbreak = true;
        homepage = "http://patch-tag.com/r/ekmett/rounding";
@@ -114116,7 +114462,7 @@ self: {
      mkDerivation {
        pname = "roundtrip";
        version = "0.2.0.3";
-       sha256 = "1q7n8fnlf9kg4647pm2a3s347dzj7qp29f6hkr0rqfmzp774zwhi";
+       sha256 = "11f24fceb9bf3a9c419ed0b8242e3ef2b743861e4ad47b88216f2647ad43f6e0";
        libraryHaskellDepends = [
          base containers pretty safe template-haskell text xml-types
        ];
@@ -114133,7 +114479,7 @@ self: {
      mkDerivation {
        pname = "roundtrip-aeson";
        version = "0.2.0.0";
-       sha256 = "0m96447l2m0y4aapil077xpnzlkjla0yp2bzajfijik9gkjbiih4";
+       sha256 = "04c6b8e47c6946199d547f89eb81a272d26f6f3f07d07895221e54410f212655";
        libraryHaskellDepends = [
          aeson base bytestring containers lens lens-aeson roundtrip
          scientific text unordered-containers vector
@@ -114153,7 +114499,7 @@ self: {
      mkDerivation {
        pname = "roundtrip-string";
        version = "0.1.0.1";
-       sha256 = "1lad64y877rf36dgldkc7qcg5xagjc00z4cf2r1ahamv379df8d7";
+       sha256 = "a721d7d219bb2aa842168e910f00934ff5f2183e6c36fa9a192e9f833c314dd1";
        libraryHaskellDepends = [ base mtl parsec roundtrip ];
        description = "Bidirectional (de-)serialization";
        license = stdenv.lib.licenses.bsd3;
@@ -114169,7 +114515,7 @@ self: {
      mkDerivation {
        pname = "roundtrip-xml";
        version = "0.3.0.5";
-       sha256 = "1gl649saiaj1biqda64wmpbnv5f3njm3rmfgvf1iavyliqgrwn9m";
+       sha256 = "35599e1f8ed46f1583dbcfd53caab4c3956dd7ad9c18d5705c41aaa8742286be";
        isLibrary = true;
        isExecutable = true;
        libraryHaskellDepends = [
@@ -114187,7 +114533,7 @@ self: {
      mkDerivation {
        pname = "route-generator";
        version = "0.6.1";
-       sha256 = "0bfrb3mz9nxrl4l5pikrp3x4igq4w9jlmvwikyc71ph8ks6rghc6";
+       sha256 = "86c1978d9e08de70989f91ef4a65e204bf48fab879c65b28a1b9dbf4eb58d92d";
        isLibrary = false;
        isExecutable = true;
        executableHaskellDepends = [
@@ -114206,7 +114552,7 @@ self: {
      mkDerivation {
        pname = "route-planning";
        version = "0.0.3";
-       sha256 = "0l3z9hjd8xqnahffg930qi13pf8cpiq44diqmpmh1narcllcbgj7";
+       sha256 = "47bec5286559d900ebad38364270bc0cb93b42c460a4e71c541677d4244c7f50";
        libraryHaskellDepends = [
          base containers coordinate lens semigroupoids semigroups text xsd
        ];
@@ -114224,7 +114570,7 @@ self: {
      mkDerivation {
        pname = "rowrecord";
        version = "0.1";
-       sha256 = "0gcrdy75f0rqfayn37frwcixb086x4s7dygphxhxbpvyl8sjnl0l";
+       sha256 = "14502b35a27edfd56187f7f97634e90681d523e3d99d61bd723803578e6f993d";
        libraryHaskellDepends = [ base containers template-haskell ];
        description = "Build records from lists of strings, as from CSV files";
        license = stdenv.lib.licenses.bsd3;
@@ -114238,7 +114584,7 @@ self: {
      mkDerivation {
        pname = "rpc";
        version = "0.0.1";
-       sha256 = "0bw92pmnkfq1azw08ygpmp1z856l3ybhmxkfhy4sfds769k2s4j9";
+       sha256 = "49122d66324737a789876ef60a971fd414f4c3adf77904f85701bb69eb15892f";
        libraryHaskellDepends = [
          base bytestring cereal containers derive network-fancy
          template-haskell th-lift
@@ -114255,7 +114601,7 @@ self: {
      mkDerivation {
        pname = "rpc-framework";
        version = "2.0.0.2";
-       sha256 = "0avjbw9zsa6nsjlwmb1lll0n80j9ggniwpy9sllaam83r6jpxhqq";
+       sha256 = "18c37ea5c90355a528d5c95f1eed7b49026401a534accaa9d4d628fd135f722b";
        isLibrary = true;
        isExecutable = true;
        libraryHaskellDepends = [
@@ -114276,7 +114622,7 @@ self: {
      mkDerivation {
        pname = "rpf";
        version = "0.2.5";
-       sha256 = "0x40j5rk8v61wzhcj730g75a97ikki7j22dfrh4z873b6mxwfh4k";
+       sha256 = "9340c77b356b1cf409ccae09214f9c339ea4ca79601cc9e0e7c16c3473918074";
        isLibrary = false;
        isExecutable = true;
        executableHaskellDepends = [
@@ -114293,7 +114639,7 @@ self: {
      mkDerivation {
        pname = "rpm";
        version = "0.0.1";
-       sha256 = "1wvaf1llcw4xcp8hmd80scqlk490qfiv5sqncpjmafw7zanrab4z";
+       sha256 = "9f2c95adfa873b55e56516ebb2a3c320914931d300b50ad1659d704669706af3";
        isLibrary = true;
        isExecutable = true;
        libraryHaskellDepends = [ base directory filepath HaXml process ];
@@ -114311,7 +114657,7 @@ self: {
      mkDerivation {
        pname = "rsagl";
        version = "0.6.0.1";
-       sha256 = "0f1f6kksrz1ghn6jhbdqsh4rhpkp65ccc4ci2fn5kmmw7qxzal59";
+       sha256 = "a950f53b3ebcd659ac139111c65831775e9809d4b82d288d852ffcace7342e38";
        libraryHaskellDepends = [
          array arrows base containers data-memocombinators deepseq mtl
          old-time OpenGL OpenGLRaw parallel parsec random rsagl-frp
@@ -114331,7 +114677,7 @@ self: {
      mkDerivation {
        pname = "rsagl-frp";
        version = "0.6.0.1";
-       sha256 = "0lim4slnhy1sq449kmvs489xy4axryn6qkk32hkzmlwvw8hqpl01";
+       sha256 = "01d08b21e29bd3fa2714634e6caccf5d11df13227ad79908c13a7868a9263552";
        libraryHaskellDepends = [
          array arrows base containers mtl old-time random rsagl-math stm
        ];
@@ -114349,7 +114695,7 @@ self: {
      mkDerivation {
        pname = "rsagl-math";
        version = "0.6.0.1";
-       sha256 = "04i1l6zb1jm784gdr86jrfm5m999px7ymzwwr5nyh69dk1730znn";
+       sha256 = "d67e304e982d19e86dc99cffea4fbf29a55aaacbd2a0dc1e41a7cab0bea12112";
        libraryHaskellDepends = [
          array base containers deepseq OpenGL OpenGLRaw parallel parsec
          random Vec Vec-OpenGLRaw
@@ -114366,7 +114712,7 @@ self: {
      mkDerivation {
        pname = "rspp";
        version = "0.1.0.0";
-       sha256 = "1rlx6hzw987jng2wmm2igfqlfym06wk8wxvqpb4v1zgqb00rabpc";
+       sha256 = "ec2e950158f8fdb0c9ba78778e2637a07a47b17b51d4cac5b3f2a0c43f349de6";
        libraryHaskellDepends = [ base ];
        jailbreak = true;
        homepage = "http://github.com/AJChapman/rspp";
@@ -114381,7 +114727,7 @@ self: {
      mkDerivation {
        pname = "rss";
        version = "3000.2.0.5";
-       sha256 = "0ydr6wqmac6bk3bn69fgay66rc2xap99jgz1gg5z09mhhv3bjmb1";
+       sha256 = "6155b9c686b026f0cb7be13f99d2555db06c8c57cf2563d798cb30553137b979";
        libraryHaskellDepends = [
          base HaXml network network-uri old-locale time
        ];
@@ -114399,7 +114745,7 @@ self: {
      mkDerivation {
        pname = "rss2irc";
        version = "1.0.6";
-       sha256 = "0gflfr97y2ypm9h5alm5c851pc0171p8wckdqdhr4wb6r844g8dw";
+       sha256 = "bca14708ca66719261c36d328e6e3801b01b0a62a5525560aad70b7f5276d43d";
        isLibrary = false;
        isExecutable = true;
        executableHaskellDepends = [
@@ -114420,7 +114766,7 @@ self: {
      mkDerivation {
        pname = "rtld";
        version = "0.0.2";
-       sha256 = "18y55lv3vyl4kpwzphw5gb1jsvp1f6i4dqh9rs6i9fyvabndvfik";
+       sha256 = "33baddec52dbbb148dce09e246a271e16e2dc37a85c3fbf99d84fa3d362dc5a3";
        libraryHaskellDepends = [ base ];
        homepage = "https://github.com/kkardzis/rtld";
        description = "dynamic linker tools for Haskell";
@@ -114432,7 +114778,7 @@ self: {
      mkDerivation {
        pname = "rtlsdr";
        version = "0.1.0.4";
-       sha256 = "090m8qsj9g0xr8ybyiik6vrc9j7bvgmgp42vznank3nklrmkxbgz";
+       sha256 = "ffad3e6ba6d38e6995fd5b90fbeadbebc8c4f2363346bf3cca1dbc2435461524";
        libraryHaskellDepends = [ base ];
        librarySystemDepends = [ rtl-sdr ];
        libraryToolDepends = [ c2hs ];
@@ -114448,7 +114794,7 @@ self: {
      mkDerivation {
        pname = "rtorrent-rpc";
        version = "0.2.2.0";
-       sha256 = "0k14m4r0zsalngb6c4dckr7z521mymabc0ihk0zz402l7s13n68s";
+       sha256 = "1a193b823e5400f23f983002b654f53588f24f9eac1166d6b354e90f32a9244c";
        libraryHaskellDepends = [
          attoparsec base blaze-builder blaze-textual bytestring deepseq haxr
          mtl network split utf8-string
@@ -114466,7 +114812,7 @@ self: {
      mkDerivation {
        pname = "rtorrent-state";
        version = "0.1.0.1";
-       sha256 = "0lh7plp9qwlya0dnfvz2sg8nhg42vnrypi2p8rh6i278glniwn90";
+       sha256 = "20591e2d7de88868604657c4ebb3dd823c68d1d3e26f671b509e729c2ebd0752";
        libraryHaskellDepends = [
          base bencoding bytestring containers directory filepath lens
          utf8-string
@@ -114485,7 +114831,7 @@ self: {
      mkDerivation {
        pname = "rubberband";
        version = "0.1.0.2";
-       sha256 = "15j402a7vwrx6sjn29jrby4qxc27c1aa4mkbalssn8jlpjhlpffm";
+       sha256 = "d5b94ba1bc5422ab35556b56a2546047b08e895f592661a5363df37d94004496";
        libraryHaskellDepends = [ base vector ];
        librarySystemDepends = [ rubberband ];
        libraryToolDepends = [ c2hs ];
@@ -114503,7 +114849,7 @@ self: {
      mkDerivation {
        pname = "ruby-marshal";
        version = "0.1.0";
-       sha256 = "1dmlgks7wfs82k9dxkgi35q4sa0a7ljpcw86j25k85vbclzpyp7j";
+       sha256 = "f25c7f3f656b17348b90067176253d0a284d7019f1cdded214483b7ef47cb4b6";
        libraryHaskellDepends = [
          base bytestring cereal containers mtl string-conv vector
        ];
@@ -114522,7 +114868,7 @@ self: {
      mkDerivation {
        pname = "ruby-qq";
        version = "0.1.0.0";
-       sha256 = "1d2a31kiiv0p8d2yygpg8mgrz0xy6zh5qnf49hz70yk2vavkcac1";
+       sha256 = "812936b7da627a703e4cc4595ce037be839f5f45ef3eef454317ec1867184ab4";
        libraryHaskellDepends = [
          base bytestring haskell-src-exts haskell-src-meta pcre-light
          process template-haskell trifecta
@@ -114538,7 +114884,7 @@ self: {
      mkDerivation {
        pname = "ruff";
        version = "0.4";
-       sha256 = "09gj31p5cbjdns7d2xs2s08kpaks0bqnhzbf93xypci6zr6gxvyl";
+       sha256 = "d4effe4cfe26b2ebfb486e7d68f1027aaa3b11d04277d18eb64d2e566e18f225";
        libraryHaskellDepends = [ array base mtl parsec safe strict Vec ];
        homepage = "https://gitorious.org/ruff";
        description = "relatively useful fractal functions";
@@ -114553,7 +114899,7 @@ self: {
      mkDerivation {
        pname = "ruler";
        version = "0.4.0.2";
-       sha256 = "1kcca2h3gvp63s9frnq4dmhaiw5pxhk5ji86bar0cwyrc9all8v5";
+       sha256 = "65234a5562d97306b25a06455926ecb7f0a8606d04dbec921ee6ee37a0508ccd";
        isLibrary = false;
        isExecutable = true;
        executableHaskellDepends = [
@@ -114571,7 +114917,7 @@ self: {
      mkDerivation {
        pname = "ruler-core";
        version = "1.0";
-       sha256 = "06c55pdfkh9vcmmzlf485d0qxczgd2xj1ajkz277df72p29xvrgd";
+       sha256 = "ede5dd93b8e2b8768ef853aa20bb68efb38e412b8838fa6b653bc1e9da2d8519";
        isLibrary = false;
        isExecutable = true;
        executableHaskellDepends = [
@@ -114588,7 +114934,7 @@ self: {
      mkDerivation {
        pname = "rungekutta";
        version = "1.0.2";
-       sha256 = "07drd0xvkg06p2fsbncafnr7wzkrs4m6sfs1szbbscggw3pxh4fp";
+       sha256 = "d711d8efe0ef31bdd6d7413b6d2ad1797e7eb2758ad9a59db806bcb93b68b91d";
        libraryHaskellDepends = [ base ];
        description = "A collection of explicit Runge-Kutta methods of various orders";
        license = stdenv.lib.licenses.bsd3;
@@ -114602,7 +114948,7 @@ self: {
      mkDerivation {
        pname = "runghc";
        version = "0.1.0.3";
-       sha256 = "1vn08xdisdf5l3ps6bcpg3rvl89209f3ig504w7ysqbjgdib96n0";
+       sha256 = "c09ab4627b7261ed0f27a0bc385c022221baf378972da3efa0c5351d5b47c0ee";
        isLibrary = false;
        isExecutable = true;
        executableHaskellDepends = [
@@ -114618,7 +114964,7 @@ self: {
      mkDerivation {
        pname = "runmemo";
        version = "1.0.0.1";
-       sha256 = "12fn0lsil0rj0pj0ixzppsdw2fmj0cnzci4fh11z9rcggwbz6pms";
+       sha256 = "ba5ef3177f8fe5f443808e44f62d03b23ac19bbef7f708e40532031a3505d689";
        testHaskellDepends = [ base data-memocombinators time ];
        homepage = "https://github.com/DanBurton/runmemo";
        description = "A simple memoization helper library";
@@ -114632,7 +114978,7 @@ self: {
      mkDerivation {
        pname = "rvar";
        version = "0.2.0.2";
-       sha256 = "1n24fl27mrm7cndp8b646b9c5hjm3hf5m12y9ni0f850dd739jm4";
+       sha256 = "a4ca344e6ba02007a24d5e845a1c1c55c2c2d232c42c749b65a7e67a047544d8";
        libraryHaskellDepends = [
          base MonadPrompt mtl random-source transformers
        ];
@@ -114646,7 +114992,7 @@ self: {
      mkDerivation {
        pname = "rwlock";
        version = "0.0.0.3";
-       sha256 = "0isx32ayaqh7vhcyl11ykdy8f1chs1fdw73h3c2r53k989yfkmba";
+       sha256 = "6ad5e97c42698e92051b701cde5cd09005877c9b3e04ea19dc0762e595185d47";
        libraryHaskellDepends = [ base monad-loops-stm stm syb ];
        homepage = "https://github.com/mokus0/rwlock";
        description = "Multiple-read / single-write locks";
@@ -114660,7 +115006,7 @@ self: {
      mkDerivation {
        pname = "rws";
        version = "0.1.1.2";
-       sha256 = "1ildbmnpdh8x25m6kjdc6506cjgngjmjhvrdfkrcwg5cdqcqs266";
+       sha256 = "c6088d196eac3ccef2742d6f28ab7cf649664031acc9696a111dc1766d5d8dc6";
        isLibrary = false;
        isExecutable = true;
        executableHaskellDepends = [ base binary bytestring parsec ];
@@ -114681,7 +115027,7 @@ self: {
      mkDerivation {
        pname = "s3-signer";
        version = "0.3.0.0";
-       sha256 = "15647fs38blg37s0407ybxlmzwdhmxz3sk914p21g90i2bw5gsc9";
+       sha256 = "89e957f81211a417c425214d3d7eafb0f15f695ffe0002f4198f2e34b43bc494";
        libraryHaskellDepends = [
          base base64-bytestring cryptohash http-types time utf8-string
        ];
@@ -114695,7 +115041,7 @@ self: {
      mkDerivation {
        pname = "safe";
        version = "0.3.9";
-       sha256 = "1jdnp5zhvalf1xy8i872n29nljfjz6lnl9ghj80ffisrnnkrwcfh";
+       sha256 = "d0319ea7b55947e70092f0256aa9f9d2496a93b0e2a0887c0f8eaa0d7fb9b6c9";
        libraryHaskellDepends = [ base ];
        homepage = "https://github.com/ndmitchell/safe#readme";
        description = "Library of safe (exception free) functions";
@@ -114707,7 +115053,7 @@ self: {
      mkDerivation {
        pname = "safe-access";
        version = "0.2.1.1";
-       sha256 = "0pijjy8ilq0spmanilmhqxkkrky7ldacxphz5ci8pvnw4g6y40z8";
+       sha256 = "e803e2cd23dcee8b222b1fdece54a3c7cf3c67c7b0d26855bd1a601a9197325e";
        libraryHaskellDepends = [ base mtl transformers ];
        jailbreak = true;
        homepage = "http://hub.darcs.net/thoferon/safe-access";
@@ -114720,7 +115066,7 @@ self: {
      mkDerivation {
        pname = "safe-failure";
        version = "0.5.0.2";
-       sha256 = "102fjardfdf9zy0vyalgq6m1l64356b0a0xaam49j31lqgfldaw7";
+       sha256 = "87ab46ddc3340c994855aa0305962983181aaac18f2abf81ffc935d7b2924e80";
        libraryHaskellDepends = [ base failure ];
        homepage = "http://www-users.cs.york.ac.uk/~ndm/safe/";
        description = "Library for safe functions (deprecated)";
@@ -114732,7 +115078,7 @@ self: {
      mkDerivation {
        pname = "safe-failure-cme";
        version = "0.1.0";
-       sha256 = "0np0gq6f9xvywdf2fz5cb43ji0r4c9aqk6gb5w80hwklxdy553gk";
+       sha256 = "f38d527ceb747208102feb998955622483280759ac7c275ce37ef7e40c7ee05a";
        libraryHaskellDepends = [
          base control-monad-exception safe-failure
        ];
@@ -114745,7 +115091,7 @@ self: {
      mkDerivation {
        pname = "safe-freeze";
        version = "0.2.1";
-       sha256 = "12mqgak0rla20n9b4m6ynx64bwr06njcr849csc0z0r573xw2v33";
+       sha256 = "636cc1fb3825830f986689a0cca43520f3454cb7de54b2920542d10ca67ab88a";
        libraryHaskellDepends = [ base indexed mtl vector ];
        jailbreak = true;
        homepage = "https://github.com/reinerp/safe-freeze";
@@ -114759,7 +115105,7 @@ self: {
      mkDerivation {
        pname = "safe-globals";
        version = "0.1.1";
-       sha256 = "0an3hy28fpdw3v5gjx13fbszzp4r2p65l8mgks0pdflscf2cwwv5";
+       sha256 = "6573ce84639aba76819eaf225acc1599dcfff5722374f9ca1ebc5d878487c32a";
        libraryHaskellDepends = [ base stm template-haskell ];
        description = "Safe top-level mutable variables which scope like ordinary values";
        license = stdenv.lib.licenses.bsd3;
@@ -114772,7 +115118,7 @@ self: {
      mkDerivation {
        pname = "safe-lazy-io";
        version = "0.1";
-       sha256 = "1hqw4i814sz94iqyj79jai8aa2mwmv0mrnfk8ggb0sdx4xqn784c";
+       sha256 = "8ca0637127bd69b0de43d3d95cc1aebc0aa55054321de97124e96b1250241cc3";
        libraryHaskellDepends = [
          base extensible-exceptions parallel strict-io
        ];
@@ -114788,7 +115134,7 @@ self: {
      mkDerivation {
        pname = "safe-plugins";
        version = "0.1";
-       sha256 = "1nxy70iig54098pzbi8mwc8412fj759y6ihmsdjsk6xlpy6bwx65";
+       sha256 = "c574be8cbfb49ba965d31546e35339d2894010e315c5f52f4a8094172338bedb";
        libraryHaskellDepends = [
          base directory filepath haskell-src-exts plugins Unixutils
        ];
@@ -114804,7 +115150,7 @@ self: {
      mkDerivation {
        pname = "safe-printf";
        version = "0.1.0.0";
-       sha256 = "19nw306q7xlj6s132qxlfskg67x6rx3zhsk2n6lbz2kryr7v99g6";
+       sha256 = "e6a5b44ff6798abfa8b1626af847cfa61ff3a676b46331823692f6830d18dca6";
        libraryHaskellDepends = [
          base haskell-src-meta template-haskell th-lift
        ];
@@ -114825,7 +115171,7 @@ self: {
      mkDerivation {
        pname = "safecopy";
        version = "0.8.5";
-       sha256 = "1r0v2276hynxkysyrdmy2334gwxgaz2v6j8g0hd5jzfj2kmnnmk9";
+       sha256 = "69566beb14d27d591a040f49b3c557aff347c610beb6ecb59fdd7a688e101be4";
        revision = "1";
        editedCabalFile = "9b7af1be25774add78e43c0f9a4f1fe55ce2a98fb00738400661835adf1672c0";
        libraryHaskellDepends = [
@@ -114848,7 +115194,7 @@ self: {
      mkDerivation {
        pname = "safeint";
        version = "0.5.3";
-       sha256 = "1xrdqylf4f6nk2rnpp0zyaj562cdn2wmf9skir21fbzkw1lzvq7j";
+       sha256 = "f2e0fd69e0f32f17448e532757b9b08d0953a4f21fdc6bb398d638e2a8c72df7";
        libraryHaskellDepends = [ base ghc-prim ];
        testHaskellDepends = [
          base HUnit QuickCheck test-framework test-framework-hunit
@@ -114866,7 +115212,7 @@ self: {
      mkDerivation {
        pname = "safer-file-handles";
        version = "0.11";
-       sha256 = "1jqw13drzj36gjvlaf9fqd4cj1dpy8psmgsdykag6krxvhq6p639";
+       sha256 = "69986b30dc3d4ff3d4f44dbfaa2ff2b705c948c32e3945b77c66c89fdb081ccb";
        libraryHaskellDepends = [
          base base-unicode-symbols explicit-iomodes pathtype
          regional-pointers regions transformers
@@ -114885,7 +115231,7 @@ self: {
      mkDerivation {
        pname = "safer-file-handles-bytestring";
        version = "0.3.0.1";
-       sha256 = "1fbhk5hmq9bpw556vz6w3vq5j380n5pzfgby6w4vrmwnn93y12b9";
+       sha256 = "6989e047b296d7bc09377e3df76fb1000d59f01edcfc6d4ae177255c619970b9";
        libraryHaskellDepends = [
          base bytestring explicit-iomodes-bytestring regions
          safer-file-handles transformers
@@ -114904,7 +115250,7 @@ self: {
      mkDerivation {
        pname = "safer-file-handles-text";
        version = "0.2.0.2";
-       sha256 = "14x0kig9dnjrksh7b4gmwdwqr045cqcqjgicvjckhf85jc8bcanm";
+       sha256 = "d52ab6109305393899dc2c3e89196685808c79e3f59175a09e59da965e9ca093";
        libraryHaskellDepends = [
          explicit-iomodes-text regions safer-file-handles text transformers
        ];
@@ -114920,7 +115266,7 @@ self: {
      mkDerivation {
        pname = "saferoute";
        version = "0.2.0.0";
-       sha256 = "00ykmy44paghgc3m731p1hh00zv11416pl2xil4cav7vrr43nb6h";
+       sha256 = "d02c3b48cefb6cc5088d5dd06b0209617f00200c378c53077bf0a94b88afd303";
        libraryHaskellDepends = [ base blaze-html containers text ];
        jailbreak = true;
        description = "A simple type-safe routing library";
@@ -114933,7 +115279,7 @@ self: {
      mkDerivation {
        pname = "sai-shape-syb";
        version = "0.3.4";
-       sha256 = "07g7qpf7avv5hnxykrh4x7qr8sx9mwwv4hbavnsqi1n7zy2z91a3";
+       sha256 = "4385f485ffc78688b5dd6a41b239afa96b94f1e904e6e9bb85656f75dcc5e71d";
        libraryHaskellDepends = [ base containers ghc ghc-syb-utils syb ];
        testHaskellDepends = [
          base containers ghc ghc-syb-utils HUnit syb
@@ -114952,7 +115298,7 @@ self: {
      mkDerivation {
        pname = "saltine";
        version = "0.0.0.4";
-       sha256 = "1n74qk8yb0ylj6gns68rak5g030yjsaycn96x0hvk1cx7qwym887";
+       sha256 = "07a1ea393e9d85b921e82659e695961e0cf0ca5419196d9f91d483e5d1c4e4d8";
        libraryHaskellDepends = [ base bytestring profunctors ];
        librarySystemDepends = [ libsodium ];
        testHaskellDepends = [
@@ -114970,7 +115316,7 @@ self: {
      mkDerivation {
        pname = "saltine-quickcheck";
        version = "0.1.0.1";
-       sha256 = "041286rsyzv67qqbbbd38fc9qqzmml0js4qr0rqhaljv8cf1sxnj";
+       sha256 = "d2761d1c435b5205710619132d01adf5639c9843a3adb5303e667fafb3412210";
        libraryHaskellDepends = [
          base bytestring bytestring-arbitrary hex QuickCheck saltine
        ];
@@ -114993,7 +115339,7 @@ self: {
      mkDerivation {
        pname = "salvia";
        version = "1.0.0";
-       sha256 = "1qcnhj3ifjqrkaw1ixqkwmv2br9w5dlk1mrrwgl73c3wxgin7gni";
+       sha256 = "d1be63e3eb7cb071e8e339d730692b3ce52576e513f718b89a194b17878496e1";
        libraryHaskellDepends = [
          base bytestring containers directory fclabels MaybeT-transformers
          monads-fd network old-locale process pureMD5 random safe
@@ -115014,7 +115360,7 @@ self: {
      mkDerivation {
        pname = "salvia-demo";
        version = "1.0.0";
-       sha256 = "0sfvx7hj0z2g57gs6l1s078z3a34hfgm4pfcb1qr1pvbc8lj3f1h";
+       sha256 = "30b82129626bdf907158cc5d529f8364a8f1d1013a50a3df294f7c20e1e9db69";
        isLibrary = true;
        isExecutable = true;
        libraryHaskellDepends = [
@@ -115037,7 +115383,7 @@ self: {
      mkDerivation {
        pname = "salvia-extras";
        version = "1.0.0";
-       sha256 = "1nfiak4nabxm27ddksaif1jdpwn7drbz25jrqk0bmyr5q6q70a51";
+       sha256 = "a12870b0c125fbbac0c45916f1576ec7f2db647051e9d9da11b52f65c954d1d9";
        libraryHaskellDepends = [
          base bytestring c10k clevercss fclabels filestore hscolour
          HStringTemplate monads-fd network old-locale pureMD5 salvia
@@ -115057,7 +115403,7 @@ self: {
      mkDerivation {
        pname = "salvia-protocol";
        version = "1.0.1";
-       sha256 = "0a49wjjhdhhlnrwfi6l2zn6jl7vynwyil6s6qzp1za7s5vji48vb";
+       sha256 = "6b2312e52efaa81feec7461b1a3db77e1f2a8dfd829ae878b614c206a5e48928";
        libraryHaskellDepends = [
          base bimap bytestring containers fclabels parsec safe split
          utf8-string
@@ -115076,7 +115422,7 @@ self: {
      mkDerivation {
        pname = "salvia-sessions";
        version = "1.0.0";
-       sha256 = "0cfl9xhawg16gkl18wfxpjysn312yb3q9bagmclrhqk3qzwxgb0h";
+       sha256 = "10acd7f9c763629829ab4fad84c7f2220cabbdbcdd7114e87c263cae604fd431";
        libraryHaskellDepends = [
          base containers fclabels MaybeT-transformers monads-fd pureMD5
          random safe salvia salvia-protocol stm time utf8-string
@@ -115094,7 +115440,7 @@ self: {
      mkDerivation {
        pname = "salvia-websocket";
        version = "1.0.0";
-       sha256 = "14sr5z5z9xjkf18z1srz6cgciyrhhs4zyl7a8pffxmb893a2gngl";
+       sha256 = "f4d927d44868d5eedc45ea50ff898630fbc81e333febf0517053f6f4cb2f5993";
        libraryHaskellDepends = [
          base bytestring fclabels monads-fd salvia salvia-protocol stm
          utf8-string
@@ -115110,7 +115456,7 @@ self: {
      mkDerivation {
        pname = "sample-frame";
        version = "0.0.3";
-       sha256 = "0ivj0bcnqqc805np62bdpvh8v4ykmw86ph5rp7k54bbv9wd31bsv";
+       sha256 = "5baf301a4f7b2d52e6b9b9c06b10afd3938de0be6d09736d0188616cd9027247";
        isLibrary = true;
        isExecutable = true;
        libraryHaskellDepends = [ base QuickCheck storable-record ];
@@ -115124,7 +115470,7 @@ self: {
      mkDerivation {
        pname = "sample-frame-np";
        version = "0.0.4";
-       sha256 = "1l7447xjxj98jx99b75hdfdjps6mcm293yhx0fjrqwxkz6anxv6d";
+       sha256 = "cdec6e95f9b3739ca5031dfa914465d5e82b9b6bb09c95529728c92efb21e4d0";
        libraryHaskellDepends = [ base numeric-prelude sample-frame ];
        homepage = "http://www.haskell.org/haskellwiki/Synthesizer";
        description = "Orphan instances for types from sample-frame and numericprelude";
@@ -115138,7 +115484,7 @@ self: {
      mkDerivation {
        pname = "samtools";
        version = "0.2.4.1";
-       sha256 = "00hm12wz6sqv0jn9v7vqxzvq1m7k8d4fdaw25x928ck7g95gk9id";
+       sha256 = "2da6f94a7a673224522f82abe64843f3d480f7ef789f9dac041b6bf3b9081502";
        isLibrary = true;
        isExecutable = true;
        libraryHaskellDepends = [ base bytestring seqloc vector ];
@@ -115161,7 +115507,7 @@ self: {
      mkDerivation {
        pname = "samtools-conduit";
        version = "0.1.1.0";
-       sha256 = "0s59ds9s8ghj8wq2cfnh2s865v8bmga53aqvcqf781iv9zvxbqmw";
+       sha256 = "bce2d5f74f3b06741c661bab51d4ab0bed629016d03a263047123ea4936ea968";
        isLibrary = true;
        isExecutable = true;
        libraryHaskellDepends = [
@@ -115183,7 +115529,7 @@ self: {
      mkDerivation {
        pname = "samtools-enumerator";
        version = "0.1.2.1";
-       sha256 = "0wk2m2av9fd5zvx29my4llbc8zqk1hrczfvnhrvd90qmw8p33r5m";
+       sha256 = "b5e4312ee21583d4768676bbcf320c137fc416a5c4d724fafea5b9b495a86272";
        libraryHaskellDepends = [
          base bytestring enumerator samtools transformers
        ];
@@ -115198,7 +115544,7 @@ self: {
      mkDerivation {
        pname = "samtools-iteratee";
        version = "0.2.2.1";
-       sha256 = "139cp03lm05s536gsf03in7lrsmiprs2x6vpr9vci4k0pq2pd06l";
+       sha256 = "d4807605be6092c876ca779b2e74beb1ea4c8f8d0338fdcc28ba804a07b82c8d";
        isLibrary = true;
        isExecutable = true;
        libraryHaskellDepends = [
@@ -115219,7 +115565,7 @@ self: {
      mkDerivation {
        pname = "sandi";
        version = "0.3.5";
-       sha256 = "19dfiph5rrxs4shpw286r4agcz739f6afw2wyrlkl66lpaaxjvl5";
+       sha256 = "856ed995bad4183a69f65c70a78c4be37cf614c906097ea126bae75ce08daea5";
        libraryHaskellDepends = [ base bytestring conduit exceptions ];
        testHaskellDepends = [
          base bytestring HUnit tasty tasty-hunit tasty-quickcheck tasty-th
@@ -115234,7 +115580,7 @@ self: {
      mkDerivation {
        pname = "sandlib";
        version = "0.0.2";
-       sha256 = "07wh6va4rpf6vvxnjqbmwfna3rg20ysjh2pnzylz6xzlayzq0pkx";
+       sha256 = "7d5e80bf57f477f3a9fff60a28b507e2e5a1ace3756169fbdec6dd4cd436901f";
        libraryHaskellDepends = [ base ];
        jailbreak = true;
        homepage = "http://github.com/regularlambda/sandlib";
@@ -115249,7 +115595,7 @@ self: {
      mkDerivation {
        pname = "sandman";
        version = "0.1.0.1";
-       sha256 = "184gsdrw10h345ic1bdcdnfaac5fhr6dx77db790fl1lff7z5s1g";
+       sha256 = "2fe8f28f73345007d259ed9cde4c86ae30a59c6dacadc062210382c073d38fa0";
        isLibrary = false;
        isExecutable = true;
        executableHaskellDepends = [
@@ -115266,7 +115612,7 @@ self: {
      mkDerivation {
        pname = "sarasvati";
        version = "0.3.0.0";
-       sha256 = "0x8d5n2mydhwl9h7vzk7nr58b2aym9xb21p4m21rfa6vy6r2n438";
+       sha256 = "68102bb2f1db289783a8e406b17aaa5e89854ab667fe7d60a21c365f852d0d75";
        libraryHaskellDepends = [ base deepseq portaudio ];
        jailbreak = true;
        homepage = "https://github.com/tokiwoousaka/Sarasvati";
@@ -115281,7 +115627,7 @@ self: {
      mkDerivation {
        pname = "sasl";
        version = "0.0.0.2";
-       sha256 = "02cv19vi8wfwzxhi33f32zihjqypxjz1x6j7ff70my2wffw95w26";
+       sha256 = "46f092b8735cf80a8e73479a1ebeecd76309e317c38d1161ffdc7114770a9b09";
        libraryHaskellDepends = [
          base base64-bytestring bytestring cryptohash monads-tf papillon
          simple-pipe
@@ -115297,7 +115643,7 @@ self: {
      mkDerivation {
        pname = "sat";
        version = "1.1.1";
-       sha256 = "1ia2asqnxzpyr9s4n488yy00388x0bfy8kwqjx17fap33jkjfi6p";
+       sha256 = "d74427a71ce32a774297984fe4dd021da10180f708114b74cafefe6eb15642c5";
        isLibrary = false;
        isExecutable = true;
        executableHaskellDepends = [ base ];
@@ -115314,7 +115660,7 @@ self: {
      mkDerivation {
        pname = "sat-micro-hs";
        version = "0.1.1";
-       sha256 = "1w09ccky9rhp1l5g3rxjp9ydfyn0cc7kxmhz922ngls4ywd1hbc4";
+       sha256 = "842d181af744d36785481fd63e0f63c07ad77cbab2e7f10a0d17e6e4276309f0";
        isLibrary = false;
        isExecutable = true;
        executableHaskellDepends = [
@@ -115333,7 +115679,7 @@ self: {
      mkDerivation {
        pname = "satchmo";
        version = "2.9.9";
-       sha256 = "134i2xd7fvdhx43a51486mb3szi6c604pqc6w3cxsic1ngm30jbw";
+       sha256 = "7c4930eab38145ddd9e086e14b8061267e3d56358884a206e9b06d775a17918c";
        libraryHaskellDepends = [
          array async base bytestring containers deepseq directory hashable
          lens memoize minisat mtl process transformers
@@ -115351,7 +115697,7 @@ self: {
      mkDerivation {
        pname = "satchmo-backends";
        version = "1.9.1";
-       sha256 = "1hyzwmhy0f4k60hqjbh9jl3qr4xw3rjgl8nz2gfcdvm5ad91bfdf";
+       sha256 = "aeb9155253a5eec6dc13df22fa641ebc938c0795092e8921309338e061e5dfc3";
        libraryHaskellDepends = [
          array base bytestring containers process satchmo timeit
        ];
@@ -115368,7 +115714,7 @@ self: {
      mkDerivation {
        pname = "satchmo-examples";
        version = "1.8.1";
-       sha256 = "1xvgamq53yfzcl1p9wbfyy7dlhxsnbj6pjpxgjkyycndgszc84w3";
+       sha256 = "8313c4be7ecd32efa77cfdca6be4b2ba43da8ef76ef1740365dff95170556ff7";
        isLibrary = false;
        isExecutable = true;
        executableHaskellDepends = [
@@ -115387,7 +115733,7 @@ self: {
      mkDerivation {
        pname = "satchmo-funsat";
        version = "1.4";
-       sha256 = "0nx0xlbwwcdhdd608akmiwzx8abrd5v4b411221rdl8fshqrbv34";
+       sha256 = "64ec9531d40ed196831021904576697929d43f8f752a044c6bb031ce17eda05b";
        libraryHaskellDepends = [
          array base containers funsat parse-dimacs satchmo
        ];
@@ -115402,7 +115748,7 @@ self: {
      mkDerivation {
        pname = "satchmo-minisat";
        version = "1.3";
-       sha256 = "1dwgj16l2zjqfmf92kpr695ycliwki6a38sxc06scvs6sv6wkc56";
+       sha256 = "a6b0c9cdd6466fa60d605da3a14c9c3c52e64b32f94e915c75587e414d908fb7";
        libraryHaskellDepends = [ base containers process satchmo ];
        homepage = "http://dfa.imn.htwk-leipzig.de/satchmo/";
        description = "minisat driver as backend for satchmo";
@@ -115415,7 +115761,7 @@ self: {
      mkDerivation {
        pname = "satchmo-toysat";
        version = "0.2.1.0";
-       sha256 = "1g6hzgdiiczwk87928xi42lv2swm218i9hs39f3zqpcp8r7fxh61";
+       sha256 = "c1c0ee4e46975dfc874b43c3145110956bb1a920b123910e9afcb318dbfbd0bc";
        libraryHaskellDepends = [
          array base containers satchmo toysolver
        ];
@@ -115433,7 +115779,7 @@ self: {
      mkDerivation {
        pname = "sbv";
        version = "4.4";
-       sha256 = "1914695yxyd3ag1z56dd88kz0p0zvl63255psd4bilzvdwlys6ls";
+       sha256 = "9a1aed296ffbd3b848d3b714310cdd1f5cf02742ad99f2c353a3f9ee4b3224a4";
        isLibrary = true;
        isExecutable = true;
        libraryHaskellDepends = [
@@ -115455,7 +115801,7 @@ self: {
      mkDerivation {
        pname = "sc3-rdu";
        version = "0.15";
-       sha256 = "0zrd9w3s535b2dpnmmrfg4i6jd9f4nh338x1cbggcw3pjyv8gk30";
+       sha256 = "60cc87b6977770f6de62a1a331a0252e356922792ed76a6f13ab8ca2074f2d7f";
        libraryHaskellDepends = [ base hsc3 hsc3-db ];
        homepage = "http://rd.slavepianos.org/t/sc3-rdu";
        description = "Haskell bindings to sc3-rdu (sc3 rd ugens)";
@@ -115470,7 +115816,7 @@ self: {
      mkDerivation {
        pname = "scalable-server";
        version = "0.2.2";
-       sha256 = "066ncvz6zid1j6d6j89m4k2hywq58p73z30dkqn2l1svlic7dmx6";
+       sha256 = "a6d77658a45b072a2c9e0d8c3fce4505730fc5243521699a91a1c56ffe66d618";
        libraryHaskellDepends = [
          attoparsec attoparsec-enumerator base blaze-builder BoundedChan
          bytestring enumerator mtl network network-enumerator
@@ -115486,7 +115832,7 @@ self: {
      mkDerivation {
        pname = "scaleimage";
        version = "0.1";
-       sha256 = "0alhi0zr2n97942wpnyzq8q62nd4nzjl0rdxaarr7psx6dd3h3nn";
+       sha256 = "d60e385a335ddf93b352bd6540e5b7a4596130c2dfdbcb05492759913f88902a";
        isLibrary = false;
        isExecutable = true;
        executableHaskellDepends = [ base filepath gd ];
@@ -115503,7 +115849,7 @@ self: {
      mkDerivation {
        pname = "scalpel";
        version = "0.2.1";
-       sha256 = "0lva7pi78ksbxcjd19dycn4ayxcma28wrjmx3x31hn01nvhsnqg0";
+       sha256 = "e061abe1b6015818461fbdcacc91509575af8865bea5d024eb4b4f74e23d6a53";
        libraryHaskellDepends = [
          base bytestring curl regex-base regex-tdfa tagsoup text
        ];
@@ -115518,7 +115864,7 @@ self: {
      mkDerivation {
        pname = "scan";
        version = "0.1.0.9";
-       sha256 = "0imc8zmg0d42pzbrxiyi8lqx5q24i73ajj3pmb3kqinfhm465jgv";
+       sha256 = "fbc9624885ce463cc7aa7748a9c68944e0d23145d1c79ed7bf8234f0ea47ac46";
        isLibrary = false;
        isExecutable = true;
        executableHaskellDepends = [ base parsec ];
@@ -115532,7 +115878,7 @@ self: {
      mkDerivation {
        pname = "scan-vector-machine";
        version = "0.2.7";
-       sha256 = "112ibzc205pjcmjiwbknw7pdh0c5fyq6i4sqk97jfdr0ynb72vvc";
+       sha256 = "6c6f7196f52037274f9a589368b0778501d8eee1762e1e6565f21620d85f5184";
        libraryHaskellDepends = [ accelerate array base dph-base HUnit ];
        testHaskellDepends = [ array base HUnit ];
        description = "An implementation of the Scan Vector Machine instruction set in Haskell";
@@ -115547,7 +115893,7 @@ self: {
      mkDerivation {
        pname = "scat";
        version = "1.1.0.1";
-       sha256 = "18sn7dg2pc5wx73gxs6036fxp8yal95pfh336llvmn3azmkd6n95";
+       sha256 = "2559d366fd6ad8ba29356340774ba2caa3db9d19c0e8fec6e9bcb02b5e3b56a3";
        isLibrary = false;
        isExecutable = true;
        executableHaskellDepends = [
@@ -115575,7 +115921,7 @@ self: {
      mkDerivation {
        pname = "scc";
        version = "0.8.2.2";
-       sha256 = "0rsx9h0y5g2sgwg47lzdzpmx5nfnpb033fyzz5xkxnc5k4bllad5";
+       sha256 = "a5294a179985d93e7bf9dfbb31c0bad6d9d2ebfdedd3431e7f5abce2014c5d67";
        isLibrary = true;
        isExecutable = true;
        libraryHaskellDepends = [
@@ -115606,7 +115952,7 @@ self: {
      mkDerivation {
        pname = "scenegraph";
        version = "0.1.0.2";
-       sha256 = "1l946h6sggg2n8ldx34v2sx4dyjqxd7i34wrsllz88iiy4qd90yw";
+       sha256 = "dc83d430f13122f429d59993114feb58fa46ba169b8cde28b2e2bda70d3424d1";
        libraryHaskellDepends = [
          array base containers fgl GLUT haskell98 hmatrix mtl old-time
          OpenGL process
@@ -115625,7 +115971,7 @@ self: {
      mkDerivation {
        pname = "scgi";
        version = "0.3.3";
-       sha256 = "0zmn5w5vwxv8slnydbrj1jfhmbvsyars2wf9bbrbgvwsfd40zd2m";
+       sha256 = "55b40f48739aefb7f25ac971a1b3f27aaf0a9d0c32afe62dd56877be0b2fb67e";
        libraryHaskellDepends = [
          base bytestring cgi extensible-exceptions network
        ];
@@ -115640,7 +115986,7 @@ self: {
      mkDerivation {
        pname = "schedevr";
        version = "0.1.0.6";
-       sha256 = "1ggywgyfpdza1fk66ixj8z3a1nv1r64dmw7l4d1m3h65yzxx9jcb";
+       sha256 = "8bc9d4fbf7c5c0514323f4f0da88c961dba0c647b24763a60beab7ebfce3febd";
        isLibrary = false;
        isExecutable = true;
        executableHaskellDepends = [
@@ -115660,7 +116006,7 @@ self: {
      mkDerivation {
        pname = "schedule-planner";
        version = "1.0.1.1";
-       sha256 = "1x42jm9fciwdp1khlvcw5vl748pw12n8xk4phbnd6iwqaazf9wv8";
+       sha256 = "68f3e4be529847d3ec8297cc8eac08fc2272e82e9c6d0a67b88d47e6529582f4";
        isLibrary = false;
        isExecutable = true;
        executableHaskellDepends = [
@@ -115676,7 +116022,7 @@ self: {
      mkDerivation {
        pname = "schedyield";
        version = "1.0";
-       sha256 = "0lzhxlfxa660vx4y49gbg2q76v8dda00h3rznj5fhdjj29pkypgp";
+       sha256 = "f75d3f6f125236e88ab43f0f08806a0d6d73b078eb25e249dfc018d51dedf053";
        libraryHaskellDepends = [ base ];
        jailbreak = true;
        description = "Exposes standard POSIX function sched_yield";
@@ -115698,7 +116044,7 @@ self: {
      mkDerivation {
        pname = "scholdoc";
        version = "0.1.3";
-       sha256 = "0dsbr4nk56cmbgdnk91s39lc4qp2wb39hkyisaf4f1n6nmx8zmn4";
+       sha256 = "c4d68f7ab5c606479cd2d14f98c6e2e262c2681a3aa469db5b9599322dc94b37";
        revision = "1";
        editedCabalFile = "bbe7070ca2ca48d86095c9a45120d2bfbf6a480b3894117d70e0f8e3ccabb435";
        isLibrary = true;
@@ -115738,7 +116084,7 @@ self: {
      mkDerivation {
        pname = "scholdoc-citeproc";
        version = "0.6";
-       sha256 = "0wy8cwr933zcqb85qscj9l9qcl2xv8mkbd2g9b4gs7c1k5b6khll";
+       sha256 = "94c2695699811dfdc84a4fb4352bda5d5086134d92695cd0c2ec8f913267c873";
        revision = "1";
        editedCabalFile = "33a066de8000d8bdb0a8f04f71baca64e27f4a2bb2d2a330f6d5a7f81090b118";
        isLibrary = true;
@@ -115772,7 +116118,7 @@ self: {
      mkDerivation {
        pname = "scholdoc-texmath";
        version = "0.1.0.1";
-       sha256 = "05yb55df33v357khdkr95ghmxqzikvq8gxqkh143zc8fi43gjf99";
+       sha256 = "2939f906890eb13f488013f787f09ef1e35ee12b29cf06e729638fe15a29cb17";
        isLibrary = true;
        isExecutable = true;
        libraryHaskellDepends = [
@@ -115795,7 +116141,7 @@ self: {
      mkDerivation {
        pname = "scholdoc-types";
        version = "0.1.3.1";
-       sha256 = "02335isa6w7mxjziiwsdm2883b778v0y0ayzxpha9p0xr5nlkbar";
+       sha256 = "59ad496dc91ddca4e0eddf2be0c146e7ac8190a84df318bfecf570a3742c6308";
        libraryHaskellDepends = [
          aeson base bytestring containers deepseq-generics ghc-prim syb
        ];
@@ -115810,7 +116156,7 @@ self: {
      mkDerivation {
        pname = "schonfinkeling";
        version = "0.1.0.0";
-       sha256 = "1wwbalfkfg66azr9zizscvdc2csi9q73d6wq5bwbiq33z522nwxy";
+       sha256 = "be732b44f963e0b8f82a989b360e4e5133c1da66fac79ff257c63c371d558bf3";
        libraryHaskellDepends = [ base ];
        description = "Transformation of n-ary functions to unary functions";
        license = stdenv.lib.licenses.bsd3;
@@ -115821,7 +116167,7 @@ self: {
      mkDerivation {
        pname = "sci-ratio";
        version = "0.2.1.0";
-       sha256 = "1qddamwk2fzakixx9f0y0r3z9z6kmyyxgpb3dhiiiza6krnf8r9k";
+       sha256 = "3365e46c9e46fd18236c63ddd7bdafd3fcf447061eb8d47b9cea3b317955ade1";
        libraryHaskellDepends = [ base hashable ];
        testHaskellDepends = [ base ];
        homepage = "https://github.com/Rufflewind/sci-ratio";
@@ -115834,7 +116180,7 @@ self: {
      mkDerivation {
        pname = "science-constants";
        version = "0.2.0.0";
-       sha256 = "0qp3d9la929kks2b2pyylgznl86gy91lp3zgpb9bn7gas3wll9vy";
+       sha256 = "7e274af9d0ea1dbbd2baef8f4b43f2cf206affa3de5fb1849e3389a4686ae362";
        libraryHaskellDepends = [ base ];
        jailbreak = true;
        description = "Mathematical/physical/chemical constants";
@@ -115846,7 +116192,7 @@ self: {
      mkDerivation {
        pname = "science-constants-dimensional";
        version = "0.1.0.1";
-       sha256 = "0n39pfs7kfhy62vl9q2ka5f9bfckncpssjsdx71d1hrld0jcq2g8";
+       sha256 = "e809cc246834c3d0c2e94d4bad2fb393b9955c5153e044b7301eba79b4bb6958";
        libraryHaskellDepends = [
          base dimensional numtype science-constants
        ];
@@ -115864,7 +116210,7 @@ self: {
      mkDerivation {
        pname = "scientific";
        version = "0.3.3.8";
-       sha256 = "0k6f9g3jpwhm52af4zayhdby8xibarn60mpxbb8xxgm78hmdw373";
+       sha256 = "e30cde2a44a7beded15afd56606c562b76e457835e7de2942815f22bc74bce4c";
        libraryHaskellDepends = [
          array base bytestring deepseq ghc-prim hashable integer-gmp text
        ];
@@ -115885,7 +116231,7 @@ self: {
      mkDerivation {
        pname = "scion";
        version = "0.1.0.2";
-       sha256 = "1ihq538ym6hh099p0h9p1ngjsq3a9h9k5ssnwyr4bqhlmv8xam0i";
+       sha256 = "1154d5d1ae14e245b2e756eb32134c6a602d9f0d3741705302109aead12818c6";
        isLibrary = true;
        isExecutable = true;
        libraryHaskellDepends = [
@@ -115916,7 +116262,7 @@ self: {
      mkDerivation {
        pname = "scion-browser";
        version = "0.5.0";
-       sha256 = "1nf4rvy8szxjra6l20jxd0v2f6zf985jiz2d1y5rkfvrqx1pwqnc";
+       sha256 = "cc627e43c779bb998b0f4dfc280b4aee1b2736685d02418dcab27f8dfccec4d9";
        isLibrary = true;
        isExecutable = true;
        libraryHaskellDepends = [
@@ -115946,7 +116292,7 @@ self: {
      mkDerivation {
        pname = "scons2dot";
        version = "0.9";
-       sha256 = "1c9akvpvwakdnqciz57bwjhqkdfkky43wmj7rx9fsk552pamzijk";
+       sha256 = "53c65fd515a54ced52cf47563e889fd3b589a1e4eb941f19b66d2abeef9e2ab1";
        isLibrary = false;
        isExecutable = true;
        executableHaskellDepends = [ base bytestring containers process ];
@@ -115963,7 +116309,7 @@ self: {
      mkDerivation {
        pname = "scope";
        version = "0.8.0.1";
-       sha256 = "1ks66paa30xwqgrllkyz0phh73pc0d2f6aq474cpz7gdb7zyrkzi";
+       sha256 = "f1cfecff59ed9d7f1939042be34403ec8e03e105df4f4af3c3bc83a1d43546cf";
        libraryHaskellDepends = [
          base bytestring containers iteratee MonadCatchIO-transformers mtl
          mwc-random time unix zoom-cache
@@ -115980,7 +116326,7 @@ self: {
      mkDerivation {
        pname = "scope-cairo";
        version = "0.8.0.1";
-       sha256 = "0dhpyf0kh6qrrcyr3iwp3i3rkj5vcl7k7aa9qmxq2qq1f6dhw4p6";
+       sha256 = "e6120e9b710163817bc549a9330f65bbc899471c97c7913dcb191b3881f31736";
        isLibrary = true;
        isExecutable = true;
        libraryHaskellDepends = [
@@ -116004,7 +116350,7 @@ self: {
      mkDerivation {
        pname = "scottish";
        version = "0.1.0.1";
-       sha256 = "01874r5r6lzwa7w0pa5i0ymnxb5vpkpxyfnf3knlyblv9b5j82nx";
+       sha256 = "dd0a24cb4a9b2e4fed1cce3adfefbcbbac6eab07b1a80bf851fc53934b260705";
        libraryHaskellDepends = [
          base data-default enclosed-exceptions http-types lens mtl
          persistent resource-pool scotty stm text transformers wai warp
@@ -116026,7 +116372,7 @@ self: {
      mkDerivation {
        pname = "scotty";
        version = "0.10.2";
-       sha256 = "0jlw82brnvc4cbpws0dq3qxn4rnb3z6rx6cfiarqwas14x4k3kl6";
+       sha256 = "86ce314927412b8eb38a8e999ecd1fcb66623b1eb801cdef62846d9b97409c4a";
        revision = "1";
        editedCabalFile = "e0ab23342583c37af1a5422fad9a64926e54cad208dbcac75c70b3db40bf9e99";
        libraryHaskellDepends = [
@@ -116051,7 +116397,7 @@ self: {
      mkDerivation {
        pname = "scotty-binding-play";
        version = "1.3";
-       sha256 = "0k9ylywhvb4nfnm304zlan0bzdx8rxcwnvip8assz80kz47zvjp9";
+       sha256 = "e9cafd0ff913a0afb542376ecb59cfa8b7bf8055f41330aa7596ac0db9a73e4d";
        libraryHaskellDepends = [
          base bytestring mtl scotty template-haskell text
        ];
@@ -116069,7 +116415,7 @@ self: {
      mkDerivation {
        pname = "scotty-blaze";
        version = "0.1.3";
-       sha256 = "0bl37bplal6y6ma0ba8llypsrx11959vcq04s8x6642hzk0cgid7";
+       sha256 = "a7c5c7c0fc5010633ad20460b6534921f4acafa714a9055435de5045ef3a832e";
        libraryHaskellDepends = [
          base blaze-builder blaze-html mtl scotty wai
        ];
@@ -116085,7 +116431,7 @@ self: {
      mkDerivation {
        pname = "scotty-cookie";
        version = "0.1.0.3";
-       sha256 = "0wyvx30889lbbgq7dmjfldlbnyg1b8b3zh1py5lis59mwz6r3w9l";
+       sha256 = "34f191cde735151d69f137c03f165ae179bb68a34ed676f05b8b2684c0e8db73";
        libraryHaskellDepends = [
          base blaze-builder bytestring containers cookie scotty text time
          transformers
@@ -116103,7 +116449,7 @@ self: {
      mkDerivation {
        pname = "scotty-fay";
        version = "0.1.1";
-       sha256 = "13ksxw2v6gac3r368ifnbrrgmmafr2fyki63ws4qxw415fwnqa82";
+       sha256 = "02296cb92b81f08e89e6c3c4e99dc84ed5fa725ed64564461e4c3db305ef7a8e";
        libraryHaskellDepends = [
          base bytestring data-default directory fay fay-jquery filepath
          http-types scotty text transformers wai
@@ -116126,7 +116472,7 @@ self: {
      mkDerivation {
        pname = "scotty-hastache";
        version = "0.2.1";
-       sha256 = "1yyip8iq1n71iidmpbfs7rifxvpphyrcaf4z394rx36hq72ka8dn";
+       sha256 = "b62135c5c1d08c9e491a9f38c5b287f7eeee623edaad5b5b8ce1d88023bad1fb";
        libraryHaskellDepends = [
          base containers filepath hastache http-types mtl scotty text wai
          warp
@@ -116145,7 +116491,7 @@ self: {
      mkDerivation {
        pname = "scotty-session";
        version = "0.0.5";
-       sha256 = "1jvxzsnprfp2k9svkzxykmpc3qs6dvzc0wnnircyimha4gca6qh7";
+       sha256 = "0762a3d8230ad6e8598ed672c0fe6e46e3c16e9dbeffb9759ae2ba7cadfe7dcb";
        libraryHaskellDepends = [
          base base64-bytestring blaze-builder bytestring crypto-api
          http-types scotty stm text time transformers unordered-containers
@@ -116162,7 +116508,7 @@ self: {
      mkDerivation {
        pname = "scotty-tls";
        version = "0.4.0";
-       sha256 = "1axr54s8zi9jw5y6yl2izjx4xvd25y18nh4fw7asq9fz0nwjb45a";
+       sha256 = "aa9025b905df25acd5e18e408b822fa2ed4ebafc51506f7ce132c58f3429b9ab";
        libraryHaskellDepends = [
          base scotty transformers wai warp warp-tls
        ];
@@ -116178,7 +116524,7 @@ self: {
      mkDerivation {
        pname = "scp-streams";
        version = "0.1.0";
-       sha256 = "1wi860cl9dsq6hfhyas3dk0gcjyd8hx62k3fjwgr5x56ps5fp6ry";
+       sha256 = "3e9beb8abea6f4921f976e4c613a44cd4bf6c06c432b0f1d3458b744193028f2";
        isLibrary = true;
        isExecutable = true;
        libraryHaskellDepends = [
@@ -116201,7 +116547,7 @@ self: {
      mkDerivation {
        pname = "scrabble-bot";
        version = "0.1.0.0";
-       sha256 = "035jpwp58l70jd0dklx5rg0sm8b2bd5r1m726dbhhlv60w6bdfn3";
+       sha256 = "c3bab60c076653085733e2d4904b5b62a1aac1cba5d3d94093e050542ebfb20c";
        isLibrary = false;
        isExecutable = true;
        executableHaskellDepends = [
@@ -116221,7 +116567,7 @@ self: {
      mkDerivation {
        pname = "scrobble";
        version = "0.2.1.1";
-       sha256 = "161l75bni4fxmh35dfz8r2vgllmmf0s55j9y2xpyskqfj3xc85a7";
+       sha256 = "4715c4fa900e4fed6f173ec9523470b552fab6c8e8bb5606acdd916857393498";
        isLibrary = true;
        isExecutable = true;
        libraryHaskellDepends = [
@@ -116245,7 +116591,7 @@ self: {
      mkDerivation {
        pname = "scroll";
        version = "1.20150323";
-       sha256 = "06nzvvqn592jgf93zck74w1nhzjq0llzypsy7x575ljvprb3ph0d";
+       sha256 = "0dc03b56be5bd2724a3f5e5fff2905587e68032767b23f927b52a462f1dedf1a";
        isLibrary = false;
        isExecutable = true;
        executableHaskellDepends = [
@@ -116267,7 +116613,7 @@ self: {
      mkDerivation {
        pname = "scrypt";
        version = "0.5.0";
-       sha256 = "1cnrjdq1ncv224dlk236a7w29na8r019d2acrsxlsaiy74iadh1y";
+       sha256 = "3ec0a622393e2a4dbbce4c899602c848d924f8516688491b1162331b7093d9b2";
        libraryHaskellDepends = [
          base base64-bytestring bytestring entropy
        ];
@@ -116290,7 +116636,7 @@ self: {
      mkDerivation {
        pname = "scrz";
        version = "0.0.0.1";
-       sha256 = "1j5mvvrk1647qfqdl4q6ywnx7l9bgnqp6rsjr1l8bynikfm0ghcg";
+       sha256 = "8fc107aa9bd1fa8568c8526773b17d2bd1d32df70613dab0c3879830f3deb5c8";
        isLibrary = false;
        isExecutable = true;
        executableHaskellDepends = [
@@ -116313,7 +116659,7 @@ self: {
      mkDerivation {
        pname = "scyther-proof";
        version = "0.10.0.1";
-       sha256 = "0c4djdr2lq6kbi726zmjicscsc2ksj4l787pzyj5lfbl9c11fb6j";
+       sha256 = "d22c17024b74395aa4fff7a04389d45330cd348bb27e234e5cd3602a72938d30";
        isLibrary = false;
        isExecutable = true;
        executableHaskellDepends = [
@@ -116333,7 +116679,7 @@ self: {
      mkDerivation {
        pname = "sde-solver";
        version = "0.1.0.0";
-       sha256 = "0sp12fcf1h4qs0l5iblf3kl6nv1sb4ff49p2ybmrx7jifiwqxma6";
+       sha256 = "46d58e7974519e9eebf2e226e21c593a6c6be81c8eae5828d098c0e09813e16a";
        libraryHaskellDepends = [
          base cereal cereal-vector ghc-prim haskell-mpi
          mersenne-random-pure64 mtl mwc-random normaldistribution parallel
@@ -116351,7 +116697,7 @@ self: {
      mkDerivation {
        pname = "sdf2p1-parser";
        version = "0.1.1";
-       sha256 = "1az42i4ridb4xza6zyg2mrsfv7gjp61727cmnfcy5x5b55nl3ahz";
+       sha256 = "1faa416d29abf4e299b3951d7182b9f29ded74aee2f96fd4ef64b5984914e4ab";
        libraryHaskellDepends = [ base bytestring parsec transformers ];
        testHaskellDepends = [
          base bytestring Cabal HUnit parsec test-framework
@@ -116367,7 +116713,7 @@ self: {
      mkDerivation {
        pname = "sdl2";
        version = "1.3.1";
-       sha256 = "17d3nmiz32hccbbxx55wa2zca8xn7mq3f02rcarzynqczvi5hlyv";
+       sha256 = "db5358e2fe0c5bffb362590037703db623c5be50bc94ded7620c8af163b5a39d";
        libraryHaskellDepends = [ base transformers ];
        librarySystemDepends = [ SDL2 ];
        libraryPkgconfigDepends = [ SDL2 ];
@@ -116380,7 +116726,7 @@ self: {
      mkDerivation {
        pname = "sdl2-image";
        version = "0.1.3.2";
-       sha256 = "0gps89yy4jzmlh5cdvs94mhmqlakqb99ldall3rirqdfhdv2wysj";
+       sha256 = "527b2e7683aee11cf3a054359ad2c253515c612549efc60aa4f54be27d42fa3e";
        libraryHaskellDepends = [ base sdl2 ];
        librarySystemDepends = [ SDL2 ];
        libraryPkgconfigDepends = [ SDL2 SDL2_image ];
@@ -116393,7 +116739,7 @@ self: {
      mkDerivation {
        pname = "sdl2-ttf";
        version = "0.2.1";
-       sha256 = "0w760xsb02n0j4bv7iigc810mwasgjf8lckrjqbipqvvq1am3l56";
+       sha256 = "a6d05155c07be31b179679328a9c7c5af10a02622fc6b31791c00ab07407e670";
        libraryHaskellDepends = [ base sdl2 ];
        librarySystemDepends = [ SDL2 SDL2_ttf ];
        testHaskellDepends = [ base sdl2 ];
@@ -116406,7 +116752,7 @@ self: {
      mkDerivation {
        pname = "sdnv";
        version = "0.1.0.0";
-       sha256 = "07d7989v4a8dz5jqrhz56ki9wkngaf1d0153271lylj015y00rmc";
+       sha256 = "ac66007c0940524fc311a304d08253cf4e9ee234e5c38c65f90d29b2134aa71d";
        libraryHaskellDepends = [ base binary bytestring ];
        description = "Self-delimiting numeric values encoding library";
        license = stdenv.lib.licenses.bsd2;
@@ -116423,7 +116769,7 @@ self: {
      mkDerivation {
        pname = "sdr";
        version = "0.1.0.3";
-       sha256 = "1whw45vnns0f5iw9vlmfxw90y3l0gp0q5yar6p6dp1dn57gyrdkc";
+       sha256 = "6cb6ecdf29b685dbcc3559f982c17d800e0f12efaed29d782c0e686b77211cf2";
        libraryHaskellDepends = [
          array base bytestring cairo cereal Chart Chart-cairo colour
          containers Decimal dynamic-graph either fftwRaw GLFW-b OpenGL
@@ -116451,7 +116797,7 @@ self: {
      mkDerivation {
        pname = "seacat";
        version = "1.0.0.3";
-       sha256 = "0iyl7mp0vpxy4kqr7qqqz642zxpla3ydlbdzmw4ipjmg5gwjr7pm";
+       sha256 = "f59e2cf92bafca1b09afbf2ddafc50f4f62f88f918e393f124bedf0d6e3dd447";
        libraryHaskellDepends = [
          base blaze-builder blaze-html bytestring ConfigFile data-default
          directory filepath http-types mime-types MissingH monad-control mtl
@@ -116471,7 +116817,7 @@ self: {
      mkDerivation {
        pname = "seal-module";
        version = "0.1.0.1";
-       sha256 = "0x2m280qbfaswr2gk26d26dwg2s3v1nk4n93zh2fh1ikpkw13dfq";
+       sha256 = "d8b511f8bc3306e804fc2359326dd8438bc79b11cd88f944e65ab98501125574";
        libraryHaskellDepends = [ base template-haskell ];
        description = "Template Haskell support for global configuration data";
        license = stdenv.lib.licenses.bsd3;
@@ -116484,7 +116830,7 @@ self: {
      mkDerivation {
        pname = "search";
        version = "0.1.0.1";
-       sha256 = "0w9pfyw33zrfjy70bwslbgyns1jswshzxcz71cgbfl4q5hjbmvkw";
+       sha256 = "7ceeba242c9850b71e0be7b3fea1e65a066dfd5b54f3058e972eff31b8773771";
        libraryHaskellDepends = [
          base ghc-prim profunctors semigroupoids tagged transformers
        ];
@@ -116501,7 +116847,7 @@ self: {
      mkDerivation {
        pname = "sec";
        version = "0.0.1";
-       sha256 = "1ryl0nm1a37r606xhxy6ykf3c8c1gml6gdqna428w8y3a2vg5q2v";
+       sha256 = "5be0f2b650c3238e045116b767687d812136dcf4c677d80d30f90c15aa05d4e7";
        libraryHaskellDepends = [ base template-haskell ];
        jailbreak = true;
        homepage = "http://github.com/urso/sec";
@@ -116514,7 +116860,7 @@ self: {
      mkDerivation {
        pname = "secdh";
        version = "0.2";
-       sha256 = "0qrb2g7dfhh2m3hwp39xlimbc3kinww279a58pah738gqnhmayrs";
+       sha256 = "3a7b55a1c50f8d03d54545a52338b7710eb66aa43d8dcbe1a80242d7ce132b63";
        isLibrary = true;
        isExecutable = true;
        libraryHaskellDepends = [ base containers ];
@@ -116530,7 +116876,7 @@ self: {
      mkDerivation {
        pname = "seclib";
        version = "1.1.0.2";
-       sha256 = "0jbgdd3mh126c3n0sblvd7rbcnnzrfyfajrj9xcsj7zi7jqvs8nw";
+       sha256 = "dc22bdb13cf11fa9594f324be5bccbdf5ab6f2699b2e0dec60460458476b6f49";
        libraryHaskellDepends = [ base ];
        jailbreak = true;
        description = "A simple library for static information-flow security in Haskell";
@@ -116547,7 +116893,7 @@ self: {
      mkDerivation {
        pname = "second-transfer";
        version = "0.6.0.0";
-       sha256 = "1w726qfbz86sicpg5apx5n767av61l3kn8fra7ban8f67amg3z7w";
+       sha256 = "fcfcf1aa3ac621abd651d9213b070d66ab638e2dfdaaf22e8bdaa0bf1c36e2f0";
        libraryHaskellDepends = [
          attoparsec base base16-bytestring binary bytestring clock conduit
          containers deepseq exceptions hashable hashtables hslogger http2
@@ -116576,7 +116922,7 @@ self: {
      mkDerivation {
        pname = "secret-santa";
        version = "0.1.0.0";
-       sha256 = "0qrc1jk2hhhhq0cq9h9g8pc2frjsb1m96h6sdj79m7km5dc2slm8";
+       sha256 = "a8522d582b759e9a8e6cda40936a585a6627d8452fc18419c0104228a60c2c63";
        isLibrary = false;
        isExecutable = true;
        executableHaskellDepends = [
@@ -116597,7 +116943,7 @@ self: {
      mkDerivation {
        pname = "secret-sharing";
        version = "1.0.0.3";
-       sha256 = "0q315gmfnhpzgi4r0p3li8vvrdl2a0xgh0gxdin6s3nkh6hjpbv2";
+       sha256 = "62af2ba181d30e6d6c6cfd01f83a5082b6bc378a745c90497cff42ebea2b6160";
        libraryHaskellDepends = [
          base binary bytestring dice-entropy-conduit finite-field polynomial
          vector
@@ -116616,7 +116962,7 @@ self: {
      mkDerivation {
        pname = "secrm";
        version = "0.0";
-       sha256 = "0hcf8mxl1br27764ha0gdf7jdl7zlxknbspqijw0jr6ws7hshxg9";
+       sha256 = "e975a8e1d1dc6409b88cf8ea6567a7ffd0268f6b0f2848cc3922af407b458e41";
        isLibrary = false;
        isExecutable = true;
        executableHaskellDepends = [ base haskell98 ];
@@ -116633,7 +116979,7 @@ self: {
      mkDerivation {
        pname = "secure-sockets";
        version = "1.2.9.2";
-       sha256 = "0ijizi76fzqamynwhyd3ppzy90bfvypmzbjr0v63ng2w0mwnrjlz";
+       sha256 = "9fca6c79055c3c3bcc0659ae5fafdf6e81e4ffbda379c8adaf0a7f674efc5146";
        libraryHaskellDepends = [
          base bytestring directory HsOpenSSL network process transformers
        ];
@@ -116647,7 +116993,7 @@ self: {
      mkDerivation {
        pname = "securemem";
        version = "0.1.9";
-       sha256 = "0dkhhjxa7njc3qbgvd5a23rkvr39vj2kn2a9nk6yjg7a8b2hvdpy";
+       sha256 = "feb60dc542ea3ce9cdb449093b85dc69e43df310aab4fd161e4cdaa3ba847036";
        libraryHaskellDepends = [
          base byteable bytestring ghc-prim memory
        ];
@@ -116663,7 +117009,7 @@ self: {
      mkDerivation {
        pname = "sednaDBXML";
        version = "0.1.2.5";
-       sha256 = "068yl4z0wb5kr7a7c7haah3z391mjqdzgxh5rg68rrjgvf7dczky";
+       sha256 = "7e7ed68edb4fe68ccccb05f6f71b9635a4f107540a1e76d4c9b32c0e3ea11e19";
        libraryHaskellDepends = [
          base bindings-DSL bytestring containers iteratee mtl text
        ];
@@ -116678,7 +117024,7 @@ self: {
      mkDerivation {
        pname = "select";
        version = "0.4.0.1";
-       sha256 = "180cj5m0bap1lb19s68icpn1dvk2s395cmlcc6dnwz3mpbj5alj0";
+       sha256 = "405255e4ba757c6e9b618c5656d2d062ee16ec6511199dc2a2e1aa056a910ca0";
        libraryHaskellDepends = [ base ];
        homepage = "http://nonempty.org/software/haskell-select";
        description = "Wrap the select(2) POSIX function";
@@ -116692,7 +117038,7 @@ self: {
      mkDerivation {
        pname = "selectors";
        version = "0.0.3.0";
-       sha256 = "1chs2d1j58y4r01231hh50gr4h0wnwsg9mardzq8ybqc6z6l32pr";
+       sha256 = "f98a41cd370c2f8ff06f59d5f434b71c40921f2810862102c8c4a32243131ab2";
        libraryHaskellDepends = [
          array base containers template-haskell text xml-conduit
        ];
@@ -116708,7 +117054,7 @@ self: {
      mkDerivation {
        pname = "selenium";
        version = "0.2.5";
-       sha256 = "0vr3d891pj947lv2grgbc83nm828gz9bbz6dp8mnf9bsji3ih7l7";
+       sha256 = "871e1847947a25672bbacdfcb5d27f48a06a0762ebe527363d24c91b126a236f";
        libraryHaskellDepends = [ base HTTP HUnit mtl network pretty ];
        description = "Test web applications through a browser";
        license = stdenv.lib.licenses.bsd3;
@@ -116723,7 +117069,7 @@ self: {
      mkDerivation {
        pname = "selenium-server";
        version = "0.1.0.0";
-       sha256 = "13bqzhia3z35174hzf2ipl4ga62mcvh7whvhwj5b8rsazgi259qf";
+       sha256 = "0ea722e2fb4a67b48ae470437ee0665518f508bd51b80fc90965fca122fc788d";
        libraryHaskellDepends = [
          base conduit directory filepath http-conduit
          http-conduit-downloader network process random regex-tdfa
@@ -116742,7 +117088,7 @@ self: {
      mkDerivation {
        pname = "selfrestart";
        version = "0.1.0";
-       sha256 = "100a427r8xjfv7fsh7khj3db9klqwnalfy33w23khxqp7k1bkq3n";
+       sha256 = "76e0b9c23c17773887e063784795e598ceb4da90701ea8ddd94e76948f200a80";
        libraryHaskellDepends = [ base directory executable-path unix ];
        homepage = "https://github.com/nh2/selfrestart";
        description = "Restarts the current executable (on binary change)";
@@ -116754,7 +117100,7 @@ self: {
      mkDerivation {
        pname = "selinux";
        version = "0.1.1";
-       sha256 = "1r0lwah32y3cza5jnihzwkl4wdk23qh7sgw6yzcajq7rjnzrf8qw";
+       sha256 = "1c2397bf95f960a9d8f7863f7d201e62364ee8e41f462b8bfa6c7831a0e214e4";
        libraryHaskellDepends = [ base unix ];
        librarySystemDepends = [ selinux ];
        homepage = "https://github.com/luite/selinux";
@@ -116768,7 +117114,7 @@ self: {
      mkDerivation {
        pname = "semaphore-plus";
        version = "0.1";
-       sha256 = "1349pzjs91xayx4dib520037mmgh4lvyc0wjx8h8yf492dvfbdkr";
+       sha256 = "79b6e5761389388f20ea9203e63725f0d57a0600a2acd848f7aa87a4e5bf898c";
        libraryHaskellDepends = [ base ];
        description = "Various concurrency abstractions built on top of semaphores";
        license = stdenv.lib.licenses.bsd3;
@@ -116781,7 +117127,7 @@ self: {
      mkDerivation {
        pname = "semi-iso";
        version = "1.0.0.0";
-       sha256 = "09hcg6hkyd4bnk0586gk4dzc76g64sx37jg0pz3jq87lrq8dzm5g";
+       sha256 = "afd4df10cef4202cc7bfe0c933ba26e699c37e23f31954c0b48b343fa1790c26";
        libraryHaskellDepends = [
          base lens profunctors semigroupoids transformers tuple-morph
        ];
@@ -116795,7 +117141,7 @@ self: {
      mkDerivation {
        pname = "semigroupoid-extras";
        version = "5";
-       sha256 = "0ciq1jnc0d9d8jph9103v04vphiz7xqa69a8f4dmmcf3bjsk6bhh";
+       sha256 = "102e33b55cc3b15a1b714825a3703f3fc2bb09d8038404af442d35c0ac0c3832";
        libraryHaskellDepends = [ base profunctors semigroupoids ];
        homepage = "http://github.com/ekmett/semigroupoid-extras";
        description = "Semigroupoids that depend on PolyKinds";
@@ -116809,8 +117155,8 @@ self: {
      }:
      mkDerivation {
        pname = "semigroupoids";
-       version = "5.0.0.2";
-       sha256 = "14q7284gq44h86j6jxi7pz1hxwfal0jgv6i2j1v2hdzqfnd8z5sw";
+       version = "5.0.0.3";
+       sha256 = "17dc07085806c6b8c79863f489f0ad534713578a529935b081691830bab4d292";
        libraryHaskellDepends = [
          base base-orphans bifunctors comonad containers contravariant
          distributive semigroups tagged transformers transformers-compat
@@ -116830,7 +117176,7 @@ self: {
      mkDerivation {
        pname = "semigroupoids-syntax";
        version = "0.0.1";
-       sha256 = "1r3byywgbcn82dq9xw4k9m5lgmhsgj02rxwmkrp4jwrjaax8v4zh";
+       sha256 = "f0938dba523273496e9e95f72c807c1ad6474b4d93f09e7013c8b2f5b8f76be4";
        libraryHaskellDepends = [
          base comonad containers contravariant distributive semigroupoids
          semigroups transformers
@@ -116851,7 +117197,7 @@ self: {
      mkDerivation {
        pname = "semigroups";
        version = "0.16.2.2";
-       sha256 = "0mzdv05yhrvnib62mwfwwj66fmyzs3axm0y5sn374ig2r113wzni";
+       sha256 = "d17e3e42c8e2457286d5c583dad5d0df57678ce4dcf12acc8a7667e80bd8ed57";
        libraryHaskellDepends = [
          base bytestring containers deepseq hashable nats text
          unordered-containers
@@ -116866,7 +117212,7 @@ self: {
      mkDerivation {
        pname = "semigroups-actions";
        version = "0.1";
-       sha256 = "0vns2vdchszw34i12s9rfl4cm76ympfrivpb397j2vzg2i7bghqb";
+       sha256 = "0bc3b74e14ef6f214f1aebee98ddadde9cca08753969112219fc6bc8da16da6e";
        libraryHaskellDepends = [ base containers semigroups ];
        jailbreak = true;
        homepage = "http://github.com/ppetr/semigroups-actions/";
@@ -116883,7 +117229,7 @@ self: {
      mkDerivation {
        pname = "semiring";
        version = "0.3";
-       sha256 = "1b56y5a45fha07rbqqjl6f5i2bw9pji97pagyjcn9bprzqfbiymy";
+       sha256 = "befab81cfef9ae6499f44fdd93a2bc892f118b335462bcf2010aba4254f1a6ac";
        isLibrary = true;
        isExecutable = true;
        libraryHaskellDepends = [ base Boolean containers monoids ];
@@ -116903,7 +117249,7 @@ self: {
      mkDerivation {
        pname = "semiring-simple";
        version = "0.2.1.0";
-       sha256 = "074wp8bn6jhx8jjp78dzjpy9bdwc2i1a1sp6qkqj689zvrhwfman";
+       sha256 = "5655c761de3f2123f1c4e6eaa042148cb795fc95bfa173a5441d4a6317ba9c1c";
        libraryHaskellDepends = [ base ];
        description = "A module for dealing with semirings";
        license = stdenv.lib.licenses.bsd3;
@@ -116916,7 +117262,7 @@ self: {
      mkDerivation {
        pname = "semver";
        version = "0.3.3.1";
-       sha256 = "1cf8dcxq4s479f826drncqc4hd07hv330zsipkrn0vc30sbkdlrn";
+       sha256 = "36d3369706836d60f3bc517f30c6860734481866363723904b8768823b6bc8b1";
        libraryHaskellDepends = [ attoparsec base deepseq text ];
        testHaskellDepends = [ base tasty tasty-hunit text ];
        homepage = "https://github.com/brendanhay/semver";
@@ -116929,7 +117275,7 @@ self: {
      mkDerivation {
        pname = "sendfile";
        version = "0.7.9";
-       sha256 = "0hnw1ym81cff49dwww19kgbs4s0kpandbvn6h5cml3y0p1nxybqh";
+       sha256 = "102fdf6db8c00f5a5981c6eed5acba1368a2d79b2970ce5b22ceb180aa0fdc42";
        libraryHaskellDepends = [ base bytestring network ];
        homepage = "http://hub.darcs.net/stepcut/sendfile";
        description = "A portable sendfile library";
@@ -116943,7 +117289,7 @@ self: {
      mkDerivation {
        pname = "sendgrid-haskell";
        version = "1.0";
-       sha256 = "0k5sbc4j9palfsp7ryap79scb50jhm0kzzq0lfa0r7py1pkx2ylp";
+       sha256 = "977ad1e70dfe9e0c94a300ff3f41851294c5743a57f97cae7654dd24095bba4c";
        libraryHaskellDepends = [
          aeson base bytestring containers exceptions http-conduit
          monad-control text transformers
@@ -116960,7 +117306,7 @@ self: {
      mkDerivation {
        pname = "sensenet";
        version = "0.1.0.0";
-       sha256 = "1yzh1ngfddybxwqybvdg7l5lgg85kmhqhdl3mzsnndvz2labphp1";
+       sha256 = "e1c2bb14157f376bf5af833688619d05bd470b3dafede531efcbb7e69e0df0fb";
        isLibrary = false;
        isExecutable = true;
        executableHaskellDepends = [
@@ -116981,7 +117327,7 @@ self: {
      mkDerivation {
        pname = "sentry";
        version = "0.1.0";
-       sha256 = "1kv4ldms739x4b2fbs6hjwy8bssrwv0kavn4jqdc2svzlfqxqsqx";
+       sha256 = "1d6bdcb1a37f6bc11a96c46e35c1e659eb853c97d0e8e5c4223d8da36ba364cf";
        isLibrary = true;
        isExecutable = true;
        libraryHaskellDepends = [
@@ -117001,7 +117347,7 @@ self: {
      mkDerivation {
        pname = "senza";
        version = "0.1";
-       sha256 = "0pl7dcs9w4dzzajlfnkrjl5kgsx8zdzzl5hvikh9v9djsmw2290h";
+       sha256 = "10242178d5b2a59de08c1b16fa7ffba8eb370b95795a47a5fabf119e346b875e";
        description = "None";
        license = stdenv.lib.licenses.bsd3;
        hydraPlatforms = stdenv.lib.platforms.none;
@@ -117014,7 +117360,7 @@ self: {
      mkDerivation {
        pname = "separated";
        version = "0.1.0";
-       sha256 = "18kb9c6l0ikhzy3kiw4pg5b7vcm42hhbkp693qyygpr74hzpi2h2";
+       sha256 = "028a783f2427dfe73d1ec9dcb92014a4b27d567997f03887ff7046400d4b6ba2";
        libraryHaskellDepends = [
          base bifunctors lens semigroupoids semigroups
        ];
@@ -117035,7 +117381,7 @@ self: {
      mkDerivation {
        pname = "seqaid";
        version = "0.4.0.0";
-       sha256 = "0kmzzxk1z10lqjawl0yqbv1n35b0bx41ikgiqii202m73khbg9qn";
+       sha256 = "16a7b7e01ca70a2062c4f1cd18485f609561c35ed803ca95c414841f66ffbf4e";
        isLibrary = true;
        isExecutable = true;
        libraryHaskellDepends = [
@@ -117058,7 +117404,7 @@ self: {
      mkDerivation {
        pname = "seqalign";
        version = "0.2.0.4";
-       sha256 = "01a3fhymyp7279hym03zzz6qkh5h47nq5y1xglar0n46imjr98af";
+       sha256 = "4ea194658d865890157d3df882ed21b0c089cdff7f80ea613ae25c5f3d744305";
        libraryHaskellDepends = [ base bytestring vector ];
        description = "Sequence Alignment";
        license = stdenv.lib.licenses.bsd3;
@@ -117069,7 +117415,7 @@ self: {
      mkDerivation {
        pname = "seqid";
        version = "0.1.0";
-       sha256 = "0q5vs8kravhiq906rrzi5iw5837bb8s6fibycgdracyfwrzvxly0";
+       sha256 = "c0d3be7fe6ce3395db637e4567345aeb0c54782cf1e76c40c2116e9527d2bb60";
        libraryHaskellDepends = [ base transformers ];
        jailbreak = true;
        description = "Sequence ID production and consumption";
@@ -117081,7 +117427,7 @@ self: {
      mkDerivation {
        pname = "seqid";
        version = "0.4.1";
-       sha256 = "0lfgw2fwizhid58aj4ncia8pqldzmkpzrmpgmvw51pgd0c25wjz0";
+       sha256 = "e04b5e0403eddd50f8aeefd6fcefacbf517c918acc12a9506911fec89de0cf51";
        libraryHaskellDepends = [ base mtl transformers ];
        description = "Sequence ID production and consumption";
        license = stdenv.lib.licenses.bsd3;
@@ -117092,7 +117438,7 @@ self: {
      mkDerivation {
        pname = "seqid-streams";
        version = "0.1.0";
-       sha256 = "13g0c76lyl3b4qdznpyr2a3szjb1dch2bsvgyv68br94045fk6d2";
+       sha256 = "a299e90a0124e585ccf66feb25206b61c9af8712d95ffb1b266b504fcd61e08d";
        libraryHaskellDepends = [ base io-streams seqid ];
        jailbreak = true;
        description = "Sequence ID IO-Streams";
@@ -117104,7 +117450,7 @@ self: {
      mkDerivation {
        pname = "seqid-streams";
        version = "0.4.0";
-       sha256 = "05h2878dlrnlv66lsf41bngk4w9nwqviq4jl3bj0wdhcdvy9d9il";
+       sha256 = "34a696fc6e0c360ee41a54121c37e63671329f5d81384d8dd9d466dad0410216";
        libraryHaskellDepends = [ base io-streams seqid ];
        jailbreak = true;
        description = "Sequence ID IO-Streams";
@@ -117118,7 +117464,7 @@ self: {
      mkDerivation {
        pname = "seqloc";
        version = "0.6.1.1";
-       sha256 = "1hsm9y6q0g7ixnqj562a33lmyka4k7f778fndcmn25v4m1myfda4";
+       sha256 = "4435e76ba86417612b6bd6a173dc99444d5fe9184a9822b1edf13c808d4f55c3";
        libraryHaskellDepends = [
          attoparsec base biocore bytestring hashable unordered-containers
          vector
@@ -117142,7 +117488,7 @@ self: {
      mkDerivation {
        pname = "seqloc-datafiles";
        version = "0.4.2";
-       sha256 = "175nifix2vax5xsinz604mm3nid7krh5a9d7gqpy02wh4f5qdrja";
+       sha256 = "4ae6868b23900be02f7ea72555609ea7453b6a25c07c1b752f5d6dd1a38bb69c";
        isLibrary = true;
        isExecutable = true;
        libraryHaskellDepends = [
@@ -117172,7 +117518,7 @@ self: {
      mkDerivation {
        pname = "sequence";
        version = "0.9.8";
-       sha256 = "0ayxy0lbkah90kpyjac0llv6lrbwymvfz2d3pdfrz1079si65jsh";
+       sha256 = "50cb62a24e07849f5dbba389ef76f57c656a36a58029e9ef0409aab928f0dd2b";
        libraryHaskellDepends = [ base containers transformers ];
        homepage = "https://github.com/atzeus/sequence";
        description = "A type class for sequences and various sequence data structures";
@@ -117184,7 +117530,7 @@ self: {
      mkDerivation {
        pname = "sequent-core";
        version = "0.5.0.1";
-       sha256 = "1q9rrr0nrnnhdv2jwpwjs1r98g3xdbqi7sfj7zsv1dykzalmc2nd";
+       sha256 = "cd0a56a9fad3b7b0f53fd2e913f16a7d3c9472d0925f2ec56ed0da6c41ce39e1";
        isLibrary = true;
        isExecutable = true;
        libraryHaskellDepends = [
@@ -117202,7 +117548,7 @@ self: {
      mkDerivation {
        pname = "sequential-index";
        version = "0.2.0.1";
-       sha256 = "0vd7nrkx59vsxrhpb46kgzbvz7v830wh5zx3vg9494wvski983y6";
+       sha256 = "c60f94e2d49b9344d2dba3ff023918689fbfd77fd3907561ee7aa7d267b6a76d";
        libraryHaskellDepends = [ base bytestring ];
        homepage = "https://github.com/aristidb/sequential-index";
        description = "Sequential numbers that allow arbitrarily inserting numbers - for containers";
@@ -117216,7 +117562,7 @@ self: {
      mkDerivation {
        pname = "sequor";
        version = "0.7.2";
-       sha256 = "1m41yk7bgazl9g30im8qvnvzjh4f4kvrd6jhk1wz2r31xxlxp7ms";
+       sha256 = "ba9edb69ef6164f17998509a96f7248e40f9b7dd18d508c64bf4abb7cef481d4";
        isLibrary = true;
        isExecutable = true;
        libraryHaskellDepends = [
@@ -117240,7 +117586,7 @@ self: {
      mkDerivation {
        pname = "serf";
        version = "0.1.1.0";
-       sha256 = "0ry0shqmazxcsjxsh6amvz2fky2fy3wwlck7d331j8csz7fwdjfn";
+       sha256 = "d6c9c6ddf99a2119c6686732caf9f04ef8e9c4df5519a8bbd4ac7f5531d4c067";
        libraryHaskellDepends = [
          attoparsec base conduit conduit-extra mtl operational process
          resourcet text
@@ -117255,7 +117601,7 @@ self: {
      mkDerivation {
        pname = "serial";
        version = "0.2.7";
-       sha256 = "1h52h8i28bhamp57q57ih1w9h26ih9g1l25gg9rhiwv5ykhy2vfq";
+       sha256 = "d86de1e1f465f308737aaf081a5e82d108987880f1147ccaad0a2e242282a2c0";
        libraryHaskellDepends = [ base unix ];
        description = "POSIX serial port wrapper";
        license = "LGPL";
@@ -117268,7 +117614,7 @@ self: {
      mkDerivation {
        pname = "serial-test-generators";
        version = "0.1.3";
-       sha256 = "0crivy8j3jnlm2vpbvfqgvmr6afwyg3lkzaj7jl0j6vgvq16xyas";
+       sha256 = "5af96e02de6f1b09a83c52fd49c7f3dc2993eb7ed8ed75b7a8d4ca2191df3133";
        libraryHaskellDepends = [
          aeson base binary bytestring cereal here
        ];
@@ -117285,7 +117631,7 @@ self: {
      mkDerivation {
        pname = "serialport";
        version = "0.4.7";
-       sha256 = "1z2drw7ighyws72wqms015n5hy0zxbrphdca7ldn34pz28122z07";
+       sha256 = "077c210212ff92611b3d8a3578f3ea1f78586c094057ccc5d1dcc3170fcf4dfc";
        libraryHaskellDepends = [ base bytestring unix ];
        testHaskellDepends = [ base bytestring HUnit ];
        homepage = "https://github.com/jputcu/serialport";
@@ -117303,7 +117649,7 @@ self: {
      mkDerivation {
        pname = "servant";
        version = "0.4.4";
-       sha256 = "1v0n194gj2cy16scfgs94q2vcb2baryp0rl1s21zwww1kfgmpffj";
+       sha256 = "d2b95b9f9b8173fe83d08166707d564b2cb60526493fc7b4099e09f9480a16ec";
        libraryHaskellDepends = [
          aeson attoparsec base bytestring bytestring-conversion
          case-insensitive http-media http-types network-uri
@@ -117326,7 +117672,7 @@ self: {
      mkDerivation {
        pname = "servant-JuicyPixels";
        version = "0.1.0.0";
-       sha256 = "1fnlyk6848nzby0nxdrvm4d0vvisdx6pmlzjnh6y1q5q8wq4m48j";
+       sha256 = "12914a3047b8e0e00db4f2d37a4d6f3aee0d1aa93bb76e815fdf2282ccf4d4ba";
        isLibrary = true;
        isExecutable = true;
        libraryHaskellDepends = [
@@ -117345,7 +117691,7 @@ self: {
      mkDerivation {
        pname = "servant-blaze";
        version = "0.4.4";
-       sha256 = "140sgy7hcp6pxjrh7zk5i59sq79swqgg76gakgdnvkg7zz0a150s";
+       sha256 = "1a94a0c0ffe7cd6ddb9bea99f31ee63a1dac538965fe03b3ecd75c068f7f1a90";
        libraryHaskellDepends = [ base blaze-html http-media servant ];
        homepage = "http://haskell-servant.github.io/";
        description = "Blaze-html support for servant";
@@ -117362,7 +117708,7 @@ self: {
      mkDerivation {
        pname = "servant-client";
        version = "0.4.4";
-       sha256 = "0m5aw8pb6iga2rf8m3mnx58xh6jnh33rvvkdzbmb3s6vplsqh6vz";
+       sha256 = "7f1b8835bddbe8b1eafa6dee9dc780561ad851e9b68e8a5c16ea45b32ee2aa54";
        libraryHaskellDepends = [
          aeson attoparsec base bytestring either exceptions http-client
          http-client-tls http-media http-types network-uri safe servant
@@ -117386,7 +117732,7 @@ self: {
      mkDerivation {
        pname = "servant-docs";
        version = "0.4.4";
-       sha256 = "0kp5346jxakjz8x92wvayz7c3f2xcvnpsgg9dxgb41imvww2pyfc";
+       sha256 = "ccf92b38df3506b25e6fe93d7ded665db8c1cef76a73913afa72aa2e0d19e54e";
        isLibrary = true;
        isExecutable = true;
        libraryHaskellDepends = [
@@ -117415,7 +117761,7 @@ self: {
      mkDerivation {
        pname = "servant-ede";
        version = "0.5";
-       sha256 = "0lq9kd96lzkyx35n46q0yxk44lirpnh9gv4wji8i8qjqf18fkg6c";
+       sha256 = "ccbce9507058621451949cec97a0bd39524266f7001b62cbe87e7e6a529b0953";
        isLibrary = true;
        isExecutable = true;
        libraryHaskellDepends = [
@@ -117440,7 +117786,7 @@ self: {
      mkDerivation {
        pname = "servant-examples";
        version = "0.4.4";
-       sha256 = "1qzrlkqwfv4w7d3sjbvz3s4kgx0x6zn0hh07hm955vvlfksgwjym";
+       sha256 = "d54bfef47474ef525285074008ec371df437891e7f2fa9473b9c6cc7f1a4f9e3";
        isLibrary = false;
        isExecutable = true;
        executableHaskellDepends = [
@@ -117462,7 +117808,7 @@ self: {
      mkDerivation {
        pname = "servant-jquery";
        version = "0.4.4";
-       sha256 = "04j2cnxrx2hljxnha94nbmql61zw3apz7n32mf23vf749svjcmvd";
+       sha256 = "6d5726b74ee4b83d84ab62d8f3af1afc0743715d9624056d97148a9ebb654212";
        isLibrary = true;
        isExecutable = true;
        libraryHaskellDepends = [ base charset lens servant text ];
@@ -117482,7 +117828,7 @@ self: {
      mkDerivation {
        pname = "servant-lucid";
        version = "0.4.4";
-       sha256 = "1vy9vdd1jkvx7nzcw6a83az4p351ds98x7wasn496h3bwk23bbhr";
+       sha256 = "19ae35c4e46b409388d58a9f8e926ea18c4bbe1a4819cebe3d7d4f195adbc9ef";
        libraryHaskellDepends = [ base http-media lucid servant ];
        homepage = "http://haskell-servant.github.io/";
        description = "Servant support for lucid";
@@ -117496,7 +117842,7 @@ self: {
      mkDerivation {
        pname = "servant-pandoc";
        version = "0.4.1.1";
-       sha256 = "00clyv651fyz0dx9b4g5c0z5z3bgybgg93x4s1b1lciwsin8i6nk";
+       sha256 = "d39a886cd43c321a56d0a48ff4def26f8d5f3e60e591957a03dfbb50ccf69401";
        revision = "1";
        editedCabalFile = "ee2eff37865c8a5c246021f6d05aae5f075ba5910cac6d650312aafb2f4bf091";
        libraryHaskellDepends = [
@@ -117512,7 +117858,7 @@ self: {
      mkDerivation {
        pname = "servant-pool";
        version = "0.1";
-       sha256 = "0if4lxb0fpdd4lnkz9j7z6vhjbrcc80pvz9jb6sdb9p6sbbgqf69";
+       sha256 = "c938fcd6d2e6a6d5b45932fd7d01622c2f09b7f947a63f2d25ad5d0756a7c445";
        libraryHaskellDepends = [ base resource-pool servant time ];
        homepage = "http://github.com/zalora/servant-pool";
        description = "Utility functions for creating servant 'Context's with \"context/connection pooling\" support";
@@ -117527,7 +117873,7 @@ self: {
      mkDerivation {
        pname = "servant-postgresql";
        version = "0.1";
-       sha256 = "1svy1v6sl5pq0zs8ms4qf7wn6zar63bqmfiyfqgz84ryli0wxrhj";
+       sha256 = "12e6ce41a43e13f41f763eba8ad730597d63f97198e88af407f816aacd0e7eeb";
        libraryHaskellDepends = [
          base bytestring postgresql-simple servant servant-pool
          servant-response
@@ -117543,7 +117889,7 @@ self: {
      mkDerivation {
        pname = "servant-response";
        version = "0.1";
-       sha256 = "0vgzi6nm3f1vjbnvhzcr6v2fh75fsl18wsps54ya0mbmfn2v6chy";
+       sha256 = "1e32b385757555a03c29fa6a8e02d5ae1ce8c436997db8ed923bb851ad89ff6d";
        libraryHaskellDepends = [ aeson base http-types text ];
        homepage = "http://github.com/zalora/servant";
        description = "Machinery to express how servant should turn results of database operations into proper JSON-encodable response types";
@@ -117557,7 +117903,7 @@ self: {
      mkDerivation {
        pname = "servant-scotty";
        version = "0.1.1";
-       sha256 = "0d3yc7aa2p1izizqnj81iscj9hbgbkpyav1ncmxzkr48svr6h783";
+       sha256 = "031d68f2d688e4f97b65366ce5ef5c6fc124998e01498b7ffc315ca1d4617e34";
        libraryHaskellDepends = [
          aeson base http-types scotty servant servant-response text
          transformers
@@ -117579,7 +117925,7 @@ self: {
      mkDerivation {
        pname = "servant-server";
        version = "0.4.4";
-       sha256 = "0byxply71jv558bs33i1j9whrfgfa1iygdjsxap7wiq9f27iyaa9";
+       sha256 = "49291f8f7009477eaeea5ab6e76350eeb90c7992218ea1172a65cb703cbddd2f";
        isLibrary = true;
        isExecutable = true;
        libraryHaskellDepends = [
@@ -117607,7 +117953,7 @@ self: {
      mkDerivation {
        pname = "serversession";
        version = "1.0.1";
-       sha256 = "08j8v6a2018bmvwsb7crdg0ajak74jggb073pdpx9s0pf3cfzyrz";
+       sha256 = "3ffbefd87017e8d46fbbe380f59e24672aa9c06b999da5f9ae0b052094d94822";
        libraryHaskellDepends = [
          aeson base base64-bytestring bytestring data-default hashable nonce
          path-pieces text time transformers unordered-containers
@@ -117629,7 +117975,7 @@ self: {
      mkDerivation {
        pname = "serversession-backend-acid-state";
        version = "1.0.1";
-       sha256 = "1hc5vpy82pxd0wlzabw3md4gvhxbnvs8wsa0wammni2a1pf123a7";
+       sha256 = "470d11dc0d4a445babe240698ef4b6abc3fd48ab832ff52907ad5f81fcdd85c1";
        libraryHaskellDepends = [
          acid-state base containers mtl safecopy serversession
          unordered-containers
@@ -117653,7 +117999,7 @@ self: {
      mkDerivation {
        pname = "serversession-backend-persistent";
        version = "1.0.1";
-       sha256 = "0n4l2hgfzlg1ra4blq6dcp61mvcfm6k8cwafi6rrzid67amr022k";
+       sha256 = "530890ab3aa6c59fb3894e7186a6a98eed1acc65cd60ba88cae1d1ef1e149458";
        libraryHaskellDepends = [
          aeson base base64-bytestring bytestring cereal path-pieces
          persistent serversession tagged text time transformers
@@ -117678,7 +118024,7 @@ self: {
      mkDerivation {
        pname = "serversession-backend-redis";
        version = "1.0";
-       sha256 = "0r1zr25zw80s4psscdwscf7wlm8qfw4dyk0kkczzvj5434jnxnj2";
+       sha256 = "42da6e2519a4c8fd3f9b134cdf08771855ca8f639a37a6f5251a20fe8bc83f64";
        libraryHaskellDepends = [
          base bytestring hedis path-pieces serversession tagged text time
          transformers unordered-containers
@@ -117700,7 +118046,7 @@ self: {
      mkDerivation {
        pname = "serversession-frontend-snap";
        version = "1.0";
-       sha256 = "1n29c3jfv61fz9kfc4zjwj7df1fll74l2kqccxmg4id8jpsrywci";
+       sha256 = "91719ff595a845f26a670c4f41c9a1d405d78ee4f213e666fa2e98ede46049d8";
        libraryHaskellDepends = [
          base bytestring nonce path-pieces serversession snap snap-core text
          time transformers unordered-containers
@@ -117718,7 +118064,7 @@ self: {
      mkDerivation {
        pname = "serversession-frontend-wai";
        version = "1.0";
-       sha256 = "0rxifhjirhmhk1x14m6lvpv6dl32g179i4i3xi3dq59r7l716j0b";
+       sha256 = "0b48130e3d3915dc46ec2392984e7862d066f6ddd454127a98b0c21c2574b167";
        libraryHaskellDepends = [
          base bytestring cookie data-default path-pieces serversession text
          time transformers unordered-containers vault wai wai-session
@@ -117736,7 +118082,7 @@ self: {
      mkDerivation {
        pname = "serversession-frontend-yesod";
        version = "1.0";
-       sha256 = "0lv7gkj4inks98g44n5kqvx5s4c66lmxf7gqfdly54znggglcf86";
+       sha256 = "063946df7bf693e26973f81dd72b3586115dfac6b358421e4a7ada48e47c6753";
        libraryHaskellDepends = [
          base bytestring containers cookie data-default path-pieces
          serversession text time transformers unordered-containers wai
@@ -117756,7 +118102,7 @@ self: {
      mkDerivation {
        pname = "servius";
        version = "1.1.1.2";
-       sha256 = "02c570ghvrp0qw2s6k30548k619424p77bpi1mfh02yrv1a45jdk";
+       sha256 = "b3c94254d8d90b005d0df1ae732e112405331129604ca305c7e0e60d1f388509";
        isLibrary = false;
        isExecutable = true;
        executableHaskellDepends = [
@@ -117778,7 +118124,7 @@ self: {
      mkDerivation {
        pname = "ses-html";
        version = "0.3.0.0";
-       sha256 = "1clf24kyyp9b8r22bacp44q0gf83zr6k1b33dz4bfy935wbnlshy";
+       sha256 = "1e6a6a172f2379b7c86f63ac304dfe03b907302197a92544462b5def27118eb2";
        libraryHaskellDepends = [
          base base64-bytestring blaze-html byteable bytestring cryptohash
          HsOpenSSL http-streams tagsoup time
@@ -117794,7 +118140,7 @@ self: {
      mkDerivation {
        pname = "ses-html-snaplet";
        version = "0.1.0.0";
-       sha256 = "1lrr321gk7djyzv9yb7x967d53azxflh4jkf9zlkpxh3p7rz6793";
+       sha256 = "231df3f3b903f63be94f6e4a02a9eb5f8dd28e49fd2c9ff6f7b29df9821839d3";
        libraryHaskellDepends = [
          base blaze-html bytestring configurator ses-html snap text
          transformers
@@ -117811,7 +118157,7 @@ self: {
      mkDerivation {
        pname = "sessions";
        version = "2008.7.18";
-       sha256 = "0zijfbakj3fh052b8nvaddg1xy87ysfbm3qnibisam93lx0agp2s";
+       sha256 = "5adca740a72355a5e38a168fba9cf607f91e5e6b6a5bb44401d00d39d572327e";
        libraryHaskellDepends = [
          base binary bytestring containers mtl network
        ];
@@ -117826,7 +118172,7 @@ self: {
      mkDerivation {
        pname = "set-cover";
        version = "0.0.4";
-       sha256 = "0323l2jnk5caa3wsxqxgsdkvnfs9llb4yh13c0rx55q0is8a203j";
+       sha256 = "7200a1908e0097d2336023404f16a5493bbb67d3afe3aef9508a9569a5a0430c";
        isLibrary = true;
        isExecutable = true;
        libraryHaskellDepends = [ base containers utility-ht ];
@@ -117840,7 +118186,7 @@ self: {
      mkDerivation {
        pname = "set-extra";
        version = "1.3.2";
-       sha256 = "0lyxz1mnslsq8crc0vnvygz8r5r3iqyl457sjvg2j6lnz132917p";
+       sha256 = "f7842446f8961a29de96fa14423d8e23978cfef3db6ec0324358536d6bf8dd53";
        libraryHaskellDepends = [ base containers mtl syb ];
        homepage = "https://github.com/ddssff/set-extra";
        description = "Functions that could be added to Data.Set.";
@@ -117852,7 +118198,7 @@ self: {
      mkDerivation {
        pname = "set-monad";
        version = "0.2.0.0";
-       sha256 = "1nxgn8d0qff4s66gcvfrnxjh0aq5q5jk0s453km28457qh946azb";
+       sha256 = "eb2b4312c4a71024ea1c85683065c1052b0065b7d96df68cd1c4390c1ab2afdb";
        libraryHaskellDepends = [ base containers deepseq ];
        description = "Set monad";
        license = stdenv.lib.licenses.bsd3;
@@ -117865,7 +118211,7 @@ self: {
      mkDerivation {
        pname = "set-with";
        version = "0.0.1";
-       sha256 = "0mkc44gkhjibq3zhxgiw3c7nfy03jmjmrafdr8x9f5ak4l9ns0h4";
+       sha256 = "04026d13255315973acacda95c65950378670f1b3cbe0effc02b4a381f216c56";
        libraryHaskellDepends = [ base containers invariant ];
        testHaskellDepends = [
          base QuickCheck quickcheck-instances tasty tasty-hunit
@@ -117883,7 +118229,7 @@ self: {
      mkDerivation {
        pname = "setdown";
        version = "0.1.0.1";
-       sha256 = "1007cb1p8ymnm39cbk423jfgzvdk7yip54yy3ydiiqwkfy2rxs5g";
+       sha256 = "afe89e857793e3189b1fde9372a33fb3edff9c1c82ccc5d2a8b67a74c3620780";
        isLibrary = false;
        isExecutable = true;
        executableHaskellDepends = [
@@ -117902,7 +118248,7 @@ self: {
      mkDerivation {
        pname = "setenv";
        version = "0.1.1.3";
-       sha256 = "0cnbgrvb9byyahb37zlqrj05rj25v190crgcw8wmlgf0mwwxyn73";
+       sha256 = "e358df39afc03d5a39e2ec650652d845c85c80cc98fe331654deafb4767ecb32";
        revision = "1";
        editedCabalFile = "c5916ac0d2a828473cd171261328a290afe0abd799db1ac8c310682fe778c45b";
        libraryHaskellDepends = [ base unix ];
@@ -117915,7 +118261,7 @@ self: {
      mkDerivation {
        pname = "setlocale";
        version = "1.0.0.3";
-       sha256 = "17n173byca8k5cmqmnzgjk7772ibhg5am5sd1adfp0zd0rcqnqsd";
+       sha256 = "4d638b5906ed83eb9a0a4d97aaca832b8a73ce94efdb8a2b2b1329e6d738c19e";
        libraryHaskellDepends = [ base ];
        homepage = "https://bitbucket.org/IchUndNichtDu/haskell-setlocale";
        description = "Haskell bindings to setlocale";
@@ -117927,18 +118273,40 @@ self: {
      mkDerivation {
        pname = "setops";
        version = "0.1.2";
-       sha256 = "1mja48p8g9prfk53218qbv83ks6rs63s0n6jad0jgrj1221afpvg";
+       sha256 = "6f5fa7821041e6274153d258a087d1d9e839d05e180531ca74f9a6872e224ad6";
        libraryHaskellDepends = [ base containers ];
        description = "Uniform names (and Unicode operators) for set operations on data structures";
        license = stdenv.lib.licenses.publicDomain;
      }) {};
 
+  "sets" = callPackage
+    ({ mkDerivation, base, commutative, containers, contravariant
+     , discrimination, hashable, QuickCheck, quickcheck-instances
+     , set-with, tasty, tasty-hunit, tasty-quickcheck
+     , unordered-containers
+     }:
+     mkDerivation {
+       pname = "sets";
+       version = "0.0.1.1";
+       sha256 = "5f9262b02eb5e6d1caf85ae65f3b659b49e5d4b17447b8cbd52a359df8ba0a1d";
+       libraryHaskellDepends = [
+         base commutative containers contravariant discrimination hashable
+         set-with unordered-containers
+       ];
+       testHaskellDepends = [
+         base QuickCheck quickcheck-instances tasty tasty-hunit
+         tasty-quickcheck
+       ];
+       description = "Various set implementations in Haskell";
+       license = stdenv.lib.licenses.mit;
+     }) {};
+
   "setters" = callPackage
     ({ mkDerivation, base, mtl, template-haskell }:
      mkDerivation {
        pname = "setters";
        version = "0.1";
-       sha256 = "0rw9m9f7cqi0kvjcq81b7qrn3v672d4w0ch1k377m1151vg20a2z";
+       sha256 = "5f2820de0e25847ace980132c04913c7ec61333e2b20cce49e2062765caa8967";
        libraryHaskellDepends = [ base mtl template-haskell ];
        description = "Small (TH) library to declare setters for typical `record' data type fields";
        license = stdenv.lib.licenses.bsd3;
@@ -117952,7 +118320,7 @@ self: {
      mkDerivation {
        pname = "sexp";
        version = "0.7";
-       sha256 = "19blk6nzbsm9syx45zzlmqxq1mi2prv0jq12cf83b4kf4pvwk32n";
+       sha256 = "568cc9f7256e9235906322600976be22d6803baef4ff42bad7a9eaf5ad9974a5";
        isLibrary = true;
        isExecutable = true;
        libraryHaskellDepends = [
@@ -117974,7 +118342,7 @@ self: {
      mkDerivation {
        pname = "sexp-show";
        version = "0.1.1.0";
-       sha256 = "1ip1y1y2z2d6ib3ihq18j93081cp2lkwjm27bc0d0ihixd154gy5";
+       sha256 = "c53f5242eb1146d0005b4754c927159705044692286018c78aa6892f7cf0e1c6";
        revision = "1";
        editedCabalFile = "314f05a4542c657517d485faa31ec23324458782cf0112acda948fb7092a154c";
        isLibrary = false;
@@ -117991,7 +118359,7 @@ self: {
      mkDerivation {
        pname = "sexpr";
        version = "0.2.1";
-       sha256 = "1ffs5r065zkipsa3y4v14if45fqjbzgksj3r40qci453kc3xq93p";
+       sha256 = "7724dc079ba390c8302079483ddf5f12bb425c2461133f94be71fe62402edab9";
        isLibrary = true;
        isExecutable = true;
        libraryHaskellDepends = [
@@ -118008,7 +118376,7 @@ self: {
      mkDerivation {
        pname = "sext";
        version = "0.1.0.0";
-       sha256 = "0vq7fbm8gm7fym9qjaxsy2mk89rn2pjfkbhv3ym94xslcybwrwpy";
+       sha256 = "fef2cc9767547792aa1f1baee9e415362734abf0ba2b8953f5eed487ea72076f";
        libraryHaskellDepends = [ base bytestring template-haskell text ];
        jailbreak = true;
        homepage = "http://github.com/dzhus/sext/";
@@ -118022,7 +118390,7 @@ self: {
      mkDerivation {
        pname = "sfml-audio";
        version = "0.7.1.1816";
-       sha256 = "057z0z2xbls1p43k0kixbw26v0pv6lsvfh5ycjx37r8xw8ks31ba";
+       sha256 = "6a85a127e21de533ba64be40b73535fb826d045f3d4e3007b941d3d5c507ff14";
        libraryHaskellDepends = [ base bytestring ];
        librarySystemDepends = [ libsndfile openal ];
        homepage = "http://patch-tag.com/r/shahn/sfml-audio";
@@ -118035,7 +118403,7 @@ self: {
      mkDerivation {
        pname = "sfmt";
        version = "0.1.1";
-       sha256 = "1jwzsk43kkvlmw551z46bhbvccf9yn1ncrhd27lm4pn93as2v1p6";
+       sha256 = "e6862db41ac95e52e9110d666683f5c931b6175c86fc500aaf74cf39c8d49fcb";
        libraryHaskellDepends = [ base bytestring entropy primitive ];
        homepage = "https://github.com/philopon/sfmt-hs";
        description = "SIMD-oriented Fast Mersenne Twister(SFMT) binding";
@@ -118050,7 +118418,7 @@ self: {
      mkDerivation {
        pname = "sgd";
        version = "0.3.7";
-       sha256 = "1z4w81mbk2syrxacfrjb690ik6lcsh1fb7m3d65zlz37y3pk5q04";
+       sha256 = "04e032eff0677cfa8b69a39ee502d48c9a1941324b66c754cf5e8bb96a409cfc";
        libraryHaskellDepends = [
          base binary bytestring containers deepseq filepath lazy-io logfloat
          monad-par mtl primitive random temporary vector
@@ -118068,7 +118436,7 @@ self: {
      mkDerivation {
        pname = "sgf";
        version = "0.1.3.1";
-       sha256 = "1bwfphbbkkwi2q8l0916yvpl58j7fb0nr144w582vpsq3wfvgiwc";
+       sha256 = "8cc7b71d1f58df2d50e184846cc17247a242eff6262440111691cfb916bc8eaf";
        libraryHaskellDepends = [
          base containers encoding extensible-exceptions mtl parsec split
          time transformers
@@ -118083,7 +118451,7 @@ self: {
      mkDerivation {
        pname = "sgrep";
        version = "0.0";
-       sha256 = "0ai9j735wj5lclixwlki5g2s50g2mscglfrir2q7bj0lwg76dygi";
+       sha256 = "f1f966cee314c875b0c8313bfa98aee281a2c52b7152de2365b4485ec691292a";
        isLibrary = false;
        isExecutable = true;
        executableHaskellDepends = [ base bio regex-compat ];
@@ -118098,7 +118466,7 @@ self: {
      mkDerivation {
        pname = "sha-streams";
        version = "0.1.1";
-       sha256 = "1qasdpm244dr7zh3hnr51jbp1b8qnrwbxvm3nnrbaf7bah1y4d2i";
+       sha256 = "5134e20354eb38b5b2b5a3eebe78b618ad70970c255b38e03fb91122ea6d5ae1";
        isLibrary = true;
        isExecutable = true;
        libraryHaskellDepends = [ base binary bytestring io-streams SHA ];
@@ -118116,7 +118484,7 @@ self: {
      mkDerivation {
        pname = "shadower";
        version = "0.1.0.6";
-       sha256 = "1m0zxnmxn536jnaj5l4qpj5k7xshffsbca0cl53y3dnb6ssq9fni";
+       sha256 = "d1ba84b536cbb6e147a10c28b6b47350f7338bbc98d02295956614dbabed1fd4";
        isLibrary = false;
        isExecutable = true;
        executableHaskellDepends = [
@@ -118134,25 +118502,27 @@ self: {
      }) {};
 
   "shadowsocks" = callPackage
-    ({ mkDerivation, aeson, base, binary, bytestring, containers
-     , cryptohash, HsOpenSSL, HUnit, network, optparse-applicative
-     , process, unordered-containers
+    ({ mkDerivation, aeson, async, base, binary, bytestring
+     , conduit-combinators, conduit-extra, containers, cryptohash
+     , HsOpenSSL, HUnit, iproute, optparse-applicative, process
+     , unordered-containers
      }:
      mkDerivation {
        pname = "shadowsocks";
-       version = "1.20141007";
-       sha256 = "1630lfspy8fnsi9j2np9sygdng59bxx1q54kcr7cx7rgq434s5ys";
+       version = "1.20150811";
+       sha256 = "1021016861c01a63f4a30825431b22e74e5011984f9406fc6642f5070e201382";
        isLibrary = false;
        isExecutable = true;
        executableHaskellDepends = [
-         aeson base binary bytestring containers cryptohash HsOpenSSL
-         network optparse-applicative unordered-containers
+         aeson async base binary bytestring conduit-combinators
+         conduit-extra containers cryptohash HsOpenSSL iproute
+         optparse-applicative unordered-containers
        ];
        testHaskellDepends = [
          base binary bytestring containers cryptohash HUnit process
        ];
        homepage = "https://github.com/rnons/shadowsocks-haskell";
-       description = "A fast tunnel proxy that help you get through firewalls";
+       description = "A fast SOCKS5 proxy that help you get through firewalls";
        license = stdenv.lib.licenses.mit;
      }) {};
 
@@ -118164,7 +118534,7 @@ self: {
      mkDerivation {
        pname = "shady-gen";
        version = "0.5.1";
-       sha256 = "1vsk0ah6ngcgn5i6xda9j400xan1y843v25hc4lqcql37mg3ifn8";
+       sha256 = "c8ba385e3d8362862961b0883d08f2c1aa0e009149b56e62b18f3d6ba00253ef";
        libraryHaskellDepends = [
          applicative-numbers base Boolean containers data-treify MemoTrie
          mtl ty TypeCompose vector-space wl-pprint
@@ -118183,7 +118553,7 @@ self: {
      mkDerivation {
        pname = "shady-graphics";
        version = "0.5.0";
-       sha256 = "1wzlygmpjfys4ijyqh8ymv2f75swy9zd0g05gxpqhxkvlrw3jdk4";
+       sha256 = "64363978a67b76886f7f053cd07ef25c97e3c4ae1e41ec6524da3b79ebf3f4f3";
        libraryHaskellDepends = [
          applicative-numbers base Boolean containers data-treify MemoTrie
          mtl shady-gen ty TypeCompose vector-space wl-pprint
@@ -118203,7 +118573,7 @@ self: {
      mkDerivation {
        pname = "shake";
        version = "0.15.5";
-       sha256 = "18vkyc8h7dpz5d3snfdssfqd1cfp22wnpv63ckrik9p8r4j6i01c";
+       sha256 = "2c806824c9e8a619f364c3ec6bb910d7b1d0b0d3ba39ab472bffb60311f373a3";
        isLibrary = true;
        isExecutable = true;
        libraryHaskellDepends = [
@@ -118231,7 +118601,7 @@ self: {
      mkDerivation {
        pname = "shake-cabal-build";
        version = "0.1.0";
-       sha256 = "1ql2w164f2sfmbcqk2da00nihwfr6a85f99apx5dwpbkfbc53n8l";
+       sha256 = "14d951d872735dde4abf2a25579032d971182d00aa8989d9aa4e0b474ce082e2";
        isLibrary = false;
        isExecutable = true;
        executableHaskellDepends = [
@@ -118250,7 +118620,7 @@ self: {
      mkDerivation {
        pname = "shake-extras";
        version = "0.1.1";
-       sha256 = "0qqzdhd6q8hhix7lx4j1v4j37b8jnv710clilk2wxbyvz03rbblz";
+       sha256 = "9fae9507f8dbafcec5a4913210ceb612ad3324d941924e4f8f10226c1a6c1f63";
        libraryHaskellDepends = [
          base bytestring cmdargs directory filepath shake
        ];
@@ -118268,7 +118638,7 @@ self: {
      mkDerivation {
        pname = "shake-language-c";
        version = "0.8.0";
-       sha256 = "1b7yi1cprgiyx06dnhc94shmfx5n1am7zhgiwg6g0bk2gg20im35";
+       sha256 = "65d408c47b622ef0cce3f1c17faa0ab67457a1268941db0ce83ebe7c5988feac";
        libraryHaskellDepends = [
          base data-default-class fclabels process shake split
          unordered-containers
@@ -118284,7 +118654,7 @@ self: {
      mkDerivation {
        pname = "shake-minify";
        version = "0.1.4";
-       sha256 = "17q0xzjj6xl9h3s6dlxgkxxz2dd4ycbh918ali1lrq2dq9gig3ir";
+       sha256 = "398e175fc24de04c43a40a850417f3a435f17b9fafd366f480897623e5ef009f";
        libraryHaskellDepends = [
          base bytestring css-text hjsmin shake text
        ];
@@ -118298,7 +118668,7 @@ self: {
      mkDerivation {
        pname = "shake-pack";
        version = "0.1.2";
-       sha256 = "0iy2n7cg7fm0by479s1hm5w2jzzfdavjlyq6nf2sh6qlkc6w2ga1";
+       sha256 = "413dc10d9b141ba885b3067b2ab76aee7f2978a930e874885fa0baf3d8b1c247";
        libraryHaskellDepends = [ base bytestring bzlib shake tar ];
        homepage = "https://github.com/LukeHoersten/shake-pack";
        description = "Shake File Pack Rule";
@@ -118314,7 +118684,7 @@ self: {
      mkDerivation {
        pname = "shaker";
        version = "0.5.1";
-       sha256 = "1m4b7pvpr5mg6g5sc9xhnn7i9lx65vb3ass38zkyrfgksg65lwhf";
+       sha256 = "0e725accd3f3b9ece747436b35d62ea6d3148fb5b027a6cb33af967cf73d8bd4";
        isLibrary = true;
        isExecutable = true;
        libraryHaskellDepends = [
@@ -118344,7 +118714,7 @@ self: {
      mkDerivation {
        pname = "shakespeare";
        version = "2.0.5";
-       sha256 = "0jdmmrglzqzpj4cfiyab3kfr0vlz1rfc893nrq94b1rg4vwh1zzh";
+       sha256 = "f0ff00f9262f874512ce7624c45c0e9f6e90dd1c4bf9e81891f7e34f5faeb549";
        revision = "1";
        editedCabalFile = "c3cde3794b87e5f99500aac7199a66ad95985ba716170551fe40e82452a61ebc";
        libraryHaskellDepends = [
@@ -118367,7 +118737,7 @@ self: {
      mkDerivation {
        pname = "shakespeare-css";
        version = "1.1.0";
-       sha256 = "18d0kxfrs0aj9pfd9p1j7w5amch1hvsww3xycgn5qk6i0z7l4ywz";
+       sha256 = "9f7b42cf07d14c5cec63be0fcef58601b2aa0a3f32dcd4dc4d52019d5d9fa0a1";
        libraryHaskellDepends = [ base shakespeare ];
        homepage = "http://www.yesodweb.com/book/shakespearean-templates";
        description = "Stick your haskell variables into css at compile time. (deprecated)";
@@ -118380,7 +118750,7 @@ self: {
      mkDerivation {
        pname = "shakespeare-i18n";
        version = "1.1.0";
-       sha256 = "0ahhg9r7d8kdxn0x33bp5p8wmwkh1yvdqhw05yjwif0ky5y9h625";
+       sha256 = "4518987cf113b8c8a52f8043dcb60f70f2cad12d778dd181ed6da276727a102a";
        libraryHaskellDepends = [ base shakespeare ];
        homepage = "http://www.yesodweb.com/book/shakespearean-templates";
        description = "A type-based approach to internationalization. (deprecated)";
@@ -118393,7 +118763,7 @@ self: {
      mkDerivation {
        pname = "shakespeare-js";
        version = "1.3.0";
-       sha256 = "0hihcrgvzf4nsrgw6vqpkzbgskq01yc1mnvp7g2wy7vq0dv4pjp4";
+       sha256 = "e4ca4b7603781fcfc53b77db1a980f004ffdd69f176fc35fd696b8bf5f663042";
        libraryHaskellDepends = [ base shakespeare ];
        homepage = "http://www.yesodweb.com/book/shakespearean-templates";
        description = "Stick your haskell variables into javascript/coffeescript at compile time. (deprecated)";
@@ -118405,7 +118775,7 @@ self: {
      mkDerivation {
        pname = "shakespeare-text";
        version = "1.1.0";
-       sha256 = "18ixixb9aqn630s9wblxcki1gggm4i0fj9752c55p3b42q8h86rc";
+       sha256 = "2c1b041116648d5b0a13e524e94024f5bd17e2649d2e9e3418c66295568f3da2";
        libraryHaskellDepends = [ base shakespeare ];
        homepage = "http://www.yesodweb.com/book/shakespearean-templates";
        description = "Interpolation with quasi-quotation: put variables strings (deprecated)";
@@ -118417,7 +118787,7 @@ self: {
      mkDerivation {
        pname = "shana";
        version = "2009.12.1";
-       sha256 = "0fg16nbi0r0pdd3sfabzdz1f4595x3hz3b4pxfwy8l78p8lppv0y";
+       sha256 = "1eec7b29bae850e4b9eb97acf1e1e82515e2c26f7f29a7476b1764109735e139";
        libraryHaskellDepends = [ base directory regex-posix ];
        homepage = "http://github.com/nfjinjing/hack/tree/master";
        description = "treat haskell functions as unix pipes";
@@ -118431,7 +118801,7 @@ self: {
      mkDerivation {
        pname = "shapefile";
        version = "0.0.0.1";
-       sha256 = "0j6c01igj767ab3pd5yzkjkd8374rmjr57f2gw5c69qnh288c6w6";
+       sha256 = "861b8690801627c30a7fc29d9265cde40cd4a69cdf9776c752c71cf96200cc48";
        libraryHaskellDepends = [
          base binary bytestring data-binary-ieee754 dbf filepath rwlock
        ];
@@ -118447,7 +118817,7 @@ self: {
      mkDerivation {
        pname = "shapely-data";
        version = "0.1";
-       sha256 = "1yn1rim4y6j834ngpz47wsi5pyhbi2gaznj0pyrqrmallzv0zin8";
+       sha256 = "c8c60ff6a754d58cb3bf40daaf9e880bfa5ba2e687fcfb2c19481a4f6accc1fa";
        libraryHaskellDepends = [
          base proxy-kindness tagged template-haskell
        ];
@@ -118467,7 +118837,7 @@ self: {
      mkDerivation {
        pname = "shared-buffer";
        version = "0.2.2";
-       sha256 = "031aabqynp5d4k47rjjwyx3xjzh4f1k4csfgdnnhsf45xv5nc3kc";
+       sha256 = "6c0e66cbee85380dad6dcf69466670047ed947f75cca7cc824ad5cebf1522a0c";
        libraryHaskellDepends = [ base bytestring unix ];
        testHaskellDepends = [
          base bytestring QuickCheck test-framework
@@ -118485,7 +118855,7 @@ self: {
      mkDerivation {
        pname = "shared-fields";
        version = "0.2.0.0";
-       sha256 = "107n6w4dn0n4iv7qmfm1d9y04rgj3ab3qc8kyqqddnbnfa44y157";
+       sha256 = "a7044f887276d9d630f613313c961af265027c6aa1ba8acf8ec402db0837f680";
        libraryHaskellDepends = [ base template-haskell ];
        testHaskellDepends = [ base Cabal hspec lens text ];
        homepage = "http://github.com/intolerable/shared-fields";
@@ -118498,7 +118868,7 @@ self: {
      mkDerivation {
        pname = "shared-memory";
        version = "0.1.0.0";
-       sha256 = "15h4j81q2v97dx61pnpaqs99z4vvlw7xl1dxbh878imxj8zn4z84";
+       sha256 = "047d623f92bd4674105cbd05da0fa77b939f92c6eada1b4c6f276d8103920496";
        libraryHaskellDepends = [ base unix ];
        testHaskellDepends = [ base bytestring unix ];
        homepage = "https://github.com/nh2/shared-memory";
@@ -118511,7 +118881,7 @@ self: {
      mkDerivation {
        pname = "sharedio";
        version = "0.1.0";
-       sha256 = "08hmmb2nn2lpirdnpp928m6xadzkv8k90x1nycw2b58vp1rpk7zv";
+       sha256 = "fb9f7973b81b952538f336749026daf337d54d4522dd6b5b8e970a6bc5aa1522";
        libraryHaskellDepends = [ base ];
        homepage = "https://github.com/nh2/haskell-sharedio";
        description = "Bundles shared calls to IO functions to perform them only once";
@@ -118523,7 +118893,7 @@ self: {
      mkDerivation {
        pname = "she";
        version = "0.6";
-       sha256 = "0x3jc2c4j0b8xavap7hj4673zb89zgww1pv13sddkn6p49pk1zvc";
+       sha256 = "6cff306f22d7d8d99a1e61dfc0f9fb09ad3f8e21129eabb6ea68014998607274";
        isLibrary = true;
        isExecutable = true;
        libraryHaskellDepends = [ base filepath mtl ];
@@ -118543,7 +118913,7 @@ self: {
      mkDerivation {
        pname = "shell-conduit";
        version = "4.5.2";
-       sha256 = "04kc9gzlqbw3d2pj6qn13pnmmrlmx8nmmj5bvxn7zdmh25nw6ys2";
+       sha256 = "427bc36d11b0b67f6cdfabc85a2dea95e65aed1dc16223af68832f4cff4b6c12";
        libraryHaskellDepends = [
          async base bytestring conduit conduit-extra control-monad-loop
          directory filepath monad-control monads-tf process resourcet
@@ -118560,7 +118930,7 @@ self: {
      mkDerivation {
        pname = "shell-escape";
        version = "0.2.0";
-       sha256 = "0jms5hdl8zrpxwypq9998798krspclivprirrcq59r179alrng72";
+       sha256 = "e23c9ba94a27e45430cb39e6bb236557e789d24129257c3def377f441b2cba4a";
        libraryHaskellDepends = [
          base binary bytestring containers vector
        ];
@@ -118574,7 +118944,7 @@ self: {
      mkDerivation {
        pname = "shell-monad";
        version = "0.6.4";
-       sha256 = "1wmihv2x4pbz9bkrjyyh4hqwsdmlldmyi5jlgxx6ry6z3jyx9i13";
+       sha256 = "23c4d4bd1cdff86c7a7f5496e86ba3b436cd3124d07b99e74a7f5dd2c586b1f2";
        libraryHaskellDepends = [ base containers text unix ];
        description = "shell monad";
        license = stdenv.lib.licenses.bsd3;
@@ -118585,7 +118955,7 @@ self: {
      mkDerivation {
        pname = "shell-pipe";
        version = "0.1";
-       sha256 = "0xyarxm2hs8yypmz8w4zbnjvv5xl9dd657j7j3a82gbghsb93vyy";
+       sha256 = "deef9196866f3d81d490479e625a4bb497bda55d9f70f4ebf51e69286acfca77";
        isLibrary = true;
        isExecutable = true;
        libraryHaskellDepends = [ base ];
@@ -118603,7 +118973,7 @@ self: {
      mkDerivation {
        pname = "shellish";
        version = "0.1.4";
-       sha256 = "1ldwid270mwyky6zmggbvn72hvs4s39hhf2zj8r0jahxnwlpbfan";
+       sha256 = "56b97529b71d2a0932925f3808d3d0446f288eddebbdfa8d9f9e5770448bbcd1";
        libraryHaskellDepends = [
          base bytestring directory filepath mtl process strict time
          unix-compat
@@ -118621,7 +118991,7 @@ self: {
      mkDerivation {
        pname = "shellmate";
        version = "0.1.6";
-       sha256 = "17fpl0h58cw5hp6jzrajkl629mw2c6x15cmlcbdxqk9xlxqrg4hr";
+       sha256 = "19929771a73d4ddcdb62b4b212ba6182d7240c9d52e52fcd8585335420a0d79d";
        libraryHaskellDepends = [
          base directory filepath process temporary time transformers
        ];
@@ -118638,7 +119008,7 @@ self: {
      mkDerivation {
        pname = "shelltestrunner";
        version = "1.3.5";
-       sha256 = "0ad8sc4md8mp0l0s40yx7qbgaabqzd4nz8lx15ajcdbwr2ffnra2";
+       sha256 = "4265eb9cc87c352655099da26f49fb7829f5163edd03a20105b7a25609d3a829";
        isLibrary = false;
        isExecutable = true;
        executableHaskellDepends = [
@@ -118661,7 +119031,7 @@ self: {
      mkDerivation {
        pname = "shelly";
        version = "1.6.3.3";
-       sha256 = "173aypf9dcrkhnaz5gfcpicw9ha6cgs7javds3s7m2qr2vdj8rhs";
+       sha256 = "1a6624db16198b7af4d06d2b79f46346c1c459bcccbdf2958533b396dcf56a9c";
        isLibrary = true;
        isExecutable = true;
        libraryHaskellDepends = [
@@ -118688,7 +119058,7 @@ self: {
      mkDerivation {
        pname = "shelly-extra";
        version = "0.3.0.1";
-       sha256 = "1mc55m10s89mp2fz267sqhayaj0igj27kwyx7hnk5h23w0nhc0h5";
+       sha256 = "0502062de043c0322d3cddf379847c1148e515c4fa18f19db835210d422d85d5";
        libraryHaskellDepends = [ async base mtl SafeSemaphore shelly ];
        testHaskellDepends = [
          async base hspec HUnit mtl SafeSemaphore shelly text
@@ -118705,7 +119075,7 @@ self: {
      mkDerivation {
        pname = "shivers-cfg";
        version = "0.1";
-       sha256 = "1jrf9l25lcmqh55zy3g2nbi60ph9m0ycvjz1q0qvpb403kqhd0wa";
+       sha256 = "8a8306f11c80acbb31c0e1cbcd3ca8095e60e2b2e20dff4b81b8325a044d2ecb";
        libraryHaskellDepends = [
          base containers directory HPDF language-dot mtl pretty process
        ];
@@ -118719,7 +119089,7 @@ self: {
      mkDerivation {
        pname = "shoap";
        version = "0.2";
-       sha256 = "0ywb8bfkdpqqv2spb92j9rzx4fv5k1c7b65wj0zwnn9rp7ckq59v";
+       sha256 = "3b153cd9b93959cb3f90bc98755898653bd27f4e52a475b5d818df36dd428b7b";
        libraryHaskellDepends = [ base curl ];
        jailbreak = true;
        homepage = "http://richardfergie.com/shoap";
@@ -118732,7 +119102,7 @@ self: {
      mkDerivation {
        pname = "shortcircuit";
        version = "0.1";
-       sha256 = "02gcr6glp1kjs4l7ds8487dbblr1pw8nyq34i3rg1hskz0b83l6z";
+       sha256 = "dfd08116f853c3f0f28864606f11bf21d3b5da4104e97628d172864b9fc9ec09";
        libraryHaskellDepends = [ base ];
        homepage = "http://github.com/aristidb/shortcircuit";
        description = "Short-circuit values and expressions";
@@ -118744,7 +119114,7 @@ self: {
      mkDerivation {
        pname = "shortcut-links";
        version = "0.4.0.0";
-       sha256 = "1i9a5hgzw9w9fqg7vjixc90ck49ag0ikm9bjl2xc30gvjslpy3r8";
+       sha256 = "280f7fa996fb81c1baa072a53a23782a91c940623dca7d1e768927fe1f2c2ac5";
        libraryHaskellDepends = [ base text ];
        homepage = "http://github.com/aelve/shortcut-links";
        description = "Link shortcuts for use in text markup";
@@ -118756,7 +119126,7 @@ self: {
      mkDerivation {
        pname = "shorten-strings";
        version = "0.1.0.1";
-       sha256 = "1srqbc2kx1zn0xlzv94y7kqdrflmdck3jy6d2fl75zhf11wilxw3";
+       sha256 = "83771a79080efe72a813cd7839266b95badcf03c9ea4fd6907f6873e055b38eb";
        libraryHaskellDepends = [ base text ];
        jailbreak = true;
        homepage = "https://github.com/Tarrasch/shorten-strings";
@@ -118769,7 +119139,7 @@ self: {
      mkDerivation {
        pname = "should-not-typecheck";
        version = "2.0";
-       sha256 = "0869dgn7xccnzxhzbjl150x0sdwwgppk06nq448i9xlnhhrk6dkc";
+       sha256 = "6c3633338496f6141121d81a30ef7d9c370d3a2881caf561ff96b17eec6bc920";
        libraryHaskellDepends = [ base deepseq HUnit ];
        testHaskellDepends = [
          base deepseq hspec hspec-expectations HUnit
@@ -118784,7 +119154,7 @@ self: {
      mkDerivation {
        pname = "show";
        version = "0.6";
-       sha256 = "15bvfffnr034z8wbmhxa8h5qskbxwbflk434dx023l1qlm3sjmsg";
+       sha256 = "4f57a947a538d021406f649049dde27d4d8d0b44aac3ba38fa64806c9d737b95";
        libraryHaskellDepends = [ base syb ];
        description = "'Show' instances for Lambdabot";
        license = "GPL";
@@ -118795,7 +119165,7 @@ self: {
      mkDerivation {
        pname = "show-type";
        version = "0.1.1";
-       sha256 = "1sppi8vj1cg7gwz7vagc1cry22b814wlwbm6jjj1c4d5f4kmpyyv";
+       sha256 = "dbfb5b2771a51116a494a62e4e39096809e1330beca97d3e7fe7b120378af7ea";
        libraryHaskellDepends = [ base ];
        homepage = "https://github.com/Kinokkory/show-type";
        description = "convert types into string values in haskell";
@@ -118807,7 +119177,7 @@ self: {
      mkDerivation {
        pname = "showdown";
        version = "0.5.3";
-       sha256 = "1gpjb8lw5zmnsd8ic739j91iqsv9a707nd9j5mbnhq6gilk61nrh";
+       sha256 = "30db60268dcf6068572d32357bc051696b1c4392691c1651d3b6fec2295af2be";
        isLibrary = false;
        isExecutable = true;
        executableHaskellDepends = [ base glade gtk random ];
@@ -118824,7 +119194,7 @@ self: {
      mkDerivation {
        pname = "shpider";
        version = "0.2.1.1";
-       sha256 = "19741zlma2fp3jbfsmqgl0004bvfpizbjljg2k5xam1k4v144kwd";
+       sha256 = "8d4f42c2263354d5cb144f52b97ebc6e2f0200a00f57ed961cd70955e90fe4a4";
        libraryHaskellDepends = [
          base bytestring containers curl mtl regex-posix tagsoup
          tagsoup-parsec time url web-encodings
@@ -118840,7 +119210,7 @@ self: {
      mkDerivation {
        pname = "shplit";
        version = "0.3";
-       sha256 = "0wml7x8843ib8jmwq6xz9q011hz4vpd7zmnvbc8h2zdql6p6lqxr";
+       sha256 = "b9636aaea1b87d01115bdbd67fdadde4c310004ebf1bccab442b0e82503fb472";
        isLibrary = false;
        isExecutable = true;
        executableHaskellDepends = [ base mtl ];
@@ -118856,7 +119226,7 @@ self: {
      mkDerivation {
        pname = "shqq";
        version = "0.1";
-       sha256 = "08mdnlnq001slxml0y1rg7nry2fz8qcf1cw0q22j84gx3csrfhcm";
+       sha256 = "954197351bfd112485c080b3e01846df099fed793978406ba73a00802db5ad22";
        libraryHaskellDepends = [
          base parsec posix-escape process template-haskell unix
        ];
@@ -118872,7 +119242,7 @@ self: {
      mkDerivation {
        pname = "shuffle";
        version = "0.1.3.3";
-       sha256 = "0ngva3p3838xay3zz442n99ilhk5d9majg342x6y7hs796lqbrrd";
+       sha256 = "2de785a94947c3e34d17643ca96a6a65421a53b28290ff87571d0d34ee50fb59";
        isLibrary = true;
        isExecutable = true;
        libraryHaskellDepends = [
@@ -118890,7 +119260,7 @@ self: {
      mkDerivation {
        pname = "sieve";
        version = "0.1.0.1";
-       sha256 = "19zjwzh3i8ql5xz9rvmbz7n2l3z7dcq683ikrpvqx3wxnc06058m";
+       sha256 = "15156000b39d8f8ef7cd330e64306be70f2aecf9abee9c7e2f14a338e0e7f2a7";
        libraryHaskellDepends = [ base ];
        homepage = "http://www.the-singleton.com";
        description = "Sieve is an implementation of the Sieve abstract data type";
@@ -118904,7 +119274,7 @@ self: {
      mkDerivation {
        pname = "sifflet";
        version = "2.2.1";
-       sha256 = "0xahs91s1kvb2vrdr6xwg4nrm3d4pfz807rnb7dj9rfj1knlaw4j";
+       sha256 = "927045ed0cd2e524db59361f80bebba48d9a2d79bc9bdcf2166bcfa043d25075";
        isLibrary = false;
        isExecutable = true;
        executableHaskellDepends = [
@@ -118925,7 +119295,7 @@ self: {
      mkDerivation {
        pname = "sifflet-lib";
        version = "2.2.1";
-       sha256 = "1snaq0vlsk4r2lbg2sk389ppwnz22mqwhf1lgwjh3cg91ab905n4";
+       sha256 = "c41690960ae9b101257f3438c87115e25b7e6f42636af11615994c4d37c0caea";
        libraryHaskellDepends = [
          base cairo containers directory fgl filepath glib gtk hxt mtl
          parsec process unix
@@ -118946,7 +119316,7 @@ self: {
      mkDerivation {
        pname = "sign";
        version = "0.4.1";
-       sha256 = "1d7hxvvmbbv8izr74l4ah1q50fwmmgman90rhjixkvppkq8fwjhz";
+       sha256 = "1f4aee109ef7eed9a3841924abeaab953b5070808a5072f28f68af55f7eef0b4";
        libraryHaskellDepends = [
          base containers deepseq hashable lattices
        ];
@@ -118966,7 +119336,7 @@ self: {
      mkDerivation {
        pname = "signals";
        version = "0.0.0.1";
-       sha256 = "12l5vixyv6j3fz8j9rwahf5ifvibqb38kc9j7xg36akc5v2n11s2";
+       sha256 = "428760c52e6c2a335e3f32b189c6c22b6e178b838ae724d177439aed7bdc858a";
        libraryHaskellDepends = [
          array base constraints containers data-reify exception-mtl
          exception-transformers language-c-quote mainland-pretty mtl
@@ -118984,7 +119354,7 @@ self: {
      mkDerivation {
        pname = "signed-multiset";
        version = "0.4";
-       sha256 = "0pxi6g095axf9x6hsiqf0ilsjlws4zvl0pjfjamjyyl1wj82h747";
+       sha256 = "871c2890e4817a2fab924e5e40f7279a53a969040e470d4d4faeab92c033b15f";
        libraryHaskellDepends = [ base containers ];
        jailbreak = true;
        description = "Multisets with negative membership";
@@ -118996,7 +119366,7 @@ self: {
      mkDerivation {
        pname = "silently";
        version = "1.2.5";
-       sha256 = "0f9qm3f7y0hpxn6mddhhg51mm1r134qkvd2kr8r6192ka1ijbxnf";
+       sha256 = "cef625635053a46032ca53b43d311921875a437910b6568ded17027fdca83839";
        libraryHaskellDepends = [ base deepseq directory ];
        testHaskellDepends = [ base deepseq directory nanospec temporary ];
        homepage = "https://github.com/hspec/silently";
@@ -119009,7 +119379,7 @@ self: {
      mkDerivation {
        pname = "simd";
        version = "0.1.0.1";
-       sha256 = "0rmp715k7k41h7nnfg3ik28pf602jvh5wb23yzbpz0j8vkfysn8m";
+       sha256 = "1559eddddc48827fd7f7432c5ee0960218779198713c67ed8181cc334b38b766";
        libraryHaskellDepends = [ base ghc-prim primitive vector ];
        jailbreak = true;
        homepage = "http://github.com/mikeizbicki/simd";
@@ -119025,7 +119395,7 @@ self: {
      mkDerivation {
        pname = "simgi";
        version = "0.3";
-       sha256 = "1yqd9799ys8y4n325mayq8qps99ajv1r4j8h6r16l5n94wvyw1ba";
+       sha256 = "6a05ee3727c9166a4236104992c3962a257d31c25ed52286251e699fd2490dfb";
        isLibrary = false;
        isExecutable = true;
        executableHaskellDepends = [
@@ -119048,7 +119418,7 @@ self: {
      mkDerivation {
        pname = "simple";
        version = "0.10.1";
-       sha256 = "1s75cr2fjgicgf6mndaf659xrp0dga68i2ii8l5dbjz0b2sbhhm7";
+       sha256 = "a742b8b458e0cbd50a45318a888c7a0ddcdc53314e355b8d7b2c3ee94466e5e8";
        isLibrary = true;
        isExecutable = true;
        libraryHaskellDepends = [
@@ -119077,7 +119447,7 @@ self: {
      mkDerivation {
        pname = "simple-actors";
        version = "0.4.0";
-       sha256 = "13xjyr6gf55yxinaah4c8fx56a9fyr191v4lwycnlkdz8vvizw25";
+       sha256 = "45f01ff746bf4d6a99e794ec9042f62e2953ba438c40a56cecbe14f74cf6b28f";
        libraryHaskellDepends = [
          base chan-split contravariant mtl transformers
        ];
@@ -119091,7 +119461,7 @@ self: {
      mkDerivation {
        pname = "simple-atom";
        version = "0.2";
-       sha256 = "1kqkaay3r03plxvvyan3hdgj2rfynygnisi6hrsjwqgj4nw6va17";
+       sha256 = "27a86db825f2612e758626ea689fb7de65215f83c32abf77a777803cbc5213cf";
        libraryHaskellDepends = [ base containers deepseq ];
        jailbreak = true;
        homepage = "http://github.com/nominolo/simple-atom";
@@ -119104,7 +119474,7 @@ self: {
      mkDerivation {
        pname = "simple-bluetooth";
        version = "0.1.0.0";
-       sha256 = "1qrlvqy2vcl36db3403nb1c0sx233d3vwxrbqb7jip13hy0h6jf4";
+       sha256 = "c44903818723dc28cfc22b77be471b43740d5858760032563383b22d3cde34e3";
        libraryHaskellDepends = [ base bytestring network ];
        librarySystemDepends = [ bluetooth ];
        description = "Simple Bluetooth API for Windows and Linux (bluez)";
@@ -119121,7 +119491,7 @@ self: {
      mkDerivation {
        pname = "simple-c-value";
        version = "0.0.0.1";
-       sha256 = "0ky0yilcc54hx8sl11z4dl14n6k9wfz0w9bwv3pbgyi44ravr8gs";
+       sha256 = "faa1bc552624fab7eed87c250ebee3691a4b026de4874035ea9014c668f4c04f";
        libraryHaskellDepends = [
          base DebugTraceHelpers dlist ghc-prim tuple
        ];
@@ -119146,7 +119516,7 @@ self: {
      mkDerivation {
        pname = "simple-conduit";
        version = "0.5.1";
-       sha256 = "1jy70cdw2h6fd2618dczajml5k82kkjmd2n0mgbby2mr6r3sk5zr";
+       sha256 = "f997a94736b90abfd6abc08a56e59c02cd42ab549f35148c68ce40c11b03c7cb";
        libraryHaskellDepends = [
          base bifunctors bytestring chunked-data containers either
          exceptions filepath free lifted-async lifted-base mmorph
@@ -119166,7 +119536,7 @@ self: {
      mkDerivation {
        pname = "simple-config";
        version = "1.2.2.1";
-       sha256 = "1ndczlpqycrmyjm8v3gpsw1f946lfvc70kzmipli4ir9cbqh5d5k";
+       sha256 = "b3b402f162294712e98df54f70d876d490e402d7f78d8daaf435338f2ffdacd9";
        libraryHaskellDepends = [
          base bytestring data-default network-uri parsec template-haskell
          transformers
@@ -119184,7 +119554,7 @@ self: {
      mkDerivation {
        pname = "simple-css";
        version = "0.0.4";
-       sha256 = "19a2yfp9gji7w5ps5lh8jwvnhma21d83v4fm2hrc92490fpq9aid";
+       sha256 = "2daa84af038988c43214d5913d500b425568379708d2a26fe127ca97aef342a5";
        libraryHaskellDepends = [
          base blaze-html hashable language-css unordered-containers
        ];
@@ -119198,7 +119568,7 @@ self: {
      mkDerivation {
        pname = "simple-eval";
        version = "0.1.0.1";
-       sha256 = "185dgpfc7b1ayw0ajfdnf28fy1a87b3kqn4fh9y5l9krzlqs2lfl";
+       sha256 = "d451a131fd79265a7c828e583cc73a4805ef9070b639a900f72aacc3dc7dada0";
        isLibrary = true;
        isExecutable = true;
        libraryHaskellDepends = [ base parsec text transformers ];
@@ -119214,7 +119584,7 @@ self: {
      mkDerivation {
        pname = "simple-firewire";
        version = "0.1.3.4";
-       sha256 = "14fh3z3vqkmfgvgxja431ivm3lk1ksgrxaqjzz25wdc493j640ka";
+       sha256 = "6a0262e44884355ec4ff12ab9e9f9e61d251770c8328d9df7eae4ebcc71fd091";
        libraryHaskellDepends = [ base bindings-dc1394 CV ];
        homepage = "https://github.com/aleator/simple-firewire";
        description = "Simplified interface for firewire cameras";
@@ -119229,7 +119599,7 @@ self: {
      mkDerivation {
        pname = "simple-form";
        version = "0.5.0";
-       sha256 = "01pqp7593vxf32fw18g7351qblj4lxvbgvs0psgb9aghsw3dss53";
+       sha256 = "a368dd06d7f0a9b49ebe40efb776a744d2854319e7a1c09d18aeef91cab9f806";
        libraryHaskellDepends = [
          base blaze-html digestive-functors email-validate network-uri
          old-locale text time transformers
@@ -119245,7 +119615,7 @@ self: {
      mkDerivation {
        pname = "simple-genetic-algorithm";
        version = "0.2.0.0";
-       sha256 = "14gy8bmkvv81zd1hmdzmmdzf4pspn4nymfpjx07jxcgm5isn49qi";
+       sha256 = "112762752cf5b12e0fe8f2baea2db1575fe27eabf5b70a43fb01ed3deb42fe91";
        isLibrary = true;
        isExecutable = true;
        libraryHaskellDepends = [ base parallel random ];
@@ -119263,7 +119633,7 @@ self: {
      mkDerivation {
        pname = "simple-genetic-algorithm-mr";
        version = "0.4.0.0";
-       sha256 = "193n24n5dpmdha85h4vn0kx846hppyzbc9f75wgndc7y7vm1qagy";
+       sha256 = "fe291cea3efeb0661f2fc725b6bebf171a82fa047613589082adde562c1176a4";
        isLibrary = true;
        isExecutable = true;
        libraryHaskellDepends = [
@@ -119282,7 +119652,7 @@ self: {
      mkDerivation {
        pname = "simple-get-opt";
        version = "0.1.0.0";
-       sha256 = "1hia6kjx3nnv6i5wrkmvj6vz52pw12fwsz48gkz7049ygpa5jnl5";
+       sha256 = "855a59d47d3e1170fe7c887ccd9d08fc8af2b791bbcecc4b34dbdad1e5342ac2";
        libraryHaskellDepends = [ base ];
        description = "A simple library for processing command-line options";
        license = stdenv.lib.licenses.bsd3;
@@ -119295,7 +119665,7 @@ self: {
      mkDerivation {
        pname = "simple-index";
        version = "0.1.0.1";
-       sha256 = "0w5nqhabv1rdbgnjw5vgx6p19dhqiq6xn5ljld3s7ndfk8nfddgy";
+       sha256 = "feb5e62c9aaed9a347a39216db0d8e18b614aee96f172eed5b2d87bd14c4b670";
        libraryHaskellDepends = [
          base containers hashable safecopy unordered-containers
        ];
@@ -119312,7 +119682,7 @@ self: {
      mkDerivation {
        pname = "simple-log";
        version = "0.3.2";
-       sha256 = "1nlnxjv2p6fkk069480czn0wg1m2jcw1g2sb38cb524kv0qn1kr0";
+       sha256 = "20cf6031d89388b2181a4b8b173893a286c781fd0c20920c98d3992bb6ec96da";
        libraryHaskellDepends = [
          base containers deepseq directory filepath
          MonadCatchIO-transformers mtl SafeSemaphore text time transformers
@@ -119327,7 +119697,7 @@ self: {
      mkDerivation {
        pname = "simple-log-syslog";
        version = "0.2.0";
-       sha256 = "1619jsxgz5afmwhjcixg54i7dhh8jl29cmziifjrg60mm4rf2c34";
+       sha256 = "6430e132a9159897a58bf15796049508c2762229af472621af4e95ffba962998";
        libraryHaskellDepends = [ base hsyslog simple-log text ];
        jailbreak = true;
        homepage = "http://github.com/mvoidex/simple-log-syslog";
@@ -119342,7 +119712,7 @@ self: {
      mkDerivation {
        pname = "simple-neural-networks";
        version = "0.2.0.1";
-       sha256 = "07brvfs19qprbpiys38gw3ypkwyx8y31fdil3kkzc9gszvcfi7vy";
+       sha256 = "7e9fe8d8fefa25f6e71c3436178647ddf379fde00f0dede35df9e214b4db791d";
        isLibrary = true;
        isExecutable = true;
        libraryHaskellDepends = [
@@ -119365,7 +119735,7 @@ self: {
      mkDerivation {
        pname = "simple-nix";
        version = "0.1.0.4";
-       sha256 = "1kyarxkp9zdf6k1jpx9a5yjrjghbr52ranfzrbcnb8kdnzi0mh0f";
+       sha256 = "0ec00ae2b76da265d9cadf599545c90b3e99a52f2af52bc334aefd7467cfcacf";
        libraryHaskellDepends = [
          base classy-prelude error-list MissingH mtl parsec system-filepath
          text text-render unordered-containers
@@ -119384,7 +119754,7 @@ self: {
      mkDerivation {
        pname = "simple-observer";
        version = "0.0.1";
-       sha256 = "1njzw6zjarlpjrmbkxwivr9azj8v1298bsd1ai3ddlmylwyhn24r";
+       sha256 = "99080b3da7bed2d64654a1e98592081bc9af52de91f7b96a96976625bfe15fda";
        libraryHaskellDepends = [ base ];
        homepage = "http://github.com/gimbo/observer.hs";
        description = "The Observer pattern";
@@ -119398,7 +119768,7 @@ self: {
      mkDerivation {
        pname = "simple-pascal";
        version = "0.1";
-       sha256 = "1nrm52agsgr2gxljv14l7f713jvbfa99qnzkcni2s7777xc33dkk";
+       sha256 = "73b631583fe71c2da265f35b9c92726bcb118e3b94842d697f223ffd942835db";
        isLibrary = true;
        isExecutable = true;
        libraryHaskellDepends = [
@@ -119416,7 +119786,7 @@ self: {
      mkDerivation {
        pname = "simple-pipe";
        version = "0.0.0.28";
-       sha256 = "11bvk1dwi6anmnsvv3hi7ii60yy3d64g38vfmxhabh93sjr4b4nm";
+       sha256 = "d59245b2d423c1a560af6ea3f18869c37b60623c118ebdb5ad5699c85b987b85";
        libraryHaskellDepends = [
          base bytestring lifted-base monad-control monads-tf stm
          transformers-base
@@ -119435,7 +119805,7 @@ self: {
      mkDerivation {
        pname = "simple-postgresql-orm";
        version = "0.9.0.1";
-       sha256 = "0j1v64ywfchxjdidy5pb1dzab0qhn516vcy580incw1bminyh3rz";
+       sha256 = "3f0fe86dac2b70662340c5b36d42b11083a57e0beb16df62931d32c73d313b48";
        libraryHaskellDepends = [
          base bytestring directory filepath postgresql-orm postgresql-simple
          resource-pool simple transformers
@@ -119451,7 +119821,7 @@ self: {
      mkDerivation {
        pname = "simple-reflect";
        version = "0.3.2";
-       sha256 = "1dpcf6w3cf1sfl9bnlsx04x7aghw029glj5d05qzrsnms2rlw8iq";
+       sha256 = "38224eb3d0d5eafc7101ad48fa92001c3e753a015d53bb12753a3836b871ecb6";
        libraryHaskellDepends = [ base ];
        homepage = "http://twanvl.nl/blog/haskell/simple-reflection-of-expressions";
        description = "Simple reflection of expressions containing variables";
@@ -119463,7 +119833,7 @@ self: {
      mkDerivation {
        pname = "simple-rope";
        version = "0.1";
-       sha256 = "187ghgn8nivvn5m8nsn0vrjh8mr6h7n6r1p1119gr4h3m2hpmrpl";
+       sha256 = "f4e67aa1a80392fc5208e1866cec8126570465dec06a8b6ab17b478bec83efa0";
        libraryHaskellDepends = [ base bytestring QuickCheck ];
        homepage = "http://github.com/jkff/haskell-rope";
        description = "Memory-efficient strings with concatenation and splitting";
@@ -119477,7 +119847,7 @@ self: {
      mkDerivation {
        pname = "simple-sendfile";
        version = "0.2.21";
-       sha256 = "0xzxcz60gl22w3rxjvw0s6js0g5mi6as1n48gl37dv4lbrn9s8v1";
+       sha256 = "61239d6c5e94ec76067d88d8a09589b53ca0a5d1806fd9f3e042d007cc67fd77";
        libraryHaskellDepends = [ base bytestring network unix ];
        testHaskellDepends = [
          base bytestring conduit conduit-extra directory hspec HUnit network
@@ -119494,7 +119864,7 @@ self: {
      mkDerivation {
        pname = "simple-server";
        version = "0.0.3";
-       sha256 = "0qmqkcyikyjcfsq82w0i54ydizfnp72h0qfsbjw5qjizf4l3awcr";
+       sha256 = "99713528713f4a5cb85cda6100c5b9d6fdd83c29117081b0764cfa193d9bb862";
        libraryHaskellDepends = [
          base bytestring concurrent-extra containers hashtables network time
          unbounded-delays
@@ -119511,7 +119881,7 @@ self: {
      mkDerivation {
        pname = "simple-session";
        version = "0.10.0.0";
-       sha256 = "1vqpikn6ml4fmz9pg29blw1c5ck8d4xx1qrb388jw57x24gknp0k";
+       sha256 = "135c3b1f11fd142e111a2be3d03b6968b2c202a72b8977d3af8ed06aec8c17ef";
        libraryHaskellDepends = [
          base base64-bytestring blaze-builder byteable bytestring containers
          cookie cryptohash http-types simple transformers wai
@@ -119527,7 +119897,7 @@ self: {
      mkDerivation {
        pname = "simple-sessions";
        version = "0.1.3";
-       sha256 = "08abag1im9gp2jpndd12sv911ca2qwh6frrz6qr87mj11xfhbky5";
+       sha256 = "c5cf055d0f41d68332363f676720c742b110d2d622b466af14f7a51ac3534b21";
        libraryHaskellDepends = [ base indexed synchronous-channels ];
        homepage = "http://www.eecs.harvard.edu/~tov/pubs/haskell-session-types/";
        description = "A simple implementation of session types";
@@ -119539,7 +119909,7 @@ self: {
      mkDerivation {
        pname = "simple-smt";
        version = "0.6.0";
-       sha256 = "15dnd6vjf8zl0bi5r4pczxdns8614rvdq1f44sgrmy8crc4x9d0c";
+       sha256 = "0cb4d409cb0cf99a9f26c405dc7626c1206d5bffec925ce202f42327b769b695";
        libraryHaskellDepends = [ base process ];
        description = "A simple way to interact with an SMT solver process";
        license = stdenv.lib.licenses.bsd3;
@@ -119552,7 +119922,7 @@ self: {
      mkDerivation {
        pname = "simple-sql-parser";
        version = "0.4.1";
-       sha256 = "0hz5acbkn9i46c8hpx258vkyj0q9ii4kh5wsjjj79avlnal2gz8q";
+       sha256 = "18fd27a8b274ab74a4949a1738498c0903e9e74645f40b113324263b1753e543";
        isLibrary = true;
        isExecutable = true;
        libraryHaskellDepends = [ base mtl parsec pretty ];
@@ -119572,7 +119942,7 @@ self: {
      mkDerivation {
        pname = "simple-stacked-vm";
        version = "0.1.1";
-       sha256 = "1grhdaf6z6illki5km1glliaaqlyvskwjvvcqz2vh8467arsy2pd";
+       sha256 = "ed0aafb33a8620b8c5c76c6fc9a7de9e62a522a52fd459e2a4349a6f9c6a30bf";
        isLibrary = true;
        isExecutable = true;
        libraryHaskellDepends = [
@@ -119587,7 +119957,7 @@ self: {
      mkDerivation {
        pname = "simple-tabular";
        version = "0.1.0.0";
-       sha256 = "0p7rd8y6rhwg0ap6cib7l32bglvfkvbzg938pdwpb2ss6cv8b9zs";
+       sha256 = "faa78536335a8b7579bb68a4f7d79e6ed3b7c4a0674566ae028fc36c3c6af95c";
        libraryHaskellDepends = [ base ];
        jailbreak = true;
        homepage = "http://github.com/BartMassey/simple-tabular";
@@ -119602,7 +119972,7 @@ self: {
      mkDerivation {
        pname = "simple-templates";
        version = "0.8.0.0";
-       sha256 = "1lmls90fbd18bklhhblfm0983w9bk66jj8iad3jzi5gd2injwj78";
+       sha256 = "e8482e6d14ed95f8e5682a22298d992bf18112a88e2e08e95c28b4e540d2b4d2";
        libraryHaskellDepends = [
          aeson attoparsec base scientific text unordered-containers vector
        ];
@@ -119620,7 +119990,7 @@ self: {
      mkDerivation {
        pname = "simple-vec3";
        version = "0.1.0.1";
-       sha256 = "1vzx88drwg40a9b7dzz4nbd5faawrc15wgyd1b12zmrsysn0h6s4";
+       sha256 = "441b08acf63ad72fc20acd3f5e02cb5c2957dab2e4ff765652803c9e1b42fdef";
        libraryHaskellDepends = [ base vector ];
        jailbreak = true;
        homepage = "http://github.com/dzhus/simple-vec3/";
@@ -119634,7 +120004,7 @@ self: {
      mkDerivation {
        pname = "simpleargs";
        version = "0.2.1";
-       sha256 = "1grjjpb3397wnr6sd0bn679k9pfg1zlm61350zd2gj5yq6pshl6p";
+       sha256 = "d750a8afc1bec827da07650453e90fcfdd34d3317681a64db6fca431d69532bf";
        libraryHaskellDepends = [ base ];
        homepage = "http://malde.org/~ketil/simpleargs";
        description = "Provides a more flexible getArgs function with better error reporting";
@@ -119648,7 +120018,7 @@ self: {
      mkDerivation {
        pname = "simpleirc";
        version = "0.3.1";
-       sha256 = "1mwhqa5gby38hlbq0shjbff4whhblw00x8wksqbh47jd6i6ihww5";
+       sha256 = "8573184d344d1e0217d693a30e00a70b424e9c5b126a80178568f8f58ac290d7";
        libraryHaskellDepends = [
          base bytestring connection containers network old-locale time
        ];
@@ -119664,7 +120034,7 @@ self: {
      mkDerivation {
        pname = "simpleirc-lens";
        version = "0.1.0.0";
-       sha256 = "0lr4zrp8h7xgg8zsznawqkkzh3pvlzfw5hl6n0hss5ramb71ccy5";
+       sha256 = "c53316ceaa2a17ad21b086c2c2dda7fb0ef8e7c45cd9af3f7aaf1f886efe2453";
        revision = "2";
        editedCabalFile = "618750d5b230316747d59d784bd40481a4404443316fc9c3a73e1349e3d10975";
        libraryHaskellDepends = [ base bytestring simpleirc ];
@@ -119681,7 +120051,7 @@ self: {
      mkDerivation {
        pname = "simplenote";
        version = "1.0";
-       sha256 = "0kggnvbhvzrsqj387vqq2xpspk4xn3830k65g4cc642gmw4l803v";
+       sha256 = "7b004409af4f10c31879c54c30d0b09dccab6f1718ef8386c43aff0dd7b6ef4d";
        libraryHaskellDepends = [
          base bytestring curl dataenc download-curl HTTP json time
          utf8-string
@@ -119698,7 +120068,7 @@ self: {
      mkDerivation {
        pname = "simpleprelude";
        version = "1.0.1.3";
-       sha256 = "0qlhh9m455fh8w9hdzykgxbw699mkd926ar031j99dhimca2d4hj";
+       sha256 = "12922614ab11b6946418202b23529b3525c3577fd3ff061347d095426a829062";
        isLibrary = true;
        isExecutable = true;
        libraryHaskellDepends = [ base ];
@@ -119716,7 +120086,7 @@ self: {
      mkDerivation {
        pname = "simplesmtpclient";
        version = "0.2";
-       sha256 = "0z8g82222nvh3yhn8qisr8qqnsv02zxjyzs32qrcg2pshbd5mdj8";
+       sha256 = "48b65ada82fa8ac73216437f2ffb17606b8b31ca3a6264a11f705b2184400f7d";
        revision = "1";
        editedCabalFile = "e6021c7bbf5e50c15433dca491f4618483229203c810a7b71e7c42094e13ad25";
        libraryHaskellDepends = [ array base directory network old-time ];
@@ -119729,7 +120099,7 @@ self: {
      mkDerivation {
        pname = "simplessh";
        version = "0.2.0.5";
-       sha256 = "1f0rck8shcm69bg2n2ijjad6dzrybfyrjqpsx5qh333mmz0q7bbq";
+       sha256 = "78ad83c1af758c0171e9fa6299bd5b3eff669a92320a2bde4aa632a8d16419b8";
        libraryHaskellDepends = [ base bytestring mtl ];
        librarySystemDepends = [ ssh2 ];
        homepage = "http://hub.darcs.net/thoferon/simplessh";
@@ -119745,7 +120115,7 @@ self: {
      mkDerivation {
        pname = "simplex";
        version = "0.3.8";
-       sha256 = "0z8ysg43dydij5l271ary8g5l26k0fvsymi99ycyjnl2ij1sg482";
+       sha256 = "0291a7838c825ae9994f2956afb703d3085a1ef25985236891b1f936c8d31e7d";
        isLibrary = false;
        isExecutable = true;
        executableHaskellDepends = [
@@ -119763,7 +120133,7 @@ self: {
      mkDerivation {
        pname = "simplex-basic";
        version = "0.0.0.1";
-       sha256 = "180bnrka1id16scz4zzi60m8692b7pyicfzfbzvi8rz1shl038zq";
+       sha256 = "f8a30128d4e16714f75fee3b16fd3d4b24832a30f17ff29936a1c5a066b60ba0";
        libraryHaskellDepends = [
          base bifunctors linear-grammar mtl QuickCheck transformers
        ];
@@ -119780,7 +120150,7 @@ self: {
      mkDerivation {
        pname = "simseq";
        version = "0.0";
-       sha256 = "0i60ksi5xc0d0rg5xzhbdjv2f3b5jr6rl9khn9i2b1n9sh1lv36m";
+       sha256 = "d58c4d03d4c9862562b270269a4d96650d27b66c0bfe5e5e060db05ea29ec044";
        isLibrary = false;
        isExecutable = true;
        executableHaskellDepends = [ base bio bytestring random ];
@@ -119795,7 +120165,7 @@ self: {
      mkDerivation {
        pname = "simtreelo";
        version = "0.1.1.0";
-       sha256 = "1j7q2mld8np16nmq8w3lx87j1f530jpxv4jlpf038k42pf4p23l2";
+       sha256 = "820e7189bb824c3480bb5492ddaf04a3b8200fea747084ab35e15ad46815f8c8";
        libraryHaskellDepends = [ base containers ];
        description = "Loader for data organized in a tree";
        license = stdenv.lib.licenses.gpl3;
@@ -119809,7 +120179,7 @@ self: {
      mkDerivation {
        pname = "sindre";
        version = "0.4";
-       sha256 = "0p76rsk02p6rw51ppbr3j7ydk57k34684qf50nrz5qd0jrnapjm2";
+       sha256 = "a2caab6c96a0e1f2b305c561820c19f394d9fc9123af7b43e1d95c01a6cee65c";
        isLibrary = true;
        isExecutable = true;
        libraryHaskellDepends = [
@@ -119836,7 +120206,7 @@ self: {
      mkDerivation {
        pname = "singleton-nats";
        version = "0.3.0.1";
-       sha256 = "1zgrvpszlvbq3mhfrs50dz2wd3bx6zxpyh0cj1zlwbn62psbdqxm";
+       sha256 = "b5e3b6f415c62e4e7f900c407ffb377d8dc6c56fa0e8ec601d786dfaf5ddf9fd";
        libraryHaskellDepends = [ base singletons ];
        description = "Unary natural numbers relying on the singletons infrastructure";
        license = stdenv.lib.licenses.bsd3;
@@ -119849,7 +120219,7 @@ self: {
      mkDerivation {
        pname = "singletons";
        version = "1.1.2.1";
-       sha256 = "1lxbajfwq65bkl73cr3zqzcqy67vqbq9sf8w9ckrik4713sx0mhb";
+       sha256 = "0b56d0f50887cc98274b1c399df0c2fb188fd9c77f64360e9dab18cc9d54abd3";
        libraryHaskellDepends = [
          base containers mtl template-haskell th-desugar
        ];
@@ -119866,7 +120236,7 @@ self: {
      mkDerivation {
        pname = "sink";
        version = "0.1.0.1";
-       sha256 = "04ny9450h2mlw1j0gn6a1vvgwsk3gbhhzshqv2sbcg5pwkzkdrzp";
+       sha256 = "f7e736ffe4b73cb6b4d818ea0fe17a636afef60ecad80764e0b40a080a49de12";
        libraryHaskellDepends = [ base ];
        jailbreak = true;
        description = "An alternative to lazy I/O that doesn't conflate execution with evaluation";
@@ -119880,7 +120250,7 @@ self: {
      mkDerivation {
        pname = "siphash";
        version = "1.0.3";
-       sha256 = "1wq5dan30ggjgmravy92ylqjvjv1q7mxrmddr7zc8h6aqr0wx0fg";
+       sha256 = "cf81ce41c6ca40c4fec9add5dcebc161cb2d31f522f9ad727df23d30ac6a05f3";
        libraryHaskellDepends = [ base bytestring cpu ];
        testHaskellDepends = [
          base bytestring QuickCheck test-framework
@@ -119898,7 +120268,7 @@ self: {
      mkDerivation {
        pname = "sirkel";
        version = "0.1";
-       sha256 = "0hhphhdvzcq9az5zriip7sgypfwbf5plx65s96nvrm2lznw4pzan";
+       sha256 = "56fd4bb8fd54d4bcad49ba984e6f718bbbeb9f3e37c6fccb5709b3bf1b841742";
        libraryHaskellDepends = [
          base binary bytestring containers hashtables haskell98 random
          remote SHA transformers
@@ -119913,7 +120283,7 @@ self: {
      mkDerivation {
        pname = "sitemap";
        version = "0.1.2";
-       sha256 = "0njb20w6kazsqgw61ykvfx3syqywv9frs7ch9bf2sr0i1d3b61bd";
+       sha256 = "6d05b3460b11642ddc4a901d9d5ddadc63af47777bfa60f8c3faab6938104b5a";
        libraryHaskellDepends = [ base lens taggy taggy-lens text ];
        homepage = "http://github.com/alpmestan/sitemap";
        description = "Sitemap parser";
@@ -119927,7 +120297,7 @@ self: {
      mkDerivation {
        pname = "sized";
        version = "0.1.0.0";
-       sha256 = "00n9fb7kk3c6dy4j19d9ikmynllpxc7yd51sign0rhvnasmyrghl";
+       sha256 = "14beecab5676c30cec8b3a94e60feb9752ebeb8ca9a520896f868d39cf72c902";
        libraryHaskellDepends = [
          base constraints containers ListLike monomorphic type-natural
          vector
@@ -119945,7 +120315,7 @@ self: {
      mkDerivation {
        pname = "sized-types";
        version = "0.5.1";
-       sha256 = "1nwr92gy8031f18w367ys0l27q4qvpkrkikbj03m93q2i7y74ry7";
+       sha256 = "c76772fc89028f5407906bc699e7dd98e02328d0fe98c151706100e49f4899db";
        isLibrary = true;
        isExecutable = true;
        libraryHaskellDepends = [
@@ -119966,7 +120336,7 @@ self: {
      mkDerivation {
        pname = "sized-vector";
        version = "1.4.2.0";
-       sha256 = "0lz1fr2n5x7xfb6y8l7prnawj1p3fp79bbgi98w1n22wazcy9jkm";
+       sha256 = "75cae4d9575c081b384af1ad95ce75e306c995cdf750e4cd72fdf4624576e153";
        libraryHaskellDepends = [
          base constraints deepseq equational-reasoning hashable monomorphic
          singletons type-natural
@@ -119985,7 +120355,7 @@ self: {
      mkDerivation {
        pname = "sizes";
        version = "2.3.2";
-       sha256 = "0xns0xl3khks1jvsmxh0nqf1saxs7qscvkbcg4270pp7n6lziqdg";
+       sha256 = "afe1f8a9b1e75e7004796ccdcd343eba2b1d1cb600f6aab70c7ac2396807da76";
        isLibrary = false;
        isExecutable = true;
        executableHaskellDepends = [
@@ -120004,7 +120374,7 @@ self: {
      mkDerivation {
        pname = "sjsp";
        version = "0.1.0";
-       sha256 = "0x76hrzm0ikijsf5n425bagzin2x463mcmlnjqvinrb6ni47f4bl";
+       sha256 = "74117748b466651b379696565687215dd8f89f5a45105b9c967146507f86e674";
        revision = "1";
        editedCabalFile = "309e00100db2c1bae2d292c485f2dc1a68e1c72a848a2142c3f0637c494dd727";
        isLibrary = false;
@@ -120025,7 +120395,7 @@ self: {
      mkDerivation {
        pname = "skein";
        version = "1.0.9.3";
-       sha256 = "0k7ibm4ykvypz6dm6jgqx0aj7qlg34cg841vipyjkbykp8nv3fn7";
+       sha256 = "c7bab12dbad3af29fd8d3b10f418198fe22315e8f849539bf9d7efe9495df14c";
        libraryHaskellDepends = [
          base bytestring cereal crypto-api tagged
        ];
@@ -120044,7 +120414,7 @@ self: {
      mkDerivation {
        pname = "skeleton";
        version = "0.1.0.0";
-       sha256 = "10bcw4l4w7myrbpmalg4mvpcyzbrnr8dafsplxkjlb6bnhc33scb";
+       sha256 = "8be93118b4cb2c2a67a7573bd550b6797dcfeeaee45155efcabe1e4e28e16c81";
        isLibrary = false;
        isExecutable = true;
        executableHaskellDepends = [
@@ -120063,7 +120433,7 @@ self: {
      mkDerivation {
        pname = "skell";
        version = "0.1.0.0";
-       sha256 = "0lnlqcw5slv5gshdq35il16pm57fh07hkd7zx95gfxx1aipyr4lp";
+       sha256 = "9792ec6f54a177f74aeaffb4090f80ee947a4da0b10cdca07e65535d38c3d452";
        libraryHaskellDepends = [
          base blaze-html bytestring containers http-types text wai
        ];
@@ -120081,7 +120451,7 @@ self: {
      mkDerivation {
        pname = "skype4hs";
        version = "0.0.0.0";
-       sha256 = "0mrd63yfmxxmv3l5v5i01rh4lyl831pfb06k9bxvc6m5q88fxglp";
+       sha256 = "97beee10c2a51ab6fb4ad380e56e18887a4a600e20965de8d8b5f7eafc302d57";
        libraryHaskellDepends = [
          attoparsec base bytestring lifted-base monad-control mtl stm text
          time transformers-base word8 X11
@@ -120100,7 +120470,7 @@ self: {
      mkDerivation {
        pname = "skypelogexport";
        version = "0.2";
-       sha256 = "0rk9m9fw6as7zzjkm4jhwgw7nbs05ky1s556xmjbnkh6l9xp2chw";
+       sha256 = "1c32717ba2064ebb64eda6141dfc2c402f7bf8e350923ae5ff472bc35daa6966";
        isLibrary = false;
        isExecutable = true;
        executableHaskellDepends = [
@@ -120121,7 +120491,7 @@ self: {
      mkDerivation {
        pname = "slack";
        version = "0.1.0.0";
-       sha256 = "0sqi4g8wavxdd98cnv869qx2p9g77f6dznxlfmgv1jlvd4a1ya67";
+       sha256 = "c7281f14699bcab05f75b4dbdf8c3be7a52b3a4e066dcb506aad6fc5d123116b";
        libraryHaskellDepends = [
          aeson base containers either http-conduit mtl old-locale text time
          transformers
@@ -120141,7 +120511,7 @@ self: {
      mkDerivation {
        pname = "slack-api";
        version = "0.5";
-       sha256 = "1jjm7qzb1s2z8c7ikwsvz2bp7f3dx3qcqw7kcas42xp0ziwnl50m";
+       sha256 = "15146a79fce07641b462f370ccf0e86db87397f85bf3190f435fe8b03e3e55ca";
        libraryHaskellDepends = [
          aeson base bytestring containers errors HsOpenSSL io-streams lens
          lens-aeson monad-loops mtl network network-uri openssl-streams text
@@ -120159,7 +120529,7 @@ self: {
      mkDerivation {
        pname = "slack-notify-haskell";
        version = "0.2.3";
-       sha256 = "0sz05v40b78qdpz8cqpnblhjy4dxqsz5175hq5083j7iv3xi3kc7";
+       sha256 = "87cd11fbd8f1c88140c1b09c50bec6bd112f215df66286fe6d189d05c82ee06b";
        isLibrary = true;
        isExecutable = true;
        libraryHaskellDepends = [
@@ -120180,7 +120550,7 @@ self: {
      mkDerivation {
        pname = "slave-thread";
        version = "1.0.0.0";
-       sha256 = "0snk0v126a79q2blddbznz50l89jfap4y4xs9i76pk0b0dcik319";
+       sha256 = "298c1959030bcc6b4e4cba134fae7232210acab77fb54697c0e92823c206d36a";
        libraryHaskellDepends = [
          base base-prelude list-t mmorph partial-handler stm-containers
          transformers
@@ -120201,7 +120571,7 @@ self: {
      mkDerivation {
        pname = "slice-cpp-gen";
        version = "0.3.0.0";
-       sha256 = "0mvjj8hs8837dby54ii71wd1sg2z3r14sr7w2hnj2nhnjy7c23yy";
+       sha256 = "de0fc18e97165a212d14fc644d421e5f3c1d1a0f274652fc6a6720a421927257";
        isLibrary = false;
        isExecutable = true;
        executableHaskellDepends = [
@@ -120220,7 +120590,7 @@ self: {
      mkDerivation {
        pname = "slidemews";
        version = "0.3";
-       sha256 = "0x6blvdqwf9sqspwj48drasizx1pb1i92a0lp06szwa2nszdvzf0";
+       sha256 = "c0fdddbeb642f1af0db8142891625837f41fb5ca0d11c9afc63a398edba6cb74";
        isLibrary = false;
        isExecutable = true;
        executableHaskellDepends = [
@@ -120240,7 +120610,7 @@ self: {
      mkDerivation {
        pname = "sloane";
        version = "2.0.5";
-       sha256 = "1jmnyw5n2k9c0bsdgna7hxc6yxjrycss02wjwsavbq13i7amq8i9";
+       sha256 = "29225cd58923e0b595e6920ba035f359766f588747d9d7f4022c4d610bf7b6ca";
        isLibrary = false;
        isExecutable = true;
        executableHaskellDepends = [
@@ -120260,7 +120630,7 @@ self: {
      mkDerivation {
        pname = "slot-lambda";
        version = "0.1.0.3";
-       sha256 = "1npin7yaharbi5nzwksj1j7rf2k1nvmr1jgcf2xpnvvbcga7l69i";
+       sha256 = "31197ad4636b6f7bbb70ecc990ebb6610a978f0c524ffe6d892b2ba8fcb1f1da";
        libraryHaskellDepends = [
          base containers haskell-src-exts haskell-src-meta syb
          template-haskell vector
@@ -120275,7 +120645,7 @@ self: {
      mkDerivation {
        pname = "sloth";
        version = "0.0.2";
-       sha256 = "0x3iw1mqbl3q723kkxr6b0i1hxcfb4sink4kmg6xnpzd3hwaspq9";
+       sha256 = "095fad381ced5fdbcdab934c1b35598e7518225826f739873878d0856be07174";
        libraryHaskellDepends = [ base mtl process ];
        description = "Testing for minimal strictness";
        license = stdenv.lib.licenses.bsd3;
@@ -120287,7 +120657,7 @@ self: {
      mkDerivation {
        pname = "smallarray";
        version = "0.2.2.4";
-       sha256 = "16fgxsg8grxhqx6d4s3mm89qbkw2k72qvr4r701ih1i8gmf1ms1z";
+       sha256 = "3fe81a5c7d280618033899e48dc59982cf8513aa7568d24cc7b0e7879eeecf99";
        libraryHaskellDepends = [ base bytestring deepseq hashable ];
        jailbreak = true;
        homepage = "http://community.haskell.org/~aslatter/code/bytearray";
@@ -120303,7 +120673,7 @@ self: {
      mkDerivation {
        pname = "smallcaps";
        version = "0.6.0.0";
-       sha256 = "1vjzvsvci8zn4y2lh7s2kh6v1c6447nfksqxcv468zz8d1mflsfi";
+       sha256 = "d169ea6a68e87f64c8661debe9ec21c4b0b00d9c421f488527f6a3c8b6de5fee";
        isLibrary = true;
        isExecutable = true;
        libraryHaskellDepends = [
@@ -120324,7 +120694,7 @@ self: {
      mkDerivation {
        pname = "smallcheck";
        version = "1.1.1";
-       sha256 = "1ygrabxh40bym3grnzqyfqn96lirnxspb8cmwkkr213239y605sd";
+       sha256 = "4d17607c1a620491e7e495a17575b73952932c761e7f9bdfa87e0102fb52f9f9";
        libraryHaskellDepends = [ base ghc-prim logict mtl pretty ];
        homepage = "https://github.com/feuerbach/smallcheck";
        description = "A property-based testing library";
@@ -120338,7 +120708,7 @@ self: {
      mkDerivation {
        pname = "smallcheck-laws";
        version = "0.1";
-       sha256 = "11b1fmbksw7z7inn9as73vjplm39d8kwmq10v8gj0yfw1g872xh0";
+       sha256 = "007671d00bdc79201fda20e0ca276a69547ae51e47ab646d3cff703d57756185";
        revision = "1";
        editedCabalFile = "ff6bf8f4f1f7b95550c9adc53125bfb25dc665260f5121eaf811ca3a08e386a1";
        libraryHaskellDepends = [
@@ -120356,7 +120726,7 @@ self: {
      mkDerivation {
        pname = "smallcheck-lens";
        version = "0.1";
-       sha256 = "19awz3gphvkmb54j3mqqmqjzdjywdrrvsb9lp46gbhjazn94sxdl";
+       sha256 = "b4754d92fd4ac2f50cb9342dbd736edccbf625ae18d7214959756e78dff85ca5";
        libraryHaskellDepends = [
          base lens smallcheck smallcheck-series tasty tasty-smallcheck
          transformers
@@ -120376,7 +120746,7 @@ self: {
      mkDerivation {
        pname = "smallcheck-series";
        version = "0.4";
-       sha256 = "05iixqnq9mfqc2gbwxnhx640apbppck8zb8akkwz1linlypvym60";
+       sha256 = "c054bfafa736d2f0f99c0aad8f26bb775d0588e9d076be9e60d8d5842dee3116";
        libraryHaskellDepends = [
          base bytestring containers logict smallcheck text transformers
        ];
@@ -120391,7 +120761,7 @@ self: {
      mkDerivation {
        pname = "smallpt-hs";
        version = "0.1";
-       sha256 = "1g4g2sgj39pkm3ll4yv0q9dcmq2lyd26qkr1gir1svmxs6hdwp59";
+       sha256 = "a95cdea0d1bd6e1d727c214f6c44f354e0ca5ac2607b42e9a8f3a6219f168fbc";
        isLibrary = false;
        isExecutable = true;
        executableHaskellDepends = [ base vector ];
@@ -120409,7 +120779,7 @@ self: {
      mkDerivation {
        pname = "smallstring";
        version = "0.3.3";
-       sha256 = "1wkgbnknx9k56ikl6hpv91r9sav8v5qvl2w7z2jadgrlj29fy755";
+       sha256 = "a51cef929034bfa6a4f8870bba71d9682b9d7248fb4243673465a66ea75d6ff2";
        libraryHaskellDepends = [
          base bytestring deepseq hashable smallarray text utf8-string
        ];
@@ -120426,7 +120796,7 @@ self: {
      mkDerivation {
        pname = "smaoin";
        version = "0.3.0.0";
-       sha256 = "0j18pdpywgb01679b4f2aj7pzna1njh45giw1b1dsqqdp45gz2rp";
+       sha256 = "378bff0ab90d63ddc20a3cbe42a0b441d97f8f54c291958e09603dee6fbb2848";
        libraryHaskellDepends = [ base bytestring random text uuid ];
        testHaskellDepends = [ base bytestring QuickCheck ];
        homepage = "http://rel4tion.org/projects/smaoin-hs/";
@@ -120439,7 +120809,7 @@ self: {
      mkDerivation {
        pname = "smartGroup";
        version = "0.3.0";
-       sha256 = "10wb5v87xl54bsl2xxsh1fh54bgqbhmmkhyaa3ly23nm2f01cpnp";
+       sha256 = "d75e168013d50ee1e950cac3592b5cf82d52a00b50f72ea85ea4d07ed02e8b83";
        libraryHaskellDepends = [
          base bytestring containers template-haskell
        ];
@@ -120456,7 +120826,7 @@ self: {
      mkDerivation {
        pname = "smartcheck";
        version = "0.2.1";
-       sha256 = "1rkw4fhiidn9rfq4dvik58zr453jsh2l8xpswas2rsv6k5w0909r";
+       sha256 = "398104789966eb2cb4e2fa764405d47214923f2a33ee46b0cbc9b618a1237ce6";
        isLibrary = true;
        isExecutable = true;
        libraryHaskellDepends = [
@@ -120476,7 +120846,7 @@ self: {
      mkDerivation {
        pname = "smartconstructor";
        version = "0.2.0.0";
-       sha256 = "1082siphwd4xx9akqip78kzpqi19i3l53h0s2vghhdm5lwplcvlv";
+       sha256 = "9b6e462fa7a53608df161ac051e88829447cff44e7463c55ea9d340e6fd40281";
        libraryHaskellDepends = [ base template-haskell ];
        homepage = "http://github.com/frerich/smartconstructor";
        description = "A package exposing a helper function for generating smart constructors";
@@ -120488,7 +120858,7 @@ self: {
      mkDerivation {
        pname = "smartword";
        version = "0.0.0.5";
-       sha256 = "0dxw4jgmwcz92n2rymdrfaz1v8lc2wknql9ca5p98jc14l8c2bl3";
+       sha256 = "832ec110258149946e512c516c27178ca21dbe72b9559f8515e9335e9f24bc37";
        isLibrary = false;
        isExecutable = true;
        executableHaskellDepends = [
@@ -120505,7 +120875,7 @@ self: {
      mkDerivation {
        pname = "sme";
        version = "0.1";
-       sha256 = "1d3kjyskwzc7p5bi6pv9yxfa6l6dqkkqc24dmmxl5wx7vmbfma25";
+       sha256 = "45a8ea56dda7f3427bad8d0886e7c4cd50a35cf7695f1357b9877d3eb59773b4";
        libraryHaskellDepends = [ base ];
        description = "A library for Secure Multi-Execution in Haskell";
        license = stdenv.lib.licenses.bsd3;
@@ -120517,7 +120887,7 @@ self: {
      mkDerivation {
        pname = "smoothie";
        version = "0.4.0.2";
-       sha256 = "1g2lk58p8rbhi45j6q3r0w4103bxi6pn9i3c5i3525s8brl4y8ni";
+       sha256 = "d1224f685e481751462c6cc464af897d0d1008077960230b89706574519954bc";
        libraryHaskellDepends = [ aeson base linear text vector ];
        homepage = "https://github.com/phaazon/smoothie";
        description = "Smooth curves via several interpolation modes";
@@ -120529,7 +120899,7 @@ self: {
      mkDerivation {
        pname = "smt-lib";
        version = "0.0.2";
-       sha256 = "1phm50pabahrpxrzp25mfhpafzhp4hz8cxp6fp93rwh4cl7cckky";
+       sha256 = "7e4ec60e6504f23cd275e676863e24177ea72e74b588fb73bf19aaa52e2815de";
        libraryHaskellDepends = [ array base directory polyparse ];
        jailbreak = true;
        homepage = "http://tomahawkins.org";
@@ -120543,7 +120913,7 @@ self: {
      mkDerivation {
        pname = "smtLib";
        version = "1.0.7";
-       sha256 = "1jn2790x7g7n6jm5cfgd692n3l6iafyv0zyz40hx8ykcs4jh2rkf";
+       sha256 = "6e660125d16c7ad42120df7fb0bd53d1d0614532ed3956aa34f6bcd3413ac2ca";
        libraryHaskellDepends = [ base pretty ];
        description = "A library for working with the SMTLIB format";
        license = stdenv.lib.licenses.bsd3;
@@ -120557,7 +120927,7 @@ self: {
      mkDerivation {
        pname = "smtlib2";
        version = "0.2";
-       sha256 = "1xkbsqhfjsnf3qx9x7n7hqp3l769k4bbrp1274sf9cqqgbcs2ny6";
+       sha256 = "c65ba1d97a18b3e4343922dcbc1699c91c3a2e86c79e9e3a1ece6ae920d66bf6";
        libraryHaskellDepends = [
          array atto-lisp attoparsec base blaze-builder bytestring
          constraints containers data-fix mtl process tagged text
@@ -120575,7 +120945,7 @@ self: {
      mkDerivation {
        pname = "smtp-mail";
        version = "0.1.4.5";
-       sha256 = "010fbrcbypajwd9fjjc35br9p5axl1pqd0n1v51585ncrlv2icyw";
+       sha256 = "dcb32836cdcc165442d9c182866fa05d959bf22a8349e952e3525dbf585e0e04";
        libraryHaskellDepends = [
          array base base16-bytestring base64-bytestring bytestring
          cryptohash filepath mime-mail network text
@@ -120594,7 +120964,7 @@ self: {
      mkDerivation {
        pname = "smtp-mail-ng";
        version = "0.1.0.2";
-       sha256 = "0jvjb3ps22p71b0vq7lgfyxmhjbzhsc3crs0cv3qsnkhz4ghvgbh";
+       sha256 = "70bd0d1ff9705a8dc76640673698867f4958bb778f1ebcc10ae70aa1ef58724b";
        libraryHaskellDepends = [
          attoparsec base base16-bytestring base64-bytestring bytestring
          crypto-random cryptohash filepath haskeline mime-mail mtl network
@@ -120612,7 +120982,7 @@ self: {
      mkDerivation {
        pname = "smtp2mta";
        version = "0.2";
-       sha256 = "0z36zvrh6xhg8s7wai65d2y6hz0qz016ick9a4yrjpqxxk78h902";
+       sha256 = "022488ceec1d5f993d5169b26802f8187c68bc68c544c58f460f7603f3fe667c";
        isLibrary = false;
        isExecutable = true;
        executableHaskellDepends = [ base haskell98 network process ];
@@ -120631,7 +121001,7 @@ self: {
      mkDerivation {
        pname = "smtps-gmail";
        version = "1.3.0";
-       sha256 = "0vbykxqrw0gdhxwgchvgvkxwh7pwyrc1wvl26x5wqlkmkalmkvv9";
+       sha256 = "69ef59a99a7552cc4b37826e1e58f6fc1ec8fbdc6f43f67887ed019e719f7e6d";
        libraryHaskellDepends = [
          attoparsec base base64-bytestring bytestring conduit conduit-extra
          cprng-aes data-default filepath mime-mail network resourcet
@@ -120649,7 +121019,7 @@ self: {
      mkDerivation {
        pname = "snake-game";
        version = "1.2";
-       sha256 = "1iy3m20ldc98agdi7n71ik8k2f62ybfg719z79lcf8pzynbfsrbd";
+       sha256 = "6d65ed96f5ff22c7683a3f85f3dcf2c23831d18ce1d813db5328b14681a8c3c7";
        libraryHaskellDepends = [ base GLUT OpenGL random ];
        description = "Snake Game Using OpenGL";
        license = stdenv.lib.licenses.bsd3;
@@ -120668,7 +121038,7 @@ self: {
      mkDerivation {
        pname = "snap";
        version = "0.14.0.6";
-       sha256 = "05xnil6kfxwrnbvg7sigzh7hl8jsfr8cvbjd41z9ywn6ymxzr7zs";
+       sha256 = "fa9ffc7bf5c6729f7e204daecd50765a220a0ffc2feaf3f6b29977370d8db617";
        isLibrary = true;
        isExecutable = true;
        libraryHaskellDepends = [
@@ -120693,7 +121063,7 @@ self: {
      mkDerivation {
        pname = "snap-accept";
        version = "0.1.0";
-       sha256 = "19sn7q9avb7y9j46fk7iga237qgcdm69sanb351c5s0lfgcpnf1m";
+       sha256 = "35387bd97314e8c24219cb2a9d4c6dece133847af14c67884cfeacad123e56a7";
        libraryHaskellDepends = [ base http-media snap-core ];
        jailbreak = true;
        homepage = "http://github.com/zimothy/snap-accept";
@@ -120707,7 +121077,7 @@ self: {
      mkDerivation {
        pname = "snap-app";
        version = "0.7.0";
-       sha256 = "1v3izzvxadjplir47ipi087sj6fcmfj5ivlhbkpp9ld7vj8sv2hi";
+       sha256 = "118aad91dca7d174ef5c90ee58a4abcc19a90f02f1c64372a45736d5f7ff71ec";
        description = "None";
        license = stdenv.lib.licenses.bsd3;
        hydraPlatforms = stdenv.lib.platforms.none;
@@ -120721,7 +121091,7 @@ self: {
      mkDerivation {
        pname = "snap-auth-cli";
        version = "0.1.0.1";
-       sha256 = "0spdn7zazd17yrcx004m4yag8vy4bac4997f81nfvy25jvg87hhl";
+       sha256 = "14c283de9645f8ed6c40eea444985ac46ff494279500d059f627b4affeb1ed6a";
        isLibrary = false;
        isExecutable = true;
        executableHaskellDepends = [
@@ -120739,7 +121109,7 @@ self: {
      mkDerivation {
        pname = "snap-blaze";
        version = "0.2.1.3";
-       sha256 = "0jpiykqgvdbhk1wk37qgfxmyrnx8553wnnmn7a4b3mq8zx8fzmlm";
+       sha256 = "95d6ef50ff08d7b1883ab65acb4729a8dbec6b770f9f31799870b5fdf0f4f14a";
        libraryHaskellDepends = [ base blaze-html snap-core ];
        homepage = "http://github.com/jaspervdj/snap-blaze";
        description = "blaze-html integration for Snap";
@@ -120751,7 +121121,7 @@ self: {
      mkDerivation {
        pname = "snap-blaze-clay";
        version = "0.1.0.0";
-       sha256 = "05zi9rjd37xznjj8yhm5har12mfrclsrwd9fbcwh5ngccd7h7fiy";
+       sha256 = "3eba034f63ecd902395b2e359e3565d95511b282a5428fa4b4bf9fd1644ef117";
        libraryHaskellDepends = [ base blaze-html clay snap-core ];
        jailbreak = true;
        homepage = "http://github.com/deckool/snap-blaze-clay";
@@ -120764,7 +121134,7 @@ self: {
      mkDerivation {
        pname = "snap-configuration-utilities";
        version = "0.1.0.0";
-       sha256 = "07cm60v7bz585fawfc8mml178z54zqfg8kb7ldln5bsa0ggpha2z";
+       sha256 = "5f2878df034aaf6269a3674df41cfea47c7402ad1531c7952ba8fc753630951d";
        libraryHaskellDepends = [
          base configurator text unordered-containers
        ];
@@ -120784,7 +121154,7 @@ self: {
      mkDerivation {
        pname = "snap-core";
        version = "0.9.7.2";
-       sha256 = "0lgnflwcjyiinrm75dy1flr37bvjn3yljx53cvlsb3ccfnxqwsjj";
+       sha256 = "526a8ebb758c8da5e966a37449fdb072af333275c1b7726ab6317ac93875f651";
        revision = "1";
        editedCabalFile = "d39520edcc970d9d1f683af9631ccbcad39536b9f88040b93efb66cbe7aefc55";
        libraryHaskellDepends = [
@@ -120808,7 +121178,7 @@ self: {
      mkDerivation {
        pname = "snap-cors";
        version = "1.2.9";
-       sha256 = "0s6bl9nldr96l0zjx1qh3zq9fs5wlrmagaalxsppjsln456gzjcd";
+       sha256 = "8dc9ff4c21966a79afee54a9a76aa6bc6897f01f10872e3fa026e5466da2cb68";
        libraryHaskellDepends = [
          attoparsec base bytestring case-insensitive hashable network
          network-uri snap text transformers unordered-containers
@@ -120825,7 +121195,7 @@ self: {
      mkDerivation {
        pname = "snap-elm";
        version = "0.1.1.2";
-       sha256 = "1lp76s5yqgw5zvkv13b4552zq9f2mrngp5l5vd8kwz9rhawgl6kr";
+       sha256 = "791afab882397d3e51db8596fb6caec225fc4529648db0e7fe853fec8b36e7d2";
        libraryHaskellDepends = [
          base bytestring directory Elm filepath process snap-core text
          transformers
@@ -120842,7 +121212,7 @@ self: {
      mkDerivation {
        pname = "snap-error-collector";
        version = "1.1.1";
-       sha256 = "1b0wsbk01zjxqmilan94h0dprnvnq4j8rhair54ra2lzyqsbdbcx";
+       sha256 = "9dadb634f69f0a9549c951c18c24c176db7c1b8024594563c55dfe00e6d21cac";
        libraryHaskellDepends = [
          async base containers monad-loops MonadCatchIO-transformers snap
          stm time transformers
@@ -120864,7 +121234,7 @@ self: {
      mkDerivation {
        pname = "snap-extras";
        version = "0.11.0.1";
-       sha256 = "1747qvwbn1rlrjk085rj1780nrsqw4ps78c13si3kkk697k4wcbm";
+       sha256 = "75314ee64966ce39a21e81a1a32fe158670bd009321704a6cc3407bbf8c6879c";
        isLibrary = true;
        isExecutable = true;
        libraryHaskellDepends = [
@@ -120891,7 +121261,7 @@ self: {
      mkDerivation {
        pname = "snap-loader-dynamic";
        version = "0.10.0.3";
-       sha256 = "0nk4knkxnfffs5pgf6x3ld83l174aymqlyasxbf7j10w0w8srmvw";
+       sha256 = "7cd7ac11071c0479dcea5a798aab57e4043a50a3a31bf76ed1ce39dba79d645a";
        libraryHaskellDepends = [
          base directory directory-tree hint mtl snap-core template-haskell
          time unix
@@ -120906,7 +121276,7 @@ self: {
      mkDerivation {
        pname = "snap-loader-static";
        version = "0.9.0.2";
-       sha256 = "0d6s7n6yryfs2jkw0hxvhvc79fhbj256askb1c6ksqhscxxxwz1m";
+       sha256 = "357cde7b671a623d0d0b6b6a658a900bba74d886bb43c0a714daf9ec8d3dda34";
        revision = "1";
        editedCabalFile = "c927448783c28f56bd57c7b09d147965b96e7b4c7320524b26c83bf10ab89c21";
        libraryHaskellDepends = [ base template-haskell ];
@@ -120924,7 +121294,7 @@ self: {
      mkDerivation {
        pname = "snap-predicates";
        version = "0.3.1";
-       sha256 = "02rksb2p8wgpla86313z6lwqli5f4ryv4wr95s61kamcpbmf18y5";
+       sha256 = "c5a3e0eabaacaa198c2e2973b27d26ae448a39357f846190a2f77174c5d2330b";
        libraryHaskellDepends = [
          attoparsec base bytestring case-insensitive containers monads-tf
          snap-core text transformers
@@ -120949,7 +121319,7 @@ self: {
      mkDerivation {
        pname = "snap-server";
        version = "0.9.5.1";
-       sha256 = "18ryin6f315picrs2159sn2668266l3xchs7jb8isw0gp52273xg";
+       sha256 = "af8f2344b90f701dd1924743d6073546206384d5a904a1338bb784e18c8d3ea3";
        revision = "1";
        editedCabalFile = "7909ad539e7d3f23f3c799d736d1a54d0a9098dd55fd6be75c13b57794bfaa5c";
        configureFlags = [ "-fopenssl" ];
@@ -120972,7 +121342,7 @@ self: {
      mkDerivation {
        pname = "snap-testing";
        version = "0.6.0.0";
-       sha256 = "1kzcdlfahhrpczihbr4f41p4ijps27lhghrh29csl6jl7n71lvqk";
+       sha256 = "136f1a8e3d541aaa591230c307e911faca486e208ee405e3673743a81c6deccf";
        libraryHaskellDepends = [
          async base bytestring containers digestive-functors HandsomeSoup
          hxt io-streams mtl process QuickCheck snap snap-core text
@@ -120997,7 +121367,7 @@ self: {
      mkDerivation {
        pname = "snap-utils";
        version = "0.1.2";
-       sha256 = "1kr09fj1jfs6sfmca51k0gwn4acya70s9irzay9yf5b9yyvka391";
+       sha256 = "210d35b7f76915e793573fc7a4c1519e2962f9033314c5aad3463b19a44b20cf";
        libraryHaskellDepends = [
          base bytestring heist http-types MonadCatchIO-transformers mtl snap
          snap-core text xmlhtml
@@ -121015,12 +121385,11 @@ self: {
      }:
      mkDerivation {
        pname = "snap-web-routes";
-       version = "0.5.0.0";
-       sha256 = "1ml0b759k2n9bd2x4akz4dfyk8ywnpgrdlcymng4vhjxbzngnniv";
+       version = "0.5.1.0";
+       sha256 = "a2d2257193d69613fe504a81596b21d6453a5e41fee959c904de2565c7bc8de0";
        libraryHaskellDepends = [
          base bytestring heist mtl snap snap-core text web-routes xmlhtml
        ];
-       jailbreak = true;
        homepage = "https://github.com/lukerandall/snap-web-routes";
        description = "Type safe URLs for Snap";
        license = stdenv.lib.licenses.bsd3;
@@ -121031,7 +121400,7 @@ self: {
      mkDerivation {
        pname = "snaplet-acid-state";
        version = "0.2.7";
-       sha256 = "0vjqcmcp0p8vmh7vzwv62bigbx1ck2vnaxlkqmg5wddn0mhfm6gx";
+       sha256 = "fd99ea6005b6355e5ec5937665b7982cf4f5e21266f3bf0fac1b5d705965586e";
        libraryHaskellDepends = [
          acid-state base mtl snap text transformers
        ];
@@ -121051,7 +121420,7 @@ self: {
      mkDerivation {
        pname = "snaplet-actionlog";
        version = "0.2.0.1";
-       sha256 = "177a1b9fvlqh59hd9b5y92lq8yxv14jh79aadkyhxb4i0l5rl9vv";
+       sha256 = "7b279a0b0591ac0efd6c4aa5032509bb7b84a948beacd4602a10d3edd20aea9c";
        libraryHaskellDepends = [
          base blaze-builder bytestring digestive-functors
          digestive-functors-heist digestive-functors-snap errors heist
@@ -121073,7 +121442,7 @@ self: {
      mkDerivation {
        pname = "snaplet-amqp";
        version = "1.1.0.0";
-       sha256 = "01qw28paifysk402lpb7y8dyhf401ls1l0dcn6fiigvczwxzmk91";
+       sha256 = "21cdfa3bff6cbf189db1ac011a340d8038e81bf2675d2a0099dabba82e121c07";
        libraryHaskellDepends = [
          amqp base bytestring configurator lens monad-control mtl network
          resource-pool snap transformers
@@ -121093,7 +121462,7 @@ self: {
      mkDerivation {
        pname = "snaplet-auth-acid";
        version = "0.1.0";
-       sha256 = "0i0py2rj2vkivl97fxnv87bpbsbms2ncdqbq4zs0777nbr717swm";
+       sha256 = "95eb134e5ef69c03f42778e1c6acd075e975d741db767712dd716e21b3f01744";
        libraryHaskellDepends = [
          acid-state aeson attoparsec base cereal clientsession directory
          errors filepath hashable lens MonadCatchIO-transformers mtl
@@ -121112,7 +121481,7 @@ self: {
      mkDerivation {
        pname = "snaplet-coffee";
        version = "0.1.0.2";
-       sha256 = "1kxxnk8m9154sallhy3rf8nmz0qkvchh8m761jgzhfbnnwlznpnf";
+       sha256 = "ce5efb29b77639f89f0ce6540421db13835f2d72797848a9d2a48454d1b4bdcf";
        libraryHaskellDepends = [
          base bytestring configurator directory filepath haskell-coffee mtl
          snap snap-core
@@ -121129,7 +121498,7 @@ self: {
      mkDerivation {
        pname = "snaplet-css-min";
        version = "0.1.2";
-       sha256 = "1bp6y0x03dpflbp4b1kkbxnqwsgnynbbpdgcpswwxz48xkpcp0ij";
+       sha256 = "3282cbeeec88fcceb9beecb5bb96f5f6698e6d5f738645eea2eeb6013af0e6ae";
        libraryHaskellDepends = [
          base bytestring css-text directory filepath lens snap text
          utf8-string
@@ -121148,7 +121517,7 @@ self: {
      mkDerivation {
        pname = "snaplet-environments";
        version = "0.1.1";
-       sha256 = "1kk2ry19z73cmmwh3hmg87n00hqhzpmdvnb36b7yf9ck4zkhgy3h";
+       sha256 = "70f807e7279325e7cf3263d9ddeafd104300ec41afc20179ad6c9c9f82cf62ce";
        libraryHaskellDepends = [
          base bson configurator mtl regex-tdfa snap snap-core text
          unordered-containers
@@ -121166,7 +121535,7 @@ self: {
      mkDerivation {
        pname = "snaplet-fay";
        version = "0.3.3.12";
-       sha256 = "1j9khzd1zalzkli0p139fx48dljn76f4g851k889q3zq5lriihps";
+       sha256 = "fac218332df80f9c109aa1a0479c3956d286487769840b229d9faa1fda8733c9";
        libraryHaskellDepends = [
          aeson base bytestring configurator directory fay filepath mtl snap
          snap-core transformers
@@ -121183,7 +121552,7 @@ self: {
      mkDerivation {
        pname = "snaplet-hasql";
        version = "1.0.2";
-       sha256 = "08gx096vg0swjc7z10nzlqsnjlr43cp190q4krkf08jb54ln3kcv";
+       sha256 = "9bcd6129294b22e0669e0483142e1b24536935a6df82f00f935c83b74d02fd21";
        libraryHaskellDepends = [
          aeson base bytestring clientsession configurator hasql
          hasql-backend lens mtl snap text time
@@ -121200,7 +121569,7 @@ self: {
      mkDerivation {
        pname = "snaplet-haxl";
        version = "0.0.0.2";
-       sha256 = "0xqz62qrhzr0ik60055w7jawxkps6cn5k6v1g7nx2zzhyvg1w4wl";
+       sha256 = "94131edef6f07fd1ed79619b592c33facece953cbc1400cc8c207f98b1301f77";
        libraryHaskellDepends = [
          base haxl MonadCatchIO-transformers snap transformers
        ];
@@ -121220,7 +121589,7 @@ self: {
      mkDerivation {
        pname = "snaplet-hdbc";
        version = "0.9.1";
-       sha256 = "17r7ailc2cnfny1ki7b027b5xipg2nvgr2yxvfh0sfzq8xkqa8ym";
+       sha256 = "d523856747f83b0da0dbdd8bfcb615efc65ed611609d3883b7ce32c16854279f";
        libraryHaskellDepends = [
          base bytestring clientsession containers convertible data-lens
          data-lens-template HDBC MonadCatchIO-transformers mtl
@@ -121241,7 +121610,7 @@ self: {
      mkDerivation {
        pname = "snaplet-hslogger";
        version = "1.0.0.2";
-       sha256 = "15cvpiz3p1qhb80sgz61mabvkb8h6j713jrny6mbg6qj945jbb0x";
+       sha256 = "1dac250b49129bb7aaf136cb118e3410adb997aac1fca7015a10873b7ebc9b95";
        libraryHaskellDepends = [
          base configurator hslogger mtl snap transformers
        ];
@@ -121258,7 +121627,7 @@ self: {
      mkDerivation {
        pname = "snaplet-i18n";
        version = "0.0.5";
-       sha256 = "0yl28vvk5p1qazcvb3ca3748cqzr45x9274ifcidcn13p327kck2";
+       sha256 = "62b279c4b82358d62273911c917a21f96386c8198a8db5d95738dc32f746827a";
        isLibrary = true;
        isExecutable = true;
        libraryHaskellDepends = [
@@ -121284,7 +121653,7 @@ self: {
      mkDerivation {
        pname = "snaplet-influxdb";
        version = "1.0.1.1";
-       sha256 = "1dv800rclzl0b251bixksfl7jf28z82ql7nikf5dvginfpm71j7j";
+       sha256 = "f2c870ea7536bedd8a9bd11e8a05fa483879a8d3b3c7158a58807eca320068b7";
        libraryHaskellDepends = [
          base bytestring configurator http-client influxdb lens
          monad-control mtl network snap text transformers
@@ -121302,7 +121671,7 @@ self: {
      mkDerivation {
        pname = "snaplet-lss";
        version = "0.1.0.0";
-       sha256 = "0gll9r65xahx5vai4pbi0nrvscg6z964m30s58kkzy3898j000gx";
+       sha256 = "fd0100244a68f83f272a1a8c4a4cfae631bdb305715d12d52e1daa5e4c4e943e";
        libraryHaskellDepends = [
          base directory filepath heist lss snap text xmlhtml
        ];
@@ -121320,7 +121689,7 @@ self: {
      mkDerivation {
        pname = "snaplet-mandrill";
        version = "0.1.0.3";
-       sha256 = "0yyb0qbd14v6xw5vix08pv40w9l8p2vwvmh67sa9b4q9wkvwv962";
+       sha256 = "c2a4cdf7e4099395943e06d6cdb7b888260ec8be08f4b80bef6693d01606cb7b";
        libraryHaskellDepends = [
          base configurator mandrill mtl network snap transformers
        ];
@@ -121339,7 +121708,7 @@ self: {
      mkDerivation {
        pname = "snaplet-mongoDB";
        version = "0.2";
-       sha256 = "0hpm2bhvb8gh4sz4dfx53s24gkkk2c234szhwbrn10bmd7hrapaw";
+       sha256 = "5c5d95e169758160f3e2f06b32041373ce47841ea5bb46be26f0a1b5e112f542";
        libraryHaskellDepends = [
          base bson bytestring compact-string-fix containers haskell-src-exts
          MonadCatchIO-transformers mongoDB mtl parsec regular safe snap
@@ -121357,7 +121726,7 @@ self: {
      mkDerivation {
        pname = "snaplet-mongodb-minimalistic";
        version = "0.0.6.12";
-       sha256 = "0d0hnn0qp4zd453wzh1d3adls68gpv28dnkr7dcmjfl4f5igdran";
+       sha256 = "56e5f66271843a59593b79da86c4be0f194d9b1a2dc0cf4721ed938b81b51034";
        libraryHaskellDepends = [
          base lens mongoDB mtl snap text transformers
        ];
@@ -121377,7 +121746,7 @@ self: {
      mkDerivation {
        pname = "snaplet-mysql-simple";
        version = "0.2.1.0";
-       sha256 = "0hq58xsk5089kcdv2pby7dd71nb3nqzxrpppzb9qyqfz7pf45nr1";
+       sha256 = "21db42dc3ddf618fd3faf7dedc3fb663d9705a3b7e5db11b9b09813275470543";
        libraryHaskellDepends = [
          base bytestring clientsession configurator containers errors lens
          MonadCatchIO-transformers mtl mysql mysql-simple
@@ -121400,7 +121769,7 @@ self: {
      mkDerivation {
        pname = "snaplet-oauth";
        version = "0.0.6";
-       sha256 = "177yspz91nlzz9pw9x9zh4s4q7z7w9kl8gg5fd285xbadxazp3yl";
+       sha256 = "d48ffb556f6af5824473e53d4467e2e71f4c34813ff5c46ffa9fda90fed5fe9c";
        libraryHaskellDepends = [
          aeson base bytestring bytestring-show data-lens data-lens-template
          failure hashable heist hoauth2 http-conduit http-types
@@ -121428,7 +121797,7 @@ self: {
      mkDerivation {
        pname = "snaplet-persistent";
        version = "0.5";
-       sha256 = "1zbxknmsg9q6jwbxr4nh8nkfgkjmxb7pr2wwqa7rgr0wvh8ipx5k";
+       sha256 = "b3f41b11dc1ce4978fc29c8b7ccfea55cee7a645d092dc179706a7a7ab9d7dfd";
        libraryHaskellDepends = [
          base bytestring clientsession configurator errors heist lens
          monad-logger MonadCatchIO-transformers mtl persistent
@@ -121450,7 +121819,7 @@ self: {
      mkDerivation {
        pname = "snaplet-postgresql-simple";
        version = "0.6.0.2";
-       sha256 = "0xx69x9mkv6xyd7arnip12zzyq7hdcqbypgypalgsj6vcjb8i4mp";
+       sha256 = "b792889664db48fda8bafe5dbf306bf060ffbf0837daac4ef3ddec59534fa677";
        revision = "2";
        editedCabalFile = "cfc56ee20478bf05a650bdcb457b606a640daa71b84a3a2a3bdb8930dcbbeb7b";
        libraryHaskellDepends = [
@@ -121471,7 +121840,7 @@ self: {
      mkDerivation {
        pname = "snaplet-postmark";
        version = "0.2.0";
-       sha256 = "0006i88ssgh6z9g967wlw0km8abxmxdjjs7aalsddzla6xdp8wnx";
+       sha256 = "dd72745b378afed63455ea68295baf7d295427e0941f935efa063ead118a0600";
        libraryHaskellDepends = [
          base configurator mtl postmark snap text transformers
        ];
@@ -121488,7 +121857,7 @@ self: {
      mkDerivation {
        pname = "snaplet-purescript";
        version = "0.3.0.0";
-       sha256 = "1dapzqyxj7s6j4drp0szldjxrhm77r4yvbjxs79155a58mj9p1wn";
+       sha256 = "96879b6445459512d2d15daeed493ea7c2dc65a35f839b1b91461fd93dfe57b5";
        libraryHaskellDepends = [
          base configurator mtl raw-strings-qq shelly snap snap-core text
          transformers
@@ -121505,7 +121874,7 @@ self: {
      mkDerivation {
        pname = "snaplet-recaptcha";
        version = "1.0.3";
-       sha256 = "02f5fv70r7zjzycrrqsd1jwgpa7sq1m6rci74dlcbnms7z9cpv26";
+       sha256 = "46eccbd23fbadac5682327b26c6ac0faa8fbb80c4de39c99fff29f0cce76c509";
        libraryHaskellDepends = [
          aeson base blaze-builder bytestring configurator heist http-conduit
          lens MonadCatchIO-transformers mtl snap text transformers
@@ -121522,7 +121891,7 @@ self: {
      mkDerivation {
        pname = "snaplet-redis";
        version = "0.1.4.2";
-       sha256 = "0ri5cj3gjz5c1snh7kbncb08ijs1551ixr06v3nxjsb03hrl4hhh";
+       sha256 = "104242331c6069d9edd806e41e432941cb88c06276cd03ad0eac7cf986642566";
        libraryHaskellDepends = [
          base configurator hedis lens mtl network snap text transformers
        ];
@@ -121541,7 +121910,7 @@ self: {
      mkDerivation {
        pname = "snaplet-redson";
        version = "0.1.0.0";
-       sha256 = "0pvan8fnddn27cps5x8gyrwmm88z96jjh124i9g3mi9aqpyx8z5d";
+       sha256 = "ad7cd4fdc52ac53a5e8a440428a5491fa15a79f60ff5a22f3bc2b6661db26a5f";
        libraryHaskellDepends = [
          aeson base bytestring configurator containers data-lens
          data-lens-template easy-file hedis mtl snap snap-core snaplet-redis
@@ -121562,7 +121931,7 @@ self: {
      mkDerivation {
        pname = "snaplet-rest";
        version = "0.1.0";
-       sha256 = "1w1cy5zisn0mxj6rrz7wrw31ariia006cjxqwh9ahds6iwqh40y1";
+       sha256 = "c10302318f4637a812e4b84b66005031661506cffcfc9c8dec15581d7ff12cf0";
        libraryHaskellDepends = [
          aeson base blaze-builder bytestring case-insensitive http-media
          lens mtl snap snap-accept snap-core text utf8-string xmlhtml
@@ -121582,7 +121951,7 @@ self: {
      mkDerivation {
        pname = "snaplet-riak";
        version = "0.2.0.0";
-       sha256 = "0q0mnk0cl31xidax6bahvwabm9341p5852939yzgbam72mcv8jh0";
+       sha256 = "004ab45915a7aaf5be4f238982ca0d64a4ba14df502dd3558b3d0ccac0b41560";
        libraryHaskellDepends = [
          aeson base containers data-lens data-lens-template mtl riak
          riak-protobuf snap snap-core time transformers
@@ -121601,7 +121970,7 @@ self: {
      mkDerivation {
        pname = "snaplet-sass";
        version = "0.1.2.0";
-       sha256 = "1aiznsi54lxzwxnilckspvp6rdfmksxppa3964kqxh93a9gvkr9z";
+       sha256 = "3fe5b95f5223c18e273169a87bbb9ed5b56ceebe7a321a6de7bf5352a2b63faa";
        libraryHaskellDepends = [
          base bytestring configurator directory filepath mtl process snap
          snap-core transformers
@@ -121618,7 +121987,7 @@ self: {
      mkDerivation {
        pname = "snaplet-sedna";
        version = "0.0.1.0";
-       sha256 = "1rd0ymsnanf3nk02cim8lm9gppm739jfi2x6fzmp10xs9wmlhqab";
+       sha256 = "4b61482b4fba8370eb77a68be8641aa7defb52a5a84626c0b4c3596575f5a0e5";
        libraryHaskellDepends = [
          base bytestring containers monad-control mtl resource-pool
          sednaDBXML snap
@@ -121636,7 +122005,7 @@ self: {
      mkDerivation {
        pname = "snaplet-ses-html";
        version = "0.1.1.0";
-       sha256 = "1s5pyhwdnpw1ijy67h4kw052jz4pp73bpjcqii31passybvfd7k6";
+       sha256 = "669ee6f6f25aab1b468c98c9bbc6b9977c290ae093c063bc8c815fdb38f4b7e8";
        libraryHaskellDepends = [
          adjunctions base blaze-html bytestring configurator lens ses-html
          snap text transformers
@@ -121656,7 +122025,7 @@ self: {
      mkDerivation {
        pname = "snaplet-sqlite-simple";
        version = "0.4.8.3";
-       sha256 = "0nc0kv9s3c4wc3xb6jggx9v4p141c3af07x8vda18c7qlfif5nx3";
+       sha256 = "a3dbe2a2a3f8301454dba81fe0d46081844b76eaef49b3fa609cb0a1d39e8059";
        libraryHaskellDepends = [
          aeson base bytestring clientsession configurator direct-sqlite lens
          MonadCatchIO-transformers mtl snap sqlite-simple text transformers
@@ -121681,7 +122050,7 @@ self: {
      mkDerivation {
        pname = "snaplet-stripe";
        version = "0.3.0";
-       sha256 = "0j85vzfmw6skag8rfww4gsg1lyfc7qbxiqhmwbsh4vfjiagrc9wp";
+       sha256 = "9727969f8ad26d02f5e215e2d8173ecc791a9e7e847397d153531b5edddf0549";
        libraryHaskellDepends = [
          base bytestring configurator heist lens-family-core mtl snap stripe
          text text-format transformers xmlhtml
@@ -121699,7 +122068,7 @@ self: {
      mkDerivation {
        pname = "snaplet-tasks";
        version = "0.1.2";
-       sha256 = "0wkhjjjmd08jbhp41j6xvcvg3g7c74cz18mm89k8alwfc50krvc0";
+       sha256 = "80ed3c41618e53856642b5a2f01939ecbcf136dbddc8402e5c128156a5947072";
        libraryHaskellDepends = [
          base bytestring containers curl data-hash haskell98 MissingH mtl
          network snap snap-core
@@ -121718,7 +122087,7 @@ self: {
      mkDerivation {
        pname = "snaplet-typed-sessions";
        version = "0.5";
-       sha256 = "0gc6vnxsbwgciv281p6jff8ylcni4qpkmak2zqz710in86grjbgw";
+       sha256 = "fc2d999f413682703efe62aa3a2f26d132ea9173d2dc80c48eecf1a5bbdd863d";
        libraryHaskellDepends = [
          base bytestring cereal clientsession containers hashtables mtl
          PSQueue random regex-posix snap snap-core time
@@ -121739,7 +122108,7 @@ self: {
      mkDerivation {
        pname = "snaplet-wordpress";
        version = "0.1.1.2";
-       sha256 = "1vmkywrd0vfyd028d0pvfglywgbv1m26j1shwy9wmnr581vx9pab";
+       sha256 = "4bddd4774025dbca93e7500769440d7b3deee973fb82860468de6dd032f7b3ee";
        libraryHaskellDepends = [
          aeson async attoparsec base blaze-builder bytestring configurator
          containers data-default either hedis heist hspec hspec-snap lens
@@ -121764,7 +122133,7 @@ self: {
      mkDerivation {
        pname = "snappy";
        version = "0.2.0.2";
-       sha256 = "14fdx0fikkd9krpzqrvas6mjqmmhmh0qwqzvz1kymil7d8rdyr85";
+       sha256 = "0565df326a87c6ea67f8fb638e01acb0562cabd16a67fc6f9ea9cd191de8cd91";
        libraryHaskellDepends = [ base bytestring ];
        librarySystemDepends = [ snappy ];
        testHaskellDepends = [
@@ -121781,7 +122150,7 @@ self: {
      mkDerivation {
        pname = "snappy-conduit";
        version = "0.1.0.0";
-       sha256 = "0k93v3dyv7818xy45l7i5wykfmnwyqkykxjh6xr937zh8a4qapfi";
+       sha256 = "d15d858942f09f91723750f6e927f6dc56373d2ff1d0427c47019deddbd8234d";
        libraryHaskellDepends = [ base bytestring conduit snappy ];
        jailbreak = true;
        homepage = "http://github.com/tatac1/snappy-conduit/";
@@ -121794,7 +122163,7 @@ self: {
      mkDerivation {
        pname = "snappy-framing";
        version = "0.1.0";
-       sha256 = "1m7zk4ns8igh2717d77k4zvf06byp35dly3ykawaz9hxwsxn1jb2";
+       sha256 = "62c960bbe61da6afb89a7e78dacab87e19e0f627f39c76c211f045a42d99ffd4";
        libraryHaskellDepends = [ array base binary bytestring snappy ];
        homepage = "https://github.com/kim/snappy-framing";
        description = "Snappy Framing Format in Haskell";
@@ -121806,7 +122175,7 @@ self: {
      mkDerivation {
        pname = "snappy-iteratee";
        version = "0.1";
-       sha256 = "17jwsvw7ik2bjanmzw4h72mdjaz031b5a6hi7cjz4ba1yjkiqnmk";
+       sha256 = "b35a1ca7f4412df2253b111a555618e02bd9aa3890f05fad924bcc78f8d65c9e";
        libraryHaskellDepends = [ base bytestring iteratee snappy ];
        jailbreak = true;
        homepage = "http://github.com/iand675/snappy-iteratee";
@@ -121823,7 +122192,7 @@ self: {
      mkDerivation {
        pname = "sndfile-enumerators";
        version = "0.10.0.0";
-       sha256 = "1nnlbhnm88xy462sh3d54b751ndl0r2qggbxn2irrwqdnhc21v4r";
+       sha256 = "99ec2018b40df39ca3b07dbd874506b4d950ce22a50da88521be23542d5cd4da";
        libraryHaskellDepends = [
          base binary bytestring containers filepath iteratee
          listlike-instances MonadCatchIO-transformers transformers vector
@@ -121836,12 +122205,29 @@ self: {
        hydraPlatforms = stdenv.lib.platforms.none;
      }) {};
 
+  "sneakyterm" = callPackage
+    ({ mkDerivation, base, classy-prelude, containers, lens, linear
+     , mtl, ncurses, transformers
+     }:
+     mkDerivation {
+       pname = "sneakyterm";
+       version = "0.1";
+       sha256 = "6dec2306f63d72f7e7931ba16827ff467de4b36d98089ecef8ba5df5346f5687";
+       libraryHaskellDepends = [
+         base classy-prelude containers lens linear mtl ncurses transformers
+       ];
+       jailbreak = true;
+       homepage = "https://github.com/pmiddend/sneakyterm";
+       description = "Tiny, declarative wrapper around ncurses";
+       license = stdenv.lib.licenses.gpl3;
+     }) {};
+
   "sneathlane-haste" = callPackage
     ({ mkDerivation, base, haste-compiler }:
      mkDerivation {
        pname = "sneathlane-haste";
        version = "1";
-       sha256 = "0m6281a1hvwbhv02vpdd01vm0jvccvq1kvy26dfncv0a8158y6wj";
+       sha256 = "921b8f4a400a6c665d33c2ef19f0666c4b507700addd2dc0868b6f185440c254";
        libraryHaskellDepends = [ base haste-compiler ];
        jailbreak = true;
        homepage = "http://sneathlane.com";
@@ -121855,7 +122241,7 @@ self: {
      mkDerivation {
        pname = "snippet-extractor";
        version = "0.2.0";
-       sha256 = "0iyya6p5i5jrhvah45bcvqgldfx49qv8393vwi5k413vxjr7c3zm";
+       sha256 = "f50f76b2ec7b04324be47ba481364ea4bb461fde6c1502d586599658ae51de47";
        isLibrary = false;
        isExecutable = true;
        executableHaskellDepends = [ base parsec ];
@@ -121870,7 +122256,7 @@ self: {
      mkDerivation {
        pname = "snm";
        version = "0.0.4";
-       sha256 = "1n2cj35qrp6a766w29qrqcpcrv81xcpk9agkbibxngxh03abyhji";
+       sha256 = "5142bfd400b03fdb575cf3a9342feb01edcc2ec31927c18d39cadc8ccb904cd8";
        isLibrary = true;
        isExecutable = true;
        libraryHaskellDepends = [
@@ -121895,7 +122281,7 @@ self: {
      mkDerivation {
        pname = "snmp";
        version = "0.2.0.0";
-       sha256 = "0vjbpjsa4ivsjzvfc9sr457pms2rw1zpb92d971n0yccl0bxmf67";
+       sha256 = "c7b8da17a08c7960c3494da4757fe059e87a4f215927e6f6977a47a2b4bc4b6e";
        libraryHaskellDepends = [
          asn1-encoding asn1-parse asn1-types async base binary bytestring
          cipher-aes cipher-des containers crypto-cipher-types cryptohash mtl
@@ -121910,7 +122296,7 @@ self: {
      mkDerivation {
        pname = "snow-white";
        version = "2009.12.1";
-       sha256 = "007hzr8dpj0mhvmnpdg0gi296q3mlicnx36s6hmgifzmyaa8kssi";
+       sha256 = "51eb8994f2f5bbf82a34da8c6e59a4756093447ce0b56beb8615c8db50fef000";
        libraryHaskellDepends = [ base binary bytestring mps ];
        homepage = "http://github.com/nfjinjing/snow-white";
        description = "encode any binary instance to white space";
@@ -121926,7 +122312,7 @@ self: {
      mkDerivation {
        pname = "snowball";
        version = "1.0.0.1";
-       sha256 = "0fvxzm14ffjqq6n51bi5cmq5yrlggpkbb9rbbw522l6cjgv0apbx";
+       sha256 = "7d5d05f693cc50210a5f2ba7b5e67d8f665f706525ae50acc1583a4742fd7d3b";
        libraryHaskellDepends = [ base bytestring text text-icu ];
        testHaskellDepends = [
          base HUnit QuickCheck quickcheck-instances test-framework-hunit
@@ -121942,7 +122328,7 @@ self: {
      mkDerivation {
        pname = "snowflake";
        version = "0.1.1.1";
-       sha256 = "1pfd8lqwv0504hli6fhwiqckcca0x9pnfzmy3kz36w7138rclmpi";
+       sha256 = "f156ca321ae17033fe1cbe7e676fea403136198e1c3a132924a080cd3145cddd";
        libraryHaskellDepends = [ base time ];
        description = "A loose port of Twitter Snowflake to Haskell. Generates arbitrary precision, unique, time-sortable identifiers.";
        license = stdenv.lib.licenses.asl20;
@@ -121955,7 +122341,7 @@ self: {
      mkDerivation {
        pname = "snowglobe";
        version = "3.0.0.2";
-       sha256 = "0l6hy0mza344k7m9skb6v9al611zgrrknhjdzx4ipqdd9zky9p23";
+       sha256 = "43dce4e74fade11b49ff4d423b737e3f044355da664d9dea99840cf52bf0d050";
        isLibrary = false;
        isExecutable = true;
        executableHaskellDepends = [
@@ -121976,7 +122362,7 @@ self: {
      mkDerivation {
        pname = "soap";
        version = "0.2.2.7";
-       sha256 = "02yirl0pr680pbwbh9z0awyk4blgdd0rir8x1gyydyn6v5dg736i";
+       sha256 = "d18cf35ad9c6fae6fd0b1de598416b8f2e323d57e027b8f8ba00997c01cdd10b";
        libraryHaskellDepends = [
          base bytestring conduit configurator data-default exceptions
          http-client http-types iconv mtl resourcet text
@@ -121998,7 +122384,7 @@ self: {
      mkDerivation {
        pname = "soap-openssl";
        version = "0.1.0.2";
-       sha256 = "03w389yhybzvc06gpxigibqga9mr7m41rkg1ki3n686j9xzm8210";
+       sha256 = "2008547f4fd22063479ce1cd1c483db926f5f08a2ff6fb0c60fb2f0f7d42830f";
        libraryHaskellDepends = [
          base configurator data-default HsOpenSSL http-client
          http-client-openssl soap text
@@ -122016,7 +122402,7 @@ self: {
      mkDerivation {
        pname = "soap-tls";
        version = "0.1.1.2";
-       sha256 = "0xnzwzmhh2i5nci7xbnkr28hxm376fbmgjcwz7svk46k1vxvlfp4";
+       sha256 = "e43abafb0ed390b9f5f99cc957973367d40e91c8d3ae7e22b3250a08ebe7df76";
        libraryHaskellDepends = [
          base configurator connection data-default http-client
          http-client-tls soap text tls x509 x509-store x509-validation
@@ -122033,7 +122419,7 @@ self: {
      mkDerivation {
        pname = "sock2stream";
        version = "0.3";
-       sha256 = "1vnrjza4x4jqlvz7mmihrjbdf4ngw02fkkn1j768w81m814vny7h";
+       sha256 = "f078bb494035208ecc91c1cee904e0cf12d796cc30d67afea658924ed497d9ee";
        isLibrary = false;
        isExecutable = true;
        executableHaskellDepends = [
@@ -122050,7 +122436,7 @@ self: {
      mkDerivation {
        pname = "sockaddr";
        version = "0.0.0";
-       sha256 = "1h74k5pipv9314y1d2wgpwgvyxfp6pcnq5051fdqr1shqlkpwbs2";
+       sha256 = "422f7e27c550878c9b0b05146cd935d775bf1fbf8f8b163c0923ed1b6f99e4c0";
        libraryHaskellDepends = [ base byteorder bytestring network ];
        description = "Printing SockAddr";
        license = stdenv.lib.licenses.bsd3;
@@ -122060,8 +122446,8 @@ self: {
     ({ mkDerivation, async, base, bytestring }:
      mkDerivation {
        pname = "socket";
-       version = "0.5.2.0";
-       sha256 = "0mika886mqzjzm14sby3qdlwdlnd20xwl2d2n1faalgimjl1149y";
+       version = "0.5.3.0";
+       sha256 = "f9d6ff67fa2a725c4184d38ecd635c955fd90ef83bcac02f16dbbb1179f26066";
        libraryHaskellDepends = [ base bytestring ];
        testHaskellDepends = [ async base bytestring ];
        homepage = "https://github.com/lpeterse/haskell-socket";
@@ -122074,7 +122460,7 @@ self: {
      mkDerivation {
        pname = "socket-activation";
        version = "0.1.0.1";
-       sha256 = "109zxc16zlp98ggc99ap7wbzaa40yg34v3abn2nfs0w49dvh1zma";
+       sha256 = "aafe00774b8403edacb04b8d4dc6f38028f5173f57a5c4de43e9d26f02eb3f81";
        libraryHaskellDepends = [ base network transformers unix ];
        homepage = "https://github.com/sakana/haskell-socket-activation";
        description = "systemd socket activation library";
@@ -122088,7 +122474,7 @@ self: {
      mkDerivation {
        pname = "socket-io";
        version = "1.3.3";
-       sha256 = "1gy8g8bxjjj1hifkhvid6v8amml0gpp6gbfpih3v0grbi5aci0w7";
+       sha256 = "8783c854892b3fb0078cd7ad67ee7d80d6aad0362d6e385d84414ad9177ac8bf";
        libraryHaskellDepends = [
          aeson attoparsec base bytestring engine-io mtl stm text
          transformers unordered-containers vector
@@ -122102,7 +122488,7 @@ self: {
      mkDerivation {
        pname = "socket-sctp";
        version = "0.1.0.0";
-       sha256 = "1xdrc3d31xzi0q8arh8liv1h9xqinscaa5ip2xs6dvf4gap7rvs8";
+       sha256 = "48ef7cae7ac4ed6674173716a598b611f704c38e14c1ac1006f1f730da60b9f5";
        libraryHaskellDepends = [ base bytestring socket ];
        librarySystemDepends = [ sctp ];
        testHaskellDepends = [ base bytestring socket ];
@@ -122123,7 +122509,7 @@ self: {
      mkDerivation {
        pname = "socketio";
        version = "0.1.3";
-       sha256 = "19rwkix7fjj3znd7z5bzknnpcfkmkmpcmrksv3q51b9fwph8gwrq";
+       sha256 = "38f387e0e52ead50f0d87ae6ca6e9d753a76ad9d7f957f9afd434a777a9c3ca7";
        libraryHaskellDepends = [
          aeson ansi-terminal attoparsec base blaze-builder bytestring
          conduit conduit-extra http-types lifted-base monad-control mtl
@@ -122147,7 +122533,7 @@ self: {
      mkDerivation {
        pname = "socks";
        version = "0.5.4";
-       sha256 = "1nmldlwxqasmg359i2aa3a903gi3lmnlspvf12xk49jrg3mf3dg9";
+       sha256 = "e9b5e1ea78592632bb086e5f4d6da523be01921a4a8998ca78552bdc396db4da";
        libraryHaskellDepends = [ base bytestring cereal network ];
        homepage = "http://github.com/vincenthz/hs-socks";
        description = "Socks proxy (version 5) implementation";
@@ -122159,7 +122545,7 @@ self: {
      mkDerivation {
        pname = "sodium";
        version = "0.11.0.3";
-       sha256 = "00qs1calial08a185ma5hm17lmmzig0yjf3710d5ikq1bmrgcqga";
+       sha256 = "ea61f6725d01cf581a086738e9c18bbf567a428545d582824280aa48150b1a03";
        libraryHaskellDepends = [ base containers mtl ];
        description = "Sodium Reactive Programming (FRP) System";
        license = stdenv.lib.licenses.bsd3;
@@ -122170,7 +122556,7 @@ self: {
      mkDerivation {
        pname = "soegtk";
        version = "0.12.1";
-       sha256 = "01f49hwxc5h85iwzgnddxlh1lmb3s27zddmghxrlq958gcrr2iar";
+       sha256 = "594591337ba8244c7387afb6f68fd063551a20edadd9f7792c0816d6394cc405";
        libraryHaskellDepends = [ base cairo gtk old-time stm ];
        jailbreak = true;
        homepage = "http://projects.haskell.org/gtk2hs/";
@@ -122185,7 +122571,7 @@ self: {
      mkDerivation {
        pname = "sonic-visualiser";
        version = "0.1.1";
-       sha256 = "0gihsk7szq27ihhy9idiaslv164by23c9c70fhzwyqx3wk7z1aip";
+       sha256 = "37aaf0cfe4a363cf3f74e0b0c486f08b98b0a956b1c5e4218c47e0afcfd4303e";
        isLibrary = true;
        isExecutable = true;
        libraryHaskellDepends = [
@@ -122207,7 +122593,7 @@ self: {
      mkDerivation {
        pname = "sophia";
        version = "0.1.2";
-       sha256 = "18svfy0ald8cz03vfv3m43w777rxksmaz0713a1vzcmyfb6h5iwg";
+       sha256 = "8fc702cd72beb2bf831ae180afaa9e3d9f73f820756cb707f80c35aa80775ba3";
        libraryHaskellDepends = [ base bindings-sophia bytestring ];
        testHaskellDepends = [
          base bindings-sophia bytestring directory tasty tasty-hunit
@@ -122224,7 +122610,7 @@ self: {
      mkDerivation {
        pname = "sort-by-pinyin";
        version = "2014.5.19";
-       sha256 = "1ksfx5zhagg2y8virg8am1w8ljrzc9ddmf7xgvi5gx88zibi32fd";
+       sha256 = "cd891157fc08f557e27efdb8da5a623f4b8a78a80abd1c37f2e23d057fe94ecf";
        libraryHaskellDepends = [
          air air-extra air-th base bytestring containers text
        ];
@@ -122238,7 +122624,7 @@ self: {
      mkDerivation {
        pname = "sorted";
        version = "0.0.1";
-       sha256 = "0rzcxhzc4s4sbdnysmjh1i8pd39jyx7a4hbhkarsp2qbx29s4h03";
+       sha256 = "0340a293e80b8babb39a7041a24ef7328d76510c5056ed6d5b9a68c23eecec67";
        libraryHaskellDepends = [ base ];
        jailbreak = true;
        description = "Efficient, type-safe sorted sequences";
@@ -122251,7 +122637,7 @@ self: {
      mkDerivation {
        pname = "sorted-list";
        version = "0.1.4.2";
-       sha256 = "1prfxpfvsx03lvk5q33azpcif2a3j80v4naw2kn48r1kb84r60m1";
+       sha256 = "a10293095a336444ec145c59b20192430917d9fd6a0c5ce6a60374bddded2edf";
        libraryHaskellDepends = [ base deepseq ];
        homepage = "https://github.com/Daniel-Diaz/sorted-list/blob/master/README.md";
        description = "Type-enforced sorted lists and related functions";
@@ -122263,7 +122649,7 @@ self: {
      mkDerivation {
        pname = "sorting";
        version = "1.0.0.1";
-       sha256 = "1i2vbmq7p7rja9rnhalyrspc2p5nc8yg6mfj9ia89j55vkc6225n";
+       sha256 = "b60861d8dca5c884544cd255f33c62b65cc1aece9e2a687352329f7b705d5bc4";
        libraryHaskellDepends = [ base ];
        homepage = "https://github.com/joneshf/sorting";
        description = "Utils for sorting";
@@ -122275,7 +122661,7 @@ self: {
      mkDerivation {
        pname = "sorty";
        version = "0.1.1";
-       sha256 = "04bripdlc90rlkv5q6p44j10n7c1zdwv0ibiq5p365xijgribfaq";
+       sha256 = "58b915f393b117336ec17145b079fb811d0b8224e41a5cf6a4192446db8d7911";
        isLibrary = false;
        isExecutable = true;
        executableHaskellDepends = [ base bytestring ];
@@ -122293,7 +122679,7 @@ self: {
      mkDerivation {
        pname = "sound-collage";
        version = "0.1";
-       sha256 = "11zwhq5r21phgadfvxxmvz7gcz3vhyrqw2rmwnkxz0n65p5az15m";
+       sha256 = "b584afca2dc682dfa7e5350b8eb3877b7cf6cedfb5f7ed9a7af006910b86fc87";
        isLibrary = false;
        isExecutable = true;
        executableHaskellDepends = [
@@ -122313,7 +122699,7 @@ self: {
      mkDerivation {
        pname = "sounddelay";
        version = "0.1.0.2";
-       sha256 = "1mqa70zbhpw860hclns4y8pri6d9swahzbhac7jhzrwq4vyia9xj";
+       sha256 = "b22715fd2698e70fe5610aae0f15d7a999982ff2445bca2030885fb83e380ad7";
        isLibrary = false;
        isExecutable = true;
        executableHaskellDepends = [ base containers parseargs WAVE ];
@@ -122331,7 +122717,7 @@ self: {
      mkDerivation {
        pname = "source-code-server";
        version = "2010.9.1";
-       sha256 = "1934awipc837mdhkfa3ghmljxk0vb16wd4f31qdl4q9nxgwfv6c8";
+       sha256 = "8899edf8eb3661421b0ec391c64d581bcc2e69856f283761ab672076235764a4";
        isLibrary = false;
        isExecutable = true;
        executableHaskellDepends = [
@@ -122353,7 +122739,7 @@ self: {
      mkDerivation {
        pname = "sourcemap";
        version = "0.1.3.0";
-       sha256 = "1flfsjs2z2zjzqwvmc2vcibvxh19s89ah4s560xr2s5mhdqwbkk5";
+       sha256 = "65cec57183b568913b304513a812d229c0be57645bb0ba39fef28b2fb4d48eba";
        revision = "1";
        editedCabalFile = "aa8b674ddb6f30642da0a391ad3481b44241f9f1cb2ee661503e59dac3ca2053";
        libraryHaskellDepends = [
@@ -122372,7 +122758,7 @@ self: {
      mkDerivation {
        pname = "sousit";
        version = "0.4";
-       sha256 = "0vfgl4l3zwfsb2p5fds47bikyvfcsypmbjd1yvkjvi36x2g3pzwr";
+       sha256 = "99ff3b9ee866c42de7f6a1c955afd7cc6d3fe33a443757ae58daf13f28a1cf6d";
        libraryHaskellDepends = [
          base bytestring cereal mtl resourcet stm transformers
        ];
@@ -122393,7 +122779,7 @@ self: {
      mkDerivation {
        pname = "sox";
        version = "0.2.2.5";
-       sha256 = "19jczxackqhbi85i0i3jl26ng34a9hkfw73jlfscfl8xjqc0j99n";
+       sha256 = "36250918961d51c7b4a3721cee264c8a8c678da07244100b8a0be2c954ff4ca6";
        libraryHaskellDepends = [
          base containers explicit-exception extensible-exceptions process
          sample-frame transformers unix utility-ht
@@ -122411,7 +122797,7 @@ self: {
      mkDerivation {
        pname = "soxlib";
        version = "0.0.2";
-       sha256 = "1d82sqihmx3ymgyahbnjlzmam4pj4rwyp956p74fpl0gsmqphmr8";
+       sha256 = "28577871d50fd0ebc8b9a6a4eb7926f292aaeaa7d22ea8fcab7ef40a23d602b5";
        isLibrary = true;
        isExecutable = true;
        libraryHaskellDepends = [
@@ -122432,7 +122818,7 @@ self: {
      mkDerivation {
        pname = "soyuz";
        version = "0.0.0";
-       sha256 = "1w8adkrics3jp8lc1gwjiwn4i94yfzxba13wf65qywhmdr9lcy3p";
+       sha256 = "777846536e15728f8b717c04b5fa779ea4482c8f92bfc028ba726816f36c0af1";
        isLibrary = true;
        isExecutable = true;
        libraryHaskellDepends = [
@@ -122450,7 +122836,7 @@ self: {
      mkDerivation {
        pname = "spacefill";
        version = "0.1";
-       sha256 = "0md1ygps2y2ri49g012xj5vv9iglixw06sicl685k60h4sskiqsk";
+       sha256 = "53e338b52610985990a12c6a03788ff4c5b477915d04f012895978a1eff3a155";
        libraryHaskellDepends = [ base ];
        testHaskellDepends = [ base ];
        homepage = "https://github.com/knz/spacefill";
@@ -122463,7 +122849,7 @@ self: {
      mkDerivation {
        pname = "spacepart";
        version = "0.1.0.0";
-       sha256 = "118wch92ix54jp1hi4qw9mk46571lnak4df8ji83bs2vz3vax6jp";
+       sha256 = "579aaef6f85be8355094c8353295a5e11443664d1c9308c395a4f42812641c85";
        libraryHaskellDepends = [ base vector-space ];
        jailbreak = true;
        homepage = "http://code.haskell.org/data-spacepart";
@@ -122478,7 +122864,7 @@ self: {
      mkDerivation {
        pname = "spaceprobe";
        version = "0.3.0";
-       sha256 = "09vpnq5mfdzr132cqm5i4xkxmpg2035pbs64a56lgq0asdzlhfmy";
+       sha256 = "be3a487fd30ae0474d51c4e875cb00e2ddda6727b154ccc408f937570bb67727";
        libraryHaskellDepends = [ base clock containers erf mtl ];
        testHaskellDepends = [
          base clock containers erf mtl QuickCheck test-framework
@@ -122496,7 +122882,7 @@ self: {
      mkDerivation {
        pname = "spanout";
        version = "0.1";
-       sha256 = "0qi1pm46fyrn4vv1b5kcwhd8im59nz5qil6z33r8wq16vv151qb4";
+       sha256 = "64e150c2de26608ef218dfd088cbb7a9d4881ae46c9615f626367b6748bd2162";
        isLibrary = false;
        isExecutable = true;
        executableHaskellDepends = [
@@ -122519,7 +122905,7 @@ self: {
      mkDerivation {
        pname = "sparse";
        version = "0.9.2";
-       sha256 = "0ckjmpnav3rd40ylksrwc0awy4pigv6ngm15z1k6sicw73iyl3pd";
+       sha256 = "ed0eeae3389c456d66f825d467cd7ef112cf15603ceb493d202d8fadecad7232";
        libraryHaskellDepends = [
          base contravariant deepseq hybrid-vectors lens primitive
          transformers vector vector-algorithms
@@ -122544,7 +122930,7 @@ self: {
      mkDerivation {
        pname = "sparse-lin-alg";
        version = "0.4.3";
-       sha256 = "1255q13mb6196i3hv1i41agifg1x1840z535mx48jjkln297gmc9";
+       sha256 = "89d57792b0744a8948af65940f080a3d3c179f0a24860d473429985547c0a588";
        libraryHaskellDepends = [ base containers ];
        testHaskellDepends = [
          base containers QuickCheck test-framework
@@ -122560,7 +122946,7 @@ self: {
      mkDerivation {
        pname = "sparsebit";
        version = "0.5";
-       sha256 = "1a4gsnmr1y8b05iws2vrmjqbs5y9svfsz0jb3k19dddn1aszzm07";
+       sha256 = "07d4ffb50ab6b596c21c4b82afddd6c917bdb0ac790bcd63010bf990abd58fa8";
        libraryHaskellDepends = [ base haskell98 ];
        homepage = "http://kyagrd.dyndns.org/wiki/SparseBitmapsForPatternMatchCoverage";
        description = "Sparse bitmaps for pattern match coverage";
@@ -122573,7 +122959,7 @@ self: {
      mkDerivation {
        pname = "sparsecheck";
        version = "0.1.0.3";
-       sha256 = "19h9vy7arhi35rqafbq3nf9a50vnlw5mbfwvl6sp1j61w0yxai95";
+       sha256 = "2545d53de0c1c870b5a19bbb550ba77683a292b3032fa7702e23c2ac8edf09a6";
        libraryHaskellDepends = [ base containers ];
        homepage = "http://www.cs.york.ac.uk/~mfn/sparsecheck/";
        description = "A Logic Programming Library for Test-Data Generation";
@@ -122588,7 +122974,7 @@ self: {
      mkDerivation {
        pname = "sparser";
        version = "0.6.1";
-       sha256 = "1mhnjlsqmvvwnh35dzrms9vsdvr563aq49qhwg35pvscsia2fpr2";
+       sha256 = "225f2754d44cef5bc6e3102782d53025efa677d235ff5606b47cef8a359516d6";
        libraryHaskellDepends = [
          base containers data-default monadplus nats pointed semigroups
        ];
@@ -122601,7 +122987,7 @@ self: {
      mkDerivation {
        pname = "spata";
        version = "2010.10.10";
-       sha256 = "1cr0d82l2b96jvszca4yavdgwq450yzigcyrrlddrf9m9908kkzy";
+       sha256 = "fecf89404a35b9dc1acdd9b317bf078560feda569e28f6f596262d41056a20b3";
        libraryHaskellDepends = [ base dlist mps mtl ];
        homepage = "http://github.com/nfjinjing/spata";
        description = "brainless form validation";
@@ -122616,7 +123002,7 @@ self: {
      mkDerivation {
        pname = "spatial-math";
        version = "0.2.4.0";
-       sha256 = "0aysc8r9ry7ii76d6522ja4pjwrfl3m212mbrimbdrh20ykirjvv";
+       sha256 = "7bcb1ca70702e6b66accab8a20eaa02e737989924214d3cc89f1f89c3262da2b";
        libraryHaskellDepends = [
          base binary cereal ghc-prim lens linear
        ];
@@ -122630,7 +123016,7 @@ self: {
      mkDerivation {
        pname = "spawn";
        version = "0.3";
-       sha256 = "0xkkl0w30rqif2jwdzjv239raly4yaf0116vkqcwh1i41jqn7ij8";
+       sha256 = "48c663b10c2406c8199edb84009cf2c45395d3105bfec6a57011673038a07376";
        libraryHaskellDepends = [ base ];
        description = "Tiny library for concurrent computations";
        license = stdenv.lib.licenses.bsd3;
@@ -122641,7 +123027,7 @@ self: {
      mkDerivation {
        pname = "spdx";
        version = "0.2.0.0";
-       sha256 = "0hxzkmyi90cbr7w8mjlp2azbkyp8gvjpv28c57lpvxw2xvyavgjq";
+       sha256 = "58beadfcee82f77de9290c897de57ee8fab9be1297ca8af8c98b81147d9dbf43";
        libraryHaskellDepends = [ base transformers ];
        testHaskellDepends = [ base tasty tasty-quickcheck ];
        homepage = "https://github.com/phadej/spdx";
@@ -122654,7 +123040,7 @@ self: {
      mkDerivation {
        pname = "spe";
        version = "0.6.3";
-       sha256 = "02cq8f9yz5z3rwkcj4nj8dgzwnn2w3b1jpndmmcqwsjymmivy8fr";
+       sha256 = "d921bf63ad5e6a8e59adcd5e19d6e0c25afe5f43d212c926cfe397ef93439809";
        libraryHaskellDepends = [ base ];
        testHaskellDepends = [ base ];
        homepage = "http://github.com/akc/spe";
@@ -122667,7 +123053,7 @@ self: {
      mkDerivation {
        pname = "special-functors";
        version = "1.0.0.1";
-       sha256 = "0c68af104qxn9lhzshcy9s466q10n3ic7q4navqi53mmmmznivrd";
+       sha256 = "2def687fadb58e12f15696e0c3e2b0206063884e9e41fd214db663028253c830";
        libraryHaskellDepends = [ base mtl ];
        jailbreak = true;
        description = "Control.Applicative, Data.Foldable, Data.Traversable (compatibility package)";
@@ -122683,7 +123069,7 @@ self: {
      mkDerivation {
        pname = "special-keys";
        version = "0.1.0.3";
-       sha256 = "0r66rzyh9m9wsy8mhyq09ar0zbalfyr627z9xrxny8242nbsygpy";
+       sha256 = "fe3eaf971544206f7beee91f61b27754ad0fb24a007b5891d73cd504fdcfc664";
        libraryHaskellDepends = [
          aeson base blaze-markup bytestring cereal deepseq hashable
          mwc-random path-pieces primitive safecopy text uuid
@@ -122702,7 +123088,7 @@ self: {
      mkDerivation {
        pname = "specialize-th";
        version = "0.0.0.8";
-       sha256 = "1b9bs08zja8id739zf0q47y91aq10gjr1ikbf7rvzav9i3w6djnc";
+       sha256 = "ccca66f88869abbff3716bc690e50301ab90fc2118b89fc6691129f911d02bad";
        libraryHaskellDepends = [
          base composition derive MissingH mtl newtype newtype-th
          template-haskell th-expand-syns tuple type-sub-th uniplate
@@ -122727,7 +123113,7 @@ self: {
      mkDerivation {
        pname = "species";
        version = "0.3.4.2";
-       sha256 = "07xixq45wbfqmdiykra2fpsfjv1n5s1zn0jvqrhja5d2i92865ly";
+       sha256 = "9e1683448aa2152561c65b02fb832e366ce9f47542e5e963abd82d5e08eeb11f";
        libraryHaskellDepends = [
          base containers multiset-comb np-extras numeric-prelude
          template-haskell
@@ -122741,7 +123127,7 @@ self: {
      mkDerivation {
        pname = "speculation";
        version = "1.5.0.2";
-       sha256 = "11d4v3x9phayx29lxl4na0b940ax27rjd867f7l9jb284p1rvhp5";
+       sha256 = "e5c29dc325482c99e871c7a026f3115d0192165096d04e93e85ec19bfad8a485";
        libraryHaskellDepends = [ base ghc-prim stm transformers ];
        homepage = "http://github.com/ekmett/speculation";
        description = "A framework for safe, programmable, speculative parallelism";
@@ -122753,7 +123139,7 @@ self: {
      mkDerivation {
        pname = "speculation-transformers";
        version = "0.1.2";
-       sha256 = "0050iy5q9m1ylkhbbnpff7yl99917pa46pgvj76isij4lvdl4f5a";
+       sha256 = "aa3842dba644461dcd91fb5d43d43d21a544fd71eedab5e0a43ed4848b8fa000";
        libraryHaskellDepends = [ speculation ];
        homepage = "http://github.com/ekmett/speculation/";
        description = "Merged into 'speculation'. Use that instead.";
@@ -122768,7 +123154,7 @@ self: {
      mkDerivation {
        pname = "spelling-suggest";
        version = "0.5.2.1";
-       sha256 = "0n0b2lbvj3pjg841pdw7pb09cpkz2d186dd4pmabjnm6r6wabm2n";
+       sha256 = "56d4a5b8c9a65ab954bda4358342137f5e96c0ba87b71b087af20eb917150b58";
        isLibrary = true;
        isExecutable = true;
        libraryHaskellDepends = [
@@ -122789,7 +123175,7 @@ self: {
      mkDerivation {
        pname = "sphero";
        version = "0.1.0.0";
-       sha256 = "1b5i6zpp3xz8jcvs44g97iyam5vcig3fpy0hcsldg51cm762sv48";
+       sha256 = "886c2dcca92c94d7a86610f8ebc68b6c97aa7c3ce911a23793e8f771ef37b1ac";
        libraryHaskellDepends = [
          base bytestring cereal containers mtl simple-bluetooth
        ];
@@ -122806,7 +123192,7 @@ self: {
      mkDerivation {
        pname = "sphinx";
        version = "0.6.0.1";
-       sha256 = "1pcm4y9k5lc00805ddv519cx4j3qld2v1dnbckg38n9dyp96wj98";
+       sha256 = "28496ed2f52d5934de64cbb6b045a37848d2590a65b756000280d132932795dd";
        libraryHaskellDepends = [
          base binary bytestring data-binary-ieee754 network text text-icu
          xml
@@ -122821,7 +123207,7 @@ self: {
      mkDerivation {
        pname = "sphinx-cli";
        version = "0.1";
-       sha256 = "08fqfmd6462skjywv2j4ilnmpbzr28d6vwmb187w3sv0byvvjzw3";
+       sha256 = "837fb9b75f60ebc10f0aabf26d1a12f9af5b2d8d448acdbd9c5a18625a75d821";
        isLibrary = false;
        isExecutable = true;
        executableHaskellDepends = [ base sphinx ];
@@ -122837,7 +123223,7 @@ self: {
      mkDerivation {
        pname = "spice";
        version = "0.5.0.0";
-       sha256 = "1xs09ipg9l38nq3kxpdyv6643ywivhw87w6il0q9bzhng4rpfj6g";
+       sha256 = "cf4877337916fe9530a0d1f08338dc91fb418cd9bedd3e07b668d0f46e4c40f7";
        libraryHaskellDepends = [
          base bytestring containers data-default elerea GLFW JuicyPixels
          JuicyPixels-repa OpenGL
@@ -122857,7 +123243,7 @@ self: {
      mkDerivation {
        pname = "spike";
        version = "0.3";
-       sha256 = "11xr80fmbd6ps79fyzb40ha1gw4crxr8gff2nk39spj0sj64jqdn";
+       sha256 = "b661498cd4405e9dc6b4c2b98772cf8cf0171404647defd2d1d7b4551d40b987";
        isLibrary = false;
        isExecutable = true;
        executableHaskellDepends = [
@@ -122877,7 +123263,7 @@ self: {
      mkDerivation {
        pname = "spine";
        version = "0.1";
-       sha256 = "1sk2vkslcbmr4z87xc7q38ywbj118bcgqrkz9fqsp7jffxvy4bgv";
+       sha256 = "fb2de277774e9eabb14b7f66fcd84221c8c53d1af8b07ed027b92e46f5dc62ea";
        libraryHaskellDepends = [ base ];
        homepage = "https://github.com/spl/spine";
        description = "Simple implementation of the generic spine view";
@@ -122889,7 +123275,7 @@ self: {
      mkDerivation {
        pname = "spir-v";
        version = "0.0.0.1";
-       sha256 = "1aazv418dd4kgpm8kq7n1cfm0gwcr0amsfdks0n1d9mn1rvz7b9p";
+       sha256 = "37adf3770eb6a6162cd0b3395d15c88c3f501d0bf6e089ea7d93b48602d95fa9";
        libraryHaskellDepends = [ base ];
        jailbreak = true;
        homepage = "https://github.com/expipiplus1/spir-v";
@@ -122902,7 +123288,7 @@ self: {
      mkDerivation {
        pname = "splay";
        version = "0.0.6";
-       sha256 = "1mq5n62lg2jbhzbl1py7yhnhdyxa0gn2xmihb9cm5r7p75p5wacl";
+       sha256 = "94295e6e39f7e452595a30d62eec03aafb062df4c7df40d7874b8a4785b105d7";
        libraryHaskellDepends = [ base ];
        description = "Generic splay-based sequence representation";
        license = stdenv.lib.licenses.bsd3;
@@ -122915,7 +123301,7 @@ self: {
      mkDerivation {
        pname = "splaytree";
        version = "0.1.5";
-       sha256 = "0jilqkgp1mk6sllxhigp1sidnp7amgsfdmxf23r0l69hp0w4dcm7";
+       sha256 = "a7b24638b830190af210aed7e6f4abea5cdba20ef745d829d566d670dfc4344a";
        libraryHaskellDepends = [ base deepseq ];
        testHaskellDepends = [
          base containers QuickCheck test-framework
@@ -122932,7 +123318,7 @@ self: {
      mkDerivation {
        pname = "splice";
        version = "0.6.1.1";
-       sha256 = "0lsfkm4vfipzbnqpf3yli6fwrv5a5mwbs149dfzhs7spa9kbxyl1";
+       sha256 = "81fabe6652571f0dbf6b8904bd782daaeccc9d89d40f77b15dff46b7499d4e53";
        libraryHaskellDepends = [ base network ];
        homepage = "http://corsis.github.com/splice/";
        description = "Cross-platform Socket to Socket Data Splicing";
@@ -122947,7 +123333,7 @@ self: {
      mkDerivation {
        pname = "spline3";
        version = "0.0.2";
-       sha256 = "112agbhn11wpy4dn0g3j9mrqcja5hhql55swmwh3lbm26hcvwjpq";
+       sha256 = "f84abe1934a22e3a20af5c97423184454986734d723c601bf1978760e17a4a84";
        isLibrary = false;
        isExecutable = true;
        executableHaskellDepends = [
@@ -122971,7 +123357,7 @@ self: {
      mkDerivation {
        pname = "splines";
        version = "0.5.0.1";
-       sha256 = "1bq5m8izvkrw21v9anp381rrq41svsmkxa0fk86ncm0lkaj09l5b";
+       sha256 = "abd004a49a1454660d9a0ea83eabde3a109c7340e35a9576103ccffd23aa05af";
        libraryHaskellDepends = [
          base containers polynomial vector vector-space
        ];
@@ -122989,7 +123375,7 @@ self: {
      mkDerivation {
        pname = "split";
        version = "0.1.4.3";
-       sha256 = "1i9vmb0zvmhqj6qcbnsapsk9lhsyzznz336c8s7v4sz20s99hsby";
+       sha256 = "7e69989206e26bb28f46cc8cf1edff5e439aa6be4adbc5b09118d6fdc1aa3bc5";
        libraryHaskellDepends = [ base ];
        jailbreak = true;
        homepage = "http://code.haskell.org/~byorgey/code/split";
@@ -123002,7 +123388,7 @@ self: {
      mkDerivation {
        pname = "split";
        version = "0.2.2";
-       sha256 = "0xa3j0gwr6k5vizxybnzk5fgb3pppgspi6mysnp2gwjp2dbrxkzr";
+       sha256 = "f9cf9e571357f227aed5be9a78f5bbf78ef55c99df2edf7fdc659acc1f904375";
        revision = "1";
        editedCabalFile = "9098e40414e8491b0a400f5874408e577a444c4eadf1e03fb4ea6dfcc32e30c4";
        libraryHaskellDepends = [ base ];
@@ -123016,7 +123402,7 @@ self: {
      mkDerivation {
        pname = "split-channel";
        version = "0.2.0.1";
-       sha256 = "0w2sgj1f5ydfvhm80d3pbka9988jwl80n14bp5nisawpd2glxvak";
+       sha256 = "53ed4e9f68972b1d6db98b040b10e512a194d45c7734802adcaef9e2827c5a70";
        libraryHaskellDepends = [ base ];
        description = "Control.Concurrent.Chan split into sending and receiving halves.";
        license = stdenv.lib.licenses.mit;
@@ -123029,7 +123415,7 @@ self: {
      mkDerivation {
        pname = "split-record";
        version = "0.1.1.1";
-       sha256 = "0d53npfi3mba83vpjkq59ga51nxqvkvv7gr0mj1jb8kj8i4jjw7v";
+       sha256 = "fb7029494472a22583ac20bfb3f7dcb8db50d44b054f79f7406ad511ddb5a334";
        isLibrary = false;
        isExecutable = true;
        executableHaskellDepends = [
@@ -123047,7 +123433,7 @@ self: {
      mkDerivation {
        pname = "split-tchan";
        version = "0.1.0.0";
-       sha256 = "0qwcbvnm2vlr4bmn8r1q3ycamvgs0nfap4dkyzgp54f9rrl73x2p";
+       sha256 = "57f47168cec99172dff7b391ab9c05faedaa981f386464eb22996e51ed5e8c63";
        libraryHaskellDepends = [ base stm ];
        description = "STM's TChan split into sending and receiving halves";
        license = stdenv.lib.licenses.bsd3;
@@ -123058,7 +123444,7 @@ self: {
      mkDerivation {
        pname = "splitter";
        version = "0.1.0.0";
-       sha256 = "1nibmm0ab7a2j9rdmnphzz2svc3xfq268jbn23a403465s0v6sq6";
+       sha256 = "066bb3812e860c40d41076496404767db0adc5fff0dada7292429da540ad2bda";
        isLibrary = false;
        isExecutable = true;
        executableHaskellDepends = [
@@ -123078,7 +123464,7 @@ self: {
      mkDerivation {
        pname = "splot";
        version = "0.3.12";
-       sha256 = "0xk5p2ikrzrmhvl69cl36sskcqgfnhxbbdlyp7bzl5pny0l0h9in";
+       sha256 = "36260828f0f616fad7b99eb6b53ab4ee6136b53683b264e88635ff3ca3b86576";
        isLibrary = false;
        isExecutable = true;
        executableHaskellDepends = [
@@ -123096,7 +123482,7 @@ self: {
      mkDerivation {
        pname = "spool";
        version = "0.1";
-       sha256 = "1svkz3cxkyi6f3akakjfk1cvij85xy69v52d88gh97xgiawp5346";
+       sha256 = "868c72b98aaf9f041f424d949d8cef05c9b859984e4e35d57026fad9d9f873eb";
        libraryHaskellDepends = [ base bytestring vector ];
        description = "Convert between ByteString and Vector.Storable without copying";
        license = stdenv.lib.licenses.bsd3;
@@ -123107,7 +123493,7 @@ self: {
      mkDerivation {
        pname = "spoon";
        version = "0.3.1";
-       sha256 = "1m41k0mfy6fpfrv2ym4m5jsjaj9xdfl2iqpppd3c4d0fffv51cxr";
+       sha256 = "b9b350b6730e34c246bbf7e228a86b3d4925b52c95542f7676d719ef2a9881d4";
        revision = "1";
        editedCabalFile = "e46c5e919cc9d0c7b0f671cddb631ef0979622a1e2250c59c7e491a799944527";
        libraryHaskellDepends = [ base deepseq ];
@@ -123122,7 +123508,7 @@ self: {
      mkDerivation {
        pname = "spoonutil";
        version = "0.0.1";
-       sha256 = "0xkarfm0c0931dz6yjs7pb5s2zizz1psnx9gfri5jq16skxk2nhd";
+       sha256 = "0d5a31fbd426605962762f75ab6ff83f7ea1cbba474b6f7e0b230106aacb6a76";
        isLibrary = true;
        isExecutable = true;
        libraryHaskellDepends = [
@@ -123141,7 +123527,7 @@ self: {
      mkDerivation {
        pname = "spoty";
        version = "0.1.0.2";
-       sha256 = "0p1mn8yixlyj2al98mxzs10m0klqqmmdfjcwc9xax97xp4ixjcm3";
+       sha256 = "a332d923b9fda4ae7a629c49d76ac5984e5041d0bf5794a812d2d31e3db2355c";
        libraryHaskellDepends = [
          aeson base bytestring lens lens-aeson pipes text
          unordered-containers wreq
@@ -123159,7 +123545,7 @@ self: {
      mkDerivation {
        pname = "spreadsheet";
        version = "0.1.3.3";
-       sha256 = "1q6cdgn1bf6dz6brd237ypw3cn0arbf9sm8ghzfngz20k0rbgcj1";
+       sha256 = "41b2b7329840fc67dd870f559ddcca0a5836f8f567889697f9cdb815ec6bcce0";
        isLibrary = true;
        isExecutable = true;
        libraryHaskellDepends = [
@@ -123175,7 +123561,7 @@ self: {
      mkDerivation {
        pname = "spritz";
        version = "0.1.0.0";
-       sha256 = "1syv2l0z7c2s6bbi5103i4var40j8pavahiic813v8m9s6waa4fk";
+       sha256 = "d311a5b8d1a9a23d02623142b5d5451290ac3689038412d7325ab0f30115dbeb";
        libraryHaskellDepends = [ base lens mtl vector ];
        homepage = "https://github.com/relrod/spritz";
        description = "An implementation of the Spritz RC4-like stream cipher in Haskell";
@@ -123189,7 +123575,7 @@ self: {
      mkDerivation {
        pname = "spsa";
        version = "0.2.0.0";
-       sha256 = "0jj08bkvmg8cj0lp7j8sd2ksanyrr5i2xxcz4kfwkrlyf8zhqxrh";
+       sha256 = "30770c3f729ee6c9dd249ff52e62c9d95ba5a7681ac97329900cbdbae742404a";
        libraryHaskellDepends = [ base hmatrix mtl random ];
        testHaskellDepends = [
          base hmatrix HUnit QuickCheck random test-framework
@@ -123209,7 +123595,7 @@ self: {
      mkDerivation {
        pname = "spy";
        version = "0.10";
-       sha256 = "1b3nhx009mzwl7n9d1bka4i9mwdh1gq08bsfmcnw9s7527nhn0ph";
+       sha256 = "f0020bed11e5e8c42dab4e2f04f00bb0f19a2251738596eca1fcd704408776ac";
        isLibrary = false;
        isExecutable = true;
        executableHaskellDepends = [
@@ -123234,7 +123620,7 @@ self: {
      mkDerivation {
        pname = "sql-simple";
        version = "0.3.1";
-       sha256 = "1vhg8ijpa64qalgza5sr3j8y1ihk6ys5lyf34vwcmjv8nlpyhpwh";
+       sha256 = "905fe82fb568cbcaf826c3795ab43713c6e0911c5917f51f5598187565440fee";
        libraryHaskellDepends = [
          base containers exceptions monad-control text transformers
          transformers-base
@@ -123253,7 +123639,7 @@ self: {
      mkDerivation {
        pname = "sql-simple-mysql";
        version = "0.3.0";
-       sha256 = "1i9xgzl3pjxii4mgx8az5gmygxq2vn1km7kmndwy07qkh26ynd7p";
+       sha256 = "f734eb8d80131fe079b3759e3a83dd02f7e7eb2b5fa1fe2a89b1cb3be87f3dc5";
        libraryHaskellDepends = [
          base data-default-class mysql mysql-simple sql-simple text
        ];
@@ -123271,7 +123657,7 @@ self: {
      mkDerivation {
        pname = "sql-simple-pool";
        version = "0.3.0";
-       sha256 = "14pradqy01vsd2cngvcbwvrwq5r3c5a00awi6j5vmkb51dycizh9";
+       sha256 = "09fec87c0b65cdba8b34912b0054612317ccf3e68bed6799687a07e07153f992";
        libraryHaskellDepends = [
          base data-default-class monad-control resource-pool sql-simple text
          time
@@ -123290,7 +123676,7 @@ self: {
      mkDerivation {
        pname = "sql-simple-postgresql";
        version = "0.3.0";
-       sha256 = "0dk2829zkcwxyqw0p2nsrm9gw527cmggdslhflrylg8xr1ag6zs1";
+       sha256 = "417ff354c81d3dea337590eaf65e654714fe52cdda8a0b38f69db3f993406236";
        libraryHaskellDepends = [
          base data-default-class postgresql-simple sql-simple text
        ];
@@ -123306,7 +123692,7 @@ self: {
      mkDerivation {
        pname = "sql-simple-sqlite";
        version = "0.3.0";
-       sha256 = "07ji17b4q9b8w9q9r8digb218qkjcrxfc24113p0f3pmgbwci3f1";
+       sha256 = "c18dc8f87af50e07ee088108e67a66726214c47ab1a19c70e268254cd609511e";
        libraryHaskellDepends = [ base sql-simple sqlite-simple ];
        jailbreak = true;
        homepage = "https://github.com/philopon/sql-simple";
@@ -123320,7 +123706,7 @@ self: {
      mkDerivation {
        pname = "sql-words";
        version = "0.1.3.1";
-       sha256 = "17dma51naynrxhvljwp7s3sadnmfqgallxsq7l763z6d0a25zkn9";
+       sha256 = "c9ce5f8402cdfc610e3d58774ad5c3aedaa6f4d0e7724937ecd97a654351b59d";
        libraryHaskellDepends = [ base ];
        testHaskellDepends = [ base QuickCheck quickcheck-simple ];
        homepage = "http://khibino.github.io/haskell-relational-record/";
@@ -123335,7 +123721,7 @@ self: {
      mkDerivation {
        pname = "sqlite";
        version = "0.5.2.2";
-       sha256 = "1hlyv2w4q2dlcsz18fqbmqf7nwsbzyh184ynzfnz5svvc8j9hbrp";
+       sha256 = "372f9824627bebf2adfbd61314a0ff4b737b1cae0b3b14be66b4094cb8d89ec2";
        libraryHaskellDepends = [
          base bytestring directory pretty time utf8-string
        ];
@@ -123352,7 +123738,7 @@ self: {
      mkDerivation {
        pname = "sqlite-simple";
        version = "0.4.9.0";
-       sha256 = "18v03yqq9jxyvxq93rh20sxak4ffsshhpq9v9lrz1lk9vnhy9pw1";
+       sha256 = "81dfe4a1dd69d2f0334d3be10ba1d6ce91a9ba0602e69170dfbecb84b11f60a3";
        libraryHaskellDepends = [
          attoparsec base blaze-builder blaze-textual bytestring containers
          direct-sqlite text time transformers
@@ -123372,7 +123758,7 @@ self: {
      mkDerivation {
        pname = "sqlite-simple-typed";
        version = "0.1.0.0";
-       sha256 = "00flij4wv8ga0bpnnai6gwwga1fkra9kr3y9yw30j7czwl5r2h0r";
+       sha256 = "1940910be59f1d0906f7c98f3c93cad305f5387f262a6bef02eaa1cd898cd401";
        libraryHaskellDepends = [
          base haskell-src-meta sqlite sqlite-simple template-haskell
          typedquery utf8-string
@@ -123389,7 +123775,7 @@ self: {
      mkDerivation {
        pname = "sqlvalue-list";
        version = "0.2";
-       sha256 = "1r9y3p355rl57pnm84flx734zzjxnnc53fkcfdkykxi5wi5j05v0";
+       sha256 = "6017204be425f6e967736cba5198b55dfe4fc6e9d41154ed3d85e652c61d3ee5";
        libraryHaskellDepends = [ base convertible HDBC template-haskell ];
        description = "Class and instances for conversion to list of SqlValue";
        license = stdenv.lib.licenses.bsd3;
@@ -123402,7 +123788,7 @@ self: {
      mkDerivation {
        pname = "squeeze";
        version = "1.0.4.4";
-       sha256 = "18nia9c5zvcwd3sbj1h53kfcfa2ihfmff74ab2lfi97dgrq5p1n4";
+       sha256 = "c4865b707eeda4e8a8588a1ce7aa835128c7dc1c0506b9f4689ced5f5852d1a2";
        isLibrary = false;
        isExecutable = true;
        executableHaskellDepends = [
@@ -123423,7 +123809,7 @@ self: {
      mkDerivation {
        pname = "sr-extra";
        version = "1.46.3.1";
-       sha256 = "0ssrv6h50kycxzb84s5j61mg78xyb4hyda2zxshnlqz0gbq134sr";
+       sha256 = "599311f07ae0636aa1ee5fa8e62159bea3f36a30b26882d6efcc4f50a0d9596b";
        libraryHaskellDepends = [
          base bytestring bzlib containers directory filepath HUnit mtl
          network-uri old-locale old-time pretty process pureMD5 QuickCheck
@@ -123441,7 +123827,7 @@ self: {
      mkDerivation {
        pname = "srcinst";
        version = "0.8.10";
-       sha256 = "05ydsh4ippapxcx7j3fq8s64qiskcrmndgvilxkdp4qhxyi80gj9";
+       sha256 = "493e80a2ef1093db66a771bf666b6653474c8c46d80d793aeb57dd1b09d4cd17";
        isLibrary = false;
        isExecutable = true;
        executableHaskellDepends = [
@@ -123458,7 +123844,7 @@ self: {
      mkDerivation {
        pname = "srcloc";
        version = "0.5.1.0";
-       sha256 = "1zssd6jxdhzl5wcygbmzq1s82i7m7rav6nm1m6kl5b68g77gc7g6";
+       sha256 = "e61df6ce79c8ac42a7a9a15ab3553ef5448174c0bfaee7192ff4c3d6a5695aff";
        libraryHaskellDepends = [ base ];
        homepage = "http://www.cs.drexel.edu/~mainland/";
        description = "Data types for managing source code locations";
@@ -123470,7 +123856,7 @@ self: {
      mkDerivation {
        pname = "srec";
        version = "0.1.0";
-       sha256 = "028sb4znvdqsygipcsf44j0xazk03pdfkirzrczmxcd11srh3h1k";
+       sha256 = "33c001b30ea1b15e3fcb3fc7e9da1d607ed58124c46976e3f31ab76d3f591a09";
        libraryHaskellDepends = [ base bytestring ];
        homepage = "http://tomahawkins.org";
        description = "Parsing and processing s-records";
@@ -123485,7 +123871,7 @@ self: {
      mkDerivation {
        pname = "sscgi";
        version = "0.3.0";
-       sha256 = "0pkhk6xhh1404yncyl62mjyp7mc2i06ihy243r0mq7qyy7ak417r";
+       sha256 = "f90432d5f11e1f5c411e4478180d8882d573bdacc250cfac27800408bb99705e";
        libraryHaskellDepends = [
          attoparsec base bytestring case-insensitive containers Glob
          MonadCatchIO-mtl mtl transformers utf8-string
@@ -123508,7 +123894,7 @@ self: {
      mkDerivation {
        pname = "ssh";
        version = "0.3.1";
-       sha256 = "1v4xrnc7h5r0nlcv3m129phf6qpp48fvkgv9yxf0fy1i3lp52krj";
+       sha256 = "324f512e1d3178075cf769bfb91d22f762e3e04d22d4b119b520177898cd9dec";
        libraryHaskellDepends = [
          asn1-encoding asn1-types base base64-string binary bytestring
          cereal containers crypto-api crypto-pubkey-types
@@ -123534,7 +123920,7 @@ self: {
      mkDerivation {
        pname = "sshd-lint";
        version = "0.1.0.1";
-       sha256 = "0q34zx8cn0gs91c4x4bicmygfaary5kk42ib62jk0hlrh3rzdi7c";
+       sha256 = "ecc4f6f380994230a5302b0a3267f15929f77c6571914e5848fa01cb50ff6460";
        isLibrary = false;
        isExecutable = true;
        executableHaskellDepends = [
@@ -123555,7 +123941,7 @@ self: {
      mkDerivation {
        pname = "sshtun";
        version = "1.0.0";
-       sha256 = "0794vsv043ppydzyjxnh06m4l3gbnga7x8nwsamh8skrzjfwn6jq";
+       sha256 = "581acb9dfc796a04abd2dca27ed4b3eb0d4aaa01d076e97ff3f70e02b6de241d";
        isLibrary = false;
        isExecutable = true;
        executableHaskellDepends = [
@@ -123576,7 +123962,7 @@ self: {
      mkDerivation {
        pname = "sssp";
        version = "1.1.1";
-       sha256 = "1nr30nrldjd3q1iw3l967x3v1rvl9afz1p87hhhkvpy60gri8m7c";
+       sha256 = "ec5414f303c6df3d218407ddf09d4a74e7b0473f26d1c163c0a3c946b30523db";
        isLibrary = true;
        isExecutable = true;
        libraryHaskellDepends = [
@@ -123605,7 +123991,7 @@ self: {
      mkDerivation {
        pname = "sstable";
        version = "1.0";
-       sha256 = "1siyjj75k1nsncpqwz53algbnvgbmr4syw45rfj1cpq4qbfwlcgm";
+       sha256 = "f531caddc2045f16a4cb8570af49aeeb6dbb1e55a37c8e2fb3da86598e943eea";
        isLibrary = true;
        isExecutable = true;
        libraryHaskellDepends = [
@@ -123622,7 +124008,7 @@ self: {
      mkDerivation {
        pname = "ssv";
        version = "0.3";
-       sha256 = "1z01611d380rgn64b0sbwxfbz7m8lgwhkc3lljpih6nsdn9hwrq5";
+       sha256 = "05670e936dda1a18afa474b009f9a3a89ebf5ce74b83458c7d19a0d1423001fc";
        isLibrary = true;
        isExecutable = true;
        libraryHaskellDepends = [ base containers ];
@@ -123637,7 +124023,7 @@ self: {
      mkDerivation {
        pname = "stable-heap";
        version = "0.1.0.0";
-       sha256 = "14wx42lmk2vd6v356q5cbd78y9xdnmkwcn6ddpnkyzq331hk23s1";
+       sha256 = "410f316118037f3fed6dcd58c667b5ad278f4e5bac6053c6366d8b59a9209d93";
        libraryHaskellDepends = [ base ];
        homepage = "http://hub.darcs.net/jmcarthur/stable-heap";
        description = "Purely functional stable heaps (fair priority queues)";
@@ -123649,7 +124035,7 @@ self: {
      mkDerivation {
        pname = "stable-maps";
        version = "0.0.5";
-       sha256 = "1sjidykbj5f692di93nml0frazvyw9kxyhjwbyyvrb9gwgc2ms3w";
+       sha256 = "7ce82ad8e32fadbcbd5f5c42df67e27e7f951da0d58e149b48c615b9a66f51ea";
        libraryHaskellDepends = [ base containers ghc-prim ];
        jailbreak = true;
        homepage = "http://github.com/ekmett/stable-maps";
@@ -123662,7 +124048,7 @@ self: {
      mkDerivation {
        pname = "stable-memo";
        version = "0.3.1";
-       sha256 = "1rv578311cvn7ym08vxxi18dhic50w7ms6cjn77vh032b8fxr3gx";
+       sha256 = "fd8ddc1d5a6200b8cfb192195d0f078545d85088bd6f04aa3f76b310063a65e7";
        libraryHaskellDepends = [ base ghc-prim hashtables ];
        description = "Memoization based on argument identity";
        license = stdenv.lib.licenses.mit;
@@ -123676,7 +124062,7 @@ self: {
      mkDerivation {
        pname = "stable-tree";
        version = "0.7.0";
-       sha256 = "0mcb983sdwfsf39gd8zsls7pgndqrnnzvxsz8kn9c5nqjxwdll4p";
+       sha256 = "9750da7897d81696ec445ff7fdadcdb8d9778fa6faa3f6d270daf1a6074a8b55";
        isLibrary = true;
        isExecutable = true;
        libraryHaskellDepends = [
@@ -123713,7 +124099,7 @@ self: {
      mkDerivation {
        pname = "stack";
        version = "9.9.9";
-       sha256 = "1kpsza23b22mg970c2qs943khzad38imzsa1xzki2a3xvfiadana";
+       sha256 = "caaaa6a2db7d2811e7ef41e95f231a4d7d3807491a0b064e7a55883584faface";
        revision = "4";
        editedCabalFile = "5ff7356010e14ec43684d11fcec6e34f47f794cc48a258919568cc27c72ffd34";
        isLibrary = true;
@@ -123756,7 +124142,7 @@ self: {
      mkDerivation {
        pname = "stack-prism";
        version = "0.1.4";
-       sha256 = "1lw42nkbzsc7mg8fnspjsply67ashrnbkml797fz2nvic84l8820";
+       sha256 = "4020440962715bf1dd4987d6b96c865a1de3e9d5f26aebd0ab87e9bfa61584d3";
        libraryHaskellDepends = [
          base profunctors tagged template-haskell transformers
        ];
@@ -123775,7 +124161,7 @@ self: {
      mkDerivation {
        pname = "stackage";
        version = "0.7.3.2";
-       sha256 = "0npry3yxbfyz97q19b405h40mb4rypgkhlp78hgl7zqbxk28ysza";
+       sha256 = "ea6b8fc4ec0bff431f44e75238dff599ac0a082c80ac14f049dfbbd5fdf0f95a";
        libraryHaskellDepends = [
          base stackage-build-plan stackage-cabal stackage-cli
          stackage-install stackage-sandbox stackage-setup stackage-update
@@ -123795,7 +124181,7 @@ self: {
      mkDerivation {
        pname = "stackage-build-plan";
        version = "0.1.1.0";
-       sha256 = "1slqkcmvnrbbg50qdf368q5h7svngw77b984mpg39p44mc7ghwyg";
+       sha256 = "cf73f80eab84dc34dead04a5750e7f76eb030b4666b88641796b65bb2b9b98ea";
        isLibrary = true;
        isExecutable = true;
        libraryHaskellDepends = [
@@ -123819,7 +124205,7 @@ self: {
      mkDerivation {
        pname = "stackage-cabal";
        version = "0.1.1";
-       sha256 = "0797izw5451mqr41a22xvv5c6c0936hi44cfmp9rzhj6mh92iwzj";
+       sha256 = "f2f32812ac46c29fd3ad8e1112a1190930c3cade5d081548c6351452f88f271d";
        isLibrary = true;
        isExecutable = true;
        libraryHaskellDepends = [ base ];
@@ -123840,7 +124226,7 @@ self: {
      mkDerivation {
        pname = "stackage-cli";
        version = "0.1.0.2";
-       sha256 = "10asq1zg7b4zqsn51ap03809j0bxrwh1gacc387wdi1p3zakn88n";
+       sha256 = "16213bd51f37c4c60f1a8ca91720cf7d0199001ae0aa50acc69facf37ec05a81";
        isLibrary = true;
        isExecutable = true;
        libraryHaskellDepends = [
@@ -123871,7 +124257,7 @@ self: {
      mkDerivation {
        pname = "stackage-curator";
        version = "0.10.0";
-       sha256 = "0dlsgm9bbib45591m7kj9vai48r4n0zvkwm4vd4c78rj54qhnq9n";
+       sha256 = "36610b312932a3c348dba4f2b93fb0242312d54e729e1a522964c5b5527d9a36";
        isLibrary = true;
        isExecutable = true;
        libraryHaskellDepends = [
@@ -123909,7 +124295,7 @@ self: {
      mkDerivation {
        pname = "stackage-install";
        version = "0.1.1.1";
-       sha256 = "0xdqd1q1xy0qax4c2dn1qa0qphvq01xy3wzdp7rr2xnd23ikmbs6";
+       sha256 = "46af3ae310cd7691f3b9edf3e17b0078c38b81c2c136c1485718f81e7068b875";
        isLibrary = true;
        isExecutable = true;
        libraryHaskellDepends = [
@@ -123932,7 +124318,7 @@ self: {
      mkDerivation {
        pname = "stackage-metadata";
        version = "0.3.0.0";
-       sha256 = "08hs6gnya0ci07gsacc01hvjamwh9xnfni9ihg7wf77w4vrncssx";
+       sha256 = "5d6b66f326fc1cc7cf833145eb6c4f905725370c8031a5df019101e5ed331a22";
        isLibrary = true;
        isExecutable = true;
        libraryHaskellDepends = [
@@ -123957,7 +124343,7 @@ self: {
      mkDerivation {
        pname = "stackage-sandbox";
        version = "0.1.5";
-       sha256 = "0d5i2wszn4sv797gzdv84abvdm3nzaa1lgn2gp4ywj1iqbbszbns";
+       sha256 = "daaeafd7c23148eec97dc23e1a94fa76d4b6972268b7ff4e3a5b13fb3517b134";
        isLibrary = true;
        isExecutable = true;
        libraryHaskellDepends = [ base ];
@@ -123979,7 +124365,7 @@ self: {
      mkDerivation {
        pname = "stackage-setup";
        version = "0.0.2";
-       sha256 = "1101sb822v42zjjgabn4s80qyvn6nvzkfagaxpzjm6dp5svl3biv";
+       sha256 = "3bae41b72eb7992affedea2937ffb6c66e8f01d2c42ef5a4fc826c21d0d20184";
        isLibrary = true;
        isExecutable = true;
        libraryHaskellDepends = [ base ];
@@ -124002,7 +124388,7 @@ self: {
      mkDerivation {
        pname = "stackage-types";
        version = "1.1.0";
-       sha256 = "0ynfnkpzvgd54x294w4ga8nyg8lrmcwg3bhlwdlxs2fcffaazi81";
+       sha256 = "01c5af9473cc09dd69e314aef138ab99a2e72d528f70924427a5bdfdefb4ce7a";
        libraryHaskellDepends = [
          aeson base Cabal containers exceptions hashable safe semigroups
          text time unordered-containers vector
@@ -124017,7 +124403,7 @@ self: {
      mkDerivation {
        pname = "stackage-update";
        version = "0.1.2";
-       sha256 = "1lw30fvscnb3n29lavw16am41adrvby1v2vbh7yykbr80pkb3hvj";
+       sha256 = "72c3b1e60528afe9fd816b8b1dfcdab9a940aa32816f4593b06359a6b70383d3";
        isLibrary = true;
        isExecutable = true;
        libraryHaskellDepends = [ base directory filepath process ];
@@ -124035,7 +124421,7 @@ self: {
      mkDerivation {
        pname = "stackage-upload";
        version = "0.1.0.5";
-       sha256 = "0fxkscyzpl6ph28100b0l663rjny9vp2jrhcca19dc0jzj0kfdgi";
+       sha256 = "f1353781fc12b09682620c6629ee4edeca3c8ca16001109080d7d0fb3dd3b33b";
        isLibrary = true;
        isExecutable = true;
        libraryHaskellDepends = [
@@ -124057,7 +124443,7 @@ self: {
      mkDerivation {
        pname = "standalone-haddock";
        version = "1.1.4.4";
-       sha256 = "02j10ws9n7xc2gvmpd146vrg7khawll9y3904h28k5d6ffk6qr14";
+       sha256 = "24646ca673a695890424200d9f28e50acef3f23624b45bf713ac1f9b3407410a";
        isLibrary = false;
        isExecutable = true;
        executableHaskellDepends = [
@@ -124073,7 +124459,7 @@ self: {
      mkDerivation {
        pname = "star-to-star";
        version = "1.0";
-       sha256 = "1nxkb1rdw6lhka49r6xdjskipyig09jzrvp82hx8a1xnqb9cyrrj";
+       sha256 = "3267cfd2c2b607853a14e8eefc65022ffa1ba796ad9b9c889a901ade7258b3db";
        libraryHaskellDepends = [ base ];
        description = "the * -> * types, operators, and covariant instances";
        license = "unknown";
@@ -124084,7 +124470,7 @@ self: {
      mkDerivation {
        pname = "star-to-star-contra";
        version = "1.0";
-       sha256 = "1kmpjm51jzk4pv6qggvwjvfqvqnr5z7znfbhiscvcq89j1842x53";
+       sha256 = "a3744150900961b6998e7039fbcf2fd9e28ddd967cbf87cdbe647e194a95b7ce";
        libraryHaskellDepends = [ base star-to-star ];
        description = "contravariant instances for * -> * types and operators";
        license = "unknown";
@@ -124095,7 +124481,7 @@ self: {
      mkDerivation {
        pname = "starling";
        version = "0.3.0";
-       sha256 = "0i0f19k2b5y6vb0jngqwnf035csgiaqjgiw37wvj8vs2lbh907bp";
+       sha256 = "771d90e0a2426f24373f83c727b18a4fb33280b31c3f2bc1dac69725660a0e44";
        libraryHaskellDepends = [
          base binary bytestring failure transformers
        ];
@@ -124112,7 +124498,7 @@ self: {
      mkDerivation {
        pname = "starrover2";
        version = "0.1.1";
-       sha256 = "0rdkxyhy62h87vdq08znqpjhg4wriwvbmn0pwak9nqsd5xk6slka";
+       sha256 = "6a526d662f4d639ba6e217d8ba368f999307e5c5f62380db3e080ae3a1efb365";
        isLibrary = false;
        isExecutable = true;
        executableHaskellDepends = [
@@ -124132,7 +124518,7 @@ self: {
      mkDerivation {
        pname = "stash";
        version = "0.1";
-       sha256 = "01h3s19agw2aa6a0hw8f9k2qibmckqllvnx2yy2w2p1xlw8g9jwm";
+       sha256 = "95cbf410a73d5cc185f7a2db4d299eacae88c54c0e710894514af0a752d00306";
        libraryHaskellDepends = [
          aeson attoparsec base bytestring directory hashable text vector
        ];
@@ -124145,7 +124531,7 @@ self: {
      mkDerivation {
        pname = "state";
        version = "0.1";
-       sha256 = "0j5hbh0rkcwfigvskmgb0hql95qs0cjbys61c6sni2hc719bshx6";
+       sha256 = "a643bd52380c8a68b561c168bf24031a97443104ebd5a9f78b8eb399015cb048";
        libraryHaskellDepends = [ arrows base mtl ];
        jailbreak = true;
        description = "Data.State";
@@ -124157,7 +124543,7 @@ self: {
      mkDerivation {
        pname = "state-plus";
        version = "0.1.1";
-       sha256 = "09zc4rymzvpq12mgl59h069m418qr43myhsj8dlf62g477wyx4g1";
+       sha256 = "e191eef939e409e3684352435f07c918055293013015faaa08f8ee5f7d26ec27";
        libraryHaskellDepends = [ base mtl ];
        testHaskellDepends = [ base checkers mtl QuickCheck ];
        jailbreak = true;
@@ -124170,7 +124556,7 @@ self: {
      mkDerivation {
        pname = "state-record";
        version = "0.0.1";
-       sha256 = "1y9ql1dlv2kf564x153gyw5h967pjn5zilfq88px8rqmkydqix7g";
+       sha256 = "eff4889b9f1567d42f42d8d1f88b95f798040bf76f94d089296e8a4d5ba038f9";
        libraryHaskellDepends = [ base mtl template-haskell ];
        homepage = "https://github.com/ktvoelker/state-record";
        description = "Better records for State monad states";
@@ -124183,7 +124569,7 @@ self: {
      mkDerivation {
        pname = "stateWriter";
        version = "0.2.3";
-       sha256 = "19rhkl39mlkyrj0i1qsmncnlj5nsvp8vp1vjhl43qmcbxfxflc0l";
+       sha256 = "1430eabaeb8b553c08857287bbd1ddda16492db355e31081cc7ed29a069d30a7";
        libraryHaskellDepends = [ base mtl transformers ];
        testHaskellDepends = [ base free hspec mtl QuickCheck ];
        description = "A faster variant of the RWS monad transformers";
@@ -124195,7 +124581,7 @@ self: {
      mkDerivation {
        pname = "statechart";
        version = "0.1.0";
-       sha256 = "122vv9h3rxn126chm5bj4rkxd7mbzndy73ck5nlmnhhxyks25d26";
+       sha256 = "46b422f4f41d425ba92d938de39bfdab9ed6672672950a9911c1f63c60da5b88";
        isLibrary = false;
        isExecutable = true;
        executableHaskellDepends = [ base polyparse ];
@@ -124209,7 +124595,7 @@ self: {
      mkDerivation {
        pname = "stateful-mtl";
        version = "1.0.7";
-       sha256 = "19645rqfqbcvngq8hj7bryl35lgx7p5k55vgsxa1a2hm2kq8vm5h";
+       sha256 = "b0d48df014150a1554d76f9732cb3dfdd132a8cfeb4888f0b39b2dec702ec4a4";
        libraryHaskellDepends = [ base MaybeT mtl ];
        description = "Typeclass instances for monad transformer stacks with an ST thread at the bottom";
        license = stdenv.lib.licenses.bsd3;
@@ -124221,7 +124607,7 @@ self: {
      mkDerivation {
        pname = "stateref";
        version = "0.3";
-       sha256 = "0hdpw6g255lj7jjvgqwhjdpzmka546vda5qjvry8gjj6nfm91lvx";
+       sha256 = "7dd390aab346ca877cde1217d5b62145cdfa6f9390e3b7a53c9296229ee1b741";
        libraryHaskellDepends = [ base mtl stm ];
        homepage = "http://code.haskell.org/~mokus/stateref/";
        description = "Abstraction for things that work like IORef";
@@ -124233,7 +124619,7 @@ self: {
      mkDerivation {
        pname = "statestack";
        version = "0.2.0.4";
-       sha256 = "0swj3f2vc56a5y2qxp2pq8nxkwngcw2lm87dmaikymchbqb832hd";
+       sha256 = "0d8a81165e90553fa3aaeda04a0567cff2d92dc257dc8e852fca14b6851b926b";
        libraryHaskellDepends = [
          base mtl transformers transformers-compat
        ];
@@ -124246,7 +124632,7 @@ self: {
      mkDerivation {
        pname = "statethread";
        version = "0.1.1";
-       sha256 = "05clniwqk4i3zz22jzbjj2x9cgkxb2ks7mccjyp3gyy4zbm2xlmz";
+       sha256 = "bfd22eeafac4fb37ae978cd5a3a7587d3e96ba90727d29c4ff23928979b49415";
        libraryHaskellDepends = [ applicative base transformers ];
        jailbreak = true;
        description = "The ST monad and STRefs";
@@ -124261,7 +124647,7 @@ self: {
      mkDerivation {
        pname = "statgrab";
        version = "0.1.3";
-       sha256 = "1rckyxg1px6v69rbr1ldy107b1q5rrh89dawlrdjzwbnmxjgbvj5";
+       sha256 = "45eef564af76f12f5ba65cb58460ce05877540f08d86bc7232dbf41b5ef793e5";
        libraryHaskellDepends = [
          async base bytestring time transformers
        ];
@@ -124277,7 +124663,7 @@ self: {
      mkDerivation {
        pname = "static-canvas";
        version = "0.2.0.2";
-       sha256 = "1lphx10wljylsbjwlw5p7bsjh5gf2fj1sl09556y814r11a6rjff";
+       sha256 = "cec96c54089904e44d2909501da413ee1528f53ab770cae5d2d44bca41e8f0d2";
        libraryHaskellDepends = [ base double-conversion free mtl text ];
        homepage = "https://github.com/jeffreyrosenbluth/static-canvas";
        description = "DSL to generate HTML5 Canvas javascript";
@@ -124289,7 +124675,7 @@ self: {
      mkDerivation {
        pname = "static-hash";
        version = "0.0.1";
-       sha256 = "0nkgx4s389027zi23wmbc6wqnmplvjvbrsbyzy7zn41mbwmzqz8l";
+       sha256 = "147dfc2b5f3510fb8fff7ee9bcb6dcf4568bb961abf221e23f02243434e96f5a";
        libraryHaskellDepends = [ array base containers hashable primes ];
        description = "Immutable hash";
        license = stdenv.lib.licenses.bsd3;
@@ -124303,7 +124689,7 @@ self: {
      mkDerivation {
        pname = "static-resources";
        version = "0.1.7";
-       sha256 = "0wf9kpn1l2iq00m1ms46vn2lrnyy8ip1z54ya2h4kqarcy5sr8m9";
+       sha256 = "a9a2ac8b6759e149a0509e941f6e44dedb4c85dd86e81a2a00380a1aec9dc971";
        libraryHaskellDepends = [
          base directory filepath hslogger MissingH mtl old-time process syb
          time
@@ -124321,7 +124707,7 @@ self: {
      mkDerivation {
        pname = "staticanalysis";
        version = "0.0.0.3";
-       sha256 = "0b6y8yi0cfisi58pxxx1gnd1vab2i8f5wb3gzv1dfsxx5hl6jlwf";
+       sha256 = "8e5369282cbd6bd7c2fe6f2c5e1c8a62a91d9a7da1f77e51893a3a06a247de2c";
        libraryHaskellDepends = [ base MissingH ];
        description = "Reusable static analysis interfaces and modules";
        license = stdenv.lib.licenses.gpl3;
@@ -124336,7 +124722,7 @@ self: {
      mkDerivation {
        pname = "statistics";
        version = "0.13.2.3";
-       sha256 = "1gbghzbacfrm7vn24ssx7wz9sycafxk9b306zm6cdlsr954v296n";
+       sha256 = "d624b1494959d3c64cfd068c9566778a799d3e3f5d6b22ec3e353ba6d6876fbd";
        libraryHaskellDepends = [
          aeson base binary deepseq erf math-functions monad-par mwc-random
          primitive vector vector-algorithms vector-binary-instances
@@ -124358,7 +124744,7 @@ self: {
      mkDerivation {
        pname = "statistics-dirichlet";
        version = "0.6.3";
-       sha256 = "1sx7hxv5gvzr270h4lb76dihcqcqwgdm6mq2394s407iipb2clbw";
+       sha256 = "7c5126d68df100a2491a025753dbe39861066333675102c111f9ef577687a7eb";
        libraryHaskellDepends = [
          base deepseq hmatrix-special nonlinear-optimization vector
        ];
@@ -124372,7 +124758,7 @@ self: {
      mkDerivation {
        pname = "statistics-fusion";
        version = "1.0.1";
-       sha256 = "17w7vz0jarbyf9y72bn9yg134q6ja5ymfyl1v9nx94glbhbybrlf";
+       sha256 = "8ee6e5175cf491d46dda817a577d51d26032c2f3c92e717c727e6525c1df879f";
        libraryHaskellDepends = [ base vector ];
        homepage = "http://code.haskell.org/~dons/code/statistics-fusion";
        description = "An implementation of high performance, minimal statistics functions";
@@ -124387,7 +124773,7 @@ self: {
      mkDerivation {
        pname = "statistics-hypergeometric-genvar";
        version = "0.1.0.0";
-       sha256 = "05j83vaklwi73yr4q4yq5f36wzmbas73lxkj0dkg0w1ss97syv7m";
+       sha256 = "f56caf4fd23a70f0660372763a8e56ab7e6e862bd8134cb21f27723ad51e4816";
        libraryHaskellDepends = [
          base math-functions mwc-random primitive statistics
        ];
@@ -124404,7 +124790,7 @@ self: {
      mkDerivation {
        pname = "statistics-linreg";
        version = "0.3";
-       sha256 = "02c9xrd3b8iy7bwgsf1r06smi88k3sgpqv2ivr782wl0dcbc4wv2";
+       sha256 = "6273c2166b8072814ede516c7c9f1e13a158b5013938fdf83a3ea2355aee8909";
        libraryHaskellDepends = [
          base MonadRandom random random-shuffle safe statistics vector
        ];
@@ -124418,7 +124804,7 @@ self: {
      mkDerivation {
        pname = "stats";
        version = "0.1.1";
-       sha256 = "08ig4nrlqshxmiar739zfbs95hlrp8l212hszh4zs0w2x4i3s17f";
+       sha256 = "ee043d22e98203fd09fc1a8a2028ba99c292f4723f8d9355ac1d6a4cb3252f22";
        isLibrary = false;
        isExecutable = true;
        executableHaskellDepends = [ base statistics text vector ];
@@ -124435,7 +124821,7 @@ self: {
      mkDerivation {
        pname = "statsd";
        version = "0.1.0.1";
-       sha256 = "13bcqms31rvzs3lfbmx43wqkmp21jbzj326yn971334cf722f0a1";
+       sha256 = "410127c4718c8c114eb2de8821ff9241dc3a311fa4d7e5e8d07fe73074c56c8d";
        libraryHaskellDepends = [
          base bytestring monad-control mtl network random
        ];
@@ -124452,7 +124838,7 @@ self: {
      mkDerivation {
        pname = "statsd-datadog";
        version = "0.2.0.0";
-       sha256 = "1c9kgyzfk5xdxsjkjhs6vbiz03mqm41qr0ycyfxc11v0wl78yazk";
+       sha256 = "f32b8f0ee56087c0baf3cc838c03a9b80ef0e3da464339a5eead97e9be7f33b1";
        libraryHaskellDepends = [
          base bytestring monad-control network text transformers-base
        ];
@@ -124466,7 +124852,7 @@ self: {
      mkDerivation {
        pname = "statvfs";
        version = "0.2";
-       sha256 = "16z9fddgvf5sl7zy7p74fng9lkdw5m9i5np3q4s2h8jdi43mwmg1";
+       sha256 = "e1555e07894d222834c1e3da12532dbc4d9a9e75e4dce3ffa1bab8fd5a73e99b";
        libraryHaskellDepends = [ base ];
        description = "Get unix filesystem statistics with statfs, statvfs";
        license = stdenv.lib.licenses.bsd3;
@@ -124477,7 +124863,7 @@ self: {
      mkDerivation {
        pname = "stb-image";
        version = "0.2.1";
-       sha256 = "1mx6i5q56wy13fvpnypb2c6fk2z3i5xdfblkpazzc70p2dgxaf52";
+       sha256 = "a238d55f13171cf6bfba932ed77a89e38be90c13eb7a7bb71bc173537089a6d7";
        libraryHaskellDepends = [ base bitmap bytestring ];
        homepage = "http://code.haskell.org/~bkomuves/";
        description = "A wrapper around Sean Barrett's JPEG/PNG decoder";
@@ -124489,7 +124875,7 @@ self: {
      mkDerivation {
        pname = "stb-truetype";
        version = "0.1.2";
-       sha256 = "1hbbi7hax5fw5zb7ashfs5paixqzqrrr64lwisda80dskdazld4m";
+       sha256 = "9534fa559bba01a49a8e9c129373c61ff7a86ed10e6a75d62fdc95aee0896bc1";
        libraryHaskellDepends = [ array base bytestring containers ];
        homepage = "http://code.haskell.org/~bkomuves/";
        description = "A wrapper around Sean Barrett's TrueType rasterizer library";
@@ -124502,7 +124888,7 @@ self: {
      mkDerivation {
        pname = "stdata";
        version = "0.0.4";
-       sha256 = "0ijir2knl4vc1cpzzmf32wcjfdc958li1wd7w5vdmgk4bx45kybf";
+       sha256 = "6ef959485f64beda76e1a7f110292a8935271917c3d5ff2f0b6c136aa7c85146";
        libraryHaskellDepends = [ base parsec syb template-haskell ];
        jailbreak = true;
        description = "Structure Data Library";
@@ -124517,7 +124903,7 @@ self: {
      mkDerivation {
        pname = "stdf";
        version = "0.2.0.0";
-       sha256 = "1blwf18qvsrhkxfakyznr3ljr35dw6d027jybr2hh4a5yfqn6zyd";
+       sha256 = "cd7f63b1f3451108455e5e1e019ae1ad8c2ce9c8f6fba95c9f30eb8d51709cae";
        isLibrary = true;
        isExecutable = true;
        libraryHaskellDepends = [
@@ -124538,7 +124924,7 @@ self: {
      mkDerivation {
        pname = "steambrowser";
        version = "0.1.0.0";
-       sha256 = "071ial002ip6lsm422wf9xzq7ka70h4va67382smkbgiinbma5g4";
+       sha256 = "e41555978df1ad59b540e318b5090447cd837f4f8e0b41aaa6e646010055311c";
        isLibrary = false;
        isExecutable = true;
        executableHaskellDepends = [ base directory parsec transformers ];
@@ -124554,7 +124940,7 @@ self: {
      mkDerivation {
        pname = "steeloverseer";
        version = "1.1.0.4";
-       sha256 = "1wqhjg6xw2k863fkfhq0i706c399xsv7z7gaf61x7l9wrc91pcbn";
+       sha256 = "76b11b12cb3cd1d38371ea9d7fb6ee290d66c089004337dd30680adecd9310f3";
        isLibrary = false;
        isExecutable = true;
        executableHaskellDepends = [
@@ -124571,7 +124957,7 @@ self: {
      mkDerivation {
        pname = "stemmer";
        version = "0.5.1";
-       sha256 = "0jiwwhwyqnbwzfn0vhd6d4f2zq6aazh18fbhm8w7zjc3cz0cr4m0";
+       sha256 = "a092ccc06783c97f38aa703914e057cae02f1c69a6c10dacfb7c59ec39e43c4a";
        libraryHaskellDepends = [ base ];
        homepage = "http://www.github.com/bgamari/stemmer";
        description = "Haskell bindings to the Snowball stemming library";
@@ -124583,7 +124969,7 @@ self: {
      mkDerivation {
        pname = "step-function";
        version = "0.1.1.0";
-       sha256 = "03pdpm1glmaqhqzr2cp08iy84c1vjhq0fq7yavmcrx94hxfw1zfd";
+       sha256 = "cdfdc05d8724f5ccea56fe600730943b30827c44e032913f865855fa42bded0e";
        libraryHaskellDepends = [ base ];
        testHaskellDepends = [
          base Cabal cabal-test-quickcheck QuickCheck
@@ -124599,7 +124985,7 @@ self: {
      mkDerivation {
        pname = "stepwise";
        version = "1.0.2";
-       sha256 = "059k8g3wb4hkxk42vm83vv6kh3igrpf7fc97xvn3qai5rx3jmgqf";
+       sha256 = "0ebf2a47cf252a3cecee273177dccd2f0e38cdde03d52dc8ec1392c5c7433315";
        libraryHaskellDepends = [ base containers mtl ];
        homepage = "http://www.cs.uu.nl/wiki/HUT/WebHome";
        license = "LGPL";
@@ -124611,7 +124997,7 @@ self: {
      mkDerivation {
        pname = "stickyKeysHotKey";
        version = "0.1.0.1";
-       sha256 = "18p0yxfw9wnzk0yxdvlm3g23k8zq5nb707411i92z5m82l6pkpmi";
+       sha256 = "b1de790d15a8962f520c811c70962df8a339c41b95eed63d98dff2c45df7e0a2";
        libraryHaskellDepends = [ base ];
        jailbreak = true;
        description = "get and set STICKYKEYS.SKF_HOTKEYACTIVE";
@@ -124624,7 +125010,7 @@ self: {
      mkDerivation {
        pname = "stitch";
        version = "0.3.2.0";
-       sha256 = "1h8n7ry8wmzvz4bjfg6vsd7ssy17y54h2pzgjdlfam8yfcly2bb7";
+       sha256 = "672de129731e55e56893ef5f0149f12778ad4fd3db3c2717f9fb578e7c3e16c1";
        libraryHaskellDepends = [ base containers text transformers ];
        testHaskellDepends = [ base Cabal hspec text ];
        description = "lightweight CSS DSL";
@@ -124636,7 +125022,7 @@ self: {
      mkDerivation {
        pname = "stm";
        version = "2.4.4";
-       sha256 = "0gc8zvdijp3rwmidkpxv76b4i0dc8dw6nbd92rxl4vxl0655iysx";
+       sha256 = "5dfb588a01b46f427b16a92d6b7843ac81489639bbdfd962e5795c19dbfe883d";
        libraryHaskellDepends = [ array base ];
        description = "Software Transactional Memory";
        license = stdenv.lib.licenses.bsd3;
@@ -124647,7 +125033,7 @@ self: {
      mkDerivation {
        pname = "stm-channelize";
        version = "0.1.1";
-       sha256 = "1aj4zibq54ssbb7smkxjrjl24d9vccgjpl2b9261yqyg692cz9hm";
+       sha256 = "15a6cf4432cf631f8c484bd02b1f633b3522a8ccb2cfaacf5a5a938257fc44aa";
        libraryHaskellDepends = [ base stm ];
        description = "Transactional I/O for duplex streams";
        license = stdenv.lib.licenses.bsd3;
@@ -124658,7 +125044,7 @@ self: {
      mkDerivation {
        pname = "stm-chans";
        version = "3.0.0.4";
-       sha256 = "0f27sp09yha43xk9q55sc185jyjs5h7gq2dhsyx6bm9kz9dzqi13";
+       sha256 = "2344fc5bfa33d565bad7b009fc0e2c5a7a595060ba149c661f44419fc0d54738";
        libraryHaskellDepends = [ base stm ];
        homepage = "http://code.haskell.org/~wren/";
        description = "Additional types of channels for STM";
@@ -124670,7 +125056,7 @@ self: {
      mkDerivation {
        pname = "stm-chunked-queues";
        version = "0.1.0.0";
-       sha256 = "0264air2mhwbya2sxskrh4z1bs8il7d9iv4vm6wyz8zxxc95v1nj";
+       sha256 = "d2865d12ebfda3efb9a99bec98daa111e9153e8179eaae85f28bc32a7254c408";
        libraryHaskellDepends = [ async base stm ];
        testHaskellDepends = [ async base HUnit stm tasty tasty-hunit ];
        homepage = "http://github.com/kholdstare/stm-chunked-queues/";
@@ -124690,7 +125076,7 @@ self: {
      mkDerivation {
        pname = "stm-conduit";
        version = "2.6.1";
-       sha256 = "0cd99aj9azlr6d9bayjyrbigbzll9yfny7qan1wnrh413i1z1x0p";
+       sha256 = "17f4f0431c81c06c79b00a1f6f9d4f94fef5e2ca5e7ab55233997e95a44aa931";
        libraryHaskellDepends = [
          async base cereal cereal-conduit conduit conduit-combinators
          conduit-extra directory ghc-prim lifted-async lifted-base
@@ -124714,7 +125100,7 @@ self: {
      mkDerivation {
        pname = "stm-containers";
        version = "0.2.9";
-       sha256 = "0p2lyz1s98cxdcqfamqyx7dxxa4fzxr0a93cbm7lnmzfjvk48p52";
+       sha256 = "a25c44e696ee574b4f5d6c240572ff8ea8dedbe91e57e5306b9da1a4c3f7545c";
        libraryHaskellDepends = [
          base-prelude focus hashable list-t loch-th placeholders primitive
          transformers
@@ -124734,7 +125120,7 @@ self: {
      mkDerivation {
        pname = "stm-delay";
        version = "0.1.1.1";
-       sha256 = "0cla21v89gcvmr1iwzibq13v1yq02xg4h6k9l6kcprj7mhd5hcmi";
+       sha256 = "b132581aac47e6cba6a1691a485e1700fbb047c02b7e1e43ae9bbd8476108a32";
        libraryHaskellDepends = [ base stm ];
        testHaskellDepends = [ base stm ];
        homepage = "https://github.com/joeyadams/haskell-stm-delay";
@@ -124750,7 +125136,7 @@ self: {
      mkDerivation {
        pname = "stm-firehose";
        version = "0.2.1";
-       sha256 = "0y4q3qj3ih2xcn0mhd4jszb1d5l87abkvlmhdvx9d1407bw9j99r";
+       sha256 = "392599f83a808496fa6eb0d23d973a889616d6d792345881655dc038241e9878";
        libraryHaskellDepends = [
          base blaze-builder conduit http-types network-conduit stm stm-chans
          stm-conduit transformers wai warp
@@ -124767,7 +125153,7 @@ self: {
      mkDerivation {
        pname = "stm-io-hooks";
        version = "1.1.0";
-       sha256 = "0dg2za2p7h9wb9lbs2yb07pdhq9sn4mdxxfmq179d9kinq94009m";
+       sha256 = "35014012b671a6964ec0d5f5de2ab13a61d8ee01cb0bbd685a3cc17385fae235";
        libraryHaskellDepends = [ array base containers mtl stm ];
        description = "STM with IO hooks";
        license = stdenv.lib.licenses.bsd3;
@@ -124778,7 +125164,7 @@ self: {
      mkDerivation {
        pname = "stm-lifted";
        version = "0.1.0.0";
-       sha256 = "1x3yxxyik0vyh3p530msxh2a1aylmh8zab05qpq7nfl5m9v6v090";
+       sha256 = "20816d76aa853a7bf0c5052cf511acd4aba004ecba8251ee807e83197def7ef4";
        revision = "1";
        editedCabalFile = "d313721a31d8e7ccc725c3a1542f4ac3f8c84fbcad10094cd1067c133edc6c54";
        libraryHaskellDepends = [ base stm transformers ];
@@ -124791,7 +125177,7 @@ self: {
      mkDerivation {
        pname = "stm-linkedlist";
        version = "0.1.0.0";
-       sha256 = "1x65z38dx0qi55fmbarc1827wpl4j08m23nklq8854y7kqznf9kr";
+       sha256 = "7926673f9ec7938210a6d30e511190845e7e040a2cab555d291183ded0f8c5f4";
        libraryHaskellDepends = [ base stm ];
        description = "Mutable, doubly linked lists for STM";
        license = stdenv.lib.licenses.bsd3;
@@ -124802,7 +125188,7 @@ self: {
      mkDerivation {
        pname = "stm-orelse-io";
        version = "0.1";
-       sha256 = "11v0xc5zlw641mf6r5k8lqhzxc4y9bsx3xivwmbkfniph0x7g5m4";
+       sha256 = "a496773a80375a3757e53bf6d1f54a9eb0fe21a668966c5c0dc470fa0beb6087";
        libraryHaskellDepends = [ base stm ];
        homepage = "http://nonempty.org/software/stm-orelse-io";
        description = "Choose between the return value of an STM operation and an IO action";
@@ -124814,7 +125200,7 @@ self: {
      mkDerivation {
        pname = "stm-promise";
        version = "0.0.3.1";
-       sha256 = "07wrbj88gwdbsczjr225g0z1ai1v13mdg71gl9qsmipqs0s0pfwc";
+       sha256 = "8cbb0b34d0f8c6aa71a22f9cd7ea083b44153e7845882c3fd3abf187905c991f";
        libraryHaskellDepends = [ base mtl process stm unix ];
        testHaskellDepends = [ base QuickCheck stm ];
        homepage = "http://www.github.com/danr/stm-promise";
@@ -124827,7 +125213,7 @@ self: {
      mkDerivation {
        pname = "stm-queue-extras";
        version = "0.2.0.0.1";
-       sha256 = "1zb6i8dg11pshvb6rm5sqdsbq547h4ys6wlmh2ywcmks2ss7q100";
+       sha256 = "00047cb4167a56c6bd809572a33d818714bc74c3bad46cd686fa86f01a8a66fd";
        libraryHaskellDepends = [ base stm stm-chans ];
        description = "Extra queue utilities for STM";
        license = stdenv.lib.licenses.asl20;
@@ -124838,7 +125224,7 @@ self: {
      mkDerivation {
        pname = "stm-sbchan";
        version = "0.1";
-       sha256 = "0fz4vfbyr848b32vbdm3pjj9gwi7wj39l3vsqmdpjnbfwvkw0y0s";
+       sha256 = "1a78c0e7e66e59795bc57a0f9a86e427f297a4bca3b6b5c55888a0ec97dbe43b";
        libraryHaskellDepends = [ base stm stm-tlist ];
        homepage = "https://github.com/joeyadams/haskell-stm-sbchan";
        description = "Bounded channel for STM where item sizes can vary";
@@ -124850,7 +125236,7 @@ self: {
      mkDerivation {
        pname = "stm-split";
        version = "0.0.0.1";
-       sha256 = "05338nbfhwmyy8njynznmbv0lddqs4kzs5x132992xq346dvvww8";
+       sha256 = "88f3bd9b210377919218a117fd27d1b8350af6aaf65b2f2df2be72e896456314";
        libraryHaskellDepends = [ base stm ];
        description = "TMVars, TVars and TChans with distinguished input and output side";
        license = stdenv.lib.licenses.bsd3;
@@ -124861,7 +125247,7 @@ self: {
      mkDerivation {
        pname = "stm-stats";
        version = "0.2.0.0";
-       sha256 = "0i8ky2l8lvh7nymxglvbifp0ylbyjw20p75avzb51zpzx6qkjkqa";
+       sha256 = "0a4f39b1e9fffe50d6dfaa9c0b04977e510fae8b6bd3d7abb7076e8aa8f01345";
        libraryHaskellDepends = [
          base containers stm template-haskell time
        ];
@@ -124874,7 +125260,7 @@ self: {
      mkDerivation {
        pname = "stm-tlist";
        version = "0.1.1";
-       sha256 = "0ssr8phmm9m93kcp045jr0rcn1dxzz202cgyw1vzjl2ch55bcsy6";
+       sha256 = "c66bb64a814c50f977e0fe3101c4ffbd05cb32c8b21070d91ca9a65ae145596b";
        libraryHaskellDepends = [ base stm ];
        homepage = "https://github.com/joeyadams/haskell-stm-tlist";
        description = "Mutable, singly-linked list in STM";
@@ -124886,7 +125272,7 @@ self: {
      mkDerivation {
        pname = "stmcontrol";
        version = "0.1";
-       sha256 = "0m42pgnvzqadqycq0qbml5da0zw7myc24y5vka1qydz7rdfyaa24";
+       sha256 = "4428e55dcbe7378f839abb782298af877fa05aa175618099c74de1bfedbb8254";
        libraryHaskellDepends = [ base haskell98 mtl stm ];
        homepage = "http://sulzmann.blogspot.com/2008/12/stm-with-control-communication-for.html";
        description = "Control communication among retrying transactions";
@@ -124901,7 +125287,7 @@ self: {
      mkDerivation {
        pname = "stomp-conduit";
        version = "0.1.0";
-       sha256 = "1qzr5fkffs96clxkvm7lf7kfafijv8fsri6k0j85wrarx3qdgapa";
+       sha256 = "eaaad7f0e859655e9004d3c4ac1dda323ae5e671f4d43d3b652669e7a62bf9e3";
        libraryHaskellDepends = [
          base conduit mime mtl resourcet stomp-queue stompl
        ];
@@ -124917,7 +125303,7 @@ self: {
      mkDerivation {
        pname = "stomp-patterns";
        version = "0.1.0";
-       sha256 = "0rdk9h7blj7j5kiwy7zq2kb4wxxs19xk3lg73c0srrvbclb0qgbw";
+       sha256 = "7c3d0c16656be7ac011be7d1317b0aba774ed614f81fcfe32cf248ba0e4cb365";
        libraryHaskellDepends = [
          base bytestring containers mime mtl split stomp-queue stompl time
        ];
@@ -124934,7 +125320,7 @@ self: {
      mkDerivation {
        pname = "stomp-queue";
        version = "0.2.2";
-       sha256 = "1kymwwj7yjdsyykqdqcnvgphbb1ypx7hi5a2wvx1wzv53lrspa9c";
+       sha256 = "2ca9ab331d657f1efae64295084fbf3eac05efdb96e186a7f7ba497f24e7d5cf";
        libraryHaskellDepends = [
          attoparsec base bytestring conduit conduit-extra mime mtl
          network-conduit-tls split stompl time utf8-string
@@ -124951,7 +125337,7 @@ self: {
      mkDerivation {
        pname = "stompl";
        version = "0.3.0";
-       sha256 = "1ip50w8f26362h1s3kb0qzv15dq264j0vbmqw5v0s40gbwmpv2aj";
+       sha256 = "52897d2b5f0f100d76e1b8ae0d243102b712f6c760cda103146618e11007e5c6";
        libraryHaskellDepends = [
          attoparsec base bytestring mime split text utf8-string
        ];
@@ -124965,7 +125351,7 @@ self: {
      mkDerivation {
        pname = "storable";
        version = "0.1";
-       sha256 = "10289mf3fskfpg0jwgzyhvg4arb0hcj3r94jngb3hlbidvf8k1jg";
+       sha256 = "4f8689dc6e715138d6b392a43c2483606545de86fe3f2ec1bb6e6a375c4d4880";
        libraryHaskellDepends = [ base mtl ];
        homepage = "http://anna.fi.muni.cz/~xjanous3/gitweb/?p=storable.git;a=summary";
        description = "Storable type class for variable-sized data";
@@ -124977,7 +125363,7 @@ self: {
      mkDerivation {
        pname = "storable-complex";
        version = "0.2.2";
-       sha256 = "01kwwkpbfjrv26vj83cd92px5qbq1bpgxj0r45534aksqhany1xb";
+       sha256 = "ab076f15c47a2a324a2119c8feee0a78e1d2af488d0d24b7113b4bb7eee47c06";
        libraryHaskellDepends = [ base ];
        homepage = "https://github.com/cartazio/storable-complex";
        description = "Storable instance for Complex";
@@ -124989,7 +125375,7 @@ self: {
      mkDerivation {
        pname = "storable-endian";
        version = "0.2.5";
-       sha256 = "04j1nk0wga4dqrqvhm8yd9h9194db1n3yrnhg8s3gsc0jk7yw1p2";
+       sha256 = "e206eecf9480e937347ad0663f6c588da490606a1e55b871c68da8c7c1b44112";
        libraryHaskellDepends = [ base byteorder ];
        description = "Storable instances with endianness";
        license = stdenv.lib.licenses.bsd3;
@@ -125000,7 +125386,7 @@ self: {
      mkDerivation {
        pname = "storable-record";
        version = "0.0.3";
-       sha256 = "1mv2s4r7dqkl2fy0wjnywyr2zi2g53nkn0z72mgr8drkzdszzxx1";
+       sha256 = "a1f7ff75fb3337945f15e7033bed284fc42fb2e7de4a0ebc1374e27632d162d7";
        isLibrary = true;
        isExecutable = true;
        libraryHaskellDepends = [ base transformers utility-ht ];
@@ -125014,7 +125400,7 @@ self: {
      mkDerivation {
        pname = "storable-static-array";
        version = "0.6.1.0";
-       sha256 = "0akdh6v2cdq38jw8v69bn3m50g6wxanh0plikq4hj5mfrkg6xsxm";
+       sha256 = "b5eb6edeccae1609099e915e00adeadc3c50eab02b998db844033726b6816d2a";
        libraryHaskellDepends = [ array base tagged vector ];
        jailbreak = true;
        description = "Statically-sized array wrappers with Storable instances for FFI marshaling";
@@ -125027,7 +125413,7 @@ self: {
      mkDerivation {
        pname = "storable-tuple";
        version = "0.0.2";
-       sha256 = "03qls46rwc3za730r6pv63rrnjq4vkh3h2vjhx9082dqa9q7vqqd";
+       sha256 = "0de37d7052b809045287720b38e0dc044b9bf330fb9a0cc6517f309e0dd1140f";
        libraryHaskellDepends = [ base storable-record utility-ht ];
        homepage = "http://code.haskell.org/~thielema/storable-tuple/";
        description = "Storable instance for pairs and triples";
@@ -125041,7 +125427,7 @@ self: {
      mkDerivation {
        pname = "storablevector";
        version = "0.2.10";
-       sha256 = "0195j9b0p5217jdai4lwyhfwihnxgsqxcbzpa375wsa66kxjk7bl";
+       sha256 = "749d29fb3446695ece50f72fd6b17eddc2c81df49c92a89a3c41940b56922505";
        libraryHaskellDepends = [
          base non-negative QuickCheck syb transformers unsafe utility-ht
        ];
@@ -125060,7 +125446,7 @@ self: {
      mkDerivation {
        pname = "storablevector-carray";
        version = "0.0";
-       sha256 = "1cqgfddaldxj2yig39fr2smm23nfz52dvh5grf4zr222djm7043i";
+       sha256 = "711070aa6c4288fc89cbafc0dd44f9ce0e51ab16d9a5f1a217b237aa5a730fb3";
        libraryHaskellDepends = [ base carray storablevector utility-ht ];
        homepage = "http://www.haskell.org/haskellwiki/Storable_Vector";
        description = "Conversion between storablevector and carray";
@@ -125075,7 +125461,7 @@ self: {
      mkDerivation {
        pname = "storablevector-streamfusion";
        version = "0.0";
-       sha256 = "1qgnakr01f28iarq1qd5x86919fj7zwf19nb80w7757l0dhdjb6m";
+       sha256 = "d52cd96003f494733840cba6e0f83fd2a5900ceaa5e180b38a48b800f254f6e1";
        isLibrary = true;
        isExecutable = true;
        libraryHaskellDepends = [
@@ -125098,7 +125484,7 @@ self: {
      mkDerivation {
        pname = "str";
        version = "0.1.0.0";
-       sha256 = "093bgzjj183g48gapmjvbrbp7ns7wfcf94ishgwy84gajpkyb6sr";
+       sha256 = "599be5e795ea11e4f9833a92e498e347db73575e5bd6ab1e226fa020e57f6b24";
        libraryHaskellDepends = [
          base base16-bytestring bytestring Crypto hashable MissingH text
          utf8-string
@@ -125117,7 +125503,7 @@ self: {
      mkDerivation {
        pname = "stratum-tool";
        version = "0.0.4";
-       sha256 = "02m8znx5spg8mjphbqw4kw5mavjki8hjfqf6x9j9i0xsja88958p";
+       sha256 = "1795849092ba839864eac66127218a536e550b9f84e305aface85d5dbafda80a";
        isLibrary = false;
        isExecutable = true;
        executableHaskellDepends = [
@@ -125134,7 +125520,7 @@ self: {
      mkDerivation {
        pname = "stream-fusion";
        version = "0.1.2.5";
-       sha256 = "006fz03jdwd9d0kwf8ma3077xxmg6zym94pwbb4sx1xcn7zf4yc6";
+       sha256 = "8679e2feb1ac87aec95afc9254fd37aff67e0e18aa22c72768a9f12607f8ce00";
        libraryHaskellDepends = [ base ];
        homepage = "http://hackage.haskell.org/trac/ghc/ticket/915";
        description = "Faster Haskell lists using stream fusion";
@@ -125147,7 +125533,7 @@ self: {
      mkDerivation {
        pname = "stream-monad";
        version = "0.4.0.2";
-       sha256 = "0311j6a378pm26g9qqfjpnjq7909qj69fhiw253ln603z5q5gkc6";
+       sha256 = "86cd5770f903184b47113c42978cc409a483a5bdd2619c9e11f5a2339491210c";
        isLibrary = true;
        isExecutable = true;
        libraryHaskellDepends = [ base logict ];
@@ -125165,7 +125551,7 @@ self: {
      mkDerivation {
        pname = "streamed";
        version = "0.2";
-       sha256 = "0dql0vxw28nr60979zhhc9frwqhg6cmj8g03r4m8zlb6anqwv7xa";
+       sha256 = "aa9fcdb15566d18f2ac9033c242b330f629e5d6210fe741230d922c1fb061437";
        libraryHaskellDepends = [
          alsa-core alsa-seq base containers data-accessor
          data-accessor-transformers event-list midi midi-alsa non-negative
@@ -125186,7 +125572,7 @@ self: {
      mkDerivation {
        pname = "streaming-commons";
        version = "0.1.12.1";
-       sha256 = "1msg18bvz1cxfh745m3jgxf65x7jncqwwpfi538x24qsn788vgfm";
+       sha256 = "d5bd8dd0b11a13d1d128d15dce31b3f2f4625c7f72d4420e749d85bf170a4fd7";
        libraryHaskellDepends = [
          array base blaze-builder bytestring directory network process
          random stm text transformers unix zlib
@@ -125207,7 +125593,7 @@ self: {
      mkDerivation {
        pname = "streaming-histogram";
        version = "0.1.0.0";
-       sha256 = "1sm05hx5llab6ng6d27rz44kd6njk85axkn3bs3nm03pr85c9xq7";
+       sha256 = "07f7c40aca77806a875ec3ceae0a9ad29a3609f9f988669e354b515a3a2ca0ea";
        libraryHaskellDepends = [ base containers criterion ];
        testHaskellDepends = [
          base containers tasty tasty-hunit tasty-quickcheck
@@ -125220,7 +125606,7 @@ self: {
      mkDerivation {
        pname = "streamproc";
        version = "1.6.2";
-       sha256 = "1wl44n4nav4h203mzfdf1bd5nh4v23dib54lvxka1rl3zymgyvp7";
+       sha256 = "e76effaaff83e6a066df949415db109b405bda0aaeb95f0710906c65892584f2";
        libraryHaskellDepends = [ base ];
        homepage = "http://github.com/peti/streamproc";
        description = "Stream Processer Arrow";
@@ -125234,7 +125620,7 @@ self: {
      mkDerivation {
        pname = "streams";
        version = "3.2.1";
-       sha256 = "1xyrsb55dg7v3pris0hc0yqdlqaymxb6g286wrbc7h2lva5wrva4";
+       sha256 = "44edcc8bda54c0c356e606896756af5e61dab0070c021df31dfbbc56cad2d9f7";
        libraryHaskellDepends = [
          adjunctions base comonad distributive semigroupoids semigroups
        ];
@@ -125248,7 +125634,7 @@ self: {
      mkDerivation {
        pname = "strict";
        version = "0.3.2";
-       sha256 = "08cjajqz9h47fkq98mlf3rc8n5ghbmnmgn8pfsl3bdldjdkmmlrc";
+       sha256 = "2cd35a67938db635a87617d9576d5df0158b581e8e5694f07487c0f4b1549221";
        libraryHaskellDepends = [ array base ];
        homepage = "http://www.cse.unsw.edu.au/~rl/code/strict.html";
        description = "Strict data types and String IO";
@@ -125262,7 +125648,7 @@ self: {
      mkDerivation {
        pname = "strict-base-types";
        version = "0.3.0";
-       sha256 = "03z38yxig43qq4xw9hinzzfarzy7176s5gfv8rsjnild8sa0bsvb";
+       sha256 = "6beb0594468d462b7546dbbda2cd09c7ffacdcff36c2c43bc1789017bb47e30f";
        libraryHaskellDepends = [
          aeson base bifunctors binary deepseq ghc-prim lens QuickCheck
          strict
@@ -125277,7 +125663,7 @@ self: {
      mkDerivation {
        pname = "strict-concurrency";
        version = "0.2.4.1";
-       sha256 = "128sbh5fnv02v2xdjlk7cb525bfckqyj7fyz5399nfycs0nj2f89";
+       sha256 = "0939212dd0cc3b9bd228dfbb233d9eccad22ca626752d9bad8026ceb0a5c1a89";
        revision = "1";
        editedCabalFile = "e9b8d4599f2eae037bb3b6008284513dbb50af7d3ab42e617b76577bdea656a1";
        libraryHaskellDepends = [ base deepseq ];
@@ -125293,7 +125679,7 @@ self: {
      mkDerivation {
        pname = "strict-ghc-plugin";
        version = "0.1.1";
-       sha256 = "0hx1zp99npwdp5w3q93xfidcw59lxskilmbqc80xi97d4w4h8jrb";
+       sha256 = "2b4b040927eda4d8016278551aa7ee3415ce5a747d243c78b98d5f9bd2fda143";
        libraryHaskellDepends = [ base ghc syb ];
        homepage = "http://thoughtpolice.github.com/strict-ghc-plugin";
        description = "Compiler plugin for making Haskell strict";
@@ -125305,7 +125691,7 @@ self: {
      mkDerivation {
        pname = "strict-identity";
        version = "0.1.0.0";
-       sha256 = "1fzcim7baycdb60z5icdw5flj1a3dfn6xscpyif6l94c1538g3i1";
+       sha256 = "218e8746098c246a5cf497e96eac6b4305495de18dc5f281598d79b54e8decbb";
        libraryHaskellDepends = [ base ];
        jailbreak = true;
        homepage = "https://github.com/cartazio/strict-identity";
@@ -125318,7 +125704,7 @@ self: {
      mkDerivation {
        pname = "strict-io";
        version = "0.2.1";
-       sha256 = "003pfzjixa04qyx4db0rgk7y72nk2xwlb29aigmdmfn80xbmw9md";
+       sha256 = "ad265e5707c8badaea8b2a89457917d38ae3cf7c19ac46bac704a81ee5777700";
        libraryHaskellDepends = [ base deepseq extensible-exceptions ];
        jailbreak = true;
        description = "A library wrapping standard IO modules to provide strict IO";
@@ -125330,7 +125716,7 @@ self: {
      mkDerivation {
        pname = "strictify";
        version = "0.1";
-       sha256 = "0z28ifg21xgzh75ird41mp40a4rrc5p0wrnbhrxv92ih6pf5zmah";
+       sha256 = "50d55fdc35308ab47b86cb660e6e61391305c8ad81b41ccb81fff5209e8b487c";
        isLibrary = false;
        isExecutable = true;
        executableHaskellDepends = [
@@ -125345,7 +125731,7 @@ self: {
      mkDerivation {
        pname = "strictly";
        version = "1.0.0.0";
-       sha256 = "1a3azrg9ksb4kmbckjqw3krxj0app6q19ighd6k3z7xpf682qx3c";
+       sha256 = "6c742c9071b79f3fa669f0c514b0b95701d9f31c1ccbc9569d64e9995efe6aa8";
        libraryHaskellDepends = [ base deepseq ];
        jailbreak = true;
        homepage = "https://github.com/DanBurton/strictly#readme";
@@ -125358,7 +125744,7 @@ self: {
      mkDerivation {
        pname = "string";
        version = "0.4.0";
-       sha256 = "1l94p8c9j8a2dbpwj5q7d1m61gdhmi6vllz34g8d9qjfwpnx7z6z";
+       sha256 = "dffcd3ede54ee2d4d023e353ba4dacb0bd606a680717c9ef6a42219918ba24d1";
        description = "None";
        license = stdenv.lib.licenses.bsd3;
        hydraPlatforms = stdenv.lib.platforms.none;
@@ -125369,7 +125755,7 @@ self: {
      mkDerivation {
        pname = "string-class";
        version = "0.1.6.5";
-       sha256 = "0yi3fagwqkgr8pf6wnl360qikyvfb649qs2y6gp0n7jjw0zc27c2";
+       sha256 = "821dc13ee0521e0bee335e689c88596efb193130835a6edc45f94dcc9f72237a";
        libraryHaskellDepends = [ base bytestring tagged text ];
        homepage = "https://github.com/bairyn/string-class";
        description = "String class library";
@@ -125381,7 +125767,7 @@ self: {
      mkDerivation {
        pname = "string-combinators";
        version = "0.6.0.5";
-       sha256 = "07ky2z5f1l5mb7r3rvyraak0bzciq4krkg5lv8g0a5vxpnzlm4cl";
+       sha256 = "94914abfbd7d17051edab4bc9927c191fd05a652d9ef3cf259b5d0e0ca177e1e";
        libraryHaskellDepends = [ base ];
        homepage = "https://github.com/basvandijk/string-combinators";
        description = "Polymorphic functions to build and combine stringlike values";
@@ -125393,7 +125779,7 @@ self: {
      mkDerivation {
        pname = "string-conv";
        version = "0.1";
-       sha256 = "0zjmlkjmdiqnfnb9qqam6bkipwqz5iwy4bjy9xcs20ljf01586l6";
+       sha256 = "861a5402709202a1594f5e2ee2792c1ff31be73255619c967516c756e5a4557e";
        libraryHaskellDepends = [ base bytestring text ];
        description = "Standardized conversion between string types";
        license = stdenv.lib.licenses.bsd3;
@@ -125404,7 +125790,7 @@ self: {
      mkDerivation {
        pname = "string-conversions";
        version = "0.4";
-       sha256 = "1bi4mjnz0srb01n0k73asizp5h2ir7j3whxai9wprqvz7kdscr0s";
+       sha256 = "1a64a6db3c7fe37c798aaa433ee4c951c0727fd46a9c096c002b6bf0adac24ae";
        libraryHaskellDepends = [ base bytestring text utf8-string ];
        description = "Simplifies dealing with different types for strings";
        license = stdenv.lib.licenses.bsd3;
@@ -125415,7 +125801,7 @@ self: {
      mkDerivation {
        pname = "string-convert";
        version = "2.0.1";
-       sha256 = "0lx9bc7czwzbf8rky8k02kgi6w3pjfz6ydig9i9ll83zy70l9208";
+       sha256 = "088844c1f17f204a534c2f366fbe93777013df1460223f3372ebf3cf0e5ba953";
        libraryHaskellDepends = [ base bytestring text utf8-string ];
        homepage = "https://bitbucket.org/tdammers/string-convert";
        description = "Provide universal string conversions between any two string-like types";
@@ -125427,7 +125813,7 @@ self: {
      mkDerivation {
        pname = "string-qq";
        version = "0.0.2";
-       sha256 = "0662m3i5xrdrr95w829bszkhp88mj9iy1zya54vk2sl5hz9wlmwp";
+       sha256 = "9757cad387856a313729caffe0639215a10be7d72b09c44bcab9e55ee2a8c218";
        libraryHaskellDepends = [ base template-haskell ];
        description = "QuasiQuoter for non-interpolated strings, texts and bytestrings";
        license = stdenv.lib.licenses.publicDomain;
@@ -125438,7 +125824,7 @@ self: {
      mkDerivation {
        pname = "string-quote";
        version = "0.0.1";
-       sha256 = "1pfkd3lwdphvl00gly7zbpvsmlw6b2d5568rxyqmq2qw6vzf9134";
+       sha256 = "6484e4fe361c0b5cb1ef1999529a5886d3aaf75dff78fa00a01bdec6e968d3dd";
        libraryHaskellDepends = [ base template-haskell ];
        description = "QuasiQuoter for non-interpolated strings, texts and bytestrings";
        license = stdenv.lib.licenses.bsd3;
@@ -125449,7 +125835,7 @@ self: {
      mkDerivation {
        pname = "string-similarity";
        version = "0.1.0.0";
-       sha256 = "0k03krg3m03bxk9i5ph5ipks9b0j8yqsal0haf8fyjq83xs1hbmv";
+       sha256 = "bb2e18741f084bef90531050a5b14712aca4e78d05de12d3ec6b803a5e9e034c";
        libraryHaskellDepends = [ base suffixtree ];
        testHaskellDepends = [ base bytestring hspec QuickCheck ];
        homepage = "http://github.com/mwotton/string-similarity";
@@ -125462,7 +125848,7 @@ self: {
      mkDerivation {
        pname = "stringable";
        version = "0.1.3";
-       sha256 = "10jsvbiqbmnbipv1566k5mqkpgfyrzbk8m7b18rqjb5m3qg9dbz7";
+       sha256 = "e7af961e1eb52c89330aeb5434d7cfdebd3b712dd39812f68dcbd685e3da5a82";
        libraryHaskellDepends = [ base bytestring system-filepath text ];
        description = "A Stringable type class, in the spirit of Foldable and Traversable";
        license = stdenv.lib.licenses.mit;
@@ -125473,7 +125859,7 @@ self: {
      mkDerivation {
        pname = "stringbuilder";
        version = "0.5.0";
-       sha256 = "1ap95xphqnrhv64c2a137wqslkdmb2jjd9ldb17gs1pw48k8hrl9";
+       sha256 = "8966882622fc06fd4e588da626a558b54daa313f2328c188d9305b0c6f2fe9aa";
        libraryHaskellDepends = [ base ];
        testHaskellDepends = [ base hspec QuickCheck ];
        description = "A writer monad for multi-line string literals";
@@ -125487,7 +125873,7 @@ self: {
      mkDerivation {
        pname = "stringlike";
        version = "0.0.0";
-       sha256 = "0wrhma5g73lnyazbb11z2xhd7fdz93mb1kgbqxjn1prhlc3j7ahy";
+       sha256 = "1eaa2307a330df6065c7ebcdb0ea48bfb9d360173f84b5bef2968ef38aaa3073";
        libraryHaskellDepends = [ base bytestring text ];
        testHaskellDepends = [
          base bytestring QuickCheck quickcheck-instances test-framework
@@ -125507,7 +125893,7 @@ self: {
      mkDerivation {
        pname = "stringprep";
        version = "1.0.0";
-       sha256 = "0ha4cvzdppd514xh9315v3nvrn1q4xd74gifdqpszw98hj2mw0b0";
+       sha256 = "60015e858428f1af2f6e2e3e725a2738d8bcedd8258c043b09a5dddbfe664441";
        libraryHaskellDepends = [ base containers text text-icu ];
        testHaskellDepends = [
          base containers QuickCheck tasty tasty-quickcheck tasty-th text
@@ -125522,7 +125908,7 @@ self: {
      mkDerivation {
        pname = "strings";
        version = "1.1";
-       sha256 = "1xz9v3w5s13yhk7iy9dw6i8s2jc6c0b1ci96dwmcq9a1n3l3ng4v";
+       sha256 = "9b3c3be8b04125cc2a6f26451616608649a15134bc251fcf847e045df8d8e9f7";
        libraryHaskellDepends = [ base bytestring text ];
        homepage = "http://hub.darcs.net/scravy/strings";
        description = "Functions for working with strings, including Text, ByteString, etc";
@@ -125534,7 +125920,7 @@ self: {
      mkDerivation {
        pname = "stringsearch";
        version = "0.3.6.6";
-       sha256 = "0jpy9xjcjdbpi3wk6mg7xwd7wfi2mma70p97v1ij5i8bj9qijpr9";
+       sha256 = "295f1971920bc52263d8275d7054ad223a7e1aefe75533f9887735c9644ffe4a";
        libraryHaskellDepends = [ array base bytestring containers ];
        homepage = "https://bitbucket.org/dafis/stringsearch";
        description = "Fast searching, splitting and replacing of ByteStrings";
@@ -125546,7 +125932,7 @@ self: {
      mkDerivation {
        pname = "stringtable-atom";
        version = "0.0.7";
-       sha256 = "1wp6w12bflrqcwi09y7s1crj72n4pbj8bkpwj2ia5gaqn5x56wjs";
+       sha256 = "5a72537ab158bda2a290fcce85e4bac48a23330bfaf80422673853b744e0e6f2";
        libraryHaskellDepends = [ base binary bytestring containers syb ];
        homepage = "http://github.com/audreyt/stringtable-atom/";
        description = "Memoize Strings as Atoms for fast comparison and sorting, with maps and sets";
@@ -125560,7 +125946,7 @@ self: {
      mkDerivation {
        pname = "stripe";
        version = "0.8.3";
-       sha256 = "1lqz116lvj2444sf2j58dg1nkjwaxm9abrizp1zqkmixbl7ykaqh";
+       sha256 = "10abe90f5d3dd6897fb83fe6a552ed8acb69c36ba848e1342144c84d4d081fd3";
        libraryHaskellDepends = [
          aeson base bytestring http-conduit http-types mtl text time
          unordered-containers utf8-string
@@ -125579,7 +125965,7 @@ self: {
      mkDerivation {
        pname = "stripe-haskell";
        version = "0.1.4.1";
-       sha256 = "066jcinjg430p4mwy1wdc5pkp3y43isv3z70w2lqdsyl2q3cgzx0";
+       sha256 = "a0ffc70616d4eb86a9e0e0fcb1751cc48f3b6f618d07cf2bb96090276d64d218";
        libraryHaskellDepends = [
          aeson base bytestring either HsOpenSSL hspec http-streams
          io-streams mtl random text time transformers unordered-containers
@@ -125601,7 +125987,7 @@ self: {
      mkDerivation {
        pname = "strive";
        version = "2.1.0";
-       sha256 = "08jirx24wnfpknlgkcz605sn9nwb0g5hv75vgrms5gbq65gkg9s2";
+       sha256 = "42a7375f3178bda26b7ebb9c0dcb038bdb647501e6b3f9a89dd7594e44cf5122";
        libraryHaskellDepends = [
          aeson base bytestring data-default gpolyline http-conduit
          http-types template-haskell text time transformers
@@ -125617,7 +126003,7 @@ self: {
      mkDerivation {
        pname = "strptime";
        version = "1.0.10";
-       sha256 = "1f42yf49fqr2fyjfakscmmlnmw3w5rg7wyy6gjyrf0gcgsh0h9fd";
+       sha256 = "cd2508a07eec0197bd7cc67b7e5e2e7cf06a69ad4c4fe5a47722639788f382b8";
        libraryHaskellDepends = [ base bytestring text time ];
        description = "Efficient parsing of LocalTime using a binding to C's strptime, with some extra features (i.e. fractional seconds)";
        license = stdenv.lib.licenses.bsd3;
@@ -125631,7 +126017,7 @@ self: {
      mkDerivation {
        pname = "structural-induction";
        version = "0.3";
-       sha256 = "1wykd33phjmz2aky2dynsxmrmxqpkh4h41majq57lh3dag87cwax";
+       sha256 = "5d7176d0536d407a0a96aa0602099c17f79a6bd7d637e1a712bf4a78c768d3f3";
        libraryHaskellDepends = [
          base containers genifunctors mtl pretty safe
        ];
@@ -125651,7 +126037,7 @@ self: {
      mkDerivation {
        pname = "structured-haskell-mode";
        version = "1.0.20";
-       sha256 = "1pcy83ic95l7k3839py4m10zlx4s4pk4n3bsx3mb7n8rp8zngcv2";
+       sha256 = "62b3673fba19d9b3eae87a0d4be6259a74fa41a8c4df34d0988796c4e2409edd";
        isLibrary = false;
        isExecutable = true;
        executableHaskellDepends = [
@@ -125670,7 +126056,7 @@ self: {
      mkDerivation {
        pname = "structured-mongoDB";
        version = "0.3";
-       sha256 = "0f4s4zi6h53jhcj3f43a2arra02fk1i2almdm6x2mjy1mzhdkjdx";
+       sha256 = "bdc9d9e0afc1cb2abaa9ad522562984e0095b3126a10372483721468e2279a38";
        libraryHaskellDepends = [
          array base bson bytestring compact-string-fix containers
          monad-control mongoDB mtl old-time template-haskell transformers
@@ -125693,7 +126079,7 @@ self: {
      mkDerivation {
        pname = "structures";
        version = "0.2";
-       sha256 = "000misbp9fsnmzhqi7na9b56h45c18ac86j7gfaxv7fgqz82zis8";
+       sha256 = "48c72fd0c7cf9ddd957b471ac4140aac1068ca4aca9e88e1af56bb74978e1500";
        libraryHaskellDepends = [
          base containers contravariant deepseq free ghc ghc-prim hashable
          hybrid-vectors lens monad-st parallel primitive semigroups
@@ -125720,7 +126106,7 @@ self: {
      mkDerivation {
        pname = "stunclient";
        version = "0.1.0.1";
-       sha256 = "0i9sbicwx6d3vsp2fxjr31msd1n5nqh1vxb2hn4in5n8y6d32qlx";
+       sha256 = "9d62319af1c8161b898562f51d20b6c586a66b18597627aedea399ce595c3a45";
        libraryHaskellDepends = [
          base bytestring cereal crypto-api cryptohash cryptohash-cryptoapi
          digest network random stringprep text transformers unbounded-delays
@@ -125742,7 +126128,7 @@ self: {
      mkDerivation {
        pname = "stunts";
        version = "0.1.2";
-       sha256 = "075rbdhlrz88qkwx54jrmb4h4jq8q5wk4ncb858llaswcbsfgl8w";
+       sha256 = "1cd1e7f4625c2b4a51418b593279c1084b02c9aa5992d2f9c408fd4c615bb91c";
        isLibrary = false;
        isExecutable = true;
        executableHaskellDepends = [
@@ -125763,7 +126149,7 @@ self: {
      mkDerivation {
        pname = "stylish-haskell";
        version = "0.5.14.1";
-       sha256 = "055kvwf158m91kx2y3ysiqpjgf15w6r8ryzm4yj0jhy48ymgil5j";
+       sha256 = "b2d0f8aa47c44309a427f5fb8cb2e125b8272f8eda0f2ffa0ca9a2121cdfb314";
        isLibrary = true;
        isExecutable = true;
        libraryHaskellDepends = [
@@ -125789,7 +126175,7 @@ self: {
      mkDerivation {
        pname = "stylized";
        version = "0.1.3";
-       sha256 = "09gacqlq3vlnsnbjjr44pjypw9v3amg8sqsxg0xwl8ricxpww774";
+       sha256 = "e41cce6f673123ca3b785d638d5e5563277ebdbc84642997d596ee812966ea25";
        libraryHaskellDepends = [ ansi-terminal base ];
        jailbreak = true;
        homepage = "http://patch-tag.com/r/lucid/Stylized";
@@ -125807,7 +126193,7 @@ self: {
      mkDerivation {
        pname = "subhask";
        version = "0.1.0.1";
-       sha256 = "17r26mccarr9m7wxvax3bmwz94gcaxg732797js1qa12fdnbsn8m";
+       sha256 = "1559bd6c7322281cb43ce988715e57ec91f4795da3abddf9a92967c55835229f";
        libraryHaskellDepends = [
          approximate base bloomfilter bytes bytestring cassava containers
          deepseq erf gamma ghc-prim hmatrix hyperloglog lens monad-primitive
@@ -125829,7 +126215,7 @@ self: {
      mkDerivation {
        pname = "subnet";
        version = "0.0.1.2";
-       sha256 = "199kslgxlhxv8zx3mj5pxgicjxyff7vzjhw13fwfxcf9pa9289nv";
+       sha256 = "db262492bac9b1eeb81b8143f9f771ce77c9e2ebb7c83afa47bb43da1fd533a5";
        libraryHaskellDepends = [ base split ];
        homepage = "https://github.com/gcganley/subnet";
        description = "subnetting calculator";
@@ -125841,7 +126227,7 @@ self: {
      mkDerivation {
        pname = "subtitleParser";
        version = "0.5";
-       sha256 = "1kkr6zbnv777gnv2lwq3pyxq3vv5r24f4avwv5g4dds3y8d8mv3q";
+       sha256 = "78ec8a1af243b7465ed97c2be288c865ef81bbbf03732ab67de79c6dd73779ce";
        libraryHaskellDepends = [ attoparsec base containers text ];
        homepage = "https://patch-tag.com/r/rubenAst/subtitleParser/home";
        description = "A parser for .srt and .sub files";
@@ -125853,7 +126239,7 @@ self: {
      mkDerivation {
        pname = "subtitles";
        version = "0.0.1";
-       sha256 = "0pvcwwz6i4mpmir0s2xnjy27j2cnbi4l9lxhlmxcsw4yz4spdgcl";
+       sha256 = "94bd7635f99e70cd7aa5b0d344495c9609798497b60b0d72acb792683ee76c5f";
        isLibrary = false;
        isExecutable = true;
        executableHaskellDepends = [ base split ];
@@ -125866,7 +126252,7 @@ self: {
      mkDerivation {
        pname = "suffixarray";
        version = "0.0.3.1";
-       sha256 = "0wa2yfz5y90dq9mf3xyl7126rvjldnaa32gmg253bfv6hjvk4hhp";
+       sha256 = "174232b78466bb358a78f589a1946d54ee6c4438d4f7e16ac20d245fbef34271";
        isLibrary = true;
        isExecutable = true;
        libraryHaskellDepends = [ base vector ];
@@ -125882,7 +126268,7 @@ self: {
      mkDerivation {
        pname = "suffixtree";
        version = "0.2.2.1";
-       sha256 = "1ddk2hp27al9jzcgkrhv7v1i7knci4l22flkgb2r94h96z5nhfq6";
+       sha256 = "063b68cb37099294c57a933a212889ccce13c33e1be6f9d89789aa232e14b3b5";
        libraryHaskellDepends = [ base bytestring containers ];
        homepage = "https://github.com/bos/suffixtree";
        description = "Efficient, lazy suffix tree implementation";
@@ -125894,7 +126280,7 @@ self: {
      mkDerivation {
        pname = "sugarhaskell";
        version = "0.1";
-       sha256 = "1hlzckm5c1dih79nmwy2gk4fjnn4kxzp3pk0adfyhldapkq6wpmq";
+       sha256 = "b85e6ef0bcaa51e85d5360de717f9fc45ae9c87cc2f36ad381b10556ea649fc2";
        isLibrary = false;
        isExecutable = true;
        executableHaskellDepends = [ base process ];
@@ -125908,7 +126294,7 @@ self: {
      mkDerivation {
        pname = "suitable";
        version = "0.1.1";
-       sha256 = "1pvw7zgvfr0z2gjy224gd92ayh20j3v97rdlqmq6k6g4yabdpgci";
+       sha256 = "91bddb96f2e4996970c5b4e593f6904040af446a8f08e1e5131f64b7df3f7cdf";
        libraryHaskellDepends = [ base containers ];
        description = "Abstract over the constraints on the parameters to type constructors";
        license = stdenv.lib.licenses.bsd3;
@@ -125920,7 +126306,7 @@ self: {
      mkDerivation {
        pname = "sundown";
        version = "0.6";
-       sha256 = "09xh3pbyarflfjk17bn2isgpmsq49d6gmq7z918kf4c32fc7x6yb";
+       sha256 = "cb9b7e98138311375148ffe0fa4c4b04eb7a9f8ec2ae13a674d465e5d71db027";
        libraryHaskellDepends = [ base bytestring text ];
        homepage = "https://github.com/bitonic/sundown";
        description = "Bindings to the sundown markdown library";
@@ -125934,7 +126320,7 @@ self: {
      mkDerivation {
        pname = "sunlight";
        version = "0.6.0.0";
-       sha256 = "1q90fxv40jz5ngh6xi1n6xjx6hh1as223wjjhchk6k0y0frdg55x";
+       sha256 = "bd94d7b2031e4c33218352f22184560142d3653736c46ee0b3e54b40767720e1";
        libraryHaskellDepends = [
          base bytestring Cabal directory old-locale process random time
          tuple
@@ -125954,7 +126340,7 @@ self: {
      mkDerivation {
        pname = "sunroof-compiler";
        version = "0.2";
-       sha256 = "1r03aw55s4vnpbfk0n39li0aai3wvm209pqdimfkkk3kkan648cz";
+       sha256 = "9f2162ac9a73cc395d8d0ddf0444dd7c44a540a4695830ddba76135d0a5703e4";
        libraryHaskellDepends = [
          base Boolean containers data-default data-reify mtl operational
          semigroups tagged template-haskell transformers vector-space
@@ -125974,7 +126360,7 @@ self: {
      mkDerivation {
        pname = "sunroof-examples";
        version = "0.2.2";
-       sha256 = "0bcxai3gq1akbcxqkkj0n52a43zqcnw865bnngy9b4z26b43kj5k";
+       sha256 = "b3c839c832e29395fcb3761583b865f80fa244b140ce893b5b5305fc46549d2d";
        isLibrary = false;
        isExecutable = true;
        executableHaskellDepends = [
@@ -125999,7 +126385,7 @@ self: {
      mkDerivation {
        pname = "sunroof-server";
        version = "0.2.1";
-       sha256 = "11acyb846wga6g6zcvlaffh299qn0l8jic8syg76cchm3l3348d5";
+       sha256 = "a52132061d153266cef31ab128110516a724a0738a6ef6cd33ea7143d0f24c85";
        libraryHaskellDepends = [
          aeson base containers data-default filepath kansas-comet scientific
          scotty semigroups stm sunroof-compiler tagged text time
@@ -126020,7 +126406,7 @@ self: {
      mkDerivation {
        pname = "supercollider-ht";
        version = "0.3";
-       sha256 = "1v8nqcfdn2dasiv24lny73bc0xz2d26wvvybhxw6s7dz4bkb9kiw";
+       sha256 = "3cceb4e622bf1d6d7887cbefcd8d68e277c0d638de522276d4aa09db1cc316ed";
        isLibrary = true;
        isExecutable = true;
        libraryHaskellDepends = [
@@ -126040,7 +126426,7 @@ self: {
      mkDerivation {
        pname = "supercollider-midi";
        version = "0.2.1";
-       sha256 = "1m3h6d49bjwhldbf4khyp6p8k4vr05m5392nk3d33x3d9pfhl20k";
+       sha256 = "13080add4d6df431da9856a4516a01799389aeb91e4ee256a390cb95483370d4";
        isLibrary = false;
        isExecutable = true;
        executableHaskellDepends = [
@@ -126061,7 +126447,7 @@ self: {
      mkDerivation {
        pname = "superdoc";
        version = "0.1.2.1";
-       sha256 = "1fjy25fm7hz495dnxl9jw0asfhl23ykyax1w4q4yvkpmx8ars9wd";
+       sha256 = "8d279d15eaf5ceed09263c74e5a71f8242a715e032d16e5b49e4c3535d115eba";
        isLibrary = true;
        isExecutable = true;
        libraryHaskellDepends = [
@@ -126084,7 +126470,7 @@ self: {
      mkDerivation {
        pname = "supero";
        version = "3.0";
-       sha256 = "0jnip7wahy4z1jiablqzvmbk40as1ala65m7da7gsp0xvf2q7hwf";
+       sha256 = "8ec38385db1d5cfd8e6aa716a3a80a5a013257dd1fd3a5a20c9f78a8f8b9d14a";
        isLibrary = false;
        isExecutable = true;
        executableHaskellDepends = [
@@ -126103,7 +126489,7 @@ self: {
      mkDerivation {
        pname = "supervisor";
        version = "0.1.1.0";
-       sha256 = "1gdgqm89ig236hkrz8sjgy3shqnl961401qgavs4qpqw7r2xk8vx";
+       sha256 = "7da3d9453e1c5f4cf4560f07408249d462a8877f52a39f273443bc9850c5afbd";
        libraryHaskellDepends = [
          base containers exceptions monadloc mtl
        ];
@@ -126118,7 +126504,7 @@ self: {
      mkDerivation {
        pname = "suspend";
        version = "0.2.0.0";
-       sha256 = "0wphk3dabba6rgd9lkxbsmq5vivvyy6b4jfxfndqb53yhdj5nkrg";
+       sha256 = "2f4f5b64837e94859b75dd49b28cf77bc75d70d5ab4f9adacb46ada5da98f072";
        libraryHaskellDepends = [ base lifted-base transformers-base ];
        description = "Simple package that allows for long thread suspensions";
        license = stdenv.lib.licenses.bsd3;
@@ -126132,7 +126518,7 @@ self: {
      mkDerivation {
        pname = "svg-tree";
        version = "0.3.1";
-       sha256 = "1fnj7d2nw4p9m46wp64gz99ssggxd0rz4737732hpk9vr5xq78lc";
+       sha256 = "8ca2837bc93bcd0bc538671cf23368fd3dad53fa8f98cb0da9e9126e453bd2ba";
        libraryHaskellDepends = [
          attoparsec base bytestring containers JuicyPixels lens linear mtl
          scientific text transformers vector xml
@@ -126148,7 +126534,7 @@ self: {
      mkDerivation {
        pname = "svg2q";
        version = "0.3.2";
-       sha256 = "0bkhh1klwp3lgsx0s62bpdhsw9sa1cdw8gjijj9npnygznbi7jhj";
+       sha256 = "12ca1397fdcfdb6b9394513ec41b0b4a27ae61bb4b180dba7e745c4e6780702e";
        isLibrary = false;
        isExecutable = true;
        executableHaskellDepends = [
@@ -126168,7 +126554,7 @@ self: {
      mkDerivation {
        pname = "svgcairo";
        version = "0.13.0.3";
-       sha256 = "0jbcz46n5324vf9i05y8zdjp4ayid2frggsadm5nr8h9mnd4vncz";
+       sha256 = "9fd94d9aad09a26c4b6d4abf979d68d12b7265fbc8171093db448c620df96c49";
        libraryHaskellDepends = [ base cairo glib mtl text ];
        libraryPkgconfigDepends = [ librsvg ];
        libraryToolDepends = [ gtk2hs-buildtools ];
@@ -126182,7 +126568,7 @@ self: {
      mkDerivation {
        pname = "svgutils";
        version = "0.1";
-       sha256 = "131mic1c09adcphry7153bviiib59avxrd7dgwny0vdmw23cgfs1";
+       sha256 = "41bbc786e0b56de02d7fedb4dcb74a65c518f71a251c9fe1654d25c0028b358c";
        isLibrary = true;
        isExecutable = true;
        libraryHaskellDepends = [ base xml ];
@@ -126198,7 +126584,7 @@ self: {
      mkDerivation {
        pname = "svm";
        version = "1.0.0.1";
-       sha256 = "19fr1lzp8j0hmqqy1hyx85gmkgxc2hy8cz5zv6jlvni0qqibiksz";
+       sha256 = "5fcfb822c620da4da5d9bf7c863c14acbf595f41ddc3e031ae1048743f0dd9a5";
        libraryHaskellDepends = [ array base ];
        homepage = "http://github.com/andrewdougherty/svm";
        description = "A support vector machine written in Haskell";
@@ -126209,10 +126595,9 @@ self: {
     ({ mkDerivation, attoparsec, base, bytestring, containers }:
      mkDerivation {
        pname = "svm-light-utils";
-       version = "0.1.2";
-       sha256 = "1p2rnx045zw9qqd88m5ldx5p3xmbsi6rkdh1bfk6ab1a0krjiifa";
+       version = "0.1.3";
+       sha256 = "fa5770c144c516485e409cc164cbc1e4f7dc5f1a32f41dd95356964c663e2e23";
        libraryHaskellDepends = [ attoparsec base bytestring containers ];
-       jailbreak = true;
        homepage = "http://github.com/bgamari/svm-light-utils";
        description = "Parsers and formatters for the SVMlight input file format";
        license = stdenv.lib.licenses.bsd3;
@@ -126225,7 +126610,7 @@ self: {
      mkDerivation {
        pname = "svm-simple";
        version = "0.2.7.1";
-       sha256 = "07s9mly01ar6c3p4fdl7wsi5j4bziagjjlbssr7x6s3ab5r8k9vd";
+       sha256 = "6da78972596a68d34fd67a51299f8a7f1159a2e6873647ee6026ab003cad491f";
        libraryHaskellDepends = [
          base binary bindings-svm bytestring containers deepseq directory
          monad-par mwc-random vector
@@ -126244,7 +126629,7 @@ self: {
      mkDerivation {
        pname = "svndump";
        version = "0.4.5";
-       sha256 = "0m6agn9riamsadf13w1g6i0nx59xl812112xdkqh0zl34rf5hkwp";
+       sha256 = "974f585c26837e00f16c5d842002a23d956e41342ff0115c53baaa98937dca54";
        libraryHaskellDepends = [
          attoparsec base bytestring containers filepath old-locale text time
        ];
@@ -126264,7 +126649,7 @@ self: {
      mkDerivation {
        pname = "swagger";
        version = "0.2.2";
-       sha256 = "1hpc569n34kr1nkrwlx76pc0yp9icr8j5cxliwjqffnh7x2czzqr";
+       sha256 = "19ffcf443fd03a87258fb4b3225166315d0fd835a7539ea70d7992619329ecc2";
        libraryHaskellDepends = [
          aeson base bytestring text time transformers
        ];
@@ -126280,7 +126665,7 @@ self: {
      mkDerivation {
        pname = "swapper";
        version = "0.1";
-       sha256 = "0a9g6cv7pvwna11cz1xc274rs0dgyhb84hqqdg5zyga7kkx0i06l";
+       sha256 = "d48008fa9c473dffcb6b18438216f4af019dc911ac87cf425096ef7b36332f29";
        libraryHaskellDepends = [
          base binary bytestring deepseq happstack-data happstack-state
          parallel
@@ -126300,7 +126685,7 @@ self: {
      mkDerivation {
        pname = "swearjure";
        version = "1.0.0";
-       sha256 = "0g3xq3abwkv6rs7kvv6niwdhx50c90ys1zrrzspx2g47c9fbs2iq";
+       sha256 = "380abd5c62873cd1affe39ffa03d480c940e1b8fd6ec3d8fce664fbed4c07d3c";
        isLibrary = false;
        isExecutable = true;
        executableHaskellDepends = [
@@ -126319,7 +126704,7 @@ self: {
      mkDerivation {
        pname = "swf";
        version = "1.0.1";
-       sha256 = "1jx5941kb97w4zpgz7m1r2x2lxllmi1i9a9nmwflinyj74xxg1rl";
+       sha256 = "3487d73b39d2db481daf36a91443ac94762abac8a19effee27fca4350349a5cb";
        libraryHaskellDepends = [ base mtl pretty ];
        homepage = "http://www.n-heptane.com/nhlab";
        description = "A library for creating Shockwave Flash (SWF) files";
@@ -126334,7 +126719,7 @@ self: {
      mkDerivation {
        pname = "swift-lda";
        version = "0.7.0.0";
-       sha256 = "0cjvj7v8kjabv6a146hwgyk8k6b4z7gz4yrhz3d0nxa86ilvjl9q";
+       sha256 = "3851b9693448750bdaf8307bf2dff9649989a67f1c1a1294d94bc989f6915b32";
        libraryHaskellDepends = [
          array base containers ghc-prim mwc-random primitive vector
        ];
@@ -126352,7 +126737,7 @@ self: {
      mkDerivation {
        pname = "swish";
        version = "0.9.1.3";
-       sha256 = "07h5677d1liap81z3gvjab5yjib2vbmzvhfzqqmkjg7grk1dblld";
+       sha256 = "8dd2d5c2ccef3c392bc6dfc1fdebda6245e9cb5272bff103ba2ad2d0ce31051e";
        isLibrary = true;
        isExecutable = true;
        libraryHaskellDepends = [
@@ -126378,7 +126763,7 @@ self: {
      mkDerivation {
        pname = "sws";
        version = "0.3.1.1";
-       sha256 = "0anl5h5lwc6b7whkg83ziyizq5w2mlcpv0akcl0ahgjl4mxnmiwd";
+       sha256 = "8dc76a7b25543ea8006553817d19ad8217fca38f7fa037213fcb304e0b2cd42a";
        isLibrary = false;
        isExecutable = true;
        executableHaskellDepends = [
@@ -126398,7 +126783,7 @@ self: {
      mkDerivation {
        pname = "syb";
        version = "0.5.1";
-       sha256 = "0iiqz5mamk1nsij99rypms7dhx5flm2n02k1x6miqgnhg075zc41";
+       sha256 = "81b05f0e78d03e1cabe9610a6045a5ae74d88eaed7e79464d436ccaa6af93846";
        libraryHaskellDepends = [ base ];
        testHaskellDepends = [ base containers HUnit mtl ];
        homepage = "http://www.cs.uu.nl/wiki/GenericProgramming/SYB";
@@ -126411,7 +126796,7 @@ self: {
      mkDerivation {
        pname = "syb-extras";
        version = "0.3";
-       sha256 = "1l1637kf1f7n5nvcp2hv516qah7baykh5w2wmil2b909k75iq2x9";
+       sha256 = "a90b1ccb9909a42568ac5cf002a757eb40854d281b8acbb62df6b8e0e61926d0";
        libraryHaskellDepends = [ base eq prelude-extras ];
        homepage = "http://github.com/ekmett/syb-extras/";
        description = "Higher order versions of the Scrap Your Boilerplate classes";
@@ -126426,7 +126811,7 @@ self: {
      mkDerivation {
        pname = "syb-with-class";
        version = "0.6.1.6";
-       sha256 = "1c61hig293lxyr2kdri3rp6wkns921fiwwmml9zhrhrrryfr0p2n";
+       sha256 = "565c909dcf39c30c7fa2b5721e5d1049dbc9cdcd23e63645f69d8e245e84c1b0";
        revision = "1";
        editedCabalFile = "e894d322dfc9c36c33058bfcbecbe6d36e620556a9713108b008120f7981cd7c";
        libraryHaskellDepends = [
@@ -126441,7 +126826,7 @@ self: {
      mkDerivation {
        pname = "syb-with-class-instances-text";
        version = "0.0.1";
-       sha256 = "0vnpqk89nxs0anx62mzasl9wrcscw18vwc284y067ryb086aj2hf";
+       sha256 = "0e0aa90c02cbe76380274830be51e04cb3cc13d5ea5761ba5540779bd0c4d76e";
        libraryHaskellDepends = [ base syb-with-class text ];
        description = "Scrap Your Boilerplate With Class Text instance";
        license = stdenv.lib.licenses.bsd3;
@@ -126456,7 +126841,7 @@ self: {
      mkDerivation {
        pname = "sylvia";
        version = "0.2.2";
-       sha256 = "1yjvjfkg623kpnzpkknljfgcizyf3jsvkncz49yjsy9j2iklqg2k";
+       sha256 = "533c4c671432792d7d229fd9b9b51cceffc89e93d4ce79bfbd7308f3a6935bfa";
        isLibrary = false;
        isExecutable = true;
        executableHaskellDepends = [
@@ -126480,7 +126865,7 @@ self: {
      mkDerivation {
        pname = "sym";
        version = "0.11.1";
-       sha256 = "140wy1l2y71v70fhl1z4sa5dvasz5f98w2knayhd7lvw15cglmbj";
+       sha256 = "7255fa58097cd3d3a057760a8e922b5fabdd8ad2e4070a1d383b1c2f68f01c90";
        libraryHaskellDepends = [
          array base containers hashable QuickCheck
        ];
@@ -126494,7 +126879,7 @@ self: {
      mkDerivation {
        pname = "sym-plot";
        version = "0.2.0";
-       sha256 = "0186i6c3dyvs5pa4fh0b284wgpm10pgwax9prahirnq8whph94p2";
+       sha256 = "e292042fe408db1ca1ca3775c5df05a1dec709120b4047d42d7afb3698890605";
        libraryHaskellDepends = [ base diagrams-cairo diagrams-lib sym ];
        jailbreak = true;
        homepage = "http://github.com/akc/sym-plot";
@@ -126508,7 +126893,7 @@ self: {
      mkDerivation {
        pname = "symbol";
        version = "0.2.4";
-       sha256 = "0cc8kdm68pirb0s7n46v0yvw5b718qf7qip40jkg5q3c3xsafx6h";
+       sha256 = "d074a7741f6ce0f2a604e4467c1c46e1acc2b707db107b3458395e646a9b8831";
        libraryHaskellDepends = [ base containers deepseq ];
        homepage = "http://www.cs.drexel.edu/~mainland/";
        description = "A 'Symbol' type for fast symbol comparison";
@@ -126520,7 +126905,7 @@ self: {
      mkDerivation {
        pname = "sync";
        version = "0.1";
-       sha256 = "10c2divizmjij5w7x2ky6dzhq6y6wr6qq1pwl7wlhgv663y9yalk";
+       sha256 = "932a9ffc30663f48f9a1fc068c4de6c61b0c7f337e8a7e789151d61f776c8281";
        libraryHaskellDepends = [ base stm ];
        description = "A fast implementation of synchronous channels with a CML-like API";
        license = stdenv.lib.licenses.bsd3;
@@ -126529,25 +126914,31 @@ self: {
 
   "sync-mht" = callPackage
     ({ mkDerivation, array, base, base16-bytestring, byteable
-     , bytestring, Cabal, cereal, containers, cryptohash, directory
-     , exceptions, filepath, io-streams, mtl, process, random
-     , regex-compat, temporary, text, time, transformers, unix, zlib
+     , bytestring, cereal, containers, cryptohash, directory, exceptions
+     , filepath, HUnit, io-streams, mtl, process, random, regex-compat
+     , temporary, text, time, transformers, unix, zlib
      }:
      mkDerivation {
        pname = "sync-mht";
-       version = "0.3.5.0";
-       sha256 = "1mkrap2qhfhnisz28vb4hjl5fmfi8r48n1igvv4c0qf9nclhfbhd";
-       isLibrary = false;
+       version = "0.3.6.0";
+       sha256 = "a6bd7b06e599844e7e93c5fff857b3b0af4975228f1b75fe25407c051f8ea5b9";
+       isLibrary = true;
        isExecutable = true;
+       libraryHaskellDepends = [
+         array base base16-bytestring byteable bytestring cereal containers
+         cryptohash directory exceptions filepath HUnit io-streams mtl
+         process random regex-compat temporary text time transformers unix
+         zlib
+       ];
        executableHaskellDepends = [
-         array base base16-bytestring byteable bytestring Cabal cereal
-         containers cryptohash directory exceptions filepath io-streams mtl
+         array base base16-bytestring byteable bytestring cereal containers
+         cryptohash directory exceptions filepath HUnit io-streams mtl
          process random regex-compat temporary text time transformers unix
          zlib
        ];
        testHaskellDepends = [
-         array base base16-bytestring byteable bytestring Cabal cereal
-         containers cryptohash directory exceptions filepath io-streams mtl
+         array base base16-bytestring byteable bytestring cereal containers
+         cryptohash directory exceptions filepath HUnit io-streams mtl
          process random regex-compat temporary text time transformers unix
          zlib
        ];
@@ -126563,7 +126954,7 @@ self: {
      mkDerivation {
        pname = "synchronous-channels";
        version = "0.2";
-       sha256 = "0xzpjq3h3mqdi553v7p6xm3i74nvbhz5igjlhfh6snlmr7p1cdvb";
+       sha256 = "6b3716eec9955a6da08354be583e5cdb921347ede69e3d4a890dd7010796f777";
        libraryHaskellDepends = [ base ];
        description = "Synchronous communication channels";
        license = stdenv.lib.licenses.bsd3;
@@ -126580,7 +126971,7 @@ self: {
      mkDerivation {
        pname = "syncthing-hs";
        version = "0.3.0.0";
-       sha256 = "0mancdrf3miicjcsrszxgv5bnka9nvbcsynyw4ljn19c2mk2628r";
+       sha256 = "19092366152c052b29e1de7acdd6b6494dbbca7efdebac996431d6e172635655";
        libraryHaskellDepends = [
          aeson base bytestring connection containers either exceptions
          http-client http-client-tls lens regex-posix text time
@@ -126604,7 +126995,7 @@ self: {
      mkDerivation {
        pname = "synt";
        version = "0.1.2";
-       sha256 = "12d9ilb81vcm24s8whk2cbq1nxlrzdsr7049962q6b0vkrk64v5v";
+       sha256 = "bb6c62669e1b2c83854989809375fb99761bf06262428e341195ed80168da989";
        isLibrary = true;
        isExecutable = true;
        libraryHaskellDepends = [
@@ -126632,7 +127023,7 @@ self: {
      mkDerivation {
        pname = "syntactic";
        version = "2.1";
-       sha256 = "1r2b11xw235qsv6z6qqssrmgd1wcbr28vmlqs7vlb4h0yhpkd1i3";
+       sha256 = "2386362ff4009245f7d198d68d445e8c87f66ad61a63f3cdd6b80cc17b084be4";
        libraryHaskellDepends = [
          base constraints containers data-hash deepseq mtl safe tagged
          template-haskell tree-view
@@ -126651,7 +127042,7 @@ self: {
      mkDerivation {
        pname = "syntactical";
        version = "0.1";
-       sha256 = "1sqnmarmdm4mha28h8gbp3jddlig84v7zqn53a29047w3877g3gw";
+       sha256 = "fc8d770e1afc1090841ac5e27f36412fd2d6e4b8eb2188848295d456b3aa16eb";
        libraryHaskellDepends = [ base ];
        description = "Distfix expression parsing library";
        license = stdenv.lib.licenses.bsd3;
@@ -126664,7 +127055,7 @@ self: {
      mkDerivation {
        pname = "syntax";
        version = "1.0.0.0";
-       sha256 = "1dhbzbf1zlpfjhnacqfhzvjznwlzv39c12a3y8ivqhplnkmqsm7x";
+       sha256 = "fd548debb4f442bc23f24389c0d2d89f72fbe5fed061a62c94eed21fdcfa0bb6";
        revision = "1";
        editedCabalFile = "7f3d7f3a8c8aedb78145f4d8a992815cdb644d839a5431b23e5fad0a62d7dd5c";
        libraryHaskellDepends = [
@@ -126682,7 +127073,7 @@ self: {
      mkDerivation {
        pname = "syntax-attoparsec";
        version = "1.0.0.0";
-       sha256 = "1ygikzc7s967bh9yz19r9zd2r1jychlf04cylbigaakrxnnkj4hi";
+       sha256 = "111239aded792af5e2a29e11e028645e862cda4f3985ef135cc7247dd89ff1f9";
        libraryHaskellDepends = [
          attoparsec base bytestring scientific semi-iso syntax text vector
        ];
@@ -126698,7 +127089,7 @@ self: {
      mkDerivation {
        pname = "syntax-example";
        version = "1.0.0.0";
-       sha256 = "1szfapnlcgr19cipm4q68w7p52sw2hapks63vcnn9qfjnav17ljr";
+       sha256 = "59d213b6b2d2e1642ddbc3e87915145c8b720f4706937a234b213f46ed55eeeb";
        isLibrary = false;
        isExecutable = true;
        executableHaskellDepends = [
@@ -126717,7 +127108,7 @@ self: {
      mkDerivation {
        pname = "syntax-example-json";
        version = "1.0.0.0";
-       sha256 = "1bgv2y97rk5jr2gkl4d1pm19v3pl1gziz4sxnlv9w539dna0dwim";
+       sha256 = "35f206946d69149e36b55d931fff0bf48e9d42bda1113a9fc8b2cc7c9217fbad";
        isLibrary = false;
        isExecutable = true;
        executableHaskellDepends = [
@@ -126735,7 +127126,7 @@ self: {
      mkDerivation {
        pname = "syntax-pretty";
        version = "0.2.0.0";
-       sha256 = "1dyv0d998lbjndiw05hz9rmiazzz3rvw8hqdx5npb6yjmq237zmf";
+       sha256 = "aefe3304aed29b756de90d43c4771eff7f156b4e1f16c063b37251945203dbb7";
        libraryHaskellDepends = [
          base pretty scientific semi-iso syntax text
        ];
@@ -126751,7 +127142,7 @@ self: {
      mkDerivation {
        pname = "syntax-printer";
        version = "1.0.0.0";
-       sha256 = "051gkxj9qgrmjp8jl48nb7487y2hd6ymrzjl62k2faa0cfz6sbqz";
+       sha256 = "1f2f6dbe63402927a63054fe5cbd6950f883c85916112ad195353f9c649f2f14";
        libraryHaskellDepends = [
          base bifunctors bytestring scientific semi-iso semigroupoids syntax
          text vector
@@ -126769,7 +127160,7 @@ self: {
      mkDerivation {
        pname = "syntax-trees";
        version = "0.1.2";
-       sha256 = "19lgaiql3d8v6w8dl0a7adrfw63ch5376dz6y4jzndrwzi43p9sb";
+       sha256 = "4ba73b48fc3c37fb25f1e6377346816c18ee72534701da10371bb54171548fa6";
        libraryHaskellDepends = [
          base haskell-src-exts hint mtl template-haskell uniplate
        ];
@@ -126785,7 +127176,7 @@ self: {
      mkDerivation {
        pname = "syntax-trees-fork-bairyn";
        version = "0.1.2.5";
-       sha256 = "1n4k8m4zl5phxyrh6s46ijxcba9iljyh7zvhrrzzaw3d00nfvqg6";
+       sha256 = "e6e1ed2c006d70f57fce70ff03bda431a9c5ba8c866803b3eff016fa494593d8";
        libraryHaskellDepends = [
          base haskell-src-exts hint mtl template-haskell uniplate
        ];
@@ -126804,7 +127195,7 @@ self: {
      mkDerivation {
        pname = "synthesizer";
        version = "0.2.0.1";
-       sha256 = "1n5r7061x8212a8wfv0j9g28l79lxgbymr1f0m1qgzkhqf80gz3d";
+       sha256 = "6dfc0790c370fe8743052ee4ead7eb341d8ac44b126cc7911241a01e0c38b9d8";
        isLibrary = true;
        isExecutable = true;
        libraryHaskellDepends = [
@@ -126829,7 +127220,7 @@ self: {
      mkDerivation {
        pname = "synthesizer-alsa";
        version = "0.5.0.2";
-       sha256 = "0k4hnhldrqjxz391p45rc125d2v8pbx23qxsvfs4hwra886imny3";
+       sha256 = "c3db1a0d422a7348b4dbbae321faba688b564460b9901bd2f85de2dc28b4904c";
        isLibrary = true;
        isExecutable = true;
        libraryHaskellDepends = [
@@ -126855,7 +127246,7 @@ self: {
      mkDerivation {
        pname = "synthesizer-core";
        version = "0.7.1";
-       sha256 = "0h3dj4j9ha1db2lw3vd7zai05ivm9lfydaynq2bxqhz77s07skzf";
+       sha256 = "ee4f7d803ee743dc97c0d6abe61d4d75c702a2faa7edc1a9582d289824916d40";
        libraryHaskellDepends = [
          array base binary bytestring containers deepseq event-list
          explicit-exception filepath non-empty non-negative numeric-prelude
@@ -126881,7 +127272,7 @@ self: {
      mkDerivation {
        pname = "synthesizer-dimensional";
        version = "0.7.0.2";
-       sha256 = "1y3jnlzpgs0n42vf5ami98c3nc1kz645spxirdaqn60f3ig4bvzb";
+       sha256 = "ebef455e1c0e188b55cbb15f5d88f933303b184ab1aae2b62016e8773fb572f8";
        isLibrary = true;
        isExecutable = true;
        libraryHaskellDepends = [
@@ -126902,7 +127293,7 @@ self: {
      mkDerivation {
        pname = "synthesizer-inference";
        version = "0.2";
-       sha256 = "07jhdd73vrhlvx6aq6rdd78qk8vfy2jcc9vrdrf8y6ikq6ir99rb";
+       sha256 = "2ba794a3c1331a8f5c6e7927c6a4f06ea389d1692d1bac4cdf14e63d4e6b501e";
        isLibrary = true;
        isExecutable = true;
        libraryHaskellDepends = [
@@ -126926,7 +127317,7 @@ self: {
      mkDerivation {
        pname = "synthesizer-llvm";
        version = "0.7.0.1";
-       sha256 = "04mzsdwf8n31nqjlv7ryylx64mvhcfkx6r8jq1yijvnb1pih4vk2";
+       sha256 = "626e02e30dcb6e197dc01265d3a7637057623af53e9f4d25b66158e478d3bf12";
        isLibrary = true;
        isExecutable = true;
        libraryHaskellDepends = [
@@ -126955,7 +127346,7 @@ self: {
      mkDerivation {
        pname = "synthesizer-midi";
        version = "0.6.0.2";
-       sha256 = "0xsfjgh82nxpwrhpllhjxxzaj42cxb5cbbpgwd1b1bsv67441h2x";
+       sha256 = "5dc040c8315bafb042e3efaec5caea4c10a97eef12527a61e6b75b81e0934e77";
        isLibrary = true;
        isExecutable = true;
        libraryHaskellDepends = [
@@ -126976,7 +127367,7 @@ self: {
      mkDerivation {
        pname = "sys-auth-smbclient";
        version = "2.0.0.0";
-       sha256 = "00j1ss8xsnd8m0v0p9r9mampbczclzanzcli2qrxcl4j9vkp2mb7";
+       sha256 = "675571e74e9250d6331691b26fd5a7ecb375abaa29a70b36a8a859dd91d64102";
        libraryHaskellDepends = [ base process text ];
        testHaskellDepends = [ base doctest ];
        homepage = "https://github.com/kkazuo/sys-auth-smbclient";
@@ -126992,7 +127383,7 @@ self: {
      mkDerivation {
        pname = "sys-process";
        version = "0.1.6";
-       sha256 = "04f6mbkc61qx8wjf95kwxhrqhv2qprl2wa73rkgsq8nc18gicf3q";
+       sha256 = "7838161f0acc22acdfcce3282e68be586c8833ec7c96e424471d07c3e6aac611";
        libraryHaskellDepends = [
          base bifunctors directory filepath lens mtl notzero process
          semigroupoids semigroups transformers
@@ -127010,7 +127401,7 @@ self: {
      mkDerivation {
        pname = "system-argv0";
        version = "0.1.1";
-       sha256 = "1ijfry2r3cypp3zmws6dczk21m4n86fkxjld7yl19gjp46fxllbd";
+       sha256 = "6d51da9d2157be14a83f8dca3e9d4196d420e667cd685effb8d7b39185cf4ec6";
        libraryHaskellDepends = [ base bytestring system-filepath text ];
        homepage = "https://john-millikin.com/software/haskell-filesystem/";
        description = "Get argv[0] as a FilePath";
@@ -127024,7 +127415,7 @@ self: {
      mkDerivation {
        pname = "system-canonicalpath";
        version = "0.3.2.0";
-       sha256 = "031m5j7xglxdgp3rkgf2v37jya1a3hhjp3mxbfyyjl27wv7pzhjy";
+       sha256 = "5ec27fcfe64750e9bd5bbd8e2b211c2a282fcfd8c2bd99c77dadd3d78f2c350c";
        libraryHaskellDepends = [
          base basic-prelude directory system-filepath text
        ];
@@ -127042,7 +127433,7 @@ self: {
      mkDerivation {
        pname = "system-command";
        version = "0.0.10";
-       sha256 = "11lfr6xm5xpvq4244pc7a0psy2m1krz0b1jd9pdw6kzn5ammi1b2";
+       sha256 = "628558ab2af64fc3db4d4d86057e9ea10aaf2f50875d4204c1fbf652bbc98e86";
        libraryHaskellDepends = [
          base directory filepath process transformers
        ];
@@ -127061,7 +127452,7 @@ self: {
      mkDerivation {
        pname = "system-fileio";
        version = "0.3.16.3";
-       sha256 = "1484hcl27s2qcby8ws5djj11q9bz68bspcifz9h5gii2ndy70x9i";
+       sha256 = "3175707cb322c65760fa2eb2ab17327f251c8294ad688efc6258e82328830491";
        libraryHaskellDepends = [
          base bytestring system-filepath text time unix
        ];
@@ -127081,7 +127472,7 @@ self: {
      mkDerivation {
        pname = "system-filepath";
        version = "0.4.13.4";
-       sha256 = "1yy5zsmmimhg6iaw9fmpwrxvxrgi5s6bfyqfihdsnx4bjvn7sp9l";
+       sha256 = "345d7dec968b74ab1b8c0e7bb78c2ef1e5be7be6b7bac455340fd658abfec5fb";
        libraryHaskellDepends = [ base bytestring deepseq text ];
        testHaskellDepends = [
          base bytestring chell chell-quickcheck QuickCheck text
@@ -127096,7 +127487,7 @@ self: {
      mkDerivation {
        pname = "system-gpio";
        version = "0.0.2";
-       sha256 = "1i718k96xvsfl9rh1x4n5ra88838wd6rzmj3p70bfkxxrsvv1zi4";
+       sha256 = "24feb0b7cebd4fb7c0b943d69f4de3682084542e96f40073a24eef6ed244e1c4";
        libraryHaskellDepends = [ array base ghc-prim ];
        homepage = "https://github.com/luzhuomi/system-gpio/";
        description = "GPIO wrapper libary for Raspberry Pi";
@@ -127108,7 +127499,7 @@ self: {
      mkDerivation {
        pname = "system-inotify";
        version = "0.1";
-       sha256 = "0ndw4vcvvf7p6nb5vn91mhbj4w9lmgm4cl0jzsks4mxs625bv4lg";
+       sha256 = "8f92bd8a30ba57a2a7fe125046eaab34712217ac21d95d9635f7b8bdd926bc59";
        libraryHaskellDepends = [ base bytestring ];
        homepage = "http://darcs.imperialviolet.org/system-inotify";
        description = "Binding to Linux's inotify interface";
@@ -127122,7 +127513,7 @@ self: {
      mkDerivation {
        pname = "system-lifted";
        version = "0.2.0.1";
-       sha256 = "1c27y14867dd6706kp9n9y287vi7vqfzd2qr9365mk2854zvqifw";
+       sha256 = "dc45bc3f2948cc5acc48198bf61dde27ee83844f36dd69c031ad1d8348f047b0";
        isLibrary = true;
        isExecutable = true;
        libraryHaskellDepends = [
@@ -127145,7 +127536,7 @@ self: {
      mkDerivation {
        pname = "system-posix-redirect";
        version = "1.1.0.1";
-       sha256 = "1wkfz898d3607xnx779l1k1qc8i2k63ixg47542r45scwq8m0lsk";
+       sha256 = "53535011e64c1792052987bc1e8799222286c30c349dd36d3fc08c8612fa6ef2";
        libraryHaskellDepends = [ base bytestring unix ];
        description = "A toy module to temporarily redirect a program's stdout";
        license = stdenv.lib.licenses.bsd3;
@@ -127160,7 +127551,7 @@ self: {
      mkDerivation {
        pname = "system-random-effect";
        version = "0.4.1.3";
-       sha256 = "1gfzyjap173brh0i4plgad0409hpah98wsf9w0n7mcr2ysrvjdmb";
+       sha256 = "ab36b9b3f622b37a2ce0c9698e125417264040538f5e1201cc6b9c7095f4dfbd";
        libraryHaskellDepends = [
          base bytestring crypto-api extensible-effects
          mersenne-random-pure64 primitive statistics vector
@@ -127182,7 +127573,7 @@ self: {
      mkDerivation {
        pname = "system-time-monotonic";
        version = "0.2";
-       sha256 = "0f5grhh6x2fbawmdk0gq1nsjz47iz8f8r2592d1l69fqddwdhc3v";
+       sha256 = "7b30d8786bd825434313a9888c1cfaf1902fb50df881d92a57cb896e20ccaf38";
        libraryHaskellDepends = [ base time ];
        homepage = "https://github.com/joeyadams/haskell-system-time-monotonic";
        description = "Simple library for using the system's monotonic clock";
@@ -127197,7 +127588,7 @@ self: {
      mkDerivation {
        pname = "system-util";
        version = "0.2";
-       sha256 = "0sjgsm4n3imnl45zgpvs1vd10wmgci2am03kpjphbqgi5bdywzqk";
+       sha256 = "137feedb2af1e105afbc7380aa4464af7210da0e7adff70ba1b6c66149d54f6a";
        libraryHaskellDepends = [
          base directory either filepath semigroups system-lifted
          template-haskell transformers unix
@@ -127220,7 +127611,7 @@ self: {
      mkDerivation {
        pname = "system-uuid";
        version = "2.1.1";
-       sha256 = "12c05aqgxfqfsc5hbwlfwy6rhcx29ywz6ai86009y45hx9iii4cb";
+       sha256 = "8b911863eab0109f0030282af3b94fa233988de78ef2050bd30ebbfeb02a8089";
        isLibrary = true;
        isExecutable = true;
        libraryHaskellDepends = [
@@ -127243,7 +127634,7 @@ self: {
      mkDerivation {
        pname = "systemd";
        version = "1.0.0";
-       sha256 = "10iyiw0m543bx9j9vdnz2lpnc3944i7ff9vbpdivvgv5z7gd17yn";
+       sha256 = "d69fd0def965bfbd63bb6b27e74e24240d662f15dfb69d64ea6b9052018f3e82";
        libraryHaskellDepends = [
          base bytestring network transformers unix
        ];
@@ -127259,7 +127650,7 @@ self: {
      mkDerivation {
        pname = "syz";
        version = "0.2.0.0";
-       sha256 = "1m5395937yyxsa1bmlfn1dxa1jr15yjhlz9s15bpwapshcd8119y";
+       sha256 = "3e85801a83fa2a7e57093a7d0aa52f21cba07a0bd6d1ba82d2ddfb335249a3d4";
        libraryHaskellDepends = [ base syb ];
        homepage = "http://www.cs.indiana.edu/~adamsmd/papers/scrap_your_zippers/";
        description = "Scrap Your Zippers";
@@ -127274,7 +127665,7 @@ self: {
      mkDerivation {
        pname = "t-regex";
        version = "0.1.0.0";
-       sha256 = "0g1sv92cglcvdcq320rwdndmq80nyy1yljl6hm86mjppha20dnxl";
+       sha256 = "b4db068482f7ca6a5085864aea83f716205c9b6d3c0331306b9bd1c744da3a3c";
        libraryHaskellDepends = [
          base containers haskell-src-exts haskell-src-meta lens mtl
          QuickCheck recursion-schemes template-haskell transformers
@@ -127290,7 +127681,7 @@ self: {
      mkDerivation {
        pname = "ta";
        version = "0.1";
-       sha256 = "1i9d34gdxrc0gnny5zgp73m0si9583i8w0gw97mqpyha4pzz6hxx";
+       sha256 = "bd43f3ff250afa8beb49fc018ee24025450dea38f7fde2ad7d80e5de1e192dc5";
        libraryHaskellDepends = [
          base containers ghc-prim mtl Takusen template-haskell time
        ];
@@ -127306,7 +127697,7 @@ self: {
      mkDerivation {
        pname = "table";
        version = "0.1.0.0";
-       sha256 = "1aqi8ivmlzi5j8kxjcwyd2nbz9jpp6q3xya8acsni5fis9l4757w";
+       sha256 = "fc944368d2d19568355348f93eb0b957a6bfac689e33d92792257e5a774411ab";
        isLibrary = false;
        isExecutable = true;
        executableHaskellDepends = [
@@ -127323,7 +127714,7 @@ self: {
      mkDerivation {
        pname = "table-tennis";
        version = "0.1.0.3";
-       sha256 = "1v5g4fbbspgm4smjxk499a0grh5xsr18688kmivql8knhxh1351k";
+       sha256 = "339411608776228a77ac13218342d6bdc0fc804a89cc2eab26f55dbd9623afec";
        libraryHaskellDepends = [ base ];
        jailbreak = true;
        description = "A table tennis game tracking engine";
@@ -127337,7 +127728,7 @@ self: {
      mkDerivation {
        pname = "tableaux";
        version = "0.2";
-       sha256 = "0dc1qdjlwxqjfb286knmbam6y9w9wlr6ah7l2ndq33yia4n2jp8b";
+       sha256 = "0b5d292c51d18f819b15f4406532e589276faa5ad54e83c47212774e65c38135";
        isLibrary = false;
        isExecutable = true;
        executableHaskellDepends = [
@@ -127356,7 +127747,7 @@ self: {
      mkDerivation {
        pname = "tables";
        version = "0.4.1.1";
-       sha256 = "1bv51i0bn0nlgi0zj8sjdch6m9dd8ncmnksz699fa28cn57ln64p";
+       sha256 = "97184b4fb10c09e552325f4f5b9945ada56a206b5223f9417cd402bb400c65af";
        libraryHaskellDepends = [
          base binary cereal comonad containers deepseq hashable lens
          profunctors safecopy template-haskell transformers
@@ -127381,7 +127772,7 @@ self: {
      mkDerivation {
        pname = "tablestorage";
        version = "0.2.1.0";
-       sha256 = "03j8cqq85i9wikw772swazbvyv1dcw0mnhmqq3slydl0axi12yr8";
+       sha256 = "287b11625780364ff5c0b8425b01672d6cbfd7575c8b73f88c3cc5823066480e";
        libraryHaskellDepends = [
          base base64-bytestring bytestring conduit crypto-api cryptohash
          HTTP http-conduit http-types mtl network old-locale resourcet SHA
@@ -127400,7 +127791,7 @@ self: {
      mkDerivation {
        pname = "tabloid";
        version = "0.47";
-       sha256 = "1qcay15g6g2c9h6vfc7pi7rl4d8fsl09vrq33pdqvgg2fp2xclh3";
+       sha256 = "0352d6c575e2bd8ddb1d03e79d00d50e3542f389f730b70d4c4c3cf34af08ae1";
        isLibrary = false;
        isExecutable = true;
        executableHaskellDepends = [
@@ -127417,7 +127808,7 @@ self: {
      mkDerivation {
        pname = "tabular";
        version = "0.2.2.7";
-       sha256 = "1ysgq7rrks7f98nnvxil8xz1q27hxdgz4szbjhqwzbwd209dmy0k";
+       sha256 = "13f8da12108dafcf3194eb6bf25febf0081c7e4734f66d2d4aeee899f3c14ffb";
        libraryHaskellDepends = [ base csv html mtl ];
        homepage = "http://hub.darcs.net/kowey/tabular";
        description = "Two-dimensional data tables with rendering functions";
@@ -127435,7 +127826,7 @@ self: {
      mkDerivation {
        pname = "taffybar";
        version = "0.4.5";
-       sha256 = "0igwq5gmfki61igrs6v51pm8r3wz8pzv6iz8dw30nmqgr3ypddlw";
+       sha256 = "9cb676fdc80f570b066fe847b3ff459f8f8cea0d651b9d5f0c264e575fc1fc45";
        isLibrary = true;
        isExecutable = true;
        libraryHaskellDepends = [
@@ -127458,7 +127849,7 @@ self: {
      mkDerivation {
        pname = "tag-bits";
        version = "0.1.1.2";
-       sha256 = "0crn1g3dh97s3b55z0pkvjm9h89kq99c2agk687vr0vij6r5di65";
+       sha256 = "c5c456b2917183bc0f32f329c152c2332198aadcf3825fca1afa24d8c60b3633";
        libraryHaskellDepends = [ base ghc-prim ];
        jailbreak = true;
        homepage = "http://github.com/ekmett/tag-bits";
@@ -127473,7 +127864,7 @@ self: {
      mkDerivation {
        pname = "tag-stream";
        version = "0.2.1";
-       sha256 = "160kyp1w3y3zg0hj198v5a3jvhpfdy0y0lfz4r2d8azay4f1pkmn";
+       sha256 = "b6ce1b1cf1ea2bd44426df51e0816feec22d872a1ba52021787ff8c1c3f51398";
        libraryHaskellDepends = [
          attoparsec base blaze-builder bytestring enumerator
        ];
@@ -127489,7 +127880,7 @@ self: {
      mkDerivation {
        pname = "tagchup";
        version = "0.4.0.4";
-       sha256 = "143bnz73fyy8swm37p0pjg9zagpgzi8mcvixvswla6fiszgc203p";
+       sha256 = "7700c1ded7d11945b9de3d6e5651fcef3ef5d39317dc332ad7c87b37ceb76b90";
        isLibrary = true;
        isExecutable = true;
        libraryHaskellDepends = [
@@ -127506,7 +127897,7 @@ self: {
      mkDerivation {
        pname = "tagged";
        version = "0.8.1";
-       sha256 = "1hc2qzhhz5p1xd8k03sklrdnhcflkwhgpl82k6fam8yckww9ipav";
+       sha256 = "5bdd98389fcca3aa9c9902d1fb209fd431685ba6530f3051ebe1960fe1c782c1";
        libraryHaskellDepends = [ base template-haskell ];
        homepage = "http://github.com/ekmett/tagged";
        description = "Haskell 98 phantom types to avoid unsafely passing dummy arguments";
@@ -127518,7 +127909,7 @@ self: {
      mkDerivation {
        pname = "tagged-binary";
        version = "0.2.0.0";
-       sha256 = "0ibp4hmzg4c4dn88ws7x1j5wc6cbz3j2hymyaw2qkac3j4phzqrm";
+       sha256 = "35e30f2f9183a9890557be7a28e4f88b19c68b0cfd688e906d8491f72b247745";
        libraryHaskellDepends = [ base binary bytestring pureMD5 ];
        description = "Provides tools for serializing data tagged with type information";
        license = stdenv.lib.licenses.mit;
@@ -127529,7 +127920,7 @@ self: {
      mkDerivation {
        pname = "tagged-exception-core";
        version = "2.1.0.0";
-       sha256 = "1w4020qb6f5vnym13a4jrha62vj7rqz3nfsrsxa34dl04y63jcax";
+       sha256 = "5d31398c2780363254d7593b3b3ece476e6114cc92a811aab7bb38b3301080f0";
        revision = "1";
        editedCabalFile = "8f3f0eba857169c03927f8605ed326b7a4a5395582aeac4edcee44369b4c9689";
        libraryHaskellDepends = [
@@ -127549,7 +127940,7 @@ self: {
      mkDerivation {
        pname = "tagged-list";
        version = "1.1";
-       sha256 = "1gdkq9d6hc25z9y8wcsjq10vz25fw40hz2hbp8jfwczhchdxy35s";
+       sha256 = "ba0cdf1b64f033ee24ba0b8a0f01e1ae88bf41c052338e7cfa4530685ac2b3bd";
        libraryHaskellDepends = [
          AbortT-transformers base binary natural-number type-equality
          type-level-natural-number type-level-natural-number-induction
@@ -127566,7 +127957,7 @@ self: {
      mkDerivation {
        pname = "tagged-th";
        version = "0.1";
-       sha256 = "1qqysn5zrkx2q3rv8ynf6nmy5rwdqk6niw0fphg5kyrg72h31s69";
+       sha256 = "c9e830a0382ffb591ebc0ef068cdc48de7e2ab35ce7ab4f3c0a2cffc8bd51ee3";
        libraryHaskellDepends = [
          base tagged template-haskell type-spine
        ];
@@ -127583,7 +127974,7 @@ self: {
      mkDerivation {
        pname = "tagged-transformer";
        version = "0.8";
-       sha256 = "13jzfrzcgbh3g3qssv08r8i8j2l5c5y84blc1m90rhyyvx2zizn7";
+       sha256 = "c7fef845dfdec30c520d8c2e827c61850a8922ca086cadf17803aec77e765f8e";
        libraryHaskellDepends = [
          base comonad contravariant distributive exceptions mtl reflection
          semigroupoids tagged
@@ -127599,7 +127990,7 @@ self: {
      mkDerivation {
        pname = "tagging";
        version = "0.1";
-       sha256 = "012lcbp2c9a38s4l2i9jaiqcxaidk93v7gxcnf9lplixrnzczy93";
+       sha256 = "23f9cfbecd3dd24b93b3acbfb3479a2daace70543245418946432526ee625404";
        libraryHaskellDepends = [ base bytestring pcre-light ];
        homepage = "git://github.com/jre2/HaskellTagging.git";
        description = "Library for tagging data";
@@ -127614,7 +128005,7 @@ self: {
      mkDerivation {
        pname = "taggy";
        version = "0.2.0";
-       sha256 = "01q2ccf3a8akaifh79ajnfr5yrjsq4xihq0pl7lsz173n7mhnsy3";
+       sha256 = "c36b0bebb1e384afe9a11760183bc15a665fb2b352a5035d545321351c630207";
        revision = "1";
        editedCabalFile = "0343ad030ba4e9fd651b383e92c213c6c4a6560ec33f561cfcfa9c5493deb50b";
        isLibrary = true;
@@ -127640,7 +128031,7 @@ self: {
      mkDerivation {
        pname = "taggy-lens";
        version = "0.1.2";
-       sha256 = "05m2c9q0rz4y0zz6n3dqf0hhzfvk0mp1692jxykg86c802d7pkib";
+       sha256 = "2bce7b9a008819f4a6ef5224136e0573bb0f2170b80d6bfe079efc0c7062a216";
        libraryHaskellDepends = [
          base lens taggy text unordered-containers
        ];
@@ -127657,7 +128048,7 @@ self: {
      mkDerivation {
        pname = "taglib";
        version = "0.1.1";
-       sha256 = "16qyfy8rxaab0q9j2v00h4j5d3la95acfhmp32x1hdxz1rwr6zfp";
+       sha256 = "d77d93790ebf3718ba18b742c754498a8e562481006c2113064ba99e91771e9b";
        libraryHaskellDepends = [ base bytestring utf8-string ];
        librarySystemDepends = [ taglib ];
        libraryPkgconfigDepends = [ taglib ];
@@ -127672,7 +128063,7 @@ self: {
      mkDerivation {
        pname = "taglib-api";
        version = "0.1.1.3";
-       sha256 = "1ahbwi28yjigbkgfv52iaaqalmmlc4d09fa65l0yczxrs7rzchmj";
+       sha256 = "b242f6f3d1b97fe6012d46b9041a61b456aab0525194edde5c2f4a8f44e40baa";
        libraryHaskellDepends = [
          base bytestring containers mtl text transformers
        ];
@@ -127689,7 +128080,7 @@ self: {
      mkDerivation {
        pname = "tagset-positional";
        version = "0.3.0";
-       sha256 = "0x1mwwlwhka12bzshy0j0w7iq9ka6kn1jgsifi26jmg7zf79zydf";
+       sha256 = "aef99f8efbe755694474513f19ec346a261c0f071278a8ff12414dc829e73574";
        libraryHaskellDepends = [
          base binary containers parsec text text-binary
        ];
@@ -127704,7 +128095,7 @@ self: {
      mkDerivation {
        pname = "tagshare";
        version = "0.0";
-       sha256 = "1q3chp1rmwmxa8rxv7548wsvbqbng6grrnv1587p08385sp4ncfj";
+       sha256 = "d2314bae2e6820700f2a61db9c9f7976e1b53547a49cdd3352bdf29ac3856ce0";
        libraryHaskellDepends = [ base containers mtl ];
        description = "TagShare - explicit sharing with tags";
        license = stdenv.lib.licenses.bsd3;
@@ -127715,7 +128106,7 @@ self: {
      mkDerivation {
        pname = "tagsoup";
        version = "0.13.3";
-       sha256 = "13b6zy6346r3cxhaivys84fnxarg8wbv7r2znazfjdkqil8n5a1j";
+       sha256 = "32a862118d7836e9beb25fe4b317472fab6e1d41daefa86067231b328cff668d";
        isLibrary = true;
        isExecutable = true;
        libraryHaskellDepends = [ base bytestring containers text ];
@@ -127732,7 +128123,7 @@ self: {
      mkDerivation {
        pname = "tagsoup-ht";
        version = "0.3";
-       sha256 = "1yxb1lmayqqlnxx4jgcbvya8llfgdbbr8rvcxwicwjrq3xsjl8km";
+       sha256 = "75222a751f384bce22ef6c6794d76acf518a94df8b3d497ab71463af2a0dabfb";
        isLibrary = true;
        isExecutable = true;
        libraryHaskellDepends = [
@@ -127755,7 +128146,7 @@ self: {
      mkDerivation {
        pname = "tagsoup-parsec";
        version = "0.0.8";
-       sha256 = "0h62kqls8nrq5wqxbzvxav4kfn1lxc6qm5vg8dhkvqdp5z6xnkzk";
+       sha256 = "f34fdbcd2fb7e13d61436f978a0deb345837c9567dffd5312f385ba4299ec240";
        libraryHaskellDepends = [ base parsec tagsoup ];
        homepage = "http://www.killersmurf.com";
        description = "Tokenizes Tag, so [ Tag ] can be used as parser input";
@@ -127771,7 +128162,7 @@ self: {
      mkDerivation {
        pname = "tagstream-conduit";
        version = "0.5.5.3";
-       sha256 = "1arlf7qil9bzcqykda8yyrnncm29jsfjvz5kbcdrbbhqpbqfi5mj";
+       sha256 = "b296e8f0ba18ae951b5bb3fc2d9d964954666df61ea9363d667f251af17134ab";
        libraryHaskellDepends = [
          attoparsec base blaze-builder bytestring case-insensitive conduit
          conduit-extra data-default resourcet text transformers xml-conduit
@@ -127789,7 +128180,7 @@ self: {
      mkDerivation {
        pname = "takahashi";
        version = "0.2.2.0";
-       sha256 = "0flr87m1yjxcv1r64bvrx1gm9dpp6xvj2lj14pi99pipywgw4kgs";
+       sha256 = "fa4dc21ff737de94e2254152217737f7b6545fe8792f6272d8ac4b1fea41993a";
        libraryHaskellDepends = [ base lens monad-skeleton mtl ];
        description = "create slide for presentation";
        license = stdenv.lib.licenses.mit;
@@ -127802,7 +128193,7 @@ self: {
      mkDerivation {
        pname = "takusen-oracle";
        version = "0.9.3";
-       sha256 = "1d57zcv409d3w6qz8n1c8k93wqrqvgynm327vx3w8p7kqs20yaad";
+       sha256 = "4d290f84c6f35cc447df478c6afddb38633ed2442c58f4b1e1a3254036fba7b4";
        isLibrary = true;
        isExecutable = true;
        libraryHaskellDepends = [ base mtl old-time time ];
@@ -127830,7 +128221,7 @@ self: {
      mkDerivation {
        pname = "tamarin-prover";
        version = "0.8.6.1";
-       sha256 = "0g7gwqaykvn2r7zbddcvcr4qjs78n0w0cvzk9sfm51i0xgmx3llg";
+       sha256 = "8fd2d1ebeb2086529d4ef36f0638b0e8688949669bb5b6fec9c2eee915e6ef3c";
        isLibrary = false;
        isExecutable = true;
        executableHaskellDepends = [
@@ -127856,7 +128247,7 @@ self: {
      mkDerivation {
        pname = "tamarin-prover-term";
        version = "0.8.5.1";
-       sha256 = "17wq4hr7wfxw5x52jzk8882197zq1lwdqk5yr9wagsbn7hldmaa5";
+       sha256 = "45a9da283c76e9a778cabe4cdc380df89f140442687e294a2fbc3b7e3224989f";
        libraryHaskellDepends = [
          attoparsec base binary bytestring containers deepseq derive
          directory dlist HUnit mtl parsec process safe split syb
@@ -127879,7 +128270,7 @@ self: {
      mkDerivation {
        pname = "tamarin-prover-theory";
        version = "0.8.6.0";
-       sha256 = "1xc11mrzfg1v8ilp7yb1zlg2359w14szhbdy86pbfzbjl31852l3";
+       sha256 = "838a82c2a0727db7ae41be2df835093c95211efd61f97369443b3cf7730d81f5";
        libraryHaskellDepends = [
          array base binary bytestring cmdargs containers deepseq derive
          directory dlist fclabels filepath HUnit mtl parallel parsec process
@@ -127901,7 +128292,7 @@ self: {
      mkDerivation {
        pname = "tamarin-prover-utils";
        version = "0.8.5.1";
-       sha256 = "11phn05fb8s80g6zk6sly8wi1rl8i3rnymkr99la8abr8yw12j3c";
+       sha256 = "6c4811b8477929a4684a79566ff38888e61039f2549bf9cd0348a3e50ab0f086";
        libraryHaskellDepends = [
          base base64-bytestring binary blaze-builder bytestring containers
          deepseq dlist fclabels mtl parsec pretty SHA syb time transformers
@@ -127918,7 +128309,7 @@ self: {
      mkDerivation {
        pname = "tamper";
        version = "0.4.1";
-       sha256 = "1nkfcai9l6z6hvjixq8nny1466f8shc5432hr8l17llqcwpbzv5p";
+       sha256 = "b7ecbf2e6798d21328ca500c5218d4c8194382b716e11ee586e61b9aa2626eda";
        libraryHaskellDepends = [ base containers mtl safe text ];
        description = "An HTML templating system similar to Blaze, implemented as a monad transformer of sorts";
        license = stdenv.lib.licenses.bsd3;
@@ -127930,7 +128321,7 @@ self: {
      mkDerivation {
        pname = "tar";
        version = "0.4.1.0";
-       sha256 = "05875pc5ns1fsbl9qgr8sqh29xl4mhvj0pwsa9z4afxv6h6328bm";
+       sha256 = "7521310c34bb3b457e529a5f2037ac84f62420d6283f9ce8d22e685bd82d0715";
        libraryHaskellDepends = [
          base bytestring directory filepath time
        ];
@@ -127945,7 +128336,7 @@ self: {
      mkDerivation {
        pname = "tar";
        version = "0.4.2.1";
-       sha256 = "102hjlrqfb9d0mvz2bdrj0wg7hvhvzbv4f8gsvxz0wfnq7k0mb9g";
+       sha256 = "2fad0ae6c1d671f0fbd60f39b2d7df70c3f33890b92df177052d2d8733955080";
        libraryHaskellDepends = [
          array base bytestring directory filepath time
        ];
@@ -127962,7 +128353,7 @@ self: {
      mkDerivation {
        pname = "tardis";
        version = "0.3.0.0";
-       sha256 = "15f88b5qg4v1ah60y0jxkww9n6z7gvnkslx4inckh6m6c7yvj8k6";
+       sha256 = "6622b9fd61a61a38998da4533ded7ee71b9b389f5d020f0c54619387cb42c895";
        libraryHaskellDepends = [ base mtl ];
        homepage = "https://github.com/DanBurton/tardis";
        description = "Bidirectional state monad transformer";
@@ -127979,7 +128370,9 @@ self: {
      mkDerivation {
        pname = "target";
        version = "0.1.3.0";
-       sha256 = "0przmavzzcbyxkqj1wffiissxz9fdlrx2q8lpxgmsamadd46xq66";
+       sha256 = "c6e06e486baa2a5d5fbf1461d1336d2efdae758ccef120f1ec7eb1ffb7aa3f5f";
+       revision = "1";
+       editedCabalFile = "173753da5f21d9f9d164cc546890e9ad602e339ed99351863ad1ba5df9489fb3";
        libraryHaskellDepends = [
          base containers directory exceptions filepath ghc ghc-paths
          liquid-fixpoint liquidhaskell mtl pretty process syb tagged
@@ -128004,7 +128397,7 @@ self: {
      mkDerivation {
        pname = "task";
        version = "0.0.1";
-       sha256 = "0z4f4hs2c7xl6c134bqhk81wzxhb6yf7fsar2fnqvahviaqqgzqn";
+       sha256 = "16ff87b18a1baa8dad135969779c370bf6cf039a102f320233b41f2634248e7c";
        isLibrary = false;
        isExecutable = true;
        executableHaskellDepends = [
@@ -128024,7 +128417,7 @@ self: {
      mkDerivation {
        pname = "taskpool";
        version = "0.1.0";
-       sha256 = "02r7y882sfj7m3yaj68v40f4065ajiig2b25v55svh13jars7c3n";
+       sha256 = "76b0a3b39223c0ad4bd9452cf16294aa18401c201b19a9fca8473a2d10f2270b";
        libraryHaskellDepends = [
          async base containers fgl stm transformers
        ];
@@ -128043,7 +128436,7 @@ self: {
      mkDerivation {
        pname = "tasty";
        version = "0.10.1.2";
-       sha256 = "0c5p86ljqa7id6rlkj4p4wy53m9p77f6nayr8ybhcqsjprpb5q4i";
+       sha256 = "91e0b26ebe5263069747d92b6bdc3937d5513c2797c849b369f1282ca941b730";
        libraryHaskellDepends = [
          ansi-terminal async base containers deepseq mtl
          optparse-applicative regex-tdfa-rc stm tagged time unbounded-delays
@@ -128060,7 +128453,7 @@ self: {
      mkDerivation {
        pname = "tasty-ant-xml";
        version = "1.0.1";
-       sha256 = "1wb9lm9rbk46g9cm2lpcrzh59zpcy270p824agg61bj1xb9jymsc";
+       sha256 = "4c572fd3ea41ae60de5344a00b8ef0ecfe54e0cfec5251597a86cc9553a569f1";
        libraryHaskellDepends = [
          base containers generic-deriving ghc-prim mtl stm tagged tasty
          transformers xml
@@ -128078,7 +128471,7 @@ self: {
      mkDerivation {
        pname = "tasty-golden";
        version = "2.3.0.1";
-       sha256 = "19jlfxhgrphsv7nfwsfil5ci2snlm9qsqwswnzn68pa3440zqiji";
+       sha256 = "5146fc0121435d64ecb75c73ac71aad46a1159a1d169eeecd91adefc607754a6";
        libraryHaskellDepends = [
          async base bytestring containers deepseq directory filepath mtl
          optparse-applicative process tagged tasty temporary-rc
@@ -128098,7 +128491,7 @@ self: {
      mkDerivation {
        pname = "tasty-hspec";
        version = "1.1";
-       sha256 = "15ly6jf4kgdc15k6b584d99j18xb41alas62gyakw5sf8y0y02i6";
+       sha256 = "260ae081474e173e957fc268455520aba320536a0495656609acbd499c349e96";
        libraryHaskellDepends = [
          base hspec hspec-core QuickCheck random tasty tasty-quickcheck
          tasty-smallcheck
@@ -128115,7 +128508,7 @@ self: {
      mkDerivation {
        pname = "tasty-html";
        version = "0.4.1";
-       sha256 = "0a4j8w4gm8wr9pgmkkahadl5k2sd19za9f6x323f01v4ff455hwg";
+       sha256 = "8fc35288736407e08618ddb8a47e0a4d8b59685350cd59df4d99a3fa08479228";
        libraryHaskellDepends = [
          base blaze-html bytestring containers filepath generic-deriving mtl
          stm tagged tasty text transformers
@@ -128130,7 +128523,7 @@ self: {
      mkDerivation {
        pname = "tasty-hunit";
        version = "0.9.2";
-       sha256 = "08qnxaw34wfnzi9irs1jd4d0zczqm3k5ffkd4zwhkz0dflmgq7mf";
+       sha256 = "ae1efc2a750dfc09f9276d3a57e6a8f8b30f1a6932e81c53fcd67132b8ea1623";
        libraryHaskellDepends = [ base tasty ];
        homepage = "http://documentup.com/feuerbach/tasty";
        description = "HUnit support for the Tasty test framework";
@@ -128142,7 +128535,7 @@ self: {
      mkDerivation {
        pname = "tasty-hunit-adapter";
        version = "1.0";
-       sha256 = "0626islqqkncdma8790z2z47r8x90y9v7fj0p5nhkw6mpy6p0ifg";
+       sha256 = "cf45708dbfd5f0096db940bab39307a9a37cc8171fa483546dcc4e8ca98e4618";
        libraryHaskellDepends = [ base HUnit tasty tasty-hunit ];
        jailbreak = true;
        homepage = "https://github.com/jstolarek/tasty-hunit-adapter";
@@ -128161,7 +128554,7 @@ self: {
      mkDerivation {
        pname = "tasty-integrate";
        version = "0.0.1";
-       sha256 = "0zjbs7ax5nrxcg1njnrliavablda5rgjciq2h3nycvic8r1g9p7x";
+       sha256 = "fddcf442462c6ee6ed800247265f2eaad1a5b68a345b69c3633ddbd2d5d14b7e";
        isLibrary = false;
        isExecutable = true;
        executableHaskellDepends = [
@@ -128189,7 +128582,7 @@ self: {
      mkDerivation {
        pname = "tasty-kat";
        version = "0.0.3";
-       sha256 = "14yvlpli6cv6bn3kh8mlfp4x1l6ns4fvmfv6hmj75cvxyzq029d7";
+       sha256 = "a72501f0f77db372648566bbba1dd1d6d0d0c975b42238875d663313e9a5db93";
        libraryHaskellDepends = [ base bytestring tasty ];
        testHaskellDepends = [
          base bytestring mtl tasty tasty-hunit tasty-quickcheck
@@ -128205,7 +128598,7 @@ self: {
      mkDerivation {
        pname = "tasty-program";
        version = "1.0.3";
-       sha256 = "18q6b8z5hh1jybr9i72ark95hwz8kg6zbh40ghgwsf6n3ijyfn8n";
+       sha256 = "1659e7651cd638cd1f7c80c0f5cd9be87358d2cc4a9c98f2f23240583e5a06a3";
        libraryHaskellDepends = [
          base deepseq directory filepath process tasty
        ];
@@ -128221,7 +128614,7 @@ self: {
      mkDerivation {
        pname = "tasty-quickcheck";
        version = "0.8.3.2";
-       sha256 = "1q1fghmsjrdl6jkcnajmsvw4d893m6cyhzpai9vvrhxy9vdy0l1v";
+       sha256 = "3b50e0db4ebec3bc778aea7ee899a923a146f8d6552acba634b465a92b7c2ee0";
        libraryHaskellDepends = [ base QuickCheck tagged tasty ];
        testHaskellDepends = [ base pcre-light tasty tasty-hunit ];
        homepage = "http://documentup.com/feuerbach/tasty";
@@ -128236,7 +128629,7 @@ self: {
      mkDerivation {
        pname = "tasty-rerun";
        version = "1.1.4";
-       sha256 = "1c0mbjfgg0s2p1cmlyd8gnmmc6wk5ih5v9jr11bln54myyjywq8m";
+       sha256 = "1561eea5f795144b570859a65d602c931b56ab7da8795a59b84283f79c5c15b0";
        libraryHaskellDepends = [
          base containers mtl optparse-applicative reducers split stm tagged
          tasty transformers
@@ -128255,7 +128648,7 @@ self: {
      mkDerivation {
        pname = "tasty-silver";
        version = "3.1.7";
-       sha256 = "1mplisyhps9n3kw2w3fjanc14cr6vbyr4xdydq76za9dmx07kd3l";
+       sha256 = "74b47940af2da96f0e6ebe7592fdda2633129855d20d2ef81c36e90bbd8ef4d6";
        libraryHaskellDepends = [
          ansi-terminal async base bytestring containers deepseq directory
          filepath mtl optparse-applicative process process-extras regex-tdfa
@@ -128275,7 +128668,7 @@ self: {
      mkDerivation {
        pname = "tasty-smallcheck";
        version = "0.8.0.1";
-       sha256 = "0yckfbz8na8ccyw2911i3a4hd3fdncclk3ng5343hs5cylw6y4sm";
+       sha256 = "55136f38f5ac6838c828cf8e4919b3cd8d06891a318424b8670c298bfe729379";
        libraryHaskellDepends = [ async base smallcheck tagged tasty ];
        homepage = "http://documentup.com/feuerbach/tasty";
        description = "SmallCheck support for the Tasty test framework";
@@ -128289,7 +128682,7 @@ self: {
      mkDerivation {
        pname = "tasty-th";
        version = "0.1.3";
-       sha256 = "1fl5pagm9bdqvp7v54ilkr91m667rxw1jifwfdhrikr938aqrzx3";
+       sha256 = "a3ff8c151a29cf986173dc451978cfc7981a529e3492b2cfddb8ad549fba85ba";
        libraryHaskellDepends = [
          base language-haskell-extract tasty template-haskell
        ];
@@ -128303,7 +128696,7 @@ self: {
      mkDerivation {
        pname = "tau";
        version = "6.2831";
-       sha256 = "10vw3y3vimqpb22amhk7n0d0jni46j60iva1gqa28ky8lhqq8ssz";
+       sha256 = "5f6b8431a4c84f24147e41ed088c34245a091ab067c2aa845817d7b8871f7c83";
        libraryHaskellDepends = [ base ];
        description = "Tau, the ratio between any circle's circumference and radius";
        license = stdenv.lib.licenses.bsd3;
@@ -128317,7 +128710,7 @@ self: {
      mkDerivation {
        pname = "tbox";
        version = "0.1.0";
-       sha256 = "0qsc4mdiryrf3pqzzjvx57iz92xagp7692h312q2pm412zg6p1vy";
+       sha256 = "7e876bde1781d42bb008038a64ce7daa8bf4e3297dcbfff11d2efb1c5b254c63";
        libraryHaskellDepends = [
          array base binary cautious-file containers directory filepath
          IfElse monad-loops mtl random safe-failure stm-io-hooks
@@ -128336,7 +128729,7 @@ self: {
      mkDerivation {
        pname = "tcache-AWS";
        version = "0.0.1";
-       sha256 = "18hi8jvc117pxjhpb891hqlsbi4wvmd6nr3vwnqqr7rcw2dsmnwv";
+       sha256 = "9bdbaa9be02c9f8cb1e57b646b5add9cc4a5298621a175a1ecf784c0b64411a2";
        libraryHaskellDepends = [
          aws base bytestring conduit http-conduit network TCache text
        ];
@@ -128351,7 +128744,7 @@ self: {
      mkDerivation {
        pname = "tccli";
        version = "0.0.1";
-       sha256 = "0ljfn9dvyncl205mrnpic5j0633gnzka03gjc4dmccsqq0c1wjm7";
+       sha256 = "a74a1e18c05833561b61f20da0e6b76f0c036461f1da5c0b109459bf5bb24e52";
        isLibrary = false;
        isExecutable = true;
        executableHaskellDepends = [
@@ -128368,7 +128761,7 @@ self: {
      mkDerivation {
        pname = "tce-conf";
        version = "1.1";
-       sha256 = "1c3wr9rab7835dfg9qmxhprb2r21iyig1wkvwl49h7brhmhxzpnh";
+       sha256 = "d0dedf6185791d9808e57bf2f0a28f4164b1f285bde2f45c2b039da572ca7cb0";
        libraryHaskellDepends = [ base containers ];
        testHaskellDepends = [ base containers HUnit ];
        homepage = "http://hub.darcs.net/dino/tce-conf";
@@ -128381,7 +128774,7 @@ self: {
      mkDerivation {
        pname = "tconfig";
        version = "0.5.2";
-       sha256 = "05cnlbrdddbrdwlm8s7b76ydwrn49vaifdgaklfhv8rzz9dfpvbr";
+       sha256 = "79edeb5afa3fa30d1d9dea3517d54ec466debc39eb6854296f79b5d6f2a29615";
        libraryHaskellDepends = [ base containers ];
        description = "Simple text configuration file parser library";
        license = stdenv.lib.licenses.bsd3;
@@ -128392,7 +128785,7 @@ self: {
      mkDerivation {
        pname = "tcp";
        version = "0.0.2";
-       sha256 = "1wqkfnkd2di9a6h0br33fd7jaf1yqpaf7kjnpjwp52l4xv04ajlv";
+       sha256 = "9b4a45c0ee848a72b9bc56cee3d4c53e38254f7363e405a0512936d1a67513f3";
        libraryHaskellDepends = [ base containers old-time ];
        homepage = "http://www.cl.cam.ac.uk/~pes20/Netsem/";
        description = "A purely functional TCP implementation";
@@ -128410,7 +128803,7 @@ self: {
      mkDerivation {
        pname = "tdd-util";
        version = "0.3.0.1";
-       sha256 = "1d9avxpj2d90agd2pvc905j7jfa4rssl7bnrp2fmky4hfcbqa8ly";
+       sha256 = "9e2285177390f8599db8d9ae43b5ce443979640189ed2bda532035216fdf2ab5";
        libraryHaskellDepends = [
          base bytestring HUnit lens MonadCatchIO-transformers parallel-io
          process QuickCheck random system-posix-redirect tagged
@@ -128435,7 +128828,7 @@ self: {
      mkDerivation {
        pname = "tdoc";
        version = "0.4.6";
-       sha256 = "0gslj3z3lnh2wl7ljg8rza6kmmgfmgv94hgla75nblirvyka8v48";
+       sha256 = "886ca4a6df39d265cb51f44192f6abeed53a8dfa193d490fe5025a3afe90543f";
        libraryHaskellDepends = [
          base bytestring template-haskell transformers xhtml
        ];
@@ -128449,7 +128842,7 @@ self: {
      mkDerivation {
        pname = "teams";
        version = "0.0.2.3";
-       sha256 = "04jq7qdh0kr55a7a3gkjc8dgn130bp0kqh8qcmf284wz981vj9gd";
+       sha256 = "ed25b9034a9f13245c6518413cc15d6004fb1a6272bea18e2a254f001b3e5812";
        libraryHaskellDepends = [ base containers fgl graphviz ];
        description = "Graphical modeling tools for sequential teams";
        license = "GPL";
@@ -128461,7 +128854,7 @@ self: {
      mkDerivation {
        pname = "teeth";
        version = "0.1.0.0";
-       sha256 = "1hxii574qdxcbh10f4bgwyaxf83inqj9vrcwk7vkffv6pg349xcl";
+       sha256 = "94f544c6bb663b37f7999ce59d24b67120d795e76f1107025cac374c4e89b1c3";
        revision = "1";
        editedCabalFile = "84bb818fc4cb06bf91450e31e9a023926449a6157ce1e5de60649cda931db416";
        libraryHaskellDepends = [ base ];
@@ -128478,7 +128871,7 @@ self: {
      mkDerivation {
        pname = "telegram";
        version = "0.1.0.0";
-       sha256 = "1ci6606fx5cisb9yrjh0mkd549w2j3h1vzj3zm2zsl9gr7agvh4n";
+       sha256 = "96c0fdd4c92f51fd45fd43fe1de090822752daac00caecd3d29195ee0c3026b2";
        libraryHaskellDepends = [
          aeson base bytestring data-default http-conduit url utf8-string
        ];
@@ -128495,7 +128888,7 @@ self: {
      mkDerivation {
        pname = "tellbot";
        version = "0.5.1.4";
-       sha256 = "0mm7yyyxs3dvqsrs1xd4mq7byfn55rwri26k9xq3l4k9v7sxbgx8";
+       sha256 = "a8bfd5f5d969123a704fd38898792ec53abf0eaea4f5a0b3c6bb0dddbdf7a756";
        isLibrary = false;
        isExecutable = true;
        executableHaskellDepends = [
@@ -128512,7 +128905,7 @@ self: {
      mkDerivation {
        pname = "template";
        version = "0.2.0.10";
-       sha256 = "10mcnhi2rdflmv79z0359nn5sylifvk9ih38xnjqqby6n4hs7mcg";
+       sha256 = "8fd5a321b1c62f8ca5ed68c098e676917a5dac4d65809fceaed4b52c22b4ac82";
        libraryHaskellDepends = [ base mtl text ];
        description = "Simple string substitution";
        license = stdenv.lib.licenses.bsd3;
@@ -128523,7 +128916,7 @@ self: {
      mkDerivation {
        pname = "template-default";
        version = "0.1.1";
-       sha256 = "07b8j11v0247fwaf3mv72m7aaq3crbsyrxmxa352vn9h2g6l1jsd";
+       sha256 = "4dcb40cd1330d92dca50bdf6ecf5ca6c60a54e1567d7e114778708b04390681d";
        libraryHaskellDepends = [ base data-default template-haskell ];
        jailbreak = true;
        homepage = "https://github.com/haskell-pkg-janitors/template-default";
@@ -128537,7 +128930,7 @@ self: {
      mkDerivation {
        pname = "template-haskell";
        version = "2.10.0.0";
-       sha256 = "1y0dikbpy98n9g1rwb6swng86cch815x5ipj8kfjgpjgs0c3i2im";
+       sha256 = "358a3818d04fde27dd44f2c6d24b409031839ee5da2c9ec34b16257fd78c0df8";
        libraryHaskellDepends = [ base pretty ];
        description = "Support library for Template Haskell";
        license = stdenv.lib.licenses.bsd3;
@@ -128548,7 +128941,7 @@ self: {
      mkDerivation {
        pname = "template-haskell-util";
        version = "0.1.1.0";
-       sha256 = "032gkb6pgd5l8ih48971ckiy7spvvr6fcmjx4ysiyyaj7hra174f";
+       sha256 = "8e9ca0323c52791fb5275d56e64cdefbeae3e364e124446044b4b477cd9a4f0c";
        libraryHaskellDepends = [
          base GenericPretty ghc-prim template-haskell
        ];
@@ -128566,7 +128959,7 @@ self: {
      mkDerivation {
        pname = "template-hsml";
        version = "0.2.0.3";
-       sha256 = "1lnw1rhxj66zn34p8ca2dx98326l40w8kj6nrxxhff0v30myxa1g";
+       sha256 = "2fa8ee2b181b38077bcfd6c8893820d48881526f423174c9b0df18d9610edcd2";
        libraryHaskellDepends = [
          base blaze-markup haskell-src-exts haskell-src-meta parsec
          template-haskell
@@ -128588,7 +128981,7 @@ self: {
      mkDerivation {
        pname = "templatepg";
        version = "0.2.6";
-       sha256 = "1i5ais5nlga3qv0w2fg5fdkfxikks9yg6fgwqx7agcrxp4wpqcb7";
+       sha256 = "67317c39b93db3a74ec7fc39f37cd273c6ee6673e539c1c1c6433d6a8b8eaac4";
        libraryHaskellDepends = [
          base binary bytestring haskell-src-meta mtl network old-locale
          parsec regex-compat regex-posix template-haskell time utf8-string
@@ -128606,7 +128999,7 @@ self: {
      mkDerivation {
        pname = "templater";
        version = "0.0.3.0";
-       sha256 = "0j00bb915j5d9a416gjqng08zcqfwbv24k2rqmb0mbmzz768viz4";
+       sha256 = "e4c78dccf9bfae0a56c5594c22f6e20eb38fc0b3583e13884aadc812d25a0048";
        libraryHaskellDepends = [ attoparsec base text ];
        testHaskellDepends = [
          base hspec hspec-attoparsec HUnit QuickCheck text
@@ -128624,7 +129017,7 @@ self: {
      mkDerivation {
        pname = "tempodb";
        version = "0.2.2.5";
-       sha256 = "00z02hl31ad497rvxjxx5khb20ql6irkgpdvsg5m7axq8bi3d5fl";
+       sha256 = "d49536e242b8ab53cbd3bbdd3773341403b1e02cbdcbbef349a4a9302814e003";
        libraryHaskellDepends = [
          aeson base blaze-builder bytestring containers HsOpenSSL HTTP
          http-streams io-streams mtl old-locale text time
@@ -128644,7 +129037,7 @@ self: {
      mkDerivation {
        pname = "temporal-csound";
        version = "0.4.3.1";
-       sha256 = "1c7difs3svrq1ka8bdf61vvg9b29baqd086l19a84f0734q5ph19";
+       sha256 = "29c05b3019073882540ad420d0b05a49acf4f60ec6b585d40c386f3db48bedb0";
        libraryHaskellDepends = [
          base csound-catalog csound-expression temporal-media
          temporal-music-notation temporal-music-notation-western
@@ -128660,7 +129053,7 @@ self: {
      mkDerivation {
        pname = "temporal-media";
        version = "0.6.0";
-       sha256 = "0mpi97lqh4mqv6flgcrwzbv8ihlxhxzf5z2xd87wxpzvcglx2n0n";
+       sha256 = "1658d1e963fbdfce0f6a5dfce27e879dc288f6fa3cb3479dd9b81288e949f156";
        libraryHaskellDepends = [ base Boolean ];
        homepage = "https://github.com/anton-k/temporal-media";
        description = "data types for temporal media";
@@ -128672,7 +129065,7 @@ self: {
      mkDerivation {
        pname = "temporal-music-notation";
        version = "0.4.1";
-       sha256 = "09mx6bfz0lxyy7z0srl4372qv42fyymc5pqxkyxj7mhf872y4biv";
+       sha256 = "3b2ee2c5410ed623bb9f1ddfc2aaf74e908dc51984660dfef1be53f0dd32bd26";
        libraryHaskellDepends = [
          base data-default temporal-media vector
        ];
@@ -128688,7 +129081,7 @@ self: {
      mkDerivation {
        pname = "temporal-music-notation-demo";
        version = "0.4.0";
-       sha256 = "1jd9yd9ay9xmlmpm4wnkpd0ic69xlg8igqbagrycc6kv4zf1p20z";
+       sha256 = "1f881bdc277b1ac67c7e6ae117d1a33d191641bbd372526fa5b527af52f3a9c9";
        libraryHaskellDepends = [
          base binary data-default HCodecs temporal-music-notation
        ];
@@ -128702,7 +129095,7 @@ self: {
      mkDerivation {
        pname = "temporal-music-notation-western";
        version = "0.4.0";
-       sha256 = "012pv4l5r3ijnyid7b8h1lpifjs7cf3k4a13f6773r93qfgvxpkc";
+       sha256 = "6cdebe9fc323e5718e712328328763474b172f0d10add3a2b7328e5c28d95704";
        libraryHaskellDepends = [ base temporal-music-notation ];
        homepage = "https://github.com/anton-k/temporal-music-notation-western";
        description = "western music notation";
@@ -128716,7 +129109,7 @@ self: {
      mkDerivation {
        pname = "temporary";
        version = "1.2.0.3";
-       sha256 = "0is67bmsjmbbw6wymhis8wyq9gax3sszm573p5719fx2c9z9r24a";
+       sha256 = "8a889c7e62a2bb144eb9e394fab51e5dbd843d473ac2eab9e16b55a9eb3a4647";
        libraryHaskellDepends = [
          base directory exceptions filepath transformers unix
        ];
@@ -128732,7 +129125,7 @@ self: {
      mkDerivation {
        pname = "temporary-rc";
        version = "1.2.0.3";
-       sha256 = "1nqih0qks439k3pr5kmbbc8rjdw730slrxlflqb27fbxbzb8skqs";
+       sha256 = "1a4f8dd65f7db92316a68ef64c3518873799115babce92ef9869103d318011db";
        libraryHaskellDepends = [
          base directory exceptions filepath transformers unix
        ];
@@ -128748,7 +129141,7 @@ self: {
      mkDerivation {
        pname = "temporary-resourcet";
        version = "0.1.0.0";
-       sha256 = "1nxl8ivp5sd250w7pwm4f1kas5g1ikij3z39px717ys1xvk1r81h";
+       sha256 = "30a01ce6ee41fb134ebf69fc21e38ce115ad6670a4f27b3828a2e9727744b4db";
        libraryHaskellDepends = [
          base directory exceptions filepath resourcet transformers unix
        ];
@@ -128767,7 +129160,7 @@ self: {
      mkDerivation {
        pname = "tempus";
        version = "0.1.0";
-       sha256 = "0hv5b09vly9zakjfgi4bnjx503ny334dhg13g5ma85rp3dbsjvsn";
+       sha256 = "566fa9571b3717a46a79233cd8c818de0e50bab48bc4e7e4543f79ba13586543";
        isLibrary = false;
        isExecutable = true;
        executableHaskellDepends = [
@@ -128786,7 +129179,7 @@ self: {
      mkDerivation {
        pname = "tensor";
        version = "0.3.0.1";
-       sha256 = "03m612xvx3p44za0g291xir89lcgm4pk885lpy3wshp0987ij1nf";
+       sha256 = "ce06190f4ae042cd87bfb420342fa98fd18472ec218907d427e48ebebb08a60e";
        libraryHaskellDepends = [ base ghc-prim random vector ];
        testHaskellDepends = [ base QuickCheck random ];
        homepage = "http://noaxiom.org/tensor";
@@ -128802,7 +129195,7 @@ self: {
      mkDerivation {
        pname = "term-rewriting";
        version = "0.2";
-       sha256 = "07axcgr8llrj8icaysi1awq29p8vgpakvv56shvjrcgjf9ar0m11";
+       sha256 = "2154905572f2b12c37d4a6ec3dd57d1bdd243057216aaf584432538af2635d1d";
        libraryHaskellDepends = [
          ansi-wl-pprint array base containers mtl multiset parsec
          union-find-array
@@ -128820,7 +129213,7 @@ self: {
      mkDerivation {
        pname = "termbox-bindings";
        version = "0.1.0.5";
-       sha256 = "0hv72kkpx6narykfbf6m59gq4l8gym6fm52n1zzazac1802zw0dv";
+       sha256 = "bb01fe054081a9affe0f5694ea4cf50f51825f2ad5b8e5a6cfca9a7ee7146743";
        isLibrary = true;
        isExecutable = true;
        libraryHaskellDepends = [ base ];
@@ -128839,7 +129232,7 @@ self: {
      mkDerivation {
        pname = "terminal-progress-bar";
        version = "0.0.1.4";
-       sha256 = "0ldvii23ks446xrd27aklh8s8pn1yi3dzhhzl05gipjqbhq3lsx3";
+       sha256 = "a36b3a305c58def80aa01fc2df46f4c15ea411a4531dd1723784e839448cbb51";
        libraryHaskellDepends = [
          base base-unicode-symbols stm stm-chans
        ];
@@ -128856,7 +129249,7 @@ self: {
      mkDerivation {
        pname = "terminal-size";
        version = "0.3.2";
-       sha256 = "0vm6xrm5j60h01lgn7srhsx2698aq6k5jkbc84bi5zh5w63fsdyp";
+       sha256 = "d737ed86e105fe1217416c4d59a6c10a2523ba86591ffb68001018596aeea66e";
        libraryHaskellDepends = [ base ];
        description = "Get terminal window height and width";
        license = stdenv.lib.licenses.bsd3;
@@ -128867,7 +129260,7 @@ self: {
      mkDerivation {
        pname = "termination-combinators";
        version = "0.1";
-       sha256 = "1k32s5vzkxnsawj8vdscyfc96hk0s97zpj1mgw1hk93hwcrxn9wh";
+       sha256 = "9027db33e370a409037f35c8fb4fd260429398f34cb78d2457daf6f977d162cc";
        libraryHaskellDepends = [ base containers contravariant ];
        jailbreak = true;
        homepage = "http://www.github.com/batterseapower/termination-combinators";
@@ -128880,7 +129273,7 @@ self: {
      mkDerivation {
        pname = "terminfo";
        version = "0.4.0.1";
-       sha256 = "1qsspg1kqk68ja217fn3anv1j8arr1pwzzb5m74zpxpjaqb02153";
+       sha256 = "a304011656f2f6fbc9a965fdcf6fc8592119b655c3ba138492c84c3cc3bb5ae3";
        libraryHaskellDepends = [ base ];
        librarySystemDepends = [ ncurses ];
        homepage = "https://github.com/judah/terminfo";
@@ -128895,7 +129288,7 @@ self: {
      mkDerivation {
        pname = "terminfo-hs";
        version = "0.1.0.1";
-       sha256 = "1bbf37c34l8q12hy9yhw1jcjzcb1g87r850pxhwyzsikwhf75g81";
+       sha256 = "01bd721ce433eaef39ec1714940f7a61b12f990c1cfae4a108185132d8196ead";
        libraryHaskellDepends = [
          attoparsec base bytestring containers directory errors filepath
        ];
@@ -128909,7 +129302,7 @@ self: {
      mkDerivation {
        pname = "terrahs";
        version = "0.9";
-       sha256 = "0gciz8nvn7x1lclzihvwy8v1c53p6frb1q32ckpmsqw7xiasqlhb";
+       sha256 = "0b52ac55ec87635def6462e0b0b23377141636f27cc3f829a3a11fbb2dfa913d";
        libraryHaskellDepends = [ base haskell98 old-time ];
        librarySystemDepends = [ terralib4c translib ];
        jailbreak = true;
@@ -128925,7 +129318,7 @@ self: {
      mkDerivation {
        pname = "tersmu";
        version = "0.2";
-       sha256 = "064s43a7iq2rr643x4ahibgjanyq3v5h6qcgvc68j1dycq56snnl";
+       sha256 = "d45a6d0a66be05890cdb8f6103cb1ed85b25df8a50913e88c959e078d4209a18";
        isLibrary = false;
        isExecutable = true;
        executableHaskellDepends = [
@@ -128944,7 +129337,7 @@ self: {
      mkDerivation {
        pname = "test-framework";
        version = "0.8.1.1";
-       sha256 = "0wxjgdvb1c4ykazw774zlx86550848wbsvgjgcrdzcgbb9m650vq";
+       sha256 = "7883626a5aebb1df327bf26dbd382208946250a79f9cc3bf9a9eb0b0767bb273";
        isLibrary = true;
        isExecutable = true;
        libraryHaskellDepends = [
@@ -128963,7 +129356,7 @@ self: {
      mkDerivation {
        pname = "test-framework-doctest";
        version = "0.2.1.2";
-       sha256 = "01k0kcsbc41zaric5zgnhfnrp9dd19brv4d3p22vly7a7bmn6n0q";
+       sha256 = "185863eb3aea78ba85b8a3919d570aada59bad83f6fdc262563f10b6349b6006";
        libraryHaskellDepends = [
          base doctest test-framework test-framework-hunit
        ];
@@ -128981,7 +129374,7 @@ self: {
      mkDerivation {
        pname = "test-framework-golden";
        version = "1.1.3.3";
-       sha256 = "1sfgr91zn7iwgj1p1s3298mswv29rbxz4x4086r8mav7prd0ww36";
+       sha256 = "66700e5abe67ab8ab2418074f2fbca496cae2b4a62e870837c3c1efb43cacfe9";
        libraryHaskellDepends = [
          base bytestring filepath mtl process temporary test-framework
        ];
@@ -128996,7 +129389,7 @@ self: {
      mkDerivation {
        pname = "test-framework-hunit";
        version = "0.3.0.1";
-       sha256 = "1h0h55kf6ff25nbfx1mhliwyknc0glwv3zi78wpzllbjbs7gvyfk";
+       sha256 = "d3f9fd8e5e7251fa2f4727feb1397d80d9e979a4b086ee962dc239e3662910c0";
        libraryHaskellDepends = [
          base extensible-exceptions HUnit test-framework
        ];
@@ -129010,7 +129403,7 @@ self: {
      mkDerivation {
        pname = "test-framework-program";
        version = "1.1";
-       sha256 = "10p6xxxbfx3yr71wdbvk7qhm3xkxq3a1dv4hgcirzynsdfk36s3z";
+       sha256 = "7f6833a66bdafa9f237b90ec16d4c07df651213e73afc6c3c97e74b77aefe682";
        libraryHaskellDepends = [ base directory process test-framework ];
        description = "Test framework support for running simple test programs";
        license = stdenv.lib.licenses.bsd3;
@@ -129023,7 +129416,7 @@ self: {
      mkDerivation {
        pname = "test-framework-quickcheck";
        version = "0.3.0";
-       sha256 = "0g8sh3x3mhns03svccgbdbw8crzpzmahp1hr1fs6ag66fqr8p9mv";
+       sha256 = "bba68b3276c63c65b40b19860b55fdf76786f86aeb31b6f500dac23afa801a3d";
        libraryHaskellDepends = [
          base deepseq extensible-exceptions QuickCheck random test-framework
        ];
@@ -129041,7 +129434,7 @@ self: {
      mkDerivation {
        pname = "test-framework-quickcheck2";
        version = "0.3.0.3";
-       sha256 = "12p1zwrsz35r3j5gzbvixz9z1h5643rhihf5gqznmc991krwd5nc";
+       sha256 = "cc96c6f30c29b16a3f7ec5c108f320a6c0f0d3ef71afff8a1cb98caf33ffe18a";
        revision = "1";
        editedCabalFile = "14fdf07c345e9460882b975851739afc2cf62f0c9930c38d0fee5b0943351638";
        libraryHaskellDepends = [
@@ -129060,7 +129453,7 @@ self: {
      mkDerivation {
        pname = "test-framework-sandbox";
        version = "0.1.0";
-       sha256 = "0bfj0l189dh52dipdnxcqllk2h6g4dwcwcw5pll2my3n7r78pn7v";
+       sha256 = "fbd88b4e3e76f82a28bd8533ce7823cf403129c5acdb76631305b6840205d22d";
        libraryHaskellDepends = [
          ansi-terminal base lifted-base mtl temporary test-framework
          test-sandbox transformers
@@ -129081,7 +129474,7 @@ self: {
      mkDerivation {
        pname = "test-framework-skip";
        version = "1.0";
-       sha256 = "1avs36j6a846a3qiy0f23qnld1swgpngidb3098dcib2rbw4p3n9";
+       sha256 = "c98e4bf8ca6245d6500263b5f8ec7d5c87462d1ec2011ff150862065a4197aab";
        libraryHaskellDepends = [ base test-framework ];
        testHaskellDepends = [
          base HUnit QuickCheck smallcheck test-framework
@@ -129098,7 +129491,7 @@ self: {
      mkDerivation {
        pname = "test-framework-smallcheck";
        version = "0.2";
-       sha256 = "1xpgpk1gp4w7w46b4rhj80fa0bcyz8asj2dcjb5x1c37b7rw90b0";
+       sha256 = "6081c4f35967b0d0cb92ac09a915fa9e2da01c401266b20ce18793fbc2bceff6";
        libraryHaskellDepends = [
          base smallcheck test-framework transformers
        ];
@@ -129112,7 +129505,7 @@ self: {
      mkDerivation {
        pname = "test-framework-testing-feat";
        version = "0.1.0.1";
-       sha256 = "0pf07psqc4ihg0wrqqm127hd9qjbllmqw9lzf1ridg6r3xs63994";
+       sha256 = "24a561741fd9bc1673709f268e2ba54be2d4e011a1629c3978301286f53dc05d";
        libraryHaskellDepends = [ base test-framework testing-feat ];
        testHaskellDepends = [ base test-framework testing-feat ];
        homepage = "http://github.com/jfischoff/test-framework-testing-feat";
@@ -129127,7 +129520,7 @@ self: {
      mkDerivation {
        pname = "test-framework-th";
        version = "0.2.4";
-       sha256 = "12lw7yj02jb9s0i7rb98jjam43j2h0gzmnbj9zi933fx7sg0sy4b";
+       sha256 = "8b780d9e3edd8d91e24f72d9fa1f80420e52959428ad7c22d0694901a43f9c8a";
        libraryHaskellDepends = [
          base haskell-src-exts language-haskell-extract regex-posix
          template-haskell test-framework
@@ -129144,7 +129537,7 @@ self: {
      mkDerivation {
        pname = "test-framework-th-prime";
        version = "0.0.8";
-       sha256 = "0gb7bpdxzsd8fnh4ck4p1ks7nxrk7fsw97x90d4zjds5hnw3hchr";
+       sha256 = "193238b8854537f94903a99fc4b53b33777bf40c974c46a075a8e9dfdb5d673d";
        libraryHaskellDepends = [
          base cpphs haskell-src-exts template-haskell test-framework
        ];
@@ -129157,7 +129550,7 @@ self: {
      mkDerivation {
        pname = "test-invariant";
        version = "0.4.5.0";
-       sha256 = "0ck3kk7pmj1679ddmrysx5j3y27619ar1b2pny45mskz3g6vyvrh";
+       sha256 = "306fbfcd1b7fea5a88b757ac90550ae6083f64e9dae7da5a3a26c87acf9c6332";
        libraryHaskellDepends = [ base QuickCheck ];
        testHaskellDepends = [ base QuickCheck tasty tasty-quickcheck ];
        homepage = "https://github.com/knupfer/test-invariant";
@@ -129170,7 +129563,7 @@ self: {
      mkDerivation {
        pname = "test-pkg";
        version = "0.3.0.0";
-       sha256 = "0fncybd3sxrbnrd4l1hri18rhfg9h0fm3k4305iwh4l65fbwg2n8";
+       sha256 = "c88ac7972b8612c8630183cc511d80e93998518819064a5ab62b773ddaf2cc3a";
        libraryHaskellDepends = [ base ];
        jailbreak = true;
        description = "Just tests Hackage";
@@ -129188,7 +129581,7 @@ self: {
      mkDerivation {
        pname = "test-sandbox";
        version = "0.1.5";
-       sha256 = "1cknqblzf2wqq46casmfq00lx4zh3y9g07bqsbchxbq4xmd000js";
+       sha256 = "5a02005aed04af0ed9d2781df0921ff0934e01c0ae6ac50cc1980bf7e9c276b2";
        libraryHaskellDepends = [
          base bytestring cereal containers data-default directory filepath
          lifted-base monad-control monad-loops mtl network process random
@@ -129215,7 +129608,7 @@ self: {
      mkDerivation {
        pname = "test-sandbox-compose";
        version = "0.1.3";
-       sha256 = "1yqh5b3gzmwqf0wj491pmkvbn9jzpg36bh427vkl1w6yj5c4ha7x";
+       sha256 = "fd28485891def040e73e82c065c6bb5f26bbf6ac372422397098d7ffc62a10fb";
        isLibrary = true;
        isExecutable = true;
        libraryHaskellDepends = [
@@ -129241,7 +129634,7 @@ self: {
      mkDerivation {
        pname = "test-sandbox-hunit";
        version = "0.1.1";
-       sha256 = "1pdxwbs3508s9j1409bvpjipbqz8ymch633r6gyrirmr1r1zp3dy";
+       sha256 = "be8dfb430eb9e698fd33790c0359f5e8e375a3bc7b2540824c1a8132f4e2bddd";
        libraryHaskellDepends = [ base HUnit lifted-base test-sandbox ];
        homepage = "http://gree.github.io/haskell-test-sandbox/";
        description = "HUnit convenience functions for use with test-sandbox";
@@ -129255,7 +129648,7 @@ self: {
      mkDerivation {
        pname = "test-sandbox-quickcheck";
        version = "0.1.0";
-       sha256 = "0gijq6qwcljq2kvh08nffb6d9qblwpj4hw2jlxidvxy1hzbsgiyi";
+       sha256 = "d1c7a7d787c1f7dd62a7527048e4e574e1d4cc72ce2200f7145852c6b1c1323e";
        libraryHaskellDepends = [
          base mtl QuickCheck random test-sandbox transformers
        ];
@@ -129269,7 +129662,7 @@ self: {
      mkDerivation {
        pname = "test-shouldbe";
        version = "0.2.1.1";
-       sha256 = "0wagfhljym2mnwpxld8dcf4qcdbp3d9liyf9mcigd4kiy5sdhfx4";
+       sha256 = "a43bd874f17192f622abc9f948531b77358689630d35da2fb755542f29744f71";
        libraryHaskellDepends = [ base HUnit ];
        testHaskellDepends = [ base hspec hspec-discover silently ];
        jailbreak = true;
@@ -129284,7 +129677,7 @@ self: {
      mkDerivation {
        pname = "test-simple";
        version = "0.1.7";
-       sha256 = "1p9y15vv23j1qn3shxl2wqb8skh0n53vrb39qv1nvff9bclxldka";
+       sha256 = "6a36da295bc9b96dc3c669acbc47b1004e8d16e68276a887c5410eb177093edd";
        libraryHaskellDepends = [
          base mtl QuickCheck state-plus template-haskell
        ];
@@ -129301,7 +129694,7 @@ self: {
      mkDerivation {
        pname = "testPkg";
        version = "0.0";
-       sha256 = "0lppzyh0qxqry8a2d1yqrin51kizw2hl937pxg2a6pi34grlhdd0";
+       sha256 = "a03548f323235ea3c4ebf78c44a1e03fce506cccd8872614f219770ca0fff752";
        isLibrary = false;
        isExecutable = true;
        executableHaskellDepends = [ base ];
@@ -129317,7 +129710,7 @@ self: {
      mkDerivation {
        pname = "testing-feat";
        version = "0.4.0.2";
-       sha256 = "15gi6w7p4alnih9grklhhr8338y1aal07admbz4n2f724hnhyb2j";
+       sha256 = "522c0f2d24e23861c95fb5a903a852c1a331508690cefc128c962a720f37f195";
        revision = "1";
        editedCabalFile = "0168dde1e9ac0e7a1f80a33c12a6c5d2b7c5e59e4dcd060ffb8d82f100c4dd3f";
        libraryHaskellDepends = [
@@ -129332,7 +129725,7 @@ self: {
      mkDerivation {
        pname = "testing-type-modifiers";
        version = "0.1.0.1";
-       sha256 = "1wh2n95n39ivv6kbqn42vbzrj8zagsmk6f2al2qj40bg5kgdl2q5";
+       sha256 = "050bdade2c6f0122b1a04a3833ab7eea2399ffda8258bca6d93ba6614bb202f2";
        libraryHaskellDepends = [ base ];
        description = "Data type modifiers for property based testing";
        license = stdenv.lib.licenses.publicDomain;
@@ -129345,7 +129738,7 @@ self: {
      mkDerivation {
        pname = "testloop";
        version = "0.1.1.0";
-       sha256 = "1bygfdcnd0y60jhyp34zkss2cxr3s2jq6ysxm0w9c4vhl361ib7z";
+       sha256 = "ffac18cca070139638a85d7b83a5d0237726b49e9f8ceba104c683665973cfaf";
        libraryHaskellDepends = [
          base Cabal directory filepath fsnotify hint mtl system-filepath
          time unix
@@ -129363,7 +129756,7 @@ self: {
      mkDerivation {
        pname = "testpack";
        version = "2.1.3.0";
-       sha256 = "1rq5d64d7j3gpgbfxmfr4xmzizjy0ricw5ghrakv8gzvxmi2bn4p";
+       sha256 = "97d82562edfb3fb4a7caf015ce62065efef86b27d9d5eed6bb6fc8d3886905e7";
        libraryHaskellDepends = [
          base containers HUnit mtl QuickCheck random
        ];
@@ -129378,7 +129771,7 @@ self: {
      mkDerivation {
        pname = "testpattern";
        version = "0.1";
-       sha256 = "0a0kw5546z5jydk6dq2p16p2kpwv7fnmy1m907m3x6n580i1vh3l";
+       sha256 = "74c01d2240c59a3eea01a9065fad3b9bdf29ae0957e06666f3b27c434ae11328";
        isLibrary = false;
        isExecutable = true;
        executableHaskellDepends = [ base filepath gtk ];
@@ -129394,7 +129787,7 @@ self: {
      mkDerivation {
        pname = "testrunner";
        version = "0.9.1";
-       sha256 = "1887g3wn5mnlbxj4vbzv0zm3gwaj9ycr9sk7hy27qbb2x7c30iaw";
+       sha256 = "5c4530d8e9622d7c848767ea94994f52f137ea07fbaf4d645fd4d662f97807a1";
        libraryHaskellDepends = [
          base HUnit QuickCheck random regex-compat stm
        ];
@@ -129408,7 +129801,7 @@ self: {
      mkDerivation {
        pname = "tetris";
        version = "0.27178";
-       sha256 = "10wlw1frkaa3j8mb8lxgpvxcx87m8wdpca3mli9c5kirdm51vjgw";
+       sha256 = "fcc91d4a6d39cec252a47528761b47f5a0cefabeaf53b42a9243a9995de09483";
        isLibrary = false;
        isExecutable = true;
        executableHaskellDepends = [ base GLUT random ];
@@ -129423,7 +129816,7 @@ self: {
      mkDerivation {
        pname = "tex2txt";
        version = "0.1.0.0";
-       sha256 = "1q41kphll7xhbccwyvlsvk5vxisig23ipmcqf7v9qc3rx1hb0p0w";
+       sha256 = "1c5cb060e879309cf67198d51b877851c7becbdc9a6ecf195bb01f4ae19d81e0";
        isLibrary = true;
        isExecutable = true;
        libraryHaskellDepends = [ base containers deepseq parsec ];
@@ -129443,7 +129836,7 @@ self: {
      mkDerivation {
        pname = "texmath";
        version = "0.8.2.2";
-       sha256 = "1wy2rr18wsn9q06arrxibahpsnr8bqrzsimmpgwji6nxpzc95x51";
+       sha256 = "a1f492d8bfdd9a28f9bbb546fd335e285b7da15ab1e7ac0cc0c96a8e42cec2f3";
        isLibrary = true;
        isExecutable = true;
        libraryHaskellDepends = [
@@ -129467,7 +129860,7 @@ self: {
      mkDerivation {
        pname = "texrunner";
        version = "0.0.1.0";
-       sha256 = "1p7q9fz6f56wcm9q0xap17xc2r9a01qf8gdlrbdgryv25fp0lhcs";
+       sha256 = "9a410aae2b62fbfcdacab43de470002a65c1fa095775805365dc1467be4bf8dc";
        libraryHaskellDepends = [
          attoparsec base bytestring directory filepath io-streams mtl
          process temporary
@@ -129489,7 +129882,7 @@ self: {
      mkDerivation {
        pname = "text";
        version = "1.2.1.3";
-       sha256 = "0gzqx5cpkdhshbz9xss51mpyq23pnf8dwjz4h3irbv2ryaa4qdlq";
+       sha256 = "98364c94f259ec95e380e44bde90b37708ec6f0d45eb9efe821ab67959e9f83f";
        libraryHaskellDepends = [
          array base binary bytestring deepseq ghc-prim integer-gmp
        ];
@@ -129510,7 +129903,7 @@ self: {
      mkDerivation {
        pname = "text-and-plots";
        version = "0.2.1.0";
-       sha256 = "0fjwjdr6pbqfzlyi75apfclsq07qld4yj4h574pgyc22lnk2z9z8";
+       sha256 = "e8a72fa6a54230ff2e390512e949a3f800ac29735795133dfd0eaf6b72935c3a";
        libraryHaskellDepends = [
          base blaze-html bytestring containers markdown text
          unordered-containers
@@ -129525,7 +129918,7 @@ self: {
      mkDerivation {
        pname = "text-binary";
        version = "0.2.1";
-       sha256 = "00paqwnngd9l88zhah9wqg4wr41mrs30xm49w8xq337yxcvz48nz";
+       sha256 = "df22f237ebfe8c813be289d40e86ce3590ccc9c33c41053f4234b5672dc7ea02";
        libraryHaskellDepends = [ base binary text ];
        homepage = "https://github.com/kawu/text-binary";
        description = "Binary instances for text types";
@@ -129539,7 +129932,7 @@ self: {
      mkDerivation {
        pname = "text-format";
        version = "0.3.1.1";
-       sha256 = "02zfgzfjvkaxbma1h2gr95h10c8q9gyaadag41q579j68iv15qbd";
+       sha256 = "6de112764446a65370204f35a5fc4b1831106049f90918545d5dcd2ddd7fee0b";
        libraryHaskellDepends = [
          array base double-conversion ghc-prim integer-gmp old-locale text
          time transformers
@@ -129554,7 +129947,7 @@ self: {
      mkDerivation {
        pname = "text-format-simple";
        version = "1.1.0";
-       sha256 = "0iqs3v03kirjczlp7jpqdqzrfvqsbm260g110abkbpbxws3szqhk";
+       sha256 = "13e2af87e67ddd359702213c60445d1a6f973f6ef8ca73e96732c739c01e1a47";
        libraryHaskellDepends = [ base MissingH ];
        description = "Simple text formatting library";
        license = stdenv.lib.licenses.bsd3;
@@ -129568,7 +129961,7 @@ self: {
      mkDerivation {
        pname = "text-icu";
        version = "0.7.0.1";
-       sha256 = "0y3z5jda7v2iyll2148ivxfd2yhp27d3ryxrspp0cdq394klqxp2";
+       sha256 = "e2764c2749033706eed5b9fb3cda11177ad15cdf11912028f551eca39a2c7f78";
        libraryHaskellDepends = [ base bytestring deepseq text ];
        librarySystemDepends = [ icu ];
        testHaskellDepends = [
@@ -129588,7 +129981,7 @@ self: {
      mkDerivation {
        pname = "text-icu-translit";
        version = "0.1.0.7";
-       sha256 = "1qfmkydayqj1knlvfs1l6nq42a4y81k5z2g87lvzafrylyjjd002";
+       sha256 = "028026a5a73e3bf5373de8895f66409e2841b0353468b7a99d4162af9a9fd5e1";
        libraryHaskellDepends = [ base text ];
        librarySystemDepends = [ icu ];
        testHaskellDepends = [
@@ -129606,7 +129999,7 @@ self: {
      mkDerivation {
        pname = "text-json-qq";
        version = "0.4.1";
-       sha256 = "137m593yz5gl6jj7mi1f9kjsgi1np4n6707aqp94iw0qzxj8hdhg";
+       sha256 = "0f368864ff18f048d2c5ea80632cb936c4a7e54c2ec47aa434f495ef472af58c";
        libraryHaskellDepends = [
          base haskell-src-meta json json-qq parsec template-haskell
        ];
@@ -129623,7 +130016,7 @@ self: {
      mkDerivation {
        pname = "text-latin1";
        version = "0.3";
-       sha256 = "1cs09qwkcljbnckakzr1wnpclkzjb0in3nnz6fpjyl4mxp5bqaw9";
+       sha256 = "892bbccaed95502faf33dfda612358f24fcaaee521ffa926b34b5236394e40b3";
        libraryHaskellDepends = [
          base bytestring case-insensitive data-checked hashable text
        ];
@@ -129640,7 +130033,7 @@ self: {
      mkDerivation {
        pname = "text-ldap";
        version = "0.1.1.6";
-       sha256 = "12r0bcj83qfaaj6q1sw21dh3y4c82rxas1s5nzyn650pfnpvv2mq";
+       sha256 = "b88abdaf75171463fdb74507ad7a1688113f600b82eb808d54cae181245b208b";
        isLibrary = true;
        isExecutable = true;
        libraryHaskellDepends = [
@@ -129660,7 +130053,7 @@ self: {
      mkDerivation {
        pname = "text-locale-encoding";
        version = "0.1.0.2";
-       sha256 = "1ls41s45qwrmmac8k1gryvxbhhczqy2wanwanw48m7xnbv52p9fg";
+       sha256 = "cfa52bca5eb69f8a08b78a5bc585c79f41b8faf6f9858998aa35735c880e44d3";
        libraryHaskellDepends = [ base bytestring bytestring-handle text ];
        homepage = "https://github.com/exbb2/text-locale-encoding";
        description = "Encode and decode Text to/from ByteString using TextEncoding";
@@ -129672,7 +130065,7 @@ self: {
      mkDerivation {
        pname = "text-manipulate";
        version = "0.2.0.1";
-       sha256 = "0bwxyjj3ll45srxhsp2ihikgqglvjc6m02ixr8xpvyqwkcfwgsg0";
+       sha256 = "e0e9c71d9b1cfb7d3bca3d0a500d939b3efc6684515c0d7bd685503aa4f49d2f";
        libraryHaskellDepends = [ base text ];
        testHaskellDepends = [ base tasty tasty-hunit text ];
        homepage = "https://github.com/brendanhay/text-manipulate";
@@ -129687,7 +130080,7 @@ self: {
      mkDerivation {
        pname = "text-normal";
        version = "0.2.1.0";
-       sha256 = "10cxvn450q2fdjxly72m20x2yikkvwx3dvyqs7b992c2dr1zc1iv";
+       sha256 = "3b06f6436e828994d6d1d8ef363adf73462f3a10551c4fbb6c4e605088dd9d81";
        libraryHaskellDepends = [ base deepseq text text-icu ];
        testHaskellDepends = [
          base hspec QuickCheck quickcheck-instances
@@ -129703,7 +130096,7 @@ self: {
      mkDerivation {
        pname = "text-position";
        version = "0.1.0.0";
-       sha256 = "0cdi5kwpwvzmadhgkgnwax4jhllm6gjrsg1y3f3fp12x28nml1g8";
+       sha256 = "e8055a2d125d84eb861b3e3c9de5339552284957dcbef96053f56f7ef92cb131";
        revision = "1";
        editedCabalFile = "45fd633a94e0a13dbaeeb1791725a72d185f54027569e967f8006f07df67d586";
        libraryHaskellDepends = [ base regex-applicative ];
@@ -129721,7 +130114,7 @@ self: {
      mkDerivation {
        pname = "text-printer";
        version = "0.4";
-       sha256 = "0jcixgxln4c12nzmj50g3mmslki6f083xjrm9hr6hqvqzffxny5q";
+       sha256 = "b878db9dfb786368324c35cb3e1070264eaa6b1d0f1459bf1581114bfbeb9149";
        libraryHaskellDepends = [
          base bytestring pretty semigroups text text-latin1
        ];
@@ -129740,7 +130133,7 @@ self: {
      mkDerivation {
        pname = "text-regex-replace";
        version = "0.1.1.0";
-       sha256 = "0p8xjw6srlb23giqrb3qay1hd1jq3gd9im0v7fnr8yifc0ri6piz";
+       sha256 = "3f5e1333602e7a94ad3b1bd498da1b588606835778ac8ce31b62d1ac0d971d5d";
        libraryHaskellDepends = [ attoparsec base text text-icu ];
        testHaskellDepends = [
          base hspec QuickCheck smallcheck text text-icu
@@ -129755,7 +130148,7 @@ self: {
      mkDerivation {
        pname = "text-register-machine";
        version = "0.4.0";
-       sha256 = "0g0iihfin5vjfk69r7jjw4vs3l1k3f0kkg3bbc4xqm274vd72bph";
+       sha256 = "f02e71da264754dc095b6bbc39811b33d0a137e1529e9ccc7472171b1d8c113c";
        libraryHaskellDepends = [ base containers mtl vector ];
        jailbreak = true;
        homepage = "https://github.com/acfoltzer/text-register-machine";
@@ -129769,7 +130162,7 @@ self: {
      mkDerivation {
        pname = "text-render";
        version = "0.1.0.2";
-       sha256 = "17fgnddp4cfh9l6vlwyq4fnrws56gxxgdvq06fnvz0x8rd0c72wp";
+       sha256 = "978bc340cba883bfad3300eff67a7fa6689ead23d873ba0d4dd031725bb3cf9d";
        libraryHaskellDepends = [ base classy-prelude mtl parsec text ];
        homepage = "http://github.com/thinkpad20/text-render";
        description = "A type class for rendering objects as text, pretty-printing, etc";
@@ -129786,7 +130179,7 @@ self: {
      mkDerivation {
        pname = "text-show";
        version = "2";
-       sha256 = "152nccaz9m337rrv7i6z1vjj73xdcp410fgxcs8imhr125fs6r2z";
+       sha256 = "5f64a35d1121c31a9166fd3910c865ad8f23e50edfc4b3733e63d4f415635694";
        libraryHaskellDepends = [
          array base base-compat bytestring bytestring-builder containers
          generic-deriving ghc-prim integer-gmp nats semigroups tagged
@@ -129814,7 +130207,7 @@ self: {
      mkDerivation {
        pname = "text-show-instances";
        version = "2.0.1";
-       sha256 = "1k5lwkfg8vrrmhm0xir1shplygvh2xki2dw13z56xrkkm8ygv3cx";
+       sha256 = "9d8dfd3caa73e66eca1f8137116717703f4f2fd421c70e2aac396ff4dce4b4cc";
        libraryHaskellDepends = [
          base base-compat bifunctors binary bytestring containers directory
          haskeline hoopl hpc old-locale old-time pretty random semigroups
@@ -129838,7 +130231,7 @@ self: {
      mkDerivation {
        pname = "text-stream-decode";
        version = "0.1.0.5";
-       sha256 = "1s2lncs5k8rswg1bpf4vz5p1maj46bsgf7ar4lzcla9bf3f4bppy";
+       sha256 = "fede45dc702b29ca3e25591df7f43244aa1a6ef99bb8bbc2e33aa35934b354e8";
        revision = "1";
        editedCabalFile = "d4ea8ff401a3ccbd8a6ce2918385bac4859150047ce9b7f752ff5575db71e9fd";
        libraryHaskellDepends = [ base bytestring text ];
@@ -129855,7 +130248,7 @@ self: {
      mkDerivation {
        pname = "text-utf7";
        version = "0.1.0.0";
-       sha256 = "0kcbw9gb8mwvc4p10m0g5gplgi38qlnnc0plaw22l1qdkx0k8ilv";
+       sha256 = "9b4634419f0d072a0457f402662dc568c447ef2b0f54102e619b57b45ee28b4d";
        libraryHaskellDepends = [ base bytestring text ];
        testHaskellDepends = [
          base bytestring quickcheck-instances tasty tasty-hunit
@@ -129873,7 +130266,7 @@ self: {
      mkDerivation {
        pname = "text-xml-generic";
        version = "0.1.1";
-       sha256 = "1w3gqv94yj1j71qhs1s6sxnxax8ahxwsz7brv0w79sg3r9akl31h";
+       sha256 = "300c3a55cae3e97438d8799daf79870a75d56dd746070d713832484fd2c66ff0";
        libraryHaskellDepends = [
          base bytestring containers haskell98 mtl not-in-base split syb
          template-haskell xml
@@ -129889,7 +130282,7 @@ self: {
      mkDerivation {
        pname = "text-xml-qq";
        version = "0.1";
-       sha256 = "0311in43n89bk1fg4y9qglvbbl47ygvcvr0f7zpr8bpaqbb1ard5";
+       sha256 = "a56515d6c2ea2e94ef3f0ee4cdf6f387d0b5367d3879f25c982b213b888d210c";
        libraryHaskellDepends = [ base parsec template-haskell xml ];
        homepage = "http://www.github.com/finnsson/text-xml-qq";
        description = "Quasiquoter for xml. XML DSL in Haskell.";
@@ -129902,7 +130295,7 @@ self: {
      mkDerivation {
        pname = "text-zipper";
        version = "0.2.1";
-       sha256 = "1a4kzn2s0ah1sizbdj6fks8zb4wmsx8cqjml4id9xj94zp4akq2r";
+       sha256 = "59e0a9c8fd24c99e5a24b44acc50d79593f5919ecec8b67ed4012aa085fd93a8";
        libraryHaskellDepends = [ base text ];
        description = "A text editor zipper library";
        license = stdenv.lib.licenses.bsd3;
@@ -129915,7 +130308,7 @@ self: {
      mkDerivation {
        pname = "text1";
        version = "0.0.3";
-       sha256 = "0l3xh8hv5xwfib63llikhnp4w3jx8nwc2rmj4sy7yd5acxgj39sc";
+       sha256 = "4ca7215f67aa347fbc26b266c1b8455d0e4eae8533523acc8a8ef7b221827d50";
        libraryHaskellDepends = [ base binary lens semigroups text ];
        testHaskellDepends = [
          base directory doctest filepath QuickCheck template-haskell
@@ -129930,7 +130323,7 @@ self: {
      mkDerivation {
        pname = "textPlot";
        version = "0.2";
-       sha256 = "0sy5lf5aa3yl3wy199ifb14cnkq5xghcv8m9ny9vzhyyk00h0j6y";
+       sha256 = "de48000198dec3bf93b7a9a2cde0eb054fcb48582ea6143c1fd40fa58aa3c56b";
        libraryHaskellDepends = [ array base ];
        description = "Plot functions in text";
        license = stdenv.lib.licenses.bsd3;
@@ -129942,7 +130335,7 @@ self: {
      mkDerivation {
        pname = "textmatetags";
        version = "0.0.1.2";
-       sha256 = "1q47s8z6igi21m4gqbyizlgiq1z7frk9pi4jppckxmpcjs5xd0gk";
+       sha256 = "f381d68b96ecd63ed9bd92c49b6676e7071c1ffdd12ffc480d22be683ed287e0";
        isLibrary = false;
        isExecutable = true;
        executableHaskellDepends = [ base haskell98 process ];
@@ -129959,7 +130352,7 @@ self: {
      mkDerivation {
        pname = "textocat-api";
        version = "0.1.0.0";
-       sha256 = "0cljy3s13xqdvxffpp74iwamfvkmq7s49vpc8vpxnq2fvh6bmkx9";
+       sha256 = "a9cfba0cdc4e60dbef46ecee44f4c1756e57158fe4dceb5cdf0df711f4f09232";
        libraryHaskellDepends = [
          aeson base bytestring conduit http-conduit http-types resourcet
          text transformers
@@ -129979,7 +130372,7 @@ self: {
      mkDerivation {
        pname = "texts";
        version = "0.4.0";
-       sha256 = "15r3lrd6qrhhsll6qlbvgd5g545mj2s6banahwlibcimqqdw8s9h";
+       sha256 = "3069c41bc635b2152987caaa65b490b590f24a7b7b516c28d510666c5aa62397";
        description = "None";
        license = stdenv.lib.licenses.bsd3;
        hydraPlatforms = stdenv.lib.platforms.none;
@@ -129990,7 +130383,7 @@ self: {
      mkDerivation {
        pname = "tf-random";
        version = "0.5";
-       sha256 = "0445r2nns6009fmq0xbfpyv7jpzwv0snccjdg7hwj4xk4z0cwc1f";
+       sha256 = "2e30cec027b313c9e1794d326635d8fc5f79b6bf6e7580ab4b00186dadc88510";
        libraryHaskellDepends = [ base primitive random time ];
        description = "High-quality splittable pseudorandom number generator";
        license = stdenv.lib.licenses.bsd3;
@@ -130001,7 +130394,7 @@ self: {
      mkDerivation {
        pname = "tfp";
        version = "1.0";
-       sha256 = "03jf2dk7sgggnr72wk6chxs3l4aycpmnapdjfm5f9i8wr0spga4l";
+       sha256 = "94a87735c81cc5e44a75b25d65eb655e113a7487cc4c2e4eb6ef3d7d66134e0e";
        libraryHaskellDepends = [ base utility-ht ];
        testHaskellDepends = [ base QuickCheck ];
        homepage = "http://www.haskell.org/haskellwiki/Type_arithmetic";
@@ -130014,7 +130407,7 @@ self: {
      mkDerivation {
        pname = "tfp-th";
        version = "0.8";
-       sha256 = "139dcwvik8yfpl3i71ddjml1xn126qrx1mbxa4mcwfm6q81fvkzm";
+       sha256 = "f5cfed02c2a63ace2a517dd5d0333622d81e6895ad851307bdcea31937672d8d";
        libraryHaskellDepends = [ base template-haskell tfp ];
        jailbreak = true;
        homepage = "http://www.haskell.org/haskellwiki/Type_arithmetic";
@@ -130030,7 +130423,7 @@ self: {
      mkDerivation {
        pname = "tftp";
        version = "0.2";
-       sha256 = "0d95nhz5z0zi665h3npcags71zgprgrh7rq86yzn3wamnavlvswn";
+       sha256 = "96eb4db7b255f161bf3708e703f3cbf7fd70f453ecda018b31f1835f3eb42535";
        isLibrary = true;
        isExecutable = true;
        libraryHaskellDepends = [
@@ -130054,7 +130447,7 @@ self: {
      mkDerivation {
        pname = "tga";
        version = "0.2";
-       sha256 = "0lpc5z575y7cq03ww2knr5qdkfb36qnim5y1gkh552r9k3pfdjhf";
+       sha256 = "0ecae6ee98298b52e07cc1971a2d3663b9d970c9760ace07c0ecf872ca2fec52";
        libraryHaskellDepends = [ base bytestring ];
        jailbreak = true;
        description = "Reading and writing of tga image files";
@@ -130069,7 +130462,7 @@ self: {
      mkDerivation {
        pname = "th-alpha";
        version = "0.2.0.2";
-       sha256 = "1syp28514wwj2c66jcx89zl5ax311jhywqgpcpqlfapfwqphysgk";
+       sha256 = "f3690f2fe6ee2a47f165f761eea10c617455e84fa833690c139273120a12d7eb";
        libraryHaskellDepends = [
          base containers mmorph mtl template-haskell th-desugar transformers
        ];
@@ -130086,7 +130479,7 @@ self: {
      mkDerivation {
        pname = "th-build";
        version = "0.4.0.0";
-       sha256 = "0f16cgwkmqhkm5nxyic0f56swzm96yqmagmbh7vjd203mn9zv9z6";
+       sha256 = "e6a7fd93ad038826f781ab3e55b137a97eae4d718045df6da913e23af9632638";
        libraryHaskellDepends = [ base template-haskell ];
        jailbreak = true;
        homepage = "https://github.com/DanielSchuessler/th-build";
@@ -130103,7 +130496,7 @@ self: {
      mkDerivation {
        pname = "th-context";
        version = "0.22";
-       sha256 = "0zzrb5dzxcn2dxhqniv3nx4kasgpx7mck730y9hgjink58wqsdx4";
+       sha256 = "a4378d392ad346f960f2609cc9eae9f7693549b763478b616fc2b2fe5b59f97f";
        libraryHaskellDepends = [
          base containers data-default haskell-src-exts lens mtl
          mtl-unleashed syb template-haskell th-desugar th-orphans
@@ -130126,7 +130519,7 @@ self: {
      mkDerivation {
        pname = "th-desugar";
        version = "1.5.4";
-       sha256 = "1dwp77gys84bb0v2af33knhwnj37rg5r662d9kcvhvqk5z4i6c68";
+       sha256 = "c83013c92f136fb8d94c4d1893cbcb6748cba19d63382536588b20eddf3997b7";
        libraryHaskellDepends = [
          base containers mtl syb template-haskell th-lift th-orphans
        ];
@@ -130144,7 +130537,7 @@ self: {
      mkDerivation {
        pname = "th-expand-syns";
        version = "0.3.0.6";
-       sha256 = "03qv93pyqk8all39knsf0mzmbfdck5x61kqnyn8rbisw5c1ymx6j";
+       sha256 = "d2f4ea032b5cc79591f516cf607a99acb9557f054edb9906a50a4decef481b0f";
        libraryHaskellDepends = [ base containers syb template-haskell ];
        testHaskellDepends = [ base template-haskell ];
        description = "Expands type synonyms in Template Haskell ASTs";
@@ -130156,7 +130549,7 @@ self: {
      mkDerivation {
        pname = "th-extras";
        version = "0.0.0.2";
-       sha256 = "15sqf2jjnqcssq8hp80fk0ysgwqykjjc31gvvmzg4sypskpjs8cl";
+       sha256 = "94212defd4d76bf27eddfb85c1a49c1ef3a73d980ea00b11d69a612ba5705897";
        libraryHaskellDepends = [ base syb template-haskell ];
        homepage = "https://github.com/mokus0/th-extras";
        description = "A grab bag of functions for use with Template Haskell";
@@ -130168,7 +130561,7 @@ self: {
      mkDerivation {
        pname = "th-fold";
        version = "0.0.0.1";
-       sha256 = "10n1aw74xi5gzs1847dhiv6yjxcz99idw91hvf34zhhs8hp8zf2z";
+       sha256 = "5fb88f2e441ac24f86db3024de624a9f75e9cd8eb01d8282feafc44e0e57c182";
        libraryHaskellDepends = [ base template-haskell ];
        homepage = "http://code.haskell.org/~mokus/th-fold";
        description = "TH fold generator";
@@ -130180,7 +130573,7 @@ self: {
      mkDerivation {
        pname = "th-inline-io-action";
        version = "0.1.0.0";
-       sha256 = "1yvxi3n1nafr37zmj0dd83sf2jq4c0sss34k4q5f64vrai8a6zwg";
+       sha256 = "8f7fa350547913e30a26930cad3560044be1f440ad0159ff19d9291bec887dfb";
        libraryHaskellDepends = [ base template-haskell ];
        homepage = "https://github.com/tolysz/inline-io-action";
        description = "Simple inline IO action into compiled code using TH";
@@ -130194,7 +130587,7 @@ self: {
      mkDerivation {
        pname = "th-instance-reification";
        version = "0.1.4";
-       sha256 = "0cnq7qxqpc58a59iv8sfqrkhx9wkzpgn9l7r84kh0xa21w16inki";
+       sha256 = "71da68020f4275002741f9d064dffd93a70e67c64ea31d5351a8b08b3b3ed832";
        libraryHaskellDepends = [
          base containers list-extras loch-th placeholders template-haskell
          th-expand-syns
@@ -130218,7 +130611,7 @@ self: {
      mkDerivation {
        pname = "th-instances";
        version = "0.1.0.14";
-       sha256 = "1izamc2j1zjyrvzns7kj1mcma4bbmyd3sagbzxsyi4ja8kszcy0v";
+       sha256 = "1b78f6f5444a92e875ffeb293d9aaf6b1155590d721e6dffce5efe2005abeac7";
        libraryHaskellDepends = [
          base checkers derive mtl QuickCheck template-haskell th-kinds
          th-lift
@@ -130238,7 +130631,7 @@ self: {
      mkDerivation {
        pname = "th-kinds";
        version = "0.1.1";
-       sha256 = "0d8n0wnygdyi9qhkr7418f0227r3dcjwvmfhpw0kslryz0vqyf5b";
+       sha256 = "ab388f37f83e533d01bfd0d5cd256b231f218043819c3c214ed1b7e72d071635";
        libraryHaskellDepends = [ base containers mtl template-haskell ];
        jailbreak = true;
        description = "Automated kind inference in Template Haskell";
@@ -130251,7 +130644,7 @@ self: {
      mkDerivation {
        pname = "th-lift";
        version = "0.7.2";
-       sha256 = "0jl2x09mh9frsx5bccw8m4m3h72bncjaix9ylyfpvizisivj8p3m";
+       sha256 = "755c2477d4f1c77d9da73ef5a824b34b1c382aa98833b64ad7d9255813e8824a";
        libraryHaskellDepends = [ base template-haskell ];
        testHaskellDepends = [ base template-haskell ];
        homepage = "http://github.com/mboes/th-lift";
@@ -130266,7 +130659,7 @@ self: {
      mkDerivation {
        pname = "th-lift-instances";
        version = "0.1.5";
-       sha256 = "1j9j70344mi77923v78v3hfhwn72cpq92i87rqd7alvbhkhcny8z";
+       sha256 = "1f79cbe0846b53751ace074591f065e2580e1d1c1b9d3d443a275642063832c9";
        libraryHaskellDepends = [
          base bytestring containers template-haskell text th-lift vector
        ];
@@ -130287,7 +130680,7 @@ self: {
      mkDerivation {
        pname = "th-orphans";
        version = "0.12.2";
-       sha256 = "0435l20vzsr6p4app6riyf242hcqizbypf4f5v17wjy3ihw0jddb";
+       sha256 = "ab3509388cc34b7ec22e8eb8ebd78f98414184f3319b7b15b926ebbf81a06510";
        libraryHaskellDepends = [
          base mtl nats template-haskell th-lift th-reify-many
        ];
@@ -130303,7 +130696,7 @@ self: {
      mkDerivation {
        pname = "th-printf";
        version = "0.3.1";
-       sha256 = "089grlpavvqv90graa9rdwg9x1ph484g5bj7sfjklqy8mgwwqg7a";
+       sha256 = "ea3cccf9abc8633aa5d347aef20822f0869e1e6f3929951f481befad2ecd2f21";
        libraryHaskellDepends = [
          attoparsec base bytestring template-haskell text transformers
        ];
@@ -130322,7 +130715,7 @@ self: {
      mkDerivation {
        pname = "th-reify-many";
        version = "0.1.3";
-       sha256 = "00hryljcs434wcv1vaamfdbjk857f46djxv7mlwplkl3zsmfhlfx";
+       sha256 = "dd51e8aafe834e7a39ad6777d90c71a7a029577355a91d36e36410cd24f51902";
        libraryHaskellDepends = [
          base containers mtl safe template-haskell th-expand-syns
        ];
@@ -130337,7 +130730,7 @@ self: {
      mkDerivation {
        pname = "th-sccs";
        version = "0.0.0.20110723";
-       sha256 = "0vrjqwdjv2922kqmh57ypbslbv1m829wag78addqsr4vjd9b3zl6";
+       sha256 = "86feb152939b648d5b53e83cc5934035ec45f5bafe1458f11422892d1bc7326f";
        libraryHaskellDepends = [ base containers template-haskell ];
        description = "Binding group analysis in Template Haskell";
        license = stdenv.lib.licenses.bsd3;
@@ -130352,7 +130745,7 @@ self: {
      mkDerivation {
        pname = "th-typegraph";
        version = "0.28";
-       sha256 = "0dwkhrrcb5n3n06dr0ck613yr3j6f05sldnvrkb654xm69pw1qfc";
+       sha256 = "cce1c06f32b59362d6ccdb36aa0b70468eec47309381dc0cb0c396c572869337";
        libraryHaskellDepends = [
          base base-compat containers data-default haskell-src-exts lens mtl
          mtl-unleashed set-extra syb template-haskell th-desugar th-orphans
@@ -130375,7 +130768,7 @@ self: {
      mkDerivation {
        pname = "themoviedb";
        version = "1.1.1.0";
-       sha256 = "1859hbhznmp7x8kbqzrpyhndfy69jg01qrp1vh67557mznari6d8";
+       sha256 = "a8999895fdf594720cdce1661cc093c978d72cf4377fbc26eae756fbe182a9a0";
        isLibrary = true;
        isExecutable = true;
        libraryHaskellDepends = [
@@ -130402,7 +130795,7 @@ self: {
      mkDerivation {
        pname = "themplate";
        version = "1.2";
-       sha256 = "0ingf6f4d2a93jdcw0lij7l02gr7mfk97svhda94wx0k1lmj2li3";
+       sha256 = "2352212b0d13744e926a70eb93a6ab273f01e8919102ce9a1c4989469c71cf46";
        revision = "1";
        editedCabalFile = "9562873914a204ed7daf91844f70592385a93b6c348798dc8772b439436ca109";
        isLibrary = false;
@@ -130423,7 +130816,7 @@ self: {
      mkDerivation {
        pname = "theoremquest";
        version = "0.0.0";
-       sha256 = "05z0jppjbw70rlyh2qis27xp8vdx9fgn7i22ckxb0m2y75gffq61";
+       sha256 = "c160e75e395e54b0fa6442c4639f4bbd6d74fb113a62013dcde0f025ef95e017";
        libraryHaskellDepends = [ base HTTP json utf8-string ];
        jailbreak = true;
        description = "A common library for TheoremQuest, a theorem proving game";
@@ -130435,7 +130828,7 @@ self: {
      mkDerivation {
        pname = "theoremquest-client";
        version = "0.0.0";
-       sha256 = "0kdfbz5sa2gcy9znz4c2hnyni01vpabixrclg2gs7awysw8hiy3a";
+       sha256 = "6af80811d79eaba39f7894e51e97ba3b8068bd8582916f7ff2ec09a5cb5fae4d";
        isLibrary = false;
        isExecutable = true;
        executableHaskellDepends = [ base HTTP network theoremquest ];
@@ -130452,7 +130845,7 @@ self: {
      mkDerivation {
        pname = "these";
        version = "0.4.2";
-       sha256 = "0hs59i07k1lkynvdpymjvl1va2frc3aq6wyrmbi7mz3vmz0bjcp7";
+       sha256 = "e732b9c0af7bfc7ae2aad97383d560d909b503ddb2fadbb6f5938679404c4543";
        revision = "1";
        editedCabalFile = "02eb71fed8c848cc4f94f1181f09a6f9667caac38746f757bd57ca881aa47629";
        libraryHaskellDepends = [
@@ -130470,7 +130863,7 @@ self: {
      mkDerivation {
        pname = "thespian";
        version = "0.999";
-       sha256 = "0z3cqjcf6xr0z7g3s1jszcs39w43sl0793gl0qm3dklbginqbcnn";
+       sha256 = "d6b2856d7c8bce362a06f48d7400d583f03434fb5a063ddef92077e398c46c7c";
        libraryHaskellDepends = [ base containers mtl ];
        homepage = "http://bitbucket.org/alinabi/thespian";
        description = "Lightweight Erlang-style actors for Haskell";
@@ -130482,7 +130875,7 @@ self: {
      mkDerivation {
        pname = "theta-functions";
        version = "1.0.1";
-       sha256 = "0m9k1b75ja5a6vq7jdqzsbqjc4fh1kzy29rzss08ph6700bm6z8f";
+       sha256 = "0e7d531700c7c08b80d63f27e1ff0cd01126f1d21f3779f036aa2859ce0a3355";
        libraryHaskellDepends = [ base ];
        homepage = "https://github.com/hijarian/theta-functions";
        description = "Theta-functions implemented as trigonometric series";
@@ -130494,7 +130887,7 @@ self: {
      mkDerivation {
        pname = "thih";
        version = "1.0";
-       sha256 = "0ir8z7al3fxjwq5nb05l136k7vp82ag6khcyf9bvjcymlra4cs0m";
+       sha256 = "15684654a6d533b957729ec1699e12e8ee33cd08b480650be6b2bb41d5f92847";
        isLibrary = true;
        isExecutable = true;
        libraryHaskellDepends = [ base pretty ];
@@ -130511,7 +130904,7 @@ self: {
      mkDerivation {
        pname = "thimk";
        version = "0.3.1";
-       sha256 = "1pjz6rnbm1llxgp47fasv40w2vg197z582vf9mm7rhm5qjp25zi0";
+       sha256 = "20fe22aec4a5c27c6a4d6e0b54fe49e16dc101d95ab943eeeb9486ba6c365fde";
        isLibrary = false;
        isExecutable = true;
        executableHaskellDepends = [
@@ -130530,7 +130923,7 @@ self: {
      mkDerivation {
        pname = "thorn";
        version = "0.2";
-       sha256 = "1krxfsgj4ciifg76khsl4lw1nb40xx4gs07nwd84ail85s394h1h";
+       sha256 = "304092862e88464550e3f600fd48ef802c1b382554c369ce733132229f763dcf";
        revision = "1";
        editedCabalFile = "d19e959e95f55075f6f4f0013cbc980e2c351c871e3d9d5bbe2febafb7711b9a";
        libraryHaskellDepends = [
@@ -130548,7 +130941,7 @@ self: {
      mkDerivation {
        pname = "thread-local-storage";
        version = "0.1.0.3";
-       sha256 = "0ka6xrxzsw2z95qcc4v2hh4ldb22zkd5s62lns3v1853g4dw7k3l";
+       sha256 = "74ccc31b79a3a0b087b654185ddafc42ac4609846213c670495f70fd7bee464d";
        libraryHaskellDepends = [ base containers ];
        testHaskellDepends = [ atomic-primops base containers ];
        description = "Several options for thread-local-storage (TLS) in Haskell";
@@ -130560,7 +130953,7 @@ self: {
      mkDerivation {
        pname = "threadPool";
        version = "0.3.1";
-       sha256 = "18zr8k9sldbkvs5yw0ann92amri6dv2n8wws87lcqxgs52sw6pwi";
+       sha256 = "915fc3b528fa75cce8419a7364c56e26e6aa44b25601ee8bde7335aad344f9a3";
        isLibrary = false;
        isExecutable = true;
        executableHaskellDepends = [ base process ];
@@ -130574,7 +130967,7 @@ self: {
      mkDerivation {
        pname = "threadmanager";
        version = "0.1.7";
-       sha256 = "17s26hlailbr8c9d3dv1pwiy81m3nzr3sw0v9y716rmhldf7k09f";
+       sha256 = "2e81795ca3b066138e4f1b703df2b7a306e423bf61b7d1124379d1a82834429f";
        libraryHaskellDepends = [ base containers ];
        description = "(deprecated in favor of 'threads') Simple thread management";
        license = stdenv.lib.licenses.bsd3;
@@ -130587,7 +130980,7 @@ self: {
      mkDerivation {
        pname = "threads";
        version = "0.5.1.3";
-       sha256 = "04b4hjwv38iv48hdaxrw8ngrid6pgia32h6vci80szgpjxslrg82";
+       sha256 = "02bd4c7597f77d0d5064db4031547cd7b4989f453c77d520223ba2b1b9846411";
        libraryHaskellDepends = [ base stm ];
        testHaskellDepends = [
          base concurrent-extra HUnit stm test-framework test-framework-hunit
@@ -130602,7 +130995,7 @@ self: {
      mkDerivation {
        pname = "threads-pool";
        version = "0.1";
-       sha256 = "1x1yafxaaf8r02cqipqnm9shj74kja1bqdp0d1cq5kdhcnh22xkz";
+       sha256 = "7f7621a065b0cd825968e036bc8292931c0975aa16df8899001939a5ba533ef4";
        libraryHaskellDepends = [ base containers mtl stm ];
        description = "A library to operate with pool of haskell's IO threads";
        license = stdenv.lib.licenses.bsd3;
@@ -130616,7 +131009,7 @@ self: {
      mkDerivation {
        pname = "threads-supervisor";
        version = "1.0.3.0";
-       sha256 = "1iipljryqj1g06bqmlyvkxagq7l3rfx7w5d1ci5dw22qsrijnkmn";
+       sha256 = "b64e2b63d65808de4a64a1157ebacb831efc549fdbd38a97012f48ecb3a437c6";
        isLibrary = true;
        isExecutable = true;
        libraryHaskellDepends = [
@@ -130638,7 +131031,7 @@ self: {
      mkDerivation {
        pname = "threadscope";
        version = "0.2.7";
-       sha256 = "1dpxgzm29p07iy17hkfzki4c9ckhwx4acvjhlwxmpmaj2a1m6mnc";
+       sha256 = "cc5653831252d55b3ba7506ea648e770b2c4489cdf4d78828f07dc24ea7ffdb6";
        isLibrary = false;
        isExecutable = true;
        executableHaskellDepends = [
@@ -130657,7 +131050,7 @@ self: {
      mkDerivation {
        pname = "threefish";
        version = "0.2.6";
-       sha256 = "1v4vxm2yb7wmzkh9rsf5b6m04wjmy7yr7jq49b5msddjdzhfmf91";
+       sha256 = "21b9eae06fb2355dcb4a04cb93fdf1557202aa59c5e99ce0fc959fe545ed9bec";
        libraryHaskellDepends = [
          array base bytestring cereal crypto-api data-default entropy random
          tagged
@@ -130676,7 +131069,7 @@ self: {
      mkDerivation {
        pname = "threepenny-gui";
        version = "0.6.0.3";
-       sha256 = "04qrwvzz705s8aqb8f5vgakh78rv1w64ldv2mvm6fg3llfl5nlfd";
+       sha256 = "cd515ba8a3743c67eaae62374a0c0f3ba303a77abb38b4b042ba80f3ffe61913";
        isLibrary = true;
        isExecutable = true;
        libraryHaskellDepends = [
@@ -130699,7 +131092,7 @@ self: {
      mkDerivation {
        pname = "thrift";
        version = "0.9.2";
-       sha256 = "1c8x66agbbrcsk08i9ha3h9kdq97lnz8sby7xsjx84v5f6kmd7a4";
+       sha256 = "449d56a7716513d4a5eec72f8dbea527e136131c0aa688c0d42caff594311db1";
        libraryHaskellDepends = [
          attoparsec base binary bytestring containers ghc-prim hashable HTTP
          network network-uri QuickCheck split text unordered-containers
@@ -130716,7 +131109,7 @@ self: {
      mkDerivation {
        pname = "thrist";
        version = "0.3.0.2";
-       sha256 = "01y4s5mpk7d0y878fr40j9k19dryj37am9g86v2s9lr5d0q2nnqp";
+       sha256 = "175b2b306825d3a4c536e8a5aace903eb71466928064870ef2a09d796bd1c407";
        libraryHaskellDepends = [ base ];
        homepage = "http://heisenbug.blogspot.com/search/label/thrist";
        description = "Type-threaded list";
@@ -130728,7 +131121,7 @@ self: {
      mkDerivation {
        pname = "throttle";
        version = "3.0.0";
-       sha256 = "1yxmq7244a8bcw1jg00dqcpwzf8h1333c51k9d0v39flpkzp5qlc";
+       sha256 = "8ce272ffbcd4a5b1414b331436c60810b9cf2fc30d802703670b2942c4c1b5fb";
        description = "None";
        license = stdenv.lib.licenses.bsd3;
        hydraPlatforms = stdenv.lib.platforms.none;
@@ -130739,7 +131132,7 @@ self: {
      mkDerivation {
        pname = "through-text";
        version = "0.1.0.0";
-       sha256 = "1kdl36n98kajaa7v7js2sy8bi09p8rrxmlfcclcfc1l92bd2aclk";
+       sha256 = "933225da128906e61865ccd1da73463781b890d742cbb38f52524d94ac19b4cd";
        libraryHaskellDepends = [ base bytestring case-insensitive text ];
        homepage = "https://www.github.com/bergmark/through-text";
        description = "Convert textual types through Text without needing O(n^2) instances";
@@ -130751,7 +131144,7 @@ self: {
      mkDerivation {
        pname = "thumbnail";
        version = "0.8.0";
-       sha256 = "1ms7pzw4lrpkpv6sb0l7jvw5a0n5j7fc9wyi28bq7ik22d4sc8kd";
+       sha256 = "6d22a6491362c6831712d1f3c4dc91c50255f8968782a5cdbef3664af8bf47d7";
        libraryHaskellDepends = [ base bytestring gd ];
        homepage = "https://github.com/cutsea110/thumbnail";
        description = "generate thumbnail image";
@@ -130766,7 +131159,7 @@ self: {
      mkDerivation {
        pname = "thumbnail-plus";
        version = "1.0.5";
-       sha256 = "0320yfgnsazl7bxm9zf077mi4dgfmlcfnzy1qpdl9w3jl5i7z441";
+       sha256 = "81907f62a172f044dbc5c17feb18adee3512eb39c0fd54fb3af42b6d9ff3400c";
        libraryHaskellDepends = [
          base bytestring conduit conduit-extra data-default directory either
          gd imagesize-conduit resourcet temporary transformers
@@ -130789,7 +131182,7 @@ self: {
      mkDerivation {
        pname = "thyme";
        version = "0.3.5.5";
-       sha256 = "0v3rbjl92bqggsdra72zdq6rxzb2qf1268424p94225lnwgp1il4";
+       sha256 = "84c6701fb7b40841d22582202382c362fd9e0d6e5f1c959b7e0f2f91a85c796c";
        libraryHaskellDepends = [
          aeson attoparsec base bytestring containers deepseq mtl old-locale
          profunctors QuickCheck random text time vector vector-space
@@ -130814,8 +131207,8 @@ self: {
      }:
      mkDerivation {
        pname = "tianbar";
-       version = "0.4.6.3";
-       sha256 = "1ns1gsjqq1xcdxqw7xplcax88ydfx8pn6id42n5idmcbgxkjzm9p";
+       version = "0.4.8.0";
+       sha256 = "5ed0ad66ed6bfeb5b7145ce1e05d578963f8f7fec43c5474ca9a9023acb3cb16";
        isLibrary = true;
        isExecutable = true;
        libraryHaskellDepends = [
@@ -130837,7 +131230,7 @@ self: {
      mkDerivation {
        pname = "tic-tac-toe";
        version = "0.1";
-       sha256 = "0bdls2xz281zdxq5z6vbkahmf6bpiqr0ra823j21783jwiyh8j01";
+       sha256 = "0148047de472a013841c02a90c328e771957a19a6b9b5f706f3f20f1bbd0b42d";
        isLibrary = false;
        isExecutable = true;
        executableHaskellDepends = [ base glade gtk haskell98 ];
@@ -130855,7 +131248,7 @@ self: {
      mkDerivation {
        pname = "tickle";
        version = "0.0.4";
-       sha256 = "11zm6fwnykp6hlfp9d4xcvcvmczj5x77sfkkx6v1gwz3qfkf2qcj";
+       sha256 = "9261e1a6c3e3f317b6e9733a7d4e2ff2b3bad9669db4741d85e64e6fb933f587";
        libraryHaskellDepends = [
          base bifunctors bytestring lens mtl semigroupoids semigroups
          transformers validation
@@ -130868,6 +131261,21 @@ self: {
        license = stdenv.lib.licenses.bsd3;
      }) {};
 
+  "tictactoe3d" = callPackage
+    ({ mkDerivation, base, hArduino, tuples-homogenous-h98, vector }:
+     mkDerivation {
+       pname = "tictactoe3d";
+       version = "0.1.0.0";
+       sha256 = "e4f7b7559e187ac46167313a50ac8af17ddf26cdd83f3b5dd8eeb0bfb5a8fd72";
+       libraryHaskellDepends = [
+         base hArduino tuples-homogenous-h98 vector
+       ];
+       jailbreak = true;
+       homepage = "https://github.com/ryo0ka/tictactoe3d";
+       description = "3D Tic-Tac-Toe logic";
+       license = stdenv.lib.licenses.gpl3;
+     }) {};
+
   "tidal" = callPackage
     ({ mkDerivation, base, binary, bytestring, colour, containers
      , hashable, hmt, hosc, mersenne-random-pure64, mtl, parsec, process
@@ -130876,7 +131284,7 @@ self: {
      mkDerivation {
        pname = "tidal";
        version = "0.5.3";
-       sha256 = "09bq5ng0wvl1rcaaaw0p2b84f9sddpmabaf9c72ifw3z9k35cfyw";
+       sha256 = "dc3b56c64c7f7017c561c9a9a5ea6d4d2747d0121770a514cb816e0e9e2d7825";
        libraryHaskellDepends = [
          base binary bytestring colour containers hashable hmt hosc
          mersenne-random-pure64 mtl parsec process text time transformers
@@ -130894,7 +131302,7 @@ self: {
      mkDerivation {
        pname = "tidal-midi";
        version = "0.1";
-       sha256 = "04d5xfr57rw22jq62iil6sa9drya6z545hcm1fx98jrkcyglb10c";
+       sha256 = "0c84459f67334b94ba0b95c142ca37cae7969436344661b01482e753b2eba511";
        libraryHaskellDepends = [
          base bytestring containers hashable hosc PortMidi process tidal
          time
@@ -130909,7 +131317,7 @@ self: {
      mkDerivation {
        pname = "tidal-vis";
        version = "0.1.8";
-       sha256 = "1j9a4sgvji2wc9kq9xf0ja45b9md4v1xlanh6cfqk8p0b2qgmcrw";
+       sha256 = "3cb3fab058e0a2891d33d02adac326ada6558892c0f58467625c44b99f262ac9";
        libraryHaskellDepends = [ base cairo colour tidal ];
        homepage = "http://yaxu.org/tidal/";
        description = "Visual rendering for Tidal patterns";
@@ -130921,7 +131329,7 @@ self: {
      mkDerivation {
        pname = "tie-knot";
        version = "0.2";
-       sha256 = "1iksr5h6cyyl88z35fbaskriv4vhc1696d3i1i3c171c0vq0hwg4";
+       sha256 = "e47108f0062c9cc0460c7134934c6070931df3d46ab9323e42d47b6660c97ac6";
        libraryHaskellDepends = [ base containers mtl recursion-schemes ];
        jailbreak = true;
        homepage = "https://github.com/ppetr/tie-knot";
@@ -130934,7 +131342,7 @@ self: {
      mkDerivation {
        pname = "tiempo";
        version = "0.0.1.0";
-       sha256 = "1gmaiiwcbn3z3zmhgii7q3922c2rwdgkjsc4104gyzjm2m08998r";
+       sha256 = "19a5844015557eff08088469395fe3593021d2c027c607eb1f7fd8c5788caabe";
        libraryHaskellDepends = [ base deepseq time ];
        jailbreak = true;
        homepage = "http://github.com/HaskVan/tiempo";
@@ -130948,7 +131356,7 @@ self: {
      mkDerivation {
        pname = "tiger";
        version = "1.1.1";
-       sha256 = "1llmizacz4sg77l5yi3f9m9xkckl1mpjh0ly20cbqf5747q354q1";
+       sha256 = "019332f021a738bc18109e02286f0d74b2d9534d6e445fe8394f93cfd48f95d2";
        isLibrary = false;
        isExecutable = true;
        executableHaskellDepends = [
@@ -130967,7 +131375,7 @@ self: {
      mkDerivation {
        pname = "tightrope";
        version = "0.2.0.0";
-       sha256 = "1vvzfsl166qhg0ykq71rzavllid216f6fg5xrk2454z9zskc9n60";
+       sha256 = "c0d8c4a6fee99342c4ccbd3c679c09a2454ab7fa391c3c3d78101b13a8767fef";
        libraryHaskellDepends = [
          aeson base bytestring containers http-types lens mtl text wai
          wai-extra wreq
@@ -130984,7 +131392,7 @@ self: {
      mkDerivation {
        pname = "tighttp";
        version = "0.0.0.8";
-       sha256 = "0xbipgy79pivy69a84lrriw7ams60r1a2rrkqy6llhsw4v2qk497";
+       sha256 = "279189c5265c434a8dc73367a1420646577578cc9912a492f13bde74fcbb7175";
        libraryHaskellDepends = [
          base bytestring handle-like monads-tf old-locale papillon
          simple-pipe time
@@ -131001,7 +131409,7 @@ self: {
      mkDerivation {
        pname = "tilings";
        version = "0.1";
-       sha256 = "03a9bc4zbfb3c0dd75rxj7h9pj3sc23l9a9gmabcww5nsx8kpjys";
+       sha256 = "dacb3b51d7b670ce96aa2fa94487607ac89be0913d97d31a6063b9f5095b490d";
        libraryHaskellDepends = [ base ];
        homepage = "https://gitorious.org/tilings";
        description = "substitution tilings";
@@ -131015,7 +131423,7 @@ self: {
      mkDerivation {
        pname = "timberc";
        version = "1.0.3";
-       sha256 = "0x2yc57g9g5ii14l65xkly55rhx44nfjqnbl4bqf286mqsgz191j";
+       sha256 = "32a4f09fc6d520e1f02274592c9d25a4c35c8aa7b317434988b1bcf44e615e74";
        isLibrary = false;
        isExecutable = true;
        executableHaskellDepends = [
@@ -131035,7 +131443,7 @@ self: {
      mkDerivation {
        pname = "time";
        version = "1.5.0.1";
-       sha256 = "0knixcmdsl2jhjw0x6is02yrw6dhjn4gr3fh06adc003gc3wr894";
+       sha256 = "24a1cc077b0300d69401d08dfc8895b0199ebd003a9a0eb8845250dd2aebd14e";
        libraryHaskellDepends = [ base deepseq ];
        testHaskellDepends = [
          base deepseq QuickCheck test-framework test-framework-quickcheck2
@@ -131051,7 +131459,7 @@ self: {
      mkDerivation {
        pname = "time-compat";
        version = "0.1.0.3";
-       sha256 = "0zqgzr8yjn36rn6gflwh5s0c92vl44xzxiw0jz8d5h0h8lhi21sr";
+       sha256 = "590711214510c0d2d09780c7fe3b21748bc4802e9053f78ccd6658e951fe0f7f";
        libraryHaskellDepends = [ base old-time time ];
        homepage = "http://hub.darcs.net/dag/time-compat";
        description = "Compatibility with old-time for the time package";
@@ -131063,7 +131471,7 @@ self: {
      mkDerivation {
        pname = "time-extras";
        version = "1.1.4";
-       sha256 = "1k9adm922l431gyk8figx5df1n2xk5awir2fpijnvvyphrwk5p3l";
+       sha256 = "74dc327986d7ef6d65bc4ee4c855995dd8e05ae92f3a34fd0b835021526d2acd";
        libraryHaskellDepends = [ base time ];
        jailbreak = true;
        homepage = "http://semantic.org/TimeLib/";
@@ -131080,7 +131488,7 @@ self: {
      mkDerivation {
        pname = "time-exts";
        version = "2.1.0";
-       sha256 = "0y73axrlm6lh8150i4av0jza18zpd5fiiqv9y5m8a7xx11a386bm";
+       sha256 = "7519345408bd1f856af169e3185d69f7a3a0be045b91084a40909a4a7357e378";
        isLibrary = true;
        isExecutable = true;
        libraryHaskellDepends = [
@@ -131106,7 +131514,7 @@ self: {
      mkDerivation {
        pname = "time-http";
        version = "0.5";
-       sha256 = "0jbiawi14p8cgcxvr5b38kyjdmhq1lagr1dqnlpymlv7d7pcxljd";
+       sha256 = "4dd2ceee6967d3ea2fb5b885fc140d18d626fd446395bc3b7b0c5d1222577149";
        libraryHaskellDepends = [
          ascii attempt attoparsec base base-unicode-symbols blaze-builder
          blaze-textual bytestring convertible-text data-default failure
@@ -131129,7 +131537,7 @@ self: {
      mkDerivation {
        pname = "time-io-access";
        version = "0.1.0.0";
-       sha256 = "0n05lw6zpcfr3lwy2qn7v0j3ym1la9x0mak8szaxc2nbkyc8drrb";
+       sha256 = "2be786989fcb0ad6d5d768aa0a7a5234543f24d8c762e1391dd9b1fb0da70558";
        libraryHaskellDepends = [ base base-io-access time ];
        jailbreak = true;
        description = "IO Access for time";
@@ -131141,7 +131549,7 @@ self: {
      mkDerivation {
        pname = "time-lens";
        version = "0.4.0.1";
-       sha256 = "0916qfan93aq91icf87ifvskrq6s6s75rhkajvl8pxp74j28hlwz";
+       sha256 = "9f53888424e7f68be8966ac25c8e36dae03cf576f120c76248588d6495c32624";
        libraryHaskellDepends = [ base data-lens-light time ];
        description = "Lens-based interface to Data.Time data structures";
        license = stdenv.lib.licenses.bsd3;
@@ -131152,7 +131560,7 @@ self: {
      mkDerivation {
        pname = "time-locale-compat";
        version = "0.1.1.0";
-       sha256 = "0mdl1i17hcbka8miq1n6mscrr84vnmx5a3mqgwv2yb28k404v815";
+       sha256 = "25a04d0099482c2f367fb80e557ab59ba09c99aec6061c2b52733178420cb455";
        libraryHaskellDepends = [ base time ];
        homepage = "http://twitter.com/khibino/";
        description = "Compatibility of TimeLocale between old-locale and time-1.5";
@@ -131164,7 +131572,7 @@ self: {
      mkDerivation {
        pname = "time-patterns";
        version = "0.1.3.1";
-       sha256 = "17gfin2bd6zsk3ij4hdh5xddlki0kb05mq9xkmvly9ka39gsr82n";
+       sha256 = "56a0ac5f1a6a264f779d3de15ac09a204eda5a2fb04122e398fa9bb6848dee9d";
        libraryHaskellDepends = [ base intervals lens thyme vector-space ];
        jailbreak = true;
        homepage = "https://bitbucket.org/jfmueller/time-patterns";
@@ -131180,7 +131588,7 @@ self: {
      mkDerivation {
        pname = "time-qq";
        version = "0.0.0.2";
-       sha256 = "0zpgs5xmjq4fk5djg438fpyh3582v22rjrpqhdr3qy81gcqbgaz7";
+       sha256 = "e7abb7307b01793c7283f8669985d8029501fd756890275b998e60597bd1ef7e";
        libraryHaskellDepends = [
          base template-haskell time time-locale-compat
        ];
@@ -131197,7 +131605,7 @@ self: {
      mkDerivation {
        pname = "time-recurrence";
        version = "0.9.2";
-       sha256 = "1arqmkagmswimbh78qfz5bcilk9i14w29j4vf4i89d00vac3vrzm";
+       sha256 = "f5e73d98da00b48422719bc8243809314d1ad92adf6174e0aa91ebfad4ac38ab";
        revision = "1";
        editedCabalFile = "7f1fe44ec61160e3fba86a04942d056ac91faa0002817e107e3d8399b71fe427";
        libraryHaskellDepends = [ base data-ordlist mtl time ];
@@ -131216,7 +131624,7 @@ self: {
      mkDerivation {
        pname = "time-series";
        version = "0.1.0.0";
-       sha256 = "1j6xrf45i4japgr35kzqcawlhdn13k3fbsjfmm2j3j92skwra095";
+       sha256 = "250195f9d422c92145ad4eeae5c61cc13648b962f8cf32f2bb4a925888cbddc8";
        isLibrary = true;
        isExecutable = true;
        libraryHaskellDepends = [ array base containers mtl ];
@@ -131231,7 +131639,7 @@ self: {
      mkDerivation {
        pname = "time-units";
        version = "1.0.0";
-       sha256 = "16g0i6r6vj9w4lbn12jqrhgbbjjca8wbzq6546dz08aks1yrk0g1";
+       sha256 = "e181997dd05321f09b21c5e0bf38524ccab51ecc588a6017253cc96db289e099";
        libraryHaskellDepends = [ base ];
        homepage = "http://github.com/acw/time-units";
        description = "A basic library for defining units of time as types";
@@ -131243,7 +131651,7 @@ self: {
      mkDerivation {
        pname = "time-w3c";
        version = "0.1.0.1";
-       sha256 = "12hnvhcv18kv1djqn5dqv8i1rrzsxlvnsjyjsy9m1ngmr9nvvfbg";
+       sha256 = "6fb9bd6dcaf5d95093d7d24b6d37edfae71c22dab8158b650b7ba2b019dc168a";
        isLibrary = true;
        isExecutable = true;
        libraryHaskellDepends = [ base convertible parsec time ];
@@ -131259,7 +131667,7 @@ self: {
      mkDerivation {
        pname = "timecalc";
        version = "0.1.1";
-       sha256 = "05nzfydzn9nmjfmdnpf5jl238kdixbwwqkyrax89i4anmpxv1v9s";
+       sha256 = "3aedb0fbad5691985057d94fccf9eab14d340495c55ddbaa93d526fb9b77df16";
        isLibrary = false;
        isExecutable = true;
        executableHaskellDepends = [ base haskeline uu-parsinglib ];
@@ -131273,7 +131681,7 @@ self: {
      mkDerivation {
        pname = "timeconsole";
        version = "0.1.0.0";
-       sha256 = "0zmrysri8hxxvr4dffmawv5cb8lyz92w8ixfj5kah8ya2p422yc0";
+       sha256 = "807921c815ca23a86691ae47c445fa9ea2c5cae6aa3ad748debd4314b3f6b97e";
        isLibrary = false;
        isExecutable = true;
        executableHaskellDepends = [ base process time ];
@@ -131287,7 +131695,7 @@ self: {
      mkDerivation {
        pname = "timeit";
        version = "1.0.0.0";
-       sha256 = "0dkjbp636dp882zlbwvvz76k4g7ga28wksd41w6mh0k8z45xjj5x";
+       sha256 = "bd48d90bf96802580d0fa4e9c99150ef3c32cdf97bf345bf40e83633cc5d7236";
        libraryHaskellDepends = [ base ];
        description = "Time a computation";
        license = stdenv.lib.licenses.bsd3;
@@ -131300,7 +131708,7 @@ self: {
      mkDerivation {
        pname = "timeout";
        version = "0.1.1";
-       sha256 = "1jddkkmc3d8ysh8rnlpkzvlg67if8c71wqmjdsysddpwwm3wbgjn";
+       sha256 = "56bec547e5fcb6a6bd6eb2621e0e432e1ef3e8fef3529b11d41eb5c1ea9cadc9";
        libraryHaskellDepends = [ base exceptions mtl time ];
        testHaskellDepends = [
          base exceptions mtl QuickCheck tasty tasty-quickcheck time
@@ -131318,7 +131726,7 @@ self: {
      mkDerivation {
        pname = "timeout-control";
        version = "0.1";
-       sha256 = "1w2y39699zsxv43w53q8qbi1wfvg14kqvxqfp92pisvxnrwpcisp";
+       sha256 = "57477679b67deb7845ba0ef78d27096f3b1ee2c2088fc207d95dff944c1a5ef0";
        libraryHaskellDepends = [
          base ghc-prim lifted-base monad-control mtl transformers-base
        ];
@@ -131334,7 +131742,7 @@ self: {
      mkDerivation {
        pname = "timeout-with-results";
        version = "0.2";
-       sha256 = "1y5mc1awahcp9xpmmwqc74cfn7g0zm1cyxi396xirll8nk335nd0";
+       sha256 = "a0d932c6b488d21cbb492376cf42fde01deb18390cf35a6f4f9741c55560b5f8";
        libraryHaskellDepends = [ base deepseq mtl parallel ];
        homepage = "https://github.com/ppetr/timeout-with-results";
        description = "Runs a time-limited computation alowing it to return intermediate results";
@@ -131348,7 +131756,7 @@ self: {
      mkDerivation {
        pname = "timeparsers";
        version = "0.3.2";
-       sha256 = "1dicp58f2amn5rgmnlfjpv4aj7ak6jrdlba2marglddvj4ycq1h7";
+       sha256 = "0706cc3c91bb35fab2aa422ddab234531da9c8bed2515b5f2eb62ae150b92cb6";
        libraryHaskellDepends = [
          attoparsec base bytestring containers convertible mtl time
        ];
@@ -131366,7 +131774,7 @@ self: {
      mkDerivation {
        pname = "timeplot";
        version = "1.0.29";
-       sha256 = "01px3hyl5hb114jibjr3p6pda6ppvxv2alk31wwc82dywnjp1srx";
+       sha256 = "3deb70a5e5be09c4380f63522576dff71ad5aeb923cb15250961c1423d1cfd06";
        isLibrary = false;
        isExecutable = true;
        executableHaskellDepends = [
@@ -131388,7 +131796,7 @@ self: {
      mkDerivation {
        pname = "timerep";
        version = "2.0.0.1";
-       sha256 = "0rk3svwx7axp77v92j1gpmnni0jlniw3sz55q5hpa6k43d2jr4b8";
+       sha256 = "68912c451b641a7561c1a57c3d78b45482686dbd2f4891f639b7abd3f9d66366";
        libraryHaskellDepends = [
          attoparsec base monoid-subclasses text time
        ];
@@ -131407,7 +131815,7 @@ self: {
      mkDerivation {
        pname = "timers";
        version = "0.2.0.3";
-       sha256 = "0q4w41jdhf5ildcdl94lgfn06fg275hf04dpah3l6vva24d8alj5";
+       sha256 = "4552851a116a6f430754b711e06039e23903ac7b9424da58a3b138d864209c60";
        libraryHaskellDepends = [
          base lifted-base monad-control suspend transformers-base
        ];
@@ -131420,7 +131828,7 @@ self: {
      mkDerivation {
        pname = "timers-updatable";
        version = "0.2.0.2";
-       sha256 = "1naw59xvbfhgz49qhvgzng4xjf4fzi59gl996pcp5l6s2sbpx4mw";
+       sha256 = "bc927e9716dad072d93529d1974afc8e38d9c9b3ff6d8813f90fbab57b2a5cd9";
        libraryHaskellDepends = [ base stm ];
        homepage = "http://github.com/paolino/timers-updatable";
        description = "timers which are updatable in the remaining time";
@@ -131434,7 +131842,7 @@ self: {
      mkDerivation {
        pname = "timestamp-subprocess-lines";
        version = "0.1.0.3";
-       sha256 = "1vn947bbfh7awmz2rxzn2rya439ljjm83rggp6g9v178hxff5aim";
+       sha256 = "35aae25c87e8849d9eb9efe581aa94340da27c16f6f72c7ee5ea40b7d621c9ee";
        isLibrary = false;
        isExecutable = true;
        executableHaskellDepends = [
@@ -131451,7 +131859,7 @@ self: {
      mkDerivation {
        pname = "timestamper";
        version = "1.0.3";
-       sha256 = "1qpzk3047ky0lx5riivv9fa418qhwsa5iyy1fb9l7az6ri094qys";
+       sha256 = "da639240cce6ab43d372c1fb5894e610a340944b7bc7984ba7c0cf43c098ffe2";
        isLibrary = false;
        isExecutable = true;
        executableHaskellDepends = [ base old-locale time ];
@@ -131467,7 +131875,7 @@ self: {
      mkDerivation {
        pname = "timezone-olson";
        version = "0.1.7";
-       sha256 = "1am6vqq3zxrnb444waqfajk3s1wpynw9fszqnk9ww7akf2v5abr3";
+       sha256 = "232f55b670531dced3b4f86b97b8f597073da6540e2b4e085936f73f30dea6aa";
        revision = "1";
        editedCabalFile = "cdd67661d2460ceb1720bcbb194726a57c21b113b9383cd1f1dca91e8e71d652";
        libraryHaskellDepends = [
@@ -131485,7 +131893,7 @@ self: {
      mkDerivation {
        pname = "timezone-olson-th";
        version = "0.1.0.1";
-       sha256 = "1xqy4bbkwn03ynvk8dhcmrp37rj1swaskh2si9adb9d5prcibsv1";
+       sha256 = "61eb1559bea5a5d5548a5ac0a915d741e6336eae0c3634b7f503583ed7221ef7";
        libraryHaskellDepends = [
          base template-haskell time timezone-olson timezone-series
        ];
@@ -131499,7 +131907,7 @@ self: {
      mkDerivation {
        pname = "timezone-series";
        version = "0.1.5.1";
-       sha256 = "0mks5s5wdw8fi5hjhf6zbs3pfgy4gsysd1369s41kw4h7aidsi6j";
+       sha256 = "d244dda23a90f019884e6684a6bd7ec43f77875edf382861890ef1c68b2e7a56";
        libraryHaskellDepends = [ base time ];
        homepage = "http://projects.haskell.org/time-ng/";
        description = "Enhanced timezone handling for Data.Time";
@@ -131511,7 +131919,7 @@ self: {
      mkDerivation {
        pname = "timing-convenience";
        version = "0.1";
-       sha256 = "078p6gzzb7f9g68lm3q5806azhrs6li35ras9jnb9gs2r6i0w83j";
+       sha256 = "72200ea2c942bfb4ac4c5ae53222353ac3af0c40058f4a9179c99df5ff33171d";
        libraryHaskellDepends = [ base time ];
        description = "Convenient functions for getting times";
        license = stdenv.lib.licenses.bsd3;
@@ -131524,7 +131932,7 @@ self: {
      mkDerivation {
        pname = "tinyMesh";
        version = "0.1.0.0";
-       sha256 = "19jpwnk7hmi0mg46nqhyiipz085dkakqwgh17lv9ccvvcirpclm3";
+       sha256 = "a3527673647b3396363d013e8ea79aad20f06f8c1e626bc8ab205678a6e557a6";
        libraryHaskellDepends = [
          attoparsec base bytestring hex serialport unix
        ];
@@ -131541,7 +131949,7 @@ self: {
      mkDerivation {
        pname = "tinylog";
        version = "0.12.1";
-       sha256 = "1hh70788d0rd35raybix383s6bb3mnibmmpdxwbqybv2dgmm4jq9";
+       sha256 = "094b52eb6b622f8f17efedd6baa2ad632da3071a3d2eaf72192d8386d00107c2";
        revision = "1";
        editedCabalFile = "b0e1cd3e83f3745355d1183935660d4b02ed152083da7af0ea4f386e155db04d";
        libraryHaskellDepends = [
@@ -131558,7 +131966,7 @@ self: {
      mkDerivation {
        pname = "tinytemplate";
        version = "0.1.1.0";
-       sha256 = "19i5vs2kb24hahwahfvn6bldzpcw68lpjlw37yvf2n8s5sq1fibc";
+       sha256 = "6c4517b02e1a59e1b63f83537929329cdddfe832763ba8385490883585de25a6";
        libraryHaskellDepends = [ base text ];
        testHaskellDepends = [ base mtl QuickCheck text ];
        jailbreak = true;
@@ -131575,7 +131983,7 @@ self: {
      mkDerivation {
        pname = "tip-haskell-frontend";
        version = "0.1.1";
-       sha256 = "0za8ls980f98qj3k6pgmzaidmnrlk0nzg1r7skif6jmhh1snqc5h";
+       sha256 = "b0306c7580b04ae3e2d42787f72d9834dbdaa2faf55d3387c428398092a6487d";
        isLibrary = true;
        isExecutable = true;
        libraryHaskellDepends = [
@@ -131595,7 +132003,7 @@ self: {
      mkDerivation {
        pname = "tip-lib";
        version = "0.1.2";
-       sha256 = "01x8hpijgx3fd0svp0di02470xnhq1gaa6k2fxjph9g5rzmx076b";
+       sha256 = "cb1cd0ebcfe525786577621aa55ec0d076708800b181bb35686ef427e385a807";
        isLibrary = true;
        isExecutable = true;
        libraryHaskellDepends = [
@@ -131618,7 +132026,7 @@ self: {
      mkDerivation {
        pname = "titlecase";
        version = "0.1.0.1";
-       sha256 = "0qwlcfr7fb5nr9vmfjfdlm3bz65jil8xnxmd54zksp1z3sxz5fhf";
+       sha256 = "0ebaf2bb1e3f5c3d3f29ad76db118db298bf46a5cd495777cab62c77b2639463";
        libraryHaskellDepends = [ base blaze-markup semigroups text ];
        testHaskellDepends = [
          base semigroups tasty tasty-hunit tasty-quickcheck text
@@ -131635,7 +132043,7 @@ self: {
      mkDerivation {
        pname = "tkhs";
        version = "0.3.0";
-       sha256 = "1svsdjb1ac5mb9zcx3wqmxdjfmf99ph94v616scya5f7lqkjcfgp";
+       sha256 = "f7392627a6c715e59936c16c92e04dc955275baf988fce7e5ab53015966c7aeb";
        isLibrary = false;
        isExecutable = true;
        executableHaskellDepends = [
@@ -131659,7 +132067,7 @@ self: {
      mkDerivation {
        pname = "tkyprof";
        version = "0.2.2.2";
-       sha256 = "1xyy1aagbjyjs9d52jmf7xch0831v7hvsb0mfrxpahvqsdac6h7a";
+       sha256 = "ea40c354d37843757b76152cbde1d9612000593fae4a515ad2d2cbf5940adef7";
        isLibrary = true;
        isExecutable = true;
        executableHaskellDepends = [
@@ -131684,7 +132092,7 @@ self: {
      mkDerivation {
        pname = "tld";
        version = "0.1.0.1";
-       sha256 = "1lda1h8ibkmnhxhnkfd1kj6aybk5w4s3hzhh379zrqbckdl0vfxb";
+       sha256 = "abbb0d689b6ce1fcd319107e3834e1652eaf8c9ca1b9696187b6ce15110caad1";
        libraryHaskellDepends = [
          base containers network-uri template-haskell text
        ];
@@ -131702,7 +132110,7 @@ self: {
      mkDerivation {
        pname = "tls";
        version = "1.3.1";
-       sha256 = "1l6maasf4pr70cxasn6bwcy2aydlmiadmd28ymz0fp8ifw388zvl";
+       sha256 = "747f840677115d077ef548b4da54acb479253ce3cb58ad3a03275fe2b452d5d0";
        libraryHaskellDepends = [
          asn1-encoding asn1-types async base byteable bytestring cereal
          cryptonite data-default-class memory mtl network transformers x509
@@ -131724,7 +132132,7 @@ self: {
      mkDerivation {
        pname = "tls-debug";
        version = "0.4.0";
-       sha256 = "06hvnyg89n4zplw2p4rnqwyyqc5r204pfdmpvim8y119pllg3mij";
+       sha256 = "32d6f128bd29048f6adcb736770910b930ec3dc736932b38bd9fd8849eb71b1a";
        isLibrary = false;
        isExecutable = true;
        executableHaskellDepends = [
@@ -131744,7 +132152,7 @@ self: {
      mkDerivation {
        pname = "tls-extra";
        version = "0.6.6";
-       sha256 = "0k0sj3nq1lrvbmd582mjj8cxbxigivz1hm8hhij1ncl2pgnq5xyv";
+       sha256 = "dbf782edbb82321b6484105518fe8e2ff6d51992b20a545a5d3bd380ed901a4c";
        isLibrary = true;
        isExecutable = true;
        libraryHaskellDepends = [
@@ -131763,7 +132171,7 @@ self: {
      mkDerivation {
        pname = "tmpl";
        version = "0.0.0.1";
-       sha256 = "101q4f51am8722b0b2d9hk84iqfg1z1shzrbikya63jpf3s6jrvg";
+       sha256 = "6f6769f470570ea3fc8c2b7fa8c30fcfe148d084a9890596100755158a233880";
        isLibrary = false;
        isExecutable = true;
        executableHaskellDepends = [
@@ -131781,7 +132189,7 @@ self: {
      mkDerivation {
        pname = "tn";
        version = "1.0.2.1";
-       sha256 = "07jhbg8b33h9b0x94di5x8dskm4mq6r7mkjcx6zzcvr26ymmyrmy";
+       sha256 = "be665fab37226ff6bfe94cce7ab2c195d4a91bea2536923a58098eb1d05b501e";
        isLibrary = false;
        isExecutable = true;
        executableHaskellDepends = [
@@ -131797,7 +132205,7 @@ self: {
      mkDerivation {
        pname = "tnet";
        version = "0.0.1";
-       sha256 = "1hxka8jfybq72isicvav81f4l9hjxhmzx4i4znkqbwzkarg2gsw9";
+       sha256 = "89eb275e56f3f385a7fd2492fe2bec12264a5c405b6d167514072fef2452b3c3";
        libraryHaskellDepends = [ attoparsec base bytestring utf8-string ];
        description = "Library for encoding/decoding TNET strings for PGI";
        license = "unknown";
@@ -131809,7 +132217,7 @@ self: {
      mkDerivation {
        pname = "to-haskell";
        version = "0.3.0";
-       sha256 = "0glf7m0r9gpab2pg1bq9qa37mrzpjwvqr3xsws6w53qqlcaw54qk";
+       sha256 = "1393c215a3188fc28de6ba8f8c3797f7e77a86c209aff0ae58eabe94413d8e3e";
        libraryHaskellDepends = [
          base containers haskell-src-exts transformers
        ];
@@ -131824,7 +132232,7 @@ self: {
      mkDerivation {
        pname = "to-string-class";
        version = "0.1.2";
-       sha256 = "0l2hj0cbc0dhd7m5bn6xqgzkdf2z4knirmv8c65hsjig9mpsvsxf";
+       sha256 = "aeebad6f4d2f4a0d8b6168d71ced245fb836ffc3ddd855ea69b001b618905050";
        libraryHaskellDepends = [ base ];
        description = "Converting string-like types to Strings";
        license = stdenv.lib.licenses.bsd3;
@@ -131836,7 +132244,7 @@ self: {
      mkDerivation {
        pname = "to-string-instances";
        version = "0.2";
-       sha256 = "1h5aq3shagzgh1j8sbslvi2rrkqv1djm595d522ci8hpj6h8vxl9";
+       sha256 = "89f68da09117a2c88428ada452650b1bcf9c45dc542f8d6480ef3f05f5c0aac0";
        libraryHaskellDepends = [ to-string-class ];
        description = "Instances for the ToString class";
        license = stdenv.lib.licenses.bsd3;
@@ -131851,7 +132259,7 @@ self: {
      mkDerivation {
        pname = "todos";
        version = "0.5.3.2";
-       sha256 = "1wgnxg9kndijm8faxsy48qznjzfcwqgjxgyff6x9c9h2fayvl719";
+       sha256 = "291cbabd72022696ba71cebf2e1fe6cc7d693f46c4ebae1caa32363bd3ebf6f1";
        isLibrary = true;
        isExecutable = true;
        libraryHaskellDepends = [
@@ -131877,7 +132285,7 @@ self: {
      mkDerivation {
        pname = "tofromxml";
        version = "0.1.0.2";
-       sha256 = "0wqdxr6fijbdzq0767cvi7yf07q6dcv1anzmsv7ms2apcyag63qh";
+       sha256 = "100ff3946757095dcfd6f55b15366b061fe0fc899b1d7300fe6dc9e84cee0d73";
        libraryHaskellDepends = [
          array base bytestring containers hexpat hexpat-pickle
        ];
@@ -131895,7 +132303,7 @@ self: {
      mkDerivation {
        pname = "toilet";
        version = "0.0.1";
-       sha256 = "09j6h4rwb6i87223zhbzclns12iyrbdmv0kawd27any5r2hkz63x";
+       sha256 = "7d983fa1c8c55b7544e36a825ddbca3e8aa02d657fc13f8438289ac533814626";
        isLibrary = false;
        isExecutable = true;
        executableHaskellDepends = [
@@ -131913,7 +132321,7 @@ self: {
      mkDerivation {
        pname = "token-bucket";
        version = "0.1.0.1";
-       sha256 = "1l3axqdkrjf28pxhrvdvlpf9wi79czsfvhi33w4v2wbj0g00j9ii";
+       sha256 = "312609c0037271b1091f23c2edf467e9449edca5bbed0cfb45c2c93c1bee6ad0";
        libraryHaskellDepends = [ base ];
        testHaskellDepends = [ base time ];
        homepage = "https://github.com/hvr/token-bucket";
@@ -131926,7 +132334,7 @@ self: {
      mkDerivation {
        pname = "tokenify";
        version = "0.1.2.0";
-       sha256 = "1fyf1ym91dbhiw7hybzhllc375v4pizl058qazfdyw6cymqm4rch";
+       sha256 = "90655271f5cc70dfdc571815407fbc64973318a5f02f0f0f8f70b590aa0fcebb";
        libraryHaskellDepends = [ base containers text ];
        homepage = "https://github.com/AKST/tokenify";
        description = "A regex lexer";
@@ -131938,7 +132346,7 @@ self: {
      mkDerivation {
        pname = "tokenize";
        version = "0.3.0";
-       sha256 = "1dcimgwy6ik5l6f98b0w6sc7pf06qazckfwf2cbmrd7g0q7lk20f";
+       sha256 = "0e88490f06efb45c17138ebbc9bec206b87b98361c2c949ca16546e3f9ab91b5";
        libraryHaskellDepends = [ base split text ];
        homepage = "https://bitbucket.org/gchrupala/lingo/overview";
        description = "Simple tokenizer for English text";
@@ -131952,7 +132360,7 @@ self: {
      mkDerivation {
        pname = "toktok";
        version = "0.5";
-       sha256 = "0y4s68gnp4xw0x22w3kdcr5wnkqygv6ajwkhb8apphja268np98v";
+       sha256 = "1ba56b91114ac27b155a7072a9cc7e1e4fcb4b666d0e2e4407bc936b1f329a78";
        isLibrary = true;
        isExecutable = true;
        libraryHaskellDepends = [ base containers haskell98 ];
@@ -131969,7 +132377,7 @@ self: {
      mkDerivation {
        pname = "tokyocabinet-haskell";
        version = "0.0.5";
-       sha256 = "1v6s39q8a6cnc0ggpspz9i0xw6aih4ixn9bhn4hwf9kwgcspardg";
+       sha256 = "af6575357b7c26c721b17025db23815119de414cffeafb1e60961985701adaec";
        libraryHaskellDepends = [ base bytestring mtl ];
        librarySystemDepends = [ tokyocabinet ];
        homepage = "http://tom-lpsd.github.com/tokyocabinet-haskell/";
@@ -131984,7 +132392,7 @@ self: {
      mkDerivation {
        pname = "tokyotyrant-haskell";
        version = "1.0.1";
-       sha256 = "1xz8n3hgkhrdabwc8hsqj3yf5x112palzz192f6pkl07vi8yz1ph";
+       sha256 = "f086ef51dc07d0798d1329fc4fd51521f4e2fc905843c4f8522dc3f9e0b0e8f7";
        libraryHaskellDepends = [ base bytestring mtl ];
        librarySystemDepends = [ tokyocabinet tokyotyrant ];
        homepage = "http://www.polarmobile.com/";
@@ -131997,7 +132405,7 @@ self: {
      mkDerivation {
        pname = "tomato-rubato-openal";
        version = "0.1.0.3";
-       sha256 = "0dk7s5fng3vybdqgqn9vqg7k6sjw4zgqld51i926lgqnixgpmw8z";
+       sha256 = "1ff17a5f8f163f6a448aa1348adf275c6a33cfc33b59fc705b7e8f675dd16736";
        libraryHaskellDepends = [ base OpenAL stm vector ];
        jailbreak = true;
        homepage = "http://www.haskell.org/haskellwiki/tomato-rubato";
@@ -132012,7 +132420,7 @@ self: {
      mkDerivation {
        pname = "toml";
        version = "0.1.3";
-       sha256 = "0wby1jas854niwyac95n39liqc874xcd1ahqpw6ksi2nhv2ld6f2";
+       sha256 = "c29946c58656443d0dbf18aad0582707311c691ab624a63c8f9614a4950c7e71";
        libraryHaskellDepends = [
          attoparsec base bytestring containers old-locale time
        ];
@@ -132028,7 +132436,7 @@ self: {
      mkDerivation {
        pname = "toolshed";
        version = "0.15.0.1";
-       sha256 = "034npn24nk07hkc6wnfqsxn8msqkgfi8zwvj0yb4rmpgmxq73v60";
+       sha256 = "c0ec7170afefd64c960772f38fa27b13eb8a6cd7d8596ed884074c4b84bd960c";
        isLibrary = true;
        isExecutable = true;
        libraryHaskellDepends = [
@@ -132047,7 +132455,7 @@ self: {
      mkDerivation {
        pname = "topkata";
        version = "0.2.4";
-       sha256 = "06b938i2362c4jcd0923lwrcf6hqgxdscizj91ns51wx73nm8fxi";
+       sha256 = "b13b54ed389d87a26d48f247a65b7f181ac732a74324d098244c9821221a6919";
        isLibrary = false;
        isExecutable = true;
        executableHaskellDepends = [
@@ -132064,7 +132472,7 @@ self: {
      mkDerivation {
        pname = "torch";
        version = "0.1";
-       sha256 = "1bai1vxd2vfxl9zn37dvrb05yh4knr5gw5syqpi6lxxd3lf0ngzc";
+       sha256 = "ec3f0b1c1dad776ae2c55e17fe4ab693405fc0cabb9d617fa2dd6dd1fa0e51ad";
        libraryHaskellDepends = [ base mtl parallel QuickCheck ];
        homepage = "http://patch-tag.com/repo/torch/home";
        description = "Simple unit test library (or framework)";
@@ -132079,7 +132487,7 @@ self: {
      mkDerivation {
        pname = "torrent";
        version = "10000.0.0";
-       sha256 = "030ll4m80ljkvq72n1aa8a2ygqa56ykkndzy5g40vh9j9j5vq52r";
+       sha256 = "5914bc8b4c32c10dc82bfe373ba73745e1e785424a052b0ede5352802aa1140c";
        libraryHaskellDepends = [
          base bencode binary bytestring containers filepath syb
        ];
@@ -132092,7 +132500,7 @@ self: {
      mkDerivation {
        pname = "tostring";
        version = "0.2.1.1";
-       sha256 = "0c95a1vjnnn3bwdz8v5hv7q2sbzn23ban3hcwqmwhmzc9ba019zg";
+       sha256 = "efa700d44aec57c82be60c0eabd610f62f2df0d9b06cf41b5fc35a2b77502531";
        libraryHaskellDepends = [ base case-insensitive text utf8-string ];
        description = "The ToString class";
        license = stdenv.lib.licenses.bsd3;
@@ -132103,7 +132511,7 @@ self: {
      mkDerivation {
        pname = "total";
        version = "1.0.4";
-       sha256 = "0zl02pznpgg719d2639491cy4df2amj7rmwfdy9dz9cksm029pga";
+       sha256 = "eadd2440d593a5df926f8ed77c6455c235e25948240d235a0ae7bd6bff15807e";
        libraryHaskellDepends = [ base void ];
        description = "Exhaustive pattern matching using lenses, traversals, and prisms";
        license = stdenv.lib.licenses.bsd3;
@@ -132114,7 +132522,7 @@ self: {
      mkDerivation {
        pname = "total-map";
        version = "0.0.4";
-       sha256 = "1gjwviqhxm3zavmb9yd14rv66qhw9cf0r6n8mdg1lkmkqi1ycb98";
+       sha256 = "282de643c4b34e1a5eabc89a0c1c4b1c62637626a1f9b4ea567fd40e71dc5cbe";
        libraryHaskellDepends = [ base containers ];
        homepage = "http://github.com/conal/total-map/";
        description = "Finitely represented /total/ maps";
@@ -132128,7 +132536,7 @@ self: {
      mkDerivation {
        pname = "total-maps";
        version = "1.0.0.2";
-       sha256 = "0i5xr0xnqazjk5j9lzhdcxlaarij1jwbfih4plfa3kpqygz5s6ps";
+       sha256 = "fa1a5dfef3f8cea11cbd0446b7b80c3266a568670d7e9a6499f22b6c3bc8bd44";
        libraryHaskellDepends = [
          adjunctions base base-compat bytes containers distributive keys
          linear reflection semigroups vector
@@ -132143,7 +132551,7 @@ self: {
      mkDerivation {
        pname = "touched";
        version = "0.2.0.1";
-       sha256 = "0lik2glqynjwcd64bdla2jsfy4yqqk4aap5f0c9zkqv9g916bxgi";
+       sha256 = "f1f565427a69e3f91303ae5ca5c8c4d813efb4148ab6454c635c5a8fe9133352";
        isLibrary = true;
        isExecutable = true;
        libraryHaskellDepends = [ base directory process time ];
@@ -132166,7 +132574,7 @@ self: {
      mkDerivation {
        pname = "toysolver";
        version = "0.3.0";
-       sha256 = "01rhq7mz20bjzqpvwwf7z4v77p9kvwgk4pv7gr6264ha30sygbr8";
+       sha256 = "28afe735180a12234c7e675f321fdf33dd7336f9c771be2ffe7201f1ebc13007";
        isLibrary = true;
        isExecutable = true;
        libraryHaskellDepends = [
@@ -132200,7 +132608,7 @@ self: {
      mkDerivation {
        pname = "tpdb";
        version = "1.2.0";
-       sha256 = "12l4a6p8jn03q71d3qi2zkv63k53brmha5hm6dwrp0sb8bv3qmb0";
+       sha256 = "60553cf6424b839b79331516056b5ea3cc61f6fc22e2d1c2c1035889ae51848a";
        libraryHaskellDepends = [
          base containers filepath hashable HaXml hxt mtl parsec text time
          wl-pprint-text
@@ -132218,7 +132626,7 @@ self: {
      mkDerivation {
        pname = "trace";
        version = "0.2.0.0";
-       sha256 = "14kzdd62gci1f1wskvvwai9wprkn8mq5wsdz4d5mw6kf7dcxbz41";
+       sha256 = "81fcd5593b6e1a5e4b23bf695e704576e6cb53547cefa9797021b2274c6b7f92";
        libraryHaskellDepends = [
          base containers deepseq monad-control mtl transformers
          transformers-base
@@ -132232,7 +132640,7 @@ self: {
      mkDerivation {
        pname = "trace-call";
        version = "0.1";
-       sha256 = "1fiz1v9d4ck8na68cywha53vgbgdk6iqad1zv6pj3lq0pwvkx6aw";
+       sha256 = "5c993e37bf00d321afd93f3485a399edadb74751907b868cb26832d2d20e3fba";
        libraryHaskellDepends = [ base containers mtl ];
        jailbreak = true;
        description = "functions for logging the arguments and results of function calls";
@@ -132244,7 +132652,7 @@ self: {
      mkDerivation {
        pname = "trace-function-call";
        version = "0.1";
-       sha256 = "0c5nsq9x59rmdkyvcrr1v94kjya48nhl9pnsad6xdmh77msf33xy";
+       sha256 = "be8fe1743d07d6d64d53dade44a14544793949da2167b6fd6c35a7d213d6b630";
        libraryHaskellDepends = [ base ];
        jailbreak = true;
        description = "Easy lightweight tracing of function arguments and results for ad hoc debugging";
@@ -132256,7 +132664,7 @@ self: {
      mkDerivation {
        pname = "traced";
        version = "3000";
-       sha256 = "1pniabsbybhjvlq4dmys8sxc1r8rhalsahdr3hbvif287h610hi9";
+       sha256 = "2942100c3c48b8b8171cb941a5a98219e5c0ba46dad74630dd122ebff452d1de";
        libraryHaskellDepends = [ base containers mtl pretty ];
        description = "Simple evaluation trace";
        license = stdenv.lib.licenses.bsd3;
@@ -132267,7 +132675,7 @@ self: {
      mkDerivation {
        pname = "tracer";
        version = "0.1";
-       sha256 = "1rgnls2zry29zrnvxv700bljdf7iqkkyzayr4lan0qvhv1bcs5jm";
+       sha256 = "5516cd56d87063601525d9abefe7c4f1b826e902e0ecbe6dfe49f8fc85a6f6e5";
        libraryHaskellDepends = [ base mtl transformers ];
        testHaskellDepends = [ base mtl transformers ];
        homepage = "https://github.com/knz/hs-tracer";
@@ -132280,7 +132688,7 @@ self: {
      mkDerivation {
        pname = "tracker";
        version = "0.1";
-       sha256 = "1jkcwkkzg3hkvffg6y2vz2c8y0iypij4ngryc4bca9q3g4zvxzs2";
+       sha256 = "42ffbe3f790327c516613e3f4b64bc3e028f98f85b78f39cdb138ef7e7e46cca";
        libraryHaskellDepends = [ base containers glib ];
        description = "Client library for Tracker metadata database, indexer and search tool";
        license = "LGPL";
@@ -132295,7 +132703,7 @@ self: {
      mkDerivation {
        pname = "trajectory";
        version = "0.1.0.0";
-       sha256 = "1n7vl903p5yg2xcyfxbxj45yd7ayd7p63fr9qfahlb0pgfl32s7h";
+       sha256 = "f06831a87b172c0a95c329bb61ee695e9de60b917d75e75917cf973b40a2fbd8";
        isLibrary = true;
        isExecutable = true;
        libraryHaskellDepends = [
@@ -132317,7 +132725,7 @@ self: {
      mkDerivation {
        pname = "transactional-events";
        version = "0.1.0.0";
-       sha256 = "0jb3cf4bn007x3by70piwcvcb216kvav4xzrqr1k5v483jaj2zml";
+       sha256 = "b47e21951c88ec3243c6f977b2d59e2688c536e3f182e3d7e80700bb88636349";
        libraryHaskellDepends = [ base ListZipper MonadPrompt stm ];
        description = "Transactional events, based on Concurrent ML semantics";
        license = stdenv.lib.licenses.bsd3;
@@ -132331,7 +132739,7 @@ self: {
      mkDerivation {
        pname = "transf";
        version = "0.13.1";
-       sha256 = "1p9nrs7a96n53cmmrv107kvwjm27gj45m9b4vj23dsvk5lsx7wil";
+       sha256 = "34f2d3352d73eb3684dc64a55a887c4754c9f73c20ec5c2b1bc59aa48ece36dd";
        isLibrary = true;
        isExecutable = true;
        libraryHaskellDepends = [
@@ -132349,7 +132757,7 @@ self: {
      mkDerivation {
        pname = "transformations";
        version = "0.2.0.0";
-       sha256 = "0nmzsd8q01ixfgqfgymbjwa5c8msq7chi16n4dwdf8x68mah7lam";
+       sha256 = "55d1035545a623d77823d68408d9c1ba22561497abfae7f0733d068051d3bf5a";
        isLibrary = true;
        isExecutable = true;
        libraryHaskellDepends = [
@@ -132367,7 +132775,7 @@ self: {
      mkDerivation {
        pname = "transformers";
        version = "0.4.3.0";
-       sha256 = "179sbhvc9dghyw58hz80109pbrzgh7vh437227a51jhmx2bsgl5k";
+       sha256 = "b3d0a797e815ca50d411e20c02f781efe7751308007d880af7f0b5c4365c3a9d";
        libraryHaskellDepends = [ base ];
        description = "Concrete functor and monad transformers";
        license = stdenv.lib.licenses.bsd3;
@@ -132380,7 +132788,7 @@ self: {
      mkDerivation {
        pname = "transformers-abort";
        version = "0.5.0.1";
-       sha256 = "0s0vvjii3h7vw8kg3xf1ig6fkxdw7z69czwdyg6nvsrcc9kbs9gm";
+       sha256 = "f525bd66622ceb6dcdf38d7f96cc3fbcf5e9cc8bc1f5f126e2fbc011a3dc1b68";
        libraryHaskellDepends = [
          base data-default-class monad-control pointed semigroupoids
          transformers transformers-base
@@ -132395,7 +132803,7 @@ self: {
      mkDerivation {
        pname = "transformers-base";
        version = "0.4.4";
-       sha256 = "11r3slgpgpra6zi2kjg3g60gvv17b1fh6qxipcpk8n86qx7lk8va";
+       sha256 = "6aa3494fc70659342fbbb163035d5827ecfd8079e3c929e2372adf771fd52387";
        revision = "1";
        editedCabalFile = "fb1a305f29cbf6ac182af7e67efaae9fcb9664d8d9606bb8a7f3414ad4c8d7a4";
        libraryHaskellDepends = [
@@ -132411,7 +132819,7 @@ self: {
      mkDerivation {
        pname = "transformers-compat";
        version = "0.4.0.4";
-       sha256 = "0lmg8ry6bgigb0v2lg0n74lxi8z5m85qq0qi4h1k9llyjb4in8ym";
+       sha256 = "d5231bc9929ed234032411038c0baae5a3d82939163c2a36582fbe657c46af52";
        libraryHaskellDepends = [ base transformers ];
        homepage = "http://github.com/ekmett/transformers-compat/";
        description = "A small compatibility shim exposing the new types from transformers 0.3 and 0.4 to older Haskell platforms.";
@@ -132423,7 +132831,7 @@ self: {
      mkDerivation {
        pname = "transformers-compose";
        version = "0.1";
-       sha256 = "0kvhl5s1js6i639hc6c4ib9jmgy4l1503ifs30a9ajrk97nagp6d";
+       sha256 = "cddca7ec49334b951418dac5014aa0c4bf2ad38a841906d330d1681974a1704f";
        libraryHaskellDepends = [ base transformers ];
        jailbreak = true;
        homepage = "http://github.com/aristidb/transformers-compose";
@@ -132439,7 +132847,7 @@ self: {
      mkDerivation {
        pname = "transformers-convert";
        version = "0.2.0.0";
-       sha256 = "0nx99jygbg5jlvb1sbgb9kz84af9861nkjdcshvfhlq8w069z737";
+       sha256 = "679c9f0ce00853e836d4acc9698341c92982fe4ceb2d1dd6a6b2bcf5bc4ca95b";
        libraryHaskellDepends = [ base data-easy either transformers ];
        testHaskellDepends = [
          base data-easy directory either errors haskell-src-exts hlint hspec
@@ -132457,7 +132865,7 @@ self: {
      mkDerivation {
        pname = "transformers-free";
        version = "1.0.1";
-       sha256 = "0fbzkr7ifvqng8wqi3332vwvmx36f8z167angyskfdd0a5rik2z0";
+       sha256 = "e08b197351a03537b57f561d133e7266f4baf916638c88397a166f174f9e7f39";
        libraryHaskellDepends = [ base transformers ];
        description = "Free monad transformers";
        license = stdenv.lib.licenses.bsd3;
@@ -132468,7 +132876,7 @@ self: {
      mkDerivation {
        pname = "transformers-lift";
        version = "0.1.0.0";
-       sha256 = "0fmd6v8a5r1x66v4cyb0adbajddm3mn1k43ryks01x1c3yw0p0sj";
+       sha256 = "52830bb81f2cf400f4f47990196c1db535a95653607946b6313de4a2d036ad3a";
        libraryHaskellDepends = [ base transformers ];
        description = "Ad-hoc type classes for lifting";
        license = stdenv.lib.licenses.bsd3;
@@ -132479,7 +132887,7 @@ self: {
      mkDerivation {
        pname = "transformers-runnable";
        version = "0.1.0.0";
-       sha256 = "0m1vvdfi661mmxm5rghsfnwcjd2r0r7ryc3jk0nwlzs0kaw5xi1s";
+       sha256 = "3ac45eb89a407fca2d9872309f4f065934c9b8751abe5c6aaf3518135ddb3b54";
        libraryHaskellDepends = [ base transformers ];
        jailbreak = true;
        homepage = "https://github.com/JanBessai/transformers-runnable";
@@ -132493,7 +132901,7 @@ self: {
      mkDerivation {
        pname = "transformers-supply";
        version = "0.1.0";
-       sha256 = "09f9n3cxi3sjmd8yscvcyahvdsqa5db5bckj9ryaflswsdm0ximq";
+       sha256 = "b8c60e6ad35c53a77c4e72b255562b0aebb6a1f26c33ed51ab528fd8d9b0c925";
        libraryHaskellDepends = [ base mtl transformers ];
        description = "Supply applicative, monad, applicative transformer and monad transformer";
        license = stdenv.lib.licenses.bsd3;
@@ -132504,7 +132912,7 @@ self: {
      mkDerivation {
        pname = "translatable-intset";
        version = "0.1";
-       sha256 = "0pv81l5q46a4f2dxps7fdzvmnphydgw7xz3xsi5cjad2kw0dsmkm";
+       sha256 = "7556dd009fa229c94ad47dfc7ef86b1e5e5bf76feee8db9b704419820b0d685f";
        isLibrary = true;
        isExecutable = true;
        libraryHaskellDepends = [ base fingertree ];
@@ -132518,7 +132926,7 @@ self: {
      mkDerivation {
        pname = "translate";
        version = "2010.1.24";
-       sha256 = "0vcqw0x7c9nb8yigvk35x72rds50kvma02rwkb757y1sk80q0mzf";
+       sha256 = "ee5780019a3af853ce9a3c0ba0ea9ea0e896c5e965ccfda247cb26763ae0986d";
        libraryHaskellDepends = [ base curl json network utf8-string ];
        homepage = "http://github.com/nfjinjing/translate";
        description = "Haskell binding to Google's AJAX Language API for Translation and Detection";
@@ -132531,18 +132939,48 @@ self: {
      mkDerivation {
        pname = "traverse-with-class";
        version = "0.2.0.3";
-       sha256 = "0snms19w3n9ni1wmf4ikwpp298nc6qk6phrjxi5g023ihqqdvr6g";
+       sha256 = "cfe4dd30867108f04aec32c36b2636cca224eee5331257798836d9c153d0d56a";
        libraryHaskellDepends = [ base template-haskell transformers ];
        description = "Generic applicative traversals";
        license = stdenv.lib.licenses.mit;
      }) {};
 
+  "travis-meta-yaml" = callPackage
+    ({ mkDerivation, aeson, base, bytestring, extra, file-embed, lens
+     , lens-aeson, optparse-applicative, regex-applicative, tasty
+     , tasty-quickcheck, text, unordered-containers, yaml
+     }:
+     mkDerivation {
+       pname = "travis-meta-yaml";
+       version = "0.1.0.0";
+       sha256 = "d5d9e8fe5c2e49fdd0beac1535d5d7567a6ab3e29d13bcc0c610e1865de09b94";
+       isLibrary = true;
+       isExecutable = true;
+       libraryHaskellDepends = [
+         aeson base bytestring file-embed lens lens-aeson regex-applicative
+         text unordered-containers yaml
+       ];
+       executableHaskellDepends = [
+         aeson base bytestring file-embed lens lens-aeson
+         optparse-applicative regex-applicative text unordered-containers
+         yaml
+       ];
+       testHaskellDepends = [
+         aeson base bytestring extra file-embed lens lens-aeson
+         regex-applicative tasty tasty-quickcheck text unordered-containers
+         yaml
+       ];
+       homepage = "https://github.com/phadej/travis-meta-yaml#readme";
+       description = ".travis.yml preprocessor";
+       license = stdenv.lib.licenses.bsd3;
+     }) {};
+
   "traypoweroff" = callPackage
     ({ mkDerivation, base, gtk, process }:
      mkDerivation {
        pname = "traypoweroff";
        version = "1.0.0";
-       sha256 = "0g7x1jj3x58jgbg6zcakyakc5jskcas03jakj7v5pfwdmk8kbc4m";
+       sha256 = "95b035d1ac8dbb5bf69153c901b46253cbc2a6f253b16fde7a12953ea40cfd3c";
        isLibrary = false;
        isExecutable = true;
        executableHaskellDepends = [ base gtk process ];
@@ -132558,7 +132996,7 @@ self: {
      mkDerivation {
        pname = "tree-monad";
        version = "0.3";
-       sha256 = "1zs1qgp908d0y7dm9mhzwl529z2aw24zr8balsvn1lzl1aynzslm";
+       sha256 = "95ea6fbd0af4d360b7a66aa1fc89e04afc240ae51fd654dbf1a02190eec341ff";
        libraryHaskellDepends = [ base ];
        homepage = "http://sebfisch.github.com/tree-monad";
        description = "Non-Determinism Monad for Tree Search";
@@ -132570,7 +133008,7 @@ self: {
      mkDerivation {
        pname = "tree-view";
        version = "0.4";
-       sha256 = "0mzywp6nipc6zs98dy4ny2s3r9d745lqpjazfnj5y4hx8swyckgn";
+       sha256 = "f64de6b9461d125fa4755fc98b6921a7a53cb4f096f88692fe86dd68cde5fe57";
        libraryHaskellDepends = [ base containers mtl ];
        description = "Render trees as foldable HTML and Unicode art";
        license = stdenv.lib.licenses.bsd3;
@@ -132583,7 +133021,7 @@ self: {
      mkDerivation {
        pname = "treemap-html";
        version = "0.1";
-       sha256 = "0jqjwg3z528z4wchpmi208lazd1nazqdai327lwxvznzjcq1m385";
+       sha256 = "058d1a3093dffedd393d6244d5f05736b4af280222d60b19271f89f2c7e3124b";
        libraryHaskellDepends = [
          base Cabal containers filepath ghc html parsec regex-posix
        ];
@@ -132600,7 +133038,7 @@ self: {
      mkDerivation {
        pname = "treemap-html-tools";
        version = "0.2";
-       sha256 = "0a7im8v118plxpi9dcgr1jhdlgj4f2a015dngyzfxqi7ij3cy6bf";
+       sha256 = "6e19cf868c27e2eebe7fb695009470443edaa00cf9b196e2edf4a21036aaf128";
        isLibrary = true;
        isExecutable = true;
        libraryHaskellDepends = [
@@ -132619,7 +133057,7 @@ self: {
      mkDerivation {
        pname = "treeviz";
        version = "1.0.0";
-       sha256 = "0nz93fn5k5fc9748h60a12j9gsl4ldm11a8y431mrm45jf8hnzq2";
+       sha256 = "027f0b919385d45cc3201ea9106aa384ea97a4080a1888c849cc9559ac1be95b";
        isLibrary = true;
        isExecutable = true;
        libraryHaskellDepends = [ base containers mtl QuickCheck random ];
@@ -132640,7 +133078,7 @@ self: {
      mkDerivation {
        pname = "tremulous-query";
        version = "1.0.7";
-       sha256 = "0vf6fh0p9ng2f0qqac8bqp259hfmv0bg146idm2pv668l1pkr7bx";
+       sha256 = "7d9d3c6fa0c8987d456dd190f016d8d5c154c4c50b31853170e2d9740174c66d";
        libraryHaskellDepends = [
          attoparsec base bytestring containers deepseq mtl network
        ];
@@ -132654,7 +133092,7 @@ self: {
      mkDerivation {
        pname = "trhsx";
        version = "0.2.2";
-       sha256 = "11jx2jf6vi7368ys39mz0ziy6xknbi0z87926n2y16am6k2h25k3";
+       sha256 = "631601c5345599e08535221df4415c7676e3e307bfa6a13d32e3c46d9c145d86";
        description = "Deprecated";
        license = stdenv.lib.licenses.bsd3;
        hydraPlatforms = stdenv.lib.platforms.none;
@@ -132667,7 +133105,7 @@ self: {
      mkDerivation {
        pname = "triangulation";
        version = "0.3";
-       sha256 = "0lx9y54n6p3xf3z6dzw0b2p87hwb1rrcgzilnl51fwvcs1m0fgdf";
+       sha256 = "ae3d076ad06c73170ab534fec7720e8bc383ae5880ff66fe707d5c6349f1a953";
        libraryHaskellDepends = [
          array base collada-types haskell98 tuple vector vector-algorithms
        ];
@@ -132688,7 +133126,7 @@ self: {
      mkDerivation {
        pname = "trifecta";
        version = "1.5.1.3";
-       sha256 = "1yd55bfhdn8ckkf2c5084fsnfwhib229xw9bn2a4lwpkzbbpflxw";
+       sha256 = "bc5377d7faf3724a94b02bf19e8458117267b523081426dc9c0cd906dd2aa5f9";
        revision = "1";
        editedCabalFile = "4aef1e889929b131bcfbc3b111cc865b1c31f86be983aee768adbfeadee03f2a";
        libraryHaskellDepends = [
@@ -132710,7 +133148,7 @@ self: {
      mkDerivation {
        pname = "trimpolya";
        version = "0";
-       sha256 = "1y559q5p0pzlr468224c6m5859z72gg0sk2vrgl82ilwkjn08i9i";
+       sha256 = "314504ac9c9c4681e8cb5b4c0dde13e7a7824a358c08810cc9f45f700b4ea5f8";
        isLibrary = false;
        isExecutable = true;
        executableHaskellDepends = [ base bio bytestring simpleargs ];
@@ -132725,7 +133163,7 @@ self: {
      mkDerivation {
        pname = "trivia";
        version = "0.0";
-       sha256 = "03xmzjqwk6492jmmbq6066ymsxb0wk0pmyf0c5f018nfps0g3i78";
+       sha256 = "e8c4f180becea2005c61c0f97ac1e460755dbd31c0e055ab148998c9b1fcb50f";
        libraryHaskellDepends = [ base comonad distributive ];
        homepage = "https://github.com/fumieval/trivia";
        description = "The trivial monad and comonad";
@@ -132737,7 +133175,7 @@ self: {
      mkDerivation {
        pname = "trivial-constraint";
        version = "0.3.0.0";
-       sha256 = "0fl72wai6yj5wflhx3cbvi3ixcfrc73217skncyb9b1ai7vg3x3y";
+       sha256 = "7ef4f1f6892aacb43cb3539f20c661d9b11e47dc8b8d0ea9e3457a131517873a";
        revision = "1";
        editedCabalFile = "c2fb0af78c16b340f5dfeb5bf5935250a7f70b72b9b5c07416aee2c8b9138b4b";
        libraryHaskellDepends = [ base ];
@@ -132751,7 +133189,7 @@ self: {
      mkDerivation {
        pname = "tropical";
        version = "0.0.0.2";
-       sha256 = "1in9jjfzbqws4bk83082yra2gcb5b095948qyji63ckbz3igp0k2";
+       sha256 = "6282fbe2f86bb261a2f4189154125865b12754f6028181e6229ae3f59d94c9c6";
        libraryHaskellDepends = [ base semiring-simple ];
        jailbreak = true;
        description = "A library for tropical mathematics";
@@ -132763,7 +133201,7 @@ self: {
      mkDerivation {
        pname = "true-name";
        version = "0.0.0.1";
-       sha256 = "1qp70i08hf7w90zyc4kz9hnyx8qaf925sy8x01r1z3dbxd473dgm";
+       sha256 = "f5b57148ebab8d1f72001d795d44720aa3ee2d4c7f12e63f48fc38884004e7e2";
        libraryHaskellDepends = [ base template-haskell ];
        testHaskellDepends = [ base containers template-haskell time ];
        homepage = "https://github.com/liyang/true-name";
@@ -132777,7 +133215,7 @@ self: {
      mkDerivation {
        pname = "truelevel";
        version = "0.1.3.1";
-       sha256 = "0q5civsnjwwhdkb16h8jak7prkfwvhds1p3xzzhwqk2p8dxf6jij";
+       sha256 = "324ae37a43574ccce1ff7ddca01bdcdccd7ccf54124113d66c907369f58eac60";
        isLibrary = false;
        isExecutable = true;
        executableHaskellDepends = [ base containers parseargs WAVE ];
@@ -132794,7 +133232,7 @@ self: {
      mkDerivation {
        pname = "trurl";
        version = "0.3.1.0";
-       sha256 = "0byg9gp6xgdy30mrjdlsijr87d6ivhj35baz5zpjxi6vgn8pa87v";
+       sha256 = "fb2075917ddbc42eef2f5fad3224dcd1b483b28c9a36992b18bebd6eee4bcf2f";
        isLibrary = true;
        isExecutable = true;
        libraryHaskellDepends = [
@@ -132813,7 +133251,7 @@ self: {
      mkDerivation {
        pname = "tsession";
        version = "0.1";
-       sha256 = "1rj11vyd272h66cjx8pq6smcpi65n3vlfv4g7indcnpcz4w5l6rk";
+       sha256 = "331b5a38f9ec5ad66c3c8f6c47f7b0c5c4cbaa36f8a22e9931501cd1fc0e41e6";
        revision = "2";
        editedCabalFile = "afd89984a633388a2db5ad107968c92693527eb6f746318c4752993633705e57";
        libraryHaskellDepends = [ base containers mtl time transformers ];
@@ -132827,7 +133265,7 @@ self: {
      mkDerivation {
        pname = "tsession-happstack";
        version = "0.1";
-       sha256 = "1sv62iqrlvzx95g6nd307y8zknp2h3ir06zc6qw4y221wz21rfyz";
+       sha256 = "dfbb1cc4e741084f3836ec1b90e380e2daf9913f60346b5e49fd6f9a711466eb";
        libraryHaskellDepends = [
          base happstack-server transformers tsession
        ];
@@ -132841,7 +133279,7 @@ self: {
      mkDerivation {
        pname = "tskiplist";
        version = "1.0.0";
-       sha256 = "0bayh8fl3wb98mifdiss8crb17jfqxxj0f1va5c2h4l7qwizh85a";
+       sha256 = "aa20f823c787122858513b38207bc74e9eb032435ac7e6624569f1411d825e2d";
        libraryHaskellDepends = [ array base containers random stm ];
        homepage = "https://github.com/thaldyron/tskiplist";
        description = "A Skip List Implementation in Software Transactional Memory (STM)";
@@ -132854,7 +133292,7 @@ self: {
      mkDerivation {
        pname = "tslogger";
        version = "0.1.0.0";
-       sha256 = "1xybllaxakzlai0ja93fyw8yr0p56g58f5akc5z9pi4w4493c7dl";
+       sha256 = "b41d3612219cc49b7e61531587ca33e582ec11f76e24254154f44fd515a5cbf7";
        libraryHaskellDepends = [ async base containers random ];
        jailbreak = true;
        description = "Thread-safe logging";
@@ -132866,7 +133304,7 @@ self: {
      mkDerivation {
        pname = "tsp-viz";
        version = "0.1.0.0";
-       sha256 = "0wrnpmvds2amm85a5j1c1nqffy6vj4y6xq21w5ia1051wrxzrbjk";
+       sha256 = "53aefc7be6a180a062e141e06e3c91db78e7b00d2cc8a20aaa5509dd76bd3673";
        isLibrary = false;
        isExecutable = true;
        executableHaskellDepends = [ base gloss stm vector ];
@@ -132884,7 +133322,7 @@ self: {
      mkDerivation {
        pname = "tsparse";
        version = "0.4.0.0";
-       sha256 = "0s5vlpvi1w6q2zxv586plvhs9p6rlc7653x7jzygfir70754n6si";
+       sha256 = "511b4bca012747f7fc97a78f620ea3d9dca4e1a6d7a0b2fb17d8f010f7a5bb68";
        isLibrary = true;
        isExecutable = true;
        libraryHaskellDepends = [
@@ -132904,7 +133342,7 @@ self: {
      mkDerivation {
        pname = "tst";
        version = "0.1.1";
-       sha256 = "1vr1l4pm02pwr8238qd9j0drkildns8m79qyq0lbzll30gc12vhx";
+       sha256 = "1d6e11d80383d2bf28c01ea75391b68dc6991b90a9613404cafc0a502fa121ef";
        libraryHaskellDepends = [ base ];
        homepage = "https://github.com/bitonic/language-spelling";
        description = "BK-tree implementation";
@@ -132919,7 +133357,7 @@ self: {
      mkDerivation {
        pname = "ttrie";
        version = "0.1.2";
-       sha256 = "09nbba623nxnlg1957sgcrrva3ycwb31asxnxihwjh0wxrqhh1k0";
+       sha256 = "60060871ee1c40c961ecb66b15c6e2cc0fb573664f9f92c2a3b6db218c5acb26";
        revision = "2";
        editedCabalFile = "f517a1ee4ab2eeefe39ec336a793845f84333835c59c3e90f885dd0711f8fbc0";
        libraryHaskellDepends = [
@@ -132944,7 +133382,7 @@ self: {
      mkDerivation {
        pname = "tttool";
        version = "1.4.0.3";
-       sha256 = "0mypgqgqaf2c74vka1pmqzrvz1kwl8pjm1llh4bflizfzrxq3s9d";
+       sha256 = "2de9817bfeee47ea168194862a2fa27c86bff3c7f5063537394c38851f7ed757";
        isLibrary = false;
        isExecutable = true;
        executableHaskellDepends = [
@@ -132962,7 +133400,7 @@ self: {
      mkDerivation {
        pname = "tubes";
        version = "0.2.2.3";
-       sha256 = "0qmg2w4sjm0q1h6ajkv3i576zsi2ndbacjsn5sibcwjbdpkpwmdr";
+       sha256 = "b9557ee76d4b72b6a22e564ba656b322ea6f4e89634fa90c0c1854a90917af62";
        libraryHaskellDepends = [ base comonad free mtl transformers ];
        homepage = "https://github.com/gatlin/tubes";
        description = "Effectful, iteratee-inspired stream processing based on a free monad";
@@ -132974,7 +133412,7 @@ self: {
      mkDerivation {
        pname = "tuntap";
        version = "0.0.2";
-       sha256 = "0q6g2wcjddb9r1l9fxpn2qcssw5gyfwsam15rc3q6xjqbwz7fm41";
+       sha256 = "8154773e5f58768307cb2554a5b9f3af70ad1916f6769768c869b5261917cf60";
        libraryHaskellDepends = [ base bytestring unix ];
        jailbreak = true;
        description = "Interface to TUN/TAP drivers";
@@ -132987,7 +133425,7 @@ self: {
      mkDerivation {
        pname = "tup-functor";
        version = "0.3.0.0";
-       sha256 = "1kj68g5g9m46dpncbrisl19gah8pzac33iyr09ym1pqk3x6jh9ix";
+       sha256 = "3d26284d1f13df507d02d9c73198fa1741f552a03ae6c5ec6d86d4f4ca4346ce";
        isLibrary = true;
        isExecutable = true;
        libraryHaskellDepends = [ base cpphs ];
@@ -133003,7 +133441,7 @@ self: {
      mkDerivation {
        pname = "tuple";
        version = "0.3.0.2";
-       sha256 = "094nx29aahyrvbcn7yca9zs2a5rxz1is7510w1q43rpvza7hdjrg";
+       sha256 = "2fcb068ffafbe64170e02094a363f83d1725f44f8af963d9dad943a592e89624";
        libraryHaskellDepends = [ base OneTuple ];
        description = "Various functions on tuples";
        license = stdenv.lib.licenses.bsd3;
@@ -133014,7 +133452,7 @@ self: {
      mkDerivation {
        pname = "tuple-gen";
        version = "2.0";
-       sha256 = "0bgwsxq8wrh76hhbwadv0rag4c7dx3644zrh2aflnsych0rncvd7";
+       sha256 = "a76d663380cc6b4b9d12307f42cce8ed30f25406bb29be203407668e70d7fc2d";
        libraryHaskellDepends = [ base combinat ];
        jailbreak = true;
        description = "Enum instances for tuples where the digits increase with the same speed";
@@ -133027,7 +133465,7 @@ self: {
      mkDerivation {
        pname = "tuple-generic";
        version = "0.5.0.0";
-       sha256 = "0cbmiwmwav0g9di1s0sdry9shijqzpb9zaag9dz95w65wgqkfzbw";
+       sha256 = "7c7d37f1e3c5f0927e4b4fa99fd6fd5846a893cf4d031d624b0f6cc52b8f7531";
        libraryHaskellDepends = [ base ];
        homepage = "http://github.com/aelve/tuple-generic";
        description = "Generic operations on tuples";
@@ -133039,7 +133477,7 @@ self: {
      mkDerivation {
        pname = "tuple-hlist";
        version = "0.2.0.0";
-       sha256 = "0z1mmm6gnhv3c4hn60v1yasvr9j5rakvyma4c535s51hk5s7g7bl";
+       sha256 = "749d77749930145d46614455bfa7ca45a6bcb5f261036321616343fb4cad357c";
        libraryHaskellDepends = [ base HList OneTuple ];
        jailbreak = true;
        homepage = "http://github.com/dudebout/tuple-hlist";
@@ -133052,7 +133490,7 @@ self: {
      mkDerivation {
        pname = "tuple-lenses";
        version = "0.1.0.2";
-       sha256 = "1qq1sla89410wr9pnkmj100izkraad1gr163815p3dvh7qi04c7w";
+       sha256 = "fc3002223e70b7714b40c384fc42532acf1f0108b24e7b53e620908414d501e3";
        libraryHaskellDepends = [ base lens template-haskell ];
        jailbreak = true;
        homepage = "http://github.com/jfischoff/tuple-lenses";
@@ -133065,7 +133503,7 @@ self: {
      mkDerivation {
        pname = "tuple-morph";
        version = "0.1.0.0";
-       sha256 = "1zi6nh1z7z2jz5h0pvdm2czfy1rx7ixnnvp9akcpas19npgyfk94";
+       sha256 = "244de7dfb5296875d954e96e6b7b3c3d07ef3e13b5ed0b60f952fcf303b426fe";
        revision = "4";
        editedCabalFile = "835c4661ff3b962ec5fa6f1899c6cb0d241362f06636478935fd5475c684eada";
        libraryHaskellDepends = [ base HList template-haskell ];
@@ -133079,7 +133517,7 @@ self: {
      mkDerivation {
        pname = "tuple-th";
        version = "0.2.5";
-       sha256 = "1mrl4vvxmby7sf1paf7hklzidnr6wq55822i73smqyz0xpf3gsjn";
+       sha256 = "56ea37dcede07b5cf5385108540ae626db163f9df0387583d3c7afdaf72634d7";
        libraryHaskellDepends = [ base containers template-haskell ];
        description = "Generate (non-recursive) utility functions for tuples of statically known size";
        license = stdenv.lib.licenses.bsd3;
@@ -133090,7 +133528,7 @@ self: {
      mkDerivation {
        pname = "tupleinstances";
        version = "0.0.1";
-       sha256 = "0kcmcg1fxsslpzpg766r9hr8aysg0s5fyang2xc0aa77zi71qyi3";
+       sha256 = "237a1c4efce728055817cf2aef8a064f7b85324cd998f3eebf54ebeec263954d";
        libraryHaskellDepends = [ base template-haskell ];
        jailbreak = true;
        homepage = "http://github.com/diegoeche/tupleinstances";
@@ -133104,7 +133542,7 @@ self: {
      mkDerivation {
        pname = "tuples-homogenous-h98";
        version = "0.1.1.0";
-       sha256 = "0fhz246wh6x0s0sjkmd3qcylsx2gfrmgmvgb7js2zjg91y7zqnh2";
+       sha256 = "025afc8f0fe9c92fb43cebedfa6a764f744d3dc3a3d52935d0a01bc80d111f3a";
        libraryHaskellDepends = [ base ];
        homepage = "https://github.com/ppetr/tuples-homogenous-h98";
        description = "Wrappers for n-ary tuples with Traversable and Applicative/Monad instances";
@@ -133116,7 +133554,7 @@ self: {
      mkDerivation {
        pname = "turing-music";
        version = "0.1.1";
-       sha256 = "163fggvjixs6m2rwc3gd3s9703r2mnz3bknii1aagwzvw5kczky3";
+       sha256 = "c3cfcf66e1fbf3a75488d1ce35bead220f70921eed0dc6b3a846f728f77b6e98";
        isLibrary = false;
        isExecutable = true;
        executableHaskellDepends = [ ALUT base ];
@@ -133129,7 +133567,7 @@ self: {
      mkDerivation {
        pname = "turkish-deasciifier";
        version = "0.1.0.0";
-       sha256 = "0dk63dknwxi7v67jn9b747mkyiz2af4b76a9q1ynn16xva2qsh93";
+       sha256 = "23418d85dadd046b7dc04999b38853e2473feb2167252b8fd927766e671b6636";
        isLibrary = true;
        isExecutable = true;
        libraryHaskellDepends = [ base containers vector ];
@@ -133145,7 +133583,7 @@ self: {
      mkDerivation {
        pname = "turni";
        version = "2011.1.15";
-       sha256 = "0152xhvm0x1ncjdib0bckhywgpzm4f1qj1ghs0jn84cz562ddwnl";
+       sha256 = "d4f2d684299f116425d0f005898323f5dfc73d9c6c81159b6436745037eca204";
        isLibrary = false;
        isExecutable = true;
        executableHaskellDepends = [ base containers MonadRandom random ];
@@ -133163,7 +133601,7 @@ self: {
      mkDerivation {
        pname = "turtle";
        version = "1.2.1";
-       sha256 = "01l4gnl5qyvi7kwn0yzhkrs0yawm5ncqbbb150nxm5r3zky8cn4w";
+       sha256 = "9c5886fcfc2397da2d2861ad85992d952b0f749ef07b60f93c717b5ca87d8406";
        libraryHaskellDepends = [
          async base clock directory foldl hostname managed optional-args
          optparse-applicative process system-fileio system-filepath
@@ -133179,7 +133617,7 @@ self: {
      mkDerivation {
        pname = "tweak";
        version = "0.1.0.1";
-       sha256 = "1l5y94gac9s55wgn6w610pqb63c8l20vmlpsnmgbzw1f9vbnzgiw";
+       sha256 = "3cbe6fd74e2ef0bf5eb5fad2ba81a0880db3f005c170631f2f4527a61e49bed0";
        libraryHaskellDepends = [ base containers lens stm transformers ];
        jailbreak = true;
        homepage = "http://github.com/jfischoff/tweak";
@@ -133192,7 +133630,7 @@ self: {
      mkDerivation {
        pname = "twentefp";
        version = "0.4.2";
-       sha256 = "1kmf907i6g6lfhw8g403b6701srrd298n4r53dvcqzy72c5qaixl";
+       sha256 = "b447850b13c77fcc761b25138b926839eb008e590390873874d43c130f48aece";
        libraryHaskellDepends = [ base gloss parsec time ];
        description = "Lab Assignments Environment at Univeriteit Twente";
        license = stdenv.lib.licenses.bsd3;
@@ -133205,7 +133643,7 @@ self: {
      mkDerivation {
        pname = "twentefp-eventloop-graphics";
        version = "0.1.0.4";
-       sha256 = "086vx0849c7kmsz5pa4jwzp24cwaf4482bq37dr7jrqx22hvk4lm";
+       sha256 = "9592b9a1101d6779723b032f8108718a3322eee792a85bbeaef3b04410e8db20";
        revision = "1";
        editedCabalFile = "2a887ef5e938d11f5944ea59ced4cf4bd22930b452f6e6b884f58031761cf817";
        libraryHaskellDepends = [
@@ -133221,7 +133659,7 @@ self: {
      mkDerivation {
        pname = "twentefp-eventloop-trees";
        version = "0.1.1.0";
-       sha256 = "1zn3bz2119jcyangs7mi2s9wcjkqgk54vwg6rfcbfg37m1v1ixy4";
+       sha256 = "c4f71876a8673cb798cbe6f14dca7c784ac69316b11efdacf24ca610c45fc3fe";
        libraryHaskellDepends = [ base eventloop ];
        description = "Tree type and show functions for lab assignment of University of Twente. Contains RoseTree and RedBlackTree";
        license = stdenv.lib.licenses.bsd3;
@@ -133232,7 +133670,7 @@ self: {
      mkDerivation {
        pname = "twentefp-graphs";
        version = "0.1.0.4";
-       sha256 = "0g0py8cb4z9i9pjhka2pyjm8vfai9x3k0vmlb06g157ish97qvir";
+       sha256 = "396e7c12d4f194f00c58b46e30474f51b98daaf457a809e54d317db218f2173c";
        libraryHaskellDepends = [ base twentefp-eventloop-graphics ];
        description = "Lab Assignments Environment at Univeriteit Twente";
        license = stdenv.lib.licenses.bsd3;
@@ -133243,7 +133681,7 @@ self: {
      mkDerivation {
        pname = "twentefp-number";
        version = "0.1.0.2";
-       sha256 = "1kh0a6h4syx98ygwidw6cc24ci91v1blshpfcczx96z850x1h6xf";
+       sha256 = "ae1b183a28e89bd43f63ee424d57d8214546046386b7c89f47a97b4da05100ce";
        libraryHaskellDepends = [ base parsec ];
        description = "Lab Assignments Environment at Univeriteit Twente";
        license = stdenv.lib.licenses.bsd3;
@@ -133255,7 +133693,7 @@ self: {
      mkDerivation {
        pname = "twentefp-rosetree";
        version = "0.1.0.1";
-       sha256 = "1dy4hmwciaglz2kfdk9fxf6hik7pgr4a4xj9y9l7s7p4k35r5bd7";
+       sha256 = "a7ad92cb98e41e7d68f24976a2487ef7cc088deb2ecde6a6f8f4a9c87885c4b7";
        libraryHaskellDepends = [
          base twentefp-eventloop-graphics twentefp-number
        ];
@@ -133270,7 +133708,7 @@ self: {
      mkDerivation {
        pname = "twentefp-trees";
        version = "0.1.0.2";
-       sha256 = "0mmj96xbqjzm4cylk39pib9jfwh6m350q1cwf6ij8pl0swab3b0g";
+       sha256 = "0facb114d7805e24a3719c050ccaa8067227d38a378d493d23f54bbcba49b256";
        libraryHaskellDepends = [ base twentefp-eventloop-graphics ];
        description = "Tree type and show functions for lab assignment of University of Twente. Contains RoseTree and ParseTree";
        license = stdenv.lib.licenses.bsd3;
@@ -133284,7 +133722,7 @@ self: {
      mkDerivation {
        pname = "twentefp-websockets";
        version = "0.1.0.1";
-       sha256 = "08227phlyvvg01n7zqyivx2f3dpfbipxaajqz4fc07zhkpmxy8h4";
+       sha256 = "0422dfeb9df01fc01cf9582ad56f5ceeb6e144dfd1e37f6c006f6f4fe13d4220";
        libraryHaskellDepends = [
          attoparsec base base64-bytestring binary blaze-builder bytestring
          case-insensitive concurrent-extra containers entropy io-streams mtl
@@ -133305,7 +133743,7 @@ self: {
      mkDerivation {
        pname = "twhs";
        version = "0.1.0.3";
-       sha256 = "0d06bv26lvr4va431h2146v88bqcxvfr0wp36f7l4a6xqgghf2l1";
+       sha256 = "810a07dfc3dd28428f33e37290ddee0c2f84b62141c03088da246f6ac45e0634";
        isLibrary = true;
        isExecutable = true;
        libraryHaskellDepends = [
@@ -133336,7 +133774,7 @@ self: {
      mkDerivation {
        pname = "twidge";
        version = "1.1.2";
-       sha256 = "162n5w4z3a1qyasd39q7751z872v31njzyhrnjfjxhsni3kif8b1";
+       sha256 = "612117e78856c32e9db419fa2f6d185b1cf4433907a7d1b4f238a8f1092f5698";
        isLibrary = false;
        isExecutable = true;
        executableHaskellDepends = [
@@ -133356,7 +133794,7 @@ self: {
      mkDerivation {
        pname = "twilight-stm";
        version = "1.2";
-       sha256 = "1hp9mkfasjyh1ji6gfmdpmx3nm9g22ag3y47nva7i30bjrs65cdr";
+       sha256 = "b9b16274960b8c78d4b687f8f194102f553b7abdadba67a20cd04baddcace9c2";
        libraryHaskellDepends = [ base containers haskell98 mtl ];
        homepage = "http://proglang.informatik.uni-freiburg.de/projects/twilight/";
        description = "STM library with safe irrevocable I/O and inconsistency repair";
@@ -133373,7 +133811,7 @@ self: {
      mkDerivation {
        pname = "twilio";
        version = "0.1.2.0";
-       sha256 = "05qhg9djp71xdwzb88xdnrg3zjbd6p8xb4gwzp0l6m3gc9wi7nvp";
+       sha256 = "77db1379626f5443c1fdfc91d5d1356dc93f5eb6ad23b43e6f3d9c2b5b7a1017";
        libraryHaskellDepends = [
          aeson base bifunctors bytestring containers errors exceptions free
          http-client http-client-tls http-types mtl network-uri old-locale
@@ -133398,7 +133836,7 @@ self: {
      mkDerivation {
        pname = "twill";
        version = "0.1.0.3";
-       sha256 = "0wkcxjfpd5fz72hwg8spxjqk8b6axm51zppld00q9f3dzagsbwx6";
+       sha256 = "a6f3a59ffa6db8840168f4de1f4aedca2c34b1ec57a3c7a138df95769dec6c72";
        libraryHaskellDepends = [
          aeson attoparsec base base16-bytestring base64-bytestring
          bytestring cryptohash data-default datetime errors old-locale
@@ -133415,7 +133853,7 @@ self: {
      mkDerivation {
        pname = "twiml";
        version = "0.1.0.0";
-       sha256 = "0ipc8i1hbsjdz6rp7ks25w0zbrcv4byp0791aw9rrdpyqzdir0zx";
+       sha256 = "fd831cdbc7feb69c1357211d70fd229be5f5012f42cf73b3f94dea054344ec46";
        libraryHaskellDepends = [ base network xml ];
        testHaskellDepends = [ base Cabal lens ];
        jailbreak = true;
@@ -133432,7 +133870,7 @@ self: {
      mkDerivation {
        pname = "twine";
        version = "0.1.2";
-       sha256 = "0q4dsh6x1w1indsx070rqayvjlzdk2nznvh0cjxd5f3jn5ggwwb1";
+       sha256 = "6171fe5eb172b8d2ba64006efbad98ed53b9bdc2191cd075b331f0d00dd48d60";
        libraryHaskellDepends = [
          base bytestring containers convertible filepath mtl parsec
        ];
@@ -133449,7 +133887,7 @@ self: {
      mkDerivation {
        pname = "twisty";
        version = "0.1.0";
-       sha256 = "02w8763m6gm9wj035s62ydg63iv7wa2cbjq2g1jd283vf2djsjyj";
+       sha256 = "d24b2d9b707b20d1647802cbc584e267c7615ef3c2e83280e4a93e538739880b";
        libraryHaskellDepends = [
          array base containers data-memocombinators MonadRandom parallel
        ];
@@ -133467,7 +133905,7 @@ self: {
      mkDerivation {
        pname = "twitch";
        version = "0.1.6.1";
-       sha256 = "0hvwcnkjma3ib00qa7ymiyrvspa7ixxp0w3wgs9zjrs49j36dmak";
+       sha256 = "53d566864c4467f9937e7c70707b8f475dbdb38fd51f85015871a82aa7657c43";
        libraryHaskellDepends = [
          base data-default directory fsnotify Glob optparse-applicative
          system-fileio system-filepath time transformers
@@ -133490,7 +133928,7 @@ self: {
      mkDerivation {
        pname = "twitter";
        version = "0.1.1";
-       sha256 = "12q5w9wfnrzh2gjmq66qhwy6i6wixfb805jg2cbphxrjjnc2v9gx";
+       sha256 = "fda52d989532777817134f168096eb919b683c87d8185ce513f067eb78e2058b";
        isLibrary = false;
        isExecutable = true;
        executableHaskellDepends = [
@@ -133513,7 +133951,7 @@ self: {
      mkDerivation {
        pname = "twitter-conduit";
        version = "0.1.1";
-       sha256 = "0rair336wjgg5pd0vh3g3nlc64f5sw2sg60jj2sjaxv296jvr3xx";
+       sha256 = "bd8fbca549627725b5901298a705d7c511c3a81d6fc00dda2def496ec6c85165";
        isLibrary = true;
        isExecutable = true;
        libraryHaskellDepends = [
@@ -133545,7 +133983,7 @@ self: {
      mkDerivation {
        pname = "twitter-enumerator";
        version = "0.0.3";
-       sha256 = "1c8y7kq0x7lnq7x7ah8c78q6cy2963nz6y83klzh2jgmr8rma6q4";
+       sha256 = "041b5533caf549013f9d0379f3ed30497866303a0c4175fac1969e0ef03c1eb1";
        libraryHaskellDepends = [
          aeson attoparsec attoparsec-enumerator authenticate base bytestring
          containers enumerator http-enumerator http-types text tls-extra
@@ -133566,7 +134004,7 @@ self: {
      mkDerivation {
        pname = "twitter-feed";
        version = "0.2.0.2";
-       sha256 = "19kwhk0bvwnyhychvfzc09w00ix7z9fmvrb4vv56vxdg20rni3fk";
+       sha256 = "d38d683310aff56dcade64e55d5dfaa747007802ecbb0d9987def2bdc0847ca6";
        libraryHaskellDepends = [
          aeson authenticate-oauth base bytestring http-conduit
        ];
@@ -133588,7 +134026,7 @@ self: {
      mkDerivation {
        pname = "twitter-types";
        version = "0.7.0";
-       sha256 = "0smzz3y6xgb0yddp62bvw4j278fw5dnjffrjfxz3dc6hd602cvlh";
+       sha256 = "906e268069d0b0367e77323b276d2bdca12324e17b09735bf360bd6efcf8bf6a";
        libraryHaskellDepends = [
          aeson base text time unordered-containers
        ];
@@ -133611,7 +134049,7 @@ self: {
      mkDerivation {
        pname = "twitter-types-lens";
        version = "0.7.0";
-       sha256 = "1775ydjpv0rii3zbz60xl8dz3537fcid3j4867ynw0zvk1sl01wc";
+       sha256 = "8c07407598fb036efd3188c8d122736794f11ba21d98bffe8831837d65f3e59c";
        libraryHaskellDepends = [
          base lens template-haskell text time twitter-types
        ];
@@ -133628,7 +134066,7 @@ self: {
      mkDerivation {
        pname = "tx";
        version = "0.1.0.0";
-       sha256 = "18fpkpri2g93vxw3qdk94nc4zlh5kqgfbvdmzkwqjadkck39alsy";
+       sha256 = "5e5395c664b32989f9fcb5ede51e9e05d24f982569363c78df233d11f39dd7a1";
        libraryHaskellDepends = [
          base bytestring cereal safecopy stm transformers
        ];
@@ -133646,7 +134084,7 @@ self: {
      mkDerivation {
        pname = "txt-sushi";
        version = "0.6.0";
-       sha256 = "0375q8qcirkalz6n48rkylkx1j8z5gvjhh8n2fdvvjqvn064q1s6";
+       sha256 = "46074c0cb01bcbbd9b13164128f72b1fc9d027f5332362cda76ae6c830c2e50c";
        isLibrary = true;
        isExecutable = true;
        libraryHaskellDepends = [
@@ -133662,7 +134100,7 @@ self: {
      mkDerivation {
        pname = "txt2rtf";
        version = "1.0.1";
-       sha256 = "0vn01ppcmdfi9n9f8h62ll9f08nda2pcrxvck0lgkwzky54v19s4";
+       sha256 = "44a7b049f1f3f3f928986cf7ccae50cd22e012a5c240e4924dd1b5caee0dc06e";
        isLibrary = false;
        isExecutable = true;
        executableHaskellDepends = [ base ];
@@ -133676,7 +134114,7 @@ self: {
      mkDerivation {
        pname = "txtblk";
        version = "0.2.0.1";
-       sha256 = "08qpdyb1dbkif4zwrap6478fsf7lha6hk18wm0r4803avrr5w2bb";
+       sha256 = "6b095e72de6a004432a81c85098d82f438edd021e6aacc3f7171ae16966f1723";
        libraryHaskellDepends = [ base ];
        jailbreak = true;
        description = "Deprecated in favor of eros";
@@ -133688,7 +134126,7 @@ self: {
      mkDerivation {
        pname = "ty";
        version = "0.1.6";
-       sha256 = "0i18c293f6dz7qgr5z4x6rzndhqv5q7myw1wvs8i9ld23d87fjhy";
+       sha256 = "1e4a77501ba2d11491de3c705f0f2e1bc3667f369dfc921f3ebf193792602844";
        libraryHaskellDepends = [ base ghc-prim ];
        homepage = "https://github.com/conal/ty";
        description = "Typed type representations and equality proofs";
@@ -133702,7 +134140,7 @@ self: {
      mkDerivation {
        pname = "typalyze";
        version = "0.1.1";
-       sha256 = "1wc1z7ps1rcbws2snci64hxddjd3bi3kbi4iwvbfaac0dz52085m";
+       sha256 = "b52020ca6f8029e5d6e691c435475ca3c9d63a242632ab85e68be5a0eff981f1";
        isLibrary = false;
        isExecutable = true;
        executableHaskellDepends = [
@@ -133719,7 +134157,7 @@ self: {
      mkDerivation {
        pname = "type-aligned";
        version = "0.9.6";
-       sha256 = "0mfyd9w13kd3ha43220p9qabw828xv19sxywy9imadpwrdqp51qv";
+       sha256 = "1b877271cbfc365563f2dc779dc2ee4820be144e1708318882a3cd11786ade55";
        libraryHaskellDepends = [ base ];
        homepage = "https://github.com/atzeus/type-aligned";
        description = "Various type-aligned sequence data structures";
@@ -133731,7 +134169,7 @@ self: {
      mkDerivation {
        pname = "type-booleans";
        version = "0.1";
-       sha256 = "11kbnfbvclkdwirnnpdi4f20pibdar4l47anvnkaxxl330zi7yfh";
+       sha256 = "d0f9133f1883f6aea6dd561d4249566dc50b8423b15d6b73e46d52b697b36b86";
        libraryHaskellDepends = [ base ];
        description = "Type-level booleans via type-families";
        license = stdenv.lib.licenses.bsd3;
@@ -133744,7 +134182,7 @@ self: {
      mkDerivation {
        pname = "type-cereal";
        version = "0.3";
-       sha256 = "1w1s1c7f2q5zwc9fghbbd1nhavh0mzzndh0mdxr7sy88a523svcv";
+       sha256 = "9b6d3d445108797d726f15c066ffaf006e056d686bc1e712e3bf60e10e0b3af0";
        libraryHaskellDepends = [
          base bytestring cereal data-hash template-haskell type-digits
          type-spine
@@ -133759,7 +134197,7 @@ self: {
      mkDerivation {
        pname = "type-digits";
        version = "0.3";
-       sha256 = "0rmqy3wcypyq09gnfz0xvkr2ly9gnpsjnil2n981ajfxsk2shi58";
+       sha256 = "a844a8c5d4dd491550b282462bf5b52f792af2dc1d7c675f02d85fcff8f0b866";
        libraryHaskellDepends = [ base template-haskell type-spine ];
        description = "Arbitrary-base type-level digits";
        license = stdenv.lib.licenses.bsd3;
@@ -133771,7 +134209,7 @@ self: {
      mkDerivation {
        pname = "type-eq";
        version = "0.5";
-       sha256 = "007srln0xxi27wca8dk72xp3cdwnk8iqmlqgbxi17c9l2x7lrkwz";
+       sha256 = "9fcf4c4f1734b113625f0fd38a239a9637366e176736a4183f22f60e2ccdfa00";
        libraryHaskellDepends = [ base ];
        libraryToolDepends = [ cpphs ];
        homepage = "http://github.com/glaebhoerl/type-eq";
@@ -133784,7 +134222,7 @@ self: {
      mkDerivation {
        pname = "type-equality";
        version = "0.1.2";
-       sha256 = "06acqpkvyvalv5knjzzbgm40hzas6cdfsypvjxsbb0mhq4d80xwr";
+       sha256 = "9977801ac1b082b57497fb7aed1a335a7d08487deb7f6967d9546dbfe7c54c19";
        libraryHaskellDepends = [ base ];
        homepage = "http://github.com/hesselink/type-equality/";
        description = "Type equality, coercion/cast and other operations";
@@ -133796,7 +134234,7 @@ self: {
      mkDerivation {
        pname = "type-equality-check";
        version = "0.0.0.3";
-       sha256 = "0fsj2mbsbhiqlv6dlkkwh3af5kx8qcif9374wiy7zf62pz4bry67";
+       sha256 = "c7f8bcc8bfc2b87f7ce4e48ce422c3a8cfe2d4807c4edacca638c2a55715523b";
        libraryHaskellDepends = [ base type-level ];
        homepage = "http://darcs.wolfgang.jeltsch.info/haskell/type-equality-check";
        description = "Type equality check";
@@ -133809,7 +134247,7 @@ self: {
      mkDerivation {
        pname = "type-functions";
        version = "0.2.0.3";
-       sha256 = "1vs6wk1z3zp3s1fxbz6bnfjlkdrcs6v4ihdnr504z9qklwb91vam";
+       sha256 = "55ed9016a713a74f40c9b6c148b6d12cb749a5b3cbfcd55dd0e3fef1c3e446ef";
        libraryHaskellDepends = [ base kinds ];
        homepage = "http://darcs.wolfgang.jeltsch.info/haskell/type-functions";
        description = "Emulation of type-level functions";
@@ -133821,7 +134259,7 @@ self: {
      mkDerivation {
        pname = "type-hint";
        version = "0.1";
-       sha256 = "1fcrma7m6y7i1y42rzhv7qch8xkk93lkh1767saw4hsb9fzwsq8i";
+       sha256 = "1161cdbf4b4b43c2953ee60438e948737604193e1bfe2c880ff178538faa99b9";
        libraryHaskellDepends = [ base ];
        homepage = "https://github.com/mvv/type-hint";
        description = "Guide type inference with proxy values";
@@ -133833,7 +134271,7 @@ self: {
      mkDerivation {
        pname = "type-int";
        version = "0.5.0.2";
-       sha256 = "1lakw4mvkii32a570zain510n9x7b2ka2r3qj5rpil1j4bpc662w";
+       sha256 = "5c18c3ee2232d07873917864a1a658a7270b42b1517d708a1223c6b92be153d1";
        libraryHaskellDepends = [ base template-haskell ];
        homepage = "http://github.com/ekmett/type-int";
        description = "Type Level 2s- and 16s- Complement Integers";
@@ -133846,7 +134284,7 @@ self: {
      mkDerivation {
        pname = "type-iso";
        version = "0.1.0.0";
-       sha256 = "03qs8frsj0a2jxpk1rrmhaivf68hg8dhjn4s3q85h4zrsxwfskjx";
+       sha256 = "5d4eed78d7f91358101e9a58091b7a1019b7a38235e7306f974201a9b3431a0f";
        libraryHaskellDepends = [
          base data-default nats numericpeano text
        ];
@@ -133860,7 +134298,7 @@ self: {
      mkDerivation {
        pname = "type-level";
        version = "0.2.4";
-       sha256 = "1cgph4y6j7wnzglzz89zd60f1mv8v82vp0n1bmkp4yqq0w2wmg9v";
+       sha256 = "3bbdca0507187b72675dc182bb05da68d7e080693fa1ffe9fb961f693c81f7b1";
        libraryHaskellDepends = [ base syb template-haskell ];
        homepage = "http://code.haskell.org/type-level";
        description = "Type-level programming library";
@@ -133873,7 +134311,7 @@ self: {
      mkDerivation {
        pname = "type-level-bst";
        version = "0.1";
-       sha256 = "0c51p6dy84ddikj6jch5hljn1i37q38wbak3chbc3ds5r674y5hk";
+       sha256 = "13164f8ec945b7c1166463aac5d1c067c4602585053269e48cad11e49bb9a130";
        libraryHaskellDepends = [ base ];
        homepage = "https://github.com/Kinokkory/type-level-bst";
        description = "type-level binary search trees in haskell";
@@ -133886,7 +134324,7 @@ self: {
      mkDerivation {
        pname = "type-level-natural-number";
        version = "2.0";
-       sha256 = "17zgm5ys1z61kxxczz3bzi9m3c48py6pvyx3cqk3xlh1w7n58ryk";
+       sha256 = "d36754ece101d23e2666a3fb7d8dbf88b05153fc6bfccf7a9fc1fca07da9ef9f";
        libraryHaskellDepends = [ base ];
        description = "Simple type level natural numbers";
        license = stdenv.lib.licenses.bsd3;
@@ -133897,7 +134335,7 @@ self: {
      mkDerivation {
        pname = "type-level-natural-number-induction";
        version = "1.0.0.1";
-       sha256 = "1mwnsz5rbqnwskzf4cyv05zxha86afqh68b5ppwvizrvwf4jav2r";
+       sha256 = "596c2589e33bffb8f9bd652103b1530629d87f01db33e2fed4dce295cbd796d7";
        libraryHaskellDepends = [
          base transformers type-level-natural-number
        ];
@@ -133911,7 +134349,7 @@ self: {
      mkDerivation {
        pname = "type-level-natural-number-operations";
        version = "1.0";
-       sha256 = "0vql5q5zhbhmwv0wqqb0xi4ayqdsz149rymhs730c583pq0h9r3w";
+       sha256 = "7ce40401be031506c6d1b0fa9c48f8ba61af48ec6061ccc1e6152ef80b2e146f";
        libraryHaskellDepends = [ base type-level-natural-number ];
        jailbreak = true;
        description = "Basic operations on type-level natural numbers";
@@ -133923,7 +134361,7 @@ self: {
      mkDerivation {
        pname = "type-level-numbers";
        version = "0.1.1.1";
-       sha256 = "12iiyaqi60fpds7fv1qvphy84rwyj71maq54mfwpcr0bdrgyymjv";
+       sha256 = "5b56ef5f6e0b6476b9aba46055c3919e67823cbc1b87ed8e6ed70113b1f2318a";
        libraryHaskellDepends = [ base template-haskell ];
        testHaskellDepends = [ base template-haskell ];
        description = "Type level numbers implemented using type families";
@@ -133935,7 +134373,7 @@ self: {
      mkDerivation {
        pname = "type-level-sets";
        version = "0.5";
-       sha256 = "1mrrwyvpjywnv2vd1nzzk0vnzsnjvbxiyxp03n9djsgwnfslzxbj";
+       sha256 = "72f54fb5b3fc69d9921de0761ffbdad2ea6f3798ffdbd0b6d8967b79b7e739d7";
        libraryHaskellDepends = [ base ghc-prim ];
        description = "Type-level sets (with value-level counterparts and various operations)";
        license = stdenv.lib.licenses.bsd3;
@@ -133947,7 +134385,7 @@ self: {
      mkDerivation {
        pname = "type-level-tf";
        version = "0.2.1";
-       sha256 = "07q69219yvf7rpfwilp70hvx2fzsxklvld7j3gayj17l9wp23g2m";
+       sha256 = "55bc212e4ff404e9d51bf234bae9ecfa3bd13704e7d2c8ddcdc76d9f8248061f";
        libraryHaskellDepends = [ base syb template-haskell ];
        homepage = "https://github.com/coreyoconnor/type-level-tf";
        description = "Type-level programming library (type families)";
@@ -133959,7 +134397,7 @@ self: {
      mkDerivation {
        pname = "type-list";
        version = "0.2.0.0";
-       sha256 = "19akcmjn1jgcxfsyw49pfydil47vh5zp99rb8qsyhmlv7x9czc03";
+       sha256 = "03b0cf523f9b56e835462ba7747f81fb101a9b773711eeb5ebecc960656553a5";
        libraryHaskellDepends = [ base singletons ];
        description = "Operations on type-level lists and tuples";
        license = stdenv.lib.licenses.bsd3;
@@ -133973,7 +134411,7 @@ self: {
      mkDerivation {
        pname = "type-natural";
        version = "0.2.3.2";
-       sha256 = "0qydsrksg9rasv90d4ivjgf1sdwfzjg0xf1wimfkhva545mray7h";
+       sha256 = "f078956b21456d385d8d3cb80e9efc8e371ddc933b9206d2d62aa7a767d6cd63";
        libraryHaskellDepends = [
          base constraints equational-reasoning monomorphic singletons
          template-haskell
@@ -133989,7 +134427,7 @@ self: {
      mkDerivation {
        pname = "type-ord";
        version = "0.3";
-       sha256 = "16nfnxh0klxx1f2mj1hc5blcm259b664w3l4frx4bksdavhnkmg5";
+       sha256 = "e5d569e1564dcf457a76840e4e8c59a988cae82a0c0659850bbdd30960b7ce9a";
        libraryHaskellDepends = [
          base template-haskell type-digits type-spine
        ];
@@ -134005,7 +134443,7 @@ self: {
      mkDerivation {
        pname = "type-ord-spine-cereal";
        version = "0.2";
-       sha256 = "1gwchzi4l7a0jm11paxz959mv9a5pbga86fyyjyglypd1988rvrb";
+       sha256 = "2bef8c500aed7afabcf4de19a4deba45a55d5349bfab1b4295401d4ae2878cbf";
        libraryHaskellDepends = [
          base template-haskell type-cereal type-ord type-spine
        ];
@@ -134019,7 +134457,7 @@ self: {
      mkDerivation {
        pname = "type-prelude";
        version = "0.1";
-       sha256 = "1ygg511j0av1g94mclrsf3p0qb2kc89jcz9nfr5fm073a2jlzlih";
+       sha256 = "30d24fa550e380ea4a76367d261362532c0cee703a5356497a612b204328eff9";
        libraryHaskellDepends = [ base ghc-prim ];
        homepage = "http://code.atnnn.com/projects/type-prelude";
        description = "Partial port of prelude to the type level. Requires GHC 7.6.1.";
@@ -134034,7 +134472,7 @@ self: {
      mkDerivation {
        pname = "type-settheory";
        version = "0.1.3.1";
-       sha256 = "1b4p9f03diq2mlp2mb39qrm095731i35q8k783bkq2knzlq01dsi";
+       sha256 = "51b70030fd760a3cd74067225c460ce394046ac669ac2a2ead02c736804b97ac";
        libraryHaskellDepends = [
          base containers syb template-haskell transformers type-equality
        ];
@@ -134048,7 +134486,7 @@ self: {
      mkDerivation {
        pname = "type-spine";
        version = "0.2.20120924";
-       sha256 = "0vy9ixmz1xm3dd0376s0h66q7qi64jqc5kqsqjpcg7akxidl03hi";
+       sha256 = "110e405bec539dc7aec41acfc2b02426e2838d81409b33406ba3f6f06b8fc96f";
        libraryHaskellDepends = [ base template-haskell ];
        description = "A spine-view on types";
        license = stdenv.lib.licenses.bsd3;
@@ -134065,7 +134503,7 @@ self: {
      mkDerivation {
        pname = "type-structure";
        version = "0.1.1";
-       sha256 = "0y2360llc41772ybjj3dcsk1r81js3yqsxww1w0j62gsdp6g9wfv";
+       sha256 = "dbf1f4cc6dfa0923010f9c778dfdd032a01ca6666d48b9bc3827104629304378";
        libraryHaskellDepends = [
          array base bytestring containers hashable loch-th mtl placeholders
          template-haskell text th-instance-reification time transformers
@@ -134093,7 +134531,7 @@ self: {
      mkDerivation {
        pname = "type-sub-th";
        version = "0.1.0.6";
-       sha256 = "11aycmbvqlrsd4kzm9m5smg7ghqz8kn3i62b19acnlpmrlr5v497";
+       sha256 = "27915d32cdf552cb540a4b9838ec441fc3775ed5a5a6fa27693a53bc57655e85";
        libraryHaskellDepends = [
          base DebugTraceHelpers HUnit QuickCheck template-haskell
          test-framework test-framework-hunit test-framework-quickcheck2
@@ -134117,7 +134555,7 @@ self: {
      mkDerivation {
        pname = "type-unary";
        version = "0.2.19";
-       sha256 = "04hpqmppwv6cs8vnf3whvmp1x4sqhirlkxcr2fjzcr1ji1gfchvr";
+       sha256 = "7943e65e883264f6a51399f549738458931e6edd900f6737d2cc6c7e6fc51712";
        libraryHaskellDepends = [
          applicative-numbers base constraints newtype ty vector-space
        ];
@@ -134131,7 +134569,7 @@ self: {
      mkDerivation {
        pname = "typeable-th";
        version = "0.1.5";
-       sha256 = "1ps9rkysx7zbcqkz51ahayg2jivlihiqdlb27iq7bf9aa7383k6v";
+       sha256 = "dbcc81c6512ab975703c62d186238c7447299e575085f22766eb9faefdcc49df";
        libraryHaskellDepends = [ base template-haskell transformers ];
        testHaskellDepends = [ base ];
        jailbreak = true;
@@ -134148,7 +134586,7 @@ self: {
      mkDerivation {
        pname = "typedquery";
        version = "0.1.0.2";
-       sha256 = "0l0fxhh1mq0801gb73pv531943i0iy5lm58hwyf5g6x6l50lj660";
+       sha256 = "c0184941a1a69b579ce710954a8b8f200e92c228fb8eb35e0008e01a20ec0e50";
        libraryHaskellDepends = [
          aeson base bytestring haskell-src-meta parsec template-haskell text
          transformers
@@ -134164,7 +134602,7 @@ self: {
      mkDerivation {
        pname = "typehash";
        version = "1.4.0.4";
-       sha256 = "11s10arrbri1f71jfpynhmwh53cgkrfxsrqch1f02j0aii7n0lpv";
+       sha256 = "fb52604f8c0a48015c800c67dd5d9e8f8d027985d65f27c37121e695b3024187";
        libraryHaskellDepends = [ base binary bytestring mtl pureMD5 syb ];
        jailbreak = true;
        description = "Create a unique hash value for a type";
@@ -134179,7 +134617,7 @@ self: {
      mkDerivation {
        pname = "typelevel-tensor";
        version = "0.2.1";
-       sha256 = "174f6xh3znf45w94xkhqwnxnzw6crpb13zff57svnj2dqvpf00gd";
+       sha256 = "ed01e0eec64d48bbf529cefd11d6cdccf06fbbe518ce4e122fc4d93f60378e9c";
        libraryHaskellDepends = [ base numeric-prelude QuickCheck ];
        testHaskellDepends = [
          array base HUnit numeric-prelude QuickCheck test-framework
@@ -134196,7 +134634,7 @@ self: {
      mkDerivation {
        pname = "typeof";
        version = "0.1.2";
-       sha256 = "1mnzkj5dp4rc4anaqxc6ia88wgrjhxwacxpqw8vp6pjqxbhhq92n";
+       sha256 = "56240ce1ea585e7337e2f876a67887323f8e908a8675acac222c93db8a9cdfd6";
        isLibrary = false;
        isExecutable = true;
        executableHaskellDepends = [ base process ];
@@ -134211,7 +134649,7 @@ self: {
      mkDerivation {
        pname = "typeparams";
        version = "0.0.6";
-       sha256 = "1blhqm8ba37mqp2ziipm0igyccyrqlwcink5xbz0m56ca7lid0vb";
+       sha256 = "6b8316e951cc940afeea65dac838c5d933e65f04f5c6f8c5c5f50cb550c590ae";
        libraryHaskellDepends = [
          base constraints deepseq ghc-prim primitive reflection tagged
          template-haskell vector
@@ -134227,7 +134665,7 @@ self: {
      mkDerivation {
        pname = "types-compat";
        version = "0.1.1";
-       sha256 = "1fl3ddsz9m0s0mnd7wq6lqkkmpq0dz83aisqgs1cpg91xlllghby";
+       sha256 = "7ec14729ed21bdcb827e584735d06f00df3a27a606f3d36c051ad4f4756b83ba";
        revision = "2";
        editedCabalFile = "8fbb17ec66d4bf5f2fffdb2327647b44292253822c9623a06b489ff547a71041";
        libraryHaskellDepends = [ base ];
@@ -134241,7 +134679,7 @@ self: {
      mkDerivation {
        pname = "typesafe-endian";
        version = "0.1.0.1";
-       sha256 = "1kg4pvrnf7vwvrcb998l9w08dpdy9hg7x2d9h5s3lqpnvvxfgcfj";
+       sha256 = "d2b1e7fadef6623a7481a9897e1e4cbedd86004f14a5b458de7c1f67f3bee4cd";
        libraryHaskellDepends = [ base ];
        homepage = "https://github.com/Ericson2314/typesafe-endian";
        description = "Enforce endianness with types";
@@ -134256,7 +134694,7 @@ self: {
      mkDerivation {
        pname = "typescript-docs";
        version = "0.0.3";
-       sha256 = "12axp6y652zlv9c9m0n5m4allpy23x0bk274gy78csrqp26akq3k";
+       sha256 = "73e0a98cb8386b868e7fe488b9401fc25f4a15a9c5829a58daf48b62bcb95d89";
        isLibrary = false;
        isExecutable = true;
        executableHaskellDepends = [
@@ -134274,7 +134712,7 @@ self: {
      mkDerivation {
        pname = "typical";
        version = "0.0.1";
-       sha256 = "0dw6mwppbhcblnr03qgavhx27l9dl6gd981afgg4spi8avfzgh4q";
+       sha256 = "98c0f7dd56285e4dde732aa0d49ea12dd1233adceae101b2a58bc1752faf8637";
        libraryHaskellDepends = [ base ];
        description = "Type level numbers, vectors, list. This lib needs to be extended.";
        license = "GPL";
@@ -134287,7 +134725,7 @@ self: {
      mkDerivation {
        pname = "typography-geometry";
        version = "1.0.0";
-       sha256 = "1vvqch3pdwymjbmir7b208qyzdzljsw1gf8icmzw5pi3vn6wkihf";
+       sha256 = "0ec6c98ddd23dec27f6511b917b896f4b7ef3102629d1ceb92d5f376076478ef";
        libraryHaskellDepends = [
          base containers parallel polynomials-bernstein vector
        ];
@@ -134305,7 +134743,7 @@ self: {
      mkDerivation {
        pname = "tz";
        version = "0.0.0.10";
-       sha256 = "15j0ai0i4savvvhd8b7f9mrm1kwdmvjrphyjclmlj1k65c6ap5qm";
+       sha256 = "1597ab0c2b6606492b65d2c39be5ae8dcf50734dee2cd4e0de5b691241544096";
        libraryHaskellDepends = [
          base binary bytestring containers deepseq time tzdata vector
        ];
@@ -134327,7 +134765,7 @@ self: {
      mkDerivation {
        pname = "tzdata";
        version = "0.1.20150129.1";
-       sha256 = "167ik26nsq2v6xqfk0rljp4p4g3r35rkvsza7cvi8qdak96dc4ay";
+       sha256 = "5e11d64c9aaa6114373beaeb3d7319793c72c9953483e970375b606d8d98f198";
        libraryHaskellDepends = [ base bytestring containers vector ];
        testHaskellDepends = [
          base bytestring directory filemanip filepath HUnit MissingH
@@ -134345,7 +134783,7 @@ self: {
      mkDerivation {
        pname = "uAgda";
        version = "1.2.0.4";
-       sha256 = "01a1h6pflvid5zcd8wy3px7cz4pxwy5pw354v9rp8k7sx4q82am8";
+       sha256 = "a82a8130e9fa4c7473daa40c7e8be7fd92cf4ebfc373d4d82f2d6eeaae814105";
        isLibrary = false;
        isExecutable = true;
        executableHaskellDepends = [
@@ -134367,7 +134805,7 @@ self: {
      mkDerivation {
        pname = "ua-parser";
        version = "0.5";
-       sha256 = "0fljfvs9gzqyn01sw57s738jazki839grff43n09bqf7nk1janbf";
+       sha256 = "6e5925c3b4c7e195801dc4b9fcd240717e25d138fa14ae03b01eff97f476923a";
        libraryHaskellDepends = [
          aeson base bytestring data-default file-embed pcre-light syb text
          yaml
@@ -134390,7 +134828,7 @@ self: {
      mkDerivation {
        pname = "uacpid";
        version = "1.2";
-       sha256 = "1ml02xap95vxvzwqlqp68hfk7yjncf3xc1h13gga0nlhby9rjv14";
+       sha256 = "246c99935f905aa0de1b0106d6876356fa331d44e6628af9df7d9774551780d6";
        isLibrary = false;
        isExecutable = true;
        executableHaskellDepends = [
@@ -134407,7 +134845,7 @@ self: {
      mkDerivation {
        pname = "uberlast";
        version = "0.0";
-       sha256 = "12p948706scjiazlwv0x1afl3v8fhv4a3l8yqn1x4y9xnr4pfmc9";
+       sha256 = "89557749b63d79d283c51ed1a1c8860eed419d0a1d6c4ebf8a9269030e22e98a";
        libraryHaskellDepends = [ base lens tagged template-haskell ];
        homepage = "https:/github.com/fumieval/uberlast";
        description = "Generate overloaded lenses from plain data declaration";
@@ -134420,7 +134858,7 @@ self: {
      mkDerivation {
        pname = "uconv";
        version = "0.0.3";
-       sha256 = "0v71qw494klyh3ar8qdp7wx7kn7629iy83xham9b7jpmvk2p76bv";
+       sha256 = "7b9973c5dcf5cab35255b00fe46312e6d8793a3fb76194d5809e4e9208c7e16c";
        libraryHaskellDepends = [ base bytestring ];
        librarySystemDepends = [ icu ];
        description = "String encoding conversion with ICU";
@@ -134435,7 +134873,7 @@ self: {
      mkDerivation {
        pname = "udbus";
        version = "0.2.1";
-       sha256 = "0a7kksh99nll91q41z4xgrcwc8pnfm0p71bxw6yymcd7yb0v09fk";
+       sha256 = "d325b0c1f2a7b1eabde17d85734175f622c6597e9dfc40704894da94a09ef328";
        isLibrary = true;
        isExecutable = true;
        libraryHaskellDepends = [
@@ -134453,7 +134891,7 @@ self: {
      mkDerivation {
        pname = "udbus-model";
        version = "0.2.1";
-       sha256 = "0xiz3z0x7p9agj14j9lm8njfqiqpyif0m2fn7lppi3w482ssfzji";
+       sha256 = "517ea7b540848f782f3dd6890a5cf41747eca445952649827c2addd3c11f3f76";
        isLibrary = true;
        isExecutable = true;
        libraryHaskellDepends = [ base bytestring udbus xml ];
@@ -134468,7 +134906,7 @@ self: {
      mkDerivation {
        pname = "udcode";
        version = "0.2.0.0";
-       sha256 = "1namnm91divk1x8ki7wfbd79f4nrym58r4ki9yamj2giv4nxda36";
+       sha256 = "66a8d62dd9f10959954f71928c4af5d912974e5b8e9f38510f73c71652b555d9";
        libraryHaskellDepends = [ base containers mtl ];
        description = "Does a set of code words form a uniquely decodable code?";
        license = stdenv.lib.licenses.bsd3;
@@ -134481,7 +134919,7 @@ self: {
      mkDerivation {
        pname = "udev";
        version = "0.1.0.0";
-       sha256 = "1a5i57f50scxbv5snn4xd953bx98qq3cgzhxjnqvxyazqz3h1fx2";
+       sha256 = "a2bb00c7c75ff9beb1951dfec706c628f5354a6a9d58abcb5e9d6950dc29b1a8";
        isLibrary = true;
        isExecutable = true;
        libraryHaskellDepends = [ base bytestring posix-paths unix ];
@@ -134498,7 +134936,7 @@ self: {
      mkDerivation {
        pname = "uglymemo";
        version = "0.1.0.1";
-       sha256 = "0ixqg5d0ly1r18jbgaa89i6kjzgi6c5hanw1b1y8c5fbq14yz2gy";
+       sha256 = "fe89ef49c0cb15867c58815b050b33f17d394d4c48a9b7240a39780a5a79b847";
        libraryHaskellDepends = [ base containers ];
        description = "A simple (but internally ugly) memoization function";
        license = stdenv.lib.licenses.publicDomain;
@@ -134512,7 +134950,7 @@ self: {
      mkDerivation {
        pname = "uhc-light";
        version = "1.1.9.0";
-       sha256 = "0dqb0054nbl5qfxrg7g4yvmiawp9ladlws26cdf32jxrm31wgmkj";
+       sha256 = "72d6c7c3a8b94b315c6346684e9ba2e97215ebf6e49d97bbc3852e4b0a000b37";
        revision = "1";
        editedCabalFile = "8847b4a41a2f6c9be09cf7b4835f53219522da9ef0ca26b918159fec747bd938";
        isLibrary = true;
@@ -134540,7 +134978,7 @@ self: {
      mkDerivation {
        pname = "uhc-util";
        version = "0.1.6.0";
-       sha256 = "1ndnmk8rfa8hwp72hgh6xx043lf59a8k50cqjm8bibfpd7fl31hj";
+       sha256 = "128641dd69d7adb85095988132914ac5d14140ef063e28cee5102997d1acb6d9";
        libraryHaskellDepends = [
          array base binary bytestring containers directory fclabels fgl
          hashable ListLike mtl process syb time time-compat uulib
@@ -134555,7 +134993,7 @@ self: {
      mkDerivation {
        pname = "uhexdump";
        version = "0.3";
-       sha256 = "064cm531yci41jf14k177w7j4zy8dfjwrpjcrwf7kpz2rhx1djyi";
+       sha256 = "d1cb163acce2df791ccf4cdecca56bc87f220f3f274c129c0c24321f46a98c18";
        isLibrary = false;
        isExecutable = true;
        executableHaskellDepends = [ base bytestring split ];
@@ -134571,7 +135009,7 @@ self: {
      mkDerivation {
        pname = "uhttpc";
        version = "0.1.1.0";
-       sha256 = "1knf8r8zq8nnidmbj1blazjxkpngczs55jjx0phnnxlc026ppynb";
+       sha256 = "cbfa7b8d008c766be1055dca52f467cfded9e5577405b96a8bd622fc5146cece";
        isLibrary = true;
        isExecutable = true;
        libraryHaskellDepends = [
@@ -134591,7 +135029,7 @@ self: {
      mkDerivation {
        pname = "ui-command";
        version = "0.5.4";
-       sha256 = "1qq902p5q6z1m0556bdc6brads7m2qrhrwnzd8k8c4jynzc829w7";
+       sha256 = "872781d8b75e1286266adff20c3316f5e8a6f232ac2d530aa8e11b5cae0009e3";
        isLibrary = true;
        isExecutable = true;
        libraryHaskellDepends = [ base data-default mtl old-locale time ];
@@ -134607,7 +135045,7 @@ self: {
      mkDerivation {
        pname = "uid";
        version = "0.1.0.1";
-       sha256 = "11v67dbanw9gmy9rbfln3ma87a9hkwvc5bwzdx840ngij5gh559b";
+       sha256 = "2b95025f91f15940506f9fafc2369f30a983541d96ba9593af2f71ab563b6687";
        libraryHaskellDepends = [
          aeson base bytestring cereal dataenc text uuid
        ];
@@ -134623,7 +135061,7 @@ self: {
      mkDerivation {
        pname = "una";
        version = "2.1.0";
-       sha256 = "0gpycwd0dgnw7cdicpn19wv1xb4jq3j9dfzry2ilv85h02zkwfvh";
+       sha256 = "703b3ebf00b0a04da3f0f9bb96e4c092ac1e364fc15e161b3bdcbe061a67fe3e";
        isLibrary = false;
        isExecutable = true;
        executableHaskellDepends = [
@@ -134641,7 +135079,7 @@ self: {
      mkDerivation {
        pname = "unagi-chan";
        version = "0.4.0.0";
-       sha256 = "04m1ns6jc1yb1i9pmqmi8k21mwgkrq4q9fbcj4af1a9khxrjxcny";
+       sha256 = "deb22e738733a9e014916cb98409cef3f11ac444b1e27a530ccb07268db6a112";
        libraryHaskellDepends = [ atomic-primops base ghc-prim primitive ];
        testHaskellDepends = [
          atomic-primops base containers ghc-prim primitive
@@ -134655,7 +135093,7 @@ self: {
      mkDerivation {
        pname = "unagi-streams";
        version = "0.1.3";
-       sha256 = "0m8x1sw925xwj2yd2ji0nk54gw1gqqz1zy0bk9z3c3sgbcy364m6";
+       sha256 = "a612333c5b4f0f367e9a0bf81f3ec62ff047cab4204ad1bc90bc1791b80e1d55";
        libraryHaskellDepends = [ base io-streams unagi-chan ];
        description = "Unagi Chan IO-Streams";
        license = stdenv.lib.licenses.bsd3;
@@ -134666,7 +135104,7 @@ self: {
      mkDerivation {
        pname = "unamb";
        version = "0.2.5";
-       sha256 = "12cbqlc7qf2sf2m4zmisx06bcc104bwivnzq2df0jqdf09bg0n9k";
+       sha256 = "3359f05602ae61095c13f8db1df9222030b60ce83ad64faa705a387c18c58b89";
        isLibrary = true;
        isExecutable = true;
        libraryHaskellDepends = [ base ];
@@ -134680,7 +135118,7 @@ self: {
      mkDerivation {
        pname = "unamb-custom";
        version = "0.13";
-       sha256 = "0r694wi9xg8brgcwl2kyv5amp6v539l121s9bpmd5lhjdnrvqjwk";
+       sha256 = "934bbcb36d12d2d2ea5d490711681a659b5b55d97e0acad9cb0bbd9e2227c964";
        libraryHaskellDepends = [ base containers mtl ];
        homepage = "http://github.com/luqui/unamb-custom";
        description = "Functional concurrency with unamb using a custom scheduler";
@@ -134695,7 +135133,7 @@ self: {
      mkDerivation {
        pname = "unbound";
        version = "0.4.3.1";
-       sha256 = "1xkp47y7yg8dl95gf4w3iwddc3yivrhcxj184cfhrx6a9rbsflpz";
+       sha256 = "ff52a7574ecaf40c1d2328c8ce60ded10fd61a8f8313f74aa20d3d7ffc2177f6";
        libraryHaskellDepends = [
          base binary containers mtl RepLib transformers
        ];
@@ -134713,7 +135151,7 @@ self: {
      mkDerivation {
        pname = "unbound-generics";
        version = "0.2";
-       sha256 = "0wmr7ylczkaqyf1yrcp9d9gmw8hv7v2yip9v96zlqx02m9j57s99";
+       sha256 = "29e95364aa02744cbf493bdde8c53e1b225e5f6ae9b2ec83f358cdcfa83fb972";
        libraryHaskellDepends = [
          base containers contravariant deepseq mtl profunctors
          template-haskell transformers transformers-compat
@@ -134731,7 +135169,7 @@ self: {
      mkDerivation {
        pname = "unbounded-delays";
        version = "0.1.0.9";
-       sha256 = "1f4h87503m3smhip432q027wj3zih18pmz2rnafh60589ifcl420";
+       sha256 = "4010ca5c4ca800039db259fc7a5180f10fc98f00580c7223ac7ad401ca4190b8";
        libraryHaskellDepends = [ base ];
        homepage = "https://github.com/basvandijk/unbounded-delays";
        description = "Unbounded thread delays and timeouts";
@@ -134743,7 +135181,7 @@ self: {
      mkDerivation {
        pname = "unbounded-delays-units";
        version = "0.4";
-       sha256 = "02j4i2dms15vb87ar3m99hvpxrjdakljyql708zs716k1jdm7614";
+       sha256 = "2498539b0cd384a33f0287622fe9544de67e374ca98eac0e5abb045d9b88440a";
        libraryHaskellDepends = [ base unbounded-delays units units-defs ];
        jailbreak = true;
        homepage = "https://github.com/jcristovao/unbouded-delays-units";
@@ -134757,7 +135195,7 @@ self: {
      mkDerivation {
        pname = "unboxed-containers";
        version = "0.0.2.4";
-       sha256 = "0yahavqjjnlf4ps8kd41s9s64nbhx2hf7qzk2xxkmq0i3b91d123";
+       sha256 = "438416d21a11e03a7b17f3e3e3a0e870596274d281b489f4258e5a29f1565079";
        libraryHaskellDepends = [ base containers ];
        homepage = "http://github.com/ekmett/unboxed-containers";
        description = "Self-optimizing unboxed sets using view patterns and data families";
@@ -134770,7 +135208,7 @@ self: {
      mkDerivation {
        pname = "unexceptionalio";
        version = "0.2.0";
-       sha256 = "1p1han6027n6d9cx0cqrfrpwqlhkainj7xi839swqj1k6d4n022n";
+       sha256 = "56086049333348cc751a28f6236d541352cc6f761933d0596ac61e018c5530dc";
        libraryHaskellDepends = [ base ];
        homepage = "https://github.com/singpolyma/unexceptionalio";
        description = "IO without any non-error, synchronous exceptions";
@@ -134783,7 +135221,7 @@ self: {
      mkDerivation {
        pname = "unfoldable";
        version = "0.8.2";
-       sha256 = "0r6jffm2i2la70xzqsribfbsa84ha5g4zfqphp9gqkvr1x2jmr2i";
+       sha256 = "51e42a450f794ffcd28517bb4f5e519020a5975b316bfc3b388a8a28aa73d264";
        libraryHaskellDepends = [
          base ghc-prim QuickCheck random transformers
        ];
@@ -134797,7 +135235,7 @@ self: {
      mkDerivation {
        pname = "ungadtagger";
        version = "1.0.0";
-       sha256 = "1hn30p9vpsvkph54grzwdrca5vh9grpa7d0w1zlvim1mnvqxmn4b";
+       sha256 = "8bd8daf1b635d4b8e90f1cb4a36e7e09eea2586efce7470abc73ebbbd305c3c2";
        libraryHaskellDepends = [ base ];
        homepage = "http://github.com/andriyp/ungadtagger";
        description = "Abstract GADTs from typelevel tags";
@@ -134809,7 +135247,7 @@ self: {
      mkDerivation {
        pname = "uni-events";
        version = "2.2.2.0";
-       sha256 = "1damlhi56xfp4xvdk2ijxjx7vxywhhbi4hiprdx09b5ipblrfpqz";
+       sha256 = "1f5f97e9bab1ac047acb3742121784dcf77dbaec328ad97627d7755322a455b5";
        libraryHaskellDepends = [ base containers uni-util ];
        homepage = "http://www.informatik.uni-bremen.de/uniform/wb/";
        description = "Event handling for the uniform workbench";
@@ -134823,7 +135261,7 @@ self: {
      mkDerivation {
        pname = "uni-graphs";
        version = "2.2.1.0";
-       sha256 = "1vwm0gmgj8c7qdildplr3jng5gj9q6b669vgmnxw4v514y529bz5";
+       sha256 = "e5af248a27a16cc2bbad6f276396c149bef2ac1c99de4663c38721f9ea0395ef";
        libraryHaskellDepends = [
          base containers mtl uni-events uni-htk uni-reactor uni-util
        ];
@@ -134839,7 +135277,7 @@ self: {
      mkDerivation {
        pname = "uni-htk";
        version = "2.2.1.2";
-       sha256 = "1zdbg2jz6dgw4jvicl2vgnnnz2mmq8r9cabfgzw7zyc6ycp5hmyk";
+       sha256 = "d357582ef386f97ff87f6e299632c2b58a6fad7d5b5016b724fc35f3a578abfd";
        libraryHaskellDepends = [
          base containers directory uni-events uni-posixutil uni-reactor
          uni-util
@@ -134856,7 +135294,7 @@ self: {
      mkDerivation {
        pname = "uni-posixutil";
        version = "2.2.1.1";
-       sha256 = "0wh3ni6l1x7rxn5yppva1xs0yb6z5hxfmzxxrnh6hbcq1pa62m5d";
+       sha256 = "ad5461d40d982d68a0cdbdffea3a2cdf2c0f740f6adfeb8bedf9f4404db40372";
        libraryHaskellDepends = [
          base directory process uni-events uni-util unix
        ];
@@ -134871,7 +135309,7 @@ self: {
      mkDerivation {
        pname = "uni-reactor";
        version = "2.2.1.0";
-       sha256 = "147nizw920xbbj5b8kqrgri1r9wpx3qddspnryxhdxq10q1xlyh2";
+       sha256 = "027ada030601f706bbcff6ead6f0e897a71c627e194fb48a5cab0391f88ff690";
        libraryHaskellDepends = [
          base containers directory uni-events uni-util
        ];
@@ -134887,7 +135325,7 @@ self: {
      mkDerivation {
        pname = "uni-uDrawGraph";
        version = "2.2.1.3";
-       sha256 = "1gblb969s9al67srxf7rd9dajy6hji91aw5zaxxhaj0vgqsdb90j";
+       sha256 = "12a4d5347e1b48057b57bf70155294d078a95a6af9b89ef53154259d4c5a74bd";
        libraryHaskellDepends = [
          base containers uni-events uni-graphs uni-posixutil uni-reactor
          uni-util
@@ -134904,7 +135342,7 @@ self: {
      mkDerivation {
        pname = "uni-util";
        version = "2.3.0.1";
-       sha256 = "0simxjsd0qi8yxnpiq88zy3bsrrw5rxfpfknr8yaf4xhc7vv39nh";
+       sha256 = "d0a6b1f761b013a73cca76baeb7a2e3c67bd86ff08e1786df72862d0b4ec356a";
        libraryHaskellDepends = [
          array base bytestring containers directory ghc-prim mtl network
          old-time parsec
@@ -134919,7 +135357,7 @@ self: {
      mkDerivation {
        pname = "unicode";
        version = "0.0";
-       sha256 = "0fy89j864dy5dzfj15aavm8bqpv2f51zf42dyjvs50qah3shh5yl";
+       sha256 = "d41708f5800a83a2b7f44d10f74371625fbc50dd4a9520dd6fc53762904cc83b";
        isLibrary = true;
        isExecutable = true;
        libraryHaskellDepends = [ base containers ];
@@ -134934,7 +135372,7 @@ self: {
      mkDerivation {
        pname = "unicode-names";
        version = "3.2.0.0";
-       sha256 = "15088dbmhvw118p3w08wxpsx41gzi0wqinqyg143225pp07aa5gc";
+       sha256 = "ec15a50eb8b7083148781edb883988ff05d2f5ed1c013e2e0a816f5857430894";
        libraryHaskellDepends = [
          array base containers unicode-properties
        ];
@@ -134947,7 +135385,7 @@ self: {
      mkDerivation {
        pname = "unicode-normalization";
        version = "0.1";
-       sha256 = "1smfc7a62xi6y4sc0vai2l0nljxl9dr9l5zkqi17n14cq36ppfwb";
+       sha256 = "8bbb7bcdc08c047b42c4f3179a724bb44b6a0115516dc034f1267661d461aeea";
        libraryHaskellDepends = [ base bytestring compact-string ];
        librarySystemDepends = [ icu ];
        homepage = "http://sloompie.reinier.de/unicode-normalization/";
@@ -134961,7 +135399,7 @@ self: {
      mkDerivation {
        pname = "unicode-prelude";
        version = "0.1.1";
-       sha256 = "05zakihlk06wckzgm43f3g26fjdn4gb3d1ypw4vcwqmipq2dbfsw";
+       sha256 = "5cbbd504beb162ce36e1d78736d623b64967c41b6e90fafe64dc8049619cea17";
        libraryHaskellDepends = [ base ];
        description = "Unicode notation for some definitions in Prelude";
        license = stdenv.lib.licenses.bsd3;
@@ -134972,7 +135410,7 @@ self: {
      mkDerivation {
        pname = "unicode-properties";
        version = "3.2.0.0";
-       sha256 = "06zrr2z9irbsxwf7fbnhp2sg36ykb2amfys2y78nzn0mw63xb3q1";
+       sha256 = "018fd587e115d86fd1f1427b579558d39bf1b4b8d02e771cef7ae598bec8f91b";
        libraryHaskellDepends = [ array base containers ];
        description = "Unicode 3.2.0 character properties";
        license = stdenv.lib.licenses.bsd3;
@@ -134983,7 +135421,7 @@ self: {
      mkDerivation {
        pname = "unicode-symbols";
        version = "0.1.1.2";
-       sha256 = "0y1awqrf1x2in158linszma69zyz3zp14h3rmdx3vmbmif9fvbyv";
+       sha256 = "dbafed928b75d53d7aab794012ee1fdfff6454fdda468a4ab051f4e032e62a78";
        libraryHaskellDepends = [ base containers ];
        jailbreak = true;
        description = "Unicode alternatives for common functions and operators";
@@ -134995,7 +135433,7 @@ self: {
      mkDerivation {
        pname = "unicoder";
        version = "0.4.1";
-       sha256 = "17a2rxq5b4a66ia4jm1g0lmkvsanfc477567wygq9kz4w9q4xwc3";
+       sha256 = "83f14e70e2e4cf849fe7c79473087356e93d2b052f5449543446915570cf429d";
        isLibrary = true;
        isExecutable = true;
        libraryHaskellDepends = [ attoparsec base text ];
@@ -135013,7 +135451,7 @@ self: {
      mkDerivation {
        pname = "unification-fd";
        version = "0.10.0.1";
-       sha256 = "15hrnmgr0pqq43fwgxc168r08xjgfhr2nchmz5blq46vwrh6gx2v";
+       sha256 = "5bf46760e6db104c57f915322b32744f7604323281f5c7dd20185f905fb51996";
        libraryHaskellDepends = [ base containers logict mtl ];
        homepage = "http://code.haskell.org/~wren/";
        description = "Simple generic unification algorithms";
@@ -135028,7 +135466,7 @@ self: {
      mkDerivation {
        pname = "uniform-io";
        version = "0.1.1.0";
-       sha256 = "0i9sdf2nnaf099r79mdrqa1hbbqyb874fk8dsqqzb1582m6czikk";
+       sha256 = "73c6cf4c15a884f531d60d4d470e5a1eaf0583c2b9d574724ac0296b856b3a45";
        revision = "1";
        editedCabalFile = "4f0651eff7cbdde40b49b5fcf90e8adf5c403a7c150ac318f0f5280b454b19f9";
        libraryHaskellDepends = [
@@ -135048,7 +135486,7 @@ self: {
      mkDerivation {
        pname = "uniform-pair";
        version = "0.1.5";
-       sha256 = "0zkkhxmhx7xpi0fjxks435z5p52f2jvw8fvp0z2qi81a18v8fh81";
+       sha256 = "014187360a2aa088c507773bc4b7144e945b7e1944cf2e1d88b79f0e6b87737e";
        libraryHaskellDepends = [ base ShowF ];
        homepage = "https://github.com/conal/uniform-pair/";
        description = "Uniform pairs with class instances";
@@ -135060,7 +135498,7 @@ self: {
      mkDerivation {
        pname = "union-find";
        version = "0.2";
-       sha256 = "1v7hj42j9w6jlzi56jg8rh4p58gfs1c5dx30wd1qqvn0p0mnihp6";
+       sha256 = "e6c2682bb8c06e8c43e360f45658d0eea17209cce84953e2a7d2f0240591f0ec";
        libraryHaskellDepends = [ base containers transformers ];
        homepage = "http://github.com/nominolo/union-find";
        description = "Efficient union and equivalence testing of sets";
@@ -135072,7 +135510,7 @@ self: {
      mkDerivation {
        pname = "union-find-array";
        version = "0.1.0.2";
-       sha256 = "1pxb1v2k04i8ds2n8zqra74gacry6dj5p87sxgkf4fazx4s316dk";
+       sha256 = "b3993034e95f39e2e6ebfaa05b64333e33f5c851197f64856e281230c50eabdf";
        libraryHaskellDepends = [ array base mtl ];
        homepage = "https://github.com/haskell-rewriting/union-find-array";
        description = "union find data structure";
@@ -135084,7 +135522,7 @@ self: {
      mkDerivation {
        pname = "union-map";
        version = "0.1";
-       sha256 = "0q1qg0vg01ypjlb90xq8zl3zc53b3yn23vgpnzv92q7xmc46gb5l";
+       sha256 = "b4ac6708abfd6091f6b7f7ed21ac1f6b14f607fd0877901695d707f036783860";
        libraryHaskellDepends = [ base containers extensible ];
        homepage = "http://github.com/minpou/union-map";
        description = "Heterogeneous map by open unions";
@@ -135099,7 +135537,7 @@ self: {
      mkDerivation {
        pname = "uniplate";
        version = "1.6.12";
-       sha256 = "1dx8f9aw27fz8kw0ad1nm6355w5rdl7bjvb427v2bsgnng30pipw";
+       sha256 = "fcc60bc6b3f6e925f611646db90e6db9f05286a9363405f844df1dc15572a8b7";
        libraryHaskellDepends = [
          base containers hashable syb unordered-containers
        ];
@@ -135115,7 +135553,7 @@ self: {
      mkDerivation {
        pname = "unique-logic";
        version = "0.3";
-       sha256 = "0pjkqvam73d6xy528r9zf75km2yr997in902174raj6kw3kgdl41";
+       sha256 = "81d0f6e6e0d34895c90902241b4f4ad98b3acb713f65248aefa68d53d5c6535e";
        libraryHaskellDepends = [ base transformers utility-ht ];
        testHaskellDepends = [
          base non-empty QuickCheck transformers utility-ht
@@ -135133,7 +135571,7 @@ self: {
      mkDerivation {
        pname = "unique-logic-tf";
        version = "0.4.1.1";
-       sha256 = "0gc41whidll04fgzjydcxgxvq270ncvqcamsd3b3qd4hfn3v9qv8";
+       sha256 = "68e3b4877590343cd668ba2a8637b3e008bcfbebac79f99f2380d216210f843d";
        libraryHaskellDepends = [
          base containers explicit-exception transformers utility-ht
        ];
@@ -135152,7 +135590,7 @@ self: {
      mkDerivation {
        pname = "uniqueid";
        version = "0.1.1";
-       sha256 = "0s1jw29g5s9ll8hbfkyalhdjpsv54w1n63mz4jph36dbq68zb7g6";
+       sha256 = "e69df591c1ab9901af24bf0e63032765eb2b1ba4ca4fb720a234e9f292e03268";
        libraryHaskellDepends = [ base ];
        homepage = "http://github.com/sebfisch/uniqueid/wikis";
        description = "Splittable Unique Identifier Supply";
@@ -135168,7 +135606,7 @@ self: {
      mkDerivation {
        pname = "units";
        version = "2.3";
-       sha256 = "14h5566b68wr5qln3x4a862j0zmfdlishipbj9mhd2wmpri6bmzj";
+       sha256 = "f2d76562be958b066b92eb46a8236dae7e2085418af461292e9923b38c290592";
        libraryHaskellDepends = [
          base containers mtl multimap singletons syb template-haskell
          th-desugar units-parser vector-space
@@ -135190,7 +135628,7 @@ self: {
      mkDerivation {
        pname = "units-attoparsec";
        version = "1.0";
-       sha256 = "11saazsgx7gpbfhwwgvrp3zwirkvv8h8c61rrsczfq1qmsljxxiz";
+       sha256 = "3ff62ea9ae3860f799ce39188620da7be6c8ffb8793fcea15bf79dfef4574a87";
        libraryHaskellDepends = [
          attoparsec base template-haskell text units units-defs
        ];
@@ -135204,7 +135642,7 @@ self: {
      mkDerivation {
        pname = "units-defs";
        version = "2.0.0.1";
-       sha256 = "04k9wjyq23ml89nnjx2lwxiik54wc4rcbmpvvr7fh9wgsl74k6pv";
+       sha256 = "fb9a490ed58f27e84edefbd6c532619c941963e75474696d42b40e81bde46912";
        libraryHaskellDepends = [ base template-haskell units ];
        homepage = "http://github.com/goldfirere/units-defs";
        description = "Definitions for use with the units package";
@@ -135219,7 +135657,7 @@ self: {
      mkDerivation {
        pname = "units-parser";
        version = "0.1.0.0";
-       sha256 = "0ha1saapphk15xk10a36k5qmn01nqpz10f8gi35ra9zqlhv8amfq";
+       sha256 = "d8558536a4f82795cb880f3910fec536005b7199662810662f61c27b95d24141";
        libraryHaskellDepends = [ base containers mtl multimap parsec ];
        testHaskellDepends = [
          base containers mtl multimap parsec syb tasty tasty-hunit
@@ -135234,7 +135672,7 @@ self: {
      mkDerivation {
        pname = "unittyped";
        version = "0.1";
-       sha256 = "1ab27rwnp8ncfn5sm4llxjxx7fbp495sl1838g8z9hishr5dgddl";
+       sha256 = "b4b5d74a863ac2f4d1430305aa4b2277b9d3bbec9492aa8b75cca26b793e62a9";
        libraryHaskellDepends = [ base ];
        testHaskellDepends = [ base ];
        jailbreak = true;
@@ -135249,7 +135687,7 @@ self: {
      mkDerivation {
        pname = "universal-binary";
        version = "0.11";
-       sha256 = "1gnrq6s7pipjqfyispkxib3xfzii1ss6a9iwv07mvb5a93hc45cw";
+       sha256 = "9c15c2e048aaac5d0fd83c2665b40e317ed7c78a7d5e1dbdc3f2c67bb4c1d9be";
        libraryHaskellDepends = [ base binary bytestring ];
        description = "Parser for OS X Universal Binary format";
        license = stdenv.lib.licenses.bsd3;
@@ -135263,7 +135701,7 @@ self: {
      mkDerivation {
        pname = "universe";
        version = "1.0";
-       sha256 = "19zr9zcqc5sfp5qfn8slkk2732j1814m3j1jkbim739limwf900z";
+       sha256 = "1f80e4788d348d53e39a32c8514940418a71c49c5423eb70b94e1786d94ff9a7";
        libraryHaskellDepends = [
          universe-instances-base universe-instances-extended
          universe-instances-trans universe-reverse-instances
@@ -135278,7 +135716,7 @@ self: {
      mkDerivation {
        pname = "universe-base";
        version = "1.0";
-       sha256 = "1bhgmikh876bda37a79iapzp58ssgfx6n57gpblyd1fprxnwqxc4";
+       sha256 = "8475cc6dcfd785e6e9baef146bba7b5aa372ff55311d75866acb1c0467ac0fae";
        libraryHaskellDepends = [ base ];
        homepage = "https://github.com/dmwit/universe";
        description = "A class for finite and recursively enumerable types and some helper functions for enumerating them";
@@ -135290,7 +135728,7 @@ self: {
      mkDerivation {
        pname = "universe-instances-base";
        version = "1.0";
-       sha256 = "04njgl32lk5a0masjdjkm4l2wsyrr29g0fsp599864mp7gp504d2";
+       sha256 = "a21150ee3bb71283522a573bf092c8d96b2e28a95336a95505aa4c2a067dd212";
        libraryHaskellDepends = [ base containers universe-base ];
        homepage = "https://github.com/dmwit/universe";
        description = "Universe instances for types from the base package";
@@ -135304,7 +135742,7 @@ self: {
      mkDerivation {
        pname = "universe-instances-extended";
        version = "1.0";
-       sha256 = "0cla7n6id0v2pphmzsc8cbghvhyjjx9720gmxdqch8ysrfknkbgi";
+       sha256 = "f1ad69a7cbda23c870ebf501715297d2c30ddf6288e95fe1bd6283168d3d8a32";
        libraryHaskellDepends = [
          adjunctions base comonad universe-instances-base void
        ];
@@ -135321,7 +135759,7 @@ self: {
      mkDerivation {
        pname = "universe-instances-trans";
        version = "1.0.0.1";
-       sha256 = "03iix0bdhfi4qlgwr8sl3gsqck6lsbkqgx245w2z5yaaxgqpq10d";
+       sha256 = "0d047cf1eb4af9f2052f44f487e7d2d44c86f51b54a3cc1fc5243ad816e8310e";
        libraryHaskellDepends = [
          base mtl transformers universe-base universe-instances-base
        ];
@@ -135335,7 +135773,7 @@ self: {
      mkDerivation {
        pname = "universe-reverse-instances";
        version = "1.0";
-       sha256 = "0jcd7qyvzq8xxv9d3hfi0f1h48xdsy9r9xnxgxc7ggga4szirm79";
+       sha256 = "e9d41cbf26eabd77587fddf69493d7ad23028303d1c1d1d2ee1de1bf3d3e8d49";
        libraryHaskellDepends = [
          base containers universe-instances-base
        ];
@@ -135353,7 +135791,7 @@ self: {
      mkDerivation {
        pname = "universe-th";
        version = "0.0.0.6";
-       sha256 = "143kcgv4lp9266d8za878l343j6g97mxc3z7gj348jjamvpyg9wx";
+       sha256 = "9da7e7efae4a4a44867ce70fd6eb49cfc841064507a98f9a31225d4af6637390";
        libraryHaskellDepends = [
          base composition mtl template-haskell tuple uniplate
        ];
@@ -135373,7 +135811,7 @@ self: {
      mkDerivation {
        pname = "unix";
        version = "2.7.1.0";
-       sha256 = "0p74ljsl1zgwnyl69pg4l15z5rqidam9fw9il4siam2m700ydm3b";
+       sha256 = "6bd4e6013855541535a1317197aa6a11e7f24ba0e4dd64a8b7fcfd40b5a4e45c";
        libraryHaskellDepends = [ base bytestring time ];
        homepage = "https://github.com/haskell/unix";
        description = "POSIX functionality";
@@ -135385,7 +135823,7 @@ self: {
      mkDerivation {
        pname = "unix-bytestring";
        version = "0.3.7.3";
-       sha256 = "1340zxy9w8nmmhhwgg9rznvz8iyfhinpycdpkryqp60ilhyjgv53";
+       sha256 = "a3ec273da411988b7d9eb7317f6d84ce47f4b7fd39bdc721acd5229e7cff808c";
        libraryHaskellDepends = [ base bytestring ];
        homepage = "http://code.haskell.org/~wren/";
        description = "Unix/Posix-specific functions for ByteStrings";
@@ -135397,7 +135835,7 @@ self: {
      mkDerivation {
        pname = "unix-compat";
        version = "0.4.1.4";
-       sha256 = "0jxk7j5pz2kgfpqr4hznndjg31pqj5xg2qfc5308fcn9xyg1myps";
+       sha256 = "fafa1a9eefc93287c028cc61f17a91f886f164b3f64392f1756f8a7f8b3cb34b";
        libraryHaskellDepends = [ base unix ];
        homepage = "http://github.com/jystic/unix-compat";
        description = "Portable POSIX-compatibility layer";
@@ -135409,7 +135847,7 @@ self: {
      mkDerivation {
        pname = "unix-fcntl";
        version = "0.0.0";
-       sha256 = "18rjz14x1mbwdppf18gv3x4jwvz68bb2n1b11ygck60yl4pqbhb9";
+       sha256 = "69c1852fa11e98c99e0f61052bd642e66f2e491ffba1e0ee6d7cd5d049f832a3";
        isLibrary = true;
        isExecutable = true;
        libraryHaskellDepends = [ base foreign-var ];
@@ -135424,7 +135862,7 @@ self: {
      mkDerivation {
        pname = "unix-handle";
        version = "0.0.0";
-       sha256 = "07ysmd9ks5lm2lg1dik75m509ryn5azw28j9hcisknf5bmrfy9li";
+       sha256 = "9126ef725dc5d9a923834922c1bf2ad6e7044a2d67c6161e1595163d53abda1f";
        libraryHaskellDepends = [ base unix ];
        description = "POSIX operations on Handles";
        license = stdenv.lib.licenses.bsd3;
@@ -135435,7 +135873,7 @@ self: {
      mkDerivation {
        pname = "unix-io-extra";
        version = "0.1";
-       sha256 = "1qy28y1apm2dxp47v0ngxj4ww3iyq4lj0n0i4z9phyr1122fglig";
+       sha256 = "2fd2e78408217b78d32711582029c13e0ece89eccf827dc8ed4dd4ab8247c2e3";
        libraryHaskellDepends = [ base ];
        description = "Support for writev, pwrite and pread";
        license = stdenv.lib.licenses.bsd3;
@@ -135448,7 +135886,7 @@ self: {
      mkDerivation {
        pname = "unix-memory";
        version = "0.1.2";
-       sha256 = "1r8s7z39d31h1n7rcincy156lbsvamr6jicx52kv8simb9gvarpp";
+       sha256 = "f766b55f5a356ab4a7289d456972555b2f6a4af0cc46968f0d308c96c63f1ae5";
        libraryHaskellDepends = [ base ];
        testHaskellDepends = [
          base mtl QuickCheck tasty tasty-hunit tasty-quickcheck unix
@@ -135465,7 +135903,7 @@ self: {
      mkDerivation {
        pname = "unix-process-conduit";
        version = "0.2.2.3";
-       sha256 = "0ldgjwdvshggygxn9fpnxvb01dba0q0bn9f7iiw5xgqhli46nvcy";
+       sha256 = "9e6d6b48a410bf5e788cc725bb00066ab500d6eef6ba64fbf3ef41bd1b97af51";
        libraryHaskellDepends = [
          base bytestring conduit directory filepath process stm time
          transformers unix
@@ -135485,7 +135923,7 @@ self: {
      mkDerivation {
        pname = "unix-pty-light";
        version = "0.1";
-       sha256 = "1n21cd6chih86g6kfl6b0x4k533ykzz93anhf6wga3033rvy09wj";
+       sha256 = "9227e0771e030cf5b871d0aa91fe9f7e8c324907cb5037cd330846c84c6341d8";
        libraryHaskellDepends = [ base unix ];
        homepage = "http://code.haskell.org/~scook0/unix-pty-light";
        description = "POSIX pseudo-terminal support";
@@ -135499,7 +135937,7 @@ self: {
      mkDerivation {
        pname = "unix-time";
        version = "0.3.5";
-       sha256 = "0pk7046lmvl7dw6g7508xsixwi3gpiq5dw0a0lfwpfr80g6mh73z";
+       sha256 = "7f1c58cd0328bbcb1d050af05670bc6f44dea3ee0894f30c6f87ee4a0d01675e";
        libraryHaskellDepends = [ base binary bytestring old-time ];
        testHaskellDepends = [
          base bytestring doctest hspec old-locale old-time QuickCheck time
@@ -135513,7 +135951,7 @@ self: {
      mkDerivation {
        pname = "unlambda";
        version = "0.1.4.1";
-       sha256 = "01v0cl540gwc8j3x6q9gc7bvdcm9f843qbbk15llw9ik2dfm5987";
+       sha256 = "07a5525d1333264e6909732d3c0872a9b2b6d7612f61d387448c3f400a656007";
        isLibrary = true;
        isExecutable = true;
        libraryHaskellDepends = [ array base mtl ];
@@ -135527,7 +135965,7 @@ self: {
      mkDerivation {
        pname = "unlit";
        version = "0.3.0.3";
-       sha256 = "0nwd4cm3licmdx06cmq42ig7r0iirw2s3ifnna4yzxpysj2aapnf";
+       sha256 = "ce5ea584d4fef6ef89b2d6c5a105cf31827c5e14045766406f95453a2a238d5b";
        isLibrary = true;
        isExecutable = true;
        libraryHaskellDepends = [ base directory text ];
@@ -135544,7 +135982,7 @@ self: {
      mkDerivation {
        pname = "unm-hip";
        version = "0.3.1.6";
-       sha256 = "170ivv689jg2k9p8czp6miq3samjbdwanh3vh9csm8iq88yrzry5";
+       sha256 = "c5e79f3d4238a2aa59827b40ab785bb22a3d70ace67e866e9ae2c984ccde119c";
        libraryHaskellDepends = [
          array base bytestring containers process vector
        ];
@@ -135560,7 +135998,7 @@ self: {
      mkDerivation {
        pname = "unordered-containers";
        version = "0.2.5.1";
-       sha256 = "06l1xv7vhpxly75saxdrbc6p2zlgz1az278arfkz4rgawfnphn3f";
+       sha256 = "6e5878ade3ea65f2a7cb0a1df155f88f7e710d5bb975a5cbf1b45fb8cfee811a";
        libraryHaskellDepends = [ base deepseq hashable ];
        testHaskellDepends = [
          base ChasingBottoms containers hashable HUnit QuickCheck
@@ -135578,7 +136016,7 @@ self: {
      mkDerivation {
        pname = "unordered-containers-rematch";
        version = "0.1.0.0";
-       sha256 = "13ld8whx1m5xglaj2adsn0qb1x00p6ir8l9kz7fv815n6ahgcii8";
+       sha256 = "2846f6a032b604b4ddf9335194a3b900f4b030b0ba2921157dbdd4d021478d8e";
        libraryHaskellDepends = [
          base hashable rematch unordered-containers
        ];
@@ -135599,7 +136037,7 @@ self: {
      mkDerivation {
        pname = "unpack-funcs";
        version = "0.3.1";
-       sha256 = "0ha8xbg1a560rd5grg6i2acg3nzq6f4d6qa7i6vrbnz7bqbg77q3";
+       sha256 = "039ff3165ee7db95b7894761d38833f8dbf19812d1bcfc4acbc01415deea4841";
        libraryHaskellDepends = [
          base bytestring primitive template-haskell transformers vector
        ];
@@ -135613,7 +136051,7 @@ self: {
      mkDerivation {
        pname = "unroll-ghc-plugin";
        version = "0.1.1";
-       sha256 = "0n05777fqqpbgnh9jab04ayw1j1as4wkkbrjixi1288fhi44m87p";
+       sha256 = "f7a04a48840e2111628f32af3939d12ac8c0bd22602999a07deb62ecce390558";
        libraryHaskellDepends = [ base ghc ];
        homepage = "http://thoughtpolice.github.com/unroll-ghc-plugin";
        description = "Compiler plugin for loop unrolling";
@@ -135625,7 +136063,7 @@ self: {
      mkDerivation {
        pname = "unsafe";
        version = "0.0";
-       sha256 = "0hc6xr1i3hkz25gdgfx1jqgpsc9mwa05bkfynp0mcfdlyz6782nz";
+       sha256 = "df0a74ccf7b43956c1b5decd5580e235317d1f96a1bbd75e117fc21143ee8641";
        libraryHaskellDepends = [ base ];
        homepage = "http://code.haskell.org/~thielema/unsafe/";
        description = "Unified interface to unsafe functions";
@@ -135637,7 +136075,7 @@ self: {
      mkDerivation {
        pname = "unsafe-promises";
        version = "0.0.1.3";
-       sha256 = "1018c3q0aq6l0011az661dvlibiv6jvwdv4c40bi8pwapri66k70";
+       sha256 = "e04c6362be8a5f1417208cecc6b7343bae48770bc67c150200d46005f0602880";
        libraryHaskellDepends = [ base threads ];
        homepage = "https://github.com/kallisti-dev/unsafe-promises";
        description = "Create pure futures using lazy IO";
@@ -135649,7 +136087,7 @@ self: {
      mkDerivation {
        pname = "unsafely";
        version = "0.2.0.0";
-       sha256 = "10v50bzd7ccjs0d1spvyl6awhwdhxmkcacm2lkillk9f7myild0r";
+       sha256 = "19341a7d3d2e4d4ae3a4a232c566edb071c895a17e5f1d1ad092b1d3fe026583";
        isLibrary = true;
        isExecutable = true;
        libraryHaskellDepends = [ base ];
@@ -135665,7 +136103,7 @@ self: {
      mkDerivation {
        pname = "unsafeperformst";
        version = "0.9.2";
-       sha256 = "0l268mzlmswm0p9cybjvi6krsgic706av9kf90fx3ylyvhgzygvc";
+       sha256 = "6c3fff1fdc9efad11d486ea6ad0c382c3e9da7895b2ecfd20595eb4a7f454650";
        libraryHaskellDepends = [ base ];
        homepage = "https://github.com/atzeus/unsafeperformst";
        description = "Like unsafeperformIO, but for the ST monad";
@@ -135679,7 +136117,7 @@ self: {
      mkDerivation {
        pname = "unscramble";
        version = "1.0";
-       sha256 = "1zlf9dw3yid6s9p0q837h3qs2wnd9wr9kh282j4j4m0gpv9dcrrf";
+       sha256 = "2e67d6d2be0f5422891448c099324fcd72a1f18067200c6ed2a6453f784b8efe";
        isLibrary = false;
        isExecutable = true;
        executableHaskellDepends = [
@@ -135695,7 +136133,7 @@ self: {
      mkDerivation {
        pname = "unusable-pkg";
        version = "0.1";
-       sha256 = "102dzsa64vnbhx2pnnh6q0vn7wag9bd8pmmag3i2yl68iqaqlvpm";
+       sha256 = "f56e8a158ec8502fe278aad68bda4a4ff16337c0065a7b4587cb6e6294fe4d80";
        isLibrary = false;
        isExecutable = true;
        executableHaskellDepends = [ base ];
@@ -135710,7 +136148,7 @@ self: {
      mkDerivation {
        pname = "up";
        version = "1.0.0.3";
-       sha256 = "1w37jmnmx2vrdwbdcnhb29bvy4857pzcx4gdavmcp598lsfj34vy";
+       sha256 = "7e93219da62895cbea56ed91cefe3d0511bf57120b5ad6166f798b5e6d9567f0";
        isLibrary = false;
        isExecutable = true;
        executableHaskellDepends = [
@@ -135728,7 +136166,7 @@ self: {
      mkDerivation {
        pname = "up-grade";
        version = "0.0.2";
-       sha256 = "1njmx622ghpzgnwm4wykzjj1ixpalbj21hs7nkbwpmljniakp2fb";
+       sha256 = "cb893b55b492d6cbd7b447c320e4a2eaf618a4fcd37352b97dffc22784e955da";
        isLibrary = false;
        isExecutable = true;
        executableHaskellDepends = [ base ports-tools process ];
@@ -135744,7 +136182,7 @@ self: {
      mkDerivation {
        pname = "uploadcare";
        version = "0.1";
-       sha256 = "1lm7mp8djhxylavihaljqjfsgzpn747plkq6f7yd2dk32xlsb5bz";
+       sha256 = "7f95a569176336d1fc71064f7a0f39f6fea79dc4922a18b7a2be43d9d0ada7d2";
        libraryHaskellDepends = [
          aeson attoparsec base bytestring cryptohash hex http-conduit
          http-types old-locale time
@@ -135760,7 +136198,7 @@ self: {
      mkDerivation {
        pname = "upskirt";
        version = "0.0.4";
-       sha256 = "0528345xiq2xmi9fwzv0rvbjqfhcvyhkik8c453yr2nr03k0zs4c";
+       sha256 = "8ce80fe600d98aec47210ccd38a1df0c3a2cd7ce607fee52ac5de0d80b194814";
        libraryHaskellDepends = [ base bytestring ];
        description = "Binding to upskirt";
        license = stdenv.lib.licenses.publicDomain;
@@ -135777,7 +136215,7 @@ self: {
      mkDerivation {
        pname = "ureader";
        version = "0.2.0.0";
-       sha256 = "11zgs8mmmkvddyq6s0x98gdqbdaj6n3rxf6ab3xf1ap2cd4siwb8";
+       sha256 = "68f1a84963e2aae0fa58cab89e873552b585db43a9036db06f6dcf5a2bd2ef87";
        isLibrary = false;
        isExecutable = true;
        executableHaskellDepends = [
@@ -135801,7 +136239,7 @@ self: {
      mkDerivation {
        pname = "urembed";
        version = "0.5.0.1";
-       sha256 = "0fnr3xskzwxxxk7iv5bmqa18zbr612pn27jjiac0l4wzv33lisik";
+       sha256 = "33ea48c7d89f130a988a521e61af0826af8f82c275951dcfecbdf33f751fd93a";
        isLibrary = false;
        isExecutable = true;
        executableHaskellDepends = [
@@ -135820,7 +136258,7 @@ self: {
      mkDerivation {
        pname = "uri";
        version = "0.1.6.3";
-       sha256 = "1dhmrn4mq3ia0iv3y2k5pw71a6677q3vdqqf2w4b3aksi6wna49j";
+       sha256 = "321165b9897aaab108170ee3b6073ec718150ebf650a3f76042a0e5c89cd15b6";
        libraryHaskellDepends = [ base parsec safe utf8-string ];
        homepage = "http://gitorious.org/uri";
        description = "Library for working with URIs";
@@ -135835,7 +136273,7 @@ self: {
      mkDerivation {
        pname = "uri-bytestring";
        version = "0.1.6";
-       sha256 = "0wz45jrxrj2mqx26nv39hy962acmzchp97lbf3d2mjna9zcd1ij6";
+       sha256 = "46c6d0d84fcaca2ada708b9e7421fb9529619287696c6b44c755c8dcb32ce473";
        libraryHaskellDepends = [
          attoparsec base blaze-builder bytestring
        ];
@@ -135856,7 +136294,7 @@ self: {
      mkDerivation {
        pname = "uri-conduit";
        version = "1.1.1.2";
-       sha256 = "0bmq241in1x0bjffp6nmbz8lf324q926mcddpvmzn2j1ipy7fvg6";
+       sha256 = "e66d77fc8d410afbebbeadb16a44c2440c47d15fd59aeb9c5ca0071b0311b82e";
        libraryHaskellDepends = [
          base bytestring conduit containers deepseq failure monad-control
          network system-fileio system-filepath text transformers
@@ -135874,7 +136312,7 @@ self: {
      mkDerivation {
        pname = "uri-encode";
        version = "1.5.0.4";
-       sha256 = "10pmg48h1az474qsr951inyvkm5y9xqwrdzyvxf83k53i07kijpp";
+       sha256 = "f7ca380f88a3cc815cdffeb7cc714fbed4b9bd8da1a4ac3139e4ab001179f582";
        isLibrary = true;
        isExecutable = true;
        libraryHaskellDepends = [
@@ -135891,7 +136329,7 @@ self: {
      mkDerivation {
        pname = "uri-enumerator";
        version = "0.1.0.1";
-       sha256 = "164yzmx18ykkf2vbl9zhqmbvb80dig8bx3pfadw23a6wyvigmhw5";
+       sha256 = "85c3fae2f6dca8217853ee8ebed08b0da0b557c5f027bab670737a147afd9e98";
        libraryHaskellDepends = [
          base bytestring containers enumerator failure network text
          transformers
@@ -135911,7 +136349,7 @@ self: {
      mkDerivation {
        pname = "uri-enumerator-file";
        version = "0.1.1.1";
-       sha256 = "15ycv01kmwnwq3qkjjcl8ayal0p4klhflzkykm2rlq1d8mi2vmd6";
+       sha256 = "a6d52d62452d609a459d7e7eea209de402aabc42944939f1c0dcf23a03d8cc97";
        libraryHaskellDepends = [
          base bytestring containers enumerator lifted-base monad-control
          network system-fileio system-filepath text transformers
@@ -135929,7 +136367,7 @@ self: {
      mkDerivation {
        pname = "uri-template";
        version = "0.2";
-       sha256 = "1y1jqymjbawwdywk770j4rk8sy7p1plvfliwcmqr0h16y31kzlpl";
+       sha256 = "f4d23fc3f026409071653c52b7e90df7788d6626129c33b96f9cab25abc732f8";
        isLibrary = true;
        isExecutable = true;
        libraryHaskellDepends = [ base containers utf8-string ];
@@ -135946,7 +136384,7 @@ self: {
      mkDerivation {
        pname = "uri-templater";
        version = "0.2.0.0";
-       sha256 = "0ypyi5vz7fjgvw1xicjksjfbpvm472dif2jw6pn09jfgqkal075s";
+       sha256 = "ba1c40d5c4cfc904ec355c0a179b38a4eebb9cd453b2d803df4fbaf37789fe7a";
        libraryHaskellDepends = [
          ansi-wl-pprint base charset containers dlist HTTP mtl parsers
          template-haskell text trifecta unordered-containers vector
@@ -135964,7 +136402,7 @@ self: {
      mkDerivation {
        pname = "url";
        version = "2.1.3";
-       sha256 = "0qag18wbrq9jjk1444mjigz1xl7xl03fz66b1lnya9qaihzpxwjs";
+       sha256 = "5af27e3f8c0a27e52d0dcb98ef06a0fdd01efe8bb21242c29432e1bc380a4f61";
        libraryHaskellDepends = [ base utf8-string ];
        homepage = "http://www.haskell.org/haskellwiki/Url";
        description = "A library for working with URLs";
@@ -135976,7 +136414,7 @@ self: {
      mkDerivation {
        pname = "url-generic";
        version = "0.1";
-       sha256 = "0yfcy2nhc67kxb7n9mjxi4z5jcq4iz4kq80fb9lbi461vijhmw5m";
+       sha256 = "b5f00a65dcc190b8685a0e203cc98f0433593e895dd664cfeaf31806adf0cc79";
        revision = "1";
        editedCabalFile = "d9926e2ce6433a73b2ba940d476f7046890752c8a1145b42a78561e8d3ff6fb9";
        libraryHaskellDepends = [ base mtl syb ];
@@ -135992,7 +136430,7 @@ self: {
      mkDerivation {
        pname = "urlcheck";
        version = "0.1.1";
-       sha256 = "1mddlppdb0c9pxvjfm40i0bcrg7wbc61hzlrlv6kir0n1j9yb8ri";
+       sha256 = "31a3e5930c16e438cda6997e180c5bfcbccc168880542777bf8981d5eea5add5";
        isLibrary = false;
        isExecutable = true;
        executableHaskellDepends = [
@@ -136009,7 +136447,7 @@ self: {
      mkDerivation {
        pname = "urldecode";
        version = "1.0.0.2";
-       sha256 = "13fip41s78qcnrg4zccd5lk3qbsaax7h5sspc0xjzlaca664hq3y";
+       sha256 = "7e60488c514cd12f3b6057eb024f574a2f3c262d8db14f5eb60ca3a303b9d18d";
        isLibrary = false;
        isExecutable = true;
        executableHaskellDepends = [ base network ];
@@ -136024,7 +136462,7 @@ self: {
      mkDerivation {
        pname = "urldisp-happstack";
        version = "0.1";
-       sha256 = "1kg25w5pnmsnjwycnf0q6d65cqfw5d0xn9rwyn4ybhh3a8q2yaa8";
+       sha256 = "48292f305203c2e589f53c27db412bdc61564c331838cb3c9756577b0b2fe2cd";
        libraryHaskellDepends = [ base bytestring happstack-server mtl ];
        description = "Simple, declarative, expressive URL routing -- on happstack";
        license = stdenv.lib.licenses.bsd3;
@@ -136036,7 +136474,7 @@ self: {
      mkDerivation {
        pname = "urlencoded";
        version = "0.4.1";
-       sha256 = "16b7jxkfva8dyvl4fdg337jmv08aicycj041s79ak9r6zh41hhwi";
+       sha256 = "91431808fc26a7a9d2d18100c93c8b0a815de519e33547e8f60da9ed66976799";
        isLibrary = true;
        isExecutable = true;
        libraryHaskellDepends = [ base mtl network network-uri split ];
@@ -136052,7 +136490,7 @@ self: {
      mkDerivation {
        pname = "urlpath";
        version = "2.1.0";
-       sha256 = "1q8zj228ln9xmr3r0ggv6pi074l8ixchn81mw8664jikf2pjcqq9";
+       sha256 = "096326af70334a620ce235200b598f889203e235fb3d9047ae3d598a84901fe1";
        revision = "1";
        editedCabalFile = "a342b25d9ea3984cf20025d421f59629d7abdf4bd2b42a4e9ef53ba5729f13e1";
        libraryHaskellDepends = [
@@ -136071,7 +136509,7 @@ self: {
      mkDerivation {
        pname = "urn";
        version = "0.1.0.0";
-       sha256 = "1wxgq445nzfly9773bjx3mr15l8ga4840d2q1zw50kk07fwxx6h7";
+       sha256 = "079adeb93b604e50f80f58344010510fd112721d5dae714ef2d47d5b08c1aff3";
        libraryHaskellDepends = [ base parsec ];
        testHaskellDepends = [ base hspec ];
        jailbreak = true;
@@ -136087,7 +136525,7 @@ self: {
      mkDerivation {
        pname = "urxml";
        version = "0.2.0.0";
-       sha256 = "141b2dhqpbirqlv53rm3xsl14mq0vxw96r3qhygraw5gp5vlvgl9";
+       sha256 = "89be4d77b9af70959f8778649378df005712a8eea3e65136c539ae8b61132b90";
        isLibrary = false;
        isExecutable = true;
        executableHaskellDepends = [
@@ -136107,7 +136545,7 @@ self: {
      mkDerivation {
        pname = "usb";
        version = "1.3.0.3";
-       sha256 = "0wn17x61pnckrxn4gba7fdk1phjm82dc2wiblm2wc36xf6mw16yf";
+       sha256 = "ce9bc0ab71dd0cc645a52b72c19a4055c21b667347ad476ccf93d91b4c3fc172";
        libraryHaskellDepends = [
          base bindings-libusb bytestring containers ghc-prim text vector
        ];
@@ -136123,7 +136561,7 @@ self: {
      mkDerivation {
        pname = "usb-enumerator";
        version = "0.3";
-       sha256 = "1gd132pshcqa8539g1dmx1hpzfdd33x7vpi9d3hrc6q6l6312nfs";
+       sha256 = "da591186a1061b96e16829de7dfa18adb97f61e8b5859746410a33a8af18a1bd";
        libraryHaskellDepends = [
          base base-unicode-symbols bindings-libusb iteratee monad-control
          transformers usb
@@ -136139,7 +136577,7 @@ self: {
      mkDerivation {
        pname = "usb-hid";
        version = "0.1.0.0";
-       sha256 = "0mx4f1zrk098c9isczni66i8qisx54r85kwyk2s238dznlys39gh";
+       sha256 = "f0a5a13db5bfa121b4989ecf8232295d478ca231d17ea663622881997f70a457";
        revision = "1";
        editedCabalFile = "3fe150e203f72b72c425bef276254a2ca91ca40cab21f6088838bb32c806e8dc";
        libraryHaskellDepends = [ attoparsec base bytestring usb ];
@@ -136156,7 +136594,7 @@ self: {
      mkDerivation {
        pname = "usb-id-database";
        version = "0.4.0.9";
-       sha256 = "1ji6zrglmlkhv743w4d4lrqvhva4yl5kqxb420z44l1wymvgg1s1";
+       sha256 = "4187f776f53c50423e1064753c0bf5446db871a6a4113ec8d970d24a5ffe26ca";
        isLibrary = true;
        isExecutable = true;
        libraryHaskellDepends = [
@@ -136175,7 +136613,7 @@ self: {
      mkDerivation {
        pname = "usb-iteratee";
        version = "0.5";
-       sha256 = "04kv2pfw24d46b135p6mwgf40wb9q43lcy66cbczh4lz0630j771";
+       sha256 = "e11c0986019f12f8d962c6784607c1697140dce3d5dc32c232a411c1dd157b12";
        libraryHaskellDepends = [
          base base-unicode-symbols bindings-libusb iteratee monad-control
          usb vector
@@ -136194,7 +136632,7 @@ self: {
      mkDerivation {
        pname = "usb-safe";
        version = "0.14";
-       sha256 = "1dhx7y74f2c04dmlsx0i80ar31d6k2qsgh7432c8k0y29iwhdzfm";
+       sha256 = "d5fd06794cc283899818e4c0a7b198a68591154011744d6b238009478e3f1db6";
        libraryHaskellDepends = [
          base base-unicode-symbols bindings-libusb bytestring iteratee
          regions text transformers usb
@@ -136211,7 +136649,7 @@ self: {
      mkDerivation {
        pname = "users";
        version = "0.3.0.0";
-       sha256 = "1f63223fxrcyp3gz63viqncqs7yln0mifcnh123172rnfhn61zka";
+       sha256 = "6afe602c74368b138608d032172bb0d41f8d99c5710ff3dfb89ee5ee8610c3b8";
        libraryHaskellDepends = [
          aeson base bcrypt path-pieces text time
        ];
@@ -136228,7 +136666,7 @@ self: {
      mkDerivation {
        pname = "users-persistent";
        version = "0.3.0.0";
-       sha256 = "0hdvsnjciw3a6gsz5lv5q6m5fs3hd60gmgfbzgx5n7md2ya5jimr";
+       sha256 = "b946599417ad1e5bfafbcbbdfa8069706857aac165d3f2f5336af0c8a4d5bb41";
        libraryHaskellDepends = [
          aeson base bytestring mtl persistent persistent-template text time
          users uuid
@@ -136248,7 +136686,7 @@ self: {
      mkDerivation {
        pname = "users-postgresql-simple";
        version = "0.3.0.0";
-       sha256 = "039da6rvjcdjg5lpd5hqkxcb9vgdcd7ppjiqk3gn6jl5q1gn1yzr";
+       sha256 = "f9fb605fc0854a63df9838ca7b4f63ededb4589f1896766979b231b9b3512d0d";
        libraryHaskellDepends = [
          aeson base bytestring mtl postgresql-simple text time users uuid
        ];
@@ -136263,7 +136701,7 @@ self: {
      mkDerivation {
        pname = "users-test";
        version = "0.3.0.0";
-       sha256 = "1cmrd0igkidmv8jfb3dv3g49i1k71rh3i4v3dksql18g7472cnxh";
+       sha256 = "b05b260e390f058af56c639338600e678698c81bbb8de524dab5c5f92268b9b2";
        libraryHaskellDepends = [ aeson base hspec text users ];
        homepage = "https://github.com/agrafix/users";
        description = "Library to test backends for the users library";
@@ -136278,7 +136716,7 @@ self: {
      mkDerivation {
        pname = "utc";
        version = "0.2.0.1";
-       sha256 = "0vnydjjvv0kh1mww9vb9l90crl9ddd5n63dwpjjs8ln56b5yvv5h";
+       sha256 = "b0ecedcb32c552a4a5bcbc0d634b6b2dd1cc40a269edc4790d7082bda56cde6e";
        libraryHaskellDepends = [
          attoparsec base bytestring clock exceptions text
        ];
@@ -136297,7 +136735,7 @@ self: {
      mkDerivation {
        pname = "utf8-env";
        version = "0.1";
-       sha256 = "0ls2ls2n12igm1day730sp1gfcwxvkkqd2xdp2lmyp2ldp0d72zp";
+       sha256 = "f78bd3c06d545c5fa9b8ad8b86e7dc9d33f7c2d5601caf5aa82f8a6085a64253";
        libraryHaskellDepends = [ base mtl utf8-string ];
        description = "UTF-8 aware substitutes for functions in System.Environment";
        license = stdenv.lib.licenses.bsd3;
@@ -136308,7 +136746,7 @@ self: {
      mkDerivation {
        pname = "utf8-light";
        version = "0.4.2";
-       sha256 = "0rwyc5z331yfnm4hpx0sph6i1zvkd1z10vvglhnp0vc9wy644k0q";
+       sha256 = "184c428ce7896d702da46f6f107e6873ff100dbc1af40b49b5ce87317e619e67";
        libraryHaskellDepends = [ base bytestring ghc-prim ];
        description = "Unicode";
        license = stdenv.lib.licenses.bsd3;
@@ -136319,7 +136757,7 @@ self: {
      mkDerivation {
        pname = "utf8-prelude";
        version = "0.1.6";
-       sha256 = "156kjn3da02z060srlsm8kqwbxzcscjzxdkp4lmv8zq5zscha5v6";
+       sha256 = "66170599fe057fb42b2577b6fe25d3ecf7c5f14455d3ac81015f00d58695d394";
        isLibrary = true;
        isExecutable = true;
        libraryHaskellDepends = [ base utf8-string ];
@@ -136333,7 +136771,7 @@ self: {
      mkDerivation {
        pname = "utf8-string";
        version = "1";
-       sha256 = "025snarzyk4kkw1dk3i8dsxilvxh4kazl6nwq61w9q49y39qiwvr";
+       sha256 = "79f388d3f089e0c483c1dc1afad524b06f1abb6e288ed9029f934cffb3b2ba08";
        libraryHaskellDepends = [ base bytestring ];
        homepage = "http://github.com/glguy/utf8-string/";
        description = "Support for reading and writing UTF8 Strings";
@@ -136345,7 +136783,7 @@ self: {
      mkDerivation {
        pname = "utility-ht";
        version = "0.0.10";
-       sha256 = "17ydzb0p8xhddvfvm4wjv5yjmy0v7nj6fsj11srnnpj91wc9k0xd";
+       sha256 = "ad8399180f495e6bb30e416a67a43d1bf82a7dd99293badd6e0d7674c1facd9f";
        libraryHaskellDepends = [ base ];
        testHaskellDepends = [ base QuickCheck ];
        description = "Various small helper functions for Lists, Maybes, Tuples, Functions";
@@ -136357,7 +136795,7 @@ self: {
      mkDerivation {
        pname = "uu-cco";
        version = "0.1.0.3";
-       sha256 = "0na2gd82z7llrppaskfkrqj3lbl0k6kvb62n4qhpqgsyz001fi8j";
+       sha256 = "12451700f85e3f7c21265698b5a799802e3a24ced34dadeecd949e2f507b4259";
        libraryHaskellDepends = [ ansi-terminal base ];
        homepage = "https://github.com/UU-ComputerScience/uu-cco";
        description = "Utilities for compiler construction: core functionality";
@@ -136369,7 +136807,7 @@ self: {
      mkDerivation {
        pname = "uu-cco-examples";
        version = "0.1.0.1";
-       sha256 = "1i8idcbq602hl1il326lq9b5gcjm9qn00wpragr1kj676g615024";
+       sha256 = "448012cc33c7c819f253f972002c4e55b25756c2d4884163a0500083176b11c5";
        isLibrary = false;
        isExecutable = true;
        executableHaskellDepends = [ base uu-cco uuagc uuagc-cabal ];
@@ -136383,7 +136821,7 @@ self: {
      mkDerivation {
        pname = "uu-cco-hut-parsing";
        version = "0.1.0.1";
-       sha256 = "06ddh2fcvy0zbzzdgpcx8kvlssrcmxx4swgkl8iy7223llanx0px";
+       sha256 = "fd826e15a54388e323a2f3714d7aaf2c6b4df7449dddd7fe5f1ff8cd9c80ad19";
        libraryHaskellDepends = [ base uu-cco uulib ];
        homepage = "https://github.com/UU-ComputerScience/uu-cco";
        description = "Utilities for compiler construction: Feedback wrapper around parser in uulib";
@@ -136395,7 +136833,7 @@ self: {
      mkDerivation {
        pname = "uu-cco-uu-parsinglib";
        version = "0.1.0.1";
-       sha256 = "1sshnlqb0ydxgrhm0i1c3mpnixfsqwrf3gl59yz4rhiw5hy33z71";
+       sha256 = "e1fc313c2c3cc24cbe4f85bee132c7daf5686f1d2c4450617ebd79b030b550eb";
        libraryHaskellDepends = [ base ListLike uu-cco uu-parsinglib ];
        homepage = "https://github.com/UU-ComputerScience/uu-cco";
        description = "Utilities for compiler construction: Feedback wrapper around parser in uu-parsinglib";
@@ -136407,7 +136845,7 @@ self: {
      mkDerivation {
        pname = "uu-interleaved";
        version = "0.2.0.0";
-       sha256 = "1rysap86jrq43b99ay52nrmbdpcba7cl0ac85nsb7gll1rbyr59i";
+       sha256 = "3195ec570e94beb3b42d882940d9518bddb66ab6a27895d21a046769d055dae7";
        libraryHaskellDepends = [ base ];
        homepage = "http://www.cs.uu.nl/wiki/bin/view/HUT/ParserCombinators";
        description = "Providing an interleaving combinator for use with applicative/alternative style implementations";
@@ -136421,7 +136859,7 @@ self: {
      mkDerivation {
        pname = "uu-options";
        version = "0.2.0.0";
-       sha256 = "11gixk6lxsakcdxir9jla5nk71phmlzd9hxp8wq23n550xw91ij6";
+       sha256 = "46c6907807a5d8213047b7c3d43eadf086336d5154a61c7b6353e94ecdecf185";
        libraryHaskellDepends = [
          base lenses mtl template-haskell transformers uu-interleaved
          uu-parsinglib
@@ -136436,7 +136874,7 @@ self: {
      mkDerivation {
        pname = "uu-parsinglib";
        version = "2.9.1";
-       sha256 = "0cic0f689a6n2si43ijyvkp174y1yfppqv64dicwxz6rm2jhz70d";
+       sha256 = "0d9c0fa5a8d9fcce596cc46c7caff3c19313eedc5ec641a216d6a8848c032c32";
        libraryHaskellDepends = [ base ListLike time uu-interleaved ];
        homepage = "http://www.cs.uu.nl/wiki/bin/view/HUT/ParserCombinators";
        description = "Fast, online, error-correcting, monadic, applicative, merging, permuting, interleaving, idiomatic parser combinators";
@@ -136448,7 +136886,7 @@ self: {
      mkDerivation {
        pname = "uu-tc";
        version = "2009.2.2";
-       sha256 = "0s7b23r7gnavwnvzpi25mc0hyg605ms249k5i4661nqpfiwn7zry";
+       sha256 = "3eff63797417db600c89652622742dc03c0f01ab45c4fbb7e55bd977f210eb68";
        libraryHaskellDepends = [ base ];
        description = "Haskell 98 parser combintors for INFOB3TC at Utrecht University";
        license = stdenv.lib.licenses.bsd3;
@@ -136462,7 +136900,7 @@ self: {
      mkDerivation {
        pname = "uuagc";
        version = "0.9.52.1";
-       sha256 = "1191a1jr1s76wjdrfzafy1ibf7a7xpg54dvwhwz4kr1jrc9jn2cq";
+       sha256 = "98092b13cb32e4493e877c3752deed471db762f04e7d979be4e6e89065502185";
        isLibrary = true;
        isExecutable = true;
        libraryHaskellDepends = [
@@ -136482,7 +136920,7 @@ self: {
      mkDerivation {
        pname = "uuagc-bootstrap";
        version = "0.9.40.2";
-       sha256 = "0zsb8pz2zx7y8sjp392hpdk30dzzmppjizcnlgd1wvq2csacnfxq";
+       sha256 = "b83bcb9466026f1edaa396fd28efadff373066bb50a471a546fef42ffe454b7f";
        isLibrary = true;
        isExecutable = true;
        libraryHaskellDepends = [
@@ -136505,7 +136943,7 @@ self: {
      mkDerivation {
        pname = "uuagc-cabal";
        version = "1.0.6.0";
-       sha256 = "02xqj4vz7hir0llxl8n517qv22jlmilknhqzx4l55gccffg7zj6w";
+       sha256 = "dcc87f9e738cbd5228e91f433b69ac540ab1f109c522da290539c2f33791b80b";
        libraryHaskellDepends = [
          base Cabal containers directory filepath mtl process uulib
        ];
@@ -136519,7 +136957,7 @@ self: {
      mkDerivation {
        pname = "uuagc-diagrams";
        version = "0.1.1.0";
-       sha256 = "16sf4kbjgxsi3amdpr3nqg15f2gmjvf3w2wh6pn72zhjqsbnfnmz";
+       sha256 = "bf5a6797c6127e71ec35900b3edc96f50957c2c376e4dbaa1a51f727d7244e9b";
        libraryHaskellDepends = [ base diagrams-lib SVGFonts ];
        jailbreak = true;
        description = "Utility for drawing attribute grammar pictures with the diagrams package";
@@ -136532,7 +136970,7 @@ self: {
      mkDerivation {
        pname = "uuagd";
        version = "0.1.0.2";
-       sha256 = "1gcznzb8hr2x5mr5pgfqhnvjjrll96g855g4niacw5bd52wdvsla";
+       sha256 = "8aeaddb8286d15ce54b4e495829e49946629b785d8bd5b722d5d6488d6b79fbd";
        isLibrary = true;
        isExecutable = true;
        libraryHaskellDepends = [ base blaze-html ];
@@ -136550,7 +136988,7 @@ self: {
      mkDerivation {
        pname = "uuid";
        version = "1.3.11";
-       sha256 = "1m8lk12ls4c5xx1y3wm2n2spm2c5slwb27k6zrdibja8z397c637";
+       sha256 = "671876d2f848c9155bfe661eb138d585897ab5b0a2f2e143ef85114d459814d5";
        libraryHaskellDepends = [
          base binary bytestring cryptohash network-info random text time
          uuid-types
@@ -136569,7 +137007,7 @@ self: {
      mkDerivation {
        pname = "uuid-aeson";
        version = "0.1.0.0";
-       sha256 = "0nd2xm908zycrbmrayi6d4c9p9rfplsjkwnz43nrq94xjn1dp2yg";
+       sha256 = "cf8bdb82959d249ced20dff22935bd2ea79b1869267a95ebcacc7f0452eda259";
        libraryHaskellDepends = [ aeson base text uuid ];
        description = "Aeson types for UUID instances";
        license = stdenv.lib.licenses.bsd3;
@@ -136580,7 +137018,7 @@ self: {
      mkDerivation {
        pname = "uuid-le";
        version = "0.2014.1";
-       sha256 = "1gfm7bxmr2b5hn4x3dr231ra0b1nwp36x2808w3l43yglz8zwp74";
+       sha256 = "e45cfed1a7cf0f42074700896ec6e5362ca0721822b7d1898565895cfb3ad5bd";
        libraryHaskellDepends = [ base bytestring uuid ];
        description = "Universally Unique Identifiers with little-endian-ish encoding tools";
        license = stdenv.lib.licenses.mit;
@@ -136591,7 +137029,7 @@ self: {
      mkDerivation {
        pname = "uuid-quasi";
        version = "0.1.0.1";
-       sha256 = "09ijnbj2znaqanaxghql3yy1fqb0nsjhrwi6kfzg4h8nrw1ir2pj";
+       sha256 = "f28a1c03cf1641f2be9b26f20ca5b6606117bc1f14c3d7955558d92fe4b23226";
        libraryHaskellDepends = [ base template-haskell uuid ];
        homepage = "http://github.com/lpeterse/uuid-quasi";
        description = "Supplemental package for 'uuid' allowing quasiquotation";
@@ -136605,7 +137043,7 @@ self: {
      mkDerivation {
        pname = "uuid-types";
        version = "1.0.2";
-       sha256 = "019f9w1jvqacbxmq828wsn6zpwp5yw7bkhyj34a4cc2zq3bfkijn";
+       sha256 = "56c6e9d6c05f30461419d2c3b90ef7e5f2fb8dd51c09846b5f4ce12d034f2e05";
        libraryHaskellDepends = [
          base binary bytestring deepseq hashable random text
        ];
@@ -136622,7 +137060,7 @@ self: {
      mkDerivation {
        pname = "uulib";
        version = "0.9.20";
-       sha256 = "1qz73rjxywc9mf54d2j4xv9m7d15gnfmi1c1fj3yklx059xlvfz2";
+       sha256 = "e2bb4d7b2aa0d3e987748185589d7d25b453d3ee448a468aab8971df651ee7e3";
        libraryHaskellDepends = [ base ghc-prim ];
        homepage = "https://github.com/UU-ComputerScience/uulib";
        description = "Haskell Utrecht Tools Library";
@@ -136634,7 +137072,7 @@ self: {
      mkDerivation {
        pname = "uvector";
        version = "0.1.1.1";
-       sha256 = "1psbdsq20nr28cr9ni2mwzwkpz3p20n1xqp0m0m9qafz66d2vi08";
+       sha256 = "08c42d9a31df299c2aa8e0e21e2c1077fc3bf9e755449b3243225b20b06e4bdf";
        revision = "1";
        editedCabalFile = "e289ff93c365248deb93e6268b57be8a47d724a39702887979fd842c80577508";
        libraryHaskellDepends = [ base ghc-prim ];
@@ -136650,7 +137088,7 @@ self: {
      mkDerivation {
        pname = "uvector-algorithms";
        version = "0.2";
-       sha256 = "0jzlirrar7grq3h02k22zxyvy1wmfrjw9lscnhpjqmsxjli1jh81";
+       sha256 = "01411922955d572c2fb44cd3c465769507bf7dff424c01e0c0f99dac728ef44b";
        libraryHaskellDepends = [ base uvector ];
        homepage = "http://code.haskell.org/~dolio/";
        description = "Efficient algorithms for uvector unboxed arrays";
@@ -136663,7 +137101,7 @@ self: {
      mkDerivation {
        pname = "uxadt";
        version = "0.0.16.0";
-       sha256 = "0qmp5k4wg5ja2382cwarf8fwjval2a5wdwvz32f965hvwgc9cd43";
+       sha256 = "833496d8e31b16939c187ff3c68b12546dc91d72597126d0104a96c7c92cb762";
        libraryHaskellDepends = [ base json MissingH mtl ];
        description = "Cross-language extensible representation for algebraic data type instances";
        license = stdenv.lib.licenses.gpl3;
@@ -136674,7 +137112,7 @@ self: {
      mkDerivation {
        pname = "uzbl-with-source";
        version = "0.1.0.0";
-       sha256 = "0q6n18kqga839gkdgdwsfbnbpfm4hh1qjln17qnmfxm3ylh2l9la";
+       sha256 = "8a262a20f5a376572d3ec152890384a4babbec729ab7d7e64b03a987270ad660";
        libraryHaskellDepends = [ base process ];
        homepage = "http://github.com/Fuuzetsu/uzbl-with-source";
        description = "Utility function for reading a source of loaded uzbl pages";
@@ -136688,7 +137126,7 @@ self: {
      mkDerivation {
        pname = "v4l2";
        version = "0.1.0.3";
-       sha256 = "1hhdpljlic1kyz0pgnv9a04z6prv7rl3x5bam5j0yhm5vijrisgp";
+       sha256 = "f7e99865dca5420f64a96a953e683e3b5ff3095069db77c1f733b04825bd0dc2";
        libraryHaskellDepends = [
          base bindings-DSL bindings-libv4l2 bindings-linux-videodev2
          bindings-posix containers ioctl
@@ -136704,7 +137142,7 @@ self: {
      mkDerivation {
        pname = "v4l2-examples";
        version = "0.1.0.2";
-       sha256 = "1knn4cbvvk1vsn9if87hqfg761n4410p08g7vlav900svfm8i1l5";
+       sha256 = "858688aadb1a80b415dde721704120c406739ec3f0201793d53bccbd1723d6ce";
        isLibrary = false;
        isExecutable = true;
        executableHaskellDepends = [ base GLUT v4l2 ];
@@ -136720,7 +137158,7 @@ self: {
      mkDerivation {
        pname = "vacuum";
        version = "2.2.0.0";
-       sha256 = "157wjx2shzfh6dfl6h8x017cn9ji3ql1p0gpi79ginz4s81f2ny1";
+       sha256 = "c15be102d2e4dbf8d289f7811b281e5126cb4e001d41435d33d07da84597fc94";
        libraryHaskellDepends = [ array base containers ghc-prim ];
        homepage = "http://thoughtpolice.github.com/vacuum";
        description = "Graph representation of the GHC heap";
@@ -136735,7 +137173,7 @@ self: {
      mkDerivation {
        pname = "vacuum-cairo";
        version = "0.5";
-       sha256 = "0jp3xn1h28igcg3xb97ifawx11i7adnyi0ff264w0fril9b8ylwc";
+       sha256 = "8c538f56a2313bc08911ce81e86d532786d0b972f1a4d5c7632f220183ede34a";
        libraryHaskellDepends = [
          base cairo deepseq directory gtk pretty process strict-concurrency
          svgcairo vacuum
@@ -136751,7 +137189,7 @@ self: {
      mkDerivation {
        pname = "vacuum-graphviz";
        version = "2.1.0.1";
-       sha256 = "093ba6n30a6gyifnk3bd50rkx8qldjqq9vsk92pnq152ibs36b2m";
+       sha256 = "552c33f48aa2046caf4853ef84b16c14a33e33286d8d695df4cf2830ac516b24";
        libraryHaskellDepends = [ base filepath graphviz vacuum ];
        jailbreak = true;
        description = "A library for transforming vacuum graphs into GraphViz output";
@@ -136766,7 +137204,7 @@ self: {
      mkDerivation {
        pname = "vacuum-opengl";
        version = "0.0.3";
-       sha256 = "1dxw3apbf59b7vi4a1gnp29ia1s2q9vx79ns7257cg9cazb01z7j";
+       sha256 = "f2fc00d6572c3d768a38daa6d377c242071593b8f60545e23e2b15b7ae1abcb7";
        isLibrary = true;
        isExecutable = true;
        libraryHaskellDepends = [ base network pretty vacuum ];
@@ -136785,7 +137223,7 @@ self: {
      mkDerivation {
        pname = "vacuum-ubigraph";
        version = "0.2.0.2";
-       sha256 = "0zpag42dr2763ddrwdy7744lqkd6207ljfw3bqm6db3a1128861z";
+       sha256 = "3f188444086aac662a5e833b490f10a64d4c0939c7379e5b1be688dc0479ea7e";
        libraryHaskellDepends = [ base containers hubigraph vacuum ];
        jailbreak = true;
        description = "Visualize Haskell data structures using vacuum and Ubigraph";
@@ -136800,7 +137238,7 @@ self: {
      mkDerivation {
        pname = "vado";
        version = "0.0.5";
-       sha256 = "07bqcp58hqyh5zvi6zpwwpppfzj30j60ryf6k0wqzckklibffqkj";
+       sha256 = "7262e756a473b28f3998c6f90c8c04437e77efe5fc7e13f72fd06388ca65781d";
        isLibrary = true;
        isExecutable = true;
        libraryHaskellDepends = [
@@ -136822,7 +137260,7 @@ self: {
      mkDerivation {
        pname = "valid-names";
        version = "0.1.0.1";
-       sha256 = "14gpkb6pbkvmny17g2gpq6i6kq7ahmcnkgrcrwm72vda12wxsl78";
+       sha256 = "e850ddb908aa6d712acf2cbf695985eae069a2c1f7897782b775cf75cd9af791";
        libraryHaskellDepends = [ base containers MonadRandom ];
        jailbreak = true;
        homepage = "https://i.joelt.io/symbols.html";
@@ -136835,7 +137273,7 @@ self: {
      mkDerivation {
        pname = "validate";
        version = "2.0.0";
-       sha256 = "19d02sblyxg73prlrmlcs4vclzxzg2pzlrp67f2kx94nsw0v3l4p";
+       sha256 = "97d0b101d796a43e853be666faaf78bf7fca36d18cd64cf31de7754f9716a0a5";
        description = "None";
        license = stdenv.lib.licenses.bsd3;
        hydraPlatforms = stdenv.lib.platforms.none;
@@ -136848,7 +137286,7 @@ self: {
      mkDerivation {
        pname = "validate-input";
        version = "0.2.0.0";
-       sha256 = "0ijlkfizxpjy7r0bh59zfj1jyn77gqd0ryz8k19v7znckq7bxgls";
+       sha256 = "9abebe0e9eccfeb35398e8fb0c1a7ee7582f83743f15b8403e5edefea39b5446";
        libraryHaskellDepends = [
          base bytestring either mtl pcre-heavy stringable text
        ];
@@ -136866,7 +137304,7 @@ self: {
      mkDerivation {
        pname = "validation";
        version = "0.5.1";
-       sha256 = "09fx4aa9jlyd59qyx0p6wpvzf9kr29j7xb10nsq61pxjbs1hn5qb";
+       sha256 = "0b170b835eb2df60b0b620ac7e64127926f7f7e5e682ee712acd53999422dd25";
        libraryHaskellDepends = [
          base bifunctors lens mtl semigroupoids semigroups transformers
        ];
@@ -136886,7 +137324,7 @@ self: {
      mkDerivation {
        pname = "validations";
        version = "0.1.0.2";
-       sha256 = "0nviyyp0nlpilp2byckrcmbd2n6wp40pq7m10da9b24hmwajkdwk";
+       sha256 = "93b72915af9088955403a11e7c01b9dc58d156657932bfc4a5f1520baef7715b";
        libraryHaskellDepends = [
          base containers digestive-functors mtl text transformers
        ];
@@ -136906,7 +137344,7 @@ self: {
      mkDerivation {
        pname = "value-supply";
        version = "0.6";
-       sha256 = "0fd6rk46sgdbdmfdr9wy0f3qzwaymgd9hl9v735g2a4bqiqanmb5";
+       sha256 = "6555ab70c48b28f1ca383b5198daab5ef18f87039ea7dc5c6dab3d6dc8cca639";
        libraryHaskellDepends = [ base ];
        description = "A library for generating values without having to thread state";
        license = stdenv.lib.licenses.bsd3;
@@ -136919,7 +137357,7 @@ self: {
      mkDerivation {
        pname = "vampire";
        version = "0.1.3.0";
-       sha256 = "16f1mdsyyfdgjcp3rzf3p1qj3d6la01i9y1yyp97m5nmd2jxsn1q";
+       sha256 = "3858dda568d5967ad2f53ef8140350d4b42171b8c3fd3c2e93af39ef75abc199";
        isLibrary = true;
        isExecutable = true;
        libraryHaskellDepends = [
@@ -136943,7 +137381,7 @@ self: {
      mkDerivation {
        pname = "var";
        version = "0.2.0.0";
-       sha256 = "1vc36yy8mvzy14jj8ly8ldc4d9vrcgyjfq3dpnzp6fhycg5kkv2i";
+       sha256 = "51ec39cb631e3a73bfbd6d6027fd6379a74658a3c853242509feef8abc3783ed";
        libraryHaskellDepends = [ base transformers ];
        testHaskellDepends = [
          base QuickCheck test-framework test-framework-quickcheck2
@@ -136961,7 +137399,7 @@ self: {
      mkDerivation {
        pname = "varan";
        version = "0.5.1";
-       sha256 = "1hvpx4jw0lwcnc4x8vwdqp7rv8779p7xaw57cphkax13f3rwm372";
+       sha256 = "e28ccaf370237435e165a770d5cf4de7a09dcfc58d6fd409b38c53c025e977c3";
        isLibrary = false;
        isExecutable = true;
        executableHaskellDepends = [
@@ -136979,7 +137417,7 @@ self: {
      mkDerivation {
        pname = "variable-precision";
        version = "0.4";
-       sha256 = "1qd6mnbg06fn31vp9d4yan8rqxyymjljrlr7m4yvn2ppw560p564";
+       sha256 = "c4940b4ce1f70abb3da927d32ca9acde779c91559eb4747718d619f096ada6e1";
        libraryHaskellDepends = [
          base complex-generic floatshow integer-gmp
          type-level-natural-number
@@ -136995,7 +137433,7 @@ self: {
      mkDerivation {
        pname = "variables";
        version = "0.1.1";
-       sha256 = "0garxmxm11qhp2wm7xib4nrlkfiqbyzf3glkdbqb582nip0sb1rp";
+       sha256 = "3787a5c18d56a0b2f06a93bee1be5f38ba49b3252bf653b9b81087507bed593d";
        libraryHaskellDepends = [ base mtl stm ];
        testHaskellDepends = [ base hspec mtl QuickCheck stm ];
        jailbreak = true;
@@ -137008,8 +137446,10 @@ self: {
     ({ mkDerivation, base, time }:
      mkDerivation {
        pname = "varying";
-       version = "0.1.0.3";
-       sha256 = "1y7mf2q1lawx3f8hdd9b70fa3hrmabm9lmi2rhxvr1dq5r5yh5q7";
+       version = "0.1.1.0";
+       sha256 = "38ef53b0b042e2083b9300c682de437a095cb807f518eb708b02a1caff650b73";
+       revision = "1";
+       editedCabalFile = "85e4874332bfcfa3dde2ca4ca8157e8fe2e4aa3c2e46a273e21b563843c3d288";
        isLibrary = true;
        isExecutable = true;
        libraryHaskellDepends = [ base time ];
@@ -137025,7 +137465,7 @@ self: {
      mkDerivation {
        pname = "vault";
        version = "0.3.0.4";
-       sha256 = "0ah6qrg71krc87f4vjy4b4shdd0mgyil8fikb3j6fl4kfwlg67jn";
+       sha256 = "561ef32877935067e458333a44a37f15b4063559c4cb4ddc412ccf705ec6062a";
        libraryHaskellDepends = [
          base containers hashable unordered-containers
        ];
@@ -137043,7 +137483,7 @@ self: {
      mkDerivation {
        pname = "vaultaire-common";
        version = "2.9.1";
-       sha256 = "178lh1cxk6ayb4918xas0g7zlan8282vjflm220pzymnxz07chsr";
+       sha256 = "594376c0efb6fa7f8110953ab90512c82afacf035a751412595e99d95980149d";
        libraryHaskellDepends = [
          async attoparsec base blaze-builder bytestring cereal containers
          hashable hslogger locators old-locale packer QuickCheck siphash
@@ -137065,7 +137505,7 @@ self: {
      mkDerivation {
        pname = "vcache";
        version = "0.2.6";
-       sha256 = "08vg106dhzam5h0a6pzz4cbyzfg6pfgcgvn6xm1266kj1ipla18d";
+       sha256 = "0d05456f0c721a2342edc6eec79ebbe6b9ef1723ff5fa3002c557dd80c086f23";
        libraryHaskellDepends = [
          base bytestring containers direct-murmur-hash easy-file filelock
          lmdb random stm transformers
@@ -137082,7 +137522,7 @@ self: {
      mkDerivation {
        pname = "vcache-trie";
        version = "0.2.0";
-       sha256 = "0d56l8339ak9my6c37j3mykmfzz67405xyb90pl0i5lf35mbff32";
+       sha256 = "6238b76a198e9608e80569f95e0039e67f57a7af439ec18caf69aa3406a2a634";
        libraryHaskellDepends = [
          array base bytestring bytestring-builder vcache
        ];
@@ -137096,7 +137536,7 @@ self: {
      mkDerivation {
        pname = "vcard";
        version = "0.1.4";
-       sha256 = "1wa1pdfw7ykmq72af63fh999il5nighf7689265hn3i5awm1m16p";
+       sha256 = "d7841a2a57250e0b8b110999e3e08bb6d09852826e18a7c4c175fac35dbb41f1";
        libraryHaskellDepends = [
          base bytestring containers mime-directory
        ];
@@ -137111,7 +137551,7 @@ self: {
      mkDerivation {
        pname = "vcd";
        version = "0.2.2";
-       sha256 = "0x0smhllghzn0xjfk5cwxaf1vnd2yp3saxw92ylyws8a546mzhzm";
+       sha256 = "f5c35f0d290a69eea9178977a5c7f5a2d91d9cea9c95e96407f6c34729ac1a74";
        libraryHaskellDepends = [ base polyparse ];
        homepage = "http://tomahawkins.org";
        description = "Reading and writing VCD files";
@@ -137123,27 +137563,39 @@ self: {
      mkDerivation {
        pname = "vcs-revision";
        version = "0.0.2";
-       sha256 = "1lp1wf440n7kinmxz7la0gyfqfdlip6f0bn8pmwkxd1dqyrvg5cg";
+       sha256 = "8f95b7b3c72db43e79bdc82ee0cc8db439ecfc038a9edfab8df3584088e3e1d2";
        libraryHaskellDepends = [ base process ];
        description = "Facilities for accessing the version control revision of the current directory";
        license = stdenv.lib.licenses.bsd3;
      }) {};
 
+  "vcs-web-hook-parse" = callPackage
+    ({ mkDerivation, aeson, base, bytestring, text }:
+     mkDerivation {
+       pname = "vcs-web-hook-parse";
+       version = "0.1.0.0";
+       sha256 = "578cceeed56d13410a33663987268c85f3c54693759cb6dc4e008b3953217961";
+       libraryHaskellDepends = [ aeson base bytestring text ];
+       homepage = "http://rel4tion.org/projects/vcs-web-hook-parse/";
+       description = "Parse development platform web hook messages";
+       license = stdenv.lib.licenses.publicDomain;
+     }) {};
+
   "vcsgui" = callPackage
-    ({ mkDerivation, base, directory, filepath, gtk, mtl, process, text
-     , vcswrapper
+    ({ mkDerivation, base, directory, filepath, gtk3, mtl, process
+     , text, vcswrapper
      }:
      mkDerivation {
        pname = "vcsgui";
-       version = "0.1.2.0";
-       sha256 = "0wqvd57n74fps2cybn970fgag2bxz8y8wwx4hb3dz7znpqzlp7y8";
+       version = "0.1.3.0";
+       sha256 = "0d8997fec3f3a0025045408f8e619abd9568247a08228daa0ff7fa9508e7b06b";
        isLibrary = true;
        isExecutable = true;
        libraryHaskellDepends = [
-         base directory filepath gtk mtl process text vcswrapper
+         base directory filepath gtk3 mtl process text vcswrapper
        ];
        executableHaskellDepends = [
-         base directory filepath gtk mtl process text vcswrapper
+         base directory filepath gtk3 mtl process text vcswrapper
        ];
        homepage = "https://github.com/forste/haskellVCSGUI";
        description = "GUI library for source code management systems";
@@ -137157,7 +137609,7 @@ self: {
      mkDerivation {
        pname = "vcswrapper";
        version = "0.1.2";
-       sha256 = "1rbmlfg6kf7b1njfwnd85shlhw8b65j53zsrcn250baj8z0x0p9s";
+       sha256 = "3a5dd0c147522d50846559ff5164310b7148a12ea859eea40debb8699ea375e5";
        isLibrary = true;
        isExecutable = true;
        libraryHaskellDepends = [
@@ -137178,7 +137630,7 @@ self: {
      mkDerivation {
        pname = "vect";
        version = "0.4.7";
-       sha256 = "1049jh8rcxfnyckz5m5asdlyafqszlig96k387raldyfzbrf8f4d";
+       sha256 = "8d38e4f2face37aaf241639af422fd1a3be569d3aad4f227f3d6759611948980";
        libraryHaskellDepends = [ base random ];
        homepage = "http://code.haskell.org/~bkomuves/";
        description = "A low-dimensional linear algebra library, tailored to computer graphics";
@@ -137190,7 +137642,7 @@ self: {
      mkDerivation {
        pname = "vect-floating";
        version = "0.1.0.4";
-       sha256 = "1kxsjsiqqpi7k0xz597z7r2fd45s38plgk6jplzxagg0i3bm0q4g";
+       sha256 = "8f6050d788e03dd53fbdd2cc472f1aba90e6443effa4f23b98275e8ca396bacf";
        libraryHaskellDepends = [ base random ];
        jailbreak = true;
        homepage = "http://github.com/cpdurham/vect-floating";
@@ -137203,7 +137655,7 @@ self: {
      mkDerivation {
        pname = "vect-floating-accelerate";
        version = "0.1.0.4";
-       sha256 = "10mn2gvpkp14j7rc7cc66x30k7xh56xpp04ak1aj8p46rsy75s4x";
+       sha256 = "9de872bcce865c2455988a807bbb29b09f09463786b1c3f29124dc79f713b682";
        revision = "1";
        editedCabalFile = "af7a5778a0ab8e79fdd4d535aeda7dba18ead15ea3f0b5ae87c3b17c5a076216";
        libraryHaskellDepends = [ accelerate base vect-floating ];
@@ -137218,7 +137670,7 @@ self: {
      mkDerivation {
        pname = "vect-opengl";
        version = "0.4.6.1";
-       sha256 = "1qp98j6bgldjcs71pd7iqc5sjf1ixb1jj0l267hw532j4yf81dig";
+       sha256 = "2fb6809c27528cc2e131820229c3ea3138a90bc3f1b41b8e66b2d1b78c44e9e2";
        libraryHaskellDepends = [ base OpenGL vect ];
        homepage = "http://code.haskell.org/~bkomuves/";
        description = "OpenGL support for the `vect' low-dimensional linear algebra library";
@@ -137230,7 +137682,7 @@ self: {
      mkDerivation {
        pname = "vector";
        version = "0.10.9.3";
-       sha256 = "08mlg0v7an6mm04skvxrgfndab0wikfs4glv7jj8ylxwc8959kdx";
+       sha256 = "bdcd541262bc538fa43c9b3ea2dd8c1c2cd5ac7bb9efa909a8d558753678b422";
        libraryHaskellDepends = [ base deepseq ghc-prim primitive ];
        jailbreak = true;
        homepage = "https://github.com/haskell/vector";
@@ -137246,7 +137698,7 @@ self: {
      mkDerivation {
        pname = "vector";
        version = "0.10.12.3";
-       sha256 = "16p8i0gvc9d4n9mxlhlnvrl2s0gmgd7kcsk5czdzz2cd4gh5qxhg";
+       sha256 = "0f765ce0238d89ffdb67656a364f7bf5012d68de9642da6bb2a425b61f88e89a";
        libraryHaskellDepends = [ base deepseq ghc-prim primitive ];
        testHaskellDepends = [
          base QuickCheck random template-haskell test-framework
@@ -137266,7 +137718,7 @@ self: {
      mkDerivation {
        pname = "vector";
        version = "0.11.0.0";
-       sha256 = "1r1jlksy7b0kb0fy00g64isk6nyd9wzzdq31gx5v1wn38knj0lqa";
+       sha256 = "0a5320ed44c3f2b04b7f61e0f63f4fcd5b337524e601e01d5813ace3f5a432e4";
        libraryHaskellDepends = [ base deepseq ghc-prim primitive ];
        testHaskellDepends = [
          base QuickCheck random template-haskell test-framework
@@ -137285,7 +137737,7 @@ self: {
      mkDerivation {
        pname = "vector-algorithms";
        version = "0.7";
-       sha256 = "1ijnmgvdhj2qi5rsq4b1ffci47inck9arrcan5jzfkvzr54fvzcx";
+       sha256 = "9dfded48c97f4ff765b18ae5acd264361e1299736111ac73895848d8f6ab56c6";
        revision = "1";
        editedCabalFile = "ba3ba4dbfe97dc45be68d13c51ba4425900b186a46cdf3eceaafb746030c1b95";
        isLibrary = true;
@@ -137305,7 +137757,7 @@ self: {
      mkDerivation {
        pname = "vector-binary";
        version = "0.1.1";
-       sha256 = "1qdjibh3ywfa0lvawdahnr9qhh2qy6899lm5inbzmksjpykgbazz";
+       sha256 = "ffabf5a6bf52cffa978da5d29490f158408853b65035ae3605ca713fe08ab2e1";
        libraryHaskellDepends = [ base binary vector ];
        homepage = "https://github.com/kawu/vector-binary";
        description = "Binary instances for vector types (deprecated)";
@@ -137317,7 +137769,7 @@ self: {
      mkDerivation {
        pname = "vector-binary-instances";
        version = "0.2.1.0";
-       sha256 = "028rsf2w193rhs1gic5yvvrwidw9sblczcn10aw64npfc6502l4l";
+       sha256 = "9450018a61ee5a62b802c1b2cfe8d289b7c8f3debeb0f8828679a4c085d31909";
        libraryHaskellDepends = [ base binary cereal vector ];
        homepage = "https://github.com/bos/vector-binary-instances";
        description = "Instances of Data.Binary and Data.Serialize for vector";
@@ -137329,7 +137781,7 @@ self: {
      mkDerivation {
        pname = "vector-buffer";
        version = "0.4.1";
-       sha256 = "16zxc2d25qd15nankhc974ax7q3y72mg5a77v5jsfrw291brnnlv";
+       sha256 = "9b5a9b57488267a765d9e7a8f2aa387ee0d3153989c169952da1e1229a60fd9b";
        libraryHaskellDepends = [ base deepseq vector ];
        description = "A buffer compatible with Data.Vector.*";
        license = stdenv.lib.licenses.bsd3;
@@ -137342,7 +137794,7 @@ self: {
      mkDerivation {
        pname = "vector-bytestring";
        version = "0.0.0.1";
-       sha256 = "0xiksm1136azrcidcsi9g59i1nb9r8lhzsn1fhnp830sr63fy7k4";
+       sha256 = "641eef86c91a0c742d74c1ea0f29ca69d9105379296ad622cb5f991142d53376";
        isLibrary = true;
        isExecutable = true;
        libraryHaskellDepends = [
@@ -137365,7 +137817,7 @@ self: {
      mkDerivation {
        pname = "vector-clock";
        version = "0.2.2";
-       sha256 = "0ndp25w61rcj4sadvhxlirrk1dhk7rmdzv9kha7kyqa41whr9629";
+       sha256 = "499894210f44613f8f8233eddf6a3e13b630738eb4c3dd942692e5607811b759";
        libraryHaskellDepends = [ base binary ghc-prim hashable ];
        testHaskellDepends = [
          array base binary ghc-prim HUnit QuickCheck test-framework
@@ -137385,7 +137837,7 @@ self: {
      mkDerivation {
        pname = "vector-conduit";
        version = "0.5.0.0";
-       sha256 = "10mqmxfqzqcgxf0isv611ailq03smdfybviamxpskncbf15sc6g1";
+       sha256 = "e119a64b708bd9a96faf2aeee55dab7a004ca30ac16c1d81eb8fe18f5dafb882";
        libraryHaskellDepends = [ base conduit primitive vector ];
        testHaskellDepends = [
          base conduit HUnit primitive QuickCheck test-framework
@@ -137402,7 +137854,7 @@ self: {
      mkDerivation {
        pname = "vector-fftw";
        version = "0.1.3.2";
-       sha256 = "0rfvr86yiwp4wb9qjggbbacmgkfj6xrk6h7xb4xmhmk88slvifm0";
+       sha256 = "a0bab8a9466856583b59fd40337337d2cd57995aeb3d89d3e2e4f2e80dcadb65";
        libraryHaskellDepends = [ base primitive storable-complex vector ];
        librarySystemDepends = [ fftw ];
        jailbreak = true;
@@ -137418,7 +137870,7 @@ self: {
      mkDerivation {
        pname = "vector-functorlazy";
        version = "0.0.1";
-       sha256 = "0ysic3f5xw675bk095pby9ihbgcxpkj4pgp61dwr354w28l0yc03";
+       sha256 = "03300f28129c9491790be6be4be4bc9dbd0563f2eb9604e62ac7f05edc60517b";
        libraryHaskellDepends = [
          base ghc-prim primitive vector vector-th-unbox
        ];
@@ -137433,7 +137885,7 @@ self: {
      mkDerivation {
        pname = "vector-heterogenous";
        version = "0.2.0";
-       sha256 = "14v0qj2r484pwbjhdymvdqjnsbqszl9wr71hv6wsvs2d8ja1bajl";
+       sha256 = "54aa1594444de8adb9d9309ccc13fd1a2f6d256ebbfa06e5e297209285c46093";
        libraryHaskellDepends = [ base vector ];
        homepage = "http://github.com/mikeizbicki/vector-heterogenous/";
        description = "A type-safe library for vectors whose elements can be of any type, or any type satisfying some constraints";
@@ -137446,8 +137898,8 @@ self: {
      }:
      mkDerivation {
        pname = "vector-instances";
-       version = "3.3.0.1";
-       sha256 = "1npgvnv8pw5xcax57cam9n5j9ra9phm4b5jj26hbpzwnlh0rkcc4";
+       version = "3.3.1";
+       sha256 = "68c7f154fe4ad53e29433e150c8718b0e74b4cf4c45a79af89940fff83868c59";
        libraryHaskellDepends = [
          base comonad keys pointed semigroupoids semigroups vector
        ];
@@ -137461,7 +137913,7 @@ self: {
      mkDerivation {
        pname = "vector-instances-collections";
        version = "0.1.0.1";
-       sha256 = "13xk2iwdwrnmdm33z0fmj4sg3irih4ayl3q5pgz31qs9kcsbhi0s";
+       sha256 = "1a44b8349b49e330febb050fea158131c7f13491d5813f466dd566de7814b38f";
        libraryHaskellDepends = [
          base collections-api template-haskell vector
        ];
@@ -137477,7 +137929,7 @@ self: {
      mkDerivation {
        pname = "vector-mmap";
        version = "0.0.2";
-       sha256 = "03hczjc7j1hxnny912cblxdwn908gwm012w03zgj2v9avldp0gmr";
+       sha256 = "b93e701bdd2a6d21df1f808b002a7f0824cb5ba78b8990bcb51d067998fc0c0e";
        libraryHaskellDepends = [ base mmap primitive vector ];
        homepage = "http://github.com/pumpkin/vector-mmap";
        description = "Memory map immutable and mutable vectors";
@@ -137489,7 +137941,7 @@ self: {
      mkDerivation {
        pname = "vector-random";
        version = "0.2";
-       sha256 = "1f74q4bs5mbcw8xg4sxb46ks5x121lbbr6cl09ssr09cpykkbdvb";
+       sha256 = "6bb735a7bf2c81ac75029499bc160d22f4a2a721ab6bf23ae26cd5a217c1e4b8";
        libraryHaskellDepends = [ base mersenne-random-pure64 vector ];
        homepage = "http://code.haskell.org/~dons/code/vector-random";
        description = "Generate vectors filled with high quality pseudorandom numbers";
@@ -137502,7 +137954,7 @@ self: {
      mkDerivation {
        pname = "vector-read-instances";
        version = "0.0.2.0";
-       sha256 = "1k30n5qh16sdfxy77vp10bx52lb1ffmjn70vg87hx12j8wg9vbv6";
+       sha256 = "66af9d1e4752840e0f7a1b1c2bab73615151fa02e1ee737c774d9b0071b160cc";
        libraryHaskellDepends = [ base vector ];
        homepage = "http://www.tbi.univie.ac.at/~choener/";
        description = "(deprecated) Read instances for 'Data.Vector'";
@@ -137515,7 +137967,7 @@ self: {
      mkDerivation {
        pname = "vector-space";
        version = "0.10.2";
-       sha256 = "0n78g23jw6pcilkssnkqvnq1z8ram1al6cbas24ziacdwjbw6zah";
+       sha256 = "507dc397e48da9f889d06a314355a82aa31fb0dd785aad278dec1a2e8778e858";
        libraryHaskellDepends = [ base Boolean MemoTrie NumInstances ];
        description = "Vector & affine spaces, linear maps, and derivatives";
        license = stdenv.lib.licenses.bsd3;
@@ -137526,7 +137978,7 @@ self: {
      mkDerivation {
        pname = "vector-space-map";
        version = "0.1.0.1";
-       sha256 = "1s5hh7dlbw1ai3nqqcavrqgidddfj99mi0gmhf2x2zn6ag86xr8b";
+       sha256 = "0be56ed053c67ed18583f581585392aeb5161fce5b318ced882af045db81b0e8";
        libraryHaskellDepends = [ base containers vector-space ];
        jailbreak = true;
        homepage = "https://github.com/conklech/vector-space-map";
@@ -137541,7 +137993,7 @@ self: {
      mkDerivation {
        pname = "vector-space-opengl";
        version = "0.2";
-       sha256 = "17rczadmjiblh96r7bfcxy53m7ig534qqcf35i7w6x90354dyiaw";
+       sha256 = "5c45df48192075c34f2cc3318cc9282f9e3a8aefccad934d827445599bfa2c9f";
        libraryHaskellDepends = [ base OpenGL vector-space ];
        testHaskellDepends = [
          base ieee754 OpenGL QuickCheck test-framework
@@ -137557,7 +138009,7 @@ self: {
      mkDerivation {
        pname = "vector-space-points";
        version = "0.2.1.1";
-       sha256 = "0d5k7wmwhm9y2jif4fy71bnp8nwbfnkh033nzhiw36wfl35aaznp";
+       sha256 = "d77ea5caa08e9bc123fc760c00a7758b5b74ed0ac73be2a2143e55c82b3fb334";
        libraryHaskellDepends = [ base vector-space ];
        description = "A type for points, as distinct from vectors";
        license = stdenv.lib.licenses.bsd3;
@@ -137568,7 +138020,7 @@ self: {
      mkDerivation {
        pname = "vector-static";
        version = "0.3.0.1";
-       sha256 = "19spzrk64j2rgyi15dvs8gfbx3nc79ybssaxkv8dn9df4fwksv91";
+       sha256 = "216d3db923ae25dbd09e5d69bd7c3acc8ebedc437ab712a27f59486266fe57a7";
        libraryHaskellDepends = [ base primitive vector ];
        jailbreak = true;
        homepage = "http://github.com/geezusfreeek/vector-static";
@@ -137582,7 +138034,7 @@ self: {
      mkDerivation {
        pname = "vector-strategies";
        version = "0.4";
-       sha256 = "04vaizcc78q94vpaly28iwhlwk6nwrsa6jmcq2afdl6yqp63njc6";
+       sha256 = "86493bccc5ded0e694c0ac4aa374e6d64c4e218f4878aaee2609a3c3d88f6a13";
        libraryHaskellDepends = [ base deepseq parallel vector ];
        description = "A parallel evaluation strategy for boxed vectors";
        license = stdenv.lib.licenses.bsd3;
@@ -137593,7 +138045,7 @@ self: {
      mkDerivation {
        pname = "vector-th-unbox";
        version = "0.2.1.2";
-       sha256 = "01admr0akldwwmzmc465f5dbqmq03ldvma67kibanjs25m39dxhd";
+       sha256 = "0df696462d424bab569cc7a8ba1b1d0057bc5a71c510567fe5bcd1a940ae4d05";
        libraryHaskellDepends = [ base template-haskell vector ];
        testHaskellDepends = [ base data-default vector ];
        description = "Deriver for Data.Vector.Unboxed using Template Haskell";
@@ -137605,7 +138057,7 @@ self: {
      mkDerivation {
        pname = "verbalexpressions";
        version = "1.0.0.0";
-       sha256 = "0wai72bqb1vp4p7ml1yj2jdmkjglihai9vhmgj7ri6y2qgzkpwly";
+       sha256 = "9ef23bffc3c29b988f7c15ee14158cf4c9599b14d2075acf2577878597385171";
        libraryHaskellDepends = [ base regex-pcre ];
        jailbreak = true;
        homepage = "https://github.com/VerbalExpressions/HaskellVerbalExpressions";
@@ -137618,7 +138070,7 @@ self: {
      mkDerivation {
        pname = "verbosity";
        version = "0.2.0.0";
-       sha256 = "0vwv4f5ni6dzvj3jbgxcy8b2hmal6c8xbdin16pifqrn55d52pa9";
+       sha256 = "495d515a29366317af0936b6d5113354552816f2acbf2587dcbf99688b239b6f";
        libraryHaskellDepends = [ base binary data-default-class deepseq ];
        homepage = "https://github.com/trskop/verbosity";
        description = "Simple enum that encodes application verbosity";
@@ -137630,7 +138082,7 @@ self: {
      mkDerivation {
        pname = "verilog";
        version = "0.0.11";
-       sha256 = "0lhl6zcf8f8ndyqx7ksj1qy4a5wnhvphsawb944d5rynrnj8fd46";
+       sha256 = "863487a4cdd6e7d208498b2b0def869617453c0e52cfd3b16f1639e4d8371452";
        libraryHaskellDepends = [ array base ];
        libraryToolDepends = [ alex happy ];
        homepage = "http://github.com/tomahawkins/verilog";
@@ -137648,7 +138100,7 @@ self: {
      mkDerivation {
        pname = "vhd";
        version = "0.2.2";
-       sha256 = "0z7a17j0rd06kvn3v4qr0fhxg0xw6n3579477y2lvx4mcc3qyrvw";
+       sha256 = "7c678f076395f44d853f87a4538635bc83d7a10319933dec9e06b40ce409ea7c";
        isLibrary = true;
        isExecutable = true;
        libraryHaskellDepends = [
@@ -137669,7 +138121,7 @@ self: {
      mkDerivation {
        pname = "vhdl";
        version = "0.1.2.1";
-       sha256 = "1bi8n8m9an1hcj4c6i2ifqyadg32nq4viffi1kiihaw3j7dh552b";
+       sha256 = "4b9402db91832b18e30cd1b9b809b662bca63c765144c388643058952ab228ae";
        libraryHaskellDepends = [ base mtl pretty regex-posix ];
        description = "VHDL AST and pretty printer";
        license = stdenv.lib.licenses.bsd3;
@@ -137680,7 +138132,7 @@ self: {
      mkDerivation {
        pname = "views";
        version = "1.0";
-       sha256 = "0kzwp58lki3jvx09n6w8rc97idhy947xqik72p2fqjyigkymv04h";
+       sha256 = "90805dfd7cd14becc4156746dc0f491eb67812cb881b9b40df72c44951b9fc4f";
        libraryHaskellDepends = [ base mtl ];
        jailbreak = true;
        description = "Views allow you to run a State monad on part of a state";
@@ -137702,7 +138154,7 @@ self: {
      mkDerivation {
        pname = "vigilance";
        version = "0.1.0.1";
-       sha256 = "1qmwqc2cgrmcjcdfwz0hmfn1irzrwbb7mybrl7myf711sri9ng45";
+       sha256 = "853c9b62d6211ce7eba179f97ad6e2f9e718acab107cee1a93ace6c704c3bce2";
        isLibrary = false;
        isExecutable = true;
        executableHaskellDepends = [
@@ -137740,7 +138192,7 @@ self: {
      mkDerivation {
        pname = "vimeta";
        version = "0.2.1.0";
-       sha256 = "0sc5mlv4d9srgv6rj43ddn27rindpyrz2mwz2i5rmm8y4ixn7jrq";
+       sha256 = "38cb637b241ed59a4b149f57f1b3bfcdc67c846d6d1099cd7e59a74636ad8569";
        isLibrary = true;
        isExecutable = true;
        libraryHaskellDepends = [
@@ -137764,7 +138216,7 @@ self: {
      mkDerivation {
        pname = "vimus";
        version = "0.2.1";
-       sha256 = "0j4j4rsngp76pvssg6kisqqwr9d95fcmxp21yq4483vvc1cv78g2";
+       sha256 = "e2a1b359607b0f4408f641dc5e992ba9a5cc31d6719aa7f5bee6dc6775269248";
        isLibrary = true;
        isExecutable = true;
        libraryHaskellDepends = [
@@ -137790,7 +138242,7 @@ self: {
      mkDerivation {
        pname = "vintage-basic";
        version = "1.0.1";
-       sha256 = "0hmnkmg6sz702nplh7indlzmv7bb36fmaglf9lw0fziabaj9kk25";
+       sha256 = "45cc99a45a2a7e07384d8e3e559d196b9d5d3f6d361e48af15e07c6d5e9db642";
        isLibrary = false;
        isExecutable = true;
        executableHaskellDepends = [
@@ -137808,7 +138260,7 @@ self: {
      mkDerivation {
        pname = "vinyl";
        version = "0.5.1";
-       sha256 = "026h8lgz487d9xhfjscnfpykgv1ppk944hl8mb6z7y3c1vh4g63b";
+       sha256 = "6b9847e00e6cf8f3cdaa884242d2bc37ec37fd759669e9604fed20f21f45d008";
        libraryHaskellDepends = [ base ghc-prim ];
        testHaskellDepends = [ base doctest lens singletons ];
        jailbreak = true;
@@ -137825,7 +138277,7 @@ self: {
      mkDerivation {
        pname = "vinyl-gl";
        version = "0.3.0.1";
-       sha256 = "182ipz8znzk5fi7mpy3m1nbsyqq54p8y0hqycnnbmaxqsmhy6z5a";
+       sha256 = "aa7ce361d5b8abbaac651e43e0d1250563af970d75f85b4f74657efbd1bf51a0";
        libraryHaskellDepends = [
          base containers GLUtil linear OpenGL tagged transformers vector
          vinyl
@@ -137846,7 +138298,7 @@ self: {
      mkDerivation {
        pname = "vinyl-json";
        version = "0.1.0.0";
-       sha256 = "07rjlwalpq67hc4pha6x02qbw5pxaz4yimx8sclps9dl7r76xi5c";
+       sha256 = "acc46e4e3eb4257d29d3a8d7e8c957fd16beb000dd28780983c7e04b15a7321f";
        libraryHaskellDepends = [
          aeson base bytestring template-haskell text vinyl
        ];
@@ -137862,7 +138314,7 @@ self: {
      mkDerivation {
        pname = "vinyl-utils";
        version = "0.1.0.1";
-       sha256 = "07clcs7rmzbwn4w9xzbiwc3flrcn2l5p0k5isapis803fpzdq2p0";
+       sha256 = "e00adcfe7503201dafd2b14c700b159665ea06e371fd9e38b17cfd9a8f66941d";
        libraryHaskellDepends = [ base contravariant transformers vinyl ];
        homepage = "http://hub.darcs.net/mjm/vinyl-utils";
        description = "Utilities for vinyl";
@@ -137877,7 +138329,7 @@ self: {
      mkDerivation {
        pname = "virthualenv";
        version = "0.2.2";
-       sha256 = "08z6dvhv4k6a71dvqhvcfl8s5aq7qcg8aj5xbym3931yykl0gxc2";
+       sha256 = "82f507e8f43e8c34aa5fbd48851ec307aba211756c43bc5b38ca4cb2e16ee623";
        isLibrary = false;
        isExecutable = true;
        executableHaskellDepends = [
@@ -137899,7 +138351,7 @@ self: {
      mkDerivation {
        pname = "vision";
        version = "0.0.5.0";
-       sha256 = "1235zclhg4nkd387df4gg3q88hvsqwsdj1j20lnfnclxfah0qxa2";
+       sha256 = "42750ca0729d32eb2c054206d934c77a4384f0788fb876d068d3920729fb6588";
        isLibrary = false;
        isExecutable = true;
        executableHaskellDepends = [
@@ -137921,7 +138373,7 @@ self: {
      mkDerivation {
        pname = "visual-graphrewrite";
        version = "0.4.0.1";
-       sha256 = "0myppx9bd8bfhii91lqdp00ckp20bq82754mr01s87l1d01gb4wp";
+       sha256 = "9793f50268811ea403c8959423105e40dcc900b80dd39062846ea1b652bfd757";
        isLibrary = true;
        isExecutable = true;
        libraryHaskellDepends = [
@@ -137948,7 +138400,7 @@ self: {
      mkDerivation {
        pname = "visual-prof";
        version = "0.5";
-       sha256 = "00wvxsq6yaidiv2izdxsvvfzj8ksrq8y3fky9y68k82ivh7r2y39";
+       sha256 = "6978910fdc51a0898c4f7ebae111ce7a22f9dddebab71fc58e2d2a6fb0ee9b03";
        isLibrary = false;
        isExecutable = true;
        executableHaskellDepends = [
@@ -137969,7 +138421,7 @@ self: {
      mkDerivation {
        pname = "vivid";
        version = "0.1.0.3";
-       sha256 = "034kjk2lxfbb4hd8z1axccz9alfkm76mpgw39nisvxngjs6si158";
+       sha256 = "a884a88d96cff6ada34d83bf5bcda9d351953e635d858f1a246bb94ec594930c";
        revision = "1";
        editedCabalFile = "de2442ab5d53f8044c99cd0489281bf902ef6615028be780e0df937ae60266da";
        libraryHaskellDepends = [
@@ -137988,7 +138440,7 @@ self: {
      mkDerivation {
        pname = "vk-aws-route53";
        version = "0.1.2";
-       sha256 = "0sblvj89bb7vxgy09m88gcphqc9w2mpawg8kdz0r77y7db0vzb4x";
+       sha256 = "9dacbfc16ac79f93c16f133dae6e153c310c2f7b08d504fcebfbac9590dc7469";
        libraryHaskellDepends = [
          aws base bytestring containers http-conduit http-types old-locale
          resourcet text time xml-conduit xml-hamlet
@@ -138003,7 +138455,7 @@ self: {
      mkDerivation {
        pname = "vk-posix-pty";
        version = "0.2.1";
-       sha256 = "1kj06niwcsb4lyhppv5bs67cf8frcs4g8fyyzv3cpipn0xdhsr97";
+       sha256 = "27650d5b07f6c6cbc6fede3bf48866d921c78ed1abec7ba1a76469c6a33540ce";
        isLibrary = true;
        isExecutable = true;
        libraryHaskellDepends = [ base bytestring process unix ];
@@ -138018,7 +138470,7 @@ self: {
      mkDerivation {
        pname = "vocabulary-kadma";
        version = "0.1.0.0";
-       sha256 = "1qzx1kl93ic68rvpwf1y9q3gn5c2zf5536ajp6l4xh75dykl8mpb";
+       sha256 = "eb5644a76fe5c04ea8b95299518afb8215fb064e3e387e774686c591e80cfde3";
        libraryHaskellDepends = [ base smaoin ];
        homepage = "http://rel4tion.org/projects/vocabularies-hs/";
        description = "Smaoin vocabulary definitions of the base framework";
@@ -138030,7 +138482,7 @@ self: {
      mkDerivation {
        pname = "void";
        version = "0.7";
-       sha256 = "0ivgr4minxb5v56v4kbd045iwqk1c2w89c830731l75mkg8qa6wq";
+       sha256 = "981b85d19bb51c1ac60103b184b86061621e0b016d4db24dd965751b2bc96f47";
        libraryHaskellDepends = [ base ghc-prim hashable semigroups ];
        homepage = "http://github.com/ekmett/void";
        description = "A Haskell 98 logically uninhabited data type";
@@ -138043,7 +138495,7 @@ self: {
      mkDerivation {
        pname = "vorbiscomment";
        version = "0.0.2";
-       sha256 = "12kfih0marcrpw9y6wvxgqy6w73f62yhy02c05wcpwxww5cg9iwx";
+       sha256 = "9dc7f458e1bcf3cb78014c000fbd306e1c6e3c7e7d73e313bf996555018c6e8a";
        libraryHaskellDepends = [
          base binary-strict bytestring mtl utf8-string
        ];
@@ -138057,7 +138509,7 @@ self: {
      mkDerivation {
        pname = "vowpal-utils";
        version = "0.1.2";
-       sha256 = "09z6nbsj4rqzhksk75glrsrmcs21p8x0jmcpqs6rc9iizz79db8g";
+       sha256 = "0fad96ceff3126968dc69755093aba416856b3cef49533f5841f6722f5b2e627";
        libraryHaskellDepends = [ base bytestring ];
        jailbreak = true;
        homepage = "https://github.com/cartazio/Vowpal-Utils";
@@ -138071,7 +138523,7 @@ self: {
      mkDerivation {
        pname = "voyeur";
        version = "0.1.0.1";
-       sha256 = "117xvh6llh3aw8nxrvvqyjaflq35l69b7s4j1sc79p8r972mdwff";
+       sha256 = "cef156c54919dd74980e92e8b392a16560ea94f478efdc2de26a404a0ddcfd84";
        libraryHaskellDepends = [ base bytestring process utf8-string ];
        jailbreak = true;
        homepage = "https://github.com/sethfowler/hslibvoyeur";
@@ -138085,7 +138537,7 @@ self: {
      mkDerivation {
        pname = "vte";
        version = "0.13.0.2";
-       sha256 = "1w3y88rqkxx3pmcx73kmihivk2k4ywm7jnb9lvmvkgj4bqggis3h";
+       sha256 = "70e8f81e5e44beb9eba66959792af7648ab9238c758ed359bda3f78933427ef0";
        libraryHaskellDepends = [ base glib gtk pango ];
        libraryPkgconfigDepends = [ vte ];
        libraryToolDepends = [ gtk2hs-buildtools ];
@@ -138099,7 +138551,7 @@ self: {
      mkDerivation {
        pname = "vtegtk3";
        version = "0.13.0.2";
-       sha256 = "0dkmp6s58nmc4qvhmxpn91b1zxf0ard33dkbh4426086k1zkcfzg";
+       sha256 = "ef3b367f9806012308816bb6315a56c0f51f5648f6f60a3726ac5a54b4b97536";
        libraryHaskellDepends = [ base glib gtk3 pango ];
        libraryPkgconfigDepends = [ vte ];
        libraryToolDepends = [ gtk2hs-buildtools ];
@@ -138120,8 +138572,8 @@ self: {
      }:
      mkDerivation {
        pname = "vty";
-       version = "5.2.10";
-       sha256 = "0wl4qfag8hkhsbm66cgxs55nq3fgmxdxzcvjvcbcm42pcyikvx9y";
+       version = "5.3.1";
+       sha256 = "3f9c18de862ee186772f0c91f18c70fc83acc9536c10f73e6714cdb092db8266";
        isLibrary = true;
        isExecutable = true;
        libraryHaskellDepends = [
@@ -138138,7 +138590,6 @@ self: {
          string-qq terminfo test-framework test-framework-hunit
          test-framework-smallcheck text unix utf8-string vector
        ];
-       jailbreak = true;
        homepage = "https://github.com/coreyoconnor/vty";
        description = "A simple terminal UI library";
        license = stdenv.lib.licenses.bsd3;
@@ -138152,7 +138603,7 @@ self: {
      mkDerivation {
        pname = "vty-examples";
        version = "5.2.0";
-       sha256 = "1iyygg5sy59f586d31zxdaz1jnpwrir6bfissarb0ag55dhl1j8x";
+       sha256 = "1dc940612be529b0b2d23aba6572ccfc5a19be6afd87d10c2a2e15afcb7bdec7";
        isLibrary = false;
        isExecutable = true;
        executableHaskellDepends = [
@@ -138172,7 +138623,7 @@ self: {
      mkDerivation {
        pname = "vty-menu";
        version = "0.0.3";
-       sha256 = "1ak6k43w381qg41mc5k5shbkwzg35kvh89yldimwk5a5sc08sqbi";
+       sha256 = "71618d00d34595c96b6cd42704f72ce37d3e17d4651656037938a0c1079966aa";
        isLibrary = true;
        isExecutable = true;
        libraryHaskellDepends = [ base vty ];
@@ -138190,7 +138641,7 @@ self: {
      mkDerivation {
        pname = "vty-ui";
        version = "1.9";
-       sha256 = "1mvs2224slnkswcag6knnj9ydkfgvw6nhaiy71bijjd2wwln4fq2";
+       sha256 = "023b6229e7a2491957383e2a680ddfcfcde693b4769aa718d7d3524d84107ad7";
        isLibrary = true;
        isExecutable = true;
        libraryHaskellDepends = [
@@ -138212,7 +138663,7 @@ self: {
      mkDerivation {
        pname = "vty-ui-extras";
        version = "0.1";
-       sha256 = "1c60bvhk1riilj7sl7x7nw4d9yg56f2k0ps1aivmjm0q4brhgnx7";
+       sha256 = "a7db07f3221854597754415f308533e5f9d408b7a71faa8fa431e630e15ec0b0";
        libraryHaskellDepends = [ base regex-base regex-pcre vty vty-ui ];
        jailbreak = true;
        description = "Extra vty-ui functionality not included in the core library";
@@ -138227,7 +138678,7 @@ self: {
      mkDerivation {
        pname = "waddle";
        version = "0.1.0.5";
-       sha256 = "0v4qhr01bqz7hb5q8hf2rdk8fxrbbmvsighi5wv2gv5b3cwh28cv";
+       sha256 = "9b2101391babec27362f11bea8775d2b778766cbc24184cb82e7e3154086986c";
        isLibrary = true;
        isExecutable = true;
        libraryHaskellDepends = [
@@ -138251,7 +138702,7 @@ self: {
      mkDerivation {
        pname = "wai";
        version = "3.0.3.0";
-       sha256 = "044djv5r10g92cg7wvz8zlxsyjhnr2mqb1gf3gr9a1rjlcsv8zn4";
+       sha256 = "c47eb435a3320795f21bee8585abc8164aaf3bfde86f7e1e13e98190cb968d10";
        libraryHaskellDepends = [
          base blaze-builder bytestring http-types network text vault
        ];
@@ -138273,7 +138724,7 @@ self: {
      mkDerivation {
        pname = "wai-app-file-cgi";
        version = "3.0.8";
-       sha256 = "0adj4s8hxr9rpmqf6899cjaw6axwzw5jvw325wv2qxv3yp4x3w5x";
+       sha256 = "bdf0d1c9f563772c362f62f02d0bffbc2bc395642921e370bd39e50e9126b229";
        libraryHaskellDepends = [
          array attoparsec attoparsec-conduit base blaze-builder blaze-html
          bytestring case-insensitive conduit conduit-extra containers
@@ -138302,7 +138753,7 @@ self: {
      mkDerivation {
        pname = "wai-app-static";
        version = "3.1.1";
-       sha256 = "0aiywk7a25fpk9fwm6fmibi4zvg5kynnjs6syfxyzfw4hl1dazjv";
+       sha256 = "5b7ed5028584bbefbbf3da6869ad9fe5ed4fe28ad599ca5d9ad715a1cee43e2a";
        isLibrary = true;
        isExecutable = true;
        libraryHaskellDepends = [
@@ -138332,7 +138783,7 @@ self: {
      mkDerivation {
        pname = "wai-conduit";
        version = "3.0.0.2";
-       sha256 = "1wqn8biq0ghz7ikmlq7x7vpdq2yc7mk9rnz9vlng7vcm7wpqilj7";
+       sha256 = "47d2882f3f95edf32cdde9db9c663dcc0bdcee3efd605a673c1f3e80e34216f3";
        libraryHaskellDepends = [
          base blaze-builder bytestring conduit http-types transformers wai
        ];
@@ -138350,7 +138801,7 @@ self: {
      mkDerivation {
        pname = "wai-cors";
        version = "0.2.3";
-       sha256 = "1mnybcf50d0ijbg2a40kf4sl55rb1m4p02nqqid4g7vcanmfjw92";
+       sha256 = "2271e9aa556c9f475ac4d80a70490d2b97423571131025de921134501c5bded6";
        libraryHaskellDepends = [
          attoparsec base base-unicode-symbols bytestring case-insensitive
          charset http-types mtl parsers transformers wai
@@ -138372,7 +138823,7 @@ self: {
      mkDerivation {
        pname = "wai-digestive-functors";
        version = "0.3";
-       sha256 = "04l9m43gm1zcgq32c70870kygy87p44zb4kvqcvi86zcspqdgpld";
+       sha256 = "8dded7f0d5ec1b1437c37b92f509b907f9e72738081c26067eec87fa06a98912";
        libraryHaskellDepends = [
          base digestive-functors http-types resourcet text transformers wai
          wai-extra wai-util
@@ -138387,7 +138838,7 @@ self: {
      mkDerivation {
        pname = "wai-dispatch";
        version = "0.1";
-       sha256 = "1qyarjbpnngb2x272gkmvrhy3f8kqygxj4nvi6giz09rdx9pfrza";
+       sha256 = "ea6777536f39811f9f89db12d99fc713b9e161de753e714417eb597b97cccae3";
        libraryHaskellDepends = [ base text wai yesod-routes ];
        homepage = "https://github.com/singpolyma/wai-dispatch";
        description = "Nice wrapper around yesod-routes for use with WAI";
@@ -138399,7 +138850,7 @@ self: {
      mkDerivation {
        pname = "wai-eventsource";
        version = "3.0.0";
-       sha256 = "1h5zlqky7ldqbmiaixizhk1s8ghf5i3ha1xfz8flxgzr7gr0al3q";
+       sha256 = "785005f23bf9bf4e1dfaae0705472c0e3ea4c3843ff6a8625db8d1e327a6bfc0";
        libraryHaskellDepends = [ wai ];
        homepage = "http://www.yesodweb.com/book/web-application-interface";
        description = "WAI support for server-sent events (deprecated)";
@@ -138418,7 +138869,7 @@ self: {
      mkDerivation {
        pname = "wai-extra";
        version = "3.0.10";
-       sha256 = "0dqvfwqzkr3g030s24lzy9l9vaws27m0cs0aq771p7f22w9g6fjh";
+       sha256 = "503af31217c29d1bcec10a6806ea119aab9d68f29f12a1c1006fe4f931771b37";
        libraryHaskellDepends = [
          ansi-terminal base base64-bytestring blaze-builder bytestring
          case-insensitive containers cookie data-default-class deepseq
@@ -138442,7 +138893,7 @@ self: {
      mkDerivation {
        pname = "wai-frontend-monadcgi";
        version = "3.0.0.1";
-       sha256 = "0g0lkkfcfi9vldl0g4r6qy8an1hsd4xnqw9z8d66mw696ydynvsj";
+       sha256 = "526feb9b37c9f06a4c433f716c3b691a06ab90c726930768a33b45c7dc9c143c";
        libraryHaskellDepends = [
          base bytestring case-insensitive cgi containers http-types
          transformers wai
@@ -138456,7 +138907,7 @@ self: {
      mkDerivation {
        pname = "wai-graceful";
        version = "0.1.0.1";
-       sha256 = "0a06yrakg9gwjjj4f9nr474j8i8xz642aj56m8vaq621i1kn7jaq";
+       sha256 = "58c96367884118ac36aaa6482588f91d4524c921d92647a494fca53755f60628";
        libraryHaskellDepends = [ base http-types mtl resourcet unix wai ];
        jailbreak = true;
        homepage = "https://bitbucket.org/dpwiz/wai-graceful";
@@ -138473,7 +138924,7 @@ self: {
      mkDerivation {
        pname = "wai-handler-devel";
        version = "2.0.0.2";
-       sha256 = "13f3w31kr3zinll76i6y3walpyqz3i1rlbsh3d7c5p8hp2d88bzy";
+       sha256 = "fe2f849ab810ddc24e1b502f9a431c1ffb4b151fde447328b5f18f3cc3e0c38d";
        isLibrary = true;
        isExecutable = true;
        libraryHaskellDepends = [
@@ -138493,7 +138944,7 @@ self: {
      mkDerivation {
        pname = "wai-handler-fastcgi";
        version = "3.0.0.1";
-       sha256 = "14lm9vbh213jxd1nkxcipisja90h3ay6mi6iiim65k7snm3b7w1v";
+       sha256 = "3bf0b346b5facc626a8cd1c46abc1a10242575bc91f56943eb720401d74e9592";
        libraryHaskellDepends = [ base bytestring wai wai-extra ];
        librarySystemDepends = [ fcgi ];
        homepage = "http://www.yesodweb.com/book/web-application-interface";
@@ -138508,7 +138959,7 @@ self: {
      mkDerivation {
        pname = "wai-handler-launch";
        version = "3.0.0.4";
-       sha256 = "1qfisa19rhlx241jr90mz8x844pp5yx1z8xbmflvj81gpnvsgh7i";
+       sha256 = "f1c0a7b7bd2f20b9a9ababa31fba2ff712823afa15a42c03119dc29c82d2d1e1";
        libraryHaskellDepends = [
          base blaze-builder bytestring http-types process streaming-commons
          transformers wai warp
@@ -138522,7 +138973,7 @@ self: {
      mkDerivation {
        pname = "wai-handler-scgi";
        version = "2.0.0.2";
-       sha256 = "0h7d78d641bjsnmxsnz4b7s9pw4x0y0xi8bld51y4nqnbjl8gvac";
+       sha256 = "4ced87a85c165be2436974a1d881079df09bf459e45bddabd57205621a3aed40";
        libraryHaskellDepends = [ base bytestring wai wai-extra ];
        jailbreak = true;
        homepage = "http://www.yesodweb.com/book/web-application-interface";
@@ -138537,7 +138988,7 @@ self: {
      mkDerivation {
        pname = "wai-handler-snap";
        version = "0.1.1";
-       sha256 = "0akk9h7m1hhdggbhj0grss94jzm13fmcmgj51nvh7mfj6f5kj31l";
+       sha256 = "340c398b33d2d503b70d45becaaa1ba17e4992d6f90109d77b0dc2500f4c732a";
        libraryHaskellDepends = [
          base bytestring containers enumerator snap-core snap-server
          transformers wai
@@ -138554,7 +139005,7 @@ self: {
      mkDerivation {
        pname = "wai-handler-webkit";
        version = "3.0.0.2";
-       sha256 = "0y7di5pnrri4dkqi8lx4gfksfpbqfwax1wjp1ijc5cw6p34mmzcs";
+       sha256 = "9afd5ac9b886b3c2640c57f2d01577785da7a77ba45314f16c24e66c6f89ed78";
        libraryHaskellDepends = [ base wai warp ];
        libraryPkgconfigDepends = [ QtWebKit ];
        homepage = "https://github.com/yesodweb/wai/tree/master/wai-handler-webkit";
@@ -138570,7 +139021,7 @@ self: {
      mkDerivation {
        pname = "wai-hastache";
        version = "0.1";
-       sha256 = "1kkn8n33cm5r7hw0xxf815nx1ixg09r7ckspq228j1syq5j1lzq8";
+       sha256 = "087f1a64c15e078984c0574f767202afc7d06d09c8f50e383cb95436864576ce";
        libraryHaskellDepends = [
          base bytestring hastache http-types transformers wai
        ];
@@ -138588,7 +139039,7 @@ self: {
      mkDerivation {
        pname = "wai-hmac-auth";
        version = "1.0.0";
-       sha256 = "1hjzwh9hzy29y617faa94428s7ja2ri0bggqxwmf27a0r4qpf1r4";
+       sha256 = "24077731c9401de12aeff8bd0562164a1e8d042149297782f149f80f13e45fc2";
        libraryHaskellDepends = [
          base base64-bytestring bifunctors byteable bytestring containers
          cryptohash http-types monad-loops mtl transformers wai
@@ -138611,7 +139062,7 @@ self: {
      mkDerivation {
        pname = "wai-lens";
        version = "0.1";
-       sha256 = "05vd7pjw6jgbb11yln4h2lbyr5pr471040p51pj7iy2m65s42v4x";
+       sha256 = "9d6c41743155f878e40de50202c221f996ec17159058ea4358eb49c3e53d6d17";
        libraryHaskellDepends = [
          base bytestring http-types lens network text vault wai
        ];
@@ -138627,7 +139078,7 @@ self: {
      mkDerivation {
        pname = "wai-lite";
        version = "0.2.0.0";
-       sha256 = "1ghxna51m304x5yvgfdgpml0yf6jqhfkixlxxnflg7z34h6wjzz4";
+       sha256 = "e47fc90d24e39f479ded9df6381dc4d2380f68bdafb9b77de9048c1a8ab21dbe";
        libraryHaskellDepends = [
          base bytestring conduit http-types text transformers wai wai-extra
        ];
@@ -138645,7 +139096,7 @@ self: {
      mkDerivation {
        pname = "wai-logger";
        version = "2.2.4.1";
-       sha256 = "1s6svvy3ci4j1dj1jaw8hg628miwj8f5gpy9n8d8hpsaxav6nzgk";
+       sha256 = "f37d6bb6ea4a5f881ab2c9df571c923c5624cc83882b19640b924436fcdedae8";
        libraryHaskellDepends = [
          auto-update base blaze-builder byteorder bytestring
          case-insensitive easy-file fast-logger http-types network unix
@@ -138663,7 +139114,7 @@ self: {
      mkDerivation {
        pname = "wai-logger-prefork";
        version = "0.3.0";
-       sha256 = "0cfslqr2zdj0x83dbscafhdljrn2xswym7hpf23zlrsrnpz71qy4";
+       sha256 = "c4e370feb55967fa8770179eeab9eec266491b748ae9d506ea40b62f32a6da31";
        libraryHaskellDepends = [
          base bytestring date-cache fast-logger http-types unix wai
          wai-logger
@@ -138681,7 +139132,7 @@ self: {
      mkDerivation {
        pname = "wai-middleware-cache";
        version = "0.3.6";
-       sha256 = "1kqrqjsmnwwavcyhwx6m2x3qk7qbd0h60817ai61dz3aprwc8hdw";
+       sha256 = "bc41c478be6afc164c5427206020680b9f894717d5740e3ddb8a735bb5c419cf";
        libraryHaskellDepends = [
          base binary blaze-builder-conduit bytestring conduit crypto-conduit
          http-types pureMD5 wai
@@ -138705,7 +139156,7 @@ self: {
      mkDerivation {
        pname = "wai-middleware-cache-redis";
        version = "0.4.3";
-       sha256 = "1vd81jcisav6jyqzwa0qn35xarm21bjrw0qps9qbbq56svkh1lw9";
+       sha256 = "89d300e7d6a6e0b570d217039ee50aa266d5cbb01828feb197662b1d990ca8ed";
        libraryHaskellDepends = [
          base binary blaze-builder-conduit bytestring case-insensitive
          conduit hedis hedis-pile http-types transformers wai
@@ -138723,7 +139174,7 @@ self: {
      mkDerivation {
        pname = "wai-middleware-catch";
        version = "0.3.6";
-       sha256 = "1vh5sad3zhdwxqbmivmy9hkbnq9vrv4k6k17rjk4f79lv2xcq56h";
+       sha256 = "d014ccbad8341d47a6cc274c33c9ce3b61bb264cbeee5817eebcc13f9ad205ee";
        libraryHaskellDepends = [
          base bytestring http-types lifted-base wai
        ];
@@ -138744,7 +139195,7 @@ self: {
      mkDerivation {
        pname = "wai-middleware-consul";
        version = "0.1.0.2";
-       sha256 = "0qq7kilp9a4qjja337saqccn250s6mnf3n80sgyg935hy1dmm7fq";
+       sha256 = "d89d5a5bf0b08cf4fcd300d9e16c351a146119c34a9f31949498a874699c0763";
        isLibrary = true;
        isExecutable = true;
        libraryHaskellDepends = [
@@ -138774,7 +139225,7 @@ self: {
      mkDerivation {
        pname = "wai-middleware-crowd";
        version = "0.1.1.2";
-       sha256 = "039vqcy16ww7cigzppl0lnmjwbvxdv0z0zq3rnklh334lyh5jfay";
+       sha256 = "5e3959a0a7640c48a7cd037ff0c16e7d2f2eaba580defb5f648773133cc33b0d";
        isLibrary = true;
        isExecutable = true;
        libraryHaskellDepends = [
@@ -138800,7 +139251,7 @@ self: {
      mkDerivation {
        pname = "wai-middleware-etag";
        version = "0.1.0.0";
-       sha256 = "0mcqnzvxx671awr2szyfpm6jskily9zxvmg61zz430km4i2q3wj8";
+       sha256 = "48f2814524758241fe0fe6d5dd7ff2344e2d4dbdce7f2d3257e198def7b79855";
        libraryHaskellDepends = [
          base base64-bytestring bytestring cryptohash filepath http-date
          http-types unix-compat unordered-containers wai
@@ -138819,7 +139270,7 @@ self: {
      mkDerivation {
        pname = "wai-middleware-gunzip";
        version = "0.0.2";
-       sha256 = "0rbvpw4y4qr2mhijlybzwwd12mkhrwmxlrhj2q0mq9diwhp597dx";
+       sha256 = "bd9d542ee4b1255c01161266da2bcf7056111ae77f792a23ac2263e209bf7b65";
        libraryHaskellDepends = [
          base bytestring http-types streaming-commons wai
        ];
@@ -138833,7 +139284,7 @@ self: {
      mkDerivation {
        pname = "wai-middleware-headers";
        version = "0.1";
-       sha256 = "10ap355j4dx42y7ycf1plpbg04wazv0q62mi3ibza8sb33hiiprh";
+       sha256 = "30df18e1184b23f5571cb10a83c1fe8a13f0d6a53738e68f17a437224b195781";
        libraryHaskellDepends = [ base bytestring http-types wai ];
        homepage = "http://github.com/seanhess/wai-middleware-headers";
        description = "cors and addHeaders for WAI";
@@ -138850,7 +139301,7 @@ self: {
      mkDerivation {
        pname = "wai-middleware-hmac";
        version = "0.1.0.0";
-       sha256 = "01xd1nhi96lflh6ssaz3m5dkacrp2b2kwk611jc8q5j3kmyc0zqs";
+       sha256 = "1a7fc07c9d43168c980cc14c3ec5123733355ba9e32bad0da48e9a14a10dad07";
        libraryHaskellDepends = [
          base base64-bytestring byteable bytestring case-insensitive
          cryptohash http-types transformers wai word8
@@ -138873,7 +139324,7 @@ self: {
      mkDerivation {
        pname = "wai-middleware-hmac-client";
        version = "0.1.0.2";
-       sha256 = "1jmfmcdv1js6rgadfhwb071qp418440ij0hm0fmyf03dk879qhds";
+       sha256 = "ba419c0e9a6d00e7ab03150219012128908bc3018b43d7d4cb46cbb01babaeca";
        isLibrary = true;
        isExecutable = true;
        libraryHaskellDepends = [
@@ -138897,7 +139348,7 @@ self: {
      mkDerivation {
        pname = "wai-middleware-metrics";
        version = "0.2.1";
-       sha256 = "0aiig72r72vykd1f1871458d4glnqsrs7rr402jv5ka05d1rg6y0";
+       sha256 = "c09b97432b40cdb2a50024e7a3b3c6963ed25021e1a0e0429b7e8b93c579312a";
        libraryHaskellDepends = [ base ekg-core http-types time wai ];
        testHaskellDepends = [
          base bytestring ekg-core http-types QuickCheck scotty tasty
@@ -138916,7 +139367,7 @@ self: {
      mkDerivation {
        pname = "wai-middleware-preprocessor";
        version = "0.2.0.0";
-       sha256 = "1n9z00v5a75pas22cdm26hj888s6kc98bddh2gfs3ffrazdmgbj1";
+       sha256 = "41ae57db57d9b9a1dd13b0b585129b4623842434a236268456b71c5536003fd9";
        libraryHaskellDepends = [
          base directory mtl split text wai wai-middleware-static
        ];
@@ -138937,7 +139388,7 @@ self: {
      mkDerivation {
        pname = "wai-middleware-prometheus";
        version = "0.1.0.1";
-       sha256 = "0drhprxja1pp0mibs2f4asl4mycy91pvyanxa0h364k9v6fwp93d";
+       sha256 = "6da4cb9dd96912332050dd2abf6f489ef94aa856c409bd6205f706257bbe3037";
        libraryHaskellDepends = [
          base bytestring data-default http-types prometheus-client text time
          wai
@@ -138956,7 +139407,7 @@ self: {
      mkDerivation {
        pname = "wai-middleware-route";
        version = "0.7.3";
-       sha256 = "0zgiaxc5rqjlkfwkb11a5zkmbybrfcqr74mq5vpj03mqz1q0lmx7";
+       sha256 = "a7570a70f8b80e20ef2eb89293317379f955e72f2a8435b99b54e25c5857f17d";
        libraryHaskellDepends = [
          base bytestring http-types text wai yesod-routes
        ];
@@ -138979,7 +139430,7 @@ self: {
      mkDerivation {
        pname = "wai-middleware-static";
        version = "0.7.0.1";
-       sha256 = "0kvs3bv5yyg1j7zghl91gi12g7k20vwbbk0ag9clmq3zn33i46iw";
+       sha256 = "3c1a12c7b07fe04a597a0accb5f806629e27427c2151f8fe91e1795ff61a7a4f";
        libraryHaskellDepends = [
          base base16-bytestring bytestring containers cryptohash directory
          expiring-cache-map filepath http-types mtl old-locale text time wai
@@ -138997,7 +139448,7 @@ self: {
      mkDerivation {
        pname = "wai-middleware-static-caching";
        version = "0.6.0.1";
-       sha256 = "0xj4r1fr1g0fybgsq65gxcvh5zn9hafvm0f73p6dnj6jhz6dryhk";
+       sha256 = "13fadccc87d248dbcc1dc781ba9d82c9fe0237ebaf18acdff20ebc905dc84476";
        libraryHaskellDepends = [
          base base16-bytestring bytestring containers cryptohash directory
          expiring-cache-map filepath http-types mtl old-locale text time
@@ -139018,7 +139469,7 @@ self: {
      mkDerivation {
        pname = "wai-middleware-throttle";
        version = "0.2.0.1";
-       sha256 = "08qxdcbn1lg9rd2rcp10iri1maamn5cily9mbg1r65h8ivdmrdan";
+       sha256 = "56b55cdb8e081693c35b35791a59b155a91a628e205c9645cbe9d160176b1d23";
        libraryHaskellDepends = [
          base containers http-types network stm token-bucket transformers
          wai
@@ -139040,7 +139491,7 @@ self: {
      mkDerivation {
        pname = "wai-predicates";
        version = "0.8.4";
-       sha256 = "06ib359k8amh15qmmv6rdmicak1rrx758xfrf75nni03z9k9rby5";
+       sha256 = "c5af9c66fa03446bcb71d975544ecf394cc5626dd9ec5a7109b02a3453192b1a";
        libraryHaskellDepends = [
          attoparsec base bytestring bytestring-conversion case-insensitive
          cookie http-types singletons transformers vault vector wai
@@ -139062,7 +139513,7 @@ self: {
      mkDerivation {
        pname = "wai-request-spec";
        version = "0.10.0.1";
-       sha256 = "13s86z82rcsy3ai4qzjbxinwxzd81zhsvf589mhn2fhfk8qm7wdg";
+       sha256 = "aff153319a0e3a61614da8b8ade10fa8fdce6dec4b7e4ca21a5eb32cd037488f";
        libraryHaskellDepends = [
          base bytestring case-insensitive containers http-types text wai
        ];
@@ -139076,7 +139527,7 @@ self: {
      mkDerivation {
        pname = "wai-responsible";
        version = "0.0.0.0";
-       sha256 = "0qf64g11113gl45bfn12j2ikdjwrdxg9r8cicfs4pmh0dq5vj0va";
+       sha256 = "6a03b90b6e00d64bb46391a19c5e6f99cb36a3902258b70aa16f8410c223c661";
        libraryHaskellDepends = [ base bytestring http-types wai ];
        jailbreak = true;
        homepage = "https://github.com/pharpend/wai-responsible";
@@ -139091,7 +139542,7 @@ self: {
      mkDerivation {
        pname = "wai-route";
        version = "0.3";
-       sha256 = "1gmadxdki64x2r7931vsgzzb1hkk03a1virkjmnfm3i7kz5dp4kp";
+       sha256 = "7792dbca9f278eea6c9533c71dd40073c2b0fe7f7a87914e169d98385b6faabe";
        libraryHaskellDepends = [
          base bytestring http-types unordered-containers wai
        ];
@@ -139108,7 +139559,7 @@ self: {
      mkDerivation {
        pname = "wai-router";
        version = "1.0.0.1";
-       sha256 = "1827mk64vyivdc12z4h230c4b993i6g8wl4sl0364jda586z58p7";
+       sha256 = "e7a2f20d2aaa496206a09a508e9e8923a545181802922f026b3bfa4dccac47a0";
        libraryHaskellDepends = [ base text wai ];
        jailbreak = true;
        homepage = "http://github.com/mdmarek/wai-router";
@@ -139123,8 +139574,8 @@ self: {
      }:
      mkDerivation {
        pname = "wai-routes";
-       version = "0.7.2";
-       sha256 = "05f8524q9rb5y4d8fryhv4jjkcgqygbckg4pkklvs86s5zlg9nsa";
+       version = "0.7.3";
+       sha256 = "92d694a9b63b8f34e1e62f5f29b65cb85566eeb9cad90b7dd34689bc296b139b";
        libraryHaskellDepends = [
          aeson base blaze-builder bytestring containers http-types
          monad-loops mtl path-pieces random template-haskell text wai
@@ -139143,7 +139594,7 @@ self: {
      mkDerivation {
        pname = "wai-routing";
        version = "0.12.1";
-       sha256 = "01bs5mmycn7dkvnp01mh226iy1b419amab83fmgk0asd2f3jsfn5";
+       sha256 = "c53a2d87134d2b305f75032d55550a64051f8d10b00670ed9eed58e66b2d7a05";
        libraryHaskellDepends = [
          attoparsec base bytestring bytestring-conversion case-insensitive
          cookie http-types transformers wai wai-predicates wai-route
@@ -139166,7 +139617,7 @@ self: {
      mkDerivation {
        pname = "wai-session";
        version = "0.3.2";
-       sha256 = "09l3gj8l127iybr8h4xcjxxcgz5b1mcy5iyyaidixnzi7jlrqww3";
+       sha256 = "83739ca93cf1db1e5b54dec7e2590dabfcc77a97ac1388f2f2f18840917c8326";
        libraryHaskellDepends = [
          base blaze-builder bytestring containers cookie http-types StateVar
          time transformers vault wai
@@ -139183,7 +139634,7 @@ self: {
      mkDerivation {
        pname = "wai-session-clientsession";
        version = "0.1";
-       sha256 = "0kczhsmkv88g0x8mk4cfy5z9wv3fzv8v3r4z0q7jkyda0grx3gwf";
+       sha256 = "8ebfd1f303aaf9290f069fe4b1d1fe6e6c9e7ef18e915951070fa13dab869f4d";
        libraryHaskellDepends = [
          base bytestring cereal clientsession errors transformers
          wai-session
@@ -139200,7 +139651,7 @@ self: {
      mkDerivation {
        pname = "wai-session-tokyocabinet";
        version = "0.1";
-       sha256 = "0cd4x3byc8kaarjpfczqaiv5y3ixrdcilnnypkhcavk3vj7w7pmr";
+       sha256 = "b9dec38fdc636ec5e0bcde5a1a59cb3d0e5f7654f8337765566a22e6d7e8a431";
        libraryHaskellDepends = [
          base bytestring cereal errors tokyocabinet-haskell transformers
          wai-session
@@ -139220,7 +139671,7 @@ self: {
      mkDerivation {
        pname = "wai-static-cache";
        version = "0.1.0.1";
-       sha256 = "0vlkh9izxx1qsb61fak57kk9k35i3vph8qbyvlmgwcw7nplagq6l";
+       sha256 = "d4e0a7e8b58733fe2add7e6104ef1eb18c99e63c652a17ccd238f4fe6382936e";
        libraryHaskellDepends = [
          base bytestring cityhash conduit conduit-combinators containers
          http-types resourcet system-filepath text transformers vector
@@ -139238,7 +139689,7 @@ self: {
      mkDerivation {
        pname = "wai-static-pages";
        version = "0.3";
-       sha256 = "0xam283gvcjryq541dzrymv9qy7asyfz8k44b6dwrvm5bqphjz9h";
+       sha256 = "307d092f5ea5eecc9b59844cf49dd7ea789c76f5f9b7400af659b2fd06125575";
        libraryHaskellDepends = [
          base blaze-builder bytestring conduit directory http-types text wai
          wai-extra
@@ -139253,7 +139704,7 @@ self: {
      mkDerivation {
        pname = "wai-test";
        version = "3.0.0";
-       sha256 = "0xys01jniib0pnhadcm7s0v5z0wcxfgi0bf5ax808zm9qzvl3xfx";
+       sha256 = "ddf541f7c7a97e045057c52d109feb8c835f36d0a7b2a6a0bd60c5686500da77";
        libraryHaskellDepends = [ wai ];
        homepage = "http://www.yesodweb.com/book/web-application-interface";
        description = "Unit test framework (built on HUnit) for WAI applications. (deprecated)";
@@ -139267,7 +139718,7 @@ self: {
      mkDerivation {
        pname = "wai-throttler";
        version = "0.1.0.5";
-       sha256 = "1jh53ac1q4zksxdrmwjgsyidvx8zlhx57nnf3ca4spa3paz9n9g6";
+       sha256 = "e6259bbeba435d4d141bceda533aa41ff5dda2d74ff29a5bd7f3131c981a05ca";
        libraryHaskellDepends = [
          base bytestring containers http-types time wai
        ];
@@ -139285,7 +139736,7 @@ self: {
      mkDerivation {
        pname = "wai-util";
        version = "0.8";
-       sha256 = "10rkrhs7xv6qmx31ll891c2nnaqpblyfxqmn8xwjhafp7ks1wqjm";
+       sha256 = "55621ef43cd729287947b6e2ee3c5d172b6b050b09511a46afd8ec7e34cc3383";
        libraryHaskellDepends = [
          aeson base blaze-builder bytestring conduit http-accept http-types
          network-uri text transformers wai wai-extra
@@ -139303,7 +139754,7 @@ self: {
      mkDerivation {
        pname = "wai-websockets";
        version = "3.0.0.6";
-       sha256 = "0i8r5r8l3z6fk7a466n48ralq33kdihc8g91ia4z22cqhl0zkizy";
+       sha256 = "fec7f901859809f1898a213dc4606c730c4c5546c41a43d499cefc41512e1945";
        isLibrary = true;
        isExecutable = true;
        libraryHaskellDepends = [
@@ -139325,7 +139776,7 @@ self: {
      mkDerivation {
        pname = "wait-handle";
        version = "0.1.1";
-       sha256 = "09080zx6m4lqli85867ilck82gvgnz4vkq9nxx5f1v5fli1i0n7m";
+       sha256 = "f5581043a4aeece04aef36e1b9c9b76f3f8126a3f1185450a498926afa070824";
        libraryHaskellDepends = [ base ];
        homepage = "https://www.github.com/fmap/waithandle";
        description = "Wait handles are MVars which can only be written to once, and from which values can never be removed";
@@ -139337,7 +139788,7 @@ self: {
      mkDerivation {
        pname = "waitfree";
        version = "0.1.5";
-       sha256 = "09hlqli7zpcxfa8w7vh937gc3rxp7s8q8v1zs8ciwnmh6ca4i8rq";
+       sha256 = "38a3481433b05a1e19d23f6c84913eb7e7c1de1909eec391729ddd7f22c51426";
        libraryHaskellDepends = [ base containers ];
        description = "A wrapping library for waitfree computation";
        license = stdenv.lib.licenses.mit;
@@ -139351,7 +139802,7 @@ self: {
      mkDerivation {
        pname = "waitra";
        version = "0.0.3.0";
-       sha256 = "0yismhhgwzrssla2bcg44jy0fdwwxh2szypyjn8wfjvmkfhzshvn";
+       sha256 = "7643fda19b754bc79195fefaaf05ec9c3707bc24e4b12514d53a7ffe20ac3a7a";
        libraryHaskellDepends = [
          aeson base bytestring directory filepath http-types
          regex-applicative template-haskell text wai
@@ -139366,6 +139817,24 @@ self: {
        hydraPlatforms = stdenv.lib.platforms.none;
      }) {};
 
+  "warc" = callPackage
+    ({ mkDerivation, attoparsec, base, bytestring, either, errors, free
+     , lens, pipes, pipes-attoparsec, pipes-bytestring, text, time
+     , transformers
+     }:
+     mkDerivation {
+       pname = "warc";
+       version = "0.1.1.1";
+       sha256 = "9530f595264316d474abb194754d69c4857b8ccc65e49280e430fd596eb65260";
+       libraryHaskellDepends = [
+         attoparsec base bytestring either errors free lens pipes
+         pipes-attoparsec pipes-bytestring text time transformers
+       ];
+       homepage = "http://github.com/bgamari/warc";
+       description = "A parser for the Web Archive (WARC) format";
+       license = stdenv.lib.licenses.bsd3;
+     }) {};
+
   "warp" = callPackage
     ({ mkDerivation, array, async, auto-update, base, blaze-builder
      , bytestring, case-insensitive, containers, directory, doctest
@@ -139377,7 +139846,7 @@ self: {
      mkDerivation {
        pname = "warp";
        version = "3.1.2";
-       sha256 = "1ya8mfvb18p9d5bj0ijnlbd7m04mj7f1z9ld82a8vry37sdifidq";
+       sha256 = "b845179b3ec3e78d94408da61fdc9195807adaa25646205769e9a2b0b6ab48f9";
        libraryHaskellDepends = [
          array auto-update base blaze-builder bytestring case-insensitive
          containers ghc-prim hashable http-date http-types http2 iproute
@@ -139402,7 +139871,7 @@ self: {
      mkDerivation {
        pname = "warp-dynamic";
        version = "0.1.0";
-       sha256 = "1kmmy2av0ikr6mb8g7ffqmf505ha4201qv7y48fyc9p8j0p6lk6g";
+       sha256 = "cf4c6a2e90e826e61d22fe6c1c80200a16505cc5ce9d8756357946b095f0b5ce";
        isLibrary = true;
        isExecutable = true;
        libraryHaskellDepends = [
@@ -139423,7 +139892,7 @@ self: {
      mkDerivation {
        pname = "warp-static";
        version = "2.0.1.1";
-       sha256 = "181z8cr55qngy6jyqzqz5wcgiyip4rn3q1am0hkcxvmdnif2w2km";
+       sha256 = "750a2e5cb4adeece260455053c6c2637faf8182f1f7feca5f1cfe25232433fa0";
        isLibrary = false;
        isExecutable = true;
        executableHaskellDepends = [
@@ -139444,7 +139913,7 @@ self: {
      mkDerivation {
        pname = "warp-tls";
        version = "3.1.0";
-       sha256 = "1790hl3a327fv01w2shdslylmhp5zv0bh7ljhymipr5vpjwjknrz";
+       sha256 = "3fdb29b9bcbbe41bab87921eb8c0fee5c24a3dd50d6ac103d8ee88a10685209d";
        libraryHaskellDepends = [
          base bytestring cprng-aes data-default-class network
          streaming-commons tls wai warp
@@ -139462,7 +139931,7 @@ self: {
      mkDerivation {
        pname = "warp-tls-uid";
        version = "0.1.0.4";
-       sha256 = "11av9jkf8z2xcpwg3nyx018qwpdrm0cs79qj14z93ah1yxbavb5y";
+       sha256 = "beacad56f701aa913e0912a7a319a8b95d8e5100dddbf1f8655d7ce4a64c5b85";
        isLibrary = true;
        isExecutable = true;
        libraryHaskellDepends = [
@@ -139484,7 +139953,7 @@ self: {
      mkDerivation {
        pname = "watchdog";
        version = "0.2.2.1";
-       sha256 = "06b93cqn6rbl6jbjyawzqmrx80h0dbcks7ia6l3wzdqpic8yjj6v";
+       sha256 = "db48e9118b17b7cf07352a1e3dd96a0002d473c59f2b2f9734746563311b6919";
        libraryHaskellDepends = [ base mtl time ];
        jailbreak = true;
        description = "Simple control structure to re-try an action with exponential backoff";
@@ -139499,7 +139968,7 @@ self: {
      mkDerivation {
        pname = "watcher";
        version = "0.0.3.0";
-       sha256 = "1c6025zpghqvw5xlapnfk8nwf32iq6dkpnpzi65pm5l5f5npwwgs";
+       sha256 = "fa717e6d7185967a8b89ffda3b9bc1510cc72d9ace5e457be11bc3777f11c0b0";
        libraryHaskellDepends = [
          base basic-prelude containers hinotify system-fileio
          system-filepath
@@ -139519,7 +139988,7 @@ self: {
      mkDerivation {
        pname = "watchit";
        version = "0.1.0.0";
-       sha256 = "134b9nrl2lmcr80hxmf72la220plh48vdl0r2la3c3k6qimsd276";
+       sha256 = "e688a66bc4660e36141519d0b61181f402211415c7d50e01caac5241b34d8b8c";
        isLibrary = true;
        isExecutable = true;
        libraryHaskellDepends = [
@@ -139544,7 +140013,7 @@ self: {
      mkDerivation {
        pname = "wavconvert";
        version = "0.1.1";
-       sha256 = "028qx9b4z2gr4nc6hid0phdrysvhfqswj64s71pw2grqw4f8ddkx";
+       sha256 = "7db6861ce1383fc16f389a18c93576706b9f1bbca045689825f9894f56ea1809";
        isLibrary = false;
        isExecutable = true;
        executableHaskellDepends = [ base directory filepath process ];
@@ -139559,7 +140028,7 @@ self: {
      mkDerivation {
        pname = "wavesurfer";
        version = "0.0.6";
-       sha256 = "1f9hsmvwdgrib44sj1rnkm4hv92iad27xg75n2y2qdq1a8giazn5";
+       sha256 = "c57e151f5201372cbcb0e5bc7e445351a40d499d3607a9095931bfc677d530b9";
        libraryHaskellDepends = [
          base binary bytestring bytestring-lexing bytestring-show
          delimited-text
@@ -139578,7 +140047,7 @@ self: {
      mkDerivation {
        pname = "wavy";
        version = "0.1.0.0";
-       sha256 = "0rvzsmd7lzimyphc2yscadwkanqpi8wnmdk5hrzwpcm6dcavyj9q";
+       sha256 = "3849bf156ba6b2cb7f8665b66a398a175b3579534c7bc1e0f5357e7a5ad57f67";
        isLibrary = true;
        isExecutable = true;
        libraryHaskellDepends = [
@@ -139600,7 +140069,7 @@ self: {
      mkDerivation {
        pname = "wcwidth";
        version = "0.0.2";
-       sha256 = "1n1fq7v64b59ajf5g50iqj9sa34wm7s2j3viay0kxpmvlcv8gipz";
+       sha256 = "ffc68736a3bbde3e8157710f29f4a99c0ca593c41194579c54a92c62f6c12ed8";
        isLibrary = true;
        isExecutable = true;
        libraryHaskellDepends = [ base containers ];
@@ -139619,7 +140088,7 @@ self: {
      mkDerivation {
        pname = "weather-api";
        version = "0.4.3";
-       sha256 = "0wlh3p5z2vivhn9pgqzjhczrb7jyfzkz889fmwnvm7h87440jnyj";
+       sha256 = "d25b090839089eba2daf2e21f4e7775e9e953f83f2e37793853b6ef1cb1d9072";
        libraryHaskellDepends = [
          aeson attoparsec base bytestring HTTP network utf8-string vector
        ];
@@ -139635,7 +140104,7 @@ self: {
      mkDerivation {
        pname = "web-browser-in-haskell";
        version = "1.0";
-       sha256 = "1y674dw8slz0m7i23j7p1qykdci2wssmx6x0yf23cf0nywz1py5k";
+       sha256 = "b3f81b3ef716383684f3a09b5eb5e622b2363d0ef7c821e2a9e0538d7823c7f8";
        libraryHaskellDepends = [ base gtk webkit ];
        description = "Web Browser In Haskell";
        license = "GPL";
@@ -139647,7 +140116,7 @@ self: {
      mkDerivation {
        pname = "web-css";
        version = "0.1.0";
-       sha256 = "1havyvd6f0xagynxpar2jsmx5x1izwl7wgxia0wbwbzaj0fzn2k2";
+       sha256 = "620afb1d90ea2fbe3850b13f7e28ff31f4d2ab9622abdbad7faa0367daf65bc1";
        libraryHaskellDepends = [ base text ];
        jailbreak = true;
        description = "Simple functions for CSS";
@@ -139661,7 +140130,7 @@ self: {
      mkDerivation {
        pname = "web-encodings";
        version = "0.3.0.9";
-       sha256 = "0lg9vbsmg9nfs2440ab2srhhawg1xfi5lnhxzd9rj7kab460w2x3";
+       sha256 = "a30b0e0c596a1e9953fb1d5a5aa2ebe1710561d662294088d0cea657f5dae951";
        isLibrary = true;
        isExecutable = true;
        libraryHaskellDepends = [
@@ -139681,7 +140150,7 @@ self: {
      mkDerivation {
        pname = "web-fpco";
        version = "0.1.1.0";
-       sha256 = "1iizmg1syjywd5hs9swcqxxzmix04hwa86p8c246xybwcklf667n";
+       sha256 = "f618e3e8647cf96e8860e81aa43824a0c7fa7bc78ceba46169dc4bafc3ab3fc6";
        libraryHaskellDepends = [
          base happstack-server safe snap snap-core snap-server
        ];
@@ -139698,7 +140167,7 @@ self: {
      mkDerivation {
        pname = "web-mongrel2";
        version = "0.0.3";
-       sha256 = "1j2pq3kzmk2gibrr4jcm5gksz9pk9shjqqpwc85ygb2mpf5yc1gw";
+       sha256 = "fc05e68bbb55ace70b62fc622ca14ef3a6afe72b954992f38a4fccfae7c057c8";
        libraryHaskellDepends = [
          base bytestring data-default file-embed haskell98 HStringTemplate
          json mtl old-time parsec system-uuid template-haskell text
@@ -139718,7 +140187,7 @@ self: {
      mkDerivation {
        pname = "web-page";
        version = "0.2.0";
-       sha256 = "1hzqwp67pj1xvhmdaxmij08820ffxf559d7jgr8037zzm7j02cql";
+       sha256 = "143301e4a9ff9f01507ef2b4548aebce01811090b176d52adc3dc87bcce5f8c3";
        isLibrary = true;
        isExecutable = true;
        libraryHaskellDepends = [
@@ -139735,7 +140204,7 @@ self: {
      mkDerivation {
        pname = "web-plugins";
        version = "0.2.8";
-       sha256 = "00w0v0q2i0jxwlav1qb967nf35bxbr6vwacs5mqficzg2d4pz969";
+       sha256 = "c9a47f4913efb3e8702d9a29be4d5e7d95e1ec3169e1b015e55d822830d88003";
        libraryHaskellDepends = [ base containers mtl stm text ];
        homepage = "http://www.happstack.com/";
        description = "dynamic plugin system for web applications";
@@ -139751,7 +140220,7 @@ self: {
      mkDerivation {
        pname = "web-routes";
        version = "0.27.9";
-       sha256 = "1azccgcnksz4c4pm1nayvjiq3m192zz21cnc0fm89hdixvqck346";
+       sha256 = "868cc9f0eeb1c184aa03ccb220fe1729d481a3dc5ed9502f61e4eb69d963ecab";
        revision = "2";
        editedCabalFile = "542f5d20616359b0897018bbd347ce7f0dc948c4e031e8a5383ed85cb931406b";
        libraryHaskellDepends = [
@@ -139771,7 +140240,7 @@ self: {
      mkDerivation {
        pname = "web-routes-boomerang";
        version = "0.28.4";
-       sha256 = "0ailw4s0c1f054q58dwylq1g1f043vw4ywk0spg5d3sk9asy8bxh";
+       sha256 = "b02fe4b54a538f56ded560724ff81e04b8f002a69e37543029c0050634e1342a";
        libraryHaskellDepends = [
          base boomerang mtl parsec text web-routes
        ];
@@ -139786,7 +140255,7 @@ self: {
      mkDerivation {
        pname = "web-routes-happstack";
        version = "0.23.9";
-       sha256 = "0vsjm979z21858wk9z1b855jqmr4apm35b5ff8x6nynq6kiflrzw";
+       sha256 = "fc67eae234d87a6b3a72aeac32ea5524572c4b412bfc34392a28889f4eaa526f";
        libraryHaskellDepends = [
          base bytestring happstack-server text web-routes
        ];
@@ -139799,7 +140268,7 @@ self: {
      mkDerivation {
        pname = "web-routes-hsp";
        version = "0.24.6";
-       sha256 = "048dxx5cjdm7v0340p9x3s73a6y7fldykzkwkpb12bb926bir3fl";
+       sha256 = "d48d1c9711692d11d69d7cfee91b75c71b358e1e3d5d4006d8a736c94aef0d11";
        libraryHaskellDepends = [ base hsp text web-routes ];
        description = "Adds XMLGenerator instance for RouteT monad";
        license = stdenv.lib.licenses.bsd3;
@@ -139810,7 +140279,7 @@ self: {
      mkDerivation {
        pname = "web-routes-mtl";
        version = "0.20.1";
-       sha256 = "1k35ch294p2pkf7mbip8wy9rin956y31sq68b4cdrj9sj9891rx5";
+       sha256 = "a5e79050923ac9dc1859c8601d863725d99893e7e8c6558f9b575c92046465cc";
        libraryHaskellDepends = [ base web-routes ];
        description = "Extends web-routes with mtl-based MonadIO / MonadTrans RouteT instances";
        license = stdenv.lib.licenses.bsd3;
@@ -139821,7 +140290,7 @@ self: {
      mkDerivation {
        pname = "web-routes-quasi";
        version = "0.7.1.1";
-       sha256 = "1rqbymi0n7kdhl272qfjhx9s3gspd5k0bjrhclj9l8mjf033vdmf";
+       sha256 = "aeb63d0670b2229a246530cb05666957bfa15387d2617104856d1e0b62f50be7";
        isLibrary = true;
        isExecutable = true;
        libraryHaskellDepends = [ base path-pieces template-haskell text ];
@@ -139837,7 +140306,7 @@ self: {
      mkDerivation {
        pname = "web-routes-regular";
        version = "0.19.0";
-       sha256 = "0qllws4mzmmc6fh4hcvj3zp7kk8pwap59yq6wy0zx7mx0ac7015r";
+       sha256 = "b904709802bd9efe81e706fb54aee217cd79ee1f723348a033acd65f89e69462";
        libraryHaskellDepends = [ base parsec regular text web-routes ];
        description = "Library for maintaining correctness of URLs within an application";
        license = stdenv.lib.licenses.bsd3;
@@ -139851,7 +140320,7 @@ self: {
      mkDerivation {
        pname = "web-routes-th";
        version = "0.22.3";
-       sha256 = "0ccv1mzisd0fnhbl776i0fhavjazm0l3b4ycnbdzgs1kh4w8gzfp";
+       sha256 = "d7fd87388133e8f7dbb2cc933528a85fc9ada003d19c4317b40e341d7f0d9b31";
        libraryHaskellDepends = [
          base parsec split template-haskell text web-routes
        ];
@@ -139868,7 +140337,7 @@ self: {
      mkDerivation {
        pname = "web-routes-transformers";
        version = "0.19.1";
-       sha256 = "0pm1v9wqlzi6cg92lajbwbnhsdm509371i8mvyvvj6qa5m58cdib";
+       sha256 = "2b36864a2d0a1bb9b7df15c5704602a5360dede24b2a2ad263267e8a79daa15e";
        libraryHaskellDepends = [ base transformers web-routes ];
        jailbreak = true;
        description = "Extends web-routes with some transformers instances for RouteT";
@@ -139883,7 +140352,7 @@ self: {
      mkDerivation {
        pname = "web-routes-wai";
        version = "0.24.1";
-       sha256 = "13mwfyafpk29c8bbx48vhbxsgk28fmh579gjn6gjlhvkisc45q1b";
+       sha256 = "2be042988e73432a9fb1f2a553607548cca7fb821b91be166249cceb9477bc8e";
        libraryHaskellDepends = [
          base bytestring http-types text wai web-routes
        ];
@@ -139898,7 +140367,7 @@ self: {
      mkDerivation {
        pname = "web-routing";
        version = "0.6.2";
-       sha256 = "1x7imgnpq3998fk4pi2z5ba0r9xc7blf61rn1i51yqqd24la887f";
+       sha256 = "ee20a428110d631f4a0c3607e3e83aaca70cd42a5fc44ba643290d7cedabf1f4";
        revision = "1";
        editedCabalFile = "4aa263239149f8ef52999fdc29c8e90c552081672a4476adedce903248e15524";
        libraryHaskellDepends = [
@@ -139920,7 +140389,7 @@ self: {
      mkDerivation {
        pname = "webcrank";
        version = "0.2.2";
-       sha256 = "1rgvpp2526lmly2fli65mygplfc6wzqcw5fkn7gq4fcrmql2cisj";
+       sha256 = "52472628ae993982dfb1d315cef0e786397a9fafc544ea84a7951a51c4bdfbe5";
        revision = "1";
        editedCabalFile = "487831902c68484790108f97e32098dad9711eb15e0729b9ab1ba009e8fd5747";
        libraryHaskellDepends = [
@@ -139945,7 +140414,7 @@ self: {
      mkDerivation {
        pname = "webcrank-dispatch";
        version = "0.1";
-       sha256 = "1w4kfcm2d6iw4d45ywg2g6iysxl2iywk3nbk5ac6p6500y6hh97k";
+       sha256 = "f324088d07a0986b982a73d931b98f8276eda379e2715f48233c9a262a7393f0";
        revision = "1";
        editedCabalFile = "50b6b56e1fccc20a2986ea93b04410b8131ea5f2f4df94df538c6b2369400fa8";
        libraryHaskellDepends = [
@@ -139966,7 +140435,7 @@ self: {
      mkDerivation {
        pname = "webcrank-wai";
        version = "0.2.1";
-       sha256 = "13db2hpyvzpx9i43d8pryq7f87zlajpfpf0h6biva28l9qamy1yv";
+       sha256 = "db075f154e1409b5e33210b8ebae54f41fe40ef6f9a236484cfdfeed2f14ab8d";
        libraryHaskellDepends = [
          base bytestring exceptions lens mtl unix-compat
          unordered-containers wai wai-lens webcrank webcrank-dispatch
@@ -139987,8 +140456,8 @@ self: {
      }:
      mkDerivation {
        pname = "webdriver";
-       version = "0.6.2";
-       sha256 = "1cr668vn51bsdwxk6az4dk8zcsgy1y5vhb7xb9mahhbv1anpnzgr";
+       version = "0.6.2.1";
+       sha256 = "d0f0a31a799da18043163d5d699f778f4d4939e31a0214293db7fa8851759a5e";
        libraryHaskellDepends = [
          aeson attoparsec base base64-bytestring bytestring cond
          data-default directory directory-tree exceptions filepath
@@ -139997,7 +140466,6 @@ self: {
          transformers-base unordered-containers vector zip-archive
        ];
        testHaskellDepends = [ base parallel text ];
-       jailbreak = true;
        homepage = "https://github.com/kallisti-dev/hs-webdriver";
        description = "a Haskell client for the Selenium WebDriver protocol";
        license = stdenv.lib.licenses.bsd3;
@@ -140011,7 +140479,7 @@ self: {
      mkDerivation {
        pname = "webdriver-angular";
        version = "0.1.7";
-       sha256 = "18lyw9qasg9ynsa9yg90121h6z5h7kl6lzw7q5zqgkwpm1xr1p21";
+       sha256 = "41dc907ba897cf877fc1877f6ae83cb07c038308203d9f94b63e3dad70e29ea2";
        libraryHaskellDepends = [
          aeson base language-javascript template-haskell text transformers
          unordered-containers webdriver
@@ -140036,7 +140504,7 @@ self: {
      mkDerivation {
        pname = "webdriver-snoy";
        version = "0.6.0.4";
-       sha256 = "02c2ihqk5gsgnv61rj14rdd76r2nhmxacml3z9krrgxgn326hrbk";
+       sha256 = "736568c4b0afbf9c67fa8356a67a855664735acb24c81cccb64fbf32318c8209";
        revision = "1";
        editedCabalFile = "7cc952e84c8ff09b8d032df7d8089bd4d5167b32834bda67c79c62a34b12d52a";
        libraryHaskellDepends = [
@@ -140061,7 +140529,7 @@ self: {
      mkDerivation {
        pname = "webidl";
        version = "0.1.1";
-       sha256 = "05l4y7y171g41dlzfgd25ww59r4ajqbj9jpzrsmq5zpazx6p6gzy";
+       sha256 = "fe3f734dffeafe82abceffca2417968ae454382fa23df7690be48513fcf18416";
        isLibrary = true;
        isExecutable = true;
        libraryHaskellDepends = [
@@ -140084,7 +140552,7 @@ self: {
      mkDerivation {
        pname = "webify";
        version = "0.1.7.0";
-       sha256 = "16fsk6x875bmnqng5mfkxcxrkp3dcs3lkmsnds5fm416x4iw1sql";
+       sha256 = "14ebc023e92690ea8a6e56d74987666ddc993bebd3d5f22cb6759583ba99da99";
        isLibrary = false;
        isExecutable = true;
        executableHaskellDepends = [
@@ -140105,7 +140573,7 @@ self: {
      mkDerivation {
        pname = "webkit";
        version = "0.14.1.0";
-       sha256 = "1mmlsdnq9pws3jhk0gzqdhy8b7zwm80g2cmygahqagvyh7jvb7r4";
+       sha256 = "249fb5e5817e3f85a17abe32f100aafc9f853c6cf83f30a11c9adf846dd3b4d6";
        libraryHaskellDepends = [
          base bytestring cairo glib gtk mtl pango text transformers
        ];
@@ -140120,11 +140588,10 @@ self: {
     ({ mkDerivation, base, glib, gtk, gtk2hs-buildtools, webkit }:
      mkDerivation {
        pname = "webkit-javascriptcore";
-       version = "0.13.0.4";
-       sha256 = "1gj40kdll7pd84graxcrc327za6kgp453zh48srmzvrk9yvnj67x";
+       version = "0.13.1.0";
+       sha256 = "b0a7c41c9c22cb1aa4697e6d30ace424bc73b15416cf98790e148c9bec10bed7";
        libraryHaskellDepends = [ base glib gtk webkit ];
        libraryToolDepends = [ gtk2hs-buildtools ];
-       jailbreak = true;
        description = "JavaScriptCore FFI from webkitgtk";
        license = stdenv.lib.licenses.bsd3;
        hydraPlatforms = stdenv.lib.platforms.none;
@@ -140137,7 +140604,7 @@ self: {
      mkDerivation {
        pname = "webkitgtk3";
        version = "0.14.1.0";
-       sha256 = "16dypc71xh223746cgwa143vqyxymx6dqxk01j3ixpx7ybzr7lnm";
+       sha256 = "d5d293fff2a7df1e870c6076dc4cafbe7bbc07098a3f66c81942c01e0ebbbe99";
        libraryHaskellDepends = [
          base bytestring cairo glib gtk3 mtl pango text transformers
        ];
@@ -140154,12 +140621,11 @@ self: {
      }:
      mkDerivation {
        pname = "webkitgtk3-javascriptcore";
-       version = "0.13.0.4";
-       sha256 = "0lq6n1bhvg9rf48scc5ss299dil205y23r9qzl1ls4g4msv6k25c";
+       version = "0.13.1.0";
+       sha256 = "caf9cc5074e51f27abb3ea52f60b8e737ca7323b96bf0862ba1713354bf835b5";
        libraryHaskellDepends = [ base glib gtk3 webkitgtk3 ];
        libraryPkgconfigDepends = [ webkit ];
        libraryToolDepends = [ gtk2hs-buildtools ];
-       jailbreak = true;
        description = "JavaScriptCore FFI from webkitgtk";
        license = stdenv.lib.licenses.bsd3;
      }) { inherit (pkgs) webkit;};
@@ -140171,7 +140637,7 @@ self: {
      mkDerivation {
        pname = "webpage";
        version = "0.0.3.1";
-       sha256 = "1s9q44wvkc60g1117c3c4klf9pc92x7rpgvb7pwyhbbkvshmnirj";
+       sha256 = "32475ba1de732de8f93d6bbf9b4f1789dde4e8246cb0134278c0b0b9392138e9";
        revision = "1";
        editedCabalFile = "1829b0f7db8745498bee16ed1d70917aa781fd14ab8f8032b51472cfc3cd6787";
        libraryHaskellDepends = [
@@ -140189,7 +140655,7 @@ self: {
      mkDerivation {
        pname = "webserver";
        version = "0.7.1.1";
-       sha256 = "0mjbw1v0xy3ji6y0wdiv77y7bc4r5z7jk67gzzgny2cx1vx3c973";
+       sha256 = "e32436fa0e9d096fdfffef9829cf2f99b075fc393b360ebc8972f80e76e04b56";
        libraryHaskellDepends = [
          base bytestring c10k containers directory filepath network
          old-locale parsec process stm time unix zlib
@@ -140204,7 +140670,7 @@ self: {
      mkDerivation {
        pname = "websnap";
        version = "0.1.0.1";
-       sha256 = "05favr2lpc8y3qy7wahcriq8qhvzvr3ngvrgdyjcvf5bvyfwlp84";
+       sha256 = "045dca9ddfabb8cda46f2fef6747de7f438c70cc0c2a7e3c1e1eb14b45deca15";
        isLibrary = false;
        isExecutable = true;
        executableHaskellDepends = [ base filepath gtk webkit ];
@@ -140223,7 +140689,7 @@ self: {
      mkDerivation {
        pname = "websockets";
        version = "0.9.5.0";
-       sha256 = "016h213sk3n662ri8ns1sswcnaml61qckprdgxdp0m2a77amivmy";
+       sha256 = "beee58d5394a54705b7f2ddfc97030b42acbb8d6415b14b330c68ea94710d004";
        libraryHaskellDepends = [
          attoparsec base base64-bytestring binary blaze-builder bytestring
          case-insensitive containers entropy mtl network random SHA text
@@ -140246,7 +140712,7 @@ self: {
      mkDerivation {
        pname = "websockets-snap";
        version = "0.9.2.0";
-       sha256 = "03szycdvygw1zkv2s090wn2jii9sqbplgbycmpm5mfm3r0jhbhxp";
+       sha256 = "b7c30525c8a3ba5aeaadccaf47efc23ac52885e520012df6fc813fbf1bf35f0f";
        libraryHaskellDepends = [
          base bytestring enumerator mtl snap-core snap-server websockets
        ];
@@ -140263,7 +140729,7 @@ self: {
      mkDerivation {
        pname = "webwire";
        version = "0.1.0";
-       sha256 = "0m2wl7cfg67yyj2bbn811g6gsvzj7sw1sb3y2zanc0dxjd4cr4r2";
+       sha256 = "2293cc4893bd0166d5177e2c1db83ef26ffdcc0b01d9b584f4fe98e7d8a15c54";
        libraryHaskellDepends = [
          base base64-bytestring blaze-builder blaze-html bytestring
          case-insensitive containers cookie cprng-aes hamlet http-types
@@ -140280,7 +140746,7 @@ self: {
      mkDerivation {
        pname = "wedding-announcement";
        version = "1.1";
-       sha256 = "0rwbckf5h68170jrs1m70kgqf9h43vypj65wcw390w0xc7kmyv49";
+       sha256 = "896c5fe7611d70900667bc1879fd1e042687df04a7069d2538011958dc648b67";
        isLibrary = false;
        isExecutable = true;
        executableHaskellDepends = [ base ];
@@ -140296,7 +140762,7 @@ self: {
      mkDerivation {
        pname = "wedged";
        version = "0";
-       sha256 = "1sdnqc40qg5pv0kj4qw33vk5cy3yym60csh3iwmpm7pzpray7511";
+       sha256 = "2194e355beff9e7a2b8f036a064cf57e7856e61e83632227d8b73c0c08c3b6e9";
        revision = "1";
        editedCabalFile = "64bac15c983cf83ab2b05b002439b8f125b9c942ae46ed75a187f7e2dc68dba5";
        isLibrary = false;
@@ -140316,7 +140782,7 @@ self: {
      mkDerivation {
        pname = "weighted-regexp";
        version = "0.3.1.2";
-       sha256 = "0r765ppzazdsm5i3prgf6a405f88xi8sx79jdz9mck4584w7fqzr";
+       sha256 = "f963773841854c56d36f329dae51ec08b9028832eee53b62a9ba7df5ef2de664";
        isLibrary = true;
        isExecutable = true;
        libraryHaskellDepends = [ array base ];
@@ -140333,7 +140799,7 @@ self: {
      mkDerivation {
        pname = "weighted-search";
        version = "0.1.0.1";
-       sha256 = "1va2b10g3h2wfl9d7f27d55z5c93fvz41sb023l4c2ym1w9kw8zv";
+       sha256 = "fb233e130fd50b46e81060e940fe7623b1f24b6947b8d312755cc0f1405842ed";
        libraryHaskellDepends = [ base ];
        homepage = "http://github.com/luqui/weighted-search";
        description = "A weighted nondeterministic search monad";
@@ -140348,7 +140814,7 @@ self: {
      mkDerivation {
        pname = "welshy";
        version = "0.1.0.0";
-       sha256 = "08pgns5irmvh9c12lxq2x72ql8ggzd3npfqnrphba3l171380gki";
+       sha256 = "713e804638810eb5e0cd16bb6b47fbef218ac5e902772a024b70d71c8bb6ef22";
        revision = "1";
        editedCabalFile = "ff6973a67b742efb8d7c1d542ba9f27056de3e547ade96d33e9b68314afec22c";
        libraryHaskellDepends = [
@@ -140367,7 +140833,7 @@ self: {
      mkDerivation {
        pname = "wheb-mongo";
        version = "0.0.3.0";
-       sha256 = "1xxks0jxjwph7372jqnscm6z0b28zz3dvb49b2aw37jmnvwrfdcy";
+       sha256 = "9e3597f9b6559ec1955889acddc6ff482cf04d65da6229ce38f072d925d0b3f7";
        libraryHaskellDepends = [ base bson mongoDB mtl text Wheb ];
        jailbreak = true;
        homepage = "https://github.com/hansonkd/Wheb-Framework";
@@ -140381,7 +140847,7 @@ self: {
      mkDerivation {
        pname = "wheb-redis";
        version = "0.0.1.0";
-       sha256 = "025chjp41qbjr9m6c3pd9v510h4aac1rvbyrki3c7617sca8a45h";
+       sha256 = "b0108514d32798c3469cd9af9d03538a4010ca4eed0e666aca72e140ae84ac08";
        libraryHaskellDepends = [ base bytestring hedis mtl text Wheb ];
        jailbreak = true;
        homepage = "https://github.com/hansonkd/Wheb-Framework";
@@ -140395,7 +140861,7 @@ self: {
      mkDerivation {
        pname = "wheb-strapped";
        version = "0.1.0.0";
-       sha256 = "1wykpp325336kk7a1vnnjffankcw0kaw3jcfin53cp8hsx4bwfdp";
+       sha256 = "b739be48d7105d368a8d8ec9c1d5049c4dab9c93d6eea0ce9c668c22c6bdd3f3";
        libraryHaskellDepends = [ base mtl StrappedTemplates text Wheb ];
        jailbreak = true;
        homepage = "https://github.com/hansonkd/Wheb-Framework";
@@ -140409,7 +140875,7 @@ self: {
      mkDerivation {
        pname = "while-lang-parser";
        version = "0.1.0.0";
-       sha256 = "0dlq2rldak4lb0w8hcx7aigdj7b59crp1k130p36cha7zpqdixll";
+       sha256 = "94f6d8f0fd474166c60523cc70334b651dd95e54a733883858944cd568169836";
        libraryHaskellDepends = [ base indents parsec ];
        homepage = "https://github.com/davnils/while-lang-parser";
        description = "Parser for the While language";
@@ -140423,7 +140889,7 @@ self: {
      mkDerivation {
        pname = "whim";
        version = "0.1.1";
-       sha256 = "0fgasnviqmz8ifkb8ikvj721f9j1xzvix5va0jxi81gh6f400ij6";
+       sha256 = "4646008833f00514bb046a971ef7ef412617c4917b46b4a68be8571cb7d5ea39";
        isLibrary = true;
        isExecutable = true;
        libraryHaskellDepends = [
@@ -140441,7 +140907,7 @@ self: {
      mkDerivation {
        pname = "whiskers";
        version = "0.1.0.3";
-       sha256 = "0kbyv0q6z2d2plblafqcmwcfiyhdbijqnqg2w7qxr7dklka8245v";
+       sha256 = "bb1081d4a4b39ddcf1e1e2618b655c0dfae818af0c3b4517bda2896f30d87e4d";
        libraryHaskellDepends = [ base parsec template-haskell ];
        jailbreak = true;
        description = "Mustache templates with Template Haskell";
@@ -140453,7 +140919,7 @@ self: {
      mkDerivation {
        pname = "whitespace";
        version = "0.4";
-       sha256 = "1y89bayaccz8qqzsfmpr917dczgbn5srskja6f2dab3ipxhk24z9";
+       sha256 = "e9133161bf712cd584334a4e9d75b1eb7dd64e48f956a73fc6e833a6bc5a09f9";
        isLibrary = false;
        isExecutable = true;
        executableHaskellDepends = [ haskell98 random ];
@@ -140468,7 +140934,7 @@ self: {
      mkDerivation {
        pname = "whois";
        version = "1.2.2";
-       sha256 = "199fd710zicx7ijyvipc7p0d3yg18f6nppcln2wz38hl9kfv0iv0";
+       sha256 = "6047b0dd4c14a2f1b9b094dd6b8d43e1f9d1c03decc6ed653c9dc50fc2692ea5";
        revision = "1";
        editedCabalFile = "c11f42da958683ffb7a2e958dcefe2ef1a3e732732010f44facfbb0fffd7571e";
        libraryHaskellDepends = [ base network network-uri split ];
@@ -140485,7 +140951,7 @@ self: {
      mkDerivation {
        pname = "wikipedia4epub";
        version = "0.0.12";
-       sha256 = "089mmwrknghkliakni3wmwrd0hcngg3kqkijfmmky4bxni6w39bd";
+       sha256 = "6da5c14db47d113f6b75324e3cc77b9641d032af7c443b55a4133e3b33af3521";
        isLibrary = true;
        isExecutable = true;
        libraryHaskellDepends = [
@@ -140503,7 +140969,7 @@ self: {
      mkDerivation {
        pname = "win-hp-path";
        version = "0.1.2";
-       sha256 = "131hr8c4q7fwqmwzyp1fwnz349h6103v5gjvzjpbhb7ngki38nfq";
+       sha256 = "d85934e27cf62cb8aefc5bbeb20708062632bee52e5cff79c5dc1d4c18ca308c";
        isLibrary = true;
        isExecutable = true;
        libraryHaskellDepends = [ base split ];
@@ -140520,7 +140986,7 @@ self: {
      mkDerivation {
        pname = "windowslive";
        version = "0.3";
-       sha256 = "15dk3wdv99ggxwypgnv8hs5ygn5bzqml9jhhz6l9kgnc0rrn3jbz";
+       sha256 = "7fc9617306ccbe99a8f910ca442bfeabd8e78b8668db773defefa5b41b1fb395";
        isLibrary = true;
        isExecutable = true;
        libraryHaskellDepends = [
@@ -140538,7 +141004,7 @@ self: {
      mkDerivation {
        pname = "winerror";
        version = "1.0.1";
-       sha256 = "0xamx4yhyv264mka4ypp0r1xh3xv7ba31sis3lbhjycn4i07wlhd";
+       sha256 = "0d527e4024967909171d3aea30d43abb0fd84306f77aa26625466c0f3de95575";
        description = "Error handling for foreign calls to the Windows API";
        license = stdenv.lib.licenses.bsd3;
        hydraPlatforms = stdenv.lib.platforms.none;
@@ -140551,7 +141017,7 @@ self: {
      mkDerivation {
        pname = "winio";
        version = "0.1";
-       sha256 = "0f13x6fcb7cb4rfza5vp1dfxx3rcggh5rgw05lkqx9jwvnqcnjwm";
+       sha256 = "954bcbb0dd5ca68e272d80bf5ce07b2c8fde5d0b7717f55d268b9dc59ce92338";
        libraryHaskellDepends = [
          base bytestring extensible-exceptions network winerror
        ];
@@ -140569,7 +141035,7 @@ self: {
      mkDerivation {
        pname = "wiring";
        version = "0.3.0";
-       sha256 = "0c7xg6xq5bmb0qc2f9509sx5yrnngp4q5v1bgxl636qp9mhck68x";
+       sha256 = "1d99c9604d179b61687f2bec82c97dd6665fba4ea024271806abae82bb79fd30";
        libraryHaskellDepends = [ base mtl template-haskell transformers ];
        testHaskellDepends = [
          base hspec mtl QuickCheck template-haskell transformers
@@ -140586,7 +141052,7 @@ self: {
      mkDerivation {
        pname = "witherable";
        version = "0.1.3";
-       sha256 = "0n0l169xh23925blgzy2i90gz8lsa0176dp49bl6cncq362bqcn8";
+       sha256 = "c832bc8419985966e84ae4367302509aa2ff408ac2ff4757116908d893091458";
        libraryHaskellDepends = [
          base base-orphans containers hashable transformers
          unordered-containers vector
@@ -140601,7 +141067,7 @@ self: {
      mkDerivation {
        pname = "witness";
        version = "0.3";
-       sha256 = "0r0395blixr5g3s2dm4x4mj93yjk4zlig0b5acbnnr7yimjmnd11";
+       sha256 = "21345b658dfe646b1753658117e92753fa9164259dd426f47825f74857490364";
        libraryHaskellDepends = [
          base categories constraints transformers
        ];
@@ -140615,7 +141081,7 @@ self: {
      mkDerivation {
        pname = "witty";
        version = "0.0.4";
-       sha256 = "1k8c74j28nji46gib7r2ivfbvvzmkka9qnyf8hh7cyjgsmxxvq83";
+       sha256 = "03e1dd7bd54f7a762044ce5b9cd49cf5efbddc8e229f159f21515a2424390ccd";
        isLibrary = false;
        isExecutable = true;
        executableHaskellDepends = [ base bytestring network unix ];
@@ -140631,7 +141097,7 @@ self: {
      mkDerivation {
        pname = "wizards";
        version = "1.0.2";
-       sha256 = "02yk9d01d39c3hpvlh2c6v35fzyf3nm92f6vff0qns30dmr2r8ab";
+       sha256 = "4ba12c726d60688b8173db3891aa1dce7f57c6364c40ba2f1c2c8d16404bd30b";
        libraryHaskellDepends = [
          base containers control-monad-free haskeline mtl transformers
        ];
@@ -140643,10 +141109,9 @@ self: {
     ({ mkDerivation, base, lens, linear, parsec, parsec-numbers }:
      mkDerivation {
        pname = "wkt";
-       version = "0.2.5";
-       sha256 = "02r453wx1kv50lw0hx4nvzzv5wjfsy16gyjqphc25aq45rl5hr8g";
+       version = "0.2.6";
+       sha256 = "ef27992128212510566866e2d008bfc55999a2e87eb9fa6f25aba00c4039a49d";
        libraryHaskellDepends = [ base lens linear parsec parsec-numbers ];
-       jailbreak = true;
        homepage = "http://github.com/bgamari/wkt";
        description = "Parsec parsers and types for geographic data in well-known text (WKT) format";
        license = stdenv.lib.licenses.bsd3;
@@ -140657,7 +141122,7 @@ self: {
      mkDerivation {
        pname = "wl-pprint";
        version = "1.2";
-       sha256 = "166zvk4zwn2zaa9kx66m1av38m34qp6h4i65bri2sfnxgvx0700r";
+       sha256 = "198003fa7edd3a2d625ec54402cdc5645434b60ad5983e93525f58fec9dcdf98";
        libraryHaskellDepends = [ base ];
        description = "The Wadler/Leijen Pretty Printer";
        license = stdenv.lib.licenses.bsd3;
@@ -140670,7 +141135,7 @@ self: {
      mkDerivation {
        pname = "wl-pprint-ansiterm";
        version = "0.2.0.0";
-       sha256 = "02s47f58ah08fvjqpdscxqiq9609agi5iplczrdkgxrv1vj8vkpz";
+       sha256 = "ffce8de40e3bf7375bfe8cde58e25309988423ee4cb78be5760840858a3b440b";
        libraryHaskellDepends = [
          ansi-terminal base bytestring containers mtl nats semigroups text
          transformers wl-pprint-extras
@@ -140688,7 +141153,7 @@ self: {
      mkDerivation {
        pname = "wl-pprint-extras";
        version = "3.5.0.5";
-       sha256 = "13wdx7l236yyv9wqsgcjlbrm5gk1bmw1z2lk4b21y699ly2imhm9";
+       sha256 = "a9c21a85a729191fc422938a1f785d61be52f3a2923d8d79dade9b21e8e98d8f";
        libraryHaskellDepends = [
          base containers nats semigroupoids semigroups text utf8-string
        ];
@@ -140707,7 +141172,7 @@ self: {
      mkDerivation {
        pname = "wl-pprint-terminfo";
        version = "3.7.1.3";
-       sha256 = "19z5cr1wqc3xcy39dswx78b6fpxhb41798zkiwkmb97nnvzwbdmv";
+       sha256 = "bbb6c5ffb6f6a455278ff3a3740259b05f67163a9deb9686677d30cc4366e5a7";
        libraryHaskellDepends = [
          base bytestring containers nats semigroups terminfo text
          transformers wl-pprint-extras
@@ -140722,7 +141187,7 @@ self: {
      mkDerivation {
        pname = "wl-pprint-text";
        version = "1.1.0.4";
-       sha256 = "1xgizzimfw17mpmw2afvmnvyag976j8ggn7k5r564rkw9f0m6bgz";
+       sha256 = "ff2d53814b7c66624a2ef3d8f79034273de5b7addb29c1ebad277057e3fff1f5";
        libraryHaskellDepends = [ base text ];
        description = "A Wadler/Leijen Pretty Printer for Text values";
        license = stdenv.lib.licenses.bsd3;
@@ -140735,7 +141200,7 @@ self: {
      mkDerivation {
        pname = "wlc-hs";
        version = "0.1.0.0";
-       sha256 = "0z553h86dznsf2wagbfhh8p27aa20jm3wmxkklr51al35xralvv9";
+       sha256 = "696faa722f83aa50329db3573eaa0442a9232e82d0ada7b870dafe66101ca57c";
        libraryHaskellDepends = [
          base containers data-default lens pretty process transformers
          xkbcommon
@@ -140760,7 +141225,7 @@ self: {
      mkDerivation {
        pname = "wobsurv";
        version = "0.1.0";
-       sha256 = "1w2j7xr4f0a63bwz96js8wrdpfw73qzdg6d607lx2526yrq8xlh2";
+       sha256 = "02d28e70f64614d1e901a699d73e1e87bbdb32475a9af4f91a460147723f52f0";
        isLibrary = true;
        isExecutable = true;
        libraryHaskellDepends = [
@@ -140791,7 +141256,7 @@ self: {
      mkDerivation {
        pname = "woffex";
        version = "0.1";
-       sha256 = "0b83s5q4i3f4l45dklp1xgrlcpzrsdbd16fvlpazlcglzxk81xmv";
+       sha256 = "bbf68066fff431fad5a5db99d056d3f95f46f3ebe1d2d90aa1c48d4870d1032d";
        isLibrary = false;
        isExecutable = true;
        executableHaskellDepends = [
@@ -140808,7 +141273,7 @@ self: {
      mkDerivation {
        pname = "wol";
        version = "0.1.2";
-       sha256 = "0w0m91srvgbj3qcxw2djpb482qlinsi2dyyb76qksdd2gw0jm57i";
+       sha256 = "f1942a017fa2353db139cbfb26a2b6916281c8bab209de191e72bd9d75481570";
        isLibrary = true;
        isExecutable = true;
        libraryHaskellDepends = [ base network split ];
@@ -140829,7 +141294,7 @@ self: {
      mkDerivation {
        pname = "wolf";
        version = "0.1.1";
-       sha256 = "1g98xjl8qpayj8ynz0391cqhfagaxa03hxqaz2wvyppalqdp44k9";
+       sha256 = "6912721ba6ea5ebfb9f80a773880eaea2907310b69806f3d925e5d8ca8ec28bd";
        isLibrary = true;
        isExecutable = true;
        libraryHaskellDepends = [
@@ -140854,7 +141319,7 @@ self: {
      mkDerivation {
        pname = "word-trie";
        version = "0.3.0";
-       sha256 = "10ljyb1hl4awg2c3wq5shdqj2s53q5fklf7p6np1jhn6i30c5wx3";
+       sha256 = "a3f3c2c088c64219ae35f7383a5dc1a368217183ba603e98785c110ac3f29282";
        revision = "1";
        editedCabalFile = "85582eefb0020e6e35a0e2588e1dd647fb20bb7f70108f29493f994af5b74a05";
        libraryHaskellDepends = [ base binary containers ];
@@ -140869,7 +141334,7 @@ self: {
      mkDerivation {
        pname = "word12";
        version = "1.0.0";
-       sha256 = "19a22vs314bps0fq7md9jv43xzrya28mmfxi39zd8a1d8h99yd5c";
+       sha256 = "ac349f12442d28d47e1ab1bb5a91503eff3ec896a9d5831dd0779130f41642a5";
        libraryHaskellDepends = [ base bytestring ];
        testHaskellDepends = [ base bytestring hspec QuickCheck ];
        homepage = "http://github.com/minpou/word12";
@@ -140884,7 +141349,7 @@ self: {
      mkDerivation {
        pname = "word24";
        version = "1.0.7";
-       sha256 = "1rh766jrmfw1hy1p4xllfq2ygxpm3zyglw4vcjainajn2r7whnhi";
+       sha256 = "115ac84f16562a1b95649b70fafc1ff5f6e70576947672838781bb9aa53107e6";
        libraryHaskellDepends = [ base ];
        testHaskellDepends = [
          base QuickCheck test-framework test-framework-quickcheck2
@@ -140900,7 +141365,7 @@ self: {
      mkDerivation {
        pname = "word8";
        version = "0.1.2";
-       sha256 = "1pbn8ra3qhwvw07p375cdmp7jzlg07hgdcr4cpscz3h7b9sy7fiw";
+       sha256 = "3cbae3755a078ecff46524b3f6e0018f7e796e6dac9c710fe09b433c544676dd";
        libraryHaskellDepends = [ base ];
        testHaskellDepends = [ base hspec ];
        description = "Word8 library";
@@ -140912,7 +141377,7 @@ self: {
      mkDerivation {
        pname = "wordcloud";
        version = "0.1";
-       sha256 = "1jdcv5h41k5xckviyc0p0k0q68s371llcvmkdbg78vh4b3xw7cd5";
+       sha256 = "a5b1c3fb58046e74de6ab36e466938432383c10417301ff764bdcc4060d9acc9";
        description = "None";
        license = stdenv.lib.licenses.bsd3;
        hydraPlatforms = stdenv.lib.platforms.none;
@@ -140923,7 +141388,7 @@ self: {
      mkDerivation {
        pname = "wordexp";
        version = "0.2.0.0";
-       sha256 = "1hfpvzbyyh47ai166xyrhmhvg2shrqcswsfalwa16wab6hcg32ki";
+       sha256 = "718af118344b711314a7ca69ae19ce508bb76185d9776342548740efd7dfd7c1";
        libraryHaskellDepends = [ array base semigroups ];
        libraryToolDepends = [ c2hs ];
        description = "wordexp(3) wrappers";
@@ -140937,7 +141402,7 @@ self: {
      mkDerivation {
        pname = "wordpass";
        version = "1.0.0.4";
-       sha256 = "0plyggai2mq38bmmgc92gd0n3q4dlsywh44yflradg50aslqw0vv";
+       sha256 = "7b038ea956a0bca632759e10c8bda68de061417b22b157eb42035711d57b9e5e";
        isLibrary = true;
        isExecutable = true;
        libraryHaskellDepends = [
@@ -140958,7 +141423,7 @@ self: {
      mkDerivation {
        pname = "words";
        version = "0.1.2";
-       sha256 = "0najaqi9fkqdkfks1c6w3fz4qf7dnr4h4brzgglg1h9ik8x5a910";
+       sha256 = "2024553a9a31c1f0e87b3f2f0249b6ed384cbe1bdcb0a0a79b0d4f9722565259";
        libraryHaskellDepends = [ base directory text ];
        description = "Cross-platform access to a list of words";
        license = stdenv.lib.licenses.bsd3;
@@ -140969,7 +141434,7 @@ self: {
      mkDerivation {
        pname = "wordsearch";
        version = "1.0.1";
-       sha256 = "0jq1aiw35xiklc9asa1pgw2rn6i8q17fq780chqpqz0ryq0iv4x2";
+       sha256 = "a2931d01f6197c7c3164001dec4ec0281a9b057f3728ad12a333f6327854014b";
        isLibrary = true;
        isExecutable = true;
        libraryHaskellDepends = [ array base containers fclabels ];
@@ -140986,7 +141451,7 @@ self: {
      mkDerivation {
        pname = "wordsetdiff";
        version = "0.0.3.1";
-       sha256 = "0kzbs1ps8fxdsjcpyvccgpw1y6i1q5gw6brgf6j1vv6r24wsh00w";
+       sha256 = "1c00a83911d9ec1da4712f2fc35fc1211a1ff87d8c6d7f99d4ad3ba46fd0eb4f";
        isLibrary = false;
        isExecutable = true;
        executableHaskellDepends = [
@@ -141003,7 +141468,7 @@ self: {
      mkDerivation {
        pname = "wp-archivebot";
        version = "0.1";
-       sha256 = "04aq760z5jn81z03yi9l0d0w034qjiqiwb702lkvk2002b61mk5z";
+       sha256 = "bfcc1acc120088b92715e02c1e7194980cc0410334453fc00fc8caf281395811";
        isLibrary = false;
        isExecutable = true;
        executableHaskellDepends = [
@@ -141020,7 +141485,7 @@ self: {
      mkDerivation {
        pname = "wrap";
        version = "0.0.0";
-       sha256 = "03pmfwwx2ykjglzrc4k09q2lv8piq107j32dg0r1aadj2ysc9fzq";
+       sha256 = "f8bbc4b417b2291532784d0c7940c0f1a24d054e6012963f7d727ad13977f50e";
        libraryHaskellDepends = [ base ];
        description = "Wrap a function's return value with another function";
        license = stdenv.lib.licenses.bsd3;
@@ -141031,7 +141496,7 @@ self: {
      mkDerivation {
        pname = "wraparound";
        version = "0.0.2";
-       sha256 = "161mz5bfmx13s9azh3dss64fw98vbaab8krysr9pbbp9dh79i1cf";
+       sha256 = "8e85980e6ce9ae7553d63e4fb4945a1b25ee88d1ba0df855d223f4ea56f93598";
        libraryHaskellDepends = [ base ];
        homepage = "http://frigidcode.com";
        description = "Convenient handling of points on a seamless 2-dimensional plane";
@@ -141046,7 +141511,7 @@ self: {
      mkDerivation {
        pname = "wraxml";
        version = "0.4.4";
-       sha256 = "1h8lqav0q6vka8yr64032yh3ncjvz6fxp1j9q5jqhzm0ai34air3";
+       sha256 = "2347454654a07e8865c14986db9df95b323ba0170310933d52731b0cb6c214c1";
        isLibrary = true;
        isExecutable = true;
        libraryHaskellDepends = [
@@ -141075,7 +141540,7 @@ self: {
      mkDerivation {
        pname = "wreq";
        version = "0.4.0.0";
-       sha256 = "15vjamr3sain8cdgqhg0jfy0rz3bbb6chrivyzvki5rs2g6pzrja";
+       sha256 = "4ae67fcd133a9738f7f73b66c8cc5a6bfc0cbc93e041fc1a43362a3d72557297";
        isLibrary = true;
        isExecutable = true;
        libraryHaskellDepends = [
@@ -141112,7 +141577,7 @@ self: {
      mkDerivation {
        pname = "wreq-sb";
        version = "0.4.0.0";
-       sha256 = "0m0vjykj1wqv07xxy2r7xz68syx5r3chni4x399f5fwn6shw1jfz";
+       sha256 = "dfc9c0a13696bbe2521a9d440bd9c8a57b8dccef270bdffb011bf320a7971b54";
        isLibrary = true;
        isExecutable = true;
        libraryHaskellDepends = [
@@ -141142,7 +141607,7 @@ self: {
      mkDerivation {
        pname = "wright";
        version = "0.1.0.2";
-       sha256 = "180012vyslprj06npavh44fmii1813w22sws9zwxzlb4r4jdm4zi";
+       sha256 = "f193da24c964d1dff94f9a6b21f80828c4581d2170ab6b0d90f952edb70800a0";
        libraryHaskellDepends = [ base bed-and-breakfast containers ];
        testHaskellDepends = [
          assertions base bed-and-breakfast containers filepath lens
@@ -141160,7 +141625,7 @@ self: {
      mkDerivation {
        pname = "wsedit";
        version = "0.1.0.0";
-       sha256 = "1035v9c22pngk2r3yisr2vvnfdjgynlgq8adj8z50xak998x22ri";
+       sha256 = "310bd1514a5375503e924d21fca8f54f3667f71659473fb298cf5e2158da6580";
        isLibrary = false;
        isExecutable = true;
        executableHaskellDepends = [
@@ -141176,7 +141641,7 @@ self: {
      mkDerivation {
        pname = "wtk";
        version = "0.2.1";
-       sha256 = "080y0ks5q6bv7dvla08x4cvcmzd13b5v1c5p5336k0vkg2c3fq79";
+       sha256 = "e960379878738369c628b7b0b0cb1aa1fdca36231d0145773b7b195cf4041e20";
        libraryHaskellDepends = [ base old-locale time transformers ];
        description = "Wojcik Tool Kit";
        license = stdenv.lib.licenses.bsd3;
@@ -141190,7 +141655,7 @@ self: {
      mkDerivation {
        pname = "wtk-gtk";
        version = "0.2";
-       sha256 = "0n9fvp83z71jvv67zjpz34r427s898shns00v84kfjjklhd61q5y";
+       sha256 = "bee0601aa4534a3709da00680b354a481f413219ffca7fccde329c3fd0dd2e59";
        libraryHaskellDepends = [
          base containers gtk lenses mtl old-locale parsec time wtk
        ];
@@ -141206,7 +141671,7 @@ self: {
      mkDerivation {
        pname = "wumpus-basic";
        version = "0.24.0";
-       sha256 = "1mahlvja39jc6zvm32n23p8ya2pfwwawbyawx8srds0bsfyqqmng";
+       sha256 = "cf568cbdd30be89635ea5cf9c515e7ee0ae5d11dc28a51f7374ca6a1e4a650d5";
        libraryHaskellDepends = [
          base containers directory filepath vector-space wumpus-core
        ];
@@ -141221,7 +141686,7 @@ self: {
      mkDerivation {
        pname = "wumpus-core";
        version = "0.52.1";
-       sha256 = "10q991xb9v2r3z7q53rwrqcqd4m6qazvdibrxsn2620l2zbjxnd8";
+       sha256 = "a8d92ed717140823acee79c5b6bfc2a6928619ce3c8f82cf1f59ecb47a480983";
        libraryHaskellDepends = [ base containers time vector-space ];
        homepage = "http://code.google.com/p/copperbox/";
        description = "Pure Haskell PostScript and SVG generation";
@@ -141236,7 +141701,7 @@ self: {
      mkDerivation {
        pname = "wumpus-drawing";
        version = "0.9.0";
-       sha256 = "1y9j2d3k862zi8681q3b2pl4nx4vyazdfwx5ji4mfgy73z62lbxw";
+       sha256 = "bc2f2acc1fc73f574994a573d7bef29b744be8156be0800c8a5f1834471332f9";
        libraryHaskellDepends = [
          base containers vector-space wumpus-basic wumpus-core
        ];
@@ -141253,7 +141718,7 @@ self: {
      mkDerivation {
        pname = "wumpus-microprint";
        version = "0.14.0";
-       sha256 = "1rrw8hzns7qa9jyzhbal0x0xbi5wa99afixs0cxqk0kgm6sar9cz";
+       sha256 = "9fa5acb4a96f82893b03ba47a75252bcc4d54107542df8bd4c0a1f6d3f443ce7";
        libraryHaskellDepends = [
          base vector-space wumpus-basic wumpus-core wumpus-drawing
        ];
@@ -141271,7 +141736,7 @@ self: {
      mkDerivation {
        pname = "wumpus-tree";
        version = "0.20.0";
-       sha256 = "1xndkri4ayxb12xhik77r59qlg05nhibc8b257csrw9br7xkk8ja";
+       sha256 = "4aa239fbc92bf1acd9296221b622b4053c8a53c9e7cc08bb08ab7b45629ecdf6";
        libraryHaskellDepends = [
          base containers vector-space wumpus-basic wumpus-core
          wumpus-drawing
@@ -141289,7 +141754,7 @@ self: {
      mkDerivation {
        pname = "wuss";
        version = "1.0.2";
-       sha256 = "0i4ln8pvjv1cgqcwid111azrls00g1jdhls3wrhnkw8wjcbiiqps";
+       sha256 = "fae21817931cf16961e64353d8647800689abf0a21b4c8197e2c6cb92fb29444";
        libraryHaskellDepends = [
          base bytestring connection network websockets
        ];
@@ -141304,7 +141769,7 @@ self: {
      mkDerivation {
        pname = "wx";
        version = "0.91.0.0";
-       sha256 = "133cjc3vfqxyw71a5x99flzg23qa2k28p2zajw6vp0z7qhv8kfjy";
+       sha256 = "5eba8936c4e783bb0d97ea8b8bc4140a0ff13e7529f5a2c2e1be63b707936c8c";
        libraryHaskellDepends = [ base stm wxcore ];
        homepage = "http://haskell.org/haskellwiki/WxHaskell";
        description = "wxHaskell";
@@ -141316,7 +141781,7 @@ self: {
      mkDerivation {
        pname = "wxAsteroids";
        version = "1.0";
-       sha256 = "0mwsh9bhzhnf8la5khy17j2brbphvkicqg0yd0y9ymnn6bgnq4br";
+       sha256 = "79116cdf32d6569f3c681e3ccce2dcf0aebc843cc1c3591445cec20f57829a57";
        isLibrary = false;
        isExecutable = true;
        executableHaskellDepends = [ base directory random wx wxcore ];
@@ -141331,7 +141796,7 @@ self: {
      mkDerivation {
        pname = "wxFruit";
        version = "0.1.2.1";
-       sha256 = "09n0b8znrwa65z1cjfizxkxj2rlsp56akagih5cycxpwivj1d7p9";
+       sha256 = "e99e16e48efc76e65981f1a9a94cb99a6621fbec3f3ac9c22f46f16c3f5ac026";
        isLibrary = true;
        isExecutable = true;
        libraryHaskellDepends = [ base old-time wx wxcore Yampa ];
@@ -141348,7 +141813,7 @@ self: {
      mkDerivation {
        pname = "wxc";
        version = "0.91.0.0";
-       sha256 = "0siab2h28dlyliznydxll22l9hdgwbmgddj01k1xw8hj4g7b53sa";
+       sha256 = "4a8fb2ce231222dec30c40b6f6eae2afc14485a0b4376f7fa49e3624a0582a6a";
        libraryHaskellDepends = [ base wxdirect ];
        librarySystemDepends = [ libX11 mesa ];
        libraryPkgconfigDepends = [ wxGTK ];
@@ -141368,7 +141833,7 @@ self: {
      mkDerivation {
        pname = "wxcore";
        version = "0.91.0.0";
-       sha256 = "01pvaysihyijklyw129vcafjqyh8bpafjzvscxvzll1g86qbqlkz";
+       sha256 = "7f52bcb0412f50fa77677a7fe9d45d087a2c9d623b89c03d9d327a18b557fb06";
        libraryHaskellDepends = [
          array base bytestring containers directory filepath parsec stm time
          wxc wxdirect
@@ -141386,7 +141851,7 @@ self: {
      mkDerivation {
        pname = "wxdirect";
        version = "0.91.0.0";
-       sha256 = "17xlviyyagcvmc7m1f4djnsw0wdakirarmv12j4fmwbnfnbryp27";
+       sha256 = "475c9f977576f1ea881461d7ac729caa71c0b5958db8500fab9b3de57ddcb49f";
        isLibrary = true;
        isExecutable = true;
        executableHaskellDepends = [
@@ -141403,7 +141868,7 @@ self: {
      mkDerivation {
        pname = "wxhnotepad";
        version = "1.2.0";
-       sha256 = "10897yb7mkc9hy2037r9yb4192n65lz997fd5apksra1rifrazyp";
+       sha256 = "d77f955dcc41653daf2acd9d943e2dc68a14c8f2299f01848789cd7a963f0981";
        isLibrary = false;
        isExecutable = true;
        executableHaskellDepends = [ base wx wxcore ];
@@ -141419,7 +141884,7 @@ self: {
      mkDerivation {
        pname = "wxturtle";
        version = "0.0.1";
-       sha256 = "0sdbi9dfja2ia0n3kggvqc3n3c5rgw096d767yvyzc52k5caakn7";
+       sha256 = "c74ea55899a2b0efb73fe63493007fb9b06107c3fbbd392c505128e95a8aab69";
        isLibrary = true;
        isExecutable = true;
        libraryHaskellDepends = [
@@ -141438,7 +141903,7 @@ self: {
      mkDerivation {
        pname = "wybor";
        version = "0.1.0";
-       sha256 = "0cyfhjpb775891qbfc3y15y16mx2hraavgvsrvqkb701rh5vngf6";
+       sha256 = "c63dbb0bcc019c35f1ce7abfad5486a257137c097e30b77048a89cb3ae84ce33";
        libraryHaskellDepends = [
          ansi-terminal base conduit containers lens resourcet semigroups
          terminal-size text transformers unix
@@ -141459,7 +141924,7 @@ self: {
      mkDerivation {
        pname = "wyvern";
        version = "0.1";
-       sha256 = "147v55c1ravnb769sjw2c8i4qw0gxh3scvx5cvb1fa6nng4x0hnq";
+       sha256 = "d842d0c9b3d62817d666a56fa607ec0f704c2262824b9dcc5976ab1c5829fb90";
        isLibrary = false;
        isExecutable = true;
        executableHaskellDepends = [
@@ -141480,7 +141945,7 @@ self: {
      mkDerivation {
        pname = "x-dsp";
        version = "0.2.3.1";
-       sha256 = "12l3zy9lmg7sf4q8b3yz2cb9pj9n0sgjglnqhcfkzzdg6pb0g4hj";
+       sha256 = "129207d635affd3f1d83d8d2279f0636c99b1613df8f853071fabc4a93ff838a";
        libraryHaskellDepends = [
          array base bytestring containers monads-tf text transformers
          type-level
@@ -141497,7 +141962,7 @@ self: {
      mkDerivation {
        pname = "x11-xim";
        version = "0.0.9.0";
-       sha256 = "0sn789j0kz891l9p0srx6537yq44b5jlyph9vc3xdb3ygy20bjrw";
+       sha256 = "3ccb05847f7eacd607db095e4f655984607f46313d6b70130d09fd096442c76a";
        revision = "1";
        editedCabalFile = "4404aa037f4df2ef8cd16834c8149d596f09b30379f0b85a3b8db9ddd30fa6b0";
        libraryHaskellDepends = [ base utf8-string X11 ];
@@ -141511,7 +141976,7 @@ self: {
      mkDerivation {
        pname = "x11-xinput";
        version = "0.1.0.0";
-       sha256 = "15ij6yfjjyqgzka1163a08ngrraxa4jpbwjq2izdl2l44k0mw29v";
+       sha256 = "3b095ec124840ada7e1458f27525515de5fc2c026a9810d4fc0f7b299d373296";
        libraryHaskellDepends = [ base containers mtl X11 ];
        librarySystemDepends = [ libXi ];
        libraryToolDepends = [ c2hs ];
@@ -141529,7 +141994,7 @@ self: {
      mkDerivation {
        pname = "x509";
        version = "1.6.0";
-       sha256 = "0fy2jyqkz6qi4x5x9hipnkwqcp3iqyb8h3cj23b69mqx98bfr7lk";
+       sha256 = "939eec164a1dd764d610920d8896c7715c86f9b437c2d44b27119b3fb197c23b";
        libraryHaskellDepends = [
          asn1-encoding asn1-parse asn1-types base bytestring containers
          cryptonite directory filepath hourglass memory mtl pem process
@@ -141551,7 +142016,7 @@ self: {
      mkDerivation {
        pname = "x509-store";
        version = "1.6.0";
-       sha256 = "08ifb2gy2ssq7ci1rlmxvm344rvcil8418ymj95l5c361nl4gcym";
+       sha256 = "d5b347a80d66b0424b92d5a340108d6c674246ddbdd21c223b586be19f582e22";
        libraryHaskellDepends = [
          asn1-encoding asn1-types base bytestring containers cryptonite
          directory filepath mtl pem process x509
@@ -141568,7 +142033,7 @@ self: {
      mkDerivation {
        pname = "x509-system";
        version = "1.6.0";
-       sha256 = "0d8ppvszc1xlvz7ixb8bbqmvhv2d9yyrrh51f5yng8mb2d2w5yah";
+       sha256 = "50f9c24513aba2677d71a1c09cbd4f4d6cb82b5e0bad1ecfdfb407f6f5be1735";
        libraryHaskellDepends = [
          base bytestring containers directory filepath mtl pem process x509
          x509-store
@@ -141586,7 +142051,7 @@ self: {
      mkDerivation {
        pname = "x509-util";
        version = "1.5.2";
-       sha256 = "12nhxi1lqr5arlj586ai6n86n226iz6k4gbnm0dq07dwgky4j0iy";
+       sha256 = "3e0249fc7cbc1d801ba8763d32cd8f46086b903551195424cdaa644c43ecd08a";
        isLibrary = false;
        isExecutable = true;
        executableHaskellDepends = [
@@ -141609,7 +142074,7 @@ self: {
      mkDerivation {
        pname = "x509-validation";
        version = "1.6.0";
-       sha256 = "07lz6klfslrlkc5zn8x4ynkpa9vfbn19vz7i67ygm1g608jcj1yc";
+       sha256 = "cc07c92402e685fafc31f1fc9d825d6e2775a7f5a423fb0b9b3453ede8349f1e";
        libraryHaskellDepends = [
          asn1-encoding asn1-types base byteable bytestring containers
          cryptonite data-default-class directory filepath hourglass memory
@@ -141627,7 +142092,7 @@ self: {
      mkDerivation {
        pname = "xattr";
        version = "0.6.2";
-       sha256 = "02vbxxn0qvkxvfxv1zgr95bvdzx14fp9h7s27wbz6mjfkfgvc39q";
+       sha256 = "380db69f9b4e56f3173f421f98ae23a1ffb65749f9fdb0bbdb7d6e0c6cef6b0b";
        libraryHaskellDepends = [ base bytestring unix ];
        librarySystemDepends = [ attr ];
        testHaskellDepends = [
@@ -141643,7 +142108,7 @@ self: {
      mkDerivation {
        pname = "xbattbar";
        version = "0.2";
-       sha256 = "1hc3k3w5x1c027jj4lgpwl4cxvy01sx78sc560fdfj6bpsqlcln0";
+       sha256 = "c05246b1becb48d71c30856974ba0ec0efce08e5f75122e51180855ef89883c1";
        isLibrary = false;
        isExecutable = true;
        executableHaskellDepends = [ base old-time select X11 ];
@@ -141657,7 +142122,7 @@ self: {
      mkDerivation {
        pname = "xcb-types";
        version = "0.7.0";
-       sha256 = "1kzqsd85zp937yna2yfpc3jy0hba92h2fp6j0a6r8r7zz5l8yk3k";
+       sha256 = "734c8f68f9ff64948d02d25c27a0486a41e0e560d779a1ac3f23dd5f50d3f8cf";
        libraryHaskellDepends = [ base containers mtl pretty xml ];
        homepage = "http://community.haskell.org/~aslatter/code/xcb-types";
        description = "Parses XML files used by the XCB project";
@@ -141673,7 +142138,7 @@ self: {
      mkDerivation {
        pname = "xcffib";
        version = "0.3.5";
-       sha256 = "0ri50cbsh8a67q3frsz6214b73ahmga348my5x5bp6w7likiqnly";
+       sha256 = "9e5a1c67a4879bbb4a2fbe2232d4ab508db34810e6ebec063e4621a817032566";
        isLibrary = true;
        isExecutable = true;
        libraryHaskellDepends = [
@@ -141698,7 +142163,7 @@ self: {
      mkDerivation {
        pname = "xchat-plugin";
        version = "0.0.3";
-       sha256 = "0rjpj6i4fn504m7s3hwqbydn0m0ryih0hw4xnc409338sval6xj6";
+       sha256 = "467643d5d6688c0408b39d700860f41954609b5f98c3a14f25a05847a2915766";
        isLibrary = true;
        isExecutable = true;
        libraryHaskellDepends = [ base directory filepath process unix ];
@@ -141717,7 +142182,7 @@ self: {
      mkDerivation {
        pname = "xcp";
        version = "0.1.0.1";
-       sha256 = "1hx9avr6zinrqar0c1zh0l49gy0d61gch8ff12am7zjxk7lbmmzs";
+       sha256 = "fad7bae8995dfe539508ce21c85e300df8970805f00706b2c2d9c66ff256a9c3";
        libraryHaskellDepends = [
          base bytestring containers mtl network transformers
        ];
@@ -141730,7 +142195,7 @@ self: {
      mkDerivation {
        pname = "xdg-basedir";
        version = "0.2.2";
-       sha256 = "0azlzaxp2dn4l1nr7shsxah2magk1szf6fx0mv75az00qsjw6qg4";
+       sha256 = "e461c3a5c6007c55ceaea03be3be0ef3a92aa0ea1aea936da0c43671bbfaf42b";
        libraryHaskellDepends = [ base directory filepath ];
        homepage = "http://github.com/willdonnelly/xdg-basedir";
        description = "A basic implementation of the XDG Base Directory specification";
@@ -141743,7 +142208,7 @@ self: {
      mkDerivation {
        pname = "xdg-userdirs";
        version = "0.1.0.2";
-       sha256 = "0vh4m385a828qb61845bb7zfcqfm000g4fjkmmlvdrfyh35vpal8";
+       sha256 = "88aabbcb80dee5b669ad533af20000d561e6fe59ab1014ccc2482055d0a8046e";
        libraryHaskellDepends = [
          base containers directory filepath xdg-basedir
        ];
@@ -141758,7 +142223,7 @@ self: {
      mkDerivation {
        pname = "xdot";
        version = "0.2.4.7";
-       sha256 = "1izf892748g7f1h4m49d52zkbzfv164r4zyqss5lsbh3brh15v3g";
+       sha256 = "6fec12605e032e4d8bd6d87f928909dbfd35bf282d914a6070e721724442eec7";
        isLibrary = true;
        isExecutable = true;
        libraryHaskellDepends = [
@@ -141774,7 +142239,7 @@ self: {
      mkDerivation {
        pname = "xenstore";
        version = "0.1.1";
-       sha256 = "0x788lpkkxg7ds1bgnw0kvkf6pkfbknn7jy0njhz85k7rv4kidf2";
+       sha256 = "c2b538c9ce6716f4a1b4c0cb63ed5c6e5ee3e69e80dbb7826ee7f5392f45e874";
        isLibrary = true;
        isExecutable = true;
        libraryHaskellDepends = [ base bytestring cereal mtl network ];
@@ -141787,7 +142252,7 @@ self: {
      mkDerivation {
        pname = "xfconf";
        version = "4.8.0.0";
-       sha256 = "0q63zavh3fz03dmky42gafypd0gpn8fs0nb9qn2a2zzj961vzswz";
+       sha256 = "9febbf8349f27fa184c56959a01db2f78176bd534f103f6b1be0bb01b7fac360";
        isLibrary = true;
        isExecutable = true;
        libraryHaskellDepends = [ base glib ];
@@ -141806,7 +142271,7 @@ self: {
      mkDerivation {
        pname = "xformat";
        version = "0.1.2.1";
-       sha256 = "1q2wm0wffvppbv5rd16z367yfkx2sq7j0i5dkfwpawf859c9pz7x";
+       sha256 = "fdfc9b582ac87175b99bad44200fd6a24fe78f19df8496cb5ef76ee738a85ce0";
        libraryHaskellDepends = [ base ];
        testHaskellDepends = [ base ];
        homepage = "http://github.com/spl/xformat";
@@ -141821,7 +142286,7 @@ self: {
      mkDerivation {
        pname = "xhaskell-library";
        version = "0.0.6";
-       sha256 = "13nnlaw56izwy0m7k4kh4g75sa5pvxn0pf9h3w8l9hnjcpv4l2ya";
+       sha256 = "ca0b4af665d2c244111f30b90b6cdfb7285dce237092792af0fc4753b8a2d68e";
        libraryHaskellDepends = [
          base bytestring containers ghc-prim mtl parsec regex-base
        ];
@@ -141839,7 +142304,7 @@ self: {
      mkDerivation {
        pname = "xhb";
        version = "0.6.2015.8.1";
-       sha256 = "1rq6g96v1fs66kdmnkvlkcxrv614ha77czclm3sfw274f7q2r2kb";
+       sha256 = "6b8a2cf071e408eef4a8947d768e8224989d3b9b744f5bdb3446bbb04d7a06e7";
        libraryHaskellDepends = [
          base binary byteorder bytestring containers network parsec stm
          Xauth
@@ -141856,7 +142321,7 @@ self: {
      mkDerivation {
        pname = "xhb-atom-cache";
        version = "0.1.0.2";
-       sha256 = "113yff75i5pc0kcz4w7npbp34bl92aibpvj2cgg30f66nml61xg9";
+       sha256 = "e9f56068b5c63830de6342eebba212892e32eebaf670f2d904ec96588e737e84";
        libraryHaskellDepends = [
          base hashable mtl transformers unordered-containers xhb
        ];
@@ -141873,7 +142338,7 @@ self: {
      mkDerivation {
        pname = "xhb-ewmh";
        version = "0.1.3.1";
-       sha256 = "02qfpwa9558svk0481dxjchr9h0phacsyqzail94kmzkhnnly64l";
+       sha256 = "94184fad85f3d749128dea63af998217c0942193bd0544c0dc1a959214bf0e0b";
        libraryHaskellDepends = [
          base binary bytestring dlist hashable mtl transformers xhb
          xhb-atom-cache
@@ -141890,7 +142355,7 @@ self: {
      mkDerivation {
        pname = "xhtml";
        version = "3000.2.1";
-       sha256 = "1n6wgzxbj8xf0wf1il827qidphnffb5vzhwzqlxhh70c2y10f0ik";
+       sha256 = "33020782170c1c083bc59fc3bfcb72cec2db223e02d1181c07ae23b9fa7fdcd8";
        libraryHaskellDepends = [ base ];
        homepage = "https://github.com/haskell/xhtml";
        description = "An XHTML combinator library";
@@ -141903,7 +142368,7 @@ self: {
      mkDerivation {
        pname = "xhtml-combinators";
        version = "0.3";
-       sha256 = "06bmdl34kly965qj7phw1hm7p7siwjprflr72n7ck32lrknmy2hk";
+       sha256 = "130a5fedcc548cc98e15275397afe4519f7b2a0c1cde237131c9d349066d7519";
        libraryHaskellDepends = [
          base containers random text transformers xml
        ];
@@ -141917,7 +142382,7 @@ self: {
      mkDerivation {
        pname = "xilinx-lava";
        version = "5.0.1.9";
-       sha256 = "13g44483bcgbfi3366m7l49z40prvr2abml6h6vcjbjnc575cs37";
+       sha256 = "6768564e61562ec9b68186d6a544def902f213a1a71a334674ebb1351021e48d";
        isLibrary = true;
        isExecutable = true;
        libraryHaskellDepends = [
@@ -141933,7 +142398,7 @@ self: {
      mkDerivation {
        pname = "xine";
        version = "0.0.0.4";
-       sha256 = "1mvi486vjf4brg6iks24wvb7gr5n7gdcqzdvv9xnncmxrscr6x36";
+       sha256 = "66749399cebd326b7bdabb7dccda3bb6e477d6e644e819cdcb8b38b90d2271d7";
        libraryHaskellDepends = [ base containers ];
        librarySystemDepends = [ xine ];
        libraryPkgconfigDepends = [ libxine ];
@@ -141952,7 +142417,7 @@ self: {
      mkDerivation {
        pname = "xing-api";
        version = "0.1.3";
-       sha256 = "1z135lcyyq7as166k3vhkqa75a555wbmfhpsdr4rsvpliq4ipqmk";
+       sha256 = "b3e21b098ef46e9d496efa4257172fa5a872149e708f694cd0ea60ef192d23fc";
        isLibrary = true;
        isExecutable = true;
        libraryHaskellDepends = [
@@ -141977,7 +142442,7 @@ self: {
      mkDerivation {
        pname = "xinput-conduit";
        version = "0.0.0";
-       sha256 = "05pcaakqc6krv13480dp7ygr8s2k5wdwr6kixmc9fcp6baa1zkn4";
+       sha256 = "c4ce1f945ae6329758ed719acc1b2f5368949f3fb7014446d8791a86a752ec16";
        libraryHaskellDepends = [
          base bytestring conduit conduit-extra transformers
        ];
@@ -141993,7 +142458,7 @@ self: {
      mkDerivation {
        pname = "xkbcommon";
        version = "0.0.1";
-       sha256 = "1chv156z6208jypl2grjjgbyja4ai3acx65rfyfpqb30987yf0r5";
+       sha256 = "2503e70f4a602c7c9d77b998ced4888a28e9d793323f41af970808f34d091bb2";
        libraryHaskellDepends = [
          base bytestring cpphs data-flags filepath process storable-record
          template-haskell text transformers
@@ -142011,7 +142476,7 @@ self: {
      mkDerivation {
        pname = "xkcd";
        version = "0.1.1";
-       sha256 = "15zwx7rkxm52pnxjhx3p979h48cls1ipb7hmryxll5rcxz9aga29";
+       sha256 = "49a8a7d2ef2c174abbcf159e7563d0942102d349777428bbbda2d43ef3e9fc97";
        isLibrary = false;
        isExecutable = true;
        executableHaskellDepends = [
@@ -142032,7 +142497,7 @@ self: {
      mkDerivation {
        pname = "xlsior";
        version = "0.1.0.1";
-       sha256 = "0dkb3dkc2srvc1951hv6m69z3d7xprsaj7lsdkj9npykqpv6nkgk";
+       sha256 = "f34d6bf6c5d35f9be46c9a1ea974befdb4f193a966c35052603b6bc1661b6b36";
        libraryHaskellDepends = [
          attoparsec base blaze-markup bytestring conduit conduit-extra
          data-default exceptions mtl resourcet scientific text time
@@ -142057,7 +142522,7 @@ self: {
      mkDerivation {
        pname = "xlsx";
        version = "0.1.0.5";
-       sha256 = "0zd3p0dkb4v9gcd3mvp6g64z1gr1m5x0pf2zyj3w7ab0dgz4gzsz";
+       sha256 = "5fff47fe6b60a9c387f45fb80b7aa921bff08979e6ee3a1a7b6993351bb8a37d";
        isLibrary = true;
        isExecutable = true;
        libraryHaskellDepends = [
@@ -142086,7 +142551,7 @@ self: {
      mkDerivation {
        pname = "xlsx-templater";
        version = "0.0.1";
-       sha256 = "00m5x9vhl0rf8azwgin6a75xpj74gybn757021z9dkn1qy35zjwr";
+       sha256 = "99cb5f86c7c1ce967e10e09463977fe4c8dbcb51c6c6c7bf422e030a77eaa502";
        isLibrary = true;
        isExecutable = true;
        executableHaskellDepends = [
@@ -142105,7 +142570,7 @@ self: {
      mkDerivation {
        pname = "xml";
        version = "1.3.14";
-       sha256 = "0g814lj7vaxvib2g3r734221k80k7ap9czv9hinifn8syals3l9j";
+       sha256 = "32d1a1a9f21a59176d84697f96ae3a13a0198420e3e4f1c48abbab7d2425013d";
        libraryHaskellDepends = [ base bytestring text ];
        homepage = "http://code.galois.com";
        description = "A simple XML library";
@@ -142119,7 +142584,7 @@ self: {
      mkDerivation {
        pname = "xml-basic";
        version = "0.1.1.3";
-       sha256 = "0m3pwg8b9pvqh9559p7nq39vnkklmf9gcay8vpvrkh17p8n14z6c";
+       sha256 = "cc7c122cba27c099f7ddc82bf692ab744ebbd3c0f6dc544a8278dfb4d0e37754";
        libraryHaskellDepends = [
          base containers data-accessor explicit-exception utility-ht
        ];
@@ -142135,7 +142600,7 @@ self: {
      mkDerivation {
        pname = "xml-catalog";
        version = "1.1.0.2";
-       sha256 = "0jzi63v8v2ksrqrk13pcl10awx57i2vm0k8xgi01rr1ncmlrnyfc";
+       sha256 = "cc799b696536e41c407c1d4d50b788a774ae40a0ec8e3033ce7a8a8df630f14b";
        libraryHaskellDepends = [
          base bytestring conduit containers text transformers uri-conduit
          xml-conduit
@@ -142156,7 +142621,7 @@ self: {
      mkDerivation {
        pname = "xml-conduit";
        version = "1.3.1";
-       sha256 = "094gkf3j7xk42km9zlkjdz0bicwxcf4207q1yalwi69zfnqmprhr";
+       sha256 = "19e65bb1753f99c8a9f2011f2088639db3b8c06f72d29fea1464f623879b8f24";
        libraryHaskellDepends = [
          attoparsec base blaze-builder blaze-html blaze-markup bytestring
          conduit conduit-extra containers data-default deepseq monad-control
@@ -142179,7 +142644,7 @@ self: {
      mkDerivation {
        pname = "xml-conduit-parse";
        version = "0.3.0.0";
-       sha256 = "0dhg2wgb7gbyn5h1z8fq813l158c49lazfxp1kx9p5jfbc12kk7s";
+       sha256 = "facc29025b4e969bfa0cb7bbaf68220c95404740d8a11f60b17ebdb31e170f36";
        libraryHaskellDepends = [
          base conduit conduit-parse containers exceptions parsers text
          xml-conduit xml-types
@@ -142200,7 +142665,7 @@ self: {
      mkDerivation {
        pname = "xml-conduit-writer";
        version = "0.1.1.1";
-       sha256 = "1ibiqxjr63gb3v0h9fdfzm205sqjixb5vm5y6413yn4scbf7qm2b";
+       sha256 = "4b547cdc629a583f0231bed45d568f12eb0244fdaeb904c11eeb0d9365c771c5";
        libraryHaskellDepends = [
          base containers dlist mtl text xml-conduit xml-types
        ];
@@ -142219,7 +142684,7 @@ self: {
      mkDerivation {
        pname = "xml-enumerator";
        version = "0.4.4.1";
-       sha256 = "0vwn6s7x626970b8lgyhmngkqv5n5kvv0qikrvi9sjzq5rjyx1zj";
+       sha256 = "f287ee652ef84b9de2ce3362b0f72cb66c3c9fadd03f8a1638c908d38f36966f";
        libraryHaskellDepends = [
          attoparsec attoparsec-enumerator base blaze-builder
          blaze-builder-enumerator bytestring containers data-default
@@ -142243,7 +142708,7 @@ self: {
      mkDerivation {
        pname = "xml-enumerator-combinators";
        version = "0.1";
-       sha256 = "1n2lywzbbjkpccpgwlj8ycf4p5wlhjs60hgqzwb33j7qiraf5jb3";
+       sha256 = "63c9e2548ef8c83116fff84160b48494974b1cf34852fe2e6377cab53ef754d8";
        isLibrary = true;
        isExecutable = true;
        libraryHaskellDepends = [
@@ -142260,7 +142725,7 @@ self: {
      mkDerivation {
        pname = "xml-extractors";
        version = "0.4.0.0";
-       sha256 = "02380x94zvm736lj2j02926xn8asc6bq4hbhm3nshh9iw8x4phwq";
+       sha256 = "98c34b3ae23141a8eda870418297615a21db8d48024821a919a7ee4f52076808";
        libraryHaskellDepends = [ base mtl safe transformers xml ];
        jailbreak = true;
        homepage = "https://github.com/holmisen/xml-extractors";
@@ -142275,7 +142740,7 @@ self: {
      mkDerivation {
        pname = "xml-hamlet";
        version = "0.4.0.11";
-       sha256 = "128ypil2c86zpkivrla031hn4rmhbpisy4zj0xmff473hz9qln9x";
+       sha256 = "3d598ad387e310e76a07f213afe35db06662611840d1bce3bcdf202668bc1e89";
        libraryHaskellDepends = [
          base containers parsec shakespeare template-haskell text
          xml-conduit
@@ -142294,7 +142759,7 @@ self: {
      mkDerivation {
        pname = "xml-helpers";
        version = "1.0.0";
-       sha256 = "0rrk0j7m8ws86hbjw0l4ryq4m9i8llhsag2sfisy5r1iv2zwa0lv";
+       sha256 = "9b02c5bfd831e4e275745a3ca521a528a64ab0cf84022e17344873548f043367";
        libraryHaskellDepends = [ base xml ];
        homepage = "http://github.com/acw/xml-helpers";
        description = "Some useful helper functions for the xml library";
@@ -142308,7 +142773,7 @@ self: {
      mkDerivation {
        pname = "xml-html-conduit-lens";
        version = "0.3.2.1";
-       sha256 = "0iy58nq5b6ixdky2xr4r8xxk3c8wqp1y3jbpsk3dr1qawzjbzp12";
+       sha256 = "22dcbfe4e70a87dcc6d477c9e1c3c51cb1317b4799e42efc6c3d9a55b045c547";
        revision = "2";
        editedCabalFile = "6c3305bb07c0fd40c933640ebe9e6114a798115cfb2f3cb976e40f1ece955132";
        libraryHaskellDepends = [
@@ -142330,7 +142795,7 @@ self: {
      mkDerivation {
        pname = "xml-lens";
        version = "0.1.6.3";
-       sha256 = "1s5ivi3caz56g5yyg3pharshs3wcygcssjx1sm9aw4mv3ylz3msd";
+       sha256 = "4dd7f1a91fbb12ae52d5a14badd9f38c0f0d7556f08ee77d79a67cc546dcb1e8";
        revision = "1";
        editedCabalFile = "1a0768a259fb0aeaaecc092c6a9777c4d498d2695b0385a0e620e47f362773b9";
        libraryHaskellDepends = [
@@ -142347,7 +142812,7 @@ self: {
      mkDerivation {
        pname = "xml-monad";
        version = "0.5";
-       sha256 = "17axppy0xzshmvw8y23hxcj2ixm2fqw3hqrjk90qmpkjcv4nk44r";
+       sha256 = "999069c96672de8a419a3263383876a2f62824eb70088ff8ae50ff0efcbd5d9d";
        libraryHaskellDepends = [
          base mtl transformers transformers-compose xml
        ];
@@ -142362,7 +142827,7 @@ self: {
      mkDerivation {
        pname = "xml-parsec";
        version = "1.0.3";
-       sha256 = "1zcmiqyw6bs50kl2417ygvnpsk9wy025ls5ck8cd863x47bqpdn2";
+       sha256 = "c2b68bd7217d18d4189aac685a04f03c4d7ded7efe0422e804452fc33d8e95fd";
        libraryHaskellDepends = [ base HaXml parsec ];
        homepage = "http://sep07.mroot.net/";
        description = "Parsing XML with Parsec";
@@ -142377,7 +142842,7 @@ self: {
      mkDerivation {
        pname = "xml-picklers";
        version = "0.3.6";
-       sha256 = "196iy4z58x58bjk5jy4fpmn8zhiramlyca4rd732i8j3jp6h5f6i";
+       sha256 = "d1b802cd9543a228c6699928e6695539c28f6cbd8e7859a65ca874543ef1d1a4";
        libraryHaskellDepends = [ base containers text xml-types ];
        testHaskellDepends = [
          base Cabal QuickCheck tasty tasty-hunit tasty-quickcheck text
@@ -142392,7 +142857,7 @@ self: {
      mkDerivation {
        pname = "xml-pipe";
        version = "0.0.0.11";
-       sha256 = "0j5fjnf6r7cagcl1ni5idwj1k5q6vjp6c59ajwsx39iqx1kdmly4";
+       sha256 = "c4d3da66e838a6d135972a1566aedc069719246fb1441b287b8a9d6c9c95ae48";
        libraryHaskellDepends = [ base bytestring papillon simple-pipe ];
        homepage = "https://github.com/YoshikuniJujo/xml-pipe/wiki";
        description = "XML parser which uses simple-pipe";
@@ -142405,7 +142870,7 @@ self: {
      mkDerivation {
        pname = "xml-prettify";
        version = "0.1.0.1";
-       sha256 = "1abjmxihh0ldlh8k4mp922s0h39303farmdbm08qn909pbrzm0f0";
+       sha256 = "c081faf3ba09248b11a8abd5acdc00230d08b410e9563211a48d020863af72a9";
        isLibrary = true;
        isExecutable = true;
        libraryHaskellDepends = [ base ];
@@ -142425,7 +142890,7 @@ self: {
      mkDerivation {
        pname = "xml-push";
        version = "0.0.0.18";
-       sha256 = "1i8qmz7mr8rfspkn4wwyq7f7fi1grpggmqmfsmx6l7bjsjv15n3y";
+       sha256 = "7ed812b6d4721d6a7ad5aee2fadecd2f4477dcc19e7362e7d52ea35ccfaf18c5";
        libraryHaskellDepends = [
          base bytestring crypto-random handle-like monad-control monads-tf
          peyotls random sasl simple-pipe stm tighttp transformers-base uuid
@@ -142446,7 +142911,7 @@ self: {
      mkDerivation {
        pname = "xml-to-json";
        version = "2.0.1";
-       sha256 = "0brfdlarr4yyfsfawkfjdbk4z3lvi9ihkhvqh5ws2ll0h80ja6md";
+       sha256 = "ad1a2501828052a1798178c309638a9b8e4fe66ad24dae9c76de939c156d2e2f";
        isLibrary = true;
        isExecutable = true;
        libraryHaskellDepends = [
@@ -142465,7 +142930,7 @@ self: {
      mkDerivation {
        pname = "xml-to-json-fast";
        version = "2.0.0";
-       sha256 = "0gsn8wdiwmvr7nvxbfj9vpzlxwdh8m9lprx2hxnkrnslmbhjz1fx";
+       sha256 = "dd852fe1aa54db3c6d87a2e74b5345b0f14effdd49bad5b73d79571e1b47563f";
        isLibrary = true;
        isExecutable = true;
        libraryHaskellDepends = [ base tagsoup text ];
@@ -142480,7 +142945,7 @@ self: {
      mkDerivation {
        pname = "xml-types";
        version = "0.3.6";
-       sha256 = "1jgqxsa9p2q3h6nymbfmvhldqrqlwrhrzmwadlyc0li50x0d8dwr";
+       sha256 = "9937d440072552c03c6d8ad79f61e61467dc28dcd5adeaad81038b9b94eef8c9";
        libraryHaskellDepends = [ base deepseq text ];
        homepage = "https://john-millikin.com/software/haskell-xml/";
        description = "Basic types for representing XML";
@@ -142492,7 +142957,7 @@ self: {
      mkDerivation {
        pname = "xml2html";
        version = "0.2.0";
-       sha256 = "1kf4vjg4cfkd4vx8jpikbb0ib4pglmyf5vqrg3j0yllmycj22ska";
+       sha256 = "6a6a2124f395520fe47819efe27ca5ef9215c15a335e89fa266d3a469edcc4cd";
        libraryHaskellDepends = [ base xml-conduit ];
        homepage = "http://github.com/snoyberg/xml";
        description = "blaze-html instances for xml-conduit types (deprecated)";
@@ -142508,7 +142973,7 @@ self: {
      mkDerivation {
        pname = "xml2json";
        version = "0.2.0.0";
-       sha256 = "15x3339qqy75qyj97dc7qbw7fs5dw4xvcslfrjpi36yd2596hamx";
+       sha256 = "bd2a685211cd9b11afcc8e6ab63be1ad6877f8c287b593a4c7e5788cd318a397";
        isLibrary = true;
        isExecutable = true;
        libraryHaskellDepends = [
@@ -142538,7 +143003,7 @@ self: {
      mkDerivation {
        pname = "xml2x";
        version = "0.4.2";
-       sha256 = "0cp21xzzqczb49mpnsxlgc4fyhmmgyy4mfczqnz85h383js5sbia";
+       sha256 = "2a2e5db41c68c082bec59fb94abc7fb542ef087bb46b7b6b22eb33fc7f0fe232";
        isLibrary = false;
        isExecutable = true;
        executableHaskellDepends = [
@@ -142557,7 +143022,7 @@ self: {
      mkDerivation {
        pname = "xmlgen";
        version = "0.6.2.1";
-       sha256 = "1rmsg9wxs0bsj0xpagxrm3fmlqd63b0dfyc21rx9jj76g9za29wh";
+       sha256 = "9027a17e7ae648997a0e8279d7c01aa6615adda8b93f753b907a01dd797abae6";
        libraryHaskellDepends = [
          base blaze-builder bytestring containers mtl text
        ];
@@ -142576,7 +143041,7 @@ self: {
      mkDerivation {
        pname = "xmlhtml";
        version = "0.2.3.4";
-       sha256 = "0cv5jqzbq7mi5lcrnaxr5qaprp8biv1jlyzpjhwnwqzla6fqamfr";
+       sha256 = "d955859d51f4636e3994f77b2ac38e0bdd7c152eb92b9b192db11ebc3e966533";
        revision = "1";
        editedCabalFile = "17e37eb81bbdd03eea4b12e65bd4a00e789bc7a04b792f138dc9056c488443a9";
        libraryHaskellDepends = [
@@ -142595,7 +143060,7 @@ self: {
      mkDerivation {
        pname = "xmltv";
        version = "0.0.1";
-       sha256 = "15i0a28svafjsziz1h3px0qys81xw0bs5bpq66hcwzxdv3s15lv9";
+       sha256 = "69d312f4d8ad7fcea031f8aea217e03d20ed31e877c0f0e3d7d2a9ad91502096";
        isLibrary = true;
        isExecutable = true;
        libraryHaskellDepends = [ base old-locale time xml ];
@@ -142617,7 +143082,7 @@ self: {
      mkDerivation {
        pname = "xmms2-client";
        version = "0.0.7.0";
-       sha256 = "0ahsxah1irfsbgkkr4vnvasb7shk4b5iyjhgpj2dc9vi26p6y5dz";
+       sha256 = "bf156fae117127d684bc0f4a1fcb2213eab3b4da76933ce75bdae518a0ea1a2a";
        libraryHaskellDepends = [
          base containers haskell98 mtl utf8-string
        ];
@@ -142632,7 +143097,7 @@ self: {
      mkDerivation {
        pname = "xmms2-client-glib";
        version = "0.0.7.0";
-       sha256 = "1rrc8w9nrmxl8kzjkbmdxh0j1krvai396mx50wsnlqn1cxgb54h3";
+       sha256 = "0392b25e67c1626a3507a5579346543bcf2001ecadae29ff44b4d76c13472ce7";
        libraryHaskellDepends = [ base haskell98 xmms2-client ];
        libraryToolDepends = [ c2hs ];
        description = "An XMMS2 client library — GLib integration";
@@ -142650,7 +143115,7 @@ self: {
      mkDerivation {
        pname = "xmobar";
        version = "0.23.1";
-       sha256 = "0yjnymiw518pjcks0kvpbj73kf0dvl1aj3a40qgmdf5xff1mac9v";
+       sha256 = "3b31558373bdb8561f06440da902dd0db8398e5c774fa027931785c263f5567a";
        configureFlags = [ "-fall_extensions" ];
        isLibrary = false;
        isExecutable = true;
@@ -142676,7 +143141,7 @@ self: {
      mkDerivation {
        pname = "xmonad";
        version = "0.11.1";
-       sha256 = "1pfjssamiwpwjp1qqkm9m9p9s35pv381m0cwg6jxg0ppglibzq1r";
+       sha256 = "39e0bf227df782d7a5799c811ad0d8b70c9d6eaaa94e8cc395fcf25895d6d2dd";
        isLibrary = true;
        isExecutable = true;
        libraryHaskellDepends = [
@@ -142696,7 +143161,7 @@ self: {
      mkDerivation {
        pname = "xmonad-bluetilebranch";
        version = "0.9.1.4";
-       sha256 = "1ymn56rc9kkzvdla9bpj3aq2z6rnz669xbj7n87z1b42aj74s8gn";
+       sha256 = "f6214d8e5482acf00fb247ae9e8cf9369b2fb01af2aea468db7fcec4b229b6fa";
        isLibrary = true;
        isExecutable = true;
        libraryHaskellDepends = [
@@ -142718,7 +143183,7 @@ self: {
      mkDerivation {
        pname = "xmonad-contrib";
        version = "0.11.4";
-       sha256 = "1g5cw9vvnfbiyi599fngk02zlmdhrf82x0bndhypkn6kybab6yd3";
+       sha256 = "a379b3d4f2d3d8793d6c76812e90cbb055fa0598cfba944af47139bb77e2acbc";
        revision = "1";
        editedCabalFile = "0280216420efaa06de7080d5998a24e27166e8b2c3d8a012846d004799c5edf2";
        libraryHaskellDepends = [
@@ -142738,7 +143203,7 @@ self: {
      mkDerivation {
        pname = "xmonad-contrib-bluetilebranch";
        version = "0.9.1.4";
-       sha256 = "1ysf8yp8jwf7a1am83w5q66ys3j6kn7ss0i86n9dmfmkc3rms6l7";
+       sha256 = "871a5df360b3bada92352802ad8f9d460eed8dc1850f545550c77189ae474efb";
        libraryHaskellDepends = [
          base containers directory extensible-exceptions mtl old-locale
          old-time process random unix utf8-string X11 X11-xft
@@ -142756,7 +143221,7 @@ self: {
      mkDerivation {
        pname = "xmonad-contrib-gpl";
        version = "0.12.1";
-       sha256 = "1xs9qwzq9x552jw9wxdaddk2w1m5kc060mqahhk2f2q3zs9nk2n9";
+       sha256 = "c98a6993fe030b2726840a5760009ba5062e666baa759eb814a5f4843fc749f7";
        libraryHaskellDepends = [ base mtl xmonad xmonad-contrib ];
        homepage = "http://xmonad.org/";
        description = "Third party extensions for xmonad";
@@ -142770,7 +143235,7 @@ self: {
      mkDerivation {
        pname = "xmonad-entryhelper";
        version = "0.1.0.0";
-       sha256 = "1xwjdy7swc4bqqx0y7bny7rci4wpq2318m9nbz365x2r7i379v9h";
+       sha256 = "30ed74463c59f462c65f36551486c09793c8f2f1761d0f3ac68b30ae8f6f92f7";
        libraryHaskellDepends = [
          base directory extensible-exceptions filepath mtl process unix X11
          xmonad xmonad-contrib
@@ -142787,7 +143252,7 @@ self: {
      mkDerivation {
        pname = "xmonad-eval";
        version = "0.1";
-       sha256 = "0k0lb4z50kj4q3dzmii4pd8lbdnlxh5l91fx4f90a35hl3v9zggk";
+       sha256 = "f3bd9ff6a0b00c059223dd85440becd4b64551bb24c6fadbc0444e503e59144c";
        libraryHaskellDepends = [
          base containers directory hint mtl old-locale old-time process
          random unix X11 xmonad xmonad-contrib
@@ -142807,7 +143272,7 @@ self: {
      mkDerivation {
        pname = "xmonad-extras";
        version = "0.12.1";
-       sha256 = "14g8i3rvfiqp6mq1xhw8f9q0svcfz5nhlsgbz20zlk1az7673z55";
+       sha256 = "a5fc71ccf92a4cfa81f8eb690a6df98e6d0d707288c31e70351747b7f388e891";
        configureFlags = [
          "-f-with_hlist" "-fwith_parsec" "-fwith_split"
        ];
@@ -142826,7 +143291,7 @@ self: {
      mkDerivation {
        pname = "xmonad-screenshot";
        version = "0.1.2";
-       sha256 = "1m7bmdhc1nlwflli1ymnjlmysg9d54w0shpxq05xwmiycg4jbwr1";
+       sha256 = "21f325c9633e56de0bc0fd420d38292d3ded2b95b6fa1029759cdac060abebd4";
        libraryHaskellDepends = [ base gtk xmonad ];
        homepage = "https://github.com/supki/xmonad-screenshot";
        description = "Workspaces screenshooting utility for XMonad";
@@ -142838,7 +143303,7 @@ self: {
      mkDerivation {
        pname = "xmonad-utils";
        version = "0.1.3.3";
-       sha256 = "1y72f8dnjbpf4kmg0fp8rfbvhwshkp10g4cj3yhy9z78w84dp9a5";
+       sha256 = "45a5db08e2e8fce4a11f929107c29d5073b897cbe83af0ea24ee2e691b72e2f8";
        isLibrary = false;
        isExecutable = true;
        executableHaskellDepends = [ base ghc random unix X11 ];
@@ -142854,7 +143319,7 @@ self: {
      mkDerivation {
        pname = "xmonad-windownames";
        version = "0.1.0.0";
-       sha256 = "1w1f0v81dnbxkmavk5d3hbnanx24yzrqacg4m8j4w36k041w7zn9";
+       sha256 = "c9fec30301d30c4e24aae43185f3f74474abec82a395b9559d7dd916d0062ef0";
        libraryHaskellDepends = [
          base containers utf8-string xmonad xmonad-contrib
        ];
@@ -142871,7 +143336,7 @@ self: {
      mkDerivation {
        pname = "xmpipe";
        version = "0.0.0.4";
-       sha256 = "09g11mfq93w3097rzydva8qwq1sjq0hwi11lg1x1yshwcb1if2iw";
+       sha256 = "3c0a17c3621c6a1f7a783484c821c05207cc3152bbf99f4f02838f845d0de125";
        libraryHaskellDepends = [
          base base64-bytestring bytestring handle-like monads-tf sasl
          simple-pipe uuid xml-pipe
@@ -142887,7 +143352,7 @@ self: {
      mkDerivation {
        pname = "xorshift";
        version = "2.0.1";
-       sha256 = "1pgkcnsgir8ci3hm3s5w3lk5dy7219242g9njx9cxb1m1cz5v5rf";
+       sha256 = "2e975d3e0b35acce5297363d41440ae2f856261dbce851e1880ce5f8b465f3dd";
        libraryHaskellDepends = [ base random time ];
        description = "Haskell implementation of the xorshift random generator";
        license = "LGPL";
@@ -142898,7 +143363,7 @@ self: {
      mkDerivation {
        pname = "xosd";
        version = "0.2.1";
-       sha256 = "1j0j64668vi0jxrzxrwyp8gwcz5zpaiai2r5k5rfsfrglhrhvhrv";
+       sha256 = "3bc30d33a42f3bed7299258ba8a2babf7cc61fba9ee7fe7397206e640c3112c8";
        libraryHaskellDepends = [ base ];
        librarySystemDepends = [ xosd ];
        homepage = "http://code.haskell.org/~dons/code/xosd";
@@ -142913,7 +143378,7 @@ self: {
      mkDerivation {
        pname = "xournal-builder";
        version = "0.1.1.1";
-       sha256 = "0v7lfhyr28gmsbzizhbw4lddhhhv74y3vb8kb9z06b32lg5wm591";
+       sha256 = "2195cacba3622c037e5a13ad3d3c391b42d81a257cc11fffd2f521913d74f46c";
        libraryHaskellDepends = [
          base blaze-builder bytestring double-conversion strict
          xournal-types
@@ -142932,7 +143397,7 @@ self: {
      mkDerivation {
        pname = "xournal-convert";
        version = "0.1.1";
-       sha256 = "1vyykx5kbq8jja6cxy38j905b23ndj73xsg0hirz0sq4pw36shmi";
+       sha256 = "b1426d06bf046bf07384e0e93e8e6c768855409268f8ce8c9212e1354b9fdeef";
        isLibrary = true;
        isExecutable = true;
        libraryHaskellDepends = [
@@ -142956,7 +143421,7 @@ self: {
      mkDerivation {
        pname = "xournal-parser";
        version = "0.5.1";
-       sha256 = "07b1gflqsjsydn304vw6zwgwlc0g7riv0b80lr165mw6c2fkmx78";
+       sha256 = "e8f43a9d6086d76242a6002db0633e0f30ca1fff866f02866d5e4b8da97b611d";
        libraryHaskellDepends = [
          attoparsec attoparsec-conduit base bytestring conduit conduit-extra
          containers exceptions lens mtl strict text transformers xml-conduit
@@ -142975,7 +143440,7 @@ self: {
      mkDerivation {
        pname = "xournal-render";
        version = "0.6.0";
-       sha256 = "0fsijjzxizhb7dx1pc83rsini8xzqj21mmkqj1x0ysyzh78siaf3";
+       sha256 = "c3a9a8d181df6b0f7a9078d61a84c4bfa368a3ce03b11b7a3b0bfed8bf94513b";
        libraryHaskellDepends = [
          base bytestring cairo containers fclabels mtl poppler strict
          TypeCompose xournal-types
@@ -142993,7 +143458,7 @@ self: {
      mkDerivation {
        pname = "xournal-types";
        version = "0.5.1";
-       sha256 = "1ii4d560wvy6iky09wbz2kdf370y87ldgr0ymsv50d7cqxfgbjap";
+       sha256 = "57c9f55cc7ec3450b6ae1ee4d7e8411e9ce1da147ff104fc8cc66f0e4c6924c6";
        libraryHaskellDepends = [
          base bytestring cereal containers lens strict TypeCompose
        ];
@@ -143009,7 +143474,7 @@ self: {
      mkDerivation {
        pname = "xsact";
        version = "1.7.3";
-       sha256 = "180svhrkj3fp69abg0ichgc9l6iv760j302bb612qzxkpyjsyz0h";
+       sha256 = "107cafa5bfb37f2c82594b802181393b1a9ad8832c82b75432d70d3933dc1aa0";
        isLibrary = false;
        isExecutable = true;
        executableHaskellDepends = [
@@ -143029,7 +143494,7 @@ self: {
      mkDerivation {
        pname = "xsd";
        version = "0.5.0.1";
-       sha256 = "1a5i2idpkm5i70jpp2kjglpylja4b9cd0nklgvl6lm8cpjn2j0k0";
+       sha256 = "600229acbc0c556ae87e745ad0585a4449ea2f7d728a7b2538b1d4795b14b1a8";
        libraryHaskellDepends = [ attoparsec base lens text time ];
        testHaskellDepends = [
          base directory doctest filepath QuickCheck quickcheck-instances
@@ -143044,7 +143509,7 @@ self: {
      mkDerivation {
        pname = "xsha1";
        version = "0.0.0";
-       sha256 = "0xljcmc8rsvkpchrdam3lpp4igq1gmym9v3drp15a9k8rfa8irmi";
+       sha256 = "b1e68894cb682655c2cd6dec547d7d01bf48eea5a3aa9621bb73eb8c58659276";
        libraryHaskellDepends = [ base HUnit QuickCheck uniplate vector ];
        description = "cryptanalysis of Blizzard's broken SHA-1 implementation";
        license = stdenv.lib.licenses.mit;
@@ -143055,7 +143520,7 @@ self: {
      mkDerivation {
        pname = "xslt";
        version = "0.1";
-       sha256 = "0i03ihk0rjj6vk2blqdhqqqk6qqrrkxx2ckigwd5mgvp3jp64648";
+       sha256 = "881862ae1c77bf5a1a7f7132d1fbcc19633331c6b061bac4dc46ca0c268c0344";
        libraryHaskellDepends = [ base libxml ];
        librarySystemDepends = [ xslt ];
        description = "Binding to libxslt";
@@ -143070,7 +143535,7 @@ self: {
      mkDerivation {
        pname = "xss-sanitize";
        version = "0.3.5.6";
-       sha256 = "1j2qrn2dbfx01m7zyk9ilgnp9zjwq9mk62b0rdal4zkg4vh212h0";
+       sha256 = "008a20e0266f7e4255cb6009336bc25cfe74eda3314dff4f0da0bbd584cd58c8";
        libraryHaskellDepends = [
          attoparsec base containers css-text network-uri tagsoup text
          utf8-string
@@ -143089,7 +143554,7 @@ self: {
      mkDerivation {
        pname = "xtc";
        version = "1.0.1";
-       sha256 = "0jfs3qbcx5h26irkq73dyc2m84qyrlj5dvy6d1s6p6520vhnqfal";
+       sha256 = "54396ce106a2986b7468c6ef5624cd1e135405f36d1c3c73340296ce161eda49";
        libraryHaskellDepends = [ base wx wxcore ];
        homepage = "http://github.com/alanz/xtc";
        description = "eXtended & Typed Controls for wxHaskell";
@@ -143101,7 +143566,7 @@ self: {
      mkDerivation {
        pname = "xtest";
        version = "0.2";
-       sha256 = "118xxx7sydpsvdqz0x107ngb85fggn630ysw6d2ckky75fmhmxk7";
+       sha256 = "67f60aab2bc7cfc944335c7b308c7dcf15b49e3d2074f071dbfa36af4fef1d85";
        libraryHaskellDepends = [ base X11 ];
        librarySystemDepends = [ libXtst ];
        description = "Thin FFI bindings to X11 XTest library";
@@ -143115,7 +143580,7 @@ self: {
      mkDerivation {
        pname = "xturtle";
        version = "0.1.25";
-       sha256 = "161fpfvzbz2kks5pxmq3wrkgfkrfjvqrl4izlq0v7sicqphfkgmd";
+       sha256 = "adbee9e0c52ceab301a63f129af1962e4ff766e603d77e8b9e53fcf5b7bb2e98";
        libraryHaskellDepends = [
          base convertible Imlib setlocale X11 X11-xft x11-xim yjsvg yjtools
        ];
@@ -143130,7 +143595,7 @@ self: {
      mkDerivation {
        pname = "xxhash";
        version = "0.0.1";
-       sha256 = "0crmvkvk2604a06jjsn613bxx0n1lv59picl2656rx2pc7wbyidn";
+       sha256 = "b645bff86157f46c8a1194c59bcaa6c182ded708c66a290d50041831f7dc3533";
        revision = "1";
        editedCabalFile = "1d641797e9e431c6152dc41cbe72551bb2f91cec8265d3a5e3b2b9718764d274";
        libraryHaskellDepends = [ base bytestring crypto-api tagged ];
@@ -143147,7 +143612,7 @@ self: {
      mkDerivation {
        pname = "y0l0bot";
        version = "0.1.1";
-       sha256 = "0gjvnl5px7ir2lf7arpiji324n32mc1a90x3w6vh5xcyb13wvkv9";
+       sha256 = "69cfcd47589ef502b7e1a383a402ab6258224694f166751c15399e7e0bb55b3e";
        isLibrary = false;
        isExecutable = true;
        executableHaskellDepends = [
@@ -143165,7 +143630,7 @@ self: {
      mkDerivation {
        pname = "yabi";
        version = "0.1.1.0";
-       sha256 = "05avn1m1mmgvzx9vkjy0fyyy38vmz39km0b190lz7lhy9qrwa2bb";
+       sha256 = "6b09c5334e1ed2f3294861813ad3f875a3e1bd77c0cbb953fffbd51a6ab05b15";
        isLibrary = false;
        isExecutable = true;
        executableHaskellDepends = [ base word8 ];
@@ -143181,7 +143646,7 @@ self: {
      mkDerivation {
        pname = "yabi-muno";
        version = "0.1.0.1";
-       sha256 = "169ndqawpkaj43iq6mbddqxprc7w6lsv3ws8a7cq7nmyn7n3r0jg";
+       sha256 = "4f823cecb1beda83d95148f3b13535fcb07c3b6e6d5583e32052cdcb156e3699";
        isLibrary = true;
        isExecutable = true;
        libraryHaskellDepends = [
@@ -143201,8 +143666,8 @@ self: {
      }:
      mkDerivation {
        pname = "yackage";
-       version = "0.7.0.8";
-       sha256 = "1wp7vqlnwxiq4fi0dly25n9jxqi1rpgngd5dn4w4gqla1mqpb43c";
+       version = "0.8.0";
+       sha256 = "b42c5fe3b93dbb4c900f462c60e5f6286aed679664e8a4ccdddae7f56f042015";
        isLibrary = false;
        isExecutable = true;
        executableHaskellDepends = [
@@ -143224,7 +143689,7 @@ self: {
      mkDerivation {
        pname = "yahoo-finance-conduit";
        version = "0.1.0.0";
-       sha256 = "1kvs12l84lgs26knrqv5f354a3bql3fg54wgnmsfcjli1vvnn1di";
+       sha256 = "b1056bf70e914ae674b58f93f2dca0780d45ca7065e36ca711fa5182a8087acf";
        libraryHaskellDepends = [
          attoparsec base cassava conduit lens mtl text vector wreq
        ];
@@ -143238,7 +143703,7 @@ self: {
      mkDerivation {
        pname = "yahoo-web-search";
        version = "0.2";
-       sha256 = "064qakx4khzz9ih9isw46c8pm8wpg662fwnis4d64nszy6y9yfck";
+       sha256 = "93399fbcf15f5b621ad1d172278c7997a37a113384eb98604cffc349fa549818";
        libraryHaskellDepends = [ base HTTP network xml ];
        homepage = "http://www.people.fas.harvard.edu/~stewart5/code/yahoo-web-search";
        description = "Yahoo Web Search Services";
@@ -143251,7 +143716,7 @@ self: {
      mkDerivation {
        pname = "yajl";
        version = "0.3.2";
-       sha256 = "07186ilac22zym1jlgl915k2a82k418xa5z9h40ss62dgmaz2xkk";
+       sha256 = "7376f1557d4d18ad0181e917d551205320256609893e2a43f55f08a66834281c";
        libraryHaskellDepends = [ base bytestring text ];
        librarySystemDepends = [ yajl ];
        libraryToolDepends = [ c2hs ];
@@ -143268,7 +143733,7 @@ self: {
      mkDerivation {
        pname = "yajl-enumerator";
        version = "0.4.1";
-       sha256 = "0dz81l58qpm3gk7zmvb702qwgq79j7d0dnyimqi6k3fp0byb5wdj";
+       sha256 = "b2f1b2fc02d78d6922aed1db06da91e9e0c7b10067edfacf7ca35e8c0a0de837";
        libraryHaskellDepends = [
          base bytestring enumerator json-types text transformers yajl
        ];
@@ -143284,7 +143749,7 @@ self: {
      mkDerivation {
        pname = "yall";
        version = "0.2.1";
-       sha256 = "131x7hl309zpwl31k6mwqd4fdrhkcwxvn4dvlky9bh3prc8kdm2s";
+       sha256 = "5ad43611cb77c095fca4bb11bb3b6713e6e648c3bc9a1906e5f72730283c3d8c";
        libraryHaskellDepends = [ base categories transformers ];
        homepage = "http://brandon.si/code/yall/";
        description = "Lenses with a southern twang";
@@ -143296,7 +143761,7 @@ self: {
      mkDerivation {
        pname = "yamemo";
        version = "0.6.0";
-       sha256 = "12qh9fi5dj4i5lprm24gc2b66qzc3mf59m22sxf93sx3dsf7rygn";
+       sha256 = "f6f97c9c6ea3eb915cd742d4545c1dec636396608f889a2f2d91c856a24b108b";
        libraryHaskellDepends = [ base containers mtl ];
        description = "Simple memoisation function";
        license = stdenv.lib.licenses.bsd3;
@@ -143311,7 +143776,7 @@ self: {
      mkDerivation {
        pname = "yaml";
        version = "0.8.12";
-       sha256 = "0nmpc1n80sv2bjqhzq5jdhd0zxzz9vka31y7k54fmdwr2jbg879i";
+       sha256 = "311df4961499b7ea4899c787a1e64efff70f1a6cb2e00fb15c626b806c60b75a";
        isLibrary = true;
        isExecutable = true;
        libraryHaskellDepends = [
@@ -143336,7 +143801,7 @@ self: {
      mkDerivation {
        pname = "yaml-config";
        version = "0.2.2";
-       sha256 = "1a6n18q6sy5sfw4r8j42d4vhcmvjggi2ax4i89ap2gmnah53jm50";
+       sha256 = "a054390a54b63e715542917425e27b72570637698248940977ba786d300ad6a8";
        libraryHaskellDepends = [
          base deepseq failure text unordered-containers yaml
        ];
@@ -143354,7 +143819,7 @@ self: {
      mkDerivation {
        pname = "yaml-light";
        version = "0.1.4";
-       sha256 = "05pxkqp91l275n48p1aqijzh34vvzi7cx2nls879b95fz2dr8lhk";
+       sha256 = "1352949bf8aea4950ed2d48ace4efc7b9301bf8c58858b882d47d0902e9efd16";
        libraryHaskellDepends = [ base bytestring containers HsSyck ];
        description = "A light-weight wrapper with utility functions around HsSyck";
        license = stdenv.lib.licenses.bsd3;
@@ -143367,7 +143832,7 @@ self: {
      mkDerivation {
        pname = "yaml-light-lens";
        version = "0.3.3";
-       sha256 = "0apl8j5i8mbn1rqmv4wk5rhhh2zcpfqsh2q6d1sl798x96c72v8y";
+       sha256 = "1e6d7198491da5437568060ba8b1bbec0b08612e93935d710e7655148b44f42a";
        libraryHaskellDepends = [
          base bytestring bytestring-lexing containers lens yaml-light
        ];
@@ -143384,7 +143849,7 @@ self: {
      mkDerivation {
        pname = "yaml-rpc";
        version = "1.0.3";
-       sha256 = "01ir8yh7g3xvybg2nyfnzci0xlqpizkdkyhd8jfhyk8yka6jbr9g";
+       sha256 = "2fe5258d9a1e4d0f9d440dfad9e68f17d30e22fbd6792bdef2bb8f77a0473906";
        libraryHaskellDepends = [
          aeson base bytestring containers http-client http-types lens
          template-haskell text th-lift transformers unordered-containers
@@ -143403,7 +143868,7 @@ self: {
      mkDerivation {
        pname = "yaml-rpc-scotty";
        version = "1.0.2";
-       sha256 = "1kbvziqd78fr47m3w86hc6pxa6jy3ljjwc0s2ga0d8zrh0irf3b3";
+       sha256 = "630d972380f9a306d4131a302e251d5e1ad5af61d0203eea21d9a1d370fc7bcd";
        libraryHaskellDepends = [
          aeson base containers http-types mmorph scotty text transformers
          yaml yaml-rpc
@@ -143421,7 +143886,7 @@ self: {
      mkDerivation {
        pname = "yaml-rpc-snap";
        version = "1.0.3";
-       sha256 = "17csdfr4g0vb46yi2jhf6phin17rcn9arc71kmgdgx0xh2hrfin9";
+       sha256 = "c94697a1801df4d75e9de1b0ac9265f9041be1350e4a11bd216b8347b26b9a9d";
        libraryHaskellDepends = [
          aeson base bytestring containers http-types snap text transformers
          yaml yaml-rpc
@@ -143439,7 +143904,7 @@ self: {
      mkDerivation {
        pname = "yaml2owl";
        version = "0.0.1";
-       sha256 = "1yz7cq6xbxjh3j5hljrzla7dpgsa2ag4ywbvc6ynf7bpikdymq65";
+       sha256 = "c5e0eadb8c771d67bd617b714f9e124abfdb8ea23f4b0a8b1c50f6d50d66e7fb";
        isLibrary = false;
        isExecutable = true;
        executableHaskellDepends = [
@@ -143458,7 +143923,7 @@ self: {
      mkDerivation {
        pname = "yamlkeysdiff";
        version = "0.5.1";
-       sha256 = "13s5qiydxcwpp0j8xap556yrlmqs7bsi62ql2c9clr4hpbw8may7";
+       sha256 = "c7ab8af8ba9064ca1213140b13f53a1a579abd29e5aa8e24b897b3de7cc4458f";
        isLibrary = false;
        isExecutable = true;
        executableHaskellDepends = [
@@ -143475,7 +143940,7 @@ self: {
      mkDerivation {
        pname = "yampa-canvas";
        version = "0.2";
-       sha256 = "16plby17rnr4c25sdacqx4vlyx338gbmadp1c6mr4c67zx76bi4a";
+       sha256 = "8ac4654effc73092ab61e13655d74363744f37e998a9a68b6024db7c825ff49a";
        isLibrary = true;
        isExecutable = true;
        libraryHaskellDepends = [ base blank-canvas stm time Yampa ];
@@ -143494,7 +143959,7 @@ self: {
      mkDerivation {
        pname = "yampa-glfw";
        version = "0.1.0.0";
-       sha256 = "133nz8916c99bby6ikkh4kplx4hbwmqhdg0h2g5vsp25w67ndmjr";
+       sha256 = "59d6668fe1455cbdcb1310bc0671e50b924eef2470ce68fc5a29311312fa768c";
        isLibrary = true;
        isExecutable = true;
        libraryHaskellDepends = [ base GLFW-b newtype OpenGL Yampa ];
@@ -143515,7 +143980,7 @@ self: {
      mkDerivation {
        pname = "yampa-glut";
        version = "0.1.1.1";
-       sha256 = "0163whn909s4zzmhgnbs0x90ky6kxvr6630g650i69hhqapbihpp";
+       sha256 = "f7c2b8aec210261341310f0c63f2eed3f80952077ad907ebff4427902ce4c304";
        isLibrary = true;
        isExecutable = true;
        libraryHaskellDepends = [
@@ -143536,7 +144001,7 @@ self: {
      mkDerivation {
        pname = "yampa2048";
        version = "0.1.0.0";
-       sha256 = "03plrnzxsci4fk23h8a992n5al1jc93igf61pskmhx8zgl3j3qmz";
+       sha256 = "bfe221077d1f7558a7bec1b8174762325055ac48492138c4742432ddbfcdf40e";
        isLibrary = false;
        isExecutable = true;
        executableHaskellDepends = [ base gloss random Yampa ];
@@ -143551,7 +144016,7 @@ self: {
      mkDerivation {
        pname = "yaop";
        version = "0.1.2.1";
-       sha256 = "0z66ffxb89bksgqfji9x8msch9yk7nmbzm2qrcn5j3w4ylg7dpdr";
+       sha256 = "b9dd761ef5840f592ccb58d4bfaa3dd327c874453d45e9f0d37325b4ba73c67c";
        revision = "1";
        editedCabalFile = "5333f04af0a27a0197004dc2e686dbbf29e5e2dc248277eb2afcb7587092a55c";
        libraryHaskellDepends = [ base mtl template-haskell ];
@@ -143566,7 +144031,7 @@ self: {
      mkDerivation {
        pname = "yap";
        version = "0.2";
-       sha256 = "14lq549jhgnf51pgy1jv31ik8qx71yl7d53w8dpq1f9mlsn1g16i";
+       sha256 = "d18417aca635b9806f437c9476a80fa7633463185b06ff6e28ce3e2813299892";
        libraryHaskellDepends = [ base ];
        jailbreak = true;
        description = "yet another prelude - a simplistic refactoring with algebraic classes";
@@ -143580,7 +144045,7 @@ self: {
      mkDerivation {
        pname = "yarr";
        version = "1.4.0.1";
-       sha256 = "0kk2yhhh6cjbav30sh68fg880kgdpks018c9gmn4gw98621nc6al";
+       sha256 = "541966833028f1476c7d89a100f4bced4d80d073c8400dc6564b320321f4624e";
        libraryHaskellDepends = [
          base deepseq fixed-vector ghc-prim missing-foreign primitive
          template-haskell
@@ -143596,7 +144061,7 @@ self: {
      mkDerivation {
        pname = "yarr-image-io";
        version = "1.3.2.1";
-       sha256 = "1wmmzw62wb5hz4qavy51wb3wwqn07zd6iiwsrzcck1jdxwy0p81x";
+       sha256 = "3da00b3cef4d86c9d8cf9ac768da3fc062cec7e2a1f8ad30f9b02c2e0cffb5f2";
        libraryHaskellDepends = [ base yarr ];
        librarySystemDepends = [ libdevil ];
        jailbreak = true;
@@ -143612,7 +144077,7 @@ self: {
      mkDerivation {
        pname = "yavie";
        version = "0.0.1";
-       sha256 = "0h2gd0k8vbz8rl34j42ayvcqp0ksz6642k9pznrd28h145wk8gz5";
+       sha256 = "e53f3479210122d1b2fd374d418cf97a828bd9f64a104906cde8af8d26684f40";
        isLibrary = true;
        isExecutable = true;
        libraryHaskellDepends = [
@@ -143629,7 +144094,7 @@ self: {
      mkDerivation {
        pname = "ycextra";
        version = "0.1";
-       sha256 = "0aa0g2r7ck052wqkqqxzvkdqv9d7x3v7rqqd8iajwys9cvqny4m5";
+       sha256 = "a5126ff166497b2e55440de37cf6e8a7a58ddbdcbf633c3117054c76b2784029";
        libraryHaskellDepends = [
          base containers csv mtl uniplate yhccore
        ];
@@ -143646,7 +144111,7 @@ self: {
      mkDerivation {
        pname = "yeganesh";
        version = "2.5";
-       sha256 = "1bgw5v1g5n06jj0lyxpf48mdpaa2s49g0lbagf3jf9q01rb92bvf";
+       sha256 = "6e2f91560e002727877b6a51f012d142a9db2a22ee764f819406d8f2c22efcad";
        isLibrary = false;
        isExecutable = true;
        executableHaskellDepends = [
@@ -143666,7 +144131,7 @@ self: {
      mkDerivation {
        pname = "yeller";
        version = "0.1.0.4";
-       sha256 = "0r9kcjax591v366m5nrm75cy97wr4ykzb7kj1bwsgss21k185a3j";
+       sha256 = "72a882c20c42eba7f90a729ef5a727999fe4593935db528d193ba4d295643365";
        libraryHaskellDepends = [
          aeson base bytestring containers http-client http-client-tls
          http-types network stm text unordered-containers
@@ -143688,7 +144153,7 @@ self: {
      mkDerivation {
        pname = "yes-precure5-command";
        version = "5.5.1";
-       sha256 = "0a5qiz0sx8kbi1ijq8lqjfszp5cvqnq1jpxx18wqndfkscjfsjbd";
+       sha256 = "6d49ed24d3d3358b390abd5f19b0c59b95fbb59398222c63886ba2aec18fb828";
        isLibrary = true;
        isExecutable = true;
        libraryHaskellDepends = [
@@ -143714,7 +144179,7 @@ self: {
      mkDerivation {
        pname = "yesod";
        version = "1.4.1.5";
-       sha256 = "0sr9z3lxnwn5bdfwja97jsya3j0y0i8z5j6mph11bjgjdhv0s5m1";
+       sha256 = "a1160d366cf2c91502bcd5c8f251041ec8a1bc962729c95d5bc572dbe9f8296b";
        libraryHaskellDepends = [
          aeson base blaze-html blaze-markup bytestring conduit-extra
          data-default directory fast-logger monad-control monad-logger safe
@@ -143734,7 +144199,7 @@ self: {
      mkDerivation {
        pname = "yesod-angular";
        version = "0.1.0.1";
-       sha256 = "1f2aghs78jc3v2raq2f07mrcpmkc4jjp2vvpal4bh4qq6jnyigzd";
+       sha256 = "edbfe8ad341813b80855776f71a5246cd6cb723dc009acb2d8834974347c4ab8";
        libraryHaskellDepends = [
          aeson base containers shakespeare template-haskell text
          transformers yesod
@@ -143752,7 +144217,7 @@ self: {
      mkDerivation {
        pname = "yesod-angular-ui";
        version = "0.1.1.0";
-       sha256 = "08rr8w4bibjjchgfp1j9gywldr8v10vg8ddmkxj6dx5b6w2kvm8k";
+       sha256 = "13d53d0537abf466649fb535f436081be546b97f4986eb1e6452aeb808473923";
        libraryHaskellDepends = [
          base blaze-html containers directory hjsmin mtl resourcet
          shakespeare template-haskell text transformers yesod yesod-core
@@ -143777,7 +144242,7 @@ self: {
      mkDerivation {
        pname = "yesod-auth";
        version = "1.4.6";
-       sha256 = "0c0h1pivqk276l0l7nlrwpswvg72x39ikyfzbdnmxgmain878v2x";
+       sha256 = "5d6c74908daabe5e6d5bdff919d3e8e2bccdf5e599da430135474cbce30d1030";
        libraryHaskellDepends = [
          aeson authenticate base base16-bytestring base64-bytestring binary
          blaze-builder blaze-html blaze-markup byteable bytestring conduit
@@ -143801,7 +144266,7 @@ self: {
      mkDerivation {
        pname = "yesod-auth-account";
        version = "1.4.1";
-       sha256 = "18bi75kx89gfzh7vi5p8pcqwip1qfpkab415bmn6pcqrlh3jd90i";
+       sha256 = "11a42607a419b36b6c5d2590a5e67538dcc831bbe896b80ffcee25d4673971a1";
        libraryHaskellDepends = [
          base blaze-html bytestring mtl nonce persistent pwstore-fast text
          yesod-auth yesod-core yesod-form yesod-persistent
@@ -143825,7 +144290,7 @@ self: {
      mkDerivation {
        pname = "yesod-auth-account-fork";
        version = "2.0";
-       sha256 = "0y3xd8iw15il05bpnkicnlv9xznqlirapbr6gmr7lxzjhgddrzyn";
+       sha256 = "d6ffdcda83f2777a727d26afab72a4d8fe9e36b52c4e7b57013496c0236a7d78";
        libraryHaskellDepends = [
          aeson base blaze-html bytestring email-validate http-types mtl
          nonce persistent pwstore-fast random tagged text yesod-auth
@@ -143849,7 +144314,7 @@ self: {
      mkDerivation {
        pname = "yesod-auth-basic";
        version = "0.1.0.2";
-       sha256 = "0b4vyf731wb7idmbqz7n8zm4p7i7y66x94ph7kaxv1jvq05k7bxa";
+       sha256 = "aaaf330bc05b86ddd53cf092d48df1279e4bea47f67cbc6a8b67f1308ef39b2c";
        libraryHaskellDepends = [
          base base64-bytestring bytestring exceptions text wai word8 yesod
        ];
@@ -143865,7 +144330,7 @@ self: {
      mkDerivation {
        pname = "yesod-auth-bcrypt";
        version = "0.2.0";
-       sha256 = "06pbzk09zfnr290sczjpqjrfbbz1c6qig402siakp7lnizav4xz5";
+       sha256 = "e577b2d58f969e3b55d4029017b161e1afe5b2c4577ea64112d9ba9fc0fceb1a";
        libraryHaskellDepends = [
          base bcrypt bytestring text yesod-auth yesod-core yesod-form
          yesod-persistent
@@ -143885,7 +144350,7 @@ self: {
      mkDerivation {
        pname = "yesod-auth-deskcom";
        version = "1.4.0";
-       sha256 = "17lpkwrfc10rdmvkjg6qmbi7gysjjhqyh7n5d1mxgxhzxzqbi06w";
+       sha256 = "dc80b8f0ef1ff6d76b68c51ee8319452fb77e2aad83c39776d1904e6329f979e";
        libraryHaskellDepends = [
          aeson base base64-bytestring byteable bytestring cipher-aes
          cprng-aes crypto-api crypto-random cryptohash data-default
@@ -143905,7 +144370,7 @@ self: {
      mkDerivation {
        pname = "yesod-auth-fb";
        version = "1.7";
-       sha256 = "1kp4vka9sjij8zyp15vj1jkaqwgy483q2gjb5wmhlqwcyp843h02";
+       sha256 = "02c041d0f58c630a2b2f4b3e810722fe71aca60c729770fd47324a9dd4dce4ce";
        libraryHaskellDepends = [
          aeson base bytestring conduit fb http-conduit lifted-base
          shakespeare text time transformers wai yesod-auth yesod-core
@@ -143924,7 +144389,7 @@ self: {
      mkDerivation {
        pname = "yesod-auth-hashdb";
        version = "1.4.2.2";
-       sha256 = "0s2qmpn4iwzdpps7yqcwb63cp8v1za9fp4amg0qc6b0pllzr616r";
+       sha256 = "d904933fa5172cc330785591eb92fa61a3cb86599c617ff4bdedf348ecad5868";
        libraryHaskellDepends = [
          base bytestring cryptohash persistent pwstore-fast text yesod-auth
          yesod-core yesod-form yesod-persistent
@@ -143943,7 +144408,7 @@ self: {
      mkDerivation {
        pname = "yesod-auth-kerberos";
        version = "1.4.2";
-       sha256 = "1q25p6kzk4xksi64gl2k4vdnfiw2pmqmca1w5zwzvdr4zzgkmx18";
+       sha256 = "28f43adfff24b7fdf92f3c285671bd824767db2653d0474cd4b393f9a7b945e0";
        libraryHaskellDepends = [
          authenticate-kerberos base bytestring shakespeare text transformers
          yesod-auth yesod-core yesod-form
@@ -143962,7 +144427,7 @@ self: {
      mkDerivation {
        pname = "yesod-auth-ldap";
        version = "0.0.3";
-       sha256 = "1ps2vk2pvni3h4pk4v2siqb3a714r09ahgr5d1l89hspb9fbzfyk";
+       sha256 = "d3bbbf5c5a57c3846868253fa812c8241c35168e5a6c322f8123da7dc5dc42df";
        libraryHaskellDepends = [
          authenticate-ldap base bytestring hamlet LDAP text transformers
          yesod-auth yesod-core yesod-form
@@ -143981,7 +144446,7 @@ self: {
      mkDerivation {
        pname = "yesod-auth-ldap-mediocre";
        version = "0.1.0.0";
-       sha256 = "03pij218i9lk79n02c2pfrxsxyqi6lzjn5bzg7zgk5a87b6b57jh";
+       sha256 = "509eb2cc3a4895f9fe797f152b3f3511fbae7b765730016c3a93a6888290f10e";
        libraryHaskellDepends = [
          aeson base LDAP text yesod-auth yesod-core yesod-form
        ];
@@ -143997,7 +144462,7 @@ self: {
      mkDerivation {
        pname = "yesod-auth-oauth";
        version = "1.4.0.2";
-       sha256 = "0vwp08rx4bnqx9mr6ixq15s334cdjadhl9n84rs3n1xd94sj1p6l";
+       sha256 = "d4dc203549ad073b7426c8260a9b928d91317409b847936bead82ed23302976f";
        libraryHaskellDepends = [
          authenticate-oauth base bytestring lifted-base text transformers
          yesod-auth yesod-core yesod-form
@@ -144015,7 +144480,7 @@ self: {
      mkDerivation {
        pname = "yesod-auth-oauth2";
        version = "0.1.2";
-       sha256 = "1bprc8n2f591igm5yfrxga7zim5vyib07h413ainhfc7g8pbaky9";
+       sha256 = "c94fb52e7a873968a31a81c00356f4bbd4f88f7a3d3b5fea8b2115272c62f9ae";
        libraryHaskellDepends = [
          aeson authenticate base bytestring hoauth2 http-conduit http-types
          lifted-base network-uri random text transformers yesod-auth
@@ -144034,7 +144499,7 @@ self: {
      mkDerivation {
        pname = "yesod-auth-pam";
        version = "1.0.0.0";
-       sha256 = "02cpg67ldjvv9sb6jr7liq3ac20rqc6lq1wjybii5vsah8hmvkhy";
+       sha256 = "1ece5d21824aef12e3f292074c0dc31908a6068ef46469964e7bcb468f799709";
        libraryHaskellDepends = [
          base hamlet pam text yesod-auth yesod-core yesod-form
        ];
@@ -144050,7 +144515,7 @@ self: {
      mkDerivation {
        pname = "yesod-auth-smbclient";
        version = "2.0.0.0";
-       sha256 = "108bmfb68rvmx3q21hz55jbic331fnplcx062vlbk6sx3jyjqgaa";
+       sha256 = "4a3d2cbd1c5d9bb9e816067446af75610c16972ce5c320f0e875676496ab0b81";
        libraryHaskellDepends = [
          base hamlet sys-auth-smbclient text yesod-auth yesod-core
          yesod-form
@@ -144069,7 +144534,7 @@ self: {
      mkDerivation {
        pname = "yesod-auth-zendesk";
        version = "1.2.1";
-       sha256 = "0jjfydbgjcymd9x47g0acjdml55f3n40193lvl4l9l02q54g9qnb";
+       sha256 = "cbe2f448c102d04409dd74a400881dae145a9b640abc437a6ad533f956f34e4a";
        libraryHaskellDepends = [
          base base16-bytestring bytestring cryptohash data-default
          http-conduit http-types template-haskell text time transformers wai
@@ -144095,8 +144560,8 @@ self: {
      }:
      mkDerivation {
        pname = "yesod-bin";
-       version = "1.4.13.1";
-       sha256 = "1vnqiibdjvkja80b8i352afrhphx8v6nihylgxaywch20b2fbkrc";
+       version = "1.4.13.2";
+       sha256 = "6ba51159341dc4e13e166cd54cd5af414ea1829f25c4d2f15eeac4507339530f";
        isLibrary = false;
        isExecutable = true;
        executableHaskellDepends = [
@@ -144124,7 +144589,7 @@ self: {
      mkDerivation {
        pname = "yesod-bootstrap";
        version = "0.1.0.0";
-       sha256 = "19hzc1k0ssmsi9k4r5bxmngr1h8a42qhaxcl5y99fbf6khpndxzg";
+       sha256 = "eff7662f9cc62d97922f947505b1200ac1909fad7d954c668aba6a0d66601fa6";
        libraryHaskellDepends = [
          base blaze-html blaze-markup conduit conduit-extra containers
          either email-validate lens-family-core lens-family-th MonadRandom
@@ -144144,7 +144609,7 @@ self: {
      mkDerivation {
        pname = "yesod-comments";
        version = "0.9.2";
-       sha256 = "1isw8cwzwwsm7p3hqj0ynwncsdfg7x0ihphyv02awchqbgc2c87i";
+       sha256 = "f12026d85b1832ae04d81e5e18413fcf35cd2cb71e480cc73d5573fe39435cc7";
        libraryHaskellDepends = [
          base bytestring directory friendly-time gravatar old-locale
          persistent template-haskell text time wai yesod yesod-auth
@@ -144164,7 +144629,7 @@ self: {
      mkDerivation {
        pname = "yesod-continuations";
        version = "0.1";
-       sha256 = "1pzc0v18fapfbwd4pn4nchmsp4nvnrkm33av83zqfb5gyzhlk1in";
+       sha256 = "368649e1f7af2c87ff405b8d5167b6db92ab2b6496d84b1a5fee2a87c206ecdf";
        isLibrary = true;
        isExecutable = true;
        libraryHaskellDepends = [
@@ -144193,7 +144658,9 @@ self: {
      mkDerivation {
        pname = "yesod-core";
        version = "1.4.12";
-       sha256 = "1sdp2lg88c9gnwr3ffa8kj2vdd3y2kd7ark4qrm4gab07x2qflq3";
+       sha256 = "035387453f60a9476ac6646675da147eb4b6859c48393732b72f31841e15b7e9";
+       revision = "1";
+       editedCabalFile = "a6f72da0eb68bc2d5da1d8d8aaa758403e5e86f6de3c61cde01376fd51e50c35";
        libraryHaskellDepends = [
          aeson auto-update base blaze-builder blaze-html blaze-markup
          bytestring case-insensitive cereal clientsession conduit
@@ -144224,7 +144691,7 @@ self: {
      mkDerivation {
        pname = "yesod-crud";
        version = "0.1.2";
-       sha256 = "0krjhskrjgymgp0nclggnivy03hmlvfy8c9d9ks4s14jw82rnhf1";
+       sha256 = "c1419b05e292044df44c2d31e4dda6150ee077b4ef5166c17dd53f99a786324f";
        libraryHaskellDepends = [
          base classy-prelude containers MissingH monad-control persistent
          random safe stm uuid yesod-core yesod-form yesod-persistent
@@ -144242,7 +144709,7 @@ self: {
      mkDerivation {
        pname = "yesod-crud-persist";
        version = "0.1.1";
-       sha256 = "171papb9hns62jswqxkg4q41wb8sb72714i4wghx7g8svh17lv28";
+       sha256 = "486c7a02dc1abdd3e1e3249270c4591a2d1e08266f76ccb514465b98d655379c";
        libraryHaskellDepends = [
          base lens persistent text transformers wai yesod-core yesod-form
          yesod-persistent
@@ -144263,7 +144730,7 @@ self: {
      mkDerivation {
        pname = "yesod-datatables";
        version = "0.1.1";
-       sha256 = "0yn6fky83069pp4i13dlx9dlk4ck2k4c6sizgnrwqcjhm39m1bz6";
+       sha256 = "e6af50d3a85032ccb37d3f6ac3c8149391495beab48d10c9bdc98081fc74c67a";
        libraryHaskellDepends = [
          aeson attoparsec base bytestring data-default persistent text yesod
          yesod-auth yesod-core yesod-default yesod-form yesod-static
@@ -144286,7 +144753,7 @@ self: {
      mkDerivation {
        pname = "yesod-default";
        version = "1.2.0";
-       sha256 = "15nsknnxnfbkpg4pswxcpgfb2y0hz0xxj56jknd93hcm7aay36pk";
+       sha256 = "f39ae1953a95c1919a9dd214d93bf81078b1dcbbac737dc9bb7339dbad9dda96";
        libraryHaskellDepends = [ base yesod-core ];
        homepage = "http://www.yesodweb.com/";
        description = "Default config and main functions for your yesod application (deprecated)";
@@ -144301,7 +144768,7 @@ self: {
      mkDerivation {
        pname = "yesod-dsl";
        version = "0.1.1.24";
-       sha256 = "0pr5z3kg27j4fgyzs7ac263wd0qxfa3m45b6fn9hg18lwjb0fgd7";
+       sha256 = "a73d0796e4148507937566155287721d83c687114c1dfdfd73441ef1e6f8255f";
        isLibrary = true;
        isExecutable = true;
        libraryHaskellDepends = [
@@ -144326,7 +144793,7 @@ self: {
      mkDerivation {
        pname = "yesod-eventsource";
        version = "1.4.0.1";
-       sha256 = "0j2x2zfr1s5a8m22kf27r6bdw041vmgf9b4v2ylc89n4m0f0dv55";
+       sha256 = "a5ec061ca8c426c4a8179bace45edd8100de96c947b8294445aae890dd175d48";
        libraryHaskellDepends = [
          base blaze-builder conduit transformers wai wai-eventsource
          wai-extra yesod-core
@@ -144345,7 +144812,7 @@ self: {
      mkDerivation {
        pname = "yesod-examples";
        version = "0.9.0.1";
-       sha256 = "1ikrx9ys8civmf1m12fbms258xa7aj55rr02x3rjwchykmzianp4";
+       sha256 = "e45a157f9d1e322ef3e802e45c8a5447755484aecb895083ab3b32a47dea79c6";
        isLibrary = false;
        isExecutable = true;
        executableHaskellDepends = [
@@ -144370,7 +144837,7 @@ self: {
      mkDerivation {
        pname = "yesod-fay";
        version = "0.8.0";
-       sha256 = "0inx11w4wdgnbxqghm9738qs19519dcdgyjmm3aah12wzv4i68gf";
+       sha256 = "ee2113c9fe5c04a8d4a855fad7584ba1a4a0311a2755f8705ff6354e7808dd46";
        libraryHaskellDepends = [
          aeson base bytestring data-default directory fay fay-dom filepath
          monad-loops process pureMD5 shakespeare template-haskell text
@@ -144388,7 +144855,7 @@ self: {
      mkDerivation {
        pname = "yesod-fb";
        version = "0.3.4";
-       sha256 = "09cymp9y21vawbgr6gcj41s5xkq6j22mvk0vgl3pnyq382j33rmp";
+       sha256 = "b7e631a440037b7b077d1bcc5d859006cf5e7420923d93dfe26a07e1d3ad9e25";
        libraryHaskellDepends = [
          aeson base bytestring conduit crypto-api fb http-conduit text wai
          yesod-core
@@ -144408,7 +144875,7 @@ self: {
      mkDerivation {
        pname = "yesod-form";
        version = "1.4.4.1";
-       sha256 = "14v4vhrbca0281im2bnvk36bm7i1r8yanxhv7lvrq5y5nqbc5bl3";
+       sha256 = "83aec216b6c5179c373d1b76ab3cca219ebacc98db2e5163400228b632dc6493";
        libraryHaskellDepends = [
          aeson attoparsec base blaze-builder blaze-html blaze-markup
          byteable bytestring containers data-default email-validate
@@ -144429,7 +144896,7 @@ self: {
      mkDerivation {
        pname = "yesod-form-json";
        version = "0.0.1";
-       sha256 = "1hr53p4sp0zm7l1ap07kv2q6hi1xli74k13h0df4cmf9y2xn7bxz";
+       sha256 = "bfaf63bbf0c955465c037084494ea43d4468b0d8f380ab023df583abc91d25c3";
        libraryHaskellDepends = [
          aeson base bytestring containers text unordered-containers
          yesod-core yesod-form
@@ -144445,7 +144912,7 @@ self: {
      mkDerivation {
        pname = "yesod-gitrepo";
        version = "0.2.1.0";
-       sha256 = "1v47d6gvw3d19mqip36y54c4d84f48jgybdwgdl8r20zfwvhyvkf";
+       sha256 = "6e6e0f37771f888c687bbc2dff24228ea0461829de8c1b714da10dbe9f6987ec";
        libraryHaskellDepends = [
          base directory enclosed-exceptions http-types lifted-base process
          temporary text wai yesod-core
@@ -144461,7 +144928,7 @@ self: {
      mkDerivation {
        pname = "yesod-gitrev";
        version = "0.1.0.0";
-       sha256 = "0jcgc8l2gh6ahxwddra0jyf78bi4rzff9nfi1knjxixfll73rrih";
+       sha256 = "30e63c0ea5aec72eed0cd1d9e4dccf242e749c9740e5d67887cac02728628f49";
        libraryHaskellDepends = [
          aeson base gitrev template-haskell yesod-core
        ];
@@ -144476,7 +144943,7 @@ self: {
      mkDerivation {
        pname = "yesod-goodies";
        version = "0.0.5";
-       sha256 = "0wxdwyb5dg00ycb09kbl1m12w2bzi6kxbjr4dqgrwfd3dgypcjdz";
+       sha256 = "bf4976fd6ba3399e1f6e24cbd5a7897f092e420d74cd0416f300bc5696e7ad73";
        libraryHaskellDepends = [
          base blaze-html bytestring directory HTTP old-locale pandoc pureMD5
          text time yesod yesod-form
@@ -144493,7 +144960,7 @@ self: {
      mkDerivation {
        pname = "yesod-json";
        version = "1.2.0";
-       sha256 = "0d035k1ls5iq1c12yxknyc33qd22ayyhl69y62zmcw7arwx35sgw";
+       sha256 = "fce9323acfea7056bf303e190abd5742343c06f376762f020b38164dc32c0334";
        libraryHaskellDepends = [ base yesod-core ];
        homepage = "http://www.yesodweb.com/";
        description = "Generate content for Yesod using the aeson package. (deprecated)";
@@ -144505,7 +144972,7 @@ self: {
      mkDerivation {
        pname = "yesod-links";
        version = "0.3.0";
-       sha256 = "0i1b4lgwv98pp7251fm3h4cdb1d868fqwm6175rk7zg699g2v61y";
+       sha256 = "3e982d5e4ae6fd337339c1548e1d32a885d51881a3ba50c4b917a5cd1f252b44";
        libraryHaskellDepends = [ base text yesod-core ];
        jailbreak = true;
        homepage = "http://github.com/pbrisbin/yesod-goodies/yesod-links";
@@ -144519,7 +144986,7 @@ self: {
      mkDerivation {
        pname = "yesod-lucid";
        version = "0.1";
-       sha256 = "1ymmpi9g3pjl23ymdjwiv748lnq1hyjq24la2ffgwrm4b6f41xip";
+       sha256 = "37f6409c59a466fe9c138a1281a587015b8ac8d991cb56fd1054def152bcb5fa";
        libraryHaskellDepends = [ base lucid monads-tf text yesod-core ];
        description = "Lucid support for Yesod";
        license = stdenv.lib.licenses.bsd3;
@@ -144538,7 +145005,7 @@ self: {
      mkDerivation {
        pname = "yesod-mangopay";
        version = "1.11.4";
-       sha256 = "0syg5a0xihrdbclsrbgqgf6llhji7zdn1g50fbvlklfpw4dkb1f7";
+       sha256 = "c785351be1d7d149f772a0bc60db3f51424a8d7bf8adac295b2dc3d8812acf6b";
        isLibrary = true;
        isExecutable = true;
        libraryHaskellDepends = [
@@ -144568,7 +145035,7 @@ self: {
      mkDerivation {
        pname = "yesod-markdown";
        version = "0.10.0";
-       sha256 = "0n9rcpf8s89swj0pz86xddl5zjbkkw1fa1h292wvs15y77lrl0zi";
+       sha256 = "f1039ae939be04bdb9480206e5029f73c95f686bdda07f81e43a218ddc653959";
        libraryHaskellDepends = [
          base blaze-html blaze-markup bytestring directory pandoc persistent
          shakespeare texmath text xss-sanitize yesod-core yesod-form
@@ -144586,7 +145053,7 @@ self: {
      mkDerivation {
        pname = "yesod-media-simple";
        version = "0.1.0.1";
-       sha256 = "1ajlrqsq7x83vc67xqb4r3328akwjp0a0vwf7nvqj3bsjqg5af76";
+       sha256 = "e638551e967a0d89b73d8e6fa0c0957c2a24c6c864e17e0cdb03f58335ce54aa";
        libraryHaskellDepends = [
          base bytestring diagrams-cairo diagrams-core diagrams-lib directory
          JuicyPixels vector yesod
@@ -144603,7 +145070,7 @@ self: {
      mkDerivation {
        pname = "yesod-newsfeed";
        version = "1.4.0.1";
-       sha256 = "02ydkri23vrm7mak2b1ybfhkdgc2dmv9vq3ki2d7sd005sp3zdly";
+       sha256 = "9eb63fae2e00347d9a8873e09d766d82bd36a15b3e2c31553d35ef21629ecd0b";
        libraryHaskellDepends = [
          base blaze-html blaze-markup bytestring containers shakespeare text
          time xml-conduit yesod-core
@@ -144618,7 +145085,7 @@ self: {
      mkDerivation {
        pname = "yesod-paginate";
        version = "0.1";
-       sha256 = "088m7prg774wdh8fp7zljxj65zj5krl4pggl63anv2wk7nlw27py";
+       sha256 = "fe1ec1a93d938b6dd530f4bd4b689e45fe626497f49feb106c9c9cf3f23d1521";
        libraryHaskellDepends = [ base template-haskell yesod ];
        description = "Pagination for Yesod sites";
        license = stdenv.lib.licenses.bsd3;
@@ -144633,7 +145100,7 @@ self: {
      mkDerivation {
        pname = "yesod-pagination";
        version = "2.0.0";
-       sha256 = "0d42b8y7zpl624d7wa2caarni9g10hg14xsbamlkykki3bl197m1";
+       sha256 = "a19e14e81a714e3f69554b77121e04e1a568b3524c287e1a1186de7f3c5a8234";
        libraryHaskellDepends = [ base esqueleto yesod ];
        testHaskellDepends = [
          base hspec monad-logger persistent persistent-sqlite resource-pool
@@ -144652,7 +145119,7 @@ self: {
      mkDerivation {
        pname = "yesod-paginator";
        version = "0.9.1";
-       sha256 = "0xi19gf6vdna3nwwmciypqgaprzb7gdjpwvfrpj82gr6yar1va5m";
+       sha256 = "b5a81db2f2263f81e4cd6ef32bdb3bebe7ab1ebe3eb2cab91dcab66ddc4b2176";
        libraryHaskellDepends = [
          base persistent resourcet text transformers yesod
        ];
@@ -144671,7 +145138,7 @@ self: {
      mkDerivation {
        pname = "yesod-persistent";
        version = "1.4.0.3";
-       sha256 = "0prvrz52c2pr4qsanjzndviyq4f6zc49in69xz5153h2vagbfmb4";
+       sha256 = "6455b79eda028e12caefc9d89808fbc611ece36ef64bab3426f90a26cacf3b5f";
        libraryHaskellDepends = [
          base blaze-builder conduit persistent persistent-template
          resource-pool resourcet transformers yesod-core
@@ -144720,7 +145187,7 @@ self: {
      mkDerivation {
        pname = "yesod-platform";
        version = "1.2.13.3";
-       sha256 = "1j71m9bqam7dl1ghhwvkw5ispp8z06hbkvdxslx5sca998vx9awv";
+       sha256 = "9babd4374a49315d3ad5bdedb9a0011fddab63e17373085fa0ed548557aae1c8";
        libraryHaskellDepends = [
          ansi-terminal ansi-wl-pprint asn1-encoding asn1-parse asn1-types
          attoparsec-conduit authenticate auto-update base base16-bytestring
@@ -144764,7 +145231,7 @@ self: {
      mkDerivation {
        pname = "yesod-pnotify";
        version = "0.5.0";
-       sha256 = "05ic4n6g8jp575qj8mq9lbnhvmdm5zwxn3wf8f1blgigqimamsps";
+       sha256 = "faeaaa6ac42f3eba82438e0fdbf92fb5d50deda20957247139e54af48c252c16";
        libraryHaskellDepends = [
          base shakespeare text transformers yesod yesod-form
        ];
@@ -144779,7 +145246,7 @@ self: {
      mkDerivation {
        pname = "yesod-pure";
        version = "0.1.0.2";
-       sha256 = "0v3xvhk5nxc2y3c21y6h7w6lg5vm1s2vzf9f02qw8gj928vsidzg";
+       sha256 = "efb7a83712493ec4b1002eb9bf850e7597470d3fd0f820d8f082755b26dc7d6c";
        libraryHaskellDepends = [ base fast-logger text yesod yesod-core ];
        jailbreak = true;
        homepage = "https://github.com/snoyberg/yesod-pure";
@@ -144797,7 +145264,7 @@ self: {
      mkDerivation {
        pname = "yesod-purescript";
        version = "0.0.5";
-       sha256 = "0arij86cfzy5hh82gc5l4i3s3z4qa9rfrnj9nrp6q25qhvgiclmy";
+       sha256 = "be5216df86b8086c6eb649daec725298fca14724b4b0271084c57fc70c92312b";
        libraryHaskellDepends = [
          aeson base bytestring containers data-default formatting fsnotify
          mtl purescript regex-tdfa regex-tdfa-text shakespeare system-fileio
@@ -144818,7 +145285,7 @@ self: {
      mkDerivation {
        pname = "yesod-raml";
        version = "0.1.0";
-       sha256 = "1vcllxsyqvr26a27l9vfi76kpdzld3ws1i0q6g9jnwhkr16bmc3f";
+       sha256 = "6eb0ba4cc813722bd33318c4a0f968f4b73bcd896e277a8432226fec75a794ed";
        isLibrary = true;
        isExecutable = true;
        libraryHaskellDepends = [
@@ -144847,7 +145314,7 @@ self: {
      mkDerivation {
        pname = "yesod-recaptcha";
        version = "1.4";
-       sha256 = "1dvbpzcfwmjv836i8g0gv80dj1iwb9gnvgwg3m5h2hi95249m471";
+       sha256 = "e1909a88282942014b1d8fbf6d5f5a3c06d900da0f3c14cd405b56eed8bf6bb7";
        libraryHaskellDepends = [
          base bytestring data-default http-conduit http-types lifted-base
          network network-info resourcet text wai yesod-auth yesod-core
@@ -144865,7 +145332,7 @@ self: {
      mkDerivation {
        pname = "yesod-routes";
        version = "1.2.0.7";
-       sha256 = "00i2nysbhmxnq0dvfdjx6nhxy680ya38nx8gcgm13fv2xwdd2p6j";
+       sha256 = "d25cd11aef62bb11ea630f758b86f20019dfa1355d36b71bc0b657b8b4b72202";
        revision = "1";
        editedCabalFile = "0d622fd91f5c82a3ae54849a9f55e15b39dcc6240f9f2119151362255cd7334e";
        libraryHaskellDepends = [
@@ -144888,7 +145355,7 @@ self: {
      mkDerivation {
        pname = "yesod-routes-flow";
        version = "1.0";
-       sha256 = "1bb0w1910mnzci4mi6r2zxhjy4wsridi5h2g97nqhd65qncq4km0";
+       sha256 = "a04e8299c5c53488ed494fc0125bcc9a132f61ff229b584964df561052e060ad";
        libraryHaskellDepends = [
          attoparsec base classy-prelude system-fileio text yesod-core
        ];
@@ -144905,7 +145372,7 @@ self: {
      mkDerivation {
        pname = "yesod-routes-typescript";
        version = "0.3.0.0";
-       sha256 = "1gn0fvspgwhzpg7pfaj029vdhlm8ypx9kyn2wdz2wzm5jkl7bnn9";
+       sha256 = "c9da75e894a57e2e7ee3c2fa99faf5a852d87612402a77cfbb1ff277f576c0be";
        libraryHaskellDepends = [
          attoparsec base classy-prelude system-fileio text yesod-core
          yesod-routes
@@ -144923,7 +145390,7 @@ self: {
      mkDerivation {
        pname = "yesod-rst";
        version = "0.2.3";
-       sha256 = "1dv8xq7hndpk3d86dxwjjplv0la8fn32pwzb5l00db9cg420jp71";
+       sha256 = "e15c0904792cad06002debf32b86754851b0e99592f766501bf3360b0fee68b7";
        libraryHaskellDepends = [
          base blaze-html directory hamlet pandoc persistent text
          xss-sanitize yesod-core yesod-form
@@ -144942,7 +145409,7 @@ self: {
      mkDerivation {
        pname = "yesod-s3";
        version = "0.1.1";
-       sha256 = "0vl24qa2aidrr7a082yhnscava06x6jf5y5x9fi9jdry3rnkhzbv";
+       sha256 = "7b7d386d1e3e3799a24bbdf8e2a4e906a8ad98b6d00b04d4c9b945251426826e";
        libraryHaskellDepends = [
          base bytestring conduit conduit-extra gd hS3 mtl network resourcet
          text yesod-core
@@ -144960,7 +145427,7 @@ self: {
      mkDerivation {
        pname = "yesod-sass";
        version = "0.1.2.0";
-       sha256 = "0mxk007csmzbrx169jlbg07vqm7ixjrfvjy6xa2lfd5g1xpc7s94";
+       sha256 = "24e9c36e0faf344785eac6cbedb2ecf154bc0f788bca6442cfeb57cd0e00b357";
        libraryHaskellDepends = [
          base data-default hsass shakespeare template-haskell text
          yesod-core
@@ -144977,7 +145444,7 @@ self: {
      mkDerivation {
        pname = "yesod-session-redis";
        version = "0.1.0";
-       sha256 = "06ilc1xjic66xj46nib8y6cq7n8hyc27kzz9zd001d12qh342brv";
+       sha256 = "3b2f4106c422b40040fbe9ff7904f310d98399f168456b88ecc6b0287b60341a";
        libraryHaskellDepends = [
          base binary bytestring containers cookie hedis mtl network
          pool-conduit random text time wai yesod-core
@@ -144995,7 +145462,7 @@ self: {
      mkDerivation {
        pname = "yesod-sitemap";
        version = "1.4.0.1";
-       sha256 = "0ri67r3yjngn4m2lj071n2v3r9w7pvsl24rayf41k7w9j3ylk100";
+       sha256 = "008449fd90899f1988f32a1341f5be87a73cb6b0e100494525f659e9473e2666";
        libraryHaskellDepends = [
          base conduit containers data-default text time xml-conduit
          xml-types yesod-core
@@ -145017,8 +145484,8 @@ self: {
      }:
      mkDerivation {
        pname = "yesod-static";
-       version = "1.5.0.1";
-       sha256 = "1yda1m7dafcmq9s2gv0cdq3kphl5gg1279crqjgf3x57dyrypjpl";
+       version = "1.5.0.2";
+       sha256 = "8aec8fc99df9a9910d7a3f732b669753c01dd3ea4177f9e5a7f8cea936b62ea9";
        libraryHaskellDepends = [
          async attoparsec base base64-bytestring blaze-builder byteable
          bytestring conduit conduit-extra containers cryptohash
@@ -145050,7 +145517,7 @@ self: {
      mkDerivation {
        pname = "yesod-static-angular";
        version = "0.1.6";
-       sha256 = "17dqk60076la64n4j6bndg9ya16q764j2cl07s2dlldw4z1g4sn1";
+       sha256 = "c16af2c227bc51da843e8032218939d804e5d36b7619492c318a9a038099b89d";
        isLibrary = true;
        isExecutable = true;
        libraryHaskellDepends = [
@@ -145076,7 +145543,7 @@ self: {
      mkDerivation {
        pname = "yesod-table";
        version = "1.0.3";
-       sha256 = "02w7ddyi0zzcvhlj1b01p3zjii2g7bn2f7wcgrdidk8dlg9hrgj5";
+       sha256 = "45be0cd3a30dcd165b7e8c1f27ec3a4fc428ffb801ac2029dcec7f107d6b870b";
        libraryHaskellDepends = [
          base containers contravariant text yesod-core
        ];
@@ -145090,7 +145557,7 @@ self: {
      mkDerivation {
        pname = "yesod-tableview";
        version = "0.2.1";
-       sha256 = "1qf7439c31a8xi0qs8fn2xdlrldi42n1k25lj6vn061lm8wg35yy";
+       sha256 = "de97f138aa341860b791b48819ac20b1d14c5b17d6218d41ec4885c1d220c7e1";
        libraryHaskellDepends = [ base hamlet persistent yesod ];
        description = "Table view for Yesod applications";
        license = stdenv.lib.licenses.bsd3;
@@ -145107,7 +145574,7 @@ self: {
      mkDerivation {
        pname = "yesod-test";
        version = "1.4.3.1";
-       sha256 = "150kzp8h9wl3c1diz6h6m62qd6w0qz4drgrm095amb0sndrh37m2";
+       sha256 = "a29e0173b31aacaa4a0235bfdcc8c7809b8685a9069a1f5b6083f204d1fd1394";
        libraryHaskellDepends = [
          attoparsec base blaze-builder blaze-html blaze-markup bytestring
          case-insensitive containers cookie hspec-core html-conduit
@@ -145131,7 +145598,7 @@ self: {
      mkDerivation {
        pname = "yesod-test-json";
        version = "0.2.0.0";
-       sha256 = "1z6cps85fypgymfmq0z67f1z5cr2x9l9hf4wrkncvkivbcb330bh";
+       sha256 = "708131165b3bcecdeccc9c389868ea22b3f2833be6035c5df5ef7a5790beccfc";
        libraryHaskellDepends = [
          aeson base bytestring conduit hspec http-types HUnit text
          transformers wai wai-test yesod-default
@@ -145150,7 +145617,7 @@ self: {
      mkDerivation {
        pname = "yesod-text-markdown";
        version = "0.1.8";
-       sha256 = "1k48wjnn4vvlh9cvh8p3yanjmr772vqz4jbz9nxk0vv9ab9dns81";
+       sha256 = "0169dbd252696f30bb4d7f49f2f116e7e42aadf2e322b85982746f62ade488cc";
        libraryHaskellDepends = [
          aeson base markdown persistent shakespeare text yesod-core
          yesod-form yesod-persistent
@@ -145166,7 +145633,7 @@ self: {
      mkDerivation {
        pname = "yesod-tls";
        version = "1.4.1";
-       sha256 = "0zvhchiky51pwhbcj4c86xsa98nwfw86188jxhnk2jwdgpdb9j68";
+       sha256 = "c8c8b4da7d8d4b312dec12a1601077dca2a474378811c916e437143f2364707f";
        libraryHaskellDepends = [
          base fast-logger monad-logger template-haskell unix wai wai-extra
          warp warp-tls yesod
@@ -145186,7 +145653,7 @@ self: {
      mkDerivation {
        pname = "yesod-transloadit";
        version = "0.3.0.0";
-       sha256 = "0p2npza0clflh1vswyjr4gxx5fxggzv1x61x7c7d79jadq88bi4m";
+       sha256 = "95c485106e4aa6d30e3b3d981ef67fafbbd2fb23597aae7780d45106d4bf565c";
        libraryHaskellDepends = [
          aeson base byteable bytestring cryptohash lens lens-aeson
          old-locale shakespeare text time transformers unordered-containers
@@ -145207,7 +145674,7 @@ self: {
      mkDerivation {
        pname = "yesod-vend";
        version = "0.3.0.0";
-       sha256 = "163ah4g6k62hypm2kj1aiwnzfjx1ngss6iqfg467vjhg71s5l1j9";
+       sha256 = "49065a74380fca7d0c790e47a3f5b3a14bf72d8f2ac829eaf55098691e816a98";
        isLibrary = true;
        isExecutable = true;
        libraryHaskellDepends = [
@@ -145232,7 +145699,7 @@ self: {
      mkDerivation {
        pname = "yesod-websockets";
        version = "0.2.3";
-       sha256 = "15kklk4wkxclrmsvwzjcy8ggal14c6nrckfn0kqcrfp0hbxzj09m";
+       sha256 = "3501f9fb82e0baccf004d64d96ad612450f51ef24c7ebe75cd94f5c9c9a47396";
        libraryHaskellDepends = [
          async base conduit enclosed-exceptions monad-control transformers
          wai wai-websockets websockets yesod-core
@@ -145249,7 +145716,7 @@ self: {
      mkDerivation {
        pname = "yesod-websockets-extra";
        version = "0.1.0.0";
-       sha256 = "042gl7w8cipjhqfl5h933b0p3j9d5m58v91p1rylz4mjgvhxpk5g";
+       sha256 = "afccdbe17eb2924f7d0e37a48d4a2d2dc971c11a23c1421d86f24686f8a14f10";
        libraryHaskellDepends = [
          base enclosed-exceptions transformers websockets yesod-websockets
        ];
@@ -145265,7 +145732,7 @@ self: {
      mkDerivation {
        pname = "yesod-worker";
        version = "0.0.1";
-       sha256 = "1rwmw1hhx2mm6ikmqcfjg9vgi95mjhv2w5r4dwn8796jkkw8zpkd";
+       sha256 = "6dde8ff89cd2a4832c6f24172e3694b5a4f8767ad2315c6734b58a0e61e095e7";
        libraryHaskellDepends = [
          base containers fast-logger monad-control monad-logger persistent
          resourcet stm template-haskell transformers transformers-base yesod
@@ -145289,7 +145756,7 @@ self: {
      mkDerivation {
        pname = "yet-another-logger";
        version = "0.2.3.1";
-       sha256 = "1m9sb4kshdvr4nd4dsd6ss2f4dfhxnbs9g1xd9rmzrd7bw9k5am0";
+       sha256 = "a0aa32135fa7e55f736a3dbca497edd035e284d6a6e9469a257937a827593ad5";
        isLibrary = true;
        isExecutable = true;
        libraryHaskellDepends = [
@@ -145315,7 +145782,7 @@ self: {
      mkDerivation {
        pname = "yhccore";
        version = "0.9.1";
-       sha256 = "18gjzlpxn0hp723ybjgq1zdbpl35iqphs7b8r5x9ddbkm435sw93";
+       sha256 = "23715d06a973b5967ac9681d0d2f8e65d0bbda0ff8c9e587381702db2ffdf2a1";
        libraryHaskellDepends = [ base containers mtl pretty uniplate ];
        homepage = "http://www.haskell.org/haskellwiki/Yhc";
        description = "Yhc's Internal Core language";
@@ -145336,7 +145803,7 @@ self: {
      mkDerivation {
        pname = "yi";
        version = "0.12.0";
-       sha256 = "167x1zmkhrh7s4wjvvpp0pydgif1yl05by8j6wimi79wwvnkiyi7";
+       sha256 = "27fa38ede63c9d58233712f95500f5c1c5d7fc05f7ee2d39d1076638eb0ffd98";
        configureFlags = [ "-fpango" "-fvty" ];
        isLibrary = true;
        isExecutable = true;
@@ -145366,7 +145833,7 @@ self: {
      mkDerivation {
        pname = "yi-contrib";
        version = "0.10.1";
-       sha256 = "053hsahkxwg2mnf3h4j95gj18x5791dqqji43l310i4l7mliw91k";
+       sha256 = "33241e693d944410061d244a8c5b48a77414e42b4912389cade2f13ea1d27014";
        libraryHaskellDepends = [
          base containers directory filepath lens mtl old-locale
          oo-prototypes split text time transformers-base yi yi-language
@@ -145384,7 +145851,7 @@ self: {
      mkDerivation {
        pname = "yi-emacs-colours";
        version = "0.1.0.1";
-       sha256 = "1kbds9s0r67bdvigjk0c58slbifnddp6ppv4jrgv6493pylp78qv";
+       sha256 = "1ba373a9bf2311b35f9664df6b6e6bd6c545352a0c4cf9e26eeb980c74d26dcd";
        libraryHaskellDepends = [ base containers split yi-language ];
        homepage = "https://github.com/Fuuzetsu/yi-emacs-colours";
        description = "Simple mapping from colour names used in emacs to Color";
@@ -145399,7 +145866,7 @@ self: {
      mkDerivation {
        pname = "yi-fuzzy-open";
        version = "0.1.0";
-       sha256 = "03y7ddas8w380asx4ldafp1r3h4nlyjky7n4n5sdyvwbi0rix1gc";
+       sha256 = "ec851e33888b6fdf74b1c41e3fa5a796c091c375aa51d2b5026870a4556bc70f";
        libraryHaskellDepends = [
          base binary containers data-default directory filepath mtl text
          transformers-base vector yi yi-language yi-rope
@@ -145415,7 +145882,7 @@ self: {
      mkDerivation {
        pname = "yi-gtk";
        version = "0.3";
-       sha256 = "1lgdzrxq3g24wy658ydknb98isyksdknn2bfdzsfi68rnij6z6nz";
+       sha256 = "df9a6f64b41999e8f46f6e096b67d3d3eb88d2b2b379548ce744bc817bfeedd1";
        homepage = "http://haskell.org/haskellwiki/Yi";
        description = "The Haskell-Scriptable Editor, helper package";
        license = "GPL";
@@ -145431,7 +145898,7 @@ self: {
      mkDerivation {
        pname = "yi-language";
        version = "0.2.0";
-       sha256 = "1a0lvddn35q9jqr0w7g2m268dy8s9dwsss7sf4460rvkg1xvkvvh";
+       sha256 = "70efb97b787367600871fa68ad794b1af9868ca8e21d0e32960997615bdb14a8";
        libraryHaskellDepends = [
          array base binary containers data-default hashable lens
          oo-prototypes pointedlist regex-base regex-tdfa template-haskell
@@ -145453,7 +145920,7 @@ self: {
      mkDerivation {
        pname = "yi-monokai";
        version = "0.1.1.2";
-       sha256 = "1nghfyiy8jdz144nbw0c2cdy8n6xyjmk31g6z24jk8dij7iwb60l";
+       sha256 = "1498c5e391b1a12989f8e68531abf4dd58e41b130cf0650909bf49e4a377f0d9";
        libraryHaskellDepends = [ base yi ];
        homepage = "https://github.com/Fuuzetsu/yi-monokai";
        description = "Monokai colour theme for the Yi text editor";
@@ -145468,7 +145935,7 @@ self: {
      mkDerivation {
        pname = "yi-rope";
        version = "0.7.0.1";
-       sha256 = "190rb5rbvdzy4d52dj3ih0kwzigh7v0fg412p3848pkv3836vmg0";
+       sha256 = "e0d56d061a7b5e44d0b82290e7c03ef0c5cf278071c8264a23feb7bd725919a4";
        libraryHaskellDepends = [
          base binary bytestring charsetdetect-ae data-default deepseq
          fingertree text text-icu
@@ -145485,7 +145952,7 @@ self: {
      mkDerivation {
        pname = "yi-snippet";
        version = "0.1.0.0";
-       sha256 = "0qbn5x7lbvb9h6gdqgvldzyy7z5y5aa9a02ss48zkccss5p6939d";
+       sha256 = "2d8d646ed19ab1f911d15a0095942abefce3fd6f743fdc9e8169ed454f2f7661";
        libraryHaskellDepends = [ base containers yi yi-rope ];
        homepage = "https://github.com/yi-editor/yi-snippet";
        description = "Snippet support for Yi";
@@ -145497,7 +145964,7 @@ self: {
      mkDerivation {
        pname = "yi-solarized";
        version = "0.1.1";
-       sha256 = "17ifjm9vgrhv00bll5zj9siz08fng1626bff9q5sfbvzd7y6i9nc";
+       sha256 = "cca668fc697f2fa70b4ece2d234c78d621f0a34ef2174a17001be6b753952e9e";
        libraryHaskellDepends = [ base yi ];
        homepage = "https://github.com/NorfairKing/yi-solarized";
        description = "Solarized colour theme for the Yi text editor";
@@ -145509,7 +145976,7 @@ self: {
      mkDerivation {
        pname = "yi-spolsky";
        version = "0.1";
-       sha256 = "152ys2x416322c13nxmi25wpilq0ddd6hj36mr25jaacf1qszv6q";
+       sha256 = "d8ecaf71704c295944ae6648685a6b00d3787911b1763b0213629840bad05e94";
        libraryHaskellDepends = [ base yi ];
        jailbreak = true;
        homepage = "https://github.com/melrief/yi-spolsky";
@@ -145522,7 +145989,7 @@ self: {
      mkDerivation {
        pname = "yi-vty";
        version = "0.3";
-       sha256 = "01jp8xcxq9a1s6fp4yivnvr5a48svjir70yl0dhhwil0l3m9v9c9";
+       sha256 = "89a59deaa080460e6103d48393a3dc1a1155f2b63b7a729dd14125dc59475706";
        homepage = "http://haskell.org/haskellwiki/Yi";
        description = "The Haskell-Scriptable Editor, helper package";
        license = "GPL";
@@ -145534,7 +146001,7 @@ self: {
      mkDerivation {
        pname = "yices";
        version = "0.0.0.12";
-       sha256 = "1k3q789dapk0c311x72w4r008rnbfz3cvajahxq208gy8iyjx9iz";
+       sha256 = "3fa62e7d44fe212070874aaacdc677cb660440265c9c1ec260605ed5123a78cc";
        libraryHaskellDepends = [ base parsec process ];
        description = "Haskell programming interface to Yices SMT solver";
        license = stdenv.lib.licenses.bsd3;
@@ -145545,7 +146012,7 @@ self: {
      mkDerivation {
        pname = "yices-easy";
        version = "0.1";
-       sha256 = "13nl3isf8npqmgsa7mc7713g7y0nk33a654rm1qnn1s6zyz41v70";
+       sha256 = "e0ec40beff46076b71a89914a3c69816f8f3463887d5a3f4abf85ae4741cd48e";
        libraryHaskellDepends = [
          base bindings-yices containers transformers
        ];
@@ -145561,7 +146028,7 @@ self: {
      mkDerivation {
        pname = "yices-painless";
        version = "0.1.2";
-       sha256 = "1q0hxzvhd9p0qb0fyps6hn06nhqcwldxyfljk8880il17ky92p3h";
+       sha256 = "705c91fc3c814680109a923adf1be50c436b8085465fefc0c2e0a606f7ef10e0";
        libraryHaskellDepends = [
          base containers pretty strict-concurrency vector
        ];
@@ -145578,7 +146045,7 @@ self: {
      mkDerivation {
        pname = "yjftp";
        version = "0.3.6.5";
-       sha256 = "11iwz7mrx3f72i3d4l9zvqb8g0722aj00s7h7wa06y4l69rfnj6m";
+       sha256 = "d548eb7232947803143ff06800a412e2808716de3f51d24614c78d9eebf93c86";
        isLibrary = true;
        isExecutable = true;
        libraryHaskellDepends = [
@@ -145597,7 +146064,7 @@ self: {
      mkDerivation {
        pname = "yjftp-libs";
        version = "0.0.2";
-       sha256 = "1rlw9i1a034lg7gc60fkxjh6kc5yrbapc745gwl1ddi2wisy3h24";
+       sha256 = "44c0e175e422b616287f851c76d5cabeb069a0ecd301c3de79940ca0424c9ce6";
        isLibrary = true;
        isExecutable = true;
        libraryHaskellDepends = [ base directory ftphs mtl process unix ];
@@ -145612,7 +146079,7 @@ self: {
      mkDerivation {
        pname = "yjsvg";
        version = "0.1.18";
-       sha256 = "1k9shfj53vqg1wgm06k2729md0q5y252sypjkx245sn3x0a7ffji";
+       sha256 = "513a7714e8c3ea42449ff27a2d8af00583569338621a501f0f0fef51a4833acd";
        libraryHaskellDepends = [ base HaXml ];
        description = "make SVG string from Haskell data";
        license = stdenv.lib.licenses.bsd3;
@@ -145623,7 +146090,7 @@ self: {
      mkDerivation {
        pname = "yjtools";
        version = "0.9.18";
-       sha256 = "13zbq37p2prbyxq1wply7qqpc2wwsic78wzcgbc430nfrrpiq4lv";
+       sha256 = "9b121c6fcece8241d87aec737458d49c0b76313e9e5e1e70f72b5f71cfc0eb8f";
        libraryHaskellDepends = [ base ];
        homepage = "http://homepage3.nifty.com/salamander/second/projects/yjtools/index.xhtml";
        description = "some tools for Monad, List, Tuple and so on";
@@ -145637,7 +146104,7 @@ self: {
      mkDerivation {
        pname = "yocto";
        version = "1.0.1";
-       sha256 = "0i92yraawhn6qkw23wm5vmgwcjgy9pis684jyq8mkawbw0nv3q9a";
+       sha256 = "2ae1b12de08bab5911f69220a3e34dfe49c65fdda5f221f8c4c642ae54f62245";
        libraryHaskellDepends = [ base containers parsec ];
        testHaskellDepends = [
          base containers parsec QuickCheck quickcheck-instances
@@ -145656,7 +146123,7 @@ self: {
      mkDerivation {
        pname = "yoko";
        version = "2.0";
-       sha256 = "07ivcx6xbmjpyj7053fp151k47y7pllwjddxxrwayrlx2qx456z6";
+       sha256 = "e69b423a169d66af78eebd35c929bdc71f324309d78d028ef457d6d54d673b1e";
        libraryHaskellDepends = [
          base bifunctors containers invariant kinds mtl records semigroups
          template-haskell th-sccs type-cereal type-digits type-equality
@@ -145672,7 +146139,7 @@ self: {
      mkDerivation {
        pname = "york-lava";
        version = "0.2";
-       sha256 = "1rpkxlfvk84zl965ik5bpplzcskd96wsnicp66ixnfs9bkqfj7qb";
+       sha256 = "0b1fe9f05c493bdba3319745abb9496d6af6e9bdabcc584ca29fa0b91dedf3e6";
        libraryHaskellDepends = [ base containers haskell98 ];
        homepage = "http://www.cs.york.ac.uk/fp/reduceron/";
        description = "A library for digital circuit description";
@@ -145685,7 +146152,7 @@ self: {
      mkDerivation {
        pname = "youtube";
        version = "0.2.0.1";
-       sha256 = "0n33778aflcdzdkc6p0qaxdqvmyzdyg0r6rg4q2wh0g74m6pl2m4";
+       sha256 = "a40a7a4d25e701c805262f9b0c9e6fdfd78d5b57185cc366fb8d51a7d0396358";
        isLibrary = false;
        isExecutable = true;
        executableHaskellDepends = [ base bytestring process utility-ht ];
@@ -145703,7 +146170,7 @@ self: {
      mkDerivation {
        pname = "yql";
        version = "0.0.0";
-       sha256 = "1qwk78adndk2m48inxklqj1rc58wx4jrdim60gwy7ax2d3w92pg6";
+       sha256 = "e65d91f868a2abe3f903a6c69625e91c159683c474761b11a96236db143a93e3";
        isLibrary = true;
        isExecutable = true;
        libraryHaskellDepends = [
@@ -145731,7 +146198,7 @@ self: {
      mkDerivation {
        pname = "yst";
        version = "0.5.0.4";
-       sha256 = "1bnmh7caj9s6sfj2hhfwdnsg75wci1qw8c3pwryqy57knwcwbvkz";
+       sha256 = "7feec519b7f3148f7de67730c471888c97f3b46ddc4128a4d34627a9d881d5ae";
        isLibrary = false;
        isExecutable = true;
        executableHaskellDepends = [
@@ -145749,7 +146216,7 @@ self: {
      mkDerivation {
        pname = "yuiGrid";
        version = "0.1";
-       sha256 = "005l0rr9l0l81706drq57nww4h0j4rw8n0ncpnkdb139941gywzq";
+       sha256 = "f873ff02496984d5a6bdcc028b78261240c2b93d05e766c00988029a7206b400";
        libraryHaskellDepends = [ base ];
        description = "Grids defined by layout hints and implemented on top of Yahoo grids";
        license = "unknown";
@@ -145763,7 +146230,7 @@ self: {
      mkDerivation {
        pname = "yuuko";
        version = "2010.11.28";
-       sha256 = "01pf0mg6lgm34src1mfz3qj41vyhmvi50yjyv72zwamd0g7sx374";
+       sha256 = "e48caecf03ad2afec5d95e7a50e2aed0ef40241edfd5c0b226a33e6a5e05ee06";
        isLibrary = true;
        isExecutable = true;
        libraryHaskellDepends = [
@@ -145793,7 +146260,7 @@ self: {
      mkDerivation {
        pname = "yxdb-utils";
        version = "0.1.0.1";
-       sha256 = "05aba4fdpqx7sar7yrw4gg341wzfhhlbvx7453ns8mccqhx9dag8";
+       sha256 = "e8a9963ac48c55a4ed28e4f4bd2884eef340c67b84677fb2d2a7e3db1c514b15";
        isLibrary = true;
        isExecutable = true;
        libraryHaskellDepends = [
@@ -145824,7 +146291,7 @@ self: {
      mkDerivation {
        pname = "z3";
        version = "4.1.0";
-       sha256 = "1vpmwizxcab1mlz7vp3hp72ddla7805jn0lq60fmkjgmj95ryvq9";
+       sha256 = "096f9f4b92f5c9591d3098022b0b4047d1d6c4b970dc7d3ead6129d67fe4f5ee";
        isLibrary = true;
        isExecutable = true;
        libraryHaskellDepends = [ base containers mtl ];
@@ -145842,7 +146309,7 @@ self: {
      mkDerivation {
        pname = "zampolit";
        version = "0.3";
-       sha256 = "1bhp98bn41lqxdl48xxcb4b4fknva2aigq5gxffcha535igdmdy3";
+       sha256 = "c3b7da5e2ca328c89cebafe0179550db4e471659ac774468eb980662174a17ae";
        isLibrary = false;
        isExecutable = true;
        executableHaskellDepends = [
@@ -145860,7 +146327,7 @@ self: {
      mkDerivation {
        pname = "zasni-gerna";
        version = "0.0.7";
-       sha256 = "1zl2kcd0hr021xl6pjvvxwxvmpb02cq04ck39qkwil56vannnksw";
+       sha256 = "5c4f6baddaa6d0c8274e633202301360ddba3bef7bcb6b680f0264081a9b82fe";
        libraryHaskellDepends = [ base papillon ];
        homepage = "https://skami.iocikun.jp/haskell/packages/zasni-gerna";
        description = "lojban parser (zasni gerna)";
@@ -145873,7 +146340,7 @@ self: {
      mkDerivation {
        pname = "zcache";
        version = "0.0.0";
-       sha256 = "10j0fwf58ig0j44f7p57zr8by6i9j1agnjzk6cs65iimm79m9avb";
+       sha256 = "6bab54d3a935c6623433f34bfb5490291abf50fea7dce30891e045541c774082";
        libraryHaskellDepends = [
          array base containers mersenne-random-pure64
        ];
@@ -145887,7 +146354,7 @@ self: {
      mkDerivation {
        pname = "zenc";
        version = "0.1.1";
-       sha256 = "0p0h7vz14k9v8gsnpkb9ca61i1k67vvsjg0bzy0ag4m20k94zlb2";
+       sha256 = "62d14fd204a292a780ff0b3ca9f73e6686188c6269cd6bf5433b4d12fe3e105c";
        libraryHaskellDepends = [ base ];
        description = "GHC style name Z-encoding and Z-decoding";
        license = stdenv.lib.licenses.bsd3;
@@ -145903,7 +146370,7 @@ self: {
      mkDerivation {
        pname = "zendesk-api";
        version = "0.1.0.0";
-       sha256 = "1x6801i5rw6a0nfdihi04bmka8qww9c77r7ygbhp3zx1hqdpdmmc";
+       sha256 = "acd6761b86a1ff71e17afee47358e21c2335eb2220c2d89c05caf05c6200c8f4";
        libraryHaskellDepends = [
          aeson base bytestring case-insensitive conduit connection
          data-default failure http-client http-client-tls http-conduit
@@ -145924,7 +146391,7 @@ self: {
      mkDerivation {
        pname = "zeno";
        version = "0.2.0.1";
-       sha256 = "03jwhgi9n9iv7zpn8nwkdyvsybsksnhsji8k2ma9rzayk36aba6v";
+       sha256 = "dba8a5cc985efd9c54151345a9a1d5532fafb76f935b64ef3f3b269be2835c0e";
        isLibrary = false;
        isExecutable = true;
        executableHaskellDepends = [
@@ -145941,7 +146408,7 @@ self: {
      mkDerivation {
        pname = "zero";
        version = "0.1.2";
-       sha256 = "01hfsi29g42b4jj3ahddv1ry7qgav17pwpngipz8igq2w81v1y9p";
+       sha256 = "37f9b003e202bf88fe8dcf5e7e4fd8eae1e373d8ad4135a4244b909744d40e06";
        libraryHaskellDepends = [ base semigroups ];
        homepage = "https://github.com/phaazon/zero";
        description = "Semigroups with absorption";
@@ -145955,7 +146422,7 @@ self: {
      mkDerivation {
        pname = "zeromq-haskell";
        version = "0.8.4";
-       sha256 = "0lvjszi08r5wm5ch03153y7lir6cdgqr2gnhq45j4b0kid6gkpv3";
+       sha256 = "63dff94c8b132c220bc1d03e91f16bcce4488f1f250c0059a9bc6404e2d77253";
        libraryHaskellDepends = [ base bytestring containers ];
        librarySystemDepends = [ zeromq ];
        testHaskellDepends = [
@@ -145975,7 +146442,7 @@ self: {
      mkDerivation {
        pname = "zeromq3-conduit";
        version = "0.1.0.0";
-       sha256 = "1n6xl5izdkbl2mb4msryrcasg08prjbgzwilz4b7yi1g79y1yf77";
+       sha256 = "e7381f7c3a2f447f16f934f2ff96cc1781a715cb3eeb4a561574cdf663a1ddd8";
        libraryHaskellDepends = [
          base bytestring conduit lifted-base monad-control mtl resourcet
          transformers zeromq3-haskell
@@ -145994,7 +146461,7 @@ self: {
      mkDerivation {
        pname = "zeromq3-haskell";
        version = "0.5.2";
-       sha256 = "1ky92qwyk27qsxnvaj0mc9yyhk7g19ry2nq55666ayahc899z213";
+       sha256 = "23889f12625079658c29055be1730aef4ce87d621548b56dd7f888e93916c9cf";
        libraryHaskellDepends = [
          async base bytestring containers MonadCatchIO-transformers
          semigroups transformers
@@ -146018,7 +146485,7 @@ self: {
      mkDerivation {
        pname = "zeromq4-haskell";
        version = "0.6.3";
-       sha256 = "0yrwqxm208n9k76i9aby5hiv55kd1p27pq6hyry5ngw95fh95p67";
+       sha256 = "c7dc92a02b893f5b7cf6d0e07bc40d6d96b2232c7ea914cd99c922206ac73c7b";
        libraryHaskellDepends = [
          async base bytestring containers exceptions semigroups transformers
        ];
@@ -146039,7 +146506,7 @@ self: {
      mkDerivation {
        pname = "zeroth";
        version = "2009.6.23.3";
-       sha256 = "10ilsxlha4l7c4z3jl6lykcjns6igyk2qma2a03yzpvgz7ijy4c0";
+       sha256 = "80112fe3f96fdfef075042552ca67fd1682bd9f4d450393e6187120569d73482";
        isLibrary = true;
        isExecutable = true;
        libraryHaskellDepends = [
@@ -146063,7 +146530,7 @@ self: {
      mkDerivation {
        pname = "zigbee-znet25";
        version = "0.1.1.0";
-       sha256 = "0kv52f7zhgd2x44a2dg89jrsxiis73m8884f4zmxdbznhq1prqf5";
+       sha256 = "c5e17c0386f6afd6eb278e2084ea383ac6aeb34ce835a108e9a23df88f13654f";
        libraryHaskellDepends = [
          base bytestring cereal MissingH mtl transformers
        ];
@@ -146081,7 +146548,7 @@ self: {
      mkDerivation {
        pname = "zip-archive";
        version = "0.2.3.7";
-       sha256 = "169nkxr5zlbymiz1ydlhlqr66vqiycmg85xh559phpkr64w3nqj1";
+       sha256 = "41623b3831795e785329b017f42af3116f6332a690361f7eac7ed15f729f3699";
        isLibrary = true;
        isExecutable = true;
        libraryHaskellDepends = [
@@ -146107,7 +146574,7 @@ self: {
      mkDerivation {
        pname = "zip-conduit";
        version = "0.2.2.2";
-       sha256 = "0spb6b1mwcqwzrr231i5s6hcln9jck0z03jdfh1zlm87mvp8670v";
+       sha256 = "1b1c83eeae0755fa03744d0ef0c1643259caa0d125862172fe1c335ec332eb6a";
        libraryHaskellDepends = [
          base bytestring cereal conduit conduit-extra digest directory
          filepath mtl old-time resourcet time transformers utf8-string
@@ -146127,7 +146594,7 @@ self: {
      mkDerivation {
        pname = "zipedit";
        version = "0.2.3";
-       sha256 = "17msh3gwylmsiabyz5x05ir2xh8h904kbp5isnvbf0z4kzfv33cr";
+       sha256 = "998db1dd9fe403b7b6d5b1dc35094810c12e722ca097ef978aba52cfdf80ba9e";
        libraryHaskellDepends = [ base directory mtl process ];
        homepage = "http://code.haskell.org/~byorgey/code/zipedit";
        description = "Create simple list editor interfaces";
@@ -146140,7 +146607,7 @@ self: {
      mkDerivation {
        pname = "zipper";
        version = "0.4.2";
-       sha256 = "1r8092amq5w9gl5szycl1r7wx87xnmkcapdzcwfa4c3pvxrhjy44";
+       sha256 = "84780973df7730a21c67bf5dc566b5fda0ce4f0e94f9af0b7d89175c954800e5";
        libraryHaskellDepends = [ base multirec ];
        homepage = "http://www.cs.uu.nl/wiki/GenericProgramming/Multirec";
        description = "Generic zipper for families of recursive datatypes";
@@ -146154,7 +146621,7 @@ self: {
      mkDerivation {
        pname = "zippers";
        version = "0.2";
-       sha256 = "1rlf01dc6dcy9sx89npsisdz1yg9v4h2byd6ms602bxnmjllm1ls";
+       sha256 = "9a864aa9acb62f018caea6f92520d9e9f9f09b8efada84ba4e9e35c35a008ee6";
        revision = "1";
        editedCabalFile = "3e27022f7ed27e35e73ed36f3aa6b396c7e7b52e864965b8d3cd4dab8394e960";
        libraryHaskellDepends = [ base lens profunctors semigroupoids ];
@@ -146169,7 +146636,7 @@ self: {
      mkDerivation {
        pname = "zippo";
        version = "0.3";
-       sha256 = "1ihdird5yryfb2ki9bwwchj8bxjcmmgjkp3hl605zzhi2lz3awx2";
+       sha256 = "a273353e1511fe5f80a170dc295fad4cf68524649caf14a758ce675f5a8e0dc6";
        libraryHaskellDepends = [ base mtl yall ];
        homepage = "http://brandon.si/code/zippo/";
        description = "A simple lens-based, generic, heterogenous, type-checked zipper library";
@@ -146181,7 +146648,7 @@ self: {
      mkDerivation {
        pname = "zlib";
        version = "0.5.4.2";
-       sha256 = "15hhsk7z3gvm7sz2ic2z1ca5c6rpsln2rr391mdbm1bxlzc1gmkm";
+       sha256 = "75d617d8a77d85ba5a0d69e42c2cd5371b56140b5fb028be3e75bff1cfd41096";
        libraryHaskellDepends = [ base bytestring ];
        librarySystemDepends = [ zlib ];
        description = "Compression and decompression in the gzip and zlib formats";
@@ -146195,7 +146662,7 @@ self: {
      mkDerivation {
        pname = "zlib";
        version = "0.6.1.1";
-       sha256 = "0dd79dxf56d8f6ad9if3j87s9gg7yd17ckypjxwplrbkahlb9xf5";
+       sha256 = "c5f5b4285473657a7997d74f7642f3e7bda40f92c3c5d49471a899e27a4ba735";
        libraryHaskellDepends = [ base bytestring ];
        librarySystemDepends = [ zlib ];
        testHaskellDepends = [
@@ -146211,7 +146678,7 @@ self: {
      mkDerivation {
        pname = "zlib-bindings";
        version = "0.1.1.5";
-       sha256 = "02ciywlz4wdlymgc3jsnicz9kzvymjw1www2163gxidnz4wb8fy8";
+       sha256 = "c83bb438f9b6c5fe860982731eb8ac7eff993e8b56cbc15ef5b471f229f79109";
        revision = "2";
        editedCabalFile = "0c6f9f81832af2473281fd58631aff8c6bbad24191e00d2a5a6ae2479249043b";
        libraryHaskellDepends = [ base bytestring zlib ];
@@ -146226,7 +146693,7 @@ self: {
      mkDerivation {
        pname = "zlib-conduit";
        version = "1.1.0";
-       sha256 = "1b22mca8bbg7f84h8y0qsb5ckzg2dw1b26y27x7b7xdxqbwpz93a";
+       sha256 = "6aa47ff9c2bdf5b34e3fc21bb1026fe2fdc9cad21878040972e7ad8514ab42ac";
        libraryHaskellDepends = [ base conduit ];
        homepage = "http://github.com/snoyberg/conduit";
        description = "Streaming compression/decompression via conduits. (deprecated)";
@@ -146240,7 +146707,7 @@ self: {
      mkDerivation {
        pname = "zlib-enum";
        version = "0.2.3.1";
-       sha256 = "1nfczminxafzk69ry1sqkj1ha0jlv3l9ak10yk205snfhpmcjgg4";
+       sha256 = "e43dc9ea85ceea02c4f4204c95e8d8540205839c58079f9399dfa96e63fdccd9";
        isLibrary = true;
        isExecutable = true;
        libraryHaskellDepends = [
@@ -146256,7 +146723,7 @@ self: {
      mkDerivation {
        pname = "zlib-lens";
        version = "0.1.2";
-       sha256 = "1vm12sm9ypik5qnnizmwx56fmpjghldzb06kn020hwlabz8c4j8n";
+       sha256 = "1649c2d05f8a720804b0d380f51b854fdeea4ce9bcfe682d2e335e9faa16a1ee";
        revision = "1";
        editedCabalFile = "353e3ef6e0281894cd494b95563bb93a30ec0ff96e309a173c36bddfc4069e66";
        libraryHaskellDepends = [ base bytestring profunctors zlib ];
@@ -146270,7 +146737,7 @@ self: {
      mkDerivation {
        pname = "zmcat";
        version = "0.3";
-       sha256 = "0lg5fn89wj5blbp2gh760ibxb2zz9f11jnwicfsmsayra51micip";
+       sha256 = "37b2584351d92b5db563915b19824bff8bd55704e6c027eea2ab489e9075e551";
        isLibrary = true;
        isExecutable = true;
        libraryHaskellDepends = [ base bytestring zeromq3-haskell ];
@@ -146286,7 +146753,7 @@ self: {
      mkDerivation {
        pname = "zmidi-core";
        version = "0.7.0";
-       sha256 = "0v8zcybr46rcdpvsji0dzr78skj79jp8l9sd49z6c7s5sddzjm9l";
+       sha256 = "3455f95bd3451f667e224d278aae4c474e8d4efe0d44a9f76d2c1b9297671f6d";
        libraryHaskellDepends = [ base binary bytestring containers ];
        homepage = "http://code.google.com/p/copperbox/";
        description = "Read and write MIDI files";
@@ -146301,7 +146768,7 @@ self: {
      mkDerivation {
        pname = "zmidi-score";
        version = "0.3.0.0";
-       sha256 = "0zhh6bdpbng69sajxdvj2mnd385gc8yyli3jzyjfxp0wr0hv3biv";
+       sha256 = "3baeb121c81cdceea4ff7244ea3d62afa0d16c1572b72e954ee6d975db32107e";
        libraryHaskellDepends = [
          aeson base binary containers data-ordlist deepseq deepseq-generics
          directory filepath mtl parallel-io text zmidi-core
@@ -146319,7 +146786,7 @@ self: {
      mkDerivation {
        pname = "zmqat";
        version = "0.2.0.0";
-       sha256 = "1k10wflfsivq792jvl3bhb8nkpx6m3z8qzarz6q8aw5hs2wslvrv";
+       sha256 = "3b6faab9d0b07085b0f9597d8cfea8a6df69d1826bd02d453a7847eda8e320cc";
        isLibrary = false;
        isExecutable = true;
        executableHaskellDepends = [
@@ -146335,7 +146802,7 @@ self: {
      mkDerivation {
        pname = "zoneinfo";
        version = "0.5";
-       sha256 = "1n27j8ca79a1ijn7k7dp61kjz62i6zfzlns8n0kwgyvpx413ws8y";
+       sha256 = "1e693e02e977fbc727b0485bfadd3751982f6730b79d79ac8c41a5a3189247d8";
        libraryHaskellDepends = [ base time ];
        jailbreak = true;
        description = "ZoneInfo library";
@@ -146350,7 +146817,7 @@ self: {
      mkDerivation {
        pname = "zoom";
        version = "0.1.0.1";
-       sha256 = "0zsr3k4c6da1l5cw3laj2snfszm4g0bz76hj2bjj61yrwmc99vnl";
+       sha256 = "d4ee9458e5d90723e512129af31778a47eedac1652d1c159a14135c3c81c597f";
        isLibrary = true;
        isExecutable = true;
        libraryHaskellDepends = [ base ghc hamlet template-haskell text ];
@@ -146374,7 +146841,7 @@ self: {
      mkDerivation {
        pname = "zoom-cache";
        version = "1.2.1.6";
-       sha256 = "0761xpfmmm309r6r44ax7x2zs49dskygl2c09x2kpxpfr7rr3k5f";
+       sha256 = "aecc91f3c9eef63b454f8009fafcd42d11fd453f5d11924d4e60d45addedc11c";
        isLibrary = true;
        isExecutable = true;
        libraryHaskellDepends = [
@@ -146404,7 +146871,7 @@ self: {
      mkDerivation {
        pname = "zoom-cache-pcm";
        version = "0.3.0.1";
-       sha256 = "0r676wb4q7wmin3liqh525w43pgdf0gmcfx2ccpbvc4ahain9vyq";
+       sha256 = "d8ef64a3828ab0bd2e63a23b561f70eddd41781105e248878d951f4c1637c764";
        libraryHaskellDepends = [
          base blaze-builder bytestring containers iteratee ListLike mtl
          type-level zoom-cache
@@ -146423,7 +146890,7 @@ self: {
      mkDerivation {
        pname = "zoom-cache-sndfile";
        version = "1.1.0.1";
-       sha256 = "0722wy6rqbx4gajn3sp946scganr2arhinxrqyq5fvvsbdxacwhz";
+       sha256 = "1f72a67a5b7a6f57b0c7b9db08b312d9aac7b421e9ea61a57aa42f9c8de7421c";
        isLibrary = false;
        isExecutable = true;
        executableHaskellDepends = [
@@ -146441,7 +146908,7 @@ self: {
      mkDerivation {
        pname = "zoom-refs";
        version = "0.0.0.0";
-       sha256 = "0pbnwgsfl4rgmgsq30snki34xh9iaky01jnxycppf0h93mbdv01p";
+       sha256 = "3780dd561d0902772ff3ddca00fc5431c14e469c568381f5ab2f13eaf4e3765d";
        libraryHaskellDepends = [ base lens stm ];
        description = "Zoom (~ Functor) and pairing (~ Applicative) for mutable references";
        license = stdenv.lib.licenses.bsd3;
@@ -146452,7 +146919,7 @@ self: {
      mkDerivation {
        pname = "zot";
        version = "0.0.2";
-       sha256 = "12wgkrlvhby0gy6kngjwyx468yarpgkiwy51v6zb8jhx79mhidq3";
+       sha256 = "03b7086b3a1d4ab4bed9a1781ee7bb59796448f75c3e3b8d7fc02fb8699e8f8b";
        revision = "1";
        editedCabalFile = "325ccedb3426935b4a56f838f3d05fc914b72729a2b80d6c804bec5657593a40";
        isLibrary = false;
@@ -146468,7 +146935,7 @@ self: {
      mkDerivation {
        pname = "zsh-battery";
        version = "0.2";
-       sha256 = "04d812dcvkbjg2y0q4q855r6g9nr2k54k2jhnbksbpnxkz0cmaxr";
+       sha256 = "b9abcac09fdddea5e7b2508a49ca14d9a667722908130cbc7872cdcd9a08a811";
        isLibrary = false;
        isExecutable = true;
        executableHaskellDepends = [ base directory filepath mtl ];
@@ -146485,7 +146952,7 @@ self: {
      mkDerivation {
        pname = "ztail";
        version = "1.1";
-       sha256 = "11x6whwyfgdgda5bhdck0k12inzix8cjfm42hh09p703nalk07nq";
+       sha256 = "d81e30a9b2039c9b008482542719eaf1db28c2049335b88a6aaf3de739e4a687";
        isLibrary = false;
        isExecutable = true;
        executableHaskellDepends = [
diff --git a/pkgs/development/interpreters/php/5.4.nix b/pkgs/development/interpreters/php/5.4.nix
deleted file mode 100644
index c9391a4e24f..00000000000
--- a/pkgs/development/interpreters/php/5.4.nix
+++ /dev/null
@@ -1,6 +0,0 @@
-{ callPackage, apacheHttpd }:
-callPackage ./generic.nix {
-  phpVersion = "5.4.43";
-  sha = "0sydirpwg150wxsjrpp3m38564832wviglmsylhbbl8an17p5mr5";
-  apacheHttpd = apacheHttpd;
-}
diff --git a/pkgs/development/interpreters/php/5.5.nix b/pkgs/development/interpreters/php/5.5.nix
deleted file mode 100644
index 18dfde4ae67..00000000000
--- a/pkgs/development/interpreters/php/5.5.nix
+++ /dev/null
@@ -1,6 +0,0 @@
-{ callPackage, apacheHttpd  }:
-callPackage ./generic.nix {
-  phpVersion = "5.5.27";
-  sha = "0w0zgqria3i3mrp03p9m0613xlaj3vsw9girmslngjn06jjwdd64";
-  apacheHttpd = apacheHttpd;
-}
diff --git a/pkgs/development/interpreters/php/5.6.nix b/pkgs/development/interpreters/php/5.6.nix
deleted file mode 100644
index 51ba06b2922..00000000000
--- a/pkgs/development/interpreters/php/5.6.nix
+++ /dev/null
@@ -1,6 +0,0 @@
-{ callPackage, apacheHttpd  }:
-callPackage ./generic.nix {
-  phpVersion = "5.6.11";
-  sha = "0riq0c8s8anb1nxvn3ljs7wdn811903sv7kl8ir2ck3n2q42csxx";
-  apacheHttpd = apacheHttpd;
-}
diff --git a/pkgs/development/interpreters/php/7.0.nix b/pkgs/development/interpreters/php/7.0.nix
deleted file mode 100644
index 1369cf4a219..00000000000
--- a/pkgs/development/interpreters/php/7.0.nix
+++ /dev/null
@@ -1,8 +0,0 @@
-{ callPackage, apacheHttpd  }:
-callPackage ./generic.nix {
-  phpVersion = "7.0.0beta1";
-  url = "https://downloads.php.net/~ab/php-7.0.0beta1.tar.bz2";
-  sha = "1pj3ysfhswg2r370ivp33fv9zbcl3yvhmxgnc731k08hv6hmd984";
-  apacheHttpd = apacheHttpd;
-  php7 = true;
-}
diff --git a/pkgs/development/interpreters/php/default.nix b/pkgs/development/interpreters/php/default.nix
new file mode 100644
index 00000000000..2d1fd454c0f
--- /dev/null
+++ b/pkgs/development/interpreters/php/default.nix
@@ -0,0 +1,308 @@
+{ lib, stdenv, fetchurl, composableDerivation, autoconf, automake, flex, bison
+, mysql, libxml2, readline, zlib, curl, postgresql, gettext
+, openssl, pkgconfig, sqlite, config, libjpeg, libpng, freetype
+, libxslt, libmcrypt, bzip2, icu, openldap, cyrus_sasl, libmhash, freetds
+, uwimap, pam, gmp, apacheHttpd }:
+
+let
+
+  generic =
+    { version, sha256, url ? "http://www.php.net/distributions/php-${version}.tar.bz2" }:
+
+    let php7 = lib.versionAtLeast version "7.0"; in
+
+    composableDerivation.composableDerivation {} (fixed: {
+
+      inherit version;
+
+      name = "php-${version}";
+
+      enableParallelBuilding = true;
+
+      buildInputs = [ flex bison pkgconfig ];
+
+      flags = {
+
+        # much left to do here...
+
+        # SAPI modules:
+
+        apxs2 = {
+          configureFlags = ["--with-apxs2=${apacheHttpd}/bin/apxs"];
+          buildInputs = [apacheHttpd];
+        };
+
+        # Extensions
+        imap = {
+          configureFlags = [
+            "--with-imap=${uwimap}"
+            "--with-imap-ssl"
+            ];
+          buildInputs = [ uwimap openssl pam ];
+        };
+
+        ldap = {
+          configureFlags = ["--with-ldap=${openldap}"];
+          buildInputs = [openldap cyrus_sasl openssl];
+        };
+
+        mhash = {
+          configureFlags = ["--with-mhash"];
+          buildInputs = [libmhash];
+        };
+
+        curl = {
+          configureFlags = ["--with-curl=${curl}"];
+          buildInputs = [curl openssl];
+        };
+
+        curlWrappers = {
+          configureFlags = ["--with-curlwrappers"];
+        };
+
+        zlib = {
+          configureFlags = ["--with-zlib=${zlib}"];
+          buildInputs = [zlib];
+        };
+
+        libxml2 = {
+          configureFlags = [
+            "--with-libxml-dir=${libxml2}"
+            ];
+          buildInputs = [ libxml2 ];
+        };
+
+        pcntl = {
+          configureFlags = [ "--enable-pcntl" ];
+        };
+
+        readline = {
+          configureFlags = ["--with-readline=${readline}"];
+          buildInputs = [ readline ];
+        };
+
+        sqlite = {
+          configureFlags = ["--with-pdo-sqlite=${sqlite}"];
+          buildInputs = [ sqlite ];
+        };
+
+        postgresql = {
+          configureFlags = ["--with-pgsql=${postgresql}"];
+          buildInputs = [ postgresql ];
+        };
+
+        pdo_pgsql = {
+          configureFlags = ["--with-pdo-pgsql=${postgresql}"];
+          buildInputs = [ postgresql ];
+        };
+
+        mysql = {
+          configureFlags = ["--with-mysql=${mysql.lib}"];
+          buildInputs = [ mysql.lib ];
+        };
+
+        mysqli = {
+          configureFlags = ["--with-mysqli=${mysql.lib}/bin/mysql_config"];
+          buildInputs = [ mysql.lib ];
+        };
+
+        mysqli_embedded = {
+          configureFlags = ["--enable-embedded-mysqli"];
+          depends = "mysqli";
+          assertion = fixed.mysqliSupport;
+        };
+
+        pdo_mysql = {
+          configureFlags = ["--with-pdo-mysql=${mysql.lib}"];
+          buildInputs = [ mysql.lib ];
+        };
+
+        bcmath = {
+          configureFlags = ["--enable-bcmath"];
+        };
+
+        gd = {
+          # FIXME: Our own gd package doesn't work, see https://bugs.php.net/bug.php?id=60108.
+          configureFlags = [
+            "--with-gd"
+            "--with-freetype-dir=${freetype}"
+            "--with-png-dir=${libpng}"
+            "--with-jpeg-dir=${libjpeg}"
+          ];
+          buildInputs = [ libpng libjpeg freetype ];
+        };
+
+        gmp = {
+          configureFlags = ["--with-gmp=${gmp}"];
+          buildInputs = [ gmp ];
+        };
+
+        soap = {
+          configureFlags = ["--enable-soap"];
+        };
+
+        sockets = {
+          configureFlags = ["--enable-sockets"];
+        };
+
+        openssl = {
+          configureFlags = ["--with-openssl=${openssl}"];
+          buildInputs = [openssl];
+        };
+
+        mbstring = {
+          configureFlags = ["--enable-mbstring"];
+        };
+
+        gettext = {
+          configureFlags = ["--with-gettext=${gettext}"];
+          buildInputs = [gettext];
+        };
+
+        intl = {
+          configureFlags = ["--enable-intl"];
+          buildInputs = [icu];
+        };
+
+        exif = {
+          configureFlags = ["--enable-exif"];
+        };
+
+        xsl = {
+          configureFlags = ["--with-xsl=${libxslt}"];
+          buildInputs = [libxslt];
+        };
+
+        mcrypt = let libmcrypt' = libmcrypt.override { disablePosixThreads = true; }; in {
+          configureFlags = ["--with-mcrypt=${libmcrypt'}"];
+          buildInputs = [libmcrypt'];
+        };
+
+        bz2 = {
+          configureFlags = ["--with-bz2=${bzip2}"];
+          buildInputs = [bzip2];
+        };
+
+        zip = {
+          configureFlags = ["--enable-zip"];
+        };
+
+        ftp = {
+          configureFlags = ["--enable-ftp"];
+        };
+
+        fpm = {
+          configureFlags = ["--enable-fpm"];
+        };
+
+        mssql = stdenv.lib.optionalAttrs (!stdenv.isDarwin) {
+          configureFlags = ["--with-mssql=${freetds}"];
+          buildInputs = [freetds];
+        };
+
+        zts = {
+          configureFlags = ["--enable-maintainer-zts"];
+        };
+
+        calendar = {
+          configureFlags = ["--enable-calendar"];
+        };
+      };
+
+      cfg = {
+        imapSupport = config.php.imap or true;
+        ldapSupport = config.php.ldap or true;
+        mhashSupport = config.php.mhash or true;
+        mysqlSupport = (!php7) && (config.php.mysql or true);
+        mysqliSupport = config.php.mysqli or true;
+        pdo_mysqlSupport = config.php.pdo_mysql or true;
+        libxml2Support = config.php.libxml2 or true;
+        apxs2Support = config.php.apxs2 or true;
+        bcmathSupport = config.php.bcmath or true;
+        socketsSupport = config.php.sockets or true;
+        curlSupport = config.php.curl or true;
+        curlWrappersSupport = (!php7) && (config.php.curlWrappers or true);
+        gettextSupport = config.php.gettext or true;
+        pcntlSupport = config.php.pcntl or true;
+        postgresqlSupport = config.php.postgresql or true;
+        pdo_pgsqlSupport = config.php.pdo_pgsql or true;
+        readlineSupport = config.php.readline or true;
+        sqliteSupport = config.php.sqlite or true;
+        soapSupport = config.php.soap or true;
+        zlibSupport = config.php.zlib or true;
+        opensslSupport = config.php.openssl or true;
+        mbstringSupport = config.php.mbstring or true;
+        gdSupport = config.php.gd or true;
+        intlSupport = config.php.intl or true;
+        exifSupport = config.php.exif or true;
+        xslSupport = config.php.xsl or false;
+        mcryptSupport = config.php.mcrypt or true;
+        bz2Support = config.php.bz2 or false;
+        zipSupport = config.php.zip or true;
+        ftpSupport = config.php.ftp or true;
+        fpmSupport = config.php.fpm or true;
+        gmpSupport = config.php.gmp or true;
+        mssqlSupport = (!php7) && (config.php.mssql or (!stdenv.isDarwin));
+        ztsSupport = config.php.zts or false;
+        calendarSupport = config.php.calendar or true;
+      };
+
+      configurePhase = ''
+        # Don't record the configure flags since this causes unnecessary
+        # runtime dependencies.
+        for i in main/build-defs.h.in scripts/php-config.in; do
+          substituteInPlace $i \
+            --replace '@CONFIGURE_COMMAND@' '(omitted)' \
+            --replace '@CONFIGURE_OPTIONS@' "" \
+            --replace '@PHP_LDFLAGS@' ""
+        done
+
+        iniFile=$out/etc/php-recommended.ini
+        [[ -z "$libxml2" ]] || export PATH=$PATH:$libxml2/bin
+        ./configure --with-config-file-scan-dir=/etc --with-config-file-path=$out/etc --prefix=$out $configureFlags
+      '';
+
+      installPhase = ''
+        unset installPhase; installPhase;
+        cp php.ini-production $iniFile
+      '';
+
+      src = fetchurl {
+        inherit url sha256;
+      };
+
+      meta = with stdenv.lib; {
+        description = "An HTML-embedded scripting language";
+        homepage = http://www.php.net/;
+        license = stdenv.lib.licenses.php301;
+        maintainers = with maintainers; [ globin ];
+      };
+
+      patches = if !php7 then [ ./fix-paths.patch ] else [ ./fix-paths-php7.patch ];
+
+    });
+
+in {
+
+  php54 = generic {
+    version = "5.4.44";
+    sha256 = "0vc5lf0yjk1fs7inri76mh0lrcmq32ji4m6yqdmg7314x5f9xmcd";
+  };
+
+  php55 = generic {
+    version = "5.5.28";
+    sha256 = "1wy2v5rmbiia3v6fc8nwg1y3sdkdmicksxnkadz1f3035rbjqz8r";
+  };
+
+  php56 = generic {
+    version = "5.6.12";
+    sha256 = "0fl5r0lzav7icg97p7gkvbxk0xk2mh7i1r45dycjlyxgf91109vg";
+  };
+
+  php70 = lib.lowPrio (generic {
+    version = "7.0.0beta1";
+    url = "https://downloads.php.net/~ab/php-7.0.0beta1.tar.bz2";
+    sha256 = "1pj3ysfhswg2r370ivp33fv9zbcl3yvhmxgnc731k08hv6hmd984";
+  });
+
+}
diff --git a/pkgs/development/interpreters/php/generic.nix b/pkgs/development/interpreters/php/generic.nix
deleted file mode 100644
index e71b6238173..00000000000
--- a/pkgs/development/interpreters/php/generic.nix
+++ /dev/null
@@ -1,291 +0,0 @@
-{ stdenv, fetchurl, composableDerivation, autoconf, automake, flex, bison
-, mysql, libxml2, readline, zlib, curl, postgresql, gettext
-, openssl, pkgconfig, sqlite, config, libjpeg, libpng, freetype
-, libxslt, libmcrypt, bzip2, icu, openldap, cyrus_sasl, libmhash, freetds
-, uwimap, pam, gmp
-
-, phpVersion, apacheHttpd, sha
-, php7 ? false, url ? null }:
-
-let
-  libmcryptOverride = libmcrypt.override { disablePosixThreads = true; };
-in
-
-composableDerivation.composableDerivation {} ( fixed : let inherit (fixed.fixed) version; in {
-
-  version = "${phpVersion}";
-
-  name = "php-${version}";
-
-  enableParallelBuilding = true;
-
-  buildInputs = [ flex bison pkgconfig ];
-
-  flags = {
-
-    # much left to do here...
-
-    # SAPI modules:
-
-    apxs2 = {
-      configureFlags = ["--with-apxs2=${apacheHttpd}/bin/apxs"];
-      buildInputs = [apacheHttpd];
-    };
-
-    # Extensions
-    imap = {
-      configureFlags = [
-        "--with-imap=${uwimap}"
-        "--with-imap-ssl"
-        ];
-      buildInputs = [ uwimap openssl pam ];
-    };
-
-    ldap = {
-      configureFlags = ["--with-ldap=${openldap}"];
-      buildInputs = [openldap cyrus_sasl openssl];
-    };
-
-    mhash = {
-      configureFlags = ["--with-mhash"];
-      buildInputs = [libmhash];
-    };
-
-    curl = {
-      configureFlags = ["--with-curl=${curl}"];
-      buildInputs = [curl openssl];
-    };
-
-    curlWrappers = {
-      configureFlags = ["--with-curlwrappers"];
-    };
-
-    zlib = {
-      configureFlags = ["--with-zlib=${zlib}"];
-      buildInputs = [zlib];
-    };
-
-    libxml2 = {
-      configureFlags = [
-        "--with-libxml-dir=${libxml2}"
-        ];
-      buildInputs = [ libxml2 ];
-    };
-
-    pcntl = {
-      configureFlags = [ "--enable-pcntl" ];
-    };
-
-    readline = {
-      configureFlags = ["--with-readline=${readline}"];
-      buildInputs = [ readline ];
-    };
-
-    sqlite = {
-      configureFlags = ["--with-pdo-sqlite=${sqlite}"];
-      buildInputs = [ sqlite ];
-    };
-
-    postgresql = {
-      configureFlags = ["--with-pgsql=${postgresql}"];
-      buildInputs = [ postgresql ];
-    };
-
-    pdo_pgsql = {
-      configureFlags = ["--with-pdo-pgsql=${postgresql}"];
-      buildInputs = [ postgresql ];
-    };
-
-    mysql = {
-      configureFlags = ["--with-mysql=${mysql.lib}"];
-      buildInputs = [ mysql.lib ];
-    };
-
-    mysqli = {
-      configureFlags = ["--with-mysqli=${mysql.lib}/bin/mysql_config"];
-      buildInputs = [ mysql.lib ];
-    };
-
-    mysqli_embedded = {
-      configureFlags = ["--enable-embedded-mysqli"];
-      depends = "mysqli";
-      assertion = fixed.mysqliSupport;
-    };
-
-    pdo_mysql = {
-      configureFlags = ["--with-pdo-mysql=${mysql.lib}"];
-      buildInputs = [ mysql.lib ];
-    };
-
-    bcmath = {
-      configureFlags = ["--enable-bcmath"];
-    };
-
-    gd = {
-      # FIXME: Our own gd package doesn't work, see https://bugs.php.net/bug.php?id=60108.
-      configureFlags = [
-        "--with-gd"
-        "--with-freetype-dir=${freetype}"
-        "--with-png-dir=${libpng}"
-        "--with-jpeg-dir=${libjpeg}"
-      ];
-      buildInputs = [ libpng libjpeg freetype ];
-    };
-
-    gmp = {
-      configureFlags = ["--with-gmp=${gmp}"];
-      buildInputs = [ gmp ];
-    };
-
-    soap = {
-      configureFlags = ["--enable-soap"];
-    };
-
-    sockets = {
-      configureFlags = ["--enable-sockets"];
-    };
-
-    openssl = {
-      configureFlags = ["--with-openssl=${openssl}"];
-      buildInputs = [openssl];
-    };
-
-    mbstring = {
-      configureFlags = ["--enable-mbstring"];
-    };
-
-    gettext = {
-      configureFlags = ["--with-gettext=${gettext}"];
-      buildInputs = [gettext];
-    };
-
-    intl = {
-      configureFlags = ["--enable-intl"];
-      buildInputs = [icu];
-    };
-
-    exif = {
-      configureFlags = ["--enable-exif"];
-    };
-
-    xsl = {
-      configureFlags = ["--with-xsl=${libxslt}"];
-      buildInputs = [libxslt];
-    };
-
-    mcrypt = {
-      configureFlags = ["--with-mcrypt=${libmcryptOverride}"];
-      buildInputs = [libmcryptOverride];
-    };
-
-    bz2 = {
-      configureFlags = ["--with-bz2=${bzip2}"];
-      buildInputs = [bzip2];
-    };
-
-    zip = {
-      configureFlags = ["--enable-zip"];
-    };
-
-    ftp = {
-      configureFlags = ["--enable-ftp"];
-    };
-
-    fpm = {
-      configureFlags = ["--enable-fpm"];
-    };
-
-    mssql = stdenv.lib.optionalAttrs (!stdenv.isDarwin) {
-      configureFlags = ["--with-mssql=${freetds}"];
-      buildInputs = [freetds];
-    };
-
-    zts = {
-      configureFlags = ["--enable-maintainer-zts"];
-    };
-
-    calendar = {
-      configureFlags = ["--enable-calendar"];
-    };
-  };
-
-  cfg = {
-    imapSupport = config.php.imap or true;
-    ldapSupport = config.php.ldap or true;
-    mhashSupport = config.php.mhash or true;
-    mysqlSupport = (!php7) && (config.php.mysql or true);
-    mysqliSupport = config.php.mysqli or true;
-    pdo_mysqlSupport = config.php.pdo_mysql or true;
-    libxml2Support = config.php.libxml2 or true;
-    apxs2Support = config.php.apxs2 or true;
-    bcmathSupport = config.php.bcmath or true;
-    socketsSupport = config.php.sockets or true;
-    curlSupport = config.php.curl or true;
-    curlWrappersSupport = (!php7) && (config.php.curlWrappers or true);
-    gettextSupport = config.php.gettext or true;
-    pcntlSupport = config.php.pcntl or true;
-    postgresqlSupport = config.php.postgresql or true;
-    pdo_pgsqlSupport = config.php.pdo_pgsql or true;
-    readlineSupport = config.php.readline or true;
-    sqliteSupport = config.php.sqlite or true;
-    soapSupport = config.php.soap or true;
-    zlibSupport = config.php.zlib or true;
-    opensslSupport = config.php.openssl or true;
-    mbstringSupport = config.php.mbstring or true;
-    gdSupport = config.php.gd or true;
-    intlSupport = config.php.intl or true;
-    exifSupport = config.php.exif or true;
-    xslSupport = config.php.xsl or false;
-    mcryptSupport = config.php.mcrypt or true;
-    bz2Support = config.php.bz2 or false;
-    zipSupport = config.php.zip or true;
-    ftpSupport = config.php.ftp or true;
-    fpmSupport = config.php.fpm or true;
-    gmpSupport = config.php.gmp or true;
-    mssqlSupport = (!php7) && (config.php.mssql or (!stdenv.isDarwin));
-    ztsSupport = config.php.zts or false;
-    calendarSupport = config.php.calendar or true;
-  };
-
-  configurePhase = ''
-    # Don't record the configure flags since this causes unnecessary
-    # runtime dependencies.
-    for i in main/build-defs.h.in scripts/php-config.in; do
-      substituteInPlace $i \
-        --replace '@CONFIGURE_COMMAND@' '(omitted)' \
-        --replace '@CONFIGURE_OPTIONS@' "" \
-        --replace '@PHP_LDFLAGS@' ""
-    done
-
-    iniFile=$out/etc/php-recommended.ini
-    [[ -z "$libxml2" ]] || export PATH=$PATH:$libxml2/bin
-    ./configure --with-config-file-scan-dir=/etc --with-config-file-path=$out/etc --prefix=$out $configureFlags
-  '';
-
-  installPhase = ''
-    unset installPhase; installPhase;
-    cp php.ini-production $iniFile
-  '';
-
-  src = fetchurl {
-    url = if url == null then
-      "http://www.php.net/distributions/php-${version}.tar.bz2"
-    else
-      url;
-    sha256 = sha;
-  };
-
-  meta = with stdenv.lib; {
-    description = "An HTML-embedded scripting language";
-    homepage = http://www.php.net/;
-    license = stdenv.lib.licenses.php301;
-    maintainers = with maintainers; [ globin ];
-  };
-
-  patches = if !php7 then
-    [ ./fix-paths.patch ]
-  else
-    [ ./fix-paths-php7.patch ]
-  ;
-
-})
diff --git a/pkgs/development/libraries/gnutls/3.3.nix b/pkgs/development/libraries/gnutls/3.3.nix
index bd95ce07254..1359980e19d 100644
--- a/pkgs/development/libraries/gnutls/3.3.nix
+++ b/pkgs/development/libraries/gnutls/3.3.nix
@@ -1,10 +1,10 @@
 { callPackage, fetchurl, ... } @ args:
 
 callPackage ./generic.nix (args // rec {
-  version = "3.3.16";
+  version = "3.3.17";
 
   src = fetchurl {
     url = "ftp://ftp.gnutls.org/gcrypt/gnutls/v3.3/gnutls-${version}.tar.lz";
-    sha256 = "1jl5n02mh83ygrrk7rq8vwylv5gdr3wccqs1ynvzr749fd2wq637";
+    sha256 = "00zrwqvy054fymb6j04xfr583javfjxsid2rbmyk63qrbqzm61v7";
   };
 })
diff --git a/pkgs/development/libraries/gnutls/3.4.nix b/pkgs/development/libraries/gnutls/3.4.nix
index 0558e4127c4..d5f74802fa5 100644
--- a/pkgs/development/libraries/gnutls/3.4.nix
+++ b/pkgs/development/libraries/gnutls/3.4.nix
@@ -1,10 +1,10 @@
 { callPackage, fetchurl, ... } @ args:
 
 callPackage ./generic.nix (args // rec {
-  version = "3.4.3";
+  version = "3.4.4";
 
   src = fetchurl {
     url = "ftp://ftp.gnutls.org/gcrypt/gnutls/v3.4/gnutls-${version}.tar.lz";
-    sha256 = "1q4adb1xi9pl00iy3cqs4r1qmwllv1g1r44p6xsg6n65dpyf53q2";
+    sha256 = "17xazr0fdhlkr13bwiy52xq6z6mssml7q1ydyj8s1hwh68703c75";
   };
 })
diff --git a/pkgs/development/libraries/gnutls/generic.nix b/pkgs/development/libraries/gnutls/generic.nix
index 95768c3ab48..21fb721a079 100644
--- a/pkgs/development/libraries/gnutls/generic.nix
+++ b/pkgs/development/libraries/gnutls/generic.nix
@@ -1,5 +1,5 @@
-{ lib, fetchurl, stdenv, autoreconfHook, zlib, lzo, libtasn1, nettle, pkgconfig, lzip
-, guileBindings, guile, perl, gmp, libidn, p11_kit, unbound
+{ lib, fetchurl, stdenv, zlib, lzo, libtasn1, nettle, pkgconfig, lzip
+, guileBindings, guile, perl, gmp, autogen, libidn, p11_kit, unbound
 , tpmSupport ? false, trousers
 
 # Version dependent args
@@ -29,12 +29,12 @@ stdenv.mkDerivation rec {
   # for the actual fix.
   enableParallelBuilding = !guileBindings;
 
-  buildInputs = [ lzo lzip nettle libtasn1 libidn p11_kit zlib gmp ]
+  buildInputs = [ lzo lzip nettle libtasn1 libidn p11_kit zlib gmp autogen ]
     ++ lib.optional (tpmSupport && stdenv.isLinux) trousers
     ++ [ unbound ]
     ++ lib.optional guileBindings guile;
 
-  nativeBuildInputs = [ perl pkgconfig autoreconfHook ];
+  nativeBuildInputs = [ perl pkgconfig ];
 
   # XXX: Gnulib's `test-select' fails on FreeBSD:
   # http://hydra.nixos.org/build/2962084/nixlog/1/raw .
diff --git a/pkgs/development/libraries/libassuan/default.nix b/pkgs/development/libraries/libassuan/default.nix
index 5202ad83605..d874d1e9ef5 100644
--- a/pkgs/development/libraries/libassuan/default.nix
+++ b/pkgs/development/libraries/libassuan/default.nix
@@ -1,11 +1,11 @@
 { fetchurl, stdenv, pth, libgpgerror }:
 
 stdenv.mkDerivation rec {
-  name = "libassuan-2.2.0";
+  name = "libassuan-2.2.1";
 
   src = fetchurl {
     url = "mirror://gnupg/libassuan/${name}.tar.bz2";
-    sha256 = "1ikf9whfi7rg71qa610ynyv12qrw20zkn7zxgvvr9dp41gbqxxbx";
+    sha256 = "1pp2kl5gc2vja41g3wk03h1hgh7gxy6pj354fb5n4lrlg6xqb4ll";
   };
 
   buildInputs = [ libgpgerror pth ];
diff --git a/pkgs/development/libraries/libaudclient/default.nix b/pkgs/development/libraries/libaudclient/default.nix
new file mode 100644
index 00000000000..c44639d1f39
--- /dev/null
+++ b/pkgs/development/libraries/libaudclient/default.nix
@@ -0,0 +1,20 @@
+{ stdenv, fetchurl, pkgconfig, glib, dbus_glib }:
+
+stdenv.mkDerivation rec {
+  name = "libaudclient-3.5-rc2";
+  version = "3.5-rc2";
+
+  src = fetchurl {
+    url = "http://distfiles.audacious-media-player.org/${name}.tar.bz2";
+    sha256 = "0nhpgz0kg8r00z54q5i96pjk7s57krq3fvdypq496c7fmlv9kdap";
+  };
+
+  buildInputs = [ pkgconfig glib dbus_glib ];
+
+  meta = with stdenv.lib; {
+    description = "Legacy D-Bus client library for Audacious";
+    homepage = http://audacious-media-player.org/;
+    license = licenses.bsd2;
+    maintainers = with maintainers; [ pSub ];
+  };
+}
diff --git a/pkgs/development/libraries/libchamplain/default.nix b/pkgs/development/libraries/libchamplain/default.nix
index 1a3c33eb80a..f0b4a1064fe 100644
--- a/pkgs/development/libraries/libchamplain/default.nix
+++ b/pkgs/development/libraries/libchamplain/default.nix
@@ -13,8 +13,6 @@ stdenv.mkDerivation rec {
 
   propagatedBuildInputs = [ glib gtk3 cairo clutter_gtk sqlite libsoup ];
 
-  configureFlags = [ "--disable-introspection" ]; # not needed anywhere AFAIK
-
   meta = {
     homepage = http://projects.gnome.org/libchamplain/;
     license = stdenv.lib.licenses.lgpl2Plus;
diff --git a/pkgs/development/libraries/libgsf/default.nix b/pkgs/development/libraries/libgsf/default.nix
index d08e4c231f5..b7e774b5223 100644
--- a/pkgs/development/libraries/libgsf/default.nix
+++ b/pkgs/development/libraries/libgsf/default.nix
@@ -4,11 +4,11 @@
 with { inherit (stdenv.lib) optionals; };
 
 stdenv.mkDerivation rec {
-  name = "libgsf-1.14.32";
+  name = "libgsf-1.14.34";
 
   src = fetchurl {
     url    = "mirror://gnome/sources/libgsf/1.14/${name}.tar.xz";
-    sha256 = "13bf38b848c01e20eb89a48150b6f864434ee4dfbb6301ddf6f4080a36cd99e9";
+    sha256 = "f0fea447e0374a73df45b498fd1701393f8e6acb39746119f8a292fb4a0cb528";
   };
 
   nativeBuildInputs = [ pkgconfig intltool ];
diff --git a/pkgs/development/libraries/libinput/default.nix b/pkgs/development/libraries/libinput/default.nix
index f02b0af8270..528ef71cda4 100644
--- a/pkgs/development/libraries/libinput/default.nix
+++ b/pkgs/development/libraries/libinput/default.nix
@@ -1,6 +1,6 @@
 { stdenv, fetchurl, pkgconfig
 , libevdev, mtdev, udev
-, documentationSupport ? true, doxygen ? null, graphviz ? null # Documentation
+, documentationSupport ? false, doxygen ? null, graphviz ? null # Documentation
 , eventGUISupport ? false, cairo ? null, glib ? null, gtk3 ? null # GUI event viewer support
 , testsSupport ? false, check ? null, valgrind ? null
 }:
@@ -15,11 +15,11 @@ in
 
 with stdenv.lib;
 stdenv.mkDerivation rec {
-  name = "libinput-0.20.0";
+  name = "libinput-0.21.0";
 
   src = fetchurl {
     url = "http://www.freedesktop.org/software/libinput/${name}.tar.xz";
-    sha256 = "0p8jswag33qjjxd8766hzk460bzhzhw32b6hl2i17aygjz7dynqp";
+    sha256 = "0l7mhdr50g11hxg2pz8ihsgzbm0810syj05d3555rzhda6g7mkkw";
   };
 
   configureFlags = [
diff --git a/pkgs/development/libraries/libpsl/default.nix b/pkgs/development/libraries/libpsl/default.nix
index 753577a2918..883ba807eda 100644
--- a/pkgs/development/libraries/libpsl/default.nix
+++ b/pkgs/development/libraries/libpsl/default.nix
@@ -5,11 +5,11 @@ let
 
   version = "${libVersion}-list-${listVersion}";
 
-  listVersion = "2015-08-03";
+  listVersion = "2015-08-07";
   listArchive = let
-    rev = "447962d71bf512fe41e828afc7fa66a1701c7c3c";
+    rev = "de9af76664aa5fd89dfee3c44c56ba91c03eefab";
   in fetchurl {
-    sha256 = "0gp0cb6p8yvyy5kvgdwg45ian9rb07bb0a9ibdj58g21l54mx3r2";
+    sha256 = "007yxs92dffgapkqik6rfrng5af8hjzf8wd7hlff91q836k40abi";
     url = "https://codeload.github.com/publicsuffix/list/tar.gz/${rev}";
   };
 
diff --git a/pkgs/development/libraries/libtorrent-rasterbar/0.16.nix b/pkgs/development/libraries/libtorrent-rasterbar/0.16.nix
index 6298f2f0c0f..985c570a34e 100644
--- a/pkgs/development/libraries/libtorrent-rasterbar/0.16.nix
+++ b/pkgs/development/libraries/libtorrent-rasterbar/0.16.nix
@@ -1,6 +1,6 @@
 { callPackage, ... } @ args:
 
 callPackage ./generic.nix (args // {
-  version = "0.16.17";
-  sha256 = "1w5gcizd6jlvzwgy0307az856h0cly685yf275p1v6bdcafd58b7";
+  version = "0.16.19";
+  sha256 = "1nlrivhnshn4wd9m5dsbjmq84731z9f9glj5q3vxz0c01s1lv7vw";
 })
diff --git a/pkgs/development/libraries/libtorrent-rasterbar/default.nix b/pkgs/development/libraries/libtorrent-rasterbar/default.nix
index e1f1fc179d6..725b98cdae6 100644
--- a/pkgs/development/libraries/libtorrent-rasterbar/default.nix
+++ b/pkgs/development/libraries/libtorrent-rasterbar/default.nix
@@ -1,6 +1,6 @@
 { callPackage, ... } @ args:
 
 callPackage ./generic.nix (args // {
-  version = "1.0.2";
-  sha256 = "1ph4cb6nrk2hiy89j3kz1wj16ph0b9yixrf4f4935rnzhha8x31w";
+  version = "1.0.6";
+  sha256 = "1qypc5lx82vlqm9016knxx8khxpc9dy78a0q2x5jmxjk8v6g994r";
 })
diff --git a/pkgs/development/libraries/libtorrent-rasterbar/generic.nix b/pkgs/development/libraries/libtorrent-rasterbar/generic.nix
index b866f66dbfa..a5bb258af1a 100644
--- a/pkgs/development/libraries/libtorrent-rasterbar/generic.nix
+++ b/pkgs/development/libraries/libtorrent-rasterbar/generic.nix
@@ -1,18 +1,26 @@
-{ stdenv, fetchurl, boost, openssl, pkgconfig, zlib, python, libiconv, geoip
+{ stdenv, fetchurl, automake, autoconf, boost, openssl, lib, libtool, pkgconfig, zlib, python, libiconv, geoip
 # Version specific options
 , version, sha256
 , ... }:
 
+let formattedVersion = lib.replaceChars ["."] ["_"] version;
+
+in
+
 stdenv.mkDerivation rec {
   name = "libtorrent-rasterbar-${version}";
   
   src = fetchurl {
-    url = "mirror://sourceforge/libtorrent/${name}.tar.gz";
+    url = "https://github.com/arvidn/libtorrent/archive/libtorrent-${formattedVersion}.tar.gz";
     inherit sha256;
   };
 
+  nativeBuildInputs = [automake autoconf libtool ];
+
   buildInputs = [ boost pkgconfig openssl zlib python libiconv geoip ];
 
+  preConfigure = "./autotool.sh";
+
   configureFlags = [ 
     "--enable-python-binding"
     "--with-libgeoip=system"
@@ -21,6 +29,8 @@ stdenv.mkDerivation rec {
     "--with-boost-libdir=${boost.lib}/lib"
     "--with-libiconv=yes"
   ];
+
+  enableParallelBuilding = true;
   
   meta = with stdenv.lib; {
     homepage = http://www.rasterbar.com/products/libtorrent/;
diff --git a/pkgs/development/libraries/nettle/generic.nix b/pkgs/development/libraries/nettle/generic.nix
index 6044f978402..3c439eb404c 100644
--- a/pkgs/development/libraries/nettle/generic.nix
+++ b/pkgs/development/libraries/nettle/generic.nix
@@ -16,9 +16,6 @@ stdenv.mkDerivation (rec {
 
   enableParallelBuilding = true;
 
-  # It doesn't build otherwise
-  dontDisableStatic = true;
-
   patches = stdenv.lib.optional (stdenv.system == "i686-cygwin")
               ./cygwin.patch;
 
diff --git a/pkgs/development/libraries/nss/default.nix b/pkgs/development/libraries/nss/default.nix
index b9c737e231b..5c73f5db26f 100644
--- a/pkgs/development/libraries/nss/default.nix
+++ b/pkgs/development/libraries/nss/default.nix
@@ -11,11 +11,11 @@ let
 
 in stdenv.mkDerivation rec {
   name = "nss-${version}";
-  version = "3.19.2";
+  version = "3.19.3";
 
   src = fetchurl {
-    url = "http://ftp.mozilla.org/pub/mozilla.org/security/nss/releases/NSS_3_19_2_RTM/src/${name}.tar.gz";
-    sha256 = "1306663e8f61d8449ad8cbcffab743a604dcd9f6f34232c210847c51dce2c9ae";
+    url = "http://ftp.mozilla.org/pub/mozilla.org/security/nss/releases/NSS_3_19_3_RTM/src/${name}.tar.gz";
+    sha256 = "c56bdad20736a8227afb3c97b25d6d2eb3982e979ddc9be1d66cb7199ae8ca8f";
   };
 
   buildInputs = [ nspr perl zlib sqlite ];
diff --git a/pkgs/development/tools/build-managers/sbt/default.nix b/pkgs/development/tools/build-managers/sbt/default.nix
index a273ea75087..b4cfc0bf0c1 100644
--- a/pkgs/development/tools/build-managers/sbt/default.nix
+++ b/pkgs/development/tools/build-managers/sbt/default.nix
@@ -2,11 +2,11 @@
 
 stdenv.mkDerivation rec {
   name = "sbt-${version}";
-  version = "0.13.8";
+  version = "0.13.9";
 
   src = fetchurl {
     url = "http://repo.typesafe.com/typesafe/ivy-releases/org.scala-sbt/sbt-launch/${version}/sbt-launch.jar";
-    sha256 = "0n4ivla8s8ygfnf95dj624nhcyganigf7fy0gamgyf31vw1vnw35";
+    sha256 = "04k411gcrq35ayd2xj79bcshczslyqkicwvhkf07hkyr4j3blxda";
   };
 
   phases = [ "installPhase" ];
diff --git a/pkgs/development/tools/misc/autogen/default.nix b/pkgs/development/tools/misc/autogen/default.nix
index 01c5fd7dcba..71ea938ea78 100644
--- a/pkgs/development/tools/misc/autogen/default.nix
+++ b/pkgs/development/tools/misc/autogen/default.nix
@@ -1,55 +1,30 @@
-{ fetchurl, stdenv, guile, which, libffi }:
-
-let version = "5.18"; in
-
-  stdenv.mkDerivation {
-    name = "autogen-${version}";
-
-    src = fetchurl {
-      url = "mirror://gnu/autogen/rel${version}/autogen-${version}.tar.gz";
-      sha256 = "1h2d3wpzkla42igxyisaqh2nwpq01vwad1wp9671xmm5ahvkw5f7";
-    };
-
-    buildInputs = [ guile which libffi ];
-
-    patchPhase =
-      '' for i in $(find -name \*.in)
-         do
-           sed -i "$i" -e's|/usr/bin/||g'
-         done
-      '';
-
-    # The tests rely on being able to find `libopts.a'.
-    configureFlags = "--enable-static";
-
-    #doCheck = true; # 2 tests fail because of missing /dev/tty
-
-    meta = with stdenv.lib; {
-      description = "Automated text and program generation tool";
-
-      longDescription = ''
-        AutoGen is a tool designed to simplify the creation and maintenance
-        of programs that contain large amounts of repetitious text.  It is
-        especially valuable in programs that have several blocks of text that
-        must be kept synchronized.
-
-        AutoGen can now accept XML files as definition input, in addition to
-        CGI data (for producing dynamic HTML) and traditional AutoGen
-        definitions.
-
-        A common example where this would be useful is in creating and
-        maintaining the code required for processing program options.
-        Processing options requires multiple constructs to be maintained in
-        parallel in different places in your program.  Options maintenance
-        needs to be done countless times.  So, AutoGen comes with an add-on
-        package named AutoOpts that simplifies the maintenance and
-        documentation of program options.
-      '';
-
-      license = with licenses; [ gpl3Plus lgpl3Plus ];
-
-      homepage = http://www.gnu.org/software/autogen/;
-
-      maintainers = [ ];
-    };
-  }
+{ stdenv, fetchurl, which, pkgconfig, perl, guile, libxml2 }:
+
+stdenv.mkDerivation rec {
+  name = "autogen-${version}";
+  version = "5.18.5";
+
+  src = fetchurl {
+    url = "mirror://gnu/autogen/rel${version}/autogen-${version}.tar.gz";
+    sha256 = "1flnbnmkbqmbfgammkl8m36wrlk6rhpgnf9pdm6gdfhqalxvggbv";
+  };
+
+  nativeBuildInputs = [ which pkgconfig perl ];
+  buildInputs = [ guile libxml2 ];
+
+  postPatch = ''
+    # Fix a broken sed expression used for detecting the minor
+    # version of guile we are using
+    sed -i "s,sed '.*-I.*',sed 's/\\\(^\\\| \\\)-I/\\\1/g',g" configure
+  '';
+
+  #doCheck = true; # 2 tests fail because of missing /dev/tty
+
+  meta = with stdenv.lib; {
+    description = "Automated text and program generation tool";
+    license = with licenses; [ gpl3Plus lgpl3Plus ];
+    homepage = http://www.gnu.org/software/autogen/;
+    platforms = platforms.all;
+    maintainers = [ ];
+  };
+}
diff --git a/pkgs/games/freeciv/default.nix b/pkgs/games/freeciv/default.nix
index ac1fc7395ae..1ad9685a505 100644
--- a/pkgs/games/freeciv/default.nix
+++ b/pkgs/games/freeciv/default.nix
@@ -1,32 +1,39 @@
 { stdenv, fetchurl, zlib, bzip2, pkgconfig, curl, lzma, gettext
-, sdlClient ? true, SDL, SDL_mixer, SDL_image, SDL_ttf, SDL_gfx, freetype
+, sdlClient ? true, SDL, SDL_mixer, SDL_image, SDL_ttf, SDL_gfx, freetype, fluidsynth
 , gtkClient ? false, gtk
 , server ? true, readline }:
 
 let
   inherit (stdenv.lib) optional optionals;
-  client = sdlClient || gtkClient;
 
   sdlName = if sdlClient then "-sdl" else "";
   gtkName = if gtkClient then "-gtk" else "";
 
-  baseName = "freeciv-2.4.0";
+  name = "freeciv";
+  version = "2.5.0";
 in
 stdenv.mkDerivation {
-  name = baseName + sdlName + gtkName;
+  name = "${name}${sdlName}${gtkName}-${version}";
 
   src = fetchurl {
-    url = "mirror://sourceforge/freeciv/${baseName}.tar.bz2";
-    sha256 = "1bc01pyihsrby6w95n49gi90ggp40dyxsy4kmlmwcakxfxprwakv";
+    url = "mirror://sourceforge/freeciv/${name}-${version}.tar.bz2";
+    sha256 = "bd9f7523ea79b8d2806d0c1844a9f48506ccd18276330580319913c43051210b";
+    # sha1 = "477b60e02606e47b31a019b065353c1a6da6c305";
+    # md5 = "8a61ecd986853200326711446c573f1b";
   };
 
   nativeBuildInputs = [ pkgconfig ];
 
   buildInputs = [ zlib bzip2 curl lzma gettext ]
-    ++ optionals sdlClient [ SDL SDL_mixer SDL_image SDL_ttf SDL_gfx freetype ]
-    ++ optional gtkClient gtk
+    ++ optionals sdlClient [ SDL SDL_mixer SDL_image SDL_ttf SDL_gfx freetype fluidsynth ]
+    ++ optionals gtkClient [ gtk ]
     ++ optional server readline;
 
+  configureFlags = []
+    ++ optional sdlClient "--enable-client=sdl"
+    ++ optional (!gtkClient) "--enable-fcmp=cli"
+    ++ optional (!server) "--disable-server";
+
   meta = with stdenv.lib; {
     description = "Multiplayer (or single player), turn-based strategy game";
 
diff --git a/pkgs/games/privateer/default.nix b/pkgs/games/privateer/default.nix
index bb67f422c9d..2eb3a916eb3 100644
--- a/pkgs/games/privateer/default.nix
+++ b/pkgs/games/privateer/default.nix
@@ -28,10 +28,16 @@ stdenv.mkDerivation {
     cp vegastrike $out/bin
     cp vegaserver $out/bin
   '';
-  
-  meta = {
+
+  meta = with stdenv.lib; {
     homepage = http://privateer.sourceforge.net/;
-    longDescription = "";
-    maintainers = with stdenv.lib.maintainers; [ chaoflow ];
+    description = "Adventure space flight simulation computer game";
+    license = licenses.gpl2Plus; # and a special license for art data
+    # https://sourceforge.net/p/privateer/code/HEAD/tree/privgold/trunk/data/art-license.txt
+
+    maintainers = with maintainers; [ chaoflow ];
+    platforms = with platforms; linux ++ darwin;
+    hydraPlatforms = [];
+    broken = true; # it won't build
   };
 }
diff --git a/pkgs/games/qqwing/default.nix b/pkgs/games/qqwing/default.nix
new file mode 100644
index 00000000000..30c9ca66d10
--- /dev/null
+++ b/pkgs/games/qqwing/default.nix
@@ -0,0 +1,35 @@
+{ stdenv, fetchFromGitHub, perl, autoconf, automake, libtool }:
+
+stdenv.mkDerivation rec {
+  name = "qqwing-${version}";
+  version = "1.3.4";
+
+  src = fetchFromGitHub {
+    owner = "stephenostermiller";
+    repo = "qqwing";
+    rev = "v${version}";
+    sha256 = "1qq0vi4ch4y3a5fb1ncr0yzkj3mbvdiwa3d51qpabq94sh0cz09i";
+  };
+
+  postPatch = ''
+    for file in "src-first-comment.pl" "src_neaten.pl"; do
+      substituteInPlace "build/$file" \
+        --replace "#!/usr/bin/perl" "#!${perl}/bin/perl"
+    done
+
+    substituteInPlace "build/cpp_install.sh" \
+      --replace "sudo " ""
+  '';
+
+  buildInputs = [ perl autoconf automake libtool ];
+
+  makeFlags = [ "prefix=$(out)" "tgz" ];
+
+  meta = with stdenv.lib; {
+    homepage = https://qqwing.com;
+    description = "Sudoku generating and solving software";
+    license = licenses.gpl2;
+    platforms = platforms.linux;
+    maintainers = with maintainers; [ jgeerds ];
+  };
+}
diff --git a/pkgs/games/tibia/default.nix b/pkgs/games/tibia/default.nix
index 03729cfae3b..dc4a8ac3692 100644
--- a/pkgs/games/tibia/default.nix
+++ b/pkgs/games/tibia/default.nix
@@ -3,11 +3,11 @@
 with stdenv.lib;
 assert stdenv.isi686;
 stdenv.mkDerivation {
-  name = "tibia-10.80";
+  name = "tibia-10.81";
 
   src = fetchurl {
-    url = http://static.tibia.com/download/tibia1080.tgz;
-    sha256 = "0ng7gi64lsda8k3674nc2gwnr8si648nmwgghrjrcwyybgsyzfvl";
+    url = http://static.tibia.com/download/tibia1081.tgz;
+    sha256 = "19p102fg31slrwg09q8dzhvz48qp8yrkpq69djn0jb9hrs7k7fpr";
   };
 
   shell = stdenv.shell;
diff --git a/pkgs/misc/drivers/sundtek/default.nix b/pkgs/misc/drivers/sundtek/default.nix
index 0ad313a7233..c3b0711f23d 100644
--- a/pkgs/misc/drivers/sundtek/default.nix
+++ b/pkgs/misc/drivers/sundtek/default.nix
@@ -3,7 +3,7 @@
 with stdenv.lib;
 
 let
-  version = "30-06-2015";
+  version = "28-07-2015";
   rpath = makeLibraryPath [ "$out/lib" "$out/bin" ];
   platform = with stdenv;
     if isx86_64 then "64bit"
@@ -15,7 +15,7 @@ in
   stdenv.mkDerivation {
     src = fetchurl {
       url = "http://www.sundtek.de/media/netinst/${platform}/installer.tar.gz";
-      sha256 = "304d2785b5e9046c78fc092341721fdc404074105e63dd635e838559d42313c3";
+      sha256 = "1gpz42rwxm76fzq6088gjzbfl82mhapc34c0ms7vphrhra6yw19h";
     };
     name = "sundtek-${version}";
 
diff --git a/pkgs/os-specific/linux/ati-drivers/builder.sh b/pkgs/os-specific/linux/ati-drivers/builder.sh
index 8df03910146..520f20e2ed6 100644
--- a/pkgs/os-specific/linux/ati-drivers/builder.sh
+++ b/pkgs/os-specific/linux/ati-drivers/builder.sh
@@ -7,8 +7,11 @@ set -x
 die(){ echo $@; exit 1; }
 
 # custom unpack:
+mkdir fglrx
+cd fglrx
 unzip $src
-run_file=$(echo fglrx-*/amd-driver-installer-*)
+cd ..
+run_file=$(echo fglrx/amd-driver-installer-*)
 sh $run_file --extract .
 
 eval "$patchPhase"
diff --git a/pkgs/os-specific/linux/ati-drivers/default.nix b/pkgs/os-specific/linux/ati-drivers/default.nix
index 179166bbc79..834e798e8d1 100644
--- a/pkgs/os-specific/linux/ati-drivers/default.nix
+++ b/pkgs/os-specific/linux/ati-drivers/default.nix
@@ -31,7 +31,7 @@ assert (!libsOnly) -> kernel != null;
 with stdenv.lib;
 
 stdenv.mkDerivation {
-  name = "ati-drivers-14.12" + (optionalString (!libsOnly) "-${kernel.version}");
+  name = "ati-drivers-15.7" + (optionalString (!libsOnly) "-${kernel.version}");
 
   builder = ./builder.sh;
 
@@ -39,12 +39,12 @@ stdenv.mkDerivation {
   gcc = stdenv.cc.cc;
 
   src = fetchurl {
-    url = http://www2.ati.com/drivers/linux/amd-catalyst-omega-14.12-linux-run-installers.zip;
-    sha256 = "0jd2scrdlyapynxfjdrarnwcdzxjqrk5fg5i10g3bm0ay8v9hrk8";
+    url = "http://www2.ati.com/drivers/linux/amd-driver-installer-15.20.1046-x86.x86_64.zip";
+    sha256 = "ffde64203f49d9288eaa25f4d744187b6f4f14a87a444bab6a001d822b327a9d";
     curlOpts = "--referer http://support.amd.com/en-us/download/desktop?os=Linux%20x86_64";
   };
 
-  patchPhase = "patch -p1 < ${./fglrx_3.17rc6-no_hotplug.patch}";
+  patchPhase = "patch -p1 < ${./kernel-api-fixes.patch}";
   patchPhaseSamples = "patch -p2 < ${./patch-samples.patch}";
 
   buildInputs =
diff --git a/pkgs/os-specific/linux/ati-drivers/fglrx_3.17rc6-no_hotplug.patch b/pkgs/os-specific/linux/ati-drivers/fglrx_3.17rc6-no_hotplug.patch
deleted file mode 100644
index 7afd54a59c5..00000000000
--- a/pkgs/os-specific/linux/ati-drivers/fglrx_3.17rc6-no_hotplug.patch
+++ /dev/null
@@ -1,31 +0,0 @@
-source: https://aur.archlinux.org/packages/catalyst/
-
-diff -uNr 14.9/common/lib/modules/fglrx/build_mod/firegl_public.c 14.9/common/lib/modules/fglrx/build_mod/firegl_public.c
---- 14.9/common/lib/modules/fglrx/build_mod/firegl_public.c	2014-09-09 16:10:17.000000000 +0200
-+++ 14.9/common/lib/modules/fglrx/build_mod/firegl_public.c	2014-09-26 19:01:44.000000000 +0200
-@@ -1093,6 +1093,9 @@
-     // directly here to allow suspend/resume without X server start. 
-         firegl_pci_save_state((KCL_PCI_DevHandle)pdev, privdev);
-         pci_disable_device(pdev);
-+#if LINUX_VERSION_CODE >= KERNEL_VERSION(3,17,0)
-+	pci_ignore_hotplug(pdev);
-+#endif
-         PMSG_EVENT(pdev->dev.power.power_state) = state;
-     }
-     else
-diff -uNr 14.9/common/lib/modules/fglrx/build_mod/kcl_acpi.c 14.9/common/lib/modules/fglrx/build_mod/kcl_acpi.c
---- 14.9/common/lib/modules/fglrx/build_mod/kcl_acpi.c	2014-09-09 16:10:17.000000000 +0200
-+++ 14.9/common/lib/modules/fglrx/build_mod/kcl_acpi.c	2014-09-26 18:57:27.000000000 +0200
-@@ -840,10 +840,12 @@
-    if(tdev != NULL)
-    {
-       device = (acpi_device_adr(tdev) >> 16) & 0xffff;
-+#if LINUX_VERSION_CODE < KERNEL_VERSION(3,17,0)
-       if(PCI_SLOT(pdev->devfn) == device)
-       {
-          tdev->flags.no_hotplug = true;
-       }
-+#endif
-    }
- #endif
-    return 0;
diff --git a/pkgs/os-specific/linux/ati-drivers/kernel-api-fixes.patch b/pkgs/os-specific/linux/ati-drivers/kernel-api-fixes.patch
new file mode 100644
index 00000000000..f763518b249
--- /dev/null
+++ b/pkgs/os-specific/linux/ati-drivers/kernel-api-fixes.patch
@@ -0,0 +1,99 @@
+diff -Nru 15.7/common/lib/modules/fglrx/build_mod/firegl_public.c 15.7.new/common/lib/modules/fglrx/build_mod/firegl_public.c
+--- 15.7/common/lib/modules/fglrx/build_mod/firegl_public.c	2015-07-04 10:31:23.000000000 -0400
++++ 15.7.new/common/lib/modules/fglrx/build_mod/firegl_public.c	2015-08-03 21:21:13.893211082 -0400
+@@ -242,6 +242,14 @@
+ #endif
+ 
+ // ============================================================
++
++#if LINUX_VERSION_CODE < KERNEL_VERSION(3,18,0)
++#define __read_cr4 read_cr4
++#define __write_cr4 write_cr4
++#endif
++
++// ============================================================
++
+ /* globals */
+ 
+ char* firegl = NULL;
+@@ -3495,10 +3503,12 @@
+         KCL_PUB_InterruptHandlerWrap,
+ #if LINUX_VERSION_CODE < KERNEL_VERSION(2,6,22)
+         ((useMSI) ? (SA_INTERRUPT) : (SA_SHIRQ)),
+-#else
++#elif LINUX_VERSION_CODE < KERNEL_VERSION(4,1,0)
+         //when MSI enabled. keep irq disabled when calling the action handler,
+         //exclude this IRQ from irq balancing (only on one CPU) 
+         ((useMSI) ? (IRQF_DISABLED) : (IRQF_SHARED)),    
++#else
++        ((useMSI) ? 0 : IRQF_SHARED),
+ #endif
+         dev_name,
+         context);
+@@ -4498,8 +4508,8 @@
+ 
+     if (cpu_has_pge)
+     {
+-        cr4 = read_cr4();
+-        write_cr4(cr4 & ~X86_CR4_PGE);
++        cr4 = __read_cr4();
++        __write_cr4(cr4 & ~X86_CR4_PGE);
+     }
+      __flush_tlb();
+ 
+@@ -4512,7 +4522,7 @@
+     write_cr0(cr0 & 0xbfffffff);
+     if (cpu_has_pge)
+     {
+-        write_cr4(cr4);
++        __write_cr4(cr4);
+     }
+     local_irq_restore(flags);
+ 
+@@ -4539,8 +4549,8 @@
+ 
+     if (cpu_has_pge)
+     {
+-        cr4 = read_cr4();
+-        write_cr4(cr4 & ~X86_CR4_PGE);
++        cr4 = __read_cr4();
++        __write_cr4(cr4 & ~X86_CR4_PGE);
+     }
+      __flush_tlb();
+   
+@@ -4552,7 +4562,7 @@
+     write_cr0(cr0 & 0xbfffffff);
+     if (cpu_has_pge)
+     {
+-        write_cr4(cr4);
++        __write_cr4(cr4);
+     }
+     local_irq_restore(flags);
+ 
+diff -Nru 15.7/common/lib/modules/fglrx/build_mod/kcl_acpi.c 15.7.new/common/lib/modules/fglrx/build_mod/kcl_acpi.c
+--- 15.7/common/lib/modules/fglrx/build_mod/kcl_acpi.c	2015-07-04 10:31:23.000000000 -0400
++++ 15.7.new/common/lib/modules/fglrx/build_mod/kcl_acpi.c	2015-08-02 19:59:54.797911610 -0400
+@@ -861,7 +861,10 @@
+ #elif LINUX_VERSION_CODE >= KERNEL_VERSION(3,17,0)
+     if(pdev)
+     {
+-       pci_ignore_hotplug(pdev);
++      struct pci_dev *bridge = pdev->bus->self;
++
++      pdev->ignore_hotplug = 1;
++      if(bridge) bridge->ignore_hotplug = 1; 
+     }
+ #endif
+ }
+diff -Nru 15.7/common/lib/modules/fglrx/build_mod/kcl_str.c 15.7.new/common/lib/modules/fglrx/build_mod/kcl_str.c
+--- 15.7/common/lib/modules/fglrx/build_mod/kcl_str.c	2015-07-04 10:31:23.000000000 -0400
++++ 15.7.new/common/lib/modules/fglrx/build_mod/kcl_str.c	2015-08-03 00:35:25.938410435 -0400
+@@ -169,7 +169,7 @@
+                                   const char* s2,
+                                   KCL_TYPE_SizeSigned count)
+ {
+-    return strnicmp(s1, s2, count);
++    return strncasecmp(s1, s2, count);
+ }
+ 
+ /** \brief Locate character in string
diff --git a/pkgs/os-specific/linux/fanctl/default.nix b/pkgs/os-specific/linux/fanctl/default.nix
new file mode 100644
index 00000000000..f0b863e0148
--- /dev/null
+++ b/pkgs/os-specific/linux/fanctl/default.nix
@@ -0,0 +1,47 @@
+{ stdenv, lib, fetchbzr, makeWrapper, bridge-utils, iproute, dnsmasq, iptables, kmod, utillinux }:
+
+stdenv.mkDerivation rec {
+  name = "fanctl-${version}";
+
+  version = "0.3.0";
+
+  src = fetchbzr {
+    url = "https://code.launchpad.net/~ubuntu-branches/ubuntu/vivid/ubuntu-fan/vivid-updates";
+    rev = 2;
+    sha256 = "1vcr2rg99g7sx1zynhiggjzc9y9z591i4535hbm21dysy3cisp7i";
+  };
+
+  buildInputs = [ makeWrapper ];
+
+  # When given --conf-file="", dnsmasq still attempts to read /etc/dnsmasq.conf;
+  # if that files does not exist, dnsmasq subsequently fails,
+  # so we'll use /dev/null.
+  #
+  # Also, make sure /var/lib/ubuntu-fan exists before starting dnsmasq.
+  buildPhase = ''
+    substituteInPlace fanctl \
+      --replace '--conf-file= ' \
+                '--conf-file=/dev/null ' \
+      --replace '/var/lib/misc' \
+                '/var/lib/ubuntu-fan'
+
+    sed -i '/dnsmasq -u/i \
+    mkdir -p /var/lib/ubuntu-fan' fanctl
+  '';
+
+  installPhase = ''
+    mkdir -p $out/bin $out/man/man8
+    cp fanctl.8 $out/man/man8
+    cp fanctl $out/bin
+    wrapProgram $out/bin/fanctl --prefix PATH : \
+      ${lib.makeSearchPath "bin" [ bridge-utils iproute dnsmasq iptables kmod utillinux ]};
+  '';
+
+  meta = with lib; {
+    description = "Ubuntu FAN network support enablement";
+    homepage = "https://launchpad.net/ubuntu/+source/ubuntu-fan";
+    license = licenses.gpl2;
+    platforms = platforms.linux;
+    maintainers = with maintainers; [ cstrahan ];
+  };
+}
diff --git a/pkgs/os-specific/linux/iproute/default.nix b/pkgs/os-specific/linux/iproute/default.nix
index f7ca0481a31..6f5ec27c638 100644
--- a/pkgs/os-specific/linux/iproute/default.nix
+++ b/pkgs/os-specific/linux/iproute/default.nix
@@ -1,4 +1,6 @@
-{ fetchurl, stdenv, flex, bison, db, iptables, pkgconfig }:
+{ fetchurl, stdenv, lib, flex, bison, db, iptables, pkgconfig
+, enableFan ? false
+}:
 
 stdenv.mkDerivation rec {
   name = "iproute2-4.1.1";
@@ -8,7 +10,7 @@ stdenv.mkDerivation rec {
     sha256 = "0vz6m2k6hdrjlg4x0r3cd75lg9ysmndbsp35pm8494zvksc7l1vk";
   };
 
-  patch = [ ./vpnc.patch ];
+  patches = lib.optionals enableFan [ ./ubuntu-fan.patch ];
 
   preConfigure = ''
     patchShebangs ./configure
diff --git a/pkgs/os-specific/linux/iproute/ubuntu-fan.patch b/pkgs/os-specific/linux/iproute/ubuntu-fan.patch
new file mode 100644
index 00000000000..e55425c2ce6
--- /dev/null
+++ b/pkgs/os-specific/linux/iproute/ubuntu-fan.patch
@@ -0,0 +1,164 @@
+This provides support for Ubuntu's Fan Networking [1].
+
+These patches were pulled from:
+https://code.launchpad.net/~ubuntu-branches/ubuntu/vivid/iproute2/vivid-proposed
+
+See revisions 18 and 19.
+
+[1] https://wiki.ubuntu.com/FanNetworking
+
+diff --git a/include/linux/if_tunnel.h b/include/linux/if_tunnel.h
+index 102ce7a..7b8f0e5 100644
+--- a/include/linux/if_tunnel.h
++++ b/include/linux/if_tunnel.h
+@@ -57,6 +57,9 @@ enum {
+ 	IFLA_IPTUN_ENCAP_FLAGS,
+ 	IFLA_IPTUN_ENCAP_SPORT,
+ 	IFLA_IPTUN_ENCAP_DPORT,
++
++	IFLA_IPTUN_FAN_UNDERLAY = 32,
++	IFLA_IPTUN_FAN_MAP = 33,
+ 	__IFLA_IPTUN_MAX,
+ };
+ #define IFLA_IPTUN_MAX	(__IFLA_IPTUN_MAX - 1)
+@@ -131,4 +134,20 @@ enum {
+ };
+ 
+ #define IFLA_VTI_MAX	(__IFLA_VTI_MAX - 1)
++
++enum {
++	IFLA_FAN_UNSPEC,
++	IFLA_FAN_MAPPING,
++	__IFLA_FAN_MAX,
++};
++
++#define IFLA_FAN_MAX (__IFLA_FAN_MAX - 1)
++
++struct ip_tunnel_fan_map {
++	__be32		underlay;
++	__be32		overlay;
++	__u16		underlay_prefix;
++	__u16		overlay_prefix;
++};
++
+ #endif /* _IF_TUNNEL_H_ */
+diff --git a/ip/link_iptnl.c b/ip/link_iptnl.c
+index 9d6bc98..ec3f05d 100644
+--- a/ip/link_iptnl.c
++++ b/ip/link_iptnl.c
+@@ -49,6 +49,42 @@ static void usage(int sit)
+ 	print_usage(stderr, sit);
+ 	exit(-1);
+ }
++static int fan_parse_map(int *argcp, char ***argvp, struct nlmsghdr *n)
++{
++	inet_prefix underlay, overlay;
++	struct ip_tunnel_fan_map map;
++	struct rtattr *nest;
++	char **argv = *argvp;
++	int argc = *argcp;
++
++	nest = addattr_nest(n, 1024, IFLA_IPTUN_FAN_MAP);
++	while (argc > 0) {
++		char *colon = strchr(*argv, ':');
++
++		if (!colon)
++			break;
++		*colon = '\0';
++
++		if (get_prefix(&overlay, *argv, AF_INET))
++			invarg("invalid fan-map overlay", *argv);
++		if (get_prefix(&underlay, colon + 1, AF_INET))
++			invarg("invalid fan-map underlay", colon + 1);
++		
++		memcpy(&map.underlay, underlay.data, 4);
++		map.underlay_prefix = underlay.bitlen;
++		memcpy(&map.overlay, overlay.data, 4);
++		map.overlay_prefix = overlay.bitlen;
++
++		argc--, argv++;
++
++		addattr_l(n, 1024, IFLA_FAN_MAPPING, &map, sizeof(map));
++	}
++	addattr_nest_end(n, nest);
++
++	*argcp = argc;
++	*argvp = argv;
++	return 0;
++}
+ 
+ static int iptunnel_parse_opt(struct link_util *lu, int argc, char **argv,
+ 			      struct nlmsghdr *n)
+@@ -66,6 +102,7 @@ static int iptunnel_parse_opt(struct link_util *lu, int argc, char **argv,
+ 	__u32 link = 0;
+ 	__u32 laddr = 0;
+ 	__u32 raddr = 0;
++	__u32 underlay = 0;
+ 	__u8 ttl = 0;
+ 	__u8 tos = 0;
+ 	__u8 pmtudisc = 1;
+@@ -174,6 +211,13 @@ get_failed:
+ 				raddr = get_addr32(*argv);
+ 			else
+ 				raddr = 0;
++		} else if (strcmp(*argv, "underlay") == 0) {
++			NEXT_ARG();
++			underlay = get_addr32(*argv);
++		} else if (strcmp(*argv, "fan-map") == 0) {
++			NEXT_ARG();
++			if (fan_parse_map(&argc, &argv, n))
++				invarg("invalid fan-map", *argv);
+ 		} else if (strcmp(*argv, "local") == 0) {
+ 			NEXT_ARG();
+ 			if (strcmp(*argv, "any"))
+@@ -318,9 +362,32 @@ get_failed:
+ 		}
+ 	}
+ 
++	if (underlay)
++		addattr32(n, 1024, IFLA_IPTUN_FAN_UNDERLAY, underlay);
++
+ 	return 0;
+ }
+ 
++static void fan_print_map(FILE *f, struct rtattr *attr)
++{
++	char b1[INET_ADDRSTRLEN], b2[INET_ADDRSTRLEN];
++	struct ip_tunnel_fan_map *m;
++	struct rtattr *i;
++	int rem;
++
++	fprintf(f, "fan-map ");
++
++	rem = RTA_PAYLOAD(attr);
++	for (i = RTA_DATA(attr); RTA_OK(i, rem); i = RTA_NEXT(i, rem)) {
++		m = RTA_DATA(i);
++		fprintf(f, "%s/%d:%s/%d ",
++			rt_addr_n2a(AF_INET, sizeof(m->overlay), &m->overlay, b1, INET_ADDRSTRLEN),
++			m->overlay_prefix,
++			rt_addr_n2a(AF_INET, sizeof(m->overlay), &m->underlay, b2, INET_ADDRSTRLEN),
++			m->underlay_prefix);
++	}
++}
++
+ static void iptunnel_print_opt(struct link_util *lu, FILE *f, struct rtattr *tb[])
+ {
+ 	char s1[1024];
+@@ -349,6 +416,17 @@ static void iptunnel_print_opt(struct link_util *lu, FILE *f, struct rtattr *tb[
+ 
+ 	fprintf(f, "local %s ", local);
+ 
++	if (tb[IFLA_IPTUN_FAN_UNDERLAY]) {
++		unsigned addr = rta_getattr_u32(tb[IFLA_IPTUN_FAN_UNDERLAY]);
++
++		if (addr)
++			fprintf(f, "underlay %s ",
++				format_host(AF_INET, 4, &addr, s1, sizeof(s1)));
++	}
++
++	if (tb[IFLA_IPTUN_FAN_MAP])
++		fan_print_map(f, tb[IFLA_IPTUN_FAN_MAP]);
++
+ 	if (tb[IFLA_IPTUN_LINK] && rta_getattr_u32(tb[IFLA_IPTUN_LINK])) {
+ 		unsigned link = rta_getattr_u32(tb[IFLA_IPTUN_LINK]);
+ 		const char *n = if_indextoname(link, s2);
diff --git a/pkgs/os-specific/linux/iproute/vpnc.patch b/pkgs/os-specific/linux/iproute/vpnc.patch
deleted file mode 100644
index 0a65f3e5df5..00000000000
--- a/pkgs/os-specific/linux/iproute/vpnc.patch
+++ /dev/null
@@ -1,15 +0,0 @@
-vpnc fails with "RTNETLINK answers: No such device"
-Patch from: https://bugs.gentoo.org/attachment.cgi?id=245736
-In reference to: https://bugs.gentoo.org/show_bug.cgi?id=331447
-
---- iproute2-2.6.35.old/ip/iproute.c	2010-09-02 16:00:21.805000124 +0200
-+++ iproute2-2.6.35/ip/iproute.c	2010-09-02 16:00:40.782000125 +0200
-@@ -160,7 +160,7 @@
- 	if (r->rtm_family == AF_INET6 && table != RT_TABLE_MAIN)
- 		ip6_multiple_tables = 1;
- 
--	if (filter.cloned == !(r->rtm_flags&RTM_F_CLONED))
-+	if (filter.cloned && !(r->rtm_flags&RTM_F_CLONED))
- 		return 0;
- 
- 	if (r->rtm_family == AF_INET6 && !ip6_multiple_tables) {
diff --git a/pkgs/os-specific/linux/kernel/linux-3.10.nix b/pkgs/os-specific/linux/kernel/linux-3.10.nix
index 0d3bfbefcca..909535c5225 100644
--- a/pkgs/os-specific/linux/kernel/linux-3.10.nix
+++ b/pkgs/os-specific/linux/kernel/linux-3.10.nix
@@ -1,12 +1,12 @@
 { stdenv, fetchurl, ... } @ args:
 
 import ./generic.nix (args // rec {
-  version = "3.10.85";
+  version = "3.10.86";
   extraMeta.branch = "3.10";
 
   src = fetchurl {
     url = "mirror://kernel/linux/kernel/v3.x/linux-${version}.tar.xz";
-    sha256 = "1zn8113m6y1wqmnr6gjzrr7ly2l8860fp2kr4q9di3c2vmnmd9v9";
+    sha256 = "1kax24y6xa49n4wc74qg503pbg0rd2imx5npyfp1wcnc6p68w0mr";
   };
 
   features.iwlwifi = true;
diff --git a/pkgs/os-specific/linux/kernel/linux-3.12.nix b/pkgs/os-specific/linux/kernel/linux-3.12.nix
index e6e04b7db53..904aebd75be 100644
--- a/pkgs/os-specific/linux/kernel/linux-3.12.nix
+++ b/pkgs/os-specific/linux/kernel/linux-3.12.nix
@@ -1,12 +1,12 @@
 { stdenv, fetchurl, ... } @ args:
 
 import ./generic.nix (args // rec {
-  version = "3.12.45";
+  version = "3.12.46";
   extraMeta.branch = "3.12";
 
   src = fetchurl {
     url = "mirror://kernel/linux/kernel/v3.x/linux-${version}.tar.xz";
-    sha256 = "01p3zbhngqnkmzw38xmxd0lf97kf2h7ihgss6bgdnkpqrbzb1pqf";
+    sha256 = "01w0b1sifzivbagm724bz0mlfrm7hpbj5a3lx1yrv8xg64gni3m1";
   };
 
   features.iwlwifi = true;
diff --git a/pkgs/os-specific/linux/kernel/linux-3.14.nix b/pkgs/os-specific/linux/kernel/linux-3.14.nix
index c4171948436..569c05fa283 100644
--- a/pkgs/os-specific/linux/kernel/linux-3.14.nix
+++ b/pkgs/os-specific/linux/kernel/linux-3.14.nix
@@ -1,13 +1,13 @@
 { stdenv, fetchurl, ... } @ args:
 
 import ./generic.nix (args // rec {
-  version = "3.14.49";
+  version = "3.14.50";
   # Remember to update grsecurity!
   extraMeta.branch = "3.14";
 
   src = fetchurl {
     url = "mirror://kernel/linux/kernel/v3.x/linux-${version}.tar.xz";
-    sha256 = "1x9p6z195c0nv7hsjcwzmr89yag35v3pyrs0081k2d8dykbl70zs";
+    sha256 = "1bc0g8a707sfqhi9yifaijxzmfrqgry7l1j9473376q0f8pkwjvy";
   };
 
   features.iwlwifi = true;
diff --git a/pkgs/os-specific/linux/kernel/linux-3.18.nix b/pkgs/os-specific/linux/kernel/linux-3.18.nix
index 527ded2db94..05c4b989f39 100644
--- a/pkgs/os-specific/linux/kernel/linux-3.18.nix
+++ b/pkgs/os-specific/linux/kernel/linux-3.18.nix
@@ -1,12 +1,12 @@
 { stdenv, fetchurl, ... } @ args:
 
 import ./generic.nix (args // rec {
-  version = "3.18.19";
+  version = "3.18.20";
   extraMeta.branch = "3.18";
 
   src = fetchurl {
     url = "mirror://kernel/linux/kernel/v3.x/linux-${version}.tar.xz";
-    sha256 = "1jdp4mixggzjy1v806v5q7qqimkm6pbjav3gwbcl2cccv6wd701x";
+    sha256 = "1mwm9xgilsqnj95v3jn94dz9a108ggfm4ifb3kxsfsx5rcl5yy8d";
   };
 
   features.iwlwifi = true;
diff --git a/pkgs/os-specific/linux/kernel/linux-3.19.nix b/pkgs/os-specific/linux/kernel/linux-3.19.nix
deleted file mode 100644
index 90c5f9e31d3..00000000000
--- a/pkgs/os-specific/linux/kernel/linux-3.19.nix
+++ /dev/null
@@ -1,17 +0,0 @@
-{ stdenv, fetchurl, ... } @ args:
-
-import ./generic.nix (args // rec {
-  version = "3.19.8";
-  extraMeta.branch = "3.19";
-
-  src = fetchurl {
-    url = "mirror://kernel/linux/kernel/v3.x/linux-${version}.tar.xz";
-    sha256 = "0yg2mlq0h9my6k1bg3b255w4qnyx609ngh1nhssx3gbzslwf0jyg";
-  };
-
-  features.iwlwifi = true;
-  features.efiBootStub = true;
-  features.needsCifsUtils = true;
-  features.canDisableNetfilterConntrackHelpers = true;
-  features.netfilterRPFilter = true;
-} // (args.argsOverride or {}))
diff --git a/pkgs/os-specific/linux/kernel/linux-4.1.nix b/pkgs/os-specific/linux/kernel/linux-4.1.nix
index e8534656349..6c0ba082e36 100644
--- a/pkgs/os-specific/linux/kernel/linux-4.1.nix
+++ b/pkgs/os-specific/linux/kernel/linux-4.1.nix
@@ -1,13 +1,13 @@
 { stdenv, fetchurl, ... } @ args:
 
 import ./generic.nix (args // rec {
-  version = "4.1.4";
+  version = "4.1.5";
   # Remember to update grsecurity!
   extraMeta.branch = "4.1";
 
   src = fetchurl {
     url = "mirror://kernel/linux/kernel/v4.x/linux-${version}.tar.xz";
-    sha256 = "17whsim5l9i486y5kchfpm9jhbr9lak4a1gdqygp5kwfrfyz5qiy";
+    sha256 = "0v40vhcs3hkjw7gl71jq03ziz93cfh3vlpn686kc9y1nnbcxks5j";
   };
 
   features.iwlwifi = true;
diff --git a/pkgs/os-specific/linux/kernel/patches.nix b/pkgs/os-specific/linux/kernel/patches.nix
index f3e33047e8b..79d58a539f0 100644
--- a/pkgs/os-specific/linux/kernel/patches.nix
+++ b/pkgs/os-specific/linux/kernel/patches.nix
@@ -58,6 +58,16 @@ rec {
       patch = ./mips-ext3-n32.patch;
     };
 
+  ubuntu_fan =
+    { name = "ubuntu-fan";
+      patch = ./ubuntu-fan-3.patch;
+    };
+
+  ubuntu_fan_4 =
+    { name = "ubuntu-fan";
+      patch = ./ubuntu-fan-4.patch;
+    };
+
   tuxonice_3_10 = makeTuxonicePatch {
     version = "2013-11-07";
     kernelVersion = "3.10.18";
@@ -65,17 +75,17 @@ rec {
   };
 
   grsecurity_stable = grsecPatch
-    { kversion  = "3.14.49";
-      revision  = "201508032312";
+    { kversion  = "3.14.50";
+      revision  = "201508102128";
       branch    = "stable";
-      sha256    = "09x0rb4pgmghcp6sdz57lwhawlb3bzrc3rg372xknhv6993ainjc";
+      sha256    = "0inp0ab8pcjfj1wnrkyiwb6cxjp2ymqcjv7lq30a4ij6qcvmfb5s";
     };
 
   grsecurity_unstable = grsecPatch
-    { kversion  = "4.1.4";
-      revision  = "201508032312";
+    { kversion  = "4.1.5";
+      revision  = "201508102129";
       branch    = "test";
-      sha256    = "16p1wq98qgwksav0ry6b5jyyi26s404v1k0cwpj7l7n86hxig67i";
+      sha256    = "1pc40xd7k0fzzd99lshy58gnapv701hjvc4bm0slfzagh241545a";
     };
 
   grsec_fix_path =
diff --git a/pkgs/os-specific/linux/kernel/ubuntu-fan-3.patch b/pkgs/os-specific/linux/kernel/ubuntu-fan-3.patch
new file mode 100644
index 00000000000..c80950d0614
--- /dev/null
+++ b/pkgs/os-specific/linux/kernel/ubuntu-fan-3.patch
@@ -0,0 +1,616 @@
+From f3c956096902669c3529cb01d40deb0c759ed94f Mon Sep 17 00:00:00 2001
+From: Jay Vosburgh <jay.vosburgh@canonical.com>
+Date: Wed, 1 Apr 2015 16:11:09 -0700
+Subject: [PATCH] UBUNTU: SAUCE: fan: Proof of concept implementation (v2)
+
+Modification to ipip tunnel driver to accept a new netlink option,
+IFLA_IPTUN_FAN_UNDERLAY, which provides a /16 network prefix and enables
+TX side destination address remapping for traffic entering the tunnel
+(to be encapsulated).
+
+For an overlay (inner) address Y.A.B.C, the transformation is F.G.A.B,
+where "F" and "G" are the first two octets of the underlay network (the
+network portion of a /16), "A" and "B" are the low order two octets of the
+underlay network host (the host portion of a /16), and "Y" is a configured
+first octet of the overlay network.
+
+E.g., underlay host 10.88.3.4 with an overlay of 99 would host overlay
+subnet 99.3.4.0/24.  An overlay network datagram from 99.3.4.5 to 99.6.7.8
+would be directed to underlay host 10.88.6.7, which hosts overlay network
+99.6.7.0/24.
+
+Includes net.fan.version sysctl as a sentinel for availability of the
+fan functionality.
+
+NOTE: this requires an updated iproute2 to facilitate configuration of
+the fan.
+
+BugLink: http://bugs.launchpad.net/bugs/1439706
+Signed-off-by: Jay Vosburgh <jay.vosburgh@canonical.com>
+[apw@canonical.com: move IFLA_IPTUN_FAN_UNDERLAY up to avoid clashing
+ with future feature additions.]
+Signed-off-by: Andy Whitcroft <apw@canonical.com>
+---
+ include/net/ip_tunnels.h       |   6 +++
+ include/uapi/linux/if_tunnel.h |   4 ++
+ net/ipv4/ipip.c                | 112 +++++++++++++++++++++++++++++++++++++++--
+ 3 files changed, 117 insertions(+), 5 deletions(-)
+
+diff --git a/include/net/ip_tunnels.h b/include/net/ip_tunnels.h
+index 25a59eb..d7eada2 100644
+--- a/include/net/ip_tunnels.h
++++ b/include/net/ip_tunnels.h
+@@ -51,6 +51,11 @@ struct ip_tunnel_dst {
+ 	__be32				 saddr;
+ };
+ 
++/* Underlay address prefix for ipip fan mode */
++struct ip_tunnel_fan {
++	u32			underlay;
++};
++
+ struct ip_tunnel {
+ 	struct ip_tunnel __rcu	*next;
+ 	struct hlist_node hash_node;
+@@ -82,6 +87,7 @@ struct ip_tunnel {
+ #endif
+ 	struct ip_tunnel_prl_entry __rcu *prl;	/* potential router list */
+ 	unsigned int		prl_count;	/* # of entries in PRL */
++	struct ip_tunnel_fan	fan;
+ 	int			ip_tnl_net_id;
+ 	struct gro_cells	gro_cells;
+ };
+diff --git a/include/uapi/linux/if_tunnel.h b/include/uapi/linux/if_tunnel.h
+index bd3cc11..8f7d269 100644
+--- a/include/uapi/linux/if_tunnel.h
++++ b/include/uapi/linux/if_tunnel.h
+@@ -57,6 +57,10 @@ enum {
+ 	IFLA_IPTUN_ENCAP_FLAGS,
+ 	IFLA_IPTUN_ENCAP_SPORT,
+ 	IFLA_IPTUN_ENCAP_DPORT,
++
++	__IFLA_IPTUN_VENDOR_BREAK,		/* Ensure new entries do not hit the below. */
++	IFLA_IPTUN_FAN_UNDERLAY=32,
++
+ 	__IFLA_IPTUN_MAX,
+ };
+ #define IFLA_IPTUN_MAX	(__IFLA_IPTUN_MAX - 1)
+diff --git a/net/ipv4/ipip.c b/net/ipv4/ipip.c
+index 40403114..e3c27cd 100644
+--- a/net/ipv4/ipip.c
++++ b/net/ipv4/ipip.c
+@@ -209,13 +209,38 @@ drop:
+ }
+ 
+ /*
++ * Determine fan tunnel endpoint to send packet to, based on the inner IP
++ * address.  For an overlay (inner) address Y.A.B.C, the transformation is
++ * F.G.A.B, where "F" and "G" are the first two octets of the underlay
++ * network (the network portion of a /16), "A" and "B" are the low order
++ * two octets of the underlay network host (the host portion of a /16),
++ * and "Y" is a configured first octet of the overlay network.
++ *
++ * E.g., underlay host 10.88.3.4 with an overlay of 99 would host overlay
++ * subnet 99.3.4.0/24.  An overlay network datagram from 99.3.4.5 to
++ * 99.6.7.8, would be directed to underlay host 10.88.6.7, which hosts
++ * overlay network 99.6.7.0/24.
++ */
++static void ipip_build_fan_iphdr(struct ip_tunnel *tunnel, struct sk_buff *skb, struct iphdr *iph)
++{
++	u32 daddr;
++
++	*iph = tunnel->parms.iph;
++
++	daddr = ntohl(ip_hdr(skb)->daddr);
++	iph->daddr = htonl((tunnel->fan.underlay & 0xffff0000) |
++			   ((daddr >> 8) & 0x0000ffff));
++}
++
++/*
+  *	This function assumes it is being called from dev_queue_xmit()
+  *	and that skb is filled properly by that function.
+  */
+ static netdev_tx_t ipip_tunnel_xmit(struct sk_buff *skb, struct net_device *dev)
+ {
+ 	struct ip_tunnel *tunnel = netdev_priv(dev);
+-	const struct iphdr  *tiph = &tunnel->parms.iph;
++	const struct iphdr *tiph;
++	struct iphdr fiph;
+ 
+ 	if (unlikely(skb->protocol != htons(ETH_P_IP)))
+ 		goto tx_error;
+@@ -224,6 +249,13 @@ static netdev_tx_t ipip_tunnel_xmit(struct sk_buff *skb, struct net_device *dev)
+ 	if (IS_ERR(skb))
+ 		goto out;
+ 
++	if (tunnel->fan.underlay) {
++		ipip_build_fan_iphdr(tunnel, skb, &fiph);
++		tiph = &fiph;
++	} else {
++		tiph = &tunnel->parms.iph;
++	}
++
+ 	skb_set_inner_ipproto(skb, IPPROTO_IPIP);
+ 
+ 	ip_tunnel_xmit(skb, dev, tiph, tiph->protocol);
+@@ -377,21 +409,44 @@ static bool ipip_netlink_encap_parms(struct nlattr *data[],
+ 	return ret;
+ }
+ 
++static int ipip_netlink_fan(struct nlattr *data[], struct ip_tunnel *t,
++			    struct ip_tunnel_parm *parms)
++{
++	u32 net = t->fan.underlay;
++
++	if (!data[IFLA_IPTUN_FAN_UNDERLAY])
++		goto err_check;
++
++	net = ntohl(nla_get_be32(data[IFLA_IPTUN_FAN_UNDERLAY])) & 0xffff0000;
++
++err_check:
++	if (parms->iph.daddr && net)
++		return -EINVAL;
++
++	t->fan.underlay = net;
++
++	return 0;
++}
++
+ static int ipip_newlink(struct net *src_net, struct net_device *dev,
+ 			struct nlattr *tb[], struct nlattr *data[])
+ {
+ 	struct ip_tunnel_parm p;
+ 	struct ip_tunnel_encap ipencap;
++	struct ip_tunnel *t = netdev_priv(dev);
++	int err;
+ 
+ 	if (ipip_netlink_encap_parms(data, &ipencap)) {
+-		struct ip_tunnel *t = netdev_priv(dev);
+-		int err = ip_tunnel_encap_setup(t, &ipencap);
++		err = ip_tunnel_encap_setup(t, &ipencap);
+ 
+ 		if (err < 0)
+ 			return err;
+ 	}
+ 
+ 	ipip_netlink_parms(data, &p);
++	err = ipip_netlink_fan(data, t, &p);
++	if (err < 0)
++		return err;
+ 	return ip_tunnel_newlink(dev, tb, &p);
+ }
+ 
+@@ -400,16 +455,20 @@ static int ipip_changelink(struct net_device *dev, struct nlattr *tb[],
+ {
+ 	struct ip_tunnel_parm p;
+ 	struct ip_tunnel_encap ipencap;
++	struct ip_tunnel *t = netdev_priv(dev);
++	int err;
+ 
+ 	if (ipip_netlink_encap_parms(data, &ipencap)) {
+-		struct ip_tunnel *t = netdev_priv(dev);
+-		int err = ip_tunnel_encap_setup(t, &ipencap);
++		err = ip_tunnel_encap_setup(t, &ipencap);
+ 
+ 		if (err < 0)
+ 			return err;
+ 	}
+ 
+ 	ipip_netlink_parms(data, &p);
++	err = ipip_netlink_fan(data, t, &p);
++	if (err < 0)
++		return err;
+ 
+ 	if (((dev->flags & IFF_POINTOPOINT) && !p.iph.daddr) ||
+ 	    (!(dev->flags & IFF_POINTOPOINT) && p.iph.daddr))
+@@ -441,6 +500,8 @@ static size_t ipip_get_size(const struct net_device *dev)
+ 		nla_total_size(2) +
+ 		/* IFLA_IPTUN_ENCAP_DPORT */
+ 		nla_total_size(2) +
++		/* IFLA_IPTUN_FAN_UNDERLAY */
++		nla_total_size(4) +
+ 		0;
+ }
+ 
+@@ -468,6 +529,11 @@ static int ipip_fill_info(struct sk_buff *skb, const struct net_device *dev)
+ 			tunnel->encap.flags))
+ 		goto nla_put_failure;
+ 
++	if (tunnel->fan.underlay)
++		if (nla_put_be32(skb, IFLA_IPTUN_FAN_UNDERLAY,
++				 htonl(tunnel->fan.underlay)))
++			goto nla_put_failure;
++
+ 	return 0;
+ 
+ nla_put_failure:
+@@ -485,6 +551,9 @@ static const struct nla_policy ipip_policy[IFLA_IPTUN_MAX + 1] = {
+ 	[IFLA_IPTUN_ENCAP_FLAGS]	= { .type = NLA_U16 },
+ 	[IFLA_IPTUN_ENCAP_SPORT]	= { .type = NLA_U16 },
+ 	[IFLA_IPTUN_ENCAP_DPORT]	= { .type = NLA_U16 },
++
++	[__IFLA_IPTUN_VENDOR_BREAK ... IFLA_IPTUN_MAX]	= { .type = NLA_BINARY },
++	[IFLA_IPTUN_FAN_UNDERLAY]	= { .type = NLA_U32 },
+ };
+ 
+ static struct rtnl_link_ops ipip_link_ops __read_mostly = {
+@@ -524,6 +593,23 @@ static struct pernet_operations ipip_net_ops = {
+ 	.size = sizeof(struct ip_tunnel_net),
+ };
+ 
++#ifdef CONFIG_SYSCTL
++static struct ctl_table_header *ipip_fan_header;
++static unsigned int ipip_fan_version = 1;
++
++static struct ctl_table ipip_fan_sysctls[] = {
++	{
++		.procname	= "version",
++		.data		= &ipip_fan_version,
++		.maxlen		= sizeof(ipip_fan_version),
++		.mode		= 0444,
++		.proc_handler	= proc_dointvec,
++	},
++	{},
++};
++
++#endif /* CONFIG_SYSCTL */
++
+ static int __init ipip_init(void)
+ {
+ 	int err;
+@@ -542,9 +628,22 @@ static int __init ipip_init(void)
+ 	if (err < 0)
+ 		goto rtnl_link_failed;
+ 
++#ifdef CONFIG_SYSCTL
++	ipip_fan_header = register_net_sysctl(&init_net, "net/fan",
++					      ipip_fan_sysctls);
++	if (!ipip_fan_header) {
++		err = -ENOMEM;
++		goto sysctl_failed;
++	}
++#endif /* CONFIG_SYSCTL */
++
+ out:
+ 	return err;
+ 
++#ifdef CONFIG_SYSCTL
++sysctl_failed:
++	rtnl_link_unregister(&ipip_link_ops);
++#endif /* CONFIG_SYSCTL */
+ rtnl_link_failed:
+ 	xfrm4_tunnel_deregister(&ipip_handler, AF_INET);
+ xfrm_tunnel_failed:
+@@ -554,6 +653,9 @@ xfrm_tunnel_failed:
+ 
+ static void __exit ipip_fini(void)
+ {
++#ifdef CONFIG_SYSCTL
++	unregister_net_sysctl_table(ipip_fan_header);
++#endif /* CONFIG_SYSCTL */
+ 	rtnl_link_unregister(&ipip_link_ops);
+ 	if (xfrm4_tunnel_deregister(&ipip_handler, AF_INET))
+ 		pr_info("%s: can't deregister tunnel\n", __func__);
+-- 
+2.4.1
+
+From 4ea8011656dfdd76e7a2391bdad47c06f85a9d02 Mon Sep 17 00:00:00 2001
+From: Andy Whitcroft <apw@canonical.com>
+Date: Tue, 21 Jul 2015 16:52:10 +0100
+Subject: [PATCH] UBUNTU: SAUCE: fan: tunnel multiple mapping mode (v3)
+
+Switch to a single tunnel for all mappings, this removes the limitations
+on how many mappings each tunnel can handle, and therefore how many Fan
+slices each local address may hold.
+
+NOTE: This introduces a new kernel netlink interface which needs updated
+iproute2 support.
+
+BugLink: http://bugs.launchpad.net/bugs/1470091
+Signed-off-by: Jay Vosburgh <jay.vosburgh@canonical.com>
+Signed-off-by: Andy Whitcroft <apw@canonical.com>
+Acked-by: Tim Gardner <tim.gardner@canonical.com>
+Acked-by: Brad Figg <brad.figg@canonical.com>
+Signed-off-by: Brad Figg <brad.figg@canonical.com>
+---
+ include/net/ip_tunnels.h       |  14 ++++-
+ include/uapi/linux/if_tunnel.h |  20 ++++++-
+ net/ipv4/ip_tunnel.c           |   7 ++-
+ net/ipv4/ipip.c                | 120 +++++++++++++++++++++++++++++++++--------
+ 4 files changed, 133 insertions(+), 28 deletions(-)
+
+diff --git a/include/net/ip_tunnels.h b/include/net/ip_tunnels.h
+index d7eada2..2f7bc8c 100644
+--- a/include/net/ip_tunnels.h
++++ b/include/net/ip_tunnels.h
+@@ -51,9 +51,18 @@ struct ip_tunnel_dst {
+ 	__be32				 saddr;
+ };
+ 
+-/* Underlay address prefix for ipip fan mode */
++/* A fan overlay /8 (250.0.0.0/8, for example) maps to exactly one /16
++ * underlay (10.88.0.0/16, for example).  Multiple local addresses within
++ * the /16 may be used, but a particular overlay may not span
++ * multiple underlay subnets.
++ *
++ * We store one underlay, indexed by the overlay's high order octet.
++ */
++#define FAN_OVERLAY_CNT		256
++
+ struct ip_tunnel_fan {
+-	u32			underlay;
++/*	u32 __rcu	*map;*/
++	u32		map[FAN_OVERLAY_CNT];
+ };
+ 
+ struct ip_tunnel {
+@@ -104,6 +113,7 @@ struct ip_tunnel {
+ #define TUNNEL_OAM		__cpu_to_be16(0x0200)
+ #define TUNNEL_CRIT_OPT		__cpu_to_be16(0x0400)
+ #define TUNNEL_OPTIONS_PRESENT	__cpu_to_be16(0x0800)
++#define TUNNEL_FAN		__cpu_to_be16(0x4000)
+ 
+ struct tnl_ptk_info {
+ 	__be16 flags;
+diff --git a/include/uapi/linux/if_tunnel.h b/include/uapi/linux/if_tunnel.h
+index 8f7d269..9625934 100644
+--- a/include/uapi/linux/if_tunnel.h
++++ b/include/uapi/linux/if_tunnel.h
+@@ -58,8 +58,8 @@ enum {
+ 	IFLA_IPTUN_ENCAP_SPORT,
+ 	IFLA_IPTUN_ENCAP_DPORT,
+ 
+-	__IFLA_IPTUN_VENDOR_BREAK,		/* Ensure new entries do not hit the below. */
+-	IFLA_IPTUN_FAN_UNDERLAY=32,
++	__IFLA_IPTUN_VENDOR_BREAK, /* Ensure new entries do not hit the below. */
++	IFLA_IPTUN_FAN_MAP = 33,
+ 
+ 	__IFLA_IPTUN_MAX,
+ };
+@@ -135,4 +135,20 @@ enum {
+ };
+ 
+ #define IFLA_VTI_MAX	(__IFLA_VTI_MAX - 1)
++
++enum {
++	IFLA_FAN_UNSPEC,
++	IFLA_FAN_MAPPING,
++	__IFLA_FAN_MAX,
++};
++
++#define IFLA_FAN_MAX (__IFLA_FAN_MAX - 1)
++
++struct ip_tunnel_fan_map {
++	__be32		underlay;
++	__be32		overlay;
++	__u16		underlay_prefix;
++	__u16		overlay_prefix;
++};
++
+ #endif /* _UAPI_IF_TUNNEL_H_ */
+diff --git a/net/ipv4/ip_tunnel.c b/net/ipv4/ip_tunnel.c
+index d3e4479..60bd10f 100644
+--- a/net/ipv4/ip_tunnel.c
++++ b/net/ipv4/ip_tunnel.c
+@@ -1078,6 +1078,11 @@ out:
+ }
+ EXPORT_SYMBOL_GPL(ip_tunnel_newlink);
+ 
++static int ip_tunnel_is_fan(struct ip_tunnel *tunnel)
++{
++	return tunnel->parms.i_flags & TUNNEL_FAN;
++}
++
+ int ip_tunnel_changelink(struct net_device *dev, struct nlattr *tb[],
+ 			 struct ip_tunnel_parm *p)
+ {
+@@ -1087,7 +1092,7 @@ int ip_tunnel_changelink(struct net_device *dev, struct nlattr *tb[],
+ 	struct ip_tunnel_net *itn = net_generic(net, tunnel->ip_tnl_net_id);
+ 
+ 	if (dev == itn->fb_tunnel_dev)
+-		return -EINVAL;
++		return ip_tunnel_is_fan(tunnel) ? 0 : -EINVAL;
+ 
+ 	t = ip_tunnel_find(itn, p, dev->type);
+ 
+diff --git a/net/ipv4/ipip.c b/net/ipv4/ipip.c
+index e3c27cd..d6ebc66 100644
+--- a/net/ipv4/ipip.c
++++ b/net/ipv4/ipip.c
+@@ -107,6 +107,7 @@
+ #include <linux/init.h>
+ #include <linux/netfilter_ipv4.h>
+ #include <linux/if_ether.h>
++#include <linux/inetdevice.h>
+ 
+ #include <net/sock.h>
+ #include <net/ip.h>
+@@ -208,6 +209,11 @@ drop:
+ 	return 0;
+ }
+ 
++static int ipip_tunnel_is_fan(struct ip_tunnel *tunnel)
++{
++	return tunnel->parms.i_flags & TUNNEL_FAN;
++}
++
+ /*
+  * Determine fan tunnel endpoint to send packet to, based on the inner IP
+  * address.  For an overlay (inner) address Y.A.B.C, the transformation is
+@@ -221,15 +227,20 @@ drop:
+  * 99.6.7.8, would be directed to underlay host 10.88.6.7, which hosts
+  * overlay network 99.6.7.0/24.
+  */
+-static void ipip_build_fan_iphdr(struct ip_tunnel *tunnel, struct sk_buff *skb, struct iphdr *iph)
++static int ipip_build_fan_iphdr(struct ip_tunnel *tunnel, struct sk_buff *skb, struct iphdr *iph)
+ {
+-	u32 daddr;
+-
+-	*iph = tunnel->parms.iph;
++	unsigned int overlay;
++	u32 daddr, underlay;
+ 
+ 	daddr = ntohl(ip_hdr(skb)->daddr);
+-	iph->daddr = htonl((tunnel->fan.underlay & 0xffff0000) |
+-			   ((daddr >> 8) & 0x0000ffff));
++	overlay = daddr >> 24;
++	underlay = tunnel->fan.map[overlay];
++	if (!underlay)
++		return -EINVAL;
++
++	*iph = tunnel->parms.iph;
++	iph->daddr = htonl(underlay | ((daddr >> 8) & 0x0000ffff));
++	return 0;
+ }
+ 
+ /*
+@@ -249,8 +260,9 @@ static netdev_tx_t ipip_tunnel_xmit(struct sk_buff *skb, struct net_device *dev)
+ 	if (IS_ERR(skb))
+ 		goto out;
+ 
+-	if (tunnel->fan.underlay) {
+-		ipip_build_fan_iphdr(tunnel, skb, &fiph);
++	if (ipip_tunnel_is_fan(tunnel)) {
++		if (ipip_build_fan_iphdr(tunnel, skb, &fiph))
++			goto tx_error;
+ 		tiph = &fiph;
+ 	} else {
+ 		tiph = &tunnel->parms.iph;
+@@ -409,21 +421,65 @@ static bool ipip_netlink_encap_parms(struct nlattr *data[],
+ 	return ret;
+ }
+ 
++static void ipip_fan_free_map(struct ip_tunnel *t)
++{
++	memset(&t->fan.map, 0, sizeof(t->fan.map));
++}
++
++static int ipip_fan_set_map(struct ip_tunnel *t, struct ip_tunnel_fan_map *map)
++{
++	u32 overlay, overlay_mask, underlay, underlay_mask;
++
++	if ((map->underlay_prefix && map->underlay_prefix != 16) ||
++	    (map->overlay_prefix && map->overlay_prefix != 8))
++		return -EINVAL;
++
++	overlay = ntohl(map->overlay);
++	overlay_mask = ntohl(inet_make_mask(map->overlay_prefix));
++
++	underlay = ntohl(map->underlay);
++	underlay_mask = ntohl(inet_make_mask(map->underlay_prefix));
++
++	if ((overlay & ~overlay_mask) || (underlay & ~underlay_mask))
++		return -EINVAL;
++
++	if (!(overlay & overlay_mask) && (underlay & underlay_mask))
++		return -EINVAL;
++
++	t->parms.i_flags |= TUNNEL_FAN;
++
++	/* Special case: overlay 0 and underlay 0 clears all mappings */
++	if (!overlay && !underlay) {
++		ipip_fan_free_map(t);
++		return 0;
++	}
++
++	overlay >>= (32 - map->overlay_prefix);
++	t->fan.map[overlay] = underlay;
++
++	return 0;
++}
++	
++
+ static int ipip_netlink_fan(struct nlattr *data[], struct ip_tunnel *t,
+ 			    struct ip_tunnel_parm *parms)
+ {
+-	u32 net = t->fan.underlay;
+-
+-	if (!data[IFLA_IPTUN_FAN_UNDERLAY])
+-		goto err_check;
++	struct ip_tunnel_fan_map *map;
++	struct nlattr *attr;
++	int rem, rv;
+ 
+-	net = ntohl(nla_get_be32(data[IFLA_IPTUN_FAN_UNDERLAY])) & 0xffff0000;
++	if (!data[IFLA_IPTUN_FAN_MAP])
++		return 0;
+ 
+-err_check:
+-	if (parms->iph.daddr && net)
++	if (parms->iph.daddr)
+ 		return -EINVAL;
+ 
+-	t->fan.underlay = net;
++	nla_for_each_nested(attr, data[IFLA_IPTUN_FAN_MAP], rem) {
++		map = nla_data(attr);
++		rv = ipip_fan_set_map(t, map);
++		if (rv)
++			return rv;
++	}
+ 
+ 	return 0;
+ }
+@@ -500,8 +556,8 @@ static size_t ipip_get_size(const struct net_device *dev)
+ 		nla_total_size(2) +
+ 		/* IFLA_IPTUN_ENCAP_DPORT */
+ 		nla_total_size(2) +
+-		/* IFLA_IPTUN_FAN_UNDERLAY */
+-		nla_total_size(4) +
++		/* IFLA_IPTUN_FAN_MAP */
++		nla_total_size(sizeof(struct ip_tunnel_fan_map)) * 256 +
+ 		0;
+ }
+ 
+@@ -529,10 +585,28 @@ static int ipip_fill_info(struct sk_buff *skb, const struct net_device *dev)
+ 			tunnel->encap.flags))
+ 		goto nla_put_failure;
+ 
+-	if (tunnel->fan.underlay)
+-		if (nla_put_be32(skb, IFLA_IPTUN_FAN_UNDERLAY,
+-				 htonl(tunnel->fan.underlay)))
++	if (tunnel->parms.i_flags & TUNNEL_FAN) {
++		struct nlattr *fan_nest;
++		int i;
++
++		fan_nest = nla_nest_start(skb, IFLA_IPTUN_FAN_MAP);
++		if (!fan_nest)
+ 			goto nla_put_failure;
++		for (i = 0; i < 256; i++) {
++			if (tunnel->fan.map[i]) {
++				struct ip_tunnel_fan_map map;
++
++				map.underlay = htonl(tunnel->fan.map[i]);
++				map.underlay_prefix = 16;
++				map.overlay = htonl(i << 24);
++				map.overlay_prefix = 8;
++				if (nla_put(skb, IFLA_FAN_MAPPING,
++					    sizeof(map), &map))
++					goto nla_put_failure;
++			}
++		}
++		nla_nest_end(skb, fan_nest);
++	}
+ 
+ 	return 0;
+ 
+@@ -553,7 +627,7 @@ static const struct nla_policy ipip_policy[IFLA_IPTUN_MAX + 1] = {
+ 	[IFLA_IPTUN_ENCAP_DPORT]	= { .type = NLA_U16 },
+ 
+ 	[__IFLA_IPTUN_VENDOR_BREAK ... IFLA_IPTUN_MAX]	= { .type = NLA_BINARY },
+-	[IFLA_IPTUN_FAN_UNDERLAY]	= { .type = NLA_U32 },
++	[IFLA_IPTUN_FAN_MAP]		= { .type = NLA_NESTED },
+ };
+ 
+ static struct rtnl_link_ops ipip_link_ops __read_mostly = {
+@@ -595,7 +669,7 @@ static struct pernet_operations ipip_net_ops = {
+ 
+ #ifdef CONFIG_SYSCTL
+ static struct ctl_table_header *ipip_fan_header;
+-static unsigned int ipip_fan_version = 1;
++static unsigned int ipip_fan_version = 3;
+ 
+ static struct ctl_table ipip_fan_sysctls[] = {
+ 	{
+-- 
+2.4.1
+
diff --git a/pkgs/os-specific/linux/kernel/ubuntu-fan-4.patch b/pkgs/os-specific/linux/kernel/ubuntu-fan-4.patch
new file mode 100644
index 00000000000..0050af6c252
--- /dev/null
+++ b/pkgs/os-specific/linux/kernel/ubuntu-fan-4.patch
@@ -0,0 +1,616 @@
+From f3c956096902669c3529cb01d40deb0c759ed94f Mon Sep 17 00:00:00 2001
+From: Jay Vosburgh <jay.vosburgh@canonical.com>
+Date: Wed, 1 Apr 2015 16:11:09 -0700
+Subject: [PATCH] UBUNTU: SAUCE: fan: Proof of concept implementation (v2)
+
+Modification to ipip tunnel driver to accept a new netlink option,
+IFLA_IPTUN_FAN_UNDERLAY, which provides a /16 network prefix and enables
+TX side destination address remapping for traffic entering the tunnel
+(to be encapsulated).
+
+For an overlay (inner) address Y.A.B.C, the transformation is F.G.A.B,
+where "F" and "G" are the first two octets of the underlay network (the
+network portion of a /16), "A" and "B" are the low order two octets of the
+underlay network host (the host portion of a /16), and "Y" is a configured
+first octet of the overlay network.
+
+E.g., underlay host 10.88.3.4 with an overlay of 99 would host overlay
+subnet 99.3.4.0/24.  An overlay network datagram from 99.3.4.5 to 99.6.7.8
+would be directed to underlay host 10.88.6.7, which hosts overlay network
+99.6.7.0/24.
+
+Includes net.fan.version sysctl as a sentinel for availability of the
+fan functionality.
+
+NOTE: this requires an updated iproute2 to facilitate configuration of
+the fan.
+
+BugLink: http://bugs.launchpad.net/bugs/1439706
+Signed-off-by: Jay Vosburgh <jay.vosburgh@canonical.com>
+[apw@canonical.com: move IFLA_IPTUN_FAN_UNDERLAY up to avoid clashing
+ with future feature additions.]
+Signed-off-by: Andy Whitcroft <apw@canonical.com>
+---
+ include/net/ip_tunnels.h       |   6 +++
+ include/uapi/linux/if_tunnel.h |   4 ++
+ net/ipv4/ipip.c                | 112 +++++++++++++++++++++++++++++++++++++++--
+ 3 files changed, 117 insertions(+), 5 deletions(-)
+
+diff --git a/include/net/ip_tunnels.h b/include/net/ip_tunnels.h
+index 25a59eb..d7eada2 100644
+--- a/include/net/ip_tunnels.h
++++ b/include/net/ip_tunnels.h
+@@ -51,6 +51,11 @@ struct ip_tunnel_dst {
+ 	__be32				 saddr;
+ };
+ 
++/* Underlay address prefix for ipip fan mode */
++struct ip_tunnel_fan {
++	u32			underlay;
++};
++
+ struct ip_tunnel {
+ 	struct ip_tunnel __rcu	*next;
+ 	struct hlist_node hash_node;
+@@ -82,6 +87,7 @@ struct ip_tunnel {
+ #endif
+ 	struct ip_tunnel_prl_entry __rcu *prl;	/* potential router list */
+ 	unsigned int		prl_count;	/* # of entries in PRL */
++	struct ip_tunnel_fan	fan;
+ 	int			ip_tnl_net_id;
+ 	struct gro_cells	gro_cells;
+ };
+diff --git a/include/uapi/linux/if_tunnel.h b/include/uapi/linux/if_tunnel.h
+index bd3cc11..8f7d269 100644
+--- a/include/uapi/linux/if_tunnel.h
++++ b/include/uapi/linux/if_tunnel.h
+@@ -57,6 +57,10 @@ enum {
+ 	IFLA_IPTUN_ENCAP_FLAGS,
+ 	IFLA_IPTUN_ENCAP_SPORT,
+ 	IFLA_IPTUN_ENCAP_DPORT,
++
++	__IFLA_IPTUN_VENDOR_BREAK,		/* Ensure new entries do not hit the below. */
++	IFLA_IPTUN_FAN_UNDERLAY=32,
++
+ 	__IFLA_IPTUN_MAX,
+ };
+ #define IFLA_IPTUN_MAX	(__IFLA_IPTUN_MAX - 1)
+diff --git a/net/ipv4/ipip.c b/net/ipv4/ipip.c
+index 40403114..e3c27cd 100644
+--- a/net/ipv4/ipip.c
++++ b/net/ipv4/ipip.c
+@@ -209,13 +209,38 @@ drop:
+ }
+ 
+ /*
++ * Determine fan tunnel endpoint to send packet to, based on the inner IP
++ * address.  For an overlay (inner) address Y.A.B.C, the transformation is
++ * F.G.A.B, where "F" and "G" are the first two octets of the underlay
++ * network (the network portion of a /16), "A" and "B" are the low order
++ * two octets of the underlay network host (the host portion of a /16),
++ * and "Y" is a configured first octet of the overlay network.
++ *
++ * E.g., underlay host 10.88.3.4 with an overlay of 99 would host overlay
++ * subnet 99.3.4.0/24.  An overlay network datagram from 99.3.4.5 to
++ * 99.6.7.8, would be directed to underlay host 10.88.6.7, which hosts
++ * overlay network 99.6.7.0/24.
++ */
++static void ipip_build_fan_iphdr(struct ip_tunnel *tunnel, struct sk_buff *skb, struct iphdr *iph)
++{
++	u32 daddr;
++
++	*iph = tunnel->parms.iph;
++
++	daddr = ntohl(ip_hdr(skb)->daddr);
++	iph->daddr = htonl((tunnel->fan.underlay & 0xffff0000) |
++			   ((daddr >> 8) & 0x0000ffff));
++}
++
++/*
+  *	This function assumes it is being called from dev_queue_xmit()
+  *	and that skb is filled properly by that function.
+  */
+ static netdev_tx_t ipip_tunnel_xmit(struct sk_buff *skb, struct net_device *dev)
+ {
+ 	struct ip_tunnel *tunnel = netdev_priv(dev);
+-	const struct iphdr  *tiph = &tunnel->parms.iph;
++	const struct iphdr *tiph;
++	struct iphdr fiph;
+ 
+ 	if (unlikely(skb->protocol != htons(ETH_P_IP)))
+ 		goto tx_error;
+@@ -224,6 +249,13 @@ static netdev_tx_t ipip_tunnel_xmit(struct sk_buff *skb, struct net_device *dev)
+ 	if (IS_ERR(skb))
+ 		goto out;
+ 
++	if (tunnel->fan.underlay) {
++		ipip_build_fan_iphdr(tunnel, skb, &fiph);
++		tiph = &fiph;
++	} else {
++		tiph = &tunnel->parms.iph;
++	}
++
+ 	skb_set_inner_ipproto(skb, IPPROTO_IPIP);
+ 
+ 	ip_tunnel_xmit(skb, dev, tiph, tiph->protocol);
+@@ -377,21 +409,44 @@ static bool ipip_netlink_encap_parms(struct nlattr *data[],
+ 	return ret;
+ }
+ 
++static int ipip_netlink_fan(struct nlattr *data[], struct ip_tunnel *t,
++			    struct ip_tunnel_parm *parms)
++{
++	u32 net = t->fan.underlay;
++
++	if (!data[IFLA_IPTUN_FAN_UNDERLAY])
++		goto err_check;
++
++	net = ntohl(nla_get_be32(data[IFLA_IPTUN_FAN_UNDERLAY])) & 0xffff0000;
++
++err_check:
++	if (parms->iph.daddr && net)
++		return -EINVAL;
++
++	t->fan.underlay = net;
++
++	return 0;
++}
++
+ static int ipip_newlink(struct net *src_net, struct net_device *dev,
+ 			struct nlattr *tb[], struct nlattr *data[])
+ {
+ 	struct ip_tunnel_parm p;
+ 	struct ip_tunnel_encap ipencap;
++	struct ip_tunnel *t = netdev_priv(dev);
++	int err;
+ 
+ 	if (ipip_netlink_encap_parms(data, &ipencap)) {
+-		struct ip_tunnel *t = netdev_priv(dev);
+-		int err = ip_tunnel_encap_setup(t, &ipencap);
++		err = ip_tunnel_encap_setup(t, &ipencap);
+ 
+ 		if (err < 0)
+ 			return err;
+ 	}
+ 
+ 	ipip_netlink_parms(data, &p);
++	err = ipip_netlink_fan(data, t, &p);
++	if (err < 0)
++		return err;
+ 	return ip_tunnel_newlink(dev, tb, &p);
+ }
+ 
+@@ -400,16 +455,20 @@ static int ipip_changelink(struct net_device *dev, struct nlattr *tb[],
+ {
+ 	struct ip_tunnel_parm p;
+ 	struct ip_tunnel_encap ipencap;
++	struct ip_tunnel *t = netdev_priv(dev);
++	int err;
+ 
+ 	if (ipip_netlink_encap_parms(data, &ipencap)) {
+-		struct ip_tunnel *t = netdev_priv(dev);
+-		int err = ip_tunnel_encap_setup(t, &ipencap);
++		err = ip_tunnel_encap_setup(t, &ipencap);
+ 
+ 		if (err < 0)
+ 			return err;
+ 	}
+ 
+ 	ipip_netlink_parms(data, &p);
++	err = ipip_netlink_fan(data, t, &p);
++	if (err < 0)
++		return err;
+ 
+ 	if (((dev->flags & IFF_POINTOPOINT) && !p.iph.daddr) ||
+ 	    (!(dev->flags & IFF_POINTOPOINT) && p.iph.daddr))
+@@ -441,6 +500,8 @@ static size_t ipip_get_size(const struct net_device *dev)
+ 		nla_total_size(2) +
+ 		/* IFLA_IPTUN_ENCAP_DPORT */
+ 		nla_total_size(2) +
++		/* IFLA_IPTUN_FAN_UNDERLAY */
++		nla_total_size(4) +
+ 		0;
+ }
+ 
+@@ -468,6 +529,11 @@ static int ipip_fill_info(struct sk_buff *skb, const struct net_device *dev)
+ 			tunnel->encap.flags))
+ 		goto nla_put_failure;
+ 
++	if (tunnel->fan.underlay)
++		if (nla_put_be32(skb, IFLA_IPTUN_FAN_UNDERLAY,
++				 htonl(tunnel->fan.underlay)))
++			goto nla_put_failure;
++
+ 	return 0;
+ 
+ nla_put_failure:
+@@ -485,6 +551,9 @@ static const struct nla_policy ipip_policy[IFLA_IPTUN_MAX + 1] = {
+ 	[IFLA_IPTUN_ENCAP_FLAGS]	= { .type = NLA_U16 },
+ 	[IFLA_IPTUN_ENCAP_SPORT]	= { .type = NLA_U16 },
+ 	[IFLA_IPTUN_ENCAP_DPORT]	= { .type = NLA_U16 },
++
++	[__IFLA_IPTUN_VENDOR_BREAK ... IFLA_IPTUN_MAX]	= { .type = NLA_BINARY },
++	[IFLA_IPTUN_FAN_UNDERLAY]	= { .type = NLA_U32 },
+ };
+ 
+ static struct rtnl_link_ops ipip_link_ops __read_mostly = {
+@@ -524,6 +593,23 @@ static struct pernet_operations ipip_net_ops = {
+ 	.size = sizeof(struct ip_tunnel_net),
+ };
+ 
++#ifdef CONFIG_SYSCTL
++static struct ctl_table_header *ipip_fan_header;
++static unsigned int ipip_fan_version = 1;
++
++static struct ctl_table ipip_fan_sysctls[] = {
++	{
++		.procname	= "version",
++		.data		= &ipip_fan_version,
++		.maxlen		= sizeof(ipip_fan_version),
++		.mode		= 0444,
++		.proc_handler	= proc_dointvec,
++	},
++	{},
++};
++
++#endif /* CONFIG_SYSCTL */
++
+ static int __init ipip_init(void)
+ {
+ 	int err;
+@@ -542,9 +628,22 @@ static int __init ipip_init(void)
+ 	if (err < 0)
+ 		goto rtnl_link_failed;
+ 
++#ifdef CONFIG_SYSCTL
++	ipip_fan_header = register_net_sysctl(&init_net, "net/fan",
++					      ipip_fan_sysctls);
++	if (!ipip_fan_header) {
++		err = -ENOMEM;
++		goto sysctl_failed;
++	}
++#endif /* CONFIG_SYSCTL */
++
+ out:
+ 	return err;
+ 
++#ifdef CONFIG_SYSCTL
++sysctl_failed:
++	rtnl_link_unregister(&ipip_link_ops);
++#endif /* CONFIG_SYSCTL */
+ rtnl_link_failed:
+ 	xfrm4_tunnel_deregister(&ipip_handler, AF_INET);
+ xfrm_tunnel_failed:
+@@ -554,6 +653,9 @@ xfrm_tunnel_failed:
+ 
+ static void __exit ipip_fini(void)
+ {
++#ifdef CONFIG_SYSCTL
++	unregister_net_sysctl_table(ipip_fan_header);
++#endif /* CONFIG_SYSCTL */
+ 	rtnl_link_unregister(&ipip_link_ops);
+ 	if (xfrm4_tunnel_deregister(&ipip_handler, AF_INET))
+ 		pr_info("%s: can't deregister tunnel\n", __func__);
+-- 
+2.4.1
+
+From 4ea8011656dfdd76e7a2391bdad47c06f85a9d02 Mon Sep 17 00:00:00 2001
+From: Andy Whitcroft <apw@canonical.com>
+Date: Tue, 21 Jul 2015 16:52:10 +0100
+Subject: [PATCH] UBUNTU: SAUCE: fan: tunnel multiple mapping mode (v3)
+
+Switch to a single tunnel for all mappings, this removes the limitations
+on how many mappings each tunnel can handle, and therefore how many Fan
+slices each local address may hold.
+
+NOTE: This introduces a new kernel netlink interface which needs updated
+iproute2 support.
+
+BugLink: http://bugs.launchpad.net/bugs/1470091
+Signed-off-by: Jay Vosburgh <jay.vosburgh@canonical.com>
+Signed-off-by: Andy Whitcroft <apw@canonical.com>
+Acked-by: Tim Gardner <tim.gardner@canonical.com>
+Acked-by: Brad Figg <brad.figg@canonical.com>
+Signed-off-by: Brad Figg <brad.figg@canonical.com>
+---
+ include/net/ip_tunnels.h       |  14 ++++-
+ include/uapi/linux/if_tunnel.h |  20 ++++++-
+ net/ipv4/ip_tunnel.c           |   7 ++-
+ net/ipv4/ipip.c                | 120 +++++++++++++++++++++++++++++++++--------
+ 4 files changed, 133 insertions(+), 28 deletions(-)
+
+diff --git a/include/net/ip_tunnels.h b/include/net/ip_tunnels.h
+index d7eada2..2f7bc8c 100644
+--- a/include/net/ip_tunnels.h
++++ b/include/net/ip_tunnels.h
+@@ -51,9 +51,18 @@ struct ip_tunnel_dst {
+ 	__be32				 saddr;
+ };
+ 
+-/* Underlay address prefix for ipip fan mode */
++/* A fan overlay /8 (250.0.0.0/8, for example) maps to exactly one /16
++ * underlay (10.88.0.0/16, for example).  Multiple local addresses within
++ * the /16 may be used, but a particular overlay may not span
++ * multiple underlay subnets.
++ *
++ * We store one underlay, indexed by the overlay's high order octet.
++ */
++#define FAN_OVERLAY_CNT		256
++
+ struct ip_tunnel_fan {
+-	u32			underlay;
++/*	u32 __rcu	*map;*/
++	u32		map[FAN_OVERLAY_CNT];
+ };
+ 
+ struct ip_tunnel {
+@@ -104,6 +113,7 @@ struct ip_tunnel {
+ #define TUNNEL_OAM		__cpu_to_be16(0x0200)
+ #define TUNNEL_CRIT_OPT		__cpu_to_be16(0x0400)
+ #define TUNNEL_GENEVE_OPT	__cpu_to_be16(0x0800)
+ #define TUNNEL_VXLAN_OPT	__cpu_to_be16(0x1000)
++#define TUNNEL_FAN		__cpu_to_be16(0x4000)
+ 
+ #define TUNNEL_OPTIONS_PRESENT	(TUNNEL_GENEVE_OPT | TUNNEL_VXLAN_OPT)
+diff --git a/include/uapi/linux/if_tunnel.h b/include/uapi/linux/if_tunnel.h
+index 8f7d269..9625934 100644
+--- a/include/uapi/linux/if_tunnel.h
++++ b/include/uapi/linux/if_tunnel.h
+@@ -58,8 +58,8 @@ enum {
+ 	IFLA_IPTUN_ENCAP_SPORT,
+ 	IFLA_IPTUN_ENCAP_DPORT,
+ 
+-	__IFLA_IPTUN_VENDOR_BREAK,		/* Ensure new entries do not hit the below. */
+-	IFLA_IPTUN_FAN_UNDERLAY=32,
++	__IFLA_IPTUN_VENDOR_BREAK, /* Ensure new entries do not hit the below. */
++	IFLA_IPTUN_FAN_MAP = 33,
+ 
+ 	__IFLA_IPTUN_MAX,
+ };
+@@ -135,4 +135,20 @@ enum {
+ };
+ 
+ #define IFLA_VTI_MAX	(__IFLA_VTI_MAX - 1)
++
++enum {
++	IFLA_FAN_UNSPEC,
++	IFLA_FAN_MAPPING,
++	__IFLA_FAN_MAX,
++};
++
++#define IFLA_FAN_MAX (__IFLA_FAN_MAX - 1)
++
++struct ip_tunnel_fan_map {
++	__be32		underlay;
++	__be32		overlay;
++	__u16		underlay_prefix;
++	__u16		overlay_prefix;
++};
++
+ #endif /* _UAPI_IF_TUNNEL_H_ */
+diff --git a/net/ipv4/ip_tunnel.c b/net/ipv4/ip_tunnel.c
+index d3e4479..60bd10f 100644
+--- a/net/ipv4/ip_tunnel.c
++++ b/net/ipv4/ip_tunnel.c
+@@ -1078,6 +1078,11 @@ out:
+ }
+ EXPORT_SYMBOL_GPL(ip_tunnel_newlink);
+ 
++static int ip_tunnel_is_fan(struct ip_tunnel *tunnel)
++{
++	return tunnel->parms.i_flags & TUNNEL_FAN;
++}
++
+ int ip_tunnel_changelink(struct net_device *dev, struct nlattr *tb[],
+ 			 struct ip_tunnel_parm *p)
+ {
+@@ -1087,7 +1092,7 @@ int ip_tunnel_changelink(struct net_device *dev, struct nlattr *tb[],
+ 	struct ip_tunnel_net *itn = net_generic(net, tunnel->ip_tnl_net_id);
+ 
+ 	if (dev == itn->fb_tunnel_dev)
+-		return -EINVAL;
++		return ip_tunnel_is_fan(tunnel) ? 0 : -EINVAL;
+ 
+ 	t = ip_tunnel_find(itn, p, dev->type);
+ 
+diff --git a/net/ipv4/ipip.c b/net/ipv4/ipip.c
+index e3c27cd..d6ebc66 100644
+--- a/net/ipv4/ipip.c
++++ b/net/ipv4/ipip.c
+@@ -107,6 +107,7 @@
+ #include <linux/init.h>
+ #include <linux/netfilter_ipv4.h>
+ #include <linux/if_ether.h>
++#include <linux/inetdevice.h>
+ 
+ #include <net/sock.h>
+ #include <net/ip.h>
+@@ -208,6 +209,11 @@ drop:
+ 	return 0;
+ }
+ 
++static int ipip_tunnel_is_fan(struct ip_tunnel *tunnel)
++{
++	return tunnel->parms.i_flags & TUNNEL_FAN;
++}
++
+ /*
+  * Determine fan tunnel endpoint to send packet to, based on the inner IP
+  * address.  For an overlay (inner) address Y.A.B.C, the transformation is
+@@ -221,15 +227,20 @@ drop:
+  * 99.6.7.8, would be directed to underlay host 10.88.6.7, which hosts
+  * overlay network 99.6.7.0/24.
+  */
+-static void ipip_build_fan_iphdr(struct ip_tunnel *tunnel, struct sk_buff *skb, struct iphdr *iph)
++static int ipip_build_fan_iphdr(struct ip_tunnel *tunnel, struct sk_buff *skb, struct iphdr *iph)
+ {
+-	u32 daddr;
+-
+-	*iph = tunnel->parms.iph;
++	unsigned int overlay;
++	u32 daddr, underlay;
+ 
+ 	daddr = ntohl(ip_hdr(skb)->daddr);
+-	iph->daddr = htonl((tunnel->fan.underlay & 0xffff0000) |
+-			   ((daddr >> 8) & 0x0000ffff));
++	overlay = daddr >> 24;
++	underlay = tunnel->fan.map[overlay];
++	if (!underlay)
++		return -EINVAL;
++
++	*iph = tunnel->parms.iph;
++	iph->daddr = htonl(underlay | ((daddr >> 8) & 0x0000ffff));
++	return 0;
+ }
+ 
+ /*
+@@ -249,8 +260,9 @@ static netdev_tx_t ipip_tunnel_xmit(struct sk_buff *skb, struct net_device *dev)
+ 	if (IS_ERR(skb))
+ 		goto out;
+ 
+-	if (tunnel->fan.underlay) {
+-		ipip_build_fan_iphdr(tunnel, skb, &fiph);
++	if (ipip_tunnel_is_fan(tunnel)) {
++		if (ipip_build_fan_iphdr(tunnel, skb, &fiph))
++			goto tx_error;
+ 		tiph = &fiph;
+ 	} else {
+ 		tiph = &tunnel->parms.iph;
+@@ -409,21 +421,65 @@ static bool ipip_netlink_encap_parms(struct nlattr *data[],
+ 	return ret;
+ }
+ 
++static void ipip_fan_free_map(struct ip_tunnel *t)
++{
++	memset(&t->fan.map, 0, sizeof(t->fan.map));
++}
++
++static int ipip_fan_set_map(struct ip_tunnel *t, struct ip_tunnel_fan_map *map)
++{
++	u32 overlay, overlay_mask, underlay, underlay_mask;
++
++	if ((map->underlay_prefix && map->underlay_prefix != 16) ||
++	    (map->overlay_prefix && map->overlay_prefix != 8))
++		return -EINVAL;
++
++	overlay = ntohl(map->overlay);
++	overlay_mask = ntohl(inet_make_mask(map->overlay_prefix));
++
++	underlay = ntohl(map->underlay);
++	underlay_mask = ntohl(inet_make_mask(map->underlay_prefix));
++
++	if ((overlay & ~overlay_mask) || (underlay & ~underlay_mask))
++		return -EINVAL;
++
++	if (!(overlay & overlay_mask) && (underlay & underlay_mask))
++		return -EINVAL;
++
++	t->parms.i_flags |= TUNNEL_FAN;
++
++	/* Special case: overlay 0 and underlay 0 clears all mappings */
++	if (!overlay && !underlay) {
++		ipip_fan_free_map(t);
++		return 0;
++	}
++
++	overlay >>= (32 - map->overlay_prefix);
++	t->fan.map[overlay] = underlay;
++
++	return 0;
++}
++	
++
+ static int ipip_netlink_fan(struct nlattr *data[], struct ip_tunnel *t,
+ 			    struct ip_tunnel_parm *parms)
+ {
+-	u32 net = t->fan.underlay;
+-
+-	if (!data[IFLA_IPTUN_FAN_UNDERLAY])
+-		goto err_check;
++	struct ip_tunnel_fan_map *map;
++	struct nlattr *attr;
++	int rem, rv;
+ 
+-	net = ntohl(nla_get_be32(data[IFLA_IPTUN_FAN_UNDERLAY])) & 0xffff0000;
++	if (!data[IFLA_IPTUN_FAN_MAP])
++		return 0;
+ 
+-err_check:
+-	if (parms->iph.daddr && net)
++	if (parms->iph.daddr)
+ 		return -EINVAL;
+ 
+-	t->fan.underlay = net;
++	nla_for_each_nested(attr, data[IFLA_IPTUN_FAN_MAP], rem) {
++		map = nla_data(attr);
++		rv = ipip_fan_set_map(t, map);
++		if (rv)
++			return rv;
++	}
+ 
+ 	return 0;
+ }
+@@ -500,8 +556,8 @@ static size_t ipip_get_size(const struct net_device *dev)
+ 		nla_total_size(2) +
+ 		/* IFLA_IPTUN_ENCAP_DPORT */
+ 		nla_total_size(2) +
+-		/* IFLA_IPTUN_FAN_UNDERLAY */
+-		nla_total_size(4) +
++		/* IFLA_IPTUN_FAN_MAP */
++		nla_total_size(sizeof(struct ip_tunnel_fan_map)) * 256 +
+ 		0;
+ }
+ 
+@@ -529,10 +585,28 @@ static int ipip_fill_info(struct sk_buff *skb, const struct net_device *dev)
+ 			tunnel->encap.flags))
+ 		goto nla_put_failure;
+ 
+-	if (tunnel->fan.underlay)
+-		if (nla_put_be32(skb, IFLA_IPTUN_FAN_UNDERLAY,
+-				 htonl(tunnel->fan.underlay)))
++	if (tunnel->parms.i_flags & TUNNEL_FAN) {
++		struct nlattr *fan_nest;
++		int i;
++
++		fan_nest = nla_nest_start(skb, IFLA_IPTUN_FAN_MAP);
++		if (!fan_nest)
+ 			goto nla_put_failure;
++		for (i = 0; i < 256; i++) {
++			if (tunnel->fan.map[i]) {
++				struct ip_tunnel_fan_map map;
++
++				map.underlay = htonl(tunnel->fan.map[i]);
++				map.underlay_prefix = 16;
++				map.overlay = htonl(i << 24);
++				map.overlay_prefix = 8;
++				if (nla_put(skb, IFLA_FAN_MAPPING,
++					    sizeof(map), &map))
++					goto nla_put_failure;
++			}
++		}
++		nla_nest_end(skb, fan_nest);
++	}
+ 
+ 	return 0;
+ 
+@@ -553,7 +627,7 @@ static const struct nla_policy ipip_policy[IFLA_IPTUN_MAX + 1] = {
+ 	[IFLA_IPTUN_ENCAP_DPORT]	= { .type = NLA_U16 },
+ 
+ 	[__IFLA_IPTUN_VENDOR_BREAK ... IFLA_IPTUN_MAX]	= { .type = NLA_BINARY },
+-	[IFLA_IPTUN_FAN_UNDERLAY]	= { .type = NLA_U32 },
++	[IFLA_IPTUN_FAN_MAP]		= { .type = NLA_NESTED },
+ };
+ 
+ static struct rtnl_link_ops ipip_link_ops __read_mostly = {
+@@ -595,7 +669,7 @@ static struct pernet_operations ipip_net_ops = {
+ 
+ #ifdef CONFIG_SYSCTL
+ static struct ctl_table_header *ipip_fan_header;
+-static unsigned int ipip_fan_version = 1;
++static unsigned int ipip_fan_version = 3;
+ 
+ static struct ctl_table ipip_fan_sysctls[] = {
+ 	{
+-- 
+2.4.1
+
diff --git a/pkgs/os-specific/linux/nvidia-x11/legacy304.nix b/pkgs/os-specific/linux/nvidia-x11/legacy304.nix
index d5e350a0302..7f13b6795d4 100644
--- a/pkgs/os-specific/linux/nvidia-x11/legacy304.nix
+++ b/pkgs/os-specific/linux/nvidia-x11/legacy304.nix
@@ -15,6 +15,8 @@ stdenv.mkDerivation {
 
   builder = ./builder-legacy304.sh;
 
+  patches = [ ./nvidia-340.76-kernel-4.0.patch ];
+
   src =
     if stdenv.system == "i686-linux" then
       fetchurl {
diff --git a/pkgs/os-specific/linux/nvidia-x11/nvidia-340.76-kernel-4.0.patch b/pkgs/os-specific/linux/nvidia-x11/nvidia-340.76-kernel-4.0.patch
index c959190023b..5fdc1fed727 100644
--- a/pkgs/os-specific/linux/nvidia-x11/nvidia-340.76-kernel-4.0.patch
+++ b/pkgs/os-specific/linux/nvidia-x11/nvidia-340.76-kernel-4.0.patch
@@ -4,7 +4,7 @@
      unsigned long cr0 = read_cr0();
      write_cr0(((cr0 & (0xdfffffff)) | 0x40000000));
      wbinvd();
-+#if LINUX_VERSION_CODE < KERNEL_VERSION(3, 20, 0)
++#if LINUX_VERSION_CODE < KERNEL_VERSION(3, 18, 0)
      *cr4 = read_cr4();
      if (*cr4 & 0x80) write_cr4(*cr4 & ~0x80);
 +#else
@@ -18,7 +18,7 @@
      wbinvd();
      __flush_tlb();
      write_cr0((cr0 & 0x9fffffff));
-+#if LINUX_VERSION_CODE < KERNEL_VERSION(3, 20, 0)
++#if LINUX_VERSION_CODE < KERNEL_VERSION(3, 18, 0)
      if (cr4 & 0x80) write_cr4(cr4);
 +#else
 +    if (cr4 & 0x80) __write_cr4(cr4);
diff --git a/pkgs/os-specific/linux/pipework/default.nix b/pkgs/os-specific/linux/pipework/default.nix
new file mode 100644
index 00000000000..225515cb70a
--- /dev/null
+++ b/pkgs/os-specific/linux/pipework/default.nix
@@ -0,0 +1,28 @@
+{ stdenv, lib, fetchFromGitHub, makeWrapper
+, bridge-utils, iproute, lxc, openvswitch, docker, busybox, dhcpcd, dhcp
+}:
+
+stdenv.mkDerivation rec {
+  name = "pipework-${version}";
+  version = "2015-07-30";
+  src = fetchFromGitHub {
+    owner = "jpetazzo";
+    repo = "pipework";
+    rev = "5a46ecb5f8f933fd268ef315f58a1eb1c46bd93d";
+    sha256 = "02znyg5ir37s8xqjcqqz6xnwyqxapn7c4scyqkcapxr932hf1frh";
+  };
+  buildInputs = [ makeWrapper ];
+  installPhase = ''
+    mkdir -p $out/bin
+    cp pipework $out/bin
+    wrapProgram $out/bin/pipework --prefix PATH : \
+      ${lib.makeSearchPath "bin" [ bridge-utils iproute lxc openvswitch docker busybox dhcpcd dhcp ]};
+  '';
+  meta = with lib; {
+    description = "Software-Defined Networking tools for LXC";
+    homepage = "https://github.com/jpetazzo/pipework";
+    license = licenses.asl20;
+    platforms = platforms.linux;
+    maintainers = with maintainers; [ cstrahan ];
+  };
+}
diff --git a/pkgs/servers/monitoring/bosun/default.nix b/pkgs/servers/monitoring/bosun/default.nix
index dfb2ffbb838..15cdc52fb86 100644
--- a/pkgs/servers/monitoring/bosun/default.nix
+++ b/pkgs/servers/monitoring/bosun/default.nix
@@ -3,14 +3,14 @@
 with goPackages;
 
 buildGoPackage rec {
-  rev = "0.2.0";
+  rev = "0.3.0";
   name = "bosun-${rev}";
   goPackagePath = "bosun.org";
   src = fetchFromGitHub {
     inherit rev;
     owner = "bosun-monitor";
     repo = "bosun";
-    sha256 = "146k37zg4l01l10vwhnhjs6jv8d35zf5l5rljmvy9ydq2npadsjd";
+    sha256 = "05qfhm5ipdry0figa0rhmg93c45dzh2lwpia73pfxp64l1daqa3a";
   };
   subPackages = [ "cmd/bosun" ];
 
diff --git a/pkgs/servers/monitoring/bosun/scollector.nix b/pkgs/servers/monitoring/bosun/scollector.nix
index bd4a5cb1047..d55a68ebdeb 100644
--- a/pkgs/servers/monitoring/bosun/scollector.nix
+++ b/pkgs/servers/monitoring/bosun/scollector.nix
@@ -3,14 +3,14 @@
 with goPackages;
 
 buildGoPackage rec {
-  rev = "20150506172827";
+  rev = "0.3.0";
   name = "scollector-${rev}";
   goPackagePath = "bosun.org";
   src = fetchFromGitHub {
     inherit rev;
     owner = "bosun-monitor";
     repo = "bosun";
-    sha256 = "0rnfiv9b835b8j8r9qh9j2mz9mm9q45vfg9cqa4nngrgfd0cqvl8";
+    sha256 = "05qfhm5ipdry0figa0rhmg93c45dzh2lwpia73pfxp64l1daqa3a";
   };
   subPackages = [ "cmd/scollector" ];
 
diff --git a/pkgs/servers/openpts/bugs.patch b/pkgs/servers/openpts/bugs.patch
new file mode 100644
index 00000000000..d818bafbc9f
--- /dev/null
+++ b/pkgs/servers/openpts/bugs.patch
@@ -0,0 +1,12 @@
+diff -urNp openpts-0.2.6-cvs-patched/src/fsm.c openpts-0.2.6-current/src/fsm.c
+--- openpts-0.2.6-cvs-patched/src/fsm.c	2012-01-05 03:49:15.000000000 -0500
++++ openpts-0.2.6-current/src/fsm.c	2012-01-09 12:11:17.338706205 -0500
+@@ -934,7 +934,7 @@ char *getEventString(OPENPTS_PCR_EVENT_W
+     /* event */
+     event = eventWrapper->event;
+     if (event != NULL) {
+-        // len = snprintf(buf, size, "PCR[%d],TYPE=%d", (int)event->ulPcrIndex, event->eventType);
++        snprintf(buf, size, "PCR[%d],TYPE=%d", (int)event->ulPcrIndex, event->eventType);
+     } else {
+         LOG(LOG_ERR, "NULL event\n");  // TODO(munetoh)
+         xfree(buf);
diff --git a/pkgs/servers/openpts/default.nix b/pkgs/servers/openpts/default.nix
new file mode 100644
index 00000000000..7d82af72b55
--- /dev/null
+++ b/pkgs/servers/openpts/default.nix
@@ -0,0 +1,53 @@
+{ stdenv, fetchurl, autoconf, automake, pkgconfig, libtool, trousers, openssl, libxml2, libuuid, gettext, perl }:
+
+stdenv.mkDerivation rec {
+  name = "openpts-${version}";
+  version = "0.2.6";
+
+  src = fetchurl {
+    url = "http://jaist.dl.osdn.jp/openpts/54410/openpts-${version}.tar.gz";
+    sha256 = "1b5phshl49fxr5y3g5zz75gm0n4cw8i7n29x5f1a95xkwrjpazi0";
+  };
+
+  # patches from https://apps.fedoraproject.org/packages/openpts/sources/patches/
+  patches = [ ./bugs.patch ./zlib.patch ./tboot.patch ./ptsc.patch ];
+
+  buildInputs = [ autoconf automake pkgconfig libtool trousers openssl libxml2 libuuid gettext ];
+
+  preConfigure = ''
+    substituteInPlace include/Makefile.am --replace "./cvs2msg.pl" "${perl}/bin/perl cvs2msg.pl";
+    $SHELL bootstrap.sh
+    '';
+
+  configureFlags = [ "--with-tss" "--with-aru" "--with-tboot" "--enable-tnc" "--with-aide" ];
+
+  NIX_CFLAGS_COMPILE = "-I${trousers}/include/trousers -I${trousers}/include/tss";
+
+  preInstall = ''
+    mkdir -p $out
+    mkdir -p $out/etc
+    cp -p dist/ptsc.conf.in $out/etc/ptsc.conf
+    cp -p dist/ptsv.conf.in $out/etc/ptsv.conf
+    mkdir -p $out/share/openpts/models
+    cp -p models/*.uml $out/share/openpts/models/
+
+    mkdir -p $out/share/openpts/tpm_emulator
+    cp dist/tpm_emulator/README.rhel $out/share/openpts/tpm_emulator/README
+    cp dist/tpm_emulator/binary_bios_measurements $out/share/openpts/tpm_emulator/
+    cp dist/tpm_emulator/tcsd $out/share/openpts/tpm_emulator/
+
+    mkdir -p $out/share/openpts/tboot
+    cp dist/tboot/README.fedora15 $out/share/openpts/tboot/README
+    cp dist/tboot/ptsc.conf.fedora15 $out/share/openpts/tboot/ptsc.conf
+    cp dist/tboot/tcsd.conf.fedora15 $out/share/openpts/tboot/tcsd.conf
+    cp dist/tboot/tcsd.fedora15 $out/share/openpts/tboot/tcsd
+    '';
+
+  meta = {
+    description = "TCG Platform Trust Service (PTS)";
+    homepage = "ttp://sourceforge.jp/projects/openpts";
+    license = stdenv.lib.licenses.cpl10;
+    platforms = stdenv.lib.platforms.unix;
+    maintainers = with stdenv.lib.maintainers; [ tstrobel ];
+  };
+}
diff --git a/pkgs/servers/openpts/ptsc.patch b/pkgs/servers/openpts/ptsc.patch
new file mode 100644
index 00000000000..b6fcde74074
--- /dev/null
+++ b/pkgs/servers/openpts/ptsc.patch
@@ -0,0 +1,28 @@
+diff -urNp openpts-0.2.6-patched/src/ptsc.c openpts-0.2.6-current/src/ptsc.c
+--- openpts-0.2.6-patched/src/ptsc.c	2012-08-21 15:57:07.733841433 -0400
++++ openpts-0.2.6-current/src/ptsc.c	2012-08-21 16:13:26.479732504 -0400
+@@ -457,7 +457,10 @@ void ptsc_lock(void) {
+             exit(1);
+         }
+         oldgrp = getegid();
+-        setegid(grp.gr_gid);
++        if(setegid(grp.gr_gid) != 0){
++		LOG(LOG_ERR, "setegid fail");
++		exit(1);
++	}
+     }
+ 
+     oldmask = umask(0);
+@@ -467,7 +470,10 @@ void ptsc_lock(void) {
+     }
+     if (grpent) {
+         chmod(LOCK_DIR, 02775);
+-        setegid(oldgrp);
++	if(setegid(oldgrp) != 0){
++		LOG(LOG_ERR, "setegid fail");
++		exit(1);
++        }
+     }
+     fd = open(LOCK_FILE, O_RDWR | O_CREAT | O_TRUNC, 0660);
+     if (fd < 0) {
+
diff --git a/pkgs/servers/openpts/tboot.patch b/pkgs/servers/openpts/tboot.patch
new file mode 100644
index 00000000000..6ecee583920
--- /dev/null
+++ b/pkgs/servers/openpts/tboot.patch
@@ -0,0 +1,21 @@
+diff -urNp openpts-0.2.6-patched/src/tboot2iml.c openpts-0.2.6-current/src/tboot2iml.c
+--- openpts-0.2.6-patched/src/tboot2iml.c	2012-07-23 16:30:12.381361421 -0400
++++ openpts-0.2.6-current/src/tboot2iml.c	2012-07-23 17:25:59.053945778 -0400
+@@ -531,7 +531,7 @@ int sinit_acm_hash(char *filename, int s
+ 
+ 
+ int sha1sum_unzip(char *filename, int *filesize, BYTE *digest) {
+-    FILE *fp;
++    gzFile fp;
+     char buf[2048];
+     SHA_CTX sha_ctx;
+     int len;
+@@ -541,7 +541,7 @@ int sha1sum_unzip(char *filename, int *f
+ 
+     /* open */
+     fp = gzopen(filename, "rb");
+-    if (fp == NULL) {
++    if (fp == Z_NULL) {
+         LOG(LOG_ERR, "File %s does not exist\n", filename);
+         return 0;
+     }
diff --git a/pkgs/servers/openpts/zlib.patch b/pkgs/servers/openpts/zlib.patch
new file mode 100644
index 00000000000..7fa3fce10fe
--- /dev/null
+++ b/pkgs/servers/openpts/zlib.patch
@@ -0,0 +1,12 @@
+diff -urNp openpts-0.2.6-cvs-patched/src/Makefile.am openpts-0.2.6-current/src/Makefile.am
+--- openpts-0.2.6-cvs-patched/src/Makefile.am	2012-01-05 03:49:15.000000000 -0500
++++ openpts-0.2.6-current/src/Makefile.am	2012-01-09 14:12:02.507361732 -0500
+@@ -30,7 +30,7 @@ localedir = $(datadir)/locale
+ 
+ 
+ AM_CPPFLAGS = -I$(top_srcdir)/include $(LIBXML2_CFLAGS) $(TSS_CFLAGS) -I../include -DLOCALEDIR=\"$(localedir)\"
+-AM_LDFLAGS = $(LIBXML2_LIBS) $(LIBCRYPTO_LIBS) $(TSS_LIBS) -lopenpts
++AM_LDFLAGS = $(LIBXML2_LIBS) $(LIBCRYPTO_LIBS) $(TSS_LIBS) -lz -lopenpts
+ # $(LIBINTL) -lopenpts
+ 
+ if HAVE_LIBUUID
diff --git a/pkgs/servers/openxpki/default.nix b/pkgs/servers/openxpki/default.nix
new file mode 100644
index 00000000000..dd1ed7c473b
--- /dev/null
+++ b/pkgs/servers/openxpki/default.nix
@@ -0,0 +1,77 @@
+{ stdenv, buildPerlPackage, fetchgit, perl, openssl, perlPackages, gettext, python34Packages
+# TODO: Remove extra dependencies once it is clear that they are NOT needed somewhere.
+, extraDependencies1 ? false, extraDependencies2 ? false, extraDependencies3 ? false }:
+
+buildPerlPackage {
+  name = "openxpki-git20150807";
+
+  src = fetchgit {
+    url = "https://github.com/openxpki/openxpki";
+    rev = "5cb76c553b6b1a81ede380857700628a7521f6e3";
+    sha256 = "7c93bdce7a205c58b08c91c249e566e885ed08f9d43cc2ac652c705c1f7e4490";
+  };
+
+  buildInputs = [ perl openssl gettext python34Packages.sphinx ];
+  propagatedBuildInputs = with perlPackages;
+    [ # dependencies from Makefile.PL
+      libintlperl ConfigVersioned LWP TestSimple ClassAccessorChained IOSocketSSL ClassStd
+      CGISession ConfigStd ConfigMerge Connector CryptCBC CryptOpenSSLAES CryptPKCS10
+      DBDMock DataPassword DataSerializer DateTimeFormatDateParse IOPrompt
+      IPCShareLite JSON Log4Perl LWPProtocolconnect LWPProtocolhttps MailRFC822Address
+      Moose NetAddrIP NetDNS NetIP NetLDAP NetHTTP NetServer NetSSLeay ParamsValidate PathClass
+      ProcProcessTable ProcSafeExec RegexpCommon SOAPLite Switch SysSigAction TemplateToolkit
+      TestPod TestPodCoverage TextCSV_XS TimeHiRes Workflow XMLFilterXInclude XMLParser
+      XMLSAX XMLSAXWriter XMLSimple XMLValidatorSchema ]
+    ++ stdenv.lib.optionals extraDependencies1
+    [ # dependencies from parsing through core/server
+      ClassAccessor Carp PathTools DataDumper DateTime DateTimeFormatStrptime DBI DigestMD5
+      DigestSHA Encode ExceptionClass Exporter FilePath FileTemp Filter GetoptLong HTMLParser
+      ScalarListUtils MathBigInt Memoize MIMEBase64 NetSMTP PodUsage RTClientREST Socket
+      Storable XSLoader ]
+    ++ stdenv.lib.optionals extraDependencies2
+    [ # dependencies taken from Debian
+      MooseXTypesPathClass DataStreamBulk MooseXStrictConstructor NamespaceAutoclean GitPurePerl
+      ConfigGitLike DevelStackTrace TreeDAGNode ClassObservable ClassFactory TimeDate ConfigAny
+      CGIFast ClassISA YAML YAMLLibYAML AuthenSASL TextCSV FileFindRulePerl IODigest ]
+    ++ stdenv.lib.optionals extraDependencies3
+    [ # dependencies taken from http://search.cpan.org/~alech/Bundle-OpenXPKI-0.06/lib/Bundle/OpenXPKI.pm
+      AttributeHandlers AttributeParamsValidate AutoLoader BC CGI CPAN CacheCache ClassClassgenclassgen
+      ClassContainer ClassDataInheritable ClassSingleton ConvertASN1 DBDSQLite DBIxHTMLViewLATEST
+      DBFile DataPage DataSpreadPagination DateTimeLocale DateTimeTimeZone DevelPPPort DevelSelfStubber
+      DevelSymdump Digest DigestSHA1 Env Error ExtUtilsCommand ExtUtilsConstant ExtUtilsInstall
+      ExtUtilsMakeMaker FileCheckTree FilterSimple GoferTransporthttp HTMLMason HTMLTagset
+      HTTPServerSimpleMason I18NCollate IO IPCSysV LocaleCodes LocaleMaketext LogDispatch MathBigRat
+      MathComplex MathRound ModuleBuild ModuleBuildDeprecated NetPing PerlIOviaQuotedPrint PodChecker
+      PodCoverage PodEscapes PodLaTeX PodParser PodPerldoc PodPlainer PodSimple Safe SearchDict SelfLoader
+      SubUplevel SysSyslog TemplatePluginAutoformat TermANSIColor TermCap TermReadKey Test TestException
+      TestHTTPServerSimple TestHarness TestHarnessStraps TextAbbrev TextBalanced TextIconv TextSoundex
+      TextTabsWrap ThreadQueue ThreadSemaphore TieFile TieRefHash TimeLocal URI UnicodeCollate
+      UnicodeNormalize WWWMechanize Want XMLFilterBufferText XMLNamespaceSupport autodie base bignum if_
+      lib libapreq2 libnet podlators threads threadsshared version ];
+
+  preConfigure = ''
+    export OPENSSL_PREFIX=${openssl}
+    substituteInPlace tools/vergen --replace "#!/usr/bin/perl" "#!${perl}/bin/perl"
+    cp ${./vergen_revision_state} .vergen_revision_state
+    cd core/server
+    '';
+
+  postInstall = ''
+    mkdir -p $out/share/openxpki
+    cp -r ../htdocs_source $out/share/openxpki/.
+    cp -r ../../config $out/share/openxpki/.
+    cp -r ../../qatest $out/share/openxpki/.
+    (cd ../i18n; make scan; make; make install PREFIX=$out)
+    (cd ../../clients/perl/OpenXPKI-Client-Enrollment; perl Makefile.PL PREFIX=$out; make; make install PREFIX=$out)
+    (cd ../../doc; make html man; cp _build/man/* $out/share/man/man1/.; mkdir -p $out/share/openxpki/doc; cp -r _build/{html,doctrees} $out/share/openxpki/doc/.)
+    '';
+
+  doCheck = false;
+
+  meta = {
+    homepage = "http://www.openxpki.org";
+    description = "Enterprise-grade PKI/Trustcenter software";
+    license = stdenv.lib.licenses.asl20;
+    maintainers = with stdenv.lib.maintainers; [ tstrobel ];
+  };
+}
diff --git a/pkgs/servers/openxpki/vergen_revision_state b/pkgs/servers/openxpki/vergen_revision_state
new file mode 100644
index 00000000000..9a5d7b531de
--- /dev/null
+++ b/pkgs/servers/openxpki/vergen_revision_state
@@ -0,0 +1,12 @@
+$revision_info = {
+                   'git-tag' => 'v0.33.0',
+                   'git-tags' => 'v0.33.0',
+                   'git-branch' => 'master',
+                   'git-description-root' => undef,
+                   'git-description' => 'v0.33.0',
+                   'revision' => '1591',
+                   'last-changed-revision' => '1591',
+                   'git-abbreviated-commit-hash' => '5cb76c5',
+                   'git-commit-hash' => '5cb76c553b6b1a81ede380857700628a7521f6e3',
+                   'git-commit-date' => 'Tue, 4 Aug 2015 12:47:29 +0200'
+                 };
diff --git a/pkgs/servers/sql/mysql/5.5.x.nix b/pkgs/servers/sql/mysql/5.5.x.nix
index 0a95db91d87..03a7840677b 100644
--- a/pkgs/servers/sql/mysql/5.5.x.nix
+++ b/pkgs/servers/sql/mysql/5.5.x.nix
@@ -4,11 +4,11 @@
 
 stdenv.mkDerivation rec {
   name = "mysql-${version}";
-  version = "5.5.44";
+  version = "5.5.45";
 
   src = fetchurl {
-    url = "http://mysql.mirrors.pair.com/Downloads/MySQL-5.5/${name}.tar.gz";
-    sha256 = "1pp5ngm4ibnp8xnn9haz1db0favd1i7cxdgl5z4677mkgljmpw45";
+    url = "mirror://mysql/MySQL-5.5/${name}.tar.gz";
+    sha256 = "0clkr3r44j8nsgmjzv6r09pb0vjangn5hpyjxgg5ynr674ygskkl";
   };
 
   patches = if stdenv.isCygwin then [
diff --git a/pkgs/stdenv/adapters.nix b/pkgs/stdenv/adapters.nix
index 480801d0d01..836dedf1cb1 100644
--- a/pkgs/stdenv/adapters.nix
+++ b/pkgs/stdenv/adapters.nix
@@ -224,7 +224,7 @@ rec {
   keepDebugInfo = stdenv: stdenv //
     { mkDerivation = args: stdenv.mkDerivation (args // {
         dontStrip = true;
-        NIX_CFLAGS_COMPILE = toString (args.NIX_CFLAGS_COMPILE or "") + " -g -O0";
+        NIX_CFLAGS_COMPILE = toString (args.NIX_CFLAGS_COMPILE or "") + " -ggdb -Og";
       });
     };
 
diff --git a/pkgs/tools/X11/xpra/default.nix b/pkgs/tools/X11/xpra/default.nix
index a18ee18668b..5ef80e887cf 100644
--- a/pkgs/tools/X11/xpra/default.nix
+++ b/pkgs/tools/X11/xpra/default.nix
@@ -1,4 +1,4 @@
-{ stdenv, fetchurl, buildPythonPackage
+{ stdenv, fetchurl, buildPythonPackage, pythonPackages
 , python, cython, pkgconfig
 , xorg, gtk, glib, pango, cairo, gdk_pixbuf, pygtk, atk, pygobject, pycairo
 , makeWrapper, xkbcomp, xorgserver, getopt, xauth, utillinux, which, fontsConf, xkeyboard_config
@@ -6,12 +6,12 @@
 , libfakeXinerama }:
 
 buildPythonPackage rec {
-  name = "xpra-0.14.19";
+  name = "xpra-0.15.3";
   namePrefix = "";
 
   src = fetchurl {
     url = "https://www.xpra.org/src/${name}.tar.xz";
-    sha256 = "0jifaysz4br1v0zibnzgd0k02rgybbsysvwrgbar1452sjb3db5m";
+    sha256 = "1671r4ah2h0i3qbp27csck506n5y1zr9fv0869cv09knspa358i4";
   };
 
   buildInputs = [
@@ -30,7 +30,7 @@ buildPythonPackage rec {
   ];
 
   propagatedBuildInputs = [
-    pil pygtk pygobject
+    pil pygtk pygobject pythonPackages.rencode
   ];
 
   postPatch = ''
diff --git a/pkgs/tools/backup/obnam/default.nix b/pkgs/tools/backup/obnam/default.nix
index edda974281e..9bd0afb4d32 100644
--- a/pkgs/tools/backup/obnam/default.nix
+++ b/pkgs/tools/backup/obnam/default.nix
@@ -12,7 +12,7 @@ pythonPackages.buildPythonPackage rec {
   };
 
   buildInputs = [ pythonPackages.sphinx attr ];
-  propagatedBuildInputs = [ pycrypto pythonPackages.paramiko pythonPackages.tracing pythonPackages.ttystatus pythonPackages.cliapp pythonPackages.larch pythonPackages.pyyaml ];
+  propagatedBuildInputs = [ pycrypto pythonPackages.paramiko pythonPackages.tracing pythonPackages.ttystatus pythonPackages.cliapp pythonPackages.larch pythonPackages.pyyaml pythonPackages.fuse ];
 
   doCheck = false;
 
diff --git a/pkgs/tools/misc/keychain/default.nix b/pkgs/tools/misc/keychain/default.nix
index 0892061a50d..6ffd36312a3 100644
--- a/pkgs/tools/misc/keychain/default.nix
+++ b/pkgs/tools/misc/keychain/default.nix
@@ -1,5 +1,6 @@
 { stdenv, fetchFromGitHub, makeWrapper, coreutils, openssh, gnupg
-, perl, procps, gnugrep, gawk, findutils, gnused }:
+, perl, procps, gnugrep, gawk, findutils, gnused
+, withProcps ? stdenv.isLinux }:
 
 stdenv.mkDerivation rec {
   name = "keychain-${version}";
@@ -26,12 +27,16 @@ stdenv.mkDerivation rec {
       --prefix PATH ":" "${gnused}/bin" \
       --prefix PATH ":" "${findutils}/bin" \
       --prefix PATH ":" "${gawk}/bin" \
-      --prefix PATH ":" "${procps}/bin"
+      ${if withProcps then ("--prefix PATH \":\" ${procps}/bin") else ""}
   '';
 
   meta = {
     description = "Keychain management tool";
     homepage = "http://www.funtoo.org/Keychain";
     license = stdenv.lib.licenses.gpl2;
+    # other platforms are untested (AFAIK)
+    platforms =
+      with stdenv.lib;
+      platforms.linux ++ platforms.darwin;
   };
 }
diff --git a/pkgs/tools/networking/dropbear/default.nix b/pkgs/tools/networking/dropbear/default.nix
index 0cbf41754c3..79a23ae3832 100644
--- a/pkgs/tools/networking/dropbear/default.nix
+++ b/pkgs/tools/networking/dropbear/default.nix
@@ -2,11 +2,11 @@
 sftpPath ? "/var/run/current-system/sw/libexec/sftp-server" }:
 
 stdenv.mkDerivation rec {
-  name = "dropbear-2015.67";
+  name = "dropbear-2015.68";
 
   src = fetchurl {
     url = "http://matt.ucc.asn.au/dropbear/releases/${name}.tar.bz2";
-    sha256 = "1rf8k3v0bklp04a6x85zpa4f45ad5rfqmiv5f1wfbzaxcja0asby";
+    sha256 = "0ii4lq19b3k06fn25zc5sbbk698s56ldrbg1vcf4pzjgj0g7rsjm";
   };
 
   dontDisableStatic = enableStatic;
diff --git a/pkgs/tools/networking/openssh/default.nix b/pkgs/tools/networking/openssh/default.nix
index 357ee2b9f21..57bbf1da22e 100644
--- a/pkgs/tools/networking/openssh/default.nix
+++ b/pkgs/tools/networking/openssh/default.nix
@@ -17,11 +17,11 @@ let
 in
 with stdenv.lib;
 stdenv.mkDerivation rec {
-  name = "openssh-6.9p1";
+  name = "openssh-7.0p1";
 
   src = fetchurl {
     url = "mirror://openbsd/OpenSSH/portable/${name}.tar.gz";
-    sha256 = "1zkci5nbpb4frmzj2vr3kv9j47x2h72kvybcpr0d8mzk73sls1vf";
+    sha256 = "1rc52jyc5v5b8j9kvasrnz9vnj9b0i7fw4nqac8wix0r794k4ngx";
   };
 
   prePatch = optionalString hpnSupport
diff --git a/pkgs/tools/security/gnupg/21.nix b/pkgs/tools/security/gnupg/21.nix
index 2bbd73763dc..2a0f1254513 100644
--- a/pkgs/tools/security/gnupg/21.nix
+++ b/pkgs/tools/security/gnupg/21.nix
@@ -13,11 +13,11 @@ with stdenv.lib;
 assert x11Support -> pinentry != null;
 
 stdenv.mkDerivation rec {
-  name = "gnupg-2.1.6";
+  name = "gnupg-2.1.7";
 
   src = fetchurl {
     url = "mirror://gnupg/gnupg/${name}.tar.bz2";
-    sha256 = "1zcj5vsrc64zyq7spnx2xlxlq6wxaf5bilpf6gbkp7qr8barlnay";
+    sha256 = "0vl4wzraln0h4db0kfza4l5by5pgfijqplji5n4riv3zsiv3g2n1";
   };
 
   postPatch = stdenv.lib.optionalString stdenv.isLinux ''
diff --git a/pkgs/tools/security/nsjail/default.nix b/pkgs/tools/security/nsjail/default.nix
new file mode 100644
index 00000000000..f2ec3af139f
--- /dev/null
+++ b/pkgs/tools/security/nsjail/default.nix
@@ -0,0 +1,30 @@
+{ stdenv, fetchgit }:
+
+stdenv.mkDerivation rec {
+  name = "nsjail-git-2015-08-10";
+
+  src = fetchgit {
+    url = https://github.com/google/nsjail;
+    rev = "8b951e6c2827386786cde4a124cd1846d25b9404";
+    sha256 = "b3b863423cc676111d2d1afbac524eee6fa824588cafccb7c42ff470508a13b1";
+  };
+
+  installPhase = ''
+    mkdir -p $out/bin
+    cp nsjail $out/bin
+  '';
+
+  meta = {
+    description = ''
+      A light-weight process isolation tool, making use of Linux namespaces
+      and seccomp-bpf syscall filters
+      '';
+    homepage = http://google.github.io/nsjail;
+
+    license = stdenv.lib.licenses.apsl20;
+
+    maintainers = [ stdenv.lib.maintainers.bosu ];
+
+    platforms = stdenv.lib.platforms.linux;
+  };
+}
diff --git a/pkgs/tools/security/pinentry/default.nix b/pkgs/tools/security/pinentry/default.nix
index 7b8e2fe2761..30d717c7bc1 100644
--- a/pkgs/tools/security/pinentry/default.nix
+++ b/pkgs/tools/security/pinentry/default.nix
@@ -1,5 +1,5 @@
 { fetchurl, stdenv, pkgconfig
-, libcap ? null, ncurses ? null, gtk2 ? null, qt4 ? null
+, libgpgerror, libassuan, libcap ? null, ncurses ? null, gtk2 ? null, qt4 ? null
 }:
 
 let
@@ -10,14 +10,14 @@ let
 in
 with stdenv.lib;
 stdenv.mkDerivation rec {
-  name = "pinentry-0.9.4";
+  name = "pinentry-0.9.5";
 
   src = fetchurl {
     url = "mirror://gnupg/pinentry/${name}.tar.bz2";
-    sha256 = "1q72ir9r9j70px61rdpd80an56k4ixmzy810nr14aildffxkb22b";
+    sha256 = "1338hj1h3sh34897120y30x12b64wyj3xjzzk5asm2hdzhxgsmva";
   };
 
-  buildInputs = [ libcap gtk2 ncurses qt4 ];
+  buildInputs = [ libgpgerror libassuan libcap gtk2 ncurses qt4 ];
 
   prePatch = ''
     substituteInPlace pinentry/pinentry-curses.c --replace ncursesw ncurses
diff --git a/pkgs/tools/security/stoken/default.nix b/pkgs/tools/security/stoken/default.nix
new file mode 100644
index 00000000000..17652e220da
--- /dev/null
+++ b/pkgs/tools/security/stoken/default.nix
@@ -0,0 +1,35 @@
+{ stdenv, fetchFromGitHub, autoconf, automake, libtool, pkgconfig
+, libxml2, nettle
+, withGTK3 ? true, gtk3 }:
+
+stdenv.mkDerivation rec {
+  pname = "stoken";
+  version = "v0.90";
+  name = "${pname}-${version}";
+  src = fetchFromGitHub {
+    owner = "cernekee";
+    repo = pname;
+    rev = version;
+    sha256 = "1k7wn8pmp7dv646g938dsr99090lsphl7zy4m9x7qbh2zlnnf9af";
+  };
+
+  preConfigure = ''
+    aclocal
+    libtoolize --automake --copy
+    autoheader
+    automake --add-missing --copy
+    autoconf
+  '';
+  buildInputs = [
+    autoconf automake libtool pkgconfig
+    libxml2 nettle
+  ] ++ stdenv.lib.optional withGTK3 gtk3;
+
+  meta = with stdenv.lib; {
+    description = "Software Token for Linux/UNIX";
+    homepage = https://github.com/cernekee/stoken;
+    license = licenses.lgpl21Plus;
+    maintainers = [ maintainers.fuuzetsu ];
+    platforms = platforms.all;
+  };
+}
diff --git a/pkgs/tools/text/colordiff/default.nix b/pkgs/tools/text/colordiff/default.nix
index 18eae754f4f..89bbd862dad 100644
--- a/pkgs/tools/text/colordiff/default.nix
+++ b/pkgs/tools/text/colordiff/default.nix
@@ -18,7 +18,7 @@ stdenv.mkDerivation {
     description = "Wrapper for 'diff' that produces the same output but with pretty 'syntax' highlighting";
     homepage = http://www.colordiff.org/;
     license = licenses.gpl3;
-    platforms = platforms.linux;
+    platforms = platforms.linux ++ platforms.darwin;
     maintainer = with maintainers; [ nckx ];
   };
 }
diff --git a/pkgs/top-level/all-packages.nix b/pkgs/top-level/all-packages.nix
index 2dd01957be7..d27dd54875f 100644
--- a/pkgs/top-level/all-packages.nix
+++ b/pkgs/top-level/all-packages.nix
@@ -2418,6 +2418,8 @@ let
     pythonPackages = python3Packages;
   };
 
+  nsjail = callPackage ../tools/security/nsjail {};
+
   nss_pam_ldapd = callPackage ../tools/networking/nss-pam-ldapd {};
 
   ntfs3g = callPackage ../tools/filesystems/ntfs-3g { };
@@ -3062,6 +3064,10 @@ let
 
   stress-ng = callPackage ../tools/system/stress-ng { };
 
+  stoken = callPackage ../tools/security/stoken {
+    withGTK3 = config.stoken.withGTK3 or true;
+  };
+
   storeBackup = callPackage ../tools/backup/store-backup { };
 
   stow = callPackage ../tools/misc/stow { };
@@ -5022,13 +5028,11 @@ let
     php = php55;
   });
 
-  php54 = callPackage ../development/interpreters/php/5.4.nix { };
-
-  php55 = callPackage ../development/interpreters/php/5.5.nix { };
-
-  php56 = callPackage ../development/interpreters/php/5.6.nix { };
-
-  php70 = callPackage ../development/interpreters/php/7.0.nix { };
+  inherit (callPackages ../development/interpreters/php { })
+    php54
+    php55
+    php56
+    php70;
 
   picoc = callPackage ../development/interpreters/picoc {};
 
@@ -6750,6 +6754,8 @@ let
 
   libatomic_ops = callPackage ../development/libraries/libatomic_ops {};
 
+  libaudclient = callPackage ../development/libraries/libaudclient { };
+
   libav = libav_11; # branch 11 is API-compatible with branch 10
   libav_all = callPackage ../development/libraries/libav { };
   inherit (libav_all) libav_0_8 libav_9 libav_11;
@@ -9028,10 +9034,14 @@ let
 
   nsq = callPackage ../servers/nsq { };
 
+  openpts = callPackage ../servers/openpts { };
+
   openresty = callPackage ../servers/http/openresty { };
 
   opensmtpd = callPackage ../servers/mail/opensmtpd { };
 
+  openxpki = callPackage ../servers/openxpki { };
+
   osrm-backend = callPackage ../servers/osrm-backend { };
 
   osrm-backend_luajit = callPackage ../servers/osrm-backend { luabind = luabind_luajit; };
@@ -9550,6 +9560,10 @@ let
 
   eject = utillinux;
 
+  fanctl = callPackage ../os-specific/linux/fanctl {
+    iproute = iproute.override { enableFan = true; };
+  };
+
   fatrace = callPackage ../os-specific/linux/fatrace { };
 
   ffadoFull = callPackage ../os-specific/linux/ffado { };
@@ -10068,6 +10082,8 @@ let
 
   perf-tools = callPackage ../os-specific/linux/perf-tools { };
 
+  pipework = callPackage ../os-specific/linux/pipework { };
+
   plymouth = callPackage ../os-specific/linux/plymouth { };
 
   pmount = callPackage ../os-specific/linux/pmount { };
@@ -10773,6 +10789,8 @@ let
 
   bar = callPackage ../applications/window-managers/bar { };
 
+  bar-xft = callPackage ../applications/window-managers/bar/xft.nix { };
+
   baresip = callPackage ../applications/networking/instant-messengers/baresip {
     ffmpeg = ffmpeg_1;
   };
@@ -10848,6 +10866,8 @@ let
 
   cava = callPackage ../applications/audio/cava { };
 
+  cbc = callPackage ../applications/science/math/cbc { };
+
   cc1394 = callPackage ../applications/video/cc1394 { };
 
   cddiscid = callPackage ../applications/audio/cd-discid { };
@@ -11394,6 +11414,8 @@ let
     fftw = fftwSinglePrec;
   };
 
+  gjay = callPackage ../applications/audio/gjay { };
+
   photivo = callPackage ../applications/graphics/photivo { };
 
   wavesurfer = callPackage ../applications/misc/audio/wavesurfer { };
@@ -12400,6 +12422,8 @@ let
 
   toxprpl = callPackage ../applications/networking/instant-messengers/pidgin-plugins/tox-prpl { };
 
+  pidgin-opensteamworks = callPackage ../applications/networking/instant-messengers/pidgin-plugins/pidgin-opensteamworks { };
+
   pithos = callPackage ../applications/audio/pithos {
     pythonPackages = python34Packages;
   };
@@ -12458,8 +12482,8 @@ let
   pythonmagick = callPackage ../applications/graphics/PythonMagick { };
 
   qbittorrent = callPackage ../applications/networking/p2p/qbittorrent {
-    boost = boost156;
-    libtorrentRasterbar = libtorrentRasterbar_0_16;
+    boost = boost;
+    libtorrentRasterbar = libtorrentRasterbar;
   };
 
   eiskaltdcpp = callPackage ../applications/networking/p2p/eiskaltdcpp { lua5 = lua5_1; };
@@ -13729,6 +13753,8 @@ let
 
   prboom = callPackage ../games/prboom { };
 
+  qqwing = callPackage ../games/qqwing { };
+
   quake3demo = callPackage ../games/quake3/wrapper {
     name = "quake3-demo-${quake3game.name}";
     description = "Demo of Quake 3 Arena, a classic first-person shooter";
diff --git a/pkgs/top-level/perl-packages.nix b/pkgs/top-level/perl-packages.nix
index 5218e9e2ecb..680f505af46 100644
--- a/pkgs/top-level/perl-packages.nix
+++ b/pkgs/top-level/perl-packages.nix
@@ -168,6 +168,14 @@ let self = _self // overrides; _self = with self; {
     };
   };
 
+  ApacheTest = buildPerlPackage {
+    name = "Apache-Test-1.38";
+    src = fetchurl {
+      url = mirror://cpan/authors/id/P/PH/PHRED/Apache-Test-1.38.tar.gz;
+      sha256 = "321717f58636ed0aa85cba6d69fc01e2ccbc90ba71ec2dcc2134d8401af65145";
+    };
+  };
+
   AppCLI = buildPerlPackage {
     name = "App-CLI-0.313";
     src = fetchurl {
@@ -259,6 +267,34 @@ let self = _self // overrides; _self = with self; {
     };
   };
 
+  AttributeHandlers = buildPerlPackage {
+    name = "Attribute-Handlers-0.99";
+    src = fetchurl {
+      url = mirror://cpan/authors/id/R/RJ/RJBS/Attribute-Handlers-0.99.tar.gz;
+      sha256 = "937ea3ebfc9b14f4a4148bf3c32803709edbd12a387137a26370b38ee1fc9835";
+    };
+    meta = {
+      description = "Simpler definition of attribute handlers";
+      license = "perl";
+    };
+  };
+
+  AttributeParamsValidate = buildPerlPackage {
+    name = "Attribute-Params-Validate-1.21";
+    src = fetchurl {
+      url = mirror://cpan/authors/id/D/DR/DROLSKY/Attribute-Params-Validate-1.21.tar.gz;
+      sha256 = "586b939ceffdb37188b7c461dd1a8f9f35695184c8703b05c35f6d508c8090f5";
+    };
+    buildInputs = [ TestFatal ];
+    propagatedBuildInputs = [ ParamsValidate ];
+    doCheck = false;
+    meta = {
+      homepage = http://metacpan.org/release/Attribute-Params-Validate;
+      description = "Define validation through subroutine attributes";
+      license = "artistic_2";
+    };
+  };
+
   ArrayCompare = buildPerlPackage {
     name = "Array-Compare-1.18";
     src = fetchurl {
@@ -392,6 +428,18 @@ let self = _self // overrides; _self = with self; {
 
   autodie = null; # part of Perl
 
+  AutoLoader = buildPerlPackage {
+    name = "AutoLoader-5.74";
+    src = fetchurl {
+      url = mirror://cpan/authors/id/S/SM/SMUELLER/AutoLoader-5.74.tar.gz;
+      sha256 = "2fac75b05309f71a6871804cd25e1a3ba0a28f43f294fb54528077558da3aff4";
+    };
+    meta = {
+      description = "Load subroutines only on demand";
+      license = "perl";
+    };
+  };
+
   autovivification = buildPerlPackage {
     name = "autovivification-0.12";
     src = fetchurl {
@@ -405,6 +453,39 @@ let self = _self // overrides; _self = with self; {
     };
   };
 
+  base = buildPerlPackage {
+    name = "base-2.18";
+    src = fetchurl {
+      url = mirror://cpan/authors/id/R/RG/RGARCIA/base-2.18.tar.gz;
+      sha256 = "55b0d21f8edb5ef6dddcb1fd2457acb19c7584f2dfdea614685cd8ea62a1c306";
+    };
+  };
+
+  BC = buildPerlPackage {
+    name = "B-C-1.52";
+    src = fetchurl {
+      url = mirror://cpan/authors/id/R/RU/RURBAN/B-C-1.52.tar.gz;
+      sha256 = "072b4b9e39431ad8ef5173557c26ade97f985cf150f6580a20f42dd9fc3651a7";
+    };
+    propagatedBuildInputs = [ BFlags IPCRun Opcodes ];
+    meta = {
+      homepage = http://www.perl-compiler.org;
+      description = "Perl compiler";
+      license = "perl";
+    };
+  };
+
+  BFlags = buildPerlPackage {
+    name = "B-Flags-0.13";
+    src = fetchurl {
+      url = mirror://cpan/authors/id/R/RU/RURBAN/B-Flags-0.13.tar.gz;
+      sha256 = "6d00f08681772d0abec3aeedb5584910a6df5ced230c1525403a1c7da42f1352";
+    };
+    meta = {
+      description = "Friendlier flags for B";
+    };
+  };
+
   BerkeleyDB = import ../development/perl-modules/BerkeleyDB {
     inherit buildPerlPackage fetchurl;
     inherit (pkgs) db;
@@ -439,6 +520,18 @@ let self = _self // overrides; _self = with self; {
     };
   };
 
+  bignum = buildPerlPackage {
+    name = "bignum-0.37";
+    src = fetchurl {
+      url = mirror://cpan/authors/id/P/PJ/PJACKLAM/bignum-0.37.tar.gz;
+      sha256 = "9d2e035222d8b00d062959cb5ae491cb6ce80b7ea0ea8c05e53c415022e4f871";
+    };
+    meta = {
+      description = "Transparent BigNumber support for Perl";
+      license = "perl";
+    };
+  };
+
   BitVector = buildPerlPackage {
     name = "Bit-Vector-7.3";
     src = fetchurl {
@@ -652,6 +745,18 @@ let self = _self // overrides; _self = with self; {
     };
   };
 
+  Carp = buildPerlPackage {
+    name = "Carp-1.36";
+    src = fetchurl {
+      url = mirror://cpan/authors/id/R/RJ/RJBS/Carp-1.36.tar.gz;
+      sha256 = "dcc789935126461c80df0653f98c1d8d0b936dcc3d04174287cb02767eca123c";
+    };
+    meta = {
+      description = "Alternative warn and die for modules";
+      license = "perl";
+    };
+  };
+
   CarpAlways = buildPerlPackage rec {
     name = "Carp-Always-0.13";
     src = fetchurl {
@@ -1172,6 +1277,20 @@ let self = _self // overrides; _self = with self; {
     };
   };
 
+  CGI = buildPerlPackage {
+    name = "CGI-4.21";
+    src = fetchurl {
+      url = mirror://cpan/authors/id/L/LE/LEEJO/CGI-4.21.tar.gz;
+      sha256 = "340d20a2b67211752d7c270c589e463d71aea8b8d75d9417250618219d3cf884";
+    };
+    propagatedBuildInputs = [ HTMLParser if_ ];
+    doCheck = false;
+    meta = {
+      homepage = https://metacpan.org/module/CGI;
+      description = "Handle Common Gateway Interface requests and responses";
+    };
+  };
+
   CGICookieXS = buildPerlPackage rec {
     name = "CGI-Cookie-XS-0.18";
     src = fetchurl {
@@ -1194,6 +1313,20 @@ let self = _self // overrides; _self = with self; {
     };
   };
 
+  CGIFast = buildPerlPackage {
+    name = "CGI-Fast-2.10";
+    src = fetchurl {
+      url = mirror://cpan/authors/id/L/LE/LEEJO/CGI-Fast-2.10.tar.gz;
+      sha256 = "98263afcc9f5d88c7cbbd39651c5431b434c1c815fe284962d887ed7be3a1dd3";
+    };
+    propagatedBuildInputs = [ FCGI if_ ];
+    doCheck = false;
+    meta = {
+      homepage = https://metacpan.org/module/CGI::Fast;
+      license = "perl";
+    };
+  };
+
   CGIFormBuilder = buildPerlPackage rec {
     name = "CGI-FormBuilder-3.09";
     src = fetchurl {
@@ -1341,6 +1474,27 @@ let self = _self // overrides; _self = with self; {
     };
   };
 
+  ClassClassgenclassgen = buildPerlPackage {
+    name = "Class-Classgen-classgen-3.03";
+    src = fetchurl {
+      url = mirror://cpan/authors/id/M/MS/MSCHLUE/Class-Classgen-classgen-3.03.tar.gz;
+      sha256 = "9b65d41b991538992e816b32cc4fa9b4a4a0bb3e9c10e7eebeff82658dbbc8f6";
+    };
+  };
+
+  ClassContainer = buildPerlPackage {
+    name = "Class-Container-0.12";
+    src = fetchurl {
+      url = mirror://cpan/authors/id/K/KW/KWILLIAMS/Class-Container-0.12.tar.gz;
+      sha256 = "771206f2b7a916ce0dfb93d82200472beaeb910248482734179bf36808e486b1";
+    };
+    propagatedBuildInputs = [ ParamsValidate ];
+    meta = {
+      description = "Glues object frameworks together transparently";
+      license = "perl";
+    };
+  };
+
   ClassDataAccessor = buildPerlPackage {
     name = "Class-Data-Accessor-0.04004";
     src = fetchurl {
@@ -1357,6 +1511,14 @@ let self = _self // overrides; _self = with self; {
     };
   };
 
+  ClassFactory = buildPerlPackage {
+    name = "Class-Factory-1.06";
+    src = fetchurl {
+      url = mirror://cpan/authors/id/P/PH/PHRED/Class-Factory-1.06.tar.gz;
+      sha256 = "c37a2d269eb935f36a23e113480ae0946fa7c12a12781396a1226c8e435f30f5";
+    };
+  };
+
   ClassFactoryUtil = buildPerlPackage rec {
     name = "Class-Factory-Util-1.7";
     src = fetchurl {
@@ -1487,6 +1649,27 @@ let self = _self // overrides; _self = with self; {
     };
   };
 
+  ClassObservable = buildPerlPackage {
+    name = "Class-Observable-1.04";
+    src = fetchurl {
+      url = mirror://cpan/authors/id/C/CW/CWINTERS/Class-Observable-1.04.tar.gz;
+      sha256 = "3ef18733a0f03c113f3bcf8ac50476e09ca1fe6234f4aaacaa24dfca95168094";
+    };
+    propagatedBuildInputs = [ ClassISA ];
+  };
+
+  ClassStd = buildPerlPackage {
+    name = "Class-Std-0.013";
+    src = fetchurl {
+      url = mirror://cpan/authors/id/C/CH/CHORNY/Class-Std-0.013.tar.gz;
+      sha256 = "bcd6d82f6c8af0fe069fced7dd165a4795b0b6e92351c7d4e5a1ab9a14fc35c6";
+    };
+    meta = {
+      description = "Support for creating standard 'inside-out' classes";
+      license = "perl";
+    };
+  };
+
   ClassUnload = buildPerlPackage rec {
     name = "Class-Unload-0.08";
     src = fetchurl {
@@ -1531,6 +1714,18 @@ let self = _self // overrides; _self = with self; {
     };
   };
 
+  CompressBzip2 = buildPerlPackage {
+    name = "Compress-Bzip2-2.22";
+    src = fetchurl {
+      url = mirror://cpan/authors/id/R/RU/RURBAN/Compress-Bzip2-2.22.tar.gz;
+      sha256 = "1603e284e07953415b8eaa132698db8b03f46383f883c0902926f36eecb7e895";
+    };
+    meta = {
+      description = "Interface to Bzip2 compression library";
+      license = "perl";
+    };
+  };
+
   CompressRawBzip2 = buildPerlPackage {
     name = "Compress-Raw-Bzip2-2.064";
     src = fetchurl {
@@ -1631,6 +1826,20 @@ let self = _self // overrides; _self = with self; {
     };
   };
 
+  ConfigMerge = buildPerlPackage {
+    name = "Config-Merge-1.04";
+    src = fetchurl {
+      url = mirror://cpan/authors/id/D/DR/DRTECH/Config-Merge-1.04.tar.gz;
+      sha256 = "a932477b43ae5fb04a16f071a891da7bd2086c10c680592f2888fa9d9972cccf";
+    };
+    buildInputs = [ ConfigAny YAML ];
+    propagatedBuildInputs = [ ConfigAny ];
+    meta = {
+      description = "Load a configuration directory tree containing YAML, JSON, XML, Perl, INI or Config::General files";
+      license = "perl";
+    };
+  };
+
   ConfigMVP = buildPerlPackage {
     name = "Config-MVP-2.200010";
     src = fetchurl {
@@ -1661,6 +1870,18 @@ let self = _self // overrides; _self = with self; {
     };
   };
 
+  ConfigStd = buildPerlPackage {
+    name = "Config-Std-0.901";
+    src = fetchurl {
+      url = mirror://cpan/authors/id/B/BR/BRICKER/Config-Std-0.901.tar.gz;
+      sha256 = "c5c57eb82a37cc41ea152098fc8e5548acfea8861140fbac8fc3beccbb09c243";
+    };
+    propagatedBuildInputs = [ ClassStd ];
+    meta = {
+      description = "Load and save configuration files in a standard format";
+    };
+  };
+
   ConfigTiny = buildPerlPackage rec {
     name = "Config-Tiny-2.20";
     src = fetchurl {
@@ -1669,6 +1890,30 @@ let self = _self // overrides; _self = with self; {
     };
   };
 
+  ConfigVersioned = buildPerlPackage {
+    name = "Config-Versioned-1.01";
+    src = fetchurl {
+      url = mirror://cpan/authors/id/M/MR/MRSCOTTY/Config-Versioned-1.01.tar.gz;
+      sha256 = "bc9a4ae3738bd89f86a07bca673627ca3c92ba969737cd6dbc7ab7ad17cd2348";
+    };
+    buildInputs = [ DateTime PathClass ];
+    propagatedBuildInputs = [ ConfigStd GitPurePerl Moose ];
+    doCheck = false;
+    meta = {
+      description = "Simple, versioned access to configuration data";
+      license = "perl";
+    };
+  };
+
+  Connector = buildPerlPackage {
+    name = "Connector-1.15";
+    src = fetchurl {
+      url = mirror://cpan/authors/id/M/MR/MRSCOTTY/Connector-1.15.tar.gz;
+      sha256 = "1p64gnkrik7f21jj0x5di0inmb4s1p33g0mxyk5gvwchkf43pyn4";
+    };
+    doCheck = false;
+  };
+
   ConvertASN1 = buildPerlPackage rec {
     name = "Convert-ASN1-0.26";
     src = fetchurl {
@@ -1740,6 +1985,19 @@ let self = _self // overrides; _self = with self; {
     };
   };
 
+  CPAN = buildPerlPackage {
+    name = "CPAN-2.10";
+    src = fetchurl {
+      url = mirror://cpan/authors/id/A/AN/ANDK/CPAN-2.10.tar.gz;
+      sha256 = "090e9e3d9fca83b89341a75c514c7411b743c887743723dbfe80f30d4ee5f3ad";
+    };
+    propagatedBuildInputs = [ ArchiveZip CompressBzip2 Expect FileHomeDir FileWhich JSONPP LWP ModuleSignature TermReadKey TextGlob YAML YAMLLibYAML YAMLSyck ];
+    meta = {
+      description = "Query, download and build perl modules from CPAN sites";
+      license = "perl";
+    };
+  };
+
   CPANChanges = buildPerlPackage {
     name = "CPAN-Changes-0.27";
     src = fetchurl {
@@ -1912,6 +2170,19 @@ let self = _self // overrides; _self = with self; {
     };
   };
 
+  CryptPKCS10 = buildPerlPackage {
+    name = "Crypt-PKCS10-1.0";
+    src = fetchurl {
+      url = mirror://cpan/authors/id/G/GK/GKNOCKE/Crypt-PKCS10-1.0.zip;
+      sha256 = "08de199411056df1a1e6374b503574d21089913daa3823ebb21aa399dc59bdb6";
+    };
+    buildInputs = [ pkgs.unzip ];
+    propagatedBuildInputs = [ ConvertASN1 ];
+    meta = {
+      license = "perl";
+    };
+  };
+
   CryptRandomSource = buildPerlPackage {
     name = "Crypt-Random-Source-0.07";
     src = fetchurl {
@@ -2083,6 +2354,14 @@ let self = _self // overrides; _self = with self; {
     };
   };
 
+  DataDumper = buildPerlPackage {
+    name = "Data-Dumper-2.154";
+    src = fetchurl {
+      url = mirror://cpan/authors/id/S/SM/SMUELLER/Data-Dumper-2.154.tar.gz;
+      sha256 = "e30fcb6dea290cda85b67fc46d227a2ea890a8bd36c213557adec9c99ebd212f";
+    };
+  };
+
   DataDumperConcise = buildPerlPackage rec {
     name = "Data-Dumper-Concise-2.020";
     src = fetchurl {
@@ -2148,6 +2427,14 @@ let self = _self // overrides; _self = with self; {
     propagatedBuildInputs = [TestException ClassAccessorChained];
   };
 
+  DataPassword = buildPerlPackage {
+    name = "Data-Password-1.12";
+    src = fetchurl {
+      url = mirror://cpan/authors/id/R/RA/RAZINF/Data-Password-1.12.tar.gz;
+      sha256 = "830cde81741ff384385412e16faba55745a54a7cc019dd23d7ed4f05d551a961";
+    };
+  };
+
   DataSection = buildPerlPackage {
     name = "Data-Section-0.101622";
     src = fetchurl {
@@ -2174,6 +2461,18 @@ let self = _self // overrides; _self = with self; {
     };
   };
 
+  DataSpreadPagination = buildPerlPackage {
+    name = "Data-SpreadPagination-0.1.2";
+    src = fetchurl {
+      url = mirror://cpan/authors/id/K/KN/KNEW/Data-SpreadPagination-0.1.2.tar.gz;
+      sha256 = "74ebfd847132c38cc9e835e14e82c43f1809a95cbc98bb84d1f7ce2e4ef487e3";
+    };
+    propagatedBuildInputs = [ DataPage MathRound ];
+    meta = {
+      license = "perl";
+    };
+  };
+
   DataStreamBulk = buildPerlPackage {
     name = "Data-Stream-Bulk-0.11";
     src = fetchurl {
@@ -2320,6 +2619,19 @@ let self = _self // overrides; _self = with self; {
     };
   };
 
+  DateTimeFormatDateParse = buildPerlPackage {
+    name = "DateTime-Format-DateParse-0.05";
+    src = fetchurl {
+      url = mirror://cpan/authors/id/J/JH/JHOBLITT/DateTime-Format-DateParse-0.05.tar.gz;
+      sha256 = "f6eca4c8be66ce9992ee150932f8fcf07809fd3d1664caf200b8a5fd3a7e5ebc";
+    };
+    propagatedBuildInputs = [ DateTime DateTimeTimeZone TimeDate ];
+    meta = {
+      description = "Parses Date::Parse compatible formats";
+      license = "perl";
+    };
+  };
+
   DateTimeFormatFlexible = buildPerlPackage {
     name = "DateTime-Format-Flexible-0.26";
     src = fetchurl {
@@ -2507,6 +2819,19 @@ let self = _self // overrides; _self = with self; {
     propagatedBuildInputs = [ IOCaptureOutput ];
   };
 
+  DevelDProf = buildPerlPackage {
+    name = "Devel-DProf-20110802.00";
+    src = fetchurl {
+      url = mirror://cpan/authors/id/F/FL/FLORA/Devel-DProf-20110802.00.tar.gz;
+      sha256 = "b9eec466ab77aa9f6ab48d33134694d1aa5a8cd221b1aa0a00d09c93ab69643c";
+    };
+    meta = {
+      homepage = http://search.cpan.org/dist/Devel-DProf;
+      description = "A B<DEPRECATED> Perl code profiler";
+      license = "perl";
+    };
+  };
+
   DevelPatchPerl = buildPerlPackage {
     name = "Devel-PatchPerl-1.28";
     src = fetchurl {
@@ -2521,6 +2846,31 @@ let self = _self // overrides; _self = with self; {
     };
   };
 
+  DevelPPPort = buildPerlPackage {
+    name = "Devel-PPPort-3.31";
+    src = fetchurl {
+      url = mirror://cpan/authors/id/W/WO/WOLFSAGE/Devel-PPPort-3.31.tar.gz;
+      sha256 = "ead2c49f0442a26890723231a92d3c0ac6ac297b814839e421a77d7889a2471d";
+    };
+    meta = {
+      description = "Perl/Pollution/Portability";
+      license = "perl";
+    };
+  };
+
+  DevelSelfStubber = buildPerlPackage {
+    name = "Devel-SelfStubber-1.05";
+    src = fetchurl {
+      url = mirror://cpan/authors/id/F/FL/FLORA/Devel-SelfStubber-1.05.tar.gz;
+      sha256 = "b7bd750e41ec2dbca3f2f1d48e5e8ba594dcc8bc7a923a2565611ab8d0846bf8";
+    };
+    meta = {
+      homepage = http://search.cpan.org/dist/Devel-SelfStubber;
+      description = "Generate stubs for a SelfLoading module";
+      license = "perl";
+    };
+  };
+
   DevelSizeMe = buildPerlPackage {
     name = "Devel-SizeMe-0.19";
     src = fetchurl {
@@ -2547,6 +2897,15 @@ let self = _self // overrides; _self = with self; {
     };
   };
 
+  DBDMock = buildPerlPackage {
+    name = "DBD-Mock-1.45";
+    src = fetchurl {
+      url = mirror://cpan/authors/id/D/DI/DICHI/DBD-Mock/DBD-Mock-1.45.tar.gz;
+      sha256 = "40a80c37b31ef14536b58b4a8b483e65953b00b8fa7397817c7eb76d540bd00f";
+    };
+    propagatedBuildInputs = [ DBI TestException ];
+  };
+
   DBDSQLite = import ../development/perl-modules/DBD-SQLite {
     inherit stdenv fetchurl buildPerlPackage DBI;
     inherit (pkgs) sqlite;
@@ -2689,6 +3048,15 @@ let self = _self // overrides; _self = with self; {
     };
   };
 
+  DBIxHTMLViewLATEST = buildPerlPackage {
+    name = "DBIx-HTMLView-LATEST";
+    src = fetchurl {
+      url = mirror://cpan/authors/id/H/HA/HAKANARDO/DBIx-HTMLView-LATEST.tar.gz;
+      sha256 = "b1af44cba329a8f583d174c5e82a7a2e91fe4f3a35cc38cbf028449578114dfa";
+    };
+    doCheck = false;
+  };
+
   DBIxSimple = buildPerlPackage {
     name = "DBIx-Simple-1.35";
     src = fetchurl {
@@ -2817,6 +3185,18 @@ let self = _self // overrides; _self = with self; {
     ];
   };
 
+  Digest = buildPerlPackage {
+    name = "Digest-1.17";
+    src = fetchurl {
+      url = mirror://cpan/authors/id/G/GA/GAAS/Digest-1.17.tar.gz;
+      sha256 = "2f6a54459fc7f37c0669d548bb224b695eb8d2ddc089aa5547645ce1f5fd86f7";
+    };
+    meta = {
+      description = "Modules that calculate message digests";
+      license = "perl";
+    };
+  };
+
   DigestCRC = buildPerlPackage rec {
     name = "Digest-CRC-0.18";
     src = fetchurl {
@@ -2859,6 +3239,18 @@ let self = _self // overrides; _self = with self; {
     };
   };
 
+  DigestMD5 = buildPerlPackage {
+    name = "Digest-MD5-2.54";
+    src = fetchurl {
+      url = mirror://cpan/authors/id/G/GA/GAAS/Digest-MD5-2.54.tar.gz;
+      sha256 = "90de11e3743ef1c753a5c2032b434e09472046fbcf346996cbe5d135b217f390";
+    };
+    meta = {
+      description = "Perl interface to the MD-5 algorithm";
+      license = "perl";
+    };
+  };
+
   DigestMD5File = buildPerlPackage {
     name = "Digest-MD5-File-0.08";
     src = fetchurl {
@@ -3419,6 +3811,19 @@ let self = _self // overrides; _self = with self; {
     };
   };
 
+  Env = buildPerlPackage {
+    name = "Env-1.04";
+    src = fetchurl {
+      url = mirror://cpan/authors/id/F/FL/FLORA/Env-1.04.tar.gz;
+      sha256 = "d94a3d412df246afdc31a2199cbd8ae915167a3f4684f7b7014ce1200251ebb0";
+    };
+    meta = {
+      homepage = http://search.cpan.org/dist/Env;
+      description = "Perl module that imports environment variables as scalars or arrays";
+      license = "perl";
+    };
+  };
+
   EnvPath = buildPerlPackage {
     name = "Env-Path-0.19";
     src = fetchurl {
@@ -3545,6 +3950,45 @@ let self = _self // overrides; _self = with self; {
     };
   };
 
+  ExtUtilsCommand = buildPerlPackage {
+    name = "ExtUtils-Command-1.20";
+    src = fetchurl {
+      url = mirror://cpan/authors/id/B/BI/BINGOS/ExtUtils-Command-1.20.tar.gz;
+      sha256 = "740cccc93ba851aae803695b7a5b65ccbaa78bf4e96aa2e54f3f632c87a98c98";
+    };
+    meta = {
+      homepage = http://search.cpan.org/dist/ExtUtils-Command;
+      description = "Utilities to replace common UNIX commands in Makefiles etc";
+      license = "perl";
+    };
+  };
+
+  Expect = buildPerlPackage {
+    name = "Expect-1.32";
+    src = fetchurl {
+      url = mirror://cpan/authors/id/S/SZ/SZABGAB/Expect-1.32.tar.gz;
+      sha256 = "d1f96842a5c7dd8516b202b530d87a70b65e7054d3bf975c34f6a42084e54e25";
+    };
+    buildInputs = [ TestException ];
+    propagatedBuildInputs = [ IOTty ];
+    meta = {
+      description = "Automate interactions with command line programs that expose a text terminal interface";
+      license = "perl";
+    };
+  };
+
+  Exporter = buildPerlPackage {
+    name = "Exporter-5.72";
+    src = fetchurl {
+      url = mirror://cpan/authors/id/T/TO/TODDR/Exporter-5.72.tar.gz;
+      sha256 = "cd13b7a0e91e8505a0ce4b25f40fab2c92bb28a99ef0d03da1001d95a32f0291";
+    };
+    meta = {
+      description = "Implements default import method for modules";
+      license = "perl";
+    };
+  };
+
   ExtUtilsCBuilder = buildPerlPackage rec {
     name = "ExtUtils-CBuilder-0.280216";
     src = fetchurl {
@@ -3566,6 +4010,14 @@ let self = _self // overrides; _self = with self; {
     };
   };
 
+  ExtUtilsConstant = buildPerlPackage {
+    name = "ExtUtils-Constant-0.23";
+    src = fetchurl {
+      url = mirror://cpan/authors/id/N/NW/NWCLARK/ExtUtils-Constant-0.23.tar.gz;
+      sha256 = "23b77025c8a5d3b93c586d4f0e712bcca3ef934edbee00a78c3fad4285f48eab";
+    };
+  };
+
   ExtUtilsCppGuess = buildPerlModule rec {
     name = "ExtUtils-CppGuess-0.07";
     src = fetchurl {
@@ -3600,6 +4052,19 @@ let self = _self // overrides; _self = with self; {
     };
   };
 
+  ExtUtilsInstall = buildPerlPackage {
+    name = "ExtUtils-Install-2.04";
+    src = fetchurl {
+      url = mirror://cpan/authors/id/B/BI/BINGOS/ExtUtils-Install-2.04.tar.gz;
+      sha256 = "1b2e5370bc63d93cf99a75feb2b9b67227b693d16ebfb730ca90a483145de3b6";
+    };
+    meta = {
+      homepage = https://metacpan.org/release/ExtUtils-Install;
+      description = "Install files from here to there";
+      license = "perl";
+    };
+  };
+
   ExtUtilsInstallPaths = buildPerlPackage {
     name = "ExtUtils-InstallPaths-0.010";
     src = fetchurl {
@@ -3698,6 +4163,15 @@ let self = _self // overrides; _self = with self; {
     propagatedBuildInputs = [ ExtUtilsTypemap ExtUtilsParseXS ];
   };
 
+  ExtUtilsXSBuilder = buildPerlPackage {
+    name = "ExtUtils-XSBuilder-0.28";
+    src = fetchurl {
+      url = mirror://cpan/authors/id/G/GR/GRICHTER/ExtUtils-XSBuilder-0.28.tar.gz;
+      sha256 = "8cced386e3d544c5ec2deb3aed055b72ebcfc2ea9a6c807da87c4245272fe80a";
+    };
+    propagatedBuildInputs = [ ParseRecDescent TieIxHash ];
+  };
+
   ExtUtilsXSpp = buildPerlModule rec {
     name = "ExtUtils-XSpp-0.1700";
     src = fetchurl {
@@ -3782,6 +4256,20 @@ let self = _self // overrides; _self = with self; {
     };
   };
 
+  FileCheckTree = buildPerlPackage {
+    name = "File-CheckTree-4.42";
+    src = fetchurl {
+      url = mirror://cpan/authors/id/R/RJ/RJBS/File-CheckTree-4.42.tar.gz;
+      sha256 = "66fb417f8ff8a5e5b7ea25606156e70e204861c59fa8c3831925b4dd3f155f8a";
+    };
+    propagatedBuildInputs = [ if_ ];
+    meta = {
+      homepage = http://search.cpan.org/dist/File-CheckTree;
+      description = "Run many filetest checks on a tree";
+      license = "perl";
+    };
+  };
+
   FileCopyRecursive = buildPerlPackage rec {
     name = "File-Copy-Recursive-0.38";
     src = fetchurl {
@@ -3908,6 +4396,18 @@ let self = _self // overrides; _self = with self; {
     };
   };
 
+  FilePath = buildPerlPackage {
+    name = "File-Path-2.11";
+    src = fetchurl {
+      url = mirror://cpan/authors/id/R/RI/RICHE/File-Path-2.11.tar.gz;
+      sha256 = "d94492c072d08bdbbd40fd75a1010ff279e99333b63b4308b1f818fe6309dd0f";
+    };
+    meta = {
+      description = "Create or remove directory trees";
+      license = "perl";
+    };
+  };
+
   Filepushd = buildPerlPackage {
     name = "File-pushd-1.005";
     src = fetchurl {
@@ -4010,6 +4510,30 @@ let self = _self // overrides; _self = with self; {
     propagatedBuildInputs = [ TestScript ];
   };
 
+  Filter = buildPerlPackage {
+    name = "Filter-1.55";
+    src = fetchurl {
+      url = mirror://cpan/authors/id/R/RU/RURBAN/Filter-1.55.tar.gz;
+      sha256 = "7855f5f5f16777c14614b5d907794a170ed4cdeb4382bf03ffca825c8c6bc4a0";
+    };
+    meta = {
+      description = "Source Filters";
+      license = "perl";
+    };
+  };
+
+  FilterSimple = buildPerlPackage {
+    name = "Filter-Simple-0.91";
+    src = fetchurl {
+      url = mirror://cpan/authors/id/S/SM/SMUELLER/Filter-Simple-0.91.tar.gz;
+      sha256 = "c75a4945e94ecfe97e1409f49df036700d2e072e288497e205c4d319a80f694d";
+    };
+    meta = {
+      description = "Simplified source filtering";
+      license = "perl";
+    };
+  };
+
   FinanceQuote = buildPerlPackage rec {
     name = "Finance-Quote-1.37";
     src = fetchurl {
@@ -4147,11 +4671,26 @@ let self = _self // overrides; _self = with self; {
     };
   };
 
+  GitPurePerl = buildPerlPackage {
+    name = "Git-PurePerl-0.51";
+    src = fetchurl {
+      url = mirror://cpan/authors/id/B/BR/BROQ/Git-PurePerl-0.51.tar.gz;
+      sha256 = "3775f385ae566ea392ece0913a06ffec46441a1273c19ba9a6d990574ec34d00";
+    };
+    buildInputs = [ Testutf8 ];
+    propagatedBuildInputs = [ ConfigGitLike DataStreamBulk DateTime FileFindRule IODigest Moose MooseXStrictConstructor MooseXTypesPathClass namespaceautoclean ];
+    doCheck = false;
+    meta = {
+      description = "A Pure Perl interface to Git repositories";
+      license = "perl";
+    };
+  };
+
   Glib = buildPerlPackage rec {
-    name = "Glib-1.312";
+    name = "Glib-1.313";
     src = fetchurl {
       url = "mirror://cpan/authors/id/X/XA/XAOC/${name}.tar.gz";
-      sha256 = "1aqww3ncaxiclfiqvl81hx7k3w4pri3k52rrar0hpzcasics5zr3";
+      sha256 = "162g342bhzy2ca4xwk63j10q9jycsps0s8l8y8pda70m7zcmr7xj";
     };
     buildInputs = [ ExtUtilsDepends ExtUtilsPkgConfig pkgs.glib ];
     meta = {
@@ -4175,6 +4714,19 @@ let self = _self // overrides; _self = with self; {
     };
   };
 
+  GoferTransporthttp = buildPerlPackage {
+    name = "GoferTransport-http-1.017";
+    src = fetchurl {
+      url = mirror://cpan/authors/id/T/TI/TIMB/GoferTransport-http-1.017.tar.gz;
+      sha256 = "f73effe3ea7afa1907ce8977c87387abb0d4404f85a724ae2637b29a73154a9b";
+    };
+    propagatedBuildInputs = [ mod_perl2 DBI HTTPMessage LWP URI ];
+    doCheck = false; # no make target 'test'
+    meta = {
+      description = "HTTP transport for DBI stateless proxy driver DBD::Gofer";
+    };
+  };
+
   GoogleProtocolBuffers = buildPerlPackage rec {
     name = "Google-ProtocolBuffers-0.11";
     src = fetchurl {
@@ -4406,6 +4958,21 @@ let self = _self // overrides; _self = with self; {
     };
   };
 
+  HTMLMason = buildPerlPackage {
+    name = "HTML-Mason-1.56";
+    src = fetchurl {
+      url = mirror://cpan/authors/id/D/DR/DROLSKY/HTML-Mason-1.56.tar.gz;
+      sha256 = "84ac24fb1d551f998145435265e5b6fd4a52ec61e4fadd3d7755eb648be2c4b2";
+    };
+    buildInputs = [ TestDeep ];
+    propagatedBuildInputs = [ CacheCache ClassContainer ExceptionClass HTMLParser LogAny ParamsValidate ];
+    meta = {
+      homepage = http://metacpan.org/release/HTML-Mason;
+      description = "High-performance, dynamic web site authoring system";
+      license = "perl";
+    };
+  };
+
   HTMLParser = buildPerlPackage {
     name = "HTML-Parser-3.71";
     src = fetchurl {
@@ -4664,6 +5231,32 @@ let self = _self // overrides; _self = with self; {
     };
   };
 
+  HTTPServerSimpleMason = buildPerlPackage {
+    name = "HTTP-Server-Simple-Mason-0.14";
+    src = fetchurl {
+      url = mirror://cpan/authors/id/J/JE/JESSE/HTTP-Server-Simple-Mason-0.14.tar.gz;
+      sha256 = "b7a49d8e6e55bff0b1f0278d951685466b143243b6f9e59e071f5472ca2a025a";
+    };
+    propagatedBuildInputs = [ HTMLMason HTTPServerSimple HookLexWrap ];
+    meta = {
+      description = "A simple mason server";
+      license = "perl";
+    };
+  };
+
+  I18NCollate = buildPerlPackage {
+    name = "I18N-Collate-1.02";
+    src = fetchurl {
+      url = mirror://cpan/authors/id/F/FL/FLORA/I18N-Collate-1.02.tar.gz;
+      sha256 = "9174506bc903eda89690394e3f45558ab7e013114227896d8569d6164648fe37";
+    };
+    meta = {
+      homepage = http://search.cpan.org/dist/I18N-Collate;
+      description = "Compare 8-bit scalar data according to the current locale";
+      license = "perl";
+    };
+  };
+
   I18NLangTags = buildPerlPackage {
     name = "I18N-LangTags-0.35";
     src = fetchurl {
@@ -4717,6 +5310,19 @@ let self = _self // overrides; _self = with self; {
     };
   };
 
+  IO = buildPerlPackage {
+    name = "IO-1.25";
+    src = fetchurl {
+      url = mirror://cpan/authors/id/G/GB/GBARR/IO-1.25.tar.gz;
+      sha256 = "89790db8b9281235dc995c1a85d532042ff68a90e1504abd39d463f05623e7b5";
+    };
+    doCheck = false;
+    meta = {
+      description = "Perl core IO modules";
+      license = "perl";
+    };
+  };
+
   IOAll = buildPerlPackage {
     name = "IO-All-0.60";
     src = fetchurl {
@@ -4807,6 +5413,19 @@ let self = _self // overrides; _self = with self; {
     };
   };
 
+  IOPrompt = buildPerlPackage {
+    name = "IO-Prompt-0.997002";
+    src = fetchurl {
+      url = mirror://cpan/authors/id/D/DC/DCONWAY/IO-Prompt-0.997002.tar.gz;
+      sha256 = "08ad24f58335ce9696666e4411b2f3cd9c2e1fb72b306b6018c1a13971361ced";
+    };
+    propagatedBuildInputs = [ TermReadKey Want ];
+    doCheck = false; # needs access to /dev/tty
+    meta = {
+      description = "Interactively prompt for user input";
+    };
+  };
+
   IOSocketInet6 = buildPerlPackage rec {
     name = "IO-Socket-INET6-2.72";
     src = fetchurl {
@@ -4916,6 +5535,18 @@ let self = _self // overrides; _self = with self; {
     };
   };
 
+  IPCSysV = buildPerlPackage {
+    name = "IPC-SysV-2.04";
+    src = fetchurl {
+      url = mirror://cpan/authors/id/M/MH/MHX/IPC-SysV-2.04.tar.gz;
+      sha256 = "93248930e667034899bf2b09b9a23348e2b800a5437fbb9b4f34c37316da3fcc";
+    };
+    meta = {
+      description = "System V IPC constants and system calls";
+      license = "perl";
+    };
+  };
+
   ImageExifTool = buildPerlPackage rec {
     name = "Image-ExifTool-9.27";
 
@@ -5113,6 +5744,47 @@ let self = _self // overrides; _self = with self; {
     };
   };
 
+  lib_ = buildPerlPackage {
+    name = "lib-0.63";
+    src = fetchurl {
+      url = mirror://cpan/authors/id/S/SM/SMUELLER/lib-0.63.tar.gz;
+      sha256 = "72f63db9220098e834d7a38231626bd0c9b802c1ec54a628e2df35f3818e5a00";
+    };
+    meta = {
+      description = "Manipulate @INC at compile time";
+      license = "perl";
+    };
+  };
+
+  libapreq2 = buildPerlPackage {
+    name = "libapreq2-2.13";
+    src = fetchurl {
+      url = mirror://cpan/authors/id/I/IS/ISAAC/libapreq2-2.13.tar.gz;
+      sha256 = "5731e6833b32d88e4a5c690e45ddf20fcf969ce3da666c5627d775e92da0cf6e";
+    };
+    buildInputs = [ ApacheTest ExtUtilsXSBuilder mod_perl2 pkgs.apacheHttpd pkgs.apr pkgs.aprutil ];
+    propagatedBuildInputs = [ mod_perl2 ];
+    makeMakerFlags = "--with-apache2-src=${pkgs.apacheHttpd} --with-apache2-apxs=${pkgs.apacheHttpd}/bin/apxs --with-apache2-httpd=${pkgs.apacheHttpd}/bin/httpd --with-apr-config=${pkgs.apr}/bin/apr-1-config --with-apu-config=${pkgs.aprutil}/bin/apu-1-config";
+    preConfigure = ''
+      # override broken prereq check
+      substituteInPlace configure --replace "prereq_check=\"\$PERL \$PERL_OPTS build/version_check.pl\"" "prereq_check=\"echo\""
+      '';
+    preBuild = ''
+      substituteInPlace apreq2-config --replace "dirname" "${pkgs.coreutils}/bin/dirname"
+      '';
+    installPhase = ''
+      mkdir $out
+      make install DESTDIR=$out
+      cp -r $out/${pkgs.apacheHttpd}/. $out/.
+      cp -r $out/$out/. $out/.
+      rm -r $out/nix
+      '';
+    doCheck = false; # test would need to start apache httpd
+    meta = {
+      license = "open_source";
+    };
+  };
+
   libintlperl = pkgs.perlPackages.libintl_perl;
 
   libintl_perl = buildPerlPackage rec {
@@ -5127,6 +5799,18 @@ let self = _self // overrides; _self = with self; {
     };
   };
 
+  libnet = buildPerlPackage {
+    name = "libnet-3.07";
+    src = fetchurl {
+      url = mirror://cpan/authors/id/S/SH/SHAY/libnet-3.07.tar.gz;
+      sha256 = "d9a23d8907e681e788a6f1a71915b1d37d057091e88049e5a4064c99ca2c9cd7";
+    };
+    meta = {
+      description = "Collection of network protocol modules";
+      license = "perl";
+    };
+  };
+
   libxml_perl = buildPerlPackage rec {
     name = "libxml-perl-0.08";
     src = fetchurl {
@@ -5291,6 +5975,18 @@ let self = _self // overrides; _self = with self; {
     };
   };
 
+  LocaleCodes = buildPerlPackage {
+    name = "Locale-Codes-3.35";
+    src = fetchurl {
+      url = mirror://cpan/authors/id/S/SB/SBECK/Locale-Codes-3.35.tar.gz;
+      sha256 = "b1a2f944b03972d2b7282767cf88100e3c0d7daa3f4ca7aef8460c1c5e246480";
+    };
+    meta = {
+      description = "A distribution of modules to handle locale codes";
+      license = "perl";
+    };
+  };
+
   LocaleGettext = buildPerlPackage {
     name = "LocaleGettext-1.05";
     buildInputs = stdenv.lib.optional (stdenv.isDarwin || stdenv.isCygwin) pkgs.gettext;
@@ -5362,6 +6058,19 @@ let self = _self // overrides; _self = with self; {
     };
   };
 
+  LogAny = buildPerlPackage {
+    name = "Log-Any-1.032";
+    src = fetchurl {
+      url = mirror://cpan/authors/id/D/DA/DAGOLDEN/Log-Any-1.032.tar.gz;
+      sha256 = "808558fa42aa96365ed0af773973a5618b4ad50511d81fc7548f67133efdb956";
+    };
+    meta = {
+      homepage = https://github.com/dagolden/Log-Any;
+      description = "Bringing loggers and listeners together";
+      license = "perl";
+    };
+  };
+
   LogContextual = buildPerlPackage {
     name = "Log-Contextual-0.006003";
     src = fetchurl {
@@ -5479,6 +6188,22 @@ let self = _self // overrides; _self = with self; {
     };
   };
 
+  LWPProtocolconnect = pkgs.perlPackages.LWPProtocolConnect;
+
+  LWPProtocolConnect = buildPerlPackage {
+    name = "LWP-Protocol-connect-6.09";
+    src = fetchurl {
+      url = mirror://cpan/authors/id/B/BE/BENNING/LWP-Protocol-connect-6.09.tar.gz;
+      sha256 = "9f252394775e23aa42c3176611e5930638ab528d5190110b4731aa5b0bf35a15";
+    };
+    buildInputs = [ TestException ];
+    propagatedBuildInputs = [ HTTPMessage IOSocketSSL LWP LWPProtocolhttps URI ];
+    meta = {
+      description = "Provides HTTP/CONNECT proxy support for LWP::UserAgent";
+      license = "perl";
+    };
+  };
+
   LWPProtocolhttps = pkgs.perlPackages.LWPProtocolHttps;
 
   LWPProtocolHttps = buildPerlPackage rec {
@@ -5573,6 +6298,14 @@ let self = _self // overrides; _self = with self; {
     buildInputs = [ParseRecDescent];
   };
 
+  MailRFC822Address = buildPerlPackage {
+    name = "Mail-RFC822-Address-0.3";
+    src = fetchurl {
+      url = mirror://cpan/authors/id/P/PD/PDWARREN/Mail-RFC822-Address-0.3.tar.gz;
+      sha256 = "351ef4104ecb675ecae69008243fae8243d1a7e53c681eeb759e7b781684c8a7";
+    };
+  };
+
   MailTools = buildPerlPackage {
     name = "MailTools-2.13";
     src = fetchurl {
@@ -5610,6 +6343,17 @@ let self = _self // overrides; _self = with self; {
     NIX_CFLAGS_LINK = "-L${pkgs.gmp}/lib -lgmp";
   };
 
+  MathBigRat = buildPerlPackage {
+    name = "Math-BigRat-0.2606";
+    src = fetchurl {
+      url = mirror://cpan/authors/id/P/PJ/PJACKLAM/Math-BigRat-0.2606.tar.gz;
+      sha256 = "a69506468dd3067249e6ba9ce35eb9d5509471d939c1efae8283cbd038ca7e28";
+    };
+    meta = {
+      description = "Arbitrary big rational numbers";
+      license = "perl";
+    };
+  };
 
   MathClipper = buildPerlModule rec {
     name = "Math-Clipper-1.23";
@@ -5620,6 +6364,14 @@ let self = _self // overrides; _self = with self; {
     propagatedBuildInputs = [ ModuleBuildWithXSpp ExtUtilsXSpp ExtUtilsTypemapsDefault TestDeep ];
   };
 
+  MathComplex = buildPerlPackage {
+    name = "Math-Complex-1.59";
+    src = fetchurl {
+      url = mirror://cpan/authors/id/Z/ZE/ZEFRAM/Math-Complex-1.59.tar.gz;
+      sha256 = "f35eb4987512c51d2c47294a008ede210d8dd759b90b887d04847c69b42dd6d1";
+    };
+  };
+
   MathConvexHullMonotoneChain = buildPerlPackage rec {
     name = "Math-ConvexHull-MonotoneChain-0.01";
     src = fetchurl {
@@ -5701,6 +6453,14 @@ let self = _self // overrides; _self = with self; {
     };
   };
 
+  Memoize = buildPerlPackage {
+    name = "Memoize-1.03.tgz";
+    src = fetchurl {
+      url = mirror://cpan/authors/id/M/MJ/MJD/Memoize-1.03.tgz;
+      sha256 = "5239cc5f644a50b0de9ffeaa51fa9991eb06ecb1bf4678873e3ab89af9c0daf3";
+    };
+  };
+
   MetaBuilder = buildPerlModule {
     name = "Meta-Builder-0.003";
     src = fetchurl {
@@ -5833,6 +6593,19 @@ let self = _self // overrides; _self = with self; {
     };
   };
 
+  ModuleBuildDeprecated = buildPerlModule {
+    name = "Module-Build-Deprecated-0.4210";
+    src = fetchurl {
+      url = mirror://cpan/authors/id/L/LE/LEONT/Module-Build-Deprecated-0.4210.tar.gz;
+      sha256 = "be089313fc238ee2183473aca8c86b55fb3cf44797312cbe9b892d6362621703";
+    };
+    doCheck = false;
+    meta = {
+      description = "A collection of modules removed from Module-Build";
+      license = "perl";
+    };
+  };
+
   ModuleBuildTiny = buildPerlModule {
     name = "Module-Build-Tiny-0.039";
     src = fetchurl {
@@ -6068,6 +6841,19 @@ let self = _self // overrides; _self = with self; {
     };
   };
 
+  ModuleSignature = buildPerlPackage {
+    name = "Module-Signature-0.79";
+    src = fetchurl {
+      url = mirror://cpan/authors/id/A/AU/AUDREYT/Module-Signature-0.79.tar.gz;
+      sha256 = "22df2ce097fb5d176efa951c782633d8debe594924a25ca66666252512ce462c";
+    };
+    buildInputs = [ IPCRun ];
+    meta = {
+      description = "Module signature file manipulation";
+      license = "cc0";
+    };
+  };
+
   ModuleUtil = buildPerlPackage {
     name = "Module-Util-1.09";
     src = fetchurl {
@@ -6094,6 +6880,20 @@ let self = _self // overrides; _self = with self; {
     };
   };
 
+  mod_perl2 = buildPerlPackage {
+    name = "mod_perl-2.0.9";
+    src = fetchurl {
+      url = http://apache.mirror.iphh.net/perl/mod_perl-2.0.9.tar.gz;
+      sha256 = "0azmir4hbb825mfmcxwa1frhnhhf82rl8xf6mmgwkhbinxmg4q02";
+    };
+    makeMakerFlags = "MP_AP_DESTDIR=$out";
+    buildInputs = [ pkgs.apacheHttpd ];
+    doCheck = false; # would try to start Apache HTTP server
+    meta = {
+      description = "Embed a Perl interpreter in the Apache HTTP server";
+    };
+  };
+
   Mojolicious = buildPerlPackage {
     name = "Mojolicious-4.63";
     src = fetchurl {
@@ -6233,8 +7033,7 @@ let self = _self // overrides; _self = with self; {
       license = "perl";
     };
   };
-  
-    
+
   TestUseAllModules = buildPerlPackage {
     name = "Test-UseAllModules-0.17";
     src = fetchurl {
@@ -6246,7 +7045,7 @@ let self = _self // overrides; _self = with self; {
       license = "perl";
     };
   };
-  
+
   MouseXTypesPathClass = buildPerlPackage {
     name = "MouseX-Types-Path-Class-0.07";
     src = fetchurl {
@@ -6924,6 +7723,35 @@ let self = _self // overrides; _self = with self; {
     };
   };
 
+  NamespaceAutoclean = buildPerlPackage {
+    name = "namespace-autoclean-0.26";
+    src = fetchurl {
+      url = mirror://cpan/authors/id/E/ET/ETHER/namespace-autoclean-0.26.tar.gz;
+      sha256 = "c0f805acd3b565c611324b7bde20d32f6ffc31afefc5b8e52f54994802594d43";
+    };
+    buildInputs = [ ModuleBuildTiny TestRequires ];
+    propagatedBuildInputs = [ BHooksEndOfScope SubIdentify NamespaceClean ];
+    meta = {
+      homepage = https://github.com/moose/namespace-autoclean;
+      description = "Keep imports out of your namespace";
+      license = "perl";
+    };
+  };
+
+  NamespaceClean = buildPerlPackage {
+    name = "namespace-clean-0.25";
+    src = fetchurl {
+      url = mirror://cpan/authors/id/R/RI/RIBASUSHI/namespace-clean-0.25.tar.gz;
+      sha256 = "946a2b7b8219562818867ad915cd493637e2639f901db050b835500c8e6ecd04";
+    };
+    propagatedBuildInputs = [ BHooksEndOfScope PackageStash ];
+    meta = {
+      homepage = http://search.cpan.org/dist/namespace-clean;
+      description = "Keep imports and functions out of your namespace";
+      license = "perl";
+    };
+  };
+
   NetAddrIP = buildPerlPackage rec {
     name = "NetAddr-IP-4.075";
     src = fetchurl {
@@ -7130,6 +7958,17 @@ let self = _self // overrides; _self = with self; {
     };
   };
 
+  NetPing = buildPerlPackage {
+    name = "Net-Ping-2.41";
+    src = fetchurl {
+      url = mirror://cpan/authors/id/S/SM/SMPETERS/Net-Ping-2.41.tar.gz;
+      sha256 = "cbff21a8d323f235b70237c7ee56ffa5f22e87511e70608c027e2ec27fce47e0";
+    };
+    meta = {
+      description = "Check a remote host for reachability";
+    };
+  };
+
   NetRabbitFoot = buildPerlPackage {
     name = "Net-RabbitFoot-1.03";
     src = fetchurl {
@@ -7293,6 +8132,18 @@ let self = _self // overrides; _self = with self; {
     };
   };
 
+  Opcodes = buildPerlPackage {
+    name = "Opcodes-0.14";
+    src = fetchurl {
+      url = mirror://cpan/authors/id/R/RU/RURBAN/Opcodes-0.14.tar.gz;
+      sha256 = "7f7365447e4d1c5b87b43091448f0488e67c9f036b26c022a5409cd73d343893";
+    };
+    meta = {
+      description = "More Opcodes information from opnames.h and opcode.h";
+      license = "perl";
+    };
+  };
+
   OpenGL = buildPerlPackage rec {
     name = "OpenGL-0.6703";
     src = fetchurl {
@@ -7536,6 +8387,14 @@ let self = _self // overrides; _self = with self; {
     doCheck = false;
   };
 
+  PathTools = buildPerlPackage {
+    name = "PathTools-3.47";
+    src = fetchurl {
+      url = mirror://cpan/authors/id/S/SM/SMUELLER/PathTools-3.47.tar.gz;
+      sha256 = "caa8d4b45372b8cb0ef0f6f696efa3a60b0fd394b115cad39a7fbb8f6bd38026";
+    };
+  };
+
   Perl5lib = buildPerlPackage rec {
     name = "perl5lib-1.02";
     src = fetchurl {
@@ -7589,6 +8448,17 @@ let self = _self // overrides; _self = with self; {
     };
   };
 
+  PerlIOviaQuotedPrint = buildPerlPackage {
+    name = "PerlIO-via-QuotedPrint-0.08";
+    src = fetchurl {
+      url = mirror://cpan/authors/id/S/SH/SHAY/PerlIO-via-QuotedPrint-0.08.tar.gz;
+      sha256 = "9b999a54134816de5217f7a8cac69fa5d89ab32dc589fcd5c9e84902f608cb9c";
+    };
+    meta = {
+      description = "PerlIO Layer for quoted-printable encoding";
+    };
+  };
+
   PerlIOviasymlink = buildPerlPackage {
     name = "PerlIO-via-symlink-0.05";
     src = fetchurl {
@@ -7788,6 +8658,26 @@ let self = _self // overrides; _self = with self; {
     };
   };
 
+  ProcProcessTable = buildPerlPackage {
+    name = "Proc-ProcessTable-0.51";
+    src = fetchurl {
+      url = mirror://cpan/authors/id/J/JW/JWB/Proc-ProcessTable-0.51.tar.gz;
+      sha256 = "66636e102985a2a05ef4334b53a7893d627c192fac5dd7ff37dd1a0a50c0128d";
+    };
+    meta = {
+      description = "Perl extension to access the unix process table";
+      license = "perl";
+    };
+  };
+
+  ProcSafeExec = buildPerlPackage {
+    name = "Proc-SafeExec-1.5";
+    src = fetchurl {
+      url = mirror://cpan/authors/id/B/BI/BILBO/Proc-SafeExec-1.5.tar.gz;
+      sha256 = "1b4d0908bcac563d34a7e5be61c5da3eee98e4a6c7fa68c2670cc5844b5a2d78";
+    };
+  };
+
   ProcWaitStat = buildPerlPackage rec {
     name = "Proc-WaitStat-1.00";
     src = fetchurl {
@@ -7865,6 +8755,14 @@ let self = _self // overrides; _self = with self; {
     };
   };
 
+  PodChecker = buildPerlPackage {
+    name = "Pod-Checker-1.71";
+    src = fetchurl {
+      url = mirror://cpan/authors/id/M/MA/MAREKR/Pod-Checker-1.71.tar.gz;
+      sha256 = "4b90e745f4d6357bb7e8999e0e7d192216b98e3f3c8a86fa6ed446f8c36601df";
+    };
+  };
+
   PodCoverage = buildPerlPackage rec {
     name = "Pod-Coverage-0.23";
     src = fetchurl {
@@ -7940,6 +8838,44 @@ let self = _self // overrides; _self = with self; {
     };
   };
 
+  PodParser = buildPerlPackage {
+    name = "Pod-Parser-1.63";
+    src = fetchurl {
+      url = mirror://cpan/authors/id/M/MA/MAREKR/Pod-Parser-1.63.tar.gz;
+      sha256 = "dbe0b56129975b2f83a02841e8e0ed47be80f060686c66ea37e529d97aa70ccd";
+    };
+    meta = {
+      description = "Modules for parsing/translating POD format documents";
+      license = "unknown";
+    };
+  };
+
+  PodLaTeX = buildPerlModule {
+    name = "Pod-LaTeX-0.61";
+    src = fetchurl {
+      url = mirror://cpan/authors/id/T/TJ/TJENNESS/Pod-LaTeX-0.61.tar.gz;
+      sha256 = "15a840ea1c8a76cd3c865fbbf2fec33b03615c0daa50f9c800c54e0cf0659d46";
+    };
+    propagatedBuildInputs = [ if_ ];
+    meta = {
+      homepage = http://github.com/timj/perl-Pod-LaTeX/tree/master;
+      description = "Convert Pod data to formatted Latex";
+      license = "perl";
+    };
+  };
+
+  podlators = buildPerlPackage {
+    name = "podlators-2.5.3";
+    src = fetchurl {
+      url = mirror://cpan/authors/id/R/RR/RRA/podlators-2.5.3.tar.gz;
+      sha256 = "c80d6d65a8694720deff1c6b2067d7564727db713b6d6b536afbad70299647d1";
+    };
+    meta = {
+      description = "Convert POD data to various other formats";
+      license = "perl";
+    };
+  };
+
   podlinkcheck = buildPerlPackage {
     name = "podlinkcheck-12";
     src = fetchurl {
@@ -7954,6 +8890,30 @@ let self = _self // overrides; _self = with self; {
     };
   };
 
+  PodPerldoc = buildPerlPackage {
+    name = "Pod-Perldoc-3.25";
+    src = fetchurl {
+      url = mirror://cpan/authors/id/M/MA/MALLEN/Pod-Perldoc-3.25.tar.gz;
+      sha256 = "f1a4b3ac7aa244485456b0e8733c773bbb39ae35b01a59515f6cba6bbe293a84";
+    };
+    meta = {
+      description = "Look up Perl documentation in Pod format";
+      license = "perl";
+    };
+  };
+
+  PodPlainer = buildPerlPackage {
+    name = "Pod-Plainer-1.04";
+    src = fetchurl {
+      url = mirror://cpan/authors/id/R/RM/RMBARKER/Pod-Plainer-1.04.tar.gz;
+      sha256 = "1bbfbf7d1d4871e5a83bab2137e22d089078206815190eb1d5c1260a3499456f";
+    };
+    meta = {
+      description = "Perl extension for converting Pod to old-style Pod";
+      license = "perl";
+    };
+  };
+
   PodMarkdown = buildPerlPackage {
     name = "Pod-Markdown-2.000";
     src = fetchurl {
@@ -7985,6 +8945,18 @@ let self = _self // overrides; _self = with self; {
     };
   };
 
+  PodUsage = buildPerlPackage {
+    name = "Pod-Usage-1.67";
+    src = fetchurl {
+      url = mirror://cpan/authors/id/M/MA/MAREKR/Pod-Usage-1.67.tar.gz;
+      sha256 = "c8be6d29b0dfe304c4ddfcc140f93d4c4de7a8362ea6e2651611c288b53cc68a";
+    };
+    propagatedBuildInputs = [ perl ];
+    meta = {
+      description = "Pod::Usage extracts POD documentation and shows usage information";
+    };
+  };
+
   PodWeaver = buildPerlPackage {
     name = "Pod-Weaver-4.004";
     src = fetchurl {
@@ -8173,6 +9145,28 @@ let self = _self // overrides; _self = with self; {
     };
   };
 
+  RTClientREST = buildPerlPackage {
+    name = "RT-Client-REST-0.49";
+    src = fetchurl {
+      url = mirror://cpan/authors/id/D/DM/DMITRI/RT-Client-REST-0.49.tar.gz;
+      sha256 = "832c84b4f19e97781e8902f123a659fdcfef68e0ed9cfe09055852e9d68f7afc";
+    };
+    buildInputs = [ TestException ];
+    propagatedBuildInputs = [ DateTime DateTimeFormatDateParse Error ExceptionClass HTTPCookies HTTPMessage LWP ParamsValidate URI ];
+    meta = {
+      description = "Talk to RT installation using REST protocol";
+      license = "perl";
+    };
+  };
+
+  Safe = buildPerlPackage {
+    name = "Safe-2.35";
+    src = fetchurl {
+      url = mirror://cpan/authors/id/R/RG/RGARCIA/Safe-2.35.tar.gz;
+      sha256 = "e5d09756580287d7dc183ddaf26e4b2467e6f75b52ad73decdbe62d0750979b1";
+    };
+  };
+
   SafeIsa = buildPerlPackage {
     name = "Safe-Isa-1.000004";
     src = fetchurl {
@@ -8231,6 +9225,30 @@ let self = _self // overrides; _self = with self; {
     };
   };
 
+  SearchDict = buildPerlPackage {
+    name = "Search-Dict-1.07";
+    src = fetchurl {
+      url = mirror://cpan/authors/id/D/DA/DAGOLDEN/Search-Dict-1.07.tar.gz;
+      sha256 = "b128cdae4712fe53e83a219ca65478a84c1b128a2c6c86933e47923cf19c6554";
+    };
+    meta = {
+      description = "Look - search for key in dictionary file";
+      license = "perl";
+    };
+  };
+
+  SelfLoader = buildPerlPackage {
+    name = "SelfLoader-1.20";
+    src = fetchurl {
+      url = mirror://cpan/authors/id/S/SM/SMUELLER/SelfLoader-1.20.tar.gz;
+      sha256 = "79b1e2b8e4081854fba666441287c18b6bd822defb5bbee79067370edba1a042";
+    };
+    meta = {
+      description = "Load functions only on demand";
+      license = "perl";
+    };
+  };
+
   SetInfinite = buildPerlPackage {
     name = "Set-Infinite-0.65";
     src = fetchurl {
@@ -8286,6 +9304,18 @@ let self = _self // overrides; _self = with self; {
     };
   };
 
+  Socket = buildPerlPackage {
+    name = "Socket-2.020";
+    src = fetchurl {
+      url = mirror://cpan/authors/id/P/PE/PEVANS/Socket-2.020.tar.gz;
+      sha256 = "9ad4174c45b4c31d5e0b8019ada1fc767093849e77f268f0d1831eeb891dfdd7";
+    };
+    meta = {
+      description = "Networking constants and support functions";
+      license = "perl";
+    };
+  };
+
   Socket6 = buildPerlPackage rec {
     name = "Socket6-0.25";
     src = fetchurl {
@@ -8481,6 +9511,17 @@ let self = _self // overrides; _self = with self; {
     propagatedBuildInputs = [ StatisticsDescriptive StatisticsDistributions ];
   };
 
+  Storable = buildPerlPackage {
+    name = "Storable-2.51";
+    src = fetchurl {
+      url = mirror://cpan/authors/id/A/AM/AMS/Storable-2.51.tar.gz;
+      sha256 = "a566b792112bbba21131ec1d7a2bf78170c648484895283ae53c7f0c3dc2f0be";
+    };
+    meta = {
+      license = "unknown";
+    };
+  };
+
   StreamBuffered = buildPerlPackage {
     name = "Stream-Buffered-0.02";
     src = fetchurl {
@@ -8893,6 +9934,30 @@ let self = _self // overrides; _self = with self; {
     };
   };
 
+  SysSigAction = buildPerlPackage {
+    name = "Sys-SigAction-0.21";
+    src = fetchurl {
+      url = mirror://cpan/authors/id/L/LB/LBAXTER/Sys-SigAction-0.21.tar.gz;
+      sha256 = "e144207a6fd261eb9f98554c76bea66d95870ee1f62d2d346a1ea95fdccf80db";
+    };
+    meta = {
+      description = "Perl extension for Consistent Signal Handling";
+      license = "perl";
+    };
+  };
+
+  SysSyslog = buildPerlPackage {
+    name = "Sys-Syslog-0.33";
+    src = fetchurl {
+      url = mirror://cpan/authors/id/S/SA/SAPER/Sys-Syslog-0.33.tar.gz;
+      sha256 = "d5d901d9d9333a66db95fb1c7692ff457f7c7ad17287b51a87e40734f7c2741d";
+    };
+    meta = {
+      description = "Perl interface to the UNIX syslog(3) calls";
+      license = "perl";
+    };
+  };
+
   SysVirt = buildPerlPackage rec {
     name = "Sys-Virt-1.2.9";
     src = fetchurl {
@@ -8966,6 +10031,20 @@ let self = _self // overrides; _self = with self; {
     };
   };
 
+  TemplatePluginAutoformat = buildPerlPackage {
+    name = "Template-Plugin-Autoformat-2.77";
+    src = fetchurl {
+      url = mirror://cpan/authors/id/K/KA/KARMAN/Template-Plugin-Autoformat-2.77.tar.gz;
+      sha256 = "bddfb4919f0abb2a2be7a9665333e0d4e098032f0e383dbaf04c4d896c7486ed";
+    };
+    propagatedBuildInputs = [ TemplateToolkit TextAutoformat ];
+    meta = {
+      homepage = https://github.com/karpet/template-plugin-autoformat;
+      description = "TT plugin for Text::Autoformat";
+      license = "perl";
+    };
+  };
+
   TemplatePluginClass = buildPerlPackage {
     name = "Template-Plugin-Class-0.14";
     src = fetchurl {
@@ -9057,6 +10136,30 @@ let self = _self // overrides; _self = with self; {
     };
   };
 
+  TermANSIColor = buildPerlPackage {
+    name = "Term-ANSIColor-4.03";
+    src = fetchurl {
+      url = mirror://cpan/authors/id/R/RR/RRA/Term-ANSIColor-4.03.tar.gz;
+      sha256 = "e89b6992030fa713f928f653dcdb71d66fa2493f873bacf5653aa121ca862450";
+    };
+    meta = {
+      description = "Color output using ANSI escape sequences";
+      license = "perl";
+    };
+  };
+
+  TermCap = buildPerlPackage {
+    name = "Term-Cap-1.16";
+    src = fetchurl {
+      url = mirror://cpan/authors/id/J/JS/JSTOWE/Term-Cap-1.16.tar.gz;
+      sha256 = "b99728ac19b740b43e6a8d3c749c336f4a5d59ffd684c42c222681ee924e4a20";
+    };
+    meta = {
+      description = "Perl termcap interface";
+      license = "perl";
+    };
+  };
+
   TermEncoding = buildPerlPackage {
     name = "Term-Encoding-0.02";
     src = fetchurl {
@@ -9192,6 +10295,17 @@ let self = _self // overrides; _self = with self; {
     };
   };
 
+  Test = buildPerlPackage {
+    name = "Test-1.26";
+    src = fetchurl {
+      url = mirror://cpan/authors/id/J/JE/JESSE/Test-1.26.tar.gz;
+      sha256 = "f7701bd28e05e7f82fe9a181bbab38f53fa6aeae48d2a810da74d1b981d4f392";
+    };
+    meta = {
+      description = "Provides a simple framework for writing test scripts";
+    };
+  };
+
   TestAssert = buildPerlPackage {
     name = "Test-Assert-0.0504";
     src = fetchurl {
@@ -9427,6 +10541,30 @@ let self = _self // overrides; _self = with self; {
     };
   };
 
+  TestHarnessStraps = buildPerlModule {
+    name = "Test-Harness-Straps-0.30";
+    src = fetchurl {
+      url = mirror://cpan/authors/id/M/MS/MSCHWERN/Test-Harness-Straps-0.30.tar.gz;
+      sha256 = "8b00efaa35723c1a35c8c8f5fa46a99e4bc528dfa520352b54ac418ef6d1cfa8";
+    };
+    meta = {
+      description = "Detailed analysis of test results";
+      license = "perl";
+    };
+  };
+
+  TestHTTPServerSimple = buildPerlPackage {
+    name = "Test-HTTP-Server-Simple-0.11";
+    src = fetchurl {
+      url = mirror://cpan/authors/id/A/AL/ALEXMV/Test-HTTP-Server-Simple-0.11.tar.gz;
+      sha256 = "85c97ebd4deb805291b17277032da48807228f24f89b1ce2fb3c09f7a896bb78";
+    };
+    propagatedBuildInputs = [ HTTPServerSimple ];
+    meta = {
+      description = "Test::More functions for HTTP::Server::Simple";
+    };
+  };
+
   TestJSON = buildPerlPackage {
     name = "Test-JSON-0.11";
     src = fetchurl {
@@ -9913,6 +11051,19 @@ let self = _self // overrides; _self = with self; {
     };
   };
 
+  TextAbbrev = buildPerlPackage {
+    name = "Text-Abbrev-1.02";
+    src = fetchurl {
+      url = mirror://cpan/authors/id/F/FL/FLORA/Text-Abbrev-1.02.tar.gz;
+      sha256 = "9cfb8bea2d5806b72fa1a0e1a3367ce662262eaa2701c6a3143a2a8076917433";
+    };
+    meta = {
+      homepage = http://search.cpan.org/dist/Text-Abbrev;
+      description = "Abbrev - create an abbreviation table from a list";
+      license = "perl";
+    };
+  };
+
   TextAligner = buildPerlPackage {
     name = "Text-Aligner-0.10";
     src = fetchurl {
@@ -9924,6 +11075,32 @@ let self = _self // overrides; _self = with self; {
     };
   };
 
+  TextAutoformat = buildPerlPackage {
+    name = "Text-Autoformat-1.72";
+    src = fetchurl {
+      url = mirror://cpan/authors/id/N/NE/NEILB/Text-Autoformat-1.72.tar.gz;
+      sha256 = "b541152699fcd0f026322f283b7d9184839742aee0edb317a014c195ea26ae51";
+    };
+    propagatedBuildInputs = [ TextReform ];
+    meta = {
+      homepage = https://github.com/neilbowers/Text-Autoformat;
+      description = "Automatic text wrapping and reformatting";
+      license = "perl";
+    };
+  };
+
+  TextBalanced = buildPerlPackage {
+    name = "Text-Balanced-2.03";
+    src = fetchurl {
+      url = mirror://cpan/authors/id/S/SH/SHAY/Text-Balanced-2.03.tar.gz;
+      sha256 = "057753f8f0568b53921f66a60a89c30092b73329bcc61a2c43339ab70c9792c8";
+    };
+    meta = {
+      description = "Extract delimited text sequences from strings";
+      license = "perl";
+    };
+  };
+
   TextBibTeX = buildPerlModule {
     name = "Text-BibTeX-0.69";
     buildInputs = [ ConfigAutoConf ExtUtilsLibBuilder ];
@@ -9945,6 +11122,19 @@ let self = _self // overrides; _self = with self; {
     };
   };
 
+  TextCSV_XS = buildPerlPackage {
+    name = "Text-CSV_XS-1.19.tgz";
+    src = fetchurl {
+      url = mirror://cpan/authors/id/H/HM/HMBRAND/Text-CSV_XS-1.19.tgz;
+      sha256 = "bcde887f613c6a50b0ce8f714cd2463570f5809f26581615690cfb424d2a7c16";
+    };
+    meta = {
+      homepage = https://metacpan.org/pod/Text::CSV_XS;
+      description = "Comma-Separated Values manipulation routines";
+      license = "perl";
+    };
+  };
+
   TextDiff = buildPerlPackage {
     name = "Text-Diff-1.41";
     src = fetchurl {
@@ -9966,6 +11156,14 @@ let self = _self // overrides; _self = with self; {
     };
   };
 
+  TextIconv = buildPerlPackage {
+    name = "Text-Iconv-1.7";
+    src = fetchurl {
+      url = mirror://cpan/authors/id/M/MP/MPIOTR/Text-Iconv-1.7.tar.gz;
+      sha256 = "5b80b7d5e709d34393bcba88971864a17b44a5bf0f9e4bcee383d029e7d2d5c3";
+    };
+  };
+
   TestInter = buildPerlPackage {
     name = "Test-Inter-1.05";
     src = fetchurl {
@@ -10055,6 +11253,18 @@ let self = _self // overrides; _self = with self; {
                               TestPod TestPodCoverage GraphViz ReadonlyXS TextTabularDisplay];
   };
 
+  TextReform = buildPerlPackage {
+    name = "Text-Reform-1.20";
+    src = fetchurl {
+      url = mirror://cpan/authors/id/C/CH/CHORNY/Text-Reform-1.20.tar.gz;
+      sha256 = "a8792dd8c1aac97001032337b36a356be96e2d74c4f039ef9a363b641db4ae61";
+    };
+    meta = {
+      description = "Manual text wrapping and reformatting";
+      license = "perl";
+    };
+  };
+
   TextSimpleTable = buildPerlPackage {
     name = "Text-SimpleTable-2.03";
     src = fetchurl {
@@ -10067,6 +11277,15 @@ let self = _self // overrides; _self = with self; {
     };
   };
 
+  TextSoundex = buildPerlPackage {
+    name = "Text-Soundex-3.04";
+    src = fetchurl {
+      url = mirror://cpan/authors/id/R/RJ/RJBS/Text-Soundex-3.04.tar.gz;
+      sha256 = "2e56bb4324ee0186b908b3bd78463643affe7295624af0628e81491e910283d9";
+    };
+    propagatedBuildInputs = [ if_ ];
+  };
+
   TextTable = buildPerlPackage {
     name = "Text-Table-1.129";
     src = fetchurl {
@@ -10083,6 +11302,17 @@ let self = _self // overrides; _self = with self; {
     };
   };
 
+  TextTabsWrap = buildPerlPackage {
+    name = "Text-Tabs+Wrap-2013.0523";
+    src = fetchurl {
+      url = mirror://cpan/authors/id/M/MU/MUIR/modules/Text-Tabs+Wrap-2013.0523.tar.gz;
+      sha256 = "b9cb056fffb737b9c12862099b952bf4ab4b1f599fd34935356ae57dab6f655f";
+    };
+    meta = {
+      description = "Expand tabs and do simple line wrapping";
+    };
+  };
+
   TextTabularDisplay = buildPerlPackage rec {
     name = "Text-TabularDisplay-1.35";
     src = fetchurl {
@@ -10218,6 +11448,43 @@ let self = _self // overrides; _self = with self; {
     };
   };
 
+  threadsshared = buildPerlPackage {
+    name = "threads-shared-1.48";
+    src = fetchurl {
+      url = mirror://cpan/authors/id/J/JD/JDHEDDEN/threads-shared-1.48.tar.gz;
+      sha256 = "7378a72bae424705e354476da69995fb8f62432bca8e98eab0fb9842da5120f8";
+    };
+    meta = {
+      description = "Perl extension for sharing data structures between threads";
+      license = "perl";
+    };
+  };
+
+  ThreadQueue = buildPerlPackage {
+    name = "Thread-Queue-3.05";
+    src = fetchurl {
+      url = mirror://cpan/authors/id/J/JD/JDHEDDEN/Thread-Queue-3.05.tar.gz;
+      sha256 = "36bc1e50b5de47ff827fbaa1d7f028016e3ef115972cac84ed8cd73a0ef95300";
+    };
+    meta = {
+      description = "Thread-safe queues";
+      license = "perl";
+    };
+  };
+
+  ThreadSemaphore = buildPerlPackage {
+    name = "Thread-Semaphore-2.12";
+    src = fetchurl {
+      url = mirror://cpan/authors/id/J/JD/JDHEDDEN/Thread-Semaphore-2.12.tar.gz;
+      sha256 = "e0f8e7057b073003e5a96a55b778abb8ee1cc1b279febedce0166526f2988965";
+    };
+    meta = {
+      description = "Thread-safe semaphores";
+      license = "perl";
+    };
+  };
+
+
   Throwable = buildPerlPackage rec {
     name = "Throwable-0.200010";
     src = fetchurl {
@@ -10239,6 +11506,17 @@ let self = _self // overrides; _self = with self; {
     };
   };
 
+  TieFile = buildPerlPackage {
+    name = "Tie-File-1.00";
+    src = fetchurl {
+      url = mirror://cpan/authors/id/T/TO/TODDR/Tie-File-1.00.tar.gz;
+      sha256 = "7ca9c8a957cf743d3a98d0eb5deb767b1e14b4f00bc9d03da83d466fcb76bd44";
+    };
+    meta = {
+      description = "Access the lines of a disk file via a Perl array";
+    };
+  };
+
   TieIxHash = buildPerlPackage {
     name = "Tie-IxHash-1.23";
     src = fetchurl {
@@ -10263,6 +11541,14 @@ let self = _self // overrides; _self = with self; {
     };
   };
 
+  TieRefHash = buildPerlPackage {
+    name = "Tie-RefHash-1.39";
+    src = fetchurl {
+      url = mirror://cpan/authors/id/F/FL/FLORA/Tie-RefHash-1.39.tar.gz;
+      sha256 = "b0b80ef571e7dadb726b8214f7352a932a8fa82af29072895aa1aadc89f48bec";
+    };
+  };
+
   TieToObject = buildPerlPackage {
     name = "Tie-ToObject-0.03";
     src = fetchurl {
@@ -10315,6 +11601,18 @@ let self = _self // overrides; _self = with self; {
     };
   };
 
+  TimeLocal = buildPerlPackage {
+    name = "Time-Local-1.2300";
+    src = fetchurl {
+      url = mirror://cpan/authors/id/D/DR/DROLSKY/Time-Local-1.2300.tar.gz;
+      sha256 = "b2acca03700a09f8ae737d3084f3f6287e983da9ab7b537c6599c291b669fb49";
+    };
+    meta = {
+      description = "Efficiently compute time from local and GMT time";
+      license = "perl";
+    };
+  };
+
   Tk = buildPerlPackage rec {
     name = "Tk-804.032_501";
     src = fetchurl {
@@ -10487,6 +11785,18 @@ let self = _self // overrides; _self = with self; {
     };
   };
 
+  UnicodeNormalize = buildPerlPackage {
+    name = "Unicode-Normalize-1.19";
+    src = fetchurl {
+      url = mirror://cpan/authors/id/S/SA/SADAHIRO/Unicode-Normalize-1.19.tar.gz;
+      sha256 = "ab16467692cb78ced706fb7bee4145ac09d9f14d9eed92be4a305de3172ce6c4";
+    };
+    meta = {
+      description = "Unicode Normalization Forms";
+      license = "perl";
+    };
+  };
+
   UnixGetrusage = buildPerlPackage {
     name = "Unix-Getrusage-0.03";
     src = fetchurl {
@@ -10682,6 +11992,29 @@ let self = _self // overrides; _self = with self; {
     };
   };
 
+  Want = buildPerlPackage {
+    name = "Want-0.26";
+    src = fetchurl {
+      url = mirror://cpan/authors/id/R/RO/ROBIN/Want-0.26.tar.gz;
+      sha256 = "4951675e13de2b0b9792be2827b8ef46ef25a0b9a2d3e9132143444dac28e17c";
+    };
+  };
+
+  Workflow = buildPerlPackage {
+    name = "Workflow-1.41";
+    src = fetchurl {
+      url = mirror://cpan/authors/id/J/JO/JONASBN/Workflow-1.41.tar.gz;
+      sha256 = "639fd428ddf186fdc7cad517cb7522b2bf092df26ef48470b2e8f747c4e8286e";
+    };
+    buildInputs = [ DBDMock ListMoreUtils TestException ];
+    propagatedBuildInputs = [ ClassAccessor ClassFactory ClassObservable DBI DateTime DateTimeFormatStrptime ExceptionClass FileSlurp LogDispatch Log4Perl XMLSimple ];
+    meta = {
+      homepage = https://github.com/jonasbn/perl-workflow;
+      description = "Simple, flexible system to implement workflows";
+      license = "perl";
+    };
+  };
+
   Wx = buildPerlPackage rec {
     name = "Wx-0.9923";
     src = fetchurl {
@@ -10784,6 +12117,24 @@ let self = _self // overrides; _self = with self; {
     propagatedBuildInputs = [XMLRegExp XMLParser LWP libxml_perl];
   };
 
+  XMLFilterBufferText = buildPerlPackage {
+    name = "XML-Filter-BufferText-1.01";
+    src = fetchurl {
+      url = mirror://cpan/authors/id/R/RB/RBERJON/XML-Filter-BufferText-1.01.tar.gz;
+      sha256 = "8fd2126d3beec554df852919f4739e689202cbba6a17506e9b66ea165841a75c";
+    };
+    doCheck = false;
+  };
+
+  XMLFilterXInclude = buildPerlPackage {
+    name = "XML-Filter-XInclude-1.0";
+    src = fetchurl {
+      url = mirror://cpan/authors/id/M/MS/MSERGEANT/XML-Filter-XInclude-1.0.tar.gz;
+      sha256 = "98746f3c1f6f049491fec203d455bb8f8c9c6e250f041904dda5d78e21187f93";
+    };
+    doCheck = false;
+  };
+
   XMLLibXML = buildPerlPackage rec {
     name = "XML-LibXML-2.0121";
     src = fetchurl {
@@ -10875,6 +12226,36 @@ let self = _self // overrides; _self = with self; {
       sha256 = "024fbjgg6s87j0y3yik55plzf7d6qpn7slwd03glcb54mw9zdglv";
     };
     propagatedBuildInputs = [XMLNamespaceSupport];
+    postInstall = ''
+      perl -MXML::SAX -e "XML::SAX->add_parser(q(XML::SAX::PurePerl))->save_parsers()"
+      '';
+  };
+
+  XMLSAXBase = buildPerlPackage {
+    name = "XML-SAX-Base-1.08";
+    src = fetchurl {
+      url = mirror://cpan/authors/id/G/GR/GRANTM/XML-SAX-Base-1.08.tar.gz;
+      sha256 = "666270318b15f88b8427e585198abbc19bc2e6ccb36dc4c0a4f2d9807330219e";
+    };
+    meta = {
+      description = "Base class for SAX Drivers and Filters";
+      homepage = http://github.com/grantm/XML-SAX-Base;
+      license = "perl";
+    };
+  };
+
+  XMLSAXWriter = buildPerlPackage {
+    name = "XML-SAX-Writer-0.56";
+    src = fetchurl {
+      url = mirror://cpan/authors/id/P/PE/PERIGRIN/XML-SAX-Writer-0.56.tar.gz;
+      sha256 = "d073f7a25072c8150317b86b99d07031316a15bffab99e63e5afe591c8217d03";
+    };
+    propagatedBuildInputs = [ XMLFilterBufferText XMLNamespaceSupport XMLSAXBase ];
+    meta = {
+      homepage = https://github.com/perigrin/xml-sax-writer;
+      description = "SAX2 XML Writer";
+      license = "perl";
+    };
   };
 
   XMLSemanticDiff = buildPerlPackage {
@@ -10922,6 +12303,18 @@ let self = _self // overrides; _self = with self; {
     doCheck = false;  # requires lots of extra packages
   };
 
+  XMLValidatorSchema = buildPerlPackage {
+    name = "XML-Validator-Schema-1.10";
+    src = fetchurl {
+      url = mirror://cpan/authors/id/S/SA/SAMTREGAR/XML-Validator-Schema-1.10.tar.gz;
+      sha256 = "6142679580150a891f7d32232b5e31e2b4e5e53e8a6fa9cbeecb5c23814f1422";
+    };
+    propagatedBuildInputs = [ TreeDAGNode XMLFilterBufferText XMLSAX ];
+    meta = {
+      description = "Validate XML against a subset of W3C XML Schema";
+    };
+  };
+
   XMLWriter = buildPerlPackage rec {
     name = "XML-Writer-0.625";
     src = fetchurl {
@@ -10930,6 +12323,19 @@ let self = _self // overrides; _self = with self; {
     };
   };
 
+  XSLoader = buildPerlPackage {
+    name = "XSLoader-0.16";
+    src = fetchurl {
+      url = mirror://cpan/authors/id/S/SA/SAPER/XSLoader-0.16.tar.gz;
+      sha256 = "96de61bad187919bf632cfa657f1b9957ad47defcc90dad8ee1f50c955eedb86";
+    };
+    meta = {
+      homepage = https://metacpan.org/module/Math::BigInt;
+      description = "Dynamically load C libraries into Perl code";
+      license = "perl";
+    };
+  };
+
   XSObjectMagic = buildPerlPackage rec {
     name = "XS-Object-Magic-0.04";
     src = fetchurl {
diff --git a/pkgs/top-level/python-packages.nix b/pkgs/top-level/python-packages.nix
index 818bdba09e5..3485503eddc 100644
--- a/pkgs/top-level/python-packages.nix
+++ b/pkgs/top-level/python-packages.nix
@@ -8038,11 +8038,11 @@ let
 
   pymysql = buildPythonPackage rec {
     name = "pymysql-${version}";
-    version = "0.6.3";
+    version = "0.6.6";
     src = pkgs.fetchgit {
       url = https://github.com/PyMySQL/PyMySQL.git;
       rev = "refs/tags/pymysql-${version}";
-      sha256 = "1m9fr2x49s3aixlmccr3w80skl19dya9h3x69wgl6ly1z27iyg24";
+      sha256 = "12v8bw7pp455zqkwraxk69qycz2ngk18bbz60v72kdbp6kssnqhz";
     };
   };
 
@@ -8316,6 +8316,57 @@ let
     };
   });
 
+  nibabel = buildPythonPackage rec {
+    version = "2.0.1";
+    name = "nibabel-${version}";
+
+    src = pkgs.fetchurl {
+      url = "http://pypi.python.org/packages/source/n/nibabel/${name}.tar.gz";
+      md5 = "3be518fde5ec5b09483d4f28c81dc974";
+    };
+
+    propagatedBuildInputs = with self; [
+      numpy
+      nose
+      modules.sqlite3
+    ];
+
+    meta = {
+      homepage = http://nipy.org/nibabel/;
+      description = "Access a multitude of neuroimaging data formats";
+      license = "BSD";
+    };
+  };
+
+  nipype = buildPythonPackage rec {
+    version = "0.10.0";
+    name = "nipype-${version}";
+
+    src = pkgs.fetchurl {
+      url = "http://pypi.python.org/packages/source/n/nipype/${name}.tar.gz";
+      md5 = "480013709633a6d292e2ef668443e0c9";
+    };
+
+    # Tests fail due to getcwd returning ENOENT???
+    doCheck = false;
+
+    propagatedBuildInputs = with self; [
+     numpy
+     dateutil
+     nose
+     traits
+     scipy
+     nibabel
+     networkx
+   ];
+
+    meta = {
+      homepage = http://nipy.org/nipype/;
+      description = "Neuroimaging in Python: Pipelines and Interfaces";
+      license = "BSD";
+    };
+  };
+
   nose = buildPythonPackage rec {
     version = "1.3.4";
     name = "nose-${version}";
@@ -11496,6 +11547,26 @@ let
     };
   };
 
+  rencode = buildPythonPackage rec {
+    name = "rencode-${version}";
+    version = "git20150810";
+    disabled = isPy33;
+
+    src = pkgs.fetchgit {
+      url = https://github.com/aresch/rencode;
+      rev = "b45e04abdca0dea36e383a8199783269f186c99e";
+      sha256 = "b4bd82852d4220e8a9493d3cfaecbc57b1325708a2d48c0f8acf262edb10dc40";
+    };
+
+    buildInputs = with self; [ cython ];
+
+    meta = {
+      homepage = https://github.com/aresch/rencode;
+      description = "Fast (basic) object serialization similar to bencode";
+      license = licenses.gpl3;
+    };
+  };
+
 
   reportlab =
    let freetype = overrideDerivation pkgs.freetype (args: { configureFlags = "--enable-static --enable-shared"; });
@@ -13720,6 +13791,24 @@ let
     };
   };
 
+  traits = buildPythonPackage rec {
+    name = "traits-${version}";
+    version = "4.5.0";
+
+    src = pkgs.fetchurl {
+      url = "http://pypi.python.org/packages/source/t/traits/${name}.tar.gz";
+      md5 = "3ad558eebaedc63c29c80183c0371d2f";
+    };
+
+    propagatedBuildInputs = with self; [ numpy ];
+
+    meta = {
+      description = "explicitly typed attributes for Python";
+      homepage = http://pypi.python.org/pypi/traits;
+      license = "BSD";
+    };
+  };
+
 
   transaction = buildPythonPackage rec {
     name = "transaction-${version}";