Merge remote-tracking branch 'origin/master' into staging.

lib/maintainers.nix

···
      alphabetically sorted.  */
 
   _1126 = "Christian Lask <[e-mail]>";
+  abbradar = "Nikolay Amiantov <[e-mail]>";
   aforemny = "Alexander Foremny <[e-mail]>";
   ak = "Alexander Kjeldaas <[e-mail]>";
   akc = "Anders Claesson <[e-mail]>";
   algorith = "Dries Van Daele <[e-mail]>";
   all = "Nix Committers <[e-mail]>";
-  abbradar = "Nikolay Amiantov <[e-mail]>";
   amiddelk = "Arie Middelkoop <[e-mail]>";
   amorsillo = "Andrew Morsillo <[e-mail]>";
   AndersonTorres = "Anderson Torres <[e-mail]>";
···
   coroa = "Jonas Hörsch <[e-mail]>";
   cstrahan = "Charles Strahan <[e-mail]>";
   DamienCassou = "Damien Cassou <[e-mail]>";
-  DerGuteMoritz = "Moritz Heidkamp <[e-mail]>";
   dbohdan = "Danyil Bohdan <[e-mail]>";
+  DerGuteMoritz = "Moritz Heidkamp <[e-mail]>";
   dmalikov = "Dmitry Malikov <[e-mail]>";
   doublec = "Chris Double <[e-mail]>";
   ederoyd46 = "Matthew Brown <[e-mail]>";
···
   offline = "Jaka Hudoklin <[e-mail]>";
   orbitz = "Malcolm Matalka <[e-mail]>";
   page = "Carles Pagès <[e-mail]>";
+  pashev = "Igor Pashev <[e-mail]>";
   phreedom = "Evgeny Egorochkin <[e-mail]>";
   pierron = "Nicolas B. Pierron <[e-mail]>";
   piotr = "Piotr Pietraszkiewicz <[e-mail]>";
···
   tomberek = "Thomas Bereknyei <[e-mail]>";
   tstrobel = "Thomas Strobel <[e-mail]>";
   ttuegel = "Thomas Tuegel <[e-mail]>";
-  twey = "James ‘Twey’ Kay <[e-mail]>";
   tv = "Tomislav Viljetić <[e-mail]>";
+  twey = "James ‘Twey’ Kay <[e-mail]>";
   urkud = "Yury G. Kudryashov <[e-mail]>";
   vandenoever = "Jos van den Oever <[e-mail]>";
   vbgl = "Vincent Laporte <[e-mail]>";

lib/modules.nix

···
     if m ? config || m ? options then
       let badAttrs = removeAttrs m ["imports" "options" "config" "key" "_file"]; in
       if badAttrs != {} then
-        throw "Module `${key}' has an unsupported attribute `${head (attrNames badAttrs)}'."
+        throw "Module `${key}' has an unsupported attribute `${head (attrNames badAttrs)}'. This is caused by assignments to the top-level attributes `config' or `options'."
       else
         { file = m._file or file;
           key = toString m.key or key;

maintainers/scripts/travis-nox-review-pr.sh

···
         nix-build pkgs/top-level/release.nix -A tarball
     else
         echo "=== Checking PR"
-        # The current HEAD is the PR merged into origin/master, so we compare
-        # against origin/master
-        nox-review wip --against origin/master
+        nox-review pr ${TRAVIS_PULL_REQUEST}
     fi
 else
     echo "$0: Unknown option $1" >&2

nixos/modules/config/update-users-groups.pl

···
 make_path("/var/lib/nixos", { mode => 0755 });
 
 
+sub hashPassword {
+    my ($password) = @_;
+    my $salt = "";
+    my @chars = ('.', '/', 0..9, 'A'..'Z', 'a'..'z');
+    $salt .= $chars[rand 64] for (1..8);
+    return crypt($password, '$6$' . $salt . '$');
+}
+
+
 # Functions for allocating free GIDs/UIDs. FIXME: respect ID ranges in
 # /etc/login.defs.
 sub allocId {
···
         } else {
             warn "warning: password file ‘$u->{passwordFile}’ does not exist\n";
         }
+    } elsif (defined $u->{password}) {
+        $u->{hashedPassword} = hashPassword($u->{password});
     }
 
     $u->{fakePassword} = $existing->{fakePassword} // "x";
···
 
 foreach my $line (-f "/etc/shadow" ? read_file("/etc/shadow") : ()) {
     chomp $line;
-    my ($name, $password, @rest) = split(':', $line, -9);
+    my ($name, $hashedPassword, @rest) = split(':', $line, -9);
     my $u = $usersOut{$name};;
     next if !defined $u;
-    $password = $u->{hashedPassword} if defined $u->{hashedPassword} && !$spec->{mutableUsers}; # FIXME
-    push @shadowNew, join(":", $name, $password, @rest) . "\n";
+    $hashedPassword = $u->{hashedPassword} if defined $u->{hashedPassword} && !$spec->{mutableUsers}; # FIXME
+    push @shadowNew, join(":", $name, $hashedPassword, @rest) . "\n";
     $shadowSeen{$name} = 1;
 }
 
 foreach my $u (values %usersOut) {
     next if defined $shadowSeen{$u->{name}};
-    my $password = "!";
-    $password = $u->{hashedPassword} if defined $u->{hashedPassword};
+    my $hashedPassword = "!";
+    $hashedPassword = $u->{hashedPassword} if defined $u->{hashedPassword};
     # FIXME: set correct value for sp_lstchg.
-    push @shadowNew, join(":", $u->{name}, $password, "1::::::") . "\n";
+    push @shadowNew, join(":", $u->{name}, $hashedPassword, "1::::::") . "\n";
 }
 
 write_file("/etc/shadow.tmp", { perms => 0600 }, @shadowNew);
 rename("/etc/shadow.tmp", "/etc/shadow") or die;
-
-
-# Call chpasswd to apply password. FIXME: generate the hashes directly
-# and merge into the /etc/shadow updating above.
-foreach my $u (@{$spec->{users}}) {
-    if (defined $u->{password}) {
-        my $pid = open(PW, "| chpasswd") or die;
-        print PW "$u->{name}:$u->{password}\n";
-        close PW or die "unable to change password of user ‘$u->{name}’: $?\n";
-    }
-}

nixos/modules/security/sudo.nix

···
           <filename>sudoers</filename> file.
         '';
     };
+
+    security.sudo.extraConfig = mkOption {
+      type = types.lines;
+      default = "";
+      description = ''
+        Extra configuration text appended to <filename>sudoers</filename>.
+      '';
+    };
   };
 
 
···
 
     security.sudo.configFile =
       ''
-        # Don't edit this file. Set the NixOS option ‘security.sudo.configFile’ instead.
+        # Don't edit this file. Set the NixOS options ‘security.sudo.configFile’
+        # and security.sudo.extraConfig instead.
 
         # Environment variables to keep for root and %wheel.
         Defaults:root,%wheel env_keep+=TERMINFO_DIRS
···
 
         # Users in the "wheel" group can do anything.
         %wheel      ALL=(ALL) ${if cfg.wheelNeedsPassword then "" else "NOPASSWD: ALL, "}SETENV: ALL
+        ${cfg.extraConfig}
       '';
 
     security.setuidPrograms = [ "sudo" "sudoedit" ];

nixos/modules/services/misc/gitolite.nix

···
         default = false;
         description = ''
           Enable gitolite management under the
-          <literal>gitolite</literal> user. The Gitolite home
-          directory is <literal>/var/lib/gitolite</literal>. After
+          <literal>gitolite</literal> user. After
           switching to a configuration with Gitolite enabled, you can
           then run <literal>git clone
           gitolite@host:gitolite-admin.git</literal> to manage it further.
         '';
       };
 
+      dataDir = mkOption {
+        type = types.str;
+        default = "/var/lib/gitolite";
+        description = ''
+          Gitolite home directory (used to store all the repositories).
+        '';
+      };
+
       adminPubkey = mkOption {
         type = types.str;
         description = ''
···
   config = mkIf cfg.enable {
     users.extraUsers.gitolite = {
       description     = "Gitolite user";
-      home            = "/var/lib/gitolite";
+      home            = cfg.dataDir;
       createHome      = true;
       uid             = config.ids.uids.gitolite;
       useDefaultShell = true;
···
 
       path = [ pkgs.gitolite pkgs.git pkgs.perl pkgs.bash pkgs.openssh ];
       script = ''
-        cd /var/lib/gitolite
+        cd ${cfg.dataDir}
         mkdir -p .gitolite/logs
         if [ ! -d repositories ]; then
           gitolite setup -pk ${pubkeyFile}

nixos/modules/services/misc/nix-daemon.nix

···
         # /etc/nixos/configuration.nix.  Do not edit it!
         build-users-group = nixbld
         build-max-jobs = ${toString (cfg.maxJobs)}
+        build-cores = ${toString (cfg.buildCores)}
         build-use-chroot = ${if cfg.useChroot then "true" else "false"}
         build-chroot-dirs = ${toString cfg.chrootDirs} /bin/sh=${sh} $(echo $extraPaths)
         binary-caches = ${toString cfg.binaryCaches}
···
           set it to the number of CPUs in your system (e.g., 2 on an Athlon
           64 X2).
         ";
+      };
+
+      buildCores = mkOption {
+        type = types.int;
+        default = 1;
+        example = 64;
+        description = ''
+          This option defines the maximum number of concurrent tasks during
+          one build. It affects, e.g., -j option for make. The default is 1.
+          Some builds may become non-deterministic with this option; use with
+          care! Packages will only be affected if enableParallelBuilding is
+          set for them.
+        '';
       };
 
       useChroot = mkOption {

nixos/modules/services/monitoring/graphite.nix

···
         example = literalExample ''
           {
             GRAPHITE_USERNAME = "user";
-            GRAPHITE_PASSWORD = "pass"; 
+            GRAPHITE_PASSWORD = "pass";
           }
         '';
       };
···
               name: Test
         '';
         example = literalExample ''
-          pushbullet_key: pushbullet_api_key 
+          pushbullet_key: pushbullet_api_key
           alerts:
             - target: stats.seatgeek.app.deal_quality.venue_info_cache.hit
               warning: .5
···
       environment.systemPackages = [ pkgs.python27Packages.graphite_web ];
     })
 
-    (mkIf cfg.api.enable { 
+    (mkIf cfg.api.enable {
       systemd.services.graphiteApi = {
         description = "Graphite Api Interface";
         wantedBy = [ "multi-user.target" ];
···
           ExecStart = ''
             ${pkgs.python27Packages.waitress}/bin/waitress-serve \
             --host=${cfg.api.host} --port=${toString cfg.api.port} \
-            graphite_api.app:app 
+            graphite_api.app:app
           '';
           User = "graphite";
           Group = "graphite";
···
           ExecStart = "${pkgs.seyren}/bin/seyren -httpPort ${toString cfg.seyren.port}";
           WorkingDirectory = dataDir;
           User = "graphite";
-          Group = "graphite"; 
+          Group = "graphite";
         };
         preStart = ''
           if ! test -e ${dataDir}/db-created; then
···
         serviceConfig = {
           ExecStart = "${pkgs.pythonPackages.graphite_pager}/bin/graphite-pager --config ${pagerConfig}";
           User = "graphite";
-          Group = "graphite"; 
+          Group = "graphite";
         };
       };
 
···
       environment.systemPackages = [ pkgs.pythonPackages.graphite_pager ];
     })
 
-    {
-      users.extraUsers = singleton {
-        name = "graphite";
-        uid = config.ids.uids.graphite;
-        description = "Graphite daemon user";
-        home = dataDir;
-      };
-      users.extraGroups.graphite.gid = config.ids.gids.graphite;
-    }
+    # Disabled: Don't create this user unconditionally!
+    #
+    # {
+    #   users.extraUsers = singleton {
+    #     name = "graphite";
+    #     uid = config.ids.uids.graphite;
+    #     description = "Graphite daemon user";
+    #     home = dataDir;
+    #   };
+    #   users.extraGroups.graphite.gid = config.ids.gids.graphite;
+    # }
   ];
 }

nixos/modules/services/networking/nat.nix

···
 
     boot = {
       kernelModules = [ "nf_nat_ftp" ];
-      kernel.sysctl = mkOverride 99 {
-        "net.ipv4.conf.all.forwarding" = true;
-        "net.ipv4.conf.default.forwarding" = true;
+      kernel.sysctl = {
+        "net.ipv4.conf.all.forwarding" = mkOverride 99 true;
+        "net.ipv4.conf.default.forwarding" = mkOverride 99 true;
       };
     };
 

pkgs/applications/audio/easytag/default.nix

···
-{ stdenv, fetchurl, pkgconfig, intltool, gtk, glib, libid3tag, id3lib, taglib
-, libvorbis, libogg, flac, itstool, libxml2
+{ stdenv, fetchurl, pkgconfig, intltool, gtk3, glib, libid3tag, id3lib, taglib
+, libvorbis, libogg, flac, itstool, libxml2, gsettings_desktop_schemas
+, makeWrapper, gnome_icon_theme
 }:
 
 stdenv.mkDerivation rec {
   name = "easytag-${version}";
-  version = "2.2.4";
+  version = "2.3.1";
 
   src = fetchurl {
-    url = "mirror://gnome/sources/easytag/2.2/${name}.tar.xz";
-    sha256 = "14f0s0l28fwxnc37aw1imal2xcg9ykq35mx2j9gaqzz02ymjk0s5";
+    url = "mirror://gnome/sources/easytag/2.3/${name}.tar.xz";
+    sha256 = "19cdx4hma4nl38m1zrc3mq9cjg6knw970abk5anhg7cvpc1371s7";
   };
 
-  preConfigure = ''
-    # pkg-config v0.23 should be enough.
-    sed -i -e '/_pkg_min_version=0.24/s/24/23/' \
-           -e 's/have_mp3=no/have_mp3=yes/' \
-           -e 's/ID3TAG_DEPS="id3tag"/ID3TAG_DEPS=""/' configure
+  preFixup = ''
+    wrapProgram $out/bin/easytag \
+      --prefix XDG_DATA_DIRS : "$XDG_ICON_DIRS:$GSETTINGS_SCHEMAS_PATH:$out/share"
   '';
 
   NIX_LDFLAGS = "-lid3tag -lz";
 
+  nativeBuildInputs = [ makeWrapper ];
   buildInputs = [
-    pkgconfig intltool gtk glib libid3tag id3lib taglib libvorbis libogg flac
-    itstool libxml2
+    pkgconfig intltool gtk3 glib libid3tag id3lib taglib libvorbis libogg flac
+    itstool libxml2 gsettings_desktop_schemas gnome_icon_theme
   ];
 
   meta = {

pkgs/applications/editors/focuswriter/default.nix

···
+{stdenv, fetchurl, qt4, pkgconfig, hunspell}:
+
+stdenv.mkDerivation rec {
+  name = "focuswriter-${version}";
+  version = "1.5.3";
+
+  src = fetchurl {
+    url = http://gottcode.org/focuswriter/focuswriter-1.5.3-src.tar.bz2;
+    sha256 = "1i58jxbiy95ijf81g8c3gwxhcg3irzssna3wv7vhrd57g4lcfj0w";
+  };
+
+  buildInputs = [ qt4 pkgconfig hunspell ];
+  
+  configurePhase = "qmake PREFIX=/";
+
+  installPhase = "make install INSTALL_ROOT=$out";
+
+  meta = {
+    description = "Simple, distraction-free writing environment";
+    license = stdenv.lib.licenses.gpl2;
+    maintainers = [ stdenv.lib.maintainers.madjar ];
+    platforms = stdenv.lib.platforms.all;
+    homepage = "http://gottcode.org/focuswriter/";
+  };
+}

pkgs/applications/misc/calibre/default.nix

···
 }:
 
 stdenv.mkDerivation rec {
-  name = "calibre-2.7.0";
+  name = "calibre-2.8.0";
 
   src = fetchurl {
     url = "mirror://sourceforge/calibre/${name}.tar.xz";
-    sha256 = "0j8ypdcrxf961093pw3h5bxhd5kd1i6vjnf9cyi55j54j31zy021";
+    sha256 = "0wjkcgv7y4ll4lh5av6zs0q3k9y6p36sndw3864zhgwqwff00k12";
   };
 
   inherit python;

pkgs/applications/misc/ikiwiki/default.nix

···
 
 let
   name = "ikiwiki";
-  version = "3.20140916";
+  version = "3.20141016";
 
   lib = stdenv.lib;
 in
···
 
   src = fetchurl {
     url = "http://ftp.de.debian.org/debian/pool/main/i/ikiwiki/${name}_${version}.tar.gz";
-    sha256 = "05nws8jkcbhg767wqgn7in1p8zbcx2kdnhxz19fq52ncfzk2ndn0";
+    sha256 = "1amvrb6djil7g0yabsngfs0f1n7qcvj2hddipjkgfjbmghd6jqiw";
   };
 
   buildInputs = [ perl TextMarkdown URI HTMLParser HTMLScrubber HTMLTemplate

pkgs/applications/networking/instant-messengers/pidgin-plugins/pidgin-latex/default.nix

···
-{ stdenv, fetchurl, pidgin, imagemagick, ghostscript
-, pkgconfig, glib, gtk, texLive
-}:
-        
+{ stdenv, fetchurl, pkgconfig, pidgin, texLive, imagemagick, glib, gtk }:
+
+let version = "1.5.0";
+in
 stdenv.mkDerivation {
-  name = "pidgin-latex";
+  name = "pidgin-latex-${version}";
 
   src = fetchurl {
-    url = http://tapas.affenbande.org/pidgin-latex/pidgin-latex-0.9.tgz;
-    sha256 = "1yqd3qgxd3n8hm60qg7yv7j1crr6f3d4yrdpgwdpw2pyf92p8nxp";
+    url = "mirror://sourceforge/pidgin-latex/pidgin-latex_${version}.tar.bz2";
+    sha256 = "9c850aee90d7e59de834f83e09fa6e3e51b123f06e265ead70957608ada95441";
   };
 
-  preBuild = ''
-    sed -e '/^PREFIX/d' -i Makefile ; 
-    sed -e 's@/usr/bin/latex@${texLive}/bin/pdflatex@g' -i pidgin-latex.h
-    sed -e 's@/usr/bin/convert@${imagemagick}/bin/convert@g' -i pidgin-latex.h
-    sed -e 's@.*convert_path.*@const gchar *convert = CONVERT_PATH;@'
-    sed -e 's@.*latex_path.*@const gchar *convert = LATEX_PATH;@'
-    sed -e 's/%s.dvi/%s.pdf/' -i pidgin-latex.c
-    sed -e 's/latex_system\(.*\)FALSE/latex_system\1TRUE/' -i pidgin-latex.c
-  '';
-
-  makeFlags = "PREFIX=\$(out)";
+  nativeBuildInputs = [pkgconfig];
+  buildInputs = [gtk glib pidgin];
+  makeFlags = "PREFIX=$(out)";
 
-  preInstall = "mkdir -p $out/lib/pidgin $out/bin";
-  
-  postInstall = ''
-    mkdir -p $out/share/pidgin-latex
-    ln -s $out/lib/pidgin/pidgin-latex.so $out/share/pidgin-latex/
+  postPatch = ''
+    sed -e 's/-Wl,-soname//' -i Makefile
   '';
 
-  buildInputs = [pidgin imagemagick ghostscript pkgconfig glib gtk texLive];
+  passthru = {
+    wrapArgs = "--prefix PATH ':' ${texLive}/bin:${imagemagick}/bin";
+  };
 
-  meta = {
-    longDescription = ''
-      Pidgin-LaTeX is a pidgin plugin that cuts everything inside \$\$
-      .. \$\$ and feeds to LaTeX. A bit of conversion (automated, of
-      course) - and you see every formula that occurs in conversation
-      in pretty graphical form.  There are some glitches - when a
-      formula fails to compile, you can see just previous formula..
-      Enable it for user by linking to ~/.purple/plugins - from
-      sw/share/pidgin-latex , not from store of course.
-    '';
-    homepage = http://tapas.affenbande.org/wordpress/?page_id=70;
+  meta = with stdenv.lib; {
+    homepage = http://sourceforge.net/projects/pidgin-latex/;
+    description = "LaTeX rendering plugin for Pidgin IM";
+    licenses = licenses.gpl2;
+    platforms = platforms.linux;
+    maintainers = maintainers.abbradar;
   };
 }

pkgs/applications/networking/instant-messengers/pidgin-plugins/pidgin-latex/pidgin-latex-sf.nix

···
-args : with args;
-let version = "1.5.0";
-in
-rec {
-  src = fetchurl {
-    url = "mirror://sourceforge/pidgin-latex/pidgin-latex_${version}.tar.bz2";
-    sha256 = "9c850aee90d7e59de834f83e09fa6e3e51b123f06e265ead70957608ada95441";
-  };
-
-  buildInputs = [texLive pkgconfig gtk imagemagick glib pidgin which];
-  configureFlags = [];
-  installFlags = [
-    "PREFIX=$out"
-  ];
-
-  preBuild = fullDepEntry (''
-    mkdir -p $out/bin
-    ln -s $(which convert) $out/bin
-    ln -s $(which xelatex) $out/bin
-    ln -s $(which dvips) $out/bin
-
-    sed -e 's/-Wl,-soname//' -i Makefile
-    sed -e 's/\(PATH("\)latex/\1xelatex/' -i LaTeX.c
-    sed -e 's/|| execute(cmddvips, dvipsopts, 10) //' -i LaTeX.c
-    sed -e 's/  strcat([*]file_ps, "[.]ps");/  strcat(*file_ps, ".pdf");/' -i LaTeX.c
-    sed -e 's/\([*]convertopts\[5\]=[{]"\)\(\\"",\)/\1 -trim \2/' -i LaTeX.c
-    sed -e 's/\(#define HEADER ".*\)12pt\(.*\)"/\116pt\2\\\\usepackage{fontspec}\\\\usepackage{xunicode}"/' -i LaTeX.h
-  '') ["minInit" "addInputs" "defEnsureDir" "doUnpack"];
-
-  postInstall = fullDepEntry (''
-    mkdir -p $out/lib
-    mkdir -p $out/share/pidgin-latex
-    ln -s ../../lib/pidgin/LaTeX.so  $out/share/pidgin-latex 
-  '') ["minInit" "defEnsureDir" "doMakeInstall"];
-
-  /* doConfigure should be specified separately */
-  phaseNames = [ "preBuild" "doMakeInstall" "postInstall"];
-
-  name = "pidgin-latex-${version}";
-  meta = {
-    description = "LaTeX rendering plugin for Pidgin IM";
-    priority = "10";
-  };
-}

pkgs/applications/networking/instant-messengers/pidgin/wrapper.nix

···
 { stdenv, buildEnv, pidgin, makeWrapper, plugins }:
 
-let drv = buildEnv {
+let
+extraArgs = map (x: x.wrapArgs or "") plugins;
+drv = buildEnv {
   name = "pidgin-with-plugins-" + (builtins.parseDrvName pidgin.name).version;
 
   paths = [ pidgin ] ++ plugins;
···
       done
     fi
     wrapProgram $out/bin/pidgin \
-      --suffix-each PURPLE_PLUGIN_PATH ':' "$out/lib/purple-${pidgin.version} $out/lib/pidgin"
+      --suffix-each PURPLE_PLUGIN_PATH ':' "$out/lib/purple-${pidgin.version} $out/lib/pidgin" \
+      ${toString extraArgs}
   '';
   };
 in stdenv.lib.overrideDerivation drv (x : { buildInputs = x.buildInputs ++ [ makeWrapper ]; })

pkgs/applications/science/math/R/default.nix

···
 }:
 
 stdenv.mkDerivation rec {
-  name = "R-3.1.0";
+  name = "R-3.1.2";
 
   src = fetchurl {
     url = "http://cran.r-project.org/src/base/R-3/${name}.tar.gz";
-    sha256 = "1qjzbw341bvi1h4jwbvdkvq8j0z9l3m85mpgrlfw0n2cz2806s4a";
+    sha256 = "0ypsm11c7n49pgh2ricyhhpfhas3famscdazzdp2zq70rapm1ldw";
   };
 
   buildInputs = [ blas bzip2 gfortran liblapack libX11 libXmu libXt
···
 
   installTargets = [ "install" "install-info" "install-pdf" ];
 
-  doCheck = true;
+  # The test suite fails when building without the recommended packages.
+  doCheck = withRecommendedPackages;
 
   enableParallelBuilding = true;
 

pkgs/applications/version-management/darcs/default.nix

···
     mv contrib/darcs_completion $out/etc/bash_completion.d/darcs
   '';
   patchPhase = ''
-    sed -i -e 's|random.*==.*|random|' darcs.cabal
+    sed -i -e 's|random.*==.*|random|' -e 's|text.*>=.*,|text,|' darcs.cabal
   '';
   meta = {
     homepage = "http://darcs.net/";

pkgs/applications/version-management/git-and-tools/github-backup/default.nix

···
 # This file was auto-generated by cabal2nix. Please do NOT edit manually!
 
-{ cabal, extensibleExceptions, filepath, git, github, hslogger
-, IfElse, MissingH, mtl, network, optparseApplicative, prettyShow
-, text, unixCompat
+{ cabal, exceptions, filepath, git, github, hslogger, IfElse
+, MissingH, mtl, network, networkUri, optparseApplicative
+, prettyShow, text, transformers, unixCompat
 }:
 
 cabal.mkDerivation (self: {
   pname = "github-backup";
-  version = "1.20140721";
-  sha256 = "0bnkfmgpk1iaaqck4ppn461fzk3s2761w2nxfrvw10gc934lhrxc";
+  version = "1.20141031";
+  sha256 = "1rg8hz7g12k6h3vflm51l6gdi0wckmxwdq1213ykrbl8w8bvlkm8";
   isLibrary = false;
   isExecutable = true;
   buildDepends = [
-    extensibleExceptions filepath github hslogger IfElse MissingH mtl
-    network optparseApplicative prettyShow text unixCompat
+    exceptions filepath github hslogger IfElse MissingH mtl network
+    networkUri optparseApplicative prettyShow text transformers
+    unixCompat
   ];
   buildTools = [ git ];
   meta = {
···
     description = "backs up everything github knows about a repository, to the repository";
     license = "GPL";
     platforms = self.ghc.meta.platforms;
-    hydraPlatforms = self.stdenv.lib.platforms.none;
-    broken = true;
   };
 })

pkgs/applications/version-management/git-repo/default.nix

···
 { stdenv, fetchurl, python }:
 
 stdenv.mkDerivation {
-  name = "git-repo-1.20";
+  name = "git-repo-1.21";
   src = fetchurl {
-    # I could not find a versioned url for the 1.20 version. In case
+    # I could not find a versioned url for the 1.21 version. In case
     # the sha mismatches, check the homepage for new version and sha.
     url = "http://commondatastorage.googleapis.com/git-repo-downloads/repo";
-    sha1 = "e197cb48ff4ddda4d11f23940d316e323b29671c";
+    sha1 = "b8bd1804f432ecf1bab730949c82b93b0fc5fede";
   };
 
   unpackPhase = "true";

pkgs/build-support/fetchgit/nix-prefetch-git

···
 builder=
 
 if test -n "$deepClone"; then
-  deepClone=true
+    deepClone=true
 else
-  deepClone=false
+    deepClone=false
 fi
 
 if test "$leaveDotGit" != 1; then
-  leaveDotGit=
+    leaveDotGit=
 else
-  leaveDotGit=true
+    leaveDotGit=true
 fi
 
 
 argi=0
 argfun=""
 for arg; do
-  if test -z "$argfun"; then
-    case $arg in
-      --out) argfun=set_out;;
-      --url) argfun=set_url;;
-      --rev) argfun=set_rev;;
-      --hash) argfun=set_hashType;;
-      --deepClone) deepClone=true;;
-      --no-deepClone) deepClone=false;;
-      --leave-dotGit) leaveDotGit=true;;
-      --fetch-submodules) fetchSubmodules=true;;
-      --builder) builder=true;;
-      *)
-          argi=$(($argi + 1))
-          case $argi in
-              1) url=$arg;;
-              2) rev=$arg;;
-              3) expHash=$arg;;
-              *) exit 1;;
-          esac
-          ;;
-    esac
-  else
-    case $argfun in
-      set_*)
-        var=$(echo $argfun | sed 's,^set_,,')
-        eval $var=$arg
-        ;;
-    esac
-    argfun=""
-  fi
+    if test -z "$argfun"; then
+        case $arg in
+            --out) argfun=set_out;;
+            --url) argfun=set_url;;
+            --rev) argfun=set_rev;;
+            --hash) argfun=set_hashType;;
+            --deepClone) deepClone=true;;
+            --no-deepClone) deepClone=false;;
+            --leave-dotGit) leaveDotGit=true;;
+            --fetch-submodules) fetchSubmodules=true;;
+            --builder) builder=true;;
+            *)
+                argi=$(($argi + 1))
+                case $argi in
+                    1) url=$arg;;
+                    2) rev=$arg;;
+                    3) expHash=$arg;;
+                    *) exit 1;;
+                esac
+                ;;
+        esac
+    else
+        case $argfun in
+            set_*)
+                var=$(echo $argfun | sed 's,^set_,,')
+                eval $var=$arg
+                ;;
+        esac
+        argfun=""
+    fi
 done
 
 usage(){
···
 }
 
 if test -z "$url"; then
-  usage
+    usage
 fi
 
 
 init_remote(){
-    local url=$1;
-    git init;
-    git remote add origin $url;
+    local url=$1
+    git init
+    git remote add origin $url
 }
 
 # Return the reference of an hash if it exists on the remote repository.
 ref_from_hash(){
-    local hash=$1;
+    local hash=$1
     git ls-remote origin | sed -n "\,$hash\t, { s,\(.*\)\t\(.*\),\2,; p; q}"
 }
 
···
 
 # Fetch everything and checkout the right sha1
 checkout_hash(){
-    local hash="$1";
-    local ref="$2";
+    local hash="$1"
+    local ref="$2"
 
     if test -z "$hash"; then
-        hash=$(hash_from_ref $ref);
-    fi;
+        hash=$(hash_from_ref $ref)
+    fi
 
     git fetch ${builder:+--progress} origin || return 1
     git checkout -b fetchgit $hash || return 1
···
 
 # Fetch only a branch/tag and checkout it.
 checkout_ref(){
-    local hash="$1";
-    local ref="$2";
+    local hash="$1"
+    local ref="$2"
 
     if "$deepClone"; then
-	# The caller explicitly asked for a deep clone.  Deep clones
-	# allow "git describe" and similar tools to work.  See
-	# http://thread.gmane.org/gmane.linux.distributions.nixos/3569
-	# for a discussion.
-	return 1
+        # The caller explicitly asked for a deep clone.  Deep clones
+        # allow "git describe" and similar tools to work.  See
+        # http://thread.gmane.org/gmane.linux.distributions.nixos/3569
+        # for a discussion.
+        return 1
     fi
 
     if test -z "$ref"; then
-        ref=$(ref_from_hash $hash);
-    fi;
+        ref=$(ref_from_hash $hash)
+    fi
 
     if test -n "$ref"; then
         # --depth option is ignored on http repository.
         git fetch ${builder:+--progress} --depth 1 origin +"$ref" || return 1
         git checkout -b fetchgit FETCH_HEAD || return 1
     else
-        return 1;
-    fi;
+        return 1
+    fi
 }
 
 # Update submodules
···
     git submodule status |
     while read l; do
         # checkout each submodule
-        local hash=$(echo $l | awk '{print substr($1,2)}');
-        local dir=$(echo $l | awk '{print $2}');
+        local hash=$(echo $l | awk '{print substr($1,2)}')
+        local dir=$(echo $l | awk '{print $2}')
         local name=$(
             git config -f .gitmodules --get-regexp submodule\.[^.]*\.path |
             sed -n "s,^\(.*\)\.path $dir\$,\\1,p")
-        local url=$(git config -f .gitmodules --get ${name}.url);
+        local url=$(git config -f .gitmodules --get ${name}.url)
 
         # Get Absolute URL if we have a relative URL
         if ! echo "$url" | grep '^[a-zA-Z]\+://' >/dev/null 2>&1; then
-          url="$(git config --get remote.origin.url)/$url"
+            url="$(git config --get remote.origin.url)/$url"
         fi
 
-        clone "$dir" "$url" "$hash" "";
-    done;
+        clone "$dir" "$url" "$hash" ""
+    done
 }
 
 clone(){
···
     local hash="$3"
     local ref="$4"
 
-    cd $dir;
+    cd $dir
 
     # Initialize the repository.
-    init_remote "$url";
+    init_remote "$url"
 
     # Download data from the repository.
     checkout_ref "$hash" "$ref" ||
     checkout_hash "$hash" "$ref" || (
-        echo 1>&2 "Unable to checkout $hash$ref from $url.";
-        exit 1;
+        echo 1>&2 "Unable to checkout $hash$ref from $url."
+        exit 1
     )
 
     # Checkout linked sources.
     if test -n "$fetchSubmodules"; then
-        init_submodules;
+        init_submodules
     fi
 
     if [ -z "$builder" -a -f .topdeps ]; then
-	if tg help 2>&1 > /dev/null
-	then
-	    echo "populating TopGit branches..."
-	    tg remote --populate origin
-	else
-	    echo "WARNING: would populate TopGit branches but TopGit is not available" >&2
-	    echo "WARNING: install TopGit to fix the problem" >&2
-	fi
+        if tg help 2>&1 > /dev/null
+        then
+            echo "populating TopGit branches..."
+            tg remote --populate origin
+        else
+            echo "WARNING: would populate TopGit branches but TopGit is not available" >&2
+            echo "WARNING: install TopGit to fix the problem" >&2
+        fi
     fi
 
-    cd $top;
+    cd $top
+}
+
+# Remove all remote branches, remove tags not reachable from HEAD, do a full
+# repack and then garbage collect unreferenced objects.
+make_deterministic_repo(){
+    local repo="$1"
+
+    # run in sub-shell to not touch current working directory
+    (
+    cd "$repo"
+    # Remove files that contain timestamps or otherwise have non-deterministic
+    # properties.
+    rm -rf .git/logs/ .git/hooks/ .git/index .git/FETCH_HEAD .git/ORIG_HEAD \
+        .git/refs/remotes/origin/HEAD .git/config
+
+    # Remove all remote branches.
+    git branch -r | while read branch; do
+        git branch -rD "$branch" >&2
+    done
+
+    # Remove tags not reachable from HEAD. If we're exactly on a tag, don't
+    # delete it.
+    maybe_tag=$(git tag --points-at HEAD)
+    git tag --contains HEAD | while read tag; do
+        if [ "$tag" != "$maybe_tag" ]; then
+            git tag -d "$tag" >&2
+        fi
+    done
+
+    # Do a full repack, for determinism.
+    # Repack does not add unreferenced objects to a pack file.
+    git repack -A -d -f
+
+    # Garbage collect unreferenced objects.
+    git gc --prune=all
+    )
 }
+
 
 clone_user_rev() {
     local dir="$1"
···
             clone "$dir" "$url" "" "$rev" 1>&2;;
         *)
             if test -z "$(echo $rev | tr -d 0123456789abcdef)"; then
-                clone "$dir" "$url" "$rev" "" 1>&2;
+                clone "$dir" "$url" "$rev" "" 1>&2
             else
-                echo 1>&2 "Bad commit hash or bad reference.";
-                exit 1;
+                echo 1>&2 "Bad commit hash or bad reference."
+                exit 1
             fi;;
     esac
 
···
     # Allow doing additional processing before .git removal
     eval "$NIX_PREFETCH_GIT_CHECKOUT_HOOK"
     if test -z "$leaveDotGit"; then
-	echo "removing \`.git'..." >&2
+        echo "removing \`.git'..." >&2
         find $dir -name .git\* | xargs rm -rf
     else
-        # The logs and index contain timestamps, and the hooks contain
-        # the nix path of git's bash
-        find $dir -name .git | xargs -I {} rm -rf {}/logs {}/index {}/hooks
+        find $dir -name .git | while read gitdir; do
+            make_deterministic_repo "$(readlink -f "$gitdir/..")"
+        done
     fi
 }
 
 if test -n "$builder"; then
-  test -n "$out" -a -n "$url" -a -n "$rev" || usage
-  mkdir $out
-  clone_user_rev "$out" "$url" "$rev"
+    test -n "$out" -a -n "$url" -a -n "$rev" || usage
+    mkdir $out
+    clone_user_rev "$out" "$url" "$rev"
 else
-  if test -z "$hashType"; then
-      hashType=sha256
-  fi
+    if test -z "$hashType"; then
+        hashType=sha256
+    fi
 
-  # If the hash was given, a file with that hash may already be in the
-  # store.
-  if test -n "$expHash"; then
-      finalPath=$(nix-store --print-fixed-path --recursive "$hashType" "$expHash" git-export)
-      if ! nix-store --check-validity "$finalPath" 2> /dev/null; then
-          finalPath=
-      fi
-      hash=$expHash
-  fi
+    # If the hash was given, a file with that hash may already be in the
+    # store.
+    if test -n "$expHash"; then
+        finalPath=$(nix-store --print-fixed-path --recursive "$hashType" "$expHash" git-export)
+        if ! nix-store --check-validity "$finalPath" 2> /dev/null; then
+            finalPath=
+        fi
+        hash=$expHash
+    fi
 
-  # If we don't know the hash or a path with that hash doesn't exist,
-  # download the file and add it to the store.
-  if test -z "$finalPath"; then
+    # If we don't know the hash or a path with that hash doesn't exist,
+    # download the file and add it to the store.
+    if test -z "$finalPath"; then
 
-      tmpPath="$(mktemp -d "${TMPDIR:-/tmp}/git-checkout-tmp-XXXXXXXX")"
-      trap "rm -rf \"$tmpPath\"" EXIT
+        tmpPath="$(mktemp -d "${TMPDIR:-/tmp}/git-checkout-tmp-XXXXXXXX")"
+        trap "rm -rf \"$tmpPath\"" EXIT
 
-      tmpFile="$tmpPath/git-export"
-      mkdir "$tmpFile"
+        tmpFile="$tmpPath/git-export"
+        mkdir "$tmpFile"
 
-      # Perform the checkout.
-      clone_user_rev "$tmpFile" "$url" "$rev"
+        # Perform the checkout.
+        clone_user_rev "$tmpFile" "$url" "$rev"
 
-      # Compute the hash.
-      hash=$(nix-hash --type $hashType $hashFormat $tmpFile)
-      if ! test -n "$QUIET"; then echo "hash is $hash" >&2; fi
+        # Compute the hash.
+        hash=$(nix-hash --type $hashType $hashFormat $tmpFile)
+        if ! test -n "$QUIET"; then echo "hash is $hash" >&2; fi
 
-      # Add the downloaded file to the Nix store.
-      finalPath=$(nix-store --add-fixed --recursive "$hashType" $tmpFile)
+        # Add the downloaded file to the Nix store.
+        finalPath=$(nix-store --add-fixed --recursive "$hashType" $tmpFile)
 
-      if test -n "$expHash" -a "$expHash" != "$hash"; then
-          echo "hash mismatch for URL \`$url'"
-          exit 1
-      fi
-  fi
+        if test -n "$expHash" -a "$expHash" != "$hash"; then
+            echo "hash mismatch for URL \`$url'"
+            exit 1
+        fi
+    fi
 
-  if ! test -n "$QUIET"; then echo "path is $finalPath" >&2; fi
+    if ! test -n "$QUIET"; then echo "path is $finalPath" >&2; fi
 
-  echo $hash
+    echo $hash
 
-  if test -n "$PRINT_PATH"; then
-      echo $finalPath
-  fi
+    if test -n "$PRINT_PATH"; then
+        echo $finalPath
+    fi
 fi

pkgs/desktops/xfce/applications/xfce4-mixer.nix

···
 { stdenv, fetchurl, pkgconfig, intltool, makeWrapper
 , glib, gstreamer, gst_plugins_base, gtk
 , libxfce4util, libxfce4ui, xfce4panel, xfconf, libunique ? null
+, pulseaudioSupport ? false, gst_plugins_good
 }:
 
 let
···
   gst_plugins_minimal = gst_plugins_base.override {
     minimalDeps = true;
   };
-  gst_plugins = [ gst_plugins_minimal ];
+  gst_plugins_pulse = gst_plugins_good.override {
+    minimalDeps = true;
+  };
+  gst_plugins = [ gst_plugins_minimal ] ++ stdenv.lib.optional pulseaudioSupport gst_plugins_pulse;
 
 in
 
···
   name = "${p_name}-${ver_maj}.${ver_min}";
 
   buildInputs =
-    [ pkgconfig intltool glib gstreamer gst_plugins_minimal gtk
+    [ pkgconfig intltool glib gstreamer gtk
       libxfce4util libxfce4ui xfce4panel xfconf libunique makeWrapper
-    ];
+    ] ++ gst_plugins;
 
   postInstall =
     ''

pkgs/desktops/xfce/default.nix

···
-{ pkgs, newScope }: let
+{ config, pkgs, newScope }: let
 
 callPackage = newScope (deps // xfce_self);
 
···
   parole          = callPackage ./applications/parole.nix { };
   ristretto       = callPackage ./applications/ristretto.nix { };
   terminal        = xfce4terminal; # it has changed its name
-  xfce4mixer      = callPackage ./applications/xfce4-mixer.nix { };
+  xfce4mixer      = callPackage ./applications/xfce4-mixer.nix {
+    pulseaudioSupport = config.pulseaudio or false;
+  };
   xfce4notifyd    = callPackage ./applications/xfce4-notifyd.nix { };
   xfce4taskmanager= callPackage ./applications/xfce4-taskmanager.nix { };
   xfce4terminal   = callPackage ./applications/terminal.nix { };

pkgs/development/compilers/agda/default.nix

···
     $out/bin/agda -c --no-main $(find $out/share -name Primitive.agda)
     $out/bin/agda-mode compile
   '';
+  jailbreak = true;
   meta = {
     homepage = "http://wiki.portal.chalmers.se/agda/";
     description = "A dependently typed functional programming language and proof assistant";

pkgs/development/compilers/idris/default.nix

···
   ];
   buildTools = [ happy ];
   extraLibraries = [ boehmgc gmp ];
-  configureFlags = "-fllvm -fgmp -fffi";
+  configureFlags = "-fgmp -fffi";
+  jailbreak = true;
   meta = {
     homepage = "http://www.idris-lang.org/";
     description = "Functional Programming Language with Dependent Types";

pkgs/development/compilers/nasm/default.nix

···
 
 stdenv.mkDerivation rec {
   name = "nasm-${version}";
-  version = "2.11.05";
+  version = "2.11.06";
   
   src = fetchurl {
     url = "http://www.nasm.us/pub/nasm/releasebuilds/${version}/${name}.tar.bz2";
-    sha256 = "1sgspnascc0asmwlv3jm1mq4vzx653sa7vlg48z20pfybk7pnhaa";
+    sha256 = "0v1y1kx09nzmk8w4v79jxhn15fmi3g7l9nmgkn7ldjl1d5yxkdl7";
   };
 
   meta = {

pkgs/development/compilers/scala/default.nix

···
 { stdenv, fetchurl, makeWrapper, jre }:
 
 stdenv.mkDerivation rec {
-  name = "scala-2.11.2";
+  name = "scala-2.11.4";
 
   src = fetchurl {
     url = "http://www.scala-lang.org/files/archive/${name}.tgz";
-    sha256 = "0mnjhjiixjphr9v101v408815hkl6hlghx9h7lmmylv5z7gk3p8k";
+    sha256 = "1140xyp8kbv4l6l95pqj2bawzlvs7h39ivikdv09n13qvqcml3q0";
   };
 
   buildInputs = [ jre makeWrapper ] ;

pkgs/development/interpreters/python/3.2/CVE-2014-1912.patch

···
-# Edited from Mercurial patch: deleted the NEWS hunk, since it didn't apply cleanly.
-# It added the following line to NEWS:
-# - Issue #20246: Fix buffer overflow in socket.recvfrom_into.
-
-
-# HG changeset patch
-# User Benjamin Peterson <[e-mail]>
-# Date 1389671978 18000
-# Node ID 9c56217e5c793685eeaf0ee224848c402bdf1e4c
-# Parent  2b5cd6d4d149dea6c6941b7e07ada248b29fc9f6
-complain when nbytes > buflen to fix possible buffer overflow (closes #20246)
-
-diff --git a/Lib/test/test_socket.py b/Lib/test/test_socket.py
---- a/Lib/test/test_socket.py
-+++ b/Lib/test/test_socket.py
-@@ -1968,6 +1968,14 @@ class BufferIOTest(SocketConnectedTest):
- 
-     _testRecvFromIntoMemoryview = _testRecvFromIntoArray
- 
-+    def testRecvFromIntoSmallBuffer(self):
-+        # See issue #20246.
-+        buf = bytearray(8)
-+        self.assertRaises(ValueError, self.cli_conn.recvfrom_into, buf, 1024)
-+
-+    def _testRecvFromIntoSmallBuffer(self):
-+        self.serv_conn.send(MSG*2048)
-+
- 
- TIPC_STYPE = 2000
- TIPC_LOWER = 200
-diff --git a/Misc/ACKS b/Misc/ACKS
---- a/Misc/ACKS
-+++ b/Misc/ACKS
-@@ -1020,6 +1020,7 @@ Eric V. Smith
- Christopher Smith
- Gregory P. Smith
- Roy Smith
-+Ryan Smith-Roberts
- Rafal Smotrzyk
- Dirk Soede
- Paul Sokolovsky
-diff --git a/Misc/NEWS b/Misc/NEWS
---- a/Modules/socketmodule.c
-+++ b/Modules/socketmodule.c
-@@ -2598,6 +2598,11 @@ sock_recvfrom_into(PySocketSockObject *s
-     if (recvlen == 0) {
-         /* If nbytes was not specified, use the buffer's length */
-         recvlen = buflen;
-+    } else if (recvlen > buflen) {
-+        PyBuffer_Release(&pbuf);
-+        PyErr_SetString(PyExc_ValueError,
-+                        "nbytes is greater than the length of the buffer");
-+        return NULL;
-     }
- 
-     readlen = sock_recvfrom_guts(s, buf, recvlen, flags, &addr);
-

pkgs/development/interpreters/python/3.2/default.nix

···
 
 let
   majorVersion = "3.2";
-  version = "${majorVersion}.5";
+  version = "${majorVersion}.6";
 
   buildInputs = filter (p: p != null) [
     zlib bzip2 gdbm sqlite db readline ncurses openssl tcl tk libX11 xproto
···
   inherit majorVersion version;
 
   src = fetchurl {
-    url = "http://www.python.org/ftp/python/${version}/Python-${version}.tar.bz2";
-    sha256 = "0pxs234g08v3lar09lvzxw4vqdpwkbqmvkv894j2w7aklskcjd6v";
+    url = "http://www.python.org/ftp/python/${version}/Python-${version}.tar.xz";
+    sha256 = "1p3vvvh3qw8avq959hdl6bq5d6r7mbhrnigqzgx6mllzh40va4hx";
   };
-
-  patches =
-    [
-      # See http://bugs.python.org/issue20246
-      ./CVE-2014-1912.patch
-    ];
 
   NIX_LDFLAGS = stdenv.lib.optionalString stdenv.isLinux "-lgcc_s";
 

pkgs/development/interpreters/python/3.3/default.nix

···
 
 let
   majorVersion = "3.3";
-  version = "${majorVersion}.5";
+  version = "${majorVersion}.6";
 
   buildInputs = filter (p: p != null) [
     zlib bzip2 lzma gdbm sqlite db readline ncurses openssl tcl tk libX11 xproto
···
 
   src = fetchurl {
     url = "http://www.python.org/ftp/python/${version}/Python-${version}.tar.xz";
-    sha256 = "1rdncc7g8g6f3lfdg33rli1yffbiq8z283xy4f5ksl1l8i49psdb";
+    sha256 = "0gsxpgd5p4mwd01gw501vsyahncyw3h9836ypkr3y32kgazy89jj";
   };
 
   NIX_LDFLAGS = stdenv.lib.optionalString stdenv.isLinux "-lgcc_s";

pkgs/development/libraries/git2/default.nix

···
 {stdenv, fetchurl, cmake, zlib, python, libssh2, openssl, http-parser}:
 
 stdenv.mkDerivation rec {
-  version = "0.21.1";
+  version = "0.21.2";
   name = "libgit2-${version}";
 
   src = fetchurl {
     name = "${name}.tar.gz";
     url = "https://github.com/libgit2/libgit2/tarball/v${version}";
-    sha256 = "0afbvcsryg7bsmbfj23l09b1xngkmqhf043njl8wm44qslrxibkz";
+    sha256 = "0icf119lhha96rk8m6s38sczjr0idr7yczw6knby61m81a25a96y";
   };
 
   cmakeFlags = "-DTHREADSAFE=ON";

pkgs/development/libraries/gstreamer/legacy/gst-plugins-good/default.nix

···
 , flac, libjpeg, zlib, speex, libpng, libdv, libcaca, libvpx
 , libiec61883, libavc1394, taglib, pulseaudio, gdk_pixbuf, orc
 , glib, gstreamer, bzip2
+, # Whether to build no plugins that have external dependencies
+  # (except the PulseAudio plugin).
+  minimalDeps ? false
 }:
 
 stdenv.mkDerivation rec {
···
   configureFlags = "--disable-oss";
 
   buildInputs =
-    [ pkgconfig glib gstreamer gst_plugins_base libavc1394 libiec61883
-      aalib libcaca cairo libdv flac libjpeg libpng pulseaudio speex
-      taglib bzip2 libvpx gdk_pixbuf orc
-    ];
+    [ pkgconfig glib gstreamer gst_plugins_base pulseaudio ]
+    ++ stdenv.lib.optionals (!minimalDeps)
+      [ aalib libcaca cairo libdv flac libjpeg libpng speex
+        taglib bzip2 libvpx gdk_pixbuf orc ];
 
   enableParallelBuilding = true;
 

pkgs/development/libraries/gstreamer/legacy/gst-python/default.nix

···
 { fetchurl, stdenv, pkgconfig, python, gstreamer
-  , gst_plugins_base, pygtk
+, gst_plugins_base, pygobject
 }:
 
 stdenv.mkDerivation rec {
···
     sha256 = "0y1i4n5m1diljqr9dsq12anwazrhbs70jziich47gkdwllcza9lg";
   };
 
+  # Need to disable the testFake test case due to bug in pygobject.
+  # See https://bugzilla.gnome.org/show_bug.cgi?id=692479
+  patches = [ ./disable-testFake.patch ];
+
   buildInputs =
-    [ pkgconfig gst_plugins_base pygtk ]
+    [ pkgconfig gst_plugins_base pygobject ]
     ;
 
   propagatedBuildInputs = [ gstreamer python ];
- 
+
   meta = {
     homepage = http://gstreamer.freedesktop.org;
 

pkgs/development/libraries/gstreamer/legacy/gst-python/disable-testFake.patch

···
+diff -Nurp gst-python-0.10.22.orig/testsuite/test_bin.py gst-python-0.10.22/testsuite/test_bin.py
+--- gst-python-0.10.22.orig/testsuite/test_bin.py	2014-10-29 18:58:00.921827721 +0100
++++ gst-python-0.10.22/testsuite/test_bin.py	2014-10-29 19:00:32.019353092 +0100
+@@ -131,52 +131,6 @@ class BinAddRemove(TestCase):
+         self.assertRaises(gst.AddError, self.bin.add, src, sink)
+         self.bin.remove(src, sink)
+         self.assertRaises(gst.RemoveError, self.bin.remove, src, sink)
+-
+-class Preroll(TestCase):
+-    def setUp(self):
+-        TestCase.setUp(self)
+-        self.bin = gst.Bin('bin')
+-
+-    def tearDown(self):
+-        # FIXME: wait for state change thread to settle down
+-        while self.bin.__gstrefcount__ > 1:
+-            time.sleep(0.1)
+-        self.assertEquals(self.bin.__gstrefcount__, 1)
+-        del self.bin
+-        TestCase.tearDown(self)
+-
+-    def testFake(self):
+-        src = gst.element_factory_make('fakesrc')
+-        sink = gst.element_factory_make('fakesink')
+-        self.bin.add(src)
+-
+-        # bin will go to paused, src pad task will start and error out
+-        self.bin.set_state(gst.STATE_PAUSED)
+-        ret = self.bin.get_state()
+-        self.assertEquals(ret[0], gst.STATE_CHANGE_SUCCESS)
+-        self.assertEquals(ret[1], gst.STATE_PAUSED)
+-        self.assertEquals(ret[2], gst.STATE_VOID_PENDING)
+-
+-        # adding the sink will cause the bin to go in preroll mode
+-        gst.debug('adding sink and setting to PAUSED, should cause preroll')
+-        self.bin.add(sink)
+-        sink.set_state(gst.STATE_PAUSED)
+-        ret = self.bin.get_state(timeout=0)
+-        self.assertEquals(ret[0], gst.STATE_CHANGE_ASYNC)
+-        self.assertEquals(ret[1], gst.STATE_PAUSED)
+-        self.assertEquals(ret[2], gst.STATE_PAUSED)
+-
+-        # to actually complete preroll, we need to link and re-enable fakesrc
+-        src.set_state(gst.STATE_READY)
+-        src.link(sink)
+-        src.set_state(gst.STATE_PAUSED)
+-        ret = self.bin.get_state()
+-        self.assertEquals(ret[0], gst.STATE_CHANGE_SUCCESS)
+-        self.assertEquals(ret[1], gst.STATE_PAUSED)
+-        self.assertEquals(ret[2], gst.STATE_VOID_PENDING)
+-
+-        self.bin.set_state(gst.STATE_NULL)
+-        self.bin.get_state()
+  
+ class ConstructorTest(TestCase):
+     def testGood(self):

pkgs/development/libraries/haskell/ConfigFile/default.nix

···
 
 cabal.mkDerivation (self: {
   pname = "ConfigFile";
-  version = "1.1.2";
-  sha256 = "0xidr8dk5sc9g1v9gw7fmmrsyqiawx2rxg4c36pm4jbcj8jdzxiq";
+  version = "1.1.4";
+  sha256 = "057mw146bip9wzs7j4b5xr1x24d8w0kr4i3inri5m57jkwspn25f";
   isLibrary = true;
   isExecutable = true;
   buildDepends = [ MissingH mtl parsec ];
   meta = {
     homepage = "http://software.complete.org/configfile";
     description = "Configuration file reading & writing";
-    license = "LGPL";
+    license = self.stdenv.lib.licenses.bsd3;
     platforms = self.ghc.meta.platforms;
   };
 })

pkgs/development/libraries/haskell/HSH/default.nix

···
 
 cabal.mkDerivation (self: {
   pname = "HSH";
-  version = "2.1.1";
-  sha256 = "14aijsafd8mkh46dy071haix16p31ppdn2s3r9kxdbjjas6qh13g";
+  version = "2.1.2";
+  sha256 = "17ysn131xskx4s1g5kg08zy141q3q16bns4bsg3yjzvf6cjpz2kq";
   isLibrary = true;
   isExecutable = true;
   buildDepends = [

pkgs/development/libraries/haskell/HTF/default.nix

···
 
 cabal.mkDerivation (self: {
   pname = "HTF";
-  version = "0.12.2.2";
-  sha256 = "02n3nqghcl9wmcr2iar9bg8nziddsvp43rzyasq4fnh166y87gc4";
+  version = "0.12.2.3";
+  sha256 = "0g5z2ypn6i7wpz1439c6qjmi8lw2b86zaljkgwchjn8r8gvw4mbm";
   isLibrary = true;
   isExecutable = true;
   buildDepends = [

pkgs/development/libraries/haskell/HaXml/default.nix

···
 
 cabal.mkDerivation (self: {
   pname = "HaXml";
-  version = "1.24.1";
-  sha256 = "1pvqgczksxasayvdb6d4g7ya7g7w1v9hsa35kaxm9bcic9y8q9az";
+  version = "1.25";
+  sha256 = "02l53v9c8qzkp5zzs31973pp27q4k2h04h9x3852gah78qjvnslk";
   isLibrary = true;
   isExecutable = true;
   buildDepends = [ filepath polyparse random ];
+  noHaddock = true;
   meta = {
-    homepage = "http://www.cs.york.ac.uk/fp/HaXml/";
+    homepage = "http://projects.haskell.org/HaXml/";
     description = "Utilities for manipulating XML documents";
     license = "LGPL";
     platforms = self.ghc.meta.platforms;

pkgs/development/libraries/haskell/MissingH/default.nix

···
 
 cabal.mkDerivation (self: {
   pname = "MissingH";
-  version = "1.2.1.0";
-  sha256 = "08zpzfhl31w35x13vapimwd508j4nydi8v3vid668r4fkqnymbss";
+  version = "1.3.0.1";
+  sha256 = "1cwdhgqqv2riqwhsgyrpmqyzvg19lx6zp1g7xdp4rikh7rkn03ds";
   buildDepends = [
     filepath hslogger HUnit mtl network parsec random regexCompat time
   ];

pkgs/development/libraries/haskell/MonadRandom/0.3.nix

···
+# This file was auto-generated by cabal2nix. Please do NOT edit manually!
+
+{ cabal, mtl, random, transformers }:
+
+cabal.mkDerivation (self: {
+  pname = "MonadRandom";
+  version = "0.3";
+  sha256 = "0bmsccjcz6glb0x0nkjlq3qywfibf0wxxv4dvdhjfw5sx6im9qx3";
+  buildDepends = [ mtl random transformers ];
+  meta = {
+    description = "Random-number generation monad";
+    license = "unknown";
+    platforms = self.ghc.meta.platforms;
+  };
+})

pkgs/development/libraries/haskell/ariadne/default.nix

···
 
 cabal.mkDerivation (self: {
   pname = "ariadne";
-  version = "0.1.2.2";
-  sha256 = "0dp2xs1g9cw27gwvw2qzyv1qk3z97mg8ab6rfx967r7ad76lkzx2";
+  version = "0.1.2.3";
+  sha256 = "02hyn3y4h7w4l5k48kp73al67lp8vzlymblb7al72w14r01ww8p3";
   isLibrary = false;
   isExecutable = true;
   buildDepends = [

pkgs/development/libraries/haskell/bindings-libusb/default.nix

···
 
 cabal.mkDerivation (self: {
   pname = "bindings-libusb";
-  version = "1.4.4.1";
-  sha256 = "1cip5a0n8svjkzawpx3wi9z7nywmn9bl3k2w559b3awy0wixybrx";
+  version = "1.4.5.0";
+  sha256 = "0xnx9p6wqbwiaqigdnf7x6vd0qq7w9wm0vxsh93adpb5wdpjza66";
   buildDepends = [ bindingsDSL ];
   pkgconfigDepends = [ libusb ];
   meta = {

pkgs/development/libraries/haskell/cabal-lenses/default.nix

···
   version = "0.4";
   sha256 = "19ryd1qvsc301kdpk0zvw89aqhvk26ccbrgddm9j5m31mn62jl2d";
   buildDepends = [ Cabal lens unorderedContainers ];
+  jailbreak = true;
   meta = {
     description = "Lenses and traversals for the Cabal library";
     license = self.stdenv.lib.licenses.bsd3;

pkgs/development/libraries/haskell/cheapskate/default.nix

···
   buildDepends = [
     blazeHtml dataDefault mtl syb text uniplate xssSanitize
   ];
+  jailbreak = true;
   meta = {
     homepage = "http://github.com/jgm/cheapskate";
     description = "Experimental markdown processor";

pkgs/development/libraries/haskell/clay/default.nix

···
   sha256 = "1w2617kpj6rblmycqb97gyshwbvzp5w2h4xh494mvdzi3bkahqpn";
   buildDepends = [ mtl text ];
   testDepends = [ HUnit mtl testFramework testFrameworkHunit text ];
+  jailbreak = true;
   meta = {
     homepage = "http://fvisser.nl/clay";
     description = "CSS preprocessor as embedded Haskell";

pkgs/development/libraries/haskell/cmdargs/default.nix

···
 
 cabal.mkDerivation (self: {
   pname = "cmdargs";
-  version = "0.10.11";
-  sha256 = "0wfw6gpqbd89wzq6gh11bc35m2wbaf2jnkf6gxhpml70jn6ca8nz";
+  version = "0.10.12";
+  sha256 = "0axn3ycw4rijh1ka5f73gz9w330s851cpxbv39ia4xnb0l95hrjy";
   isLibrary = true;
   isExecutable = true;
   buildDepends = [ filepath transformers ];

pkgs/development/libraries/haskell/diagrams/contrib.nix

···
     diagramsLib HUnit QuickCheck testFramework testFrameworkHunit
     testFrameworkQuickcheck2
   ];
+  jailbreak = true;
   meta = {
     homepage = "http://projects.haskell.org/diagrams/";
     description = "Collection of user contributions to diagrams EDSL";

pkgs/development/libraries/haskell/diagrams/core.nix

···
     dualTree lens MemoTrie monoidExtras newtype semigroups vectorSpace
     vectorSpacePoints
   ];
+  jailbreak = true;
   meta = {
     homepage = "http://projects.haskell.org/diagrams";
     description = "Core libraries for diagrams EDSL";

pkgs/development/libraries/haskell/diagrams/lib.nix

···
     monoidExtras optparseApplicative semigroups tagged vectorSpace
     vectorSpacePoints
   ];
+  jailbreak = true;
   meta = {
     homepage = "http://projects.haskell.org/diagrams";
     description = "Embedded domain-specific language for declarative graphics";

pkgs/development/libraries/haskell/diagrams/postscript.nix

···
     dataDefaultClass diagramsCore diagramsLib dlist filepath hashable
     lens monoidExtras mtl semigroups split vectorSpace
   ];
+  jailbreak = true;
   meta = {
     homepage = "http://projects.haskell.org/diagrams/";
     description = "Postscript backend for diagrams drawing EDSL";

pkgs/development/libraries/haskell/diagrams/rasterific.nix

···
     JuicyPixels lens mtl optparseApplicative Rasterific split
     statestack time
   ];
+  jailbreak = true;
   meta = {
     homepage = "http://projects.haskell.org/diagrams/";
     description = "Rasterific backend for diagrams";

pkgs/development/libraries/haskell/diagrams/svg.nix

···
     diagramsLib filepath hashable JuicyPixels lens monoidExtras mtl
     split time vectorSpace
   ];
+  jailbreak = true;
   meta = {
     homepage = "http://projects.haskell.org/diagrams/";
     description = "SVG backend for diagrams drawing EDSL";

pkgs/development/libraries/haskell/digestive-functors-aeson/default.nix

···
     license = self.stdenv.lib.licenses.gpl3;
     platforms = self.ghc.meta.platforms;
     maintainers = with self.stdenv.lib.maintainers; [ ocharles ];
+    broken = true;
   };
 })

pkgs/development/libraries/haskell/digestive-functors-snap/default.nix

···
   version = "0.6.1.0";
   sha256 = "07xb8jr70j03kggk55p3zzp07y7amzm7f8hdzry4vff7yx41rxhr";
   buildDepends = [ digestiveFunctors filepath mtl snapCore text ];
+  jailbreak = true;
   meta = {
     homepage = "http://github.com/jaspervdj/digestive-functors";
     description = "Snap backend for the digestive-functors library";

pkgs/development/libraries/haskell/encoding/default.nix

···
   buildDepends = [
     binary extensibleExceptions HaXml mtl regexCompat
   ];
+  jailbreak = true;
   meta = {
     homepage = "http://code.haskell.org/encoding/";
     description = "A library for various character encodings";

pkgs/development/libraries/haskell/entropy/default.nix

···
 
 cabal.mkDerivation (self: {
   pname = "entropy";
-  version = "0.3.3";
-  sha256 = "0px97mims7pbxyh8jqckc14ahdjj7r3hhckzpjqnxpkcisb2c738";
+  version = "0.3.4";
+  sha256 = "1khfvrk49zf0rd90d34983048mxy093ci2qk8866qq0hwi53b0q0";
   meta = {
     homepage = "https://github.com/TomMD/entropy";
     description = "A platform independent entropy source";

pkgs/development/libraries/haskell/extra/default.nix

···
 
 cabal.mkDerivation (self: {
   pname = "extra";
-  version = "0.4";
-  sha256 = "1wqhnfm297iwf6l4bkhnlbv4bb54b9y5qig7h5n7fjn88bxgwj1l";
+  version = "0.6";
+  sha256 = "1mayrzlk6kycdwcag60pzas5cmbhlxid1bkfsaqa371bfjs79zpn";
   buildDepends = [ filepath time ];
-  testDepends = [ QuickCheck time ];
+  testDepends = [ filepath QuickCheck time ];
   meta = {
     homepage = "https://github.com/ndmitchell/extra#readme";
     description = "Extra functions I use";

pkgs/development/libraries/haskell/filestore/default.nix

···
 
 cabal.mkDerivation (self: {
   pname = "filestore";
-  version = "0.6.0.3";
-  sha256 = "03qmv3cqp1fv7b7pdjdx12cb27bfjbwwjdhkcvkfq89qwk9wh1h0";
+  version = "0.6.0.4";
+  sha256 = "1b3ymdqwcn84m8kkybshx10bfylby49i0yhbassvlgf0n096lp12";
   buildDepends = [ Diff filepath parsec split time utf8String xml ];
   testDepends = [ Diff filepath HUnit mtl time ];
   jailbreak = true;
+  doCheck = false;
   meta = {
     description = "Interface for versioning file stores";
     license = self.stdenv.lib.licenses.bsd3;

pkgs/development/libraries/haskell/force-layout/default.nix

···
   buildDepends = [
     dataDefaultClass lens vectorSpace vectorSpacePoints
   ];
+  jailbreak = true;
   meta = {
     description = "Simple force-directed layout";
     license = self.stdenv.lib.licenses.bsd3;

pkgs/development/libraries/haskell/ghc-mod/default.nix

···
 { cabal, async, Cabal, convertible, dataDefault, deepseq, djinnGhc
 , doctest, emacs, filepath, ghcPaths, ghcSybUtils, haskellSrcExts
 , hlint, hspec, ioChoice, makeWrapper, monadControl, monadJournal
-, mtl, split, syb, text, time, transformers, transformersBase
+, mtl, split, syb, temporary, text, time, transformers
+, transformersBase
 }:
 
 cabal.mkDerivation (self: {
   pname = "ghc-mod";
-  version = "5.1.1.0";
-  sha256 = "0msx2x976ap4jx506mzp48sdigc29vq4ypjbxiyn30mjw52rg53w";
+  version = "5.2.0.0";
+  sha256 = "1zwdr3zlnc8d49d6jrvj2yrfnamp1120gffzd6vfxqgvapk71vfk";
   isLibrary = true;
   isExecutable = true;
   buildDepends = [
     async Cabal convertible dataDefault deepseq djinnGhc filepath
     ghcPaths ghcSybUtils haskellSrcExts hlint ioChoice monadControl
-    monadJournal mtl split syb text time transformers transformersBase
+    monadJournal mtl split syb temporary text time transformers
+    transformersBase
   ];
   testDepends = [
     Cabal convertible deepseq djinnGhc doctest filepath ghcPaths
     ghcSybUtils haskellSrcExts hlint hspec ioChoice monadControl
-    monadJournal mtl split syb text time transformers transformersBase
+    monadJournal mtl split syb temporary text time transformers
+    transformersBase
   ];
   buildTools = [ emacs makeWrapper ];
   doCheck = false;

pkgs/development/libraries/haskell/ghc-vis/default.nix

···
 
 cabal.mkDerivation (self: {
   pname = "ghc-vis";
-  version = "0.7.2.6";
-  sha256 = "12jyxcqyrqiai0fdfnpvsn1v64is7p8zixi745k29h54i0px1j89";
+  version = "0.7.2.7";
+  sha256 = "0kxkmbp71yx5mskzpcyjd8s2yq01q1q6dxmqzmwg6naalcpcbswv";
   buildDepends = [
     cairo deepseq fgl ghcHeapView graphviz gtk mtl svgcairo text
     transformers xdot

pkgs/development/libraries/haskell/gitit/default.nix

···
 
 { cabal, aeson, base64Bytestring, blazeHtml, ConfigFile, feed
 , filepath, filestore, ghcPaths, happstackServer, highlightingKate
-, hoauth2, hslogger, HStringTemplate, HTTP, httpClient
-, httpClientTls, json, mtl, network, networkUri, pandoc
-, pandocTypes, parsec, random, recaptcha, safe, SHA, split, syb
-, tagsoup, text, time, uri, url, utf8String, xhtml, xml
-, xssSanitize, zlib
+, hoauth2, hslogger, HStringTemplate, HTTP, httpClientTls
+, httpConduit, json, mtl, network, networkUri, pandoc, pandocTypes
+, parsec, random, recaptcha, safe, SHA, split, syb, tagsoup, text
+, time, uri, url, utf8String, uuid, xhtml, xml, xssSanitize, zlib
 }:
 
 cabal.mkDerivation (self: {
   pname = "gitit";
-  version = "0.10.5.1";
-  sha256 = "0wi40f34xqqz0q8m14g7ay6yk37c3fkdijydv0di43i20bxixjhv";
+  version = "0.10.6.1";
+  sha256 = "1l6zra0yiwrmiycblp25b5yd1yrz94537l8zkspkf7z6wc8vdkn0";
   isLibrary = true;
   isExecutable = true;
   buildDepends = [
     aeson base64Bytestring blazeHtml ConfigFile feed filepath filestore
     ghcPaths happstackServer highlightingKate hoauth2 hslogger
-    HStringTemplate HTTP httpClient httpClientTls json mtl network
+    HStringTemplate HTTP httpClientTls httpConduit json mtl network
     networkUri pandoc pandocTypes parsec random recaptcha safe SHA
-    split syb tagsoup text time uri url utf8String xhtml xml
+    split syb tagsoup text time uri url utf8String uuid xhtml xml
     xssSanitize zlib
   ];
   jailbreak = true;

pkgs/development/libraries/haskell/graphviz/default.nix

···
 # This file was auto-generated by cabal2nix. Please do NOT edit manually!
 
 { cabal, colour, dlist, fgl, filepath, polyparse, QuickCheck
-, temporary, text, transformers, wlPprintText
+, systemGraphviz, temporary, text, transformers, wlPprintText
 }:
 
 cabal.mkDerivation (self: {
···
     colour dlist fgl filepath polyparse temporary text transformers
     wlPprintText
   ];
-  testDepends = [ fgl filepath QuickCheck text ];
-  doCheck = false;
+  testDepends = [ fgl filepath QuickCheck systemGraphviz text ];
+  jailbreak = true;
   meta = {
     homepage = "http://projects.haskell.org/graphviz/";
     description = "Bindings to Graphviz for graph visualisation";

pkgs/development/libraries/haskell/hakyll/default.nix

···
 
 cabal.mkDerivation (self: {
   pname = "hakyll";
-  version = "4.5.5.1";
-  sha256 = "060wcak242p2gja616bdair4sg2k04s8cld5nlk8p3b6an2isld9";
+  version = "4.6.0.0";
+  sha256 = "0ihaw53935g9pyasa8g5qi1dgvxanhhpkg0xcjq7aazqk2cciqy3";
   isLibrary = true;
   isExecutable = true;
   buildDepends = [

pkgs/development/libraries/haskell/haskell-platform/2009.2.0.2.nix

···
     stm time xhtml zlib parsec network
     cabalInstall alex happy ghc
   ];
+  propagatedUserEnvPkgs = self.propagatedBuildInputs;
   meta = {
     description = "Haskell Platform meta package";
     license = self.stdenv.lib.licenses.bsd3;

pkgs/development/libraries/haskell/haskell-platform/2010.1.0.0.nix

···
     stm xhtml zlib parsec
     cabalInstall alex happy ghc
   ];
+  propagatedUserEnvPkgs = self.propagatedBuildInputs;
   meta = {
     description = "Haskell Platform meta package";
     license = self.stdenv.lib.licenses.bsd3;

pkgs/development/libraries/haskell/haskell-platform/2010.2.0.0.nix

···
     stm xhtml zlib mtl parsec deepseq
     cabalInstall alex happy ghc
   ];
+  propagatedUserEnvPkgs = self.propagatedBuildInputs;
   meta = {
     description = "Haskell Platform meta package";
     license = self.stdenv.lib.licenses.bsd3;

pkgs/development/libraries/haskell/haskell-platform/2011.2.0.0.nix

···
     cabalInstall alex happy ghc
   ];
   noHaddock = true;
+  propagatedUserEnvPkgs = self.propagatedBuildInputs;
   meta = {
     description = "Haskell Platform meta package";
     license = self.stdenv.lib.licenses.bsd3;

pkgs/development/libraries/haskell/haskell-platform/2011.2.0.1.nix

···
     touch $sourceRoot/LICENSE
   '';
   noHaddock = true;
+  propagatedUserEnvPkgs = self.propagatedBuildInputs;
   meta = {
     description = "Haskell Platform meta package";
     license = self.stdenv.lib.licenses.bsd3;

pkgs/development/libraries/haskell/haskell-platform/2011.4.0.0.nix

···
     touch $sourceRoot/LICENSE
   '';
   noHaddock = true;
+  propagatedUserEnvPkgs = self.propagatedBuildInputs;
   meta = {
     homepage = "http://haskell.org/platform";
     description = "Haskell Platform meta package";

pkgs/development/libraries/haskell/haskell-platform/2012.2.0.0.nix

···
     touch $sourceRoot/LICENSE
   '';
   noHaddock = true;
+  propagatedUserEnvPkgs = self.propagatedBuildInputs;
   meta = {
     homepage = "http://haskell.org/platform";
     description = "Haskell Platform meta package";

pkgs/development/libraries/haskell/haskell-platform/2012.4.0.0.nix

···
     touch $sourceRoot/LICENSE
   '';
   noHaddock = true;
+  propagatedUserEnvPkgs = self.propagatedBuildInputs;
   meta = {
     homepage = "http://haskell.org/platform";
     description = "Haskell Platform meta package";

pkgs/development/libraries/haskell/haskell-platform/2013.2.0.0.nix

···
     touch $sourceRoot/LICENSE
   '';
   noHaddock = true;
+  propagatedUserEnvPkgs = self.propagatedBuildInputs;
   meta = {
     homepage = "http://haskell.org/platform";
     description = "Haskell Platform meta package";

pkgs/development/libraries/haskell/haskell-src-exts/1.16.0.nix pkgs/development/libraries/haskell/haskell-src-exts/1.16.0.1.nix

···
 
 cabal.mkDerivation (self: {
   pname = "haskell-src-exts";
-  version = "1.16.0";
-  sha256 = "15nhmwd2vfv14d4mc35alcjxg165a8jh0pgzinmx8aa8zbzvz5ha";
+  version = "1.16.0.1";
+  sha256 = "1h8gjw5g92rvvzadqzpscg73x7ajvs1wlphrh27afim3scdd8frz";
   buildDepends = [ cpphs ];
   testDepends = [
     filepath mtl smallcheck syb tasty tastyGolden tastySmallcheck

pkgs/development/libraries/haskell/haskoin/default.nix

···
     mtl pbkdf QuickCheck split testFramework testFrameworkHunit
     testFrameworkQuickcheck2 text
   ];
+  jailbreak = true;
   doCheck = false;
   meta = {
     homepage = "http://github.com/haskoin/haskoin";

pkgs/development/libraries/haskell/haskore/default.nix

···
 
 cabal.mkDerivation (self: {
   pname = "haskore";
-  version = "0.2.0.4";
-  sha256 = "0hhsiazdz44amilcwfxl0r10yxzhql83pgd21k89fmg1gkc4q46j";
+  version = "0.2.0.5";
+  sha256 = "0zvr7hwxnv01g626617yv7f0vwpmyqvlwbyc6yhb2mrlfqwdgbd0";
   isLibrary = true;
   isExecutable = true;
   buildDepends = [

pkgs/development/libraries/haskell/haste-perch/default.nix

···
 
 cabal.mkDerivation (self: {
   pname = "haste-perch";
-  version = "0.1.0.3";
-  sha256 = "1ad7kv47kq0sav49qnqdk76blk44sgjvk1zgn5k2bqvfnr26641j";
+  version = "0.1.0.4";
+  sha256 = "12ssfik7v671727yxplz44gwgy9i815l44r4z3x066ndcqglr306";
   buildDepends = [ hasteCompiler transformers ];
   meta = {
     homepage = "https://github.com/agocorona/haste-perch";

pkgs/development/libraries/haskell/haxr/default.nix

···
     base64Bytestring blazeBuilder HaXml HTTP mtl network networkUri
     time utf8String
   ];
+  jailbreak = true;
   meta = {
     homepage = "http://www.haskell.org/haskellwiki/HaXR";
     description = "XML-RPC client and server library";

pkgs/development/libraries/haskell/hcltest/default.nix

···
     text transformers transformersBase
   ];
   testDepends = [ doctest filepath ];
+  jailbreak = true;
   meta = {
     homepage = "http://github.com/bennofs/hcltest/";
     description = "A testing library for command line applications";

pkgs/development/libraries/haskell/hmatrix-gsl/default.nix

···
+# This file was auto-generated by cabal2nix. Please do NOT edit manually!
+
+{ cabal, gsl, hmatrix, random, vector }:
+
+cabal.mkDerivation (self: {
+  pname = "hmatrix-gsl";
+  version = "0.16.0.2";
+  sha256 = "1l865v2vpjl7f5741z58m9gw1ksskgzfm5gzp9pxiqazsgb2h5ym";
+  buildDepends = [ hmatrix random vector ];
+  pkgconfigDepends = [ gsl ];
+  meta = {
+    homepage = "https://github.com/albertoruiz/hmatrix";
+    description = "Numerical computation";
+    license = "GPL";
+    platforms = self.ghc.meta.platforms;
+  };
+})

pkgs/development/libraries/haskell/hmatrix-special/default.nix

···
 # This file was auto-generated by cabal2nix. Please do NOT edit manually!
 
-{ cabal, gsl, hmatrix }:
+{ cabal, gsl, hmatrix, hmatrixGsl }:
 
 cabal.mkDerivation (self: {
   pname = "hmatrix-special";
-  version = "0.2.0";
-  sha256 = "0lp8mvagbzayq3r08wgk498n6d9vgb1skb8wzrzi5a1fc5j8m0wj";
-  buildDepends = [ hmatrix ];
+  version = "0.3.0.1";
+  sha256 = "1ziqzbfrk7xyah5n0cys1ccnmj2z91wxdamanv3y5v717zhdrqix";
+  buildDepends = [ hmatrix hmatrixGsl ];
   extraLibraries = [ gsl ];
   meta = {
-    homepage = "http://perception.inf.um.es/hmatrix";
+    homepage = "https://github.com/albertoruiz/hmatrix";
     description = "Interface to GSL special functions";
     license = "GPL";
     platforms = self.ghc.meta.platforms;

pkgs/development/libraries/haskell/hspec-meta/default.nix

···
 
 cabal.mkDerivation (self: {
   pname = "hspec-meta";
-  version = "1.12.1";
-  sha256 = "1920gpcam7y3slg1an8ywhw6lxammgy21nmxbxlh77iz65rldzls";
+  version = "1.12.2";
+  sha256 = "1gx62pqii2y29wxk6krzrwj18xp15y3qxyvnkkgcq9j984146zfs";
   isLibrary = true;
   isExecutable = true;
   buildDepends = [

pkgs/development/libraries/haskell/hspec-wai/default.nix

···
     description = "Experimental Hspec support for testing WAI applications (depends on hspec2!)";
     license = self.stdenv.lib.licenses.mit;
     platforms = self.ghc.meta.platforms;
+    hydraPlatforms = self.stdenv.lib.platforms.none;
   };
 })

pkgs/development/libraries/haskell/hspec/default.nix

···
 
 cabal.mkDerivation (self: {
   pname = "hspec";
-  version = "1.12.1";
-  sha256 = "0w42lsl5qs452f04qpbr6nvs4qgp7cwd9262f34vzjq8m83nhjwk";
+  version = "1.12.2";
+  sha256 = "1ika9qqw8y9j95db9xgjsfj9s9jb56hq962mwbpx1pl5d15m5262";
   isLibrary = true;
   isExecutable = true;
   buildDepends = [

pkgs/development/libraries/haskell/hspec2/default.nix

···
     description = "Alpha version of Hspec 2.0";
     license = self.stdenv.lib.licenses.mit;
     platforms = self.ghc.meta.platforms;
+    broken = true;
   };
 })

pkgs/development/libraries/haskell/imm/default.nix

···
 
 { cabal, async, caseInsensitive, cond, dataDefault, dyre, feed
 , filepath, hslogger, httpConduit, httpTypes, lens, mimeMail
-, monadControl, mtl, network, opml, random, resourcet, text
-, textIcu, time, timerep, tls, transformers, transformersBase
+, monadControl, mtl, network, networkUri, opml, random, resourcet
+, text, textIcu, time, timerep, tls, transformers, transformersBase
 , utf8String, xdgBasedir, xml
 }:
 
 cabal.mkDerivation (self: {
   pname = "imm";
-  version = "0.6.0.2";
-  sha256 = "0bawp8zqpkxig33ybv0yxv6bh51rfhsyp0q7l0lh61gy17rx0gsa";
+  version = "0.6.0.3";
+  sha256 = "0fhqb36xj2xr1hhfrhk1npms9lnvbh6fmvki9mmm3gqs06hb925l";
   isLibrary = true;
   isExecutable = true;
   buildDepends = [
     async caseInsensitive cond dataDefault dyre feed filepath hslogger
-    httpConduit httpTypes lens mimeMail monadControl mtl network opml
-    random resourcet text textIcu time timerep tls transformers
-    transformersBase utf8String xdgBasedir xml
+    httpConduit httpTypes lens mimeMail monadControl mtl network
+    networkUri opml random resourcet text textIcu time timerep tls
+    transformers transformersBase utf8String xdgBasedir xml
   ];
   meta = {
     description = "Retrieve RSS/Atom feeds and write one mail per new item in a maildir";
     license = "unknown";
     platforms = self.ghc.meta.platforms;
-    broken = true;
+    maintainers = with self.stdenv.lib.maintainers; [ bergey ];
   };
 })

pkgs/development/libraries/haskell/json-assertions/default.nix

···
   version = "1.0.5";
   sha256 = "1vf6y8xbl48giq1p6d62294rfvfdw62l1q4dspy990ii0v5gkyck";
   buildDepends = [ aeson indexed indexedFree lens lensAeson text ];
+  jailbreak = true;
   meta = {
     homepage = "http://github.com/ocharles/json-assertions.git";
     description = "Test that your (Aeson) JSON encoding matches your expectations";

pkgs/development/libraries/haskell/language-c-inline/default.nix

···
 
 cabal.mkDerivation (self: {
   pname = "language-c-inline";
-  version = "0.7.6.1";
-  sha256 = "0giyclrkxbigqpgrvlz896nsiqi7fghm79pzcxmxn7vslmardn4a";
+  version = "0.7.7.0";
+  sha256 = "10wj8dlsjimgln14y7b50pnnn865ln46v3xcqwr7ahjcl3icavg6";
   buildDepends = [ filepath languageCQuote mainlandPretty ];
   testDepends = [ languageCQuote ];
   meta = {

pkgs/development/libraries/haskell/language-c/default.nix

···
 
 cabal.mkDerivation (self: {
   pname = "language-c";
-  version = "0.4.6";
-  sha256 = "0pzd3g5q3sjfngs29biannza6l9am75kcjy5q0xcjv7xhz0z1m31";
+  version = "0.4.7";
+  sha256 = "1r0jlncv6d6ai8kblrdq9gz8abx57b24y6hfh30xx20zdgccjvaz";
   buildDepends = [ filepath syb ];
   buildTools = [ alex happy ];
   meta = {

pkgs/development/libraries/haskell/lens-aeson/default.nix

···
 
 cabal.mkDerivation (self: {
   pname = "lens-aeson";
-  version = "1.0.0.1";
-  sha256 = "1gkplcvi570bd824q4zswi1ajb3730b7qng48g1zpjskvikn32qn";
+  version = "1.0.0.2";
+  sha256 = "1hq0zs1h4wapy1n9vyr4yiysnwbv26di8gl6msx3jkcahvlnkvlp";
   buildDepends = [
     aeson attoparsec lens scientific text unorderedContainers vector
   ];

pkgs/development/libraries/haskell/lens-family-th/default.nix

···
 
 cabal.mkDerivation (self: {
   pname = "lens-family-th";
-  version = "0.3.0.0";
-  sha256 = "0p9z278rpr9mqdpxa5izllplfrbxwzdziqjzjn4x1j2g9f3q5f8s";
+  version = "0.4.0.0";
+  sha256 = "02fc3kppb7y2c6j22wi2mzcxffj4k3dl3x09vjllqchfpfcpwbm5";
   meta = {
     homepage = "http://github.com/DanBurton/lens-family-th#readme";
     description = "Generate lens-family style lenses";

pkgs/development/libraries/haskell/lens/default.nix

···
 , QuickCheck, reflection, semigroupoids, semigroups, simpleReflect
 , split, tagged, testFramework, testFrameworkHunit
 , testFrameworkQuickcheck2, testFrameworkTh, text, transformers
-, transformersCompat, unorderedContainers, vector, void, zlib
+, transformersCompat, unorderedContainers, vector, void
 }:
 
 cabal.mkDerivation (self: {
   pname = "lens";
-  version = "4.4.0.2";
-  sha256 = "03h1r6np1aas5nnw3nsqcvl9an9yriikcgapnfck82pmmdvg5l47";
+  version = "4.5";
+  sha256 = "009wdzybzmk7cs27fzigsmxknim6f9s7lp7iivgcsfn49pd8imwv";
   buildDepends = [
     bifunctors comonad contravariant distributive exceptions filepath
     free hashable mtl parallel primitive profunctors reflection
     semigroupoids semigroups split tagged text transformers
-    transformersCompat unorderedContainers vector void zlib
+    transformersCompat unorderedContainers vector void
   ];
   testDepends = [
     deepseq doctest filepath genericDeriving hlint HUnit mtl nats
···
     testFrameworkHunit testFrameworkQuickcheck2 testFrameworkTh text
     transformers unorderedContainers vector
   ];
-  patchPhase = ''
-    configureFlags="-f-test-hlint"
-  '';
   meta = {
     homepage = "http://github.com/ekmett/lens/";
     description = "Lenses, Folds and Traversals";

pkgs/development/libraries/haskell/libsystemd-journal/default.nix

···
     unixBytestring unorderedContainers uuid vector
   ];
   extraLibraries = [ systemd-journal ];
+  jailbreak = true;
   meta = {
     homepage = "http://github.com/ocharles/libsystemd-journal";
     description = "Haskell bindings to libsystemd-journal";

pkgs/development/libraries/haskell/linear/default.nix

···
 
 cabal.mkDerivation (self: {
   pname = "linear";
-  version = "1.10.1.2";
-  sha256 = "05zbqdcdjq7anng2nymy05wsnk9qpk8mgivqcndbfjpk4l1r9k94";
+  version = "1.11.2";
+  sha256 = "11xinkqg4p6q287qiljq7p9lq0s58hznw2as29ppb5n3q5pab3ib";
   buildDepends = [
     adjunctions binary distributive hashable lens reflection
     semigroupoids semigroups tagged transformers unorderedContainers

pkgs/development/libraries/haskell/llvm-general-pure/3.3.8.2.nix

···
-# This file was auto-generated by cabal2nix. Please do NOT edit manually!
-
-{ cabal, HUnit, mtl, parsec, QuickCheck, setenv, testFramework
-, testFrameworkHunit, testFrameworkQuickcheck2, transformers
-}:
-
-cabal.mkDerivation (self: {
-  pname = "llvm-general-pure";
-  version = "3.3.8.2";
-  sha256 = "171mp9rydw6r2khcmvkcfjk934ckfahwyx1b4a15gmj8sr1s9hzp";
-  buildDepends = [ mtl parsec setenv transformers ];
-  testDepends = [
-    HUnit mtl QuickCheck testFramework testFrameworkHunit
-    testFrameworkQuickcheck2
-  ];
-  doCheck = false;
-  meta = {
-    description = "Pure Haskell LLVM functionality (no FFI)";
-    license = self.stdenv.lib.licenses.bsd3;
-    platforms = self.ghc.meta.platforms;
-    hydraPlatforms = self.stdenv.lib.platforms.none;
-  };
-})

pkgs/development/libraries/haskell/llvm-general/3.3.8.2.nix

···
-# This file was auto-generated by cabal2nix. Please do NOT edit manually!
-
-{ cabal, HUnit, llvmConfig, llvmGeneralPure, mtl, parsec
-, QuickCheck, setenv, testFramework, testFrameworkHunit
-, testFrameworkQuickcheck2, transformers, utf8String
-}:
-
-cabal.mkDerivation (self: {
-  pname = "llvm-general";
-  version = "3.3.8.2";
-  sha256 = "11qnvpnx4i8mjdgn5y58rl70wf8pzmd555hrdaki1f4q0035cmm5";
-  buildDepends = [
-    llvmGeneralPure mtl parsec setenv transformers utf8String
-  ];
-  testDepends = [
-    HUnit llvmGeneralPure mtl QuickCheck testFramework
-    testFrameworkHunit testFrameworkQuickcheck2
-  ];
-  buildTools = [ llvmConfig ];
-  doCheck = false;
-  meta = {
-    description = "General purpose LLVM bindings";
-    license = self.stdenv.lib.licenses.bsd3;
-    platforms = self.ghc.meta.platforms;
-    hydraPlatforms = self.stdenv.lib.platforms.none;
-  };
-})

pkgs/development/libraries/haskell/logging/default.nix

···
 
 cabal.mkDerivation (self: {
   pname = "logging";
-  version = "1.4.1";
-  sha256 = "15mhpafv797f8aifjyjb5nc0fkd7if7bvx5hx9mzxycdzlk28gfp";
+  version = "2.1.0";
+  sha256 = "15ad4g7zkbklawd98m6x838fr5383vkvq92y75f56j1kj17g7rrh";
   buildDepends = [
     binary fastLogger liftedBase monadControl monadLogger pcreLight
     text time transformers vectorSpace

pkgs/development/libraries/haskell/mainland-pretty/default.nix

···
   version = "0.2.7";
   sha256 = "1g4s2xscj6dpkcghs5lws658ki0rhriivpdr5ilcycvr28k3l35q";
   buildDepends = [ srcloc text ];
+  jailbreak = true;
   meta = {
     homepage = "http://www.eecs.harvard.edu/~mainland/";
     description = "Pretty printing designed for printing source code";

pkgs/development/libraries/haskell/monad-journal/default.nix

···
 
 cabal.mkDerivation (self: {
   pname = "monad-journal";
-  version = "0.5";
-  sha256 = "1dr5l9pz1wij3ysp95pchlgw1zs12akgrm7rrr3bnv162c13vb9h";
+  version = "0.5.0.1";
+  sha256 = "1rxmz6hx8kh8sw497h4kpxkvhgaa7jbzif7qssjqijyfmghsxh80";
   buildDepends = [
     either monadControl mtl transformers transformersBase
   ];
   meta = {
     homepage = "http://github.com/phaazon/monad-journal";
     description = "Pure logger typeclass and monad transformer";
-    license = self.stdenv.lib.licenses.publicDomain;
+    license = self.stdenv.lib.licenses.bsd3;
     platforms = self.ghc.meta.platforms;
     maintainers = with self.stdenv.lib.maintainers; [ fuuzetsu ];
   };

pkgs/development/libraries/haskell/persistent-mysql/default.nix

···
 
 cabal.mkDerivation (self: {
   pname = "persistent-mysql";
-  version = "2.1";
-  sha256 = "0r4xxv1250ny7x3298mqcv2x5l8vp0ncn9k9js7yi2lj9gcijj6f";
+  version = "2.1.1";
+  sha256 = "058i7iblbf73z2gnyc1d70vdwmcyfr4hq3lw59hng1qmqs93dv4l";
   buildDepends = [
     aeson blazeBuilder conduit monadControl monadLogger mysql
     mysqlSimple persistent resourcet text transformers

pkgs/development/libraries/haskell/persistent/default.nix

···
 
 cabal.mkDerivation (self: {
   pname = "persistent";
-  version = "2.1.0.1";
-  sha256 = "0506w53shy0ck7vyncrhh5prp9jri8bbp2awzbkavfxiwzra1l83";
+  version = "2.1.0.2";
+  sha256 = "15g0y7vmzihg6cxym5drzbk8jzpp8cqkfvnvmd395fa2ki2acxm7";
   buildDepends = [
     aeson attoparsec base64Bytestring blazeHtml blazeMarkup conduit
     exceptions fastLogger liftedBase monadControl monadLogger mtl

pkgs/development/libraries/haskell/pipes-shell/default.nix

···
   testDepends = [
     async hspec pipes pipesBytestring pipesSafe stm stmChans text
   ];
+  jailbreak = true;
   doCheck = false;
   meta = {
     description = "Create proper Pipes from System.Process";

pkgs/development/libraries/haskell/polyparse/default.nix

···
 
 cabal.mkDerivation (self: {
   pname = "polyparse";
-  version = "1.9";
-  sha256 = "12khjhv1dvs4j1jyh3law7m1gmkad8s6q7clh7w6l5ll2n1dc4lz";
+  version = "1.10";
+  sha256 = "0nz7dv91a2f7gf4jnma8qcqa4n6qjcyggf8qdja46sdcabpd0ij2";
   buildDepends = [ text ];
   meta = {
     homepage = "http://code.haskell.org/~malcolm/polyparse/";

pkgs/development/libraries/haskell/postgresql-simple/default.nix

···
 
 cabal.mkDerivation (self: {
   pname = "postgresql-simple";
-  version = "0.4.6.0";
-  sha256 = "16pipp806askv7a97d2nncws8kr29d09rvas17b3mhbly5nah2kr";
+  version = "0.4.7.0";
+  sha256 = "17cs5f7pfh30y2n8b3w76v832sd5z9m5xswpfa5w6r2vf18xpkqs";
   buildDepends = [
     aeson attoparsec blazeBuilder blazeTextual hashable postgresqlLibpq
     scientific text time transformers uuid vector

pkgs/development/libraries/haskell/purescript/default.nix

···
 
 { cabal, cmdtheline, filepath, haskeline, monadUnify, mtl, parsec
 , patternArrows, time, transformers, unorderedContainers
-, utf8String, xdgBasedir
+, utf8String
 }:
 
 cabal.mkDerivation (self: {
···
   isExecutable = true;
   buildDepends = [
     cmdtheline filepath haskeline monadUnify mtl parsec patternArrows
-    time transformers unorderedContainers utf8String xdgBasedir
+    time transformers unorderedContainers utf8String
   ];
   testDepends = [ filepath mtl parsec transformers utf8String ];
   doCheck = false;

pkgs/development/libraries/haskell/reactive-banana-wx/default.nix

···
   isExecutable = true;
   buildDepends = [ cabalMacosx reactiveBanana wx wxcore ];
   configureFlags = "-f-buildExamples";
+  jailbreak = true;
   meta = {
     homepage = "http://haskell.org/haskellwiki/Reactive-banana";
     description = "Examples for the reactive-banana library, using wxHaskell";

pkgs/development/libraries/haskell/rest-gen/default.nix

···
 
 cabal.mkDerivation (self: {
   pname = "rest-gen";
-  version = "0.16.0.4";
-  sha256 = "1qh8sg4klkssxwqyi7r5hzjzg45csxy7f7cznv27hmrpji28z2x2";
+  version = "0.16.1";
+  sha256 = "05z4k2wjdf1vvj95f2k56j8bd7vx7wla4rryyb6pcnjrwvr2f7ws";
   buildDepends = [
     aeson blazeHtml Cabal codeBuilder fclabels filepath hashable
     haskellSrcExts hslogger HStringTemplate hxt jsonSchema restCore

pkgs/development/libraries/haskell/rethinkdb/default.nix

···
 
 cabal.mkDerivation (self: {
   pname = "rethinkdb";
-  version = "1.15.1.0";
-  sha256 = "139a5xii9fkywr1fq7z37wvs732w6j06005z6r7ycr99swrzpgvq";
+  version = "1.15.2.0";
+  sha256 = "1cca6nrdaia5dgq2ah6sfr9qy01iasilw7zdw6k8vp5907alsh0f";
   buildDepends = [
     aeson base64Bytestring binary dataDefault mtl network scientific
     text time unorderedContainers utf8String vector

pkgs/development/libraries/haskell/scientific/0.3.3.1.nix pkgs/development/libraries/haskell/scientific/0.3.3.2.nix

···
 
 cabal.mkDerivation (self: {
   pname = "scientific";
-  version = "0.3.3.1";
-  sha256 = "1p1g9cj827hb1zsn6zip7vgiwrw2vxfali6qvhccd6j1p12drw0b";
+  version = "0.3.3.2";
+  sha256 = "17lxxjfbmmlr0ppkrhw42lqhcg42nk21n5l2x9i6b87g8qr37jii";
   buildDepends = [ deepseq hashable text ];
   testDepends = [
     QuickCheck smallcheck tasty tastyAntXml tastyHunit tastyQuickcheck

pkgs/development/libraries/haskell/semigroups/default.nix

···
 
 cabal.mkDerivation (self: {
   pname = "semigroups";
-  version = "0.15.3";
-  sha256 = "0bzrab88vvgv3bnbcc7gyc05b9h9zz1pnc6bv2d2mpg653pm97k3";
+  version = "0.15.4";
+  sha256 = "17jr1wz44avcdws3pxh8jif9myylx7d1gwfv0paiq6yb6r089y68";
   buildDepends = [ deepseq hashable nats text unorderedContainers ];
   meta = {
     homepage = "http://github.com/ekmett/semigroups/";

pkgs/development/libraries/haskell/serialport/default.nix

···
   version = "0.4.7";
   sha256 = "1z2drw7ighyws72wqms015n5hy0zxbrphdca7ldn34pz28122z07";
   testDepends = [ HUnit ];
-  doCheck = false; # Test requires a connected Arduino...
+  doCheck = false;
   meta = {
     homepage = "https://github.com/jputcu/serialport";
     description = "Cross platform serial port library";

pkgs/development/libraries/haskell/snap/core.nix

···
     HUnit MonadCatchIOTransformers mtl random regexPosix text time
     unixCompat unorderedContainers vector zlibEnum
   ];
+  jailbreak = true;
   meta = {
     homepage = "http://snapframework.com/";
     description = "Snap: A Haskell Web Framework (core interfaces and types)";

pkgs/development/libraries/haskell/snap/server.nix

···
   ];
   configureFlags = "-fopenssl";
   patchPhase = ''
-    sed -i -e 's|HsOpenSSL >= .*|HsOpenSSL|' -e 's|network.*2.6,|network,|' snap-server.cabal
+    sed -i -e 's|text *>= .*,|text,|' -e 's|HsOpenSSL >= .*|HsOpenSSL|' -e 's|network.*2.6,|network,|' snap-server.cabal
   '';
   meta = {
     homepage = "http://snapframework.com/";

pkgs/development/libraries/haskell/snap/snap.nix

···
     snapCore snapServer stm syb text time transformers
     unorderedContainers vector vectorAlgorithms xmlhtml
   ];
-  jailbreak = true;
+  patchPhase = ''
+    sed -i -e 's|lens *>=.*|lens|' snap.cabal
+  '';
   meta = {
     homepage = "http://snapframework.com/";
     description = "Top-level package for the Snap Web Framework";

pkgs/development/libraries/haskell/snaplet-acid-state/default.nix

···
   version = "0.2.6.1";
   sha256 = "0wlawnsxisslqzspa29swsdmncgx04z3rd1bhwx73mx5pksykw60";
   buildDepends = [ acidState snap text ];
+  jailbreak = true;
   meta = {
     homepage = "https://github.com/mightybyte/snaplet-acid-state";
     description = "acid-state snaplet for Snap Framework";

pkgs/development/libraries/haskell/tasty/default.nix

···
 
 cabal.mkDerivation (self: {
   pname = "tasty";
-  version = "0.10.0.4";
-  sha256 = "028i567qmfkgriqs5y7vp6g5lz557cy5awhblcp6y2ya0aj78w5r";
+  version = "0.10.1";
+  sha256 = "1l8ah7018f3m8css56h59fcly1jhanm5wd0hbgm8mg6pn7rrjml5";
   buildDepends = [
     ansiTerminal async deepseq mtl optparseApplicative regexTdfaRc stm
     tagged time unboundedDelays

pkgs/development/libraries/haskell/text/1.2.0.0.nix

···
+# This file was auto-generated by cabal2nix. Please do NOT edit manually!
+
+{ cabal, deepseq, HUnit, QuickCheck, random, testFramework
+, testFrameworkHunit, testFrameworkQuickcheck2
+}:
+
+cabal.mkDerivation (self: {
+  pname = "text";
+  version = "1.2.0.0";
+  sha256 = "0c681yaqq68imj77qzy0j4iag8q90mhnnaalfwc08nzv8cr6c8z6";
+  buildDepends = [ deepseq ];
+  testDepends = [
+    deepseq HUnit QuickCheck random testFramework testFrameworkHunit
+    testFrameworkQuickcheck2
+  ];
+  doCheck = false;
+  meta = {
+    homepage = "https://github.com/bos/text";
+    description = "An efficient packed Unicode text type";
+    license = self.stdenv.lib.licenses.bsd3;
+    platforms = self.ghc.meta.platforms;
+  };
+})

pkgs/development/libraries/haskell/th-lift-instances/default.nix

···
   sha256 = "02sf7qn1rs33cdf1dl7vpwkhqzhmj8h3naw0ngh2kz05ymk2qng4";
   buildDepends = [ text thLift vector ];
   testDepends = [ doctest filepath QuickCheck text vector ];
+  jailbreak = true;
   meta = {
     homepage = "http://github.com/bennofs/th-lift-instances/";
     description = "Lift instances for template-haskell for common data types";

pkgs/development/libraries/haskell/th-orphans/default.nix

···
 # This file was auto-generated by cabal2nix. Please do NOT edit manually!
 
-{ cabal, thLift }:
+{ cabal, thLift, thReifyMany }:
 
 cabal.mkDerivation (self: {
   pname = "th-orphans";
-  version = "0.8.1";
-  sha256 = "1glf1zkiip18l0qdy3856ag7ksbxzd11dzdyq00qrz87kck5y58w";
-  buildDepends = [ thLift ];
+  version = "0.8.2";
+  sha256 = "19d4ls2plxmn5n9c99503mvi99ffp6y6zxi564zf6cdfgw8v73fy";
+  buildDepends = [ thLift thReifyMany ];
   jailbreak = true;
   meta = {
     description = "Orphan instances for TH datatypes";

pkgs/development/libraries/haskell/th-reify-many/default.nix

···
+# This file was auto-generated by cabal2nix. Please do NOT edit manually!
+
+{ cabal, mtl, safe, thExpandSyns }:
+
+cabal.mkDerivation (self: {
+  pname = "th-reify-many";
+  version = "0.1.2";
+  sha256 = "1r7ran4vi2mrhcr6qil89cni6ci3dgm775lfw5ciml3gz1948vz9";
+  buildDepends = [ mtl safe thExpandSyns ];
+  meta = {
+    homepage = "http://github.com/mgsloan/th-reify-many";
+    description = "Recurseively reify template haskell datatype info";
+    license = self.stdenv.lib.licenses.bsd3;
+    platforms = self.ghc.meta.platforms;
+  };
+})

pkgs/development/libraries/haskell/twitter-conduit/default.nix

···
     license = self.stdenv.lib.licenses.bsd3;
     platforms = self.ghc.meta.platforms;
     maintainers = with self.stdenv.lib.maintainers; [ ocharles ];
+    broken = true;
   };
 })

pkgs/development/libraries/haskell/uri-encode/default.nix

···
   isLibrary = true;
   isExecutable = true;
   buildDepends = [ networkUri text utf8String ];
+  jailbreak = true;
   meta = {
     description = "Unicode aware uri-encoding";
     license = "unknown";

pkgs/development/libraries/haskell/vcswrapper/default.nix

···
   isLibrary = true;
   isExecutable = true;
   buildDepends = [ filepath hxt mtl parsec split text ];
+  jailbreak = true;
   meta = {
     homepage = "https://github.com/forste/haskellVCSWrapper";
     description = "Wrapper for source code management systems";

pkgs/development/libraries/haskell/vty-ui/default.nix

···
 # This file was auto-generated by cabal2nix. Please do NOT edit manually!
 
-{ cabal, filepath, mtl, QuickCheck, random, regexBase, stm, text
-, time, vector, vty
+{ cabal, dataDefault, filepath, mtl, QuickCheck, random, regexBase
+, stm, text, time, vector, vty
 }:
 
 cabal.mkDerivation (self: {
   pname = "vty-ui";
-  version = "1.7.1";
-  sha256 = "1xgv2psbqcqpzgj1f1pis6hr7yvny8y9ajimllam7zsk6kbhngzz";
+  version = "1.8";
+  sha256 = "08jrcwml5g74mp4wy7kqp9jd5mfbxl04517v5354jiwn4dc77azm";
   isLibrary = true;
   isExecutable = true;
   buildDepends = [
-    filepath mtl QuickCheck random regexBase stm text time vector vty
+    dataDefault filepath mtl QuickCheck random regexBase stm text time
+    vector vty
   ];
   jailbreak = true;
   meta = {
···
     description = "An interactive terminal user interface library for Vty";
     license = self.stdenv.lib.licenses.bsd3;
     platforms = self.ghc.meta.platforms;
-    broken = true;
   };
 })

pkgs/development/libraries/haskell/vty/default.nix

···
 
 cabal.mkDerivation (self: {
   pname = "vty";
-  version = "5.2.4";
-  sha256 = "0dqp54sf6pl7magjhd91k87z50zi83x6w27kmyzp55112aiy7bf6";
+  version = "5.2.5";
+  sha256 = "15c49nzmkld4vcdmjbh0azlzsqrqmfb0z87zfixqxcl0bafpzrjy";
   isLibrary = true;
   isExecutable = true;
   buildDepends = [

pkgs/development/libraries/haskell/warp-tls/default.nix

···
 
 cabal.mkDerivation (self: {
   pname = "warp-tls";
-  version = "3.0.0.1";
-  sha256 = "054xazykd2njwrjzxkz08nqf7fghgjzc7rg7qbl5pfpn9b2a4pls";
+  version = "3.0.1";
+  sha256 = "0s87ricslidyg6m17q5mllpl47v0d8mvvd6psq4izz5l27dg2xpy";
   buildDepends = [
     cprngAes dataDefaultClass network streamingCommons tls wai warp
   ];

pkgs/development/libraries/haskell/wl-pprint-text/default.nix

···
   version = "1.1.0.2";
   sha256 = "0wbfqp38as2qpn66sq4hvl3hzvj66v301cz9rmgnx2i62r0a3s81";
   buildDepends = [ text ];
+  jailbreak = true;
   meta = {
     description = "A Wadler/Leijen Pretty Printer for Text values";
     license = self.stdenv.lib.licenses.bsd3;

pkgs/development/libraries/haskell/wreq/default.nix

···
     license = self.stdenv.lib.licenses.bsd3;
     platforms = self.ghc.meta.platforms;
     maintainers = with self.stdenv.lib.maintainers; [ ocharles ];
+    broken = true;
   };
 })

pkgs/development/libraries/haskell/wxHaskell/no-ldconfig.patch

···
+Only in wxc-0.91.0.0: dist
+diff -ubr wxc-0.91.0.0-orig/Setup.hs wxc-0.91.0.0/Setup.hs
+--- wxc-0.91.0.0-orig/Setup.hs	2014-10-31 13:30:15.514809137 +0100
++++ wxc-0.91.0.0/Setup.hs	2014-10-31 13:33:53.606372005 +0100
+@@ -507,5 +507,3 @@
+         inst_lib_dir = libdir $ absoluteInstallDirs pkg_descr local_bld_info NoCopyDest
+ 
+     installOrdinaryFile (verbosity flags) (bld_dir </> lib_name) (inst_lib_dir </> lib_name)
+-    ldconfig inst_lib_dir
+-

pkgs/development/libraries/haskell/wxHaskell/wx.nix

···
 
 cabal.mkDerivation (self: {
   pname = "wx";
-  version = "0.90.1.0";
-  sha256 = "1669mrd73c3v7c4yc0zgyqsnfgzb7561v1wd168y06d0db1nlkn9";
+  version = "0.91.0.0";
+  sha256 = "133cjc3vfqxyw71a5x99flzg23qa2k28p2zajw6vp0z7qhv8kfjy";
   buildDepends = [ stm wxcore ];
-  preConfigure = "find . -type f -exec touch {} +";
   meta = {
     homepage = "http://haskell.org/haskellwiki/WxHaskell";
     description = "wxHaskell";
     license = "unknown";
     platforms = self.ghc.meta.platforms;
-    maintainers = [ self.stdenv.lib.maintainers.andres ];
+    maintainers = with self.stdenv.lib.maintainers; [ andres ];
   };
 })

pkgs/development/libraries/haskell/wxHaskell/wxc.nix

···
 
 cabal.mkDerivation (self: {
   pname = "wxc";
-  version = "0.90.1.1";
-  sha256 = "0cvfphskvsq3lsl24h6jh8r6yw5jg8qa9wdc883yasfvmzmxwwgc";
+  version = "0.91.0.0";
+  sha256 = "0siab2h28dlyliznydxll22l9hdgwbmgddj01k1xw8hj4g7b53sa";
   buildDepends = [ wxdirect ];
   extraLibraries = [ libX11 mesa wxGTK ];
   noHaddock = true;
+  patches = [ ./no-ldconfig.patch ];
   postInstall = ''
     cp -v dist/build/libwxc.so.${self.version} $out/lib/libwxc.so
   '';
···
     description = "wxHaskell C++ wrapper";
     license = "unknown";
     platforms = self.ghc.meta.platforms;
-    maintainers = [ self.stdenv.lib.maintainers.andres ];
+    maintainers = with self.stdenv.lib.maintainers; [ andres ];
   };
 })

pkgs/development/libraries/haskell/wxHaskell/wxcore.nix

···
 
 cabal.mkDerivation (self: {
   pname = "wxcore";
-  version = "0.90.1.1";
-  sha256 = "1ma6vjf87b493vz3sj6hxzifqixk62n6b5gvixpfzfig1lysddgp";
+  version = "0.91.0.0";
+  sha256 = "01pvaysihyijklyw129vcafjqyh8bpafjzvscxvzll1g86qbqlkz";
   buildDepends = [ filepath parsec stm time wxc wxdirect ];
   extraLibraries = [ libX11 mesa wxGTK ];
-  patchPhase = ''
-    sed -i -e 's|array >= .*,|array,|' wxcore.cabal
-  '';
   meta = {
     homepage = "http://haskell.org/haskellwiki/WxHaskell";
     description = "wxHaskell core";
     license = "unknown";
     platforms = self.ghc.meta.platforms;
-    maintainers = [ self.stdenv.lib.maintainers.andres ];
+    maintainers = with self.stdenv.lib.maintainers; [ andres ];
   };
 })

pkgs/development/libraries/haskell/wxHaskell/wxdirect.nix

···
 
 cabal.mkDerivation (self: {
   pname = "wxdirect";
-  version = "0.90.1.1";
-  sha256 = "0ibhxl4n66w094jhca01z2vmibgz0nn7qddgxzqngvajzjvnha98";
+  version = "0.91.0.0";
+  sha256 = "17xlviyyagcvmc7m1f4djnsw0wdakirarmv12j4fmwbnfnbryp27";
   isLibrary = true;
   isExecutable = true;
   buildDepends = [ filepath parsec strict time ];

pkgs/development/libraries/haskell/xdot/default.nix

···
 
 cabal.mkDerivation (self: {
   pname = "xdot";
-  version = "0.2.4.5";
-  sha256 = "0dv9y5i3707pnx4c0gf9y3zv6p02az4rvspd84hprfvnhd8qfdcp";
+  version = "0.2.4.6";
+  sha256 = "123vygzkqlycc298zh3321y7w85xnynbavzqms6cb8zgzya42wrs";
   isLibrary = true;
   isExecutable = true;
   buildDepends = [ cairo graphviz gtk mtl polyparse text ];

pkgs/development/libraries/haskell/xml-html-conduit-lens/default.nix

···
   testDepends = [
     doctest hspec hspecExpectationsLens lens xmlConduit
   ];
+  jailbreak = true;
   meta = {
     homepage = "https://github.com/supki/xml-html-conduit-lens#readme";
     description = "Optics for xml-conduit and html-conduit";

pkgs/development/libraries/haskell/xml-lens/default.nix

···
 
 cabal.mkDerivation (self: {
   pname = "xml-lens";
-  version = "0.1.6.1";
-  sha256 = "093grvlpm19l3g10ka82xpzl2wr0gli71kfkbvk4gvg3194fkw4h";
+  version = "0.1.6.2";
+  sha256 = "14x3xz4rydl8x7ddznz90n3z5csy12c7l0r7bms8s7yqv4qzf6hz";
   buildDepends = [ lens text xmlConduit ];
   jailbreak = true;
   meta = {

pkgs/development/libraries/haskell/yesod-auth-hashdb/default.nix

···
 
 cabal.mkDerivation (self: {
   pname = "yesod-auth-hashdb";
-  version = "1.4.1";
-  sha256 = "11biiylg2366vymx37asr7ibw8migwnkf3nj6lx1i94ldvs9kfd4";
+  version = "1.4.1.1";
+  sha256 = "0bb37iawsdq3m5p1sjdnz954f3nfdmvvhm0hxap1z2hf9dk516ci";
   buildDepends = [
     cryptohash persistent pwstoreFast text yesodAuth yesodCore
     yesodForm yesodPersistent

pkgs/development/libraries/haskell/yi-language/default.nix

···
 
 cabal.mkDerivation (self: {
   pname = "yi-language";
-  version = "0.1.0.7";
-  sha256 = "1d6r5lvpngrhgyfam8hf675h9ylglhyzv11pabczbh8rz4jk40w1";
+  version = "0.1.0.8";
+  sha256 = "1lzn1yswrh72lqvc5xcna2xjv5zs3x1mzc1ijkqjl84nvqcabj60";
   buildDepends = [
     binary dataDefault derive hashable lens ooPrototypes pointedlist
     regexBase regexTdfa transformersBase unorderedContainers

pkgs/development/libraries/libfaketime/default.nix

···
+{ stdenv, fetchurl }:
+
+stdenv.mkDerivation rec {
+  name = "libfaketime-0.9.6";
+
+  src = fetchurl {
+    url = "http://www.code-wizards.com/projects/libfaketime/${name}.tar.gz";
+    sha256 = "1dw2lqsv2iqwxg51mdn25b4fjj3v357s0mc6ahxawqp210krg29s";
+  };
+
+  preBuild = ''
+    makeFlagsArray+=(PREFIX="$out" LIBDIRNAME=/lib)
+  '';
+
+  meta = with stdenv.lib; {
+    description = "Report faked system time to programs without having to change the system-wide time";
+    homepage = http://www.code-wizards.com/projects/libfaketime/;
+    license = licenses.gpl2;
+    platforms = platforms.all;
+    maintainers = [ maintainers.bjornfor ];
+  };
+}

pkgs/development/libraries/libmicrohttpd/default.nix

···
 {stdenv, fetchurl, curl, libgcrypt}:
 
 stdenv.mkDerivation rec {
-  name = "libmicrohttpd-0.9.37";
+  name = "libmicrohttpd-0.9.38";
 
   src = fetchurl {
     url = "mirror://gnu/libmicrohttpd/${name}.tar.gz";
-    sha256 = "1p3wnhr43v6vqdgl86r76298wjfxz2ihj9zh9kpz8l7va30br357";
+    sha256 = "08g7p4l0p2fsjj8ayl68zq1bqgrn0pck19bm8yd7k61whvfv9wld";
   };
 
   buildInputs = [ curl libgcrypt ];

pkgs/development/libraries/nlopt/default.nix

···
-{ fetchurl, stdenv
-, withOctave ? true, octave ? null}:
+{ fetchurl, stdenv, octave ? null }:
 
 stdenv.mkDerivation rec {
-  name = "nlopt-2.3";
+  name = "nlopt-2.4.2";
 
   src = fetchurl {
     url = "http://ab-initio.mit.edu/nlopt/${name}.tar.gz";
-    sha256 = "1iw2cjgypyqz779f47fz0nmifbrvk4zs4rxi1ibk36f4ly3wg6p6";
+    sha256 = "12cfkkhcdf4zmb6h7y6qvvdvqjs2xf9sjpa3rl3bq76px4yn76c0";
   };
 
-  buildInputs = stdenv.lib.optional withOctave octave;
+  buildInputs = [ octave ];
 
   configureFlags = "--with-cxx --enable-shared --with-pic --without-guile --without-python
   --without-matlab " +
-    stdenv.lib.optionalString withOctave ("--with-octave " +
+    stdenv.lib.optionalString (octave != null) ("--with-octave " +
         "M_INSTALL_DIR=$(out)/${octave.sitePath}/m " +
         "OCT_INSTALL_DIR=$(out)/${octave.sitePath}/oct ");
+
+  meta = {
+    homepage = "http://ab-initio.mit.edu/nlopt/";
+    description = "Free open-source library for nonlinear optimization";
+    license = stdenv.lib.licenses.lgpl21Plus;
+
+    hydraPlatforms = stdenv.lib.platforms.linux;
+    maintainers = [ stdenv.lib.maintainers.simons ];
+  };
+
 }

pkgs/development/libraries/postgis/default.nix

···
     name = "postgis-${version}";
 
     src = fetchurl {
-      url = "http://postgis.refractions.net/download/postgis-${fix.fixed.version}.tar.gz";
+      url = "http://download.osgeo.org/postgis/source/postgis-${fix.fixed.version}.tar.gz";
       inherit (fix.fixed) sha256;
     };
 
···
     sha256 = "0i6inyiwc5zgf5a4ssg0y774f8vn45zn5c38ccgnln9r6i54vc6k";
   });
 
-  v_1_5_1 = pgDerivationBase.merge ( fix : {
-    version = "1.5.1";
-    sha256 = "0nymvqqi6pp4nh4dcshzqm76x4sraf119jp7l27c2q1lygm6p6jr";
+  v_1_5_8 = pgDerivationBase.merge ( fix : {
+    version = "1.5.8";
+    sha256 = "016qn2hk3w8rg60rqn91l2nfk9zcsw0pv2s5rb1qhjw15ypgv5j8";
     sql_srcs = ["postgis.sql" "spatial_ref_sys.sql"];
   });
 

pkgs/development/ocaml-modules/camlimages/4.1.nix

···
+{stdenv, fetchurl, omake, ocaml, omake_rc1, libtiff, libjpeg, libpng, giflib, findlib, libXpm, freetype, graphicsmagick, ghostscript }:
+
+assert stdenv.lib.versionAtLeast (stdenv.lib.getVersion ocaml) "4.00";
+
+let
+  pname = "camlimages";
+  version = "4.1.2";
+in
+
+stdenv.mkDerivation {
+  name = "${pname}-${version}";
+
+  src = fetchurl {
+    url = "https://bitbucket.org/camlspotter/camlimages/get/${version}.tar.bz2";
+    sha256 = "1ppddhfknpirj1vilm5dxgyp82kf7ahpvjmh7z75a1fnaqv3kpki";
+  };
+
+  buildInputs = [ocaml omake_rc1 findlib graphicsmagick ghostscript ];
+
+  propagatedBuildInputs = [libtiff libjpeg libpng giflib freetype libXpm ];
+
+  createFindlibDestdir = true;
+
+  buildPhase = ''
+    omake
+  '';
+
+  installPhase = ''
+    omake install
+  '';
+
+  meta = with stdenv.lib; {
+    homepage = https://bitbucket.org/camlspotter/camlimages;
+    description = "OCaml image processing library";
+    license = licenses.lgpl2;
+    maintainers = [ maintainers.vbgl ];
+  };
+}

pkgs/development/ocaml-modules/ocaml-cairo2/default.nix

···
+{ stdenv, fetchurl, ocaml, findlib, pkgconfig, cairo, lablgtk, gtk,
+  enableGtkSupport ? true # Whether to compile with support for Gtk
+                          # integration (library file cairo2_gtk). Depends
+                          # on lablgtk and gtk.
+}:
+
+let
+  inherit (stdenv.lib) optionals;
+  pname = "ocaml-cairo2";
+  version = "0.4.6";
+in
+
+stdenv.mkDerivation {
+
+  name = "${pname}-${version}";
+
+  src = fetchurl {
+    url = "http://forge.ocamlcore.org/frs/download.php/1279/cairo2-0.4.6.tar.gz";
+    sha256 = "1lc1iv5yz49avbc0wbrw9nrx8dn0c35r7cykivjln1zc2fwscf7w";
+  };
+
+  buildInputs = [ ocaml findlib pkgconfig cairo ]
+                ++ optionals enableGtkSupport [ gtk ];
+
+  # lablgtk2 is marked as a propagated build input since loading the
+  # cairo.lablgtk2 package from the toplevel tries to load lablgtk2 as
+  # well.
+  propagatedBuildInputs = optionals enableGtkSupport [ lablgtk ];
+
+  createFindlibDestdir = true;
+
+  configurePhase = "ocaml setup.ml -configure --prefix $out"
+                 + (if enableGtkSupport then " --enable-lablgtk2"
+                                        else " --disable-lablgtk2");
+
+  buildPhase = "ocaml setup.ml -build";
+
+  installPhase = "ocaml setup.ml -install";
+
+  meta = with stdenv.lib; {
+    homepage = "http://forge.ocamlcore.org/projects/cairo";
+    description = "Binding to Cairo, a 2D Vector Graphics Library";
+    longDescription = ''
+      This is a binding to Cairo, a 2D graphics library with support for
+      multiple output devices. Currently supported output targets include
+      the X Window System, Quartz, Win32, image buffers, PostScript, PDF,
+      and SVG file output.
+    '';
+    license = licenses.lgpl3;
+    platforms = ocaml.meta.platforms;
+    maintainers = [ maintainers.jirkamarsik ];
+  };
+}

pkgs/development/r-modules/cran-packages.nix

···
 let self = _self // overrides; _self = with self; {
 
   RcppArmadillo = buildRPackage {
-    name = "RcppArmadillo-0.4.320.0";
+    name = "RcppArmadillo-0.4.500.0";
     src = fetchurl {
-      url = "mirror://cran/src/contrib/RcppArmadillo_0.4.320.0.tar.gz";
-      sha256 ="0cicjn63w9awr9cd5wj09s2rsr83j7rn45cnqlflgx5wmh512jwm";
+      url = "mirror://cran/src/contrib/RcppArmadillo_0.4.500.0.tar.gz";
+      sha256="1fi6wvs4f0sb1lxpimly1i3hl3pjzwgvh4izmb9v7wm12c068kka";
     };
     propagatedBuildInputs = [Rcpp];
     patchPhase = "patchShebangs configure";
     meta.hydraPlatforms = R.meta.hydraPlatforms;
   };
 
-  /* Needed to add one more entry to depends: */
-  dplyr = derive { name="dplyr"; version="0.2"; sha256="04kby4n2qvngfdmpqarhizavpy9mr99zpwfxpknqbnbpbya5px1q"; depends=[assertthat Rcpp magrittr Lahman hflights BH]; };
-  png = derive { name="png"; version="0.1-7"; sha256="0g2mcp55lvvpx4kd3mn225mpbxqcq73wy5qx8b4lyf04iybgysg2"; depends=[ pkgs.libpng ]; };
+  rJava = buildRPackage {
+    name = "rJava-0.9-6";
+    src = fetchurl {
+      url = "mirror://cran/src/contrib/rJava_0.9-6.tar.gz";
+      sha256 ="008g6s6rcb5lnz5y2a2rs4iq85a4nl522g714s1w1r153qcc0jz0";
+    };
+    propagatedBuildInputs = [pkgs.jdk pkgs.lzma pkgs.bzip2 pkgs.pcre pkgs.icu pkgs.libzip];
+    preConfigure = ''
+    export JAVA_CPPFLAGS=-I${pkgs.jdk}/include/
+    export JAVA_HOME=${pkgs.jdk}
+    '';
+    meta.hydraPlatforms = R.meta.hydraPlatforms;
+  };
 
   A3 = derive { name="A3"; version="0.9.2"; sha256="01s7znhph2mr3snpscci3y7nbcisa6kg6hy7im3742r6ah0z3jv7"; depends=[xtable pbapply]; };
   abc = derive { name="abc"; version="2.0"; sha256="0fs6hxyk95c61mn3p642xs3ib9wfjii2v9a74pf488iaywc1kd7d"; depends=[nnet quantreg MASS locfit]; };
···
   AcceptanceSampling = derive { name="AcceptanceSampling"; version="1.0-3"; sha256="1camxmvz8prkvpf3d3rc07bnfphakwdlickqlr4sgzrs4k27rr4f"; depends=[]; };
   ACCLMA = derive { name="ACCLMA"; version="1.0"; sha256="1na27sp18fq12gp6vxgqw1ffsz2yi1d8xvrxbrzx5g1kqxrayy0v"; depends=[]; };
   accrual = derive { name="accrual"; version="1.0"; sha256="0gw418i9nlrm7nkg6d4m2icd4a04a7avqfjj7nidhl6vy4nflg3k"; depends=[fgui SMPracticals]; };
-  accrued = derive { name="accrued"; version="1.1"; sha256="1xmrlllh535wdcx6bcwl9hh2ps3ms4rdgal0ziq444rw2phxr48i"; depends=[]; };
+  accrued = derive { name="accrued"; version="1.2"; sha256="0xkar6kpxf7sq36xqf6cvns2sp5qgqxqjb8hindp59gvlcd2r5a7"; depends=[]; };
   ACD = derive { name="ACD"; version="1.5.3"; sha256="1a67bi3hklq8nlc50r0qnyr4k7m9kpvijy8sqqpm54by5hsysfd6"; depends=[]; };
-  Ace = derive { name="Ace"; version="0.0.8"; sha256="0zjg6xwzd2lc555rviaq60rb1fq9vdf8cdazlf3c9m0i1pvz990i"; depends=[]; };
   acepack = derive { name="acepack"; version="1.3-3.3"; sha256="17xfxjflc79y15hnrks3wina5irrggrxb9al9h5q0x1c401ds843"; depends=[]; };
-  acer = derive { name="acer"; version="0.1.2"; sha256="17x7281m2wa6a1pcga3xarg3infw5vygr7z068h8pqm30ix34ky4"; depends=[Rcpp]; };
-  aCGH_Spline = derive { name="aCGH.Spline"; version="2.2"; sha256="1ll045qgwl1170a4x93vj1xrn197l5ds648qasxlpnsm1a6svwas"; depends=[rJava]; };
   acm4r = derive { name="acm4r"; version="1.0"; sha256="1wqzc35i1rshx0zlmas8y4qkkvy6h9r4i4apscjjv1xg2wjflzxa"; depends=[MASS]; };
   ACNE = derive { name="ACNE"; version="0.7.0"; sha256="137xp69adhggz1wxzm5r95vcphrlrqpxsrz0gny59isx4xr28aal"; depends=[aroma_affymetrix MASS R_methodsS3 R_oo R_utils matrixStats R_filesets]; };
   acopula = derive { name="acopula"; version="0.9.2"; sha256="1z8bs4abbfsdxfpbczdrf1ma84bmh7akwx2ki9070zavrhbf00cf"; depends=[]; };
···
   acss_data = derive { name="acss.data"; version="1.0"; sha256="09kl4179ipr8bq19g89xcdi1xxs397zcx5cvgp6viy8gn687ilgv"; depends=[]; };
   ACTCD = derive { name="ACTCD"; version="1.0-0"; sha256="0zn8f6l5vmn4w1lqjnpcxvfbr2fhwbhdjx4144h3bk71bk9raavl"; depends=[R_methodsS3]; };
   Actigraphy = derive { name="Actigraphy"; version="1.2"; sha256="02xxmzjqym46q0fzddmy29i8la9knrna3b46y8849nmbpqvmp3qn"; depends=[fda lattice SDMTools]; };
+  activity = derive { name="activity"; version="1.0"; sha256="1y1vy3kj9n21jvbyl3s5hllfkqp3z1rnn7701c5jxhay5dbdz3p2"; depends=[circular overlap pbapply]; };
   actuar = derive { name="actuar"; version="1.1-6"; sha256="0f0zvk4a3rni656jfml2nqb3h3amks3g4aczp8j2x01ywwmazqr9"; depends=[]; };
   ActuDistns = derive { name="ActuDistns"; version="3.0"; sha256="04rff9czcgac80clpv32a1dl0jbyvfsa7wqxyywgk99w672x50i2"; depends=[reliaR actuar hypergeo]; };
   ada = derive { name="ada"; version="2.0-3"; sha256="1c0nj9k628bcl4r8j0rmyp5f1igdjq6qhjxyif6575fvn2gdzmbw"; depends=[rpart]; };
   adabag = derive { name="adabag"; version="3.2"; sha256="1ijr5i5p8sf2cq7cgiwh0qk3c4wxagk6r06a2vrjy76d262m1060"; depends=[rpart mlbench caret]; };
   adagio = derive { name="adagio"; version="0.5.9"; sha256="1yp9w557advb7dzrdqwkffpdmhn6mk4879lrrjd0d6kv89fwz5yr"; depends=[]; };
-  AdapEnetClass = derive { name="AdapEnetClass"; version="1.0"; sha256="0m8wg515djdpkq5lv8nkcny9s2iq9ym092jd99nysazqw0qy6a8r"; depends=[imputeYn glmnet lars]; };
+  AdapEnetClass = derive { name="AdapEnetClass"; version="1.1"; sha256="0xx1528s1kl20ka8asjm91sawfnj0z2sw8gw9z7grc94ssfd80zc"; depends=[imputeYn glmnet lars quadprog]; };
+  adaptDA = derive { name="adaptDA"; version="1.0"; sha256="0nk7n628d30jz03a2rmpgzrwwd79rlpqvr6lwhilmkg1gblvz7r1"; depends=[MASS]; };
   AdaptFit = derive { name="AdaptFit"; version="0.2-2"; sha256="124lj1sq5cbp35z4ybkc7ci3fi6pgf8pc5k9mpqmyb6dj870q836"; depends=[SemiPar MASS nlme cluster]; };
   AdaptFitOS = derive { name="AdaptFitOS"; version="0.54"; sha256="0h9jfq9mk5wd6v6an40l3sk2adn6fcaks22bi8d9s7zr2ldpzrjq"; depends=[SemiPar nlme MASS mgcv]; };
   AdaptiveSparsity = derive { name="AdaptiveSparsity"; version="1.4"; sha256="1az7isvalf3kmdiycrfl6s9k9xqk22k1mc6rh8v0jmcz402qyq8z"; depends=[Rcpp]; };
   adaptivetau = derive { name="adaptivetau"; version="2.1"; sha256="0q8i9gxybv1xyyxvrppr00jmhg80n0iphwlsqjdp34dd0y8ksx4m"; depends=[]; };
   adaptMCMC = derive { name="adaptMCMC"; version="1.1"; sha256="1y1qxn3qm59nyy9ld5x30p452yam7b2fyl236b14xvpm8g3xx1fa"; depends=[coda Matrix]; };
-  adaptsmoFMRI = derive { name="adaptsmoFMRI"; version="1.1"; sha256="1h79gh1bd6s2xhwf4whh72wf2cz4di2p8dnlf6192mfg108qc6nw"; depends=[Matrix coda mvtnorm MCMCpack spatstat]; };
+  adaptsmoFMRI = derive { name="adaptsmoFMRI"; version="1.1"; sha256="1h79gh1bd6s2xhwf4whh72wf2cz4di2p8dnlf6192mfg108qc6nw"; depends=[Matrix coda mvtnorm MCMCpack]; };
   adaptTest = derive { name="adaptTest"; version="1.0"; sha256="08d7a5dlzhaj236jvaw3c91008l66vf5i4k5anhcs32a3j8yh2iv"; depends=[lattice]; };
   additivityTests = derive { name="additivityTests"; version="1.1-2"; sha256="0ijk91whhsb7nm1ax9wpfw9qgxfb1bvg2cq939m81gvk09kzrvgz"; depends=[]; };
+  addreg = derive { name="addreg"; version="1.2"; sha256="1xgf9q0z3prvchyba1vaai6ij72nzvj2dqyr6y2wzb96jfqv19kl"; depends=[combinat glm2]; };
+  ADDT = derive { name="ADDT"; version="1.0"; sha256="1jx7rxi0yfn34pf3cf9zpf434rapgn5qn2mn5rkq5lysr3kwdw91"; depends=[]; };
   ade4 = derive { name="ade4"; version="1.6-2"; sha256="0h136nhfqrapwscm3c7frlcynrfxb9x8gmd1s44gaa8m25rjgdqf"; depends=[]; };
   ade4TkGUI = derive { name="ade4TkGUI"; version="0.2-6"; sha256="010ggsxcmljh0cdba4lcfnsd9r49pwqs6kbw88syfn2qv65hh5kq"; depends=[ade4]; };
   adegenet = derive { name="adegenet"; version="1.4-2"; sha256="13fglxy40rnwi5hsmmvwlfcvfn8dybxyy3k5qhpml8jgpbl3fsdb"; depends=[ade4 MASS igraph ape shiny ggplot2]; };
···
   adlift = derive { name="adlift"; version="1.3-2"; sha256="0nzg16vhm5qg3xzczi3f6cynvp9ym2jsfrc4fdyxq7bwp9kry2i4"; depends=[EbayesThresh]; };
   ADM3 = derive { name="ADM3"; version="1.3"; sha256="1hg9wjdhckilqd13dr4cim4j6jsh2sdwm18i3pfmfdj8cyswm3h0"; depends=[]; };
   AdMit = derive { name="AdMit"; version="2.0.1"; sha256="0bqzq2pf5449qyr8ff5d3sq0lbsph29ppv6zzf1rbjz06sc5d6ff"; depends=[mvtnorm]; };
-  ads = derive { name="ads"; version="1.5-2.1"; sha256="1jwgk48qypg36v53kj7wy5rcz059p1qg8awm3nf7xngrb2zff6h3"; depends=[ade4 spatstat]; };
+  ads = derive { name="ads"; version="1.5-2.1"; sha256="1jwgk48qypg36v53kj7wy5rcz059p1qg8awm3nf7xngrb2zff6h3"; depends=[ade4]; };
+  adwave = derive { name="adwave"; version="1.0"; sha256="10cz870n3az7brmf2658g0jrc1x39c69vw37n99m8x6wxxp6ypn8"; depends=[waveslim]; };
   aemo = derive { name="aemo"; version="0.1.0"; sha256="1iik0rrqkkx9n1qb1pvq5iwxqmvs6vnx8z80hdzb5vqq0lvi1bsx"; depends=[dplyr stringr assertthat lubridate]; };
   AER = derive { name="AER"; version="1.2-2"; sha256="0ny9khzqxzx4npaqmknhpi3aldz11ipg71zw4skxphclamlsgp86"; depends=[car lmtest sandwich survival zoo Formula]; };
-  afex = derive { name="afex"; version="0.10-113"; sha256="19fr444dy50d6psfc84qqkc04fp792jb7nxrv5b29q8j1yznkqnq"; depends=[car lme4 pbkrtest reshape2 stringr coin Matrix]; };
+  afex = derive { name="afex"; version="0.11-131"; sha256="143696sz4z8l98smb74bbqcax1rdxcfmb2dwd9jp6iwx2i32c62r"; depends=[car lme4 reshape2 stringr coin Matrix pbkrtest]; };
   AFLPsim = derive { name="AFLPsim"; version="0.3-3"; sha256="1vknmd98v65118c093gqpfckcggnk4c8rn6bblsaclwmx0jdi78s"; depends=[adegenet introgress]; };
   aftgee = derive { name="aftgee"; version="0.4-3"; sha256="0r1fq3n28hfkdih6a2nyz5vy832fsxxs0fr2zlml6cikpbay8zqx"; depends=[MASS BB survival geepack]; };
   AGD = derive { name="AGD"; version="0.30"; sha256="175hsii3g8vx5ms552wnh1hcn3p6hgfggv1zi5gpwlsc0i875iag"; depends=[gamlss]; };
-  agop = derive { name="agop"; version="0.1-3"; sha256="02yc7n8avg69750cnc1prvp2fnz964sfc7vggxfyyqrig9q5ppyq"; depends=[Matrix igraph]; };
+  agop = derive { name="agop"; version="0.1-4"; sha256="1jwyl02z053rsdw9hryv1nyj9wlq310l51fghp1p0j51c159mlpx"; depends=[Matrix igraph]; };
   agRee = derive { name="agRee"; version="0.3-1"; sha256="1gqbhv44z1r9m54fmrg0frnzsgsp13v5ppmzpv28frz9d8x7sxx6"; depends=[miscF lme4 R2jags]; };
   Agreement = derive { name="Agreement"; version="0.8-1"; sha256="1g29rxr8xsr0dh2r6c6j2bqs0q6snz9wz0hrnb92cxj27ili55yq"; depends=[R2HTML]; };
-  agricolae = derive { name="agricolae"; version="1.2-0"; sha256="1r9x6skkim25qp50xzg3jmv8hibpnr5kig4dqaycc6xki49pps50"; depends=[]; };
+  agricolae = derive { name="agricolae"; version="1.2-1"; sha256="1vrc1bjqcp3xk8q41bl3kvjvaj58gw19dv7vwsxn9r6r99hlb3j1"; depends=[klaR MASS nlme cluster spdep]; };
   agridat = derive { name="agridat"; version="1.9"; sha256="0ip8ln0hxx2ax21hhrxnksvkzw6mfwhvxfgj7xph5insly3x9h88"; depends=[lattice reshape2]; };
-  agrmt = derive { name="agrmt"; version="1.31"; sha256="0s0av1fg9aswkyj1vzr6fng53r5cnkfb3x0n46zrkb1fgb5fwdgm"; depends=[]; };
+  agrmt = derive { name="agrmt"; version="1.35"; sha256="164wj1bnjasc6pscz29v478ap65hjm5whxs2g2x5adghcda698i5"; depends=[]; };
   AGSDest = derive { name="AGSDest"; version="2.1"; sha256="1l36x3sjb0732aic2y4yrvx64phii1xjfzr4nc3x9b2crr988n0g"; depends=[ldbounds]; };
   agsemisc = derive { name="agsemisc"; version="1.3-1"; sha256="1905q35jgjhghlawql43yh296kbpysp927x3hj750yshz5zayzyr"; depends=[lattice MASS]; };
   ahaz = derive { name="ahaz"; version="1.14"; sha256="1z7w5rxd5cya7kxhgxqvn72k87y33ginxra9g7j9wrfs5jgx6kvx"; depends=[survival Matrix]; };
-  AICcmodavg = derive { name="AICcmodavg"; version="2.00"; sha256="1k156yziqd376mkcyz94c76a3rpmf8afgxdy9rn3dgalxfkb0rx6"; depends=[]; };
+  AICcmodavg = derive { name="AICcmodavg"; version="2.0-1"; sha256="1rraxdmzhjwfi4sdcagksrbprszdbxswczb0s5glgmbh2kfd3654"; depends=[lattice MASS Matrix nlme unmarked VGAM]; };
   AID = derive { name="AID"; version="1.4"; sha256="1wj2jmqla0b2y9hrvl5i69bncdx1xjdd7if69j6dy1dnxv6clx1z"; depends=[MASS tseries nortest]; };
   aidar = derive { name="aidar"; version="1.0.0"; sha256="01vs14bz4k504q5lx65b60kyi7hgvjdmib8igiipjmg4snwh8hdk"; depends=[XML]; };
   AIM = derive { name="AIM"; version="1.01"; sha256="11lkfilxk265a7jkc1wq5xlgxa56xhg302f1q9xb7gmjnzdigb21"; depends=[survival survival]; };
···
   akmeans = derive { name="akmeans"; version="1.1"; sha256="1nqbxbx583n0h2zmpy002rlmr6j86j6bg76xj5c69brrh59dpyw1"; depends=[]; };
   alabama = derive { name="alabama"; version="2011.9-1"; sha256="05c1a8707akwy39n2gjg3ahdp9xdkl18a32wdchw60f0h4ixqfdi"; depends=[numDeriv]; };
   ALDqr = derive { name="ALDqr"; version="0.5"; sha256="0294d6cjfl5m63jhrv4rbh7npwrbmmw5101jz5bbwihhj94qcxp9"; depends=[HyperbolicDist]; };
-  aLFQ = derive { name="aLFQ"; version="1.3.1"; sha256="0i351xa5x3sn0li5qway0wjhifvf9jfjb7hxk5vw13gzn0cq9sd5"; depends=[data_table plyr caret seqinr]; };
-  AlgDesign = derive { name="AlgDesign"; version="1.1-7.2"; sha256="1c0hxg02dzjnns6awwsfaa5sc00x4zkc5jmsdz5vssjkliviwm9k"; depends=[]; };
+  aLFQ = derive { name="aLFQ"; version="1.3.2"; sha256="1963np2b2x7gbpgwcx0rqxd2psfdfmh72ap1y4p7f37ibjm8g45m"; depends=[data_table plyr caret seqinr lattice randomForest ROCR reshape2 protiq]; };
+  AlgDesign = derive { name="AlgDesign"; version="1.1-7.3"; sha256="0bl7mx4dnmkgs2x1fj7cqnrp7jx18mqwxyga0rzlniq12h8mc3fz"; depends=[]; };
   ALKr = derive { name="ALKr"; version="0.5.3.1"; sha256="09df3vx2q0sn8fwz2cc9lckzwrf2hgbglzyn376d6nkrm6gq792a"; depends=[MASS Rcpp]; };
   allan = derive { name="allan"; version="1.01"; sha256="02bv9d5ywbq67achfjifb3i7iiaaxa8r9x3qvpri2jl1cxnlf27m"; depends=[biglm]; };
   allanvar = derive { name="allanvar"; version="1.0"; sha256="0wpywdr15gb49m9kxrpjfsxlxrm4hwm46x42k8dgc6sihfsqbm22"; depends=[gplots]; };
   alleHap = derive { name="alleHap"; version="0.7.2"; sha256="1x10grrv732a0iidr2c96vbl46553njhvvlq249jxn3y11lfq2gv"; depends=[gtools]; };
-  allelematch = derive { name="allelematch"; version="2.03"; sha256="1dmalyljsmf7njr6fj8bcjii13swvh89dj3r1mp2xxf1r0p6jry8"; depends=[dynamicTreeCut]; };
+  allelematch = derive { name="allelematch"; version="2.5"; sha256="1kws6y3igq6l85cfjrck2dzcfpgr56ridbc6w071h8kjw19mlzas"; depends=[dynamicTreeCut]; };
   AlleleRetain = derive { name="AlleleRetain"; version="1.3.1"; sha256="1k2iwns1wk5n02cii6p9prgdb6asys3vwiq5dq2i26fk2xr6j4gq"; depends=[]; };
   allelic = derive { name="allelic"; version="0.1"; sha256="0xs4kd3vqb5ph8kqc3lcqgirrdkz8b627pvnczvci2g0sr3cl18j"; depends=[]; };
   AllPossibleSpellings = derive { name="AllPossibleSpellings"; version="1.1"; sha256="0ksfm2pfjka3yjgcd257v7sns1niaylsfxvhhh2jwdi016cpdw10"; depends=[]; };
-  alm = derive { name="alm"; version="0.1.9"; sha256="13i5f9b8bz6chdczlwfd3ka3mvn3i87jgpr2b6df03yc1vd9z25v"; depends=[ggplot2 RCurl plyr stringr reshape reshape2 httr RJSONIO lubridate]; };
+  alm = derive { name="alm"; version="0.3.1"; sha256="02k4jc1s7qc6l3h9s9w7714bh606593mvhsbqk5vm9ga3320m48k"; depends=[ggplot2 plyr stringr reshape reshape2 httr jsonlite lubridate]; };
   alphahull = derive { name="alphahull"; version="1.0"; sha256="0k3n9l4vbvpmdb4m37y1ynsiv27l8b5fmm6l35sazlfbbinhzwc1"; depends=[tripack sgeostat splancs]; };
   alphashape3d = derive { name="alphashape3d"; version="1.1"; sha256="1hfxvzqgirc587vxyggxdqii90nvypzi3wddvd2zdw2h95v9kfyg"; depends=[geometry rgl]; };
   alr3 = derive { name="alr3"; version="2.0.5"; sha256="0zrrsv2kjq3cky3bhk6gp32p1qpr1i5k2lx7c1w08bql0nb1x740"; depends=[car]; };
-  alr4 = derive { name="alr4"; version="1.0.3"; sha256="1m73b626fljfs96wvv1v627v48qilq5dyi5clqn8b4a5lyjjs2mg"; depends=[car effects]; };
+  alr4 = derive { name="alr4"; version="1.0.5"; sha256="0m8jgc4mfni17psf8m0avf0m364vcq5k3c9x807p98ch2z5nsygv"; depends=[car effects]; };
   ALS = derive { name="ALS"; version="0.0.5"; sha256="1ryviknpf7c0v20bmc40khhmx51b83hbh9q9iwz9d694by51xryc"; depends=[nnls Iso]; };
   ALSCPC = derive { name="ALSCPC"; version="1.0"; sha256="0ippxzq5qwb9dnpvm1kxhc0fxh83rs9ny5rcvd30w2bp632q9qdx"; depends=[]; };
   amap = derive { name="amap"; version="0.8-12"; sha256="0z7c5lrwqvjcnjm48zq2ifyx089fabvwf1zz17qlxq44i8xzpx8j"; depends=[]; };
···
   AmericanCallOpt = derive { name="AmericanCallOpt"; version="0.95"; sha256="1nhy44j5bmmjsp6g79nrn741rzzxikhdnxk4wwbdj9igcc1bs573"; depends=[]; };
   AMGET = derive { name="AMGET"; version="1.0"; sha256="18wdzzg5wr7akbd1iasa4mvmy44fb2n5gpghwcrx80knnicy3dxq"; depends=[]; };
   aml = derive { name="aml"; version="0.1-1"; sha256="09xxlxp784wlb561apns3j8f2h9pfk497cy5pk8wr4hhqqv4d3al"; depends=[lars]; };
-  AMOEBA = derive { name="AMOEBA"; version="1.0"; sha256="0iaznr19hdi40mkj82ai4r83b8whvvzmbiba0kwkp2g8g38a5brk"; depends=[snowfall rlecuyer spdep]; };
+  AMOEBA = derive { name="AMOEBA"; version="1.1"; sha256="1npzh3rpfnxd4r1pj1hm214sfgbw4wmq4ws093lnl7pvsl0q37xn"; depends=[snowfall rlecuyer spdep]; };
   AMORE = derive { name="AMORE"; version="0.2-15"; sha256="00zfqcsah2353mrhqkv8bbh24l8gaxk4y78icr9kxy4pqb2988yz"; depends=[]; };
   AmpliconDuo = derive { name="AmpliconDuo"; version="1.0"; sha256="0l6p5c2802a1f3b77cdrrk3wdf41926mh34630p462fb3wqipps0"; depends=[ggplot2 xtable]; };
-  anacor = derive { name="anacor"; version="1.0-4"; sha256="13f5cnna7vdimv4mxmjj21alxjzi1rk0hksajfy2m0b3yn2vl612"; depends=[rgl scatterplot3d fda colorspace car]; };
-  anaglyph = derive { name="anaglyph"; version="0.1-1"; sha256="1a9c7rl7r2sgl230mcwqnmxjqba8skycdhi09i834qaw2h9qd4k5"; depends=[]; };
-  analogue = derive { name="analogue"; version="0.12-0"; sha256="16bdrvhk4ivq43lfl7pncrwzjdsvwqj8d3j2krskmpdh9qc3sq65"; depends=[vegan lattice rgl mgcv MASS brglm princurve]; };
+  anacor = derive { name="anacor"; version="1.0-5"; sha256="1m2r5x5spb5nahd9cvnsxwqi0ay2kasmha21rbwj3r99jz1vxkql"; depends=[rgl car scatterplot3d colorspace fda]; };
+  analogue = derive { name="analogue"; version="0.14-0"; sha256="1a0qljcanhpnsjpllvhpwky1177nxx3gz46azxz2sw1vqg2qjfh2"; depends=[vegan mgcv MASS brglm princurve lattice]; };
   AnalyzeFMRI = derive { name="AnalyzeFMRI"; version="1.1-16"; sha256="1mbjb682ns5230jd3vcvd6x4gnn9hpbmjd7r8120y4sp2g733b0f"; depends=[R_matlab fastICA]; };
   anametrix = derive { name="anametrix"; version="1.6"; sha256="14xrrnvz7jn1jqds48l5pvzlx6hsaxrjc932lqnvv70sfypinjkm"; depends=[RCurl XML pastecs]; };
   anapuce = derive { name="anapuce"; version="2.2"; sha256="0qs27as628090k3sq5b14l90g7qdp23d0jz5lb1wxsgi3ji0f7qj"; depends=[]; };
-  AncestryMapper = derive { name="AncestryMapper"; version="1.1"; sha256="0nc9iacdgmdda9d9ga9mn0dvmv8d1571sblifqdrz35p5yl7fr0g"; depends=[]; };
   anchors = derive { name="anchors"; version="3.0-8"; sha256="12gd2526y7s2a8i6b9xma2c3sc6zxnwzl6sn8b50hbxizwr8d34j"; depends=[rgenoud MASS]; };
   AnDE = derive { name="AnDE"; version="1.0"; sha256="1yil8ab50wvlqmdla9kmfba8vfgy5r694r6igb58s6vnmld78yf2"; depends=[discretization functional foreign stringr]; };
   andrews = derive { name="andrews"; version="1.0"; sha256="130i86qkdy1xpcf611jpzqgmd17iik7j7spdcfwzk48f31biyp8v"; depends=[]; };
   anesrake = derive { name="anesrake"; version="0.70"; sha256="17127rmjfrdwnr2m6205cci3b0kd9girp82qranxwac4mgb7p7ld"; depends=[Hmisc]; };
-  Animal = derive { name="Animal"; version="1.04"; sha256="0hahvq1x81s0qmr58jv6q96jnc8lzn4ycljd8adhpgsx3wn8s7mq"; depends=[]; };
   animalTrack = derive { name="animalTrack"; version="1.0.0"; sha256="0jlvfflpaq64s48sblzh1n1vx8g3870iss97whigri29s6hn79ry"; depends=[rgl]; };
   animation = derive { name="animation"; version="2.3"; sha256="1hqgkaxmyyfrx7cfzv00010r9l2n8gxm35jd41p3kc208mhd7ssp"; depends=[]; };
   AnnotLists = derive { name="AnnotLists"; version="1.2"; sha256="1g2khb2ggniwg2zcjamsm3bxyrl2zabvk540b5vyy9am9k83m1g9"; depends=[]; };
-  anoint = derive { name="anoint"; version="1.3"; sha256="0hwvwd6ghxhkfymf124igski8l98k29pj3ahi5mflm8gv0qan92g"; depends=[survival glmnet MASS]; };
-  anominate = derive { name="anominate"; version="0.4"; sha256="00cqwlka33aqr3jks1fsxizwdlrfmv5w5bpnkzknhgz70l60h38n"; depends=[wnominate oc pscl MCMCpack]; };
+  anominate = derive { name="anominate"; version="0.5"; sha256="0qhq3ngxi1d3yln6bafg3c36a7whnznnww0101da2y0i6dw79lg5"; depends=[coda wnominate oc pscl MCMCpack]; };
   AnthropMMD = derive { name="AnthropMMD"; version="0.9.9"; sha256="10wn0fkcli5yz3fhngsz8sg1mfllqkvjrpjggd9qynay2zrpiw1n"; depends=[tcltk2]; };
-  Anthropometry = derive { name="Anthropometry"; version="1.0"; sha256="1cvq06hyxcgg95n21bi22csdgc6l6av78bvz7r7qdsl7wffddk0w"; depends=[shapes rgl archetypes nnls depth FNN ICGE cluster]; };
+  Anthropometry = derive { name="Anthropometry"; version="1.1"; sha256="1yqdps5n07jl05nv7136jwhfndn01vim2kx9s76mk4alvsw7s8ls"; depends=[shapes rgl archetypes nnls depth FNN ICGE cluster biclust]; };
   antitrust = derive { name="antitrust"; version="0.94"; sha256="1k768lmx5vv069bd9fzly1205rxr9mkqi1p8jjx67kwmyhhw5sd2"; depends=[MASS evd BB numDeriv ggplot2]; };
-  AntWeb = derive { name="AntWeb"; version="0.6.1"; sha256="1m4r7zx6mmxwdf1ldwmqad2lzc9kw150l0b3z2994nvcx36r4cj4"; depends=[rjson plyr assertthat httr leafletR]; };
+  AntWeb = derive { name="AntWeb"; version="0.7"; sha256="1ykfg3zzjdvjppr2l4f26lx00cn5vaqhhz1j1b5yh113ggyl40qw"; depends=[rjson plyr assertthat httr leafletR]; };
   aod = derive { name="aod"; version="1.3"; sha256="1a6xs5d5289w69xd2salsxwikjjhjzvsnplqrq78b1sr6kzfyxz3"; depends=[]; };
   aods3 = derive { name="aods3"; version="0.4-1"; sha256="074c16wmgd1vc2yvwx1y84bg55hvmm5yi8zgpwh51jcsbqlhbpgn"; depends=[lme4 boot]; };
   AOfamilies = derive { name="AOfamilies"; version="1.01"; sha256="0v3b83k12lsrdcrkjl2ff38d0g8sbrnm5pmm9xphyrk3lfgap76k"; depends=[lqmm quantreg]; };
-  aoristic = derive { name="aoristic"; version="0.5"; sha256="0hvq6qf5ib7x7c7jg9qbsglhazvbr5rkhfi1r43h4i2fhdvymhrn"; depends=[ggplot2 spatstat GISTools lubridate classInt reshape2 rgdal plotKML]; };
+  aoristic = derive { name="aoristic"; version="0.5"; sha256="0hvq6qf5ib7x7c7jg9qbsglhazvbr5rkhfi1r43h4i2fhdvymhrn"; depends=[ggplot2 GISTools lubridate classInt reshape2 rgdal plotKML]; };
+  apc = derive { name="apc"; version="1.0"; sha256="1fhw6cjcqcjwsjswhgm7rgwn3m3d9lkb9mk6cxh04jk3x2j9l3az"; depends=[]; };
   apcluster = derive { name="apcluster"; version="1.3.5"; sha256="1hckvir43s0jshn9kiwqmpsnav04lxv060l6xlf60a8yk5zf1cqs"; depends=[Rcpp]; };
   ape = derive { name="ape"; version="3.1-4"; sha256="04vkzbqjy89vs2n421ji2r4p60x5frjnlgpjp42k9n5x295hb89s"; depends=[nlme lattice]; };
-  aplpack = derive { name="aplpack"; version="1.2.9"; sha256="024q0vsimhr3cj4fz2x10hf7mm89psn8f04j013qas7wdsixkswk"; depends=[]; };
+  aplpack = derive { name="aplpack"; version="1.3.0"; sha256="0i6jy6aygkqk5gagngdw9h9l579lf0qkiy5v8scq5c015w000aaq"; depends=[]; };
   apmsWAPP = derive { name="apmsWAPP"; version="1.0"; sha256="1azgif06dsbadwlvv9nqs8vwixp6balrrbpj62khzmv1jvqr4072"; depends=[seqinr gtools]; };
   appell = derive { name="appell"; version="0.0-4"; sha256="0g7pzhxqgscnyf07xycbrpyimp1z1hljgcr3nqigpx09w7zi5wlw"; depends=[]; };
   apple = derive { name="apple"; version="0.3"; sha256="194z2f6hwdjjxdkjwlmfhpfp26p9yp3gparklhdbb6zlb4a9nnhz"; depends=[MASS]; };
···
   aqr = derive { name="aqr"; version="0.4"; sha256="04frgil3nbxsww66r9x0c6f308pzqr1970prp20bdv9qm3ym5axw"; depends=[xts RCurl]; };
   AquaEnv = derive { name="AquaEnv"; version="1.0-3"; sha256="1hkygw09w70im9f6l6q5yxk86mdl5pkczqfqrwc4wl1yhz7z1gjb"; depends=[minpack_lm deSolve]; };
   AR1seg = derive { name="AR1seg"; version="1.0"; sha256="0v9adx5wj9r4jwl3bqqmj0byiqfp585jz013qfqrq601wj8v4zi3"; depends=[Segmentor3IsBack]; };
-  ARAMIS = derive { name="ARAMIS"; version="1.0.1"; sha256="12bsn5lpb9cv0py1ymbqhbnjrpisf09yixpnqbazsmrz7lrin079"; depends=[MASS LearnBayes]; };
   archdata = derive { name="archdata"; version="0.1"; sha256="1k7cpqwgvkwfz25a9db0c8g6ii6xsbhkj3c9alghhaafs7x8n47w"; depends=[]; };
   archetypes = derive { name="archetypes"; version="2.2-0"; sha256="1djzlnl1pjb0ndgpfj905kf9kpgf9yizrcvh4i1p6f043qiy0axf"; depends=[modeltools nnls]; };
+  archivist = derive { name="archivist"; version="1.1"; sha256="1vqfpb1g8877zmnj12a1ariglq7w03xpqs63bj429rd9agg66pw2"; depends=[RSQLite DBI lubridate jsonlite RCurl digest httr]; };
   ArDec = derive { name="ArDec"; version="2.0"; sha256="14niggcq7xlvpdhxhy8j870gb11cpk4rwn9gwsfmcfvh49g58i80"; depends=[]; };
   arf3DS4 = derive { name="arf3DS4"; version="2.5-10"; sha256="12cbrk57c9m7fj1x7nfmcj1vp28wj0wymsjdz8ylxhm3jblbgmxc"; depends=[corpcor]; };
   arfima = derive { name="arfima"; version="1.2-6"; sha256="1xdcvfaaza3bn5p5yhafqh67018z260aqp9gwwnw1nrrmz7fsh2h"; depends=[ltsa]; };
   argosfilter = derive { name="argosfilter"; version="0.63"; sha256="0rrc2f28hla0azw90a5gk3zj72vxhm1b6yy8ani7r78yyfhgm9ig"; depends=[]; };
   argparse = derive { name="argparse"; version="1.0.1"; sha256="03p8dpwc26xz01lfbnmckcx6wzky43dyq71085b0anzsavgx0786"; depends=[proto findpython getopt rjson]; };
   argparser = derive { name="argparser"; version="0.1"; sha256="0x4wm8hjzb779pp39v8q210npg7kzh9m8wwqmd17aaqaa3l2al9f"; depends=[]; };
-  arm = derive { name="arm"; version="1.7-05"; sha256="1cpgbhp7pz1m9r40ia08hi2mdl87ar9m1h72cldvajq0imlckcrl"; depends=[MASS Matrix lme4 abind coda nlme]; };
+  arm = derive { name="arm"; version="1.7-07"; sha256="19xshr5r36g9jsyxdm0dihvga89fd080hbhmyhxv1rbv4496jwqa"; depends=[MASS Matrix lme4 abind coda nlme]; };
   arnie = derive { name="arnie"; version="0.1.2"; sha256="14xkgyfn9zvkbgram15w7qzqc5pl1a8ig66cif7a79najrgd914r"; depends=[]; };
   aroma_affymetrix = derive { name="aroma.affymetrix"; version="2.12.0"; sha256="1r3ywi97xqvk6dif7kkc3gqapiydd2sbq0ibxs1qf6s2v236d71r"; depends=[R_utils aroma_core R_methodsS3 R_oo R_cache R_filesets aroma_apd MASS matrixStats]; };
   aroma_apd = derive { name="aroma.apd"; version="0.5.0"; sha256="1pi4k7psrc120r8mn352vg60mjvbnm1f56dm9svfxfyl0qhcfd00"; depends=[R_methodsS3 R_oo R_utils R_huge]; };
···
   ArrayBin = derive { name="ArrayBin"; version="0.2"; sha256="0jlhcv2d7pmqi32w71nz063ri1yj4i4isr3msnw7ckzvi9r42jwm"; depends=[]; };
   arrayhelpers = derive { name="arrayhelpers"; version="0.76-20120816"; sha256="1q80dykcbqbcigv2f9xg1brfm3835i0zvs0810q6kh682a3hpqbi"; depends=[]; };
   ars = derive { name="ars"; version="0.4"; sha256="0ynciw8n2jpqi40gsrj189419vgr1lgs9wridh09nj7n451b4kvg"; depends=[]; };
-  ARTIVA = derive { name="ARTIVA"; version="1.2.2"; sha256="1k51yfh2xxchbiq9b64llc3sp330kh30lai75fgnbycwynkpsk5m"; depends=[MASS igraph gplots]; };
   ARTP = derive { name="ARTP"; version="2.0.4"; sha256="1f6ay9lyaqsc33b0larb8v6imp5adaycya84wif2sg32rv4gx3yl"; depends=[]; };
-  arules = derive { name="arules"; version="1.1-4"; sha256="0i2s706rm6bbzqxb0vfqq14m9zr4djyjjkvsqgrqbsvwgp8i29zk"; depends=[Matrix]; };
+  arules = derive { name="arules"; version="1.1-5"; sha256="0hi3ni9qwrw8abvnvdd77xn9vr4gzfj4fabm2j60zi679zz84ck2"; depends=[Matrix]; };
   arulesNBMiner = derive { name="arulesNBMiner"; version="0.1-4"; sha256="05vj7pzzh84xr6d0m16dhzr7bw50hkiyq99vl46zinak648my338"; depends=[arules rJava]; };
   arulesSequences = derive { name="arulesSequences"; version="0.2-6"; sha256="1fvph6c8dy3hj0h63h85bzzzka8dx0cc0lcncz9svyahy1j4q3z0"; depends=[arules]; };
   arulesViz = derive { name="arulesViz"; version="0.1-9"; sha256="1s1hsf64fg32r3p1h8bvzbpr7a28szdh9hs7ck9qykh2s93xh12z"; depends=[arules scatterplot3d vcd seriation igraph]; };
-  asbio = derive { name="asbio"; version="1.0-5"; sha256="1wvg8j9hlla9z9di4qinmkn9d8wmindiqxa3jgdqx6srlwdx1b09"; depends=[scatterplot3d pixmap tkrplot plotrix mvtnorm deSolve lattice]; };
+  aRxiv = derive { name="aRxiv"; version="0.5.2"; sha256="0gaqwrkzkb22295nymmcccbr1l8qvhnhpmfkgs9bfk3qbkjkdb5y"; depends=[httr XML]; };
+  asbio = derive { name="asbio"; version="1.1-1"; sha256="13iz795jiplx677y24pwx5ggxbz0b8x7g8khmvvbl05h2rab3pw8"; depends=[scatterplot3d pixmap tkrplot plotrix mvtnorm deSolve lattice multcompView]; };
   ascii = derive { name="ascii"; version="2.1"; sha256="19dfbp7k4bjxjn8wdzhbmz7g3za6gn8vcnd5qkm4dz7gg1fg7b8p"; depends=[]; };
   ascrda = derive { name="ascrda"; version="1.15"; sha256="17anzlhcjmrk13s5gs752rsc735y5wvba6r3w1nbv0cnkpnyk8i7"; depends=[class nnet rda MASS sfsmisc e1071 pamr]; };
   asd = derive { name="asd"; version="2.0"; sha256="1nnsbh6g0bhvhp6644zf2l6frr3qnls0s7y7r0g211b5zagq20z3"; depends=[mvtnorm]; };
   ash = derive { name="ash"; version="1.0-14"; sha256="15x16ld25i160asqf4z4difa6zn2yfgl04j8y8nqb0djymdx7a1f"; depends=[]; };
+  ASMap = derive { name="ASMap"; version="0.3-2"; sha256="0rmf12lhzgi301mnf7iy98zq6ggdalwr45lgrw09n9qzb3jf4dp5"; depends=[qtl gtools fields lattice]; };
   aspace = derive { name="aspace"; version="3.2"; sha256="1g51mrzb6amafky2kg2mx63g6n327f505ndhna6s488xlsr1sl49"; depends=[splancs Hmisc shapefiles]; };
   aspect = derive { name="aspect"; version="1.0-2"; sha256="1p06vglsj2z0qal3sacjfm6cr9vb3jidk1c1rsmwy4cfv7dzh58n"; depends=[]; };
   assertive = derive { name="assertive"; version="0.1-8"; sha256="0j1phpx2w34rdjaar3fqhp0rsvdlidvw2irfazbh9955mdn2cwq1"; depends=[]; };
···
   AssotesteR = derive { name="AssotesteR"; version="0.1-10"; sha256="0aysilg79vprcyjirqz6c5s1ry1ia92xik3l38qrw1gf3vfli9cw"; depends=[mvtnorm]; };
   aster = derive { name="aster"; version="0.8-30"; sha256="0vdlimkkmd9ar5v3xrbi9gshvj980l7641brd7cqs78sqf0v71fn"; depends=[trust]; };
   aster2 = derive { name="aster2"; version="0.1"; sha256="1qbh1l2cnhvdfxaw1bv8cpj96nv03g155b1xh1vdigniwc04mssw"; depends=[]; };
-  astro = derive { name="astro"; version="1.1"; sha256="15xxa3ynlgk6dhlb1z9lwvf9jqvfw9ghkl7rjbdcrvc52b92nwd3"; depends=[MASS plotrix]; };
+  astro = derive { name="astro"; version="1.2"; sha256="1c7zrycgj2n8gz50m94ys1dspilds91s1b2pwaq6df1va17pznby"; depends=[MASS plotrix]; };
   astrochron = derive { name="astrochron"; version="0.3.1"; sha256="0anm8k31kgvbdkzid2f9mg7ivdrihwb6g1i82jqpljbwvmkp0fmw"; depends=[baseline multitaper fields]; };
+  astrodatR = derive { name="astrodatR"; version="0.1"; sha256="00689px4znwmlp6qbj6z2a51b7ylx1yrrjpv6zjkvrwpv6lyj9fw"; depends=[]; };
   astroFns = derive { name="astroFns"; version="4.1-0"; sha256="0g5q0y067xf1ah91b4lg8mr9imj0d6lgig7gbj3b69fn335k363g"; depends=[]; };
   astrolibR = derive { name="astrolibR"; version="0.1"; sha256="0gkgry5aiz29grp9vdq9zgg6ss47ql08nwcmz1pfvd0g0h9h75l8"; depends=[]; };
-  astsa = derive { name="astsa"; version="1.2"; sha256="13nlk5m5j9rygjih2hd3nj5iyncm1cx4smcj9zpr6nrsc79brwzj"; depends=[]; };
+  astsa = derive { name="astsa"; version="1.3"; sha256="01bslr6hww029097244r5l4bz4v7z46gpihw39har8h0xicl6ywk"; depends=[]; };
   asympTest = derive { name="asympTest"; version="0.1.3"; sha256="11nlkgws3y8xbz3yli55414a2rkk7367q9q5r2ssa61jaiimibhh"; depends=[]; };
   asypow = derive { name="asypow"; version="2013.9-1"; sha256="0zd42ha30kysjhd6rwxr91k1hhsimw3py2inymbpxgyq4s890whs"; depends=[]; };
   AtelieR = derive { name="AtelieR"; version="0.24"; sha256="0yialpmbsbx70gvps4r58xg9wvqcril8j8yd61lkkmz4b3195zai"; depends=[proto cairoDevice gWidgetsRGtk2 partitions]; };
+  atmcmc = derive { name="atmcmc"; version="1.0"; sha256="05k69b5wlysz3kh0yiqvshgvr0nyz34zkvn6bjs30cwz7s9j21pn"; depends=[]; };
   ATmet = derive { name="ATmet"; version="1.2"; sha256="047ibxxf5si45zw22zy8a1kpj36q0pd3bsmxwvn0dhf4h65ah0zz"; depends=[DiceDesign lhs metRology msm sensitivity]; };
   AtmRay = derive { name="AtmRay"; version="1.31"; sha256="162078jd032i72sgaar9hqcnn1lh60ajcqpsz4l5ysxfkghcxlh8"; depends=[]; };
-  attfad = derive { name="attfad"; version="1.1"; sha256="10vdb60i8iigslcd0f3ipkf7m3d7h8zhq9x0n7yilc1xpd79r3ha"; depends=[]; };
   AUC = derive { name="AUC"; version="0.3.0"; sha256="0ripcib2qz0m7rgr1kiz68nx8f6p408l1ww7j78ljqik7p3g41g7"; depends=[]; };
   AUCRF = derive { name="AUCRF"; version="1.1"; sha256="00d7jcg2dyvf7sc9w7vxxd85m7nsbcmfqsavrv236vxfpfc9yn7i"; depends=[randomForest]; };
   audio = derive { name="audio"; version="0.1-5"; sha256="1hv4052n2r6jkzkilhkfsk4dj1xhbgk4bhba2ca9nf8ag92jkqml"; depends=[]; };
   audiolyzR = derive { name="audiolyzR"; version="0.4-9"; sha256="09jsrjy15vcn6da0kgk06ghayyrf3s853gqv8qdawg745ky2hbgi"; depends=[hexbin RJSONIO plotrix]; };
   audit = derive { name="audit"; version="0.1-1"; sha256="0hrcdcwda5c0snskrychiyfjcbnymkcl2x43bapb6inw9y8989qv"; depends=[]; };
+  audited = derive { name="audited"; version="1.9"; sha256="0waybwh1vzkdhpr20pylyml1cd8b34hp43qpwyyzga6s73swxb1f"; depends=[igraph metrumrg]; };
   autoencoder = derive { name="autoencoder"; version="1.0"; sha256="18i6b2vjhlq9f82syw3k88gm9bvklv827nflgzq0xzjnzh6z5nr8"; depends=[]; };
   automap = derive { name="automap"; version="1.0-14"; sha256="1190kbmp0x80x0hyifdbblb4ijq79kvrfn9rkp5k6diig4v30n0w"; depends=[sp gstat lattice reshape]; };
   autopls = derive { name="autopls"; version="1.2-7"; sha256="173i1g11waz72myclfdch9v3wsvdr9mdz2gxdqifq9wj50s4zrg4"; depends=[pls]; };
-  AutoSEARCH = derive { name="AutoSEARCH"; version="1.2"; sha256="1zl5zd96249y2zfpidpl9n3zwcp74kvcxn4s10v0lypvr19cr3hn"; depends=[zoo]; };
+  AutoSEARCH = derive { name="AutoSEARCH"; version="1.3"; sha256="1wwrki8gshz4sn22a62pv5rzl1ziva930ci1ygb77bzc9wd65ka1"; depends=[zoo gets lgarch]; };
   avgrankoverlap = derive { name="avgrankoverlap"; version="1.0"; sha256="1wyafcygwdk754wp25283nd84lnn9qxha41xij55ylrn4nvg57l1"; depends=[]; };
   aws = derive { name="aws"; version="1.9-4"; sha256="11vbsg4yhnl4995m8gq5gykrlk61y3a618g2zxkc9wdf5z4xqdny"; depends=[awsMethods gsl]; };
   awsMethods = derive { name="awsMethods"; version="1.0-3"; sha256="1r6rbrlc5wbljp2x9aqhhnjblnb3gjm217x0cbmrw1pa0cf7q5jq"; depends=[]; };
···
   bagRboostR = derive { name="bagRboostR"; version="0.0.2"; sha256="1k9w98p3ad3myzyqhcrc4rsn7196qvhnmk5ddx3fpd1rdvy2dnby"; depends=[randomForest]; };
   BalancedSampling = derive { name="BalancedSampling"; version="1.4"; sha256="0l8jxszd0j27kb58xrn7lvf52mhifqjd1w42cp4kdiax8c6s7421"; depends=[Rcpp]; };
   BaM = derive { name="BaM"; version="0.99"; sha256="1q04va2s876ydlmaalx63r520pfx1qzpjg6hbnl9pvn86b5grnf4"; depends=[bayesm coda MASS mice survival foreign nnet]; };
+  bamboo = derive { name="bamboo"; version="0.9.5"; sha256="03aqrwgr77n2kzfnc5scv6n6d4401q9ddnzlki7d6rblilfb2w12"; depends=[rJava jvmr]; };
   bamdit = derive { name="bamdit"; version="1.1-1"; sha256="0f865yfwd2pvbkcx8jm4iyilldmprsgyqnscp1n28rp3sbdii4bl"; depends=[coda rjags]; };
   BAMMtools = derive { name="BAMMtools"; version="2.0.2"; sha256="10z638f79j3jksb69sqrnkzs5nzxi9srsxww4ky3bk21zb66ikhd"; depends=[ape]; };
   bams = derive { name="bams"; version="1.6"; sha256="1pplnpilpydxf7gcs87424cajss74q8cr9pyv2biy4pkvfql0nxl"; depends=[]; };
···
   BANOVA = derive { name="BANOVA"; version="0.2"; sha256="1zgn9wxh4c89rris58hhj5fh37mmy8wjvligr02id7a1pcw177m3"; depends=[rjags runjags coda]; };
   barcode = derive { name="barcode"; version="1.1"; sha256="14zh714cwgq80zspvhw88cs5b82gvz4b6yfbshj9b7x0y2961nxd"; depends=[lattice]; };
   bark = derive { name="bark"; version="0.1-0"; sha256="00sgwr1sfbx0gb2ssbnmbz90mwb40sk3s24asj7lhadwgm150nly"; depends=[]; };
-  Barnard = derive { name="Barnard"; version="1.3"; sha256="1kyc6rph0c9lxv6mkdl5n11xw1pvavlm2kknplb3sv6f94ss2yci"; depends=[]; };
-  bartMachine = derive { name="bartMachine"; version="1.0.2"; sha256="1mxl8yra44ypxchqlyfv950gac1m8mw85qqaifzylm7fqb12xr8s"; depends=[rJava car randomForest missForest]; };
+  bartMachine = derive { name="bartMachine"; version="1.0.4"; sha256="0j1yfwpxxins9hgmzbj5z24vbad62hmpbdz2gasfxdpdl78v1xav"; depends=[rJava car randomForest missForest]; };
   BAS = derive { name="BAS"; version="1.0"; sha256="1j5crafky3jb25kim3b7gxg9azn3ya357ckq1v7wryzi3zi674sg"; depends=[MASS]; };
-  BaSAR = derive { name="BaSAR"; version="1.3"; sha256="0n18gjgnqdmwdna6b5r664rw2svjqlpis95vchnlk19cr3pjvqc1"; depends=[polynom orthopolynom]; };
   base64 = derive { name="base64"; version="1.1"; sha256="1wn3zj1qlgybzid4nr6hvlyqg1rp2dwfh88vxrfby2fy2ba1nl5x"; depends=[]; };
   base64enc = derive { name="base64enc"; version="0.1-2"; sha256="0d2b7vl08abssfwprfiqc0yscb1gz4xlzlwwbf7y9z19wbyxizh5"; depends=[]; };
   baseline = derive { name="baseline"; version="1.1-3"; sha256="1n3g1ads26nq3y31nniirac453pdshzkdfg774w46x83cc5pc0xj"; depends=[SparseM]; };
-  basicspace = derive { name="basicspace"; version="0.07"; sha256="0lpj03a5cwrj0pag6hb29rfi8dw51hqx7rrc4r00lsbqf5picin2"; depends=[]; };
   BASIX = derive { name="BASIX"; version="1.1"; sha256="18dkvv1iwskfnlpl6xridcgqpalbbpm2616mvc3hfrc0b26v01id"; depends=[]; };
   BaSTA = derive { name="BaSTA"; version="1.9.3"; sha256="1jfki5lnsvd6fjrld2qp179lyzli61pi2308lkkl1h6vgp11zp2v"; depends=[msm]; };
+  BAT = derive { name="BAT"; version="1.0.1"; sha256="1kljrw2nc6xnqz4ryv4w8zfy17l3r7bsql921ixqa2rlp3jczyl4"; depends=[vegan]; };
   batade = derive { name="batade"; version="0.1"; sha256="1lr0j20iydh15l6gbn471vzbwh29n58dlpv9bcx1mnsqqnsgpmal"; depends=[hwriter]; };
   batch = derive { name="batch"; version="1.1-4"; sha256="03v8a1hsjs6nfgmhdsv6fhy3af2vahc67wsk71wrvdxwslmn669q"; depends=[]; };
-  BatchExperiments = derive { name="BatchExperiments"; version="1.2"; sha256="0kvn8vaxzdvzfx05639v3jbrxvwrr9rr8zssw62pdr77h7j9a3gf"; depends=[BatchJobs checkmate BBmisc DBI RSQLite plyr]; };
-  BatchJobs = derive { name="BatchJobs"; version="1.3"; sha256="1vcncmy7zzri93gh9gfbz8dz4agz2nkhv1bddzddx27b2sqjq4dn"; depends=[BBmisc checkmate digest DBI RSQLite sendmailR brew stringr fail]; };
+  BatchExperiments = derive { name="BatchExperiments"; version="1.4"; sha256="1px1id2jd34vknlygljqd3cwq6bwch8jfb2npq59cvvwlxxx4qpc"; depends=[BatchJobs checkmate BBmisc DBI RSQLite plyr]; };
+  BatchJobs = derive { name="BatchJobs"; version="1.5"; sha256="1aa41rlj0n0mw03kb5n645shfrm18y5snpmlm5hm6fmlvrykqn4p"; depends=[BBmisc brew checkmate DBI digest fail RSQLite sendmailR stringr]; };
   batchmeans = derive { name="batchmeans"; version="1.0-1"; sha256="06p51ipc603zqkf7ifv495jxbnqqxzx5h8mnz5l5sz9rq5pixg13"; depends=[]; };
   BayesBridge = derive { name="BayesBridge"; version="0.5"; sha256="1czyna2mrznlr5swvm9i7x99yfwjvwbzy42avh6xb0342q5glnhw"; depends=[]; };
   bayesclust = derive { name="bayesclust"; version="3.1"; sha256="0zxjd64nz8c6vg6jwb2xh6kbw41a2pcmlwq5cl6k2kbplqbm2jdf"; depends=[]; };
···
   BayesCR = derive { name="BayesCR"; version="1.0"; sha256="0cq1ii01j0nprnyvfxml1nrajrbb9yanr4fa5fcwn764cq5s30n9"; depends=[MCMCpack mvtnorm Rlab truncdist truncnorm]; };
   BayesDA = derive { name="BayesDA"; version="2012.04-1"; sha256="0fp27cmhw8dsxr4mc1flm6qh907476kph8ch2889g9p31xm1psjc"; depends=[]; };
   bayesDem = derive { name="bayesDem"; version="2.4-1"; sha256="0s2dhy8c90smvaxcng6ixhjm7kvwwz2c4lgplynrggrm8rfb19ay"; depends=[gWidgets gWidgetsRGtk2 bayesTFR bayesLife bayesPop RGtk2 wpp2012]; };
-  BayesFactor = derive { name="BayesFactor"; version="0.9.7"; sha256="02bqsvxsxkyhxm0llwnscsp204ffjygdk9xraml1l2fkz3cg62vl"; depends=[coda pbapply mvtnorm stringr]; };
+  BayesFactor = derive { name="BayesFactor"; version="0.9.9"; sha256="1a34caxsmixvriw7hwqsqxbkjg70lv0s81m2i5w5kybfk81xdvnh"; depends=[coda pbapply mvtnorm stringr Rcpp gtools]; };
   bayesGARCH = derive { name="bayesGARCH"; version="2.0.1"; sha256="1gz18wjikkg3yf71b1g21cx918dyz89f5m295iv8ah807cdx7vjk"; depends=[mvtnorm coda]; };
   bayesGDS = derive { name="bayesGDS"; version="0.6.0"; sha256="17ihpsh7lqjninprfwbx3v2415s27qybr5c2z4ls43slv8zrv8mz"; depends=[Matrix]; };
   BayesGESM = derive { name="BayesGESM"; version="1.0"; sha256="1ssg4l86jfriq4izlgzypz37c7xzcfsr6ngh8ksak8ka1lmidsig"; depends=[truncdist GIGrvg normalp gsl]; };
···
   bayesMCClust = derive { name="bayesMCClust"; version="1.0"; sha256="14cyvcyx3nmkbvsy7n4xjp7zvcgdhy013dv9d72y8j5dvlv82pb4"; depends=[gplots xtable mnormt MASS bayesm boa e1071 gtools]; };
   BayesMed = derive { name="BayesMed"; version="1.0"; sha256="1ppl5g8c5yy8jzhm34wvvprn9dj697ihcg8jb5111qmjybzzp0dh"; depends=[R2jags QRM polspline MCMCpack]; };
   bayesmix = derive { name="bayesmix"; version="0.7-3"; sha256="142132aslmmm35yai4n1d2hqqkczvrnm8ln9gwxvbczmxaggnc01"; depends=[rjags coda]; };
-  BayesNetDiscovery = derive { name="BayesNetDiscovery"; version="0.1"; sha256="1p3mxl75ds75snqim59w9xvr7f4a1mbks2k05zd9wwwy4w7v74l7"; depends=[DPpackage igraph mclust pscl tmvtnorm]; };
+  BayesMixSurv = derive { name="BayesMixSurv"; version="0.9"; sha256="0hqkqpzk21d2zh7pyn042w1s51wyszkmam0rwzgy0i9i51zjxwvz"; depends=[survival]; };
   BayesNI = derive { name="BayesNI"; version="0.1"; sha256="0zvr6rkb5zxgl53xby69d0j3yrfnlcmac6kwkxz77q5616w9dwq0"; depends=[]; };
   BayesPen = derive { name="BayesPen"; version="1.0"; sha256="1c31n0mrx07j9mw4afdh1qznkiq2jrig3ldpsnhkv2nd2apgjbbp"; depends=[lars MCMCpack SuppDists]; };
-  bayesPop = derive { name="bayesPop"; version="5.0-0"; sha256="0a577jkm0v88q2i7dmn2xqndm9z5y3hwfxr4a5d65cnrlsahfzdl"; depends=[bayesTFR bayesLife abind plyr wpp2012]; };
+  bayesPop = derive { name="bayesPop"; version="5.1-5"; sha256="1hmkkbrhy92qlwsml81fjdk7axmr3yfq6in3pk0l6sfq33y43hlc"; depends=[bayesTFR bayesLife abind plyr wpp2012]; };
   bayespref = derive { name="bayespref"; version="1.0"; sha256="0gwlzs7qkgmf90np7xv85d27jjqggyhfj00vpya664a2znyjb3jm"; depends=[coda lattice MASS MCMCpack RColorBrewer]; };
   bayesQR = derive { name="bayesQR"; version="2.2"; sha256="0w5fg7hdwpgs2dg4vzcdsm60wkxgjxhcssw9jzig5qgdjdkm07nm"; depends=[]; };
   bayess = derive { name="bayess"; version="1.4"; sha256="0axipk5hn2hw3g4dfh7y3xa0dxqmi8kqpbr77nl14y7ydpija6xm"; depends=[MASS mnormt gplots combinat]; };
···
   Bayesthresh = derive { name="Bayesthresh"; version="2.0.1"; sha256="0w26h1ragqcg1i4h7c2y6vd8fig2jb2zrnvvchgg5z2hg9qdplsf"; depends=[lme4 MASS VGAM mvtnorm matrixcalc coda]; };
   BayesValidate = derive { name="BayesValidate"; version="0.0"; sha256="1gli65avpkb90asx92l1yjbwaxcsyb920idyjwgd2sl2b3l657ly"; depends=[]; };
   BayesVarSel = derive { name="BayesVarSel"; version="1.5.1"; sha256="0r2al4d74dbra7va88fcazq5h19f0i4wymd39apsz3a3hsb8vdvv"; depends=[MASS]; };
-  BayesX = derive { name="BayesX"; version="0.2-8"; sha256="1kj0xwy972383vx52i8dn7vp0x8r5cbbii0s7nwfz0bn2iaks0c0"; depends=[shapefiles sp maptools colorspace coda]; };
+  BayesX = derive { name="BayesX"; version="0.2-9"; sha256="0p170m8zkaspiah1fdyql9lj9yqg6sl525blzq7wwgx5wx4rvncs"; depends=[shapefiles sp maptools colorspace coda]; };
   BayesXsrc = derive { name="BayesXsrc"; version="2.1-2"; sha256="114804f6maak5dmwzw4cbigjcdw7c6sgx48af35yrvkspi1gsz3b"; depends=[]; };
   BayHap = derive { name="BayHap"; version="1.0.1"; sha256="0xqnl2cbf0pyjlpywyy0j4mwknfn8msz4s719dsri3r7hvn9m6kd"; depends=[boa]; };
   BayHaz = derive { name="BayHaz"; version="0.1-3"; sha256="08ilghlkgyma5758yw7mdgqycqcillqmx73knzzdlg2kzc77dvg6"; depends=[]; };
···
   BB = derive { name="BB"; version="2014.1-1"; sha256="05ang9k03cpdyjskifp8y68sjgbsnp8xj1a85hzqychlb7d4f2qk"; depends=[]; };
   bbefkr = derive { name="bbefkr"; version="4.2"; sha256="1wjx652w3p41sq71a2zdzmb7frjxm6xvcgrc2ark2spwb0lbjjw6"; depends=[]; };
   bbemkr = derive { name="bbemkr"; version="2.0"; sha256="015c57s8mpimm82nddnh382wlkisxgdmc2hvp7k38pcnqxc5gb5q"; depends=[MASS]; };
-  BBmisc = derive { name="BBmisc"; version="1.7"; sha256="06lr7yjq9ypyvrvkf3gn1dl7ppf2mpn6jnvv3m4724g2sgh53cv4"; depends=[checkmate]; };
+  BBEST = derive { name="BBEST"; version="0.1-0"; sha256="0f833h8zbxgxabgmmcyi4ycys82dplmgzmi3l0fp735h2l3gy8a7"; depends=[DEoptim aws ggplot2 reshape2 shiny]; };
+  BBmisc = derive { name="BBmisc"; version="1.8"; sha256="1h48p45pcnda095w77yqc7vfbkwzkcsn36ms0mm7lcmyjbl503m9"; depends=[checkmate]; };
   bbmle = derive { name="bbmle"; version="1.0.17"; sha256="1j3x2glnn0i0fc0mmafwkkqh1js90g8q7gix2vrhif0pmwinsrak"; depends=[numDeriv lattice MASS]; };
   BBMM = derive { name="BBMM"; version="3.0"; sha256="1cvv786wf1rr5906qg1di2krrv5jgw3dnyl8z2pvs8jyn0kb3fkj"; depends=[]; };
-  bbo = derive { name="bbo"; version="0.1"; sha256="1giif78135f3hy8dqims83imism0k3507jlppgcb3x6pxk7dgwbs"; depends=[]; };
+  bbo = derive { name="bbo"; version="0.2"; sha256="19xrbla3bb3csg3gjjrpkgyr379zfwyh293bcrcd6j8rnm6g4i01"; depends=[]; };
   BBRecapture = derive { name="BBRecapture"; version="0.1"; sha256="05xzp5zjmkh0cyl47qfsz0l8drg8mimssybhycc4q69aif9scqxb"; depends=[HI locfit lme4 secr]; };
   bc3net = derive { name="bc3net"; version="1.0.2"; sha256="0iakqf4apscxb4mb5klj9qklbi25dmdd77la3ads2y882gm2nj0z"; depends=[c3net infotheo igraph Matrix lattice]; };
-  BCA = derive { name="BCA"; version="0.9-2"; sha256="1kry9v0sfcpn5vv4hwd983svwcgv841y9pkjdzi849gspmc9291r"; depends=[car clv cluster class flexclust rpart nnet rgl Rcmdr]; };
+  BCA = derive { name="BCA"; version="0.9-3"; sha256="0ksd6b0ykydgdn33x29bwwqkrp23cvdj3imps0l6qs1p4465j5nf"; depends=[RcmdrMisc Rcmdr car rpart flexclust clv]; };
   BCBCSF = derive { name="BCBCSF"; version="1.0-0"; sha256="1ag8wz8a9vh1x4jgppimgchfs53rr6hbg5xzzr6k2h4bfsg7pmn3"; depends=[abind]; };
   BCDating = derive { name="BCDating"; version="0.9.3"; sha256="1ibm34wab1dpigrhifkyr1nylgbprbh22fdw9zpmg8bawb7zgbsl"; depends=[]; };
-  BcDiag = derive { name="BcDiag"; version="1.0.4"; sha256="1cpy80cza2yqwgp6zma1p3chdbfbxb3in19rj1zndf89baggr520"; depends=[]; };
+  BcDiag = derive { name="BcDiag"; version="1.0.5"; sha256="18wryszrpmc2c4pdyvacns7r90l6n2x63cwsa6xjkgq3qwyz6nlj"; depends=[]; };
   BCE = derive { name="BCE"; version="2.1"; sha256="0dqp08pbq7r88yhvlwgzzk9dcdln7awlliy5mfq18j5jhiy7axiz"; depends=[FME limSolve Matrix]; };
   BCEA = derive { name="BCEA"; version="2.0-2"; sha256="1n0fp6na2y4n7p6ncwgi6hwx97mfrga3fkp3i0z06bh1p1jh8m88"; depends=[]; };
   BCEs0 = derive { name="BCEs0"; version="1.1"; sha256="0q63bkmk0kk9p5d3xb0f5srzfrbr743isyw4v2h9ch5yyxizcizb"; depends=[]; };
···
   bcrm = derive { name="bcrm"; version="0.4.4"; sha256="0gcigc7505fsk1m70df3n0dz553adkbs8yz2bhskb4qrw4gbmvr7"; depends=[mvtnorm ggplot2]; };
   bcv = derive { name="bcv"; version="1.0"; sha256="053if27miv46mbkni6pcpdpz0l336r5l95k7927dqalnri894xwz"; depends=[]; };
   bda = derive { name="bda"; version="3.2.0-3"; sha256="1725qdlkcf7hfklnksy7jslh66cfm7gsil1xgm2rw8hr6v2l0pmx"; depends=[]; };
-  BDgraph = derive { name="BDgraph"; version="2.10"; sha256="0f35i3r8i6fbh86537z8lvfmhydp87kmmcs4vycaa9ja88fb6czl"; depends=[Matrix igraph]; };
+  BDgraph = derive { name="BDgraph"; version="2.12"; sha256="13q1fafgllwj8fkl02i13417a9w7pn94sbjxjr29b5dgw81dgz2q"; depends=[Matrix igraph]; };
   bdoc = derive { name="bdoc"; version="1.2"; sha256="15d7grc0a1hakkxhgbm2gp0awggzlmsp8zf8abj5bgfih63gcmj2"; depends=[]; };
   bdpv = derive { name="bdpv"; version="1.1"; sha256="0i6wdf27243ch8pn2chqriwxjg3g72wbvzlx52mz4ahw700xjc7n"; depends=[]; };
-  bdsmatrix = derive { name="bdsmatrix"; version="1.3-1"; sha256="1iiqz34ssb5i5jd1x5d0mccir9ycrq2vq30g67ggw12apl7yks1l"; depends=[]; };
+  bdscale = derive { name="bdscale"; version="1.1"; sha256="1p0mv8z7j6mjcc25f4j2gaxmg06q90vp0j1s7nzln3fm1fiqj0xm"; depends=[ggplot2 scales]; };
+  bdsmatrix = derive { name="bdsmatrix"; version="1.3-2"; sha256="16qhfwk0r1snm9hg32qwz7hizkpwc32m723hjm23m2026gvz2nwy"; depends=[]; };
   bdvis = derive { name="bdvis"; version="0.1.0"; sha256="1f837i48gmspx9xrnxzsgdbg6ykxmvkp8l20y19yd9iakhv7k3jy"; depends=[maps plotrix sqldf plyr taxize treemap ggplot2]; };
   bdynsys = derive { name="bdynsys"; version="1.2"; sha256="06n4n5yix6yd5180c5y7qdk2p5jpjqiw28147l8fp58zqxvwjrxb"; depends=[plm Formula MASS Hmisc deSolve pracma caTools matrixStats]; };
   beadarrayFilter = derive { name="beadarrayFilter"; version="1.1.0"; sha256="044dq5irc00v2f2gjz0vb69w7q7b84lppc55ganabdv4f0dxdblc"; depends=[RColorBrewer]; };
   beadarrayMSV = derive { name="beadarrayMSV"; version="1.1.0"; sha256="0785vmjsli37hjyppk7hlqmn0b683s1apysx9dghbw4h6rgvr8n9"; depends=[rggobi]; };
-  beanplot = derive { name="beanplot"; version="1.1"; sha256="0h1ns2y0f6x5z9bn4wsv640509q4jxhqvmqr7snf8vk54vc35zs5"; depends=[]; };
+  beanplot = derive { name="beanplot"; version="1.2"; sha256="0wmkr704fl8kdxkjwmaxw2a2h5dwzfgsgpncnk2p2wd4768jknj9"; depends=[]; };
+  BEANSP = derive { name="BEANSP"; version="1.0"; sha256="0xcb81pk3iidb3dz9l4hm6cwx8hrbg5qz0sfi59yx2f7nsazr4xk"; depends=[]; };
   bear = derive { name="bear"; version="2.6.3"; sha256="1w933rb1v4ixgmxpbjxrfwzhiddpr0vxwr3gryl6z6p4wvwdwvp7"; depends=[reshape nlme gdata ICSNP sciplot plotrix ggplot2 png]; };
   BEDASSLE = derive { name="BEDASSLE"; version="1.4"; sha256="02638v89rcqky6npfckr1h7g563lbhs51bsprfr10jk44aj527np"; depends=[MASS matrixcalc emdbook]; };
   beepr = derive { name="beepr"; version="1.1"; sha256="187gww50yc8hzrzwz6j9ib101196g6ci9fx3dqyhg764ydn8if1n"; depends=[stringr audio]; };
   beeswarm = derive { name="beeswarm"; version="0.1.6"; sha256="05n2a1fqmh4m7d0b8vmcprss5ivgb0dlyly07jywj3vrf2z81yhy"; depends=[]; };
   benchden = derive { name="benchden"; version="1.0.5"; sha256="1cwcgcm660k8rc8cpd9sfpzz66r55b4f4hcjc0hznpml35015zla"; depends=[]; };
   benchmark = derive { name="benchmark"; version="0.3-6"; sha256="05rgrjhbvkdv06nzbh0v57b06vdikrqc1d29wirzficxxbjk1hih"; depends=[proto ggplot2 relations psychotools reshape scales plyr]; };
-  Benchmarking = derive { name="Benchmarking"; version="0.23"; sha256="0q0m34l3216m467b28nckg7l4g0z7jmxdamba3jgzfm4rv73d6rd"; depends=[lpSolveAPI ucminf]; };
+  Benchmarking = derive { name="Benchmarking"; version="0.24"; sha256="18gx8cwip1c03p37apyr9z89p117bz439vfgx91gxbbg1scc8bfp"; depends=[lpSolveAPI ucminf]; };
   benford_analysis = derive { name="benford.analysis"; version="0.1.1"; sha256="00ynk1af5nbq8bn8y77sckx4w32g5zxcp06pdpcxwvp38d7hxhvc"; depends=[data_table]; };
   BenfordTests = derive { name="BenfordTests"; version="1.1.1"; sha256="12xzc4gq4h7p18ypbkybrzjj2qh71rgd7nzznij36yv7n6h21mlw"; depends=[]; };
   bentcableAR = derive { name="bentcableAR"; version="0.2.3"; sha256="0d20cc3zis3pc3r86z12cwcz013w0mglbg6xgv90wq912jjpkxk9"; depends=[]; };
   BEQI2 = derive { name="BEQI2"; version="1.0-1"; sha256="0afp8f6kfmpa8qi952qnyxl2nn6kszc8fgvplvbl13v572261m7s"; depends=[knitr markdown RJSONIO xtable plyr reshape2]; };
   ber = derive { name="ber"; version="4.0"; sha256="0gl7rms92qpa5ksn8h3ppykmxk5lzbcs13kf2sjiy0r2535n8ydi"; depends=[MASS]; };
-  Bergm = derive { name="Bergm"; version="2.9"; sha256="1sjc9vkcbbhdc93gzsm25ld5h7hkwb8n6i51xzflphi0w1a66zkv"; depends=[ergm network coda mvtnorm]; };
+  Bergm = derive { name="Bergm"; version="3.0"; sha256="1awzif47ghkrbqm1cgs7xc6rrwr89fcasnsdbhkr3qjss8jffmb7"; depends=[ergm network coda mvtnorm]; };
   BerlinData = derive { name="BerlinData"; version="1.0.0"; sha256="1i4vb1gs3ffb2lxdhl8hzqwcr9nm8ya484glds3bdvj10ypncrya"; depends=[XML stringr]; };
-  berryFunctions = derive { name="berryFunctions"; version="1.4"; sha256="13kzrz0lrqlbysd7ymphcw12fg237knmvkdc71cl85929ydr09d8"; depends=[]; };
+  berryFunctions = derive { name="berryFunctions"; version="1.6"; sha256="0qar3mhplshxhlkci81hgsyfiprnpqmf011hkjvibsqm2s19w3qw"; depends=[]; };
   Bessel = derive { name="Bessel"; version="0.5-5"; sha256="1apcpwqgnbsn544x2mfjkp4136xn33pijazmbzas7lr14syl5a6b"; depends=[Rmpfr]; };
   BEST = derive { name="BEST"; version="0.2.2"; sha256="160lvrd0zjm1lr8llra6lyz3qsmqhn3bpdlmwingwfimbpb754rz"; depends=[rjags coda]; };
   bestglm = derive { name="bestglm"; version="0.34"; sha256="0b6lj91v0vww0fy50sqdn99izkxqbhv83y3zkyrrpvdzwia4dg9w"; depends=[leaps]; };
   betafam = derive { name="betafam"; version="1.0"; sha256="1nf5509alqnr5qpva36f1wb7rdnc084p170h91jv89xvzsidqxca"; depends=[]; };
   betapart = derive { name="betapart"; version="1.3"; sha256="0h2y2c3q6njzh2rlxh8izgkrq9y7abkbb0b13f2iyj9pnalvdv52"; depends=[ape geometry picante rcdd]; };
   betaper = derive { name="betaper"; version="1.1-0"; sha256="1gr533iw71n2sq8gga9kzlah7k28cnlwxb2yh562gw6mh1axmidm"; depends=[vegan ellipse]; };
-  betareg = derive { name="betareg"; version="3.0-4"; sha256="1crkp1j11zpzd92hc1zaw0pb68ngga8gl6v504p4r7629806g5hv"; depends=[Formula flexmix lmtest modeltools sandwich]; };
-  betategarch = derive { name="betategarch"; version="3.1"; sha256="1m4xif7xn1hhz9a77mmy0hlqrfp7qxardc95jcvx1jy76nny21af"; depends=[zoo]; };
+  betareg = derive { name="betareg"; version="3.0-5"; sha256="1zpj1x5jvkn7d8jln16vr4xziahng0f54vb4gc4vs03z7c853i4a"; depends=[flexmix Formula lmtest modeltools sandwich]; };
+  betategarch = derive { name="betategarch"; version="3.2"; sha256="0x3l1zvdp8r7mam7fvdlh1w3dwpjwj86n0ysfk8g824p4mn2wsgv"; depends=[zoo]; };
   bethel = derive { name="bethel"; version="0.2"; sha256="1zlkw672k1c5px47bpa2vk3w2906vkhvifz20h6xm7s51gmm64i0"; depends=[]; };
   bezier = derive { name="bezier"; version="1.1"; sha256="1bhqf1zbshkf1x8mgqp4mkgdxk9jxi51xj6i47kqkyn9gbdzch0c"; depends=[]; };
   bfa = derive { name="bfa"; version="0.3.1"; sha256="02vnbm77blllb74kll8w1i91k0llk43vq60aqjwpc5kqmzy652pk"; depends=[coda Rcpp RcppArmadillo]; };
-  bfast = derive { name="bfast"; version="1.4.4"; sha256="1k8rwlzrnkgs0wj0yy4gh4lj4zd5zyzwgwckgjy8k53r4296js66"; depends=[strucchange MASS forecast zoo raster sp strucchange zoo raster]; };
+  bfast = derive { name="bfast"; version="1.5.7"; sha256="0n75minka55rxpvs3qkj0c65ydn1gc3i8lkr2gdyn1adjkl5yn01"; depends=[strucchange zoo forecast sp raster]; };
   bfp = derive { name="bfp"; version="0.0-27"; sha256="08hlr33dwwjc4ag8vfsa3w4rcsc2093j8zwb05xkkl5nwqsq3mq0"; depends=[Rcpp]; };
   bgeva = derive { name="bgeva"; version="0.2"; sha256="178c2jkg5578mh1yq37713lwfbz98nbsc2p1bmacgmbxbqnkba3x"; depends=[mgcv magic trust]; };
   BGLR = derive { name="BGLR"; version="1.0.3"; sha256="02aw71r8khnkahqplycwziz7fh8hmnniq5bqnsk4fijv7z9gkbkg"; depends=[]; };
   bgmm = derive { name="bgmm"; version="1.6"; sha256="04d06rhb8ax1q4ayl03cw18j4wk4g4690kwdgiyym9yi0gh8hjij"; depends=[mvtnorm car lattice combinat]; };
-  BGPhazard = derive { name="BGPhazard"; version="1.0"; sha256="14nk8gxzd0xd4fcc16m026rlq3prnppv3jywllfapk5986cacq4g"; depends=[survival]; };
   BGSIMD = derive { name="BGSIMD"; version="1.0"; sha256="0xkr56z8l72wps7faqi5pna1nzalc3qj09jvd3v9zy8s7zf5r7w4"; depends=[]; };
-  BH = derive { name="BH"; version="1.54.0-3"; sha256="18n82c37562aklykw074ma0x95k9s4xp3l94jrjw2grajcrhx68b"; depends=[]; };
+  BH = derive { name="BH"; version="1.54.0-4"; sha256="1rcajynncy4qrs6sms05h8kqr9ry7c10j1l0xm1lr251qfjxhxkh"; depends=[]; };
   Bhat = derive { name="Bhat"; version="0.9-10"; sha256="1vg4pzrk3y0dk1kbf80mxsbz9ammkysh6bn26maiplmjagbj954v"; depends=[]; };
   BHH2 = derive { name="BHH2"; version="2012.04-0"; sha256="10ixvjpkqamlddrndpnw5gsdm4gdhp693jdvc0f774ngmf32rbaa"; depends=[]; };
   BHMSMAfMRI = derive { name="BHMSMAfMRI"; version="1.0"; sha256="0j5ivknsr441clgm0b95f2rz4pr29ixvw3dgsi8nb0ffh52dgz7q"; depends=[fmri AnalyzeFMRI wavethresh]; };
···
   biclust = derive { name="biclust"; version="1.0.2"; sha256="09w164zsnc48apf3r0yr6bfjxlpy4s2wqpzfhlg60c3c7bk1bf7v"; depends=[MASS colorspace lattice]; };
   BiDimRegression = derive { name="BiDimRegression"; version="1.0.6"; sha256="1kgrk4xanvxqdq619ha08wwplmsn2xqygx4dziagx48iqfpp1lxj"; depends=[nlme]; };
   bifactorial = derive { name="bifactorial"; version="1.4.7"; sha256="187zlsqph7m63wf6wajvs6a4a08aax9hiqssgvma6cpkpisfiz4k"; depends=[mvtnorm multcomp lattice Rcpp]; };
-  BIFIEsurvey = derive { name="BIFIEsurvey"; version="0.3-47"; sha256="10x2zfn19966mmmy2zxjhksxpzs38y8v25bmdn13vdmx70768gsc"; depends=[Rcpp miceadds]; };
+  BIFIEsurvey = derive { name="BIFIEsurvey"; version="1.0"; sha256="1i36xcv26bsi63sfcibqyqsd3nic1xgkphncn3hmvk4f8gwcljcm"; depends=[Rcpp miceadds]; };
   bigalgebra = derive { name="bigalgebra"; version="0.8.4"; sha256="19rv552ac0q9djc1yvpldkc0lipdf6q143m9dnndpsqs7ayqlr4g"; depends=[bigmemory]; };
   biganalytics = derive { name="biganalytics"; version="1.1.1"; sha256="0g45b293c1z9n2z9ab66jsy8yaiqm7bbs2d6pglzwgmmdvwy03qd"; depends=[bigmemory]; };
   bigdata = derive { name="bigdata"; version="0.1"; sha256="1n1zcjhvb2s87d7fkcm95x11ss4b8pczza0n55gxjv4przfiq0in"; depends=[glmnet Matrix lattice]; };
···
   biglars = derive { name="biglars"; version="1.0.2"; sha256="17zs25dvlja9ynx2fm5f4nmgkx4mnyqs5iscwsyahr6qigx1rz9x"; depends=[ff]; };
   biglm = derive { name="biglm"; version="0.9-1"; sha256="1z7h4by457z93k5i6qf5rq7xmd1y2kcd1rq4pv465cd32d4mb2g1"; depends=[DBI]; };
   bigmemory = derive { name="bigmemory"; version="4.4.6"; sha256="1pplnpxqg380l5mjgz0ak4ipsx7x54339n2wr3dd29xv3w2fb5rp"; depends=[bigmemory_sri BH]; };
-  bigmemory_sri = derive { name="bigmemory.sri"; version="0.1.2"; sha256="01nz4phifx10r1hs83avisnaqxvs3y70v0yczjgcr8kih2cnvbsd"; depends=[]; };
+  bigmemory_sri = derive { name="bigmemory.sri"; version="0.1.3"; sha256="0mg14ilwdkd64q2ri9jdwnk7mp55dqim7xfifrs65sdsv1934h2m"; depends=[]; };
   bigml = derive { name="bigml"; version="0.1-1"; sha256="0x0gn5pyffc8s0z2hp9iqgc63mmb3q7fb8lafzz2x67z2gghxi77"; depends=[RJSONIO RCurl plyr]; };
   bigpca = derive { name="bigpca"; version="1.0"; sha256="1s4qmg7xl8z0sv1b1vfqw0r5cvlbrxx1n0m03ira8fpykcck2clm"; depends=[reader NCmisc bigmemory biganalytics bigmemory_sri BH irlba]; };
   bigrf = derive { name="bigrf"; version="0.1-11"; sha256="0lazi8jk8aapdyyynd5yfcbn4jpjyxh8l64ayd0jj3nisl6hvmdh"; depends=[bigmemory foreach]; };
-  bigsplines = derive { name="bigsplines"; version="1.0-2"; sha256="0sbjq1vh8im6rwyz27h5m8rpckqiiaz9h22kcbzissy2dckis3l8"; depends=[]; };
+  bigRR = derive { name="bigRR"; version="1.3-10"; sha256="08m77r9br6wb9i21smaj4pwwpq3nxdirs542gnkrpakl7bvyp6s3"; depends=[hglm DatABEL]; };
+  bigsplines = derive { name="bigsplines"; version="1.0-4"; sha256="10i8scp048s7mdxccqq2wz7ffqljnpgbhki5hkyjp7i5lbhbmcax"; depends=[]; };
   bigtabulate = derive { name="bigtabulate"; version="1.1.2"; sha256="0vp873r3gww6kfkjdm87qgcdi85362kq946lvs45ggvyv7iaw0wa"; depends=[bigmemory]; };
   BigTSP = derive { name="BigTSP"; version="1.0"; sha256="1jdpa8rcnrhzn0hilb422pdxprdljrzpgr4f26668c1vv0kd6k4v"; depends=[glmnet tree randomForest gbm]; };
-  bilan = derive { name="bilan"; version="2013.12"; sha256="0wrrs6l8iwy6r707djsmlmwiw0y5z6wwnsn27fvmq9cb8scvbfan"; depends=[Rcpp]; };
   bild = derive { name="bild"; version="1.1-3"; sha256="02fi3h6mhg2m1ppkcpxpwzjfchkk9h7yv73j0365srr1jxki44pm"; depends=[]; };
   bimetallic = derive { name="bimetallic"; version="1.0"; sha256="181qi4dr0zc7x6wziq7jdc1his20jmprfpq3hrfm56fr5n1sj8wl"; depends=[]; };
   binda = derive { name="binda"; version="1.0.0"; sha256="0h5a67ygn4hwkdzbmhdkqjngln32yr8rk36k87m3hq1ahj4jn73x"; depends=[entropy]; };
   bindata = derive { name="bindata"; version="0.9-19"; sha256="15ya21fz1kvq4qsppkn9ypiqvaq8q4vszdcgcymampa7zc07z2ld"; depends=[e1071 mvtnorm]; };
+  binequality = derive { name="binequality"; version="0.6.1"; sha256="18pcz5b65zk6fwh597pcbpyy0j7gkxp5swwadxvsa3cainvyd07n"; depends=[gamlss gamlss_cens gamlss_dist survival ineq]; };
   bingat = derive { name="bingat"; version="1.1"; sha256="1pb1yy1xrfvh71pg237lkmi56p8pbam60rii5i5km1i960lq0wc1"; depends=[matrixStats network]; };
   binGroup = derive { name="binGroup"; version="1.1-0"; sha256="1sf7prg2x1ryynf1kz7jr50svmga7kjgd5pi9qm3g2hyimz8mvs4"; depends=[]; };
   binhf = derive { name="binhf"; version="1.0-1"; sha256="0l8925bj6mjv2y7fn76zh2g8xjig3kbbdy4jl0ip3gd9kbrakl9k"; depends=[wavethresh adlift]; };
···
   binomTools = derive { name="binomTools"; version="1.0-1"; sha256="14594i7iapd6hy4j36yb88xmrbmczg8zgbs0b6k0adnmqf83bn4v"; depends=[]; };
   binr = derive { name="binr"; version="1.0"; sha256="0wgc78kx51qfn5wfzll5nz8iwanixkyb5sbqwi40fak93bvycklm"; depends=[]; };
   binseqtest = derive { name="binseqtest"; version="1.0"; sha256="103nbi3zq9m632665iqz0z79v963ixhd5xrjfx6drwpfp4i69pbl"; depends=[clinfun]; };
+  bio3d = derive { name="bio3d"; version="2.1-3"; sha256="1iip34prynbib0aasrcxr1gck2vmal8vxwyrjx7ra9pq9zcnvjyq"; depends=[]; };
   Biodem = derive { name="Biodem"; version="0.3"; sha256="0wfyypr46awki2nrvhcjwacmaxrr2wvhdv9hddnf10msssflvshc"; depends=[]; };
   BiodiversityR = derive { name="BiodiversityR"; version="2.4-4"; sha256="1sgjvjhvfdljjap69hi3f5j0ma9nikh43vgzbj8zkrz95d3jwd66"; depends=[Rcmdr]; };
   BioGeoBEARS = derive { name="BioGeoBEARS"; version="0.2.1"; sha256="0wyddc5ma47ljpqipfkwsgddp12m9iy4kqwwgklyhf0rqia56b1h"; depends=[rexpokit cladoRcpp ape phylobase optimx FD xtable plotrix gdata]; };
···
   bio_infer = derive { name="bio.infer"; version="1.3-3"; sha256="14pdv6yk0sk6v8g9p6bazbp7mr3wmxgfi6p6dj9n77lhqlvjcgm9"; depends=[]; };
   biom = derive { name="biom"; version="0.3.12"; sha256="18fmzp2zqjk7wm39yjlln7mpw5vw01m5kmivjb26sd6725w7zlaa"; depends=[plyr RJSONIO Matrix]; };
   BioMark = derive { name="BioMark"; version="0.4.2"; sha256="17r4q2migmdk2vqfbr69q07cgdzwpjgs3ijmnm42srs5d3brw8cr"; depends=[pls glmnet MASS st]; };
-  BiomarkeR = derive { name="BiomarkeR"; version="1.3"; sha256="0djhqindpmzx6kkj17db6d1n3w5v5wl1l3z14lnl0r2k1hf276fy"; depends=[igraph Hmisc]; };
   biomod2 = derive { name="biomod2"; version="3.1-48"; sha256="1qsxzgikzxvgfrvm3lqfbwk1fnd55z1jgi9d6nyjxxcmn65lgx5l"; depends=[sp raster reshape abind rasterVis pROC nnet gbm mda randomForest rpart MASS]; };
-  bionetdata = derive { name="bionetdata"; version="1.0"; sha256="1y5nnyfzbdk8673jyi733j4ncsc62kbsn1b8ghq10cb4xzxf2mvf"; depends=[]; };
+  BIOM_utils = derive { name="BIOM.utils"; version="0.9"; sha256="0xckhdvf15a62awfk9rjyqbi6rm7p4awxz7vg2m7bqiqzdll80p7"; depends=[]; };
+  bionetdata = derive { name="bionetdata"; version="1.0.1"; sha256="1l362zxgcvxln47b1vc46ad6ww8ibwhqr2myxnz1dnk2a8nj7r2q"; depends=[]; };
   biopara = derive { name="biopara"; version="1.5"; sha256="1fhhs6lkm3iphlkx6wklh9sgr1mkjkka9wv2m8fnk0xw01bdsyl5"; depends=[]; };
   BioPhysConnectoR = derive { name="BioPhysConnectoR"; version="1.6-10"; sha256="1cc22knlvbvwsrz2a7syk2ampm1ljc44ykv5wf0szhnh75pxg13l"; depends=[snow matrixcalc]; };
   bioPN = derive { name="bioPN"; version="1.2.0"; sha256="0mvqgsfc7d4h6npgg728chyp5jcsf49xhnq8cgjxfzmdayr1fwr8"; depends=[]; };
   bios2mds = derive { name="bios2mds"; version="1.2.2"; sha256="1avzkbk91b7ifjba5zby5r2yw5mibf2wv05a4nj27gwxfwrr21cd"; depends=[amap e1071 scales cluster rgl]; };
-  BioStatR = derive { name="BioStatR"; version="1.0.4"; sha256="043fakac56kf1mdmwlm8q3hjdxlclissxbkv26y2brqp2sfr01pb"; depends=[]; };
+  BioStatR = derive { name="BioStatR"; version="2.0.0"; sha256="1k3z337lj8r06xgrqgi5h67hhkz2s5hggj6dhcciq26i1nzafsw6"; depends=[ggplot2]; };
   biotools = derive { name="biotools"; version="1.2"; sha256="0wiv10qqah6yp5kwsndv48agnvrfl3j04pj0nsyiwyf9nvajxvic"; depends=[rpanel tkrplot MASS boot]; };
   bipartite = derive { name="bipartite"; version="2.04"; sha256="0rp2j2ip8523jmvgvbnj56q49yazwz2wqyqc0l00flvp4920svf0"; depends=[vegan sna fields igraph MASS permute]; };
   biplotbootGUI = derive { name="biplotbootGUI"; version="1.0"; sha256="0pgm31nhh1b78a8ciqjxw7gf3j7hh9wjc3myj29jpl92flbqmsw0"; depends=[rgl tkrplot vegan tcltk2]; };
   BIPOD = derive { name="BIPOD"; version="0.2.1"; sha256="04r58gzk3hldbn115j9ik4bclzz5xb2i3x6b90m2w9sq7ymn3zg1"; depends=[Rcpp]; };
-  birdring = derive { name="birdring"; version="1.1"; sha256="0j24s1vwf848bpswphzf0liyyda9rknh03gnqpflk66imxkbvgxc"; depends=[geosphere ks lazyData raster rgdal rgeos rworldmap rworldxtra sp]; };
-  birk = derive { name="birk"; version="1.0"; sha256="09arzwpgcanp6cds70rr7qnpnva0fag88k1gg9yhg4k0yvbhqdbd"; depends=[]; };
+  birdring = derive { name="birdring"; version="1.2"; sha256="1jhhvdipsx3kw8n6gw6amm1vq0m83l48dkark9vvi2hpd730ca1y"; depends=[geosphere ks lazyData raster rgdal rgeos rworldmap rworldxtra sp]; };
+  birk = derive { name="birk"; version="1.1"; sha256="0v1p7bi2zbc8ghhbcpanwx52kkyxd06jhzq7kkcpjk1nzmhxhqgw"; depends=[]; };
   bisectr = derive { name="bisectr"; version="0.1.0"; sha256="1vjsjshvzj66qqzg32rviklqswrb00jyq6vwrywg1hpqhf4kisv7"; depends=[devtools]; };
-  BiSEp = derive { name="BiSEp"; version="1.0"; sha256="1iw3ask3gpjhx0gnjgl3402fygi7bnsrha6dfxfsmyzz94im352x"; depends=[mclust]; };
+  BiSEp = derive { name="BiSEp"; version="2.0"; sha256="1nm76bcdwwy8c434a94rnhfvnc3va54q0jd8blkbh79qm5nwcpf9"; depends=[mclust]; };
   bisoreg = derive { name="bisoreg"; version="1.1"; sha256="16d6nxbj18y6wv57nxbmwv0gypsgf7hw76hsyv0fhydrkf404igb"; depends=[bootstrap monreg R2WinBUGS coda]; };
   bit = derive { name="bit"; version="1.1-12"; sha256="0a6ig6nnjzq80r2ll4hc74za3xwzbzig6wlyb4dby0knzf3iqa6f"; depends=[]; };
   bit64 = derive { name="bit64"; version="0.9-4"; sha256="1w734l5ayr7w17a3gk2kmkqwz7v5jm830kfhyqmnd15i816lnjb9"; depends=[bit]; };
···
   biwt = derive { name="biwt"; version="1.0"; sha256="1mb3x8ky3x8j4n8d859i7byyjyfzq035i674b2dmdca6mn7paa14"; depends=[rrcov MASS]; };
   bizdays = derive { name="bizdays"; version="0.1.5"; sha256="0y25sm77chk77s4wdb5a4r583ks44mpny9w8c8azbx7nhcvfb4yq"; depends=[]; };
   BlakerCI = derive { name="BlakerCI"; version="1.0-4"; sha256="1sa9qq5frjjcw46p3ankn7v3gj0gwn9lww6jacz8flf5qpplhn4l"; depends=[]; };
+  BlandAltmanLeh = derive { name="BlandAltmanLeh"; version="0.1.0"; sha256="0y35zkxiallp4x09646qb8wj9bayh7mpnjg43qmzhxkm7l95b78r"; depends=[]; };
   Blaunet = derive { name="Blaunet"; version="1.0.1"; sha256="1qcp5wag4081pcjg5paryxz3hk3rqql15v891ppqc1injni7rljz"; depends=[network]; };
-  BLCOP = derive { name="BLCOP"; version="0.2.8"; sha256="1x4dq7ri23wyhdz4hb80iqwwfijg8a3bj0nqgh4rvrwwdjx96ikv"; depends=[MASS quadprog]; };
   blender = derive { name="blender"; version="0.1.2"; sha256="1qqkfgf7fzwcz88a43cqr8bw86qda33f18dg3rv1k77gpjqr999c"; depends=[vegan]; };
   blighty = derive { name="blighty"; version="3.1-4"; sha256="1fkz3vfcnciy6rfybddcp5j744dcsdpmf7cln2jky0krag8pjzpn"; depends=[]; };
-  blkergm = derive { name="blkergm"; version="1.0"; sha256="00xqmqn7y3vwygfx2v6kqm52n96vxlip2yk09gf30cqn2p3b6sck"; depends=[ergm ergm_userterms]; };
+  blkergm = derive { name="blkergm"; version="1.1"; sha256="0giknhcl14b4djn5k5v5n33b7bc3f8x6lx2h4jr25kpd89aynhq5"; depends=[network ergm statnet_common]; };
   blm = derive { name="blm"; version="2013.2.4.4"; sha256="1w6c30cq38j4i1q4hjg12l70mhy5viw886l1lsnxyvniy113in4i"; depends=[]; };
   blme = derive { name="blme"; version="1.0-2"; sha256="11m98j9xr6w0hfcss4bbx2aa34gnc5p9if9r8ilw9ify18by77np"; depends=[lme4]; };
   blockcluster = derive { name="blockcluster"; version="3.0.1"; sha256="1lxm20f8dhxfnm13j08sj7h3sfwc8limyqn8n87c3kl87066gdaq"; depends=[Rcpp]; };
···
   BlockMessage = derive { name="BlockMessage"; version="1.0"; sha256="1jrcb9j1ikbpw098gqbcj29yhffa15xav90y6vpginmhbfpwlbf4"; depends=[]; };
   blockmodeling = derive { name="blockmodeling"; version="0.1.8"; sha256="0x71w1kysj9x6v6vsirq0nndsf6f3wzkf8pbsq3x68sf4cdji1xl"; depends=[]; };
   blockrand = derive { name="blockrand"; version="1.3"; sha256="1090vb26w6s7iqjcal0xbb3qb6p6j46a5w25f1wjdppd1spvh7f9"; depends=[]; };
+  blocksdesign = derive { name="blocksdesign"; version="1.1"; sha256="11pf15ks0833vczk6q9q19bcqzvhsgiafdj3w4ymvphppsww2j3b"; depends=[crossdes]; };
   blockTools = derive { name="blockTools"; version="0.6-1"; sha256="10f2rkailk0bvg5hj9hxy0p3snknbpvsydx3cpsy0n6y5srwhrfr"; depends=[MASS]; };
   blowtorch = derive { name="blowtorch"; version="1.0.1"; sha256="19z2z2alq5lr3f4nmjzpmyxssxalwfkm437bsjnzyf0r3zvycy9c"; depends=[ggplot2 foreach iterators]; };
   BLR = derive { name="BLR"; version="1.3"; sha256="02p29p06vhh8gxkfnqdf9niq09bygshmiipvd3q19k92g0a10l69"; depends=[SuppDists]; };
-  BMA = derive { name="BMA"; version="3.17.1"; sha256="0lq42qn82969vhk2vdyxb1d7lrqqgp8793m9rlzgg011c6b38qam"; depends=[survival leaps robustbase]; };
-  BMAmevt = derive { name="BMAmevt"; version="1.0"; sha256="0cy3h81xd1jjg7fdwndb5az67cp7kn1wp87p17za8506vyxj1pa0"; depends=[coda]; };
+  BMA = derive { name="BMA"; version="3.18.1"; sha256="0ppcjjcrjrs18lp55hrs0ad7x052v57wd0zdfmvyydlsjbgnsx1p"; depends=[survival leaps robustbase inline]; };
   bmd = derive { name="bmd"; version="0.5"; sha256="0d4wxyymycb416sdn272292l70s1h2m5kv568vakx3rbvb8y6agy"; depends=[drc]; };
   bmem = derive { name="bmem"; version="1.5"; sha256="1miiki743rraralk9dp12dsjjajj3iizcrfwmplf6xas6pl8sfk6"; depends=[Amelia MASS lavaan sem snowfall]; };
   BMhyd = derive { name="BMhyd"; version="1.2-2"; sha256="09gb1pq9y3gq9avpaqrlxdsm9iqsxpbnr0bg2mw1vkhc0d5z8zv7"; depends=[corpcor numDeriv]; };
···
   bnlearn = derive { name="bnlearn"; version="3.6"; sha256="0q5w5lsjgr7lgfgb7yhybq5ixaps2p91gx19l6dg2xlxw2m5fnab"; depends=[]; };
   BNPdensity = derive { name="BNPdensity"; version="2013.8"; sha256="1qlhav764ji289kcibbmqjj62mmxiw3zsiwjz1gkifzgpmzyar85"; depends=[]; };
   bnpmr = derive { name="bnpmr"; version="1.1"; sha256="0hvwkdbs2p2l0iw0425nca614qy3gsqfq4mifipy98yxxvgh8qgc"; depends=[]; };
+  BNSP = derive { name="BNSP"; version="1.0.0"; sha256="1ijwmcpfcvv5gc1diwamz02sbj0mfwh9al86yx1wa3gfb6pvd623"; depends=[]; };
   boa = derive { name="boa"; version="1.1.7-2"; sha256="1n7i0i8jq2sa1kzhbgyqzl9d53wja7fsxd7rligc8xjm0sdsb386"; depends=[]; };
-  BOG = derive { name="BOG"; version="1.1"; sha256="0lr2n4j32b7qzmyb2048kssc7sbchivhi2a8skmahhjl85jgy166"; depends=[hash DIME]; };
-  boilerpipeR = derive { name="boilerpipeR"; version="1.2"; sha256="00r8rlwx9qkfqk8x0mcskklz3skvnmcc55r9pd9rqxz7sp7s71h5"; depends=[rJava]; };
-  bold = derive { name="bold"; version="0.1.2"; sha256="0fjsnn9iqvlhgq9l5r17l5125arlsaz68pgd3b9i7596767zm1f2"; depends=[XML httr stringr assertthat]; };
+  boilerpipeR = derive { name="boilerpipeR"; version="1.2.2"; sha256="0hcjlinzq2778zhwvsdyif099w8qjz5yidvpsyhphk4r6jyk4k2w"; depends=[rJava]; };
+  BOIN = derive { name="BOIN"; version="1.0"; sha256="14rh2sz4h79vxrskc10idd6mb3dyy8ngdxrac134yxna7507ly0s"; depends=[]; };
+  bold = derive { name="bold"; version="0.2.0"; sha256="06dnhhf2bmiqxizarsqd6l2dcsldz4135srqa7yz90flsl9ihzwx"; depends=[XML httr stringr assertthat jsonlite reshape plyr]; };
   Bolstad = derive { name="Bolstad"; version="0.2-25"; sha256="1dj0ib3jndnsdx2cqsy0dz54szdx1xq3r2xqnxzk4ysng6svdym8"; depends=[]; };
   Bolstad2 = derive { name="Bolstad2"; version="1.0-28"; sha256="08cfadvl9jl9278ilsf8cm2i2a3i8zsa2f3vjzw2nlv85fwi2c7v"; depends=[]; };
   boolean3 = derive { name="boolean3"; version="3.1.5"; sha256="0ayjiff1mv7mvzfbqlxryg3vmmq85a63yslw4rk04awh5k4kpr88"; depends=[optimx numDeriv lattice rgenoud mvtnorm rlecuyer]; };
-  BoolNet = derive { name="BoolNet"; version="2.0"; sha256="1zg6knqdmcx1wv6i72fpyh86jjkhb9k0xplaczcxfx2f294y4bfr"; depends=[]; };
+  BoolNet = derive { name="BoolNet"; version="2.0.1"; sha256="0g6pq39hcpfjxvij9x0j7x4xjfkynqnzn4ydkbcrjxhsrkp8h5z5"; depends=[igraph XML]; };
   Boom = derive { name="Boom"; version="0.1"; sha256="03xsfzfl1wvhbd6d1blhwx4dd0vpf7kaha2f50p6q17q6c1ph2vv"; depends=[MASS]; };
   BoomSpikeSlab = derive { name="BoomSpikeSlab"; version="0.4.1"; sha256="0s0pbb5dmry736x19li5g364kirvhkhpyjm5q0kp5nvq83bi1hq0"; depends=[Boom]; };
   boostr = derive { name="boostr"; version="1.0.0"; sha256="123ag8m042i1dhd4i5pqayqxbkfdj4z0kq2fyhxfy92a7550gib2"; depends=[foreach iterators stringr]; };
   boostSeq = derive { name="boostSeq"; version="1.0"; sha256="0sikyzhn1i6f6n7jnk1kb82j0x72rj8g5cimp2qx3fxz33i0asx6"; depends=[genetics lpSolveAPI]; };
-  boot = derive { name="boot"; version="1.3-11"; sha256="0s8v5mpyz2pqmm0kk8qkjiqr3wb1j1mqazx5hgsdabq6ga85ah8j"; depends=[]; };
+  boot = derive { name="boot"; version="1.3-13"; sha256="0nkl3kbg23ch0jirrfm4033lhjwvay5j3gjd477kw0105zkalhcc"; depends=[]; };
   bootES = derive { name="bootES"; version="1.01"; sha256="00y901d5cjdpzras5w6mv851h5zgp36m5ib6dazs4vqrfpqymva8"; depends=[boot]; };
   bootfs = derive { name="bootfs"; version="1.4.2"; sha256="1qac7v0yzhxzqbdhkpgb4z1gqr6v6hjyb2y5lsxlq5dg1ka1cnb0"; depends=[pROC igraph ROCR gbm colorRamps gplots gtools pamr randomForest Boruta caret tgp mlegp penalizedSVM]; };
   bootLR = derive { name="bootLR"; version="0.9"; sha256="0p4hq8nfdd8jw8r8dmlb6va4g7jjnkbsah69hissa9lqawbj9pi7"; depends=[boot]; };
···
   bootStepAIC = derive { name="bootStepAIC"; version="1.2-0"; sha256="0p6v4zjsaj1p6c678010fazdh40lpv0rvhczd1halj8aic98avdx"; depends=[MASS]; };
   bootstrap = derive { name="bootstrap"; version="2014.4"; sha256="1kf5jml03yfqz2868jbnjvy839x09ml0niyq85va503pq8gmj5br"; depends=[]; };
   bootSVD = derive { name="bootSVD"; version="0.1"; sha256="1rzwp8kadyc0dg6lscag586xliapp1ninz7qxczl8jmxa9sx9z89"; depends=[]; };
+  boral = derive { name="boral"; version="0.5"; sha256="0abxb22s4cqz2bx1ggy78jjyfjj0plv8zgccyj06jgzqqciw2fr2"; depends=[coda R2jags mvtnorm fishMod MASS]; };
   Boruta = derive { name="Boruta"; version="3.1.0"; sha256="0dmg8yyx6bb5s6glqsajk0qqf6xwb8qzwi6gbi5agd3i57xm8nak"; depends=[randomForest rFerns]; };
   boss = derive { name="boss"; version="2.1"; sha256="1knsnf19b1xvvq20pjiv56anbnk0d51aq6z3ikhi8y92ijkzh0y8"; depends=[lme4 geepack Matrix ncdf]; };
-  BoSSA = derive { name="BoSSA"; version="1.2"; sha256="0rvb6y7jwy0nmjvnpkim09fdph5kazg8cr0jchnz1s46n16gvc96"; depends=[ape SoDA]; };
+  BoSSA = derive { name="BoSSA"; version="1.2"; sha256="191hq0np9iadks4sflg360k64xnz8j956y30pqzwciinb4hgq1nr"; depends=[ape SoDA]; };
   boussinesq = derive { name="boussinesq"; version="1.0.3"; sha256="1j1jarc3j5rby1wvj1raj779c1ka5w68z7v3q8xhzjcaccrjhzxk"; depends=[]; };
   boxplotdbl = derive { name="boxplotdbl"; version="1.2.2"; sha256="01bvp6vjnlhc4lndxwd705bzlsh7zq0i9v66mxszrcz6v8hb9rwi"; depends=[]; };
   bpca = derive { name="bpca"; version="1.2-2"; sha256="05ldz6b2s379mymj8jzvia9x6gj047gwsxvnv3zj9x8b1hvndnd6"; depends=[scatterplot3d rgl]; };
   bpcp = derive { name="bpcp"; version="1.1.0"; sha256="15dy3bbpazm4g72lwdf925f13a4dpdhi771283564v9f3n7qm3qf"; depends=[]; };
   bPeaks = derive { name="bPeaks"; version="1.2"; sha256="1z6jghcmw0lwv17ms7gdp5zzimaawq3ahbwkxa4062g373592smd"; depends=[]; };
-  bpkde = derive { name="bpkde"; version="1.0-4"; sha256="142wmbs7hm5rs6vfgkg5q1rcc2jvg87kpxc8jbywf620ryycpc5z"; depends=[]; };
+  bpkde = derive { name="bpkde"; version="1.0-7"; sha256="1ls6rwmbgb2vzsjn34r87ab8rnz3ls61g6f4x3jpglbk0j91f0h8"; depends=[]; };
   bqtl = derive { name="bqtl"; version="1.0-30"; sha256="1v1p3wvqm5hmwpnjqaz8vlpzm036gpzpxsvy7m0v4x7nc5vrq7g6"; depends=[]; };
   BradleyTerry2 = derive { name="BradleyTerry2"; version="1.0-5"; sha256="131z9ccfh55inlczy5wnzni2pch4brs6nzjrg8f5xnvkpyy6jqsp"; depends=[lme4 brglm gtools]; };
-  BrailleR = derive { name="BrailleR"; version="0.9"; sha256="11aygays2f3qy6z8x8srs9d7saggqpcamns36f7dbcc94b84aqkj"; depends=[]; };
+  BrailleR = derive { name="BrailleR"; version="0.11"; sha256="0vrgk89in5r13434r2p13shckl2b916dj8xn7kpmyngylp91r3a2"; depends=[nortest xtable moments knitr]; };
   brainR = derive { name="brainR"; version="1.2"; sha256="1515v6kk73p4s3vrnkpkilfxfyqrf7b762sq6j364ygsyfybvh2z"; depends=[rgl misc3d oro_nifti]; };
   brainwaver = derive { name="brainwaver"; version="1.6"; sha256="0r79dpd9bbbn34rm29512srzj3m29qgvbryvrp1mwv8mmcsh6ij6"; depends=[waveslim]; };
   branchLars = derive { name="branchLars"; version="1.0"; sha256="1adk9j77ynv7y8q04nvb468ik4nq4ff3j2nbxw596kgg5bg1ymz0"; depends=[lars]; };
   breakage = derive { name="breakage"; version="1.0-1"; sha256="1zn0hxkz4zqhrfny75gkp2sgc0fs4v3y940aw32fmjh4j8kl3n4j"; depends=[Imap]; };
   breakaway = derive { name="breakaway"; version="1.0"; sha256="1agigb3b2ff1p9lx9ndz4hs1sgyv1g2zjb41l5p23370i5gk1nbn"; depends=[]; };
   breakpoint = derive { name="breakpoint"; version="1.0"; sha256="0clmrad4ycpi0rxrvkh4agwixdayypjdnk3lfyb5g2w2hngrxv73"; depends=[ggplot2 foreach]; };
-  bReeze = derive { name="bReeze"; version="0.3-2"; sha256="1k5xc3ymi53pib4hpgy9x6s5c6dvw5v1xrqyiqmbzx2djfw65dr5"; depends=[RColorBrewer]; };
+  bReeze = derive { name="bReeze"; version="0.4-0"; sha256="1znhmb2inbfv574adhwjwk3qf9kikrxrly4n6sfyim1z6sagnj0z"; depends=[]; };
   brew = derive { name="brew"; version="1.0-6"; sha256="1vghazbcha8gvkwwcdagjvzx6yl8zm7kgr0i9wxr4jng06d1l3fp"; depends=[]; };
   brglm = derive { name="brglm"; version="0.5-9"; sha256="14hxjamxyd0npak8wyfmmb17qclj5f86wz2y9qq3gbyi2s1bqw2v"; depends=[profileModel]; };
   bride = derive { name="bride"; version="1.3"; sha256="03k9jwklg1l8sqyjfh914570880ii0qb5dd9l0bg0d0qrghbj0rk"; depends=[]; };
···
   BRugs = derive { name="BRugs"; version="0.8-3"; sha256="1qjwm6qizg70nvpl5p2yx65ynghazchqw7d2iadhdjz7dd293sqi"; depends=[coda]; };
   BSagri = derive { name="BSagri"; version="0.1-8"; sha256="148pr4lkgdi4bwc9lavgj356nh240iazz28xklq14rw4gzhmz2k4"; depends=[gamlss multcomp MCPAN mvtnorm boot mratios]; };
   BSDA = derive { name="BSDA"; version="1.01"; sha256="06mgmwwh56bj27wdya8ln9mr3v5gb6fcca7v9s256k64i19z12yi"; depends=[e1071 lattice]; };
+  BSGW = derive { name="BSGW"; version="0.9"; sha256="0df5d0d0kfvwavxbxra36jjs9044q1szq1xm37dvh4wfvvv6igmb"; depends=[survival]; };
   bshazard = derive { name="bshazard"; version="1.0"; sha256="151c63pyapddc4z77bgkhmd7rsa1jl47x8s2n2s8yc6alwmj6dvs"; depends=[survival Epi]; };
   BsMD = derive { name="BsMD"; version="2013.0718"; sha256="1yvazqlbmm221r7nkhrhi309gkk6vx7ji5xlvf07klya2zg20gcj"; depends=[]; };
   bspec = derive { name="bspec"; version="1.4"; sha256="1iq66hx4d0f5pvsh6qcsd2kzm913aqil4w66bfshj192fwbfziix"; depends=[]; };
   bspmma = derive { name="bspmma"; version="0.1-1"; sha256="0bd6221rrbxjvabf1lqr9nl9s0qwav47gc56sxdw32pd99j9x5a9"; depends=[]; };
   BSquare = derive { name="BSquare"; version="1.1"; sha256="1s16307m5gj60nv4m652iisyqi3jw5pmnvar6f52rw1sypfp5n49"; depends=[quadprog quantreg VGAM]; };
-  BSSasymp = derive { name="BSSasymp"; version="1.0-2"; sha256="1m0rssdi4v68sm28x99j5igcl3z2hnlj8f4wx9xxxbj4l6mqy6yv"; depends=[fICA JADE]; };
+  BSSasymp = derive { name="BSSasymp"; version="1.1-0"; sha256="0z3abgvbpmwgzb6b6r5ys3msy97lfdg81p8d19c83aaa6hrngggn"; depends=[fICA JADE]; };
   bst = derive { name="bst"; version="0.3-4"; sha256="1s7qv2q9mcgg1c5mhblqg3nk9hary4pq6z0xgi3a6rs1929mgdyf"; depends=[rpart gbm]; };
-  bstats = derive { name="bstats"; version="1.1-11-5"; sha256="15is47404zlcqrniydhxc9ssixnm846spxcfds4cjg9d9x3mdscj"; depends=[]; };
   bsts = derive { name="bsts"; version="0.5.1"; sha256="0qzyrn8zbfxrplyw04yrcakig6lc1i8fpwl893vbzciyhwmrjlya"; depends=[BoomSpikeSlab zoo xts Boom]; };
   btf = derive { name="btf"; version="1.1"; sha256="0n1h4hmjpvj97mpvannh3s5l08m4zfv0w64hrgdv4s5808miwfzc"; depends=[Matrix coda]; };
+  BTSPAS = derive { name="BTSPAS"; version="2014.0901"; sha256="0ankkhm38rvq06g0jnbvjbja4jv8lg21dsc0rxsy174b1i6vjhwi"; depends=[coda actuar rjags R2OpenBUGS ggplot2 plyr]; };
   BTYD = derive { name="BTYD"; version="2.3"; sha256="032xcy4z3gs4kqn91z7l6anp1vn5j60g32k2h87jx2aymy796cl0"; depends=[gsl Matrix]; };
   bujar = derive { name="bujar"; version="0.1-4"; sha256="0v48mkg78sy91z1z4xvy2r3xmay74615kzqxjqlclkk20999z56m"; depends=[mda ncvreg mboost gbm earth elasticnet rms]; };
   BurStFin = derive { name="BurStFin"; version="1.02"; sha256="16w2s0bg73swdps9r0i8lwvf1najiqyx7w7f91xrsfhmnqkkjzka"; depends=[]; };
   BurStMisc = derive { name="BurStMisc"; version="1.00"; sha256="0718a1p7iiqkfhhmnzxggc6hd8sm847n1qh7rfbdl8b0k0bgvnj0"; depends=[]; };
   bursts = derive { name="bursts"; version="1.0-1"; sha256="172g09d1vmwl83xs6gr4gfblqmx3apvblpzdr5d7fcw1ybsx0kj6"; depends=[]; };
+  bvarsv = derive { name="bvarsv"; version="1.0"; sha256="0ak4nsrcvhkg0145ax5ib9ljb5yc63zzfxlgvdbrdr4mlri4gsid"; depends=[Rcpp]; };
   bvenn = derive { name="bvenn"; version="0.1"; sha256="1xrya49w5bd2b7plfxpqla60b2828rkm0rjmc4qnqzvrahsbal0y"; depends=[]; };
   bvls = derive { name="bvls"; version="1.4"; sha256="18aaf7kk5mks3a59wwqhm1ckpn6s704l9m5nzy0x5iw0s98ijbm2"; depends=[]; };
   bvpSolve = derive { name="bvpSolve"; version="1.2.4"; sha256="1ss25md3q59cm40rxw29x9421xjc7gd964hx9xwvx4h8dis34rgd"; depends=[rootSolve deSolve]; };
···
   C50 = derive { name="C50"; version="0.1.0-19"; sha256="1x8a284w1fffvvd7mx3xn1i7sr266wq7j6k0d0v8rln2fwilkd07"; depends=[]; };
   ca = derive { name="ca"; version="0.55"; sha256="1mk6hias079ys4khlq0mb4z80mcqhml2n8fdiyfcxy61vj522yb8"; depends=[]; };
   cabootcrs = derive { name="cabootcrs"; version="1.0"; sha256="0a6y04jq837k1pk8b9nhgz7rima7s8jid6vdjyfvrqshgaiabg1q"; depends=[]; };
-  cacher = derive { name="cacher"; version="1.1-2"; sha256="17zw30mpi1vrgk1jsxqpw2id3k78rrs6i55kq0yl64aikmq91c0v"; depends=[]; };
-  cacheSweave = derive { name="cacheSweave"; version="0.6-1"; sha256="0w30ryd24x2z204k8j41knayq3ax4b5zf0ai1andgdzjvf5jmmas"; depends=[filehash stashR digest]; };
   cacIRT = derive { name="cacIRT"; version="1.3"; sha256="1qd9qw47d9dmxhnva3ik62q5rfcw0pd1ha1y689345nl05wysjkh"; depends=[]; };
   CaDENCE = derive { name="CaDENCE"; version="1.2.1"; sha256="1l6mqra36syvpg9aqh4p6ndj3yj50rabx8hh788zpy4n57m5lpv7"; depends=[]; };
   CADFtest = derive { name="CADFtest"; version="0.3-2"; sha256="00nsnzgjwkif7mbrw7msswjxhi9aysjdx3qg3i4mdmj1rmp7c4dc"; depends=[dynlm sandwich tseries urca]; };
···
   calibrator = derive { name="calibrator"; version="1.2-6"; sha256="1arprrqmczbhc1gl85fh37cwpcky8vvqdh6zfza3hy21pn21i4kh"; depends=[emulator cubature]; };
   CALINE3 = derive { name="CALINE3"; version="1.0-2"; sha256="07w1kb7wqdi1qslpvpmqcmq6da4h7sgwv3aih4brdprym61c3rkm"; depends=[]; };
   calmate = derive { name="calmate"; version="0.11.0"; sha256="1zy836nk607ra67q0x7yc4czkcn9ffzlipzhr4mhjk6l5d8sys2q"; depends=[R_utils aroma_core MASS R_methodsS3 R_oo matrixStats R_filesets]; };
-  CAMAN = derive { name="CAMAN"; version="0.71"; sha256="1pfdypzj0s1nrlyzlam7pprggiriksfdri5xpmm43gmx3bybx8zb"; depends=[sp mvtnorm]; };
+  CAMAN = derive { name="CAMAN"; version="0.72"; sha256="10qikirv73d03ssg3sb6w3ih92ms5726b5lqw3x7r5rpbl9179rh"; depends=[sp mvtnorm]; };
   camel = derive { name="camel"; version="0.2.0"; sha256="0krilird8j69zbll96k46pcys4gfkcnkisww138wslwbicl52334"; depends=[lattice igraph MASS Matrix]; };
   cancerTiming = derive { name="cancerTiming"; version="2.0.0"; sha256="0p5hxzhql2rlyx334d8km676va50ql73kxsqjr15q80z7zffyq9d"; depends=[LearnBayes]; };
   candisc = derive { name="candisc"; version="0.6-5"; sha256="0rbmfyhnyaq1j7sql2sgi47ahrggbb71z2z5pw2gg16kd2f465qk"; depends=[car heplots]; };
-  cape = derive { name="cape"; version="1.2"; sha256="01bh8lngp346w6pjvbw4jllbr8f9f8ypsxv6c9p6zv5l7w5yzri8"; depends=[corpcor evd qpcR Matrix igraph fdrtool]; };
   caper = derive { name="caper"; version="0.5.2"; sha256="1l773sxmh1nyxlrjz8brnwhwraff826scwixrqmgdciqk7046d35"; depends=[ape MASS mvtnorm]; };
   capm = derive { name="capm"; version="0.5"; sha256="1pal7v965zyl52fivdqn30w570gvhxjsnafml6jz16x4kszw5jar"; depends=[deSolve FME survey ggplot2 reshape2 shiny rgdal maptools sp]; };
   capme = derive { name="capme"; version="1.3"; sha256="0d4acwp4y8djcry8gr34dx3h8bn8sj3z2di5zl9657czw5289zm8"; depends=[lpSolve]; };
   capushe = derive { name="capushe"; version="1.0"; sha256="0dwxaiqnz0qbsk4icjapklaa9bpjfl4gqvk1f92livy97jmf1r44"; depends=[MASS]; };
   capwire = derive { name="capwire"; version="1.1.4"; sha256="18a3dnbgr55yjdk6pd7agmb48lsiqjpd7fm64dr1si6rpgpl4i9c"; depends=[]; };
-  car = derive { name="car"; version="2.0-20"; sha256="0dbq3ndw9srrf7pp7wl8gj7cwcgggnjh4i6c9aqmrap7wnaa14fb"; depends=[MASS nnet]; };
+  car = derive { name="car"; version="2.0-21"; sha256="1p6dbwzysp8h09081p4zf4dqwak9qs55g3m4klrcr4vzw87n3mzg"; depends=[MASS nnet]; };
   CARBayes = derive { name="CARBayes"; version="3.0"; sha256="0wflay6k159cw8149qb4ib1mlpsbgddlbkiyfxd4qz3vwl06dg3q"; depends=[MASS Rcpp truncdist spam coda]; };
   CARBayesST = derive { name="CARBayesST"; version="1.0"; sha256="1mn2g9i39pzq0jvz1qml41mf1bj6qx3cp5c3hszgm8vbamc2a1xx"; depends=[Rcpp truncdist coda]; };
-  carcass = derive { name="carcass"; version="1.2"; sha256="104lpqs65h9z8d3bl0m1f30anadk9hq4sg2ahgppm5n3d4yhcdl5"; depends=[lme4 survival expm arm]; };
+  carcass = derive { name="carcass"; version="1.3"; sha256="1psxdxdqlc999xylizj5vg1p1pzyrikg9gjqvpv4k0q9b5h0nrpj"; depends=[lme4 survival expm arm MASS]; };
   cardidates = derive { name="cardidates"; version="0.4.5"; sha256="1zw8c8jiq8bz748xppwj88z1882qk7k2r0k2gkrsvw7b6c9h35pb"; depends=[boot pastecs]; };
   care = derive { name="care"; version="1.1.5"; sha256="1gvx4a88ci7428sxna74jxfi8ykzjgnarc18mvm8h3mk7i03r4mj"; depends=[corpcor]; };
   CARE1 = derive { name="CARE1"; version="1.1.0"; sha256="1zwl4zv60mrzlzfgd7n37jjlr0j918a8ji36n94s5xw8wwipiznw"; depends=[]; };
-  caret = derive { name="caret"; version="6.0-30"; sha256="11298kqidv69zfaqzf7px539dchvkk64ilxy8k55nx37pn665v01"; depends=[lattice ggplot2 car reshape2 foreach plyr nlme BradleyTerry2]; };
+  caret = derive { name="caret"; version="6.0-35"; sha256="05fnz6hwckbvfnw9i3sfgnni1fyjg52ql14i4vrpg7ay5cawrlxa"; depends=[lattice ggplot2 car reshape2 foreach plyr nlme BradleyTerry2]; };
   caribou = derive { name="caribou"; version="1.1"; sha256="0ibl3jhvsgjfcva0113z0di9n5n30bs90yz0scckfv1c0pjhn4xd"; depends=[]; };
   CarletonStats = derive { name="CarletonStats"; version="1.1"; sha256="18pd1hi8bnbv0sdixw746xvdg9szvng422yj12mk0k50v60403xg"; depends=[]; };
   caroline = derive { name="caroline"; version="0.7.6"; sha256="1afxxbrd7w628l4pxdmvwbs7mbgxlhnfq3nxk2s93w47gn7r9fp7"; depends=[]; };
   CARramps = derive { name="CARramps"; version="0.1.2"; sha256="097xxvql6qglk6x4yi7xsvr15n0yj21613zv003z0mhgvqr1n5vf"; depends=[]; };
   CARrampsOcl = derive { name="CARrampsOcl"; version="0.1.4"; sha256="1sdrir7h7xl1imipm9b71vca062dxqsqd8mg3w9f3s80x2aghxl8"; depends=[OpenCL fields]; };
   caschrono = derive { name="caschrono"; version="1.4"; sha256="1l9hmsacynh73kh14jrp7a42385v78znn9ll1jchzgkyz2x4dibw"; depends=[forecast Hmisc its timeSeries]; };
-  caseMatch = derive { name="caseMatch"; version="1.0"; sha256="1nq1ca59akdsp1a5j3y252zy3fcw5908a7k83k93gjy7j1m7q6f8"; depends=[]; };
+  caseMatch = derive { name="caseMatch"; version="1.0.1"; sha256="0r8z0dfhaqc5wmcrd1mgq1bn71h41fhk5q3ihffg0s9qsix4pk7j"; depends=[]; };
   cat = derive { name="cat"; version="0.0-6.5"; sha256="1gv7chqp6kccipkrxjwhsa7yizizsmk4pj8672rgjmpfcc64pqfm"; depends=[]; };
   catdata = derive { name="catdata"; version="1.2"; sha256="0907sr7kjlr47sxaxvkk3za5j2rn6zvckkgjc9inr5hrn5nv5hsv"; depends=[MASS]; };
   CatDyn = derive { name="CatDyn"; version="1.0-5"; sha256="1syc40256104nm8n7h5b7w3ia2iya0y47p1sdxk8g1dy4l5wnalm"; depends=[optimx BB]; };
   catenary = derive { name="catenary"; version="1.1"; sha256="0khdk61fh8ngr70qf9i2655h5nblj98r8zl724ljv1cjb5x1vphv"; depends=[ggplot2 boot]; };
+  CateSelection = derive { name="CateSelection"; version="1.0"; sha256="194lk6anrb05gaarwdg8lj5wm6k61b4r702cja3nf3z91i8paqi7"; depends=[]; };
   cati = derive { name="cati"; version="0.8"; sha256="0kz58dyq5jacf2w2nvhyh3dvk0vgcrm7fjfirywykbrbh5srfw2a"; depends=[nlme ade4 ape e1071 mice rasterVis hypervolume]; };
-  catIrt = derive { name="catIrt"; version="0.4-2"; sha256="1s6r85ylznhsf4wwlf2rlyhfp5p84lkp0mxpg1p9bwrqnhahygmk"; depends=[numDeriv sfsmisc]; };
+  catIrt = derive { name="catIrt"; version="0.5-0"; sha256="09010z1q96nbnpys6mybspaqy57lvgd2cvwgnfijzgx3kl87pwnl"; depends=[numDeriv]; };
   catnet = derive { name="catnet"; version="1.14.3"; sha256="099vxi3fy5y4w635mqmbzsyqiswsw76kz3l5vgg8ckrj1cqshh5z"; depends=[]; };
-  caTools = derive { name="caTools"; version="1.17"; sha256="00jgbna2dm99y5hwk3y28ng2w2c0vxrx4rlz6mhd15z4lsdx1ys6"; depends=[bitops]; };
-  catR = derive { name="catR"; version="3.1"; sha256="03mp0gmzjdxy5ashlir3l6id5r7iw9mvmwvi12jg2byggm5blby3"; depends=[]; };
+  caTools = derive { name="caTools"; version="1.17.1"; sha256="1x4szsn2qmbzpyjfdaiz2q7jwhap2gky9wq0riah74q0pzz76ank"; depends=[bitops]; };
+  catR = derive { name="catR"; version="3.2"; sha256="1cj4dal2yyfcapr8d9mmr3hzcvl5b2w12z1daw9iz79fizvx9ji8"; depends=[]; };
   catspec = derive { name="catspec"; version="0.97"; sha256="1crry0vg2ijahkq9msbkqknljx6vnx2m88bmy34p9vb170g9dbs1"; depends=[]; };
+  causaleffect = derive { name="causaleffect"; version="1.0"; sha256="1xg0dczqk10nnybm3i9rcnsqr34y86dngb7p6vl1n7bhxrn580jf"; depends=[igraph XML]; };
   CausalGAM = derive { name="CausalGAM"; version="0.1-3"; sha256="0g68m2kxixwr7rx65r57m1n0qa161igc428zh9rj91fg6h4pdq4w"; depends=[gam]; };
   causalsens = derive { name="causalsens"; version="0.1"; sha256="1v72zjplsa073f92qdza1zvwa1fwxlpmh8f6w5z8qcyiwqcbmifr"; depends=[]; };
   Causata = derive { name="Causata"; version="4.2-0"; sha256="04lndjy4rdf063z75zv42b000z06ffnr91pv2sql1ks6w60zmh1m"; depends=[XML R_utils rjson RMySQL RCurl stringr yaml boot foreach data_table glmnet ggplot2]; };
   CAvariants = derive { name="CAvariants"; version="2.1"; sha256="105bj6r6i7xz95lr5g4ld9xfgyq1dn15lw117jivx76z3k2zpi59"; depends=[]; };
   cba = derive { name="cba"; version="0.2-14"; sha256="067rm1rfz0rrq8xkzibd81pwvc9rx7ki46bncim4j5ra6i9pn24n"; depends=[proxy]; };
-  CBPS = derive { name="CBPS"; version="0.8"; sha256="0a619sgr4iv66y16a7bfywxhniaxsrixr6pqwn88hj0j0k5b312i"; depends=[MASS MatchIt nnet numDeriv]; };
+  CBPS = derive { name="CBPS"; version="0.9"; sha256="08pc50fndpx6xvxkvqdklrp6v98w2j387frq08nlglcbfjk22i6x"; depends=[MASS MatchIt nnet numDeriv]; };
   CCA = derive { name="CCA"; version="1.2"; sha256="00zy6bln22qshhlll0y0adnvb8wa1f7famqyws71b6pcnwxki5ha"; depends=[fda fields]; };
   CCAGFA = derive { name="CCAGFA"; version="1.0.3"; sha256="1qicxrrwwd9il894v11lmmf4i88j72nyqm3z8iz9f7m17l9yiwwf"; depends=[]; };
   ccaPP = derive { name="ccaPP"; version="0.3.0"; sha256="1wj5yij02372xarhvxsnh43v0l6xb2p8rflmskw6x86vpcdqd6zw"; depends=[Rcpp pcaPP robustbase RcppArmadillo]; };
···
   cccrm = derive { name="cccrm"; version="1.1"; sha256="0q7vxzj3lblz5ddgzm8z99k0b0z194963hx96bbkqm4rv705dgb0"; depends=[nlme gdata]; };
   ccda = derive { name="ccda"; version="1.0"; sha256="13wxzwpld55rbpbslrgm2f7gamvkbmkaic7xrp1nn4l3lvg236dy"; depends=[MASS]; };
   ccgarch = derive { name="ccgarch"; version="0.2.3"; sha256="0angffla3sk9i86v6bbsav95fp3mz5yvq7qfv0fx2v0nd2cx116w"; depends=[]; };
-  cclust = derive { name="cclust"; version="0.6-18"; sha256="1lyk205i6q0s194r4l575l531c60kdql6p8aqhjjfkjfhczh5hq3"; depends=[]; };
+  cclust = derive { name="cclust"; version="0.6-19"; sha256="11lzzpr65jw7s0419bdy3w7cq97ysvv52ijb1wgqpa48wh1qbqqd"; depends=[]; };
   CCM = derive { name="CCM"; version="1.1"; sha256="0gya1109w61ia6cq3jg2z5gmvjkv9xg71l2rxhrrf6bx1c2nsrq6"; depends=[]; };
   CCMnet = derive { name="CCMnet"; version="0.0-2"; sha256="1x5xjnnyr31yq9cgqfrvg71x7mmc2c54r59fv0az49njh3yg3vja"; depends=[sna network ergm]; };
   CCP = derive { name="CCP"; version="1.1"; sha256="07jxh33pb8llk1gx4rc80ppi35z8y1gwsf19zrca9w91aahcs8cx"; depends=[]; };
   CCpop = derive { name="CCpop"; version="1.0"; sha256="10kgw3b98r0kn74w89znq6skgk8b3ldil6yb0hn5rlcf6lazjzca"; depends=[nloptr]; };
-  CCTpack = derive { name="CCTpack"; version="1.2"; sha256="13350yqfj8fdmlhi2il0jvjfa58q6xrjw6jjwnla0y0kh1hgycb3"; depends=[R2jags rjags psych mvtnorm polycor MASS]; };
+  CCTpack = derive { name="CCTpack"; version="1.4"; sha256="09s2ysqsz158lrah44rwvs3nlhyqlvwcj6aar2p79flf4xxdwsvk"; depends=[R2jags rjags psych mvtnorm polycor MASS]; };
   cda = derive { name="cda"; version="1.5.1"; sha256="09a2jb25219hq6if3bx03lsp94rp2ll9g73dhkdi665y7rlhgqwh"; depends=[dielectric Rcpp statmod randtoolbox reshape2 plyr]; };
   cdb = derive { name="cdb"; version="0.0.1"; sha256="1rdb4lacjcw67apdyiv7cl1xvv9d1mrzck1qk605n6794k7wf2ys"; depends=[bitops]; };
+  cdcsis = derive { name="cdcsis"; version="1.0"; sha256="1fxdsaqpjhpffn2fxddfcrx8wxwyvfws6rxkpp57g25980xiyzkd"; depends=[ks]; };
   CDFt = derive { name="CDFt"; version="1.0.1"; sha256="0sc8ga48l3vvqfjq3ak5j1y27hgr5dw61wp0w5jpwzjz22jzqbap"; depends=[]; };
   CDLasso = derive { name="CDLasso"; version="1.1"; sha256="0n699y18ia2yqpk78mszgggy7jz5dybwsi2y56kdyblddcmz1yv7"; depends=[]; };
-  CDM = derive { name="CDM"; version="3.3-24"; sha256="1s6bp45b9y80i3ildha2v4zb41rpf0vxrwc7rh38pzalvvyawgq7"; depends=[mvtnorm MASS psych polycor sfsmisc Rcpp]; };
+  CDM = derive { name="CDM"; version="3.4-21"; sha256="1qm144p6p0gph9xvmm6sdfyrrj3ila6p6zvwk9ybpga01x5xpijk"; depends=[mvtnorm MASS psych polycor sfsmisc Rcpp]; };
   CDNmoney = derive { name="CDNmoney"; version="2012.4-1"; sha256="1bnfsygbzdd70m5s9qq7524b1fybdws46axxjbw9dhwqpr8w85id"; depends=[]; };
   CDVine = derive { name="CDVine"; version="1.2"; sha256="1qfjbzdfz2dydkfw3b0jjma4csn62177j5sgzh6rszf0nifsi97g"; depends=[MASS mvtnorm igraph]; };
+  CEC = derive { name="CEC"; version="0.9.1"; sha256="17zgb6qwxhm0drwf1d4nwifqalx83xhcgmhidj9zqvvz9nn6qib3"; depends=[]; };
   cec2005benchmark = derive { name="cec2005benchmark"; version="1.0.3"; sha256="1fc833ji557y2vb6snlxh90gz1n7fxjfkwjmdcmasj1sfzaalsjy"; depends=[]; };
   cec2013 = derive { name="cec2013"; version="0.1-4"; sha256="199r6b1gkay9a7v1x7v2w8xmxmafvizdyb1dkiq3qylsqvhq994d"; depends=[]; };
   celestial = derive { name="celestial"; version="1.1"; sha256="19yxaa63px9byn5k2k2qr89f5vy73cqb5l4zq4qj1v27g06k5dy7"; depends=[]; };
···
   censNID = derive { name="censNID"; version="0-0-1"; sha256="1ij5ci6nkqf0rq51vyh4jw5sr3y46yndfkjmwl78ppdj66axxir5"; depends=[]; };
   censReg = derive { name="censReg"; version="0.5-20"; sha256="15k7iq4275dyah3r47vgxsx6g6mr7ma53lkv6d1n89bczzys72kx"; depends=[maxLik glmmML sandwich miscTools]; };
   CensRegMod = derive { name="CensRegMod"; version="0.0"; sha256="0vfkyj2mx5l1pmcah8zilxrjlb6iign1by4ydjq8ddk1zyi242sw"; depends=[]; };
+  cents = derive { name="cents"; version="0.1-41"; sha256="03ycbd0c8b7danbblaixg6sm7msr9ixkanqswczqa8n2frhjfgj0"; depends=[]; };
   CePa = derive { name="CePa"; version="0.5"; sha256="1y2q72j8bqx509i62a2x9j40rj5bkpgx4z6fwj05ibazc1441asd"; depends=[igraph snow]; };
   cepp = derive { name="cepp"; version="1.0"; sha256="0lw3qr0vp0qbg2b62abhi1ady1dwig68m4nzqnjnk3lqxzp0fs8f"; depends=[trust randtoolbox]; };
   CerioliOutlierDetection = derive { name="CerioliOutlierDetection"; version="1.0.8"; sha256="0n67y7ah496wck9hlrphya9k753gk44v7zgfz4s2a5ii49739zqi"; depends=[robustbase]; };
   cfa = derive { name="cfa"; version="0.9-3"; sha256="0pl1mxv6jxn3mvlh75gr8as0daklyr7gkh37fcgmn2bwi973sspy"; depends=[]; };
   CfEstimateQuantiles = derive { name="CfEstimateQuantiles"; version="1.0"; sha256="1qf85pnl81r0ym1mmsrhbshwi4h1iv19a2wjnghbylpjaslgxp6i"; depends=[]; };
-  CFL = derive { name="CFL"; version="0.1"; sha256="1vi1iiyg7qga7knpqgf30zfzy46aqzs8digkv5933lc2xrv03ap1"; depends=[]; };
   cg = derive { name="cg"; version="1.0-1"; sha256="0qi3xzjwx303b9m1sddyvz1raw78m5gy9bxqy08hyja2gqj8v855"; depends=[Hmisc VGAM MASS lattice survival multcomp nlme]; };
-  cgam = derive { name="cgam"; version="1.1"; sha256="1dy23ix0ll0riqpdqxhf86fmw4m8mgqmp6m1c4nyhwk2z2adxd3k"; depends=[coneproj]; };
-  cgAUC = derive { name="cgAUC"; version="1.1.2"; sha256="1y3q4hmkd6wbn4zjgclla3jif272sn4vv63ijxnfrsylzy02xhln"; depends=[]; };
+  cgam = derive { name="cgam"; version="1.2"; sha256="14vl608bf223jclaxfb6i7irfn9g2dqp76fhw82j4h7w4l47i1c3"; depends=[coneproj]; };
+  cgAUC = derive { name="cgAUC"; version="1.2.1"; sha256="172f9rkfhv4xzwpw8izsnsdbcw9p3hvxhh0fd8hzlkil7vskr3k8"; depends=[Rcpp]; };
   cgdsr = derive { name="cgdsr"; version="1.1.30"; sha256="0c8n2c6gqhk5klrxmmyf77czn2zwmm1f9cbp8n8yrhdcdqminznm"; depends=[R_oo R_methodsS3]; };
   cggd = derive { name="cggd"; version="0.8"; sha256="06z0mrxxc02parn9vkjv89qq4yqmsccsy319fi6c5iarssyvin1r"; depends=[]; };
   cgh = derive { name="cgh"; version="1.0-7.1"; sha256="1fgjz43bgnswlyvrm669x697lybq3jyzz4l8ppgxqwxp4p4d2yqn"; depends=[]; };
   cghFLasso = derive { name="cghFLasso"; version="0.2-1"; sha256="0b1hnjf9g0v47hbz0dy9m6jhcl1ky20yyhhmm8myng2sndcpjsbf"; depends=[]; };
   cghseg = derive { name="cghseg"; version="1.0.2"; sha256="0nz52wlgpl9r9pa41lz7nzk35fvcn3zr0gyliiw8q1nyxl2m0q1s"; depends=[]; };
+  CGP = derive { name="CGP"; version="2.0-2"; sha256="1mggv3c8525vbdfdc3yhpp4vm4zzdvbwyxim29zj0lzwjf9fkgqk"; depends=[]; };
   cgwtools = derive { name="cgwtools"; version="1.1"; sha256="11ryc20iqz0xwpq0cfjy37f6mnyrwvhf7kkf574j0v9fn6zg2jic"; depends=[]; };
-  ChainLadder = derive { name="ChainLadder"; version="0.1.7"; sha256="06jgxhjlvzcgfm7dnzd81ycf1xx7qcyvk5541qmnvniwqppfvm19"; depends=[systemfit Matrix actuar Hmisc statmod reshape2 MASS lattice tweedie]; };
+  ChainLadder = derive { name="ChainLadder"; version="0.1.8"; sha256="0ih0wb82i8f7hz3qyxhqzn9b6v684f66cga5w07qzv92788nzh8g"; depends=[systemfit Matrix actuar Hmisc statmod reshape2 MASS lattice tweedie]; };
   changeLOS = derive { name="changeLOS"; version="2.1"; sha256="1bld2phnvcwfpqbkg1ycjci4i4dc4di8gjckbqjp997zyr42nnay"; depends=[survival]; };
   changepoint = derive { name="changepoint"; version="1.1.5"; sha256="090rak3ydlh92w0mpp2sjjx4m9x33clcs77waj20gzxbq38mqdci"; depends=[zoo]; };
   ChargeTransport = derive { name="ChargeTransport"; version="1.0.2"; sha256="0mq06ckp3yyj5g1z2sla79fiqdk2nlbclm618frhqcgmq93h0vha"; depends=[]; };
   CHAT = derive { name="CHAT"; version="1.1"; sha256="1hl4xr4lkvb7r36gcbgax6ipqc3rsvn1r03w7fk9gf9bbyg7bkhg"; depends=[DPpackage]; };
   CHCN = derive { name="CHCN"; version="1.5"; sha256="18n8f002w0p0l1s5mrrsyjddn10kdbb6b7jx1v9h1m81ifdbv0xb"; depends=[bitops RCurl]; };
   cheb = derive { name="cheb"; version="0.3"; sha256="0vqkdx7i40w493vr7xywjypr398rjzdk5g410m1yi95cy1nk4mc7"; depends=[]; };
-  chebpol = derive { name="chebpol"; version="1.3-1040"; sha256="13x6li7cs72pnhxxdigg6r9f0nay89hldzh76vp0hi0i2y9vw0dz"; depends=[]; };
+  chebpol = derive { name="chebpol"; version="1.3-1367"; sha256="0w1yfnag0sjqjn7g5yn3wd19kkwzcchb491335h70rm360m1kr0y"; depends=[]; };
   CheckDigit = derive { name="CheckDigit"; version="0.1-1"; sha256="0091q9f77a0n701n668zaghi6b2k3n2jlb1y91nghijkv32a7d0j"; depends=[]; };
-  checkmate = derive { name="checkmate"; version="1.2"; sha256="0n1qqyzwyxg6ymibxpbr84gg5bnrwfgw9klwyyvlq1bhd3qs3njn"; depends=[]; };
-  cheddar = derive { name="cheddar"; version="0.1-625"; sha256="1qdxid6h7kyja0ac4v6ml2s6vw5lhrlchcz8lbf37gs9bpx6b4jc"; depends=[]; };
+  checkmate = derive { name="checkmate"; version="1.5.0"; sha256="0zvz2sy7ykx94dc7h8g67vmkphd6x6b133fqcm8xznfxq6kfd972"; depends=[]; };
+  cheddar = derive { name="cheddar"; version="0.1-626"; sha256="16dl267zbqnix739827mvdgchg5xzgz5q14hh8cw2fq089frjlz9"; depends=[]; };
   chemCal = derive { name="chemCal"; version="0.1-34"; sha256="0sn0mhp2d9a9rddfpkiv1pkrmvnv4sy18c1x2ks0lwpaklg78fbs"; depends=[]; };
   chemometrics = derive { name="chemometrics"; version="1.3.8"; sha256="0vd5p2qhd17hr9psk6pg4jvcadz2pjffkjaffva4spa7m7qpp5ss"; depends=[class e1071 gclus lars MASS mclust nnet pcaPP pls rpart robustbase som]; };
   ChemometricsWithR = derive { name="ChemometricsWithR"; version="0.1.8"; sha256="084da2hx6agryw7bv6img10pqmsdz2mpihbrj6j081lammrik4fj"; depends=[ChemometricsWithRData MASS pls]; };
   ChemometricsWithRData = derive { name="ChemometricsWithRData"; version="0.1.3"; sha256="14l1y4md8hxq8gvip5vgg07vcr0d9yyhm5ckhzk8zwprdabn9a10"; depends=[]; };
-  chemosensors = derive { name="chemosensors"; version="0.7.7"; sha256="1yi0d69nxknca3k7pnxppgjaqyzlc1ksxaa7w31favq0xbdw508n"; depends=[pls plyr reshape2 ggplot2 LearnBayes quadprog RColorBrewer]; };
+  chemosensors = derive { name="chemosensors"; version="0.7.8"; sha256="0zphfag0q6zskd301z1dldazzxr2fam6h41cpyivphaxpaljiv0m"; depends=[pls plyr reshape2 ggplot2 LearnBayes quadprog RColorBrewer]; };
   ChemoSpec = derive { name="ChemoSpec"; version="2.0-2"; sha256="01zng3nhsynj8kbnk7aisj1803q9svd9n6jnnl0vb82lsb29bfw7"; depends=[pls amap chemometrics robustbase RColorBrewer plyr pcaPP mvtnorm mvoutlier rgl R_utils mclust MASS baseline IDPmisc gsubfn lattice seriation]; };
   cherry = derive { name="cherry"; version="0.5-10"; sha256="0fs4p5k1lwwlin5fj9z91aw59ybp60phjk293imizg6vpai5h39p"; depends=[bitops lpSolve Matrix]; };
   chillR = derive { name="chillR"; version="0.54"; sha256="1qcwspww5nvp6nh26ly6ckqd0jzq4fkq5svjj5a55pvk04xk9frs"; depends=[pls Kendall spam fields]; };
-  chipPCR = derive { name="chipPCR"; version="0.0.7"; sha256="0acj8z92zbfv8b14j31h7vlaf8k4w44z8gcg8vcfhxgskfajcwk0"; depends=[MASS outliers ptw quantreg Rfit robustbase shiny signal]; };
+  chipPCR = derive { name="chipPCR"; version="0.0.8-3"; sha256="1qslzbxirpbiqlfcvjrs7z6i4a86a04b9fgfm3ngmkv32ai0zajz"; depends=[lmtest MASS outliers ptw quantreg Rfit robustbase shiny signal]; };
   chngpt = derive { name="chngpt"; version="2014.5-29"; sha256="0i8hz8cixy3fx9cpprraqpadrs835zna8y64irp85xhckdrv9xzv"; depends=[kyotil MASS]; };
   CHNOSZ = derive { name="CHNOSZ"; version="1.0.3.1"; sha256="0cmirnb8jkaxnscpkwm2a8yyzl9zaf3q323avpgg7fwwhr6c1l19"; depends=[]; };
   ChoiceModelR = derive { name="ChoiceModelR"; version="1.2"; sha256="0dkp3354gvrn44010s8fjbmkpgn1hpl4xbfs5xslql8sk8rw0n2c"; depends=[]; };
   choplump = derive { name="choplump"; version="1.0-0.3"; sha256="10nkkcmpay4rcqbkdhlksnxqb177j5bjpsffyy6q5dbl7nf7whx1"; depends=[]; };
-  chords = derive { name="chords"; version="0.67"; sha256="0dj9bbl5abdvvfrn17xxnrnrlvdxw4m841ds37a6pf8dzprs1gdv"; depends=[]; };
-  choroplethr = derive { name="choroplethr"; version="1.7.0"; sha256="1sq518zb6pv1sg7vb7ml4wsfpk1a5a73mcmdz8an1lnwnqbywsmy"; depends=[ggplot2 scales plyr Hmisc acs stringr]; };
+  chords = derive { name="chords"; version="0.90"; sha256="0wz5glm15615xb3cicc0m34zg78qzng3lpmysswbrfhc8x4kkchh"; depends=[MASS]; };
+  choroplethr = derive { name="choroplethr"; version="2.0.0"; sha256="14h07q2plw561dh7q20869yw7rvyhdv1vrcmficqcpy0xw0lhjix"; depends=[scales Hmisc stringr ggplot2 dplyr R6 acs WDI]; };
+  choroplethrMaps = derive { name="choroplethrMaps"; version="1.0"; sha256="00dgwikfxm1p1dqz1ybsxj1j8jcmrwa08m2d3zsww2invd55pk7g"; depends=[]; };
   chromoR = derive { name="chromoR"; version="1.0"; sha256="1x11byr6i89sdk405h6jd2rbvgwrcvqvb112bndv2rh9jnrvcw4z"; depends=[haarfisz gdata]; };
   chron = derive { name="chron"; version="2.3-45"; sha256="0jkanbisi1bxh35rg0i6sl82f8r9v8va8mf8hknfvwv7p7n3ddpx"; depends=[]; };
   CHsharp = derive { name="CHsharp"; version="0.3"; sha256="0aa9v6yih6qmqsmc8zsl8k1wqsp3sp2bfwri3d37k06vfj7gwbh0"; depends=[scatterplot3d KernSmooth]; };
   CIDnetworks = derive { name="CIDnetworks"; version="0.6.0"; sha256="0bx1wgcsbkg6zqza435fd11kaqkdspl4mlnjjjca8j0gcfvdjxgc"; depends=[mvtnorm msm Rcpp igraph numDeriv pbivnorm]; };
   CIFsmry = derive { name="CIFsmry"; version="1.0.1"; sha256="118vyiiy4iqn86n9xf84n5hrwrhzhr1mdsmyg9sm6qq6dm7zg6la"; depends=[]; };
   cin = derive { name="cin"; version="0.1"; sha256="1pwvy5nh5nrnysfqrzllb9fcrpddqg02c7iw3w9fij2h8s2v6kq5"; depends=[]; };
-  CINID = derive { name="CINID"; version="1.0"; sha256="0xa9zbd578ac5gc2mm7k5yisw5sx8x259c5gwyy6frpkldhbwldn"; depends=[]; };
-  CINOEDV = derive { name="CINOEDV"; version="1.0"; sha256="1a6c0y7nzqmb0x5baf54fyddnhi94ixybwm3mgim45z2jzak6435"; depends=[R_matlab igraph ggplot2 reshape2]; };
-  CircE = derive { name="CircE"; version="1.0"; sha256="1fik612iggqv9hvp9nmpx0h6g6s6vfk99z8anvqkk5ify5690g1x"; depends=[]; };
-  circlize = derive { name="circlize"; version="0.1.0"; sha256="0v5czgs21wn261bw686nbsn3c15ssdkx3frclwqcvqlk61xfghqr"; depends=[]; };
+  CINID = derive { name="CINID"; version="1.2"; sha256="0pkgzi2j0045p10kjvnq8f4j1agzrqfw0czvvfrzj9yjfpj8xc99"; depends=[]; };
+  CINOEDV = derive { name="CINOEDV"; version="1.1"; sha256="0hxqj5wvb4ib4zmpsgf497vlsy8q3mkr8vx93yswy3hk8gf94s9f"; depends=[R_matlab igraph ggplot2 reshape2]; };
+  CircE = derive { name="CircE"; version="1.1"; sha256="14bja3zv9wg389m6khmsy3q12hhnfcp49rvrmw47y6fh5m7ihrz2"; depends=[]; };
+  circlize = derive { name="circlize"; version="0.1.2"; sha256="12ii2ilh233y3sd951ff9mdfi0ng2f2ad49p0f32dhm9rbc5lx3k"; depends=[GlobalOptions]; };
   CircNNTSR = derive { name="CircNNTSR"; version="2.1"; sha256="1rl17kw6bl5xf7pgsc4im12i2kqz4a3b11vzzlb6wfl5yck6iff5"; depends=[]; };
   CircStats = derive { name="CircStats"; version="0.2-4"; sha256="1f2pf1ppp843raa82s2qxm3xlcv6zpi578zc4pl0d7qyxqnh603s"; depends=[MASS boot]; };
   circular = derive { name="circular"; version="0.4-7"; sha256="1kgis2515c931ir76kpxnjx0cscw4n09a5qz1rbrhf34gv81pzqw"; depends=[boot]; };
···
   class = derive { name="class"; version="7.3-11"; sha256="1j6wqirih9x6q50vq21543np4i99ia6ih2ffriiw1gms8xmdfrsk"; depends=[MASS]; };
   classGraph = derive { name="classGraph"; version="0.7-4"; sha256="08cid5bdbciyijlzkx3684gx0cyzcj8myawf4dhcrz00jqrg8v60"; depends=[]; };
   classifly = derive { name="classifly"; version="0.4"; sha256="0mw1vcas0gr1r4yvh0j02zhk7kp5342r0bhhg776hqgqdczgh5zj"; depends=[class plyr]; };
-  classify = derive { name="classify"; version="1.2"; sha256="1c1919phhn3xlm807408hhryy1ifm8vf68zcb0gj3adiczpj5xcy"; depends=[Rcpp plyr ggplot2 lattice R2jags reshape2]; };
+  classify = derive { name="classify"; version="1.3"; sha256="0134h12h6v06d7ldj9qgqjhh5f5ap98pvr0v6d4k8dqndnn0pggy"; depends=[Rcpp plyr ggplot2 lattice R2jags reshape2]; };
   classInt = derive { name="classInt"; version="0.1-21"; sha256="1sld7bw1x2i8qqj0fbavifl9ni8724fg2wrwjyg657ib8f2yqj5z"; depends=[e1071 class]; };
+  classyfire = derive { name="classyfire"; version="0.1-0"; sha256="0nnmwx11d1hghlgzrpf5nvjflxdhjhwd6nqqfv498i86dff53qkp"; depends=[snowfall e1071 boot neldermead ggplot2 optimbase]; };
   clere = derive { name="clere"; version="1.1"; sha256="1jna5dqy47mldd557qxl7vr59v5lalhligvm3c4k6b2dfararhfr"; depends=[Rcpp]; };
-  clhs = derive { name="clhs"; version="0.5-1"; sha256="09165qcnlwz6aaafq4lzzpm7id15wgfbz3am9gfp2g5fyh0irsr2"; depends=[ggplot2 sp raster reshape2 plyr scales]; };
-  ClickClust = derive { name="ClickClust"; version="0.1.1"; sha256="1mgim5z4j0lmjlazqqigc88r41ciqnz9d49irm9b2bdjwg2rpilw"; depends=[]; };
+  clhs = derive { name="clhs"; version="0.5-4"; sha256="0535mpl1dbm9ij1dvj8dsmv4fickdg47by1mvf71lgfk5mjxy5nc"; depends=[ggplot2 sp raster reshape2 plyr scales]; };
+  ClickClust = derive { name="ClickClust"; version="1.1.2"; sha256="0j3838w3kvzyzgfiz0la65fhpgi25qp3kky5iiy4lciqhv5y8ikh"; depends=[]; };
   clickstream = derive { name="clickstream"; version="1.1.2"; sha256="1l59411jsph6v4rkwanbjcgjcyknywl7ri0hh7z957v02h4m7as1"; depends=[igraph plyr reshape2 Rsolnp]; };
   climdex_pcic = derive { name="climdex.pcic"; version="1.1-1"; sha256="1payygvw327qjab9vzivqd21f5w0gwq3f2jjpmkk89fn7rznz7y2"; depends=[PCICt caTools Rcpp]; };
   clime = derive { name="clime"; version="0.4.1"; sha256="0qs9i7cprxddg1cmxhnmcfhl7v7g1r519ff2zfipxbs59m5xk9sf"; depends=[lpSolve]; };
   clinfun = derive { name="clinfun"; version="1.0.6"; sha256="00prrdm6qm5p2sjjlhi99msvqpxcm492z378wgl65iwf0jywdnpw"; depends=[mvtnorm]; };
   clinsig = derive { name="clinsig"; version="1.0-4"; sha256="0w2qb9k6fkw9lqi0ib6kzi6pvpb5hpq78w9x2jjs0yyqsj0rydwv"; depends=[]; };
   clinUtiDNA = derive { name="clinUtiDNA"; version="1.0"; sha256="0x3hb09073gkh60fc8ia0sfk948sm6z6j8sqkz275k4m8ryrabas"; depends=[]; };
+  CLME = derive { name="CLME"; version="1.0-1"; sha256="13j5qgyy6naicc5jc3vavas0bqzc69wggpyy3xxq9as6w2zjj5bj"; depends=[MASS quadprog shiny Iso]; };
   clogitL1 = derive { name="clogitL1"; version="1.4"; sha256="0m9yrg9mzzfv5qkdf6w55xyrjdghyrf27kk7b4x2gyvwvi5b7dkm"; depends=[Rcpp]; };
   cloudUtil = derive { name="cloudUtil"; version="0.1.10"; sha256="1j86vpd4ngrdpfjk44wb1mp0l88dxia64pjd2idfcd276giplh6s"; depends=[]; };
   clpAPI = derive { name="clpAPI"; version="1.2.6"; sha256="1kgzmzf87b0j43ch21anmm2d73bj2d16slmyavpbkdwg72dg1sjb"; depends=[]; };
   CLSOCP = derive { name="CLSOCP"; version="1.0"; sha256="0rkwq9rl2ph4h5zwb2i3yphjyzxmh6b6k23a8gcczycx6xdq4yhw"; depends=[Matrix]; };
   clue = derive { name="clue"; version="0.3-48"; sha256="1lwfm5sk9d35khcrvjs91bixfnjc3zwyfzq5ma9ljsc6hs80y8ar"; depends=[cluster]; };
   clues = derive { name="clues"; version="0.5-4"; sha256="0pgd3vjfplvsfn3nw6sqlkfsv6lbpjlcai7z9qp31qcih3g71vgr"; depends=[]; };
-  cluster = derive { name="cluster"; version="1.15.2"; sha256="0bv7qsbf6x3gq2iz3rwbjsj3cs8j0dvzxjhwdsvnqgkc1yhpkr13"; depends=[]; };
-  clusterCrit = derive { name="clusterCrit"; version="1.2.3"; sha256="0xd06w7jsl3srvhqx08vywy191k97lk3mgl2hsx1ki8ydplrdyha"; depends=[]; };
+  cluster = derive { name="cluster"; version="1.15.3"; sha256="014aycvxnw86rvzg8z6n9q2g7h5bzz6slz6l7vcaiiqpk9jxijj1"; depends=[]; };
   cluster_datasets = derive { name="cluster.datasets"; version="1.0-1"; sha256="0i68s9305q08fhynpq24qnlw03gg4hbk4184z3q3ycbi8njpr4il"; depends=[]; };
   clusterfly = derive { name="clusterfly"; version="0.4"; sha256="0mxpn7aywqadyk43rr7dlvj0zjcyf4q7qbqw5ds38si7ik34lkrg"; depends=[rggobi e1071 reshape2 plyr RGtk2]; };
   clustergas = derive { name="clustergas"; version="1.0"; sha256="1vf4czpwk71yxd26vm5sal0ml20ssjrq4bmk31yzxydpxn495fg8"; depends=[cluster]; };
···
   ClustOfVar = derive { name="ClustOfVar"; version="0.8"; sha256="17y8q2g4yjxs2jl1s8n5svxi021nlm0phs1g5hcnfxzpadq84wbs"; depends=[]; };
   clustrd = derive { name="clustrd"; version="0.1.2"; sha256="022lzp1wvbaa20d8hribgq9miy6i7jxm5m1p3p52h9b7bzga3q6g"; depends=[corpcor e1071 ggplot2 irlba]; };
   clustsig = derive { name="clustsig"; version="1.1"; sha256="0n5nf712vsa8zb0c2lv4gjqsgva62678vjngr9idgswb73shxm8v"; depends=[]; };
-  ClustVarLV = derive { name="ClustVarLV"; version="1.3"; sha256="13v7ip42wdzgvzpmkd8pzhv8j0kcavkby8fl4x4wn35ds46hx1v5"; depends=[Rcpp]; };
-  clustvarsel = derive { name="clustvarsel"; version="2.0"; sha256="0ql98r2aqwfmbn48xd68wpi2lk671aj2l8dqjn0jjp1vrk9fbw1m"; depends=[mclust BMA foreach iterators]; };
+  ClustVarLV = derive { name="ClustVarLV"; version="1.3.1"; sha256="0ilfpiah8jw11n4bnr7chgycldjkqp3xgq3majisiqfqn2ankxl3"; depends=[Rcpp]; };
+  clustvarsel = derive { name="clustvarsel"; version="2.1"; sha256="0sj9065s604sjzmlziak9xxl0xhplmp1g3d5dl9smwf2x8bb80mw"; depends=[mclust BMA foreach iterators]; };
   clv = derive { name="clv"; version="0.3-2.1"; sha256="1qgp2qhblg6ysyrlg0ad169ahwhcyn5pvsqzdlqj700y1k7wl7mc"; depends=[cluster class]; };
   clValid = derive { name="clValid"; version="0.6-6"; sha256="1l9q7684vv75jnbymaa10md13qri2wjjg7chr1z1m0rai8iq3xxw"; depends=[cluster class]; };
   cmaes = derive { name="cmaes"; version="1.0-11"; sha256="1hwf49d1m660jdngqak9pqasysmpc4jcgr8m04szwbyzyy6xrm5k"; depends=[]; };
···
   CMPControl = derive { name="CMPControl"; version="1.0"; sha256="0cp29cibiydawsl0cq433l9abdivr16b431zlrh45wzr5kzfcs0v"; depends=[compoisson]; };
   cmprsk = derive { name="cmprsk"; version="2.2-7"; sha256="1imr3wpnj4g57n2x4ryahl4lk8lvq9y2r7319zv3k82mznha8bcm"; depends=[survival]; };
   cmrutils = derive { name="cmrutils"; version="1.2-2"; sha256="0gc4sx8g9364sybmrqdjdvddqjd9ps6v205kaw0nqdx30xn96hmm"; depends=[chron]; };
-  cna = derive { name="cna"; version="0.1-3"; sha256="0y6qqg4454njldm8qipq260jbwfkh23iffpyghjnj2raw5fjgh8b"; depends=[]; };
+  cmvnorm = derive { name="cmvnorm"; version="1.0"; sha256="18aqjxr2rm4v813w25bp0jjm3110b22r8yskmnpspcw44666829v"; depends=[emulator elliptic]; };
+  cna = derive { name="cna"; version="1.0-0"; sha256="1pyglciid1q22mlkdm1r2wc2sbwcl98m26hzdgwrjmkvdn4r4166"; depends=[]; };
   cncaGUI = derive { name="cncaGUI"; version="0.0-2"; sha256="1rgs7446qb40b4qi1i4m5c3111kbqap4z1g7s01pnbylil0m80fd"; depends=[rgl tcltk2 tkrplot]; };
   CNOGpro = derive { name="CNOGpro"; version="1.0"; sha256="02vqnjsz0402xdqsxrxicgdsyi3nqc3cfrbabfkywn3q102gzq0f"; depends=[seqinr]; };
   CNprep = derive { name="CNprep"; version="1.0"; sha256="1i8iz0ir14g56zjsj8z4kmds5rybg8jjra33v0qcjwp489s6475a"; depends=[mclust rlecuyer]; };
···
   coda = derive { name="coda"; version="0.16-1"; sha256="0575pbx37jn7ljgjybl2v7rry55l6s6cb3a0m9znh4blln405q4i"; depends=[lattice]; };
   codadiags = derive { name="codadiags"; version="1.0"; sha256="1x243pn6qnkjyxs31h1hxy8x852r0fc952ww77g40qnrk8qw79xg"; depends=[coda]; };
   codep = derive { name="codep"; version="0.4-1"; sha256="1jkd6k80d6vyriwmq1car5zjms304zrdrfbjib664zxzx1wadf8z"; depends=[]; };
-  codetools = derive { name="codetools"; version="0.2-8"; sha256="0m326kfxihm5ayfn5b4k8awdf34002iy094gazbc3h0y42r4g86b"; depends=[]; };
+  codetools = derive { name="codetools"; version="0.2-9"; sha256="0d3kfkk8xngjin825ynlcxp9xgcr4z33n1zbj239j04rpicxmsvc"; depends=[]; };
   coefficientalpha = derive { name="coefficientalpha"; version="0.2.6"; sha256="0a0fvg22sg3idavv2qrb9sjvjjfm39fvpjsxz83a7bk6400vflsr"; depends=[MASS]; };
   coefplot = derive { name="coefplot"; version="1.2.0"; sha256="1v6c3fk2wrjgs3b31vajmig6dvmp5acfm72wh0iffpg0qgvf5hh7"; depends=[ggplot2 plyr reshape2 useful scales proto]; };
   coenocliner = derive { name="coenocliner"; version="0.1-0"; sha256="0hys1a4ai09pax5ydcaq39ll3rdjzyhgvz72z0iv9fwv4fbmwbr9"; depends=[]; };
   coexist = derive { name="coexist"; version="1.0"; sha256="15ydhrx996i6caa0360c2bgn2zvgwfg5wdhsqq1gvrggs15w7nml"; depends=[]; };
   CoImp = derive { name="CoImp"; version="0.2-3"; sha256="04n0drx98hi8hmlb5xwl87ylv03j1ld04vp9d8s5sphvm9bbx690"; depends=[copula nnet gtools locfit]; };
-  coin = derive { name="coin"; version="1.0-23"; sha256="07433fblandxb8gzkzln49cckv75mqr2z847dwsa3qz68callxba"; depends=[survival modeltools mvtnorm]; };
+  coin = derive { name="coin"; version="1.0-24"; sha256="1h1d6pi957qkmlk2j8f280sc6jkg328wnyxjk43yxj2zwmdnmgpd"; depends=[survival modeltools mvtnorm]; };
   CoinMinD = derive { name="CoinMinD"; version="1.1"; sha256="0invnbj5589wbs0k2w5aq9qak7axc3s0g9nw85c48lnl0v95s91i"; depends=[MCMCpack]; };
-  colbycol = derive { name="colbycol"; version="0.8"; sha256="198zc4jd7gby1dhvmg7fy41ldbxkgqj6ram54g3w6sw0yv9ilk8r"; depends=[rJava filehash]; };
   cold = derive { name="cold"; version="1.0-3"; sha256="17nlqhp5415m8wjkb2ykmk1q3lgw1aycf85b6byl8p06bfrvmw2p"; depends=[]; };
   CollocInfer = derive { name="CollocInfer"; version="1.0.1"; sha256="0wfk3qw28msz3wqm5xmivjgi18kqv1s6w76vh71zq777d6a7al6i"; depends=[fda deSolve MASS Matrix spam]; };
   coloc = derive { name="coloc"; version="2.3-1"; sha256="1j3m9afpkm0bzib38yqvk85b6s6l56s6j2ni96gii4a06r87ig60"; depends=[colorspace MASS BMA]; };
···
   combinat = derive { name="combinat"; version="0.0-8"; sha256="1h9hr88gigihc4na7lb5i7rn4az1xa7sb34zvnznaj6pdrmwy4qm"; depends=[]; };
   CombinS = derive { name="CombinS"; version="1.0"; sha256="0gi66hmj3jmr301r2ahrln4zjjjvl6gabdv3y5df7aqidxlbhqbb"; depends=[]; };
   CombMSC = derive { name="CombMSC"; version="1.4.2"; sha256="1wkawxisn9alpwrymja8dla8n25z2fhai3l2xhin0b914y2kai09"; depends=[]; };
-  comclim = derive { name="comclim"; version="0.9.2"; sha256="14x9qpflprdi7j94xipndzp76bbs7cqmyhqd2cakxgnl1q915pnx"; depends=[]; };
-  commandr = derive { name="commandr"; version="0.9.5"; sha256="1i960c4hszxm10qcpn9hrhxfzxfp9yywkbj4i9hraj8ka759z75a"; depends=[]; };
-  CommonJavaJars = derive { name="CommonJavaJars"; version="1.0-4"; sha256="0amn8z8im64q1k6j6l2bh4795b6i665wxqpgabhv471zfhdk0nil"; depends=[]; };
+  comclim = derive { name="comclim"; version="0.9.4"; sha256="0m6ynccscsrrq70p0drwrwxp4skc630kv1l5smh48pi8kagahj1g"; depends=[]; };
+  commandr = derive { name="commandr"; version="1.0.1"; sha256="1d6cha5wc1nx6jm8jscl7kgvn33xv0yxwjf6h3ar3dfbvi4pp5fk"; depends=[]; };
+  commentr = derive { name="commentr"; version="0.1"; sha256="0kyi7xd2f2b1avk78bmkbagyjqwwx21hca670n38k1a28kvnjpix"; depends=[stringr]; };
+  CommonJavaJars = derive { name="CommonJavaJars"; version="1.0-5"; sha256="0kwf504g1izyy7hxss21dgz26w0spxibdlacrjdh7q10z799hfhh"; depends=[]; };
   CommonTrend = derive { name="CommonTrend"; version="0.7-1"; sha256="088pg2hy2g2jgs84xawrnsf7gpvrpqjsimkx7g0i5r5fmkx169f9"; depends=[MASS urca]; };
   CommunityCorrelogram = derive { name="CommunityCorrelogram"; version="1.0"; sha256="1wkrm5lil595sc4ih3qsf4sgvfipzlav0n7339ixqw9zxm2pg4nj"; depends=[vegan]; };
   comorbidities = derive { name="comorbidities"; version="1.0"; sha256="01aisxy4cx3jw37cg6mwvfj4nv10ndmwjxf8xsfv7s20hdb0gmqn"; depends=[]; };
   Comp2ROC = derive { name="Comp2ROC"; version="1.0"; sha256="0vymjbxdlvm5dvss4z4zjdc7y7040s3j972gh2138wfygji1szg7"; depends=[ROCR boot]; };
   compactr = derive { name="compactr"; version="0.1"; sha256="0f2yds6inmx0lixj08ibqyd2i61l2cbg1ckgpb8dl2q7kcyyd6mx"; depends=[]; };
   compare = derive { name="compare"; version="0.2-4"; sha256="0fhw7y7xwrv79wxvs9gy4xddjzc6hh97m81a10j64jssy4p291b6"; depends=[]; };
-  compareGroups = derive { name="compareGroups"; version="2.0.4"; sha256="1z2aipcjnqh83g33aypspwk8kkab5i2h5ms0lnnmcp3c8wn8pzi8"; depends=[Hmisc xtable gdata SNPassoc survival epitools HardyWeinberg]; };
+  compareGroups = derive { name="compareGroups"; version="2.0.5"; sha256="1r07g5l0x8bkgm13qzw992aw0wn2q2wcadidr9444nqhk2l8809b"; depends=[Hmisc xtable gdata SNPassoc survival epitools HardyWeinberg]; };
   compareODM = derive { name="compareODM"; version="1.2"; sha256="019hq8j56asjvh4x1p65785mf38xr05j3by0749gl9k9yl8645da"; depends=[XML]; };
   CompareTests = derive { name="CompareTests"; version="1.0"; sha256="098axl20jid35pqvgiwk6h91waafigwks6n5f4pg7xxx1fifks4f"; depends=[]; };
   comparison = derive { name="comparison"; version="1.0-4"; sha256="0pc462rhk8gr8zrf08ksi315kmhydlp027q5gd40ap5mmhk7rd82"; depends=[isotone]; };
   compeir = derive { name="compeir"; version="1.0"; sha256="1bb5459wcqpjic2b9kjn0l0qdn7sqmmx34hdb2aqg80q22mhx5dv"; depends=[lattice etm]; };
+  compendiumdb = derive { name="compendiumdb"; version="0.1.0"; sha256="1dvgkbrsj2fw3mr454mfqhjcz0lbhvz848hgj1ld76p10zhs2vyk"; depends=[RMySQL]; };
   CompGLM = derive { name="CompGLM"; version="1.0"; sha256="04bjal92r0m7is5ygqpd0mdz3fb3pwcr7rc3mbxg9sg57nff3kf5"; depends=[Rcpp]; };
   compHclust = derive { name="compHclust"; version="1.0-2"; sha256="1h39krvz516xwsvn5987i1zbzan8vx2411qz6dad112hpss0vyk9"; depends=[]; };
+  Compind = derive { name="Compind"; version="1.0"; sha256="13gfsbjaciign8cswsibdj9a4rwj5afwrk4g1x4fyihfhnm4qx7m"; depends=[Benchmarking psych boot Hmisc MASS GPArotation lpSolve nonparaeff]; };
   complex_surv_dat_sim = derive { name="complex.surv.dat.sim"; version="2.0.0"; sha256="1x4whyq0bds0zblppcvv7lk6qy567c37x19n1r0xjgyl3id40f7c"; depends=[eha statmod]; };
+  complmrob = derive { name="complmrob"; version="0.5.5"; sha256="1klabkx5q27h0na4987bbd3xs1v3nmy5nxc5izs7y0x2s8i324v1"; depends=[robustbase ggplot2 boot scales]; };
   CompLognormal = derive { name="CompLognormal"; version="3.0"; sha256="1dhgr9l713l2n889bpa47lbg2qab0fz0r15qa928c0b9nz688ddm"; depends=[numDeriv]; };
   compoisson = derive { name="compoisson"; version="0.3"; sha256="0v5dl7xydqi4p97nipn4hyhpq2gghmx81ygvl0vc8b65jhq89y0p"; depends=[MASS]; };
   COMPoissonReg = derive { name="COMPoissonReg"; version="0.3.4"; sha256="1mf2q7phc2bn700yp7i2i6ccj6lrvh8b2dmibqihh76a85j1ycrq"; depends=[]; };
···
   compound_Cox = derive { name="compound.Cox"; version="1.4"; sha256="08sdkq040zk9mb1lcy4nm32gwab26vaig8brp2n3aizagx9fv3r9"; depends=[numDeriv survival]; };
   Compounding = derive { name="Compounding"; version="1.0.2"; sha256="1xlb3ylwjv70850agir0mx79kcvs43h0n1sm22zcny3509s2r7lf"; depends=[hypergeo]; };
   CompQuadForm = derive { name="CompQuadForm"; version="1.4.1"; sha256="1kv4bdkwidkjw0hgn2krv42p9v1a03p47g0p03lja3flhfbmiifj"; depends=[]; };
-  CompRandFld = derive { name="CompRandFld"; version="1.0.3"; sha256="1qfq1zkdxk6jh3z7vfp91c6jcvj4smq21cndxdmq150f6vsx35fl"; depends=[]; };
-  compute_es = derive { name="compute.es"; version="0.2-3"; sha256="17g1s9vz61kyqsm16vbzwmaw2qz6r99p9cg3s6c7lk73vr2qrwni"; depends=[]; };
-  ConConPiWiFun = derive { name="ConConPiWiFun"; version="0.4.2"; sha256="0x3md1xfrrg41qfyafbvl9qaa6yy81nky3pl5z9qs850mjbs8qdl"; depends=[Rcpp]; };
+  CompRandFld = derive { name="CompRandFld"; version="1.0.3-1"; sha256="0faazwmf9gr39m7bal0wb36cq4a36h9xrk6nj316sy57fd4w1aiw"; depends=[]; };
+  compute_es = derive { name="compute.es"; version="0.2-4"; sha256="1b5i8z66zbag0vdv98mmpwmizpm68vc3ajh0n3q94zdcmhcbx12d"; depends=[]; };
+  ConConPiWiFun = derive { name="ConConPiWiFun"; version="0.4.4"; sha256="1dq9nlg04xs2n9g62y4gbl8ay4vsa25d7d7dra7q8zq6a561hzz5"; depends=[Rcpp]; };
   concor = derive { name="concor"; version="1.0-0.1"; sha256="0hjyvi6p16cyrmq0bq7fph1r5f3adp7zpf123wkm5bkjnc5122k0"; depends=[]; };
   concreg = derive { name="concreg"; version="0.5"; sha256="0psvnirl5rqicyzxs9sivh23bzzwdgviqczdl2in2gnrvdiw7m6f"; depends=[survival]; };
   cond = derive { name="cond"; version="1.2-3"; sha256="0y7m7valk7zn40y62348czmdvfkx59il9sl6wy565lzqfiimd9ps"; depends=[statmod survival]; };
···
   CondReg = derive { name="CondReg"; version="0.20"; sha256="1ffnrjfjcb66i9nyvidkcn4k9pcj4r7xanjwzcxcrj2qm39apkqx"; depends=[]; };
   coneproj = derive { name="coneproj"; version="1.4"; sha256="07zhqidjinpphvr7xdzrn3f5iq6bx8c2sj5gya2bz8glf4x74h9d"; depends=[Rcpp]; };
   conf_design = derive { name="conf.design"; version="2.0.0"; sha256="06vdxljkjq1x56xkg041l271an1xv9wq79swxvzzk64dqqnmay51"; depends=[]; };
-  confReg = derive { name="confReg"; version="0.1.3"; sha256="0cwz5wnrk0qppj65gskizy2jb9y6x6xhkyb5qhd5xfc698x6ivs2"; depends=[e1071]; };
+  confidence = derive { name="confidence"; version="1.1-0"; sha256="11y2mjh9ykmsgf6km6f2w5rql1vqwick4jzmxg5gkfkiisvsq1cp"; depends=[knitr markdown plyr xtable ggplot2]; };
   confreq = derive { name="confreq"; version="1.1"; sha256="14d0vlf4bwmdwayqg2fsyqblyinx1d3mqhndhjjk0d59qmr44lsa"; depends=[]; };
   conicfit = derive { name="conicfit"; version="1.0.0"; sha256="032a9ajrv1xl2i4p3a32fyzg6s76vngdcmwqnh2lgk72srlhryzj"; depends=[pracma geigen]; };
   conics = derive { name="conics"; version="0.3"; sha256="06p6dj5dkkcy7hg1aa7spi9py45296dk0m6n8s2n3bzh3aal5nzq"; depends=[]; };
   conjoint = derive { name="conjoint"; version="1.39"; sha256="0f8fwf419js9c292i3ac89rlrwxs2idhwxml1qd8xd2ggwfh6w5m"; depends=[AlgDesign clusterSim]; };
   ConjointChecks = derive { name="ConjointChecks"; version="0.0.9"; sha256="097mhiz8zjmmkiiapr3zfx7v35xirg57nqp1swd72dixaa23nhr1"; depends=[]; };
   ConnMatTools = derive { name="ConnMatTools"; version="0.1.5"; sha256="02cv2rlfp9shwqc9nwb8278akmwv7yvviwl23jglzsyh721dpqkr"; depends=[]; };
-  CONOR = derive { name="CONOR"; version="1.0.2"; sha256="1h6vx8hq8lbjdhv466q9q4h13hir1pfj6bjmg90gmqjwrpbdciw1"; depends=[CLSOCP tseries outliers nortest quadprog zoo fields fpc flexclust plyr CONORData]; };
-  CONORData = derive { name="CONORData"; version="1.0.2"; sha256="0a52wz9i9md15wqvhh105wjvlw4byx7qgy9i1sd1wr4jn84ir5wf"; depends=[CLSOCP tseries outliers nortest quadprog zoo fields fpc flexclust plyr]; };
   constrainedKriging = derive { name="constrainedKriging"; version="0.2.3"; sha256="1hppfc0pv0jphmj7pip1cn65sfrcwvnpymlvpyp7sbn3nmy2qqrb"; depends=[sp spatialCovariance rgeos RandomFields]; };
   contfrac = derive { name="contfrac"; version="1.1-9"; sha256="16yl96bmr16a18qfz6y5zf7p02ky1jy2iimcb1wp50g7imlcq840"; depends=[]; };
   conting = derive { name="conting"; version="1.3"; sha256="1aw3hp88xif5s94388g4805xqnv21dj47wshgkbg33dn11lf2hwf"; depends=[mvtnorm BMS gtools tseries coda]; };
   contrast = derive { name="contrast"; version="0.19"; sha256="1kc3scz3msa52lplc79mmn4z99kq1p2vlb18wqxa9q2ma133x6pl"; depends=[rms]; };
   ConvCalendar = derive { name="ConvCalendar"; version="1.2"; sha256="0yq9a42gw3pxxwvpbj6zz5a5zl7g5vkswq3mjjv5r28zwa3v05vc"; depends=[]; };
-  ConvergenceConcepts = derive { name="ConvergenceConcepts"; version="1.0"; sha256="1s6yxiaxmv7yxydwjhxi778vznh4gs8l5cgy308bxj53d4d6kfkz"; depends=[tkrplot lattice]; };
+  ConvergenceConcepts = derive { name="ConvergenceConcepts"; version="1.1"; sha256="0878fz33jxh5cf72lv0lga48wq2hqa4wz6m59111k59pzrsli344"; depends=[tkrplot lattice]; };
   convexHaz = derive { name="convexHaz"; version="0.2"; sha256="0lfksb01iilhyjbr9wj3w4s9nbkdcl649w86fp2mz6s6makmq84x"; depends=[]; };
   cooccur = derive { name="cooccur"; version="1.1"; sha256="1q2x89jpr81jq0hw218c9h8spc1gwgax58j8npgd6rnzlkpxxyam"; depends=[reshape2 gmp ggplot2]; };
+  cooptrees = derive { name="cooptrees"; version="1.0"; sha256="0izvwna1jsqik3v5fz1r4c86irvma42clw0p4rdvwswv5pk698i1"; depends=[igraph optrees gtools]; };
   COP = derive { name="COP"; version="1.0-2"; sha256="1gynknplvx97hjhi7adsgq9r9lqismch1q1pqvgmz0x1wkg4jj40"; depends=[dr MASS]; };
-  COPASutils = derive { name="COPASutils"; version="0.1"; sha256="1w080k6fpbvcx1pqaa2n5vhf7nmr1z403wj7ilkxy5s6cw7gmyi5"; depends=[ggplot2 reshape2 dplyr kernlab stringr knitr]; };
-  copBasic = derive { name="copBasic"; version="1.5.4"; sha256="1za91mkahkrcg4h54ii2zk3c22rn8krsa95aj9y0kgg3rxnd09hz"; depends=[lmomco]; };
-  copula = derive { name="copula"; version="0.999-10"; sha256="1xx7f1mzym8amlyf84s7yrwygyfcvfqisar64ikyr1ksf571l77i"; depends=[Matrix gsl ADGofTest stabledist mvtnorm pspline]; };
+  COPASutils = derive { name="COPASutils"; version="0.1.4"; sha256="0273530jis6plw1gg5mp4xbcw7x8k6bhqwdss5n3fypmi2vkb880"; depends=[ggplot2 reshape2 dplyr kernlab stringr knitr]; };
+  copBasic = derive { name="copBasic"; version="1.6.0"; sha256="1sqh61ln0ih731frdgisslll2qf8p3896abjap4f79fy1dn83p70"; depends=[lmomco]; };
+  copCAR = derive { name="copCAR"; version="1.0"; sha256="0rq432w959p7drx73vsrdh5dhi2wy7dsjhhb4nh9wm36kkzki5ca"; depends=[numDeriv Rcpp spam]; };
+  copula = derive { name="copula"; version="0.999-12"; sha256="131wr6a7qxsdsl9f5amjkzj2wwgdwlg85a1pmd0bflzfi86dvrdf"; depends=[Matrix lattice gsl ADGofTest stabledist mvtnorm pspline]; };
   copulaedas = derive { name="copulaedas"; version="1.4.1"; sha256="1xs02s91la4i1x1zs8k5gfvd9jhs2zqhv58431p1j3spfapzf2rc"; depends=[copula vines mvtnorm truncnorm]; };
-  CopulaRegression = derive { name="CopulaRegression"; version="0.1-4"; sha256="17cfs47g5am0gf6kv366v87zv2gcmc7s7bcay4ccfqzqhbhli2i4"; depends=[MASS VineCopula]; };
+  CopulaRegression = derive { name="CopulaRegression"; version="0.1-5"; sha256="0dd1n7b23yww36718khi6a5kgy8qjpkrh0k433c265653mf1siq8"; depends=[MASS VineCopula]; };
   CopyDetect = derive { name="CopyDetect"; version="1.1"; sha256="0h9bf7ay5yr6dwk7q28b6xxfzy6smljkq6qwjkzfscy5hnmwxkpa"; depends=[irtoys]; };
   corclass = derive { name="corclass"; version="0.1"; sha256="02mxypdrjwf8psk0j9ggbw14889a87c6lw11qki3s3biq52qsx3y"; depends=[igraph]; };
   corcounts = derive { name="corcounts"; version="1.4"; sha256="0irlx62ql5rp5s7nnjdy6jh723wl4039wn10zxri8ihxwqsyyz3f"; depends=[]; };
   CORE = derive { name="CORE"; version="2.0"; sha256="18vnqfasrn0bkplr3qj21wrksnj8wbsfhg7r0aimaa9c9nz9l7kg"; depends=[]; };
   CORElearn = derive { name="CORElearn"; version="0.9.43"; sha256="0qzj2fx8if157dplxcsss5s0gllwf183vhiqmapbkdix2h9l9jk5"; depends=[cluster rpart]; };
-  corHMM = derive { name="corHMM"; version="1.14"; sha256="03kwj8y4c4jw9lwpvyi3539184yifhcavbhh6rbw9pasnxkzj28l"; depends=[ape nloptr expm numDeriv corpcor phangorn rgenoud]; };
+  coreTDT = derive { name="coreTDT"; version="1.0"; sha256="14rnh61gk3m6g8rq77hm9ybds0px15di2mxm3jiyfdfynx5ng58f"; depends=[]; };
+  corHMM = derive { name="corHMM"; version="1.15"; sha256="1f1qq8fnnx68mpfj863pml4xynxsl21f9r1qqv7yfrx14daki4a0"; depends=[ape nloptr expm numDeriv corpcor phangorn rgenoud]; };
   CORM = derive { name="CORM"; version="1.0.2"; sha256="0g5plafx2h1ija8jd6rxvy8qsrqprfbwbi1kq1p4jdr9miha20nv"; depends=[cluster]; };
-  corpcor = derive { name="corpcor"; version="1.6.6"; sha256="0rjlqbh76f5q3sjbh9nhvsip9391mnh05x5f7cqi6rp63c194v12"; depends=[]; };
+  corpcor = derive { name="corpcor"; version="1.6.7"; sha256="1vfzi17vkvzbqgzhmpdhybb6lli0z9vm9p31cwb8bn8ddlkn5ll4"; depends=[]; };
   corpora = derive { name="corpora"; version="0.4-3"; sha256="0zh8mabfy9yqgx7asi4yqv4c0kj59yvyxxaxjgdjy5kkr17zd4g4"; depends=[]; };
   CorrBin = derive { name="CorrBin"; version="1.4"; sha256="0xnj2rhm4ph9277v2wfrp15p8nbdxiqfpcj0shj0d9z8rasx7p8m"; depends=[boot combinat]; };
-  CorReg = derive { name="CorReg"; version="0.15.0"; sha256="17cgq5ssqxa8v5afjhnfg4fr1p9bs3migzmh5b9b2kxixm81flk5"; depends=[Rcpp lars elasticnet clere spikeslab corrplot Matrix mclust Rmixmod ridge rpart MASS parcor mvtnorm]; };
+  CorReg = derive { name="CorReg"; version="0.15.7"; sha256="133n2mwb5azcrqap3bvzs46yw359pcnr7p5g0wdz9nmv51aq9g3b"; depends=[Rcpp lars elasticnet clere spikeslab corrplot Matrix mclust Rmixmod ridge rpart MASS mvtnorm]; };
   correlate = derive { name="correlate"; version="1.0"; sha256="0hv0i928f49p8n78hd3bcx923l2x0zcs4kwj71ph8gm7s8540fhc"; depends=[]; };
   Correlplot = derive { name="Correlplot"; version="1.0-2"; sha256="0prxnbi7ga5d23i0i4qpynfb3zrsgjxam47km6nsj1prakdkrq7w"; depends=[calibrate xtable]; };
-  corrgram = derive { name="corrgram"; version="1.5"; sha256="015h4vnbmjir81x9ifqbnl25havpi8m7p3iaj30rl1hdhhbpy0dz"; depends=[seriation]; };
+  corrgram = derive { name="corrgram"; version="1.6"; sha256="1y0963hqh909pqfjkjp2wwq1npmy7qp37gyfyy5vcspl2fic4afb"; depends=[seriation]; };
   corrplot = derive { name="corrplot"; version="0.73"; sha256="0xnlkb8lhdjcc10drym9ymqzvfwa3kvf955y0k66z5jvabzyjkck"; depends=[]; };
   corrsieve = derive { name="corrsieve"; version="1.6-8"; sha256="0ak3j9khcwv5rxbicck2sr260wpmd3xj254y7pdavx2fk0b72yxs"; depends=[]; };
   corTools = derive { name="corTools"; version="1.0"; sha256="0arvqk2xp19ap73zmdk0kb1fycb3v2mf65b4bhanvcqwr4kg4vdk"; depends=[]; };
   COSINE = derive { name="COSINE"; version="2.1"; sha256="10ypj849pmvhx117ph3k1jqa62nc4sdmv8665yahds7mh0ymhpjj"; depends=[MASS genalg]; };
   cosinor = derive { name="cosinor"; version="1.1"; sha256="02nnqg51vq48lzk667cyarnmhcf5mifnsdij7dlgqvz2k4fdq4pl"; depends=[ggplot2 shiny]; };
   cosmoFns = derive { name="cosmoFns"; version="1.0-1"; sha256="0a6xhbgxxnymlvicg99yhgny2lscxcbmvqmy17kxmahdi797dsg6"; depends=[]; };
+  CosmoPhotoz = derive { name="CosmoPhotoz"; version="0.1"; sha256="04girid6wvgyrk8ha81mdqjx2mmzifz57l1hzcgrdnzmjmm3vlmp"; depends=[ggplot2 ggthemes arm COUNT gridExtra pcaPP mvtnorm shiny]; };
   cosmosR = derive { name="cosmosR"; version="1.0"; sha256="0w4qywnkgcybgyyhnvvg33amqi2vnkry6iajakyqr1x2hzfpf9sv"; depends=[xlsx]; };
   cosso = derive { name="cosso"; version="2.1-1"; sha256="1wyq27qak0kz4bbzynm24r5ksvb6ddd43h2ykh6m935xck16blyb"; depends=[quadprog Rglpk glmnet]; };
   costat = derive { name="costat"; version="2.3"; sha256="1kqyl89lx1amap9zgrfy1bqnl93kahrksj6yms44yrxr1as2g4nk"; depends=[wavethresh]; };
   cotrend = derive { name="cotrend"; version="1.0"; sha256="0h0y502wqq83wlf9ab1b9rxg1wycvi3sp4lbqfpvy46vgljrjw87"; depends=[xts]; };
-  COUNT = derive { name="COUNT"; version="1.3.1"; sha256="1j67f9cjqn523g3khawxj41c19c2l6l287f8ry8mnmijfs0hvpr4"; depends=[msme sandwich MASS]; };
+  couchDB = derive { name="couchDB"; version="1.3.0"; sha256="153zxi2liv932r7mphhzgxw4wyizh5iyk62ad6x64av31kd2qzsn"; depends=[RCurl bitops httr rjson]; };
+  COUNT = derive { name="COUNT"; version="1.3.2"; sha256="1lb67gwznva5p046f4gjjisip5a12icp7d2g1ipizixw99c5lll8"; depends=[msme sandwich MASS]; };
   countrycode = derive { name="countrycode"; version="0.17"; sha256="0rmmqh0x34bdnyb19r719rsm46q8193lf7wcynd5s3c2i4vbkx8n"; depends=[]; };
   CountsEPPM = derive { name="CountsEPPM"; version="1.0"; sha256="19l0nb1rrhqcxcjx4lrp298xgxprziz1ccl3r1q3h16yj5vhkqrw"; depends=[Matrix Formula]; };
   covLCA = derive { name="covLCA"; version="1.0"; sha256="15jsjrlaws1cqyrwvh4lzbhxkb11jmgpmddg98nfrzmjpczn2iw3"; depends=[Matrix mlogit poLCA]; };
···
   coxphw = derive { name="coxphw"; version="3.0.0"; sha256="11pyd09dwkbixjz1riv8rz3jrp1ix6cbn1fw9nm8vnrc19x5lkz5"; depends=[survival]; };
   CoxRidge = derive { name="CoxRidge"; version="0.9.1"; sha256="11vlsrv03j6kcxq9an7g210nq6cc6qd04b7w0pfbdk4bniqc0k60"; depends=[survival]; };
   coxrobust = derive { name="coxrobust"; version="1.0"; sha256="08hp0fz5gfxgs3ipglj6qfr6v63kzxkrzg650bmzabq8dvrxd97q"; depends=[survival]; };
+  CP = derive { name="CP"; version="1.5"; sha256="0hzp4h7bhhxn336kkq27phplk7idwk27jjsp6zimwl8fq3ylh0dr"; depends=[survival]; };
   cpa = derive { name="cpa"; version="1.0"; sha256="14kcxayw4cdbjfa6bvfzqp8flwc0sr3hmh2dnr1dfax0hnccd71m"; depends=[]; };
   cpca = derive { name="cpca"; version="0.1.2"; sha256="1pccsjahb1qynnxa0akhfpcmhfmdg4rd1s6pfqrdl7bwbcmq4lqf"; depends=[]; };
   CPE = derive { name="CPE"; version="1.4.4"; sha256="09sqp2a0j43jr9ya9piv8575rwd5fdvwmiz4chv75r3mw8p128mn"; depends=[survival rms]; };
···
   cplexAPI = derive { name="cplexAPI"; version="1.2.11"; sha256="1rfvq2a561dz3szvrs9s5gsizwwp0b5rn4059v9divzw23clr2a9"; depends=[]; };
   cplm = derive { name="cplm"; version="0.7-2"; sha256="0vwj130r5wbax9ixcn0fdznh1zrr0wq48iivmlymqbhbqajmv8fb"; depends=[coda Matrix biglm ggplot2 minqa nlme reshape2 statmod tweedie]; };
   CPMCGLM = derive { name="CPMCGLM"; version="1.1"; sha256="1w8yp37vxz2cl0yqdzpyxdfq2scz2h9i4crjzjmjzpzffi45f06s"; depends=[mvtnorm plyr]; };
-  Cprob = derive { name="Cprob"; version="1.2.2"; sha256="18dzyfgxx32azmb02i1gr0fb6nq1b81wni9cgj3qgw8ga7lplgik"; depends=[prodlim tpr geepack lgtdl lattice]; };
+  Cprob = derive { name="Cprob"; version="1.2.3"; sha256="12kid241q0l28c77wfiqi1b7qj9scdz3ww6dcda5bkb8dcpr9sxv"; depends=[prodlim tpr geepack lgtdl lattice]; };
   CR = derive { name="CR"; version="1.0"; sha256="0smb2i560dwbxg3mp1svfxmaiw193pd3klwqq0i27czf07k1xfvj"; depends=[]; };
   CRAC = derive { name="CRAC"; version="1.0"; sha256="0vnqmmmwakx5jnzqp20dng35p7rvmz3ypm2m7bs41m8nhh2wq1xa"; depends=[]; };
   crackR = derive { name="crackR"; version="0.3-9"; sha256="18fr3d6ywcvmdbisqbrbqsr92v33paigxfbslcxf7pk26nzn2lly"; depends=[Hmisc evd]; };
···
   crank = derive { name="crank"; version="1.0-5"; sha256="1zy0z308kw0qgyppkm66p8vqw5b1qcn5avhm78zh0r9k60069dm5"; depends=[]; };
   crantastic = derive { name="crantastic"; version="0.1"; sha256="0y2w9g100llnyw2qwjrib17k2r2q9yws77mf6999c93r8ygzn4f5"; depends=[]; };
   crawl = derive { name="crawl"; version="1.4-1"; sha256="175w5933h5hhhjnrc0l1kg5q24b8pclnf5sf36gj1pmg8s58d1gp"; depends=[mvtnorm sp raster]; };
+  crayon = derive { name="crayon"; version="1.1.0"; sha256="03l7sw6ilr4hmahk921kkq4hlvlscginrq3mw8aypc4wb6y32qhm"; depends=[memoise]; };
   crblocks = derive { name="crblocks"; version="0.9-1"; sha256="1m6yy6jb1dld7m9jaasms5ps8sn3v039jvlk8b0c08hmm7y0rm3z"; depends=[]; };
   crch = derive { name="crch"; version="0.1-0"; sha256="1f4y2dd6lxsryyjjv569bxh1b4ymcnma0m9k7j150anzvkbrgnjn"; depends=[Formula ordinal]; };
   CreditMetrics = derive { name="CreditMetrics"; version="0.0-2"; sha256="16g3xw8r6axqwqv2f0bbqmwicgyx7nwzff59dz967iqna1wh3spi"; depends=[]; };
···
   crn = derive { name="crn"; version="1.1"; sha256="1fw0cwx478bs6hxidisykz444jj5g136zld1i8cv859lf44fvx2d"; depends=[chron RCurl]; };
   crossdes = derive { name="crossdes"; version="1.1-1"; sha256="1d7lv3ibq1rwxx8kc3ia6l9dbz2dxdd5pnf2vhhjmwm448iamcfd"; depends=[AlgDesign gtools]; };
   crossmatch = derive { name="crossmatch"; version="1.3-1"; sha256="082lrv2129mfhwlh99z3g8id3a29s8854skl152bl3ig8pk2gbjz"; depends=[survival nbpMatching]; };
+  Crossover = derive { name="Crossover"; version="0.1-13"; sha256="0s3nlc6yzgnrhdxpjqfpw8qcnjbhs5y0ng3qqpmpm9d9br8kivri"; depends=[rJava CommonJavaJars JavaGD ggplot2 MASS crossdes xtable Matrix multcomp digest]; };
   crossReg = derive { name="crossReg"; version="1.0"; sha256="1866jhfnksv9rk89vw7w4gaxi76bxfjvqxx7cfa8nlrcsmaqd7rf"; depends=[]; };
   crossval = derive { name="crossval"; version="1.0.1"; sha256="1xdl6cmmfkl46arbm71jhdsscjknclvsiaysijlp2p4vgw2762pa"; depends=[]; };
   crp_CSFP = derive { name="crp.CSFP"; version="2.0"; sha256="0ji208hn3zimql0xhy8bl7w0vg40szw28fia7k1f7g9z0wbl9xqp"; depends=[MASS]; };
···
   cshapes = derive { name="cshapes"; version="0.4-2"; sha256="015mkh0iwdbhpbk8gpnq48pp026mfidd69rj70arpmg3knd2jvff"; depends=[sp maptools plyr]; };
   cslogistic = derive { name="cslogistic"; version="0.1-3"; sha256="1s8p3qpz81nn6zr0pzw6h9ca3p6ahd8zj640vy5gcb5waqwj6bfj"; depends=[mvtnorm]; };
   csn = derive { name="csn"; version="1.1"; sha256="1cv5pv6g1b635c5bamq43339vh1rxadwjl4vxyrx56991wyr36sl"; depends=[mnormt]; };
-  csound = derive { name="csound"; version="0.1-1"; sha256="0d4bad8qld29k0yavg7f2srljnbax0gj53dljqw1b1z7shyqd1n5"; depends=[rdyncall]; };
   CSS = derive { name="CSS"; version="1.0.2"; sha256="0p0c3gfj6p58hd4398kkpjg7rhx6wh5z6qddpqnvbm24acq7nrvh"; depends=[XML stringr]; };
   csSAM = derive { name="csSAM"; version="1.2.4"; sha256="1ms8w4v5m9cxs9amqyljc2hr1178cz6pbhmv7iiq9yj1ijnl4r1x"; depends=[]; };
   cstar = derive { name="cstar"; version="1.0"; sha256="1zws4cq5d37hqdxdk86g85p2wwihbqnkdsg48vx66sgffsf1fgxd"; depends=[]; };
···
   currentSurvival = derive { name="currentSurvival"; version="1.0"; sha256="0bqpfwf4v4pb024a98qwg81m6zd7ljg1ps42ifhxpqx7b9gdyi6c"; depends=[survival cmprsk]; };
   curvetest = derive { name="curvetest"; version="2.2"; sha256="1lz6rx9fmgyrlci1dyanscp2a18ki9lhrwnrzhp062flysffimg6"; depends=[locfit R_oo R_methodsS3]; };
   curvHDR = derive { name="curvHDR"; version="1.0-3"; sha256="0rq72prxv2r5nicss9mh4wpkfjvlbb885w85ag4qrqijzq6y8q04"; depends=[feature geometry hdrcde ks misc3d ptinpoly rgl]; };
-  cusp = derive { name="cusp"; version="2.2"; sha256="0c8hxsvvp2p86jwcbx1rzs6i8w2mh3dnsfmfkwpq9x28aps3dmd5"; depends=[]; };
   cutoffR = derive { name="cutoffR"; version="1.0"; sha256="1801jylmpp4msyf07rhg4153kky1zvi4v0kkjb9d51dc7zkhh531"; depends=[ggplot2 reshape2]; };
   cuttlefish_model = derive { name="cuttlefish.model"; version="1.0"; sha256="1rmkfyfd1323g2ymd5gi1aksp160cwy5ha5cjqh5r6fzd8hhqjxs"; depends=[]; };
   cvAUC = derive { name="cvAUC"; version="1.0-0"; sha256="1z8l2ivv7h8din6q46ds3gnlsff10l4ry2kavqv9qsl4xkd8rim0"; depends=[ROCR]; };
···
   CVST = derive { name="CVST"; version="0.2-1"; sha256="17xacyi8cf37rr2xswx96qy7pwkaqq394awdlswykz3qlyzx4zx2"; depends=[kernlab Matrix]; };
   CVThresh = derive { name="CVThresh"; version="1.1.1"; sha256="19d7pslzj8r3z5gn3cplpz2h2ayz6k1nrfx3s2b7a8w1il3vmi69"; depends=[wavethresh EbayesThresh]; };
   cvTools = derive { name="cvTools"; version="0.3.2"; sha256="0b7xb6dmhqbvz32zyfbdvm9zjyc59snic6wp1r21ina48hchn3sj"; depends=[lattice robustbase lattice robustbase]; };
+  CVTuningCov = derive { name="CVTuningCov"; version="1.0"; sha256="1bwzis82lqwcqp2djy4bnd3vvjr47krlv3pdc5msh12wcs0xhs7n"; depends=[]; };
   cvxclustr = derive { name="cvxclustr"; version="1.1.1"; sha256="0idmx4wgz4d0b1xzmlq5bsk2f2q38lpf9c117hg97xsfndzn7vqj"; depends=[Matrix igraph]; };
-  cwhmisc = derive { name="cwhmisc"; version="4.0"; sha256="1lvq2mcbdr38nzbx344c2y9ayi3lv9fkzwwf0l2jzan9s2sppxx2"; depends=[lattice]; };
+  cwhmisc = derive { name="cwhmisc"; version="5.0"; sha256="0b70ssss48kpjyimwm8hwcx82whg77j40qxaaj4vhhqc8d2bzgd2"; depends=[lattice]; };
   cwm = derive { name="cwm"; version="0.0.3"; sha256="1ln2l12whjhc2gx38hkf3xx26w5vz7m377kv67irh6rrywqqsyxn"; depends=[MASS matlab permute]; };
   cxxfunplus = derive { name="cxxfunplus"; version="1.0"; sha256="0kyy5shgkn7wikjdqrxlbpfl3zkkv4v1p8a1vv0xkncwarjs4n8d"; depends=[inline]; };
   cycloids = derive { name="cycloids"; version="1.0"; sha256="00pdxny11mhfi8hf76bfyhd1d53557wcbl2bqwjzlpw5x3vdnsan"; depends=[]; };
···
   dagR = derive { name="dagR"; version="1.1.3"; sha256="13jyhwjvvrjjja18rqzfdcw9ck90qm5yjwd25nygxgdf1894y03b"; depends=[]; };
   Daim = derive { name="Daim"; version="1.1.0"; sha256="19s0p3a4db89i169n2jz7lf8r7pdmrksw7m3cp9n275b5h8yjimx"; depends=[rms]; };
   DAKS = derive { name="DAKS"; version="2.1-2"; sha256="1817s7xd4h2zzaagmnw423qaxpa5fmxi3fh4h9hm2ra9w7nh6ljj"; depends=[relations sets]; };
-  DALY = derive { name="DALY"; version="1.3.0"; sha256="18naa4422zphdcngbdzahjn9gb7vgzg8jk3kpvn7vccjjcl36gjd"; depends=[]; };
+  DALY = derive { name="DALY"; version="1.4.0"; sha256="1gx4q24149q1ipsrinswrm37z1nf4swgq188zsc1xifmw9l28v11"; depends=[]; };
   DAMisc = derive { name="DAMisc"; version="1.2"; sha256="1fkp21inpgfr5lfid8wmajlcsqbnrgl5c35j0863sywvz6gamgc2"; depends=[car effects lattice sm MASS nnet pscl gdata xtable]; };
+  DAMOCLES = derive { name="DAMOCLES"; version="1.0"; sha256="1zk9r17f0nf3w78iwglw3hfz750pnjrd9p1d29bgh31zpc1714wi"; depends=[geiger caper ape deSolve matrixStats]; };
   dams = derive { name="dams"; version="0.1"; sha256="0h0chh9ahsfvqhv1a0dfw88q7gdl1d0w11qcw0w4qmc2ipsl52i6"; depends=[RCurl]; };
   DandEFA = derive { name="DandEFA"; version="1.5"; sha256="0d82rjkgqf4w7qg7irlqvzzav1f23i2gmygkbf8jycaa6xhli80d"; depends=[gplots polycor]; };
   darch = derive { name="darch"; version="0.9.1"; sha256="0syrzmmz43msd51whkb4xy5n0kgcl50yw4w3i9sdd9k20glvwpsx"; depends=[futile_logger ff]; };
   darts = derive { name="darts"; version="1.0"; sha256="07i5349s335jaags352mdx8chf47ay41q7b0mh2xjwn2h9kzgqib"; depends=[]; };
-  DatABEL = derive { name="DatABEL"; version="0.9-4.1"; sha256="1vfsfx8kmjdid5xxmm9sn873gs8nwk3bkdkiav74y1qa1fq2cyd5"; depends=[]; };
-  datacheck = derive { name="datacheck"; version="1.0.0"; sha256="03lms1m3g1rc6jj224hzzbv975xkdd0jsm602zn74j73i227fvmz"; depends=[Hmisc stringr shiny testthat xtable]; };
-  DataCombine = derive { name="DataCombine"; version="0.1.26"; sha256="0wvlr7983v5w0cnwqzv72qzx9abwaw2v2r0bq1ay0n1yxi9wnlf9"; depends=[data_table dplyr]; };
+  DatABEL = derive { name="DatABEL"; version="0.9-5"; sha256="0az3p5a9i1bkx90ky1vldkschkcynzz3a422hpp9a3hayykzrl6g"; depends=[]; };
+  datacheck = derive { name="datacheck"; version="1.0.4"; sha256="1ns5cmsvmqswzpa33mqcmj92b4j3l32v29ki3crg0kayrpdmyrbw"; depends=[Hmisc shiny stringr]; };
+  DataCombine = derive { name="DataCombine"; version="0.2.2"; sha256="0ibcm6xrqb1i4mv4qa8gw38v3pcj8j3zcn7d0383aiv5bcz78qqx"; depends=[data_table dplyr]; };
   dataframes2xls = derive { name="dataframes2xls"; version="0.4.5"; sha256="0lfdp87k0yypwvnsr7803ylzqfy51l37zgwy9zn5nb6n30p588fv"; depends=[]; };
   datalist = derive { name="datalist"; version="0.2"; sha256="0q82wira0sfi63cn66f5cfyd15f19ig7pbmpk56j38a3115l2fmn"; depends=[assertthat]; };
   datamap = derive { name="datamap"; version="0.1-1"; sha256="0qm4zb9ldg4wz1a7paj5ilr1dhyagq81rk9l2v43hmkv52sssgkv"; depends=[DBI]; };
-  datamart = derive { name="datamart"; version="0.4.2"; sha256="1khhjva0kpl4j406lpn4n1bxlxk5wcmz4cbbrw71gi3bg3sxpd5y"; depends=[RJSONIO XML RCurl base64 markdown]; };
+  datamart = derive { name="datamart"; version="0.5.2"; sha256="0c0l157fzkcp30ch4ymaalcx18zhz6sa5srr50w9izhbx3pmldxp"; depends=[RJSONIO XML RCurl base64 gsubfn markdown]; };
   datamerge = derive { name="datamerge"; version="1.0-1"; sha256="03xb48igkh0f91iq6qc2j5xzqfy2n51ci5i850gn09mm9k4lxij1"; depends=[xtermStyle]; };
-  dataone = derive { name="dataone"; version="1.0.0"; sha256="0r2andiv1igygdd3rby4jqs0imhkyfyl0jzb67lc2vjgwh3m2rx0"; depends=[rJava XML dataonelibs rJava XML]; };
-  dataonelibs = derive { name="dataonelibs"; version="1.0.0"; sha256="12qp8vgdqhsfsnh06ml6lz0vvk934q4bpbg79p9l1hsnbxwnj2w6"; depends=[rJava]; };
   dataQualityR = derive { name="dataQualityR"; version="1.0"; sha256="0f2410sd6kldv7zkqsmbz1js0p5iq7zwlnfwmmnlbrd303p35p3j"; depends=[]; };
-  data_table = derive { name="data.table"; version="1.9.2"; sha256="1fchjg939av89m0zsv85w2xcc8qriwkskk0mcsqy8ip6pcfnlg66"; depends=[reshape2]; };
+  dataRetrieval = derive { name="dataRetrieval"; version="1.4.0"; sha256="1ahm2sm71xbgdpp0rsx9d7k30bciv8c0y0z4i18dshc49y4br57a"; depends=[zoo XML RCurl reshape2 lubridate]; };
+  data_table = derive { name="data.table"; version="1.9.4"; sha256="0gsnjjly3mxwfs6q0kjr42vr234mprp8kcyzcsa4dqf2ya2gs1s6"; depends=[chron reshape2]; };
   datautils = derive { name="datautils"; version="0.1.4"; sha256="0adg87p9rzz62cm0s80x71mhsg3yfg93gskv1hs1l8gaj78zd1y1"; depends=[deldir gplots gtools]; };
   dataview = derive { name="dataview"; version="2.0-9"; sha256="0519h2c33v04vwdd8nz9xmqha15svhxdj761d68qmi52jrw6858d"; depends=[xtermStyle]; };
   date = derive { name="date"; version="1.2-34"; sha256="066zsddpw87x1bhl3479k6fd1wrl3x91n5rd454diwmwq2s8i5qb"; depends=[]; };
   DATforDCEMRI = derive { name="DATforDCEMRI"; version="0.55"; sha256="0v26a1gi8l21ga5nqcnyfaa7gc8zxq6wk95b96ajgpdybb0l9s53"; depends=[xtable akima R_oo R_methodsS3 matlab lattice locfit]; };
   dave = derive { name="dave"; version="1.5"; sha256="0sw9hc4y9wdfbnnk6isg7z7sky6ni68pkjxdlrph5m7jcyqphz96"; depends=[labdsv vegan]; };
   Davies = derive { name="Davies"; version="1.1-8"; sha256="1wp7ifbs4vqfrn4vwh09lc53yiagpww91m5mxmcr62mjbw8q7zhr"; depends=[]; };
-  dawai = derive { name="dawai"; version="1.0"; sha256="0vff248ldm24dk7kh2z2sj5m4g7jc5nmnlqay5j4h0gsk95fb8d5"; depends=[mvtnorm ibdreg boot]; };
+  dawai = derive { name="dawai"; version="1.1"; sha256="0icf8iys980z0agyba94xa16400p2vdvg8hg52vvlgfc85ikqfkx"; depends=[mvtnorm ibdreg boot]; };
   dbarts = derive { name="dbarts"; version="0.8-3"; sha256="17yd0xsb9z175p8gjq06yycbxlqc58q0bd5mz31aspwva96brmjh"; depends=[]; };
   dbConnect = derive { name="dbConnect"; version="1.0"; sha256="1vab5l4cah5vgq6a1b9ywx7abwlsk0kjx8vb3ha03hylcx546w42"; depends=[RMySQL gWidgets]; };
   dbEmpLikeGOF = derive { name="dbEmpLikeGOF"; version="1.2.4"; sha256="0vhpcxy702cp3lvlif2fzmvccys8iy7bv1fbg6ki2l8bvn2f7c5p"; depends=[]; };
   dbEmpLikeNorm = derive { name="dbEmpLikeNorm"; version="1.0.0"; sha256="0h5r2mqgallxf9hin64771qqn9ilgk1kpsjsdj2dqfl3m8zg967l"; depends=[dbEmpLikeGOF]; };
   DBFTest = derive { name="DBFTest"; version="1.0"; sha256="0h83ic16z0lg7grjh4jbrxf672qchqv4zzypm2b1mhmzl01jn1wg"; depends=[]; };
   DBGSA = derive { name="DBGSA"; version="1.2"; sha256="04zqh9y3nqcdzs5jn8aaq5idy9zl450ikvl788xs860wlg692qv2"; depends=[fdrtool]; };
-  DBI = derive { name="DBI"; version="0.2-7"; sha256="1qxmcgswrbisvzmaz2s6bcfbh3lb2hmizjxaqkan147r823rh2p9"; depends=[]; };
-  DBKGrad = derive { name="DBKGrad"; version="1.5"; sha256="0k0bl680ynblbla5k9fndh5x7a6f8jyr402a7dg9cjnhhw5q7bxc"; depends=[minpack_lm SDD TSA lattice]; };
+  DBI = derive { name="DBI"; version="0.3.1"; sha256="0xj5baxwnhl23rd5nskhjvranrwrc68f3xlyrklglipi41bm69hw"; depends=[]; };
+  DBKGrad = derive { name="DBKGrad"; version="1.6"; sha256="0207zx0v1x3zhfbs0h1ssxc1b683k111f90k8ybhknb147104knr"; depends=[minpack_lm SDD TSA lattice]; };
   dblcens = derive { name="dblcens"; version="1.1.7"; sha256="02639vyaqg7jpxih8cljc8snijb78bb084f4j3ns6byd09xbdwcw"; depends=[]; };
-  dbmss = derive { name="dbmss"; version="2.1.1"; sha256="1x1148csb6r2xckah3ha595hxx26i3cx3xp99sdwp9dic1hg8ral"; depends=[spatstat Rcpp cubature]; };
+  dbmss = derive { name="dbmss"; version="2.1.1"; sha256="1x1148csb6r2xckah3ha595hxx26i3cx3xp99sdwp9dic1hg8ral"; depends=[Rcpp cubature]; };
   dbstats = derive { name="dbstats"; version="1.0.3"; sha256="1l7yy6m98pkkrzycxcajjjw2h0crbm0fazyq9xg8875ar29i291p"; depends=[cluster pls]; };
   dcemriS4 = derive { name="dcemriS4"; version="0.51"; sha256="14ir9g4jg8asim8f33wizmvj6vm96583h212yygsa6yc301bhad8"; depends=[oro_nifti]; };
   DCGL = derive { name="DCGL"; version="2.1.1"; sha256="16jdlpl09q9pcymk5xxca2ba0vqv2l05wzi4ffb9ffydxpxy61j9"; depends=[igraph]; };
-  dcGOR = derive { name="dcGOR"; version="1.0.2"; sha256="03k6bmnn7qi0192243s9n640fh55rng2r1s8z5zs6ziwrlym7zm2"; depends=[Matrix igraph dnet]; };
+  dcGOR = derive { name="dcGOR"; version="1.0.3"; sha256="1qv4c9kqvm7rig573d4mb5iccz9wp6nmynd8kpf3d9ipijf9p365"; depends=[Matrix igraph dnet]; };
   DCL = derive { name="DCL"; version="0.1.0"; sha256="1ls3x3v0wmddfy7ii7509cglb28l1ix1zaicdc6mhwin0rpp2rx3"; depends=[lattice latticeExtra]; };
   dclone = derive { name="dclone"; version="2.0-0"; sha256="1j8g955rvdgcmc9vnz3xizlkq8w1bslav5h72igvzzffcvqbj9hq"; depends=[coda]; };
   DCluster = derive { name="DCluster"; version="0.2-6"; sha256="0g7d15kq3dbrjmd5fmiwwg2b6gakz1lpsgrpkg6q89pzwlqx8xr9"; depends=[boot spdep MASS]; };
···
   DDD = derive { name="DDD"; version="2.5"; sha256="1svm6l8ssnnf5g3hci46pvw6amisyy1dvfm0mvdryglgfc8vv6jd"; depends=[deSolve ape ade4]; };
   ddepn = derive { name="ddepn"; version="2.2"; sha256="1zwz664jq6qvf1lcwyfn6kyn6dwxhh2nnyirayx0vqs9c6xzpir7"; depends=[lattice coda igraph gam gplots]; };
   DDHFm = derive { name="DDHFm"; version="1.1.1"; sha256="03zs2zbrhjcb321baghva7b8y61c8p9z6bfj2vg9cvadpb0260nk"; depends=[]; };
-  DDIwR = derive { name="DDIwR"; version="0.1-0"; sha256="0rf1gj1lzbivkz0pqxbih1zqjccv2rhaqrfdhpwbsqhlw12qkkg5"; depends=[XML foreign]; };
+  DDIwR = derive { name="DDIwR"; version="0.2-0"; sha256="0dqbldl5c6b8i5q3yk0hwd12lp8z9j4ilnmsqrkj69fv7mys9q3k"; depends=[XML foreign]; };
   ddst = derive { name="ddst"; version="1.03"; sha256="0zbqw4qmrh80jjgn8jzbnq3kykj1v5bsg6k751vircc0x9vnig3j"; depends=[orthopolynom evd]; };
   deal = derive { name="deal"; version="1.2-37"; sha256="1nn2blmxz3j5yzpwfviarnmabbyivc25cbfhcf814avrhpysvpxa"; depends=[]; };
   deamer = derive { name="deamer"; version="1.0"; sha256="1xbxr78n6s1yhf192ab4syi1naqlwl9z4cxzchrkw80q7bxqfiz8"; depends=[]; };
   debug = derive { name="debug"; version="1.3.1"; sha256="0mpwi6sippxyr1l8xf48xqv6qw6pmfkxs13k1gjyd7bkzlbchgqd"; depends=[mvbutils]; };
   decctools = derive { name="decctools"; version="0.2.0"; sha256="0k5w49s9s51m7w1h5adk26nw1ypwv5g1mlal78qmx5a4jzaf5bw9"; depends=[XLConnect stringr XML reshape2 RCurl lubridate plyr]; };
   DECIDE = derive { name="DECIDE"; version="1.1"; sha256="1g6l2k4nmspg5y4gzxcnx58kix0br6sgmf54jlaxk69nkvdxm9xy"; depends=[]; };
+  decompr = derive { name="decompr"; version="1.2"; sha256="0fklg2xv4xbd9bxvmgm2gz0gc3pb4g54xl5gb28r80cm29vg1js4"; depends=[]; };
   decon = derive { name="decon"; version="1.2-4"; sha256="1v4l0xq29rm8mks354g40g9jxn0didzlxg3g7z08m0gvj29zdj7s"; depends=[]; };
   Deducer = derive { name="Deducer"; version="0.7-7"; sha256="1x97rz92v1hx30fdmgd1lnzydgygjp6zh20v082qymvh997l1zzd"; depends=[ggplot2 JGR car MASS rJava e1071 scales plyr foreign multcomp effects]; };
   DeducerExtras = derive { name="DeducerExtras"; version="1.7"; sha256="0sngsq31469a74y7nhskl82fwy2i0ga68m9g6b1xyhxz1a8kgvlg"; depends=[Deducer irr rJava]; };
···
   DeducerSpatial = derive { name="DeducerSpatial"; version="0.7"; sha256="0133qk3yjcifyha7c4pqr5s0hmbci72bzgil2r0sxjmrljs3q727"; depends=[JavaGD Deducer sp maptools OpenStreetMap scales rgdal UScensus2010 Hmisc]; };
   DeducerSurvival = derive { name="DeducerSurvival"; version="0.1-0"; sha256="03qk3y4pibvrxbnxbm5rlksw807dvbilip1jbpn1r7k02ibzq676"; depends=[Deducer]; };
   DeducerText = derive { name="DeducerText"; version="0.1-2"; sha256="0if2p9j74wa5rva4iv0i8iax22grl9j7lqcqzqlywjgqwnlzxa05"; depends=[Deducer tm wordcloud RColorBrewer SnowballC]; };
-  deducorrect = derive { name="deducorrect"; version="1.3-4"; sha256="0hpq0cahfar9y9f6mvpmx35mvinwnnmqq16y9yzrmzbxjkylz2ja"; depends=[editrules]; };
+  deducorrect = derive { name="deducorrect"; version="1.3-5"; sha256="06lcqnay36fgkzvgbiq7b67r9lfgll3lxfr1pmx14vmivshb6mmm"; depends=[editrules]; };
   deepnet = derive { name="deepnet"; version="0.2"; sha256="09crwiq12wzwvdp3yxhc40vdh7hsnm4smqamnk4i6hli11ca90h4"; depends=[]; };
   Defaults = derive { name="Defaults"; version="1.1-1"; sha256="0ikgd5mswlky327pzp09cz93bn3mq7qnybq1r64y19c2brbax00d"; depends=[]; };
   degenes = derive { name="degenes"; version="1.1"; sha256="1xxn5j06qizywimrp1pl8z3yjdy1a167b9jnm77gmv87rp6j240c"; depends=[]; };
   degreenet = derive { name="degreenet"; version="1.2"; sha256="07b6phgyydfp8jwjvrqcvcx3b2qhbkr44xkcn20ya1igsbyh6kzz"; depends=[]; };
-  Delaporte = derive { name="Delaporte"; version="2.2-0"; sha256="063cqcizqby81k71lnkrnrcxafrnwqfj20y1k38yp9giwgm1ndxs"; depends=[Rcpp]; };
+  Delaporte = derive { name="Delaporte"; version="2.2-1"; sha256="09xs1gyz0wkjw0k4b5ahy7zb8xjrg610bbdvvyxkfbh9jaf8q90b"; depends=[Rcpp]; };
   deldir = derive { name="deldir"; version="0.1-6"; sha256="1hbvkcyclnrrh3xrixn23z1f51n41khcqi5b6gx40qpq0zsbn7sn"; depends=[]; };
   deltaPlotR = derive { name="deltaPlotR"; version="1.4"; sha256="0lmwwaazyrbnp4nsvl2mydcpij34xv9hbyqwcjwx4vij33034k2p"; depends=[MASS]; };
   Demerelate = derive { name="Demerelate"; version="0.8-1"; sha256="1qngwlzzpd2cmij5ldrmhcn12s9yxd0rargc5vzvkrwcqpkgylkn"; depends=[Formula fts sfsmisc vegan mlogit]; };
   DEMEtics = derive { name="DEMEtics"; version="0.8-7"; sha256="1s59qim60d4gp5rxjacdbmxdbpdm7cy9samn088w8fs0q232vjjx"; depends=[]; };
   demi = derive { name="demi"; version="1.1.1"; sha256="19zszmjcczmz9qjp1dhvf92w134266w4qwskdpz36q72m5455zdb"; depends=[plyr R_utils]; };
-  demography = derive { name="demography"; version="1.17"; sha256="01yq3wzzcdclgklxqr3sgxglnw18ljxnhzlmzaj9fzqqdw6xngv3"; depends=[forecast rainbow ftsa cobs mgcv strucchange RCurl]; };
+  deming = derive { name="deming"; version="1.0-1"; sha256="00v59qb6qwbwsvcwi59d0c0g3czfz1190ccj4dx6yarizr4g6cy8"; depends=[boot]; };
+  demography = derive { name="demography"; version="1.18"; sha256="17r7sz5ikngc4qg495wmn99xawmllpx7rw2gpv8q8bypbc47wlfv"; depends=[forecast rainbow ftsa cobs mgcv strucchange RCurl]; };
   demoKde = derive { name="demoKde"; version="0.9-3"; sha256="1nkvsjms1gfvjz5l7zza0cgx4yqmn2kgnax44pysn0zqmhfny8bw"; depends=[]; };
-  dendextend = derive { name="dendextend"; version="0.16.1"; sha256="1qgvr26kn016qwgbaff4r8xqpsvxl3plv1nxafq7rq4havzhfgf9"; depends=[magrittr whisker ape]; };
+  dendextend = derive { name="dendextend"; version="0.17.5"; sha256="0mjmxmkla4vhni0bgm6z9375pjcghccd10595bq1z84g1fxzqrjc"; depends=[magrittr whisker]; };
   dendextendRcpp = derive { name="dendextendRcpp"; version="0.5.1"; sha256="062f7yjsg196v8c09h6gvbhi0fzgwg40a8xhi751avkjc68z30cq"; depends=[Rcpp dendextend]; };
   dendroextras = derive { name="dendroextras"; version="0.2.1"; sha256="0k1w374r4fvfcbzhrgcvklccjggyz755z7wc2vqfi3c5hvdb9ns4"; depends=[]; };
   DendSer = derive { name="DendSer"; version="1.0.1"; sha256="0id6pqx54zjg5bcc7qbxiigx3wyic771xn9n0hbm7yhybz6p3gz9"; depends=[gclus seriation]; };
-  dendsort = derive { name="dendsort"; version="0.2.1"; sha256="10qhvxbyziy0xw40j35xsk4sixqc4l0653jgd01spmn4dm1ihj33"; depends=[]; };
+  dendsort = derive { name="dendsort"; version="0.3.2"; sha256="0qj65jraj6ksmsfsrc4f3y8m7x5lqg9bqc9yb5s3bav2r8qjyhv6"; depends=[]; };
   denpro = derive { name="denpro"; version="0.9.1"; sha256="0ihgk300njhp6dzm1gsmknlx4c5h6kiwprgv3l3f29s6gdxx4f6n"; depends=[]; };
   densityClust = derive { name="densityClust"; version="0.1-1"; sha256="1apv9n871dshln5ccg8x3pwqi8yfx73ijfqsvzcljqnv36qpqpqd"; depends=[]; };
-  Density_T_HoldOut = derive { name="Density.T.HoldOut"; version="1.02"; sha256="0xjr6z136c0vgsb609xcqf6g4ivyvgpfr4qkwdlj9z5g7gcf3bhl"; depends=[histogram]; };
+  Density_T_HoldOut = derive { name="Density.T.HoldOut"; version="2.00"; sha256="0kh5nns1kqyiqqfsgvxhx774i2mf4gcim8fp5jjyq577x4679r31"; depends=[histogram]; };
   denstrip = derive { name="denstrip"; version="1.5.3"; sha256="10h8ivs7nd6gkf93zvqzqjb1lzfabvvs182636m67f86jfn6d4y4"; depends=[]; };
   DEoptim = derive { name="DEoptim"; version="2.2-2"; sha256="0yayp056knd7d6bvk07k7rnj79vibmkzflnk71dsfbkk5yx7vc77"; depends=[]; };
-  DEoptimR = derive { name="DEoptimR"; version="1.0-1"; sha256="02c1pmpg42wwmp3wjfi09qbidclclwmrmd3gbfvrnivq7ngp2zil"; depends=[]; };
+  DEoptimR = derive { name="DEoptimR"; version="1.0-2"; sha256="00viy7x3br3094az635lmjydm826d48vv2f14rwmdhqmv03066kq"; depends=[]; };
   depend_truncation = derive { name="depend.truncation"; version="2.1"; sha256="1b13mqm8pjw0r0z5h7vizz15nzhslxhcn4cb8pzadyq98mcmk4g2"; depends=[mvtnorm]; };
   depmix = derive { name="depmix"; version="0.9.12"; sha256="0brs6cskrk52dn41zaqa59dxz377sl9lnh89457d3ykbj4jbc97c"; depends=[MASS]; };
   depmixS4 = derive { name="depmixS4"; version="1.3-2"; sha256="18xmn5fv9wszh86ph91yypfnyrxy7j2gqrzzgkb84986fjp2sxlq"; depends=[nnet MASS Rsolnp]; };
   depth = derive { name="depth"; version="2.0-0"; sha256="1aj4cch3iwb6vz0bzj4w5r6jp2qs39g8lxi2nmpbi3m7a6qrgr2q"; depends=[abind rgl circular]; };
+  DepthProc = derive { name="DepthProc"; version="1.0.1"; sha256="11hzqmdpyxbmq7w0xwafk9gnj9k2vcf7bxf4jy743m770kqjsamr"; depends=[ggplot2 Rcpp rrcov np MASS lattice sm geometry]; };
   depthTools = derive { name="depthTools"; version="0.4"; sha256="1699r0h1ksgrlz9xafw2jnqfsc7xs0yaw97fc6dv3r11x6gxk00y"; depends=[]; };
+  descomponer = derive { name="descomponer"; version="1.0"; sha256="0n9s0fa8gv13sv1qffi11si8fdcg8pvxhpdwfkrsl3ky9mrd69yg"; depends=[taRifx]; };
   descr = derive { name="descr"; version="1.0.3"; sha256="0x3hpr1sy6cpqn434i5z9g4n2insfv7hmks9igx3fnkr5vad7q8l"; depends=[xtable]; };
   DescribeDisplay = derive { name="DescribeDisplay"; version="0.2.4"; sha256="13npxq1314n4n08j6hbmij7qinl1xrxrgc5hxpbbpbd16d75c7iw"; depends=[proto reshape2 ggplot2 plyr scales GGally]; };
-  DescTools = derive { name="DescTools"; version="0.99.7"; sha256="0a53r3spwwq641mgzgj7xipfbrgnwd0radn92n17ra4ffxa6f3bh"; depends=[boot]; };
+  DescTools = derive { name="DescTools"; version="0.99.8.1"; sha256="1na2j0j7mkk0j2y3jac5hslmr3qp5924kv4z9zrwiymjb52jbwmr"; depends=[boot]; };
   deseasonalize = derive { name="deseasonalize"; version="1.35"; sha256="1fjsa7g34dckjs6mx9b10m99byxagggm0p9pw2f1vmpjqlasin0l"; depends=[lattice FitAR]; };
   designGG = derive { name="designGG"; version="1.1"; sha256="1x043j36llwd7kd4skbpl2smz2ybsxjqf5yd1xwqmardq60gdv2w"; depends=[]; };
   desirability = derive { name="desirability"; version="1.6"; sha256="17g998fmps4ypiscqd2nmh38sd0q7k3r60h2zdrq3wbm1vyyzygk"; depends=[]; };
   desire = derive { name="desire"; version="1.0.7"; sha256="0jmj644nj6ck0gsk7c30af9wbg3asf0pqv1fny98irndqv508kf6"; depends=[loglognorm]; };
   DESnowball = derive { name="DESnowball"; version="1.0"; sha256="012kdnxmzap6afc3ffkcvk1mazlkp286av6g9fwz2wcbf5mh9n1m"; depends=[clue combinat MASS cluster]; };
-  deSolve = derive { name="deSolve"; version="1.10-9"; sha256="03zqq3lfcc9k0zyfm2mhyzkq2crn1m5gaw1w0x377zrrasl3fw9g"; depends=[]; };
+  deSolve = derive { name="deSolve"; version="1.11"; sha256="014fbrgzlarg2w27kq9qy7631hvhlf7ldrn5g8x2xibb260832s1"; depends=[]; };
   detect = derive { name="detect"; version="0.3-2"; sha256="1mjc8h3xb2zbj4dxala8yqbdl94knf9q0qvkc37ag1b2w4y2d2b0"; depends=[Formula]; };
   deTestSet = derive { name="deTestSet"; version="1.1.1"; sha256="1qc8sj44zlndyr9k5r179pmy8kyq0wawz7q2xgdmnx27j2rjls43"; depends=[ReacTran]; };
+  DetMCD = derive { name="DetMCD"; version="0.0.1"; sha256="1bxj7yf98bg185ig2svpkhky6hw14ijb8hwc6g5a3xx6xa9hs57y"; depends=[matrixStats pcaPP robustbase MASS]; };
   detrendeR = derive { name="detrendeR"; version="1.0.4"; sha256="1z10gf6mgqybb9ml6z3drq65n7g28h2pqpilc2h84l6y76sy909c"; depends=[dplR]; };
   DetSel = derive { name="DetSel"; version="1.0.2"; sha256="0igkccclmjwzk7sl414zlhiykym0qwaz5p76wf4i7yrpjgk7mhl9"; depends=[ash]; };
   devEMF = derive { name="devEMF"; version="1.2"; sha256="14nqx1gy6hlkmzrrayd7kgljla9flxx4xm329436znd66184sass"; depends=[]; };
-  Devore6 = derive { name="Devore6"; version="0.6-0"; sha256="093jbz405wi0zf4nhracy80pl3m7255lq7jkbymfd5snpr9gnb53"; depends=[]; };
   Devore7 = derive { name="Devore7"; version="0.7.6"; sha256="1m18p8h9vv4v0aq2fkjyj39vzb8a09azbbczhfiv4y88w540i8nw"; depends=[MASS lattice]; };
-  devtools = derive { name="devtools"; version="1.5"; sha256="1gd8skhj7612zbci361h3yys6iwxr7dvgrjr99vs7b0c0mglm7hp"; depends=[httr RCurl memoise whisker evaluate digest]; };
+  devtools = derive { name="devtools"; version="1.6.1"; sha256="0aza8y80bb9cv8i9vx1w2511qzf0anssig5xry0mnnpdipk7gjb5"; depends=[httr RCurl memoise whisker evaluate digest rstudioapi jsonlite]; };
   df2json = derive { name="df2json"; version="0.0.2"; sha256="10m7xn7rm4aql1bzpckjcx5kvdw44m1pxgzqkgkd40lzqb1cwk18"; depends=[rjson]; };
   dfcrm = derive { name="dfcrm"; version="0.2-2"; sha256="1kwgxfqnz2bcicyb27lp6bnvrj30lqjpn5fg7kaqshgkj53g0s4f"; depends=[]; };
   dfexplore = derive { name="dfexplore"; version="0.2.1"; sha256="04nbhn59l1kas26nwj4qflkjvvr33sj1mm7zg7fhvya85gvlhrbf"; depends=[ggplot2]; };
···
   diagram = derive { name="diagram"; version="1.6.2"; sha256="0jxy1rwph29w8q1383ykbnpq61p220azyv6miq1dx0v2fk5579da"; depends=[shape]; };
   DiagTest3Grp = derive { name="DiagTest3Grp"; version="1.6"; sha256="04dxyyqv333rkjf2vlfpal59m7klhw6y7qilym6nw78qb1kqqys7"; depends=[car KernSmooth gplots]; };
   diaplt = derive { name="diaplt"; version="1.2.1"; sha256="0pya6rqzsvc5nd3smhydvabarglc4nn04q605vbllmbhq9rv00pa"; depends=[]; };
-  dice = derive { name="dice"; version="1.1"; sha256="0wnmiyrf57kjkby26z9lgplphv3p15dfxgsbbsgwq65md2d6idyn"; depends=[gtools]; };
+  dice = derive { name="dice"; version="1.2"; sha256="0gic7lqnsdmwv3dbzwwmcwdfyfqlq8kpr2pciqphd1j2ligzwl3s"; depends=[gtools]; };
   DiceDesign = derive { name="DiceDesign"; version="1.6"; sha256="1djq7clga3cvpgfycs3zjj106213yhfj9909sqrni70nj1nwdpj9"; depends=[]; };
   DiceEval = derive { name="DiceEval"; version="1.3"; sha256="1vp9zwd09cwl3c8066jr9d3w4yic70fvd40r7hsj2y8d0bhiwl82"; depends=[DiceKriging]; };
   DiceKriging = derive { name="DiceKriging"; version="1.5.3"; sha256="14826fwsj6cifksyd605nbfxlfwnapr80inm4chjmm0f2xjc4r5n"; depends=[]; };
   DiceOptim = derive { name="DiceOptim"; version="1.4"; sha256="11k6gqw8bcfcnxhm6a039vnkdm7526h3aszjqwfp1s7m157w8kp2"; depends=[DiceKriging rgenoud MASS lhs]; };
   DiceView = derive { name="DiceView"; version="1.3-1"; sha256="0c7i1jy13d5bj822q1rp0d7gmmfjd00jaah34pnj8fzwyrq404z9"; depends=[DiceKriging DiceEval rgl]; };
   dichromat = derive { name="dichromat"; version="2.0-0"; sha256="1l8db1nk29ccqg3mkbafvfiw0775iq4gapysf88xq2zp6spiw59i"; depends=[]; };
-  dicionariosIBGE = derive { name="dicionariosIBGE"; version="1.5"; sha256="03gsp5h39a4s6zgvwnrfdyj1wzrp688qk8g5hdr8rk3a2rzbbzgg"; depends=[]; };
+  dicionariosIBGE = derive { name="dicionariosIBGE"; version="1.6"; sha256="1rss1ydhcn6sma2lmlpq6s0h3dglwc20w499x1jzkcjnzc1rc7gl"; depends=[]; };
   dielectric = derive { name="dielectric"; version="0.2.3"; sha256="1p1c0w7a67zxp1cb99yinylk5r1v89mmpfybcy94ydydhydbhivk"; depends=[]; };
   DierckxSpline = derive { name="DierckxSpline"; version="1.1-9"; sha256="07bp86zfbcp3d7jdhfap3z1sy15534qvdapdzscbyr2x82mmqpy3"; depends=[lattice PolynomF fda]; };
   diffdepprop = derive { name="diffdepprop"; version="0.1-9"; sha256="0mgrm1isr26v2mcm6fkzc7443ji00vpnqmw4zngx81n7442b3cl2"; depends=[gee rootSolve PropCIs]; };
···
   DIFlasso = derive { name="DIFlasso"; version="1.0-1"; sha256="048d5x9nzksphsdk9lwfagl165bb40r0pvjq2ihvhqvxspgpar4b"; depends=[grplasso penalized miscTools]; };
   difR = derive { name="difR"; version="4.5"; sha256="0qlaqpywyjggw74h5y5r2aivcyknc6b7l8b1p69g3lyx4d2hz8wp"; depends=[lme4 ltm]; };
   digest = derive { name="digest"; version="0.6.4"; sha256="06xbklq6laffv609hsfqyj04fhdnr9bgjh6ala7253h9vvkjch1k"; depends=[]; };
-  Digiroo2 = derive { name="Digiroo2"; version="0.6"; sha256="1b1ahhqz5largjadlk5n6nw2183c05k28mksb1wm26y0lps0vdgr"; depends=[maptools spatstat spdep]; };
+  Digiroo2 = derive { name="Digiroo2"; version="0.6"; sha256="1b1ahhqz5largjadlk5n6nw2183c05k28mksb1wm26y0lps0vdgr"; depends=[maptools spdep]; };
   dils = derive { name="dils"; version="0.8.1"; sha256="1q6ba9j14hzf7xy895mzxc6n9yjgind55jf350iqscwzxf7ynp33"; depends=[igraph Rcpp]; };
   DIME = derive { name="DIME"; version="1.2"; sha256="11l6mk6i3kqphrnq4iwk4b0ridbbpg2pr4pyqaqbsb06ng899xw0"; depends=[]; };
   dinamic = derive { name="dinamic"; version="1.0"; sha256="0mx72q83bbwm10ayr3f1dzwr5wgz7gclw7rh39yyh95slg237nzr"; depends=[]; };
···
   DIRECT = derive { name="DIRECT"; version="1.0"; sha256="129bx45zmd6h7j6ilbzj2hjg4bcdc08dvm2igggi8ajndl1l5q9j"; depends=[]; };
   directlabels = derive { name="directlabels"; version="2013.6.15"; sha256="083cwahz320r4w4jbh62pxmzn1i1hixp398zm8f2fpzh4qp5y44g"; depends=[quadprog]; };
   directPA = derive { name="directPA"; version="1.0"; sha256="16bllp7afb83y73zr5wxfkad7vxzfqwdmhcxfa5jml4hlvkhgv1r"; depends=[]; };
-  DirichletReg = derive { name="DirichletReg"; version="0.4-0"; sha256="1azrqx1wa7yaary3qk4pz605xzvzdvwqwz5darl2aighwafzgy8d"; depends=[maxLik Formula rgl]; };
+  DirichletReg = derive { name="DirichletReg"; version="0.5-2"; sha256="0x1s9x7dynykgbfdnsgpbnvq4dyc43wakmbv8r3gi9prn4af7a5k"; depends=[Formula rgl maxLik]; };
   dirmult = derive { name="dirmult"; version="0.1.3-4"; sha256="1r9bhw1z0c1cgfv7jc0pvdx3fpnwplkxwz8j8jjvw14zyx803rnz"; depends=[]; };
   Disake = derive { name="Disake"; version="1.0"; sha256="1i58q6dqk980mk8qj66hbqd64wmkvpa4v0z6c0q3lkirsvdm4cwv"; depends=[]; };
   disclap = derive { name="disclap"; version="1.5"; sha256="0piv9gxhxcd4pbh5qjn9c3199f32y3qiw5vy8cr77ki70dnmr66n"; depends=[]; };
···
   discretization = derive { name="discretization"; version="1.0-1"; sha256="00vq2qsssnvgpx7ihbi9wcafpb29rgv01r06fwqf9nmv5hpwqbmp"; depends=[]; };
   discrimARTs = derive { name="discrimARTs"; version="0.2"; sha256="088v4awic4bhzqcr7nvk2nldf8cm1jqshg2pzjd2l2p1cgwmlxib"; depends=[RUnit]; };
   DiscriMiner = derive { name="DiscriMiner"; version="0.1-29"; sha256="1ii8aa4dwfk991qdnpmkva20wvs5fqcna9030c799ybf11qpdass"; depends=[]; };
-  diseasemapping = derive { name="diseasemapping"; version="0.7.5"; sha256="0i5za00p2pgbwak5gl006yamklzg2m6xcxmqba1kiz16dddfscqq"; depends=[sp mgcv]; };
+  diseasemapping = derive { name="diseasemapping"; version="1.1.0"; sha256="1jsg7np0ghi33pavnybimnfkay22k5p3fjiv5fs7zk2v4cykpi1d"; depends=[sp]; };
   diskmemoiser = derive { name="diskmemoiser"; version="1.0-1"; sha256="0lacadc3mm1w55sff3lphp3xrr1inn2r382c1z8gf6kzal7c9pd8"; depends=[digest]; };
-  dismo = derive { name="dismo"; version="0.9-3"; sha256="1vr24kx4mv15wivpk6lw1j8l4422p5al80fld8x6fcp31sf7q652"; depends=[raster sp]; };
+  dismo = derive { name="dismo"; version="1.0-5"; sha256="1zzzj4r96a35ghngszym1dg1wbr8mvinn7cvmqwnnjn3c2zq4w0g"; depends=[raster sp]; };
   disp2D = derive { name="disp2D"; version="1.0"; sha256="0q5bds2r1mqzcwmnj61dmwqv6b0s0scq5h3nim47q3wp0n4gbslz"; depends=[geometry]; };
   displayHTS = derive { name="displayHTS"; version="1.0"; sha256="0mqfdyvn2c5c3204ykyq29ydldsq0kb3a1d7mrzqr7cvrj1ahlqa"; depends=[]; };
   dispmod = derive { name="dispmod"; version="1.1"; sha256="141gzhnmxxl495cpjgd4wnvdrbz6715m6sd1pycrbaqrsdc1pv57"; depends=[]; };
   dissUtils = derive { name="dissUtils"; version="1.0"; sha256="00fzlmkdfw2s3k824wp2pk3v7cvxnywi1hfp86g4mm95z2qlw9br"; depends=[]; };
-  Distance = derive { name="Distance"; version="0.9.1"; sha256="04bk0kplpmz3qifyar1fs8jrkyk55a4z1yxwkxx957r419afl6l4"; depends=[mrds]; };
+  Distance = derive { name="Distance"; version="0.9.2"; sha256="0mxwn9mwzfxnqpxvb4h8955c75hvnk09ji330924dfmi3fca8xjf"; depends=[mrds]; };
   DistatisR = derive { name="DistatisR"; version="1.0"; sha256="1il00v26q68h5dd5c9lm2jblgn8hs6n0457r13mlw6r7pcj0158j"; depends=[prettyGraphs car]; };
   distfree_cr = derive { name="distfree.cr"; version="1.0"; sha256="13y714l6b3kkpp75fdrsbdclgj1vw1xsvbj9pxi4lkwf11wwmrqr"; depends=[]; };
   distillery = derive { name="distillery"; version="1.0-1"; sha256="0hfj4qbfb5219dm7yrgf2h4jrh2qsjhwrbv8gbrxcr0xf6gqbxmv"; depends=[]; };
···
   distrEx = derive { name="distrEx"; version="2.5"; sha256="0mbccd53r9wl875i702j14wlrv7pjgrwzlnyc511cqa5pg3mn81i"; depends=[distr]; };
   DistributionUtils = derive { name="DistributionUtils"; version="0.5-1"; sha256="1in2k7xsaa0wadjgdh8m0v25v0dzx89pb20i5nsa19vx2iiysqbd"; depends=[RUnit]; };
   distrMod = derive { name="distrMod"; version="2.5.2"; sha256="1vgb06qhfpav93xv9lamzmn8mccx5bqdfplkcqpv3i7qlgmngvh9"; depends=[distr distrEx RandVar MASS]; };
-  distrom = derive { name="distrom"; version="0.2"; sha256="1mvqqwaa6jwg483gjzgb0wplg1r8p7q7ihypa2z0c8pcbja8i9ff"; depends=[Matrix gamlr]; };
+  distrom = derive { name="distrom"; version="0.3-1"; sha256="17x58lx411wlb153rv1nlmf1g528w1az8nsswvwscv15n7bvdkdf"; depends=[Matrix gamlr]; };
   distrRmetrics = derive { name="distrRmetrics"; version="2.5"; sha256="0c7fhckw7hav68gag8ymgicywl2vbnvqpjxca0x24wpdi1gs4jf6"; depends=[distr fBasics fGarch]; };
   distrSim = derive { name="distrSim"; version="2.5.2"; sha256="0ipg4l2vyifaj1r9a4cc8kg32s65jpz5wxrlnrix95xk5wasdpbh"; depends=[setRNG distr]; };
   distrTeach = derive { name="distrTeach"; version="2.5"; sha256="0a7qfqpirzcd94dvcvmprhhj2j1yl3lpizsi8mdqr19zcp6dw21k"; depends=[distr distrEx]; };
···
   diveRsity = derive { name="diveRsity"; version="1.9.5"; sha256="0rybnjkkxsam0fhsfcxb2h00p65169iw8kb7xgzzgzdfi258zp9s"; depends=[ggplot2 shiny qgraph Rcpp]; };
   DiversitySampler = derive { name="DiversitySampler"; version="2.1"; sha256="1sfx7craykb82ncphvdj19mzc0kwzafhxlk9jcxkskygrlwsxfgg"; depends=[]; };
   DivMelt = derive { name="DivMelt"; version="1.0.3"; sha256="03vkz8d283l3zgqg7bh5dg3bss27pxv4qih7zwspwyjk81nw3xmr"; depends=[glmnet]; };
-  dixon = derive { name="dixon"; version="0.0-5"; sha256="0x7x0l7p8kmkfqqqah8hck2r96b3w8padd41skd3q35vq8kmnsqc"; depends=[splancs spatstat]; };
+  dixon = derive { name="dixon"; version="0.0-5"; sha256="0x7x0l7p8kmkfqqqah8hck2r96b3w8padd41skd3q35vq8kmnsqc"; depends=[splancs]; };
   dkDNA = derive { name="dkDNA"; version="0.1.0"; sha256="1waqj8l48yqlzi3rb3ilxyx79n5d4w0sp02flvynwaxck6jvh8gc"; depends=[]; };
-  dlm = derive { name="dlm"; version="1.1-3"; sha256="1mk5hlhm4bm8a5ilrbiwqggj1wg2jiv44s6gjjkjigs24673lg27"; depends=[]; };
+  dlm = derive { name="dlm"; version="1.1-4"; sha256="0hyphl90bqc16j7in750pmiyq28hmc46kxgv7gj17c8xl9c9xqxm"; depends=[]; };
   dlmap = derive { name="dlmap"; version="1.13"; sha256="0s6wlkggkm3qndwyvw72xv1n0mcjb7ss3ajbq2ll6rv30splq0db"; depends=[qtl ibdreg wgaim nlme mgcv]; };
   dlmodeler = derive { name="dlmodeler"; version="1.4-2"; sha256="06gqvk2wrzz4kpsh4vyrbqwmxirsvg78qj7clvcxdac0sfqn4gl7"; depends=[KFAS]; };
+  DLMtool = derive { name="DLMtool"; version="1.34"; sha256="0ir1131r408ya235k7syg854bfgsim39hh2k1498n5hrbaa99xfx"; depends=[snowfall boot MASS]; };
   dlnm = derive { name="dlnm"; version="2.1.3"; sha256="044khdhk4dgd09cwmidsfa2rgd43h7wnd48bmmrnsvj3314bic0f"; depends=[nlme]; };
   dma = derive { name="dma"; version="1.2-0"; sha256="1q0zclp7y1y1ksy8j64z05jy1fi0lmgd9a5cswxyl8l4xbs894wn"; depends=[]; };
   DMR = derive { name="DMR"; version="2.0"; sha256="1kal3bvhwqs00b6p6kl0ja35pcz9v9y569148qfhy94m319fcpzm"; depends=[magic]; };
···
   DMwR = derive { name="DMwR"; version="0.4.1"; sha256="1qrykl9zdvgm4c801iix5rxmhk9vbwnrq9cnc58ms5jf34hnmbcf"; depends=[lattice xts quantmod zoo abind rpart class ROCR]; };
   dna = derive { name="dna"; version="1.1-1"; sha256="0gw70h1j67h401hdvd38d6jz71x1a6xlz6ziba6961zy6m3k5xbm"; depends=[]; };
   DNAprofiles = derive { name="DNAprofiles"; version="0.2"; sha256="15la7csf45175g4hkfdz41jgbj5njad5d4jwfhpadxkb9v2mgaw4"; depends=[RcppProgress Rcpp bit]; };
-  DNAtools = derive { name="DNAtools"; version="0.1-8"; sha256="146r59lhj57b0dlwwsddks9lpfdyvbjm8i5mvkc6w9wwj32g931i"; depends=[Rsolnp multicool]; };
+  DNAtools = derive { name="DNAtools"; version="0.1-21"; sha256="1ncx2rmxb0ip804x6xznfv8brjpp518fhnm1653mlrsl3hpzrh88"; depends=[Rsolnp multicool Rcpp]; };
   DnE = derive { name="DnE"; version="1.01"; sha256="04b2zz1b47nxpl8060ravybwq6y3s08fbkg5a4qiiaz9a84kvbhw"; depends=[]; };
-  dnet = derive { name="dnet"; version="1.0.5"; sha256="12kx9701gl33rhym6xzfhqjlz1xq0zzqblha6rn9l8wkkkva3aq5"; depends=[igraph Matrix]; };
+  dnet = derive { name="dnet"; version="1.0.6"; sha256="0zhv2yfrlhfwjbgbvjzmw3c5g5rj33n8l2npdf6b4nqz0c0hc1jn"; depends=[igraph Matrix]; };
   DOBAD = derive { name="DOBAD"; version="1.0.3"; sha256="0q8sjcbfdg66jrhii98kls1l2gzx5s8nzv5xrbyl497cn6ysiww0"; depends=[numDeriv]; };
-  doBy = derive { name="doBy"; version="4.5-10"; sha256="1axdy61n6jf0chr9276aj16h4dbq9nh4cw82md2r7mgw746ccvcn"; depends=[survival MASS Matrix lme4]; };
-  docopt = derive { name="docopt"; version="0.1.1"; sha256="1fgwh5r216g4ndgpwpp8vb7scls5f47mn29y1fl9rp4mwzr2vpdh"; depends=[stringr]; };
+  doBy = derive { name="doBy"; version="4.5-11"; sha256="0cfg0lkyy7inpwvhhylfzv6xpq81i6163cr4m2wz3h9crmq0cnnx"; depends=[survival MASS Matrix]; };
+  docopt = derive { name="docopt"; version="0.3"; sha256="1qiivvbqx9mirzqqg3wbj7mi5fdw5xjsq983pq4fpms6fpx4j9kq"; depends=[stringr]; };
+  documair = derive { name="documair"; version="0.6-0"; sha256="1pphcbx90n9xn8a7gvfrwzfapwqgpbl3gg2grm7chfxgcp7i99i2"; depends=[]; };
   Dodge = derive { name="Dodge"; version="0.8"; sha256="1vnvqb2qvl6c13s48pyfn1g6yfhc60ql3vn7yh2zymxcsr1gxgcw"; depends=[]; };
-  DoE_base = derive { name="DoE.base"; version="0.26-1"; sha256="07mcbxz9xf87ldsigr8bxczhq487ixv4m2xcz622sc43nbzri8la"; depends=[conf_design vcd combinat MASS]; };
-  DoE_wrapper = derive { name="DoE.wrapper"; version="0.8-9"; sha256="1f4q7i0d620wn13c6l3bifqqr5b1g1ihdw5fw92yaw1zv9dwzx0c"; depends=[FrF2 DoE_base rsm lhs DiceDesign AlgDesign]; };
+  DoE_base = derive { name="DoE.base"; version="0.26-3"; sha256="0b0nkp85ryhy2r9xzmd0331v6a63bh2z2anzc7ra3k315c76ajq3"; depends=[conf_design vcd combinat MASS]; };
+  DoE_wrapper = derive { name="DoE.wrapper"; version="0.8-10"; sha256="12q3arfm76x9j8qnrmw07jh904qdqz59ga1zk8m3n17prr11vrgb"; depends=[FrF2 DoE_base rsm lhs DiceDesign AlgDesign]; };
   doMC = derive { name="doMC"; version="1.3.3"; sha256="0g5psgk92b2zk9fkap3a86haay2y0kfz75cyk3d1ila9m7cd2cn4"; depends=[foreach iterators]; };
   Dominance = derive { name="Dominance"; version="1.0.0"; sha256="0xcmslzfdcy826vcnlybhdyym5kqkrdqidq6jn10s4jic7jk8nl3"; depends=[igraph chron gdata]; };
-  domino = derive { name="domino"; version="0.1-7"; sha256="0xlmry11jmv4x3pq89w02yjq9qrvaqc8r71lr2cw5k1jsi0swxas"; depends=[]; };
+  domino = derive { name="domino"; version="0.2-1"; sha256="1ix7m8khlxdn1axxc1jxvjmqd0np2h2z5nb9i188jk3zzpdw11ka"; depends=[]; };
   doMPI = derive { name="doMPI"; version="0.2"; sha256="0cvws4zwbjj9ji0s69qy1843404a221pyxg9y35ihfcrjknfjc0l"; depends=[foreach iterators Rmpi]; };
   doParallel = derive { name="doParallel"; version="1.0.8"; sha256="1z6cwqnjvqsbck44padqkv4r75cy32p5vrlkkan4mq84cc8062nx"; depends=[foreach iterators]; };
   doRedis = derive { name="doRedis"; version="1.1.1"; sha256="10ldfzq6m83b9w24az9bf5wbfm6y9gi233s8qgsk4dnr84n3nizx"; depends=[rredis foreach iterators]; };
   doRNG = derive { name="doRNG"; version="1.6"; sha256="0yvg4052gfdh54drn6xnpiqyd77p8765yi525nag3ismw2yn9y58"; depends=[foreach rngtools iterators pkgmaker]; };
-  DoseFinding = derive { name="DoseFinding"; version="0.9-11"; sha256="10i2vpv09avspn2daa9bcpj0nicdjm71gixhvh3x7xb3681zsw2d"; depends=[lattice mvtnorm]; };
+  DoseFinding = derive { name="DoseFinding"; version="0.9-12"; sha256="126xhq1ckry65g312cqvs9bdcl2ws34k6xnq7n9dcgi8jiizz46d"; depends=[lattice mvtnorm]; };
   doSNOW = derive { name="doSNOW"; version="1.0.12"; sha256="0j71n0l9lbvwllw9iigvjgv0x8z2j57grl3yazkgcyzy0mcgf741"; depends=[foreach iterators snow]; };
   dosresmeta = derive { name="dosresmeta"; version="1.3.0"; sha256="0yfm8dkds8abdl6jrib5vvgkyrd5cl5a99qs27safxx0fcpdiz4k"; depends=[mvmeta aod Matrix]; };
   dostats = derive { name="dostats"; version="1.3.1"; sha256="0xcp9arpvqb7am6caiazlgllvd3hhk4gqjd2wizr2jc5dkwfl4qn"; depends=[]; };
+  dotenv = derive { name="dotenv"; version="1.0"; sha256="1lxwvrhqcwj9q24x30xzrw8qqhxgyr88ja3fajm5hf3pwbw85yls"; depends=[magrittr falsy]; };
   DoubleCone = derive { name="DoubleCone"; version="1.0"; sha256="1pba9ypp0n3i2k3ji1x8j7h548pfam9z99hxylcjcxnnvc7xs2fw"; depends=[coneproj Matrix MASS]; };
   DoubleExpSeq = derive { name="DoubleExpSeq"; version="1.0"; sha256="0y797iqmxihrsp8lhy84p5hlyw3ckpklv0pgcqv4h39a6cpglbvd"; depends=[numDeriv]; };
   downloader = derive { name="downloader"; version="0.3"; sha256="0jpq8z3i9fkgs8wwjrq5qd7qfi5w3rxmzmsi1c1dxlnxzzhg6kxq"; depends=[digest]; };
   dpa = derive { name="dpa"; version="1.0-3"; sha256="0chkbbqxpq5fmqzr74jvflls9h0i2y25jp8gvlg3pfam9j07w7i5"; depends=[sem igraph]; };
-  dpcR = derive { name="dpcR"; version="0.1.2-1"; sha256="1czkwyqnly7lwn00mifm0apnh8ahfv4v9iwzvfwcamfl7qkwbvx6"; depends=[qpcR binom chipPCR e1071 dgof pracma rateratio_test signal shiny spatstat]; };
+  dpcR = derive { name="dpcR"; version="0.1.3.1"; sha256="0nlzjq3b9i76l1ngvcd32c8jl3z6cwn2fhg75lrgrwl6fl2v46jb"; depends=[binom chipPCR e1071 dgof multcomp qpcR pracma rateratio_test signal shiny]; };
   dpglasso = derive { name="dpglasso"; version="1.0"; sha256="1mx28xbm2z2bxyp33wv2v6vgn1yfsdsa0bzjjdxasgd6lvr51myf"; depends=[]; };
   dplR = derive { name="dplR"; version="1.6.0"; sha256="1rjb10adhycp16xav7z5c93jfcjwpcrp8cdiyab8skrijgzbp0vx"; depends=[gmp digest lattice stringr XML]; };
+  dplyr = derive { name="dplyr"; version="0.3.0.2"; sha256="1b4bpr80qvi6k2m27qz4w78hp8hnh9395hcr38zyni5zj469fprw"; depends=[assertthat R6 Rcpp magrittr lazyeval DBI BH]; };
   dpmixsim = derive { name="dpmixsim"; version="0.0-8"; sha256="0paa2hmpd6bqf0m7p9j7l2h3j18lm64ya6ya8zvp55wm8pf7xgqg"; depends=[oro_nifti cluster]; };
   DPpackage = derive { name="DPpackage"; version="1.1-6"; sha256="01qdl6cp6wkddl9fwwpxwvyhb7lpjxis6wnbm2s288y2n9wi4j24"; depends=[MASS nlme survival]; };
   DPw = derive { name="DPw"; version="1.1.2"; sha256="0waprp6xql67ijwwsy0z8f0fnazkzci0nzwiajwkvy7vbwcch5bx"; depends=[]; };
···
   drm = derive { name="drm"; version="0.5-8"; sha256="1p6ixd7hnv41gfmvan3rv9xzz1279hmrnvfrl6pxwzs9zcnbb53a"; depends=[]; };
   drmdel = derive { name="drmdel"; version="1.3"; sha256="0yflpja6r8cm4yv07ac1wic8w2iv0pwqpgh3ls2pjwv3vqzg7jrm"; depends=[]; };
   drsmooth = derive { name="drsmooth"; version="1.0"; sha256="1cxhj28dkll704kif040vqnp9grb61v891rswvyx7aa9216156px"; depends=[car clinfun mgcv multcomp pgirmess DTK segmented mvtnorm]; };
-  ds = derive { name="ds"; version="2.0"; sha256="0jxkwp8hm36aqh8xdxh3q5zgafwik6i9ihs52sxrllpmhyb39x3p"; depends=[]; };
+  ds = derive { name="ds"; version="3.0"; sha256="10xp575l0wh85wg32k3as02kgqm9ax9nx9i5kd5bkimfwg4qv745"; depends=[]; };
   dsample = derive { name="dsample"; version="0.91.1"; sha256="0nxx3x55zj089aq2shk7cg9bgh6xw7jnrr2qmlaq6bflwn58wn1q"; depends=[]; };
   DSBayes = derive { name="DSBayes"; version="1.1"; sha256="0iv4l11dww45qg8x6xcf82f9rcz8bcb9w1mj7c7ha9glv5sfb25v"; depends=[BB]; };
   dse = derive { name="dse"; version="2013.3-2"; sha256="170bpd0ix5bslbif2blcyb8dkbxwl3334h2nw0fgcx495vxvvx2x"; depends=[tframe setRNG tfplot]; };
···
   dse2 = derive { name="dse2"; version="2011.11-2"; sha256="05kf2072a50wd6p42yx5wpy0m7wq1gssy877nfyyc5l0pwviy3zs"; depends=[EvalEst]; };
   DSL = derive { name="DSL"; version="0.1-5"; sha256="0k320cmim9mvi5cmr6964h9i2jbskh76xws3p6zsfakk63ndg3rr"; depends=[]; };
   dslice = derive { name="dslice"; version="1.0.2"; sha256="0y8q52g7d01hfyysrbqgg0xrqvia046phr9xfwgy0bp254xdwfcp"; depends=[Rcpp ggplot2 scales]; };
-  dsm = derive { name="dsm"; version="2.2.4"; sha256="1pbvirxwxr35hcd64sn1cd3cv40nrq7dz92apdvaf754sxfqx2xw"; depends=[mgcv mrds nlme ggplot2 statmod]; };
-  DSpat = derive { name="DSpat"; version="0.1.5"; sha256="1njc9p2cxszcskdm21x00yvcs7gx71x18fdayih6l3g5l40c698a"; depends=[spatstat RandomFields mgcv rgeos]; };
+  dsm = derive { name="dsm"; version="2.2.5"; sha256="0sfsfzcsqnvjkc5l7h5xq8p2jsgwxfzds75sqs58a0kzagcm1b05"; depends=[mgcv mrds nlme ggplot2 statmod]; };
+  DSpat = derive { name="DSpat"; version="0.1.5"; sha256="1njc9p2cxszcskdm21x00yvcs7gx71x18fdayih6l3g5l40c698a"; depends=[RandomFields mgcv rgeos]; };
   DSsim = derive { name="DSsim"; version="1.0.1"; sha256="0a62l8jfrnr2h9laxw27p8icvfa8f1gdhdiywwb33328barhzfrk"; depends=[shapefiles splancs mrds mgcv]; };
+  DStree = derive { name="DStree"; version="1.0"; sha256="14wba25ylmsyrndh007kl377dv4r34wr1555yxl6kyxrs4yg3jir"; depends=[rpart pec Ecdat rpart_plot survival Rcpp]; };
   DTComPair = derive { name="DTComPair"; version="1.0.3"; sha256="1af2293ckkpz0gjcibgzzvz37852cav4wa4girpc87yn3p4ajlri"; depends=[gee PropCIs]; };
   DTDA = derive { name="DTDA"; version="2.1-1"; sha256="0hi2qjcwd6zrzx87mdn1kns5f2h6jh7sz9jpgbi0p0i80xg8jnn3"; depends=[]; };
   dti = derive { name="dti"; version="1.2-0"; sha256="01z51x1fpsc79b298gsx5fq2y5w3pwiq58a13pm96a4mkyzzwhk7"; depends=[awsMethods adimpro rgl oro_nifti oro_dicom gsl]; };
···
   dualScale = derive { name="dualScale"; version="0.9.1"; sha256="11hqxprai0s5id6wk4n2q174r1sqx9fzw3fscvqd2cgw8cjn1iwl"; depends=[matrixcalc ff vcd lattice Matrix]; };
   dummies = derive { name="dummies"; version="1.5.6"; sha256="01f84crqx17xd6xy55qxlvsj3knm8lhw7jl26p2rh2w3y0nvqlbm"; depends=[]; };
   DunnettTests = derive { name="DunnettTests"; version="2.0"; sha256="1sf0bdxays10n8jh2qy85fv7p593x58d4pas9dwlvvah0bddhggg"; depends=[mvtnorm]; };
+  dunn_test = derive { name="dunn.test"; version="1.2.0"; sha256="0r83x8qsazzkpnv6mbdzakhiacydd42sfgazzpx5536dwcvlb486"; depends=[]; };
   dupiR = derive { name="dupiR"; version="1.1"; sha256="01yhwgqm2y6znxds3p2admcyayvjj5xw7vvc9djd7b6ywsivb8sa"; depends=[plotrix]; };
   dvfBm = derive { name="dvfBm"; version="1.0"; sha256="0gx11dxkbnh759ysd1lxdarlddgr3l5gwd5b0klwvwsgck6jv529"; depends=[wmtsa]; };
   dvn = derive { name="dvn"; version="0.3.3"; sha256="14ncna67qgknh20xdvxqddjhagj61niwpvz4ava9k0z68rgzmk5h"; depends=[RCurl XML]; };
-  DWD = derive { name="DWD"; version="0.11"; sha256="1yqcww4jbbvdcv0yj9h8q2w7ck7pwr0zcvmncp9mc4n4k9y67r9j"; depends=[Matrix]; };
   dyn = derive { name="dyn"; version="0.2-9"; sha256="16zd32567aj0gqv9chbcdgi6sj78pnnfy5k8si15v5pnfvkkwslp"; depends=[zoo]; };
   DynamicDistribution = derive { name="DynamicDistribution"; version="1.1"; sha256="1s78hpj2pxjs4vixin1i816qjbn3wk7b8rd2zdjp4d4rbxifcqf5"; depends=[]; };
   dynamicGraph = derive { name="dynamicGraph"; version="0.2.2.6"; sha256="1xnsp8mr3is4yyn0pyrvqhl893gdx2y1zv8d2d55aah2xbfk0fjj"; depends=[ggm]; };
   dynamicTreeCut = derive { name="dynamicTreeCut"; version="1.62"; sha256="1y11gg6k32wpsyb10kdv176ivczx2jlizs1xsrjrs6iwbncwzrkp"; depends=[]; };
   dynatopmodel = derive { name="dynatopmodel"; version="1.0"; sha256="1dq18wqbf7y597mbqv8fwwc5fm8l618mkqvb2l95bplq7n508hng"; depends=[raster xts shape fields rgeos maptools rgdal sp spam hydroGOF topmodel intervals]; };
   dynaTree = derive { name="dynaTree"; version="1.2-7"; sha256="06pw78j6wwx7yc175bns1m2p5kg5400vg8x14v4hbrz3ydagx4dn"; depends=[]; };
-  dynBiplotGUI = derive { name="dynBiplotGUI"; version="1.1.0"; sha256="15m4gxdlwzvvj64vjkkb1608q4k0w84my7m8x1qc04bly9p3q038"; depends=[tcltk2 tkrplot]; };
+  dynBiplotGUI = derive { name="dynBiplotGUI"; version="1.1.1"; sha256="1xngcr8r48yigm7gg5a06c9xl6zaj6s59izqrni1874x5ji39ql3"; depends=[tcltk2 tkrplot]; };
   DynClust = derive { name="DynClust"; version="3.13"; sha256="020zl2yljp47r03rcbzrbdmwk482xx27awwzv4kdrbchbzwhxqgm"; depends=[]; };
   dynCorr = derive { name="dynCorr"; version="0.1-2"; sha256="0qzhhfhkwpq6mwg7y6sxpqvcj8klvivnfv69g7x3ycha1kw2xk3w"; depends=[lpridge]; };
   dynia = derive { name="dynia"; version="0.2"; sha256="1swip4kqjln3wsa9xl0g92zklqafarva923nw7s44g4pjdy73d5l"; depends=[]; };
   dynlm = derive { name="dynlm"; version="0.3-3"; sha256="0ym23gv2vkvvnxvzk5kh6xy4gb5wbnpdbgkb5s6zx24lh81whvcs"; depends=[zoo car lmtest]; };
-  dynsim = derive { name="dynsim"; version="0.2.4"; sha256="1b4j47asqanrfhyg9r730brp3xaw1853jk23va2sx606q2rh94wv"; depends=[DataCombine ggplot2 gridExtra Zelig]; };
+  DynNom = derive { name="DynNom"; version="1.0"; sha256="1lccwg3yvv2i5xhqaws0ja7xbi66g728s7p2s037r6i3dahi86w4"; depends=[ggplot2 stargazer shiny compare]; };
+  dynsim = derive { name="dynsim"; version="1.0"; sha256="0w4brs8kcps6gkamkic57nj61iz7zdxq972jwzs17i43wfcrw32c"; depends=[ggplot2 gridExtra MASS]; };
   dynsurv = derive { name="dynsurv"; version="0.2-2"; sha256="0418r7adki48pg3h7i1mgv3xpbryi520va3jpd03dx15zrq8zaqg"; depends=[survival reshape plyr nleqslv ggplot2]; };
-  e1071 = derive { name="e1071"; version="1.6-3"; sha256="0scyxk3y2fizvw5zrddxid37vzayd879g67faq0a879nhk7fkm1z"; depends=[class]; };
-  eaf = derive { name="eaf"; version="1.05"; sha256="12jwkz4cn3kgg3yczb0xgbp394bzgzps1mz0b999i3p1k6vn46z6"; depends=[modeltools]; };
+  e1071 = derive { name="e1071"; version="1.6-4"; sha256="0hakqawy8bz4hvjzz9dbc2pbqhaf1qjsgl0agz3qfg63974whw2i"; depends=[class]; };
+  eaf = derive { name="eaf"; version="1.06"; sha256="1v0sw52wsnhqfg9i2zhmkl0w5ikcd4zdmz4fy03scjx5impiww7a"; depends=[modeltools]; };
   earlywarnings = derive { name="earlywarnings"; version="1.0.59"; sha256="06j5g5lrzl4p5pb1pp79h00iqpbwralzhpzxmaiymv7j8kz87nr0"; depends=[ggplot2 moments tgp tseries fields nortest quadprog Kendall KernSmooth lmtest som spam]; };
   earth = derive { name="earth"; version="3.2-7"; sha256="1j9w03i4pvz8a6s9rkfssj7bqz5sql0g7rzwpmis33kvi0d7wihn"; depends=[plotmo plotrix]; };
-  easi = derive { name="easi"; version="0.2"; sha256="0kvcixbiijh3akxqy2w6kwydayqlr7lk2ws747a1z4whhclm1623"; depends=[systemfit micEcon]; };
-  easingr = derive { name="easingr"; version="1.0.0"; sha256="18q9r5wvfhn03500lvwriycdw3gqbg3fpd86137mz8gxdg2pawic"; depends=[xts lattice latticeExtra]; };
+  easingr = derive { name="easingr"; version="1.0.1"; sha256="0sisqryqlymkk9v1wq0v1db3g9sx5vaqxxkw1470c75ix5s2n5s3"; depends=[xts lattice latticeExtra]; };
   EasyABC = derive { name="EasyABC"; version="1.3.1"; sha256="1d1j7n6mhpmbbczg0yjs4kqjxlclc7pm5fl7pkxp9dmfic002y34"; depends=[abc pls mnormt MASS lhs]; };
-  easyanova = derive { name="easyanova"; version="3.0"; sha256="19mcjj1lvy8kf6s004rqnalv80jf62g7dpsnrwkrklb19n1164v8"; depends=[car nlme]; };
+  easyanova = derive { name="easyanova"; version="4.0"; sha256="1d8fkgyqzphipvla7x8ipcf0by07iqx8xran15d2q82yq9iik5g9"; depends=[car nlme]; };
   EasyHTMLReport = derive { name="EasyHTMLReport"; version="0.1.1"; sha256="1hgg8i7py7bx48cldyc7yydf0bggmbj3fx3kwiv9jh1x5wyh929z"; depends=[base64enc markdown knitr ggplot2 scales xtable reshape2]; };
   EasyMARK = derive { name="EasyMARK"; version="1.0"; sha256="10slkblbyxq98c3sxgs194dnkx996khfcpxj6jhz355dp35z7c9d"; depends=[MASS stringr rjags coda foreach doParallel random]; };
   easynls = derive { name="easynls"; version="4.0"; sha256="1j2crqvgsf84bpwzf4qh5xkzn5mhxhfx9c0y3p8dbyn8bg7zc2rf"; depends=[]; };
···
   EBMAforecast = derive { name="EBMAforecast"; version="0.42"; sha256="161l6jxbzli2g5lcmlp74z320rsvsi80pxk1vc1ypa1hgwz3q80x"; depends=[separationplot ensembleBMA plyr Hmisc abind]; };
   EBS = derive { name="EBS"; version="3.0"; sha256="0nrqglbfr7wagd4xrk5jx0kficjgvk7wqwzqrbs589dkll24sn5b"; depends=[MASS]; };
   ebSNP = derive { name="ebSNP"; version="1.0"; sha256="0x3ijwg4yycsfy6jch1zvakzfvdgpiq8i7sqdp5assb8z1823w0b"; depends=[]; };
-  Ecdat = derive { name="Ecdat"; version="0.2-6"; sha256="1chx78xi04jr9qpc3z2g9x3sj41sdqp3zpjcgv817mcz84zc8mkc"; depends=[Ecfun]; };
-  ecespa = derive { name="ecespa"; version="1.1-7"; sha256="0ynyphc1jnk088041i0yk22bh4ga1v9xwrcghy70q1ipv0z279ph"; depends=[splancs spatstat]; };
-  Ecfun = derive { name="Ecfun"; version="0.1-0"; sha256="0jfcqxbx27dwbipx1b994iy4qnpkg1sh4xpq7qq8yy823rgpkhrp"; depends=[]; };
+  Ecdat = derive { name="Ecdat"; version="0.2-7"; sha256="1z9mxx3mvn3vi5drxlzss7gs7vpzg7shinl529bx4jpxqpci90jy"; depends=[Ecfun]; };
+  ecespa = derive { name="ecespa"; version="1.1-7"; sha256="0ynyphc1jnk088041i0yk22bh4ga1v9xwrcghy70q1ipv0z279ph"; depends=[splancs]; };
+  Ecfun = derive { name="Ecfun"; version="0.1-2"; sha256="1shwp1si3k9zmvrsicq9h3csmmxdsha8w5za8rf86zdcx0rhf9d0"; depends=[fda gdata RCurl XML tis jpeg MASS TeachingDemos]; };
   ecipex = derive { name="ecipex"; version="1.0"; sha256="0pzmrpnis52hvy80p3k60mg9xldq6fx8g9n3nnqi3z56wxmqpdv7"; depends=[CHNOSZ]; };
   ecodist = derive { name="ecodist"; version="1.2.9"; sha256="199f3lwwm8r2bnik595m540la1p4z6vbkwfqh9kimy9d0fjp8nps"; depends=[]; };
-  ecoengine = derive { name="ecoengine"; version="1.4"; sha256="0smjwgci2kz09idzq10q50z0hs2nr7rjj7i0r7iksdyb7ggb3hzm"; depends=[httr plyr assertthat whisker dplyr RJSONIO lubridate leafletR]; };
+  ecoengine = derive { name="ecoengine"; version="1.6"; sha256="1dbg9y8hz7z385ml102y3akfffphg0llnyqg5iqblqann7nrzpsn"; depends=[httr plyr assertthat whisker dplyr jsonlite lubridate leafletR]; };
   EcoHydRology = derive { name="EcoHydRology"; version="0.4.12"; sha256="03dzdw79s0cnnd7mv6wfxw374yf66dlcmj10xh6sh5i352697xp1"; depends=[operators topmodel DEoptim XML]; };
   ecolMod = derive { name="ecolMod"; version="1.2.5"; sha256="07dr3q17vd60569w34apylpsv81qcf31l7v0bqdycb5mlaifdahz"; depends=[rootSolve diagram deSolve]; };
   ecoreg = derive { name="ecoreg"; version="0.2"; sha256="08iw7w9z7zqwhvirnhdc2jr2qjp9yma8ddc831d5dvbvi2j7kq84"; depends=[]; };
+  ecoretriever = derive { name="ecoretriever"; version="0.1"; sha256="1iwds81pyn9c04fmnjfsri7rjanrfki8hngdwpqcx3dkbsg76ii6"; depends=[]; };
   ecosim = derive { name="ecosim"; version="1.2"; sha256="1lzjd6kl2864ngyiqyfnnra5ag9bj42pxb793gwp45r7z95k32rf"; depends=[deSolve stoichcalc]; };
-  ecospat = derive { name="ecospat"; version="1.0"; sha256="1pnyiy89smr0cnw1z5cv83b7dybzs5h2kfyxis2k3rlx26rzczfv"; depends=[ade4 ape gam gbm sp adehabitatHR adehabitatMA biomod2 dismo ecodist maptools randomForest spatstat raster rms]; };
+  ecospat = derive { name="ecospat"; version="1.0"; sha256="1pnyiy89smr0cnw1z5cv83b7dybzs5h2kfyxis2k3rlx26rzczfv"; depends=[ade4 ape gam gbm sp adehabitatHR adehabitatMA biomod2 dismo ecodist maptools randomForest raster rms]; };
   EcoTroph = derive { name="EcoTroph"; version="1.6"; sha256="0zi6g0ra107s47r32mm9h6r1wll3avi0mpjmhcr0nj9y48nv14w3"; depends=[XML]; };
+  ecoval = derive { name="ecoval"; version="1.0"; sha256="1szvr2ipb7bd0cyslhwwwyx5kw7yx3kpqcyzxfd9pk263bny323g"; depends=[utility rivernet]; };
+  EcoVirtual = derive { name="EcoVirtual"; version="0.1"; sha256="1c815kxljk4qhw0zs28w16ggasfyyyb6aggffx1m1q21s63h6c8h"; depends=[]; };
   ecp = derive { name="ecp"; version="1.6.0"; sha256="1xzawnqk8maxk9ha4cms5xvylwb4m1mkxps88p5xh7grgpcw6drn"; depends=[Rcpp]; };
   edcc = derive { name="edcc"; version="1.0-0"; sha256="036fi6mnn9480hkb378xb5jilkfvdydjmkyw4mcc9s1lz195f62w"; depends=[spc]; };
   edeR = derive { name="edeR"; version="1.0.0"; sha256="1dg0aqm5c4zyf015hz1hhn3m4lfvybc4gc1s7sp8jcsk46rxz0cc"; depends=[rJava rjson rJython]; };
-  EDISON = derive { name="EDISON"; version="1.0"; sha256="17yjvvsgsmd4i00wzmih50qz3wqig2zdg5r877b4hqk1dsv5kxym"; depends=[corpcor MASS]; };
+  edgeRun = derive { name="edgeRun"; version="1.0.9"; sha256="0d5nc8fwlm61dbi00dwszj1zqlij4gfds3w1mpcqnnfilr2g3di1"; depends=[data_table]; };
+  EDISON = derive { name="EDISON"; version="1.1"; sha256="09xw4p4hwj8djq143wfdcqhr2mhwynj4ixj3ma7crhqidgal169p"; depends=[corpcor MASS]; };
   editrules = derive { name="editrules"; version="2.7.2"; sha256="19g07caacwphvrqn900chrz3k6x4z8gmvlcvna5x2mqidcjkf25i"; depends=[igraph lpSolveAPI]; };
   EDR = derive { name="EDR"; version="0.6-5.1"; sha256="10ldygd1ymc4s9gqhhnpipggsiv4rwbgajvdk4mykkg3zmz7cbpm"; depends=[]; };
   edrGraphicalTools = derive { name="edrGraphicalTools"; version="2.1"; sha256="09y63xj3gqrz66mym20g4pmfwrb0wnc2n67692hnqq8dz31q7p3i"; depends=[rgl mvtnorm MASS lasso2]; };
   eegAnalysis = derive { name="eegAnalysis"; version="0.0"; sha256="1lrwjbhm5fnf5fhyyga2b21j2snnmj3zfvfxfkvgsbdnzr3qxaxb"; depends=[e1071 wmtsa fields splus2R]; };
+  eegkitdata = derive { name="eegkitdata"; version="1.0"; sha256="1krsadhamv1m8im8sa1yfl7injvrc4vv3p88ps1mpn8hibk5g51m"; depends=[]; };
   eeptools = derive { name="eeptools"; version="0.3.1"; sha256="0m6i0hiw565wgziknlf19rh2fq8zvzq2v5a0ppnwcv8vhbhyph3g"; depends=[ggplot2 MASS stringr maptools arm data_table memisc]; };
-  effects = derive { name="effects"; version="3.0-0"; sha256="075vd540d8wry1l70s28pkmd1g3424yan9f7mwvcrqf0l62ahmfg"; depends=[lattice colorspace]; };
+  effects = derive { name="effects"; version="3.0-1"; sha256="01j0h4xy3zwxl66an343f6x3sdbgzzdzy520d90jxnak60nsh443"; depends=[lattice colorspace]; };
   EffectsRelBaseline = derive { name="EffectsRelBaseline"; version="0.5"; sha256="1dsnakcrgmlx44599ii92wvhxbxrh0hij59709wsskx1x1152zvh"; depends=[]; };
-  EffectStars = derive { name="EffectStars"; version="1.3"; sha256="193j2dbp6bp60yb2qym119ciry3s5z54iv1vmb9wrddjzb77nnvv"; depends=[VGAM]; };
-  effsize = derive { name="effsize"; version="0.5.1"; sha256="0dy9q3zbcr5c4nijknly9mfr6rbs2qlv4jgzn0wpl2cz7hpngvk4"; depends=[]; };
+  EffectStars = derive { name="EffectStars"; version="1.5"; sha256="0j2jxxxpcsrsjzszz4mfk3892ain3qkswa1dkpsmfsk4zs06g0s4"; depends=[VGAM]; };
+  effsize = derive { name="effsize"; version="0.5.2"; sha256="0xhrq1a7vjcbipvmslmkw4widnp0scfcir80sr5npcx5pvxagsq3"; depends=[]; };
   egcm = derive { name="egcm"; version="1.0.2"; sha256="17fzxl34vc38308wbvjp5xdv1q48k4lf6gsw7ax27zc4chqlmqfz"; depends=[ggplot2 tseries zoo MASS]; };
-  eggCounts = derive { name="eggCounts"; version="0.2"; sha256="0ilwhw2fk8mvqsnranpj4mny98vhha8jrrxccz6x0f8hsy34b27k"; depends=[coda actuar boot]; };
+  eggCounts = derive { name="eggCounts"; version="0.3"; sha256="0rsw0610jppnxvw22dj33sn1xq5wf44nsgszwi0jxcd45n1n2k8x"; depends=[coda actuar boot]; };
   egonet = derive { name="egonet"; version="1.2"; sha256="1f0fbqyk2ilmhirxvf1iwgfappi5r7807ag77r89lbaf5jq8akl0"; depends=[sna]; };
   eha = derive { name="eha"; version="2.4-1"; sha256="1znxpcrwp8fllr3m14gbxwgp7yln55jwvkilmbsqldz00za6xn0w"; depends=[survival]; };
-  eHOF = derive { name="eHOF"; version="1.4"; sha256="050wlckw2i8iqymdmq68zj2fwq74slsbk83p5kkhxlyn132m0k47"; depends=[mgcv lattice]; };
+  eHOF = derive { name="eHOF"; version="1.5"; sha256="1k0ii5njaw8za8vwxhjkmqwmb5lqj8168pzrf743y9d2dl2lnmyf"; depends=[mgcv lattice]; };
   EIAdata = derive { name="EIAdata"; version="0.0.1"; sha256="0adgkjfymgsimlaalcgcqdsagfvycrnsx93bx2xsbvlbywjk9fhn"; depends=[XML plyr xts zoo]; };
   eigeninv = derive { name="eigeninv"; version="2011.8-1"; sha256="18dh29js824d7mrvmq3a33gl05fyldzvgi8mmmr477573iy9r30g"; depends=[]; };
   eigenmodel = derive { name="eigenmodel"; version="1.01"; sha256="0p9n28x5gg46nszzd2z9ky5fhv6qa070673i1df6bhjh962aqgaf"; depends=[]; };
···
   EloRating = derive { name="EloRating"; version="0.41"; sha256="1d7kcng0iv4paagm0jljkfk7c2n3vvs91khjvlc7jpifisf1zi7a"; depends=[zoo]; };
   elrm = derive { name="elrm"; version="1.2.2"; sha256="0wz0l703v0iyp7nswdmh65n0cy3a7rfvyxd795a6nzk3nich8bfg"; depends=[coda]; };
   ElstonStewart = derive { name="ElstonStewart"; version="1.1"; sha256="1y2g4x3fhi78c2406bk8r8c3x9zhx8ya3qlbnypdm65j0minixsn"; depends=[kinship2 digest]; };
-  ELT = derive { name="ELT"; version="1.2"; sha256="19q6i1ilsi09mlbs3l0p6n86390jmrs0g93zpa1h0hql7ymcb8p2"; depends=[locfit lattice latticeExtra xlsx]; };
-  em2 = derive { name="em2"; version="0.9"; sha256="120731nh5qq3kzbfj9p2s4fhrr3xvddj5n0bv5m3dp5l5495px1b"; depends=[plyr]; };
+  ELT = derive { name="ELT"; version="1.3"; sha256="0q6gc3npwxqq0hz1ardssv5wfxjnx93pi4l1viqsb0wp2kkfq3w6"; depends=[locfit lattice latticeExtra xlsx]; };
   EMA = derive { name="EMA"; version="1.4.4"; sha256="1hqkan9k6ps4qckjrhsgxzham106fm38m5rgayz8i2ji3spvbfca"; depends=[survival xtable heatmap_plus GSA MASS FactoMineR cluster]; };
+  embryogrowth = derive { name="embryogrowth"; version="5.1"; sha256="1irdx1zkp1k4hqi9c9hrckiy647nld2n9mgw9kx8gp771963n5rq"; depends=[deSolve phenology Hmisc]; };
   EMC = derive { name="EMC"; version="1.3"; sha256="0sdpxf229z3j67mr9s7z4adzvvphgvynna09xkkpdj21mpml23p6"; depends=[mvtnorm MASS]; };
   EMCC = derive { name="EMCC"; version="1.2"; sha256="1qff8yvw7iqdsrqkvwb7m14xh7gcnjcrf8gw00g4j6aq0h0cgk2z"; depends=[MASS mclust EMC]; };
   EMCluster = derive { name="EMCluster"; version="0.2-4"; sha256="0m5cl5mrg6q0ixfpjj1jwd7l5hcldc33lr7n6xgy7p9nlr52mimz"; depends=[MASS]; };
···
   emdatr = derive { name="emdatr"; version="0.2"; sha256="11s9yiziswgll12c1sm3jb7hvy469ks64zx6w8dk1b36cx4lzf3h"; depends=[RCurl]; };
   emdbook = derive { name="emdbook"; version="1.3.4"; sha256="19i8i1wp6vqgc77ajaqrfrjw6ijjafkgdqgfpa0dvl1w117rpy2d"; depends=[MASS lattice plyr]; };
   emdist = derive { name="emdist"; version="0.3-1"; sha256="1z14pb9z9nkd0f2c8pln4hzkfqa9dk9n3vg8czc8jiv0ndnqi7rq"; depends=[]; };
-  emg = derive { name="emg"; version="1.0.5"; sha256="028g8gqjjqfwly6vzvinbpilay5jj9rnm7ri9aby9q0hj5prh56m"; depends=[]; };
   emil = derive { name="emil"; version="1.1-6"; sha256="1qk655swpl8f492y9smzlfxf7aysbwashfs6whnsi7f9dbigw6cd"; depends=[]; };
   EMJumpDiffusion = derive { name="EMJumpDiffusion"; version="1.4.1"; sha256="10lw6717yq9vlywn5ilsl0d99fpx3zvc87vf7s0zxswhs81h7x1w"; depends=[]; };
   emma = derive { name="emma"; version="0.1-0"; sha256="0psd8lrbcqla8mkhp0wlassaaimgwlmqy5yv2wwcq59mc5k1v27f"; depends=[earth clusterSim]; };
···
   EMMIXuskew = derive { name="EMMIXuskew"; version="0.11-6"; sha256="0japf0l0sj84jna7b5kirp6pgqa4c923ldwphb16ch2xxrgk5n5k"; depends=[MASS]; };
   EMMREML = derive { name="EMMREML"; version="2.0"; sha256="0fyqwyym6d1adn5pvrfspmr933qhi30h58hxr2rbzwm5kwh6c8jr"; depends=[Matrix]; };
   emoa = derive { name="emoa"; version="0.5-0"; sha256="1wcnsnkdmpcn21dyql5dmj728n794bmfr6g9hgh9apzbhn4cri8p"; depends=[]; };
-  EMP = derive { name="EMP"; version="1.0.1"; sha256="12ahyfav918qf7bphhy251x0gzhdziaz2gg064hcwh6jaqw0jw0g"; depends=[]; };
-  emplik = derive { name="emplik"; version="0.9-9-2"; sha256="131wk9nfymkygb89jk9cwi53dx4857c06ip9pfzzvswch3hhdqwb"; depends=[quantreg]; };
+  EMP = derive { name="EMP"; version="1.0.2"; sha256="0kh0mirfvas0kyvx3igrwg265rqsfn2jpf2daa0swq9vvs97czis"; depends=[]; };
+  emplik = derive { name="emplik"; version="0.9-9-6"; sha256="0qrrsws9hnb9f2zv50q4v9zx467n6hm83g841h3ba511iwjpp32r"; depends=[quantreg]; };
   emplik2 = derive { name="emplik2"; version="1.10"; sha256="19s19jhcaqnh6vjfgrsgjvjlrsm5fa1mgwc5v36hzdf2mv1xhr3q"; depends=[]; };
   EMT = derive { name="EMT"; version="1.1"; sha256="0m3av1x3jcp3hxnzrfb128kch9gy2zlr6wpy96c5c8kgbngndmph"; depends=[]; };
-  emulator = derive { name="emulator"; version="1.2-13"; sha256="1y8mrrz4dw66wn3lhi7x7r72bxa77rpc68zqab6c67ndyi4wamxr"; depends=[mvtnorm]; };
+  emulator = derive { name="emulator"; version="1.2-15"; sha256="1rp7q7zs8b49jzdkbzm4s1g8554h41hcabf4d78k9jhhys2z28g2"; depends=[mvtnorm]; };
   EMVC = derive { name="EMVC"; version="0.1"; sha256="1725zrvq419yj0gd79h8bm56lv2mmk296wq3wapivcy6xn0j97jh"; depends=[]; };
   ENA = derive { name="ENA"; version="1.3-0"; sha256="02gsngkzc8vfpg2jvcabwp4kpfs14cajs9xv1rh76807l5ylqihz"; depends=[GeneNet space WGCNA parmigene]; };
   enaR = derive { name="enaR"; version="2.7"; sha256="0jjxqrxyak9b39j9yycfgp7bhb82y8zinc2kcc6pbs5w6m5dsyvr"; depends=[sna network MASS stringr gdata]; };
   endogMNP = derive { name="endogMNP"; version="0.2-1"; sha256="0maxcp321ngbxrg0i23nlwhj849v771xahh53367x928ss4f8v7i"; depends=[]; };
   endorse = derive { name="endorse"; version="1.4.1"; sha256="0xyi2cq4k4xa8kr717i4njl6rgjf5z99056jbhp2rbzfyy4sw61d"; depends=[coda]; };
-  energy = derive { name="energy"; version="1.6.1"; sha256="08s7kzl12fcp1lz86jzwznxk6dqvls418zcqwd31shqqynna25vm"; depends=[boot]; };
+  energy = derive { name="energy"; version="1.6.2"; sha256="008yf4r6546mzk9q515zliqxyjx6w0z19g5wlarg7f4lrzsmqiaw"; depends=[boot]; };
   english = derive { name="english"; version="1.0-1"; sha256="1413axjp2icj9wwnkz3vl4gvrwlgmjpc2djzv5bllbnc4a4dgj24"; depends=[]; };
   EngrExpt = derive { name="EngrExpt"; version="0.1-8"; sha256="0zclvckj2i7j4kfs58hcjcl722vl2y6dcnjz238cjfgwv279gqhp"; depends=[lattice]; };
+  enigma = derive { name="enigma"; version="0.1.0"; sha256="0k7shqs8lvx2nxvfdnp56wfhvnxrdg64y3s3b8aj6871r00pasa8"; depends=[httr jsonlite plyr]; };
+  ENiRG = derive { name="ENiRG"; version="0.1"; sha256="1cnl1mjl5y1rc6fv7c9jw2lkm898l3flfrj3idx9v1brjzyx5xlf"; depends=[ade4 raster R_utils sp spgrass6 gdata fgui miniGUI]; };
+  ENMeval = derive { name="ENMeval"; version="0.1.1"; sha256="0g1h8dklv6rv73wwpx3vhbpnwply5lpq8x9jvl7r018x9gcvvb9m"; depends=[dismo raster rJava]; };
   ENmisc = derive { name="ENmisc"; version="1.2-7"; sha256="07rix4nbwx3a4p2fif4wxbm0nh0qr7wbs7nfx2fblafxfzhh6jc7"; depends=[Hmisc vcd RColorBrewer]; };
+  enpls = derive { name="enpls"; version="1.0"; sha256="1grnabrb0kzjvjvwp9rx1xqfljla0jd5xrkcbwfzmy2ymmbvh6ma"; depends=[pls foreach doParallel]; };
   EnQuireR = derive { name="EnQuireR"; version="0.10"; sha256="00kyclcr8da79lwpqa1vzkwn6pgf197h2biackwgphb0byhi8ssx"; depends=[FactoMineR SensoMineR Rcmdr MASS]; };
   enRich = derive { name="enRich"; version="2.0"; sha256="13ahwdifm33h4h5mvmc49v39fbhiy291rbdwm4c8kxjrqjq9ip66"; depends=[]; };
   enrichvs = derive { name="enrichvs"; version="0.0.5"; sha256="0x91s03hz1yprddm6mqi75bm45ki3yapfrxmap7d4qc0hi06h22k"; depends=[]; };
···
   ensembleMOS = derive { name="ensembleMOS"; version="0.7"; sha256="0g5qzdic5jvgn6wv7zh0jnz8malfgfxn26l7lg30y96vcmi4hk54"; depends=[ensembleBMA chron]; };
   entropart = derive { name="entropart"; version="1.2.0"; sha256="11k05nk8lf5790wmx2323w5wk233xmk48scfv3hrph8y6665vddq"; depends=[ade4]; };
   entropy = derive { name="entropy"; version="1.2.0"; sha256="1qs8g5jp6ydhirxnrck3qqq3cc232hcaizy401c8gjn2vn23s15d"; depends=[]; };
-  EntropyEstimation = derive { name="EntropyEstimation"; version="0.1"; sha256="1l31vc9478db22zg79zm26xahagvw7p5ywkhyq4lanl38gh2my6y"; depends=[]; };
+  EntropyEstimation = derive { name="EntropyEstimation"; version="1.0"; sha256="02jvgr5ixzffyhxwycwhk8j33h6p1a32rckh0a4rfkaw5ihvxk0v"; depends=[]; };
   enviPat = derive { name="enviPat"; version="1.9"; sha256="0xm23gv4ixmsal9rf0cbq0lwvlpagpmapskz3c4d8qzvhr8qrl3b"; depends=[]; };
-  enviPick = derive { name="enviPick"; version="1.0"; sha256="117m06qp0l554sssv1vzhrysbi6rj9dm53szzkl8i8riqqm1m442"; depends=[shiny readMzXmlData]; };
+  enviPick = derive { name="enviPick"; version="1.2"; sha256="1ir8aqnbf470x0n5bqhb13aclkv13z8ha80dfhxx4ik5k65papcg"; depends=[shiny readMzXmlData]; };
   EnviroStat = derive { name="EnviroStat"; version="0.4-0"; sha256="05sa63z6yzny2ncxpm5d3x0bx8snkn0x5pzpj2a7y6rwf6al5q4r"; depends=[MASS]; };
   EnvNicheR = derive { name="EnvNicheR"; version="1.0"; sha256="1vw21gsdrx8gkf1rf8cnazv8l9ddcdmy2gckyf33fz7z2mbzgbkk"; depends=[]; };
-  EnvStats = derive { name="EnvStats"; version="1.0.2"; sha256="0914j7v190j401rdqqpfz3s69pb6crmq297wiw2q99syx0fnimnw"; depends=[]; };
+  EnvStats = derive { name="EnvStats"; version="1.0.3"; sha256="03wcqv4v14wkrrfi68qinaza3fbspw2a1pv1rm5nshcp8hw38qga"; depends=[]; };
   epade = derive { name="epade"; version="0.3.8"; sha256="1alvsifc6i71ilm1xxs1d7sqlapb48bqd6z2n4wi6pqcjvwp7bif"; depends=[plotrix]; };
   Epi = derive { name="Epi"; version="1.1.67"; sha256="12wbzv21whjnzlyqacgqmsgrjbkgj2495y9fwvav5mr21yfrjds3"; depends=[]; };
   epi2loc = derive { name="epi2loc"; version="1.0-1"; sha256="16abk1v177sg7gmaw42ldf6hf20l7dvyq295zwbq76nxj467khdv"; depends=[pwr]; };
   epibasix = derive { name="epibasix"; version="1.3"; sha256="0d0087sa8lqw35pn7gdg2qqzw3dvz57sgavymwl1ybcj5d4lsbyk"; depends=[]; };
   epicalc = derive { name="epicalc"; version="2.15.1.0"; sha256="11x9q990hc7rf5xfvba47axdy7vld76xcf3kd9lkr0c8nbl5ss9v"; depends=[foreign survival MASS nnet]; };
   EpiContactTrace = derive { name="EpiContactTrace"; version="0.8.8"; sha256="1vlr2xxnyq1i6ky39g8j3pf3m5775bmhii7vpskb0x7nnq161yzb"; depends=[Rcpp plyr R2HTML]; };
-  EpiDynamics = derive { name="EpiDynamics"; version="0.1"; sha256="11gbqpqnv6aydpwvki912cknvbzn24b3ajbc8ivzj7vvfp9blcmd"; depends=[deSolve FME reshape2 ggplot2]; };
+  EpiDynamics = derive { name="EpiDynamics"; version="0.2"; sha256="1hqbfysvw2ln8z3as6lfcjlhkzccksngwh2vm25zsgy93gxw3mcc"; depends=[deSolve reshape2 ggplot2]; };
   EpiEstim = derive { name="EpiEstim"; version="1.1-2"; sha256="0r56iglhkrqvlsf3gbahd544h944fmbyn6jdc113rhjscf6dl605"; depends=[]; };
-  EpiModel = derive { name="EpiModel"; version="1.0.1"; sha256="00afgdvbmc7qxq1r8kpldkfqvnwqp23ig2y06jmipmrcga3xf5z2"; depends=[network networkDynamic tergm deSolve ergm RColorBrewer statnet_common]; };
-  epinet = derive { name="epinet"; version="0.0-8.1"; sha256="00mq2bqdnjp7wwsb3dldlxd0l3vyij48az4s3vrmycab8g9dffk5"; depends=[]; };
+  EpiModel = derive { name="EpiModel"; version="1.1"; sha256="1abnq7jxl9abi4g5wa65b9i49l8vbkf5asa83y2r7qawla8xi4nc"; depends=[network networkDynamic tergm deSolve doParallel ergm foreach RColorBrewer statnet_common]; };
+  epinet = derive { name="epinet"; version="2.0.8"; sha256="09vggvkj4yjhfiwy7mqyqn8n4sr9ar0wj5j680sy900sybvxpw25"; depends=[]; };
   epiR = derive { name="epiR"; version="0.9-59"; sha256="0x0k7s2kl9mj7x2vnrj1bc586jkvc6sb34jsgjhwk3gyh9prp57q"; depends=[survival]; };
   epitools = derive { name="epitools"; version="0.5-7"; sha256="163sibnbihdsnkxf313fr8n8rh5d64dwjagv95vhhzr87f21sw22"; depends=[]; };
+  Eplot = derive { name="Eplot"; version="1.0"; sha256="1glmkjjj432z9g4gi56pgvfrm5w86iplirnd5hm4s99qci2hgc64"; depends=[]; };
   epoc = derive { name="epoc"; version="0.2.5-1"; sha256="1r19cvcqf39yf09n3znbdy3dsr7z96yx6zib6031mqqdsxaav5qd"; depends=[lassoshooting Matrix irr elasticnet survival]; };
   epr = derive { name="epr"; version="2.0"; sha256="1xqc0jhgdwwvilqpljxzpzz3wx30kigy09sxvzcfvsjmxyyvflqy"; depends=[car]; };
   EQL = derive { name="EQL"; version="1.0-0"; sha256="0lxfiizkvsfls1km1zr9v980191af6qjrxwcqsa2n6ygzcb17dp5"; depends=[ttutils lattice]; };
   eqs2lavaan = derive { name="eqs2lavaan"; version="3.0"; sha256="1lj6jwkfd84h9ldb6l74lrx2pnsl1c0d7mnrcrjkska87djb2nzd"; depends=[lavaan stringr]; };
   eqtl = derive { name="eqtl"; version="1.1-7"; sha256="0xfr8344irhzyxs9flnqn4avk3iv1scqhzac5c2ppmzqhb398azr"; depends=[qtl]; };
-  equate = derive { name="equate"; version="2.0-2"; sha256="1n83rr01y5rcsr2wgcd1n7ihjk5bvxdl7f9abcjdz6vja7qg6h83"; depends=[]; };
+  equate = derive { name="equate"; version="2.0-3"; sha256="0y37nxily7zjx00z7h4vmpn8cs7bl3aravhjkjz9l6y0fv0rc5vv"; depends=[]; };
   equateIRT = derive { name="equateIRT"; version="1.1"; sha256="0z889z973yvklbn6i4jf6cxzvs2x9bn7454v5f23xmnj1wh5qv2s"; depends=[statmod]; };
   equivalence = derive { name="equivalence"; version="0.6.0"; sha256="1q17c2bs36f46bmm6wzmp0g2lg7d0j9mlrfnkzxnlvmspwksc0zl"; depends=[lattice boot PairedData]; };
   erboost = derive { name="erboost"; version="1.2"; sha256="0afgh0zkl3h3ab4s7wl0cn24qdyhszssai9i390mi7w0p88wgba9"; depends=[lattice]; };
   erer = derive { name="erer"; version="2.2"; sha256="198bahz958dpdlk3himrjs0sa4j2hdppy3v4l3h8l52jaf1iq4n1"; depends=[lmtest systemfit tseries urca ggplot2]; };
   ergm = derive { name="ergm"; version="3.1.3"; sha256="0g4cap1gx0l57l0aix29wz9lspnxv2vqkkdlcghbdv41fdddvdlm"; depends=[statnet_common network robustbase coda trust Matrix]; };
   ergm_count = derive { name="ergm.count"; version="3.1.1"; sha256="0l66shy5p7h9j3h5gpkn48ps069mdaqbscnnkvmwjfvcc7k5vr8m"; depends=[statnet_common ergm network]; };
-  ergm_graphlets = derive { name="ergm.graphlets"; version="1.0.1"; sha256="0j2z8dvgfrkvm9sqpyqvylz6sakxl8wpy4fbgc20wwznfzbaaal6"; depends=[statnet]; };
+  ergm_graphlets = derive { name="ergm.graphlets"; version="1.0.2"; sha256="1wfk8kh4rqw1f7dg4vsjq8nirgwyyk21r0x7x2hrd4v4ci0mcz6j"; depends=[statnet]; };
   ergmharris = derive { name="ergmharris"; version="1.0"; sha256="1bfijhsljlykb94wi25lbpv35zkmgqpmgzmxcq98gjvzbn5j9pdq"; depends=[]; };
   ergm_userterms = derive { name="ergm.userterms"; version="3.1.1"; sha256="0pvklvyxi7sjc5041zl8vcisni0jz1283gyjw5mhas9bl47g1cwc"; depends=[network ergm statnet_common]; };
   eRm = derive { name="eRm"; version="0.15-4"; sha256="0x05vsf8kp0z422w1b1wqayada2vbl7jh4ifa52sqlq7ygsmnmi1"; depends=[MASS Matrix]; };
···
   ESG = derive { name="ESG"; version="0.1"; sha256="1jw6239asv6lwxrz5v0r5pzg6v500bqxg8361sh4jj67rsrc7g9m"; depends=[]; };
   ESGtoolkit = derive { name="ESGtoolkit"; version="0.1"; sha256="0r09arhsvamdyahini5yhgc43msdxwvn45l57xbfszahsnr3b3aq"; depends=[CDVine ggplot2 gridExtra reshape2 ycinterextra Rcpp]; };
   esotericR = derive { name="esotericR"; version="1.0"; sha256="0kl9c2z2mpg3mk8jnl0ssgcf6y0i9jpczms746j8f07ydrcxpf41"; depends=[]; };
-  ESPRESSO = derive { name="ESPRESSO"; version="2.0"; sha256="1xz4lw1rczs4laz1drrqyz91w62a99z7jzs2wkcdrhcirgmmpjp3"; depends=[MASS]; };
   EstCRM = derive { name="EstCRM"; version="1.3"; sha256="0fmnlh0pnprskq01iq3rfassyxq7fywiprvqw0xdlh8yxl3w2c9n"; depends=[Hmisc lattice]; };
   estout = derive { name="estout"; version="1.2"; sha256="0whrwlh4kzyip45s4zifj64mgsbnrllpvphs6i5csb7hi3mdb3i5"; depends=[]; };
   etable = derive { name="etable"; version="1.2.0"; sha256="17xahaf2fz1qgqjaw8qbnss95il6g47m3w00yqc5nkvv37gs0q7c"; depends=[xtable Hmisc]; };
-  ETAS = derive { name="ETAS"; version="0.0-1"; sha256="1p38ay3vnca8b8wszm66whxap8k58c004l1nlsk7zkynyia0im6c"; depends=[spatstat]; };
-  etasFLP = derive { name="etasFLP"; version="1.0.3"; sha256="1krfpnqh7w157cfy8rwa6dmr0j8xqvnhwvygbrcvns3a3y4v4ix0"; depends=[mapdata rgl fields maps]; };
+  ETAS = derive { name="ETAS"; version="0.0-1"; sha256="1p38ay3vnca8b8wszm66whxap8k58c004l1nlsk7zkynyia0im6c"; depends=[]; };
+  etasFLP = derive { name="etasFLP"; version="1.1.1"; sha256="0p24f4ycf7vckcwcmn6rkrdvv96q7w94gjp3h2k2s3v1yawgn152"; depends=[mapdata rgl fields maps]; };
   ETC = derive { name="ETC"; version="1.3"; sha256="1nvb9n0my7h1kq996mk91canxi6vxy3mzhrshrvm13ixvl48lkkh"; depends=[mvtnorm]; };
   ETLUtils = derive { name="ETLUtils"; version="1.2"; sha256="0mlfq23v7nl6lslscknk9mdx4dxk8xyc5imnvzlhzhag0k50mqj2"; depends=[ff]; };
   etm = derive { name="etm"; version="0.6-1"; sha256="00sm4cib1r4wcn71v1ry3asszshks4f6br7s5xzm8d5ngxdlsxda"; depends=[survival lattice]; };
···
   eventstudies = derive { name="eventstudies"; version="1.1"; sha256="13l2yhmlpiid9r3njnmvja231l00ym7gvwfbv0m9fk2k5j6gm5id"; depends=[zoo xts boot]; };
   EVER = derive { name="EVER"; version="1.2"; sha256="1yk6ln4shp53jvph6jy1d5m4cq080p6f03qwigdw4f0al9qzja2s"; depends=[]; };
   evir = derive { name="evir"; version="1.7-3"; sha256="1kn139vvzdrx5r9jayjb4b0803b0bbppxk68z00gdb50mxgvi593"; depends=[]; };
-  evmix = derive { name="evmix"; version="2.1"; sha256="1fg3pz1l3qk37qbp02c81rfsvpfm0zjh8q83cvkir1ap5k6xzfwl"; depends=[MASS gsl]; };
+  evmix = derive { name="evmix"; version="2.3"; sha256="1lp0k0ccpjaxy0l1chhr37jr2120g4x1xncvqq0dd162ppw8wqg8"; depends=[MASS gsl]; };
   evobiR = derive { name="evobiR"; version="1.0"; sha256="12j01qzc4yrjpxbj39bl29f5ypxwk33c6qf0mjjbgpwn5g6fgsi4"; depends=[seqinr ape stringr geiger taxize]; };
   evolvability = derive { name="evolvability"; version="1.0"; sha256="17vkmb5208q4lx6jslx96nbhsl9m2c4ra6264bparbgrg34byg9x"; depends=[coda]; };
   evora = derive { name="evora"; version="1.0"; sha256="0blq28ldynbq3v6rh0yk89wy1sjp4621h6iwnyyiipqwzihwrhz2"; depends=[Hmisc]; };
   EvoRAG = derive { name="EvoRAG"; version="2.0"; sha256="0gb269mpl2hbx1cqakv3qicpyrlfb4k8a3a7whhg90masbgmh8f6"; depends=[]; };
   evt0 = derive { name="evt0"; version="1.1-3"; sha256="08sbyvx49kp3jsyki60gbbnci26d6yk0yj2zcl4bhfac8c3mm6ya"; depends=[evd]; };
-  evtree = derive { name="evtree"; version="0.1-5"; sha256="09byr935z4bzc3yk0l51lnm99k2ac2z44pwx2p35w4080gpsa10r"; depends=[partykit]; };
+  evtree = derive { name="evtree"; version="1.0-0"; sha256="0i37lkdfzvgby98888ndd5wzxs7y11sxf9mh6pqpqgwif05p4z3i"; depends=[partykit]; };
   EWGoF = derive { name="EWGoF"; version="2.0"; sha256="07kpzaqfd7ihpmh2y5806mz5h64dcajia5v36pp9myl04fvpjapp"; depends=[Rcpp maxLik miscTools]; };
   Exact = derive { name="Exact"; version="1.4"; sha256="1l4cq6kslnl8x8c53m2w8w1vijmbxaxzr1fpdzrm2hfra0p5z90s"; depends=[]; };
-  exact2x2 = derive { name="exact2x2"; version="1.3.0"; sha256="0gp6b04bd6pf1a01d6d99p8mbjcqsayrdbm58wky2pg8s445523q"; depends=[exactci ssanv]; };
-  exactci = derive { name="exactci"; version="1.2-1"; sha256="1vnaggb38px2z8fhav0s8hnqz0x2y0ivfzxhyfqn2rlm1v2zxmn0"; depends=[]; };
+  exact2x2 = derive { name="exact2x2"; version="1.4.0"; sha256="1yzigyyvzs3aq3sl3birs9bzir1l8b30qfbhfg5aw80w6a5p0hb1"; depends=[exactci ssanv]; };
+  exactci = derive { name="exactci"; version="1.3-0"; sha256="03mhgpyrgm3cb0hw908wxhi6pxrvcsw4r1lmbx95xn44j1p9zpzk"; depends=[ssanv]; };
   ExactCIdiff = derive { name="ExactCIdiff"; version="1.3"; sha256="1vayq8x7gk1fnr1jrlscg6rb58wncriybw4m1z0glfgzr259103y"; depends=[]; };
   exactLoglinTest = derive { name="exactLoglinTest"; version="1.4.2"; sha256="0j146ih9szzks9r45vq1jf47hrwjq081q1nsja5h1gpllks8217h"; depends=[]; };
-  exactmeta = derive { name="exactmeta"; version="1.0-1"; sha256="1alva8ls4l56j3bdxgd1mh9isqk198iyrycc88vgpmj30gjpwncn"; depends=[]; };
+  exactmeta = derive { name="exactmeta"; version="1.0-2"; sha256="1v807ns799qajffky4k18iah0s3qh2ava6sz5i85hwx9dhkz19h4"; depends=[]; };
   ExactPath = derive { name="ExactPath"; version="1.0"; sha256="0ngvalmgdswf73q0jr4psg0ihnb7qwkamm6h64l01k5rmgd5nm16"; depends=[ncvreg lars]; };
   exactRankTests = derive { name="exactRankTests"; version="0.8-27"; sha256="0ygy3ygdnrrcggps5zh5r7kqfa9vj6gfgdyli63n8cwdimfyndhn"; depends=[]; };
   exams = derive { name="exams"; version="2.0-0"; sha256="0w3hnwnwcvl2i0y08qw96fkhfy31hx3pvw2qjxi95vhna5987k0h"; depends=[]; };
   ExceedanceTools = derive { name="ExceedanceTools"; version="1.2.2"; sha256="084sc6pggfbcyavhfnd5whyigw7dyjhb4cxmxi0kh2jiam5k8v5b"; depends=[splancs SpatialTools]; };
+  exCon = derive { name="exCon"; version="0.1-0"; sha256="02zanw79ix0gqks7svblm6bysf81yvxc4s49sq2cac4xc5hfpjj8"; depends=[jsonlite]; };
   excursions = derive { name="excursions"; version="1.1-20140610"; sha256="0x7rk00abf7fw9h2qqp6s2snkm1snkl35mgmxvgwv0a0jm3q56ls"; depends=[Matrix]; };
   ExomeDepth = derive { name="ExomeDepth"; version="1.0.7"; sha256="02jsbnpyb8y4qnid084z6x1w22pdhnjq6729ixjiw715vavn4p27"; depends=[aod VGAM]; };
-  expands = derive { name="expands"; version="1.4"; sha256="1k9rr13vbppmaq8i0s4q7szp42b444hx5fka9q9vwskhv3d9azwi"; depends=[rJava flexmix matlab mclust moments ape permute]; };
+  expands = derive { name="expands"; version="1.5"; sha256="14m5fzh302v0nchf875i4nwrr25wk7hych405psgfidq058pr985"; depends=[rJava flexmix matlab mclust moments ape permute]; };
   ExpDes = derive { name="ExpDes"; version="1.1.2"; sha256="0qfigbx06b3p04x5v7wban139mp8hg8x77x6nzwa4v6dr226qbkv"; depends=[]; };
   ExpDes_pt = derive { name="ExpDes.pt"; version="1.1.2"; sha256="0khw2jhg2vxcivgr20ybvrsqhd8l8bir5xjmr4m44za9nhap43bz"; depends=[]; };
   expectreg = derive { name="expectreg"; version="0.39"; sha256="1mxhv6phc3lgp0zz20wszx4nr3by9p6492wcb0x8wn8p8p1sy1b3"; depends=[mboost BayesX quadprog]; };
···
   expp = derive { name="expp"; version="1.1"; sha256="13zbhkkcshqrpln5gsa051d390q9ij97lawsdbd5j7fj9hxm9pwh"; depends=[sp spdep rgeos deldir]; };
   expsmooth = derive { name="expsmooth"; version="2.02"; sha256="1l9k4llzkqwzmrr1l68qr58ngzs3ql67hxrr5fcrcwwnaa1zinyj"; depends=[tseries forecast]; };
   exptest = derive { name="exptest"; version="1.2"; sha256="0wgjg62rjhnr206hkg5h2923q8dq151wyv54pi369hzy3lp8qrvq"; depends=[]; };
-  exsic = derive { name="exsic"; version="1.0"; sha256="01gvqpy72vs7hn5hcxazzqjb44crh0j31khc11m99ig1ynkbvkms"; depends=[stringr markdown]; };
-  ExtDist = derive { name="ExtDist"; version="0.3.3"; sha256="1igdjyadjvm26n3y08gckblxnndrly8d8cgr23hrjww7khdn6ng2"; depends=[numDeriv optimx matrixcalc]; };
+  exsic = derive { name="exsic"; version="1.1.1"; sha256="1k6nqs9i4iivxnk4nkimp6zvdly274wibkmx9n0wz01gnzxqil0p"; depends=[stringr markdown]; };
+  ExtDist = derive { name="ExtDist"; version="0.3.7"; sha256="0vcckw94j02qcy298p26f2v9jrw3a0j62r4xb0cg11cj5aysqw3q"; depends=[numDeriv optimx VGAM SuppDists truncdist]; };
   extfunnel = derive { name="extfunnel"; version="1.3"; sha256="162w5b2wjs3yqy8jisamsapav6swa8sskf1b6x5hglnrv3i4qyyy"; depends=[rmeta]; };
-  extlasso = derive { name="extlasso"; version="0.1"; sha256="1yb7pfvpchpx81ffa8hjl5h0qf7714zasllf7w4znk3i9dadbyd1"; depends=[]; };
   extraBinomial = derive { name="extraBinomial"; version="2.1"; sha256="0qmvl35f7n78kghszwyaz4wzbswqy4p98c3b6alzrc2ldsq6pq5z"; depends=[]; };
-  extracat = derive { name="extracat"; version="1.7-0"; sha256="1m0rfz6vma8rw8rgmadagw26ysq4jmwwysdy9kb5vk8d06la3hag"; depends=[colorspace hexbin scales ggplot2 reshape2 plyr TSP]; };
+  extracat = derive { name="extracat"; version="1.7-1"; sha256="1vgxr9j812jjr0i188vv7c1l0d7b73aakvfgsm0agwv7vj8k0rhi"; depends=[colorspace hexbin scales ggplot2 reshape2 plyr TSP]; };
   extrafont = derive { name="extrafont"; version="0.16"; sha256="0ml1a7m28cdx1a6qcmg8840v95lmhl39ad51q1k3bnqzbxfgqncl"; depends=[extrafontdb Rttf2pt1]; };
   extrafontdb = derive { name="extrafontdb"; version="1.0"; sha256="115n42hfvv5h4nn4cfkfmkmn968py4lpy8zd0d6w5yylwpzbm8gs"; depends=[]; };
-  extraTrees = derive { name="extraTrees"; version="1.0.1"; sha256="0kq59aw05cjvry4sbwb4mrnrhggibjnf0ga9kwbipkkdgzzj5wsz"; depends=[rJava]; };
+  extraTrees = derive { name="extraTrees"; version="1.0.3"; sha256="1igk6f9s8bp097zkirr4qprx5lkci8l1v7hglqpbrj5m156xyj10"; depends=[rJava]; };
   ExtremeBounds = derive { name="ExtremeBounds"; version="0.1.4.1"; sha256="00k7s5dpia9hajdsb70vd0bx01spaz4m6cjk00gzwndia54cb1dp"; depends=[Formula]; };
-  extRemes = derive { name="extRemes"; version="2.0-1"; sha256="0rp2khgrq3wpyxvhyrgrx5b5af33jzfcgmmqlvkx0rr6ql4fqywq"; depends=[Lmoments distillery car]; };
+  extRemes = derive { name="extRemes"; version="2.0-3"; sha256="0aiigqyay3i4nlmmr1k7fs2nw6vqxf1q321p6s0ip8aq2awlgnjl"; depends=[Lmoments distillery car]; };
   extremevalues = derive { name="extremevalues"; version="2.2"; sha256="162j6kqnd1ak2w2m6y5dbxcya1ap4648hvc83ibq33bxk98rh7sb"; depends=[]; };
   extWeibQuant = derive { name="extWeibQuant"; version="1.0"; sha256="0l20x33nh50jfrkwm8d0n824d400lnjia8ymdwr10sgj3v1x7vp1"; depends=[]; };
   eyetracking = derive { name="eyetracking"; version="1.1"; sha256="0ajas96s25hjp3yrg42hp78qjhl1aih04mjirkskx32qsyq5hfpv"; depends=[]; };
···
   factas = derive { name="factas"; version="2.3"; sha256="015lpxf37z8vx4h7a8lavksd7i0gc4x7a7ja63wi9h1czdjsc28k"; depends=[plotrix FactoMineR Matrix]; };
   FactMixtAnalysis = derive { name="FactMixtAnalysis"; version="1.0"; sha256="1l4wfp39b7g38vdk6jpd5zq08sjhsg0s71f662aca2rj6l3a2x3r"; depends=[MASS mvtnorm]; };
   FactoClass = derive { name="FactoClass"; version="1.1.0"; sha256="0y7yd2i79j1m5yl6vnvma47xhr3rl7i37h9sadyrpfm4s486b3kc"; depends=[ade4 xtable]; };
-  FactoMineR = derive { name="FactoMineR"; version="1.26"; sha256="0a5kxygybsk2y7nyzl3hnvpspimx3c77j7n8syhs817zw3d6sg6i"; depends=[car ellipse lattice cluster scatterplot3d leaps]; };
+  FactoMineR = derive { name="FactoMineR"; version="1.27"; sha256="1ai76v74ygn183ka3qz1yz9wz1yidbymgylh00lg6f2mjz0r937i"; depends=[car MASS ellipse lattice cluster scatterplot3d leaps]; };
   factorplot = derive { name="factorplot"; version="1.1-1"; sha256="1l8pabf32dr12l7b4dgv5jaxpsjymgdxc51miv72zczrx8adc7da"; depends=[multcomp nnet]; };
   factorQR = derive { name="factorQR"; version="0.1-4"; sha256="1vl01fm5qfyhnqbl5y86vkr50b8cv07vzlqs3v6smqaqq6yp4lv4"; depends=[lattice]; };
   factualR = derive { name="factualR"; version="0.5"; sha256="1wz8ibcmilcx62yy29nd2i1pdmjf7fm0g9i5s58gdn8cjlhnw1jl"; depends=[RJSONIO RCurl]; };
-  FADA = derive { name="FADA"; version="1.0"; sha256="1qqxzlmwybajyjfvmlvkq6bfd8vm7lgvgs49vh3x8fdbk6annaj6"; depends=[MASS elasticnet sparseLDA sda glmnet mnormt]; };
+  FADA = derive { name="FADA"; version="1.2"; sha256="1wpjqvhhgvirzcvl8r23iaw63wr8rys19mjy71mn24wg3zwnc2qz"; depends=[MASS elasticnet sparseLDA sda glmnet mnormt crossval]; };
   FAdist = derive { name="FAdist"; version="2.0"; sha256="0qkbliz25xlsng7fi9hk1vshpd3535yrv5rc43m3g2mj024a9wxg"; depends=[]; };
   Fahrmeir = derive { name="Fahrmeir"; version="2012.04-0"; sha256="1axx6r4g6gj1inih41i2az4y0d3jq9x1a6nyj8k7wp51z4z2nbmk"; depends=[]; };
   fail = derive { name="fail"; version="1.2"; sha256="0xzvb71iq20ah1x1zlb9kbx0r47jhqlzxx0sxwhkibglpzskg84z"; depends=[BBmisc]; };
   FAiR = derive { name="FAiR"; version="0.4-15"; sha256="18nj95fiy3j7kf4nzf692dxja3msnaaj5csg745bnajb48l606wz"; depends=[rgenoud gWidgetsRGtk2 rrcov Matrix]; };
-  faisalconjoint = derive { name="faisalconjoint"; version="1.10"; sha256="0z1d241s05jpcih6kh8dhs3k506mwls4xms5zszsmdbzri6sa34x"; depends=[]; };
   falcon = derive { name="falcon"; version="0.1"; sha256="0yas8a8nqdp03s77k5z1xlyz59gapyx68pz0mf6i2snjwpgai59v"; depends=[]; };
+  falsy = derive { name="falsy"; version="1.0"; sha256="16j6j7kf5xlqg6m2sfdfgpcjf9grrcfh9ij0282hnirgl7a4cvjd"; depends=[]; };
   fame = derive { name="fame"; version="2.18"; sha256="132wb59d15bs94fga5hwxxr9pklyp2rjn448nl8lx5spjrvycwf4"; depends=[tis]; };
   Familias = derive { name="Familias"; version="2.1"; sha256="1ccm2hm8vlm450yqx3r45qklgwa6wb54i39ybfh9g2fl544spzn8"; depends=[paramlink]; };
   FAMT = derive { name="FAMT"; version="2.5"; sha256="0mn85yy9zmiklfwqjbhbhzbawwp2yqrm9pvm8jhasn9c3kw1pcp2"; depends=[mnormt]; };
···
   fANCOVA = derive { name="fANCOVA"; version="0.5-1"; sha256="034m2mmm6wmsjd41sg82m9ppqjf4b1kgw5vl2w7kzqfx0lypaiwv"; depends=[]; };
   fanovaGraph = derive { name="fanovaGraph"; version="1.4.7"; sha256="19bzl6yrmi5lgyx6nq3f7i0rdaz2ig580h8116axrsxpx8c4d52x"; depends=[sensitivity igraph DiceKriging]; };
   fanplot = derive { name="fanplot"; version="3.3"; sha256="0bv7x3xrsg0pmp9gmck30jypv8cwc03bv753m49dfpgs2p9srcmc"; depends=[]; };
-  FAOSTAT = derive { name="FAOSTAT"; version="1.6"; sha256="18wx691hclbf7fvfk3swsz6ripv9w70nlqhsk3lgr4il8bjsr3cy"; depends=[RJSONIO plyr data_table MASS classInt ggplot2 labeling scales]; };
+  FAOSTAT = derive { name="FAOSTAT"; version="1.9"; sha256="0gff60vlv35m5sjmz7glbdrd6ijy6n32a9xd26z2ix839qgywvqj"; depends=[RJSONIO plyr data_table MASS classInt ggplot2 labeling scales]; };
   faoutlier = derive { name="faoutlier"; version="0.4"; sha256="113qpwil669jr89kpqs6c6xzh0z3vp2hzfy98mh1dr2dvaznd06f"; depends=[sem lattice lavaan MASS]; };
   far = derive { name="far"; version="0.6-3"; sha256="0i7c0zrz33abwkml1zdjf5m61bxpfndwziqjbh6wyhdz8msp2kmf"; depends=[nlme]; };
   faraway = derive { name="faraway"; version="1.0.6"; sha256="10vj38chfnlz595pdi16v8gcwsbmn8a7p4gb0mm98dncyin5p2a3"; depends=[]; };
   fArma = derive { name="fArma"; version="3010.79"; sha256="1byxyy4afl1gq58r1cmc5p6frdr9rljr1x3pdnc8nj8rr65lkg72"; depends=[timeDate timeSeries fBasics]; };
   farsi = derive { name="farsi"; version="1.0"; sha256="0y14f86bccwjirdx33383wa605y7l7lr0w7ygvg8r7f7izkv7r3n"; depends=[]; };
   fAsianOptions = derive { name="fAsianOptions"; version="3010.79"; sha256="1w9ph3rz6cd7g275flzsnqxwd3r5xin6pkini8pbsi9s8hbqv3vl"; depends=[timeDate timeSeries fBasics fOptions]; };
+  fAssets = derive { name="fAssets"; version="3011.83"; sha256="0i3phc8kxwhzf6010bv5k2ff5zlv7aqrwavqmhly4wwby73i39yl"; depends=[timeDate timeSeries fBasics fMultivar robustbase MASS sn ecodist mvnormtest energy]; };
   fast = derive { name="fast"; version="0.63"; sha256="00ag9d0dwn9al104y93m8dclbjqabr9liif8gr19v3gv6k2k6p2c"; depends=[zoo]; };
   fastclime = derive { name="fastclime"; version="1.2.4"; sha256="0z91khjzffwy4mbqgkfw4l9mw32sg4p5pvcg4v24z1q44pgnwn4y"; depends=[lattice igraph MASS Matrix]; };
   fastcluster = derive { name="fastcluster"; version="1.1.13"; sha256="0hkml8ggmq5gqw9indqh6rb5x922qq8chd9s35fkxdcgzw58253a"; depends=[]; };
   fastcox = derive { name="fastcox"; version="1.1.1"; sha256="1a5i0ragl0r6p29iamkn04igakiwyysykfbs2p6ybgy8pfdq69sv"; depends=[Matrix]; };
-  fastGHQuad = derive { name="fastGHQuad"; version="0.1-1"; sha256="0qnffhplfl2kb4dd90as298ays19k4f18slhj063f01gywqqrahn"; depends=[Rcpp]; };
+  fastGHQuad = derive { name="fastGHQuad"; version="0.2"; sha256="0yv3wdyj7hs1gr3rq08k520v0ldmv5zzng709xjx2kchhwhmy8ah"; depends=[Rcpp]; };
   FastHCS = derive { name="FastHCS"; version="0.0.2"; sha256="0vc7wmsgk731br0y1vrv50vx5sp7jjjbavd4my6y72rsl9iajv3q"; depends=[matrixStats]; };
   fastHICA = derive { name="fastHICA"; version="1.0"; sha256="02lqqni7j2sp3ndb3kq785d7jf08p2s3ch30di8ffhwn57indald"; depends=[fastICA energy]; };
   fastICA = derive { name="fastICA"; version="1.2-0"; sha256="0ykk78fsk5da2g16i4wji85bvji7nayjvkfp07hyaxq9d15jmf0r"; depends=[]; };
   FastImputation = derive { name="FastImputation"; version="1.2"; sha256="04bz623kcanxcl9z8zl6m7m47pk0szcjrjlgs5v1yl3jnq9m2n7g"; depends=[]; };
   fastM = derive { name="fastM"; version="0.0-2"; sha256="0q5dz47sqj6d4r3k6l6q34l5ajb8fjbf7xam75scp0mg3czswnfn"; depends=[Rcpp]; };
   fastmatch = derive { name="fastmatch"; version="1.0-4"; sha256="16gfizfb1p7rjybrfm57nb6hdm30iirbppva8p8xf8pndz35fjbs"; depends=[]; };
-  FastPCS = derive { name="FastPCS"; version="0.0.9"; sha256="12hzp8vk2qb847xy42r0dhab21c0xn23vvakb4qa1jwz6ykji1zk"; depends=[matrixStats]; };
-  fastR = derive { name="fastR"; version="0.4-2"; sha256="19vg2dpbq4d7c3zyp18ygx91f0i0n37xwywbj87l7va82l55flyx"; depends=[lattice mosaic]; };
-  FastRCS = derive { name="FastRCS"; version="0.0.3"; sha256="0v69hgl0lwasj6xhzmd9sqv3ipax8d0gz6svhmcvnf47rzr8wc7z"; depends=[matrixStats]; };
+  fastR = derive { name="fastR"; version="0.8-1"; sha256="08p03i72zn0cbwjsxpnsknk0148dx3pfwkw740x7f52c3jgbb1gi"; depends=[mosaic lattice mosaicData]; };
   FastRWeb = derive { name="FastRWeb"; version="1.1-0"; sha256="1hiabi7ibp69n5wi5x4kwznxhc2i7dxdrqf1fm6ppv7ix0wkjs07"; depends=[Cairo]; };
   fastSOM = derive { name="fastSOM"; version="0.9"; sha256="03501d5289lrlr4qcgxciz160hqc6nhqb9ab266fr132fkbiv4id"; depends=[]; };
-  fat2Lpoly = derive { name="fat2Lpoly"; version="1.0.2"; sha256="1v5lrs2jksqiaavyhrsa2kjcw84wzg98g3v0kyx7jhmq8686027g"; depends=[kinship2 multgee]; };
+  fat2Lpoly = derive { name="fat2Lpoly"; version="1.1.1"; sha256="0xgxlx9m6lgcn784892g2xvnabyq8k45wi3xrszrbdxxa7zqd1i4"; depends=[kinship2 multgee]; };
   FatTailsR = derive { name="FatTailsR"; version="1.0-3"; sha256="0r9n18qlr70p6y4v1xv1lxi1lzm9qp29qy4w51chllqjn15kmv7l"; depends=[minpack_lm]; };
   FAwR = derive { name="FAwR"; version="1.0.1"; sha256="1j97hdhaamg6xqkaxb04xzsd60hd69n9y84frkqi9swvhr565waj"; depends=[MASS lattice]; };
-  fBasics = derive { name="fBasics"; version="3010.86"; sha256="1ij7f030r12g7s4jfykyfbnfwxwy777smccf9aw0imrz5ik6qjaj"; depends=[MASS timeDate timeSeries stabledist gss]; };
+  fBasics = derive { name="fBasics"; version="3011.87"; sha256="1x4jv4db0nr2fig6hglk0kv6j27ngkc8qzclgiklbl8wjfrrp9zh"; depends=[timeDate timeSeries gss stabledist MASS]; };
   fbati = derive { name="fbati"; version="1.0-1"; sha256="1ia67dg9b61kc14mjg7065v0c6n6agdp8cjdviasyzga00wzsyxj"; depends=[pbatR fgui rootSolve]; };
   FBFsearch = derive { name="FBFsearch"; version="1.0"; sha256="1nxfhll9gx9l6hzpcihlz880qxr0fyv5rjghk0xgp8xn4r5wxw11"; depends=[Rcpp RcppArmadillo]; };
   FBN = derive { name="FBN"; version="1.5.1"; sha256="0723krsddfi4cy2i3vd6pi483qjxniychnsi9r8nw7dm052nb4sf"; depends=[]; };
···
   fcd = derive { name="fcd"; version="0.1"; sha256="091wbf5iskcgyr7jv58wrf590qijb0qcpninmvm3xrwxi34r37xr"; depends=[glmnet MASS combinat]; };
   fCertificates = derive { name="fCertificates"; version="0.5-3"; sha256="1m0kglsr6g0f7m8r9ls95zj3hmjqq83whyk6svar39p13vabadw6"; depends=[fBasics fOptions fExoticOptions]; };
   fclust = derive { name="fclust"; version="1.0.1"; sha256="1xl8mw4wfwp9n9fmfmzxz8k8qyrk62qr77j085b3kgp7a85dp8ma"; depends=[]; };
-  fcros = derive { name="fcros"; version="1.1"; sha256="1wnsjghcs0gfqzl6v95zf0cxm3apnii92b2gxg3hkbgmc6xjm5bf"; depends=[]; };
-  FD = derive { name="FD"; version="1.0-11"; sha256="18g2fn6s60hxnasrj58450bjsf4kz62mypyby9avs5anlwihj8gm"; depends=[ade4 ape geometry vegan]; };
+  fCopulae = derive { name="fCopulae"; version="3011.81"; sha256="0r4g567icgiiz6cxi6ak3kzrav9qzsc6zvww5dj1pd8mkd4r1f0y"; depends=[timeDate timeSeries fBasics fMultivar]; };
+  fcros = derive { name="fcros"; version="1.2"; sha256="0p2qx5fyfr6fa6dpbg07xgqx452wzmrsf30hkdjllp1vry8yy6jp"; depends=[]; };
+  FD = derive { name="FD"; version="1.0-12"; sha256="0xdpciq14i8rh7v6mw174hip64r7mrzhx7gwri3vp9y7a1380sbi"; depends=[ade4 ape geometry vegan]; };
   fda = derive { name="fda"; version="2.4.3"; sha256="19a7jylpr8sh1yz9ljyk889ksfd0xwagbvg83vy6vfsi82q1910g"; depends=[Matrix]; };
   fdakma = derive { name="fdakma"; version="1.1.1"; sha256="0y70ckgxkns6p45gv9w02krrr96vzs8f838s5vk02c2m6ynp4prs"; depends=[]; };
   fdaMixed = derive { name="fdaMixed"; version="0.4"; sha256="15m13v71kqxd9gqiymgfkq0dvcpzp05576m8zkg08m0k067ga9bd"; depends=[Formula Rcpp]; };
···
   fdatest = derive { name="fdatest"; version="1.0"; sha256="0m17abycfczkhwmrmjg43ra3fcaqicr15v2frwfgr5p1wj9x0gwq"; depends=[fda]; };
   fda_usc = derive { name="fda.usc"; version="1.2.0"; sha256="1ifp94i0px3683ph90f7c3z1gh92c33nlfk1f2drr4s0fyb1kzy3"; depends=[fda MASS mgcv rpart]; };
   FDboost = derive { name="FDboost"; version="0.0-5"; sha256="1xra0g46kicq74cpjby6y1va2bxvx8b9fiy76mdg1s6n8m6r1pxn"; depends=[mboost Matrix mgcv zoo nnls]; };
+  FDGcopulas = derive { name="FDGcopulas"; version="1.0"; sha256="1i86ns4hq74y0gnxfschshjlc6if3js0disjb4bwfizaclwbw3as"; depends=[Rcpp numDeriv randtoolbox]; };
   fdrci = derive { name="fdrci"; version="2.0"; sha256="0smyl9phl02wghimawvff3h267w3h213jbqpka155i6cfzig9qjy"; depends=[]; };
   FDRreg = derive { name="FDRreg"; version="0.1"; sha256="17hppvyncbmyqpi7sin9qsrgffrnx8xjcla2ra6y0sqzam1145y4"; depends=[fda Rcpp mosaic]; };
   fdrtool = derive { name="fdrtool"; version="1.2.12"; sha256="15c1ikddwzzl3mq2dcwjicjg46k436m315dhmkxmbwilrdqlcrn6"; depends=[]; };
   fds = derive { name="fds"; version="1.7"; sha256="164f2cbywph7kyn712lfq4d86v22j4y3fg5i9zyz956hipqv0qvw"; depends=[rainbow RCurl]; };
   fdth = derive { name="fdth"; version="1.1-8"; sha256="195219rndjcccd3b1gn3xc9iky8f3w5ig8x9822d4a2xajr78jnv"; depends=[]; };
-  FeaLect = derive { name="FeaLect"; version="1.3"; sha256="0an548y067g2n7xbg6slxnlaxzn71nwq28cdf9788w4zs98gh9c9"; depends=[lars rms]; };
   feature = derive { name="feature"; version="1.2.10"; sha256="0jsqa2mv4kxzx3jh1lakg62f15776yzc8clj7wyijnx4jbkx8k8j"; depends=[ks]; };
   features = derive { name="features"; version="2011.8-2"; sha256="0yshwqv2mzl5jj323jwxscpz2ygb4ywxh6q0zwphb24bhv7h9lwd"; depends=[lokern]; };
   fechner = derive { name="fechner"; version="1.0-2"; sha256="0yhiqr0wlka3wq0nhwy9n02ax3x5b0y803iadbsr3xb54pxbfbqd"; depends=[]; };
   federalregister = derive { name="federalregister"; version="0.1.2"; sha256="0f73jhzhqi3a97iyfx5c5i09vxwnyypgw6668z7nch8lvq337s8x"; depends=[RCurl RJSONIO]; };
-  FeedbackTS = derive { name="FeedbackTS"; version="1.1"; sha256="1vp9kxfk1p9hcdl9qg0f5bggh7h2ly9ag70w7dbmkgsika4c0r03"; depends=[maps mapdata proj4 geoR]; };
+  FeedbackTS = derive { name="FeedbackTS"; version="1.2"; sha256="0yg90b9fk8cq0kilhfr598x74hdnji42pny10jw43f70hdf9mkl1"; depends=[maps mapdata proj4 geoR sp]; };
   fExoticOptions = derive { name="fExoticOptions"; version="2152.78"; sha256="0h58prj8nh340b0fxxkgg4bk25yxvb4f8ppq677hr12x8sysf1a8"; depends=[timeDate timeSeries fBasics fOptions]; };
   fExpressCertificates = derive { name="fExpressCertificates"; version="1.2"; sha256="1r4qkhf7alasbwjz910b0x4dlzm72af06kv7v2vwyzvf3byn21c5"; depends=[mvtnorm tmvtnorm fCertificates Matrix]; };
   fExtremes = derive { name="fExtremes"; version="3010.81"; sha256="0bzgnn0wf7lqhj7b2dbbhi61s8fi2kmi87gg9hzqqi6p7krnz1n5"; depends=[timeDate timeSeries fBasics fGarch fTrading]; };
···
   fgui = derive { name="fgui"; version="1.0-5"; sha256="0gzwxzvf2y9p5rlfk862d7l1dm2sdwjhjpcb8p494cj4g1xshazg"; depends=[]; };
   FHtest = derive { name="FHtest"; version="1.1"; sha256="0yqy3lvxjhk7biqfikxqlgs9zsy1vlld9pqxhgxmq04gbnjn2jfk"; depends=[interval MLEcens MASS KMsurv]; };
   FI = derive { name="FI"; version="1.0"; sha256="17qzl8qvxklpqrzsmvw4wq3lyqz3zkidr7ihxc4vdzmmz69pyh2f"; depends=[]; };
-  fICA = derive { name="fICA"; version="1.0-0"; sha256="054dg6ikps0ynfy06y95an5mi2wwqx88ylk5qcifxhjiylw36v5v"; depends=[JADE]; };
+  fICA = derive { name="fICA"; version="1.0-2"; sha256="058kkhjksm0nrfaj0csi6dgzr83kq4cln04v9fja12cqvdij9k7k"; depends=[JADE Rcpp]; };
   fields = derive { name="fields"; version="7.1"; sha256="0wxm8pq4j5clz1hcgdlajasg5cbq8x35i82wrw3gsy27kslyadkd"; depends=[spam maps]; };
   FieldSim = derive { name="FieldSim"; version="3.1.3"; sha256="0ap1mfsjj3bflpryn0y8h9kg5mzfrnqj6h9f3m5ja32yjv19ql60"; depends=[rgl RColorBrewer]; };
   fifer = derive { name="fifer"; version="1.0"; sha256="0vbkks6y6pacgpiixm10fbfa34lmk5r9kwd30lfjf0g7r51fhvv9"; depends=[xtable MASS]; };
···
   FITSio = derive { name="FITSio"; version="2.0-0"; sha256="1gf3i1q9g81gydag2gj1wsy6wi5jj2v4j3lyrnh1n2g4kxd6s3cp"; depends=[]; };
   fitTetra = derive { name="fitTetra"; version="1.0"; sha256="0ia6wk4gicpmn6kclsd28p7v1npwfv2blagiz0cxzwfw3njv103g"; depends=[]; };
   FKF = derive { name="FKF"; version="0.1.3"; sha256="01ibihca39zng4wrvhq8h28bmb2rnsjm21xy22b85kpn3mbnh7f1"; depends=[RUnit]; };
-  flare = derive { name="flare"; version="1.4.0"; sha256="19hygxsz0sr1cvqyr6snxgrd9cfi25h1zyk8xhg35jffpbs97d7p"; depends=[lattice MASS Matrix]; };
+  flam = derive { name="flam"; version="1.0"; sha256="0jyx0wff5zdpnhgxz74k6fxgwdnl7khanahv63af22y0mqpd066f"; depends=[MASS]; };
+  flare = derive { name="flare"; version="1.5.0"; sha256="03bq40lwwq49vvbarf37y7c3smm29mxqfxsc66gkg8l5pak4l38i"; depends=[lattice MASS Matrix igraph]; };
   flashClust = derive { name="flashClust"; version="1.01-2"; sha256="0l4lpz451ll7f7lfxmb7ds24ppzhfg1c3ypvydglcc35p2dq99s8"; depends=[]; };
   flexclust = derive { name="flexclust"; version="1.3-4"; sha256="1x9gyg69kb3wn02w885kl6hcwpf2ki66gzfayvc83jisrwxvdfvv"; depends=[lattice modeltools]; };
   flexCWM = derive { name="flexCWM"; version="1.1"; sha256="0vxzf3ifmpg7l13bvbmv6h5a3gmn2h1xvkq354lvy4s8znk643c4"; depends=[numDeriv mnormt mclust ellipse mixture Flury]; };
-  flexmix = derive { name="flexmix"; version="2.3-11"; sha256="14nv6dxpgm9nr01rcz32x42agr4xi2anyss2fiywjidwbdgj50iy"; depends=[lattice modeltools nnet]; };
+  flexmix = derive { name="flexmix"; version="2.3-12"; sha256="1qp1q4cz5ixprqvm98i0w6rhlhlafm96qy2as7qcsah8vas5jdp1"; depends=[lattice modeltools nnet]; };
   FlexParamCurve = derive { name="FlexParamCurve"; version="1.4-3"; sha256="1056lxs9c2bbh2i2gv1bv2sy8gq6k6p0jpl1d3axqd1xk5pipm2x"; depends=[nlme]; };
-  flexsurv = derive { name="flexsurv"; version="0.3"; sha256="0ig0151843qfc4pvk9mh80kly1n9mq9aphwkwligm9llspiwbcja"; depends=[survival muhaz mvtnorm]; };
+  flexsurv = derive { name="flexsurv"; version="0.5"; sha256="0a0mhnz9xayb0pjx4glq09yiz8jplynkq8aniw9saxdik8zd1srg"; depends=[survival muhaz mvtnorm deSolve]; };
   FLIM = derive { name="FLIM"; version="1.1"; sha256="1gghzmj3mvih4gglk27rx1v18q72xnvymgzjwa84m5vlc8840jpa"; depends=[zoo MASS]; };
   flip = derive { name="flip"; version="2.4.3"; sha256="04zf2gnk5w57gxnlnh26pn1ir1wfrzxhfhchr33ghk7prhc7k4b8"; depends=[e1071 someMTP cherry Rcpp]; };
   FLLat = derive { name="FLLat"; version="1.1"; sha256="1h2nfx7gb66hjdfkdm6im6n8c1fjdz9csg39pckb47c0khl3g9r0"; depends=[gplots]; };
···
   flowfield = derive { name="flowfield"; version="1.0"; sha256="1cx3i0w3xq781mmms4x20fshlf1i9bwxw9bxx562crix3fq3m50j"; depends=[]; };
   FLR = derive { name="FLR"; version="1.0"; sha256="0k50vi73qj7sjps0s6b2hq1cmpa4qr2vwkpd2wv2w1hhhrj8lm0n"; depends=[combinat]; };
   flsa = derive { name="flsa"; version="1.05"; sha256="07z2b1pnpnimgbzkjgjl2b074pl9mml7nac2p8qvdgv7aj070cmh"; depends=[]; };
-  FLSSS = derive { name="FLSSS"; version="1.0"; sha256="1plpq4m7fh1g3hrbby1v93pnp1kn7ickb2vd6fa3zs7r9dkglikn"; depends=[Rcpp]; };
+  FLSSS = derive { name="FLSSS"; version="3.0"; sha256="1fdc0600hl9xakc0fj9yk2v2ram52rv2jhdl168p20df0afgbjam"; depends=[Rcpp]; };
   FluOMatic = derive { name="FluOMatic"; version="1.0"; sha256="06hww6viynisnfiphvghv4iqf1gk2snb8aksignaw8pnlkixnsg7"; depends=[]; };
   Flury = derive { name="Flury"; version="0.1-3"; sha256="105fv9azjkd8bsb9b8ba3gpy3pjnyyyp753qhrd11byp3d0bbxy0"; depends=[]; };
   flux = derive { name="flux"; version="0.3-0"; sha256="0pc9cab2pwrfl0fnz29wp7a398r49hvbi50jp8i2fk2rfvck21a7"; depends=[caTools]; };
   fma = derive { name="fma"; version="2.01"; sha256="1j5mvhbrdnkyj4svibpahnz7d4221nkhja5b7fnh68mbmil607fc"; depends=[tseries forecast]; };
   FME = derive { name="FME"; version="1.3.1"; sha256="1wylpxr9m65ksizjhn97082kfkf9m451qraw93cgn5660skxw7d8"; depends=[deSolve rootSolve minpack_lm MASS coda]; };
   fmri = derive { name="fmri"; version="1.5-1"; sha256="0dla5w8x4njw2njryb35nqh4r31wdps9bl5wzab2grzl546wwmwm"; depends=[]; };
-  fmsb = derive { name="fmsb"; version="0.5.0"; sha256="1aynq4d2nrx11irrbhvjavvd86ffgrw5jv6pwnk97lw6qjfk5kc3"; depends=[]; };
+  fmsb = derive { name="fmsb"; version="0.5.1"; sha256="0y9h29a2wsngx73vn07f31l8ffrrm0si3qqx60hgxmb57v501kqz"; depends=[]; };
   FMStable = derive { name="FMStable"; version="0.1-2"; sha256="00viigpqfbqc4hyl9cwicbwqf2ksjak28qrqaa16jhbqz93j4fck"; depends=[]; };
   fmt = derive { name="fmt"; version="1.0"; sha256="13gsywnyvf9zy5n644g2xyd60f92w2dp7vil2dncjvjcqsib22a0"; depends=[]; };
+  fMultivar = derive { name="fMultivar"; version="3011.78"; sha256="115hqbbxsdjs5v2rhalg8vz0m5lyg8ppjjqmbq1x21jdnbg6l0fl"; depends=[timeDate timeSeries fBasics cubature mvtnorm sn]; };
   FNN = derive { name="FNN"; version="1.1"; sha256="1kncmiaraq1mrykb9fj3fsxswabk3l71fnp1vks0x9aay5xfk8mj"; depends=[]; };
   fNonlinear = derive { name="fNonlinear"; version="3010.78"; sha256="0pmz16b606i3mx05zjln4nyl53ks7rlwgm45ldr9qgmw51pflwz9"; depends=[timeDate timeSeries fBasics fGarch]; };
   foba = derive { name="foba"; version="0.1"; sha256="1af8whgl66v0vwzdf03b6141k3dysdc0svymlgifcga5gqkwzsl0"; depends=[]; };
···
   forams = derive { name="forams"; version="2.0-4"; sha256="1kvxlqdyzb3rqa45hp7jxjm009w0r6h78nr3yh9bqcz594zqidbq"; depends=[vegan]; };
   foreach = derive { name="foreach"; version="1.4.2"; sha256="097zk7cwyjxgw2i8i547y437y0gg2fmyc5g4i8bbkn99004qzzfl"; depends=[codetools iterators]; };
   ForeCA = derive { name="ForeCA"; version="0.1"; sha256="1nbflawx8h4lpb9ixbp0zcyl0bqykqlqail31i00ywkak2ic3pm3"; depends=[ifultools splus2R nlme R_utils sapa mgcv astsa]; };
-  forecast = derive { name="forecast"; version="5.5"; sha256="040sjs26jdpcvn1mipbvy81ygr1ck1z69jhx375l76hbswyq801c"; depends=[zoo timeDate tseries fracdiff Rcpp nnet colorspace]; };
+  forecast = derive { name="forecast"; version="5.6"; sha256="16dwbqqhjvn7q6zj4h0p3amjs3wlc0krpjaqmhk8p6ny11qaj70c"; depends=[zoo timeDate tseries fracdiff Rcpp nnet colorspace]; };
   foreign = derive { name="foreign"; version="0.8-61"; sha256="0r994z3ihvrbfhzpvp2dkxbfgkbmccgrryfaxmy1vi56v59n73w8"; depends=[]; };
   forensic = derive { name="forensic"; version="0.2"; sha256="0kn8wn6p3fm67w88fbarg467vfnb42pc2cdgibs0vlgzw8l2dmig"; depends=[genetics combinat]; };
   forensim = derive { name="forensim"; version="4.3"; sha256="1j92imykw48cciay0r6n1aq1jrdb2b1grrz6lpc4kgbnbd7mk0qm"; depends=[tcltk2 tkrplot]; };
···
   ForIT = derive { name="ForIT"; version="1.0"; sha256="0mi2cw09mbc54s8qwcwxin2na1gfyi60cdssy2ncynma7alq3733"; depends=[]; };
   fork = derive { name="fork"; version="1.2.4"; sha256="1sb4xypirmrknhrc872ky845kym58dmakn6c2crsbp67wpg63m4l"; depends=[]; };
   FormalSeries = derive { name="FormalSeries"; version="1.0"; sha256="09m4ifinasww0xfprs29xsrqhxxkw9zffb3919xnkkjkwp0nax4v"; depends=[]; };
-  formatR = derive { name="formatR"; version="0.10"; sha256="0rxm4c896rcmalmq1hsjg053dqb3m2vf9jqap5w5bsllaiakwh4a"; depends=[]; };
+  formatR = derive { name="formatR"; version="1.0"; sha256="18wv05ijdymipnyxy5h34y3nbx42ifk79qiapfgx5fjjzpspq6q5"; depends=[]; };
   Formula = derive { name="Formula"; version="1.1-2"; sha256="1axjcmy4x2175nrfjc7vwkijcyr86ws6nbs08990wq8gcal15a10"; depends=[]; };
   formula_tools = derive { name="formula.tools"; version="1.3.4"; sha256="1xxl45x88fpskwvfj6sbcbfng84plpf8sjrkwawzki9a41ydhwaq"; depends=[operator_tools]; };
   fortunes = derive { name="fortunes"; version="1.5-2"; sha256="1wv1x055v388ay4gnd1l8y6dgvamyfvmsd0ik9fziygwsaljb049"; depends=[]; };
   forward = derive { name="forward"; version="1.0.3"; sha256="0swn5ysp3f660kl9jpmkck9324j1g3yhj2hl238rfrcr5wihxifc"; depends=[MASS]; };
+  ForwardSearch = derive { name="ForwardSearch"; version="1.0"; sha256="0yd47832piqxzjxgl7bc8pn0c8f7vbgsm9z6894rzyi615kjl70b"; depends=[robustbase]; };
   fossil = derive { name="fossil"; version="0.3.7"; sha256="188hyb3r1dnxkmqf2czh1kdzmk4mjc0v1kn1zml2yvxaxk7adsrz"; depends=[sp maps shapefiles]; };
   FourScores = derive { name="FourScores"; version="1.0"; sha256="0d21mrl9bzsvhljv7ymiyck508smp66w9qivrb2rp0p803h9yibm"; depends=[]; };
-  fpc = derive { name="fpc"; version="2.1-7"; sha256="1zymk2v7s8jyn4jm3qaxzd5rlx748ap4ad2dd56w195q5j1xn4bh"; depends=[MASS cluster mclust flexmix]; };
+  fpc = derive { name="fpc"; version="2.1-9"; sha256="01x7zcsbz9n10dxx8plb37c7z7pfz1xd5dvfrij3na327mny3pxs"; depends=[MASS cluster mclust flexmix prabclus class diptest mvtnorm robustbase kernlab trimcluster]; };
   fpca = derive { name="fpca"; version="0.2-1"; sha256="13b102026xlfb7c2rb3xsqsymm7xpmaxppaafjkb5dx0b1lz0jrc"; depends=[sm]; };
   FPDC = derive { name="FPDC"; version="1.0"; sha256="0f6f5bjh1dqv9n6hpbgj922ymbd1zdb0b4ad5h9nk1c6c9ysai7y"; depends=[ThreeWay]; };
+  fPortfolio = derive { name="fPortfolio"; version="3011.81"; sha256="1rmyp2dv1jgrfj76mnggvi98ffa0yr8d9dlxxmg5pc6pdy2g4q4c"; depends=[timeDate timeSeries fBasics fAssets fCopulae robustbase MASS Rglpk slam Rsymphony Rsolnp kernlab quadprog rneos]; };
   fpow = derive { name="fpow"; version="0.0-2"; sha256="0am3nczimcfrm9hi02vl2xxsh703qjmr2j11y014mll3f2v1l8cy"; depends=[]; };
   fpp = derive { name="fpp"; version="0.5"; sha256="1jqnx6bgpvnbbj2fa2b6m6aj8jd5cb9kz877r8kp7a5qj62xv1ww"; depends=[forecast fma expsmooth lmtest tseries]; };
   fptdApprox = derive { name="fptdApprox"; version="2.0"; sha256="152bajs76wrapp0zdbkckff6kdkkm6sqqlqd2w220hsi96l2p9dh"; depends=[]; };
   fracdiff = derive { name="fracdiff"; version="1.4-2"; sha256="03l5dqpqwwi5c8fwc2vissfawcsignai60h2zalknkibvk782dwq"; depends=[]; };
-  fracprolif = derive { name="fracprolif"; version="1.0.5"; sha256="0d028dkiwv8jlsnvdv3wqgx6vsl2ai0icpdadl66sjj45yxv1z7g"; depends=[emg numDeriv]; };
   fractal = derive { name="fractal"; version="2.0-0"; sha256="17wz3c9f1l1rphzdn7j27j5nb1ll6j84f9ihk0z6fni41050szv7"; depends=[splus2R ifultools sapa wmtsa scatterplot3d]; };
   fractaldim = derive { name="fractaldim"; version="0.8-4"; sha256="0fln4qn0d79agnnlzi8b9g9qn90zynq1cg9v5isiyi71345v45nr"; depends=[abind]; };
   fractalrock = derive { name="fractalrock"; version="1.1.0"; sha256="15f4w8hq3d8khgq269669ri16qxhar9646w40cw7wzh79r9gpf00"; depends=[futile_any futile_logger timeDate quantmod]; };
   FRACTION = derive { name="FRACTION"; version="1.0"; sha256="0g25dzsbharsq8bzfka96zccaqppdclax24mz5m080ddg4y8zj49"; depends=[]; };
   frailtyHL = derive { name="frailtyHL"; version="1.1"; sha256="1xjdph0ixanf9w4b6hx6igfhkcp8h93sclrg0pgqgmbvm41lhb1x"; depends=[Matrix numDeriv survival]; };
-  frailtypack = derive { name="frailtypack"; version="2.6.1"; sha256="0xzf7qffp9ybxdd9x2s30k23lcss8wf6rbljp3x5xbyg87nfawyd"; depends=[survival boot MASS survC1]; };
+  frailtypack = derive { name="frailtypack"; version="2.7.2"; sha256="07vhpz757argz9k15lxnn2iad1gybnnjgw6n9pp7sghh5bynx5j1"; depends=[survival boot MASS survC1]; };
   frair = derive { name="frair"; version="0.4"; sha256="1g52ykj1m9znpp0pvry7dnmhg4m73nbkw0bp31zl6pcsdgmxxqjr"; depends=[bbmle emdbook boot]; };
+  Frames2 = derive { name="Frames2"; version="0.0.3"; sha256="0nsiff1lpxzhiv0ah5d116aldm4qmwqgx9vvk6q03p8lwj4mynsn"; depends=[sampling]; };
   FRAPO = derive { name="FRAPO"; version="0.3-8"; sha256="1wqayyai8pdm1vq6qvpd10qpd882cyjb0y0jl582fxd3a2ic7n14"; depends=[quadprog Rglpk timeSeries]; };
   FRB = derive { name="FRB"; version="1.8"; sha256="13rp4gqldx84mngrdv5fa9xamkng7b3kgy30ywykcx46gmrym6ps"; depends=[corpcor rrcov]; };
   frbs = derive { name="frbs"; version="2.2-0"; sha256="13m8hm2925h1mz2wgbsxiqls5gy7sgvp0rsdcsy2sm7czjnl2z7n"; depends=[]; };
   FRCC = derive { name="FRCC"; version="1.0"; sha256="1g1rsdqsvwf7wc16dj16y6r0347j8jsv5l1pxvj1h0579zinaf2b"; depends=[CCP MASS calibrate corpcor]; };
   freeknotsplines = derive { name="freeknotsplines"; version="1.0"; sha256="19zs42q9njknirdbrbnp8bv4vr32kd8wxmkqj0a0nh06i5fcx67r"; depends=[]; };
-  FreeSortR = derive { name="FreeSortR"; version="1.0"; sha256="1zrff48abf42md6y2x2s8sd23807dx78fjgbfzzxswg3hz34g5sa"; depends=[smacof vegan ellipse]; };
+  FreeSortR = derive { name="FreeSortR"; version="1.1"; sha256="03z5wmr88gr6raa2cg7w4j6y5vgxr3g8b8axzhbd7jipswr5x1jf"; depends=[smacof vegan ellipse]; };
   freestats = derive { name="freestats"; version="0.0.3"; sha256="0b18n8idap089gkmjknzzb94dvs2drpdqs0mrw7dqnacxgbbqwfj"; depends=[MASS mvtnorm]; };
+  fRegression = derive { name="fRegression"; version="3011.81"; sha256="1qyacwwa2mjq9szwwwfdnny4np68bj1j4bvfkywl7q7x44p4n5b4"; depends=[timeDate timeSeries fBasics lmtest mgcv nnet polspline]; };
   FREQ = derive { name="FREQ"; version="1.0"; sha256="01nra30pbnqdd63pa87lcws3hnhhzybcjvx2jqyxjghn6khz47j0"; depends=[]; };
   freqMAP = derive { name="freqMAP"; version="0.2"; sha256="02hpkqqrxifrr1cxn5brp166jwa8lgl1mcgmq7s8csrbbd900ziv"; depends=[]; };
   freqparcoord = derive { name="freqparcoord"; version="1.0.0"; sha256="0hn5y10yp3j76lqrmj6dsaafamgy4pfxx1p4y92z17s79x29j59q"; depends=[ggplot2 GGally FNN mvtnorm]; };
-  freqweights = derive { name="freqweights"; version="0.1.0"; sha256="1ckhr0d21gd193lkwv4723n4q72phg93ymi00810f1h5677mghby"; depends=[plyr dplyr data_table biglm fastcluster FactoMineR]; };
+  freqweights = derive { name="freqweights"; version="1.0.1"; sha256="13wy8nzs888yn7ld96qq3p7k3xjn6s38qdlfb3nqmh52daqcnn7m"; depends=[plyr dplyr data_table biglm fastcluster FactoMineR]; };
+  FRESA_CAD = derive { name="FRESA.CAD"; version="1.0"; sha256="1i7l2rq3p2qwd186ippnxbis8dj2va6n67q61bakd3rflm0k5mn9"; depends=[Hmisc pROC stringr miscTools survival]; };
   FrF2 = derive { name="FrF2"; version="1.7-1"; sha256="0i9hfx7n0g866imdsmalqzs8v95vx08cz97hi8311v1wc3pqsn1j"; depends=[DoE_base sfsmisc BsMD scatterplot3d igraph]; };
   FrF2_catlg128 = derive { name="FrF2.catlg128"; version="1.2-1"; sha256="0i4m5zb9dazpvmnp8wh3k51bm0vykh4gncnhdg71mfk4hzrfpdac"; depends=[FrF2]; };
   frm = derive { name="frm"; version="1.2"; sha256="128ya5gx27hywkhf9mivscxsk8rgf07c0y65fh15hp1c8m6dx0nz"; depends=[]; };
···
   frontier = derive { name="frontier"; version="1.1-0"; sha256="0k2ap22qddzki63biikr1jzi5vmqz4j06d7qrf1y8axdq1q1cr44"; depends=[micEcon lmtest moments Formula miscTools]; };
   frontiles = derive { name="frontiles"; version="1.2"; sha256="08qq25wbylvhvmq34wggyj0hwdlxfs9rfs8gjqsrg50xccchniqi"; depends=[classInt colorspace rgl sp]; };
   frt = derive { name="frt"; version="0.1"; sha256="1qy76a1wkznaqzlyj1nq74mf1pnyly1s8gnff8q30zfccqk68cxv"; depends=[]; };
-  fscaret = derive { name="fscaret"; version="0.8.5.6"; sha256="060i64q65ra2npxvrd6ihzqqqv3s4xyisvgrskkyybswhqzvhxvr"; depends=[caret gsubfn]; };
-  FSelector = derive { name="FSelector"; version="0.19"; sha256="1b9jj8lqly31v393mx9dmr437sw0pk7m693ah4xnr2c9vjry6fav"; depends=[randomForest RWeka digest]; };
+  fscaret = derive { name="fscaret"; version="0.8.6.3"; sha256="0qfla027lwgyblfbl5x9i5d3i547z2g8cwpn06ly61zy1ck6j619"; depends=[caret gsubfn]; };
+  FSelector = derive { name="FSelector"; version="0.20"; sha256="0gbnm48x5myhxxw8gz7ck9sl41nj5rxq4gwifqk3l4kiqphywlpi"; depends=[randomForest RWeka digest entropy]; };
   fslr = derive { name="fslr"; version="1.1"; sha256="0m2bhmbkf4594k6l8xmqlrgv2z6pmhwm3an0ll5qvl6giy1q70vc"; depends=[stringr oro_nifti matrixStats]; };
   fso = derive { name="fso"; version="2.0-1"; sha256="02dr12bssiwn8s1aa1941hfpa4007gd65f3l4s74gs2vgjzdxf8s"; depends=[labdsv rgl]; };
-  fSRM = derive { name="fSRM"; version="0.3.5"; sha256="1dprw19ssw4v892b6iqsz5i7dmicjhgr6v1fkhnwd988nqv6h01s"; depends=[lavaan plyr reshape2]; };
+  fSRM = derive { name="fSRM"; version="0.6"; sha256="1f7kp35cy7r1z4anmab2x6h27laf001spc950qj7mi9ffal7v1r4"; depends=[lavaan plyr reshape2 ggplot2 scales foreign tcltk2 gridExtra]; };
   FTICRMS = derive { name="FTICRMS"; version="0.8"; sha256="0kv02mdmwflhqdrkhzb55si5qnqqgdadgyabqc2hwr6iccn7aq8c"; depends=[Matrix lattice]; };
   ftnonpar = derive { name="ftnonpar"; version="0.1-88"; sha256="0df9zxwjpfc939ccnm1iipwhpf76b34v0x74nsi1mm1g927dfl0i"; depends=[]; };
   fTrading = derive { name="fTrading"; version="3010.78"; sha256="0qakjxnr5nslw06ywlj65m3w7pjgn5hixxc2rnqhvvvmjpdxybz7"; depends=[timeDate timeSeries fBasics]; };
···
   ftsa = derive { name="ftsa"; version="4.0"; sha256="0phqsw3zq0bq6sdqdacyajk1xk7ns66nd3rpszl96gi7jw5m5bf8"; depends=[forecast rainbow colorspace]; };
   fueleconomy = derive { name="fueleconomy"; version="0.1"; sha256="1svy5naqfwdvmz98l80j38v06563vknajisnk596yq5rwapl71vj"; depends=[]; };
   fugeR = derive { name="fugeR"; version="0.1.2"; sha256="0kd90s91vzv0g3v9ii733h10d8y6i05lk21p5npb3csizqbdx94l"; depends=[snowfall Rcpp]; };
-  fume = derive { name="fume"; version="1.0"; sha256="0g9ygyjxsk0m3ad25h3bcgxs9g29blqn8p27s9g47kxvh4v1nq4y"; depends=[chron]; };
   fun = derive { name="fun"; version="0.1-0"; sha256="0z4nq2w1wz1clc7cf87pf870hayxq5mpzhllfgwj4mmh2xpphnrf"; depends=[]; };
   FunChisq = derive { name="FunChisq"; version="1.0"; sha256="1wrj483w6fjwwqjbymdj229nismmwaxw6v6fpba9mylqbyhs69gc"; depends=[]; };
   FunCluster = derive { name="FunCluster"; version="1.09"; sha256="0i73asn1w4s6ydf2ddn5wpr0mwbbxzgmaly1pslarzkx71wk03fz"; depends=[Hmisc cluster]; };
···
   FuncMap = derive { name="FuncMap"; version="1.0-2"; sha256="0psz2bsmq22ghgr3dijsw094b9ams15dvknigcgi5sq1invafx4a"; depends=[mvbutils]; };
   functional = derive { name="functional"; version="0.6"; sha256="120qq9apg6bf39n9vnp68db5rdhwvnj2vi12a8j8243vq8kqxdqr"; depends=[]; };
   FunctionalNetworks = derive { name="FunctionalNetworks"; version="1.0.0"; sha256="071hjgiccbrf1gxrh7niw2w1p6vgc77qvrildi59xhk53qcwzqdp"; depends=[]; };
+  funFEM = derive { name="funFEM"; version="1.0"; sha256="1jvax3ch21391f34gdd4yp8cbnrhl3sj9hny7slj2v0iq9iiz2wj"; depends=[MASS fda elasticnet]; };
+  funHDDC = derive { name="funHDDC"; version="1.0"; sha256="038m64yv27wz7ki2gcn94q011p8mv0ggmli5n27y0f5bnkfh6d6w"; depends=[fda]; };
   fUnitRoots = derive { name="fUnitRoots"; version="3010.78"; sha256="04nwwazd8jvzds6p4njzq4wpcsrvvvs0y9z8v8r402myd4856ssm"; depends=[urca timeDate timeSeries fBasics]; };
   funreg = derive { name="funreg"; version="1.1"; sha256="1sxr4mylcpbya197d55yi6d7g5pfspaf59xxbwjgmwgjw06rl76r"; depends=[MASS mgcv mvtnorm]; };
-  FusedLasso = derive { name="FusedLasso"; version="1.0.6"; sha256="1m2l7ihd55viy5a543gg2rhzkcmf5myxxbc5gqf1icrwjg6bny41"; depends=[Matrix]; };
   FusedPCA = derive { name="FusedPCA"; version="0.2"; sha256="0z4kvm6mn11fmc8w62aky2binjdcgrw4ij5vg65sb55da9s8d2kd"; depends=[genlasso]; };
   futile_any = derive { name="futile.any"; version="1.3.0"; sha256="1c7pj64kz09qzwrxvkp1w1w8mvxwq36zkj6w4b7yyi8v7x3daq2a"; depends=[lambda_r]; };
   futile_logger = derive { name="futile.logger"; version="1.3.7"; sha256="0mcca1d70a173f2c54g05fp6174z3265bc4z73k8hs16sfb3s7zf"; depends=[lambda_r futile_options]; };
···
   futile_paradigm = derive { name="futile.paradigm"; version="2.0.4"; sha256="14xsp1mgwhsawwmswqq81bv6jfz2z6ilr6pmnkx8cblyrl2nwh0v"; depends=[futile_options RUnit]; };
   fuzzyFDR = derive { name="fuzzyFDR"; version="1.0"; sha256="0zd8i9did0d9gp42xjmwrccm32glabvvy08kl8phhwb1yaq53h7w"; depends=[]; };
   fuzzyMM = derive { name="fuzzyMM"; version="1.0.1"; sha256="1pqfc9b9l2xx5pl45hfildikqjsdgqfhqzi2nbb34026nla5m8vk"; depends=[osmar frbs igraph rgeos rgdal]; };
-  FuzzyNumbers = derive { name="FuzzyNumbers"; version="0.3-3"; sha256="1vbfkr8r1n8d564ws8dqfbd49f33vd7drg3chg2vr9bxh292wsl3"; depends=[]; };
+  FuzzyNumbers = derive { name="FuzzyNumbers"; version="0.3-5"; sha256="0saqmx9vryjd8sgja54vzq3a4czg39j36zmlrnz2v612q8lcy1v2"; depends=[]; };
   fuzzyRankTests = derive { name="fuzzyRankTests"; version="0.3-5"; sha256="1g09506bbpk05a2r2wxjynjs8dmjd2q7x74d83vjscg1kdk4kazq"; depends=[]; };
   FuzzyStatProb = derive { name="FuzzyStatProb"; version="1.0"; sha256="0dkxix2blb403a72a9n13hyx31rknfxfq0cbkvvk7dvgis2w6k14"; depends=[MultinomialCI FuzzyNumbers DEoptim]; };
   FuzzyToolkitUoN = derive { name="FuzzyToolkitUoN"; version="1.0"; sha256="104s45mmlam67vwpshhpns2mgwvmhnbj8w1918jyk2r5mqibwz06"; depends=[]; };
   fwdmsa = derive { name="fwdmsa"; version="0.2"; sha256="0p0kh8am6gajfaixkvq61f12hfbm6chl9372yzn1yilhiyvqdxgp"; depends=[]; };
   FWDselect = derive { name="FWDselect"; version="1.1"; sha256="1snamrzf0cqcm6sc5vr1b0scgy83jgr5hgsf2cjb3vi3j01hz9wd"; depends=[mgcv]; };
   fwi_fbp = derive { name="fwi.fbp"; version="1.5"; sha256="08ngg70vi2fca5yblm2gf1lkjjmb6m39d8q6429n7i3jn6ca5nzf"; depends=[]; };
-  fwsim = derive { name="fwsim"; version="0.3.1"; sha256="0l9qsysi0v8q58ik0pk7jxs2m57q2n82apc0rb0d0czm7dmib6b6"; depends=[Rcpp]; };
+  fwsim = derive { name="fwsim"; version="0.3.2"; sha256="0yg3bpvf83ahy26fj1nfhfrblmr0i7i18kmnphi8w1bcqjwz6n8h"; depends=[Rcpp]; };
   fxregime = derive { name="fxregime"; version="1.0-3"; sha256="15fh8yhcba2gw2xfd0yiw5ssvbgb62l6vb28bxz71ckdyv9nsahk"; depends=[zoo strucchange car sandwich]; };
   G1DBN = derive { name="G1DBN"; version="3.1.1"; sha256="015rw3bpz32a8254janddgg1ip947qgcvmiwx5r3v7g8n854bwxn"; depends=[MASS igraph]; };
-  G2Sd = derive { name="G2Sd"; version="2.1-1"; sha256="01b7bpvnl51dms7bp076v0mbz8bk2vrlkqji9fk6nyqfpxg5zn6a"; depends=[shiny xlsx rJava xlsxjars]; };
-  GA = derive { name="GA"; version="2.1"; sha256="06adi6kdav5c9kzn4y6gq73p496y73hvcdv6nf7d0by8hx5ncyc4"; depends=[]; };
+  G2Sd = derive { name="G2Sd"; version="2.1.2"; sha256="16rivywmax264vvhfk1liid4g87k4b07y0imv4nz01rscxc7lv9h"; depends=[shiny xlsx rJava xlsxjars]; };
+  GA = derive { name="GA"; version="2.2"; sha256="1pk80jwzvpmi61df0y331qvl8jkdizblg93s7gaspkbzy50wyfkp"; depends=[foreach iterators]; };
   GA4Stratification = derive { name="GA4Stratification"; version="1.0"; sha256="0li23mrxjx72fir16j3q06fa32cicck4pfc30n0dy2lysf81m9gs"; depends=[]; };
   GABi = derive { name="GABi"; version="0.1"; sha256="1zmiaqbd1jrpiz9hk16s8rggcpl3xyyhjkkdliymx2p42vy5b5mf"; depends=[hash]; };
   GAD = derive { name="GAD"; version="1.1.1"; sha256="0lyrw0d7i7yn1wkqlbf3rg3dnijfwsjn3kdbsg19hmvwq6qpsak2"; depends=[matrixStats R_methodsS3]; };
···
   GAMBoost = derive { name="GAMBoost"; version="1.2-3"; sha256="0450h9zf12r524lxk1lrv9imvvkk6fmyd3chnxp18nnvys7215pv"; depends=[Matrix]; };
   gamboostLSS = derive { name="gamboostLSS"; version="1.1-2"; sha256="1my718gp5wnzrpy50r9cjcjy4kbxvy0q1867n21dll6rhbxz0yil"; depends=[mboost]; };
   gamboostMSM = derive { name="gamboostMSM"; version="1.1.5"; sha256="1n6ngbxx9f3p98jfiq4x21y0rqmhy18zyv13y8mkrz7hrchh835f"; depends=[mboost]; };
-  gamclass = derive { name="gamclass"; version="0.52"; sha256="0ypdsjmzj5vj6z5iimx1xva6pqh75s1dlaar2hkyn8zx08d0q2kh"; depends=[car mgcv DAAG MASS rpart randomForest lattice latticeExtra ape KernSmooth]; };
+  gamclass = derive { name="gamclass"; version="0.55"; sha256="0nhy1qdc221hsnby8j0m2a4x4a8qwfixbaq4gd22rn1xpbsdnfw3"; depends=[car mgcv DAAG MASS rpart randomForest lattice latticeExtra ape KernSmooth]; };
   games = derive { name="games"; version="1.1-1"; sha256="05x27vivz2acp7darja0x21l29ddlav6ch6l89a9s60v52zqflik"; depends=[maxLik Formula MASS stringr]; };
-  gamlr = derive { name="gamlr"; version="1.11-3"; sha256="01mwgmmyp132d792darjrfbcihw04sy3fyw2xchshjqry616j82i"; depends=[Matrix]; };
-  gamlss = derive { name="gamlss"; version="4.3-0"; sha256="0hsywaf3ng7c8b7xcq16q1cnld7g224gwdkf7s07zlfv23v6kxs8"; depends=[gamlss_data gamlss_dist nlme MASS survival]; };
+  gamlr = derive { name="gamlr"; version="1.12-1"; sha256="17vfb3kac5y3xfw8s1m8czm5bq5z6x6lc43f2szj5lv84mf2r6y7"; depends=[Matrix]; };
+  gamlss = derive { name="gamlss"; version="4.3-1"; sha256="1yhg76shxaz78pmyadhh0kf710gaf9mz58hi832mpzd0hd2635y7"; depends=[gamlss_data gamlss_dist nlme MASS survival]; };
   gamlss_add = derive { name="gamlss.add"; version="4.3-0"; sha256="0kafvrh5b60pd7vs7swd6xq9c2py6ixjrdnhq2y4w112fp86jnbp"; depends=[gamlss mgcv nnet rpart]; };
   gamlss_cens = derive { name="gamlss.cens"; version="4.2.7"; sha256="1dy8myravipsa3cmkdwy3m46s419fhck0f0yz1kf6qlvxxr7a4m4"; depends=[gamlss gamlss_dist survival]; };
   gamlss_data = derive { name="gamlss.data"; version="4.2-7"; sha256="0g3fmqrwxmj14r0p0ai1adq6cs3bd3ys47gjcja035xjiajg6cs2"; depends=[]; };
   gamlss_demo = derive { name="gamlss.demo"; version="4.2-7"; sha256="1mlfkm290dk8fvfahmrr7adhw0bj4923zjs2xn0fvbj739rgv6b7"; depends=[rpanel gamlss gamlss_tr gamlss_util]; };
-  gamlss_dist = derive { name="gamlss.dist"; version="4.3-0"; sha256="1cnv7f7qwaw4fhaciw3s7xgyqa9h6v12frix6arb9nkciknb8hv5"; depends=[MASS]; };
+  gamlss_dist = derive { name="gamlss.dist"; version="4.3-1"; sha256="0598sg1dq5xx6a2pdlp87xmkfjfnk6prahnqlpn8yp3jmjm9ws47"; depends=[MASS]; };
   gamlss_mx = derive { name="gamlss.mx"; version="4.2-7"; sha256="0k1isn2mavmwm15jk4gp9r3ks6z9pwd7k3xdsc29b9p8v8iapj4q"; depends=[gamlss nnet MASS]; };
   gamlss_nl = derive { name="gamlss.nl"; version="4.1-0"; sha256="083l5lsb0csxcp4vffvdv2nr7jk3s2gkcavx66m8inzw16j7xilz"; depends=[gamlss survival]; };
   gamlss_spatial = derive { name="gamlss.spatial"; version="0.1"; sha256="0lsq3lfv9gxjvnbnib551sfvcn6g9amwg51q5ipwwzh12hdl0m98"; depends=[gamlss spam mgcv]; };
···
   gamlss_util = derive { name="gamlss.util"; version="4.2-7"; sha256="1c8xc0qf387cd9d6k9fzlwvj9735y7v6njsb5fls2fimpnd5vsik"; depends=[gamlss colorspace Matrix MASS rgenoud zoo gamlss_add spam]; };
   gamm4 = derive { name="gamm4"; version="0.2-3"; sha256="19vy5wik9nh77cm25gp3j3j8w8vinwzx5pv90nzdzvx84yvvf0y3"; depends=[Matrix lme4 mgcv]; };
   Gammareg = derive { name="Gammareg"; version="1.0"; sha256="1a5wibnbd8jg0v8577n1x9kc358qpd4jz7l8h7r541sdpprm6wb0"; depends=[]; };
-  gammSlice = derive { name="gammSlice"; version="1.2-6"; sha256="19443rfpk9ivv42zy5vdfhs4pcrbcn4d984xnchfbznmddilavg8"; depends=[KernSmooth lattice mgcv]; };
   GANPA = derive { name="GANPA"; version="1.0"; sha256="0ia8djv46jm397nxjrm9yc5gacf1r4z0ckiliz57cbrqwh7z2wpa"; depends=[GANPAdata]; };
   GANPAdata = derive { name="GANPAdata"; version="1.0"; sha256="0mhdadl7zgsacn59ym42magg3214k1xhabwn78fv7kgccszcgc86"; depends=[]; };
   gaoptim = derive { name="gaoptim"; version="1.1"; sha256="04igpn73k6f6652y496igwypfxmz4igg4jgxx6swqyi37182rqhm"; depends=[]; };
-  gap = derive { name="gap"; version="1.1-10"; sha256="02as90x8r93mynwpa1dirp0lplc7i27ya3q7fq6zbq2xn16j4vj5"; depends=[]; };
+  gap = derive { name="gap"; version="1.1-12"; sha256="1760jwfrlfmb8crk8kba0swpazcznlv80c6j8fiyd9zxjhnq7zf5"; depends=[]; };
+  gapmap = derive { name="gapmap"; version="0.0.2"; sha256="0xykpy3cmbiwwa3s8f4777585r7l441qb9ks6ajym01scqcj3nwl"; depends=[ggplot2 reshape2]; };
   gaussDiff = derive { name="gaussDiff"; version="1.1"; sha256="0fqjdxp2ibbami75ba16d02dz4rz5sk8mni45di9anydx44g9d45"; depends=[]; };
   gaussquad = derive { name="gaussquad"; version="1.0-2"; sha256="0bcvkssmwwngcd4cnv924n9h3c8z1w3x9c9bkwn5jbz9zyv1lfms"; depends=[polynom orthopolynom]; };
   gb = derive { name="gb"; version="1.1.8-8"; sha256="18n9wqz82mjxjgzk8vc68kyz3b6lk21d2f16551d6fikjla03adf"; depends=[boot]; };
···
   gbRd = derive { name="gbRd"; version="0.4-11"; sha256="06x97rw5i6v6cgjxkfhxnw4dn7lghn5q6ra7ri5ag1x9dkfzcl82"; depends=[]; };
   gbs = derive { name="gbs"; version="1.0"; sha256="19zcsvd258ibrj356zlwgryjqylcs56agg3z6d44xbnf8prg05ig"; depends=[nlme]; };
   GCAI_bias = derive { name="GCAI.bias"; version="1.0"; sha256="10092mwpmfbcga0n39a0i6g8xxch8xiwg15cckipw6yxjyx0sivc"; depends=[]; };
+  gCat = derive { name="gCat"; version="0.1"; sha256="10990ilsjk52kqkcdngj4nq0kcbn4w1syxl1mqjq2n5g1l002yjy"; depends=[]; };
   gcbd = derive { name="gcbd"; version="0.2.5"; sha256="0fkg6vk0jkl6680n1hljyv783j4hd84mql0k4pfblvqafwv4nhm3"; depends=[RSQLite plyr reshape lattice]; };
   GCD = derive { name="GCD"; version="3.0.4"; sha256="1mrgscbrljfyzxprclyw9rcwlkcnifm15kkkapkv56c5ms2ic2i5"; depends=[sp raster ggplot2]; };
   gcdnet = derive { name="gcdnet"; version="1.0.4"; sha256="0fmy0li06rahch4ir0xa81yilvrd0zqyhmpl4hfxjahhl3npw370"; depends=[Matrix]; };
···
   gdalUtils = derive { name="gdalUtils"; version="0.3.1"; sha256="1a6sg3x5yfffa9xrkvc98i2hm3lvna4jw7p89gn2bf74kzphqpmy"; depends=[sp foreach R_utils]; };
   gdata = derive { name="gdata"; version="2.13.3"; sha256="05k5l4gz0381z89sp64xhngcsykazzznwmankwsnimx5alwrfk2m"; depends=[gtools]; };
   g_data = derive { name="g.data"; version="2.4"; sha256="14a4m0v38p3j1k1kymkxwydlgm8b73hlx9m80sg1l4aj38fvflzl"; depends=[]; };
-  GDAtools = derive { name="GDAtools"; version="1.1"; sha256="0r1d98wavzwg3icr3czfzmcf1d86nwzq2s6avqkh4h0sank220wn"; depends=[FactoMineR]; };
+  GDAtools = derive { name="GDAtools"; version="1.3"; sha256="1av29mllix0az4n85vxh1344j6jmy103hd78ibjwxalm620rp7ns"; depends=[FactoMineR]; };
   GDELTtools = derive { name="GDELTtools"; version="1.2"; sha256="1rx6kjh7kmyycqapvbizcxkcfp09qvqv7k8f25v333sxkacpz6p5"; depends=[plyr TimeWarp]; };
   gdimap = derive { name="gdimap"; version="0.1-6"; sha256="0bz7h8wxkwp8yb2qzfj1932m4b28rxlhr8939cqbzfma0zb2ywzx"; depends=[rgl oro_nifti movMF gridExtra colorspace geometry gsl abind]; };
   gdistance = derive { name="gdistance"; version="1.1-5"; sha256="12877mg0ih346h62xa087xwbrqrjvdh0fs8avrvyy4qpqls2s7qn"; depends=[raster igraph Matrix sp]; };
+  gdsfmt = derive { name="gdsfmt"; version="1.1.0.1"; sha256="051b0d8i5g3w0i1r95md0334vj1qrclf9n5zzw20fqjbias1z3rs"; depends=[]; };
   gee = derive { name="gee"; version="4.13-18"; sha256="0zfxmjajbgr7999gbnqppq43zzk901kqra7b1d5fa2qn8js6h1ng"; depends=[]; };
   geeM = derive { name="geeM"; version="0.7.1"; sha256="0pzvy0ga17g5v5dd2q4q7fmcwj3nws0p1cg5s0dz3azmrj7n4s31"; depends=[Matrix]; };
-  geepack = derive { name="geepack"; version="1.1-6"; sha256="0ixwrr2jjrqzh23zg9cibayinjxzgdpia9znsv7qwhc7hx23a2zm"; depends=[]; };
-  geigen = derive { name="geigen"; version="1.3"; sha256="16zz3k4j75hn1dkzydsxnk0jblka22fbww7ak9lgg1znkfws6dhk"; depends=[]; };
+  geepack = derive { name="geepack"; version="1.2-0"; sha256="1pxh9nsyj9a40znm4zza4nbi3dkhb96s3azi43p9ivvfj3l21m74"; depends=[]; };
+  geigen = derive { name="geigen"; version="1.4"; sha256="0k7h3farw9a3sxh0q4gilwqlgz1gqr4al6jbr70j2y5p6sbkvabd"; depends=[]; };
   geiger = derive { name="geiger"; version="2.0.3"; sha256="1wqihvscmq44i34205fzv79wk7j2a72qd8y6ycgrv74plql0316c"; depends=[ape MASS mvtnorm subplex deSolve digest Rcpp coda]; };
   gems = derive { name="gems"; version="0.9.5"; sha256="15n3xfhifcxmhsmc2p4ijgfd9l1pmzqj0zmh0xxi8y10ax68f524"; depends=[MASS msm mstate plyr data_table]; };
   gemtc = derive { name="gemtc"; version="0.6"; sha256="03aw5r62577fizvbl7wpl7k3m8bxji21h8a41gl8yr4fpj0353yj"; depends=[coda igraph meta XML]; };
···
   genasis = derive { name="genasis"; version="1.0"; sha256="1r0733cc2hss3f8dp19s1ji55yp72mds7p3x1zvvpiks2r7w712p"; depends=[Kendall fitdistrplus]; };
   GenBinomApps = derive { name="GenBinomApps"; version="1.0-2"; sha256="1ps1rq8cjlwh658mysdh3xbn5fihanzcwxb38xvg4031vnwv80in"; depends=[]; };
   gendata = derive { name="gendata"; version="1.0"; sha256="1hyyf9kpf8f0xxwwvirxlz6nw6wf2wqq5vvjnyikq5dwa7a3ngmw"; depends=[]; };
+  gender = derive { name="gender"; version="0.4.1"; sha256="1k14vdk8n4n1xsvjb4p8wk2wbb7qkfx06c230q5fb1bzf8grlxi2"; depends=[devtools dplyr httr jsonlite]; };
   GENEAread = derive { name="GENEAread"; version="1.1.1"; sha256="0c3d76yl8dqclk8zhhgrd6bv6b599vkpbyg3hjspb6npdw6zs6k8"; depends=[bitops]; };
   GeneCycle = derive { name="GeneCycle"; version="1.1.2"; sha256="1ghdzdddbv6cnxqd08amy4c4s5jsxa637r828ygffk6z76xjr6b6"; depends=[MASS longitudinal fdrtool]; };
   GeneF = derive { name="GeneF"; version="1.0"; sha256="0bizf47944b2zv9ayxb9rhrqx0ilz2xlvkw7x5vbg7l67y2g2l4d"; depends=[]; };
···
   genetics = derive { name="genetics"; version="1.3.8.1"; sha256="0gfbrpz0zp5bgw3s21wrhjfy70laif47wcrjrm6mjgs6xapiw790"; depends=[combinat gdata gtools MASS mvtnorm]; };
   GeneticTools = derive { name="GeneticTools"; version="0.3"; sha256="16jqi98nvdmfbmx6z10d2kxfc9mp4zhpg22rschiy6ysp4lczs3c"; depends=[gMWT Rcpp RcppArmadillo plotrix]; };
   GenKern = derive { name="GenKern"; version="1.2-60"; sha256="12qmd9ydizl7h178ndn25i4xscjnrssl5k7bifwv94m0wrgj4x6c"; depends=[KernSmooth]; };
-  genlasso = derive { name="genlasso"; version="1.2"; sha256="0ahkml10nvx1sfikl0ai3yfs5gzps7ss9aymsg1wy494p95riwz5"; depends=[MASS Matrix igraph]; };
+  genlasso = derive { name="genlasso"; version="1.3"; sha256="1q4ybg8xzphnqwywwdb7i2q94dlxwpggvisjqqdj39jh2cabda57"; depends=[MASS Matrix igraph]; };
+  GENLIB = derive { name="GENLIB"; version="1.0.1"; sha256="1vgm920bwb194mn78xp471hiln4iy430jfa8mxwx976bbcxkgpkh"; depends=[Rcpp kinship2 bootstrap Matrix lattice quadprog foreach doParallel]; };
   genMOSS = derive { name="genMOSS"; version="1.1"; sha256="08d6j0iwfah1ianqdr884hh6bg04vfk4kml3clmf7vzx8wfmliy5"; depends=[]; };
   genMOSSplus = derive { name="genMOSSplus"; version="1.0"; sha256="1n3ngx1piy3l14k5k95wrgvrjw9238jkygfqanl3xg2na2mmkr26"; depends=[]; };
   genomicper = derive { name="genomicper"; version="1.3"; sha256="0fpvf286x0rf2mg9x82668kg5fx90arz5vf3731qinmdnnvrpziv"; depends=[]; };
···
   GenSA = derive { name="GenSA"; version="1.1.4"; sha256="0ph3n0hv7p8i03by42hl0f2b1kmhpvyvd7rfgay2wl9lknfsq0vv"; depends=[]; };
   gensemble = derive { name="gensemble"; version="1.0"; sha256="0yyi7djzqx4yhxp6yy1rjgvzidjlna79ds89bgj6m6zj3aav6yw2"; depends=[]; };
   genSurv = derive { name="genSurv"; version="1.0.2"; sha256="0hvkrlcl8jrj0x0ixrl34484p9kxlwxfaa64ynz6jf3dcyghp9l0"; depends=[]; };
+  geoBayes = derive { name="geoBayes"; version="0.1.3"; sha256="0i5yxdgcbikq9b69f9z7080mcrff7phzij25q9jsd63rlld1nz77"; depends=[coda sp]; };
   geoCount = derive { name="geoCount"; version="1.131209"; sha256="0v9nsqhwf58czq4vh9f2yim2r7w9sfx9g9hp4jdbfy4q7jc5m02a"; depends=[Rcpp RcppArmadillo]; };
   GeoDE = derive { name="GeoDE"; version="1.0"; sha256="0wawkzj0344pprm8g884d7by8v74iw96b109rgm7anal48fl30im"; depends=[Matrix MASS]; };
   GeoGenetix = derive { name="GeoGenetix"; version="0.0.2"; sha256="0rrc8rdf6whpd830s2g9ybz82jcd0il9kkfrjh3xza3b86fasdvg"; depends=[RandomFields]; };
···
   geomapdata = derive { name="geomapdata"; version="1.0-4"; sha256="1g89msnav87kim32xxbayqcx1v4439x4fsmc8xhlvq4jwlhd5xxw"; depends=[]; };
   geometry = derive { name="geometry"; version="0.3-4"; sha256="1rplvy7528v270c4pdxxb34h7mfdd6141dnb9aw59xc0sd9cx0lv"; depends=[magic]; };
   geomorph = derive { name="geomorph"; version="2.1.1"; sha256="12w5d7m6kg1pl42g21zfgk9by77wak82z8k0xh4zlbwiy8zv30z6"; depends=[rgl jpeg vegan ape geiger phytools]; };
-  geonames = derive { name="geonames"; version="0.996"; sha256="14fgwhg8c7aagrp1c1yc80hjr06z8ldr85v27gn1nnikvz71idgy"; depends=[rjson]; };
+  geonames = derive { name="geonames"; version="0.997"; sha256="1lywi5fxbw9ky3rf3q72iknl9as86c8d5dkrqwzhxn5nbxiwbpsc"; depends=[rjson]; };
   geophys = derive { name="geophys"; version="1.3-6"; sha256="1yfhilgc2nv5jfp0n7iah0wl041an2850c2qnzrvx0vv9fywgw9g"; depends=[RPMG RSEIS RFOC GEOmap cluster]; };
-  geoR = derive { name="geoR"; version="1.7-4"; sha256="00868h4rvw923n2b7v191rcr10vyyljxzg3dl7hgc7al1c98gjwq"; depends=[sp MASS splancs RandomFields]; };
+  geoR = derive { name="geoR"; version="1.7-4.1"; sha256="19mafynvnpabwm5i6m4ax6d9rrh3fgyg9sslb552v6ry9nfq31h0"; depends=[sp MASS splancs RandomFields]; };
   geoRglm = derive { name="geoRglm"; version="0.9-4"; sha256="1wzq8p4xi40j4cagg7ji8qz9kynrwlyrlcvv0358pbl19nvg7hxb"; depends=[geoR]; };
-  georob = derive { name="georob"; version="0.1-4"; sha256="0a68r63adya3syf8fc1ha90x8587r2hp5w44na4gvnr9rs883f1i"; depends=[sp constrainedKriging lmtest nlme nleqslv quantreg RandomFields robustbase]; };
+  georob = derive { name="georob"; version="0.1-5"; sha256="0awcqcpv82pn2z7lgir73pg2b0whvrrfy55gi0jrjn7lzyakhqaq"; depends=[sp constrainedKriging lmtest nlme nleqslv quantreg RandomFields robustbase snowfall]; };
   geoscale = derive { name="geoscale"; version="1.1"; sha256="1xmn8y33jz1f16sjbzrld20gy7w54awrr79lhs9s4r8k1gmn0zqg"; depends=[]; };
   geospacom = derive { name="geospacom"; version="0.5-7"; sha256="00yi2wwnjh2z8xhzfbp1jhh5fhq2z885s0gv937xsin4a63m76fd"; depends=[rgeos classInt sp maptools geosphere]; };
-  geosphere = derive { name="geosphere"; version="1.3-8"; sha256="1ldg3lrz9plhr5b1dgnc2nj5srpv23xxma83kcd7aicll4x1jmbw"; depends=[sp]; };
-  geospt = derive { name="geospt"; version="0.5-0"; sha256="0bpflmj1kx2fph5b9dfy57bxdqjhpwnn8050k8afky5fmiwzm708"; depends=[geoR gstat genalg limSolve MASS plyr TeachingDemos gsl]; };
-  geostatsp = derive { name="geostatsp"; version="0.9.999"; sha256="0qrcfgyv4g6vmz3623mlh2ad31hw6k82xjlsmcgab3d4mzk0q7qx"; depends=[Matrix raster sp]; };
+  geosphere = derive { name="geosphere"; version="1.3-11"; sha256="0gsbzbx7x4ly7dfh8ld3fa795ysf4sl8a1jg3jc12nrrx85cwl74"; depends=[sp]; };
+  geospt = derive { name="geospt"; version="1.0-0"; sha256="11gs2g7gxrzzridlhgbvpgjv55zfxy7y3d24dr3zf9ssa2z8v4v2"; depends=[gstat genalg MASS sp nloptr fields gsl plyr TeachingDemos sgeostat]; };
+  geostatsp = derive { name="geostatsp"; version="1.1.0"; sha256="05w4wz4l5624c260sl6in4a2pp7bbwp1whmhr3nnrjb4ynnx5541"; depends=[Matrix raster sp abind numDeriv pracma]; };
   geotools = derive { name="geotools"; version="0.1"; sha256="0d0vf9dvrrv68ivssp58qzaj8vra26ms33my097jmzmgagwy1spd"; depends=[]; };
   geotopbricks = derive { name="geotopbricks"; version="1.3.5.4"; sha256="065h5dd7qxjydblgkgj2amz8krscgf7ds61b923w3b4biin4s4q4"; depends=[raster stringr zoo]; };
   GeoXp = derive { name="GeoXp"; version="1.6.2"; sha256="18wdmdwb79ipdjdii068dz9f55b5ldxn95g5q6jcxsqwp0wldvw8"; depends=[quantreg rgl spdep KernSmooth rgeos robustbase splancs]; };
   geozoo = derive { name="geozoo"; version="0.4.3"; sha256="0nmmmyk0ih5aqpsn7ip4dhgfm7jhcnca8pigyr9794b110icq1rv"; depends=[bitops]; };
   GESTr = derive { name="GESTr"; version="0.1"; sha256="1q12l2vcq6bcyybnknrmfbm6rpzcmxgq2vyj33xwhkmm9g2ii9k6"; depends=[mclust gtools]; };
   getopt = derive { name="getopt"; version="1.20.0"; sha256="00f57vgnzmg7cz80rjmjz1556xqcmx8nhrlbbhaq4w7gl2ibl87r"; depends=[]; };
-  GetoptLong = derive { name="GetoptLong"; version="0.0.5"; sha256="1aygm6h4mqac6h4scss3c2p3snyl2lmd8lnw034rakz2azj8j0by"; depends=[rjson]; };
+  GetoptLong = derive { name="GetoptLong"; version="0.0.7"; sha256="0953y3w42yl0hkb7k9b6pskjpjfwdvnxrcbscijcnvsp3c5j0d1k"; depends=[rjson GlobalOptions]; };
   GetR = derive { name="GetR"; version="0.1"; sha256="1b2wirhz4nhvmf863czwb8z8b42ilsyjjrg9rc4nd9b7nz50bmjg"; depends=[party]; };
+  gets = derive { name="gets"; version="0.1"; sha256="1dibbbg02hrdh062br51f51576jwd01dn1y4vg2hwcah6pg9hh2s"; depends=[zoo lgarch]; };
   gettingtothebottom = derive { name="gettingtothebottom"; version="3.0"; sha256="0n3d8xx4pwh4bps6jkfj4g8mpknj0lsfk03bayhvil744r5jnrn7"; depends=[ggplot2 Matrix lpSolve reshape2]; };
   GEVcdn = derive { name="GEVcdn"; version="1.1.3"; sha256="13p6hkdybs8s2i363z2a65yijqarwj9swvy22ljk61shf2nzbk80"; depends=[VGAM]; };
   GEVStableGarch = derive { name="GEVStableGarch"; version="1.0"; sha256="007s7lbfpp1bqnyg08rwarsmkxlx16p4is1k3736fmnri9sfp7z6"; depends=[fGarch fExtremes stabledist skewt Rsolnp]; };
   GExMap = derive { name="GExMap"; version="1.1.3"; sha256="1a6i2z9ndgia4v96nkr77cjqnbgxigqbqlibg82gwa0a6pl7r7nz"; depends=[]; };
-  gfcanalysis = derive { name="gfcanalysis"; version="1.1"; sha256="1z29y6gx0b9b9h6939vb9pqplcjhi0xb5l3bgjybjad01p2dnqas"; depends=[raster rgdal geosphere RCurl rgeos plyr ggplot2 sp stringr animation rasterVis]; };
-  GGally = derive { name="GGally"; version="0.4.7"; sha256="1wbpl47ha6q6si4xyfx0i019wagn2ka1zyfhblvjcj9hhcvzz6m9"; depends=[ggplot2 gtable plyr reshape stringr]; };
-  ggdendro = derive { name="ggdendro"; version="0.1-14"; sha256="0x6bl0v2lkiybc5pdrcak5cslhaw7cxhh6imsrvdhcrzdr4cc45s"; depends=[MASS ggplot2]; };
+  gfcanalysis = derive { name="gfcanalysis"; version="1.2"; sha256="147vgv4z14xn0j94g7z0y099gz8xj2yb02r6j3mfi4412dg5f5fp"; depends=[raster rgdal geosphere RCurl rgeos plyr ggplot2 sp stringr animation rasterVis]; };
+  GGally = derive { name="GGally"; version="0.4.8"; sha256="0wc91c4d8m2335rp0x6i193hw538fnwhbplq3lv0maljwsj8s2pn"; depends=[ggplot2 gtable plyr reshape stringr]; };
+  ggdendro = derive { name="ggdendro"; version="0.1-15"; sha256="1xa1pswkf7xnrxs1zqw71ws0r6r0nmc2gnc76bd372czfdn4npci"; depends=[MASS ggplot2]; };
   GGEBiplotGUI = derive { name="GGEBiplotGUI"; version="1.0-8"; sha256="0bkagsm9mkcghc2q46cc86kjajzgjbq9588v0v2bp71qw8m97mbh"; depends=[rgl tkrplot]; };
   ggHorizon = derive { name="ggHorizon"; version="0.1"; sha256="0k617qnfqdl9w2hdwppkrgl51krnwpdf0gahzvivcwzynbmywc37"; depends=[ggplot2 plyr RColorBrewer proto]; };
-  GGIR = derive { name="GGIR"; version="1.0-4"; sha256="09fqw4al4bn87h9543ais634crk9mzvfzdgp25gwy7lhpwzdl2y0"; depends=[GENEAread matlab]; };
-  gglasso = derive { name="gglasso"; version="1.2"; sha256="0bn56axyr741qdj5pxzbwaqjb7mp727ph67ng5d6ibsz1z2bh7pk"; depends=[]; };
+  GGIR = derive { name="GGIR"; version="1.1-3"; sha256="0kwx09hycqzbbmixnznbk58cg7a3y6c963205axi6vvqcpi0pdck"; depends=[]; };
+  gglasso = derive { name="gglasso"; version="1.3"; sha256="0qqp5zak4xsakhydn9cfhpb19n6yidgqj183il1v7yi90qjfyn66"; depends=[]; };
   ggm = derive { name="ggm"; version="2.1"; sha256="1m2p5cn7lfy4757rspp3d3jnphjp5vh3lvrim1lxlda577kpdmnf"; depends=[igraph]; };
   ggmap = derive { name="ggmap"; version="2.3"; sha256="0sl3jkifba3q0khl5sg2nf08kgn1pirw5a1xag07za51sqda5b5q"; depends=[ggplot2 proto scales RgoogleMaps png plyr reshape2 rjson mapproj]; };
   ggmcmc = derive { name="ggmcmc"; version="0.5.1"; sha256="17pmb2kfrjc2s538my8finr029vy1npzk44626xvznf6bf6bv895"; depends=[plyr reshape2 ggplot2]; };
-  GGMselect = derive { name="GGMselect"; version="0.1-8"; sha256="1chmyzbn85c5z5b8lvgqpr7knwg25dm7qbb4nhivcdr6ipd1dqr0"; depends=[mvtnorm lars gtools]; };
+  GGMselect = derive { name="GGMselect"; version="0.1-9"; sha256="18l98v6hv0sjhany275lsbdjwclx3abqfi924n9qlcnap1rvsfwz"; depends=[mvtnorm lars gtools]; };
   ggparallel = derive { name="ggparallel"; version="0.1.1"; sha256="1z8w4bm4ahmmwbr87qlqhm8jlrqf7dhdvm1cf0xrwjlkmy6dqjvg"; depends=[ggplot2 reshape2 plyr]; };
   ggplot2 = derive { name="ggplot2"; version="1.0.0"; sha256="138rxp8zr0x945ajmhg35x35xs0ci743iqhffqy90c7hcn0gpvz6"; depends=[plyr digest gtable reshape2 scales proto MASS]; };
+  ggRandomForests = derive { name="ggRandomForests"; version="1.0.0"; sha256="173k0l8grsl3lvvhiflj98fqy1rdh9yiq14c81irm39dxai801xn"; depends=[ggplot2 randomForestSRC reshape2 survival dplyr]; };
   ggROC = derive { name="ggROC"; version="1.0"; sha256="0p9gdy7ia59d5m84z9flz5b03ri7nbigb3fav2v2wrml300d24vn"; depends=[ggplot2]; };
   ggsubplot = derive { name="ggsubplot"; version="0.3.2"; sha256="1rrq47rf95hnwz8c33sbnpvc37sb6v2w37863hyjl6gc0bhyrvzb"; depends=[ggplot2 plyr proto scales stringr]; };
   ggtern = derive { name="ggtern"; version="1.0.3.2"; sha256="05nh8610l5lw41wkidl2m78nqyfbc7faiawpc442lin3qxrj64bq"; depends=[ggplot2 plyr gtable scales reshape2 proto MASS sp]; };
   ggthemes = derive { name="ggthemes"; version="1.7.0"; sha256="1wfqh3mq4hyyfgvw99bq1s8qxvl3qasa8qcikfhbp2ky898w5npb"; depends=[ggplot2 colorspace proto scales]; };
-  ggvis = derive { name="ggvis"; version="0.3.0.1"; sha256="0fx39j7vg9r4a7ni9nnq7x7s93lfzbbsg4zsbb6x429hyawvcj8x"; depends=[assertthat RJSONIO shiny magrittr dplyr htmltools]; };
+  ggvis = derive { name="ggvis"; version="0.4"; sha256="09q7ccg5lsj0qqixpiq4xccpqckr7g4ws7ysr5mac3sgl8hm9r87"; depends=[assertthat jsonlite shiny magrittr dplyr lazyeval htmltools]; };
   GhcnDaily = derive { name="GhcnDaily"; version="1.5"; sha256="1gln1giid5n5b9mxidh90l8ahvcgx968zak2lxr2f9c32pnrpmnp"; depends=[R_utils R_oo R_methodsS3 abind ncdf]; };
   GHQp = derive { name="GHQp"; version="1.0"; sha256="0qpcpwv7rz67qhz1p5k2im02jvs7l8z9sa6ypz13hig5fzm8j9bp"; depends=[statmod]; };
   ghyp = derive { name="ghyp"; version="1.5.6"; sha256="0y3915jxb2rf01f7r6111p88ijhmzyz4qsmy7vfijlilkz0ynn20"; depends=[numDeriv gplots]; };
···
   GillespieSSA = derive { name="GillespieSSA"; version="0.5-4"; sha256="0bs16g8vm9yrv74g94lj8fdfmf1rjj0f04lcnaya7gyak3jhk36q"; depends=[]; };
   gIPFrm = derive { name="gIPFrm"; version="2.0"; sha256="1syjsnna7b7y27yf7zsxjwq8z5f4wxf2hfadhgjaw898gvfcnrbc"; depends=[]; };
   giRaph = derive { name="giRaph"; version="0.1.2"; sha256="137c39fz4vz37lpws3nqhrsf4qsyf2l0mr1ml3rq49zz4146i0rz"; depends=[]; };
-  GISTools = derive { name="GISTools"; version="0.7-2"; sha256="1n1zzi25xx320gwmsn5rj8c3m1wqwmjbzf32krdzmaqiwvhf7c1b"; depends=[maptools RColorBrewer MASS rgeos]; };
+  GISTools = derive { name="GISTools"; version="0.7-4"; sha256="06alb5d2k4qj344i9cpgm3lz9m68rkmjqfx5k2hzn7z458xjrlxs"; depends=[maptools sp RColorBrewer MASS rgeos]; };
   gitter = derive { name="gitter"; version="1.0.4"; sha256="1pvl8k8mb15mcfz1074y246s9basmi5vbpw2n1ca0d8wm5wdidap"; depends=[jpeg tiff logging PET ggplot2]; };
   Giza = derive { name="Giza"; version="1.0"; sha256="13nkm8mk1v7s85kmp6psvnr1v97vi0gid8rsqyq3x6046pyl5z6v"; depends=[reshape lattice lattice]; };
-  glarma = derive { name="glarma"; version="1.2-0"; sha256="1zci132hz11y8j2jvakzqsxddihqr88y09bd7fx5xzipm7iaa7yq"; depends=[MASS]; };
+  glarma = derive { name="glarma"; version="1.3-0"; sha256="0r8c6c6q3jd2nv83jfws2skfji4zp9ia134k6wd4f535j7jqv2kw"; depends=[MASS]; };
   glasso = derive { name="glasso"; version="1.8"; sha256="0gcapw7kyxb19wvdyxq1vsmc5j7yyd0rvqxs2i71k31q352sg6zw"; depends=[]; };
   glassomix = derive { name="glassomix"; version="1.2"; sha256="13a2ly0by58z8djq8nbakpyacgb6nkdsqxjq44yw4v2fy3s22z3n"; depends=[mvtnorm glasso huge]; };
-  glcm = derive { name="glcm"; version="0.3.2"; sha256="1kipm2z1q47ban6yah6hxkaa9fvkw990hn9c02bywf80wg16770n"; depends=[Rcpp]; };
+  glcm = derive { name="glcm"; version="1.0"; sha256="0i1i4dwswy0pi6fj78qffgk90pcrpzbr2dn87siq52kl7i66c2ny"; depends=[Rcpp]; };
   gld = derive { name="gld"; version="2.2.1"; sha256="1x9xlqj87xmk90hn20k1yvnvyndxdbi67yrxrfdhr3lhxabq5msw"; depends=[]; };
   GLDEX = derive { name="GLDEX"; version="2.0.0.0"; sha256="0pskh9wa32im6wrjkqkxczfsds71mx2435yhn7vrna4vzyc2xdvb"; depends=[cluster]; };
   gldist = derive { name="gldist"; version="2160.2"; sha256="1dcf3pb4xqvhqj4m3xc3ihzjbzxjspjrnc8819hmlnmdd0csghmx"; depends=[]; };
···
   glmlep = derive { name="glmlep"; version="0.1"; sha256="0jnm3cf2r9fyncxzpk87g4pnxbryqcxxrc5y2a80pv48al3sxlzk"; depends=[]; };
   glmmBUGS = derive { name="glmmBUGS"; version="2.3"; sha256="1j96c1c2lqplhjvyigpj494yxj85bpmc7cnd1hl1rc8b552jr192"; depends=[MASS abind]; };
   glmmGS = derive { name="glmmGS"; version="0.5-1"; sha256="1aqyxw3nrjri8k8wlwvddy25dj7mjqndssd5p5arax8vaqgrdnjz"; depends=[]; };
-  glmmLasso = derive { name="glmmLasso"; version="1.3.1"; sha256="07i5bnaj3is8ag8gqzpma4kzfk33f11k9r30cdwzx8sp2xfh16gr"; depends=[minqa]; };
+  glmmLasso = derive { name="glmmLasso"; version="1.3.3"; sha256="122dl5l4ngl9xvyz1kr58hryyxmld0zpwp5437ckwbnkf9bv1ldk"; depends=[minqa]; };
   glmmML = derive { name="glmmML"; version="1.0"; sha256="0b1q5mj325xga3lfks28r03363bjfa31rlgjzwk4s0a6g21bdl4a"; depends=[]; };
   glmnet = derive { name="glmnet"; version="1.9-8"; sha256="1ndaq6qbn8vxs7ha4x9k0qcblr1byixvrhh572794xzgdn548prm"; depends=[Matrix]; };
   glmnetcr = derive { name="glmnetcr"; version="1.0.2"; sha256="1pyg23hdqksiaqdcrsaqz9vb7mgclm41hh0vb7ndkdv284bzzlbz"; depends=[glmnet]; };
···
   glmpathcr = derive { name="glmpathcr"; version="1.0.3"; sha256="0qa63c7kwpxf6smczgzf4fmvczw1ynqq5vgcw3bxdbs37q4ypj8n"; depends=[glmpath mvtnorm]; };
   glmperm = derive { name="glmperm"; version="1.0-5"; sha256="1m6nxk9k5qjmq4kvv1nv7n51hagwxi97pd5a3wgiky3wml4aa2nw"; depends=[survival]; };
   glmulti = derive { name="glmulti"; version="1.0.7"; sha256="154s72sjp6pz7ki7s4mgn5v62j7h0lfz9mngf40wvmy31da2s8ix"; depends=[rJava]; };
+  glmvsd = derive { name="glmvsd"; version="1.0"; sha256="15im9cvylxvh76r2sjm6g9jb1cip2l08j9pyqv39dxpcky7xxvvl"; depends=[glmnet ncvreg MASS]; };
   glmx = derive { name="glmx"; version="0.1-0"; sha256="0i0p1xk5yk1l274gfr4ijmqnnbq7yyzmi577pb7igwvi3hjn7g7k"; depends=[MASS Formula lmtest sandwich]; };
   globalboosttest = derive { name="globalboosttest"; version="1.1-0"; sha256="1k7kgnday27sn6s1agzlj94asww81655d2zprx6qg7liv677bxvf"; depends=[mboost survival]; };
   GlobalDeviance = derive { name="GlobalDeviance"; version="0.4"; sha256="0s318arq2kmn8fh0rd5hd1h9wmadr9q8yw8ramsjzvdc41bxqq1a"; depends=[snowfall]; };
   globalGSA = derive { name="globalGSA"; version="1.0"; sha256="1f3xv03m6g2p725ff0xjhvn2xcfm7r7flyrba080i4ldy6fd8jg8"; depends=[]; };
-  globalOptTests = derive { name="globalOptTests"; version="1.0"; sha256="0vmly1mh8k5aihlwxfp30gj0qdrwfx2b9bcbs8ccrpfhgcvacnr9"; depends=[]; };
+  GlobalOptions = derive { name="GlobalOptions"; version="0.0.2"; sha256="0d0fb9q4qqc85q8yf123zm1c04agg5scylfwh1smv5ivhjy78pqz"; depends=[]; };
+  globalOptTests = derive { name="globalOptTests"; version="1.1"; sha256="0yf4p82dpjh36ddpfrby7m3fnj2blf5s76lncflch917sq251h4f"; depends=[]; };
   glogis = derive { name="glogis"; version="0.1-1"; sha256="02wdncycmnsvj09d1032cns3xbrh92ki5zn9sa3gscw1xzz0yzh6"; depends=[zoo sandwich]; };
   glpkAPI = derive { name="glpkAPI"; version="1.2.10"; sha256="0xlgccb77xgscfg46pxxcz5k9gm8a913xgp48dfmxw31n7ynckml"; depends=[]; };
-  GLSME = derive { name="GLSME"; version="1.0.1"; sha256="0v1d8jpjg0gpsvscx6gna4hi9pxr762bjf77hnla30hwfc0a95a2"; depends=[mvtnorm corpcor]; };
-  gmailr = derive { name="gmailr"; version="0.0.1"; sha256="0i87bgjzfd69s2cihvpilvl8nvw993cfsya3bz14fyvplvzf41lx"; depends=[httr base64enc jsonlite]; };
-  gmatrix = derive { name="gmatrix"; version="0.1"; sha256="06fbqixjbpxm4k6l132krbmk2jvh4r2s64nlbi9gb3whq55pf4ih"; depends=[]; };
-  GMCM = derive { name="GMCM"; version="1.0.1"; sha256="0vy4givxvppjc2r6s4q8yz86xzaw059fl1vjv0ni0hlbxz4dbb96"; depends=[mvtnorm Rcpp]; };
-  gMCP = derive { name="gMCP"; version="0.8-6"; sha256="1pr40k4qj4yy9hcp2zx8x4dys9vav7gk4164999wg4psp7f06va0"; depends=[rJava JavaGD MASS PolynomF multcomp mvtnorm Matrix CommonJavaJars]; };
-  GMD = derive { name="GMD"; version="0.3.1.1"; sha256="1vpapfnkn5gfqy033qirblx7xkbh52nw95sxw10v4aajddy0dyx9"; depends=[gplots]; };
+  GLSME = derive { name="GLSME"; version="1.0.2"; sha256="1zdqrji8x0f3wjl8bhpbnwdfklihv3ii20iz2y2gsm53yzw7dlwq"; depends=[mvtnorm corpcor]; };
+  gmailr = derive { name="gmailr"; version="0.5.0"; sha256="1jr3xf561y08wi1a9ysdbra7vf85hp14ybjn457c5mhhyfvxav49"; depends=[httr base64enc magrittr jsonlite]; };
+  gmatrix = derive { name="gmatrix"; version="0.2"; sha256="1w83m6q8xflifqqgkkg2my4fkjfjyv0qq4ly8yqk12k77lb03hxq"; depends=[]; };
+  GMCM = derive { name="GMCM"; version="1.1.1"; sha256="181in94mdc6fka0l4a6vc84n295pgsv18yf5mgf59qfmz8vjxi4n"; depends=[Rcpp]; };
+  gMCP = derive { name="gMCP"; version="0.8-8"; sha256="0568pqvcbrpqbppvpvmgxf23rzy1fgl892asq9lhcjslzsz89an5"; depends=[rJava JavaGD xlsxjars MASS PolynomF multcomp mvtnorm Matrix CommonJavaJars]; };
+  GMD = derive { name="GMD"; version="0.3.3"; sha256="0hdya8ai210wxnkfra9bzyswk3gib5fm53fs61rh0nsmg3ysdga6"; depends=[gplots]; };
   Gmisc = derive { name="Gmisc"; version="0.6.7"; sha256="15bgkgxqmgg81ry3ssx1darspmyhpzfcnkhkprqf495c07sh94jb"; depends=[Hmisc stringr lattice sp]; };
   gmm = derive { name="gmm"; version="1.5-0"; sha256="071i2bk73z606yb6a3vrv4cfyvgfwkrirm09i7bg2l3y2is1dfgj"; depends=[sandwich]; };
   GMMBoost = derive { name="GMMBoost"; version="1.1.2"; sha256="01q165vkdiv4qh96lha0g2g94jpnzdclbby6q43ghh9j1yrd4qzj"; depends=[minqa magic]; };
···
   gnumeric = derive { name="gnumeric"; version="0.7-2"; sha256="14c7a8aiqvqfbrjb1akpfjwidrzdhrw8a07ask083krki6vbi7hh"; depends=[XML]; };
   goalprog = derive { name="goalprog"; version="1.0-2"; sha256="1h3nd3d53hbz5hl3494lpfjnp1ddklc17nhgw18362jd1nk14awy"; depends=[lpSolve]; };
   gof = derive { name="gof"; version="0.9.1"; sha256="1s12gga9d6yizn2y7lzql4jd80lp5jpyml8ybn7xqswp8am82vpg"; depends=[]; };
-  GoFKernel = derive { name="GoFKernel"; version="2.0-3"; sha256="1ddnm7r48ya9rgna9jvf9mpk3bkn6954rr4rwsimybcp758b4ilv"; depends=[KernSmooth]; };
+  GoFKernel = derive { name="GoFKernel"; version="2.0-4"; sha256="12iashl0l8an1rdb9adjqbfvpv22rzf4y6vjdlg060r3qq7xr8kl"; depends=[KernSmooth]; };
   goft = derive { name="goft"; version="1.0"; sha256="061x6mnzidmnza9q7z2ikik9zrn434yjx1690bxbh41ckvb92hnx"; depends=[gPdtest mvShapiroTest]; };
   goftest = derive { name="goftest"; version="1.0-2"; sha256="11xw0cfj71z5smywsds9ijbhf3glxkqnhxmwwdqkv4gjrrr2y1bv"; depends=[]; };
   GOGANPA = derive { name="GOGANPA"; version="1.0"; sha256="1xbir21zvr5hv2y6nndzpsrpmnr7glrc7y6xgcyb856wx46ajan9"; depends=[GANPA WGCNA]; };
   gogarch = derive { name="gogarch"; version="0.7-2"; sha256="03gpl73zc6kx4gni59xbg7b38dkpd7p4c7kvlqm46f58j257viik"; depends=[fGarch fastICA]; };
   googlePublicData = derive { name="googlePublicData"; version="0.12.05"; sha256="01wilag2h55zdxxim2h06k0l93csi2nl7iqjnmk4yf9ayz226bc8"; depends=[XML XLConnect]; };
-  googleVis = derive { name="googleVis"; version="0.5.4"; sha256="0182bspqyg91ckczlq3p48basak12vcsj6nzgv7yljzzan0yx2sr"; depends=[RJSONIO]; };
+  googleVis = derive { name="googleVis"; version="0.5.6"; sha256="1gv8j4k5529i8gwqi4jk4gqlhbs8hykh5g6q6yqdmx27hz5dq1yn"; depends=[RJSONIO]; };
   gooJSON = derive { name="gooJSON"; version="1.0.01"; sha256="02sldh5lsrjprc9mbf99jyid7ij62db5f1h60z719gxl4pk6fjms"; depends=[rjson]; };
   goric = derive { name="goric"; version="0.0-7"; sha256="199scq0ii2l2jgxm634n9vs4w4zxq5scyc4ssab8m6yg4z8v45xp"; depends=[mvtnorm quadprog Matrix nlme MASS]; };
-  GOsummaries = derive { name="GOsummaries"; version="1.1"; sha256="1lkaid88lrm2xyz62xx32xnpch9qlhb3lif9jmk2zaym1d53558a"; depends=[ggplot2 Rcpp plyr gProfileR reshape2 gtable]; };
   govStatJPN = derive { name="govStatJPN"; version="0.1"; sha256="03sywa7rl5rblvv370mfszz5ngp850qf32yydy1fdx10lv5amrfl"; depends=[]; };
   gpairs = derive { name="gpairs"; version="1.2"; sha256="09mkdbs9hklxnmqcsnf65s3dfsfcr7kppp6zxj08v5hxym1gpz3l"; depends=[barcode lattice vcd MASS colorspace]; };
   GPArotation = derive { name="GPArotation"; version="2012.3-1"; sha256="1kvd6djsr6vdjd228i03d914n77sd5sym7dl5lbaq76bgmqfhr77"; depends=[]; };
···
   gpclib = derive { name="gpclib"; version="1.5-5"; sha256="08j81b8wymsgin20n54gvm6m54rmdic51p6qzs9cz4pmgl7dkkjv"; depends=[]; };
   GPCSIV = derive { name="GPCSIV"; version="0.1.0"; sha256="118l792mwd54xsi3g8afg3vc6wds8j6fyaz3mwmq04mlcyblym4l"; depends=[scatterplot3d sqldf]; };
   gPdtest = derive { name="gPdtest"; version="0.4"; sha256="00dlhnklfg2yp4hp7yjgr2nfswv22c007xq1mxdbkll62zgd94mq"; depends=[]; };
-  GPFDA = derive { name="GPFDA"; version="2.1"; sha256="05al7s49zcxhww8zirh2p2bk7yl262sl3sb2zzyisn8fnwn46iyk"; depends=[fda_usc spam MASS]; };
-  GPfit = derive { name="GPfit"; version="0.2-0"; sha256="16r3lqgkqb90w2hcf4ha3jczmrycagw3vmqknq32ly2a025n9gv9"; depends=[lhs lattice]; };
+  GPFDA = derive { name="GPFDA"; version="2.2"; sha256="1xqk03g8b8hi1vdqh6a9wml8ln0ad6lmy14z8k8c4wdc5kbzdr0b"; depends=[fda_usc spam fda MASS]; };
+  GPfit = derive { name="GPfit"; version="0.2-1"; sha256="1r7dmrjilnis4m8v0bibai0bkm3iwka4zxzrda8r49wmcpf99n2d"; depends=[lhs lattice]; };
   gpk = derive { name="gpk"; version="1.0"; sha256="1zfhkqyypb24mhbj2zi9qy3gw0kqxvlp8j5ni3zm7k5rz1bnrygg"; depends=[]; };
   gplm = derive { name="gplm"; version="0.7-2"; sha256="0pr39fbkv61iwd110lq76p2fi4dvx9qz6mjsvg6bpja9pfbb6wc0"; depends=[AER]; };
-  gplots = derive { name="gplots"; version="2.14.1"; sha256="1xmn29jsmkzbz5lazaxqq79kb58n2rlicns4ifsg45x8ypj1mqjn"; depends=[gtools gdata caTools KernSmooth]; };
+  gplots = derive { name="gplots"; version="2.14.2"; sha256="1ydb294qpz971kn44f9jq876wqxg58xisxm8y14v0kpl151yzclc"; depends=[gtools gdata caTools KernSmooth]; };
   GPLTR = derive { name="GPLTR"; version="0.95"; sha256="0fm260pwg66j91hddyql95lvvcpzvvbi3hddwzrk1bhyrgd8kj55"; depends=[rpart]; };
   gpmap = derive { name="gpmap"; version="0.1.1"; sha256="00jhslbxbp6dgq7bw346hfpw0gans048vsn7chyzjhyr7ah5xrfg"; depends=[isotone plyr ggplot2 foreach]; };
   gpr = derive { name="gpr"; version="1.1"; sha256="03ywik11kc6cnaqrzzzi94jkrdbd378m3sf26f2vpb7d834nl728"; depends=[]; };
···
   grade = derive { name="grade"; version="0.2-1"; sha256="085hfvqn880yk19axdjv3z9jr33kls212vs172a8mzhnkallph1r"; depends=[]; };
   GRaF = derive { name="GRaF"; version="0.1-12"; sha256="1d7mr2z49v6ch4jbzh0dj2yjy2c5p51ws38xfz233sjz475snajr"; depends=[dismo]; };
   gRain = derive { name="gRain"; version="1.2-3"; sha256="0cxlni9b4p4g02zhhsbbpkwhx9y3x83vm7qd6lsca02yi96palsi"; depends=[gRbase igraph]; };
-  gramEvol = derive { name="gramEvol"; version="1.1-1"; sha256="026sy3p1b6hy5xkg70zw6bb56i7qpadqs2ndym9ddznh09mk1fsj"; depends=[]; };
+  gramEvol = derive { name="gramEvol"; version="1.2-1"; sha256="12lixsczgy5ypriv6vwfv8ymfa72pxqhh58dc7n41wcl0zhgfzb4"; depends=[]; };
   GrammR = derive { name="GrammR"; version="1.0.0"; sha256="1j1k891cn9fyyp1nfyj6hjcz87qflipfwd9f9zg5s8y4jf0i9a7g"; depends=[gWidgets RGtk2 gWidgetsRGtk2 MASS cluster rgl GUniFrac ape]; };
-  granova = derive { name="granova"; version="2.0"; sha256="02jk6p0y29z09l2d35flyrx1g0b4vjpwv99v46pi4kdkiv50508x"; depends=[car]; };
   granovaGG = derive { name="granovaGG"; version="1.2"; sha256="0gy8ba1zlm62f458sxrph3cyz4c6nqkaddm6nwj54nyicxqah32h"; depends=[ggplot2 RColorBrewer plyr gridExtra reshape2]; };
   gRapfa = derive { name="gRapfa"; version="1.0"; sha256="07yzwzna9pdyzndxk6wwyl6v3gkfc7dvy1ixmdl3d38mcl1ahwyq"; depends=[igraph]; };
   gRapHD = derive { name="gRapHD"; version="0.2.4"; sha256="0fxd04s6zh23chks4k6nwb5w408xjy89b44pa42kv6qnqj86ylvm"; depends=[]; };
···
   gridExtra = derive { name="gridExtra"; version="0.9.1"; sha256="15pj5w5wlrf8gw4z01i9j88gk6bm4kni64fpip9icmxkn887y3hx"; depends=[]; };
   gridGraphviz = derive { name="gridGraphviz"; version="0.1"; sha256="14zcr0w2c9cgdw6ij93w52k3bkmgdmx809snh9jjf2amy08p2gbg"; depends=[]; };
   gridSVG = derive { name="gridSVG"; version="1.4-0"; sha256="0ch1waz2z60a7ivn63nf1418kgypr0nv8vr3ak3my0i7gdgny2pc"; depends=[RJSONIO XML]; };
-  GriegSmith = derive { name="GriegSmith"; version="1.0"; sha256="1a7gnaig1wvxpph7d8c37kx51dznzk0457fzf7alw95iwpyb4z7j"; depends=[spatstat]; };
+  GriegSmith = derive { name="GriegSmith"; version="1.0"; sha256="1a7gnaig1wvxpph7d8c37kx51dznzk0457fzf7alw95iwpyb4z7j"; depends=[]; };
   gRim = derive { name="gRim"; version="0.1-17"; sha256="0vn031r318kp78cx00n43fc42bv6sjyb8dm6q0l08s0g9n2w17dp"; depends=[gRbase gRain igraph]; };
   grImport = derive { name="grImport"; version="0.9-0"; sha256="1d8fd7502qj7cirjqdkr1qj51rylw2fz5hs06avfvc2dxs2xwfw1"; depends=[XML]; };
   grnn = derive { name="grnn"; version="0.1.0"; sha256="1dxcmar42g9hz4zlyszlmmnnsnja0gxfggav5jxv0gkp32rkd0wh"; depends=[]; };
   groc = derive { name="groc"; version="1.0.4"; sha256="1v32gwr8ghv47dmzp1x02n3aaqv3cfywh7xzx2486v4p960s42gc"; depends=[rrcov pls mgcv robust robustbase MASS]; };
-  grofit = derive { name="grofit"; version="1.1.1"; sha256="0m0phd5irk007k2kpxlsg03g7939nndf363fmkcxffykvp0023hz"; depends=[]; };
+  grofit = derive { name="grofit"; version="1.1.1-1"; sha256="1rnym5fxbg3bin2idmymrwvf1fcd646bipbgjd6wby8my69zy4c5"; depends=[]; };
   grouped = derive { name="grouped"; version="0.6-0"; sha256="1glxgacpwk7yjbkwg5ci6bmb2il6hf5zhydwi5bbq6hc032m9976"; depends=[MASS]; };
   GroupSeq = derive { name="GroupSeq"; version="1.3.2"; sha256="16n06jw7f97jhafgl9sfvd163v1walhlpmai1hmhiwjvv341sp13"; depends=[]; };
   growcurves = derive { name="growcurves"; version="0.2.3.9"; sha256="1f8hh8ppp6bgrb8crm46xrria3vdnz62aya9lhwcdaggfmy7j25l"; depends=[Rcpp RcppArmadillo reshape2 scales ggplot2 Formula testthat]; };
-  growfunctions = derive { name="growfunctions"; version="0.1"; sha256="0r11grbxbmdx2yg2jh22rf0frg7jz0w7n5d7mbhn16fwnkm3y9mw"; depends=[Rcpp Matrix spam mvtnorm ggplot2 reshape2 scales]; };
   growthmodels = derive { name="growthmodels"; version="1.2.0"; sha256="1wy5z77819s3daa0mifafcjfkggsq0ac522yagj86ml3vf7yqppj"; depends=[]; };
-  growthrate = derive { name="growthrate"; version="1.2"; sha256="05a2g3lcw4c0r3hykk5lsxmx2s1lp1fsjjxmip75dhid969sagcs"; depends=[Matrix clime mvtnorm]; };
-  grplasso = derive { name="grplasso"; version="0.4-3"; sha256="1v15x0kbzfvl3ygbrsxqgj3mz6a107bfvanbymh0hs7668b1zkab"; depends=[]; };
+  growthrate = derive { name="growthrate"; version="1.3"; sha256="1ak3yqlm7dnkdjlmikwa57qnf7yd9n1ixz36gv3shr252750x9cd"; depends=[Matrix clime mvtnorm]; };
+  grplasso = derive { name="grplasso"; version="0.4-4"; sha256="1l27fbdf08xj6flvbyvq9pc9v0hv9xpwpxxgcalv1l7rnvbq42jm"; depends=[]; };
   grppenalty = derive { name="grppenalty"; version="2.1-0"; sha256="12hbghmg96dwlscjy6nspgkmqqj4vwq2qcwcz1gp50a08qbmdcrk"; depends=[]; };
-  grpreg = derive { name="grpreg"; version="2.6-0"; sha256="1j112c96milqnd34dmznm1x7i02ydh484msd6vm98daghb42dzsg"; depends=[Matrix]; };
+  grpreg = derive { name="grpreg"; version="2.7-1"; sha256="0ly981ms475n66ncy756kb2qk9hy4lm0v5l8jjwk94kln6dbyp6v"; depends=[Matrix]; };
   grt = derive { name="grt"; version="0.2"; sha256="0cqjk7yqk2ryx1pgvjd3x8l25hqv92p8rvdr7xw4jkzillllwmhz"; depends=[MASS rgl misc3d]; };
   GRTo = derive { name="GRTo"; version="1.2"; sha256="0x65g8a39vrb8m3hqajxi0ksmdavz0p6mlamqprkdn9p6ikf5c73"; depends=[bootstrap]; };
   GSA = derive { name="GSA"; version="1.03"; sha256="1h1sbpn1rrdh44w4fx2avc7x24ba40mvpd8b2x5wfrc7a294zf6z"; depends=[]; };
···
   gsalib = derive { name="gsalib"; version="2.0"; sha256="0yk39ca7yrsksga73ma2pdqfy3s1xpp07y8622x44b9cazv6rdy4"; depends=[]; };
   gsarima = derive { name="gsarima"; version="0.1-4"; sha256="0q5i5szyqvj1sgyg17khqx5rgdpn3wxp22ddr9m9rb653y03xzz0"; depends=[MASS]; };
   gsbDesign = derive { name="gsbDesign"; version="0.96-2"; sha256="0sk4a66z9bqi3aa2ky9472p9znfm93kc9p5igdmvii4dr0syyfxd"; depends=[gsDesign lattice]; };
-  gsDesign = derive { name="gsDesign"; version="2.8-8"; sha256="0czr2xyh3nd8kgvw71wvqakvmfbdbysiyyfnh2az7l4j33xyhfc9"; depends=[ggplot2 xtable stringr RUnit plyr]; };
-  GSE = derive { name="GSE"; version="3.0"; sha256="1b1nrnvgly7zpyw9z9ddgmx7qfz0mllwm8k7czs17x3l5gkmw8ir"; depends=[Rcpp RcppArmadillo MASS ggplot2]; };
+  gsDesign = derive { name="gsDesign"; version="2.9-2"; sha256="0n2mz2h0z54gl8a3bw68s09pns85v8jnpalhm59nji4skyk7lzad"; depends=[ggplot2 xtable stringr RUnit plyr]; };
+  GSE = derive { name="GSE"; version="3.1"; sha256="08xr7w6dsmgs3l8ayihadcvwy0xdzn78fllxa42sk7nfz6waadr3"; depends=[Rcpp MASS ggplot2]; };
   gSeg = derive { name="gSeg"; version="0.1"; sha256="0qnv3c0rla0g2fb4s4x1i0zdp3dlvi98qf80wlr54gnn7s9vpjf1"; depends=[]; };
   gset = derive { name="gset"; version="1.0"; sha256="10qiwp94z8zm2gvklnz23qmypdwh72jz0v7rdcni38pv2hcky637"; depends=[Hmisc mvtnorm MCMCpack]; };
-  gsg = derive { name="gsg"; version="1.0"; sha256="0j2h1i94vr0mvj4rl328n666b9nn2xnakid8k1r2lh88vk3dv9ma"; depends=[mgcv mvtnorm boot numDeriv]; };
+  gsg = derive { name="gsg"; version="2.0"; sha256="17fjl7aw1s814krnszxd4y1d4210bnkrf4kb2fwsycqwcwms5pm7"; depends=[mgcv mvtnorm boot numDeriv]; };
   GSIF = derive { name="GSIF"; version="0.4-1"; sha256="0ry2lq9cncd68wnrfgfw53mqi1jiijggdz3ib37xpkcqh754101x"; depends=[sp RSAGA dismo rgdal raster aqp plotKML gstat boot rpart quantregForest randomForest nlme]; };
   gskat = derive { name="gskat"; version="1.0"; sha256="19mbif7wr88vk5wlc7m2l4xghjmfj2qd3s8yvjlkawbnjk8x6ib0"; depends=[CompQuadForm e1071 gee geepack Matrix]; };
   gsl = derive { name="gsl"; version="1.9-10"; sha256="06n21p0k2ki6nb725a6sxwlb4p7xc5jhg11nq9c3z3dj39r0qgbd"; depends=[]; };
   GSM = derive { name="GSM"; version="1.3.1"; sha256="1ay6znw31qnhz5k6fa0aiccr2xxmnj7v3vzrvlk6y5v5smlvybd0"; depends=[gtools]; };
-  gsmaRt = derive { name="gsmaRt"; version="1.0"; sha256="0hpf0vgmhill3w8cqpsgvxjgwk2ka154vm9klidckm05qcqlwdn6"; depends=[R2HTML rgl scatterplot3d xtable]; };
   gsmoothr = derive { name="gsmoothr"; version="0.1.7"; sha256="00z9852vn5pj04dhl3w36yk0xjawniay6iifw1i7fd8g98mgspxp"; depends=[]; };
   gss = derive { name="gss"; version="2.1-3"; sha256="07bp60fhax8v4nyzcgadadi1kfwgwk5r08y6ifsgim500jbw7apk"; depends=[]; };
   gsscopu = derive { name="gsscopu"; version="0.9-1"; sha256="0qg4ra7zvp0j6wjbb14sqajfq745bza3v50s0c5xxnddblqi4hcc"; depends=[gss]; };
   gstat = derive { name="gstat"; version="1.0-19"; sha256="1yhrp1dgkl11hr8jy1kmsiaf8avf02m85wcnvf34vlbil24hy7py"; depends=[lattice sp zoo spacetime FNN]; };
   gstudio = derive { name="gstudio"; version="1.3"; sha256="1ddifizswm41y4sxnnfw8j90clba6zf022x0z4xipccaznim2gy9"; depends=[ggplot2 raster sp reshape2 ggmap popgraph]; };
-  gsubfn = derive { name="gsubfn"; version="0.6-5"; sha256="1glpq5ghzgarqg8wfl7pblblm31d4dsxrlrkhsgckldbdap52yws"; depends=[proto]; };
+  gsubfn = derive { name="gsubfn"; version="0.6-6"; sha256="196x4c3ihf4q3i0v7b1xa6jm8jjld2rsx00qz03n90wfnjdx5idv"; depends=[proto]; };
   gtable = derive { name="gtable"; version="0.1.2"; sha256="0k9hfj6r5y238gqh92s3cbdn34biczx3zfh79ix5xq0c5vkai2xh"; depends=[]; };
   gtcorr = derive { name="gtcorr"; version="0.2-1"; sha256="1n56zmyv58jwr95p453jb86j82pdnq57gfc8m15jndjc9p31zl0m"; depends=[]; };
   gte = derive { name="gte"; version="1.2-1"; sha256="0h6c5n9wz8b4b5pmqfbc8ivqpg2jh4k6x94wns1l33kiah70pmjd"; depends=[survival]; };
   gtools = derive { name="gtools"; version="3.4.1"; sha256="0d5v864v3qnmmxas8xf74aarli9nr3l16bwj9qzs2s9k498q6azs"; depends=[]; };
   gtx = derive { name="gtx"; version="0.0.8"; sha256="0x71jji2yldi9wpx8d3nldbjfj4930j7zcasayzbylf9094gmg26"; depends=[survival]; };
-  GuardianR = derive { name="GuardianR"; version="0.4"; sha256="0jk97x106srswp28r68713ky707cx957hvbkjggfppcglic5dc1n"; depends=[RCurl RJSONIO]; };
-  Guerry = derive { name="Guerry"; version="1.5-0"; sha256="18pgmsqd6ign5g4lwpd35gxaypm3zjf1i82w63ss11dsqddnfyvh"; depends=[sp shapefiles]; };
+  GuardianR = derive { name="GuardianR"; version="0.5"; sha256="0m5arxz4ih84zg8sf2wy2kg38adraa098gb52vwz93dzdm1dhslw"; depends=[RCurl RJSONIO]; };
+  Guerry = derive { name="Guerry"; version="1.6-1"; sha256="1hpp49w2kd1npsd709cwg125pw6mrqxfv2nn3lcs1mg2r49ki2bl"; depends=[]; };
   GUIDE = derive { name="GUIDE"; version="1.0.9"; sha256="1y0y6rwv1khd9bdaz5rl9nmxiangx0jckgihg16wb6hx6kf8kzc1"; depends=[rpanel tkrplot]; };
+  GUILDS = derive { name="GUILDS"; version="1.2"; sha256="0nirrbq8z7axnrgwbykv5886yf3akf64zynza8l2m96nvzlkzf4y"; depends=[Rcpp pracma subplex]; };
   gumbel = derive { name="gumbel"; version="1.04"; sha256="0fl44i4kz9wbba1iv4fy1b74nf25axdkifhczgrgpy5d81ky43v6"; depends=[]; };
   GUniFrac = derive { name="GUniFrac"; version="1.0"; sha256="0w08b22xkx0llmwk1kj4ibapvg3fxkgkmjz6z6acr4nwqfwmjzzx"; depends=[vegan ape]; };
   GUTS = derive { name="GUTS"; version="0.3.5"; sha256="10yi18yv3vbm7pn11bbj3baxqga5yymilabf56bc18prpirnw51b"; depends=[Rcpp]; };
-  gvcm_cat = derive { name="gvcm.cat"; version="1.6"; sha256="0v5q97gjninxrjdclxj1bn362h0j93pm71k9gp79aa3sdy4ay6s4"; depends=[Matrix MASS]; };
+  gvcm_cat = derive { name="gvcm.cat"; version="1.7"; sha256="0wgras21wzx1magcayz9nra8licrbx8aglmc272wrw3nqiagh0fi"; depends=[Matrix MASS]; };
   gvlma = derive { name="gvlma"; version="1.0.0.2"; sha256="0gj52hg665nmlwgbjh9yvz7a3sbzlbj41ksxchnnlxaxipdf6sl8"; depends=[]; };
   GWAF = derive { name="GWAF"; version="2.1"; sha256="1s56d3b6p5fpaxi32ks2mmhsa5sgi746hf159wk0z99099gli8g3"; depends=[geepack coxme lme4]; };
   GWASExactHW = derive { name="GWASExactHW"; version="1.01"; sha256="19qmk8h7kxmn9kzw0x4xns5p3qqz27xkqq4q6zmh4jzizd0fsl78"; depends=[]; };
   GWAtoolbox = derive { name="GWAtoolbox"; version="2.2.4"; sha256="0adpixlfh0j1py79b0636921kmz2zvhv8p07m6ism6h3xva0i4ck"; depends=[]; };
   gwerAM = derive { name="gwerAM"; version="1.0"; sha256="1c3rzd1jf52a4dn63hh43m9s9xnjvqn67amlm9z1ndrnn6fwfg1b"; depends=[MASS Matrix]; };
   GWG = derive { name="GWG"; version="1.0"; sha256="1va0cd229dhhi1lmrkpwapcm96hrdmxilrmba02xnl7ikhisw0my"; depends=[]; };
-  gWidgets = derive { name="gWidgets"; version="0.0-53"; sha256="06imjabf9fqghaszqq77x6vxq864cn36n6534bkg23m9fwzqzf23"; depends=[]; };
+  gWidgets = derive { name="gWidgets"; version="0.0-54"; sha256="13lbbbnmkvb559klgsnz0q27qlyv102xakb6yccxsxjw249hm8c2"; depends=[]; };
   gWidgets2 = derive { name="gWidgets2"; version="1.0-5"; sha256="1y6vm6ds77yr1qiqlcaixbsarbwx5w53ba343svla7wva80ajbpl"; depends=[digest]; };
   gWidgets2RGtk2 = derive { name="gWidgets2RGtk2"; version="1.0-2"; sha256="1pzcpjz5cdizvj0ih2r4i3ll6flm45q8ym6sz0wqbg4j3ir0l5kh"; depends=[memoise RGtk2 gWidgets2]; };
   gWidgets2tcltk = derive { name="gWidgets2tcltk"; version="1.0-2"; sha256="1dzrc8yry4l2afpijr35irnqmvfpd22vlb3lih4pk14n52690y0h"; depends=[digest memoise gWidgets2]; };
   gWidgetsRGtk2 = derive { name="gWidgetsRGtk2"; version="0.0-82"; sha256="0b1imvy2094s2ixar7z4kxs047855ssijx8l22a1hlwdg7zp7sng"; depends=[RGtk2 gWidgets]; };
   gWidgetstcltk = derive { name="gWidgetstcltk"; version="0.0-55"; sha256="06991rqh4927bal7j718bn2ziy6rws8yq682lmp5vbqhdd36afv2"; depends=[gWidgets digest]; };
-  gWidgetsWWW = derive { name="gWidgetsWWW"; version="0.0-23"; sha256="14yw04kgfqfwl44zkyqy075rjd5vafbzig6x5py25ypbdk3hwn7a"; depends=[proto filehash digest rjson]; };
   GWmodel = derive { name="GWmodel"; version="1.2-3"; sha256="04sks9rnqxgxyj9q3nyrnknp4cdfck2p52svxfdrgvxqr48kf6ff"; depends=[maptools robustbase]; };
   GWRM = derive { name="GWRM"; version="1.1"; sha256="1l8rw2nksd1vskjb7kjn93vgrs39bcrr8zz1j66rmkcc399pf6nf"; depends=[]; };
   gwrr = derive { name="gwrr"; version="0.2-1"; sha256="1fjk217pimnmxsimqp9sn02nr1mwy3hw3vsr95skbfsd6vdda14d"; depends=[fields lars]; };
   GWsignif = derive { name="GWsignif"; version="1.0"; sha256="04663qgy3xmijrx8m1s5ql7zj70mgsd58dl08ci742l1fzmfya5f"; depends=[]; };
-  GxM = derive { name="GxM"; version="1.0"; sha256="1vaq0fkx3bf2kdmn2iqgad8haprg9i3a9101nrvyh2pv2g894761"; depends=[Rcpp minqa nlme]; };
-  h2o = derive { name="h2o"; version="2.4.3.11"; sha256="0mlyzvylqqi3w85riyp2mhyzdqf6yvmxibdjj41glaqc5vj37dlx"; depends=[RCurl rjson statmod]; };
+  GxM = derive { name="GxM"; version="1.1"; sha256="02rv8qb46ylk22iqn9cgh63vkyrg9a8nr1d0d3j5hqhi0wyhc41r"; depends=[Rcpp minqa nlme]; };
+  h2o = derive { name="h2o"; version="2.8.1.1"; sha256="12v5xjh7j7ns5wqj8aa6phx6cbh8d03r9h933g8ynss18pkd901w"; depends=[RCurl rjson statmod survival]; };
   haarfisz = derive { name="haarfisz"; version="4.5"; sha256="1qmh4glwzqwqx3pvxc71rlcimp1l0plgdf380v9hk0b4gj7g3pkf"; depends=[wavethresh]; };
-  HAC = derive { name="HAC"; version="1.0-0"; sha256="00va1q17a1vijhb557kh6scqakllqlblcv2hfisi7fq0h2ainni1"; depends=[copula]; };
+  HAC = derive { name="HAC"; version="1.0-1"; sha256="11m3f3fmra4ic3kql5n34ssdwgd1db0avgw3rpmwmq99wgpsdvr5"; depends=[copula]; };
   HadoopStreaming = derive { name="HadoopStreaming"; version="0.2"; sha256="1l9msaizjvnsj1jrpghj4g057qifdgg6vbqhfxhn1fiqdqi2056q"; depends=[getopt]; };
   hamlet = derive { name="hamlet"; version="0.7"; sha256="0f3gl5xvgdksaxk76dyv46hahc41f2j3pf9wp0rc0q7wpp5nfsjl"; depends=[]; };
   HandTill2001 = derive { name="HandTill2001"; version="0.2-9"; sha256="1j4ivxarm3k9sj05824lv6b03apyabpciv4mp253vv0yzjcp2bzf"; depends=[]; };
   Hankel = derive { name="Hankel"; version="0.0-1"; sha256="0g3b0ji8hw29k0wxxvlnbcm0z91p4vbajbrhm6cqbccjq85lg4si"; depends=[]; };
-  hapassoc = derive { name="hapassoc"; version="1.2-6"; sha256="14ddh7wiyks0wcw0iy1af9njg4wsn5flv59r463z2b3pbj5zp1qc"; depends=[]; };
+  hapassoc = derive { name="hapassoc"; version="1.2-7"; sha256="1cyx68fzazyyihhp2r237c6igspnfklswnja2k4z3my528ggbq7k"; depends=[]; };
   HapEstXXR = derive { name="HapEstXXR"; version="0.1-6"; sha256="0ldmfa9729sf9r1kaldsskq8w6kvjac778bzjyi0a1pfz2walzjb"; depends=[survival]; };
   HAPim = derive { name="HAPim"; version="1.3"; sha256="03qy0pxazv3gdq3fck7171ixilb9zi1dwnvc4v7d726g0lvn80pg"; depends=[]; };
   Haplin = derive { name="Haplin"; version="5.3"; sha256="1gfg9dhgw42yjd1i8knnjvc2y2fbdc2ypa396g48hmsnislqffsd"; depends=[MASS mgcv GenABEL DatABEL filehash]; };
   haplo_ccs = derive { name="haplo.ccs"; version="1.3.1"; sha256="0cs90zxxbvglz1af0lh37dw1gxa04k0kawzxamz2was3dbh19lbz"; depends=[haplo_stats survival]; };
   HaploSim = derive { name="HaploSim"; version="1.8.4"; sha256="0794f76hc9qvjmay7c61cmzycqafljs0g0hliq9xfrw4f23gq3sa"; depends=[]; };
-  haplo_stats = derive { name="haplo.stats"; version="1.6.8"; sha256="1zz8hi37zwc6wkn5q7zhz1l29vlklhnj8gzp1pmz4ys496c2lwxh"; depends=[]; };
+  haplo_stats = derive { name="haplo.stats"; version="1.6.11"; sha256="0j3zh4n2rly8dij8srm8ck6fl63haw6d27m3nfnrxywr87pljg14"; depends=[]; };
   HAP_ROR = derive { name="HAP.ROR"; version="1.0"; sha256="1id9amz1cc2l2vnpp0ikbhf8ghbgzqd1b9dfivnyglg7996c3gbg"; depends=[hash ape]; };
   hapsim = derive { name="hapsim"; version="0.3"; sha256="18r0cq15psjwxprml84ihj5gw4pk6agd7x0qicj899awa21f2qb3"; depends=[MASS]; };
   HardyWeinberg = derive { name="HardyWeinberg"; version="1.5.4"; sha256="0098n5m3svcc3z5cvmqygazlvm1dzd4zfbpj1q9zqs5wr3407wcv"; depends=[mice]; };
···
   hda = derive { name="hda"; version="0.2-12"; sha256="11z9p35dvhi7bdw09d2yawh46nxk8axw76b51vk089g12nr2b9x7"; depends=[e1071]; };
   HDclassif = derive { name="HDclassif"; version="1.2.2"; sha256="0j32nhl2v0bipflidwfk6q8a0pvn7qjs7ks1al2izsr772dwfcvq"; depends=[MASS]; };
   hddplot = derive { name="hddplot"; version="0.56"; sha256="0s9iijwq8zfvavqq2bkqm2884sg0957ppkggsv6mmm3cbdi2xrlc"; depends=[MASS]; };
+  hddtools = derive { name="hddtools"; version="0.2.2"; sha256="0ldasm8aqzcc0lfmgdbvljz103g11ydw01g4mv7wzysjvw6zlwfl"; depends=[sp rgdal raster RCurl XML zoo]; };
   hdeco = derive { name="hdeco"; version="0.4.1"; sha256="04nggwckvn1kwi238qd33l4pryzn4aq5bmi30bvfi99gwnrlgfgq"; depends=[]; };
   hdi = derive { name="hdi"; version="0.1-2"; sha256="19lc2h34jlj198gchnhbfbb8igwlan2b977a47j8p3q6haj5bcv1"; depends=[glmnet linprog MASS scalreg]; };
   hdlm = derive { name="hdlm"; version="1.2"; sha256="0s4lzg3s2k7f7byygb11s7f78l3rkkb0zn03kh3d7h8250wg9fax"; depends=[glmnet foreach MASS iterators]; };
   HDMD = derive { name="HDMD"; version="1.2"; sha256="0na0z08fdf47ghfl2r3fp9qg5pi99kvp7liymwxym2wglkwl4chq"; depends=[psych MASS]; };
-  HDPenReg = derive { name="HDPenReg"; version="0.89.8"; sha256="1w1p3ivqw5snp9c08qss08radcv32h9pd5av0gj8kachcf4b6x0l"; depends=[Rcpp]; };
+  HDPenReg = derive { name="HDPenReg"; version="0.89.9"; sha256="0151z7n6sh1acd9a2c1g4pmjz15hl7jjmyl2p2hlr631wap675k4"; depends=[Rcpp]; };
   hdrcde = derive { name="hdrcde"; version="3.1"; sha256="027nxpzk1g0yx8rns7npdz30afs5hwpdqjiamc7yjrsi0rzm71lw"; depends=[mvtnorm locfit ash ks KernSmooth]; };
   HDtweedie = derive { name="HDtweedie"; version="1.1"; sha256="14awd7sws0464f68f5xwnv1xvr0xflvx2z2zzcfj1csvk3af0zzj"; depends=[]; };
   HEAT = derive { name="HEAT"; version="1.2"; sha256="1qifqd06ifl0f5l44mkxapnkwhpm0b82yq6dhfw4f8yhb27wd0z2"; depends=[]; };
   heatex = derive { name="heatex"; version="1.0"; sha256="0c7bxblq24m80yi24gmrqqlcw8jh0lb749adsh51yr6nzpap6i9n"; depends=[]; };
-  heatmap3 = derive { name="heatmap3"; version="1.0.4"; sha256="0yrqq97r05xypqgd2dz5cyb54kjdhdzi59rclppcibwhjzpvgdka"; depends=[fastcluster]; };
-  heatmapFit = derive { name="heatmapFit"; version="2.0.2"; sha256="00p39y6x13yxrxfqx6gzmb80fk1hsyi8wa6brx40hj37pyyfis0p"; depends=[]; };
+  heatmap3 = derive { name="heatmap3"; version="1.0.7"; sha256="037aw51ynhi45yzsdd9af9kv1lza2k5lvx8m8jbzp6adadpwr305"; depends=[fastcluster]; };
   heatmap_plus = derive { name="heatmap.plus"; version="1.3"; sha256="0rzffm15a51b7l55k0krk6w7v8czy3vpwz1qmbybr7av0pln7wn3"; depends=[]; };
-  heavy = derive { name="heavy"; version="0.2-3"; sha256="17mr2i629hw38dadbl75rmkz9y3brc2yz3hap1vp607ya420cmv8"; depends=[]; };
-  helloJavaWorld = derive { name="helloJavaWorld"; version="0.0-7"; sha256="0x0f64w5783mh0ryv0krpdzhicbv912y36h74h1qapcy5225fxh5"; depends=[rJava]; };
+  heavy = derive { name="heavy"; version="0.2-35"; sha256="04aw0r2hgnxf9nsd18q2b5d130vj578nyv5wacivikgfifyy0y39"; depends=[]; };
+  helloJavaWorld = derive { name="helloJavaWorld"; version="0.0-9"; sha256="1a8yxja54iqdy2k8bicrcx1y3rkgslas03is4v78yhbz42c9fi8s"; depends=[rJava]; };
   helsinki = derive { name="helsinki"; version="0.9.20"; sha256="0jlyvj8cyzb0si2gqwik4jzbmwfawwnap9k6jl1z2nw2rz5w1k3c"; depends=[maptools rjson RCurl]; };
   heplots = derive { name="heplots"; version="1.0-12"; sha256="064kanmqm4b0sbyw60wfb19adclpdagm23l6p86vi0hyx0dr0ykz"; depends=[car MASS]; };
   hergm = derive { name="hergm"; version="1.3-11"; sha256="1kfh7ry84smxf3d0ykjr7d0ckh2dk9y63761f4pmskfxqx12w98a"; depends=[ergm]; };
+  hermite = derive { name="hermite"; version="1.0"; sha256="11daz0lwlr6klbqkc4bkkmghfm0p2pqmpclrp6dj5v3403h3yksh"; depends=[]; };
   hett = derive { name="hett"; version="0.3-1"; sha256="1y0hr9g2pjwzc5azh095h33qidxhhmlvd1csamjnhwdphj5drzz0"; depends=[MASS lattice]; };
   het_test = derive { name="het.test"; version="0.1"; sha256="08kxp81dx32anh0k5b65x7w7madwnn9hiabdrk6ck6b6mx37x26v"; depends=[vars]; };
   hexbin = derive { name="hexbin"; version="1.27.0"; sha256="0fs5nsaalic6fj7b347yjczws310y3q2v37yr8sg74yq8wqzsdj8"; depends=[lattice]; };
···
   hflights = derive { name="hflights"; version="0.1"; sha256="1rb6finck13i6949i6hsgfk90q4ybxh1m3is2mlw2m6087bpzfbd"; depends=[]; };
   hgam = derive { name="hgam"; version="0.1-2"; sha256="1flcc67n8kbh9m5phdfl587xg1x935zbp305y0gdmkc8vpkiwpcf"; depends=[grplasso lattice rgl]; };
   hglasso = derive { name="hglasso"; version="1.2"; sha256="1qq41ma33wz7qjs5zx72yvngpsiq62z9sd6d5hvvl83brq0fcr4b"; depends=[glasso mvtnorm igraph fields]; };
-  hglm = derive { name="hglm"; version="2.0-8"; sha256="14md1d54zbhc2cnrvim5l8rwg556ln0ssamxj5354nrvr6sxv8gs"; depends=[Matrix MASS hglm_data]; };
+  hglm = derive { name="hglm"; version="2.0-11"; sha256="0yqnky2p5avxn7nv8wnk57xkd0dpk89jas6d577q50ms4dpwdl6z"; depends=[Matrix MASS hglm_data]; };
   hglm_data = derive { name="hglm.data"; version="1.0-0"; sha256="1hrq1jac658z5xjsg03nfkb4kwm9z44bhciv5chk74ww8gjr9j9q"; depends=[Matrix MASS]; };
   HGNChelper = derive { name="HGNChelper"; version="0.3.0"; sha256="1w1x8fkvwlm4xqfx3afg42hhsa459sxqacsiph088sr77lhd3acz"; depends=[]; };
-  HH = derive { name="HH"; version="3.0-4"; sha256="11b1qvhdl1waskvvcdkdkljh5d3ql6ajsq0vg4fapprfkq4jamv1"; depends=[lattice latticeExtra multcomp reshape2 leaps vcd colorspace RColorBrewer]; };
+  HH = derive { name="HH"; version="3.1-5"; sha256="0m7gydzqm7ih9ii9fcbs8l59r535l314daxdpdya661bmcgjd2ks"; depends=[lattice latticeExtra multcomp reshape2 leaps vcd colorspace RColorBrewer Rcmdr]; };
   HHG = derive { name="HHG"; version="1.4"; sha256="048jbwhrbgp1pv2j6sw234ykdn7bgpa49slwh3p5547nl2cwjysg"; depends=[]; };
-  hht = derive { name="hht"; version="2.0.2"; sha256="1hah6f8svvp63nzdfrnri8bi6dzx1qn372dmiz6x2jpp77mw2mkc"; depends=[EMD fields]; };
   HI = derive { name="HI"; version="0.4"; sha256="0i7y4zcdr6wcjy43lz9h8glzpdv0pz7livr95xb1j4p8zafykday"; depends=[]; };
-  HIBAG = derive { name="HIBAG"; version="1.2.3"; sha256="08hg9l5il2zicbpg04biiqm99lj51ny6ias8hwxj2s4gyr1qd5ny"; depends=[]; };
-  HiClimR = derive { name="HiClimR"; version="1.1.2"; sha256="1vq8gln5888aa9835phixniijf1madxgsx895ld6nxxrwd9jhwpl"; depends=[]; };
+  HIBAG = derive { name="HIBAG"; version="1.2.4"; sha256="0mmy7yn9xl0gp3cgkv4zym2hbzbw1kvsdhv5mvl401v95qjy5z20"; depends=[]; };
+  HiClimR = derive { name="HiClimR"; version="1.1.4"; sha256="097dih3k8xmsgcgd3bkyg6zvnyl80y4yjwl3n658g574ab8gxgch"; depends=[]; };
   HiCseg = derive { name="HiCseg"; version="1.1"; sha256="19581k3g71wrznyqrp4hmspqyzcbcfbc48xgjlq13zmqii45hcn6"; depends=[]; };
-  hiddenf = derive { name="hiddenf"; version="1.0"; sha256="00r27dyfg4mjsp4s3hjk19alqc4jbfvy8pk5zjvz7gdgq68fxaza"; depends=[]; };
-  HiddenMarkov = derive { name="HiddenMarkov"; version="1.7-0"; sha256="0223yw1ga2c2y1fqjgr3m4yw7w8cp5r0z5cz766qvbc5wv65bh59"; depends=[]; };
+  hiddenf = derive { name="hiddenf"; version="1.1"; sha256="04pl3glvg3m1xzvxnc5lwjz839zrpc8zhnsxcswvvaqpgzip5f1p"; depends=[]; };
+  HiddenMarkov = derive { name="HiddenMarkov"; version="1.8-1"; sha256="13c5g6wryzry1rvqcfpkjm9vibc6lv864fvcjmr2z8ianiqrrn6p"; depends=[]; };
+  HiDimDA = derive { name="HiDimDA"; version="0.2-2"; sha256="0y45c7yi20ixr7d8zmjsbxsc9kvvwpdw49qncpz5l5wmdmzhy8mm"; depends=[]; };
+  HiDimMaxStable = derive { name="HiDimMaxStable"; version="0.1"; sha256="1h2sqkqb24a0ywwxx4w2qi8w3f9xq41mipmcfnpph3aygdam61y1"; depends=[copula mnormt partitions maxLik mnormpow VGAM]; };
   hierarchicalDS = derive { name="hierarchicalDS"; version="2.01"; sha256="0qdpdr8wk27zm1gf50awnmy8sghqq7mcdq30ahcyphmxmkm5cn1l"; depends=[truncnorm MASS mvtnorm Matrix coda spsurvey MCMCpack xtable mc2d]; };
-  hierfstat = derive { name="hierfstat"; version="0.04-10"; sha256="1n0nn5liwvf3xc743vdxpfqsbr40n599f981gk49d9nq8qk0kggl"; depends=[gtools ade4]; };
+  hierfstat = derive { name="hierfstat"; version="0.04-14"; sha256="0zbl5cq0cidv0glgi1g2q0azfw393lnb7hp8m69sxwdjn3y3912c"; depends=[gtools ade4]; };
   hierNet = derive { name="hierNet"; version="1.6"; sha256="08lifk92caa4l9nfb89rl6vby8sd1ba3ay7z29ffirsg7cx07qiw"; depends=[]; };
+  HierO = derive { name="HierO"; version="0.1"; sha256="009lf28k8grldapk3smcsjs14gxl1y58p39ksc3nv9i1hzkcd62z"; depends=[rneos RCurl bitops XML tcltk2]; };
   hier_part = derive { name="hier.part"; version="1.0-4"; sha256="03acdgzkhbk4p0wxw2g1hzklmq9hzmdkkvfj742vzfswdd803yg9"; depends=[gtools]; };
   HIest = derive { name="HIest"; version="2.0"; sha256="0ik55kxhzjyg6z6072iz9nfaj7x1nvf91l1kysgvkjccr6jf3y86"; depends=[nnet]; };
-  highfrequency = derive { name="highfrequency"; version="0.2"; sha256="0gq1szwqal792n1k14m51flbjz72vfym14wkxl3q48mwv2i4s772"; depends=[xts zoo]; };
+  highD2pop = derive { name="highD2pop"; version="1.0"; sha256="1s4v6m2d3vzvxsgmjzczv1zj3kv3ygvv6gbkkbjwsdhkvc1rdmf0"; depends=[fastclime]; };
   highlight = derive { name="highlight"; version="0.4.4"; sha256="03mch5waqkzb9pb4llgalbxdfn3h6adh05f3i43kscssc67bs30l"; depends=[]; };
-  highr = derive { name="highr"; version="0.3"; sha256="1y0amfvdpqwq0n60fykbsir4jd1ynkwfcgadjnn1997amk9qja5x"; depends=[]; };
-  highriskzone = derive { name="highriskzone"; version="1.1"; sha256="1qpk63jh44075b6fnhqx1iqjywzzwhvr6lry3vjlx0sfv1nqad6k"; depends=[spatstat ks]; };
+  highr = derive { name="highr"; version="0.4"; sha256="18qfh6v5h29g6y2fkgd4qnkl1ijzzjh369gvn9pzcgaapm6s2wpf"; depends=[]; };
+  highTtest = derive { name="highTtest"; version="1.0"; sha256="0iyr47nid147m9m8bsjjxc9kvjv68rgay4naxldwisyscqp8jl0m"; depends=[colorfulVennPlot]; };
   hillmakeR = derive { name="hillmakeR"; version="0.2"; sha256="1baynibgn4xqmpsxna8irggxvdc484mq5nza00rwg58vh1bc7wzq"; depends=[]; };
   HiLMM = derive { name="HiLMM"; version="1.0"; sha256="1x3my51vzxlk9q7vj2ljpqinxw777953mhgzvbqildph4szh4xh4"; depends=[]; };
   hint = derive { name="hint"; version="0.1-1"; sha256="1n18j2hcb1qynhsln10nzryi20l5aqhr7i1aanww10y5dz573zi3"; depends=[]; };
···
   hisemi = derive { name="hisemi"; version="1.0-319"; sha256="0pm7dsaaqrdhkvxsk2cjvk6qd2rqqmddmv012smnrivi7mpnvd4w"; depends=[Matrix Iso fda]; };
   HistData = derive { name="HistData"; version="0.7-5"; sha256="17s64hfs7r77p0wjzpbgz9wp3gjzbly2d0v784f9m2bka8gj6xhr"; depends=[]; };
   histogram = derive { name="histogram"; version="0.0-23"; sha256="0hrhk423wdybqbvgsjn7dxgb95bkvmbh573q1696634hvzfdm68c"; depends=[]; };
-  HistogramTools = derive { name="HistogramTools"; version="0.3"; sha256="1wfvrznr578s2hc8ccs849pz4kjlyi4brdxhw919cvk758ahy9rv"; depends=[Hmisc ash stringr]; };
+  HistogramTools = derive { name="HistogramTools"; version="0.3.1"; sha256="0cc3saly5q2kn1gr2mam7g901ddcipmlrn1m0amgrnbkakby2320"; depends=[Hmisc ash stringr]; };
   hitandrun = derive { name="hitandrun"; version="0.4-2"; sha256="143aj926mx0v26f8dsagr90ggzk23lfms57agzrnqfvddla7ng9c"; depends=[rcdd]; };
   hive = derive { name="hive"; version="0.1-16"; sha256="1xaxnr8nfkji2b5f5dq2h01pkl20rm24wxnf1y1xv695v3j58ibd"; depends=[rJava XML]; };
   HiveR = derive { name="HiveR"; version="0.2-27"; sha256="1c0isfiq8xw68qi3mk6m5dilsvbib7hy0ill9wga6kf6qndlfc49"; depends=[RColorBrewer plyr tkrgl jpeg png]; };
···
   HK80 = derive { name="HK80"; version="0.0.1"; sha256="1qhknrqpspxrdxzf5kakans94db58bbhgpblvpwcyw4jrjmm0ng7"; depends=[]; };
   HLMdiag = derive { name="HLMdiag"; version="0.2.5"; sha256="1yim9m5q1m112aj7zhsw345l32bdj7lbw2mqpcxhjzv1lcknm5lq"; depends=[lme4 ggplot2 plyr reshape2 MASS Matrix Rcpp]; };
   hlr = derive { name="hlr"; version="0.0-4"; sha256="04w1hzjfg2ly9vm9ynh676fy74d9ncy3a1mak209z2ddgr3m7r2y"; depends=[MASS]; };
-  HLSM = derive { name="HLSM"; version="0.2"; sha256="052qsdbfamlpwmxz7bwbnd956kibgvw3w6r7gvvp2s08g58arvy7"; depends=[MASS coda]; };
+  HLSM = derive { name="HLSM"; version="0.4"; sha256="115215fiaib6ndvzb3gn80l636ddxp0dxrnph8pnh16b3b6q2jnk"; depends=[MASS coda]; };
   hmeasure = derive { name="hmeasure"; version="1.0"; sha256="0wr0xq956glmhvy4yis3qq7cfqv9x82ci9fzx3wjvaykd16h0sx9"; depends=[]; };
-  Hmisc = derive { name="Hmisc"; version="3.14-4"; sha256="1jpz1sxvcip1k7yc8wkxf68fplr6dv24pavblxmi823xq1pjq21y"; depends=[lattice survival Formula latticeExtra cluster]; };
+  Hmisc = derive { name="Hmisc"; version="3.14-5"; sha256="0xbm60k3j0013s4k9vfpr29ngscf6ii5h9vxagxjjbln1k4f9ya1"; depends=[lattice survival Formula latticeExtra cluster rpart nnet acepack foreign]; };
   HMM = derive { name="HMM"; version="1.0"; sha256="0z0hcqfixx1l2a6d3lpy5hmh0n4gjgs0jnck441akpp3vh37glzw"; depends=[]; };
   HMMCont = derive { name="HMMCont"; version="1.0"; sha256="1drni4f72x83sprn65wnhw0pv1q8lfkgmxdr9h4rwv1accril85x"; depends=[]; };
   hmm_discnp = derive { name="hmm.discnp"; version="0.2-3"; sha256="1r9xxgsqh5pw9incldaxnsqhyanhd4jwm6w0ix1k43i53dw4diyr"; depends=[]; };
-  hmmm = derive { name="hmmm"; version="1.0-2"; sha256="057yfp1sgp1wvhdq0sfvs598zcq8dhrbqfc02lih5pnwacf96vpc"; depends=[quadprog MASS mvtnorm]; };
+  hmmm = derive { name="hmmm"; version="1.0-3"; sha256="0yjx5i13jbv7vzxn84m6305124ri7jnym0bxbdj46s6l7lw025a9"; depends=[quadprog MASS mvtnorm]; };
   HMMpa = derive { name="HMMpa"; version="1.0"; sha256="14r2axg42by49qm6avgv7g3xnc29bxlrni5fhc5vdz0wygkcrqhn"; depends=[]; };
   HMP = derive { name="HMP"; version="1.3.1"; sha256="1r39mq8j071khza37ck7w4kvk1di71hhn5m4wnx9dak7nlcq2nwx"; depends=[MCMCpack dirmult]; };
   HMPTrees = derive { name="HMPTrees"; version="1.2"; sha256="0agp8w7rzr1byj01di89r3qy1vb9inb2zgys78mg8jnk7axi925l"; depends=[ape]; };
···
   homals = derive { name="homals"; version="1.0-5"; sha256="1azrwvdzn379in2sz9d94w2f2xp0d6iiayrv0bws44kvdzr95aqm"; depends=[rgl ape scatterplot3d]; };
   homeR = derive { name="homeR"; version="0.1"; sha256="0yq93b3wkgbnwzpyhx9c73sb9xgz7m3z4p5rflk3lmc0p53h81g5"; depends=[]; };
   homtest = derive { name="homtest"; version="1.0-5"; sha256="1lnqlg3dwq174ic6dbjllysw5fjy5kvvgbl6gvabjmcs66z27fp0"; depends=[]; };
-  HotDeckImputation = derive { name="HotDeckImputation"; version="0.1.0"; sha256="1zj09fa5bqfw27zzard9a9a2aglg7ff8z2zzfyjcdz187l6g9gql"; depends=[]; };
+  hot_deck = derive { name="hot.deck"; version="1.0"; sha256="11dxj676y55p4n0c27l7f3ns8kk308f6b6lhwfpjqfz0wgysnfq9"; depends=[mice]; };
+  HotDeckImputation = derive { name="HotDeckImputation"; version="1.0.0"; sha256="0zb02wcpq09lr7lr4wcgrbw9x7jcvhi34g7f4s6h88zz7xg9daw5"; depends=[Rglpk]; };
   Hotelling = derive { name="Hotelling"; version="1.0-2"; sha256="0dzsqnn4c4av23qjnmacwc78i0xg355p1xwfmgipr04ivym0mqn0"; depends=[corpcor]; };
   hotspots = derive { name="hotspots"; version="1.0.2"; sha256="1cwcwin86y7afjhs8jwlz1m63hh70dcjag0msds4ngksvjh9gj2q"; depends=[lattice ineq]; };
   howmany = derive { name="howmany"; version="0.3-1"; sha256="045ck8qahfg2swbgyf7dpl32ryq1m4sbalhr7m5qdgpm62vz8h7f"; depends=[]; };
   HPbayes = derive { name="HPbayes"; version="0.1"; sha256="1kpqnv7ymf95sgb0ik7npc4qfkzc1zb483vwnjpba4f42jhf508y"; depends=[MASS mvtnorm corpcor numDeriv boot]; };
   hpcwld = derive { name="hpcwld"; version="0.4"; sha256="1vh5jvq9nbghsl59fi6v3nmsh0jmxq7pzbs3fgasz8c3jmjw50kp"; depends=[]; };
-  HPO_db = derive { name="HPO.db"; version="1.2"; sha256="04mys72qajp7cn0vhzr9mv388d5a69kjvkwxjjskz24k91xwn4vz"; depends=[]; };
   hpoPlot = derive { name="hpoPlot"; version="1.0"; sha256="0jd0imbhsw74gziafkzn7hrxz79llmpksspbnxnslm1mifl81www"; depends=[functional plotrix Hmisc]; };
-  HPOSim = derive { name="HPOSim"; version="1.2"; sha256="1bgakx9y1cqc54adm6d4zlqvd2smxq895bf68njsgj3ygrlglc2v"; depends=[HPO_db igraph]; };
   hqmisc = derive { name="hqmisc"; version="0.1-1"; sha256="0jcy2hb3dmzf9j4n92aq7247mx9w7n30wpsx0dkchqnjwlqwwncw"; depends=[]; };
   hrr = derive { name="hrr"; version="1.1.1"; sha256="17jzsgh2784y7jdwpa50v7qz99dw6k2n25sisnam6h1a39b96byn"; depends=[]; };
-  HSAUR = derive { name="HSAUR"; version="1.3-3"; sha256="0lf6z9fgmbdhpvz2dyni5wi1ri6y6fikkf1px03pirlswm1mbchj"; depends=[]; };
-  HSAUR2 = derive { name="HSAUR2"; version="1.1-10"; sha256="0r06abgiiwj3b9cd652hics2rzkslk1gplxv751501nn7k2qid7i"; depends=[]; };
-  HSAUR3 = derive { name="HSAUR3"; version="1.0-1"; sha256="1w1c3ypyvlfi95qg3xxdjfgxlykrcn3rly7z2mvpzkdx4dhi3kls"; depends=[]; };
+  HSAUR = derive { name="HSAUR"; version="1.3-4"; sha256="1y79ivzz7dy81q9vvsa55aldas1gfrz1in9c5v53gi40q6w9pkff"; depends=[]; };
+  HSAUR2 = derive { name="HSAUR2"; version="1.1-11"; sha256="18j12kj42x3myzkyxm11m9y314icavdald9y424pwpyjx4p51v1v"; depends=[]; };
+  HSAUR3 = derive { name="HSAUR3"; version="1.0-2"; sha256="0anip378k6zagk722m7fnx5lsms6pk7fs375pdywy3zcr7p9pm4z"; depends=[]; };
   hSDM = derive { name="hSDM"; version="1.4"; sha256="1jq6hdnyv446ng62srip0b48kccf0qw3xqym3fprg74mjdy3inqr"; depends=[coda]; };
   hsicCCA = derive { name="hsicCCA"; version="1.0"; sha256="1d4lkjrihwhl3jrsj7250ccd90nfwpllyavc3mp15fhcy2jnjci8"; depends=[]; };
   hsmm = derive { name="hsmm"; version="0.4"; sha256="1fh8c5kfv4brygdq6bfkrhrhkm99mxl4ljb1mhp9nf2bjlla11mc"; depends=[mvtnorm]; };
   hsphase = derive { name="hsphase"; version="2.0.0"; sha256="04zhqnrrzhg1kqxf251q7iglazsj28dqqvhvch472925xf7dnap3"; depends=[snowfall Rcpp]; };
   HSROC = derive { name="HSROC"; version="2.1.7"; sha256="05gixmzmgdply9zhjpss54b50ch4b8586cik6c49naxcqxr0y5vd"; depends=[lattice coda MASS MCMCpack]; };
   HSSVD = derive { name="HSSVD"; version="1.1"; sha256="0kpfcb9ibwhdanc56ysbvx3zirhbrxqyrgpbmi9yvnc5m2c8377d"; depends=[bcv]; };
-  htmltools = derive { name="htmltools"; version="0.2.4"; sha256="0957n22dfbhy0fc1hnf65jghdfiv1zj0kd6x5byafv54aby0bzqy"; depends=[digest]; };
+  htmltools = derive { name="htmltools"; version="0.2.6"; sha256="1gp6f6388xy3cvnb08q08vraidjp740gfxlafdd19m2s04v5hncz"; depends=[digest]; };
   HTMLUtils = derive { name="HTMLUtils"; version="0.1.5"; sha256="12r8x7b944lbzz3f4j6w88szq6j9gscbss3f5bzpisw33sr4wgx3"; depends=[R2HTML]; };
   hts = derive { name="hts"; version="4.4"; sha256="1dpm669lc4khjkcs49m1nh7i61sclsqy7xbcn4mqqjhfgs7sg7sk"; depends=[forecast SparseM]; };
-  HTSCluster = derive { name="HTSCluster"; version="2.0.3"; sha256="1c3gk6q87fl7yfikpr7q6h9mp8mjm9qmzm1vxxilfl5qm9d8f92p"; depends=[plotrix ggplot2 RColorBrewer poisson_glm_mix]; };
-  HTSDiff = derive { name="HTSDiff"; version="1.0.2"; sha256="0l1shki2jkbx22l3rksdk1np9rgv40594ldn2rwhrzz6k2vz15by"; depends=[plotrix HTSCluster poisson_glm_mix]; };
-  httpRequest = derive { name="httpRequest"; version="0.0.9"; sha256="1s71lpxv5n1syffckxnnxm5470b2lb2l7pikcm1r2j21j08g807f"; depends=[]; };
-  httpuv = derive { name="httpuv"; version="1.3.0"; sha256="0fs2saz9g17069hkrh6r3wlzsbljv2dvq6sdlwh54dlm6skp7jm6"; depends=[Rcpp]; };
-  httr = derive { name="httr"; version="0.4"; sha256="18ikpbjczjci8di9mwcjkm10fcl9jn40kp4i33kidrmamyryq4zq"; depends=[RCurl stringr digest jsonlite]; };
+  HTSCluster = derive { name="HTSCluster"; version="2.0.4"; sha256="1kvq118hqxc81n88g4bq10lh84dydrqqhzig246wf3f97ajvq7y0"; depends=[capushe poisson_glm_mix plotrix]; };
+  HTSDiff = derive { name="HTSDiff"; version="1.0.5"; sha256="03g5hwjgg7g79lskwrgd32gy34v0fn8yh95zndid0qm6i7vwip9w"; depends=[plotrix HTSCluster poisson_glm_mix]; };
+  httpRequest = derive { name="httpRequest"; version="0.0.10"; sha256="0f6mksy38p9nklsr44ki7a79df1f28jwn2jfyb6f9kbjzh98746j"; depends=[]; };
+  httpuv = derive { name="httpuv"; version="1.3.2"; sha256="0vp3bz1nxi0ladlgi1r6wd480y0m2m0gsba2hrs73s9b8afrfh6v"; depends=[Rcpp]; };
+  httr = derive { name="httr"; version="0.5"; sha256="074z78zv3nif53lsmn2k6hwv3yz4xr21wacb53s3f6hnmms8qvfp"; depends=[RCurl stringr digest jsonlite]; };
   huge = derive { name="huge"; version="1.2.6"; sha256="11njfd4i8q950apga6sdk84p4wk4qvp8bpg6yz9lgjrgj2hn14n2"; depends=[Matrix lattice igraph MASS]; };
   HUM = derive { name="HUM"; version="1.0"; sha256="1bq74l88jvscmq9ihv5wn06w2wng073ybvqb2bdx2dmiqlpv6jw2"; depends=[gtools Rcpp rgl]; };
   humanFormat = derive { name="humanFormat"; version="1.0"; sha256="0zwjbl8s5dx5d57sfmq6myc6snximc56zl88h8y1s1jqphyn9sir"; depends=[testthat]; };
···
   HWEBayes = derive { name="HWEBayes"; version="1.4"; sha256="1rbffx6pn031a278ps9aqxcaq8yi73s5kf60za143ysbfxv9dphw"; depends=[MCMCpack mvtnorm]; };
   HWEintrinsic = derive { name="HWEintrinsic"; version="1.2.1"; sha256="1sg5lrc6kl5rr6f5awp100qpd1679745kixasiddiggzd8fhgb7q"; depends=[]; };
   HW_pval = derive { name="HW.pval"; version="1.0"; sha256="14nmyqw2d9cmn64789yc54fmiqanh6n1dizp7vj94h7b0jwq63yy"; depends=[]; };
-  hwriter = derive { name="hwriter"; version="1.3"; sha256="12hs78m2pzjhjpv43qdc3lazf5qi5w1vpzqign6qpdrhm85xgvhi"; depends=[]; };
+  hwriter = derive { name="hwriter"; version="1.3.2"; sha256="0arjsz854rfkfqhgvpqbm9lfni97dcjs66isdsfvwfd2wz932dbb"; depends=[]; };
   hwriterPlus = derive { name="hwriterPlus"; version="1.0-3"; sha256="06hq493v702hy2mv73glav4az2wphzy3lqqkxjkpjpab00xc42d5"; depends=[hwriter TeachingDemos]; };
   HWxtest = derive { name="HWxtest"; version="1.0.3"; sha256="0qw632djkfx94d8rxgpwmbb4zwwlhgzakjj657wcd6gfi90i72ix"; depends=[]; };
   hybridEnsemble = derive { name="hybridEnsemble"; version="0.1.1"; sha256="1hn6zfz22mgxv5qpwdgmn7a9snha7hdkbbqq3xicy37j8xypsab5"; depends=[kernelFactory ada rpart ROCR nnet e1071 NMOF GenSA Rmalschains pso AUC soma genalg reportr nnls quadprog tabuSearch glmnet]; };
···
   hydroGOF = derive { name="hydroGOF"; version="0.3-8"; sha256="1ljk2dk5ydsg7qdizyzkbw0b2zdhnb3x9h965d94ygzg8nw5kbak"; depends=[zoo hydroTSM xts]; };
   HydroMe = derive { name="HydroMe"; version="2.0"; sha256="1a1d3lay94mzwk8n22l650h3p133npdf4aj63zgrdw4760p54rqf"; depends=[nlme minpack_lm]; };
   hydroPSO = derive { name="hydroPSO"; version="0.3-4"; sha256="12md94g78m7m1np36sadx0wxpb149pn5gd8yj2kw7fphb8g6a218"; depends=[Hmisc sp lattice zoo lhs]; };
-  hydrostats = derive { name="hydrostats"; version="0.2"; sha256="1sp8lp4rqkq5ivlfdg26k6azmxvr8ma0ggkcj10zdl0q85j7ldj2"; depends=[]; };
+  hydrostats = derive { name="hydrostats"; version="0.2.1"; sha256="07pi1q4g5bhjq9vd31rvakqbrspk1yxhysds904b0cmax9wwlqlx"; depends=[]; };
   hydroTSM = derive { name="hydroTSM"; version="0.4-2-1"; sha256="0z5xw25w2fn67x2dw61msfdnp2dr2s2yi525fcjxn77339x9ksfr"; depends=[zoo xts e1071 gstat automap sp]; };
   HyperbolicDist = derive { name="HyperbolicDist"; version="0.6-2"; sha256="1wgqbx9ascyk6gw1dmvfz6hljvbh49gb9shr9qgf22qbq83waiva"; depends=[]; };
   hyperdirichlet = derive { name="hyperdirichlet"; version="1.4-9"; sha256="03c2xgfhfbpn1za84ajhvm0i5cpmfnz1makidrr2222addgyp9zx"; depends=[aylmer abind mvtnorm cubature]; };
-  hypergea = derive { name="hypergea"; version="1.0.1"; sha256="17fi0sjgyjydd327wghicpys09bpkil4840d9zv779dj9zk2slj9"; depends=[]; };
+  hypergea = derive { name="hypergea"; version="1.2.3"; sha256="13a8r7f2qq7wi0h7jrg29mn573njzi1rwna0ch9sj8sdy8w26r6w"; depends=[]; };
   hypergeo = derive { name="hypergeo"; version="1.2-5"; sha256="00rqyw7xc4q6lqg0vy1jkb4rc1xbdgvqsmx58n6w2006zni54ss1"; depends=[elliptic contfrac]; };
   hyperSpec = derive { name="hyperSpec"; version="0.98-20140523"; sha256="1ypmq5xgcjqrq9i8f08csjqffv9qfpfkvrbawlf1ds7i49h6jq28"; depends=[lattice mvtnorm]; };
-  hypervolume = derive { name="hypervolume"; version="1.0.1"; sha256="1ja3wx8k1hbcgwinbbs5m2amayj2wdmkk2kqaywrvgpm2k1f40i5"; depends=[Rcpp rgl MASS geometry igraph]; };
+  hypervolume = derive { name="hypervolume"; version="1.0.2"; sha256="051623cxlqs7h4zf2a4adhcyqawsap8xszv6naj6m2zss33b4md3"; depends=[Rcpp rgl MASS geometry igraph]; };
   HyPhy = derive { name="HyPhy"; version="1.0"; sha256="0994ymv7sswbp8qw3pay34s926cflw2hq2gnchw7rknybvlsrinq"; depends=[ape R_utils]; };
   hypothesestest = derive { name="hypothesestest"; version="1.0"; sha256="0g8sm386m1zm9i3900r62x83wb600cy8hqk7dlvbx6wcgrxg82sm"; depends=[]; };
   hypred = derive { name="hypred"; version="0.4"; sha256="08nqgw0h3zh4vyhfd1cngr6snz5n7skj3d9rg2qccz9pnjp7j1ab"; depends=[]; };
···
   hzar = derive { name="hzar"; version="0.2-5"; sha256="000l4ki3hvznnhkxc5j422h5ifnsfqalv666j48yby1hsf1lc3kg"; depends=[MCMCpack foreach coda]; };
   IASD = derive { name="IASD"; version="1.0.7"; sha256="0a25sd82fxnmz3f4iaxhc69cdfb7xmh7wi79wv11sbw9cv2pl7kr"; depends=[]; };
   IAT = derive { name="IAT"; version="0.2"; sha256="0byivq2298sjvpsz5z1w7r31h6z2jqpip40z8r2alygbgwwa48pd"; depends=[data_table ggplot2]; };
-  ibd = derive { name="ibd"; version="1.1"; sha256="1p7dw74qpbdalb8vq8jixjhizjl2zc8wrl28mzavw89lbragvi6k"; depends=[lpSolve MASS]; };
+  iBATCGH = derive { name="iBATCGH"; version="1.1"; sha256="0nl5l17pm92ns40qzkmayc48a6i4j8w0562sp5jxyi95y4vb4aiy"; depends=[Rcpp msm]; };
   IBDhaploRtools = derive { name="IBDhaploRtools"; version="1.7"; sha256="1jg2vrs9ly7l8yidw8ppa41v657jhjcj7n27zi1f2vsh3vmjri0m"; depends=[]; };
   ibdreg = derive { name="ibdreg"; version="0.2.5"; sha256="1kaa5q1byi30wzr0mw4w2cv1ssxprzcwf91wrpqwkgcsdy7dkh2g"; depends=[]; };
   IBDsim = derive { name="IBDsim"; version="0.9-4"; sha256="0cpabz7mnhsrmjrgb23zs5anjrkhwc2005b2inl6p93l47i81fps"; depends=[paramlink]; };
   ibeemd = derive { name="ibeemd"; version="1.0.1"; sha256="115z13q02gzixziknix2l53mi12zzg30ra9h35pv6qzrr11ra1ic"; depends=[fields deldir rgeos sp spdep]; };
+  ibelief = derive { name="ibelief"; version="1.0"; sha256="1mcmq1zpj1f6alhnsznb27iknp7dzdsd25di8a64hw5c3cnx3xay"; depends=[]; };
   IBHM = derive { name="IBHM"; version="1.1-11"; sha256="1m0zxlybcak2v5c4spgaa39ngb2hryak4xd875jryk1dcnk9c702"; depends=[DEoptim cmaes Rcpp]; };
   Iboot = derive { name="Iboot"; version="0.1-1"; sha256="1fahh86kgv2axj2qg14n87v888sc0kb567s6zr3fh5zv361phwkq"; depends=[]; };
   ibr = derive { name="ibr"; version="1.4.5"; sha256="0nw2j232br06l30v3cn4qcr25vbh911v2mz7nfail40sqxc6wwc4"; depends=[]; };
-  IBrokers = derive { name="IBrokers"; version="0.9-10"; sha256="1kpmmiar5762byy6pl8x8drpsw8as9ilbqzgqhfrvj5rd31mylz6"; depends=[xts]; };
+  IBrokers = derive { name="IBrokers"; version="0.9-12"; sha256="0mhh4kgwrncrcysvnvah6xc7fhx5ywjzn258cs9xj9kzns0jblk6"; depends=[xts zoo]; };
   iBUGS = derive { name="iBUGS"; version="0.1.4"; sha256="0vsxy8pnbix0rg7ksgywx7kypqb5ngkxhldh3cisjkvdv638ybps"; depends=[R2WinBUGS gWidgetsRGtk2]; };
-  iC10 = derive { name="iC10"; version="1.0.2"; sha256="17pgm3k1zh502bvdcc86wl8fsd1mbcl6hw2rqhpy0c3bhabrixki"; depends=[pamr CONOR iC10TrainingData]; };
-  iC10TrainingData = derive { name="iC10TrainingData"; version="1.0.0"; sha256="0il8caxwinjpcf4gfimi07b7ccv5v916s2968vy2vdx6439y1rss"; depends=[]; };
+  iC10 = derive { name="iC10"; version="1.1.1"; sha256="1awmg2m9f7lq5p16mzlmz2sw680vbi70j4ksxx8d385rhmy6v5w6"; depends=[pamr iC10TrainingData]; };
+  iC10TrainingData = derive { name="iC10TrainingData"; version="1.0.1"; sha256="1x1kgxiib9l7whm2kmbv1s912hgpl7rdpqpn67nlkiswnr27hqn4"; depends=[]; };
   IC2 = derive { name="IC2"; version="1.0-1"; sha256="03jjb62msxjxdg9l3zd1ns0d2w37hkxy5pnjgaywxw3vfk4zwfj9"; depends=[]; };
   ic50 = derive { name="ic50"; version="1.4.2"; sha256="1a5ddmbdfr3ls132fvalbkh4yaawv9k58rgpy54s5qddrm6aas2s"; depends=[]; };
-  icamix = derive { name="icamix"; version="1.0"; sha256="1ain8fnyy4bj306zcli1c3d50sqckg88wnm0ppni0crwxvqcvvkm"; depends=[Rcpp]; };
+  ica = derive { name="ica"; version="1.0-0"; sha256="009xv1ycgbnw6ysx1wxrgygny7qa2wd2mcjrg2fwxg958mzyrx4z"; depends=[]; };
+  icamix = derive { name="icamix"; version="1.0.1"; sha256="06jaznzgixglbrrmvmp3cnghdldv30h5nfjghvdymia27m7ssdrr"; depends=[Rcpp]; };
   icaOcularCorrection = derive { name="icaOcularCorrection"; version="3.0.0"; sha256="1vmvarc2apipd0vlhprc5wpgh8i38m5myj1gqdymjrnky0azq17f"; depends=[fastICA mgcv]; };
-  icapca = derive { name="icapca"; version="1.0"; sha256="1m8z5444y06wadc63zlb1x3qfgam81j78nvzzxlpxijydzh8xla8"; depends=[]; };
+  icapca = derive { name="icapca"; version="1.1"; sha256="131gdrk8vsbac0krmsryvsp21bn9hzxqxq847zn16cxjf6y5i3xb"; depends=[]; };
   ICC = derive { name="ICC"; version="2.2.1"; sha256="1xl8x8ddbrk8ma57mybmmv9m096wlpbas7hsmd2c6qzcrlz6i7wa"; depends=[]; };
   icd9 = derive { name="icd9"; version="0.5"; sha256="128gv2yxylncmbr6b1qz82ys7aanqxf35psrmrh2i4l84w3w5l8g"; depends=[memoise]; };
   ICE = derive { name="ICE"; version="0.69"; sha256="04p8lakaha28mdh965w0ppyxfrz5ssi1n9xifvsbn3ihdra67rip"; depends=[KernSmooth]; };
···
   identity = derive { name="identity"; version="0.2-1"; sha256="1j5wb5cj5j49in2g6r1shdm4ri4cfzj22hpqazvcmq4dm291sdi9"; depends=[]; };
   IDPmisc = derive { name="IDPmisc"; version="1.1.17"; sha256="0nbwdyg9javjjfvljwbp2jl0c6414c11zb2pirmm5pmimaq9vv0q"; depends=[lattice]; };
   IDPSurvival = derive { name="IDPSurvival"; version="1.0"; sha256="1v1w0i74b065b4qc302xbdl5df7qx9z8jmbc9cn46fqm1hh2b6d7"; depends=[Rsolnp gtools survival]; };
-  idr = derive { name="idr"; version="1.1.1"; sha256="0shwwyvc4j32grxanhyqk66aykzy5bzic2004krvzbmcb5cr1sgb"; depends=[]; };
+  idr = derive { name="idr"; version="1.2"; sha256="05nvgw1xdg670bsjjrxkgd1mrdkciccpw4krn0zcgdf2r21dzgwb"; depends=[]; };
   iDynoR = derive { name="iDynoR"; version="1.0"; sha256="01702vl10191mbq2wby1m0y6h8i6y6ic4pa83d27cg3yccsrhziz"; depends=[XML vegan]; };
   ieeeround = derive { name="ieeeround"; version="0.2-0"; sha256="0xaxrlalyn8w0w4fva8fd86306nvw3iyz44r0hvay3gsrmgn3fjh"; depends=[]; };
   ifa = derive { name="ifa"; version="7.0"; sha256="1cxafd7iwvyidzy27lyk1b9m27vk785ipj9ydkyx9z1v0zna2wnl"; depends=[mvtnorm]; };
   iFad = derive { name="iFad"; version="3.0"; sha256="0jrl9bayihp3wb4k5w9kc71qlsdxk7vl83ydfibx2bg79c4hf3cs"; depends=[Rlab MASS coda ROCR]; };
   ifs = derive { name="ifs"; version="0.1.4"; sha256="0fzani8rnn4rdwlghq967hhi4zfjnk3gwpk3v6wys738xj7yfwp1"; depends=[]; };
-  ifultools = derive { name="ifultools"; version="2.0-0"; sha256="0xgd4j09kixsv653cj5h1kyf9jfzz8nhc85xixbcpz3yn0fqbn00"; depends=[splus2R MASS]; };
+  ifultools = derive { name="ifultools"; version="2.0-1"; sha256="16lrmajyfa15akgjq71w9xlfsr4y9aqfw7y0jf6gydaz4y6jq9b9"; depends=[splus2R MASS]; };
   iGasso = derive { name="iGasso"; version="1.2"; sha256="123487slizsmw5b0imwqll8n03navx30kvawr6jfibbjfdd8vfn7"; depends=[lattice CompQuadForm]; };
   IgorR = derive { name="IgorR"; version="0.7.1"; sha256="1ahj1ckzjffsskicdy2b70pzx5cn2r0s22yg1ajwiyy4ykwcg4pk"; depends=[bitops]; };
   igraph = derive { name="igraph"; version="0.7.1"; sha256="1nvb30zjjw861idbd8zap9qqg22k87zdi6qqvjf1s29v7hkx7kq7"; depends=[Matrix]; };
   igraphdata = derive { name="igraphdata"; version="0.2"; sha256="0hm757fc2snqlav3wx1vdmwy2gr5cskig97c2zlvk88sfwgx4i2m"; depends=[]; };
   igraphtosonia = derive { name="igraphtosonia"; version="1.0"; sha256="0vy9jnpjp68l8s0hi1l57j9p41c543h3iqv16pwl550f38zqp8j6"; depends=[igraph]; };
+  iki_dataclim = derive { name="iki.dataclim"; version="1.0"; sha256="1yhvgr8d3j2r8y9c02rzcg80bz4cx58kzybm4rch78m0207wqs7p"; depends=[zoo lubridate climdex_pcic PCICt]; };
   IM = derive { name="IM"; version="1.0"; sha256="1f1vr5zfqnanc5xmmlfkjkvxwbyyysi3mcvkg95p8r687a7zl0cx"; depends=[png jpeg bmp]; };
   Imap = derive { name="Imap"; version="1.32"; sha256="0b4w0mw9ljw6zxwvi0qzb08yq9n169lzgkdcwizrd07x9k9xjxs7"; depends=[]; };
   imguR = derive { name="imguR"; version="1.0.0"; sha256="0yhlir0qxi6hjmqlmmklwd4vkymc5bzv9id9dlis1fr1f8a64vwp"; depends=[RCurl httr png jpeg]; };
···
   imputeLCMD = derive { name="imputeLCMD"; version="1.0"; sha256="0avgl8wwwsz27z439y415lv4h33af58db084mjr236y1z9sfhdyw"; depends=[tmvtnorm norm]; };
   imputeMDR = derive { name="imputeMDR"; version="1.1.2"; sha256="0ds5a4wav9vb9z5nji8hv5l76310rd970xf702fd0ckx1sh6rgd7"; depends=[]; };
   imputeR = derive { name="imputeR"; version="1.0.0"; sha256="18rx70w7xb33m84ifxl3p599js78pa748c9lmlkic6yqrgsabcip"; depends=[caret reshape2 glmnet pls rda Cubist ridge gbm mboost rpart]; };
-  imputeYn = derive { name="imputeYn"; version="1.1"; sha256="12hdx7bwpm4jickpbj7cswjsl6f772ibzaf3d79q24n24ymw576h"; depends=[quadprog emplik mvtnorm]; };
+  imputeYn = derive { name="imputeYn"; version="1.2"; sha256="08i3bwzmd4cn3cbwbrcjh3b75m7xms9m3dpmym99g08282cmljwx"; depends=[quadprog emplik mvtnorm survival]; };
   in2extRemes = derive { name="in2extRemes"; version="1.0-1"; sha256="0k5qczs54b7bl71my8xmnqly91g7c5skj0lm2g8dk4hgrx6wwsrf"; depends=[extRemes]; };
   inarmix = derive { name="inarmix"; version="0.4"; sha256="11a1vaxq22d5lab07jp5pw0znkaqj6bmkn6vsx62y6m4mmqk04yr"; depends=[Matrix Rcpp]; };
   incReg = derive { name="incReg"; version="1.0"; sha256="1kckx64hn8g9wvjg7g9xild5hclim1rs7z2m7rgmbdwlbayxpwgv"; depends=[car]; };
   IndependenceTests = derive { name="IndependenceTests"; version="0.2"; sha256="04qfh2mg9xkfnvp6k7w1ip4rb663p3pzww9lyprcjvr3hcac7gqa"; depends=[xtable]; };
-  indicspecies = derive { name="indicspecies"; version="1.7.2"; sha256="1spf70a42kc5yg62zi9a2dvdyh5npc67bcln4zqcg7dyachw3f2n"; depends=[permute sp rgeos]; };
+  indicoio = derive { name="indicoio"; version="0.3"; sha256="04c2j4l103fiiibf83z7iq95wfnlv9rj46cyp9xy68bzqkbwdi3m"; depends=[httr rjson stringr png]; };
+  indicspecies = derive { name="indicspecies"; version="1.7.3"; sha256="142r5csd0qyd05zc639zj53lcifgy14mx6j7h18gz9i67bdqa4ma"; depends=[permute sp rgeos]; };
   ineq = derive { name="ineq"; version="0.2-13"; sha256="09fsxyrh0j7mwmb5hkhmrzgcy7kf85jxkh7zlwpgqgcsyl1n91z0"; depends=[]; };
   InfDim = derive { name="InfDim"; version="1.0"; sha256="0rh3ch0m015xjkxy08vf9pc6q7azjc6sgicd2j6cwh611pqq39wq"; depends=[]; };
   inference = derive { name="inference"; version="0.1.0"; sha256="0j92isfkbhk13yx2hd3a5dd7ikcbgjc04zisd1n5kmg6ajw2aj6r"; depends=[sandwich]; };
···
   InPosition = derive { name="InPosition"; version="0.12.7"; sha256="1f7xb2kxikmja4cq7s1aiwhdq27zc6hghjbliqqpm8ci8860lb8p"; depends=[prettyGraphs ExPosition]; };
   insideRODE = derive { name="insideRODE"; version="2.0"; sha256="1ffndk8761cpkririb3g1qsq9nwmh82lcrpql9i5fksdprvdjzcw"; depends=[deSolve nlme lattice]; };
   insol = derive { name="insol"; version="1.1.1"; sha256="0zbawkp4qb0kqb7y9ibiyy8sa9rfgbzwmcdswx6s87p0h7brrqn6"; depends=[]; };
+  insuranceData = derive { name="insuranceData"; version="1.0"; sha256="0wryh8i1v3bnpbqn6d6dpxr9bwwl6mnh5cb5igz0yanh4m1rx96w"; depends=[]; };
   intamap = derive { name="intamap"; version="1.3-37"; sha256="17l1bifks0vsk0a3bj2g4w8qrvhmdh0p145kmd09223x9yc4mc9v"; depends=[sp gstat automap mvtnorm MASS evd]; };
-  intamapInteractive = derive { name="intamapInteractive"; version="1.1-10"; sha256="073k6sdds40fmlbw1xnp3x5sc9qdyq2s1bhp7av4jjm930hsvsrn"; depends=[intamap spcosa spatstat automap gstat]; };
+  intamapInteractive = derive { name="intamapInteractive"; version="1.1-10"; sha256="073k6sdds40fmlbw1xnp3x5sc9qdyq2s1bhp7av4jjm930hsvsrn"; depends=[intamap spcosa automap gstat]; };
   intcox = derive { name="intcox"; version="0.9.3"; sha256="1m1lzmymh2pk570k6nxq3nj7wxkvs1s3nvz8cb456fnv72ng8fap"; depends=[survival]; };
   integrOmics = derive { name="integrOmics"; version="2.55"; sha256="1c9vkhvnndhs3h9qzcg3pvizjk9rhgk8gccaxh33spgr4rql8vcw"; depends=[]; };
   Interact = derive { name="Interact"; version="1.1"; sha256="1g9zhafdpr7j410bi8p03d8x9f8m3n329x8v01yk15f65fp7pl1d"; depends=[]; };
···
   intergraph = derive { name="intergraph"; version="2.0-0"; sha256="0y5cd7y08p86fxm4zqraj81sj5a5h7725wvzcyxd8p1q3ky2sj9f"; depends=[network igraph]; };
   Interpol = derive { name="Interpol"; version="1.3.1"; sha256="1598lnnrcxihxysdljphqxig15fd8z7linw9byjmqypwcpk6r5jn"; depends=[]; };
   Interpol_T = derive { name="Interpol.T"; version="2.1.1"; sha256="1fbsl1ypkc65y6c0p32gpi2a2aal8jg02mclz7ri57hf4c1k09gz"; depends=[date chron]; };
-  InterVA4 = derive { name="InterVA4"; version="1.4"; sha256="06yq0zfpakw4ifg8i5jazsbh6k62ksnpw7b02kyc2phi67gvj84k"; depends=[]; };
+  InterVA4 = derive { name="InterVA4"; version="1.5"; sha256="0w2klq9dara941d4xz85qrq8dcp7vpc6rrz2k9ry01rsnpdzzybh"; depends=[]; };
   interval = derive { name="interval"; version="1.1-0.1"; sha256="1lln9jkli28i4wivwzqrsxvv2n15560f7msjy5gssrm45vxrxms8"; depends=[survival perm MLEcens]; };
-  intervals = derive { name="intervals"; version="0.14.0"; sha256="0hqifkb8pbx0v42z3s78nm38b3ixi0vycq8kba4mv3w8v7zcfbxb"; depends=[]; };
+  intervals = derive { name="intervals"; version="0.15.0"; sha256="0lvxaq5ia7hj65n00awz454a2vdxpskxjw45wsakgh0sc60hk8yz"; depends=[]; };
   interventionalDBN = derive { name="interventionalDBN"; version="1.2.2"; sha256="0wpp4bfi22ncvl0vdivniwwvcqgnpifpgxb4g5jbyvr0z735cd9w"; depends=[]; };
   IntLik = derive { name="IntLik"; version="1.0"; sha256="13ww5bsbf1vnpaip0w53rw99a8hxzziibj7j66cm31jmi8l6fznf"; depends=[maxLik]; };
   intpoint = derive { name="intpoint"; version="1.0"; sha256="0zcv64a0clgf1k3ylh97q1w5ddrv227846gy9a68h6sgwc0ps88b"; depends=[]; };
···
   intReg = derive { name="intReg"; version="0.1-2"; sha256="1sm7v4fnfsdhyqr3q8dms0ifwb00hzf3x1g0fpm7xldlqc3wf6pr"; depends=[maxLik sets sets]; };
   intRegGOF = derive { name="intRegGOF"; version="0.85-1"; sha256="0fyvhl6jmi6krfbimsq61dhixlz9h9jxk4yjvwbx2vl8d9fnnr54"; depends=[]; };
   introgress = derive { name="introgress"; version="1.2.3"; sha256="1j527gf7pmfy5365p2j2jbxq0fb0xh2992hj4d7dxapn4psgmvsk"; depends=[nnet genetics RColorBrewer]; };
-  intsvy = derive { name="intsvy"; version="1.3"; sha256="0743kn95njgv31yhl21h35k9fv78czdw3w669wsvzf35gasxak3y"; depends=[memisc foreign plyr]; };
+  intsvy = derive { name="intsvy"; version="1.4"; sha256="0c50ivmy9g99zaqrm2qv915gwzlwd66baiqhlv0fcz50pqs3z4zk"; depends=[memisc foreign plyr ggplot2 reshape]; };
   InventorymodelPackage = derive { name="InventorymodelPackage"; version="1.0.2"; sha256="1w35idsagl9v93ci3qmal3xbf11sy6h1k7xnv25c59ivfnpjpkva"; depends=[e1071]; };
-  investr = derive { name="investr"; version="1.1.0"; sha256="1r01dk2xkg2j56xig7yrczbks2kllcszwdj9ih3xxxk16hgb1cgd"; depends=[]; };
+  investr = derive { name="investr"; version="1.1.2"; sha256="1nz6vkpf409vdz5jn4cni8x6ic9nqxdg5xjknqvf137pz1bs2dqx"; depends=[nlme]; };
   invGauss = derive { name="invGauss"; version="1.1"; sha256="0l93pk2sh74dd6a6f3970nval5p29sz47ynzqnphx0wl3yfmmg9c"; depends=[survival optimx]; };
   io = derive { name="io"; version="0.1"; sha256="1yvyxp45y1v1lrksga5gfjqb2w509l3v817830ya5f740h517l74"; depends=[]; };
+  iosmooth = derive { name="iosmooth"; version="0.91"; sha256="03kyzhcl5lipaiajs53dc8jaazxv877nl0njbq88cp4af3gd6s82"; depends=[]; };
   ipdmeta = derive { name="ipdmeta"; version="2.4"; sha256="0k9wqpmrvqdh73brmdzv86a2dbyddjyyyqzqgp1vqb3k48k009s2"; depends=[nlme]; };
   ipdw = derive { name="ipdw"; version="0.2-1"; sha256="18qvw635dy9ddz16nn0j4s0n97nbyw7yb4a8v1m0f5v9prggj7py"; depends=[gdistance raster]; };
   ipfp = derive { name="ipfp"; version="1.0"; sha256="1hpfbgygnpnl3fpx7zl728jyw00y3kbbc5f0d407phm56sfqmqwi"; depends=[]; };
···
   isa2 = derive { name="isa2"; version="0.3.3"; sha256="0czviglmbb7hmhghrg4hla4xhbjr98a5ivqkbq70rnfmqzffcxcz"; depends=[]; };
   ISBF = derive { name="ISBF"; version="0.2"; sha256="0vhxazbm56pli8m931l1kkica4spf50yclr3yhbwx3539775421a"; depends=[]; };
   iScreen = derive { name="iScreen"; version="1.0"; sha256="09iyimzrx7510xamhl6w1f7p6j096wh5yck9zgwbk87mvabqynmg"; depends=[maptree]; };
-  isdals = derive { name="isdals"; version="2.0-1"; sha256="0r4dwfz18aai38wg213pn3gny9sh42nm19p6swxmzrkrigiwy4qa"; depends=[]; };
+  isdals = derive { name="isdals"; version="2.0-4"; sha256="15p432fskdz2r8523cw122mfhvrq8vdsdsrd0kz9yfin4b5z3zfh"; depends=[]; };
   ISDA_R = derive { name="ISDA.R"; version="1.0"; sha256="0w6p2iy6s7fy8pw2cf4b5zhqcgjjwd5bkax1aqflaaj4ppmfx64v"; depends=[scatterplot3d]; };
-  IsingFit = derive { name="IsingFit"; version="0.2.0"; sha256="03858wnz9si8r9qlwg5hx0xai4kfn6nnh0mfmias6f5wkgjj0niv"; depends=[qgraph Matrix glmnet]; };
+  IsingFit = derive { name="IsingFit"; version="0.3.0"; sha256="0imgj3g6sankzmycjkzzz3bgai3jjycgsinhs5zy9k4vgqjg27d6"; depends=[qgraph Matrix glmnet]; };
   isingLenzMC = derive { name="isingLenzMC"; version="0.2.1"; sha256="1g1rz8p9vw2jnx6qw9mb614fpkv5bd7cndwcz0mva33y5shhnibl"; depends=[]; };
   IsingSampler = derive { name="IsingSampler"; version="0.1.1"; sha256="068fy16fw2ja25mllyw4z3bn17pxdq17zg75zwlwmljds6psa1gk"; depends=[Rcpp plyr]; };
   ISLR = derive { name="ISLR"; version="1.0"; sha256="0gmhvsivhpq3x8a240lgcbv1qzdgf6wxms4svak1501clc87xc6x"; depends=[]; };
···
   IsoGene = derive { name="IsoGene"; version="1.0-22"; sha256="097xxgqdk2j7y22qflrgss9pgbyg01rcw5088b43pbv3sc85fqcs"; depends=[Iso xtable ff]; };
   isopam = derive { name="isopam"; version="0.9-12"; sha256="16zkw6y57i46w6v6z8zh0p2mapqry35ibl54vpb5mwp6six2hklk"; depends=[vegan cluster]; };
   isopat = derive { name="isopat"; version="1.0"; sha256="0fznvgycyd35dh7pbq1xhp667gsficlmycn5pcrqcbs89069xr1s"; depends=[]; };
-  isotone = derive { name="isotone"; version="1.0-1"; sha256="1miq1d35kl5br8jl0lv2jjn8nbhjzy92lqd4jzgi374g7cxyclp1"; depends=[]; };
+  isotone = derive { name="isotone"; version="1.0-2"; sha256="0qcad691c1dk61a75813hxbc61jllvfc3j21gn85f0kcf4hn6dnz"; depends=[]; };
   isotonic_pen = derive { name="isotonic.pen"; version="1.0"; sha256="1lgw15df08f4dhrjjfr0jqkcvxwad92kflj2px526pcxwkj7cj3i"; depends=[coneproj Matrix]; };
   IsotopeR = derive { name="IsotopeR"; version="0.4.7"; sha256="18gwmh4nprj4z0ar1w8npj2ymxihw5ydwa33g25mimjk8y2cs0x5"; depends=[coda fgui runjags]; };
   ISOweek = derive { name="ISOweek"; version="0.6-2"; sha256="1f1h8pgjaa14cvaj8ldl87b4vslxwvyfj46m0hkylwp73sv3g2mm"; depends=[stringr]; };
···
   its = derive { name="its"; version="1.1.8"; sha256="1g9qmdrw7qiw0xiryf7bf5m9prrba7r11jyzprzdglc1akizav8a"; depends=[Hmisc]; };
   itsmr = derive { name="itsmr"; version="1.5"; sha256="0l9m5is6d6pkpfkihx0jir5iv8zmqqav8vh9bkkpqv5iz61p4kxb"; depends=[]; };
   IUPS = derive { name="IUPS"; version="1.0"; sha256="01pv03ink668fi2vxqybli0kgva13gxhqfdxkwz6qk5rnpzwvf5w"; depends=[R2jags Matching boot]; };
-  ivbma = derive { name="ivbma"; version="1.02"; sha256="0ay7ghrygllpgh7cagrk1f56hxw1s1wfv4bap78javiyj6jgwfzy"; depends=[]; };
+  ivbma = derive { name="ivbma"; version="1.05"; sha256="0d7kg6pkdx1aj1i6kqs2r7j1klxxwymml63qnrq6a6fia3ck9kk9"; depends=[]; };
   ivfixed = derive { name="ivfixed"; version="1.0"; sha256="0a26zrkvz0ffq4zxdx5vhr1nvsi9c15s6gvc1zy2pddjz31x2xi5"; depends=[Formula]; };
-  ivivc = derive { name="ivivc"; version="0.2.0"; sha256="0dsmdhy8iv96xvlm734vh16gva10gh9dij9vqlnj6l782cffs04w"; depends=[reshape sciplot png deSolve minpack_lm]; };
+  ivivc = derive { name="ivivc"; version="0.2.1"; sha256="1zrhsfvwsb3pzypxiac4wfrcwk4lnab0d1zg9r2wdgrpxis1iz9i"; depends=[reshape sciplot png deSolve minpack_lm]; };
   ivlewbel = derive { name="ivlewbel"; version="1.1"; sha256="0ykcfikm2i28s3fm6zzx8cjvpwhksg8an0rfr0b35gf7p69brgag"; depends=[gmm plyr lmtest]; };
-  ivpack = derive { name="ivpack"; version="1.1"; sha256="058g73n3gbpwdav4n78n1wfskfp518wkk220a55x5h82i77a5n6a"; depends=[AER sandwich lmtest]; };
+  ivpack = derive { name="ivpack"; version="1.2"; sha256="0cr5acjrn41d3q0b77hlg2jmsbf1msvys9gcavm1blsryg2bc03c"; depends=[AER sandwich lmtest]; };
+  ivprobit = derive { name="ivprobit"; version="1.0"; sha256="1kijq7k6iv2ybaxb08kqzm2s2k6wp2z50r01kxcq023pmyfjczwy"; depends=[]; };
   iWeigReg = derive { name="iWeigReg"; version="1.0"; sha256="09ajbqllr4ajmpk8qs6qw019fx8a7vsabm37867zycssn77z9nc8"; depends=[MASS trust]; };
-  iwtp = derive { name="iwtp"; version="1.0.0"; sha256="1q3nrp526kzkz74vjxvzm6dgdwlsmx7n034a06sqw210z9mqw3dr"; depends=[survival]; };
-  jaatha = derive { name="jaatha"; version="2.5"; sha256="06p04lbxkxg3lbs5idg27iknhkz5j6mcv1mjd4bnxpfcmhhcl4k3"; depends=[phyclust Rcpp reshape2]; };
-  jackknifeKME = derive { name="jackknifeKME"; version="1.0"; sha256="1vkxp6z4fb73azndk6iis2ckv3ch5c5lrpf5x4ah56z3wd785v9v"; depends=[imputeYn survival]; };
+  jaatha = derive { name="jaatha"; version="2.6"; sha256="1skm4ax3dhmvc9xhpqvrk7bkmlgq13320qnrarwwnv9483hzcgcg"; depends=[phyclust Rcpp reshape2]; };
+  jackknifeKME = derive { name="jackknifeKME"; version="1.1"; sha256="1bzwgyyc2zcm27qahbbf5iqx24q0ddwlzwg7h4h866rlwzb4xf1b"; depends=[imputeYn]; };
   jackstraw = derive { name="jackstraw"; version="1.0"; sha256="1irfzivy7c9fb2pr98flx05s5hkk6sid1hkd5b3k9m9mgs6ixbfy"; depends=[corpcor]; };
-  JADE = derive { name="JADE"; version="1.9-91"; sha256="142a7cq2rpl746m1lcsr5da50zhc0zddxzc8dxddc87qszf920jw"; depends=[clue]; };
+  JADE = derive { name="JADE"; version="1.9-92"; sha256="0ki3jpz4npjikn3jjb7ppiyx0flhxx3p8aghjxlm3klhkm0k6ix4"; depends=[clue]; };
+  JAGUAR = derive { name="JAGUAR"; version="1.1"; sha256="0iy91hx4rcsx84kazkmq0jnl6gqnc1cmbkb957y0v2zr9adpqs4y"; depends=[Rcpp plyr lme4 doParallel]; };
   JASPAR = derive { name="JASPAR"; version="0.0.1"; sha256="0wiyn7cz45hwy9zkvacx28zdrg78q6715cg4r9xgcb39q25s0dcy"; depends=[gtools]; };
   JavaGD = derive { name="JavaGD"; version="0.6-1"; sha256="13n6xzbbjgd0bpwv2xgm3dlscg87wh32q6fcq50kk6byp6yv05sc"; depends=[]; };
   JBTools = derive { name="JBTools"; version="0.7.2.6"; sha256="1wpkv8841kzpw2iqacp6k0y182lsvfl1ri54aq1hg4ypb51b8ibb"; depends=[foreach gplots colorspace plotrix]; };
···
   JGR = derive { name="JGR"; version="1.7-16"; sha256="0iv659mjsv7apzpzvmq23w514h6yq50hi70ym7jrv948qrzh64pg"; depends=[rJava JavaGD iplots]; };
   JM = derive { name="JM"; version="1.3-0"; sha256="0yn33dvy9kp7xaxlqk11f86qaichdcxpmq04gpnbcs8w8cdjjz3m"; depends=[MASS nlme survival]; };
   JMbayes = derive { name="JMbayes"; version="0.6-1"; sha256="1zshy4v7jj3r1vcp9yrw1jj5abmc8wkglsxdb5v6rpmk4xwhvvcq"; depends=[MASS nlme survival]; };
+  JMdesign = derive { name="JMdesign"; version="1.1"; sha256="0w5nzhp82g0k7j5704fif16sf95rpckd76jjz9fbd71pp2d80vlh"; depends=[]; };
   Jmisc = derive { name="Jmisc"; version="0.3.1"; sha256="1szn29dng54l2xmrm6pg3d5rmwdc1ks23vsnsmplnr5rx7yj002s"; depends=[]; };
   Johnson = derive { name="Johnson"; version="1.4"; sha256="12ajcfz5mwxvimv8nq683a2x3590gz0gnyviviyzf5x066a4q0lj"; depends=[]; };
   JohnsonDistribution = derive { name="JohnsonDistribution"; version="0.24"; sha256="00211pa2wn4bsfj6wfl9q9g123cp8iz3kxc17pw9q65j9an4sr0m"; depends=[]; };
···
   JoSAE = derive { name="JoSAE"; version="0.2.2"; sha256="1ag4qg9cfcg8i2xz79bza2qlw3azw33h7k2ip5nlfkfpd33l9w05"; depends=[nlme]; };
   jpeg = derive { name="jpeg"; version="0.1-8"; sha256="05hawv5qcb82ljc1l2nchx1wah8mq2k2kfkhpzyww554ngzbwcnh"; depends=[]; };
   JPSurv = derive { name="JPSurv"; version="1.0.1"; sha256="11hfji0nyfmw1d7y2cijpp7ivlv5s9k8g771kmgwy14wflkyf7g2"; depends=[]; };
-  jSonarR = derive { name="jSonarR"; version="1.0"; sha256="1369v79y2679p1c1s6pfi0zdj21zbbln3a4gqsxivx82m0lwqprp"; depends=[RCurl]; };
-  jsonlite = derive { name="jsonlite"; version="0.9.11"; sha256="4e6d86dfd1584ed2b96b1eb6c067b07847df5fff673d07ffacca6399c330552e"; depends=[]; };
+  jSonarR = derive { name="jSonarR"; version="1.1.1"; sha256="054q3ly471xa64yyz2as6vkr440ip1y8n5wl6s3zbhqy3bqkdqif"; depends=[RCurl jsonlite]; };
+  jsonlite = derive { name="jsonlite"; version="0.9.13"; sha256="1l8l6a6l9427z4gkpgq718yfd3h4pbj7d2lazhpnb286ipp82w21"; depends=[]; };
   jtrans = derive { name="jtrans"; version="0.1"; sha256="1wcrjyifsnpk9jfmwc1cx30qp5vavwl87i0avbbls8cmji7z0nay"; depends=[]; };
   JudgeIt = derive { name="JudgeIt"; version="1.5.1"; sha256="1jssz1x9gw9hjpqlqbvlxa99icl8gffzl6qya0cnaxr50p82hdag"; depends=[]; };
   Julia = derive { name="Julia"; version="1.0"; sha256="0df72mjkfsaz7wbrg3l6fcypwm59hdxxndjv1b833xa4qpq5301g"; depends=[]; };
-  jvmr = derive { name="jvmr"; version="2.11.1.1"; sha256="18hb0pwyrgnrs16w4hl44i401604qfj0hwv2fggm8s21qxb35x9x"; depends=[rJava]; };
-  KANT = derive { name="KANT"; version="1.0"; sha256="0k5i1fwbmc1cg9p2zi94npkdn12lm92d7y8ncqnn64dr8ypxh2h5"; depends=[]; };
+  jvmr = derive { name="jvmr"; version="2.11.2.1"; sha256="0h76b1596zil2m6fbhp38gchxwif942sldbfc6sgbn3ig9mz8zw5"; depends=[rJava]; };
+  KANT = derive { name="KANT"; version="2.0"; sha256="169j72pmdkcj6hv8qgmc02aps0ppvvl1vnr1hzrb1gsf7zj7bs3y"; depends=[]; };
   KappaGUI = derive { name="KappaGUI"; version="1.1"; sha256="1fyx23i6j18q6swazwy2l70lg2933akh4d0k6dzvfjxrai7fvi7y"; depends=[irr]; };
   kappalab = derive { name="kappalab"; version="0.4-6"; sha256="0dmzy0d7azzfpnzbf8b7a6zgmmfwzfiybz8610asajyfsj36gszl"; depends=[lpSolve quadprog kernlab]; };
   kappaSize = derive { name="kappaSize"; version="1.1"; sha256="0jrjal8cvy2yg0qiyilmv3jl3ib5k9jg8gp2533kdsx4m0sack04"; depends=[]; };
···
   KATforDCEMRI = derive { name="KATforDCEMRI"; version="0.740"; sha256="1k8fihd9m26k14rvc5d5x0d9xc3mh8d49hs64p55np1acqfhg2sy"; depends=[locfit R_matlab matlab]; };
   kcirt = derive { name="kcirt"; version="0.6.0"; sha256="1gm3c89i5dq7lj8khc12v30j1c0l1gwb4kv24cyy1yw6wg40sjig"; depends=[mvtnorm snowfall corpcor]; };
   kdetrees = derive { name="kdetrees"; version="0.1.5"; sha256="1plf2yp2vl3r5znp5j92l6hx1kgj0pzs7ffqgvz2nap5nf1c6rdg"; depends=[ape distory ggplot2]; };
-  kedd = derive { name="kedd"; version="1.0.0"; sha256="1llc8hqbrp1r75b28z889nik047y400g2h05a7cjaq0r2qxbcqx1"; depends=[]; };
+  kedd = derive { name="kedd"; version="1.0.1"; sha256="1hk4a6n4ywd61g24843zb1z0wbz10lz82as9cpig6m1hglbhs8ll"; depends=[]; };
   kelvin = derive { name="kelvin"; version="1.2-2"; sha256="0fl2yxc0dpmkhq3f7711gd08i7jlzlfncin1d6q251dfnmwd7rzf"; depends=[Bessel]; };
   Kendall = derive { name="Kendall"; version="2.2"; sha256="0z2yr3x2nvdm81w2imb61hxwcbmg14kfb2bxgh3wmkmv3wfjwkwn"; depends=[boot]; };
   kequate = derive { name="kequate"; version="1.4.0"; sha256="0vr45y4f6x3080pf3k53nifavf8mfhikz54nis66c53fs9rp0jwf"; depends=[ltm equateIRT]; };
   kerdiest = derive { name="kerdiest"; version="1.2"; sha256="16xj2br520ls8vw5qksxq9hqlpxlwmxccfk5balwgk5n2yhjs6r3"; depends=[date chron evir]; };
   kernelFactory = derive { name="kernelFactory"; version="0.2.0"; sha256="1ihghqrrndgif6kh6n0f4g3bfy5miskn3mk5ynxfcnnrfvp9h3xj"; depends=[randomForest AUC genalg kernlab]; };
   kernlab = derive { name="kernlab"; version="0.9-19"; sha256="0caqp5dp1irhwpq8lyram35r8x16qlfp6f5wzqyi5rzcz27d03sg"; depends=[]; };
-  KernSmooth = derive { name="KernSmooth"; version="2.23-12"; sha256="0jlpfaf8wqa9hq7scdmgfhkvr5hi61di54slkzskg0pr7c28rlqh"; depends=[]; };
+  KernSmooth = derive { name="KernSmooth"; version="2.23-13"; sha256="1r9zrr3cfiblr2nkyzn05x82kab0fj2qn2nknnsdm80y42lvsprz"; depends=[]; };
   KernSmoothIRT = derive { name="KernSmoothIRT"; version="6.1"; sha256="1hq4sykddh9sg24qrnccii89nqxmq7hnldhn8wl6y62aj0h1nrqm"; depends=[Rcpp plotrix rgl]; };
   KFAS = derive { name="KFAS"; version="1.0.4-1"; sha256="0s9mrqb1mvs77z57hx734kajbyqddcc9j20wrsmrbf8g97in61s7"; depends=[]; };
   KFKSDS = derive { name="KFKSDS"; version="1.5"; sha256="0wahqli7j851kdqi29b059gb2zm0x00fq08sixvlrcbdf3irlv3m"; depends=[]; };
···
   kmc = derive { name="kmc"; version="0.1-2"; sha256="16lv8wk24cp91qg5202zhfmdhg83qw8bwiycknaml5ki820ffdlx"; depends=[rootSolve emplik Rcpp]; };
   km_ci = derive { name="km.ci"; version="0.5-2"; sha256="1l6kw8jppaa1802yc5pbfwwgac56nhwc9p076ivylhms4w7cdf8v"; depends=[survival]; };
   kmconfband = derive { name="kmconfband"; version="0.1"; sha256="10n5w8k57faqcclwshs4m66i2i5b70i6f3xq5nqlgsi2ldkysbc9"; depends=[survival]; };
-  kmi = derive { name="kmi"; version="0.5"; sha256="13m9kxbyph24njp28r122gry03rpkp26ldilhjc4rnixczvnhzwi"; depends=[survival mitools]; };
+  kmi = derive { name="kmi"; version="0.5.1"; sha256="0519mi7kwrsfpili7y8nmyiky6qwf8xkd0n7cwj02c8d119bk9sa"; depends=[survival mitools]; };
   Kmisc = derive { name="Kmisc"; version="0.5.0"; sha256="0pbj3gf0bxkzczl6k4vgnxdss2wmsffqvcf73zjwvzvr8ibi5d95"; depends=[Rcpp data_table lattice knitr markdown]; };
   kml = derive { name="kml"; version="2.2"; sha256="1g8wgmvs31r3hp7y8n9pkxc9qy5fxvb3nicmzgacmghaiwbwc8g3"; depends=[clv longitudinalData]; };
   kml3d = derive { name="kml3d"; version="2.2"; sha256="1n94kfi49rgb9149bgc9043f0y5xpaclmfjr8fkwairqz5nnmgbv"; depends=[clv rgl misc3d longitudinalData kml]; };
   kmlcov = derive { name="kmlcov"; version="1.0.1"; sha256="09s9ganfsnwp22msha78g6pjr45ppyfyqjf6ci64w3w15q5qlcd9"; depends=[]; };
   KMsurv = derive { name="KMsurv"; version="0.1-5"; sha256="0hi5vvk584rl70gbrr75w9hc775xmbxnaig0dd6hlpi4071pnqjm"; depends=[]; };
-  knitcitations = derive { name="knitcitations"; version="1.0-1"; sha256="0zlgia03r7am1ahbkraxqzsl649x1iidxq5s1jf1c8jkgfdjgicm"; depends=[RefManageR digest httr]; };
-  knitr = derive { name="knitr"; version="1.6"; sha256="0r34ras0csvm73z6j4f606pi387mjn4dz91djkx1j6fpk5rx1f68"; depends=[evaluate digest formatR highr markdown stringr]; };
+  knitcitations = derive { name="knitcitations"; version="1.0.4"; sha256="0dzm60rilzvxihj7iqj0lr9nmavw2fb4p7qmn6l3ggy4dax0gws7"; depends=[RefManageR digest httr]; };
+  knitr = derive { name="knitr"; version="1.7"; sha256="03md5zxkjv7a5sszb10z8w3jazdcwxqlzihzkjnz6wamffvzn9dr"; depends=[evaluate digest formatR highr markdown stringr]; };
   knitrBootstrap = derive { name="knitrBootstrap"; version="0.9.0"; sha256="1cw5dvhjiypk6847qypxphfl9an54qjvd6qv029znhwijsg56mmg"; depends=[knitr markdown]; };
   knnGarden = derive { name="knnGarden"; version="1.0.1"; sha256="1gmhgr42l6pvc6pzlq5khrlh080795b0v1l5xf956g2ckgk5r8m1"; depends=[cluster]; };
-  knnIndep = derive { name="knnIndep"; version="1.0"; sha256="13iav0db8qmbmnf7hxmbvcyb0d76wyd05ib8mfzmgsdcpdkn4f72"; depends=[]; };
+  knnIndep = derive { name="knnIndep"; version="2.0"; sha256="1fwkldgs2994svf3sj90pwsfx6r22cwwa22b30hdmd24l8v9kzn7"; depends=[]; };
   kobe = derive { name="kobe"; version="1.3.2"; sha256="1z64jwrq6ddpm22cvk2swmxl1j7qyz0ddk3880c7zfq6gk7f9bxl"; depends=[plyr reshape ggplot2 MASS emdbook coda]; };
+  kofnGA = derive { name="kofnGA"; version="1.0"; sha256="1h50dkysydk2nk90xi0lw6qyc15131xh2m4vh0gkfch8sd2gwqiw"; depends=[]; };
   kohonen = derive { name="kohonen"; version="2.0.15"; sha256="1mamn6lwnd54jw7bbxgrxj511abn9wg5rxrm9fac7jndf00kjaim"; depends=[class MASS]; };
   kolmim = derive { name="kolmim"; version="0.2"; sha256="1cq1miny83shxas4zijcbzcnxv29vjyxj3pip8brf52sjvrj4max"; depends=[]; };
   KoNLP = derive { name="KoNLP"; version="0.76.9"; sha256="1q72irl4izb7f5bb99plpqnmpfdq4x4ymp4wm2bsyfjcxm649ya8"; depends=[rJava stringr hash tau Sejong]; };
···
   KrigInv = derive { name="KrigInv"; version="1.3"; sha256="1zgrx0rmcaf3j3igqhvnbzjwh2dm2x5s5l027c7cbrl1rn20im0r"; depends=[DiceKriging rgenoud MASS lhs pbivnorm randtoolbox DiceView]; };
   KRLS = derive { name="KRLS"; version="0.3-7"; sha256="0dx4b68xx3saqlkbpvvrhxjscl7jr5phwqvjywxsp4qxlr3ysl79"; depends=[]; };
   krm = derive { name="krm"; version="13.11-03"; sha256="05yy06ib879j1gcgqgljkfw79a3vg2ij71w7zah4ixl7di0301la"; depends=[]; };
-  ks = derive { name="ks"; version="1.9.2"; sha256="05h13g4nla3gvawsb9zf7w8cdylpf7rc6ly6lp5dbsgc9qxha5py"; depends=[KernSmooth misc3d mvtnorm rgl multicool]; };
+  ks = derive { name="ks"; version="1.9.3"; sha256="077sx9kms8nkgg6c4bg24n0j6a7bf253bp26hybyilbagp7k6pin"; depends=[KernSmooth misc3d mvtnorm rgl multicool]; };
   kSamples = derive { name="kSamples"; version="1.0"; sha256="0a4kl6508isjsbv8g7b8g9c2kmai90lwdjn0576i7l4hnqvi532b"; depends=[SuppDists]; };
+  kselection = derive { name="kselection"; version="0.1.1"; sha256="18l8a00v8ldpzvbzi5ph7hmgrlsydkynfzqn3vs1i84zvwrh1fz5"; depends=[]; };
   KsPlot = derive { name="KsPlot"; version="1.3"; sha256="1mzpsgzscpv888ipfh9nakhqrgw7rdinb5lwhkjk9yk7ap5lfvs0"; depends=[e1071 caret nnet MASS caTools mda glmnet randomForest mvpart]; };
   kst = derive { name="kst"; version="0.2-1"; sha256="1wy9cvvln994qgr0p7qa9qs1jd7gjv6ch65gg6i42cf9681m9h65"; depends=[proxy relations sets]; };
   ktsolve = derive { name="ktsolve"; version="1.1"; sha256="0b5myr093v3qaj9gzbw1w728i5ij418whxxpicj51w657dcy647k"; depends=[]; };
   ktspair = derive { name="ktspair"; version="1.0"; sha256="1v63982jidxlcf2syahcb29myv34kc790l7lwyfxx9l50ssb812n"; depends=[]; };
   kulife = derive { name="kulife"; version="0.1-14"; sha256="070ayy6fr9nsncjjljikn2i5sp2cx3xjjqyc64y2992yx74jgvvd"; depends=[]; };
-  kyotil = derive { name="kyotil"; version="2014.4-1"; sha256="1cqbrn860lfh0bsfglmqa3vqv1jfblicfaz2albk31p9hh14hm20"; depends=[]; };
+  kyotil = derive { name="kyotil"; version="2014.10-5"; sha256="1gfgrqqg1r8xydlyvrarj7mngy64ppfm6bszqkmy2rbfrj1n29hl"; depends=[]; };
   kza = derive { name="kza"; version="3.0.0"; sha256="0v811ln9vg7msvks9lpgmdi39p01342yi8fj180aclha3mfk6gfw"; depends=[polynom]; };
   kzft = derive { name="kzft"; version="0.17"; sha256="1y6almhs1x21cr4bbf5fj3mnhp65ivzs869660cyg70sva853sv7"; depends=[polynom]; };
   kzs = derive { name="kzs"; version="1.4"; sha256="1srffwfg0ps8zx0c6hs2rc2y2p01qjl5g1ypqsbhq88vkcppx1w9"; depends=[lattice]; };
   l2boost = derive { name="l2boost"; version="1.0"; sha256="1p0sbvlnax4ba4wjkh3r0bmjs601k590g7bdfk6wxvlj42jxcnkl"; depends=[MASS]; };
   labdsv = derive { name="labdsv"; version="1.6-1"; sha256="0bcsjznq9w1arv503895060hkri0447fnc49nj4ynry7fi35ci22"; depends=[mgcv MASS]; };
   labeledLoop = derive { name="labeledLoop"; version="0.1"; sha256="0gq392h0sab8k7k8bzx6m7z5xpdsflldhwbpdf92zbmkbzxsz00m"; depends=[]; };
-  labeling = derive { name="labeling"; version="0.2"; sha256="194awd2j33hk7p368q2npkrggkxd1xi45bj79vd8hc4jj65pzala"; depends=[]; };
+  labeling = derive { name="labeling"; version="0.3"; sha256="13sk7zrrrzry6ky1bp8mmnzcl9jhvkig8j4id9nny7z993mnk00d"; depends=[]; };
   label_switching = derive { name="label.switching"; version="1.2"; sha256="149np2jqr4vffj1mb7wvnlpj4fhb3gijrdn7qx1m946pf3h13wvv"; depends=[lpSolve combinat]; };
   labeltodendro = derive { name="labeltodendro"; version="1.3"; sha256="13kpmv26zzjf5iwpr4vs797irplmaixp1agx5v80wr4lvd2hirvg"; depends=[]; };
   labstatR = derive { name="labstatR"; version="1.0.7"; sha256="1p6xav9cb7yx3n8rkh8xm1jkykf3xw974id49j558hmayq47ad4f"; depends=[]; };
-  laeken = derive { name="laeken"; version="0.4.5"; sha256="1wbdj7wnyapj4wbzsclm1vyyaxid4ww72dv5v2nk64q7fbc56py0"; depends=[boot MASS]; };
+  laeken = derive { name="laeken"; version="0.4.6"; sha256="1rhkv1kk508pwln1d325iq4fink2ncssps0ypxi52j9d7wk78la6"; depends=[boot MASS]; };
   laercio = derive { name="laercio"; version="1.0-1"; sha256="0la6fxv5k9zq4pyn8dxjiayx3vs9ksm9c6qg4mnyr9vs12z53imm"; depends=[]; };
   LaF = derive { name="LaF"; version="0.6.1"; sha256="1yg498qzxzx4qpp27rwh854x7vkz8iqmny1pvcy2rvnnb8g0wk24"; depends=[Rcpp]; };
-  laGP = derive { name="laGP"; version="1.1"; sha256="03xpgmab61m160vbcach218njwdkpfqvs19fvcvixvgy3hpa0prc"; depends=[]; };
-  Lahman = derive { name="Lahman"; version="2.0-3"; sha256="0rsjm81yda7z73dvafhbplkp1ly5diwwmls2fgpz3pvr2hc72v1f"; depends=[]; };
+  laGP = derive { name="laGP"; version="1.1-3"; sha256="11blzdnil0nw3q5vf4y1rv7l4zxjx8ilynv9jpkm14azv5dsr8jw"; depends=[tgp]; };
+  Lahman = derive { name="Lahman"; version="3.0-1"; sha256="0w7vp3vjxhigyyqmmka4bw5v4pp5z3jzmf0krq8biwzrpx5qp86x"; depends=[]; };
   LakeMetabolizer = derive { name="LakeMetabolizer"; version="1.1"; sha256="0l2l9l2c75cmxpqi2w9cgsad2ffnx6b7wvx6xdx6mkb52kkp9sqy"; depends=[rLakeAnalyzer plyr]; };
+  lakemorpho = derive { name="lakemorpho"; version="1.0"; sha256="0kxd493cccs24qqyw58110d2v5w8560qfnbm6qz7aki0xa7kaqrg"; depends=[maptools rgdal raster rgeos sp geosphere]; };
   Lambda4 = derive { name="Lambda4"; version="3.0"; sha256="04ikkflfr0nmy1gr3gfldlh2v8mpl82k1wwnzp57d2kn75m9vbxz"; depends=[]; };
   lambda_r = derive { name="lambda.r"; version="1.1.6"; sha256="03f3945f9kqj7in1mxk23ai56x68rdyd10c3ki4nqqysshyjr4d4"; depends=[]; };
   lambda_tools = derive { name="lambda.tools"; version="1.0.3"; sha256="1vd1ms8yzy01wvg4baj2ypyiyy27ck3na9awlmvhdvxc1s459sr7"; depends=[lambda_r]; };
   LambertW = derive { name="LambertW"; version="0.2.9.9.5"; sha256="06330zdpp2h973j841axd9nqgmy5z8gns1w2anmjw298k164mr6g"; depends=[moments gsl MASS nortest maxLik]; };
-  lancet_iraqmortality = derive { name="lancet.iraqmortality"; version="0.2-0"; sha256="00f467j9lw30r6han9d3gdkyqmkqsr3hq4cvp2mc93qhpprf81cq"; depends=[foreign]; };
+  landpred = derive { name="landpred"; version="1.0"; sha256="1bl17xkx18i8i7arccnjmxvhjn4yiy7w64hg4n0xmhk8pg0l3mrg"; depends=[survival]; };
   landsat = derive { name="landsat"; version="1.0.8"; sha256="07zvj1yyryxk7rwgcrf1kl32p2karkkqz6xrnwy1096dg9iw2js7"; depends=[rgdal sp lmodel2 mgcv]; };
   languageR = derive { name="languageR"; version="1.4.1"; sha256="0grkhdjz9dcrgq6qwv7wpwmckn3mfv022c5wrx29b1dxafd0qzm0"; depends=[]; };
   lar = derive { name="lar"; version="0.1-2"; sha256="0qda0y4ag10kg83wxs3z754kc8c1dg2rwciy64klk7an4ln43i5b"; depends=[data_table treemap xlsx]; };
-  LARF = derive { name="LARF"; version="1.1"; sha256="0mlmfd748flxf3cxj3y668azhx9v7wd2cf3c6qj56llmk5fygfbg"; depends=[]; };
+  LARF = derive { name="LARF"; version="1.2"; sha256="1qhi5zkgk8qlgfvq0jas9dda6nlg94kcay1famm0s488ssg6sr3k"; depends=[]; };
   LargeRegression = derive { name="LargeRegression"; version="1.0"; sha256="05vkd6skqg19bs54vsjf3i4rwz1j3g1gmp9jj8fsnmkds46yr91y"; depends=[Matrix]; };
   lars = derive { name="lars"; version="1.2"; sha256="0blj44wqrx6lmym1m9v6wkz8zxzbjax2zl6swgdczci0ixb5nx34"; depends=[]; };
   laser = derive { name="laser"; version="2.4-1"; sha256="1f6j3xdks0w63fqjj9q8ng2m6ss90kcnsrigwal0bqskpvrpiqyz"; depends=[ape geiger]; };
   lasso2 = derive { name="lasso2"; version="1.2-19"; sha256="0zkwjsd42a6z4gylq9xbs4z8n1v7ncwvssjnn3h4yz1icjfzzlvk"; depends=[]; };
-  lassoscore = derive { name="lassoscore"; version="0.5"; sha256="1nnaxy0h48p8ribg4s6sxvqmnwjvr7d9yjxxcn2j4g8pwvfpiirg"; depends=[glasso glmnet]; };
+  lassoscore = derive { name="lassoscore"; version="0.6"; sha256="1i3i07da8sw9w47rcflhylz8zxvzkyycbc1a4gf6hbcpp21rqd7d"; depends=[glasso glmnet Matrix]; };
   lassoshooting = derive { name="lassoshooting"; version="0.1.5-1"; sha256="0ixjw8akplcfbzwyry9p4bhbcm128yghz2bjf9yr8np6qrn5ym22"; depends=[]; };
   latdiag = derive { name="latdiag"; version="0.2"; sha256="11fahajwky3cfbd8y5xfaiz24qf7bkifbzcnvhv7daan4gsha04z"; depends=[]; };
   latentnet = derive { name="latentnet"; version="2.5.1"; sha256="0jzdgsw3i0s0rn8199m7g4x2gwbbrc5nd7fzimhxmib99pyzvrjf"; depends=[statnet_common network ergm sna mvtnorm abind coda]; };
   Laterality = derive { name="Laterality"; version="0.9.2"; sha256="13b1mpjcq7a14dwscnfs07hahd9is2fbn4wxwh31732vv3hr7kwm"; depends=[ade4]; };
   lattice = derive { name="lattice"; version="0.20-29"; sha256="0ip6qw1kry68dqj97bh8ddpq6gfsxf3n3axc6pn3zv2n1mfv6s9s"; depends=[]; };
-  latticeDensity = derive { name="latticeDensity"; version="1.0.7"; sha256="1y33p8hfmpzn8zl4a6zxg1q3zx912nhqlilca6kl5q156zi0sv3d"; depends=[splancs spdep spatstat spam]; };
+  latticeDensity = derive { name="latticeDensity"; version="1.0.7"; sha256="1y33p8hfmpzn8zl4a6zxg1q3zx912nhqlilca6kl5q156zi0sv3d"; depends=[splancs spdep spam]; };
   latticeExtra = derive { name="latticeExtra"; version="0.6-26"; sha256="16x00sg76mga8p5q5ybaxs34q0ibml8wq91822faj5fmg7r1050d"; depends=[RColorBrewer lattice]; };
-  LatticeKrig = derive { name="LatticeKrig"; version="3.3"; sha256="1l8rw63ljc54zsmnan8z7ipgdhzy3fjqrgywspn7g1120pfl59a4"; depends=[spam fields]; };
-  latticist = derive { name="latticist"; version="0.9-44"; sha256="0kx2dyyr3zn3p63r5ypaw22hdrqyjibkws3hgyc3d560shjyfafv"; depends=[lattice latticeExtra vcd gWidgets]; };
+  LatticeKrig = derive { name="LatticeKrig"; version="3.4"; sha256="0qa16sxzj40nk4kmzcb7n4xxn7bqlkx7ar66qpqvh2dvcvi1d70d"; depends=[spam fields]; };
   lava = derive { name="lava"; version="1.2.6"; sha256="16vdc1j3py4jszcldprlsxjc2pzbprpj7mdj53164adiw7vfah78"; depends=[numDeriv]; };
-  lavaan = derive { name="lavaan"; version="0.5-16"; sha256="1ifzhbzb57smzj22hc19d0hl1v6qg1jvilgrjy9fp0kixk1qmf80"; depends=[MASS mnormt pbivnorm quadprog]; };
+  lavaan = derive { name="lavaan"; version="0.5-17"; sha256="0rb9bra1nzsbrvvjwcj5vh7l689wdvaq1r86r85919b6n3x38v4b"; depends=[MASS mnormt pbivnorm quadprog]; };
   lavaan_survey = derive { name="lavaan.survey"; version="1.1"; sha256="1vscv165kilkc00pgs2s9qn404l3rv45zc9kzmrghxz42jsy04zc"; depends=[lavaan survey MASS Matrix]; };
   lava_tobit = derive { name="lava.tobit"; version="0.4-7"; sha256="1da98d5pndlbbw37k64fmr2mi1hvkhjxsmm3y9p4b772pz9i1pvj"; depends=[lava mvtnorm survival]; };
   lawstat = derive { name="lawstat"; version="2.4.1"; sha256="142plbzpvi5xy7j5m5wizhz3w1n9im9hs8byhs6kfjpdw710qn7h"; depends=[mvtnorm VGAM]; };
   lazy = derive { name="lazy"; version="1.2-15"; sha256="1pdqgvn0qpfg5hcg5159ccf5qj2nd1ibai9p85rwjpddfynk6jks"; depends=[]; };
   lazyData = derive { name="lazyData"; version="1.0.3"; sha256="1i4jry54id8hhfla77pwk3rj2cci6na36hxj7k35k8lx666fdam2"; depends=[]; };
+  lazyeval = derive { name="lazyeval"; version="0.1.9"; sha256="1qqm9pvjh32h9c9g7wnrsa2lc15azqkq1vwq1knlyksyvwh3rbpl"; depends=[]; };
   lazyWeave = derive { name="lazyWeave"; version="2.2.5"; sha256="18j31lbbplxvrz4wnq7hfw9qcx1s0y4c34lbxwly2wyrvzjhxybl"; depends=[Hmisc survival]; };
+  lbfgs = derive { name="lbfgs"; version="1.2.1"; sha256="0p99g4f3f63vhsw0s1m0y241is9lfqma86p26pvja1szlapz3jf5"; depends=[Rcpp]; };
   lbiassurv = derive { name="lbiassurv"; version="1.1"; sha256="1i6l3y4rasqpqka7j39qjx22wjbilgc9pkp05an52aysfvfxy193"; depends=[actuar]; };
   LCA = derive { name="LCA"; version="0.1"; sha256="14nhx2fs18558zljnw56mdz3qx30v394llhzswxhznjfiiqc9z5h"; depends=[]; };
   LCAextend = derive { name="LCAextend"; version="1.2"; sha256="1y9azq9v42a3z5fq6gj8js89qblb2z93k4mg4jmw0wgkyv6mysfc"; depends=[boot mvtnorm rms kinship2]; };
   lcd = derive { name="lcd"; version="0.7-3"; sha256="1jnnw15d4s8yb5z5jnzvmlrxv5x6n3h7wcdiz2nw4vfiqncnpwx4"; depends=[igraph MASS ggm]; };
   lcda = derive { name="lcda"; version="0.3"; sha256="1ximsyn6qw2gfn7b1hdpbjs6h6nk7hrignlii0np1lbf0k8l4xxl"; depends=[poLCA]; };
   LCFdata = derive { name="LCFdata"; version="2.0"; sha256="1x3vbr6hdviqvd6dxn1kb449g0q5zkfmjsmr5nxd2g82p69lv3xm"; depends=[]; };
-  lcmm = derive { name="lcmm"; version="1.6.4"; sha256="1qk821q7abq7w2iyyd2yyjj1cr943ycjb4174m3zdxj3qxlq1v0z"; depends=[survival]; };
-  lctools = derive { name="lctools"; version="0.1-3"; sha256="1wn9qymbcq9q99xnjbk3qswrfljvfqqhihvgr0brbpq3pbbxh55x"; depends=[reshape weights]; };
+  lcmm = derive { name="lcmm"; version="1.6.6"; sha256="1n3m1r34rvdjjpj4854iwy74vlhwiaj30q48rk9jph98q4hz3vgx"; depends=[survival]; };
   lda = derive { name="lda"; version="1.3.2"; sha256="1iizsksp8wz34ji7p2kc6npxz9rzhs6217793nfri6y6mq23vs8z"; depends=[]; };
   ldbounds = derive { name="ldbounds"; version="1.1-1"; sha256="15ixrq615x64zmi6dryq3ww0dqxd0qf5xx1bs3w934sf99l46bhs"; depends=[lattice]; };
   LDcorSV = derive { name="LDcorSV"; version="1.3.1"; sha256="0i4npl90mkj8vry6ckq8bc4ydbl44vxichgsxyn80r6k9i71yl67"; depends=[MASS]; };
···
   LDheatmap = derive { name="LDheatmap"; version="0.99-1"; sha256="1bj42chw1xyf8yg6cfv9p4yzsggng7zy6wrw6q22559pwm6c6vr0"; depends=[genetics]; };
   ldlasso = derive { name="ldlasso"; version="3.2"; sha256="0ij68zvgm8dfd2qwx6h6ygndac29qa0ddpf11z959v06n8jsnk11"; depends=[GenABEL quadprog]; };
   LDOD = derive { name="LDOD"; version="1.0"; sha256="0mf2sy01yv57mqicrz08a17m6crigklx6fmw9zpxv7g85qw1iq4v"; depends=[Rsolnp Rmpfr]; };
-  ldr = derive { name="ldr"; version="1.3.2"; sha256="1fjgj3g5qgc0sx6xwp48agvm2f59s55qjsxn332cgnfyxaz5pazz"; depends=[GrassmannOptim Matrix]; };
+  ldr = derive { name="ldr"; version="1.3.3"; sha256="1c48qm388zlya186qmsbxxdcg1mdv3nc3i96lqb40yhcx2yshbip"; depends=[GrassmannOptim Matrix]; };
   LDRTools = derive { name="LDRTools"; version="0.1"; sha256="1cr0v6qsdldy89p44lhr6hisqaz99qzab32kd1srdnnwnwl1q2y4"; depends=[]; };
   LDtests = derive { name="LDtests"; version="1.0"; sha256="1jwqr7zlp9hv7vw8xp80xvrwbdv796wjgr914v393wfa07j5wbd1"; depends=[]; };
   LeafAngle = derive { name="LeafAngle"; version="1.2"; sha256="18b3gncn18jvsjprjmaays67iwjdcpszy5z711rb71h1vyi0fdfs"; depends=[]; };
-  leafletR = derive { name="leafletR"; version="0.2-1"; sha256="0l2xqi8b5j1qrfrahk06r7b3vx0lrgihfaiv0psxj6d81xv2x72y"; depends=[]; };
-  LEAPFrOG = derive { name="LEAPFrOG"; version="1.0.6"; sha256="0zsvf22ir8r4ld67ir4m9ziqwrxfnjs44yjayicpm6sg4bdfdfa5"; depends=[alabama MASS]; };
-  leapp = derive { name="leapp"; version="1.2"; sha256="1yiqzmhgl5f3zwpcc5sz3yqrvp8p6r4w2ffdfyirirayqc96ar17"; depends=[MASS corpcor]; };
+  leafletR = derive { name="leafletR"; version="0.3-1"; sha256="1jgmjm4f91saq2cjfgi240zz3i1r1nfb267i0gj15k2nak6ng86j"; depends=[brew jsonlite]; };
+  LEAPFrOG = derive { name="LEAPFrOG"; version="1.0.7"; sha256="0z9ahkk4qzc45h1r806frv9cd84vvshvn5mr84gx7qdxljfkfq6h"; depends=[alabama MASS]; };
   leaps = derive { name="leaps"; version="2.9"; sha256="1ax9v983401hvb6cdswkc1k7j62j8yk6ds22qdj24vdidhdz5979"; depends=[]; };
   LearnBayes = derive { name="LearnBayes"; version="2.15"; sha256="0cz2rgqy1cmdz2h1qbdvfqxmmdzmg2z1scdlxr7k385anha13ja5"; depends=[]; };
   learningr = derive { name="learningr"; version="0.29"; sha256="1nr4ydcq2mskv4c0pmf0kxv5wm8pvjqmv19xz5yaq0j834b0n5q7"; depends=[plyr]; };
+  lefse = derive { name="lefse"; version="0.1"; sha256="1zdmjxr5xa5p3miw79mhsswsh289hgzfmn3mpj1lyzal1qgw1h5m"; depends=[ape picante geiger fBasics SDMTools vegan]; };
   leiv = derive { name="leiv"; version="2.0-6"; sha256="18cf050653qrwyma23r50i66irjpdbp03nc96pirji5sl4dr9q7x"; depends=[]; };
   LeLogicielR = derive { name="LeLogicielR"; version="1.2"; sha256="0h52pzrksi1mn55mnxbfi61hl7x61cnkhp450slfrk68f6kp30x6"; depends=[xtable RColorBrewer gdata IndependenceTests]; };
-  lessR = derive { name="lessR"; version="3.1"; sha256="1hnjzh8chh08hgmsfc3gqgzcvs5rqycxdp0kjv660mbmrmi0g270"; depends=[car leaps MBESS foreign gdata triangle]; };
+  lessR = derive { name="lessR"; version="3.1.1"; sha256="0cx5bvwfkrfy5im7x718ixf45aw22561b9w0vv0qp97y7xyjqja5"; depends=[car leaps MBESS foreign gdata triangle]; };
   lestat = derive { name="lestat"; version="1.8"; sha256="12w3s5yr9lsnjkr3nsay5sm4p241y4xz0s3ir56kxjqw23g6m80v"; depends=[MASS]; };
   letsR = derive { name="letsR"; version="1.0"; sha256="1far1vil7g4ymvmhzb0dgfng5d1nkcb4rr1sp7yi72lz60h3g9hk"; depends=[maps raster XML geosphere maptools sp]; };
-  lfe = derive { name="lfe"; version="1.7-1289"; sha256="1k64llwsjk6lpfyvzwq5plickds15r42p0x5ppr57xzjqfyhyy61"; depends=[Matrix Formula xtable]; };
+  lfe = derive { name="lfe"; version="1.7-1404"; sha256="1pjjm7a770la4zwajw3qc4wpaydbj9dwm4wd28jjpi01wcb07cli"; depends=[Matrix Formula xtable]; };
   lfstat = derive { name="lfstat"; version="0.6.1"; sha256="0i3zrinvjxlg9w5zqrv8wzy15vxvi2gw3jrlfs4rddkxnp98ya9d"; depends=[lattice lmom lmomRFA latticeExtra]; };
   lga = derive { name="lga"; version="1.1-1"; sha256="1nkvar9lmdvsc3c21xmrnpn0haqk03jwvc9zfxvk5nwi4m9457lg"; depends=[boot lattice]; };
-  lgarch = derive { name="lgarch"; version="0.4"; sha256="0pf66p8nvrzjkayjj4y38lbyhz389q3q7ffd3kzsa3a1z9h2156x"; depends=[zoo]; };
-  lgcp = derive { name="lgcp"; version="1.3-6"; sha256="04khs0knax3g20hgi5ykny1ck4jxz1aivaa19bb24fljvhn88prv"; depends=[spatstat sp raster RandomFields iterators ncdf rpanel fields maptools Matrix rgeos]; };
+  lgarch = derive { name="lgarch"; version="0.5"; sha256="01y5p3w4i1yfxb647pkdazqn9yac1p6jp7rk92ddxnvvjb6fdp59"; depends=[zoo]; };
+  lgcp = derive { name="lgcp"; version="1.3-6"; sha256="04khs0knax3g20hgi5ykny1ck4jxz1aivaa19bb24fljvhn88prv"; depends=[sp raster RandomFields iterators ncdf rpanel fields maptools Matrix rgeos]; };
   LGS = derive { name="LGS"; version="0.91"; sha256="0rzj1shapyg7hyzsb9v81dirwihd7bz9s861l75g3yl3p4qm8sg7"; depends=[]; };
   lgtdl = derive { name="lgtdl"; version="1.1.3"; sha256="00lffc60aq1qjyy66nygaypdky9rypy607mr8brwimjn8k1f0gx4"; depends=[]; };
   lhs = derive { name="lhs"; version="0.10"; sha256="1hc23g04b6nsg8xffkscwsq2mr725r6s296iqll887b3mnm3xaqz"; depends=[]; };
   libamtrack = derive { name="libamtrack"; version="0.5.5"; sha256="0v2h4ficf87ai3h2liw8j7428k0bzzb59zini2vskwhcqb7ky7yw"; depends=[]; };
-  LiblineaR = derive { name="LiblineaR"; version="1.80-7"; sha256="1gg4x0x94qq7h3nf5z3k7zy3iknydz3cfpnb8syhpgv5a462i84v"; depends=[]; };
+  LiblineaR = derive { name="LiblineaR"; version="1.80-10"; sha256="0qhcrdazqn7zf3wq79rg0sr9bp9a7fw6p3gjrhyyn3b2klbrcz7k"; depends=[]; };
   LICORS = derive { name="LICORS"; version="0.2.0"; sha256="0p9y21k1mj1v397jpb5g6jiw7rpzbyfwr4kv2rp3lyxyasy2ykf0"; depends=[RColorBrewer mvtnorm zoo FNN fields locfit Matrix]; };
   LICurvature = derive { name="LICurvature"; version="0.1.1"; sha256="09hqar4kvksd816ya6jg349r0v6z2m2109hq6j4k1d2vchab4lni"; depends=[MASS]; };
   lifecontingencies = derive { name="lifecontingencies"; version="1.1"; sha256="0rjiqmhqiliy8zbprxnr63r0wvwzs825gd6rrz4skwxcwpl4d0sh"; depends=[]; };
···
   LIHNPSD = derive { name="LIHNPSD"; version="0.2.1"; sha256="08ils29vvaq6abkgxbh028vwjw6l6h10cirbnwr65s458zvh4xqv"; depends=[sn moments BB Bolstad2 optimx Rmpfr]; };
   likelihood = derive { name="likelihood"; version="1.6"; sha256="11p7k6wpr7ypas414qir0hracy0960j8g3nwlhjbmynwmfzpkq1r"; depends=[nlme]; };
   likeLTD = derive { name="likeLTD"; version="5.4.0"; sha256="09h1a4pn1i3vm3116yxvx07b62cbqmq84svpkbxykl4jmlqmwg8x"; depends=[DEoptim ggplot2 gtools rtf gdata]; };
-  likert = derive { name="likert"; version="1.1"; sha256="1jmzxqav5hqvafb53k4mk8a2zfbzvlynqxkphndnbngq7z5915ah"; depends=[ggplot2 gridExtra xtable reshape psych]; };
+  likert = derive { name="likert"; version="1.2"; sha256="1x1mlaqzwr15xzcfq9934jxb3m5irvw6yivirrj45wscxn3kz5s1"; depends=[ggplot2 xtable psych reshape gridExtra plyr]; };
   LIM = derive { name="LIM"; version="1.4.5"; sha256="1dir9dqrpns77n5ydm3fpj2k0pl7q15z8vqbi5704vsfv94mgmas"; depends=[limSolve diagram]; };
   limitplot = derive { name="limitplot"; version="1.2"; sha256="0wj1xalm80fa5pvjwh2zf5hpvxa3r1hnkh2z9z285wkbrcl0qfl2"; depends=[]; };
   limSolve = derive { name="limSolve"; version="1.5.5"; sha256="1wcw4f95alsn1x1x98hlivc65p28ykq9njgjs561yl2zn4dyfqxf"; depends=[quadprog lpSolve MASS]; };
+  LindenmayeR = derive { name="LindenmayeR"; version="0.1-0"; sha256="0pkb6wgbn2iqszq4zr088x90k16jkk0r8pzmfpvzxv6k3m2lrv87"; depends=[stringr]; };
   LinearizedSVR = derive { name="LinearizedSVR"; version="1.3"; sha256="0h3xmlnd5x37r5hdhcz90z5n1hsbr2ci3m939i89p1x9644i2l5g"; depends=[kernlab LiblineaR expectreg]; };
   lineup = derive { name="lineup"; version="0.34-1"; sha256="0p6gxbv8xdrhgk8zdlnqrybald9vqz717czb49b123h84rjr2f19"; depends=[qtl class]; };
-  linkcomm = derive { name="linkcomm"; version="1.0-10"; sha256="1xs22cskrbk1yvsaa5dmnr62468z4baw6hy5m2jjcm854b42mkp9"; depends=[igraph RColorBrewer dynamicTreeCut]; };
+  linkcomm = derive { name="linkcomm"; version="1.0-11"; sha256="1w5sfmzvrk30fr161pk0cy5nj8kasqm6hqgyafq6r280b5s272cb"; depends=[igraph RColorBrewer dynamicTreeCut]; };
   linkim = derive { name="linkim"; version="0.1"; sha256="0yvyid9x59ias8h436a202hd2kmqvn8k1zcrgja2l4z2pzcvfn91"; depends=[]; };
   linLIR = derive { name="linLIR"; version="1.1"; sha256="1v5bwki5j567x2kndfd5nli5i093a33in31025h9hsvkbal1dxgp"; depends=[]; };
   linprog = derive { name="linprog"; version="0.9-2"; sha256="1ki14an0pmhs2mnmfjjvdzd76pshiyvi659zf7hqvqwj0viv4dw9"; depends=[lpSolve]; };
+  LinRegInteractive = derive { name="LinRegInteractive"; version="0.2-2"; sha256="1sy3l29m9ky918ql1hikh16y5z6k0cw55s34wb64a41lhs2dnb4y"; depends=[rpanel]; };
   LINselect = derive { name="LINselect"; version="0.0-1"; sha256="1n6nsspdp1ig8v9bclyga072hxqj2hb9n1smrqia8jrma07yaydl"; depends=[]; };
   lint = derive { name="lint"; version="0.3"; sha256="0lkrn5nsizyixhdp5njxgrgwmygwr663jxv5k9a22a63x1qbwpiq"; depends=[plyr harvestr stringr dostats foreach]; };
   liso = derive { name="liso"; version="0.2"; sha256="072l7ac1fbkh8baiiwx2psiv1sd7h8ggmgk5xkzml069ihhldj5i"; depends=[MASS Iso]; };
   lisp = derive { name="lisp"; version="0.1"; sha256="025sq46277q9i21189cbmx5dnrh5wfshc5k6la1wjilhr1iqf6nj"; depends=[]; };
   lisrelToR = derive { name="lisrelToR"; version="0.1.4"; sha256="0zicq0z3hhixan1p1apybnf3v5s6v6ysll4pcz8ivygwr2swv3p5"; depends=[]; };
-  list = derive { name="list"; version="6.1"; sha256="18yclnj71yknw46wy2f2hjhrg38fyklirgr0x5aibk7yywpry0qq"; depends=[sandwich VGAM magic gamlss_dist MASS quadprog arm corpcor mvtnorm coda]; };
+  list = derive { name="list"; version="7.0"; sha256="07i8gixsi34yq17832md2qgsnxgnbwq31bc5h8bwdxb08ndg8qlm"; depends=[sandwich VGAM magic gamlss_dist MASS quadprog arm corpcor mvtnorm coda]; };
   LIStest = derive { name="LIStest"; version="2.1"; sha256="1gk253v3f1jcr4z5ps8nrqf1n7isjhbynxsi9jq729w7h725806a"; depends=[]; };
-  llama = derive { name="llama"; version="0.7"; sha256="01hxphrii5lydg3yivrl0yg45ilma9a3g0r6rh44vak79zc6gxz7"; depends=[mlr plyr rJava parallelMap]; };
+  llama = derive { name="llama"; version="0.7.2"; sha256="115j944891mf6sba2bk1lhb8ksdw2halncjvf1j9wsjb6d41liha"; depends=[mlr plyr rJava parallelMap]; };
   lle = derive { name="lle"; version="1.1"; sha256="09wq7mzw48czp5k0b4ij399cflc1jz876fqv0mfvlrydc9igmjhk"; depends=[scatterplot3d MASS snowfall]; };
-  lllcrc = derive { name="lllcrc"; version="1.1"; sha256="0m4dqg774d0pzpwvr4hj50xdz93y83w0yjcial8b14wy8zcdsmmz"; depends=[data_table combinat VGAM plyr]; };
+  lllcrc = derive { name="lllcrc"; version="1.2"; sha256="06n1fcd3g3z5rl2cyx8jhyscq9fb52mmh0cxg81cnbmai3sliccb"; depends=[data_table combinat VGAM plyr]; };
   lmbc = derive { name="lmbc"; version="0.9.1"; sha256="0pxm29n8rhcy7g8kia0bgz78w5nr851dhhrb7nn13szw6j13ji8x"; depends=[mseq lars]; };
-  lm_beta = derive { name="lm.beta"; version="1.0"; sha256="13n9y9q4igqswvf4yfjk15gqa81z3kc7l0hizr3ssxpa8x9igpc5"; depends=[]; };
+  lm_beta = derive { name="lm.beta"; version="1.5"; sha256="1f7bmfjmz90snfjkvx54knwgav3r6fr85wayi19bwljh1d57wv1i"; depends=[]; };
   lm_br = derive { name="lm.br"; version="2.5"; sha256="0v4gam24gny4g5618kakamryw0aq62wb9k7w6n3wq397mysnkd15"; depends=[Rcpp]; };
   lme4 = derive { name="lme4"; version="1.1-7"; sha256="0v9vl9rspakyw2dmcl5lbhv1nlg10yhgdvi3gpfnizln7xw9ksyp"; depends=[Matrix Rcpp MASS nlme lattice minqa nloptr]; };
   lmec = derive { name="lmec"; version="1.0"; sha256="09shj01h2dl5lh7ch0wayr7qyhlmk0prv3p1vfgy91sn0wpbqlxr"; depends=[mvtnorm]; };
   lmeNB = derive { name="lmeNB"; version="1.2"; sha256="0xgw1kmq3krz8z0ickjg6qkj3bq2bkbwcd79c5fkl6fa3hp035mh"; depends=[numDeriv statmod lmeNBBayes]; };
   lmeNBBayes = derive { name="lmeNBBayes"; version="1.2"; sha256="0zpxdgqv5yhpwl2jfrxx37b126pgrflynmw9i4vmcvzx830d084l"; depends=[]; };
+  lmenssp = derive { name="lmenssp"; version="1.0"; sha256="0a1q9ax0pnz9gcv4nzgay9lznaz9gp27jj6vp6la7vfhrfg5qcg6"; depends=[MASS nlme]; };
   LMERConvenienceFunctions = derive { name="LMERConvenienceFunctions"; version="2.5"; sha256="1kq0ww8h43rsygjz5pmb3ym027klgi4sw1csdr9apwgd3ydbnr7n"; depends=[Matrix lme4]; };
   lmerTest = derive { name="lmerTest"; version="2.0-11"; sha256="151zgpqabvq1m58632caw9q298y7zh4aw059hdfzx9p8z7104ris"; depends=[Matrix lme4 numDeriv MASS Hmisc gplots pbkrtest]; };
   lmeSplines = derive { name="lmeSplines"; version="1.1-10"; sha256="0fy6hspk7rqqkzv0czvvs8r4ishvs7zsf4ykvia65nj26w7yhyia"; depends=[nlme]; };
   LMest = derive { name="LMest"; version="1.0"; sha256="0i76wkj8a95pa5spxsaxbkk2nyrjdlnzri9739n3h08sagwc0y67"; depends=[MASS Matrix]; };
+  lmeVarComp = derive { name="lmeVarComp"; version="1.0"; sha256="17zrl33h4lcd8lpdv3d12h5afj8nxr2lyw6699zq4fds2chbq66l"; depends=[]; };
   lmf = derive { name="lmf"; version="1.2"; sha256="1xqlqmjl7wf5b2s2a1k1ara21v74b3wvwl4mhbj9dkdb0jcrgfva"; depends=[]; };
   lmm = derive { name="lmm"; version="0.9"; sha256="0gs68iwk9gajb5af5ibgg9k5280ixqki8vxyp3cq5lrk96gcmqpr"; depends=[]; };
   lmmfit = derive { name="lmmfit"; version="1.0"; sha256="06mzmx7md7qw5mfhgdljc7i40sx9yrx7j57xbbp3fhl2zs1dpb4g"; depends=[nlme MASS]; };
   lmmlasso = derive { name="lmmlasso"; version="0.1-2"; sha256="1mvd38k9npyc05a2x7z0908qz9x4srqgzq9yjyyggplqfrl4dgsz"; depends=[emulator miscTools penalized]; };
-  lmms = derive { name="lmms"; version="1.0"; sha256="1qisic9ha764nl8xscf17r2chhx1jp8s2hv189ksc6wl34dcxvqq"; depends=[nlme lmeSplines reshape gdata]; };
+  lmmot = derive { name="lmmot"; version="0.1.1"; sha256="134rw5sy6ibpp5cn3hayym4l2s5cr0123ygk2rjf54j5mf52szm3"; depends=[maxLik MASS]; };
+  lmms = derive { name="lmms"; version="1.1"; sha256="1kbfv6g1r4kdij2mz3a32sy9r3i961xxvmwhb1k0jjhhvc5y74f4"; depends=[nlme lmeSplines reshape gdata gplots ggplot2]; };
   lmodel2 = derive { name="lmodel2"; version="1.7-2"; sha256="0dyzxflr82k7ns824zlycj502jx3qmgrck125im2k2da34ir3m3q"; depends=[]; };
   lmom = derive { name="lmom"; version="2.4"; sha256="04mfp7fcw1696qn34pxdffspwy0xalig3p7mqcj49v6kdxclpx1p"; depends=[]; };
   lmomco = derive { name="lmomco"; version="2.1.1"; sha256="0q58g13j7h8pag3yj96qpnsa2m77hrrjkc24f6x847vlsn39md80"; depends=[]; };
   Lmoments = derive { name="Lmoments"; version="1.1-5"; sha256="13s9lbmfbjfam6xg0q9jl2p3q3db3pimcmnx47vx82qdm43xa4an"; depends=[]; };
   lmomRFA = derive { name="lmomRFA"; version="3.0"; sha256="188i2fk2csqwdmw3x1wwigaajbvwfd9dwd8q3pmx7ha4smp49amk"; depends=[lmom]; };
-  lmSupport = derive { name="lmSupport"; version="1.07.1"; sha256="1smv1ag12373981qqhlrdf4xj73j2h0jblb74gd2w70zrbx0s2qb"; depends=[car psych gplots gvlma MASS]; };
+  lmSupport = derive { name="lmSupport"; version="2.9.1"; sha256="11c86ji7srv80zlrp6c8ark312xzvajig8flc5qm77dgacik8daq"; depends=[car psych gvlma AICcmodavg lme4 pbkrtest]; };
   lmtest = derive { name="lmtest"; version="0.9-33"; sha256="1ycmxjrxf41mnbgakdmn4y2kmgp4rkj7v3nqwqnlc6gdfdmac73s"; depends=[zoo]; };
   loa = derive { name="loa"; version="0.2.15"; sha256="137l90qz87xrid28knbj8997pjqgqf6769cwfj82cm57m98bda91"; depends=[lattice MASS png RgoogleMaps RColorBrewer]; };
   localdepth = derive { name="localdepth"; version="0.5-7"; sha256="0h0y74xnhdqa7y51ljmpz7ayznppvy2ll06wfds6200lb9cxgr7k"; depends=[circular]; };
   localgauss = derive { name="localgauss"; version="0.33"; sha256="1xgcwlgkzkxws771zig4x6v0m6flf9vlcgpa80ajr0vmjhlplbly"; depends=[ggplot2 MASS foreach matrixStats]; };
   localsolver = derive { name="localsolver"; version="2.3"; sha256="1d18rihzqf1f5j9agfp8jysll7lqk1ai23hkdqkn6wwxj442llv4"; depends=[]; };
-  locfdr = derive { name="locfdr"; version="1.1-7"; sha256="1ix64nf0lymvqfks399871ynyph32x4yhymdw0nw59jh3c3ldhxx"; depends=[]; };
   locfit = derive { name="locfit"; version="1.5-9.1"; sha256="0lafrmq1q7x026m92h01hc9cjjiximqqi3v1g2hw7ai9vf7i897m"; depends=[lattice]; };
   locits = derive { name="locits"; version="1.4"; sha256="1q9vsf5h4n7r4gy1dwdhfyq3n0rn33akb3nx6yzinncj4w4cqq0h"; depends=[wavethresh igraph]; };
   Lock5Data = derive { name="Lock5Data"; version="2.6"; sha256="0ckaac00ck5vyv0gv25l1zhgkm3char6ks1p4fl3vdl5gdyrc1pp"; depends=[]; };
   locpol = derive { name="locpol"; version="0.6-0"; sha256="1zpdh3g7yx3rcn3rhlc3dm19c4b9kx2k8wy8vkwh744a1kysvdga"; depends=[]; };
   loe = derive { name="loe"; version="1.0"; sha256="11wjzq4h7qjrnrj1zg3msg1ksld9c3r3n3biamf2hz8zvi1asvqv"; depends=[igraph MASS vegan Matrix]; };
-  log4r = derive { name="log4r"; version="0.1-4"; sha256="1wgn9gywkldfzxgpdfj84l05zw6y84bwzjr7q6fjddfdvxmdwa5n"; depends=[]; };
+  log4r = derive { name="log4r"; version="0.2"; sha256="07q8m7z2sxm6n25a62invf76qakxdsijfh3272spc8xrmdmyw6rj"; depends=[]; };
+  logbin = derive { name="logbin"; version="1.0"; sha256="17vabb348kczn839mhwshn20qgrdnpd0ll81hb8bcsricm6dqhna"; depends=[glm2]; };
   LogConcDEAD = derive { name="LogConcDEAD"; version="1.5-9"; sha256="135vkp70q6gn75ds43aq08y13vrsgsgykssmnhrh6545i86vmhhi"; depends=[MASS mvtnorm]; };
   logconcens = derive { name="logconcens"; version="0.16-4"; sha256="11bk03kjlb747g54axmb0nayz226g41xvanbw79aij76vjbglv7y"; depends=[]; };
-  logcondens = derive { name="logcondens"; version="2.1.1"; sha256="1anawy47g2bmpi5x4s9dqw82c51mv98wfy39sikb1jixbs40mqgp"; depends=[]; };
+  logcondens = derive { name="logcondens"; version="2.1.2"; sha256="0lnsyjl77l9024pqncyxwivmj05f5mfa3563jql47jajaai0my8y"; depends=[ks]; };
   logcondens_mode = derive { name="logcondens.mode"; version="1.0.1"; sha256="1i2c2prk5j863p3a3q3xnsv684igfi5czz3dib7zfjldpf0qyaq7"; depends=[logcondens distr]; };
   logcondiscr = derive { name="logcondiscr"; version="1.0.5"; sha256="170rg4rqch0mlhmc1zc59h271b57y3xfxrc3gh9pwvc9r11gw7k5"; depends=[Matrix mvtnorm cobs]; };
+  logconPH = derive { name="logconPH"; version="1.3"; sha256="1fmv2zp48pvyimyz3czfr13q09f8hj4pjdf1fh53rfdir8gvgv5g"; depends=[]; };
   logging = derive { name="logging"; version="0.7-103"; sha256="1sp7q217awizb6l8c9p5dix6skpq8j7w8i088x4mm0fc0qr1ba5c"; depends=[]; };
+  LogicForest = derive { name="LogicForest"; version="2.1.0"; sha256="0zdyyi6wka0568414f1kw91rx04y76n1k11wxd4r8svb5wybjhp5"; depends=[LogicReg CircStats gtools plotrix]; };
   LOGICOIL = derive { name="LOGICOIL"; version="0.99.0"; sha256="1wgg7kigzzk5ghjn3hkjf1bb8d6mvjfmkwq64phri5jpxd742ps9"; depends=[nnet]; };
   LogicReg = derive { name="LogicReg"; version="1.5.5"; sha256="1lccxiafi2g2jmzaklcgman5zgax2rvfh61qzwz1w0p57460m581"; depends=[survival]; };
   logistf = derive { name="logistf"; version="1.21"; sha256="0cwbmd0mvj4wywpx7p4lhs70nhab7bfl6fzz2c4snn3ma6sy7x8c"; depends=[mice mgcv]; };
   LogisticDx = derive { name="LogisticDx"; version="0.1"; sha256="1w530panmbwf4qplzzj02q9g2lfzrkawxy66ibwdd14z9bwjdclj"; depends=[multcomp data_table pROC car gRbase rms statmod speedglm]; };
-  logistiX = derive { name="logistiX"; version="1.0-1"; sha256="0k2658hph4h9v0f1c4nd0zi72xzf7l4ivhy063y01zx61q8dbi8q"; depends=[]; };
-  logitchoice = derive { name="logitchoice"; version="0.9.1"; sha256="16019836wf1vhs49qmw9z53px4l20ggg4k6lhlll8l91q0mkisk3"; depends=[]; };
+  logitchoice = derive { name="logitchoice"; version="0.9.4"; sha256="1vkw7cwp7nwrsj9ifn4gz21zbw9da5rph9lr3w466zxkzdkbldqj"; depends=[]; };
   LogitNet = derive { name="LogitNet"; version="0.1-1"; sha256="08xi5rpbqkc1b3qj24blv3l0r68wcqbsbjcqxiypm75f3c2irc4i"; depends=[]; };
   logitnorm = derive { name="logitnorm"; version="0.8.29"; sha256="0wbdxh3n44nzb6c0ahyd8gndfql1y56fns2bkmzqi3nxy9blhx18"; depends=[]; };
   loglognorm = derive { name="loglognorm"; version="1.0.1"; sha256="0rhx769a5nmidpbpngs2vglsbkpgw9badz3kj3jfmpj873jfnbln"; depends=[]; };
   logmult = derive { name="logmult"; version="0.6"; sha256="1r8i2zgmgm44dhg2z2k7cqy10hldp1p91idjiyg9pmi8dfch8xki"; depends=[gnm qvcalc]; };
   LogrankA = derive { name="LogrankA"; version="1.0"; sha256="005zkpzi8h03qvqlpkygrf9xv4q77klafkfxw47x04jvkhklwigb"; depends=[]; };
-  logregperm = derive { name="logregperm"; version="1.0"; sha256="002s5a71m3ykyypq8gw4xa642xnbp2rjwd1cxnf0rkgmshngqaik"; depends=[]; };
   logspline = derive { name="logspline"; version="2.1.5"; sha256="18hpzcg71v3zjzp92whgxgn7w87cadgxr65pp7nv6m5pvj130i3p"; depends=[]; };
   lokern = derive { name="lokern"; version="1.1-5"; sha256="0fgpkmz8jy77sb0m862j7v32lj9d3x373na1102wvq164jjhyqg2"; depends=[sfsmisc]; };
   lomb = derive { name="lomb"; version="1.0"; sha256="06lbk7s1ilqx6xsgj628wzdwmnvbs0p03hdpx8665fhddcxh3ryy"; depends=[]; };
···
   lpc = derive { name="lpc"; version="1.0.2"; sha256="1r6ynkhqjic1m7fqrqsp7f8rpxqih5idn4j96fqrdj8nj01znv29"; depends=[]; };
   LPCM = derive { name="LPCM"; version="0.44-8"; sha256="14627wk5azxm3y3a0qfy4qz57nxbdcasnv7djpqhk2gxf5smq19k"; depends=[]; };
   lpint = derive { name="lpint"; version="2.0"; sha256="0p1np8wlfbax0c7ysc5fs9dai8s00h1v0gan89dbd6bx06307w2r"; depends=[]; };
-  LPmerge = derive { name="LPmerge"; version="1.5"; sha256="0qy3j6xnsk5h2lmx3mx2q4b5g4vip54nh2f85zg5ncg0x5qqrizb"; depends=[Rglpk Matrix]; };
+  LPmerge = derive { name="LPmerge"; version="1.6"; sha256="0xc06s2p7n151lzrp0dcrrxk8zmd816dc7qbnbcail5c1bhvdqhd"; depends=[Rglpk Matrix]; };
   lpmodeler = derive { name="lpmodeler"; version="0.2-1"; sha256="17k67l03dkjx61p4hwswghjm6awk0zx173x9xafxrfd8jrgsf6kf"; depends=[slam]; };
   lpridge = derive { name="lpridge"; version="1.0-7"; sha256="0nkl70fwzra308bzlhjfpkxr8hpd8v1xdnah7nscxa10qlisgr2k"; depends=[]; };
   LPS = derive { name="LPS"; version="1.0.4"; sha256="0dy45nn1bmzd17y2dsh4pf4jmh9qvifigvpg2lv2zrmvlx53cli5"; depends=[]; };
···
   LS2W = derive { name="LS2W"; version="1.3-3"; sha256="0pdsv7ld0j116rh94m5y1i2mwrzc80fqxmc6ykc51i1sj6ws3i5k"; depends=[wavethresh]; };
   LS2Wstat = derive { name="LS2Wstat"; version="2.0-3"; sha256="0wkh1a6xbp3qg5favxsj166jcgdza16zki675gswxckana6s4is7"; depends=[LS2W matrixStats geoR RandomFields spdep]; };
   lsa = derive { name="lsa"; version="0.73"; sha256="041wa1i85i90qvm5sxvd9nidis8s069cvf9nw1r68ajkvds65y91"; depends=[SnowballC]; };
-  LSAfun = derive { name="LSAfun"; version="0.3.1"; sha256="15sa3hq2x6wna8bv9mry06k80kvhf1kkl6zfybwzc953vxp6yijp"; depends=[lsa rgl]; };
+  LSAfun = derive { name="LSAfun"; version="0.3.2"; sha256="1pxa3paq7kq07h3a14hdkx4s3g3dq4wn2q5nvp1083gg0zk0fpgh"; depends=[lsa rgl]; };
   LSC = derive { name="LSC"; version="0.1.5"; sha256="1nlnwqb24sbgvl96azh8a833ij5xknjr2wr8shs59lm2n63a3ql9"; depends=[LICORS RColorBrewer fields gam Matrix]; };
   LSD = derive { name="LSD"; version="2.5"; sha256="0j7lmsz93q2zv9y05aan5pwhpzh8m1i45mh4p386g7bvfrwlmxbx"; depends=[MASS gtools RColorBrewer colorRamps schoolmath ellipse]; };
   lsdv = derive { name="lsdv"; version="1.1"; sha256="0rl1xszr9r8v71j98gjpav30n2ncsci19hjlc9flzs1s20sb1xpr"; depends=[]; };
   lsgl = derive { name="lsgl"; version="1.0.123.0"; sha256="15chgzds2vb4jgw7vzday6km7i92g6ifpj0a2x9s4nvrdzh9y8di"; depends=[sglOptim Matrix]; };
   lshorth = derive { name="lshorth"; version="0.1-6"; sha256="0nbjakx0zx4fg09fv26pr9dlrbvb7ybi6swg84m2kwjky8399vvx"; depends=[]; };
-  lsmeans = derive { name="lsmeans"; version="2.11"; sha256="15cvdc4mzk9qr9zq5adkabzs1bkpnl2cf8mhsdc1jgm521ff4w26"; depends=[multcomp plyr Matrix]; };
+  lsmeans = derive { name="lsmeans"; version="2.12"; sha256="0j8kh3wbazw2pa3i10qwbimajr8a9d77g1h2hg2pq26525c4ahmx"; depends=[multcomp plyr Matrix]; };
   LSMonteCarlo = derive { name="LSMonteCarlo"; version="1.0"; sha256="0w5042phkba5dw92r67ppp2s4khjpw5mm701dh9dya9lhj88bz6s"; depends=[mvtnorm fBasics]; };
   lspls = derive { name="lspls"; version="0.2-1"; sha256="1g27fqhnx9db0zrxbhqr76agvxy8a5fx1bfy58j2ni76pki1y4rl"; depends=[pls]; };
   lsr = derive { name="lsr"; version="0.3.2"; sha256="1ahcj3ja5hj7pc7hvzlvhmh62mql3a0awli8szsyld0fpn50wprz"; depends=[]; };
   lss = derive { name="lss"; version="0.52"; sha256="1fvs8p9rhx81xfn450smnd0i1ym06ar6nwwcpl74a66pfi9a5sbp"; depends=[quantreg]; };
-  ltbayes = derive { name="ltbayes"; version="0.3"; sha256="1b35bwli08yzgv3idg86wz8fzpx7r5sx0ryr950rdh0n2jdml09q"; depends=[mcmc MHadaptive numDeriv]; };
   ltm = derive { name="ltm"; version="1.0-0"; sha256="1igkgb0jy3mzlnp9s6avhcpplwijz5g3x26a3lavyy3d9fjpmfpa"; depends=[MASS msm polycor]; };
   ltmle = derive { name="ltmle"; version="0.9.3-1"; sha256="0nvcxl55nmcabsz79vkjxmnifzm2vxg0lgwcjqiwsj242vhnfjhh"; depends=[]; };
   LTPDvar = derive { name="LTPDvar"; version="1.1"; sha256="0zb3ffz5vw1zabgzhpcw1mzfqh4g7r0sq4iy31nzyv8smdwddqzw"; depends=[]; };
···
   lubridate = derive { name="lubridate"; version="1.3.3"; sha256="1f07z3f90vbghsarwjzn2nj6qz8qyfkqalszx8cb5kliijdkwy8z"; depends=[plyr stringr memoise]; };
   luca = derive { name="luca"; version="1.0-5"; sha256="1jiqwibkrgga4ahz0qgpfkvrsxjqc55i2nwnm60xddb8hpb6a6qx"; depends=[survival genetics]; };
   Luminescence = derive { name="Luminescence"; version="0.3.4"; sha256="036kib458qwr1l1pl1nb4hip43rchmx7qwf32y8z7b8nf9b8sbvy"; depends=[Rserve XML shape rgl matrixStats]; };
+  lunar = derive { name="lunar"; version="0.1-04"; sha256="0nkzy6sf40hxkvsnkzmqxk4sfb3nk7ay4rjdnwf2zym30qax74kk"; depends=[]; };
   lvm4net = derive { name="lvm4net"; version="0.1"; sha256="0b140jybn6jpr1qh3s84vg0ba34356vc8pa4v2zfp9ggipfl073b"; depends=[ergm ellipse igraph]; };
   LVMMCOR = derive { name="LVMMCOR"; version="0.01.1"; sha256="1lq4hqcg0qkywdr4a22m1fr3m97749mm6n2jzdj9i7jrf0agc1fs"; depends=[nlme MASS]; };
   LVQTools = derive { name="LVQTools"; version="1.2"; sha256="06mninrrr49xsh00gfsp0vc418r6pdvq3m6sbnj0ywdyki106mni"; depends=[]; };
   lxb = derive { name="lxb"; version="1.3"; sha256="0mvjk0s9bzvznjy0cxjsqv28f6jjzvr713b2346ym4cm0y4l3mir"; depends=[]; };
   lymphclon = derive { name="lymphclon"; version="1.2.3"; sha256="0dvyihghjamqmhn9lvh1qblqh946b9ldnxyhb6z1gi57pyfgq00w"; depends=[VGAM MASS expm corpcor]; };
   M3 = derive { name="M3"; version="0.3"; sha256="1l40alk166lshckqp72k5zmsgm7s5mgyzxlp11l64mgncjwkw2r3"; depends=[ncdf4 rgdal maps mapdata]; };
+  m4fe = derive { name="m4fe"; version="0.1"; sha256="06lh45591z2lc6lw91vyn066x0m1zwxxfp6nbirp1rz901v843ph"; depends=[]; };
   MAc = derive { name="MAc"; version="1.1"; sha256="1lshi5rb8l2mpd302wskhlk5vz1wjidvbss9y69l63zjqdwjs7ch"; depends=[]; };
   MAclinical = derive { name="MAclinical"; version="1.0-5"; sha256="1g0ka1kqww2xim8rp5rznkzn0a541zvf841s3lbphfh9k3y3ixs3"; depends=[party plsgenomics st e1071]; };
   MAd = derive { name="MAd"; version="0.8-1"; sha256="16lis6q61d11z0kn3svd77yr0k3jm0zhqpwacl86jdjlmn67l92i"; depends=[]; };
···
   madsim = derive { name="madsim"; version="1.1"; sha256="1d9mv769zia43krdfl43hp22cp5mdi3ycwj3kxyfcjrg23bjnyc0"; depends=[]; };
   Maeswrap = derive { name="Maeswrap"; version="1.4.11"; sha256="15i36xj2bdzhly78614077s8k2z75a1gmzl2crsfgvhyyjdax8r7"; depends=[rgl lattice geometry]; };
   magic = derive { name="magic"; version="1.5-6"; sha256="1399w1zhz79nj8cdhslybncd9h6rylfhb548nv22ip0dxxdkyv0v"; depends=[abind]; };
-  magicaxis = derive { name="magicaxis"; version="1.9"; sha256="0v851arnpc15h7ccqwjlz52jv83ij96r4b44qkm45ipr9dfm84zf"; depends=[MASS plotrix sm]; };
+  magicaxis = derive { name="magicaxis"; version="1.9.3"; sha256="0dxlqpxw82v9cxfp475ppd02ywvlg96b1cfj02fjvs04xfprhar0"; depends=[MASS plotrix sm]; };
   magma = derive { name="magma"; version="1.3.0-2"; sha256="0hgwjq30ksx2qg4q9fj57m27i96sci8hrfrqc2lw4hz18b6kkph4"; depends=[]; };
   magrittr = derive { name="magrittr"; version="1.0.1"; sha256="0syb8dpcqag392any8s7shgqv4s33q3ppwnpmih31yhz875k3aaw"; depends=[]; };
   mail = derive { name="mail"; version="1.0"; sha256="1m89cvw5ba4d87kp2dj3f8bvd6sgj9k56prqmw761q919xwprgw6"; depends=[]; };
   mailR = derive { name="mailR"; version="0.3"; sha256="0m23npg5zsdwflw4744v30ypnpa6f8ddflwh3mpabxrxw4scb547"; depends=[rJava stringr]; };
-  MAINT_Data = derive { name="MAINT.Data"; version="0.2"; sha256="0kmvz3s6ci9zi9k3vvrkl7jwqfjgdfk7b6xv7dskjh6mbgpcqcf4"; depends=[MASS sn miscTools]; };
+  MAINT_Data = derive { name="MAINT.Data"; version="0.3"; sha256="1qh7kdcnwfibzyhr53inqjz61srbpypcqjri60zdl32jpf109vng"; depends=[MASS miscTools]; };
   makeProject = derive { name="makeProject"; version="1.0"; sha256="09q8xa5j4s5spgzzr3y06l3xis93lqxlx0q66s2nczrhd8nrz3ca"; depends=[]; };
   malaria_em = derive { name="malaria.em"; version="2.0"; sha256="1n34ahifggpdlpmigy010zysana0fg9c8ji0khk8g3il2gmzmgim"; depends=[]; };
   MALDIquant = derive { name="MALDIquant"; version="1.11"; sha256="1jnpmv44j9zry64wvnv37hcda61570hypnv16z99arjazpi4nzmn"; depends=[]; };
···
   MAMA = derive { name="MAMA"; version="2.2.1"; sha256="1dcyfir6jv28jzvphiqrjns3jh2zg2201iwcvjzbmddl2isk9h0i"; depends=[metaMA xtable gtools xtable]; };
   MAMS = derive { name="MAMS"; version="0.3"; sha256="17d75phlxi9267dwpzmnzpk01l69xvcdqjjabj0ai7j2l6llp2n9"; depends=[mvtnorm]; };
   MAMSE = derive { name="MAMSE"; version="0.1-3"; sha256="06q6raqbyi9zwg3wzaygqmfs3di55fh4bln3vscdw95kma4hz9km"; depends=[]; };
-  Mangrove = derive { name="Mangrove"; version="1.1"; sha256="15dzxsm982v7sskqh31fdiiqyac37l00i51z3f4nk3zpz6gq2nw5"; depends=[]; };
+  managelocalrepo = derive { name="managelocalrepo"; version="0.1.4"; sha256="060r9wkrn2v6wij926l7qlxlw8k2zbgrmwf2awf1x6llfs4vaiby"; depends=[stringr assertthat]; };
   ManyTests = derive { name="ManyTests"; version="1.1"; sha256="11xk3j2q7w6b6ljmp7b8gni0khpmpvcvzwxypy0w8ihi2gaczsxj"; depends=[]; };
   Map2NCBI = derive { name="Map2NCBI"; version="1.0"; sha256="02cgmayrhkyji0cwr6n0f439njq29mzna7sgzkq6ml45njm9m5nh"; depends=[]; };
-  MAPA = derive { name="MAPA"; version="1.7"; sha256="1xw9slmhn6r0cczp37m75l944vggnjwinx2p4jkkya445mvgyhjy"; depends=[forecast]; };
+  MAPA = derive { name="MAPA"; version="1.8"; sha256="0x03gr20qd5fwczljyz78pqmn6abs0sgv6zq2mz40a2xx12fp3qr"; depends=[forecast]; };
   mapdata = derive { name="mapdata"; version="2.2-3"; sha256="1fhj34cgq6rniy0339qv2ghbs0aiq38h9jfwx7szb83yj37v7wm6"; depends=[maps]; };
   MapGAM = derive { name="MapGAM"; version="0.7-0"; sha256="00ggr7wrkz13n1f9gsp3qxxjwb01kq47aqv2mj4pa6p253iw19i7"; depends=[gam maptools]; };
   MAPLES = derive { name="MAPLES"; version="1.0"; sha256="0hzsh7z1k7qazpxjqbm9842zgdpl51irg7yfd119a7b2sd3a8li9"; depends=[mgcv]; };
-  mapmisc = derive { name="mapmisc"; version="0.9.4"; sha256="0qsv36sk6fd3ix85yagl86y2r1kkl3qry0g0k6d0rb87aaxmk86i"; depends=[sp raster]; };
-  mapplots = derive { name="mapplots"; version="1.4"; sha256="0wwz52hjhp2xzw38zsvbk5cgdfr58rakjnmficjr305x88kisz20"; depends=[]; };
+  mapmisc = derive { name="mapmisc"; version="1.0.0"; sha256="0y4p1fs6kqiwlp41kn7r5z2222xcqgzdnl9q4v0dlawfck2kbzcw"; depends=[sp raster]; };
+  mapplots = derive { name="mapplots"; version="1.5"; sha256="09sk78a0p8hlwhk3w2dwvpb0a6p7fqdxyskvz32p1lcav7y3jfrb"; depends=[]; };
   mapproj = derive { name="mapproj"; version="1.2-2"; sha256="1fdb72hvcp6jm7rhvs8zdkya6ifs92lfqnmq5vj5amwckkxfidc6"; depends=[maps]; };
-  maps = derive { name="maps"; version="2.3-7"; sha256="01bzy9xqa5fhqjhvwrxygkk5ym3rl9kz86frpby735bx5qy6ij4b"; depends=[]; };
+  maps = derive { name="maps"; version="2.3-9"; sha256="1gzy81sl4vpr4hsnh4jsp5rd26jdkzsw99qxwfmbadjyf55q06wv"; depends=[]; };
   mapStats = derive { name="mapStats"; version="1.17"; sha256="1jnqchrrn2v1smzk1c3laycr2fs8x59c9mb8lhs4bxqbhhwgmi8p"; depends=[survey lattice maptools RColorBrewer Hmisc quantreg classInt sp colorspace reshape2]; };
   maptools = derive { name="maptools"; version="0.8-30"; sha256="0vbpgxdz6xl8a2bkhcw6rfs15nvmppka0ad7i2v2pi18350riwpq"; depends=[sp foreign lattice]; };
   maptpx = derive { name="maptpx"; version="1.9-1"; sha256="1yrlgz5bkjjs3m59dqp60n95lax0fp7xw00v59kymmw5hr3sis6f"; depends=[slam]; };
···
   MAR1 = derive { name="MAR1"; version="1.0"; sha256="1r6j890icl5h3m2876sakmwr3c65513xnsj68sy0y0q7xj3a039l"; depends=[leaps bestglm]; };
   mar1s = derive { name="mar1s"; version="2.1"; sha256="0psjva7nsgar5sj03adjx44pw0sdqnsd96m4g6k8d76pv30m1g7l"; depends=[cmrutils fda zoo]; };
   marelac = derive { name="marelac"; version="2.1.3"; sha256="155a8ijl2y8l4r980ml0p23jrwnf36xqsa8s1q6n7arhxwaknhxv"; depends=[shape seacarb]; };
+  MareyMap = derive { name="MareyMap"; version="1.2"; sha256="1l7s1ffl9bg1zx5nyb1r3dba188mxiaprdda3gqm2cr1f33jmr51"; depends=[tkrplot]; };
   marg = derive { name="marg"; version="1.2-2"; sha256="0j08zzcrj8nqsargi6xi50gy9pl4smmsp4b7ywlga7r1ga38g82r"; depends=[statmod survival]; };
   margie = derive { name="margie"; version="1.0"; sha256="1jkhg15xdiqjvpzbbc39l8jlfw0yrbarnd3zbgb3p0rh733x5g4j"; depends=[]; };
   marginalmodelplots = derive { name="marginalmodelplots"; version="0.4.2"; sha256="0d7m7sddz9rp1mkvirhcmk7hlbxsag3nm3vqfampnr7l2h158baa"; depends=[locfit]; };
-  markdown = derive { name="markdown"; version="0.7.2"; sha256="02dgi2q5gs359affvx0w2pvfcr25wqpzfvyc6labyfxmiw0gax13"; depends=[mime]; };
+  markdown = derive { name="markdown"; version="0.7.4"; sha256="09bqwv75mvfnjwbsz4v0zr9mmjdccwwgayiv7f6db48lngijng4f"; depends=[mime]; };
   marked = derive { name="marked"; version="1.1.6"; sha256="0f9sa4mdkiq1fn99sczb0glf5xfm17a3x8dq9ycf0l39fyg582d0"; depends=[lme4 R2admb truncnorm coda optimx ggplot2 Matrix numDeriv Rcpp plyr]; };
-  MarkedPointProcess = derive { name="MarkedPointProcess"; version="0.2.21"; sha256="06bypa124raa4vbcvi082vpd8bndnar4p1v18dq261z6j3ixk44k"; depends=[RandomFields R2Cuba]; };
   maRketSim = derive { name="maRketSim"; version="0.9.2"; sha256="1cq17zjwyf4i5lcqgxqkw805s4mr6qp89blgpmpxy8gdrbfj93m4"; depends=[]; };
   markovchain = derive { name="markovchain"; version="0.0.9.5"; sha256="06fsfrfm7xyba97yfxcp85vqamavbinvm8wr2darafn20ggahrck"; depends=[igraph Matrix matlab expm]; };
   MarkowitzR = derive { name="MarkowitzR"; version="0.1402"; sha256="1fbn6l8z76ak8z2nyzmizcjm7h54y58773nsy03x1pwykcwpzw9f"; depends=[matrixcalc sandwich gtools]; };
···
   marqLevAlg = derive { name="marqLevAlg"; version="1.1"; sha256="1wmqi68g0flrlmj87vwgvyxap0miss0n42qiiw7ypyj4jw9kwm8j"; depends=[]; };
   MARSS = derive { name="MARSS"; version="3.9"; sha256="0vn8axzz0nqdcl3w00waghz68z8pvfm764w11kxxigvjpw2plj31"; depends=[nlme mvtnorm KFAS]; };
   maSAE = derive { name="maSAE"; version="0.1-2"; sha256="18a1zbfmjhrmi3fgqd7vaicpsca59kp8r1003pwl7l4032p32fxk"; depends=[]; };
-  MASS = derive { name="MASS"; version="7.3-33"; sha256="1bq005zxyc7842z4cz5ilhh917clfdmhg5czfq6plkdgwq8nfhlk"; depends=[]; };
-  MASSI = derive { name="MASSI"; version="1.1"; sha256="13kavfsm48qq9zyp10scfjcgrk0x2n4my7cz2xy78s14knlrks5y"; depends=[fpc gplots]; };
+  MASS = derive { name="MASS"; version="7.3-35"; sha256="0kcyl2c6nk39fy6kprcxf4mwq8lkrwysgq6hwcrf4hspz79bnmd2"; depends=[]; };
   MASSTIMATE = derive { name="MASSTIMATE"; version="1.2"; sha256="1j9l8b5d518ag9ivzr1z4dd2m23y2ia1wdshx1krmshn8xsd6lwp"; depends=[]; };
   MasterBayes = derive { name="MasterBayes"; version="2.51"; sha256="0mbvhn6yspralmlajimdin14hszh78m0bxb3zdxd73xhjqxl4ixk"; depends=[coda genetics gtools kinship2]; };
-  MAT = derive { name="MAT"; version="0.1-3"; sha256="0z9kiji0kar286dcirsgrszd2kn6hcrfq8jhnn5pa2rfscgccdmj"; depends=[MASS]; };
+  MAT = derive { name="MAT"; version="2.0"; sha256="180gk64qc0708pzfmc1m50d7h2l90n2n5kbglpj2fcrwx31bk6rn"; depends=[Rcpp]; };
   Matching = derive { name="Matching"; version="4.8-3.4"; sha256="04m647342j4yi74ds7ddwnyrf58qdy7k3mc067k3p779qavq2ka1"; depends=[MASS]; };
+  MatchingFrontier = derive { name="MatchingFrontier"; version="0.3.17"; sha256="1z4sgvcivlnfhkgqi7jr7b6iwlwskwwnkw9hsaiy4apgki4m0ngn"; depends=[igraph MASS]; };
   MatchIt = derive { name="MatchIt"; version="2.4-21"; sha256="02kii2143i8zywxlf049l841b1y4hqjwkr1cnyv6b8b7y7lz2m5v"; depends=[MASS]; };
   mathgraph = derive { name="mathgraph"; version="0.9-11"; sha256="0xikgzn24p0qqlrmaydmjk5yz5pq2rilsvpx86n3p2k2fc3wpwjy"; depends=[]; };
-  maticce = derive { name="maticce"; version="1.0-3"; sha256="0nir60jbai0fisccrpkrnjm5z9lvhimhwfiqnmzxw4mjiifj41c2"; depends=[ouch ape]; };
   matie = derive { name="matie"; version="1.2"; sha256="1ymx49cyvz63imqw5n48grilphiqvvdirwsrv82p7jgxdyav2xv0"; depends=[dfoptim mvtnorm seriation igraph gplots cba]; };
   matlab = derive { name="matlab"; version="1.0.2"; sha256="0m21k2vzbc5d3c93p2hk4208xyd2av2slg55q5j1ibjidiryqgd2"; depends=[]; };
+  matpow = derive { name="matpow"; version="0.1.1"; sha256="1a6q21ba16qfdpykmjwgmrb1kkvvyx48qg8cbgpdmch0vhibcgcp"; depends=[]; };
+  matR = derive { name="matR"; version="0.9"; sha256="0lih3g2z6rxykprl3s529xcf466bpzpsv4l20dkgx1fgfslfcl2p"; depends=[MGRASTer BIOM_utils]; };
   Matrix = derive { name="Matrix"; version="1.1-4"; sha256="1pxkyfa09gf5rwk1x9hdxrgr1hjs4390h73z3f8h2224rszr3hqh"; depends=[lattice]; };
   matrixcalc = derive { name="matrixcalc"; version="1.0-3"; sha256="1c4w9dhi5w98qj1wwh9bbpnfk39rhiwjbanalr8bi5nmxkpcmrhp"; depends=[]; };
   MatrixEQTL = derive { name="MatrixEQTL"; version="2.1.0"; sha256="03ccawgrkv0r3y8smpym27p5bsxy8y9rhn7pqs9ybb385951azy9"; depends=[]; };
   MatrixModels = derive { name="MatrixModels"; version="0.3-1.1"; sha256="0b44gyvpfvhbkl1vymni7pplidz9a5jrcalswx19hnh5x14qw168"; depends=[Matrix]; };
-  matrixpls = derive { name="matrixpls"; version="0.3.0"; sha256="12qa1isj9609xj8qrr8ra8l711zagckim3nwvp7crrv4i6jm4299"; depends=[assertive matrixcalc psych lavaan MASS]; };
-  matrixStats = derive { name="matrixStats"; version="0.10.0"; sha256="15pgp50jyycp9hqrf6g9yz0gfv9a0w5yd9amw3vwn3mr202fab5f"; depends=[R_methodsS3]; };
+  matrixpls = derive { name="matrixpls"; version="0.4.0"; sha256="0vd8k7rkv2xwh8rx1ra9im9xqlal5r29gzbvxd2b33xwngvg89m2"; depends=[assertive matrixcalc psych lavaan MASS]; };
+  matrixStats = derive { name="matrixStats"; version="0.10.3"; sha256="1qskky9m217cv9pa5dyi31fa8isdg9cwadq80q85vn3p24rap5l4"; depends=[R_methodsS3]; };
   MATTOOLS = derive { name="MATTOOLS"; version="1.1"; sha256="1nzrkm3a08rpsd9vplyf33rrkadlrd0ln70k95qxj98ndh2v97px"; depends=[]; };
   MAVTgsa = derive { name="MAVTgsa"; version="1.3"; sha256="0rzal9nsi8y873cbf6hrdyzyxnpd4r1yr9fj66cn0s1c8g93ls0y"; depends=[corpcor foreach multcomp randomForest MASS]; };
   MaXact = derive { name="MaXact"; version="0.2.1"; sha256="1n7af7kg54jbr09qk2a8gb9cjh25cnxzj2snscpn8sr8cmcrij0i"; depends=[mnormt]; };
···
   mbest = derive { name="mbest"; version="0.1"; sha256="0dz54rgbl40cbrv6670qd441ymz43lj16dvd9fnq3znfafc1790n"; depends=[lme4]; };
   MBI = derive { name="MBI"; version="1.0"; sha256="1lb0sjwa6x360n9a9pagz6yhxh37gxq1fk0f5c3i2sd56ny9jpns"; depends=[]; };
   mblm = derive { name="mblm"; version="0.12"; sha256="17h65bapvz89g5in3gkxq541bxgpj9pciz6i5hzhqn0bdbsb3k6r"; depends=[]; };
-  MBmca = derive { name="MBmca"; version="0.0.3-3"; sha256="04v1xbkmrb196pm6a1ql8jdw2h126zzq5qni0mv3vh9wwnlnqlcs"; depends=[robustbase chipPCR]; };
+  MBmca = derive { name="MBmca"; version="0.0.3-4"; sha256="1vmzf7df3d5a9nilm4pvv31dyspazab2gm3i6ccqrffq0l93kdgi"; depends=[robustbase chipPCR]; };
   mbmdr = derive { name="mbmdr"; version="2.6"; sha256="0ss5w66hcgd8v8j9bbbp12a720sblhr2hy9kidqfr8hgjaqlch86"; depends=[logistf]; };
-  mboost = derive { name="mboost"; version="2.3-0"; sha256="1p4jqmnsp37jx52cw3k86zkbxr8qch710nszk173mqxcf77w28ip"; depends=[Matrix survival lattice nnls quadprog]; };
-  mc2d = derive { name="mc2d"; version="0.1-14"; sha256="1djnvwlq1qvvwhnmj3ijwyaqyp1k778i1yv6qmlj053lc38b54j7"; depends=[mvtnorm]; };
+  mboost = derive { name="mboost"; version="2.4-0"; sha256="1rv16vg7zfj9pl8pkzfh4pr79bsdnxhacv8pysf8bbr17hrvm8yn"; depends=[stabs Matrix survival lattice nnls quadprog]; };
+  mc2d = derive { name="mc2d"; version="0.1-15"; sha256="1kp2l1gvw3caplq9916s1dmpmfp6fb2xscys9gj6dykl6gi4h4hb"; depends=[mvtnorm]; };
   MC2toPath = derive { name="MC2toPath"; version="0.0.16"; sha256="0jdn9wpxavn2wrml907v23mfxr62wwjdh7487ihjj59g434ry7wh"; depends=[RNetCDF]; };
   MCAPS = derive { name="MCAPS"; version="0.3-2"; sha256="1jvxl9xi102pcs3swxlx4jk76i7i4fll88c92k7m379ik3r36alb"; depends=[stashR]; };
   MCAvariants = derive { name="MCAvariants"; version="1.0"; sha256="08c5qpklilj41agi5nzm4f5w41pdxk98i1wc1ahhnawc3n2cdbjz"; depends=[]; };
   mcbiopi = derive { name="mcbiopi"; version="1.1.2"; sha256="12h4bv3hx1m6bsqdxj5n3b5gh98ms508am8pigz7ckmv0xkyhx85"; depends=[]; };
   mcc = derive { name="mcc"; version="1.0"; sha256="0p661a870bvh3xhcahqqq85azn9rjl3vacjy96jsdn86irj4s0vi"; depends=[]; };
   mcclust = derive { name="mcclust"; version="1.0"; sha256="00qprmsjwbn2d0jl7p9mz8pv7k8ld3mzk862pr1grigk0lqwhx06"; depends=[lpSolve]; };
-  MCDA = derive { name="MCDA"; version="0.0.3"; sha256="0nfj5wlsjhj3z20jvdwl12r18rxnpk343r49j5awkh41qa0qyjr8"; depends=[Rglpk Kendall glpkAPI]; };
+  MCDA = derive { name="MCDA"; version="0.0.6"; sha256="0mkcvf4nllm3i2rw5kmrlzfw7lgz0mblrk1yihgnbf6wlm4v109c"; depends=[Rglpk Kendall glpkAPI]; };
   mcga = derive { name="mcga"; version="2.0.9"; sha256="197yldx03c634f3x0mpxxvqrys93n7z7n3x0alvqa42z3vdkrz7b"; depends=[]; };
   mcgibbsit = derive { name="mcgibbsit"; version="1.1.0"; sha256="09ydcbjz3abmh46966v01dh26fy79dfklk3zjf262zp3c62ld9yf"; depends=[coda]; };
   mcGlobaloptim = derive { name="mcGlobaloptim"; version="0.1"; sha256="1p8841y9a4yq51prv6iirgw9ln8jznx8nk547sc5xlznksjy1g9n"; depends=[randtoolbox snow]; };
   mcheatmaps = derive { name="mcheatmaps"; version="1.0.0"; sha256="1gglm32xpmim38m7fziczgqfbpcq2899lxardsrzg6j1vhmf765y"; depends=[gridBase]; };
   MChtest = derive { name="MChtest"; version="1.0-2"; sha256="01lflilrp42m236cznn6qgzvv5v9fzpx6wcfxp3q545bw2xmbdvj"; depends=[]; };
-  mcIRT = derive { name="mcIRT"; version="0.40"; sha256="1mqyivxgg0mzhlvl3swgicb78ikk998yab0ssmbagbk24amr1q7h"; depends=[Rcpp RcppArmadillo]; };
+  mcIRT = derive { name="mcIRT"; version="0.41"; sha256="0pbwydl4zjzwdlpzwpqm4xhq716zgq9s7bvcbrqp6q0jkba9zjnw"; depends=[Rcpp]; };
   mcll = derive { name="mcll"; version="1.2"; sha256="0i9zqbh0l9a9mv4558gbdq9mh52chanykyfwmiymmxygxhp809sz"; depends=[statmod locfit]; };
-  mclogit = derive { name="mclogit"; version="0.2-7"; sha256="1ykkrbbnha7npmxr79qc7x77xa3847rjcax6gxrala5s07yg7sww"; depends=[memisc Matrix]; };
-  mclust = derive { name="mclust"; version="4.3"; sha256="0ii3w4d66p47i0xmjl9gz4g36piqz3b2kny876qdfjj7wh9m7hpl"; depends=[]; };
+  mclogit = derive { name="mclogit"; version="0.3-1"; sha256="0zyms6v9qjh6a5ccahfanarp4sg49yingb8wpjcz61skqvm8j7qx"; depends=[Matrix]; };
+  mclust = derive { name="mclust"; version="4.4"; sha256="1xwk5w3nzwmwavn1ni53bnhf3klvy65c05819j1aqa6dna1j1jkq"; depends=[]; };
   mcmc = derive { name="mcmc"; version="0.9-3"; sha256="148l28nb1qv82x2hj46c26yhn0lw8x5jsrp2dav9sbysv1bdj2f8"; depends=[]; };
   MCMCglmm = derive { name="MCMCglmm"; version="2.21"; sha256="1mjjp65w7pg2kxrx2qf0lh1kdi9d21xxj7s39zhi3q8ixw35h95r"; depends=[Matrix coda ape corpcor tensorA]; };
   MCMChybridGP = derive { name="MCMChybridGP"; version="4.3"; sha256="1a2mhhscjf7s2qczc4zz2pvb9kichdqr1lnkjsyiy61snbhkvp3n"; depends=[MASS]; };
···
   mcmcplots = derive { name="mcmcplots"; version="0.4.1"; sha256="0japi78j1a9q6mb7j74d81lj45j8878mdby7765yz8xnjzwjpslb"; depends=[coda sfsmisc colorspace denstrip]; };
   MCMC_qpcr = derive { name="MCMC.qpcr"; version="1.1.3"; sha256="101pbg08p594ilcrrig9sqkddprpl6cd6g9y9rrk1rq6cy5cmrvr"; depends=[MCMCglmm ggplot2]; };
   mcmcse = derive { name="mcmcse"; version="1.0-1"; sha256="1jn5hl6aw83qmwccyfmcsvcymx9cp4d3qnfzzqvlw22x26rx88r6"; depends=[]; };
-  mco = derive { name="mco"; version="1.0.12"; sha256="1zfk01l9hza810f0kw8i4d3ayvn6l115c7i31a9ai1c33yralj0d"; depends=[]; };
+  mco = derive { name="mco"; version="1.0-15"; sha256="0mbhc98f4gy5d5mhf06w036bp7syfzy0nv5xzlsygjkdpgzkwpm2"; depends=[]; };
   Mcomp = derive { name="Mcomp"; version="2.05"; sha256="0wggj0h0qxjwym1vz1gk9iwnwia4lpjlk6n46l6hinsdax3g221y"; depends=[tseries forecast]; };
   MConjoint = derive { name="MConjoint"; version="0.1"; sha256="02yik28mhvd4rfqwrprdbdjx9c49ds55fh042bsjajs2ip467w5c"; depends=[]; };
   MCPAN = derive { name="MCPAN"; version="1.1-15"; sha256="0811wrbp0nf4nj8kvq62ks8yksabib8r1a0gx3nr3v6avfnv08w1"; depends=[mvtnorm multcomp]; };
···
   MDM = derive { name="MDM"; version="1.3"; sha256="1bvjhl243rf19829ly1qc20ik937hb82lq23aiysj7ya55z8hdpf"; depends=[nnet]; };
   MDPtoolbox = derive { name="MDPtoolbox"; version="4.0.2"; sha256="04w0y5ib23l7nhj1947hwvfk6lpwwc11amqpyw1w53yj794g97wz"; depends=[Matrix linprog]; };
   MDR = derive { name="MDR"; version="1.2"; sha256="0g2fvvcwagml6635va87nc0ijzy0pypx5aqzz7mf5w13j0wpm24y"; depends=[lattice]; };
-  meboot = derive { name="meboot"; version="1.4-3"; sha256="0n01g1mjm07pii1las7l2003kg705fqdi941l9lyvdkglnx0dkc6"; depends=[dynlm nlme]; };
+  mdsdt = derive { name="mdsdt"; version="1.0"; sha256="0ngf2p6lm32124qyfh18zlgf0dipj3njn6d0m8f192563kp50q0p"; depends=[ellipse mnormt polycor]; };
+  measuRing = derive { name="measuRing"; version="0.1"; sha256="1nlsxrld6dsqv4cyssjpva2hh38csyjr52bpgrvrh1kdjd951qrc"; depends=[tiff zoo pastecs]; };
+  meboot = derive { name="meboot"; version="1.4-5"; sha256="1h33f3dpx906q5nmd57hhkq07mbs2kg8mv6mi4imaa2zpr5vc4py"; depends=[dynlm nlme]; };
   mederrRank = derive { name="mederrRank"; version="0.0.7"; sha256="08jbqmb418qb7v2x6lm4wig1pfzzfx6fhb49mbfhlkbmssbqsjfq"; depends=[BB numDeriv]; };
-  mediation = derive { name="mediation"; version="4.4"; sha256="1vgx0i9gk7lqpvyyci0d5s9ls0ydhvhrqw9041ikb4b6h2y2aln3"; depends=[MASS Matrix lpSolve sandwich]; };
+  mediation = derive { name="mediation"; version="4.4.2"; sha256="0bprzmcmwkhhb9d6r3xkgvlbkd3rqykw5nxd1kbjw0g62a14qmqh"; depends=[MASS Matrix lpSolve sandwich mvtnorm]; };
   MedOr = derive { name="MedOr"; version="0.1"; sha256="1rwc14s16lnzgb78ac2017hv9pss7zw7nw3y7vrvq1qx4fgiw6f8"; depends=[]; };
   medSTC = derive { name="medSTC"; version="1.0.0"; sha256="1f7w6jbxairqvghr5b7vgdllg3ian16a1fgi7vqlq0mhy2j6phan"; depends=[]; };
   MEET = derive { name="MEET"; version="5.1.1"; sha256="02xz2zkwqaf1wck9a3h1j6z8dasw4j0zqa88jg6h10wqzcrlp9ba"; depends=[seqinr Matrix ROCR Hmisc KernSmooth]; };
···
   meifly = derive { name="meifly"; version="0.3"; sha256="1x3lhy7fmasss0rq60z5qp74ni32sahw62s8cnp2j431sp95pczc"; depends=[plyr leaps MASS]; };
   mem = derive { name="mem"; version="1.4"; sha256="1d3fgllh7fhlfz3rz2jm31r8vn7msz4na4762iaw161qp2j101db"; depends=[sm boot]; };
   memgene = derive { name="memgene"; version="1.0"; sha256="00b1mi2hvzzps542mh2p96s27kjqkpcic7djklfcwnfn1m4bz0i5"; depends=[ade4 raster gdistance vegan]; };
-  memisc = derive { name="memisc"; version="0.96-9"; sha256="0nra47086z4cxwx2hj0w3rdc7zi7k05z9fm6mxw2gi19jgamwcma"; depends=[lattice MASS]; };
+  memisc = derive { name="memisc"; version="0.96-10"; sha256="1w62kgnjw57l0l645f02r0583l4pysx8dms16j6kba5hj4g427b2"; depends=[lattice MASS]; };
   memoise = derive { name="memoise"; version="0.2.1"; sha256="19wm4b3kq6xva43kga3xydnl7ybl5mq7b4y2fczgzzjz63jd75y4"; depends=[digest]; };
   MEMSS = derive { name="MEMSS"; version="0.9-2"; sha256="0wyw8yjs4miwgwdfcnfbzvkxrgv5r3jlg3cg8q2vy7s69wvhksmy"; depends=[lme4]; };
   memuse = derive { name="memuse"; version="1.1"; sha256="1i6l3d885b4v01hlkl50m401bwi7akydhh52gf4kya5khanb8n2b"; depends=[]; };
   MergeGUI = derive { name="MergeGUI"; version="0.2-1"; sha256="1hx03qv5jyjjmqdvylc3kz5dl5qsdqwlirjbrnxrw7grkgkhygap"; depends=[gWidgetsRGtk2 ggplot2 cairoDevice rpart]; };
   merror = derive { name="merror"; version="2.0.1"; sha256="09v62f7ycywasid3b7x52dhidplwdbx9fd0855b40jklfy469bkn"; depends=[]; };
-  MESS = derive { name="MESS"; version="0.2-1"; sha256="1hqq615643iqhw6kvcxnxqlpzirdvq0hjm7j2n9x5zkr62syaql3"; depends=[geepack kinship2 mvtnorm]; };
-  meta = derive { name="meta"; version="3.7-1"; sha256="0v8pi7lv645vkw6l13r251hh1rzvsklpx98kx6y3d0kwkbcj3p23"; depends=[]; };
+  MESS = derive { name="MESS"; version="0.3-2"; sha256="0x518awi2mxjh3vq69n1jv4d4dxjxhqfx1py48dijgd6w674d3q8"; depends=[geepack glmnet Matrix kinship2 mvtnorm]; };
+  meta = derive { name="meta"; version="3.8-0"; sha256="0cqyvhxjfs9fgdidvibrmqwhbymfp7xqh5pb6krqviqz41rx1fwj"; depends=[]; };
   MetABEL = derive { name="MetABEL"; version="0.2-0"; sha256="0rqjv85mgswrbbp8b8ip6cdmz0cvfy9lm5mcr8a7h38rzgx3g3i3"; depends=[]; };
   MetabolAnalyze = derive { name="MetabolAnalyze"; version="1.3"; sha256="0cl76x6imx4a95wd74xx5s8i2vg8wq3inqgakvgzmkwxad6qhrqp"; depends=[mclust mvtnorm ellipse gtools gplots]; };
-  metabolomics = derive { name="metabolomics"; version="0.1.3"; sha256="1i5wqpjqbl5rhmys6l3iqkrnni7hw7ihq6c5l49ibi7mfyhzq5j9"; depends=[crmn]; };
   metacom = derive { name="metacom"; version="1.3"; sha256="12asmqwaihm9j6p6qp79m1j93gfcj6rkwmpywhi6nv4g85c1shll"; depends=[vegan lattice]; };
   metacor = derive { name="metacor"; version="1.0-2"; sha256="04k3ph0yg3jp8x4g6l1h4m0qwl51mx0626xmm0fzr1pv4b4a1ypw"; depends=[rmeta gsl]; };
   MetaDE = derive { name="MetaDE"; version="1.0.5"; sha256="1ijg64bri5jn2d3d13q1gvvfyqmbh6gn0lk6dkihixf0jwvjdyqi"; depends=[survival combinat]; };
···
   metaLik = derive { name="metaLik"; version="0.41.0"; sha256="08wiriq6cm02d0b0q34056y5249daidpjzkwzgjq6dh55v5fp2s4"; depends=[]; };
   metaMA = derive { name="metaMA"; version="2.1"; sha256="1hwhj3m4n48qb9vqix2qazsy1xnmwk8x37zm826xx9j0n5j2ilac"; depends=[SMVar]; };
   metamisc = derive { name="metamisc"; version="0.1.1"; sha256="1cvlsix3b857xdw6anqhqsrfwxpnf4rbzg4ybf6aw7vcdc05zgwd"; depends=[mvtnorm ellipse bbmle rjags coda]; };
+  metaMix = derive { name="metaMix"; version="0.1"; sha256="15vw8cwsy56fhq0q9w99799bnkj2ji2ns0ljfkg1p7wwhfrj689f"; depends=[data_table Matrix gtools Rmpi ggplot2]; };
   metap = derive { name="metap"; version="0.6"; sha256="1iy5cmwrlsr70z0qnqn30n15knsfclg383815a2a8yqpg5gs4953"; depends=[]; };
   MetaPCA = derive { name="MetaPCA"; version="0.1.4"; sha256="14g4v3hyxnds4l2q36mpz282yqg8ahgdw3b0qmj0xg17krrf5l2s"; depends=[foreach]; };
+  metaplus = derive { name="metaplus"; version="0.6-1"; sha256="1fk6sphjjcazd6v5k9dm5491487g0wzglzd0hg2pfy029bllx0a8"; depends=[bbmle metafor boot numDeriv]; };
   MetaQC = derive { name="MetaQC"; version="0.1.13"; sha256="11595ggjr46z6xiwmhiyx1sydaq68l18y7mgdwxsg81g03ck9x1r"; depends=[proto foreach iterators]; };
   metaRNASeq = derive { name="metaRNASeq"; version="0.4"; sha256="14xqgxvlip6il1gx9xvv37683qm7zmyswklbcgqw9rgqifi0plal"; depends=[]; };
   metasens = derive { name="metasens"; version="0.1-0"; sha256="0hrrzn6p14p2vs7bllkh9yxg0a3x87dmniglhq05p23g4lymcmbl"; depends=[meta]; };
   MetaSKAT = derive { name="MetaSKAT"; version="0.40"; sha256="1jxs32hvsw6wzci9f1rc7sw1dfyazdm2d57wcmhkggfg3hkdn1vv"; depends=[SKAT]; };
   metatest = derive { name="metatest"; version="1.0-4"; sha256="0bz6gg2n4ffkr144jxk27y24xpqhp8awr09wkaijmv8902qx6qah"; depends=[]; };
-  Metatron = derive { name="Metatron"; version="0.1-0"; sha256="0pfkb8wh1gbygbi7m9c5zi630clkn2bd1y9yrdxjlqifzvwx4dbi"; depends=[lme4 mpt Matrix]; };
-  meteoForecast = derive { name="meteoForecast"; version="0.31"; sha256="02rbl05i70ss65946w1aa2bg01l8hspqmmqz4w8j2jhs6dhgd429"; depends=[raster sp zoo ncdf rjson]; };
+  Metatron = derive { name="Metatron"; version="0.1-1"; sha256="0apz2k3za19px1bcg4ls0axaljrpxnqhs86b6s862c370sspc1x8"; depends=[lme4 mpt Matrix]; };
+  meteoForecast = derive { name="meteoForecast"; version="0.43"; sha256="1fpbxkdkgi50xbx3n26apdm6i29a2302vabfz0z3czafd76wkwg7"; depends=[raster sp zoo ncdf rjson]; };
   meteogRam = derive { name="meteogRam"; version="1.0"; sha256="167gyxjnl4dyfqs3znv8sdpkvpqdxzdqi1g730s30gycrm9snap9"; depends=[ggplot2 RadioSonde]; };
+  MetFns = derive { name="MetFns"; version="1.0"; sha256="03kx8cr4c6mgjincf87m305fhryh1c42hdzr1ljl63affnlp7nfp"; depends=[astroFns plotrix]; };
   Meth27QC = derive { name="Meth27QC"; version="1.1"; sha256="0ad30svs2kjzmmyvcm0jmv64iyq7slp1x1xl35h2rv1b6zbd4658"; depends=[gplots]; };
   MethComp = derive { name="MethComp"; version="1.22"; sha256="0wp2v8z5y9nl3jalcl2a42z2fpkwkzkvl407farws0yih0hj8b8l"; depends=[nlme]; };
   Methplot = derive { name="Methplot"; version="1.0"; sha256="0aaqss9zfn55qi45jffxkksnkw510npjnkygafx49vl77bkagqh5"; depends=[ggplot2 reshape]; };
···
   metRology = derive { name="metRology"; version="0.9-17"; sha256="1g4gv3mpii71i6imfwqg9d5iwfx03bq4lizzhx7dy39b2mj7jd4q"; depends=[MASS numDeriv]; };
   metrumrg = derive { name="metrumrg"; version="5.55"; sha256="1y95j8chnm34svf4q7ijqm19778pnap8734a40v3zb17zbjvs3aj"; depends=[reshape lattice XML MASS]; };
   mets = derive { name="mets"; version="0.2.8"; sha256="11mvd8bjd2h106d7kr60axp24pp38z21jkabgbpcigzc14mrd8y9"; depends=[timereg lava numDeriv Rcpp]; };
-  MetSizeR = derive { name="MetSizeR"; version="0.99"; sha256="1msq0la89fvg9vfz5k8rzsnhpqa9b8cjyhggp7mp10rzh696sdap"; depends=[gWidgets cairoDevice pscl gtools MetabolAnalyze]; };
   MetStaT = derive { name="MetStaT"; version="1.0"; sha256="0400gx6i8xlkm51da98ap91c3hgrkgfgxswn0plaxfry3625khkp"; depends=[MASS abind pls]; };
   mewAvg = derive { name="mewAvg"; version="0.3.0"; sha256="16gc78ccjffp9qgc7rs622jql54ij83ygvph3hz19wpk22m96glm"; depends=[]; };
   MExPosition = derive { name="MExPosition"; version="2.0.3"; sha256="1l27wp0psfvlkk79fhb8ypf8awardjljg1f37yj42friy9pdfksz"; depends=[prettyGraphs ExPosition]; };
   MF = derive { name="MF"; version="4.3.2"; sha256="1arnhyqf1cjvngygcpqk2g4d52949rhkjmclbaskyxcrvp62qln0"; depends=[]; };
+  mfblock = derive { name="mfblock"; version="1.0"; sha256="06raii52gb7fzh23ahvkrcwvbx3mg02ww3qa340igkqys6jf3yih"; depends=[skewt boot nloptr]; };
   MFDA = derive { name="MFDA"; version="1.1-4"; sha256="0zf21al8ivmsxlf1i7kc01w0jx3s6650a034cdynz7axnxx28ncx"; depends=[gss mvtnorm]; };
   MFHD = derive { name="MFHD"; version="0.0.1"; sha256="0gb8y297y1x03wy46530psmlawyv4z5dydilk36qcmadlk1wx02k"; depends=[fda_usc deldir depth depthTools matrixStats]; };
   mFilter = derive { name="mFilter"; version="0.1-3"; sha256="1cz9d8447iiy7sq47civ1lcjafqdqs40lzxm2a4alw4wy57hc2h6"; depends=[]; };
-  mfp = derive { name="mfp"; version="1.4.9"; sha256="1xnx4jgkxccli1y852kvf26q04mdidczpic3ms916a8mkby7kg3k"; depends=[survival]; };
-  MFSAS = derive { name="MFSAS"; version="1.0-0"; sha256="1vnhkr4bgwdn6ffzqfp8w7z45m0ghrfr6ib4agv23frk36ypmxxr"; depends=[]; };
+  mfp = derive { name="mfp"; version="1.5.0"; sha256="1hqsw7dn7vwgg5qhjmx50xdm0k3g95n0r6r8wbqrp3nx8rzxgsnr"; depends=[survival]; };
+  MfUSampler = derive { name="MfUSampler"; version="0.9"; sha256="1j60skwcfzqg5fvvrflxk7qiqlla1w51xfbhwilzxrfv6ww9jq8j"; depends=[ars]; };
   mfx = derive { name="mfx"; version="1.1"; sha256="1zhpk38k7vdq0pyqi1s858ns19qycs3nznpa00yv8sz9n798wnn5"; depends=[sandwich lmtest MASS betareg]; };
-  mgcv = derive { name="mgcv"; version="1.8-2"; sha256="01ml3lwwisg96mb9xs5z5igy4hl480zwbf3s4kpwzzg375ksn49v"; depends=[nlme Matrix]; };
+  mgcv = derive { name="mgcv"; version="1.8-3"; sha256="0sh4k2fqr6ldny6xbs6d0kwa5dj6ykkzkwlly1d2g8c5yl2ldixb"; depends=[nlme Matrix]; };
   MGLM = derive { name="MGLM"; version="0.0.6"; sha256="00kz2l7xn9df8n0035i2rkgj6rlb99y9z68935q8px70njs8rl87"; depends=[ggplot2 plyr reshape2]; };
   mgpd = derive { name="mgpd"; version="1.99"; sha256="0cxpgza9i0hjm5w1i5crzlgh740v143120zwjn95cav8pk8n2wyb"; depends=[evd numDeriv corpcor fields]; };
   mgraph = derive { name="mgraph"; version="1.03"; sha256="0av2c0jvqsdfb3i0s0498wcms0n2mm0z3nnl98mx2fy7wz34z8b2"; depends=[rgdal]; };
   MGRASTer = derive { name="MGRASTer"; version="0.9"; sha256="0jmf2900r56v60981sabflkhid3yrqd9xd7crb56vgfl1qkva9zp"; depends=[]; };
-  MGSDA = derive { name="MGSDA"; version="1.0"; sha256="1h4sz9csc5cvkr0jnwas28233yx4v0lwxsgl6vh4gxk8w81md25y"; depends=[glmnet]; };
+  MGSDA = derive { name="MGSDA"; version="1.1"; sha256="09z066sfjvx7awxc86gfw066wlz6svj7nxkhlas63a7zfbkiz7hl"; depends=[glmnet MASS]; };
   mGSZ = derive { name="mGSZ"; version="1.0"; sha256="08l98i75h2h8kx9ksvzp5qr8jhf0l6n4j7rg8fcn7hk8chn8v5zh"; depends=[GSA MASS ismev]; };
   MHadaptive = derive { name="MHadaptive"; version="1.1-8"; sha256="1w3bm82v8ahxrf0vqn0pznv7dqn212drinkz8y5kr1flx423l9ws"; depends=[MASS]; };
   mhsmm = derive { name="mhsmm"; version="0.4.12"; sha256="0k8qm447fcgfc5fmqn478dszr76jmin85k51ccqmhgk14jiz64bf"; depends=[mvtnorm]; };
-  mht = derive { name="mht"; version="3.00"; sha256="143gmipx6v9nvg2lq1kbl7ns6qmvwpxf3gzmq4b6cfgamcljl05l"; depends=[glmnet]; };
+  mht = derive { name="mht"; version="3.0.11"; sha256="1d1ca3jp5q9xmnlnjsqi247vz6gm25bb8x5lzwd6z0n87lv26n1k"; depends=[glmnet]; };
   mhurdle = derive { name="mhurdle"; version="1.0-1"; sha256="1x631fgbq3ika05svyavzadyjd7vi9bcmsgb58wfhpf9xq6j5rcr"; depends=[Formula truncreg maxLik pbivnorm]; };
-  mi = derive { name="mi"; version="0.09-18.03"; sha256="01cxkqy5g0i7bqr9rb86075p5gmwgcs7cvs4nfs00r5vjw1hgq61"; depends=[arm abind car foreign lme4 MASS Matrix nnet R2WinBUGS]; };
+  mi = derive { name="mi"; version="0.09-19"; sha256="1r3b6mm3pr95lb52m2vynmg0l2wy80hznjq2rff1qwplbq1pl04n"; depends=[arm abind car foreign lme4 MASS Matrix nnet R2WinBUGS]; };
   mice = derive { name="mice"; version="2.22"; sha256="1b7ivpa21ipzbmmwjn1ch968zpw6wydg30f7jdk95m40lrk2xs68"; depends=[Rcpp lattice MASS nnet randomForest rpart]; };
   miceadds = derive { name="miceadds"; version="0.14-9"; sha256="0zfqs52kaj9sxdzc7j0zxbnaqnkz9a8pwgn2p0pz46qf7kgx6y16"; depends=[MASS mice mvtnorm pan sirt lme4 MBESS pls mitools bayesm Rcpp inline car foreign]; };
   micEcon = derive { name="micEcon"; version="0.6-12"; sha256="1kxhr3qqgswq8glrjfcjz0hyb163lwf303yhwlgrwjciqgp5dq17"; depends=[miscTools]; };
···
   micEconCES = derive { name="micEconCES"; version="0.9-8"; sha256="06g6z8hf7y9d942w6gya0fd5aidzfjkx3280gjygdlwpv7nlpqzv"; depends=[minpack_lm DEoptim systemfit car micEcon miscTools]; };
   micEconSNQP = derive { name="micEconSNQP"; version="0.6-6"; sha256="1n3pxapc90iz1w3plaqflayd0b1jqd65yw5nbbm9xz0ih132dby9"; depends=[miscTools systemfit MASS]; };
   MiClip = derive { name="MiClip"; version="1.2"; sha256="0cszylg7sk88gs1f4dfshw74kdifjr4q069ssxzgss9k90rszp30"; depends=[moments VGAM]; };
-  microbenchmark = derive { name="microbenchmark"; version="1.3-0"; sha256="1j0pif46bymmkgr61yf2xv2ymm0xwx52lyc46pgas4i9czygdc9v"; depends=[]; };
+  microbenchmark = derive { name="microbenchmark"; version="1.4-2"; sha256="05yxvdnkxr2ll94h6f2m5sn3gg7vrlm9nbdxgmj2g8cp8gfxpfkg"; depends=[ggplot2]; };
   MicroDatosEs = derive { name="MicroDatosEs"; version="0.6.3.1"; sha256="17ka9bdic8vdr0aabmgm216zm9a8jppxll042b5ric4vzplah17d"; depends=[memisc Hmisc]; };
   micromap = derive { name="micromap"; version="1.9"; sha256="0scb79rrj11vy7qgq27hy8222ar22yagk31bq8b5z268zwfbw4fs"; depends=[ggplot2 maptools RColorBrewer rgdal]; };
   micromapST = derive { name="micromapST"; version="1.0.3"; sha256="182zhpsps8cx3wflc5j62njzsv108d5a30v9sb1wpxpcrnsyr343"; depends=[RColorBrewer]; };
+  micropan = derive { name="micropan"; version="1.0"; sha256="0qnxm6z2pk1wibchj6rhn3hld77dzl5qgvzl4v9n16ywlgdv09ai"; depends=[igraph]; };
   MicroStrategyR = derive { name="MicroStrategyR"; version="1.0-1"; sha256="0a6bk0wnwx8zy9081n7wb12lidgckrhn350r0q5m6aa82l6l8ihi"; depends=[gWidgetsRGtk2]; };
   MicSim = derive { name="MicSim"; version="1.0.6"; sha256="01w9x3ld8b64m3d9qjbja6gbmgnsj2bna9l7lisa17add0i11744"; depends=[chron snowfall rlecuyer]; };
   midasr = derive { name="midasr"; version="0.3"; sha256="1gdfrf8p4wxz03bzdqrvj4ss14zy7dh5ac04ncvg4db2wcdxq6z5"; depends=[sandwich optimx MASS numDeriv Matrix]; };
-  MIfuns = derive { name="MIfuns"; version="5.1"; sha256="1jhiaf9wrwgrlsl8s81qh0m8x1vpa01gnw2nxcfpshi7i9il3lw7"; depends=[reshape lattice XML MASS]; };
   MigClim = derive { name="MigClim"; version="1.6"; sha256="171pnalidyw0v2fcjdc3kyrq5kg035kwj5xl8zwgn3hlanpaljvp"; depends=[SDMTools raster]; };
   migest = derive { name="migest"; version="1.6"; sha256="1mjjcba74nk10kdbsaphih3zdyaqmf02hrv13s34klwdwkp3nv0m"; depends=[]; };
   migration_indices = derive { name="migration.indices"; version="0.3.0"; sha256="0h0yjcj70wzpgrv3wl1f2h2wangh1klsllq0i0935plgzw736mwd"; depends=[calibrate]; };
   migui = derive { name="migui"; version="0.00-09"; sha256="0mrvsls9q039pay0vf59xwg6bbr7ahwl4x3iwvar6sbfg8606as8"; depends=[tkrplot mi foreign]; };
   MIICD = derive { name="MIICD"; version="1.1"; sha256="0d697mggax1yp7b4dfxdi25rqmwrq25gmmjqsag6sa5raqr96gc9"; depends=[mstate prodlim cmprsk riskRegression MASS survival]; };
   MILC = derive { name="MILC"; version="1.0"; sha256="14xsiw5al6kixwvf3ph0dlm8s13gsbqvzb92da6ng3x4iiyb1g0w"; depends=[]; };
-  mime = derive { name="mime"; version="0.1.2"; sha256="0afndhp8sxvx689b0i9mx52ws9wynd41z8ij3kqnqcz0sa1n4ifb"; depends=[]; };
+  mime = derive { name="mime"; version="0.2"; sha256="0kg1wwxh7v7b7wqbxf47ngy978hc2a9nknwra5racpd2gzyg3ghn"; depends=[]; };
   MImix = derive { name="MImix"; version="1.0"; sha256="033gxr0z2xba0pgckiigblb1xa94wrfmpgv3j122cdynjch44j4r"; depends=[]; };
   MindOnStats = derive { name="MindOnStats"; version="0.8"; sha256="1fsswkbrxd3f0hz3nd25xvp36si292s4q2r52hw6rsps2mx6bgqi"; depends=[]; };
-  minerva = derive { name="minerva"; version="1.3"; sha256="0ph65jfm05wck3zz0lh3bmaj0p4c9309nzkrjpjxqkcnrfdbw6wf"; depends=[]; };
+  minerva = derive { name="minerva"; version="1.4.1"; sha256="0dg5xnl9srdvid49na8478bnvagv0khiv6hl7z8gw6m745681i89"; depends=[]; };
   Miney = derive { name="Miney"; version="0.1"; sha256="0sgln0653rgglinr8rns5s2az0lgyp9slmynyhhhs265grkhrfj0"; depends=[]; };
-  miniCRAN = derive { name="miniCRAN"; version="0.0-16"; sha256="01f8cgvnzji56qd7d8cnhm5cp9mx45kyxfkqf46l10c8rhll6h3c"; depends=[XML]; };
+  miniCRAN = derive { name="miniCRAN"; version="0.1-1"; sha256="0azyv5wcl4dk1z4j6pq26y7h7f9lvq6m198dj4aa142k9smxfrnw"; depends=[XML httr igraph]; };
   miniGUI = derive { name="miniGUI"; version="0.8.0"; sha256="1iq52x7wbcin7ya207jj3k9vym7mavm5z61vggyabdmr768pci39"; depends=[]; };
   minimax = derive { name="minimax"; version="1.0"; sha256="1g0d9q5h1avbb0yg7ajw5330820i3n5cgkpsif754l4j3ikya8p3"; depends=[]; };
   minpack_lm = derive { name="minpack.lm"; version="1.1-8"; sha256="0nvsxqwg3k9k3dqjzkz1vq2z0xla317011zm9ms8y1qvf75raz83"; depends=[]; };
   minPtest = derive { name="minPtest"; version="1.7"; sha256="088kckpbfy2yp0pk3zrixrimywrvkaib5ywa7fkr5phnzlsl80sv"; depends=[scrime Epi]; };
-  minqa = derive { name="minqa"; version="1.2.3"; sha256="06w8in7kpsv8c7frpsgjb40x4vsc8y0ashb0il1yyr157gqdgyhn"; depends=[Rcpp]; };
-  minque = derive { name="minque"; version="1.0"; sha256="1ympfyf24883n7178s7jspq18bq5j2kb87hz2yq9i99ds6liqr6b"; depends=[klaR agridat Matrix]; };
+  minqa = derive { name="minqa"; version="1.2.4"; sha256="036drja6xz7awja9iwb76x91415p26fb0jmg7y7v0p65m6j978fg"; depends=[Rcpp]; };
+  minque = derive { name="minque"; version="1.1"; sha256="1hx4j38213hs8lssf9kj5s423imk7dzv60mdbzrpbp7la7jk2n57"; depends=[klaR Matrix]; };
   minxent = derive { name="minxent"; version="0.01"; sha256="1a0kak4ff1mnpvc9arr3sihp4adialnxxyaacdgmwpw61wgcir7h"; depends=[]; };
   miP = derive { name="miP"; version="1.1"; sha256="17y2badm76iwidjp45flm9ln098lk9r5m6lgx3skzcq3hp075967"; depends=[VIM mi mice Amelia lattice vcd]; };
   MIPHENO = derive { name="MIPHENO"; version="1.2"; sha256="0hcaq66biv4izszdhqkgxgz91mgkjk1yrwq27fx07a2zmzj44sfv"; depends=[doBy gdata]; };
   miRada = derive { name="miRada"; version="1.13.8-8"; sha256="1m6rm65pv4r16r0s5ih69nr3v2rnpsvpdpk07pi7k4f7v9wck71v"; depends=[]; };
-  mirt = derive { name="mirt"; version="1.4"; sha256="0ngm22lhwfv2l68nn7qrvjpyz49kcasdaj2jx46fcb4851xxahyw"; depends=[lattice GPArotation Rcpp numDeriv]; };
+  mirt = derive { name="mirt"; version="1.6.1"; sha256="0wc085dcr59rkfj6ssmpdg50s76ilxcgh2jyin7f7028xwyy40a2"; depends=[lattice GPArotation Rcpp sfsmisc numDeriv]; };
+  mirtCAT = derive { name="mirtCAT"; version="0.2"; sha256="0n81wx5mvbkgk1ybk0n3slp6qg15gw8y7lmfrsbgjx7bcs80b8ky"; depends=[mirt shiny lattice]; };
   miRtest = derive { name="miRtest"; version="1.7"; sha256="0nqn3xrwlw2z9wjhf6rv0n9frqqviiv54syxyn1nkcn2d5lygwn3"; depends=[corpcor MASS RepeatedHighDim]; };
   misc3d = derive { name="misc3d"; version="0.8-4"; sha256="0qjzpw3h09qi2gfz52b7nhzd95p7yyxsd03fldc9wzzn6wi3vpkm"; depends=[]; };
   miscF = derive { name="miscF"; version="0.1-2"; sha256="195rb9acdirfhap0z35yvcci5xn4j84mlbafki4l1vfgqgnh0ajj"; depends=[MCMCpack mvtnorm Rcpp RcppArmadillo]; };
   miscFuncs = derive { name="miscFuncs"; version="1.2-6"; sha256="1302k6pvf74a0b9bkdjdr2j1xl98842rbq7137h8hwldl50g48i7"; depends=[roxygen2 mvtnorm]; };
-  MiscPsycho = derive { name="MiscPsycho"; version="1.6"; sha256="1zs6apivzzii7nln3jmhxggnhxk3j54cw84wbsc8hb279rv943il"; depends=[statmod]; };
-  miscset = derive { name="miscset"; version="0.3.1"; sha256="1x1948cwxjqkz23p14ilv5x381xbfkzg328n51fw3sqz11lb2h8g"; depends=[Rcpp xtable]; };
+  miscset = derive { name="miscset"; version="0.4"; sha256="04cl8a2chcynfn5rljqw2ll4ry0wqaslqgjh9ny8ax3hcvyvmmwl"; depends=[data_table gridExtra Rcpp xtable]; };
   miscTools = derive { name="miscTools"; version="0.6-16"; sha256="19mslb64lm8srrmml1v40rfkxhqw02bplw0yjv7qnkqj44hcqfw1"; depends=[]; };
   missForest = derive { name="missForest"; version="1.4"; sha256="0y02dhrbcx10hfkakg5ysr3kpyrsh2d9i5b0qzhj9x5x0d5q11gp"; depends=[randomForest foreach itertools]; };
-  MissingDataGUI = derive { name="MissingDataGUI"; version="0.2-0"; sha256="18z25wjq4mcd7vv7wg1xz0hmac2dvd1ap91p22yxvpk1qjllzaq3"; depends=[gWidgetsRGtk2 ggplot2 GGally cairoDevice reshape]; };
+  MissingDataGUI = derive { name="MissingDataGUI"; version="0.2-2"; sha256="07a3y8l0r7a0f7zmp5pg2aqkf7hyk8cf562x3m8b38w96vir4vr0"; depends=[gWidgetsRGtk2 ggplot2 GGally cairoDevice reshape]; };
   missMDA = derive { name="missMDA"; version="1.7.2"; sha256="07m8vih9bbzsx47g59dz9m8m23r8rrvnwddm29gx0cv24snh97lv"; depends=[FactoMineR]; };
   MissMech = derive { name="MissMech"; version="1.0.1"; sha256="0xcxzgjv9p9w8rdq07vanfrw0b49acdikr8brm78hshy0dsnas32"; depends=[]; };
   MiST = derive { name="MiST"; version="1.0"; sha256="0gqln792gixqfh201xciaygmxbafa0wyv5gpbg9w5zkbbv44wrfk"; depends=[CompQuadForm]; };
   mistat = derive { name="mistat"; version="1.0-2"; sha256="1n5wdn5pl6mflzxpdwjj0x44c8a3cxxpwhmyw1jkx5r8yk95mh3p"; depends=[]; };
   mistral = derive { name="mistral"; version="1.1-0"; sha256="08gnichjihhl8dnyh7612x9m2b8vbj81jcya8bh1aaxql26zq9w1"; depends=[DiceKriging e1071 kernlab Matrix mvtnorm rgenoud]; };
   MitISEM = derive { name="MitISEM"; version="1.0"; sha256="03305ds3rgr29z4idaxzsm83igiygna2sqd5vpixklngsrp8w341"; depends=[mvtnorm]; };
-  mitools = derive { name="mitools"; version="2.2"; sha256="08sbm17sw549ljid93x64lxg79f860as6j3vv0f8nh1zb9rabqh8"; depends=[foreign]; };
+  mitools = derive { name="mitools"; version="2.3"; sha256="0w76zcl8mfgd7d4njhh0k473hagf9ndcadnnjd35c94ym98jja33"; depends=[]; };
   mix = derive { name="mix"; version="1.0-8"; sha256="0zdbxrslj39cl272ggzvlc41gysj1inbcbmsa4ch7ss5xvk5vfbf"; depends=[]; };
-  mixAK = derive { name="mixAK"; version="3.6-1"; sha256="1khnxvmnd7qwk3lxld70dwxfdya2rq4ybdal89v0p7mxcv9abzdh"; depends=[colorspace lme4 fastGHQuad mnormt]; };
+  mixAK = derive { name="mixAK"; version="3.8"; sha256="1mkfa9zy61j4hn131x9kfsvydk7p0kp79zg1x9aidpaz5agdc92k"; depends=[colorspace lme4 fastGHQuad mnormt coda]; };
   mixcat = derive { name="mixcat"; version="1.0-3"; sha256="0xszngygd3yj61pvv6jrrb5j0sxgpxzhlic69xrd5mv5iyw0cmxd"; depends=[statmod]; };
   mixdist = derive { name="mixdist"; version="0.5-4"; sha256="100i9mb930mzvdha31m1srylmpa64wxyjv6pkw1g5lhm1hsclwm3"; depends=[]; };
   mixedQF = derive { name="mixedQF"; version="0.3"; sha256="037376k13qh0c5nw1nxx3fvffisl9kcdyjz5d4i6vn3gfj0yqccc"; depends=[nnet MASS]; };
   MixedTS = derive { name="MixedTS"; version="1.0.1"; sha256="0ljal2jxscwrv439blavf5gjxbi3k3jfqqmwblzfvc05dqgvdk0b"; depends=[MASS]; };
   mixer = derive { name="mixer"; version="1.7"; sha256="0as9l0s646snli5pykh0i6zpz168f8i5wmxk07l5rhxnb74m0id2"; depends=[]; };
   mixexp = derive { name="mixexp"; version="1.1.2"; sha256="11gzjmg0nifr18nikga1fx8bdgqn2kj1jsyk8q6vi9q9k952f746"; depends=[gdata lattice]; };
-  MixGHD = derive { name="MixGHD"; version="1.0"; sha256="008xbbvyc8lm1375yvbk7zvqz2hbf87jq7q9xv75zn65gxm8j93m"; depends=[Bessel MASS mvtnorm ghyp numDeriv]; };
-  mixlm = derive { name="mixlm"; version="1.0.5"; sha256="104rh4g7ik1ry0xb53n5b5fv1spvck6s2k2h4xjlp1ykazph073y"; depends=[multcomp pls leaps lme4 car]; };
+  mixlm = derive { name="mixlm"; version="1.0.6"; sha256="0fn81ncjnaa7lsdgx7mwpg7vh8d2kiag28r25myz2hc54750r53j"; depends=[multcomp pls pracma leaps lme4 car]; };
   mixlow = derive { name="mixlow"; version="1.0.1"; sha256="12vnp3gl3ykxzgvc4bwhi4flmc1sl2y77yi0zi4by17q93a49akm"; depends=[nlme]; };
   MixMAP = derive { name="MixMAP"; version="1.3.1"; sha256="0m6m9wi0ain7z96s6z6kmwjisfqm3al6m459y5zr2l1cdbdpxfpv"; depends=[lme4]; };
-  mixOmics = derive { name="mixOmics"; version="5.0-2"; sha256="01xcmm9g80cn8bmq761h3v5az5pj0qldnbszgqx6b2bcrxkc0wg9"; depends=[MASS lattice RGCCA igraph rgl pheatmap]; };
+  mixOmics = derive { name="mixOmics"; version="5.0-3"; sha256="1b8ms3jz4acvbfm2b1iw30h2d80lpqgabwr5j9k2gy3nvqm72nxq"; depends=[MASS lattice RGCCA igraph rgl pheatmap]; };
   mixPHM = derive { name="mixPHM"; version="0.7.0"; sha256="0gyvccz205wwnmggh5zw90r6kmr5lv4s4zrdazi2ghjjrvv0gv6b"; depends=[survival lattice]; };
   mixRasch = derive { name="mixRasch"; version="1.1"; sha256="1r067pv7b54y1bz8p496wxv4by96dxfi2n1c99gziqf5ramx3qzp"; depends=[]; };
   mixreg = derive { name="mixreg"; version="0.0-5"; sha256="0wsb1z98ymhshw9nhsvlszsanflxv3alwpdsw8lr3v62bkwka8zr"; depends=[]; };
   mixsep = derive { name="mixsep"; version="0.2.1-2"; sha256="1ywwag02wbx3pkd7h0j9aab44bdmwsaaz0p2pcqn1fs3cpw35wa2"; depends=[tcltk2 MASS RODBC]; };
   MixSim = derive { name="MixSim"; version="1.0-9"; sha256="16kg12784z82x8f1vscv9d5yakmki2m8gqr4hy9417c31xfkk3zy"; depends=[MASS]; };
   mixsmsn = derive { name="mixsmsn"; version="1.0-9"; sha256="0pgip1xfgfrdy3g3197d7visn164zi7xnp6wlsgjwxdylvjsxkji"; depends=[mvtnorm]; };
-  mixstock = derive { name="mixstock"; version="0.9.5.1"; sha256="05bnxz7xkr5j96r85r7pc47svc60nwfmfax76naplzbvn751mhkg"; depends=[coda plotrix abind lattice]; };
   mixtools = derive { name="mixtools"; version="1.0.2"; sha256="0x809m6lbzprd5kq6wqk528x9apaj5df3sidzk9jiw06qklngwg8"; depends=[boot MASS segmented]; };
   mixture = derive { name="mixture"; version="1.1"; sha256="09hp28fh1y2kllny6l0zciwbhhnjjgyipsx1vs55rq7rr0s94pkn"; depends=[]; };
   MixtureInf = derive { name="MixtureInf"; version="1.0-1"; sha256="1cq8zzhhb6vg545n9aw1b9fhx025zy75dd6pw161svsb5776py5d"; depends=[]; };
   mizer = derive { name="mizer"; version="0.2"; sha256="0cpal9lrjbvc923h499hbv4pqw3yjd4jvvhgayxgkak2lz2jzmcz"; depends=[plyr reshape2 ggplot2]; };
-  mkin = derive { name="mkin"; version="0.9-32"; sha256="1b1s1px4zcbpk2wl49qricxgjw4pvffhvf3ccyrjhxdrdpmcknyr"; depends=[minpack_lm rootSolve FME deSolve]; };
+  mkde = derive { name="mkde"; version="0.1"; sha256="04v84arpnmjrkk88ffphnhkz32x7y0dypk75jfmbbgcgv59xlglv"; depends=[Rcpp raster sp]; };
+  mkin = derive { name="mkin"; version="0.9-33"; sha256="0mpdnaziwxp4ncjhypm3xfg9lg5hz4mkhil8vz1fh4z4lx1gg3nv"; depends=[minpack_lm rootSolve FME deSolve]; };
   MKLE = derive { name="MKLE"; version="0.05"; sha256="00hcihjn3xfkzy0lvb70hl2acjkwk6s3y7l4gprix24shnblvxzi"; depends=[]; };
   MKmisc = derive { name="MKmisc"; version="0.96"; sha256="1lcnmswvix290s63cqqlq4ls6wyzzb3f5ykcn4sch6nv71bn8x5x"; depends=[RColorBrewer robustbase]; };
   mkssd = derive { name="mkssd"; version="1.1"; sha256="1qqzy6fn6sc3lxahc19hzzf1hzxsyvxqi7npynw0vkknlrvh2ijp"; depends=[]; };
···
   mlmRev = derive { name="mlmRev"; version="1.0-6"; sha256="0mvmahnbbp478xwldj4wlsjib4v4afhs07643gxgcqpi56zbd5h7"; depends=[lme4]; };
   mlogit = derive { name="mlogit"; version="0.2-4"; sha256="15ndly7i56k8blgvpn15ixxnqx9yvbci7n3mb3hm9mnrxwh5v7sx"; depends=[Formula maxLik statmod zoo MASS lmtest]; };
   mlogitBMA = derive { name="mlogitBMA"; version="0.1-6"; sha256="1wl8ljh6rr1wx7dxmd1rq5wjbpz3426z8dpg7pkf1x9wr94a2q25"; depends=[BMA abind maxLik]; };
-  MLPAstats = derive { name="MLPAstats"; version="0.5-9"; sha256="0cy315kj2ivqwrdhg85ncp634mwx2bbwzs86w1pcjwf03v217wk9"; depends=[nlme boot tkrplot pixmap]; };
   mlPhaser = derive { name="mlPhaser"; version="0.01"; sha256="1s2mqlnbcjdkx0ghvr2sw9rzggqa4jy2vzi9vbyqkh6795lgck6n"; depends=[]; };
-  mlr = derive { name="mlr"; version="2.1"; sha256="15czq70hgfbfr1j9lhbsrmmf2d5mqvy1zj9xkmnycfvk0zsh996j"; depends=[ParamHelpers BBmisc parallelMap codetools survival checkmate]; };
+  mlr = derive { name="mlr"; version="2.2"; sha256="1l1ng2k3iyz3x1237kshcana6f8dds79dzs703c95wrzvfsrim89"; depends=[ParamHelpers BBmisc checkmate codetools ggplot2 parallelMap plyr survival]; };
   MLRMPA = derive { name="MLRMPA"; version="1.0"; sha256="0gfbi70b15ivv76l3i0zlm14cq398nlny40aci3vqxxd0m2lyyx5"; depends=[ClustOfVar]; };
   MM = derive { name="MM"; version="1.6-2"; sha256="1z7i8ggd54qjmlxw9ks686hqgm272lwwhgw2s00d9946rxhb3ffi"; depends=[magic partitions emulator Oarray]; };
-  mmand = derive { name="mmand"; version="1.0.0"; sha256="10dqg99iaq5mfdz0x35z7f8xsf5fhw3jis0zgqxia8vzrw68q70v"; depends=[reportr Rcpp]; };
+  mmand = derive { name="mmand"; version="1.1.0"; sha256="0awi9wxxalz81d6766djbjsk980n65dhz02fcqb69ifc7x80lc33"; depends=[reportr Rcpp]; };
   mmap = derive { name="mmap"; version="0.6-12"; sha256="12ql03wzwj23h8lwd07rln6id44mfrgf9wcxn58y09wn3ky1rm6a"; depends=[]; };
-  mmcm = derive { name="mmcm"; version="1.2-4"; sha256="16lh9ivnj3l01y28lgb5gykkxwa56cssadnh516qwhnv63c586sv"; depends=[mvtnorm]; };
+  mmcm = derive { name="mmcm"; version="1.2-5"; sha256="193mlvl8fp5y2150m0xw5bhr7nkr4fgmwjbv1dg314a7ara42v4y"; depends=[mvtnorm]; };
   mmds = derive { name="mmds"; version="1.1"; sha256="0f5qzkfhi7vg8vsd8r41idmbwrrgc7qzfnp81adms2yzrza17wrw"; depends=[]; };
-  mme = derive { name="mme"; version="0.1-4"; sha256="1k9l86q8bahkp0g6g6k963j3n2pzz4jb2xljw31r8xxlxpiv11n5"; depends=[mixstock MASS Matrix]; };
+  mme = derive { name="mme"; version="0.1-5"; sha256="07k1xagwpyzsrlc00y9xlaxcpwdhz55v567i7fzvqa96ical8nlf"; depends=[MASS Matrix]; };
   mmeln = derive { name="mmeln"; version="1.1"; sha256="06bxp157cdab6ghx3yrsn8l2gixh9cyv6fv4pqyq0yxqwbjf9bmi"; depends=[]; };
   mmeta = derive { name="mmeta"; version="2.2"; sha256="06zkazi97f3il2vlx4f8c7zz4kxs9ylhscd06j31h504c1w96ddf"; depends=[aod HI]; };
   MMIX = derive { name="MMIX"; version="1.2"; sha256="02c74qp48ixqh5cjp2006zgg4xz4bgxxq3csyhjl219if19kmj5m"; depends=[]; };
···
   mmod = derive { name="mmod"; version="1.2.1"; sha256="0c2ijg5116hacq0f18xhkbxankjp0k34zfnw8q02ahzwd26ds0z7"; depends=[adegenet pegas]; };
   MMS = derive { name="MMS"; version="3.00"; sha256="06909912v2hr52s8k0a0830lbmdh05dcd7k47vydhbwq3rzf3ahg"; depends=[glmnet Matrix mht]; };
   MMST = derive { name="MMST"; version="0.6-1.1"; sha256="1gd7v34xi3wn2rjhk0ih0q2i2hb7c5x8kvv90g90ln803b5wvbhs"; depends=[]; };
-  mnlogit = derive { name="mnlogit"; version="1.1.1"; sha256="0n6b5c14dcqv8pldrdgpjq8r2q956whwz2bxalphcf5da9r9jlc7"; depends=[]; };
+  mnlogit = derive { name="mnlogit"; version="1.2.0"; sha256="0ymkm3xwm97v5f9lg2ir4czdfb47hibgrkirc2iw66fh24iah84m"; depends=[mlogit lmtest Formula]; };
   MNM = derive { name="MNM"; version="1.0-0"; sha256="0qab0qqhfjmaiji5yqdvd1lqz8f90q40sdwpcah923yi3g6alh2q"; depends=[ellipse ICS ICSNP SpatialNP mvtnorm survey]; };
+  mnormpow = derive { name="mnormpow"; version="0.1.1"; sha256="0z53vwhkhkkr6zrjhd3yr14mb02vh7lr63frf0ivajndxiap0s9v"; depends=[]; };
   mnormt = derive { name="mnormt"; version="1.5-1"; sha256="1msxbdlg4wb45lsg0m4hqf41qglnmbqw55815v8qvyfjkwrgns8b"; depends=[]; };
   MNP = derive { name="MNP"; version="2.6-4"; sha256="068lssg565dw673dm8f5k6dbxl2vblnszg8wibzy3ijf96hp03cw"; depends=[MASS]; };
   mobForest = derive { name="mobForest"; version="1.2"; sha256="198air7fplgiw86vs7m4dn4kai0gpnnmv14bykbw3lnaxk4fk8fd"; depends=[party lattice modeltools]; };
-  Mobilize = derive { name="Mobilize"; version="2.16-2"; sha256="077s56cfb6cp2fiyrvva130c63nqr7nczfyfkykmkdsjsgs3ksp8"; depends=[Ohmage ggplot2 wordcloud reshape2]; };
+  Mobilize = derive { name="Mobilize"; version="2.16-4"; sha256="16vdvpwspa0igb52zvzyk0if9l4wq1hm8y42572i8sh1m82wyyfs"; depends=[Ohmage ggplot2 wordcloud reshape2]; };
   MOCCA = derive { name="MOCCA"; version="1.2"; sha256="04smpzn9x64w1vpw4szqa7dwnaak1ls6gpg7fgajs68mv5zivffa"; depends=[cclust clv]; };
   Modalclust = derive { name="Modalclust"; version="0.6"; sha256="16h90d30jwdrla5627rva0yf69n0zib9z5fl3k5awlqfscz4fw26"; depends=[mvtnorm zoo class]; };
   modeest = derive { name="modeest"; version="2.1"; sha256="0l4y7yhkgsxycdd2lck0g8g6k2r059hwlrrcpl46md3rva4jgbnp"; depends=[]; };
···
   ModelMap = derive { name="ModelMap"; version="3.0.15"; sha256="1d7qn1p4fv94bdlr6if64vxl9yknavix4gzmpg3kxwlrxaz2g8a2"; depends=[randomForest raster gbm rgdal fields HandTill2001 PresenceAbsence]; };
   modeltools = derive { name="modeltools"; version="0.2-21"; sha256="0ynds453xprxv0jqqzi3blnv5w6vrdww9pvd1sq4lrr5ar3k3cq7"; depends=[]; };
   modiscloud = derive { name="modiscloud"; version="0.14"; sha256="0vwhfp50yb21xkanvzk983vk0laflv60kj1ybx3fydfljwqx0rwj"; depends=[date sp sfsmisc raster rgdal]; };
-  MODISTools = derive { name="MODISTools"; version="0.93.9"; sha256="086i965gxmcqz7n0a1wg4jhplb3ivpfpwl1w32vzr0wql5yyp85i"; depends=[RCurl XML]; };
-  modTempEff = derive { name="modTempEff"; version="1.5.1"; sha256="1xny818gnr5fphxvpc343mcc6xcacr0asi36m7q0bxmzy3lhs8r6"; depends=[mgcv]; };
+  MODISTools = derive { name="MODISTools"; version="0.94.4"; sha256="177gmrzyfx13bznwx1pwfkixypi1x0r1wddxy3mzxf91qj4f335q"; depends=[RCurl XML]; };
+  modTempEff = derive { name="modTempEff"; version="1.5.2"; sha256="00xdvc0i3p8wq913giy44w0xz07sa4bdgqpi7pmpbv2c5wj30pk1"; depends=[mgcv]; };
   moduleColor = derive { name="moduleColor"; version="1.08-1"; sha256="16z0iyy517j1kbsbcpdppy0gyac7vyfz13yznzhs42fwj7k0iwxl"; depends=[dynamicTreeCut]; };
   MOJOV = derive { name="MOJOV"; version="1.0.1"; sha256="11mcqxw83z4xx29s34v4rsbb3zvyhlb2lmvf97b77n455gsy5hab"; depends=[aod survey saws lattice]; };
-  mokken = derive { name="mokken"; version="2.7.5"; sha256="0wrf5xlhvb3lcjdxkrf8pfsq8k159l5zvcwni653vrxl1rfwh69m"; depends=[]; };
+  mokken = derive { name="mokken"; version="2.7.7"; sha256="1v0khh1bb2h7j2x54mdw8vqlimhw25r2ps89hw4l88qfaz05ir77"; depends=[poLCA]; };
   mombf = derive { name="mombf"; version="1.5.7"; sha256="0kmxzdkjwlbw3sjinjcxsi1fjylib232agvq0bx58i7bzcad8bv9"; depends=[mvtnorm ncvreg actuar mgcv]; };
   moments = derive { name="moments"; version="0.13"; sha256="05pa4gkmpmp744a5rsr2arqh7y5bgalwrwdn731jg6waqiniy024"; depends=[]; };
   Momocs = derive { name="Momocs"; version="0.2-6"; sha256="187w6xyswlg5nac6lbprcwvj63gka832n33vlj2ix810vqyxd0fk"; depends=[ade4 sp shapes jpeg spdep ape]; };
   mondate = derive { name="mondate"; version="0.10.01.02"; sha256="18v15y7fkll47q6kg7xzmj5777bz0yw4c7qfiw2bjp0f3b11qrd2"; depends=[]; };
-  MonetDB_R = derive { name="MonetDB.R"; version="0.9.4"; sha256="0ivymfng1959xw5wwmfl8l72dz4skarsb791ij54xcfn4v7c18np"; depends=[DBI digest]; };
   monitoR = derive { name="monitoR"; version="1.0.2"; sha256="1nrw8xrp99p62w4bpsbca9ahdra9cid1piidwhjc4f6vqsbkp479"; depends=[tuneR]; };
   monmlp = derive { name="monmlp"; version="1.1.2"; sha256="14x6xz07hg2c5n36rc314z66jqvgmicjxi2vsqyy91vwjxs9akrm"; depends=[]; };
   monomvn = derive { name="monomvn"; version="1.9-5"; sha256="1fh0c1234hb5f3rwy85i4rlzc3n1851q5mivckcjs2vdm9rz25mg"; depends=[pls lars MASS]; };
···
   moonsun = derive { name="moonsun"; version="0.1.3"; sha256="1y8mwxmcy4iz444c2fayyi4i0jk1k561dp6cbjg2b3lmdml0whmi"; depends=[]; };
   mopsocd = derive { name="mopsocd"; version="0.5.1"; sha256="10hssnm1afqmxa9kw6ifqnz3p3yyjrmxgi98zlj31a5g4nis8wb1"; depends=[]; };
   morgenstemning = derive { name="morgenstemning"; version="1.0"; sha256="17y90cf8ajmkfwla0hm4jgkbkd1mxnym63ph2468sfxkhn0r3v88"; depends=[]; };
-  Morpho = derive { name="Morpho"; version="2.0.3-1"; sha256="0j2wfjxrk0myxk1j4g0jh68npg8wwia2i3a02dn9mxnmx90nbvaa"; depends=[Rvcg rgl colorRamps foreach Matrix yaImpute doParallel Rcpp]; };
+  Morpho = derive { name="Morpho"; version="2.1"; sha256="0l084myn49krm1j9d9rb4jb40yf9kd1v3m06arzi9bjy33id7bg2"; depends=[Rvcg rgl colorRamps foreach Matrix yaImpute doParallel Rcpp]; };
   morse = derive { name="morse"; version="1.0.2"; sha256="044aljv48mfq6yj9i77yqf03qa4qqkncaalzhph3wr9w4jvxpxn5"; depends=[plyr]; };
   MorseGen = derive { name="MorseGen"; version="1.2"; sha256="1kq35n00ky70zmxb20g4mwx0hn8c5g1hw3csmd5n6892mbrri8s9"; depends=[]; };
-  MortalitySmooth = derive { name="MortalitySmooth"; version="2.3.2"; sha256="0r24v94nslavxjxvyc8a1f6dar3vm2lysg6qpxcgw6zgx8k0vk00"; depends=[svcm lattice]; };
-  mosaic = derive { name="mosaic"; version="0.9-0"; sha256="0zmzx1mh6nhp6jz68abdl44hb918cyrpa1qj25m41c0x83rnwi0s"; depends=[car dplyr lattice ggplot2 reshape2 plyr Hmisc latticeExtra gridExtra ggdendro]; };
-  moult = derive { name="moult"; version="1.3"; sha256="0mvzyildng2qs4jgws37wa2b8ms8bv7mmzs0dxbc1wcq56vfs9yj"; depends=[Formula]; };
+  MortalitySmooth = derive { name="MortalitySmooth"; version="2.3.3"; sha256="1ms9f13n554n4y04rpsnlwwbplk225k467jrldhkigshvc721m9r"; depends=[svcm lattice]; };
+  mosaic = derive { name="mosaic"; version="0.9.1-3"; sha256="1flnzg2hwzlvhkn167y8chc0prrhijb96y0sr87rssbcy5zyzhzr"; depends=[car dplyr lattice ggplot2 mosaicData MASS reshape2 plyr latticeExtra gridExtra ggdendro]; };
+  mosaicData = derive { name="mosaicData"; version="0.9.1"; sha256="0gxnw3x806pm97x1043qq3qf1cwn1z1771cayp3xlh5khn5bijk7"; depends=[]; };
+  moult = derive { name="moult"; version="1.4"; sha256="0nglf7wijp2v66fpyh88glbn1glp8vvkbvpc1g6136bg6ahbbkkl"; depends=[Formula Matrix]; };
   move = derive { name="move"; version="1.2.475"; sha256="0d542554bamgnc5qd7z497ssk885mz4m1wbaiqpi5cyxd24kwgii"; depends=[geosphere sp raster rgdal]; };
   movMF = derive { name="movMF"; version="0.2-0"; sha256="1p9ay7w93gyx4janw23iwg2j0wkvnvzalaa20n1rlahhmh327g7i"; depends=[skmeans clue slam]; };
-  mp = derive { name="mp"; version="0.1"; sha256="13wsfhvxwpvz5qx95a720vp2l7807whvrv7dabqfajmnc45bdlj4"; depends=[]; };
+  mp = derive { name="mp"; version="0.1.2"; sha256="1g5zalsygnznkq1zmrmfbxqff5ib7viyq3hq9g3xfkjmn752q0as"; depends=[]; };
   mpa = derive { name="mpa"; version="0.7.3"; sha256="0mhnsbgr77fkn957zfiw8skyvgd084rja1y4wk5zf08q5xjs2zvn"; depends=[network]; };
   MPAgenomics = derive { name="MPAgenomics"; version="1.1.0"; sha256="0kf6vsxp6dcmqkl7yjyfjch9ms33pf9w7qrk76q05man5hn7y4fz"; depends=[R_utils changepoint glmnet cghseg]; };
+  mpath = derive { name="mpath"; version="0.1-15"; sha256="1zb87xb6vj7n76nfk519blc77dj4yaq37j157frqxiw62bvb6qpl"; depends=[MASS glmnet pscl numDeriv]; };
   MPCI = derive { name="MPCI"; version="1.0.6"; sha256="1ngxx5363cm2cid3dl9amva016xy914sz49nfdkh88hjsxv3svjc"; depends=[]; };
+  mpcv = derive { name="mpcv"; version="1.1"; sha256="0vwycspiw9saj811f6alkbijivy7szpahf35bxn2rpn2bdhbn21i"; depends=[lpSolve]; };
   MPDiR = derive { name="MPDiR"; version="0.1-15"; sha256="1ga3dk9ncycsq30w6na4g7aik43v8q2kcrg7x6lpmiaa9qa2wn16"; depends=[]; };
   mph = derive { name="mph"; version="0.9"; sha256="11wcy23sv8x7aq6ky8wi0cq55yhjkkm9hn672qy803dwzzxv5y61"; depends=[]; };
   MPINet = derive { name="MPINet"; version="1.0"; sha256="1zw3piqhhpagg5qahc2xahxxfdwdk8w94aass1virlpl0f52ik8s"; depends=[BiasedUrn mgcv]; };
-  MplusAutomation = derive { name="MplusAutomation"; version="0.6-2"; sha256="0b85hnxxd46xr240k0vswwh81n57a2azmmz9wyc6x8qidiagqzxg"; depends=[plyr boot gsubfn coda xtable lattice]; };
+  MplusAutomation = derive { name="MplusAutomation"; version="0.6-3"; sha256="1zb4drqaswzwssky1bp69p3p8inqfdvxg2ji9bjrzf3vf0b5fl4p"; depends=[boot plyr gsubfn coda xtable lattice texreg]; };
   mpm = derive { name="mpm"; version="1.0-22"; sha256="0wijw8v0wmbfrda5564cmnp788qmlkk21yn5cp5qk8aprm9l1fnk"; depends=[MASS KernSmooth]; };
   mpMap = derive { name="mpMap"; version="1.14"; sha256="0gmhg5ps8yli8699a5aw26skfbjxx4zpp0paqxxdc0zl28l0pdff"; depends=[gdata seriation qtl wgaim]; };
   mpmcorrelogram = derive { name="mpmcorrelogram"; version="0.1-3"; sha256="0qgzsh744002whh3v1hrxs1i0xnk9zgfgkdgx2f0ffj00vvnwr97"; depends=[vegan]; };
-  mpmi = derive { name="mpmi"; version="0.4"; sha256="0lfzw1bncp9nhsng5j5avvwi02grx8pmf39v5zav63s0lzmrj8a3"; depends=[KernSmooth]; };
+  mpmi = derive { name="mpmi"; version="0.41"; sha256="1iwdhvdglsamzq18f0r5mh0anrd4ffrddafdlbw16kr8jy0c8fdn"; depends=[KernSmooth]; };
   mpoly = derive { name="mpoly"; version="0.0.5"; sha256="1zhmd3lsa0n56yr3bdhg3r668zrmf35phm8g69c18a3rr5qmcdqg"; depends=[stringr rSymPy rJython rJava rjson partitions plyr]; };
   Mposterior = derive { name="Mposterior"; version="0.1.2"; sha256="16a7wvg41ld2bhbss480js5h12r41nl7jmc3y4jsbv1lr5py4ymy"; depends=[Rcpp]; };
+  mppa = derive { name="mppa"; version="1.0"; sha256="06v6vq2nfh4b407x2gyvcp5wbdrcnk3m8y58akapi66lj8xplcx4"; depends=[]; };
   MPSEM = derive { name="MPSEM"; version="0.2-5"; sha256="1jy459rg7i7x24ygdnlibwlh8rx7arpajjycqw414w5p9yy9ns1f"; depends=[ape MASS]; };
-  mpt = derive { name="mpt"; version="0.4-1"; sha256="08drh66056pnvs43gc7dxhb62ajkdijbc9ca2y1hjrgvkssqk5xg"; depends=[]; };
-  MPTinR = derive { name="MPTinR"; version="1.5.1"; sha256="0gy0jdzrkwcn1yvnrdb5dqrk1z96qa2ga41zhg63kz1b2m16q7i5"; depends=[numDeriv Brobdingnag Rcpp]; };
-  MPV = derive { name="MPV"; version="1.29"; sha256="165sbayrp8p3aqwqrmf1g10agm0kdjksr6mr6p929j22kkf3k8gx"; depends=[]; };
+  mpt = derive { name="mpt"; version="0.5-0"; sha256="0bsfk8rxl3bnsydzs32061ayfgxkyxhnjk8pirgzrrsm2vk6j3j9"; depends=[]; };
+  MPTinR = derive { name="MPTinR"; version="1.6.3"; sha256="1rxh8pj6zc06zhs5rllm98br0bkmgmc9d7hk04m251ji54mj80b1"; depends=[numDeriv Brobdingnag Rcpp]; };
+  MPV = derive { name="MPV"; version="1.35"; sha256="0mfg05w7zx5my7g60yvbk2fiakrdskb82rcwzpncjdnn3pmc2axv"; depends=[]; };
   mQTL = derive { name="mQTL"; version="1.0"; sha256="0k80xvkr0b0mp3bj2s558fjxi2zf4k7ggnw6hsjm8lr84i108dks"; depends=[qtl MASS outliers]; };
   mra = derive { name="mra"; version="2.13"; sha256="1x282nzdz5bd3yji26mnzlvrkxszx15cra079k07rgdxqnixg2c8"; depends=[]; };
   mratios = derive { name="mratios"; version="1.3.17"; sha256="0a2pn4234ri5likaqbxgkw8xqmwchr6fak3nninral0yzd4rcal5"; depends=[mvtnorm]; };
   MRCE = derive { name="MRCE"; version="2.0"; sha256="0fnd7ykcxi04pv1af5zbmavsp577vkw6pcrh011na5pzy2xrc49z"; depends=[QUIC]; };
-  MRCV = derive { name="MRCV"; version="0.3-2"; sha256="061x9bnngm2f16bf6i0v00lf0g41wfg90ha0bjbphipcychzn3a3"; depends=[tables]; };
   mrdrc = derive { name="mrdrc"; version="1.0-6"; sha256="0kk6837hx4c7ixsrmib46ycvimv90ka8sj3w0310s4d7bzxvw1sc"; depends=[drc locfit]; };
-  mrds = derive { name="mrds"; version="2.1.6"; sha256="14ab9pay3daqi2pcrcx98w8fzg1l5j0vr7vfybvrsjy5xd0c8f2q"; depends=[optimx mgcv Rsolnp]; };
+  mrds = derive { name="mrds"; version="2.1.10"; sha256="0gbivbawvzpg9s9yrfnil44h8ng9k8gf8swfgmlzibi9ixrv90lb"; depends=[optimx mgcv Rsolnp]; };
   mreg = derive { name="mreg"; version="1.1"; sha256="06la0yy2yys161jhlzlcm5lcv0664wm6sa8gjdnpd1s1nx52jkqf"; depends=[]; };
+  MRH = derive { name="MRH"; version="1.1"; sha256="1qf0kx1b4nrgzx9g68yvnycjflrdhagvxav90q2nsbxk5w6ffnrq"; depends=[survival KMsurv coda]; };
   mritc = derive { name="mritc"; version="0.4-0"; sha256="02a8h1x3pk406zpn89gl5wkcd74qm5gqz8gqpckk3nv881pkayaz"; depends=[lattice misc3d fmri AnalyzeFMRI]; };
   mRm = derive { name="mRm"; version="1.1.5"; sha256="0sbpk7z4ij917nw8wyvnm87iav95ybqrzvmsjy3r8nyq55bjzyn7"; depends=[]; };
   MRMR = derive { name="MRMR"; version="0.1.3"; sha256="1b3a4bkpcncl4sh7d81nk6b2dzhzqn9zhqdxv31jgippsqm2s3k2"; depends=[reshape2 ggplot2 lubridate lmtest plyr]; };
-  mRMRe = derive { name="mRMRe"; version="2.0.4"; sha256="1ig78szk20s0cdj4pzrxxqa2hlx7126fh0jah8ym0563ps8hwill"; depends=[survival igraph]; };
+  mRMRe = derive { name="mRMRe"; version="2.0.5"; sha256="1lhpamjy8dbk3lzjj0wj041cg99rw6925i9fq297c93jxq562414"; depends=[survival igraph]; };
   MRsurv = derive { name="MRsurv"; version="0.2"; sha256="148myzk6r8whkpv1yv59dmdlr2n8vdwmaww165aw696xfjxwq550"; depends=[survival mvtnorm]; };
   MRwarping = derive { name="MRwarping"; version="1.0"; sha256="13bcs7rlm4irx7yzdnib558w9014a4chh9xwc010m6pxvxv36qnv"; depends=[boa SemiPar]; };
   msap = derive { name="msap"; version="1.1.8"; sha256="0z5lm782jjb9w1h5vgz8bmxjdcrq9zb3xp1w5cb479jjc7krlgg3"; depends=[ade4 ape]; };
   msarc = derive { name="msarc"; version="1.3.4"; sha256="0rgbrgdwjsybqcbfpf71b9z6qwwn8ph87z4hp0c1gmjrv8b9byld"; depends=[gplots]; };
   MsatAllele = derive { name="MsatAllele"; version="1.05"; sha256="1w489xjc7vxanam6hr4ym692j6a2skkmyzgqsmccy3101pzn522h"; depends=[]; };
+  msBP = derive { name="msBP"; version="1.0-1"; sha256="136s1az62zq0z92ahzywld7lnpjknxklmlh56dhgxif52b81vq0p"; depends=[DPpackage]; };
   MSBVAR = derive { name="MSBVAR"; version="0.9-1"; sha256="1qd8v3n9nvyp1j1byb8dkmvkbmk5p2kgx7wjmsa9sh4siqbxzn4w"; depends=[KernSmooth xtable coda bit mvtnorm lattice]; };
+  msda = derive { name="msda"; version="1.0.1"; sha256="0bd9am0dyrs9x8xj6rccgqcx15ddag1fakjzpyw43n3zi0h24fa6"; depends=[Matrix MASS]; };
   mseapca = derive { name="mseapca"; version="1.0"; sha256="115njdk8cv55zxd38hq9qaca686ykckni0f3xl8w3bn32gb5g9a7"; depends=[XML]; };
   MSeasy = derive { name="MSeasy"; version="5.3.3"; sha256="191mvg1imxfjlnd808ypn4lsjx7n6ydf16flax79hv01z7rcjylh"; depends=[amap clValid cluster fpc]; };
   MSeasyTkGUI = derive { name="MSeasyTkGUI"; version="5.3.3"; sha256="0ihz8vr2wbgy88bzssilgvlhkbr13jznfjvnqy73wpchqgwy0wy6"; depends=[MSeasy]; };
···
   msgpackR = derive { name="msgpackR"; version="1.1"; sha256="0a6vm4q1zfy8wlvhl9wfy09ig1iag9fvjasz5w9bll7idky4ldx5"; depends=[]; };
   msgps = derive { name="msgps"; version="1.3"; sha256="0nvxy9a41z5d111gqr1gh521imm795l1li70g1mzrag1gpg810c5"; depends=[]; };
   msir = derive { name="msir"; version="1.3"; sha256="0d7zxjmhr1ri3qz3fdkf56fi5dz2p9lb2vyqccrpn7js2ibkqhpl"; depends=[mclust]; };
+  MSIseq = derive { name="MSIseq"; version="0.99.1"; sha256="1wg0j0qr2g2lhhw57cvlawd5hik0bmqb66ynxgn62sgx1nkj3g74"; depends=[RWeka rJava R_utils]; };
   msm = derive { name="msm"; version="1.4"; sha256="1x7ys6695jarwfkh3xv607mwm5l2y2gzq2mczjfdcs9mla2l96a5"; depends=[survival mvtnorm expm]; };
   msme = derive { name="msme"; version="0.5.1"; sha256="1bkj10pgmv9q61384fwd2pxccclclc3knc5x212p42w4w49hnm1q"; depends=[MASS lattice]; };
   msos = derive { name="msos"; version="1.0.1"; sha256="0fbxi8x83sj8a6bahc7q28vql00pxqdia2vxb6ilsc459xaph6vc"; depends=[mclust tree]; };
   MSQC = derive { name="MSQC"; version="1.0.1"; sha256="1vs9kygjg9f4sr1m80hdn03gdhbdqfjamqxhbs9zha8smjrsgisw"; depends=[rgl]; };
   msr = derive { name="msr"; version="0.4.1"; sha256="1kfj6xq7l32ligc53akiym3s9if87087gan8nqz4w7d8nxp693s7"; depends=[Matrix class glmnet e1071 rgl RColorBrewer colorspace]; };
   msSurv = derive { name="msSurv"; version="1.1-2"; sha256="1nyadgzwdyf48qhqdx8sszvgkhxafacnccacg39ghm6gqv8b5j60"; depends=[class lattice]; };
+  MST = derive { name="MST"; version="1.0"; sha256="142xhg7fpf27ba9gi3dxbmpcpmz56dks0rp4ybqpcxiq3z7wacxp"; depends=[survival MASS]; };
   mstate = derive { name="mstate"; version="0.2.7"; sha256="0rys25cwr814k8z65206s12yv18dala66b3nlfq882dw5cfpaybl"; depends=[survival RColorBrewer]; };
   MSwM = derive { name="MSwM"; version="1.2"; sha256="01l23ia20y3nchykha4vz6sa757zmbvgx2315cacxfcqk9rgs08c"; depends=[nlme]; };
   mtk = derive { name="mtk"; version="1.0"; sha256="0vq2xlxf86l92fl91qm8m4yfjyz1h8szmwxiics7sc9f0as0dkmy"; depends=[stringr XML sensitivity lhs rgl]; };
   MTS = derive { name="MTS"; version="0.32"; sha256="0jxa0madik1d317wsl1svb2bndi6mw125brbxpyf019lknh6yajy"; depends=[Rcpp fGarch mvtnorm]; };
   mtsdi = derive { name="mtsdi"; version="0.3.3"; sha256="1hx4m1jnfhkycxizxaklnd9illajqvv1nml8ajfn3kjmrb5z7qlp"; depends=[gam]; };
-  MTurkR = derive { name="MTurkR"; version="0.4"; sha256="19hk6jgkj7rr4syad3chmyacn0q2m9lq0z3hdrfavcwqa203zgp9"; depends=[RCurl digest XML]; };
+  MTurkR = derive { name="MTurkR"; version="0.5.51"; sha256="0x3qb8419a6nm5lvmk02lcw544jmbw6swcry20wjc7gzkrldq4zr"; depends=[RCurl digest XML]; };
   MUCflights = derive { name="MUCflights"; version="0.0-3"; sha256="03ksvv5nyzlqiml1nz405r3yqb2cl35kpm1h61zcv2nqq8cxqshs"; depends=[XML geosphere sp RSQLite NightDay]; };
   MuFiCokriging = derive { name="MuFiCokriging"; version="1.2"; sha256="09p8wdmlsf21ibqyjigwdipcin3ij0naxcd035hqgfj76v20wiyv"; depends=[DiceKriging]; };
   muhaz = derive { name="muhaz"; version="1.2.6"; sha256="1b7gzygbb5qss0sf9kdwp7rnj8iz58yq9267n9ffqsl9gwiwa1b7"; depends=[survival]; };
-  multcomp = derive { name="multcomp"; version="1.3-5"; sha256="0zi3vxp0yfmf5qvp38l16d9lr12b86av0h4i6qzwaxbmnv14vzjd"; depends=[mvtnorm survival TH_data sandwich]; };
+  multcomp = derive { name="multcomp"; version="1.3-7"; sha256="1g9vzhh2m5vh957n6mhn9ikmgn0kwjwvrcra1flqhqq2zhqsh75x"; depends=[mvtnorm survival TH_data sandwich]; };
   multcompView = derive { name="multcompView"; version="0.1-5"; sha256="0vfgvqxqgxyifkqs3r5xxj7rfn8lfmby6wyyiqa5jv01073xchib"; depends=[]; };
   MultEq = derive { name="MultEq"; version="2.3"; sha256="0fshv7i97q8j7vzkxrv6f20kpqr1kp9v6pbw50g86h37l0jghj7r"; depends=[]; };
   multgee = derive { name="multgee"; version="1.4"; sha256="02h8zl79a8ad0q3inpb3aqjr9icjxjiph2b4rxnwa6kq8p3aagwn"; depends=[gnm VGAM]; };
···
   multic = derive { name="multic"; version="0.3.8.1"; sha256="06lc9kn0z3s7x00hz8vj903q0c6cncnj4v3ygvd2yvkgcbhfvjd0"; depends=[]; };
   Multiclasstesting = derive { name="Multiclasstesting"; version="1.3.9"; sha256="09y3gnarqv15wgmk545qrwpjwb2ilv2b2kc74cxzcb2p1lflfjzm"; depends=[]; };
   MultiCNVDetect = derive { name="MultiCNVDetect"; version="0.1-1"; sha256="0mfisblw3skm4y8phfg4wa0rdchl01wccarsq79hv63y78pfhh13"; depends=[]; };
-  multicon = derive { name="multicon"; version="1.2"; sha256="0cjmh4q2yvv9pqmmnilzhzvmds2nzbipy4vd009zjfq4c925c7m0"; depends=[psych abind foreach mvtnorm sciplot]; };
+  multicon = derive { name="multicon"; version="1.3"; sha256="0qc7szww7fmzckvkfa368pqphw0gfnv28r1wy6n8kaps6dm2r8li"; depends=[psych abind foreach mvtnorm sciplot]; };
   multicool = derive { name="multicool"; version="0.1-2"; sha256="1rs7q93lcr1crrx433zgil2db1rb3n4qw62r52nvpllqfwfx98dc"; depends=[]; };
-  multicore = derive { name="multicore"; version="0.2"; sha256="10ypgs6nzi9bv8xy97cprs3ffss8jdlba5nj2gwglqggb8ch9i9r"; depends=[]; };
   multiDimBio = derive { name="multiDimBio"; version="0.3.3"; sha256="1aj6yam31mr0abjb6m5m85r1w71snha4s7h4ikyw66sc73xkmb9m"; depends=[ggplot2 lme4 misc3d MASS RColorBrewer]; };
-  multigroup = derive { name="multigroup"; version="0.4"; sha256="13811j3g6wg11yrsz3pskis2n8d7svhq9vg95d7r3fi5bbivinh5"; depends=[]; };
+  multigroup = derive { name="multigroup"; version="0.4.2"; sha256="0wnxql8mhz1sk82mrc2rvs96g91azcxzhsas3pfygk162lild035"; depends=[MASS]; };
   MultiLCIRT = derive { name="MultiLCIRT"; version="2.7"; sha256="0i9ydhqw8a6rvds708vn1ypmfw5nrnpnfzjmg4s01gcm2xswvli0"; depends=[MASS limSolve]; };
   multilevel = derive { name="multilevel"; version="2.5"; sha256="0pzv5xc8p6cpzzv9iq3a3ib1dcan445mm12whf3d6qkz2k4778g6"; depends=[nlme MASS]; };
   multilevelPSA = derive { name="multilevelPSA"; version="1.2"; sha256="1wkywcnlvmf5li3ii7vhjsj390ay88gz9ll5agiyaj15gfd3mjls"; depends=[ggplot2 plyr psych reshape proto xtable xtable]; };
···
   MultiOrd = derive { name="MultiOrd"; version="2.1"; sha256="12y5cg06qyaz72gk3bi5pqkd55n72rz056y9va49znlsqph09x2x"; depends=[mvtnorm corpcor Matrix psych]; };
   MultiPhen = derive { name="MultiPhen"; version="2.0.0"; sha256="05w7khzyxswlsz4sxhaakbz828zrdya1y8qcsdfc6w7wgl8qpmj9"; depends=[MASS abind epitools meta HardyWeinberg RColorBrewer gplots]; };
   multiPIM = derive { name="multiPIM"; version="1.4-1"; sha256="0r69gkl8k6dd2rafrwvrdkpz4jlffz1g6czspsi908jf9dyw8y72"; depends=[lars penalized polspline rpart]; };
+  multipleNCC = derive { name="multipleNCC"; version="1.0"; sha256="13z6yq77h1r6kp8wgza58c6yp9a1gqm0w36x534mxbhcmingdw9f"; depends=[survival gam]; };
   multiplex = derive { name="multiplex"; version="1.2"; sha256="06wrzglgrvahavlcknf80cp0j4k840dhmclw9g6wqv51pq9brj2f"; depends=[]; };
   multipol = derive { name="multipol"; version="1.0-6"; sha256="1yjz0p4mcgzs98s61i8315wyhh986jxp8b0lq66375ckpr2ddcss"; depends=[abind]; };
   multisensi = derive { name="multisensi"; version="1.0-7"; sha256="1sq0jxkp33wsv6id27nka0764mr1jskqzsr2nhmqc4c8l312bkp6"; depends=[]; };
-  MultiSV = derive { name="MultiSV"; version="0.0-62"; sha256="05klka4y60q7d4yi47q784y64irgic6cwcj330zm96j1hf2dli16"; depends=[nlme reshape]; };
+  multispatialCCM = derive { name="multispatialCCM"; version="1.0"; sha256="1fzd91w10iln8qb81z240lq3fi4gq22l4rh9npkav6fiq6g6rlp8"; depends=[]; };
+  MultiSV = derive { name="MultiSV"; version="0.0-67"; sha256="0924lvkx12aqjxxz8bwqdi4h9xc2acf8aynllx0m45ip5r4gh1g2"; depends=[nlme reshape]; };
   multitable = derive { name="multitable"; version="1.6"; sha256="067bgl793wwvb1rhan70ih0ga3dxja2c6zx7fwzml5rqi6p728pr"; depends=[]; };
   multitaper = derive { name="multitaper"; version="1.0-8"; sha256="1x0a4nrngh1hs44h4gnmjfhx57kgxmkyzm431i5k288ydv57vvx0"; depends=[]; };
   multivator = derive { name="multivator"; version="1.1-4"; sha256="125ifkpm1pny4rjpzirnwpmpjfg0y8w0rygj0way0p1qwm0l207n"; depends=[emulator mvtnorm]; };
-  multiwayvcov = derive { name="multiwayvcov"; version="1.0.4"; sha256="1cn906qsffjnvi7ycbrvd91jawyxlph6gzf74yb4dpbbkyk4n8p1"; depends=[sandwich]; };
+  multiwayvcov = derive { name="multiwayvcov"; version="1.2.1"; sha256="15gxcrg2i1aqbxkif5dmdz81yzqj7a4hq0dcd0narzsvm5b4w9py"; depends=[sandwich boot]; };
+  MultNonParam = derive { name="MultNonParam"; version="1.0"; sha256="0xff81wjmyw2d38r0v3n7vv0dasg9rlrc0zrdwsmfd83zpvxqj5m"; depends=[]; };
   multxpert = derive { name="multxpert"; version="0.1"; sha256="03mvf4m0kabm22vy4zkj1cfh884larpj8cbgg3p9l3pag20snf1l"; depends=[mvtnorm]; };
   muma = derive { name="muma"; version="1.4"; sha256="0midx3wzyvcz8rk9kvsfll3xg41pkz40si4jw2ps54ykkf9rkm99"; depends=[car pdist pls gplots mvtnorm robustbase gtools bitops caTools pcaPP rrcov]; };
   MuMIn = derive { name="MuMIn"; version="1.10.5"; sha256="1pza894h6mjjv2i4ifx2z410bz7lw2a9b986z6x30sr2al4xvfkn"; depends=[]; };
···
   muscle = derive { name="muscle"; version="3.8.31-4"; sha256="0pijc8x6pwsb6z4061v1r7iwq5lsnia5qn1bikwpxy8ir19nic72"; depends=[]; };
   muStat = derive { name="muStat"; version="1.7.0"; sha256="18727xj9i9hcnpdfnl1b9wd6cp7wl1g74byqpda2gsrcardl57wz"; depends=[]; };
   mutoss = derive { name="mutoss"; version="0.1-8"; sha256="13x49dk1xyn697yindg6m00nqbn2cb12544v2k14ckmnw07mp1gq"; depends=[mvtnorm plotrix multcomp]; };
-  mutossGUI = derive { name="mutossGUI"; version="0.1-8"; sha256="1lpfz5d36v0szfg7vn7gdad27rvzxbx4w3651dmi2y1ff0d8j5z3"; depends=[rJava JavaGD CommonJavaJars plotrix mutoss multcomp]; };
+  mutossGUI = derive { name="mutossGUI"; version="0.1-9"; sha256="1xdby6n0w1155kx6mhinvgqm0ssgyy4443pkq3k88a5s4bfxw5bw"; depends=[mutoss multcomp plotrix rJava JavaGD CommonJavaJars JGR]; };
   MVA = derive { name="MVA"; version="1.0-5"; sha256="18x075hjqhrjwxivvrixgs6yc67il3n5p1m7v2wymcf8h2mkki91"; depends=[HSAUR2]; };
   mvabund = derive { name="mvabund"; version="3.9.1"; sha256="0v9chsc08a9gsj026kv99jv0d3ww5gxblbliscqghl4b36hzkx6r"; depends=[Rcpp MASS tweedie statmod]; };
   MVB = derive { name="MVB"; version="1.1"; sha256="0an8b594rknlcz6zxjva6br8f34sgwdi2jil3xh1xzb5fa55dw0f"; depends=[Rcpp RcppArmadillo]; };
···
   mvinfluence = derive { name="mvinfluence"; version="0.6"; sha256="1cd5p6cl2zln8madjf3vsbmqlg4nsklzzy6ngdd5glj1a9qapd6c"; depends=[car heplots]; };
   mvmeta = derive { name="mvmeta"; version="0.4.5"; sha256="0faczanbz6i7794sqxm21a6v52cs5hrjjzdypdvi23bkl4mkxjrb"; depends=[]; };
   mvMORPH = derive { name="mvMORPH"; version="1.0.2"; sha256="1zzh2vmm3l6zvzg8b39ivkx2jmbw2g6n00jj4icp46w8jb26rlwa"; depends=[phytools ape corpcor subplex]; };
-  MVN = derive { name="MVN"; version="3.4"; sha256="13cmb4xls3j366lcjl6a7vimx457q1a531sy23nrddmyw1g918l2"; depends=[nortest moments MASS]; };
+  MVN = derive { name="MVN"; version="3.5"; sha256="1mfchzqgmvd6qwlyppkcw2lfgc38vq264rjlzqkdyy50kkry43d3"; depends=[nortest moments MASS robustbase mvoutlier]; };
   mvna = derive { name="mvna"; version="1.2-3"; sha256="1gwv17j6w9c38bqvnasv9kfigbdxiqkzwj89gqmkxgw715f9nnpp"; depends=[lattice]; };
-  mvnfast = derive { name="mvnfast"; version="0.1.2"; sha256="1pa0l6krk44pa3ndnh7wm77cg79x7m7n8r3ffz0w8jmzh59s9nr2"; depends=[Rcpp]; };
+  mvnfast = derive { name="mvnfast"; version="0.1.3"; sha256="1ghm6zdrh2ax8r4jin8gka0qjwcsixn5faclf17sr5bx7l5b62np"; depends=[Rcpp]; };
   mvngGrAd = derive { name="mvngGrAd"; version="0.1.3"; sha256="1c0rwywsa2dzhhphwc9prdxv6jyk1qdc655zvzyxif6ay3wnganf"; depends=[]; };
   mvnmle = derive { name="mvnmle"; version="0.1-11"; sha256="02mpmrr22cqb3v8x7kydgg715yl3lrdgzgdqpchmp0xrl2db8gq4"; depends=[]; };
   mvnormtest = derive { name="mvnormtest"; version="0.1-9"; sha256="1iaxjwp7bgxhaa4xqvgqb61316mq2fb0452d0pabhmbxkvmvdnj6"; depends=[]; };
···
   MVPARTwrap = derive { name="MVPARTwrap"; version="0.1-9.2"; sha256="0kj89nlndfcddsx2i9isfd7lqzj8rlsd47anhca5cmj1nyjsb4w5"; depends=[mvpart Hmisc labdsv vegan fBasics ade4]; };
   MVpower = derive { name="MVpower"; version="2.0"; sha256="176g8jfn8gbbhyxcny9prvkn7gk23lmcr4pnxlf0a0pacxczsldr"; depends=[randomForest pamr kernlab class]; };
   mvProbit = derive { name="mvProbit"; version="0.1-0"; sha256="0fnrlralydlsf9iphq385f8hpqigfmi8rafvgp443gygvpq5b6g0"; depends=[mvtnorm maxLik abind bayesm miscTools]; };
+  mvprpb = derive { name="mvprpb"; version="1.0.4"; sha256="1kcjynz9s7vrvcgjb9sbqv7g50yiymbpkpg6ci34wznd33f7nrxm"; depends=[]; };
   MVR = derive { name="MVR"; version="1.20.0"; sha256="1wwzws9116ck14g6xd1svmwc9wkr8piwb24bddnzri388p8qkgb4"; depends=[statmod]; };
+  mvrtn = derive { name="mvrtn"; version="1.0"; sha256="0k0k76wk5zq0cjydncsrb60rdhmb58mlf7zhclhaqmli1cy697k8"; depends=[]; };
   mvsf = derive { name="mvsf"; version="1.0"; sha256="1krvsxvj38c5ndvnsd1m18fkqld748kn5j2jbgdr3ca9m3i5nlwf"; depends=[nortest mvnormtest]; };
   mvShapiroTest = derive { name="mvShapiroTest"; version="1.0"; sha256="0zcv5l28gwipkmymk12l4wcj9v047pr8k8q5avljdrs2a37f74v1"; depends=[]; };
   mvSLOUCH = derive { name="mvSLOUCH"; version="1.1.3"; sha256="1vkyhy6a12hdlkwsf64lgimpigri6r6l02vvy1b5r05j002baxgr"; depends=[ouch ape numDeriv mvtnorm corpcor]; };
···
   mvtnorm = derive { name="mvtnorm"; version="1.0-0"; sha256="0cm0dwqga7nnb2016jzacmaa233whr7vx75fffhmjzivrfg5vhy8"; depends=[]; };
   mvtsplot = derive { name="mvtsplot"; version="1.0-1"; sha256="0g5grrha77rsnkfasw5pxnpmkl7vgb728ms8apyg8xnbmgilg9vv"; depends=[RColorBrewer]; };
   mwa = derive { name="mwa"; version="0.3.2"; sha256="123xvm4vrwl7vfc9sas4jj7fn38m37c6h38j0aczpmygmx54bbmr"; depends=[cem rJava MASS]; };
-  mwaved = derive { name="mwaved"; version="1.0.1"; sha256="0c9hiwf7ldvgm3vh5s7wgvgl304cc2sbsyczbk1wqybcy17cs7s5"; depends=[Rcpp shiny]; };
+  mwaved = derive { name="mwaved"; version="1.1.0"; sha256="1d06b0yxhrqx190qqisgaj2c6mx47bpj1h89jgbk9zdww9pqnvq4"; depends=[Rcpp shiny]; };
   mxkssd = derive { name="mxkssd"; version="1.1"; sha256="0m9763dqrk8qkrvp18bsv96jv0xhc2m8sbxdk6x3w6kdjcl663p2"; depends=[]; };
   MXM = derive { name="MXM"; version="0.2.1"; sha256="047whr0fly89i5vlyd4z8lj2nxyfkk9vvniasncnwls8vmmpf1jk"; depends=[]; };
   mycobacrvR = derive { name="mycobacrvR"; version="1.0"; sha256="1xd9ackzdd8db6bayza0bg4n256mi9rdqih0cdc0nl212c3iz75g"; depends=[]; };
   myepisodes = derive { name="myepisodes"; version="1.1.1"; sha256="0xk9bwgpl630nhc8qa2pc0rwqbqk3haxnp78gfxq6sn6z7i44k1p"; depends=[XML]; };
   Myrrix = derive { name="Myrrix"; version="1.1"; sha256="15w1dic6p983g2gajbm4pws743z68y0k2hxrdwx6ppnzn9rk07rs"; depends=[Myrrixjars rJava]; };
   Myrrixjars = derive { name="Myrrixjars"; version="1.0-1"; sha256="0dy82l0903pl4c31hbllscfmxrv3bd5my5b2kv5d3x5zq0x99df0"; depends=[rJava]; };
+  nabor = derive { name="nabor"; version="0.4.3"; sha256="10h6pf44db75y956h5wfkfwh7lm5lxpz33p8h60802sg0nvs8src"; depends=[Rcpp]; };
   nacopula = derive { name="nacopula"; version="0.8-1"; sha256="1g1kcs6vqagq0nisyc43040ri3a9iy3fv4bnjjjc5zrla52a20w5"; depends=[copula copula]; };
   NADA = derive { name="NADA"; version="1.5-6"; sha256="0y7njsvaypcarzygsqpqla20h5xmidzjmya4rbq39gg6gkc0ky27"; depends=[survival]; };
   nadiv = derive { name="nadiv"; version="2.13.2"; sha256="1r63z08k46b6hryxracicsw1hr91x4pgk2x58c9nijdni4my7kkc"; depends=[Matrix]; };
   namespace = derive { name="namespace"; version="0.9.1"; sha256="1bsx5q19l7m3q2qys87izvq06zgb22b7hqblx0spkvzgiiwlq236"; depends=[]; };
-  nanop = derive { name="nanop"; version="2.0-3"; sha256="1dz06j292n7ppibmlp7pzjywcglv86hp7lsh07dz7j7p8gbbsza8"; depends=[distrEx rgl]; };
+  nanop = derive { name="nanop"; version="2.0-4"; sha256="0795kksw6yry9il8xj21iq13xw6jipqcv5vjs3k7s19dbah2k8pi"; depends=[distrEx rgl]; };
   NanoStringNorm = derive { name="NanoStringNorm"; version="1.1.17"; sha256="02jvrrz4cmr7l35s7xh0mmwmr5l5lga1vnph2rij2lb8124ardf5"; depends=[gdata]; };
   NAPPA = derive { name="NAPPA"; version="2.0"; sha256="18yipic8xkf13jaaxnn388m49r5q2g7q7gb0mmw3gh7226lmz987"; depends=[plyr NanoStringNorm]; };
   nasaweather = derive { name="nasaweather"; version="0.1"; sha256="05pqrsf2vmkzc7l4jvvqbi8wf9f46854y73q2gilag62s85vm9xb"; depends=[]; };
-  nat = derive { name="nat"; version="1.4.10"; sha256="1200qxsrhlxassi8jyrcwfpknyck2p092sxv2gkc74vp62w2b0lp"; depends=[rgl RANN igraph filehash digest nat_utils]; };
+  nat = derive { name="nat"; version="1.5.12"; sha256="1pf6d6y6zakixlhvmpv1di27waz5gnhk8gmnk4n76xgfs3zk85lb"; depends=[rgl RANN igraph filehash digest nat_utils plyr]; };
+  nat_nblast = derive { name="nat.nblast"; version="1.5"; sha256="1slpk126fwgn90j3aazlf3pw2ij050dghc1yqadv6mjcj82qpm5i"; depends=[rgl nat nabor dendroextras plyr spam]; };
+  nat_templatebrains = derive { name="nat.templatebrains"; version="0.4.1"; sha256="06vqnrwcara4ljkf5wbwqbsfx1ypd8xsv8pbrs5x6hyj5jxnnvaz"; depends=[rgl nat]; };
   naturalsort = derive { name="naturalsort"; version="0.1.2"; sha256="0m8a8z0n5zmmgpmpn5w87j2jfsz1igz3x133z3q25h8jlyaxy750"; depends=[]; };
   nat_utils = derive { name="nat.utils"; version="0.4.2"; sha256="0k5bdqwrbq82bb9ld90ia7b4vjaczba20h231a129rkszsy6sz9v"; depends=[]; };
-  NbClust = derive { name="NbClust"; version="2.0.1"; sha256="00b4h17pnvqsk0hvaz6dbrrys3dshy6zf0s371z7rr1n52xyy8ga"; depends=[]; };
+  NB = derive { name="NB"; version="0.9"; sha256="1gh42z7lp6g09fsfmikxqzyvqp2874cx3a6vr96w43jfwmgi2diq"; depends=[]; };
+  NbClust = derive { name="NbClust"; version="2.0.3"; sha256="1wphzfb63j85na2l8plc02wmkpvzwi8wp8q8i04jf1n265fa378l"; depends=[]; };
   NBDdirichlet = derive { name="NBDdirichlet"; version="1.01"; sha256="07j9pcha6clrji8p4iw466hscgs6w43q0f7278xykqcdnk39gkyv"; depends=[]; };
   nbpMatching = derive { name="nbpMatching"; version="1.4.0"; sha256="0ncw8xihdh24cfz0rhcvvp2l5mhm2z7hllnkf45bhdhpams6yryp"; depends=[Hmisc MASS]; };
   NBPSeq = derive { name="NBPSeq"; version="0.3.0"; sha256="0l4ylxhs2k9ww21jjqs67fygk92avdchhx2y1ixzl7yr2yh1y9by"; depends=[]; };
   nCal = derive { name="nCal"; version="13.12-01"; sha256="06grlb7ac9vy3ncnqz5h63iarsh94z4mcb29bigkdvnbv9whj7mn"; depends=[drc gdata gWidgets xtable]; };
   NCBI2R = derive { name="NCBI2R"; version="1.4.6"; sha256="1gsvc9v9005hf71nsqgybnfhlmdr3wwzm5ab7h8c8ly5waq2w9i7"; depends=[]; };
   ncbit = derive { name="ncbit"; version="2013.03.29"; sha256="0f07h8v68119rjvgm84b75j0j7dvcrl6dq62vp41adlm2hgjg024"; depends=[]; };
-  ncdf = derive { name="ncdf"; version="1.6.7"; sha256="14jqbr6xjq58zawc14j85advbafspfrn40al26zg0v3warwlfwfy"; depends=[]; };
-  ncdf4 = derive { name="ncdf4"; version="1.12"; sha256="110h4s0qg6rp0k1s3fl464g409mq5ajyhfb0cxvwbgz2dp32p8aj"; depends=[]; };
+  ncdf = derive { name="ncdf"; version="1.6.8"; sha256="0600qh0diw1j47w8b7gpk1wkpvinpvf3g9v3hlp3f8hcwpdn3s0y"; depends=[]; };
+  ncdf4 = derive { name="ncdf4"; version="1.13"; sha256="07s1lh5cg4fck7sapfka2skky70max1rfhimblnqf41phndxjcsv"; depends=[]; };
   ncdf4_helpers = derive { name="ncdf4.helpers"; version="0.3-3"; sha256="051akd7r6zx805a0xwcs95q5sd8alag0f1gzqjk3n188q8r3ji5j"; depends=[ncdf4 PCICt abind]; };
   ncdf_tools = derive { name="ncdf.tools"; version="0.7.1.291"; sha256="149d89kim67q77w17afc5x7hkvmk05gfkaw6cpl583j2zxingify"; depends=[RNetCDF chron abind plotrix raster RColorBrewer JBTools]; };
   nCDunnett = derive { name="nCDunnett"; version="1.0.0"; sha256="0n5zzsdrhra5xql110wrxbfdjm3fwa6qhvnpj89w9ph9nr4ad8gf"; depends=[]; };
   ncf = derive { name="ncf"; version="1.1-5"; sha256="03nbmg9swxhpwrmfjsanp6fj5l2nw160sys70mj10a0ljlaf904z"; depends=[]; };
   ncg = derive { name="ncg"; version="0.1.1"; sha256="1jzkzp61cc5jxmdnl867lcrjjm7y2iw9imzprbd098p1j3w8fvj7"; depends=[]; };
-  NCmisc = derive { name="NCmisc"; version="1.1"; sha256="13nx9p6yq46lf2q92ximi33wynxfxah8ns18227xxm99d6fpb05v"; depends=[proftools]; };
+  NCmisc = derive { name="NCmisc"; version="1.1.3"; sha256="051qbqsvqb5wivba8msdhswfg0cxyxnyp601zgb1zvzcnbrffimg"; depends=[proftools]; };
   ncvreg = derive { name="ncvreg"; version="3.2-0"; sha256="0j53aj71lxz3pxh6a4vlgw0f9zk4gjh4xf5c7qsm5cp8nfpkplm5"; depends=[]; };
   ndl = derive { name="ndl"; version="0.2.16"; sha256="1l56kg3x4579hzr4sig3iwrd81rhm8nmmrqfs54zxqv5yxpk3hp4"; depends=[Rcpp MASS]; };
   ndtv = derive { name="ndtv"; version="0.5.1"; sha256="0cvqpr74als10zhdravbc7ykacy3ll7y5fx4n5jik0avwcaclgkc"; depends=[network networkDynamic animation sna MASS statnet_common]; };
···
   NEff = derive { name="NEff"; version="1.0"; sha256="0ksnmxjy2ms2z7rq4rddnykydwlb4f9c13nak5f8m65pfjcgv3sk"; depends=[msm bit]; };
   negenes = derive { name="negenes"; version="1.0-1"; sha256="0g8m3idjm24cf9b1wngw2pv1axgnv9mk5wqs78zgwvn0m67ypsiz"; depends=[]; };
   neldermead = derive { name="neldermead"; version="1.0-9"; sha256="144liymq0cnd80cp2vn2d1j22g0izipnchc90r526gfpm2gklh7n"; depends=[optimbase optimsimplex]; };
-  Nemenyi = derive { name="Nemenyi"; version="1.1"; sha256="1hcliwbzy1ckyy49kh8qn0830s1ari40mqkvx9vj4hsdys9wjhnl"; depends=[]; };
   nephro = derive { name="nephro"; version="1.0"; sha256="0dv6gj1q6qrg9y6cpf230q1mksqk3nvzj3afavhrwz1fcz2w22f4"; depends=[]; };
   NestedCohort = derive { name="NestedCohort"; version="1.1-3"; sha256="10hsc6zik8sz2mp6ig3xr6z3bq0c6rlvqkn11pxny17a4n02wapp"; depends=[survival MASS]; };
   netClass = derive { name="netClass"; version="1.2.1"; sha256="04yrj71l5p83rpwd0iaxdkhm49z9qp3h6b7rp9cgav244q060m9y"; depends=[kernlab Matrix ROCR igraph samr]; };
···
   NetData = derive { name="NetData"; version="0.3"; sha256="1jf05zwy0c6gmm7kvxlwvai61bz4wpsw7cl0h4i21ipzn1rqxmqj"; depends=[]; };
   NetIndices = derive { name="NetIndices"; version="1.4.3"; sha256="0ff57f5b12lccqbfin530ra373rn1wz6n42b0jnkyi2ra8hcm88f"; depends=[MASS]; };
   netmeta = derive { name="netmeta"; version="0.6-0"; sha256="0cwlwd4bms0kf6nicx7crjjighzrzjgfgmx5yl5v7am4v7kwhz2g"; depends=[meta magic]; };
-  NetPreProc = derive { name="NetPreProc"; version="1.0"; sha256="1w0iih6pz8ci1y09xlzm2x3082s57znp1cxq44ckwh45hvzbxbmi"; depends=[]; };
   nets = derive { name="nets"; version="0.1"; sha256="0zshiavdi1z8mq6q93vsyb5wx5nq37qln9gcyvamvi2pgy5xg4k2"; depends=[igraph]; };
   NetSim = derive { name="NetSim"; version="0.9"; sha256="07h4qwz64k8zj8c2mx23cbnhg4rqrb4nfh20xw98kspz7cisdg6d"; depends=[Rcpp]; };
-  netweavers = derive { name="netweavers"; version="1.0"; sha256="1k0i31h1wg3hk6m0w56jq14hqc4xpdmw7xy4mydars2nzfj41kzj"; depends=[igraph]; };
+  nettools = derive { name="nettools"; version="1.0.1"; sha256="13fw316r31g9cjlbyy9qfccsyagxb6pyvn5k32f166b7vj92mk1q"; depends=[rootSolve dtw WGCNA Matrix minerva combinat igraph]; };
   network = derive { name="network"; version="1.10.2"; sha256="1qdlwdhqyv1z4vhcbyqfx4iw207m76gly87pgyb85wqif4fifk0x"; depends=[]; };
   networkDynamic = derive { name="networkDynamic"; version="0.6.3"; sha256="0yb536q7v16wx491c5dmw7sf7h4f2rxs39bsdi0sknizgnmsqlv0"; depends=[network statnet_common]; };
   networkDynamicData = derive { name="networkDynamicData"; version="0.1.0"; sha256="1vln4n8jldqi1a6qb9j9aaxyjb8pfgwd8brnsqr8hp9lm3axd24b"; depends=[networkDynamic network]; };
   networkreporting = derive { name="networkreporting"; version="0.0.1"; sha256="1vfvx5gf90p31gy6kcv7l2ibzbfl382gffa79dl8gascbsg6s8z8"; depends=[functional ggplot2 plyr reshape2 stringr]; };
   networksis = derive { name="networksis"; version="2.1-2"; sha256="05x0mp9ig7nff1js0zv7hq8p7jr7dqscs46zlbrxrrcy1waydb0s"; depends=[ergm network]; };
   networkTomography = derive { name="networkTomography"; version="0.3"; sha256="1hd7av231zz0d2f9ql5p6c95k7dj62hp0shdfshmyfjh8900amw7"; depends=[coda igraph KFAS limSolve plyr Rglpk]; };
+  neural = derive { name="neural"; version="1.4.2.2"; sha256="05hrqgppgwp38rdzw86naglxj0bz3wqv04akq7f0jxbbjc6kwy4j"; depends=[]; };
   neuralnet = derive { name="neuralnet"; version="1.32"; sha256="0p9r5j8q0flv15wn5s6qi9if7npna107l1ffv37nzx1b4vgswnl9"; depends=[MASS]; };
   neuroblastoma = derive { name="neuroblastoma"; version="1.0"; sha256="0hs87fvwaq53xxbh2dw3hjsmf1zkyqli9qyacxf72fnkyhhl8b45"; depends=[]; };
   neuroim = derive { name="neuroim"; version="0.0.3"; sha256="0n5jkyvdaiigv51s5bb508w5xkh0qkd1zbs67nnms14s1664fhiz"; depends=[stringr hash iterators abind Matrix yaImpute]; };
···
   Newdistns = derive { name="Newdistns"; version="1.0"; sha256="1agg5v05x9qlg1w439aycfjfd5yap6ivn1kqgsc3ck148ar11wb2"; depends=[]; };
   nFactors = derive { name="nFactors"; version="2.3.3"; sha256="016d76yfxz7gx7zz5dgwjmj2c5m6kxdmqj0lln5w6d70r9g1kxg7"; depends=[MASS psych boot lattice]; };
   ngram = derive { name="ngram"; version="1.1"; sha256="0p5wm55anch1i0y3478f5d4sivs7q8j3kwlg89nk3337win06499"; depends=[]; };
-  ngramr = derive { name="ngramr"; version="1.4.3"; sha256="0j66v841xkb1yw2n4pa7p8kz574np2yj2ic71z6aq71npdbxgh9a"; depends=[httr RCurl plyr rjson stringr reshape2 ggplot2 scales]; };
-  ngspatial = derive { name="ngspatial"; version="1.0-3"; sha256="1ph3yg8vcvij3ymw41dczjpzs68icm5lr0pxybmmfgggpmw5cjyb"; depends=[Rcpp batchmeans]; };
+  ngramr = derive { name="ngramr"; version="1.4.5"; sha256="1cqapla0lknxl669w5x3av9nr4vy9qrfznznqj22xlqaj0p53c18"; depends=[httr RCurl plyr rjson stringr reshape2 ggplot2 scales]; };
+  ngspatial = derive { name="ngspatial"; version="1.0-4"; sha256="0nxqjhlgp8jx7p6mcxcb2nz7m65jkraib8ffkf90kbd8xqz42wf1"; depends=[Rcpp batchmeans]; };
+  NHANES = derive { name="NHANES"; version="1.0"; sha256="18sy2x61bnily3fz0rs61y44kn6y2ikgrzr6nhgm6fkqv02ffdg8"; depends=[]; };
   NHEMOtree = derive { name="NHEMOtree"; version="1.0"; sha256="0ycprj2rz2fy6a7ps0bsr27iphmbfxi9pbvl8rcr6p8yagfb84mb"; depends=[partykit emoa sets rpart]; };
-  nhlscrapr = derive { name="nhlscrapr"; version="1.5.1"; sha256="0gyg7yvjf9r6q4br17rnlm6c8hsxlm6raym1y3rrl05ss1a63jwx"; depends=[RCurl rjson biglm bitops]; };
-  NHMMfdr = derive { name="NHMMfdr"; version="1.0.6"; sha256="10xwvmzqkx90zh88yjmf6d8gsbqil4vxp53d914080b3aygsvxm8"; depends=[MASS locfdr]; };
+  nhlscrapr = derive { name="nhlscrapr"; version="1.8"; sha256="0y2shw3g84flh88a15czdsb62xwdqxhvzkn4kpbn0k9ddyfzxc48"; depends=[RCurl rjson biglm bitops]; };
+  NHMM = derive { name="NHMM"; version="3.3"; sha256="0jq7zsz9334mvbffbq7h47p8rqp6lz1crfa8bbbpff1pjnal1kpb"; depends=[BayesLogit msm MCMCpack MASS Rcpp]; };
   NHPoisson = derive { name="NHPoisson"; version="3.0"; sha256="11gdfqfly3cvr6ndxvp06kbdd7aw6k25kz8kyxxybjpzszxbpmq8"; depends=[car]; };
   nice = derive { name="nice"; version="0.4"; sha256="1alq8n8pchn9v0fvwrifdisazkh519x109bqgnpgnwf79wblmnhy"; depends=[]; };
   nicheROVER = derive { name="nicheROVER"; version="1.0"; sha256="0sa7wfpzkin78vz48vwa5iac82v5l1s3zczdxz8sc2kyg22fj0aw"; depends=[mvtnorm]; };
···
   Nippon = derive { name="Nippon"; version="0.5.3"; sha256="02m591aljlaxn95k7sl8gfsviv4ywqv9mrkjf6g19kfrc9pbgjqg"; depends=[maptools]; };
   NISTnls = derive { name="NISTnls"; version="0.9-13"; sha256="03a1c8a5dr5l5x4wbclnsh3vmx3dy7migfdzdx7d7p3s7hj3ibif"; depends=[]; };
   nlADG = derive { name="nlADG"; version="0.1-0"; sha256="0nvd5hzd1p81jwx5p7js86wblgg615vdnpbvy5rhmhf1ig583z1b"; depends=[ggm]; };
-  nleqslv = derive { name="nleqslv"; version="2.4"; sha256="114h883rvfz48f2mx88cz1mirz15hbx3c4c4n1jvddk93dmz45j4"; depends=[]; };
-  nlme = derive { name="nlme"; version="3.1-117"; sha256="105zrprpgd4snwcy80qfnjzvd5m7g4cx8njji83gg7ynskhrhxj9"; depends=[lattice]; };
+  nleqslv = derive { name="nleqslv"; version="2.5"; sha256="1p9m9ryp58xca9arl798cmslfjvxb3w5hdg3bs62yham1q951a48"; depends=[]; };
+  nlme = derive { name="nlme"; version="3.1-118"; sha256="1lr78gyplxr4g0m3qpv62l4qp1b4nrhgk7lz1v3m0xd70y2l9j6c"; depends=[lattice]; };
   nlmeODE = derive { name="nlmeODE"; version="1.1"; sha256="1zp1p98mzbfxidl87yrj2i9m21zlfp622dfnmyg8f2pyijhhn0y2"; depends=[deSolve nlme lattice]; };
   nlmeU = derive { name="nlmeU"; version="0.70-3"; sha256="05kxymgybziiijpb17bhcd9aq4awmp5km67l2py9ypakivi0hc6l"; depends=[nlme]; };
   nlmrt = derive { name="nlmrt"; version="2013-9.24"; sha256="1nqcxfgl5iplmar58015ixir2c7agdw91i0ndn2imdx0il1x2hra"; depends=[]; };
-  nloptr = derive { name="nloptr"; version="1.0.4"; sha256="1cypz91z28vhvwq2rzqjrbdc6a2lvfr2g16vid2sax618q6ai089"; depends=[]; };
-  NLP = derive { name="NLP"; version="0.1-3"; sha256="0mg2sa1f9i2rfhzggd55mi3gmsb9xz6y51ygrk8i27vgyr7x0h7w"; depends=[]; };
+  nloptr = derive { name="nloptr"; version="1.0.4"; sha256="1cypz91z28vhvwq2rzqjrbdc6a2lvfr2g16vid2sax618q6ai089"; depends=[pkgs.nlopt]; };
+  NLP = derive { name="NLP"; version="0.1-5"; sha256="1l5c21bpbbnpspxi7nmjny1k3i9q5szyxnarndb3yx7aywkvjrkj"; depends=[]; };
   NLPutils = derive { name="NLPutils"; version="0.0-1"; sha256="036pafnjcbz7ihdgsjss4jq8fb420j8fmxyymv7kr4pr78wjysbx"; depends=[NLP SnowballC qdap]; };
   nlreg = derive { name="nlreg"; version="1.2-2"; sha256="1pi7057ldiqb12kw334iavb4i92ziy1kv4amcc4d1nfsjam03jxv"; depends=[statmod survival]; };
   NLRoot = derive { name="NLRoot"; version="1.0"; sha256="1x8mcdgqqrhyykr12bv4hl4wbh1zw2qgpnd2yrm68kb92iy95rh4"; depends=[]; };
···
   NlsyLinks = derive { name="NlsyLinks"; version="1.302"; sha256="0m1qvrpdfwql4jdk3nbn80llq83wavimifw630gnazwmkgkcncai"; depends=[lavaan]; };
   nlt = derive { name="nlt"; version="2.1-3"; sha256="1j0xrrbr1hvfda8rvnc17lj96m6cz24faxvwn68ilf7j1ab2lkgn"; depends=[EbayesThresh adlift]; };
   nlts = derive { name="nlts"; version="0.2-0"; sha256="14kvzc1p4anj9f7pg005pcbmc4k0917r49pvqys9a0a51ira67vb"; depends=[locfit acepack]; };
+  nlWaldTest = derive { name="nlWaldTest"; version="1.0.1"; sha256="1rwpkkddivpcamhsp22nmy5gz2006y9kbdzj8lhh20s1vsyhn2b3"; depends=[stringr numDeriv]; };
   nmcdr = derive { name="nmcdr"; version="0.3.0"; sha256="1557pdv7mqdjwpm6d9zw3zfbm1s8ai3rasd66nigscmlq102w745"; depends=[CDFt]; };
   NMF = derive { name="NMF"; version="0.20.5"; sha256="1j91vklzi4qjlix5sn9qh86dwx6vxnla2p4ag81apkr441jkvynr"; depends=[pkgmaker registry rngtools cluster stringr digest gridBase colorspace RColorBrewer foreach doParallel ggplot2 reshape2]; };
   NMFN = derive { name="NMFN"; version="2.0"; sha256="0n5fxqwyvy4c1lr0glilcz1nmwqdc9krkqgqh3nlyv23djby9np5"; depends=[]; };
   NMOF = derive { name="NMOF"; version="0.28-2"; sha256="0c22fpzg8qg6asd0glq5cz32mhw7607bcsl7cmrkfzwm8p4yarns"; depends=[]; };
-  nnclust = derive { name="nnclust"; version="2.2"; sha256="1mr506ddvw4lslylpmm43wmd6mwv055zjzgb427nj3jl142dfyz2"; depends=[]; };
   nnet = derive { name="nnet"; version="7.3-8"; sha256="0nhbprhwkpnhzw6jls8y76xskfh9gq491kg8q8wnamjv3gnngfa5"; depends=[]; };
   nnls = derive { name="nnls"; version="1.4"; sha256="07vcrrxvswrvfiha6f3ikn640yg0m2b4yd9lkmim1g0jmsmpfp8f"; depends=[]; };
   nodeHarvest = derive { name="nodeHarvest"; version="0.6"; sha256="16151rwmqkf5vlyrlxlirz8s0nimxppx1f7f4pwfxi9vipwph125"; depends=[quadprog randomForest]; };
···
   NominalLogisticBiplot = derive { name="NominalLogisticBiplot"; version="0.2"; sha256="0m9442d9i78x57gdwyl3ckwp1m6j27cam774zkb358dw5nmwxbmz"; depends=[mirt gmodels MASS]; };
   noncensus = derive { name="noncensus"; version="0.1"; sha256="0cfj17bfzddfshhhzv2ijhrp9ylcscmsysswjcsjfxmy3gbkd00q"; depends=[]; };
   nonlinearTseries = derive { name="nonlinearTseries"; version="0.2.1"; sha256="1pq93g25arnc68kyvv6ymywdvbqv6620dvqzv1l43c1xssw364bc"; depends=[Matrix rgl tseries TSA]; };
+  nonnest2 = derive { name="nonnest2"; version="0.1-1"; sha256="1qp7z3pr7q3cbqm3kvdw3kciz9a52r1j21gh2w2gv0wnaq5msdk3"; depends=[CompQuadForm mvtnorm sandwich]; };
   nonparaeff = derive { name="nonparaeff"; version="0.5-8"; sha256="1kkn68m7cqlzx3v539cjxw3x5a2y86lvmyv2k98s87m3yvqg0gdk"; depends=[lpSolve gdata Hmisc rms geometry psych pwt]; };
   NonpModelCheck = derive { name="NonpModelCheck"; version="1.0"; sha256="0mgbyp651jfqyfavpv12i9kwqf0cpk2mzh9m0b5k4n759710qv8f"; depends=[dr MASS]; };
   nonrandom = derive { name="nonrandom"; version="1.42"; sha256="0icm23hw593322z41wmjkwxqknh2pa9kpzbrch7xw1mhp93sd5ll"; depends=[lme4]; };
-  nontarget = derive { name="nontarget"; version="1.3"; sha256="0kg3b1xs7sfgkjj5wf536r4k9b9hgi2hlkymsw0spskvjg2sd3q0"; depends=[enviPat nontargetData mgcv]; };
+  nontarget = derive { name="nontarget"; version="1.5"; sha256="1b9hvsm0pzaxlrl1w9n6dw7vf9474nxq9nsan00a07kd40x3rssi"; depends=[enviPat nontargetData mgcv]; };
   nontargetData = derive { name="nontargetData"; version="1.1"; sha256="07cdbpmn64sg4jfhljdcx503d55azyz58x7nkji044z3jmdryzqw"; depends=[]; };
-  nopp = derive { name="nopp"; version="1.0.3"; sha256="128c441l5fgapxwl143yhciz8jcak8fisypp6wq6csdxpbs8w21f"; depends=[mlogit MASS]; };
-  nor1mix = derive { name="nor1mix"; version="1.1-4"; sha256="11ym6av7zykynkqvhkbnl7rwxgzrjhgjnbq7whxhkb6qbf6khfsx"; depends=[]; };
+  nopp = derive { name="nopp"; version="1.0.4"; sha256="00wn0pnqpy9xll0aa8ah45ldgk1ziw464x8zkc8iq4l2a22lgn4v"; depends=[mlogit]; };
+  nor1mix = derive { name="nor1mix"; version="1.2-0"; sha256="1s92bwpwq9p0d06adclm43yqq0k7ifv8lknn1scxg8nj4g03qjhs"; depends=[]; };
   nordklimdata1 = derive { name="nordklimdata1"; version="1.0"; sha256="0l50g09c102r8fz8ks42dfywg2vh2ad8lhqi7n3gc8nhad8rapqr"; depends=[]; };
   norm = derive { name="norm"; version="1.0-9.5"; sha256="01j1h412yfjx5r4dd0w8rhlf55997spgb6zd6pawy19rgw0byp1h"; depends=[]; };
   NormalGamma = derive { name="NormalGamma"; version="1.1"; sha256="0r3hhfscif0sx9v8f450yf119gpvf3ilpb8n3ziy4v4qf2jlcfnk"; depends=[optimx histogram]; };
   NormalLaplace = derive { name="NormalLaplace"; version="0.2-0"; sha256="1yrqfqhxkavczascwpq7z77jwpa1s2dn2cfi15vxfjyayhdxq4aa"; depends=[DistributionUtils GeneralizedHyperbolic]; };
   normalp = derive { name="normalp"; version="0.6.9"; sha256="1a2m7agcnqmf69mgbkjmmp7mvpx9r4gk13x98yfkg1dyh3b48rri"; depends=[]; };
-  NormPsy = derive { name="NormPsy"; version="1.0.1"; sha256="050cb4i3pb1jbi1scxnnnf1rwxwvr472m284gcjlzrcr5xzbx0gr"; depends=[lcmm]; };
   NORMT3 = derive { name="NORMT3"; version="1.0-3"; sha256="041s0qwmksy3c7j45n4hhqhq3rv2hncm2fi5srjpwf9fcj5wxypg"; depends=[]; };
   normtest = derive { name="normtest"; version="1.1"; sha256="073r2mwfs6c4vqh8921nlyygl0f20nhv997s0iwf00d3jckkc4pp"; depends=[]; };
   normwhn_test = derive { name="normwhn.test"; version="1.0"; sha256="1kr45bfydk40hgdg24i2f28cdaw65hg9gmsgv4lsvvr2m3r74vi6"; depends=[]; };
···
   np = derive { name="np"; version="0.60-2"; sha256="0zs1d4mmgns7s26qcplf9mlz9rkp6f9mv7abb0b9b2an23y6gmi5"; depends=[boot cubature]; };
   nparcomp = derive { name="nparcomp"; version="2.0"; sha256="154689lk1sd1smc3fyslrgz4rzg166n2d8nz7bhbjcrq2fhj8pj0"; depends=[multcomp mvtnorm]; };
   nparLD = derive { name="nparLD"; version="2.1"; sha256="1asq00lv1rz3rkz1gqpi7f83p5vhzfib3m7ka1ywpf2wfbfng27n"; depends=[MASS]; };
+  NPBayesImpute = derive { name="NPBayesImpute"; version="0.3"; sha256="1iixigxdcxx17ixy9x339pvqgamky2a6fg973jd8a6afvil3nfwb"; depends=[Rcpp]; };
   npbr = derive { name="npbr"; version="1.0"; sha256="12s25vn4f0373y2ijmpam0an4p64xr3m71xgf20g5przmr77bm0a"; depends=[Rglpk Benchmarking]; };
   NPCD = derive { name="NPCD"; version="1.0-6"; sha256="1lnj55f73rpjy6amg1n5x7b0jsrmharp0fhcjcn0dflcrjwianxj"; depends=[BB R_oo R_methodsS3]; };
-  NPCirc = derive { name="NPCirc"; version="2.0.0"; sha256="03b4lx7rkpjlxy9854dy16qw15x1cjwzyyvxn778n5xsva0c498b"; depends=[circular misc3d movMF plotrix rgl shape]; };
+  NPCirc = derive { name="NPCirc"; version="2.0.1"; sha256="1pyckjvf4vzns9hxnhnk7cm4abllmdj3f142pvjhnilyqwndqgyc"; depends=[circular misc3d movMF plotrix rgl shape]; };
   npcp = derive { name="npcp"; version="0.1-0"; sha256="1kkz7qnvmbbl2yfar8s23cn2jh2cqjwnrgjqw5a0wzli5ky613nl"; depends=[]; };
   npde = derive { name="npde"; version="2.0"; sha256="1cp4k7jvsw9rc6rrck902nqqjaf2c1nxjic7i9r3fd6yca1lgqb9"; depends=[mclust]; };
   NPHMC = derive { name="NPHMC"; version="2.2"; sha256="000x9y00gfkaj5lf00a55b9qx15x05yp3g3nmp8slyzsnfv66p5d"; depends=[survival smcure]; };
   nplplot = derive { name="nplplot"; version="4.5"; sha256="1dpbs0jb34gv0zj528357z1j2pwahjbp04rm7jir6qk0jhyaxxgh"; depends=[]; };
   nplr = derive { name="nplr"; version="0.1-1"; sha256="0br7flriqbig8frq0j4lxiv6i8bwgsj422faln85ga93hnlky0a1"; depends=[]; };
   NPMLEcmprsk = derive { name="NPMLEcmprsk"; version="1.0"; sha256="0yakcjkxqlbpzs8jdaahdl4lv5l2ffq7l7v00sl77sn9gflgprk3"; depends=[]; };
-  npmlreg = derive { name="npmlreg"; version="0.45-5"; sha256="0jkj3wi435bgb1swll56bcwc1vzq00l503miy171232avy8qrpaf"; depends=[statmod]; };
+  npmlreg = derive { name="npmlreg"; version="0.46-1"; sha256="1gddl6diw8ix8vz7n1r4ps9cjx3q00mafpapskjk7pcz69m6hfv1"; depends=[statmod]; };
   NPMPM = derive { name="NPMPM"; version="1.0"; sha256="14rjj48vfj4wv1na5v181jby016afx4ak1fs0f3g1fif4kbgbdx0"; depends=[]; };
   npmv = derive { name="npmv"; version="2.1"; sha256="0ivd3wm1fmmaq8i2h0kdd11z9k1czb61ms8fj0xb5xmfy0g1rphy"; depends=[Formula ggplot2]; };
   NPMVCP = derive { name="NPMVCP"; version="1.1"; sha256="13jpm46abwziq8859jhl6hg1znk3ws1q7g4vlr2jyri3qa6h22dd"; depends=[]; };
···
   NPS = derive { name="NPS"; version="1.0"; sha256="1acg3367rd53dgwzqr8pnfr8z72s3699h2nhrhh2w9zdqipid89g"; depends=[]; };
   NPsimex = derive { name="NPsimex"; version="0.2-1"; sha256="1k9i1f5ckvzdns8f5qnm2zq7qs3wsgzsnfwdz21zmhmi6d0pwchm"; depends=[]; };
   npsm = derive { name="npsm"; version="0.01"; sha256="1bx3l3sh5jvwngq05006mjyy5rs136wlg6wgshqy4d104zqwqjxk"; depends=[Rfit]; };
-  npsp = derive { name="npsp"; version="0.2-4"; sha256="1lzdr958m00dxwzgd46x5fs07sx0gnzbyjrllfa6s7r9klg4i707"; depends=[quadprog]; };
+  npsp = derive { name="npsp"; version="0.3-6"; sha256="1wiv4gp3y1c26xaq8zssias3j3h8mpb6izcmcarghvnfhj32l8jb"; depends=[quadprog]; };
   npst = derive { name="npst"; version="2.0"; sha256="1y5ij3nmh9pj6p97jpx75g26sk508mznr0l67cwj381zfb77hj1n"; depends=[]; };
   NRAIA = derive { name="NRAIA"; version="0.9-8"; sha256="16v8s9mqvr6sbiwwj93n3nyrm996wyw4f9l569mw2ykqpdkbp7hm"; depends=[lattice]; };
   nricens = derive { name="nricens"; version="1.2"; sha256="17h0vckchqlvcsa604cgbcw1akaxl30yx24x1d8201svyz9n0hhb"; depends=[survival]; };
···
   nscancor = derive { name="nscancor"; version="0.6"; sha256="1wkk08h8yz2mzgvmq0vr30iiczpbp0304vjwxqgsa3h240m4awsm"; depends=[]; };
   NScluster = derive { name="NScluster"; version="1.0.2"; sha256="1bvr44qx3bzbgsdpj70dfq9azkrsywkbvwvm3lwwgpn0spk8apld"; depends=[]; };
   nsga2R = derive { name="nsga2R"; version="1.0"; sha256="04jj0a3isfc348vg46il5x9l33cr7xawz5w0mm4pwr6djhd8nfhx"; depends=[mco]; };
+  nsgp = derive { name="nsgp"; version="1.0.5"; sha256="0piajjz3r71dnjw7lwpjhbaygxcrbbxfvhf8p3n2izyr2pw5fml9"; depends=[MASS]; };
   NSM3 = derive { name="NSM3"; version="1.1"; sha256="0xyx06pc9690akdm02597pgcchn29gvc4kzcgyc3ihsjj71xryi2"; depends=[combinat MASS partitions survival agricolae ash binom BSDA coin epitools fANCOVA gtools Hmisc km_ci metafor nortest np quantreg Rfit SemiPar SuppDists waveslim]; };
   nsprcomp = derive { name="nsprcomp"; version="0.5"; sha256="1rrjiwkpiaqlp27s5xfd6jwmmpzgxm5d7874gp33511wa0vrhnnf"; depends=[]; };
-  nsRFA = derive { name="nsRFA"; version="0.7-11"; sha256="1mlm8fygzr8b03rflays78l63ld0nagprc8xbwny5f87vi00wwq4"; depends=[]; };
-  nullabor = derive { name="nullabor"; version="0.2.1"; sha256="1pxxynfjjyqmgqvfb4fcs6jy63cf9bcbi9x1kz4f5b454q2g1raq"; depends=[MASS ggplot2 plyr]; };
+  nsRFA = derive { name="nsRFA"; version="0.7-12"; sha256="182zshwyg0l6shb5wcwibqygxs8qmgma9c4s683za8q3f9l94aqj"; depends=[]; };
+  nullabor = derive { name="nullabor"; version="0.3.0"; sha256="0bpqqn56x04kplgdlchwvi7gvs3hbc2xyza4kr8nxlj7wsh95pk3"; depends=[ggplot2 MASS plyr dplyr moments fpc]; };
   numbers = derive { name="numbers"; version="0.4-5"; sha256="0z69samkj7fvbk0wj2nbnkcw17y1sdha7hghkc7yhgkwx2z1pana"; depends=[gmp]; };
   numDeriv = derive { name="numDeriv"; version="2012.9-1"; sha256="09s00a1wddpq5556mz87vdmx045rhjrx1w8f2a37m8hljghy86k9"; depends=[]; };
-  numOSL = derive { name="numOSL"; version="1.5"; sha256="06lfy4jkk3myzlwivgh9j6ig1l0q9mgaa1zh3vxv2vdkzjd0l56b"; depends=[]; };
+  numOSL = derive { name="numOSL"; version="1.7"; sha256="1hgyjjxpirgf2vmn273s861mnpyq2363kaafnkzgbcg0s08xxj1r"; depends=[]; };
   nutshell = derive { name="nutshell"; version="2.0"; sha256="1v11g5wqyxnj29b7akl0cwa34hcqs79ijbiv735pg3df4ggyrzvm"; depends=[nutshell_bbdb nutshell_audioscrobbler]; };
   nutshell_audioscrobbler = derive { name="nutshell.audioscrobbler"; version="1.0"; sha256="10fvc5d22gnfb0bkgbww48f0vvcaja96g5gfv85kap939j11172j"; depends=[]; };
   nutshell_bbdb = derive { name="nutshell.bbdb"; version="1.0"; sha256="19c4047rjahyh6wa6kcf82pj09smskskvhka9lnpchj13br8rizw"; depends=[]; };
···
   oblique_tree = derive { name="oblique.tree"; version="1.1.1"; sha256="01vyc46gz7qx8fc5bg3zbhjyhnmfgjii120a915vmr38cs51qhqh"; depends=[tree glmnet nnet]; };
   obs_agree = derive { name="obs.agree"; version="1.0"; sha256="191xshnrncjqzwd2rdq334vsx0338q3y3k1nbm04hdaysbnla9jv"; depends=[]; };
   obsSens = derive { name="obsSens"; version="1.3"; sha256="1vfm1mzsycwkqa39vf3fcdv1s6adps9hw1rxlvl8v9kq746hcabw"; depends=[]; };
-  oc = derive { name="oc"; version="0.93"; sha256="1nw594wrlnb0kkhkqfa14wxahh1yshpa2hz25nlnb42mi9pbrzg4"; depends=[pscl]; };
+  oc = derive { name="oc"; version="0.95"; sha256="1zmy34fsqcd4rq0v72r514k6gm3jmf9a5zv4m6kj09hl89xvqsci"; depends=[pscl]; };
   occ = derive { name="occ"; version="1.0"; sha256="1gn8rg6k5lwwb6axfby7hiss5m64j2rh3hsmwwij58j5xda3jlbx"; depends=[]; };
   oce = derive { name="oce"; version="0.9-14"; sha256="03vp83504pwjk6wbx5l4s31qvxfyd3g38snvfvp8b0pvnlv8f2fh"; depends=[mapproj]; };
   ocean = derive { name="ocean"; version="0.2-4"; sha256="1554iixfbw3k6w9xh3hgbiygszqvj5ci431cfmnx48jm27h2alqg"; depends=[ncdf4 proj4]; };
-  OceanView = derive { name="OceanView"; version="1.0"; sha256="1x94zrvz45vval4qiim6755ispj23zp0d6qvzg3xd65y30gprni1"; depends=[plot3D plot3Drgl shape]; };
+  OceanView = derive { name="OceanView"; version="1.0.1"; sha256="12jah913rfwin45rv4zhkd28l2fwg5ajz4ixl39gd8j78mni4xdx"; depends=[plot3D plot3Drgl shape]; };
   ocedata = derive { name="ocedata"; version="0.1.2"; sha256="0kic6m09a66zc5fxh9fkqk7rp3mnpf0p6i1qy2irh3bj9ccmdkvk"; depends=[]; };
   ODB = derive { name="ODB"; version="1.1.1"; sha256="1hha4rkbc2zh3karkqa0vn4v0nmcd7sljcymy1nh28bx1gx2ffgs"; depends=[DBI RJDBC]; };
   odfWeave = derive { name="odfWeave"; version="0.8.4"; sha256="1rp9j3snkkp0fqmkr6h6pxqd4cxkdfajgh4vlhpz56gr2l9j48q5"; depends=[lattice XML]; };
   odfWeave_survey = derive { name="odfWeave.survey"; version="1.0"; sha256="0cz7dxh1x4aflvfrdzhi5j64ma5s19ma8fk9q2m086j11a1dw3jn"; depends=[odfWeave survey]; };
   ODMconverter = derive { name="ODMconverter"; version="2.0"; sha256="1691fmkdjhk7rih8qk3rp6bykplz8hxsl7in8gjrc5ll0fkygm98"; depends=[XML xlsx]; };
   oem = derive { name="oem"; version="1.02.1"; sha256="0z9k0jhpp5dayyin6v8p26rgl8s983hnpsk195c9z458i7nbmrpd"; depends=[Rcpp]; };
-  Ohmage = derive { name="Ohmage"; version="2.11-3"; sha256="16mm58yzh1r8s8x3jhdjwb01a1a8yjiay4v7gcj7j4r7z4mqr75c"; depends=[RCurl RJSONIO]; };
+  Ohmage = derive { name="Ohmage"; version="2.11-4"; sha256="14pga59ikiywyl6xnfd2d8sy323vyn88q9sf101bcwp0s0qczwzg"; depends=[RCurl RJSONIO]; };
   OIdata = derive { name="OIdata"; version="1.0"; sha256="078khxrszwnrww2h0ag153bf59fnyhirxy4m56ssgr2gmfahaymf"; depends=[RCurl maps RCurl maps]; };
   OIsurv = derive { name="OIsurv"; version="0.2"; sha256="148mpjj5navc1vrl72y87krn4lf3awnd32z3g4qqaia404w5w7p7"; depends=[survival KMsurv]; };
-  OjaNP = derive { name="OjaNP"; version="0.9-7"; sha256="1sf23q4qwvx1n8ny9rk4jcrjsb4hifn4ry12p5k29x4baaxmn3xg"; depends=[ICS ICSNP]; };
+  OjaNP = derive { name="OjaNP"; version="0.9-8"; sha256="010l75irgj7nl8yq6crp8d00zjgpv9wg2maw99cj0frhqxvqzbfz"; depends=[ICS ICSNP]; };
   okmesonet = derive { name="okmesonet"; version="0.1.4"; sha256="1fq17v1wx8hxvlk489vp6nlsx8ifs4491099zhikhn1fj7b1m346"; depends=[plyr]; };
   OligoSpecificitySystem = derive { name="OligoSpecificitySystem"; version="1.3"; sha256="0s76fxai1kgq0hcr5m18yz7i14algld97rjrax75cxm1ccylah71"; depends=[tkrplot]; };
   OLScurve = derive { name="OLScurve"; version="0.2.0"; sha256="1zqapfwgwy9rxnbhmlgplkphw1bdia4cyi9q6iwcppw3rjw75f1n"; depends=[lattice]; };
···
   Oncotree = derive { name="Oncotree"; version="0.3.3"; sha256="147rc9ci66lxbb91ys2ig40sgmldi15p604yysrd4ccbxpbk2zwf"; depends=[boot]; };
   OneHandClapping = derive { name="OneHandClapping"; version="1.5"; sha256="1j45qy4nwnmiqmjqnhzs4f6zspckzhr1rx56i9ddis4iahffqd19"; depends=[]; };
   onemap = derive { name="onemap"; version="2.0-4"; sha256="00xmhm5qy0ycw0mnlyl20vfw0wxmpb36f07k0jj92c4zbpwjiygx"; depends=[tkrplot]; };
-  ONETr = derive { name="ONETr"; version="0.1-1"; sha256="0jaxz8104xfdn2ys6lgg16vrbin73b5qfnrr81bgmdcpsk9ggix5"; depends=[XML RCurl]; };
+  ONETr = derive { name="ONETr"; version="1.0"; sha256="0k0bxz2598nvw93ynl250ci4150zyaxp3na6r33n0i3kzvxgrysy"; depends=[XML RCurl]; };
   OneTwoSamples = derive { name="OneTwoSamples"; version="1.0-3"; sha256="0019rc2f4jmbm6sinkvalvjqwi822x78aiin88kg8qbbb5ml8l89"; depends=[]; };
   onion = derive { name="onion"; version="1.2-4"; sha256="0x3n9mwknxjwhpdg8an0ilix5cb8dyy5fqnb6nxx7ww885k0381a"; depends=[]; };
   OOmisc = derive { name="OOmisc"; version="1.2"; sha256="09vaxn5czsgn6wpr27lka40kzd76jzqgqxavf26ms3m9kkdf83g4"; depends=[]; };
-  OpasnetUtils = derive { name="OpasnetUtils"; version="1.0.0"; sha256="04w6jvrjwiyva8lblx7i3ynywhis7d45nzhc1gls9yqxq0p426i1"; depends=[rjson RCurl reshape2 triangle httpRequest digest xtable]; };
+  OpasnetUtils = derive { name="OpasnetUtils"; version="1.1.0"; sha256="1a7j96pg0v8j527m0w48k8lxwb2ynrqq1y7140bi1ciq0466azx3"; depends=[rjson RCurl reshape2 triangle httpRequest digest xtable ggplot2 rgdal sp]; };
   OPDOE = derive { name="OPDOE"; version="1.0-9"; sha256="0pf8rv5wydc8pl4x57g7bk2swjabaxdgijgsigjy5wihfcb48654"; depends=[gmp mvtnorm orthopolynom nlme crossdes polynom]; };
   OPE = derive { name="OPE"; version="0.7"; sha256="0ld3pr94ii1pmfk99qfwgria6ki2iz2hwmn7pj3cjwprv8jkcjji"; depends=[]; };
   opefimor = derive { name="opefimor"; version="1.1"; sha256="0xv57l38wx3w67h312g5xcpi9m7ggd6crqvqjh5gddq0g1g93bjq"; depends=[]; };
   openair = derive { name="openair"; version="1.0"; sha256="04swl74189ccbak0qw55gyw66v07ia0wg8xwiak81233wc0ins42"; depends=[plyr reshape2 mgcv lattice latticeExtra cluster RColorBrewer Rcpp]; };
   OpenCL = derive { name="OpenCL"; version="0.1-3"; sha256="0f7vis0jcp0nh808xbzc73vj7kdcjb0qqzzsh3gvgamzbjfslch8"; depends=[]; };
-  opencpu = derive { name="opencpu"; version="1.4.3"; sha256="0515x95rvrp9hpxmc65hz6r35g8ql2hvlqhj94zapaa55ycw95jb"; depends=[evaluate httpuv knitr jsonlite devtools httr brew pander]; };
+  opencpu = derive { name="opencpu"; version="1.4.4"; sha256="1dvxzahsf6sj6sr6mmp8j56pvds00x76diq1v7219chy8zvss484"; depends=[evaluate httpuv knitr jsonlite devtools httr brew pander]; };
   openintro = derive { name="openintro"; version="1.4"; sha256="1k6pzlsrqikbri795vic9h191nf2j7v7hjybjfkrx6847c1r4iam"; depends=[]; };
   OpenMPController = derive { name="OpenMPController"; version="0.1-2"; sha256="1cpsbjmqql0fsjc1xv323pfkhfr9vrcv5g4j3p1qc5zn4z9pq7r6"; depends=[]; };
   openNLP = derive { name="openNLP"; version="0.2-3"; sha256="1d609hv24sxjppxpkgfvsl7p8vsajj0ivczcjixlnrly09j9ajrh"; depends=[NLP openNLPdata rJava]; };
   openNLPdata = derive { name="openNLPdata"; version="1.5.3-1"; sha256="1a048irgv56yi2lvhpqh8vh4dl7g7zfg934qypjxg8mcdcqi820y"; depends=[rJava]; };
-  OpenRepGrid = derive { name="OpenRepGrid"; version="0.1.8"; sha256="1m71wb9i30vggbxpcv9ywbdi21ki8qivqw70i3rsrk8r1nx3zxq1"; depends=[colorspace plyr abind rgl GPArotation psych XML xlsx pvclust]; };
+  OpenRepGrid = derive { name="OpenRepGrid"; version="0.1.9"; sha256="1s40c2yfd4a4khs0ghlbzii94x8cidg851bivanplg2s51j5jrhk"; depends=[pvclust colorspace plyr stringr abind rgl GPArotation psych XML]; };
+  openssl = derive { name="openssl"; version="0.1"; sha256="1q5bdn07pwiz99f5810m7xv6jlv408kas55pyjlwfc50lg5v04k1"; depends=[]; };
   OpenStreetMap = derive { name="OpenStreetMap"; version="0.3.1"; sha256="009xiqsbgqb3lba6msyzq7ncripmvpymxynkga8pqc8npv8g7fzb"; depends=[rJava raster rgdal rJava]; };
-  openxlsx = derive { name="openxlsx"; version="2.0.15"; sha256="0wnczn3bnmcp3z8qx1al9is903y2iv532kb2sxz45ld3313n2y5z"; depends=[Rcpp]; };
-  operators = derive { name="operators"; version="0.1-6"; sha256="13lqxifbw8h4xn5gjf96bnzq9fzrncrj1g5lib8gvbpcbwn2smsl"; depends=[]; };
+  opentraj = derive { name="opentraj"; version="1.0"; sha256="13nqal96199l8vkgmkvl542ksnappkscb6rbdmdapxyi977qrgxk"; depends=[plyr maptools openair raster rgdal reshape doParallel foreach sp]; };
+  openxlsx = derive { name="openxlsx"; version="2.2.1"; sha256="0wcvyl5gzkh28v2y40ckzp4prp9ygby01pm66rp902xhjqz0vnw1"; depends=[Rcpp]; };
+  operators = derive { name="operators"; version="0.1-7"; sha256="1qik9ihv5blz77bzsnrslf665ndpa8vp3xldqsgvs4gr5bg5algw"; depends=[]; };
   operator_tools = derive { name="operator.tools"; version="1.3.0"; sha256="0y5f0ifj4gaq03gm44vdvslcs7lglk1p8kq47mdc0gc1yfa6l00c"; depends=[]; };
   OPI = derive { name="OPI"; version="1.6"; sha256="0d9863zs54chmdc74g508xpclj7gjk7q36amdnqq0bffp87bj9nq"; depends=[rJava]; };
   opm = derive { name="opm"; version="1.1.0"; sha256="14sj0frjfd4a7j30zyk1fbhkpry45bjcn2k0l9jf7xc8415rbc3v"; depends=[lattice boot hwriter plotrix Ckmeans_1d_dp pkgutils yaml mgcv grofit rjson nlme DBI]; };
   opmdata = derive { name="opmdata"; version="0.7.0"; sha256="043zzp2p4cvda5rshi9s990lm5qyi6ydkmy84xanwaqvysi1cpyy"; depends=[opm]; };
-  oposSOM = derive { name="oposSOM"; version="0.2-3"; sha256="0s6sq9ij8swgpljpk0jbzl0a1qw2y122zgxazy54q16xdf5a5vgy"; depends=[som fastICA pixmap igraph]; };
   ops = derive { name="ops"; version="1.0"; sha256="0cvwyn5sz5lx8sin8w4k8ymslfl4nfaa012a9vcl2hvp4850rk25"; depends=[]; };
   optAUC = derive { name="optAUC"; version="1.0"; sha256="0j1llzqa3n7kqw3i5bb7284z0hi6s5jbjfl9zap0l7xf6hg4x1dn"; depends=[MASS]; };
   optBiomarker = derive { name="optBiomarker"; version="1.0-27"; sha256="1kkj602d4klwyd8kylawgfysg8dlp2g6j7afkppzv5x8mbhs5ji4"; depends=[rpanel rgl MASS randomForest e1071 ipred msm Matrix]; };
···
   OptInterim = derive { name="OptInterim"; version="3.0.1"; sha256="1ks24yv5jjhlvscwjppad27iass59da1mls99hlif0li9mvkbvyk"; depends=[mvtnorm clinfun]; };
   optiRum = derive { name="optiRum"; version="0.33"; sha256="1324wmi6b2y9whacf9883k1f86bs9gvxp46gksiga1dwab53nlhv"; depends=[data_table]; };
   optiscale = derive { name="optiscale"; version="1.1"; sha256="1c263w9df66m7lgvzpdfm2zwx9nj8wcdpgh5gijachr2dzffmrp2"; depends=[lattice]; };
-  optmatch = derive { name="optmatch"; version="0.9-3"; sha256="143rkqajs9vc2idg7vs043njh3jgbl3v5x2jnnbxj6g3qlgzd5cb"; depends=[digest]; };
+  optmatch = derive { name="optmatch"; version="0.9-3"; sha256="16mhrhdpyqrj1g24mwc3fl0qyqq1kna8z6cj239fpbjhqb1mirjb"; depends=[digest]; };
   optparse = derive { name="optparse"; version="1.2.0"; sha256="064grlajnmbcbyhmfgx58mbbmv94sxdkxdqqww0cbi7dg441sli2"; depends=[getopt]; };
   optpart = derive { name="optpart"; version="2.1-1"; sha256="0m2nsrynqbw9sj7cp7c37grx9g20dld2f26g0xzbj16wz7whgp02"; depends=[cluster labdsv MASS plotrix]; };
   optR = derive { name="optR"; version="1.1.1"; sha256="1lr5n0g21jayb27b2j8zh16f1k28avzg7k2mwyc7rjhhxv8k9w1j"; depends=[]; };
+  optrees = derive { name="optrees"; version="1.0"; sha256="1zqpjii8dsfs98n58qpif81ckvyxkr0661svhlbgzi19xb2vszqs"; depends=[igraph]; };
   ora = derive { name="ora"; version="2.0-1"; sha256="0albxqma220rnrpfdq3z9cawr83q1a0zzczbbcy4nijjm4mswphy"; depends=[DBI ROracle]; };
   orca = derive { name="orca"; version="1.0"; sha256="0cqz1zmlzwdprhbxs4arjv2gx868dx47xg8jmjvzk7g2xc9prj62"; depends=[]; };
   ORCI = derive { name="ORCI"; version="1.1"; sha256="0xy5lvz2scz06fphjyhqbdhp4bizmv87a8xykp9dbgx8b4ssnqgz"; depends=[BiasedUrn BlakerCI PropCIs]; };
···
   orddom = derive { name="orddom"; version="3.1"; sha256="165axs15fvwhrp89xd87l81q3h2qjll1vrwcsap645cwvb85nwsh"; depends=[psych]; };
   ORDER2PARENT = derive { name="ORDER2PARENT"; version="1.0"; sha256="04c80vk6z227w6qsnfls89ig4vqyiiymdarhq1pxa0gpr8j2ssx5"; depends=[Matrix]; };
   orderbook = derive { name="orderbook"; version="1.03"; sha256="0dlvjrzdhhh8js4g1lvxs46q7fdxfxavxnb4nj6xlwca75i51675"; depends=[lattice hash]; };
-  OrdFacReg = derive { name="OrdFacReg"; version="1.0.4"; sha256="00zw5zqbn2v5r4mqgs4m7gz278bnb53jf5x6c50yv47643m0nxfy"; depends=[eha MASS]; };
+  OrdFacReg = derive { name="OrdFacReg"; version="1.0.5"; sha256="1if6ghagj2196pc73ankfrcms0snlpibgfca1c6lhj96m1waahg2"; depends=[survival eha MASS]; };
   ordinal = derive { name="ordinal"; version="2013.9-30"; sha256="07a226ccd05a3w0i5j6f3mwbmnc3xpl7myq33zl6r4gpvcc8d7c3"; depends=[ucminf MASS Matrix]; };
+  ordinalgmifs = derive { name="ordinalgmifs"; version="1.0.1"; sha256="1xg047xxlgil1a7bylck4r8g271sl1mp45d5fsjckh3kyg1gkazi"; depends=[]; };
   OrdinalLogisticBiplot = derive { name="OrdinalLogisticBiplot"; version="0.3"; sha256="0z03dpargdkay99gci5kpxr2i8cgiw3gfras65f83bjr2pkmsdla"; depends=[mirt MASS NominalLogisticBiplot]; };
+  OrdLogReg = derive { name="OrdLogReg"; version="1.1"; sha256="18s75pmz1g3yac2rfl41kj8sfflq298qkijnvqlybgxpq98ickxx"; depends=[LogicReg]; };
   OrdMonReg = derive { name="OrdMonReg"; version="1.0.3"; sha256="1xca8pvvq79j484l2rmn4nva8ncx8z51g5diljikck231y8qjqaz"; depends=[]; };
   OrdNor = derive { name="OrdNor"; version="1.0"; sha256="1n6c0d4r1w3n016lzk2i5yyvawk9pgmsbzymbbyq7gx8a80iv32h"; depends=[mvtnorm corpcor Matrix GenOrd]; };
   ordPens = derive { name="ordPens"; version="0.2-1"; sha256="1kcxjfr2ncnqg293ph509hpgzzn5s4ih2kd8agl335zlxcksz3fp"; depends=[grplasso mgcv RLRsim]; };
+  ore = derive { name="ore"; version="1.0.1"; sha256="1y26bxjwn0q4wnkqz5nm7v1lsi9bm4az4fqy2c7byz2495jqcrpl"; depends=[]; };
   OrgMassSpecR = derive { name="OrgMassSpecR"; version="0.4-4"; sha256="046lr0piiy5w5lxjvyw7iqqclkghmc6zqymfypkw374gk73yrm76"; depends=[]; };
   ORIClust = derive { name="ORIClust"; version="1.0-1"; sha256="1biddddyls2zsg71w4innxl0ckfb80q2j9pmd56wvbc0qnbm0w3q"; depends=[]; };
   orientlib = derive { name="orientlib"; version="0.10.3"; sha256="1qi46hkz73b8722zc3w6wvsq1ydlk37yxn9rd1dqygqbs1svkmvv"; depends=[]; };
···
   ORMDR = derive { name="ORMDR"; version="1.3-2"; sha256="0y7b2aja3zvsd6lm7jal9pabcfxv16r2wh0kyzjkdfanvvgk3wmm"; depends=[]; };
   oro_dicom = derive { name="oro.dicom"; version="0.4.1"; sha256="0mxjqk7b0k4srkk5yqm21b2x67c5hyd7nwf3b1qlb9rvnfjhqyhk"; depends=[oro_nifti]; };
   oro_nifti = derive { name="oro.nifti"; version="0.4.0"; sha256="1pragzjdldzgiaj4rbx37ki0930wfxj3kvan43vijd11a8ij1g5l"; depends=[bitops]; };
-  oro_pet = derive { name="oro.pet"; version="0.2.1"; sha256="1ysi7jxx1jalx78vqpbq1rd8q85nrz23zrz3vbj5ar3l265kwd5q"; depends=[oro_nifti]; };
+  oro_pet = derive { name="oro.pet"; version="0.2.3"; sha256="06agl6rvd01h6mnilj0vl52dxw6b7b41vl6vmbvaq5qy1wmiaiz7"; depends=[oro_dicom oro_nifti]; };
   orQA = derive { name="orQA"; version="0.2.1"; sha256="0vivjrpcbql42y078gi91kfpfdpv73j23jkiv8fpazzwzdi8ydqq"; depends=[Rcpp gtools nlme]; };
   orsk = derive { name="orsk"; version="1.0-1"; sha256="155wc9sfla3717b6xmhmsmvsnh2qbzzkffhibmj4xc0pd9lwwz2v"; depends=[BB BHH2]; };
   orthogonalsplinebasis = derive { name="orthogonalsplinebasis"; version="0.1.5"; sha256="060g2z8zx5gkk8v31cs0c6v5jzkd7hc9l2syx6hmvj6przr2cxi4"; depends=[]; };
···
   OutlierDM = derive { name="OutlierDM"; version="1.0-0"; sha256="1yphr47nswcaqa5pfamc3ksqcxwhxl388sdml2aqjjfd9w29lf2g"; depends=[quantreg MatrixModels outliers pcaPP]; };
   outliers = derive { name="outliers"; version="0.14"; sha256="0vcqfqmmv4yblyp3s6bd25r49pxb7hjzipiic5a82924nqfqzkmn"; depends=[]; };
   OUwie = derive { name="OUwie"; version="1.43"; sha256="1ixyws6q9p8kms3smzj8rkmsry2y4s9al4vhxpqfmbgypigq7n9k"; depends=[ape nloptr numDeriv corpcor lattice phytools phangorn]; };
-  overlap = derive { name="overlap"; version="0.2.3"; sha256="0d41fhdbm009j53hq4cm2dz04wlh955c4q80dw1d1wcyjz627n49"; depends=[]; };
+  overlap = derive { name="overlap"; version="0.2.4"; sha256="1pp3fggkbhif52i5lpihy7syhq2qp56mjvsxgbgwlcfbzy27ph1c"; depends=[]; };
   oz = derive { name="oz"; version="1.0-20"; sha256="1d420606ldyw2rhl8dh5hpscvjx6vanbq0hrg81m7b6v0q5rkfri"; depends=[]; };
+  P2C2M = derive { name="P2C2M"; version="0.5"; sha256="1ii1jnzkcnm7ks3l3ka4gka7fh7r5x677dvndqcayg08fj5xw7wk"; depends=[ape apTreeshape ggplot2 rPython stringr]; };
   p2distance = derive { name="p2distance"; version="1.0.1"; sha256="1ims8i5z5k97kjpdysgx8g7lgvnvf7amahcrssw7bk38bvbxawni"; depends=[]; };
   p3state_msm = derive { name="p3state.msm"; version="1.3"; sha256="0gbrka62ylxx64r3abpk60y92k2lk5smlf8na68qazph8llsl2rv"; depends=[survival]; };
   pa = derive { name="pa"; version="1.2-1"; sha256="1pfgzxirkb0p8f6smjlrbp1qpsh0vsvqf306cvldaj9zx8cw0q9f"; depends=[ggplot2]; };
···
   packClassic = derive { name="packClassic"; version="0.5.2"; sha256="04a1sg9vx3r0sq54q9kj0kpahp6my246jy3bivgy09g5fjk0dmkj"; depends=[]; };
   packdep = derive { name="packdep"; version="0.3.1"; sha256="1827h9xcvgdad9nwz9k3hi79jc33yr7dnxy4xn2frp3fdh4q81ll"; depends=[igraph]; };
   packHV = derive { name="packHV"; version="1.8"; sha256="0dr2picjd7mm633vw29524f3n4jpyillpzi9cg7yc2cymxnrgvyg"; depends=[survival WriteXLS]; };
+  packrat = derive { name="packrat"; version="0.4.1-1"; sha256="17c91ivyrxzq1mj3yw3kxlrl0rvq2072q0ivckfxhlgl1qlpk4fx"; depends=[]; };
   packS4 = derive { name="packS4"; version="0.9.1"; sha256="01kkw5g3xcn9hhfglmfvwsryid0w4vw9azh6as8l8d5i1xjyp9k7"; depends=[]; };
-  pacose = derive { name="pacose"; version="1.4"; sha256="10dpqafbq5iwfhx9xf6l902y23p2w4mvaclkhrcz2d89njakcnaz"; depends=[ggm igraph ppls MASS corpcor glmnet mvtnorm lcd]; };
   paf = derive { name="paf"; version="1.0"; sha256="0wrqn67jfrjjxwcrkka6dljgi3mdk00vfjkzzcv2v7c97gx1zvwn"; depends=[survival]; };
   PAGI = derive { name="PAGI"; version="1.0"; sha256="01j1dz5ihqslpwp9yidmhw86l112l7rfkswmf03vss872mpvyp3f"; depends=[igraph]; };
   PAGWAS = derive { name="PAGWAS"; version="1.0"; sha256="1zwq4b0bgsskzvlapffh30ys9y4wlcfwpjqw8m2i9zabib5knx9i"; depends=[lars doMC mnormt]; };
···
   pairwise = derive { name="pairwise"; version="0.2.5"; sha256="0r08v95f6f2safi6c0x84v5gib5qnkv46dmi97rdb9l2xzly249b"; depends=[]; };
   pairwiseCI = derive { name="pairwiseCI"; version="0.1-22"; sha256="1lgir9gcikx8c9pd2wdsqnik9rwr4qkymcf4ndp8s491vj6cm6sa"; depends=[MCPAN coin boot mratios binMto MASS]; };
   palaeoSig = derive { name="palaeoSig"; version="1.1-2"; sha256="0f5y69zzb32zi3kdy8jpcvz3i38nmmi0d9ajs44jrq4rkhhhwq3v"; depends=[rioja vegan TeachingDemos gstat fields mapproj]; };
-  paleobioDB = derive { name="paleobioDB"; version="0.1"; sha256="0ax5mzfvrxwg82brc4589bkd7cl8iy254iq6sjs9cr3d7x0zyahz"; depends=[maps raster rjson gtools RCurl plyr scales]; };
+  paleobioDB = derive { name="paleobioDB"; version="0.2"; sha256="1rlk9h41yzl03xfy30fjkczlvg5r83qrndch5l995mgwyhss3bqv"; depends=[raster maps rjson gtools RCurl plyr scales]; };
   paleofire = derive { name="paleofire"; version="1.1.3"; sha256="0k46pq16chrp5gcp5gd5vph9zj17ci4yb1lgyrwrm8qnvydi1nkp"; depends=[GCD rworldmap locfit gtools caTools pscl Imap RCurl devtools raster sp rgdal ggplot2 lattice RColorBrewer agricolae plyr]; };
   paleoMAS = derive { name="paleoMAS"; version="2.0-1"; sha256="1hhb5wbj4m3ch8wnvd1zkl5bk6wa9nl6jl1dhm4z6yqkh29yn9z6"; depends=[MASS vegan lattice]; };
-  paleotree = derive { name="paleotree"; version="2.0"; sha256="06bi9wikgb9szlhf747ijnqikv87svlf579w4hx9yplc8m44br1s"; depends=[ape phangorn]; };
+  paleotree = derive { name="paleotree"; version="2.2"; sha256="01gjmi4ji8356cl2ifyq8d18avmac60013xnd2rl0akycprv5l9z"; depends=[ape phangorn]; };
   paleoTS = derive { name="paleoTS"; version="0.4-4"; sha256="19acfq5z42blk6ya7sj3sprddlgvhrzb9zqpvpy4q8siqkxxrjah"; depends=[mvtnorm]; };
   palinsol = derive { name="palinsol"; version="0.92"; sha256="1jxy3qx8w1r8jwgdavf37gqjjqpizdqk218xcc7b77xi8w52vxpg"; depends=[gsl]; };
-  PamGeneMixed = derive { name="PamGeneMixed"; version="1.03"; sha256="0pg19nnn8d23mqw7aw1wqijcgfavvixr42p51iz0m931ig3sg4ki"; depends=[mgcv gplots nlme]; };
   pamm = derive { name="pamm"; version="0.7"; sha256="02py4zcymmwnlpsvha5cgc4ik8fp0gbsg86s5q7z5fl3ma3g669j"; depends=[lme4 mvtnorm gmodels]; };
-  pamr = derive { name="pamr"; version="1.54.1"; sha256="05jm67y329z4qcsacd9mc7hcq7g6icf2mi53nranmkgcnhwvr78k"; depends=[cluster survival]; };
+  pamr = derive { name="pamr"; version="1.55"; sha256="1hy3khb0gikdr3vpjz0s245m5zang1vq8k93g7n9fq3sjfa034gd"; depends=[cluster survival]; };
   pan = derive { name="pan"; version="0.9"; sha256="1payx5bzs0hp3f176ia56y4a9pym8p4h7ap5wag2symlvprzppah"; depends=[]; };
-  pander = derive { name="pander"; version="0.3.8"; sha256="0ka9cjwmvr79rbymww9m36l7z0rdf8xkxvc6r2y5lm6mpzx1s13i"; depends=[digest]; };
+  pander = derive { name="pander"; version="0.5.1"; sha256="0m95vnrzw9v4cq52kn3a605gbk1qd24ivh7aywhk1lh0imlk7i85"; depends=[digest Rcpp]; };
   panelAR = derive { name="panelAR"; version="0.1"; sha256="1ka2rbl9gs65xh2y2m4aqwh5qj4szibjy101hqfmza9wmdh25gpq"; depends=[car]; };
   Paneldata = derive { name="Paneldata"; version="1.0"; sha256="00hk340x5d4mnpl3k0hy1nypgj55as2j7y2pgzfk3fpn3zls5zib"; depends=[]; };
+  PANICr = derive { name="PANICr"; version="0.0.0.2"; sha256="17r550wyp4nsjk3n1c786z0xfn0h1gpnas22dcq5bl0jn16mh40c"; depends=[MCMCpack]; };
   papeR = derive { name="papeR"; version="0.4-0"; sha256="0w1pqmgaa15x4vxr4msw5fwmd42kgrhniy2h7wvpyyvgzxfvb0s3"; depends=[car nlme lme4 survival gmodels]; };
   ParallelForest = derive { name="ParallelForest"; version="1.1.0"; sha256="1xa9lfgrvzv7bvv1aaabcfk4372p8x5gxgj463h5ggf9x177lj5j"; depends=[]; };
   parallelize_dynamic = derive { name="parallelize.dynamic"; version="0.9-1"; sha256="03zypcvk1iwkgy6dmd5bxg3h2bqvjikxrbzw676804zi6y49mhln"; depends=[]; };
   parallelMap = derive { name="parallelMap"; version="1.1"; sha256="1h3im52ia29m1qv4dcvw1zxciv3v9b9fq2difg6cs9apdn0fvlz8"; depends=[BBmisc checkmate fail]; };
   parallelMCMCcombine = derive { name="parallelMCMCcombine"; version="1.0"; sha256="05krkd643awqhfrylq9lxr2cmgvnm1msn2x8p1l1483n2gzyklz7"; depends=[mvtnorm]; };
-  ParamHelpers = derive { name="ParamHelpers"; version="1.3"; sha256="15dbqsr5sp16wq0nqi07gkkqc1drb87s5yw54s3dv1mg6bn4az7k"; depends=[BBmisc checkmate]; };
+  ParamHelpers = derive { name="ParamHelpers"; version="1.4"; sha256="1jbzn3r8i8avwg51nxp6940c4wvqfp8ficqzw2q1xyrm5rkkqgg5"; depends=[BBmisc checkmate]; };
   paramlink = derive { name="paramlink"; version="0.9-6"; sha256="0pazllkjbqzvl9vmpvr67lkcsd960mipcd1p1nf00y8hknrwh7qp"; depends=[kinship2 maxLik]; };
   paran = derive { name="paran"; version="1.5.1"; sha256="0nvgk01z2vypk5bawkd6pp0pnbgb54ljy0p8sc47c8ibk242ljqk"; depends=[MASS]; };
   parboost = derive { name="parboost"; version="0.1.3"; sha256="1ziqbbcxvhc3v0vjpf9y6jhk3rqbgn9cilwcfxlxjbw73jhvvclg"; depends=[mboost party iterators plyr caret glmnet doParallel]; };
-  parcor = derive { name="parcor"; version="0.2-4"; sha256="0zz1i3cm1gy2bx77hpydk0wlsr60nanjx57g0zr5wm01imkk99wa"; depends=[MASS glmnet ppls Epi GeneNet]; };
+  parcor = derive { name="parcor"; version="0.2-6"; sha256="10bhw50g8c4ln5gapa7wghhb050a3jmd1sw1d1k8yljibwcbbx36"; depends=[MASS glmnet ppls Epi GeneNet]; };
   ParDNAcopy = derive { name="ParDNAcopy"; version="1.3"; sha256="1y0fl5gj3d3xj6krfyg48fs9vz3s4jb61js0b7yfzgv6a3289g5a"; depends=[]; };
   ParentOffspring = derive { name="ParentOffspring"; version="1.0"; sha256="117g8h0k65f2cjffigl8n4x37y41rr2kz33qn2awyi876nd3mh93"; depends=[]; };
-  ParetoPosStable = derive { name="ParetoPosStable"; version="1.0.2"; sha256="1a42s9lhzzimvlxdpbd8dfqc5a936f1s31d040fwgs8i3qfpfjwp"; depends=[ADGofTest lmom]; };
+  ParetoPosStable = derive { name="ParetoPosStable"; version="1.0.3"; sha256="0f3f4wn33vw1y3cjcvlk44g8z6hjkv4ws535pkcz3lgb95fl4q0n"; depends=[ADGofTest lmom]; };
   parfm = derive { name="parfm"; version="2.5.6"; sha256="1zas6isgirha379f246zg84ddv0jl2n4795brshd98hkayl4c1fi"; depends=[survival eha msm]; };
   parfossil = derive { name="parfossil"; version="0.2.0"; sha256="12gsc5n4ycvhzxvq5j0r3jnnrzw1q412dbvmakipyw2yx2l2s7jn"; depends=[fossil foreach]; };
   parma = derive { name="parma"; version="1.5-1"; sha256="0qrq3bx0amri9b3s6bym4znnk140jjd2abnvqyihaj4bf2glbl0g"; depends=[nloptr slam Rglpk quadprog FRAPO corpcor]; };
   parmigene = derive { name="parmigene"; version="1.0.2"; sha256="1fsm6pkr17jcbzkj1hbn91jf890fviqk1lq6ls8pihsdgah1zb4d"; depends=[]; };
-  parspatstat = derive { name="parspatstat"; version="0.1-4"; sha256="14rcw2lzqwdjg4avjw3d6ivgdglkkagdh6pnd7bprkkdv8i5a9h2"; depends=[Rmpi spatstat]; };
+  parsedate = derive { name="parsedate"; version="1.1.1"; sha256="0mr97rw4fzg2v9dh5d4x0b76d5s56gi6zilq69yjhbx78w46apzc"; depends=[]; };
   partDSA = derive { name="partDSA"; version="0.9.5"; sha256="0zblwjzwhalcnbmgwnqxpq7ixf4xhgx9lpf0lk3krry3di537s0q"; depends=[survival]; };
   partialOR = derive { name="partialOR"; version="0.9"; sha256="02vbvln8lswysaafpxq5rxb6crp7yhlc13i42kybv8fr10jaagjj"; depends=[nnet]; };
   partitionMap = derive { name="partitionMap"; version="0.5"; sha256="0pi066xaaq0iqr0d7cncdzjd7bacmgrivc4qvhqx0y7q1vifrdjm"; depends=[randomForest]; };
   partitionMetric = derive { name="partitionMetric"; version="1.1"; sha256="1wry9d3s814yp79ayab7rzf8z5l2mwpgnrc5j7d2sac24vp4pd48"; depends=[]; };
   partitions = derive { name="partitions"; version="1.9-15"; sha256="0jgpknm4zah50w9i3fbq2f1whm4hywm2j72vxc3ignx1snx2z0gs"; depends=[gmp polynom]; };
   partsm = derive { name="partsm"; version="1.1-2"; sha256="0cv3lgkdkn97bc85iwlv9w5pmqwwwsgb717zxnbgb5mzf4xn3f3g"; depends=[]; };
-  party = derive { name="party"; version="1.0-15"; sha256="159k6pq5in9608m6y007vhlvlhd98z1m75i727c7k1vjj0rxsdf1"; depends=[zoo sandwich strucchange modeltools survival coin]; };
-  partykit = derive { name="partykit"; version="0.8-0"; sha256="083lwaz38d40qdhlhf33vplykx1m3ham0q8r7pmwivj09nbfkmya"; depends=[survival]; };
+  party = derive { name="party"; version="1.0-17"; sha256="11r5r21wc9rxj0l6nz2b0ic89lrhfy7vjs24rs4848h63cz21h4a"; depends=[zoo sandwich strucchange modeltools survival coin]; };
+  partykit = derive { name="partykit"; version="0.8-2"; sha256="1yygbf3kj60r1h6afl82if73mzn2pampyiicfhav6l7za93z7qzw"; depends=[survival]; };
   parviol = derive { name="parviol"; version="1.1"; sha256="1sfgic86ssd5wjf9ydss9kjd3m4jmm2d1v896sjsv8bydwymbpx3"; depends=[vioplot]; };
   PAS = derive { name="PAS"; version="1.2"; sha256="0q5g9j8xb9fl7r8f1w5gk5h83ll5w1r6m2gq9ilw8w8s96pm4xd8"; depends=[glmnet]; };
   pass = derive { name="pass"; version="1.0"; sha256="00dzwg2lnzmrrmzq3fyrs4axswgnsn7f62l2f2a8d8gyf8qzz3nf"; depends=[MASS lars ncvreg]; };
···
   pathdiagram = derive { name="pathdiagram"; version="0.1.9"; sha256="1j2h9mmwfi95nwhk9214kcfpb1qrmw249mjaza7i9gijmlicraxz"; depends=[shape]; };
   pathmox = derive { name="pathmox"; version="0.2.0"; sha256="0hcllnpjjays35yngz309f1gcx9qg5z9h302kg9mhxs90470x4w0"; depends=[plspm tester]; };
   PatternClass = derive { name="PatternClass"; version="1.5"; sha256="1paw39xm2rqjnc7pnbya7gyl160kzl56nys9g0y1sa6cqycy3y5x"; depends=[SDMTools]; };
+  pauwels2014 = derive { name="pauwels2014"; version="1.0"; sha256="1b7whn13lgydc69kg1fhnwkxirw0nqq75cfvii0yg0j4p8r1lw42"; depends=[deSolve ggplot2]; };
   pavo = derive { name="pavo"; version="0.5-1"; sha256="189kshc5dm02qv0rm1dlcxrhvga4yhlkn3yyj3rjhmrags4rmwcb"; depends=[rgl rcdd mapproj geometry]; };
   pawacc = derive { name="pawacc"; version="1.2"; sha256="1a9dzym02rfymjqw1rnp0hri50ysdnax171x5whi5j7fmvmc9rk5"; depends=[SparseM]; };
   PAWL = derive { name="PAWL"; version="0.5"; sha256="1sx4g4qycba2j1fm0bvhz3hk6ghhdc37rz5zi1njqxrpmbnkqg04"; depends=[mvtnorm foreach reshape ggplot2]; };
···
   pbdBASE = derive { name="pbdBASE"; version="0.2-3"; sha256="1zfz45fnjmp8yz4nlac9q1d49gpczkl2b0rz2s33jbv5i32z3yvs"; depends=[rlecuyer pbdMPI pbdSLAP]; };
   pbdDEMO = derive { name="pbdDEMO"; version="0.2-0"; sha256="0vilri4d25mb339zsgh1zypyqxv1vzfdc8b8ivqi5yz1nrzm05gz"; depends=[rlecuyer pbdMPI pbdSLAP pbdBASE pbdDMAT]; };
   pbdDMAT = derive { name="pbdDMAT"; version="0.2-3"; sha256="18x607r0gx1nnw9p305ci5sfcxbi5zdr2b6yf9y6vqjsckicnw62"; depends=[rlecuyer pbdMPI pbdSLAP pbdBASE]; };
-  pbdMPI = derive { name="pbdMPI"; version="0.2-4"; sha256="035b1wg7an1sjfbk6giv4n8znhxg8l0rnqf14c982d9fbcfbxf47"; depends=[rlecuyer]; };
+  pbdMPI = derive { name="pbdMPI"; version="0.2-5"; sha256="0g21zyl8dck5mxjsg4iif62ngrigj58hr8mzdvr47r1b081abzb4"; depends=[rlecuyer]; };
   pbdNCDF4 = derive { name="pbdNCDF4"; version="0.1-4"; sha256="0fd29mnbns30ck09kkh53dgj24ddrqzks4xrrk2hh1wiy7ap1h95"; depends=[]; };
   pbdPROF = derive { name="pbdPROF"; version="0.2-3"; sha256="0vk29vgsv7fhw240sagz0szg0wb649sqc05j1aj027zvz931vfl8"; depends=[ggplot2 gridExtra reshape2]; };
   pbdSLAP = derive { name="pbdSLAP"; version="0.1-9"; sha256="118fy8316p3ahshq0wcwqj20v019dgbgx9wlz7vq35zg5i2fwccw"; depends=[rlecuyer pbdMPI]; };
   PBImisc = derive { name="PBImisc"; version="0.999"; sha256="0igwl78wj8w6jzmk5m8y9rf4j72qrcjyhb83kz44is72ddzsyss6"; depends=[MASS lme4 Matrix]; };
   pbivnorm = derive { name="pbivnorm"; version="0.5-1"; sha256="18ry0qz0ryazplv5iwdvbfngn0zv7frqp16nc2x70s0wf3izxkwr"; depends=[]; };
-  pbkrtest = derive { name="pbkrtest"; version="0.4-0"; sha256="1mpcqciqgljjw60yccpb368a0h1casxijqjdwp3s1wi03ixp8iqz"; depends=[MASS lme4 Matrix]; };
+  pbkrtest = derive { name="pbkrtest"; version="0.4-1"; sha256="1dwjlpl1441cy6280dk40mh4w4lza0c5kdxcc37hj19p0ck03r95"; depends=[MASS lme4 Matrix]; };
   pbo = derive { name="pbo"; version="1.3.4"; sha256="0v522z36q48k4mx5gym564kgvhmf08fsadp8qs6amzbgkdx40yc4"; depends=[lattice]; };
+  pBrackets = derive { name="pBrackets"; version="1.0"; sha256="0cwv609hzp8anfv3cgfbspz8w0g1ljfz05wm4xfhwy15v32fckrj"; depends=[]; };
   pbs = derive { name="pbs"; version="1.1"; sha256="0cpgs6k5h8y2cia01zs1p4ri8r7ljg2z4x8xcbx73s680dvnxa2w"; depends=[]; };
   PBSadmb = derive { name="PBSadmb"; version="0.68.104"; sha256="01akimdsp0bkvz3a5d75yyy3ph0mff85n8qsnr59fla5b5cm4qlj"; depends=[PBSmodelling]; };
   PBSddesolve = derive { name="PBSddesolve"; version="1.11.29"; sha256="13vprr66hh5d19xambpyw7k7fvqxb8mj5s9ba19ls7xgypw22cmm"; depends=[]; };
···
   pcalg = derive { name="pcalg"; version="2.0-3"; sha256="1vfrqm8hjdprsdqpik6a4zhv4yxyqyqa3dr2226qkm5ijblrcmwx"; depends=[abind igraph ggm corpcor robustbase vcd Rcpp]; };
   PCAmixdata = derive { name="PCAmixdata"; version="2.1"; sha256="12g6pkp9yffp1arqdvnx721cn34h0a7m3bm2ayd9fsrvbaqb7ci8"; depends=[]; };
   pcaPA = derive { name="pcaPA"; version="1.2"; sha256="1acfhv6225r0d8m45z7dlx78lmypdlh1cg4irvf8b3av0qv12g5x"; depends=[polycor ltm ggplot2 mc2d]; };
-  pcaPP = derive { name="pcaPP"; version="1.9-49"; sha256="0yk97r0rwkppnzp0kc1j3hcp4n2dr8765mbmvlaikjgwhlhbby4q"; depends=[mvtnorm]; };
+  pcaPP = derive { name="pcaPP"; version="1.9-60"; sha256="10mwgykpp05d7qsbli0pr99i6arhq5aladsbp1gnb67lasbx4fs5"; depends=[mvtnorm]; };
   PCDSpline = derive { name="PCDSpline"; version="1.0"; sha256="15kmvcwvwlsr1107n7mfajvf9b1kcslnhsdx0drjjhsvq193qrqa"; depends=[nleqslv matrixcalc]; };
-  pcenum = derive { name="pcenum"; version="1.0.1"; sha256="0jcwggxcnlbx75lwwpaldv28sgmhxa46rny94sji37hq3zil8yhw"; depends=[]; };
   pcg = derive { name="pcg"; version="1.1"; sha256="194j72hcp7ywq1q3dd493pwkn1fmdg647gmhxcd1jm6xgijhvv87"; depends=[]; };
   PCGSE = derive { name="PCGSE"; version="0.2"; sha256="19bpnn1b8ihmf52zh9g9pc38130np1ki8l7wf0j5myw2cnw6fna8"; depends=[RMTstat MASS]; };
   PCICt = derive { name="PCICt"; version="0.5-4"; sha256="1g17hxs00dlnb6p0av6l7j99qy00555f80nk1i1i1x87fszp3axa"; depends=[]; };
···
   pcrcoal = derive { name="pcrcoal"; version="1.1"; sha256="17mm13xpmghachiqr7v2691jk39mbfsadpg028gs3iiwmh0pksa0"; depends=[ape ggplot2 phylosim]; };
   PCS = derive { name="PCS"; version="1.2"; sha256="0488h6s1yz6fwiqf88z2vgckn6i0kwls8cazmpw3wspnaqvl2n4s"; depends=[statmod]; };
   pcse = derive { name="pcse"; version="1.9"; sha256="04vprsvcmv1ivxqrrvd1f8ifg493byncqvmr84fmc0jw5m9jrk3j"; depends=[]; };
-  pdc = derive { name="pdc"; version="0.5"; sha256="1fx8y2irhklpkhxljy6vkg28i2xhprnhzrfrmxvmggpfk8xca8by"; depends=[]; };
+  pdc = derive { name="pdc"; version="1.0"; sha256="0hq26d8jj7g03c5f80nl6sy162hdkvvf63mmws3ycn5i5zzyygq8"; depends=[]; };
   pdfCluster = derive { name="pdfCluster"; version="1.0-2"; sha256="0kbci54dlzn736835fh18xnf2pmzqrdmwa3jim29xcnwa1r2gklb"; depends=[geometry]; };
-  pdfetch = derive { name="pdfetch"; version="0.1.5"; sha256="16al3db30nv25b0559n1mia3ragc494pn96sqc8hw99p50mrqgab"; depends=[zoo xts RCurl XML lubridate jsonlite reshape2]; };
+  pdfetch = derive { name="pdfetch"; version="0.1.6"; sha256="1j3fdjnmfj84pfd5bc37ssbs83ya3ma0hj5iy1a0bg9wb5xqap13"; depends=[httr zoo xts XML lubridate jsonlite reshape2]; };
   pdist = derive { name="pdist"; version="1.2"; sha256="18nd3mgad11f2zmwcp0w3sxlch4a9y6wp8dfdyzvjn7y4b4bq0dd"; depends=[]; };
   pdmod = derive { name="pdmod"; version="1.0"; sha256="1czpaghp2lcad4j6wxswdfw0n9m0phngy966zr4fr3ciqpx3q129"; depends=[mco]; };
+  pdR = derive { name="pdR"; version="1.1"; sha256="1nizjvrhcg7x4cd12jvgyg4vqxcpfli64z48gw99n53gjbjnb6sq"; depends=[]; };
   PDSCE = derive { name="PDSCE"; version="1.2"; sha256="17lc6d8ly6jbvjijpzg45dvqrzrh5s1sp415nycazgpbg9ypwr2h"; depends=[]; };
-  peacots = derive { name="peacots"; version="1.0"; sha256="1wc2651n34jn88711g295hzyd04ay4gabigh1xcw3m9gpvqnag1k"; depends=[]; };
+  peacots = derive { name="peacots"; version="1.1"; sha256="042644i8x0s4nd425lp8v1i4jspib3qxkgvprgapdhgqcp6cabk0"; depends=[]; };
   Peaks = derive { name="Peaks"; version="0.2"; sha256="0a173p5cdm1jnm7bwsvjpxh4dccy593g02c4qjwky1cgzy5rvin2"; depends=[]; };
   pear = derive { name="pear"; version="1.2"; sha256="1ixmyzm72s18qrfv2m8xzh5503k1q90lhddq4sp46m0q7qyxb192"; depends=[]; };
   pearson7 = derive { name="pearson7"; version="1.0"; sha256="0dz5zf3k6bwj460gna6ak7hwdrsjinhv2ckkgqrycilfsx1w5h44"; depends=[]; };
   PearsonDS = derive { name="PearsonDS"; version="0.97"; sha256="0bsdj4zir12zkv8yhq1z6dqjzhkb9l0f88jrr4iyclns1pcqvrvi"; depends=[]; };
   PearsonICA = derive { name="PearsonICA"; version="1.2-4"; sha256="0jkbqha1nb9pf72ffki47wymsdmd50smkdhvpzvanv4y2rmqfhvg"; depends=[]; };
-  pec = derive { name="pec"; version="2.2.9"; sha256="0qvkmm8k2bg6sg42csrk6sn5qa1bvnmn8q485sxc11lqgxvic2jx"; depends=[prodlim survival rms foreach]; };
+  pec = derive { name="pec"; version="2.3.7"; sha256="16mw9waz4lizac3vdcvrpnznn00h4lf9q50k02iqvmw26q4rrx81"; depends=[prodlim foreach rms survival]; };
   pedantics = derive { name="pedantics"; version="1.5"; sha256="0m5jxzkf1pf657q2klv6idnywg18ki962666nj7sfyl4rq06xhsi"; depends=[MasterBayes MCMCglmm kinship2]; };
   PedCNV = derive { name="PedCNV"; version="0.1"; sha256="09qxcjzwdgzdkbj28rzmfv7k3q2qsiapnvx3m45a835r57h5gynp"; depends=[Rcpp RcppArmadillo ggplot2]; };
   pedgene = derive { name="pedgene"; version="2.1"; sha256="0nmp1s0i5b4h45p3f4rvvixjz8sgv56as3c85rvv3a8xwfd1gcxq"; depends=[Matrix CompQuadForm survey kinship2]; };
   pedigree = derive { name="pedigree"; version="1.4"; sha256="1dqfvzcl6f15n4d4anjkd0h8vwsbxjg1lmlj33px8rpp3y8xzdgw"; depends=[Matrix HaploSim reshape]; };
   pedigreemm = derive { name="pedigreemm"; version="0.3-3"; sha256="1bpkba9nxbaxnivrjarf1p2p9dcz6smf9k2djawis1wq9dhylvsb"; depends=[lme4 Matrix]; };
   pedometrics = derive { name="pedometrics"; version="0.1-9"; sha256="1szp3mp24y32kz24p1c8mzdljqdl61fwnd3q1d5kqwg85amifa12"; depends=[spsurvey xtable XML stringr sp car pbapply MASS plyr lattice latticeExtra VecStatGraphs2D mvtsplot]; };
-  pegas = derive { name="pegas"; version="0.5-1"; sha256="0imn9n0y9nxp8vv1nz3qg9vmb5bdzxm596fxxg4hcgw7am6ap2sq"; depends=[ape adegenet]; };
+  pegas = derive { name="pegas"; version="0.6"; sha256="142hcc5h52sil1wp3m315y07wa6aqvx8igf2pywdz56ydwk2rwpk"; depends=[ape adegenet]; };
   PEIP = derive { name="PEIP"; version="1.7"; sha256="1bagi1kr8vd3b3r524vrk747bqmd9insny1nxj8bdvdk0a9yr949"; depends=[bvls Matrix RSEIS pracma]; };
   PEMM = derive { name="PEMM"; version="1.0"; sha256="18dd9hsbdrnhrrff7gpdqrw2jv44j8lg0v3lkcdpbd4pppcaq84h"; depends=[]; };
   penalized = derive { name="penalized"; version="0.9-42"; sha256="160ypgfcbdxcrgrhq99rgxl1wgn7854y64820nkvmfpc0ady7s4q"; depends=[survival survival]; };
···
   pensim = derive { name="pensim"; version="1.2.9"; sha256="10nrnxwfs41bhybs7j6xgnx0pq3c802n9k8irngmh8iy4w3wbhrq"; depends=[penalized MASS]; };
   peperr = derive { name="peperr"; version="1.1-7"; sha256="01a6sxcmb8v2iz2xdwhdnr92k3w2vn3hr0hg9b6mkpzjf4n45q3k"; depends=[snowfall survival]; };
   peplib = derive { name="peplib"; version="1.5.1"; sha256="1bdgmwbk76ryl5gxcgf3slds92yilg9p1x1lx0hnzzwcgx99wif3"; depends=[]; };
-  PepPrep = derive { name="PepPrep"; version="1.0.0"; sha256="1nrf0q1w9xsv7yp8zm9gbbbn9wg8brbix45m64gvrb9izrx3p09k"; depends=[stringr]; };
+  PepPrep = derive { name="PepPrep"; version="1.1.0"; sha256="1s2xn05xry50l9kf1mj6yd1dpc7yp6g3d00960hswvhznb0a4l84"; depends=[stringr]; };
   peptider = derive { name="peptider"; version="0.1.5"; sha256="1jlvzfm1i7yyplwgsp08x3sx07gmkv24ri8jrlkz6jspj9w90dwq"; depends=[discreteRV plyr dplyr]; };
-  Peptides = derive { name="Peptides"; version="0.4"; sha256="1841cfx6i2yc5142j1160aandvlrljvfxx79clylj5k9yavpj8rc"; depends=[seqinr]; };
+  Peptides = derive { name="Peptides"; version="1.0.1"; sha256="1z9zwan5cxicg1qzxvxrj4lyml0jrir83g5lskzdm4a4g3sl6qyc"; depends=[seqinr]; };
   pequod = derive { name="pequod"; version="0.0-3"; sha256="14nag0bd2icg294y7n47c6xlw54rrdia887d2ni6achjqgwvffzh"; depends=[ggplot2 car]; };
   perARMA = derive { name="perARMA"; version="1.5"; sha256="1d9vrxv8r6qgxhaz3pv8n34c526gi5cd8w7wxy9qc914y8kplmzr"; depends=[corpcor gnm matlab Matrix signal]; };
-  PerfMeas = derive { name="PerfMeas"; version="1.1"; sha256="1b49p5lvnshrinf08v9c6nriycrspy569v5akjpffyqi2badr82b"; depends=[]; };
-  PerformanceAnalytics = derive { name="PerformanceAnalytics"; version="1.1.0"; sha256="082lh4g9lngbj1chmd23ax1603apnpwh7blml6vq6z3lic59qqgy"; depends=[zoo xts]; };
+  PerFit = derive { name="PerFit"; version="1.2"; sha256="1m0s51k497ks4y5253sw1aq5cdkhfkr70mz31xk01c50v11mb268"; depends=[ltm irtoys]; };
+  PerfMeas = derive { name="PerfMeas"; version="1.2.1"; sha256="1x7ancmb41zd1js24rx94plgbssyc71z2bvpic6mg34xjkwdjw93"; depends=[]; };
+  PerformanceAnalytics = derive { name="PerformanceAnalytics"; version="1.4.3541"; sha256="1czchsccsbdfjw743j6rm101q2q01pggyl8zmlva213pwm86zb3v"; depends=[xts zoo]; };
   performanceEstimation = derive { name="performanceEstimation"; version="0.1.1"; sha256="1km2ljsy8hj9x6xr9am0f4wzihlhbyxhcss7kcxbimxvcv0a479n"; depends=[ggplot2]; };
   perm = derive { name="perm"; version="1.0-0.0"; sha256="0075awl66ynv10vypg63fcxk33qzvxddrp8mi4w08ysvimcyxijk"; depends=[]; };
   PermAlgo = derive { name="PermAlgo"; version="1.0"; sha256="1dc4b5pn77av80k6pgh9k0ksvv9lnjqiwdb2jv55nm0ndycw0qr4"; depends=[]; };
-  PerMallows = derive { name="PerMallows"; version="1.3"; sha256="08bgy8k2xcb61kyqxdskz8x0cfw27cypp1r470lvld544r4x0hp1"; depends=[Rcpp]; };
+  PerMallows = derive { name="PerMallows"; version="1.7"; sha256="15bn8qpwl5v7kq5jzls6fis6r11pxh2v7dhj4c9qmw2w9c3x1g7s"; depends=[Rcpp]; };
   permGPU = derive { name="permGPU"; version="0.14.6"; sha256="1h01nfq8hn7i29xanma70q6s5mj83znbb2lg9x7bjgdrgj38vy2m"; depends=[RUnit foreach survival]; };
   permtest = derive { name="permtest"; version="1.2"; sha256="1sciyjs840h004zg8bwclq0j0n22anvjvx3fz62y4dzblrynhrci"; depends=[]; };
   permute = derive { name="permute"; version="0.8-3"; sha256="0zc3b3cl7q7y9pglc690ldg6p7bl7d1h7xkwnqqmvrpn7cq29rdb"; depends=[]; };
···
   pesticides = derive { name="pesticides"; version="0.1"; sha256="1w180hqqav0mh9sr9djj94sf55fzh4r373a7h08a2nz9nyjpq09w"; depends=[]; };
   PET = derive { name="PET"; version="0.4.9"; sha256="1ijg6mfh3xrc1gjh6a4nq64psk9yh16yc8nfp7c9837xbjigqq7f"; depends=[adimpro]; };
   PF = derive { name="PF"; version="9.5"; sha256="1y99brdabj78s5kxyv0136s40kaaj3zya9lk4qd0kqk83z2gdawp"; depends=[xtable RColorBrewer gdata]; };
-  pfa = derive { name="pfa"; version="1.0"; sha256="116mpfdmfyd0p5j33rjw1xwxyyaccagbrpw7jbh4x996s057mql4"; depends=[lars POET quantreg]; };
   pgam = derive { name="pgam"; version="0.4.12"; sha256="0vhac2mysd053bswy3xwpiz0q0qh260hziw6bygpf83vkj94qf2v"; depends=[]; };
   pgirmess = derive { name="pgirmess"; version="1.5.9"; sha256="1n58r5ghd2ppnid6787gd1n18f23pf0fk7yr3vagcqpzv4pk0wic"; depends=[boot nlme rgdal sp spdep splancs]; };
   pglm = derive { name="pglm"; version="0.1-2"; sha256="1arn2gf0bkg0s59a96hyhrm7adw66d33qs2al2s0ghln6fyk8674"; depends=[maxLik plm statmod]; };
   pGLS = derive { name="pGLS"; version="0.0-1"; sha256="1rlk8q09sikf4vpzsx0c7s6qqh2hxf8dy2bgcm4nnkbv2nfjz438"; depends=[MASS]; };
   PGM2 = derive { name="PGM2"; version="1.0"; sha256="18azh6k271p9dvc23q402pv7wrilr1yk02vqqy6qjppnvq6jxahg"; depends=[]; };
   pgmm = derive { name="pgmm"; version="1.1"; sha256="0ajdcnxxy18ifidid4xnq9a03bsrvcbh3dh2vhviggkhq8gji1dn"; depends=[]; };
-  pgnorm = derive { name="pgnorm"; version="1.1"; sha256="0fxx9wvzinh17cxy74xms6dbabifav0wsi2cl0wdfykpbwalmszk"; depends=[]; };
   pgs = derive { name="pgs"; version="0.4-0"; sha256="1zf5sjn662sds3h06zk5p4g71qnpwp5yhw1dkjzs1rs48pxmagrx"; depends=[gsl R2Cuba]; };
   phalen = derive { name="phalen"; version="1.0"; sha256="0awj9a48dy0azkhqkkzf82q75hrsb2yw6dgbsvlsb0a71g4wyhlr"; depends=[sqldf]; };
-  phangorn = derive { name="phangorn"; version="1.99-7"; sha256="1q6a6md52d2f9xlrs5wv9crncwxh9a4x6zfxmdbsvrlwmgsbzvcx"; depends=[ape quadprog igraph Matrix fastmatch]; };
+  phangorn = derive { name="phangorn"; version="1.99-9"; sha256="0ngk3ysh84n1an7kajk3hcisvnywzd73m1x8h3ij2xpksfb0igz9"; depends=[ape quadprog igraph Matrix fastmatch rgl]; };
   PharmPow = derive { name="PharmPow"; version="1.0"; sha256="0gabkd8p4zsig9p697lyk8m2jxb5abjk81rpzd5ih1yk1qanhsn5"; depends=[scatterplot3d]; };
   phaseR = derive { name="phaseR"; version="1.3"; sha256="1hwclb7lys00vc260y3z9428b5dgm7zq474i8yg0w07rxqriaq2h"; depends=[deSolve]; };
   PhaseType = derive { name="PhaseType"; version="0.1.3"; sha256="092dqyqfaxj8qpwxcjb5cayhnq597rfjz1xb93ps4nrczycqs0l6"; depends=[coda ggplot2 reshape]; };
···
   pheatmap = derive { name="pheatmap"; version="0.7.7"; sha256="0zj6n6cjkim20apihl943rhzxlmkmpqwh00l6h2c8z04m3pv186v"; depends=[RColorBrewer]; };
   phenability = derive { name="phenability"; version="1.0"; sha256="19vxknc0v8vz5cd748fhsndsrpggzlsiims9j7p2s6jlankkgsz9"; depends=[calibrate]; };
   phenex = derive { name="phenex"; version="1.0-7"; sha256="0q563cv9lskikf3ls0idp56lirw9gxn71rgxp9xn8an05gwdg0xr"; depends=[]; };
+  PHENIX = derive { name="PHENIX"; version="1.0"; sha256="1shkf77bq3lvkj6srcil3fqwp78hfkbjnhkz2v8kmfqf92h4z5pb"; depends=[ppcor]; };
   phenmod = derive { name="phenmod"; version="1.2-3"; sha256="0dxwx8c7zka29fq7svrvn8bghj8jh8grbrgsw4pvavx2439cldak"; depends=[gstat RColorBrewer lattice pheno]; };
   pheno = derive { name="pheno"; version="1.6"; sha256="0xdya1g1ap7h12c6zn3apbkxr725rjhcp4gbdchkvcnwz4y9vw8c"; depends=[nlme SparseM quantreg]; };
   pheno2geno = derive { name="pheno2geno"; version="1.2.1"; sha256="0rh4fzka453i5djsyv4c0z3x6d5r7fvyvxi6x1a1806nzy7w43hj"; depends=[qtl VGAM mixtools]; };
-  phenology = derive { name="phenology"; version="3.69"; sha256="0xyd53w162b9f2k4wkrkhi2m7fwj30ii4xjlp7l5px352x1nhylv"; depends=[fields zoo coda shiny]; };
+  phenology = derive { name="phenology"; version="4.0"; sha256="04zpqvbq5qb3kr1crgj2lbnzj9hcipak2rp4qvskisg750rr8h3p"; depends=[fields zoo coda shiny]; };
   PHeval = derive { name="PHeval"; version="0.5.1"; sha256="12vlfg2w27hc19f8dwvhl8r0xfwapp1r9bihq7ax3d9j7aayv217"; depends=[survival]; };
   phia = derive { name="phia"; version="0.1-5"; sha256="0vkl4ccsdx72dwis2959f6w9zg584wfkn58fh2slybdyg9p8886a"; depends=[car]; };
   phmm = derive { name="phmm"; version="0.7-5"; sha256="0dil0ha199yh85j1skwfdl0v02vxdmb0xcc1jdbayjr5jrn9m1zk"; depends=[survival lattice Matrix]; };
···
   phonR = derive { name="phonR"; version="0.4-2"; sha256="15hi15minbd756vplmcyf0987ppanr44kds13nny0v1h5yyv8kyx"; depends=[]; };
   phonTools = derive { name="phonTools"; version="0.2-2.0"; sha256="1wd1a5506p3ny6vi9pq6yg9gbz082fxw4l3cxsplkdpqgkhryrww"; depends=[]; };
   phreeqc = derive { name="phreeqc"; version="1.0-8877"; sha256="0w529qpqrjcn619bqinkdd8f02vigiwy799h7i33p7iwbf15jvzj"; depends=[]; };
-  phtt = derive { name="phtt"; version="3.1.1"; sha256="02fqg2djpvbm6id1dg8c8w1qccd2axxrhlfi4vrm8d1qcrbjkjm1"; depends=[pspline]; };
+  phtt = derive { name="phtt"; version="3.1.2"; sha256="1fvvx5jilq5dlgh3qlfsjxr8jizy4k34a1g3lknfkmvn713ycp7v"; depends=[pspline]; };
   PhViD = derive { name="PhViD"; version="1.0.6"; sha256="17mr8gj6ic4p0xvxiva046r1gmy9azvm1s95rinxqsdd7hiak72w"; depends=[MCMCpack]; };
+  PhyActBedRest = derive { name="PhyActBedRest"; version="1.0"; sha256="0fpg17fwap12da7xka8pnd1wk6rbmw3zl099588g2r05wq3425sx"; depends=[]; };
   phyclust = derive { name="phyclust"; version="0.1-15"; sha256="1j643k0mjmswsvp9jyiawkjf2qhfrw6xf4s2viqv987zxif2kd7z"; depends=[ape]; };
   phyext = derive { name="phyext"; version="0.0.1"; sha256="07hmjgp4qb3x95rbgm83sh9zwhsxjl1v5rvs39m565sc0fax1qdi"; depends=[phylobase ape]; };
   phylin = derive { name="phylin"; version="1.0"; sha256="10pbs4adsyp43i89jb3xi0m55sl1w7ifmc98v74iq9p8xa15sdci"; depends=[]; };
   phylobase = derive { name="phylobase"; version="0.6.8"; sha256="0xj7x4cdfp0yadvjhdkw1ai3yd081ri4gpdg0n5g0z13cjaa6mjh"; depends=[ade4 ape Rcpp]; };
   phyloclim = derive { name="phyloclim"; version="0.9-4"; sha256="0ngg8x192lrhd75rr6qbh72pqijbrhrpizl27q0vr6hp7n9ch3zx"; depends=[ape raster]; };
-  phyloland = derive { name="phyloland"; version="1.0"; sha256="0r6rpwcq13bxa6289bfj0a0is67a49nj5npi5381090iarkwfvs7"; depends=[ape gsubfn]; };
+  phyloland = derive { name="phyloland"; version="1.3"; sha256="10g40m6n2s4qvnzlqcwpy3k0j7bxdp79f586jj910b8p00ymrksp"; depends=[ape]; };
   phylolm = derive { name="phylolm"; version="2.1"; sha256="0g0s9n0899gbh5hhk469b3c1z8zhp9il50srnbvmfhql0cf1v22c"; depends=[ape]; };
   phylosim = derive { name="phylosim"; version="2.1.1"; sha256="0rrz5c7zl2hjalwm6m8pydikiwmiq2dybx2yhzp0ps2bcsn02lhn"; depends=[R_oo ape compoisson ggplot2 R_methodsS3]; };
   phylotools = derive { name="phylotools"; version="0.1.2"; sha256="19w7xzk6sk1g9br7vwv338nvszzh0lk5rdzf0khiywka31bbsjyb"; depends=[seqRFLP ape picante spaa fields]; };
   phyloTop = derive { name="phyloTop"; version="1.1.1"; sha256="046myyr01c4zc6sfy7r6p2vswkqqqd3w4k173gjbjazl1ims1sjs"; depends=[phylobase NHPoisson ape igraph]; };
   phyreg = derive { name="phyreg"; version="0.7"; sha256="0saynhq4yvd4x2xaljcsfmqk7da2jq3jqk26fm9qivg900z4kf35"; depends=[]; };
   PhysicalActivity = derive { name="PhysicalActivity"; version="0.1-1"; sha256="1aqyip7psf3pdrxkpidfldkk9naihvnc7s3n6w6vvr9h1l5mpmvc"; depends=[]; };
-  phytools = derive { name="phytools"; version="0.4-21"; sha256="1mvksa62hanbnn7ndgpsgipl8ckdhnzvfsarpidpxzgsc7vwagz8"; depends=[ape maps animation clusterGeneration mnormt msm numDeriv phangorn plotrix scatterplot3d]; };
+  phytools = derive { name="phytools"; version="0.4-31"; sha256="1dmwjkd2c16amz7v4nwyd0006kydy3snrb1wkjd69n6qnfwmr7ba"; depends=[ape maps animation clusterGeneration mnormt msm numDeriv phangorn plotrix scatterplot3d]; };
   pi0 = derive { name="pi0"; version="1.3-250"; sha256="1561zvf1hcd05iqy245c0z23mi8ypk6q3lkfldcr55cs67w4lmz6"; depends=[LowRankQP Matrix numDeriv limSolve rgl scatterplot3d Iso quadprog kernlab]; };
   picante = derive { name="picante"; version="1.6-2"; sha256="1zxpd8kh3ay6f3gdqkij1a6vnkr98dc1jib2r6br2kjyzshabcsd"; depends=[ape vegan nlme]; };
+  picasso = derive { name="picasso"; version="0.3.0"; sha256="0z314akr1x2a28hh5hbb7mzkyaxsj4dfkdmx10l6gqllgk9j5qca"; depends=[lattice igraph MASS Matrix]; };
   PIGE = derive { name="PIGE"; version="0.9"; sha256="1x8ml25mm69dvlszm9p2ycph92nxcsgd52ydj7ha0dwrrpcv2law"; depends=[snowfall ARTP xtable survival]; };
   PIGShift = derive { name="PIGShift"; version="1.0.0"; sha256="15cgpi7j5cs4aqdq5cy7535x8ar916d9hd109kc01njrwxp1xr96"; depends=[ape mvtnorm]; };
-  PIN = derive { name="PIN"; version="0.8"; sha256="1hymf5106zxgbg8dki9jb7gy4vh2mjwbvzh0n2d7qkr6rm8lpmag"; depends=[]; };
-  pipeR = derive { name="pipeR"; version="0.4"; sha256="1lvi2pxb5jl874hgqp7f4vbkr306slg0lrsmbicvwg569dz5262f"; depends=[]; };
+  pingr = derive { name="pingr"; version="1.1.0"; sha256="0j03qcsyckv3zh2v4m8wz8kyfl0k8qi71rm20rc0spy1s9ng7fcb"; depends=[]; };
+  pipeR = derive { name="pipeR"; version="0.5"; sha256="1x761ycmnldzsvahfaz1k8qz0qnrqp54qxqaskc8zp841cbhp8bh"; depends=[]; };
   PIPS = derive { name="PIPS"; version="1.0.1"; sha256="1c5v3s6xys9p1q32k6mpsffhi9gwsq951rh12hs76dmak862yspc"; depends=[]; };
-  pitchRx = derive { name="pitchRx"; version="1.5"; sha256="17g7kx6gjaknb14h3l76zr128s6skgvj2i1pg83sqj5ipj55qzhr"; depends=[ggplot2 XML2R plyr MASS hexbin mgcv]; };
-  PivotalR = derive { name="PivotalR"; version="0.1.16.17"; sha256="079s4cs6awc8rbr82b1fm0096j34lbmzgnczrfclxnb2rwmn8biv"; depends=[Matrix]; };
+  pitchRx = derive { name="pitchRx"; version="1.6"; sha256="16x152xz7vs4bwi4xh05sbj38xgqzk8g95vfm0vm5mf94qnnaa6c"; depends=[ggplot2 XML2R plyr MASS hexbin mgcv]; };
+  PivotalR = derive { name="PivotalR"; version="0.1.17.8"; sha256="023qhinh61ix4s8jkp2kbxpfly77w05sgaiqidbrsxf7zxih3zcf"; depends=[Matrix]; };
   pixmap = derive { name="pixmap"; version="0.4-11"; sha256="04klxp6jndw1bp6z40v20fbmdmdpfca2g0czmmmgbkark9s1183g"; depends=[]; };
   PK = derive { name="PK"; version="1.3-2"; sha256="0162ri9wlm9inryljal48av8yxb326na94kckkigsrklfxb3wkp2"; depends=[]; };
-  PKfit = derive { name="PKfit"; version="1.2.2"; sha256="04gix9yyzfsam2zql5q9rr45zzpdz5y7i6w1lf6rqf4fgnjwfjqs"; depends=[deSolve minpack_lm]; };
-  pkgKitten = derive { name="pkgKitten"; version="0.1.0"; sha256="17gf3yiy7hq6f53sjxajnf87cg6c7ialiyfw61bj4fjbhskw92ij"; depends=[]; };
+  PKfit = derive { name="PKfit"; version="1.2.4"; sha256="1vyf7w3d2wylj8hrgz7hpb2syvwsmf8bbdjh4w3kgcjdjivvnvxn"; depends=[optimx deSolve minpack_lm]; };
+  pkgKitten = derive { name="pkgKitten"; version="0.1.2"; sha256="0nk51c3cx9hy8dwdi7llf9k6kq8495dvy8bxjlajwiwd39jipvgs"; depends=[]; };
   pkgmaker = derive { name="pkgmaker"; version="0.22"; sha256="0vrqnd3kg6liqvpbd969jjsdx0f0rvmmxgdbwwrp6xfmdg0pib8r"; depends=[registry codetools digest stringr xtable]; };
   PKgraph = derive { name="PKgraph"; version="1.7"; sha256="0g36cdv5cblqx69j48irxjc5nlw2cl3p714mlsblnd3362z1brwn"; depends=[RGtk2 gWidgetsRGtk2 cairoDevice lattice rggobi ggplot2 proto RGtk2 gWidgetsRGtk2]; };
   pkgutils = derive { name="pkgutils"; version="0.6.0"; sha256="0pi1xaamirsv1bwlwcvyd1hvdgbjbdmw3vg3krawsb34mynbrcff"; depends=[]; };
···
   pks = derive { name="pks"; version="0.3-0"; sha256="0lvj5kfjf8wikszz1dipwr1fw9xbhy3nx0ksqz4ln240k7fn5kcj"; depends=[sets]; };
   PKtools = derive { name="PKtools"; version="1.5-0"; sha256="0za6qgl9q9y4j87kfhvanpc9mfckzww6q2kjz7divbv8ygn5cd1m"; depends=[lattice nlme R2HTML xtable]; };
   plan = derive { name="plan"; version="0.4-2"; sha256="0vwiv8gcjdbnsxd8zqf0j1yh6gvbzm0b5kr7m47ha9z64d7wxch6"; depends=[]; };
-  planar = derive { name="planar"; version="1.5"; sha256="1ph3q985xw1sg9cs5k1cqpr46f0svycdc1dg3pqmdrzqdi8a3gyx"; depends=[dielectric Rcpp RcppArmadillo statmod cubature reshape2 plyr]; };
+  planar = derive { name="planar"; version="1.5.2"; sha256="1w843qk88x3kzi4q79d5ifzgp975dj4ih93g2g6fa6wh529j4w3h"; depends=[dielectric Rcpp statmod cubature reshape2 plyr]; };
   planor = derive { name="planor"; version="0.2-0"; sha256="0mvlkrggwgrc9fmp935kihj2v7gfnghw7smpkbb3pbrrv9zhjlgi"; depends=[conf_design]; };
   PlayerRatings = derive { name="PlayerRatings"; version="1.0-0"; sha256="0hjb05bdha00ggcpp3n4f86dxjlhzmlpwgsbbx3mhyv3qq1g32ky"; depends=[]; };
-  playitbyr = derive { name="playitbyr"; version="0.2-1"; sha256="0pi0kji32ha6csff5w2xl8f76clrxlkwws60lzqzc83avrb0930n"; depends=[csound]; };
   playwith = derive { name="playwith"; version="0.9-54"; sha256="1zmm8sskchim3ba3l0zqfvxnrqfmiv94a8l6slcf3if3cf9kkzal"; depends=[lattice cairoDevice gWidgetsRGtk2 RGtk2 gWidgets gridBase]; };
   plfm = derive { name="plfm"; version="1.1.1"; sha256="0vsbva2clkjn8ddinmihq1gzd8g8yjiwd11rl7xzbyabjxkp95n1"; depends=[sfsmisc abind]; };
   plgp = derive { name="plgp"; version="1.1-5"; sha256="04kxiixm6p9s42fs775lrh8112v2m7akjp78r46l0rd8fzp3zyiq"; depends=[mvtnorm tgp]; };
-  plink = derive { name="plink"; version="1.3-1"; sha256="1g8n4fy7yx3386kgvc0kgh8gd390yl4fxs09whdl1mzz5q9sx4wp"; depends=[lattice MASS statmod]; };
   PLIS = derive { name="PLIS"; version="1.1"; sha256="0b81s7677wglqvv1b5lx8k2iaks09kz0wrl07245a7j2pk9nxv7p"; depends=[]; };
   plm = derive { name="plm"; version="1.4-0"; sha256="13y9s7gyrgqmnzafhn4c1zkz6gdawc8nr5nbrx0pn2mbw3fqfrjh"; depends=[Formula MASS bdsmatrix zoo nlme sandwich]; };
   plmDE = derive { name="plmDE"; version="1.0"; sha256="19xxi0zzpxcrsdrbs0hiwqgnv2aaw1q3mi586wv27zz6lfqcr9lr"; depends=[MASS R_oo]; };
   plmm = derive { name="plmm"; version="0.1-1"; sha256="1dfxd1mqqjy2mf7qc6mh4wx5ya9q8fkqgrf01apisb66xxx5zya7"; depends=[sm Formula nlme]; };
   pln = derive { name="pln"; version="0.2-1"; sha256="09zg7zwmmqpjr1j59lqsjf4blrkya9wfwddgzfm9rr5jxrzvqcv8"; depends=[]; };
+  PLordprob = derive { name="PLordprob"; version="1.0"; sha256="156lvz6vfm68hm32l5nlhq15hfacdla627d6lf8l4g34lwzdh8k8"; depends=[mnormt]; };
   plot2groups = derive { name="plot2groups"; version="0.10"; sha256="00mp82vvx6inlc2zj2cqqnzyglrm9x9im2vrqqk8j2jn0hbgfymy"; depends=[ggplot2]; };
   plot3D = derive { name="plot3D"; version="1.0-1"; sha256="1zvvsl94azz3252c8f485zhzd4x23wfj08x85vq873fj36p82aaf"; depends=[misc3d]; };
   plot3Drgl = derive { name="plot3Drgl"; version="1.0"; sha256="109vsivif4hmw2hk3hi4y703d3snzxbr9pzhn1846imdclkl12yg"; depends=[rgl plot3D]; };
···
   PLRModels = derive { name="PLRModels"; version="1.1"; sha256="0dwnzfw7a1cxz9s00kxf19jmjsc8cy6cc9q2mjqf8z7690wrg7hb"; depends=[]; };
   pls = derive { name="pls"; version="2.4-3"; sha256="114ka4766x8fx0zvvr7cylky1jsy542nj6s7sb2dwv8zjhbclkhn"; depends=[]; };
   plsdepot = derive { name="plsdepot"; version="0.1.17"; sha256="1i00wxr451xpfy6dnvcm11aqf9106jsh5hj7gpds22ysgm4iq5w4"; depends=[]; };
-  plsdof = derive { name="plsdof"; version="0.2-6"; sha256="1gdc6ck2l8k4i275lj1kvpqbzgm5a5db21zc828hz56aqfj28fm9"; depends=[MASS]; };
+  plsdof = derive { name="plsdof"; version="0.2-7"; sha256="1z8z9m0nsnyy1fipzvm1srpxn3q6wjrlivmmki1f8plwkixkyc5y"; depends=[MASS]; };
   plsgenomics = derive { name="plsgenomics"; version="1.2-6"; sha256="0f0pns20hd8hfc3v9m9vb8sng8qib6cry1k49nqs9gn09hhh26w9"; depends=[MASS]; };
   plspm = derive { name="plspm"; version="0.4.1"; sha256="00ibz69vhf0x3c73khkg57mzw49c3vq20yiqdqm9cpkdr9fczn2n"; depends=[amap diagram tester turner]; };
   plsRbeta = derive { name="plsRbeta"; version="0.1.8"; sha256="1gfwl659pmwjkif8n1vz7ljij3r8akzrlf389qwmhy57d6lhyb6w"; depends=[mvtnorm boot Formula plsdof MASS plsRglm betareg]; };
···
   pmcgd = derive { name="pmcgd"; version="1.1"; sha256="1pybzvyjmzpcnxrjsas06diy3x83i1r5491s6ccyr63l56hs55d5"; depends=[mixture mnormt]; };
   pmclust = derive { name="pmclust"; version="0.1-6"; sha256="05zjx4psvk5zjmr0iwwwig990g6h04ajn5wi0xi8bqv046r47q3h"; depends=[rlecuyer pbdMPI MASS]; };
   PMCMR = derive { name="PMCMR"; version="1.0"; sha256="07k98zp4s65vx7ybj75b0i1jhlnvfspwjqh10nxdn0zmixw9nywj"; depends=[]; };
-  pmg = derive { name="pmg"; version="0.9-42"; sha256="16jkkhpjiwpk5gszr7fc133l3y50dfwqxb45flzihxvp1x42d70y"; depends=[lattice MASS proto foreign gWidgets gWidgetsRGtk2]; };
+  pmg = derive { name="pmg"; version="0.9-43"; sha256="0i7d50m4w7p8ipyx2d3qmc54aiqvw0ls8igkk8s1xc7k8ympfqi6"; depends=[gWidgets gWidgetsRGtk2 proto lattice foreign MASS]; };
   pmlr = derive { name="pmlr"; version="1.0"; sha256="1z3hbw4wabpai1q8kbn77nzxqziag8y04cidlfiw7z969s4pkmgl"; depends=[]; };
   pmml = derive { name="pmml"; version="1.4.2"; sha256="0588sph67zs58knf4g3fd7c84i2yag81igr882jgbaxhfhxrpk6n"; depends=[XML survival]; };
   pmmlTransformations = derive { name="pmmlTransformations"; version="1.2.2"; sha256="1p31lakhqwk0qhb565j2sjcfsjsx0i5v8kj8779ryjyvy7717m6m"; depends=[]; };
   pmr = derive { name="pmr"; version="1.2.4"; sha256="15yrh533rj5i728nvcpjj3m5wa3jbspnfj941px3mf11h14npxpp"; depends=[]; };
+  png = derive { name="png"; version="0.1-7"; sha256="0g2mcp55lvvpx4kd3mn225mpbxqcq73wy5qx8b4lyf04iybgysg2"; depends=[pkgs.libpng]; };
   pnmtrem = derive { name="pnmtrem"; version="1.3"; sha256="0053gg368sdpcw2qzydpq0c5v2cxdlwgf5k68cbw0yx41csjgvz0"; depends=[MASS]; };
   pnn = derive { name="pnn"; version="1.0.1"; sha256="1s6ib60sbdas4720hrsr5lsszsa474kfblqcalsb56c84gkl42ka"; depends=[]; };
   pocrm = derive { name="pocrm"; version="0.8"; sha256="04i9slfb9hmhhhq6m2iz7p3cm3v1v6nsvnr117dp55cxanfymd6f"; depends=[dfcrm nnet]; };
-  POET = derive { name="POET"; version="1.0"; sha256="0drn9530b14hindim8si1828yabyqc85b0qi900ahi5rv1p38v82"; depends=[]; };
   poibin = derive { name="poibin"; version="1.2"; sha256="12dm1kdalbqy8k7dfldf89v6zw6nd0f73gcdx32xbmry2l2976sa"; depends=[]; };
   PoiClaClu = derive { name="PoiClaClu"; version="1.0.2"; sha256="1j593sc344h9iy7if1ppihx2qd73dv32d77d8ckac43i7b2lig24"; depends=[]; };
   poilog = derive { name="poilog"; version="0.4"; sha256="0bg03rd5rn4rbdpiv87i8lamhs5m7n7cj8qf48wpnirg6jpdxggs"; depends=[]; };
···
   PoissonSeq = derive { name="PoissonSeq"; version="1.1.2"; sha256="1hhx0gv06cp6hm6h36mqy411qn9x15y45crpzbyf8crfs85c6gbg"; depends=[combinat]; };
   poistweedie = derive { name="poistweedie"; version="1.0"; sha256="18992fafypds3qsb52c09fasm3hzlyh5zya6cw32wnhipmda643m"; depends=[]; };
   poLCA = derive { name="poLCA"; version="1.4.1"; sha256="0bknnndcxsnlq6z9k1vbhqiib1mlzlx4badz85kc7a3xbrdrfs9f"; depends=[scatterplot3d MASS]; };
-  pollstR = derive { name="pollstR"; version="1.0.2"; sha256="1nnd62m0241ig725dx27f6msbj0nhgh149rij4rjy79w5w1zsa02"; depends=[httr plyr jsonlite]; };
+  polidata = derive { name="polidata"; version="0.1.0"; sha256="07641v0dnn161kyxx7viplkf8c3r51hd4hd5pzmcph4y4387r01i"; depends=[jsonlite RCurl]; };
+  pollstR = derive { name="pollstR"; version="1.1.1"; sha256="1wl5nli8y7mxwr5j1cp0z1a9ny4d1anh5pyc8vi1jbnvqdnin1v6"; depends=[httr plyr jsonlite]; };
   polspline = derive { name="polspline"; version="1.1.9"; sha256="1n08dhwpf53slk1zib491kii54x9h16g3jgr2kxxpyc5xfv4yj26"; depends=[]; };
   polyaAeppli = derive { name="polyaAeppli"; version="2.0"; sha256="0kyz3ap92xz7aqyviyrpggfmicy1gybrx7y19djsmixcwz53zqch"; depends=[]; };
   polyapost = derive { name="polyapost"; version="1.1-6"; sha256="1wk85nl2p9plnaavjdr4bqxxhjc84ynv53bh2v1rmq87jymw40b1"; depends=[boot]; };
   polyclip = derive { name="polyclip"; version="1.3-0"; sha256="05bbj4hy4h1hcb4pzg1mjp8k7k91kqq5rg2x0ns4hcs1h4zrspds"; depends=[]; };
   polycor = derive { name="polycor"; version="0.7-8"; sha256="0hvww5grl68dff23069smfk3isysyi5n2jm4qmaynrk0m3yvhxwn"; depends=[mvtnorm sfsmisc]; };
-  polyCub = derive { name="polyCub"; version="0.5-0"; sha256="0ry7kfy99nzwpbs8ac138b05rs36n1whdc0gcvgdb1x76xsa36lr"; depends=[sp spatstat]; };
+  polyCub = derive { name="polyCub"; version="0.5-1"; sha256="13l0gnzj5gs4iikcaj13nsb8ndbb7asx8ycllli61az12rc2p6yf"; depends=[sp]; };
   polynom = derive { name="polynom"; version="1.3-8"; sha256="05lng88c8cwj65cav31hsrca9nbrqn5rmcz79b17issyk2j0g86p"; depends=[]; };
   PolynomF = derive { name="PolynomF"; version="0.94"; sha256="006ds50ivq91v2jyhgpm5rfaipxbzsnljrki6fjplcw07g0frz71"; depends=[]; };
   PolyPatEx = derive { name="PolyPatEx"; version="0.9"; sha256="1y3jsy095kfp9ycjnj467s1y5abba7jkm83x2cajp5g2jdgp7cf6"; depends=[gtools]; };
-  polysat = derive { name="polysat"; version="1.3-2"; sha256="1h1ixxa4z6qr3ixpphy70axd3kf4gnwiw1i22qzm4m06h4bdchva"; depends=[combinat]; };
+  polysat = derive { name="polysat"; version="1.3-3"; sha256="02h1lf1bk7hhphfdcql0rmiszp3b3mdfhqfwxj369389dg0q57bd"; depends=[]; };
   polySegratio = derive { name="polySegratio"; version="0.2-4"; sha256="05kvj475zhlrmp7rm691cfs28igp4ac2cn2xxf7axx09v1nq33db"; depends=[gdata]; };
   polySegratioMM = derive { name="polySegratioMM"; version="0.6-3"; sha256="1y4kzb1p3aw7ng8mv1hszpvb5hwwxy4vg34mhhk705ki4jy8jgvp"; depends=[polySegratio gtools coda lattice]; };
   polytomous = derive { name="polytomous"; version="0.1.6"; sha256="137qcnncih1lm2wshwrznlcr0k552n0sqhiy73iwis59lg854caa"; depends=[MASS Hmisc lme4]; };
···
   PopED = derive { name="PopED"; version="0.1.1"; sha256="0p5wiwl1d7ywjpq3zj5mkk12hqhi0xgcwf9sr3pdqyrczhl825d3"; depends=[ggplot2 MASS mvtnorm nlme]; };
   popgen = derive { name="popgen"; version="1.0-3"; sha256="00rgfwmmiharfxqlpy21n3jbxwr5whzdg8psqylkjf83ls2myqzm"; depends=[cluster]; };
   PopGenKit = derive { name="PopGenKit"; version="1.0"; sha256="0l4mbm0cyppgvcw2cbimrv29aiciyj00k8wfwcj5zr8sh7fgfhs4"; depends=[]; };
-  PopGenome = derive { name="PopGenome"; version="2.0.8"; sha256="07s4b8v00m2fsja0ynri67ns240kskw7f0snzfcs94p1kaalj4jx"; depends=[ff]; };
-  PopGenReport = derive { name="PopGenReport"; version="2.0"; sha256="1bi7a2dbqr73andgzmq00x5hkbi06ylmhyfn12b4h2260v6w5mwk"; depends=[knitr adegenet raster lattice RgoogleMaps gap calibrate xtable plyr dismo reshape ggplot2 R_utils ade4 pegas genetics rgdal gdistance vegan sp mmod]; };
+  PopGenome = derive { name="PopGenome"; version="2.0.9"; sha256="0zvpli7622x41yfvazlj1ibk42q6x8crcw1d2bb8il3r95xi8b0p"; depends=[ff]; };
+  PopGenReport = derive { name="PopGenReport"; version="2.1"; sha256="040h7cvnh1xqlbsyg1lkfiz88421myr47r63v466bxidwb17bqg2"; depends=[knitr adegenet raster lattice RgoogleMaps gap calibrate xtable plyr dismo reshape ggplot2 R_utils ade4 pegas genetics rgdal gdistance vegan sp mmod GGally]; };
   popgraph = derive { name="popgraph"; version="1.4"; sha256="1z6w6vj3vl2w10hvzwmkw4d475bqcd6ys92xnn445ag6vpq0cvxq"; depends=[ggplot2 igraph MASS sp Matrix sampling]; };
   popKorn = derive { name="popKorn"; version="0.3-0"; sha256="1zcl6ms7ghbcjyjgfg35h37ma8nspg15rk2ik82yalqlzxjf7kxw"; depends=[boot]; };
   poppr = derive { name="poppr"; version="1.1.2"; sha256="0qzqyrx8jqz9xhwq6v2ic2jm82g3csg6cs31g7hailx559axxi8i"; depends=[adegenet vegan ggplot2 phangorn ape igraph ade4 pegas reshape2]; };
-  popRange = derive { name="popRange"; version="1.1.1"; sha256="1n8swfhnxk757n6nxsmn8dzx2h01xdr2s64wy2m4xq7wpdp9lajq"; depends=[]; };
+  popRange = derive { name="popRange"; version="1.1.3"; sha256="0kkz6va0p8zv3skaqqcpw42014d9x9x4ilx0czz91qf46h61jgb0"; depends=[findpython]; };
   popReconstruct = derive { name="popReconstruct"; version="1.0-3"; sha256="1m4gj43bzsz8y4jay0bc5mvdfwqx5agha4l2r0svm6qg8cfl4lza"; depends=[coda]; };
   popsom = derive { name="popsom"; version="2.3"; sha256="0hdg1nx8mlpqw9aj2q08sb20frsc5jnbvqpfalf5kyvlygnhxdlc"; depends=[som fields]; };
   portes = derive { name="portes"; version="2.1-3"; sha256="0nqh6aync5igmvg7nr5inkv2cwgzd0zi6ky0vvrc3abchqsjm2ck"; depends=[]; };
   portfolio = derive { name="portfolio"; version="0.4-6"; sha256="0kaaincyzc2f4dm7n08y3vs1yd1r7pd997gf2wvfjydw7wkc5pin"; depends=[lattice nlme]; };
   portfolioSim = derive { name="portfolioSim"; version="0.2-7"; sha256="1vf46882ys06ia6gfiibxx1b1g81xrg0zzman9hvsj4iky3pwbar"; depends=[lattice portfolio]; };
   PortRisk = derive { name="PortRisk"; version="1.0"; sha256="0vyzvi56lmdlhxpbxcxcfqa8271jv2l45w7x1kzzwl6q0wm4bjln"; depends=[zoo]; };
-  postCP = derive { name="postCP"; version="1.7.2"; sha256="1zi3ns202rsfbjkblsmk3vzlygixgm81cp9kga64q1xgk40vq657"; depends=[MASS Segmentor3IsBack]; };
   potts = derive { name="potts"; version="0.5-2"; sha256="1q4kvknxkrd8qbv8l3vmwrppgzq5bsysnqgm029lx7iys73x4fck"; depends=[]; };
   PottsUtils = derive { name="PottsUtils"; version="0.3-2"; sha256="05ds0a7jq63zxr3jh66a0df0idzhis76qv6inydsjk2majadj3zv"; depends=[miscF]; };
   powell = derive { name="powell"; version="1.0-0"; sha256="160i4ki3ymvq08szaxshqlz7w063493j5zqvnw6cgjmxs7y0vj8y"; depends=[]; };
-  PoweR = derive { name="PoweR"; version="1.0.1"; sha256="1m6y7f89kjhdmrdw1xb59cly0xjz79b1krhywkg9m7z73k1yx9h9"; depends=[]; };
-  Power2Stage = derive { name="Power2Stage"; version="0.1-4"; sha256="1gdkrvmrss5x6m33y6lk8d397q64jj4d72hxvs9yj1wwngd635ah"; depends=[PowerTOST]; };
+  PoweR = derive { name="PoweR"; version="1.0.3"; sha256="0mrdw2444y0gykxy5qwlrifhfclhx9jbdhx1syv1gldk06wd6z9f"; depends=[Rcpp RcppArmadillo]; };
+  Power2Stage = derive { name="Power2Stage"; version="0.1-5"; sha256="1mpb1qx2iad4vqqxy1zxlsi0bx2cf4d98h6s7g1040hk9lpdl671"; depends=[PowerTOST]; };
   powerAnalysis = derive { name="powerAnalysis"; version="0.2"; sha256="15ff3wnn37sjkiyycgh16g7gwl3l321fbw12kv621dad5bki14jl"; depends=[]; };
-  powerGWASinteraction = derive { name="powerGWASinteraction"; version="1.0.0"; sha256="0ij843g95ypxc7cfhvi3pm57b5ry1xr2x0f944l9ncyy8d15jxc4"; depends=[]; };
+  powerGWASinteraction = derive { name="powerGWASinteraction"; version="1.1.0"; sha256="08xf7dvwz2md2y8j4bjlfr5vs7y2wxssdfpkdl0h39cdrz8y1pv2"; depends=[mvtnorm pwr]; };
   poweRlaw = derive { name="poweRlaw"; version="0.20.5"; sha256="03s4kn01q4v2wx2y5pglqycjr37076g9alp9kz915h0ckfv1i42f"; depends=[VGAM]; };
   powerMediation = derive { name="powerMediation"; version="0.1.7"; sha256="1nysqyz5rbpn25k1pi9g7gwiarm8ncyw5xxal972wv8c70lsn4ir"; depends=[]; };
   powerpkg = derive { name="powerpkg"; version="1.5"; sha256="0mbk2fda2fvyp1h5lk5b1fg398xybbjv0z6kdx7w7xj345misf7l"; depends=[]; };
   powerSurvEpi = derive { name="powerSurvEpi"; version="0.0.6"; sha256="1jsbrj35m296mkk47zcpb2haain6bf23k0xzphnb4sq8f06cmq1p"; depends=[survival]; };
-  PowerTOST = derive { name="PowerTOST"; version="1.1-13"; sha256="0w535rnwsdjad7fhrm0bxqkbci4y5qdgdy8rif3y5s5qkjhlqxnc"; depends=[mvtnorm]; };
-  PP = derive { name="PP"; version="0.2-1"; sha256="0qrmlfjfsaj1jxbpzzbh1lnsw5c9b631b7q5jxrzvg675m0wy2mr"; depends=[]; };
+  PowerTOST = derive { name="PowerTOST"; version="1.2-02"; sha256="101mzpbiwqy8d9ghsxf5gn5nsx84i7w1hm9vj9wyysxkqqimgy32"; depends=[mvtnorm]; };
+  PP = derive { name="PP"; version="0.5.3"; sha256="17y1v2536n7ap0kvllwkmndmdjf4wgwl171c053ph45krv37mscf"; depends=[Rcpp]; };
   ppcor = derive { name="ppcor"; version="1.0"; sha256="18l5adjysack86ws61xh89z5xfr83v932a0pn6ad8i8py3nd85fj"; depends=[]; };
   ppiPre = derive { name="ppiPre"; version="1.5"; sha256="1d1567h2j0y4f8jkaiszxkq13xkxq9jb3bf0rmjmy1z263nnl4a1"; depends=[igraph e1071]; };
-  ppls = derive { name="ppls"; version="1.6-0"; sha256="0jd80sfsg7j2540sz5v9n43pni9713sb1nvb5h1azbr3mnwqsri5"; depends=[MASS]; };
-  ppmlasso = derive { name="ppmlasso"; version="1.0"; sha256="0f5wld45r874rmi5bvhiqhpi5jqgrg5lwqazfhkv1md0ac2klkqj"; depends=[spatstat]; };
+  ppls = derive { name="ppls"; version="1.6-1"; sha256="1r3h4pf79bkzpqdvyg33nwjabsqfv7r8a4ziq2zwx5vvm7mdy7pd"; depends=[MASS]; };
   pps = derive { name="pps"; version="0.94"; sha256="0sirxpagqc2ghc01zc6q4dk691six9wkgknfbwaqxbxvda3hcmyq"; depends=[]; };
-  ppstat = derive { name="ppstat"; version="0.9"; sha256="1mnlvdzvayz30sbiq95wm0ywmzc168lqx0l33397jadiq5zbsbkn"; depends=[processdata reshape2 ggplot2 Matrix]; };
   PPtree = derive { name="PPtree"; version="2.3.0"; sha256="002qjdx52r2h90wzrf2r3kz8fv3nwx08qbp909whn6r4pbdl532v"; depends=[MASS penalizedLDA]; };
-  pqantimalarials = derive { name="pqantimalarials"; version="0.1"; sha256="0q7knygxcv9s7lnpzn165dqvgff6zsz25ld44rh4fddgfzlwynn8"; depends=[shiny rms reshape2 RColorBrewer plyr]; };
+  pqantimalarials = derive { name="pqantimalarials"; version="0.2"; sha256="0azxkf1rvk9cyzr4gbp4y2vcxrxw3d4f002d5gjkvv1f4kx8faw1"; depends=[reshape2 RColorBrewer plyr shiny]; };
   prabclus = derive { name="prabclus"; version="2.2-4"; sha256="1p4hhs002cyrmnmfc2s11zia2jcnafidmy41dl3bd8mqyq3d193z"; depends=[MASS mclust]; };
-  pracma = derive { name="pracma"; version="1.7.0"; sha256="1hi71m4hkyj8pvl01xl9675pza983ikigxp13i6i08bbpxsaclsm"; depends=[]; };
+  pracma = derive { name="pracma"; version="1.7.3"; sha256="11q1zbnzq1lmfiwsmy8v5zhgwg3vcmvq1ybd36n2r1gzvnzmj44p"; depends=[]; };
   PracTools = derive { name="PracTools"; version="0.0-2"; sha256="1bigir9fv6qrj3r8bfff6zyvxi10c0qh56kvhqsclvwyg3hfk5yz"; depends=[]; };
   pragma = derive { name="pragma"; version="0.1.3"; sha256="1n30a346pph4d8cj4p4qx2l6fnwhkxa8yxdisx47pix376ljpjfx"; depends=[]; };
   praktikum = derive { name="praktikum"; version="0.1"; sha256="0kkydgglvqw371fxh46fi86fmdndhwq1n8qj0ynbh2gz1cn86aw1"; depends=[]; };
   predfinitepop = derive { name="predfinitepop"; version="1.0"; sha256="1x5ri1kvd1rd9bjp2ygqwl68yp6hyb6aly22bs5kdwv2vn9nlq9w"; depends=[]; };
   PredictABEL = derive { name="PredictABEL"; version="1.2-1"; sha256="18fmafl1d4nwf7mya9gh1rlv5936zzr2jm3fwn5r2m5fc034qqjx"; depends=[Hmisc ROCR epitools PBSmodelling]; };
   PredictiveRegression = derive { name="PredictiveRegression"; version="0.1-4"; sha256="15vkisj3q4hinc3d537s8inhj3wk62q67qhy050xmp9j563ainmd"; depends=[]; };
-  predictmeans = derive { name="predictmeans"; version="0.97"; sha256="1l5b85rw96mh3xvcv5iiiy7zh8s0hx0bw037a3p49vbsw3k9p5vb"; depends=[lme4 nlme ggplot2 lattice pbkrtest plyr]; };
+  predictmeans = derive { name="predictmeans"; version="0.99"; sha256="1qfqh21d3m0k2491hv5rl5k4v49j5089xsdk3bxicp30l512rax0"; depends=[lme4 nlme ggplot2 lattice pbkrtest plyr]; };
   predmixcor = derive { name="predmixcor"; version="1.1-1"; sha256="0v99as0dzn0lqnbbzycq9j885rgsa1cy4qgbya37bbjd01b3pykd"; depends=[]; };
   prefmod = derive { name="prefmod"; version="0.8-32"; sha256="0v5r195gzbfi6jbqz8r1x2fzj3anqxf4hxaxb9krm9rkwgphrwpi"; depends=[gnm colorspace]; };
-  PReMiuM = derive { name="PReMiuM"; version="3.0.28"; sha256="0cs18ig3ykd1s1hll7bq8ii1pbw4lr9ij8qyg7jh359k9vb6m5gy"; depends=[Rcpp ggplot2 cluster plotrix]; };
+  PReMiuM = derive { name="PReMiuM"; version="3.0.30"; sha256="1xzs50gnwdjr34lgg1nb9kp0aihicvaif3fqha3ymp2lz5whbz5c"; depends=[Rcpp ggplot2 cluster plotrix]; };
   PresenceAbsence = derive { name="PresenceAbsence"; version="1.1.9"; sha256="17qn4ggkr5aqml45nkihj1j35y479ywkm1xcfkb2g8ky66jb0c0s"; depends=[]; };
-  PResiduals = derive { name="PResiduals"; version="0.1-0"; sha256="0g3div2i5sr4fbc7l6zzvaw72nbs80lkc1yv7p32w6g2cmyjhy7c"; depends=[Formula]; };
+  preseqR = derive { name="preseqR"; version="1.0.1"; sha256="0plwhgs6fgvra2w5xcjrr260fra0nl2cpsn5r1z701q7b8nbm257"; depends=[]; };
+  PResiduals = derive { name="PResiduals"; version="0.2-0"; sha256="0bjn600wq8h11spi20q3gdv9ajrvagjyw6a8pfmm3pvangasq2nl"; depends=[Formula rms sandwich actuar]; };
   prettyGraphs = derive { name="prettyGraphs"; version="2.1.5"; sha256="19jag5cymancxy5lvkj5mkhdbxr37pciqj4vdvmxr82mvw3d75m4"; depends=[]; };
   prettyR = derive { name="prettyR"; version="2.0-8"; sha256="1wz802mmsbm4011jskdvifm9p5vqjiq7x2cmxyvc6fi2g8s224rw"; depends=[]; };
-  prevalence = derive { name="prevalence"; version="0.2.0"; sha256="0yab4ig0hwyr10fgcw50hs63hbdpch83500xws05h1srsd2kiq8f"; depends=[rjags coda]; };
+  prettyunits = derive { name="prettyunits"; version="1.0.0"; sha256="0lh83pf30hnqcq6ppq8axlyawp0qxpym0lqq8pchh3gq8mgcdz1h"; depends=[magrittr assertthat]; };
+  prevalence = derive { name="prevalence"; version="0.3.0"; sha256="0hg4vpw89pyx2i9za3zg666kyi016sn4jpbk2sp0s435fzqp74dp"; depends=[rjags coda]; };
+  PrevMap = derive { name="PrevMap"; version="1.0"; sha256="1w1y4zgnfs6lj2cddwmslrwlywa3xfk8fgdrqv1j2adpj8x36rb3"; depends=[geoR maxLik raster pdist]; };
   prevR = derive { name="prevR"; version="2.9"; sha256="1h0v52pwhrb9ib61wjqdcand5prc1h205nd2rl5qiiqcnq4xn582"; depends=[sp gstat GenKern rgdal fields]; };
   prim = derive { name="prim"; version="1.0.14"; sha256="0ndzp2dj2rz6wffnc1a4bdn45vb5r6hf0niiixh0chrlakd5d4w7"; depends=[]; };
   primer = derive { name="primer"; version="1.0"; sha256="0vkq794a9qmz9klgzz7xz35msnmhdaq3f91lcix762wlchz6v7sg"; depends=[deSolve lattice]; };
···
   princurve = derive { name="princurve"; version="1.1-12"; sha256="19fprwpfhgv6n6ann978ilwhh58qi443q25z01qzxml4b5jzsd7w"; depends=[]; };
   prinsimp = derive { name="prinsimp"; version="0.8-8"; sha256="074a27ml0x0m23hlznv6qz6wvfqkv08qxh3v1sbkl9nxrc7ak4vn"; depends=[]; };
   PRISMA = derive { name="PRISMA"; version="0.2-2"; sha256="0r4dhnp0f6q43iklmwjim20hy9wjijkh8q4gljx8sph47njc0xqd"; depends=[Matrix gplots ggplot2]; };
-  PrivateLR = derive { name="PrivateLR"; version="1.1-69"; sha256="0harlkccxa51k75if5z1h29lnis1dinh2zsk2liicwyjxcnmx0ml"; depends=[]; };
+  PrivateLR = derive { name="PrivateLR"; version="1.2-21"; sha256="1jwq8f0dnngj8sfbmcmxy34nkkq6yjw0mq3w1f8rasz67v3bwzp3"; depends=[]; };
   prLogistic = derive { name="prLogistic"; version="1.2"; sha256="1abwz7nqkz2qbyqyr603kl9a3rkad3f4vxhck6a9kl80xrmfrj9s"; depends=[boot lme4 Hmisc]; };
   prob = derive { name="prob"; version="0.9-5"; sha256="05skjqimzhnk99z864466dc8qx58pavrky320il91yqyr8b98j8b"; depends=[combinat fAsianOptions hypergeo VGAM]; };
   ProbForecastGOP = derive { name="ProbForecastGOP"; version="1.3.2"; sha256="0fnw3g19lx4vs8vmn4qdirvybkiy2cxkhwkn9qa3phz45iixnvx4"; depends=[RandomFields fields]; };
   probsvm = derive { name="probsvm"; version="1.00"; sha256="1k0zysym7ncmjy9h7whwi49qsfkpxfk7chfdjrydl6hn6pscis37"; depends=[kernlab]; };
   pROC = derive { name="pROC"; version="1.7.3"; sha256="1xbz50phi2ygrgvcv36vnbc2icga8abjiha2ap35bwffg5d2zmvi"; depends=[plyr Rcpp]; };
-  processdata = derive { name="processdata"; version="0.8.2"; sha256="1rdb3chpm7c2acx5r262gcg5w02mplh6xgxlld070kb91i7drahj"; depends=[ggplot2 reshape2]; };
   ProDenICA = derive { name="ProDenICA"; version="1.0"; sha256="04gnsnd0xzw3bfbssdp06bar0lk305ry2c97pmwxgiz3ay88dfsj"; depends=[gam]; };
-  prodlim = derive { name="prodlim"; version="1.4.3"; sha256="0y18ngb1gy8zdk4dfakb57pyjll8937acbaz2lynwhbabd6kg66l"; depends=[survival KernSmooth lava]; };
+  prodlim = derive { name="prodlim"; version="1.4.5"; sha256="0p2b01i01k9qbj91sp73wg998d07cv6ppragvizz6r185m10ip35"; depends=[survival KernSmooth lava]; };
   PROFANCY = derive { name="PROFANCY"; version="1.0"; sha256="11a0fpsv1hy0djv36x2i2hv2j50ryy0x7g7nn7vv76m1sl6q6r4b"; depends=[Matrix lattice igraph]; };
   profdpm = derive { name="profdpm"; version="3.3"; sha256="07lhjavrx4fa5950w928mfpddmmnmvdapl5n6mv49m8h3bxs4nmy"; depends=[]; };
   ProfessR = derive { name="ProfessR"; version="2.3"; sha256="1y88as4xjvdm2v2ms5l7c6ziq7sll6qkrpgzdd4xnbcjx7c0g9w8"; depends=[RPMG]; };
···
   ProgGUIinR = derive { name="ProgGUIinR"; version="0.0-4"; sha256="0srhk42ssx4i096sbs4jacqjsc1ffqjxjgvpplzshlqaby1h3795"; depends=[ggplot2 svMisc MASS]; };
   prognosticROC = derive { name="prognosticROC"; version="0.7"; sha256="0lscsyll41hpfzihdavygdzqw9xxjp48dmy4i17qsx5h01jl1h4i"; depends=[survival]; };
   proj4 = derive { name="proj4"; version="1.0-8"; sha256="06r3lavgixrsa52d1v31laqcbw6fb9xn23akv39hvaib78diglv9"; depends=[]; };
-  ProjectTemplate = derive { name="ProjectTemplate"; version="0.5-1"; sha256="0fi5i9icac2rjrpmgvb9glqr6z5fr880bn8hz6djgi1n1bn2v1g8"; depends=[]; };
-  propagate = derive { name="propagate"; version="1.0-3"; sha256="1kg29c72r6yz8asm6zdjxiwkrkz8dh92iybcxmiwzifhshv4gg34"; depends=[MASS tmvtnorm Rcpp ff minpack_lm]; };
+  ProjectTemplate = derive { name="ProjectTemplate"; version="0.6"; sha256="0ijsy49gghnki5l63vg5l2awy57kbxbih618j5i5lxs44g15sa5v"; depends=[]; };
+  propagate = derive { name="propagate"; version="1.0-4"; sha256="18vyh4i4zlsmggfyd4w0zrznk75m84k08p1qa9crind04n5581j1"; depends=[MASS tmvtnorm Rcpp ff minpack_lm]; };
   PropCIs = derive { name="PropCIs"; version="0.2-5"; sha256="0wnc5h4390w4rglr7gjh6827f5r7gdhajx1iwp5fggdlm808hgq7"; depends=[]; };
   PropClust = derive { name="PropClust"; version="1.4-2"; sha256="13ac895i7ljayyqcjjmwvwar6wf1j0qssazcb5nlz8rw155qwavs"; depends=[flashClust dynamicTreeCut]; };
+  propOverlap = derive { name="propOverlap"; version="1.0"; sha256="0q72z9vbkpll4i3wy3fq06rz97in2cm3jjnvl6p9w8qc44zjlcyl"; depends=[]; };
   PropScrRand = derive { name="PropScrRand"; version="1.1"; sha256="0cj62dzg4zm8d1g8h7qmviiwm93cwplppbi0p674fmmf1wy84v9s"; depends=[]; };
   prospectr = derive { name="prospectr"; version="0.1.3"; sha256="18lh03xg6bgzsdsl56bjd63xdp16sqgr3s326sgifkkak8ffbv7q"; depends=[RcppArmadillo foreach iterators Rcpp]; };
   proteomicdesign = derive { name="proteomicdesign"; version="2.0"; sha256="01s47pgwxy4xx10f3qmbfv59gbaj0qw017kpkpsn33s8w7ad63r0"; depends=[MASS]; };
···
   proto = derive { name="proto"; version="0.3-10"; sha256="03mvzi529y6kjcp9bkpk7zlgpcakb3iz73hca6rpjy14pyzl3nfh"; depends=[]; };
   protoclass = derive { name="protoclass"; version="1.0"; sha256="17d2m6r1shgb47v8mwdg1a7f5h29m5l7f5m0nsmv0xc90s9cpvk8"; depends=[class]; };
   PROTOLIDAR = derive { name="PROTOLIDAR"; version="0.1"; sha256="0bz3071b0wlcvh40vl3dyiiixk5avsj6kjjnvlvx264i5g08rij4"; depends=[]; };
-  protr = derive { name="protr"; version="0.2-1"; sha256="0kjvq7w2pg8vdv0f7lsc6f1ksbv9f9x7p61aqfzqignz9nh792dd"; depends=[]; };
-  protViz = derive { name="protViz"; version="0.1.98"; sha256="1lw9whid25pkprhw1ivb9fjaa5vx1w5mvj3dx299bp4dqg75dns6"; depends=[Rcpp]; };
-  proxy = derive { name="proxy"; version="0.4-12"; sha256="1hjbx94c4m2v22fswdd2jkb43ixfv6qivx8qiyzm23g1965ynvii"; depends=[]; };
+  protr = derive { name="protr"; version="0.4-1"; sha256="09hl9q34qsmcz6rrsp05zy9zhgjxl3hp9g8ag6501sxlk470y80x"; depends=[]; };
+  protViz = derive { name="protViz"; version="0.2.9"; sha256="0kn2dd3za8mmb6476v3wqnymhihyavw2qsh98i4q3xdiz1g77vql"; depends=[Rcpp]; };
+  proxy = derive { name="proxy"; version="0.4-13"; sha256="1lqkv2m9xryi6504mxxgw1xmvvz5qbh887ak38aqkf8cyzc10mi1"; depends=[]; };
   pRSR = derive { name="pRSR"; version="3.0.2"; sha256="1s81mi172mwxhp786c1fl579cg87valppr0z958ssvxsvg5hbfxy"; depends=[]; };
   pryr = derive { name="pryr"; version="0.1"; sha256="1vp63v1l4myahmmbphc043x1kpmvvdhs6dr640dxi0napvkdqlq6"; depends=[stringr codetools Rcpp]; };
   PSAboot = derive { name="PSAboot"; version="1.1"; sha256="176sbjr906xk2ycl8653k7nch2h7ryxfisdy178k51f55qpvv4h9"; depends=[ggplot2 PSAgraphics Matching MatchIt modeltools party psych reshape2 rpart TriMatch]; };
   PSAgraphics = derive { name="PSAgraphics"; version="2.1.1"; sha256="05c0k94dxddyrhsnhnd4jcv6fxbbv9vdkss2hvlf3m3xc6jbwvh9"; depends=[rpart]; };
   psbcGroup = derive { name="psbcGroup"; version="1.0"; sha256="1l28sy0jys1g3nyfls9nl9vx9b6qh405a2nhx0qgxwb24l67x56n"; depends=[bayesm LearnBayes SuppDists mvtnorm]; };
   PSCBS = derive { name="PSCBS"; version="0.43.0"; sha256="1pv61ha8c2hx91hik9n6fz2gxdhijgcsdjhznaml5v1d5ba3vzjj"; depends=[R_methodsS3 R_oo R_utils R_cache matrixStats]; };
-  pscl = derive { name="pscl"; version="1.04.4"; sha256="0mm8qak7cq8qks60wx6lslii79wnkh58a31izgns35wwlflg8g6n"; depends=[MASS mvtnorm coda gam vcd lattice]; };
+  pscl = derive { name="pscl"; version="1.4.6"; sha256="13bdmnm4g36x32r0vzzcvlgks9yx44lphvm9k80m24l45mlh7sby"; depends=[MASS lattice]; };
   psd = derive { name="psd"; version="0.4-1"; sha256="1knfpgvmhrispfvlv94rnpbrjkyggqrmng65bjdjjigq83hhzywm"; depends=[fftw RColorBrewer signal zoo]; };
   psData = derive { name="psData"; version="0.1.2"; sha256="0w8kzivqrh1b6gq803rfd10drxdwgy0cxb5sff273m6jxzak52f2"; depends=[countrycode DataCombine foreign xlsx]; };
   pse = derive { name="pse"; version="0.3.4"; sha256="1ni4rwskcr326x5z81hsh36nkcrpq5d7pkqh6xyh4fjm57wjwzbp"; depends=[Hmisc boot]; };
···
   psych = derive { name="psych"; version="1.4.8.11"; sha256="110j5d7xdaviklf3mv9jlnli3l4n5g4mxasgxdj6kw7f66fqh634"; depends=[]; };
   psychometric = derive { name="psychometric"; version="2.2"; sha256="1b7cx6icixh8k3bv60fqxjjks23qn09vlcimqfv2x3m3nkf8p1s9"; depends=[multilevel nlme multilevel nlme]; };
   psychomix = derive { name="psychomix"; version="1.1-1"; sha256="0p3kidbsmfm09s7c3p8nlj069wcyln1cxmjmj5nj7f618c407zyf"; depends=[flexmix psychotools lattice Formula modeltools]; };
-  psychotools = derive { name="psychotools"; version="0.2-0"; sha256="13zpg4xi5hmr8yzjsri4kn0dy39ns5razdmchh4nwfr9gjn0h29b"; depends=[]; };
-  psychotree = derive { name="psychotree"; version="0.13-0"; sha256="1jwya7glgaz4zb81i37bvxnm712b1y34dh5s3y64lms2bd98wc4b"; depends=[party psychotools modeltools sandwich strucchange]; };
+  psychotools = derive { name="psychotools"; version="0.3-0"; sha256="0iwk1sqsbilh4k80n0kh2pv44dd9fgn6zhfl94hqgm1bbrqf9qgc"; depends=[]; };
+  psychotree = derive { name="psychotree"; version="0.14-0"; sha256="18kmiqqxfhc0ydqx18561j05xawrhg8gshw7hr8zh4j6ymga23fh"; depends=[partykit psychotools Formula]; };
   psyphy = derive { name="psyphy"; version="0.1-9"; sha256="1ndc6sy662wj2qfx7r97crlqjd8fdkfvfy59qmf34bcbzbg33riz"; depends=[]; };
   psytabs = derive { name="psytabs"; version="0.5"; sha256="0jcsv771ndf0fv76982rbv099ii4l55a8bj1mhgr54838ins0gg7"; depends=[psych plyr rtf R2HTML mokken lavaan semTools]; };
   pt = derive { name="pt"; version="1.0"; sha256="0hjijfmc9dip3ys8xg44w0fwvyzyjyjl9hpwm7j2nzg3plv6i1fz"; depends=[]; };
-  PTAk = derive { name="PTAk"; version="1.2-6"; sha256="06b59qmlz7n6nydb7d2nbv2ggfam0092qzavshgfa6p8r5vzxcj6"; depends=[tensor]; };
+  PTAk = derive { name="PTAk"; version="1.2-9"; sha256="1wbjak8dp53601z39kkpa4ysm264x32371rbgbzmyzx89ap2c0cq"; depends=[tensor]; };
   PTE = derive { name="PTE"; version="1.0"; sha256="10if2hh69yysi2y82m7is74hmzw2xpxijgb8bhy1d4g9n9lqidfs"; depends=[doParallel]; };
-  ptinpoly = derive { name="ptinpoly"; version="2.1"; sha256="0l16hvg3b7km0kh2wqzcvnn6jydvvh5mm089j15in4s1wsjn173k"; depends=[misc3d]; };
-  PtProcess = derive { name="PtProcess"; version="3.3-1"; sha256="0qh673i00z8x07zjhwazambz1myw5q342zfqfgm2f5z59v1j7m48"; depends=[]; };
+  ptinpoly = derive { name="ptinpoly"; version="2.4"; sha256="1jbj8z7lqg7w1mqdh230qjaydx2yb6ffgkc39k7dx8xl30g00i5b"; depends=[misc3d]; };
+  PtProcess = derive { name="PtProcess"; version="3.3-7"; sha256="0a180qdf1a7jhng4ihjhd2aq2d7pd9pahir6920xczxvdgp3lm0l"; depends=[]; };
   ptw = derive { name="ptw"; version="1.0-7"; sha256="195pa6hj3y9spyc7yxfgr8alkp48a7ccnyp64r6fyjwj6ds08b64"; depends=[]; };
   PubBias = derive { name="PubBias"; version="1.0"; sha256="0dr5dhfx57knrs05pbx9ngg4k2937n8gjzsgd0jfqd8dfxhy051k"; depends=[rmeta R_utils]; };
-  pubmed_mineR = derive { name="pubmed.mineR"; version="1.0.1"; sha256="0d288hx98j5k4nmzj1vc3sfjwh9i4cljfgi6vklrsvgn5sx39x91"; depends=[RCurl XML NCBI2R boot R2HTML]; };
-  PubMedWordcloud = derive { name="PubMedWordcloud"; version="0.3.1"; sha256="1bq2jswhc3vr84x6a9fspygirl54z7b1pdlcpnd7g4374ypvlrrz"; depends=[XML stringr RCurl wordcloud tm GOsummaries RColorBrewer]; };
+  pubmed_mineR = derive { name="pubmed.mineR"; version="1.0.2"; sha256="0r3n4116z3f4yf3rglq3r34qfv2qcb01hwgmzm7d7q07cx9p5lqk"; depends=[RCurl XML NCBI2R boot R2HTML]; };
+  PubMedWordcloud = derive { name="PubMedWordcloud"; version="0.3.2"; sha256="1xn4ygpvj6pm548yj5kjh2l8n59p2caihfpbkykvbkzgf7hq8p00"; depends=[XML stringr RCurl wordcloud tm RColorBrewer]; };
   pumilioR = derive { name="pumilioR"; version="1.3"; sha256="1zmcdp978p73bh9fdshxlrzgfg18j007xgxgr439rq90bwiwva6j"; depends=[XML RCurl]; };
   PurBayes = derive { name="PurBayes"; version="1.3"; sha256="0nbm4cyrwfbwwbjbjkylr86cshaqbvbif6dkp4fag8kbcgyyx5qh"; depends=[rjags]; };
   pushoverr = derive { name="pushoverr"; version="0.1.3"; sha256="18bxipbrcv8anrvdmgff1674b735x0zp6bwf319cgxsgbs9nlwqi"; depends=[httr]; };
   PVAClone = derive { name="PVAClone"; version="0.1-2"; sha256="0afl2il5wdcwzpyhjkgq8iz16q1086c3ndr4cjlyspgbss9h5l24"; depends=[dcmle dclone]; };
   pvar = derive { name="pvar"; version="1.0.9"; sha256="01bkva4kna1vfjlsss16s6501l8x2s95a5wh7wsmwq3spdgp1i2r"; depends=[]; };
   pvclass = derive { name="pvclass"; version="1.1"; sha256="0qaj71qrcj0kgwb1xravylqfc2b1ww5h8l4pdd2m0x33aygrm0kk"; depends=[Matrix]; };
-  pvclust = derive { name="pvclust"; version="1.2-2"; sha256="152qwvk4lpdsrv96148bc3z51jqdaa7p95ql2zhpb7a2fvzs5ad5"; depends=[]; };
+  pvclust = derive { name="pvclust"; version="1.3-0"; sha256="1cm1m6ps90qn7lyi16vjnjwllzd6lmvwpipmdwnbq6zgnwjcn2iz"; depends=[]; };
   PVR = derive { name="PVR"; version="0.2.1"; sha256="1p87pj9g0qlc8ja6xdj2amny9pbkaqb34x2y9nkl1nj1pkwjq2s5"; depends=[ape splancs]; };
-  pvsR = derive { name="pvsR"; version="0.2"; sha256="1liykrh05k4qlfh1b61rafvgzx99fl9nh75a6mr5z5zczn8i00mv"; depends=[XML nnet httr]; };
+  pvsR = derive { name="pvsR"; version="0.3"; sha256="1ijmqlcsc8z0aphdd3j37ci8yqsy50wnr2fwn7h8fxbyd12ax2nj"; depends=[XML nnet httr]; };
   pwr = derive { name="pwr"; version="1.1.1"; sha256="1is6kqqjf3bzsddj4advj8qcp30rz2zlqc0g98072m96nmq5ywgn"; depends=[]; };
   PwrGSD = derive { name="PwrGSD"; version="2.000"; sha256="0qxvws9mfrnqw5s24qhqk6cbffjm13z7awyxdmnilazghpiq1p7s"; depends=[survival]; };
   pwt = derive { name="pwt"; version="7.1-1"; sha256="0926viwmwldmzlzbnjfijh00wrhgb0h4h0mlrls71pi5pjfldifa"; depends=[]; };
   pwt8 = derive { name="pwt8"; version="8.0-0"; sha256="12cgyban6waj0cxz9gb35s5v0v29rmx67ipzalzdnrjp5nsmy431"; depends=[]; };
   pxR = derive { name="pxR"; version="0.40.0"; sha256="08s62kzdgak7mjzyhd32qn93q5l7sj01vhsk7fjg9nxjvm78xxka"; depends=[stringr reshape2 RJSONIO plyr]; };
-  pyramid = derive { name="pyramid"; version="1.3"; sha256="1jmcqzgxqwvfa9aidayjx6j1s9f3kwqvivwldwpkf780i9wkdig9"; depends=[]; };
-  qat = derive { name="qat"; version="0.72"; sha256="0vs7xc32h9s5p7486cafzzll7xaby7lbqmmpnshkn8mq021xlxkg"; depends=[ncdf gplots XML gdata moments boot fields]; };
+  pxweb = derive { name="pxweb"; version="0.4"; sha256="00i1iyjvp4ds99xa94cada09qxsnh62cj6ad741l4jd5zfh3ks9g"; depends=[data_table plyr stringr RJSONIO httr]; };
+  pycno = derive { name="pycno"; version="1.2"; sha256="0ha5css95xb98dq6qk98gnp1al32gy6w5fkz74255vs4hmkwfzw2"; depends=[sp maptools rgeos]; };
+  pyramid = derive { name="pyramid"; version="1.4"; sha256="0hh0hmckicl0r2r9zlf693j65jr9jgmiz643j2asp57nbs99lgxz"; depends=[]; };
+  qat = derive { name="qat"; version="0.73"; sha256="1fff4sv1n3i0gfgj83sy4pygxalifdycm27hsw51r72n86049cdc"; depends=[ncdf XML gdata moments boot fields gplots]; };
   QCA = derive { name="QCA"; version="1.1-3"; sha256="083hc00d7srvxfkfax51ffngidbdhjqaxga3lln5gw53m2831v35"; depends=[lpSolve]; };
   QCA3 = derive { name="QCA3"; version="0.0-7"; sha256="0i9i2i633sjnzsywq51r2l7fkbd4ip217hp0vnkj78sfl7zf1270"; depends=[lpSolveAPI]; };
   QCAGUI = derive { name="QCAGUI"; version="1.9-6"; sha256="020ngni02j2w2ylhyidimm51d426pym2g1hg7gnpb7aplxx67n6x"; depends=[abind QCA]; };
-  qcc = derive { name="qcc"; version="2.5"; sha256="1j2l4i1vy8wqsl64r0qmc8dflyn1abbmzhpqqsmhwldifcdbdsb9"; depends=[MASS]; };
+  qcc = derive { name="qcc"; version="2.6"; sha256="0bsdgpsqvkz2w1qanxwx8kvrpkpzs9jgw8ml2lyqhmhqbxyg125r"; depends=[MASS]; };
   QCGWAS = derive { name="QCGWAS"; version="1.0-8"; sha256="1wn1kddgfmqv326pihnavbgsbd2yxrlq5s2xgi6kbprssxvj8bk1"; depends=[]; };
   qcr = derive { name="qcr"; version="0.1-18"; sha256="16dfda3rwivsdhp7j5izzbk2rzwfabfmxgpq4kjc4h7r90n2vly2"; depends=[qcc]; };
-  qdap = derive { name="qdap"; version="2.1.1"; sha256="1in345544gspj7wki82gdaiaxzn5qcp5jz73n522gjnybymllv2b"; depends=[ggplot2 qdapDictionaries qdapTools RColorBrewer chron dplyr gdata gridExtra igraph NLP openNLP plotrix RCurl reports reshape2 scales stringdist tm venneuler wordcloud xlsx XML]; };
+  qdap = derive { name="qdap"; version="2.2.0"; sha256="0lbc38x4gvh6q2sb6d524ksfhpvxm8knfy85bmwbf6d3q4s0b6q4"; depends=[ggplot2 qdapDictionaries qdapRegex qdapTools RColorBrewer chron dplyr gdata gender gridExtra igraph NLP openNLP plotrix RCurl reports reshape2 scales stringdist tm venneuler wordcloud xlsx XML]; };
   qdapDictionaries = derive { name="qdapDictionaries"; version="1.0.2"; sha256="0s1dqp3hjllkvq638hvggcbfsdwks91r0ymynl7cdh7dr5pg91bc"; depends=[]; };
-  qdapTools = derive { name="qdapTools"; version="1.0.2"; sha256="1vvgcj0cymfc8yqw3i8jzr199hq04z7y86qgljdl86v4xvl44ggv"; depends=[chron data_table RCurl]; };
-  qfa = derive { name="qfa"; version="0.0-10"; sha256="1c6yh5fa45fk3g9hi905b2cjswn6gmn53f0gb5v5byb9gr9bjf7s"; depends=[sp DEoptim]; };
+  qdapRegex = derive { name="qdapRegex"; version="0.1.2"; sha256="1fn6rsjh76qh4kscb43gld06bs5k3v6hkn4viccw0ixzv3x6pq7k"; depends=[stringi]; };
+  qdapTools = derive { name="qdapTools"; version="1.0.3"; sha256="15ba12vk923l71lbhdhqq2pv6nqrdgm3ljsq7k818l40j7z1376a"; depends=[chron data_table RCurl]; };
+  qdm = derive { name="qdm"; version="0.1-0"; sha256="0cfxyy8s5zfb7867f9xv9scq9blq2qnw68x66m7y7nqlrrff5xdr"; depends=[]; };
   qgraph = derive { name="qgraph"; version="1.2.5"; sha256="1jgjxfds28kk03qrk01r8dla4xjpbqcqdwa1ifay2vqahwlkpz65"; depends=[psych ellipse lavaan sem plyr Hmisc igraph jpeg png colorspace Matrix sna corpcor reshape2 ggplot2 glasso huge]; };
+  qgtools = derive { name="qgtools"; version="1.0"; sha256="0irqfaj2qqx7n1jfc0kmfpgzqrhwwlj0qizsmya94zk9d27bcpn5"; depends=[Matrix MASS]; };
   qiimer = derive { name="qiimer"; version="0.9.2"; sha256="08625hz2n7yk9zk1k9sa46n2ggbw5qs0mlqkmzyjjh3qlnb1354a"; depends=[pheatmap]; };
   qlcMatrix = derive { name="qlcMatrix"; version="0.9.2"; sha256="1d8953bj69d0nia3qh3s1djf9m7wkvfdxqd234026gh1d3qchkr2"; depends=[Matrix]; };
   qLearn = derive { name="qLearn"; version="1.0"; sha256="1ilxmgazm8gjz8c1hhbp4fccibnvnalxrag8b0rn081zsqmhf094"; depends=[]; };
   qlspack = derive { name="qlspack"; version="2.2"; sha256="0b9sqvnvldhd8vymajrbql0vn70rml13jgsq5ihm6skzq5qms7y6"; depends=[geepack]; };
   qmap = derive { name="qmap"; version="1.0-3"; sha256="1c7qvmd5whi446nzssqvhz1j2mpx22nlzzdrcql84v18ry0dr18m"; depends=[fitdistrplus]; };
-  qmethod = derive { name="qmethod"; version="1.1"; sha256="0ygmprfjwx1bi3pi9iqq15m243vy9f90znyf4qwp0zwbbpxyaqi5"; depends=[psych GPArotation]; };
+  qmethod = derive { name="qmethod"; version="1.2.2"; sha256="02qa8vnn5p4zqkak8m7j7n35pkn9m8y5n6g70wdmkklnmj2nzgzs"; depends=[psych GPArotation]; };
   qmrparser = derive { name="qmrparser"; version="0.1.4"; sha256="1lw8sn4qsdv4bxf5p7gnkm0vmiymyj03svbl232zyyb0fh97i7nk"; depends=[]; };
   QoLR = derive { name="QoLR"; version="1.0"; sha256="1ah6x1fcs4l571jvgm0c257cgxhhpkzfhqimwbb9j7xbz3h55lp3"; depends=[survival zoo]; };
   qp = derive { name="qp"; version="0.3-2"; sha256="1964bj2ggmpaqz0rnmc2zx5hyrzawlmawz3mh046cx1pdzlsqfwh"; depends=[]; };
-  qpcR = derive { name="qpcR"; version="1.3-9"; sha256="1dbxy7al75d7zjwg8kgvmmddfklj13hq9nb1vyblmzcsa59rx91s"; depends=[MASS minpack_lm rgl robustbase Matrix]; };
+  qpcR = derive { name="qpcR"; version="1.4-0"; sha256="029qhncfiicb3picay5yd42g6qi0x981r6mgd67vdx71cac9fp59"; depends=[MASS minpack_lm rgl robustbase Matrix]; };
   qPCR_CT = derive { name="qPCR.CT"; version="1.1"; sha256="19j41fsd2m7p2nxi2h2mj43rjxx6sz2jpf4sk0bfvl1gyj0iz3hi"; depends=[RColorBrewer]; };
-  qqman = derive { name="qqman"; version="0.1.1"; sha256="1j77i2lz2rp2kgsfsfv6zf9ai8ffylmkrfiq2rv53vmrq92h407c"; depends=[]; };
+  qqman = derive { name="qqman"; version="0.1.2"; sha256="024ln79hig5ggcyc3466r6y6zx2hwy2698x65cha5zpm51kq1abs"; depends=[]; };
   qrfactor = derive { name="qrfactor"; version="1.4"; sha256="0f02lh8zrc36slwqy11x03yzfdy94p1lk5jar9h5cwa1dvi5k8gm"; depends=[mvoutlier mgraph pvclust cluster maptools]; };
   QRM = derive { name="QRM"; version="0.4-10"; sha256="1fkxjqyb9yqki4qwk393ra66wg5dnbr5b5sgypm8wk973crbhcj0"; depends=[gsl Matrix mvtnorm numDeriv timeSeries Rcpp mgcv]; };
   qrnn = derive { name="qrnn"; version="1.1.2"; sha256="01wsz9qcdiayi7gsyy2y09jyyapanyhlc4pdyman2f7z5nl9yv9i"; depends=[]; };
   QSARdata = derive { name="QSARdata"; version="1.3"; sha256="0dhldnh0jzzb4assycc0l14s45ymvha48w04jbnr34lrwgr9krh4"; depends=[]; };
   qtbase = derive { name="qtbase"; version="1.0.4"; sha256="02yilvywkcqn3y9ayix18cgkwhi0gh69fl3fcw28fs2zxf1hqy75"; depends=[]; };
-  qtl = derive { name="qtl"; version="1.32-10"; sha256="0ywgsjfyjvnfisd2hnh2f5rqjhy0znnf2c1qjdqfx6g7vh3hblr1"; depends=[]; };
+  qtl = derive { name="qtl"; version="1.34-17"; sha256="0i5pqsrka0s1a5ak782a0vg5852waazq11cyfhf3ck6lgqbba462"; depends=[]; };
   qtlbim = derive { name="qtlbim"; version="2.0.7"; sha256="0nm7ky5bkzhmfr41fs1pvl51i2df1fz11j55q74ma2wzki5adfps"; depends=[qtl lattice coda MASS]; };
   qtlbook = derive { name="qtlbook"; version="0.18-1"; sha256="09b4w7kqdlmpf0vsjgwbi9sraafzchvk18yzrx72gs151v03nxlm"; depends=[qtl]; };
   qtlDesign = derive { name="qtlDesign"; version="0.941"; sha256="138yi85i5xiaqrns4v2hw46b731bdgnb301wg2h4cfrxvrw4l0d5"; depends=[]; };
···
   QTLRel = derive { name="QTLRel"; version="0.2-14"; sha256="05x56a8fjr6xk38dphdzh77y520cr6zykjp3qlx27drk9s5z06cs"; depends=[gdata]; };
   qtpaint = derive { name="qtpaint"; version="0.9.0"; sha256="06yqakg134mks8q7a40f5knjpcm1k2wdzchs0ywvfpwvpwgwig01"; depends=[qtbase qtbase]; };
   qtutils = derive { name="qtutils"; version="0.1-3"; sha256="018k9v3mab1mfcjh4mv1a1iish50fwdhb51mqn17k6fyrrrv7vs5"; depends=[qtbase qtbase]; };
-  QuACN = derive { name="QuACN"; version="1.7.4"; sha256="1bcvnzycw7xvnms41rqsnfvggvcmpaw6byrsdzqmg7z0q754b1j4"; depends=[combinat Rmpfr igraph]; };
   quad = derive { name="quad"; version="1.0"; sha256="0fak12l19f260k0ygh6zimx8dabzsv7a9i2njw8hnfcs3ndffhv5"; depends=[PearsonDS]; };
   quadprog = derive { name="quadprog"; version="1.5-5"; sha256="0jg3r6abmhp8r9vkbhpx9ldjfw6vyl1m4c5vwlyjhk1mi03656fr"; depends=[]; };
   quadrupen = derive { name="quadrupen"; version="0.2-4"; sha256="0gs565zi5qkccr9f65smvzgq2d97p7i5inksp2492bjvqhsbagxj"; depends=[Rcpp ggplot2 Matrix reshape2 scales]; };
   qualCI = derive { name="qualCI"; version="0.1"; sha256="09mzsy5ryyrn1gz9ahrh95cpfk7g09pmjjy0m82fh4xc7j5w6kpf"; depends=[combinat]; };
-  qualityTools = derive { name="qualityTools"; version="1.54"; sha256="0qrxf47fv56c86p0mmg3l3qvx8p3rvapffwhaw4yn4kbp7yiap5d"; depends=[]; };
+  QualInt = derive { name="QualInt"; version="1.0.0"; sha256="1ms96m3nz54848gm9kdcydnk5kn2i8p1rgl2dwn7cqcqblfvsr4j"; depends=[survival ggplot2]; };
+  qualityTools = derive { name="qualityTools"; version="1.54"; sha256="0ylp5a49b4q4max4yz30ia7r12s4jrvqn9zx5a21qcnpinf8b932"; depends=[]; };
   qualV = derive { name="qualV"; version="0.3"; sha256="0cr3jlp0y83nk6i965bd6v86sl8pjx47z1y20lcygrf5cb6m4ifw"; depends=[KernSmooth]; };
   Quandl = derive { name="Quandl"; version="2.3.2"; sha256="0dx6myf5gw7dvhglsc60hwq8nsj73zz3gcqcad1z3d27acv2q7m0"; depends=[RCurl RJSONIO zoo xts]; };
   quantchem = derive { name="quantchem"; version="0.13"; sha256="1ga5xa7lsk04flfp1syjzpnvj3i2ypzh1m49vq1xkdwpm6axdy8n"; depends=[MASS outliers]; };
-  QuantifQuantile = derive { name="QuantifQuantile"; version="0.2"; sha256="0h0bc81y21zag0kgfr5i9rk74m32qg0x5a8n9pvm2f6c0126q7vi"; depends=[rgl]; };
-  quantmod = derive { name="quantmod"; version="0.4-0"; sha256="12411ykj1f1ni5y00ma3kr5h5fsi0rqkshz7501wykj926js9v5j"; depends=[Defaults xts zoo TTR]; };
+  QuantifQuantile = derive { name="QuantifQuantile"; version="1.0"; sha256="0r3yz8k68z6c751r0ryxv744spch4aws50313miq498r5mvr4w1y"; depends=[rgl]; };
+  quantmod = derive { name="quantmod"; version="0.4-2"; sha256="02krcvm320pb4wlzq7x34a605cwlnizc42ar64i8sif49hin1agj"; depends=[xts zoo TTR]; };
   QuantPsyc = derive { name="QuantPsyc"; version="1.5"; sha256="1i9bh88r8zxndzjqsj14qw64gnvm5a9kvhjhzk3qsrvl3qzjgh93"; depends=[boot MASS]; };
   quantreg = derive { name="quantreg"; version="5.05"; sha256="07djmdlmij9add2sgdsb1p6521hlnsfmll8lqs3x0z9gmr2wyx4f"; depends=[SparseM]; };
   quantregForest = derive { name="quantregForest"; version="0.2-3"; sha256="06c73f66nnw3vd2dv8h5skzyxbr89i3pyprbb0if721h5d7pm0s7"; depends=[randomForest]; };
···
   r2d2 = derive { name="r2d2"; version="1.0-0"; sha256="1zl0b36kx49ymfks8rm33hh0z460y3cz6189zqaf0kblg3a32nsi"; depends=[KernSmooth MASS sp]; };
   r2dRue = derive { name="r2dRue"; version="1.0.4"; sha256="1apdq7zj5fhs349wm9g6y06nn33x24pg3gdp4z1frd18qlacf8z5"; depends=[rgdal sp matrixStats]; };
   R2G2 = derive { name="R2G2"; version="1.0-2"; sha256="05d5vybvsi4pyr099916nk1l8sqszs9gaj2vhsx1jxxks8981na7"; depends=[]; };
-  R2GUESS = derive { name="R2GUESS"; version="1.3"; sha256="1jqzh2f9qwwmcf16hjgnl3rgp49zx6m090r750p3n4ds3qr96zx7"; depends=[fields MCMCpack mixOmics mvtnorm snowfall]; };
-  R2HTML = derive { name="R2HTML"; version="2.2.1"; sha256="11p0mg6b39z2w7k76j21hy09r8fm3rwkiby2lmhx5cgvnvxgrqf1"; depends=[]; };
+  R2GUESS = derive { name="R2GUESS"; version="1.5"; sha256="07bn52jbgkglp74ial592cd0xcq9273xjpms792sswy0h07z3zwx"; depends=[fields MCMCpack mixOmics mvtnorm snowfall]; };
+  R2HTML = derive { name="R2HTML"; version="2.3.1"; sha256="01mycvmz4xd1729kkb8nv5cl30v3qy3k4fmrlr2m1112hf5cmp59"; depends=[]; };
   R2jags = derive { name="R2jags"; version="0.04-03"; sha256="0wygsz5zzng8fh82pzhqly3d532ljz0jj34h9nz7g3v5asv0kcqm"; depends=[rjags abind coda R2WinBUGS]; };
   r2lh = derive { name="r2lh"; version="0.7"; sha256="1kkyjv9x2klrjnaaw4a16sxdfqmpp9s5mlclzlczlqjypbf2aa6d"; depends=[]; };
   R2OpenBUGS = derive { name="R2OpenBUGS"; version="3.2-2.2"; sha256="0hnp46linvpnzifhyb3r13xmwvdc3psabs53xl6qxxm4snrl4bnd"; depends=[coda boot]; };
···
   R2WinBUGS = derive { name="R2WinBUGS"; version="2.1-19"; sha256="03bvxv46lhhnbfjq3w5ig50icncwn1bdq7lsh6w1szdk90ah2zgh"; depends=[coda boot]; };
   R330 = derive { name="R330"; version="1.0"; sha256="01sprsg7kph62abhymm8zfqr9bd6dhihrfxzgr4pzi5wj3h80bjm"; depends=[s20x leaps rgl lattice]; };
   R4CDISC = derive { name="R4CDISC"; version="0.2"; sha256="1g8n89y1l5jy3168qz9j0kz3dvyadhn5mhilpzlpn3pijvv2vndf"; depends=[XML]; };
-  R4CouchDB = derive { name="R4CouchDB"; version="0.4"; sha256="15177dwwnhl6mfvb78knhmjqi34pb74dcgb9rf9j0rvy85vznzzm"; depends=[bitops RCurl RJSONIO]; };
+  R4CouchDB = derive { name="R4CouchDB"; version="0.6"; sha256="0d32p5jl1fw2190dvn46hfw2j7v849ps5a00j18jky2gl4blvghs"; depends=[bitops RCurl RJSONIO]; };
   R4dfp = derive { name="R4dfp"; version="0.2-4"; sha256="02crzjphlq4hi2crh9lh8l0acmc1rgb3wr1x8sn56cwhq4xzqzcb"; depends=[]; };
   r4ss = derive { name="r4ss"; version="1.22.1"; sha256="1rjnglwa3i8rlzyqqr5h8yh7vglrh8zpd3829qcc1vfi4swcwwqw"; depends=[coda corpcor gplots gtools maps pso RCurl]; };
-  R6 = derive { name="R6"; version="1.0.1"; sha256="0q1ni6g0i3h2l7dj8fip1614likdki8apmrjs7ggma77qfc5jsaf"; depends=[]; };
+  R6 = derive { name="R6"; version="2.0.1"; sha256="0ngm3hl0q3aj067q6q0iqh729z8jx3ydvasj1jw9qrr7bzjh1jn5"; depends=[]; };
   race = derive { name="race"; version="0.1.59"; sha256="13jprlnngribgvyr7fbg9d36i8qf3cax85n71dl71iv0y24al1cy"; depends=[]; };
   RAD = derive { name="RAD"; version="0.3"; sha256="0nmgsaykxavq2bskq5x0jvsxzsf4w2gqc0z80a59376li4vs9lpj"; depends=[mvtnorm MASS]; };
   RADami = derive { name="RADami"; version="1.0-3"; sha256="0rg07dsh2rlldajcj0gq5sgsl1i3qa28bsrmq88xcljg5hnr4iqn"; depends=[ape geiger phangorn]; };
-  RadioSonde = derive { name="RadioSonde"; version="1.3"; sha256="1bvy281v278dni7ms4mq963463mwsj1bys9n2lvn6y8p7jhqvhdj"; depends=[]; };
+  RadioSonde = derive { name="RadioSonde"; version="1.4"; sha256="1v9jdpynmb01m3syhas1s08xxlvjawhlvjkyhils2iggi4xw4hiq"; depends=[]; };
   RadOnc = derive { name="RadOnc"; version="1.0.8"; sha256="1p74fbihbzfn6irc8khp4kvmsxd7scg3c2nkr7w0p7c75f76d9an"; depends=[rgl geometry oro_dicom ptinpoly]; };
+  RAdwords = derive { name="RAdwords"; version="0.1"; sha256="0zpss4sw3nx3zc1b4py7zp2075vaqjlrhppqgrkdqvznl87p3fki"; depends=[RCurl rjson]; };
   rags2ridges = derive { name="rags2ridges"; version="1.3"; sha256="1dzpaxvlrbpj2hw2p2gfhqvrlg5jdpd5z6q0dzxjdxh8z7xjsklb"; depends=[GeneNet expm reshape ggplot2 igraph Hmisc]; };
   RAHRS = derive { name="RAHRS"; version="1.0.1"; sha256="068alq0mrfgcmpa5gfrrqgixpdadva11s9ammg7p6g9lfrjx6gcc"; depends=[pracma RSpincalc]; };
   rainbow = derive { name="rainbow"; version="3.2"; sha256="043qbbyb1i7b8n3vspr6rdwlpqg3wdn31rsq3hmlahvwrfqma70n"; depends=[MASS pcaPP hdrcde cluster colorspace ks]; };
-  raincpc = derive { name="raincpc"; version="0.2"; sha256="02551m1rjws8h7shdms5q4rmskqdwijfx7306wp1cl7x0gjc800q"; depends=[SDMTools]; };
-  rainfreq = derive { name="rainfreq"; version="0.1"; sha256="1km77iks570w48xkad5giirw8yphlnnpv5j2fkh1nd9bqarwjxyb"; depends=[RCurl SDMTools]; };
+  raincpc = derive { name="raincpc"; version="0.4"; sha256="0yzpyidvf24frf82pj7rarjh0ncm5dhm0mmpsf2ycqlvp0qld10i"; depends=[SDMTools]; };
+  rainfreq = derive { name="rainfreq"; version="0.2"; sha256="0ryvgfi685lpsm7lqz1rnpsapw308pjxs47nvfg1nd6vp63vq3qk"; depends=[RCurl SDMTools]; };
   rAltmetric = derive { name="rAltmetric"; version="0.3"; sha256="0jq5w5yd1cps4npbm9wmrjb5vc36y89ib986ggqycd9jalmshxjd"; depends=[plyr RCurl reshape2 png ggplot2 RJSONIO]; };
+  RAM = derive { name="RAM"; version="1.1.0"; sha256="0l4daqrrcmj424k7x9jr8lpcqlhx000m71ayv3i3cchdq87xmzhf"; depends=[vegan ggplot2 gridExtra RColorBrewer gplots plyr reshape2 scales labdsv stringr ggmap permute]; };
   Rambo = derive { name="Rambo"; version="1.1"; sha256="1yc04xsfkc54y19g5iwambgnlc49ixjjvfrafsgis2zh5w6rjwv8"; depends=[sna]; };
   RAMpath = derive { name="RAMpath"; version="0.3.8"; sha256="1p1l6iirb314n5246kyyz0r3ja4v05xb5a6aq9k26wsb5m42x85k"; depends=[lavaan ellipse]; };
   ramps = derive { name="ramps"; version="0.6-12"; sha256="128lqfkgmcbcfvs210j14h54spqjcr4jdhk2rqgrwcjp5wjv209w"; depends=[coda maps Matrix nlme fields]; };
   randaes = derive { name="randaes"; version="0.3"; sha256="14803argy0xdd8mpn4v67gbp90qi2is4x6na9zw7i9pm504xji1x"; depends=[]; };
   random = derive { name="random"; version="0.2.2"; sha256="0h3vmd581i0srf9lfdgjv8kkinxf1kjg8aia0dhr5adghqvf5dck"; depends=[]; };
-  RandomFields = derive { name="RandomFields"; version="3.0.35"; sha256="0m3hv7rmipc36059iv8igy3r783by8zi854c4gm8awzdav3wdv4a"; depends=[sp]; };
+  RandomFields = derive { name="RandomFields"; version="3.0.44"; sha256="1id0n7b78s3s677vi4n49azhm6cqqnrihsxi86slvmm3mzdnzrby"; depends=[sp colorspace spam tcltk2 tkrplot]; };
   randomForest = derive { name="randomForest"; version="4.6-10"; sha256="0glj08w6sbabr3n71kzd5w3jb7vhrys8rq904j27a4xk0qp4s5lv"; depends=[]; };
-  randomForestSRC = derive { name="randomForestSRC"; version="1.5.4"; sha256="0bk7xg1lhi2mhqjnmgls4c0jf5d463pzzp1x4wkf0jal3yjgl4y3"; depends=[]; };
+  randomForestSRC = derive { name="randomForestSRC"; version="1.5.5"; sha256="1n1zpcppx1x3q871ynyx083397h86zrp5c0ldbv6b4wsz6ja6lv1"; depends=[]; };
   randomGLM = derive { name="randomGLM"; version="1.02-1"; sha256="031338zxy6vqak8ibl2as0l37pa6qndln0g3i9gi4s6cvbdw3xrv"; depends=[MASS foreach doParallel]; };
-  randomizationInference = derive { name="randomizationInference"; version="1.0.1"; sha256="1l4h9d0r199z775da0la30qijm8xikmbfnl7av7h1ar305ph6r2v"; depends=[permute matrixStats]; };
+  randomizationInference = derive { name="randomizationInference"; version="1.0.2"; sha256="1qxl88r5xai7z4sh0xxv225fzmslrbzfgrqx1ab5zm1i1w8g55yv"; depends=[permute matrixStats]; };
   randomizeBE = derive { name="randomizeBE"; version="0.3-1"; sha256="06hj614wp9lb348qwyqgw5zk2vn0m81bkwz4jprgjd72kpy8kv1h"; depends=[]; };
-  randomLCA = derive { name="randomLCA"; version="0.8-7"; sha256="1xs2jh0parvqjm88cs2w2yb8r4ld6643fn84w35v8jsffbs98522"; depends=[lattice nlme boot]; };
+  randomLCA = derive { name="randomLCA"; version="1.0-0"; sha256="01c7bnykh7vrkn4xcr1hpqrhrdn4112xicfa3i8a21gd7g2wnvka"; depends=[lattice boot fastGHQuad]; };
   randomNames = derive { name="randomNames"; version="0.0-6"; sha256="18fyxpqj6xv933nyv4s59wv7pgl4wra123qmf0fa68gk1zj9l153"; depends=[data_table]; };
   random_polychor_pa = derive { name="random.polychor.pa"; version="1.1.4-1"; sha256="1051v7krrawdqnhz9q01rsknp2i7iv82d370q7m9i9d9i8wfnpk5"; depends=[psych nFactors boot MASS mvtnorm sfsmisc]; };
   randomSurvivalForest = derive { name="randomSurvivalForest"; version="3.6.4"; sha256="1k08q43rxlz822rqzz3nvy40646764c8ds25ylsvg6daan2qzzmv"; depends=[]; };
-  randomUniformForest = derive { name="randomUniformForest"; version="1.0.6"; sha256="0qmkg8nbz3pv11yvwp45kkl3vl7mn1bgqhp5j13vr9c1gc732pgh"; depends=[Rcpp doParallel foreach ggplot2 pROC gtools]; };
+  randomUniformForest = derive { name="randomUniformForest"; version="1.0.8"; sha256="0yrjws6in58340dzs7v91v76s4bn0c9j3a6ng6bj65frijry3z5d"; depends=[Rcpp doParallel iterators foreach ggplot2 pROC gtools]; };
   randtests = derive { name="randtests"; version="0.3"; sha256="0v5hbbmx7cl1q8bfgk9141hqbimch5fkhcbr9xfxidydxyl9jqln"; depends=[]; };
   randtoolbox = derive { name="randtoolbox"; version="1.15"; sha256="02knvk0ln6x0hlpbvvpll0dnb5d7s3n6zn5kdxih792y5yihiwbh"; depends=[rngWELL]; };
   RandVar = derive { name="RandVar"; version="0.9.2"; sha256="04hw4v2d9aa8z9f8wvwbzhbfy8zjl5q8mpl9b91q86fhh1yq5cz4"; depends=[distr distrEx]; };
-  rangeMapper = derive { name="rangeMapper"; version="0.2-6"; sha256="1p4i677s7hc74snsk0vwswxp493ijwynsfmzjkrslzk819ng7zii"; depends=[RSQLite rgdal sp raster maptools RSQLite_extfuns lattice RColorBrewer classInt]; };
-  RankAggreg = derive { name="RankAggreg"; version="0.4-3"; sha256="0m9wndpfgiy9cf2ss1vk7f09yl0qiqhx48kn1qid69vhv73nsyf3"; depends=[gtools clValid]; };
+  rangeMapper = derive { name="rangeMapper"; version="0.2-8"; sha256="0bxb37gy98smypjj27r3dbd0vfyvaqw2p25qv07j3isykcn2pxpn"; depends=[RSQLite rgdal sp rgeos raster maptools lattice RColorBrewer classInt]; };
+  RankAggreg = derive { name="RankAggreg"; version="0.5"; sha256="1c5ckk2pfkdxs3l24wgai2xg817wv218fzp7w1r3rcshxf0dcz2i"; depends=[gtools]; };
   Rankcluster = derive { name="Rankcluster"; version="0.92.9"; sha256="172jjsyc6a5y32s2fb8z6lgcq6rcwjbk3xnc5vvkhj64amlyxla6"; depends=[Rcpp]; };
   rankhazard = derive { name="rankhazard"; version="1.0"; sha256="1kylg8yjrixbv86i2ffhhn8f5shsj8kvi66k202ari0li92y7dsg"; depends=[survival]; };
-  RankResponse = derive { name="RankResponse"; version="3.0.3"; sha256="0bl0w8dzwn73psiln4bkilq1l1bn1jnh4mmvblvb3wnms8srhrpv"; depends=[]; };
+  RankResponse = derive { name="RankResponse"; version="3.1.1"; sha256="04s588zbxcjgvpmbb2x46bbf5l15xm7pwiaxjgc1kn1pn6g1080c"; depends=[]; };
   RANN = derive { name="RANN"; version="2.4.1"; sha256="13d2wi3r4b190f6s6y4zipqf43gy9c1h71b9j7qmc3lqca4nvzmd"; depends=[]; };
   RAP = derive { name="RAP"; version="1.1"; sha256="18dclijs72p6gxawpg8hk7n512ah4by5jfg2jnrp8mz79ajmdgir"; depends=[]; };
   RapidPolygonLookup = derive { name="RapidPolygonLookup"; version="0.1"; sha256="0m6r11ksryzcfcm265wr9fhwb867j9ppfhalvvygzig5j85sg92k"; depends=[sp RANN PBSmapping RgoogleMaps]; };
   RAPIDR = derive { name="RAPIDR"; version="0.1"; sha256="06lhsjy7s71p5bcpln999smvr6n1fp5qfbr7i8wjcn4p1ddcfdcm"; depends=[data_table PropCIs]; };
   RApiSerialize = derive { name="RApiSerialize"; version="0.1.0"; sha256="0gm2j8kh40imhncwwx1sx9kmraaxcxycvgwls53lcyy2ap344k9j"; depends=[]; };
   RAppArmor = derive { name="RAppArmor"; version="1.0.1"; sha256="06j7ghmzw2rrlk8nsarmpk1ab2gg88qs52zpw37rhqchpyzwwkfb"; depends=[]; };
+  rappdirs = derive { name="rappdirs"; version="0.3"; sha256="1yjd91h1knagri5m4djal25p7925162zz5g6005h1fgcvwz3sszd"; depends=[]; };
   rapport = derive { name="rapport"; version="0.51"; sha256="1qn45nrcawr8d9pkdnpmm37dg31l28gfbnwjl62fs7y691187cqp"; depends=[lattice plyr pander yaml reshape]; };
   rapportools = derive { name="rapportools"; version="1.0"; sha256="1sgv4sc737i12arh5dc3263kjsz3dzg06qihfmrqyax94mv2d01b"; depends=[reshape plyr pander]; };
   RArcInfo = derive { name="RArcInfo"; version="0.4-12"; sha256="1j1c27g2gmnxwslff4l0zivi48qxvpshmi7s9wd21cf5id0y4za4"; depends=[RColorBrewer]; };
   rareGE = derive { name="rareGE"; version="0.1"; sha256="0v3a2wns77q923ilddicqzg0108f8kmfdnsff1n65icin7cfzsny"; depends=[MASS nlme survey]; };
-  rareNMtests = derive { name="rareNMtests"; version="1.0"; sha256="0axmxn4arw2iwsj64zsvy99hwcmkl2jy9vqnbwshl8hpaypbdxz9"; depends=[vegan]; };
+  rareNMtests = derive { name="rareNMtests"; version="1.1"; sha256="13r2hipqsf8z9k48ha5bh53n3plw1whb7crpy8zqqkcac8444b2z"; depends=[vegan]; };
   Rarity = derive { name="Rarity"; version="1.2-1"; sha256="16ds0s396f42qqmn4xrnmfk1j6v917p27dgi9iji976hn2q463hh"; depends=[]; };
-  rARPACK = derive { name="rARPACK"; version="0.5-0"; sha256="0d4kd4fi6rvdamj5kvyba6zm0250ldm7nqrgnmapnc2q0wv0hik8"; depends=[Rcpp Matrix]; };
+  rARPACK = derive { name="rARPACK"; version="0.6-0"; sha256="1abfb8pkdfq0x9k4s95va18wnaigx3skpcaiq51ag9i22y6z3wmg"; depends=[Matrix Rcpp]; };
   RaschSampler = derive { name="RaschSampler"; version="0.8-6"; sha256="1ap5r8k4ydnsxqz5hvnnp9cbp0mdnx5bn8pn2wh0rp42897mfm4i"; depends=[]; };
   rasclass = derive { name="rasclass"; version="0.2.1"; sha256="04g2sirxrf16xjmyn4zcci757k7sgvsjbg0qjfr5phbr1rssy9qf"; depends=[car nnet RSNNS e1071 randomForest]; };
-  raster = derive { name="raster"; version="2.2-31"; sha256="0i0a6d8g3qxxlmp897q80lw2k3ccidrfm236l0pd9nwydy0bqpl1"; depends=[sp]; };
-  rasterVis = derive { name="rasterVis"; version="0.28"; sha256="0pq47ldjnihi1mgy5g9ymgvfm5hkpivhcz8qk3kn24cp7j06n0xh"; depends=[raster lattice latticeExtra hexbin sp zoo RColorBrewer]; };
+  raster = derive { name="raster"; version="2.3-12"; sha256="13h3glha5q1j3kvms0l8lbkm1vy49w675s83fxh0fyfh4rh0lrb7"; depends=[sp]; };
+  rasterVis = derive { name="rasterVis"; version="0.32"; sha256="040cg1v30ixkjkibqjpvz94wz486ffsrsnpfgzlp302xvvsmb3dk"; depends=[raster lattice latticeExtra hexbin sp zoo RColorBrewer]; };
   rateratio_test = derive { name="rateratio.test"; version="1.0-2"; sha256="1a2v12z2dr893ha80fhada1820z5ih53w4pnsss9r9xw3hi0m6k5"; depends=[]; };
   raters = derive { name="raters"; version="1.1"; sha256="0djpax59qvvqklph847wh4m2231y3zrzv2i7maq43pr8pyw9f2md"; depends=[]; };
   rationalfun = derive { name="rationalfun"; version="0.1-0"; sha256="15949vs9pdjz7426zhgqn7y87xzn79ikrpa2vyjnsid1igpyh0mp"; depends=[polynom]; };
   RAtmosphere = derive { name="RAtmosphere"; version="1.1"; sha256="0mk43bq28hlrjwaycsxca458k8xf00q58czgc17d8yx3kz17a5i0"; depends=[]; };
-  rattle = derive { name="rattle"; version="3.1.0"; sha256="01kknaxg2is1isl9yjgdqvsilgrv9z4awnnd99bavpwarrb0cvg0"; depends=[]; };
+  rattle = derive { name="rattle"; version="3.3.0"; sha256="0qjlfjpklq94ifgrywc6ldq9n7b06k4pcrkmvv9npary4pkb44bf"; depends=[]; };
   rAverage = derive { name="rAverage"; version="0.3-6"; sha256="005gjk8bifvncl1yfazj4bs8l4k2pgygwdyfrkkd4xvcywar0p73"; depends=[foreign]; };
-  rAvis = derive { name="rAvis"; version="0.1.1"; sha256="0iyhc24xm2655wc1dhg8vhd5yr7zx6hywpxczkfs0a7pifckfy4g"; depends=[stringr XML RCurl scrapeR gdata scales rgdal maptools raster sp]; };
+  rAvis = derive { name="rAvis"; version="0.1.2"; sha256="0m5dl8as0vmmsd3j0z0xwcpq55yfax42fa67qn4lsnaglyqmd4lm"; depends=[stringr XML RCurl scrapeR gdata scales rgdal maptools raster sp]; };
   rawFasta = derive { name="rawFasta"; version="1.0.0"; sha256="0krvs8d1r8hggjg84n7g3ncdkifa3hipbma98f49kf81fzn2npip"; depends=[]; };
-  rbamtools = derive { name="rbamtools"; version="2.9.14"; sha256="0kdbgl7yivhdf6xi2xp9rdvfmpb6d090ja10lj1385qzv3ym0zln"; depends=[]; };
+  rbamtools = derive { name="rbamtools"; version="2.10.0"; sha256="00y5393nac4x1vz9m5li0053cr679dj29v7ss6njgph8q27mv19c"; depends=[]; };
   rbefdata = derive { name="rbefdata"; version="0.3.5"; sha256="12mcqz0pqgwfw5fmma0gwddj4zk0hpwmrsb74dvzqvgcvpfjnv98"; depends=[XML RCurl rjson wordcloud rtematres RColorBrewer]; };
   rbenchmark = derive { name="rbenchmark"; version="1.0.0"; sha256="010fn3qwnk2k411cbqyvra1d12c3bhhl3spzm8kxffmirj4p2al9"; depends=[]; };
-  RBerkeley = derive { name="RBerkeley"; version="0.7-4"; sha256="0jslac7d0dyqxpy4lcg1i7kz9hdidnlxhf982lnsl5kx5fl0nmxi"; depends=[]; };
   rBeta2009 = derive { name="rBeta2009"; version="1.0"; sha256="0ljzxlndn9ba36lh7s3k4biim2qkh2mw9c0kj22a507qbzw1vgnq"; depends=[]; };
   rbhl = derive { name="rbhl"; version="0.1.0"; sha256="1m2n1qczhhdlv9pkmw9dlqi2wmdw8wac8d557c4rk0vnzwzgpgpi"; depends=[httr XML RJSONIO plyr]; };
   RbioRXN = derive { name="RbioRXN"; version="1.3.1"; sha256="122h6pghpb8dfrqvdkvp25bp7dl8kc1aka13h6hp88vaj32pf4ij"; depends=[plyr RCurl gdata data_table stringr]; };
   rbiouml = derive { name="rbiouml"; version="1.4"; sha256="03zpchcwq4sn8cymcrzw6r6fkxh85b8mivy42jkd0knm6i7f9aa6"; depends=[RCurl RJSONIO]; };
-  rbison = derive { name="rbison"; version="0.3.2"; sha256="04j0cq56b46d2nvvdl2sg49ffydbqv0bdzf9ccbh21y9z05s195a"; depends=[plyr httr mapproj ggplot2 gridExtra maptools sp data_table rjson]; };
-  Rbitcoin = derive { name="Rbitcoin"; version="0.9"; sha256="1l9k0pkxsdfm7aay47755zgx6k2b3pwnwxbzn80q5q27s1062pjv"; depends=[data_table RJSONIO RCurl digest]; };
+  rbison = derive { name="rbison"; version="0.4.3"; sha256="1d9f1p17rfxw8nzj8ffnjlpgibh6fdk8gmpizac7j2idhs6k26fw"; depends=[plyr httr mapproj ggplot2 gridExtra maptools sp dplyr jsonlite assertthat]; };
+  Rbitcoin = derive { name="Rbitcoin"; version="0.9.2"; sha256="0ndq4kg1jq6h0jxwhpdp8sw1n5shg53lwa1x0bi7rifmy0gnh66f"; depends=[data_table RCurl digest RJSONIO]; };
   rbitcoinchartsapi = derive { name="rbitcoinchartsapi"; version="1.0.4"; sha256="0r272jvjh3rzch8dmn4s0a5n5k6dsir7pr4qswzfvafqjdiwjajz"; depends=[RJSONIO RCurl]; };
   rbmn = derive { name="rbmn"; version="0.9-2"; sha256="1zy832y399cmfmhpyfh7vfd293fylf1ylmp8w8krkmzkmyfa80f2"; depends=[MASS]; };
   rbounds = derive { name="rbounds"; version="2.0"; sha256="19xxz5dzzh706pp9391fq4v0g1fsd442x6mqqdvhkm51a9x0ih3p"; depends=[Matching]; };
   rbugs = derive { name="rbugs"; version="0.5-9"; sha256="1kvn7x931gjpxymrz0bv50k69s1x1x9mv34vkz54sdkmi08rgb3y"; depends=[]; };
   rbundler = derive { name="rbundler"; version="0.3.7"; sha256="0wmahn59h9vqm6bq1gwnf6mvfkyhqh6xvdc5hraszn1419asy26f"; depends=[devtools]; };
-  RC = derive { name="RC"; version="1.0.2.13"; sha256="0rhbmmihsk09k1nhxkbq0kgxnynl4wfz4lq2jc9cvq8afirxi7wx"; depends=[igraph bitops]; };
   RCA = derive { name="RCA"; version="1.4.5"; sha256="0s200s28a6gh3dggad52dgqnf0k2jsfrqv1hbg8w2529v4s3dc5i"; depends=[igraph]; };
   R_cache = derive { name="R.cache"; version="0.10.0"; sha256="0y8q3w9z9cyzsg60x95kkc81ksc2d5vpdaqg5njq5bgjyw7yjqvs"; depends=[R_methodsS3 R_oo R_utils]; };
   RCALI = derive { name="RCALI"; version="0.2-6"; sha256="01zaks9mdgi9hcwsfvg3dwkihmb5ay5ilgg10fqcz2cssldj9x7x"; depends=[splancs]; };
-  Rcapture = derive { name="Rcapture"; version="1.3-1"; sha256="1k6w5pyml5y2sdfjc1xpl2d5p6d8zj98kwndgir56hyrrrm7nxgx"; depends=[]; };
+  Rcapture = derive { name="Rcapture"; version="1.4-2"; sha256="1nsxy5vpfv7fj03i6l5pgzjm0cldwqxxycnvqkfkshbryjcyl0ps"; depends=[]; };
   rCarto = derive { name="rCarto"; version="0.8"; sha256="08813l4xfahjyn0jv48q8f6sy402n78dqsg01192pxl2dfc2i9ry"; depends=[RColorBrewer maptools classInt]; };
   RCassandra = derive { name="RCassandra"; version="0.1-3"; sha256="0xa241s81cyw6lfjb522f2mlyrd0gav9yz3z5jab9hpdpgg9ri38"; depends=[]; };
+  rcbalance = derive { name="rcbalance"; version="1.0"; sha256="0dvnjdnv4x2c5657sm8qjvmkqj7lp7ddkpan7lhai3qlw2gqijz9"; depends=[MASS plyr]; };
   rcdd = derive { name="rcdd"; version="1.1-8"; sha256="09bb92rp44palx9dvc9pb0gdmb1g22289xjk8p9s918lalc6i9aw"; depends=[]; };
-  rcdk = derive { name="rcdk"; version="3.2.3.2"; sha256="0av5g1yhixx4px8xadg0645a31rgzbpfk2gpf8szxjlb16yvb7cs"; depends=[fingerprint rJava rcdklibs png iterators]; };
-  rcdklibs = derive { name="rcdklibs"; version="1.5.4"; sha256="0ffqvyrawr3n7y6yfag3lpqaz4z2v8ng3kr9h4qfmmab317njwwn"; depends=[rJava]; };
-  RCEIM = derive { name="RCEIM"; version="0.1"; sha256="1z9vp5x4zsc2rg6b080aw88p57gg5xl88psmk0dvy30l39wm4qx5"; depends=[]; };
+  rcdk = derive { name="rcdk"; version="3.3.2"; sha256="02rlg3w8dbmag8b4z4wayh7xn61xc9g3647kxg91r0mvfhmrxl2h"; depends=[fingerprint rJava rcdklibs png iterators]; };
+  rcdklibs = derive { name="rcdklibs"; version="1.5.8.4"; sha256="0mzkr23f4d639vhxfdbg44hzxapmpqkhc084ikcj93gjwvdz903k"; depends=[rJava]; };
+  RCEIM = derive { name="RCEIM"; version="0.2"; sha256="0l3lfx3zqxf310rhvjkn977xchxzi7cbzij3ks0nqlx55x5ica9w"; depends=[]; };
   Rcell = derive { name="Rcell"; version="1.2-6"; sha256="0wly2wgm7506a9f26jbq2b0v9wlh2wyp086r2vi6bia9j8sxhi0c"; depends=[proto plyr reshape ggplot2 digest]; };
   Rcgmin = derive { name="Rcgmin"; version="2013-02.20"; sha256="1y6095vapb3r8p9i5hqa14gfpl4q3g2n82nb64429kl6w3mlfk8f"; depends=[numDeriv]; };
   Rchoice = derive { name="Rchoice"; version="0.1"; sha256="030x42jq6dd25g7isk5m9s0v9rfqkkj7i7286i9as1mpn73nlyz5"; depends=[maxLik Formula sandwich ggplot2 plotrix car lmtest]; };
-  rChoiceDialogs = derive { name="rChoiceDialogs"; version="1.0.4"; sha256="12gzfw0r1ljk81j7hglgsmdm7xwa2n2w2f56sg684l26jyqsaw1z"; depends=[rJava]; };
-  rcicr = derive { name="rcicr"; version="0.2.1"; sha256="0676h5n4r7ymfjq4z0y9rxx842w2byn73335k6wqxxf9sy29lsgc"; depends=[matlab aspace jpeg]; };
+  rChoiceDialogs = derive { name="rChoiceDialogs"; version="1.0.6"; sha256="0lp8amdalirpsba44aa3r31xnhmi36qb9qf8f8gdxxbarpgprsbi"; depends=[rJava]; };
+  rcicr = derive { name="rcicr"; version="0.2.4"; sha256="0dvi51vh6mci1iv480ic06l7yqs8642g5i2sji37wq0cq3k2ypvm"; depends=[matlab aspace jpeg]; };
   RCircos = derive { name="RCircos"; version="1.1.2"; sha256="0j7ww2djnhpra13vjr6y772sg64ikdmw1z68lpp9i7d0shlc3qx9"; depends=[]; };
   RClimMAWGEN = derive { name="RClimMAWGEN"; version="1.1"; sha256="0icy560llfd10mxlq0xmc6lbg6a030za9sygw1rpz8sk5j0lvb84"; depends=[climdex_pcic RMAWGEN]; };
   rClinicalCodes = derive { name="rClinicalCodes"; version="1.0.1"; sha256="1p4p8r2n0k8h9xdzbngb95rshjp3376f5lsx228biqmswhpkhvlf"; depends=[stringr RCurl XML rjson tm]; };
   Rclusterpp = derive { name="Rclusterpp"; version="0.2.3"; sha256="02s5gmmmd0l98wd1y884pjl3h289dyd9p9s7dh7yl2zaslqs2094"; depends=[Rcpp RcppEigen]; };
   rCMA = derive { name="rCMA"; version="1.0.0"; sha256="16d3cdxiaq65lwbvq8wjcp89vrfdp9kwrdl2jy9fynsg0v2lasvp"; depends=[rJava]; };
-  Rcmdr = derive { name="Rcmdr"; version="2.0-4"; sha256="0py5qfr1zk83hgp06xvypz5b9nml5km5xwp2hzy3cf4fd2xjkl3q"; depends=[tcltk2]; };
-  RcmdrMisc = derive { name="RcmdrMisc"; version="1.0-0"; sha256="09798qhx6qcmwpqcmn3fmaww861i5lsbqbmsbq3kx58lmablxs53"; depends=[abind Hmisc MASS e1071 car]; };
-  RcmdrPlugin_BCA = derive { name="RcmdrPlugin.BCA"; version="0.9-7"; sha256="1r4mib6r6qdhkbysxjs7s49j2l1qivlksaixzyz321jwsilpl411"; depends=[BCA car Rcmdr]; };
-  RcmdrPlugin_coin = derive { name="RcmdrPlugin.coin"; version="1.0-21"; sha256="10fapjk74fpknym3pf2c0g25c4sk0pkfkakfy2c5fw9nw4a1j71f"; depends=[Rcmdr coin survival multcomp]; };
+  Rcmdr = derive { name="Rcmdr"; version="2.1-4"; sha256="0ddlwmsqj7ycjfb7ggj9qk9rzzlhk4h1hc1xln0sqmjcc3m0axi4"; depends=[RcmdrMisc car tcltk2 abind]; };
+  RcmdrMisc = derive { name="RcmdrMisc"; version="1.0-2"; sha256="18by1b1iz7q6lbnhxj5l5w58fqsvki84d830sv7iyzrs2q6n7vhq"; depends=[car sandwich abind Hmisc MASS e1071]; };
+  RcmdrPlugin_BCA = derive { name="RcmdrPlugin.BCA"; version="0.9-8"; sha256="0xkip7q9i57ghgz0rh0pl8nkl7bflf4w1g4zbyjdlcjypyf7lnr8"; depends=[Rcmdr BCA flexclust car RcmdrMisc nnet foreign rpart rpart_plot]; };
+  RcmdrPlugin_coin = derive { name="RcmdrPlugin.coin"; version="1.0-22"; sha256="0qmdjnjmgq52wgl4llg69q9x7hvwd73mz3swv0sv88v8zqg7xj93"; depends=[Rcmdr coin survival multcomp]; };
   RcmdrPlugin_depthTools = derive { name="RcmdrPlugin.depthTools"; version="1.3"; sha256="09mjn5jn4rdj1lh515vr3xlnk615flg13kcwbpk0an2si4xkgm9h"; depends=[Rcmdr depthTools]; };
-  RcmdrPlugin_doBy = derive { name="RcmdrPlugin.doBy"; version="0.1-3"; sha256="0nza4y8px90fbhqs9wyjy9302cjavvk72kr1553ljcyh16hjwmmr"; depends=[Rcmdr doBy]; };
-  RcmdrPlugin_DoE = derive { name="RcmdrPlugin.DoE"; version="0.12-2"; sha256="19axgapk8scqi1ky3r3m2dn942z1q6licsaym6ky7a6lygs52k4z"; depends=[DoE_base FrF2 DoE_wrapper relimp Rcmdr]; };
+  RcmdrPlugin_DoE = derive { name="RcmdrPlugin.DoE"; version="0.12-3"; sha256="1iifn71kjjgcp7dfz2pjq57mgbv4rrznrl3b3k9gdc2dva1z9zvc"; depends=[DoE_base FrF2 DoE_wrapper relimp Rcmdr RcmdrMisc]; };
   RcmdrPlugin_doex = derive { name="RcmdrPlugin.doex"; version="0.2.0"; sha256="0l3c8vwifyl8a7qkfaqxm7cws2cg1g501qa93w5svcgp03yf98mj"; depends=[Rcmdr multcomp]; };
   RcmdrPlugin_EACSPIR = derive { name="RcmdrPlugin.EACSPIR"; version="0.2-1"; sha256="0fn12acbjh0n402hn9whhhyij3jlwmvlawyfi9myimnb4wyaqgwb"; depends=[R2HTML abind ez nortest reshape Rcmdr]; };
-  RcmdrPlugin_EBM = derive { name="RcmdrPlugin.EBM"; version="1.0-3"; sha256="189q5k7lr9laq4s10hhjnd4mfdrdjqxf7sn2q1gq9nfglcpkwql6"; depends=[Rcmdr epiR abind]; };
+  RcmdrPlugin_EBM = derive { name="RcmdrPlugin.EBM"; version="1.0-8"; sha256="0lkj869xdacvnma0qq20fqdsq59jqka2fv5h78f99lybzcb95i11"; depends=[Rcmdr epiR abind]; };
+  RcmdrPlugin_EcoVirtual = derive { name="RcmdrPlugin.EcoVirtual"; version="0.1"; sha256="00yk09c1d1frwpfq12zvhg4gnc3p63r61abnil623jpr6wh4b2x8"; depends=[Rcmdr EcoVirtual]; };
   RcmdrPlugin_epack = derive { name="RcmdrPlugin.epack"; version="1.2.5"; sha256="1577qhac4rldifax5x3l39cddan6dhq2dv4iv2n64nadgrl0259w"; depends=[Rcmdr TeachingDemos tseries abind MASS xts forecast]; };
-  RcmdrPlugin_EZR = derive { name="RcmdrPlugin.EZR"; version="1.24"; sha256="1zcpj1xcbmcyrbsr0gsndm5p6qls57zrkjcidk8y27pyd6gim2zj"; depends=[Rcmdr]; };
+  RcmdrPlugin_EZR = derive { name="RcmdrPlugin.EZR"; version="1.26"; sha256="0ywxjj22dwmvdl5c8g1p2diwb9dwq8l5gvlij8kdjyxq67fc4f0r"; depends=[Rcmdr]; };
+  RcmdrPlugin_FactoMineR = derive { name="RcmdrPlugin.FactoMineR"; version="1.5-0"; sha256="1hfnn12l3jljqpczpxz4m9ywbmw5rc1c8dpfl4cabrxnh6ymnk1a"; depends=[FactoMineR Rcmdr]; };
   RcmdrPlugin_HH = derive { name="RcmdrPlugin.HH"; version="1.1-40"; sha256="0i85bbzy46jk8568d7mx1fwq9zk51iq1jjwr2mnik4zh6914f9h5"; depends=[HH lattice latticeExtra rgl Rcmdr multcomp leaps]; };
-  RcmdrPlugin_IPSUR = derive { name="RcmdrPlugin.IPSUR"; version="0.1-8"; sha256="1xgirbwcc2jz16da9fw553phxd2i4ky5jqzspdccj1i7fd4l625m"; depends=[Rcmdr]; };
+  RcmdrPlugin_IPSUR = derive { name="RcmdrPlugin.IPSUR"; version="0.2-1"; sha256="1lk7divj5va74prsnchq8yx9fbyym7xcsyqzkf72w448fgvvvwlv"; depends=[Rcmdr]; };
   RcmdrPlugin_KMggplot2 = derive { name="RcmdrPlugin.KMggplot2"; version="0.2-0"; sha256="1w4n7r3sp6h87wxhrzg500w90p8dzr43j28p8p1r2y0v0i0v6mk5"; depends=[ggplot2 ggthemes gtable plyr Rcmdr RColorBrewer scales survival tcltk2]; };
   RcmdrPlugin_lfstat = derive { name="RcmdrPlugin.lfstat"; version="0.7"; sha256="009yj9c5cr34k8qa16q19sp7c5iwv95g9swbm004nr18mfah8x9w"; depends=[lfstat Rcmdr]; };
-  RcmdrPlugin_MA = derive { name="RcmdrPlugin.MA"; version="0.0-1"; sha256="1l4nvwa0gq83ndkc190l7lba76d9gnf52k4p1z5jfpc9p9s6c20k"; depends=[MAd metafor Rcmdr]; };
+  RcmdrPlugin_MA = derive { name="RcmdrPlugin.MA"; version="0.0-2"; sha256="1zivlc0r2mkxpx23ba76njmb2wnnjijysvza4f24dg4l47d0sr2p"; depends=[Rcmdr MAd metafor]; };
   RcmdrPlugin_mosaic = derive { name="RcmdrPlugin.mosaic"; version="1.0-7"; sha256="0k6xaz2dfm9ch9lxqsh19jm8d4bbyjj2ffmjjxl57kanb3pvrrwv"; depends=[ENmisc vcd Hmisc Rcmdr]; };
   RcmdrPlugin_MPAStats = derive { name="RcmdrPlugin.MPAStats"; version="1.1.5"; sha256="0km6yglhn0128kk1xm2mnrkr2lkv3r9zndhlv7h1dkd16aph3vm3"; depends=[Rcmdr ordinal]; };
-  RcmdrPlugin_NMBU = derive { name="RcmdrPlugin.NMBU"; version="1.7.3"; sha256="07xghjyzpvlgav716fmm3xjk617h84m48qrjpj2nin1hkgbaab31"; depends=[mixlm MASS pls Rcmdr]; };
+  RcmdrPlugin_NMBU = derive { name="RcmdrPlugin.NMBU"; version="1.7.5"; sha256="14cvlzyipnq9scvwgakw3623qmf7qxlqlvmhx8cinf4hnd95j2vc"; depends=[mixlm MASS pls Rcmdr]; };
   RcmdrPlugin_orloca = derive { name="RcmdrPlugin.orloca"; version="4.1"; sha256="19qj6llr5sfw267dgbn2jvrsisb54qbjhgaiigfzymk6px33wwmg"; depends=[orloca orloca_es Rcmdr]; };
   RcmdrPlugin_plotByGroup = derive { name="RcmdrPlugin.plotByGroup"; version="0.1-0"; sha256="10wc7lnihsrldsynq2s0syr1aqmvfnj9rhgwh1nkk7jlrwcgj0z6"; depends=[Rcmdr lattice]; };
   RcmdrPlugin_pointG = derive { name="RcmdrPlugin.pointG"; version="0.6.6"; sha256="0sc3akbpdys353va05b40g3rq8qihw0pmhvv0kckkhsgrbr8mc07"; depends=[Rcmdr RColorBrewer]; };
   RcmdrPlugin_qual = derive { name="RcmdrPlugin.qual"; version="2.2.6"; sha256="00wznh0k909cd9vwdj1ag3224xkqnwjsad1bfkgxbszsx0w6xvy9"; depends=[Rcmdr]; };
+  RcmdrPlugin_ROC = derive { name="RcmdrPlugin.ROC"; version="1.0-16"; sha256="1pxv0izdkqjhvmbvln6n2lhr1mamfy4q20ld6dqkldxj9bivzckb"; depends=[Rcmdr pROC ROCR ResourceSelection PredictABEL]; };
   RcmdrPlugin_sampling = derive { name="RcmdrPlugin.sampling"; version="1.1"; sha256="0fx0s63wq0si1jydl9xyj9ny7iglg91zpvkyrnc05i5pan9l3xd9"; depends=[lpSolve sampling MASS Rcmdr]; };
   RcmdrPlugin_SCDA = derive { name="RcmdrPlugin.SCDA"; version="1.0"; sha256="0z43hhp798kga70xmiq4wzp5iad553rndn17g3va3dh6lz1k3y3h"; depends=[SCVA SCRT SCMA Rcmdr]; };
-  RcmdrPlugin_seeg = derive { name="RcmdrPlugin.seeg"; version="1.0"; sha256="105c2rl3mrcv7r3iqa9d2zs6cys7vfpyydylkg2cggfqkghxgr95"; depends=[Rcmdr seeg spatstat sgeostat]; };
+  RcmdrPlugin_seeg = derive { name="RcmdrPlugin.seeg"; version="1.0"; sha256="105c2rl3mrcv7r3iqa9d2zs6cys7vfpyydylkg2cggfqkghxgr95"; depends=[Rcmdr seeg sgeostat]; };
   RcmdrPlugin_SLC = derive { name="RcmdrPlugin.SLC"; version="0.2"; sha256="1nwpzmgfla1y05dxf81w0wmvvmvcq5jn5k8phlq30920ia7ybs8g"; depends=[SLC Rcmdr]; };
   RcmdrPlugin_SM = derive { name="RcmdrPlugin.SM"; version="0.3.1"; sha256="10sjh2x02kb6yaxbvd9ihc6777j4iv6wi6k42gyl3k7i2c39fyn3"; depends=[Rcmdr car RColorBrewer colorspace vcd]; };
   RcmdrPlugin_sos = derive { name="RcmdrPlugin.sos"; version="0.3-0"; sha256="1r9jxzmf5ks62b5jbw0pkf388i1lnld6i27xhfzysjqdxcnzdsdz"; depends=[sos Rcmdr tcltk2]; };
   RcmdrPlugin_StatisticalURV = derive { name="RcmdrPlugin.StatisticalURV"; version="1.0-1"; sha256="04pqqgy12rnhwm8l0752hb9p5h4l11mm7flm6n9kkcvbkvagsbrz"; depends=[agricolae multcomp car Rcmdr]; };
+  RcmdrPlugin_steepness = derive { name="RcmdrPlugin.steepness"; version="0.3-2"; sha256="0f9b71mbj212l62mg7x5irzy7d3s11gyyi4gsjgkv1l4nbv5k6dm"; depends=[Rcmdr steepness]; };
   RcmdrPlugin_survival = derive { name="RcmdrPlugin.survival"; version="1.0-4"; sha256="03rgr9klf2d1ml8i2avf9lncjr3bfcb4v7mcwg800wwdjzkwqkql"; depends=[survival date Rcmdr]; };
   RcmdrPlugin_TeachingDemos = derive { name="RcmdrPlugin.TeachingDemos"; version="1.0-7"; sha256="0d473p0df99x9a3jfwb49gxsrcvslcw9yandramwq82cwy3sdcxw"; depends=[rgl TeachingDemos Rcmdr]; };
-  RcmdrPlugin_temis = derive { name="RcmdrPlugin.temis"; version="0.7"; sha256="1h1s2r2vz4sjnw25hvm13laflhlva28shlkg5kq6qk98p802gr19"; depends=[tm NLP slam zoo lattice Rcmdr tcltk2 ca R2HTML RColorBrewer latticeExtra stringi]; };
+  RcmdrPlugin_temis = derive { name="RcmdrPlugin.temis"; version="0.7.2"; sha256="0n5if3cip66pi0mh4xn06yq4w2nzmxgd3g56m4k1384zssrq66gn"; depends=[tm NLP slam zoo lattice Rcmdr tcltk2 ca R2HTML RColorBrewer latticeExtra stringi]; };
   RcmdrPlugin_UCA = derive { name="RcmdrPlugin.UCA"; version="1.0-2"; sha256="11a8jaz5vycq8hnpxzrbv1g8vyh0ic1y48952ah633b2j1m1ay8i"; depends=[Rcmdr]; };
+  RCMIP5 = derive { name="RCMIP5"; version="1.0"; sha256="1ng5j1f6yidzyx351hii9wff5iif5r5vzwbj9apvmrjrzc9w8vns"; depends=[abind plyr reshape2 foreach digest]; };
   Rcolombos = derive { name="Rcolombos"; version="1.5.0"; sha256="139ayyc94m6srbcccw1j8p4by5nxy7s52ahvdq2ag183hk91gjq4"; depends=[httr]; };
   RColorBrewer = derive { name="RColorBrewer"; version="1.0-5"; sha256="0y4ficfdjzrd7lkcaafjrdqr5r3jiha7rvg76h8m5yak396c9has"; depends=[]; };
   Rcplex = derive { name="Rcplex"; version="0.3-2"; sha256="1hx9s327af7yawzyq5isvx8n6pvr0481lrfajgh8nihj7g69nmk7"; depends=[slam]; };
   RCPmod = derive { name="RCPmod"; version="1.4"; sha256="1psn1w8ws0n96jqvd98l0wl0l46w0691c5vm9aarql2pqnc73lw9"; depends=[numDeriv gtools]; };
-  Rcpp = derive { name="Rcpp"; version="0.11.2"; sha256="1b42kmm314xzcjldcqaljsqfxczh8czjzl9afds372vh7asjmjm1"; depends=[]; };
-  Rcpp11 = derive { name="Rcpp11"; version="3.1.1"; sha256="03a28n1nk9xrl055xnnzvla8qdq8k856bj7vim2fyws5kw9b8sbp"; depends=[]; };
+  Rcpp = derive { name="Rcpp"; version="0.11.3"; sha256="0k0j99m8qqm65gdng3lxxnpbbzrcyyk6k992iq4lz5pl16qsxgha"; depends=[]; };
   RcppBDT = derive { name="RcppBDT"; version="0.2.3"; sha256="0gnj4gz754l80df7w3d5qn7a57z9kq494n00wp6f7vr8aqgq8wi1"; depends=[Rcpp]; };
   rcppbugs = derive { name="rcppbugs"; version="0.1.4.1"; sha256="0wb5mzw1sdrr7lc6izilv60k5v0wcvy8q31a863b63a9jvh16g8d"; depends=[Rcpp]; };
   RcppClassic = derive { name="RcppClassic"; version="0.9.5"; sha256="193nsplyqd1fb7hwxsk0s7dz6rm6rw7lp04jff08mswcjdkh69g4"; depends=[Rcpp]; };
   RcppClassicExamples = derive { name="RcppClassicExamples"; version="0.1.1"; sha256="0shs12y3gj5p7gharjik48dqk0fy4k2jx7h22ppvgbs8z85qjrb8"; depends=[Rcpp RcppClassic]; };
   RcppCNPy = derive { name="RcppCNPy"; version="0.2.3"; sha256="1baz9272vwc44yab7xb6ig0gd2gj8idrhywir2zq77q8bfhqc9gh"; depends=[Rcpp]; };
   RcppDE = derive { name="RcppDE"; version="0.1.2"; sha256="0ji5csfygqvrcahgx5gxy7dddpykckzw8hmqslsdl7l68wj60qkc"; depends=[Rcpp RcppArmadillo]; };
-  RcppEigen = derive { name="RcppEigen"; version="0.3.2.1.2"; sha256="010a27jby8c61mgw2qb47zkln1v33gj0xcn8lf7sw0kb2mdh58yl"; depends=[Matrix Rcpp]; };
+  RcppEigen = derive { name="RcppEigen"; version="0.3.2.2.0"; sha256="1d3qb73d6b22pwar2mimynfm6z2c58cr36r6l1j34ysz00lyi1mk"; depends=[Matrix Rcpp]; };
   RcppExamples = derive { name="RcppExamples"; version="0.1.6"; sha256="1jnqh9nii5nncsah0lrkls8dqqcka9fnbvfg8ikl4cqjri17rpbv"; depends=[Rcpp]; };
   RcppGSL = derive { name="RcppGSL"; version="0.2.2"; sha256="0f47bs3ll42wxday2bg7w5fnv8a4280yvmzkjzn3b36v8wvm44g8"; depends=[Rcpp]; };
-  RcppMLPACK = derive { name="RcppMLPACK"; version="1.0.9"; sha256="042pznzd9b43k8n57xlbl1k4w6pzn4miv44qv3cf7w5br2rk1ks7"; depends=[Rcpp]; };
-  RcppOctave = derive { name="RcppOctave"; version="0.14.1"; sha256="0fdljr0jdnardcm2qm29ibz16xymal8xac3p4grscipa44vm1w0b"; depends=[Rcpp pkgmaker digest stringr]; };
+  RcppMLPACK = derive { name="RcppMLPACK"; version="1.0.9-3"; sha256="1s5h5sad4c4pxxa7vx8j74x4qlsl4a23l6qpq51k5lwrxchcjklk"; depends=[Rcpp]; };
+  RcppOctave = derive { name="RcppOctave"; version="0.14.5"; sha256="0dplc2x9fq2jfzfbcxdd45pmiimapqb3xhyjkzd4k6q8xmqjw95p"; depends=[Rcpp pkgmaker digest stringr]; };
+  RcppParallel = derive { name="RcppParallel"; version="4.3.3"; sha256="1xsp44jfynvz6flfajgbf82aykdhz242brmwxw9w67ngx96x0dxv"; depends=[]; };
   RcppProgress = derive { name="RcppProgress"; version="0.1"; sha256="1gvj51gadljaakm1nxdwgxzh723vv3ypzpzsgacsppxpj4rivxq4"; depends=[Rcpp]; };
   RcppRedis = derive { name="RcppRedis"; version="0.1.1"; sha256="0q05m4vssvk9xyxskdvpgwm3mhif2xbwggpwkyxdn7frsfz2fpvm"; depends=[Rcpp RApiSerialize]; };
   RcppRoll = derive { name="RcppRoll"; version="0.1.0"; sha256="0xwm64z7pr2cjmq4kri7zzhy7wvq7aj9lq3xm2g830fn71qvj8x3"; depends=[Rcpp RcppArmadillo]; };
   RcppSMC = derive { name="RcppSMC"; version="0.1.4"; sha256="1gcqffb6rkw029cpzv7bzsxaq0a5b032zjvriw6yjzyrpi944ip7"; depends=[Rcpp]; };
   RcppXts = derive { name="RcppXts"; version="0.0.4"; sha256="143rhz97qh8sbr6p2fqzxz4cgigwprbqrizxpkjxyhq8347g8p4i"; depends=[Rcpp xts]; };
   RcppZiggurat = derive { name="RcppZiggurat"; version="0.1.2"; sha256="05ai6s2j025fvr4znpmsvhxj4x7xyw2wsb9j3c5sv7aw1byfs0bb"; depends=[Rcpp]; };
-  rcqp = derive { name="rcqp"; version="0.3"; sha256="0vxcgchnxdsdamclcshjbkn00ysmfmqp586a36wsyv3zqrd6rg7p"; depends=[plyr]; };
   Rcsdp = derive { name="Rcsdp"; version="0.1.53"; sha256="0x91hyx6z9f4zd7djxlq7dnznmr9skyzwbbcbjyid9hxbcfyvhcp"; depends=[]; };
   rCUR = derive { name="rCUR"; version="1.3"; sha256="1f38xbc5n91k2y88cg0sv1z2p4g5vl7v2k1024f42f7526g2p2lx"; depends=[MASS Matrix lattice]; };
   RCurl = derive { name="RCurl"; version="1.95-4.3"; sha256="1gyjarnxwz3ldpm1vwq9ls6al66rvs7yshzhrl1fv9lbm1qi8yfg"; depends=[bitops pkgs.curl]; };
-  Rd2roxygen = derive { name="Rd2roxygen"; version="1.4"; sha256="09dxgp65zac5b9mxbjrvy3ihdwski98xva5afq659b8yfvkviq4g"; depends=[roxygen2 formatR]; };
+  Rd2roxygen = derive { name="Rd2roxygen"; version="1.5"; sha256="0qh64bd323s3h44ypjxv98ndp332q31imf5prmaqvzcjs2j0r3gh"; depends=[roxygen2 formatR]; };
   rda = derive { name="rda"; version="1.0.2-2"; sha256="1g2q7c0y138i9r7jgjrlpqznvwpqsj6f7vljqqfzh2l6kcj43vjj"; depends=[]; };
   rdatamarket = derive { name="rdatamarket"; version="0.6.4"; sha256="16a1yxvf841505a8gh7jf09fx6ipysymrpvsd4b07xdg5hvbzx25"; depends=[zoo RCurl RJSONIO]; };
   rdd = derive { name="rdd"; version="0.56"; sha256="1x61ik606mwn46x3qzgq8wk2f6d5qqr95h30bz6hfbjlpcxw3700"; depends=[sandwich lmtest AER Formula]; };
   rdetools = derive { name="rdetools"; version="1.0"; sha256="0pkl990viv7ifr7ihgdcsww93sk2wlzp2cg931wywagfp8dijd02"; depends=[]; };
-  R_devices = derive { name="R.devices"; version="2.9.2"; sha256="14nr2alx59xm2cagpqrzviw7lxwxdrv9y42wb60230439nh3gpla"; depends=[R_methodsS3 R_oo R_utils base64enc]; };
+  R_devices = derive { name="R.devices"; version="2.12.0"; sha256="0as90warygvcsa5cvicjykn7jz2d5cdw68ghqi9cj5lzqq982dkn"; depends=[R_methodsS3 R_oo R_utils base64enc]; };
   RDIDQ = derive { name="RDIDQ"; version="1.0"; sha256="09gincmxv20srh4h82ld1ifwncaibic9b30i56zhy0w35353pxm2"; depends=[]; };
   RDieHarder = derive { name="RDieHarder"; version="0.1.3"; sha256="0wls7b0qfbi6hsq9xdywi4mdhim5b6mrzhvyrm9dxp9z1k7imz6m"; depends=[]; };
   Rdistance = derive { name="Rdistance"; version="1.1"; sha256="1rgjiks4s5l0vdj4svik9zz6kwwxsh9nj6q2ng7iblny6iqm6kbd"; depends=[]; };
+  RDML = derive { name="RDML"; version="0.4-2"; sha256="0bx1n6x3yskpbgwwwjhs6hk43sfq7x55yffvnd7bz5qb3l49wsw2"; depends=[XML chipPCR]; };
   rDNA = derive { name="rDNA"; version="1.30.1"; sha256="12h83zirv55sryc1zww97ws8kvsym1z7p7y5d4w43nam8mi3fpcd"; depends=[rJava]; };
   Rdpack = derive { name="Rdpack"; version="0.4-14"; sha256="19vscr9l63c074n76b6a6jbl956sphjhz0d50yiwp3cvqf28yssf"; depends=[gbRd bibtex]; };
-  rdrobust = derive { name="rdrobust"; version="0.6"; sha256="074lj2nz0rqxdx6cyd5cf3c073b0ra6d3pxpvp5dhx6iqzmpwcdp"; depends=[]; };
+  rdrobust = derive { name="rdrobust"; version="0.70"; sha256="1zfsgzyi648v5zzbjjw01vvznws6yv30n981ljn996g4y2qy7gp4"; depends=[]; };
   rdryad = derive { name="rdryad"; version="0.1.1"; sha256="0mqpkmwkznyxj0nn1v389p741dlc66dixcvljsn2rvg0q6p75fkj"; depends=[XML RCurl OAIHarvester ape gdata plyr stringr RJSONIO]; };
   RDS = derive { name="RDS"; version="0.6"; sha256="14zk511agqckriqjiaargglzsw14mch8q7zh97qd38xg0568mh73"; depends=[ggplot2 gridExtra rgexf igraph scales locfit Hmisc reshape2]; };
-  Rdsm = derive { name="Rdsm"; version="2.0.2"; sha256="1wzfc72zjvqdffkyp19zflab88r9yb3qrd0d96k8453dgmz8aygp"; depends=[bigmemory]; };
+  Rdsm = derive { name="Rdsm"; version="2.1.1"; sha256="07fc6c2hv0vvg15va552y54cla1mrqsd75w3zh02vc7yd226l4rj"; depends=[bigmemory]; };
   RDSTK = derive { name="RDSTK"; version="1.1"; sha256="07vfhsyah8vpvgfxfnmp5py1pxf4vvfzy8jk7zp1x2gl6dz2g7hq"; depends=[plyr rjson RCurl]; };
   rDVR = derive { name="rDVR"; version="0.1.1"; sha256="19a4f9k65bd49vkn3sxkjdmcpwyawk7gwmvancvqr745gfgs0wzg"; depends=[RCurl]; };
-  rdyncall = derive { name="rdyncall"; version="0.7.5"; sha256="0w7dwjswf8dx2w1piyrqr1wixmmlkgzlfwnnxvbiy2mfy1lwd04r"; depends=[]; };
   ReacTran = derive { name="ReacTran"; version="1.4.1"; sha256="01k3w6iffql198na968dmqgzsqgd1kwrjb34yw7mzppyisjcyv0k"; depends=[rootSolve deSolve shape]; };
-  readbitmap = derive { name="readbitmap"; version="0.1-2"; sha256="11cha65hl5r8h143pnf54mxa0lpqphzi9l0n4bg24bjpdz15cppi"; depends=[bmp jpeg png]; };
-  readBrukerFlexData = derive { name="readBrukerFlexData"; version="1.7"; sha256="0ajahma356aicl0jpwpdynf35yrh74z8zwjhav4h7v57zlvwhh1f"; depends=[]; };
-  reader = derive { name="reader"; version="1.0.1"; sha256="1320kmysri660p54l86n260nrxskpfrwn4zbbwvp7w9fcqa09zyn"; depends=[NCmisc]; };
+  readbitmap = derive { name="readbitmap"; version="0.1-4"; sha256="08fqqsdb2wsx415mnac9mzl5sr5and0zx72ablnlidqfxv8xsi9d"; depends=[bmp jpeg png]; };
+  readBrukerFlexData = derive { name="readBrukerFlexData"; version="1.8"; sha256="124l2g8nzsf2piymksviv291pbpmc0lnx97vqcyiz435gqjkplgf"; depends=[]; };
+  reader = derive { name="reader"; version="1.0.4"; sha256="0hfv6x80c3jlhy5pspibbpfqqik0rly399qh4b1wn5da0vrbmvs3"; depends=[NCmisc]; };
   readMLData = derive { name="readMLData"; version="0.9-6"; sha256="15rb8hm60fc30xgxjwxl7v5blzf02s6cb8pk0p26cgn9liiavjhb"; depends=[XML]; };
-  readMzXmlData = derive { name="readMzXmlData"; version="2.7"; sha256="1c4q2ghp7mr1i3547vdq3mhvhqz0y2il5za5milrwb72wpq1cdfi"; depends=[base64enc digest XML]; };
+  readMzXmlData = derive { name="readMzXmlData"; version="2.8"; sha256="0x5h3dh6fkc30m6gx6pzmrxr31s80d1qgpcakspjza53qn6fjb16"; depends=[base64enc digest XML]; };
   readODS = derive { name="readODS"; version="1.4"; sha256="00xcas8y0cq3scgi9vlfkrjalphmd7bsynlzpy7izxa5w9b7x79f"; depends=[XML]; };
+  RealVAMS = derive { name="RealVAMS"; version="0.3-1"; sha256="04d4sc3lhlklx1y016rmh3x27m8caxlp53qn2ks5wz52w26pfdhn"; depends=[Matrix numDeriv Rcpp]; };
   reams = derive { name="reams"; version="0.1"; sha256="07hqi0y59kv5lg0nl75xy8n48zw03y5m71zx58aiig94bf3yl95c"; depends=[leaps mgcv]; };
-  Rearrangement = derive { name="Rearrangement"; version="1.0"; sha256="0biyg2m0ip2x4fwfw7c1ynidzb5cvdlr0gycx90w319jlz3rxqz0"; depends=[quantreg]; };
-  REBayes = derive { name="REBayes"; version="0.45"; sha256="0r3adc98x84ynqh682ngr7ghf0bzqhqbjay7lq842iny2wqwi6yz"; depends=[Rmosek Matrix SparseM]; };
+  REBayes = derive { name="REBayes"; version="0.50"; sha256="0p4kv709r0577xq3mdw2vwla1gsjm8b9mnbsbfwm8fx3n3wfrx0p"; depends=[Rmosek Matrix SparseM]; };
   rebird = derive { name="rebird"; version="0.1.1"; sha256="0s8wmp2sghs56ppca57fjfab7wngszmy1g8rd3hiwx6br0sjidcg"; depends=[RJSONIO httr RCurl plyr]; };
-  rebmix = derive { name="rebmix"; version="2.6.1"; sha256="0yh284z0mfa24m27r5sm1qlaagz5vvd83wq7jyc42ahnfm7cm8gv"; depends=[]; };
+  rebmix = derive { name="rebmix"; version="2.6.2"; sha256="1cib2xwxv2pzhhc1fw7dfnjmk7s8fvxpn7025fvisg0gx5533978"; depends=[]; };
+  RECA = derive { name="RECA"; version="1.0"; sha256="0ah67yr6sppm66bfayq8k3p63g8bcc61k6j3rzrj6qx8d72kq54d"; depends=[]; };
   recalls = derive { name="recalls"; version="0.1.0"; sha256="121r2lf32x4yq8zxx6pbnphs7ygn382ns85qxws6jnqzy52q41vh"; depends=[RCurl RJSONIO]; };
   reccsim = derive { name="reccsim"; version="0.9-1"; sha256="17nsp91xq20vfwjfwav80qjs2wc7gwpmrdnwv7lc61baq0kkcs7k"; depends=[]; };
   ReCiPa = derive { name="ReCiPa"; version="3.0"; sha256="019vlvgxnqqlwghxygfqggzp2b4x2pqzdrbhaa703zdhm58k0n1g"; depends=[]; };
   recluster = derive { name="recluster"; version="2.5"; sha256="1hyq3nxbkah9jmly9a7ykzrf72r8yyd5ra5hf6d8fcprg15h8gg2"; depends=[vegan ape picante phangorn phytools cluster]; };
-  recommenderlab = derive { name="recommenderlab"; version="0.1-4"; sha256="0ays9y3l7nj4vcbdraqv627lv0vf3wiqfszcqrh74h8jz9nnx78d"; depends=[Matrix registry arules proxy]; };
+  recommenderlab = derive { name="recommenderlab"; version="0.1-5"; sha256="1hpgd2la4wnlxx5h8cjni4i978hdssr041zrg851lpjrkbxmxfsi"; depends=[Matrix registry arules proxy]; };
   recommenderlabBX = derive { name="recommenderlabBX"; version="0.1-0"; sha256="0dl79cxarsfp8l4nxnns05jwnjygigjhwpjrr4lzx4nvsfxmgsr2"; depends=[recommenderlab]; };
   recommenderlabJester = derive { name="recommenderlabJester"; version="0.1-0"; sha256="1m5jg8gs16cwwwcnjzqkyzwyip8fshrwhmqz8g7nlf6g3p9347rl"; depends=[recommenderlab]; };
   Records = derive { name="Records"; version="1.0"; sha256="08y1g2m6bdrvv4rpkhd5v2lh7vprxy9bcx9ahp1f7p062bn2lwji"; depends=[]; };
+  recosystem = derive { name="recosystem"; version="0.2.4"; sha256="19d8c98wkzaxmzkg5z3ry6klcqgbcmb8ycwh52l9mvvy2k1ybkw6"; depends=[Rcpp]; };
   RECSO = derive { name="RECSO"; version="1.0"; sha256="1ipjfxk58wkrq6a0nqrg9b734xj1qa8xnr44xigbpjrpdqd5j3lm"; depends=[]; };
   REdaS = derive { name="REdaS"; version="0.9.1"; sha256="0nd0d6cnx43k73cygbw0r6hdxpwkzwrlm4vr60s6hk227am15z68"; depends=[]; };
+  redcapAPI = derive { name="redcapAPI"; version="1.0.1"; sha256="190fy2i7x1xwjpihg3p6wznzld2wa284jp8laxxbc735jqrj1a0f"; depends=[chron httr stringr]; };
+  REDCapR = derive { name="REDCapR"; version="0.4-28"; sha256="08x3zwcm9yq27nia320lrfwq4vq8dhy73cqsxll2zsa8nl05mpaw"; depends=[httr plyr stringr]; };
   REEMtree = derive { name="REEMtree"; version="0.90.3"; sha256="01sp36p12ky8vgsz6aik80w4abs70idr9sn4627lf94r92wwwsbc"; depends=[nlme rpart]; };
   ref = derive { name="ref"; version="0.99"; sha256="0f0yz08pqpg57mcm7rh4g0rbvlcvs5fbpjkfrq7fmj850z1ixvw0"; depends=[]; };
-  referenceIntervals = derive { name="referenceIntervals"; version="1.1"; sha256="0lw233rsyii3bjzj262qq85sf3sgj3nq7r8siwfn115amjbi6r6r"; depends=[boot extremevalues car outliers]; };
+  referenceIntervals = derive { name="referenceIntervals"; version="1.1.1"; sha256="04199nxh216msaghkp66zsi96h76a7c42ldml0fm66v2vamcslg8"; depends=[boot extremevalues car outliers]; };
   RefFreeEWAS = derive { name="RefFreeEWAS"; version="1.3"; sha256="1cb1q2nki0d18ia4cmi1sp7qih9hv7g1jk1kyp7vya5gp572z3cd"; depends=[isva]; };
-  refGenome = derive { name="refGenome"; version="1.2.0"; sha256="038v9pwh8fra31l14bwb2kyilmc9kqbvb9s1c0d79yxkx6znjc49"; depends=[RSQLite doBy]; };
-  RefManageR = derive { name="RefManageR"; version="0.8.3"; sha256="0ik85hgf1v347kypb7k97nhr0dm2nqz156k9lkf8dcjml3f00sk0"; depends=[XML RCurl RJSONIO plyr bibtex lubridate stringr]; };
+  refGenome = derive { name="refGenome"; version="1.3.0"; sha256="121aw4w84hlhxgwlf1gh0w3ydvd8zsijrh0q7fzcwi1vdgnjb7lv"; depends=[doBy RSQLite DBI]; };
+  RefManageR = derive { name="RefManageR"; version="0.8.40"; sha256="1d1r9whn37fv818brl98hy6hmihd6h6632xgf3n639m4km419v9r"; depends=[XML RCurl RJSONIO plyr bibtex lubridate stringr]; };
   refund = derive { name="refund"; version="0.1-11"; sha256="1afsxab1jivs4vj6diqh7352v98divna6az1dxsdn7lvw6cmph6y"; depends=[fda lattice boot mgcv MASS glmnet magic nlme wavethresh Matrix gamm4 matrixStats lme4 RLRsim]; };
   refund_wave = derive { name="refund.wave"; version="0.1"; sha256="1vnhg7gi5r8scwivqjwhrv72sq8asnm4whx3jk39saphdxpk5hxv"; depends=[glmnet wavethresh]; };
   RegClust = derive { name="RegClust"; version="1.0"; sha256="1d9w74phw4fgafglc18j7dpmln96fvxnf1kdc9zddgj90p8yfx63"; depends=[]; };
-  REGENT = derive { name="REGENT"; version="1.0.5"; sha256="1id1bkrr0q1nwja8y7glb5wsq1hkx6gf1d09vbmfl62hslqblqn8"; depends=[]; };
   registry = derive { name="registry"; version="0.2"; sha256="1ifv9sql70kylfj12cdb1j1zpk3ix728m8qj46sf1zyc5mhll01s"; depends=[]; };
   reglogit = derive { name="reglogit"; version="1.2-2"; sha256="0nq60s8l860z6nd52l6c77vamis7hl2j667gkxry0jir2pxsk4jp"; depends=[mvtnorm boot Matrix]; };
   regpro = derive { name="regpro"; version="0.1.0"; sha256="0d47ffsqx1633pmf3abi7wksyng2g71mz2z9nb2zqdak794l1n44"; depends=[denpro]; };
···
   relax = derive { name="relax"; version="1.3.15"; sha256="0cgvxw3pmy9kx8p81bb5n5nnbn6l9hm07k6hdy7p2j2gl15xxnpq"; depends=[]; };
   relaxnet = derive { name="relaxnet"; version="0.3-2"; sha256="1l83rk7r4vkcxbfljmibzm8lzpx0vf406hv4h5cy9x0k3rz2bfh0"; depends=[glmnet]; };
   relaxo = derive { name="relaxo"; version="0.1-2"; sha256="1rzmq7q3j271s6qwwrmwidv0vxcjpgjhyiqgr6fkczkai2lbnd8x"; depends=[lars]; };
-  reldist = derive { name="reldist"; version="1.6-2"; sha256="0f5l74jmk8jxi43jyjxjv9cklk8359drjkjipz7972dm3a7i4rmw"; depends=[]; };
+  reldist = derive { name="reldist"; version="1.6-3"; sha256="1qr2sbr0h7by6zllz23p3k136wk1i1lzn066hllw4cqhxfviaynm"; depends=[mgcv]; };
   relevent = derive { name="relevent"; version="1.0-3"; sha256="054x4kmc0h0s6a4svjqawy52sllzmaca46q6abnr5qhdzzmfh21n"; depends=[trust sna]; };
   Reliability = derive { name="Reliability"; version="0.0-2"; sha256="12zsicgbjqih3grbs62pw37x8wlkmnyc7g0yz6bqnfb4ym2yb7fg"; depends=[]; };
   ReliabilityTheory = derive { name="ReliabilityTheory"; version="0.1.4"; sha256="1faab4z3rp0xqc0s0rrkw4kxgyc332xz3sjaz1wd4p6kiydds2hi"; depends=[igraph sfsmisc combinat FRACTION mcmc PhaseType actuar HI]; };
···
   remix = derive { name="remix"; version="2.1"; sha256="0s1gaf7vj08xd4m7lc9qpwvk0mpamabbxk71970mfazx6hk24dr0"; depends=[plyr survival Hmisc ascii]; };
   rEMM = derive { name="rEMM"; version="1.0-8"; sha256="1d8nwranqfvr9c0g2ny7akawgqk5hjnr1mclk87gmbmwn9iwik34"; depends=[proxy MASS clusterGeneration igraph]; };
   remMap = derive { name="remMap"; version="0.1-0"; sha256="03jbrnk8nbaj6l8g428il5h6p2sszndd2bl4rvg8347pw7cp4kk1"; depends=[]; };
+  remote = derive { name="remote"; version="0.3.0"; sha256="1f41j26grkv4830bvi6z16b63yksplrq3yg1amd4l634lwhp6x55"; depends=[Rcpp raster foreach]; };
   Renext = derive { name="Renext"; version="2.1-0"; sha256="19920kb3qd97vm285zbxqarpq8dyyrx1k6sks990xjbgpy7vyj3y"; depends=[evd numDeriv]; };
   RenextGUI = derive { name="RenextGUI"; version="1.0-2"; sha256="0ghs8bwb6qdyvhghxvdy51cibylgm7bdbzgqsn1nbxam39yhvfv9"; depends=[gWidgets gWidgetstcltk Renext]; };
-  rentrez = derive { name="rentrez"; version="0.2.4"; sha256="00ixhzwk9s802n4msd63aika2g315cw8kppr0rq02wkch7a2nl3w"; depends=[RCurl XML]; };
+  rentrez = derive { name="rentrez"; version="0.3.1"; sha256="1awamp0730wzpxzbdr9rhy4xb06b25xrmk2pj3h6kj75k4k7h5vs"; depends=[XML httr]; };
   Reol = derive { name="Reol"; version="1.55"; sha256="0147x3fvafc47zd2chgv3b40k480pcjpji8vm1d741i1p6ml448p"; depends=[XML RCurl ape]; };
   ReorderCluster = derive { name="ReorderCluster"; version="1.0"; sha256="0ss750frzvj0bm1w7zblmcsjpszhnbffwlkaw31sm003lbx9hy58"; depends=[gplots Rcpp]; };
-  Reot = derive { name="Reot"; version="0.1.0"; sha256="0kpp5mg7dpfas77mw95ryfknjvdx7vwah42dip1kgyy7sxqqhn3h"; depends=[Rcpp raster foreach]; };
   RepeatedHighDim = derive { name="RepeatedHighDim"; version="2.0.0"; sha256="1n9w4jb25pm0mmsahlfhkp9jmhgp5b21l1g85gm2wbxqkjsg7g0g"; depends=[MASS nlme]; };
-  repfdr = derive { name="repfdr"; version="1.0"; sha256="1rscfbnq739al5pac1y9szjw2g6f9z6qimkvhrkn9xfchjw3jvky"; depends=[locfdr]; };
-  repmis = derive { name="repmis"; version="0.2.9"; sha256="0ivk7sfnjia6xqsk7z0sqjdyhkrr894zpjfgm3l1sqnxam001rm2"; depends=[digest httr plyr R_cache xlsx]; };
+  repfdr = derive { name="repfdr"; version="1.1"; sha256="1k85y27k42kw5zmbrnnqb62x3djjzdm4zrvm2g4dl8ykdlnaikv9"; depends=[]; };
+  replicationInterval = derive { name="replicationInterval"; version="0.2"; sha256="1hs5alhpdnhwn86wrlqhbf1cpy96hh6rffkmcpbxxpcv3fhzgz7b"; depends=[MBESS]; };
+  repmis = derive { name="repmis"; version="0.3"; sha256="11z931vcz4z85w03y32zs3iyh40abnmlnkdd6h1q93b3m14k0ykj"; depends=[digest httr plyr R_cache xlsx]; };
   repolr = derive { name="repolr"; version="2.0"; sha256="10wg07sfxcxzswf3zh5sx2cm9dxjx11zymy82a4q9awnacb5gp9b"; depends=[gee]; };
-  ReporteRs = derive { name="ReporteRs"; version="0.5.5"; sha256="1g6dsdjzzc144z992cp9cd65naj4ll2b616562wlqz9983jzaap4"; depends=[ReporteRsjars rJava base64]; };
-  ReporteRsjars = derive { name="ReporteRsjars"; version="0.0.1"; sha256="0y2kzlyw2yf65jvawrvwwqhwwp0yw3ssx8y4jwkcyqn66b6gzh8j"; depends=[rJava]; };
+  ReporteRs = derive { name="ReporteRs"; version="0.6.0"; sha256="089rk7h5ivjns5rj86p2irbz1dywrs7z5ya5vk7cb1kc6q0wxkh1"; depends=[ReporteRsjars rJava]; };
+  ReporteRsjars = derive { name="ReporteRsjars"; version="0.0.2"; sha256="1abvgzxipg0cgiy26z14i99qydzqva6j2v7pnrxapysg7ml5cnjc"; depends=[rJava]; };
   reportr = derive { name="reportr"; version="1.1.2"; sha256="0lxnmay9vgg7dsa3scszx3v4lb6m3bv6kjl0dk7hrl7bd67azdrk"; depends=[]; };
   reportRx = derive { name="reportRx"; version="1.0"; sha256="0npiflql0lq8sqp6xgydxbw7xdr0zdxj1s2h4bnpmn4clc05r7m4"; depends=[reshape survival xtable aod cmprsk geoR stringr]; };
   reports = derive { name="reports"; version="0.1.2"; sha256="14w9dlhvk4080sq03ad3dhcww7c213f8ygbnxm7kxcpk36j71yjn"; depends=[knitr knitcitations]; };
   reporttools = derive { name="reporttools"; version="1.1.1"; sha256="0cnxzq679f860z063j3pbm2c5qcaz45g73khj9rdp3if0cci8ikj"; depends=[xtable]; };
-  REPPlab = derive { name="REPPlab"; version="0.2"; sha256="1d3mb4mi17xlvyw9dgrcad6gfnyk0v1s0safxqyarm4xmh1bppzw"; depends=[rJava lattice]; };
+  REPPlab = derive { name="REPPlab"; version="0.9"; sha256="0f3p9kjsn0x3sf4qx05rm1llad09w6dimvhdd7q8w3ggwqsh2w20"; depends=[rJava lattice]; };
+  repra = derive { name="repra"; version="0.4.2"; sha256="1djcs83z8ckpmsbyzscnysmy45z28kswzm852176b9pip21mb1w8"; depends=[data_table dplyr Rcpp reshape2 ggplot2 assertthat]; };
   represent = derive { name="represent"; version="1.0"; sha256="0jvb40i6r1bh9ysfqwsj7s1g933d7z5fq9d618yjrqr6hbbqsvac"; depends=[]; };
   REQS = derive { name="REQS"; version="0.8-12"; sha256="049glqhc8h8gf425kmj92jv70917dsigpm37diby0c6hb4jrg8ka"; depends=[gtools]; };
   resample = derive { name="resample"; version="0.2"; sha256="1p6hyd0wi037bsz0xd9gkw28sp4nkj1zmqs9h0lzkxbspn6h0q7j"; depends=[]; };
···
   reshapeGUI = derive { name="reshapeGUI"; version="0.1.0"; sha256="0kb57isws8gw0nlr6v9lg06c8000hqw0fvhfjsjyf8w6zwbbq3zs"; depends=[reshape2 plyr gWidgets gWidgetsRGtk2]; };
   ResistorArray = derive { name="ResistorArray"; version="1.0-28"; sha256="055zr4rybgrvg3wsgd9vhyjpvzdskrlss68r0g7rnj4yxkix0kxz"; depends=[]; };
   ResourceSelection = derive { name="ResourceSelection"; version="0.2-4"; sha256="01r1w03paazyix5jjxww89falba1qfiqcznx79a6fmsiv8gm2x5w"; depends=[]; };
-  restlos = derive { name="restlos"; version="0.1-2"; sha256="14nbi8xqjs9plkzamg0ja1mx7klpbnnglk7p2nipz551b0nmzn7i"; depends=[som rgl ade4 geometry nnclust]; };
+  restlos = derive { name="restlos"; version="0.1-3"; sha256="0lqkvxczclg7ab8n0rd8b27ycrakw3pf379n1js49fwvvvqkymdg"; depends=[som rgl geometry igraph]; };
   restorepoint = derive { name="restorepoint"; version="0.1.5"; sha256="0xmpxprirnd1yavwk3vkc0cp715d187mn0amppya7kd47iw10wsy"; depends=[]; };
   retimes = derive { name="retimes"; version="0.1-2"; sha256="019sllyfahlqnqry2gqw4w5cy4cavrqnwpwrbb25cgjpdb19raja"; depends=[]; };
   reutils = derive { name="reutils"; version="0.1.2"; sha256="0f2c6zxk6x2plq649b1ml6b112j6y8ys074pn30yw35ncg3h86fa"; depends=[assertthat RCurl XML]; };
   revealedPrefs = derive { name="revealedPrefs"; version="0.1"; sha256="1akinhrvw3rmsxircnj2ymfphsca50j2jda5v4kqcprpigf1i8j1"; depends=[Rcpp]; };
   review = derive { name="review"; version="2.5"; sha256="0qk4n6g0hp49rjqhpipgja777namdafk6yf4kcxdld1cghdikw31"; depends=[XML Hmisc]; };
   reweight = derive { name="reweight"; version="1.2.1"; sha256="0fv7q1zb3f4vplg3b5ykb1ydwbzmiajgd1ihrxl732ll8rkkfa4v"; depends=[]; };
+  rex = derive { name="rex"; version="0.1.2"; sha256="1q1p25j71dyrd1qba402031gajk53fr6vnw0ks7j3z44li0b3ic4"; depends=[magrittr lazyeval]; };
   rexpokit = derive { name="rexpokit"; version="0.24.1"; sha256="143zi6qb0l8vbx87jf58v1zfxqmvv6x4im1knd6q4dpp9gffqs22"; depends=[SparseM Rcpp]; };
   Rfacebook = derive { name="Rfacebook"; version="0.4"; sha256="0f5wbd16a7wsw1fpficz6i2vrwyw3n75a1qm4dv5181jr6ik492p"; depends=[httr rjson]; };
   rFerns = derive { name="rFerns"; version="0.3.3"; sha256="0d0zkqqqv9l71a5bjps1m69mrpqxkzs77zlf6kbg70b053dzhiph"; depends=[]; };
   RFGLS = derive { name="RFGLS"; version="1.1"; sha256="13ggxj74h5b2hfhjyc50ndxznkvlg18j80m78hkzwh25d3948fsk"; depends=[bdsmatrix Matrix]; };
   rfigshare = derive { name="rfigshare"; version="0.3.6"; sha256="1n6i5ppn3v93126gvva8sn85v1h4f7hgc43pxja9bwr1ypmzgr45"; depends=[RJSONIO httr httpuv plyr yaml ggplot2 XML]; };
-  R_filesets = derive { name="R.filesets"; version="2.4.0"; sha256="1970x41g7wxspslfijmx021z06s3lfw5wz0mr8h5bk1y8sj0gsvk"; depends=[R_oo R_methodsS3 R_utils R_cache digest]; };
+  R_filesets = derive { name="R.filesets"; version="2.6.0"; sha256="0n99mxdajb6rk7cvgy4gihaifiw31llngrhx22mfn3zs7wbdk9d1"; depends=[R_oo R_methodsS3 R_utils R_cache digest]; };
   RFinanceYJ = derive { name="RFinanceYJ"; version="0.3.1"; sha256="0qhmzsch7c2p0zckjkspsajzh8m10cf75ixjlgd0nj8rm41fngm3"; depends=[XML xts]; };
   rfishbase = derive { name="rfishbase"; version="0.2-2"; sha256="09pa5zpw9rclf5pqj1wjjhdcblca9sm9xcs9ka3xfa7azj7n9ljd"; depends=[XML RCurl]; };
   rfisheries = derive { name="rfisheries"; version="0.1"; sha256="1g0h3icj7cikfkh76yff84hil23rfshlnnqmgvnfbhykyr2zmk61"; depends=[httr data_table assertthat ggplot2 rjson]; };
   Rfit = derive { name="Rfit"; version="0.18"; sha256="06zpk4nyhqcq9py5i8c4zvz02csax39r09ays97w5k24zrnwk0q9"; depends=[quantreg]; };
-  RFLPtools = derive { name="RFLPtools"; version="1.5"; sha256="0j3cdjibmdhg1qsmbpw7zbw9jz6gy662z28849xsr7gppzm08xbw"; depends=[RColorBrewer]; };
+  RFLPtools = derive { name="RFLPtools"; version="1.6"; sha256="1hl2crg7jl266zac41xvx151h7kl52346wnlvd8hba64s4s4apay"; depends=[RColorBrewer]; };
   RfmriVC = derive { name="RfmriVC"; version="1.0.4"; sha256="15bzpwi01gb580wl0flvp7pwqf1sgk6fsdmfq4cqaprb979js79f"; depends=[mvtnorm mgcv Rniftilib]; };
+  rfoaas = derive { name="rfoaas"; version="0.0.4"; sha256="1p6sd197jbrccckpmpkicvdzy56a5p91mddiaw3384krqn3q3lb1"; depends=[]; };
   RFOC = derive { name="RFOC"; version="3.3-3"; sha256="101d7nf4zjni5kdk54w3afdaqnjzl7y90zygybkqpd0vi82q602b"; depends=[RPMG GEOmap RSEIS MASS splancs]; };
   RForcecom = derive { name="RForcecom"; version="0.7"; sha256="0rjav2rwanzqgi1yasbm9lj18f0mfxwd8w8x41skf656gfcpi0i4"; depends=[XML RCurl plyr]; };
+  rfordummies = derive { name="rfordummies"; version="0.0-2"; sha256="01wbhn8wpwkwvkafx4m8l5zj2xjbvwjlzbnwkd4i7g2nrvw29wsx"; depends=[]; };
   rforensicbatwing = derive { name="rforensicbatwing"; version="1.3"; sha256="0ff4v7px4wm5rd4f4z8s4arh48hgayqjfpnni2997c92wlsq3d12"; depends=[Rcpp]; };
   rfPermute = derive { name="rfPermute"; version="1.6.1"; sha256="1fpj0wjaxfqcp6z0azkmgqjsysgpm0vgg81pi6w9xs6a5nwa6wd1"; depends=[randomForest ggplot2 gridExtra]; };
   RFreak = derive { name="RFreak"; version="0.3-0"; sha256="1dmllxb6yjkfkn34f07j2g7w5m63b5d10lh9xsmxyfk23b8l3x0x"; depends=[rJava]; };
+  RGA = derive { name="RGA"; version="0.1.3"; sha256="0d7vwzz6yx17qskhc62v3cbia8cxj67f75wk96p78b7h8wza3zf9"; depends=[httr jsonlite httpuv shiny]; };
   rgabriel = derive { name="rgabriel"; version="0.7"; sha256="1c6awfppm1gqg7rm3551k6wyhqvjpyidqikjisg2p2kkhmyfkyzx"; depends=[]; };
   rgam = derive { name="rgam"; version="0.6.3"; sha256="0mbyyhhyr7ijv2sq9n7g0vaxivngwf4nbb5398xpsh7fxvgw5zdw"; depends=[Rcpp]; };
   rGammaGamma = derive { name="rGammaGamma"; version="1.0.12"; sha256="1051ah6q11qkxj1my4xybbzc8xcqkxfmps8mv2his5cyfllwidbs"; depends=[gsl]; };
···
   Rgbp = derive { name="Rgbp"; version="1.0.6"; sha256="1j4j7g9z7p592f82k0yvibrydynkd9v1ldil2vf3ikc650bn2l02"; depends=[sn]; };
   RGCCA = derive { name="RGCCA"; version="2.0"; sha256="0mcp51z5jkn7yxmspp5cvmmvq0cwh7hj66g7wjmxsi74dwxcinvg"; depends=[MASS]; };
   rgcvpack = derive { name="rgcvpack"; version="0.1-4"; sha256="1vlvw9slrra18qaizqk2xglzky0i6z3bsan85x908wrg8drss4h5"; depends=[]; };
-  rgdal = derive { name="rgdal"; version="0.8-16"; sha256="17qk7kd0l0l52nyf6drr0gv4b0ibkggyn6g3ky9flsjy05b3wg8j"; depends=[sp pkgs.gdal pkgs.proj]; };
+  rgdal = derive { name="rgdal"; version="0.9-1"; sha256="1jq6z4z0q00djfmm2nsr5cn7idall5pfqp2p88ah9g24k928v3gf"; depends=[sp pkgs.gdal pkgs.proj]; };
   RGENERATE = derive { name="RGENERATE"; version="1.1"; sha256="1da3b50cfv5jb63ijzbnr226jadbww2bapcxzx8am7zydm6gqnss"; depends=[RMAWGEN]; };
   RGenetics = derive { name="RGenetics"; version="0.1"; sha256="0x5sspd67hh08qm62whlnnd838m0np29q3bfzgwp6j85lhil3jrx"; depends=[]; };
   rgenoud = derive { name="rgenoud"; version="5.7-12"; sha256="17gzkn4laylnksy8h2w8c0whcxpchsx7bwjzk1q5sfqxswclqq0g"; depends=[]; };
-  rgeos = derive { name="rgeos"; version="0.3-6"; sha256="134cppgg5349i5qs9k2161fakd15l1fx1x6mgv28c5vic2xdm4wl"; depends=[sp pkgs.geos]; };
+  rgeos = derive { name="rgeos"; version="0.3-8"; sha256="0snbfxzh700fn415li0wia94zgb0x73vwdrbrpimvz9k3y43yvp8"; depends=[sp pkgs.geos]; };
   rgexf = derive { name="rgexf"; version="0.14.3.11"; sha256="16mil1csyzkaywcdrjzz5r60n4xhhinxawg30skc7d9awkf26qfa"; depends=[XML Rook igraph]; };
   rggobi = derive { name="rggobi"; version="2.1.20"; sha256="1a7l68h3m9cq14k7y96ijgh0iz3d6j4j2anxg50pykz20lnykr9g"; depends=[RGtk2]; };
   RGIFT = derive { name="RGIFT"; version="0.1-5"; sha256="1745fs4bq0ss39fiwljspvrmnkgbbpc1fjvhvcrsmp2iizq12sgn"; depends=[]; };
-  rgl = derive { name="rgl"; version="0.93.1098"; sha256="1nc4s8a2zihd7vg8mfyfah02mickgyqxscbpd7njzv9xycvr7jv5"; depends=[]; };
+  rgl = derive { name="rgl"; version="0.95.1157"; sha256="0m38a2f8h73hxa5ykcvv0g1p3cj8p198gsnwk6r97r8qzils5fax"; depends=[]; };
   Rglpk = derive { name="Rglpk"; version="0.6-0"; sha256="0g0s63skabr0yqk5s9p66p77z8v3pr3hbnirbgdddlvkpphi08xx"; depends=[slam]; };
   Rgnuplot = derive { name="Rgnuplot"; version="1.0.1"; sha256="1yag6ip2ppclhnpfc3mn6bsaylv2lk2k3jr8wgrgzrb7z22p7dk8"; depends=[]; };
+  RGoogleAnalytics = derive { name="RGoogleAnalytics"; version="0.1.1"; sha256="1049fyxl00izw92rm508p90asjp0agmv38b00yfbmasfzsp1r00s"; depends=[lubridate httr]; };
   RgoogleMaps = derive { name="RgoogleMaps"; version="1.2.0.6"; sha256="1kd77617j2dz3dqjskv71vj8xv0yjgcysrpw7a615s0ys2hs91wp"; depends=[png RJSONIO]; };
   rgp = derive { name="rgp"; version="0.4-1"; sha256="1p5qa46v0sli7ccyp39iysn04yvq80dy2w1hk4c80pfwrxc6n03g"; depends=[emoa]; };
   rgpui = derive { name="rgpui"; version="0.1-1"; sha256="0hp1z00n6jzi45j61hlp5qj26wpjvbzjz3nvpxvmcjdmkk3vjfyp"; depends=[rgp shiny emoa]; };
   rgr = derive { name="rgr"; version="1.1.9"; sha256="1fs8f0g1wm6virwjzlgabp1i89n8jpdiwnkvk5w1lggs36xc8q59"; depends=[MASS fastICA]; };
-  RGraphics = derive { name="RGraphics"; version="2.0-9"; sha256="1y0rrhvpn92l8mb0m8ny8ddpwgv6wkd3a10zhbing541f3y754nn"; depends=[lattice ggplot2]; };
+  RGraphics = derive { name="RGraphics"; version="2.0-12"; sha256="03f0rlckfkll3s30avglbf0524laf8n6plxlbmbx1qi1s18hcfai"; depends=[lattice ggplot2]; };
   rgrs = derive { name="rgrs"; version="0.3"; sha256="19whlp3i0jps4pdif03h6z79zliw4shiqh7ackhk2gwq5c28jsql"; depends=[questionr]; };
   RGtk2 = derive { name="RGtk2"; version="2.20.31"; sha256="1ilnlmsk9fis61pc5bn9sf7z4b7vc7f0a0zcy77kk4bns6iqjvyp"; depends=[]; };
   RGtk2Extras = derive { name="RGtk2Extras"; version="0.6.1"; sha256="19gjz2bk9dix06wrmlnq02yj1ly8pzhvr0riz9b08vbzlsv9gnk2"; depends=[RGtk2]; };
-  RH2 = derive { name="RH2"; version="0.1-2.12"; sha256="1ig9yxpaza7lm0b20sp7jr024hp284c0zs3k06k3k1vw1dyw60fj"; depends=[chron RJDBC]; };
+  RH2 = derive { name="RH2"; version="0.2.3"; sha256="1qbxy600fc8k2xl70liggdgg03ga6a8yad001banqzdmh508wcxl"; depends=[chron RJDBC rJava]; };
   rHealthDataGov = derive { name="rHealthDataGov"; version="1.0.1"; sha256="0lkjprss15yl6n9wgh79r4clip3jndly2ab1lv4iijzxnxay099d"; depends=[bit64 httr jsonlite]; };
   Rhh = derive { name="Rhh"; version="1.0.2"; sha256="0blxim8yrb0qnbkc1z2q24q6ryakggq2zhaa223swla99ahmsny3"; depends=[]; };
-  RHive = derive { name="RHive"; version="2.0-0.0"; sha256="0r49irdwigxxqniidx7i3j7si8bw7zklw3n4zvhcmzfkvx0al91n"; depends=[rJava]; };
-  RHmm = derive { name="RHmm"; version="2.0.3"; sha256="1mnsqkg419d1z0kyxpjj9md3aammvw0xfrd7dwymii2ql050v47b"; depends=[MASS nlme]; };
+  RHive = derive { name="RHive"; version="2.0-0.2"; sha256="0a1saqqwh6zvz264jkkd6c9abxpsg1j4yfivb5h773i76pzhvqc3"; depends=[rJava]; };
   rhosp = derive { name="rhosp"; version="1.05"; sha256="1d1a4dc8hgvjmfb21s7j19yadbi1a9qp06prd80izbhvj2hni573"; depends=[]; };
-  Rhpc = derive { name="Rhpc"; version="0.14-78"; sha256="136xld0k99nlgmg6p5dcr882f2r11b0bahh57swwcfi9nfqw3zaz"; depends=[]; };
-  RhpcBLASctl = derive { name="RhpcBLASctl"; version="0.14-72"; sha256="0417d8lvwhnfniq41wlcl642z01nv3mhzj9fyb5hlg5vafqpmp8n"; depends=[]; };
+  Rhpc = derive { name="Rhpc"; version="0.14-261"; sha256="09rb68dys283gqmgn00v5skz6y5mcychg7hjrmi59pcfl5i7sk71"; depends=[]; };
+  RhpcBLASctl = derive { name="RhpcBLASctl"; version="0.14-256"; sha256="1s9mwwh269wwdqnb98jxsmpjm2bdf5dj4c3wkj5i81w2p1sm8qx3"; depends=[]; };
   rHpcc = derive { name="rHpcc"; version="1.0"; sha256="0096z90mmf1j2xpb9034a5ph52m8z6n6xjh3km2vrhw63g3cpwap"; depends=[RCurl XML]; };
   RHRV = derive { name="RHRV"; version="4.0"; sha256="16xmmmw8gsqalbqf59xwpkd2bkfwxrdx8bwdn875bizx7mn0bql7"; depends=[tkrplot waveslim nonlinearTseries]; };
   RHT = derive { name="RHT"; version="1.0"; sha256="1gxf8nhj3y92h8al7l3fxa45wc568kb3cykrbdjlsy2zjacf7fcc"; depends=[]; };
···
   RI2by2 = derive { name="RI2by2"; version="1.2"; sha256="0387ncq1nhpz8521nwsjybsdpncm56nrwkz68apgihmrbjlmp6m7"; depends=[gtools]; };
   rich = derive { name="rich"; version="0.3"; sha256="122xb729xlm8gyb7b3glw4sdvrh98wh89528kcbibpx83bp3frc0"; depends=[boot vegan permute]; };
   ridge = derive { name="ridge"; version="2.1-3"; sha256="0pdmybygf730dw73a5ncl9fw3kjnnpqqkanqxi97aj9n4cfcjn7z"; depends=[]; };
-  RidgeFusion = derive { name="RidgeFusion"; version="1.0-2"; sha256="1izhq9vqj9kca3ddk91f5h8351qr3cnwig9i7d76rhlzawrl7ch9"; depends=[mvtnorm]; };
+  RidgeFusion = derive { name="RidgeFusion"; version="1.0-3"; sha256="10llmrsfpcqrkcbw7zj44kvfy7ywn9rk49n7zplilz8h94zzcmjv"; depends=[mvtnorm]; };
   Ridit = derive { name="Ridit"; version="1.1"; sha256="02cni6hzf1bsns7vi8vklnhc0pfb5vwqhjnnfnjnnaxpzpsbvdfn"; depends=[]; };
   RIFS = derive { name="RIFS"; version="0.1-5"; sha256="0705dhirh7bhy2yf3b1mpk3m7lggg4pwy640lvaspwaxkd6zac5w"; depends=[]; };
   RIGHT = derive { name="RIGHT"; version="0.1.2"; sha256="047g6gymrfzccnp56pvvk3s2r19p1czm9pjmpdn3fnx13d8lalaz"; depends=[shiny]; };
-  RImageJROI = derive { name="RImageJROI"; version="0.1"; sha256="06x8p8wpzmsc6f2330m74x4dmh21dn0gqicand2l198knahp3kf7"; depends=[spatstat]; };
-  RImpala = derive { name="RImpala"; version="0.1.3"; sha256="108ykv3g17ymglcisawihlns0gzmzhx1xcbfwpa5pni4x9hxw0g9"; depends=[rJava]; };
+  RImageJROI = derive { name="RImageJROI"; version="0.1"; sha256="06x8p8wpzmsc6f2330m74x4dmh21dn0gqicand2l198knahp3kf7"; depends=[]; };
+  RImpala = derive { name="RImpala"; version="0.1.5"; sha256="0kx2h6gkjxrsp6c33p1j7irs205rn5lpknlmc8as3v1ziigi4d51"; depends=[rJava]; };
   rinat = derive { name="rinat"; version="0.1.4"; sha256="1m5k1wcinm6is3mf86314scgy3xfifz7ly7il5zgqyg9jkkpywbz"; depends=[httr plyr jsonlite ggplot2 maps]; };
   rindex = derive { name="rindex"; version="0.12"; sha256="1k9zihvrp955c4lh70zjlsssviy2app8w6mv5ln4nawackbz0six"; depends=[regtest]; };
   ringbuffer = derive { name="ringbuffer"; version="1.1"; sha256="1jj6zdvqlkc30bnxapg0sjl5ci5kq76611smqc4jc8adzhzwrh3f"; depends=[]; };
···
   rio = derive { name="rio"; version="0.1.2"; sha256="0h80msbj1qcc9m4408qcckw238ydqdzzgr9frlmmc7qi4dyba4i4"; depends=[stringr foreign testthat]; };
   rioja = derive { name="rioja"; version="0.8-7"; sha256="1164sxwv9wafqmprnkr9sdsd109ss8w2l1j8ir7kq8ya071k3zbl"; depends=[vegan]; };
   ripa = derive { name="ripa"; version="2.0-2"; sha256="0n1gaga0d4bb9qdlm7gksa1nwi4y28kbgwr3icwqgihf1bfb9m81"; depends=[Rcpp]; };
-  risaac = derive { name="risaac"; version="0.1"; sha256="1ndqxlq4l48iiaghx897bhr7q56csbia7y1a98fic8hzfp03811r"; depends=[]; };
   riskRegression = derive { name="riskRegression"; version="0.0.8"; sha256="0bjxwj4wrlcqkm1zf25p39h3jwf0f11zspzsk4b41axr3adlvmdw"; depends=[prodlim rms pec rms cmprsk survival]; };
   risksetROC = derive { name="risksetROC"; version="1.0.4"; sha256="1fh0jf8v536qzf1v3awx3f73wykzicli4r54yg1z926ccqb4h80l"; depends=[survival MASS]; };
   RISmed = derive { name="RISmed"; version="2.1.2"; sha256="1hi22sf6g047m2bq9yh6bwvi1x8bjw12vslfp6iyrim0w2pk96m1"; depends=[]; };
   Ritc = derive { name="Ritc"; version="1.0.1"; sha256="1h41s4jihzj0yj8xyan0zhhyyiq8m5567vw4gvmmr81p1qfzvva8"; depends=[minpack_lm]; };
-  rite = derive { name="rite"; version="0.3.1"; sha256="0z12jxbmis9l82y0l98gf8hyxfwasj5lpznkmi8kwvvya3jw5ypf"; depends=[tcltk2 RCurl]; };
+  rite = derive { name="rite"; version="0.3.4"; sha256="196ashcfj5p52qpnpnrkg7vxq87v7vhf1d7z40mk134gmxk2784j"; depends=[tcltk2 RCurl knitr markdown]; };
   RItools = derive { name="RItools"; version="0.1-12"; sha256="0zdwj5y355d8jnwmjic3djwn6zy7h1iyl58j9hmnmc3m369cir0s"; depends=[lattice SparseM xtable svd abind]; };
   riv = derive { name="riv"; version="2.0-4"; sha256="1c9k62plqgxcgcm2j1s26hqvgww96n6bfjz2yk7m3p2wf8gkkyam"; depends=[MASS rrcov quantreg]; };
-  riverplot = derive { name="riverplot"; version="0.2"; sha256="160xy3q7a7qfabambhq0h3mrx8wbiv88xvcfzkya3fkq5nac22c5"; depends=[]; };
+  rivernet = derive { name="rivernet"; version="1.0"; sha256="0za5k00k9vivpq4wr1xqc4aw7mlcxhjj2b3iiip1qy13fg7bhbjm"; depends=[]; };
+  riverplot = derive { name="riverplot"; version="0.3"; sha256="1x02ci6744k3lsqh53vmpmv957b5wwr1idvn16nzixvzknixryq8"; depends=[]; };
   rivervis = derive { name="rivervis"; version="0.39.4"; sha256="1al0ylmpvkxfhkv9i4j6pvrlqn13pdwmzs7s6vazmgmkl3iggav4"; depends=[]; };
   Rivivc = derive { name="Rivivc"; version="0.9"; sha256="0gl3040pp9nqm4g2ympnx80z64zfnn1hfsxka8ynd2cqhjn3b5i1"; depends=[signal]; };
   RJaCGH = derive { name="RJaCGH"; version="2.0.2"; sha256="1fy8wsnv7diwg2w7j61scm6vd35a5jb36i9pzh5m7jz6yqsank50"; depends=[]; };
-  rjags = derive { name="rjags"; version="3-13"; sha256="0npfyphi8z25h7w4frplbyjgib1gawz7ib9gz5w6h2i0pricm53r"; depends=[coda]; };
-  rJava = buildRPackage {
-    name = "rJava-0.9-6";
-    src = fetchurl {
-      url = "mirror://cran/src/contrib/rJava_0.9-6.tar.gz";
-      sha256 ="008g6s6rcb5lnz5y2a2rs4iq85a4nl522g714s1w1r153qcc0jz0";
-    };
-    propagatedBuildInputs = [pkgs.jdk pkgs.lzma pkgs.bzip2 pkgs.pcre pkgs.icu pkgs.libzip];
-    preConfigure = ''
-    export JAVA_CPPFLAGS=-I${pkgs.jdk}/include/
-    export JAVA_HOME=${pkgs.jdk}
-    '';
-    meta.hydraPlatforms = R.meta.hydraPlatforms;
-  };
+  rjags = derive { name="rjags"; version="3-14"; sha256="1hfsa8jl5imk2j2qnafa5q95zn69bhvijdpvfs64vsiqsalsg7yk"; depends=[coda]; };
   rJavax = derive { name="rJavax"; version="0.3"; sha256="0sv2fjinp4wmdfvcpgm4hv8v3fkiiv84ywqyr4hz86j50ncd79km"; depends=[rJava]; };
   RJDBC = derive { name="RJDBC"; version="0.2-4"; sha256="14nqz4gx24gcjmnd3hrhvfs5f68c3nqhb6nypv9gvk19dx1jayg0"; depends=[DBI rJava]; };
   rje = derive { name="rje"; version="1.9"; sha256="1dyd34z6lb0p6zmyax5dpzflgc9a4saka33mvdfcxi5pj0rnygaz"; depends=[]; };
-  Rjms = derive { name="Rjms"; version="0.0.5"; sha256="0bb07wynvk07p8i5x87hlxfavjs5wf5gasfggyjxycr54sphlg6z"; depends=[rJava Rjmsjars rJava Rjmsjars]; };
-  Rjmsjars = derive { name="Rjmsjars"; version="0.0.1"; sha256="0xi42p1wgp7f15j3b74zisf0xrz86kgyn5anq3x5ahyb9cfrnmqx"; depends=[rJava rJava]; };
   rJPSGCS = derive { name="rJPSGCS"; version="0.2-6"; sha256="1x6mwy6232kjl8ssvkbamhfvxsc3rqbjsrlrprj0bprssm3pcr2g"; depends=[rJava]; };
   Rjpstatdb = derive { name="Rjpstatdb"; version="0.1"; sha256="0iwgsp3mblp7bsx88wfpqn09y1xrkingfkm3z9jsi2bwrnrjc2iv"; depends=[RCurl XML]; };
+  RJSDMX = derive { name="RJSDMX"; version="1.1"; sha256="17z9aihq0qgxkx00z995s328p8m76kbs6s9z0c6ybnm8xjckkn4d"; depends=[rJava zoo]; };
   rjson = derive { name="rjson"; version="0.2.14"; sha256="0mrk2ahgb6pn7aq5lgixrxjkkpjmn4sbkazvg7bbfvyvxps1gm4k"; depends=[]; };
   RJSONIO = derive { name="RJSONIO"; version="1.3-0"; sha256="1dwgyiy19sixhy6yclqcaaxswbmpq7digyjjxhy1qv0wfsvk94qi"; depends=[]; };
-  RJSONLD = derive { name="RJSONLD"; version="1.0.3"; sha256="17myzigzmn6hd0fbzm7h4n65aiighklrzfr3irg1520aa35s6214"; depends=[RJSONIO formula_tools stringr lmtest]; };
+  rjstat = derive { name="rjstat"; version="0.2"; sha256="1ylwp6d3cc8xb8129yr49grx9vb4xyp62ig0qa7vzkbdplba2zr2"; depends=[jsonlite assertthat]; };
   rJython = derive { name="rJython"; version="0.0-4"; sha256="13fpcw37cca738v9idqgi3gv9avfkfwfacxj54p2c4wyg46ghnah"; depends=[rJava rjson]; };
   RKEA = derive { name="RKEA"; version="0.0-4"; sha256="0qkjnyy4b6vzdiapadx9hmw3h4gfgmbi4g5078rr6kq5kmwqlwgh"; depends=[rJava tm]; };
   rknn = derive { name="rknn"; version="1.2"; sha256="1c92cv3462f00p237fkh06hl66j912ssiav4hpc4jphvs01g30kz"; depends=[gmp]; };
-  Rknots = derive { name="Rknots"; version="1.2.1"; sha256="1qv7l4c3n3zyz2s5whl5chi5yfb1j67kihk1c8gpjl291axmmi8w"; depends=[rgl rSymPy]; };
   rkt = derive { name="rkt"; version="1.3"; sha256="0d82id22xac84l5iqls0mlg1g9yn4hhkmf4ln7xlp0zinmmhym9m"; depends=[]; };
   rkvo = derive { name="rkvo"; version="0.1"; sha256="0ci8jqf9nc8hb063nckxdnp0nlyr4ghby356lxm00anw44jlmw8v"; depends=[Rcpp]; };
   Rlab = derive { name="Rlab"; version="2.15.1"; sha256="1pb0pj84i1s4ckdmcglqxa8brhjha4y4rfm9x0na15n7d9lzi9ag"; depends=[]; };
-  Rlabkey = derive { name="Rlabkey"; version="2.1.123"; sha256="0jz8x3n6byxmb10jcrcyznyj3zwab3bkp2g52n707w2jv0xvn8l5"; depends=[RCurl rjson]; };
+  Rlabkey = derive { name="Rlabkey"; version="2.1.125"; sha256="18hwzbrrs39y6qbqn6r5fcpxqmvr62f12jqh3j98w0zgpa16vvcy"; depends=[RCurl rjson]; };
   rLakeAnalyzer = derive { name="rLakeAnalyzer"; version="1.4"; sha256="1qs8f4sv044bxrf45wzfj444plkcq3i61353881x8shn13h3awas"; depends=[plyr]; };
   rlecuyer = derive { name="rlecuyer"; version="0.3-3"; sha256="1n0vny3k5s5152y0ggz9vfn4bqay9ncbdzkw9g4703pszrbwq7xh"; depends=[]; };
   rLindo = derive { name="rLindo"; version="8.0.1"; sha256="05qyc4wvpjgw8jxmwn2nwybi695fjn0cdilkprwmjg07c82f0q5n"; depends=[]; };
-  rlist = derive { name="rlist"; version="0.3"; sha256="1l9iypqzdj8j6zg9a55xc6l31sp2lznyx17a1jsl6717bbh5bpmg"; depends=[stringdist data_table yaml jsonlite]; };
+  rlist = derive { name="rlist"; version="0.3-2"; sha256="11br13s7frwz9ix7lgb4qpgcnvbqrzx0l0mx5kdg4pbvlbhjd4ij"; depends=[stringdist data_table yaml jsonlite]; };
   rlme = derive { name="rlme"; version="0.4"; sha256="02683sklihj3726a90jryybf855rvbz9v3dm9z9yhb32q9bfmy34"; depends=[MASS quantreg nlme mgcv stringr magic robustbase Rcpp]; };
   RLRsim = derive { name="RLRsim"; version="3.0"; sha256="16bqsp15b8ikgix18p63k6sf81d1al4djbb51r08imjs4z9jppg4"; depends=[Rcpp mgcv]; };
   RM2 = derive { name="RM2"; version="0.0"; sha256="1v57nhwg8jrpv4zi22fhrphw0p0haynq13pg9k992sb0c72dx70a"; depends=[msm]; };
   rmaf = derive { name="rmaf"; version="2.0"; sha256="00qhdfzbjvmz83nicl73yhx7w8sv6j7x928j4vd6ll79098x4y84"; depends=[]; };
   RMallow = derive { name="RMallow"; version="1.0"; sha256="0prd5fc98mlxnwjhscmghw62jhq9rj5jk8qf4fnaa2a718yxf9b5"; depends=[combinat]; };
   Rmalschains = derive { name="Rmalschains"; version="0.2-2"; sha256="1ki3igj78sk4kk1cvbzrgzjdvw6kbdb7dmqglh6ws2nmr5b6a7fx"; depends=[Rcpp]; };
-  RMark = derive { name="RMark"; version="2.1.8"; sha256="1g8zp1c6wdpi7rr0g4sfzxnvc56svl6qb2i971rvjh03ja3wzvi1"; depends=[snowfall matrixcalc msm coda]; };
+  RMark = derive { name="RMark"; version="2.1.9"; sha256="1z7hh9fwaaiwa2s27vrc3yckqc0vhimazqj71601ibsqs3pljzh8"; depends=[snowfall matrixcalc msm coda]; };
+  rmarkdown = derive { name="rmarkdown"; version="0.3.3"; sha256="0i3wdis931s91fzy9n2lkfslxiw7wayyfbkygl0mgs1dhldhgk4m"; depends=[knitr yaml htmltools caTools]; };
   rmatio = derive { name="rmatio"; version="0.10.0"; sha256="1p1gsv7fj14hynna4a7nnxbchd0i1db03yxah4pcz3sd3a9hqw0f"; depends=[Matrix lattice]; };
-  R_matlab = derive { name="R.matlab"; version="3.0.1"; sha256="0r8427bqr7kwrf1bp3chphpavpbaaq5yj3ad4jc40b75zg9dmi91"; depends=[R_methodsS3 R_oo R_utils]; };
+  R_matlab = derive { name="R.matlab"; version="3.1.1"; sha256="15j1mshzv1lpjlsdcjg45khdvl0w8mqwd387i1lc0zv1r29m6mn9"; depends=[R_methodsS3 R_oo R_utils]; };
   RMAWGEN = derive { name="RMAWGEN"; version="1.2.6.1"; sha256="1j8yb37sv2ycg3zgdj6hlxvlrsgvb9rh4yxd40bah2j1xgibr36z"; depends=[chron date vars]; };
   RMC = derive { name="RMC"; version="0.2"; sha256="1sc4nsjmaw2ajm8bka7r4mf73zxqhnvx23kl4v20pfpy9rhgd0h6"; depends=[]; };
   RMediation = derive { name="RMediation"; version="1.1.3"; sha256="07ck74dl1wwb88229fhkh2czlynddff7zvjyhisxk53qmdb0wvmw"; depends=[MASS lavaan e1071]; };
-  RMessenger = derive { name="RMessenger"; version="0.1.5"; sha256="1xsfvygf9bbfzbldpkmg399qhfai5s5fmc60xjpkjmxhjqh4vry1"; depends=[Rcpp]; };
   rmeta = derive { name="rmeta"; version="2.16"; sha256="1s3n185kk0ddv8v6c7mbc7cpj6yg532r7is6pjf9vda7317rxywy"; depends=[]; };
   rmetasim = derive { name="rmetasim"; version="2.0.4"; sha256="1a3bhiybzdvgqnnyh3d31d6vdsp4mi33sv8ks9b9xd9r369npk86"; depends=[ape ade4 gtools]; };
   R_methodsS3 = derive { name="R.methodsS3"; version="1.6.1"; sha256="1c3f64bvnpxfb3k2g7z3a6qms36z0n2hflw5w5952c82jx10cl0x"; depends=[]; };
···
   Rmisc = derive { name="Rmisc"; version="1.5"; sha256="1ijjhfy3v91fspid77rrkc5dkcb2lav37wc3f4k5lwrn24wzy5y8"; depends=[lattice plyr]; };
   Rmixmod = derive { name="Rmixmod"; version="2.0.2"; sha256="1qv6zymkgsbplrq4aa87lvcsv75dssj8qqq2h9665v31jsgx84lr"; depends=[Rcpp]; };
   RmixmodCombi = derive { name="RmixmodCombi"; version="1.0"; sha256="0cwcyclq143938wby0aj265xyib6gbca1br3x09ijliaj3pjgdqi"; depends=[Rmixmod Rcpp]; };
-  rmmseg4j = derive { name="rmmseg4j"; version="0.2-0"; sha256="1icc6a04hbqszzrs7sqp120v44g33rqgz2x926jvxvcishadnd90"; depends=[rJava]; };
-  rmngb = derive { name="rmngb"; version="0.4-1"; sha256="06ky3snnvg3rwz0cwi4j06w8spkl488rizn5ppph7ai5a92ydhx9"; depends=[]; };
+  RMKdiscrete = derive { name="RMKdiscrete"; version="0.1"; sha256="0b4adw46sn98qmy4nxv5l5svcjrp5532x7slfhhgsskqx408lzjf"; depends=[]; };
+  rmngb = derive { name="rmngb"; version="0.5-1"; sha256="0xlkf0ar14d06pxsrzakhvb0yqx13fwvlal3mwmvz4r0wg8c1vyc"; depends=[]; };
+  RMOA = derive { name="RMOA"; version="1.0"; sha256="01mrl6544wv2jc8b8gk1whs865sbv4id5sywnf1hq3r7g8wgs8lp"; depends=[RMOAjars rJava]; };
+  RMOAjars = derive { name="RMOAjars"; version="1.0"; sha256="0k3w37dwyyvfxh7a9l76cyjm27qq1clxppc5h16li2m8x68fvpjq"; depends=[rJava]; };
   RMongo = derive { name="RMongo"; version="0.0.25"; sha256="1anybw64bcipwsjc880ywzj0mxkgcj6q0aszdad6zd4zlbm444pc"; depends=[rJava]; };
   rmongodb = derive { name="rmongodb"; version="1.6.5"; sha256="0y7vj1ci5k19qdh7jznm4izsqj2v6hfjarxq31xdmymajwi171rs"; depends=[jsonlite plyr]; };
   Rmosek = derive { name="Rmosek"; version="1.2.5.1"; sha256="1ki28357ijwzzxyb820lsf8l5x2i46shar0v71k15hvf9jn0h7zm"; depends=[Matrix]; };
   rmp = derive { name="rmp"; version="1.0"; sha256="1g0785fwjbwbj82sir3n7sg3idsjzdhrpxc7z88339cv9g4rl7ry"; depends=[]; };
-  Rmpfr = derive { name="Rmpfr"; version="0.5-5"; sha256="1ddyck28wb64gk3w0fph8aqsm021zv3z98jsbcdj0by77jaigmxj"; depends=[gmp]; };
+  Rmpfr = derive { name="Rmpfr"; version="0.5-6"; sha256="0a9xfvrkx11x3yw9yp3zzsyjzmpmj2ihhdy0qmji34yxp9m1r9s6"; depends=[gmp]; };
   Rmpi = derive { name="Rmpi"; version="0.6-5"; sha256="0i9z3c45jyxy86yh3f2nja5miv5dbnipm7fpm751i7qh630acykc"; depends=[]; };
   RMRAINGEN = derive { name="RMRAINGEN"; version="1.0"; sha256="175kd803a44yblq2jw5mrn2qv4piiy249577lf684bmmajf4ird4"; depends=[copula RGENERATE RMAWGEN blockmatrix Matrix]; };
-  rms = derive { name="rms"; version="4.2-0"; sha256="1kxifrypn6a0v2rbzhn3lch821d5w9qzj9rzvrsgac4fwskis65j"; depends=[Hmisc survival SparseM]; };
+  rms = derive { name="rms"; version="4.2-1"; sha256="078i2x88r8p81mz83l0nwkhh7v0zv6229rff6lgkdv4x6qbn11x0"; depends=[Hmisc survival lattice SparseM quantreg nlme rpart polspline multcomp]; };
   rms_gof = derive { name="rms.gof"; version="1.0"; sha256="1n0h3nrp11f2x70mfjxpk2f3g4vwjaf4476pjjwy49smxxlxwz82"; depends=[]; };
   RMTstat = derive { name="RMTstat"; version="0.2"; sha256="1qp4msw8ikv6zr1j1ahxgwka7878v4av6zfqvj4j9w570v8afxvf"; depends=[]; };
   RMySQL = derive { name="RMySQL"; version="0.9-3"; sha256="1kmsrphzrk7a6f3i0pmpxlpj7w7yb5s2psx72lfv4zyd0aji83n1"; depends=[DBI]; };
   rnaseqWrapper = derive { name="rnaseqWrapper"; version="1.0-1"; sha256="1fa3hmwrpccf09dlpginl31lcxpj5ypxspa0mlraynlfl5jrivch"; depends=[ecodist gplots gtools]; };
-  RnavGraph = derive { name="RnavGraph"; version="0.1.6"; sha256="15f4az5wcmg1fv1sl34523lwcqpz6dv63z6yvnhx8hdac5ry9biw"; depends=[]; };
+  RnavGraph = derive { name="RnavGraph"; version="0.1.7"; sha256="14sgllz3jj9padhiwkb731wcn9byhqm1ba2ivpyas3121y8c7yvx"; depends=[scagnostics rgl]; };
   RnavGraphImageData = derive { name="RnavGraphImageData"; version="0.0.3"; sha256="1mrh0p2ckczw4xr1kfmcf0ri2h2fhp7fmf8sn2h1capmm12i1q8f"; depends=[]; };
   rnbn = derive { name="rnbn"; version="1.0.0"; sha256="1f3yv8cvrwlnzyk8g5b5sg5pvp6f15mi6bhfff44d0v1m6nwnp01"; depends=[RCurl RJSONIO]; };
-  RNCBI = derive { name="RNCBI"; version="0.9.1"; sha256="1gvaizcm7ajblnxkqxvdalg5kws5kfa8186hw5rr7q3dc51gxm0i"; depends=[rJava XML RNCBIEUtilsLibs RNCBIAxis2Libs]; };
-  RNCBIAxis2Libs = derive { name="RNCBIAxis2Libs"; version="0.9"; sha256="0lrvpka3bj6x6sqbjqwg8wlfgcjqq53ks4b48afqfzvqg9z8jk4d"; depends=[rJava]; };
   RNCBIEUtilsLibs = derive { name="RNCBIEUtilsLibs"; version="0.9"; sha256="1h1ywx8wxy6n2rbpmjbqw4c0djz29pbncisd0mlbshj1fw226jba"; depends=[rJava]; };
   RNCEP = derive { name="RNCEP"; version="1.0.6"; sha256="0z8fa7hgd6ss2yzpjn3d1ybqakgn76c7hp3h87ma0k03ilawxi09"; depends=[abind maps fields tgp fossil RColorBrewer]; };
   RND = derive { name="RND"; version="1.1"; sha256="1rbnjkfrsvm68xp90l4awixbvpid9nxnhg6i6fndpdmqwly2fwdp"; depends=[]; };
   rneos = derive { name="rneos"; version="0.2-7"; sha256="0vsifj6zfrdij1gjdp1dlh41cckwd04h41q30m7ard4pgyl9n7za"; depends=[RCurl XML]; };
-  RNetCDF = derive { name="RNetCDF"; version="1.6.2-3"; sha256="0drylsg3nnlb060zg7vn3n24f908mhwqf7bbw8ys32chflrdvwl2"; depends=[]; };
-  RNetLogo = derive { name="RNetLogo"; version="1.0-0"; sha256="1378v70bdk69mri6n0770q2qlch1lzi7zr2i7s9vgpnc27hxxjcx"; depends=[rJava]; };
+  RNetCDF = derive { name="RNetCDF"; version="1.6.3-1"; sha256="0c112qwxzml3mbdss69607amxvhpkfgs7ihymxidgkv0s3ra7cp5"; depends=[]; };
+  RNetLogo = derive { name="RNetLogo"; version="1.0-1"; sha256="051yx7l8qbnvb4gn67m00wnl6v0jrmavmp7n7zygjn7p1xi3w22c"; depends=[rJava igraph]; };
   RNeXML = derive { name="RNeXML"; version="1.1.3"; sha256="1fcs1fwq66fb04zi2pwgn7xfljp8053s2vb0g4j5vzv0dq7nxy98"; depends=[ape XML plyr taxize reshape2 httr uuid]; };
   rngtools = derive { name="rngtools"; version="1.2.4"; sha256="1fcgfqrrb48z37xgy8sffx91p9irp39yqzxv7nqp1x2hnwsrh097"; depends=[pkgmaker stringr digest]; };
   rngWELL = derive { name="rngWELL"; version="0.10-3"; sha256="1wijscc0s6h1ipc1r8h179y94s1bzf409xlpiyr1njaxvvvpwvw1"; depends=[]; };
···
   Rniftilib = derive { name="Rniftilib"; version="0.0-32"; sha256="1ck7ddhm759zha1iazg5razchq3gsfq3rzvfb8ichnl5l15z9ry2"; depends=[]; };
   RNiftyReg = derive { name="RNiftyReg"; version="1.1.2"; sha256="1g74qdx71wzyl0k7liwvl33rzhz7srmn15x55md5gyljxb5rqm6c"; depends=[reportr oro_nifti]; };
   rnoaa = derive { name="rnoaa"; version="0.2.0"; sha256="1v1yiwzsaqk95yxxla277bfdxs397p99y17yzh8z2m2xz54pn6sh"; depends=[httr lubridate plyr ggplot2 scales sp rgdal rgeos maptools stringr XML data_table assertthat jsonlite]; };
-  rNOMADS = derive { name="rNOMADS"; version="2.0.1"; sha256="1clycf5h7gf2dcs2x4k0nqn2qbhm94a38nwvk7v89zkwzbjiy083"; depends=[scrapeR stringr fields XML GEOmap MBA RCurl]; };
+  rnrfa = derive { name="rnrfa"; version="0.1.0"; sha256="10kh1qs65zwlqvnah2i9cks2nj5g4sw1q2a2vwzkapcmwg7hp6bv"; depends=[XML2R RCurl zoo rjson rgdal sp stringr]; };
   ROAuth = derive { name="ROAuth"; version="0.9.3"; sha256="13h0q7dx4xx7fngi3zfm92ws5x4c6cfa2svq7smmci7c0z4kirb2"; depends=[RCurl digest]; };
   RobAStBase = derive { name="RobAStBase"; version="0.9"; sha256="1428xaplcjq6r0migbaqncfj0iz8hzzfabmabm167p44wa2bwbwh"; depends=[rrcov distr distrEx distrMod RandVar]; };
-  robCompositions = derive { name="robCompositions"; version="1.8.0"; sha256="19j9x14kganramig349n5680r86f9dc83iz1h6n3626bp9da1j33"; depends=[robustbase rrcov car MASS pls]; };
+  robCompositions = derive { name="robCompositions"; version="1.9.0"; sha256="0kplw0zlszfarkhsk2hrakf649c3sl1ig8l8xhknj1v2qwkblbx2"; depends=[robustbase rrcov GGally MASS pls]; };
   robcor = derive { name="robcor"; version="0.1-6"; sha256="1hw8simv93jq8a5y79hblhqz157wr8q9dzgm0xhvvv5nkzyqkpzf"; depends=[]; };
   robeth = derive { name="robeth"; version="2.7"; sha256="03pnwd3xjb9yv8jfav0s4l9k5pgpampp15ak7z0yvkjs20rvfq3d"; depends=[]; };
   robfilter = derive { name="robfilter"; version="4.0"; sha256="1mj50531xjncg9lfidxzlyqrzwjm7pdsky88s3syspf70cjq6mg8"; depends=[robustbase MASS lattice]; };
   RobLox = derive { name="RobLox"; version="0.9"; sha256="1ws6bkzvg1y1cwmls71das0lih6gncx5w3ncd2siznapd4n44p69"; depends=[distrMod RobAStBase lattice RColorBrewer RandVar distr]; };
   RobLoxBioC = derive { name="RobLoxBioC"; version="0.9"; sha256="0ia7vn8x8whyp8kl7mpwd6fd0yv0y3pb1mppnh2329x7xdvcs5j4"; depends=[RobLox lattice RColorBrewer distr]; };
-  RobPer = derive { name="RobPer"; version="1.1"; sha256="00299p918xkrh8ifgblj98gbkfj5c0qygjh842j715kbqfg7zbfz"; depends=[robustbase quantreg BB rgenoud]; };
+  RobPer = derive { name="RobPer"; version="1.2"; sha256="1623cbza624r4f4v5z9f7gr7bvwy4qysrksizw5zpgj75xzq7ici"; depends=[robustbase quantreg BB rgenoud]; };
   RobRex = derive { name="RobRex"; version="0.9"; sha256="0ii539mjq462n1lbnyv3whl8b1agvhvlz31wwyz911gb40isl639"; depends=[ROptRegTS]; };
   RobRSVD = derive { name="RobRSVD"; version="1.0"; sha256="07z5fw8j5lq7nyxgkvb9i4iwb5inddz2ib4m2bjx6q4c1ricpqz9"; depends=[]; };
   RObsDat = derive { name="RObsDat"; version="14.04"; sha256="06454axywp5264cczhz8k31n7qmg95c2rnxv08frfgzwgm3cfzhr"; depends=[xts zoo DBI vwr e1071]; };
-  robumeta = derive { name="robumeta"; version="1.1"; sha256="1b1pms0jmyfw1hmw2gllhxica4sds427y92by3w99kf3472im3d5"; depends=[]; };
+  robumeta = derive { name="robumeta"; version="1.3"; sha256="0b4w9gv1sjcpds4i7hsqmbrc4b4x7cbv26snvzy60ng23dpyc8aq"; depends=[]; };
   robust = derive { name="robust"; version="0.4-16"; sha256="0psai9d6w7yi0wfm57cc7b2jd5i7wbk2xagrhnvhxknw0dwzf2jh"; depends=[fit_models MASS lattice robustbase rrcov]; };
   RobustAFT = derive { name="RobustAFT"; version="1.2"; sha256="156p5ic91f8qhc2g6zyrbipa58bvwq8xkpbbhnvx9kvrw8k62ibs"; depends=[robustbase survival]; };
   robustbase = derive { name="robustbase"; version="0.91-1"; sha256="1sf6dx2xjhp8ydxgv9hajjp064plr88ykg7fbglcqbl8apx9pr9h"; depends=[DEoptimR]; };
+  robustDA = derive { name="robustDA"; version="1.0"; sha256="0yp18kskj46jfhkrn96nsf9a5dw0vy52h5m23w4xrln8b6l9g978"; depends=[MASS mclust Rsolnp]; };
   robustfa = derive { name="robustfa"; version="1.0-5"; sha256="04nk5ipml54snsmiqf5sbhx490i46gnhs7yibf4wscrsj1bh2mqy"; depends=[rrcov]; };
   robustgam = derive { name="robustgam"; version="0.1.7"; sha256="0s1z7jylj757g91najbyi1aiqnssd207jfm9yhias746540qp3kw"; depends=[Rcpp RcppArmadillo mgcv robustbase]; };
   robustHD = derive { name="robustHD"; version="0.5.0"; sha256="14ql2k5880lbwkv1acydrli6jyh6dls32jjhimbz82zzkzfk2cxr"; depends=[ggplot2 perry robustbase MASS]; };
   robustlmm = derive { name="robustlmm"; version="1.6"; sha256="18lhbnmcd6nc0qr23a19mhw9k9r30li6z92g600dil6ll8s5m54z"; depends=[lme4 Matrix ggplot2 lattice nlme robustbase xtable]; };
   robustloggamma = derive { name="robustloggamma"; version="0.4-28"; sha256="0wwa7i2qw0fd5fiy45h7qiw7526zyyxx379ll4ha2n593dwhybx3"; depends=[robustbase]; };
   RobustRankAggreg = derive { name="RobustRankAggreg"; version="1.1"; sha256="1pslqyr1lji1zvcrwyax4zg2s81p1jnhfldz8mdfhsp5y7v8iar3"; depends=[]; };
-  robustreg = derive { name="robustreg"; version="0.1-3"; sha256="0llnd6yzg0kg3049pcfwjzz4hnd40w06w59kvnh01q47p4c75bkj"; depends=[]; };
+  robustreg = derive { name="robustreg"; version="0.1-7"; sha256="1nrz10065mwccil78c74vmkhinskpnk1vyp1ikrdw23vyk2l00nc"; depends=[Rcpp Matrix]; };
   robustvarComp = derive { name="robustvarComp"; version="0.1-2"; sha256="187mcpih509hx15wjjr7z2h6h76mz2v0d8xgsxjd8wz7l3dnlp2f"; depends=[robustbase GSE numDeriv robust plyr]; };
   robustX = derive { name="robustX"; version="1.1-4"; sha256="1s2aav2jr22dgrl7xzk09yn9909k76kpiz271w5r1id6hpfprjwc"; depends=[robustbase]; };
   ROC632 = derive { name="ROC632"; version="0.6"; sha256="0vgv4rclvb79mfj1phs2hmxhwchpc5rj43hvsj6bp7wv8cahfg5g"; depends=[survival penalized survivalROC]; };
   rocc = derive { name="rocc"; version="1.2"; sha256="00yxbbphhwkg4sj2h7pd9vw86yavl711nk8yylwmjd3qv39qjml0"; depends=[ROCR]; };
-  rockchalk = derive { name="rockchalk"; version="1.8.0"; sha256="17lmvdqk23jrhl8i3ygl7k49p7ckm3j5phvnxrivbnqysbz84pky"; depends=[MASS car]; };
+  rockchalk = derive { name="rockchalk"; version="1.8.86"; sha256="0rdp9dmgz2wjac1ahvivpb8fzjamr8v1vszgsjpfiyc9l90zv4bk"; depends=[lme4 car MASS]; };
   RockFab = derive { name="RockFab"; version="1.2"; sha256="1b5mhfll5vmqwl4pblmclyx9604vn07jyza02rm0jcsx915ms8sc"; depends=[rgl]; };
   rococo = derive { name="rococo"; version="1.1.2"; sha256="08204y3g3xd2srpcpnbkq1laqfr3wrhy73whlxf83gffw8j0iyv8"; depends=[Rcpp]; };
   ROCR = derive { name="ROCR"; version="1.0-5"; sha256="1zinan5hfvgg24imn0210m2lwqk5jxmmw8gz08l44j988lw8c2iw"; depends=[gplots]; };
   ROCt = derive { name="ROCt"; version="0.8"; sha256="1k0571gq7igg56qxwf9ibk28v763ji0w9183gs6qp95lpbyp5zwr"; depends=[date survival relsurv]; };
   ROCwoGS = derive { name="ROCwoGS"; version="1.0"; sha256="029nramxwhzqim315g1vkg1zsszzkic28w6ahwg9n7bk9d08adzk"; depends=[]; };
-  RODBC = derive { name="RODBC"; version="1.3-10"; sha256="0zjvyg522xwd7957vg2gy6hb8bjagn5457250aqh8f1qnpp57c48"; depends=[]; };
+  RODBC = derive { name="RODBC"; version="1.3-10"; sha256="1cswx1r0ycklqj2calhk1anmiaadx0kyazsvbsm3h5sm7wsqfw5b"; depends=[]; };
   RODBCext = derive { name="RODBCext"; version="0.2.3"; sha256="0j0774gpnd72mw3x9qv7shiwrk0s5rk8hf0wjq4iy42wwbvql7l6"; depends=[RODBC]; };
   RODM = derive { name="RODM"; version="1.1"; sha256="0cyi2y3lsw77gqxmawla5jlm4vnhsagh3ykdgb6izxslc4j2fszx"; depends=[RODBC]; };
   ROI = derive { name="ROI"; version="0.1-0"; sha256="01za8cxjf721m2lxnw352k8g32pglmllk50l7b8yhjwc49k8rl66"; depends=[registry slam]; };
···
   ROI_plugin_quadprog = derive { name="ROI.plugin.quadprog"; version="0.0-2"; sha256="0mkjq87rv1xf0bggpqd2r4gabv11spgcds2y94r3vpmh8krf71jf"; depends=[quadprog ROI slam]; };
   ROI_plugin_symphony = derive { name="ROI.plugin.symphony"; version="0.0-2"; sha256="1z4cahz0h38jw54p9363ca6i3qq7dwlm3568dr91gvpqf76b05wd"; depends=[ROI Rsymphony slam]; };
   R_oo = derive { name="R.oo"; version="1.18.0"; sha256="0difa5258i59vb538xp9p1jkzzrbmm8l35gqhpchfxk5dhn2cq9a"; depends=[R_methodsS3]; };
-  Rook = derive { name="Rook"; version="1.0-9"; sha256="013d95f2ddp0yngw7fs267k5lyksffqz61g7ngrx5faddbd6y0ym"; depends=[brew]; };
+  Rook = derive { name="Rook"; version="1.1-1"; sha256="00s9a0kr9rwxvlq433daxjk4ji8m0w60hjdprf502msw9kxfrx00"; depends=[brew]; };
+  RootsExtremaInflections = derive { name="RootsExtremaInflections"; version="1.0"; sha256="1vcbjxx1yfla71fmmf5w8dqp0vqw93dxsjsvz0vj28bfqmkmh554"; depends=[]; };
   rootSolve = derive { name="rootSolve"; version="1.6.5"; sha256="0xr6krw9f9cjc38894x4c172vhxdpy3sp6f8sc25mwvmjwidcwrn"; depends=[]; };
+  ropensecretsapi = derive { name="ropensecretsapi"; version="1.0.1"; sha256="0d4yl0h4am3blskdnzk119hk374c3vx0cg99r20w07yh8jfafrw7"; depends=[RJSONIO RCurl]; };
   ROptEst = derive { name="ROptEst"; version="0.9"; sha256="0m5czyqcsz42dzrhm3vwfmn046n57cb7x5sqzf2nad1gqgxzxp1d"; depends=[distr distrEx distrMod RandVar RobAStBase]; };
   ROptEstOld = derive { name="ROptEstOld"; version="0.9.2"; sha256="0blf34xff9pjfy983xm7a27xqkh9173nk64ysas6f0g4h31gh8ax"; depends=[distr distrEx RandVar evd]; };
   ROptRegTS = derive { name="ROptRegTS"; version="0.9.1"; sha256="1a8pbn63wh2w2n409yzbwvarvhphcn82rdqjh407ch3k3x6jz3r5"; depends=[ROptEstOld RandVar distr distrEx]; };
···
   rotations = derive { name="rotations"; version="1.2"; sha256="13z5ysjqz3qkiw4nrp9dgy55kbmff5j7m3hfp2h0sj8x1saglf66"; depends=[ggplot2 Rcpp]; };
   Rothermel = derive { name="Rothermel"; version="1.1"; sha256="1bfmqw2f0dd4dlvd1v8wr2iq5cd0a48cyrakxl1hy5461gkxvxls"; depends=[GA ftsa]; };
   RoughSets = derive { name="RoughSets"; version="1.1-0"; sha256="0v6cb0xidx2rbkgb92fahrjyy974xiaizxqryzzj1z0nnqb5zadp"; depends=[]; };
-  rowr = derive { name="rowr"; version="1.0"; sha256="0ga955991ycs9sf5za1qrrf9yggnxy1yzh2mw900h124n23pj5rv"; depends=[]; };
-  roxygen = derive { name="roxygen"; version="0.1-3"; sha256="0w2n4p4skwqr0yw49l06fxmncsplfj2q4gapdbc9wpm9w1g267fw"; depends=[digest gsubfn]; };
-  roxygen2 = derive { name="roxygen2"; version="4.0.1"; sha256="116zy31qbsqc0234g1f6n3w40awd4i8255ksyvisgk0nvmwjjs80"; depends=[stringr brew digest Rcpp]; };
+  rowr = derive { name="rowr"; version="1.0.1"; sha256="0ipm8g1ans5wmf3g24dkij1fibjh9i03bziwsxnb06ycx9ymrqqw"; depends=[]; };
+  roxygen2 = derive { name="roxygen2"; version="4.0.2"; sha256="1rn43rssbgamnfd4ipsq50mrgki5h63z898v9fjd7kr9rrrbpidm"; depends=[stringr brew digest Rcpp]; };
   royston = derive { name="royston"; version="1.0"; sha256="1hhb1v1aqvvlzirxiyhv6zahz82w2pq4d6yp3rcakq0sw7dhawn6"; depends=[nortest moments]; };
   rpanel = derive { name="rpanel"; version="1.1-3"; sha256="1wm0dcbyvxz4ily8skz2yda44n74x2nmc4pg11ja0yvk038gjfns"; depends=[]; };
   rpart = derive { name="rpart"; version="4.1-8"; sha256="1vhmwvb7hsh75lvmsjmkab2zl136irca1dhr6p57s1yhmpw4cys0"; depends=[]; };
···
   rpart_utils = derive { name="rpart.utils"; version="0.5"; sha256="00ahvmly6cdf7qhhcic0dbjlljqq8kbhx15rc7vrkd3hzd55c0im"; depends=[rpart]; };
   RPCLR = derive { name="RPCLR"; version="1.0"; sha256="03kpyszsjb656lfwx2yszv0a9ygxs1x1dla6mpkhcnqw00684fab"; depends=[MASS survival]; };
   Rpdb = derive { name="Rpdb"; version="2.2"; sha256="0gf6qab05a3ky8skbbjiadizi1gs4pcw3zp25qj5gn82lb6382pd"; depends=[rgl]; };
-  rpf = derive { name="rpf"; version="0.36"; sha256="13b6nakpbr8y4i52m8jmgavmqml99qyca8bs22s178jc72ndqyhq"; depends=[mvtnorm]; };
-  rpg = derive { name="rpg"; version="1.1"; sha256="17wfx0dfixdkw0lqh7xcq115ksj640av2jbqbpvd0l2xnpnk9sag"; depends=[Rcpp uuid RApiSerialize]; };
+  rpf = derive { name="rpf"; version="0.40"; sha256="1ix34fvws6gkpx4nhg207vm9zc89kyk2dar80fp9qm3jqafqb1mr"; depends=[mvtnorm]; };
+  rpg = derive { name="rpg"; version="1.2"; sha256="13vvym3xf70fmm57nl56dc5wvvv9va9id2agxlzxd9yrhlxbcnhm"; depends=[Rcpp uuid RApiSerialize]; };
   rphast = derive { name="rphast"; version="1.5"; sha256="0r6bk0lbqpv60byhiv847ij5bxrflrs0nsla1zrn8ww7371czsgj"; depends=[]; };
   Rphylip = derive { name="Rphylip"; version="0.1-23"; sha256="0kpqmik4bhr74ib8yvaavr10z4v4w3li5vibdhz7lvz35jfirg9r"; depends=[ape]; };
   rPlant = derive { name="rPlant"; version="2.7"; sha256="0gqxb49d6qzkd533s9qp75byvz66v1csdlnmh3m2zg96aw32178r"; depends=[rjson RCurl seqinr knitcitations]; };
-  rplexos = derive { name="rplexos"; version="0.8"; sha256="0fgb878s68fmhdkgk8v9f3rrb1v1nd1w580vwa5bv0ix9kh7dfqq"; depends=[dplyr RSQLite RSQLite_extfuns Rcpp DBI lubridate plyr reshape2 assertthat]; };
+  rplexos = derive { name="rplexos"; version="0.10.0.1"; sha256="1zqz5s5iixd7daw5wss7c12kdj2j5qrmybmhb7pgnn9zp57mxadg"; depends=[dplyr RSQLite Rcpp DBI data_table lubridate reshape2 stringi assertthat]; };
   rplos = derive { name="rplos"; version="0.4.1"; sha256="1v757v0b09mggdrgfzqmhvmf7yhqm3k42ml8sg8v4j74lscy653l"; depends=[ggplot2 RCurl RJSONIO XML plyr stringr googleVis httr lubridate reshape2 data_table whisker solr assertthat]; };
   rplotengine = derive { name="rplotengine"; version="1.0-5"; sha256="1wwpfnr5vi8z26alm8y5gply0y4iniagimldzy2z696djzz8p8p8"; depends=[xtable]; };
   RPMG = derive { name="RPMG"; version="2.1-5"; sha256="1ck6bz72h1kwi7gg8vd0zw1q61pqv23rish84zri2p18z7nd9kvh"; depends=[]; };
-  RPMM = derive { name="RPMM"; version="1.10"; sha256="0xhcf0a28zdxd6x495k9xddirkd37bzs8n99jbmsdxza19a7f0vz"; depends=[cluster]; };
+  RPMM = derive { name="RPMM"; version="1.20"; sha256="09rwrcd8jz0nii1vx0n3b4daidiq0kp0vf88bvi84y4i06743il7"; depends=[cluster]; };
   Rpoppler = derive { name="Rpoppler"; version="0.0-1"; sha256="01zsbm538yhwm1cyz5j6x2ngz05yqj16yxyvyxqhn6jp8d0885jh"; depends=[]; };
   rportfolios = derive { name="rportfolios"; version="1.0"; sha256="1zcv5ddmk15l0p03nlffimlhhpcc7l1c05xl2d1xlfk58rkvqns6"; depends=[]; };
   RPostgreSQL = derive { name="RPostgreSQL"; version="0.4"; sha256="0gpmbpiaiqvjzyl84l2l8v2jnz3h41v8jl99sp1qvvyrjrickra2"; depends=[DBI]; };
   RPPanalyzer = derive { name="RPPanalyzer"; version="1.3"; sha256="1jrij862nhwd1va54pis8shbcprjjzz22hlivzh3ifrkdf6rz4pg"; depends=[quantreg lattice gam gplots ggplot2 Hmisc]; };
-  rPref = derive { name="rPref"; version="0.1"; sha256="1mgal96qq907xj3nmzm00c9l1b1382i4p594c70wj690c4dknffp"; depends=[Rcpp dplyr igraph]; };
-  rprintf = derive { name="rprintf"; version="0.1-1"; sha256="0zdzxb3psdy51fy492rr4wnv1cw0qhyw1525aaz0lwbids1cxvwf"; depends=[stringr]; };
+  rPref = derive { name="rPref"; version="0.2"; sha256="1jqknx3sym3qngbqjpbh7iprh1xygyckpmjjalrm66l9skrwywa2"; depends=[Rcpp RcppParallel dplyr igraph]; };
+  rprintf = derive { name="rprintf"; version="0.1-2"; sha256="1jsn6i3ikcdbrg8g89hmb1ky3a84fykx5gpnbswplhidh2qhb9jz"; depends=[stringr]; };
   RProtoBuf = derive { name="RProtoBuf"; version="0.4.1"; sha256="1992nz0dz4h802gakcri1c9dgacxc5nvg3h5lm2zv6yg748ha6nh"; depends=[Rcpp RCurl]; };
   rpsychi = derive { name="rpsychi"; version="0.8"; sha256="1h40kbqvvwwjkz5hrclj6j22zhav3yyfbbhqahs1whwjkksnam4w"; depends=[gtools]; };
   rpubchem = derive { name="rpubchem"; version="1.5.0.2"; sha256="0lvi7m8jb2izsfia3c0qigsd1k1x9r02gymlwfg29pb8k10lwcjf"; depends=[XML car RCurl RJSONIO]; };
   RPublica = derive { name="RPublica"; version="0.1.1"; sha256="0m0wib0nijya228jmcl98l2hsx8l28dg6lvpwmx67jyhpvpplpkl"; depends=[XML RJSONIO RCurl]; };
   rpud = derive { name="rpud"; version="0.0.2"; sha256="03xddc6kh39wlcv8dvpnv4h0f5qx5cv327xip26zk7gg7pgrn05x"; depends=[]; };
-  RPushbullet = derive { name="RPushbullet"; version="0.0.2"; sha256="1234p26zrlvsniwaibj4795ds7j30aqkljlq9l06ivnz00rm8a5s"; depends=[RJSONIO]; };
+  RPushbullet = derive { name="RPushbullet"; version="0.1.0"; sha256="09wi6j1w169s3zzci69pl9ar8kydvnz2avhpkws2rpwm8fv6xx3n"; depends=[RJSONIO]; };
   rPython = derive { name="rPython"; version="0.0-5"; sha256="0d608v1x8walwnx7aa3m0n7999jlbiymhl7605z4n7ps6l1140mv"; depends=[RJSONIO]; };
-  RQDA = derive { name="RQDA"; version="0.2-6"; sha256="0d3jqr8bhphyi1ch9x5y0s14z86n9zspn748m9xxa15nhnyfmx3l"; depends=[RSQLite gWidgetsRGtk2 RGtk2 DBI igraph gWidgets]; };
+  RQDA = derive { name="RQDA"; version="0.2-7"; sha256="05h2f5sk0a14bhzqng5xp87li24b6n11p5lcxf9xpy7sbmh5ig6g"; depends=[RSQLite gWidgetsRGtk2 RGtk2 DBI igraph gWidgets]; };
+  rqPen = derive { name="rqPen"; version="1.0"; sha256="1vd2kjbqb5jqvbciagw03fp28ljswifznkdqj34q753kzvryblri"; depends=[quantreg]; };
   Rquake = derive { name="Rquake"; version="2.2"; sha256="0gkarqqhmiakc968ffwywkwy7npm1ly5gd6bbhr8fjfwdnhjam5n"; depends=[RPMG RSEIS GEOmap MBA minpack_lm rgl]; };
   RQuantLib = derive { name="RQuantLib"; version="0.3.12"; sha256="1ih7lkpa3p0ipgc8hs9miv500rk285ddc7pmn2qv03ibpsdlvjmq"; depends=[Rcpp]; };
   Rramas = derive { name="Rramas"; version="0.1-4"; sha256="191rm2ylvf3ffc9i4wpjvfbsinmw7s1m0wcq24j4qs4fxg8qqzyq"; depends=[diagram]; };
···
   rrcov = derive { name="rrcov"; version="1.3-4"; sha256="0k2lqwsfb9ir053m4dbz8z57xq6mlfj63i1k64p1h5jdzbpyw1ks"; depends=[robustbase pcaPP mvtnorm]; };
   rrcovHD = derive { name="rrcovHD"; version="0.2-2"; sha256="03b1mpqqhfjxjzz9agx575mcgalb7jrsv843zjqv9jp4wszprs6z"; depends=[rrcov robustbase pcaPP pls spls]; };
   rrcovNA = derive { name="rrcovNA"; version="0.4-4"; sha256="0zrzgnl83wfsaz0rma07hgb5jlmhvqwv06q7zkm65xd6mfsalqv0"; depends=[rrcov robustbase norm]; };
-  rrdf = derive { name="rrdf"; version="2.0.2"; sha256="1m1dfxi720c0xyj1x41zc4vc3dhxs9flysm4xri8b7cibx44piyk"; depends=[rJava rrdflibs]; };
-  rrdflibs = derive { name="rrdflibs"; version="1.3.0"; sha256="1qhi0diwvlw5icbym0nlg2yy8gibajycw55szsiipdxkjxj5r85l"; depends=[rJava]; };
-  Rrdrand = derive { name="Rrdrand"; version="0.1-9"; sha256="11j3zi27469nckh1irrhkm3386yagfqny7s6rh5gb7y0988194yy"; depends=[]; };
-  rredis = derive { name="rredis"; version="1.6.8"; sha256="01kksak1hdlcc2q32rzs8i45flxb7shzyq785yr0kanr54pd874z"; depends=[]; };
+  Rrdrand = derive { name="Rrdrand"; version="0.1-10"; sha256="1j72v44scmghm29jxjdy0651qlkhsnrb3bb5qff82451mbd17bzb"; depends=[]; };
+  rredis = derive { name="rredis"; version="1.6.9"; sha256="00fgrhyj6bai0kc18c2m1fsk9ja5c9q7m6dpsb8wsn4gs79mw3sc"; depends=[]; };
   RRF = derive { name="RRF"; version="1.6"; sha256="1gp224mracrz53vnxwfvd7bln18v8x7w130wslhfgcdl0n4f2d28"; depends=[]; };
   rriskDistributions = derive { name="rriskDistributions"; version="2.0"; sha256="0278426m4v7b8qb9ydzxqncayq8z25b36n4livqg40zpazp3hy85"; depends=[mc2d eha msm tkrplot]; };
   rrlda = derive { name="rrlda"; version="1.1"; sha256="06n9jah190cz25n93jlb5zb0xrx91bjvxgswwdx9hdf0fmwrpkvz"; depends=[pcaPP mvoutlier glasso matrixcalc]; };
+  RRreg = derive { name="RRreg"; version="0.1.3"; sha256="1jflg27kgiccfi5q7pv68qxv144bqipamjqmblhyk4wqd2gvarwl"; depends=[doParallel foreach]; };
   R_rsp = derive { name="R.rsp"; version="0.19.0"; sha256="0qh9nd6zpiw4c86qlwys8g7rqvay20m1yfp2zrvah5bz51hixbd1"; depends=[R_methodsS3 R_oo R_utils R_cache]; };
   rrules = derive { name="rrules"; version="0.1-0"; sha256="0f9msp289akzricjrm8dvfbh2dihfbszr7ms4fld1cr30zssajin"; depends=[]; };
   RSA = derive { name="RSA"; version="0.9.3"; sha256="132fqsr6zzv0q5maxgdh8amg6g0if3wdbhml0p0r668yy1wiq5l8"; depends=[lavaan ggplot2 lattice gridExtra plyr RColorBrewer]; };
···
   rscproxy = derive { name="rscproxy"; version="2.0-5"; sha256="1bjdv7drlnffcnyc0j8r22j7v60k1xj58bw8nk9l8wvnmngrjz86"; depends=[]; };
   RSDA = derive { name="RSDA"; version="1.2"; sha256="06sa3x0abm2gnf4i4y3d5mlqj1wl7mzzal27sa1x65awzi6rs2kz"; depends=[sqldf XML scales FactoMineR ggplot2 glmnet abind scatterplot3d]; };
   rsdepth = derive { name="rsdepth"; version="0.1-5"; sha256="064jbb6gnx0sm41w3sbi6mvsbzsfkjqfici6frk8sfm9ybvm591j"; depends=[]; };
+  rsdmx = derive { name="rsdmx"; version="0.4-1"; sha256="14403609vr563axgv3fd6ma4j403apfwbrc8dnq2mh56x9sa8jq6"; depends=[XML RCurl plyr]; };
   RSeed = derive { name="RSeed"; version="0.1.31"; sha256="0wljchzkp8800v9zcgjapkbildkb3p2xnkh1m6m7q6qqc9aw8mws"; depends=[sybil]; };
   rseedcalc = derive { name="rseedcalc"; version="1.2"; sha256="1di9bzwxyxm9gs14ks9z6sixi656hz9xwmq3aaqh53cjjr1ka0rc"; depends=[]; };
   RSEIS = derive { name="RSEIS"; version="3.3-3"; sha256="13fb4mx3sgnbrcn1kkxy0a490kikjrq49ii3x14xw2s8ci030wlr"; depends=[RPMG Rwave]; };
-  RSelenium = derive { name="RSelenium"; version="1.3.1"; sha256="0cp48ga35v82y34r362ghkargkhr0nqfn0p15yifmfmd65l9j5q5"; depends=[RCurl RJSONIO caTools XML]; };
+  RSelenium = derive { name="RSelenium"; version="1.3.5"; sha256="15pnmnljl4dm9gbcgnad5j58k6cgs6qm34829kdgyb0ygs9q7ya0"; depends=[RCurl RJSONIO XML caTools]; };
   rsem = derive { name="rsem"; version="0.4.5"; sha256="02vccj03bxisi2jwl31rwi4gw9i26g70aagdgg5gk8z0bys78v4d"; depends=[MASS lavaan]; };
   Rserve = derive { name="Rserve"; version="1.7-3"; sha256="09rha4p86vak7ss721mwp5bm5ig09xam8zlqv63n9wf36v3kdmpn"; depends=[]; };
   rSFA = derive { name="rSFA"; version="1.03"; sha256="0bgapvlx5n0984ryyh1is0w88lhxj49gcar8gkwiw455jbzx7isp"; depends=[MASS]; };
···
   RSGHB = derive { name="RSGHB"; version="1.0.2"; sha256="0ffdx9lscbgknfqhvjdh3rwnlhiqxbpqa55jkn111a1vfv726v3d"; depends=[]; };
   RSiena = derive { name="RSiena"; version="1.1-232"; sha256="0qp3bqq5p19bg47m37s2dw8m4q91hnkc2zxwhsgb076q0xvvv9xq"; depends=[Matrix]; };
   rsig = derive { name="rsig"; version="1.0"; sha256="129k78i8kc30bzlphdb68vv3sw2k6xyiwrhw08vhzz6mf3jxlqsh"; depends=[survival BBmisc glmnet superpc Matrix]; };
-  RsimMosaic = derive { name="RsimMosaic"; version="1.0.1"; sha256="10xlmzsrc4m6lsinrvl4kw0zdrqmidqi2a9s87sx1rfilvzv0ri4"; depends=[jpeg fields RANN]; };
-  RSiteCatalyst = derive { name="RSiteCatalyst"; version="1.3.3"; sha256="0z6yg403qg2b18261s3v406ji18wpsjmd7i8v7ilr94pwgx0xhcl"; depends=[digest httr rjson plyr stringr base64enc]; };
+  RsimMosaic = derive { name="RsimMosaic"; version="1.0.2"; sha256="0d5z5dffi2prz0r31x08c8gw83448bhkma5mzcmrdlg6kx5y7dp8"; depends=[jpeg fields RANN]; };
+  RSiteCatalyst = derive { name="RSiteCatalyst"; version="1.4.0"; sha256="0d5zl3a0zwj09pp1qhx8zfyazvlf9sb06cn4icg2hidzgwv749mp"; depends=[jsonlite httr plyr base64enc digest stringr]; };
   RSKC = derive { name="RSKC"; version="2.4.1"; sha256="1dvzxf001a9dg71l4bh8z3aia7mymqy800268qf7qzy9n6552g59"; depends=[flexclust]; };
-  rsm = derive { name="rsm"; version="2.06"; sha256="0pjkqdhzmnzfc400z5xpdb17v6qckpnx2qpia2hm51m7xjfhks5b"; depends=[]; };
+  rsm = derive { name="rsm"; version="2.07"; sha256="0d1kymgmprp41xvax6c5k881dxjgf6bnvpl4mh9l1pnjdcq7pyi5"; depends=[]; };
+  rsml = derive { name="rsml"; version="1.0"; sha256="1wg1j3i62kgw8ji6xfg72z3kafr8342cl0ccsnc4g2hkq5pj5yk8"; depends=[XML rgl]; };
   RSNNS = derive { name="RSNNS"; version="0.4-5"; sha256="1wk91vjgf7q65n9q8hciv08bgzawpljnhaqgy9qdwpr82v8959i7"; depends=[Rcpp]; };
   rsnps = derive { name="rsnps"; version="0.1.0"; sha256="1wpbr2sjcw6hh9sq8h2jzgvc4xlygf0kcd91sqg89nmprfw73j6c"; depends=[plyr stringr httr RCurl XML]; };
   RSNPset = derive { name="RSNPset"; version="0.2"; sha256="0ivym4ysadvlfr9k4ikpw2diil9xd3hqx6xj8jcz482d3h8qcgq6"; depends=[fastmatch foreach doRNG Rcpp]; };
   RSocrata = derive { name="RSocrata"; version="1.5"; sha256="0hbazn4c3bmx9kc030l19ciz9m0r5p6760ggyxl8f7sh8g3bqw32"; depends=[httr jsonlite]; };
   RSofia = derive { name="RSofia"; version="1.1"; sha256="0q931y9rcf6slb0s2lsxhgqrzy4yqwh8hb1124nxg0bjbxvjbihn"; depends=[Rcpp]; };
   Rsolnp = derive { name="Rsolnp"; version="1.14"; sha256="0i5d8133vg0939j5772nbw1wd4cyp6q4684iqnl12qkk30hnh94s"; depends=[truncnorm]; };
-  Rsomoclu = derive { name="Rsomoclu"; version="1.3.1"; sha256="106cbp8vm5sx8h6k0ddlp51r65jl0d6c0bz29vp8z4adx8ikacsm"; depends=[Rcpp]; };
+  Rsomoclu = derive { name="Rsomoclu"; version="1.4.1"; sha256="0yr0nsm2b7wg1x57db9zclqnqqbmhyax9vgw13ynqirq2ysxxsg6"; depends=[Rcpp]; };
   rspa = derive { name="rspa"; version="0.1-5"; sha256="18p2q2q372vbf90dfilcah07w1ivb34mv7rm5882z2s1jlixa5dk"; depends=[editrules]; };
   rspear = derive { name="rspear"; version="0.1-2"; sha256="1rjg84plnvlcp3p2929f1afl43lb92d3bfsvlhsaw92z7iva1vad"; depends=[plyr]; };
   RSpincalc = derive { name="RSpincalc"; version="1.0.1"; sha256="0n751l329j9pgpdnqrdnf93i9l1qxfp2bl4v4ray3nrnjx8g5mc9"; depends=[]; };
   rsprng = derive { name="rsprng"; version="1.0"; sha256="1sfjwfm03pn73mcq4f2chsldjlhmpjxhqkpmaqf71jbmb7ph41ip"; depends=[]; };
-  RSQLite = derive { name="RSQLite"; version="0.11.4"; sha256="0300q901bc0zypvapq8kp0ixpm4vbg5a27bkg9k0s4m3l7rcp85v"; depends=[DBI DBI]; };
-  RSQLite_extfuns = derive { name="RSQLite.extfuns"; version="0.0.1"; sha256="03ixy1q5dv4fnp4m1h75c7rvgfgfyxk5hgzd7fl7pqa1q13pjp6a"; depends=[RSQLite]; };
+  RSQLite = derive { name="RSQLite"; version="1.0.0"; sha256="08b1syv8z887gxiw8i09dpqh0zisfb6ihq6qqr01zipvkahzq34f"; depends=[DBI]; };
+  RSQLServer = derive { name="RSQLServer"; version="0.1.1"; sha256="0xaw8a06xgc78hjg4bndip0jpc7l4glk28pggm2l3j31ybx81kw7"; depends=[DBI rJava RJDBC]; };
   Rssa = derive { name="Rssa"; version="0.11"; sha256="06mg1fdviayvhc50p9l5imh431b7cb3f3x3pl513phwhsv0qc0lk"; depends=[svd forecast lattice]; };
   rstiefel = derive { name="rstiefel"; version="0.9"; sha256="1l80bx07swalh5dbx34zwjza3xf3nk1kp1832v6hzk60i5xycdxd"; depends=[]; };
   RStorm = derive { name="RStorm"; version="0.902"; sha256="1apk358jwzg5hkrcq8h39rax1prgz9bhkz9z51glmci88qrw1frv"; depends=[plyr]; };
   rstream = derive { name="rstream"; version="1.3.2"; sha256="1habswhdlx7l92s9p9554px4kf9f9mhk5vkdq2fv4wk3381c0fgi"; depends=[]; };
   rstudioapi = derive { name="rstudioapi"; version="0.1"; sha256="027482pbdxnfhcpdw2ns2qhpa18zri71nz8fk0svq6900m2237h8"; depends=[]; };
-  rsubgroup = derive { name="rsubgroup"; version="0.5"; sha256="1hrsp920gv0fr7s3w07vxish6wk3wnhd1rj04zvndd563fxvnl0l"; depends=[rJava foreign]; };
+  rsubgroup = derive { name="rsubgroup"; version="0.6"; sha256="1hz8rnbsl97ch6sjwxdicn2sjyn6cajg2zwmfp03idzpb3ixlk7l"; depends=[rJava foreign]; };
   Rsundials = derive { name="Rsundials"; version="1.6"; sha256="0vrvxsznbclgls4jljc59lyli6cw9k1a3wapfrs6xbkqi8865iif"; depends=[]; };
-  RSurvey = derive { name="RSurvey"; version="0.8-0"; sha256="1kc07hvvpyk83ci0x6g0lmnxksd91y2ilfalbhlbp69jid111k1v"; depends=[sp rgeos MBA]; };
+  rsunlight = derive { name="rsunlight"; version="0.3.0"; sha256="148byg8180657ny01xny28sdawbq87hf89f8c1rzfjl5qwcxmbqd"; depends=[httr plyr jsonlite stringr assertthat]; };
+  RSurvey = derive { name="RSurvey"; version="0.8-2"; sha256="1fksjbzny0wl0k2sj3bxflzim7i8r5dfwz9ih4ssk5xaxfmjz2f5"; depends=[sp rgeos MBA]; };
   RSvgDevice = derive { name="RSvgDevice"; version="0.6.4.4"; sha256="0vplac5jzg6bmvbpmj4nhiiimsr9jlbk8mzyifnnndk9iyf2lcmz"; depends=[]; };
   RSVGTipsDevice = derive { name="RSVGTipsDevice"; version="1.0-4"; sha256="1ybk5q4dhskrh7h1sy86ilchdwi6rivy3vv3lph6pms2virgm854"; depends=[]; };
   Rsymphony = derive { name="Rsymphony"; version="0.1-17"; sha256="1wg1l4535xmrqvyhf23b9kw3ggqxlcrig0x0dnhx0m2qr9v3ijni"; depends=[]; };
···
   rtf = derive { name="rtf"; version="0.4-11"; sha256="04z0s5l9qjlbqahmqdaqv7mkqavsz4yz25swahh99xfwp9plknfl"; depends=[R_oo R_methodsS3]; };
   rtfbs = derive { name="rtfbs"; version="0.3.2"; sha256="1v26znlispc8304xid0dsflphiwzil6nrxlsgj8dkp4prh6hdb34"; depends=[rphast]; };
   rtiff = derive { name="rtiff"; version="1.4.4"; sha256="13cz35dfz735yk2lci8cmjmsg4ddm31lv98lpx8ymy3bwmzdmc3c"; depends=[pixmap]; };
+  rtkpp = derive { name="rtkpp"; version="0.8.3"; sha256="1ch78j27kwnpymy6wic8w2wzy2qa75m7wbxqb1k302l5hwylbjcs"; depends=[Rcpp]; };
   RTOMO = derive { name="RTOMO"; version="1.1-2"; sha256="15swp7jx5xmj87hjcfdar3r5sqnnb795qclf8b7l4bvx80h9nh2i"; depends=[RPMG GEOmap RSEIS splancs]; };
   rtop = derive { name="rtop"; version="0.3-45"; sha256="0dh7jlnakk1hd27swspa0fj6pq6yddxhz32w3d7xq8jgr7xm8d70"; depends=[sp gstat]; };
   RTriangle = derive { name="RTriangle"; version="1.6-0.6"; sha256="1g4dp792awbvsl35nvyd8gkx99p2njdcafin16qysfrjl43f5i4s"; depends=[]; };
   rts = derive { name="rts"; version="1.0-3"; sha256="0jqk0p2q1vx9l6zf9pbc5k3lsw4hg5x1r6p0f7wjiks50x55pbl4"; depends=[raster xts zoo]; };
-  Rtsne = derive { name="Rtsne"; version="0.8"; sha256="153f02f6iizd9986d6hxvpdddrwhnjy9a9yyrch2zcmcbh63hfba"; depends=[Rcpp]; };
-  Rttf2pt1 = derive { name="Rttf2pt1"; version="1.3.1"; sha256="0hz7fgj2p410m19r88qqdm9cc5m729sgacinazfsi93qz9rp1r51"; depends=[]; };
-  rtype = derive { name="rtype"; version="0.1"; sha256="14x86lhy5fmh2k1463p4v0lhsy51q0fkyg0jgnh7g65sry41bd68"; depends=[]; };
+  Rtsne = derive { name="Rtsne"; version="0.9"; sha256="1b3ilfirlhmbv1914rwnj9mamn6clzi86csp3szfwg93gk23yymn"; depends=[Rcpp]; };
+  Rttf2pt1 = derive { name="Rttf2pt1"; version="1.3.2"; sha256="1x8lfymbp5z8vkl13cdhzqlmz47an5cdxjjs75qrikbqvyqzjr5d"; depends=[]; };
+  rtype = derive { name="rtype"; version="0.1-1"; sha256="0wjf359w7gb1nrhbxknzg7qdys0hdn6alv07rd9wm6zynnn1vwxy"; depends=[]; };
   Ruchardet = derive { name="Ruchardet"; version="0.0-3"; sha256="0dgldi6fgp949c3455m9b4q6crqv530jph210xzph41vgw8a2q2v"; depends=[Rcpp]; };
+  rucm = derive { name="rucm"; version="0.4"; sha256="1s3q6wfp9nb50rqsaq6h2wb48qvxncmlf8l4gm18pr25wkangfxq"; depends=[KFAS]; };
   rugarch = derive { name="rugarch"; version="1.3-3"; sha256="16vjk4vmsp35dgyb17c43q29z2laq320x6g73p5jc7l6xdjd3v5b"; depends=[Rsolnp nloptr ks numDeriv spd xts zoo chron SkewHyperbolic expm Rcpp]; };
-  RUnit = derive { name="RUnit"; version="0.4.26"; sha256="0glz0ag2za5g4k8fjnsr97504bfk9d6khly1rqrrngg4qxz5wlf0"; depends=[]; };
+  RUnit = derive { name="RUnit"; version="0.4.27"; sha256="11hxy1n2rds3yl0zr0lg3dj7cfjlhk9r2ig6r9jl57b53g802kf7"; depends=[]; };
   Runiversal = derive { name="Runiversal"; version="1.0.2"; sha256="0667mspsjydmxi848c6wsf14gz72bmdj9b3lilma92b7fhqnv7ai"; depends=[]; };
   runjags = derive { name="runjags"; version="1.2.1-0"; sha256="0rsqyrk9vzrnhw66c7hdqnbnvk6qsl882fshh2njzivaqxk2ibqq"; depends=[lattice coda]; };
-  Runuran = derive { name="Runuran"; version="0.20.0"; sha256="1syzrmkw96gsw7vf10f1515zdqm9hdmq1v6yf1nbmipil1nkgsqs"; depends=[]; };
+  Runuran = derive { name="Runuran"; version="0.21.0"; sha256="1p33z9h2zj6fx42rlq6yajd6lwvzy4a1a5gs67dz5k1zbza8avw0"; depends=[]; };
   RunuranGUI = derive { name="RunuranGUI"; version="0.1"; sha256="0wm91mzgd01qjinj94fr53m0gkxjvx7yjhmwbkrxsjn6mjklq72l"; depends=[Runuran rvgtest gWidgets gWidgetsRGtk2 cairoDevice]; };
-  R_utils = derive { name="R.utils"; version="1.32.4"; sha256="12ypy8sxk5w1a3mpg4hi6k5db7ydrlj7qmp2lzh1rzcpbdg3wgka"; depends=[R_oo R_methodsS3]; };
+  R_utils = derive { name="R.utils"; version="1.34.0"; sha256="1brpj67px14d1y5ax3j49sbf7dnnj1rcbhli5ph44y65snrmdaih"; depends=[R_oo R_methodsS3]; };
+  ruv = derive { name="ruv"; version="0.9.4"; sha256="07bvyqrkm10vh63l8dm93spd7l0v105a87lsbjw4vg65czp1iayg"; depends=[]; };
   rv = derive { name="rv"; version="2.3.1"; sha256="0bjqwk7djl625fws3jlzr1naanwmrfb37hzkyy5szai52nqr2xij"; depends=[]; };
-  RVAideMemoire = derive { name="RVAideMemoire"; version="0.9-38"; sha256="02683sklihj3726a90jryybf855rvbz9v3dm9z9yhb32q9bfmy34"; depends=[ade4 boot car lme4 lsmeans MASS mixOmics multcomp statmod]; };
+  RVAideMemoire = derive { name="RVAideMemoire"; version="0.9-40"; sha256="0vw0na9kjhcdhwxfy6rxhk8db2z92a5lf63n5mzm7jp5479zi12b"; depends=[ade4 boot car lme4 lsmeans MASS mixOmics multcomp statmod]; };
   rvalues = derive { name="rvalues"; version="0.2"; sha256="1zc4irq0s9mm7yz8pc3n9il0z508wwf2a2j741wyyw90f35fasi0"; depends=[]; };
-  Rvcg = derive { name="Rvcg"; version="0.8"; sha256="086r4vvqidwzikdmvij52nqgb1ka5z5f0k9c9qi6izn450lpf34y"; depends=[Rcpp]; };
+  Rvcg = derive { name="Rvcg"; version="0.9"; sha256="0p5qnw7jqq5ia36431ywp5mwcx09lsx0pnrw0n4fvc7zvgjjqs3c"; depends=[Rcpp]; };
   rvertnet = derive { name="rvertnet"; version="0.0-5"; sha256="1rj6csx2qb094wgkablrpzlbqb0hpzg5d29xrar2cy39gjmz40cj"; depends=[RCurl plyr RJSONIO httr ggplot2 maps]; };
   rvgtest = derive { name="rvgtest"; version="0.7.4"; sha256="1lhha5nh8fk42pckg4ziha8sa6g20m0l4p078pjj51kz0k8929ng"; depends=[]; };
   rvHPDT = derive { name="rvHPDT"; version="3.0"; sha256="05nrfnyvb8ar7k2bmn227rn20w1yzkp1smwi4sysc00hyjrlyg8s"; depends=[gtools]; };
···
   RWekajars = derive { name="RWekajars"; version="3.7.11-1"; sha256="1w8y8xxsmm9b7hnnwknsbivkgbarnfqmv9666b7c5db9yra1hf7f"; depends=[rJava]; };
   RWiener = derive { name="RWiener"; version="1.2-0"; sha256="1ssh4xcyr4whgyd91p6bjsm9mq1ajqjqva0yyk13dnf5jfpsr0gs"; depends=[]; };
   Rwinsteps = derive { name="Rwinsteps"; version="1.0-1"; sha256="0kzngkan9vydibnr3xm4pyz4v6kz0r4h19f0ngqpri07fkhdsxzd"; depends=[]; };
-  rwm = derive { name="rwm"; version="1.53"; sha256="0x19502xzc3x90iwvhvj24w36qab79v4y7mb37ax8a0n3pw6rah8"; depends=[]; };
   rworldmap = derive { name="rworldmap"; version="1.3-1"; sha256="0wrg6ap39bq88sv5axxd90yyqafn77amk5429pxd9v5a2hdm3g8w"; depends=[sp maptools fields]; };
   rworldxtra = derive { name="rworldxtra"; version="1.01"; sha256="183z01h316wf1r4vjvjhbj7cg4xarn4b8qbmnn5y7nrrdndzi163"; depends=[sp]; };
   rwt = derive { name="rwt"; version="1.0.0"; sha256="112wp682z4gkxsd3bqnlkdrh42bfzwnnhzyangxi2dh0qw63bgcr"; depends=[matlab]; };
···
   RXKCD = derive { name="RXKCD"; version="1.7-5"; sha256="0dsds1bv2vfq61gfppar2ai23dryh09ric5i6zaccms6q64z23md"; depends=[RJSONIO png jpeg plyr]; };
   RXMCDA = derive { name="RXMCDA"; version="1.5.3"; sha256="1pc52kvihxzq12p95r4srmnawxcsvd4r7252dajby338p56d1lw8"; depends=[XML kappalab]; };
   RXshrink = derive { name="RXshrink"; version="1.0-8"; sha256="0l4aknr1vxrkxqsgkjcffs0731jskyzvl055a01vd8h4a0826n5s"; depends=[lars]; };
-  Ryacas = derive { name="Ryacas"; version="0.2-11"; sha256="116ncg48ih1v3ra095k63ccqchfbvzixh3cfjb2bbc47a9zh8phc"; depends=[XML]; };
+  Ryacas = derive { name="Ryacas"; version="0.2-12.1"; sha256="18dpnr6kj0a8f2jcbj9f6ahd0mg7bm1qm8dcs1wh8kmjl3klr1y8"; depends=[XML]; };
   RYoudaoTranslate = derive { name="RYoudaoTranslate"; version="1.0"; sha256="1i3iyqh97vpn02bm66kkmw52ni29js30v18n2aw8pvr88jpdgxm4"; depends=[RCurl rjson]; };
   ryouready = derive { name="ryouready"; version="0.3"; sha256="0nms3zfkis2fsxkyj3dr95vz3kk6pkm7l5ga7iz8pxy1ywrawj2i"; depends=[stringr car]; };
   rYoutheria = derive { name="rYoutheria"; version="1.0.0"; sha256="1yj66ars5a8mbv2axl6l5g7wflwz3j4mhwk3iz5w33rfhixixm9l"; depends=[plyr RJSONIO reshape2 RCurl]; };
-  rysgran = derive { name="rysgran"; version="2.1.0"; sha256="1l2mx297iyipap8cw2wcw5gm7jq4076bf4gvgvij4q35vp62m85z"; depends=[soiltexture lattice]; };
+  rysgran = derive { name="rysgran"; version="2.1.0"; sha256="1l2mx297iyipap8cw2wcw5gm7jq4076bf4gvgvij4q35vp62m85z"; depends=[lattice]; };
   Rz = derive { name="Rz"; version="0.9-1"; sha256="1cpsmfxijrfx06ydpjzbaak7gkad4jjk1ph9453l9zly1cwzgspj"; depends=[foreign memisc psych ggplot2 RGtk2 formatR]; };
   rzmq = derive { name="rzmq"; version="0.6.8"; sha256="0likcj1xivr0y42krnm5zynkr6slfc3yqq2nd90x79ldvbfdqxc6"; depends=[]; };
   s20x = derive { name="s20x"; version="3.1-10"; sha256="0hxi8d1pl0jgg66jxzz0z973sg3f4s1jf75smmizy99kd76rdnh0"; depends=[]; };
   s2dverification = derive { name="s2dverification"; version="2.1.1"; sha256="1m3m5sbq96fhnl4slxgb2j0009kqfdivdn3nbb203pc0knjpflnq"; depends=[GEOmap geomapdata maps mapproj]; };
   s4vd = derive { name="s4vd"; version="1.0"; sha256="07pnkhyqf9iymj913813d93dmb3iqbdlcl0gsgacihyyinb4id5s"; depends=[biclust]; };
   sac = derive { name="sac"; version="1.0.1"; sha256="1rl5ayhg5y84fw9w3zf43dijjlw9x0g0w2z4haw5xmxfni72ms8w"; depends=[]; };
+  saccades = derive { name="saccades"; version="0.1"; sha256="0bmwqfhdqf4j0xpyfzzgl6h35r3wgjmkrmnwn9l17648f236d7c8"; depends=[zoom]; };
   sads = derive { name="sads"; version="0.1.10"; sha256="02662vbbk3jikp506ljil9zqchs6bq3lsw4fwbbi2wgg7xvb260g"; depends=[MASS bbmle poilog VGAM untb]; };
   sae = derive { name="sae"; version="1.0-2"; sha256="0a9g07m1a8v4iw9pnzlws356kv4f77qkz5yc454i7130zfp2kxxi"; depends=[nlme MASS]; };
   saemix = derive { name="saemix"; version="1.2"; sha256="1whwn54iiapdfig6qpzji3z3skir6jrs34dq78zlynibgrg95hx6"; depends=[]; };
+  saery = derive { name="saery"; version="1.0"; sha256="09x1v627llqbpiwkh1wr0z7gsndfdrjzag2hprhq1adbzh05k47z"; depends=[]; };
+  saeSim = derive { name="saeSim"; version="0.6.0"; sha256="10gvbzscnhc42a8z2jq8951i74v8pq7xsh3v3zsk2k4g8sx9hdy2"; depends=[dplyr ggplot2 MASS spdep]; };
   SAFD = derive { name="SAFD"; version="0.4"; sha256="1zbja8bgva2j24ks4m14hbf4s0n674lj89nfxkkmwrljzsmjrjhv"; depends=[]; };
   safeBinaryRegression = derive { name="safeBinaryRegression"; version="0.1-3"; sha256="1g68r6pp5l41rbgyfqgcha1gpsisnl0ybdmdqr4ylr43f61dpgvd"; depends=[lpSolveAPI]; };
+  safi = derive { name="safi"; version="1.0"; sha256="1km58w57kdmyfj4a97zhnjcka4q4pxm8r2br01qq2niaihpbzp98"; depends=[]; };
   SAM = derive { name="SAM"; version="1.0.5"; sha256="1fki43bp6kan6ls2rd6vrp1mcwvz92wzcr7x6sjirbmr03smcypr"; depends=[]; };
   SamplerCompare = derive { name="SamplerCompare"; version="1.2.5"; sha256="1p05fb6g0rwkzz0qp8hx88skxvfq265ndv9g694gc2h8vzwpan1y"; depends=[mvtnorm]; };
   sampleSelection = derive { name="sampleSelection"; version="1.0-2"; sha256="1hzvvwvqp6v9d6ldm17kx3g8pbgngw2pxklny0b3man47zh5jshc"; depends=[maxLik miscTools systemfit Formula]; };
   samplesize = derive { name="samplesize"; version="0.1-8"; sha256="0w4aa6p0j7l9xykhgqv7yps2nxx11q1mrgivdnv4si8fbkqx148n"; depends=[]; };
   Sample_Size = derive { name="Sample.Size"; version="1.0"; sha256="1vfnb2gg3rax4sxd81xqznfvh300nv45nn7zjsyrdjyg1n3ym7nw"; depends=[]; };
-  samplesize4surveys = derive { name="samplesize4surveys"; version="0.5.1"; sha256="0qinzr55ldg7ngsa9lzwwwysjfk3230xs7kcqkvimnrn5z4n898v"; depends=[TeachingSampling]; };
+  samplesize4surveys = derive { name="samplesize4surveys"; version="2.1.0"; sha256="08vs1b4rwyd4yh3y2l1gkh8wpjhh2w52929p6b0sfj0iywp2dr03"; depends=[TeachingSampling]; };
   SampleSizeMeans = derive { name="SampleSizeMeans"; version="1.1"; sha256="1wbc46n8b8wbcxl21blbzs5728dr8r0l8d3jpzbha8pcav0xrh1m"; depends=[]; };
   SampleSizeProportions = derive { name="SampleSizeProportions"; version="1.0"; sha256="0mvkvx3nni0l8ys68sq3h2zlbjvksdcdzxqlf03k0ca5bbcmdf9l"; depends=[]; };
   sampling = derive { name="sampling"; version="2.6"; sha256="11r8p29kwc0ggycbv7sm1zmazmfm4p5207l764ad4znjib0cab6p"; depends=[MASS lpSolve]; };
   samplingbook = derive { name="samplingbook"; version="1.2.0"; sha256="1vynz6hsnz5d0vg66f8k67h24rb809k9chb4waymk6vwnp8lksz9"; depends=[pps sampling survey]; };
   samplingEstimates = derive { name="samplingEstimates"; version="0.1-3"; sha256="1srdchlpxksfdqhf5qdvl7nz0qsxkxww7hzqj0q71asbzlq3am3p"; depends=[samplingVarEst]; };
-  SamplingStrata = derive { name="SamplingStrata"; version="1.0-2"; sha256="04mb14hb328s4smpfidxf448mpa1cij9lbsfii7j0a0qx9nwapy2"; depends=[]; };
+  SamplingStrata = derive { name="SamplingStrata"; version="1.0-3"; sha256="16nrcv5hbbvn4rgckzagi84i7h49bd878mnpknlzmzr5ykzywsay"; depends=[]; };
   samplingVarEst = derive { name="samplingVarEst"; version="0.9-9"; sha256="04wgsq3sh69iy8p07ch210p22n5mds7cxp5s6zggzamqpf0hpnw7"; depends=[]; };
   sampSurf = derive { name="sampSurf"; version="0.7-2"; sha256="1bj1m5c8bx8i4jyk6kdgcfmgfj15iirxwg259r0c4fk7whcnfz59"; depends=[sp raster rasterVis boot]; };
   samr = derive { name="samr"; version="2.0"; sha256="0rsfca07pvmhfn7b49yk2ycw00wsq6dmrpv9haxz8q0xv7n5n2q9"; depends=[matrixStats]; };
   SAMURAI = derive { name="SAMURAI"; version="1.2.1"; sha256="02fipbjcsbp2b2957x6183z20icv1yly2pd1747nyww9bmpa7ycm"; depends=[metafor]; };
   sand = derive { name="sand"; version="1.0.2"; sha256="1y371ds86gcq2id996vp56h5dax2wm0mlk1ks2mp1k81n63l7wmf"; depends=[igraph igraphdata]; };
-  sandwich = derive { name="sandwich"; version="2.3-1"; sha256="1yjbqzsv742m74gz57bnj1jmjw5n5qqp057fkz490l7b65kj9nqn"; depends=[zoo]; };
+  sandwich = derive { name="sandwich"; version="2.3-2"; sha256="10ag2iwwxcwgbmbibfkpxxc8iih7bmya57zl4g983fb7zyd36mhz"; depends=[zoo]; };
   sanitizers = derive { name="sanitizers"; version="0.1.0"; sha256="1c1831fnv1nzpq8nw9krgf9fm8v54w0gvcn4443b6jghnnbhn2n6"; depends=[]; };
-  sanon = derive { name="sanon"; version="1.3"; sha256="0kh2gvcd7nxcgfswhspw9xw68sk0kcrcv86h8ysfrwxi35ln6a75"; depends=[]; };
+  sanon = derive { name="sanon"; version="1.4"; sha256="0zg0paiz3rb0fk2mgi8rlzqy9vq3afy5vx6s15k1xqz8rjgsbd1x"; depends=[]; };
   sapa = derive { name="sapa"; version="2.0-0"; sha256="04zf1xs4w7s28mvc272la8z3r1slnf50pw0k8zj335j3i56x6b9y"; depends=[ifultools splus2R]; };
   SAPP = derive { name="SAPP"; version="1.0.4"; sha256="0a86vz390v2g5lz1r33qrmhgvak4rpfmpxy39shnivhagnrsarkl"; depends=[]; };
+  saps = derive { name="saps"; version="1.0.0"; sha256="02si76ckinkm4ajclq4isy6gi0cf1mwfrq3w17i5gflbfqmf2qvj"; depends=[survival reshape2]; };
   sas7bdat = derive { name="sas7bdat"; version="0.5"; sha256="0qxlapb6wdhzpwlmzlhscy3av7va3h6gkzsppn4sx5q960310an3"; depends=[]; };
   SAScii = derive { name="SAScii"; version="1.0"; sha256="0nq859xmrvpbifk8q1kbx3svg61rqdg8p8gr1pn85fr0j3w7h666"; depends=[]; };
   SASmixed = derive { name="SASmixed"; version="1.0-4"; sha256="0491x4a3fwiy26whclrc19alcdxccn40ghpsgwjkn9sxi8vj5wvm"; depends=[]; };
···
   SBSA = derive { name="SBSA"; version="0.2.3"; sha256="1v23lzzziyjlvgn5p2n1qcq2zv9hsyz2w15lbnfi5wvinxhlg8sc"; depends=[Rcpp]; };
   sca = derive { name="sca"; version="0.8-9"; sha256="024yxm1rlyz3hx9viv2nb6rapy938diaknc3nzkgq0ffky2gf0s3"; depends=[]; };
   scagnostics = derive { name="scagnostics"; version="0.2-4"; sha256="0fhc7d2nfhm8w6s6z1ls6i8d7c90h4q7rb92rz8pgq3xh031hpcf"; depends=[rJava]; };
-  scaleboot = derive { name="scaleboot"; version="0.3-3"; sha256="0w3gwqxshiypbixrdjg3p5z3qfp0nf9gv838z9hlbf0xpzgk11xa"; depends=[]; };
   scales = derive { name="scales"; version="0.2.4"; sha256="08dryii8ibh16wxs61pam07b24rwhqvdcdhk09mij289l309192v"; depends=[RColorBrewer dichromat munsell plyr labeling]; };
   scalreg = derive { name="scalreg"; version="1.0"; sha256="06iqij1cyiw55ijzk2byrwh3m5iwsra7clx8l4v69rc236q8zbdi"; depends=[lars MASS]; };
-  scam = derive { name="scam"; version="1.1-7"; sha256="0wjpc5fcr4409gnanq7xnmlai51my86zndsxh5lw418ywdgcbyn4"; depends=[mgcv Matrix]; };
+  scam = derive { name="scam"; version="1.1-8"; sha256="1190xdahr4cx50qn32lxqm3p8m9c3968qx6f5mpyicaw34j9whz4"; depends=[mgcv Matrix]; };
   scape = derive { name="scape"; version="2.2-0"; sha256="0dgbh65fg6i5x4lpfkshn382zcc4jk1wp62pwd2l2f59pyfb92a3"; depends=[coda Hmisc lattice]; };
   scar = derive { name="scar"; version="0.2-1"; sha256="04x42414qxrz8c7xrnmpr00r46png2jy5giwicdx6gx8jwrkzhzs"; depends=[]; };
-  scaRabee = derive { name="scaRabee"; version="1.1-3"; sha256="1fdxmk2mbrynxh6zy0xjmcwa384n5bppl1vzmfj5rjw840f7hbrk"; depends=[neldermead lattice deSolve]; };
+  scaRabee = derive { name="scaRabee"; version="1.1-3"; sha256="1yap3hi36f8hk93jn59nxrbgq8iw0xwkkm3pc2gb50cpcpaq41pd"; depends=[neldermead lattice deSolve]; };
   scatterplot3d = derive { name="scatterplot3d"; version="0.3-35"; sha256="1w0r7cyz01rzmgcf2x7wa4xs88ga6fd67wksyjyzrh2pdcbc56yx"; depends=[]; };
   SCBmeanfd = derive { name="SCBmeanfd"; version="1.1"; sha256="0pcyrnzlnlyn4v3lyv7pv01v2lh4vig1x4x8g98lpccpi1bimd4z"; depends=[boot KernSmooth]; };
   SCEPtER = derive { name="SCEPtER"; version="0.1-0"; sha256="13jnqcgsz3rz5dis8jmbma1m6z72qphdjyjf3984c66clhazxnh9"; depends=[MASS]; };
   SCEPtERextras = derive { name="SCEPtERextras"; version="0.1-0"; sha256="1vv231h744c7j7rvcb2xaffmwdd9ms76yvvw2l3xcb72iwhl5dbw"; depends=[]; };
-  SCGLR = derive { name="SCGLR"; version="2.0"; sha256="0pgix9i520yj7gpby3fcykvk9nnq1pl8b0akyhdv5l6vax9d5bg4"; depends=[Matrix Formula expm ggplot2 ROCR]; };
-  scholar = derive { name="scholar"; version="0.1.1"; sha256="1wlhxw5k28qypfl6dm07cjrpvpmvcbwn1fc7205xpj20f41jchra"; depends=[stringr plyr R_cache XML]; };
+  SCGLR = derive { name="SCGLR"; version="2.0.1"; sha256="1xanlanxq3qwj7zad6zk1fy4cpbg2ns4dxvnfld209ra3y4jmbkx"; depends=[Matrix Formula expm ggplot2 ROCR]; };
+  scholar = derive { name="scholar"; version="0.1.2"; sha256="1h1a6psgmiifi7p87ar3fr0mcfmg44yh4683dmqxrxrfcvgaxvca"; depends=[stringr plyr R_cache XML]; };
   schoolmath = derive { name="schoolmath"; version="0.4"; sha256="06gcmm294d0bs5whvknrq48sk7li961lzy4bcncjg052zbbpn67x"; depends=[]; };
-  schoRsch = derive { name="schoRsch"; version="1.0"; sha256="15kjab5cpss2kkf3pd2nyszdsfn77840zx7yrbkry6n7xb4x8icn"; depends=[]; };
+  schoRsch = derive { name="schoRsch"; version="1.1"; sha256="0bi2vn9qr49yy3g45xgglqn1b5b6z8cbn9phzmqjc1v7rn80s5zg"; depends=[]; };
   schwartz97 = derive { name="schwartz97"; version="0.0.6"; sha256="0l34f30l75zrg3n377jp0cw7m88cqkgzy6ql78mrx8ra88aspfzn"; depends=[FKF mvtnorm RUnit]; };
   SCI = derive { name="SCI"; version="1.0-1"; sha256="1m5a15a4n0zjqykq38pyw9133g2ih4ykbgak8c8khq8p0isnl8qb"; depends=[fitdistrplus lmomco]; };
   scidb = derive { name="scidb"; version="1.1-2"; sha256="1nkyzvjpacm4imv778nc6gc468419shkyhxb59hsaw9840wcs1na"; depends=[Matrix iterators RCurl zoo]; };
···
   SCMA = derive { name="SCMA"; version="1.1"; sha256="0bims9l047xvbwp2r5ly5cgpd7fc0p2cik48gg42abwdqvppf542"; depends=[]; };
   SCORER2 = derive { name="SCORER2"; version="0.99.0"; sha256="1a28wga69ip9s98ch2dqgl0qkwa3w6frmaqcvhclc360ik813mxq"; depends=[]; };
   scoring = derive { name="scoring"; version="0.5-1"; sha256="0vxjcbp43h2ipc428qc0gx7nh6my7202hixwhnmspl4f3kai3wkp"; depends=[]; };
-  ScottKnott = derive { name="ScottKnott"; version="1.2-4"; sha256="0s2b74isklmjjz5qzb0sg2lzqxv3bka2wxcja1lg49npmv70kly7"; depends=[]; };
+  ScottKnott = derive { name="ScottKnott"; version="1.2-5"; sha256="1ywwhdghcy30mp2nhsk2yhgb37nrdmb9yan5vvzsg66bchc3xgll"; depends=[]; };
   scout = derive { name="scout"; version="1.0.3"; sha256="0wmjmk0ckd211cq5ykd0yzjschs7fkg04w67arl4pwma0z5z56lq"; depends=[glasso lars]; };
   SCperf = derive { name="SCperf"; version="1.0"; sha256="1v9l7d9lil2gy5bw6i7bzc24808m063xaw2spl005j0a9rh4ag41"; depends=[]; };
   ScrabbleScore = derive { name="ScrabbleScore"; version="1.0"; sha256="19vgaxnhvqsbllqxfbnhnar2j4g0fkxi7rfsmkks2bd2py81x04m"; depends=[]; };
···
   ScreenClean = derive { name="ScreenClean"; version="1.0.1"; sha256="0haanr05g4vwp5apncyzv8i3r61g4xf9ihm8ilcabcgpri56gpjk"; depends=[MASS Matrix quadprog]; };
   scrime = derive { name="scrime"; version="1.3.3"; sha256="1vp7ai10m0f3s0hywyqh0yllxj6z6p795zqpr6vp58fh6yq20x73"; depends=[]; };
   scriptests = derive { name="scriptests"; version="1.0-9"; sha256="03jv5hgzs4hvkpvjr9073nncmwj20cwispzwrbvxjdnvm5hnjg3y"; depends=[]; };
-  SCRT = derive { name="SCRT"; version="1.0"; sha256="1yk3ialhsn5qgjsi7zl7m61bkkwiw90xa4fl1vwncbgpzhrfzgkj"; depends=[]; };
+  scrm = derive { name="scrm"; version="1.3-2"; sha256="12wj92jivjgypdrili5gf0mks59w0vy1lvdnk7plby9lnmj79cy5"; depends=[Rcpp]; };
+  SCRT = derive { name="SCRT"; version="1.1"; sha256="0c5pyxsqivhmdd0cbpnvc90pbyw24p3a5zalz85af5b6mkqmjn8y"; depends=[]; };
   scrypt = derive { name="scrypt"; version="0.1.0"; sha256="1hc1rziigwggdx2pvklldkw88mdzbwa8b8a2a0ip4cm1w6flsl9n"; depends=[Rcpp]; };
   scuba = derive { name="scuba"; version="1.7-0"; sha256="11mdc8pj552ag36ib4sfbjv8r0psa6wnb13spz0v3rbaslz25hpw"; depends=[]; };
-  SCVA = derive { name="SCVA"; version="1.0"; sha256="0dphdrc069d9nggpipl97wj1vqwnnjlv3fs68pqygzb5kbd70nx3"; depends=[]; };
+  SCVA = derive { name="SCVA"; version="1.1"; sha256="0fv0xvla7gmvvp9cg9jpb1p2k3bmib7yzrf3k17xav8zp0smq4y2"; depends=[]; };
   sda = derive { name="sda"; version="1.3.4"; sha256="0fbbiyh6sp23mg6lmzk9fm9sprqwvrv0fxxjykl5ww0pbl63rrmj"; depends=[entropy corpcor fdrtool]; };
-  SDaA = derive { name="SDaA"; version="0.1-2"; sha256="03ijiqwvvqs79ql9p016hpn5dwxnys820k00aza29npm9k2bciww"; depends=[survey ggplot2]; };
+  SDaA = derive { name="SDaA"; version="0.1-3"; sha256="0z10ba4s9r850fjhnrirj2jgnfj931vwzi3kw9502r5k7941lsx0"; depends=[]; };
   SDBP = derive { name="SDBP"; version="1.0"; sha256="18yk5zasxga58ny8n8kz3b8j0j8xznb9wqf5642xzfvcb9dd1kz2"; depends=[]; };
   sdcMicro = derive { name="sdcMicro"; version="4.4.0"; sha256="0ig43sdzn940mpv2d8v1v0k77nb5mwwsy8amkb6vdxs0rql7qvyy"; depends=[brew knitr data_table xtable car robustbase cluster MASS e1071 Rcpp sets]; };
   sdcMicroGUI = derive { name="sdcMicroGUI"; version="1.1.1"; sha256="0icxxbfxl65da07bpi7l2jzk85y990ndhl60lwyp077sjq5rd20q"; depends=[sdcMicro gWidgetsRGtk2 cairoDevice vcd foreign Hmisc]; };
   sdcTable = derive { name="sdcTable"; version="0.17.1"; sha256="0wljdpggf8mhsjg0xrgb3xqd346zb4f8pk0jfgv38krhkfxz1ss5"; depends=[stringr Rcpp Rglpk lpSolveAPI data_table]; };
   SDD = derive { name="SDD"; version="1.1"; sha256="1bl9xlns6np26pgiiza25c54k4989knksdkkk653g8s8gmr4y34x"; depends=[Hmisc sm tseries rpanel rgl]; };
-  SDDA = derive { name="SDDA"; version="1.0-5"; sha256="1lwp36bwx13cyiqyzh5jp2c0f0g2hvppqxnpjcflmcz7s23h5dp7"; depends=[MASS]; };
   sddpack = derive { name="sddpack"; version="0.9"; sha256="1963l8jbfwrqhqcpif73di9i5mb996r4f8smjyil6l7sdir7cg9l"; depends=[]; };
-  sde = derive { name="sde"; version="2.0.10"; sha256="1wkgam394190zg1m0b9hg81h9mkqhqw8isk7xf5vdqxymjzsaxjm"; depends=[MASS fda zoo]; };
+  sde = derive { name="sde"; version="2.0.13"; sha256="194dkwrww9win5chhlffjv1xkhpxx2bcv6hf81xaqk7pdf7ifj80"; depends=[MASS fda zoo]; };
   sdef = derive { name="sdef"; version="1.5"; sha256="1xmx3nfjjfh6zw1vq7iip4rnshh40azja83xyvnz04jcv574vhxm"; depends=[]; };
   SDMTools = derive { name="SDMTools"; version="1.1-221"; sha256="1kacrpamshv7wz83yn45sfbw4m9c44xrrngzcklnwx8gcxx2knm6"; depends=[R_utils]; };
-  sdmvspecies = derive { name="sdmvspecies"; version="0.3"; sha256="0xcgwj600a3r3v8hcy2xf1bkc60p44g2cjyq8qs2g3wqd7zyqj1b"; depends=[GPArotation ggplot2 psych raster]; };
+  sdmvspecies = derive { name="sdmvspecies"; version="0.3.1"; sha256="1rpbj55598862vb4bwrvcbskm10xibsvx58fpvkn58zbm6ab2534"; depends=[GPArotation ggplot2 psych raster]; };
   sdnet = derive { name="sdnet"; version="2.01.3"; sha256="1sr60ca2dn182nacsi1ix02cdjygf45jv51dcfz5744hj7afcvws"; depends=[]; };
   sdprisk = derive { name="sdprisk"; version="1.0-3"; sha256="0v490zz2c1qa0w9nfd0xs5xbbvd9g8vp39fp8x7k7cy598vby4yx"; depends=[numDeriv PolynomF rootSolve]; };
   sdtoolkit = derive { name="sdtoolkit"; version="2.33-1"; sha256="0pirgzcn8b87hjb35bmg082qp14idc5pfvm6dikpgkswag23hwh8"; depends=[]; };
···
   sealasso = derive { name="sealasso"; version="0.1-2"; sha256="0cjy3fj170p5wa41c2hwscmhqxwkjq22vhg9kbajnq7df2s20jcp"; depends=[lars]; };
   SearchTrees = derive { name="SearchTrees"; version="0.5.2"; sha256="11p81x1klkmxarypxpbisf78dlrmhzzg9y9hxpwz75pks1y56gqg"; depends=[]; };
   seas = derive { name="seas"; version="0.4-3"; sha256="1n0acg6fvaym4nx1ihw0vmb79csds0k4x9427qmcyxbl9hxxmllp"; depends=[]; };
-  season = derive { name="season"; version="0.3-3"; sha256="0562qxc5bz9yjkz0zzighlp52ysv0gjn8xfycbxckmjxy3wrk9cz"; depends=[ggplot2 MASS mgcv survival coda]; };
-  seasonal = derive { name="seasonal"; version="0.60.0"; sha256="0cs987gsh2brgwv30ildrzq2phj6pfrksl8dq3rdlx0a7411ll5i"; depends=[]; };
+  season = derive { name="season"; version="0.3-4"; sha256="0rcz1gd3wbk77289b2vblbs3hhzf5vszdfmjvw4byfsw2willa7n"; depends=[ggplot2 MASS mgcv survival coda]; };
+  seasonal = derive { name="seasonal"; version="0.70.1"; sha256="0vjyr864v5v1hxy00djzmbq38ajmywacp9k0zfv1q9nf64kg62l5"; depends=[]; };
   seawaveQ = derive { name="seawaveQ"; version="1.0.0"; sha256="19vm1f0qkmkkbnfy1hkqnfz6x2a7g9902ka76bhpcscynl69iy56"; depends=[survival NADA lubridate]; };
   SEchart = derive { name="SEchart"; version="0.1"; sha256="19gqcd6xzwg37nzc67p88ip4i0v2f59ds85xfw9qq8lybvdm76k2"; depends=[JM]; };
   SECP = derive { name="SECP"; version="0.1-4"; sha256="0a4j0ggrbs0jzcph70hc4f5alln4kdn2mrkp3jbh321a6494kwl1"; depends=[SPSL]; };
-  secr = derive { name="secr"; version="2.8.2"; sha256="0p885q2r8wy4n8j1dvmmd59p5nfds8f4l1mwiw4z3xwck3bwi776"; depends=[abind MASS nlme sp]; };
+  secr = derive { name="secr"; version="2.9.0"; sha256="0ak1r0zn34arfwv3qjnxbrzbr2d1yvlj4mif5hsc2hcp3v5kh4yz"; depends=[abind MASS nlme sp mgcv raster]; };
   secrdesign = derive { name="secrdesign"; version="2.1.3"; sha256="1gfkc5cdk9jg3db5yiq06k9li226m1sxd5r59283ci96sd6fh02s"; depends=[secr abind]; };
-  seedy = derive { name="seedy"; version="0.1"; sha256="16rg2i2g3ri882jsiyvqk4yw7xmg7f1hiirb77w1pqa30007gl7v"; depends=[]; };
-  seeg = derive { name="seeg"; version="1.0"; sha256="1d45vl075p4qbd74gpaa8aw1h82p9n633fym10yp9bmcv4gwksg6"; depends=[car spatstat sgeostat]; };
+  seedy = derive { name="seedy"; version="1.0"; sha256="1p9mbnkgdz3rlaj5ygaai81g8kvs68y4zcgf7745gr17vflys8kf"; depends=[]; };
+  seeg = derive { name="seeg"; version="1.0"; sha256="1d45vl075p4qbd74gpaa8aw1h82p9n633fym10yp9bmcv4gwksg6"; depends=[car sgeostat]; };
   seem = derive { name="seem"; version="1.0"; sha256="0cjdi9c89bqvrx9gzxph958cfqicc1qfnzsair0gvsk3cxsrw6bf"; depends=[]; };
   SEER2R = derive { name="SEER2R"; version="1.0"; sha256="0lk0kkp8sv3nl19zwqd7449mmjxsj3pqpzdmqf70qf8xh2pqyvzd"; depends=[]; };
   SEERaBomb = derive { name="SEERaBomb"; version="2014.4.1"; sha256="1vlk6hcn05vdjfc7c8dhvsd1hc2yq1pdmhb7i48b689lkxg82igz"; depends=[RSQLite LaF]; };
-  seewave = derive { name="seewave"; version="1.7.3"; sha256="1bgv90x1rc7xyril6qarbx5mza131admd75s9704s8l7n4zfy64k"; depends=[fftw tuneR]; };
+  seewave = derive { name="seewave"; version="1.7.6"; sha256="1sh2i9hb8v0awhczvkj803lmdvg5p1fla685xb3s2a3if1q5zc5i"; depends=[fftw tuneR]; };
   seg = derive { name="seg"; version="0.5-1"; sha256="0gsdbq7b5wpknhlilrw771japr63snvx4vpirvzph4fjyby1c7rg"; depends=[sp splancs]; };
-  segmented = derive { name="segmented"; version="0.4-0.0"; sha256="0dcr3s33j68ficbjgvi9hv5z2ihplljwp5zrqp82bc43qhbwsr6i"; depends=[]; };
+  segmag = derive { name="segmag"; version="1.2.2"; sha256="130saznhssg0qsc34fcw80x92mmqhjgizrb4fxpjsg7a8jjrclp8"; depends=[Rcpp]; };
+  segmented = derive { name="segmented"; version="0.5-0.0"; sha256="13p259snxj96xysj05gy2c705n6brbf5dfba4n3riwwb8ngs69cd"; depends=[]; };
   Segmentor3IsBack = derive { name="Segmentor3IsBack"; version="1.8"; sha256="00m6fvx6s8mz477c8b4dmgdh52jf6jx1lcqzf84l90b1xw93qnv7"; depends=[]; };
   SE_IGE = derive { name="SE.IGE"; version="1.0"; sha256="0gx3kdsdl3rjms6fxabxz51z84r9mcy4934l2g43ifrxbyphnias"; depends=[]; };
   Sejong = derive { name="Sejong"; version="0.01"; sha256="1d9gw42dbs74w7xi8r9bs6dhl23y16yxqzyhqqayvcm98q3l77nf"; depends=[]; };
   SEL = derive { name="SEL"; version="1.0-2"; sha256="1nrk0fx6ff330abq8askvp0790xnfv00m3sraqcr32hciw6ks421"; depends=[quadprog lattice]; };
   selectiongain = derive { name="selectiongain"; version="2.0.29"; sha256="0l0av8dw14yfnc5a17nknjimhbi0nw30h7m8la346kibcsmszyvr"; depends=[mvtnorm]; };
-  selectMeta = derive { name="selectMeta"; version="1.0.6"; sha256="0qv06x6q6p2lwr13fw8xc6mkpb23h41sqnc9wyq8xx37d2jgpcif"; depends=[DEoptim]; };
+  selectMeta = derive { name="selectMeta"; version="1.0.7"; sha256="1ibiiddl9km8dahfc3kdpl42k43fx4mqgqibxgv5q8zbcp2829p9"; depends=[DEoptim]; };
   selectr = derive { name="selectr"; version="0.2-2"; sha256="0hzj8ccs2jcfaqlpgrf59y6z7hrxsb2c85kkxflp6180rpqjrwq4"; depends=[XML stringr]; };
   SeleMix = derive { name="SeleMix"; version="0.9.1"; sha256="04gxgja35qs4k66iil014dzgl5bkx0qhr9w4v7qpmwv2bb07jwz3"; depends=[mvtnorm Ecdat xtable]; };
+  SelvarMix = derive { name="SelvarMix"; version="1.0"; sha256="0yysmf854xz5l0lf2x0hw0qxbrdhgfrcx5ggw8n4pjfv553p38ni"; depends=[Rcpp glasso Rmixmod]; };
   sem = derive { name="sem"; version="3.1-5"; sha256="093kklhl9fnawpwj3km1q0px6fm40kc3vg7kw93y3yb6hniwla35"; depends=[matrixcalc]; };
   semdiag = derive { name="semdiag"; version="0.1.2"; sha256="0kjcflw7dn907zx6790w7hnf5db6bf549whfsc0c2r173kf13irp"; depends=[sem]; };
   semGOF = derive { name="semGOF"; version="0.2-0"; sha256="1lsv72yaza80jqadmah7v2cpfqfay57y12hcz6brvia6bmr5qagb"; depends=[sem MASS matrixcalc]; };
   semiArtificial = derive { name="semiArtificial"; version="1.2.0"; sha256="11pwdqpsf5d5g74s2b8ixmrh2khkha3d4akzlkn652s98qr55dpc"; depends=[CORElearn MASS nnet cluster mclust fpc timeSeries timeDate]; };
   SemiCompRisks = derive { name="SemiCompRisks"; version="1.0"; sha256="1q10bqws152vk7fpd9m8w16m0ns2i10q07wnmmbjladvfq4ja9il"; depends=[]; };
   SEMID = derive { name="SEMID"; version="0.1"; sha256="1bxdjdyqlvxz339jdgw90qi6kvfhjdmga38vhfl3ldlxfv2s9gfk"; depends=[igraph]; };
-  SemiMarkov = derive { name="SemiMarkov"; version="1.3.1"; sha256="0cqrwpg26m8paa1rnz5yd6min00kwvl9ifgf4x71y2ldzr2n52b8"; depends=[numDeriv MASS Rsolnp]; };
-  SemiPar = derive { name="SemiPar"; version="1.0-4"; sha256="1gg80wpqa006qahpaxb5y7vnf4w0x9mhjwh6w3271j0b9znr1gs5"; depends=[MASS cluster nlme]; };
-  SemiParBIVProbit = derive { name="SemiParBIVProbit"; version="3.2-11"; sha256="1b1ywyax76893vp6s4ldjvk035vky4pbiagl8blzcwp7vhvy4ys7"; depends=[CDVine mgcv mvtnorm MASS magic polycor VineCopula VGAM survey trust matrixStats Matrix sn]; };
-  SemiParSampleSel = derive { name="SemiParSampleSel"; version="1.1"; sha256="0b2vdrqi4mw4bp6r82b3c329cddjxwc39rcramq5nr8awv9ib0cf"; depends=[copula mgcv mvtnorm magic trust Matrix]; };
+  SemiMarkov = derive { name="SemiMarkov"; version="1.4"; sha256="0z43ynkd6wrxrfdbq01jiwyvw2shc3r3pmircnzkbwm2sffd3515"; depends=[numDeriv MASS Rsolnp]; };
+  SemiPar = derive { name="SemiPar"; version="1.0-4.1"; sha256="05gnk4s0d6276rmnyyv6gy1wpkji3sw563n8l7hmi9qqa19ij22w"; depends=[MASS cluster nlme]; };
+  SemiParBIVProbit = derive { name="SemiParBIVProbit"; version="3.2-12"; sha256="1m681y4fh3fdi26w794ydqczls3rmqc1k2m24lqkzbhjv42w6rjb"; depends=[mgcv mvtnorm magic CDVine VineCopula VGAM survey trust Matrix sn]; };
+  SemiParSampleSel = derive { name="SemiParSampleSel"; version="1.1-1"; sha256="0a3kynh96gp0ngw25v05fmcapx3iiclcjbypq2nn8sybbv9991c4"; depends=[copula mgcv mvtnorm magic trust Matrix]; };
   semisupKernelPCA = derive { name="semisupKernelPCA"; version="0.1.5"; sha256="1v8wdq63b1gqicj8c9a24k0w7cc0bkg0mnc9z5mklsfcl7g0g6k9"; depends=[datautils irlba]; };
   SEMModComp = derive { name="SEMModComp"; version="1.0"; sha256="1za67470f13z8jsy3z588c7iiiz993d3vjqrb8v9fann2r6sf1md"; depends=[mvtnorm]; };
-  semPlot = derive { name="semPlot"; version="1.0.0"; sha256="0ih94pwhkgd8jni3wkv1xmjr4c00q94dq4n8mxdwvixwi1l0gzjq"; depends=[qgraph lavaan sem plyr XML igraph lisrelToR rockchalk colorspace corpcor]; };
+  semPlot = derive { name="semPlot"; version="1.0.1"; sha256="0sdp970qb4mz5vzncfmqxvg1z12gmiyqi3yaz9x2drm3rgzavy83"; depends=[qgraph lavaan sem plyr XML igraph lisrelToR rockchalk colorspace corpcor]; };
   semPLS = derive { name="semPLS"; version="1.0-10"; sha256="0q5linjyv5npkw4grx3vq58iq2q1grf06ikivhkg8w7rvb7pqn6b"; depends=[lattice]; };
-  semTools = derive { name="semTools"; version="0.4-0"; sha256="1s6js0wqipfvn8hdmsmxjg3h8j4n6v00jisiwg4rfljvis9wx27l"; depends=[MASS lavaan]; };
-  sendmailR = derive { name="sendmailR"; version="1.1-2"; sha256="1d3rzcckrfqsilpzmpacwibhz858b8sw029vfz6mjh6q0ijswi2q"; depends=[base64enc]; };
+  semTools = derive { name="semTools"; version="0.4-6"; sha256="1rxs6kwfc4bp273i9p25v4mc2sm91fkgsg178ifd4d3235xawcvz"; depends=[lavaan]; };
+  sendmailR = derive { name="sendmailR"; version="1.2-1"; sha256="0z7ipywnzgkhfvl4zb2fjwl1xq7b5wib296vn9c9qgbndj6b1zh4"; depends=[base64enc]; };
   sendplot = derive { name="sendplot"; version="4.0.0"; sha256="0ia2xck94nwirwxi38nv0viz5wb8291yiak6f0wgwh84irsrfp1h"; depends=[rtiff]; };
-  sensitivity = derive { name="sensitivity"; version="1.8-2"; sha256="1q30xpb1w5dnkivxh1ck53jz2m9kpjmzvr2yd739zxxlir5kx8gr"; depends=[boot]; };
+  sensitivity = derive { name="sensitivity"; version="1.9"; sha256="1fvm8d8pqb7drg83nrqi49fizisdq7g45r7zkhrva5wydy8b5fl3"; depends=[boot]; };
   SensitivityCaseControl = derive { name="SensitivityCaseControl"; version="2.1"; sha256="00jqzqx7g0av9lw13is723gph486gb8ga0wgcmmzpmb24s5nya9z"; depends=[]; };
   sensitivitymv = derive { name="sensitivitymv"; version="1.2"; sha256="0h8lbl5yhxgzdrajjydb2ap9q3dnm1abxdk8gdhp84m1bv8pznkj"; depends=[]; };
   sensitivitymw = derive { name="sensitivitymw"; version="1.1"; sha256="1bknnfkkqgmchabcjdfikm37sn5k41ar8lpnjw58i8qh7yzq237i"; depends=[]; };
···
   SenSrivastava = derive { name="SenSrivastava"; version="2012-04-0"; sha256="0ki0kl18cj8lkad6q48piyvslkirs8y5rnfa8bvgjxsisxg2ahhp"; depends=[]; };
   separationplot = derive { name="separationplot"; version="1.0"; sha256="1m8s531dsmzdam5s2yn0qyvm89zfxrzj8sh8r2gpcf31qrai7m26"; depends=[MASS RColorBrewer]; };
   seqCBS = derive { name="seqCBS"; version="1.2"; sha256="1kywi3kvvl9y6nm7cwf6fj8gz9gzznp5va336g1akzgy77k82d8v"; depends=[clue]; };
-  seqDesign = derive { name="seqDesign"; version="1.0.1"; sha256="17zb8l5kasjvrsrgs2k0ih25ydlz7hpr9dcr1rm1akvscmk8np3d"; depends=[survival xtable]; };
+  seqDesign = derive { name="seqDesign"; version="1.0.2"; sha256="0v4g4r9y79vqf4i2r96y6wgjf2aww98k06rk3lpr4cz1yp5x3gvx"; depends=[survival xtable]; };
   SeqFeatR = derive { name="SeqFeatR"; version="0.1.5"; sha256="1cpb64h3pcp18zrly0hxy2wfn68x4pgyj0ywl4z2kadi6y3r0gyh"; depends=[tcltk2 plotrix ape plyr phangorn]; };
   SeqGrapheR = derive { name="SeqGrapheR"; version="0.4.8.3"; sha256="03plwa3sc1pg34p1szbz3d0z8y53w7iqm7qn9q6fj72rsnk5spxc"; depends=[igraph rggobi gWidgets gWidgetsRGtk2 cairoDevice]; };
-  seqinr = derive { name="seqinr"; version="3.0-7"; sha256="0r54kvvwlp5i1fbk4vgbinj3zwzjppiyh7f5dy4kmja8m5lslc4x"; depends=[]; };
-  seqMeta = derive { name="seqMeta"; version="1.4"; sha256="0wmwvw09fskwpvy727lc974aw9gvd495wgxf8k1ybi16bq2h080j"; depends=[survival Matrix coxme CompQuadForm]; };
+  seqinr = derive { name="seqinr"; version="3.0-9"; sha256="1m57nmpkxhka1mgfaq5clwdhipz36v795w1d51qr8zypdnxacfgq"; depends=[ade4]; };
+  seqMeta = derive { name="seqMeta"; version="1.5"; sha256="1igag08qkfvkx83w6jjyfmjpxil9wvag1yfnxp3pqbglj9l99pmn"; depends=[survival Matrix coxme CompQuadForm]; };
   seqminer = derive { name="seqminer"; version="3.1"; sha256="15b63j15bgqzix4vp57q1vi9jnqn5an2p8kmvacg95ahrv8w0a0m"; depends=[stringr]; };
   seqmon = derive { name="seqmon"; version="0.2"; sha256="075hc6vgl1w3nisrihf5w6mkkg9q601jsqxm9hk9yagyvvd7d78w"; depends=[]; };
   seqPERM = derive { name="seqPERM"; version="1.0"; sha256="1i8ai4gxybh08wxjh96m6xlqxhh7ch0xihjs879snmy4zqfi0pap"; depends=[]; };
   seqRFLP = derive { name="seqRFLP"; version="1.0.1"; sha256="1i98hm8wgwr8b6hd237y2i9i0xgn35w4n2rxy4lqc5zq71gkwkvk"; depends=[]; };
   sequences = derive { name="sequences"; version="0.5.8"; sha256="1872737x77mknn2ay7qh8brd28hzsqzjqkx4shwkp0w7lk2p0rp0"; depends=[Rcpp]; };
   Sequential = derive { name="Sequential"; version="1.1"; sha256="1fr4n6qbxwj6hs01h07wdj5v4c7af5q8ccnm33yzcrx845qf8fiv"; depends=[]; };
-  sequenza = derive { name="sequenza"; version="2.0.0"; sha256="04kva5bvflpzq53qgif8sw49npcx1hwlqvrypgb6ynajyg28hd6p"; depends=[squash]; };
+  sequenza = derive { name="sequenza"; version="2.1.0"; sha256="0qnznw6gn5yfd64mib8h9y29vak40d3znzkqvhlpnn0da6aak1zv"; depends=[squash]; };
   seriation = derive { name="seriation"; version="1.0-13"; sha256="0k3m4x0msdynblcy1ign4p5qlsqmxk2p4vfjkv0fz3qjsbxfw61n"; depends=[TSP cluster gclus colorspace MASS]; };
   servr = derive { name="servr"; version="0.1"; sha256="035pf1xg0jgjrba39wxwlrh7n43kp29ymagfv7yskxj31dh3b34i"; depends=[httpuv]; };
   sesem = derive { name="sesem"; version="1.0.1"; sha256="0s4xkv6bc5nxhj09mk9agnj11b9h7swccs9jrn4lg3fy12vqhf5a"; depends=[lavaan mgcv gplots]; };
···
   SetMethods = derive { name="SetMethods"; version="1.0"; sha256="0zizvrzyk01w4ncazvifmjm4h5zrpsf6n68n11sc8f5kzny9ia48"; depends=[lattice betareg lattice betareg]; };
   setRNG = derive { name="setRNG"; version="2011.11-2"; sha256="1gp577yy3wzszpzgdhfpas7hrk658rb2vz0dxm111s5xnc5wcp74"; depends=[]; };
   sets = derive { name="sets"; version="1.0-13"; sha256="1ys17iy2gjkfnp3914g6sfx3ilgm18pdfak59cqrwalwwnhc3zaz"; depends=[]; };
+  settings = derive { name="settings"; version="0.1.1"; sha256="00b69vh4r8f40v6rm11hgry7dfqsrd2ij9h07y60xxzdjrwigm14"; depends=[]; };
   setwidth = derive { name="setwidth"; version="1.0-3"; sha256="1s6m24kmkafscgibgfldm70m57bv4gs0m7fdki18nwdi1rvwpkbf"; depends=[]; };
   severity = derive { name="severity"; version="2.0"; sha256="1mp19y2pn7nl9m8xfljc515kk5dirv0r2kypazpmd956lcivziqq"; depends=[]; };
   sExtinct = derive { name="sExtinct"; version="1.1"; sha256="1l6232z6c4z3cfl1da94wa6hlv9hj5mcb85fj1y0yparkvvl8249"; depends=[lattice]; };
   sfa = derive { name="sfa"; version="1.0-1"; sha256="1acqxgydf8j5csdkx0yf169x3yaa31r0ccdrqarh6vj1hacm89ad"; depends=[]; };
   sfsmisc = derive { name="sfsmisc"; version="1.0-26"; sha256="0claxq1s1hkwwymx8iva650v51fjf4ly10zm17d42qhnn4b2whgd"; depends=[]; };
-  sft = derive { name="sft"; version="1.0-1"; sha256="0pi6x66mcywc1lbkwnwldnfg64h5vpp65vlis6b9cqd8iyx8msp4"; depends=[fda]; };
-  SGCS = derive { name="SGCS"; version="2.0"; sha256="1d7abq07f0702k33j334va7kc4swz7rdqqb4sw1wq6a671r7k5v6"; depends=[spatstat]; };
+  sft = derive { name="sft"; version="2.0-7"; sha256="1fq1b32f08i4k9bv4hh7rhk1jj7kgans6dwh1bmawaqkchyab3jr"; depends=[fda]; };
+  SGCS = derive { name="SGCS"; version="2.0"; sha256="1d7abq07f0702k33j334va7kc4swz7rdqqb4sw1wq6a671r7k5v6"; depends=[]; };
   sgeostat = derive { name="sgeostat"; version="1.0-25"; sha256="04zl932s6zb26r42h2l8qf3d43bmrq67281mrkh4spn4vcddv5da"; depends=[]; };
   SGL = derive { name="SGL"; version="1.1"; sha256="1wc430jqn3li102zpfmyyavfbab7x7ww9p89clxsndyigrrbjdr7"; depends=[]; };
-  sglasso = derive { name="sglasso"; version="1.0-1"; sha256="19f8qjhmv3jpx9p9wcnbzsifla0rccypxgwjykszr4gi7jl1s4z5"; depends=[Matrix]; };
+  sglasso = derive { name="sglasso"; version="1.1-0"; sha256="1iyj8clk2ibj94nxh1xi1wr50y2l53fxcivc2jdnilcqmscwbf1x"; depends=[Matrix]; };
   sglOptim = derive { name="sglOptim"; version="1.0.122.0"; sha256="07anc9ixbc82807ixr4k779src72gvbx0wsy3mr0mvzg9xq2fi1v"; depends=[Matrix]; };
   sglr = derive { name="sglr"; version="0.7"; sha256="11gjbvq51xq7xbmpziyzwqfzf4avyxj2wpiz0kp4vfdj3v7p4fp9"; depends=[ggplot2 shiny]; };
-  sgof = derive { name="sgof"; version="2.1"; sha256="1nipm2lf02g0j4f8kas99wi4wmwp5vx2a97jj5mg8mclkwpifnhr"; depends=[poibin discreteMTP]; };
   SGP = derive { name="SGP"; version="1.2-0.0"; sha256="0v4ljhvfrvl6izprcrw8w36474fjz0v1kpcsg0sx32359amd3zxz"; depends=[Cairo colorspace data_table doParallel foreach gridBase iterators jsonlite plyr quantreg reshape2 RSQLite sn]; };
   sGPCA = derive { name="sGPCA"; version="1.0"; sha256="16aa5jgvkabrlxaf1p7ngrls79mksarh6di3vp26kb3d3wx087dx"; depends=[Matrix fields]; };
   SGPdata = derive { name="SGPdata"; version="8.0-0.0"; sha256="0g25s2wcj47394fm16maygafnynizma3mgb3r65b5p9c27swk4v8"; depends=[]; };
-  sgr = derive { name="sgr"; version="1.1"; sha256="1wbpxjv4g4jccih5xn2m7fqq4w1b4p05j56iwldkjp2r6paj5af1"; depends=[]; };
+  sgr = derive { name="sgr"; version="1.2"; sha256="11c3qp3ypqlzkhhlvhw84ih8acz46d27zbha10mwfznbpq3nzl94"; depends=[MASS]; };
   shape = derive { name="shape"; version="1.4.1"; sha256="1s1yj7cqc9svqliv9f9k3fimkakblri9vwr785ihav58x5cn90qj"; depends=[]; };
   shapefiles = derive { name="shapefiles"; version="0.7"; sha256="08ghndihs45kylbzd9wnxffn8ixvxjhjnjldjyd526ai2sj8xcgf"; depends=[foreign]; };
-  shapes = derive { name="shapes"; version="1.1-9"; sha256="044d4ci9lv6g9vbh8zn85f08d9n8f91vn8gn1wqv1lp0qjycpmjv"; depends=[scatterplot3d rgl MASS]; };
+  shapes = derive { name="shapes"; version="1.1-10"; sha256="038xps6f8b6w9qa9csqk33ggmb311h5zxwsxr027bd95a3vmyijx"; depends=[scatterplot3d rgl MASS]; };
   SharpeR = derive { name="SharpeR"; version="0.1401"; sha256="1l55llafs81gl1mdhyyi6m02w7mx8g46y65jf1kw5mbrljgri8az"; depends=[matrixcalc xtable]; };
   sharpshootR = derive { name="sharpshootR"; version="0.6-3"; sha256="1dpcyd1wi022zcs9s48xg3wzy17dqcd0622ak0phvbwxgpwmz9j2"; depends=[aqp ape igraph cluster lattice latticeExtra vegan sp reshape2 Hmisc scales circular RColorBrewer plyr]; };
   sharx = derive { name="sharx"; version="1.0-4"; sha256="1flcflx6w93s8bk4lcwcscwx8vacdl8900ikwkz358jbgywskd5n"; depends=[Formula dcmle dclone]; };
-  shiny = derive { name="shiny"; version="0.10.1"; sha256="1hd26n0mx62vsnvfvypkihj89hnbmvdwyw33h45x4vyiz5h1kd17"; depends=[httpuv caTools RJSONIO xtable digest htmltools]; };
+  shiny = derive { name="shiny"; version="0.10.2.1"; sha256="03figla0lm6fb51f0g3mvlpy2nsmywxkpila4x9lqh0hs6yw0v4v"; depends=[httpuv mime RJSONIO xtable digest htmltools R6]; };
   shinyAce = derive { name="shinyAce"; version="0.1.0"; sha256="1031hzh647ys0d5hkw7cqxj0wgry3rxgq95fgs7slbm0rgx9g6f7"; depends=[shiny]; };
   shinyBS = derive { name="shinyBS"; version="0.20"; sha256="1l95g2rzv53vwx5zcaqiqz8jirncwh1yb14y62x9phg4n5jfk9f8"; depends=[shiny]; };
-  shinyFiles = derive { name="shinyFiles"; version="0.3.2"; sha256="19qzsvk5pqq59hfmzw4fg5fds26y1hqwhgjqf1pkxbmbd337qdik"; depends=[shiny]; };
+  shinyFiles = derive { name="shinyFiles"; version="0.4.0"; sha256="147g9ah7p97wkn3zpfhn5fljpwy2v936r4jqbdm7fbh7zi3rb3k2"; depends=[shiny htmltools]; };
   shinyRGL = derive { name="shinyRGL"; version="0.1.0"; sha256="07llg1yg5vmsp89jk60ly695zvxky6n06ar77mjxzlyc294akwmy"; depends=[rgl shiny]; };
   SHIP = derive { name="SHIP"; version="1.0.2"; sha256="0b83cclibdz1r7sz968nmca4najwgps9wrdlsh4gxrl7fq40k4ln"; depends=[]; };
-  shotGroups = derive { name="shotGroups"; version="0.5"; sha256="02v785p5lqjpdp5vn7snpg1wgr7whpp4s4vbiwyaxmfp6kwqk81q"; depends=[boot coin CompQuadForm energy KernSmooth mvoutlier robustbase]; };
+  shopifyr = derive { name="shopifyr"; version="0.28"; sha256="1ypqgiqimdwj9fjy9ykk42rnkipb4cvdxy5m9z9jklvk5a7cgrml"; depends=[RCurl R6 RJSONIO]; };
+  shotGroups = derive { name="shotGroups"; version="0.6"; sha256="0khcgzli6114yqrglmsvhr8rwkkkwdkd06b50isbc24vpv6xbfx9"; depends=[boot coin CompQuadForm energy KernSmooth mvoutlier robustbase]; };
   showtext = derive { name="showtext"; version="0.2"; sha256="18pr03n0v2dg93pnp3saar3664dpina33wzmhw13hqcx6nfjgzw7"; depends=[sysfonts]; };
   shp2graph = derive { name="shp2graph"; version="0-2"; sha256="09gbb7f9h3q2p56dwb2813mr36115ah70szq47jimpymzkd2x08m"; depends=[maptools igraph]; };
-  shrink = derive { name="shrink"; version="1.1"; sha256="0avf3502mjz2apy1nnz8a6xp5n77vva5v1n84sn1qimjnz40g58d"; depends=[]; };
-  ShrinkCovMat = derive { name="ShrinkCovMat"; version="1.0.1"; sha256="08cb4r94vywpi5g6gbmjb197694553hyy0lb68wa11k6p3qnsh06"; depends=[]; };
+  shrink = derive { name="shrink"; version="1.2.0"; sha256="0r207mj57kjn6wfmz4f2l4wmbz7g1pvj96gpl0s76vkdjzbh1l47"; depends=[survival MASS rms]; };
+  ShrinkCovMat = derive { name="ShrinkCovMat"; version="1.0.2"; sha256="0q9gf0w148z6xii691l0fripk2znyypq69hgfz2ynk75r7yr1jkg"; depends=[]; };
   shuffle = derive { name="shuffle"; version="1.0"; sha256="037i45mfys1nr9sqmmsfb2yd3ba3aa22hc701f5j2zp8jx57qn3k"; depends=[]; };
-  siar = derive { name="siar"; version="4.2"; sha256="1c4z72jr81dzkp9xqyrrkwjsalvvksl67pnbaadkc52v84fhzx3r"; depends=[hdrcde coda MASS bayesm mnormt spatstat]; };
+  siar = derive { name="siar"; version="4.2"; sha256="1c4z72jr81dzkp9xqyrrkwjsalvvksl67pnbaadkc52v84fhzx3r"; depends=[hdrcde coda MASS bayesm mnormt]; };
   sideChannelAttack = derive { name="sideChannelAttack"; version="1.0-6"; sha256="1xcsy1h8gc8a4f9nzs7zv8x6v55g1pg8vy1kg64iqxm0gnz2f20l"; depends=[MASS corpcor mmap ade4 infotheo]; };
   sidier = derive { name="sidier"; version="2.3"; sha256="08w6xsncs4nbjgmfh1irfjrc7iflg7w4dx3shr9fh0vbsd35g8wl"; depends=[ape network igraph]; };
   sievetest = derive { name="sievetest"; version="1.2.2"; sha256="0mbgkf014m6bc7qg60vf065i6mvl5n4a0bvg8vb7dw531vsw2771"; depends=[]; };
   sig = derive { name="sig"; version="0.0-4"; sha256="0q5bwaj15jlmcg4qqcdkkwbnqphwgwzcnfzga12xzr912rwjybjr"; depends=[]; };
   sigclust = derive { name="sigclust"; version="1.1.0"; sha256="0151v7lr4n4yyn93j0s06gzc9jh9xhdgvfw6kvpfy24jl6wdii7g"; depends=[]; };
-  SightabilityModel = derive { name="SightabilityModel"; version="1.2"; sha256="1piw8i6c3bdwjj20329431is3b7mxij7f1g49g7qw00s197n8qha"; depends=[]; };
+  SightabilityModel = derive { name="SightabilityModel"; version="1.3"; sha256="0rgv5735y07yyv5y9c3flzha97ykn34ysmzy6as1z94hqfr4w746"; depends=[]; };
+  sigloc = derive { name="sigloc"; version="0.0.4"; sha256="13v2dlgsbcsqqm8yxls62i7r3sk8m3c78jv8f9lgdihq5pjnd9zp"; depends=[nleqslv ellipse]; };
   signal = derive { name="signal"; version="0.7-4"; sha256="0sz8im7i46qy5wjpm34a2nqvrc1vipmqlw8ns3i2s1vhcvp7fjs1"; depends=[MASS]; };
-  signalextraction = derive { name="signalextraction"; version="2.0.3"; sha256="0kxk32jfkcgkdcq4xfzdf24qr6wkkhl4yf2v4sjqxhviwml2g2aq"; depends=[]; };
-  signal_hsmm = derive { name="signal.hsmm"; version="1.0"; sha256="12v6frrhbaa8y9l3zy41fz8xkzalhp6afw33jad57c8hym4985nz"; depends=[seqinr shiny]; };
+  signal_hsmm = derive { name="signal.hsmm"; version="1.1"; sha256="0ifx7ahl5nj90id0pk4gpz0hdq72rsf53n05s17g6j275dzkmd0n"; depends=[seqinr shiny]; };
   sigora = derive { name="sigora"; version="0.9.2"; sha256="1s3c0xwxabr3n8sb6rjhzkkzbpvcczbgqq6b263yypwasqbg4mlb"; depends=[]; };
   SigTree = derive { name="SigTree"; version="1.6"; sha256="1z6z3s6gay3pcjazibb0schipc9qqpp3ahf0f56fq9mhk545125z"; depends=[ape phyext RColorBrewer]; };
   SII = derive { name="SII"; version="1.0.3"; sha256="1k9mvz6g25qs351c0vx7n5h77kb6k833jrcww14ni59yc9jgvsyg"; depends=[]; };
   simba = derive { name="simba"; version="0.3-5"; sha256="14kqxqavacckl5s1518iiwzrmlgbxz1lxy33y8c9qq7xaln41g9h"; depends=[vegan]; };
   simboot = derive { name="simboot"; version="0.2-5"; sha256="0slznwk8i3z76sxbfd4y5rp28jr6jv4i5ynnckpr10i59ba04wlq"; depends=[boot mvtnorm]; };
-  SimComp = derive { name="SimComp"; version="1.9.0"; sha256="1qw1bm0pahmvjxwa15q42vifq71lg7rw3dij7vba14sy88746m3g"; depends=[mvtnorm multcomp mratios]; };
+  SimComp = derive { name="SimComp"; version="2.2"; sha256="07gmlbwvv07kq3z7gq2jxlank011c0cqh8zwwp4pzf061d3gjdm6"; depends=[mvtnorm multcomp mratios]; };
   SimCorMultRes = derive { name="SimCorMultRes"; version="1.2"; sha256="0wgi36sdpsippdbawdl7b9bvip0l8gp8xd1v85vznd1dibkfjr1r"; depends=[evd]; };
   simctest = derive { name="simctest"; version="2.4"; sha256="12qxav3qy1s6g8yr6ygbjp3jlrf2p0h3zvl8bnqpk6mx95zw5gh3"; depends=[]; };
-  Sim_DiffProc = derive { name="Sim.DiffProc"; version="2.7"; sha256="03g70f5rpj1695abbkk0n73bj1hniw6gzckzg3g5zrjczg96xxs8"; depends=[]; };
+  Sim_DiffProc = derive { name="Sim.DiffProc"; version="2.9"; sha256="1cq168ga4p70hgx7rsm9rvam8b0wvjivqp2nsprk39i864j9sr91"; depends=[scatterplot3d rgl]; };
   simecol = derive { name="simecol"; version="0.8-4"; sha256="0k83zcnvxq89m60d9157w3sn2gwyl6m7812qy1bgn260ac2nqv10"; depends=[deSolve]; };
   simex = derive { name="simex"; version="1.5"; sha256="01706vbmfgcg13w1kq8v5rnk5xggbd1n7fv50c6bvhdyc1dly313"; depends=[]; };
   simexaft = derive { name="simexaft"; version="1.0.7"; sha256="13w9m35qrrp8kkz4gqp7fg9jv8fs99y19n21bdxsd3f5mlkbvqgl"; depends=[mvtnorm survival]; };
   simFrame = derive { name="simFrame"; version="0.5.3"; sha256="154d4k6x074ib813dp42l5l8v81x9bq2c8q0p5mwm63pj0rgf5f3"; depends=[Rcpp lattice]; };
-  SimHap = derive { name="SimHap"; version="1.2.0"; sha256="1mnvqfqfgkhnh3glvr0xamw7si29jg1ri0nbb437a7wf023siy9z"; depends=[survival nlme]; };
   Simile = derive { name="Simile"; version="1.3"; sha256="0jf0ispjv8izrxggp6y3a3scd8qlbqfgppqz8m1q9n3gy8jhbsli"; depends=[]; };
   SIMMS = derive { name="SIMMS"; version="0.0.1"; sha256="0s53kc95jbav28kj35isc7j09qpjsk49za8p766z9yfaiw0higp7"; depends=[survival MASS]; };
   simMSM = derive { name="simMSM"; version="1.0.1"; sha256="0lway32vjajlsnkvi7j9hcsaz7bmhzmi1w3r2gr28y5mbkpfkgb2"; depends=[]; };
   simone = derive { name="simone"; version="1.0-2"; sha256="071krim64s7fjwvwq7bjr0pw33mw9am9wpyypcy4gs7g1hj8wcir"; depends=[mixer]; };
-  simPH = derive { name="simPH"; version="1.2.2"; sha256="0bhycpip0f06ddgvydr19pdw8hl1yw3rvl781yqpc1zid657wir9"; depends=[car DataCombine data_table dplyr ggplot2 gridExtra MASS mgcv plyr reshape2 stringr survival quadprog]; };
+  simPH = derive { name="simPH"; version="1.2.3"; sha256="1x773y7jblrv048vq1p99dzmb95wj2s4c01jgl0m7dg78z1hh5fl"; depends=[car DataCombine data_table dplyr ggplot2 gridExtra lazyeval MASS mgcv reshape2 stringr survival quadprog]; };
   simpleboot = derive { name="simpleboot"; version="1.1-3"; sha256="1qprjisfflhzg8ll12p3q1zcfdiyc45glic2j9cw9nhx5rb065fk"; depends=[boot]; };
   SimpleTable = derive { name="SimpleTable"; version="0.1-2"; sha256="1rkybrp7zlb7cj37799npss1ldic0yf519q5l7a6ikal4yl1afyb"; depends=[hdrcde locfit MCMCpack]; };
   simplexreg = derive { name="simplexreg"; version="1.0"; sha256="144kljh968i7n2d21r4204i4h952mfrkfc8b5r6x760msgjphxvh"; depends=[Formula plotrix]; };
+  SimplicialCubature = derive { name="SimplicialCubature"; version="1.0"; sha256="0da2krxsd3p7v2jm4fp2ksh0ak1y0cjxj7inwkdiwmmmgjyq033f"; depends=[]; };
   Simpsons = derive { name="Simpsons"; version="0.1.0"; sha256="1pm6wga1yxc35zgz72plzq23d3l4bbzfdvhszdxmkn1pkk64h8ms"; depends=[mclust]; };
   SimRAD = derive { name="SimRAD"; version="0.94"; sha256="0jlq1bmq1xl5inh4s722jjxp54dh3dcpcvdncnzma6yb0inw8sj5"; depends=[]; };
-  simsalapar = derive { name="simsalapar"; version="1.0-3"; sha256="0svfa8xnc5r6xqkwxvlnhml4l708ksgaq8fmnqbr1hwvzc6shypl"; depends=[sfsmisc gridBase colorspace]; };
-  simsem = derive { name="simsem"; version="0.5-3"; sha256="12y2jlyys3aq8k7wi13iarzlgiqisp7731vcnd5rvla3cn0bnzrw"; depends=[lavaan]; };
+  simsalapar = derive { name="simsalapar"; version="1.0-4"; sha256="035mimkia6q1yiz413pwbgfwk6cyad24kpvhmd6gp61njawwha19"; depends=[sfsmisc gridBase colorspace]; };
+  simsem = derive { name="simsem"; version="0.5-8"; sha256="1kir1c0g5xb4gzmpvx13qp071b3d5v0br3093q394wzp22d816xk"; depends=[lavaan]; };
   SimSeq = derive { name="SimSeq"; version="1.0.0"; sha256="142qjkfz53q3g9k37nqhilsw1mcklsa9q05yqvyn9dvj9l06y11i"; depends=[fdrtool]; };
   simSummary = derive { name="simSummary"; version="0.1.0"; sha256="1ay2aq6ajf1rf6d0ag3qghxpwj0f8b3fhpr2k0imzmpbyag1i3gj"; depends=[abind svUnit gdata]; };
-  simTool = derive { name="simTool"; version="1.0"; sha256="005sq9pgmg80k67rn8y1qh88g1qh3hdi7adsrkf5hcbqzs6pzg30"; depends=[plyr reshape]; };
-  SimuChemPC = derive { name="SimuChemPC"; version="1.3"; sha256="0ff454rvplr1ad5c9nmq4jbdbgfy5gzlvxfwhnyv2wzvdcyca6rk"; depends=[rcdk]; };
+  simTool = derive { name="simTool"; version="1.0.3"; sha256="1x018p5mssrhz2ghs3ly9wss12503h93gl7zk0mqh1bcrzximh0k"; depends=[plyr reshape]; };
+  SimuChemPC = derive { name="SimuChemPC"; version="1.3"; sha256="06sxknaykikcgbw7qbbw1risg0sbaisb68vhfd7cl6sg0327dznk"; depends=[rcdk]; };
   SimultAnR = derive { name="SimultAnR"; version="1.1"; sha256="0jvmxwmbnx14h27b576dg9mw3c2z0w3m82f51f25zd1darcl06bj"; depends=[]; };
   SIN = derive { name="SIN"; version="0.6"; sha256="0vq80m3vl8spdnlkwvwy0gk3ziyybqzjp3scnfdcpn942ds7sgg9"; depends=[]; };
   SINGLE = derive { name="SINGLE"; version="1.3"; sha256="0wd7jzys51rnwr5rhf2llpygqxydjrv0dill19v8sz9w0madkil4"; depends=[flsa igraph dse Matrix]; };
-  siplab = derive { name="siplab"; version="1.1"; sha256="1b5drhla4p7n1y1cp7kqwqzw0b286kgij9j6wsks5vjgy5qfal1x"; depends=[spatstat]; };
+  siplab = derive { name="siplab"; version="1.1"; sha256="1b5drhla4p7n1y1cp7kqwqzw0b286kgij9j6wsks5vjgy5qfal1x"; depends=[]; };
   sirad = derive { name="sirad"; version="2.0-7"; sha256="009icj1jil757vvsf88sgmdz40swrx1qvrhnx7wwj7p3dlh78pvw"; depends=[zoo ncdf RNetCDF raster]; };
   siRSM = derive { name="siRSM"; version="1.1"; sha256="0fx6bfb5c8hdlgjxddwhhzr09ls53kfgn36hjk9zi5z8m14a7wbn"; depends=[rsm MASS foreach doSNOW]; };
-  sirt = derive { name="sirt"; version="0.46-15"; sha256="0r6qhv1mcxms231s7s1xscdjadj87qvbi0mkdf8krb7285x69k2y"; depends=[sfsmisc TAM CDM combinat ic_infer sm psych pbivnorm gtools Rcpp qgraph lavaan semPlot igraph coda mvtnorm MASS]; };
+  sirt = derive { name="sirt"; version="1.0-3"; sha256="1nd99vp12qkqvzb2rylf6z4db962qbyqqi0ka7b3yrv2im2fpx87"; depends=[sfsmisc TAM CDM mirt combinat ic_infer sm psych pbivnorm gtools Rcpp qgraph lavaan semPlot igraph coda mvtnorm MASS Matrix]; };
   SIS = derive { name="SIS"; version="0.7-4"; sha256="0a8apfjzfwd5a2cvkviwvqlp26hqr34lba65cq5hxf9n05x2s7rx"; depends=[glmnet ncvreg survival]; };
+  sisVIVE = derive { name="sisVIVE"; version="1.0"; sha256="1y6zq8dp5k9mx83x6fryjh0h5f5wyry1cbi33rj3h7sss8vi3vz0"; depends=[lars]; };
   sitar = derive { name="sitar"; version="1.0.1"; sha256="1ji8742f518fzg8xz0dy5irwdz7a0nymajh69zd2l53yvcsnlwdp"; depends=[nlme]; };
   sitools = derive { name="sitools"; version="1.4"; sha256="0c0qnvsv06g6v7hxad96fkp9j641v8472mbphvaxa60k3xc7ackb"; depends=[]; };
   SixSigma = derive { name="SixSigma"; version="0.8-1"; sha256="15jdr10a7a6wv50vz9y6qcrbhnddl8zh4j4d48xrarrqbjy6l4p7"; depends=[qcc lattice ggplot2 reshape2 nortest testthat]; };
   SiZer = derive { name="SiZer"; version="0.1-4"; sha256="0kiwvxrfa2b49r2iab5v2aysc2yzk5ck3h41f2hr0vq5pdnz0qy5"; depends=[boot]; };
   sjdbc = derive { name="sjdbc"; version="1.5.0-71"; sha256="0i9wdfadfcabayq78ilcn6x6y5csazbsgd60vssa2hdff0ncgvk1"; depends=[rJava]; };
-  sjPlot = derive { name="sjPlot"; version="1.4.2"; sha256="1vw66yz6j7inyb17krb0q830i9ik6wk3a1a1mn8gv1nhm48j8qlq"; depends=[ggplot2 MASS car foreign lmtest plyr psych reshape2 scales]; };
-  SKAT = derive { name="SKAT"; version="0.95"; sha256="0jvcwckx7m5jc929ip2fqppgl1c9cx7bpybx986fs25gg7m808d4"; depends=[]; };
+  sjPlot = derive { name="sjPlot"; version="1.5"; sha256="1pcvx5qpqszp99ps712p1sz1gd6jfnhm5abh04kqf1iy76f1fmxm"; depends=[ggplot2 MASS car foreign plyr psych reshape2 scales]; };
+  SKAT = derive { name="SKAT"; version="1.0"; sha256="1wzmbi5m2vmaz42awn01li796y62af73h5l1nwbky9z25p0j549a"; depends=[]; };
   skatMeta = derive { name="skatMeta"; version="1.4.3"; sha256="0bknv066ya4yl4hl4y02d9lglq2wkl9c2j1shzg3d64dg4sjvbak"; depends=[Matrix coxme survival CompQuadForm]; };
   skda = derive { name="skda"; version="0.1"; sha256="0a6mksr1d0j3pd0kz4jb6yh466gvl4fkrvgvnlmvivpv6b2gqs3q"; depends=[]; };
   SkewHyperbolic = derive { name="SkewHyperbolic"; version="0.3-2"; sha256="00l1bz3wxvs7qwl4sy814w6nrh0k79ldck5zd6c5alvg50hjwwk3"; depends=[DistributionUtils GeneralizedHyperbolic RUnit]; };
   skewt = derive { name="skewt"; version="0.1"; sha256="1xm00zfzjv53cq9drfcx7w2ri5dwsq7kajrk2hc1mvw0b6s4x2ix"; depends=[]; };
   Skillings_Mack = derive { name="Skillings.Mack"; version="1.0-2"; sha256="1spf77ix9d264r126hnrjm7z8fw19v1bk5pqhqcf6lm93zlcgh8i"; depends=[MASS matrixcalc gtools]; };
   skmeans = derive { name="skmeans"; version="0.2-6"; sha256="1ncas6mx9w5saz28vvwni8g0wbm6m7gfv8a7azw4305pc64bawam"; depends=[slam clue cluster]; };
+  slackr = derive { name="slackr"; version="1.2"; sha256="1ymj3x52wyp0mp41xnnycg0vhdmv8whimwk1hzfsqr30pccnvn9j"; depends=[httr jsonlite data_table ggplot2]; };
   slam = derive { name="slam"; version="0.1-32"; sha256="000636dwj4kmj5w1w5s6bqixh78m7262y3fgizj7rfhcnc2gz7ad"; depends=[]; };
   SLC = derive { name="SLC"; version="0.3"; sha256="0l0y1sjj0glsb7vwla99ijclcgaq2y85bgz1wqm348n4shsmm2rs"; depends=[]; };
+  sld = derive { name="sld"; version="0.3"; sha256="18xj57v9gg78d894cr1h6wp10i05hrnmwhmq6yh6211kdyj9ljp1"; depends=[lmom]; };
   Sleuth2 = derive { name="Sleuth2"; version="1.0-7"; sha256="1zav2g1yqc6bvzap4r5xwy9abkdj8iswivj5y2lylc25nkxwcswg"; depends=[]; };
   Sleuth3 = derive { name="Sleuth3"; version="0.1-6"; sha256="0q8sgh2szqnxc289vgi5v0sljzz8yb803ijx9w5mswdxw87z2dq3"; depends=[]; };
   slfm = derive { name="slfm"; version="0.1"; sha256="0s5q6ank6075sls9pkqhf7jlvi6gyvsbxa99c34d6ccrv88skyzq"; depends=[Rcpp coda]; };
   SLHD = derive { name="SLHD"; version="1.2-1"; sha256="0n5j20hp7kgi23gjprcwcaji8wdz5wwqqyc7i8dv0058fz2b5gzc"; depends=[]; };
   slp = derive { name="slp"; version="1.0-3"; sha256="09jyrp6y3rigy043d8s5i7nh89pgpvn3cv51mr729c9ccr6jdjb1"; depends=[mgcv]; };
-  sltl = derive { name="sltl"; version="1.0"; sha256="08bh76qs4if17iw51wic1r9v17wldyqgmbyfpccqp49x7ajxnwhq"; depends=[FitAR timeSeries lubridate]; };
   sm = derive { name="sm"; version="2.2-5.4"; sha256="0hnq5s2fv94gaj0nyqc1vjdjd64vsp9z23nqa8hxvjcaf996rwj9"; depends=[]; };
   smaa = derive { name="smaa"; version="0.2-2"; sha256="1xd5yd63j67w9kb3sl3jbxkvd76270c1wlg9r3k85dm2mjd0l38v"; depends=[]; };
   smacof = derive { name="smacof"; version="1.5-0"; sha256="06csyz9fvdicxm11wh9mp6i4mvlgxyiclhlyg45grag0kqjgg6ha"; depends=[rgl polynom scatterplot3d Hmisc colorspace nnls]; };
···
   SmithWilsonYieldCurve = derive { name="SmithWilsonYieldCurve"; version="1.0.1"; sha256="0qvhd1dn2wm9gzyp6k7iq057xqpkngkb4cfmvmjqmf0vhysp371w"; depends=[]; };
   SML = derive { name="SML"; version="0.1"; sha256="0pdj7321wy50v5l23hknlm30kp8cfgn072pbbifyp8qzmk0hyd8h"; depends=[glmnet Matrix lattice]; };
   SMNCensReg = derive { name="SMNCensReg"; version="2.4"; sha256="1q5yjc1njlm3hd33fdjv9d46jawr5l7r1zzj4m22spd2q5cpv04i"; depends=[Matrix PerformanceAnalytics]; };
-  SmoothHazard = derive { name="SmoothHazard"; version="1.0.9"; sha256="01ipdkb51zwrwb1gj344y4gl0934y8j54738rdzffl2lq6r3w7kv"; depends=[prodlim mvtnorm]; };
+  smoother = derive { name="smoother"; version="1.0.0.0"; sha256="0i4g19xh20v4ig9fcy1gvbawi0a92jkg2qwdcxvgcflvppnvbv22"; depends=[]; };
+  SmoothHazard = derive { name="SmoothHazard"; version="1.2.3"; sha256="0p6hnq782d5qwmq6ak2rmbzx84lrsy02lr303gg3y0vln5i2myyn"; depends=[lava mvtnorm prodlim]; };
   smoothHR = derive { name="smoothHR"; version="1.0.1"; sha256="02kjqkgnhjwhq1vmva9nmy36a7bc6zjj6g81dw9m4zd3y9nbb005"; depends=[survival]; };
   smoothie = derive { name="smoothie"; version="1.0-1"; sha256="12p4ig8fbmlsby5jjd3d27njv8j7aiwx0m2n1nmgvjj0n330s1kj"; depends=[]; };
   smoothmest = derive { name="smoothmest"; version="0.1-2"; sha256="14cri1b6ha8w4h8m26b3d7qip211wfv1sywgdxw3a6vqgc65hmk5"; depends=[MASS]; };
   smoothSurv = derive { name="smoothSurv"; version="1.3-2"; sha256="11aq3yb7q4pilp00l7q8r3ywbmwnka63kkjpvakp27mvaqyr02qr"; depends=[survival]; };
   smoothtail = derive { name="smoothtail"; version="2.0.3"; sha256="0yr3j5mq1h9pd72kyi9z6wzly9cqkscim814yi710y79l03gp0fd"; depends=[logcondens]; };
   SMPracticals = derive { name="SMPracticals"; version="1.4-2"; sha256="0apmkmsv2fqmxpgq08n9k9dvcknj74s4cpp0myjcd6kibb7g9slq"; depends=[ellipse MASS nlme survival]; };
-  SMR = derive { name="SMR"; version="1.0.0"; sha256="1479rkzwciw6h2r43wip52fmv5im33jrdphahcg38rfdqbx5ayrr"; depends=[]; };
+  SMR = derive { name="SMR"; version="2.0"; sha256="0b1g85j7l9q8nx769i1mpbv28784pj4m64f7vns88msr9p0jg2lq"; depends=[]; };
   sms = derive { name="sms"; version="2.3"; sha256="0grxyp590hj2rvw1fw3yidzkl8nqqp5a14bp9xfpdph2nyas61qq"; depends=[doParallel foreach]; };
   smss = derive { name="smss"; version="1.0-1"; sha256="17a0x92hxzn212yiz87n7ssyi3bdhnyawxk1kkmk46q1ss22a1pm"; depends=[]; };
   SMVar = derive { name="SMVar"; version="1.3.3"; sha256="17wr4lixy3p32gr4jq02d7zsr88yrbddjsvynzdsdrwbxf4mwqhp"; depends=[]; };
-  sn = derive { name="sn"; version="1.1-0"; sha256="0agilvhrg3x8xqysa098qjj0nzvfx6yps6v85jiwllhd1dp70fnl"; depends=[mnormt numDeriv]; };
+  sn = derive { name="sn"; version="1.1-1"; sha256="0nmwg1jqq42d4i7zhdlsjhja5wa2ily0n3d4vsri0f96cppnpkn2"; depends=[mnormt numDeriv]; };
   sna = derive { name="sna"; version="2.3-2"; sha256="1dmdv1bi22gg4qdrjkdzdc51qsbb2bg4hn47b50lxnrywdj1b5jy"; depends=[]; };
   snapshot = derive { name="snapshot"; version="0.1.2"; sha256="0cif1ybxxjpyp3spnh98qpyw1i5sgi1jlafcbcldbqhsdzfz4q10"; depends=[]; };
-  SNFtool = derive { name="SNFtool"; version="2.1"; sha256="12kjxgjazb0qivcyg0lkqlvkdk7algpw3s1ir8p5if5c8cpicjyy"; depends=[]; };
+  SNFtool = derive { name="SNFtool"; version="2.2"; sha256="1d84ybsi91mr3ma4jzmr9606hg1q00yg0dn50vkjnyda50igcb1c"; depends=[heatmap_plus]; };
+  snipEM = derive { name="snipEM"; version="1.0"; sha256="0f98c3ycl0g0l3sgjgk7xrjp6ss7n8zzlyzvpcb6agc60cnw3w03"; depends=[Rcpp mvtnorm MASS GSE]; };
   snow = derive { name="snow"; version="0.3-13"; sha256="1habq43ncac9609xky3nqfkbq52cz36dg8jbdihag269z1kazdnf"; depends=[]; };
   SnowballC = derive { name="SnowballC"; version="0.5.1"; sha256="0kbg33hy6m2hv9jspyx6naqmk2q6h2zmvvczjmkwqvlhzlj0c5s4"; depends=[]; };
   snowfall = derive { name="snowfall"; version="1.84-6"; sha256="1n9v9m4c02pspgkxfmq7zdk41s2vjcsk06b0kz9km4xy1x7k0hsg"; depends=[snow]; };
   snowFT = derive { name="snowFT"; version="1.3-0"; sha256="10hhhzzzyz1ph7c8k08s79h4pdwq4jk8bh47y37ww0yjq0fd6gik"; depends=[snow]; };
+  snpar = derive { name="snpar"; version="1.0"; sha256="0c9myg748jm7khqs8yhg2glxgar1wcf6gyg0xwbmw0qc41myzfnq"; depends=[]; };
   SNPassoc = derive { name="SNPassoc"; version="1.9-2"; sha256="113byj8zbg6xyxb1qzm76sqfyk3fap0sd90691zzm1x2pbfnb3mh"; depends=[haplo_stats survival mvtnorm]; };
-  snpEnrichment = derive { name="snpEnrichment"; version="1.4-0"; sha256="0fdr27d7hk3vzvhrvgnypwcrk4y0sncrrg4kk730ynsv0ig7dswl"; depends=[]; };
+  snpEnrichment = derive { name="snpEnrichment"; version="1.5-0"; sha256="1c211schd3hpjis8jhxjp7akgfw2bp5933wpz08c345hk49s35vm"; depends=[]; };
   snplist = derive { name="snplist"; version="0.12"; sha256="0jsf080pbpnsx2jygyqg0l14lsr4fvjzahgchdrawjhl2rky4nwl"; depends=[RSQLite Rcpp R_utils]; };
   SNPmaxsel = derive { name="SNPmaxsel"; version="1.0-3"; sha256="0pjvixwqzjd3jwccc8yqq9c76afvbmfq0z1w0cwyj8bblrjpx13z"; depends=[mvtnorm combinat]; };
   SNPMClust = derive { name="SNPMClust"; version="1.0"; sha256="1vyag8axrl888qhjsbv7g84hzfsnvxh5ccdcdriamy50c2chkji8"; depends=[MASS mclust]; };
   snp_plotter = derive { name="snp.plotter"; version="0.5.1"; sha256="16apsqvkah5l0d5qcwp3lq2jspkb6n62wzr0wskmj84jblx483vv"; depends=[genetics]; };
   snpStatsWriter = derive { name="snpStatsWriter"; version="1.5-6"; sha256="04qhng888yih8gc7yd6rrxvvqf98x3c2xxz22gkwqx59waqd4jlq"; depends=[colorspace]; };
   SNPtools = derive { name="SNPtools"; version="1.1"; sha256="0l29kiqz4048x7amxx1qzkaw2xnd6lpdsdp5nq3rck9amx2hw64a"; depends=[]; };
+  sns = derive { name="sns"; version="0.9.1"; sha256="1knah4y3amv9j03djdm0kcwd50z8hdrpiknx1i35m3bdix85knsn"; depends=[mvtnorm]; };
   SNSequate = derive { name="SNSequate"; version="1.1-1"; sha256="1jgpjws5apysp55pwy3x8mbzy4zjvv39anp6j2x4lgczh5nf49b6"; depends=[magic]; };
   SOAR = derive { name="SOAR"; version="0.99-11"; sha256="1n38gx5sxpkqfkk4y6vpp6g19b8bs5bisni9wn6311s0csizp86m"; depends=[]; };
   soc_ca = derive { name="soc.ca"; version="0.7.1"; sha256="0lg1bpbd0crywa29xc79cn3kr614wq4hr09xpwk17nv7q8qw8cnh"; depends=[ggplot2 gridExtra ellipse scales]; };
   SocialMediaMineR = derive { name="SocialMediaMineR"; version="0.1"; sha256="113nyjncl5yi61hz8i7k60b3f0f9a5vyrd3s72nbmc44cnvr8fci"; depends=[RCurl jsonlite httr]; };
-  SocialNetworks = derive { name="SocialNetworks"; version="1.0"; sha256="0g6l1rf08qz0332fglc2gvkba55fjq9fiwf25rjqanh6spgk60fn"; depends=[Rcpp]; };
+  SocialNetworks = derive { name="SocialNetworks"; version="1.1"; sha256="0d868xka6d35i17r28cvm0ya971xk6y1kycsfff0279w27cjd9x0"; depends=[Rcpp]; };
   SOD = derive { name="SOD"; version="1.0"; sha256="0f0rh1qsjzxb3zzr440kvl6fnnj7dvc5apdzs5hpf6xrlfg863pk"; depends=[Rcpp]; };
   SoDA = derive { name="SoDA"; version="1.0-6"; sha256="0sh2dan4ga2k14rirnkvgzsvbksx1k4ika5gkf5cy247rjkqnpj0"; depends=[]; };
   SODC = derive { name="SODC"; version="1.0"; sha256="18s4rcp5dzchvwrzzbfhbs3x91zlg1rymjarxjk5i429mfrn0krx"; depends=[magic ppls psych MASS]; };
···
   SoftClustering = derive { name="SoftClustering"; version="0.14.02"; sha256="15j79h1ccvzfpi55prbv2d7bms1grgry0ka58cr757cvwavrnbb8"; depends=[]; };
   softImpute = derive { name="softImpute"; version="1.0"; sha256="0pkpr8pxvrrw4p95907bnhl3k54dxz5r2fk8zi56kilrarhzchqr"; depends=[Matrix]; };
   soilDB = derive { name="soilDB"; version="1.3-2"; sha256="0rpkj9rjk75nz4dp0hkp4xjmd5s4lwppabbdqppwc5xs0565rdb6"; depends=[RODBC aqp plyr Hmisc]; };
-  soilphysics = derive { name="soilphysics"; version="1.1"; sha256="1a7dcdhqm4dfdyicbpwc1wlj13y1pwkicyqkam1pizd5wblhr97b"; depends=[rpanel MASS]; };
+  soilphysics = derive { name="soilphysics"; version="1.2"; sha256="0n1w211dkgacahna8b62v2mk813nma66m0y4krwydcbsnwhs4k30"; depends=[rpanel MASS]; };
   soilprofile = derive { name="soilprofile"; version="1.0"; sha256="0sdfg6m2m6rb11hj017jx2lzcgk6llb01994x749s0qhzxmvx9mb"; depends=[aqp lattice munsell splancs]; };
   SoilR = derive { name="SoilR"; version="1.1-23"; sha256="1cryypgnbck5hvkc2izrd8r10q2b97f2p1s46x4dk8p099gck5wg"; depends=[deSolve RUnit]; };
   soil_spec = derive { name="soil.spec"; version="2.1.3"; sha256="17fm4hyx8g6pj7qv11xlnx459x1s41fapz6ck4my9br734gcm4ns"; depends=[KernSmooth wavelets hexView pls]; };
-  soiltexture = derive { name="soiltexture"; version="1.2.13"; sha256="10f4fdvicm7gj5zizpw197avzsbzj9x1g92y1ibh6lpdx3qz0ba1"; depends=[sp MASS]; };
   soilwater = derive { name="soilwater"; version="1.0.1"; sha256="08rz1i5dsgwfvfd4sl5x9j970v82v3kny0rqg1zbdnr53vp2xc7j"; depends=[]; };
   solaR = derive { name="solaR"; version="0.38"; sha256="0cvza0d4kd47kr6749ysvw664kjja87ppn4jvan4hrklczbpdc9z"; depends=[lattice latticeExtra zoo]; };
   SOLOMON = derive { name="SOLOMON"; version="1.0-1"; sha256="0z91wsrgdir25ks4dnirzsg4f1ngal7n40235m3w43j6y6dhkqrc"; depends=[]; };
···
   someKfwer = derive { name="someKfwer"; version="1.1"; sha256="023lrf62z3ik3g6qljmyjkg1lxs21q93ajj3hyjri14431ccc2pg"; depends=[]; };
   someMTP = derive { name="someMTP"; version="1.4.1"; sha256="19bsn8rny1vv9343bvk8xzhh82sskl0zg0f5r59g9k812q5llchn"; depends=[]; };
   somplot = derive { name="somplot"; version="1.6.4"; sha256="06c8p2lqz3yxmxdl7ji8a3czvxnsbl7bwyiig76pkwc3a5qqfbb9"; depends=[hexbin]; };
+  sonicLength = derive { name="sonicLength"; version="1.4.4"; sha256="1v46xzx3jxxxs2biyrq6xbv2lhpz1i95la93hj6dl4jfyikmx0im"; depends=[]; };
   soobench = derive { name="soobench"; version="1.0-73"; sha256="1y2r061pd4kr0kdgp8db3qy2aj07jdiyvy2py4fmwg6b8pcf9y0l"; depends=[]; };
+  SOR = derive { name="SOR"; version="0.22"; sha256="1njwlsvdnwxidvwrx18h6h4dhrsdgy0fikkhn20pip42qqwd96gz"; depends=[Matrix]; };
   SortableHTMLTables = derive { name="SortableHTMLTables"; version="0.1-3"; sha256="1jgrqsm0cj8qlk0s4qn3b83w96mgpp5gmhgcg9q2glc72v8c4ljh"; depends=[testthat brew]; };
   sortinghat = derive { name="sortinghat"; version="0.1"; sha256="1wrxwhdp3gj1ra0rgldnmc0w019bnjb6z9j20c5p1ab09x4dmlny"; depends=[MASS bdsmatrix mvtnorm]; };
   sorvi = derive { name="sorvi"; version="0.6.23"; sha256="070g6kxnacqwzl4djhbb5zjvp71997xl2l53cfni05yf7mkm17as"; depends=[reshape pxR ggplot2 plyr RColorBrewer XML]; };
···
   SPACECAP = derive { name="SPACECAP"; version="1.1.0"; sha256="1m5x2rydppib6fj7wlc6pq4gyvyvhw49yx9qgy4c2rk648wxnhrj"; depends=[coda]; };
   spaceExt = derive { name="spaceExt"; version="1.0"; sha256="0lp8qmb7vcgxqqpsi89zjy7kxpibg3x2mq205pjmsrbbh7saqzr4"; depends=[limSolve glasso]; };
   spacejam = derive { name="spacejam"; version="1.1"; sha256="1mdxmfa1aifh3h279cklm4inin0cx3h0z2lm738bai34j6hpvar7"; depends=[igraph Matrix]; };
-  spacetime = derive { name="spacetime"; version="1.1-0"; sha256="0hmwlvam57i58lhfy9328ld1w4c5ilif6s1wvz6l9zvh036169zi"; depends=[sp zoo xts intervals lattice rgeos]; };
+  spacetime = derive { name="spacetime"; version="1.1-1"; sha256="1c5bkc2dih30frzv2qbzmjvd0vy6n1d4ajp8r84kag2ync3hsdqd"; depends=[sp zoo xts intervals lattice rgeos]; };
   spacodiR = derive { name="spacodiR"; version="0.13.0115"; sha256="0c0grrvillpwjzv6fixviizq9l33y7486ypxniwg7i5j6k36nkpl"; depends=[picante colorspace Rcpp]; };
   spacom = derive { name="spacom"; version="1.0-4"; sha256="1jfsbgy7b0mwl4n2pgrkkghx9p8b0wipvg4c5jar6v8ydby6qg94"; depends=[spdep foreach iterators lme4 nlme Matrix]; };
-  spam = derive { name="spam"; version="0.41-0"; sha256="0pky172hycis2idq4274f9i4vhvj3lz7fpr869vm4qklb91j81sp"; depends=[]; };
-  spaMM = derive { name="spaMM"; version="1.2.0"; sha256="0q8gfy9f0hrf82yp4rnwmjpyh97dz4yx1bhxiww8lh3dsbaagjns"; depends=[Matrix MASS lpSolveAPI proxy geometry Rcpp]; };
+  spam = derive { name="spam"; version="1.0-1"; sha256="033s5ka05kg97fmc3l1li3z6x5225rwhrdxh57wwn4axrjwy1nyy"; depends=[]; };
+  spaMM = derive { name="spaMM"; version="1.3.0"; sha256="0z8ibj5gmmm8pdzpckky3yasfk4p8b21q25wf78pw0788h2x5as1"; depends=[Matrix MASS lpSolveAPI proxy geometry Rcpp nlme]; };
   SPAr = derive { name="SPAr"; version="0.1"; sha256="068jlsvaxx80ih6n86286m2r75cvy6w0m51vpj4gfclhh38py4p4"; depends=[]; };
   sparc = derive { name="sparc"; version="0.9.0"; sha256="0jsirrkmvrfxav9sphk8a4n52fg0d1vnk3i8m804i4xl0s7lrg8s"; depends=[]; };
   sparcl = derive { name="sparcl"; version="1.0.3"; sha256="1348pi8akx1k6b7cf4bhpm4jqr5v8l5k086c7s6rbi5p6qlpsrvz"; depends=[]; };
+  spark = derive { name="spark"; version="1.0.0"; sha256="0ryc7kq3hx8nd5m999p1y7lxli6x862y6hqpv8xwpqak0y863p6m"; depends=[magrittr]; };
   sparkTable = derive { name="sparkTable"; version="0.11.0"; sha256="1293w8xyav7fqrsicx61g4hfq4v4pcd00msi2rm9y5y51b313pm1"; depends=[Cairo gridExtra ggplot2 shiny xtable StatMatch Rglpk pixmap RGraphics]; };
   sparktex = derive { name="sparktex"; version="0.1"; sha256="0r6jnn9fj166pdhnjbsaqmfmnkq0qr1cjprihlnln9jad05mrkjx"; depends=[]; };
   SPARQL = derive { name="SPARQL"; version="1.16"; sha256="0gak1q06yyhdmcxb2n3v0h9gr1vqd0viqji52wpw211qp6r6dcrc"; depends=[XML RCurl]; };
-  sparr = derive { name="sparr"; version="0.3-5"; sha256="0vyy4zvvmkdr285wmmd3c84mvkwsz367k44b2i1j0sfj62m9w7q2"; depends=[spatstat rgl MASS]; };
+  sparr = derive { name="sparr"; version="0.3-6"; sha256="1imgph2bf575rm06l4vsz0nhizkrwa3p5j6b6gdn30l0hlhxjp0j"; depends=[rgl MASS]; };
   sparseBC = derive { name="sparseBC"; version="1.0"; sha256="16x581pm9fkbb4kp8lvz95mnckgrjbiwj9zin8hzyxdl1nrg4c3m"; depends=[glasso]; };
   sparsediscrim = derive { name="sparsediscrim"; version="0.2"; sha256="0m8ccmqpg1np738njavf736qh917hd3blywyzc3vwa1xl59wqccl"; depends=[corpcor bdsmatrix mvtnorm]; };
   SparseGrid = derive { name="SparseGrid"; version="0.8.2"; sha256="057xbj2bhjm9i32kn39iscnqqdsvsmq0b8c92l8hnf9avf1sx10x"; depends=[]; };
···
   SparseM = derive { name="SparseM"; version="1.05"; sha256="041mkl0dlydlar0v0a66n9s1n0klayr08hwzpmwr2hsr05z0z380"; depends=[]; };
   sparseMVN = derive { name="sparseMVN"; version="0.1.0"; sha256="1xcq1w80ypqdz4zxwhnnzc50lhja6qxfxxnrg5xkgzpmy1zvjbzq"; depends=[Matrix]; };
   sparsenet = derive { name="sparsenet"; version="1.2"; sha256="106a2q4syrcnmicrx92gnbsf2i5ml7pidwghrpl6926glj59j248"; depends=[glmnet shape]; };
-  spartan = derive { name="spartan"; version="2.0"; sha256="05xzhmyfx6krdsrqy2x8rsybvh3pc88nrggk955lqy7vwrdpf1j7"; depends=[]; };
+  sparseSEM = derive { name="sparseSEM"; version="2.5"; sha256="0ig8apsi94kvbcq3i8nzmywbdizlss7c6r9bppcyl9lxgikc3cds"; depends=[]; };
+  SparseTSCGM = derive { name="SparseTSCGM"; version="2.1.1"; sha256="0xr3l049kssi7k074wggvc96p2zlca076j2hwpwpmna42xl3dmqv"; depends=[glasso longitudinal flare MASS mvtnorm network abind]; };
+  spartan = derive { name="spartan"; version="2.1"; sha256="1zkb08ppsmbkvgw16y46nlhcsb2s7dh3rcm7f57ydchpda2gxixh"; depends=[]; };
   spatcounts = derive { name="spatcounts"; version="1.1"; sha256="0rp8054aiwc62r1m3l4v5dh3cavbs5h2yb01453bw9rwis1pj2qm"; depends=[]; };
   spate = derive { name="spate"; version="1.3"; sha256="17aiqi5cd17y9kaqx9yssk772ghcldk9i4s8nyafq8zp8d4r85i1"; depends=[mvtnorm truncnorm]; };
   spatgraphs = derive { name="spatgraphs"; version="2.62"; sha256="1h7sv6qc5zhaiaqlrzagrlc2mxlasdzilmi5q9nrd1vsdzsqxvb4"; depends=[]; };
···
   SpatialExtremes = derive { name="SpatialExtremes"; version="2.0-0"; sha256="0fjh4cjzljwzxk4bhcrff9wnkskaiawbj7z6swrj1xl35mq4dljx"; depends=[]; };
   spatial_gev_bma = derive { name="spatial.gev.bma"; version="1.0"; sha256="1rjn0gsbgiv69brhnm0zj25ya3nyfh4yf6jizng85mvss3viv3hj"; depends=[SpatialExtremes msm coda]; };
   spatialkernel = derive { name="spatialkernel"; version="0.4-19"; sha256="0gbl6lrbaxzv2f975k0vd6ghrljgf1kjazld3hm7781kv1f87lji"; depends=[]; };
+  spatialnbda = derive { name="spatialnbda"; version="1.0"; sha256="14mx5jybymasyia752f3vnr5vmswcavbz8bpqr69vlxphw27qkwk"; depends=[SocialNetworks mvtnorm]; };
   SpatialNP = derive { name="SpatialNP"; version="1.1-1"; sha256="108gxk0gbbjck9bgxvqb9h216ww21lmh2by0hrhzwx5r63hhcbmd"; depends=[]; };
   SpatialPack = derive { name="SpatialPack"; version="0.2-3"; sha256="1gs0x3wj3hj663m6kszwhy3ibcx0lrslr127miy1rhz8683ij71c"; depends=[]; };
   spatialprobit = derive { name="spatialprobit"; version="0.9-10"; sha256="1z88nss69pixazqk3b6rpyc7mjryfznrgw9swfyfxky0bsdfj6mv"; depends=[Matrix spdep mvtnorm tmvtnorm]; };
-  spatialsegregation = derive { name="spatialsegregation"; version="2.40"; sha256="0kpna2198nrj93bjsdgvj85wnjfj18psdq919fjnnhbzgzdkxs7l"; depends=[spatstat]; };
-  spatialTailDep = derive { name="spatialTailDep"; version="1.0"; sha256="070jsz86jc4qvwa8j9gfksy23hf0wgj307w7jd5107ng1f42047v"; depends=[cubature mvtnorm SpatialExtremes]; };
+  spatialsegregation = derive { name="spatialsegregation"; version="2.40"; sha256="0kpna2198nrj93bjsdgvj85wnjfj18psdq919fjnnhbzgzdkxs7l"; depends=[]; };
+  spatialTailDep = derive { name="spatialTailDep"; version="1.0.1"; sha256="1ai6w6yl41wlkj4lvxcn0v6xgqqi4g22qihinq4ysf38pawprs6p"; depends=[cubature mvtnorm SpatialExtremes]; };
   spatial_tools = derive { name="spatial.tools"; version="1.4.8"; sha256="0qnsjfx974na87p3n7sp711sc13v6dmpvb2kjpvscixs8rsy03y1"; depends=[iterators foreach rgdal raster mmap abind doParallel]; };
   SpatialTools = derive { name="SpatialTools"; version="0.5.8"; sha256="18zchr8bfjqdr9j6vh6365mhrj2n0ns1ixvmas5s0ppiim59jl7j"; depends=[spBayes Rcpp]; };
-  SpatialVx = derive { name="SpatialVx"; version="0.2-1"; sha256="0j6m698nyd9nq0qx1s2ykk05q2scj9jb0m813r0xyymf0sl0l90a"; depends=[spatstat fields smoothie smatr turboEM distillery maps boot CircStats fastcluster waveslim]; };
+  SpatialVx = derive { name="SpatialVx"; version="0.2-1"; sha256="0j6m698nyd9nq0qx1s2ykk05q2scj9jb0m813r0xyymf0sl0l90a"; depends=[fields smoothie smatr turboEM distillery maps boot CircStats fastcluster waveslim]; };
   SpatioTemporal = derive { name="SpatioTemporal"; version="1.1.7"; sha256="0rc5zf8cnjw59azgqmslfz2dl5i17dfmb7ls5c849qybp2gn2zdv"; depends=[Matrix MASS]; };
-  spatstat = derive { name="spatstat"; version="1.37-0"; sha256="1vz22y6k79xqbcl5qdbjn36qwlc7sh7jlcvrdq9v1sbmqvdj2j23"; depends=[mgcv deldir abind tensor polyclip]; };
-  spatsurv = derive { name="spatsurv"; version="0.9-6"; sha256="0gq0m27i96v3pasq8b4d6dyi6x3irxm648f3l2sw693dm12gcqrx"; depends=[survival sp iterators RandomFields fields rgl Matrix stringr]; };
+  spatsurv = derive { name="spatsurv"; version="0.9-7"; sha256="0n75p59qd1p47r4cs7p0pilq368bjlf0wn2hssaz47rbrp0kss0n"; depends=[survival sp iterators RandomFields fields rgl Matrix stringr]; };
   spBayes = derive { name="spBayes"; version="0.3-8"; sha256="0pmriffqnblqyd1332a2pqrjr7y3wllb17swb403h7c9dph6mzzv"; depends=[coda magic abind Formula]; };
-  spBayesSurv = derive { name="spBayesSurv"; version="1.0.0"; sha256="17di7irh9sad3jviw8adp3z0v1qi8j6rsh2wv0y6k59milflsdn9"; depends=[Rcpp survival]; };
+  spBayesSurv = derive { name="spBayesSurv"; version="1.0.1"; sha256="1c23f73hzzdpz5cbjixgdg7b5xj6d9ch45hf71skr2rd79a39sqi"; depends=[Rcpp survival coda]; };
   spc = derive { name="spc"; version="0.5.0"; sha256="0bh4a3dpavczckhpwqax1h5w73ai3mkf0nwq9nhlvkdrh6k6j6cy"; depends=[]; };
-  spcadjust = derive { name="spcadjust"; version="0.1-2"; sha256="1i64hbslsmnap6ljwpzygrbcb2q1zp0jsm02x2a29nyxq05wwrrv"; depends=[]; };
+  spcadjust = derive { name="spcadjust"; version="0.1-3"; sha256="1l6m4aisk780znpjr7lnlh0z42rbc2jyblv17hafbr1siymrasc2"; depends=[]; };
   spcosa = derive { name="spcosa"; version="0.3-5"; sha256="15q0f2sfhm1b13zs5a50yfvqhgcn4fyncf0h5ivin2k9g5xvq4k4"; depends=[rJava ggplot2 sp]; };
   spcov = derive { name="spcov"; version="1.01"; sha256="1brmy64wbk56bwz9va7mc86a0ajbfy09qpjafyq2jv7gm7a35ph5"; depends=[]; };
   spcr = derive { name="spcr"; version="1.2"; sha256="0xixl6b4h3iawpbfgdni6z2v7ch3ydn7s9fyr8g0sjr4svzqbyiv"; depends=[]; };
   spd = derive { name="spd"; version="2.0-0"; sha256="0aznzj68gynhx295gdb4sb7xxjiya4vbdg3gshfs0mwg1qzrhxy9"; depends=[KernSmooth]; };
-  spdep = derive { name="spdep"; version="0.5-74"; sha256="0f9ahp57dfincwjazx0fgqzk4i2nc6fxra7dlfa8xvzwrp1yll05"; depends=[sp Matrix LearnBayes deldir boot coda nlme MASS]; };
-  spdynmod = derive { name="spdynmod"; version="1.0"; sha256="0az4y95j1x0kid6smc0k20w1q2bnjnr267rw8fk0j41rrm7njcai"; depends=[deSolve raster animation]; };
+  spdep = derive { name="spdep"; version="0.5-77"; sha256="0l4qsfcjdmj1xpc53b0vhv50n533ijzjcg0lmm7w8pslyhkmq8hh"; depends=[sp Matrix LearnBayes deldir boot coda nlme MASS]; };
+  spdynmod = derive { name="spdynmod"; version="1.0"; sha256="05gaaln14lrrds43l2f9hw43c86gswyzymz97hc3mci1cgiwfwbz"; depends=[deSolve raster animation]; };
   spe = derive { name="spe"; version="1.1.2"; sha256="0xyx42n3gcsgqmy80nc9la6p6gq07anpzx0afwffyx9fv20fvys0"; depends=[]; };
   speccalt = derive { name="speccalt"; version="0.1.1"; sha256="0j7rbidmmx78vgwsqvqjbjjh92fnkf2sdx0q79xlpjl2dph7d6l6"; depends=[]; };
   SPECIES = derive { name="SPECIES"; version="1.0"; sha256="0p45llf2wjr467bqr4pbljfank9zz3fm42yl3i0r3jbkxgz0rjf0"; depends=[]; };
   SpeciesMix = derive { name="SpeciesMix"; version="0.3.1"; sha256="0wl15k00d7n9pmnp1kr28p05z4vrziprcdndw77kwkcgv51cvllk"; depends=[MASS numDeriv]; };
   specificity = derive { name="specificity"; version="0.1.1"; sha256="1gvlyx9crkzm3yyp1ln5j9czcg83k7grm6ijabhl919gjjr1p60n"; depends=[car]; };
-  SpecsVerification = derive { name="SpecsVerification"; version="0.1-1"; sha256="0bym4r2bz02v7cw0sn5bpsrnyvrm9jq2s9hz621x10d37iymc7m0"; depends=[]; };
+  SpecsVerification = derive { name="SpecsVerification"; version="0.3-0"; sha256="19vr4xlx9gx0ph6k2kf59bpbhmzncm1mmzz7ld3pjc7k4jfba3np"; depends=[]; };
   spectralGP = derive { name="spectralGP"; version="1.3.1"; sha256="1bc8y4wk09spsvbv8cn1iqq2y9qdlvrcnpqh2s0b8j4nxx262gyb"; depends=[]; };
   spectral_methods = derive { name="spectral.methods"; version="0.7.2.125"; sha256="06d7l3hv1yi887yd3ig63n2ajyxa7a0cpjaza8spif9yj5jia35d"; depends=[Rssa raster nnet abind RNetCDF ncdf_tools foreach JBTools DistributionUtils RColorBrewer]; };
-  speedglm = derive { name="speedglm"; version="0.2"; sha256="1vl3q67qhrvg01m2yaxrjz4rc3wh1mrmr3hdh0bbdg8rjq1khbl0"; depends=[Matrix]; };
-  speedRlibs = derive { name="speedRlibs"; version="1.1-36"; sha256="1q0kv07wgirfmvaqrnyfr6csz8yycjnpqlvxq9w2k5agsn86pbr8"; depends=[]; };
-  speedRlibTF = derive { name="speedRlibTF"; version="0.3-39"; sha256="061cnc9qy1zpfr0k9a57jfy3xf25gkl67f22sniykmk31v0vr60r"; depends=[]; };
+  speedglm = derive { name="speedglm"; version="0.2-1.0"; sha256="13gjij9pb65j9c52d5cxl9n6fjmcwbhja4wdl4619dy5rj9vsyi4"; depends=[Matrix]; };
   speff2trial = derive { name="speff2trial"; version="1.0.4"; sha256="0dj5mh2sdp6j4ijgv14hjr39rasab8g83lx1d9y50av11yhbf2pw"; depends=[leaps survival]; };
   SPEI = derive { name="SPEI"; version="1.6"; sha256="0mbz4nydnzwypfbi1d9fjy09x6133q096qbfrc913dbidzkvfpqv"; depends=[lmomco]; };
   sperich = derive { name="sperich"; version="1.5-5"; sha256="0xwzyfx3z06lapvhzdzrfr9hw2hm8d0cyfmc29p5fcplmjm24idh"; depends=[]; };
   sperrorest = derive { name="sperrorest"; version="0.2-1"; sha256="17jq8r98pq3hsyiinxg30lddxwpwi696srsvm3lfxrzk11076j6v"; depends=[ROCR rpart]; };
   spfrontier = derive { name="spfrontier"; version="0.1.10"; sha256="0x1f8g8lg1f5kp9m2pnj8qbv5pjk40kh40yd3s6iwgny4hjsmg60"; depends=[moments ezsim tmvtnorm mvtnorm Matrix]; };
-  spgrass6 = derive { name="spgrass6"; version="0.8-3"; sha256="0syrm4fgyzslvl9k8szlha01iqkz02nla08whys3pvf4s9zjd4xl"; depends=[sp XML]; };
-  spgwr = derive { name="spgwr"; version="0.6-24"; sha256="10yiyq704gs51h7i2nrd5r8730np7hvkcfnn3mly5wgaanrcb6n4"; depends=[sp]; };
+  spgrass6 = derive { name="spgrass6"; version="0.8-6"; sha256="0vpv2vycd6rdnwm1f73733x1nclhr2x4x1s5116szskni77b0pii"; depends=[sp XML]; };
+  spgwr = derive { name="spgwr"; version="0.6-25"; sha256="03kddalnlis5vw9d8shmp2v8f057nqnsvh5qncx75hpbhrzvkmni"; depends=[sp]; };
   sphereplot = derive { name="sphereplot"; version="1.5"; sha256="1i1p20h95cgw5wqp9bwfs9nygm4dxzsggz08ncjs1xrsvhhq9air"; depends=[rgl]; };
   SphericalCubature = derive { name="SphericalCubature"; version="1.0.1"; sha256="0j592zvs07yc6amahlxgdw0k1vqr89gvcq22vcwzkx62igvlf6pv"; depends=[cubature]; };
   SpherWave = derive { name="SpherWave"; version="1.2.2"; sha256="1wd9pql97m1zl0axzpkfq9sxadrm5cfax0gxh0ncqadaq7w7lml4"; depends=[fields]; };
···
   spikeslab = derive { name="spikeslab"; version="1.1.5"; sha256="0dzkipbrpwki6fyk4hqlql3yhadwmclgbrx00bxahrmlaz1vjzh2"; depends=[lars randomForest]; };
   spikeSlabGAM = derive { name="spikeSlabGAM"; version="1.1-7"; sha256="1hdclj3fq31n9hvyggj2rvz2m95kjszbcswa46vfi2vyiwbb2bia"; depends=[ggplot2 akima coda cluster gridExtra MASS MCMCpack mvtnorm R2WinBUGS reshape scales]; };
   SPIn = derive { name="SPIn"; version="1.1"; sha256="109xxrg7bsmmfd6ik85kxrw2qclxbh5ipsh5mmrdl4hki3hnyp2s"; depends=[quadprog]; };
-  splancs = derive { name="splancs"; version="2.01-34"; sha256="0r7kn16mkpzyj52i28w40k0hngkf4i3si4qvkb8m5s641lw2jmpk"; depends=[sp]; };
-  splitstackshape = derive { name="splitstackshape"; version="1.2.0"; sha256="0p9av1zzzl6h5d3fprwcd8ng1g2s8wq7bzid7lqig3k8mcgzwm20"; depends=[data_table]; };
+  splancs = derive { name="splancs"; version="2.01-36"; sha256="0m29zh91jyz69nh2a9iigzcaxd1mlhq3b7z40vgqib4jnbzkbyg5"; depends=[sp]; };
+  splitstackshape = derive { name="splitstackshape"; version="1.4.2"; sha256="0m9karfh0pcy0jj3dzq87vybxv9gmcrq5m2k7byxpki95apbrsmg"; depends=[data_table]; };
   splm = derive { name="splm"; version="1.1-0"; sha256="1dhfasan5abr9gf6lfdl83cr47ckkj5sqjqgclnc6f6a2125q1fi"; depends=[MASS nlme spdep plm Matrix bdsmatrix spam ibdreg car lmtest Ecdat maxLik]; };
   spls = derive { name="spls"; version="2.2-1"; sha256="0zgk9qd825zqgikpkg13jm8hi6ncg48qw5f985bi145nwy9j19xs"; depends=[MASS nnet pls]; };
   splus2R = derive { name="splus2R"; version="1.2-0"; sha256="0kmyr1azyh0m518kzwvvgz7hv1x5myj37xn7w2gfn0vbn5xl8pv1"; depends=[]; };
   splusTimeDate = derive { name="splusTimeDate"; version="2.5.0-135"; sha256="0hghggdcr70vfjx4npj37nmd96qvgrp1gpwa9bznvjkvyfawwy6i"; depends=[]; };
   splusTimeSeries = derive { name="splusTimeSeries"; version="1.5.0-73"; sha256="1csk0ffgg1bi2k1m2bbxl6aqqqxf6i8sc8d4azip8ck7rn8vya46"; depends=[splusTimeDate]; };
-  spMC = derive { name="spMC"; version="0.3.1"; sha256="12ymyyy77y7azbg983y091dfqcv68c7lpz2rcnnn384jqp7b2c4v"; depends=[]; };
+  spMC = derive { name="spMC"; version="0.3.4"; sha256="0s04vdj7xi2zayxy6qx918fqsp0p8hixx6a101b0w0a3db9gshv5"; depends=[]; };
   SPmlficmcm = derive { name="SPmlficmcm"; version="1.1"; sha256="02hg9dzfnxa8cz31kkq52707f7y5471cq78asfbrf397mfz82wbl"; depends=[numDeriv nleqslv boot]; };
   SPMS = derive { name="SPMS"; version="2.0"; sha256="150kb4gjiksp3kc7p9j5zqc4955rq4fb27as71z89h23mkswz5r5"; depends=[Matrix]; };
   spnet = derive { name="spnet"; version="0.9.0.1"; sha256="0fy19y155m1fmifdnsyb8y71xgnk3hyril28x68bwvn2v9d737k5"; depends=[sp shape]; };
-  spocc = derive { name="spocc"; version="0.2.0"; sha256="069yfksdk10779pb6xyg8cgq83ipbigi2zs9dymqyk8q6w1y8xhf"; depends=[ggplot2 rinat rbison rgbif ecoengine rebird AntWeb plyr ggmap maptools rworldmap sp rgeos lubridate RColorBrewer httr XML rgdal RJSONIO leafletR data_table assertthat whisker]; };
+  spocc = derive { name="spocc"; version="0.2.2"; sha256="0hy72nh29hkzgqhsbadx4708y4sswacn9z75kcrqd1krc5fqa926"; depends=[ggplot2 rgbif rinat rbison ecoengine rebird AntWeb plyr ggmap maptools rworldmap sp rgeos lubridate RColorBrewer httr XML rgdal RJSONIO leafletR data_table assertthat whisker]; };
   SPODT = derive { name="SPODT"; version="0.9"; sha256="0r5zr0h5dgbkpn6dlvpj58s2wp3ngb7zb1xdapq1j25msmhwn5yy"; depends=[rgdal sp tree]; };
   sporm = derive { name="sporm"; version="1.1"; sha256="07sxz62h4jb7xlqg08sj4wpx121n9jfk65196mnxdvb36lqmb4hp"; depends=[]; };
   SportsAnalytics = derive { name="SportsAnalytics"; version="0.2"; sha256="1vb080ak1mfvr6d0q9i3r8hd547ba80bavjdcri0gclqqcjf1ach"; depends=[]; };
   SPOT = derive { name="SPOT"; version="1.0.4184"; sha256="0rikfs2rha7q2xbycvky8si2ccgmamcn662g8ni105cr6m9hvvpc"; depends=[rpart emoa]; };
+  SPREDA = derive { name="SPREDA"; version="1.0"; sha256="1dyqsra899fd1nbk1b7vkw8gs455c6pbcvzw84q9iri77186xqhv"; depends=[survival nlme]; };
+  sprint = derive { name="sprint"; version="1.0.7"; sha256="1yzx1qjpxx9yc0hbm1mmha5b7aq13iflq66af597b7yj6abm7zjp"; depends=[rlecuyer ff randomForest boot e1071]; };
   sprsmdl = derive { name="sprsmdl"; version="0.1-0"; sha256="09klwsjp5w6p7dkn5ddmqp7m9a3zcmpr9vhcf00ynwyp1w7d26gi"; depends=[]; };
   SPSL = derive { name="SPSL"; version="0.1-8"; sha256="1jg1nfhz8qml1wwqa4d0w7vkdmbgdy5xlfqx0h2pdw2z8iij3xxc"; depends=[]; };
   spsmooth = derive { name="spsmooth"; version="1.1-3"; sha256="09b740586zyi8npq0bmy8qifs9rq0rzhs9c300fr6pjpc7134xn4"; depends=[mgcv]; };
   spsurvey = derive { name="spsurvey"; version="2.6"; sha256="1s48acqi502mdabhymhn0jjsghnlh2w6wnrfaa9gv0a7xjvjkydq"; depends=[sp deldir foreign MASS rgeos]; };
   spt = derive { name="spt"; version="1.13-8-8"; sha256="18s74pxfmsjaj92z2a34nq90caf61s84c616yv33a0xvfvp32qr5"; depends=[]; };
-  spTimer = derive { name="spTimer"; version="1.0-2"; sha256="1f0y0bzipk0j272w8d31rw8l0xvw5hj64d5j9cfvjzgbp9kzp56h"; depends=[coda forecast spacetime]; };
+  spTimer = derive { name="spTimer"; version="1.0-3"; sha256="0ys1apara63l3a6sx07hgb1v67yq02lm9w8x70f1ixisilhw6q39"; depends=[coda sp]; };
+  sptm = derive { name="sptm"; version="14.10-11"; sha256="1g7dqfsyy0cvv3idx16bpny9z4f638aprbc50x8kk4zfk3km7wnr"; depends=[survival survey kyotil]; };
   spuRs = derive { name="spuRs"; version="2.0.0"; sha256="0lbc3nny6idijdaxrxfkfrn40bxfyp9z3yl9mwb1k6cyd10v5mfj"; depends=[MASS lattice]; };
-  sqldf = derive { name="sqldf"; version="0.4-7.1"; sha256="03pg1wrkbhh6yi794rf5a96kls0zixqz50ralznvgd0zyvmd3cz2"; depends=[gsubfn proto RSQLite RSQLite_extfuns DBI chron]; };
+  SQDA = derive { name="SQDA"; version="1.0"; sha256="0nfimk625wb64010r5r7hzr64jfwgc6rbn13wvrpn0jgayji87h6"; depends=[PDSCE mvtnorm]; };
+  sqldf = derive { name="sqldf"; version="0.4-9"; sha256="0nm77wkj4w1rc545bsa0sw1i3l13myq3brx26sii18zsx6lmprgz"; depends=[gsubfn proto RSQLite DBI chron]; };
   sqliter = derive { name="sqliter"; version="0.1.0"; sha256="17jjljq60szz0m8p2wc5l56659aap7an5gknc848dp89ycjgj3zx"; depends=[stringr functional DBI RSQLite]; };
   sqlshare = derive { name="sqlshare"; version="1.0.3"; sha256="1qy8vlzi6i4wsr53i71jlsv1b7ww254mbk2qzsvmcrranf42zbp8"; depends=[RCurl]; };
   sqlutils = derive { name="sqlutils"; version="1.1.2"; sha256="1d3x4wid7f9h2y36avsajjvshzcszr2nby71ixfdq3iv8z01z4j3"; depends=[roxygen2 stringr DBI]; };
   SQN = derive { name="SQN"; version="1.0.5"; sha256="0kb8kf6g482zqdp4avwvhs3pqghfny757dbzfl1abaigmvwvx4qj"; depends=[mclust nor1mix]; };
-  SQUAREM = derive { name="SQUAREM"; version="2012.7-1"; sha256="17d5b9h7h8ayasi4zg790b3a11rka8dkfcmvhrjg4rvlggwjda5j"; depends=[]; };
+  SQUAREM = derive { name="SQUAREM"; version="2014.8-1"; sha256="17fn37da4zslbfq5h4f3dfwyw1dxj5y2rgly3vjl2c4k5bnwxxqw"; depends=[]; };
   squash = derive { name="squash"; version="1.0.6"; sha256="16iplngzzlif999z821a9bwx9jlmikdvwnk6p6d9w75b1fsbc0pz"; depends=[]; };
   sra = derive { name="sra"; version="0.1"; sha256="165r1aiv17gdhln2374724nx04wjcdpillxwwkxgshz3kjyvajvj"; depends=[]; };
   sROC = derive { name="sROC"; version="0.1-2"; sha256="0cp6frhk9ndffb454dqp8fzjrla76dbz0mn4y8zz1nbq1jzmz0d3"; depends=[]; };
-  SRPM = derive { name="SRPM"; version="0.1-7"; sha256="1c7mca1p0z48w5jbywqqfbdwzcimy24fm23h5n930mxbxgh51shk"; depends=[stashR filehash cacheSweave]; };
   SRRS = derive { name="SRRS"; version="0.1.1"; sha256="0jv545a97q4pyl89lmhn3y0jhdzyq033mvx144x8lcgx59s7cyi3"; depends=[tcltk2 gtools]; };
   ss3sim = derive { name="ss3sim"; version="0.8.2"; sha256="1gj3kf4ccd5n2jr4sm50gny5x1zq4brkhqgw0nww41spnimascfr"; depends=[plyr r4ss gtools lubridate reshape2]; };
   ssanv = derive { name="ssanv"; version="1.0-2"; sha256="18ib0djqxjpp4xgvsffwqgxqljpwc24ysxj26phpr6p8kdl3hr2f"; depends=[]; };
-  SSDforR = derive { name="SSDforR"; version="1.4.6"; sha256="1ab4z7zm08wgy9vm1bbfgrxhizly5wpwzk8ikqzkfpvy43fgv80m"; depends=[psych]; };
+  SSDforR = derive { name="SSDforR"; version="1.4.7"; sha256="0d2p8rszjk1zh5wlv0bxsf40829kdxg9264i08z3db0lvhlbmaz2"; depends=[psych TTR MASS TSA]; };
   sse = derive { name="sse"; version="0.5-1"; sha256="0g0bwmgc585haqbb13366s3pv1vdh793hwwibz7im0avjs2ldsjq"; depends=[lattice]; };
   ssfit = derive { name="ssfit"; version="1.1"; sha256="1fais0msi2ppgfp0vbx3qri7s9zs51i7n90w36xkwwac4f46bq5y"; depends=[survey]; };
   ssh_utils = derive { name="ssh.utils"; version="1.0"; sha256="08313zzzgcyvzkrkq0w0yf748ya1a9shx5xnan5891v0lah9v0b1"; depends=[stringr]; };
···
   sss = derive { name="sss"; version="0.0-11"; sha256="0k7p1ws0w7wg9wyxcg1zpk8q6kr32l3jl6yd9r4qmzq04dwqrdgz"; depends=[plyr XML]; };
   SSsimple = derive { name="SSsimple"; version="0.6.4"; sha256="0p7d4hx7mhn5myq8ajcij6hhg79rjxigk5v8z93yfdw4gjcb5wad"; depends=[mvtnorm]; };
   ssvd = derive { name="ssvd"; version="1.0"; sha256="1fdpr38qi59ijrz16jixn6ii1hvmxfjirjqfcp7dxrqz9nx8x0sk"; depends=[]; };
-  ssym = derive { name="ssym"; version="1.3"; sha256="00bgqcf7l6mfjqxsvarh4g78hq21k4dq883c5yd7xkw609dp94pw"; depends=[GIGrvg numDeriv gsl normalp]; };
+  ssym = derive { name="ssym"; version="1.5.1"; sha256="026qn8qaf0y7kwb82rqpbhhkc645s5a2s6r408h8hx6bppvg7i8y"; depends=[GIGrvg numDeriv normalp Formula]; };
   st = derive { name="st"; version="1.2.2"; sha256="0dbs95iaac3zvcgrndqic6rwchyvkbda641pv0dvj7h64c3k8w24"; depends=[sda fdrtool]; };
   stab = derive { name="stab"; version="0.1.8"; sha256="1rbwfxdbdqb1l91xmnnz5z5m353z4rjihr0c1f7r77a0zl7sa3zj"; depends=[MASS reshape]; };
   stabledist = derive { name="stabledist"; version="0.6-6"; sha256="0s59jp3y5ks4rfj7x76vb9g3slbbn98lvki54lv96yxdfr8i7ry5"; depends=[]; };
   StableEstim = derive { name="StableEstim"; version="2.0"; sha256="080khfix88j4656hmdy9l0xpbk9zzw7z7d7f6yvwsbalk3ag18i5"; depends=[Matrix stabledist testthat numDeriv xtable fBasics MASS]; };
+  stabs = derive { name="stabs"; version="0.1-0"; sha256="0ira32jw8fdv7qcmvk6ai0vgwn7mh1srxb5m7v2v5aj29gd2zfcd"; depends=[]; };
   Stack = derive { name="Stack"; version="2.0-1"; sha256="09fgfhw9grxnpl5yg05p9gvlz38iw4prns1jn14nj3qx01k5rnxb"; depends=[plyr stringr ff ffbase bit]; };
   stacomirtools = derive { name="stacomirtools"; version="0.3"; sha256="1lbbnvmilf3j3hyhvpkyjd4b4sf3zwygilb8x0kjn2jfhkxnx4c1"; depends=[RODBC xtable]; };
   stam = derive { name="stam"; version="0.0-1"; sha256="1x1j45fir64kffny0nssb2hwn4rcp8gd2cjv6fw4yy0l4d0xi5iv"; depends=[np sp]; };
-  StAMPP = derive { name="StAMPP"; version="1.2"; sha256="0fd328byrcq11rpq4dvk65vs8gswaw0d9jb8di9hx5r7cdpka1g3"; depends=[pegas doParallel foreach adegenet]; };
+  StAMPP = derive { name="StAMPP"; version="1.3"; sha256="1igf6arp7glihkv60zc7c0zwfqaf5kcm2d1xr856fj194zxww9ad"; depends=[pegas doParallel foreach adegenet]; };
   StandardizeText = derive { name="StandardizeText"; version="1.0"; sha256="0s267k2b109pcdiyd26gm4ag5afikrnnb55d3cs6g2fvzp744hfp"; depends=[]; };
-  standGL = derive { name="standGL"; version="1.1"; sha256="1ffskpba30ih1sb1gscy4njgr4vv0642311hj1m7x7n5slisnysm"; depends=[]; };
   STAR = derive { name="STAR"; version="0.3-7"; sha256="1g78j4iyh78li1jaa3zz5qv4p41cg0imhmvbfakd34l32ppih4ll"; depends=[survival mgcv R2HTML gss codetools]; };
   stargazer = derive { name="stargazer"; version="5.1"; sha256="0ar0qm289ncsns2pqkabpyjc90ws0il1q7fp5206wqghgsvqjcc0"; depends=[]; };
-  STARSEQ = derive { name="STARSEQ"; version="1.02"; sha256="1gb763bb7z871hb443d29r0vvyl2inr0df0q0xxxg16scl4p4yvb"; depends=[CompQuadForm numDeriv vcf2geno]; };
   startupmsg = derive { name="startupmsg"; version="0.9"; sha256="1l75w4v1cf4kkb05akhgzk5n77zsj6h20ds8y0aa6kd2208zxd9f"; depends=[]; };
   stashR = derive { name="stashR"; version="0.3-5"; sha256="1lnpi1vb043aj4b9vmmy56anj4344709986b27hqaqk5ajzq9c3w"; depends=[filehash digest]; };
   Stat2Data = derive { name="Stat2Data"; version="1.6"; sha256="0pk68ffc6ffpddfpf9wi8ch39h6k3r80kldld3z5pnql18rc8nvx"; depends=[]; };
+  statar = derive { name="statar"; version="0.1.2"; sha256="1sy0nvpx9ji39bjjrlb23d46r2inyljzsk54lf1llmfjpy6pslkp"; depends=[data_table dplyr ggplot2 Hmisc lazyeval lfe lubridate matrixStats stringr tidyr]; };
   StatDA = derive { name="StatDA"; version="1.6.7"; sha256="140hqg56axwg5ckfr4n4rr453ppsgf5bmmd7kg4mai1xnj4wmg8b"; depends=[geoR sgeostat cluster e1071 MASS MBA mgcv rgl robustbase xtable]; };
   StatDataML = derive { name="StatDataML"; version="1.0-25"; sha256="05s9kbrjl2wsfccgav34b02m06q62r3iyjd0ndr6xcqlw9x2w2ya"; depends=[XML]; };
-  StateTrace = derive { name="StateTrace"; version="1.0-4"; sha256="1nmdqmg4az1afhprjyqb9qqcvd0xa6xdb8gzar5jrcdldxxbsw35"; depends=[KernSmooth coda fgui]; };
+  statebins = derive { name="statebins"; version="1.0"; sha256="1mqky4nb31xjhn922csvv8ps2fwgcgazxs56rcn3ka32c59a4mmg"; depends=[ggplot2 scales gridExtra RColorBrewer]; };
   statfi = derive { name="statfi"; version="0.9.8"; sha256="0kg9bj2mmd95ysg604rcg4szqx3whbqm14fwivnd110jgfy20gk2"; depends=[pxR]; };
   StatMatch = derive { name="StatMatch"; version="1.2.2"; sha256="1ml88ssd2xrnxh6xbg25bbskqv9jrn5vczaq3a3v4bccimv65prh"; depends=[proxy clue survey RANN]; };
   StatMethRank = derive { name="StatMethRank"; version="1.0"; sha256="0mcvwn1f3hylvyg46vigc5wnvhhig5v01ag3y9rap32v85f308zh"; depends=[MASS rjags pmr]; };
···
   statnet = derive { name="statnet"; version="2014.2.0"; sha256="0xp8xnqb32wzkxfm7f34z6mnsd9id8an5829n16czwldj9vv6s10"; depends=[network ergm sna networkDynamic tergm ergm_count latentnet statnet_common]; };
   statnet_common = derive { name="statnet.common"; version="3.1.1"; sha256="1fs38f4dxrvgm60xvn04jr2wwyrjg25h3rbdwrx7dx24fj7sx6wl"; depends=[]; };
   StatRank = derive { name="StatRank"; version="0.0.4"; sha256="0s0jc4hvrry9a884fqfk3gp1w4ww5wif2kh3m0f22nn7qb49if9p"; depends=[truncdist plyr]; };
+  steepness = derive { name="steepness"; version="0.2-2"; sha256="0bw7wm7n2xspkmj90qsjfssnig683s3qwg1ndkq2aw3f6clh4ilm"; depends=[]; };
   stellaR = derive { name="stellaR"; version="0.3-3"; sha256="098sz6b8pl3fyca3g6myp97nna368xhxf8krmibadnnsr49q5zs9"; depends=[]; };
   Stem = derive { name="Stem"; version="1.0"; sha256="1fr02mi5qyxbqavdh2hg8ggw4nfjh3vs7g0vh834h6y0v53l71r5"; depends=[mvtnorm MASS]; };
   STEPCAM = derive { name="STEPCAM"; version="1.0"; sha256="0lgikdj0mghz5hjm3rlrnnddjhvf9cmm0hwklbdyl3h816gq1jci"; depends=[vcd FD gtools MASS]; };
-  stepp = derive { name="stepp"; version="2.3-2"; sha256="1x7vbniwk83x9wn6a5ya053nkg9jmzqprqbg87zpp0fsn9z7qhyq"; depends=[cmprsk survival]; };
+  stepp = derive { name="stepp"; version="3.0-11"; sha256="0jrwfvcgh3sjm3zag93kjyny2qqsyiw988vnx6jw7s31bv9g0d6s"; depends=[car survival]; };
   stepPlr = derive { name="stepPlr"; version="0.92"; sha256="16j32sk7ri4jdgss7vw5zz7s42rxk7rs376iyxzzpy1zcc9b64rv"; depends=[]; };
   stepwise = derive { name="stepwise"; version="0.3"; sha256="1lbx1bxwkf9dw6q46w40pp7h5nkxgghmx8rkpaymm6iybc7gyir2"; depends=[]; };
-  StereoMorph = derive { name="StereoMorph"; version="1.1"; sha256="0yin0x6lwjzc04497p6xv4hckp1s4mvzq5jhplrc13xyv5121vwv"; depends=[bezier rjson shiny]; };
+  StereoMorph = derive { name="StereoMorph"; version="1.2.1"; sha256="1wvkqrfghxcdiicr81hrl320zcpj6q9kqjddsrm24p98vs83hlpi"; depends=[bezier rjson shiny Rcpp jpeg]; };
   stilt = derive { name="stilt"; version="1.0.1"; sha256="1vrbbic0vqzgy574kzcr38iqyhax4wa6zl6w74n65z15map2fyma"; depends=[fields]; };
   stima = derive { name="stima"; version="1.1"; sha256="1i8l7pfnqxx660h3r2jf6a9bj5ikg9hw7v8apwk98ms8l7q77p5l"; depends=[rpart]; };
   stinepack = derive { name="stinepack"; version="1.3"; sha256="0kjpcjqkwndqs7cyc6w62z1nnkqmhkifz2w0bi341jh0ybmak4fq"; depends=[]; };
-  stm = derive { name="stm"; version="0.6.24"; sha256="0hifw7m50sa2r82mj4zc65pfb0hcqr7wcqmps9a0q8y57k077y4a"; depends=[matrixStats slam lda stringr]; };
-  StMoSim = derive { name="StMoSim"; version="2.2"; sha256="127nr488a9xx3pjzrncbzw58ims87jifnzhpvqrr74px6wv0yisc"; depends=[]; };
+  stm = derive { name="stm"; version="1.0.1"; sha256="15zf3cg9ggxqf2pyxmdczzrq6q4pqy3r9pm7i2qjwc4rc3730dp8"; depends=[matrixStats slam lda stringr Matrix glmnet]; };
+  StMoSim = derive { name="StMoSim"; version="3.0"; sha256="18mdgpn0x6338zzvc7nwccz6ypqmlpv7pzcy5fwx5y2wfkmdp4rm"; depends=[RcppParallel Rcpp]; };
   stocc = derive { name="stocc"; version="1.23"; sha256="183rv1l1hpa691f3xf455bv8dzdw6ac79zg3v99zksli6i7c8jdz"; depends=[truncnorm coda Matrix fields]; };
-  stochprofML = derive { name="stochprofML"; version="1.1"; sha256="0pxx0ws4zklf38kjvp68rkk5qfzrxhk38f8d1ib8dd0chb7avb01"; depends=[MASS numDeriv]; };
-  stochvol = derive { name="stochvol"; version="0.8-4"; sha256="1s79anyiczci9jhwqc3nslvc2k4gqzbwijhinbr9703qhhnm5qx0"; depends=[coda Rcpp]; };
+  stochprofML = derive { name="stochprofML"; version="1.2"; sha256="0gqfm2l2hq1dy3cvg9v2ksphydqdmaj8lppl5s5as2khnh6bd1l1"; depends=[MASS numDeriv]; };
+  stochvol = derive { name="stochvol"; version="0.9-0"; sha256="1ziad5jdq4ilfrd3fkh83sz32k21cq7g982qnkdam9aly1rnrijf"; depends=[coda Rcpp]; };
   stockPortfolio = derive { name="stockPortfolio"; version="1.2"; sha256="0k5ss6lf9yhcvc4hwqmcfpdn6qkbq5kaw0arldkl46391kac3bd1"; depends=[]; };
   stoichcalc = derive { name="stoichcalc"; version="1.1-3"; sha256="0z9fnapibfp070jxg27k74fdxpgszl07xiqfj448dkydpg8ydkrb"; depends=[]; };
   Storm = derive { name="Storm"; version="1.1"; sha256="118l03d6las9cvhh4d845r7z6mlqff6ixxdfrdf025jsiqagm395"; depends=[rjson]; };
   stosim = derive { name="stosim"; version="0.0.12"; sha256="0c4sj5iirm542hx782izfdmy2m3kl5q28l10xjj0ib4xn5y6yx3c"; depends=[tcltk2 Rcpp]; };
   STPGA = derive { name="STPGA"; version="1.0"; sha256="1kqxzjrxf194n006dr3h5kprb4l7qy8bgm2n6251p0sswpvr70j1"; depends=[]; };
-  stpp = derive { name="stpp"; version="1.0-4"; sha256="04xl2745xr5r7yirbdmxaxqvl4gp73wr6xl08w21mcccsnpc3d1s"; depends=[splancs KernSmooth spatstat]; };
+  stpp = derive { name="stpp"; version="1.0-4"; sha256="04xl2745xr5r7yirbdmxaxqvl4gp73wr6xl08w21mcccsnpc3d1s"; depends=[splancs KernSmooth]; };
   stppResid = derive { name="stppResid"; version="1.1"; sha256="0hgzsyy5y0sqd4d2agdr7p2kq0w51vs8f63dvj6j49h8cvgiws2x"; depends=[deldir splancs cubature]; };
   StrainRanking = derive { name="StrainRanking"; version="1.1"; sha256="0q6k90if74320mrs2ccq2izynylr8zakciwbc2c6ms0v57aalwic"; depends=[]; };
   strap = derive { name="strap"; version="1.3"; sha256="1f9whr9cg73q4lfqdygqd88f2lc08bb7qcalrr4dc00jjgy1r8rw"; depends=[ape geoscale]; };
···
   StratSel = derive { name="StratSel"; version="1.0"; sha256="1kr7bl2qrj2ra3szvw5z5y6ra6zz5q3v9vx81p8r5618zffa8q3b"; depends=[mnormt memisc Formula]; };
   straweib = derive { name="straweib"; version="1.0"; sha256="0bh2f4n4i7fiki52sa57v96757qw1gn1lcn7vgxmc5hk5rzp2mi8"; depends=[]; };
   stream = derive { name="stream"; version="1.0-3"; sha256="14l1fdqzbvy8vxq0rmrwm2afwd4h85khc0a22r6vk488355wn9ps"; depends=[hash proxy animation clue cluster clusterGeneration fpc MASS mlbench]; };
-  StreamingLm = derive { name="StreamingLm"; version="0.1"; sha256="079ks5gj6ydj2fqq8pwhkb24a0zbz2j400777fm6a39wjgbgdx1n"; depends=[biglm]; };
   StreamMetabolism = derive { name="StreamMetabolism"; version="1.0"; sha256="03pr7i1c3qddqwibfc2x08d2nh8fih02k7a1xhqs1awfs43x56is"; depends=[zoo chron maptools]; };
   streamMOA = derive { name="streamMOA"; version="0.1-1"; sha256="12x9i0cr56s54b2z3wfblrv6f36z8k2pgrr5gaqyshl8rgvyvrzz"; depends=[stream rJava]; };
   streamR = derive { name="streamR"; version="0.2.1"; sha256="1ml33mj7zqlzfyyam23xk5d25jkm3qr7rfj2kc5j5vgsih6kr0gl"; depends=[RCurl rjson]; };
   stremo = derive { name="stremo"; version="0.2"; sha256="13b9xnd8ykxrm8gnakh0ixbsb7yppqv3isga8dsz473wzy82y6h1"; depends=[lavaan numDeriv MASS]; };
   stressr = derive { name="stressr"; version="1.0.0"; sha256="00b93gfh1jd5r7i3dhsfqjidrczf693kyqlsa1krdndg8f0jkyj7"; depends=[xts XML lattice latticeExtra]; };
   StressStrength = derive { name="StressStrength"; version="1.0"; sha256="0m67rawgn6w49zh4mw951i3pk4ckp4bxz9yphw0klllazjxyd6qp"; depends=[]; };
-  stringdist = derive { name="stringdist"; version="0.8.0"; sha256="16bmf81dv8xbvy1b5c8rrj6vja00m00cb14v2zl9syxs923dq94i"; depends=[]; };
+  stringdist = derive { name="stringdist"; version="0.8.1"; sha256="0ry5v1cmxm7nsvvz0dm7fzrfgss7g7k9k89cp5jpyyxzksi9xrf1"; depends=[]; };
   stringi = derive { name="stringi"; version="0.2-5"; sha256="0yyqdapn0gqrwynv0sikq42b5vv166qq96w099rm3fispc037yb8"; depends=[]; };
   stringr = derive { name="stringr"; version="0.6.2"; sha256="0dv7dd0xsivlccnf9pr5kb7zirgqn9mc6lgw5hnmkbb0s1qrrz63"; depends=[]; };
   strucchange = derive { name="strucchange"; version="1.5-0"; sha256="17ikp36ahnsx1q3avqkz5r2n2yagzq7j6m515vdm8rxgv0538is3"; depends=[zoo sandwich]; };
-  structSSI = derive { name="structSSI"; version="1.0.5"; sha256="0i832k8jf317m47kzzfhgla4qm8bqmj3azjm4iqndkym2ry3jiy4"; depends=[igraph Matrix RColorBrewer classInt]; };
+  structSSI = derive { name="structSSI"; version="1.1"; sha256="0rmf3q65adrqh9nrc4apqm4ca7frpwqr6xh80b4mxiz0z4wfcv9q"; depends=[igraph rjson ggplot2 reshape2]; };
   strum = derive { name="strum"; version="0.4"; sha256="06y4bf2z55zl5k9snd7mgbrfx85irnbk316g9169m5mij4lca4g7"; depends=[pedigree MASS Rcpp]; };
-  strvalidator = derive { name="strvalidator"; version="1.3.0"; sha256="1sddiclnhdl935l27863617h8s2kgny68d80hnqw9a3ga0iri486"; depends=[gtable ggplot2 gWidgets plyr scales gridExtra]; };
+  strvalidator = derive { name="strvalidator"; version="1.3.1"; sha256="1d69qrs4wfx7wjbr5xy0wmf81lhih8asz9hwy861fxy7iak6gvlw"; depends=[ggplot2 gWidgets gridExtra gtable plyr scales gWidgetsRGtk2 RGtk2]; };
   stsm = derive { name="stsm"; version="1.4"; sha256="0j6kvsij6rsvkjc4q1m9vi9afvsib8x6zwjka1xwbp8g6fzamjq4"; depends=[KFKSDS stsm_class]; };
   stsm_class = derive { name="stsm.class"; version="1.3"; sha256="19jrja5ff31gh5k2zqhqsyd7w2ivr4s6bkliash6x8fmd22h5zs8"; depends=[]; };
-  stylo = derive { name="stylo"; version="0.5.6"; sha256="0ga6kv4i0zsapnbiqinz4wy34c0kracxrd2cgyqp0dkhshsiw2jf"; depends=[tcltk2 ape pamr e1071 class lattice tsne]; };
+  stylo = derive { name="stylo"; version="0.5.8-2"; sha256="1vslcn0gnzvsznashivpfsh45z1kjzpx55lq58s2ryaz8hdigy41"; depends=[tcltk2 ape pamr e1071 class lattice tsne]; };
   SubCultCon = derive { name="SubCultCon"; version="1.0"; sha256="08q6k4nsv3gl5qk87s87smdg047yc2a4i7kg0fp08i7q7h62jkvz"; depends=[]; };
   subgroup = derive { name="subgroup"; version="1.1"; sha256="1n3qw7vih1rngmp4fwjbs050ngby840frj28i8x7d7aa52ha2syf"; depends=[]; };
   SubLasso = derive { name="SubLasso"; version="1.0"; sha256="12m7ynlqhikjhavd12bhsd04s9cpv8aq5xgm875i10mb3ldpd1bd"; depends=[glmnet psych gplots]; };
   subplex = derive { name="subplex"; version="1.1-4"; sha256="0c6y5ibyxh0mpn77f7kwrmkpb3mah10hbqhwqmz4i1lfv58mb4zk"; depends=[]; };
-  subselect = derive { name="subselect"; version="0.12-3"; sha256="1m1vk8jgmw0cb9gmzvvpzdpjaqp56kwhalb2b2il20kc57czmymr"; depends=[]; };
+  subrank = derive { name="subrank"; version="0.8.5"; sha256="0vcizby33aig56qhy19dyfx0bp7ha3j859yapqk8yq73cszj7mk9"; depends=[]; };
+  subselect = derive { name="subselect"; version="0.12-4"; sha256="0h56d68clsr4lmvn2a291di62xvjdypbwlpk2x1xjlyss10yhamh"; depends=[]; };
   subsemble = derive { name="subsemble"; version="0.0.9"; sha256="0vzjmxpdwagqb9p2r4f2xyghmrprx3nk58bd6zfskdgj0ymfgz5z"; depends=[SuperLearner]; };
   subtype = derive { name="subtype"; version="1.0"; sha256="1094q46j0njkkqv09slliclp3jf8hkg4147hmisggy433xwd19xh"; depends=[penalized ROCR]; };
   sudoku = derive { name="sudoku"; version="2.6"; sha256="13j7m06m38s654wn75kbbrin5nqda4faiawlsharxgrljcibcbrk"; depends=[]; };
   SUE = derive { name="SUE"; version="1.0"; sha256="0akv724s84v2zixvwywj1ydfnfvcjnaabv6gm0601nsrh6ij1mi6"; depends=[]; };
-  sugaR = derive { name="sugaR"; version="0.0-5"; sha256="0lg0wm4fbf4f4vlsy2cnfwm18vnc3i6bd51pixpdb9m512pw761c"; depends=[]; };
   summarytools = derive { name="summarytools"; version="0.1"; sha256="1qrn47z21ijgpp8kj20wviin2zldj8fpf4d759b05v3k0y3q27zr"; depends=[Hmisc pander timeDate]; };
-  Sunder = derive { name="Sunder"; version="0.0.2"; sha256="0fnxj4fi99f1jvlbir0wkqvf48msnz1rspzg17jsd1kp2ha5kq35"; depends=[RandomFields]; };
+  Sunder = derive { name="Sunder"; version="0.0.3"; sha256="0iyipvlz66l84b71cjyjmyirl43jcj4sfzfqk07dzycfgvvwkz3h"; depends=[mnormt]; };
   SunterSampling = derive { name="SunterSampling"; version="1.0"; sha256="07s5sd6kf2jg276b5q1ns3h7849b1h0rx77kb3vs4j1svn8k9wxy"; depends=[]; };
   supclust = derive { name="supclust"; version="1.0-7"; sha256="0437pccagvqv6ikdsgzpif9yyiv6p24lhn5frk6yqby2asj09727"; depends=[rpart class]; };
   superbiclust = derive { name="superbiclust"; version="0.1"; sha256="0hzihmjjwk3axgy1y95ckq6m5gmb7ybjj7zscplgsnihi5256jnk"; depends=[biclust Matrix]; };
···
   support_BWS = derive { name="support.BWS"; version="0.1-2"; sha256="14p5b4b84x66lzn7qz1xy7sbb5i3wqwcsf6r6ap612nj83srjmqa"; depends=[]; };
   support_CEs = derive { name="support.CEs"; version="0.3-2"; sha256="0q8n4w3p682165lv20m30m8p9mhd3wzrzg8aqizf9zc2m5w9ffyd"; depends=[DoE_base MASS simex]; };
   surface = derive { name="surface"; version="0.4-1"; sha256="0z7fh09hjmxfmqzi588gjwqqlpj1a475aixrnvy911lkx3zfk146"; depends=[ape ouch MASS geiger]; };
-  Surrogate = derive { name="Surrogate"; version="0.1-2"; sha256="07imwp725qwnxj4437qc2420n624vchnlaisd20ck8ygyvkb2mn0"; depends=[MASS nlme msm lme4]; };
+  Surrogate = derive { name="Surrogate"; version="0.1-3"; sha256="1z07zck27qsp64zpz7qrxdnabkffnxqh3bixg5zrd37zgki9ig1w"; depends=[MASS nlme msm lme4]; };
   suRtex = derive { name="suRtex"; version="0.9"; sha256="0xcy3x1079v10bn3n3y6lxignb9n3h57w4hhrvzi5y14x05jjyda"; depends=[]; };
   surv2sampleComp = derive { name="surv2sampleComp"; version="1.0-4"; sha256="1ihz71vzrkd5ksy7421myrgkbww0z5k0ywcb2bfalxx2bd2cs2wf"; depends=[survival plotrix flexsurv survC1]; };
+  survAccuracyMeasures = derive { name="survAccuracyMeasures"; version="1.2"; sha256="1i41xkvqpxpq9spryh1syp57ymlzw71ygdjqn41rv8jjc9q52x9g"; depends=[survival Rcpp]; };
   survAUC = derive { name="survAUC"; version="1.0-5"; sha256="0bcj982ib1h0sjql09zbvx3h1m96jy9q37krmk6kfzw25ms6bzzr"; depends=[survival]; };
-  survBayes = derive { name="survBayes"; version="0.2.2"; sha256="08fbb2kyy7gcqlbzbliy4njkyk6jhr4nlfb4nbmh2kfdfcb6q62v"; depends=[survival coda]; };
   survC1 = derive { name="survC1"; version="1.0-2"; sha256="1bidjhq3k5ab7gqj1b2afngip7pp6c9c7q0m6ww7h7i2vg505l7v"; depends=[survival]; };
-  surveillance = derive { name="surveillance"; version="1.8-0"; sha256="043hdz4rfk5a50lzcb3q5sccn93r9r6ll79p1jxr0xhxlahgrp6i"; depends=[Rcpp sp xtable polyCub MASS Matrix spatstat]; };
+  surveillance = derive { name="surveillance"; version="1.8-1"; sha256="08a876xzzca8q0rvcl5058z2rkj9qn24iqbhxwq481f27112k4v7"; depends=[Rcpp sp xtable polyCub MASS Matrix]; };
   survexp_fr = derive { name="survexp.fr"; version="1.0"; sha256="12rjpnih0xld4dg5gl7gwxdxmrdmyzsymm7j05v98ynldd1jkjl8"; depends=[survival]; };
-  survey = derive { name="survey"; version="3.29-5"; sha256="0qzg6h3m27d9v6iyh88pk7iq2glfnn8364jjl7z5d5cbw3ga3j81"; depends=[]; };
+  survey = derive { name="survey"; version="3.30-3"; sha256="0vcyph1vpnl4xaqd85ffh1gm0dqhvgr3343q0mlycmyq485x0idy"; depends=[]; };
   surveydata = derive { name="surveydata"; version="0.1-14"; sha256="1zcp3wb7yhsa59cl4bdw7p08vpviypvfa9hggwc60w7ashpky73i"; depends=[stringr plyr]; };
   Survgini = derive { name="Survgini"; version="1.0"; sha256="1gxkdv2j1njbgnwb52vyhz7p2lrcg3hp6sry3kyhp4wkvf6gnhxi"; depends=[survival]; };
   survIDINRI = derive { name="survIDINRI"; version="1.1-1"; sha256="03lsypx189zm28gv764gdq24a18jj3kpdk91ssa501qxj5jv7v29"; depends=[survival survC1]; };
   survival = derive { name="survival"; version="2.37-7"; sha256="1ihs42gjbw06aj5hz128964lshpi934cyc8npv9c8ann4mc2r3b5"; depends=[]; };
-  survivalMPL = derive { name="survivalMPL"; version="0.1.0"; sha256="1nq316w88j7dg48683ka326b2y3f9jl73mig47n3y31z2x9hc8h0"; depends=[survival]; };
+  survivalMPL = derive { name="survivalMPL"; version="0.1.1"; sha256="0c4hr2q50snd5qm2drg4qzfkcz4klxr4jba6xpc8n2i8wn573cvc"; depends=[survival]; };
   survivalROC = derive { name="survivalROC"; version="1.0.3"; sha256="0wnd65ff5w679hxa1zrpfrx9qg47q21pjxppsga6m3h4iq1yfj8l"; depends=[]; };
-  survJamda = derive { name="survJamda"; version="1.1.2"; sha256="172mryz19n4nb9w20xh7yhn4pqaw9m98na2x235lps5rwcjk6x7b"; depends=[survival survivalROC ecodist survJamda_data]; };
-  survJamda_data = derive { name="survJamda.data"; version="1.0.1"; sha256="1b8vy59hawgvpjds96q5wscggv8hffkbjw7zwfwf5g3firhb4gnq"; depends=[]; };
   survMisc = derive { name="survMisc"; version="0.4.2"; sha256="1mv503lrgjfbggasgsls2pqlxz3kj4hrw9qslgzxh3dizfqkb02c"; depends=[survival ggplot2 data_table rpart gridExtra combinat Hmisc zoo km_ci KMsurv gam]; };
   survPresmooth = derive { name="survPresmooth"; version="1.1-8"; sha256="1qva7yx4vv99mgh3wqxdnbasa1gy0ixxyxpqrfbn6827whjzf91m"; depends=[]; };
   survrec = derive { name="survrec"; version="1.2-2"; sha256="0b77ncr1wg2xqqg1bv1bvb48kmd9h3ja2dysiggvprzjrj7hdlmx"; depends=[boot]; };
···
   swamp = derive { name="swamp"; version="1.2.3"; sha256="1xpnq5yrmmsx3d48x411p7nx6zmwmfc9hz6m3v9avvpjkbc3glkg"; depends=[amap gplots MASS]; };
   SWATmodel = derive { name="SWATmodel"; version="0.5.9"; sha256="1i48g9nbjfn30ppwyzyz3k181nscv4wx773l8mzfdwhx0nlv4kyj"; depends=[EcoHydRology]; };
   SweaveListingUtils = derive { name="SweaveListingUtils"; version="0.6.1"; sha256="04xl7sw14x3ia5nsmkj1fhxvycl9wpim3frx83dd6kh8i0hpip54"; depends=[startupmsg]; };
-  sweSCB = derive { name="sweSCB"; version="0.3.5"; sha256="1g6c73kqrnssycf4k239dpgkv8bvllbrxjwxga6fqdzb7jsnwh4y"; depends=[data_table stringr RJSONIO httr]; };
+  sweidnumbr = derive { name="sweidnumbr"; version="0.2"; sha256="0zsijh9jf0pnil5n69ix408j3plbrnj0235whh9rch486ibyk779"; depends=[lubridate]; };
   swfscMisc = derive { name="swfscMisc"; version="1.0.1"; sha256="0ya0ng6973mix9i0k817mgvfqwshpfqjlnn5xbs6vz2cw2xm8g6g"; depends=[mapdata maps]; };
-  swirl = derive { name="swirl"; version="2.2.15"; sha256="1r2hpkhcs040z3dmhc90cpznjjb1r4nnah27yz4vp58dx0aidcjl"; depends=[stringr testthat httr yaml RCurl digest]; };
+  swirl = derive { name="swirl"; version="2.2.16"; sha256="0wfm44nicrswszly7bwkb8z046x92p687ycglbjinvr73p4bmv0q"; depends=[stringr testthat httr yaml RCurl digest]; };
   SwissAir = derive { name="SwissAir"; version="1.1.4"; sha256="1avc32q7nbwjkcbml7z05car6khv1ghcz3miw0krm8i53w032c6f"; depends=[]; };
   switchnpreg = derive { name="switchnpreg"; version="0.8-0"; sha256="1vaanz01vd62ds2g2xv4kjlnvp13h59n8yqikwx07293ixd4qhpw"; depends=[MASS fda expm HiddenMarkov]; };
   sybil = derive { name="sybil"; version="1.2.6"; sha256="1d7q0dvpqxay86dy4zbllv78dsh0amr8n7wl0vkrb8jbakq4afip"; depends=[Matrix lattice]; };
···
   symbolicDA = derive { name="symbolicDA"; version="0.4-1"; sha256="14lcxgbsizw0l1xcjrmz3jvfsbwlirkd0shp293hg3qi7gbzcms8"; depends=[clusterSim XML rgl shapes e1071 ade4]; };
   symbols = derive { name="symbols"; version="1.1"; sha256="1234rx3divhg60p0h0zn11viqn51fm6b8876m6rip2i6z8vrg319"; depends=[shape]; };
   symmoments = derive { name="symmoments"; version="1.2"; sha256="074k0285c0yri39zags420kjls6kjlvlhymg3r7y24h42zdy82d4"; depends=[mvtnorm cubature combinat multipol]; };
-  synbreed = derive { name="synbreed"; version="0.9-7"; sha256="0v81q18dqr7zrh7830xfk30jq6kzgn0kcrp9zq6swk5laalkkqg4"; depends=[doBy BLR regress abind lattice igraph MASS LDheatmap qtl synbreedData]; };
+  synbreed = derive { name="synbreed"; version="0.10-3"; sha256="0i0d376g96l7b20hfynf673wxnxhg9wj5b28kv7kihs4w0rr3j92"; depends=[doBy BLR regress abind lattice igraph MASS LDheatmap qtl synbreedData]; };
   synbreedData = derive { name="synbreedData"; version="1.4"; sha256="0pfpvg4wvxfwpvxq8f93z1amfss98as66kwpj5mnvvlr33ffmka9"; depends=[]; };
   synchronicity = derive { name="synchronicity"; version="1.1.4"; sha256="0hcxwgf1irswwabgl0b6vb9q09nhxc1ljsm195lc8ql49sfj9mfz"; depends=[bigmemory_sri]; };
   synchrony = derive { name="synchrony"; version="0.2.3"; sha256="0fi9a3j8dfslf1nqx8d53fi635y3aq8isxw0dbjbpgk7rc71nzby"; depends=[]; };
···
   SyNet = derive { name="SyNet"; version="2.0"; sha256="0mb9dscddkvmkf7l3bbcy4dlfmrvvy588vxdqy5dr783bpa5dkiw"; depends=[tkrplot]; };
   synlik = derive { name="synlik"; version="0.1.1"; sha256="0g4n78amydihsq4jg2i9barjm9g40zczasb31fj10yn6wir1dhv7"; depends=[Rcpp Matrix]; };
   Synth = derive { name="Synth"; version="1.1-5"; sha256="1cfvh91nz6skjk8jv04fhwv3ga9kcsfgq3mdy8lx75jkx16zr0pk"; depends=[kernlab optimx]; };
+  synthpop = derive { name="synthpop"; version="1.0-0"; sha256="1ifdzfql2a9gn021l5f93qrx30db48hpq43c5zanmb2zdqb8zc16"; depends=[lattice MASS nnet rpart party]; };
   sysfonts = derive { name="sysfonts"; version="0.2"; sha256="15wzb7c89645xxbhn29bh0djys73iklq05228qnhd5gx5sr43dd0"; depends=[]; };
   systemfit = derive { name="systemfit"; version="1.1-14"; sha256="0f33v96awyhxw3i6zr6whdz91hbfi7vwnfs0bz7xsrjcinqhm6h5"; depends=[Matrix car lmtest sandwich]; };
-  tab = derive { name="tab"; version="2.1.2"; sha256="0g3wjl83k61xshbp813zvkapqiwjf9lr7i1bpxrjify2lqwis8k7"; depends=[survey survival gee]; };
+  tab = derive { name="tab"; version="2.1.3"; sha256="0ypb11gvasx7mdkpysfjvxb61660sdaggp6l43iyp2grfrilkm7y"; depends=[survey survival gee]; };
   Table1Heatmap = derive { name="Table1Heatmap"; version="1.1"; sha256="1nrabjivfsdhaqmlq365pskkrp99jqsxn8vy03mdnqn5h5zv7wvx"; depends=[colorRamps]; };
   table1xls = derive { name="table1xls"; version="0.3.1"; sha256="0zd93wrdj4q0ph375qlgdhpqm3n8s941vks5h07ks9gc8id1bnx5"; depends=[XLConnect]; };
   TableMonster = derive { name="TableMonster"; version="1.1"; sha256="1xflw719isy5hxvm0z67bip01cpafylnj76zssb3c174j912f7y3"; depends=[xtable]; };
   tableone = derive { name="tableone"; version="0.6.2"; sha256="0jmii05kqd01bllc4wi9r38qa0dpxqlcpk572d3m7c009izsz8zl"; depends=[e1071 gmodels]; };
   tableplot = derive { name="tableplot"; version="0.3-5"; sha256="1jkkl2jw7lwm5zkx2yaiwnq1s3li81vidjkyl393g1aqm9jf129l"; depends=[]; };
   tables = derive { name="tables"; version="0.7.79"; sha256="05f23y5ff961ksx4fnmwpf6zvc9573if8s2cmz9bwki66h2g9xb7"; depends=[Hmisc]; };
-  TableToLongForm = derive { name="TableToLongForm"; version="1.3.0"; sha256="1dxis6gx0misvl18jzsaqxjajclc98xppgxil5xsz1lcq0fkn383"; depends=[]; };
+  TableToLongForm = derive { name="TableToLongForm"; version="1.3.1"; sha256="135q0bgsm2yndrg3vpwmihbqlyf3qkm97i0jvcw6bf06p6b2fk41"; depends=[]; };
   tabplot = derive { name="tabplot"; version="1.1"; sha256="0vyc6b6h540sqwhrza2ijg7ghw2x8rla827b8qy2sh0ckm0ybjrx"; depends=[ffbase]; };
   tabplotd3 = derive { name="tabplotd3"; version="0.3.3"; sha256="0mbj45vb17wlnndpkhvq7xaawsb814x7zxa4rqbfgidvbm1p3abv"; depends=[tabplot httpuv Rook brew RJSONIO]; };
   tabuSearch = derive { name="tabuSearch"; version="1.1"; sha256="0bri03jksm314xy537dldbdvgyq6sywfmpmj2g2acdcli31kkpq0"; depends=[]; };
-  TAM = derive { name="TAM"; version="1.0-3"; sha256="122wn95hbi7w41k1dbmwbr1q4rsrcskcy39ff64dclak70ackblm"; depends=[MASS mvtnorm tensor sfsmisc GPArotation psych Rcpp]; };
+  TAM = derive { name="TAM"; version="1.1"; sha256="1y678sn4awy7pzfwvhj1b9fpgd377iwbm2hkq7lnsff0fx3z0cia"; depends=[MASS mvtnorm CDM tensor sfsmisc GPArotation psych Rcpp mirt lattice]; };
+  Tampo = derive { name="Tampo"; version="1.0"; sha256="10w9is8wskl5xvjfqmjhjpyppazrxw7fq1s58hi62rvcc4mpgz37"; depends=[mvpart]; };
   TANOVA = derive { name="TANOVA"; version="1.0.0"; sha256="0c2mrahchwagisrkjl5l1s0mv0ny80kngq8dz0fjj9lwxwqwvwa5"; depends=[MASS]; };
   TaoTeProgramming = derive { name="TaoTeProgramming"; version="1.0"; sha256="1b36s5mpm5vbhzcwmvm8g5pl7vpn6rsl5cnglfy8kgm1q9nnr7ff"; depends=[]; };
   TapeR = derive { name="TapeR"; version="0.3.2"; sha256="070zl7hqv5zprhs464gy1kmz0am58l0vig8xvdq6pbz94nrhvpj0"; depends=[nlme pracma]; };
···
   TauP_R = derive { name="TauP.R"; version="1.1"; sha256="10sjvcv70fjrsl5nnk9gm4sy7nhwm6aaq57gr37cb10v079ykmk1"; depends=[]; };
   tawny = derive { name="tawny"; version="2.1.2"; sha256="0ihg3qlng8swak1dfpbnlx5xc45d1i9rgqawmqa97v5m91smfa71"; depends=[lambda_r lambda_tools futile_logger futile_matrix tawny_types zoo xts PerformanceAnalytics quantmod]; };
   tawny_types = derive { name="tawny.types"; version="1.1.3"; sha256="1v0k6nn45rdczjn5ymsp2fqq0ijnlniyf3bc08ibd8yd1jcdyjnj"; depends=[lambda_r lambda_tools futile_logger futile_options zoo xts quantmod]; };
-  taxize = derive { name="taxize"; version="0.3.0"; sha256="1qixhiz92s0ys5sk61gjhq21855p739zih0sdxmhhah6x1m46agm"; depends=[XML RCurl stringr plyr httr RJSONIO foreach ape Taxonstand reshape2 data_table vegan assertthat]; };
-  Taxonstand = derive { name="Taxonstand"; version="1.3"; sha256="0qfvsl2ywkagqn18iyjs3208szs0wm3xi39mssaw2l6rwyrx3kvd"; depends=[]; };
-  tbart = derive { name="tbart"; version="0.9"; sha256="1iim4qshbazrb58ydhaxzp9xpy9w1ji2h4nh74scnmsxjdj3gfkg"; depends=[Rcpp sp]; };
+  taxize = derive { name="taxize"; version="0.4.0"; sha256="11wq690nkdgpssmm5sw85j2wb88bpjr5qiy3y2rg3xppf68xb5ib"; depends=[XML RCurl stringr plyr httr jsonlite foreach ape Taxonstand reshape2 data_table vegan assertthat bold]; };
+  Taxonstand = derive { name="Taxonstand"; version="1.5"; sha256="04n06k9l2nfygsg7qi8yq7ynj0zjh888bj5hw9pc1cwgvfn1r9iv"; depends=[]; };
+  tbart = derive { name="tbart"; version="0.9.1"; sha256="1xpv9vfak57836c50n7rg9hrxd6iz6378jpddsd4zm7pvnzzhhim"; depends=[Rcpp sp]; };
   tbdiag = derive { name="tbdiag"; version="0.1"; sha256="1wr2whgdk84426hb2pf8iiyradh9c61gyazvcrnbkgx2injkz65q"; depends=[]; };
   TBEST = derive { name="TBEST"; version="3.0"; sha256="1c4zbp4jsl8qsbx7bnqm7z7njm60qcc1yhxdbg75mw326brfvw1z"; depends=[signal fdrtool]; };
   TBSSurvival = derive { name="TBSSurvival"; version="1.1"; sha256="0hh0zpvwbkix8g9slf6bh4qzwmig5qif80q1ph6m5i496ywjcc80"; depends=[mcmc coda survival normalp R_utils BMS]; };
   TcGSA = derive { name="TcGSA"; version="0.9.8"; sha256="19gp3pj4p2svrfyviccvv13q82qj7584nck8zbba90hzv9g4xy86"; depends=[lme4 ggplot2 GSA reshape2 gtools gplots cluster stringr]; };
   tcltk2 = derive { name="tcltk2"; version="1.2-10"; sha256="0m648n028xc6gi3ypih0nyswczh787pwfq7ky2hsxabp958faflb"; depends=[]; };
+  tclust = derive { name="tclust"; version="1.2-3"; sha256="0a1b7yp4l9wf6ic5czizyl2cnxrc1virj0icr8i6m1vv23jd8jfp"; depends=[mvtnorm sn mclust cluster]; };
+  TDA = derive { name="TDA"; version="1.2"; sha256="02nfvrg428l6pq2vrsx5dj45k9gnsfvdbhvcwj86ab66z5cdjffk"; depends=[FNN igraph scales]; };
+  TDboost = derive { name="TDboost"; version="1.0"; sha256="1qiwz35i89lv95v3x5s28q0mkrvcfs1cfn4l0a5spvnyhy4kcacc"; depends=[lattice]; };
   TDD = derive { name="TDD"; version="0.4"; sha256="193y8brybkjsajrbnlx1sdnw1wyyn9rhlm5wvp4aamqhvi8z13vn"; depends=[signal RSEIS pracma]; };
   tdm = derive { name="tdm"; version="3.0.2"; sha256="06k2dp5gf2k9q23mpswn2yh0525xaz0zznx6r7gn0gim2l7msbqj"; depends=[rjags coda png deSolve]; };
-  TDMR = derive { name="TDMR"; version="1.1"; sha256="15s1569435h7mlpvwg9k2584nk352sc4l6nqq2mk2hhj4brpa30l"; depends=[SPOT e1071]; };
+  TDMR = derive { name="TDMR"; version="1.2"; sha256="0w056qxh7c56m3p6jlrp8fv2j2r1njxzgwzk3l1lhyxr94gff263"; depends=[testit SPOT]; };
   tdthap = derive { name="tdthap"; version="1.1-7"; sha256="0lqcw4bzjd995pwn2yrmzay82gnkxnmxxsqplpbn5gg8p6sf5qqk"; depends=[]; };
   TeachingDemos = derive { name="TeachingDemos"; version="2.9"; sha256="160xch4812darv77qk2xjblm6nfnna5x2rxy335bwdsdjzcx4x9m"; depends=[]; };
   TeachingSampling = derive { name="TeachingSampling"; version="3.2.1"; sha256="1diw8qz6yi3g7d1ysklrvxwbzda9ybi039yr6agzw0w0b2b59jj4"; depends=[]; };
   TeachNet = derive { name="TeachNet"; version="0.7"; sha256="1p39bsf846r7zwz4lrrv2bpyx9yrkqzrnacajwrz3jjqj6qpp6cn"; depends=[]; };
-  TED = derive { name="TED"; version="1.0"; sha256="0fzjfm9fjyn6h89vwgc912q8hx7ly4mqpacbz05iykhz3xdzfb9p"; depends=[foreach zoo fields animation geoR RcppArmadillo]; };
-  teigen = derive { name="teigen"; version="2.0.1"; sha256="1lsx7cb6frfi0i2pg1w228kydfymrbxqd535hnrhhq9j1shhykk4"; depends=[]; };
+  TED = derive { name="TED"; version="1.1.1"; sha256="0nb2arx7c1m8ymnkmj3jwbcw23vhkr1f3vlym2hqs0pq0lnsl4g0"; depends=[foreach zoo fields animation geoR RcppArmadillo]; };
+  TEEReg = derive { name="TEEReg"; version="1.0"; sha256="1xpr4m8yamifjx7njb7dyqv51rsbjym9c5avflf69r9sazf3n503"; depends=[]; };
+  teigen = derive { name="teigen"; version="2.0.7"; sha256="0pyxpmmd4s6azq8lzn0lrg7jkr7g638xkhljx1w5bval6cq2bcwk"; depends=[]; };
   tempdisagg = derive { name="tempdisagg"; version="0.23"; sha256="1ym0cbvm8f1wvnkpdm34d5yzgbn3hig1kc3zv8b24pnx11ywv751"; depends=[]; };
   tensor = derive { name="tensor"; version="1.5"; sha256="19mfsgr6vz4lgwidm80i4yw0y1dr3n8i6qz7g4n2xa0k74zc5pp1"; depends=[]; };
   tensorA = derive { name="tensorA"; version="0.36"; sha256="1xpczn94a6vfkfibfvr71a7wccksg16pc22h0inpafna4qpygcwp"; depends=[]; };
···
   testit = derive { name="testit"; version="0.3"; sha256="142q0zwlzx3w69j0fsd06s3pihr76kw9yg21596aalazh7c2yfgi"; depends=[]; };
   TestScorer = derive { name="TestScorer"; version="1.6"; sha256="11125i0dwh961q5xbg57lli5bzzls3y482iw5f0qwalwkppk7sv0"; depends=[]; };
   TestSurvRec = derive { name="TestSurvRec"; version="1.2.1"; sha256="05f5gc8hvz09hx015jzis6ikki9c1brdq7l7a9bxm9bqbcc9f2f9"; depends=[survrec boot]; };
-  testthat = derive { name="testthat"; version="0.8.1"; sha256="1nja6yfcqyxi6nfs8mcwasslfw8mzlacjwj3kr65zmg58pm82ga4"; depends=[digest]; };
+  testthat = derive { name="testthat"; version="0.9.1"; sha256="0hbkyfx54fz4lwyz3azfxb6xkdcmm6kjdv6ma47gv947m90ysnfk"; depends=[digest]; };
+  testthatsomemore = derive { name="testthatsomemore"; version="0.1"; sha256="0j9sszm4l0mn7nqz47li6fq5ycb3yawc2yrad9ngb75cvp47ikkk"; depends=[testthat]; };
   texmex = derive { name="texmex"; version="2.1"; sha256="17x4xw2h4g9a10zk4mvi3jz3gf4rf81b29hg2g3gq6a6nrxsj8sy"; depends=[mvtnorm]; };
   TExPosition = derive { name="TExPosition"; version="2.6.10"; sha256="12rgijlclaipwjjiyng7nwilzixdy6lsvncigcg0vjydhgk97jn1"; depends=[prettyGraphs ExPosition]; };
-  texreg = derive { name="texreg"; version="1.33"; sha256="14x8q35w0w6p2zkqycqkpkan1637r9z6dl68d1dn4n5im7f2n4kw"; depends=[]; };
+  texreg = derive { name="texreg"; version="1.34"; sha256="03w8fk5lkpgag22a63jnhf0cn3l5ryjh4pkfhxgqzrijvrr1v2cb"; depends=[]; };
   textcat = derive { name="textcat"; version="1.0-2"; sha256="0m8jbw8k8h6m9q9x25gvx0glzwhhpy73pjv4zivivna5zxapgi23"; depends=[tau slam]; };
   textir = derive { name="textir"; version="2.0-2"; sha256="19n14nqx7gcp5ypfqwmk80lxxwqc0dklm09z3f9czg68j6qv181i"; depends=[distrom gamlr Matrix]; };
   textometry = derive { name="textometry"; version="0.1.3"; sha256="1a0dp1flx3yh7wqn0cmb5pq83qqnz94ynkqkmj4kw9ha5j8kcnwx"; depends=[]; };
-  TFDEA = derive { name="TFDEA"; version="0.9.4"; sha256="0376mzlfzf2ff6pnfsh4lf6gx9c1xdnl59pwm31zc73li4npy61h"; depends=[lpSolveAPI]; };
+  TFDEA = derive { name="TFDEA"; version="0.9.5"; sha256="12rr9inzr21vkfcmknxa8zd229vws3nyc4dfz44zsfxzzwi8sqk3"; depends=[lpSolveAPI]; };
   tfer = derive { name="tfer"; version="1.1"; sha256="19d31hkxs6dc4hvj5495a3kmydm29mhp9b2wp65mmig5c82cl9ck"; depends=[]; };
   TFMPvalue = derive { name="TFMPvalue"; version="0.0.5"; sha256="13bfcwfiyl61cv2ma23fcmv2cvbsyzdbg2pl6l6zg39l6scxf9na"; depends=[Rcpp]; };
   tfplot = derive { name="tfplot"; version="2014.2-2"; sha256="1jrkzccvqmwghp6nhxay0m1qx8r5wa96zb9r8v6qihryi9m3amhs"; depends=[tframe]; };
···
   tikzDevice = derive { name="tikzDevice"; version="0.7.0"; sha256="12r6qk5qp4yvi3vqvdxp02799y6fhmg21qv6abp1s620n8hgva6d"; depends=[filehash]; };
   tileHMM = derive { name="tileHMM"; version="1.0-6"; sha256="18vqj7fdh4knnjk9s7yk2bgn3qwqz92fmm5fdny21gi0wl4qgdsd"; depends=[]; };
   TilePlot = derive { name="TilePlot"; version="1.3.1"; sha256="0yfzjyzc743rv5piw9mb7y0rr558hkxszgz49lya2w3i1mqvxbzy"; depends=[]; };
-  tilting = derive { name="tilting"; version="1.0"; sha256="0s0lac39wnczjy6kb2a1an55fyndh61ya5cx4ic3799cgqvn8ba0"; depends=[mvtnorm]; };
-  timeDate = derive { name="timeDate"; version="3010.98"; sha256="12f4bdb9lv724p4p1490iznhnwznnn69c5b6wbljdvscl1yvys9a"; depends=[]; };
+  timeDate = derive { name="timeDate"; version="3011.99"; sha256="1fav8pi305vpbr7gkvpj5y9pgmck8359ba6gviki6h5xxs8zxi0s"; depends=[]; };
   timeit = derive { name="timeit"; version="0.2.1"; sha256="0fsa67jyk4yizyd079265jg6fvjsifkb60y3fkkxsqm7ffqi6568"; depends=[microbenchmark]; };
   timeline = derive { name="timeline"; version="0.9"; sha256="0zkanz3ac6cgsfl80sydgwnjrj9rm7pcfph7wzl3xkh4k0inyjq3"; depends=[ggplot2]; };
   TimeMachine = derive { name="TimeMachine"; version="1.2"; sha256="1dz0j777wmd8mpkm2ryiahpcw6w88w429zjcw6m67pi20r1992cb"; depends=[]; };
-  timeordered = derive { name="timeordered"; version="0.9.6"; sha256="0h6y3asq1y788571c423bqkgdcx6k5i9jp6hp59x99g9l77y71sn"; depends=[igraph plyr]; };
+  timeordered = derive { name="timeordered"; version="0.9.7"; sha256="0mb2sa74var1k65a90vkqhk4b4hykb8ngs7cz9j7cgn2x91x4qzq"; depends=[igraph plyr]; };
   TimeProjection = derive { name="TimeProjection"; version="0.2.0"; sha256="04yr4cg2khkw9n3y3qk0ni1327k4pxm09zz2xg8mpjdvgi4p9yi3"; depends=[lubridate timeDate Matrix]; };
   timereg = derive { name="timereg"; version="1.8.5"; sha256="1ppmhx86cf276fl1nwmlpbjhh6ddvrcw2gc53ncqcyff0jg6r4c1"; depends=[survival prodlim]; };
   timeROC = derive { name="timeROC"; version="0.2"; sha256="1ikd2wr5cja784hihqdyk7mwky18czz58sl0xrvmzhc67153a4jz"; depends=[pec mvtnorm timereg]; };
   timesboot = derive { name="timesboot"; version="1.0"; sha256="1ixmcigi1bf42np93md8d3w464papg9hp85v0c3hg3vl4nsm2bji"; depends=[boot]; };
-  timeSeries = derive { name="timeSeries"; version="3010.97"; sha256="0iv1jkh1h2qamsi22m7l3pdx0mgz96lafwjdxc99i558l2gdp2s3"; depends=[timeDate]; };
-  timetools = derive { name="timetools"; version="1.6.0"; sha256="1ynapbzbnxyyqs1lkb482jp3yfjmnbqqv80ksc6vasi6gm0fmx7h"; depends=[]; };
+  timeSeries = derive { name="timeSeries"; version="3011.98"; sha256="1smcm4k1a6br696p39s9w9ivzip33mspsixf6c72i01zgbrj6qnc"; depends=[timeDate]; };
+  timetools = derive { name="timetools"; version="1.6.1"; sha256="13hl9xp010dcwlcyhi62qw66cvd7k6w86ba3m543c9y4x79nw86b"; depends=[]; };
   TimeWarp = derive { name="TimeWarp"; version="1.0-7"; sha256="1qjr3kfdd1ym0fi4hgjqm32gigchbchxy4xyxmsyl8y7jh2jk9qj"; depends=[]; };
   TIMP = derive { name="TIMP"; version="1.11.0"; sha256="0l8n3xg5ds1lbndd993nijny26s9p36n3j128527y53fs4915lxn"; depends=[fields vcd gplots colorspace gclus nnls deSolve minpack_lm MASS]; };
   timsac = derive { name="timsac"; version="1.3.3"; sha256="0jg9mjzzfl94z4dqb2kz0aiccpclnbyf9p08x3a3cw1y6wqmzrmy"; depends=[]; };
   Tinflex = derive { name="Tinflex"; version="1.0"; sha256="0zvh2nfx4kqf90mmrpdm2fzlzn7s7gs09i8zin604hqxjir6p3ny"; depends=[]; };
   TInPosition = derive { name="TInPosition"; version="0.13.6"; sha256="1cxxrfpbiyknaivv6gyp79lz0rxwhrndcd054smksxq8zcfz0v7c"; depends=[prettyGraphs TExPosition ExPosition InPosition]; };
   tipom = derive { name="tipom"; version="1.0.2-1"; sha256="1gdfv0g5dw742j6ycmi0baqh6xcchp3yf2n1g8vn7jmqgz5mlhdr"; depends=[]; };
-  tis = derive { name="tis"; version="1.23"; sha256="0k8g9r0ngiw5dnmg0vddcmfw2w7g69lamrpczabrd2jmvvy67npn"; depends=[]; };
+  tis = derive { name="tis"; version="1.27"; sha256="1kgzc032qa005hzcimhbbhcs5kcvm88pfb48ac84k205f6xhdsir"; depends=[]; };
   titan = derive { name="titan"; version="1.0-16"; sha256="0x30a877vj99z3fh3cw9762j5ci56964j2466xfbwcywhn9njz5r"; depends=[MASS boot lattice]; };
   tkrgl = derive { name="tkrgl"; version="0.7"; sha256="1kpq5p6izqrn1zr53firis3rmifq9lf6326lf3z7l1p82nf2yps5"; depends=[rgl]; };
   tkrplot = derive { name="tkrplot"; version="0.0-23"; sha256="1cnyszn3rmr1kwvi5a178dr3074skdijfixf5ln8av5wwcy35947"; depends=[]; };
   tlemix = derive { name="tlemix"; version="0.1.3"; sha256="0c4mvdxlhbmyxj070xyipx4c27hwxlb3c5ps65ipm6gi8v8r6spj"; depends=[]; };
+  tlm = derive { name="tlm"; version="0.1.2"; sha256="1y2kz5xnq3x0c7jrrl4rw8azk2qhm62i3qsglvrdffiy898qa40j"; depends=[boot]; };
   tlmec = derive { name="tlmec"; version="0.0-2"; sha256="1gak8vxmfjf05bhaj6lych7bm8hgav1x3h14k2ra7236v82rqbw7"; depends=[mvtnorm]; };
   tlnise = derive { name="tlnise"; version="2.0"; sha256="1vh998vqj359249n9zmw04rsivb7nlbdfgzf20pgh2sndm3rh8qz"; depends=[]; };
   tm = derive { name="tm"; version="0.6"; sha256="004hswgswz3gdrpa6j61hl4rls843bxnsp5qac5kyxvfmwalsgr8"; depends=[NLP slam]; };
···
   tmvtnorm = derive { name="tmvtnorm"; version="1.4-9"; sha256="1dacdhqv6bb29a81bmxp8hxy4hragpg8mb5kql4cp59q08zmizyi"; depends=[mvtnorm Matrix gmm]; };
   tnet = derive { name="tnet"; version="3.0.11"; sha256="00hifb145w0a9f5qi3gx16lm1qg621jp523vswb8h86jqmxcczbc"; depends=[igraph survival]; };
   toaster = derive { name="toaster"; version="0.2.5"; sha256="0yybv6lq22mzawyvywh1dpg5p5mx5qqqssdhgd3ff78cqp7j298r"; depends=[RODBC plyr reshape2 ggplot2 scales RColorBrewer wordcloud ggmap]; };
-  tolerance = derive { name="tolerance"; version="0.5.3"; sha256="058gl3vsqq4ylxrafj6fd70xsw4jbxjlxl30h8pd2dyv1h70b5zf"; depends=[rgl]; };
+  tolerance = derive { name="tolerance"; version="1.0.0"; sha256="1anim3rq60fscylnz066fddihrxzy0j0d09ni262fqhbc2fla0xy"; depends=[rgl]; };
   topicmodels = derive { name="topicmodels"; version="0.2-1"; sha256="1if1pdx4jnfx3xi37xs411qv3h449vkwxzzqd7krxaxbj3gqq7n9"; depends=[modeltools slam tm]; };
   TopKLists = derive { name="TopKLists"; version="1.0.2"; sha256="0hsfa465rw7mjwgp9nk2aa9gqrwc61r867n4kfix6fbngqr11m5k"; depends=[Hmisc gplots]; };
   topmodel = derive { name="topmodel"; version="0.7.2-2"; sha256="1nqa8fnpxcn373v6qcd9ma8qzcqwl2md347yql3c8bpqlm9ggz16"; depends=[]; };
···
   tpe = derive { name="tpe"; version="1.0.1"; sha256="0zsa8vb4qmln3sb4lplv43lh50yys9vfd3rxfp6qxqqjxivd0xsh"; depends=[]; };
   TPmsm = derive { name="TPmsm"; version="1.1.1"; sha256="0fd4l1rzclq32l97g7rdvhdvfdylgwaf079y24arfvkyphs2xga4"; depends=[KernSmooth]; };
   tpr = derive { name="tpr"; version="0.3-1"; sha256="0nxl0m39zaii6rwm35hxcdk6iy2f729jjmhc2cpr8h0mgvgqf19d"; depends=[lgtdl]; };
+  TR8 = derive { name="TR8"; version="0.9.11"; sha256="164fd9g4vn4p51m5ygg65lkjapb9a42wkfcp4ngdqh542x313y2n"; depends=[RCurl XML taxize plyr rappdirs gWidgets gWidgetstcltk]; };
   track = derive { name="track"; version="1.0-15"; sha256="05v6p2mfms59p3cs4vwpzvi9gaadrin50fc39l5kjqwqa9vhmkz7"; depends=[]; };
   trackObjs = derive { name="trackObjs"; version="1.0-18"; sha256="0wwm9yx5wnmgvyd7zczkv8mdzixazb3kps112w19rdbnkiq1db3d"; depends=[]; };
   TrackReconstruction = derive { name="TrackReconstruction"; version="1.1"; sha256="1f2l3nshb6qrhyczw5rxqqzmsjxf0rvv3y78j8d9lv1nnd9kxzq5"; depends=[fields RColorBrewer]; };
   tractor_base = derive { name="tractor.base"; version="2.5.0"; sha256="17s4iyp67w7m8gslm87p3ic5r9iq7x1ifpxqrmnin3y5a3d04f5v"; depends=[reportr]; };
-  traitr = derive { name="traitr"; version="0.13"; sha256="0xn2w83w9mh2aal375snzv9r7yv7adly3axf8kchlcxs2kgrrn8f"; depends=[digest proto gWidgets]; };
+  traitr = derive { name="traitr"; version="0.14"; sha256="1pkc8wcq55229wkwb54hg9ndbhlxziv51n8880z6yq73zac1hbmf"; depends=[digest proto gWidgets]; };
+  traj = derive { name="traj"; version="1.0"; sha256="0g8fmq3ndp8kdk9jrjakw5hbkw6nh2m0lw396xk42sa0rb4df5s6"; depends=[cluster psych pastecs NbClust GPArotation]; };
+  trajectories = derive { name="trajectories"; version="0.1-1"; sha256="0vf1czc97bqq5snqdma9l1knb4bznyn8pcs8f1q6ssk0xfjrl3s3"; depends=[lattice sp spacetime rgdal rgeos]; };
   TraMineR = derive { name="TraMineR"; version="1.8-8"; sha256="12zbk7bq4ff4dzq86zbh9pspl1b9a69k0rw9lg8sh3mmc0f09m8j"; depends=[RColorBrewer boot]; };
   TraMineRextras = derive { name="TraMineRextras"; version="0.2.2"; sha256="0sb072ssg5q3kncb3b1a0nrnapjq8rly0ibh3gdrld9fdbdbjx68"; depends=[TraMineR RColorBrewer combinat survival]; };
   TRAMPR = derive { name="TRAMPR"; version="1.0-7"; sha256="135ylhijhpdxpznfdbdzwfsvy8bhw1yx28c3520a3lyrqvinpawg"; depends=[]; };
   translate = derive { name="translate"; version="0.1.2"; sha256="1w0xrg1xxwfdanlammmixf06hwq700ssbjlc3cfigl50p87dbc5x"; depends=[RCurl RJSONIO functional lisp]; };
   translateR = derive { name="translateR"; version="1.0"; sha256="11kh9hjpsj5rfmzybnh345n1gzb0pdksrjp04nzlv948yc0mg5gm"; depends=[RJSONIO RCurl textcat httr]; };
-  transmission = derive { name="transmission"; version="0.2.0"; sha256="0cp3fb05kj3zj1x3i7icisaswdqbn9mhx5vi778x44r68h2lap17"; depends=[Rcpp ggplot2 reshape2 plyr]; };
-  transnet = derive { name="transnet"; version="0.1"; sha256="0apsb67dxcnnsjnldr1vsjpc7xwy4cipybk9d86rf86l6cmirci6"; depends=[rJava plyr reshape2]; };
-  transport = derive { name="transport"; version="0.6-2"; sha256="038p40jp654w0jbgzxy1sj4258g9lzdfzija1mfz6nc6ibycviyj"; depends=[]; };
+  transport = derive { name="transport"; version="0.6-3"; sha256="1sldlccsprzan1liyslzp9wzz3d36khyr6zri773npvnss9pa67w"; depends=[]; };
   trapezoid = derive { name="trapezoid"; version="2.0-0"; sha256="0f6rwmnn61bj97xxdgbydi94jizv1dbq0qycl60jb4dsxvif8l3n"; depends=[]; };
   TreatmentSelection = derive { name="TreatmentSelection"; version="1.1.2"; sha256="1mvrb72yz51gmwqlfg5gsjbi65lqk5j24agddw1br53ymdvjgzq4"; depends=[ggplot2]; };
+  treatSens = derive { name="treatSens"; version="1.0"; sha256="0g3v9b1kdndqls9h1ijp5v17ybb1710bdclid745y6lfkia1b71w"; depends=[]; };
   tree = derive { name="tree"; version="1.0-35"; sha256="1k8c2kjk53gix68frprlyx5ww7cm373vz1xg2r2jxbzxg1y4v691"; depends=[]; };
   treebase = derive { name="treebase"; version="0.0-7.1"; sha256="0kj1cyk14j4qzm31f47a8g7qh4842rqkzr0fqh9i5c8kzrqxbc0g"; depends=[ape XML RCurl reshape2 data_table]; };
   treeclim = derive { name="treeclim"; version="1.0.7"; sha256="1l2m4pq5wcb3wkxy9mkay87vzdcn8rxgsknsb72ahdb3zim0yg0v"; depends=[Rcpp abind plyr ggplot2 lmtest lmodel2 np boot]; };
   treecm = derive { name="treecm"; version="1.2.1"; sha256="02al6iz25pay7y1qmbpy04nw8dj9c5r7km6q5k3v3jdkfal6cm6k"; depends=[plyr]; };
   treelet = derive { name="treelet"; version="1.0"; sha256="16g4lmp4yrfg328d0qwrp101y1qnwcrff7kna60cjmqdpvg3wm15"; depends=[]; };
   treemap = derive { name="treemap"; version="2.2"; sha256="0h4wkjw12n9awqsvrs72nmsxq3d5as3zjy8kyhw7715h1cvry769"; depends=[colorspace data_table ggplot2 gridBase igraph RColorBrewer shiny]; };
-  TreePar = derive { name="TreePar"; version="3.0"; sha256="12i3y2wmja0xrq3h43fi4r8991q328l1p51q5nbz17crd44pds31"; depends=[ape Matrix subplex TreeSim deSolve]; };
-  TreeSim = derive { name="TreeSim"; version="2.0"; sha256="0kzmvay0ai0acjhcr4w7674gvln9sgg7n4qc3rg5kfcdqj4q8whp"; depends=[ape geiger laser]; };
+  TreePar = derive { name="TreePar"; version="3.1"; sha256="01bxvpji80d85ficg24zynjrpkm1qw6v9m1pb7474vn4br4fca52"; depends=[ape Matrix subplex TreeSim deSolve]; };
+  TreeSim = derive { name="TreeSim"; version="2.1"; sha256="01izfzlvrak65mzwpz4bn5cansw10fvfjfvj164f5g0qghg9v84n"; depends=[ape geiger laser]; };
   TreeSimGM = derive { name="TreeSimGM"; version="1.2"; sha256="0y6hadwx3apw11jy5d4al3dav3his8b4xvkv7s5d5rd92l7yrw0r"; depends=[TreeSim]; };
-  treethresh = derive { name="treethresh"; version="0.1-7"; sha256="0757w8y7hqki9znn726h7ry1hdrhnfj9ps179jmh5cl0gb5p2qin"; depends=[EbayesThresh wavethresh]; };
   TrialSize = derive { name="TrialSize"; version="1.3"; sha256="1hikhw2l7d3c7cg4p7zzrgdwhy9g4rv06znpw5mc6kwinyakp75q"; depends=[]; };
   TRIANG = derive { name="TRIANG"; version="1.2"; sha256="09hfvfmqrmx8dphlk46ga0y9s986kb32qdhgiq95faqfhpirf0qa"; depends=[]; };
   TRIANGG = derive { name="TRIANGG"; version="1.0"; sha256="1ycqyaijxmgi7v9rzdsq3gxx1wll51yfpdyxbjiyp9gpgmcs7h48"; depends=[]; };
···
   trifield = derive { name="trifield"; version="1.1"; sha256="0xk48fkd5xa3mfn3pwdya0ihpkwnh20sgj3rc7fmzjil47kqscvy"; depends=[]; };
   TriMatch = derive { name="TriMatch"; version="0.9.1"; sha256="1207lnysdjd347m1lsbxy19lq73bjs1irqwk94y8idp1pcj4pfpd"; depends=[ggplot2 scales reshape2 ez psych PSAgraphics]; };
   trimcluster = derive { name="trimcluster"; version="0.1-2"; sha256="0lsgbg93hm0w1rdb813ry0ks2l0jfpyqzqkf3h3bj6fch0avcbv2"; depends=[]; };
+  trimTrees = derive { name="trimTrees"; version="1.2"; sha256="0v75xf5186dy76332x4w7vdwcz7zpqga8mxrb5all2miq2v45fi8"; depends=[randomForest mlbench]; };
   trioGxE = derive { name="trioGxE"; version="0.1-1"; sha256="1ra86l3i7fhb6nsy8izixyvm6z23shv7fcjmnnpil54995j15ax4"; depends=[msm mgcv gtools]; };
-  trip = derive { name="trip"; version="1.1-17"; sha256="1i1hc89bdws4k10w6yz0wqnkkk2mgbhkv0kdnx2q8ljir9p4gbyx"; depends=[sp maptools MASS spatstat]; };
+  trip = derive { name="trip"; version="1.1-18"; sha256="1gwx8i6fbls3fm0l7ynnqfdc3fbk55vwjs4lkplpd2qbkm923axd"; depends=[sp maptools MASS]; };
   tripack = derive { name="tripack"; version="1.3-6"; sha256="1dknz1arzfyknip04a9fxdhqmrkb0r0lr8hgria9s0d57hr1ay12"; depends=[]; };
   tripEstimation = derive { name="tripEstimation"; version="0.0-41"; sha256="11cn9lz4vdcx8wb46cm5sj0rfjl9cs50z7zxfxrn79nz0pga4gwn"; depends=[lattice mgcv rgdal sp zoo]; };
-  TripleR = derive { name="TripleR"; version="1.2.1"; sha256="0ab0mb044594rixira088l2dr5r9jrbphiigi8nv8ggm6536sqf0"; depends=[reshape plyr]; };
+  TripleR = derive { name="TripleR"; version="1.4"; sha256="1hzfdip9n390cizk329k6bdpz1vkxj76khc8lxm0yx9jbc50ng6d"; depends=[ggplot2 reshape2 plyr]; };
+  trotter = derive { name="trotter"; version="0.6"; sha256="0i8r2f2klkkfnjm7jhvga3gx6m7r97pd73d88004jzlm9ficspgy"; depends=[]; };
   trueskill = derive { name="trueskill"; version="0.1"; sha256="0mqvm64fcsxjlh789lqdk6l28q31yhh6jjirwjlgbpxxb90c5107"; depends=[]; };
   truncdist = derive { name="truncdist"; version="1.0-1"; sha256="0aszs6rz8nydyf2dw1m4fj9fclb0r4vpgqywyaqjkdnhzmyn593g"; depends=[evd]; };
   truncgof = derive { name="truncgof"; version="0.6-0"; sha256="0b499i9zjwvva5jfl9fj02jjrgy8myxqfjwa0cjg0jrpgxczgwg8"; depends=[MASS]; };
···
   truncreg = derive { name="truncreg"; version="0.2-1"; sha256="0qvdfj93phk1s2p4n0rmpf8x9gj5n1j75h4z424mrg10r24699rd"; depends=[maxLik]; };
   truncSP = derive { name="truncSP"; version="1.2.2"; sha256="1hdi518j3sg9273g01l1jqlmqya3ppim82ma7zakwqpmsjmzw18q"; depends=[truncreg boot]; };
   trust = derive { name="trust"; version="0.1-6"; sha256="1jghgwnazhqgyn2k0b3x4n8swncyy6dzlkv86chv98zw4s3bnlak"; depends=[]; };
-  trustOptim = derive { name="trustOptim"; version="0.8.3"; sha256="04pkni5053r9czmf81jaq3y1kvw902g237pa6d3jgkvlqaznqwg3"; depends=[Rcpp RcppEigen Matrix]; };
   TSA = derive { name="TSA"; version="1.01"; sha256="0cm97hwxm6vfgy9mc3kgwq6dnmn86p8a4avnfjbai048qnwrn6hx"; depends=[leaps locfit mgcv tseries]; };
   TSAgg = derive { name="TSAgg"; version="1.0.1"; sha256="01s0grwfbhhfipqdnc0932rjsz4k52rln2bs8dsvrk6f8wps7h1k"; depends=[lubridate]; };
   tsbridge = derive { name="tsbridge"; version="1.1"; sha256="0mry3ia54cdfydpzm8asrq1ldj70gnpb5dqzj51w0jiyps2zlw6f"; depends=[mvtnorm tsbugs]; };
   tsbugs = derive { name="tsbugs"; version="1.2"; sha256="130v4x6cfy7ddvhijsnvipm4ycrispkj1j0z5f326yb4v5lrk91x"; depends=[]; };
-  TSclust = derive { name="TSclust"; version="1.2.1"; sha256="1ixawrs686p5g8kdaiqpf4y8ndpz0vgz9ji1ahja8i6nscfzasd9"; depends=[wmtsa pdc cluster locpol KernSmooth dtw longitudinalData]; };
+  TSclust = derive { name="TSclust"; version="1.2.2"; sha256="1v58kbgbpwzvsc1s832626pbc70dxcfrk97mpbb6wy7n3i34qvdh"; depends=[wmtsa pdc cluster locpol KernSmooth dtw longitudinalData]; };
   TScompare = derive { name="TScompare"; version="2013.9-1"; sha256="1gghr7xsg524sc9lhy1ymlhigaz6pi69fnccgn784ff2hl3w6d8w"; depends=[TSdbi tframe tfplot]; };
   TSdata = derive { name="TSdata"; version="2013.9-1"; sha256="1r3x6w17517if2jpcz2mr8jk5i080dkx4nlffblrcsxjhfvlz0xh"; depends=[]; };
   TSdbi = derive { name="TSdbi"; version="2013.9-1"; sha256="12v9dv7hrq626q44v3lws950m241fq5fsfsnmgvfbbyya5ixis86"; depends=[DBI tframe]; };
   TSdist = derive { name="TSdist"; version="1.2"; sha256="103wv6wy5gjim2cf14d6afinyla85p6dncchi17fr0s4vqkmx3m5"; depends=[proxy zoo xts]; };
-  tsDyn = derive { name="tsDyn"; version="0.9-33"; sha256="080bzbxvjfwayq9j7r1ghalvjcql9sk7ryzj880k2by4179fhnkk"; depends=[mnormt mgcv nnet tseriesChaos tseries vars urca forecast MASS Matrix foreach]; };
+  tsDyn = derive { name="tsDyn"; version="0.9-41"; sha256="1ssb0z35xmnwyrsvmk2jsxfd5h0xhnx8kp8qyxc43j4v2nz5l4kq"; depends=[mnormt mgcv nnet tseriesChaos tseries vars urca forecast MASS Matrix foreach]; };
   TSEN = derive { name="TSEN"; version="1.0"; sha256="1pn313g2ylbjc37rqcakd797vffnh7v0rgg1xl5wjyvcgmm5mxix"; depends=[ncdf]; };
   tseries = derive { name="tseries"; version="0.10-32"; sha256="0jz8a3z3hx2ps7krmpg6m10jvz5ddgmcrmnd38jpxb6ndnhh3pzw"; depends=[quadprog zoo]; };
   tseriesChaos = derive { name="tseriesChaos"; version="0.1-13"; sha256="0f2hycxyvcaj3s1lmva1qy46xr6qi43k8fvnm4md5qj8jp2zkazg"; depends=[deSolve]; };
···
   TSgetSymbol = derive { name="TSgetSymbol"; version="2013.9-1"; sha256="1hn78xrfdnwhjrgcnn71ihvdgv4qwdxhpjwcqp0pbkgbxj3q5w3k"; depends=[TSdbi quantmod DBI zoo tframe tframePlus]; };
   TShistQuote = derive { name="TShistQuote"; version="2013.9-1"; sha256="06din7frxmbk4qxkpv0z5srh8nh0wkmrfl9lz17y7cwsmldl4hvr"; depends=[TSdbi DBI tframe tframePlus zoo tseries]; };
   TSHRC = derive { name="TSHRC"; version="0.1-3"; sha256="18ygg7bqwg1pdqi52l1lf33gcd277895rlf5853yzh7ln2ivssmi"; depends=[]; };
-  tsintermittent = derive { name="tsintermittent"; version="1.3"; sha256="10ch3ssfgdxhxg0l5m4jp2mryj7s23crwnj0nwnc9w3yarl9mxjy"; depends=[MAPA]; };
+  tsintermittent = derive { name="tsintermittent"; version="1.4"; sha256="13n4373s26b9wg21vhynvzvhc1xc9anqi21i4anx28mkzzag03dc"; depends=[MAPA]; };
   TSjson = derive { name="TSjson"; version="2014.4-1"; sha256="1rkxc4dm7hdva0hiqbka8isfszjy26if9hnarsm51cflk8b60zhk"; depends=[TSdbi findpython DBI tframe tframePlus rjson]; };
   tslars = derive { name="tslars"; version="1.0"; sha256="0ylpn4jxmrck7hna3j420kw2yhsrklrq2664w85z30xij3zrrrci"; depends=[]; };
   tsModel = derive { name="tsModel"; version="0.6"; sha256="0mkmhzj4g38ngzfcfx0zsiqpxs2qpw82kgmm1b8gl671s4rz00zs"; depends=[]; };
···
   TTAinterfaceTrendAnalysis = derive { name="TTAinterfaceTrendAnalysis"; version="1.5.1"; sha256="1i9p5s7xj3py8465yjjaqs2m7krjxzzqd86lkpbgzxnxjdnxcx5i"; depends=[Hmisc pastecs reshape wq e1071 timeSeries fBasics relimp multcomp nlme lubridate tcltk2]; };
   tth = derive { name="tth"; version="4.3-2"; sha256="1gs8xjljklvs0pavvn9f59y09hw7x2da58a46b5x01g08i0j8h1d"; depends=[]; };
   TTR = derive { name="TTR"; version="0.22-0"; sha256="0aackwmmakjcynpq4nxi8xw1x3688rkg6kypgd5jiprzzdhsz5rq"; depends=[xts]; };
-  ttScreening = derive { name="ttScreening"; version="1.3"; sha256="1ixy3s0a1vwr5qf1w24n8bhbq6qbwraal8xb8ypbvpjkrl0d14z2"; depends=[matrixStats corpcor]; };
+  ttScreening = derive { name="ttScreening"; version="1.4"; sha256="02ikm9z8wm5h702hm34g9nlknidhbc666lbmifh6imibi1fyf5q7"; depends=[matrixStats corpcor MASS]; };
   ttutils = derive { name="ttutils"; version="1.0-1"; sha256="18mk30070mcplybg320vjbk9v5flxnbqi5gx0yyr1z6ymjmnrxbc"; depends=[]; };
   ttwa = derive { name="ttwa"; version="0.8.5.1"; sha256="1lhypcwssq0dspizvln3w4dg16ad6mz8cj4w34c5vsrayqid7fyn"; depends=[data_table]; };
-  TukeyC = derive { name="TukeyC"; version="1.1-4"; sha256="0p6wiyk6k2jabbf1s8fgzd547f3c0paf8d9hfa9aan5vwfcfyld6"; depends=[]; };
+  TukeyC = derive { name="TukeyC"; version="1.1-5"; sha256="08s9scsd2l6wavc7qqlffjbf89vkd6xpb4iawvbqf7jh8jiyvw17"; depends=[]; };
   TunePareto = derive { name="TunePareto"; version="2.4"; sha256="0pljl3q5s9yqc4ph70y66ff9ci9w8gwj8jsy8srxqkgqvahc8arf"; depends=[]; };
   tuneR = derive { name="tuneR"; version="1.2.1"; sha256="1f6mdkfwfy6r62sbwq37sylvcji6f3mj9w13sgicxjn6swbszf57"; depends=[signal]; };
-  tuple = derive { name="tuple"; version="0.3-06"; sha256="025fkyiv5gn5gajk0fdknp00vc6z2b9f7j9p025cl8jyxgpyv4xy"; depends=[]; };
-  turboEM = derive { name="turboEM"; version="2012.2-1"; sha256="1vv7bjkkqm96qkqqz6gzhz7ii4yzr252r8wf37dgv5qfh1jlbvp2"; depends=[numDeriv quantreg foreach]; };
+  tuple = derive { name="tuple"; version="0.4-02"; sha256="0fm8fsdfiwknjpc20ivi5m5b19r9scdxhzij70l8qi3ixw1f0rnk"; depends=[]; };
+  turboEM = derive { name="turboEM"; version="2014.8-1"; sha256="0g9nm1m542hslz8272n5qz6h59criyf71l2w218dvq34bcjcd3yy"; depends=[doParallel foreach numDeriv quantreg iterators]; };
   turfR = derive { name="turfR"; version="0.8-4"; sha256="0fqzwnrwxlighxbapmnarxzh91s6khjbb26xs8gqzz3f8xwmj9dy"; depends=[dplyr]; };
   turner = derive { name="turner"; version="0.1.7"; sha256="1xckb750hbfmzhvabj0lzrsscib7g187b44ag831z58zvawwh772"; depends=[tester]; };
-  TurtleGraphics = derive { name="TurtleGraphics"; version="1.0-4"; sha256="10zdwpfd2a0w995v4w2rvbvcczg53cb2kpm6bcyvrj8j5nqzmgqf"; depends=[]; };
+  TurtleGraphics = derive { name="TurtleGraphics"; version="1.0-5"; sha256="18azwbvs3cv3arp6zhh5bklf7n04p13jpfjh44nxv5159jry7arr"; depends=[]; };
   TUWmodel = derive { name="TUWmodel"; version="0.1-2"; sha256="1k3gdsl8rv10ipa82rgyhjh4pqf4n2d2dj68s9r5pkv362kzk1ra"; depends=[]; };
+  tvd = derive { name="tvd"; version="0.1.0"; sha256="07al7gpm81a16q5nppsyc5rhv6zzkcvw72isx955b1q189v073aw"; depends=[Rcpp]; };
   tvm = derive { name="tvm"; version="0.2"; sha256="1fwa37xnp3idal8v1xxlc9gr25595f644i7a3h8xpd0k086sp1dg"; depends=[ggplot2 reshape2]; };
   twang = derive { name="twang"; version="1.4-0"; sha256="0r9n0s421dhvsr3ppzhdxsq4viz18mbi9mglhyyl5r6slzyb4m0x"; depends=[gbm survey xtable latticeExtra]; };
   tweedie = derive { name="tweedie"; version="2.2.1"; sha256="1fsi0qf901bvvwa8bb6qvp90fkx1svzswljlvw4zirdavy65w0iq"; depends=[]; };
···
   TwoCop = derive { name="TwoCop"; version="1.0"; sha256="1ycxq8vbp68z82r2dfg2wkc9zk3bn33d94xay20g2p55lnzl2ifd"; depends=[]; };
   twoStageGwasPower = derive { name="twoStageGwasPower"; version="0.99.0"; sha256="1xvy6v444v47i29aw54y29xiizkmryv8p3mjha93xr3xq9bx2mq7"; depends=[]; };
   twostageTE = derive { name="twostageTE"; version="1.2"; sha256="05k9lvkailv06cah71p71hnx8in045nxz6waplsccznplhgqg5ar"; depends=[isotone]; };
-  TwoStepCLogit = derive { name="TwoStepCLogit"; version="1.2.2"; sha256="0z3jg0hl7v2g1bral94gn3b1d11dzrlnzc912yh52vrcawbkmckq"; depends=[survival]; };
+  TwoStepCLogit = derive { name="TwoStepCLogit"; version="1.2.3"; sha256="0arqpfflflsydsgcrpq364vqf4sn019m03ygmpq810wa78v4r9s0"; depends=[survival]; };
   txtplot = derive { name="txtplot"; version="1.0-3"; sha256="1949ab1bzvysdb79g8x1gaknj0ih3d6g63pv9512h5m5l3a6c31h"; depends=[]; };
-  UBCRM = derive { name="UBCRM"; version="1.0"; sha256="1lkj0pg3pmj91s8i9xzs3bpizpmvjn85bs89wl54whjjhfnnfynk"; depends=[]; };
   ucbthesis = derive { name="ucbthesis"; version="1.0"; sha256="0l855if3a7862lxlnkbx52qa617mby634sbb2gkprj21rwd7lcbp"; depends=[knitr stringr]; };
   ucminf = derive { name="ucminf"; version="1.1-3"; sha256="19gmbz32rhrdagvhf2s901lvi1r6273wzznry5daryq6w1jx5z3v"; depends=[]; };
   udunits2 = derive { name="udunits2"; version="0.6"; sha256="1dlxcx7yw7yqpimnfikdraqcmjsjz7js0j24li0879dzwrqa27ja"; depends=[]; };
···
   Unicode = derive { name="Unicode"; version="0.1-4"; sha256="0ja0l8b95r2wgybbrpbdbbfjzdq2ns0kcvffv47sq29m516dasyh"; depends=[]; };
   uniCox = derive { name="uniCox"; version="1.0"; sha256="1glgk6k8gwxk3haqaswd2gmr7a2hgwjkwk2i1qc5ya7gg8svyavv"; depends=[survival]; };
   uniReg = derive { name="uniReg"; version="1.0"; sha256="1xl19dqnxxibgiiny9ysll2z8j1i70qrszf4xbacq1a6z31vm840"; depends=[DoseFinding MASS mvtnorm quadprog SEL]; };
+  unittest = derive { name="unittest"; version="1.0-1"; sha256="08r4qpfj37mykbwd893m4nqyxzar0c3qal76jwsypv3gr7y0khd9"; depends=[]; };
   unmarked = derive { name="unmarked"; version="0.10-4"; sha256="1mb9c6h51y476y50q4bh9v6wx6d91b2npf18a66gjs406nra3yck"; depends=[reshape lattice Rcpp plyr]; };
   untb = derive { name="untb"; version="1.7-2"; sha256="1ha0xj94sz1r325qb4sb5hla9hw1gbqr76703vk792x9696skhji"; depends=[Brobdingnag partitions polynom]; };
-  upclass = derive { name="upclass"; version="1.0"; sha256="0ga49pcxib4lp0pq1ljj1fjbrg7jz4vpjp5hq0c1v1hw2p7a3giy"; depends=[mclust classifly gclus]; };
+  upclass = derive { name="upclass"; version="2.0"; sha256="0jkxn6jgglw6pzzbcvi1pnq4hwfach3xbi13zwml4i83s3n5b0vg"; depends=[mclust]; };
   uplift = derive { name="uplift"; version="0.3.5"; sha256="11xikfmg6dg8mhwqq6wq9j9aw4ljh84vywpm9v0fk8r5a1wyy2f6"; depends=[RItools MASS coin tables penalized]; };
+  UPMASK = derive { name="UPMASK"; version="1.0"; sha256="19krsqkz2g5b6svqp29s6i92bhlk7liv8lf7d03za848w7y2jkhq"; depends=[MASS RSQLite DBI]; };
   urca = derive { name="urca"; version="1.2-8"; sha256="0gyjb99m6w6h701vmsav16jpfl5276vlyaagizax8k20ns9ddl4b"; depends=[nlme]; };
   UScancer = derive { name="UScancer"; version="0.1-2"; sha256="0p1kxw1phqq598ljk3njznc9kmgscc8gmwdrvx1scba9rr6n61kl"; depends=[rgdal]; };
   UScensus2000blkgrp = derive { name="UScensus2000blkgrp"; version="0.03"; sha256="196hpqrc3rq0m6ra6qinlhz1yknplx08pfp57l6yalni26c8pia0"; depends=[maptools sp foreign]; };
···
   usdm = derive { name="usdm"; version="1.1-12"; sha256="0padc9ppfisnjg1nzw5csv2zki6dby7487lis8pixf1hhbinsnci"; depends=[raster]; };
   useful = derive { name="useful"; version="1.1.8"; sha256="1lzl7rr9qxqa0ga6ml7qi7wi02fd4isgpfskvi3igy10iw1zv3hb"; depends=[ggplot2 plyr scales]; };
   userfriendlyscience = derive { name="userfriendlyscience"; version="0.1-2"; sha256="1b2ypga0kzf8qsl160by1vfp8p6z2mczn3w1qgk042y83kiaiawx"; depends=[ggplot2 plyr psych pwr fBasics e1071 ltm MBESS foreign knitr xtable GGally lavaan]; };
-  UsingR = derive { name="UsingR"; version="2.0-1"; sha256="1z6kiprivam0apdw5qfxyixjwcqpjlap6adccn35cwilgz7ab55i"; depends=[MASS HistData Hmisc aplpack quantreg]; };
+  UsingR = derive { name="UsingR"; version="2.0-2"; sha256="0qn993bb890ihgvq7kddac6xgfgfai30x62ip0048ymnvcmvjfhf"; depends=[MASS HistData Hmisc quantreg]; };
+  uskewFactors = derive { name="uskewFactors"; version="1.0"; sha256="1ixcxqw8ai77ndn1cfkq53a090fgs95yzvas1qg2siwpfsm4yix6"; depends=[tmvtnorm mvtnorm MCMCpack MASS]; };
   usl = derive { name="usl"; version="1.3.1"; sha256="1d5xq0iwjp9zdn7xc6vjh74gb0w7fym50qyfd0fn362q5g3jsyk0"; depends=[nlmrt]; };
   ustyc = derive { name="ustyc"; version="1.0.0"; sha256="1267bng2dz3229cbbq47w22i2yq2ydpw26ngqa1nbi3ma6hwqsv4"; depends=[XML plyr]; };
-  utility = derive { name="utility"; version="1.2"; sha256="10dwmf4gcz0jbakwnvgm475sjjilqj1gf3zisil22pk0rcm51kgj"; depends=[]; };
+  utility = derive { name="utility"; version="1.3"; sha256="0ng7jc45k9rgj9055ndmgl308zjvxd2cjsk2pn57x44rl1lldcj5"; depends=[]; };
   uuid = derive { name="uuid"; version="0.1-1"; sha256="1b35h2n86233zb6dwkgxxlvnlld8kmv0j6j3m31xjbpmc3ppr7w3"; depends=[]; };
   UWHAM = derive { name="UWHAM"; version="1.0"; sha256="1qaj8anaxqnx4nc6vvzda9hhhzqk9qp8q7bxm26qgia4hgascnrv"; depends=[trust]; };
   vacem = derive { name="vacem"; version="0.1-1"; sha256="0lh32hj4g1hsa45v6pmfyj1hw0klk8gr1k451lvs4hzpkkcwkqbn"; depends=[foreach]; };
   varbvs = derive { name="varbvs"; version="1.0"; sha256="0ywgb6ibijffjjzqqb5lvh1lk5qznwwiq7kbsyzkwcxbp8xkabjw"; depends=[]; };
   varComp = derive { name="varComp"; version="0.1-317"; sha256="16nmhipi0nlh0igc3g9jbv1pqvigmgxy8f395xx6hbzyg87x2ha9"; depends=[quadprog Matrix MASS CompQuadForm RLRsim SPA3G mvtnorm nlme]; };
-  varcompci = derive { name="varcompci"; version="1.0.1"; sha256="11fxb63479cha4apakfd1rs89ngrpfhy0h1412wxyn4k8kbibkk4"; depends=[]; };
   vardiag = derive { name="vardiag"; version="0.2-0"; sha256="0avj900zx4nr67dk08n0n6arxx2cb2ymm0kd5xxnzsmyrmwm40mm"; depends=[]; };
-  vardpoor = derive { name="vardpoor"; version="0.2.0.9.2"; sha256="0snc0fcmkppca4rcgdyac0mzg235gm7zira5691mnmamrn4f7ikm"; depends=[data_table laeken reshape2 foreach lpSolve plyr gdata]; };
+  vardpoor = derive { name="vardpoor"; version="0.2.0.13"; sha256="1zvjx87zl244fivnjnd268zwxnkxp4s0bw2zp7s3lmzvcz97bnz1"; depends=[data_table laeken reshape2 foreach plyr gdata MASS stringr]; };
   VarEff = derive { name="VarEff"; version="1.0"; sha256="0zp024z5xl43z2z67fq5ryfiamfvdbbbv1iaaiyw3shjbg2bp8dp"; depends=[mcmc]; };
   VaRES = derive { name="VaRES"; version="1.0"; sha256="0gw05jiqgirhz3c8skbb07y4h44r6vi68gnd5y7ql455v0c2raza"; depends=[]; };
-  VAR_etp = derive { name="VAR.etp"; version="0.4"; sha256="0pzxmm41l6sci2jcsnlljymb2vb9b6n9lmj3kjs177cfsd6lp9z1"; depends=[]; };
+  VAR_etp = derive { name="VAR.etp"; version="0.5"; sha256="19vpfbgj5v9c9yw2hpr0jcfr18sc69kjbfi0h0ibl317whyknakm"; depends=[]; };
   VariABEL = derive { name="VariABEL"; version="0.9-2"; sha256="0vlr6zxl75i49p35jxrc5fwfrb55n91hqdan2ikcix3r2k4qs5k0"; depends=[]; };
   VarianceGamma = derive { name="VarianceGamma"; version="0.3-1"; sha256="01jv5qrfw8y8yyd3jy3058bpnfyzz7d0m4rx0iibs79gv2rvq5sn"; depends=[DistributionUtils GeneralizedHyperbolic RUnit]; };
   vars = derive { name="vars"; version="1.5-2"; sha256="1q45z5b07ww4nafrvjl48z0w1zpck3cd8fssgwgh4pw84id3dyjh"; depends=[MASS strucchange urca lmtest sandwich]; };
···
   VBmix = derive { name="VBmix"; version="0.2.17"; sha256="0fhx2vk5ffq147kfgsqjbqwgv64m7z9mbz4gchj90440ih7kyxa5"; depends=[lattice pixmap mnormt]; };
   vbsr = derive { name="vbsr"; version="0.0.5"; sha256="1avskbxxyinjjdga4rnghcfvd4sypv4m39ysfaij5avvmi89bx3b"; depends=[]; };
   vcd = derive { name="vcd"; version="1.3-2"; sha256="1ww69sgg178aqcs90mm599nlr6hnxn54d2wzyhddgx1z3qxhzwjd"; depends=[MASS colorspace]; };
-  vcdExtra = derive { name="vcdExtra"; version="0.6-1"; sha256="11f7my59v4wkj1hbpx4vg1bim93i3ajix24iic5jsrk0gi0431x4"; depends=[vcd gnm MASS]; };
-  vcf2geno = derive { name="vcf2geno"; version="2.3"; sha256="1ib9g3162d4mlwrk77fhzsgkcbrbvygav0ycl8527nxbdiyb77f1"; depends=[]; };
+  vcdExtra = derive { name="vcdExtra"; version="0.6-3"; sha256="1zpgr4ykcys1gc0cicrdl5w02mr2f5bm60cpm3r3mqs718nsjxkv"; depends=[vcd gnm MASS]; };
+  vcrpart = derive { name="vcrpart"; version="0.2-1"; sha256="0z2jblq6i71gr78a2jyg6h8yc952jv6dfcq62z4nrvi37m4d56c3"; depends=[partykit nlme rpart numDeriv ucminf zoo sandwich strucchange]; };
   VDA = derive { name="VDA"; version="1.3"; sha256="063mpwbyykx4f46wzfvrgnlq73ar7i06gxr4mjzbhqcfrsybi72b"; depends=[rgl]; };
   vdg = derive { name="vdg"; version="1.0"; sha256="1agikw9w9rnn3b2q8lp9y3bxjrf8vx24j624wf19bvx5s3ghqc36"; depends=[ggplot2 quantreg proxy]; };
-  Vdgraph = derive { name="Vdgraph"; version="2.1-3"; sha256="1vyx6q7h2xj9qipyh7pdnd0mh6cs379irxqaylnn2m9rcrmj191q"; depends=[]; };
-  VdgRsm = derive { name="VdgRsm"; version="1.01"; sha256="01hywwjmyvl9ls6gn2vl5z5cv2zlnxl2rfr3k1pachz3gq0yhdc1"; depends=[DoE_wrapper AlgDesign permute]; };
-  vec2dtransf = derive { name="vec2dtransf"; version="1.0"; sha256="0hi7x38f3lyxqgwzjz86ld4snva4ci5rinbqhap04d5hcr2sdpzi"; depends=[sp]; };
-  vecsets = derive { name="vecsets"; version="1.0"; sha256="0jj02fri400pzdqvydcdm3z70wzcwi9zgh45g3rwz3rh5lg15778"; depends=[]; };
+  Vdgraph = derive { name="Vdgraph"; version="2.2-1"; sha256="1bbx6ab6868dn0pbhvixcvmk79h1pa6azqqr100cdljxgcnygi79"; depends=[]; };
+  vdmR = derive { name="vdmR"; version="0.1.0"; sha256="0rv9c6bn711dn1fhgmr4ig0lr9s6yjk7r5ccvyiadgn6g5mr2bds"; depends=[ggplot2 plyr maptools gridSVG rjson GGally Rook dplyr]; };
+  vec2dtransf = derive { name="vec2dtransf"; version="1.1"; sha256="029xynay9f9rn0syphh2rhd3szv50ib4r0h0xfhhvbbb37h5dc9s"; depends=[sp]; };
+  vecsets = derive { name="vecsets"; version="1.1"; sha256="0k27g3frc9y9z2qlm19kfpls6wl0422dilhdlk6096f1fp3mc6ij"; depends=[]; };
   VecStatGraphs2D = derive { name="VecStatGraphs2D"; version="1.7"; sha256="08f9ixpiq8s5h8h608wrs9l16xk3c1xcrvwgvm5wqm6xfkj9gpfd"; depends=[MASS]; };
-  VecStatGraphs3D = derive { name="VecStatGraphs3D"; version="1.5"; sha256="04x2xqnbgkbi626y9ihs3nlxzf84jz44zlapsdlrxqlswiw4n0mw"; depends=[rgl misc3d MASS]; };
+  VecStatGraphs3D = derive { name="VecStatGraphs3D"; version="1.6"; sha256="1pnpgnxdiis4kzwhh17k61aidyan5fp9rzqhvwf6gljb4csqsk54"; depends=[rgl misc3d MASS]; };
   vectoptim = derive { name="vectoptim"; version="0.2"; sha256="1n19sipx5r0qy08jmrbsrf0kgwgl31np88wc1zyc2bkx8h1zkmf2"; depends=[foreach doParallel]; };
   vegan = derive { name="vegan"; version="2.0-10"; sha256="06anm8q82qziqhc3x8cll2xshhjiqkdbwnq1cyn98mshmxlg8i4z"; depends=[permute lattice]; };
+  vegan3d = derive { name="vegan3d"; version="0.65-0"; sha256="0c75hybhwqv56f2zpskr99rr9k6hw6rbv29bcxn0fciw5jqk01m3"; depends=[vegan rgl scatterplot3d]; };
   vegclust = derive { name="vegclust"; version="1.6.3"; sha256="0l6j4sgzfqvcypx2dszpnsd1sivk33pixlgf9abqifp45skpkwfg"; depends=[vegan sp]; };
   vegdata = derive { name="vegdata"; version="0.6-6"; sha256="0fwilqdzfhmdp8v0i6swmd6600g7mf5pdmz7r5076k0qzapalb3r"; depends=[foreign XML]; };
   vegetarian = derive { name="vegetarian"; version="1.2"; sha256="15ys1m8p3067dfsjwz6ds837n6rqd19my23yj8vw78xli3qmn445"; depends=[]; };
-  VennDiagram = derive { name="VennDiagram"; version="1.6.7"; sha256="0n291hg4qfjx9z5bhna6blzp7zwi6il2s3vg6600nd2rd7nfx98h"; depends=[]; };
+  VennDiagram = derive { name="VennDiagram"; version="1.6.9"; sha256="0sxgspqsn15y3pipd9wy4wh2n5rkb9bazqkfwkf88p483azpjxw9"; depends=[]; };
   venneuler = derive { name="venneuler"; version="1.1-0"; sha256="10fviqv9vr7zkmqm6iy2l9bjxglf2ljb7sx423vi4s9vffcxjp17"; depends=[rJava]; };
   verification = derive { name="verification"; version="1.40"; sha256="19nhpv41s024cqd3qzx0d2sc9234x73s6k8nfj6wf5jvbc5z0xv4"; depends=[fields boot CircStats MASS dtw]; };
+  vetools = derive { name="vetools"; version="1.3-28"; sha256="1470xgqdq9n5kj86gdfds15k3vqidk3h99zi3g76hhyfl8gyl1c0"; depends=[sp stringr tis lubridate maptools plyr xts scales]; };
   VGAM = derive { name="VGAM"; version="0.9-4"; sha256="1mpi73vxz6dzmr1g7d1mnybb18zpn7klaqb7x3cq8j2c37b9ywq4"; depends=[]; };
   VGAMdata = derive { name="VGAMdata"; version="0.9-4"; sha256="0swmq2pi987pln24pyxrrqr8smqk2290j06wfj1ldpa5g4yjzqmr"; depends=[]; };
   VHDClassification = derive { name="VHDClassification"; version="0.3"; sha256="1ij4h3gzxb9mm9q743kc3sg2q609mnqz6mhlrbim1wcjji2b7bv4"; depends=[e1071 lattice]; };
   VideoComparison = derive { name="VideoComparison"; version="0.11"; sha256="04jc9br4ddck2sh9bhy02jx34cqxvh904lr46sid6dnmaqfn80l7"; depends=[RJSONIO RCurl zoo pracma Rcpp]; };
   VIF = derive { name="VIF"; version="1.0"; sha256="0yvg6ikrcs7mhg0pavhcywrfysv7ylvnhxpc5sam86dbp69flx9x"; depends=[]; };
-  VIM = derive { name="VIM"; version="4.0.0"; sha256="1w62x5vvbpn3h1zwh0jvvy3lpwai1d708jq18zq99bh1qn8n6bfg"; depends=[colorspace car robustbase sp vcd MASS nnet e1071 Rcpp glmnet]; };
+  VIM = derive { name="VIM"; version="4.1.0"; sha256="15nmywg8mhknvivg9bfszif2allim5vf1hjfbfyl053jphjpax26"; depends=[colorspace data_table car robustbase sp vcd MASS nnet e1071 Rcpp]; };
   VIMGUI = derive { name="VIMGUI"; version="0.9.0"; sha256="195lakyik597sjkq6c5v3881p35111gzmj2r5f5nr53vi6bn4pzm"; depends=[tkrplot VIM survey gWidgetsRGtk2 foreign RGtk2 Cairo Hmisc]; };
   VineCopula = derive { name="VineCopula"; version="1.3"; sha256="1vxm7bk7p452p4kbm5q3ricxcd4f74zzlibxx13wj0cbza5p49nl"; depends=[MASS mvtnorm igraph copula]; };
   vines = derive { name="vines"; version="1.1.0"; sha256="1cf06i2vci0hwszdlpcig90klxgd7l2k79dln71lc9y0xrzxz9lf"; depends=[copula ADGofTest cubature TSP]; };
   violinmplot = derive { name="violinmplot"; version="0.2.1"; sha256="1j3hb03y988xa704kp25v1z1pmpxw5k1502zfqjaf8cy4lr3kzsc"; depends=[lattice]; };
   vioplot = derive { name="vioplot"; version="0.2"; sha256="16wkb26kv6qr34hv5zgqmgq6zzgysg9i78pvy2c097lr60v087v0"; depends=[sm]; };
   viopoints = derive { name="viopoints"; version="0.2-1"; sha256="0cpbkkzm1rxch8gnvlmmzy8g521f5ang3nhlcnin419gha0w6avf"; depends=[]; };
-  visova = derive { name="visova"; version="1.0"; sha256="1w547nbhd69k6y5k0wv51crykwnlzhms2v6xjwp62n8idjlg81ai"; depends=[RJSONIO]; };
-  visreg = derive { name="visreg"; version="2.0-5"; sha256="0pnq8irvsmcb0v77s0vhfldv7myg202fm3wdgssnpsihbz747gcc"; depends=[lattice]; };
+  virtualspecies = derive { name="virtualspecies"; version="1.0"; sha256="1qg5106ja17nsqzjnyswjf438f55195l197pizkybb2ilg4fw0x1"; depends=[raster ade4 dismo rworldmap]; };
+  visova = derive { name="visova"; version="1.1"; sha256="1ag1vs5alh62yj5722qb74rmvvxv7906h7nb5m31bac2p4ldbfar"; depends=[RJSONIO]; };
+  visreg = derive { name="visreg"; version="2.0-6"; sha256="0fshbhvsk40272m7zh5npidqpxvfvwx5y4if6jygnb1kn0kal17b"; depends=[lattice]; };
   visualFields = derive { name="visualFields"; version="0.4"; sha256="07pkaccnk8c9zzizpcdw82vcbqdng2bi9aczpa68i7fz24bvcfan"; depends=[gridBase flip matrixStats Hmisc]; };
   visualizationTools = derive { name="visualizationTools"; version="0.2.05"; sha256="08ry8bz2278ncjx0sdrg19mv448i0n497l5abpv9f8xhsfsqyrpf"; depends=[]; };
   visualize = derive { name="visualize"; version="4.2"; sha256="1jgk7j0f3p72wbqnmplrgpy7hlh7k2cmvx83gr2zfnbhygdi22mk"; depends=[]; };
···
   vitality = derive { name="vitality"; version="1.0"; sha256="0di72khz1mwqlirx78a86lwqhjmbbgmxm6vmlwq546dwvs6q071g"; depends=[IMIS]; };
   VizOR = derive { name="VizOR"; version="0.7-9"; sha256="1xw06y86nsrwpri6asrwh8kccjsqzzidgbpld6d6l7vrglp8m6sr"; depends=[lattice rms]; };
   VLF = derive { name="VLF"; version="1.0"; sha256="1il8zhm80mc22zj16dpsy4s6s9arj21l9ik0vccyrpnlr8ws3d3l"; depends=[]; };
-  VLMC = derive { name="VLMC"; version="1.3-14"; sha256="073v7wvcfksc224994vp4xswpl5yl37mgrr2gl95566ncbgdm29q"; depends=[MASS]; };
-  VNM = derive { name="VNM"; version="1.0"; sha256="0wng71bxgi1z70cjrkn8dixg86bxhvbhimlrnqjxbwds6z3ds4pz"; depends=[]; };
+  VLMC = derive { name="VLMC"; version="1.4-0"; sha256="0ifrmwq095xpmn3r303l3b9z31fri224nk3jn7aim6chcjmy1r71"; depends=[MASS]; };
+  VNM = derive { name="VNM"; version="2.0"; sha256="0qgr8n7h938dlsirwgcisl79jk8qxbac8nbl0p38kckfgwfsj06c"; depends=[]; };
   Voss = derive { name="Voss"; version="0.1-4"; sha256="056izh1j26vqjhjh01fr7nwiz1l6vwr5z4fll87w99nc5wc4a467"; depends=[fields]; };
   vowels = derive { name="vowels"; version="1.2"; sha256="07w2jv5sswwwzrsc9hdnjh5kj5lqqmpmjn5ihrdj0xpmnhcm4vhp"; depends=[]; };
-  vows = derive { name="vows"; version="0.2-1"; sha256="0aqk09y45l4p814x83l07smy1m2aypsf0c341j56di5bsc55vl2m"; depends=[fda gamm4 RLRsim Rniftilib rpanel shape stringr tkrplot]; };
+  vows = derive { name="vows"; version="0.3"; sha256="0b8jgf1zh7qqkiszbygm9hgld3gv6m5vsw7jz8sl3zkc0lixxysn"; depends=[fda gamm4 rpanel mgcv RLRsim Rniftilib shape stringr]; };
   VoxR = derive { name="VoxR"; version="0.5.1"; sha256="07lsp6lrkq0gv55m84dl9w7gz5246d9avypqnkz96n3rbbgd0w5z"; depends=[]; };
   VPdtw = derive { name="VPdtw"; version="2.1-10"; sha256="1sipiqbk766czd1jxam3bc2hfq7wsn72x51j5ssn2s2q0gvpl7m1"; depends=[]; };
   vrmlgen = derive { name="vrmlgen"; version="1.4.9"; sha256="0lifhhf41yml4k83wpkssl14jgn8jaw1lcknwbci1sd8s1c4478l"; depends=[]; };
···
   VSURF = derive { name="VSURF"; version="0.8.2"; sha256="1d9irh8s49i8i9q8psmfl41jnr95wvm3libxin0ir8r297rq82z3"; depends=[randomForest rpart doParallel]; };
   vwr = derive { name="vwr"; version="0.3.0"; sha256="1h790vjcdfngs1siwldvqz8jrxpkajl3266lzadfnmchfan1x7xv"; depends=[stringdist lattice latticeExtra]; };
   W2CWM2C = derive { name="W2CWM2C"; version="1.0"; sha256="14q1y4vpmrx8qz5nav8bbjkxqsqk646zcwr8h7yzi7cfa85b4cxz"; depends=[waveslim wavemulcor]; };
-  W3CMarkupValidator = derive { name="W3CMarkupValidator"; version="0.1-0"; sha256="1p2i45clmkygf8yxg3kmb4qbad2dnmbbldcxm8i6hhsc87mfb18g"; depends=[XML RCurl]; };
+  W3CMarkupValidator = derive { name="W3CMarkupValidator"; version="0.1-1"; sha256="1bxgsm6yl62adp3apvkihvvw40130z5ki49gnriv3syaw2bgwa0r"; depends=[XML RCurl]; };
   waffect = derive { name="waffect"; version="1.2"; sha256="0r5dvm0ggyxyv81hxdr1an658wkqkhqq2xaqzqpnh4sh4wbak35a"; depends=[Rcpp]; };
   waldwolf = derive { name="waldwolf"; version="0.1"; sha256="0gig3dqs8f44kdzr3abmm4wcnby2ifgqs72ck5wvny6gkwyfdvys"; depends=[]; };
   walkscoreAPI = derive { name="walkscoreAPI"; version="1.2"; sha256="1c2gfkl5yl3mkviah8s8zjnqk6lnzma1yilxgfxckdh5wywi39fx"; depends=[]; };
···
   WCQ = derive { name="WCQ"; version="0.2"; sha256="1yhkr2iazd7lh9r68xz1lh32z6r1sdnmqrjshcrm4rbwai0j3lkr"; depends=[]; };
   WDI = derive { name="WDI"; version="2.4"; sha256="0ih6d9znq6b2prb4nvq5ypyjv1kpi1vylm3zvmkdjvx95z1qsinf"; depends=[RJSONIO]; };
   weatherData = derive { name="weatherData"; version="0.4.1"; sha256="19ynb9w52ay15awaf4bqm9lj2w6pk70lyaipn46jrspwxqsvfhlc"; depends=[plyr]; };
-  weathermetrics = derive { name="weathermetrics"; version="1.0"; sha256="1ay4gcxpblqnn6zqkdnr0mgnm9r42wlmpb6k3smhbz4zca4kjfzy"; depends=[]; };
-  WebDevelopR = derive { name="WebDevelopR"; version="1.0"; sha256="0q4plv5nh6xp35j53xl207d7x0l8041ipi7k7rjrspv9vx7ncgvl"; depends=[]; };
+  webutils = derive { name="webutils"; version="0.2"; sha256="19b39jmhblvljkazzf6a55pxd74hx65cvh4s1vgx7m475rqrg6ih"; depends=[jsonlite]; };
   webvis = derive { name="webvis"; version="0.0.2"; sha256="1cdn9jrpg2sbx4dsj0xf7m0daqr7fqiw3xy1lg0i0qn9cpvi348f"; depends=[]; };
   WeightedCluster = derive { name="WeightedCluster"; version="1.2"; sha256="1d0df284fzfa34fi7b3d7f4zzm9ppyah46rj865446l5pjvl9np3"; depends=[TraMineR cluster RColorBrewer]; };
   weightedKmeans = derive { name="weightedKmeans"; version="1.2.0"; sha256="140cvl1jwwqyvcsf7pbsxh9k4bynd7c1q159pp7ia1f1sgimxafb"; depends=[lattice latticeExtra clv]; };
···
   weirs = derive { name="weirs"; version="0.23"; sha256="1kp49r5ba7ii1mr1nszbssx3fn0c2hcfpawm3a1kbh4rmhvy3frs"; depends=[]; };
   wesanderson = derive { name="wesanderson"; version="0.3"; sha256="169phanzwz3mgzqncwxc5kdshhmj922nzlbq8gz6grvh51bc7aaa"; depends=[]; };
   wfe = derive { name="wfe"; version="1.3"; sha256="16b39i60x10kw6yz44ff19h638s9lsgnz8azc76zl9b8s64jliya"; depends=[arm Matrix MASS]; };
-  wgaim = derive { name="wgaim"; version="1.4-0"; sha256="0rm9p7c7kxzzpakcm6wc7viisn2y6rwayc0r0hgpiv8fkv3n1sai"; depends=[qtl lattice]; };
+  wgaim = derive { name="wgaim"; version="1.4-3"; sha256="132i8dw2x46hihvv49ppx9ddll1clz7235y6b5cq1rzs19y7bwqd"; depends=[qtl lattice]; };
   WGCNA = derive { name="WGCNA"; version="1.41-1"; sha256="0ljqlxrkfxqb7fjdapfx9wrr7115z9rh7lms07vc94z3k1y2qdlw"; depends=[dynamicTreeCut flashClust matrixStats Hmisc foreach doParallel reshape]; };
   wgsea = derive { name="wgsea"; version="1.8"; sha256="1114wik011sm2n12bwm2bhqvdxagbhbscif45k4pgxdkahy2abpi"; depends=[]; };
   WhatIf = derive { name="WhatIf"; version="1.5-6"; sha256="02lqvirnf24jn8b2s08z5fjmpilp2z08lww1s793n3pn783adbky"; depends=[lpSolve]; };
   whisker = derive { name="whisker"; version="0.3-2"; sha256="0z4cn115gxcl086d6bnqr8afi67b6a7xqg6ivmk3l4ng1x8kcj28"; depends=[]; };
-  WhopGenome = derive { name="WhopGenome"; version="0.8.2"; sha256="145sn2ikjv1xykx5xv0djj4vainqj0v9c3lqnd1r7bygjl4n4v7c"; depends=[]; };
+  WhopGenome = derive { name="WhopGenome"; version="0.9.0"; sha256="0h750i3zpy1jff1qnp3aqyaf7z2kqi8zbdd2jgn1vcsg5y07nywd"; depends=[]; };
   widals = derive { name="widals"; version="0.5.4"; sha256="1bl59s1r4gkvq4nkf94fk7m0zvhbrszkgmig66lfxhyvk9r84fvb"; depends=[snowfall]; };
   WideLM = derive { name="WideLM"; version="0.1-1"; sha256="0spxl960pgzh0cn1gkw2ayixpi982rr85qajcdqahmn9msk877h8"; depends=[Rcpp]; };
   widenet = derive { name="widenet"; version="0.1-2"; sha256="1nimm8szbg82vg00f5c7b3f3sk0gplssbl4ggasjnh7dl621vfny"; depends=[glmnet relaxnet]; };
   wikibooks = derive { name="wikibooks"; version="0.2"; sha256="178lhri1b8if2j7y7l9kqgyvmkn4z0bxp5l4dmm97x3pav98c7ks"; depends=[]; };
-  WikipediR = derive { name="WikipediR"; version="1.0.0"; sha256="01w9km1g0cynsgsq3bv6d8ggizym211c1ksyz7w3nkq25288fcds"; depends=[httr jsonlite]; };
+  WikipediR = derive { name="WikipediR"; version="1.0.1"; sha256="154yj5syxgjlxbaxigj50w991if67hp1lbsa8mj322bvglhsgb5c"; depends=[httr jsonlite]; };
   WilcoxCV = derive { name="WilcoxCV"; version="1.0-2"; sha256="1kbb7ikgnlxybmvqrbn4cd8xnqrkwipk4xd6yja1xsi39a109xzl"; depends=[]; };
-  wild1 = derive { name="wild1"; version="1.09"; sha256="1ydjz3f4z6fdw4wynyd64bwwm68vh0xqxvg6zw8z7pdg8y2h89zl"; depends=[chron survival sp maptools spatstat ICSNP ks]; };
+  wildlifeDI = derive { name="wildlifeDI"; version="0.1"; sha256="16262cb02d3w2lkaqns5zhzk9wm25lfcbwsgcav2hs93pmdx2dma"; depends=[sp rgeos adehabitatLT]; };
+  windex = derive { name="windex"; version="1.0"; sha256="0ci10x6mm5i03j05fyadxa0ic0ngpyp5nsn05p9m7v1is5jhxci0"; depends=[geiger ape scatterplot3d]; };
   witness = derive { name="witness"; version="1.2"; sha256="1pccn7czm1q0w31zpmky5arkcbnfl94gh1nnkf8kmcccdrr3lxph"; depends=[]; };
   wle = derive { name="wle"; version="0.9-9"; sha256="032zqfqg6ghg56zgr005g8q94zskmbzv1p08lxv227ikkbmnwn53"; depends=[circular]; };
   WMCapacity = derive { name="WMCapacity"; version="0.9.6.6"; sha256="19x6l06srh59q1cnixisa5fgm5hkpq35h9zfmdnfaj3xl8pxhzyn"; depends=[gtools gWidgets gWidgetsRGtk2 coda cairoDevice RGtk2 XML]; };
   WMDB = derive { name="WMDB"; version="1.0"; sha256="10wdjy3g2qg975yf1dhy09w9b8rs3w6iszhbzqx9igfqvi8isrr1"; depends=[]; };
   wmtsa = derive { name="wmtsa"; version="2.0-0"; sha256="0y2bv166xwwpb1wf6897qybyf84f34qjsmygdbv90r637c050yk5"; depends=[splus2R ifultools MASS]; };
-  wnominate = derive { name="wnominate"; version="0.98"; sha256="1c3g89f7xl781m8lqy730vlb6p5dxq16vgll80jmsx8p7fsy6pb4"; depends=[pscl]; };
+  wnominate = derive { name="wnominate"; version="0.99"; sha256="19pis0p4kkwyddn8f93p4ff7l1hvcdr7m3hrv4bzmm9nd8iy8mk1"; depends=[pscl]; };
   wombsoft = derive { name="wombsoft"; version="2.0"; sha256="11ri29vj1yg2lpr6vf1i45w20hqh8dswj04ylbq0vy27cwmxqljd"; depends=[]; };
   wordcloud = derive { name="wordcloud"; version="2.5"; sha256="1ajqdkm8h1wid3d41zd8v7xzf2swid998w31zrghd45a5lcp7qcm"; depends=[RColorBrewer slam Rcpp]; };
   wordmatch = derive { name="wordmatch"; version="1.0"; sha256="0zscp361qf79y1zsliga18hc7wj36cnydshrqb9pv67b65njrznz"; depends=[plyr reshape2]; };
-  wordnet = derive { name="wordnet"; version="0.1-9"; sha256="1cwrdfdv1ma429na9y2yci9vrms8vfqqwj9qkcq8hzkm02yzkdsf"; depends=[rJava]; };
+  wordnet = derive { name="wordnet"; version="0.1-10"; sha256="0s68hkyk28ry0g96d4gxy7r9nywypx7ymqpzadlb79dls32i20lz"; depends=[rJava]; };
   WordPools = derive { name="WordPools"; version="1.0-2"; sha256="1izs4cymf2xy1lax85rvsgsgi05ygf0ibi9gzxc96sbgvy4m78kf"; depends=[]; };
   wpp2008 = derive { name="wpp2008"; version="1.0-1"; sha256="0gd3vjw1fpzhp3qlf1jpc24f76i0pxsjs5pb1v3k2si6df7q4msd"; depends=[]; };
   wpp2010 = derive { name="wpp2010"; version="1.2-0"; sha256="1h87r1cn4lnx80dprvawsyzfkriscqjgr27gvv7n19wvsx8qd57k"; depends=[]; };
-  wpp2012 = derive { name="wpp2012"; version="2.2-0"; sha256="1wsdx1vywydbwd53fai4sapisln10qxi6jj9yvyy92gg14hcx3ff"; depends=[]; };
-  wppExplorer = derive { name="wppExplorer"; version="1.3-0"; sha256="0bki4s6ihl752d7y4ckvb056jlvcpqmp8fc7a7rvdbxw0d66sfh4"; depends=[shiny plyr reshape2 googleVis wpp2012 Hmisc ggplot2]; };
+  wpp2012 = derive { name="wpp2012"; version="2.2-1"; sha256="00283s4r36zzwn67fydrl7ldg6jhn14qkf47h0ifmsky95bd1n5k"; depends=[]; };
+  wppExplorer = derive { name="wppExplorer"; version="1.4-0"; sha256="1dyg9482h9854nx526151rclh3m45g78x36ll8xw78ywnj9xrjzj"; depends=[shiny plyr reshape2 googleVis wpp2012 Hmisc ggplot2]; };
   wq = derive { name="wq"; version="0.4-1"; sha256="0a46islpzpbkx6c7mbn6q787mh9mb6sy4k46lz8s63fh2h7p0szk"; depends=[zoo]; };
   WrightMap = derive { name="WrightMap"; version="1.1"; sha256="0dmximp549gr37ps56vz8mnlii7753dc5v0wl3s78cymjmnmyr0z"; depends=[]; };
   write_snns = derive { name="write.snns"; version="0.0-4.2"; sha256="0sxg7z8rnh4lssbivkrfxldv4ivy37wkndzzndpbvq2gbvbjnp4l"; depends=[]; };
-  WriteXLS = derive { name="WriteXLS"; version="3.5.0"; sha256="0b5md3jy18wrigadqjzfnrpvm35nn0aa62zsq5d72k5fr7lbh3gr"; depends=[]; };
+  WriteXLS = derive { name="WriteXLS"; version="3.5.1"; sha256="0grhwwlibdpvzjlm1vc5ykl54jcz0jmg6rkhis00rjn5yqccx0in"; depends=[]; };
+  WRS2 = derive { name="WRS2"; version="0.2-0"; sha256="0ci1a93z25rymy9fs4by9qbbkx6nn3iwzvkwsap3bm7gg7g6dpb2"; depends=[MASS reshape]; };
   wrspathrow = derive { name="wrspathrow"; version="0.1"; sha256="1xkh12aal85qhk8d0pdj2qbi6pp4jnr6zbxkhdw2zwav57ly3f4i"; depends=[wrspathrowData sp raster rgeos rgdal]; };
   wrspathrowData = derive { name="wrspathrowData"; version="1.0"; sha256="0a1aggcll0fmkwfg4h7rs4j5h3v1bh95dkbriwrb0bx0cikg63x3"; depends=[]; };
   wskm = derive { name="wskm"; version="1.4.11"; sha256="1pmsir4msy95x080k463f34ms4vm8nayr21g2cd50mmzffbm5mwl"; depends=[lattice latticeExtra clv]; };
···
   x12 = derive { name="x12"; version="1.5.0"; sha256="0z5hsq0rv71jl9102fqci2wyklmqxly0nc4h7ky845dpvqfrg9yv"; depends=[stringr]; };
   x12GUI = derive { name="x12GUI"; version="0.12.0"; sha256="0vks6m0jck6sl17z9qcw1p1wv5iqdblnmssmfrfjqv626sb9jsn6"; depends=[x12 Hmisc RGtk2 cairoDevice lattice stringr]; };
   XBRL = derive { name="XBRL"; version="0.99.12"; sha256="0n51hmhzgx2j1xff5v57p3n30sab580hwdjsqr0vaghqaa6xwpwg"; depends=[Rcpp]; };
+  x_ent = derive { name="x.ent"; version="0.0.4"; sha256="0ln40cnlzfc1w1vs4vrjndhy0fii6hgjhy2qyrcibyzf0lkwf18s"; depends=[opencpu rJava stringr xtable jsonlite venneuler]; };
   xergm = derive { name="xergm"; version="1.1"; sha256="132g3gyzfasiv58dxni893ikj5dy1pzbff2rnjyqijd10zngw9rg"; depends=[ergm statnet statnet_common network sna texreg Matrix boot coda ROCR igraph vegan lme4]; };
+  xgboost = derive { name="xgboost"; version="0.3-2"; sha256="1sp0rl4ixdcqljcf12cc517vnwj851g88xla641nfl0qbcj8b7n7"; depends=[Matrix]; };
   xgobi = derive { name="xgobi"; version="1.2-15"; sha256="03ym5mm16rb1bdwrymr393r3xgprp0ign45ryym3g0x2zi8dy557"; depends=[]; };
-  xgrid = derive { name="xgrid"; version="1.0-1"; sha256="1xg3frzybck2lmqsxnw448rw4si55k3ygwdkn88d1zfc6llswz9p"; depends=[]; };
   xhmmScripts = derive { name="xhmmScripts"; version="1.1"; sha256="1qryyb34jx9c64l8bnwp40b08y81agdj5w0icj8dk052x50ip1hl"; depends=[gplots plotrix]; };
   XiMpLe = derive { name="XiMpLe"; version="0.03-21"; sha256="1j387jzxh0z9dmhvc0kpjjjzf781sgrw57nwzdqwx6bn09bw509d"; depends=[]; };
   xkcd = derive { name="xkcd"; version="0.0.3"; sha256="086kdy4dp7312pxv7zpx3qf8rk91lv0snrhipzcmcn1m4q77q9z2"; depends=[Hmisc ggplot2]; };
-  XLConnect = derive { name="XLConnect"; version="0.2-8"; sha256="026ilqji5kck0azxi9zxry5032kakinjgqsmzxd8z0cwhgmfgq1k"; depends=[XLConnectJars rJava]; };
-  XLConnectJars = derive { name="XLConnectJars"; version="0.2-8"; sha256="1ak0wi07hk8bwi418jy43x5pq57a709xqg6njkc4f394jf8rr60s"; depends=[rJava]; };
+  XLConnect = derive { name="XLConnect"; version="0.2-9"; sha256="1lbbvl4jx42cvc8paswc6p8vf8aqqhf3v52a9fhpv79lcizch558"; depends=[XLConnectJars rJava]; };
+  XLConnectJars = derive { name="XLConnectJars"; version="0.2-9"; sha256="0js79297himq628cwx5cc3pcq3iv6p16bn4bpd5diyjaya4x27g3"; depends=[rJava]; };
   xlsx = derive { name="xlsx"; version="0.5.7"; sha256="0qxkdpf1dvi0x7fy65abjx2j60rdx7fv5yi8l2wdm0f2631pnwin"; depends=[rJava xlsxjars]; };
-  xlsxjars = derive { name="xlsxjars"; version="0.6.0"; sha256="0mjfvd433iz742gn3avaq48172yi5hhd0ajc3v22y1j4k9w82pr7"; depends=[rJava]; };
-  Xmisc = derive { name="Xmisc"; version="0.1.0"; sha256="1iyv9gp7fw3r7s3v9srd799nhwgpn5851v3n2xfwpcvj9kczrd5r"; depends=[]; };
+  xlsxjars = derive { name="xlsxjars"; version="0.6.1"; sha256="1rka5smm7yqnhhlblpihhciydfap4i6kjaa4a7isdg7qjmzm3h9p"; depends=[rJava]; };
+  Xmisc = derive { name="Xmisc"; version="0.2.1"; sha256="11gwlcyxhz1p50m68cnqrxmisdk99v8vrsbvyr7k67f0kvsznzs1"; depends=[]; };
   XML = derive { name="XML"; version="3.98-1.1"; sha256="0n9i6746211wihglbpsgalj2cyvggn4rv6a4fbavqwnjw3h1hwwl"; depends=[pkgs.libxml2]; };
   XML2R = derive { name="XML2R"; version="0.0.6"; sha256="0azfh950r2b7ck3n1vzk3mdll7zy844nx3mbk676jxnj8gg7nxk5"; depends=[XML RCurl plyr]; };
   XNomial = derive { name="XNomial"; version="1.0.1"; sha256="134bwglqhgah7v3w6ir65dch2dwp5h4vldw521ba74l5v9b2j2h4"; depends=[]; };
   xoi = derive { name="xoi"; version="0.61-1"; sha256="0ypy0rb0f0bns41vjzyln04k3hypgr3wysqbdi0b0r14ip5rb47k"; depends=[qtl]; };
   xpose4 = derive { name="xpose4"; version="4.5.0"; sha256="136a1lq9raba731rxy55dy9mw8rs1rha0940b85ljr70mvpmzmqd"; depends=[lattice gam Hmisc survival]; };
-  xtable = derive { name="xtable"; version="1.7-3"; sha256="1rsfq0acf1pvpci3jq9fbhsv6ws4d46yap8m2xjk1cr463m9gdcc"; depends=[]; };
+  xtable = derive { name="xtable"; version="1.7-4"; sha256="1fvx4p058ygsyj9f4xb9k5h0fdi4zibadqrsn4qbx4am30qrlqj7"; depends=[]; };
   xtermStyle = derive { name="xtermStyle"; version="2.2-4"; sha256="0m1lwr7smym7aczcqqgqj5bx46j38ymmljilxl54bby188qhfcyz"; depends=[]; };
   xts = derive { name="xts"; version="0.9-7"; sha256="163hzcnxrdb4lbsnwwv7qa00h4qlg4jm289acgvbg4jbiywpq7zi"; depends=[zoo]; };
   yacca = derive { name="yacca"; version="1.1"; sha256="0wg2wgvh1najmccmgzyigj11mshrdb8w4r2pqq360dracpn0ak6x"; depends=[]; };
···
   yhatr = derive { name="yhatr"; version="0.12.1"; sha256="1rps8y7i5fg0xrkjigjx0xa5cwj5b4xf9186dv8valzhbqkvvba1"; depends=[httr RCurl rjson plyr jsonlite stringr]; };
   YieldCurve = derive { name="YieldCurve"; version="4.1"; sha256="0w47j8v2lvarrclnixwzaq98nv1xh2m48q5xvnmk7j9nsv2l3p68"; depends=[xts]; };
   ykmeans = derive { name="ykmeans"; version="1.0"; sha256="0xfji2fmslvc059kk3rwkv575ffzl787sa9d4vw5hxnsmkn8lq50"; depends=[plyr foreach]; };
-  YourCast = derive { name="YourCast"; version="1.6.1"; sha256="03aq01amg4cxnxcxnsd1hxkx63w323f8ldkibl1f826gd7lbcqf1"; depends=[ggplot2 gridExtra lattice foreign reshape2]; };
+  YourCast = derive { name="YourCast"; version="1.6.2"; sha256="0vl37svwky6j1am235ac2wk1fdmh509w0h4m7y93lpjhzj6m8c1p"; depends=[ggplot2 gridExtra lattice foreign reshape2]; };
   YplantQMC = derive { name="YplantQMC"; version="0.5"; sha256="0x3ndpamj1ayy1svh9q8pwmfnar9zyw5i6h1k1hqwc92h0k6jsmz"; depends=[rgl geometry LeafAngle devtools]; };
   YPmodel = derive { name="YPmodel"; version="1.1"; sha256="036f5y8qrcxglblgnaa15xzlz9pxbhbysrbr2gl66h9dvcd6kavr"; depends=[]; };
   YuGene = derive { name="YuGene"; version="1.1.2"; sha256="0sy0bh49l0fajh1z88mpb4f0k3hsf3kd1vxv731qhpxcrc3pz09b"; depends=[mixOmics]; };
-  yuima = derive { name="yuima"; version="1.0.24"; sha256="1lr43man9cv8xknwbmaqkz54p3g5znwqyvxjwd75hyj82fa63j60"; depends=[zoo expm]; };
-  zCompositions = derive { name="zCompositions"; version="1.0.1"; sha256="1kjg03cgpi6xjqg0hnjqragyn7yy56pzf2wfwpkrxb5vy92kyjpq"; depends=[MASS NADA truncnorm]; };
+  yuima = derive { name="yuima"; version="1.0.36"; sha256="1rz96v0c9sikjvm3i8x887v1bkiixps691vclpd6i4cchyayx63h"; depends=[zoo expm cubature mvtnorm]; };
+  zCompositions = derive { name="zCompositions"; version="1.0.3"; sha256="0lxy201ys9dvv8c09q8wbks1c2jkjyd1bbrxhjr7zi9j7m0parl7"; depends=[MASS NADA truncnorm]; };
   ZeBook = derive { name="ZeBook"; version="0.5"; sha256="1djwda6hzx6kpf4dbmw0fkfq39fqh80aa3q9c6p41qxzcpim27dw"; depends=[triangle deSolve]; };
   Zelig = derive { name="Zelig"; version="4.2-1"; sha256="1hhr9jx25fdnkqwyj2bkgrvqlah4z2drphmb5mdn1an2p2g23v9z"; depends=[boot MASS sandwich]; };
   ZeligChoice = derive { name="ZeligChoice"; version="0.8-1"; sha256="1ql9yq83ipf0vpv63fpckylwq4jrcbfjgjm77f5ndkd83gqjzrmg"; depends=[Zelig VGAM]; };
···
   ZeligMultilevel = derive { name="ZeligMultilevel"; version="0.7-1"; sha256="00zlambykds4z1c5kx3rpla1kllyp96cxwvbc5lalwdb9i48pp3s"; depends=[Zelig lme4]; };
   zendeskR = derive { name="zendeskR"; version="0.4"; sha256="06cjwk08w3x6dx717123psinid5bx6c563jnfn890373jw6xnfrk"; depends=[RCurl rjson]; };
   zic = derive { name="zic"; version="0.8.1"; sha256="05mn894qdx6k7158dbsjy2b49n0gz5xnmlixr2dhkxc12ydj6zs5"; depends=[Rcpp RcppArmadillo coda]; };
-  ZIM = derive { name="ZIM"; version="1.0.1"; sha256="1y3vlxw4ybl2s269r3sbi156y4ffg83kfs152fsxc8q4caygc379"; depends=[MASS]; };
+  ZIM = derive { name="ZIM"; version="1.0.2"; sha256="1n4dc0as011gzaac153zq1dfbg1axvmf9znlmhl7xjj4dz4966qm"; depends=[MASS]; };
   zipcode = derive { name="zipcode"; version="1.0"; sha256="1lvlf1h5fv412idpdssjfh4fki933dm5nhr41ppl1mf45b9j7azn"; depends=[]; };
   zipfR = derive { name="zipfR"; version="0.6-6"; sha256="1y3nqfjg5m89mdvcmqwjmwlc8p3hpcqnwv4ji1a7ggg4n63lwl3j"; depends=[]; };
   zoeppritz = derive { name="zoeppritz"; version="1.0-4"; sha256="0mjg55jc5b8h2jj6cy8b34a4q7jhhx73xns0v2dpfkq4kmilsv5p"; depends=[]; };

pkgs/development/tools/haskell/cabal2nix/default.nix

···
 
 cabal.mkDerivation (self: {
   pname = "cabal2nix";
-  version = "1.70";
-  sha256 = "0jc66x6p6blcz1pk4pkdh93dx17658pr0i5h4w3zynv4c2jgy138";
+  version = "1.71";
+  sha256 = "1hhw1i4gqsd73mrj60sza36dqfz32ydh70sk9182m4wpgpsrwxvr";
   isLibrary = false;
   isExecutable = true;
   buildDepends = [

pkgs/development/tools/haskell/ghcid/default.nix

···
 # This file was auto-generated by cabal2nix. Please do NOT edit manually!
 
-{ cabal, cmdargs, filepath, tasty, tastyHunit, time }:
+{ cabal, cmdargs, extra, filepath, tasty, tastyHunit, terminalSize
+, time
+}:
 
 cabal.mkDerivation (self: {
   pname = "ghcid";
-  version = "0.2";
-  sha256 = "1g0jwj8s0rgwrdgyn6dwrqhf9v4kck5kfr4ggmp9c0mjjyfxq6pf";
+  version = "0.3.1";
+  sha256 = "09dyynqa42q6rcms8pghlyih8a3fahb5fbhc500grqc094kgfs7c";
   isLibrary = true;
   isExecutable = true;
-  buildDepends = [ cmdargs filepath time ];
-  testDepends = [ cmdargs filepath tasty tastyHunit time ];
+  buildDepends = [ cmdargs extra filepath terminalSize time ];
+  testDepends = [
+    cmdargs extra filepath tasty tastyHunit terminalSize time
+  ];
   doCheck = false;
   meta = {
     homepage = "https://github.com/ndmitchell/ghcid#readme";

pkgs/development/tools/haskell/hslogger/default.nix

···
 
 cabal.mkDerivation (self: {
   pname = "hslogger";
-  version = "1.2.4";
-  sha256 = "0r0c7wqz49lzxg7sakkw6nwmxnyzhqscxvnxiqwkwsgv3q2sh3wc";
+  version = "1.2.6";
+  sha256 = "0yqw7824bn8vb9iynx8lkgswxd0nz484k4bvcwd02wvakbbfawkk";
   isLibrary = true;
   isExecutable = true;
   buildDepends = [ mtl network time ];

pkgs/development/tools/haskell/ihaskell/default.nix

···
 # This file was auto-generated by cabal2nix. Please do NOT edit manually!
-# This file was later edited to add patches, disable testing.
-# Also patch the profile config to point to the ihaskell kernel exe
 
 { cabal, aeson, base64Bytestring, cereal, classyPrelude, cmdargs
 , filepath, ghcParser, ghcPaths, haskeline, haskellSrcExts, here
 , hlint, hspec, HTTP, HUnit, MissingH, monoTraversable, mtl, parsec
 , random, setenv, shelly, split, stm, strict, systemArgv0
 , systemFilepath, tar, text, transformers, unorderedContainers
-, utf8String, uuid, vector, zeromq4Haskell, fetchpatch
+, utf8String, uuid, vector, zeromq4Haskell
 }:
 
 cabal.mkDerivation (self: {
   pname = "ihaskell";
-  version = "0.4.2.0";
-  sha256 = "012rmasdc167w6gl18ysr53737j4p4afk0qcsv81hif92vvg5j1c";
+  version = "0.4.3.0";
+  sha256 = "1k6i56cdzv5ikci20brq7qj07nqdpzkfj7xr69lh1gvx7xb24ida";
   isLibrary = true;
   isExecutable = true;
-  patches = [ (fetchpatch { url = "https://github.com/gibiansky/IHaskell/pull/296.patch"; sha256 = "1h9gxq9l3j949prcwqkdkrc3q3sxai4b345hfp5hfi0mhfbysfn6"; }) ];
-  prePatch = ''
-    tar xvf profile/profile.tar -C profile
-    sed -i -e '1iexe = "'$out'/bin/IHaskell".replace(" ", "\\ ")\' profile/ipython_config.py
-  '';
-  doCheck = false;
   buildDepends = [
     aeson base64Bytestring cereal classyPrelude cmdargs filepath
     ghcParser ghcPaths haskeline haskellSrcExts here hlint hspec HTTP
···
     strict systemArgv0 systemFilepath tar text transformers
     unorderedContainers utf8String uuid vector zeromq4Haskell
   ];
-  testDepends = [ # let's keep these anyway
+  testDepends = [
     aeson base64Bytestring cereal classyPrelude cmdargs filepath
     ghcParser ghcPaths haskeline haskellSrcExts here hlint hspec HTTP
     HUnit MissingH monoTraversable mtl parsec random setenv shelly
     split stm strict systemArgv0 systemFilepath tar text transformers
     unorderedContainers utf8String uuid vector zeromq4Haskell
   ];
-  postInstall = ''
-    patchShebangs .
-  '';
   jailbreak = true;
-  meta = with self.stdenv.lib; {
+  doCheck = false;
+  meta = {
     homepage = "http://gibiansky.github.io/IHaskell/";
     description = "A Haskell backend kernel for the IPython project";
-    license = licenses.mit;
+    license = self.stdenv.lib.licenses.mit;
     platforms = self.ghc.meta.platforms;
-    hydraPlatforms = self.stdenv.lib.platforms.none;
-    maintainers = with maintainers; [ edwtjo ];
+    maintainers = with self.stdenv.lib.maintainers; [ edwtjo ];
   };
 })

pkgs/games/tibia/default.nix

···
 with stdenv.lib;
 assert stdenv.isi686;
 stdenv.mkDerivation {
-  name = "tibia-10.59";
+  name = "tibia-10.61";
 
   src = fetchurl {
-    url = http://static.tibia.com/download/tibia1059.tgz;
-    sha256 = "0g9f4g7d461yj47rsiv5fpvh4wry9rsx4j6q1jajq4liv5xdlhl7";
+    url = http://static.tibia.com/download/tibia1061.tgz;
+    sha256 = "0dyhzhklarx9zj281d5pjxvfd1r740wdg79b07dj8ll8zwvxfqcz";
   };
 
   shell = stdenv.shell;

pkgs/misc/emulators/dolphin-emu/default.nix

···
 
   enableParallelBuilding = true;
 
-  buildInputs = [ stdenv pkgconfig cmake bluez ffmpeg libao mesa gtk2 glib
+  buildInputs = [ pkgconfig cmake bluez ffmpeg libao mesa gtk2 glib
                   gettext libpthreadstubs libXrandr libXext readline openal
                   libXdmcp portaudio SDL wxGTK30 pulseaudio ];
 

pkgs/misc/emulators/dolphin-emu/master.nix

···
 , pulseaudio ? null }:
 
 stdenv.mkDerivation rec {
-  name = "dolphin-emu-20141002";
+  name = "dolphin-emu-20141101";
   src = fetchgit {
     url = git://github.com/dolphin-emu/dolphin.git;
-    rev = "ed7f0739ae31c07c31d013964986c549317aba6e";
-    sha256 = "01qwlkh3c0ij97zycq0v4kclxmnlbwcc1bmvjzl4cbczhxbbx4hk";
+    rev = "9daaf94f3c8caf71dab16c7e591ce7905c1416c4";
+    sha256 = "1n71by34mrgdxcr8c5bsbpy9azi62512knp5sjgzq6sfwzgy40d8";
     fetchSubmodules = false;
   };
 
···
 
   enableParallelBuilding = true;
 
-  buildInputs = [ stdenv pkgconfig cmake bluez ffmpeg libao mesa gtk2 glib
+  buildInputs = [ pkgconfig cmake bluez ffmpeg libao mesa gtk2 glib
                   gettext libpthreadstubs libXrandr libXext readline openal
                   git libXdmcp portaudio SDL wxGTK30 pulseaudio ];
 

pkgs/os-specific/linux/kernel/linux-3.14.nix

···
 { stdenv, fetchurl, ... } @ args:
 
 import ./generic.nix (args // rec {
+  # Remember to update grsecurity!
   version = "3.14.23";
   extraMeta.branch = "3.14";
 

pkgs/os-specific/linux/kernel/linux-3.17.nix

···
 { stdenv, fetchurl, ... } @ args:
 
 import ./generic.nix (args // rec {
+  # Remember to update grsecurity!
   version = "3.17.2";
   extraMeta.branch = "3.17";
 

pkgs/os-specific/linux/kernel/patches.nix

···
   };
 
   grsecurity_stable = grsecPatch
-    { kversion  = "3.14.22";
-      revision  = "201410250026";
+    { kversion  = "3.14.23";
+      revision  = "201410312212";
       branch    = "stable";
-      sha256    = "1yvzdykg7dkza4iwhwlrjw8p5k6pyxy91z7xckbq46vbj8xikpk2";
+      sha256    = "19ghha8khr03jwjp2ax1fi9hg7535gwnyv0in1dr4mz5cy23scsm";
     };
 
   grsecurity_unstable = grsecPatch
-    { kversion  = "3.17.1";
-      revision  = "201410281754";
+    { kversion  = "3.17.2";
+      revision  = "201410312213";
       branch    = "test";
-      sha256    = "0igpbk10j1iiwgc7v9rkq1hfg9nb98f0fw6zs2qs7d9j1gx3xks5";
+      sha256    = "0jk0f6mn74hcx98jpdivgs5a336ng1r41fhhdjbyv4i733hid25a";
     };
 
   grsec_fix_path =

pkgs/servers/nosql/mongodb/default.nix

···
 
 with stdenv.lib;
 
-let version = "2.6.4";
+let version = "2.6.5";
     system-libraries = [
       "pcre"
       "boost"
···
 
   src = fetchurl {
     url = "http://downloads.mongodb.org/src/mongodb-src-r${version}.tar.gz";
-    sha256 = "1h4rrgcb95234ryjma3fjg50qsm1bnxjx5ib0c3p9nzmc2ji2m07";
+    sha256 = "0v58kyp4cj4yag0djnswfiifrcll5y7x772y99b3afg89xicpmjm";
   };
 
   nativeBuildInputs = [ scons ];

pkgs/servers/sql/postgresql/9.4beta3.nix

···
+{ stdenv, fetchurl, zlib, readline, libossp_uuid }:
+
+with stdenv.lib;
+
+let version = "9.4beta3"; in
+
+stdenv.mkDerivation rec {
+  name = "postgresql-${version}";
+
+  src = fetchurl {
+    url = "mirror://postgresql/source/v${version}/${name}.tar.bz2";
+    sha256 = "0pdawsmrzwgf2c4g18xlgzv6q34kd8q2p1nxag0xaw4sbdmdilas";
+  };
+
+  buildInputs = [ zlib readline ] ++ optionals (!stdenv.isDarwin) [ libossp_uuid ];
+
+  enableParallelBuilding = true;
+
+  makeFlags = [ "world" ];
+
+  configureFlags = optional (!stdenv.isDarwin)
+    ''
+      --with-ossp-uuid
+    '';
+
+  patches = [ ./disable-resolve_symlinks-94.patch ./less-is-more.patch ];
+
+  installTargets = [ "install-world" ];
+
+  LC_ALL = "C";
+
+  passthru = {
+    inherit readline;
+    psqlSchema = "9.4";
+  };
+
+  meta = {
+    homepage = http://www.postgresql.org/ ;
+    description = "A powerful, open source object-relational database system";
+    license = stdenv.lib.licenses.postgresql;
+    maintainers = with stdenv.lib.maintainers; [ aristid ocharles ];
+    hydraPlatforms = stdenv.lib.platforms.linux;
+  };
+}

pkgs/tools/compression/pbzip2/default.nix

···
 {stdenv, fetchurl, bzip2}:
 
-let name = "pbzip2";
-    version = "1.0.5";
+let major = "1.1";
+    version = "${major}.9";
 in
-stdenv.mkDerivation {
-  name = name + "-" + version;
+stdenv.mkDerivation rec {
+  name = "pbzip2-${version}";
 
   src = fetchurl {
-    url = "http://compression.ca/${name}/${name}-${version}.tar.gz";
-    sha256 = "0vc9r6b2djhpwslavi2ykv6lk8pwf4lqb107lmapw2q8d658qpa1";
+    url = "https://launchpad.net/pbzip2/${major}/${version}/+download/${name}.tar.gz";
+    sha256 = "1i7rql77ac33lz7lzrjyl9b16mqizmdkb8hv295a493f7vh1nhmx";
   };
 
   buildInputs = [ bzip2 ];
···
       make install PREFIX=$out
   '';
 
-  meta = {
+  meta = with stdenv.lib; {
     homepage = http://compression.ca/pbzip2/;
     description = "A parallel implementation of bzip2 for multi-core machines";
-    license = "free";
-    maintainers = with stdenv.lib.maintainers; [viric];
-    platforms = with stdenv.lib.platforms; linux;
+    license = licenses.bsd2;
+    maintainers = with maintainers; [viric];
+    platforms = with platforms; linux;
   };
 }

pkgs/tools/compression/pxz/_SC_ARG_MAX.patch

···
+From b8f9827fc4de9296c7a6f5e6fdac46e070cd6cb4 Mon Sep 17 00:00:00 2001
+From: Igor Pashev <[e-mail]>
+Date: Sat, 1 Nov 2014 18:10:05 +0300
+Subject: [PATCH] Fixed crash on Linux when stack size is unlimited
+
+---
+ pxz.c | 7 +++++--
+ 1 file changed, 5 insertions(+), 2 deletions(-)
+
+diff --git a/pxz.c b/pxz.c
+index 9cb843e..52713e2 100644
+--- a/pxz.c
++++ b/pxz.c
+@@ -65,7 +65,7 @@ FILE **ftemp;
+ char str[0x100];
+ char buf[BUFFSIZE];
+ char *xzcmd;
+-size_t xzcmd_max;
++const size_t xzcmd_max = 10240;
+ 
+ unsigned opt_complevel = 6, opt_stdout, opt_keep, opt_threads, opt_verbose;
+ unsigned opt_force, opt_stdout;
+@@ -243,9 +243,12 @@ int main( int argc, char **argv ) {
+ 	lzma_filter filters[LZMA_FILTERS_MAX + 1];
+ 	lzma_options_lzma lzma_options;
+ 	
+-	xzcmd_max = sysconf(_SC_ARG_MAX);
+ 	page_size = sysconf(_SC_PAGE_SIZE);
+ 	xzcmd = malloc(xzcmd_max);
++	if (!xzcmd) {
++		fprintf(stderr, "Failed to allocate %lu bytes for xz command.\n", xzcmd_max);
++		return -1;
++	}
+ 	snprintf(xzcmd, xzcmd_max, XZ_BINARY);
+ 	
+ 	parse_args(argc, argv);

pkgs/tools/compression/pxz/default.nix

···
+{ stdenv, fetchgit, xz, lzma }:
+
+let name = "pxz";
+    version = "4.999.9beta+git";
+in
+stdenv.mkDerivation {
+  name = name + "-" + version;
+
+  src = fetchgit {
+    url = "https://github.com/jnovy/pxz.git";
+    rev = "ae808463c2950edfdedb8fb49f95006db0a18667";
+    sha256 = "0na2kw8cf0qd8l1aywlv9m3xrxnqlcwxfdwp3f7x9vxwqx3k32kc";
+  };
+
+  buildInputs = [ lzma ];
+
+  patches = [ ./_SC_ARG_MAX.patch ];
+
+  buildPhase = ''
+    gcc -o pxz pxz.c -llzma \
+        -fopenmp -D_FILE_OFFSET_BITS=64 -D_LARGEFILE_SOURCE -O2 \
+        -DPXZ_BUILD_DATE=\"nixpkgs\" \
+        -DXZ_BINARY=\"${xz}/bin/xz\" \
+        -DPXZ_VERSION=\"${version}\"
+  '';
+
+  installPhase = ''
+    mkdir -p $out/bin $out/share/man/man1
+    cp pxz $out/bin
+    cp pxz.1 $out/share/man/man1
+  '';
+
+  meta = {
+    homepage = "https://jnovy.fedorapeople.org/pxz/";
+    license = stdenv.lib.licenses.gpl2Plus;
+    maintainers = with stdenv.lib.maintainers; [pashev];
+    description = ''Parallel XZ is a compression utility that takes advantage of
+      running LZMA compression of different parts of an input file on multiple
+      cores and processors simultaneously. Its primary goal is to utilize all
+      resources to speed up compression time with minimal possible influence
+      on compression ratio'';
+  };
+}

pkgs/tools/misc/youtube-dl/default.nix

···
 { stdenv, fetchurl, python, zip }:
 
 let
-  version = "2014.10.25";
+  version = "2014.10.30";
 in
 stdenv.mkDerivation rec {
   name = "youtube-dl-${version}";
 
   src = fetchurl {
     url = "http://youtube-dl.org/downloads/${version}/${name}.tar.gz";
-    sha256 = "0llgallsvvwxr52kzpd91rz1vxm4drj2jzns30jfdqv81a9d98wa";
+    sha256 = "1fl8lf8ddg2vqjzzhh9idrmva10x9hc6n78q3vbgh16gvpg35c3y";
   };
 
   buildInputs = [ python ];

pkgs/tools/package-management/nox/default.nix

···
-{ lib, pythonPackages, git, fetchgit, makeWrapper, nix }:
+{ lib, pythonPackages, fetchurl, makeWrapper, nix }:
 
 pythonPackages.buildPythonPackage rec {
-  name = "nox-0.0.1";
+  name = "nox-${version}";
+  version = "0.0.1";
   namePrefix = "";
 
-  src = fetchgit {
-    url = "git://github.com/madjar/nox.git";
-    rev = "e5a4dbe5d11c3258e3038b4ae6f49d53f02d76cd";
-    sha256 = "25d0ae9eeb6387bb45cbda8da08760ffef6a1661ebd106c537b468c93e66c035";
-    leaveDotGit = true; # required by pbr
+  src = fetchurl {
+    url = "https://pypi.python.org/packages/source/n/nix-nox/nix-nox-${version}.tar.gz";
+    sha256 = "1s1jhickdhym70qrb5h4qxq1mvkpwgdppqpfb2jnpfaf1az6c207";
   };
 
-  buildInputs = [ git pythonPackages.pbr makeWrapper ];
+  buildInputs = [ pythonPackages.pbr makeWrapper ];
 
   pythonPath = with pythonPackages; [
       dogpile_cache

pkgs/tools/security/mbox/default.nix

···
       homepage = http://pdos.csail.mit.edu/mbox/;
       maintainers = with maintainers; [ emery ];
       license = licenses.bsd3;
-      platforms = platforms.linux;
+      platforms = [ "x86_64-linux" ];
     };
 
-}
+}

pkgs/tools/security/pwgen/default.nix

···
 {stdenv, fetchurl}:
 stdenv.mkDerivation {
-  name = "pwgen-2.06";
+  name = "pwgen-2.07";
 
   src = fetchurl {
-    url = mirror://sourceforge/pwgen/pwgen-2.06.tar.gz;
-    sha256 = "0m1lhkcyizisksr1vlqysjkickrca9qwqkkx6vkv4zhg7ag8qnb1";
+    url = mirror://sourceforge/pwgen/pwgen-2.07.tar.gz;
+    sha256 = "0mhmw700kkh238fzivcwnwi94bj9f3h36yfh3k3j2v19b0zmjx7b";
   };
   meta = {
     description = "Password generator which creates passwords which can be easily memorized by a human";

pkgs/top-level/all-packages.nix

···
   freetds = callPackage ../development/libraries/freetds { };
 
   frescobaldi = callPackage ../misc/frescobaldi {};
-  
+
   ftgl = callPackage ../development/libraries/ftgl { };
 
   ftgl212 = callPackage ../development/libraries/ftgl/2.1.2.nix { };
···
   partimage = callPackage ../tools/backup/partimage { };
 
   pigz = callPackage ../tools/compression/pigz { };
+
+  pxz = callPackage ../tools/compression/pxz { };
 
   haproxy = callPackage ../tools/networking/haproxy { };
 
···
   pdfread = callPackage ../tools/graphics/pdfread { };
 
   briss = callPackage ../tools/graphics/briss { };
- 
-  brickd = callPackage ../servers/brickd { 
-    libusb = libusb1; 
+
+  brickd = callPackage ../servers/brickd {
+    libusb = libusb1;
   };
 
   bully = callPackage ../tools/networking/bully { };
···
   eggDerivation = callPackage ../development/compilers/chicken/eggDerivation.nix { };
 
   chicken = callPackage ../development/compilers/chicken {
-    bootstrap-chicken = chicken.override { bootstrap-chicken = null; }; 
+    bootstrap-chicken = chicken.override { bootstrap-chicken = null; };
   };
 
   egg2nix = callPackage ../development/tools/egg2nix {
···
     camomile_0_8_2 = callPackage ../development/ocaml-modules/camomile/0.8.2.nix { };
     camomile = callPackage ../development/ocaml-modules/camomile { };
 
-    camlimages = callPackage ../development/ocaml-modules/camlimages {
+    camlimages_4_0 = callPackage ../development/ocaml-modules/camlimages/4.0.nix {
       libpng = libpng12;
       giflib = giflib_4_1;
     };
+    camlimages_4_1 = callPackage ../development/ocaml-modules/camlimages/4.1.nix {};
+    camlimages = camlimages_4_1;
 
     biniou = callPackage ../development/ocaml-modules/biniou { };
 
     ocaml_cairo = callPackage ../development/ocaml-modules/ocaml-cairo { };
+
+    ocaml_cairo2 = callPackage ../development/ocaml-modules/ocaml-cairo2 { };
 
     cmdliner = callPackage ../development/ocaml-modules/cmdliner { };
 
···
   // { lablgtk = ocamlPackages_3_10_0.lablgtk_2_14; };
   ocamlPackages_3_11_2 = (mkOcamlPackages ocaml_3_11_2 pkgs.ocamlPackages_3_11_2)
   // { lablgtk = ocamlPackages_3_11_2.lablgtk_2_14; };
-  ocamlPackages_3_12_1 = mkOcamlPackages ocaml_3_12_1 pkgs.ocamlPackages_3_12_1;
+  ocamlPackages_3_12_1 = (mkOcamlPackages ocaml_3_12_1 pkgs.ocamlPackages_3_12_1)
+  // { camlimages = ocamlPackages_3_12_1.camlimages_4_0; };
   ocamlPackages_4_00_1 = mkOcamlPackages ocaml_4_00_1 pkgs.ocamlPackages_4_00_1;
   ocamlPackages_4_01_0 = mkOcamlPackages ocaml_4_01_0 pkgs.ocamlPackages_4_01_0;
   ocamlPackages_4_02_0 = mkOcamlPackages ocaml_4_02_0 pkgs.ocamlPackages_4_02_0;
···
   glpk = callPackage ../development/libraries/glpk { };
 
   glsurf = callPackage ../applications/science/math/glsurf {
-    inherit (ocamlPackages) lablgl findlib camlimages ocaml_mysql mlgmp;
+    inherit (ocamlPackages) lablgl findlib ocaml_mysql mlgmp;
     libpng = libpng12;
     giflib = giflib_4_1;
+    camlimages = ocamlPackages.camlimages_4_0;
   };
 
   gmime = callPackage ../development/libraries/gmime { };
···
   libelf = callPackage ../development/libraries/libelf { };
 
   libetpan = callPackage ../development/libraries/libetpan { };
+
+  libfaketime = callPackage ../development/libraries/libfaketime { };
 
   libfm = callPackage ../development/libraries/libfm { };
   libfm-extra = callPackage ../development/libraries/libfm {
···
   R = callPackage ../applications/science/math/R {
     inherit (xlibs) libX11 libXt;
     texLive = texLiveAggregationFun { paths = [ texLive texLiveExtra ]; };
-    withRecommendedPackages = false;
+    withRecommendedPackages = true;
   };
 
   rWrapper = callPackage ../development/r-modules/wrapper.nix {
     # Those packages are usually installed as part of the R build.
-    recommendedPackages = with rPackages; [ MASS lattice Matrix nlme
-      survival boot cluster codetools foreign KernSmooth rpart class
-      nnet spatial mgcv ];
+    recommendedPackages = with rPackages; [ boot class cluster codetools
+      foreign KernSmooth lattice MASS Matrix mgcv nlme nnet rpart
+      spatial survival ];
     # Override this attribute to register additional libraries.
     packages = [];
   };
···
 
   postgresql93 = callPackage ../servers/sql/postgresql/9.3.x.nix { };
 
-  postgresql94 = callPackage ../servers/sql/postgresql/9.4.x.nix { };
+  postgresql94beta2 = callPackage ../servers/sql/postgresql/9.4beta2.nix { };
+  postgresql94beta3 = callPackage ../servers/sql/postgresql/9.4beta3.nix { };
+  postgresql94 = postgresql94beta3;
 
   postgresql_jdbc = callPackage ../servers/sql/postgresql/jdbc { };
 
···
 
   fluidsynth = callPackage ../applications/audio/fluidsynth { };
 
+  focuswriter = callPackage ../applications/editors/focuswriter { };
+
   fossil = callPackage ../applications/version-management/fossil { };
 
   freewheeling = callPackage ../applications/audio/freewheeling { };
···
     inherit (xlibs) libX11 xproto;
   };
 
-  easytag = callPackage ../applications/audio/easytag { };
+  easytag = callPackage ../applications/audio/easytag {
+    inherit (gnome3) gnome_icon_theme;
+  };
 
   mp3info = callPackage ../applications/audio/mp3info { };
 
···
     plugins = [];
   };
 
-  pidginlatex = callPackage ../applications/networking/instant-messengers/pidgin-plugins/pidgin-latex {
-    imagemagick = imagemagickBig;
-  };
+  pidginlatex = callPackage ../applications/networking/instant-messengers/pidgin-plugins/pidgin-latex { };
 
-  pidginlatexSF = builderDefsPackage
-    (import ../applications/networking/instant-messengers/pidgin-plugins/pidgin-latex/pidgin-latex-sf.nix)
-    {
-      inherit pkgconfig pidgin texLive imagemagick which glib gtk;
-    };
+  pidginlatexSF = pidginlatex;
 
   pidginmsnpecan = callPackage ../applications/networking/instant-messengers/pidgin-plugins/msn-pecan { };
 
···
   mate-themes = callPackage ../misc/themes/mate-themes { };
 
   xfce = xfce4_10;
-  xfce4_10 = recurseIntoAttrs (import ../desktops/xfce { inherit pkgs newScope; });
+  xfce4_10 = recurseIntoAttrs (import ../desktops/xfce { inherit config pkgs newScope; });
 
 
   ### SCIENCE

pkgs/top-level/haskell-defaults.nix

···
         vectorBinaryInstances = self.vectorBinaryInstances.override { binary = self.binary_0_7_2_2; };
       };
     };
+    entropy = super.entropy.override { cabal = self.cabal.override { Cabal = self.Cabal_1_18_1_3; }; };
     gloss = null;                       # requires base >= 4.7
     haddock = self.haddock_2_13_2;
     modularArithmetic = null;           # requires base >= 4.7

pkgs/top-level/haskell-packages.nix

···
 
   graphmod = callPackage ../development/tools/haskell/graphmod {};
 
-  graphviz = callPackage ../development/libraries/haskell/graphviz {};
+  graphviz = callPackage ../development/libraries/haskell/graphviz { systemGraphviz = pkgs.graphviz; };
 
   graphSCC = callPackage ../development/libraries/haskell/graphscc {};
 
···
   haskellSrc = self.haskellSrc_1_0_1_6;
 
   haskellSrcExts_1_15_0_1 = callPackage ../development/libraries/haskell/haskell-src-exts/1.15.0.1.nix {};
-  haskellSrcExts_1_16_0 = callPackage ../development/libraries/haskell/haskell-src-exts/1.16.0.nix {};
-  haskellSrcExts = self.haskellSrcExts_1_16_0;
+  haskellSrcExts_1_16_0_1 = callPackage ../development/libraries/haskell/haskell-src-exts/1.16.0.1.nix {};
+  haskellSrcExts = self.haskellSrcExts_1_16_0_1;
 
   haskellSrcMeta = callPackage ../development/libraries/haskell/haskell-src-meta {};
 
···
     liblapack = pkgs.liblapack.override { shared = true; };
   };
 
+  hmatrixGsl = callPackage ../development/libraries/haskell/hmatrix-gsl {};
+
   hmatrixSpecial = callPackage ../development/libraries/haskell/hmatrix-special {};
 
   hoauth = callPackage ../development/libraries/haskell/hoauth {};
···
 
   hsc3 = callPackage ../development/libraries/haskell/hsc3 {};
 
-  hsc3-dot = callPackage ../development/libraries/haskell/hsc3-dot {};
+  hsc3Dot = callPackage ../development/libraries/haskell/hsc3-dot {};
 
-  hsc3-process = callPackage ../development/libraries/haskell/hsc3-process {};
+  hsc3Process = callPackage ../development/libraries/haskell/hsc3-process {};
 
-  hsc3-db = callPackage ../development/libraries/haskell/hsc3-db {};
+  hsc3Db = callPackage ../development/libraries/haskell/hsc3-db {};
 
-  hsc3-lang = callPackage ../development/libraries/haskell/hsc3-lang {
+  hsc3Lang = callPackage ../development/libraries/haskell/hsc3-lang {
     hmatrixSpecial = self.hmatrixSpecial.override {
       hmatrix = self.hmatrix.override { binary = self.binary_0_7_2_2; };
+      hmatrixGsl = self.hmatrixGsl.override {
+        hmatrix = self.hmatrix.override { binary = self.binary_0_7_2_2; };
+      };
     };
   };
 
···
 
   ListZipper = callPackage ../development/libraries/haskell/ListZipper {};
 
-  # Needed for idris for now
-  llvmGeneral_3_3_8_2 = callPackage ../development/libraries/haskell/llvm-general/3.3.8.2.nix {
-    llvmConfig = pkgs.llvm_33;
-    llvmGeneralPure = self.llvmGeneralPure_3_3_8_2;
-  };
-  llvmGeneral_3_4_4_0 = callPackage ../development/libraries/haskell/llvm-general/3.4.4.0.nix {
-    llvmConfig = pkgs.llvm;
-  };
-  llvmGeneral = self.llvmGeneral_3_4_4_0;
+  llvmGeneral = callPackage ../development/libraries/haskell/llvm-general { llvmConfig = pkgs.llvm; };
 
-  llvmGeneralPure_3_3_8_2 = callPackage ../development/libraries/haskell/llvm-general-pure/3.3.8.2.nix {};
-  llvmGeneralPure_3_4_4_0 = callPackage ../development/libraries/haskell/llvm-general-pure/3.4.4.0.nix {};
-  llvmGeneralPure = self.llvmGeneralPure_3_4_4_0;
+  llvmGeneralPure = callPackage ../development/libraries/haskell/llvm-general-pure {};
 
   lrucache = callPackage ../development/libraries/haskell/lrucache {};
 
···
 
   MonadRandom_0_1_13 = callPackage ../development/libraries/haskell/MonadRandom/0.1.13.nix {};
   MonadRandom_0_2_0_1 = callPackage ../development/libraries/haskell/MonadRandom/0.2.0.1.nix {};
-  MonadRandom = self.MonadRandom_0_2_0_1;
+  MonadRandom_0_3 = callPackage ../development/libraries/haskell/MonadRandom/0.3.nix {};
+  MonadRandom = self.MonadRandom_0_3;
 
   monadStm = callPackage ../development/libraries/haskell/monad-stm {};
 
···
   sbv = callPackage ../development/libraries/haskell/sbv {};
 
   scientific_0_2_0_2 = callPackage ../development/libraries/haskell/scientific/0.2.0.2.nix {};
-  scientific_0_3_3_1 = callPackage ../development/libraries/haskell/scientific/0.3.3.1.nix {};
-  scientific = self.scientific_0_3_3_1;
+  scientific_0_3_3_2 = callPackage ../development/libraries/haskell/scientific/0.3.3.2.nix {};
+  scientific = self.scientific_0_3_3_2;
 
   scotty = callPackage ../development/libraries/haskell/scotty {};
 
···
   text_0_11_2_3 = callPackage ../development/libraries/haskell/text/0.11.2.3.nix {};
   text_0_11_3_1 = callPackage ../development/libraries/haskell/text/0.11.3.1.nix {};
   text_1_1_1_3 = callPackage ../development/libraries/haskell/text/1.1.1.3.nix {};
-  text = self.text_1_1_1_3;
+  text_1_2_0_0 = callPackage ../development/libraries/haskell/text/1.2.0.0.nix {};
+  text = self.text_1_2_0_0;
 
   textFormat = callPackage ../development/libraries/haskell/text-format {};
 
···
   threadmanager = callPackage ../development/libraries/haskell/threadmanager {};
 
   threads = callPackage ../development/libraries/haskell/threads {};
+
+  thReifyMany = callPackage ../development/libraries/haskell/th-reify-many {};
 
   Thrift = callPackage ../development/libraries/haskell/Thrift {};
 

pkgs/top-level/python-packages.nix

···
     name = "poppler-qt4-${version}";
     version = "0.18.1";
     disabled = isPy3k || isPyPy;
-    
+
     src = pkgs.fetchurl {
       url = "https://pypi.python.org/packages/source/p/python-poppler-qt4/" +
             "python-poppler-qt4-${version}.tar.gz";
···
       ${python}/bin/${python.executable} setup.py install \
         --install-lib=$out/lib/${python.libPrefix}/site-packages \
         --prefix="$out"
-    ''; 
+    '';
 
     meta = with stdenv.lib; {
       homepage = https://github.com/Groundworkstech/pybfd;
···
 
     buildInputs = with self; [ nose mock ];
     propagatedBuildInputs = with self; [
-      jinja2 pyyaml redis requests pagerduty 
+      jinja2 pyyaml redis requests pagerduty
       python_simple_hipchat pushbullet
     ];
 
···
       maintainers = [ stdenv.lib.maintainers.DamienCassou ];
     };
   };
+
+  datadiff = buildPythonPackage rec {
+    name = "datadiff-1.1.6";
+
+    src = pkgs.fetchurl {
+      url = "https://pypi.python.org/packages/source/d/datadiff/datadiff-1.1.6.zip";
+      md5 = "c34a690db75eead148aa5fa89e575d1e";
+    };
+
+    buildInputs = with self; [ nose ];
+
+    meta = with stdenv.lib; {
+      description = "DataDiff";
+      homepage = http://sourceforge.net/projects/datadiff/;
+      license = licenses.asl20;
+    };
+  };
+
+  termcolor = buildPythonPackage rec {
+    name = "termcolor-1.1.0";
+
+    src = pkgs.fetchurl {
+      url = "https://pypi.python.org/packages/source/t/termcolor/termcolor-1.1.0.tar.gz";
+      md5 = "043e89644f8909d462fbbfa511c768df";
+    };
+
+    meta = with stdenv.lib; {
+      description = "Termcolor";
+      homepage = http://pypi.python.org/pypi/termcolor;
+      license = licenses.mit;
+    };
+  };
+
 }); in pythonPackages