Merge #10816: improve FreeBSD support

2025-04-16 08:38:19 +00:00 · 2016-01-05 09:50:10 +01:00 · 2016-01-05 09:50:10 +01:00 · 7c879d342d
commit 7c879d342d
parent 1ebff73b88 aa4562596f
343 changed files with 22927 additions and 11695 deletions
--- a/lib/maintainers.nix
+++ b/lib/maintainers.nix
@ -99,6 +99,7 @@
  ericsagnes = "Eric Sagnes <eric.sagnes@gmail.com>";
  erikryb = "Erik Rybakken <erik.rybakken@math.ntnu.no>";
  ertes = "Ertugrul Söylemez <ertesx@gmx.de>";
+  exi = "Reno Reckling <nixos@reckling.org>";
  exlevan = "Alexey Levan <exlevan@gmail.com>";
  falsifian = "James Cook <james.cook@utoronto.ca>";
  flosse = "Markus Kohlhase <mail@markus-kohlhase.de>";
@ -142,7 +143,7 @@
  jcumming = "Jack Cummings <jack@mudshark.org>";
  jefdaj = "Jeffrey David Johnson <jefdaj@gmail.com>";
  jfb = "James Felix Black <james@yamtime.com>";
-  jgeerds = "Jascha Geerds <jg@ekby.de>";
+  jgeerds = "Jascha Geerds <jascha@jgeerds.name>";
  jgillich = "Jakob Gillich <jakob@gillich.me>";
  jirkamarsik = "Jirka Marsik <jiri.marsik89@gmail.com>";
  joachifm = "Joachim Fasting <joachifm@fastmail.fm>";
@ -233,6 +234,7 @@
  phausmann = "Philipp Hausmann <nix@314.ch>";
  philandstuff = "Philip Potter <philip.g.potter@gmail.com>";
  phreedom = "Evgeny Egorochkin <phreedom@yandex.ru>";
+  phunehehe = "Hoang Xuan Phu <phunehehe@gmail.com>";
  pierron = "Nicolas B. Pierron <nixos@nbp.name>";
  piotr = "Piotr Pietraszkiewicz <ppietrasa@gmail.com>";
  pjbarnoy = "Perry Barnoy <pjbarnoy@gmail.com>";
--- a/nixos/doc/manual/installation/installing.xml
+++ b/nixos/doc/manual/installation/installing.xml
@ -35,7 +35,7 @@
  <command>systemctl stop network-manager</command>.</para></listitem>

  <listitem><para>The NixOS installer doesn’t do any partitioning or
-  formatting yet, so you need to that yourself.  Use the following
+  formatting yet, so you need to do that yourself.  Use the following
  commands:

  <itemizedlist>
--- a/nixos/doc/manual/release-notes/rl-unstable.xml
+++ b/nixos/doc/manual/release-notes/rl-unstable.xml
@ -30,6 +30,7 @@ nixos.path = ./nixpkgs-unstable-2015-12-06/nixos;

  <itemizedlist>
    <listitem><para><literal>services/monitoring/longview.nix</literal></para></listitem>
+    <listitem><para><literal>services/web-apps/pump.io.nix</literal></para></listitem>
  </itemizedlist>
 </para>

--- a/nixos/lib/test-driver/Machine.pm
+++ b/nixos/lib/test-driver/Machine.pm
@ -381,6 +381,11 @@ sub waitForUnit {
            my $info = $self->getUnitInfo($unit);
            my $state = $info->{ActiveState};
            die "unit ‘$unit’ reached state ‘$state’\n" if $state eq "failed";
+            if ($state eq "inactive") {
+                my ($status, $jobs) = $self->execute("systemctl list-jobs --full 2>&1");
+                die "unit ‘$unit’ is inactive and there are no pending jobs\n"
+                    if $jobs =~ /No jobs/; # FIXME: fragile
+            }
            return 1 if $state eq "active";
        };
    });
--- a/nixos/modules/config/sysctl.nix
+++ b/nixos/modules/config/sysctl.nix
@ -22,10 +22,9 @@ in

    boot.kernel.sysctl = mkOption {
      default = {};
-      example = {
-        "net.ipv4.tcp_syncookies" = false;
-        "vm.swappiness" = 60;
-      };
+      example = literalExample ''
+        { "net.ipv4.tcp_syncookies" = false; "vm.swappiness" = 60; }
+      '';
      type = types.attrsOf sysctlOption;
      description = ''
        Runtime parameters of the Linux kernel, as set by
--- a/nixos/modules/installer/cd-dvd/iso-image.nix
+++ b/nixos/modules/installer/cd-dvd/iso-image.nix
@ -43,6 +43,13 @@ let
    LINUX /boot/bzImage
    APPEND init=${config.system.build.toplevel}/init ${toString config.boot.kernelParams}
    INITRD /boot/initrd
+
+    # A variant to boot with 'nomodeset'
+    LABEL boot-nomodeset
+    MENU LABEL NixOS ${config.system.nixosVersion}${config.isoImage.appendToMenuLabel} (with nomodeset)
+    LINUX /boot/bzImage
+    APPEND init=${config.system.build.toplevel}/init ${toString config.boot.kernelParams} nomodeset
+    INITRD /boot/initrd
  '';

  isolinuxMemtest86Entry = ''
@ -59,10 +66,18 @@ let
    mkdir -p $out/EFI/boot
    cp -v ${pkgs.gummiboot}/lib/gummiboot/gummiboot${targetArch}.efi $out/EFI/boot/boot${targetArch}.efi
    mkdir -p $out/loader/entries
+
    echo "title NixOS Live CD" > $out/loader/entries/nixos-livecd.conf
    echo "linux /boot/bzImage" >> $out/loader/entries/nixos-livecd.conf
    echo "initrd /boot/initrd" >> $out/loader/entries/nixos-livecd.conf
    echo "options init=${config.system.build.toplevel}/init ${toString config.boot.kernelParams}" >> $out/loader/entries/nixos-livecd.conf
+
+    # A variant to boot with 'nomodeset'
+    echo "title NixOS Live CD (with nomodeset)" > $out/loader/entries/nixos-livecd-nomodeset.conf
+    echo "linux /boot/bzImage" >> $out/loader/entries/nixos-livecd-nomodeset.conf
+    echo "initrd /boot/initrd" >> $out/loader/entries/nixos-livecd-nomodeset.conf
+    echo "options init=${config.system.build.toplevel}/init ${toString config.boot.kernelParams} nomodeset" >> $out/loader/entries/nixos-livecd-nomodeset.conf
+
    echo "default nixos-livecd" > $out/loader/loader.conf
    echo "timeout ${builtins.toString config.boot.loader.gummiboot.timeout}" >> $out/loader/loader.conf
  '';
@ -230,7 +245,6 @@ in
    boot.kernelParams =
      [ "root=LABEL=${config.isoImage.volumeID}"
        "boot.shell_on_fail"
-        "nomodeset"
      ];

    fileSystems."/" =
--- a/nixos/modules/misc/ids.nix
+++ b/nixos/modules/misc/ids.nix
@ -238,6 +238,7 @@
      heapster = 214;
      bepasty = 215;
      pumpio = 216;
+      nm-openvpn = 217;

      # When adding a uid, make sure it doesn't match an existing gid. And don't use uids above 399!

@ -453,6 +454,7 @@
      calibre-server = 213;
      bepasty = 215;
      pumpio = 216;
+      nm-openvpn = 217;

      # When adding a gid, make sure it doesn't match an existing
      # uid. Users and groups with the same name should have equal
--- a/nixos/modules/misc/nixos.xml
+++ b/nixos/modules/misc/nixos.xml
@ -35,7 +35,7 @@ nixos.path = ./nixpkgs-16-03/nixos;

 <para>Another option is to fetch a specific version of NixOS, with either
 the <literal>fetchTarball</literal> builtin, or the
-<literal>pkgs.fetchFromGithub</literal> function and use the result as an
+<literal>pkgs.fetchFromGitHub</literal> function and use the result as an
 input.

 <programlisting>
--- a/nixos/modules/module-list.nix
+++ b/nixos/modules/module-list.nix
@ -441,6 +441,7 @@
  ./services/x11/window-managers/metacity.nix
  ./services/x11/window-managers/none.nix
  ./services/x11/window-managers/twm.nix
+  ./services/x11/window-managers/windowlab.nix
  ./services/x11/window-managers/wmii.nix
  ./services/x11/window-managers/xmonad.nix
  ./services/x11/xfs.nix
--- a/nixos/modules/rename.nix
+++ b/nixos/modules/rename.nix
@ -75,6 +75,8 @@ with lib;
    # DNSCrypt-proxy
    (mkRenamedOptionModule [ "services" "dnscrypt-proxy" "port" ] [ "services" "dnscrypt-proxy" "localPort" ])

+    (mkRenamedOptionModule [ "services" "hostapd" "extraCfg" ] [ "services" "hostapd" "extraConfig" ])
+
    # Options that are obsolete and have no replacement.
    (mkRemovedOptionModule [ "boot" "initrd" "luks" "enable" ])
    (mkRemovedOptionModule [ "programs" "bash" "enable" ])
--- a/nixos/modules/services/computing/slurm/slurm.nix
+++ b/nixos/modules/services/computing/slurm/slurm.nix
@ -34,6 +34,15 @@ in

      };

+      package = mkOption {
+        type = types.package;
+        default = pkgs.slurm-llnl;
+        example = literalExample "pkgs.slurm-llnl-full";
+        description = ''
+          The packge to use for slurm binaries.
+        '';
+      };
+
      controlMachine = mkOption {
        type = types.nullOr types.str;
        default = null;
@ -91,38 +100,69 @@ in

  ###### implementation

-  config = mkIf (cfg.client.enable || cfg.server.enable) {
+  config =
+    let
+      wrappedSlurm = pkgs.stdenv.mkDerivation {
+        name = "wrappedSlurm";

-    environment.systemPackages = [ pkgs.slurm-llnl ];
+        propagatedBuildInputs = [ cfg.package configFile ];
+
+        builder = pkgs.writeText "builder.sh" ''
+          source $stdenv/setup
+          mkdir -p $out/bin
+          find  ${cfg.package}/bin -type f -executable | while read EXE
+          do
+            exename="$(basename $EXE)"
+            wrappername="$out/bin/$exename"
+            cat > "$wrappername" <<EOT
+          #!/bin/sh
+          if [ -z "$SLURM_CONF" ]
+          then
+            SLURM_CONF="${configFile}" "$EXE" "\$@"
+          else
+            "$EXE" "\$0"
+          fi
+          EOT
+            chmod +x "$wrappername"
+          done
+        '';
+      };
+
+  in mkIf (cfg.client.enable || cfg.server.enable) {
+
+    environment.systemPackages = [ wrappedSlurm ];

    systemd.services.slurmd = mkIf (cfg.client.enable) {
-      path = with pkgs; [ slurm-llnl coreutils ];
+      path = with pkgs; [ wrappedSlurm coreutils ];

      wantedBy = [ "multi-user.target" ];
      after = [ "systemd-tmpfiles-clean.service" ];

      serviceConfig = {
        Type = "forking";
-        ExecStart = "${pkgs.slurm-llnl}/bin/slurmd -f ${configFile}";
+        ExecStart = "${wrappedSlurm}/bin/slurmd";
        PIDFile = "/run/slurmd.pid";
        ExecReload = "${pkgs.coreutils}/bin/kill -HUP $MAINPID";
      };
+
+      preStart = ''
+        mkdir -p /var/spool
+      '';
    };

    systemd.services.slurmctld = mkIf (cfg.server.enable) {
-      path = with pkgs; [ slurm-llnl munge coreutils ];
+      path = with pkgs; [ wrappedSlurm munge coreutils ];
      
      wantedBy = [ "multi-user.target" ];
-      after = [ "network.target" "auditd.service" "munged.service" "slurmdbd.service" ];
+      after = [ "network.target" "munged.service" ];
      requires = [ "munged.service" ];

      serviceConfig = {
        Type = "forking";
-        ExecStart = "${pkgs.slurm-llnl}/bin/slurmctld";
+        ExecStart = "${wrappedSlurm}/bin/slurmctld";
        PIDFile = "/run/slurmctld.pid";
        ExecReload = "${pkgs.coreutils}/bin/kill -HUP $MAINPID";
      };
-      environment = { SLURM_CONF = "${configFile}"; };
    };

  };
--- a/nixos/modules/services/continuous-integration/jenkins/default.nix
+++ b/nixos/modules/services/continuous-integration/jenkins/default.nix
@ -48,13 +48,13 @@ in {
        '';
      };

-      host = mkOption {
+      listenAddress = mkOption {
        default = "0.0.0.0";
        example = "localhost";
        type = types.str;
        description = ''
-          Specifies the bind adress on which the jenkins HTTP interface listens.
-          The default is the wildcard adress.
+          Specifies the bind address on which the jenkins HTTP interface listens.
+          The default is the wildcard address.
        '';
      };

@ -156,18 +156,18 @@ in {
      '';

      script = ''
-        ${pkgs.jdk}/bin/java -jar ${pkgs.jenkins} --httpListenAddress=${cfg.host} \
+        ${pkgs.jdk}/bin/java -jar ${pkgs.jenkins} --httpListenAddress=${cfg.listenAddress} \
                                                  --httpPort=${toString cfg.port} \
                                                  --prefix=${cfg.prefix} \
                                                  ${concatStringsSep " " cfg.extraOptions}
      '';

      postStart = ''
-        until ${pkgs.curl}/bin/curl -s -L ${cfg.host}:${toString cfg.port}${cfg.prefix} ; do
+        until ${pkgs.curl}/bin/curl -s -L ${cfg.listenAddress}:${toString cfg.port}${cfg.prefix} ; do
          sleep 10
        done
        while true ; do
-          index=`${pkgs.curl}/bin/curl -s -L ${cfg.host}:${toString cfg.port}${cfg.prefix}`
+          index=`${pkgs.curl}/bin/curl -s -L ${cfg.listenAddress}:${toString cfg.port}${cfg.prefix}`
          if [[ !("$index" =~ 'Please wait while Jenkins is restarting' ||
                  "$index" =~ 'Please wait while Jenkins is getting ready to work') ]]; then
            exit 0
--- a/nixos/modules/services/continuous-integration/jenkins/job-builder.nix
+++ b/nixos/modules/services/continuous-integration/jenkins/job-builder.nix
@ -144,7 +144,7 @@ in {
            done

            echo "Asking Jenkins to reload config"
-            curl --silent -X POST http://${jenkinsCfg.host}:${toString jenkinsCfg.port}${jenkinsCfg.prefix}/reload
+            curl --silent -X POST http://${jenkinsCfg.listenAddress}:${toString jenkinsCfg.port}${jenkinsCfg.prefix}/reload
          '';
      serviceConfig = {
        User = jenkinsCfg.user;
--- a/nixos/modules/services/misc/plex.nix
+++ b/nixos/modules/services/misc/plex.nix
@ -54,6 +54,15 @@ in
          false.
        '';
      };
+
+      package = mkOption {
+        type = types.package;
+        default = pkgs.plex;
+        description = ''
+          The Plex package to use. Plex subscribers may wish to use their own
+          package here, pointing to subscriber-only server versions.
+        '';
+      };
    };
  };

@ -75,7 +84,7 @@ in
        # why this is done.
        test -d "${cfg.dataDir}/.skeleton" || mkdir "${cfg.dataDir}/.skeleton"
        for db in "com.plexapp.plugins.library.db"; do
-            cp "${plex}/usr/lib/plexmediaserver/Resources/base_$db" "${cfg.dataDir}/.skeleton/$db"
+            cp "${cfg.package}/usr/lib/plexmediaserver/Resources/base_$db" "${cfg.dataDir}/.skeleton/$db"
            chmod u+w "${cfg.dataDir}/.skeleton/$db"
            chown ${cfg.user}:${cfg.group} "${cfg.dataDir}/.skeleton/$db"
        done
@ -117,14 +126,14 @@ in
        User = cfg.user;
        Group = cfg.group;
        PermissionsStartOnly = "true";
-        ExecStart = "/bin/sh -c '${plex}/usr/lib/plexmediaserver/Plex\\ Media\\ Server'";
+        ExecStart = "/bin/sh -c '${cfg.package}/usr/lib/plexmediaserver/Plex\\ Media\\ Server'";
      };
      environment = {
        PLEX_MEDIA_SERVER_APPLICATION_SUPPORT_DIR=cfg.dataDir;
-        PLEX_MEDIA_SERVER_HOME="${plex}/usr/lib/plexmediaserver";
+        PLEX_MEDIA_SERVER_HOME="${cfg.package}/usr/lib/plexmediaserver";
        PLEX_MEDIA_SERVER_MAX_PLUGIN_PROCS="6";
        PLEX_MEDIA_SERVER_TMPDIR="/tmp";
-        LD_LIBRARY_PATH="${plex}/usr/lib/plexmediaserver";
+        LD_LIBRARY_PATH="${cfg.package}/usr/lib/plexmediaserver";
        LC_ALL="en_US.UTF-8";
        LANG="en_US.UTF-8";
      };
--- a/nixos/modules/services/networking/dnsmasq.nix
+++ b/nixos/modules/services/networking/dnsmasq.nix
@ -5,8 +5,10 @@ with lib;
 let
  cfg = config.services.dnsmasq;
  dnsmasq = pkgs.dnsmasq;
+  stateDir = "/var/lib/dnsmasq";

  dnsmasqConf = pkgs.writeText "dnsmasq.conf" ''
+    dhcp-leasefile=${stateDir}/dnsmasq.leases
    ${optionalString cfg.resolveLocalQueries ''
      conf-file=/etc/dnsmasq-conf.conf
      resolv-file=/etc/dnsmasq-resolv.conf
@ -76,12 +78,11 @@ in

    services.dbus.packages = [ dnsmasq ];

-    users.extraUsers = singleton
-      { name = "dnsmasq";
-        uid = config.ids.uids.dnsmasq;
-        description = "Dnsmasq daemon user";
-        home = "/var/empty";
-      };
+    users.extraUsers = singleton {
+      name = "dnsmasq";
+      uid = config.ids.uids.dnsmasq;
+      description = "Dnsmasq daemon user";
+    };

    systemd.services.dnsmasq = {
        description = "Dnsmasq Daemon";
@ -89,6 +90,9 @@ in
        wantedBy = [ "multi-user.target" ];
        path = [ dnsmasq ];
        preStart = ''
+          mkdir -m 755 -p ${stateDir}
+          touch ${stateDir}/dnsmasq.leases
+          chown -R dnsmasq ${stateDir}
          touch /etc/dnsmasq-{conf,resolv}.conf
          dnsmasq --test
        '';
--- a/nixos/modules/services/networking/hostapd.nix
+++ b/nixos/modules/services/networking/hostapd.nix
@ -2,21 +2,17 @@

 # TODO:
 #
-# asserts 
+# asserts
 #   ensure that the nl80211 module is loaded/compiled in the kernel
-#   hwMode must be a/b/g
-#   channel must be between 1 and 13 (maybe)
 #   wpa_supplicant and hostapd on the same wireless interface doesn't make any sense
-#   perhaps an assertion that there is a dhcp server and a dns server on the IP address serviced by the hostapd?

 with lib;

 let

  cfg = config.services.hostapd;
-  
-  configFile = pkgs.writeText "hostapd.conf"  
-    ''
+
+  configFile = pkgs.writeText "hostapd.conf" ''
    interface=${cfg.interface}
    driver=${cfg.driver}
    ssid=${cfg.ssid}
@ -37,8 +33,8 @@ let
      wpa_passphrase=${cfg.wpaPassphrase}
      '' else ""}

-    ${cfg.extraCfg}
-    '' ;
+    ${cfg.extraConfig}
+  '' ;

 in

@ -65,9 +61,9 @@ in

      interface = mkOption {
        default = "";
-        example = "wlan0";
+        example = "wlp2s0";
        description = ''
-          The interfaces <command>hostapd</command> will use. 
+          The interfaces <command>hostapd</command> will use.
        '';
      };

@ -89,8 +85,7 @@ in
      };

      hwMode = mkOption {
-        default = "b";
-        example = "g";
+        default = "g";
        type = types.string;
        description = ''
          Operation mode.
@ -98,17 +93,16 @@ in
        '';
      };

-      channel = mkOption { 
+      channel = mkOption {
        default = 7;
        example = 11;
        type = types.int;
-        description = 
-          ''
+        description = ''
          Channel number (IEEE 802.11)
          Please note that some drivers do not use this value from
          <command>hostapd</command> and the channel will need to be configured
          separately with <command>iwconfig</command>.
-          '';
+        '';
      };

      group = mkOption {
@ -131,16 +125,15 @@ in
        default = "my_sekret";
        example = "any_64_char_string";
        type = types.string;
-        description = 
-          ''
+        description = ''
          WPA-PSK (pre-shared-key) passphrase. Clients will need this
          passphrase to associate with this access point.
          Warning: This passphrase will get put into a world-readable file in
          the Nix store!
-          '';
+        '';
      };

-      extraCfg = mkOption {
+      extraConfig = mkOption {
        default = "";
        example = ''
          auth_algo=0
@ -158,17 +151,25 @@ in

  config = mkIf cfg.enable {

+    assertions = [
+      { assertion = (cfg.hwMode == "a" || cfg.hwMode == "b" || cfg.hwMode == "g");
+        message = "hwMode must be a/b/g";
+      }
+      { assertion = (cfg.channel >= 1 && cfg.channel <= 13);
+        message = "channel must be between 1 and 13";
+      }];
+
    environment.systemPackages =  [ pkgs.hostapd ];

    systemd.services.hostapd =
      { description = "hostapd wireless AP";

-        path = [ pkgs.hostapd ]; 
+        path = [ pkgs.hostapd ];
        wantedBy = [ "network.target" ];

        after = [ "${cfg.interface}-cfg.service" "nat.service" "bind.service" "dhcpd.service"];

-        serviceConfig = 
+        serviceConfig =
          { ExecStart = "${pkgs.hostapd}/bin/hostapd ${configFile}";
            Restart = "always";
          };
--- a/nixos/modules/services/networking/networkmanager.nix
+++ b/nixos/modules/services/networking/networkmanager.nix
@ -223,9 +223,11 @@ in {
    }
    {
      name = "nm-openvpn";
+      gid = config.ids.gids.nm-openvpn;
    }];
    users.extraUsers = [{
      name = "nm-openvpn";
+      uid = config.ids.uids.nm-openvpn;
    }];

    systemd.packages = cfg.packages;
--- a/nixos/modules/services/x11/redshift.nix
+++ b/nixos/modules/services/x11/redshift.nix
@ -98,13 +98,16 @@ in {
      requires = [ "display-manager.service" ];
      after = [ "display-manager.service" ];
      wantedBy = [ "graphical.target" ];
-      serviceConfig.ExecStart = ''
-        ${cfg.package}/bin/redshift \
-          -l ${cfg.latitude}:${cfg.longitude} \
-          -t ${toString cfg.temperature.day}:${toString cfg.temperature.night} \
-          -b ${toString cfg.brightness.day}:${toString cfg.brightness.night} \
-          ${lib.strings.concatStringsSep " " cfg.extraOptions}
-      '';
+      serviceConfig = {
+        ExecStart = ''
+          ${cfg.package}/bin/redshift \
+            -l ${cfg.latitude}:${cfg.longitude} \
+            -t ${toString cfg.temperature.day}:${toString cfg.temperature.night} \
+            -b ${toString cfg.brightness.day}:${toString cfg.brightness.night} \
+            ${lib.strings.concatStringsSep " " cfg.extraOptions}
+        '';
+	RestartSec = 3;
+      };
      environment = { DISPLAY = ":0"; };
      serviceConfig.Restart = "always";
    };
--- a/nixos/modules/services/x11/window-managers/windowlab.nix
+++ b/nixos/modules/services/x11/window-managers/windowlab.nix
@ -0,0 +1,22 @@
+{lib, pkgs, config, ...}:
+
+let
+  cfg = config.services.xserver.windowManager.windowlab;
+in
+
+{
+  options = {
+    services.xserver.windowManager.windowlab.enable =
+      lib.mkEnableOption "windowlab";
+  };
+
+  config = lib.mkIf cfg.enable {
+    services.xserver.windowManager = {
+      session =
+        [{ name  = "windowlab";
+           start = "${pkgs.windowlab}/bin/windowlab";
+        }];
+    };
+    environment.systemPackages = [ pkgs.windowlab ];
+  };
+}
--- a/nixos/modules/services/x11/xserver.nix
+++ b/nixos/modules/services/x11/xserver.nix
@ -280,6 +280,13 @@ in
        '';
      };

+      xkbDir = mkOption {
+        type = types.path;
+        description = ''
+          Path used for -xkbdir xserver parameter.
+        '';
+      };
+
      config = mkOption {
        type = types.lines;
        description = ''
@ -462,7 +469,7 @@ in
            target = "X11/xorg.conf";
          }
          # -xkbdir command line option does not seems to be passed to xkbcomp.
-          { source = "${pkgs.xkeyboard_config}/etc/X11/xkb";
+          { source = "${cfg.xkbDir}";
            target = "X11/xkb";
          }
        ]);
@ -528,7 +535,7 @@ in
      [ "-ac"
        "-terminate"
        "-config ${configFile}"
-        "-xkbdir" "${pkgs.xkeyboard_config}/etc/X11/xkb"
+        "-xkbdir" "${cfg.xkbDir}"
      ] ++ optional (cfg.display != null) ":${toString cfg.display}"
        ++ optional (cfg.tty     != null) "vt${toString cfg.tty}"
        ++ optionals (cfg.display != null) [ "-logfile" "/var/log/X.${toString cfg.display}.log" ]
@ -540,6 +547,8 @@ in
        xorg.xf86inputevdev
      ];

+    services.xserver.xkbDir = mkDefault "${pkgs.xkeyboard_config}/etc/X11/xkb";
+
    services.xserver.config =
      ''
        Section "ServerFlags"
--- a/nixos/modules/system/boot/loader/grub/install-grub.pl
+++ b/nixos/modules/system/boot/loader/grub/install-grub.pl
@ -387,6 +387,10 @@ sub addProfile {
    my $curEntry = 0;
    foreach my $link (@links) {
        last if $curEntry++ >= $configurationLimit;
+        if (! -e "$link/nixos-version") {
+            warn "skipping corrupt system profile entry ‘$link’\n";
+            next;
+        }
        my $date = strftime("%F", localtime(lstat($link)->mtime));
        my $version =
            -e "$link/nixos-version"
--- a/nixos/modules/system/etc/etc.nix
+++ b/nixos/modules/system/etc/etc.nix
@ -112,8 +112,9 @@ in

          config = {
            target = mkDefault name;
-            source = mkIf (config.text != null)
-              (mkDefault (pkgs.writeText "etc-file" config.text));
+            source = mkIf (config.text != null) (
+              let name' = "etc-" + baseNameOf name;
+              in mkDefault (pkgs.writeText name' config.text));
          };

        });
--- a/nixos/modules/tasks/network-interfaces-scripted.nix
+++ b/nixos/modules/tasks/network-interfaces-scripted.nix
@ -83,13 +83,13 @@ in
                  # FIXME: get rid of "|| true" (necessary to make it idempotent).
                  ip route add default via "${cfg.defaultGateway}" ${
                    optionalString (cfg.defaultGatewayWindowSize != null)
-                      "window ${cfg.defaultGatewayWindowSize}"} || true
+                      "window ${toString cfg.defaultGatewayWindowSize}"} || true
                ''}
                ${optionalString (cfg.defaultGateway6 != null && cfg.defaultGateway6 != "") ''
                  # FIXME: get rid of "|| true" (necessary to make it idempotent).
                  ip -6 route add ::/0 via "${cfg.defaultGateway6}" ${
                    optionalString (cfg.defaultGatewayWindowSize != null)
-                      "window ${cfg.defaultGatewayWindowSize}"} || true
+                      "window ${toString cfg.defaultGatewayWindowSize}"} || true
                ''}
              '';
          };
--- a/nixos/modules/virtualisation/amazon-image.nix
+++ b/nixos/modules/virtualisation/amazon-image.nix
@ -11,7 +11,7 @@ with lib;
 let cfg = config.ec2; in

 {
-  imports = [ ../profiles/headless.nix ./ec2-data.nix ./amazon-grow-partition.nix ];
+  imports = [ ../profiles/headless.nix ./ec2-data.nix ./amazon-grow-partition.nix ./amazon-init.nix ];

  config = {

--- a/nixos/modules/virtualisation/amazon-init.nix
+++ b/nixos/modules/virtualisation/amazon-init.nix
@ -44,7 +44,6 @@ let
    nixos-rebuild switch
  '';
 in {
-  imports = [ "${modulesPath}/virtualisation/amazon-image.nix" ];
  boot.postBootCommands = ''
    ${bootScript} &
  '';
--- a/nixos/modules/virtualisation/docker.nix
+++ b/nixos/modules/virtualisation/docker.nix
@ -69,7 +69,8 @@ in
        description = ''
          The postStart phase of the systemd service. You may need to
          override this if you are passing in flags to docker which
-          don't cause the socket file to be created.
+          don't cause the socket file to be created. This option is ignored
+          if socket activation is used.
        '';
      };

@ -81,22 +82,29 @@ in
  config = mkIf cfg.enable (mkMerge [
    { environment.systemPackages = [ pkgs.docker ];
      users.extraGroups.docker.gid = config.ids.gids.docker;
-    }
-    (mkIf cfg.socketActivation {
-
      systemd.services.docker = {
        description = "Docker Application Container Engine";
-        after = [ "network.target" "docker.socket" ];
-        requires = [ "docker.socket" ];
+        wantedBy = optional (!cfg.socketActivation) "multi-user.target";
+        after = [ "network.target" ] ++ (optional cfg.socketActivation "docker.socket") ;
+        requires = optional cfg.socketActivation "docker.socket";
        serviceConfig = {
-          ExecStart = "${pkgs.docker}/bin/docker daemon --host=fd:// --group=docker --storage-driver=${cfg.storageDriver} ${cfg.extraOptions}";
+          ExecStart = "${pkgs.docker}/bin/docker daemon --group=docker --storage-driver=${cfg.storageDriver} ${optionalString cfg.socketActivation "--host=fd://"} ${cfg.extraOptions}";
          #  I'm not sure if that limits aren't too high, but it's what
          #  goes in config bundled with docker itself
          LimitNOFILE = 1048576;
          LimitNPROC = 1048576;
        } // proxy_env;
-      };

+        path = [ pkgs.kmod ] ++ (optional (cfg.storageDriver == "zfs") pkgs.zfs);
+        environment.MODULE_DIR = "/run/current-system/kernel-modules/lib/modules";
+
+        postStart = if cfg.socketActivation then "" else cfg.postStart;
+
+        # Presumably some containers are running we don't want to interrupt
+        restartIfChanged = false;
+      };
+    }
+    (mkIf cfg.socketActivation {
      systemd.sockets.docker = {
        description = "Docker Socket for the API";
        wantedBy = [ "sockets.target" ];
@ -108,29 +116,6 @@ in
        };
      };
    })
-    (mkIf (!cfg.socketActivation) {
-
-      systemd.services.docker = {
-        description = "Docker Application Container Engine";
-        wantedBy = [ "multi-user.target" ];
-        after = [ "network.target" ];
-        serviceConfig = {
-          ExecStart = "${pkgs.docker}/bin/docker daemon --group=docker --storage-driver=${cfg.storageDriver} ${cfg.extraOptions}";
-          #  I'm not sure if that limits aren't too high, but it's what
-          #  goes in config bundled with docker itself
-          LimitNOFILE = 1048576;
-          LimitNPROC = 1048576;
-        } // proxy_env;
-
-        path = [ pkgs.kmod ] ++ (optional (cfg.storageDriver == "zfs") pkgs.zfs);
-        environment.MODULE_DIR = "/run/current-system/kernel-modules/lib/modules";
-
-        postStart = cfg.postStart;
-
-        # Presumably some containers are running we don't want to interrupt
-        restartIfChanged = false;
-      };
-    })
  ]);

 }
--- a/nixos/modules/virtualisation/qemu-vm.nix
+++ b/nixos/modules/virtualisation/qemu-vm.nix
@ -40,16 +40,17 @@ let
      if [ -z "$TMPDIR" -o -z "$USE_TMPDIR" ]; then
          TMPDIR=$(mktemp -d nix-vm.XXXXXXXXXX --tmpdir)
      fi
+
      # Create a directory for exchanging data with the VM.
      mkdir -p $TMPDIR/xchg

      ${if cfg.useBootLoader then ''
-        # Create a writable copy/snapshot of the boot disk
-        # A writable boot disk can be booted from automatically
+        # Create a writable copy/snapshot of the boot disk.
+        # A writable boot disk can be booted from automatically.
        ${pkgs.qemu_kvm}/bin/qemu-img create -f qcow2 -b ${bootDisk}/disk.img $TMPDIR/disk.img || exit 1

        ${if cfg.useEFIBoot then ''
-          # VM needs a writable flash BIOS
+          # VM needs a writable flash BIOS.
          cp ${bootDisk}/bios.bin $TMPDIR || exit 1
          chmod 0644 $TMPDIR/bios.bin || exit 1
        '' else ''
--- a/nixos/release.nix
+++ b/nixos/release.nix
@ -47,6 +47,7 @@ let
          };
          inherit iso;
          passthru = { inherit config; };
+          preferLocalBuild = true;
        }
        ''
          mkdir -p $out/nix-support
@ -149,6 +150,7 @@ in rec {
            maintainers = maintainers.eelco;
          };
          ova = config.system.build.virtualBoxOVA;
+          preferLocalBuild = true;
        }
        ''
          mkdir -p $out/nix-support
@ -168,6 +170,7 @@ in rec {
            boot.loader.grub.device = mkDefault "/dev/sda";
          });
      }).config.system.build.toplevel;
+      preferLocalBuild = true;
    }
    "mkdir $out; ln -s $toplevel $out/dummy");

@ -220,7 +223,7 @@ in rec {
  tests.dockerRegistry = hydraJob (import tests/docker-registry.nix { system = "x86_64-linux"; });
  tests.etcd = hydraJob (import tests/etcd.nix { system = "x86_64-linux"; });
  tests.ec2-nixops = hydraJob (import tests/ec2.nix { system = "x86_64-linux"; }).boot-ec2-nixops;
-  #tests.ec2-config = hydraJob (import tests/ec2.nix { system = "x86_64-linux"; }).boot-ec2-config;
+  tests.ec2-config = hydraJob (import tests/ec2.nix { system = "x86_64-linux"; }).boot-ec2-config;
  tests.firefox = callTest tests/firefox.nix {};
  tests.firewall = callTest tests/firewall.nix {};
  tests.fleet = hydraJob (import tests/fleet.nix { system = "x86_64-linux"; });
--- a/nixos/tests/slurm.nix
+++ b/nixos/tests/slurm.nix
@ -0,0 +1,80 @@
+import ./make-test.nix ({ pkgs, ... }:
+let mungekey = "mungeverryweakkeybuteasytointegratoinatest";
+    slurmconfig = {
+      client.enable = true;
+      controlMachine = "control";
+      nodeName = ''
+        control
+        NodeName=node[1-3] CPUs=1 State=UNKNOWN
+      '';
+      partitionName = "debug Nodes=node[1-3] Default=YES MaxTime=INFINITE State=UP";
+    };
+in {
+  name = "slurm";
+
+  nodes =
+    let
+    computeNode =
+      { config, pkgs, ...}:
+      {
+        # TODO slrumd port and slurmctld port should be configurations and
+        # automatically allowed by the  firewall.
+        networking.firewall.enable = false;
+        services.munge.enable = true;
+        services.slurm = slurmconfig;
+      };
+    in {
+    control =
+      { config, pkgs, ...}:
+      {
+        networking.firewall.enable = false;
+        services.munge.enable = true;
+        services.slurm = {
+          server.enable = true;
+        } // slurmconfig;
+      };
+    node1 = computeNode;
+    node2 = computeNode;
+    node3 = computeNode;
+  };
+
+  testScript =
+  ''
+  startAll;
+
+  # Set up authentification across the cluster
+  foreach my $node (($control,$node1,$node2,$node3))
+  {
+    $node->waitForUnit("default.target");
+
+    $node->succeed("mkdir /etc/munge");
+    $node->succeed("echo '${mungekey}' > /etc/munge/munge.key");
+    $node->succeed("chmod 0400 /etc/munge/munge.key");
+    $node->succeed("systemctl restart munged");
+  }
+
+  # Restart the services since they have probably failed due to the munge init
+  # failure
+
+  subtest "can_start_slurmctld", sub {
+    $control->succeed("systemctl restart slurmctld");
+    $control->waitForUnit("slurmctld.service");
+  };
+
+  subtest "can_start_slurmd", sub {
+    foreach my $node (($control,$node1,$node2,$node3))
+    {
+      $node->succeed("systemctl restart slurmd.service");
+      $node->waitForUnit("slurmd");
+    }
+  };
+
+  # Test that the cluster work and can distribute jobs;
+
+  subtest "run_distributed_command", sub {
+    # Run `hostname` on 3 nodes of the partition (so on all the 3 nodes).
+    # The output must contain the 3 different names
+    $control->succeed("srun -N 3 hostname | sort | uniq | wc -l | xargs test 3 -eq");
+  };
+  '';
+})
--- a/pkgs/applications/altcoins/bitcoin.nix
+++ b/pkgs/applications/altcoins/bitcoin.nix
@ -17,7 +17,8 @@ stdenv.mkDerivation rec{
  };

  buildInputs = [ pkgconfig autoreconfHook openssl db48 boost zlib
-                  miniupnpc utillinux protobuf ]
+                  miniupnpc protobuf ]
+                  ++ optionals stdenv.isLinux [ utillinux ]
                  ++ optionals withGui [ qt4 qrencode ];

  configureFlags = [ "--with-boost-libdir=${boost.lib}/lib" ]
--- a/pkgs/applications/audio/amarok/default.nix
+++ b/pkgs/applications/audio/amarok/default.nix
@ -2,6 +2,7 @@
 , qtscriptgenerator, gettext, curl , libxml2, mysql, taglib
 , taglib_extras, loudmouth , kdelibs , qca2, libmtp, liblastfm, libgpod
 , phonon , strigi, soprano, qjson, ffmpeg, libofa, nepomuk_core ? null
+, lz4, lzo, snappy, libaio
 }:

 stdenv.mkDerivation rec {
@ -23,8 +24,14 @@ stdenv.mkDerivation rec {
    qtscriptgenerator stdenv.cc.libc gettext curl libxml2 mysql.lib
    taglib taglib_extras loudmouth kdelibs phonon strigi soprano qca2
    libmtp liblastfm libgpod qjson ffmpeg libofa nepomuk_core
+    lz4 lzo snappy libaio
  ];

+  # This is already fixed upstream, will be release in 2.9
+  preConfigure = ''
+    sed -i -e 's/STRLESS/VERSION_LESS/g' cmake/modules/FindTaglib.cmake
+  '';
+
  cmakeFlags = "-DKDE4_BUILD_TESTS=OFF";

  propagatedUserEnvPkgs = [ qtscriptgenerator ];
--- a/pkgs/applications/audio/cantata/default.nix
+++ b/pkgs/applications/audio/cantata/default.nix
@ -93,6 +93,11 @@ stdenv.mkDerivation rec {
    "-DENABLE_UDISKS2=ON"
  ];

+  # This is already fixed upstream but not released yet. Maybe in version 2.
+  preConfigure = ''
+    sed -i -e 's/STRLESS/VERSION_LESS/g' cmake/FindTaglib.cmake
+  '';
+
  postInstall = stdenv.lib.optionalString withQt5 ''
    wrapQtProgram "$out/bin/cantata"
  '';
--- a/pkgs/applications/audio/spotify/default.nix
+++ b/pkgs/applications/audio/spotify/default.nix
@ -1,4 +1,4 @@
-{ fetchurl, stdenv, dpkg, xorg, qt4, alsaLib, makeWrapper, openssl, freetype
+{ fetchurl, stdenv, dpkg, xorg, qt4, alsaLib, makeWrapper, openssl_1_0_1, freetype
 , glib, pango, cairo, atk, gdk_pixbuf, gtk, cups, nspr, nss, libpng, GConf
 , libgcrypt, chromium, udev, fontconfig
 , dbus, expat, ffmpeg_0_10 }:
@ -67,8 +67,8 @@ stdenv.mkDerivation {
      # Work around Spotify referring to a specific minor version of
      # OpenSSL.

-      ln -s ${openssl}/lib/libssl.so $libdir/libssl.so.1.0.0
-      ln -s ${openssl}/lib/libcrypto.so $libdir/libcrypto.so.1.0.0
+      ln -s ${openssl_1_0_1}/lib/libssl.so $libdir/libssl.so.1.0.0
+      ln -s ${openssl_1_0_1}/lib/libcrypto.so $libdir/libcrypto.so.1.0.0
      ln -s ${nspr}/lib/libnspr4.so $libdir/libnspr4.so
      ln -s ${nspr}/lib/libplc4.so $libdir/libplc4.so

--- a/pkgs/applications/editors/emacs-modes/elpa-packages.json
+++ b/pkgs/applications/editors/emacs-modes/elpa-packages.json
@ -246,10 +246,10 @@
    "org": {
        "fetch": {
            "tag": "fetchurl",
-            "url": "http://elpa.gnu.org/packages/org-20151214.tar",
-            "sha256": "15m9l7p7xfmcrxrcsxbvpp8bq5ajcapknvqblhmk77j7ca3jffi1"
+            "url": "http://elpa.gnu.org/packages/org-20151221.tar",
+            "sha256": "01p8c70bd2mp3w08vpha0dvpljhj4r5797b0m9q16z4zhxqaqbqx"
        },
-        "version": "20151214",
+        "version": "20151221",
        "deps": []
    },
    "bug-hunter": {
--- a/pkgs/applications/editors/emacs-modes/melpa-packages.json
+++ b/pkgs/applications/editors/emacs-modes/melpa-packages.json
--- a/pkgs/applications/editors/emacs-modes/melpa-packages.nix
+++ b/pkgs/applications/editors/emacs-modes/melpa-packages.nix
@ -18,7 +18,7 @@ let

  inherit (lib) makeScope mapAttrs;

-  json = builtins.readFile ./melpa-stable-packages.json;
+  json = builtins.readFile ./melpa-packages.json;
  manifest = builtins.fromJSON json;

  mkPackage = self: name: recipe:
@ -36,10 +36,14 @@ let
              or unknownFetcher;
            args = builtins.removeAttrs recipe.fetch [ "tag" ];
            src = fetch args;
+            recipeFile = fetchurl {
+              url = "https://raw.githubusercontent.com/milkypostman/melpa/${recipe.recipe.commit}/recipes/${name}";
+              inherit (recipe.recipe) sha256;
+            };
          in melpaBuild {
            pname = name;
            inherit (recipe) version;
-            inherit src;
+            inherit recipeFile src;
            packageRequires =
              let lookupDep = d: self."${d}" or null;
              in map lookupDep recipe.deps;
--- a/pkgs/applications/editors/emacs-modes/melpa-stable-packages.json
+++ b/pkgs/applications/editors/emacs-modes/melpa-stable-packages.json
--- a/pkgs/applications/editors/emacs-modes/melpa-stable-packages.nix
+++ b/pkgs/applications/editors/emacs-modes/melpa-stable-packages.nix
@ -38,10 +38,14 @@ let
              or unknownFetcher;
            args = builtins.removeAttrs recipe.fetch [ "tag" ];
            src = fetch args;
+            recipeFile = fetchurl {
+              url = "https://raw.githubusercontent.com/milkypostman/melpa/${recipe.recipe.commit}/recipes/${name}";
+              inherit (recipe.recipe) sha256;
+            };
          in melpaBuild {
            pname = name;
            inherit (recipe) version;
-            inherit src;
+            inherit recipeFile src;
            packageRequires =
              let lookupDep = d: self."${d}" or null;
              in map lookupDep recipe.deps;
--- a/pkgs/applications/graphics/darktable/default.nix
+++ b/pkgs/applications/graphics/darktable/default.nix
@ -9,12 +9,12 @@
 assert stdenv ? glibc;

 stdenv.mkDerivation rec {
-  version = "1.6.8";
+  version = "1.6.9";
  name = "darktable-${version}";

  src = fetchurl {
    url = "https://github.com/darktable-org/darktable/releases/download/release-${version}/darktable-${version}.tar.xz";
-    sha256 = "0189d5pn6g01rynfkhxynrqgfi24v94x8fp0fs7ilrncv0dzhxmn";
+    sha256 = "0wri89ygjpv7npiz58mnydhgldywp6arqp9jq3v0g54a56fiwwhg";
  };

  buildInputs =
--- a/pkgs/applications/graphics/jpegoptim/default.nix
+++ b/pkgs/applications/graphics/jpegoptim/default.nix
@ -0,0 +1,24 @@
+{ stdenv, fetchurl, libjpeg }:
+
+stdenv.mkDerivation rec {
+  version = "1.4.3";
+  name = "jpegoptim-${version}";
+
+  src = fetchurl {
+    url = "http://www.kokkonen.net/tjko/src/${name}.tar.gz";
+    sha256 = "0k53q7dc8w5ashz8v261x2b5vvz7gdvg8w962rz9gjvkjbh4lg93";
+  };
+
+  # There are no checks, it seems.
+  doCheck = false;
+
+  buildInputs = [ libjpeg ];
+
+  meta = {
+    description = "Optimize JPEG files";
+    homepage = http://www.kokkonen.net/tjko/projects.html ;
+    license = stdenv.lib.licenses.gpl2;
+    maintainers = [ stdenv.lib.maintainers.aristid ];
+    platforms = stdenv.lib.platforms.all;
+  };
+}
--- a/pkgs/applications/graphics/sane/backends-git.nix
+++ b/pkgs/applications/graphics/sane/backends-git.nix
@ -1,58 +0,0 @@
-{ stdenv, fetchurl, fetchgit, hotplugSupport ? true, libusb ? null
-, gt68xxFirmware ? null, snapscanFirmware ? null
-}:
-let
-  firmware = gt68xxFirmware { inherit fetchurl; };
-in
-assert hotplugSupport -> (stdenv.system == "i686-linux" || stdenv.system == "x86_64-linux");
-
-let version = "2015-12-20"; in
-stdenv.mkDerivation {
-  name = "sane-backends-${version}";
-
-  src = fetchgit {
-    url = "git://alioth.debian.org/git/sane/sane-backends.git";
-    rev = "5136e664b8608604f54a2cc1d466019922b311e6";
-    sha256 = "998fdc9cdd3f9220c38244e0b87bba3ee623d7d20726479b04ed95b3836a37ed";
-  };
-
-  udevSupport = hotplugSupport;
-
-  buildInputs = if libusb != null then [libusb] else [];
-
-  postInstall = ''
-    if test "$udevSupport" = "1"; then
-      mkdir -p $out/etc/udev/rules.d/
-      ./tools/sane-desc -m udev > $out/etc/udev/rules.d/60-libsane.rules || \
-      cp tools/udev/libsane.rules $out/etc/udev/rules.d/60-libsane.rules
-    fi
-  '';
-
-  preInstall =
-    if gt68xxFirmware != null then
-      "mkdir -p \${out}/share/sane/gt68xx ; ln -s " + firmware.fw +
-      " \${out}/share/sane/gt68xx/" + firmware.name
-    else if snapscanFirmware != null then
-      "mkdir -p \${out}/share/sane/snapscan ; ln -s " + snapscanFirmware +
-      " \${out}/share/sane/snapscan/your-firmwarefile.bin ;" +
-      "mkdir -p \${out}/etc/sane.d ; " +
-      "echo epson2 > \${out}/etc/sane.d/dll.conf"
-    else "";
-
-  meta = with stdenv.lib; {
-    inherit version;
-    homepage = "http://www.sane-project.org/";
-    description = "SANE (Scanner Access Now Easy) backends";
-    longDescription = ''
-      Collection of open-source SANE backends (device drivers).
-      SANE is a universal scanner interface providing standardized access to
-      any raster image scanner hardware: flatbed scanners, hand-held scanners,
-      video- and still-cameras, frame-grabbers, etc. For a list of supported
-      scanners, see http://www.sane-project.org/sane-backends.html.
-    '';
-    license = licenses.gpl2Plus;
-
-    maintainers = with maintainers; [ nckx simons ];
-    platforms = platforms.linux;
-  };
-}
--- a/pkgs/applications/graphics/sane/backends.nix
+++ b/pkgs/applications/graphics/sane/backends.nix
@ -1,67 +0,0 @@
-{ stdenv, fetchurl, hotplugSupport ? true, libusb ? null, libv4l ? null
-, pkgconfig ? null, gt68xxFirmware ? null, snapscanFirmware ? null
-}:
-
-assert hotplugSupport -> (stdenv.system == "i686-linux" || stdenv.system == "x86_64-linux");
-
-let
-  firmware = gt68xxFirmware { inherit fetchurl; };
-in
-stdenv.mkDerivation rec {
-  version = "1.0.25";
-  name = "sane-backends-${version}";
-
-  src = fetchurl {
-    urls = [
-      "http://pkgs.fedoraproject.org/repo/pkgs/sane-backends/sane-backends-1.0.25.tar.gz/f9ed5405b3c12f07c6ca51ee60225fe7/${name}.tar.gz"
-      "https://alioth.debian.org/frs/download.php/file/4146/${name}.tar.gz"
-    ];
-    curlOpts = "--insecure";
-    sha256 = "0b3fvhrxl4l82bf3v0j47ypjv6a0k5lqbgknrq1agpmjca6vmmx4";
-  };
-
-  outputs = [ "out" "doc" "man" ];
-
-  udevSupport = hotplugSupport;
-
-  configureFlags = stdenv.lib.optional (libusb != null) "--enable-libusb_1_0";
-
-  buildInputs = []
-    ++ stdenv.lib.optional (libusb != null) libusb
-    ++ stdenv.lib.optional (libv4l != null) libv4l
-    ++ stdenv.lib.optional (pkgconfig != null) pkgconfig
-    ;
-
-  postInstall = ''
-    if test "$udevSupport" = "1"; then
-      mkdir -p $out/etc/udev/rules.d/
-      ./tools/sane-desc -m udev > $out/etc/udev/rules.d/49-libsane.rules || \
-      cp tools/udev/libsane.rules $out/etc/udev/rules.d/49-libsane.rules
-    fi
-  '';
-
-  preInstall =
-    if gt68xxFirmware != null then
-      "mkdir -p \${out}/share/sane/gt68xx ; ln -s " + firmware.fw +
-      " \${out}/share/sane/gt68xx/" + firmware.name
-    else if snapscanFirmware != null then
-      "mkdir -p \${out}/share/sane/snapscan ; ln -s " + snapscanFirmware +
-      " \${out}/share/sane/snapscan/your-firmwarefile.bin"
-    else "";
-
-  meta = with stdenv.lib; {
-    homepage = "http://www.sane-project.org/";
-    description = "SANE (Scanner Access Now Easy) backends";
-    longDescription = ''
-      Collection of open-source SANE backends (device drivers).
-      SANE is a universal scanner interface providing standardized access to
-      any raster image scanner hardware: flatbed scanners, hand-held scanners,
-      video- and still-cameras, frame-grabbers, etc. For a list of supported
-      scanners, see http://www.sane-project.org/sane-backends.html.
-    '';
-    license = licenses.gpl2Plus;
-
-    maintainers = with maintainers; [ nckx simons ];
-    platforms = platforms.linux;
-  };
-}
--- a/pkgs/applications/graphics/sane/backends/default.nix
+++ b/pkgs/applications/graphics/sane/backends/default.nix
@ -0,0 +1,13 @@
+{ callPackage, fetchurl, ... } @ args:
+
+callPackage ./generic.nix (args // rec {
+  version = "1.0.25";
+  src = fetchurl {
+    sha256 = "0b3fvhrxl4l82bf3v0j47ypjv6a0k5lqbgknrq1agpmjca6vmmx4";
+    urls = [
+      "http://pkgs.fedoraproject.org/repo/pkgs/sane-backends/sane-backends-${version}.tar.gz/f9ed5405b3c12f07c6ca51ee60225fe7/sane-backends-${version}.tar.gz"
+      "https://alioth.debian.org/frs/download.php/file/4146/sane-backends-${version}.tar.gz"
+    ];
+    curlOpts = "--insecure";
+  };
+})
--- a/pkgs/applications/graphics/sane/backends/generic.nix
+++ b/pkgs/applications/graphics/sane/backends/generic.nix
@ -0,0 +1,72 @@
+{ stdenv, fetchurl
+, avahi, libusb1, libv4l, net_snmp
+, gettext, pkgconfig
+
+# List of { src name backend } attibute sets - see installFirmware below:
+, extraFirmware ? []
+
+# For backwards compatibility with older setups; use extraFirmware instead:
+, gt68xxFirmware ? null, snapscanFirmware ? null
+
+# Passed from versioned package (e.g. default.nix, git.nix):
+, version, src, ...
+}:
+
+stdenv.mkDerivation {
+  inherit src;
+
+  name = "sane-backends-${version}";
+
+  outputs = [ "out" "doc" "man" ];
+
+  configureFlags = []
+    ++ stdenv.lib.optional (avahi != null) "--enable-avahi"
+    ++ stdenv.lib.optional (libusb1 != null) "--enable-libusb_1_0"
+    ;
+
+  buildInputs = [ avahi libusb1 libv4l net_snmp ];
+  nativeBuildInputs = [ gettext pkgconfig ];
+
+  postInstall = let
+
+    compatFirmware = extraFirmware
+      ++ stdenv.lib.optional (gt68xxFirmware != null) {
+        src = gt68xxFirmware.fw;
+        inherit (gt68xxFirmware) name;
+        backend = "gt68xx";
+      }
+      ++ stdenv.lib.optional (snapscanFirmware != null) {
+        src = snapscanFirmware;
+        name = "your-firmwarefile.bin";
+        backend = "snapscan";
+      };
+
+    installFirmware = f: ''
+      mkdir -p $out/share/sane/${f.backend}
+      ln -sv ${f.src} $out/share/sane/${f.backend}/${f.name}
+    '';
+
+  in ''
+    mkdir -p $out/etc/udev/rules.d/
+    ./tools/sane-desc -m udev > $out/etc/udev/rules.d/49-libsane.rules || \
+    cp tools/udev/libsane.rules $out/etc/udev/rules.d/49-libsane.rules
+  '' + stdenv.lib.concatStrings (builtins.map installFirmware compatFirmware);
+
+  meta = with stdenv.lib; {
+    inherit version;
+
+    description = "SANE (Scanner Access Now Easy) backends";
+    longDescription = ''
+      Collection of open-source SANE backends (device drivers).
+      SANE is a universal scanner interface providing standardized access to
+      any raster image scanner hardware: flatbed scanners, hand-held scanners,
+      video- and still-cameras, frame-grabbers, etc. For a list of supported
+      scanners, see http://www.sane-project.org/sane-backends.html.
+    '';
+    homepage = "http://www.sane-project.org/";
+    license = licenses.gpl2Plus;
+
+    maintainers = with maintainers; [ nckx simons ];
+    platforms = platforms.linux;
+  };
+}
--- a/pkgs/applications/graphics/sane/backends/git.nix
+++ b/pkgs/applications/graphics/sane/backends/git.nix
@ -0,0 +1,10 @@
+{ callPackage, fetchgit, ... } @ args:
+
+callPackage ./generic.nix (args // {
+  version = "2015-12-27";
+  src = fetchgit {
+    sha256 = "4bf6e8815d2edbbc75255928d0fb030639a9fea9a5aa953dcf1f00e167eff527";
+    rev = "cadb4b0fff00540159625320416e5601c4704627";
+    url = "git://alioth.debian.org/git/sane/sane-backends.git";
+  };
+})
--- a/pkgs/applications/misc/ding/default.nix
+++ b/pkgs/applications/misc/ding/default.nix
@ -0,0 +1,53 @@
+{ aspell, aspellDicts_de, aspellDicts_en, buildEnv, fetchurl, fortune, gnugrep, makeWrapper, stdenv, tk, tre }:
+let
+  aspellEnv = buildEnv {
+    name = "env-ding-aspell";
+    paths = [
+      aspell
+      aspellDicts_de
+      aspellDicts_en
+    ];
+  };
+in
+stdenv.mkDerivation rec {
+  name = "ding-1.8";
+
+  src = fetchurl {
+    url = "http://ftp.tu-chemnitz.de/pub/Local/urz/ding/${name}.tar.gz";
+    sha256 = "00z97ndwmzsgig9q6y98y8nbxy76pyi9qyj5qfpbbck24gakpz5l";
+  };
+
+  buildInputs = [ aspellEnv fortune gnugrep makeWrapper tk tre ];
+
+  patches = [ ./dict.patch ];
+
+  installPhase = ''
+    mkdir -p $out/bin
+    mkdir -p $out/share/dict
+    mkdir -p $out/share/man/man1
+    mkdir -p $out/share/applications
+    mkdir -p $out/share/pixmaps
+
+    for f in ding ding.1; do
+      sed -i "s@/usr/share@$out/share@g" "$f"
+    done
+
+    sed -i "s@/usr/bin/fortune@fortune@g" ding
+
+    cp ding $out/bin/
+    cp de-en.txt $out/share/dict/
+    cp ding.1 $out/share/man/man1/
+    cp ding.png $out/share/pixmaps/
+    cp ding.desktop $out/share/applications/
+
+    wrapProgram $out/bin/ding --prefix PATH : ${gnugrep}/bin:${aspellEnv}/bin:${tk}/bin:${fortune}/bin --prefix ASPELL_CONF : "\"prefix ${aspellEnv};\""
+  '';
+
+  meta = with stdenv.lib; {
+    description = "Simple and fast dictionary lookup tool";
+    homepage = https://www-user.tu-chemnitz.de/~fri/ding/;
+    license = licenses.gpl2Plus;
+    platforms = platforms.linux; # homepage says: unix-like except darwin
+    maintainers = [ maintainers.exi ];
+  };
+}
--- a/pkgs/applications/misc/ding/dict.patch
+++ b/pkgs/applications/misc/ding/dict.patch
@ -0,0 +1,26 @@
+Ding persists its settings to $HOME/.dingrc on startup, this sadly includes the path to the dictionary.
+On all other distributions, that would be /usr/share/dict/de-en.txt and would hardly ever change.
+On nixos, this will indeed change on ever update and would break it for all users.
+This just comments out the dictionary path in the .dingrc so the user can still set it if she wants to, but it will not affect normal operations.
+--- a/ding
+++ b/ding
+@@ -899,7 +899,9 @@ if { ! [info exists ding_version]} {
+         }
+ 
+         # Change path of default ger-eng.txt when upgrading from version 1.1
+-        if {$searchmeth($i,dictfile) == {/usr/dict/ger-eng.txt} &&
+        if {! [info exists searchmeth($i,dictfile)]} {
+            set searchmeth($i,dictfile) $default_searchmeth(0,dictfile)
+        } elseif {$searchmeth($i,dictfile) == {/usr/dict/ger-eng.txt} &&
+             $ding_version == {1.1}} {
+             set searchmeth($i,dictfile) $default_searchmeth(0,dictfile)
+             debug 2 "New path and name of ger-eng.txt configured: $default_searchmeth(0,dictfile)"
+@@ -5065,7 +5067,7 @@ proc saveOptions {} {
+     foreach i $searchmpos {
+         puts $fd "set searchmeth($n,name) {$searchmeth($i,name)}"
+         puts $fd "set searchmeth($n,type) {$searchmeth($i,type)}"
+-        puts $fd "set searchmeth($n,dictfile) {$searchmeth($i,dictfile)}"
+        puts $fd "#set searchmeth($n,dictfile) {$searchmeth($i,dictfile)}"
+         puts $fd "set searchmeth($n,separator) {$searchmeth($i,separator)}"
+         puts $fd "set searchmeth($n,language1) {$searchmeth($i,language1)}"
+         puts $fd "set searchmeth($n,language2) {$searchmeth($i,language2)}"
--- a/pkgs/applications/misc/gpsprune/default.nix
+++ b/pkgs/applications/misc/gpsprune/default.nix
@ -0,0 +1,32 @@
+{ fetchurl, stdenv, bash, jre8 }:
+
+stdenv.mkDerivation rec {
+  name = "gpsprune-${version}";
+  version = "18.2";
+
+  src = fetchurl {
+    url = "http://activityworkshop.net/software/gpsprune/gpsprune_${version}.jar";
+    sha256 = "12zwwiy0jfrwvgrb110flx4b7k3sp3ivx8ijjymdbbk48xil93l2";
+  };
+
+  phases = [ "installPhase" ];
+
+  buildInputs = [ jre8 ];
+
+  installPhase = ''
+    mkdir -p $out/bin $out/share/java
+    cp -v $src $out/share/java/gpsprune.jar
+    cat > $out/bin/gpsprune <<EOF
+    #!${bash}/bin/bash
+    exec ${jre8}/bin/java -jar $out/share/java/gpsprune.jar "\$@"
+    EOF
+    chmod 755 $out/bin/gpsprune
+  '';
+
+  meta = with stdenv.lib; {
+    description = "Application for viewing, editing and converting GPS coordinate data";
+    homepage = http://activityworkshop.net/software/gpsprune/;
+    license = licenses.gpl2Plus;
+    maintainers = [ maintainers.rycee ];
+  };
+}
--- a/pkgs/applications/misc/josm/default.nix
+++ b/pkgs/applications/misc/josm/default.nix
@ -0,0 +1,32 @@
+{ fetchurl, stdenv, bash, jre8 }:
+
+stdenv.mkDerivation rec {
+  name = "josm-${version}";
+  version = "9060";
+
+  src = fetchurl {
+    url = "https://josm.openstreetmap.de/download/josm-snapshot-${version}.jar";
+    sha256 = "0c1q0bs3x1j9wzmb52xnppdyvni4li5khbfja7axn2ml09hqa0j2";
+  };
+
+  phases = [ "installPhase" ];
+
+  buildInputs = [ jre8 ];
+
+  installPhase = ''
+    mkdir -p $out/bin $out/share/java
+    cp -v $src $out/share/java/josm.jar
+    cat > $out/bin/josm <<EOF
+    #!${bash}/bin/bash
+    exec ${jre8}/bin/java -jar $out/share/java/josm.jar "\$@"
+    EOF
+    chmod 755 $out/bin/josm
+  '';
+
+  meta = with stdenv.lib; {
+    description = "An extensible editor for OpenStreetMap";
+    homepage = https://josm.openstreetmap.de/;
+    license = licenses.gpl2Plus;
+    maintainers = [ maintainers.rycee ];
+  };
+}
--- a/pkgs/applications/misc/playonlinux/default.nix
+++ b/pkgs/applications/misc/playonlinux/default.nix
@ -17,6 +17,8 @@
 , xterm
 , pkgs
 , pkgsi686Linux
+, which
+, curl
 }:

 assert stdenv.isLinux;
@ -39,6 +41,8 @@ let
      wine
      xdg-user-dirs
      xterm
+      which
+      curl
    ];

  ld32 =
--- a/pkgs/applications/misc/qpdfview/default.nix
+++ b/pkgs/applications/misc/qpdfview/default.nix
@ -5,10 +5,10 @@ let
  s = # Generated upstream information
  rec {
    baseName="qpdfview";
-    version = "0.4.15";
+    version = "0.4.16";
    name="${baseName}-${version}";
    url="https://launchpad.net/qpdfview/trunk/${version}/+download/qpdfview-${version}.tar.gz";
-    sha256 = "0wgj02zpbyq4m2ix8rljiz312l2xk81gpy030vy424icq4xsip52";
+    sha256 = "0zysjhr58nnmx7ba01q3zvgidkgcqxjdj4ld3gx5fc7wzvl1dm7s";
  };
  buildInputs = [
    qt4 poppler_qt4 pkgconfig djvulibre libspectre cups file ghostscript
--- a/pkgs/applications/misc/rtv/default.nix
+++ b/pkgs/applications/misc/rtv/default.nix
@ -1,14 +1,14 @@
 { stdenv, fetchFromGitHub, pkgs, lib, python, pythonPackages }:

 pythonPackages.buildPythonPackage rec {
-  version = "1.7.0";
+  version = "1.8.0";
  name = "rtv-${version}";

  src = fetchFromGitHub {
    owner = "michael-lazar";
    repo = "rtv";
    rev = "v${version}";
-    sha256 = "0fynymia3c2rynq9bm0jssd3rad7f7hhmjpkby7yj6g3jvk7jn4x";
+    sha256 = "0vp9yapm6bm4zdhd1ibbirc23ck7smrbsrask7xkrnz7qysxgsd3";
  };

  propagatedBuildInputs = with pythonPackages; [
--- a/pkgs/applications/misc/terminal-notifier/default.nix
+++ b/pkgs/applications/misc/terminal-notifier/default.nix
@ -18,7 +18,7 @@ stdenv.mkDerivation rec {
    cp -r terminal-notifier.app $out/Applications
    cat >$out/bin/terminal-notifier <<EOF
    cd $out/Applications/terminal-notifier.app
-    exec ./Contents/MacOS/terminal-notifier
+    exec ./Contents/MacOS/terminal-notifier "\$@"
    EOF
    chmod +x $out/bin/terminal-notifier
  '';
--- a/pkgs/applications/networking/browsers/chromium/common.nix
+++ b/pkgs/applications/networking/browsers/chromium/common.nix
@ -145,6 +145,7 @@ let
      linux_use_gold_binary = false;
      linux_use_gold_flags = false;
      proprietary_codecs = false;
+      use_sysroot = false;
      use_gnome_keyring = gnomeKeyringSupport;
      use_gconf = gnomeSupport;
      use_gio = gnomeSupport;
--- 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 = "49.0.2587.3";
-    sha256 = "05mhd6z833w1r4v7jz8rbm06j29h0l4ix45v29l5npv41sqr4lj2";
-    sha256bin32 = "1lrf3zfzy3yif854nkrl6acdfwc93xhry9ykfjjr1a4mpnlqbp1v";
-    sha256bin64 = "1sn1p5jh2gy463np99xw7jhcl9hd28b4gm2wqv19z0a67k84jdpd";
+    version = "49.0.2593.0";
+    sha256 = "1krkf8dg10xnvxs4zfvy2rkp0v3gxg55418b11kmfywsxjfi09hv";
+    sha256bin32 = "0sarfj8r6x28pbmcpd5facm6liifazj744c9qn6ci6xg7f8jlnxi";
+    sha256bin64 = "1l5s504mmr4v5y67fsla9hyrk7dm155yc790ld87s1ya03h455gr";
  };
  beta = {
-    version = "48.0.2564.41";
-    sha256 = "06k5vjv1argvxssjrlvyxn5gi93gx8r8dqanv3cpvwpw8nwyqrdj";
-    sha256bin32 = "0k77hpacnz0plh67wd2p6dxbpkcb8930p08inxy3mzjlralq9fyj";
-    sha256bin64 = "1zdisb36s5nh7h7swfyjb2shxpapp1anpil4prfd3jkf6bv64k1i";
+    version = "48.0.2564.48";
+    sha256 = "1qasdz9rwdqa2if8y4kkk19fspgjpk3q782c8l1p5n2cm25lkfa9";
+    sha256bin32 = "0pgc3iy4s7whmckc14r0cvgmk7pqgidd2w0xv53bfq2k504b5ykw";
+    sha256bin64 = "1lx6l8s2wdgzldbm8licpf22l6z13mvq05xlbn8ybizhn159nykj";
  };
  stable = {
-    version = "47.0.2526.80";
-    sha256 = "01adc5fh2agk2d5a15pg230x3h43h4lxmzlvwbm43dm34f1i81xi";
-    sha256bin32 = "0779z35snwc3qnh5fzf9gm4mmw8vj0j8k3w3vlksn532hclyl6b6";
-    sha256bin64 = "0xj9i06xdsarfl1jfw6ra3j1ri0iqnjafqw2p2r4kaqsgf1a2fdv";
+    version = "47.0.2526.106";
+    sha256 = "1rjqkawj7l127cd9s1wxwn4v7dfbrlahml98sam3fg8a6drm0lv4";
+    sha256bin32 = "14svd5x8lzfyyigfirxx1q9pg2bsnnb0fdwa7vvh1awq3zzfd38n";
+    sha256bin64 = "121289vwaz391b32hp2lihlpaql76y44gdpqkl9a3md0j1zk1nd9";
  };
 }
--- a/pkgs/applications/networking/browsers/firefox-bin/sources.nix
+++ b/pkgs/applications/networking/browsers/firefox-bin/sources.nix
@ -4,185 +4,185 @@
 # ruby generate_sources.rb > sources.nix

 {
-  version = "43.0.1";
+  version = "43.0.2";
  sources = [
-    { locale = "ach"; arch = "linux-i686"; sha256 = "77cd7332ecebd3e51cb45896d61494e95e57707dcc1393af00695f8232274c17"; }
-    { locale = "ach"; arch = "linux-x86_64"; sha256 = "792d25a8d536d32dc89b655f5e3961b704fa27618395d3ae637180242eae2b71"; }
-    { locale = "af"; arch = "linux-i686"; sha256 = "fe211798f211a316a5ecf5a5c4dd61389e448b45166c681f886fa1e97bff4734"; }
-    { locale = "af"; arch = "linux-x86_64"; sha256 = "7a6e077c0702e7c832a9b9c5f35a70f19dd4c0c9f910a8a254fe165a5f3d8331"; }
-    { locale = "an"; arch = "linux-i686"; sha256 = "a01769decb90c7235f2cffcb6eaa135ba0a838e182f8398e12ff664e8be500c0"; }
-    { locale = "an"; arch = "linux-x86_64"; sha256 = "8e4b243cca233a6f00b07ccb5ac2330edc5de590d2d6b787d753e965fd6e777c"; }
-    { locale = "ar"; arch = "linux-i686"; sha256 = "e572f980f5d28b994b930d3a5665e92f8ab5c149a19a99132bf93cdf2bf75fbc"; }
-    { locale = "ar"; arch = "linux-x86_64"; sha256 = "b42f56de042899d67461fab43d41f9b23817e879df23cd0c4be748b701a8d5da"; }
-    { locale = "as"; arch = "linux-i686"; sha256 = "652919614ebd2775d3a13706ffb09959655f9bb12f0a120698c1deec6c244554"; }
-    { locale = "as"; arch = "linux-x86_64"; sha256 = "62793f511b7a4244beca42d5dbb235df8431f7156a09fc4c1227cfaf19fe8885"; }
-    { locale = "ast"; arch = "linux-i686"; sha256 = "e6a8ab24ef5585cc5204b5150066c8e96fb30c15b89a7c885fb8def445f2734f"; }
-    { locale = "ast"; arch = "linux-x86_64"; sha256 = "e8c286528d5149c58bbae4a75b2d95c408e81de85cfe68e431d97f51c19ec0b0"; }
-    { locale = "az"; arch = "linux-i686"; sha256 = "829728affcb12321102bee38eb5b0e428d9a9d910a69bb299e77452c5bca6f02"; }
-    { locale = "az"; arch = "linux-x86_64"; sha256 = "aed06f78b55620e2632a9fcb4cbbf36f34ad1510ab7df2dc3de94c8c57f79263"; }
-    { locale = "be"; arch = "linux-i686"; sha256 = "257afd489537fa53ae84daf819a859a62757122d824d501d95c5010235c345e1"; }
-    { locale = "be"; arch = "linux-x86_64"; sha256 = "7021ac97b762b7d17a498c86c52551056b0cc388a8e10e81e034b845e05f0925"; }
-    { locale = "bg"; arch = "linux-i686"; sha256 = "a2c74efe9233c4b3bf1a6b9beee417b869ef129e6b60a3078e9528a84d354149"; }
-    { locale = "bg"; arch = "linux-x86_64"; sha256 = "a492710cc54c9bc6e406d558063bd16158059fe2e87bf172405b3c6ea38eb391"; }
-    { locale = "bn-BD"; arch = "linux-i686"; sha256 = "465bad32dc16f8ddb669d032a217ca5863410384b40a86b81290f85b2fc85811"; }
-    { locale = "bn-BD"; arch = "linux-x86_64"; sha256 = "063b1642e0ea6ac8b07baa3969698337bfc3a96db724b7a32a668c2e4cf516f1"; }
-    { locale = "bn-IN"; arch = "linux-i686"; sha256 = "cebcf89bafe0cb88e1d725bf4b4caf72f845a6abd7d5c0ff9b9ed02c99eba686"; }
-    { locale = "bn-IN"; arch = "linux-x86_64"; sha256 = "85b51db611b917d3ffddc6b1bf39405eadb69d64473731780fb21f4db42a94af"; }
-    { locale = "br"; arch = "linux-i686"; sha256 = "997ae06800cf75ec62084db0f453caebe9e6ef0cc43abaf14a623785ca365a2e"; }
-    { locale = "br"; arch = "linux-x86_64"; sha256 = "4455965e809900bb42595c7c05365ec1d26b7508c9d7ca24ac636be4b6583147"; }
-    { locale = "bs"; arch = "linux-i686"; sha256 = "0e88abaa021e9e435e41baf59590e4d2ee7c3ec442b01620297671f4c4fa023e"; }
-    { locale = "bs"; arch = "linux-x86_64"; sha256 = "229ad924b0c72823e7599f8a53df0c1fe46fc4d9972e18a32caa78bbd7f72dec"; }
-    { locale = "ca"; arch = "linux-i686"; sha256 = "5f03a177cd4ea81732329f7ee62494ad25f79e65f12ad4e0cb244aaa95c66e0a"; }
-    { locale = "ca"; arch = "linux-x86_64"; sha256 = "67f29e97d323fa8ccf1e14f1638beeecf5489701a13509cd824b61e6c64e0b96"; }
-    { locale = "cs"; arch = "linux-i686"; sha256 = "100c1ce1bcdbfc9b4a6f3e576e71ca9cbc771ac7d28d916fbfbbf40c7e37a42c"; }
-    { locale = "cs"; arch = "linux-x86_64"; sha256 = "178373db4c0ca4edd6150595529d62fa38912a71ab0d6122fe8ba2ee5947f7dd"; }
-    { locale = "cy"; arch = "linux-i686"; sha256 = "fbdf1b10f6f07c21669a5d515e9c14b3ad8b2a606e2bb997cb75df4928021f48"; }
-    { locale = "cy"; arch = "linux-x86_64"; sha256 = "7444923521bf421fe60c721fa16b6005f40a108813e547ef32c0c1263d687630"; }
-    { locale = "da"; arch = "linux-i686"; sha256 = "4277aa0783b92e5a101ef52ea191347fb873700f8366d06480dc2445fe7c391e"; }
-    { locale = "da"; arch = "linux-x86_64"; sha256 = "9300787407ca226bf1ac9a25f8f4e9428793c032ca102c65b1841a12ebb508b6"; }
-    { locale = "de"; arch = "linux-i686"; sha256 = "ceaef87cf7553368a919396c3c303033fe6e1bb23477549ff25d2426473127e6"; }
-    { locale = "de"; arch = "linux-x86_64"; sha256 = "55b7296fa2643d7caee38fa0e282959cd0160fb7f8a89bca11085d6bba40a679"; }
-    { locale = "dsb"; arch = "linux-i686"; sha256 = "7b92682d19f457d162c537bea71f9c026b36cefdda440f2a1ea489f44fc57f63"; }
-    { locale = "dsb"; arch = "linux-x86_64"; sha256 = "be235c2af381500a5cbc4f0c400106a31b00a49fcf19d2a981f5ee7221f7617e"; }
-    { locale = "el"; arch = "linux-i686"; sha256 = "832c7f65d97795a284e93bec61c14ffcffaf74fa3fc844f1ae896058f0409e72"; }
-    { locale = "el"; arch = "linux-x86_64"; sha256 = "4758c97ab627cd7818f4a38febca52c11084e2c8e0ee2d05f70a6e1f2b67661f"; }
-    { locale = "en-GB"; arch = "linux-i686"; sha256 = "02b926d46100116ab7bab27ecbfa60ded6674d5d687f76412443a52e5fdb4283"; }
-    { locale = "en-GB"; arch = "linux-x86_64"; sha256 = "98d83b9434d948d7fbc24708363d1c8e8d37551711994c7b8448f6e924f49be7"; }
-    { locale = "en-US"; arch = "linux-i686"; sha256 = "a8530e2b5d5c16c1afef6759a9015e83767271046537a050442fd6c457986746"; }
-    { locale = "en-US"; arch = "linux-x86_64"; sha256 = "ea797acf50c2efb39968773864aeac0bd17dc3a1dc726b3ff95780aec01ea669"; }
-    { locale = "en-ZA"; arch = "linux-i686"; sha256 = "4baa2cc65dd053e226f4391a975c162c8c709f31f82c31d7707ab168f8c249c2"; }
-    { locale = "en-ZA"; arch = "linux-x86_64"; sha256 = "93ddb0c696131e9a7a258fc44eed88d5aecac50f101106211e69220e602c949a"; }
-    { locale = "eo"; arch = "linux-i686"; sha256 = "eabb1fad074ccc3887fb56eda2d71f51af3aa22541d310f0c25ddab0a52ba7a8"; }
-    { locale = "eo"; arch = "linux-x86_64"; sha256 = "280f9010cad2583eaca8892cbb2600e3b98d77181ef30f5cf233951e26414df9"; }
-    { locale = "es-AR"; arch = "linux-i686"; sha256 = "82741dd5a2bdb7541d931ed8606ec483f44b0d6416a3f4d9b3fa1c1e57cd3390"; }
-    { locale = "es-AR"; arch = "linux-x86_64"; sha256 = "10499b8c57d6d6c8976e80e5b50c278846c45d408a2ead66328c780cb5a40ed2"; }
-    { locale = "es-CL"; arch = "linux-i686"; sha256 = "e5879a71124b429250f6bea231f0411e80c28718a7cecdd7713e9512d21c22f6"; }
-    { locale = "es-CL"; arch = "linux-x86_64"; sha256 = "177b19854746c70fbe1243db51b22e3a96e660def60763d79a340b08c7537d6d"; }
-    { locale = "es-ES"; arch = "linux-i686"; sha256 = "b1f2baa7fdeb2a670289fdbea089084f01171c1a5295142aff38a36efe7c4f3f"; }
-    { locale = "es-ES"; arch = "linux-x86_64"; sha256 = "231e9d0d9588732d4aa440e7d56eaa4d6a94457b0805802643c4ab6b5be46087"; }
-    { locale = "es-MX"; arch = "linux-i686"; sha256 = "917e235734993f4a121eb01fd91cf1788b018f52477116b1848a2faebdf6c4d0"; }
-    { locale = "es-MX"; arch = "linux-x86_64"; sha256 = "de6ec93363ae0f814737bb63ff17d5beb2e756d5990ca15f7dca445bfcf83331"; }
-    { locale = "et"; arch = "linux-i686"; sha256 = "dacfc817b23972d066a89c2430d0e4ae450fa7c05cc148c726e0a739aa248dcc"; }
-    { locale = "et"; arch = "linux-x86_64"; sha256 = "e114477a85c27f199e807b203c78c148b9b594d3dcf8fefa08bb6b15c1b60deb"; }
-    { locale = "eu"; arch = "linux-i686"; sha256 = "0fba5ce5724309e251cc010b5bdff861b21934fe21ce810c11bc8f25ef6f2854"; }
-    { locale = "eu"; arch = "linux-x86_64"; sha256 = "d43fa45c2e78c112a2dfc00e5486dad0150aca3d14ea87e6184392a394ca0e0a"; }
-    { locale = "fa"; arch = "linux-i686"; sha256 = "fb37966eca9e8077b96187b73925e3ff9d2725954db4ce6a9dcf8fe7004d1213"; }
-    { locale = "fa"; arch = "linux-x86_64"; sha256 = "46e103d2bbaf66e123a2f178b29c20fc7e87dec3cd1ef4cf7edbee379104774a"; }
-    { locale = "ff"; arch = "linux-i686"; sha256 = "46658e4701c21276a2731efa1c64783dce29fd3cfca35edebb36dd094f826280"; }
-    { locale = "ff"; arch = "linux-x86_64"; sha256 = "aae29a8ab6a2245536a7828dc688973589d46c32f60e3e08424d417b2fdca1ce"; }
-    { locale = "fi"; arch = "linux-i686"; sha256 = "45c19f14327a5ec2a6ca64e9126467d88ff43995e98a9954a3b50b5440a2cc46"; }
-    { locale = "fi"; arch = "linux-x86_64"; sha256 = "2ea74f89de5af4ffdcc27746a524114f5160ddc38d041a344367c85856830c7e"; }
-    { locale = "fr"; arch = "linux-i686"; sha256 = "05b2998f27e59ef1a771deceef92888995503b220b4bd6e60bf62d5bf5bb3b91"; }
-    { locale = "fr"; arch = "linux-x86_64"; sha256 = "8b39731c52323fda138e82a6152cefa5f90bed9b3997415feb508498faa96c34"; }
-    { locale = "fy-NL"; arch = "linux-i686"; sha256 = "b51c3801e852f6ded7f5cc166dba95398e14a316103e34dab71b7bb82260880f"; }
-    { locale = "fy-NL"; arch = "linux-x86_64"; sha256 = "44f8629a19a48748b10246df108b2dfb3b685b261462a925c64c337649ee6b55"; }
-    { locale = "ga-IE"; arch = "linux-i686"; sha256 = "62d5eda1223150bb402ab56a5bd106e5b5e95229b5f4f7542d786d7d6b4e55d0"; }
-    { locale = "ga-IE"; arch = "linux-x86_64"; sha256 = "8b1329faf13cd75e960f5958c98002ef486cbd76d8429e800b8930707d23bbc4"; }
-    { locale = "gd"; arch = "linux-i686"; sha256 = "6f572140ee8ff1a299613c6f459a7de0097519f04fb4094bfd9736fb13bd9d58"; }
-    { locale = "gd"; arch = "linux-x86_64"; sha256 = "4d03d82c86cf1e574264786ff2cf6d70201d0ec657ab729530ae90303a160fdc"; }
-    { locale = "gl"; arch = "linux-i686"; sha256 = "f0f1ab79f93a5467f097b7c5c4ac20847c1029b975ea2bd40b772a9a6ae8c759"; }
-    { locale = "gl"; arch = "linux-x86_64"; sha256 = "093cad0eac9c3f399a24ed5cc954f520a997562e05920cb833b44f19dfe35807"; }
-    { locale = "gu-IN"; arch = "linux-i686"; sha256 = "1ab234f32b8fbedbcf80965661f0db0245826e965d6f6266a329723ea2f5a19f"; }
-    { locale = "gu-IN"; arch = "linux-x86_64"; sha256 = "d10681ce58b2b2ff00b0219b0807707efb4005dcb1bb7d63ce4c297d2c6f6213"; }
-    { locale = "he"; arch = "linux-i686"; sha256 = "10f8c4ce42dc5a74754bc18d1f2883eee7c02884900435f432be01a7fdb4b8ed"; }
-    { locale = "he"; arch = "linux-x86_64"; sha256 = "9bc878bc21c03717f75f6a24ba604f7822dc2872afe02a00d01fefec593679d0"; }
-    { locale = "hi-IN"; arch = "linux-i686"; sha256 = "e5cf142f1aedbaee1044ef07e2ab78f9a11658d11544dd4a0f2d5a756862e8ba"; }
-    { locale = "hi-IN"; arch = "linux-x86_64"; sha256 = "adea7b2dffbd2b354c1fbb395c661ddf433e65ba2ea0e121e3275ecc0d691df4"; }
-    { locale = "hr"; arch = "linux-i686"; sha256 = "12152b2510a30b0961715af872c93f16e178d9251b76e69e036f48576795fff9"; }
-    { locale = "hr"; arch = "linux-x86_64"; sha256 = "37013843d5ec1056139cfd54d12c490314cf22cd0cef54dd95540baeeee6230c"; }
-    { locale = "hsb"; arch = "linux-i686"; sha256 = "5f9cda6b0a8a86bf22697d05625abb0b12776a5dd28e696ccece9a2eb5147bc6"; }
-    { locale = "hsb"; arch = "linux-x86_64"; sha256 = "d927c16ad103a0b2c2fa701e474d68b89cf45813b94714d1fed82140ae699d66"; }
-    { locale = "hu"; arch = "linux-i686"; sha256 = "26522239478dad6fc04c06cf1a4e13998cdc69dd026afe127f5c62cf40114332"; }
-    { locale = "hu"; arch = "linux-x86_64"; sha256 = "3742d3f582d5229e58fe918d022b8bd55e856957b95f7d75aed4aefa2983713f"; }
-    { locale = "hy-AM"; arch = "linux-i686"; sha256 = "d847834c540d40344678d20e4c0a9f30cb3af3b28e0147da9905522c1e43d553"; }
-    { locale = "hy-AM"; arch = "linux-x86_64"; sha256 = "672bb8abca09194ffcf402ac89296c31d46c5dd10cec7d98e7588faf98112d15"; }
-    { locale = "id"; arch = "linux-i686"; sha256 = "d6388edc053ffd8d1c8b96d09edacec503109f33b42ba89a3a35fee8593e1b58"; }
-    { locale = "id"; arch = "linux-x86_64"; sha256 = "7968be1865b6381f970e514f1f9268bd41cfda5b8e5695544dd93627ec0c8124"; }
-    { locale = "is"; arch = "linux-i686"; sha256 = "7239ce4db17389e1717a63827faad3ef4957ef496f2f7b4d7e1e9fc96aa864cd"; }
-    { locale = "is"; arch = "linux-x86_64"; sha256 = "babbec58f631050242183926f0956a3c5ff2a064a8aafdc2d1bdd945b0c353ad"; }
-    { locale = "it"; arch = "linux-i686"; sha256 = "75b5f2fa097819a5de8450422b368f0b2bd4fb8e5ff67b60abc9a014939113f5"; }
-    { locale = "it"; arch = "linux-x86_64"; sha256 = "63737299f29d8f52f9ef00e43160ecc3c8a9046c050e6b78c651079750853505"; }
-    { locale = "ja"; arch = "linux-i686"; sha256 = "6ee7bc9487d9ac5d121a706920e8efaabe9bdc5bb7527f02f38fe27771aa1042"; }
-    { locale = "ja"; arch = "linux-x86_64"; sha256 = "f9add10fe74ad4b1fb42618a93f686ae3929e862b24248eed7abb3ab8129808d"; }
-    { locale = "kk"; arch = "linux-i686"; sha256 = "8e10163a29fd333f31bbfa57ad92f2b3cfedec23726779cafa567de80e217548"; }
-    { locale = "kk"; arch = "linux-x86_64"; sha256 = "b20fcb23b481ad30089bf94b704847ae8deae3841c3d032b39d3ec43eef0eda5"; }
-    { locale = "km"; arch = "linux-i686"; sha256 = "6df67080e6e2b8236432bdf7d215b674ef2d534c63dcabeb3a894966e4e8866f"; }
-    { locale = "km"; arch = "linux-x86_64"; sha256 = "983571f48d4517f25e22a0c828240bd00e8cdf5f643c7ad0b094b2a73d7cd2f5"; }
-    { locale = "kn"; arch = "linux-i686"; sha256 = "27e20cc9794805763539683407d3e40a02b8cc77ea7e4ec6d63a73bad36d6a74"; }
-    { locale = "kn"; arch = "linux-x86_64"; sha256 = "6d4733730e57ea4aac60e0fb55b8db00c41d9848f1b9b28811cbada781b557d8"; }
-    { locale = "ko"; arch = "linux-i686"; sha256 = "81cc34afd043bebd79760ec759eb47b5ac32374ee1e3698327a3520d51f308b8"; }
-    { locale = "ko"; arch = "linux-x86_64"; sha256 = "2401953e6f1fdf8a7b5c3bf01c9ae7b0873697f8519ac8c27495053e1a23990c"; }
-    { locale = "lij"; arch = "linux-i686"; sha256 = "3d3917d0fad2cea34325d95e21208f7bc33a5f8823b633c5c4c3e38979f0e4d4"; }
-    { locale = "lij"; arch = "linux-x86_64"; sha256 = "85e8b23f22a5349a649f892b5134ece615ba2832257cdbeebe4d44900d140070"; }
-    { locale = "lt"; arch = "linux-i686"; sha256 = "4ac4805e59b4a9546b5a035d5599be3bb828d06f53ceaef1a38d7e906da40030"; }
-    { locale = "lt"; arch = "linux-x86_64"; sha256 = "b9f0ae9691e2c956a7e7227552d86624a03e99258caab7a4fa8a028f28a50551"; }
-    { locale = "lv"; arch = "linux-i686"; sha256 = "552e9bd5a00373135a165bbf05d2edfbc6ee6708b0b6e2ff71c7762d44baa303"; }
-    { locale = "lv"; arch = "linux-x86_64"; sha256 = "7591d8edf125a3c98383b2fdcb84016659ada7314cf15390401183641fffbe2a"; }
-    { locale = "mai"; arch = "linux-i686"; sha256 = "c25de9a04ae447b39c1ba33e0e1ab56a1e085a2fc6d0bffe4d47f3c2e6353587"; }
-    { locale = "mai"; arch = "linux-x86_64"; sha256 = "b8bd88d4e472f12518e848900947fea0070dd6acba698fe7330a0aec0e2241c4"; }
-    { locale = "mk"; arch = "linux-i686"; sha256 = "baa001a2118908ec106717260b6aa8e8a66372f72a6424c4ec77545ddfc586c5"; }
-    { locale = "mk"; arch = "linux-x86_64"; sha256 = "cbb8e8c9184ae617809603c0ab0704d0271d7bc5a84b0d7697dd5ab980a1108e"; }
-    { locale = "ml"; arch = "linux-i686"; sha256 = "5defd3a75c2f7858335b5bd2f5d46e555e237af7be3cb671f324a107fecc04dc"; }
-    { locale = "ml"; arch = "linux-x86_64"; sha256 = "bc5dadffe98a2fb127fa0a83442880359123630e944516410b48a923659f0f70"; }
-    { locale = "mr"; arch = "linux-i686"; sha256 = "fa324f6e164be65b94e5d9dd56f52dfed744f71403d06e1ee6db6d653fa9c56e"; }
-    { locale = "mr"; arch = "linux-x86_64"; sha256 = "e52a794c144c062925e310d2aae725152e70b2c1c61657772ae639f2a36bf656"; }
-    { locale = "ms"; arch = "linux-i686"; sha256 = "a27bf493efba61fc01f2c64308338e510671708895567af4b209fa3bc41718da"; }
-    { locale = "ms"; arch = "linux-x86_64"; sha256 = "da349192ee2a36ed48e3ae8ff4d1acea55877544c77a2b07dd2f017ce4f6e1b7"; }
-    { locale = "nb-NO"; arch = "linux-i686"; sha256 = "37245f0291b519b436b1b862299960a7961bfb496ca18c247cc5014ccddf9427"; }
-    { locale = "nb-NO"; arch = "linux-x86_64"; sha256 = "02c93155e20775db45d05cd46a8b28e2e88c2a20dc4c847ca0ac4844691c4a2a"; }
-    { locale = "nl"; arch = "linux-i686"; sha256 = "c449d3b9b9b1aa3e438e7380f7c9c89c3d91f207f798a7a5dea11ea05371caa5"; }
-    { locale = "nl"; arch = "linux-x86_64"; sha256 = "15ccabff42c778fdff18757bfca234e0bf1bde589b76c7fb950783437cd9c0b8"; }
-    { locale = "nn-NO"; arch = "linux-i686"; sha256 = "1ec5fea33f0a150c1039386ebefef81acb004142ca4d18023d6e86852969cffb"; }
-    { locale = "nn-NO"; arch = "linux-x86_64"; sha256 = "3a8d31dd02895a7113ed3eb4cc004b2748c39badff206f69f2f9fe0aceb1b013"; }
-    { locale = "or"; arch = "linux-i686"; sha256 = "fa93ce73fa59876f7beb0f48e484dd4561a4d4c2c187d8c896f5e1e5f9306342"; }
-    { locale = "or"; arch = "linux-x86_64"; sha256 = "bd3cdf10fce0ac75bfa2e5fac591b09c8351a3ae2f2018e45546e77d85c384f5"; }
-    { locale = "pa-IN"; arch = "linux-i686"; sha256 = "5f2917636c1b193b3b7136bf6444a0924f693916f981456965cb452d58812400"; }
-    { locale = "pa-IN"; arch = "linux-x86_64"; sha256 = "a8f440c37462a4712df9cd274fd939a4c5bd1a5e4d38435499f598be36b18e1a"; }
-    { locale = "pl"; arch = "linux-i686"; sha256 = "757cc7c6d9e6cfd701b0a84cce6973f356b0f16781ba80ad92b66c5bc8389d65"; }
-    { locale = "pl"; arch = "linux-x86_64"; sha256 = "45702d113636970e97222bb7ff48f8e54e16912e39f9c576a17b1ee3fd2530a0"; }
-    { locale = "pt-BR"; arch = "linux-i686"; sha256 = "241ba56480c8e7a983e26fa8382c3a5f177d31858fd4453b6ba42578d1d0c9ef"; }
-    { locale = "pt-BR"; arch = "linux-x86_64"; sha256 = "90f03fbbe12256824024050698e231c3093630ebd09be56e372d4f76e89b55b2"; }
-    { locale = "pt-PT"; arch = "linux-i686"; sha256 = "af2e770bd86a2d683883ce9e28be32837be55c3e705430dd5b60d6684154969f"; }
-    { locale = "pt-PT"; arch = "linux-x86_64"; sha256 = "dbaefe62b8285931e1a09b70f6082c7c52404117d0ee92a343250b419a2399e3"; }
-    { locale = "rm"; arch = "linux-i686"; sha256 = "b559d1ffb96587ecf335b6cefcd8f4155161780f6121d19f244d59b051f2145f"; }
-    { locale = "rm"; arch = "linux-x86_64"; sha256 = "247029e16aa38a83aec68e7269a93a1ee6f6cb9846aca97fd4a2c44a22ff2b64"; }
-    { locale = "ro"; arch = "linux-i686"; sha256 = "d3555d64bb64958c577af8ffd958eebaec8cba00a9755b2005bf480527fa52cf"; }
-    { locale = "ro"; arch = "linux-x86_64"; sha256 = "e81aeb9737cfece9ae9e886fcf32a85aea943ef4211af8a4fee46cca8b9c9027"; }
-    { locale = "ru"; arch = "linux-i686"; sha256 = "ab93abbabb9f0d605cc8a0775d3a25e383e5d16c19eda2c5d88fbb7353f4983e"; }
-    { locale = "ru"; arch = "linux-x86_64"; sha256 = "304c4eec5ddb2416b71fec38bb2eb0bb9260a9746bccc4c31b9ebf97351d09fb"; }
-    { locale = "si"; arch = "linux-i686"; sha256 = "4f946959e40dfff8fa83654c733e3c7dc5cd4bfe2d166d454a1f9c98cf3a7d65"; }
-    { locale = "si"; arch = "linux-x86_64"; sha256 = "e06e5d2ea19ea5f4e8db666a53c1854f7861a06f53d2bfac8bc3c128bddc9f87"; }
-    { locale = "sk"; arch = "linux-i686"; sha256 = "10aa224b3e7eac73f196d4c8ef836b903938c326ee86024f56847afb667cad35"; }
-    { locale = "sk"; arch = "linux-x86_64"; sha256 = "376e803c1626a6cd47f1627c4d735fba422e48385bfb5333b58a52115ce13ae8"; }
-    { locale = "sl"; arch = "linux-i686"; sha256 = "fb15fc51459c916a9c9c6e3969dedd873fdd89d7864d17d6cbedb29e905b6749"; }
-    { locale = "sl"; arch = "linux-x86_64"; sha256 = "ae545eae7e637aff1825913b454eb9be87321a1fd6d9777c6aea33aa4159f629"; }
-    { locale = "son"; arch = "linux-i686"; sha256 = "9df97e243e34df135c91476a4bfb632e0a1e0935afc643f142b1536d0f6c3c1a"; }
-    { locale = "son"; arch = "linux-x86_64"; sha256 = "f8f0ba26226d12bc5896d67fb52e4f5166f307dcc1ea4a09faf11a3a57bdefa4"; }
-    { locale = "sq"; arch = "linux-i686"; sha256 = "0478e708713d8a8d966442d26f02654945e8b888213e1df017b09de066ddbeb0"; }
-    { locale = "sq"; arch = "linux-x86_64"; sha256 = "516a655ac44e81f530673aecfd3ce2d50487b79e00a89ad196ba8772bd87eb3b"; }
-    { locale = "sr"; arch = "linux-i686"; sha256 = "777d1582a745eaa1134282cf9b299fabf1eaabfefa045701fdf5ccc33ea7f439"; }
-    { locale = "sr"; arch = "linux-x86_64"; sha256 = "2675e68d168baa851bd8c7b320818add6135ac96f938ef9039807286c82d9321"; }
-    { locale = "sv-SE"; arch = "linux-i686"; sha256 = "a2af1b6c6f2a054176e2ae19d4a8d1ff659fdf25fbb6dda1ae01fe1d3e20fce6"; }
-    { locale = "sv-SE"; arch = "linux-x86_64"; sha256 = "dc8ed365766fe29849f3840d05516be2c68018b3165a2a83bce4c4f1fff63a9e"; }
-    { locale = "ta"; arch = "linux-i686"; sha256 = "d24f0fe9ee72cb88a214873a49d7734b9a0e78fbcf39baaa5bf72a50aea34ff7"; }
-    { locale = "ta"; arch = "linux-x86_64"; sha256 = "5a88e39ccad7f3aca46d5f0558194b13c33e557c58c24683eadd4484566be219"; }
-    { locale = "te"; arch = "linux-i686"; sha256 = "78b61877ba4b89b9a7d2198d59c3331b2e697f8bf9c55a3e6e734cb3f4e3df91"; }
-    { locale = "te"; arch = "linux-x86_64"; sha256 = "693e5253f4564ae69a21a25e18fbbf5902e2e5e39b388d1cc30e35f9a49029c4"; }
-    { locale = "th"; arch = "linux-i686"; sha256 = "372f36a5ea8fe5b92c2aa1ec7fcde80ca0bd006cdc220b14d1175eeb11fb7679"; }
-    { locale = "th"; arch = "linux-x86_64"; sha256 = "03b1f0037809b14f7e2daafa7dd43471ed914e445fdf4d12c5bba50c4b66e0aa"; }
-    { locale = "tr"; arch = "linux-i686"; sha256 = "d030908f9ed247e93a4417d48ef3b4ab136dd5325d5a7e8894f186a6a5179a3f"; }
-    { locale = "tr"; arch = "linux-x86_64"; sha256 = "9e15c843feff5d071a4a8e3be64cb2faba9021846c7d5bfe13f206ce91300eb9"; }
-    { locale = "uk"; arch = "linux-i686"; sha256 = "1b377aec5af5af4021b5385f2a46198d181d1c4d8994b2a1a4108bf9cacdcac3"; }
-    { locale = "uk"; arch = "linux-x86_64"; sha256 = "0b158a684610ca92d95868605f18dd61040e0bab820ef7e858505d04d8b5685f"; }
-    { locale = "uz"; arch = "linux-i686"; sha256 = "8d905bac16fd022354aa54743ae12afabc6f823609586f9ca12ea6b9717ef9e7"; }
-    { locale = "uz"; arch = "linux-x86_64"; sha256 = "e22740daf104694323437ae5885aaba67fb7392719c0872ba6f07e2ea73557c1"; }
-    { locale = "vi"; arch = "linux-i686"; sha256 = "372904386e107a595179b6a0f6bed84e7f986878e054c7e052c3e0378b2a9b2e"; }
-    { locale = "vi"; arch = "linux-x86_64"; sha256 = "9c6e2f5cfec7d468dbbf3bda667b00865fec1f10d90a0ba9971ca4c33e8e87b9"; }
-    { locale = "xh"; arch = "linux-i686"; sha256 = "b056ba0741f09be1d2d2e7980ecc17e813c587080328959e7f4362409fabac3e"; }
-    { locale = "xh"; arch = "linux-x86_64"; sha256 = "075effe19f422430948c0a90255ba26bcbf0a4b21153652c1d582ab626eb6be6"; }
-    { locale = "zh-CN"; arch = "linux-i686"; sha256 = "e3e8b0e0bba1a9a583cb0f82e24d3898f453a9fc478f119ca15f9a8c280dc1e8"; }
-    { locale = "zh-CN"; arch = "linux-x86_64"; sha256 = "92236719b5553aad48215b51d13173f7c2673afc4f05d16d92d74a102efa8a22"; }
-    { locale = "zh-TW"; arch = "linux-i686"; sha256 = "7400fe4f31e95472ca7ddaf2fc0ededa7b8fe709d32674a264639bd065885aaf"; }
-    { locale = "zh-TW"; arch = "linux-x86_64"; sha256 = "7f5dd7597600175f7d049d99558c44910ca5a3d07b4ee1140d1ad7e5fb4e6c16"; }
+    { locale = "ach"; arch = "linux-i686"; sha256 = "da9307cb24c75665adc6a5e02d3045eac9babd33c6da778167644d13cc685de2"; }
+    { locale = "ach"; arch = "linux-x86_64"; sha256 = "1a8f13b44107e9689aa339f19c8247142ce82ef9a63bb4be077c212d4d4ad03c"; }
+    { locale = "af"; arch = "linux-i686"; sha256 = "b8dcbf287b350becd7a4e1d812a2251bf10861fe6fe3c85ea9b56e4aafa2a156"; }
+    { locale = "af"; arch = "linux-x86_64"; sha256 = "241a503d4cd2793c538a5cc1ad0990b2a5cd40a584504cf5dde77a28d2f47049"; }
+    { locale = "an"; arch = "linux-i686"; sha256 = "530f5e4743384e543e4cf829f00e5f37adccf64b4af5067aab1e316aba72c579"; }
+    { locale = "an"; arch = "linux-x86_64"; sha256 = "1bbde5a3c897ebed7c7820362257626835c1adfafb29a20e80bcc4b1c40407b4"; }
+    { locale = "ar"; arch = "linux-i686"; sha256 = "f254b2f7117b866e2c8611d5367fc1e2a8e20e1997746204234ae6869c01f6e9"; }
+    { locale = "ar"; arch = "linux-x86_64"; sha256 = "bec6a50c9ce11906edb09591ed1f37d94291fb67b2d4ab9a8f5f87b0e837c0be"; }
+    { locale = "as"; arch = "linux-i686"; sha256 = "b894da79ba753489a3f0509aa54abb9cf67c84e80a73bc00d0e7e7483e1c4ac9"; }
+    { locale = "as"; arch = "linux-x86_64"; sha256 = "ef435b67eac29cf4024ad8df1d4efd413ea58fd76c0e4ec2f2595e7c90743953"; }
+    { locale = "ast"; arch = "linux-i686"; sha256 = "96566e2de543bb4b3bba195b99efb8ec1c01f6ec969dc75293ed66033b52a92b"; }
+    { locale = "ast"; arch = "linux-x86_64"; sha256 = "29f9ccdfc93a72db314df43564fce754ddc678b89a55035f23582bf4a7c66135"; }
+    { locale = "az"; arch = "linux-i686"; sha256 = "cc58914388b53df51d5bd78f0e63286166bbf278e691b8589bc7db18257627c5"; }
+    { locale = "az"; arch = "linux-x86_64"; sha256 = "7f1db3428190e1bbc01506a029df8c81a0ea67b301f161a5bb297c47d5db41d8"; }
+    { locale = "be"; arch = "linux-i686"; sha256 = "c8bd88c4ffb98d8611d760b144f46ab3cef4f7808f2b1008cd5aa75eadaf02eb"; }
+    { locale = "be"; arch = "linux-x86_64"; sha256 = "1b063e4e4a33b9d29f01d7c98a942446d738b195877a617dd454c2697fd6a539"; }
+    { locale = "bg"; arch = "linux-i686"; sha256 = "1186851b6a27a2d23572c9fa0a9bfabcfca1925d36e7fa79e5918541892bcda9"; }
+    { locale = "bg"; arch = "linux-x86_64"; sha256 = "d185c5eb1640d13ee9fd049db41d267af728de56f833bc32a182f69c4921d1c0"; }
+    { locale = "bn-BD"; arch = "linux-i686"; sha256 = "fcc0a0c46e913cb7b4d44c502f62ece83ae8d22703419edafd15321b77758625"; }
+    { locale = "bn-BD"; arch = "linux-x86_64"; sha256 = "d1e066c2347e109fab28e525b5780edb9c5c063322745d971e4ad79a110568f6"; }
+    { locale = "bn-IN"; arch = "linux-i686"; sha256 = "3a85767878b840411c57d176af597666aaeaede9a290032f374629eac536eeca"; }
+    { locale = "bn-IN"; arch = "linux-x86_64"; sha256 = "a3314e2a9f74d9f2c85e592a74e1353b2f048349ba65bf4cfdf35c72b130cd61"; }
+    { locale = "br"; arch = "linux-i686"; sha256 = "a6cd3445e65ca3c818856d6a3b9069aa437ea638f11bb8be520db73604150090"; }
+    { locale = "br"; arch = "linux-x86_64"; sha256 = "9c9f5720b568d768933d7d55bfa7853bb7918bcc651b7c2e281ccf3d2a5e2218"; }
+    { locale = "bs"; arch = "linux-i686"; sha256 = "9c0844cc1dde7712219626148988df642ab10e81494d4794a51a61bb92ddd110"; }
+    { locale = "bs"; arch = "linux-x86_64"; sha256 = "44d91b25d18aa108adf49677069ebd75236f82c7016ee9d518e2ff3f6ad40ffb"; }
+    { locale = "ca"; arch = "linux-i686"; sha256 = "5669828dec411832064e790e65203dabd3703a86090e87a931c6bd495fd39bc7"; }
+    { locale = "ca"; arch = "linux-x86_64"; sha256 = "1e1cec512fb7038327488ce884e171ecda23ae26f98d39159ca96b8acea2029a"; }
+    { locale = "cs"; arch = "linux-i686"; sha256 = "a7bdf99153ae8351c3f4f98db5e65d2a0598457dc0774508fc6ebe26c40ff43e"; }
+    { locale = "cs"; arch = "linux-x86_64"; sha256 = "16fd46498fa33334a5bd1cf06351b410f7df41526c195de21959bf837ce5d488"; }
+    { locale = "cy"; arch = "linux-i686"; sha256 = "8a251c77bbdb6a44163285cacb3a78ffe85835cbe0b9156ad300e733c9ee3934"; }
+    { locale = "cy"; arch = "linux-x86_64"; sha256 = "61f2b6b13d9ce1066b6207b16865a038cb35c51f61a5bc05503cf948704320f7"; }
+    { locale = "da"; arch = "linux-i686"; sha256 = "d1e5d20f7b396bb8b823e7a15a6e220fb930601c2df6e9fc5ca588d3ffce1698"; }
+    { locale = "da"; arch = "linux-x86_64"; sha256 = "a5f20fb678a51a526ebd135b149c6769dda46827174259cabbc4912c6f0619d5"; }
+    { locale = "de"; arch = "linux-i686"; sha256 = "74e9e40b191fd56e99708910c8798d4a8588271a90eef6f7658e042a0765d0e5"; }
+    { locale = "de"; arch = "linux-x86_64"; sha256 = "470781e1debb2085fa538008cd3203c64b534b5a88c6a6ac01418a3ef344216b"; }
+    { locale = "dsb"; arch = "linux-i686"; sha256 = "459e0d6c55ad822bae10a47a7b14004153a3f3363026556568d7108411318104"; }
+    { locale = "dsb"; arch = "linux-x86_64"; sha256 = "97fd138bb33c80a3213b33d4796573b65d4659b888959730cc02e726bcc65388"; }
+    { locale = "el"; arch = "linux-i686"; sha256 = "41b684530ed9bd80c03cb0cd8b1e4de8b3af383f611884965e98215ade1dd8c7"; }
+    { locale = "el"; arch = "linux-x86_64"; sha256 = "b1a7f2a4de87510b9630c6cade94b7f628bbf04289119d3912ea0eb5260b55b2"; }
+    { locale = "en-GB"; arch = "linux-i686"; sha256 = "3c40217b451bd28dd5f1aebcb9a9f7aafdfa3c9c7fd635d69674912a9e73f77c"; }
+    { locale = "en-GB"; arch = "linux-x86_64"; sha256 = "6aa6cd0945bbe97b30e431fdb09a4deb45a0aba6e1283f881a35732b7403e247"; }
+    { locale = "en-US"; arch = "linux-i686"; sha256 = "dd6c585c24e1e9212b65eabee8e52c5dbc9e4acce4fc51c32aacd82b3c6333e3"; }
+    { locale = "en-US"; arch = "linux-x86_64"; sha256 = "9c56ff8734eb860a6038f6bd00d98aeabe57037e230c66d551aac451a27efa79"; }
+    { locale = "en-ZA"; arch = "linux-i686"; sha256 = "0335775eb1a073d1889e8a43f913ea096bbd735a0b98687c75c7fde5eb636f44"; }
+    { locale = "en-ZA"; arch = "linux-x86_64"; sha256 = "5ab68e226bfc141167a477779181c48a84cabe80f250c874182ad0364d0c3dd5"; }
+    { locale = "eo"; arch = "linux-i686"; sha256 = "99a0cf562a067cd30d1047814c1984364b1702e93e638016a4fe8910868cfcdf"; }
+    { locale = "eo"; arch = "linux-x86_64"; sha256 = "ba0bc0093bf2b0ea82eb958fdf06683f4941bd9a44138c793175a0b9e5a86ad4"; }
+    { locale = "es-AR"; arch = "linux-i686"; sha256 = "3adaec2ccb2b1949492c27c466daa5809afc690bf0559418d2d60faae0b5456a"; }
+    { locale = "es-AR"; arch = "linux-x86_64"; sha256 = "67f774442c64d653d624a270eea1202fad389f926c6b7dee56ef965e65311ef0"; }
+    { locale = "es-CL"; arch = "linux-i686"; sha256 = "ee56546d943795434a6759a55dec6e848f244691dc234f4c62746aa1f73cb85d"; }
+    { locale = "es-CL"; arch = "linux-x86_64"; sha256 = "cdbf12f21efb2e18d23ef9c6322c96469c72140200fa47c554067df3a9f89b8d"; }
+    { locale = "es-ES"; arch = "linux-i686"; sha256 = "d3518ffe26d3c21beb009c657b93cf2f01be416f697d89beac497c71044f134a"; }
+    { locale = "es-ES"; arch = "linux-x86_64"; sha256 = "ae34d9f586b28b1063cfebb755edc2a11214085f3a185f31d757c2358493ed13"; }
+    { locale = "es-MX"; arch = "linux-i686"; sha256 = "09a03624363efba7e5d707c312f58e577019b8b7987d817fe1cf77bf2afa7dfc"; }
+    { locale = "es-MX"; arch = "linux-x86_64"; sha256 = "820c50a0991779f664be8013e10a6db2833caa4b1fed370a7d6a8eb71f5766f3"; }
+    { locale = "et"; arch = "linux-i686"; sha256 = "bb2d259606836c5d01d149f2735639cad7411efcd5e0e5deacdc3f1bbae8d80d"; }
+    { locale = "et"; arch = "linux-x86_64"; sha256 = "17265f828cb3232cca73b3bf5b806cf361769c77bfef0e6571a16eb73036cccb"; }
+    { locale = "eu"; arch = "linux-i686"; sha256 = "0bedcadc3b60ecb58af25d5950fe693063eb80f65d6d85e72ff0cdab3e7f2030"; }
+    { locale = "eu"; arch = "linux-x86_64"; sha256 = "371d5648c7ffaf325ef34030ad0a9971246bc1df354fc11dd66bc461dce303fc"; }
+    { locale = "fa"; arch = "linux-i686"; sha256 = "a7c55492f08e5f44d5cccb015d00abf8b8e74dec7da37e937f8d0f76a4c49338"; }
+    { locale = "fa"; arch = "linux-x86_64"; sha256 = "6fe831c56d96dbed1c4a6859ba58dc20bbdf43efbc2bb225a707df7966f8b9dc"; }
+    { locale = "ff"; arch = "linux-i686"; sha256 = "5cf4f3235db02c385ffc355e0fa1060b79afd5a8899ff31da1d0dad4d065e4cf"; }
+    { locale = "ff"; arch = "linux-x86_64"; sha256 = "0576772ddcbdbe3d26ae20dd47b4e635de709c34eb6a797afab7743ac68815bf"; }
+    { locale = "fi"; arch = "linux-i686"; sha256 = "8edd2e8058fc848456b2dc1bb54f669159b232b5423dcde6638e5d61294f1ffe"; }
+    { locale = "fi"; arch = "linux-x86_64"; sha256 = "94bd189308502abea3d6d762378220097d3d743cc42872e6c43cdcd86aa51b4f"; }
+    { locale = "fr"; arch = "linux-i686"; sha256 = "652f87501ba2a5baf1de865d7a607837a9ed623834c2d796baf4e3891fc78a6b"; }
+    { locale = "fr"; arch = "linux-x86_64"; sha256 = "94c3725ea6fc2a7833e9ee60fdcd0ae3a53c80ce7f13ca00634b5d99b12a4607"; }
+    { locale = "fy-NL"; arch = "linux-i686"; sha256 = "8d9ed839afa148da954acfdca139dbcf9f235c097fc7c562a8ab52f9ece68b4b"; }
+    { locale = "fy-NL"; arch = "linux-x86_64"; sha256 = "650c8a50b8473fd09dbcd1c818ca8c3ab0c6618696198124f32e0153307e2aa3"; }
+    { locale = "ga-IE"; arch = "linux-i686"; sha256 = "a70af727b36bc7d084211a880318f3a9f73977ff75f728b50cc4bfa9398c61d2"; }
+    { locale = "ga-IE"; arch = "linux-x86_64"; sha256 = "01d3635c38068facc135fcca979517d729999db52f4a00c0b2ee27cf830df870"; }
+    { locale = "gd"; arch = "linux-i686"; sha256 = "9763cbe0387cb86f91cdd6b1dfa6e257cc40c4525c753869ee091bfe49f172e8"; }
+    { locale = "gd"; arch = "linux-x86_64"; sha256 = "16d3452fdbabada41626d981dee0e48282d672d9d6073b363ede9e86c4ed56ce"; }
+    { locale = "gl"; arch = "linux-i686"; sha256 = "facde8f17e2f90e49a02b36d016535e1123c7f78ac44ee1110c80dc472e84133"; }
+    { locale = "gl"; arch = "linux-x86_64"; sha256 = "b0955c4381f7f0013e9e0b1dcf8d8c53a3bf694af6970638b2e88dc080771ed7"; }
+    { locale = "gu-IN"; arch = "linux-i686"; sha256 = "cb42e0750736bd14c81bbb76bb05e02c97e798b01d9f41bad091295f9bbb5655"; }
+    { locale = "gu-IN"; arch = "linux-x86_64"; sha256 = "c497650eda2e4fc0f99b9d9c1ef0df33b0ea7b6e32d2eb7d4ee109e5ae1f2add"; }
+    { locale = "he"; arch = "linux-i686"; sha256 = "d4cc561b6ce55f0820e6bd8479de9fd1ed53fd228e7cef28a890aebd687c26aa"; }
+    { locale = "he"; arch = "linux-x86_64"; sha256 = "9294083a0ce8b06cc565c9d643d3e45d50393a5abff230dde8fe42aa29d8b870"; }
+    { locale = "hi-IN"; arch = "linux-i686"; sha256 = "3493dda678fe94e13d34a62d194b612037f472546b96a94de2390706139636ef"; }
+    { locale = "hi-IN"; arch = "linux-x86_64"; sha256 = "db45625e758d3db82705373004cc16176f8376bf087ac11da06c7c22e613dc2a"; }
+    { locale = "hr"; arch = "linux-i686"; sha256 = "227399d033c4a7877387ac965d84ac265600bc16614de1b99618f39808b92894"; }
+    { locale = "hr"; arch = "linux-x86_64"; sha256 = "a4f061ed24c66f936da13f8d93eb311f8fda7cc468d7cc9f71a4c747bbd9af19"; }
+    { locale = "hsb"; arch = "linux-i686"; sha256 = "41bc010d4cca63bc77b8d637e6ca2731e3c5900b6783955335aae0ee3d2eedae"; }
+    { locale = "hsb"; arch = "linux-x86_64"; sha256 = "4618d03269cad3fe8ca3d618de581d37fef37b9276e72613d2c12b212bb2c894"; }
+    { locale = "hu"; arch = "linux-i686"; sha256 = "be456ef5df061985f7413fc7af45b4f0b86ac4a99a57d3574d8ad6dba727a8fe"; }
+    { locale = "hu"; arch = "linux-x86_64"; sha256 = "c229ca2c9fba2ac98e912e5c5f4500d423b1f2cbf768e539112e97c0f0fe410b"; }
+    { locale = "hy-AM"; arch = "linux-i686"; sha256 = "0a569d1b8c8d685c3eb5701471420aa47110c737504a105f660dca72a82490af"; }
+    { locale = "hy-AM"; arch = "linux-x86_64"; sha256 = "b15c86feb6d69005244f409290489d8f5ffaff0c85ec876ba931be38c7de07b0"; }
+    { locale = "id"; arch = "linux-i686"; sha256 = "dc8ca98414ccc67087c896c84a0a223026f12ed9fec499eba6203b8ec0b3e6e7"; }
+    { locale = "id"; arch = "linux-x86_64"; sha256 = "6a831ab4c2605fdbac15ac81853a19f5c8633756ad5136f93c3eb76637e2b997"; }
+    { locale = "is"; arch = "linux-i686"; sha256 = "02e9a2022c0da27e069689d25ba80c1d04dc29e6a045833fa1c5e503b5ca9f9a"; }
+    { locale = "is"; arch = "linux-x86_64"; sha256 = "0ffd2b8f1fdafd91ae4e089c075446f57adcc748bea4994d40207e5cba9a5655"; }
+    { locale = "it"; arch = "linux-i686"; sha256 = "f84d5304a37e33883322c9c508f4d342f99901c9339d293308ef78bb561a3c40"; }
+    { locale = "it"; arch = "linux-x86_64"; sha256 = "78c5cb912d6c24d5a7636fd400470d298e4f58493ca6fd3e5f6b88e4b8037e77"; }
+    { locale = "ja"; arch = "linux-i686"; sha256 = "a3d563846ef60176712574a9f66d24a785f749390afde21cbc4823e9d30cc3ba"; }
+    { locale = "ja"; arch = "linux-x86_64"; sha256 = "56bdf673d645dff09e96970fc4cb33b1810d57051e7c12f6fe1ba01fa971e293"; }
+    { locale = "kk"; arch = "linux-i686"; sha256 = "a5b10502bacf265e2157b7246457c33adcf037e4e28291e26a7fdd9f53f94638"; }
+    { locale = "kk"; arch = "linux-x86_64"; sha256 = "2a7c74168d040653cbc31d6d03846b9165f617cebb74388818d73d681056561d"; }
+    { locale = "km"; arch = "linux-i686"; sha256 = "26e696f0a03d7d6c3541563f89ba08d06a47039ca93f15d2f1909db7ca1b8d08"; }
+    { locale = "km"; arch = "linux-x86_64"; sha256 = "18676450680d18631a855dcf91fd4592f8e3e908b04122476ae62d619bfbdd4f"; }
+    { locale = "kn"; arch = "linux-i686"; sha256 = "cf6c95c0f06381f3aa4eb03c8854a530e63b0b5c6d971dc019a5c6cf81f80b0b"; }
+    { locale = "kn"; arch = "linux-x86_64"; sha256 = "fabd1b824a4593454f8c9d7c6c47f7244ec9d1800cbe397042fb3bc41a75d09b"; }
+    { locale = "ko"; arch = "linux-i686"; sha256 = "d3d9ff36de18ca424511df1ddbd4c49c84499491510a064a6f55f15599e1c172"; }
+    { locale = "ko"; arch = "linux-x86_64"; sha256 = "e8eef3e4c6201e1d1e936ee6ec53f875b6c2a0496d308b8fbe03b5cbdf229bec"; }
+    { locale = "lij"; arch = "linux-i686"; sha256 = "de6b35a675539d1bf0ff1c8f3837ba030da64b0e51c30e594515ac13578495f5"; }
+    { locale = "lij"; arch = "linux-x86_64"; sha256 = "9d2351a7bed09127b618cfd86f2d394fdefcbbf2801da3a60a697982b5bbb9f1"; }
+    { locale = "lt"; arch = "linux-i686"; sha256 = "5e5c3d5083b8d71a249f9e5009072132c9524063fa0cdb1f47ad0ff5260725c7"; }
+    { locale = "lt"; arch = "linux-x86_64"; sha256 = "c57df2ce20d09070514f783a12e179ff05a4ac14e7ec67b0081f284f70079468"; }
+    { locale = "lv"; arch = "linux-i686"; sha256 = "30267f85939965eab0ec50f4c869a0a42fa0d0775ae516088f9a3ff57f1bf3d2"; }
+    { locale = "lv"; arch = "linux-x86_64"; sha256 = "c1389231d627df347910d28172a823da18f2ebd5697093035faa499da24755eb"; }
+    { locale = "mai"; arch = "linux-i686"; sha256 = "6dec829e1ea28f8c4480d0517f72909d2d652fd827693dc919298906b62b47d2"; }
+    { locale = "mai"; arch = "linux-x86_64"; sha256 = "29ed57ad173243d7cc2460a534c3f63709e235db74810a0d6f12dc460c5f4a52"; }
+    { locale = "mk"; arch = "linux-i686"; sha256 = "98d4c529ca979e4ba03b3c1640feb0c93ca1ac2a92ac07403a39a07adce8df44"; }
+    { locale = "mk"; arch = "linux-x86_64"; sha256 = "53d6752d67e3277afe3ea239ceb1f890edc5a15fe078d41bc074246598376603"; }
+    { locale = "ml"; arch = "linux-i686"; sha256 = "321d682e8e1e42e8e4522d791e7e7ae13d1622d740038f3586813099f0275d96"; }
+    { locale = "ml"; arch = "linux-x86_64"; sha256 = "f0dfba4cd8fd961ef6c088ef9139b8ce5e33fcefa8cda142c9f51bfae663c092"; }
+    { locale = "mr"; arch = "linux-i686"; sha256 = "b40b8fbbe5ab56055d57f7b9a67ff00e84b7c7d19afc7bb07b4311ef3fb6c66b"; }
+    { locale = "mr"; arch = "linux-x86_64"; sha256 = "3bb64e13d59a1c65460282e4236655a0c2997d894e9b897a8dc3b20a4baca3c9"; }
+    { locale = "ms"; arch = "linux-i686"; sha256 = "15aeda467f0c0c893dd923ee56fcf2547242f0a4089709ce0cbdb27778c71b1b"; }
+    { locale = "ms"; arch = "linux-x86_64"; sha256 = "32cea21ff68efd7c384746c32c0138464fbae4d25065fe58d6d56e191ee5b082"; }
+    { locale = "nb-NO"; arch = "linux-i686"; sha256 = "371af3de1ae68ba242cc55cb7c080008ca305c61d5c8c4e687f53568bcb8f416"; }
+    { locale = "nb-NO"; arch = "linux-x86_64"; sha256 = "54e17787e0d31893dcba314e98cfb795fd6f85e335a0e84ce35a0f44a56b6e1d"; }
+    { locale = "nl"; arch = "linux-i686"; sha256 = "92df7a99107ccd938800161e759beb6269a6a30f69c892064e130280a3caa692"; }
+    { locale = "nl"; arch = "linux-x86_64"; sha256 = "41c1bfc828917d58cf8f334b8d2b333ddb50dd416faaae41a0c063bd8c23942c"; }
+    { locale = "nn-NO"; arch = "linux-i686"; sha256 = "ad96e3c670c244d366ce0d600d87a308d95e51309ab86becf1c8c69245dbed0f"; }
+    { locale = "nn-NO"; arch = "linux-x86_64"; sha256 = "eee10d92a2bcc32507936c3c2c5c2c220a4de955aa8b48d23f0d923c9b0faa48"; }
+    { locale = "or"; arch = "linux-i686"; sha256 = "1ddaa000c9b3d5a7dccdddaeb8fda53ba821935bf24ee5c2ca0053e3b2900bd7"; }
+    { locale = "or"; arch = "linux-x86_64"; sha256 = "0d62ab80bdd5853d8dfae01d9420929d9321d1f6b9f40d372c6241f1345de76a"; }
+    { locale = "pa-IN"; arch = "linux-i686"; sha256 = "accdde423ac5c518d14b435d00e1f536cd240f31108b58f0b5e1a925637faab4"; }
+    { locale = "pa-IN"; arch = "linux-x86_64"; sha256 = "89ae2f460c6fdab846d6b41dba84f63c94a7bfc1f61e3e79da5d643d4c1a1fca"; }
+    { locale = "pl"; arch = "linux-i686"; sha256 = "d8e043d8ba0c223f0232facef10b6d2e2ee13733bf8670a9101796bfddb3c2f1"; }
+    { locale = "pl"; arch = "linux-x86_64"; sha256 = "f6ada91433d48b699c02fddf22e2d8aa36e6b0cc365b73625bf6fb80ed3fb877"; }
+    { locale = "pt-BR"; arch = "linux-i686"; sha256 = "b2d294d7761cfc3c8a58ee072bb8a0b82cc79724f6b103073632e682fda32f60"; }
+    { locale = "pt-BR"; arch = "linux-x86_64"; sha256 = "642c56b5d510f5efc8a365be956789d7760bfe983aa397ae194eef5bd15f601b"; }
+    { locale = "pt-PT"; arch = "linux-i686"; sha256 = "6bc224414c39047c42040ebaaa7e7d61bb09939a9878ec4a2d7d7e8c31a7ecfc"; }
+    { locale = "pt-PT"; arch = "linux-x86_64"; sha256 = "cc00a2fb38fed6ffef5a6a6931b043c65948c18f3d502a0e3ae641a1847203b7"; }
+    { locale = "rm"; arch = "linux-i686"; sha256 = "2cebf2678e1a469447205a7495f17185259d73a72439f8fd400eee957e571bbc"; }
+    { locale = "rm"; arch = "linux-x86_64"; sha256 = "32fe2ef01b0d495476768eff7e4750c2c82196e60f50c2e824adbf611f275289"; }
+    { locale = "ro"; arch = "linux-i686"; sha256 = "289cef6b438a59bac459c203a6b1b2965b089f1487ea78ff524a6a68f5996862"; }
+    { locale = "ro"; arch = "linux-x86_64"; sha256 = "7df67b1a5a12297a214d1f794c84b58ca12a182ee780e2574116214dfc785388"; }
+    { locale = "ru"; arch = "linux-i686"; sha256 = "65fd6a9a90b4e5c8fc784850dd5bce41901b0d241dae9c37110bf99643d52d32"; }
+    { locale = "ru"; arch = "linux-x86_64"; sha256 = "585683dca4c427ecbcc17d42465b6e374a76d5266b908df1b47f4a1ad81e7794"; }
+    { locale = "si"; arch = "linux-i686"; sha256 = "6567d5ab15a1bd20426569a6480d6e44f2c1917145fa607357f0d3d0502c840a"; }
+    { locale = "si"; arch = "linux-x86_64"; sha256 = "f0aad93013b6070516851a13352d1aabd0d10bd7891eaea878d3632c1b295296"; }
+    { locale = "sk"; arch = "linux-i686"; sha256 = "c6da9d539302dca6ad8e3165ca595eb80438fb4caea11979c0e07ca215696929"; }
+    { locale = "sk"; arch = "linux-x86_64"; sha256 = "236dd9171f471849e8cddb2b8ff0166e41bdedcb0bb3c1662fdffa83c3e89374"; }
+    { locale = "sl"; arch = "linux-i686"; sha256 = "4b9160bfa7579fc893a40387f0185cb74d7db2cfb0eabd2aa032259ed53b7a97"; }
+    { locale = "sl"; arch = "linux-x86_64"; sha256 = "56bc853e4e5e21d08b2ccd04687388473c45ac4403d0b51ed41d8a6a3a26e396"; }
+    { locale = "son"; arch = "linux-i686"; sha256 = "b73fcee703ce937ec25993da5e09163541fef9eaa4e65ec7d5358f1dfa1b596f"; }
+    { locale = "son"; arch = "linux-x86_64"; sha256 = "95ef838ac58e82ec435ddf7e2ea0bbf8b8d1bdb34832aa664d1ad8f5abbd9a13"; }
+    { locale = "sq"; arch = "linux-i686"; sha256 = "370313d2cf543ab3aeaa5de11f748d69a168a82d6e29c27d4c398bb577fdb06d"; }
+    { locale = "sq"; arch = "linux-x86_64"; sha256 = "a86a6604169ab6d9bc2657a0d26db0a3f96b2927223c5a43128dcf49bad243f1"; }
+    { locale = "sr"; arch = "linux-i686"; sha256 = "a7ad2ec678944f37cfee69025871369b658013f77df9df0f1bbfd9cbc03666d2"; }
+    { locale = "sr"; arch = "linux-x86_64"; sha256 = "b081bc35064722b4de95f4e29c4ee203bca124ebe0c33bbf91f0e11f904928f7"; }
+    { locale = "sv-SE"; arch = "linux-i686"; sha256 = "5a6fe1f1c7e1d5bd91a0c82e47ce5b88e31611cf51d6452afde3ef06d2d1a695"; }
+    { locale = "sv-SE"; arch = "linux-x86_64"; sha256 = "9a09a020acabfaef4fa25d94723fa437c57761f0dbd9bda880b8ca3acb5248df"; }
+    { locale = "ta"; arch = "linux-i686"; sha256 = "0e0839d5a899576f3fd796079748dba8612526bd5f855e8718eccb3ed05944c0"; }
+    { locale = "ta"; arch = "linux-x86_64"; sha256 = "cdcd8e06216289df7cdb4f82f01207a7112fa4f52040bd70c2f497b3d701730a"; }
+    { locale = "te"; arch = "linux-i686"; sha256 = "e4609f803edb243ba8c8fbfb7ecea2e652a9e94adeec2f6c03af42c2e8bc5b74"; }
+    { locale = "te"; arch = "linux-x86_64"; sha256 = "b9151a27be6a8de94fa25b53dfb85e765cc2ff823c2de6a0d0583883fc30ea48"; }
+    { locale = "th"; arch = "linux-i686"; sha256 = "48349866a10948cc0b4f8b6bc2fecd5dcbd4d09ff4ba569f7fb3e569edadd976"; }
+    { locale = "th"; arch = "linux-x86_64"; sha256 = "ef38e6a99cc8cb9e32e95af0ae7f7c99b82310e28b082b6aa085aa80f180ef60"; }
+    { locale = "tr"; arch = "linux-i686"; sha256 = "fbad5fa2196dddb5061fec1f47fa7af85c0a824f520588b7446d2740928e34cd"; }
+    { locale = "tr"; arch = "linux-x86_64"; sha256 = "c644f251f1e43acc3baa550b540750fb7d11c2f440c7906e1955d34694a0d718"; }
+    { locale = "uk"; arch = "linux-i686"; sha256 = "9db7dc494734011ed61c5286fcb1f4b4dfb418528792ef92fbfc3734a9618129"; }
+    { locale = "uk"; arch = "linux-x86_64"; sha256 = "06cbcceb189bad7174cf46678535cd4bfb1062e5ac878fd313fc341315001106"; }
+    { locale = "uz"; arch = "linux-i686"; sha256 = "cfa94474277edc7739c11795b2907b894c87f5c573c43aaf5a951a2f13a9c8ef"; }
+    { locale = "uz"; arch = "linux-x86_64"; sha256 = "e3a581e965fbb3711e6ca6d6d5b378eded8e8ea9767f94993c50632b6f4a7aed"; }
+    { locale = "vi"; arch = "linux-i686"; sha256 = "ecd4a5b8fa66e78cdb93b04eb2b3a5ac354bd5e231d8f4bcbf2acfb94b5190b5"; }
+    { locale = "vi"; arch = "linux-x86_64"; sha256 = "1d52852d973d5d6bea8ef860b216aff4eea59dff576f13ae67aa9b96ef0c9878"; }
+    { locale = "xh"; arch = "linux-i686"; sha256 = "24befe5e2fe2001ab3827543f97b52ecd15f5cbad89d977584aa4dc08a0e9c11"; }
+    { locale = "xh"; arch = "linux-x86_64"; sha256 = "4cafc2a6028d8141e47b09a9d8d96404cb4b5806cfaab452566f9a7baff89f25"; }
+    { locale = "zh-CN"; arch = "linux-i686"; sha256 = "80ec43ed8918fa452271988d53875f184196460b15086fe793af4842458ab790"; }
+    { locale = "zh-CN"; arch = "linux-x86_64"; sha256 = "1d3fc933a5b3f4082fac9176f6a802e01f8a26d711c339116799e58629843f27"; }
+    { locale = "zh-TW"; arch = "linux-i686"; sha256 = "a255ce81f6ac1774ae6c8a5b9208169864a672f22f7037c93f01758c4eaa357b"; }
+    { locale = "zh-TW"; arch = "linux-x86_64"; sha256 = "27b048c3df2ff25fd6f7c33cc30016e8a657a2f30ef7b0da9a2f4097c1b5e494"; }
  ];
 }
--- a/pkgs/applications/networking/cluster/mesos/default.nix
+++ b/pkgs/applications/networking/cluster/mesos/default.nix
@ -15,7 +15,7 @@ in stdenv.mkDerivation rec {
  dontDisableStatic = true;

  src = fetchurl {
-    url = "http://archive.apache.org/dist/mesos/${version}/${name}.tar.gz";
+    url = "mirror://apache/mesos/${version}/${name}.tar.gz";
    sha256 = "1v5xpn4wal4vcrvcklchx9slkpa8xlwqkdbnxzy9zkzpq5g3arxr";
  };

--- a/pkgs/applications/networking/cluster/mesos/fetch-mesos-deps.sh
+++ b/pkgs/applications/networking/cluster/mesos/fetch-mesos-deps.sh
--- a/pkgs/applications/networking/cluster/mesos/mesos-deps.nix
+++ b/pkgs/applications/networking/cluster/mesos/mesos-deps.nix
@ -6,7 +6,7 @@ stdenv.mkDerivation {

  outputHashAlgo = "sha256";
  outputHashMode = "recursive";
-  outputHash = "03qjq481ly5ajynlr9iqvrjra5fvv2jz4wp2f3in5vnxa61inrrk";
+  outputHash = "12c6z5yvp60v57f6nijifp14i56bb5614hac1qg528s9liaf8vml";

  buildInputs = [ curl ];

--- a/pkgs/applications/networking/instant-messengers/baresip/default.nix
+++ b/pkgs/applications/networking/instant-messengers/baresip/default.nix
@ -4,11 +4,11 @@
 , gsm, speex, portaudio, spandsp, libuuid
 }:
 stdenv.mkDerivation rec {
-  version = "0.4.15";
+  version = "0.4.16";
  name = "baresip-${version}";
  src=fetchurl {
    url = "http://www.creytiv.com/pub/baresip-${version}.tar.gz";
-    sha256 = "13712li6y3ikwzl17j46w25xyv3z98yqj7zpr3jifyvbna9ls5r3";
+    sha256 = "04a9d7il39b1kfqh7al0g0q8v32hphgjx8gkixrlp5qsqlzvk876";
  };
  buildInputs = [zlib openssl libre librem pkgconfig
    cairo mpg123 gstreamer gst_ffmpeg gst_plugins_base gst_plugins_bad gst_plugins_good
--- a/pkgs/applications/networking/instant-messengers/blink/default.nix
+++ b/pkgs/applications/networking/instant-messengers/blink/default.nix
@ -3,11 +3,11 @@

 pythonPackages.buildPythonPackage rec {
  name = "blink-${version}";
-  version = "1.4.1";
+  version = "1.4.2";
  
  src = fetchurl {
    url = "http://download.ag-projects.com/BlinkQt/${name}.tar.gz";
-    sha256 = "0lpc3gm0hk55m7i2hlmk2p76akcfvnqxg0hyamfhha90nv6fk7sf";
+    sha256 = "0ia5hgwyg6cm393ik4ggzhcmc957ncswycs07ilwj6vrrzraxfk7";
  };

  patches = [ ./pythonpath.patch ];
--- a/pkgs/applications/networking/instant-messengers/gajim/default.nix
+++ b/pkgs/applications/networking/instant-messengers/gajim/default.nix
@ -20,11 +20,11 @@ with stdenv.lib;

 stdenv.mkDerivation rec {
  name = "gajim-${version}";
-  version = "0.16.4";
+  version = "0.16.5";

  src = fetchurl {
    url = "http://www.gajim.org/downloads/0.16/gajim-${version}.tar.bz2";
-    sha256 = "0zyfs7q1qg8iqszr8l1gb18gqla6zrrfsgpmbxblpi9maqxas5i1";
+    sha256 = "14fhcqnkqygh91132dnf1idayj4r3iqbwb44sd3mxv20n6ribh55";
  };

  patches = [
--- a/pkgs/applications/networking/instant-messengers/ratox/default.nix
+++ b/pkgs/applications/networking/instant-messengers/ratox/default.nix
@ -8,7 +8,7 @@ stdenv.mkDerivation rec {

  src = fetchurl {
    url = "http://git.2f30.org/ratox/snapshot/${name}.tar.gz";
-    sha256 = "1fm9b3clvnc2nf0pd1z8g08kfszwhk1ij1lyx57wl8vd51z4xsi5";
+    sha256 = "0xnw3zcz9frmcxqhwg38hhnsy1g5xl9yc19nl0vwi5awz8wqqy19";
  };

  buildInputs = [ libtoxcore ];
--- a/pkgs/applications/networking/mailreaders/thunderbird-bin/sources.nix
+++ b/pkgs/applications/networking/mailreaders/thunderbird-bin/sources.nix
@ -4,123 +4,123 @@
 # ruby generate_sources.rb > sources.nix

 {
-  version = "38.4.0";
+  version = "38.5.0";
  sources = [
-    { locale = "ar"; arch = "linux-i686"; sha256 = "30383ea1567d2338af99de09f144e4a3cf6c195bc3707c1011171b4c09a885ab"; }
-    { locale = "ar"; arch = "linux-x86_64"; sha256 = "0325b8da77e0ec1c97eac81367cbf68c2e4cf62ddd086ab07494cd1705d6134e"; }
-    { locale = "ast"; arch = "linux-i686"; sha256 = "5e91cb9df7aab8c887dadcdf8d01b0dd2e6427ed570333b66a680c57ff9391b2"; }
-    { locale = "ast"; arch = "linux-x86_64"; sha256 = "3e275d4db234f2ce1c226577dbd6289f870c7ac9f3963136eaa6fa097cb7fbef"; }
-    { locale = "be"; arch = "linux-i686"; sha256 = "74a4dcbcf45e766b3a4b23a0bf4c08d61b8e8e8923b45d27ca23f2785dd4120b"; }
-    { locale = "be"; arch = "linux-x86_64"; sha256 = "52e9c46cb12b4cdb8d6eaa384717572ef5bd845c18a36d8cfd15db39c4d0332f"; }
-    { locale = "bg"; arch = "linux-i686"; sha256 = "0dde851fee0eba8be214f8f673a5da9924f84cf1b558d3f76aa80f6008e518f1"; }
-    { locale = "bg"; arch = "linux-x86_64"; sha256 = "198607f773ddc38ab1c2433500f53578fab38dea817a24ae94849fa8045bbb67"; }
-    { locale = "bn-BD"; arch = "linux-i686"; sha256 = "a34e8ae21b22cb80b772a31341a7dd5da23aaddf8685c6a1a20be6f8f3c312af"; }
-    { locale = "bn-BD"; arch = "linux-x86_64"; sha256 = "03f611a7029002e593175cb4e624b1d3885c12847115a027d89625d3be9247c4"; }
-    { locale = "br"; arch = "linux-i686"; sha256 = "6c61dcc67472b3fd1b8361d4960e0ec2a190e7a18aa9e05060fa80a7d23b3796"; }
-    { locale = "br"; arch = "linux-x86_64"; sha256 = "f4589f1e31697fd65296f306350558ca9355962182e69d0c6f4b303b62407e5b"; }
-    { locale = "ca"; arch = "linux-i686"; sha256 = "dd2f59e278a34081c6ac3f1c8dbb61b2e9fe188b23715e6917c7034ac562ae42"; }
-    { locale = "ca"; arch = "linux-x86_64"; sha256 = "0f77e01e3a9dda94c8dd7cc34ab2eefbfd4bcacc6d09b3a8563632130c3fb83b"; }
-    { locale = "cs"; arch = "linux-i686"; sha256 = "389e99cc4b2c56067ea02eef9e2e347ef972fe21a20a094c6d056aa5e7fb65ff"; }
-    { locale = "cs"; arch = "linux-x86_64"; sha256 = "c34ee1e3607df27a9edc03faed4476533489a962715a9d7920282044e9af2dd6"; }
-    { locale = "cy"; arch = "linux-i686"; sha256 = "f77986fb3ab81e82e611247066ba6856518a209694cc71592895c4186ec80607"; }
-    { locale = "cy"; arch = "linux-x86_64"; sha256 = "549a0c15bbd298e9d3753782e97a0874bf2bfca607bfed484efe3b9fdce3c9b0"; }
-    { locale = "da"; arch = "linux-i686"; sha256 = "e56cf65ce0719a3a22d2fdb33ce08113348022afd3a557f2ac39a25e35f632de"; }
-    { locale = "da"; arch = "linux-x86_64"; sha256 = "991b5ff474cff16d106b88ee31ac889c6e0543e15b3bf4340c3c263cd3a3ea4c"; }
-    { locale = "de"; arch = "linux-i686"; sha256 = "7f28547c9e67c4d76815337d8f5f39e303d1a1055077a77af42ad4162dd3b476"; }
-    { locale = "de"; arch = "linux-x86_64"; sha256 = "4c16d7477792759eb754cb5770be67dc78dab3cdfb47c29bb3bf038dbfe6601e"; }
-    { locale = "dsb"; arch = "linux-i686"; sha256 = "8f5a82f61c80dd9a1358ee43e192364f34dbba0253aeba00ad0c5d1656e57a34"; }
-    { locale = "dsb"; arch = "linux-x86_64"; sha256 = "7804c72b8c758193fbd45feedc185d01717133bf2fa1b1d0054ea421224c780e"; }
-    { locale = "el"; arch = "linux-i686"; sha256 = "8128d4330fdfa0c5b0e5b309d1957b7523b337f862bd1e9d2286f50fc652f339"; }
-    { locale = "el"; arch = "linux-x86_64"; sha256 = "1d1f7859cd25aa5bd18222f97b4496c8f661a375b1e0404eb92b0bec3bb60ae7"; }
-    { locale = "en-GB"; arch = "linux-i686"; sha256 = "980f494e26c8a2904490d55ff2bdfcf8b3d2c82c4b251a7ade3bce90d1e4632c"; }
-    { locale = "en-GB"; arch = "linux-x86_64"; sha256 = "3f3fd4139c64bbea32c53683a2ba75be24fa4a2024922c42b4647ce28a59457f"; }
-    { locale = "en-US"; arch = "linux-i686"; sha256 = "bca69f68e6296608e50bb798e46e209cc3be9f20b5baacc102f7571316f7f65e"; }
-    { locale = "en-US"; arch = "linux-x86_64"; sha256 = "e8d9a31537a6db91efec6372106e655d73ab3e55f3c0ff2e42e564e2a4da7781"; }
-    { locale = "es-AR"; arch = "linux-i686"; sha256 = "bbb8817ed30f591f54d47066765cc4796786f5fa41cd2ee2dbf59001fcaad4c6"; }
-    { locale = "es-AR"; arch = "linux-x86_64"; sha256 = "06b55c261bc0cfbc257c264e9643088682256aaf739c8905cfbd4cd08f0868bd"; }
-    { locale = "es-ES"; arch = "linux-i686"; sha256 = "44a77de45e05ad469cd03d17efa4766a1e2e06bc8e2e7a5d954db3aea17b8407"; }
-    { locale = "es-ES"; arch = "linux-x86_64"; sha256 = "f14c54fc64eb586c8015352d24b392268d3b2ced7312a5647fc1385e14f6d93d"; }
-    { locale = "et"; arch = "linux-i686"; sha256 = "81b28a75d61d9f8463f18ce48943b0f701f392201655eba4899fa609cb59cd9c"; }
-    { locale = "et"; arch = "linux-x86_64"; sha256 = "974247ffb2e003026d46888b425a5f497b7a6d06213190e5668c085e1c44453d"; }
-    { locale = "eu"; arch = "linux-i686"; sha256 = "f45344ec704ad5a07639da1076ad2e6b1cad21bb75c9462e5e46abad3e57b588"; }
-    { locale = "eu"; arch = "linux-x86_64"; sha256 = "4acba2bb5780f85e45a28f58027b75b2832281a7f001f780b215c564a2da2671"; }
-    { locale = "fi"; arch = "linux-i686"; sha256 = "74c4d196d31fbc000d541d057ed7dfa31cf713f7964be4bc6fe1c3f80680824d"; }
-    { locale = "fi"; arch = "linux-x86_64"; sha256 = "14dfe7b1cf2b1feb8a27628a27d5ef00e64dc401c5aebac1e01e1b94f7d091b6"; }
-    { locale = "fr"; arch = "linux-i686"; sha256 = "a6749feae77747703f3a07a1c58bc5679c5faaeb207cb5e46f98cbac733294e1"; }
-    { locale = "fr"; arch = "linux-x86_64"; sha256 = "201af3653ade9411902e208a2d16a7b0357d2a4a44d5dfcccf59d7939e24e787"; }
-    { locale = "fy-NL"; arch = "linux-i686"; sha256 = "8521f1f0551531aef107a21ad953fdeaf0b025266f709e9cfd49eab92a3dcaf2"; }
-    { locale = "fy-NL"; arch = "linux-x86_64"; sha256 = "195f0f25dab810e4f8a89d01f3ddb837378cd9fd691425b0b6b50653ac9bad73"; }
-    { locale = "ga-IE"; arch = "linux-i686"; sha256 = "f3f216995781f4ec55346822483d073e4a1c15449df78e56a05acb7743198292"; }
-    { locale = "ga-IE"; arch = "linux-x86_64"; sha256 = "ebcbc721eee9020ac52eeee92531307512a8a3f2306eee3952b9343a52381d4b"; }
-    { locale = "gd"; arch = "linux-i686"; sha256 = "234e5cb13726b1025c96403e8522c2cbb169ba547513c007501230d6fff3face"; }
-    { locale = "gd"; arch = "linux-x86_64"; sha256 = "2cffd346a895b520c804d8efc7f92e38ace1256a007d8a95abd5687c6fdebcbc"; }
-    { locale = "gl"; arch = "linux-i686"; sha256 = "e65afb4d848a4d6922b550888990733046227dd9201c917b161f19d9b5cab232"; }
-    { locale = "gl"; arch = "linux-x86_64"; sha256 = "ec85e88f167c195fb1f5ac07adcd4b1ebe538ccb94959a1d2d9ca33406fc2277"; }
-    { locale = "he"; arch = "linux-i686"; sha256 = "2b6f436f26ab131d6d6e883a16d27f5a5b9570ada883fe8a387462ad6a2e50ea"; }
-    { locale = "he"; arch = "linux-x86_64"; sha256 = "e37020bd431a697b73b88cfc1a9ddee0168009627ce3848684d8de499ad3b053"; }
-    { locale = "hr"; arch = "linux-i686"; sha256 = "7c005e34cde48c606dbd67d43fa691c96cd8a27ce50b552b1c1b3e114ae112b3"; }
-    { locale = "hr"; arch = "linux-x86_64"; sha256 = "b41260a478e8afa2ae530d6b170514a815b8962bbb3bd32431032604868c3d48"; }
-    { locale = "hsb"; arch = "linux-i686"; sha256 = "b4b2e41f9afe8eea8b347bd8fe0ba8d03ac8b9cf9b055469e053e4f72bc1c665"; }
-    { locale = "hsb"; arch = "linux-x86_64"; sha256 = "b6540fe80976a53828058e91f4a311192a7da37fd1ea8574161c0cfe494d17f2"; }
-    { locale = "hu"; arch = "linux-i686"; sha256 = "c7b27a351e095353f2f53b50275ed7774faeb9254b980dd6571d48a935b50630"; }
-    { locale = "hu"; arch = "linux-x86_64"; sha256 = "d5b014fd679bc475ade1278ba661a97e0a92d0fea8a6351e199677f5185f19f4"; }
-    { locale = "hy-AM"; arch = "linux-i686"; sha256 = "e6748c7f84a6040e98bb0cb3b1ec1c975f2174f8a89c2cc0ef83921dd56d2b1c"; }
-    { locale = "hy-AM"; arch = "linux-x86_64"; sha256 = "ce902a1ecadf1a89ab7f32ed17eef33725c946447fd67bc83cde0492fd65022b"; }
-    { locale = "id"; arch = "linux-i686"; sha256 = "6f2851c35f8b3fa5187d05d252da8d593f5ec4f9d268dc9c6973b0f87ed0733e"; }
-    { locale = "id"; arch = "linux-x86_64"; sha256 = "1a89f09b6a4c3418fb4a1490430e96742e5e8f5dc8b2613ccd9214950c6e8c80"; }
-    { locale = "is"; arch = "linux-i686"; sha256 = "e1cdede34db4b9d289596a689e04452813b6c9a83c72513d51c9f356879af9b2"; }
-    { locale = "is"; arch = "linux-x86_64"; sha256 = "eeb91667080edb15bb5e023333ff7410580b70de878628b4e6bbaa3d0db2bdfa"; }
-    { locale = "it"; arch = "linux-i686"; sha256 = "bd531bf775d991710fd63f1de90b6389c176d6a0c7d7068a8139f70379d6a76b"; }
-    { locale = "it"; arch = "linux-x86_64"; sha256 = "89fe33ffda15340926c727b535b378bf629389edccf8f8627b03b4056284b93b"; }
-    { locale = "ja"; arch = "linux-i686"; sha256 = "6e22ad0f04be5ce33dfe1d33d4d935e0dce425d80c5e6e07f3b7f2c856f64aee"; }
-    { locale = "ja"; arch = "linux-x86_64"; sha256 = "2aaafcb3b5da060458e67f493c10a3f02266e328222f25f96b8229f8dfec37b2"; }
-    { locale = "ko"; arch = "linux-i686"; sha256 = "7a0a5957bb1cf2724e551fe2f05e06e4493f95ea939812f535a166428d127a25"; }
-    { locale = "ko"; arch = "linux-x86_64"; sha256 = "ee62aee7a4b549d95e4bcab696c28ada842f352111bb44f4d39d1fe05a49d970"; }
-    { locale = "lt"; arch = "linux-i686"; sha256 = "ed13eeea81f3673ae082e92db0cb966889f00cfc14c6f54f4f90677a3adc0fd4"; }
-    { locale = "lt"; arch = "linux-x86_64"; sha256 = "22fdb92474591dcb05fae0c6bf65d696bcba718b208224411867a38af187c87a"; }
-    { locale = "nb-NO"; arch = "linux-i686"; sha256 = "44c999f4f73d02ea3c336ceba5771ddd187ce241fd3dcc027f315bdd935ba1c4"; }
-    { locale = "nb-NO"; arch = "linux-x86_64"; sha256 = "04aaf3ce92aaadfc975730956b0e92a3b26b5b1abfb376bbc2e8c35b2b1d5169"; }
-    { locale = "nl"; arch = "linux-i686"; sha256 = "06b86c4bc4018e5117a8e8a129f81d8ca5fb2781bd06a2f2ec29fcaceba23d58"; }
-    { locale = "nl"; arch = "linux-x86_64"; sha256 = "186ee5e191160a72f6f5f99371412cc0cb44fc66184d5a33b0aa8cc480b784c7"; }
-    { locale = "nn-NO"; arch = "linux-i686"; sha256 = "0ce71ba703d3b307ae66502768c6fe924fbd838570f917e1ab65fc8ffedddfc8"; }
-    { locale = "nn-NO"; arch = "linux-x86_64"; sha256 = "4e5f3b1ac34c61ae977d9f346fa04de7a3b21a21756bbf120f5d1bd8f56a98c9"; }
-    { locale = "pa-IN"; arch = "linux-i686"; sha256 = "7b99742ca9ccca0f5151d4f9ff4b3fffbc9df5f6c8e89c3f2236da84639d6050"; }
-    { locale = "pa-IN"; arch = "linux-x86_64"; sha256 = "6e66778a0c318add8d8fdac631400af94a9fff77d90c1c039a91e3b4ae8e66fe"; }
-    { locale = "pl"; arch = "linux-i686"; sha256 = "7d50ff91e15954c4736309e23425603ae731c9d221936106a67517a5caf8c24d"; }
-    { locale = "pl"; arch = "linux-x86_64"; sha256 = "bc224b70b522199e6c3c7012f3aec9a4cd6b31feb8eea23e3701ff891bcd2d77"; }
-    { locale = "pt-BR"; arch = "linux-i686"; sha256 = "7194b4ef864aa1cfcc00d9ba108cb9436bfcb72fda9a4bf2ff3abbf47877a5f4"; }
-    { locale = "pt-BR"; arch = "linux-x86_64"; sha256 = "6a94b5a6448af6c273fa526b3a359f4435482d1f55f9fbd40ef0d7aded98b1ad"; }
-    { locale = "pt-PT"; arch = "linux-i686"; sha256 = "1a0fab79901d40fe8709e8675a3c8cc6cb6474e10c64730bcda13a3577f94334"; }
-    { locale = "pt-PT"; arch = "linux-x86_64"; sha256 = "3672d9b0e9de882ef9f9851e0ecd9deb52053c65b4a747ac8ef0700b53426f5a"; }
-    { locale = "rm"; arch = "linux-i686"; sha256 = "5f2008f9225ade5e1cff93f804e59b95f998129b1de7910280a3a7f508ea9ca5"; }
-    { locale = "rm"; arch = "linux-x86_64"; sha256 = "645d13223d1aaf5ca3768515e6d9ac12a4205834bf1329765fbc6ff0410eed8e"; }
-    { locale = "ro"; arch = "linux-i686"; sha256 = "582bafffc11ff585860b5af8e8f75d359f4f8e928c794cf35522c083089664ea"; }
-    { locale = "ro"; arch = "linux-x86_64"; sha256 = "bf3d9ca3e1ee0d55dd601d25be1b2f2c9ebbe78094a2df725704b060b834eda0"; }
-    { locale = "ru"; arch = "linux-i686"; sha256 = "3f3ebf446a22176b429cc328b002ffa723e27727ca29def5dfb88eeddef605f7"; }
-    { locale = "ru"; arch = "linux-x86_64"; sha256 = "41f17ef5311d0d1cb10893adb68ca312710f16b07c41d64b31695013cfe15cdd"; }
-    { locale = "si"; arch = "linux-i686"; sha256 = "de99654352ff974fcf0c83d0f6aca669bf6fbfcc6ad534b0a26568d30c650564"; }
-    { locale = "si"; arch = "linux-x86_64"; sha256 = "554e32f4c204a8c7aa1b3d83dd736524abc0595c5fde6c5f58b0b5a644133df1"; }
-    { locale = "sk"; arch = "linux-i686"; sha256 = "c54c6039343bd0bdbe449e6c8633a8aa18ce187850a4d81912b0751d84769fa4"; }
-    { locale = "sk"; arch = "linux-x86_64"; sha256 = "cc38fdc0202da4a7292564f3f30fc01080582991dd5a5fb28860ccb4f4c8d75f"; }
-    { locale = "sl"; arch = "linux-i686"; sha256 = "a276c5f8d1ce308f79f6ae6f95118164bd8882acc9c2aa8140c544626d1c1960"; }
-    { locale = "sl"; arch = "linux-x86_64"; sha256 = "ccbbb0cfd53a9ac5f500e7313111a74d305107578ab94e17bf54175f3366279e"; }
-    { locale = "sq"; arch = "linux-i686"; sha256 = "ede984ffb03f4a35ee18699a217d1d75492a4e7a372168a9c6ccc8fb7d133922"; }
-    { locale = "sq"; arch = "linux-x86_64"; sha256 = "43a3fdb69989c0365d568eb7d7e697fd9d94ce59f0438a3f9b0e615c255e1eb3"; }
-    { locale = "sr"; arch = "linux-i686"; sha256 = "48ee50e180515633db238d73ec8d50cd3dd5dd79e8ab7050f341a5be73401dd9"; }
-    { locale = "sr"; arch = "linux-x86_64"; sha256 = "2a7deb046cd8652e04aafcd88b8d621a2503f7061c6b48cdafcbc763143e88bd"; }
-    { locale = "sv-SE"; arch = "linux-i686"; sha256 = "e87406cb2503ab7cc0ee8df8ac4ec92c90e5033a0133da72b14fd72e736c5360"; }
-    { locale = "sv-SE"; arch = "linux-x86_64"; sha256 = "f6227e1c4442dca0ff7ececf90c03bd711d6a5a83d0f8bf9857dd5c964ed243f"; }
-    { locale = "ta-LK"; arch = "linux-i686"; sha256 = "758c22dac6d97296ef1543f7eafca7d937a2313dd09ac3ca4bfe401009afe210"; }
-    { locale = "ta-LK"; arch = "linux-x86_64"; sha256 = "5f1993c3c54cd0ae42cdac9606664d8127de26ef31a94ec4f7da264a233d788e"; }
-    { locale = "tr"; arch = "linux-i686"; sha256 = "68a3dce3a3c84d111b36dc544a82496364d3b16b411d70ee148bf8f9b8d650a0"; }
-    { locale = "tr"; arch = "linux-x86_64"; sha256 = "facf8cc17d37049ce5c48a9aec9ce97a46242c46c18b2b52a2b3d6ca14217f63"; }
-    { locale = "uk"; arch = "linux-i686"; sha256 = "836cd0eca497cc554da3e68e2274c16c875dc600b8541854a4c11e54e3262b49"; }
-    { locale = "uk"; arch = "linux-x86_64"; sha256 = "2fdaafbd212530c309639aa0ee3ebc113c8aeddf7811b5db51e9792a98deeecb"; }
-    { locale = "vi"; arch = "linux-i686"; sha256 = "9b263fb42a5ed939dc63a452e7cb87c295c6eaf270bfa97d9c858eed2931c0ae"; }
-    { locale = "vi"; arch = "linux-x86_64"; sha256 = "b7684a1836b489b5ef8ad9b28ce0837a846fa55305f83d3a998f6722a97c0e65"; }
-    { locale = "zh-CN"; arch = "linux-i686"; sha256 = "39b0d87388ae8646f7b81d1008e8b9019a3f702031103e497326bb80988559ed"; }
-    { locale = "zh-CN"; arch = "linux-x86_64"; sha256 = "c85ad956bb69a97abd116b30ca5e2303fe4aebdffb08a8120ce7fdeda161b117"; }
-    { locale = "zh-TW"; arch = "linux-i686"; sha256 = "e2f931b5ffbb1d6169e16125bcc40bc432debc01354f193450075d19f0a23a78"; }
-    { locale = "zh-TW"; arch = "linux-x86_64"; sha256 = "3d9310cec9c1370e6a9fa8185935c6c48c3029fc17b6f2fcc311e8f8565ac804"; }
+    { locale = "ar"; arch = "linux-i686"; sha256 = "29237bd1fff3790d891fcfa18959b808afa88c35b9c7036cc3cf79737560c3a5"; }
+    { locale = "ar"; arch = "linux-x86_64"; sha256 = "480120055452c284eef26329419faa176cc5abff90c3dd986ea1d3478b869984"; }
+    { locale = "ast"; arch = "linux-i686"; sha256 = "e659e19bc053a95bb4d753ff452637a29f792e61247fd1b70f70e90f62e8a268"; }
+    { locale = "ast"; arch = "linux-x86_64"; sha256 = "1755ad5c097b92342224f7d659fc1c0db899b15f6874fcd256f76fac1bf27488"; }
+    { locale = "be"; arch = "linux-i686"; sha256 = "3682652d2aae978ceef32b4dccb2e20c4dc5584b6840df823664c214495e89bd"; }
+    { locale = "be"; arch = "linux-x86_64"; sha256 = "99a5e05ea1cd5a302b24b0bf8a87e495de1bd044d7335609016fbae49786a6b0"; }
+    { locale = "bg"; arch = "linux-i686"; sha256 = "cd0b6cf8b620d619040a64f8692f78fcacf5500b5c092a6a40552397f56e2757"; }
+    { locale = "bg"; arch = "linux-x86_64"; sha256 = "4001a26df6cee9182b85370e51d9e54284a066e8f8002c6dafc2ca872153ca36"; }
+    { locale = "bn-BD"; arch = "linux-i686"; sha256 = "bcdc5791b3a95c12e8cb19f92d57191360fff12ddf116d92b8ca1b32aa977827"; }
+    { locale = "bn-BD"; arch = "linux-x86_64"; sha256 = "037459abe2bf39d0ca05b0abfb18d112b9e56b4888b64ae956a6317800cc0047"; }
+    { locale = "br"; arch = "linux-i686"; sha256 = "1c907debf9f9c9a949bd1c7e7329ebc2fbdd6ff19ecf9411a67ce27079dae1ee"; }
+    { locale = "br"; arch = "linux-x86_64"; sha256 = "ace19a987e0a5fb10cf73d1b031e96c9333054083ab380e9a602f00b3347f334"; }
+    { locale = "ca"; arch = "linux-i686"; sha256 = "5553dcde7e432643516405f465a981f52d5eaf3e53f7cec7d179034778d74122"; }
+    { locale = "ca"; arch = "linux-x86_64"; sha256 = "1d3ee5b1487ff62243147aaaa1ba984976a969ddc0c7697b1f361db6a5d66023"; }
+    { locale = "cs"; arch = "linux-i686"; sha256 = "d22a52c3e5d66a4cb8d084e7127f0acf79a36fbc1e96cccbb66adb205a4eb7a6"; }
+    { locale = "cs"; arch = "linux-x86_64"; sha256 = "f75b81a8a984ef52bd5a11fbd98f00b16a1696c5dca9b2315ca35d23ed6ad4b9"; }
+    { locale = "cy"; arch = "linux-i686"; sha256 = "0cae8f5bcff66cea0ea7a92f4503039078402eb149bca9a1bbbb170423a9625f"; }
+    { locale = "cy"; arch = "linux-x86_64"; sha256 = "e4d5c5d920489ad73ceb2a0582285d35bc9fdf2e817a14a20d563b3f36dca71b"; }
+    { locale = "da"; arch = "linux-i686"; sha256 = "7cdbc0622b71ead86d7d180fab328b4346bba324f43381680cb9e4cad026667d"; }
+    { locale = "da"; arch = "linux-x86_64"; sha256 = "95cb578a1b9d271c7597852be14c18bd057eae01ef62429197ea47cb97f367b7"; }
+    { locale = "de"; arch = "linux-i686"; sha256 = "5e7a7d84bba7e3ce06a31678e2b97439597b5185866586c69f61d3eeaead7bf8"; }
+    { locale = "de"; arch = "linux-x86_64"; sha256 = "6d221dc885188ae683eb0c103b8551d25f2c26a82456abfcaea695b4555c83e1"; }
+    { locale = "dsb"; arch = "linux-i686"; sha256 = "d5cc9990acc678c483bc19649d67af96dda0308f66eea61f5917fcb40db13a4f"; }
+    { locale = "dsb"; arch = "linux-x86_64"; sha256 = "01ad8dbd1b9fac2dfe269ed171ab6fe32751892147f136f9ab8c8d023ed0fe11"; }
+    { locale = "el"; arch = "linux-i686"; sha256 = "7040a9d0c51ce310e74e9d3b1c04f5088ba688212100700f78e1c7b4f8722739"; }
+    { locale = "el"; arch = "linux-x86_64"; sha256 = "e2a3b0f3b022c320b0b7b372442cb85ac716f85e757cdf107246a6b7d4715835"; }
+    { locale = "en-GB"; arch = "linux-i686"; sha256 = "c7258c7864087eb90d59f763ed0b23ee99f2a6a45c433d97e89583ea37ccdb32"; }
+    { locale = "en-GB"; arch = "linux-x86_64"; sha256 = "af32ae7ba6d7b61d46c074ec0086fce4150b5b6255eb43c3c17c97f597b688d1"; }
+    { locale = "en-US"; arch = "linux-i686"; sha256 = "c7794f3e1d51fa7e0935d689078b348114d3abf010a0525b22e5375950b6098e"; }
+    { locale = "en-US"; arch = "linux-x86_64"; sha256 = "01bb4a3bd43aa5dde30197178cb50ac35ac62cde637227aca8bdd410c9f62546"; }
+    { locale = "es-AR"; arch = "linux-i686"; sha256 = "f89e5f28d792161cd5b791ad68eb64c6a55a5de15dc00d5b042153b8fe549ab4"; }
+    { locale = "es-AR"; arch = "linux-x86_64"; sha256 = "a7c3102c5c5c6999723fa889af88f1d14630867334db8703ca9b5f5368359127"; }
+    { locale = "es-ES"; arch = "linux-i686"; sha256 = "a01fc84e9ce676f9b163e882cee5b6ca70b98a43b2937c6f5298f800b7ee3d78"; }
+    { locale = "es-ES"; arch = "linux-x86_64"; sha256 = "030840e14241776d60cbd1ce9d0790df4e4f7b1fd5f554df9a3a51c9421af573"; }
+    { locale = "et"; arch = "linux-i686"; sha256 = "f6da6a171f4a00afaf5af2fbcc6cdd7504e00cc38f62baad1f9aad51467ef191"; }
+    { locale = "et"; arch = "linux-x86_64"; sha256 = "8fed1407c48e0f7f39c888f08001ec0705c09b587a6921b2644e91020e8f2763"; }
+    { locale = "eu"; arch = "linux-i686"; sha256 = "0f1c30b2e5c6d1a2359a1714605ab382c617a00fb2a3ab9aa0570c27df6bc1a6"; }
+    { locale = "eu"; arch = "linux-x86_64"; sha256 = "5192b9230659a8ec35abf4353201d6f2ac66c1ffce33d0dd68c38dbb1302029c"; }
+    { locale = "fi"; arch = "linux-i686"; sha256 = "5812be19808c789c6f36484aad72ead4a5b75ce52d91047794da0c5919a4f68f"; }
+    { locale = "fi"; arch = "linux-x86_64"; sha256 = "64243724356329e81f8754f4bc1d3e848a6544f598ceec44ac63a69d52003944"; }
+    { locale = "fr"; arch = "linux-i686"; sha256 = "63117d10a3fa00b86eaf9023d562ca817ea44b89788de190d7870c22df6ee5b1"; }
+    { locale = "fr"; arch = "linux-x86_64"; sha256 = "22715532882458ff60ccf52c5502eddb5f7a9ef646a22915c3928ff6ca244bdf"; }
+    { locale = "fy-NL"; arch = "linux-i686"; sha256 = "9be2f10d9f5dcddc7b5119609ac9b864aa61b2e1839e3bdce3f4e742f5e94c12"; }
+    { locale = "fy-NL"; arch = "linux-x86_64"; sha256 = "a71900daca5ac832240fa27c15ad76afca75b8b86c101899c58f6ee20bd33fc2"; }
+    { locale = "ga-IE"; arch = "linux-i686"; sha256 = "4426fcb698d40fc796a3affafda1f142e4f252e3861354915a8ba4db41e28754"; }
+    { locale = "ga-IE"; arch = "linux-x86_64"; sha256 = "a7533879eda14dd1b6e8ce4e68006fd1d1fff9b7fec12c14f30871084625581c"; }
+    { locale = "gd"; arch = "linux-i686"; sha256 = "82593c88c14b6ac518d0da17aced0ffe4a78e06faf4275508218fd09da535f4b"; }
+    { locale = "gd"; arch = "linux-x86_64"; sha256 = "3ec0a23d6ac098dd97dec52778202d6dc24cd76d7f142a452b4309be32d9cc29"; }
+    { locale = "gl"; arch = "linux-i686"; sha256 = "64cd467c054da7506b5e72e159c0829a6d41db1482d9343a8cdd5b0bf7166d0f"; }
+    { locale = "gl"; arch = "linux-x86_64"; sha256 = "a9ec09c8cbc54f071f80226bb203f4f5823f71cf376978d0e69cefc5562cd5bf"; }
+    { locale = "he"; arch = "linux-i686"; sha256 = "bb21099de57446c1a9284fa54ed491bbd1d104b64f9c479b8d0ded607fb79c7d"; }
+    { locale = "he"; arch = "linux-x86_64"; sha256 = "4397b52af2d90e0642b7e66fc39b60987dbba94737666e205df8b1b0b4c280de"; }
+    { locale = "hr"; arch = "linux-i686"; sha256 = "65164ae7e551458bcb8afef5da13d1a632c7ddb181e112833b1fe0a0ab391c17"; }
+    { locale = "hr"; arch = "linux-x86_64"; sha256 = "e026eae7e0eb85558ad58616a90240e14bd9011bbe6ed5bcf68788ad21d182eb"; }
+    { locale = "hsb"; arch = "linux-i686"; sha256 = "c2bd24db8c46a11108241a3aa6f57f234aa52e982af013e081c4b45621878b7b"; }
+    { locale = "hsb"; arch = "linux-x86_64"; sha256 = "b01690e94a2f8b5d8049ac62061206fc296b6a7e2c609d3368facefa246f06e5"; }
+    { locale = "hu"; arch = "linux-i686"; sha256 = "7ea9be32fc7b198e300273a973162364a4dbe17bfa6b7e5fe39bd01fbd93c79e"; }
+    { locale = "hu"; arch = "linux-x86_64"; sha256 = "d9ca99cb52265fe8cf89c9b48469479dcb9e251f8c3f3527540c19f44439234b"; }
+    { locale = "hy-AM"; arch = "linux-i686"; sha256 = "899906072114caaab0e7f48a7b67f77dbeca7d2130171a2277c98116479951ea"; }
+    { locale = "hy-AM"; arch = "linux-x86_64"; sha256 = "6a636b312c1a38474cd26700b0419e2cb174c440e4ac652a6d29bf6837a2bdd1"; }
+    { locale = "id"; arch = "linux-i686"; sha256 = "9827c378de89d3eed6bd297233c934fa7a84796efb02d82a4be1f8235c2dbe6c"; }
+    { locale = "id"; arch = "linux-x86_64"; sha256 = "23075b98ac7a1674cd1189806680062eb0eb35cbe08d7d0592242295184932bc"; }
+    { locale = "is"; arch = "linux-i686"; sha256 = "e64f2b7dfa4654bb681bfa5c34adc9d64400c3c7dfb1f9dd7ab0c04d998c6784"; }
+    { locale = "is"; arch = "linux-x86_64"; sha256 = "2049e8c19e3a58f1f0f08926e786c3a2d81292d94eb0346b54ae86edba35bf3b"; }
+    { locale = "it"; arch = "linux-i686"; sha256 = "12941cb1feec8beacc8cf62b94f902ddacadc424abe511226be2e85248496a60"; }
+    { locale = "it"; arch = "linux-x86_64"; sha256 = "9da22cef1e8b5d92c048c8bee59ca88b9801f95073083c218412de0406af6dc4"; }
+    { locale = "ja"; arch = "linux-i686"; sha256 = "bdd5fee3bc2d807b1b6329f0f8f14bed85f8eacfc1210f4a5204687b7c0e250b"; }
+    { locale = "ja"; arch = "linux-x86_64"; sha256 = "c48477523b11d7ec6314f54c2d0d62b35c6474b06bbd7c0bd0317971303a1073"; }
+    { locale = "ko"; arch = "linux-i686"; sha256 = "d887a32f4073231856522ba034c4e952eb56d7ed06895e0d26dfc3d3a7488b0f"; }
+    { locale = "ko"; arch = "linux-x86_64"; sha256 = "c02ff12289d32d5d3ad5f88a5c851f46f8d31c66ce8013622959f537cae1101b"; }
+    { locale = "lt"; arch = "linux-i686"; sha256 = "99095f5f55c3ce6d0bb485d25eff1afdadb63e8f41caaddacceced71a92bbb9e"; }
+    { locale = "lt"; arch = "linux-x86_64"; sha256 = "a4de32255d7334bf1eabda06332f8665a9d60bdf667a43c219ba2de08865f1e8"; }
+    { locale = "nb-NO"; arch = "linux-i686"; sha256 = "8b547faa6f76d1aa1f0f33235380e5379663c5d6e66e55ea0baa61a62f37e272"; }
+    { locale = "nb-NO"; arch = "linux-x86_64"; sha256 = "17873b2664d665d1d53fe69c4041aa6474f58a18cf5dc0f86b739d95d193bb48"; }
+    { locale = "nl"; arch = "linux-i686"; sha256 = "ba36cb5c4b008f878b181ed3ff56198cd83739fb9d2018d6710288daafa6df7a"; }
+    { locale = "nl"; arch = "linux-x86_64"; sha256 = "04afe1c59bfdfb9573623e9e84165863465356ec7872f1afc448c841c4e9392d"; }
+    { locale = "nn-NO"; arch = "linux-i686"; sha256 = "2fa6cc0e585574d3460597b25c6549b2aebd2b2af203edef960dea2b81bae954"; }
+    { locale = "nn-NO"; arch = "linux-x86_64"; sha256 = "ca8bdb92d16a89f7baca59e0c11662d2dfead62eb209746d738fbccbea8d00c5"; }
+    { locale = "pa-IN"; arch = "linux-i686"; sha256 = "79575806b00f77adae3b2ad794c2e268436e2b4b2904186ea88caa2bbcc5e232"; }
+    { locale = "pa-IN"; arch = "linux-x86_64"; sha256 = "2220b6bc45f98f088c653ee255718613b43e93691173441f0825c39e3ea8c263"; }
+    { locale = "pl"; arch = "linux-i686"; sha256 = "829788db6afdb0f09b23d0230abf176153a252a76964ae4ad6df161568e03b6b"; }
+    { locale = "pl"; arch = "linux-x86_64"; sha256 = "89792685c6ff26bae9d42326dbe0ca77b6a651df51ba02bd76a85692c83aba5a"; }
+    { locale = "pt-BR"; arch = "linux-i686"; sha256 = "b7898b8fde2c32c8d7fe105ab88751fb9acaa756f3826dfaab3fa33fa7bfd5a4"; }
+    { locale = "pt-BR"; arch = "linux-x86_64"; sha256 = "691e722d24695960574fb5423d2d5713d3729a0cf3bbffdbe3f550b1b0a8a91b"; }
+    { locale = "pt-PT"; arch = "linux-i686"; sha256 = "06e9c005c45b6d71e4f4957ae0d92578baf2b0ff783f38dca4a5018f84319bfd"; }
+    { locale = "pt-PT"; arch = "linux-x86_64"; sha256 = "5422bf1e694a462864759374bc3afdf9f0033121b879413a3edc18a20d406b4e"; }
+    { locale = "rm"; arch = "linux-i686"; sha256 = "54c0f6dfc40b748f74ab9fd79dd4b0987ce17eced23b293cf83b1867f38d7c53"; }
+    { locale = "rm"; arch = "linux-x86_64"; sha256 = "a164dfa18736b3f84ce2a80fea1f6441bbd3de113c26eab503ab7710866f7555"; }
+    { locale = "ro"; arch = "linux-i686"; sha256 = "3135adfb8c2b674545d3e80a8f3d77a89332dbe4cdff0f05817d5ae2edac8025"; }
+    { locale = "ro"; arch = "linux-x86_64"; sha256 = "7a95f8853d5776267ab62fcc208214a7a4f2a7d82350ac7967ca90ab2178e737"; }
+    { locale = "ru"; arch = "linux-i686"; sha256 = "df9cb429c6fe10e7aeae06d49329fed27cf9cd84b3b28e7fef82008399dfe453"; }
+    { locale = "ru"; arch = "linux-x86_64"; sha256 = "aa97b360bd5cfd0686b0d75df21500249e0f7ab1586e37774d60040abdd2ecd8"; }
+    { locale = "si"; arch = "linux-i686"; sha256 = "ba1ef9b8576589a9bf8523f26fe42416f14f4c38b74b4519792aff6896a4c34b"; }
+    { locale = "si"; arch = "linux-x86_64"; sha256 = "bcd73d4a1187d8e43dcbfd7bb4df3c0f7893175785d633113b0a5b526bb718d8"; }
+    { locale = "sk"; arch = "linux-i686"; sha256 = "004423ed395fcc4cba02e703f5086f9255758edd2bd3125adeb8fb006a4f769e"; }
+    { locale = "sk"; arch = "linux-x86_64"; sha256 = "9abb27a35c2076fc3c85e18b20f909ba41b4618afda51f2adbb0ef960b67483f"; }
+    { locale = "sl"; arch = "linux-i686"; sha256 = "ff2dca954720bcb1947c18b1013666c6568f6638b204adf5a0277e6bff64f468"; }
+    { locale = "sl"; arch = "linux-x86_64"; sha256 = "a334a65d54efaacdafcddad336f313d24b594c14bfc874159cd9a4ca9ded2b03"; }
+    { locale = "sq"; arch = "linux-i686"; sha256 = "b5e53cd682a8b4494074c1c0c7e4d4fb94a36a06e81522cb4b7289b4ed6bd486"; }
+    { locale = "sq"; arch = "linux-x86_64"; sha256 = "747174de108fcf0a7201e22df90f613846a0b66384b007ccddeb51b6dc651aca"; }
+    { locale = "sr"; arch = "linux-i686"; sha256 = "fa53bfe3c00878b462e6aa3a0bf76a6e1e4dc6d9095f2104a355ac5b773e936c"; }
+    { locale = "sr"; arch = "linux-x86_64"; sha256 = "308965f1b97405e7c6db95e7cffae69fe6a899539782c06b1446ab97ddb19d45"; }
+    { locale = "sv-SE"; arch = "linux-i686"; sha256 = "0b2e6e13cd30b46b81c8fb9fd195d27ce96c40f03d17ba0f8095d4ddd226ff45"; }
+    { locale = "sv-SE"; arch = "linux-x86_64"; sha256 = "dc47f9c38a845461db14a08d67f143c8b5ba04aa441aeecae8bd8f3cbf79fca6"; }
+    { locale = "ta-LK"; arch = "linux-i686"; sha256 = "3f5afc0975aebe8981202927fe5507065c47ccd64f1ddd8adb426c0032ee267e"; }
+    { locale = "ta-LK"; arch = "linux-x86_64"; sha256 = "8a9b241836c0b495865e9d64d2e89cb054a01e8e3fb55ee8a1cbbd0def7d5a93"; }
+    { locale = "tr"; arch = "linux-i686"; sha256 = "c104cbdfaee89946ab11b3bc0de6cfaf5d88f5e18a6be400dc573e7b1c10319d"; }
+    { locale = "tr"; arch = "linux-x86_64"; sha256 = "717c460478cdb986fbfcd5fcd16f7fb66af930e3ca2826176b7158ff865d51a5"; }
+    { locale = "uk"; arch = "linux-i686"; sha256 = "dcfbdd8ba1897bdfcb26b0ec1c50a88808c2ca988418cca56eab74e1f870ba1c"; }
+    { locale = "uk"; arch = "linux-x86_64"; sha256 = "648764a8aad2ea954416f2293023598cd26d4bae1bb44da1406868d1286c3f58"; }
+    { locale = "vi"; arch = "linux-i686"; sha256 = "2b938e4c4614de013b9e0f7d4bdde0353cea42c7651491f2d92323a25d9157d6"; }
+    { locale = "vi"; arch = "linux-x86_64"; sha256 = "82571f95eaf3a88c7cc7fc056779ed4f4ea5664333c5e015ccd4995fc48ca0a7"; }
+    { locale = "zh-CN"; arch = "linux-i686"; sha256 = "db6a5619c7fcd9487ecd5518590a7ad28ee4a9fd12348c950ce1b12de5232dfe"; }
+    { locale = "zh-CN"; arch = "linux-x86_64"; sha256 = "36ac3599d3bba4a4e982df6cbb355becc0e0e237b127c3b2afea3618754fafbe"; }
+    { locale = "zh-TW"; arch = "linux-i686"; sha256 = "269dccd617074567654a053186d6830fff38503431156db5a00d70bef093bf0e"; }
+    { locale = "zh-TW"; arch = "linux-x86_64"; sha256 = "c78e2ad7df58f86a26bb81c13a27a8722884573278a1dd179ffba577902c92e5"; }
  ];
 }
--- a/pkgs/applications/networking/newsreaders/liferea/default.nix
+++ b/pkgs/applications/networking/newsreaders/liferea/default.nix
@ -6,14 +6,14 @@
 }:

 let pname = "liferea";
-    version = "1.10.16";
+    version = "1.10.17";
 in
 stdenv.mkDerivation rec {
  name = "${pname}-${version}";

  src = fetchurl {
    url = "https://github.com/lwindolf/${pname}/releases/download/v${version}/${name}.tar.bz2";
-    sha256 = "0b8cvlyiamc4hwjcxzs0h3mk3gxnmnwyi79mjv36601xgfjs5f9j";
+    sha256 = "0svgl50w3hai31n5sm42sl0cd86c32cka0xzfy4r8gi0lyjdjxyx";
  };

  buildInputs = with gst_all_1; [
@ -37,12 +37,12 @@ stdenv.mkDerivation rec {
    done
  '';

-  meta = {
+  meta = with stdenv.lib; {
    description = "A GTK-based news feed agregator";
    homepage = http://lzone.de/liferea/;
-    license = stdenv.lib.licenses.gpl2Plus;
-    maintainers = with stdenv.lib.maintainers; [ vcunat romildo ];
-    platforms = stdenv.lib.platforms.linux;
+    license = licenses.gpl2Plus;
+    maintainers = with maintainers; [ vcunat romildo ];
+    platforms = platforms.linux;

    longDescription = ''
      Liferea (Linux Feed Reader) is an RSS/RDF feed reader.
--- a/pkgs/applications/networking/sniffers/wireshark/default.nix
+++ b/pkgs/applications/networking/sniffers/wireshark/default.nix
@ -1,6 +1,7 @@
 { stdenv, fetchurl, pkgconfig, perl, flex, bison, libpcap, libnl, c-ares
 , gnutls, libgcrypt, geoip, openssl, lua5, makeDesktopItem, python, libcap, glib
-, withGtk ? false, gtk ? null
+, zlib
+, withGtk ? false, gtk ? null, pango ? null, cairo ? null, gdk_pixbuf ? null
 , withQt ? false, qt4 ? null
 }:

@ -24,9 +25,9 @@ stdenv.mkDerivation {

  buildInputs = [
    bison flex perl pkgconfig libpcap lua5 openssl libgcrypt gnutls
-    geoip libnl c-ares python libcap glib
+    geoip libnl c-ares python libcap glib zlib
  ] ++ optional withQt qt4
-    ++ optional withGtk gtk;
+    ++ (optionals withGtk [gtk pango cairo gdk_pixbuf]);

  patches = [ ./wireshark-lookup-dumpcap-in-path.patch ];

@ -52,8 +53,6 @@ stdenv.mkDerivation {
    mkdir -p "$out"/share/icons/
    cp "$desktopItem/share/applications/"* "$out/share/applications/"
    cp image/wsicon.svg "$out"/share/icons/wireshark.svg
-  '' + optionalString withQt ''
-    mv "$out/bin/wireshark-qt" "$out/bin/wireshark"
  '';

  enableParallelBuilding = true;
--- a/pkgs/applications/networking/sync/rsync/default.nix
+++ b/pkgs/applications/networking/sync/rsync/default.nix
@ -7,18 +7,18 @@ assert enableACLs -> acl != null;

 stdenv.mkDerivation rec {
  name = "rsync-${version}";
-  version = "3.1.1";
+  version = "3.1.2";

  mainSrc = fetchurl {
    # signed with key 0048 C8B0 26D4 C96F 0E58  9C2F 6C85 9FB1 4B96 A8C5
    url = "mirror://samba/rsync/src/rsync-${version}.tar.gz";
-    sha256 = "0896iah6w72q5izpxgkai75bn40dqkqifi2ivcxjzr2zrx7kdr3x";
+    sha256 = "1hm1q04hz15509f0p9bflw4d6jzfvpm1d36dxjwihk1wzakn5ypc";
  };

  patchesSrc = fetchurl {
    # signed with key 0048 C8B0 26D4 C96F 0E58  9C2F 6C85 9FB1 4B96 A8C5
    url = "mirror://samba/rsync/rsync-patches-${version}.tar.gz";
-    sha256 = "0iij996xbyn20yr4w3kv3rw3cx4jwkg2k85x6w5hb5xlgsis8zjl";
+    sha256 = "09i3dcl37p22dp75vlnsvx7bm05ggafnrf1zwhf2kbij4ngvxvpd";
  };

  srcs = [mainSrc] ++ stdenv.lib.optional enableCopyDevicesPatch patchesSrc;
--- a/pkgs/applications/networking/vnstat/default.nix
+++ b/pkgs/applications/networking/vnstat/default.nix
@ -1,29 +1,32 @@
-{stdenv, fetchurl, ncurses}:
+{ stdenv, fetchurl, gd, ncurses }:

-let version = "1.14"; in
+let version = "1.15"; in
 stdenv.mkDerivation rec {
  name = "vnstat-${version}";

  src = fetchurl {
-    sha256 = "11l39qqv5pgli9zzn0xilld67bi5qzxymsn97m4r022xv13jlipq";
+    sha256 = "0fdw3nbrfm4acv48r0934ls6ld5lwkff3gyym2c72qlbm9dlp0f3";
    url = "http://humdi.net/vnstat/${name}.tar.gz";
  };

-  installPhase = ''
-    mkdir -p $out/{bin,sbin} $out/share/man/{man1,man5}
-    cp src/vnstat $out/bin
-    cp src/vnstatd $out/sbin
-    cp man/vnstat.1 man/vnstatd.1 $out/share/man/man1
-    cp man/vnstat.conf.5 $out/share/man/man5
-  '';
+  buildInputs = [ gd ncurses ];

-  buildInputs = [ncurses];
+  postPatch = ''
+    substituteInPlace src/cfg.c --replace /usr/local $out
+  '';

  meta = with stdenv.lib; {
    inherit version;
+    description = "Console-based network statistics utility for Linux";
+    longDescription = ''
+      vnStat is a console-based network traffic monitor for Linux and BSD that
+      keeps a log of network traffic for the selected interface(s). It uses the
+      network interface statistics provided by the kernel as information source.
+      This means that vnStat won't actually be sniffing any traffic and also
+      ensures light use of system resources.
+    '';
    homepage = http://humdi.net/vnstat/;
    license = licenses.gpl2Plus;
-    description = "Console-based network statistics utility for Linux";
    maintainers = with maintainers; [ nckx ];
    platforms = platforms.linux;
  };
--- a/pkgs/applications/office/libreoffice/default.nix
+++ b/pkgs/applications/office/libreoffice/default.nix
@ -20,7 +20,7 @@ let
  langsSpaces = stdenv.lib.concatStringsSep " " langs;
  major = "5";
  minor = "0";
-  patch = "2";
+  patch = "4";
  tweak = "2";
  subdir = "${major}.${minor}.${patch}";
  version = "${subdir}${if tweak == "" then "" else "."}${tweak}";
@ -47,14 +47,14 @@ let

    translations = fetchSrc {
      name = "translations";
-      sha256 = "06w1gz78136bs6fbwslxz5zsg538yqfarkq1am7zn8rzczz2qplh";
+      sha256 = "1kdrs49agqhb2b687hqh6sq7328z2sf04dmhb3xv5zy4rjvv5pha";
    };

    # TODO: dictionaries

    help = fetchSrc {
      name = "help";
-      sha256 = "157hypz093vhqbysygx5q4fbb81785m2b7slccfkp8x87dcsahj3";
+      sha256 = "005jwny8xmsnvvh0xkk9csnqv2jkaslr2n9xm82bqalcg81j0g2x";
    };

  };
@ -63,7 +63,7 @@ in stdenv.mkDerivation rec {

  src = fetchurl {
    url = "http://download.documentfoundation.org/libreoffice/src/${subdir}/libreoffice-${version}.tar.xz";
-    sha256 = "0xn1pg72vfdajmhak6chajvd51h74jqvq2565xv3j823143niw01";
+    sha256 = "1j3dmk5xifcgmd6dgqqifzh8wmc7daqfbkvk6cxa94611yvl0x34";
  };

  # Openoffice will open libcups dynamically, so we link it directly
--- a/pkgs/applications/office/libreoffice/generate-libreoffice-srcs.sh
+++ b/pkgs/applications/office/libreoffice/generate-libreoffice-srcs.sh
@ -0,0 +1,54 @@
+#!/run/current-system/sw/bin/bash
+
+# Take the list of files from the main package, ooo.lst.in
+
+cat <<EOF
+[
+EOF
+
+write_entry(){
+  echo '{'
+  echo "  name = \"${name}\";"
+  echo "  md5 = \"${md5}\";"
+  echo "  brief = ${brief};"
+  echo '}'
+}
+
+while read line; do
+  case "$line" in
+    \#*)
+      echo Skipping comment: "$line" >&2;
+      ;;
+    *_MD5SUM\ :=*)
+      read tbline;
+      line=${line##* };
+      if [ "${tbline#*VERSION_MICRO}" != "$tbline" ]; then
+         verline=${tbline##* };
+         read tbline;
+         tbline=${tbline##* };
+         md5=$line
+         name=$tbline;
+         name="${name/\$([A-Z]*_VERSION_MICRO)/$verline}"
+      else
+         tbline=${tbline##* };
+         md5=$line
+         name=$tbline;
+      fi
+      brief=true;
+      write_entry;
+      ;;
+    *_TARBALL\ :=*)
+      line=${line##* };
+      line="${line#,}"
+      md5=${line:0:32};
+      name=${line:33};
+      brief=false;
+      write_entry;
+      ;;
+    *)
+      echo Skipping: "$line" >&2;
+      ;;
+  esac
+done
+
+echo ']'
--- a/pkgs/applications/office/libreoffice/libreoffice-srcs.nix
+++ b/pkgs/applications/office/libreoffice/libreoffice-srcs.nix
@ -1,15 +1,14 @@
-# DEPRECATED: these dependencies sould be system libraries
 [
+{
+  name = "libabw-0.1.1.tar.bz2";
+  md5 = "7a3815b506d064313ba309617b6f5a0b";
+  brief = true;
+}
 {
  name = "commons-codec-1.6-src.tar.gz";
  md5 = "2e482c7567908d334785ce7d69ddfff7";
  brief = false;
 }
-{
-  name = "commons-codec-1.9-src.zip";
-  md5 = "048751f3271906db5126ab76870444c4";
-  brief = false;
-}
 {
  name = "commons-httpclient-3.1-src.tar.gz";
  md5 = "2c9b0f83ed5890af02c0df1c1776f39b";
@ -20,11 +19,6 @@
  md5 = "625ff5f2f968dd908bca43c9469d6e6b";
  brief = false;
 }
-{
-  name = "commons-lang3-3.3.1-src.tar.gz";
-  md5 = "8ab049135b2d15313da5d9f0656894a1";
-  brief = false;
-}
 {
  name = "commons-logging-1.2-src.tar.gz";
  md5 = "ce977548f1cbf46918e93cd38ac35163";
@ -40,21 +34,61 @@
  md5 = "71a11d037240b292f824ba1eb537b4e3";
  brief = true;
 }
+{
+  name = "boost_1_55_0.tar.bz2";
+  md5 = "d6eef4b4cacb2183f2bf265a5a03a354";
+  brief = false;
+}
+{
+  name = "bsh-2.0b5-src.zip";
+  md5 = "ec1941a74d3ef513c4ce57a9092b74e1";
+  brief = false;
+}
+{
+  name = "cairo-1.10.2.tar.gz";
+  md5 = "f101a9e88b783337b20b2e26dfd26d5f";
+  brief = false;
+}
+{
+  name = "libcdr-0.1.1.tar.bz2";
+  md5 = "b33fd0be3befdd1b37777e08ce058bd9";
+  brief = true;
+}
 {
  name = "clucene-core-2.3.3.4.tar.gz";
  md5 = "48d647fbd8ef8889e5a7f422c1bfda94";
  brief = false;
 }
+{
+  name = "libcmis-0.5.0.tar.gz";
+  md5 = "5821b806a98e6c38370970e682ce76e8";
+  brief = false;
+}
+{
+  name = "CoinMP-1.7.6.tgz";
+  md5 = "1cce53bf4b40ae29790d2c5c9f8b1129";
+  brief = true;
+}
 {
  name = "collada2gltf-master-cb1d97788a.tar.bz2";
  md5 = "4b87018f7fff1d054939d19920b751a0";
  brief = false;
 }
 {
-  name = "ConvertTextToNumber-1.3.2.oxt";
-  md5 = "451ccf439a36a568653b024534669971";
+  name = "cppunit-1.13.2.tar.gz";
+  md5 = "d1c6bdd5a76c66d2c38331e2d287bc01";
+  brief = true;
+}
+{
+  name = "converttexttonumber-1-5-0.oxt";
+  md5 = "1f467e5bb703f12cbbb09d5cf67ecf4a";
  brief = false;
 }
+{
+  name = "curl-7.43.0.tar.bz2";
+  md5 = "11bddbb452a8b766b932f859aaeeed39";
+  brief = true;
+}
 {
  name = "libe-book-0.1.2.tar.bz2";
  md5 = "6b48eda57914e6343efebc9381027b78";
@ -75,6 +109,16 @@
  md5 = "dd7dab7a5fea97d2a6a43f511449b7cd";
  brief = false;
 }
+{
+  name = "Firebird-2.5.2.26540-0.tar.bz2";
+  md5 = "21154d2004e025c8a3666625b0357bb5";
+  brief = true;
+}
+{
+  name = "fontconfig-2.8.0.tar.gz";
+  md5 = "77e15a92006ddc2adbb06f840d591c0e";
+  brief = false;
+}
 {
  name = "crosextrafonts-20130214.tar.gz";
  md5 = "368f114c078f94214a308a74c7e991bc";
@ -140,6 +184,16 @@
  md5 = "dbf2caca1d3afd410a29217a9809d397";
  brief = false;
 }
+{
+  name = "glew-1.10.0.zip";
+  md5 = "594eb47b4b1210e25438d51825404d5a";
+  brief = false;
+}
+{
+  name = "glm-0.9.4.6-libreoffice.zip";
+  md5 = "bae83fa5dc7f081768daace6e199adc3";
+  brief = false;
+}
 {
  name = "graphite2-1.2.4.tgz";
  md5 = "2ef839348fe28e3b923bf8cced440227";
@ -226,8 +280,18 @@
  brief = false;
 }
 {
-  name = "language-subtag-registry-2015-06-08.tar.bz2";
-  md5 = "d431bd8a70455be1fa8523fa633c005b";
+  name = "jpegsrc.v9a.tar.gz";
+  md5 = "3353992aecaee1805ef4109aadd433e7";
+  brief = true;
+}
+{
+  name = "libjpeg-turbo-1.3.1.tar.gz";
+  md5 = "2c3a68129dac443a72815ff5bb374b05";
+  brief = true;
+}
+{
+  name = "language-subtag-registry-2015-08-04.tar.bz2";
+  md5 = "bf5986dbfa1c9a0f26cf1b00ed369484";
  brief = true;
 }
 {
@ -259,7 +323,6 @@
  name = "libgltf-0.0.2.tar.bz2";
  md5 = "d63a9f47ab048f5009d90693d6aa6424";
  brief = true;
-  subDir = "libgltf/";
 }
 {
  name = "liblangtag-0.5.1.tar.bz2";
@ -271,11 +334,26 @@
  md5 = "1f24ab1d39f4a51faf22244c94a6203f";
  brief = false;
 }
+{
+  name = "libxml2-2.9.3.tar.gz";
+  md5 = "daece17e045f1c107610e137ab50c179";
+  brief = false;
+}
+{
+  name = "libxslt-1.1.28.tar.gz";
+  md5 = "9667bf6f9310b957254fdcf6596600b7";
+  brief = false;
+}
 {
  name = "lp_solve_5.5.tar.gz";
  md5 = "26b3e95ddf3d9c077c480ea45874b3b8";
  brief = false;
 }
+{
+  name = "mariadb_client-2.0.0-src.tar.gz";
+  md5 = "a233181e03d3c307668b4c722d881661";
+  brief = false;
+}
 {
  name = "mdds_0.12.1.tar.bz2";
  md5 = "ef2560ed5416652a7fe195305b14cebe";
@ -307,8 +385,8 @@
  brief = false;
 }
 {
-  name = "nss-3.19.2-with-nspr-4.10.8.tar.gz";
-  md5 = "2100bc5a7ea9685928ff68cda2e60569";
+  name = "nss-3.19.4-with-nspr-4.10.10.tar.gz";
+  md5 = "478e0e90ebc4a90159549e77021021fd";
  brief = false;
 }
 {
@ -321,6 +399,16 @@
  md5 = "4ca8a6ef0afeefc864e9ef21b9f14bd6";
  brief = true;
 }
+{
+  name = "openldap-2.4.31.tgz";
+  md5 = "804c6cb5698db30b75ad0ff1c25baefd";
+  brief = false;
+}
+{
+  name = "openssl-1.0.2a.tar.gz";
+  md5 = "a06c547dac9044161a477211049f60ef";
+  brief = true;
+}
 {
  name = "liborcus-0.7.0.tar.bz2";
  md5 = "7681383be6ce489d84c1c74f4e7f9643";
@ -337,8 +425,8 @@
  brief = false;
 }
 {
-  name = "libpng-1.5.18.tar.gz";
-  md5 = "5266905cef49d1224437465ad4d67fd9";
+  name = "libpng-1.5.24.tar.gz";
+  md5 = "6652e428d1d3fc3c6cb1362159b1cf3b";
  brief = true;
 }
 {
@ -346,6 +434,16 @@
  md5 = "35c0660065d023365e9854c13e289d12";
  brief = true;
 }
+{
+  name = "postgresql-9.2.1.tar.bz2";
+  md5 = "c0b4799ea9850eae3ead14f0a60e9418";
+  brief = false;
+}
+{
+  name = "Python-3.3.5.tgz";
+  md5 = "803a75927f8f241ca78633890c798021";
+  brief = true;
+}
 {
  name = "raptor2-2.0.9.tar.gz";
  md5 = "4ceb9316488b0ea01acf011023cf7fff";
@ -386,9 +484,39 @@
  md5 = "0168229624cfac409e766913506961a8";
  brief = false;
 }
+{
+  name = "vigra1.6.0.tar.gz";
+  md5 = "d62650a6f908e85643e557a236ea989c";
+  brief = false;
+}
+{
+  name = "libvisio-0.1.1.tar.bz2";
+  md5 = "726c1f5be65eb7d649e0d48b63d920e7";
+  brief = true;
+}
+{
+  name = "libwpd-0.10.0.tar.bz2";
+  md5 = "0773d79a1f240ef9f4f20242b13c5bb7";
+  brief = true;
+}
+{
+  name = "libwpg-0.3.0.tar.bz2";
+  md5 = "17da9770cb8b317b7633f9807b32b71a";
+  brief = true;
+}
+{
+  name = "libwps-0.4.0.tar.bz2";
+  md5 = "e9162d2566421d9d71b3ad2377a68fd5";
+  brief = true;
+}
 {
  name = "xsltml_2.1.2.zip";
  md5 = "a7983f859eafb2677d7ff386a023bc40";
  brief = false;
 }
+{
+  name = "zlib-1.2.8.tar.gz";
+  md5 = "44d667c142d7cda120332623eab69f40";
+  brief = true;
+}
 ]
--- a/pkgs/applications/science/math/pari/default.nix
+++ b/pkgs/applications/science/math/pari/default.nix
@ -1,12 +1,12 @@
 { stdenv, fetchurl, gmp, readline }:

 stdenv.mkDerivation rec {
-  version = "2.7.4";
+  version = "2.7.5";
  name = "pari-${version}";

  src = fetchurl {
    url = "http://pari.math.u-bordeaux.fr/pub/pari/unix/${name}.tar.gz";
-    sha256 = "0k1qqagfl6zn7gvwmsqffj6g9yrzqvszwh2mblhmxpjlw1pigfh8";
+    sha256 = "0c8l83a0gjq73r9hndsrzkypwxvnnm4pxkkzbg6jm95m80nzwh11";
  };

  buildInputs = [gmp readline];
--- a/pkgs/applications/version-management/cvs2svn/default.nix
+++ b/pkgs/applications/version-management/cvs2svn/default.nix
@ -1,11 +1,11 @@
-{stdenv, fetchurl, python, makeWrapper}:
+{stdenv, lib, fetchurl, python, cvs, makeWrapper}:

-stdenv.mkDerivation {
-  name = "cvs2svn-2.0.1";
+stdenv.mkDerivation rec {
+  name = "cvs2svn-2.4.0";

  src = fetchurl {
-    url = http://cvs2svn.tigris.org/files/documents/1462/39919/cvs2svn-2.0.1.tar.gz;
-    sha256 = "1pgbyxzgn22lnw3h5c2nd8z46pkk863jg3fgh9pqa1jihsx1cg1j";
+    url = "http://cvs2svn.tigris.org/files/documents/1462/49237/${name}.tar.gz";
+    sha256 = "05piyrcp81a1jgjm66xhq7h1sscx42ccjqaw30h40dxlwz1pyrx6";
  };

  buildInputs = [python makeWrapper];
@ -13,8 +13,11 @@ stdenv.mkDerivation {
  buildPhase = "true";
  installPhase = ''
    python ./setup.py install --prefix=$out
-    wrapProgram $out/bin/cvs2svn \
-        --set PYTHONPATH "$(toPythonPath $out):$PYTHONPATH"
+    for i in bzr svn git; do
+      wrapProgram $out/bin/cvs2$i \
+          --prefix PATH : "${lib.makeSearchPath "bin" [ cvs ]}" \
+          --set PYTHONPATH "$(toPythonPath $out):$PYTHONPATH"
+    done
  '';

  /* !!! maybe we should absolutise the program names in
@ -23,5 +26,6 @@ stdenv.mkDerivation {
  meta = {
    description = "A tool to convert CVS repositories to Subversion repositories";
    homepage = http://cvs2svn.tigris.org/;
+    maintainers = [ lib.maintainers.makefu ];
  };
 }
--- a/pkgs/applications/version-management/git-and-tools/default.nix
+++ b/pkgs/applications/version-management/git-and-tools/default.nix
@ -94,6 +94,8 @@ rec {

  svn2git_kde = callPackage ./svn2git-kde { };

+  subgit = callPackage ./subgit { };
+
  darcsToGit = callPackage ./darcs-to-git { };

  gitflow = callPackage ./gitflow { };
--- a/pkgs/applications/version-management/git-and-tools/git/default.nix
+++ b/pkgs/applications/version-management/git-and-tools/git/default.nix
@ -34,7 +34,8 @@ stdenv.mkDerivation {
    ++ stdenv.lib.optionals guiSupport [tcl tk];

  # required to support pthread_cancel()
-  NIX_LDFLAGS = stdenv.lib.optionalString (!stdenv.isDarwin) "-lgcc_s";
+  NIX_LDFLAGS = stdenv.lib.optionalString (!stdenv.cc.isClang) "-lgcc_s"
+              + stdenv.lib.optionalString (stdenv.isFreeBSD) "-lthr";

  # without this, git fails when trying to check for /etc/gitconfig existence
  propagatedSandboxProfile = stdenv.lib.sandbox.allowDirectoryList "/etc";
--- a/pkgs/applications/version-management/git-and-tools/subgit/default.nix
+++ b/pkgs/applications/version-management/git-and-tools/subgit/default.nix
@ -0,0 +1,26 @@
+{ stdenv, fetchurl, unzip, makeWrapper, jre }:
+
+stdenv.mkDerivation {
+  name = "subgit-3.1.0";
+
+  meta = {
+    description = "A tool for a smooth, stress-free SVN to Git migration";
+    longDescription = "Create writable Git mirror of a local or remote Subversion repository and use both Subversion and Git as long as you like. You may also do a fast one-time import from Subversion to Git.";
+    homepage = http://subgit.com;
+    license = stdenv.lib.licenses.unfree;
+    platforms = stdenv.lib.platforms.all;
+  };
+
+  buildInputs = [ unzip makeWrapper ];
+
+  installPhase = ''
+    mkdir $out;
+    cp -r bin lib $out;
+    wrapProgram $out/bin/subgit --set JAVA_HOME ${jre};
+  '';
+
+  src = fetchurl {
+    url = http://old.subgit.com/download/subgit-3.1.0.zip;
+    sha256 = "08qhpg6y2ziwplm0z1ghh1wfp607sw4hyb53a7qzfn759j5kcdrg";
+  };
+}
--- a/pkgs/applications/video/clipgrab/default.nix
+++ b/pkgs/applications/video/clipgrab/default.nix
@ -1,11 +1,11 @@
 { stdenv, fetchurl, makeDesktopItem, ffmpeg, qt4 }:

-let version = "3.5.5"; in
+let version = "3.5.6"; in
 stdenv.mkDerivation rec {
  name = "clipgrab-${version}";

  src = fetchurl {
-    sha256 = "01si6mqfmdwins6l18l6qyhkak0mj4yksbg30qhwywm8wmwl08jd";
+    sha256 = "0wm6hqaq6ydbvvd0fqkfydxd5h7gf4di7lvq63xgxl4z40jqc25n";
    # The .tar.bz2 "Download" link is a binary blob, the source is the .tar.gz!
    url = "http://download.clipgrab.de/${name}.tar.gz";
  };
--- a/pkgs/applications/virtualization/virt-viewer/default.nix
+++ b/pkgs/applications/virtualization/virt-viewer/default.nix
@ -1,6 +1,6 @@
 { stdenv, fetchurl, pkgconfig, intltool, glib, libxml2, gtk3, gtkvnc, gmp
 , libgcrypt, gnupg, cyrus_sasl, shared_mime_info, libvirt, libcap_ng, yajl
-, gsettings_desktop_schemas, makeWrapper
+, gsettings_desktop_schemas, makeWrapper, xen, numactl
 , spiceSupport ? true, spice_gtk ? null, spice_protocol ? null, libcap ? null, gdbm ? null
 }:

@ -9,25 +9,20 @@ assert spiceSupport ->

 with stdenv.lib;

-let sourceInfo = rec {
-    baseName="virt-viewer";
-    version="2.0";
-    name="${baseName}-${version}";
-    url="http://virt-manager.org/download/sources/${baseName}/${name}.tar.gz";
-    hash="0dylhpk5rq9jz0l1cxs50q2s74z0wingygm1m33bmnmcnny87ig9";
-}; in
-
-stdenv.mkDerivation  {
-  inherit (sourceInfo) name version;
+stdenv.mkDerivation rec {
+  baseName = "virt-viewer";
+  version = "2.0";
+  name = "${baseName}-${version}";

  src = fetchurl {
-    url = sourceInfo.url;
-    sha256 = sourceInfo.hash;
+    url = "http://virt-manager.org/download/sources/${baseName}/${name}.tar.gz";
+    sha256 = "0dylhpk5rq9jz0l1cxs50q2s74z0wingygm1m33bmnmcnny87ig9";
  };

-  buildInputs = [ 
+  buildInputs = [
    pkgconfig intltool glib libxml2 gtk3 gtkvnc gmp libgcrypt gnupg cyrus_sasl
    shared_mime_info libvirt libcap_ng yajl gsettings_desktop_schemas makeWrapper
+    xen numactl
  ] ++ optionals spiceSupport [ spice_gtk spice_protocol libcap gdbm ];

  postInstall = ''
--- a/pkgs/applications/window-managers/compiz/default.nix
+++ b/pkgs/applications/window-managers/compiz/default.nix
@ -15,11 +15,11 @@ let
  s = # Generated upstream information
  rec {
    baseName="compiz";
-    version="0.9.12.1";
+    version="0.9.12.2";
    name="${baseName}-${version}";
-    hash="0kl5im3zq0rjlxbgz5cyk38qzssahrljc67z1n16pjc1qmr6m7cb";
-    url="https://launchpad.net/compiz/0.9.12/0.9.12.1/+download/compiz-0.9.12.1.tar.bz2";
-    sha256="0kl5im3zq0rjlxbgz5cyk38qzssahrljc67z1n16pjc1qmr6m7cb";
+    hash="107cv8jm7nl0lbkj2y7878lmv1pd6blra68fg10cgb7xdngaq5w9";
+    url="https://launchpad.net/compiz/0.9.12/0.9.12.2/+download/compiz-0.9.12.2.tar.bz2";
+    sha256="107cv8jm7nl0lbkj2y7878lmv1pd6blra68fg10cgb7xdngaq5w9";
  };
  buildInputs = [cmake pkgconfig
    libXrender renderproto gtk libwnck pango cairo
--- a/pkgs/applications/window-managers/qtile/default.nix
+++ b/pkgs/applications/window-managers/qtile/default.nix
@ -7,13 +7,13 @@ in

 buildPythonPackage rec {
  name = "qtile-${version}";
-  version = "0.10.2";
+  version = "0.10.3";

  src = fetchFromGitHub {
    owner = "qtile";
    repo = "qtile";
    rev = "v${version}";
-    sha256 = "0dhdwjr4pdlzli68fa8glrnsjzxp6agdab9cnmpsqlwiwh97x9a6";
+    sha256 = "02252sfcniijkpk5rfgb800wvdpl223xrx1bhrxpzgggpgfbnmn6";
  };

  patches = [
--- a/pkgs/applications/window-managers/windowlab/default.nix
+++ b/pkgs/applications/window-managers/windowlab/default.nix
@ -0,0 +1,34 @@
+{ stdenv, fetchurl, pkgconfig
+, libX11, libXext, libXft }:
+
+let version = "1.40"; in
+stdenv.mkDerivation {
+  name = "windowlab-${version}";
+
+  src = fetchurl {
+    url = "http://nickgravgaard.com/windowlab/windowlab-${version}.tar";
+    sha256 = "1fx4jwq4s98p2wpvawsiww7d6568bpjgcjpks61dzfj8p2j32s4d";
+  };
+
+  buildInputs = [ pkgconfig libX11 libXext libXft ];
+
+  postPatch =
+    ''
+      mv Makefile Makefile.orig
+      echo \
+         "
+          DEFINES += -DXFT
+          EXTRA_INC += $(pkg-config --cflags xft)
+          EXTRA_LIBS += $(pkg-config --libs xft)
+         " > Makefile
+      sed "s|/usr/local|$out|g" Makefile.orig >> Makefile
+    '';
+
+  meta = with stdenv.lib;
+    { description = "Small and simple stacking window manager";
+      homepage    = "http://nickgravgaard.com/windowlab/";
+      license     = licenses.gpl2;
+      maintainers = with maintainers; [ ehmry ];
+      platforms   = platforms.linux;
+    };
+}
--- a/pkgs/build-support/emacs/melpa.nix
+++ b/pkgs/build-support/emacs/melpa.nix
@ -8,6 +8,8 @@ with lib;
 { pname
 , version

+, recipeFile ? null
+
 , files ? null
 , fileSpecs ? [ "*.el" "*.el.in" "dir"
                "*.info" "*.texi" "*.texinfo"
@ -22,8 +24,8 @@ with lib;
 let

  packageBuild = fetchurl {
-    url = https://raw.githubusercontent.com/milkypostman/melpa/12a862e5c5c62ce627dab83d7cf2cca6e8b56c47/package-build.el;
-    sha256 = "1nviyyprypz7nmam9rwli4yv3kxh170glfbznryrp4czxkrjjdhk";
+    url = https://raw.githubusercontent.com/milkypostman/melpa/2b3eb31c077fcaff94b74b757c1ce17650333943/package-build.el;
+    sha256 = "1biwg2pqmmdz5iwqbjdszljazqymvgyyjcnc255nr6qz8mhnx67j";
  };

  fname = "${pname}-${version}";
@ -43,8 +45,17 @@ import ./generic.nix { inherit lib stdenv emacs texinfo; } ({
    runHook preBuild

    emacs --batch -Q -l $packageBuild -l ${./melpa2nix.el} \
+    ${if recipeFile == null
+      then
+      ''
      -f melpa2nix-build-package \
      ${pname} ${version} ${targets}
+      ''
+      else
+      ''
+      -f melpa2nix-build-package-from-recipe \
+      ${pname} ${version} ${recipeFile}
+      ''}

    runHook postBuild
  '';
--- a/pkgs/build-support/emacs/melpa2nix.el
+++ b/pkgs/build-support/emacs/melpa2nix.el
@ -21,16 +21,25 @@
    (`(,package ,version . ,files)
     (melpa2nix-package-build-archive package version files))))

+(defun melpa2nix-build-package-from-recipe ()
+  (if (not noninteractive)
+      (error "`melpa2nix-build-package' is to be used only with -batch"))
+  (pcase command-line-args-left
+    (`(,package ,version ,recipe-file)
+     (let* ((rcp (cdr (package-build--read-from-file recipe-file)))
+            (files (package-build--config-file-list rcp)))
+       (melpa2nix-package-build-archive package version files)))))
+
 (defun melpa2nix-package-build-archive (name version files)
  "Build a package archive for package NAME."
-  (pb/message "\n;;; %s\n" name)
+  (package-build--message "\n;;; %s\n" name)
  (let* ((start-time (current-time))
         (archive-entry (package-build-package name
                                               version
                                               files
                                               package-build-working-dir
                                               package-build-archive-dir)))
-    
-    (pb/message "Built in %.3fs, finished at %s"
-                (time-to-seconds (time-since start-time))
-                (current-time-string))))
+
+    (package-build--message "Built in %.3fs, finished at %s"
+                            (time-to-seconds (time-since start-time))
+                            (current-time-string))))
--- a/pkgs/build-support/fetchzip/default.nix
+++ b/pkgs/build-support/fetchzip/default.nix
@ -10,6 +10,7 @@
 { # Optionally move the contents of the unpacked tree up one level.
  stripRoot ? true
 , url
+, extraPostFetch ? ""
 , ... } @ args:

 lib.overrideDerivation (fetchurl ({
@ -47,7 +48,8 @@ lib.overrideDerivation (fetchurl ({
      fi
    '' else ''
      mv "$unpackDir"/* "$out/"
-    '');
-} // removeAttrs args [ "stripRoot" ]))
+    '') #*/
+    + extraPostFetch;
+} // removeAttrs args [ "stripRoot" "extraPostFetch" ]))
 # Hackety-hack: we actually need unzip hooks, too
 (x: {nativeBuildInputs = x.nativeBuildInputs++ [unzip];})
--- a/pkgs/data/misc/wireless-regdb/default.nix
+++ b/pkgs/data/misc/wireless-regdb/default.nix
@ -0,0 +1,28 @@
+{ stdenv, fetchgit }:
+
+let version = "2015-12-14"; in
+stdenv.mkDerivation {
+  name = "wireless-regdb-${version}";
+
+  src = fetchgit {
+    sha256 = "1ldfcxn3mdb104czy78b7nj1clsbfp8fc6mshix98zq0bg4k7rsm";
+    url = https://git.kernel.org/pub/scm/linux/kernel/git/sforshee/wireless-regdb.git;
+    rev = "refs/tags/master-${version}";
+  };
+
+  phases = [ "unpackPhase" "installPhase" ];
+
+  makeFlags = [
+    "DESTDIR=$(out)"
+    "PREFIX="
+  ];
+
+  meta = with stdenv.lib; {
+    inherit version;
+    description = "Wireless regulatory database for CRDA";
+    homepage = http://wireless.kernel.org/en/developers/Regulatory/;
+    license = licenses.isc;
+    platforms = platforms.all;
+    maintainers = with maintainers; [ nckx ];
+  };
+}
--- a/pkgs/desktops/gnome-3/3.16/apps/gnome-boxes/default.nix
+++ b/pkgs/desktops/gnome-3/3.16/apps/gnome-boxes/default.nix
@ -2,8 +2,8 @@
 , glib, gobjectIntrospection, libxml2, gtk3, gtkvnc, libvirt, spice_gtk
 , spice_protocol, libuuid, libsoup, libosinfo, systemd, tracker, vala
 , libcap_ng, libcap, yajl, gmp, gdbm, cyrus_sasl, gnome3, librsvg
-, desktop_file_utils, mtools, cdrkit, libcdio
-, libusb, libarchive, acl
+, desktop_file_utils, mtools, cdrkit, libcdio, libgudev
+, libusb, libarchive, acl, xen, numactl
 }:

 # TODO: ovirt (optional)
@ -25,7 +25,7 @@ stdenv.mkDerivation rec {
    gobjectIntrospection libxml2 gtk3 gtkvnc libvirt spice_gtk spice_protocol
    libuuid libsoup libosinfo systemd tracker vala libcap_ng libcap yajl gmp
    gdbm cyrus_sasl gnome3.defaultIconTheme libusb libarchive
-    librsvg desktop_file_utils acl
+    librsvg desktop_file_utils acl libgudev xen numactl
  ];

  preFixup = ''
--- a/pkgs/desktops/gnome-3/3.18/apps/gnome-boxes/default.nix
+++ b/pkgs/desktops/gnome-3/3.18/apps/gnome-boxes/default.nix
@ -2,8 +2,8 @@
 , glib, gobjectIntrospection, libxml2, gtk3, gtkvnc, libvirt, spice_gtk
 , spice_protocol, libuuid, libsoup, libosinfo, systemd, tracker, vala
 , libcap_ng, libcap, yajl, gmp, gdbm, cyrus_sasl, gnome3, librsvg
-, desktop_file_utils, mtools, cdrkit, libcdio
-, libusb, libarchive, acl
+, desktop_file_utils, mtools, cdrkit, libcdio, numactl, xen
+, libusb, libarchive, acl, libgudev
 }:

 # TODO: ovirt (optional)
@ -20,7 +20,7 @@ stdenv.mkDerivation rec {
    gobjectIntrospection libxml2 gtk3 gtkvnc libvirt spice_gtk spice_protocol
    libuuid libsoup libosinfo systemd tracker vala libcap_ng libcap yajl gmp
    gdbm cyrus_sasl gnome3.defaultIconTheme libusb libarchive
-    librsvg desktop_file_utils acl
+    librsvg desktop_file_utils acl libgudev numactl xen
  ];

  preFixup = ''
--- a/pkgs/desktops/plasma-5.5/fetchsrcs.sh
+++ b/pkgs/desktops/plasma-5.5/fetchsrcs.sh
@ -4,7 +4,7 @@
 set -x

 # The trailing slash at the end is necessary!
-RELEASE_URL="http://download.kde.org/stable/plasma/5.5.1/"
+RELEASE_URL="http://download.kde.org/stable/plasma/5.5.2/"
 EXTRA_WGET_ARGS='-A *.tar.xz'

 mkdir tmp; cd tmp
--- a/pkgs/desktops/plasma-5.5/srcs.nix
+++ b/pkgs/desktops/plasma-5.5/srcs.nix
@ -3,307 +3,307 @@

 {
  bluedevil = {
-    version = "5.5.1";
+    version = "5.5.2";
    src = fetchurl {
-      url = "${mirror}/stable/plasma/5.5.1/bluedevil-5.5.1.tar.xz";
-      sha256 = "09id2vyjdmwl20km0zfwhz2rsyrb2yrfygczh39v1s3nqz88mw97";
-      name = "bluedevil-5.5.1.tar.xz";
+      url = "${mirror}/stable/plasma/5.5.2/bluedevil-5.5.2.tar.xz";
+      sha256 = "0z13vj9ybdilsixnn44wixr54f50lbbq52ryjfc4bxllycv9fzjf";
+      name = "bluedevil-5.5.2.tar.xz";
    };
  };
  breeze = {
-    version = "5.5.1";
+    version = "5.5.2";
    src = fetchurl {
-      url = "${mirror}/stable/plasma/5.5.1/breeze-5.5.1.tar.xz";
-      sha256 = "03chjfi878r9cz6vy7px0fma8lzrynpnnvbfqw2pbz00mny89hkw";
-      name = "breeze-5.5.1.tar.xz";
+      url = "${mirror}/stable/plasma/5.5.2/breeze-5.5.2.tar.xz";
+      sha256 = "171n9i642i2p1a8sd5pjamm41phbih5f244f1f5f6h2r29bpccgr";
+      name = "breeze-5.5.2.tar.xz";
    };
  };
  breeze-gtk = {
-    version = "5.5.1";
+    version = "5.5.2";
    src = fetchurl {
-      url = "${mirror}/stable/plasma/5.5.1/breeze-gtk-5.5.1.tar.xz";
-      sha256 = "10nnahdsyl7rh6r4wzrxjhw6pl5j5b29wkv7a9kkyqjmhmfxsmpq";
-      name = "breeze-gtk-5.5.1.tar.xz";
+      url = "${mirror}/stable/plasma/5.5.2/breeze-gtk-5.5.2.tar.xz";
+      sha256 = "1zlxdb6rlg7r4dfd87l9p0js52c9k190l8aj2zd9hhw2wyc388x0";
+      name = "breeze-gtk-5.5.2.tar.xz";
    };
  };
  discover = {
-    version = "5.5.1";
+    version = "5.5.2";
    src = fetchurl {
-      url = "${mirror}/stable/plasma/5.5.1/discover-5.5.1.tar.xz";
-      sha256 = "0nr48126xb48ra9gc40bhbsz74ssrf6dnx189n3sdvb00y7a26wf";
-      name = "discover-5.5.1.tar.xz";
+      url = "${mirror}/stable/plasma/5.5.2/discover-5.5.2.tar.xz";
+      sha256 = "13wm838yqhl1xw4wp93b0avfacp2zgg9rvml1hm6ksfbbyh8xxj0";
+      name = "discover-5.5.2.tar.xz";
    };
  };
  kde-cli-tools = {
-    version = "5.5.1";
+    version = "5.5.2";
    src = fetchurl {
-      url = "${mirror}/stable/plasma/5.5.1/kde-cli-tools-5.5.1.tar.xz";
-      sha256 = "0izn9fqbrjxcpwwjfr4522jazz2aw8h0r5c4s99hmy5q6hyr59bj";
-      name = "kde-cli-tools-5.5.1.tar.xz";
+      url = "${mirror}/stable/plasma/5.5.2/kde-cli-tools-5.5.2.tar.xz";
+      sha256 = "0di7qxifrck1d1y24dypvgd3b60pkddlk2nnf6m230m0qacw6kk6";
+      name = "kde-cli-tools-5.5.2.tar.xz";
    };
  };
  kdecoration = {
-    version = "5.5.1";
+    version = "5.5.2";
    src = fetchurl {
-      url = "${mirror}/stable/plasma/5.5.1/kdecoration-5.5.1.tar.xz";
-      sha256 = "1fdflipbfbivy3p90n30wc6flqck5hx5q4zli42v2a039bzj44jn";
-      name = "kdecoration-5.5.1.tar.xz";
+      url = "${mirror}/stable/plasma/5.5.2/kdecoration-5.5.2.tar.xz";
+      sha256 = "1g9bvkqvzy8h5l79qcm3zf4s146fld4la3ri83bbsfd9my6lrwph";
+      name = "kdecoration-5.5.2.tar.xz";
    };
  };
  kde-gtk-config = {
-    version = "5.5.1";
+    version = "5.5.2";
    src = fetchurl {
-      url = "${mirror}/stable/plasma/5.5.1/kde-gtk-config-5.5.1.tar.xz";
-      sha256 = "1pjs59i9xwz3csd86qmvb4c7n766q1dam8llvklkx17i8f9ddri0";
-      name = "kde-gtk-config-5.5.1.tar.xz";
+      url = "${mirror}/stable/plasma/5.5.2/kde-gtk-config-5.5.2.tar.xz";
+      sha256 = "0pd8a36ggdrp145mxk28n33r8fd436v74jq8xzvq0f2gfh4lcih8";
+      name = "kde-gtk-config-5.5.2.tar.xz";
    };
  };
  kdeplasma-addons = {
-    version = "5.5.1";
+    version = "5.5.2";
    src = fetchurl {
-      url = "${mirror}/stable/plasma/5.5.1/kdeplasma-addons-5.5.1.tar.xz";
-      sha256 = "0i59p4dyaz7kz9rcx2hpwg3c7sbwsk4cab9ldcck6vb83szxi1il";
-      name = "kdeplasma-addons-5.5.1.tar.xz";
+      url = "${mirror}/stable/plasma/5.5.2/kdeplasma-addons-5.5.2.tar.xz";
+      sha256 = "0lqhgqy25bijpm62hlzn2ksia0dldvvdf4s9ax8b2g4jq114wrl4";
+      name = "kdeplasma-addons-5.5.2.tar.xz";
    };
  };
  kgamma5 = {
-    version = "5.5.1";
+    version = "5.5.2";
    src = fetchurl {
-      url = "${mirror}/stable/plasma/5.5.1/kgamma5-5.5.1.tar.xz";
-      sha256 = "0qwb2fl27pprr6m2vhr021whpashgan3lx2s91iyb09cxf56883y";
-      name = "kgamma5-5.5.1.tar.xz";
+      url = "${mirror}/stable/plasma/5.5.2/kgamma5-5.5.2.tar.xz";
+      sha256 = "0lcz7frb3134k7pvll7di1x08bs8q1cxr4hy0d1danns6jj19w6q";
+      name = "kgamma5-5.5.2.tar.xz";
    };
  };
  khelpcenter = {
-    version = "5.5.1";
+    version = "5.5.2";
    src = fetchurl {
-      url = "${mirror}/stable/plasma/5.5.1/khelpcenter-5.5.1.tar.xz";
-      sha256 = "0alsn8xsac0l2zdsk9fvawz3zvg431qgg443p05v6a2pfadb2b0s";
-      name = "khelpcenter-5.5.1.tar.xz";
+      url = "${mirror}/stable/plasma/5.5.2/khelpcenter-5.5.2.tar.xz";
+      sha256 = "1ypy0p9ld9gy06z8r19lcysbzbg202m3ljdmzkzixvr8173lg01x";
+      name = "khelpcenter-5.5.2.tar.xz";
    };
  };
  khotkeys = {
-    version = "5.5.1";
+    version = "5.5.2";
    src = fetchurl {
-      url = "${mirror}/stable/plasma/5.5.1/khotkeys-5.5.1.tar.xz";
-      sha256 = "0rbmdh8yv8ms19kn3r0qcgy0wlrin5jhxic55pc4hdccxy0alchi";
-      name = "khotkeys-5.5.1.tar.xz";
+      url = "${mirror}/stable/plasma/5.5.2/khotkeys-5.5.2.tar.xz";
+      sha256 = "0dcdh0hxhlqaip3vk02npw3bk2pgpsrfhjr80k8bmhiy9g95z7ab";
+      name = "khotkeys-5.5.2.tar.xz";
    };
  };
  kinfocenter = {
-    version = "5.5.1";
+    version = "5.5.2";
    src = fetchurl {
-      url = "${mirror}/stable/plasma/5.5.1/kinfocenter-5.5.1.tar.xz";
-      sha256 = "0b1z8qsa1qpl9w13ag8154biry44r19nrg1mb5r3wjy22s1nmf40";
-      name = "kinfocenter-5.5.1.tar.xz";
+      url = "${mirror}/stable/plasma/5.5.2/kinfocenter-5.5.2.tar.xz";
+      sha256 = "1wg8yv096glby3ds822b643x0lrhmf67karr1xcd98xr5l188ngw";
+      name = "kinfocenter-5.5.2.tar.xz";
    };
  };
  kmenuedit = {
-    version = "5.5.1";
+    version = "5.5.2";
    src = fetchurl {
-      url = "${mirror}/stable/plasma/5.5.1/kmenuedit-5.5.1.tar.xz";
-      sha256 = "0wk5lainva9pc8ccflpfgil9b9vi6wf1vfd5pkn11n9dqr1sbgcq";
-      name = "kmenuedit-5.5.1.tar.xz";
+      url = "${mirror}/stable/plasma/5.5.2/kmenuedit-5.5.2.tar.xz";
+      sha256 = "1gqb2wrb1ahdqljm451w9kbyl0mmqm7axrpnf4hblh4453ym19wr";
+      name = "kmenuedit-5.5.2.tar.xz";
    };
  };
  kscreen = {
-    version = "5.5.1";
+    version = "5.5.2";
    src = fetchurl {
-      url = "${mirror}/stable/plasma/5.5.1/kscreen-5.5.1.tar.xz";
-      sha256 = "1zn31yfk2x9xpqvr0liyna98sk486qqbdgzisx8dl5jm8j7lxm5c";
-      name = "kscreen-5.5.1.tar.xz";
+      url = "${mirror}/stable/plasma/5.5.2/kscreen-5.5.2.tar.xz";
+      sha256 = "0kqf296r6gxfq0cz2s8yg05jazb3048fxbm2v0b9mv235c5j5xap";
+      name = "kscreen-5.5.2.tar.xz";
    };
  };
  kscreenlocker = {
-    version = "5.5.1";
+    version = "5.5.2";
    src = fetchurl {
-      url = "${mirror}/stable/plasma/5.5.1/kscreenlocker-5.5.1.tar.xz";
-      sha256 = "0614w38isbqhvw425620mabvczjph52b6mpzzp0ac462ryl5061s";
-      name = "kscreenlocker-5.5.1.tar.xz";
+      url = "${mirror}/stable/plasma/5.5.2/kscreenlocker-5.5.2.tar.xz";
+      sha256 = "1yknbrxnk162jvi8da4m23qxcwxqm1jsa1l1yxw4nj6rdz3jl6dm";
+      name = "kscreenlocker-5.5.2.tar.xz";
    };
  };
  ksshaskpass = {
-    version = "5.5.1";
+    version = "5.5.2";
    src = fetchurl {
-      url = "${mirror}/stable/plasma/5.5.1/ksshaskpass-5.5.1.tar.xz";
-      sha256 = "0xafh56wpa7ypj2j4pbgp8p7gk95xa7q3wbab3qw8n7gwjwvgm8v";
-      name = "ksshaskpass-5.5.1.tar.xz";
+      url = "${mirror}/stable/plasma/5.5.2/ksshaskpass-5.5.2.tar.xz";
+      sha256 = "0dq1qifmq3qdb6ia19n22wrxv5pndl77hlr2pyn2i67rz19zxywf";
+      name = "ksshaskpass-5.5.2.tar.xz";
    };
  };
  ksysguard = {
-    version = "5.5.1";
+    version = "5.5.2";
    src = fetchurl {
-      url = "${mirror}/stable/plasma/5.5.1/ksysguard-5.5.1.tar.xz";
-      sha256 = "0zp3hd22hljn1xqdbmayhrbm4niksp9s6p8fx0nv7pnnv8h02vw1";
-      name = "ksysguard-5.5.1.tar.xz";
+      url = "${mirror}/stable/plasma/5.5.2/ksysguard-5.5.2.tar.xz";
+      sha256 = "0c1iaimpwnh6naryj7apqxkdcaj5wmyir1yvlpr5v9wp49gkn2nx";
+      name = "ksysguard-5.5.2.tar.xz";
    };
  };
  kwallet-pam = {
-    version = "5.5.1";
+    version = "5.5.2";
    src = fetchurl {
-      url = "${mirror}/stable/plasma/5.5.1/kwallet-pam-5.5.1.tar.xz";
-      sha256 = "1hk8a82dmvf9h5bhykpfx02b65vx30ziak698sjs0zp0hxfilq56";
-      name = "kwallet-pam-5.5.1.tar.xz";
+      url = "${mirror}/stable/plasma/5.5.2/kwallet-pam-5.5.2.tar.xz";
+      sha256 = "0gmk2jm1svvy1jxr5nsq14gscalzknrmzyar858nijyc9k5wb1n0";
+      name = "kwallet-pam-5.5.2.tar.xz";
    };
  };
  kwayland = {
-    version = "5.5.1";
+    version = "5.5.2";
    src = fetchurl {
-      url = "${mirror}/stable/plasma/5.5.1/kwayland-5.5.1.tar.xz";
-      sha256 = "18dxhyphd5chswa39isn47xjhp6v2di5jjs03g21wfc4q0avpd45";
-      name = "kwayland-5.5.1.tar.xz";
+      url = "${mirror}/stable/plasma/5.5.2/kwayland-5.5.2.tar.xz";
+      sha256 = "1i1gx3f1ygh9l1hwh4jcipjzl9b00issqk22i1li3054cb45g0mv";
+      name = "kwayland-5.5.2.tar.xz";
    };
  };
  kwayland-integration = {
-    version = "5.5.1";
+    version = "5.5.2";
    src = fetchurl {
-      url = "${mirror}/stable/plasma/5.5.1/kwayland-integration-5.5.1.tar.xz";
-      sha256 = "1ss19cxisz9xj4nh6zjmndpcp6r4gvmpsbqa2wycrvsqq6wrsr5f";
-      name = "kwayland-integration-5.5.1.tar.xz";
+      url = "${mirror}/stable/plasma/5.5.2/kwayland-integration-5.5.2.tar.xz";
+      sha256 = "09czrmyz75mkpaq9ca8n4w2b9x15dhw1l4g2vyqzarc8y5id4bnv";
+      name = "kwayland-integration-5.5.2.tar.xz";
    };
  };
  kwin = {
-    version = "5.5.1";
+    version = "5.5.2";
    src = fetchurl {
-      url = "${mirror}/stable/plasma/5.5.1/kwin-5.5.1.tar.xz";
-      sha256 = "0gqh98v4h6mc087xdqma5ab478f0zl2v1p6614q9w4si7770i8vl";
-      name = "kwin-5.5.1.tar.xz";
+      url = "${mirror}/stable/plasma/5.5.2/kwin-5.5.2.tar.xz";
+      sha256 = "0cly3mnb7d64h0pcfiqhcqs7p9plwsh0zb7kgz7ahcahqqgzbx4p";
+      name = "kwin-5.5.2.tar.xz";
    };
  };
  kwrited = {
-    version = "5.5.1";
+    version = "5.5.2";
    src = fetchurl {
-      url = "${mirror}/stable/plasma/5.5.1/kwrited-5.5.1.tar.xz";
-      sha256 = "0din1v4jls2bmxx50dx6hs4anfzrr50cb5m8qdq6n0j35p60xq30";
-      name = "kwrited-5.5.1.tar.xz";
+      url = "${mirror}/stable/plasma/5.5.2/kwrited-5.5.2.tar.xz";
+      sha256 = "0fm6bvihyksiizxdp3alpal19c897pjmhqp2cyf7z9aahkyhpgh8";
+      name = "kwrited-5.5.2.tar.xz";
    };
  };
  libkscreen = {
-    version = "5.5.1";
+    version = "5.5.2";
    src = fetchurl {
-      url = "${mirror}/stable/plasma/5.5.1/libkscreen-5.5.1.tar.xz";
-      sha256 = "1v31hxdrwhrx0n582cp2is09k9slw8a7c8qr5yxc8gi96sj3hb2y";
-      name = "libkscreen-5.5.1.tar.xz";
+      url = "${mirror}/stable/plasma/5.5.2/libkscreen-5.5.2.tar.xz";
+      sha256 = "02aaaqzblahn477m07xzrk4vc21gc9szhj9aj780qyvpng8jifn2";
+      name = "libkscreen-5.5.2.tar.xz";
    };
  };
  libksysguard = {
-    version = "5.5.1";
+    version = "5.5.2";
    src = fetchurl {
-      url = "${mirror}/stable/plasma/5.5.1/libksysguard-5.5.1.tar.xz";
-      sha256 = "1zgvxvrmi0amxmn4cmd0g4bdb7b97msdkycsckp7krv5mw5h55dx";
-      name = "libksysguard-5.5.1.tar.xz";
+      url = "${mirror}/stable/plasma/5.5.2/libksysguard-5.5.2.tar.xz";
+      sha256 = "1z4riwjb3i9wv3zd34y5cv1s2pb3x1v6kayl5bq89v8pyqqkp5n5";
+      name = "libksysguard-5.5.2.tar.xz";
    };
  };
  milou = {
-    version = "5.5.1";
+    version = "5.5.2";
    src = fetchurl {
-      url = "${mirror}/stable/plasma/5.5.1/milou-5.5.1.tar.xz";
-      sha256 = "10qsfqx8rqzzy7yg1sikyxh9ycfplmvv30y8rgv4hihnh1yywhks";
-      name = "milou-5.5.1.tar.xz";
+      url = "${mirror}/stable/plasma/5.5.2/milou-5.5.2.tar.xz";
+      sha256 = "180i93zlypqnsw5105xqgfjnvg024z7i7qxhv7snidzm9yrc3f0q";
+      name = "milou-5.5.2.tar.xz";
    };
  };
  oxygen = {
-    version = "5.5.1";
+    version = "5.5.2";
    src = fetchurl {
-      url = "${mirror}/stable/plasma/5.5.1/oxygen-5.5.1.tar.xz";
-      sha256 = "0fszhf3xavmygm82kb3i8pymvz9bc5av5mi35d0qj3fzwfgdkd6h";
-      name = "oxygen-5.5.1.tar.xz";
+      url = "${mirror}/stable/plasma/5.5.2/oxygen-5.5.2.tar.xz";
+      sha256 = "0q9mbazync4skgkz595ccjznndkv6v3qwhhyx2ycs73s2v4380kp";
+      name = "oxygen-5.5.2.tar.xz";
    };
  };
  plasma-desktop = {
-    version = "5.5.1";
+    version = "5.5.2";
    src = fetchurl {
-      url = "${mirror}/stable/plasma/5.5.1/plasma-desktop-5.5.1.tar.xz";
-      sha256 = "1gazhr4501176z6r8psz8wjg3hcfigvpfm02q82aw9jpyy7sjini";
-      name = "plasma-desktop-5.5.1.tar.xz";
+      url = "${mirror}/stable/plasma/5.5.2/plasma-desktop-5.5.2.tar.xz";
+      sha256 = "08c4hmnmwzy67cp01p001mil9cvf0gx37dxf0iwghxw7b7nzmxnf";
+      name = "plasma-desktop-5.5.2.tar.xz";
    };
  };
  plasma-mediacenter = {
-    version = "5.5.1";
+    version = "5.5.2";
    src = fetchurl {
-      url = "${mirror}/stable/plasma/5.5.1/plasma-mediacenter-5.5.1.tar.xz";
-      sha256 = "12xlixrjbs6lmdabp7f9mp6dhwai7qnj5n867q86qv6i836y10dy";
-      name = "plasma-mediacenter-5.5.1.tar.xz";
+      url = "${mirror}/stable/plasma/5.5.2/plasma-mediacenter-5.5.2.tar.xz";
+      sha256 = "1019nbgb6f37bn9ncbjzmybrcfi187sf0rg0mxpvrhh1imdfxwsj";
+      name = "plasma-mediacenter-5.5.2.tar.xz";
    };
  };
  plasma-nm = {
-    version = "5.5.1";
+    version = "5.5.2";
    src = fetchurl {
-      url = "${mirror}/stable/plasma/5.5.1/plasma-nm-5.5.1.tar.xz";
-      sha256 = "0q0189vz7770xv65skj7a47lbavfgz9a4x4csqv834k40pawkyhg";
-      name = "plasma-nm-5.5.1.tar.xz";
+      url = "${mirror}/stable/plasma/5.5.2/plasma-nm-5.5.2.tar.xz";
+      sha256 = "00fx5m6avbq14wkmd6jjd1wda8rznav2hs5x70jx9dnkl1c6463x";
+      name = "plasma-nm-5.5.2.tar.xz";
    };
  };
  plasma-pa = {
-    version = "5.5.1";
+    version = "5.5.2";
    src = fetchurl {
-      url = "${mirror}/stable/plasma/5.5.1/plasma-pa-5.5.1.tar.xz";
-      sha256 = "13falp4xq028jnkqf5nsv71vv9icclvyk701s5dbcff7v2k2zphk";
-      name = "plasma-pa-5.5.1.tar.xz";
+      url = "${mirror}/stable/plasma/5.5.2/plasma-pa-5.5.2.tar.xz";
+      sha256 = "0nikv5ms1dnyf4w41c97gsx2wvy7da3qz7hddx3xnkzk3hh596fi";
+      name = "plasma-pa-5.5.2.tar.xz";
    };
  };
  plasma-sdk = {
-    version = "5.5.1";
+    version = "5.5.2";
    src = fetchurl {
-      url = "${mirror}/stable/plasma/5.5.1/plasma-sdk-5.5.1.tar.xz";
-      sha256 = "1s1k8zdkzpp51dn7w1ra4mswjnrr7nnf7nywdx8k10c0fyxny7hy";
-      name = "plasma-sdk-5.5.1.tar.xz";
+      url = "${mirror}/stable/plasma/5.5.2/plasma-sdk-5.5.2.tar.xz";
+      sha256 = "0ain65582dz075xjfq8kh7rkcf8hzbr7fdw4hifmcjfp4lh0da4g";
+      name = "plasma-sdk-5.5.2.tar.xz";
    };
  };
  plasma-workspace = {
-    version = "5.5.1.1";
+    version = "5.5.2";
    src = fetchurl {
-      url = "${mirror}/stable/plasma/5.5.1/plasma-workspace-5.5.1.1.tar.xz";
-      sha256 = "019pmhlry3zyrq4mvs35k1lmz35cwk4xvpl8wy7awx8r631dm4by";
-      name = "plasma-workspace-5.5.1.1.tar.xz";
+      url = "${mirror}/stable/plasma/5.5.2/plasma-workspace-5.5.2.tar.xz";
+      sha256 = "00nmfq864lkj03z82cgfczxhijafhd9nxiw0cprs6x9kvp1d3ylc";
+      name = "plasma-workspace-5.5.2.tar.xz";
    };
  };
  plasma-workspace-wallpapers = {
-    version = "5.5.1";
+    version = "5.5.2";
    src = fetchurl {
-      url = "${mirror}/stable/plasma/5.5.1/plasma-workspace-wallpapers-5.5.1.tar.xz";
-      sha256 = "1w2bbgcbjvdjxlgd4r3wva87i08y2ngqy85fngpl4387rq234zri";
-      name = "plasma-workspace-wallpapers-5.5.1.tar.xz";
+      url = "${mirror}/stable/plasma/5.5.2/plasma-workspace-wallpapers-5.5.2.tar.xz";
+      sha256 = "11gymzyhszb9192z0q54z6dlgxqivixj2grhynj2096r4c8jb1rk";
+      name = "plasma-workspace-wallpapers-5.5.2.tar.xz";
    };
  };
  polkit-kde-agent = {
-    version = "1-5.5.1";
+    version = "1-5.5.2";
    src = fetchurl {
-      url = "${mirror}/stable/plasma/5.5.1/polkit-kde-agent-1-5.5.1.tar.xz";
-      sha256 = "181d0l0dh7kxdz2ykl6g8mirxjcldm5p2737py3c7g617ysl97c1";
-      name = "polkit-kde-agent-1-5.5.1.tar.xz";
+      url = "${mirror}/stable/plasma/5.5.2/polkit-kde-agent-1-5.5.2.tar.xz";
+      sha256 = "0jmsmx41ixksl1cja295c06agpcs4hn4c0jvhc30b5l9i7nf79j9";
+      name = "polkit-kde-agent-1-5.5.2.tar.xz";
    };
  };
  powerdevil = {
-    version = "5.5.1";
+    version = "5.5.2";
    src = fetchurl {
-      url = "${mirror}/stable/plasma/5.5.1/powerdevil-5.5.1.tar.xz";
-      sha256 = "1gjhclm58dxlmb6g8dm2alfqk7iw9fy5vyryn0z6i71j7760aqpp";
-      name = "powerdevil-5.5.1.tar.xz";
+      url = "${mirror}/stable/plasma/5.5.2/powerdevil-5.5.2.tar.xz";
+      sha256 = "1l5765izd4p6i5q1f2r77ra0fip8fb0c1pl5bxg45sg3hnnaxk21";
+      name = "powerdevil-5.5.2.tar.xz";
    };
  };
  sddm-kcm = {
-    version = "5.5.1";
+    version = "5.5.2";
    src = fetchurl {
-      url = "${mirror}/stable/plasma/5.5.1/sddm-kcm-5.5.1.tar.xz";
-      sha256 = "0fbnyvyklr409n2qdbyvn1sqhkl7jdabldpv6brq010wd5f2rfrv";
-      name = "sddm-kcm-5.5.1.tar.xz";
+      url = "${mirror}/stable/plasma/5.5.2/sddm-kcm-5.5.2.tar.xz";
+      sha256 = "0fcyhndi1hh17cpbadm8alfhrkal847h4a7rx2rs8rrgypxdzhf9";
+      name = "sddm-kcm-5.5.2.tar.xz";
    };
  };
  systemsettings = {
-    version = "5.5.1";
+    version = "5.5.2";
    src = fetchurl {
-      url = "${mirror}/stable/plasma/5.5.1/systemsettings-5.5.1.tar.xz";
-      sha256 = "19q9yvlvyq61m3xjnii6zfpf5kwnja906i3709ia29132ai4x3sn";
-      name = "systemsettings-5.5.1.tar.xz";
+      url = "${mirror}/stable/plasma/5.5.2/systemsettings-5.5.2.tar.xz";
+      sha256 = "03y6mhfy3ax12g2s937w88hd88ln23asvcbsl52fy8h37b9vlnba";
+      name = "systemsettings-5.5.2.tar.xz";
    };
  };
  user-manager = {
-    version = "5.5.1";
+    version = "5.5.2";
    src = fetchurl {
-      url = "${mirror}/stable/plasma/5.5.1/user-manager-5.5.1.tar.xz";
-      sha256 = "12mrn2fila5m1nzrj196s6q15g91c52zqqbgzi9zqk22n2801l9f";
-      name = "user-manager-5.5.1.tar.xz";
+      url = "${mirror}/stable/plasma/5.5.2/user-manager-5.5.2.tar.xz";
+      sha256 = "0lvl8dhy8vymngb4p5x4y7miih8g004ii237lwrxv254ddv60azn";
+      name = "user-manager-5.5.2.tar.xz";
    };
  };
 }
--- a/pkgs/development/compilers/arachne-pnr/default.nix
+++ b/pkgs/development/compilers/arachne-pnr/default.nix
@ -0,0 +1,35 @@
+{ stdenv, fetchFromGitHub, icestorm }:
+
+stdenv.mkDerivation rec {
+  name = "arachne-pnr-${version}";
+  version = "2015.12.29";
+
+  src = fetchFromGitHub {
+    owner = "cseed";
+    repo = "arachne-pnr";
+    rev = "1a4fdf96a7fd08806c032d41a2443c8e17c72c80";
+    sha256 = "1dj7ycffwkmlsh12117fbybkdfnlhxbbxkbfgwfyvcgmg3cacgl1";
+  };
+
+  preBuild = ''
+    makeFlags="DESTDIR=$out $makeFlags"
+  '';
+  makeFlags = "ICEBOX=${icestorm}/share/icebox";
+
+  meta = {
+    description = "Place and route tool for FPGAs";
+    longDescription = ''
+      Arachne-pnr implements the place and route step of
+      the hardware compilation process for FPGAs. It
+      accepts as input a technology-mapped netlist in BLIF
+      format, as output by the Yosys [0] synthesis suite
+      for example. It currently targets the Lattice
+      Semiconductor iCE40 family of FPGAs [1]. Its output
+      is a textual bitstream representation for assembly by
+      the IceStorm [2] icepack command.
+    '';
+    homepage = https://github.com/cseed/arachne-pnr;
+    license = stdenv.lib.licenses.gpl2;
+    maintainers = [ stdenv.lib.maintainers.shell ];
+  };
+}
--- a/pkgs/development/compilers/fpc/default.nix
+++ b/pkgs/development/compilers/fpc/default.nix
@ -3,12 +3,12 @@
 let startFPC = import ./binary.nix { inherit stdenv fetchurl; }; in

 stdenv.mkDerivation rec {
-  version = "2.6.4";
+  version = "3.0.0";
  name = "fpc-${version}";

  src = fetchurl {
    url = "mirror://sourceforge/freepascal/fpcbuild-${version}.tar.gz";
-    sha256 = "1akdlp4n9ai1gnn4yq236i5rx03rs5sjfgk60myb7nb9lk7kp74d";
+    sha256 = "1v40bjp0kvsi8y0mndqvvhnsqjfssl2w6wpfww51j4rxblfkp4fm";
  };

  buildInputs = [ startFPC gawk ];
--- a/pkgs/development/compilers/fpc/lazarus.nix
+++ b/pkgs/development/compilers/fpc/lazarus.nix
@ -8,10 +8,10 @@ stdenv, fetchurl
 let
  s =
  rec {
-    version = "1.2.6";
+    version = "1.4.4";
    versionSuffix = "-0";
    url = "mirror://sourceforge/lazarus/Lazarus%20Zip%20_%20GZip/Lazarus%20${version}/lazarus-${version}${versionSuffix}.tar.gz";
-    sha256 = "1sjyc2l46hyd5ic5hr6vscy4qr9kazyhiyddy7bfs9vgf54fdiy0";
+    sha256 = "12w3xwqif96a65b0ygi4riqrp0122wsp0ykb1j7k8hjfyk91x91a";
    name = "lazarus-${version}";
  };
  buildInputs = [
--- a/pkgs/development/compilers/julia/default.nix
+++ b/pkgs/development/compilers/julia/default.nix
@ -28,10 +28,10 @@ let
    sha256 = "03kaqbjbi6viz0n33dk5jlf6ayxqlsq4804n7kwkndiga9s4hd42";
  };

-  libuvVersion = "28f5f06b5ff6f010d666ec26552e0badaca5cdcd";
+  libuvVersion = "9ab431a88fe255dd21e19a11f7fa2dd95774abf4";
  libuv = fetchurl {
    url = "https://api.github.com/repos/JuliaLang/libuv/tarball/${libuvVersion}";
-    sha256 = "1ksns0aiayxmxffvq2kc96904mxlmbkfc30xxck69xnidr2jvr4a";
+    sha256 = "1bh973lbrzrjk7pcjbjnh4n92qldi81ql3aqsclywn2yg07a36h5";
  };

  rmathVersion = "0.1";
--- a/pkgs/development/compilers/kotlin/default.nix
+++ b/pkgs/development/compilers/kotlin/default.nix
@ -1,12 +1,12 @@
 { stdenv, fetchurl, makeWrapper, jre, unzip, which }:

 stdenv.mkDerivation rec {
-  version = "1.0.0-beta-4583";
+  version = "1.0.0-beta-4584";
  name = "kotlin-${version}";

  src = fetchurl {
    url = "https://github.com/JetBrains/kotlin/releases/download/build-${version}/kotlin-compiler-${version}.zip";
-    sha256 = "4db71d3c1f150618568ebd1f8c17567ff15afe022c2f0121368c17afad9e8188";
+    sha256 = "191698784f4a1f769df14757bad40243293aa6bc3d8e906bfa0c80c3db0a1d2c";
  };

  propagatedBuildInputs = [ jre which ] ;
--- a/pkgs/development/compilers/llvm/3.7/libc++abi.nix
+++ b/pkgs/development/compilers/llvm/3.7/libc++abi.nix
@ -5,7 +5,7 @@ stdenv.mkDerivation {

  src = fetch "libcxxabi" "1swvnhrf9g67579c5picg0l869f8l2bwi4xqpbcb4n296gyp9c28";

-  buildInputs = [ cmake ] ++ stdenv.lib.optional (!stdenv.isDarwin) libunwind;
+  buildInputs = [ cmake ] ++ stdenv.lib.optional (!stdenv.isDarwin && !stdenv.isFreeBSD) libunwind;

  postUnpack = ''
    unpackFile ${libcxx.src}
--- a/pkgs/development/compilers/llvm/3.7/llvm.nix
+++ b/pkgs/development/compilers/llvm/3.7/llvm.nix
@ -22,6 +22,11 @@ let
 in stdenv.mkDerivation rec {
  name = "llvm-${version}";

+  patches = [
+    # Backport for Rust, remove when 3.7.1 is released
+    ./r242372-fix-LLVMBuildLandingPad.patch
+  ];
+
  unpackPhase = ''
    unpackFile ${src}
    mv llvm-${version}.src llvm
--- a/pkgs/development/compilers/llvm/3.7/r242372-fix-LLVMBuildLandingPad.patch
+++ b/pkgs/development/compilers/llvm/3.7/r242372-fix-LLVMBuildLandingPad.patch
@ -0,0 +1,60 @@
+Index: llvm/bindings/ocaml/llvm/llvm_ocaml.c
+===================================================================
+--- llvm/bindings/ocaml/llvm/llvm_ocaml.c	(revision 242371)
+++ llvm/bindings/ocaml/llvm/llvm_ocaml.c	(revision 242372)
+@@ -1745,7 +1745,7 @@
+ CAMLprim LLVMValueRef llvm_build_landingpad(LLVMTypeRef Ty, LLVMValueRef PersFn,
+                                             value NumClauses,  value Name,
+                                             value B) {
+-    return LLVMBuildLandingPad(Builder_val(B), Ty, Int_val(NumClauses),
+    return LLVMBuildLandingPad(Builder_val(B), Ty, PersFn, Int_val(NumClauses),
+                                String_val(Name));
+ }
+ 
+Index: llvm/bindings/go/llvm/ir.go
+===================================================================
+--- llvm/bindings/go/llvm/ir.go	(revision 242371)
+++ llvm/bindings/go/llvm/ir.go	(revision 242372)
+@@ -1731,7 +1731,7 @@
+ func (b Builder) CreateLandingPad(t Type, nclauses int, name string) (l Value) {
+ 	cname := C.CString(name)
+ 	defer C.free(unsafe.Pointer(cname))
+-	l.C = C.LLVMBuildLandingPad(b.C, t.C, C.unsigned(nclauses), cname)
+	l.C = C.LLVMBuildLandingPad(b.C, t.C, nil, C.unsigned(nclauses), cname)
+ 	return l
+ }
+ 
+Index: llvm/lib/IR/Core.cpp
+===================================================================
+--- llvm/lib/IR/Core.cpp	(revision 242371)
+++ llvm/lib/IR/Core.cpp	(revision 242372)
+@@ -2257,7 +2257,14 @@
+ }
+ 
+ LLVMValueRef LLVMBuildLandingPad(LLVMBuilderRef B, LLVMTypeRef Ty,
+-                                 unsigned NumClauses, const char *Name) {
+                                 LLVMValueRef PersFn, unsigned NumClauses,
+                                 const char *Name) {
+  // The personality used to live on the landingpad instruction, but now it
+  // lives on the parent function. For compatibility, take the provided
+  // personality and put it on the parent function.
+  if (PersFn)
+    unwrap(B)->GetInsertBlock()->getParent()->setPersonalityFn(
+        cast<Function>(unwrap(PersFn)));
+   return wrap(unwrap(B)->CreateLandingPad(unwrap(Ty), NumClauses, Name));
+ }
+ 
+Index: llvm/include/llvm-c/Core.h
+===================================================================
+--- llvm/include/llvm-c/Core.h	(revision 242371)
+++ llvm/include/llvm-c/Core.h	(revision 242372)
+@@ -2675,7 +2675,8 @@
+                              LLVMBasicBlockRef Then, LLVMBasicBlockRef Catch,
+                              const char *Name);
+ LLVMValueRef LLVMBuildLandingPad(LLVMBuilderRef B, LLVMTypeRef Ty,
+-                                 unsigned NumClauses, const char *Name);
+                                 LLVMValueRef PersFn, unsigned NumClauses,
+                                 const char *Name);
+ LLVMValueRef LLVMBuildResume(LLVMBuilderRef B, LLVMValueRef Exn);
+ LLVMValueRef LLVMBuildUnreachable(LLVMBuilderRef);
+ 
--- a/pkgs/development/compilers/rustc/default.nix
+++ b/pkgs/development/compilers/rustc/default.nix
@ -1,11 +1,11 @@
 { stdenv, callPackage }:

 callPackage ./generic.nix {
-  shortVersion = "1.4.0";
+  shortVersion = "1.5.0";
  isRelease = true;
  forceBundledLLVM = false;
  configureFlags = [ "--release-channel=stable" ];
-  srcSha = "13wpi9nb3h6wwck2mxhza85fahzcwgas00w8m25086v34dha4dp1";
+  srcSha = "1vfpwx6a2f2rn528774cz9r7r82ppycn8z8ybll6bphdw7cyar1g";

  /* Rust is bootstrapped from an earlier built version. We need
  to fetch these earlier versions, which vary per platform.
@ -22,7 +22,6 @@ callPackage ./generic.nix {
  snapshotDate = "2015-08-11";
  snapshotRev = "1af31d4";

-  # cc-ar-opts.patch should be removable in 1.4.0+
  patches = [ ./patches/remove-uneeded-git.patch ]
    ++ stdenv.lib.optional stdenv.needsPax ./patches/grsec.patch;
 }
--- a/pkgs/development/compilers/rustc/head.nix
+++ b/pkgs/development/compilers/rustc/head.nix
@ -23,6 +23,6 @@ callPackage ./generic.nix {
  snapshotRev = "1af31d4";

  patches = [ ./patches/remove-uneeded-git.patch ]
-    ++ stdenv.lib.optional stdenv.needsPax ./patches/grsec-head.patch;
+    ++ stdenv.lib.optional stdenv.needsPax ./patches/grsec.patch;
 }

--- a/pkgs/development/compilers/rustc/patches/grsec-head.patch
+++ b/pkgs/development/compilers/rustc/patches/grsec-head.patch
@ -1,24 +0,0 @@
-diff --git a/src/test/run-make/relocation-model/Makefile b/src/test/run-make/relocation-model/Makefile
-index b22f34f..c6489bd 100644
--- a/src/test/run-make/relocation-model/Makefile
-+++ b/src/test/run-make/relocation-model/Makefile
-@@ -2,9 +2,11 @@
- 
- all: others
- 	$(RUSTC) -C relocation-model=dynamic-no-pic foo.rs
-+	paxctl -czexm $(TMPDIR)/foo
- 	$(call RUN,foo)
- 
- 	$(RUSTC) -C relocation-model=default foo.rs
-+	paxctl -czexm $(TMPDIR)/foo
- 	$(call RUN,foo)
- 
- 	$(RUSTC) -C relocation-model=default --crate-type=dylib foo.rs
-@@ -16,6 +18,7 @@ others:
- else
- others:
- 	$(RUSTC) -C relocation-model=static foo.rs
-+	paxctl -czexm $(TMPDIR)/foo
- 	$(call RUN,foo)
- 	$(RUSTC) -C relocation-model=static --crate-type=dylib foo.rs
- endif
--- a/Show More
+++ b/Show More