quicklispPackages: add a basic set of packages, make sure that quicklispPackages_asdf_3_1 can be built completely

pkgs/development/lisp-modules/quicklisp-to-nix-output/agnostic-lizard.nix

···
-{ fetchurl }:
-rec {
-  baseName = ''agnostic-lizard'';
-  version = ''20170227-git'';
-
-  description = ''A portable code walker that makes a best effort to be correct in most cases'';
-
-  deps = [ ];
-
-  src = fetchurl {
-    url = ''http://beta.quicklisp.org/archive/agnostic-lizard/2017-02-27/agnostic-lizard-20170227-git.tgz'';
-    sha256 = ''0gnbxfdz35z9kznnhnj9x5zzn25k1x2ifv4v9rkzb0xmi7xkx9wi'';
-  };
-}

pkgs/development/lisp-modules/quicklisp-to-nix-output/alexandria.nix

···
     url = ''http://beta.quicklisp.org/archive/alexandria/2017-02-27/alexandria-20170227-git.tgz'';
     sha256 = ''0gnn4ysyvqf8wfi94kh6x23iwx3czaicam1lz9pnwsv40ws5fwwh'';
   };
+
+  overrides = x: {
+    postInstall = ''
+        echo "$CL_SOURCE_REGISTRY"
+        NIX_LISP_PRELAUNCH_HOOK='nix_lisp_run_single_form "(asdf:load-system :alexandria)"' "$out/bin/alexandria-lisp-launcher.sh" ""
+    '';
+  };
 }

pkgs/development/lisp-modules/quicklisp-to-nix-output/anaphora.nix

···
+args @ { fetchurl, ... }:
+rec {
+  baseName = ''anaphora'';
+  version = ''20170227-git'';
+
+  description = ''The Anaphoric Macro Package from Hell'';
+
+  deps = [ ];
+
+  src = fetchurl {
+    url = ''http://beta.quicklisp.org/archive/anaphora/2017-02-27/anaphora-20170227-git.tgz'';
+    sha256 = ''1inv6bcly6r7yixj1pp0i4h0y7lxyv68mk9wsi5iwi9gx6000yd9'';
+  };
+
+  overrides = x: {
+    postInstall = ''
+        echo "$CL_SOURCE_REGISTRY"
+        NIX_LISP_PRELAUNCH_HOOK='nix_lisp_run_single_form "(asdf:load-system :anaphora)"' "$out/bin/anaphora-lisp-launcher.sh" ""
+    '';
+  };
+}

pkgs/development/lisp-modules/quicklisp-to-nix-output/array-utils.nix

···
+args @ { fetchurl, ... }:
+rec {
+  baseName = ''array-utils'';
+  version = ''20160929-git'';
+
+  description = ''A few utilities for working with arrays.'';
+
+  deps = [ ];
+
+  src = fetchurl {
+    url = ''http://beta.quicklisp.org/archive/array-utils/2016-09-29/array-utils-20160929-git.tgz'';
+    sha256 = ''1nlrf7b81qq7l85kkdh3fxcs6ngnvh5zk7mb5mwf8vjm5kpfbbcx'';
+  };
+
+  overrides = x: {
+    postInstall = ''
+        echo "$CL_SOURCE_REGISTRY"
+        NIX_LISP_PRELAUNCH_HOOK='nix_lisp_run_single_form "(asdf:load-system :array-utils)"' "$out/bin/array-utils-lisp-launcher.sh" ""
+    '';
+  };
+}

pkgs/development/lisp-modules/quicklisp-to-nix-output/babel-streams.nix

···
+args @ { fetchurl, ... }:
+rec {
+  baseName = ''babel-streams'';
+  version = ''babel-20150608-git'';
+
+  description = ''Some useful streams based on Babel's encoding code'';
+
+  deps = [ args."alexandria" args."babel" args."trivial-gray-streams" ];
+
+  src = fetchurl {
+    url = ''http://beta.quicklisp.org/archive/babel/2015-06-08/babel-20150608-git.tgz'';
+    sha256 = ''0nv2w7k33rwc4dwi33ay2rkmvnj4vsz9ar27z8fiar34895vndk5'';
+  };
+
+  overrides = x: {
+    postInstall = ''
+        echo "$CL_SOURCE_REGISTRY"
+        NIX_LISP_PRELAUNCH_HOOK='nix_lisp_run_single_form "(asdf:load-system :babel-streams)"' "$out/bin/babel-streams-lisp-launcher.sh" ""
+    '';
+  };
+}

pkgs/development/lisp-modules/quicklisp-to-nix-output/babel.nix

···
 
   description = ''Babel, a charset conversion library.'';
 
-  deps = [ args."trivial-features" args."alexandria" ];
+  deps = [ args."alexandria" args."trivial-features" ];
 
   src = fetchurl {
     url = ''http://beta.quicklisp.org/archive/babel/2015-06-08/babel-20150608-git.tgz'';
     sha256 = ''0nv2w7k33rwc4dwi33ay2rkmvnj4vsz9ar27z8fiar34895vndk5'';
+  };
+
+  overrides = x: {
+    postInstall = ''
+        echo "$CL_SOURCE_REGISTRY"
+        NIX_LISP_PRELAUNCH_HOOK='nix_lisp_run_single_form "(asdf:load-system :babel)"' "$out/bin/babel-lisp-launcher.sh" ""
+    '';
   };
 }

pkgs/development/lisp-modules/quicklisp-to-nix-output/blackbird.nix

···
+args @ { fetchurl, ... }:
+rec {
+  baseName = ''blackbird'';
+  version = ''20160531-git'';
+
+  description = ''A promise implementation for Common Lisp.'';
+
+  deps = [ args."vom" ];
+
+  src = fetchurl {
+    url = ''http://beta.quicklisp.org/archive/blackbird/2016-05-31/blackbird-20160531-git.tgz'';
+    sha256 = ''0l053fb5fdz1q6dyfgys6nmbairc3aig4wjl5abpf8b1paf7gzq9'';
+  };
+
+  overrides = x: {
+    postInstall = ''
+        echo "$CL_SOURCE_REGISTRY"
+        NIX_LISP_PRELAUNCH_HOOK='nix_lisp_run_single_form "(asdf:load-system :blackbird)"' "$out/bin/blackbird-lisp-launcher.sh" ""
+    '';
+  };
+}

pkgs/development/lisp-modules/quicklisp-to-nix-output/bordeaux-threads.nix

···
   baseName = ''bordeaux-threads'';
   version = ''v0.8.5'';
 
-  description = ''Bordeaux Threads makes writing portable multi-threaded apps simple'';
+  description = ''Bordeaux Threads makes writing portable multi-threaded apps simple.'';
 
   deps = [ args."alexandria" ];
 
   src = fetchurl {
     url = ''http://beta.quicklisp.org/archive/bordeaux-threads/2016-03-18/bordeaux-threads-v0.8.5.tgz'';
     sha256 = ''09q1xd3fca6ln6mh45cx24xzkrcnvhgl5nn9g2jv0rwj1m2xvbpd'';
+  };
+
+  overrides = x: {
+    postInstall = ''
+        echo "$CL_SOURCE_REGISTRY"
+        NIX_LISP_PRELAUNCH_HOOK='nix_lisp_run_single_form "(asdf:load-system :bordeaux-threads)"' "$out/bin/bordeaux-threads-lisp-launcher.sh" ""
+    '';
   };
 }

pkgs/development/lisp-modules/quicklisp-to-nix-output/caveman.nix

···
+args @ { fetchurl, ... }:
+rec {
+  baseName = ''caveman'';
+  version = ''20161031-git'';
+
+  description = ''Web Application Framework for Common Lisp'';
+
+  deps = [ args."anaphora" args."cl-emb" args."cl-ppcre" args."cl-project" args."cl-syntax" args."cl-syntax-annot" args."clack-v1-compat" args."do-urlencode" args."local-time" args."myway" ];
+
+  src = fetchurl {
+    url = ''http://beta.quicklisp.org/archive/caveman/2016-10-31/caveman-20161031-git.tgz'';
+    sha256 = ''111zxnlsn99sybmwgyxh0x29avq898nxssysvaf8v4mbb6fva2hi'';
+  };
+
+  overrides = x: {
+    postInstall = ''
+        echo "$CL_SOURCE_REGISTRY"
+        NIX_LISP_PRELAUNCH_HOOK='nix_lisp_run_single_form "(asdf:load-system :caveman)"' "$out/bin/caveman-lisp-launcher.sh" ""
+    '';
+  };
+}

pkgs/development/lisp-modules/quicklisp-to-nix-output/cffi-grovel.nix

···
+args @ { fetchurl, ... }:
+rec {
+  baseName = ''cffi-grovel'';
+  version = ''cffi_0.18.0'';
+
+  description = ''The CFFI Groveller'';
+
+  deps = [ args."alexandria" args."cffi" args."cffi-toolchain" ];
+
+  src = fetchurl {
+    url = ''http://beta.quicklisp.org/archive/cffi/2016-10-31/cffi_0.18.0.tgz'';
+    sha256 = ''0g4clx9l9c7iw9hiv94ihzp4zb80yq3i5j6lr3vkz9z2dndzcpzz'';
+  };
+
+  overrides = x: {
+    postInstall = ''
+        echo "$CL_SOURCE_REGISTRY"
+        NIX_LISP_PRELAUNCH_HOOK='nix_lisp_run_single_form "(asdf:load-system :cffi-grovel)"' "$out/bin/cffi-grovel-lisp-launcher.sh" ""
+    '';
+  };
+}

pkgs/development/lisp-modules/quicklisp-to-nix-output/cffi-toolchain.nix

···
+args @ { fetchurl, ... }:
+rec {
+  baseName = ''cffi-toolchain'';
+  version = ''cffi_0.18.0'';
+
+  description = ''The CFFI toolchain'';
+
+  deps = [ args."cffi" ];
+
+  src = fetchurl {
+    url = ''http://beta.quicklisp.org/archive/cffi/2016-10-31/cffi_0.18.0.tgz'';
+    sha256 = ''0g4clx9l9c7iw9hiv94ihzp4zb80yq3i5j6lr3vkz9z2dndzcpzz'';
+  };
+
+  overrides = x: {
+    postInstall = ''
+        echo "$CL_SOURCE_REGISTRY"
+        NIX_LISP_PRELAUNCH_HOOK='nix_lisp_run_single_form "(asdf:load-system :cffi-toolchain)"' "$out/bin/cffi-toolchain-lisp-launcher.sh" ""
+    '';
+  };
+}

pkgs/development/lisp-modules/quicklisp-to-nix-output/cffi.nix

···
 
   description = ''The Common Foreign Function Interface'';
 
-  deps = [ args."uiop" args."alexandria" args."trivial-features" args."babel" ];
+  deps = [ args."alexandria" args."babel" args."trivial-features" args."uiop" ];
 
   src = fetchurl {
     url = ''http://beta.quicklisp.org/archive/cffi/2016-10-31/cffi_0.18.0.tgz'';
     sha256 = ''0g4clx9l9c7iw9hiv94ihzp4zb80yq3i5j6lr3vkz9z2dndzcpzz'';
+  };
+
+  overrides = x: {
+    postInstall = ''
+        echo "$CL_SOURCE_REGISTRY"
+        NIX_LISP_PRELAUNCH_HOOK='nix_lisp_run_single_form "(asdf:load-system :cffi)"' "$out/bin/cffi-lisp-launcher.sh" ""
+    '';
   };
 }

pkgs/development/lisp-modules/quicklisp-to-nix-output/chipz.nix

···
     url = ''http://beta.quicklisp.org/archive/chipz/2016-03-18/chipz-20160318-git.tgz'';
     sha256 = ''1dpsg8kd43k075xihb0szcq1f7iq8ryg5r77x5wi6hy9jhpq8826'';
   };
+
+  overrides = x: {
+    postInstall = ''
+        echo "$CL_SOURCE_REGISTRY"
+        NIX_LISP_PRELAUNCH_HOOK='nix_lisp_run_single_form "(asdf:load-system :chipz)"' "$out/bin/chipz-lisp-launcher.sh" ""
+    '';
+  };
 }

pkgs/development/lisp-modules/quicklisp-to-nix-output/chunga.nix

···
     url = ''http://beta.quicklisp.org/archive/chunga/2014-12-17/chunga-1.1.6.tgz'';
     sha256 = ''1ivdfi9hjkzp2anhpjm58gzrjpn6mdsp35km115c1j1c4yhs9lzg'';
   };
+
+  overrides = x: {
+    postInstall = ''
+        echo "$CL_SOURCE_REGISTRY"
+        NIX_LISP_PRELAUNCH_HOOK='nix_lisp_run_single_form "(asdf:load-system :chunga)"' "$out/bin/chunga-lisp-launcher.sh" ""
+    '';
+  };
 }

pkgs/development/lisp-modules/quicklisp-to-nix-output/circular-streams.nix

···
+args @ { fetchurl, ... }:
+rec {
+  baseName = ''circular-streams'';
+  version = ''20161204-git'';
+
+  description = ''Circularly readable streams for Common Lisp'';
+
+  deps = [ args."fast-io" args."trivial-gray-streams" ];
+
+  src = fetchurl {
+    url = ''http://beta.quicklisp.org/archive/circular-streams/2016-12-04/circular-streams-20161204-git.tgz'';
+    sha256 = ''1i29b9sciqs5x59hlkdj2r4siyqgrwj5hb4lnc80jgfqvzbq4128'';
+  };
+
+  overrides = x: {
+    postInstall = ''
+        echo "$CL_SOURCE_REGISTRY"
+        NIX_LISP_PRELAUNCH_HOOK='nix_lisp_run_single_form "(asdf:load-system :circular-streams)"' "$out/bin/circular-streams-lisp-launcher.sh" ""
+    '';
+  };
+}

pkgs/development/lisp-modules/quicklisp-to-nix-output/cl+ssl.nix

···
 
   description = ''Common Lisp interface to OpenSSL.'';
 
-  deps = [ args."cffi" args."trivial-gray-streams" args."flexi-streams" args."bordeaux-threads" args."trivial-garbage" args."uiop" ];
+  deps = [ args."bordeaux-threads" args."cffi" args."flexi-streams" args."trivial-garbage" args."trivial-gray-streams" args."uiop" ];
 
   src = fetchurl {
     url = ''http://beta.quicklisp.org/archive/cl+ssl/2016-12-08/cl+ssl-20161208-git.tgz'';
     sha256 = ''0x9xa2rdfh9gxp5m27cj0wvzjqccz4w5cvm7nbk5shwsz5xgr7hs'';
+  };
+
+  overrides = x: {
+    postInstall = ''
+        echo "$CL_SOURCE_REGISTRY"
+        NIX_LISP_PRELAUNCH_HOOK='nix_lisp_run_single_form "(asdf:load-system :cl+ssl)"' "$out/bin/cl+ssl-lisp-launcher.sh" ""
+    '';
   };
 }

pkgs/development/lisp-modules/quicklisp-to-nix-output/cl-annot.nix

···
+args @ { fetchurl, ... }:
+rec {
+  baseName = ''cl-annot'';
+  version = ''20150608-git'';
+
+  description = ''Python-like Annotation Syntax for Common Lisp'';
+
+  deps = [ args."alexandria" ];
+
+  src = fetchurl {
+    url = ''http://beta.quicklisp.org/archive/cl-annot/2015-06-08/cl-annot-20150608-git.tgz'';
+    sha256 = ''0ixsp20rk498phv3iivipn3qbw7a7x260x63hc6kpv2s746lpdg3'';
+  };
+
+  overrides = x: {
+    postInstall = ''
+        echo "$CL_SOURCE_REGISTRY"
+        NIX_LISP_PRELAUNCH_HOOK='nix_lisp_run_single_form "(asdf:load-system :cl-annot)"' "$out/bin/cl-annot-lisp-launcher.sh" ""
+    '';
+  };
+}

pkgs/development/lisp-modules/quicklisp-to-nix-output/cl-ansi-text.nix

···
+args @ { fetchurl, ... }:
+rec {
+  baseName = ''cl-ansi-text'';
+  version = ''20150804-git'';
+
+  description = ''ANSI control string characters, focused on color'';
+
+  deps = [ args."alexandria" args."cl-colors" ];
+
+  src = fetchurl {
+    url = ''http://beta.quicklisp.org/archive/cl-ansi-text/2015-08-04/cl-ansi-text-20150804-git.tgz'';
+    sha256 = ''112w7qg8yp28qyc2b5c7km457krr3xksxyps1icmgdpqf9ccpn2i'';
+  };
+
+  overrides = x: {
+    postInstall = ''
+        echo "$CL_SOURCE_REGISTRY"
+        NIX_LISP_PRELAUNCH_HOOK='nix_lisp_run_single_form "(asdf:load-system :cl-ansi-text)"' "$out/bin/cl-ansi-text-lisp-launcher.sh" ""
+    '';
+  };
+}

pkgs/development/lisp-modules/quicklisp-to-nix-output/cl-async-base.nix

···
+args @ { fetchurl, ... }:
+rec {
+  baseName = ''cl-async-base'';
+  version = ''cl-async-20160825-git'';
+
+  description = ''Base system for cl-async.'';
+
+  deps = [ args."bordeaux-threads" args."cffi" args."cl-libuv" ];
+
+  src = fetchurl {
+    url = ''http://beta.quicklisp.org/archive/cl-async/2016-08-25/cl-async-20160825-git.tgz'';
+    sha256 = ''104x6vw9zrmzz3sipmzn0ygil6ccyy8gpvvjxak2bfxbmxcl09pa'';
+  };
+
+  overrides = x: {
+    postInstall = ''
+        echo "$CL_SOURCE_REGISTRY"
+        NIX_LISP_PRELAUNCH_HOOK='nix_lisp_run_single_form "(asdf:load-system :cl-async)"' "$out/bin/cl-async-base-lisp-launcher.sh" ""
+    '';
+  };
+}

pkgs/development/lisp-modules/quicklisp-to-nix-output/cl-async-util.nix

···
+args @ { fetchurl, ... }:
+rec {
+  baseName = ''cl-async-util'';
+  version = ''cl-async-20160825-git'';
+
+  description = ''Internal utilities for cl-async.'';
+
+  deps = [ args."cffi" args."cl-async-base" args."cl-libuv" args."cl-ppcre" args."fast-io" args."vom" ];
+
+  src = fetchurl {
+    url = ''http://beta.quicklisp.org/archive/cl-async/2016-08-25/cl-async-20160825-git.tgz'';
+    sha256 = ''104x6vw9zrmzz3sipmzn0ygil6ccyy8gpvvjxak2bfxbmxcl09pa'';
+  };
+
+  overrides = x: {
+    postInstall = ''
+        echo "$CL_SOURCE_REGISTRY"
+        NIX_LISP_PRELAUNCH_HOOK='nix_lisp_run_single_form "(asdf:load-system :cl-async)"' "$out/bin/cl-async-util-lisp-launcher.sh" ""
+    '';
+  };
+}

pkgs/development/lisp-modules/quicklisp-to-nix-output/cl-async.nix

···
+args @ { fetchurl, ... }:
+rec {
+  baseName = ''cl-async'';
+  version = ''20160825-git'';
+
+  description = ''Asynchronous operations for Common Lisp.'';
+
+  deps = [ args."babel" args."cffi" args."cl-async-base" args."cl-async-util" args."cl-libuv" args."cl-ppcre" args."static-vectors" args."trivial-features" args."trivial-gray-streams" args."uiop" ];
+
+  src = fetchurl {
+    url = ''http://beta.quicklisp.org/archive/cl-async/2016-08-25/cl-async-20160825-git.tgz'';
+    sha256 = ''104x6vw9zrmzz3sipmzn0ygil6ccyy8gpvvjxak2bfxbmxcl09pa'';
+  };
+
+  overrides = x: {
+    postInstall = ''
+        echo "$CL_SOURCE_REGISTRY"
+        NIX_LISP_PRELAUNCH_HOOK='nix_lisp_run_single_form "(asdf:load-system :cl-async)"' "$out/bin/cl-async-lisp-launcher.sh" ""
+    '';
+  };
+}

pkgs/development/lisp-modules/quicklisp-to-nix-output/cl-base64.nix

···
     url = ''http://beta.quicklisp.org/archive/cl-base64/2015-09-23/cl-base64-20150923-git.tgz'';
     sha256 = ''0haip5x0091r9xa8gdzr21s0rk432998nbxxfys35lhnyc1vgyhp'';
   };
+
+  overrides = x: {
+    postInstall = ''
+        echo "$CL_SOURCE_REGISTRY"
+        NIX_LISP_PRELAUNCH_HOOK='nix_lisp_run_single_form "(asdf:load-system :cl-base64)"' "$out/bin/cl-base64-lisp-launcher.sh" ""
+    '';
+  };
 }

pkgs/development/lisp-modules/quicklisp-to-nix-output/cl-colors.nix

···
+args @ { fetchurl, ... }:
+rec {
+  baseName = ''cl-colors'';
+  version = ''20151218-git'';
+
+  description = ''Simple color library for Common Lisp'';
+
+  deps = [ args."alexandria" args."let-plus" ];
+
+  src = fetchurl {
+    url = ''http://beta.quicklisp.org/archive/cl-colors/2015-12-18/cl-colors-20151218-git.tgz'';
+    sha256 = ''032kswn6h2ib7v8v1dg0lmgfks7zk52wrv31q6p2zj2a156ccqp4'';
+  };
+
+  overrides = x: {
+    postInstall = ''
+        echo "$CL_SOURCE_REGISTRY"
+        NIX_LISP_PRELAUNCH_HOOK='nix_lisp_run_single_form "(asdf:load-system :cl-colors)"' "$out/bin/cl-colors-lisp-launcher.sh" ""
+    '';
+  };
+}

pkgs/development/lisp-modules/quicklisp-to-nix-output/cl-cookie.nix

···
+args @ { fetchurl, ... }:
+rec {
+  baseName = ''cl-cookie'';
+  version = ''20150804-git'';
+
+  description = ''HTTP cookie manager'';
+
+  deps = [ args."alexandria" args."cl-ppcre" args."local-time" args."proc-parse" args."quri" ];
+
+  src = fetchurl {
+    url = ''http://beta.quicklisp.org/archive/cl-cookie/2015-08-04/cl-cookie-20150804-git.tgz'';
+    sha256 = ''0llh5d2p7wi5amzpckng1bzmf2bdfdwkfapcdq0znqlzd5bvbby8'';
+  };
+
+  overrides = x: {
+    postInstall = ''
+        echo "$CL_SOURCE_REGISTRY"
+        NIX_LISP_PRELAUNCH_HOOK='nix_lisp_run_single_form "(asdf:load-system :cl-cookie)"' "$out/bin/cl-cookie-lisp-launcher.sh" ""
+    '';
+  };
+}

pkgs/development/lisp-modules/quicklisp-to-nix-output/cl-emb.nix

···
+args @ { fetchurl, ... }:
+rec {
+  baseName = ''cl-emb'';
+  version = ''20170227-git'';
+
+  description = ''A templating system for Common Lisp'';
+
+  deps = [ ];
+
+  src = fetchurl {
+    url = ''http://beta.quicklisp.org/archive/cl-emb/2017-02-27/cl-emb-20170227-git.tgz'';
+    sha256 = ''03n97xvh3v8bz1p75v1vhryfkjm74v0cr5jwg4rakq9zkchhfk80'';
+  };
+
+  overrides = x: {
+    postInstall = ''
+        echo "$CL_SOURCE_REGISTRY"
+        NIX_LISP_PRELAUNCH_HOOK='nix_lisp_run_single_form "(asdf:load-system :cl-emb)"' "$out/bin/cl-emb-lisp-launcher.sh" ""
+    '';
+  };
+}

pkgs/development/lisp-modules/quicklisp-to-nix-output/cl-fad.nix

···
 
   description = ''Portable pathname library'';
 
-  deps = [ args."bordeaux-threads" args."alexandria" ];
+  deps = [ args."alexandria" args."bordeaux-threads" ];
 
   src = fetchurl {
     url = ''http://beta.quicklisp.org/archive/cl-fad/2016-08-25/cl-fad-0.7.4.tgz'';
     sha256 = ''1avp5j66vrpv5symgw4n4szlc2cyqz4haa0cxzy1pl8p0a8k0v9x'';
+  };
+
+  overrides = x: {
+    postInstall = ''
+        echo "$CL_SOURCE_REGISTRY"
+        NIX_LISP_PRELAUNCH_HOOK='nix_lisp_run_single_form "(asdf:load-system :cl-fad)"' "$out/bin/cl-fad-lisp-launcher.sh" ""
+    '';
   };
 }

pkgs/development/lisp-modules/quicklisp-to-nix-output/cl-fuse.nix

···
 
   description = ''CFFI bindings to FUSE (Filesystem in user space)'';
 
-  deps = [ args."cffi" args."cl-utilities" args."bordeaux-threads" args."trivial-backtrace" args."iterate" args."trivial-utf-8" ];
+  deps = [ args."bordeaux-threads" args."cffi" args."cffi-grovel" args."cl-utilities" args."iterate" args."trivial-backtrace" args."trivial-utf-8" ];
 
   src = fetchurl {
     url = ''http://beta.quicklisp.org/archive/cl-fuse/2016-03-18/cl-fuse-20160318-git.tgz'';
     sha256 = ''1yllmnnhqp42s37a2y7h7vph854xgna62l1pidvlyskc90bl5jf6'';
+  };
+
+  overrides = x: {
+    postInstall = ''
+        echo "$CL_SOURCE_REGISTRY"
+        NIX_LISP_PRELAUNCH_HOOK='nix_lisp_run_single_form "(asdf:load-system :cl-fuse)"' "$out/bin/cl-fuse-lisp-launcher.sh" ""
+    '';
   };
 }

pkgs/development/lisp-modules/quicklisp-to-nix-output/cl-json.nix

···
+args @ { fetchurl, ... }:
+rec {
+  baseName = ''cl-json'';
+  version = ''20141217-git'';
+
+  description = ''JSON in Lisp. JSON (JavaScript Object Notation) is a lightweight data-interchange format.'';
+
+  deps = [ ];
+
+  src = fetchurl {
+    url = ''http://beta.quicklisp.org/archive/cl-json/2014-12-17/cl-json-20141217-git.tgz'';
+    sha256 = ''00cfppyi6njsbpv1x03jcv4zwplg0q1138174l3wjkvi3gsql17g'';
+  };
+
+  overrides = x: {
+    postInstall = ''
+        echo "$CL_SOURCE_REGISTRY"
+        NIX_LISP_PRELAUNCH_HOOK='nix_lisp_run_single_form "(asdf:load-system :cl-json)"' "$out/bin/cl-json-lisp-launcher.sh" ""
+    '';
+  };
+}

pkgs/development/lisp-modules/quicklisp-to-nix-output/cl-l10n-cldr.nix

···
+args @ { fetchurl, ... }:
+rec {
+  baseName = ''cl-l10n-cldr'';
+  version = ''20120909-darcs'';
+
+  description = ''The necessary CLDR files for cl-l10n packaged in a QuickLisp friendly way.'';
+
+  deps = [ ];
+
+  src = fetchurl {
+    url = ''http://beta.quicklisp.org/archive/cl-l10n-cldr/2012-09-09/cl-l10n-cldr-20120909-darcs.tgz'';
+    sha256 = ''03l81bx8izvzwzw0qah34l4k47l4gmhr917phhhl81qp55x7zbiv'';
+  };
+
+  overrides = x: {
+    postInstall = ''
+        echo "$CL_SOURCE_REGISTRY"
+        NIX_LISP_PRELAUNCH_HOOK='nix_lisp_run_single_form "(asdf:load-system :cl-l10n-cldr)"' "$out/bin/cl-l10n-cldr-lisp-launcher.sh" ""
+    '';
+  };
+}

pkgs/development/lisp-modules/quicklisp-to-nix-output/cl-l10n.nix

···
+args @ { fetchurl, ... }:
+rec {
+  baseName = ''cl-l10n'';
+  version = ''20161204-darcs'';
+
+  description = ''Portable CL Locale Support'';
+
+  deps = [ args."alexandria" args."cl-fad" args."cl-l10n-cldr" args."cl-ppcre" args."closer-mop" args."cxml" args."flexi-streams" args."iterate" args."local-time" args."metabang-bind" ];
+
+  src = fetchurl {
+    url = ''http://beta.quicklisp.org/archive/cl-l10n/2016-12-04/cl-l10n-20161204-darcs.tgz'';
+    sha256 = ''1r8jgwks21az78c5kdxgw5llk9ml423vjkv1f93qg1vx3zma6vzl'';
+  };
+
+  overrides = x: {
+    postInstall = ''
+        echo "$CL_SOURCE_REGISTRY"
+        NIX_LISP_PRELAUNCH_HOOK='nix_lisp_run_single_form "(asdf:load-system :cl-l10n)"' "$out/bin/cl-l10n-lisp-launcher.sh" ""
+    '';
+  };
+}

pkgs/development/lisp-modules/quicklisp-to-nix-output/cl-libuv.nix

···
+args @ { fetchurl, ... }:
+rec {
+  baseName = ''cl-libuv'';
+  version = ''20160825-git'';
+
+  description = ''Low-level libuv bindings for Common Lisp.'';
+
+  deps = [ args."alexandria" args."cffi" args."cffi-grovel" ];
+
+  src = fetchurl {
+    url = ''http://beta.quicklisp.org/archive/cl-libuv/2016-08-25/cl-libuv-20160825-git.tgz'';
+    sha256 = ''02vi9ph9pxbxgp9jsbgzb9nijsv0vyk3f1jyhhm88i0y1kb3595r'';
+  };
+
+  overrides = x: {
+    postInstall = ''
+        echo "$CL_SOURCE_REGISTRY"
+        NIX_LISP_PRELAUNCH_HOOK='nix_lisp_run_single_form "(asdf:load-system :cl-libuv)"' "$out/bin/cl-libuv-lisp-launcher.sh" ""
+    '';
+  };
+}

pkgs/development/lisp-modules/quicklisp-to-nix-output/cl-ppcre.nix

···
     url = ''http://beta.quicklisp.org/archive/cl-ppcre/2015-09-23/cl-ppcre-2.0.11.tgz'';
     sha256 = ''1djciws9n0jg3qdrck3j4wj607zvkbir8p379mp0p7b5g0glwvb2'';
   };
+
+  overrides = x: {
+    postInstall = ''
+        echo "$CL_SOURCE_REGISTRY"
+        NIX_LISP_PRELAUNCH_HOOK='nix_lisp_run_single_form "(asdf:load-system :cl-ppcre)"' "$out/bin/cl-ppcre-lisp-launcher.sh" ""
+    '';
+  };
 }

pkgs/development/lisp-modules/quicklisp-to-nix-output/cl-project.nix

···
+args @ { fetchurl, ... }:
+rec {
+  baseName = ''cl-project'';
+  version = ''20160531-git'';
+
+  description = ''Generate a skeleton for modern project'';
+
+  deps = [ args."cl-emb" args."cl-ppcre" args."local-time" args."prove" args."uiop" ];
+
+  src = fetchurl {
+    url = ''http://beta.quicklisp.org/archive/cl-project/2016-05-31/cl-project-20160531-git.tgz'';
+    sha256 = ''1xwjgs5pzkdnd9i5lcic9z41d1c4yf7pvarrvawfxcicg6rrfw81'';
+  };
+
+  overrides = x: {
+    postInstall = ''
+        echo "$CL_SOURCE_REGISTRY"
+        NIX_LISP_PRELAUNCH_HOOK='nix_lisp_run_single_form "(asdf:load-system :cl-project)"' "$out/bin/cl-project-lisp-launcher.sh" ""
+    '';
+  };
+}

pkgs/development/lisp-modules/quicklisp-to-nix-output/cl-reexport.nix

···
+args @ { fetchurl, ... }:
+rec {
+  baseName = ''cl-reexport'';
+  version = ''20150709-git'';
+
+  description = ''Reexport external symbols in other packages.'';
+
+  deps = [ args."alexandria" ];
+
+  src = fetchurl {
+    url = ''http://beta.quicklisp.org/archive/cl-reexport/2015-07-09/cl-reexport-20150709-git.tgz'';
+    sha256 = ''1y6qlyps7g0wl4rbmzvw6s1kjdwwmh33layyjclsjp9j5nm8mdmi'';
+  };
+
+  overrides = x: {
+    postInstall = ''
+        echo "$CL_SOURCE_REGISTRY"
+        NIX_LISP_PRELAUNCH_HOOK='nix_lisp_run_single_form "(asdf:load-system :cl-reexport)"' "$out/bin/cl-reexport-lisp-launcher.sh" ""
+    '';
+  };
+}

pkgs/development/lisp-modules/quicklisp-to-nix-output/cl-syntax-annot.nix

···
+args @ { fetchurl, ... }:
+rec {
+  baseName = ''cl-syntax-annot'';
+  version = ''cl-syntax-20150407-git'';
+
+  description = ''CL-Syntax Reader Syntax for cl-annot'';
+
+  deps = [ args."cl-annot" args."cl-syntax" ];
+
+  src = fetchurl {
+    url = ''http://beta.quicklisp.org/archive/cl-syntax/2015-04-07/cl-syntax-20150407-git.tgz'';
+    sha256 = ''1pz9a7hiql493ax5qgs9zb3bmvf0nnmmgdx14s4j2apdy2m34v8n'';
+  };
+
+  overrides = x: {
+    postInstall = ''
+        echo "$CL_SOURCE_REGISTRY"
+        NIX_LISP_PRELAUNCH_HOOK='nix_lisp_run_single_form "(asdf:load-system :cl-syntax-annot)"' "$out/bin/cl-syntax-annot-lisp-launcher.sh" ""
+    '';
+  };
+}

pkgs/development/lisp-modules/quicklisp-to-nix-output/cl-syntax.nix

···
+args @ { fetchurl, ... }:
+rec {
+  baseName = ''cl-syntax'';
+  version = ''20150407-git'';
+
+  description = ''Reader Syntax Coventions for Common Lisp and SLIME'';
+
+  deps = [ args."named-readtables" args."trivial-types" ];
+
+  src = fetchurl {
+    url = ''http://beta.quicklisp.org/archive/cl-syntax/2015-04-07/cl-syntax-20150407-git.tgz'';
+    sha256 = ''1pz9a7hiql493ax5qgs9zb3bmvf0nnmmgdx14s4j2apdy2m34v8n'';
+  };
+
+  overrides = x: {
+    postInstall = ''
+        echo "$CL_SOURCE_REGISTRY"
+        NIX_LISP_PRELAUNCH_HOOK='nix_lisp_run_single_form "(asdf:load-system :cl-syntax)"' "$out/bin/cl-syntax-lisp-launcher.sh" ""
+    '';
+  };
+}

pkgs/development/lisp-modules/quicklisp-to-nix-output/cl-unicode.nix

···
+args @ { fetchurl, ... }:
+rec {
+  baseName = ''cl-unicode'';
+  version = ''0.1.5'';
+
+  description = ''Portable Unicode Library'';
+
+  deps = [ ];
+
+  src = fetchurl {
+    url = ''http://beta.quicklisp.org/archive/cl-unicode/2014-12-17/cl-unicode-0.1.5.tgz'';
+    sha256 = ''1jd5qq5ji6l749c4x415z22y9r0k9z18pdi9p9fqvamzh854i46n'';
+  };
+
+  overrides = x: {
+    postInstall = ''
+        echo "$CL_SOURCE_REGISTRY"
+        NIX_LISP_PRELAUNCH_HOOK='nix_lisp_run_single_form "(asdf:load-system :cl-unicode)"' "$out/bin/cl-unicode-lisp-launcher.sh" ""
+    '';
+  };
+}

pkgs/development/lisp-modules/quicklisp-to-nix-output/cl-utilities.nix

···
     url = ''http://beta.quicklisp.org/archive/cl-utilities/2010-10-06/cl-utilities-1.2.4.tgz'';
     sha256 = ''1z2ippnv2wgyxpz15zpif7j7sp1r20fkjhm4n6am2fyp6a3k3a87'';
   };
+
+  overrides = x: {
+    postInstall = ''
+        echo "$CL_SOURCE_REGISTRY"
+        NIX_LISP_PRELAUNCH_HOOK='nix_lisp_run_single_form "(asdf:load-system :cl-utilities)"' "$out/bin/cl-utilities-lisp-launcher.sh" ""
+    '';
+  };
 }

pkgs/development/lisp-modules/quicklisp-to-nix-output/cl-who.nix

···
+args @ { fetchurl, ... }:
+rec {
+  baseName = ''cl-who'';
+  version = ''1.1.4'';
+
+  description = ''(X)HTML generation macros'';
+
+  deps = [ ];
+
+  src = fetchurl {
+    url = ''http://beta.quicklisp.org/archive/cl-who/2014-12-17/cl-who-1.1.4.tgz'';
+    sha256 = ''0r9wc92njz1cc7nghgbhdmd7jy216ylhlabfj0vc45bmfa4w44rq'';
+  };
+
+  overrides = x: {
+    postInstall = ''
+        echo "$CL_SOURCE_REGISTRY"
+        NIX_LISP_PRELAUNCH_HOOK='nix_lisp_run_single_form "(asdf:load-system :cl-who)"' "$out/bin/cl-who-lisp-launcher.sh" ""
+    '';
+  };
+}

pkgs/development/lisp-modules/quicklisp-to-nix-output/clack-v1-compat.nix

···
+args @ { fetchurl, ... }:
+rec {
+  baseName = ''clack-v1-compat'';
+  version = ''clack-20170227-git'';
+
+  description = '''';
+
+  deps = [ ];
+
+  src = fetchurl {
+    url = ''http://beta.quicklisp.org/archive/clack/2017-02-27/clack-20170227-git.tgz'';
+    sha256 = ''1sm6iamghpzmrv0h375y2famdngx62ml5dw424896kixxfyr923x'';
+  };
+
+  overrides = x: {
+    postInstall = ''
+        echo "$CL_SOURCE_REGISTRY"
+        NIX_LISP_PRELAUNCH_HOOK='nix_lisp_run_single_form "(asdf:load-system :clack-v1-compat)"' "$out/bin/clack-v1-compat-lisp-launcher.sh" ""
+    '';
+  };
+}

pkgs/development/lisp-modules/quicklisp-to-nix-output/clack.nix

···
+args @ { fetchurl, ... }:
+rec {
+  baseName = ''clack'';
+  version = ''20170227-git'';
+
+  description = ''Web application environment for Common Lisp'';
+
+  deps = [ ];
+
+  src = fetchurl {
+    url = ''http://beta.quicklisp.org/archive/clack/2017-02-27/clack-20170227-git.tgz'';
+    sha256 = ''1sm6iamghpzmrv0h375y2famdngx62ml5dw424896kixxfyr923x'';
+  };
+
+  overrides = x: {
+    postInstall = ''
+        echo "$CL_SOURCE_REGISTRY"
+        NIX_LISP_PRELAUNCH_HOOK='nix_lisp_run_single_form "(asdf:load-system :clack)"' "$out/bin/clack-lisp-launcher.sh" ""
+    '';
+  };
+}

pkgs/development/lisp-modules/quicklisp-to-nix-output/closer-mop.nix

···
+args @ { fetchurl, ... }:
+rec {
+  baseName = ''closer-mop'';
+  version = ''20170227-git'';
+
+  description = ''Closer to MOP is a compatibility layer that rectifies many of the absent or incorrect CLOS MOP features across a broad range of Common Lisp implementations.'';
+
+  deps = [ ];
+
+  src = fetchurl {
+    url = ''http://beta.quicklisp.org/archive/closer-mop/2017-02-27/closer-mop-20170227-git.tgz'';
+    sha256 = ''1hdnbryh6gd8kn20yr5ldgkcs8i71c6awwf6a32nmp9l42gwv9k3'';
+  };
+
+  overrides = x: {
+    postInstall = ''
+        echo "$CL_SOURCE_REGISTRY"
+        NIX_LISP_PRELAUNCH_HOOK='nix_lisp_run_single_form "(asdf:load-system :closer-mop)"' "$out/bin/closer-mop-lisp-launcher.sh" ""
+    '';
+  };
+}

pkgs/development/lisp-modules/quicklisp-to-nix-output/closure-common.nix

···
+args @ { fetchurl, ... }:
+rec {
+  baseName = ''closure-common'';
+  version = ''20101107-git'';
+
+  description = '''';
+
+  deps = [ args."babel" args."trivial-gray-streams" ];
+
+  src = fetchurl {
+    url = ''http://beta.quicklisp.org/archive/closure-common/2010-11-07/closure-common-20101107-git.tgz'';
+    sha256 = ''1982dpn2z7rlznn74gxy9biqybh2d4r1n688h9pn1s2bssgv3hk4'';
+  };
+
+  overrides = x: {
+    postInstall = ''
+        echo "$CL_SOURCE_REGISTRY"
+        NIX_LISP_PRELAUNCH_HOOK='nix_lisp_run_single_form "(asdf:load-system :closure-common)"' "$out/bin/closure-common-lisp-launcher.sh" ""
+    '';
+  };
+}

pkgs/development/lisp-modules/quicklisp-to-nix-output/clss.nix

···
+args @ { fetchurl, ... }:
+rec {
+  baseName = ''clss'';
+  version = ''20170124-git'';
+
+  description = ''A DOM tree searching engine based on CSS selectors.'';
+
+  deps = [ args."array-utils" args."plump" ];
+
+  src = fetchurl {
+    url = ''http://beta.quicklisp.org/archive/clss/2017-01-24/clss-20170124-git.tgz'';
+    sha256 = ''0rrg3brzash1b14n686xjx6d5glm2vg32g0i8hyvaffqd82493pb'';
+  };
+
+  overrides = x: {
+    postInstall = ''
+        echo "$CL_SOURCE_REGISTRY"
+        NIX_LISP_PRELAUNCH_HOOK='nix_lisp_run_single_form "(asdf:load-system :clss)"' "$out/bin/clss-lisp-launcher.sh" ""
+    '';
+  };
+}

pkgs/development/lisp-modules/quicklisp-to-nix-output/clx.nix

···
     url = ''http://beta.quicklisp.org/archive/clx/2017-02-27/clx-20170227-git.tgz'';
     sha256 = ''0zgp1yqy0lm528bhil93ap7df01qdyfhnbxhckjv87xk8rs0g5nx'';
   };
+
+  overrides = x: {
+    postInstall = ''
+        echo "$CL_SOURCE_REGISTRY"
+        NIX_LISP_PRELAUNCH_HOOK='nix_lisp_run_single_form "(asdf:load-system :clx)"' "$out/bin/clx-lisp-launcher.sh" ""
+    '';
+  };
 }

pkgs/development/lisp-modules/quicklisp-to-nix-output/css-lite.nix

···
+args @ { fetchurl, ... }:
+rec {
+  baseName = ''css-lite'';
+  version = ''20120407-git'';
+
+  description = '''';
+
+  deps = [ ];
+
+  src = fetchurl {
+    url = ''http://beta.quicklisp.org/archive/css-lite/2012-04-07/css-lite-20120407-git.tgz'';
+    sha256 = ''1gf1qqaxhly6ixh9ykqhg9b52s8p5wlwi46vp2k29qy7gmx4f1qg'';
+  };
+
+  overrides = x: {
+    postInstall = ''
+        echo "$CL_SOURCE_REGISTRY"
+        NIX_LISP_PRELAUNCH_HOOK='nix_lisp_run_single_form "(asdf:load-system :css-lite)"' "$out/bin/css-lite-lisp-launcher.sh" ""
+    '';
+  };
+}

pkgs/development/lisp-modules/quicklisp-to-nix-output/cxml-dom.nix

···
+args @ { fetchurl, ... }:
+rec {
+  baseName = ''cxml-dom'';
+  version = ''cxml-20110619-git'';
+
+  description = '''';
+
+  deps = [ args."cxml-xml" ];
+
+  src = fetchurl {
+    url = ''http://beta.quicklisp.org/archive/cxml/2011-06-19/cxml-20110619-git.tgz'';
+    sha256 = ''04k6syn9p7qsazi84kab9n9ki2pb5hrcs0ilw7wikxfqnbabm2yk'';
+  };
+
+  overrides = x: {
+    postInstall = ''
+        echo "$CL_SOURCE_REGISTRY"
+        NIX_LISP_PRELAUNCH_HOOK='nix_lisp_run_single_form "(asdf:load-system :cxml)"' "$out/bin/cxml-dom-lisp-launcher.sh" ""
+    '';
+  };
+}

pkgs/development/lisp-modules/quicklisp-to-nix-output/cxml-klacks.nix

···
+args @ { fetchurl, ... }:
+rec {
+  baseName = ''cxml-klacks'';
+  version = ''cxml-20110619-git'';
+
+  description = '''';
+
+  deps = [ args."cxml-xml" ];
+
+  src = fetchurl {
+    url = ''http://beta.quicklisp.org/archive/cxml/2011-06-19/cxml-20110619-git.tgz'';
+    sha256 = ''04k6syn9p7qsazi84kab9n9ki2pb5hrcs0ilw7wikxfqnbabm2yk'';
+  };
+
+  overrides = x: {
+    postInstall = ''
+        echo "$CL_SOURCE_REGISTRY"
+        NIX_LISP_PRELAUNCH_HOOK='nix_lisp_run_single_form "(asdf:load-system :cxml)"' "$out/bin/cxml-klacks-lisp-launcher.sh" ""
+    '';
+  };
+}

pkgs/development/lisp-modules/quicklisp-to-nix-output/cxml-test.nix

···
+args @ { fetchurl, ... }:
+rec {
+  baseName = ''cxml-test'';
+  version = ''cxml-20110619-git'';
+
+  description = '''';
+
+  deps = [ args."cxml-dom" args."cxml-klacks" args."cxml-xml" ];
+
+  src = fetchurl {
+    url = ''http://beta.quicklisp.org/archive/cxml/2011-06-19/cxml-20110619-git.tgz'';
+    sha256 = ''04k6syn9p7qsazi84kab9n9ki2pb5hrcs0ilw7wikxfqnbabm2yk'';
+  };
+
+  overrides = x: {
+    postInstall = ''
+        echo "$CL_SOURCE_REGISTRY"
+        NIX_LISP_PRELAUNCH_HOOK='nix_lisp_run_single_form "(asdf:load-system :cxml)"' "$out/bin/cxml-test-lisp-launcher.sh" ""
+    '';
+  };
+}

pkgs/development/lisp-modules/quicklisp-to-nix-output/cxml-xml.nix

···
+args @ { fetchurl, ... }:
+rec {
+  baseName = ''cxml-xml'';
+  version = ''cxml-20110619-git'';
+
+  description = '''';
+
+  deps = [ args."closure-common" args."puri" args."trivial-gray-streams" ];
+
+  src = fetchurl {
+    url = ''http://beta.quicklisp.org/archive/cxml/2011-06-19/cxml-20110619-git.tgz'';
+    sha256 = ''04k6syn9p7qsazi84kab9n9ki2pb5hrcs0ilw7wikxfqnbabm2yk'';
+  };
+
+  overrides = x: {
+    postInstall = ''
+        echo "$CL_SOURCE_REGISTRY"
+        NIX_LISP_PRELAUNCH_HOOK='nix_lisp_run_single_form "(asdf:load-system :cxml)"' "$out/bin/cxml-xml-lisp-launcher.sh" ""
+    '';
+  };
+}

pkgs/development/lisp-modules/quicklisp-to-nix-output/cxml.nix

···
+args @ { fetchurl, ... }:
+rec {
+  baseName = ''cxml'';
+  version = ''20110619-git'';
+
+  description = '''';
+
+  deps = [ args."cxml-dom" args."cxml-klacks" args."cxml-test" ];
+
+  src = fetchurl {
+    url = ''http://beta.quicklisp.org/archive/cxml/2011-06-19/cxml-20110619-git.tgz'';
+    sha256 = ''04k6syn9p7qsazi84kab9n9ki2pb5hrcs0ilw7wikxfqnbabm2yk'';
+  };
+
+  overrides = x: {
+    postInstall = ''
+        echo "$CL_SOURCE_REGISTRY"
+        NIX_LISP_PRELAUNCH_HOOK='nix_lisp_run_single_form "(asdf:load-system :cxml)"' "$out/bin/cxml-lisp-launcher.sh" ""
+    '';
+  };
+}

pkgs/development/lisp-modules/quicklisp-to-nix-output/dexador.nix

···
+args @ { fetchurl, ... }:
+rec {
+  baseName = ''dexador'';
+  version = ''20170227-git'';
+
+  description = ''Yet another HTTP client for Common Lisp'';
+
+  deps = [ ];
+
+  src = fetchurl {
+    url = ''http://beta.quicklisp.org/archive/dexador/2017-02-27/dexador-20170227-git.tgz'';
+    sha256 = ''0fc3hlckxfwz1ymindb9p44c6idfz8z6w5zk8cbd4nvvd0f2a8kz'';
+  };
+
+  overrides = x: {
+    postInstall = ''
+        echo "$CL_SOURCE_REGISTRY"
+        NIX_LISP_PRELAUNCH_HOOK='nix_lisp_run_single_form "(asdf:load-system :dexador)"' "$out/bin/dexador-lisp-launcher.sh" ""
+    '';
+  };
+}

pkgs/development/lisp-modules/quicklisp-to-nix-output/do-urlencode.nix

···
+args @ { fetchurl, ... }:
+rec {
+  baseName = ''do-urlencode'';
+  version = ''20130720-git'';
+
+  description = ''Percent Encoding (aka URL Encoding) library'';
+
+  deps = [ args."babel" args."babel-streams" ];
+
+  src = fetchurl {
+    url = ''http://beta.quicklisp.org/archive/do-urlencode/2013-07-20/do-urlencode-20130720-git.tgz'';
+    sha256 = ''19l4rwqc52w7nrpy994b3n2dcv8pjgc530yn2xmgqlqabpxpz3xa'';
+  };
+
+  overrides = x: {
+    postInstall = ''
+        echo "$CL_SOURCE_REGISTRY"
+        NIX_LISP_PRELAUNCH_HOOK='nix_lisp_run_single_form "(asdf:load-system :do-urlencode)"' "$out/bin/do-urlencode-lisp-launcher.sh" ""
+    '';
+  };
+}

pkgs/development/lisp-modules/quicklisp-to-nix-output/documentation-utils.nix

···
+args @ { fetchurl, ... }:
+rec {
+  baseName = ''documentation-utils'';
+  version = ''20161204-git'';
+
+  description = ''A few simple tools to help you with documenting your library.'';
+
+  deps = [ args."trivial-indent" ];
+
+  src = fetchurl {
+    url = ''http://beta.quicklisp.org/archive/documentation-utils/2016-12-04/documentation-utils-20161204-git.tgz'';
+    sha256 = ''0vyj5nvy697w2fvp2rb42jxgqah85ivz1hg84amqfi4bvik2npvq'';
+  };
+
+  overrides = x: {
+    postInstall = ''
+        echo "$CL_SOURCE_REGISTRY"
+        NIX_LISP_PRELAUNCH_HOOK='nix_lisp_run_single_form "(asdf:load-system :documentation-utils)"' "$out/bin/documentation-utils-lisp-launcher.sh" ""
+    '';
+  };
+}

pkgs/development/lisp-modules/quicklisp-to-nix-output/drakma.nix

···
 
   description = ''Full-featured http/https client based on usocket'';
 
-  deps = [ args."puri" args."cl-base64" args."chunga" args."flexi-streams" args."cl-ppcre" args."chipz" args."usocket" args."cl+ssl" ];
+  deps = [ args."chipz" args."chunga" args."cl+ssl" args."cl-base64" args."cl-ppcre" args."flexi-streams" args."puri" args."usocket" ];
 
   src = fetchurl {
     url = ''http://beta.quicklisp.org/archive/drakma/2015-10-31/drakma-2.0.2.tgz'';
     sha256 = ''1bpwh19fxd1ncvwai2ab2363bk6qkpwch5sa4csbiawcihyawh2z'';
+  };
+
+  overrides = x: {
+    postInstall = ''
+        echo "$CL_SOURCE_REGISTRY"
+        NIX_LISP_PRELAUNCH_HOOK='nix_lisp_run_single_form "(asdf:load-system :drakma)"' "$out/bin/drakma-lisp-launcher.sh" ""
+    '';
   };
 }

pkgs/development/lisp-modules/quicklisp-to-nix-output/esrap.nix

···
     url = ''http://beta.quicklisp.org/archive/esrap/2017-01-24/esrap-20170124-git.tgz'';
     sha256 = ''1182011bbhvkw2qsdqrccl879vf5k7bcda318n0xskk35hzircp8'';
   };
+
+  overrides = x: {
+    postInstall = ''
+        echo "$CL_SOURCE_REGISTRY"
+        NIX_LISP_PRELAUNCH_HOOK='nix_lisp_run_single_form "(asdf:load-system :esrap)"' "$out/bin/esrap-lisp-launcher.sh" ""
+    '';
+  };
 }

pkgs/development/lisp-modules/quicklisp-to-nix-output/external-program.nix

···
     url = ''http://beta.quicklisp.org/archive/external-program/2016-08-25/external-program-20160825-git.tgz'';
     sha256 = ''0avnnhxxa1wfri9i3m1339nszyp1w2cilycc948nf5awz4mckq13'';
   };
+
+  overrides = x: {
+    postInstall = ''
+        echo "$CL_SOURCE_REGISTRY"
+        NIX_LISP_PRELAUNCH_HOOK='nix_lisp_run_single_form "(asdf:load-system :external-program)"' "$out/bin/external-program-lisp-launcher.sh" ""
+    '';
+  };
 }

pkgs/development/lisp-modules/quicklisp-to-nix-output/fast-http.nix

···
+args @ { fetchurl, ... }:
+rec {
+  baseName = ''fast-http'';
+  version = ''20170227-git'';
+
+  description = ''A fast HTTP protocol parser in Common Lisp'';
+
+  deps = [ ];
+
+  src = fetchurl {
+    url = ''http://beta.quicklisp.org/archive/fast-http/2017-02-27/fast-http-20170227-git.tgz'';
+    sha256 = ''0kpfn4i5r12hfnb3j00cl9wq5dcl32n3q67lr2qsb6y3giz335hx'';
+  };
+
+  overrides = x: {
+    postInstall = ''
+        echo "$CL_SOURCE_REGISTRY"
+        NIX_LISP_PRELAUNCH_HOOK='nix_lisp_run_single_form "(asdf:load-system :fast-http)"' "$out/bin/fast-http-lisp-launcher.sh" ""
+    '';
+  };
+}

pkgs/development/lisp-modules/quicklisp-to-nix-output/fast-io.nix

···
+args @ { fetchurl, ... }:
+rec {
+  baseName = ''fast-io'';
+  version = ''20170124-git'';
+
+  description = ''Alternative I/O mechanism to a stream or vector'';
+
+  deps = [ args."alexandria" args."static-vectors" args."trivial-gray-streams" ];
+
+  src = fetchurl {
+    url = ''http://beta.quicklisp.org/archive/fast-io/2017-01-24/fast-io-20170124-git.tgz'';
+    sha256 = ''0w57iddbpdcchnv3zg7agd3ydm36aw2mni4iasi8wd628gq9a6i2'';
+  };
+
+  overrides = x: {
+    postInstall = ''
+        echo "$CL_SOURCE_REGISTRY"
+        NIX_LISP_PRELAUNCH_HOOK='nix_lisp_run_single_form "(asdf:load-system :fast-io)"' "$out/bin/fast-io-lisp-launcher.sh" ""
+    '';
+  };
+}

pkgs/development/lisp-modules/quicklisp-to-nix-output/flexi-streams.nix

···
     url = ''http://beta.quicklisp.org/archive/flexi-streams/2015-07-09/flexi-streams-1.0.15.tgz'';
     sha256 = ''0zkx335winqs7xigbmxhhkhcsfa9hjhf1q6r4q710y29fbhpc37p'';
   };
+
+  overrides = x: {
+    postInstall = ''
+        echo "$CL_SOURCE_REGISTRY"
+        NIX_LISP_PRELAUNCH_HOOK='nix_lisp_run_single_form "(asdf:load-system :flexi-streams)"' "$out/bin/flexi-streams-lisp-launcher.sh" ""
+    '';
+  };
 }

pkgs/development/lisp-modules/quicklisp-to-nix-output/form-fiddle.nix

···
+args @ { fetchurl, ... }:
+rec {
+  baseName = ''form-fiddle'';
+  version = ''20160929-git'';
+
+  description = ''A collection of utilities to destructure lambda forms.'';
+
+  deps = [ args."documentation-utils" ];
+
+  src = fetchurl {
+    url = ''http://beta.quicklisp.org/archive/form-fiddle/2016-09-29/form-fiddle-20160929-git.tgz'';
+    sha256 = ''1lmdxvwh0d81jlkc9qq2cw0bizjbmk7f5fjcb8ps65andfyj9bd7'';
+  };
+
+  overrides = x: {
+    postInstall = ''
+        echo "$CL_SOURCE_REGISTRY"
+        NIX_LISP_PRELAUNCH_HOOK='nix_lisp_run_single_form "(asdf:load-system :form-fiddle)"' "$out/bin/form-fiddle-lisp-launcher.sh" ""
+    '';
+  };
+}

pkgs/development/lisp-modules/quicklisp-to-nix-output/http-body.nix

···
+args @ { fetchurl, ... }:
+rec {
+  baseName = ''http-body'';
+  version = ''20161204-git'';
+
+  description = ''HTTP POST data parser for Common Lisp'';
+
+  deps = [ args."babel" args."cl-ppcre" args."cl-utilities" args."fast-http" args."flexi-streams" args."jonathan" args."quri" args."trivial-gray-streams" ];
+
+  src = fetchurl {
+    url = ''http://beta.quicklisp.org/archive/http-body/2016-12-04/http-body-20161204-git.tgz'';
+    sha256 = ''1y50yipsbl4j99igmfi83pr7p56hb31dcplpy05fp5alkb5rv0gi'';
+  };
+
+  overrides = x: {
+    postInstall = ''
+        echo "$CL_SOURCE_REGISTRY"
+        NIX_LISP_PRELAUNCH_HOOK='nix_lisp_run_single_form "(asdf:load-system :http-body)"' "$out/bin/http-body-lisp-launcher.sh" ""
+    '';
+  };
+}

pkgs/development/lisp-modules/quicklisp-to-nix-output/hunchentoot.nix

···
   simple framework for user-defined handlers and can be extended
   through subclassing.'';
 
-  deps = [ args."chunga" args."cl-base64" args."cl-fad" args."cl-ppcre" args."flexi-streams" args."cl+ssl" args."md5" args."rfc2388" args."trivial-backtrace" args."usocket" args."bordeaux-threads" ];
+  deps = [ args."bordeaux-threads" args."chunga" args."cl+ssl" args."cl-base64" args."cl-fad" args."cl-ppcre" args."flexi-streams" args."md5" args."rfc2388" args."trivial-backtrace" args."usocket" ];
 
   src = fetchurl {
     url = ''http://beta.quicklisp.org/archive/hunchentoot/2016-03-18/hunchentoot-1.2.35.tgz'';
     sha256 = ''0gp2rgndkijjydb1x3p8414ii1z372gzdy945jy0491bcbhygj74'';
+  };
+
+  overrides = x: {
+    postInstall = ''
+        echo "$CL_SOURCE_REGISTRY"
+        NIX_LISP_PRELAUNCH_HOOK='nix_lisp_run_single_form "(asdf:load-system :hunchentoot)"' "$out/bin/hunchentoot-lisp-launcher.sh" ""
+    '';
   };
 }

pkgs/development/lisp-modules/quicklisp-to-nix-output/idna.nix

···
     url = ''http://beta.quicklisp.org/archive/idna/2012-01-07/idna-20120107-git.tgz'';
     sha256 = ''0q9hja9v5q7z89p0bzm2whchn05hymn3255fr5zj3fkja8akma5c'';
   };
+
+  overrides = x: {
+    postInstall = ''
+        echo "$CL_SOURCE_REGISTRY"
+        NIX_LISP_PRELAUNCH_HOOK='nix_lisp_run_single_form "(asdf:load-system :idna)"' "$out/bin/idna-lisp-launcher.sh" ""
+    '';
+  };
 }

pkgs/development/lisp-modules/quicklisp-to-nix-output/iolib.nix

···
 
   description = ''I/O library.'';
 
-  deps = [ args."iolib/base" args."iolib/multiplex" args."iolib/streams" args."iolib/sockets" ];
+  deps = [ args."alexandria" args."babel" args."bordeaux-threads" args."cffi" args."idna" args."split-sequence" args."swap-bytes" args."trivial-features" args."uiop" ];
 
   src = fetchurl {
     url = ''http://beta.quicklisp.org/archive/iolib/2016-03-18/iolib-v0.8.1.tgz'';
     sha256 = ''090xmjzyx5d7arpk9g0fsyblwh6myq2d1cb7w52r3zy1394c9481'';
+  };
+
+  overrides = x: {
+    postInstall = ''
+        echo "$CL_SOURCE_REGISTRY"
+        NIX_LISP_PRELAUNCH_HOOK='nix_lisp_run_single_form "(asdf:load-system :iolib)"' "$out/bin/iolib-lisp-launcher.sh" ""
+    '';
   };
 }

pkgs/development/lisp-modules/quicklisp-to-nix-output/iolib_slash_asdf.nix

···
-args @ { fetchurl, ... }:
-rec {
-  baseName = ''iolib_slash_asdf'';
-  version = ''iolib-v0.8.1'';
-
-  description = ''A few ASDF component classes.'';
-
-  deps = [ args."alexandria" ];
-
-  src = fetchurl {
-    url = ''http://beta.quicklisp.org/archive/iolib/2016-03-18/iolib-v0.8.1.tgz'';
-    sha256 = ''090xmjzyx5d7arpk9g0fsyblwh6myq2d1cb7w52r3zy1394c9481'';
-  };
-}

pkgs/development/lisp-modules/quicklisp-to-nix-output/iolib_slash_base.nix

···
-args @ { fetchurl, ... }:
-rec {
-  baseName = ''iolib_slash_base'';
-  version = ''iolib-v0.8.1'';
-
-  description = ''Base IOlib package, used instead of CL.'';
-
-  deps = [ args."iolib/common-lisp" args."alexandria" args."split-sequence" ];
-
-  src = fetchurl {
-    url = ''http://beta.quicklisp.org/archive/iolib/2016-03-18/iolib-v0.8.1.tgz'';
-    sha256 = ''090xmjzyx5d7arpk9g0fsyblwh6myq2d1cb7w52r3zy1394c9481'';
-  };
-}

pkgs/development/lisp-modules/quicklisp-to-nix-output/iolib_slash_common-lisp.nix

···
-args @ { fetchurl, ... }:
-rec {
-  baseName = ''iolib_slash_common-lisp'';
-  version = ''iolib-v0.8.1'';
-
-  description = ''Slightly modified Common Lisp.'';
-
-  deps = [ args."alexandria" ];
-
-  src = fetchurl {
-    url = ''http://beta.quicklisp.org/archive/iolib/2016-03-18/iolib-v0.8.1.tgz'';
-    sha256 = ''090xmjzyx5d7arpk9g0fsyblwh6myq2d1cb7w52r3zy1394c9481'';
-  };
-}

pkgs/development/lisp-modules/quicklisp-to-nix-output/iolib_slash_conf.nix

···
-args @ { fetchurl, ... }:
-rec {
-  baseName = ''iolib_slash_conf'';
-  version = ''iolib-v0.8.1'';
-
-  description = ''Compile-time configuration for IOLib.'';
-
-  deps = [ ];
-
-  src = fetchurl {
-    url = ''http://beta.quicklisp.org/archive/iolib/2016-03-18/iolib-v0.8.1.tgz'';
-    sha256 = ''090xmjzyx5d7arpk9g0fsyblwh6myq2d1cb7w52r3zy1394c9481'';
-  };
-}

pkgs/development/lisp-modules/quicklisp-to-nix-output/iolib_slash_grovel.nix

···
-args @ { fetchurl, ... }:
-rec {
-  baseName = ''iolib_slash_grovel'';
-  version = ''iolib-v0.8.1'';
-
-  description = ''The CFFI Groveller'';
-
-  deps = [ args."iolib/asdf" args."iolib/base" args."iolib/conf" args."alexandria" args."split-sequence" args."cffi" args."uiop" ];
-
-  src = fetchurl {
-    url = ''http://beta.quicklisp.org/archive/iolib/2016-03-18/iolib-v0.8.1.tgz'';
-    sha256 = ''090xmjzyx5d7arpk9g0fsyblwh6myq2d1cb7w52r3zy1394c9481'';
-  };
-}

pkgs/development/lisp-modules/quicklisp-to-nix-output/iolib_slash_multiplex.nix

···
-args @ { fetchurl, ... }:
-rec {
-  baseName = ''iolib_slash_multiplex'';
-  version = ''iolib-v0.8.1'';
-
-  description = ''I/O multiplexing library.'';
-
-  deps = [ args."iolib/base" args."iolib/syscalls" args."cffi" ];
-
-  src = fetchurl {
-    url = ''http://beta.quicklisp.org/archive/iolib/2016-03-18/iolib-v0.8.1.tgz'';
-    sha256 = ''090xmjzyx5d7arpk9g0fsyblwh6myq2d1cb7w52r3zy1394c9481'';
-  };
-}

pkgs/development/lisp-modules/quicklisp-to-nix-output/iolib_slash_sockets.nix

···
-args @ { fetchurl, ... }:
-rec {
-  baseName = ''iolib_slash_sockets'';
-  version = ''iolib-v0.8.1'';
-
-  description = ''Socket library.'';
-
-  deps = [ args."iolib/base" args."iolib/syscalls" args."iolib/streams" args."babel" args."cffi" args."iolib/grovel" args."bordeaux-threads" args."idna" args."swap-bytes" ];
-
-  src = fetchurl {
-    url = ''http://beta.quicklisp.org/archive/iolib/2016-03-18/iolib-v0.8.1.tgz'';
-    sha256 = ''090xmjzyx5d7arpk9g0fsyblwh6myq2d1cb7w52r3zy1394c9481'';
-  };
-}

pkgs/development/lisp-modules/quicklisp-to-nix-output/iolib_slash_streams.nix

···
-args @ { fetchurl, ... }:
-rec {
-  baseName = ''iolib_slash_streams'';
-  version = ''iolib-v0.8.1'';
-
-  description = ''Gray streams.'';
-
-  deps = [ args."iolib/base" args."iolib/multiplex" args."cffi" ];
-
-  src = fetchurl {
-    url = ''http://beta.quicklisp.org/archive/iolib/2016-03-18/iolib-v0.8.1.tgz'';
-    sha256 = ''090xmjzyx5d7arpk9g0fsyblwh6myq2d1cb7w52r3zy1394c9481'';
-  };
-}

pkgs/development/lisp-modules/quicklisp-to-nix-output/iolib_slash_syscalls.nix

···
-args @ { fetchurl, ... }:
-rec {
-  baseName = ''iolib_slash_syscalls'';
-  version = ''iolib-v0.8.1'';
-
-  description = ''Syscalls and foreign types.'';
-
-  deps = [ args."trivial-features" args."cffi" args."iolib/base" args."iolib/grovel" ];
-
-  src = fetchurl {
-    url = ''http://beta.quicklisp.org/archive/iolib/2016-03-18/iolib-v0.8.1.tgz'';
-    sha256 = ''090xmjzyx5d7arpk9g0fsyblwh6myq2d1cb7w52r3zy1394c9481'';
-  };
-}

pkgs/development/lisp-modules/quicklisp-to-nix-output/ironclad.nix

···
+args @ { fetchurl, ... }:
+rec {
+  baseName = ''ironclad'';
+  version = ''ironclad_0.33.0'';
+
+  description = ''A cryptographic toolkit written in pure Common Lisp'';
+
+  deps = [ args."nibbles" ];
+
+  src = fetchurl {
+    url = ''http://beta.quicklisp.org/archive/ironclad/2014-11-06/ironclad_0.33.0.tgz'';
+    sha256 = ''1ld0xz8gmi566zxl1cva5yi86aw1wb6i6446gxxdw1lisxx3xwz7'';
+  };
+
+  overrides = x: {
+    postInstall = ''
+        echo "$CL_SOURCE_REGISTRY"
+        NIX_LISP_PRELAUNCH_HOOK='nix_lisp_run_single_form "(asdf:load-system :ironclad)"' "$out/bin/ironclad-lisp-launcher.sh" ""
+    '';
+  };
+}

pkgs/development/lisp-modules/quicklisp-to-nix-output/iterate.nix

···
     url = ''http://beta.quicklisp.org/archive/iterate/2016-08-25/iterate-20160825-darcs.tgz'';
     sha256 = ''0kvz16gnxnkdz0fy1x8y5yr28nfm7i2qpvix7mgwccdpjmsb4pgm'';
   };
+
+  overrides = x: {
+    postInstall = ''
+        echo "$CL_SOURCE_REGISTRY"
+        NIX_LISP_PRELAUNCH_HOOK='nix_lisp_run_single_form "(asdf:load-system :iterate)"' "$out/bin/iterate-lisp-launcher.sh" ""
+    '';
+  };
 }

pkgs/development/lisp-modules/quicklisp-to-nix-output/jonathan.nix

···
+args @ { fetchurl, ... }:
+rec {
+  baseName = ''jonathan'';
+  version = ''20170124-git'';
+
+  description = ''High performance JSON encoder and decoder. Currently support: SBCL, CCL.'';
+
+  deps = [ args."babel" args."cl-annot" args."cl-ppcre" args."cl-syntax" args."cl-syntax-annot" args."fast-io" args."proc-parse" args."trivial-types" ];
+
+  src = fetchurl {
+    url = ''http://beta.quicklisp.org/archive/jonathan/2017-01-24/jonathan-20170124-git.tgz'';
+    sha256 = ''1r54w7i1fxaqz6q7idamcy3bvsg0pvfjcs2qq4dag519zwcpln5l'';
+  };
+
+  overrides = x: {
+    postInstall = ''
+        echo "$CL_SOURCE_REGISTRY"
+        NIX_LISP_PRELAUNCH_HOOK='nix_lisp_run_single_form "(asdf:load-system :jonathan)"' "$out/bin/jonathan-lisp-launcher.sh" ""
+    '';
+  };
+}

pkgs/development/lisp-modules/quicklisp-to-nix-output/lack-component.nix

···
+args @ { fetchurl, ... }:
+rec {
+  baseName = ''lack-component'';
+  version = ''lack-20161204-git'';
+
+  description = '''';
+
+  deps = [ ];
+
+  src = fetchurl {
+    url = ''http://beta.quicklisp.org/archive/lack/2016-12-04/lack-20161204-git.tgz'';
+    sha256 = ''10bnpgbh5nk9lw1xywmvh5661rq91v8sp43ds53x98865ni7flnv'';
+  };
+
+  overrides = x: {
+    postInstall = ''
+        echo "$CL_SOURCE_REGISTRY"
+        NIX_LISP_PRELAUNCH_HOOK='nix_lisp_run_single_form "(asdf:load-system :lack-component)"' "$out/bin/lack-component-lisp-launcher.sh" ""
+    '';
+  };
+}

pkgs/development/lisp-modules/quicklisp-to-nix-output/lack-util.nix

···
+args @ { fetchurl, ... }:
+rec {
+  baseName = ''lack-util'';
+  version = ''lack-20161204-git'';
+
+  description = '''';
+
+  deps = [ args."ironclad" ];
+
+  src = fetchurl {
+    url = ''http://beta.quicklisp.org/archive/lack/2016-12-04/lack-20161204-git.tgz'';
+    sha256 = ''10bnpgbh5nk9lw1xywmvh5661rq91v8sp43ds53x98865ni7flnv'';
+  };
+
+  overrides = x: {
+    postInstall = ''
+        echo "$CL_SOURCE_REGISTRY"
+        NIX_LISP_PRELAUNCH_HOOK='nix_lisp_run_single_form "(asdf:load-system :lack-util)"' "$out/bin/lack-util-lisp-launcher.sh" ""
+    '';
+  };
+}

pkgs/development/lisp-modules/quicklisp-to-nix-output/lack.nix

···
+args @ { fetchurl, ... }:
+rec {
+  baseName = ''lack'';
+  version = ''20161204-git'';
+
+  description = ''A minimal Clack'';
+
+  deps = [ args."lack-component" args."lack-util" ];
+
+  src = fetchurl {
+    url = ''http://beta.quicklisp.org/archive/lack/2016-12-04/lack-20161204-git.tgz'';
+    sha256 = ''10bnpgbh5nk9lw1xywmvh5661rq91v8sp43ds53x98865ni7flnv'';
+  };
+
+  overrides = x: {
+    postInstall = ''
+        echo "$CL_SOURCE_REGISTRY"
+        NIX_LISP_PRELAUNCH_HOOK='nix_lisp_run_single_form "(asdf:load-system :lack)"' "$out/bin/lack-lisp-launcher.sh" ""
+    '';
+  };
+}

pkgs/development/lisp-modules/quicklisp-to-nix-output/let-plus.nix

···
+args @ { fetchurl, ... }:
+rec {
+  baseName = ''let-plus'';
+  version = ''20170124-git'';
+
+  description = ''Destructuring extension of LET*.'';
+
+  deps = [ args."alexandria" args."anaphora" ];
+
+  src = fetchurl {
+    url = ''http://beta.quicklisp.org/archive/let-plus/2017-01-24/let-plus-20170124-git.tgz'';
+    sha256 = ''1hfsw4g36vccz2lx6gk375arjj6y85yh9ch3pq7yiybjlxx68xi8'';
+  };
+
+  overrides = x: {
+    postInstall = ''
+        echo "$CL_SOURCE_REGISTRY"
+        NIX_LISP_PRELAUNCH_HOOK='nix_lisp_run_single_form "(asdf:load-system :let-plus)"' "$out/bin/let-plus-lisp-launcher.sh" ""
+    '';
+  };
+}

pkgs/development/lisp-modules/quicklisp-to-nix-output/lev.nix

···
+args @ { fetchurl, ... }:
+rec {
+  baseName = ''lev'';
+  version = ''20150505-git'';
+
+  description = ''libev bindings for Common Lisp'';
+
+  deps = [ args."cffi" ];
+
+  src = fetchurl {
+    url = ''http://beta.quicklisp.org/archive/lev/2015-05-05/lev-20150505-git.tgz'';
+    sha256 = ''0lkkzb221ks4f0qjgh6pr5lyvb4884a87p96ir4m36x411pyk5xl'';
+  };
+
+  overrides = x: {
+    postInstall = ''
+        echo "$CL_SOURCE_REGISTRY"
+        NIX_LISP_PRELAUNCH_HOOK='nix_lisp_run_single_form "(asdf:load-system :lev)"' "$out/bin/lev-lisp-launcher.sh" ""
+    '';
+  };
+}

pkgs/development/lisp-modules/quicklisp-to-nix-output/local-time.nix

···
+args @ { fetchurl, ... }:
+rec {
+  baseName = ''local-time'';
+  version = ''20170124-git'';
+
+  description = ''A library for manipulating dates and times, based on a paper by Erik Naggum'';
+
+  deps = [ args."cl-fad" ];
+
+  src = fetchurl {
+    url = ''http://beta.quicklisp.org/archive/local-time/2017-01-24/local-time-20170124-git.tgz'';
+    sha256 = ''0nf21bhclr2cwpflf733wn6hr6mcz94dr796jk91f0ck28nf7ab1'';
+  };
+
+  overrides = x: {
+    postInstall = ''
+        echo "$CL_SOURCE_REGISTRY"
+        NIX_LISP_PRELAUNCH_HOOK='nix_lisp_run_single_form "(asdf:load-system :local-time)"' "$out/bin/local-time-lisp-launcher.sh" ""
+    '';
+  };
+}

pkgs/development/lisp-modules/quicklisp-to-nix-output/lquery.nix

···
+args @ { fetchurl, ... }:
+rec {
+  baseName = ''lquery'';
+  version = ''20160929-git'';
+
+  description = ''A library to allow jQuery-like HTML/DOM manipulation.'';
+
+  deps = [ args."array-utils" args."clss" args."form-fiddle" args."plump" ];
+
+  src = fetchurl {
+    url = ''http://beta.quicklisp.org/archive/lquery/2016-09-29/lquery-20160929-git.tgz'';
+    sha256 = ''1kqc0n4zh44yay9vbv6wirk3122q7if2999146lrgada5fy17r7x'';
+  };
+
+  overrides = x: {
+    postInstall = ''
+        echo "$CL_SOURCE_REGISTRY"
+        NIX_LISP_PRELAUNCH_HOOK='nix_lisp_run_single_form "(asdf:load-system :lquery)"' "$out/bin/lquery-lisp-launcher.sh" ""
+    '';
+  };
+}

pkgs/development/lisp-modules/quicklisp-to-nix-output/map-set.nix

···
+args @ { fetchurl, ... }:
+rec {
+  baseName = ''map-set'';
+  version = ''20160628-hg'';
+
+  description = ''Set-like data structure.'';
+
+  deps = [ ];
+
+  src = fetchurl {
+    url = ''http://beta.quicklisp.org/archive/map-set/2016-06-28/map-set-20160628-hg.tgz'';
+    sha256 = ''15fbha43a5153ah836djp9dbg41728adjrzwryv68gcqs31rjk9v'';
+  };
+
+  overrides = x: {
+    postInstall = ''
+        echo "$CL_SOURCE_REGISTRY"
+        NIX_LISP_PRELAUNCH_HOOK='nix_lisp_run_single_form "(asdf:load-system :map-set)"' "$out/bin/map-set-lisp-launcher.sh" ""
+    '';
+  };
+}

pkgs/development/lisp-modules/quicklisp-to-nix-output/marshal.nix

···
+args @ { fetchurl, ... }:
+rec {
+  baseName = ''marshal'';
+  version = ''cl-20170124-git'';
+
+  description = ''marshal: Simple (de)serialization of Lisp datastructures.'';
+
+  deps = [ ];
+
+  src = fetchurl {
+    url = ''http://beta.quicklisp.org/archive/cl-marshal/2017-01-24/cl-marshal-20170124-git.tgz'';
+    sha256 = ''0z43m3jspl4c4fcbbxm58hxd9k69308pyijgj7grmq6mirkq664d'';
+  };
+
+  overrides = x: {
+    postInstall = ''
+        echo "$CL_SOURCE_REGISTRY"
+        NIX_LISP_PRELAUNCH_HOOK='nix_lisp_run_single_form "(asdf:load-system :marshal)"' "$out/bin/marshal-lisp-launcher.sh" ""
+    '';
+  };
+}

pkgs/development/lisp-modules/quicklisp-to-nix-output/md5.nix

···
     url = ''http://beta.quicklisp.org/archive/md5/2015-08-04/md5-20150804-git.tgz'';
     sha256 = ''1sf79pjip19sx7zmznz1wm4563qc208lq49m0jnhxbv09wmm4vc5'';
   };
+
+  overrides = x: {
+    postInstall = ''
+        echo "$CL_SOURCE_REGISTRY"
+        NIX_LISP_PRELAUNCH_HOOK='nix_lisp_run_single_form "(asdf:load-system :md5)"' "$out/bin/md5-lisp-launcher.sh" ""
+    '';
+  };
 }

pkgs/development/lisp-modules/quicklisp-to-nix-output/metabang-bind.nix

···
+args @ { fetchurl, ... }:
+rec {
+  baseName = ''metabang-bind'';
+  version = ''20170124-git'';
+
+  description = ''Bind is a macro that generalizes multiple-value-bind, let, let*, destructuring-bind, structure and slot accessors, and a whole lot more.'';
+
+  deps = [ ];
+
+  src = fetchurl {
+    url = ''http://beta.quicklisp.org/archive/metabang-bind/2017-01-24/metabang-bind-20170124-git.tgz'';
+    sha256 = ''1xyiyrc9c02ylg6b749h2ihn6922kb179x7k338dmglf4mpyqxwc'';
+  };
+
+  overrides = x: {
+    postInstall = ''
+        echo "$CL_SOURCE_REGISTRY"
+        NIX_LISP_PRELAUNCH_HOOK='nix_lisp_run_single_form "(asdf:load-system :metabang-bind)"' "$out/bin/metabang-bind-lisp-launcher.sh" ""
+    '';
+  };
+}

pkgs/development/lisp-modules/quicklisp-to-nix-output/myway.nix

···
+args @ { fetchurl, ... }:
+rec {
+  baseName = ''myway'';
+  version = ''20150302-git'';
+
+  description = ''Sinatra-compatible routing library.'';
+
+  deps = [ args."alexandria" args."cl-ppcre" args."cl-utilities" args."map-set" args."quri" ];
+
+  src = fetchurl {
+    url = ''http://beta.quicklisp.org/archive/myway/2015-03-02/myway-20150302-git.tgz'';
+    sha256 = ''1spab9zzhwjg3r5xncr5ncha7phw72wp49cxxncgphh1lfaiyblh'';
+  };
+
+  overrides = x: {
+    postInstall = ''
+        echo "$CL_SOURCE_REGISTRY"
+        NIX_LISP_PRELAUNCH_HOOK='nix_lisp_run_single_form "(asdf:load-system :myway)"' "$out/bin/myway-lisp-launcher.sh" ""
+    '';
+  };
+}

pkgs/development/lisp-modules/quicklisp-to-nix-output/named-readtables.nix

···
+args @ { fetchurl, ... }:
+rec {
+  baseName = ''named-readtables'';
+  version = ''20170124-git'';
+
+  description = ''Library that creates a namespace for named readtable
+  akin to the namespace of packages.'';
+
+  deps = [ ];
+
+  src = fetchurl {
+    url = ''http://beta.quicklisp.org/archive/named-readtables/2017-01-24/named-readtables-20170124-git.tgz'';
+    sha256 = ''1j0drddahdjab40dd9v9qy92xbvzwgbk6y3hv990sdp9f8ac1q45'';
+  };
+
+  overrides = x: {
+    postInstall = ''
+        echo "$CL_SOURCE_REGISTRY"
+        NIX_LISP_PRELAUNCH_HOOK='nix_lisp_run_single_form "(asdf:load-system :named-readtables)"' "$out/bin/named-readtables-lisp-launcher.sh" ""
+    '';
+  };
+}

pkgs/development/lisp-modules/quicklisp-to-nix-output/nibbles.nix

···
+args @ { fetchurl, ... }:
+rec {
+  baseName = ''nibbles'';
+  version = ''20161204-git'';
+
+  description = ''A library for accessing octet-addressed blocks of data in big- and little-endian orders'';
+
+  deps = [ ];
+
+  src = fetchurl {
+    url = ''http://beta.quicklisp.org/archive/nibbles/2016-12-04/nibbles-20161204-git.tgz'';
+    sha256 = ''06cdnivq2966crpj8pidqmwagaif848yvq4fjqq213f3wynwknh4'';
+  };
+
+  overrides = x: {
+    postInstall = ''
+        echo "$CL_SOURCE_REGISTRY"
+        NIX_LISP_PRELAUNCH_HOOK='nix_lisp_run_single_form "(asdf:load-system :nibbles)"' "$out/bin/nibbles-lisp-launcher.sh" ""
+    '';
+  };
+}

pkgs/development/lisp-modules/quicklisp-to-nix-output/optima.nix

···
+args @ { fetchurl, ... }:
+rec {
+  baseName = ''optima'';
+  version = ''20150709-git'';
+
+  description = ''Optimized Pattern Matching Library'';
+
+  deps = [ args."alexandria" args."closer-mop" ];
+
+  src = fetchurl {
+    url = ''http://beta.quicklisp.org/archive/optima/2015-07-09/optima-20150709-git.tgz'';
+    sha256 = ''0vqyqrnx2d8qwa2jlg9l2wn6vrykraj8a1ysz0gxxxnwpqc29hdc'';
+  };
+
+  overrides = x: {
+    postInstall = ''
+        echo "$CL_SOURCE_REGISTRY"
+        NIX_LISP_PRELAUNCH_HOOK='nix_lisp_run_single_form "(asdf:load-system :optima)"' "$out/bin/optima-lisp-launcher.sh" ""
+    '';
+  };
+}

pkgs/development/lisp-modules/quicklisp-to-nix-output/parenscript.nix

···
+args @ { fetchurl, ... }:
+rec {
+  baseName = ''parenscript'';
+  version = ''Parenscript-2.6'';
+
+  description = ''Lisp to JavaScript transpiler'';
+
+  deps = [ args."anaphora" args."cl-ppcre" args."named-readtables" ];
+
+  src = fetchurl {
+    url = ''http://beta.quicklisp.org/archive/parenscript/2016-03-18/Parenscript-2.6.tgz'';
+    sha256 = ''1hvr407fz7gzaxqbnki4k3l44qvl7vk6p5pn7811nrv6lk3kp5li'';
+  };
+
+  overrides = x: {
+    postInstall = ''
+        echo "$CL_SOURCE_REGISTRY"
+        NIX_LISP_PRELAUNCH_HOOK='nix_lisp_run_single_form "(asdf:load-system :parenscript)"' "$out/bin/parenscript-lisp-launcher.sh" ""
+    '';
+  };
+}

pkgs/development/lisp-modules/quicklisp-to-nix-output/plump-dom.nix

···
+args @ { fetchurl, ... }:
+rec {
+  baseName = ''plump-dom'';
+  version = ''plump-20170124-git'';
+
+  description = ''A DOM for use with the Plump parser.'';
+
+  deps = [ args."array-utils" ];
+
+  src = fetchurl {
+    url = ''http://beta.quicklisp.org/archive/plump/2017-01-24/plump-20170124-git.tgz'';
+    sha256 = ''1swl5kr6hgl7hkybixsx7h4ddc7c0a7pisgmmiz2bs2rv4inz69x'';
+  };
+
+  overrides = x: {
+    postInstall = ''
+        echo "$CL_SOURCE_REGISTRY"
+        NIX_LISP_PRELAUNCH_HOOK='nix_lisp_run_single_form "(asdf:load-system :plump-dom)"' "$out/bin/plump-dom-lisp-launcher.sh" ""
+    '';
+  };
+}

pkgs/development/lisp-modules/quicklisp-to-nix-output/plump-lexer.nix

···
+args @ { fetchurl, ... }:
+rec {
+  baseName = ''plump-lexer'';
+  version = ''plump-20170124-git'';
+
+  description = ''A very simple toolkit to help with lexing used mainly in Plump.'';
+
+  deps = [ ];
+
+  src = fetchurl {
+    url = ''http://beta.quicklisp.org/archive/plump/2017-01-24/plump-20170124-git.tgz'';
+    sha256 = ''1swl5kr6hgl7hkybixsx7h4ddc7c0a7pisgmmiz2bs2rv4inz69x'';
+  };
+
+  overrides = x: {
+    postInstall = ''
+        echo "$CL_SOURCE_REGISTRY"
+        NIX_LISP_PRELAUNCH_HOOK='nix_lisp_run_single_form "(asdf:load-system :plump-lexer)"' "$out/bin/plump-lexer-lisp-launcher.sh" ""
+    '';
+  };
+}

pkgs/development/lisp-modules/quicklisp-to-nix-output/plump-parser.nix

···
+args @ { fetchurl, ... }:
+rec {
+  baseName = ''plump-parser'';
+  version = ''plump-20170124-git'';
+
+  description = ''Plump's core parser component.'';
+
+  deps = [ args."plump-dom" args."plump-lexer" args."trivial-indent" ];
+
+  src = fetchurl {
+    url = ''http://beta.quicklisp.org/archive/plump/2017-01-24/plump-20170124-git.tgz'';
+    sha256 = ''1swl5kr6hgl7hkybixsx7h4ddc7c0a7pisgmmiz2bs2rv4inz69x'';
+  };
+
+  overrides = x: {
+    postInstall = ''
+        echo "$CL_SOURCE_REGISTRY"
+        NIX_LISP_PRELAUNCH_HOOK='nix_lisp_run_single_form "(asdf:load-system :plump-parser)"' "$out/bin/plump-parser-lisp-launcher.sh" ""
+    '';
+  };
+}

pkgs/development/lisp-modules/quicklisp-to-nix-output/plump.nix

···
+args @ { fetchurl, ... }:
+rec {
+  baseName = ''plump'';
+  version = ''20170124-git'';
+
+  description = ''An XML / XHTML / HTML parser that aims to be as lenient as possible.'';
+
+  deps = [ args."plump-dom" args."plump-lexer" args."plump-parser" ];
+
+  src = fetchurl {
+    url = ''http://beta.quicklisp.org/archive/plump/2017-01-24/plump-20170124-git.tgz'';
+    sha256 = ''1swl5kr6hgl7hkybixsx7h4ddc7c0a7pisgmmiz2bs2rv4inz69x'';
+  };
+
+  overrides = x: {
+    postInstall = ''
+        echo "$CL_SOURCE_REGISTRY"
+        NIX_LISP_PRELAUNCH_HOOK='nix_lisp_run_single_form "(asdf:load-system :plump)"' "$out/bin/plump-lisp-launcher.sh" ""
+    '';
+  };
+}

pkgs/development/lisp-modules/quicklisp-to-nix-output/proc-parse.nix

···
+args @ { fetchurl, ... }:
+rec {
+  baseName = ''proc-parse'';
+  version = ''20160318-git'';
+
+  description = ''Procedural vector parser'';
+
+  deps = [ args."alexandria" args."babel" ];
+
+  src = fetchurl {
+    url = ''http://beta.quicklisp.org/archive/proc-parse/2016-03-18/proc-parse-20160318-git.tgz'';
+    sha256 = ''00261w269w9chg6r3sh8hg8994njbsai1g3zni0whm2dzxxq6rnl'';
+  };
+
+  overrides = x: {
+    postInstall = ''
+        echo "$CL_SOURCE_REGISTRY"
+        NIX_LISP_PRELAUNCH_HOOK='nix_lisp_run_single_form "(asdf:load-system :proc-parse)"' "$out/bin/proc-parse-lisp-launcher.sh" ""
+    '';
+  };
+}

pkgs/development/lisp-modules/quicklisp-to-nix-output/prove.nix

···
+args @ { fetchurl, ... }:
+rec {
+  baseName = ''prove'';
+  version = ''20170124-git'';
+
+  description = '''';
+
+  deps = [ args."alexandria" args."cl-ansi-text" args."cl-colors" args."cl-ppcre" args."uiop" ];
+
+  src = fetchurl {
+    url = ''http://beta.quicklisp.org/archive/prove/2017-01-24/prove-20170124-git.tgz'';
+    sha256 = ''1kyhh4yvf47psb5v0zqivcwn71n6my5fwggdifymlpigk2q3zn03'';
+  };
+
+  overrides = x: {
+    postInstall = ''
+        echo "$CL_SOURCE_REGISTRY"
+        NIX_LISP_PRELAUNCH_HOOK='nix_lisp_run_single_form "(asdf:load-system :prove)"' "$out/bin/prove-lisp-launcher.sh" ""
+    '';
+  };
+}

pkgs/development/lisp-modules/quicklisp-to-nix-output/puri.nix

···
     url = ''http://beta.quicklisp.org/archive/puri/2015-09-23/puri-20150923-git.tgz'';
     sha256 = ''099ay2zji5ablj2jj56sb49hk2l9x5s11vpx6893qwwjsp2881qa'';
   };
+
+  overrides = x: {
+    postInstall = ''
+        echo "$CL_SOURCE_REGISTRY"
+        NIX_LISP_PRELAUNCH_HOOK='nix_lisp_run_single_form "(asdf:load-system :puri)"' "$out/bin/puri-lisp-launcher.sh" ""
+    '';
+  };
 }

pkgs/development/lisp-modules/quicklisp-to-nix-output/quri.nix

···
+args @ { fetchurl, ... }:
+rec {
+  baseName = ''quri'';
+  version = ''20161204-git'';
+
+  description = ''Yet another URI library for Common Lisp'';
+
+  deps = [ args."alexandria" args."babel" args."cl-utilities" args."split-sequence" ];
+
+  src = fetchurl {
+    url = ''http://beta.quicklisp.org/archive/quri/2016-12-04/quri-20161204-git.tgz'';
+    sha256 = ''14if83kd2mv68p4g4ch2w796w3micpzv40z7xrcwzwj64wngwabv'';
+  };
+
+  overrides = x: {
+    postInstall = ''
+        echo "$CL_SOURCE_REGISTRY"
+        NIX_LISP_PRELAUNCH_HOOK='nix_lisp_run_single_form "(asdf:load-system :quri)"' "$out/bin/quri-lisp-launcher.sh" ""
+    '';
+  };
+}

pkgs/development/lisp-modules/quicklisp-to-nix-output/rfc2388.nix

···
     url = ''http://beta.quicklisp.org/archive/rfc2388/2013-07-20/rfc2388-20130720-git.tgz'';
     sha256 = ''1ky99cr4bgfyh0pfpl5f6fsmq1qdbgi4b8v0cfs4y73f78p1f8b6'';
   };
+
+  overrides = x: {
+    postInstall = ''
+        echo "$CL_SOURCE_REGISTRY"
+        NIX_LISP_PRELAUNCH_HOOK='nix_lisp_run_single_form "(asdf:load-system :rfc2388)"' "$out/bin/rfc2388-lisp-launcher.sh" ""
+    '';
+  };
 }

pkgs/development/lisp-modules/quicklisp-to-nix-output/salza2.nix

···
+args @ { fetchurl, ... }:
+rec {
+  baseName = ''salza2'';
+  version = ''2.0.9'';
+
+  description = ''Create compressed data in the ZLIB, DEFLATE, or GZIP
+  data formats'';
+
+  deps = [ ];
+
+  src = fetchurl {
+    url = ''http://beta.quicklisp.org/archive/salza2/2013-07-20/salza2-2.0.9.tgz'';
+    sha256 = ''1m0hksgvq3njd9xa2nxlm161vgzw77djxmisq08v9pz2bz16v8va'';
+  };
+
+  overrides = x: {
+    postInstall = ''
+        echo "$CL_SOURCE_REGISTRY"
+        NIX_LISP_PRELAUNCH_HOOK='nix_lisp_run_single_form "(asdf:load-system :salza2)"' "$out/bin/salza2-lisp-launcher.sh" ""
+    '';
+  };
+}

pkgs/development/lisp-modules/quicklisp-to-nix-output/smart-buffer.nix

···
+args @ { fetchurl, ... }:
+rec {
+  baseName = ''smart-buffer'';
+  version = ''20160628-git'';
+
+  description = ''Smart octets buffer'';
+
+  deps = [ args."flexi-streams" args."uiop" args."xsubseq" ];
+
+  src = fetchurl {
+    url = ''http://beta.quicklisp.org/archive/smart-buffer/2016-06-28/smart-buffer-20160628-git.tgz'';
+    sha256 = ''1wp50snkc8739n91xlnfnq1dzz3kfp0awgp92m7xbpcw3hbaib1s'';
+  };
+
+  overrides = x: {
+    postInstall = ''
+        echo "$CL_SOURCE_REGISTRY"
+        NIX_LISP_PRELAUNCH_HOOK='nix_lisp_run_single_form "(asdf:load-system :smart-buffer)"' "$out/bin/smart-buffer-lisp-launcher.sh" ""
+    '';
+  };
+}

pkgs/development/lisp-modules/quicklisp-to-nix-output/split-sequence.nix

···
     url = ''http://beta.quicklisp.org/archive/split-sequence/2015-08-04/split-sequence-1.2.tgz'';
     sha256 = ''12x5yfvinqz9jzxwlsg226103a9sdf67zpzn5izggvdlw0v5qp0l'';
   };
+
+  overrides = x: {
+    postInstall = ''
+        echo "$CL_SOURCE_REGISTRY"
+        NIX_LISP_PRELAUNCH_HOOK='nix_lisp_run_single_form "(asdf:load-system :split-sequence)"' "$out/bin/split-sequence-lisp-launcher.sh" ""
+    '';
+  };
 }

pkgs/development/lisp-modules/quicklisp-to-nix-output/static-vectors.nix

···
+args @ { fetchurl, ... }:
+rec {
+  baseName = ''static-vectors'';
+  version = ''v1.8.2'';
+
+  description = ''Create vectors allocated in static memory.'';
+
+  deps = [ args."alexandria" args."cffi" args."cffi-grovel" ];
+
+  src = fetchurl {
+    url = ''http://beta.quicklisp.org/archive/static-vectors/2017-01-24/static-vectors-v1.8.2.tgz'';
+    sha256 = ''0p35f0wrnv46bmmxlviwpsbxnlnkmxwd3xp858lhf0dy52cyra1g'';
+  };
+
+  overrides = x: {
+    postInstall = ''
+        echo "$CL_SOURCE_REGISTRY"
+        NIX_LISP_PRELAUNCH_HOOK='nix_lisp_run_single_form "(asdf:load-system :static-vectors)"' "$out/bin/static-vectors-lisp-launcher.sh" ""
+    '';
+  };
+}

pkgs/development/lisp-modules/quicklisp-to-nix-output/stumpwm.nix

···
 
   description = ''A tiling, keyboard driven window manager'';
 
-  deps = [ args."alexandria" args."cl-ppcre" args."clx" ];
+  deps = [ ];
 
   src = fetchurl {
     url = ''http://beta.quicklisp.org/archive/stumpwm/2017-02-27/stumpwm-20170227-git.tgz'';
     sha256 = ''0w1arw1x5hsw0w6rc1ls4bf7gf8cjcm6ar68kp74zczp0y35fign'';
+  };
+
+  overrides = x: {
+    postInstall = ''
+        echo "$CL_SOURCE_REGISTRY"
+        NIX_LISP_PRELAUNCH_HOOK='nix_lisp_run_single_form "(asdf:load-system :stumpwm)"' "$out/bin/stumpwm-lisp-launcher.sh" ""
+    '';
   };
 }

pkgs/development/lisp-modules/quicklisp-to-nix-output/swap-bytes.nix

···
     url = ''http://beta.quicklisp.org/archive/swap-bytes/2016-09-29/swap-bytes-v1.1.tgz'';
     sha256 = ''0snwbfplqhg1y4y4m7lgvksg1hs0sygfikz3rlbkfl4gwg8pq8ky'';
   };
+
+  overrides = x: {
+    postInstall = ''
+        echo "$CL_SOURCE_REGISTRY"
+        NIX_LISP_PRELAUNCH_HOOK='nix_lisp_run_single_form "(asdf:load-system :swap-bytes)"' "$out/bin/swap-bytes-lisp-launcher.sh" ""
+    '';
+  };
 }

pkgs/development/lisp-modules/quicklisp-to-nix-output/trivial-backtrace.nix

···
     url = ''http://beta.quicklisp.org/archive/trivial-backtrace/2016-05-31/trivial-backtrace-20160531-git.tgz'';
     sha256 = ''1vcvalcv2ljiv2gyh8xjcg62cjsripjwmnhc8zji35ja1xyqvxhx'';
   };
+
+  overrides = x: {
+    postInstall = ''
+        echo "$CL_SOURCE_REGISTRY"
+        NIX_LISP_PRELAUNCH_HOOK='nix_lisp_run_single_form "(asdf:load-system :trivial-backtrace)"' "$out/bin/trivial-backtrace-lisp-launcher.sh" ""
+    '';
+  };
 }

pkgs/development/lisp-modules/quicklisp-to-nix-output/trivial-features.nix

···
     url = ''http://beta.quicklisp.org/archive/trivial-features/2016-12-04/trivial-features-20161204-git.tgz'';
     sha256 = ''0i2zyc9c7jigljxll29sh9gv1fawdsf0kq7s86pwba5zi99q2ij2'';
   };
+
+  overrides = x: {
+    postInstall = ''
+        echo "$CL_SOURCE_REGISTRY"
+        NIX_LISP_PRELAUNCH_HOOK='nix_lisp_run_single_form "(asdf:load-system :trivial-features)"' "$out/bin/trivial-features-lisp-launcher.sh" ""
+    '';
+  };
 }

pkgs/development/lisp-modules/quicklisp-to-nix-output/trivial-garbage.nix

···
     url = ''http://beta.quicklisp.org/archive/trivial-garbage/2015-01-13/trivial-garbage-20150113-git.tgz'';
     sha256 = ''1yy1jyx7wz5rr7lr0jyyfxgzfddmrxrmkp46a21pcdc4jlss1h08'';
   };
+
+  overrides = x: {
+    postInstall = ''
+        echo "$CL_SOURCE_REGISTRY"
+        NIX_LISP_PRELAUNCH_HOOK='nix_lisp_run_single_form "(asdf:load-system :trivial-garbage)"' "$out/bin/trivial-garbage-lisp-launcher.sh" ""
+    '';
+  };
 }

pkgs/development/lisp-modules/quicklisp-to-nix-output/trivial-gray-streams.nix

···
     url = ''http://beta.quicklisp.org/archive/trivial-gray-streams/2014-08-26/trivial-gray-streams-20140826-git.tgz'';
     sha256 = ''1nhbp0qizvqvy2mfl3i99hlwiy27h3gq0jglwzsj2fmnwqvpfx92'';
   };
+
+  overrides = x: {
+    postInstall = ''
+        echo "$CL_SOURCE_REGISTRY"
+        NIX_LISP_PRELAUNCH_HOOK='nix_lisp_run_single_form "(asdf:load-system :trivial-gray-streams)"' "$out/bin/trivial-gray-streams-lisp-launcher.sh" ""
+    '';
+  };
 }

pkgs/development/lisp-modules/quicklisp-to-nix-output/trivial-indent.nix

···
+args @ { fetchurl, ... }:
+rec {
+  baseName = ''trivial-indent'';
+  version = ''20160929-git'';
+
+  description = ''A very simple library to allow indentation hints for SWANK.'';
+
+  deps = [ ];
+
+  src = fetchurl {
+    url = ''http://beta.quicklisp.org/archive/trivial-indent/2016-09-29/trivial-indent-20160929-git.tgz'';
+    sha256 = ''0nc7d5xdx4h8jvvqif7f721z8296kl6jk5hqmgr0mj3g7svgfrir'';
+  };
+
+  overrides = x: {
+    postInstall = ''
+        echo "$CL_SOURCE_REGISTRY"
+        NIX_LISP_PRELAUNCH_HOOK='nix_lisp_run_single_form "(asdf:load-system :trivial-indent)"' "$out/bin/trivial-indent-lisp-launcher.sh" ""
+    '';
+  };
+}

pkgs/development/lisp-modules/quicklisp-to-nix-output/trivial-mimes.nix

···
+args @ { fetchurl, ... }:
+rec {
+  baseName = ''trivial-mimes'';
+  version = ''20160929-git'';
+
+  description = ''Tiny library to detect mime types in files.'';
+
+  deps = [ ];
+
+  src = fetchurl {
+    url = ''http://beta.quicklisp.org/archive/trivial-mimes/2016-09-29/trivial-mimes-20160929-git.tgz'';
+    sha256 = ''1sdsplngi3civv9wjd9rxxj3ynqc3260cfykpid5lpy8rhbyiw0w'';
+  };
+
+  overrides = x: {
+    postInstall = ''
+        echo "$CL_SOURCE_REGISTRY"
+        NIX_LISP_PRELAUNCH_HOOK='nix_lisp_run_single_form "(asdf:load-system :trivial-mimes)"' "$out/bin/trivial-mimes-lisp-launcher.sh" ""
+    '';
+  };
+}

pkgs/development/lisp-modules/quicklisp-to-nix-output/trivial-types.nix

···
+args @ { fetchurl, ... }:
+rec {
+  baseName = ''trivial-types'';
+  version = ''20120407-git'';
+
+  description = ''Trivial type definitions'';
+
+  deps = [ ];
+
+  src = fetchurl {
+    url = ''http://beta.quicklisp.org/archive/trivial-types/2012-04-07/trivial-types-20120407-git.tgz'';
+    sha256 = ''0y3lfbbvi2qp2cwswzmk1awzqrsrrcfkcm1qn744bgm1fiqhxbxx'';
+  };
+
+  overrides = x: {
+    postInstall = ''
+        echo "$CL_SOURCE_REGISTRY"
+        NIX_LISP_PRELAUNCH_HOOK='nix_lisp_run_single_form "(asdf:load-system :trivial-types)"' "$out/bin/trivial-types-lisp-launcher.sh" ""
+    '';
+  };
+}

pkgs/development/lisp-modules/quicklisp-to-nix-output/trivial-utf-8.nix

···
     url = ''http://beta.quicklisp.org/archive/trivial-utf-8/2011-10-01/trivial-utf-8-20111001-darcs.tgz'';
     sha256 = ''1lmg185s6w3rzsz3xa41k5w9xw32bi288ifhrxincy8iv92w65wb'';
   };
+
+  overrides = x: {
+    postInstall = ''
+        echo "$CL_SOURCE_REGISTRY"
+        NIX_LISP_PRELAUNCH_HOOK='nix_lisp_run_single_form "(asdf:load-system :trivial-utf-8)"' "$out/bin/trivial-utf-8-lisp-launcher.sh" ""
+    '';
+  };
 }

pkgs/development/lisp-modules/quicklisp-to-nix-output/uiop.nix

···
     url = ''http://beta.quicklisp.org/archive/uiop/2017-01-24/uiop-3.2.0.tgz'';
     sha256 = ''1rrn1mdcb4dmb517vrp3nzwpp1w8hfvpzarj36c7kkpjq23czdig'';
   };
+
+  overrides = x: {
+    postInstall = ''
+        echo "$CL_SOURCE_REGISTRY"
+        NIX_LISP_PRELAUNCH_HOOK='nix_lisp_run_single_form "(asdf:load-system :uiop)"' "$out/bin/uiop-lisp-launcher.sh" ""
+    '';
+  };
 }

pkgs/development/lisp-modules/quicklisp-to-nix-output/usocket.nix

···
     url = ''http://beta.quicklisp.org/archive/usocket/2016-10-31/usocket-0.7.0.1.tgz'';
     sha256 = ''1mpcfawbzd72cd841bb0hmgx4kinnvcnazc7vym83gv5iy6lwif2'';
   };
+
+  overrides = x: {
+    postInstall = ''
+        echo "$CL_SOURCE_REGISTRY"
+        NIX_LISP_PRELAUNCH_HOOK='nix_lisp_run_single_form "(asdf:load-system :usocket)"' "$out/bin/usocket-lisp-launcher.sh" ""
+    '';
+  };
 }

pkgs/development/lisp-modules/quicklisp-to-nix-output/vom.nix

···
+args @ { fetchurl, ... }:
+rec {
+  baseName = ''vom'';
+  version = ''20160825-git'';
+
+  description = ''A tiny logging utility.'';
+
+  deps = [ ];
+
+  src = fetchurl {
+    url = ''http://beta.quicklisp.org/archive/vom/2016-08-25/vom-20160825-git.tgz'';
+    sha256 = ''0mvln0xx8qnrsmaj7c0f2ilgahvf078qvhqag7qs3j26xmamjm93'';
+  };
+
+  overrides = x: {
+    postInstall = ''
+        echo "$CL_SOURCE_REGISTRY"
+        NIX_LISP_PRELAUNCH_HOOK='nix_lisp_run_single_form "(asdf:load-system :vom)"' "$out/bin/vom-lisp-launcher.sh" ""
+    '';
+  };
+}

pkgs/development/lisp-modules/quicklisp-to-nix-output/woo.nix

···
+args @ { fetchurl, ... }:
+rec {
+  baseName = ''woo'';
+  version = ''20170227-git'';
+
+  description = ''An asynchronous HTTP server written in Common Lisp'';
+
+  deps = [ ];
+
+  src = fetchurl {
+    url = ''http://beta.quicklisp.org/archive/woo/2017-02-27/woo-20170227-git.tgz'';
+    sha256 = ''0myydz817mpkgs97p9y9n4z0kq00xxr2b65klsdkxasvvfyjw0d1'';
+  };
+
+  overrides = x: {
+    postInstall = ''
+        echo "$CL_SOURCE_REGISTRY"
+        NIX_LISP_PRELAUNCH_HOOK='nix_lisp_run_single_form "(asdf:load-system :woo)"' "$out/bin/woo-lisp-launcher.sh" ""
+    '';
+  };
+}

pkgs/development/lisp-modules/quicklisp-to-nix-output/wookie.nix

···
+args @ { fetchurl, ... }:
+rec {
+  baseName = ''wookie'';
+  version = ''20170227-git'';
+
+  description = ''An evented webserver for Common Lisp.'';
+
+  deps = [ ];
+
+  src = fetchurl {
+    url = ''http://beta.quicklisp.org/archive/wookie/2017-02-27/wookie-20170227-git.tgz'';
+    sha256 = ''0i1wrgr5grg387ldv1zfswws1g3xvrkxxvp1m58m9hj0c1vmm6v0'';
+  };
+
+  overrides = x: {
+    postInstall = ''
+        echo "$CL_SOURCE_REGISTRY"
+        NIX_LISP_PRELAUNCH_HOOK='nix_lisp_run_single_form "(asdf:load-system :wookie)"' "$out/bin/wookie-lisp-launcher.sh" ""
+    '';
+  };
+}

pkgs/development/lisp-modules/quicklisp-to-nix-output/xmls.nix

···
+args @ { fetchurl, ... }:
+rec {
+  baseName = ''xmls'';
+  version = ''1.7'';
+
+  description = '''';
+
+  deps = [ ];
+
+  src = fetchurl {
+    url = ''http://beta.quicklisp.org/archive/xmls/2015-04-07/xmls-1.7.tgz'';
+    sha256 = ''1pch221g5jv02rb21ly9ik4cmbzv8ca6bnyrs4s0yfrrq0ji406b'';
+  };
+
+  overrides = x: {
+    postInstall = ''
+        echo "$CL_SOURCE_REGISTRY"
+        NIX_LISP_PRELAUNCH_HOOK='nix_lisp_run_single_form "(asdf:load-system :xmls)"' "$out/bin/xmls-lisp-launcher.sh" ""
+    '';
+  };
+}

pkgs/development/lisp-modules/quicklisp-to-nix-output/xsubseq.nix

···
+args @ { fetchurl, ... }:
+rec {
+  baseName = ''xsubseq'';
+  version = ''20150113-git'';
+
+  description = ''Efficient way to manage "subseq"s in Common Lisp'';
+
+  deps = [ ];
+
+  src = fetchurl {
+    url = ''http://beta.quicklisp.org/archive/xsubseq/2015-01-13/xsubseq-20150113-git.tgz'';
+    sha256 = ''0ykjhi7pkqcwm00yzhqvngnx07hsvwbj0c72b08rj4dkngg8is5q'';
+  };
+
+  overrides = x: {
+    postInstall = ''
+        echo "$CL_SOURCE_REGISTRY"
+        NIX_LISP_PRELAUNCH_HOOK='nix_lisp_run_single_form "(asdf:load-system :xsubseq)"' "$out/bin/xsubseq-lisp-launcher.sh" ""
+    '';
+  };
+}

pkgs/development/lisp-modules/quicklisp-to-nix-output/yason.nix

···
+args @ { fetchurl, ... }:
+rec {
+  baseName = ''yason'';
+  version = ''v0.7.6'';
+
+  description = ''JSON parser/encoder'';
+
+  deps = [ args."alexandria" args."trivial-gray-streams" ];
+
+  src = fetchurl {
+    url = ''http://beta.quicklisp.org/archive/yason/2016-02-08/yason-v0.7.6.tgz'';
+    sha256 = ''00gfn14bvnw0in03y5m2ssgvhy3ppf5a3s0rf7mf4rq00c5ifchk'';
+  };
+
+  overrides = x: {
+    postInstall = ''
+        echo "$CL_SOURCE_REGISTRY"
+        NIX_LISP_PRELAUNCH_HOOK='nix_lisp_run_single_form "(asdf:load-system :yason)"' "$out/bin/yason-lisp-launcher.sh" ""
+    '';
+  };
+}

pkgs/development/lisp-modules/quicklisp-to-nix-overrides.lisp

···
+(defparameter testnames (make-hash-table :test 'equal))
+(setf
+  (gethash "cxml-xml" testnames) "cxml"
+  (gethash "cxml-dom" testnames) "cxml"
+  (gethash "cxml-test" testnames) "cxml"
+  (gethash "cxml-klacks" testnames) "cxml"
+  (gethash "cl-async-base" testnames) "cl-async"
+  (gethash "cl-async-util" testnames) "cl-async"
+  )

pkgs/development/lisp-modules/quicklisp-to-nix-overrides.nix

···
 {pkgs, buildLispPackage, quicklisp-to-nix-packages}:
-{
-  iterate = x: {
-    overrides = x: {
-      configurePhase="buildPhase(){ true; }";
-    };
+let
+  addDeps = newdeps: x: {deps = x.deps ++ newdeps;};
+  addNativeLibs = libs: x: { propagatedBuildInputs = libs; };
+  skipBuildPhase = x: { 
+    overrides = y: ((x.overrides y) // { buildPhase = "true"; });
   };
+  qlnp = quicklisp-to-nix-packages;
+  multiOverride = l: x: if l == [] then {} else
+    ((builtins.head l) x) // (multiOverride (builtins.tail l) x);
+in
+{
+  stumpwm = addDeps (with qlnp; [alexandria cl-ppcre clx]);
+  iterate = skipBuildPhase;
   cl-fuse = x: {
     propagatedBuildInputs = [pkgs.fuse];
-    overrides = x : {
+    overrides = y : (x.overrides y) // {
       configurePhase = ''
         export CL_SOURCE_REGISTRY="$CL_SOURCE_REGISTRY:$PWD"
         export makeFlags="$makeFlags LISP=common-lisp.sh"
       '';
     };
   };
-  hunchentoot = x: {
-    propagatedBuildInputs = [pkgs.openssl];
-  };
-  iolib = x: {
-    propagatedBuildInputs = [pkgs.libfixposix pkgs.gcc];
-    overrides = y: {
-      postBuild = ''
-        NIX_LISP_PRELAUNCH_HOOK='nix_lisp_run_single_form "(asdf:load-system :iolib)"' common-lisp.sh ""
-      '';
-    };
-  };
+  hunchentoot = addNativeLibs [pkgs.openssl];
+  iolib = addNativeLibs [pkgs.libfixposix pkgs.gcc];
+  cl-unicode = addDeps (with qlnp; [cl-ppcre flexi-streams]);
+  clack =  addDeps (with qlnp;[lack bordeaux-threads prove]);
+  clack-v1-compat =  addDeps (with qlnp;[
+    lack bordeaux-threads prove usocket dexador http-body trivial-backtrace
+    marshal local-time cl-base64 cl-ppcre quri trivial-mimes trivial-types
+    flexi-streams circular-streams ironclad cl-syntax-annot alexandria
+    split-sequence
+  ]);
+  cxml = skipBuildPhase;
+  cxml-xml = skipBuildPhase;
+  cxml-dom = skipBuildPhase;
+  cxml-klacks = skipBuildPhase;
+  cxml-test = skipBuildPhase;
+  wookie = multiOverride [(addDeps (with qlnp; [
+      alexandria blackbird cl-async chunga fast-http quri babel cl-ppcre
+      cl-fad fast-io vom do-urlencode
+    ])) 
+    (addNativeLibs (with pkgs; [libuv openssl]))];
+  woo = addDeps (with qlnp; [
+    cffi lev clack swap-bytes static-vectors fast-http proc-parse quri fast-io
+    trivial-utf-8 vom
+  ]);
+  lev = addNativeLibs [pkgs.libev];
+  dexador = addDeps (with qlnp; [
+    usocket fast-http quri fast-io chunga cl-ppcre cl-cookie trivial-mimes
+    chipz cl-base64 cl-reexport qlnp."cl+ssl" alexandria bordeaux-threads
+  ]);
+  fast-http = addDeps (with qlnp; [
+    alexandria cl-utilities proc-parse xsubseq smart-buffer
+  ]);
+  cl-emb = addDeps (with qlnp; [cl-ppcre]);
+  "cl+ssl" = addNativeLibs [pkgs.openssl];
+  cl-colors = skipBuildPhase;
+  cl-libuv = addNativeLibs [pkgs.libuv];
+  cl-async-base = addDeps (with qlnp; [
+    cffi fast-io vom cl-libuv cl-ppcre trivial-features static-vectors
+    trivial-gray-streams babel
+  ]);
+  css-lite = addDeps (with qlnp; [parenscript]);
 }

pkgs/development/lisp-modules/quicklisp-to-nix-systems.txt

···
-stumpwm
+alexandria
+babel
+blackbird
+bordeaux-threads
+caveman
+cffi
+chipz
+circular-streams
+clack
+cl-async
+cl-base64
+cl-cookie
 cl-fuse
+cl-json
+cl-l10n
+closer-mop
+cl-ppcre
+cl-reexport
+cl-syntax-annot
+cl-unicode
+cl-utilities
+cl-who
+clx
+parenscript
+css-lite
+cxml
+dexador
+drakma
 esrap
+external-program
+fast-http
+fast-io
+flexi-streams
+http-body
 hunchentoot
-external-program
-drakma
 iolib
+ironclad
+iterate
+lack
+lev
+local-time
+lquery
+marshal
+optima
+parenscript
+plump
+proc-parse
+prove
+quri
+salza2
+smart-buffer
+split-sequence
+static-vectors
+stumpwm
+trivial-backtrace
+trivial-mimes
+trivial-types
+trivial-utf-8
+usocket
+woo
+wookie
+xmls
+xsubseq
+yason

pkgs/development/lisp-modules/quicklisp-to-nix.nix

···
   buildLispPackage = callPackage ./define-package.nix;
   qlOverrides = callPackage ./quicklisp-to-nix-overrides.nix {};
 
-  "iolib/conf" = buildLispPackage
+  "closure-common" = buildLispPackage
     ((f: x: (x // (f x)))
-       (qlOverrides."iolib/conf" or (x: {}))
-       (import ./quicklisp-to-nix-output/iolib_slash_conf.nix {
+       (qlOverrides."closure-common" or (x: {}))
+       (import ./quicklisp-to-nix-output/closure-common.nix {
          inherit fetchurl;
+           "babel" = quicklisp-to-nix-packages."babel";
+           "trivial-gray-streams" = quicklisp-to-nix-packages."trivial-gray-streams";
        }));
-  "iolib_slash_conf" = quicklisp-to-nix-packages."iolib/conf";
 
 
-  "iolib/asdf" = buildLispPackage
+  "let-plus" = buildLispPackage
     ((f: x: (x // (f x)))
-       (qlOverrides."iolib/asdf" or (x: {}))
-       (import ./quicklisp-to-nix-output/iolib_slash_asdf.nix {
+       (qlOverrides."let-plus" or (x: {}))
+       (import ./quicklisp-to-nix-output/let-plus.nix {
          inherit fetchurl;
            "alexandria" = quicklisp-to-nix-packages."alexandria";
+           "anaphora" = quicklisp-to-nix-packages."anaphora";
        }));
-  "iolib_slash_asdf" = quicklisp-to-nix-packages."iolib/asdf";
 
 
-  "swap-bytes" = buildLispPackage
+  "trivial-indent" = buildLispPackage
     ((f: x: (x // (f x)))
-       (qlOverrides."swap-bytes" or (x: {}))
-       (import ./quicklisp-to-nix-output/swap-bytes.nix {
+       (qlOverrides."trivial-indent" or (x: {}))
+       (import ./quicklisp-to-nix-output/trivial-indent.nix {
          inherit fetchurl;
-           "trivial-features" = quicklisp-to-nix-packages."trivial-features";
        }));
 
 
-  "idna" = buildLispPackage
+  "documentation-utils" = buildLispPackage
     ((f: x: (x // (f x)))
-       (qlOverrides."idna" or (x: {}))
-       (import ./quicklisp-to-nix-output/idna.nix {
+       (qlOverrides."documentation-utils" or (x: {}))
+       (import ./quicklisp-to-nix-output/documentation-utils.nix {
          inherit fetchurl;
-           "split-sequence" = quicklisp-to-nix-packages."split-sequence";
+           "trivial-indent" = quicklisp-to-nix-packages."trivial-indent";
        }));
 
 
-  "iolib/grovel" = buildLispPackage
+  "trivial-garbage" = buildLispPackage
     ((f: x: (x // (f x)))
-       (qlOverrides."iolib/grovel" or (x: {}))
-       (import ./quicklisp-to-nix-output/iolib_slash_grovel.nix {
+       (qlOverrides."trivial-garbage" or (x: {}))
+       (import ./quicklisp-to-nix-output/trivial-garbage.nix {
          inherit fetchurl;
-           "iolib/asdf" = quicklisp-to-nix-packages."iolib/asdf";
-           "iolib/base" = quicklisp-to-nix-packages."iolib/base";
-           "iolib/conf" = quicklisp-to-nix-packages."iolib/conf";
-           "alexandria" = quicklisp-to-nix-packages."alexandria";
-           "split-sequence" = quicklisp-to-nix-packages."split-sequence";
+       }));
+
+
+  "cxml-xml" = buildLispPackage
+    ((f: x: (x // (f x)))
+       (qlOverrides."cxml-xml" or (x: {}))
+       (import ./quicklisp-to-nix-output/cxml-xml.nix {
+         inherit fetchurl;
+           "closure-common" = quicklisp-to-nix-packages."closure-common";
+           "puri" = quicklisp-to-nix-packages."puri";
+           "trivial-gray-streams" = quicklisp-to-nix-packages."trivial-gray-streams";
+       }));
+
+
+  "cffi-toolchain" = buildLispPackage
+    ((f: x: (x // (f x)))
+       (qlOverrides."cffi-toolchain" or (x: {}))
+       (import ./quicklisp-to-nix-output/cffi-toolchain.nix {
+         inherit fetchurl;
            "cffi" = quicklisp-to-nix-packages."cffi";
-           "uiop" = quicklisp-to-nix-packages."uiop";
        }));
-  "iolib_slash_grovel" = quicklisp-to-nix-packages."iolib/grovel";
 
 
-  "iolib/syscalls" = buildLispPackage
+  "map-set" = buildLispPackage
     ((f: x: (x // (f x)))
-       (qlOverrides."iolib/syscalls" or (x: {}))
-       (import ./quicklisp-to-nix-output/iolib_slash_syscalls.nix {
+       (qlOverrides."map-set" or (x: {}))
+       (import ./quicklisp-to-nix-output/map-set.nix {
          inherit fetchurl;
-           "trivial-features" = quicklisp-to-nix-packages."trivial-features";
-           "cffi" = quicklisp-to-nix-packages."cffi";
-           "iolib/base" = quicklisp-to-nix-packages."iolib/base";
-           "iolib/grovel" = quicklisp-to-nix-packages."iolib/grovel";
        }));
-  "iolib_slash_syscalls" = quicklisp-to-nix-packages."iolib/syscalls";
 
 
-  "iolib/common-lisp" = buildLispPackage
+  "babel-streams" = buildLispPackage
     ((f: x: (x // (f x)))
-       (qlOverrides."iolib/common-lisp" or (x: {}))
-       (import ./quicklisp-to-nix-output/iolib_slash_common-lisp.nix {
+       (qlOverrides."babel-streams" or (x: {}))
+       (import ./quicklisp-to-nix-output/babel-streams.nix {
          inherit fetchurl;
            "alexandria" = quicklisp-to-nix-packages."alexandria";
+           "babel" = quicklisp-to-nix-packages."babel";
+           "trivial-gray-streams" = quicklisp-to-nix-packages."trivial-gray-streams";
        }));
-  "iolib_slash_common-lisp" = quicklisp-to-nix-packages."iolib/common-lisp";
 
 
-  "split-sequence" = buildLispPackage
+  "cl-colors" = buildLispPackage
     ((f: x: (x // (f x)))
-       (qlOverrides."split-sequence" or (x: {}))
-       (import ./quicklisp-to-nix-output/split-sequence.nix {
+       (qlOverrides."cl-colors" or (x: {}))
+       (import ./quicklisp-to-nix-output/cl-colors.nix {
          inherit fetchurl;
+           "alexandria" = quicklisp-to-nix-packages."alexandria";
+           "let-plus" = quicklisp-to-nix-packages."let-plus";
        }));
 
 
-  "trivial-garbage" = buildLispPackage
+  "cl-ansi-text" = buildLispPackage
     ((f: x: (x // (f x)))
-       (qlOverrides."trivial-garbage" or (x: {}))
-       (import ./quicklisp-to-nix-output/trivial-garbage.nix {
+       (qlOverrides."cl-ansi-text" or (x: {}))
+       (import ./quicklisp-to-nix-output/cl-ansi-text.nix {
          inherit fetchurl;
+           "alexandria" = quicklisp-to-nix-packages."alexandria";
+           "cl-colors" = quicklisp-to-nix-packages."cl-colors";
        }));
 
 
-  "trivial-gray-streams" = buildLispPackage
+  "plump-parser" = buildLispPackage
     ((f: x: (x // (f x)))
-       (qlOverrides."trivial-gray-streams" or (x: {}))
-       (import ./quicklisp-to-nix-output/trivial-gray-streams.nix {
+       (qlOverrides."plump-parser" or (x: {}))
+       (import ./quicklisp-to-nix-output/plump-parser.nix {
          inherit fetchurl;
+           "plump-dom" = quicklisp-to-nix-packages."plump-dom";
+           "plump-lexer" = quicklisp-to-nix-packages."plump-lexer";
+           "trivial-indent" = quicklisp-to-nix-packages."trivial-indent";
        }));
 
 
-  "babel" = buildLispPackage
+  "plump-lexer" = buildLispPackage
     ((f: x: (x // (f x)))
-       (qlOverrides."babel" or (x: {}))
-       (import ./quicklisp-to-nix-output/babel.nix {
+       (qlOverrides."plump-lexer" or (x: {}))
+       (import ./quicklisp-to-nix-output/plump-lexer.nix {
          inherit fetchurl;
-           "trivial-features" = quicklisp-to-nix-packages."trivial-features";
-           "alexandria" = quicklisp-to-nix-packages."alexandria";
        }));
 
 
-  "uiop" = buildLispPackage
+  "plump-dom" = buildLispPackage
     ((f: x: (x // (f x)))
-       (qlOverrides."uiop" or (x: {}))
-       (import ./quicklisp-to-nix-output/uiop.nix {
+       (qlOverrides."plump-dom" or (x: {}))
+       (import ./quicklisp-to-nix-output/plump-dom.nix {
          inherit fetchurl;
+           "array-utils" = quicklisp-to-nix-packages."array-utils";
        }));
 
 
-  "iolib/sockets" = buildLispPackage
+  "form-fiddle" = buildLispPackage
     ((f: x: (x // (f x)))
-       (qlOverrides."iolib/sockets" or (x: {}))
-       (import ./quicklisp-to-nix-output/iolib_slash_sockets.nix {
+       (qlOverrides."form-fiddle" or (x: {}))
+       (import ./quicklisp-to-nix-output/form-fiddle.nix {
          inherit fetchurl;
-           "iolib/base" = quicklisp-to-nix-packages."iolib/base";
-           "iolib/syscalls" = quicklisp-to-nix-packages."iolib/syscalls";
-           "iolib/streams" = quicklisp-to-nix-packages."iolib/streams";
-           "babel" = quicklisp-to-nix-packages."babel";
-           "cffi" = quicklisp-to-nix-packages."cffi";
-           "iolib/grovel" = quicklisp-to-nix-packages."iolib/grovel";
-           "bordeaux-threads" = quicklisp-to-nix-packages."bordeaux-threads";
-           "idna" = quicklisp-to-nix-packages."idna";
-           "swap-bytes" = quicklisp-to-nix-packages."swap-bytes";
+           "documentation-utils" = quicklisp-to-nix-packages."documentation-utils";
        }));
-  "iolib_slash_sockets" = quicklisp-to-nix-packages."iolib/sockets";
 
 
-  "iolib/streams" = buildLispPackage
+  "clss" = buildLispPackage
     ((f: x: (x // (f x)))
-       (qlOverrides."iolib/streams" or (x: {}))
-       (import ./quicklisp-to-nix-output/iolib_slash_streams.nix {
+       (qlOverrides."clss" or (x: {}))
+       (import ./quicklisp-to-nix-output/clss.nix {
          inherit fetchurl;
-           "iolib/base" = quicklisp-to-nix-packages."iolib/base";
-           "iolib/multiplex" = quicklisp-to-nix-packages."iolib/multiplex";
-           "cffi" = quicklisp-to-nix-packages."cffi";
+           "array-utils" = quicklisp-to-nix-packages."array-utils";
+           "plump" = quicklisp-to-nix-packages."plump";
        }));
-  "iolib_slash_streams" = quicklisp-to-nix-packages."iolib/streams";
 
 
-  "iolib/multiplex" = buildLispPackage
+  "array-utils" = buildLispPackage
     ((f: x: (x // (f x)))
-       (qlOverrides."iolib/multiplex" or (x: {}))
-       (import ./quicklisp-to-nix-output/iolib_slash_multiplex.nix {
+       (qlOverrides."array-utils" or (x: {}))
+       (import ./quicklisp-to-nix-output/array-utils.nix {
          inherit fetchurl;
-           "iolib/base" = quicklisp-to-nix-packages."iolib/base";
-           "iolib/syscalls" = quicklisp-to-nix-packages."iolib/syscalls";
-           "cffi" = quicklisp-to-nix-packages."cffi";
        }));
-  "iolib_slash_multiplex" = quicklisp-to-nix-packages."iolib/multiplex";
 
 
-  "iolib/base" = buildLispPackage
+  "lack-util" = buildLispPackage
     ((f: x: (x // (f x)))
-       (qlOverrides."iolib/base" or (x: {}))
-       (import ./quicklisp-to-nix-output/iolib_slash_base.nix {
+       (qlOverrides."lack-util" or (x: {}))
+       (import ./quicklisp-to-nix-output/lack-util.nix {
          inherit fetchurl;
-           "iolib/common-lisp" = quicklisp-to-nix-packages."iolib/common-lisp";
-           "alexandria" = quicklisp-to-nix-packages."alexandria";
-           "split-sequence" = quicklisp-to-nix-packages."split-sequence";
+           "ironclad" = quicklisp-to-nix-packages."ironclad";
        }));
-  "iolib_slash_base" = quicklisp-to-nix-packages."iolib/base";
 
 
-  "chipz" = buildLispPackage
+  "lack-component" = buildLispPackage
     ((f: x: (x // (f x)))
-       (qlOverrides."chipz" or (x: {}))
-       (import ./quicklisp-to-nix-output/chipz.nix {
+       (qlOverrides."lack-component" or (x: {}))
+       (import ./quicklisp-to-nix-output/lack-component.nix {
          inherit fetchurl;
        }));
 
 
-  "puri" = buildLispPackage
+  "nibbles" = buildLispPackage
     ((f: x: (x // (f x)))
-       (qlOverrides."puri" or (x: {}))
-       (import ./quicklisp-to-nix-output/puri.nix {
+       (qlOverrides."nibbles" or (x: {}))
+       (import ./quicklisp-to-nix-output/nibbles.nix {
          inherit fetchurl;
        }));
 
 
-  "trivial-features" = buildLispPackage
+  "swap-bytes" = buildLispPackage
     ((f: x: (x // (f x)))
-       (qlOverrides."trivial-features" or (x: {}))
-       (import ./quicklisp-to-nix-output/trivial-features.nix {
+       (qlOverrides."swap-bytes" or (x: {}))
+       (import ./quicklisp-to-nix-output/swap-bytes.nix {
          inherit fetchurl;
+           "trivial-features" = quicklisp-to-nix-packages."trivial-features";
        }));
 
 
-  "usocket" = buildLispPackage
+  "idna" = buildLispPackage
     ((f: x: (x // (f x)))
-       (qlOverrides."usocket" or (x: {}))
-       (import ./quicklisp-to-nix-output/usocket.nix {
+       (qlOverrides."idna" or (x: {}))
+       (import ./quicklisp-to-nix-output/idna.nix {
          inherit fetchurl;
            "split-sequence" = quicklisp-to-nix-packages."split-sequence";
        }));
···
     ((f: x: (x // (f x)))
        (qlOverrides."md5" or (x: {}))
        (import ./quicklisp-to-nix-output/md5.nix {
+         inherit fetchurl;
+       }));
+
+
+  "jonathan" = buildLispPackage
+    ((f: x: (x // (f x)))
+       (qlOverrides."jonathan" or (x: {}))
+       (import ./quicklisp-to-nix-output/jonathan.nix {
+         inherit fetchurl;
+           "babel" = quicklisp-to-nix-packages."babel";
+           "cl-annot" = quicklisp-to-nix-packages."cl-annot";
+           "cl-ppcre" = quicklisp-to-nix-packages."cl-ppcre";
+           "cl-syntax" = quicklisp-to-nix-packages."cl-syntax";
+           "cl-syntax-annot" = quicklisp-to-nix-packages."cl-syntax-annot";
+           "fast-io" = quicklisp-to-nix-packages."fast-io";
+           "proc-parse" = quicklisp-to-nix-packages."proc-parse";
+           "trivial-types" = quicklisp-to-nix-packages."trivial-types";
+       }));
+
+
+  "puri" = buildLispPackage
+    ((f: x: (x // (f x)))
+       (qlOverrides."puri" or (x: {}))
+       (import ./quicklisp-to-nix-output/puri.nix {
          inherit fetchurl;
        }));
 
···
        (qlOverrides."cl+ssl" or (x: {}))
        (import ./quicklisp-to-nix-output/cl+ssl.nix {
          inherit fetchurl;
+           "bordeaux-threads" = quicklisp-to-nix-packages."bordeaux-threads";
            "cffi" = quicklisp-to-nix-packages."cffi";
-           "trivial-gray-streams" = quicklisp-to-nix-packages."trivial-gray-streams";
            "flexi-streams" = quicklisp-to-nix-packages."flexi-streams";
-           "bordeaux-threads" = quicklisp-to-nix-packages."bordeaux-threads";
            "trivial-garbage" = quicklisp-to-nix-packages."trivial-garbage";
+           "trivial-gray-streams" = quicklisp-to-nix-packages."trivial-gray-streams";
            "uiop" = quicklisp-to-nix-packages."uiop";
        }));
 
 
-  "flexi-streams" = buildLispPackage
+  "chunga" = buildLispPackage
     ((f: x: (x // (f x)))
-       (qlOverrides."flexi-streams" or (x: {}))
-       (import ./quicklisp-to-nix-output/flexi-streams.nix {
+       (qlOverrides."chunga" or (x: {}))
+       (import ./quicklisp-to-nix-output/chunga.nix {
          inherit fetchurl;
            "trivial-gray-streams" = quicklisp-to-nix-packages."trivial-gray-streams";
        }));
 
 
+  "cxml-test" = buildLispPackage
+    ((f: x: (x // (f x)))
+       (qlOverrides."cxml-test" or (x: {}))
+       (import ./quicklisp-to-nix-output/cxml-test.nix {
+         inherit fetchurl;
+           "cxml-dom" = quicklisp-to-nix-packages."cxml-dom";
+           "cxml-klacks" = quicklisp-to-nix-packages."cxml-klacks";
+           "cxml-xml" = quicklisp-to-nix-packages."cxml-xml";
+       }));
+
+
+  "cxml-klacks" = buildLispPackage
+    ((f: x: (x // (f x)))
+       (qlOverrides."cxml-klacks" or (x: {}))
+       (import ./quicklisp-to-nix-output/cxml-klacks.nix {
+         inherit fetchurl;
+           "cxml-xml" = quicklisp-to-nix-packages."cxml-xml";
+       }));
+
+
+  "cxml-dom" = buildLispPackage
+    ((f: x: (x // (f x)))
+       (qlOverrides."cxml-dom" or (x: {}))
+       (import ./quicklisp-to-nix-output/cxml-dom.nix {
+         inherit fetchurl;
+           "cxml-xml" = quicklisp-to-nix-packages."cxml-xml";
+       }));
+
+
+  "named-readtables" = buildLispPackage
+    ((f: x: (x // (f x)))
+       (qlOverrides."named-readtables" or (x: {}))
+       (import ./quicklisp-to-nix-output/named-readtables.nix {
+         inherit fetchurl;
+       }));
+
+
+  "cl-annot" = buildLispPackage
+    ((f: x: (x // (f x)))
+       (qlOverrides."cl-annot" or (x: {}))
+       (import ./quicklisp-to-nix-output/cl-annot.nix {
+         inherit fetchurl;
+           "alexandria" = quicklisp-to-nix-packages."alexandria";
+       }));
+
+
+  "metabang-bind" = buildLispPackage
+    ((f: x: (x // (f x)))
+       (qlOverrides."metabang-bind" or (x: {}))
+       (import ./quicklisp-to-nix-output/metabang-bind.nix {
+         inherit fetchurl;
+       }));
+
+
+  "cl-l10n-cldr" = buildLispPackage
+    ((f: x: (x // (f x)))
+       (qlOverrides."cl-l10n-cldr" or (x: {}))
+       (import ./quicklisp-to-nix-output/cl-l10n-cldr.nix {
+         inherit fetchurl;
+       }));
+
+
   "cl-fad" = buildLispPackage
     ((f: x: (x // (f x)))
        (qlOverrides."cl-fad" or (x: {}))
        (import ./quicklisp-to-nix-output/cl-fad.nix {
          inherit fetchurl;
+           "alexandria" = quicklisp-to-nix-packages."alexandria";
            "bordeaux-threads" = quicklisp-to-nix-packages."bordeaux-threads";
+       }));
+
+
+  "cffi-grovel" = buildLispPackage
+    ((f: x: (x // (f x)))
+       (qlOverrides."cffi-grovel" or (x: {}))
+       (import ./quicklisp-to-nix-output/cffi-grovel.nix {
+         inherit fetchurl;
            "alexandria" = quicklisp-to-nix-packages."alexandria";
+           "cffi" = quicklisp-to-nix-packages."cffi";
+           "cffi-toolchain" = quicklisp-to-nix-packages."cffi-toolchain";
        }));
 
 
-  "cl-base64" = buildLispPackage
+  "cl-libuv" = buildLispPackage
+    ((f: x: (x // (f x)))
+       (qlOverrides."cl-libuv" or (x: {}))
+       (import ./quicklisp-to-nix-output/cl-libuv.nix {
+         inherit fetchurl;
+           "alexandria" = quicklisp-to-nix-packages."alexandria";
+           "cffi" = quicklisp-to-nix-packages."cffi";
+           "cffi-grovel" = quicklisp-to-nix-packages."cffi-grovel";
+       }));
+
+
+  "cl-async-util" = buildLispPackage
+    ((f: x: (x // (f x)))
+       (qlOverrides."cl-async-util" or (x: {}))
+       (import ./quicklisp-to-nix-output/cl-async-util.nix {
+         inherit fetchurl;
+           "cffi" = quicklisp-to-nix-packages."cffi";
+           "cl-async-base" = quicklisp-to-nix-packages."cl-async-base";
+           "cl-libuv" = quicklisp-to-nix-packages."cl-libuv";
+           "cl-ppcre" = quicklisp-to-nix-packages."cl-ppcre";
+           "fast-io" = quicklisp-to-nix-packages."fast-io";
+           "vom" = quicklisp-to-nix-packages."vom";
+       }));
+
+
+  "cl-async-base" = buildLispPackage
+    ((f: x: (x // (f x)))
+       (qlOverrides."cl-async-base" or (x: {}))
+       (import ./quicklisp-to-nix-output/cl-async-base.nix {
+         inherit fetchurl;
+           "bordeaux-threads" = quicklisp-to-nix-packages."bordeaux-threads";
+           "cffi" = quicklisp-to-nix-packages."cffi";
+           "cl-libuv" = quicklisp-to-nix-packages."cl-libuv";
+       }));
+
+
+  "trivial-gray-streams" = buildLispPackage
+    ((f: x: (x // (f x)))
+       (qlOverrides."trivial-gray-streams" or (x: {}))
+       (import ./quicklisp-to-nix-output/trivial-gray-streams.nix {
+         inherit fetchurl;
+       }));
+
+
+  "uiop" = buildLispPackage
     ((f: x: (x // (f x)))
-       (qlOverrides."cl-base64" or (x: {}))
-       (import ./quicklisp-to-nix-output/cl-base64.nix {
+       (qlOverrides."uiop" or (x: {}))
+       (import ./quicklisp-to-nix-output/uiop.nix {
          inherit fetchurl;
        }));
 
 
-  "chunga" = buildLispPackage
+  "myway" = buildLispPackage
+    ((f: x: (x // (f x)))
+       (qlOverrides."myway" or (x: {}))
+       (import ./quicklisp-to-nix-output/myway.nix {
+         inherit fetchurl;
+           "alexandria" = quicklisp-to-nix-packages."alexandria";
+           "cl-ppcre" = quicklisp-to-nix-packages."cl-ppcre";
+           "cl-utilities" = quicklisp-to-nix-packages."cl-utilities";
+           "map-set" = quicklisp-to-nix-packages."map-set";
+           "quri" = quicklisp-to-nix-packages."quri";
+       }));
+
+
+  "do-urlencode" = buildLispPackage
     ((f: x: (x // (f x)))
-       (qlOverrides."chunga" or (x: {}))
-       (import ./quicklisp-to-nix-output/chunga.nix {
+       (qlOverrides."do-urlencode" or (x: {}))
+       (import ./quicklisp-to-nix-output/do-urlencode.nix {
          inherit fetchurl;
+           "babel" = quicklisp-to-nix-packages."babel";
+           "babel-streams" = quicklisp-to-nix-packages."babel-streams";
+       }));
+
+
+  "clack-v1-compat" = buildLispPackage
+    ((f: x: (x // (f x)))
+       (qlOverrides."clack-v1-compat" or (x: {}))
+       (import ./quicklisp-to-nix-output/clack-v1-compat.nix {
+         inherit fetchurl;
+       }));
+
+
+  "cl-syntax" = buildLispPackage
+    ((f: x: (x // (f x)))
+       (qlOverrides."cl-syntax" or (x: {}))
+       (import ./quicklisp-to-nix-output/cl-syntax.nix {
+         inherit fetchurl;
+           "named-readtables" = quicklisp-to-nix-packages."named-readtables";
+           "trivial-types" = quicklisp-to-nix-packages."trivial-types";
+       }));
+
+
+  "cl-project" = buildLispPackage
+    ((f: x: (x // (f x)))
+       (qlOverrides."cl-project" or (x: {}))
+       (import ./quicklisp-to-nix-output/cl-project.nix {
+         inherit fetchurl;
+           "cl-emb" = quicklisp-to-nix-packages."cl-emb";
+           "cl-ppcre" = quicklisp-to-nix-packages."cl-ppcre";
+           "local-time" = quicklisp-to-nix-packages."local-time";
+           "prove" = quicklisp-to-nix-packages."prove";
+           "uiop" = quicklisp-to-nix-packages."uiop";
+       }));
+
+
+  "cl-emb" = buildLispPackage
+    ((f: x: (x // (f x)))
+       (qlOverrides."cl-emb" or (x: {}))
+       (import ./quicklisp-to-nix-output/cl-emb.nix {
+         inherit fetchurl;
+       }));
+
+
+  "anaphora" = buildLispPackage
+    ((f: x: (x // (f x)))
+       (qlOverrides."anaphora" or (x: {}))
+       (import ./quicklisp-to-nix-output/anaphora.nix {
+         inherit fetchurl;
+       }));
+
+
+  "vom" = buildLispPackage
+    ((f: x: (x // (f x)))
+       (qlOverrides."vom" or (x: {}))
+       (import ./quicklisp-to-nix-output/vom.nix {
+         inherit fetchurl;
+       }));
+
+
+  "trivial-features" = buildLispPackage
+    ((f: x: (x // (f x)))
+       (qlOverrides."trivial-features" or (x: {}))
+       (import ./quicklisp-to-nix-output/trivial-features.nix {
+         inherit fetchurl;
+       }));
+
+
+  "yason" = buildLispPackage
+    ((f: x: (x // (f x)))
+       (qlOverrides."yason" or (x: {}))
+       (import ./quicklisp-to-nix-output/yason.nix {
+         inherit fetchurl;
+           "alexandria" = quicklisp-to-nix-packages."alexandria";
            "trivial-gray-streams" = quicklisp-to-nix-packages."trivial-gray-streams";
        }));
 
 
+  "xsubseq" = buildLispPackage
+    ((f: x: (x // (f x)))
+       (qlOverrides."xsubseq" or (x: {}))
+       (import ./quicklisp-to-nix-output/xsubseq.nix {
+         inherit fetchurl;
+       }));
+
+
+  "xmls" = buildLispPackage
+    ((f: x: (x // (f x)))
+       (qlOverrides."xmls" or (x: {}))
+       (import ./quicklisp-to-nix-output/xmls.nix {
+         inherit fetchurl;
+       }));
+
+
+  "wookie" = buildLispPackage
+    ((f: x: (x // (f x)))
+       (qlOverrides."wookie" or (x: {}))
+       (import ./quicklisp-to-nix-output/wookie.nix {
+         inherit fetchurl;
+       }));
+
+
+  "woo" = buildLispPackage
+    ((f: x: (x // (f x)))
+       (qlOverrides."woo" or (x: {}))
+       (import ./quicklisp-to-nix-output/woo.nix {
+         inherit fetchurl;
+       }));
+
+
+  "usocket" = buildLispPackage
+    ((f: x: (x // (f x)))
+       (qlOverrides."usocket" or (x: {}))
+       (import ./quicklisp-to-nix-output/usocket.nix {
+         inherit fetchurl;
+           "split-sequence" = quicklisp-to-nix-packages."split-sequence";
+       }));
+
+
   "trivial-utf-8" = buildLispPackage
     ((f: x: (x // (f x)))
        (qlOverrides."trivial-utf-8" or (x: {}))
···
        }));
 
 
-  "iterate" = buildLispPackage
+  "trivial-types" = buildLispPackage
+    ((f: x: (x // (f x)))
+       (qlOverrides."trivial-types" or (x: {}))
+       (import ./quicklisp-to-nix-output/trivial-types.nix {
+         inherit fetchurl;
+       }));
+
+
+  "trivial-mimes" = buildLispPackage
     ((f: x: (x // (f x)))
-       (qlOverrides."iterate" or (x: {}))
-       (import ./quicklisp-to-nix-output/iterate.nix {
+       (qlOverrides."trivial-mimes" or (x: {}))
+       (import ./quicklisp-to-nix-output/trivial-mimes.nix {
          inherit fetchurl;
        }));
 
···
        }));
 
 
-  "bordeaux-threads" = buildLispPackage
+  "stumpwm" = buildLispPackage
+    ((f: x: (x // (f x)))
+       (qlOverrides."stumpwm" or (x: {}))
+       (import ./quicklisp-to-nix-output/stumpwm.nix {
+         inherit fetchurl;
+       }));
+
+
+  "static-vectors" = buildLispPackage
     ((f: x: (x // (f x)))
-       (qlOverrides."bordeaux-threads" or (x: {}))
-       (import ./quicklisp-to-nix-output/bordeaux-threads.nix {
+       (qlOverrides."static-vectors" or (x: {}))
+       (import ./quicklisp-to-nix-output/static-vectors.nix {
          inherit fetchurl;
            "alexandria" = quicklisp-to-nix-packages."alexandria";
+           "cffi" = quicklisp-to-nix-packages."cffi";
+           "cffi-grovel" = quicklisp-to-nix-packages."cffi-grovel";
        }));
 
 
-  "cl-utilities" = buildLispPackage
+  "split-sequence" = buildLispPackage
     ((f: x: (x // (f x)))
-       (qlOverrides."cl-utilities" or (x: {}))
-       (import ./quicklisp-to-nix-output/cl-utilities.nix {
+       (qlOverrides."split-sequence" or (x: {}))
+       (import ./quicklisp-to-nix-output/split-sequence.nix {
          inherit fetchurl;
        }));
 
 
-  "cffi" = buildLispPackage
+  "smart-buffer" = buildLispPackage
     ((f: x: (x // (f x)))
-       (qlOverrides."cffi" or (x: {}))
-       (import ./quicklisp-to-nix-output/cffi.nix {
+       (qlOverrides."smart-buffer" or (x: {}))
+       (import ./quicklisp-to-nix-output/smart-buffer.nix {
          inherit fetchurl;
+           "flexi-streams" = quicklisp-to-nix-packages."flexi-streams";
            "uiop" = quicklisp-to-nix-packages."uiop";
+           "xsubseq" = quicklisp-to-nix-packages."xsubseq";
+       }));
+
+
+  "salza2" = buildLispPackage
+    ((f: x: (x // (f x)))
+       (qlOverrides."salza2" or (x: {}))
+       (import ./quicklisp-to-nix-output/salza2.nix {
+         inherit fetchurl;
+       }));
+
+
+  "quri" = buildLispPackage
+    ((f: x: (x // (f x)))
+       (qlOverrides."quri" or (x: {}))
+       (import ./quicklisp-to-nix-output/quri.nix {
+         inherit fetchurl;
            "alexandria" = quicklisp-to-nix-packages."alexandria";
-           "trivial-features" = quicklisp-to-nix-packages."trivial-features";
+           "babel" = quicklisp-to-nix-packages."babel";
+           "cl-utilities" = quicklisp-to-nix-packages."cl-utilities";
+           "split-sequence" = quicklisp-to-nix-packages."split-sequence";
+       }));
+
+
+  "prove" = buildLispPackage
+    ((f: x: (x // (f x)))
+       (qlOverrides."prove" or (x: {}))
+       (import ./quicklisp-to-nix-output/prove.nix {
+         inherit fetchurl;
+           "alexandria" = quicklisp-to-nix-packages."alexandria";
+           "cl-ansi-text" = quicklisp-to-nix-packages."cl-ansi-text";
+           "cl-colors" = quicklisp-to-nix-packages."cl-colors";
+           "cl-ppcre" = quicklisp-to-nix-packages."cl-ppcre";
+           "uiop" = quicklisp-to-nix-packages."uiop";
+       }));
+
+
+  "proc-parse" = buildLispPackage
+    ((f: x: (x // (f x)))
+       (qlOverrides."proc-parse" or (x: {}))
+       (import ./quicklisp-to-nix-output/proc-parse.nix {
+         inherit fetchurl;
+           "alexandria" = quicklisp-to-nix-packages."alexandria";
            "babel" = quicklisp-to-nix-packages."babel";
        }));
 
 
-  "clx" = buildLispPackage
+  "plump" = buildLispPackage
     ((f: x: (x // (f x)))
-       (qlOverrides."clx" or (x: {}))
-       (import ./quicklisp-to-nix-output/clx.nix {
+       (qlOverrides."plump" or (x: {}))
+       (import ./quicklisp-to-nix-output/plump.nix {
          inherit fetchurl;
+           "plump-dom" = quicklisp-to-nix-packages."plump-dom";
+           "plump-lexer" = quicklisp-to-nix-packages."plump-lexer";
+           "plump-parser" = quicklisp-to-nix-packages."plump-parser";
        }));
 
 
-  "cl-ppcre" = buildLispPackage
+  "optima" = buildLispPackage
     ((f: x: (x // (f x)))
-       (qlOverrides."cl-ppcre" or (x: {}))
-       (import ./quicklisp-to-nix-output/cl-ppcre.nix {
+       (qlOverrides."optima" or (x: {}))
+       (import ./quicklisp-to-nix-output/optima.nix {
          inherit fetchurl;
+           "alexandria" = quicklisp-to-nix-packages."alexandria";
+           "closer-mop" = quicklisp-to-nix-packages."closer-mop";
        }));
 
 
-  "alexandria" = buildLispPackage
+  "marshal" = buildLispPackage
     ((f: x: (x // (f x)))
-       (qlOverrides."alexandria" or (x: {}))
-       (import ./quicklisp-to-nix-output/alexandria.nix {
+       (qlOverrides."marshal" or (x: {}))
+       (import ./quicklisp-to-nix-output/marshal.nix {
          inherit fetchurl;
        }));
 
 
-  "iolib" = buildLispPackage
+  "lquery" = buildLispPackage
     ((f: x: (x // (f x)))
-       (qlOverrides."iolib" or (x: {}))
-       (import ./quicklisp-to-nix-output/iolib.nix {
+       (qlOverrides."lquery" or (x: {}))
+       (import ./quicklisp-to-nix-output/lquery.nix {
          inherit fetchurl;
-           "iolib/base" = quicklisp-to-nix-packages."iolib/base";
-           "iolib/multiplex" = quicklisp-to-nix-packages."iolib/multiplex";
-           "iolib/streams" = quicklisp-to-nix-packages."iolib/streams";
-           "iolib/sockets" = quicklisp-to-nix-packages."iolib/sockets";
+           "array-utils" = quicklisp-to-nix-packages."array-utils";
+           "clss" = quicklisp-to-nix-packages."clss";
+           "form-fiddle" = quicklisp-to-nix-packages."form-fiddle";
+           "plump" = quicklisp-to-nix-packages."plump";
        }));
 
 
-  "drakma" = buildLispPackage
+  "local-time" = buildLispPackage
     ((f: x: (x // (f x)))
-       (qlOverrides."drakma" or (x: {}))
-       (import ./quicklisp-to-nix-output/drakma.nix {
+       (qlOverrides."local-time" or (x: {}))
+       (import ./quicklisp-to-nix-output/local-time.nix {
          inherit fetchurl;
-           "puri" = quicklisp-to-nix-packages."puri";
-           "cl-base64" = quicklisp-to-nix-packages."cl-base64";
-           "chunga" = quicklisp-to-nix-packages."chunga";
-           "flexi-streams" = quicklisp-to-nix-packages."flexi-streams";
-           "cl-ppcre" = quicklisp-to-nix-packages."cl-ppcre";
-           "chipz" = quicklisp-to-nix-packages."chipz";
-           "usocket" = quicklisp-to-nix-packages."usocket";
-           "cl+ssl" = quicklisp-to-nix-packages."cl+ssl";
+           "cl-fad" = quicklisp-to-nix-packages."cl-fad";
        }));
 
 
-  "external-program" = buildLispPackage
+  "lev" = buildLispPackage
     ((f: x: (x // (f x)))
-       (qlOverrides."external-program" or (x: {}))
-       (import ./quicklisp-to-nix-output/external-program.nix {
+       (qlOverrides."lev" or (x: {}))
+       (import ./quicklisp-to-nix-output/lev.nix {
          inherit fetchurl;
+           "cffi" = quicklisp-to-nix-packages."cffi";
+       }));
+
+
+  "lack" = buildLispPackage
+    ((f: x: (x // (f x)))
+       (qlOverrides."lack" or (x: {}))
+       (import ./quicklisp-to-nix-output/lack.nix {
+         inherit fetchurl;
+           "lack-component" = quicklisp-to-nix-packages."lack-component";
+           "lack-util" = quicklisp-to-nix-packages."lack-util";
+       }));
+
+
+  "iterate" = buildLispPackage
+    ((f: x: (x // (f x)))
+       (qlOverrides."iterate" or (x: {}))
+       (import ./quicklisp-to-nix-output/iterate.nix {
+         inherit fetchurl;
+       }));
+
+
+  "ironclad" = buildLispPackage
+    ((f: x: (x // (f x)))
+       (qlOverrides."ironclad" or (x: {}))
+       (import ./quicklisp-to-nix-output/ironclad.nix {
+         inherit fetchurl;
+           "nibbles" = quicklisp-to-nix-packages."nibbles";
+       }));
+
+
+  "iolib" = buildLispPackage
+    ((f: x: (x // (f x)))
+       (qlOverrides."iolib" or (x: {}))
+       (import ./quicklisp-to-nix-output/iolib.nix {
+         inherit fetchurl;
+           "alexandria" = quicklisp-to-nix-packages."alexandria";
+           "babel" = quicklisp-to-nix-packages."babel";
+           "bordeaux-threads" = quicklisp-to-nix-packages."bordeaux-threads";
+           "cffi" = quicklisp-to-nix-packages."cffi";
+           "idna" = quicklisp-to-nix-packages."idna";
+           "split-sequence" = quicklisp-to-nix-packages."split-sequence";
+           "swap-bytes" = quicklisp-to-nix-packages."swap-bytes";
            "trivial-features" = quicklisp-to-nix-packages."trivial-features";
+           "uiop" = quicklisp-to-nix-packages."uiop";
        }));
 
 
···
        (qlOverrides."hunchentoot" or (x: {}))
        (import ./quicklisp-to-nix-output/hunchentoot.nix {
          inherit fetchurl;
+           "bordeaux-threads" = quicklisp-to-nix-packages."bordeaux-threads";
            "chunga" = quicklisp-to-nix-packages."chunga";
+           "cl+ssl" = quicklisp-to-nix-packages."cl+ssl";
            "cl-base64" = quicklisp-to-nix-packages."cl-base64";
            "cl-fad" = quicklisp-to-nix-packages."cl-fad";
            "cl-ppcre" = quicklisp-to-nix-packages."cl-ppcre";
            "flexi-streams" = quicklisp-to-nix-packages."flexi-streams";
-           "cl+ssl" = quicklisp-to-nix-packages."cl+ssl";
            "md5" = quicklisp-to-nix-packages."md5";
            "rfc2388" = quicklisp-to-nix-packages."rfc2388";
            "trivial-backtrace" = quicklisp-to-nix-packages."trivial-backtrace";
            "usocket" = quicklisp-to-nix-packages."usocket";
-           "bordeaux-threads" = quicklisp-to-nix-packages."bordeaux-threads";
+       }));
+
+
+  "http-body" = buildLispPackage
+    ((f: x: (x // (f x)))
+       (qlOverrides."http-body" or (x: {}))
+       (import ./quicklisp-to-nix-output/http-body.nix {
+         inherit fetchurl;
+           "babel" = quicklisp-to-nix-packages."babel";
+           "cl-ppcre" = quicklisp-to-nix-packages."cl-ppcre";
+           "cl-utilities" = quicklisp-to-nix-packages."cl-utilities";
+           "fast-http" = quicklisp-to-nix-packages."fast-http";
+           "flexi-streams" = quicklisp-to-nix-packages."flexi-streams";
+           "jonathan" = quicklisp-to-nix-packages."jonathan";
+           "quri" = quicklisp-to-nix-packages."quri";
+           "trivial-gray-streams" = quicklisp-to-nix-packages."trivial-gray-streams";
+       }));
+
+
+  "flexi-streams" = buildLispPackage
+    ((f: x: (x // (f x)))
+       (qlOverrides."flexi-streams" or (x: {}))
+       (import ./quicklisp-to-nix-output/flexi-streams.nix {
+         inherit fetchurl;
+           "trivial-gray-streams" = quicklisp-to-nix-packages."trivial-gray-streams";
+       }));
+
+
+  "fast-io" = buildLispPackage
+    ((f: x: (x // (f x)))
+       (qlOverrides."fast-io" or (x: {}))
+       (import ./quicklisp-to-nix-output/fast-io.nix {
+         inherit fetchurl;
+           "alexandria" = quicklisp-to-nix-packages."alexandria";
+           "static-vectors" = quicklisp-to-nix-packages."static-vectors";
+           "trivial-gray-streams" = quicklisp-to-nix-packages."trivial-gray-streams";
+       }));
+
+
+  "fast-http" = buildLispPackage
+    ((f: x: (x // (f x)))
+       (qlOverrides."fast-http" or (x: {}))
+       (import ./quicklisp-to-nix-output/fast-http.nix {
+         inherit fetchurl;
+       }));
+
+
+  "external-program" = buildLispPackage
+    ((f: x: (x // (f x)))
+       (qlOverrides."external-program" or (x: {}))
+       (import ./quicklisp-to-nix-output/external-program.nix {
+         inherit fetchurl;
+           "trivial-features" = quicklisp-to-nix-packages."trivial-features";
        }));
 
 
···
        }));
 
 
+  "drakma" = buildLispPackage
+    ((f: x: (x // (f x)))
+       (qlOverrides."drakma" or (x: {}))
+       (import ./quicklisp-to-nix-output/drakma.nix {
+         inherit fetchurl;
+           "chipz" = quicklisp-to-nix-packages."chipz";
+           "chunga" = quicklisp-to-nix-packages."chunga";
+           "cl+ssl" = quicklisp-to-nix-packages."cl+ssl";
+           "cl-base64" = quicklisp-to-nix-packages."cl-base64";
+           "cl-ppcre" = quicklisp-to-nix-packages."cl-ppcre";
+           "flexi-streams" = quicklisp-to-nix-packages."flexi-streams";
+           "puri" = quicklisp-to-nix-packages."puri";
+           "usocket" = quicklisp-to-nix-packages."usocket";
+       }));
+
+
+  "dexador" = buildLispPackage
+    ((f: x: (x // (f x)))
+       (qlOverrides."dexador" or (x: {}))
+       (import ./quicklisp-to-nix-output/dexador.nix {
+         inherit fetchurl;
+       }));
+
+
+  "cxml" = buildLispPackage
+    ((f: x: (x // (f x)))
+       (qlOverrides."cxml" or (x: {}))
+       (import ./quicklisp-to-nix-output/cxml.nix {
+         inherit fetchurl;
+           "cxml-dom" = quicklisp-to-nix-packages."cxml-dom";
+           "cxml-klacks" = quicklisp-to-nix-packages."cxml-klacks";
+           "cxml-test" = quicklisp-to-nix-packages."cxml-test";
+       }));
+
+
+  "css-lite" = buildLispPackage
+    ((f: x: (x // (f x)))
+       (qlOverrides."css-lite" or (x: {}))
+       (import ./quicklisp-to-nix-output/css-lite.nix {
+         inherit fetchurl;
+       }));
+
+
+  "parenscript" = buildLispPackage
+    ((f: x: (x // (f x)))
+       (qlOverrides."parenscript" or (x: {}))
+       (import ./quicklisp-to-nix-output/parenscript.nix {
+         inherit fetchurl;
+           "anaphora" = quicklisp-to-nix-packages."anaphora";
+           "cl-ppcre" = quicklisp-to-nix-packages."cl-ppcre";
+           "named-readtables" = quicklisp-to-nix-packages."named-readtables";
+       }));
+
+
+  "clx" = buildLispPackage
+    ((f: x: (x // (f x)))
+       (qlOverrides."clx" or (x: {}))
+       (import ./quicklisp-to-nix-output/clx.nix {
+         inherit fetchurl;
+       }));
+
+
+  "cl-who" = buildLispPackage
+    ((f: x: (x // (f x)))
+       (qlOverrides."cl-who" or (x: {}))
+       (import ./quicklisp-to-nix-output/cl-who.nix {
+         inherit fetchurl;
+       }));
+
+
+  "cl-utilities" = buildLispPackage
+    ((f: x: (x // (f x)))
+       (qlOverrides."cl-utilities" or (x: {}))
+       (import ./quicklisp-to-nix-output/cl-utilities.nix {
+         inherit fetchurl;
+       }));
+
+
+  "cl-unicode" = buildLispPackage
+    ((f: x: (x // (f x)))
+       (qlOverrides."cl-unicode" or (x: {}))
+       (import ./quicklisp-to-nix-output/cl-unicode.nix {
+         inherit fetchurl;
+       }));
+
+
+  "cl-syntax-annot" = buildLispPackage
+    ((f: x: (x // (f x)))
+       (qlOverrides."cl-syntax-annot" or (x: {}))
+       (import ./quicklisp-to-nix-output/cl-syntax-annot.nix {
+         inherit fetchurl;
+           "cl-annot" = quicklisp-to-nix-packages."cl-annot";
+           "cl-syntax" = quicklisp-to-nix-packages."cl-syntax";
+       }));
+
+
+  "cl-reexport" = buildLispPackage
+    ((f: x: (x // (f x)))
+       (qlOverrides."cl-reexport" or (x: {}))
+       (import ./quicklisp-to-nix-output/cl-reexport.nix {
+         inherit fetchurl;
+           "alexandria" = quicklisp-to-nix-packages."alexandria";
+       }));
+
+
+  "cl-ppcre" = buildLispPackage
+    ((f: x: (x // (f x)))
+       (qlOverrides."cl-ppcre" or (x: {}))
+       (import ./quicklisp-to-nix-output/cl-ppcre.nix {
+         inherit fetchurl;
+       }));
+
+
+  "closer-mop" = buildLispPackage
+    ((f: x: (x // (f x)))
+       (qlOverrides."closer-mop" or (x: {}))
+       (import ./quicklisp-to-nix-output/closer-mop.nix {
+         inherit fetchurl;
+       }));
+
+
+  "cl-l10n" = buildLispPackage
+    ((f: x: (x // (f x)))
+       (qlOverrides."cl-l10n" or (x: {}))
+       (import ./quicklisp-to-nix-output/cl-l10n.nix {
+         inherit fetchurl;
+           "alexandria" = quicklisp-to-nix-packages."alexandria";
+           "cl-fad" = quicklisp-to-nix-packages."cl-fad";
+           "cl-l10n-cldr" = quicklisp-to-nix-packages."cl-l10n-cldr";
+           "cl-ppcre" = quicklisp-to-nix-packages."cl-ppcre";
+           "closer-mop" = quicklisp-to-nix-packages."closer-mop";
+           "cxml" = quicklisp-to-nix-packages."cxml";
+           "flexi-streams" = quicklisp-to-nix-packages."flexi-streams";
+           "iterate" = quicklisp-to-nix-packages."iterate";
+           "local-time" = quicklisp-to-nix-packages."local-time";
+           "metabang-bind" = quicklisp-to-nix-packages."metabang-bind";
+       }));
+
+
+  "cl-json" = buildLispPackage
+    ((f: x: (x // (f x)))
+       (qlOverrides."cl-json" or (x: {}))
+       (import ./quicklisp-to-nix-output/cl-json.nix {
+         inherit fetchurl;
+       }));
+
+
   "cl-fuse" = buildLispPackage
     ((f: x: (x // (f x)))
        (qlOverrides."cl-fuse" or (x: {}))
        (import ./quicklisp-to-nix-output/cl-fuse.nix {
          inherit fetchurl;
+           "bordeaux-threads" = quicklisp-to-nix-packages."bordeaux-threads";
            "cffi" = quicklisp-to-nix-packages."cffi";
+           "cffi-grovel" = quicklisp-to-nix-packages."cffi-grovel";
            "cl-utilities" = quicklisp-to-nix-packages."cl-utilities";
-           "bordeaux-threads" = quicklisp-to-nix-packages."bordeaux-threads";
+           "iterate" = quicklisp-to-nix-packages."iterate";
            "trivial-backtrace" = quicklisp-to-nix-packages."trivial-backtrace";
-           "iterate" = quicklisp-to-nix-packages."iterate";
            "trivial-utf-8" = quicklisp-to-nix-packages."trivial-utf-8";
        }));
 
 
-  "stumpwm" = buildLispPackage
+  "cl-cookie" = buildLispPackage
+    ((f: x: (x // (f x)))
+       (qlOverrides."cl-cookie" or (x: {}))
+       (import ./quicklisp-to-nix-output/cl-cookie.nix {
+         inherit fetchurl;
+           "alexandria" = quicklisp-to-nix-packages."alexandria";
+           "cl-ppcre" = quicklisp-to-nix-packages."cl-ppcre";
+           "local-time" = quicklisp-to-nix-packages."local-time";
+           "proc-parse" = quicklisp-to-nix-packages."proc-parse";
+           "quri" = quicklisp-to-nix-packages."quri";
+       }));
+
+
+  "cl-base64" = buildLispPackage
+    ((f: x: (x // (f x)))
+       (qlOverrides."cl-base64" or (x: {}))
+       (import ./quicklisp-to-nix-output/cl-base64.nix {
+         inherit fetchurl;
+       }));
+
+
+  "cl-async" = buildLispPackage
+    ((f: x: (x // (f x)))
+       (qlOverrides."cl-async" or (x: {}))
+       (import ./quicklisp-to-nix-output/cl-async.nix {
+         inherit fetchurl;
+           "babel" = quicklisp-to-nix-packages."babel";
+           "cffi" = quicklisp-to-nix-packages."cffi";
+           "cl-async-base" = quicklisp-to-nix-packages."cl-async-base";
+           "cl-async-util" = quicklisp-to-nix-packages."cl-async-util";
+           "cl-libuv" = quicklisp-to-nix-packages."cl-libuv";
+           "cl-ppcre" = quicklisp-to-nix-packages."cl-ppcre";
+           "static-vectors" = quicklisp-to-nix-packages."static-vectors";
+           "trivial-features" = quicklisp-to-nix-packages."trivial-features";
+           "trivial-gray-streams" = quicklisp-to-nix-packages."trivial-gray-streams";
+           "uiop" = quicklisp-to-nix-packages."uiop";
+       }));
+
+
+  "clack" = buildLispPackage
+    ((f: x: (x // (f x)))
+       (qlOverrides."clack" or (x: {}))
+       (import ./quicklisp-to-nix-output/clack.nix {
+         inherit fetchurl;
+       }));
+
+
+  "circular-streams" = buildLispPackage
+    ((f: x: (x // (f x)))
+       (qlOverrides."circular-streams" or (x: {}))
+       (import ./quicklisp-to-nix-output/circular-streams.nix {
+         inherit fetchurl;
+           "fast-io" = quicklisp-to-nix-packages."fast-io";
+           "trivial-gray-streams" = quicklisp-to-nix-packages."trivial-gray-streams";
+       }));
+
+
+  "chipz" = buildLispPackage
     ((f: x: (x // (f x)))
-       (qlOverrides."stumpwm" or (x: {}))
-       (import ./quicklisp-to-nix-output/stumpwm.nix {
+       (qlOverrides."chipz" or (x: {}))
+       (import ./quicklisp-to-nix-output/chipz.nix {
+         inherit fetchurl;
+       }));
+
+
+  "cffi" = buildLispPackage
+    ((f: x: (x // (f x)))
+       (qlOverrides."cffi" or (x: {}))
+       (import ./quicklisp-to-nix-output/cffi.nix {
          inherit fetchurl;
            "alexandria" = quicklisp-to-nix-packages."alexandria";
+           "babel" = quicklisp-to-nix-packages."babel";
+           "trivial-features" = quicklisp-to-nix-packages."trivial-features";
+           "uiop" = quicklisp-to-nix-packages."uiop";
+       }));
+
+
+  "caveman" = buildLispPackage
+    ((f: x: (x // (f x)))
+       (qlOverrides."caveman" or (x: {}))
+       (import ./quicklisp-to-nix-output/caveman.nix {
+         inherit fetchurl;
+           "anaphora" = quicklisp-to-nix-packages."anaphora";
+           "cl-emb" = quicklisp-to-nix-packages."cl-emb";
            "cl-ppcre" = quicklisp-to-nix-packages."cl-ppcre";
-           "clx" = quicklisp-to-nix-packages."clx";
+           "cl-project" = quicklisp-to-nix-packages."cl-project";
+           "cl-syntax" = quicklisp-to-nix-packages."cl-syntax";
+           "cl-syntax-annot" = quicklisp-to-nix-packages."cl-syntax-annot";
+           "clack-v1-compat" = quicklisp-to-nix-packages."clack-v1-compat";
+           "do-urlencode" = quicklisp-to-nix-packages."do-urlencode";
+           "local-time" = quicklisp-to-nix-packages."local-time";
+           "myway" = quicklisp-to-nix-packages."myway";
+       }));
+
+
+  "bordeaux-threads" = buildLispPackage
+    ((f: x: (x // (f x)))
+       (qlOverrides."bordeaux-threads" or (x: {}))
+       (import ./quicklisp-to-nix-output/bordeaux-threads.nix {
+         inherit fetchurl;
+           "alexandria" = quicklisp-to-nix-packages."alexandria";
+       }));
+
+
+  "blackbird" = buildLispPackage
+    ((f: x: (x // (f x)))
+       (qlOverrides."blackbird" or (x: {}))
+       (import ./quicklisp-to-nix-output/blackbird.nix {
+         inherit fetchurl;
+           "vom" = quicklisp-to-nix-packages."vom";
+       }));
+
+
+  "babel" = buildLispPackage
+    ((f: x: (x // (f x)))
+       (qlOverrides."babel" or (x: {}))
+       (import ./quicklisp-to-nix-output/babel.nix {
+         inherit fetchurl;
+           "alexandria" = quicklisp-to-nix-packages."alexandria";
+           "trivial-features" = quicklisp-to-nix-packages."trivial-features";
+       }));
+
+
+  "alexandria" = buildLispPackage
+    ((f: x: (x // (f x)))
+       (qlOverrides."alexandria" or (x: {}))
+       (import ./quicklisp-to-nix-output/alexandria.nix {
+         inherit fetchurl;
        }));
 
 

pkgs/development/lisp-modules/quicklisp-to-nix/ql-to-nix.lisp

···
          (nix-prefetch-url local-url)))
      (ideal-md5 (ql-dist:archive-md5 ql-release))
      (file-md5 (getf archive-data :md5))
-     (raw-dependencies (asdf:system-depends-on asdf-system))
+     (raw-dependencies (ql-dist:required-systems ql-system))
      (dependencies (remove-if-not 'ql-dist:find-system raw-dependencies))
      (deps (mapcar (lambda (x) (list :name x)) dependencies))
      (name (string-downcase (format nil "~a" system)))
···
     :url url
     :md5 file-md5
     :name name
+    :testname (gethash name testnames)
     :filename (escape-filename name)
     :deps deps
     :dependencies dependencies
···
       finally (return res))))
 
 (defun ql-to-nix (target-directory)
+  (load (format nil "~a/quicklisp-to-nix-overrides.lisp" target-directory))
   (let*
     ((systems
        (cl-ppcre:split