commit bc06c93905f60a82d6ebbb78f78cf289257860cc · pyrox.dev/nixpkgs

+26

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

···

       1
       1
       +
       /* Generated file. */

     

       2
       2
       +
       args @ { fetchurl, ... }:

     

       3
       3
       +
       rec {

     

       4
       4
       +
         baseName = "fn";

     

       5
       5
       +
         version = "20171019-git";

     

       6
       6
       +
       

     

       7
       7
       +
         description = "Some macros for lambda brevity";

     

       8
       8
       +
       

     

       9
       9
       +
         deps = [ args."named-readtables" ];

     

       10
       10
       +
       

     

       11
       11
       +
         src = fetchurl {

     

       12
       12
       +
           url = "http://beta.quicklisp.org/archive/fn/2017-10-19/fn-20171019-git.tgz";

     

       13
       13
       +
           sha256 = "0r062ffn31sc7313xlfaa9pwnf2wdkiq4spqlr1lk5r8isvdnzz8";

     

       14
       14
       +
         };

     

       15
       15
       +
       

     

       16
       16
       +
         packageName = "fn";

     

       17
       17
       +
       

     

       18
       18
       +
         asdFilesToKeep = ["fn.asd"];

     

       19
       19
       +
         overrides = x: x;

     

       20
       20
       +
       }

     

       21
       21
       +
       /* (SYSTEM fn DESCRIPTION Some macros for lambda brevity SHA256

     

       22
       22
       +
           0r062ffn31sc7313xlfaa9pwnf2wdkiq4spqlr1lk5r8isvdnzz8 URL

     

       23
       23
       +
           http://beta.quicklisp.org/archive/fn/2017-10-19/fn-20171019-git.tgz MD5

     

       24
       24
       +
           0e1cfe5f19ceec8966baa3037772d31e NAME fn FILENAME fn DEPS

     

       25
       25
       +
           ((NAME named-readtables FILENAME named-readtables)) DEPENDENCIES

     

       26
       26
       +
           (named-readtables) VERSION 20171019-git SIBLINGS NIL PARASITES NIL) */

+28

pkgs/development/lisp-modules/quicklisp-to-nix-output/glsl-docs.nix

···

       1
       1
       +
       /* Generated file. */

     

       2
       2
       +
       args @ { fetchurl, ... }:

     

       3
       3
       +
       rec {

     

       4
       4
       +
         baseName = "glsl-docs";

     

       5
       5
       +
         version = "glsl-spec-release-quicklisp-f04476f7-git";

     

       6
       6
       +
       

     

       7
       7
       +
         description = "The official docs for all the symbols in glsl-symbols";

     

       8
       8
       +
       

     

       9
       9
       +
         deps = [ args."glsl-symbols" ];

     

       10
       10
       +
       

     

       11
       11
       +
         src = fetchurl {

     

       12
       12
       +
           url = "http://beta.quicklisp.org/archive/glsl-spec/2019-10-07/glsl-spec-release-quicklisp-f04476f7-git.tgz";

     

       13
       13
       +
           sha256 = "0vdxx5asra0r58qpk35ncmyh418szzzvby8bpkrb052g00nzqgj7";

     

       14
       14
       +
         };

     

       15
       15
       +
       

     

       16
       16
       +
         packageName = "glsl-docs";

     

       17
       17
       +
       

     

       18
       18
       +
         asdFilesToKeep = ["glsl-docs.asd"];

     

       19
       19
       +
         overrides = x: x;

     

       20
       20
       +
       }

     

       21
       21
       +
       /* (SYSTEM glsl-docs DESCRIPTION

     

       22
       22
       +
           The official docs for all the symbols in glsl-symbols SHA256

     

       23
       23
       +
           0vdxx5asra0r58qpk35ncmyh418szzzvby8bpkrb052g00nzqgj7 URL

     

       24
       24
       +
           http://beta.quicklisp.org/archive/glsl-spec/2019-10-07/glsl-spec-release-quicklisp-f04476f7-git.tgz

     

       25
       25
       +
           MD5 52760939a269acce6b2cba8dbde81ef7 NAME glsl-docs FILENAME glsl-docs DEPS

     

       26
       26
       +
           ((NAME glsl-symbols FILENAME glsl-symbols)) DEPENDENCIES (glsl-symbols)

     

       27
       27
       +
           VERSION glsl-spec-release-quicklisp-f04476f7-git SIBLINGS

     

       28
       28
       +
           (glsl-spec glsl-symbols) PARASITES NIL) */

+26

pkgs/development/lisp-modules/quicklisp-to-nix-output/glsl-spec.nix

···

       1
       1
       +
       /* Generated file. */

     

       2
       2
       +
       args @ { fetchurl, ... }:

     

       3
       3
       +
       rec {

     

       4
       4
       +
         baseName = "glsl-spec";

     

       5
       5
       +
         version = "release-quicklisp-f04476f7-git";

     

       6
       6
       +
       

     

       7
       7
       +
         description = "The GLSL Spec as a datastructure";

     

       8
       8
       +
       

     

       9
       9
       +
         deps = [ ];

     

       10
       10
       +
       

     

       11
       11
       +
         src = fetchurl {

     

       12
       12
       +
           url = "http://beta.quicklisp.org/archive/glsl-spec/2019-10-07/glsl-spec-release-quicklisp-f04476f7-git.tgz";

     

       13
       13
       +
           sha256 = "0vdxx5asra0r58qpk35ncmyh418szzzvby8bpkrb052g00nzqgj7";

     

       14
       14
       +
         };

     

       15
       15
       +
       

     

       16
       16
       +
         packageName = "glsl-spec";

     

       17
       17
       +
       

     

       18
       18
       +
         asdFilesToKeep = ["glsl-spec.asd"];

     

       19
       19
       +
         overrides = x: x;

     

       20
       20
       +
       }

     

       21
       21
       +
       /* (SYSTEM glsl-spec DESCRIPTION The GLSL Spec as a datastructure SHA256

     

       22
       22
       +
           0vdxx5asra0r58qpk35ncmyh418szzzvby8bpkrb052g00nzqgj7 URL

     

       23
       23
       +
           http://beta.quicklisp.org/archive/glsl-spec/2019-10-07/glsl-spec-release-quicklisp-f04476f7-git.tgz

     

       24
       24
       +
           MD5 52760939a269acce6b2cba8dbde81ef7 NAME glsl-spec FILENAME glsl-spec DEPS

     

       25
       25
       +
           NIL DEPENDENCIES NIL VERSION release-quicklisp-f04476f7-git SIBLINGS

     

       26
       26
       +
           (glsl-docs glsl-symbols) PARASITES NIL) */

+27

pkgs/development/lisp-modules/quicklisp-to-nix-output/glsl-symbols.nix

···

       1
       1
       +
       /* Generated file. */

     

       2
       2
       +
       args @ { fetchurl, ... }:

     

       3
       3
       +
       rec {

     

       4
       4
       +
         baseName = "glsl-symbols";

     

       5
       5
       +
         version = "glsl-spec-release-quicklisp-f04476f7-git";

     

       6
       6
       +
       

     

       7
       7
       +
         description = "Lispy versions of all glsl names as symbols";

     

       8
       8
       +
       

     

       9
       9
       +
         deps = [ ];

     

       10
       10
       +
       

     

       11
       11
       +
         src = fetchurl {

     

       12
       12
       +
           url = "http://beta.quicklisp.org/archive/glsl-spec/2019-10-07/glsl-spec-release-quicklisp-f04476f7-git.tgz";

     

       13
       13
       +
           sha256 = "0vdxx5asra0r58qpk35ncmyh418szzzvby8bpkrb052g00nzqgj7";

     

       14
       14
       +
         };

     

       15
       15
       +
       

     

       16
       16
       +
         packageName = "glsl-symbols";

     

       17
       17
       +
       

     

       18
       18
       +
         asdFilesToKeep = ["glsl-symbols.asd"];

     

       19
       19
       +
         overrides = x: x;

     

       20
       20
       +
       }

     

       21
       21
       +
       /* (SYSTEM glsl-symbols DESCRIPTION Lispy versions of all glsl names as symbols

     

       22
       22
       +
           SHA256 0vdxx5asra0r58qpk35ncmyh418szzzvby8bpkrb052g00nzqgj7 URL

     

       23
       23
       +
           http://beta.quicklisp.org/archive/glsl-spec/2019-10-07/glsl-spec-release-quicklisp-f04476f7-git.tgz

     

       24
       24
       +
           MD5 52760939a269acce6b2cba8dbde81ef7 NAME glsl-symbols FILENAME

     

       25
       25
       +
           glsl-symbols DEPS NIL DEPENDENCIES NIL VERSION

     

       26
       26
       +
           glsl-spec-release-quicklisp-f04476f7-git SIBLINGS (glsl-docs glsl-spec)

     

       27
       27
       +
           PARASITES NIL) */

+26

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

···

       1
       1
       +
       /* Generated file. */

     

       2
       2
       +
       args @ { fetchurl, ... }:

     

       3
       3
       +
       rec {

     

       4
       4
       +
         baseName = "lisp-unit";

     

       5
       5
       +
         version = "20170124-git";

     

       6
       6
       +
       

     

       7
       7
       +
         description = "Common Lisp library that supports unit testing.";

     

       8
       8
       +
       

     

       9
       9
       +
         deps = [ ];

     

       10
       10
       +
       

     

       11
       11
       +
         src = fetchurl {

     

       12
       12
       +
           url = "http://beta.quicklisp.org/archive/lisp-unit/2017-01-24/lisp-unit-20170124-git.tgz";

     

       13
       13
       +
           sha256 = "00bc19r7vr76rpk8lh8z7qln0glpf66mzqxw215488zwz3nwcq4m";

     

       14
       14
       +
         };

     

       15
       15
       +
       

     

       16
       16
       +
         packageName = "lisp-unit";

     

       17
       17
       +
       

     

       18
       18
       +
         asdFilesToKeep = ["lisp-unit.asd"];

     

       19
       19
       +
         overrides = x: x;

     

       20
       20
       +
       }

     

       21
       21
       +
       /* (SYSTEM lisp-unit DESCRIPTION

     

       22
       22
       +
           Common Lisp library that supports unit testing. SHA256

     

       23
       23
       +
           00bc19r7vr76rpk8lh8z7qln0glpf66mzqxw215488zwz3nwcq4m URL

     

       24
       24
       +
           http://beta.quicklisp.org/archive/lisp-unit/2017-01-24/lisp-unit-20170124-git.tgz

     

       25
       25
       +
           MD5 2c55342cb8af18b290bb6a28c75deac5 NAME lisp-unit FILENAME lisp-unit DEPS

     

       26
       26
       +
           NIL DEPENDENCIES NIL VERSION 20170124-git SIBLINGS NIL PARASITES NIL) */

+30

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

···

       1
       1
       +
       /* Generated file. */

     

       2
       2
       +
       args @ { fetchurl, ... }:

     

       3
       3
       +
       rec {

     

       4
       4
       +
         baseName = "parse-float";

     

       5
       5
       +
         version = "20200218-git";

     

       6
       6
       +
       

     

       7
       7
       +
         parasites = [ "parse-float-tests" ];

     

       8
       8
       +
       

     

       9
       9
       +
         description = "Parse floating point values in strings.";

     

       10
       10
       +
       

     

       11
       11
       +
         deps = [ args."alexandria" args."lisp-unit" ];

     

       12
       12
       +
       

     

       13
       13
       +
         src = fetchurl {

     

       14
       14
       +
           url = "http://beta.quicklisp.org/archive/parse-float/2020-02-18/parse-float-20200218-git.tgz";

     

       15
       15
       +
           sha256 = "02rhgn79hhv0p5ysj4gwk5bhmr2sj6cvkacbqzzw24qrzgcpdnfw";

     

       16
       16
       +
         };

     

       17
       17
       +
       

     

       18
       18
       +
         packageName = "parse-float";

     

       19
       19
       +
       

     

       20
       20
       +
         asdFilesToKeep = ["parse-float.asd"];

     

       21
       21
       +
         overrides = x: x;

     

       22
       22
       +
       }

     

       23
       23
       +
       /* (SYSTEM parse-float DESCRIPTION Parse floating point values in strings.

     

       24
       24
       +
           SHA256 02rhgn79hhv0p5ysj4gwk5bhmr2sj6cvkacbqzzw24qrzgcpdnfw URL

     

       25
       25
       +
           http://beta.quicklisp.org/archive/parse-float/2020-02-18/parse-float-20200218-git.tgz

     

       26
       26
       +
           MD5 149e40a8c5fd6ab0e43242cb898d66bf NAME parse-float FILENAME parse-float

     

       27
       27
       +
           DEPS

     

       28
       28
       +
           ((NAME alexandria FILENAME alexandria) (NAME lisp-unit FILENAME lisp-unit))

     

       29
       29
       +
           DEPENDENCIES (alexandria lisp-unit) VERSION 20200218-git SIBLINGS NIL

     

       30
       30
       +
           PARASITES (parse-float-tests)) */

+39

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

···

       1
       1
       +
       /* Generated file. */

     

       2
       2
       +
       args @ { fetchurl, ... }:

     

       3
       3
       +
       rec {

     

       4
       4
       +
         baseName = "varjo";

     

       5
       5
       +
         version = "release-quicklisp-92f9c75b-git";

     

       6
       6
       +
       

     

       7
       7
       +
         description = "Common Lisp -> GLSL Compiler";

     

       8
       8
       +
       

     

       9
       9
       +
         deps = [ args."alexandria" args."cl-ppcre" args."documentation-utils" args."fn" args."glsl-docs" args."glsl-spec" args."glsl-symbols" args."named-readtables" args."parse-float" args."trivial-indent" args."uiop" args."vas-string-metrics" ];

     

       10
       10
       +
       

     

       11
       11
       +
         src = fetchurl {

     

       12
       12
       +
           url = "http://beta.quicklisp.org/archive/varjo/2021-01-24/varjo-release-quicklisp-92f9c75b-git.tgz";

     

       13
       13
       +
           sha256 = "0xxi2ivjz3fqgw2nxzshf9m7ppvzv7wdg20lr0krq14i8j5gf5jy";

     

       14
       14
       +
         };

     

       15
       15
       +
       

     

       16
       16
       +
         packageName = "varjo";

     

       17
       17
       +
       

     

       18
       18
       +
         asdFilesToKeep = ["varjo.asd"];

     

       19
       19
       +
         overrides = x: x;

     

       20
       20
       +
       }

     

       21
       21
       +
       /* (SYSTEM varjo DESCRIPTION Common Lisp -> GLSL Compiler SHA256

     

       22
       22
       +
           0xxi2ivjz3fqgw2nxzshf9m7ppvzv7wdg20lr0krq14i8j5gf5jy URL

     

       23
       23
       +
           http://beta.quicklisp.org/archive/varjo/2021-01-24/varjo-release-quicklisp-92f9c75b-git.tgz

     

       24
       24
       +
           MD5 78a3b8021885ebfab4015e20b885cdcf NAME varjo FILENAME varjo DEPS

     

       25
       25
       +
           ((NAME alexandria FILENAME alexandria) (NAME cl-ppcre FILENAME cl-ppcre)

     

       26
       26
       +
            (NAME documentation-utils FILENAME documentation-utils)

     

       27
       27
       +
            (NAME fn FILENAME fn) (NAME glsl-docs FILENAME glsl-docs)

     

       28
       28
       +
            (NAME glsl-spec FILENAME glsl-spec)

     

       29
       29
       +
            (NAME glsl-symbols FILENAME glsl-symbols)

     

       30
       30
       +
            (NAME named-readtables FILENAME named-readtables)

     

       31
       31
       +
            (NAME parse-float FILENAME parse-float)

     

       32
       32
       +
            (NAME trivial-indent FILENAME trivial-indent) (NAME uiop FILENAME uiop)

     

       33
       33
       +
            (NAME vas-string-metrics FILENAME vas-string-metrics))

     

       34
       34
       +
           DEPENDENCIES

     

       35
       35
       +
           (alexandria cl-ppcre documentation-utils fn glsl-docs glsl-spec

     

       36
       36
       +
            glsl-symbols named-readtables parse-float trivial-indent uiop

     

       37
       37
       +
            vas-string-metrics)

     

       38
       38
       +
           VERSION release-quicklisp-92f9c75b-git SIBLINGS (varjo.import varjo.tests)

     

       39
       39
       +
           PARASITES NIL) */

+27

pkgs/development/lisp-modules/quicklisp-to-nix-output/vas-string-metrics.nix

···

       1
       1
       +
       /* Generated file. */

     

       2
       2
       +
       args @ { fetchurl, ... }:

     

       3
       3
       +
       rec {

     

       4
       4
       +
         baseName = "vas-string-metrics";

     

       5
       5
       +
         version = "20160208-git";

     

       6
       6
       +
       

     

       7
       7
       +
         description = "Jaro-Winkler and Levenshtein string distance algorithms.";

     

       8
       8
       +
       

     

       9
       9
       +
         deps = [ ];

     

       10
       10
       +
       

     

       11
       11
       +
         src = fetchurl {

     

       12
       12
       +
           url = "http://beta.quicklisp.org/archive/vas-string-metrics/2016-02-08/vas-string-metrics-20160208-git.tgz";

     

       13
       13
       +
           sha256 = "1s9a9bgc2ibknjr6mlbr4gsxcwpjivz5hbl1wz57fsh4n0w8h7ch";

     

       14
       14
       +
         };

     

       15
       15
       +
       

     

       16
       16
       +
         packageName = "vas-string-metrics";

     

       17
       17
       +
       

     

       18
       18
       +
         asdFilesToKeep = ["vas-string-metrics.asd"];

     

       19
       19
       +
         overrides = x: x;

     

       20
       20
       +
       }

     

       21
       21
       +
       /* (SYSTEM vas-string-metrics DESCRIPTION

     

       22
       22
       +
           Jaro-Winkler and Levenshtein string distance algorithms. SHA256

     

       23
       23
       +
           1s9a9bgc2ibknjr6mlbr4gsxcwpjivz5hbl1wz57fsh4n0w8h7ch URL

     

       24
       24
       +
           http://beta.quicklisp.org/archive/vas-string-metrics/2016-02-08/vas-string-metrics-20160208-git.tgz

     

       25
       25
       +
           MD5 5f38d4ee241c11286be6147f481e7fd0 NAME vas-string-metrics FILENAME

     

       26
       26
       +
           vas-string-metrics DEPS NIL DEPENDENCIES NIL VERSION 20160208-git SIBLINGS

     

       27
       27
       +
           (test.vas-string-metrics) PARASITES NIL) */

+17 -16

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

···

       11
       11
        
       bordeaux-threads

     

       12
       12
        
       calispel

     

       13
       13
        
       caveman

     

       14
       14
       -
       cl-custom-hash-table

     

       15
       14
        
       cffi

     

       16
       15
        
       cffi-grovel

     

       17
       16
        
       cffi-uffi-compat

     
···

       19
       18
        
       chipz

     

       20
       19
        
       chunga

     

       21
       20
        
       circular-streams

     

       22
       22
       -
       clack

     

       23
       23
       -
       clack-v1-compat

     

       21
       21
       +
       cl+ssl

     

       24
       22
        
       cl-annot

     

       25
       23
        
       cl-ansi-text

     

       26
       24
        
       cl-async

     
···

       35
       33
        
       cl-cookie

     

       36
       34
        
       cl-css

     

       37
       35
        
       cl-csv

     

       36
       36
       +
       cl-custom-hash-table

     

       38
       37
        
       cl-dbi

     

       39
       38
        
       cl-dot

     

       40
       39
        
       cl-emb

     
···

       44
       43
        
       cl-gobject-introspection

     

       45
       44
        
       cl-hooks

     

       46
       45
        
       cl-html-diff

     

       47
       47
       -
       cl-html5-parser

     

       48
       46
        
       cl-html-parse

     

       47
       47
       +
       cl-html5-parser

     

       49
       48
        
       cl-interpol

     

       50
       49
        
       cl-jpeg

     

       51
       50
        
       cl-json

     
···

       54
       53
        
       cl-locale

     

       55
       54
        
       cl-markup

     

       56
       55
        
       cl-mysql

     

       57
       57
       -
       closer-mop

     

       58
       58
       -
       closure-common

     

       59
       59
       -
       closure-html

     

       60
       56
        
       cl-paths-ttf

     

       61
       57
        
       cl-pdf

     

       62
       58
        
       cl-ppcre

     
···

       67
       63
        
       cl-qprint

     

       68
       64
        
       cl-reexport

     

       69
       65
        
       cl-slice

     

       70
       70
       -
       cl-speedy-queue

     

       71
       66
        
       cl-smtp

     

       72
       72
       -
       cl-syslog

     

       73
       73
       -
       clsql

     

       74
       74
       -
       clsql-postgresql

     

       75
       75
       -
       clsql-postgresql-socket

     

       76
       76
       -
       clsql-sqlite3

     

       77
       77
       -
       clss

     

       78
       78
       -
       cl+ssl

     

       67
       67
       +
       cl-speedy-queue

     

       79
       68
        
       cl-store

     

       80
       69
        
       cl-syntax

     

       81
       70
        
       cl-syntax-annot

     

       82
       71
        
       cl-syntax-anonfun

     

       83
       72
        
       cl-syntax-markup

     

       73
       73
       +
       cl-syslog

     

       84
       74
        
       cl-test-more

     

       85
       75
        
       cl-typesetting

     

       86
       86
       -
       clump

     

       87
       76
        
       cl-unicode

     

       88
       77
        
       cl-unification

     

       89
       78
        
       cl-utilities

     

       90
       79
        
       cl-vectors

     

       91
       80
        
       cl-webkit2

     

       92
       81
        
       cl-who

     

       82
       82
       +
       clack

     

       83
       83
       +
       clack-v1-compat

     

       93
       84
        
       clfswm

     

       85
       85
       +
       closer-mop

     

       86
       86
       +
       closure-common

     

       87
       87
       +
       closure-html

     

       88
       88
       +
       clsql

     

       89
       89
       +
       clsql-postgresql

     

       90
       90
       +
       clsql-postgresql-socket

     

       91
       91
       +
       clsql-sqlite3

     

       92
       92
       +
       clss

     

       93
       93
       +
       clump

     

       94
       94
        
       clx

     

       95
       95
        
       collectors

     

       96
       96
        
       command-line-arguments

     
···

       209
       209
        
       utilities.print-items

     

       210
       210
        
       utilities.print-tree

     

       211
       211
        
       uuid

     

       212
       212
       +
       varjo

     

       212
       213
        
       woo

     

       213
       214
        
       wookie

     

       214
       215
        
       xembed

+315 -235

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

···

       6
       6
        
         buildLispPackage = callPackage ./define-package.nix;

     

       7
       7
        
         qlOverrides = callPackage ./quicklisp-to-nix-overrides.nix {};

     

       8
       8
        
       

     

       9
       9
       +
         "lisp-unit" = buildLispPackage

     

       10
       10
       +
           ((f: x: (x // (f x)))

     

       11
       11
       +
              (qlOverrides."lisp-unit" or (x: {}))

     

       12
       12
       +
              (import ./quicklisp-to-nix-output/lisp-unit.nix {

     

       13
       13
       +
                inherit fetchurl;

     

       14
       14
       +
              }));

     

       15
       15
       +
       

     

       16
       16
       +
       

     

       9
       17
        
         "pythonic-string-reader" = buildLispPackage

     

       10
       18
        
           ((f: x: (x // (f x)))

     

       11
       19
        
              (qlOverrides."pythonic-string-reader" or (x: {}))

     
···

       74
       82
        
              }));

     

       75
       83
        
       

     

       76
       84
        
       

     

       85
       85
       +
         "vas-string-metrics" = buildLispPackage

     

       86
       86
       +
           ((f: x: (x // (f x)))

     

       87
       87
       +
              (qlOverrides."vas-string-metrics" or (x: {}))

     

       88
       88
       +
              (import ./quicklisp-to-nix-output/vas-string-metrics.nix {

     

       89
       89
       +
                inherit fetchurl;

     

       90
       90
       +
              }));

     

       91
       91
       +
       

     

       92
       92
       +
       

     

       93
       93
       +
         "parse-float" = buildLispPackage

     

       94
       94
       +
           ((f: x: (x // (f x)))

     

       95
       95
       +
              (qlOverrides."parse-float" or (x: {}))

     

       96
       96
       +
              (import ./quicklisp-to-nix-output/parse-float.nix {

     

       97
       97
       +
                inherit fetchurl;

     

       98
       98
       +
                  "alexandria" = quicklisp-to-nix-packages."alexandria";

     

       99
       99
       +
                  "lisp-unit" = quicklisp-to-nix-packages."lisp-unit";

     

       100
       100
       +
              }));

     

       101
       101
       +
       

     

       102
       102
       +
       

     

       103
       103
       +
         "glsl-symbols" = buildLispPackage

     

       104
       104
       +
           ((f: x: (x // (f x)))

     

       105
       105
       +
              (qlOverrides."glsl-symbols" or (x: {}))

     

       106
       106
       +
              (import ./quicklisp-to-nix-output/glsl-symbols.nix {

     

       107
       107
       +
                inherit fetchurl;

     

       108
       108
       +
              }));

     

       109
       109
       +
       

     

       110
       110
       +
       

     

       111
       111
       +
         "glsl-spec" = buildLispPackage

     

       112
       112
       +
           ((f: x: (x // (f x)))

     

       113
       113
       +
              (qlOverrides."glsl-spec" or (x: {}))

     

       114
       114
       +
              (import ./quicklisp-to-nix-output/glsl-spec.nix {

     

       115
       115
       +
                inherit fetchurl;

     

       116
       116
       +
              }));

     

       117
       117
       +
       

     

       118
       118
       +
       

     

       119
       119
       +
         "glsl-docs" = buildLispPackage

     

       120
       120
       +
           ((f: x: (x // (f x)))

     

       121
       121
       +
              (qlOverrides."glsl-docs" or (x: {}))

     

       122
       122
       +
              (import ./quicklisp-to-nix-output/glsl-docs.nix {

     

       123
       123
       +
                inherit fetchurl;

     

       124
       124
       +
                  "glsl-symbols" = quicklisp-to-nix-packages."glsl-symbols";

     

       125
       125
       +
              }));

     

       126
       126
       +
       

     

       127
       127
       +
       

     

       128
       128
       +
         "fn" = buildLispPackage

     

       129
       129
       +
           ((f: x: (x // (f x)))

     

       130
       130
       +
              (qlOverrides."fn" or (x: {}))

     

       131
       131
       +
              (import ./quicklisp-to-nix-output/fn.nix {

     

       132
       132
       +
                inherit fetchurl;

     

       133
       133
       +
                  "named-readtables" = quicklisp-to-nix-packages."named-readtables";

     

       134
       134
       +
              }));

     

       135
       135
       +
       

     

       136
       136
       +
       

     

       77
       137
        
         "mgl-pax" = buildLispPackage

     

       78
       138
        
           ((f: x: (x // (f x)))

     

       79
       139
        
              (qlOverrides."mgl-pax" or (x: {}))

     
···

       709
       769
        
              }));

     

       710
       770
        
       

     

       711
       771
        
       

     

       712
       712
       -
         "cl-aa" = buildLispPackage

     

       713
       713
       -
           ((f: x: (x // (f x)))

     

       714
       714
       -
              (qlOverrides."cl-aa" or (x: {}))

     

       715
       715
       -
              (import ./quicklisp-to-nix-output/cl-aa.nix {

     

       716
       716
       -
                inherit fetchurl;

     

       717
       717
       -
              }));

     

       718
       718
       -
       

     

       719
       719
       -
       

     

       720
       772
        
         "clump-binary-tree" = buildLispPackage

     

       721
       773
        
           ((f: x: (x // (f x)))

     

       722
       774
        
              (qlOverrides."clump-binary-tree" or (x: {}))

     
···

       732
       784
        
              (import ./quicklisp-to-nix-output/clump-2-3-tree.nix {

     

       733
       785
        
                inherit fetchurl;

     

       734
       786
        
                  "acclimation" = quicklisp-to-nix-packages."acclimation";

     

       735
       735
       -
              }));

     

       736
       736
       -
       

     

       737
       737
       -
       

     

       738
       738
       -
         "cl-anonfun" = buildLispPackage

     

       739
       739
       -
           ((f: x: (x // (f x)))

     

       740
       740
       -
              (qlOverrides."cl-anonfun" or (x: {}))

     

       741
       741
       -
              (import ./quicklisp-to-nix-output/cl-anonfun.nix {

     

       742
       742
       -
                inherit fetchurl;

     

       743
       787
        
              }));

     

       744
       788
        
       

     

       745
       789
        
       

     
···

       753
       797
        
              }));

     

       754
       798
        
       

     

       755
       799
        
       

     

       800
       800
       +
         "cl-aa" = buildLispPackage

     

       801
       801
       +
           ((f: x: (x // (f x)))

     

       802
       802
       +
              (qlOverrides."cl-aa" or (x: {}))

     

       803
       803
       +
              (import ./quicklisp-to-nix-output/cl-aa.nix {

     

       804
       804
       +
                inherit fetchurl;

     

       805
       805
       +
              }));

     

       806
       806
       +
       

     

       807
       807
       +
       

     

       756
       808
        
         "global-vars" = buildLispPackage

     

       757
       809
        
           ((f: x: (x // (f x)))

     

       758
       810
        
              (qlOverrides."global-vars" or (x: {}))

     

       759
       811
        
              (import ./quicklisp-to-nix-output/global-vars.nix {

     

       812
       812
       +
                inherit fetchurl;

     

       813
       813
       +
              }));

     

       814
       814
       +
       

     

       815
       815
       +
       

     

       816
       816
       +
         "cl-anonfun" = buildLispPackage

     

       817
       817
       +
           ((f: x: (x // (f x)))

     

       818
       818
       +
              (qlOverrides."cl-anonfun" or (x: {}))

     

       819
       819
       +
              (import ./quicklisp-to-nix-output/cl-anonfun.nix {

     

       760
       820
        
                inherit fetchurl;

     

       761
       821
        
              }));

     

       762
       822
        
       

     
···

       1473
       1533
        
                  "trivial-utf-8" = quicklisp-to-nix-packages."trivial-utf-8";

     

       1474
       1534
        
                  "vom" = quicklisp-to-nix-packages."vom";

     

       1475
       1535
        
                  "xsubseq" = quicklisp-to-nix-packages."xsubseq";

     

       1536
       1536
       +
              }));

     

       1537
       1537
       +
       

     

       1538
       1538
       +
       

     

       1539
       1539
       +
         "varjo" = buildLispPackage

     

       1540
       1540
       +
           ((f: x: (x // (f x)))

     

       1541
       1541
       +
              (qlOverrides."varjo" or (x: {}))

     

       1542
       1542
       +
              (import ./quicklisp-to-nix-output/varjo.nix {

     

       1543
       1543
       +
                inherit fetchurl;

     

       1544
       1544
       +
                  "alexandria" = quicklisp-to-nix-packages."alexandria";

     

       1545
       1545
       +
                  "cl-ppcre" = quicklisp-to-nix-packages."cl-ppcre";

     

       1546
       1546
       +
                  "documentation-utils" = quicklisp-to-nix-packages."documentation-utils";

     

       1547
       1547
       +
                  "fn" = quicklisp-to-nix-packages."fn";

     

       1548
       1548
       +
                  "glsl-docs" = quicklisp-to-nix-packages."glsl-docs";

     

       1549
       1549
       +
                  "glsl-spec" = quicklisp-to-nix-packages."glsl-spec";

     

       1550
       1550
       +
                  "glsl-symbols" = quicklisp-to-nix-packages."glsl-symbols";

     

       1551
       1551
       +
                  "named-readtables" = quicklisp-to-nix-packages."named-readtables";

     

       1552
       1552
       +
                  "parse-float" = quicklisp-to-nix-packages."parse-float";

     

       1553
       1553
       +
                  "trivial-indent" = quicklisp-to-nix-packages."trivial-indent";

     

       1554
       1554
       +
                  "uiop" = quicklisp-to-nix-packages."uiop";

     

       1555
       1555
       +
                  "vas-string-metrics" = quicklisp-to-nix-packages."vas-string-metrics";

     

       1476
       1556
        
              }));

     

       1477
       1557
        
       

     

       1478
       1558
        
       

     
···

       3060
       3140
        
              }));

     

       3061
       3141
        
       

     

       3062
       3142
        
       

     

       3143
       3143
       +
         "clump" = buildLispPackage

     

       3144
       3144
       +
           ((f: x: (x // (f x)))

     

       3145
       3145
       +
              (qlOverrides."clump" or (x: {}))

     

       3146
       3146
       +
              (import ./quicklisp-to-nix-output/clump.nix {

     

       3147
       3147
       +
                inherit fetchurl;

     

       3148
       3148
       +
                  "acclimation" = quicklisp-to-nix-packages."acclimation";

     

       3149
       3149
       +
                  "clump-2-3-tree" = quicklisp-to-nix-packages."clump-2-3-tree";

     

       3150
       3150
       +
                  "clump-binary-tree" = quicklisp-to-nix-packages."clump-binary-tree";

     

       3151
       3151
       +
              }));

     

       3152
       3152
       +
       

     

       3153
       3153
       +
       

     

       3154
       3154
       +
         "clss" = buildLispPackage

     

       3155
       3155
       +
           ((f: x: (x // (f x)))

     

       3156
       3156
       +
              (qlOverrides."clss" or (x: {}))

     

       3157
       3157
       +
              (import ./quicklisp-to-nix-output/clss.nix {

     

       3158
       3158
       +
                inherit fetchurl;

     

       3159
       3159
       +
                  "array-utils" = quicklisp-to-nix-packages."array-utils";

     

       3160
       3160
       +
                  "documentation-utils" = quicklisp-to-nix-packages."documentation-utils";

     

       3161
       3161
       +
                  "plump" = quicklisp-to-nix-packages."plump";

     

       3162
       3162
       +
                  "trivial-indent" = quicklisp-to-nix-packages."trivial-indent";

     

       3163
       3163
       +
              }));

     

       3164
       3164
       +
       

     

       3165
       3165
       +
       

     

       3166
       3166
       +
         "clsql-sqlite3" = buildLispPackage

     

       3167
       3167
       +
           ((f: x: (x // (f x)))

     

       3168
       3168
       +
              (qlOverrides."clsql-sqlite3" or (x: {}))

     

       3169
       3169
       +
              (import ./quicklisp-to-nix-output/clsql-sqlite3.nix {

     

       3170
       3170
       +
                inherit fetchurl;

     

       3171
       3171
       +
                  "clsql" = quicklisp-to-nix-packages."clsql";

     

       3172
       3172
       +
                  "clsql-uffi" = quicklisp-to-nix-packages."clsql-uffi";

     

       3173
       3173
       +
                  "uffi" = quicklisp-to-nix-packages."uffi";

     

       3174
       3174
       +
              }));

     

       3175
       3175
       +
       

     

       3176
       3176
       +
       

     

       3177
       3177
       +
         "clsql-postgresql-socket" = buildLispPackage

     

       3178
       3178
       +
           ((f: x: (x // (f x)))

     

       3179
       3179
       +
              (qlOverrides."clsql-postgresql-socket" or (x: {}))

     

       3180
       3180
       +
              (import ./quicklisp-to-nix-output/clsql-postgresql-socket.nix {

     

       3181
       3181
       +
                inherit fetchurl;

     

       3182
       3182
       +
                  "clsql" = quicklisp-to-nix-packages."clsql";

     

       3183
       3183
       +
                  "md5" = quicklisp-to-nix-packages."md5";

     

       3184
       3184
       +
                  "uffi" = quicklisp-to-nix-packages."uffi";

     

       3185
       3185
       +
              }));

     

       3186
       3186
       +
       

     

       3187
       3187
       +
       

     

       3188
       3188
       +
         "clsql-postgresql" = buildLispPackage

     

       3189
       3189
       +
           ((f: x: (x // (f x)))

     

       3190
       3190
       +
              (qlOverrides."clsql-postgresql" or (x: {}))

     

       3191
       3191
       +
              (import ./quicklisp-to-nix-output/clsql-postgresql.nix {

     

       3192
       3192
       +
                inherit fetchurl;

     

       3193
       3193
       +
                  "clsql" = quicklisp-to-nix-packages."clsql";

     

       3194
       3194
       +
                  "clsql-uffi" = quicklisp-to-nix-packages."clsql-uffi";

     

       3195
       3195
       +
                  "uffi" = quicklisp-to-nix-packages."uffi";

     

       3196
       3196
       +
              }));

     

       3197
       3197
       +
       

     

       3198
       3198
       +
       

     

       3199
       3199
       +
         "clsql" = buildLispPackage

     

       3200
       3200
       +
           ((f: x: (x // (f x)))

     

       3201
       3201
       +
              (qlOverrides."clsql" or (x: {}))

     

       3202
       3202
       +
              (import ./quicklisp-to-nix-output/clsql.nix {

     

       3203
       3203
       +
                inherit fetchurl;

     

       3204
       3204
       +
                  "uffi" = quicklisp-to-nix-packages."uffi";

     

       3205
       3205
       +
              }));

     

       3206
       3206
       +
       

     

       3207
       3207
       +
       

     

       3208
       3208
       +
         "closure-html" = buildLispPackage

     

       3209
       3209
       +
           ((f: x: (x // (f x)))

     

       3210
       3210
       +
              (qlOverrides."closure-html" or (x: {}))

     

       3211
       3211
       +
              (import ./quicklisp-to-nix-output/closure-html.nix {

     

       3212
       3212
       +
                inherit fetchurl;

     

       3213
       3213
       +
                  "alexandria" = quicklisp-to-nix-packages."alexandria";

     

       3214
       3214
       +
                  "babel" = quicklisp-to-nix-packages."babel";

     

       3215
       3215
       +
                  "closure-common" = quicklisp-to-nix-packages."closure-common";

     

       3216
       3216
       +
                  "flexi-streams" = quicklisp-to-nix-packages."flexi-streams";

     

       3217
       3217
       +
                  "trivial-features" = quicklisp-to-nix-packages."trivial-features";

     

       3218
       3218
       +
                  "trivial-gray-streams" = quicklisp-to-nix-packages."trivial-gray-streams";

     

       3219
       3219
       +
              }));

     

       3220
       3220
       +
       

     

       3221
       3221
       +
       

     

       3222
       3222
       +
         "closure-common" = buildLispPackage

     

       3223
       3223
       +
           ((f: x: (x // (f x)))

     

       3224
       3224
       +
              (qlOverrides."closure-common" or (x: {}))

     

       3225
       3225
       +
              (import ./quicklisp-to-nix-output/closure-common.nix {

     

       3226
       3226
       +
                inherit fetchurl;

     

       3227
       3227
       +
                  "alexandria" = quicklisp-to-nix-packages."alexandria";

     

       3228
       3228
       +
                  "babel" = quicklisp-to-nix-packages."babel";

     

       3229
       3229
       +
                  "trivial-features" = quicklisp-to-nix-packages."trivial-features";

     

       3230
       3230
       +
                  "trivial-gray-streams" = quicklisp-to-nix-packages."trivial-gray-streams";

     

       3231
       3231
       +
              }));

     

       3232
       3232
       +
       

     

       3233
       3233
       +
       

     

       3234
       3234
       +
         "closer-mop" = buildLispPackage

     

       3235
       3235
       +
           ((f: x: (x // (f x)))

     

       3236
       3236
       +
              (qlOverrides."closer-mop" or (x: {}))

     

       3237
       3237
       +
              (import ./quicklisp-to-nix-output/closer-mop.nix {

     

       3238
       3238
       +
                inherit fetchurl;

     

       3239
       3239
       +
              }));

     

       3240
       3240
       +
       

     

       3241
       3241
       +
       

     

       3063
       3242
        
         "clfswm" = buildLispPackage

     

       3064
       3243
        
           ((f: x: (x // (f x)))

     

       3065
       3244
        
              (qlOverrides."clfswm" or (x: {}))

     
···

       3069
       3248
        
              }));

     

       3070
       3249
        
       

     

       3071
       3250
        
       

     

       3251
       3251
       +
         "clack-v1-compat" = buildLispPackage

     

       3252
       3252
       +
           ((f: x: (x // (f x)))

     

       3253
       3253
       +
              (qlOverrides."clack-v1-compat" or (x: {}))

     

       3254
       3254
       +
              (import ./quicklisp-to-nix-output/clack-v1-compat.nix {

     

       3255
       3255
       +
                inherit fetchurl;

     

       3256
       3256
       +
                  "alexandria" = quicklisp-to-nix-packages."alexandria";

     

       3257
       3257
       +
                  "babel" = quicklisp-to-nix-packages."babel";

     

       3258
       3258
       +
                  "bordeaux-threads" = quicklisp-to-nix-packages."bordeaux-threads";

     

       3259
       3259
       +
                  "cffi" = quicklisp-to-nix-packages."cffi";

     

       3260
       3260
       +
                  "cffi-grovel" = quicklisp-to-nix-packages."cffi-grovel";

     

       3261
       3261
       +
                  "cffi-toolchain" = quicklisp-to-nix-packages."cffi-toolchain";

     

       3262
       3262
       +
                  "chipz" = quicklisp-to-nix-packages."chipz";

     

       3263
       3263
       +
                  "chunga" = quicklisp-to-nix-packages."chunga";

     

       3264
       3264
       +
                  "circular-streams" = quicklisp-to-nix-packages."circular-streams";

     

       3265
       3265
       +
                  "cl_plus_ssl" = quicklisp-to-nix-packages."cl_plus_ssl";

     

       3266
       3266
       +
                  "cl-annot" = quicklisp-to-nix-packages."cl-annot";

     

       3267
       3267
       +
                  "cl-base64" = quicklisp-to-nix-packages."cl-base64";

     

       3268
       3268
       +
                  "cl-cookie" = quicklisp-to-nix-packages."cl-cookie";

     

       3269
       3269
       +
                  "cl-fad" = quicklisp-to-nix-packages."cl-fad";

     

       3270
       3270
       +
                  "cl-ppcre" = quicklisp-to-nix-packages."cl-ppcre";

     

       3271
       3271
       +
                  "cl-reexport" = quicklisp-to-nix-packages."cl-reexport";

     

       3272
       3272
       +
                  "cl-syntax" = quicklisp-to-nix-packages."cl-syntax";

     

       3273
       3273
       +
                  "cl-syntax-annot" = quicklisp-to-nix-packages."cl-syntax-annot";

     

       3274
       3274
       +
                  "cl-utilities" = quicklisp-to-nix-packages."cl-utilities";

     

       3275
       3275
       +
                  "clack" = quicklisp-to-nix-packages."clack";

     

       3276
       3276
       +
                  "clack-handler-hunchentoot" = quicklisp-to-nix-packages."clack-handler-hunchentoot";

     

       3277
       3277
       +
                  "clack-socket" = quicklisp-to-nix-packages."clack-socket";

     

       3278
       3278
       +
                  "clack-test" = quicklisp-to-nix-packages."clack-test";

     

       3279
       3279
       +
                  "dexador" = quicklisp-to-nix-packages."dexador";

     

       3280
       3280
       +
                  "dissect" = quicklisp-to-nix-packages."dissect";

     

       3281
       3281
       +
                  "fast-http" = quicklisp-to-nix-packages."fast-http";

     

       3282
       3282
       +
                  "fast-io" = quicklisp-to-nix-packages."fast-io";

     

       3283
       3283
       +
                  "flexi-streams" = quicklisp-to-nix-packages."flexi-streams";

     

       3284
       3284
       +
                  "http-body" = quicklisp-to-nix-packages."http-body";

     

       3285
       3285
       +
                  "hunchentoot" = quicklisp-to-nix-packages."hunchentoot";

     

       3286
       3286
       +
                  "ironclad" = quicklisp-to-nix-packages."ironclad";

     

       3287
       3287
       +
                  "jonathan" = quicklisp-to-nix-packages."jonathan";

     

       3288
       3288
       +
                  "lack" = quicklisp-to-nix-packages."lack";

     

       3289
       3289
       +
                  "lack-component" = quicklisp-to-nix-packages."lack-component";

     

       3290
       3290
       +
                  "lack-middleware-backtrace" = quicklisp-to-nix-packages."lack-middleware-backtrace";

     

       3291
       3291
       +
                  "lack-util" = quicklisp-to-nix-packages."lack-util";

     

       3292
       3292
       +
                  "local-time" = quicklisp-to-nix-packages."local-time";

     

       3293
       3293
       +
                  "marshal" = quicklisp-to-nix-packages."marshal";

     

       3294
       3294
       +
                  "md5" = quicklisp-to-nix-packages."md5";

     

       3295
       3295
       +
                  "named-readtables" = quicklisp-to-nix-packages."named-readtables";

     

       3296
       3296
       +
                  "proc-parse" = quicklisp-to-nix-packages."proc-parse";

     

       3297
       3297
       +
                  "quri" = quicklisp-to-nix-packages."quri";

     

       3298
       3298
       +
                  "rfc2388" = quicklisp-to-nix-packages."rfc2388";

     

       3299
       3299
       +
                  "rove" = quicklisp-to-nix-packages."rove";

     

       3300
       3300
       +
                  "smart-buffer" = quicklisp-to-nix-packages."smart-buffer";

     

       3301
       3301
       +
                  "split-sequence" = quicklisp-to-nix-packages."split-sequence";

     

       3302
       3302
       +
                  "static-vectors" = quicklisp-to-nix-packages."static-vectors";

     

       3303
       3303
       +
                  "trivial-backtrace" = quicklisp-to-nix-packages."trivial-backtrace";

     

       3304
       3304
       +
                  "trivial-features" = quicklisp-to-nix-packages."trivial-features";

     

       3305
       3305
       +
                  "trivial-garbage" = quicklisp-to-nix-packages."trivial-garbage";

     

       3306
       3306
       +
                  "trivial-gray-streams" = quicklisp-to-nix-packages."trivial-gray-streams";

     

       3307
       3307
       +
                  "trivial-mimes" = quicklisp-to-nix-packages."trivial-mimes";

     

       3308
       3308
       +
                  "trivial-types" = quicklisp-to-nix-packages."trivial-types";

     

       3309
       3309
       +
                  "uiop" = quicklisp-to-nix-packages."uiop";

     

       3310
       3310
       +
                  "usocket" = quicklisp-to-nix-packages."usocket";

     

       3311
       3311
       +
                  "xsubseq" = quicklisp-to-nix-packages."xsubseq";

     

       3312
       3312
       +
              }));

     

       3313
       3313
       +
       

     

       3314
       3314
       +
       

     

       3315
       3315
       +
         "clack" = buildLispPackage

     

       3316
       3316
       +
           ((f: x: (x // (f x)))

     

       3317
       3317
       +
              (qlOverrides."clack" or (x: {}))

     

       3318
       3318
       +
              (import ./quicklisp-to-nix-output/clack.nix {

     

       3319
       3319
       +
                inherit fetchurl;

     

       3320
       3320
       +
                  "alexandria" = quicklisp-to-nix-packages."alexandria";

     

       3321
       3321
       +
                  "bordeaux-threads" = quicklisp-to-nix-packages."bordeaux-threads";

     

       3322
       3322
       +
                  "ironclad" = quicklisp-to-nix-packages."ironclad";

     

       3323
       3323
       +
                  "lack" = quicklisp-to-nix-packages."lack";

     

       3324
       3324
       +
                  "lack-component" = quicklisp-to-nix-packages."lack-component";

     

       3325
       3325
       +
                  "lack-middleware-backtrace" = quicklisp-to-nix-packages."lack-middleware-backtrace";

     

       3326
       3326
       +
                  "lack-util" = quicklisp-to-nix-packages."lack-util";

     

       3327
       3327
       +
                  "split-sequence" = quicklisp-to-nix-packages."split-sequence";

     

       3328
       3328
       +
                  "uiop" = quicklisp-to-nix-packages."uiop";

     

       3329
       3329
       +
                  "usocket" = quicklisp-to-nix-packages."usocket";

     

       3330
       3330
       +
              }));

     

       3331
       3331
       +
       

     

       3332
       3332
       +
       

     

       3072
       3333
        
         "cl-who" = buildLispPackage

     

       3073
       3334
        
           ((f: x: (x // (f x)))

     

       3074
       3335
        
              (qlOverrides."cl-who" or (x: {}))

     
···

       3138
       3399
        
              }));

     

       3139
       3400
        
       

     

       3140
       3401
        
       

     

       3141
       3141
       -
         "clump" = buildLispPackage

     

       3142
       3142
       -
           ((f: x: (x // (f x)))

     

       3143
       3143
       -
              (qlOverrides."clump" or (x: {}))

     

       3144
       3144
       -
              (import ./quicklisp-to-nix-output/clump.nix {

     

       3145
       3145
       -
                inherit fetchurl;

     

       3146
       3146
       -
                  "acclimation" = quicklisp-to-nix-packages."acclimation";

     

       3147
       3147
       -
                  "clump-2-3-tree" = quicklisp-to-nix-packages."clump-2-3-tree";

     

       3148
       3148
       -
                  "clump-binary-tree" = quicklisp-to-nix-packages."clump-binary-tree";

     

       3149
       3149
       -
              }));

     

       3150
       3150
       -
       

     

       3151
       3151
       -
       

     

       3152
       3402
        
         "cl-typesetting" = buildLispPackage

     

       3153
       3403
        
           ((f: x: (x // (f x)))

     

       3154
       3404
        
              (qlOverrides."cl-typesetting" or (x: {}))

     
···

       3176
       3426
        
              }));

     

       3177
       3427
        
       

     

       3178
       3428
        
       

     

       3429
       3429
       +
         "cl-syslog" = buildLispPackage

     

       3430
       3430
       +
           ((f: x: (x // (f x)))

     

       3431
       3431
       +
              (qlOverrides."cl-syslog" or (x: {}))

     

       3432
       3432
       +
              (import ./quicklisp-to-nix-output/cl-syslog.nix {

     

       3433
       3433
       +
                inherit fetchurl;

     

       3434
       3434
       +
                  "alexandria" = quicklisp-to-nix-packages."alexandria";

     

       3435
       3435
       +
                  "babel" = quicklisp-to-nix-packages."babel";

     

       3436
       3436
       +
                  "cffi" = quicklisp-to-nix-packages."cffi";

     

       3437
       3437
       +
                  "global-vars" = quicklisp-to-nix-packages."global-vars";

     

       3438
       3438
       +
                  "local-time" = quicklisp-to-nix-packages."local-time";

     

       3439
       3439
       +
                  "split-sequence" = quicklisp-to-nix-packages."split-sequence";

     

       3440
       3440
       +
                  "trivial-features" = quicklisp-to-nix-packages."trivial-features";

     

       3441
       3441
       +
                  "usocket" = quicklisp-to-nix-packages."usocket";

     

       3442
       3442
       +
              }));

     

       3443
       3443
       +
       

     

       3444
       3444
       +
       

     

       3179
       3445
        
         "cl-syntax-markup" = buildLispPackage

     

       3180
       3446
        
           ((f: x: (x // (f x)))

     

       3181
       3447
        
              (qlOverrides."cl-syntax-markup" or (x: {}))

     
···

       3232
       3498
        
              }));

     

       3233
       3499
        
       

     

       3234
       3500
        
       

     

       3235
       3235
       -
         "cl_plus_ssl" = buildLispPackage

     

       3236
       3236
       -
           ((f: x: (x // (f x)))

     

       3237
       3237
       -
              (qlOverrides."cl_plus_ssl" or (x: {}))

     

       3238
       3238
       -
              (import ./quicklisp-to-nix-output/cl_plus_ssl.nix {

     

       3239
       3239
       -
                inherit fetchurl;

     

       3240
       3240
       -
                  "alexandria" = quicklisp-to-nix-packages."alexandria";

     

       3241
       3241
       -
                  "babel" = quicklisp-to-nix-packages."babel";

     

       3242
       3242
       -
                  "bordeaux-threads" = quicklisp-to-nix-packages."bordeaux-threads";

     

       3243
       3243
       -
                  "cffi" = quicklisp-to-nix-packages."cffi";

     

       3244
       3244
       -
                  "flexi-streams" = quicklisp-to-nix-packages."flexi-streams";

     

       3245
       3245
       -
                  "split-sequence" = quicklisp-to-nix-packages."split-sequence";

     

       3246
       3246
       -
                  "trivial-features" = quicklisp-to-nix-packages."trivial-features";

     

       3247
       3247
       -
                  "trivial-garbage" = quicklisp-to-nix-packages."trivial-garbage";

     

       3248
       3248
       -
                  "trivial-gray-streams" = quicklisp-to-nix-packages."trivial-gray-streams";

     

       3249
       3249
       -
                  "uiop" = quicklisp-to-nix-packages."uiop";

     

       3250
       3250
       -
                  "usocket" = quicklisp-to-nix-packages."usocket";

     

       3251
       3251
       -
              }));

     

       3252
       3252
       -
       

     

       3253
       3253
       -
       

     

       3254
       3254
       -
         "clss" = buildLispPackage

     

       3255
       3255
       -
           ((f: x: (x // (f x)))

     

       3256
       3256
       -
              (qlOverrides."clss" or (x: {}))

     

       3257
       3257
       -
              (import ./quicklisp-to-nix-output/clss.nix {

     

       3258
       3258
       -
                inherit fetchurl;

     

       3259
       3259
       -
                  "array-utils" = quicklisp-to-nix-packages."array-utils";

     

       3260
       3260
       -
                  "documentation-utils" = quicklisp-to-nix-packages."documentation-utils";

     

       3261
       3261
       -
                  "plump" = quicklisp-to-nix-packages."plump";

     

       3262
       3262
       -
                  "trivial-indent" = quicklisp-to-nix-packages."trivial-indent";

     

       3263
       3263
       -
              }));

     

       3264
       3264
       -
       

     

       3265
       3265
       -
       

     

       3266
       3266
       -
         "clsql-sqlite3" = buildLispPackage

     

       3501
       3501
       +
         "cl-speedy-queue" = buildLispPackage

     

       3267
       3502
        
           ((f: x: (x // (f x)))

     

       3268
       3268
       -
              (qlOverrides."clsql-sqlite3" or (x: {}))

     

       3269
       3269
       -
              (import ./quicklisp-to-nix-output/clsql-sqlite3.nix {

     

       3503
       3503
       +
              (qlOverrides."cl-speedy-queue" or (x: {}))

     

       3504
       3504
       +
              (import ./quicklisp-to-nix-output/cl-speedy-queue.nix {

     

       3270
       3505
        
                inherit fetchurl;

     

       3271
       3271
       -
                  "clsql" = quicklisp-to-nix-packages."clsql";

     

       3272
       3272
       -
                  "clsql-uffi" = quicklisp-to-nix-packages."clsql-uffi";

     

       3273
       3273
       -
                  "uffi" = quicklisp-to-nix-packages."uffi";

     

       3274
       3274
       -
              }));

     

       3275
       3275
       -
       

     

       3276
       3276
       -
       

     

       3277
       3277
       -
         "clsql-postgresql-socket" = buildLispPackage

     

       3278
       3278
       -
           ((f: x: (x // (f x)))

     

       3279
       3279
       -
              (qlOverrides."clsql-postgresql-socket" or (x: {}))

     

       3280
       3280
       -
              (import ./quicklisp-to-nix-output/clsql-postgresql-socket.nix {

     

       3281
       3281
       -
                inherit fetchurl;

     

       3282
       3282
       -
                  "clsql" = quicklisp-to-nix-packages."clsql";

     

       3283
       3283
       -
                  "md5" = quicklisp-to-nix-packages."md5";

     

       3284
       3284
       -
                  "uffi" = quicklisp-to-nix-packages."uffi";

     

       3285
       3285
       -
              }));

     

       3286
       3286
       -
       

     

       3287
       3287
       -
       

     

       3288
       3288
       -
         "clsql-postgresql" = buildLispPackage

     

       3289
       3289
       -
           ((f: x: (x // (f x)))

     

       3290
       3290
       -
              (qlOverrides."clsql-postgresql" or (x: {}))

     

       3291
       3291
       -
              (import ./quicklisp-to-nix-output/clsql-postgresql.nix {

     

       3292
       3292
       -
                inherit fetchurl;

     

       3293
       3293
       -
                  "clsql" = quicklisp-to-nix-packages."clsql";

     

       3294
       3294
       -
                  "clsql-uffi" = quicklisp-to-nix-packages."clsql-uffi";

     

       3295
       3295
       -
                  "uffi" = quicklisp-to-nix-packages."uffi";

     

       3296
       3296
       -
              }));

     

       3297
       3297
       -
       

     

       3298
       3298
       -
       

     

       3299
       3299
       -
         "clsql" = buildLispPackage

     

       3300
       3300
       -
           ((f: x: (x // (f x)))

     

       3301
       3301
       -
              (qlOverrides."clsql" or (x: {}))

     

       3302
       3302
       -
              (import ./quicklisp-to-nix-output/clsql.nix {

     

       3303
       3303
       -
                inherit fetchurl;

     

       3304
       3304
       -
                  "uffi" = quicklisp-to-nix-packages."uffi";

     

       3305
       3305
       -
              }));

     

       3306
       3306
       -
       

     

       3307
       3307
       -
       

     

       3308
       3308
       -
         "cl-syslog" = buildLispPackage

     

       3309
       3309
       -
           ((f: x: (x // (f x)))

     

       3310
       3310
       -
              (qlOverrides."cl-syslog" or (x: {}))

     

       3311
       3311
       -
              (import ./quicklisp-to-nix-output/cl-syslog.nix {

     

       3312
       3312
       -
                inherit fetchurl;

     

       3313
       3313
       -
                  "alexandria" = quicklisp-to-nix-packages."alexandria";

     

       3314
       3314
       -
                  "babel" = quicklisp-to-nix-packages."babel";

     

       3315
       3315
       -
                  "cffi" = quicklisp-to-nix-packages."cffi";

     

       3316
       3316
       -
                  "global-vars" = quicklisp-to-nix-packages."global-vars";

     

       3317
       3317
       -
                  "local-time" = quicklisp-to-nix-packages."local-time";

     

       3318
       3318
       -
                  "split-sequence" = quicklisp-to-nix-packages."split-sequence";

     

       3319
       3319
       -
                  "trivial-features" = quicklisp-to-nix-packages."trivial-features";

     

       3320
       3320
       -
                  "usocket" = quicklisp-to-nix-packages."usocket";

     

       3321
       3506
        
              }));

     

       3322
       3507
        
       

     

       3323
       3508
        
       

     
···

       3341
       3526
        
              }));

     

       3342
       3527
        
       

     

       3343
       3528
        
       

     

       3344
       3344
       -
         "cl-speedy-queue" = buildLispPackage

     

       3345
       3345
       -
           ((f: x: (x // (f x)))

     

       3346
       3346
       -
              (qlOverrides."cl-speedy-queue" or (x: {}))

     

       3347
       3347
       -
              (import ./quicklisp-to-nix-output/cl-speedy-queue.nix {

     

       3348
       3348
       -
                inherit fetchurl;

     

       3349
       3349
       -
              }));

     

       3350
       3350
       -
       

     

       3351
       3351
       -
       

     

       3352
       3529
        
         "cl-slice" = buildLispPackage

     

       3353
       3530
        
           ((f: x: (x // (f x)))

     

       3354
       3531
        
              (qlOverrides."cl-slice" or (x: {}))

     
···

       3460
       3637
        
              }));

     

       3461
       3638
        
       

     

       3462
       3639
        
       

     

       3463
       3463
       -
         "closure-html" = buildLispPackage

     

       3464
       3464
       -
           ((f: x: (x // (f x)))

     

       3465
       3465
       -
              (qlOverrides."closure-html" or (x: {}))

     

       3466
       3466
       -
              (import ./quicklisp-to-nix-output/closure-html.nix {

     

       3467
       3467
       -
                inherit fetchurl;

     

       3468
       3468
       -
                  "alexandria" = quicklisp-to-nix-packages."alexandria";

     

       3469
       3469
       -
                  "babel" = quicklisp-to-nix-packages."babel";

     

       3470
       3470
       -
                  "closure-common" = quicklisp-to-nix-packages."closure-common";

     

       3471
       3471
       -
                  "flexi-streams" = quicklisp-to-nix-packages."flexi-streams";

     

       3472
       3472
       -
                  "trivial-features" = quicklisp-to-nix-packages."trivial-features";

     

       3473
       3473
       -
                  "trivial-gray-streams" = quicklisp-to-nix-packages."trivial-gray-streams";

     

       3474
       3474
       -
              }));

     

       3475
       3475
       -
       

     

       3476
       3476
       -
       

     

       3477
       3477
       -
         "closure-common" = buildLispPackage

     

       3478
       3478
       -
           ((f: x: (x // (f x)))

     

       3479
       3479
       -
              (qlOverrides."closure-common" or (x: {}))

     

       3480
       3480
       -
              (import ./quicklisp-to-nix-output/closure-common.nix {

     

       3481
       3481
       -
                inherit fetchurl;

     

       3482
       3482
       -
                  "alexandria" = quicklisp-to-nix-packages."alexandria";

     

       3483
       3483
       -
                  "babel" = quicklisp-to-nix-packages."babel";

     

       3484
       3484
       -
                  "trivial-features" = quicklisp-to-nix-packages."trivial-features";

     

       3485
       3485
       -
                  "trivial-gray-streams" = quicklisp-to-nix-packages."trivial-gray-streams";

     

       3486
       3486
       -
              }));

     

       3487
       3487
       -
       

     

       3488
       3488
       -
       

     

       3489
       3489
       -
         "closer-mop" = buildLispPackage

     

       3490
       3490
       -
           ((f: x: (x // (f x)))

     

       3491
       3491
       -
              (qlOverrides."closer-mop" or (x: {}))

     

       3492
       3492
       -
              (import ./quicklisp-to-nix-output/closer-mop.nix {

     

       3493
       3493
       -
                inherit fetchurl;

     

       3494
       3494
       -
              }));

     

       3495
       3495
       -
       

     

       3496
       3496
       -
       

     

       3497
       3640
        
         "cl-mysql" = buildLispPackage

     

       3498
       3641
        
           ((f: x: (x // (f x)))

     

       3499
       3642
        
              (qlOverrides."cl-mysql" or (x: {}))

     
···

       3603
       3746
        
              }));

     

       3604
       3747
        
       

     

       3605
       3748
        
       

     

       3606
       3606
       -
         "cl-html-parse" = buildLispPackage

     

       3607
       3607
       -
           ((f: x: (x // (f x)))

     

       3608
       3608
       -
              (qlOverrides."cl-html-parse" or (x: {}))

     

       3609
       3609
       -
              (import ./quicklisp-to-nix-output/cl-html-parse.nix {

     

       3610
       3610
       -
                inherit fetchurl;

     

       3611
       3611
       -
              }));

     

       3612
       3612
       -
       

     

       3613
       3613
       -
       

     

       3614
       3749
        
         "cl-html5-parser" = buildLispPackage

     

       3615
       3750
        
           ((f: x: (x // (f x)))

     

       3616
       3751
        
              (qlOverrides."cl-html5-parser" or (x: {}))

     
···

       3620
       3755
        
                  "flexi-streams" = quicklisp-to-nix-packages."flexi-streams";

     

       3621
       3756
        
                  "string-case" = quicklisp-to-nix-packages."string-case";

     

       3622
       3757
        
                  "trivial-gray-streams" = quicklisp-to-nix-packages."trivial-gray-streams";

     

       3758
       3758
       +
              }));

     

       3759
       3759
       +
       

     

       3760
       3760
       +
       

     

       3761
       3761
       +
         "cl-html-parse" = buildLispPackage

     

       3762
       3762
       +
           ((f: x: (x // (f x)))

     

       3763
       3763
       +
              (qlOverrides."cl-html-parse" or (x: {}))

     

       3764
       3764
       +
              (import ./quicklisp-to-nix-output/cl-html-parse.nix {

     

       3765
       3765
       +
                inherit fetchurl;

     

       3623
       3766
        
              }));

     

       3624
       3767
        
       

     

       3625
       3768
        
       

     
···

       3744
       3887
        
              }));

     

       3745
       3888
        
       

     

       3746
       3889
        
       

     

       3890
       3890
       +
         "cl-custom-hash-table" = buildLispPackage

     

       3891
       3891
       +
           ((f: x: (x // (f x)))

     

       3892
       3892
       +
              (qlOverrides."cl-custom-hash-table" or (x: {}))

     

       3893
       3893
       +
              (import ./quicklisp-to-nix-output/cl-custom-hash-table.nix {

     

       3894
       3894
       +
                inherit fetchurl;

     

       3895
       3895
       +
              }));

     

       3896
       3896
       +
       

     

       3897
       3897
       +
       

     

       3747
       3898
        
         "cl-csv" = buildLispPackage

     

       3748
       3899
        
           ((f: x: (x // (f x)))

     

       3749
       3900
        
              (qlOverrides."cl-csv" or (x: {}))

     
···

       3943
       4094
        
              }));

     

       3944
       4095
        
       

     

       3945
       4096
        
       

     

       3946
       3946
       -
         "clack-v1-compat" = buildLispPackage

     

       4097
       4097
       +
         "cl_plus_ssl" = buildLispPackage

     

       3947
       4098
        
           ((f: x: (x // (f x)))

     

       3948
       3948
       -
              (qlOverrides."clack-v1-compat" or (x: {}))

     

       3949
       3949
       -
              (import ./quicklisp-to-nix-output/clack-v1-compat.nix {

     

       4099
       4099
       +
              (qlOverrides."cl_plus_ssl" or (x: {}))

     

       4100
       4100
       +
              (import ./quicklisp-to-nix-output/cl_plus_ssl.nix {

     

       3950
       4101
        
                inherit fetchurl;

     

       3951
       4102
        
                  "alexandria" = quicklisp-to-nix-packages."alexandria";

     

       3952
       4103
        
                  "babel" = quicklisp-to-nix-packages."babel";

     

       3953
       4104
        
                  "bordeaux-threads" = quicklisp-to-nix-packages."bordeaux-threads";

     

       3954
       4105
        
                  "cffi" = quicklisp-to-nix-packages."cffi";

     

       3955
       3955
       -
                  "cffi-grovel" = quicklisp-to-nix-packages."cffi-grovel";

     

       3956
       3956
       -
                  "cffi-toolchain" = quicklisp-to-nix-packages."cffi-toolchain";

     

       3957
       3957
       -
                  "chipz" = quicklisp-to-nix-packages."chipz";

     

       3958
       3958
       -
                  "chunga" = quicklisp-to-nix-packages."chunga";

     

       3959
       3959
       -
                  "circular-streams" = quicklisp-to-nix-packages."circular-streams";

     

       3960
       3960
       -
                  "cl_plus_ssl" = quicklisp-to-nix-packages."cl_plus_ssl";

     

       3961
       3961
       -
                  "cl-annot" = quicklisp-to-nix-packages."cl-annot";

     

       3962
       3962
       -
                  "cl-base64" = quicklisp-to-nix-packages."cl-base64";

     

       3963
       3963
       -
                  "cl-cookie" = quicklisp-to-nix-packages."cl-cookie";

     

       3964
       3964
       -
                  "cl-fad" = quicklisp-to-nix-packages."cl-fad";

     

       3965
       3965
       -
                  "cl-ppcre" = quicklisp-to-nix-packages."cl-ppcre";

     

       3966
       3966
       -
                  "cl-reexport" = quicklisp-to-nix-packages."cl-reexport";

     

       3967
       3967
       -
                  "cl-syntax" = quicklisp-to-nix-packages."cl-syntax";

     

       3968
       3968
       -
                  "cl-syntax-annot" = quicklisp-to-nix-packages."cl-syntax-annot";

     

       3969
       3969
       -
                  "cl-utilities" = quicklisp-to-nix-packages."cl-utilities";

     

       3970
       3970
       -
                  "clack" = quicklisp-to-nix-packages."clack";

     

       3971
       3971
       -
                  "clack-handler-hunchentoot" = quicklisp-to-nix-packages."clack-handler-hunchentoot";

     

       3972
       3972
       -
                  "clack-socket" = quicklisp-to-nix-packages."clack-socket";

     

       3973
       3973
       -
                  "clack-test" = quicklisp-to-nix-packages."clack-test";

     

       3974
       3974
       -
                  "dexador" = quicklisp-to-nix-packages."dexador";

     

       3975
       3975
       -
                  "dissect" = quicklisp-to-nix-packages."dissect";

     

       3976
       3976
       -
                  "fast-http" = quicklisp-to-nix-packages."fast-http";

     

       3977
       3977
       -
                  "fast-io" = quicklisp-to-nix-packages."fast-io";

     

       3978
       4106
        
                  "flexi-streams" = quicklisp-to-nix-packages."flexi-streams";

     

       3979
       3979
       -
                  "http-body" = quicklisp-to-nix-packages."http-body";

     

       3980
       3980
       -
                  "hunchentoot" = quicklisp-to-nix-packages."hunchentoot";

     

       3981
       3981
       -
                  "ironclad" = quicklisp-to-nix-packages."ironclad";

     

       3982
       3982
       -
                  "jonathan" = quicklisp-to-nix-packages."jonathan";

     

       3983
       3983
       -
                  "lack" = quicklisp-to-nix-packages."lack";

     

       3984
       3984
       -
                  "lack-component" = quicklisp-to-nix-packages."lack-component";

     

       3985
       3985
       -
                  "lack-middleware-backtrace" = quicklisp-to-nix-packages."lack-middleware-backtrace";

     

       3986
       3986
       -
                  "lack-util" = quicklisp-to-nix-packages."lack-util";

     

       3987
       3987
       -
                  "local-time" = quicklisp-to-nix-packages."local-time";

     

       3988
       3988
       -
                  "marshal" = quicklisp-to-nix-packages."marshal";

     

       3989
       3989
       -
                  "md5" = quicklisp-to-nix-packages."md5";

     

       3990
       3990
       -
                  "named-readtables" = quicklisp-to-nix-packages."named-readtables";

     

       3991
       3991
       -
                  "proc-parse" = quicklisp-to-nix-packages."proc-parse";

     

       3992
       3992
       -
                  "quri" = quicklisp-to-nix-packages."quri";

     

       3993
       3993
       -
                  "rfc2388" = quicklisp-to-nix-packages."rfc2388";

     

       3994
       3994
       -
                  "rove" = quicklisp-to-nix-packages."rove";

     

       3995
       3995
       -
                  "smart-buffer" = quicklisp-to-nix-packages."smart-buffer";

     

       3996
       4107
        
                  "split-sequence" = quicklisp-to-nix-packages."split-sequence";

     

       3997
       3997
       -
                  "static-vectors" = quicklisp-to-nix-packages."static-vectors";

     

       3998
       3998
       -
                  "trivial-backtrace" = quicklisp-to-nix-packages."trivial-backtrace";

     

       3999
       4108
        
                  "trivial-features" = quicklisp-to-nix-packages."trivial-features";

     

       4000
       4109
        
                  "trivial-garbage" = quicklisp-to-nix-packages."trivial-garbage";

     

       4001
       4110
        
                  "trivial-gray-streams" = quicklisp-to-nix-packages."trivial-gray-streams";

     

       4002
       4002
       -
                  "trivial-mimes" = quicklisp-to-nix-packages."trivial-mimes";

     

       4003
       4003
       -
                  "trivial-types" = quicklisp-to-nix-packages."trivial-types";

     

       4004
       4004
       -
                  "uiop" = quicklisp-to-nix-packages."uiop";

     

       4005
       4005
       -
                  "usocket" = quicklisp-to-nix-packages."usocket";

     

       4006
       4006
       -
                  "xsubseq" = quicklisp-to-nix-packages."xsubseq";

     

       4007
       4007
       -
              }));

     

       4008
       4008
       -
       

     

       4009
       4009
       -
       

     

       4010
       4010
       -
         "clack" = buildLispPackage

     

       4011
       4011
       -
           ((f: x: (x // (f x)))

     

       4012
       4012
       -
              (qlOverrides."clack" or (x: {}))

     

       4013
       4013
       -
              (import ./quicklisp-to-nix-output/clack.nix {

     

       4014
       4014
       -
                inherit fetchurl;

     

       4015
       4015
       -
                  "alexandria" = quicklisp-to-nix-packages."alexandria";

     

       4016
       4016
       -
                  "bordeaux-threads" = quicklisp-to-nix-packages."bordeaux-threads";

     

       4017
       4017
       -
                  "ironclad" = quicklisp-to-nix-packages."ironclad";

     

       4018
       4018
       -
                  "lack" = quicklisp-to-nix-packages."lack";

     

       4019
       4019
       -
                  "lack-component" = quicklisp-to-nix-packages."lack-component";

     

       4020
       4020
       -
                  "lack-middleware-backtrace" = quicklisp-to-nix-packages."lack-middleware-backtrace";

     

       4021
       4021
       -
                  "lack-util" = quicklisp-to-nix-packages."lack-util";

     

       4022
       4022
       -
                  "split-sequence" = quicklisp-to-nix-packages."split-sequence";

     

       4023
       4111
        
                  "uiop" = quicklisp-to-nix-packages."uiop";

     

       4024
       4112
        
                  "usocket" = quicklisp-to-nix-packages."usocket";

     

       4025
       4113
        
              }));

     
···

       4106
       4194
        
                  "cl-ppcre" = quicklisp-to-nix-packages."cl-ppcre";

     

       4107
       4195
        
                  "trivial-features" = quicklisp-to-nix-packages."trivial-features";

     

       4108
       4196
        
                  "uiop" = quicklisp-to-nix-packages."uiop";

     

       4109
       4109
       -
              }));

     

       4110
       4110
       -
       

     

       4111
       4111
       -
       

     

       4112
       4112
       -
         "cl-custom-hash-table" = buildLispPackage

     

       4113
       4113
       -
           ((f: x: (x // (f x)))

     

       4114
       4114
       -
              (qlOverrides."cl-custom-hash-table" or (x: {}))

     

       4115
       4115
       -
              (import ./quicklisp-to-nix-output/cl-custom-hash-table.nix {

     

       4116
       4116
       -
                inherit fetchurl;

     

       4117
       4197
        
              }));

     

       4118
       4198
        
       

     

       4119
       4199