Deployment error: cannot coerce a set to a string, at: ExecStart = "${laurus-nobilis}/.stack-work/install/x86_64-linux-nix/lts-12.26/8.4.4/bin/laurus-nobilis";

1error_message.txt

$ nixops deploy -d laurus-nobilis-gce
trace: `lib.nixpkgsVersion` is deprecated, use `lib.version` instead!
bootstrap> creating GCE image 'n-a6cb126b7cc011e99d230a0027000000-bootstrap'...
laurus...> creating GCE disk of 20 GiB from image 'n-a6cb126b7cc011e99d230a0027000000-bootstrap'...
laurus...> creating GCE machine 'n-a6cb126b7cc011e99d230a0027000000-laurus'...
laurus...> got public IP: 35.240.125.176
laurus...> attaching GCE disk 'n-a6cb126b7cc011e99d230a0027000000-laurus-root'...
ssh: connect to host 35.240.125.176 port 22: Connection refused
laurus...> could not connect to ‘root@35.240.125.176’, retrying in 1 seconds...
laurus...> setting state version to 18.09
laurus...> waiting for SSH...
building all machine configurations...
error: cannot coerce a set to a string, at /home/hhefesto/src/laurus-nobilis/laurus-nobilis-configuration.nix:20:28
(use '--show-trace' to show detailed location information)
Traceback (most recent call last):
  File "/nix/store/rim62cxjv285p3j2wxvf42clbrjprila-nixops-1.6.1/bin/..nixops-wrapped-wrapped", line 990, in <module>
    args.op()
  File "/nix/store/rim62cxjv285p3j2wxvf42clbrjprila-nixops-1.6.1/bin/..nixops-wrapped-wrapped", line 411, in op_deploy
    max_concurrent_activate=args.max_concurrent_activate)
  File "/nix/store/rim62cxjv285p3j2wxvf42clbrjprila-nixops-1.6.1/lib/python2.7/site-packages/nixops/deployment.py", line 1056, in deploy
    self.run_with_notify('deploy', lambda: self._deploy(**kwargs))
  File "/nix/store/rim62cxjv285p3j2wxvf42clbrjprila-nixops-1.6.1/lib/python2.7/site-packages/nixops/deployment.py", line 1045, in run_with_notify
    f()
  File "/nix/store/rim62cxjv285p3j2wxvf42clbrjprila-nixops-1.6.1/lib/python2.7/site-packages/nixops/deployment.py", line 1056, in <lambda>
    self.run_with_notify('deploy', lambda: self._deploy(**kwargs))
  File "/nix/store/rim62cxjv285p3j2wxvf42clbrjprila-nixops-1.6.1/lib/python2.7/site-packages/nixops/deployment.py", line 996, in _deploy
    self.configs_path = self.build_configs(dry_run=dry_run, repair=repair, include=include, exclude=exclude)
  File "/nix/store/rim62cxjv285p3j2wxvf42clbrjprila-nixops-1.6.1/lib/python2.7/site-packages/nixops/deployment.py", line 664, in build_configs
    raise Exception("unable to build all machine configurations")
Exception: unable to build all machine configurations

2laurus-nobilis-configuration.nix

# /laurus-nobilis/laurus-nobilis-configuration.nix
{
  network.description = "laurus-nobilis";

  laurus =
    { config, pkgs, ... }: let
      laurus-nobilis = import ./default.nix { inherit pkgs; };
      # laurus-nobilis = import ./stack2nix.nix { inherit pkgs; }; # Maybe stack2nix.nix directly of default.nix?
    in
    { networking.hostName = "laurus-nobilis";

      networking.firewall.allowedTCPPorts = [ 22 80 3000 5432 ];
      environment.systemPackages = [ laurus-nobilis ];

      systemd.services.laurus-nobilis =
        { description = "laurus-nobilis";
          wantedBy = [ "multi-user.target" ];
          after = [ "network.target" ];
          serviceConfig =
            { ExecStart = "${laurus-nobilis}/.stack-work/install/x86_64-linux-nix/lts-12.26/8.4.4/bin/laurus-nobilis";
            };
        };
      services.postgresql = {
        enable = true;
        package = pkgs.postgresql_11;
        enableTCPIP = true;
        authentication = pkgs.lib.mkOverride 10 ''
          local all all trust
          host all all ::1/128 trust
        '';
        initialScript = pkgs.writeText "backend-initScript" ''
          CREATE ROLE analyzer WITH LOGIN PASSWORD 'anapass' CREATEDB;
          CREATE DATABASE aanalyzer_yesod;
          GRANT ALL PRIVILEGES ON DATABASE analyzer TO aanalyzer_yesod;
        '';
      };
    };
}

3laurus-nobilis-gce.nix

{
  laurus =
    { deployment.targetEnv = "gce";
      deployment.gce = {
        # credentials
        project = "laurus-nobilis";
        serviceAccount = "laurus-nobilis2@laurus-nobilis.iam.gserviceaccount.com";
        accessKey = "~/.ssh/laurus-nobilis-key.json";

        # instance properties
        region = "europe-west1-b";
        instanceType = "n1-standard-2";
        tags = ["crazy"];
        scheduling.automaticRestart = true;
        scheduling.onHostMaintenance = "MIGRATE";

        rootDiskSize = 20;
      } ;
    };
}

4default.nix

# /laurus-nobilis/default.nix
{ pkgs ? import <nixpkgs> {}, compiler ? "ghc844" }:
pkgs.haskell.packages.${compiler}.callPackage ./stack2nix.nix { }

5stack2nix.nix

# Generated using stack2nix 0.2.2.

{ pkgs ? (import <nixpkgs> {})
, compiler ? pkgs.haskell.packages.ghc844
}:

with pkgs.haskell.lib;

let
  stackPackages = { pkgs, stdenv, callPackage }:
    self: {
      array = null;
      base = null;
      bin-package-db = null;
      binary = null;
      bytestring = null;
      containers = null;
      deepseq = null;
      directory = null;
      filepath = null;
      ghc-boot = null;
      ghc-boot-th = null;
      ghc-prim = null;
      ghci = null;
      hpc = null;
      integer-gmp = null;
      pretty = null;
      process = null;
      rts = null;
      template-haskell = null;
      terminfo = null;
      time = null;
      transformers = null;
      unix = null;
      "ALUT" = callPackage
        ({ mkDerivation, base, freealut, OpenAL, StateVar, stdenv
         , transformers
         }:
         mkDerivation {
           pname = "ALUT";
           version = "2.4.0.2";
           sha256 = "b8364da380f5f1d85d13e427851a153be2809e1838d16393e37566f34b384b87";
           isLibrary = true;
           isExecutable = true;
           libraryHaskellDepends = [ base OpenAL StateVar transformers ];
           librarySystemDepends = [ freealut ];
           doHaddock = false;
           doCheck = false;
           homepage = "https://github.com/haskell-openal/ALUT";
           description = "A binding for the OpenAL Utility Toolkit";
           license = stdenv.lib.licenses.bsd3;
         }) {inherit (pkgs) freealut;};
      "ANum" = callPackage
        ({ mkDerivation, base, stdenv }:
         mkDerivation {
           pname = "ANum";
           version = "0.2.0.2";
           sha256 = "f6ae0d1b663100a2aa3dfdab12f4af0851408659eb5c2f78b8b443b0d29dbb1a";
           libraryHaskellDepends = [ base ];
           doHaddock = false;
           doCheck = false;
           homepage = "https://github.com/DanBurton/ANum#readme";
           description = "Num instance for Applicatives provided via the ANum newtype";
           license = stdenv.lib.licenses.bsd3;
         }) {};
      "Agda" = callPackage
        ({ mkDerivation, alex, array, async, base, binary, blaze-html
         , boxes, bytestring, Cabal, containers, data-hash, deepseq
         , directory, EdisonCore, edit-distance, emacs, equivalence
         , filemanip, filepath, geniplate-mirror, gitrev, happy, hashable
         , hashtables, haskeline, ieee754, mtl, murmur-hash, pretty, process
         , regex-tdfa, stdenv, stm, strict, template-haskell, text, time
         , transformers, unordered-containers, uri-encode, zlib
         }:
         mkDerivation {
           pname = "Agda";
           version = "2.5.4.2";
           sha256 = "f645add8a47a35da3f37757204fa9c80aeb0993d628fc2057fa343e92e579b1f";
           isLibrary = true;
           isExecutable = true;
           enableSeparateDataOutput = true;
           setupHaskellDepends = [ base Cabal filemanip filepath process ];
           libraryHaskellDepends = [
             array async base binary blaze-html boxes bytestring containers
             data-hash deepseq directory EdisonCore edit-distance equivalence
             filepath geniplate-mirror gitrev hashable hashtables haskeline
             ieee754 mtl murmur-hash pretty process regex-tdfa stm strict
             template-haskell text time transformers unordered-containers
             uri-encode zlib
           ];
           libraryToolDepends = [ alex happy ];
           executableHaskellDepends = [ base directory filepath process ];
           executableToolDepends = [ emacs ];
           doHaddock = false;
           doCheck = false;
           postInstall = ''
             files=("$data/share/ghc-"*"/"*"-ghc-"*"/Agda-"*"/lib/prim/Agda/"{Primitive.agda,Builtin"/"*.agda})
             for f in "''${files[@]}" ; do
               $out/bin/agda $f
             done
             for f in "''${files[@]}" ; do
               $out/bin/agda -c --no-main $f
             done
             $out/bin/agda-mode compile
           '';
           homepage = "http://wiki.portal.chalmers.se/agda/";
           description = "A dependently typed functional programming language and proof assistant";
           license = "unknown";
           hydraPlatforms = stdenv.lib.platforms.none;
         }) {};
      "Allure" = callPackage
        ({ mkDerivation, async, base, containers, enummapset, filepath
         , LambdaHack, optparse-applicative, random, stdenv
         , template-haskell, text, transformers, zlib
         }:
         mkDerivation {
           pname = "Allure";
           version = "0.8.3.0";
           sha256 = "6b83013281da6ccc5f0bf4c483a53acdbff7679c7234a1dfa57261c45a8cf8fb";
           isLibrary = false;
           isExecutable = true;
           enableSeparateDataOutput = true;
           executableHaskellDepends = [
             async base containers enummapset filepath LambdaHack
             optparse-applicative random template-haskell text transformers zlib
           ];
           doHaddock = false;
           doCheck = false;
           homepage = "http://allureofthestars.com";
           description = "Near-future Sci-Fi roguelike and tactical squad game";
           license = "unknown";
           hydraPlatforms = stdenv.lib.platforms.none;
         }) {};
      "BiobaseNewick" = callPackage
        ({ mkDerivation, aeson, attoparsec, base, binary, cereal
         , cereal-text, cmdargs, containers, fgl, ForestStructures
         , QuickCheck, stdenv, text, text-binary, vector
         }:
         mkDerivation {
           pname = "BiobaseNewick";
           version = "0.0.0.2";
           sha256 = "6432f684a75fd8a2cea59a5359a59f48020ead19119efaed7018ecae726d13bd";
           isLibrary = true;
           isExecutable = true;
           libraryHaskellDepends = [
             aeson attoparsec base binary cereal cereal-text containers fgl
             ForestStructures QuickCheck text text-binary vector
           ];
           executableHaskellDepends = [
             base cmdargs ForestStructures text vector
           ];
           doHaddock = false;
           doCheck = false;
           homepage = "https://github.com/choener/BiobaseNewick";
           description = "Newick file format parser";
           license = stdenv.lib.licenses.bsd3;
         }) {};
      "Boolean" = callPackage
        ({ mkDerivation, base, stdenv }:
         mkDerivation {
           pname = "Boolean";
           version = "0.2.4";
           sha256 = "67216013b02b8ac5b534a1ef25f409f930eea1a85eae801933a01ad43145eef8";
           libraryHaskellDepends = [ base ];
           doHaddock = false;
           doCheck = false;
           description = "Generalized booleans and numbers";
           license = stdenv.lib.licenses.bsd3;
         }) {};
      "BoundedChan" = callPackage
        ({ mkDerivation, array, base, stdenv }:
         mkDerivation {
           pname = "BoundedChan";
           version = "1.0.3.0";
           sha256 = "531ceaed7f62844c2a63a7cbfdcab332ea5eaa218e9922ca3305580438adc46d";
           libraryHaskellDepends = [ array base ];
           doHaddock = false;
           doCheck = false;
           description = "Implementation of bounded channels";
           license = stdenv.lib.licenses.bsd3;
         }) {};
      "Cabal" = callPackage
        ({ mkDerivation, array, base, binary, bytestring, containers
         , deepseq, directory, filepath, mtl, parsec, pretty, process
         , stdenv, text, time, transformers, unix
         }:
         mkDerivation {
           pname = "Cabal";
           version = "2.2.0.1";
           sha256 = "02b5301304df73cea3c7d544b5026b228141dc3ac1d5b08c9a206f99aa330a7b";
           setupHaskellDepends = [ mtl parsec ];
           libraryHaskellDepends = [
             array base binary bytestring containers deepseq directory filepath
             mtl parsec pretty process text time transformers unix
           ];
           doHaddock = false;
           doCheck = false;
           homepage = "http://www.haskell.org/cabal/";
           description = "A framework for packaging Haskell software";
           license = stdenv.lib.licenses.bsd3;
         }) {};
      "ChannelT" = callPackage
        ({ mkDerivation, base, free, mmorph, mtl, stdenv, transformers-base
         }:
         mkDerivation {
           pname = "ChannelT";
           version = "0.0.0.7";
           sha256 = "3e215d425e3cfccf2e4d84b1402fb39a2081cb33b6556059db616e722a7c77a0";
           libraryHaskellDepends = [ base free mmorph mtl transformers-base ];
           doHaddock = false;
           doCheck = false;
           homepage = "https://github.com/pthariensflame/ChannelT";
           description = "Generalized stream processors";
           license = stdenv.lib.licenses.bsd3;
         }) {};
      "ChasingBottoms" = callPackage
        ({ mkDerivation, base, containers, mtl, QuickCheck, random, stdenv
         , syb
         }:
         mkDerivation {
           pname = "ChasingBottoms";
           version = "1.3.1.5";
           sha256 = "60f43e0956459606e3432ab528bada79503f928c9fa26e52deaea8961613d341";
           libraryHaskellDepends = [
             base containers mtl QuickCheck random syb
           ];
           doHaddock = false;
           doCheck = false;
           description = "For testing partial and infinite values";
           license = stdenv.lib.licenses.mit;
         }) {};
      "Clipboard" = callPackage
        ({ mkDerivation, base, directory, stdenv, unix, utf8-string, X11 }:
         mkDerivation {
           pname = "Clipboard";
           version = "2.3.2.0";
           sha256 = "3f82c8183a599025c5199ba50d0661512683e9cf29e6054858f1abe2ab8b25b7";
           libraryHaskellDepends = [ base directory unix utf8-string X11 ];
           doHaddock = false;
           doCheck = false;
           homepage = "http://haskell.org/haskellwiki/Clipboard";
           description = "System clipboard interface";
           license = stdenv.lib.licenses.bsd3;
         }) {};
      "ClustalParser" = callPackage
        ({ mkDerivation, base, cmdargs, either-unwrap, parsec, stdenv, text
         , vector
         }:
         mkDerivation {
           pname = "ClustalParser";
           version = "1.2.3";
           sha256 = "fed67bdcb9d89d871b02f556e5a294d0ea6fd05576f92621a8797abff4325a72";
           isLibrary = true;
           isExecutable = true;
           libraryHaskellDepends = [ base parsec text vector ];
           executableHaskellDepends = [ base cmdargs either-unwrap ];
           doHaddock = false;
           doCheck = false;
           description = "Libary for parsing Clustal tools output";
           license = stdenv.lib.licenses.gpl3;
         }) {};
      "DAV" = callPackage
        ({ mkDerivation, base, bytestring, case-insensitive, containers
         , data-default, exceptions, haskeline, http-client, http-client-tls
         , http-types, lens, mtl, network, network-uri, optparse-applicative
         , stdenv, transformers, transformers-base, transformers-compat
         , utf8-string, xml-conduit, xml-hamlet
         }:
         mkDerivation {
           pname = "DAV";
           version = "1.3.3";
           sha256 = "24f49c63bd603b7757569ac0f5842ac30dea2bfcce64d157162a952e576e3991";
           isLibrary = true;
           isExecutable = true;
           libraryHaskellDepends = [
             base bytestring case-insensitive containers data-default exceptions
             http-client http-client-tls http-types lens mtl transformers
             transformers-base transformers-compat utf8-string xml-conduit
             xml-hamlet
           ];
           executableHaskellDepends = [
             base bytestring case-insensitive containers data-default exceptions
             haskeline http-client http-client-tls http-types lens mtl network
             network-uri optparse-applicative transformers transformers-base
             transformers-compat utf8-string xml-conduit xml-hamlet
           ];
           doHaddock = false;
           doCheck = false;
           homepage = "http://floss.scru.org/hDAV";
           description = "RFC 4918 WebDAV support";
           license = stdenv.lib.licenses.gpl3;
         }) {};
      "DRBG" = callPackage
        ({ mkDerivation, base, bytestring, cereal, cipher-aes128
         , crypto-api, cryptohash-cryptoapi, entropy, mtl, parallel
         , prettyclass, stdenv, tagged
         }:
         mkDerivation {
           pname = "DRBG";
           version = "0.5.5";
           sha256 = "21df3202486cc83c7cc3f867cb139eac9a3f69bd91b5f6b016ae026e03c33bfd";
           enableSeparateDataOutput = true;
           libraryHaskellDepends = [
             base bytestring cereal cipher-aes128 crypto-api
             cryptohash-cryptoapi entropy mtl parallel prettyclass tagged
           ];
           doHaddock = false;
           doCheck = false;
           description = "Deterministic random bit generator (aka RNG, PRNG) based HMACs, Hashes, and Ciphers";
           license = stdenv.lib.licenses.bsd3;
         }) {};
      "Decimal" = callPackage
        ({ mkDerivation, base, deepseq, stdenv }:
         mkDerivation {
           pname = "Decimal";
           version = "0.5.1";
           sha256 = "575ca5c65a8ea5a5bf2cd7b794a0d16622082cb501bf4b0327c5895c0b80f34c";
           libraryHaskellDepends = [ base deepseq ];
           doHaddock = false;
           doCheck = false;
           homepage = "https://github.com/PaulJohnson/Haskell-Decimal";
           description = "Decimal numbers with variable precision";
           license = stdenv.lib.licenses.bsd3;
         }) {};
      "Diff" = callPackage
        ({ mkDerivation, array, base, pretty, stdenv }:
         mkDerivation {
           pname = "Diff";
           version = "0.3.4";
           sha256 = "77b7daec5a79ade779706748f11b4d9b8f805e57a68e7406c3b5a1dee16e0c2f";
           libraryHaskellDepends = [ array base pretty ];
           doHaddock = false;
           doCheck = false;
           description = "O(ND) diff algorithm in haskell";
           license = stdenv.lib.licenses.bsd3;
         }) {};
      "Earley" = callPackage
        ({ mkDerivation, base, ListLike, stdenv }:
         mkDerivation {
           pname = "Earley";
           version = "0.12.1.0";
           sha256 = "731493be9cb960c3159458dc24b1a217d6f26e1f46a840bef880accd04d5bd1d";
           isLibrary = true;
           isExecutable = true;
           libraryHaskellDepends = [ base ListLike ];
           doHaddock = false;
           doCheck = false;
           description = "Parsing all context-free grammars using Earley's algorithm";
           license = stdenv.lib.licenses.bsd3;
         }) {};
      "Ebnf2ps" = callPackage
        ({ mkDerivation, array, base, containers, directory, happy
         , old-time, stdenv, unix
         }:
         mkDerivation {
           pname = "Ebnf2ps";
           version = "1.0.15";
           sha256 = "0ecce7d721d6c8993fa6ba6cfb16f1101d85e00bbaf0b6941d36a00badea2b4b";
           isLibrary = false;
           isExecutable = true;
           executableHaskellDepends = [
             array base containers directory old-time unix
           ];
           executableToolDepends = [ happy ];
           doHaddock = false;
           doCheck = false;
           homepage = "https://github.com/FranklinChen/Ebnf2ps";
           description = "Peter's Syntax Diagram Drawing Tool";
           license = stdenv.lib.licenses.bsd3;
         }) {};
      "EdisonAPI" = callPackage
        ({ mkDerivation, base, mtl, stdenv }:
         mkDerivation {
           pname = "EdisonAPI";
           version = "1.3.1";
           sha256 = "95a3b8d01599520a50456219b5a2e9f7832bcddaaeb8e94ce777bd87a4a6b56e";
           libraryHaskellDepends = [ base mtl ];
           doHaddock = false;
           doCheck = false;
           homepage = "http://rwd.rdockins.name/edison/home/";
           description = "A library of efficient, purely-functional data structures (API)";
           license = stdenv.lib.licenses.mit;
         }) {};
      "EdisonCore" = callPackage
        ({ mkDerivation, array, base, containers, EdisonAPI, mtl
         , QuickCheck, stdenv
         }:
         mkDerivation {
           pname = "EdisonCore";
           version = "1.3.2.1";
           sha256 = "73c6014d07107a9ed21df76a59f70c9d68d64ac84cced35f7b628f1d792cf239";
           libraryHaskellDepends = [
             array base containers EdisonAPI mtl QuickCheck
           ];
           doHaddock = false;
           doCheck = false;
           homepage = "http://rwd.rdockins.name/edison/home/";
           description = "A library of efficient, purely-functional data structures (Core Implementations)";
           license = stdenv.lib.licenses.mit;
         }) {};
      "FenwickTree" = callPackage
        ({ mkDerivation, base, QuickCheck, stdenv, template-haskell }:
         mkDerivation {
           pname = "FenwickTree";
           version = "0.1.2.1";
           sha256 = "9c172d62b24365e663a0355e8eaa34362a1a769c18a64391939a9b50e384f03c";
           enableSeparateDataOutput = true;
           libraryHaskellDepends = [ base QuickCheck template-haskell ];
           doHaddock = false;
           doCheck = false;
           homepage = "https://github.com/mgajda/FenwickTree";
           description = "Data structure for fast query and update of cumulative sums";
           license = stdenv.lib.licenses.bsd3;
         }) {};
      "Fin" = callPackage
        ({ mkDerivation, alg, base, foldable1, natural-induction, peano
         , stdenv, universe-base
         }:
         mkDerivation {
           pname = "Fin";
           version = "0.2.7.0";
           sha256 = "c331fecbdac3f80567c89beb85faaa2bdc1d4a056c56b38b1f18f856056b4970";
           libraryHaskellDepends = [
             alg base foldable1 natural-induction peano universe-base
           ];
           doHaddock = false;
           doCheck = false;
           description = "Finite totally-ordered sets";
           license = stdenv.lib.licenses.bsd3;
         }) {};
      "FindBin" = callPackage
        ({ mkDerivation, base, directory, filepath, stdenv }:
         mkDerivation {
           pname = "FindBin";
           version = "0.0.5";
           sha256 = "279c7967e0803ca3b9a0a1956ce7ba9b9a2294eb9f971bea8a557b5f80ddfda4";
           libraryHaskellDepends = [ base directory filepath ];
           doHaddock = false;
           doCheck = false;
           homepage = "https://github.com/audreyt/findbin";
           description = "Locate directory of original program";
           license = stdenv.lib.licenses.bsd3;
         }) {};
      "FloatingHex" = callPackage
        ({ mkDerivation, base, stdenv, template-haskell }:
         mkDerivation {
           pname = "FloatingHex";
           version = "0.4";
           sha256 = "b277054db48d2dec62e3831586f218cbe0a056dec44dbc032e9a73087425a24c";
           libraryHaskellDepends = [ base template-haskell ];
           doHaddock = false;
           doCheck = false;
           description = "Read and write hexadecimal floating point numbers";
           license = stdenv.lib.licenses.bsd3;
         }) {};
      "FontyFruity" = callPackage
        ({ mkDerivation, base, binary, bytestring, containers, deepseq
         , directory, filepath, stdenv, text, vector, xml
         }:
         mkDerivation {
           pname = "FontyFruity";
           version = "0.5.3.4";
           sha256 = "43d3878154d543a337b0cc45f40dcd57153e47fca39122bac0e5ed81b6bc5b3d";
           libraryHaskellDepends = [
             base binary bytestring containers deepseq directory filepath text
             vector xml
           ];
           doHaddock = false;
           doCheck = false;
           description = "A true type file format loader";
           license = stdenv.lib.licenses.bsd3;
         }) {};
      "ForestStructures" = callPackage
        ({ mkDerivation, base, containers, fgl, QuickCheck, stdenv
         , unordered-containers, vector, vector-th-unbox
         }:
         mkDerivation {
           pname = "ForestStructures";
           version = "0.0.0.2";
           sha256 = "fe74067fee601844de5c839a115f2bd75d4a1be9f0ee8ec42c0150bcf886693f";
           libraryHaskellDepends = [
             base containers fgl QuickCheck unordered-containers vector
             vector-th-unbox
           ];
           doHaddock = false;
           doCheck = false;
           homepage = "https://github.com/choener/ForestStructures";
           description = "Tree- and forest structures";
           license = stdenv.lib.licenses.bsd3;
         }) {};
      "GLFW-b" = callPackage
        ({ mkDerivation, base, bindings-GLFW, deepseq, stdenv }:
         mkDerivation {
           pname = "GLFW-b";
           version = "3.2.1.0";
           sha256 = "31c022e0ad63f259ff9fa582a235924786e929a95b52efae10a3d29fef7cb6a6";
           revision = "2";
           editedCabalFile = "0xlby7483dv33c13f44kkvmai186g72jhxmcq8749s1hyxi6fqnb";
           libraryHaskellDepends = [ base bindings-GLFW deepseq ];
           doHaddock = false;
           doCheck = false;
           description = "Bindings to GLFW OpenGL library";
           license = stdenv.lib.licenses.bsd3;
         }) {};
      "GLURaw" = callPackage
        ({ mkDerivation, base, libGL, libGLU, OpenGLRaw, stdenv
         , transformers
         }:
         mkDerivation {
           pname = "GLURaw";
           version = "2.0.0.4";
           sha256 = "b863fd5cb26b1a37afb66ef8a81c0335bc073d33b0a67ec5190dfc62cb885dc4";
           libraryHaskellDepends = [ base OpenGLRaw transformers ];
           librarySystemDepends = [ libGL libGLU ];
           doHaddock = false;
           doCheck = false;
           homepage = "http://www.haskell.org/haskellwiki/Opengl";
           description = "A raw binding for the OpenGL graphics system";
           license = stdenv.lib.licenses.bsd3;
         }) {inherit (pkgs) libGL; inherit (pkgs) libGLU;};
      "GLUT" = callPackage
        ({ mkDerivation, array, base, containers, OpenGL, StateVar, stdenv
         , transformers
         }:
         mkDerivation {
           pname = "GLUT";
           version = "2.7.0.14";
           sha256 = "5cf8f7700a6b6ac33e39b2d7bd300679a245ff7c1498eb423901134f9d302106";
           isLibrary = true;
           isExecutable = true;
           libraryHaskellDepends = [
             array base containers OpenGL StateVar transformers
           ];
           doHaddock = false;
           doCheck = false;
           homepage = "http://www.haskell.org/haskellwiki/Opengl";
           description = "A binding for the OpenGL Utility Toolkit";
           license = stdenv.lib.licenses.bsd3;
         }) {};
      "GenericPretty" = callPackage
        ({ mkDerivation, base, ghc-prim, pretty, stdenv }:
         mkDerivation {
           pname = "GenericPretty";
           version = "1.2.2";
           sha256 = "eeea7ae7081f866de6a83ab8c4c335806b8cbb679d85e416e6224384ffcdae3c";
           libraryHaskellDepends = [ base ghc-prim pretty ];
           doHaddock = false;
           doCheck = false;
           homepage = "https://github.com/RazvanRanca/GenericPretty";
           description = "A generic, derivable, haskell pretty printer";
           license = stdenv.lib.licenses.bsd3;
         }) {};
      "Glob" = callPackage
        ({ mkDerivation, base, containers, directory, dlist, filepath
         , stdenv, transformers, transformers-compat
         }:
         mkDerivation {
           pname = "Glob";
           version = "0.9.3";
           sha256 = "3a77853eba3700c5346cd6d4008302e70dca93a7e8ac0d679cf41b16c7a4c9e8";
           libraryHaskellDepends = [
             base containers directory dlist filepath transformers
             transformers-compat
           ];
           doHaddock = false;
           doCheck = false;
           homepage = "http://iki.fi/matti.niemenmaa/glob/";
           description = "Globbing library";
           license = stdenv.lib.licenses.bsd3;
         }) {};
      "HCodecs" = callPackage
        ({ mkDerivation, array, base, bytestring, QuickCheck, random
         , semigroups, stdenv
         }:
         mkDerivation {
           pname = "HCodecs";
           version = "0.5.1";
           sha256 = "a724616b79ac12c2d661dc3f54cfa0e7d530d1ba3eafa1e6c3e7116e035a3143";
           libraryHaskellDepends = [
             array base bytestring QuickCheck random semigroups
           ];
           doHaddock = false;
           doCheck = false;
           homepage = "http://www-db.informatik.uni-tuebingen.de/team/giorgidze";
           description = "A library to read, write and manipulate MIDI, WAVE, and SoundFont2 files";
           license = stdenv.lib.licenses.bsd3;
         }) {};
      "HDBC" = callPackage
        ({ mkDerivation, base, bytestring, containers, convertible, mtl
         , old-time, stdenv, text, time, utf8-string
         }:
         mkDerivation {
           pname = "HDBC";
           version = "2.4.0.2";
           sha256 = "670757fd674b6caf2f456034bdcb54812af2cdf2a32465d7f4b7f0baa377db5a";
           isLibrary = true;
           isExecutable = true;
           libraryHaskellDepends = [
             base bytestring containers convertible mtl old-time text time
             utf8-string
           ];
           doHaddock = false;
           doCheck = false;
           homepage = "https://github.com/hdbc/hdbc";
           description = "Haskell Database Connectivity";
           license = stdenv.lib.licenses.bsd3;
         }) {};
      "HDBC-mysql" = callPackage
        ({ mkDerivation, base, bytestring, Cabal, HDBC, mysqlclient
         , openssl, stdenv, time, utf8-string, zlib
         }:
         mkDerivation {
           pname = "HDBC-mysql";
           version = "0.7.1.0";
           sha256 = "81c985d4a243c965930fb412b3175ca799ba66985f8b6844014fd600df1da7cf";
           setupHaskellDepends = [ base Cabal ];
           libraryHaskellDepends = [ base bytestring HDBC time utf8-string ];
           librarySystemDepends = [ mysqlclient openssl zlib ];
           doHaddock = false;
           doCheck = false;
           homepage = "http://github.com/ryantm/hdbc-mysql";
           description = "MySQL driver for HDBC";
           license = "LGPL";
         }) {inherit (pkgs) mysqlclient; inherit (pkgs) openssl; 
inherit (pkgs) zlib;};
      "HDBC-session" = callPackage
        ({ mkDerivation, base, HDBC, stdenv }:
         mkDerivation {
           pname = "HDBC-session";
           version = "0.1.2.0";
           sha256 = "aa057f18bbc9d2f9876152246682f546c9cf140192515c7c23b5be2fccc296e3";
           libraryHaskellDepends = [ base HDBC ];
           doHaddock = false;
           doCheck = false;
           homepage = "http://khibino.github.io/haskell-relational-record/";
           description = "Bracketed connection for HDBC";
           license = stdenv.lib.licenses.bsd3;
         }) {};
      "HPDF" = callPackage
        ({ mkDerivation, array, base, base64-bytestring, binary, bytestring
         , containers, errors, mtl, random, stdenv, vector, zlib
         }:
         mkDerivation {
           pname = "HPDF";
           version = "1.4.10";
           sha256 = "de2bfddd93eeef2129a2378e8dce486d086bec3c48ee2a1bf1a5fb01581607d4";
           revision = "1";
           editedCabalFile = "1djn0a9rk3qrbz31bxj115r65p28fi3wzcrkrnjvzibl3450pq30";
           libraryHaskellDepends = [
             array base base64-bytestring binary bytestring containers errors
             mtl random vector zlib
           ];
           doHaddock = false;
           doCheck = false;
           homepage = "http://www.alpheccar.org";
           description = "Generation of PDF documents";
           license = stdenv.lib.licenses.bsd3;
         }) {};
      "HSet" = callPackage
        ({ mkDerivation, base, containers, hashable, hashtables, stdenv }:
         mkDerivation {
           pname = "HSet";
           version = "0.0.1";
           sha256 = "eba93be5a76581585ae33af6babe9c2718fae307d41989cd36a605d9b0e8d16a";
           libraryHaskellDepends = [ base containers hashable hashtables ];
           doHaddock = false;
           doCheck = false;
           description = "Faux heterogeneous sets";
           license = stdenv.lib.licenses.bsd3;
         }) {};
      "HSlippyMap" = callPackage
        ({ mkDerivation, base, stdenv }:
         mkDerivation {
           pname = "HSlippyMap";
           version = "3.0.1";
           sha256 = "27eb37f3b1e70780173e732a949776fc0b0ecc5b1ba515c2e239d6545a2beb0d";
           libraryHaskellDepends = [ base ];
           doHaddock = false;
           doCheck = false;
           homepage = "https://github.com/apeyroux/HSlippyMap";
           description = "OpenStreetMap Slippy Map";
           license = stdenv.lib.licenses.bsd3;
         }) {};
      "HStringTemplate" = callPackage
        ({ mkDerivation, array, base, blaze-builder, bytestring, containers
         , deepseq, directory, filepath, mtl, old-locale, parsec, pretty
         , semigroups, stdenv, syb, template-haskell, text, time, void
         }:
         mkDerivation {
           pname = "HStringTemplate";
           version = "0.8.7";
           sha256 = "4f4ea4aa2e45e7c45821b87b0105c201fbadebc2f2d00c211e728403a0af6b0e";
           libraryHaskellDepends = [
             array base blaze-builder bytestring containers deepseq directory
             filepath mtl old-locale parsec pretty semigroups syb
             template-haskell text time void
           ];
           doHaddock = false;
           doCheck = false;
           description = "StringTemplate implementation in Haskell";
           license = stdenv.lib.licenses.bsd3;
         }) {};
      "HSvm" = callPackage
        ({ mkDerivation, base, containers, stdenv }:
         mkDerivation {
           pname = "HSvm";
           version = "0.1.0.3.22";
           sha256 = "8dac8a583c762675f2d64138303618f017d6be95d59e60774ea7cbfc040dab04";
           libraryHaskellDepends = [ base containers ];
           doHaddock = false;
           doCheck = false;
           description = "Haskell Bindings for libsvm";
           license = stdenv.lib.licenses.bsd3;
         }) {};
      "HTF" = callPackage
        ({ mkDerivation, aeson, array, base, base64-bytestring, bytestring
         , containers, cpphs, Diff, directory, haskell-src, HUnit
         , lifted-base, monad-control, mtl, old-time, pretty, process
         , QuickCheck, random, regex-compat, stdenv, text, time, unix
         , vector, xmlgen
         }:
         mkDerivation {
           pname = "HTF";
           version = "0.13.2.5";
           sha256 = "365af323c6254ec5c33745e1d42ceeba0940992a43f523608c4dc64d7c49aece";
           isLibrary = true;
           isExecutable = true;
           libraryHaskellDepends = [
             aeson array base base64-bytestring bytestring containers cpphs Diff
             directory haskell-src HUnit lifted-base monad-control mtl old-time
             pretty process QuickCheck random regex-compat text time unix vector
             xmlgen
           ];
           executableHaskellDepends = [
             array base cpphs directory HUnit mtl old-time random text
           ];
           doHaddock = false;
           doCheck = false;
           homepage = "https://github.com/skogsbaer/HTF/";
           description = "The Haskell Test Framework";
           license = stdenv.lib.licenses.lgpl21;
         }) {};
      "HTTP" = callPackage
        ({ mkDerivation, array, base, bytestring, mtl, network, network-uri
         , parsec, stdenv, time
         }:
         mkDerivation {
           pname = "HTTP";
           version = "4000.3.12";
           sha256 = "a3ff6a9c93771079121083f1691188fe45f84380118e0f76bc4578153c361990";
           revision = "2";
           editedCabalFile = "1gw6xzp1n4gsqwnbfr29ds8v4wpk78b2bha8i108dqav97viwm8c";
           libraryHaskellDepends = [
             array base bytestring mtl network network-uri parsec time
           ];
           doHaddock = false;
           doCheck = false;
           homepage = "https://github.com/haskell/HTTP";
           description = "A library for client-side HTTP";
           license = stdenv.lib.licenses.bsd3;
         }) {};
      "HUnit" = callPackage
        ({ mkDerivation, base, call-stack, deepseq, stdenv }:
         mkDerivation {
           pname = "HUnit";
           version = "1.6.0.0";
           sha256 = "7448e6b966e98e84b7627deba23f71b508e9a61e7bc571d74304a25d30e6d0de";
           libraryHaskellDepends = [ base call-stack deepseq ];
           doHaddock = false;
           doCheck = false;
           homepage = "https://github.com/hspec/HUnit#readme";
           description = "A unit testing framework for Haskell";
           license = stdenv.lib.licenses.bsd3;
         }) {};
      "HUnit-approx" = callPackage
        ({ mkDerivation, base, call-stack, HUnit, stdenv }:
         mkDerivation {
           pname = "HUnit-approx";
           version = "1.1.1.1";
           sha256 = "4a4327d328bb8b944c73ec211dd29e953e477f99fd3f9e28fe5200f02fa62baf";
           libraryHaskellDepends = [ base call-stack HUnit ];
           doHaddock = false;
           doCheck = false;
           homepage = "https://github.com/goldfirere/HUnit-approx";
           description = "Approximate equality for floating point numbers with HUnit";
           license = stdenv.lib.licenses.bsd3;
         }) {};
      "HaTeX" = callPackage
        ({ mkDerivation, base, bytestring, containers, hashable, matrix
         , parsec, QuickCheck, stdenv, text, transformers, wl-pprint-extras
         }:
         mkDerivation {
           pname = "HaTeX";
           version = "3.19.0.0";
           sha256 = "1fd977a582f44a62dafe32ad72acde8c0c01b0ae0ce5f7d6bbc4d91b68e24749";
           libraryHaskellDepends = [
             base bytestring containers hashable matrix parsec QuickCheck text
             transformers wl-pprint-extras
           ];
           doHaddock = false;
           doCheck = false;
           homepage = "https://github.com/Daniel-Diaz/HaTeX/blob/master/README.md";
           description = "The Haskell LaTeX library";
           license = stdenv.lib.licenses.bsd3;
         }) {};
      "HandsomeSoup" = callPackage
        ({ mkDerivation, base, containers, HTTP, hxt, hxt-http, mtl
         , network, network-uri, parsec, stdenv, transformers
         }:
         mkDerivation {
           pname = "HandsomeSoup";
           version = "0.4.2";
           sha256 = "0ae2dad3fbde1efee9e45b84b2aeb5b526cc7b3ea2cbc5715494f7bde3ceeefb";
           isLibrary = true;
           isExecutable = true;
           enableSeparateDataOutput = true;
           libraryHaskellDepends = [
             base containers HTTP hxt hxt-http mtl network network-uri parsec
             transformers
           ];
           doHaddock = false;
           doCheck = false;
           homepage = "https://github.com/egonSchiele/HandsomeSoup";
           description = "Work with HTML more easily in HXT";
           license = stdenv.lib.licenses.bsd3;
         }) {};
      "HaskellNet" = callPackage
        ({ mkDerivation, array, base, base64-string, bytestring, cryptohash
         , mime-mail, mtl, network, old-time, pretty, stdenv, text
         }:
         mkDerivation {
           pname = "HaskellNet";
           version = "0.5.1";
           sha256 = "3245d31ad76f9f9013a2f6e2285d73ed37376eeb073c100b9a6d19e87f0ca838";
           libraryHaskellDepends = [
             array base base64-string bytestring cryptohash mime-mail mtl
             network old-time pretty text
           ];
           doHaddock = false;
           doCheck = false;
           homepage = "https://github.com/jtdaugherty/HaskellNet";
           description = "Client support for POP3, SMTP, and IMAP";
           license = stdenv.lib.licenses.bsd3;
         }) {};
      "HaskellNet-SSL" = callPackage
        ({ mkDerivation, base, bytestring, connection, data-default
         , HaskellNet, network, stdenv, tls
         }:
         mkDerivation {
           pname = "HaskellNet-SSL";
           version = "0.3.4.0";
           sha256 = "83ae92547fd5d52b5b74402101ec254423abeac0c0725e14a112d6ffc843040f";
           enableSeparateDataOutput = true;
           libraryHaskellDepends = [
             base bytestring connection data-default HaskellNet network tls
           ];
           doHaddock = false;
           doCheck = false;
           homepage = "https://github.com/dpwright/HaskellNet-SSL";
           description = "Helpers to connect to SSL/TLS mail servers with HaskellNet";
           license = stdenv.lib.licenses.bsd3;
         }) {};
      "Hoed" = callPackage
        ({ mkDerivation, array, base, bytestring, cereal, cereal-text
         , cereal-vector, clock, containers, deepseq, directory, hashable
         , libgraph, open-browser, primitive, process, QuickCheck
         , regex-tdfa, regex-tdfa-text, semigroups, stdenv, strict
         , template-haskell, terminal-size, text, transformers, uniplate
         , unordered-containers, vector, vector-th-unbox
         }:
         mkDerivation {
           pname = "Hoed";
           version = "0.5.1";
           sha256 = "a8f6dc9717e15642f00cd84a8d1030ac6a7c7870f7015e380bd728a843c3f4e7";
           libraryHaskellDepends = [
             array base bytestring cereal cereal-text cereal-vector clock
             containers deepseq directory hashable libgraph open-browser
             primitive process QuickCheck regex-tdfa regex-tdfa-text semigroups
             strict template-haskell terminal-size text transformers uniplate
             unordered-containers vector vector-th-unbox
           ];
           doHaddock = false;
           doCheck = false;
           homepage = "https://github.com/MaartenFaddegon/Hoed";
           description = "Lightweight algorithmic debugging";
           license = stdenv.lib.licenses.bsd3;
         }) {};
      "HsOpenSSL" = callPackage
        ({ mkDerivation, base, bytestring, Cabal, network, openssl, stdenv
         , time
         }:
         mkDerivation {
           pname = "HsOpenSSL";
           version = "0.11.4.15";
           sha256 = "cebdceef21d8f00feaa3dcc31b18fc960bbfeaec1326ece1edeb56d4cc54b545";
           revision = "1";
           editedCabalFile = "0bkcw2pjfgv1bhgkrpncvwq9czfr7cr4ak14n0v8c2y33i33wk5z";
           configureFlags = [ "-f-fast-bignum" ];
           setupHaskellDepends = [ base Cabal ];
           libraryHaskellDepends = [ base bytestring network time ];
           librarySystemDepends = [ openssl ];
           doHaddock = false;
           doCheck = false;
           homepage = "https://github.com/vshabanov/HsOpenSSL";
           description = "Partial OpenSSL binding for Haskell";
           license = stdenv.lib.licenses.publicDomain;
         }) {inherit (pkgs) openssl;};
      "HsOpenSSL-x509-system" = callPackage
        ({ mkDerivation, base, bytestring, HsOpenSSL, stdenv, unix }:
         mkDerivation {
           pname = "HsOpenSSL-x509-system";
           version = "0.1.0.3";
           sha256 = "5bdcb7ae2faba07a374109fea0a1431ae09d080f8574e60ab7a351b46f931f92";
           libraryHaskellDepends = [ base bytestring HsOpenSSL unix ];
           doHaddock = false;
           doCheck = false;
           homepage = "https://github.com/redneb/HsOpenSSL-x509-system";
           description = "Use the system's native CA certificate store with HsOpenSSL";
           license = stdenv.lib.licenses.bsd3;
         }) {};
      "IPv6Addr" = callPackage
        ({ mkDerivation, aeson, attoparsec, base, iproute, network
         , network-info, random, stdenv, text
         }:
         mkDerivation {
           pname = "IPv6Addr";
           version = "1.1.1";
           sha256 = "3b0959a9f1357b12aff50bda88e3af6e13ba0787758209c68a60fb6e88755e50";
           libraryHaskellDepends = [
             aeson attoparsec base iproute network network-info random text
           ];
           doHaddock = false;
           doCheck = false;
           homepage = "https://github.com/MichelBoucey/IPv6Addr";
           description = "Library to deal with IPv6 address text representations";
           license = stdenv.lib.licenses.bsd3;
         }) {};
      "IPv6DB" = callPackage
        ({ mkDerivation, aeson, attoparsec, base, bytestring, fast-logger
         , hedis, http-types, IPv6Addr, mtl, optparse-applicative, stdenv
         , text, unordered-containers, vector, wai, wai-logger, warp
         }:
         mkDerivation {
           pname = "IPv6DB";
           version = "0.3.1";
           sha256 = "96354eb278fe7de771fb7fd9f29dbe6f328a0497526dc85f066eca65c7074418";
           isLibrary = true;
           isExecutable = true;
           libraryHaskellDepends = [
             aeson attoparsec base bytestring hedis http-types IPv6Addr mtl text
             unordered-containers vector
           ];
           executableHaskellDepends = [
             aeson base bytestring fast-logger hedis http-types IPv6Addr mtl
             optparse-applicative text unordered-containers vector wai
             wai-logger warp
           ];
           doHaddock = false;
           doCheck = false;
           homepage = "http://ipv6db.cybervisible.com";
           description = "A RESTful microService for IPv6-related data";
           license = stdenv.lib.licenses.bsd3;
         }) {};
      "Imlib" = callPackage
        ({ mkDerivation, array, base, imlib2, stdenv, X11 }:
         mkDerivation {
           pname = "Imlib";
           version = "0.1.2";
           sha256 = "3ed318a7777a3b0752327b7b128edb3a1d562202b480a6d6b793b79ed90ebd1c";
           libraryHaskellDepends = [ array base X11 ];
           librarySystemDepends = [ imlib2 ];
           doHaddock = false;
           doCheck = false;
           license = stdenv.lib.licenses.bsd3;
         }) {inherit (pkgs) imlib2;};
      "IntervalMap" = callPackage
        ({ mkDerivation, base, containers, deepseq, stdenv }:
         mkDerivation {
           pname = "IntervalMap";
           version = "0.6.1.0";
           sha256 = "133676b9e01008b9d9bfeb5dbf3f51aabdc53b3a334588e68a8b6f5089ab873c";
           libraryHaskellDepends = [ base containers deepseq ];
           doHaddock = false;
           doCheck = false;
           homepage = "http://www.chr-breitkopf.de/comp/IntervalMap";
           description = "Containers for intervals, with efficient search";
           license = stdenv.lib.licenses.bsd3;
         }) {};
      "JuicyPixels" = callPackage
        ({ mkDerivation, base, binary, bytestring, containers, deepseq, mtl
         , primitive, stdenv, transformers, vector, zlib
         }:
         mkDerivation {
           pname = "JuicyPixels";
           version = "3.2.9.5";
           sha256 = "849c6cf4a613f906f7e553a1baefe9c0dc61c13b41a5f5b9605cf80e328cc355";
           libraryHaskellDepends = [
             base binary bytestring containers deepseq mtl primitive
             transformers vector zlib
           ];
           doHaddock = false;
           doCheck = false;
           homepage = "https://github.com/Twinside/Juicy.Pixels";
           description = "Picture loading/serialization (in png, jpeg, bitmap, gif, tga, tiff and radiance)";
           license = stdenv.lib.licenses.bsd3;
         }) {};
      "JuicyPixels-blp" = callPackage
        ({ mkDerivation, attoparsec, base, binary, bytestring, directory
         , filepath, hashable, JuicyPixels, optparse-simple, stdenv
         , text-show, unordered-containers, vector
         }:
         mkDerivation {
           pname = "JuicyPixels-blp";
           version = "0.1.1.0";
           sha256 = "7d2f9e45580ff26a7a15b2fefb7e6582d5a32d7e84f34b99f856ae6451ea8c6d";
           isLibrary = true;
           isExecutable = true;
           libraryHaskellDepends = [
             attoparsec base binary bytestring hashable JuicyPixels text-show
             vector
           ];
           executableHaskellDepends = [
             base bytestring directory filepath JuicyPixels optparse-simple
             text-show unordered-containers
           ];
           doHaddock = false;
           doCheck = false;
           homepage = "http://github.com/NCrashed/JuicyPixels-blp#readme";
           description = "BLP format decoder/encoder over JuicyPixels library";
           license = stdenv.lib.licenses.bsd3;
         }) {};
      "JuicyPixels-extra" = callPackage
        ({ mkDerivation, base, JuicyPixels, stdenv }:
         mkDerivation {
           pname = "JuicyPixels-extra";
           version = "0.3.0";
           sha256 = "c5a03a9747bcd984924d6f7c9b4771188e297df82160e7d667ea8f4f671b0e22";
           revision = "3";
           editedCabalFile = "1xr4vjhzjw3ynibb6693dhcz2jbvbx4yg2bir8w2s98n37gwsxd7";
           enableSeparateDataOutput = true;
           libraryHaskellDepends = [ base JuicyPixels ];
           doHaddock = false;
           doCheck = false;
           homepage = "https://github.com/mrkkrp/JuicyPixels-extra";
           description = "Efficiently scale, crop, flip images with JuicyPixels";
           license = stdenv.lib.licenses.bsd3;
         }) {};
      "JuicyPixels-scale-dct" = callPackage
        ({ mkDerivation, base, base-compat, carray, fft, JuicyPixels
         , stdenv
         }:
         mkDerivation {
           pname = "JuicyPixels-scale-dct";
           version = "0.1.2";
           sha256 = "f7381b88446224897e6677692bbdc39cb5b755216212f0ad8050046865cd3013";
           revision = "2";
           editedCabalFile = "0pp67ygrd3m6q8ry5229m1b2rhy401gb74368h09bqc6wa3g7ygv";
           libraryHaskellDepends = [
             base base-compat carray fft JuicyPixels
           ];
           doHaddock = false;
           doCheck = false;
           homepage = "https://github.com/phadej/JuicyPixels-scale-dct#readme";
           description = "Scale JuicyPixels images with DCT";
           license = stdenv.lib.licenses.bsd3;
         }) {};
      "LambdaHack" = callPackage
        ({ mkDerivation, assert-failure, async, base, base-compat, binary
         , bytestring, containers, deepseq, directory, enummapset, filepath
         , ghc-prim, hashable, hsini, keys, miniutter, optparse-applicative
         , pretty-show, random, sdl2, sdl2-ttf, stdenv, stm
         , template-haskell, text, time, transformers, unordered-containers
         , vector, vector-binary-instances, zlib
         }:
         mkDerivation {
           pname = "LambdaHack";
           version = "0.8.3.0";
           sha256 = "5a9b23a893ba809d8f7ff1ef810d4d542fcd7419876aef4208cf237a3662076c";
           isLibrary = true;
           isExecutable = true;
           enableSeparateDataOutput = true;
           libraryHaskellDepends = [
             assert-failure async base base-compat binary bytestring containers
             deepseq directory enummapset filepath ghc-prim hashable hsini keys
             miniutter optparse-applicative pretty-show random sdl2 sdl2-ttf stm
             text time transformers unordered-containers vector
             vector-binary-instances zlib
           ];
           executableHaskellDepends = [
             assert-failure async base base-compat binary bytestring containers
             deepseq directory enummapset filepath ghc-prim hashable hsini keys
             miniutter optparse-applicative pretty-show random stm
             template-haskell text time transformers unordered-containers vector
             vector-binary-instances zlib
           ];
           doHaddock = false;
           doCheck = false;
           homepage = "https://lambdahack.github.io";
           description = "A game engine library for tactical squad ASCII roguelike dungeon crawlers";
           license = stdenv.lib.licenses.bsd3;
         }) {};
      "LibZip" = callPackage
        ({ mkDerivation, base, bindings-libzip, bytestring, filepath, mtl
         , stdenv, time, utf8-string
         }:
         mkDerivation {
           pname = "LibZip";
           version = "1.0.1";
           sha256 = "a636e0202d2a3f60d894a814bd9834cf8c62313b67ccc48c295f02a4bebe425f";
           libraryHaskellDepends = [
             base bindings-libzip bytestring filepath mtl time utf8-string
           ];
           doHaddock = false;
           doCheck = false;
           homepage = "http://bitbucket.org/astanin/hs-libzip/";
           description = "Bindings to libzip, a library for manipulating zip archives";
           license = stdenv.lib.licenses.bsd3;
         }) {};
      "List" = callPackage
        ({ mkDerivation, base, stdenv, transformers }:
         mkDerivation {
           pname = "List";
           version = "0.6.2";
           sha256 = "c4b92be1202fc59112018f76d5b17cd3a659ebc36384a46e000ab2fbaf99b878";
           revision = "1";
           editedCabalFile = "11ws93cdzz7k4nvcld2d74155mdgcvyi6f6an7gpf9z4k523c11n";
           libraryHaskellDepends = [ base transformers ];
           doHaddock = false;
           doCheck = false;
           homepage = "http://github.com/yairchu/generator";
           description = "List monad transformer and class";
           license = stdenv.lib.licenses.bsd3;
         }) {};
      "ListLike" = callPackage
        ({ mkDerivation, array, base, bytestring, containers, deepseq
         , dlist, fmlist, stdenv, text, utf8-string, vector
         }:
         mkDerivation {
           pname = "ListLike";
           version = "4.6";
           sha256 = "c1cdec79a5f585a5839eea26a2afe6a37aab5ed2f402a16e7d59fe9a4e925a9a";
           revision = "2";
           editedCabalFile = "1mca2r4gjznqdh4kck5cjkn53isgkhvkf3ri09qsn7nsssvgki0g";
           libraryHaskellDepends = [
             array base bytestring containers deepseq dlist fmlist text
             utf8-string vector
           ];
           doHaddock = false;
           doCheck = false;
           homepage = "http://github.com/JohnLato/listlike";
           description = "Generic support for list-like structures";
           license = stdenv.lib.licenses.bsd3;
         }) {};
      "MemoTrie" = callPackage
        ({ mkDerivation, base, newtype-generics, stdenv }:
         mkDerivation {
           pname = "MemoTrie";
           version = "0.6.9";
           sha256 = "1d6045b8fdf7b89ed6b495e535613f5091cdfc9cdfe05a862207e76ce205f794";
           isLibrary = true;
           isExecutable = true;
           libraryHaskellDepends = [ base newtype-generics ];
           doHaddock = false;
           doCheck = false;
           homepage = "https://github.com/conal/MemoTrie";
           description = "Trie-based memo functions";
           license = stdenv.lib.licenses.bsd3;
         }) {};
      "MissingH" = callPackage
        ({ mkDerivation, array, base, containers, directory, filepath
         , hslogger, HUnit, mtl, network, old-locale, old-time, parsec
         , process, random, regex-compat, stdenv, time, unix
         }:
         mkDerivation {
           pname = "MissingH";
           version = "1.4.1.0";
           sha256 = "49ecd2df3ad45d6da64a984e506cd0e2ca02c238a743d757feeea8c4cddce0ca";
           revision = "2";
           editedCabalFile = "1k7d8cgvpmln4imcrfpj4c02n3c5l1gkd5hs4hnar9ln0qh61cfx";
           libraryHaskellDepends = [
             array base containers directory filepath hslogger HUnit mtl network
             old-locale old-time parsec process random regex-compat time unix
           ];
           doHaddock = false;
           doCheck = false;
           homepage = "http://software.complete.org/missingh";
           description = "Large utility library";
           license = stdenv.lib.licenses.bsd3;
         }) {};
      "MonadPrompt" = callPackage
        ({ mkDerivation, base, mtl, stdenv }:
         mkDerivation {
           pname = "MonadPrompt";
           version = "1.0.0.5";
           sha256 = "b012cbbe83650f741c7b7f6eafcc89dec299b0ac74a758b6f3a8cdfc5d3bbeda";
           libraryHaskellDepends = [ base mtl ];
           doHaddock = false;
           doCheck = false;
           description = "MonadPrompt, implementation & examples";
           license = stdenv.lib.licenses.bsd3;
         }) {};
      "MonadRandom" = callPackage
        ({ mkDerivation, base, mtl, primitive, random, stdenv, transformers
         , transformers-compat
         }:
         mkDerivation {
           pname = "MonadRandom";
           version = "0.5.1.1";
           sha256 = "abda4a297acf197e664695b839b4fb70f53e240f5420489dc21bcf6103958470";
           revision = "2";
           editedCabalFile = "0l6a39vmqxig7jpr6snync4sli77wm6lwzypmmvx103d65p17k8k";
           libraryHaskellDepends = [
             base mtl primitive random transformers transformers-compat
           ];
           doHaddock = false;
           doCheck = false;
           description = "Random-number generation monad";
           license = stdenv.lib.licenses.bsd3;
         }) {};
      "MusicBrainz" = callPackage
        ({ mkDerivation, aeson, base, bytestring, conduit, conduit-extra
         , HTTP, http-conduit, http-types, monad-control, resourcet, stdenv
         , text, time, time-locale-compat, transformers, unliftio-core
         , vector, xml-conduit, xml-types
         }:
         mkDerivation {
           pname = "MusicBrainz";
           version = "0.4.1";
           sha256 = "262c29f630a761356454c2a382d149230ea2e621c95102b3d3b30427d7c0cd57";
           libraryHaskellDepends = [
             aeson base bytestring conduit conduit-extra HTTP http-conduit
             http-types monad-control resourcet text time time-locale-compat
             transformers unliftio-core vector xml-conduit xml-types
           ];
           doHaddock = false;
           doCheck = false;
           homepage = "http://floss.scru.org/hMusicBrainz";
           description = "interface to MusicBrainz XML2 and JSON web services";
           license = stdenv.lib.licenses.gpl3;
         }) {};
      "Network-NineP" = callPackage
        ({ mkDerivation, base, binary, bytestring, containers, convertible
         , exceptions, hslogger, monad-loops, monad-peel, mstate, mtl
         , network, NineP, regex-posix, stateref, stdenv, transformers
         }:
         mkDerivation {
           pname = "Network-NineP";
           version = "0.4.4";
           sha256 = "fe2b0a7eadcf9329f0865564324052324770de035f1d5caa67a5bd5b634c3b85";
           isLibrary = true;
           isExecutable = true;
           libraryHaskellDepends = [
             base binary bytestring containers convertible exceptions hslogger
             monad-loops monad-peel mstate mtl network NineP regex-posix
             stateref transformers
           ];
           doHaddock = false;
           doCheck = false;
           description = "High-level abstraction over 9P protocol";
           license = "unknown";
           hydraPlatforms = stdenv.lib.platforms.none;
         }) {};
      "NineP" = callPackage
        ({ mkDerivation, base, binary, bytestring, stdenv }:
         mkDerivation {
           pname = "NineP";
           version = "0.0.2.1";
           sha256 = "4bb1516b9fb340118960043e0c72aa62316be8ff3f78cc8c1354e2fac96dd8cc";
           configureFlags = [ "-f-bytestring-in-base" ];
           libraryHaskellDepends = [ base binary bytestring ];
           doHaddock = false;
           doCheck = false;
           homepage = "http://9ph.googlecode.com";
           description = "9P2000 in pure Haskell";
           license = stdenv.lib.licenses.bsd3;
         }) {};
      "NoHoed" = callPackage
        ({ mkDerivation, base, stdenv, template-haskell }:
         mkDerivation {
           pname = "NoHoed";
           version = "0.1.1";
           sha256 = "9b663a234c034e0049126ae7f06d1756dc496012177bf18548c6d8caeec43b3d";
           libraryHaskellDepends = [ base template-haskell ];
           doHaddock = false;
           doCheck = false;
           homepage = "https://github.com/pepeiborra/NoHoed";
           description = "Placeholder package to preserve debug ability via conditional builds";
           license = stdenv.lib.licenses.bsd3;
         }) {};
      "NumInstances" = callPackage
        ({ mkDerivation, base, stdenv }:
         mkDerivation {
           pname = "NumInstances";
           version = "1.4";
           sha256 = "cbdb2a49346f59ceb5ab38592d7bc52e5205580d431d0ac6d852fd9880e59679";
           libraryHaskellDepends = [ base ];
           doHaddock = false;
           doCheck = false;
           homepage = "https://github.com/conal/NumInstances";
           description = "Instances of numeric classes for functions and tuples";
           license = stdenv.lib.licenses.bsd3;
         }) {};
      "ObjectName" = callPackage
        ({ mkDerivation, base, stdenv, transformers }:
         mkDerivation {
           pname = "ObjectName";
           version = "1.1.0.1";
           sha256 = "72dbef237580fd4e8567de2de752835bbadd3629f486d1586486d49a49aad210";
           libraryHaskellDepends = [ base transformers ];
           doHaddock = false;
           doCheck = false;
           homepage = "https://github.com/svenpanne/ObjectName";
           description = "Explicitly handled object names";
           license = stdenv.lib.licenses.bsd3;
         }) {};
      "OneTuple" = callPackage
        ({ mkDerivation, base, stdenv }:
         mkDerivation {
           pname = "OneTuple";
           version = "0.2.2";
           sha256 = "d82e702485bcbdefbda0d12b6a250d318a269572ee58d63b60eee531e56624dc";
           revision = "1";
           editedCabalFile = "07jd23glblzmnlw7sn565sk9gm7vj9h459j46bkbcrrxnp0n0myq";
           libraryHaskellDepends = [ base ];
           doHaddock = false;
           doCheck = false;
           description = "Singleton Tuple";
           license = stdenv.lib.licenses.bsd3;
         }) {};
      "Only" = callPackage
        ({ mkDerivation, base, deepseq, stdenv }:
         mkDerivation {
           pname = "Only";
           version = "0.1";
           sha256 = "ab7aa193e8c257d3bda6b0b3c1cbcf74cdaa85ab08cb20c2dd62ba248c1ab265";
           revision = "1";
           editedCabalFile = "1ahk7p34kmh041mz7lyc10nhcxgv2i4z8nvzxvqm2x34gslmsbzr";
           libraryHaskellDepends = [ base deepseq ];
           doHaddock = false;
           doCheck = false;
           description = "The 1-tuple type or single-value \"collection\"";
           license = stdenv.lib.licenses.bsd3;
         }) {};
      "OpenAL" = callPackage
        ({ mkDerivation, base, ObjectName, openal, OpenGL, StateVar, stdenv
         , transformers
         }:
         mkDerivation {
           pname = "OpenAL";
           version = "1.7.0.4";
           sha256 = "3989f6c4fe437843551004dd011c4308bf63d787ae4fbb8ce71d44b1b0b1f118";
           isLibrary = true;
           isExecutable = true;
           libraryHaskellDepends = [
             base ObjectName OpenGL StateVar transformers
           ];
           librarySystemDepends = [ openal ];
           doHaddock = false;
           doCheck = false;
           homepage = "https://github.com/haskell-openal/ALUT";
           description = "A binding to the OpenAL cross-platform 3D audio API";
           license = stdenv.lib.licenses.bsd3;
         }) {inherit (pkgs) openal;};
      "OpenGL" = callPackage
        ({ mkDerivation, base, bytestring, containers, GLURaw, ObjectName
         , OpenGLRaw, StateVar, stdenv, text, transformers
         }:
         mkDerivation {
           pname = "OpenGL";
           version = "3.0.2.2";
           sha256 = "4cba40fe8eecee67c8251556b4c05d9e98256c11d49c20e914f8232bfae67da7";
           libraryHaskellDepends = [
             base bytestring containers GLURaw ObjectName OpenGLRaw StateVar
             text transformers
           ];
           doHaddock = false;
           doCheck = false;
           homepage = "http://www.haskell.org/haskellwiki/Opengl";
           description = "A binding for the OpenGL graphics system";
           license = stdenv.lib.licenses.bsd3;
         }) {};
      "OpenGLRaw" = callPackage
        ({ mkDerivation, base, bytestring, containers, fixed, half, libGL
         , stdenv, text, transformers
         }:
         mkDerivation {
           pname = "OpenGLRaw";
           version = "3.3.1.0";
           sha256 = "6b0745f6d421f658b57c13bfdbae014c0aa6871a98e11e98908d4a04461f1cf5";
           libraryHaskellDepends = [
             base bytestring containers fixed half text transformers
           ];
           librarySystemDepends = [ libGL ];
           doHaddock = false;
           doCheck = false;
           homepage = "http://www.haskell.org/haskellwiki/Opengl";
           description = "A raw binding for the OpenGL graphics system";
           license = stdenv.lib.licenses.bsd3;
         }) {inherit (pkgs) libGL;};
      "ParsecTools" = callPackage
        ({ mkDerivation, base, parsec, stdenv }:
         mkDerivation {
           pname = "ParsecTools";
           version = "0.0.2.0";
           sha256 = "ef4843353127aa3e6f6ab0aece9f4245225d375802921e151a1751d797857a87";
           libraryHaskellDepends = [ base parsec ];
           doHaddock = false;
           doCheck = false;
           description = "Parsec combinators for more complex objects";
           license = stdenv.lib.licenses.gpl3;
         }) {};
      "QuasiText" = callPackage
        ({ mkDerivation, attoparsec, base, haskell-src-meta, stdenv
         , template-haskell, text, th-lift-instances
         }:
         mkDerivation {
           pname = "QuasiText";
           version = "0.1.2.6";
           sha256 = "e801d269e25263645ee66fc090040fe9b9c8a8e5bf10485801dd7a5a30e0f119";
           libraryHaskellDepends = [
             attoparsec base haskell-src-meta template-haskell text
             th-lift-instances
           ];
           doHaddock = false;
           doCheck = false;
           homepage = "https://github.com/mikeplus64/QuasiText";
           description = "A QuasiQuoter for Text";
           license = stdenv.lib.licenses.bsd3;
         }) {};
      "QuickCheck" = callPackage
        ({ mkDerivation, base, containers, deepseq, random, stdenv
         , template-haskell, tf-random, transformers
         }:
         mkDerivation {
           pname = "QuickCheck";
           version = "2.11.3";
           sha256 = "488c5652139da0bac8b3e7d76f11320ded298549e62db530938bfee9ca981876";
           revision = "1";
           editedCabalFile = "1z9fldzrlnvvzrcv4jy7zrhrrcsb2aq7y6jsn3qmisb6hicfppb7";
           libraryHaskellDepends = [
             base containers deepseq random template-haskell tf-random
             transformers
           ];
           doHaddock = false;
           doCheck = false;
           homepage = "https://github.com/nick8325/quickcheck";
           description = "Automatic testing of Haskell programs";
           license = stdenv.lib.licenses.bsd3;
         }) {};
      "RSA" = callPackage
        ({ mkDerivation, base, binary, bytestring, crypto-api
         , crypto-pubkey-types, SHA, stdenv
         }:
         mkDerivation {
           pname = "RSA";
           version = "2.3.0";
           sha256 = "eee76dc7f9dd2d2cdeb014af728ff56f2f5d2908212bd3bb8c5e89f5c6485333";
           libraryHaskellDepends = [
             base binary bytestring crypto-api crypto-pubkey-types SHA
           ];
           doHaddock = false;
           doCheck = false;
           description = "Implementation of RSA, using the padding schemes of PKCS#1 v2.1.";
           license = stdenv.lib.licenses.bsd3;
         }) {};
      "Rasterific" = callPackage
        ({ mkDerivation, base, bytestring, containers, dlist, FontyFruity
         , free, JuicyPixels, mtl, primitive, stdenv, transformers, vector
         , vector-algorithms
         }:
         mkDerivation {
           pname = "Rasterific";
           version = "0.7.4";
           sha256 = "986efe76aad9a8530d4826b8c0f8034866f37b8d645ea34a9849edca9357c58d";
           libraryHaskellDepends = [
             base bytestring containers dlist FontyFruity free JuicyPixels mtl
             primitive transformers vector vector-algorithms
           ];
           doHaddock = false;
           doCheck = false;
           description = "A pure haskell drawing engine";
           license = stdenv.lib.licenses.bsd3;
         }) {};
      "RefSerialize" = callPackage
        ({ mkDerivation, base, binary, bytestring, containers, hashtables
         , stdenv, stringsearch
         }:
         mkDerivation {
           pname = "RefSerialize";
           version = "0.4.0";
           sha256 = "05b25eb1ab943d96119aa2acca678fc8f194c3411af521e3835f4de5c752bbb2";
           libraryHaskellDepends = [
             base binary bytestring containers hashtables stringsearch
           ];
           doHaddock = false;
           doCheck = false;
           description = "Write to and read from ByteStrings maintaining internal memory references";
           license = stdenv.lib.licenses.bsd3;
         }) {};
      "SCalendar" = callPackage
        ({ mkDerivation, base, containers, stdenv, text, time }:
         mkDerivation {
           pname = "SCalendar";
           version = "1.1.0";
           sha256 = "4971bf6df45953434088ba50d0e17dcc49a0e4c2dd37ad06385c1f87d87b348d";
           libraryHaskellDepends = [ base containers text time ];
           doHaddock = false;
           doCheck = false;
           homepage = "https://www.researchgate.net/publication/311582722_Method_of_Managing_Resources_in_a_Telecommunication_Network_or_a_Computing_System";
           description = "This is a library for handling calendars and resource availability based on the \"top-nodes algorithm\" and set operations";
           license = stdenv.lib.licenses.mit;
         }) {};
      "SHA" = callPackage
        ({ mkDerivation, array, base, binary, bytestring, stdenv }:
         mkDerivation {
           pname = "SHA";
           version = "1.6.4.4";
           sha256 = "6bd950df6b11a3998bb1452d875d2da043ee43385459afc5f16d471d25178b44";
           isLibrary = true;
           isExecutable = true;
           libraryHaskellDepends = [ array base binary bytestring ];
           doHaddock = false;
           doCheck = false;
           description = "Implementations of the SHA suite of message digest functions";
           license = stdenv.lib.licenses.bsd3;
         }) {};
      "STMonadTrans" = callPackage
        ({ mkDerivation, array, base, mtl, stdenv }:
         mkDerivation {
           pname = "STMonadTrans";
           version = "0.4.3";
           sha256 = "574fd56cf74036c20d00a09d815659dbbb0ae51c8103d00c93cd9558ad3322db";
           revision = "1";
           editedCabalFile = "09kqrv9a4yhsdpix49h9qjw0j2fhxrgkjnfrnyxg1nspmqrvl50m";
           libraryHaskellDepends = [ array base mtl ];
           doHaddock = false;
           doCheck = false;
           description = "A monad transformer version of the ST monad";
           license = stdenv.lib.licenses.bsd3;
         }) {};
      "SVGFonts" = callPackage
        ({ mkDerivation, attoparsec, base, blaze-markup, blaze-svg
         , bytestring, cereal, cereal-vector, containers, data-default-class
         , diagrams-core, diagrams-lib, directory, parsec, split, stdenv
         , text, vector, xml
         }:
         mkDerivation {
           pname = "SVGFonts";
           version = "1.7";
           sha256 = "da3ccd65e0963473df035f4543b56dfc84b45edca540990050e5de444fa431cd";
           revision = "1";
           editedCabalFile = "1w687f4lk4l07wqgldhpg7ycid0fs099x8vrylcxqdgfrzmm04dg";
           enableSeparateDataOutput = true;
           libraryHaskellDepends = [
             attoparsec base blaze-markup blaze-svg bytestring cereal
             cereal-vector containers data-default-class diagrams-core
             diagrams-lib directory parsec split text vector xml
           ];
           doHaddock = false;
           doCheck = false;
           description = "Fonts from the SVG-Font format";
           license = stdenv.lib.licenses.bsd3;
         }) {};
      "SafeSemaphore" = callPackage
        ({ mkDerivation, base, containers, stdenv, stm }:
         mkDerivation {
           pname = "SafeSemaphore";
           version = "0.10.1";
           sha256 = "21e5b737a378cae9e1faf85cab015316d4c84d4b37e6d9d202111cef8c4cef66";
           revision = "1";
           editedCabalFile = "1k61gqgfh6n3sj8ni8sfvpcm39nqc2msjfxk2pgmhfabvv48w5hv";
           libraryHaskellDepends = [ base containers stm ];
           doHaddock = false;
           doCheck = false;
           homepage = "https://github.com/ChrisKuklewicz/SafeSemaphore";
           description = "Much safer replacement for QSemN, QSem, and SampleVar";
           license = stdenv.lib.licenses.bsd3;
         }) {};
      "SegmentTree" = callPackage
        ({ mkDerivation, base, stdenv }:
         mkDerivation {
           pname = "SegmentTree";
           version = "0.3";
           sha256 = "6188c1b1276d7fa0391098a563df73dd522d20b57dc5321fe3418a9e3ca84fc1";
           isLibrary = true;
           isExecutable = true;
           libraryHaskellDepends = [ base ];
           doHaddock = false;
           doCheck = false;
           description = "Data structure for querying the set (or count) of intervals covering given point";
           license = stdenv.lib.licenses.bsd3;
         }) {};
      "ShellCheck" = callPackage
        ({ mkDerivation, aeson, base, bytestring, Cabal, containers
         , directory, mtl, parsec, process, QuickCheck, regex-tdfa, stdenv
         }:
         mkDerivation {
           pname = "ShellCheck";
           version = "0.5.0";
           sha256 = "2b9430736f48de17a60c035546a6a969c14392521bec30119e1c869017d3307c";
           isLibrary = true;
           isExecutable = true;
           setupHaskellDepends = [ base Cabal process ];
           libraryHaskellDepends = [
             aeson base bytestring containers directory mtl parsec process
             QuickCheck regex-tdfa
           ];
           executableHaskellDepends = [
             aeson base bytestring containers directory mtl parsec QuickCheck
             regex-tdfa
           ];
           doHaddock = false;
           doCheck = false;
           homepage = "https://www.shellcheck.net/";
           description = "Shell script analysis tool";
           license = stdenv.lib.licenses.gpl3;
         }) {};
      "Spintax" = callPackage
        ({ mkDerivation, attoparsec, base, extra, mtl, mwc-random, stdenv
         , text
         }:
         mkDerivation {
           pname = "Spintax";
           version = "0.3.3";
           sha256 = "21df2193bf1216d55a0d43691182125993eeadc6f097eaf5eb995c23f2016b13";
           libraryHaskellDepends = [
             attoparsec base extra mtl mwc-random text
           ];
           doHaddock = false;
           doCheck = false;
           homepage = "https://github.com/MichelBoucey/spintax";
           description = "Random text generation based on spintax";
           license = stdenv.lib.licenses.bsd3;
         }) {};
      "Spock" = callPackage
        ({ mkDerivation, base, base64-bytestring, bytestring, containers
         , cryptonite, focus, hashable, http-types, hvect, list-t
         , monad-control, mtl, reroute, resource-pool, resourcet, Spock-core
         , stdenv, stm, stm-containers, text, time, transformers
         , transformers-base, unordered-containers, vault, wai
         }:
         mkDerivation {
           pname = "Spock";
           version = "0.13.0.0";
           sha256 = "8a73a3ddeb8982cd7c10f650e9adbfec2f6abac8da3a912bdb3025dc8d731ad0";
           libraryHaskellDepends = [
             base base64-bytestring bytestring containers cryptonite focus
             hashable http-types hvect list-t monad-control mtl reroute
             resource-pool resourcet Spock-core stm stm-containers text time
             transformers transformers-base unordered-containers vault wai
           ];
           doHaddock = false;
           doCheck = false;
           homepage = "https://www.spock.li";
           description = "Another Haskell web framework for rapid development";
           license = stdenv.lib.licenses.bsd3;
         }) {};
      "Spock-core" = callPackage
        ({ mkDerivation, aeson, base, base64-bytestring, bytestring
         , case-insensitive, containers, cookie, directory, hashable
         , http-api-data, http-types, hvect, monad-control, mtl, old-locale
         , reroute, resourcet, stdenv, stm, superbuffer, text, time
         , transformers, transformers-base, unordered-containers, vault, wai
         , wai-extra, warp
         }:
         mkDerivation {
           pname = "Spock-core";
           version = "0.13.0.0";
           sha256 = "5ecabd42a48c1930ca37f9ec02192b7cdf2cf2f49aba5b4d7f7a0d8d25d85162";
           libraryHaskellDepends = [
             aeson base base64-bytestring bytestring case-insensitive containers
             cookie directory hashable http-api-data http-types hvect
             monad-control mtl old-locale reroute resourcet stm superbuffer text
             time transformers transformers-base unordered-containers vault wai
             wai-extra warp
           ];
           doHaddock = false;
           doCheck = false;
           homepage = "https://www.spock.li";
           description = "Another Haskell web framework for rapid development";
           license = stdenv.lib.licenses.bsd3;
         }) {};
      "StateVar" = callPackage
        ({ mkDerivation, base, stdenv, stm, transformers }:
         mkDerivation {
           pname = "StateVar";
           version = "1.1.1.1";
           sha256 = "eb6436516ab2d5e3d3e070b5a1595c4dceea760a58a9cc8d23dad5f6008f2223";
           libraryHaskellDepends = [ base stm transformers ];
           doHaddock = false;
           doCheck = false;
           homepage = "https://github.com/haskell-opengl/StateVar";
           description = "State variables";
           license = stdenv.lib.licenses.bsd3;
         }) {};
      "Strafunski-StrategyLib" = callPackage
        ({ mkDerivation, base, directory, mtl, stdenv, syb, transformers }:
         mkDerivation {
           pname = "Strafunski-StrategyLib";
           version = "5.0.1.0";
           sha256 = "a018c7420289a381d2b491a753f685b9d691be07cea99855cc5c8e05d5a9a295";
           revision = "1";
           editedCabalFile = "1hngxq1f7fybg6ixkdhmvgsw608mhnxkwbw04ql5zspcfl78v6l2";
           libraryHaskellDepends = [ base directory mtl syb transformers ];
           doHaddock = false;
           doCheck = false;
           description = "Library for strategic programming";
           license = stdenv.lib.licenses.bsd3;
         }) {};
      "TCache" = callPackage
        ({ mkDerivation, base, bytestring, containers, directory
         , hashtables, mtl, old-time, RefSerialize, stdenv, stm, text
         }:
         mkDerivation {
           pname = "TCache";
           version = "0.12.1";
           sha256 = "f134b45fcdd127fa1a4214f01d44dc34e994fed137cec63f4c4ea632363ab7bd";
           libraryHaskellDepends = [
             base bytestring containers directory hashtables mtl old-time
             RefSerialize stm text
           ];
           doHaddock = false;
           doCheck = false;
           description = "A Transactional cache with user-defined persistence";
           license = stdenv.lib.licenses.bsd3;
         }) {};
      "TypeCompose" = callPackage
        ({ mkDerivation, base, base-orphans, stdenv }:
         mkDerivation {
           pname = "TypeCompose";
           version = "0.9.14";
           sha256 = "56034f7917c7464e3be93754c36302d91b8d750f84f6ed7af146f94c4fd05a57";
           revision = "1";
           editedCabalFile = "1pxg6az5vkl0zvs3zdvvvnhxqawd9fkkd44jmzzzyyibppgni6x4";
           libraryHaskellDepends = [ base base-orphans ];
           doHaddock = false;
           doCheck = false;
           homepage = "https://github.com/conal/TypeCompose";
           description = "Type composition classes & instances";
           license = stdenv.lib.licenses.bsd3;
         }) {};
      "ViennaRNAParser" = callPackage
        ({ mkDerivation, base, parsec, ParsecTools, process, stdenv
         , transformers
         }:
         mkDerivation {
           pname = "ViennaRNAParser";
           version = "1.3.3";
           sha256 = "7ee941d106b8b0c57e1ca5104d19b94215721e4a7b8aeb53fa353d246efbaefe";
           libraryHaskellDepends = [
             base parsec ParsecTools process transformers
           ];
           doHaddock = false;
           doCheck = false;
           description = "Libary for parsing ViennaRNA package output";
           license = stdenv.lib.licenses.gpl3;
         }) {};
      "Win32-notify" = callPackage
        ({ mkDerivation, base, containers, directory, stdenv, Win32 }:
         mkDerivation {
           pname = "Win32-notify";
           version = "0.3.0.3";
           sha256 = "0c21dbe06cb1ce3b3e5f1aace0b7ee359b36e7cb057f8fe2c28c943150044116";
           isLibrary = true;
           isExecutable = true;
           libraryHaskellDepends = [ base containers directory Win32 ];
           doHaddock = false;
           doCheck = false;
           description = "A binding to part of the Win32 library for file notification";
           license = stdenv.lib.licenses.bsd3;
         }) {};
      "X11" = callPackage
        ({ mkDerivation, base, data-default, libX11, libXext, libXinerama
         , libXrandr, libXrender, libXScrnSaver, stdenv
         }:
         mkDerivation {
           pname = "X11";
           version = "1.9";
           sha256 = "10138e863d8c6f860aad1755a6f1a36949cc02d83e5afacf6677fb3999f10db9";
           libraryHaskellDepends = [ base data-default ];
           librarySystemDepends = [
             libX11 libXext libXinerama libXrandr libXrender libXScrnSaver
           ];
           doHaddock = false;
           doCheck = false;
           homepage = "https://github.com/xmonad/X11";
           description = "A binding to the X11 graphics library";
           license = stdenv.lib.licenses.bsd3;
         }) {inherit (pkgs.xorg) libXScrnSaver; inherit (pkgs.xorg) libXext; 
inherit (pkgs.xorg) libXinerama; inherit (pkgs.xorg) libXrender;};
      "X11-xft" = callPackage
        ({ mkDerivation, base, libXft, stdenv, utf8-string, X11 }:
         mkDerivation {
           pname = "X11-xft";
           version = "0.3.1";
           sha256 = "4eba3fee62570e06447654030a62fb55f19587884bc2cef77a9c3b2c3458f8d1";
           libraryHaskellDepends = [ base utf8-string X11 ];
           libraryPkgconfigDepends = [ libXft ];
           doHaddock = false;
           doCheck = false;
           description = "Bindings to the Xft, X Free Type interface library, and some Xrender parts";
           license = "LGPL";
         }) {};
      "Xauth" = callPackage
        ({ mkDerivation, base, libXau, stdenv }:
         mkDerivation {
           pname = "Xauth";
           version = "0.1";
           sha256 = "ba332dea9ec152b3f676d22461eee81a657e16987c3dfb8249e9dbe0cda56ed7";
           libraryHaskellDepends = [ base ];
           libraryPkgconfigDepends = [ libXau ];
           doHaddock = false;
           doCheck = false;
           description = "A binding to the X11 authentication library";
           license = stdenv.lib.licenses.bsd3;
         }) {};
      "abstract-deque" = callPackage
        ({ mkDerivation, array, base, containers, random, stdenv, time }:
         mkDerivation {
           pname = "abstract-deque";
           version = "0.3";
           sha256 = "09aa10f38193a8275a7791b92a4f3a7192a304874637e2a35c897dde25d75ca2";
           libraryHaskellDepends = [ array base containers random time ];
           doHaddock = false;
           doCheck = false;
           homepage = "https://github.com/rrnewton/haskell-lockfree/wiki";
           description = "Abstract, parameterized interface to mutable Deques";
           license = stdenv.lib.licenses.bsd3;
         }) {};
      "abstract-deque-tests" = callPackage
        ({ mkDerivation, abstract-deque, array, base, containers, HUnit
         , random, stdenv, test-framework, test-framework-hunit, time
         }:
         mkDerivation {
           pname = "abstract-deque-tests";
           version = "0.3";
           sha256 = "5f17fb4cc26559f81c777f494622907e8927181175eaa172fb6adbf14b2feba5";
           libraryHaskellDepends = [
             abstract-deque array base containers HUnit random test-framework
             test-framework-hunit time
           ];
           doHaddock = false;
           doCheck = false;
           homepage = "https://github.com/rrnewton/haskell-lockfree/wiki";
           description = "A test-suite for any queue or double-ended queue satisfying an interface";
           license = stdenv.lib.licenses.bsd3;
         }) {};
      "abstract-par" = callPackage
        ({ mkDerivation, base, deepseq, stdenv }:
         mkDerivation {
           pname = "abstract-par";
           version = "0.3.3";
           sha256 = "248a8739bd902462cb16755b690b55660e196e58cc7e6ef8157a72c2a3d5d860";
           libraryHaskellDepends = [ base deepseq ];
           doHaddock = false;
           doCheck = false;
           homepage = "https://github.com/simonmar/monad-par";
           description = "Type classes generalizing the functionality of the 'monad-par' library";
           license = stdenv.lib.licenses.bsd3;
         }) {};
      "accuerr" = callPackage
        ({ mkDerivation, base, bifunctors, lens, semigroups, stdenv }:
         mkDerivation {
           pname = "accuerr";
           version = "0.2.0.2";
           sha256 = "4f6a8230d2ad3bc274dea234208ce4f5282e2d9413a5da1f5505fc55a2fa9a36";
           libraryHaskellDepends = [ base bifunctors lens semigroups ];
           doHaddock = false;
           doCheck = false;
           homepage = "http://www.github.com/massysett/accuerr";
           description = "Data type like Either but with accumulating error type";
           license = stdenv.lib.licenses.bsd3;
         }) {};
      "ace" = callPackage
        ({ mkDerivation, attoparsec, base, blaze-html, blaze-markup
         , data-default, parsec, stdenv, text
         }:
         mkDerivation {
           pname = "ace";
           version = "0.6";
           sha256 = "d3472b659d26cf7ea9afa207ec24ac0314598de997722e636e9bfa24b3900738";
           libraryHaskellDepends = [
             attoparsec base blaze-html blaze-markup data-default parsec text
           ];
           doHaddock = false;
           doCheck = false;
           description = "Attempto Controlled English parser and printer";
           license = stdenv.lib.licenses.bsd3;
         }) {};
      "action-permutations" = callPackage
        ({ mkDerivation, base, stdenv }:
         mkDerivation {
           pname = "action-permutations";
           version = "0.0.0.1";
           sha256 = "a419ee59f996e5305afd96336a561a9fcf26844362eaa32ab6b747a8f9fd1466";
           libraryHaskellDepends = [ base ];
           doHaddock = false;
           doCheck = false;
           description = "Execute a set of actions (e.g. parsers) in each possible order";
           license = stdenv.lib.licenses.bsd3;
         }) {};
      "active" = callPackage
        ({ mkDerivation, base, lens, linear, semigroupoids, semigroups
         , stdenv, vector
         }:
         mkDerivation {
           pname = "active";
           version = "0.2.0.13";
           sha256 = "5d9a141d58bcefbf699ed233a22309ded671c25ed64bcee11a663d00731280fb";
           revision = "8";
           editedCabalFile = "1j771jblfaygc3qf8iaw9b87yrqxhkq79mdi9zyhvlr2vcac362s";
           libraryHaskellDepends = [
             base lens linear semigroupoids semigroups vector
           ];
           doHaddock = false;
           doCheck = false;
           description = "Abstractions for animation";
           license = stdenv.lib.licenses.bsd3;
         }) {};
      "ad" = callPackage
        ({ mkDerivation, array, base, Cabal, cabal-doctest, comonad
         , containers, data-reify, erf, free, nats, reflection, semigroups
         , stdenv, transformers
         }:
         mkDerivation {
           pname = "ad";
           version = "4.3.5";
           sha256 = "9c5e754b1f0ff83490bcc30f5dfa8504de5a34ab8f7be03ac232882940dc8d60";
           revision = "5";
           editedCabalFile = "0yzyfqhsafzaqzj8wmjrj5ghm6jwbxya3wxc9sjl59j9q20jc4nq";
           setupHaskellDepends = [ base Cabal cabal-doctest ];
           libraryHaskellDepends = [
             array base comonad containers data-reify erf free nats reflection
             semigroups transformers
           ];
           doHaddock = false;
           doCheck = false;
           homepage = "http://github.com/ekmett/ad";
           description = "Automatic Differentiation";
           license = stdenv.lib.licenses.bsd3;
         }) {};
      "adjunctions" = callPackage
        ({ mkDerivation, array, base, comonad, containers, contravariant
         , distributive, free, mtl, profunctors, semigroupoids, semigroups
         , stdenv, tagged, transformers, transformers-compat, void
         }:
         mkDerivation {
           pname = "adjunctions";
           version = "4.4";
           sha256 = "507c2ef55337ae61c805f8cbc1213dfd7d2b85187342675d662254b8d8a16ae9";
           revision = "2";
           editedCabalFile = "1yfsjx7dqikg3hvld7i91xfsg5lawmr5980lvfd794sybmgxsf17";
           libraryHaskellDepends = [
             array base comonad containers contravariant distributive free mtl
             profunctors semigroupoids semigroups tagged transformers
             transformers-compat void
           ];
           doHaddock = false;
           doCheck = false;
           homepage = "http://github.com/ekmett/adjunctions/";
           description = "Adjunctions and representable functors";
           license = stdenv.lib.licenses.bsd3;
         }) {};
      "adler32" = callPackage
        ({ mkDerivation, base, bytestring, stdenv, zlib }:
         mkDerivation {
           pname = "adler32";
           version = "0.1.2.0";
           sha256 = "26b43c9f389f45ed792698ea4880d24ba56ab61c6f7cae51e582a05e0b5866a4";
           libraryHaskellDepends = [ base bytestring ];
           librarySystemDepends = [ zlib ];
           doHaddock = false;
           doCheck = false;
           homepage = "https://github.com/redneb/hs-adler32";
           description = "An implementation of Adler-32, supporting rolling checksum operation";
           license = stdenv.lib.licenses.bsd3;
         }) {inherit (pkgs) zlib;};
      "aern2-mp" = callPackage
        ({ mkDerivation, base, convertible, hspec, integer-logarithms, lens
         , mixed-types-num, QuickCheck, regex-tdfa, rounded, stdenv
         , template-haskell
         }:
         mkDerivation {
           pname = "aern2-mp";
           version = "0.1.3.1";
           sha256 = "758b01846bf21c90aad334867fb29e3115d4b174ac68bd9286ab7ddc7467d1bf";
           libraryHaskellDepends = [
             base convertible hspec integer-logarithms lens mixed-types-num
             QuickCheck regex-tdfa rounded template-haskell
           ];
           doHaddock = false;
           doCheck = false;
           homepage = "https://github.com/michalkonecny/aern2";
           description = "Multi-precision ball (interval) arithmetic";
           license = stdenv.lib.licenses.bsd3;
         }) {};
      "aern2-real" = callPackage
        ({ mkDerivation, aern2-mp, aeson, base, bytestring, containers
         , convertible, hspec, lens, mixed-types-num, QuickCheck, random
         , stdenv, stm, transformers
         }:
         mkDerivation {
           pname = "aern2-real";
           version = "0.1.1.0";
           sha256 = "25e0428536b401d5a06fd3b169025747663359595b3cfcdb56a042be81d002eb";
           isLibrary = true;
           isExecutable = true;
           libraryHaskellDepends = [
             aern2-mp aeson base bytestring containers convertible hspec lens
             mixed-types-num QuickCheck stm transformers
           ];
           executableHaskellDepends = [
             aern2-mp base mixed-types-num QuickCheck random
           ];
           doHaddock = false;
           doCheck = false;
           homepage = "https://github.com/michalkonecny/aern2";
           description = "Exact real numbers via Cauchy sequences and MPFR";
           license = stdenv.lib.licenses.bsd3;
         }) {};
      "aeson" = callPackage
        ({ mkDerivation, attoparsec, base, base-compat, bytestring
         , containers, deepseq, dlist, ghc-prim, hashable, scientific
         , stdenv, tagged, template-haskell, text, th-abstraction, time
         , time-locale-compat, unordered-containers, uuid-types, vector
         }:
         mkDerivation {
           pname = "aeson";
           version = "1.3.1.1";
           sha256 = "843f302f8186c1ee6e0d9c0630588e4c7fc0f41763333a2d0d4b6f07087a31c4";
           libraryHaskellDepends = [
             attoparsec base base-compat bytestring containers deepseq dlist
             ghc-prim hashable scientific tagged template-haskell text
             th-abstraction time time-locale-compat unordered-containers
             uuid-types vector
           ];
           doHaddock = false;
           doCheck = false;
           homepage = "https://github.com/bos/aeson";
           description = "Fast JSON parsing and encoding";
           license = stdenv.lib.licenses.bsd3;
         }) {};
      "aeson-attoparsec" = callPackage
        ({ mkDerivation, aeson, attoparsec, base, stdenv }:
         mkDerivation {
           pname = "aeson-attoparsec";
           version = "0.0.0";
           sha256 = "a5868390477938b3086e820f4a432f9d6a3972454f561fc386520634eec72104";
           libraryHaskellDepends = [ aeson attoparsec base ];
           doHaddock = false;
           doCheck = false;
           homepage = "https://github.com/athanclark/aeson-attoparsec#readme";
           description = "Embed an Attoparsec text parser into an Aeson parser";
           license = stdenv.lib.licenses.bsd3;
         }) {};
      "aeson-better-errors" = callPackage
        ({ mkDerivation, aeson, base, bytestring, dlist, mtl, scientific
         , stdenv, text, transformers, transformers-compat
         , unordered-containers, vector, void
         }:
         mkDerivation {
           pname = "aeson-better-errors";
           version = "0.9.1.0";
           sha256 = "68f001bf055ec7b755d91019f2a0ef136307d157a231acddad6b4cc561f67327";
           libraryHaskellDepends = [
             aeson base bytestring dlist mtl scientific text transformers
             transformers-compat unordered-containers vector void
           ];
           doHaddock = false;
           doCheck = false;
           homepage = "https://github.com/hdgarrood/aeson-better-errors";
           description = "Better error messages when decoding JSON values";
           license = stdenv.lib.licenses.mit;
         }) {};
      "aeson-casing" = callPackage
        ({ mkDerivation, aeson, base, stdenv }:
         mkDerivation {
           pname = "aeson-casing";
           version = "0.1.0.5";
           sha256 = "cfec563dc6822f035858a7190153d8818c200be565806b43b70f198bf5410577";
           libraryHaskellDepends = [ aeson base ];
           doHaddock = false;
           doCheck = false;
           description = "Tools to change the formatting of field names in Aeson instances";
           license = stdenv.lib.licenses.mit;
         }) {};
      "aeson-compat" = callPackage
        ({ mkDerivation, aeson, attoparsec, attoparsec-iso8601, base
         , base-compat, bytestring, containers, exceptions, hashable
         , scientific, stdenv, tagged, text, time, time-locale-compat
         , unordered-containers, vector
         }:
         mkDerivation {
           pname = "aeson-compat";
           version = "0.3.9";
           sha256 = "e043941ba761c13a3854fc087521b864b56b2df874154e42aedb67b2a77f23c8";
           libraryHaskellDepends = [
             aeson attoparsec attoparsec-iso8601 base base-compat bytestring
             containers exceptions hashable scientific tagged text time
             time-locale-compat unordered-containers vector
           ];
           doHaddock = false;
           doCheck = false;
           homepage = "https://github.com/phadej/aeson-compat#readme";
           description = "Compatibility layer for aeson";
           license = stdenv.lib.licenses.bsd3;
         }) {};
      "aeson-diff" = callPackage
        ({ mkDerivation, aeson, base, bytestring, edit-distance-vector
         , hashable, mtl, optparse-applicative, scientific, stdenv, text
         , unordered-containers, vector
         }:
         mkDerivation {
           pname = "aeson-diff";
           version = "1.1.0.5";
           sha256 = "61d9dd60b6c19dd5aa350b85083ebed3eab8d8611893db1279e55e43d7c7fbcf";
           revision = "1";
           editedCabalFile = "0a29nph4a1ny365nhsxlm73mk6zgaam4sfx6knzqjy8dxp1gkj48";
           isLibrary = true;
           isExecutable = true;
           libraryHaskellDepends = [
             aeson base bytestring edit-distance-vector hashable mtl scientific
             text unordered-containers vector
           ];
           executableHaskellDepends = [
             aeson base bytestring optparse-applicative text
           ];
           doHaddock = false;
           doCheck = false;
           homepage = "https://github.com/thsutton/aeson-diff";
           description = "Extract and apply patches to JSON documents";
           license = stdenv.lib.licenses.bsd3;
         }) {};
      "aeson-extra" = callPackage
        ({ mkDerivation, aeson, aeson-compat, attoparsec
         , attoparsec-iso8601, base, base-compat-batteries, bytestring
         , containers, deepseq, exceptions, hashable, parsec
         , recursion-schemes, scientific, stdenv, template-haskell, text
         , these, time, unordered-containers, vector
         }:
         mkDerivation {
           pname = "aeson-extra";
           version = "0.4.1.1";
           sha256 = "d48a65d976cbf496c8e5e9c927118ffcc878d6a83adf2fc9cebd418186d6fdf8";
           revision = "4";
           editedCabalFile = "0ja5vr9w22wyknkjyl7w43frdfdfnxphvrai1b18lhinjqcd9bl5";
           libraryHaskellDepends = [
             aeson aeson-compat attoparsec attoparsec-iso8601 base
             base-compat-batteries bytestring containers deepseq exceptions
             hashable parsec recursion-schemes scientific template-haskell text
             these time unordered-containers vector
           ];
           doHaddock = false;
           doCheck = false;
           homepage = "https://github.com/phadej/aeson-extra#readme";
           description = "Extra goodies for aeson";
           license = stdenv.lib.licenses.bsd3;
         }) {};
      "aeson-generic-compat" = callPackage
        ({ mkDerivation, aeson, base, stdenv }:
         mkDerivation {
           pname = "aeson-generic-compat";
           version = "0.0.1.3";
           sha256 = "a6b6ca511483bc9de72c2c640a9f871fe8d329811fb8b87d0a664c4394e223cf";
           libraryHaskellDepends = [ aeson base ];
           doHaddock = false;
           doCheck = false;
           description = "Compatible generic class names of Aeson";
           license = stdenv.lib.licenses.bsd3;
         }) {};
      "aeson-iproute" = callPackage
        ({ mkDerivation, aeson, base, iproute, stdenv, text
         , unordered-containers
         }:
         mkDerivation {
           pname = "aeson-iproute";
           version = "0.2";
           sha256 = "ee4d53338bfdc4a6ce0039dea24e797a0ff1e22c312b31be2e73ddc0bddf268f";
           libraryHaskellDepends = [
             aeson base iproute text unordered-containers
           ];
           doHaddock = false;
           doCheck = false;
           homepage = "https://github.com/greydot/aeson-iproute";
           description = "Aeson instances for iproute types";
           license = stdenv.lib.licenses.bsd3;
         }) {};
      "aeson-picker" = callPackage
        ({ mkDerivation, aeson, base, lens, lens-aeson, stdenv, text }:
         mkDerivation {
           pname = "aeson-picker";
           version = "0.1.0.4";
           sha256 = "b20e23905c395d7b61fce6c5f6343758e3753a2dbee61800d3e15e753ac7c452";
           libraryHaskellDepends = [ aeson base lens lens-aeson text ];
           doHaddock = false;
           doCheck = false;
           homepage = "https://github.com/ozzzzz/aeson-picker#readme";
           description = "Tiny library to get fields from JSON format";
           license = stdenv.lib.licenses.bsd3;
         }) {};
      "aeson-pretty" = callPackage
        ({ mkDerivation, aeson, attoparsec, base, base-compat, bytestring
         , cmdargs, scientific, stdenv, text, unordered-containers, vector
         }:
         mkDerivation {
           pname = "aeson-pretty";
           version = "0.8.7";
           sha256 = "c1c1ecc5e3abd004a6c4c256ee6f61da2a43d7f1452ffa391dee250df43b27d5";
           isLibrary = true;
           isExecutable = true;
           libraryHaskellDepends = [
             aeson base base-compat bytestring scientific text
             unordered-containers vector
           ];
           executableHaskellDepends = [
             aeson attoparsec base bytestring cmdargs
           ];
           doHaddock = false;
           doCheck = false;
           homepage = "http://github.com/informatikr/aeson-pretty";
           description = "JSON pretty-printing library and command-line tool";
           license = stdenv.lib.licenses.bsd3;
         }) {};
      "aeson-qq" = callPackage
        ({ mkDerivation, aeson, attoparsec, base, base-compat
         , haskell-src-meta, parsec, scientific, stdenv, template-haskell
         , text, vector
         }:
         mkDerivation {
           pname = "aeson-qq";
           version = "0.8.2";
           sha256 = "6db252c94601efcb1ce395de0084ccf931a3525339ccdca011a740e7b11cc152";
           libraryHaskellDepends = [
             aeson attoparsec base base-compat haskell-src-meta parsec
             scientific template-haskell text vector
           ];
           doHaddock = false;
           doCheck = false;
           homepage = "https://github.com/sol/aeson-qq#readme";
           description = "JSON quasiquoter for Haskell";
           license = stdenv.lib.licenses.mit;
         }) {};
      "aeson-typescript" = callPackage
        ({ mkDerivation, aeson, base, containers, interpolate, mtl, stdenv
         , template-haskell, text, th-abstraction, unordered-containers
         }:
         mkDerivation {
           pname = "aeson-typescript";
           version = "0.1.1.0";
           sha256 = "77a3b10384383f0188feef57015a896e89bac9882df4c83bed765f70b77aa46b";
           revision = "1";
           editedCabalFile = "1y5baadwfpyszd78dfbcln93ypg7ai6qvbdz7r95ili8p0vwikbk";
           libraryHaskellDepends = [
             aeson base containers interpolate mtl template-haskell text
             th-abstraction unordered-containers
           ];
           doHaddock = false;
           doCheck = false;
           homepage = "https://github.com/codedownio/aeson-typescript#readme";
           description = "Generate TypeScript definition files from your ADTs";
           license = stdenv.lib.licenses.bsd3;
         }) {};
      "aeson-utils" = callPackage
        ({ mkDerivation, aeson, attoparsec, base, bytestring, scientific
         , stdenv, text
         }:
         mkDerivation {
           pname = "aeson-utils";
           version = "0.3.0.2";
           sha256 = "71814b1be8849f945395eb81217a2ad464f2943134c50c09afd8a3126add4b1f";
           revision = "7";
           editedCabalFile = "0lnlmsn5imbapdhbza1175wm04ynn1w75llkhlk1akpanx1dnd15";
           libraryHaskellDepends = [
             aeson attoparsec base bytestring scientific text
           ];
           doHaddock = false;
           doCheck = false;
           description = "Utilities for working with Aeson";
           license = stdenv.lib.licenses.bsd3;
         }) {};
      "aeson-yak" = callPackage
        ({ mkDerivation, aeson, base, stdenv }:
         mkDerivation {
           pname = "aeson-yak";
           version = "0.1.1.3";
           sha256 = "af4355bc315a152592e9c06f5cc41bdb5ce7b236d85fe572a292c6bac02faa74";
           libraryHaskellDepends = [ aeson base ];
           doHaddock = false;
           doCheck = false;
           homepage = "https://github.com/tejon/aeson-yak";
           description = "Handle JSON that may or may not be a list, or exist";
           license = stdenv.lib.licenses.mit;
         }) {};
      "al" = callPackage
        ({ mkDerivation, base, c2hs, mtl, openal, stdenv }:
         mkDerivation {
           pname = "al";
           version = "0.1.4.2";
           sha256 = "8bf0f3b3a05ea7b7b8e43da282e1952e5c532ed23247d3384d394cd5046cecd2";
           libraryHaskellDepends = [ base mtl ];
           libraryPkgconfigDepends = [ openal ];
           libraryToolDepends = [ c2hs ];
           doHaddock = false;
           doCheck = false;
           homepage = "http://github.com/phaazon/al";
           description = "OpenAL 1.1 raw API.";
           license = stdenv.lib.licenses.bsd3;
         }) {inherit (pkgs) openal;};
      "alarmclock" = callPackage
        ({ mkDerivation, async, base, clock, stdenv, stm, time
         , unbounded-delays
         }:
         mkDerivation {
           pname = "alarmclock";
           version = "0.5.0.2";
           sha256 = "2574a30897a9a63f09ba97a51f1aead1baeade3cd8b4b063a74d5bb8fa73d64c";
           libraryHaskellDepends = [
             async base clock stm time unbounded-delays
           ];
           doHaddock = false;
           doCheck = false;
           homepage = "https://bitbucket.org/davecturner/alarmclock";
           description = "Wake up and perform an action at a certain time";
           license = stdenv.lib.licenses.bsd3;
         }) {};
      "alerts" = callPackage
        ({ mkDerivation, base, blaze-html, stdenv, text }:
         mkDerivation {
           pname = "alerts";
           version = "0.1.0.0";
           sha256 = "52418ed3abfff15e802506e5fb45f56d38eee020cb01af3f0acfe163c470ca68";
           libraryHaskellDepends = [ base blaze-html text ];
           doHaddock = false;
           doCheck = false;
           homepage = "https://github.com/alx741/alerts#readme";
           description = "Alert messages for web applications";
           license = stdenv.lib.licenses.bsd3;
         }) {};
      "alex" = callPackage
        ({ mkDerivation, array, base, containers, directory, happy, stdenv
         }:
         mkDerivation {
           pname = "alex";
           version = "3.2.4";
           sha256 = "d58e4d708b14ff332a8a8edad4fa8989cb6a9f518a7c6834e96281ac5f8ff232";
           isLibrary = false;
           isExecutable = true;
           enableSeparateDataOutput = true;
           executableHaskellDepends = [ array base containers directory ];
           executableToolDepends = [ happy ];
           doHaddock = false;
           doCheck = false;
           homepage = "http://www.haskell.org/alex/";
           description = "Alex is a tool for generating lexical analysers in Haskell";
           license = stdenv.lib.licenses.bsd3;
         }) {};
      "alg" = callPackage
        ({ mkDerivation, base, stdenv, util }:
         mkDerivation {
           pname = "alg";
           version = "0.2.9.0";
           sha256 = "98724f959ada2387e94cc17a7bdc39eb868d8ef291daa12b82535b517eedb470";
           libraryHaskellDepends = [ base util ];
           doHaddock = false;
           doCheck = false;
           description = "Algebraic structures";
           license = stdenv.lib.licenses.bsd3;
         }) {};
      "algebra" = callPackage
        ({ mkDerivation, adjunctions, array, base, containers, distributive
         , mtl, nats, semigroupoids, semigroups, stdenv, tagged
         , transformers, void
         }:
         mkDerivation {
           pname = "algebra";
           version = "4.3.1";
           sha256 = "25982f929b6f9930ad4df7b2c4084da473178a6e1f33ccc556ec96ee6f541224";
           revision = "1";
           editedCabalFile = "1lxxbbibsf1lkm6fv0svfvfbr0dg16jwcm18hcmfgwypzxqdrbdz";
           libraryHaskellDepends = [
             adjunctions array base containers distributive mtl nats
             semigroupoids semigroups tagged transformers void
           ];
           doHaddock = false;
           doCheck = false;
           homepage = "http://github.com/ekmett/algebra/";
           description = "Constructive abstract algebra";
           license = stdenv.lib.licenses.bsd3;
         }) {};
      "algebraic-graphs" = callPackage
        ({ mkDerivation, array, base, base-compat, containers, deepseq, mtl
         , stdenv
         }:
         mkDerivation {
           pname = "algebraic-graphs";
           version = "0.2";
           sha256 = "887ae448ff4ea7af9cfd0d4242c1505346df0ea3919e587d20c05a603e2ada65";
           libraryHaskellDepends = [
             array base base-compat containers deepseq mtl
           ];
           doHaddock = false;
           doCheck = false;
           homepage = "https://github.com/snowleopard/alga";
           description = "A library for algebraic graph construction and transformation";
           license = stdenv.lib.licenses.mit;
         }) {};
      "almost-fix" = callPackage
        ({ mkDerivation, base, stdenv }:
         mkDerivation {
           pname = "almost-fix";
           version = "0.0.2";
           sha256 = "20597d015fe9b6bb6bfcb0eaee3eb58b28e38a1f4f43049ad0aeebcc6409a70f";
           libraryHaskellDepends = [ base ];
           doHaddock = false;
           doCheck = false;
           description = "Recurse while a predicate is satisfied";
           license = stdenv.lib.licenses.bsd3;
         }) {};
      "alsa-core" = callPackage
        ({ mkDerivation, alsaLib, base, extensible-exceptions, stdenv }:
         mkDerivation {
           pname = "alsa-core";
           version = "0.5.0.1";
           sha256 = "eb50495ef05ecc7c06a0147da7f0d3efde832a44d23caaf5172dc114882270ab";
           libraryHaskellDepends = [ base extensible-exceptions ];
           libraryPkgconfigDepends = [ alsaLib ];
           doHaddock = false;
           doCheck = false;
           homepage = "http://www.haskell.org/haskellwiki/ALSA";
           description = "Binding to the ALSA Library API (Exceptions)";
           license = stdenv.lib.licenses.bsd3;
           platforms = [ "i686-linux" "x86_64-linux" ];
         }) {inherit (pkgs) alsaLib;};
      "alsa-pcm" = callPackage
        ({ mkDerivation, alsa-core, alsaLib, array, base
         , extensible-exceptions, sample-frame, semigroups, stdenv
         , storable-record
         }:
         mkDerivation {
           pname = "alsa-pcm";
           version = "0.6.1.1";
           sha256 = "6348f63e2858df9c0b516053c7c5111139936faea6edf7cf400b8fba6cca94d6";
           isLibrary = true;
           isExecutable = true;
           libraryHaskellDepends = [
             alsa-core array base extensible-exceptions sample-frame semigroups
             storable-record
           ];
           libraryPkgconfigDepends = [ alsaLib ];
           doHaddock = false;
           doCheck = false;
           homepage = "http://www.haskell.org/haskellwiki/ALSA";
           description = "Binding to the ALSA Library API (PCM audio)";
           license = stdenv.lib.licenses.bsd3;
         }) {inherit (pkgs) alsaLib;};
      "alsa-seq" = callPackage
        ({ mkDerivation, alsa-core, alsaLib, array, base, bytestring
         , data-accessor, enumset, extensible-exceptions, poll, stdenv
         , transformers, utility-ht
         }:
         mkDerivation {
           pname = "alsa-seq";
           version = "0.6.0.7";
           sha256 = "06cda1e24993aaf0c3592b51a613cf1e187eea603dd77ad3a129a8a7b1e0b778";
           isLibrary = true;
           isExecutable = true;
           libraryHaskellDepends = [
             alsa-core array base bytestring data-accessor enumset
             extensible-exceptions poll transformers utility-ht
           ];
           libraryPkgconfigDepends = [ alsaLib ];
           doHaddock = false;
           doCheck = false;
           homepage = "http://www.haskell.org/haskellwiki/ALSA";
           description = "Binding to the ALSA Library API (MIDI sequencer)";
           license = stdenv.lib.licenses.bsd3;
         }) {inherit (pkgs) alsaLib;};
      "alternative-vector" = callPackage
        ({ mkDerivation, base, stdenv, vector }:
         mkDerivation {
           pname = "alternative-vector";
           version = "0.0.0";
           sha256 = "42474bc708dbc81e13a7850887cefc2596db47cb07423610094cd994f754c7b1";
           libraryHaskellDepends = [ base vector ];
           doHaddock = false;
           doCheck = false;
           homepage = "https://github.com/athanclark/alternative-vector#readme";
           description = "Use vectors instead of lists for many and some";
           license = stdenv.lib.licenses.bsd3;
         }) {};
      "alternators" = callPackage
        ({ mkDerivation, base, lens, mmorph, mtl, newtype-generics, stdenv
         , stm, transformers
         }:
         mkDerivation {
           pname = "alternators";
           version = "1.0.0.0";
           sha256 = "44395b8b42193fdd78f94fd9f62560bfa69aef345a0fb2602df0d8d3613fd339";
           libraryHaskellDepends = [
             base lens mmorph mtl newtype-generics stm transformers
           ];
           doHaddock = false;
           doCheck = false;
           homepage = "https://github.com/louispan/alternators#readme";
           description = "Handy functions when using transformers";
           license = stdenv.lib.licenses.bsd3;
         }) {};
      "amazonka" = callPackage
        ({ mkDerivation, amazonka-core, base, bytestring, conduit
         , conduit-extra, directory, exceptions, http-client, http-conduit
         , http-types, ini, mmorph, monad-control, mtl, resourcet, retry
         , stdenv, text, time, transformers, transformers-base
         , transformers-compat, void
         }:
         mkDerivation {
           pname = "amazonka";
           version = "1.6.0";
           sha256 = "3721892c87946c12bbd87ddba38d9e244aa962db190d8897c16a264c4f3fc41c";
           libraryHaskellDepends = [
             amazonka-core base bytestring conduit conduit-extra directory
             exceptions http-client http-conduit http-types ini mmorph
             monad-control mtl resourcet retry text time transformers
             transformers-base transformers-compat void
           ];
           doHaddock = false;
           doCheck = false;
           homepage = "https://github.com/brendanhay/amazonka";
           description = "Comprehensive Amazon Web Services SDK";
           license = stdenv.lib.licenses.mpl20;
         }) {};
      "amazonka-apigateway" = callPackage
        ({ mkDerivation, amazonka-core, base, stdenv }:
         mkDerivation {
           pname = "amazonka-apigateway";
           version = "1.6.0";
           sha256 = "56e63ecfbd8358d0d2766e08f8f2b08362bb435c1059a5791964089dbab75ae8";
           libraryHaskellDepends = [ amazonka-core base ];
           doHaddock = false;
           doCheck = false;
           homepage = "https://github.com/brendanhay/amazonka";
           description = "Amazon API Gateway SDK";
           license = stdenv.lib.licenses.mpl20;
         }) {};
      "amazonka-application-autoscaling" = callPackage
        ({ mkDerivation, amazonka-core, base, stdenv }:
         mkDerivation {
           pname = "amazonka-application-autoscaling";
           version = "1.6.0";
           sha256 = "5536a7d1c24cd5907b85bd743df5989d91cb3325602944062c9c640178a61df7";
           libraryHaskellDepends = [ amazonka-core base ];
           doHaddock = false;
           doCheck = false;
           homepage = "https://github.com/brendanhay/amazonka";
           description = "Amazon Application Auto Scaling SDK";
           license = stdenv.lib.licenses.mpl20;
         }) {};
      "amazonka-appstream" = callPackage
        ({ mkDerivation, amazonka-core, base, stdenv }:
         mkDerivation {
           pname = "amazonka-appstream";
           version = "1.6.0";
           sha256 = "eb90692b932d62c4e7006d661b8022c4dd9f7d4dcc07e5499eceae14b33747df";
           libraryHaskellDepends = [ amazonka-core base ];
           doHaddock = false;
           doCheck = false;
           homepage = "https://github.com/brendanhay/amazonka";
           description = "Amazon AppStream SDK";
           license = stdenv.lib.licenses.mpl20;
         }) {};
      "amazonka-autoscaling" = callPackage
        ({ mkDerivation, amazonka-core, base, stdenv }:
         mkDerivation {
           pname = "amazonka-autoscaling";
           version = "1.6.0";
           sha256 = "1b52132b23ef899937d20cef595d9f8757f85861d142616bcb5ee0ba8ed5f8d3";
           libraryHaskellDepends = [ amazonka-core base ];
           doHaddock = false;
           doCheck = false;
           homepage = "https://github.com/brendanhay/amazonka";
           description = "Amazon Auto Scaling SDK";
           license = stdenv.lib.licenses.mpl20;
         }) {};
      "amazonka-budgets" = callPackage
        ({ mkDerivation, amazonka-core, base, stdenv }:
         mkDerivation {
           pname = "amazonka-budgets";
           version = "1.6.0";
           sha256 = "ccc692856a7f7ddfba573cde6506108a30a59f641748ecc787aece894d7ce4b7";
           libraryHaskellDepends = [ amazonka-core base ];
           doHaddock = false;
           doCheck = false;
           homepage = "https://github.com/brendanhay/amazonka";
           description = "Amazon Budgets SDK";
           license = stdenv.lib.licenses.mpl20;
         }) {};
      "amazonka-certificatemanager" = callPackage
        ({ mkDerivation, amazonka-core, base, stdenv }:
         mkDerivation {
           pname = "amazonka-certificatemanager";
           version = "1.6.0";
           sha256 = "1fdf93c685a1b348a851b793b170a0a2282b06dc65a91c016d4756ea5726aa6a";
           libraryHaskellDepends = [ amazonka-core base ];
           doHaddock = false;
           doCheck = false;
           homepage = "https://github.com/brendanhay/amazonka";
           description = "Amazon Certificate Manager SDK";
           license = stdenv.lib.licenses.mpl20;
         }) {};
      "amazonka-cloudformation" = callPackage
        ({ mkDerivation, amazonka-core, base, stdenv }:
         mkDerivation {
           pname = "amazonka-cloudformation";
           version = "1.6.0";
           sha256 = "15e2c82574906a13d390f68f5a57a83f4bbfc37fb9ce590c9f73e00dcafa8335";
           libraryHaskellDepends = [ amazonka-core base ];
           doHaddock = false;
           doCheck = false;
           homepage = "https://github.com/brendanhay/amazonka";
           description = "Amazon CloudFormation SDK";
           license = stdenv.lib.licenses.mpl20;
         }) {};
      "amazonka-cloudfront" = callPackage
        ({ mkDerivation, amazonka-core, base, stdenv }:
         mkDerivation {
           pname = "amazonka-cloudfront";
           version = "1.6.0";
           sha256 = "956a60988ff3b9bef042bf523b63c882cd7b2c386483cc3f1d1d8534aad334a2";
           libraryHaskellDepends = [ amazonka-core base ];
           doHaddock = false;
           doCheck = false;
           homepage = "https://github.com/brendanhay/amazonka";
           description = "Amazon CloudFront SDK";
           license = stdenv.lib.licenses.mpl20;
         }) {};
      "amazonka-cloudhsm" = callPackage
        ({ mkDerivation, amazonka-core, base, stdenv }:
         mkDerivation {
           pname = "amazonka-cloudhsm";
           version = "1.6.0";
           sha256 = "e4227038a39486e8c390198997571ca1b14ebf5e15fec1146169da7378a41b5f";
           libraryHaskellDepends = [ amazonka-core base ];
           doHaddock = false;
           doCheck = false;
           homepage = "https://github.com/brendanhay/amazonka";
           description = "Amazon CloudHSM SDK";
           license = stdenv.lib.licenses.mpl20;
         }) {};
      "amazonka-cloudsearch" = callPackage
        ({ mkDerivation, amazonka-core, base, stdenv }:
         mkDerivation {
           pname = "amazonka-cloudsearch";
           version = "1.6.0";
           sha256 = "dd17345576acd8f44fd3af82f07b00fdce0781abbd51ab2df827fa48528c6394";
           libraryHaskellDepends = [ amazonka-core base ];
           doHaddock = false;
           doCheck = false;
           homepage = "https://github.com/brendanhay/amazonka";
           description = "Amazon CloudSearch SDK";
           license = stdenv.lib.licenses.mpl20;
         }) {};
      "amazonka-cloudsearch-domains" = callPackage
        ({ mkDerivation, amazonka-core, base, stdenv }:
         mkDerivation {
           pname = "amazonka-cloudsearch-domains";
           version = "1.6.0";
           sha256 = "24f0d36f9aeed5041fd893b8a0d60e5df6f31c8a126cead4652115c6b28f7ca7";
           libraryHaskellDepends = [ amazonka-core base ];
           doHaddock = false;
           doCheck = false;
           homepage = "https://github.com/brendanhay/amazonka";
           description = "Amazon CloudSearch Domain SDK";
           license = stdenv.lib.licenses.mpl20;
         }) {};
      "amazonka-cloudtrail" = callPackage
        ({ mkDerivation, amazonka-core, base, stdenv }:
         mkDerivation {
           pname = "amazonka-cloudtrail";
           version = "1.6.0";
           sha256 = "d9d99df96ac2e46321e0da7d1797f12472ee32011f126d2881a2f19aa7491c24";
           libraryHaskellDepends = [ amazonka-core base ];
           doHaddock = false;
           doCheck = false;
           homepage = "https://github.com/brendanhay/amazonka";
           description = "Amazon CloudTrail SDK";
           license = stdenv.lib.licenses.mpl20;
         }) {};
      "amazonka-cloudwatch" = callPackage
        ({ mkDerivation, amazonka-core, base, stdenv }:
         mkDerivation {
           pname = "amazonka-cloudwatch";
           version = "1.6.0";
           sha256 = "25c812b364b22d96d082e3598cd75d988cb8e3decdb8e3291a0deb9714dbee51";
           libraryHaskellDepends = [ amazonka-core base ];
           doHaddock = false;
           doCheck = false;
           homepage = "https://github.com/brendanhay/amazonka";
           description = "Amazon CloudWatch SDK";
           license = stdenv.lib.licenses.mpl20;
         }) {};
      "amazonka-cloudwatch-events" = callPackage
        ({ mkDerivation, amazonka-core, base, stdenv }:
         mkDerivation {
           pname = "amazonka-cloudwatch-events";
           version = "1.6.0";
           sha256 = "13fb5e436fc4c534d6e01c47ef23f589c01042f8a9d7efb622e89bd8f5d2ec4d";
           libraryHaskellDepends = [ amazonka-core base ];
           doHaddock = false;
           doCheck = false;
           homepage = "https://github.com/brendanhay/amazonka";
           description = "Amazon CloudWatch Events SDK";
           license = stdenv.lib.licenses.mpl20;
         }) {};
      "amazonka-cloudwatch-logs" = callPackage
        ({ mkDerivation, amazonka-core, base, stdenv }:
         mkDerivation {
           pname = "amazonka-cloudwatch-logs";
           version = "1.6.0";
           sha256 = "80e4e74af0fb29f5ecc04f4d956ba0e9950f7936c858c1ff84461b62ca87ee7d";
           libraryHaskellDepends = [ amazonka-core base ];
           doHaddock = false;
           doCheck = false;
           homepage = "https://github.com/brendanhay/amazonka";
           description = "Amazon CloudWatch Logs SDK";
           license = stdenv.lib.licenses.mpl20;
         }) {};
      "amazonka-codebuild" = callPackage
        ({ mkDerivation, amazonka-core, base, stdenv }:
         mkDerivation {
           pname = "amazonka-codebuild";
           version = "1.6.0";
           sha256 = "fdbf43578e0aa54c616b2daf8b442b32a8765b62da0c3b7f6b1df95f4e55a0ab";
           libraryHaskellDepends = [ amazonka-core base ];
           doHaddock = false;
           doCheck = false;
           homepage = "https://github.com/brendanhay/amazonka";
           description = "Amazon CodeBuild SDK";
           license = stdenv.lib.licenses.mpl20;
         }) {};
      "amazonka-codecommit" = callPackage
        ({ mkDerivation, amazonka-core, base, stdenv }:
         mkDerivation {
           pname = "amazonka-codecommit";
           version = "1.6.0";
           sha256 = "8a2f2630bfabd3c71fdb811a9bbafefb058ce085ad18c1756a82f59bdd682415";
           libraryHaskellDepends = [ amazonka-core base ];
           doHaddock = false;
           doCheck = false;
           homepage = "https://github.com/brendanhay/amazonka";
           description = "Amazon CodeCommit SDK";
           license = stdenv.lib.licenses.mpl20;
         }) {};
      "amazonka-codedeploy" = callPackage
        ({ mkDerivation, amazonka-core, base, stdenv }:
         mkDerivation {
           pname = "amazonka-codedeploy";
           version = "1.6.0";
           sha256 = "3315b99ab8851acb5ae1251344474e0ec03796e9fd59f1d18278abc7add3c2df";
           libraryHaskellDepends = [ amazonka-core base ];
           doHaddock = false;
           doCheck = false;
           homepage = "https://github.com/brendanhay/amazonka";
           description = "Amazon CodeDeploy SDK";
           license = stdenv.lib.licenses.mpl20;
         }) {};
      "amazonka-codepipeline" = callPackage
        ({ mkDerivation, amazonka-core, base, stdenv }:
         mkDerivation {
           pname = "amazonka-codepipeline";
           version = "1.6.0";
           sha256 = "c46eea221931601ced439454d3a3fe0030acccbb776bf153182010ca8f2ec043";
           libraryHaskellDepends = [ amazonka-core base ];
           doHaddock = false;
           doCheck = false;
           homepage = "https://github.com/brendanhay/amazonka";
           description = "Amazon CodePipeline SDK";
           license = stdenv.lib.licenses.mpl20;
         }) {};
      "amazonka-cognito-identity" = callPackage
        ({ mkDerivation, amazonka-core, base, stdenv }:
         mkDerivation {
           pname = "amazonka-cognito-identity";
           version = "1.6.0";
           sha256 = "3aac30e210d3fc0f45166b6211c4c61eb7cc4480fb550f106cd6206c8dc9b6d5";
           libraryHaskellDepends = [ amazonka-core base ];
           doHaddock = false;
           doCheck = false;
           homepage = "https://github.com/brendanhay/amazonka";
           description = "Amazon Cognito Identity SDK";
           license = stdenv.lib.licenses.mpl20;
         }) {};
      "amazonka-cognito-idp" = callPackage
        ({ mkDerivation, amazonka-core, base, stdenv }:
         mkDerivation {
           pname = "amazonka-cognito-idp";
           version = "1.6.0";
           sha256 = "a98989c8ca10bb938fb4f27803920462fc8f88d7104cebb5106b9e3728e81fff";
           libraryHaskellDepends = [ amazonka-core base ];
           doHaddock = false;
           doCheck = false;
           homepage = "https://github.com/brendanhay/amazonka";
           description = "Amazon Cognito Identity Provider SDK";
           license = stdenv.lib.licenses.mpl20;
         }) {};
      "amazonka-cognito-sync" = callPackage
        ({ mkDerivation, amazonka-core, base, stdenv }:
         mkDerivation {
           pname = "amazonka-cognito-sync";
           version = "1.6.0";
           sha256 = "5fde10d8e1f31e676433dfd32d061739d805a076ee58abd9c05d8faba36cf435";
           libraryHaskellDepends = [ amazonka-core base ];
           doHaddock = false;
           doCheck = false;
           homepage = "https://github.com/brendanhay/amazonka";
           description = "Amazon Cognito Sync SDK";
           license = stdenv.lib.licenses.mpl20;
         }) {};
      "amazonka-config" = callPackage
        ({ mkDerivation, amazonka-core, base, stdenv }:
         mkDerivation {
           pname = "amazonka-config";
           version = "1.6.0";
           sha256 = "5cb03ebc049efbccfb48ab926e08f0e9824880bb349129601f724679fe42c9cd";
           libraryHaskellDepends = [ amazonka-core base ];
           doHaddock = false;
           doCheck = false;
           homepage = "https://github.com/brendanhay/amazonka";
           description = "Amazon Config SDK";
           license = stdenv.lib.licenses.mpl20;
         }) {};
      "amazonka-core" = callPackage
        ({ mkDerivation, aeson, attoparsec, base, bifunctors, bytestring
         , case-insensitive, conduit, conduit-extra, cryptonite, deepseq
         , exceptions, hashable, http-client, http-conduit, http-types, lens
         , memory, mtl, resourcet, scientific, semigroups, stdenv, tagged
         , text, time, transformers, transformers-compat
         , unordered-containers, xml-conduit, xml-types
         }:
         mkDerivation {
           pname = "amazonka-core";
           version = "1.6.0";
           sha256 = "afe1c5b74aadc0222419bd792688fd179e4f5693aeb75b74232f770fff093dc9";
           libraryHaskellDepends = [
             aeson attoparsec base bifunctors bytestring case-insensitive
             conduit conduit-extra cryptonite deepseq exceptions hashable
             http-client http-conduit http-types lens memory mtl resourcet
             scientific semigroups tagged text time transformers
             transformers-compat unordered-containers xml-conduit xml-types
           ];
           doHaddock = false;
           doCheck = false;
           homepage = "https://github.com/brendanhay/amazonka";
           description = "Core data types and functionality for Amazonka libraries";
           license = stdenv.lib.licenses.mpl20;
         }) {};
      "amazonka-datapipeline" = callPackage
        ({ mkDerivation, amazonka-core, base, stdenv }:
         mkDerivation {
           pname = "amazonka-datapipeline";
           version = "1.6.0";
           sha256 = "1b212dd70864ef1ccc45e3a7deca936e0e1803c97aacefc34fad966fd85f3ae5";
           libraryHaskellDepends = [ amazonka-core base ];
           doHaddock = false;
           doCheck = false;
           homepage = "https://github.com/brendanhay/amazonka";
           description = "Amazon Data Pipeline SDK";
           license = stdenv.lib.licenses.mpl20;
         }) {};
      "amazonka-devicefarm" = callPackage
        ({ mkDerivation, amazonka-core, base, stdenv }:
         mkDerivation {
           pname = "amazonka-devicefarm";
           version = "1.6.0";
           sha256 = "d81b74b8b0c254a487ce464b1d6f0679d774bd42daf32312867e4dd37e35c569";
           libraryHaskellDepends = [ amazonka-core base ];
           doHaddock = false;
           doCheck = false;
           homepage = "https://github.com/brendanhay/amazonka";
           description = "Amazon Device Farm SDK";
           license = stdenv.lib.licenses.mpl20;
         }) {};
      "amazonka-directconnect" = callPackage
        ({ mkDerivation, amazonka-core, base, stdenv }:
         mkDerivation {
           pname = "amazonka-directconnect";
           version = "1.6.0";
           sha256 = "8d85b9ce865eac817610a3a1db2e28100ff0069b85f41c4359a6aa5978533832";
           libraryHaskellDepends = [ amazonka-core base ];
           doHaddock = false;
           doCheck = false;
           homepage = "https://github.com/brendanhay/amazonka";
           description = "Amazon Direct Connect SDK";
           license = stdenv.lib.licenses.mpl20;
         }) {};
      "amazonka-discovery" = callPackage
        ({ mkDerivation, amazonka-core, base, stdenv }:
         mkDerivation {
           pname = "amazonka-discovery";
           version = "1.6.0";
           sha256 = "7bc67ad76b1413c2aebe48324d56b2e6f4279db6e7d4951e93bdaa5329199213";
           libraryHaskellDepends = [ amazonka-core base ];
           doHaddock = false;
           doCheck = false;
           homepage = "https://github.com/brendanhay/amazonka";
           description = "Amazon Application Discovery Service SDK";
           license = stdenv.lib.licenses.mpl20;
         }) {};
      "amazonka-dms" = callPackage
        ({ mkDerivation, amazonka-core, base, stdenv }:
         mkDerivation {
           pname = "amazonka-dms";
           version = "1.6.0";
           sha256 = "a75f19dc2a7642840a97a135f24cd9120d3f5a81ad924aad6a46c514fba180f3";
           libraryHaskellDepends = [ amazonka-core base ];
           doHaddock = false;
           doCheck = false;
           homepage = "https://github.com/brendanhay/amazonka";
           description = "Amazon Database Migration Service SDK";
           license = stdenv.lib.licenses.mpl20;
         }) {};
      "amazonka-ds" = callPackage
        ({ mkDerivation, amazonka-core, base, stdenv }:
         mkDerivation {
           pname = "amazonka-ds";
           version = "1.6.0";
           sha256 = "06fa338938aee62f81f93755cdc7039515dc0c6b32bb7c0bac33d7c92066d389";
           libraryHaskellDepends = [ amazonka-core base ];
           doHaddock = false;
           doCheck = false;
           homepage = "https://github.com/brendanhay/amazonka";
           description = "Amazon Directory Service SDK";
           license = stdenv.lib.licenses.mpl20;
         }) {};
      "amazonka-dynamodb" = callPackage
        ({ mkDerivation, amazonka-core, base, stdenv }:
         mkDerivation {
           pname = "amazonka-dynamodb";
           version = "1.6.0";
           sha256 = "33f54ee4f898972f1539a00e65a851bb940c8d26058d63ddfcd07fbca57f9a3f";
           libraryHaskellDepends = [ amazonka-core base ];
           doHaddock = false;
           doCheck = false;
           homepage = "https://github.com/brendanhay/amazonka";
           description = "Amazon DynamoDB SDK";
           license = stdenv.lib.licenses.mpl20;
         }) {};
      "amazonka-dynamodb-streams" = callPackage
        ({ mkDerivation, amazonka-core, base, stdenv }:
         mkDerivation {
           pname = "amazonka-dynamodb-streams";
           version = "1.6.0";
           sha256 = "b3f832ddf70e95232cb79d71633276aa65c72e51c6c553118b4bc9db3a48e57f";
           libraryHaskellDepends = [ amazonka-core base ];
           doHaddock = false;
           doCheck = false;
           homepage = "https://github.com/brendanhay/amazonka";
           description = "Amazon DynamoDB Streams SDK";
           license = stdenv.lib.licenses.mpl20;
         }) {};
      "amazonka-ec2" = callPackage
        ({ mkDerivation, amazonka-core, base, stdenv }:
         mkDerivation {
           pname = "amazonka-ec2";
           version = "1.6.0";
           sha256 = "2221c2c4e188aac9f0c9e4bb2e0bce65eb21102e6199c3783c20f3797da955cc";
           libraryHaskellDepends = [ amazonka-core base ];
           doHaddock = false;
           doCheck = false;
           homepage = "https://github.com/brendanhay/amazonka";
           description = "Amazon Elastic Compute Cloud SDK";
           license = stdenv.lib.licenses.mpl20;
         }) {};
      "amazonka-ecr" = callPackage
        ({ mkDerivation, amazonka-core, base, stdenv }:
         mkDerivation {
           pname = "amazonka-ecr";
           version = "1.6.0";
           sha256 = "42088ad4b4d4c01b87267a372fec706f57db4db19b27c06a3c6826ef62ef8450";
           libraryHaskellDepends = [ amazonka-core base ];
           doHaddock = false;
           doCheck = false;
           homepage = "https://github.com/brendanhay/amazonka";
           description = "Amazon EC2 Container Registry SDK";
           license = stdenv.lib.licenses.mpl20;
         }) {};
      "amazonka-ecs" = callPackage
        ({ mkDerivation, amazonka-core, base, stdenv }:
         mkDerivation {
           pname = "amazonka-ecs";
           version = "1.6.0";
           sha256 = "309535abe8359475b3430488c84c398ed8d25a05321101c725e4a04d5f4cde3f";
           libraryHaskellDepends = [ amazonka-core base ];
           doHaddock = false;
           doCheck = false;
           homepage = "https://github.com/brendanhay/amazonka";
           description = "Amazon EC2 Container Service SDK";
           license = stdenv.lib.licenses.mpl20;
         }) {};
      "amazonka-efs" = callPackage
        ({ mkDerivation, amazonka-core, base, stdenv }:
         mkDerivation {
           pname = "amazonka-efs";
           version = "1.6.0";
           sha256 = "268456294406d63eb49422027226af8ef15ce08dc2095be9a6657bf9bf41afbb";
           libraryHaskellDepends = [ amazonka-core base ];
           doHaddock = false;
           doCheck = false;
           homepage = "https://github.com/brendanhay/amazonka";
           description = "Amazon Elastic File System SDK";
           license = stdenv.lib.licenses.mpl20;
         }) {};
      "amazonka-elasticache" = callPackage
        ({ mkDerivation, amazonka-core, base, stdenv }:
         mkDerivation {
           pname = "amazonka-elasticache";
           version = "1.6.0";
           sha256 = "e4a74a2ce2d89534fd738c429dc9a0ee7564ee3539bd93488eba211176763969";
           libraryHaskellDepends = [ amazonka-core base ];
           doHaddock = false;
           doCheck = false;
           homepage = "https://github.com/brendanhay/amazonka";
           description = "Amazon ElastiCache SDK";
           license = stdenv.lib.licenses.mpl20;
         }) {};
      "amazonka-elasticbeanstalk" = callPackage
        ({ mkDerivation, amazonka-core, base, stdenv }:
         mkDerivation {
           pname = "amazonka-elasticbeanstalk";
           version = "1.6.0";
           sha256 = "c1dc065763475b705aabf61086546bcd312e6802dbb328775b9777e682b2386a";
           libraryHaskellDepends = [ amazonka-core base ];
           doHaddock = false;
           doCheck = false;
           homepage = "https://github.com/brendanhay/amazonka";
           description = "Amazon Elastic Beanstalk SDK";
           license = stdenv.lib.licenses.mpl20;
         }) {};
      "amazonka-elasticsearch" = callPackage
        ({ mkDerivation, amazonka-core, base, stdenv }:
         mkDerivation {
           pname = "amazonka-elasticsearch";
           version = "1.6.0";
           sha256 = "3429fcae1c6fec5ebbc8acf1597532615b39def394d2296d641614c0225f3083";
           libraryHaskellDepends = [ amazonka-core base ];
           doHaddock = false;
           doCheck = false;
           homepage = "https://github.com/brendanhay/amazonka";
           description = "Amazon Elasticsearch Service SDK";
           license = stdenv.lib.licenses.mpl20;
         }) {};
      "amazonka-elastictranscoder" = callPackage
        ({ mkDerivation, amazonka-core, base, stdenv }:
         mkDerivation {
           pname = "amazonka-elastictranscoder";
           version = "1.6.0";
           sha256 = "ab12a7c97e09cd1a60e81525e793f5f7b84799f8f9968a2b62bae8b9c9f3c10a";
           libraryHaskellDepends = [ amazonka-core base ];
           doHaddock = false;
           doCheck = false;
           homepage = "https://github.com/brendanhay/amazonka";
           description = "Amazon Elastic Transcoder SDK";
           license = stdenv.lib.licenses.mpl20;
         }) {};
      "amazonka-elb" = callPackage
        ({ mkDerivation, amazonka-core, base, stdenv }:
         mkDerivation {
           pname = "amazonka-elb";
           version = "1.6.0";
           sha256 = "59c974009a2c26f7d267ae9736c71893a82ae69c19f344b87b4e3afd19f97e4d";
           libraryHaskellDepends = [ amazonka-core base ];
           doHaddock = false;
           doCheck = false;
           homepage = "https://github.com/brendanhay/amazonka";
           description = "Amazon Elastic Load Balancing SDK";
           license = stdenv.lib.licenses.mpl20;
         }) {};
      "amazonka-elbv2" = callPackage
        ({ mkDerivation, amazonka-core, base, stdenv }:
         mkDerivation {
           pname = "amazonka-elbv2";
           version = "1.6.0";
           sha256 = "2a53d35e29b613ac7261a3202023cb8221607fd8df5f034c572d6aa751c622c9";
           libraryHaskellDepends = [ amazonka-core base ];
           doHaddock = false;
           doCheck = false;
           homepage = "https://github.com/brendanhay/amazonka";
           description = "Amazon Elastic Load Balancing SDK";
           license = stdenv.lib.licenses.mpl20;
         }) {};
      "amazonka-emr" = callPackage
        ({ mkDerivation, amazonka-core, base, stdenv }:
         mkDerivation {
           pname = "amazonka-emr";
           version = "1.6.0";
           sha256 = "e9a07458ee61feadeff2e98fc83c1542320d5b97744225304dc1cc568ad9774f";
           libraryHaskellDepends = [ amazonka-core base ];
           doHaddock = false;
           doCheck = false;
           homepage = "https://github.com/brendanhay/amazonka";
           description = "Amazon Elastic MapReduce SDK";
           license = stdenv.lib.licenses.mpl20;
         }) {};
      "amazonka-gamelift" = callPackage
        ({ mkDerivation, amazonka-core, base, stdenv }:
         mkDerivation {
           pname = "amazonka-gamelift";
           version = "1.6.0";
           sha256 = "ebcdbd4a43c8d02dc0a0d7302f4b27c8e106a783e910c5cdaa68a7a7ee775ffc";
           libraryHaskellDepends = [ amazonka-core base ];
           doHaddock = false;
           doCheck = false;
           homepage = "https://github.com/brendanhay/amazonka";
           description = "Amazon GameLift SDK";
           license = stdenv.lib.licenses.mpl20;
         }) {};
      "amazonka-glacier" = callPackage
        ({ mkDerivation, amazonka-core, base, stdenv }:
         mkDerivation {
           pname = "amazonka-glacier";
           version = "1.6.0";
           sha256 = "5307434d1fbddfba54b56ceb5eea2e5dfa3ece05b9353e61a998788af3e0f913";
           libraryHaskellDepends = [ amazonka-core base ];
           doHaddock = false;
           doCheck = false;
           homepage = "https://github.com/brendanhay/amazonka";
           description = "Amazon Glacier SDK";
           license = stdenv.lib.licenses.mpl20;
         }) {};
      "amazonka-health" = callPackage
        ({ mkDerivation, amazonka-core, base, stdenv }:
         mkDerivation {
           pname = "amazonka-health";
           version = "1.6.0";
           sha256 = "c216b18e93e998ff04b00a5fc3ab6df8d36ef95d4b9988587eceb837615ba67b";
           libraryHaskellDepends = [ amazonka-core base ];
           doHaddock = false;
           doCheck = false;
           homepage = "https://github.com/brendanhay/amazonka";
           description = "Amazon Health APIs and Notifications SDK";
           license = stdenv.lib.licenses.mpl20;
         }) {};
      "amazonka-iam" = callPackage
        ({ mkDerivation, amazonka-core, base, stdenv }:
         mkDerivation {
           pname = "amazonka-iam";
           version = "1.6.0";
           sha256 = "a335813a795c3d28400b95b94f1b14ada3e621e83d07cb9fd9c7e7edb285905d";
           libraryHaskellDepends = [ amazonka-core base ];
           doHaddock = false;
           doCheck = false;
           homepage = "https://github.com/brendanhay/amazonka";
           description = "Amazon Identity and Access Management SDK";
           license = stdenv.lib.licenses.mpl20;
         }) {};
      "amazonka-importexport" = callPackage
        ({ mkDerivation, amazonka-core, base, stdenv }:
         mkDerivation {
           pname = "amazonka-importexport";
           version = "1.6.0";
           sha256 = "0951f2bcd74e24c687ab39a044cfc9334b68fdb3c885d54693c918a1c97dcd04";
           libraryHaskellDepends = [ amazonka-core base ];
           doHaddock = false;
           doCheck = false;
           homepage = "https://github.com/brendanhay/amazonka";
           description = "Amazon Import/Export SDK";
           license = stdenv.lib.licenses.mpl20;
         }) {};
      "amazonka-inspector" = callPackage
        ({ mkDerivation, amazonka-core, base, stdenv }:
         mkDerivation {
           pname = "amazonka-inspector";
           version = "1.6.0";
           sha256 = "bcef005e38e63b742c1d7c63de84f582a447042a19ea611b1b617751f3cce13e";
           libraryHaskellDepends = [ amazonka-core base ];
           doHaddock = false;
           doCheck = false;
           homepage = "https://github.com/brendanhay/amazonka";
           description = "Amazon Inspector SDK";
           license = stdenv.lib.licenses.mpl20;
         }) {};
      "amazonka-iot" = callPackage
        ({ mkDerivation, amazonka-core, base, stdenv }:
         mkDerivation {
           pname = "amazonka-iot";
           version = "1.6.0";
           sha256 = "180b2169c97bd021e5f013cc72b64fe701270a7a5000950e20fa6373d38a26d0";
           libraryHaskellDepends = [ amazonka-core base ];
           doHaddock = false;
           doCheck = false;
           homepage = "https://github.com/brendanhay/amazonka";
           description = "Amazon IoT SDK";
           license = stdenv.lib.licenses.mpl20;
         }) {};
      "amazonka-iot-dataplane" = callPackage
        ({ mkDerivation, amazonka-core, base, stdenv }:
         mkDerivation {
           pname = "amazonka-iot-dataplane";
           version = "1.6.0";
           sha256 = "aee63bc0e6eca4cc4f76f7c8aa5e20f97e3f98268160006099014c66f4a88742";
           libraryHaskellDepends = [ amazonka-core base ];
           doHaddock = false;
           doCheck = false;
           homepage = "https://github.com/brendanhay/amazonka";
           description = "Amazon IoT Data Plane SDK";
           license = stdenv.lib.licenses.mpl20;
         }) {};
      "amazonka-kinesis" = callPackage
        ({ mkDerivation, amazonka-core, base, stdenv }:
         mkDerivation {
           pname = "amazonka-kinesis";
           version = "1.6.0";
           sha256 = "549e41d29e46ff6aa485676436cb7cf15d2d37c2d0c62e6358b9b12b92e22f38";
           libraryHaskellDepends = [ amazonka-core base ];
           doHaddock = false;
           doCheck = false;
           homepage = "https://github.com/brendanhay/amazonka";
           description = "Amazon Kinesis SDK";
           license = stdenv.lib.licenses.mpl20;
         }) {};
      "amazonka-kinesis-analytics" = callPackage
        ({ mkDerivation, amazonka-core, base, stdenv }:
         mkDerivation {
           pname = "amazonka-kinesis-analytics";
           version = "1.6.0";
           sha256 = "7efb5438596ef4541ebca35e4b87adf3c989bf88032be2d2e617bb14a7f685ee";
           libraryHaskellDepends = [ amazonka-core base ];
           doHaddock = false;
           doCheck = false;
           homepage = "https://github.com/brendanhay/amazonka";
           description = "Amazon Kinesis Analytics SDK";
           license = stdenv.lib.licenses.mpl20;
         }) {};
      "amazonka-kinesis-firehose" = callPackage
        ({ mkDerivation, amazonka-core, base, stdenv }:
         mkDerivation {
           pname = "amazonka-kinesis-firehose";
           version = "1.6.0";
           sha256 = "120545cdc888c031290b2f8a6745b911ebc6e2e5c077005067683118d197549c";
           libraryHaskellDepends = [ amazonka-core base ];
           doHaddock = false;
           doCheck = false;
           homepage = "https://github.com/brendanhay/amazonka";
           description = "Amazon Kinesis Firehose SDK";
           license = stdenv.lib.licenses.mpl20;
         }) {};
      "amazonka-kms" = callPackage
        ({ mkDerivation, amazonka-core, base, stdenv }:
         mkDerivation {
           pname = "amazonka-kms";
           version = "1.6.0";
           sha256 = "7aa5333583b494d0a5585f78ead67833a7e72942b264673ee8b91d7be89e8e99";
           libraryHaskellDepends = [ amazonka-core base ];
           doHaddock = false;
           doCheck = false;
           homepage = "https://github.com/brendanhay/amazonka";
           description = "Amazon Key Management Service SDK";
           license = stdenv.lib.licenses.mpl20;
         }) {};
      "amazonka-lambda" = callPackage
        ({ mkDerivation, amazonka-core, base, stdenv }:
         mkDerivation {
           pname = "amazonka-lambda";
           version = "1.6.0";
           sha256 = "649626896a7572979c5628e9406eb9be090106b7468473455e77aa59cec99b06";
           libraryHaskellDepends = [ amazonka-core base ];
           doHaddock = false;
           doCheck = false;
           homepage = "https://github.com/brendanhay/amazonka";
           description = "Amazon Lambda SDK";
           license = stdenv.lib.licenses.mpl20;
         }) {};
      "amazonka-lightsail" = callPackage
        ({ mkDerivation, amazonka-core, base, stdenv }:
         mkDerivation {
           pname = "amazonka-lightsail";
           version = "1.6.0";
           sha256 = "741b4c6aff2f0e08fe9868aa858708a8ab36f95859bc0a9eecfdd9bd2060aceb";
           libraryHaskellDepends = [ amazonka-core base ];
           doHaddock = false;
           doCheck = false;
           homepage = "https://github.com/brendanhay/amazonka";
           description = "Amazon Lightsail SDK";
           license = stdenv.lib.licenses.mpl20;
         }) {};
      "amazonka-marketplace-analytics" = callPackage
        ({ mkDerivation, amazonka-core, base, stdenv }:
         mkDerivation {
           pname = "amazonka-marketplace-analytics";
           version = "1.6.0";
           sha256 = "4d6c0db0e9c17b5131c6b03cd27bc53fbddb144c3910d46639edfdccbecd5d6a";
           libraryHaskellDepends = [ amazonka-core base ];
           doHaddock = false;
           doCheck = false;
           homepage = "https://github.com/brendanhay/amazonka";
           description = "Amazon Marketplace Commerce Analytics SDK";
           license = stdenv.lib.licenses.mpl20;
         }) {};
      "amazonka-marketplace-metering" = callPackage
        ({ mkDerivation, amazonka-core, base, stdenv }:
         mkDerivation {
           pname = "amazonka-marketplace-metering";
           version = "1.6.0";
           sha256 = "672de14acac579673c8c3cf032c3806554355cc84ae1b61882a589af2afb5f77";
           libraryHaskellDepends = [ amazonka-core base ];
           doHaddock = false;
           doCheck = false;
           homepage = "https://github.com/brendanhay/amazonka";
           description = "Amazon Marketplace Metering SDK";
           license = stdenv.lib.licenses.mpl20;
         }) {};
      "amazonka-ml" = callPackage
        ({ mkDerivation, amazonka-core, base, stdenv }:
         mkDerivation {
           pname = "amazonka-ml";
           version = "1.6.0";
           sha256 = "9dc12d7b71a72ea720efe9de60668ab904adddfdfbe9c422f5ebda940a556dfe";
           libraryHaskellDepends = [ amazonka-core base ];
           doHaddock = false;
           doCheck = false;
           homepage = "https://github.com/brendanhay/amazonka";
           description = "Amazon Machine Learning SDK";
           license = stdenv.lib.licenses.mpl20;
         }) {};
      "amazonka-opsworks" = callPackage
        ({ mkDerivation, amazonka-core, base, stdenv }:
         mkDerivation {
           pname = "amazonka-opsworks";
           version = "1.6.0";
           sha256 = "9a4372339b8ec556331b0198b5faf74bd8116f0816176aa8626d31f3b372d918";
           libraryHaskellDepends = [ amazonka-core base ];
           doHaddock = false;
           doCheck = false;
           homepage = "https://github.com/brendanhay/amazonka";
           description = "Amazon OpsWorks SDK";
           license = stdenv.lib.licenses.mpl20;
         }) {};
      "amazonka-opsworks-cm" = callPackage
        ({ mkDerivation, amazonka-core, base, stdenv }:
         mkDerivation {
           pname = "amazonka-opsworks-cm";
           version = "1.6.0";
           sha256 = "4f9e9b755f70fffd15cea08d0dfef5dc23ee4f822471f8e89f4d9b2f77a748f4";
           libraryHaskellDepends = [ amazonka-core base ];
           doHaddock = false;
           doCheck = false;
           homepage = "https://github.com/brendanhay/amazonka";
           description = "Amazon OpsWorks for Chef Automate SDK";
           license = stdenv.lib.licenses.mpl20;
         }) {};
      "amazonka-pinpoint" = callPackage
        ({ mkDerivation, amazonka-core, base, stdenv }:
         mkDerivation {
           pname = "amazonka-pinpoint";
           version = "1.6.0";
           sha256 = "b0f8cdaabd9f357d5a687999ce83c7670f43023507ab9b25e94bc717f916b005";
           libraryHaskellDepends = [ amazonka-core base ];
           doHaddock = false;
           doCheck = false;
           homepage = "https://github.com/brendanhay/amazonka";
           description = "Amazon Pinpoint SDK";
           license = stdenv.lib.licenses.mpl20;
         }) {};
      "amazonka-polly" = callPackage
        ({ mkDerivation, amazonka-core, base, stdenv }:
         mkDerivation {
           pname = "amazonka-polly";
           version = "1.6.0";
           sha256 = "773edcfa2628cb9e616b9f1f5fab461cd6f0e5822dafa43fef4403c54e958ad0";
           libraryHaskellDepends = [ amazonka-core base ];
           doHaddock = false;
           doCheck = false;
           homepage = "https://github.com/brendanhay/amazonka";
           description = "Amazon Polly SDK";
           license = stdenv.lib.licenses.mpl20;
         }) {};
      "amazonka-rds" = callPackage
        ({ mkDerivation, amazonka-core, base, stdenv }:
         mkDerivation {
           pname = "amazonka-rds";
           version = "1.6.0";
           sha256 = "c793613c53773b3ba8c5db1fa342e68c25fcada39f8557c6ed39feb05f1bc24d";
           libraryHaskellDepends = [ amazonka-core base ];
           doHaddock = false;
           doCheck = false;
           homepage = "https://github.com/brendanhay/amazonka";
           description = "Amazon Relational Database Service SDK";
           license = stdenv.lib.licenses.mpl20;
         }) {};
      "amazonka-redshift" = callPackage
        ({ mkDerivation, amazonka-core, base, stdenv }:
         mkDerivation {
           pname = "amazonka-redshift";
           version = "1.6.0";
           sha256 = "426ab96936e8d42ed85b31f076d99304148a6eb0896edbe90c6b1e570a90b329";
           libraryHaskellDepends = [ amazonka-core base ];
           doHaddock = false;
           doCheck = false;
           homepage = "https://github.com/brendanhay/amazonka";
           description = "Amazon Redshift SDK";
           license = stdenv.lib.licenses.mpl20;
         }) {};
      "amazonka-rekognition" = callPackage
        ({ mkDerivation, amazonka-core, base, stdenv }:
         mkDerivation {
           pname = "amazonka-rekognition";
           version = "1.6.0";
           sha256 = "462e427021e5362747b155ba4f77e4c1d99d794087dca273697fae93aff532a8";
           libraryHaskellDepends = [ amazonka-core base ];
           doHaddock = false;
           doCheck = false;
           homepage = "https://github.com/brendanhay/amazonka";
           description = "Amazon Rekognition SDK";
           license = stdenv.lib.licenses.mpl20;
         }) {};
      "amazonka-route53" = callPackage
        ({ mkDerivation, amazonka-core, base, stdenv, text }:
         mkDerivation {
           pname = "amazonka-route53";
           version = "1.6.0";
           sha256 = "68ef773bd9c44b28cb6166d86e3e499d9d32581915548ba08670f5cb1caa6317";
           libraryHaskellDepends = [ amazonka-core base text ];
           doHaddock = false;
           doCheck = false;
           homepage = "https://github.com/brendanhay/amazonka";
           description = "Amazon Route 53 SDK";
           license = stdenv.lib.licenses.mpl20;
         }) {};
      "amazonka-route53-domains" = callPackage
        ({ mkDerivation, amazonka-core, base, stdenv }:
         mkDerivation {
           pname = "amazonka-route53-domains";
           version = "1.6.0";
           sha256 = "f75bfe2f5f57c7367412479f3406cabcafa11a1436dd19f9a00ead6932e1a5ea";
           libraryHaskellDepends = [ amazonka-core base ];
           doHaddock = false;
           doCheck = false;
           homepage = "https://github.com/brendanhay/amazonka";
           description = "Amazon Route 53 Domains SDK";
           license = stdenv.lib.licenses.mpl20;
         }) {};
      "amazonka-s3" = callPackage
        ({ mkDerivation, amazonka-core, base, lens, stdenv, text }:
         mkDerivation {
           pname = "amazonka-s3";
           version = "1.6.0";
           sha256 = "eca18ebbd0df13a78768d9665827c7624282f76d512b3cf8f0f22a3afd463f47";
           libraryHaskellDepends = [ amazonka-core base lens text ];
           doHaddock = false;
           doCheck = false;
           homepage = "https://github.com/brendanhay/amazonka";
           description = "Amazon Simple Storage Service SDK";
           license = stdenv.lib.licenses.mpl20;
         }) {};
      "amazonka-sdb" = callPackage
        ({ mkDerivation, amazonka-core, base, stdenv }:
         mkDerivation {
           pname = "amazonka-sdb";
           version = "1.6.0";
           sha256 = "b9c28b21326fdb78a0acee0968188ffb6fb156c7fe0faf688a2ec83d3f5fbdfd";
           libraryHaskellDepends = [ amazonka-core base ];
           doHaddock = false;
           doCheck = false;
           homepage = "https://github.com/brendanhay/amazonka";
           description = "Amazon SimpleDB SDK";
           license = stdenv.lib.licenses.mpl20;
         }) {};
      "amazonka-servicecatalog" = callPackage
        ({ mkDerivation, amazonka-core, base, stdenv }:
         mkDerivation {
           pname = "amazonka-servicecatalog";
           version = "1.6.0";
           sha256 = "11f8df3b1b2b43ec636eb5a428c43c8534eae9d9554071298688005bcb46f264";
           libraryHaskellDepends = [ amazonka-core base ];
           doHaddock = false;
           doCheck = false;
           homepage = "https://github.com/brendanhay/amazonka";
           description = "Amazon Service Catalog SDK";
           license = stdenv.lib.licenses.mpl20;
         }) {};
      "amazonka-ses" = callPackage
        ({ mkDerivation, amazonka-core, base, stdenv }:
         mkDerivation {
           pname = "amazonka-ses";
           version = "1.6.0";
           sha256 = "778d32e738faae3fd1a7e12a67dddce063c0480740b95e1a58b5c23dc052bd02";
           libraryHaskellDepends = [ amazonka-core base ];
           doHaddock = false;
           doCheck = false;
           homepage = "https://github.com/brendanhay/amazonka";
           description = "Amazon Simple Email Service SDK";
           license = stdenv.lib.licenses.mpl20;
         }) {};
      "amazonka-shield" = callPackage
        ({ mkDerivation, amazonka-core, base, stdenv }:
         mkDerivation {
           pname = "amazonka-shield";
           version = "1.6.0";
           sha256 = "b983a85b2b5a617bc3cbc911bc8d00a3fbf199ddd5dee67bdb3882b23747ebf4";
           libraryHaskellDepends = [ amazonka-core base ];
           doHaddock = false;
           doCheck = false;
           homepage = "https://github.com/brendanhay/amazonka";
           description = "Amazon Shield SDK";
           license = stdenv.lib.licenses.mpl20;
         }) {};
      "amazonka-sms" = callPackage
        ({ mkDerivation, amazonka-core, base, stdenv }:
         mkDerivation {
           pname = "amazonka-sms";
           version = "1.6.0";
           sha256 = "fc4d359d2988d7604780a5eca5b3371d3d3034180e96d2cbc6148559f0cda47f";
           libraryHaskellDepends = [ amazonka-core base ];
           doHaddock = false;
           doCheck = false;
           homepage = "https://github.com/brendanhay/amazonka";
           description = "Amazon Server Migration Service SDK";
           license = stdenv.lib.licenses.mpl20;
         }) {};
      "amazonka-snowball" = callPackage
        ({ mkDerivation, amazonka-core, base, stdenv }:
         mkDerivation {
           pname = "amazonka-snowball";
           version = "1.6.0";
           sha256 = "534b30fe9205ba1edf8b1c5c4f4f91dccbe124f95a599f5efdf0cc4cd502ee25";
           libraryHaskellDepends = [ amazonka-core base ];
           doHaddock = false;
           doCheck = false;
           homepage = "https://github.com/brendanhay/amazonka";
           description = "Amazon Import/Export Snowball SDK";
           license = stdenv.lib.licenses.mpl20;
         }) {};
      "amazonka-sns" = callPackage
        ({ mkDerivation, amazonka-core, base, stdenv }:
         mkDerivation {
           pname = "amazonka-sns";
           version = "1.6.0";
           sha256 = "1d16b548031359ed593b14d172e7880847934e76bbedf535d014674414e37573";
           libraryHaskellDepends = [ amazonka-core base ];
           doHaddock = false;
           doCheck = false;
           homepage = "https://github.com/brendanhay/amazonka";
           description = "Amazon Simple Notification Service SDK";
           license = stdenv.lib.licenses.mpl20;
         }) {};
      "amazonka-sqs" = callPackage
        ({ mkDerivation, amazonka-core, base, stdenv }:
         mkDerivation {
           pname = "amazonka-sqs";
           version = "1.6.0";
           sha256 = "743838707d28707095700afdf2d875ff34c5fe1d90b214f5a7e48be04c900433";
           libraryHaskellDepends = [ amazonka-core base ];
           doHaddock = false;
           doCheck = false;
           homepage = "https://github.com/brendanhay/amazonka";
           description = "Amazon Simple Queue Service SDK";
           license = stdenv.lib.licenses.mpl20;
         }) {};
      "amazonka-ssm" = callPackage
        ({ mkDerivation, amazonka-core, base, stdenv }:
         mkDerivation {
           pname = "amazonka-ssm";
           version = "1.6.0";
           sha256 = "11218249760a2d06cfd5ad2b41bf67233b6178f86e2ab979c199088a5a1c701a";
           libraryHaskellDepends = [ amazonka-core base ];
           doHaddock = false;
           doCheck = false;
           homepage = "https://github.com/brendanhay/amazonka";
           description = "Amazon Simple Systems Manager (SSM) SDK";
           license = stdenv.lib.licenses.mpl20;
         }) {};
      "amazonka-stepfunctions" = callPackage
        ({ mkDerivation, amazonka-core, base, stdenv }:
         mkDerivation {
           pname = "amazonka-stepfunctions";
           version = "1.6.0";
           sha256 = "99ac8e545d28d7d765e180a26572d216f88d1e6ab9a2cd0f0a874992fa89acbf";
           libraryHaskellDepends = [ amazonka-core base ];
           doHaddock = false;
           doCheck = false;
           homepage = "https://github.com/brendanhay/amazonka";
           description = "Amazon Step Functions SDK";
           license = stdenv.lib.licenses.mpl20;
         }) {};
      "amazonka-storagegateway" = callPackage
        ({ mkDerivation, amazonka-core, base, stdenv }:
         mkDerivation {
           pname = "amazonka-storagegateway";
           version = "1.6.0";
           sha256 = "6f06376650f03107ebd13a622b77b1983da91c6030927e2d10afb4040b48b43d";
           libraryHaskellDepends = [ amazonka-core base ];
           doHaddock = false;
           doCheck = false;
           homepage = "https://github.com/brendanhay/amazonka";
           description = "Amazon Storage Gateway SDK";
           license = stdenv.lib.licenses.mpl20;
         }) {};
      "amazonka-sts" = callPackage
        ({ mkDerivation, amazonka-core, base, stdenv }:
         mkDerivation {
           pname = "amazonka-sts";
           version = "1.6.0";
           sha256 = "36056b67d6f97a5b137f7ae35f39fb5417c61991333347129ed3e77f79a99a12";
           libraryHaskellDepends = [ amazonka-core base ];
           doHaddock = false;
           doCheck = false;
           homepage = "https://github.com/brendanhay/amazonka";
           description = "Amazon Security Token Service SDK";
           license = stdenv.lib.licenses.mpl20;
         }) {};
      "amazonka-support" = callPackage
        ({ mkDerivation, amazonka-core, base, stdenv }:
         mkDerivation {
           pname = "amazonka-support";
           version = "1.6.0";
           sha256 = "7f434aef975f2817d4b9d7aa1c6055d788988e817fdb5c8fae20a787f26853e9";
           libraryHaskellDepends = [ amazonka-core base ];
           doHaddock = false;
           doCheck = false;
           homepage = "https://github.com/brendanhay/amazonka";
           description = "Amazon Support SDK";
           license = stdenv.lib.licenses.mpl20;
         }) {};
      "amazonka-swf" = callPackage
        ({ mkDerivation, amazonka-core, base, stdenv }:
         mkDerivation {
           pname = "amazonka-swf";
           version = "1.6.0";
           sha256 = "1f0e437ba9c1511f46c64df16ae4551667fee39ade3c32f251f9e34b2255aa90";
           libraryHaskellDepends = [ amazonka-core base ];
           doHaddock = false;
           doCheck = false;
           homepage = "https://github.com/brendanhay/amazonka";
           description = "Amazon Simple Workflow Service SDK";
           license = stdenv.lib.licenses.mpl20;
         }) {};
      "amazonka-test" = callPackage
        ({ mkDerivation, aeson, amazonka-core, base, bifunctors, bytestring
         , case-insensitive, conduit, conduit-extra, groom, http-client
         , http-types, process, resourcet, stdenv, tasty, tasty-hunit
         , template-haskell, temporary, text, time, unordered-containers
         , yaml
         }:
         mkDerivation {
           pname = "amazonka-test";
           version = "1.6.0";
           sha256 = "46a8b77900370524a487f2ca0490473e23d0155664db2461c5504678d275dd28";
           libraryHaskellDepends = [
             aeson amazonka-core base bifunctors bytestring case-insensitive
             conduit conduit-extra groom http-client http-types process
             resourcet tasty tasty-hunit template-haskell temporary text time
             unordered-containers yaml
           ];
           doHaddock = false;
           doCheck = false;
           homepage = "https://github.com/brendanhay/amazonka";
           description = "Common functionality for Amazonka library test-suites";
           license = stdenv.lib.licenses.mpl20;
         }) {};
      "amazonka-waf" = callPackage
        ({ mkDerivation, amazonka-core, base, stdenv }:
         mkDerivation {
           pname = "amazonka-waf";
           version = "1.6.0";
           sha256 = "880b9ec52be2d8fb0f5711d1e5357b0ce566e98b775e3bb7921e8f4295bbb980";
           libraryHaskellDepends = [ amazonka-core base ];
           doHaddock = false;
           doCheck = false;
           homepage = "https://github.com/brendanhay/amazonka";
           description = "Amazon WAF SDK";
           license = stdenv.lib.licenses.mpl20;
         }) {};
      "amazonka-workspaces" = callPackage
        ({ mkDerivation, amazonka-core, base, stdenv }:
         mkDerivation {
           pname = "amazonka-workspaces";
           version = "1.6.0";
           sha256 = "56cf348d8c519a4db23693e81cccf822975ec5b37e74dda54f9f020415c91c84";
           libraryHaskellDepends = [ amazonka-core base ];
           doHaddock = false;
           doCheck = false;
           homepage = "https://github.com/brendanhay/amazonka";
           description = "Amazon WorkSpaces SDK";
           license = stdenv.lib.licenses.mpl20;
         }) {};
      "amazonka-xray" = callPackage
        ({ mkDerivation, amazonka-core, base, stdenv }:
         mkDerivation {
           pname = "amazonka-xray";
           version = "1.6.0";
           sha256 = "8f510075361aa600cd7759763f4de55aed07b8a7cce65eb445dfcf9f475590f0";
           libraryHaskellDepends = [ amazonka-core base ];
           doHaddock = false;
           doCheck = false;
           homepage = "https://github.com/brendanhay/amazonka";
           description = "Amazon X-Ray SDK";
           license = stdenv.lib.licenses.mpl20;
         }) {};
      "amqp" = callPackage
        ({ mkDerivation, base, binary, bytestring, clock, connection
         , containers, data-binary-ieee754, monad-control, network
         , network-uri, split, stdenv, stm, text, vector, xml
         }:
         mkDerivation {
           pname = "amqp";
           version = "0.18.1";
           sha256 = "4678e2eb976df97e27cacbc4b1feafeb5a1800a9779b0a36666f04804f43e248";
           isLibrary = true;
           isExecutable = true;
           libraryHaskellDepends = [
             base binary bytestring clock connection containers
             data-binary-ieee754 monad-control network network-uri split stm
             text vector
           ];
           executableHaskellDepends = [ base containers xml ];
           doHaddock = false;
           doCheck = false;
           homepage = "https://github.com/hreinhardt/amqp";
           description = "Client library for AMQP servers (currently only RabbitMQ)";
           license = stdenv.lib.licenses.bsd3;
         }) {};
      "annotated-wl-pprint" = callPackage
        ({ mkDerivation, base, stdenv }:
         mkDerivation {
           pname = "annotated-wl-pprint";
           version = "0.7.0";
           sha256 = "0c262d7fe13a9a50216438ec882c13e25f31236b886a5692e3c35b85cd773d18";
           revision = "1";
           editedCabalFile = "138k24qxvl90l7dwdw1b3w36mpw93n0xi0nljblqg88pxg7jcvjx";
           libraryHaskellDepends = [ base ];
           doHaddock = false;
           doCheck = false;
           homepage = "https://github.com/david-christiansen/annotated-wl-pprint";
           description = "The Wadler/Leijen Pretty Printer, with annotation support";
           license = stdenv.lib.licenses.bsd3;
         }) {};
      "ansi-terminal" = callPackage
        ({ mkDerivation, base, colour, stdenv }:
         mkDerivation {
           pname = "ansi-terminal";
           version = "0.8.2";
           sha256 = "90a7324811e7da0d0aecd66454b1622e3b1ee22ed09bbdae379c0ff079d2fa90";
           isLibrary = true;
           isExecutable = true;
           libraryHaskellDepends = [ base colour ];
           doHaddock = false;
           doCheck = false;
           homepage = "https://github.com/feuerbach/ansi-terminal";
           description = "Simple ANSI terminal support, with Windows compatibility";
           license = stdenv.lib.licenses.bsd3;
         }) {};
      "ansi-wl-pprint" = callPackage
        ({ mkDerivation, ansi-terminal, base, stdenv }:
         mkDerivation {
           pname = "ansi-wl-pprint";
           version = "0.6.8.2";
           sha256 = "a630721bd57678c3bfeb6c703f8249e434cbf85f40daceec4660fb8c6725cb3e";
           revision = "2";
           editedCabalFile = "0xq83bwya8mfijp3dn9zfsqbbkl1wpzfjcmnkw8a06icjh9vg458";
           isLibrary = true;
           isExecutable = true;
           libraryHaskellDepends = [ ansi-terminal base ];
           doHaddock = false;
           doCheck = false;
           homepage = "http://github.com/ekmett/ansi-wl-pprint";
           description = "The Wadler/Leijen Pretty Printer for colored ANSI terminal output";
           license = stdenv.lib.licenses.bsd3;
         }) {};
      "api-field-json-th" = callPackage
        ({ mkDerivation, aeson, base, lens, split, stdenv, template-haskell
         , text
         }:
         mkDerivation {
           pname = "api-field-json-th";
           version = "0.1.0.2";
           sha256 = "b8d49c3869bc8104539c43d5544ed2271d1e68a963440d781ee71d2252b0f724";
           libraryHaskellDepends = [
             aeson base lens split template-haskell text
           ];
           doHaddock = false;
           doCheck = false;
           homepage = "https://github.com/nakaji-dayo/api-field-json-th";
           description = "option of aeson's deriveJSON";
           license = stdenv.lib.licenses.bsd3;
         }) {};
      "app-settings" = callPackage
        ({ mkDerivation, base, containers, directory, mtl, parsec, stdenv
         , text
         }:
         mkDerivation {
           pname = "app-settings";
           version = "0.2.0.12";
           sha256 = "2bd198b97077090476f8f512a7c03f3ab4147a6df51cf8cd22b5145c37b2ccda";
           libraryHaskellDepends = [
             base containers directory mtl parsec text
           ];
           doHaddock = false;
           doCheck = false;
           homepage = "https://github.com/emmanueltouzery/app-settings";
           description = "A library to manage application settings (INI file-like)";
           license = stdenv.lib.licenses.bsd3;
         }) {};
      "appar" = callPackage
        ({ mkDerivation, base, bytestring, stdenv }:
         mkDerivation {
           pname = "appar";
           version = "0.1.7";
           sha256 = "f6de4f1d1332d665057a9fd1af6b805f66cf04299b03f53696f3c9db4f7ff21f";
           libraryHaskellDepends = [ base bytestring ];
           doHaddock = false;
           doCheck = false;
           description = "A simple applicative parser";
           license = stdenv.lib.licenses.bsd3;
         }) {};
      "apply-refact" = callPackage
        ({ mkDerivation, base, containers, directory, filemanip, filepath
         , ghc, ghc-exactprint, mtl, optparse-applicative, process, refact
         , stdenv, syb, temporary, transformers, unix-compat
         }:
         mkDerivation {
           pname = "apply-refact";
           version = "0.5.0.0";
           sha256 = "1f5fb9b53f5750c5c73e36f93a708189e15f7300cd2fb95da77ba87a215b74af";
           isLibrary = true;
           isExecutable = true;
           libraryHaskellDepends = [
             base containers directory filemanip ghc ghc-exactprint mtl process
             refact syb temporary transformers unix-compat
           ];
           executableHaskellDepends = [
             base containers directory filemanip filepath ghc ghc-exactprint mtl
             optparse-applicative process refact syb temporary transformers
             unix-compat
           ];
           doHaddock = false;
           doCheck = false;
           description = "Perform refactorings specified by the refact library";
           license = stdenv.lib.licenses.bsd3;
         }) {};
      "apportionment" = callPackage
        ({ mkDerivation, base, containers, stdenv, utility-ht }:
         mkDerivation {
           pname = "apportionment";
           version = "0.0.0.3";
           sha256 = "8f71d0b77152edb048e9f75c72a82b9d7ae1b15432fc011610fe9f1b83225b18";
           libraryHaskellDepends = [ base containers utility-ht ];
           doHaddock = false;
           doCheck = false;
           homepage = "http://hub.darcs.net/thielema/apportionment";
           description = "Round a set of numbers while maintaining its sum";
           license = stdenv.lib.licenses.bsd3;
         }) {};
      "approximate" = callPackage
        ({ mkDerivation, base, binary, bytes, Cabal, cabal-doctest, cereal
         , comonad, deepseq, ghc-prim, hashable, lens, log-domain, pointed
         , safecopy, semigroupoids, semigroups, stdenv, vector
         }:
         mkDerivation {
           pname = "approximate";
           version = "0.3.1";
           sha256 = "d837f716d9e73d68a53a17321f0433dd9ffe71df24d550aed6a34ec1c2ad2ea2";
           setupHaskellDepends = [ base Cabal cabal-doctest ];
           libraryHaskellDepends = [
             base binary bytes cereal comonad deepseq ghc-prim hashable lens
             log-domain pointed safecopy semigroupoids semigroups vector
           ];
           doHaddock = false;
           doCheck = false;
           homepage = "http://github.com/analytics/approximate/";
           description = "Approximate discrete values and numbers";
           license = stdenv.lib.licenses.bsd3;
         }) {};
      "arithmoi" = callPackage
        ({ mkDerivation, array, base, containers, exact-pi, ghc-prim
         , integer-gmp, integer-logarithms, mtl, random, stdenv, vector
         }:
         mkDerivation {
           pname = "arithmoi";
           version = "0.7.0.0";
           sha256 = "8b33049122c6194d61467b3685294c2c0029a3e877f481598f4b21b7285e030c";
           revision = "3";
           editedCabalFile = "1s0jm2y0jhfrj7af80csckiizkfq5h0v4zb92mkwh1pkfi763fha";
           configureFlags = [ "-f-llvm" ];
           libraryHaskellDepends = [
             array base containers exact-pi ghc-prim integer-gmp
             integer-logarithms mtl random vector
           ];
           doHaddock = false;
           doCheck = false;
           homepage = "https://github.com/cartazio/arithmoi";
           description = "Efficient basic number-theoretic functions";
           license = stdenv.lib.licenses.mit;
         }) {};
      "array-memoize" = callPackage
        ({ mkDerivation, array, base, stdenv }:
         mkDerivation {
           pname = "array-memoize";
           version = "0.6.0";
           sha256 = "76c88cb3ed04875821a5601f6a1c40f4e15ef8cb36e8a3d4004df956d1db05dc";
           libraryHaskellDepends = [ array base ];
           doHaddock = false;
           doCheck = false;
           description = "Memoization combinators using arrays for finite sub-domains of functions";
           license = stdenv.lib.licenses.bsd3;
         }) {};
      "arrow-extras" = callPackage
        ({ mkDerivation, base, stdenv }:
         mkDerivation {
           pname = "arrow-extras";
           version = "0.1.0.1";
           sha256 = "c13c3aba839d1ec78a49991fa4038a68c5eb9ef6da61eceb6e68bc3ce0586a6c";
           libraryHaskellDepends = [ base ];
           doHaddock = false;
           doCheck = false;
           homepage = "https://github.com/louispan/arrow-extras#readme";
           description = "Extra functions for Control.Arrow";
           license = stdenv.lib.licenses.bsd3;
         }) {};
      "arrow-list" = callPackage
        ({ mkDerivation, base, containers, mtl, stdenv }:
         mkDerivation {
           pname = "arrow-list";
           version = "0.7";
           sha256 = "33f836f23648aa2cea11533f7a9941127c397eecdca105b2084dded9e039d5d8";
           libraryHaskellDepends = [ base containers mtl ];
           doHaddock = false;
           doCheck = false;
           homepage = "https://github.com/silkapp/arrow-list";
           description = "List arrows for Haskell";
           license = stdenv.lib.licenses.bsd3;
         }) {};
      "ascii-progress" = callPackage
        ({ mkDerivation, async, base, concurrent-output, data-default
         , stdenv, time
         }:
         mkDerivation {
           pname = "ascii-progress";
           version = "0.3.3.0";
           sha256 = "7e3fa6b80c09a83c9ba8a0644ef304ca92d65b76383b8dd023ff9f89ebec913e";
           isLibrary = true;
           isExecutable = true;
           libraryHaskellDepends = [
             async base concurrent-output data-default time
           ];
           doHaddock = false;
           doCheck = false;
           homepage = "https://github.com/yamadapc/haskell-ascii-progress";
           description = "A simple progress bar for the console";
           license = stdenv.lib.licenses.mit;
         }) {};
      "asn1-encoding" = callPackage
        ({ mkDerivation, asn1-types, base, bytestring, hourglass, stdenv }:
         mkDerivation {
           pname = "asn1-encoding";
           version = "0.9.5";
           sha256 = "1e863bfd363f6c3760cc80f2c0d422e17845a9f79fe006030db202ecab5aaf29";
           libraryHaskellDepends = [ asn1-types base bytestring hourglass ];
           doHaddock = false;
           doCheck = false;
           homepage = "http://github.com/vincenthz/hs-asn1";
           description = "ASN1 data reader and writer in RAW, BER and DER forms";
           license = stdenv.lib.licenses.bsd3;
         }) {};
      "asn1-parse" = callPackage
        ({ mkDerivation, asn1-encoding, asn1-types, base, bytestring
         , stdenv
         }:
         mkDerivation {
           pname = "asn1-parse";
           version = "0.9.4";
           sha256 = "c6a328f570c69db73f8d2416f9251e8a03753f90d5d19e76cbe69509a3ceb708";
           libraryHaskellDepends = [
             asn1-encoding asn1-types base bytestring
           ];
           doHaddock = false;
           doCheck = false;
           homepage = "https://github.com/vincenthz/hs-asn1";
           description = "Simple monadic parser for ASN1 stream types";
           license = stdenv.lib.licenses.bsd3;
         }) {};
      "asn1-types" = callPackage
        ({ mkDerivation, base, bytestring, hourglass, memory, stdenv }:
         mkDerivation {
           pname = "asn1-types";
           version = "0.3.2";
           sha256 = "0c571fff4a10559c6a630d4851ba3cdf1d558185ce3dcfca1136f9883d647217";
           libraryHaskellDepends = [ base bytestring hourglass memory ];
           doHaddock = false;
           doCheck = false;
           homepage = "http://github.com/vincenthz/hs-asn1-types";
           description = "ASN.1 types";
           license = stdenv.lib.licenses.bsd3;
         }) {};
      "assert-failure" = callPackage
        ({ mkDerivation, base, pretty-show, stdenv, text }:
         mkDerivation {
           pname = "assert-failure";
           version = "0.1.2.2";
           sha256 = "f69416fd527b4f6933586edfc9ee741a2163c3741471e9b8e46a244495bd4a9d";
           enableSeparateDataOutput = true;
           libraryHaskellDepends = [ base pretty-show text ];
           doHaddock = false;
           doCheck = false;
           homepage = "https://github.com/Mikolaj/assert-failure";
           description = "Syntactic sugar improving 'assert' and 'error'";
           license = stdenv.lib.licenses.bsd3;
         }) {};
      "astro" = callPackage
        ({ mkDerivation, base, matrix, stdenv, time }:
         mkDerivation {
           pname = "astro";
           version = "0.4.2.1";
           sha256 = "da5dde1bcf42e4f48f5f23dbf3a890a2904ecaf86df3d75e365e071b924afe29";
           libraryHaskellDepends = [ base matrix time ];
           doHaddock = false;
           doCheck = false;
           homepage = "https://github.com/aligusnet/astro";
           description = "Amateur astronomical computations";
           license = stdenv.lib.licenses.bsd3;
         }) {};
      "async" = callPackage
        ({ mkDerivation, base, hashable, stdenv, stm }:
         mkDerivation {
           pname = "async";
           version = "2.2.1";
           sha256 = "8f0b86022a1319d3c1c68655790da4b7f98017982e27ec3f3dbfe01029d39027";
           revision = "1";
           editedCabalFile = "0lg8c3iixm7vjjq2nydkqswj78i4iyx2k83hgs12z829yj196y31";
           isLibrary = true;
           isExecutable = true;
           libraryHaskellDepends = [ base hashable stm ];
           doHaddock = false;
           doCheck = false;
           homepage = "https://github.com/simonmar/async";
           description = "Run IO operations asynchronously and wait for their results";
           license = stdenv.lib.licenses.bsd3;
         }) {};
      "async-extra" = callPackage
        ({ mkDerivation, async, base, deepseq, split, stdenv }:
         mkDerivation {
           pname = "async-extra";
           version = "0.2.0.0";
           sha256 = "0d06d5a5cb835597ff1668ae58a1f0d048830164876838533dec4a78eb11cc43";
           libraryHaskellDepends = [ async base deepseq split ];
           doHaddock = false;
           doCheck = false;
           homepage = "https://github.com/agrafix/async-extra#readme";
           description = "Useful concurrent combinators";
           license = stdenv.lib.licenses.mit;
         }) {};
      "async-refresh" = callPackage
        ({ mkDerivation, base, formatting, lifted-async, microlens
         , microlens-th, monad-logger, safe-exceptions, stdenv, stm, text
         , unliftio, unliftio-core
         }:
         mkDerivation {
           pname = "async-refresh";
           version = "0.3.0.0";
           sha256 = "da68061b2548a9b5b3e6f4af60120554ebfae9638dfa0b10cf7a244710a334c9";
           libraryHaskellDepends = [
             base formatting lifted-async microlens microlens-th monad-logger
             safe-exceptions stm text unliftio unliftio-core
           ];
           doHaddock = false;
           doCheck = false;
           homepage = "https://github.com/mtesseract/async-refresh";
           description = "Package implementing core logic for refreshing of expiring data";
           license = stdenv.lib.licenses.bsd3;
         }) {};
      "async-refresh-tokens" = callPackage
        ({ mkDerivation, async-refresh, base, bytestring, formatting
         , microlens, microlens-th, monad-logger, safe-exceptions, stdenv
         , text, unliftio, unliftio-core
         }:
         mkDerivation {
           pname = "async-refresh-tokens";
           version = "0.4.0.0";
           sha256 = "67a7419449428fc5f80e9cfc392df115f03721811d6cd73a6c7cbd83f48dc7df";
           libraryHaskellDepends = [
             async-refresh base bytestring formatting microlens microlens-th
             monad-logger safe-exceptions text unliftio unliftio-core
           ];
           doHaddock = false;
           doCheck = false;
           homepage = "https://github.com/mtesseract/async-refresh-tokens#readme";
           description = "Package implementing core logic for refreshing of expiring access tokens";
           license = stdenv.lib.licenses.bsd3;
         }) {};
      "async-timer" = callPackage
        ({ mkDerivation, async, base, safe-exceptions, stdenv, unliftio
         , unliftio-core
         }:
         mkDerivation {
           pname = "async-timer";
           version = "0.2.0.0";
           sha256 = "0632bfc4c141aa47c461747b3edb59f76ef5523a66ac03be0f32868a5e04cee0";
           libraryHaskellDepends = [
             async base safe-exceptions unliftio unliftio-core
           ];
           doHaddock = false;
           doCheck = false;
           homepage = "https://github.com/mtesseract/async-timer#readme";
           description = "Provides API for timer based execution of IO actions";
           license = stdenv.lib.licenses.bsd3;
         }) {};
      "atom-basic" = callPackage
        ({ mkDerivation, base, base64-bytestring, bytestring, network
         , network-uri, stdenv, text, time
         }:
         mkDerivation {
           pname = "atom-basic";
           version = "0.2.5";
           sha256 = "24be9667b8bad3ad63b2e9b42fdea5aa0fd96f7e90f52fb1203adfa71d2f75ee";
           libraryHaskellDepends = [
             base base64-bytestring bytestring network network-uri text time
           ];
           doHaddock = false;
           doCheck = false;
           description = "Basic Atom feed construction";
           license = stdenv.lib.licenses.bsd3;
         }) {};
      "atom-conduit" = callPackage
        ({ mkDerivation, base, blaze-builder, conduit, conduit-combinators
         , lens-simple, mono-traversable, parsers, safe-exceptions, stdenv
         , text, time, timerep, uri-bytestring, xml-conduit, xml-types
         }:
         mkDerivation {
           pname = "atom-conduit";
           version = "0.5.0.1";
           sha256 = "8c88c5c77567753b56163bfa596f50a9cfdde28796e66bb194ca6d9057e831cd";
           libraryHaskellDepends = [
             base blaze-builder conduit conduit-combinators lens-simple
             mono-traversable parsers safe-exceptions text time timerep
             uri-bytestring xml-conduit xml-types
           ];
           doHaddock = false;
           doCheck = false;
           description = "Streaming parser/renderer for the Atom 1.0 standard (RFC 4287).";
           license = stdenv.lib.licenses.publicDomain;
         }) {};
      "atomic-primops" = callPackage
        ({ mkDerivation, base, ghc-prim, primitive, stdenv }:
         mkDerivation {
           pname = "atomic-primops";
           version = "0.8.2";
           sha256 = "67f8872e0c1e634d819a967365eb4ad514e9b2cde967fbc710da7cdc4d17d933";
           revision = "1";
           editedCabalFile = "0gdcd84x2s4jiry0was74rzv9l53an1q6ad8jiaj37fr4fim0wcc";
           libraryHaskellDepends = [ base ghc-prim primitive ];
           doHaddock = false;
           doCheck = false;
           homepage = "https://github.com/rrnewton/haskell-lockfree/wiki";
           description = "A safe approach to CAS and other atomic ops in Haskell";
           license = stdenv.lib.licenses.bsd3;
         }) {};
      "atomic-write" = callPackage
        ({ mkDerivation, base, bytestring, directory, filepath, stdenv
         , temporary, text, unix-compat
         }:
         mkDerivation {
           pname = "atomic-write";
           version = "0.2.0.6";
           sha256 = "d4634b777ea8df551bc619125b6240047c74b6454c1a3caaad10496a39d443f7";
           libraryHaskellDepends = [
             base bytestring directory filepath temporary text unix-compat
           ];
           doHaddock = false;
           doCheck = false;
           homepage = "https://github.com/stackbuilders/atomic-write";
           description = "Atomically write to a file";
           license = stdenv.lib.licenses.mit;
         }) {};
      "attoparsec" = callPackage
        ({ mkDerivation, array, base, bytestring, containers, deepseq
         , scientific, stdenv, text, transformers
         }:
         mkDerivation {
           pname = "attoparsec";
           version = "0.13.2.2";
           sha256 = "dd93471eb969172cc4408222a3842d867adda3dd7fb39ad8a4df1b121a67d848";
           revision = "3";
           editedCabalFile = "1birva836xdp92lf1v5yrs8lj3bgj9vnarrfh2ssfxxacqj1gjji";
           libraryHaskellDepends = [
             array base bytestring containers deepseq scientific text
             transformers
           ];
           doHaddock = false;
           doCheck = false;
           homepage = "https://github.com/bos/attoparsec";
           description = "Fast combinator parsing for bytestrings and text";
           license = stdenv.lib.licenses.bsd3;
         }) {};
      "attoparsec-base64" = callPackage
        ({ mkDerivation, attoparsec, base, bytestring, stdenv, text, word8
         }:
         mkDerivation {
           pname = "attoparsec-base64";
           version = "0.0.0";
           sha256 = "0833530c8b4a46217272d14638f91325e156b22046fa291b528228afe66173e7";
           libraryHaskellDepends = [ attoparsec base bytestring text word8 ];
           doHaddock = false;
           doCheck = false;
           homepage = "https://github.com/athanclark/attoparsec-base64#readme";
           description = "Fetch only base64 characters, erroring in the attoparsec monad on failure";
           license = stdenv.lib.licenses.bsd3;
         }) {};
      "attoparsec-binary" = callPackage
        ({ mkDerivation, attoparsec, base, bytestring, stdenv }:
         mkDerivation {
           pname = "attoparsec-binary";
           version = "0.2";
           sha256 = "05e6445b20b396c99275de3e37bf8bb18559a5666ad5136907857bf574e77a0b";
           libraryHaskellDepends = [ attoparsec base bytestring ];
           doHaddock = false;
           doCheck = false;
           description = "Binary processing extensions to Attoparsec";
           license = stdenv.lib.licenses.bsd3;
         }) {};
      "attoparsec-expr" = callPackage
        ({ mkDerivation, attoparsec, base, stdenv }:
         mkDerivation {
           pname = "attoparsec-expr";
           version = "0.1.1.2";
           sha256 = "8d4cd436112ce9007d2831776d4c5102a5322c48993229d2d41e259c07bb457c";
           libraryHaskellDepends = [ attoparsec base ];
           doHaddock = false;
           doCheck = false;
           description = "Port of parsec's expression parser to attoparsec";
           license = stdenv.lib.licenses.bsd3;
         }) {};
      "attoparsec-ip" = callPackage
        ({ mkDerivation, attoparsec, base, ip, stdenv }:
         mkDerivation {
           pname = "attoparsec-ip";
           version = "0.0.1";
           sha256 = "8da5ca8ae483bbb8dacfae3a888fa9438f55f84f8605e7c769091ee5b6555629";
           libraryHaskellDepends = [ attoparsec base ip ];
           doHaddock = false;
           doCheck = false;
           homepage = "https://github.com/athanclark/attoparsec-ip#readme";
           description = "Parse IP data types with attoparsec";
           license = stdenv.lib.licenses.bsd3;
         }) {};
      "attoparsec-iso8601" = callPackage
        ({ mkDerivation, attoparsec, base, base-compat, stdenv, text, time
         }:
         mkDerivation {
           pname = "attoparsec-iso8601";
           version = "1.0.1.0";
           sha256 = "499ffbd2d39e79cc4fda5ad0129dbf94fdb72a84aa932dfe2a5f5c5c02074142";
           libraryHaskellDepends = [ attoparsec base base-compat text time ];
           doHaddock = false;
           doCheck = false;
           homepage = "https://github.com/bos/aeson";
           description = "Parsing of ISO 8601 dates, originally from aeson";
           license = stdenv.lib.licenses.bsd3;
         }) {};
      "attoparsec-path" = callPackage
        ({ mkDerivation, attoparsec, base, path, stdenv, text }:
         mkDerivation {
           pname = "attoparsec-path";
           version = "0.0.0.1";
           sha256 = "d07126622210fdb18722f585c61bda0a17389aecc83e786f9f6e621ec120b60c";
           libraryHaskellDepends = [ attoparsec base path text ];
           doHaddock = false;
           doCheck = false;
           homepage = "https://github.com/athanclark/attoparsec-path#readme";
           description = "Convenience bindings between path and attoparsec";
           license = stdenv.lib.licenses.bsd3;
         }) {};
      "attoparsec-uri" = callPackage
        ({ mkDerivation, attoparsec, attoparsec-ip, base, bytedump, ip
         , stdenv, strict, text, vector
         }:
         mkDerivation {
           pname = "attoparsec-uri";
           version = "0.0.4";
           sha256 = "4e032ccaa65f96edac79556431ade75ad400371d0a5c19aeed6a7adbd3d2f1f3";
           libraryHaskellDepends = [
             attoparsec attoparsec-ip base bytedump ip strict text vector
           ];
           doHaddock = false;
           doCheck = false;
           homepage = "https://github.com/athanclark/attoparsec-uri#readme";
           description = "URI parser / printer using attoparsec";
           license = stdenv.lib.licenses.bsd3;
         }) {};
      "audacity" = callPackage
        ({ mkDerivation, base, bytestring, deepseq, directory
         , explicit-exception, filepath, non-empty, semigroups, stdenv
         , storable-record, storablevector, tagchup, transformers
         , utility-ht, xml-basic
         }:
         mkDerivation {
           pname = "audacity";
           version = "0.0.2";
           sha256 = "d9d2dfb1c4e6ad39b535561feb720a7889dc1151ad6625fd5522d4212dbc26a4";
           isLibrary = true;
           isExecutable = true;
           libraryHaskellDepends = [
             base bytestring deepseq directory explicit-exception filepath
             non-empty semigroups storable-record storablevector tagchup
             transformers utility-ht xml-basic
           ];
           doHaddock = false;
           doCheck = false;
           homepage = "http://hub.darcs.net/thielema/audacity";
           description = "Interchange with the Audacity sound signal editor";
           license = stdenv.lib.licenses.bsd3;
         }) {};
      "authenticate" = callPackage
        ({ mkDerivation, aeson, attoparsec, base, blaze-builder, bytestring
         , case-insensitive, conduit, containers, http-conduit, http-types
         , network-uri, resourcet, stdenv, tagstream-conduit, text
         , transformers, unordered-containers, xml-conduit
         }:
         mkDerivation {
           pname = "authenticate";
           version = "1.3.4";
           sha256 = "3fd566dbfdf75d81ad1bebd19facb9f01509ead6e27d9aed802404ecde932fb8";
           revision = "1";
           editedCabalFile = "0ipbmf633c0kmcwwb7d51ac8s4220nfyk5xghhq66mpgna77j2c2";
           libraryHaskellDepends = [
             aeson attoparsec base blaze-builder bytestring case-insensitive
             conduit containers http-conduit http-types network-uri resourcet
             tagstream-conduit text transformers unordered-containers
             xml-conduit
           ];
           doHaddock = false;
           doCheck = false;
           homepage = "http://github.com/yesodweb/authenticate";
           description = "Authentication methods for Haskell web applications";
           license = stdenv.lib.licenses.mit;
         }) {};
      "authenticate-oauth" = callPackage
        ({ mkDerivation, base, base64-bytestring, blaze-builder, bytestring
         , crypto-pubkey-types, data-default, http-client, http-types
         , random, RSA, SHA, stdenv, time, transformers, transformers-compat
         }:
         mkDerivation {
           pname = "authenticate-oauth";
           version = "1.6";
           sha256 = "d26d9f10fd57e06fa2af066df65e578ff3ec7541efc3e6648b29a743b13f8375";
           revision = "1";
           editedCabalFile = "1fxwn8bn6qs8dhxq0q04psq7zp1qvw1b6g3vmsclgyj9p7kr77ms";
           libraryHaskellDepends = [
             base base64-bytestring blaze-builder bytestring crypto-pubkey-types
             data-default http-client http-types random RSA SHA time
             transformers transformers-compat
           ];
           doHaddock = false;
           doCheck = false;
           homepage = "http://github.com/yesodweb/authenticate";
           description = "Library to authenticate with OAuth for Haskell web applications";
           license = stdenv.lib.licenses.bsd3;
         }) {};
      "auto" = callPackage
        ({ mkDerivation, base, base-orphans, bytestring, cereal, containers
         , deepseq, MonadRandom, profunctors, random, semigroups, stdenv
         , transformers
         }:
         mkDerivation {
           pname = "auto";
           version = "0.4.3.1";
           sha256 = "c6e26d1cbb17e3645e55bc8e9432b124520fbcba5ff32445acd4260c25cd3b41";
           libraryHaskellDepends = [
             base base-orphans bytestring cereal containers deepseq MonadRandom
             profunctors random semigroups transformers
           ];
           doHaddock = false;
           doCheck = false;
           homepage = "https://github.com/mstksg/auto";
           description = "Denotative, locally stateful programming DSL & platform";
           license = stdenv.lib.licenses.mit;
         }) {};
      "auto-update" = callPackage
        ({ mkDerivation, base, stdenv }:
         mkDerivation {
           pname = "auto-update";
           version = "0.1.4";
           sha256 = "5e96c151024e8bcaf4eaa932e16995872b2017f46124b967e155744d9580b425";
           libraryHaskellDepends = [ base ];
           doHaddock = false;
           doCheck = false;
           homepage = "https://github.com/yesodweb/wai";
           description = "Efficiently run periodic, on-demand actions";
           license = stdenv.lib.licenses.mit;
         }) {};
      "autoexporter" = callPackage
        ({ mkDerivation, base, Cabal, directory, filepath, stdenv }:
         mkDerivation {
           pname = "autoexporter";
           version = "1.1.13";
           sha256 = "7bb6fbf567f56a5a3ec53036fe82aa8e17452c46778a34e9dd00477e5cdcaf16";
           isLibrary = true;
           isExecutable = true;
           libraryHaskellDepends = [ base Cabal directory filepath ];
           executableHaskellDepends = [ base Cabal directory filepath ];
           doHaddock = false;
           doCheck = false;
           homepage = "https://github.com/tfausak/autoexporter#readme";
           description = "Automatically re-export modules";
           license = stdenv.lib.licenses.mit;
         }) {};
      "avro" = callPackage
        ({ mkDerivation, aeson, array, base, base16-bytestring, binary
         , bytestring, containers, data-binary-ieee754, entropy, fail
         , hashable, mtl, pure-zlib, scientific, semigroups, stdenv, tagged
         , template-haskell, text, unordered-containers, vector
         }:
         mkDerivation {
           pname = "avro";
           version = "0.3.5.1";
           sha256 = "c805534d4829dba8055985284a07436cb77481dfc4554d91937d8b0f864afc90";
           libraryHaskellDepends = [
             aeson array base base16-bytestring binary bytestring containers
             data-binary-ieee754 entropy fail hashable mtl pure-zlib scientific
             semigroups tagged template-haskell text unordered-containers vector
           ];
           doHaddock = false;
           doCheck = false;
           homepage = "https://github.com/GaloisInc/avro#readme";
           description = "Avro serialization support for Haskell";
           license = stdenv.lib.licenses.bsd3;
         }) {};
      "avwx" = callPackage
        ({ mkDerivation, attoparsec, base, HTTP, lens, optparse-applicative
         , parsers, pretty-show, stdenv, text
         }:
         mkDerivation {
           pname = "avwx";
           version = "0.3.0.2";
           sha256 = "b4299cc4e05a4c94f53d06f05b30baac1e15c59663b59afd1dd32417a280fb0a";
           isLibrary = true;
           isExecutable = true;
           libraryHaskellDepends = [ attoparsec base HTTP lens parsers text ];
           executableHaskellDepends = [
             base optparse-applicative pretty-show text
           ];
           doHaddock = false;
           doCheck = false;
           homepage = "https://www.hcesperer.org/posts/2016-09-20-avwx.html";
           description = "Parse aviation weather reports";
           license = stdenv.lib.licenses.mit;
         }) {};
      "backprop" = callPackage
        ({ mkDerivation, base, containers, deepseq, microlens, primitive
         , reflection, simple-reflect, stdenv, transformers, vector, vinyl
         }:
         mkDerivation {
           pname = "backprop";
           version = "0.2.5.0";
           sha256 = "aa2dbe41de6aa015cd3c0d9edb21ab24254d19b9205fbc440fc2a6cbccae6bf5";
           libraryHaskellDepends = [
             base containers deepseq microlens primitive reflection
             simple-reflect transformers vector vinyl
           ];
           doHaddock = false;
           doCheck = false;
           homepage = "https://backprop.jle.im";
           description = "Heterogeneous automatic differentation";
           license = stdenv.lib.licenses.bsd3;
         }) {};
      "bank-holidays-england" = callPackage
        ({ mkDerivation, base, containers, stdenv, time }:
         mkDerivation {
           pname = "bank-holidays-england";
           version = "0.1.0.8";
           sha256 = "3219472077c4093809dc7c986b693aee2b76c12d44b6063d1b7055af3aa9672a";
           libraryHaskellDepends = [ base containers time ];
           doHaddock = false;
           doCheck = false;
           homepage = "https://bitbucket.org/davecturner/bank-holidays-england";
           description = "Calculation of bank holidays in England and Wales";
           license = stdenv.lib.licenses.bsd3;
         }) {};
      "barrier" = callPackage
        ({ mkDerivation, base, blaze-svg, bytestring, stdenv
         , template-haskell, text, unordered-containers
         }:
         mkDerivation {
           pname = "barrier";
           version = "0.1.1";
           sha256 = "6395da01eea1984c7bcc85c624b1b5dfbe0b6b764adeed7b04c9fa4d8de91ed9";
           revision = "1";
           editedCabalFile = "167akvi72l47gcqbq5609m24469pq0xmv0kjbmivnrxs796gh890";
           isLibrary = true;
           isExecutable = true;
           enableSeparateDataOutput = true;
           libraryHaskellDepends = [
             base blaze-svg bytestring template-haskell text
             unordered-containers
           ];
           doHaddock = false;
           doCheck = false;
           homepage = "https://github.com/philopon/barrier";
           description = "Shields.io style badge generator";
           license = stdenv.lib.licenses.mit;
         }) {};
      "base-compat" = callPackage
        ({ mkDerivation, base, stdenv, unix }:
         mkDerivation {
           pname = "base-compat";
           version = "0.10.5";
           sha256 = "990aea21568956d44ab018c5dbfbaea014b9a0d5295d29ca7550149419a6fb41";
           libraryHaskellDepends = [ base unix ];
           doHaddock = false;
           doCheck = false;
           description = "A compatibility layer for base";
           license = stdenv.lib.licenses.mit;
         }) {};
      "base-compat-batteries" = callPackage
        ({ mkDerivation, base, base-compat, stdenv }:
         mkDerivation {
           pname = "base-compat-batteries";
           version = "0.10.1";
           sha256 = "15578bafe45db81f7c7ad33253b2b047dab9b6df4ca7ca57f541d64084f113c9";
           libraryHaskellDepends = [ base base-compat ];
           doHaddock = false;
           doCheck = false;
           description = "base-compat with extra batteries";
           license = stdenv.lib.licenses.mit;
         }) {};
      "base-orphans" = callPackage
        ({ mkDerivation, base, ghc-prim, stdenv }:
         mkDerivation {
           pname = "base-orphans";
           version = "0.7";
           sha256 = "0aaddc39e3d0bba13acfcf0009ef57bf91d2ee74b295041d63e14c6caf4dee14";
           libraryHaskellDepends = [ base ghc-prim ];
           doHaddock = false;
           doCheck = false;
           homepage = "https://github.com/haskell-compat/base-orphans#readme";
           description = "Backwards-compatible orphan instances for base";
           license = stdenv.lib.licenses.mit;
         }) {};
      "base-prelude" = callPackage
        ({ mkDerivation, base, stdenv }:
         mkDerivation {
           pname = "base-prelude";
           version = "1.3";
           sha256 = "e3cc66e99d6c83aac548c4d8e6a166e5bd9cf557947cde49161026d0341267fe";
           libraryHaskellDepends = [ base ];
           doHaddock = false;
           doCheck = false;
           homepage = "https://github.com/nikita-volkov/base-prelude";
           description = "The most complete prelude formed solely from the \"base\" package";
           license = stdenv.lib.licenses.mit;
         }) {};
      "base-unicode-symbols" = callPackage
        ({ mkDerivation, base, stdenv }:
         mkDerivation {
           pname = "base-unicode-symbols";
           version = "0.2.2.4";
           sha256 = "a2f841430fec32edba778b74bde83bf0170ada7c5e2e59d7187c8f06d92dcca9";
           libraryHaskellDepends = [ base ];
           doHaddock = false;
           doCheck = false;
           homepage = "http://haskell.org/haskellwiki/Unicode-symbols";
           description = "Unicode alternatives for common functions and operators";
           license = stdenv.lib.licenses.bsd3;
         }) {};
      "base16-bytestring" = callPackage
        ({ mkDerivation, base, bytestring, ghc-prim, stdenv }:
         mkDerivation {
           pname = "base16-bytestring";
           version = "0.1.1.6";
           sha256 = "5afe65a152c5418f5f4e3579a5e0d5ca19c279dc9bf31c1a371ccbe84705c449";
           libraryHaskellDepends = [ base bytestring ghc-prim ];
           doHaddock = false;
           doCheck = false;
           homepage = "http://github.com/bos/base16-bytestring";
           description = "Fast base16 (hex) encoding and decoding for ByteStrings";
           license = stdenv.lib.licenses.bsd3;
         }) {};
      "base32string" = callPackage
        ({ mkDerivation, aeson, base, binary, bytestring, stdenv, text }:
         mkDerivation {
           pname = "base32string";
           version = "0.9.1";
           sha256 = "9e931613aeba5f630f9292fc99131388f406e4b34d8f050515ed93aaf632ea32";
           enableSeparateDataOutput = true;
           libraryHaskellDepends = [ aeson base binary bytestring text ];
           doHaddock = false;
           doCheck = false;
           homepage = "http://www.leonmergen.com/opensource.html";
           description = "Fast and safe representation of a Base-32 string";
           license = stdenv.lib.licenses.mit;
         }) {};
      "base58string" = callPackage
        ({ mkDerivation, aeson, base, binary, bytestring, stdenv, text }:
         mkDerivation {
           pname = "base58string";
           version = "0.10.0";
           sha256 = "3b72607dd76e30a5054acea656c3805f7191e27d67884a7db5fbc73c17e9c088";
           enableSeparateDataOutput = true;
           libraryHaskellDepends = [ aeson base binary bytestring text ];
           doHaddock = false;
           doCheck = false;
           homepage = "http://www.leonmergen.com/opensource.html";
           description = "Fast and safe representation of a Base-58 string";
           license = stdenv.lib.licenses.mit;
         }) {};
      "base64-bytestring" = callPackage
        ({ mkDerivation, base, bytestring, stdenv }:
         mkDerivation {
           pname = "base64-bytestring";
           version = "1.0.0.2";
           sha256 = "193654ed9bd9e7f20163c9b70bab32d33010be50a5e1e8e2258229faf32a608c";
           libraryHaskellDepends = [ base bytestring ];
           doHaddock = false;
           doCheck = false;
           homepage = "https://github.com/haskell/base64-bytestring";
           description = "Fast base64 encoding and decoding for ByteStrings";
           license = stdenv.lib.licenses.bsd3;
         }) {};
      "base64-bytestring-type" = callPackage
        ({ mkDerivation, aeson, base, base-compat, base64-bytestring
         , binary, bytestring, cereal, deepseq, hashable, QuickCheck, stdenv
         , text
         }:
         mkDerivation {
           pname = "base64-bytestring-type";
           version = "1";
           sha256 = "74019bd11f8012ae5ccc88c206bc5a8024f7605130099aabbac012073160e440";
           revision = "4";
           editedCabalFile = "0yfhy4a9n67l9w3amqrzzy79q47yyj6qbv5i5lqym5z7ygwmlzn6";
           libraryHaskellDepends = [
             aeson base base-compat base64-bytestring binary bytestring cereal
             deepseq hashable QuickCheck text
           ];
           doHaddock = false;
           doCheck = false;
           homepage = "https://github.com/futurice/haskell-base64-bytestring-type#readme";
           description = "A newtype around ByteString, for base64 encoding";
           license = stdenv.lib.licenses.bsd3;
         }) {};
      "base64-string" = callPackage
        ({ mkDerivation, base, stdenv }:
         mkDerivation {
           pname = "base64-string";
           version = "0.2";
           sha256 = "3ec896ca7261ad4ddeffbaa3bdf4d5cb61775250c303fca9929aa9a56acc705e";
           libraryHaskellDepends = [ base ];
           doHaddock = false;
           doCheck = false;
           homepage = "http://urchin.earth.li/~ian/cabal/base64-string/";
           description = "Base64 implementation for String's";
           license = "unknown";
           hydraPlatforms = stdenv.lib.platforms.none;
         }) {};
      "basement" = callPackage
        ({ mkDerivation, base, ghc-prim, stdenv }:
         mkDerivation {
           pname = "basement";
           version = "0.0.8";
           sha256 = "c7f41b97f2b0a71804c3c7d760047dc9adc9734e789084ca1198c4764ce192a4";
           revision = "1";
           editedCabalFile = "005w4d6bkx6xq1whgwna4rqmxc36vgjbvb8q35sh1z2s76l89ajy";
           libraryHaskellDepends = [ base ghc-prim ];
           doHaddock = false;
           doCheck = false;
           homepage = "https://github.com/haskell-foundation/foundation#readme";
           description = "Foundation scrap box of array & string";
           license = stdenv.lib.licenses.bsd3;
         }) {};
      "basic-prelude" = callPackage
        ({ mkDerivation, base, bytestring, containers, filepath, hashable
         , stdenv, text, transformers, unordered-containers, vector
         }:
         mkDerivation {
           pname = "basic-prelude";
           version = "0.7.0";
           sha256 = "10755f892548faa956b81b40d1d03ec6e94609fd8ec8e92be09b4453b7ad9379";
           libraryHaskellDepends = [
             base bytestring containers filepath hashable text transformers
             unordered-containers vector
           ];
           doHaddock = false;
           doCheck = false;
           homepage = "https://github.com/snoyberg/basic-prelude#readme";
           description = "An enhanced core prelude; a common foundation for alternate preludes";
           license = stdenv.lib.licenses.mit;
         }) {};
      "bbdb" = callPackage
        ({ mkDerivation, base, parsec, stdenv }:
         mkDerivation {
           pname = "bbdb";
           version = "0.8";
           sha256 = "dce7798cb8e46e1c0f7048579496cabeebddaba9b6233820fd0496723fbc2a5c";
           libraryHaskellDepends = [ base parsec ];
           doHaddock = false;
           doCheck = false;
           homepage = "https://github.com/henrylaxen/bbdb";
           description = "Ability to read, write, and modify BBDB files";
           license = stdenv.lib.licenses.gpl3;
         }) {};
      "bcrypt" = callPackage
        ({ mkDerivation, base, bytestring, data-default, entropy, memory
         , stdenv
         }:
         mkDerivation {
           pname = "bcrypt";
           version = "0.0.11";
           sha256 = "e4331788eda7b65064d88930b4b7a50f5011bdec0ad46059d8c4ee6a5e72fcef";
           libraryHaskellDepends = [
             base bytestring data-default entropy memory
           ];
           doHaddock = false;
           doCheck = false;
           description = "Haskell bindings to the bcrypt password hash";
           license = stdenv.lib.licenses.bsd3;
         }) {};
      "beam-core" = callPackage
        ({ mkDerivation, aeson, base, bytestring, containers, dlist, free
         , ghc-prim, hashable, microlens, mtl, network-uri, stdenv, tagged
         , text, time, vector-sized
         }:
         mkDerivation {
           pname = "beam-core";
           version = "0.7.2.2";
           sha256 = "1231aedb995f40758924ad39d3476a51b3a186e5e849f3d4b284860838500f98";
           revision = "1";
           editedCabalFile = "1fvds5arsm0h81fw4rf5fsg5sa9jfqn350amhhc247f0hhjy3csf";
           libraryHaskellDepends = [
             aeson base bytestring containers dlist free ghc-prim hashable
             microlens mtl network-uri tagged text time vector-sized
           ];
           doHaddock = false;
           doCheck = false;
           homepage = "http://travis.athougies.net/projects/beam.html";
           description = "Type-safe, feature-complete SQL query and manipulation interface for Haskell";
           license = stdenv.lib.licenses.mit;
         }) {};
      "beam-migrate" = callPackage
        ({ mkDerivation, aeson, base, beam-core, bytestring, containers
         , deepseq, dependent-map, dependent-sum, free, ghc-prim, hashable
         , haskell-src-exts, mtl, parallel, pqueue, pretty, scientific
         , stdenv, text, time, unordered-containers, uuid-types, vector
         }:
         mkDerivation {
           pname = "beam-migrate";
           version = "0.3.2.1";
           sha256 = "2d195926ead3ed550e5efddd32f87f4cc93a5bad6ac8c2906478387ed0f39373";
           revision = "1";
           editedCabalFile = "1ghg6n0dj63i0am7wh0cg95hwyf29gnkm0llrw3wb5pj8f7937gv";
           libraryHaskellDepends = [
             aeson base beam-core bytestring containers deepseq dependent-map
             dependent-sum free ghc-prim hashable haskell-src-exts mtl parallel
             pqueue pretty scientific text time unordered-containers uuid-types
             vector
           ];
           doHaddock = false;
           doCheck = false;
           homepage = "https://travis.athougies.net/projects/beam.html";
           description = "SQL DDL support and migrations support library for Beam";
           license = stdenv.lib.licenses.mit;
         }) {};
      "bench" = callPackage
        ({ mkDerivation, base, criterion, optparse-applicative, process
         , silently, stdenv, text, turtle
         }:
         mkDerivation {
           pname = "bench";
           version = "1.0.12";
           sha256 = "a6376f4741588201ab6e5195efb1e9921bc0a899f77a5d9ac84a5db32f3ec9eb";
           isLibrary = false;
           isExecutable = true;
           executableHaskellDepends = [
             base criterion optparse-applicative process silently text turtle
           ];
           doHaddock = false;
           doCheck = false;
           homepage = "https://github.com/Gabriel439/bench";
           description = "Command-line benchmark tool";
           license = stdenv.lib.licenses.bsd3;
         }) {};
      "bencode" = callPackage
        ({ mkDerivation, base, binary, bytestring, containers, parsec
         , stdenv
         }:
         mkDerivation {
           pname = "bencode";
           version = "0.6.0.0";
           sha256 = "3b8efdfecee9bc486d9bcdbb633b7128ca235360f102478a7e0f8c895281f68a";
           libraryHaskellDepends = [
             base binary bytestring containers parsec
           ];
           doHaddock = false;
           doCheck = false;
           description = "Parser and printer for bencoded data";
           license = stdenv.lib.licenses.bsd3;
         }) {};
      "between" = callPackage
        ({ mkDerivation, base, stdenv }:
         mkDerivation {
           pname = "between";
           version = "0.11.0.0";
           sha256 = "8337351326c5a613d9b7520b6a8203234c04454e23550a81739beaa6f671465d";
           libraryHaskellDepends = [ base ];
           doHaddock = false;
           doCheck = false;
           homepage = "https://github.com/trskop/between";
           description = "Function combinator \"between\" and derived combinators";
           license = stdenv.lib.licenses.bsd3;
         }) {};
      "bhoogle" = callPackage
        ({ mkDerivation, base, brick, bytestring, containers, directory
         , filepath, hoogle, lens, process, protolude, stdenv, text, time
         , typed-process, vector, vty
         }:
         mkDerivation {
           pname = "bhoogle";
           version = "0.1.3.5";
           sha256 = "c9e57081ae65d50c68ec6ad583ffe7bcaa79589dcc743ebce153f030034f2fbe";
           revision = "2";
           editedCabalFile = "0jwfw2xa55ysfxyzp5n2pf2vq753iagpmvg9xnj69nv6ly9whfp7";
           isLibrary = false;
           isExecutable = true;
           executableHaskellDepends = [
             base brick bytestring containers directory filepath hoogle lens
             process protolude text time typed-process vector vty
           ];
           doHaddock = false;
           doCheck = false;
           homepage = "https://github.com/andrevdm/bhoogle#readme";
           description = "Simple terminal GUI for local hoogle";
           license = "(BSD-3-Clause OR Apache-2.0)";
         }) {};
      "bibtex" = callPackage
        ({ mkDerivation, base, latex, parsec, stdenv, utility-ht }:
         mkDerivation {
           pname = "bibtex";
           version = "0.1.0.6";
           sha256 = "090a3b9589388bdf9d2bf60d8d1898aa0313a2874b551ba86cbbd049f3ee5f04";
           isLibrary = true;
           isExecutable = true;
           libraryHaskellDepends = [ base latex parsec utility-ht ];
           doHaddock = false;
           doCheck = false;
           homepage = "http://www.haskell.org/haskellwiki/BibTeX";
           description = "Parse, format and processing BibTeX files";
           license = stdenv.lib.licenses.bsd3;
         }) {};
      "bifunctors" = callPackage
        ({ mkDerivation, base, base-orphans, comonad, containers
         , semigroups, stdenv, tagged, template-haskell, th-abstraction
         , transformers
         }:
         mkDerivation {
           pname = "bifunctors";
           version = "5.5.3";
           sha256 = "d434528fd2ea765bace57c4ade0bc9fa32ba2c425f563b33a4b60f625ecfc9ca";
           libraryHaskellDepends = [
             base base-orphans comonad containers semigroups tagged
             template-haskell th-abstraction transformers
           ];
           doHaddock = false;
           doCheck = false;
           homepage = "http://github.com/ekmett/bifunctors/";
           description = "Bifunctors";
           license = stdenv.lib.licenses.bsd3;
         }) {};
      "bimap" = callPackage
        ({ mkDerivation, base, containers, exceptions, stdenv }:
         mkDerivation {
           pname = "bimap";
           version = "0.3.3";
           sha256 = "73829355c7bcbd3eedba22a382a04a3ab641702b00828790ec082ec2db3a8ad1";
           libraryHaskellDepends = [ base containers exceptions ];
           doHaddock = false;
           doCheck = false;
           homepage = "https://github.com/joelwilliamson/bimap";
           description = "Bidirectional mapping between two key types";
           license = stdenv.lib.licenses.bsd3;
         }) {};
      "bimap-server" = callPackage
        ({ mkDerivation, aeson, base, bimap, binary, directory, http-types
         , stdenv, unix, wai, warp
         }:
         mkDerivation {
           pname = "bimap-server";
           version = "0.1.0.1";
           sha256 = "09dfd1865812f40e317b610cbe05cc65ba6ea7215428748e1038ff7fc38ef535";
           libraryHaskellDepends = [
             aeson base bimap binary directory http-types unix wai warp
           ];
           doHaddock = false;
           doCheck = false;
           description = "Two-column database server";
           license = stdenv.lib.licenses.bsd3;
         }) {};
      "binary-bits" = callPackage
        ({ mkDerivation, base, binary, bytestring, stdenv }:
         mkDerivation {
           pname = "binary-bits";
           version = "0.5";
           sha256 = "16534a018a4754d8d1eab051711c23fb741f41a0d141b289001c52824b5be794";
           libraryHaskellDepends = [ base binary bytestring ];
           doHaddock = false;
           doCheck = false;
           description = "Bit parsing/writing on top of binary";
           license = stdenv.lib.licenses.bsd3;
         }) {};
      "binary-conduit" = callPackage
        ({ mkDerivation, base, binary, bytestring, conduit, exceptions
         , stdenv, vector
         }:
         mkDerivation {
           pname = "binary-conduit";
           version = "1.3.1";
           sha256 = "0480c3ff498bdbba6913ee8ad70d4828cf7a766bf9336a3ed8eb73676c46d29f";
           libraryHaskellDepends = [
             base binary bytestring conduit exceptions vector
           ];
           doHaddock = false;
           doCheck = false;
           homepage = "http://github.com/qnikst/binary-conduit/";
           description = "data serialization/deserialization conduit library";
           license = stdenv.lib.licenses.mit;
         }) {};
      "binary-ext" = callPackage
        ({ mkDerivation, attoparsec, base, binary, bytestring, conduit
         , conduit-combinators, data-binary-ieee754, errors, exceptions
         , monad-control, monad-loops, mono-traversable, mtl, scientific
         , stdenv, text, transformers, transformers-base
         }:
         mkDerivation {
           pname = "binary-ext";
           version = "2.0.4";
           sha256 = "6e58e19bde26d6f271916ceb43a28903136e28cf7868d86f65e68a60152ade08";
           libraryHaskellDepends = [
             attoparsec base binary bytestring conduit conduit-combinators
             data-binary-ieee754 errors exceptions monad-control monad-loops
             mono-traversable mtl scientific text transformers transformers-base
           ];
           doHaddock = false;
           doCheck = false;
           homepage = "https://github.com/A1-Triard/binary-ext#readme";
           description = "An alternate with strong-typed errors for `Data.Binary.Get` monad from `binary` package.";
           license = stdenv.lib.licenses.asl20;
         }) {};
      "binary-ieee754" = callPackage
        ({ mkDerivation, array, base, binary, stdenv }:
         mkDerivation {
           pname = "binary-ieee754";
           version = "0.1.0.0";
           sha256 = "15c489898bcd346b4067a27579cb5fc62e2fafecbec81ea0446165a24aee4d54";
           libraryHaskellDepends = [ array base binary ];
           doHaddock = false;
           doCheck = false;
           homepage = "https://github.com/winterland1989/binary-ieee754";
           description = "Backport ieee754 float double combinators to older binary";
           license = stdenv.lib.licenses.bsd3;
         }) {};
      "binary-list" = callPackage
        ({ mkDerivation, base, binary, bytestring, deepseq, phantom-state
         , stdenv, transformers
         }:
         mkDerivation {
           pname = "binary-list";
           version = "1.1.1.2";
           sha256 = "6b21e58ea4091b9572cb24a92dfb1ddc14fcea82d2272d30a83eb1b430dd1878";
           libraryHaskellDepends = [
             base binary bytestring deepseq phantom-state transformers
           ];
           doHaddock = false;
           doCheck = false;
           description = "Lists of length a power of two";
           license = stdenv.lib.licenses.bsd3;
         }) {};
      "binary-orphans" = callPackage
        ({ mkDerivation, aeson, base, binary, case-insensitive, hashable
         , scientific, stdenv, tagged, text, text-binary, time
         , unordered-containers, vector, vector-binary-instances
         }:
         mkDerivation {
           pname = "binary-orphans";
           version = "0.1.8.0";
           sha256 = "f17557ccd98931df2bea038f25e7f835f38019ea7d53bd763f71fe64f931c0cc";
           revision = "5";
           editedCabalFile = "1dny1jvwwcyrbzhqvymmn6n7ib48bpy0nasbrcrdrpzjypkmg500";
           libraryHaskellDepends = [
             aeson base binary case-insensitive hashable scientific tagged text
             text-binary time unordered-containers vector
             vector-binary-instances
           ];
           doHaddock = false;
           doCheck = false;
           homepage = "https://github.com/phadej/binary-orphans#readme";
           description = "Orphan instances for binary";
           license = stdenv.lib.licenses.bsd3;
         }) {};
      "binary-parser" = callPackage
        ({ mkDerivation, base, base-prelude, bytestring, mtl, stdenv, text
         , transformers
         }:
         mkDerivation {
           pname = "binary-parser";
           version = "0.5.5";
           sha256 = "1dab718e06a978118cd28d2412bceaa0b6ec8d67785bdb0982e259fb60fe43b3";
           revision = "3";
           editedCabalFile = "14n41yazmks2qw0v4krxcqw3ac0wdy2z53d0qz0rdjcd94fpghjf";
           libraryHaskellDepends = [
             base base-prelude bytestring mtl text transformers
           ];
           doHaddock = false;
           doCheck = false;
           homepage = "https://github.com/nikita-volkov/binary-parser";
           description = "A highly-efficient but limited parser API specialised for bytestrings";
           license = stdenv.lib.licenses.mit;
         }) {};
      "binary-parsers" = callPackage
        ({ mkDerivation, base, binary, bytestring, bytestring-lexing
         , scientific, stdenv
         }:
         mkDerivation {
           pname = "binary-parsers";
           version = "0.2.3.0";
           sha256 = "bc6195493b950efcbeb9ef54dfe47a6badf894dff934cf02a4b170331c1b217a";
           revision = "1";
           editedCabalFile = "09ag18yr1m26fl3w7ab1d5q5j201ygbw7qsbsy41bwd6iq87rq15";
           libraryHaskellDepends = [
             base binary bytestring bytestring-lexing scientific
           ];
           doHaddock = false;
           doCheck = false;
           homepage = "https://github.com/winterland1989/binary-parsers";
           description = "Extends binary with parsec/attoparsec style parsing combinators";
           license = stdenv.lib.licenses.bsd3;
         }) {};
      "binary-search" = callPackage
        ({ mkDerivation, base, containers, stdenv, transformers }:
         mkDerivation {
           pname = "binary-search";
           version = "1.0.0.3";
           sha256 = "b0e32df46aeddceac57bd6afa940f84f275f82fb251479e10fadd7c14414f6fa";
           libraryHaskellDepends = [ base containers transformers ];
           doHaddock = false;
           doCheck = false;
           description = "Binary and exponential searches";
           license = stdenv.lib.licenses.bsd3;
         }) {};
      "binary-shared" = callPackage
        ({ mkDerivation, base, binary, bytestring, containers, mtl, stdenv
         }:
         mkDerivation {
           pname = "binary-shared";
           version = "0.8.3";
           sha256 = "830116505018fc43de09867bea9039b0bfa29e77564efa8c3f3b708933c098b2";
           libraryHaskellDepends = [ base binary bytestring containers mtl ];
           doHaddock = false;
           doCheck = false;
           homepage = "http://www.leksah.org";
           description = "Sharing for the binary package";
           license = "GPL";
         }) {};
      "binary-tagged" = callPackage
        ({ mkDerivation, aeson, array, base, base16-bytestring, binary
         , bytestring, containers, generics-sop, hashable, scientific, SHA
         , stdenv, tagged, text, time, unordered-containers, vector
         }:
         mkDerivation {
           pname = "binary-tagged";
           version = "0.1.5.1";
           sha256 = "70cb8fff540937f1d9753a71e0343039ee1718a0f029d4df698164b04fd5d5a4";
           revision = "1";
           editedCabalFile = "1z612d3wbrlywcx96lc52svi9b2s6nskdnwnwm3d5mylcqaqckcx";
           libraryHaskellDepends = [
             aeson array base base16-bytestring binary bytestring containers
             generics-sop hashable scientific SHA tagged text time
             unordered-containers vector
           ];
           doHaddock = false;
           doCheck = false;
           homepage = "https://github.com/phadej/binary-tagged#readme";
           description = "Tagged binary serialisation";
           license = stdenv.lib.licenses.bsd3;
         }) {};
      "bindings-DSL" = callPackage
        ({ mkDerivation, base, stdenv }:
         mkDerivation {
           pname = "bindings-DSL";
           version = "1.0.25";
           sha256 = "63de32380c68d1cc5e9c7b3622d67832c786da21163ba0c8a4835e6dd169194f";
           libraryHaskellDepends = [ base ];
           doHaddock = false;
           doCheck = false;
           homepage = "https://github.com/jwiegley/bindings-dsl/wiki";
           description = "FFI domain specific language, on top of hsc2hs";
           license = stdenv.lib.licenses.bsd3;
         }) {};
      "bindings-GLFW" = callPackage
        ({ mkDerivation, base, bindings-DSL, libGL, libX11, libXcursor
         , libXext, libXfixes, libXi, libXinerama, libXrandr, libXxf86vm
         , stdenv
         }:
         mkDerivation {
           pname = "bindings-GLFW";
           version = "3.2.1.1";
           sha256 = "6b24c66b20ebfd8ff2e4ac32e3b435889bba0a32477598ba69fc7adc9608160e";
           libraryHaskellDepends = [ base bindings-DSL ];
           librarySystemDepends = [
             libGL libX11 libXcursor libXext libXfixes libXi libXinerama
             libXrandr libXxf86vm
           ];
           doHaddock = false;
           doCheck = false;
           description = "Low-level bindings to GLFW OpenGL library";
           license = stdenv.lib.licenses.bsd3;
         }) {inherit (pkgs) libGL; inherit (pkgs.xorg) libXext; 
inherit (pkgs.xorg) libXfixes;};
      "bindings-libzip" = callPackage
        ({ mkDerivation, base, bindings-DSL, libzip, stdenv }:
         mkDerivation {
           pname = "bindings-libzip";
           version = "1.0.1";
           sha256 = "908d060360d66974b1d9400dea28a1dce35a88baf5d73a6e3c12be8e74cda2ec";
           libraryHaskellDepends = [ base bindings-DSL ];
           libraryPkgconfigDepends = [ libzip ];
           doHaddock = false;
           doCheck = false;
           homepage = "http://bitbucket.org/astanin/hs-libzip/";
           description = "Low level bindings to libzip";
           license = stdenv.lib.licenses.bsd3;
         }) {inherit (pkgs) libzip;};
      "bindings-uname" = callPackage
        ({ mkDerivation, base, stdenv }:
         mkDerivation {
           pname = "bindings-uname";
           version = "0.1";
           sha256 = "130e75c3fd95e232452c7d903efbfab2d2ff6c9d455b617adeaebe5d60235cd3";
           libraryHaskellDepends = [ base ];
           doHaddock = false;
           doCheck = false;
           description = "Low-level binding to POSIX uname(3)";
           license = stdenv.lib.licenses.publicDomain;
         }) {};
      "bit-stream" = callPackage
        ({ mkDerivation, base, ghc-prim, stdenv, vector }:
         mkDerivation {
           pname = "bit-stream";
           version = "0.1.0.2";
           sha256 = "811f2e7d4a827440bc21557e48c5310fe91e1b17f337ec35208546e1c5639bf4";
           isLibrary = true;
           isExecutable = true;
           libraryHaskellDepends = [ base ghc-prim vector ];
           doHaddock = false;
           doCheck = false;
           homepage = "https://github.com/Bodigrim/bit-stream#readme";
           description = "Lazy, infinite, compact stream of Bool with O(1) indexing";
           license = stdenv.lib.licenses.bsd3;
         }) {};
      "bitarray" = callPackage
        ({ mkDerivation, array, base, stdenv }:
         mkDerivation {
           pname = "bitarray";
           version = "0.0.1.1";
           sha256 = "b27f6f1065053a0e8e24fbf9382b7060af9962d8d150b631c682c0c58469d802";
           revision = "1";
           editedCabalFile = "10fk92v9afjqk43zi621jxl0n8kci0xjj32lz3vqa9xbh67zjz45";
           libraryHaskellDepends = [ array base ];
           doHaddock = false;
           doCheck = false;
           homepage = "http://code.haskell.org/~bkomuves/";
           description = "Mutable and immutable bit arrays";
           license = stdenv.lib.licenses.bsd3;
         }) {};
      "bitcoin-api" = callPackage
        ({ mkDerivation, aeson, base, base58string, binary, bitcoin-block
         , bitcoin-script, bitcoin-tx, bitcoin-types, bytestring, hexstring
         , lens, lens-aeson, stdenv, text, unordered-containers, wreq
         }:
         mkDerivation {
           pname = "bitcoin-api";
           version = "0.12.1";
           sha256 = "c978de1519b24c5c04ff518ad1209f74f91df31d65e23592dc639219df6b3e30";
           enableSeparateDataOutput = true;
           libraryHaskellDepends = [
             aeson base base58string binary bitcoin-block bitcoin-script
             bitcoin-tx bitcoin-types bytestring hexstring lens lens-aeson text
             unordered-containers wreq
           ];
           doHaddock = false;
           doCheck = false;
           homepage = "http://www.leonmergen.com/opensource.html";
           description = "Provides access to the RPC API of Bitcoin Core";
           license = stdenv.lib.licenses.mit;
         }) {};
      "bitcoin-api-extra" = callPackage
        ({ mkDerivation, base, binary, bitcoin-api, bitcoin-block
         , bitcoin-tx, bytestring, conduit, lens, stdenv, stm, stm-chans
         , stm-conduit, text, transformers
         }:
         mkDerivation {
           pname = "bitcoin-api-extra";
           version = "0.9.1";
           sha256 = "c423c6007d0f830dd2bbc0e1bc9219980e6fb2bde684890e265e1bfce4bdd7fc";
           enableSeparateDataOutput = true;
           libraryHaskellDepends = [
             base binary bitcoin-api bitcoin-block bitcoin-tx bytestring conduit
             lens stm stm-chans stm-conduit text transformers
           ];
           doHaddock = false;
           doCheck = false;
           homepage = "http://www.leonmergen.com/opensource.html";
           description = "Higher level constructs on top of the bitcoin-api package";
           license = stdenv.lib.licenses.mit;
         }) {};
      "bitcoin-block" = callPackage
        ({ mkDerivation, base, binary, bitcoin-tx, bitcoin-types
         , bytestring, cryptohash, hexstring, largeword, lens, stdenv
         }:
         mkDerivation {
           pname = "bitcoin-block";
           version = "0.13.1";
           sha256 = "d7f57c0fe71045dab85d223dc15d64db3a15cc7fd8446bfe4ebd98cd9d417d5a";
           enableSeparateDataOutput = true;
           libraryHaskellDepends = [
             base binary bitcoin-tx bitcoin-types bytestring cryptohash
             hexstring largeword lens
           ];
           doHaddock = false;
           doCheck = false;
           homepage = "http://www.leonmergen.com/opensource.html";
           description = "Utility functions for manipulating bitcoin blocks";
           license = stdenv.lib.licenses.mit;
         }) {};
      "bitcoin-script" = callPackage
        ({ mkDerivation, base, base16-bytestring, binary, bytestring
         , stdenv, text
         }:
         mkDerivation {
           pname = "bitcoin-script";
           version = "0.11.1";
           sha256 = "398c1d86e918731b5b2026351bb3b0b90b20606517e7c21e42f05d6c6e197b4c";
           enableSeparateDataOutput = true;
           libraryHaskellDepends = [
             base base16-bytestring binary bytestring text
           ];
           doHaddock = false;
           doCheck = false;
           homepage = "http://www.leonmergen.com/opensource.html";
           description = "Compilation, manipulation and decompilation of Bitcoin scripts";
           license = stdenv.lib.licenses.mit;
         }) {};
      "bitcoin-tx" = callPackage
        ({ mkDerivation, base, binary, bitcoin-script, bitcoin-types
         , bytestring, cryptohash, hexstring, lens, stdenv
         }:
         mkDerivation {
           pname = "bitcoin-tx";
           version = "0.13.1";
           sha256 = "3bb88265353066c394e96a56b2dc555fa13d37ca7f820978b793196c6829cc00";
           enableSeparateDataOutput = true;
           libraryHaskellDepends = [
             base binary bitcoin-script bitcoin-types bytestring cryptohash
             hexstring lens
           ];
           doHaddock = false;
           doCheck = false;
           homepage = "http://www.leonmergen.com/opensource.html";
           description = "Utility functions for manipulating bitcoin transactions";
           license = stdenv.lib.licenses.mit;
         }) {};
      "bitcoin-types" = callPackage
        ({ mkDerivation, base, base58string, binary, bytestring, hexstring
         , stdenv, text
         }:
         mkDerivation {
           pname = "bitcoin-types";
           version = "0.9.2";
           sha256 = "b72f9448508b64706d5f443748dc9b8abde8e749959187ce3d8356cde0d6c40b";
           enableSeparateDataOutput = true;
           libraryHaskellDepends = [
             base base58string binary bytestring hexstring text
           ];
           doHaddock = false;
           doCheck = false;
           homepage = "http://www.leonmergen.com/opensource.html";
           description = "Provides consistent low-level types used commonly among Bitcoin implementations";
           license = stdenv.lib.licenses.mit;
         }) {};
      "bits" = callPackage
        ({ mkDerivation, base, bytes, Cabal, cabal-doctest, mtl, stdenv
         , transformers
         }:
         mkDerivation {
           pname = "bits";
           version = "0.5.1";
           sha256 = "657e557bb913b53fb3b3fc7eda820cf3c85a5b89692d242275d3e8e8d9479c93";
           revision = "5";
           editedCabalFile = "012qycmsfz5l6y82d3zgjmp1k3pgvhlpjdk6rwlpc1wlfbpdqiaw";
           setupHaskellDepends = [ base Cabal cabal-doctest ];
           libraryHaskellDepends = [ base bytes mtl transformers ];
           doHaddock = false;
           doCheck = false;
           homepage = "http://github.com/ekmett/bits";
           description = "Various bit twiddling and bitwise serialization primitives";
           license = stdenv.lib.licenses.bsd3;
         }) {};
      "bits-extra" = callPackage
        ({ mkDerivation, base, ghc-prim, stdenv, vector }:
         mkDerivation {
           pname = "bits-extra";
           version = "0.0.1.3";
           sha256 = "692b08b3e9a490f5b2776b8f20277320fad247d9c4ea158225fee0f27f91afed";
           libraryHaskellDepends = [ base ghc-prim vector ];
           doHaddock = false;
           doCheck = false;
           homepage = "https://github.com/haskell-works/bits-extra#readme";
           description = "Useful bitwise operations";
           license = stdenv.lib.licenses.bsd3;
         }) {};
      "bitset-word8" = callPackage
        ({ mkDerivation, base, containers, stdenv, template-haskell
         , th-lift-instances
         }:
         mkDerivation {
           pname = "bitset-word8";
           version = "0.1.1.1";
           sha256 = "ffc0f8508049717192021dabcfe77d65f604cbe107da6b8b76d45b891dbe52de";
           libraryHaskellDepends = [
             base containers template-haskell th-lift-instances
           ];
           doHaddock = false;
           doCheck = false;
           homepage = "https://github.com/nshimaza/bitset-word8#readme";
           description = "Space efficient set of Word8 and some pre-canned sets useful for parsing HTTP";
           license = stdenv.lib.licenses.mit;
         }) {};
      "bitx-bitcoin" = callPackage
        ({ mkDerivation, aeson, base, bytestring, deepseq, exceptions
         , http-client, http-client-tls, http-types, microlens, microlens-th
         , network, QuickCheck, scientific, split, stdenv, text, time
         }:
         mkDerivation {
           pname = "bitx-bitcoin";
           version = "0.12.0.0";
           sha256 = "31f2398bbb0deff80361fdabb108c1552ae097b15a44c6ca6674977ae735c871";
           libraryHaskellDepends = [
             aeson base bytestring deepseq exceptions http-client
             http-client-tls http-types microlens microlens-th network
             QuickCheck scientific split text time
           ];
           doHaddock = false;
           doCheck = false;
           homepage = "https://github.com/tebello-thejane/bitx.hs";
           description = "A Haskell library for working with the BitX bitcoin exchange";
           license = stdenv.lib.licenses.bsd3;
         }) {};
      "blake2" = callPackage
        ({ mkDerivation, base, bytestring, stdenv }:
         mkDerivation {
           pname = "blake2";
           version = "0.2.0";
           sha256 = "07d910e3f5c6e98f5a6b9d53dbe5f52506c3859b513bc7493b52552a28382cfc";
           libraryHaskellDepends = [ base bytestring ];
           doHaddock = false;
           doCheck = false;
           homepage = "https://github.com/centromere/blake2";
           description = "A library providing BLAKE2";
           license = stdenv.lib.licenses.publicDomain;
         }) {};
      "blank-canvas" = callPackage
        ({ mkDerivation, aeson, base, base-compat-batteries
         , base64-bytestring, bytestring, colour, containers
         , data-default-class, http-types, kansas-comet, mime-types, scotty
         , semigroups, stdenv, stm, text, text-show, transformers, vector
         , wai, wai-extra, warp
         }:
         mkDerivation {
           pname = "blank-canvas";
           version = "0.6.3";
           sha256 = "739d24ff7035fd675e95c2d33bd9d3cb7d1ef0cca94c16bbf950c4a7f7b320b4";
           revision = "3";
           editedCabalFile = "15gcxvbbb0pjnw6wh4jvc4xqvv1gr493h2s9yclf81vfg7bry24w";
           enableSeparateDataOutput = true;
           libraryHaskellDepends = [
             aeson base base-compat-batteries base64-bytestring bytestring
             colour containers data-default-class http-types kansas-comet
             mime-types scotty semigroups stm text text-show transformers vector
             wai wai-extra warp
           ];
           doHaddock = false;
           doCheck = false;
           homepage = "https://github.com/ku-fpg/blank-canvas/wiki";
           description = "HTML5 Canvas Graphics Library";
           license = stdenv.lib.licenses.bsd3;
         }) {};
      "blas-carray" = callPackage
        ({ mkDerivation, base, blas-ffi, carray, netlib-carray, netlib-ffi
         , stdenv, storable-complex, transformers
         }:
         mkDerivation {
           pname = "blas-carray";
           version = "0.0.1.1";
           sha256 = "bdad1b777d36e46a63bec022190bd009d2782018d7a447f41e3c2db772635f46";
           libraryHaskellDepends = [
             base blas-ffi carray netlib-carray netlib-ffi storable-complex
             transformers
           ];
           doHaddock = false;
           doCheck = false;
           homepage = "http://hub.darcs.net/thielema/blas-carray/";
           description = "Auto-generated interface to Fortran BLAS via CArrays";
           license = stdenv.lib.licenses.bsd3;
         }) {};
      "blas-ffi" = callPackage
        ({ mkDerivation, base, blas, netlib-ffi, stdenv }:
         mkDerivation {
           pname = "blas-ffi";
           version = "0.0.2";
           sha256 = "cc6f6b33062c81cf0fdd9f0c1bf1b600d546b0dfc8f773ef603068710455f810";
           isLibrary = true;
           isExecutable = true;
           libraryHaskellDepends = [ base netlib-ffi ];
           libraryPkgconfigDepends = [ blas ];
           doHaddock = false;
           doCheck = false;
           homepage = "http://hub.darcs.net/thielema/blas-ffi/";
           description = "Auto-generated interface to Fortran BLAS";
           license = stdenv.lib.licenses.bsd3;
         }) {inherit (pkgs) blas;};
      "blas-hs" = callPackage
        ({ mkDerivation, base, blas, stdenv, storable-complex }:
         mkDerivation {
           pname = "blas-hs";
           version = "0.1.1.0";
           sha256 = "80e06b0927982b391d239f8656ed437cd29665969d1a078ea4e42a2bf196b086";
           libraryHaskellDepends = [ base storable-complex ];
           librarySystemDepends = [ blas ];
           doHaddock = false;
           doCheck = false;
           homepage = "https://github.com/Rufflewind/blas-hs";
           description = "Low-level Haskell bindings to Blas";
           license = stdenv.lib.licenses.mit;
         }) {inherit (pkgs) blas;};
      "blaze-bootstrap" = callPackage
        ({ mkDerivation, base, blaze-html, stdenv, text }:
         mkDerivation {
           pname = "blaze-bootstrap";
           version = "0.1.0.1";
           sha256 = "53b54c0b55ae7a436ec7e5d4e29d50fceb1ccd459ef715236358a3c661d05163";
           libraryHaskellDepends = [ base blaze-html text ];
           doHaddock = false;
           doCheck = false;
           homepage = "http://github.com/agrafix/blaze-bootstrap";
           description = "Blaze helper functions for bootstrap pages";
           license = stdenv.lib.licenses.mit;
         }) {};
      "blaze-builder" = callPackage
        ({ mkDerivation, base, bytestring, deepseq, stdenv, text }:
         mkDerivation {
           pname = "blaze-builder";
           version = "0.4.1.0";
           sha256 = "91fc8b966f3e9dc9461e1675c7566b881740f99abc906495491a3501630bc814";
           libraryHaskellDepends = [ base bytestring deepseq text ];
           doHaddock = false;
           doCheck = false;
           homepage = "http://github.com/lpsmith/blaze-builder";
           description = "Efficient buffered output";
           license = stdenv.lib.licenses.bsd3;
         }) {};
      "blaze-colonnade" = callPackage
        ({ mkDerivation, base, blaze-html, blaze-markup, colonnade, stdenv
         , text
         }:
         mkDerivation {
           pname = "blaze-colonnade";
           version = "1.2.2";
           sha256 = "1f2f7116ffea5ad2a04337b9bdc1277de0b12a71fb4b830b216c37911d8ea14c";
           libraryHaskellDepends = [
             base blaze-html blaze-markup colonnade text
           ];
           doHaddock = false;
           doCheck = false;
           homepage = "https://github.com/andrewthad/colonnade#readme";
           description = "Helper functions for using blaze-html with colonnade";
           license = stdenv.lib.licenses.bsd3;
         }) {};
      "blaze-html" = callPackage
        ({ mkDerivation, base, blaze-builder, blaze-markup, bytestring
         , stdenv, text
         }:
         mkDerivation {
           pname = "blaze-html";
           version = "0.9.1.1";
           sha256 = "ea0e944298dbbd692b41af4f15dbd1a1574aec7b8f91f38391d25106b143bb1b";
           libraryHaskellDepends = [
             base blaze-builder blaze-markup bytestring text
           ];
           doHaddock = false;
           doCheck = false;
           homepage = "http://jaspervdj.be/blaze";
           description = "A blazingly fast HTML combinator library for Haskell";
           license = stdenv.lib.licenses.bsd3;
         }) {};
      "blaze-markup" = callPackage
        ({ mkDerivation, base, blaze-builder, bytestring, stdenv, text }:
         mkDerivation {
           pname = "blaze-markup";
           version = "0.8.2.2";
           sha256 = "c6f0cf8fd707ba8c0b700e0c5ad6a1212c8b57d46a9cbdfb904d8bf585ad82e1";
           revision = "1";
           editedCabalFile = "0ivspcxz0b2r7kcas5hlw0fh92883r8ghwz9lck7nyqn6wn5i8zx";
           libraryHaskellDepends = [ base blaze-builder bytestring text ];
           doHaddock = false;
           doCheck = false;
           homepage = "http://jaspervdj.be/blaze";
           description = "A blazingly fast markup combinator library for Haskell";
           license = stdenv.lib.licenses.bsd3;
         }) {};
      "blaze-svg" = callPackage
        ({ mkDerivation, base, blaze-markup, mtl, stdenv }:
         mkDerivation {
           pname = "blaze-svg";
           version = "0.3.6.1";
           sha256 = "f6a4f1bba1e973b336e94de73369f4562778fde43b6ac7c0b32d6a501527aa60";
           libraryHaskellDepends = [ base blaze-markup mtl ];
           doHaddock = false;
           doCheck = false;
           homepage = "https://github.com/deepakjois/blaze-svg";
           description = "SVG combinator library";
           license = stdenv.lib.licenses.bsd3;
         }) {};
      "blaze-textual" = callPackage
        ({ mkDerivation, base, blaze-builder, bytestring, ghc-prim
         , integer-gmp, old-locale, stdenv, text, time, vector
         }:
         mkDerivation {
           pname = "blaze-textual";
           version = "0.2.1.0";
           sha256 = "1042795ab0bab891c034c24a51bafecbb89870ccd28af39534ab3d9ae7f46c2d";
           libraryHaskellDepends = [
             base blaze-builder bytestring ghc-prim integer-gmp old-locale text
             time vector
           ];
           doHaddock = false;
           doCheck = false;
           homepage = "http://github.com/bos/blaze-textual";
           description = "Fast rendering of common datatypes";
           license = stdenv.lib.licenses.bsd3;
         }) {};
      "bmp" = callPackage
        ({ mkDerivation, base, binary, bytestring, stdenv }:
         mkDerivation {
           pname = "bmp";
           version = "1.2.6.3";
           sha256 = "3cc63de40fe088ce4d1c869180fd2309bcec35a940c9e3d1904d3520ca2fdacc";
           libraryHaskellDepends = [ base binary bytestring ];
           doHaddock = false;
           doCheck = false;
           homepage = "https://github.com/benl23x5/bmp";
           description = "Read and write uncompressed BMP image files";
           license = stdenv.lib.licenses.mit;
         }) {};
      "bno055-haskell" = callPackage
        ({ mkDerivation, base, bytestring, cereal, h2c, mtl, resourcet
         , stdenv
         }:
         mkDerivation {
           pname = "bno055-haskell";
           version = "0.1.0";
           sha256 = "7adc29f94755047b4214115c23b63041e9d3970d2648f53dcd38b84725059ad8";
           libraryHaskellDepends = [
             base bytestring cereal h2c mtl resourcet
           ];
           doHaddock = false;
           doCheck = false;
           homepage = "https://bitbucket.org/fmapE/bno055-haskell";
           description = "Library for communication with the Bosch BNO055 orientation sensor";
           license = stdenv.lib.licenses.mit;
         }) {};
      "boltzmann-samplers" = callPackage
        ({ mkDerivation, ad, base, containers, hashable, hmatrix, ieee754
         , MonadRandom, mtl, QuickCheck, stdenv, transformers
         , unordered-containers, vector
         }:
         mkDerivation {
           pname = "boltzmann-samplers";
           version = "0.1.1.0";
           sha256 = "de7c3e1f77b0ae27c78cb53e539dbaa8dc2f6e3f3605c25f1611545806ad878e";
           libraryHaskellDepends = [
             ad base containers hashable hmatrix ieee754 MonadRandom mtl
             QuickCheck transformers unordered-containers vector
           ];
           doHaddock = false;
           doCheck = false;
           homepage = "https://github.com/Lysxia/boltzmann-samplers#readme";
           description = "Uniform random generators";
           license = stdenv.lib.licenses.mit;
         }) {};
      "boolean-like" = callPackage
        ({ mkDerivation, attoparsec, base, bytestring, containers
         , semigroups, stdenv, text, vector
         }:
         mkDerivation {
           pname = "boolean-like";
           version = "0.1.1.0";
           sha256 = "6ca47b21a6d98161edfd94f4d5a19daacc13d229b87a0c107e868ff0259658b8";
           libraryHaskellDepends = [
             attoparsec base bytestring containers semigroups text vector
           ];
           doHaddock = false;
           doCheck = false;
           homepage = "http://github.com/Shou/boolean-like";
           description = "Logical combinatory operations dealing with datatypes representing booleans by their constructors";
           license = stdenv.lib.licenses.bsd3;
         }) {};
      "boolsimplifier" = callPackage
        ({ mkDerivation, base, containers, stdenv }:
         mkDerivation {
           pname = "boolsimplifier";
           version = "0.1.8";
           sha256 = "096fa9377241520ee114403fd53b51a7369187fb4dca65f19f85a727d689828f";
           revision = "1";
           editedCabalFile = "0xqm0vn9i49b75fnvnvcnr9m4zwvhqynrkcjdxghrsxayg420lnh";
           libraryHaskellDepends = [ base containers ];
           doHaddock = false;
           doCheck = false;
           description = "Simplification tools for simple propositional formulas";
           license = stdenv.lib.licenses.bsd3;
         }) {};
      "bordacount" = callPackage
        ({ mkDerivation, base, containers, stdenv }:
         mkDerivation {
           pname = "bordacount";
           version = "0.1.0.0";
           sha256 = "cb691095f688dc2c1726750d5e5d267d3f49466377869a574d6416090a46fdce";
           libraryHaskellDepends = [ base containers ];
           doHaddock = false;
           doCheck = false;
           homepage = "https://github.com/hverr/bordacount#readme";
           description = "Implementation of the Borda count election method";
           license = stdenv.lib.licenses.bsd3;
         }) {};
      "boring" = callPackage
        ({ mkDerivation, adjunctions, base, base-compat, constraints, fin
         , generics-sop, stdenv, streams, tagged, transformers
         , transformers-compat, vec
         }:
         mkDerivation {
           pname = "boring";
           version = "0.1";
           sha256 = "73d60829c3a789f3d377d56ce7844aaaea6b517bcea43e06579ab785181b4664";
           revision = "2";
           editedCabalFile = "1jxaby4cagbhii194x9x0j75ms1v5bm14sx7d19zz3844mh9qyci";
           libraryHaskellDepends = [
             adjunctions base base-compat constraints fin generics-sop streams
             tagged transformers transformers-compat vec
           ];
           doHaddock = false;
           doCheck = false;
           homepage = "https://github.com/phadej/boring";
           description = "Boring and Absurd types";
           license = stdenv.lib.licenses.bsd3;
         }) {};
      "both" = callPackage
        ({ mkDerivation, base, semigroups, stdenv, zero }:
         mkDerivation {
           pname = "both";
           version = "0.1.1.0";
           sha256 = "6f4ee8b7745fb3054282240fe941dd74cf2481f1a07b170d211c2b8791340e8e";
           revision = "1";
           editedCabalFile = "0fi2lvxcdnj9bi683kl840xpyj12wxwxvqbi86a6qp4r8bq8442n";
           libraryHaskellDepends = [ base semigroups zero ];
           doHaddock = false;
           doCheck = false;
           homepage = "https://github.com/barrucadu/both";
           description = "Like Maybe, but with a different Monoid instance";
           license = stdenv.lib.licenses.mit;
         }) {};
      "bound" = callPackage
        ({ mkDerivation, base, bifunctors, binary, bytes, Cabal
         , cabal-doctest, cereal, comonad, deepseq, hashable, mmorph
         , profunctors, stdenv, template-haskell, transformers
         , transformers-compat
         }:
         mkDerivation {
           pname = "bound";
           version = "2.0.1";
           sha256 = "294a206f33b6583e56bd3aad620e4a7bd0a22b4bf4c6fe5988b2fe55159fbb76";
           revision = "7";
           editedCabalFile = "0amr5rpq8andqq3z2dsh8hn67g3x7ykcmqq899vbkxwnpvg60h5r";
           setupHaskellDepends = [ base Cabal cabal-doctest ];
           libraryHaskellDepends = [
             base bifunctors binary bytes cereal comonad deepseq hashable mmorph
             profunctors template-haskell transformers transformers-compat
           ];
           doHaddock = false;
           doCheck = false;
           homepage = "http://github.com/ekmett/bound/";
           description = "Making de Bruijn Succ Less";
           license = stdenv.lib.licenses.bsd3;
         }) {};
      "boundingboxes" = callPackage
        ({ mkDerivation, base, lens, stdenv }:
         mkDerivation {
           pname = "boundingboxes";
           version = "0.2.3";
           sha256 = "e80947aa2c2c7f11e7eb2eb088a463d1cd1cdf03790e4c2746b629dcb1737564";
           libraryHaskellDepends = [ base lens ];
           doHaddock = false;
           doCheck = false;
           homepage = "https://github.com/fumieval/boundingboxes";
           description = "A generic boundingbox for an arbitrary vector";
           license = stdenv.lib.licenses.bsd3;
         }) {};
      "bower-json" = callPackage
        ({ mkDerivation, aeson, aeson-better-errors, base, bytestring
         , deepseq, ghc-prim, mtl, scientific, stdenv, text, transformers
         , unordered-containers, vector
         }:
         mkDerivation {
           pname = "bower-json";
           version = "1.0.0.1";
           sha256 = "7aa954e2b1bf79307db710c158108bd9ddb45b333ca96072cdbfaf96c77b7e73";
           libraryHaskellDepends = [
             aeson aeson-better-errors base bytestring deepseq ghc-prim mtl
             scientific text transformers unordered-containers vector
           ];
           doHaddock = false;
           doCheck = false;
           homepage = "https://github.com/hdgarrood/bower-json";
           description = "Read bower.json from Haskell";
           license = stdenv.lib.licenses.mit;
         }) {};
      "boxes" = callPackage
        ({ mkDerivation, base, split, stdenv }:
         mkDerivation {
           pname = "boxes";
           version = "0.1.5";
           sha256 = "38e1782e8a458f342a0acbb74af8f55cb120756bc3af7ee7220d955812af56c3";
           libraryHaskellDepends = [ base split ];
           doHaddock = false;
           doCheck = false;
           description = "2D text pretty-printing library";
           license = stdenv.lib.licenses.bsd3;
         }) {};
      "brick" = callPackage
        ({ mkDerivation, base, config-ini, containers, contravariant
         , data-clist, deepseq, dlist, microlens, microlens-mtl
         , microlens-th, stdenv, stm, template-haskell, text, text-zipper
         , transformers, vector, vty, word-wrap
         }:
         mkDerivation {
           pname = "brick";
           version = "0.37.2";
           sha256 = "7cb86cd88d344d4a8b997677f805e3a3adaecf37d65478e06081737efbc1d99c";
           revision = "1";
           editedCabalFile = "0cj98cjlr400yf47lg50syj5zpvh6q9mm1hp4blns6ndz2xys5rz";
           configureFlags = [ "-fdemos" ];
           isLibrary = true;
           isExecutable = true;
           libraryHaskellDepends = [
             base config-ini containers contravariant data-clist deepseq dlist
             microlens microlens-mtl microlens-th stm template-haskell text
             text-zipper transformers vector vty word-wrap
           ];
           executableHaskellDepends = [
             base microlens microlens-th text text-zipper vector vty word-wrap
           ];
           doHaddock = false;
           doCheck = false;
           homepage = "https://github.com/jtdaugherty/brick/";
           description = "A declarative terminal user interface library";
           license = stdenv.lib.licenses.bsd3;
         }) {};
      "brittany" = callPackage
        ({ mkDerivation, aeson, base, butcher, bytestring, cmdargs
         , containers, czipwith, data-tree-print, deepseq, directory, extra
         , filepath, ghc, ghc-boot-th, ghc-exactprint, ghc-paths, monad-memo
         , mtl, multistate, neat-interpolation, pretty, random, safe
         , semigroups, stdenv, strict, syb, text, transformers, uniplate
         , unsafe, yaml
         }:
         mkDerivation {
           pname = "brittany";
           version = "0.11.0.0";
           sha256 = "46a80e13ff5543913d6f019a58ad7f0b2dc34faa190dc0d0d4ecf882498decb9";
           revision = "2";
           editedCabalFile = "1f20w6zzbygnpa7f6xbaqxx34l62r53ikywg2snn0zkfizf3lcgx";
           isLibrary = true;
           isExecutable = true;
           libraryHaskellDepends = [
             aeson base butcher bytestring cmdargs containers czipwith
             data-tree-print deepseq directory extra filepath ghc ghc-boot-th
             ghc-exactprint ghc-paths monad-memo mtl multistate
             neat-interpolation pretty random safe semigroups strict syb text
             transformers uniplate unsafe yaml
           ];
           executableHaskellDepends = [
             aeson base butcher bytestring cmdargs containers czipwith
             data-tree-print deepseq directory extra filepath ghc ghc-boot-th
             ghc-exactprint ghc-paths monad-memo mtl multistate
             neat-interpolation pretty safe semigroups strict syb text
             transformers uniplate unsafe yaml
           ];
           doHaddock = false;
           doCheck = false;
           homepage = "https://github.com/lspitzner/brittany/";
           description = "Haskell source code formatter";
           license = stdenv.lib.licenses.agpl3;
         }) {};
      "broadcast-chan" = callPackage
        ({ mkDerivation, base, stdenv }:
         mkDerivation {
           pname = "broadcast-chan";
           version = "0.1.1";
           sha256 = "ad5bd65a301aff6df38c4111f02e73cce3bcfed7bfae6c66c2e70310f1e985f2";
           revision = "1";
           editedCabalFile = "03bmddz9bryh3viskh2nldj4hbzl5b9xkkx2pml73vq9bn2aq5s4";
           libraryHaskellDepends = [ base ];
           doHaddock = false;
           doCheck = false;
           homepage = "https://github.com/merijn/broadcast-chan";
           description = "Broadcast channel type that avoids 0 reader space leaks";
           license = stdenv.lib.licenses.bsd3;
         }) {};
      "bsb-http-chunked" = callPackage
        ({ mkDerivation, base, bytestring, stdenv }:
         mkDerivation {
           pname = "bsb-http-chunked";
           version = "0.0.0.4";
           sha256 = "148309e23eb8b261c1de374712372d62d8c8dc8ee504c392809c7ec33c0a0e7c";
           libraryHaskellDepends = [ base bytestring ];
           doHaddock = false;
           doCheck = false;
           homepage = "http://github.com/sjakobi/bsb-http-chunked";
           description = "Chunked HTTP transfer encoding for bytestring builders";
           license = stdenv.lib.licenses.bsd3;
         }) {};
      "bson" = callPackage
        ({ mkDerivation, base, binary, bytestring, cryptohash
         , data-binary-ieee754, mtl, network, stdenv, text, time
         }:
         mkDerivation {
           pname = "bson";
           version = "0.3.2.7";
           sha256 = "27329dcd593fd7503e7cf6705c863ed5c76b2fc816342e194c79d5a1d4c87f2b";
           revision = "1";
           editedCabalFile = "1y6gy4rq2wb123p1qc35p0hnk8dqh2hnlys2c97znwcjjsd5p203";
           libraryHaskellDepends = [
             base binary bytestring cryptohash data-binary-ieee754 mtl network
             text time
           ];
           doHaddock = false;
           doCheck = false;
           homepage = "http://github.com/mongodb-haskell/bson";
           description = "BSON documents are JSON-like objects with a standard binary encoding";
           license = stdenv.lib.licenses.asl20;
         }) {};
      "bson-lens" = callPackage
        ({ mkDerivation, base, bson, lens, stdenv, text }:
         mkDerivation {
           pname = "bson-lens";
           version = "0.1.1";
           sha256 = "d73bb417def2d8cb1efebfc22482a859e119bcc4005dd10106c82dff5ceeb160";
           libraryHaskellDepends = [ base bson lens text ];
           doHaddock = false;
           doCheck = false;
           homepage = "https://github.com/jb55/bson-lens";
           description = "BSON lenses";
           license = stdenv.lib.licenses.mit;
         }) {};
      "btrfs" = callPackage
        ({ mkDerivation, base, bytestring, stdenv, time, unix }:
         mkDerivation {
           pname = "btrfs";
           version = "0.1.2.3";
           sha256 = "7efc0b5c65623dcf60910baf896aec7da7ac2df4231f03a3072c78fb5b2fb88d";
           revision = "1";
           editedCabalFile = "1py88k9sjmx9x41l0wmp19a52ng9fdf66rmd0n9404gxxbqd5jxv";
           isLibrary = true;
           isExecutable = true;
           libraryHaskellDepends = [ base bytestring time unix ];
           doHaddock = false;
           doCheck = false;
           homepage = "https://github.com/redneb/hs-btrfs";
           description = "Bindings to the btrfs API";
           license = stdenv.lib.licenses.bsd3;
         }) {};
      "buffer-builder" = callPackage
        ({ mkDerivation, base, bytestring, mtl, stdenv, text
         , unordered-containers, vector
         }:
         mkDerivation {
           pname = "buffer-builder";
           version = "0.2.4.7";
           sha256 = "b389fac5ce61818adb8451550762aca135c34b9007b68be5a8d9a0fa45583f58";
           libraryHaskellDepends = [
             base bytestring mtl text unordered-containers vector
           ];
           doHaddock = false;
           doCheck = false;
           homepage = "https://github.com/chadaustin/buffer-builder";
           description = "Library for efficiently building up buffers, one piece at a time";
           license = stdenv.lib.licenses.bsd3;
         }) {};
      "buffer-pipe" = callPackage
        ({ mkDerivation, base, stdenv }:
         mkDerivation {
           pname = "buffer-pipe";
           version = "0.0";
           sha256 = "0875b6e41988f70e20d2e9d1a092ae03d545954732f93d65a3481b5c4b52dccf";
           isLibrary = false;
           isExecutable = true;
           executableHaskellDepends = [ base ];
           doHaddock = false;
           doCheck = false;
           description = "Read from stdin and write to stdout in large blocks";
           license = stdenv.lib.licenses.bsd3;
         }) {};
      "butcher" = callPackage
        ({ mkDerivation, base, bifunctors, containers, deque, extra, free
         , microlens, microlens-th, mtl, multistate, pretty, stdenv
         , transformers, unsafe, void
         }:
         mkDerivation {
           pname = "butcher";
           version = "1.3.2.0";
           sha256 = "0cb29a2355c7fc4e55c61ef6138067a8f3f30baaa945d9a2ca7b638023d2ea1a";
           revision = "1";
           editedCabalFile = "1r4v2biwd0hp6v1jgx7zngh0hqlsk8ia3bvggbxxn5sp5x7ika1m";
           libraryHaskellDepends = [
             base bifunctors containers deque extra free microlens microlens-th
             mtl multistate pretty transformers unsafe void
           ];
           doHaddock = false;
           doCheck = false;
           homepage = "https://github.com/lspitzner/butcher/";
           description = "Chops a command or program invocation into digestable pieces";
           license = stdenv.lib.licenses.bsd3;
         }) {};
      "butter" = callPackage
        ({ mkDerivation, aeson, base, bytestring, containers
         , forkable-monad, free, HUnit, network-simple, stdenv, stm
         , template-haskell, text, transformers
         }:
         mkDerivation {
           pname = "butter";
           version = "0.1.0.6";
           sha256 = "8640b2681a57c0bc545684c821e80a97d57fe14bc6036e9030dc4cc63c2e4164";
           libraryHaskellDepends = [
             aeson base bytestring containers forkable-monad free HUnit
             network-simple stm template-haskell text transformers
           ];
           doHaddock = false;
           doCheck = false;
           homepage = "https://github.com/System-Indystress/Butter#readme";
           description = "Monad Transformer for Asyncronous Message Passing";
           license = stdenv.lib.licenses.bsd3;
         }) {};
      "bv" = callPackage
        ({ mkDerivation, base, ghc-prim, integer-gmp, stdenv }:
         mkDerivation {
           pname = "bv";
           version = "0.5";
           sha256 = "04a189ab1758f6adc51ffff0a10705d8c8b54959946a90a3b9a750c930c77bda";
           isLibrary = true;
           isExecutable = true;
           libraryHaskellDepends = [ base ghc-prim integer-gmp ];
           doHaddock = false;
           doCheck = false;
           homepage = "https://github.com/iagoabal/haskell-bv";
           description = "Bit-vector arithmetic library";
           license = stdenv.lib.licenses.bsd3;
         }) {};
      "bv-little" = callPackage
        ({ mkDerivation, base, deepseq, hashable, integer-gmp
         , mono-traversable, primitive, QuickCheck, stdenv
         }:
         mkDerivation {
           pname = "bv-little";
           version = "0.1.2";
           sha256 = "8c8d394050d154e100e29df7daf75235eb870aeb3946d8a68f58472e31c14c77";
           libraryHaskellDepends = [
             base deepseq hashable integer-gmp mono-traversable primitive
             QuickCheck
           ];
           doHaddock = false;
           doCheck = false;
           homepage = "https://github.com/recursion-ninja/bv-little";
           description = "Efficient little-endian bit vector library";
           license = stdenv.lib.licenses.bsd3;
         }) {};
      "byteable" = callPackage
        ({ mkDerivation, base, bytestring, stdenv }:
         mkDerivation {
           pname = "byteable";
           version = "0.1.1";
           sha256 = "243b34a1b5b64b39e39fe58f75c18f6cad5b668b10cabcd86816cbde27783fe2";
           enableSeparateDataOutput = true;
           libraryHaskellDepends = [ base bytestring ];
           doHaddock = false;
           doCheck = false;
           homepage = "http://github.com/vincenthz/hs-byteable";
           description = "Type class for sequence of bytes";
           license = stdenv.lib.licenses.bsd3;
         }) {};
      "bytedump" = callPackage
        ({ mkDerivation, base, bytestring, stdenv }:
         mkDerivation {
           pname = "bytedump";
           version = "1.0";
           sha256 = "ae17b5040f0423eec792505f14d1d3e53f5ff81ddf83524f1c5dc7a16c0dc0dd";
           isLibrary = true;
           isExecutable = true;
           enableSeparateDataOutput = true;
           libraryHaskellDepends = [ base bytestring ];
           doHaddock = false;
           doCheck = false;
           homepage = "http://github.com/vincenthz/hs-bytedump";
           description = "Flexible byte dump helpers for human readers";
           license = stdenv.lib.licenses.bsd3;
         }) {};
      "byteorder" = callPackage
        ({ mkDerivation, base, stdenv }:
         mkDerivation {
           pname = "byteorder";
           version = "1.0.4";
           sha256 = "bd20bbb586947f99c38a4c93d9d0266f49f6fc581767b51ba568f6d5d52d2919";
           libraryHaskellDepends = [ base ];
           doHaddock = false;
           doCheck = false;
           homepage = "http://community.haskell.org/~aslatter/code/byteorder";
           description = "Exposes the native endianness or byte ordering of the system";
           license = stdenv.lib.licenses.bsd3;
         }) {};
      "bytes" = callPackage
        ({ mkDerivation, base, binary, bytestring, Cabal, cabal-doctest
         , cereal, containers, hashable, mtl, scientific, stdenv, text, time
         , transformers, transformers-compat, unordered-containers, void
         }:
         mkDerivation {
           pname = "bytes";
           version = "0.15.5";
           sha256 = "039935e6b367eb8657aa3eb109e719b257a06524b0d9ff5246e8029bb7a07118";
           setupHaskellDepends = [ base Cabal cabal-doctest ];
           libraryHaskellDepends = [
             base binary bytestring cereal containers hashable mtl scientific
             text time transformers transformers-compat unordered-containers
             void
           ];
           doHaddock = false;
           doCheck = false;
           homepage = "https://github.com/ekmett/bytes";
           description = "Sharing code for serialization between binary and cereal";
           license = stdenv.lib.licenses.bsd3;
         }) {};
      "byteset" = callPackage
        ({ mkDerivation, base, binary, stdenv }:
         mkDerivation {
           pname = "byteset";
           version = "0.1.1.0";
           sha256 = "13499c5b279f022097e9ae1d0aeef3fcea12b7f18f50157d4950aec58741afa1";
           revision = "1";
           editedCabalFile = "1lgxxxrmw4g32pa861n6qbfpzwv14wfjrlp4hv5zd9hygy6v6q2p";
           libraryHaskellDepends = [ base binary ];
           doHaddock = false;
           doCheck = false;
           description = "Set of bytes";
           license = stdenv.lib.licenses.bsd3;
         }) {};
      "bytestring-builder" = callPackage
        ({ mkDerivation, base, bytestring, deepseq, stdenv }:
         mkDerivation {
           pname = "bytestring-builder";
           version = "0.10.8.2.0";
           sha256 = "27faef6db27c5be5a3715fd68b93725853e0e668849eaf92ce7c33cef9cb2c3f";
           libraryHaskellDepends = [ base bytestring deepseq ];
           doHaddock = false;
           doCheck = false;
           description = "The new bytestring builder, packaged outside of GHC";
           license = stdenv.lib.licenses.bsd3;
         }) {};
      "bytestring-conversion" = callPackage
        ({ mkDerivation, attoparsec, base, bytestring, case-insensitive
         , double-conversion, stdenv, text
         }:
         mkDerivation {
           pname = "bytestring-conversion";
           version = "0.3.1";
           sha256 = "13b7ea48737dc7a7fd4c894ff1fb9344cf8d9ef8f4201e813d578b613e874ef8";
           revision = "2";
           editedCabalFile = "1x8c42cfzb6fdvgkxxdxcpdf16csimlzsgahb1axnplmr6b3ba63";
           libraryHaskellDepends = [
             attoparsec base bytestring case-insensitive double-conversion text
           ];
           doHaddock = false;
           doCheck = false;
           homepage = "https://github.com/twittner/bytestring-conversion/";
           description = "Type-classes to convert values to and from ByteString";
           license = stdenv.lib.licenses.mpl20;
         }) {};
      "bytestring-lexing" = callPackage
        ({ mkDerivation, base, bytestring, stdenv }:
         mkDerivation {
           pname = "bytestring-lexing";
           version = "0.5.0.2";
           sha256 = "01f9add3f25067a89c5ae9ab1f2fd8ab75ec9f386987ee0d83f73ec855b43f73";
           libraryHaskellDepends = [ base bytestring ];
           doHaddock = false;
           doCheck = false;
           homepage = "http://code.haskell.org/~wren/";
           description = "Parse and produce literals efficiently from strict or lazy bytestrings";
           license = stdenv.lib.licenses.bsd2;
         }) {};
      "bytestring-strict-builder" = callPackage
        ({ mkDerivation, base, base-prelude, bytestring, semigroups, stdenv
         }:
         mkDerivation {
           pname = "bytestring-strict-builder";
           version = "0.4.5.1";
           sha256 = "1879edb56e530169f5c4a738fff46ac56faeb30f9ac3d59f1361183111a5c69e";
           revision = "1";
           editedCabalFile = "1snn8qb17maa76zji75i4yfz9x8ci16xp6zwg6kgwb33lf06imnd";
           libraryHaskellDepends = [
             base base-prelude bytestring semigroups
           ];
           doHaddock = false;
           doCheck = false;
           homepage = "https://github.com/nikita-volkov/bytestring-strict-builder";
           description = "An efficient strict bytestring builder";
           license = stdenv.lib.licenses.mit;
         }) {};
      "bytestring-tree-builder" = callPackage
        ({ mkDerivation, base, base-prelude, bytestring, semigroups, stdenv
         , text
         }:
         mkDerivation {
           pname = "bytestring-tree-builder";
           version = "0.2.7.2";
           sha256 = "a12df2ef970eab34c7bb968ba1a157fb01e478cd9abada097fc3e4ec61b5020e";
           libraryHaskellDepends = [
             base base-prelude bytestring semigroups text
           ];
           doHaddock = false;
           doCheck = false;
           homepage = "https://github.com/nikita-volkov/bytestring-tree-builder";
           description = "A very efficient ByteString builder implementation based on the binary tree";
           license = stdenv.lib.licenses.mit;
         }) {};
      "bzlib" = callPackage
        ({ mkDerivation, base, bytestring, bzip2, stdenv }:
         mkDerivation {
           pname = "bzlib";
           version = "0.5.0.5";
           sha256 = "9ee7d0ac7461b330820af928c13c6668bf4fe3601f171c42432a85c33718017e";
           libraryHaskellDepends = [ base bytestring ];
           librarySystemDepends = [ bzip2 ];
           doHaddock = false;
           doCheck = false;
           description = "Compression and decompression in the bzip2 format";
           license = stdenv.lib.licenses.bsd3;
         }) {inherit (pkgs) bzip2;};
      "bzlib-conduit" = callPackage
        ({ mkDerivation, base, bindings-DSL, bytestring, bzip2, conduit
         , data-default-class, mtl, resourcet, stdenv
         }:
         mkDerivation {
           pname = "bzlib-conduit";
           version = "0.3.0.1";
           sha256 = "43d811549f7fb0710e4895ad54f78418271579f7e27d75e3c3470b74b285a239";
           enableSeparateDataOutput = true;
           libraryHaskellDepends = [
             base bindings-DSL bytestring conduit data-default-class mtl
             resourcet
           ];
           librarySystemDepends = [ bzip2 ];
           doHaddock = false;
           doCheck = false;
           homepage = "https://github.com/snoyberg/bzlib-conduit#readme";
           description = "Streaming compression/decompression via conduits";
           license = stdenv.lib.licenses.bsd3;
         }) {inherit (pkgs) bzip2;};
      "c2hs" = callPackage
        ({ mkDerivation, array, base, bytestring, containers, directory
         , dlist, filepath, language-c, pretty, process, stdenv
         }:
         mkDerivation {
           pname = "c2hs";
           version = "0.28.6";
           sha256 = "91dd121ac565009f2fc215c50f3365ed66705071a698a545e869041b5d7ff4da";
           isLibrary = false;
           isExecutable = true;
           enableSeparateDataOutput = true;
           executableHaskellDepends = [
             array base bytestring containers directory dlist filepath
             language-c pretty process
           ];
           doHaddock = false;
           doCheck = false;
           homepage = "https://github.com/haskell/c2hs";
           description = "C->Haskell FFI tool that gives some cross-language type safety";
           license = stdenv.lib.licenses.gpl2;
         }) {};
      "cabal-doctest" = callPackage
        ({ mkDerivation, base, Cabal, directory, filepath, stdenv }:
         mkDerivation {
           pname = "cabal-doctest";
           version = "1.0.6";
           sha256 = "decaaa5a73eaabaf3c4f8c644bd7f6e3f428b6244e935c0cf105f75f9b24ed2d";
           revision = "2";
           editedCabalFile = "1kbiwqm4fxrsdpcqijdq98h8wzmxydcvxd03f1z8dliqzyqsbd60";
           libraryHaskellDepends = [ base Cabal directory filepath ];
           doHaddock = false;
           doCheck = false;
           homepage = "https://github.com/phadej/cabal-doctest";
           description = "A Setup.hs helper for doctests running";
           license = stdenv.lib.licenses.bsd3;
         }) {};
      "cabal-install" = callPackage
        ({ mkDerivation, array, async, base, base16-bytestring, binary
         , bytestring, Cabal, containers, cryptohash-sha256, deepseq
         , directory, echo, edit-distance, filepath, hackage-security
         , hashable, HTTP, mtl, network, network-uri, pretty, process
         , random, stdenv, stm, tar, time, unix, zlib
         }:
         mkDerivation {
           pname = "cabal-install";
           version = "2.2.0.0";
           sha256 = "c856a2dd93c5a7b909597c066b9f9ca27fbda1a502b3f96077b7918c0f64a3d9";
           revision = "1";
           editedCabalFile = "0f1svlhh4cpj3p5fs9bcjpv15qp291lnvlaxxcw7aib8a1gn3wim";
           configureFlags = [ "-flib" "-f-native-dns" ];
           isLibrary = true;
           isExecutable = true;
           setupHaskellDepends = [ base Cabal filepath process ];
           libraryHaskellDepends = [
             array async base base16-bytestring binary bytestring Cabal
             containers cryptohash-sha256 deepseq directory echo edit-distance
             filepath hackage-security hashable HTTP mtl network network-uri
             pretty process random stm tar time unix zlib
           ];
           executableHaskellDepends = [ base Cabal directory filepath ];
           doHaddock = false;
           doCheck = false;
           postInstall = ''
             mkdir $out/etc
             mv bash-completion $out/etc/bash_completion.d
           '';
           homepage = "http://www.haskell.org/cabal/";
           description = "The command-line interface for Cabal and Hackage";
           license = stdenv.lib.licenses.bsd3;
         }) {};
      "cabal-rpm" = callPackage
        ({ mkDerivation, base, bytestring, Cabal, directory, filepath
         , http-client, http-client-tls, http-conduit, process, simple-cmd
         , stdenv, time, unix
         }:
         mkDerivation {
           pname = "cabal-rpm";
           version = "0.12.6";
           sha256 = "da26117406caca76e85729b69c8ef573499b5fb1a816951aeb861fb4cf16c0cc";
           configureFlags = [ "-f-old-locale" ];
           isLibrary = false;
           isExecutable = true;
           executableHaskellDepends = [
             base bytestring Cabal directory filepath http-client
             http-client-tls http-conduit process simple-cmd time unix
           ];
           doHaddock = false;
           doCheck = false;
           homepage = "https://github.com/juhp/cabal-rpm";
           description = "RPM packaging tool for Haskell Cabal-based packages";
           license = stdenv.lib.licenses.gpl3;
         }) {};
      "cabal2nix" = callPackage
        ({ mkDerivation, aeson, ansi-wl-pprint, base, bytestring, Cabal
         , containers, deepseq, directory, distribution-nixpkgs, filepath
         , hackage-db, hopenssl, hpack, language-nix, lens, monad-par
         , monad-par-extras, mtl, optparse-applicative, pretty, process
         , split, stdenv, text, time, transformers, yaml
         }:
         mkDerivation {
           pname = "cabal2nix";
           version = "2.9.3";
           sha256 = "129fcefe74fcb0c15aa4747603116820d751b0ea904376cd1603381a339a8182";
           isLibrary = true;
           isExecutable = true;
           libraryHaskellDepends = [
             aeson ansi-wl-pprint base bytestring Cabal containers deepseq
             directory distribution-nixpkgs filepath hackage-db hopenssl hpack
             language-nix lens optparse-applicative pretty process split text
             time transformers yaml
           ];
           executableHaskellDepends = [
             aeson base bytestring Cabal containers directory
             distribution-nixpkgs filepath hopenssl language-nix lens monad-par
             monad-par-extras mtl optparse-applicative pretty
           ];
           doHaddock = false;
           doCheck = false;
           preCheck = ''
             export PATH="$PWD/dist/build/cabal2nix:$PATH"
             export HOME="$TMPDIR/home"
           '';
           homepage = "https://github.com/nixos/cabal2nix#readme";
           description = "Convert Cabal files into Nix build instructions";
           license = stdenv.lib.licenses.bsd3;
         }) {};
      "cabal2spec" = callPackage
        ({ mkDerivation, base, Cabal, filepath, optparse-applicative
         , stdenv, time
         }:
         mkDerivation {
           pname = "cabal2spec";
           version = "2.1.1";
           sha256 = "ad063835309823388883324a42d951f15c5da9b4e324bfe3de97751f4fdca9ba";
           isLibrary = true;
           isExecutable = true;
           libraryHaskellDepends = [ base Cabal filepath time ];
           executableHaskellDepends = [
             base Cabal filepath optparse-applicative
           ];
           doHaddock = false;
           doCheck = false;
           homepage = "https://github.com/peti/cabal2spec";
           description = "Convert Cabal files into rpm spec files";
           license = stdenv.lib.licenses.gpl3;
         }) {};
      "cache" = callPackage
        ({ mkDerivation, base, clock, hashable, stdenv, stm, transformers
         , unordered-containers
         }:
         mkDerivation {
           pname = "cache";
           version = "0.1.1.1";
           sha256 = "1029991d52add00d7ea68cc03e7d87301cf23f644a0ffa8dbbaed91c9eb05f11";
           libraryHaskellDepends = [
             base clock hashable stm transformers unordered-containers
           ];
           doHaddock = false;
           doCheck = false;
           homepage = "https://github.com/hverr/haskell-cache#readme";
           description = "An in-memory key/value store with expiration support";
           license = stdenv.lib.licenses.bsd3;
         }) {};
      "cachix" = callPackage
        ({ mkDerivation, async, base, base16-bytestring, base64-bytestring
         , bifunctors, bytestring, cachix-api, conduit, conduit-extra
         , cookie, cryptonite, data-default, dhall, directory, ed25519
         , filepath, fsnotify, here, hspec-discover, http-client
         , http-client-tls, http-conduit, http-types, lzma-conduit
         , megaparsec, memory, mmorph, optparse-applicative, process
         , protolude, resourcet, retry, safe-exceptions, servant
         , servant-auth, servant-auth-client, servant-client
         , servant-client-core, servant-streaming-client, stdenv, streaming
         , text, unix, uri-bytestring, versions
         }:
         mkDerivation {
           pname = "cachix";
           version = "0.1.3";
           sha256 = "a0fbaad0d8b286738ae58ccbb7a2fcd1e6cba983d973a9f1b7952399739b0f6e";
           isLibrary = true;
           isExecutable = true;
           libraryHaskellDepends = [
             async base base16-bytestring base64-bytestring bifunctors
             bytestring cachix-api conduit conduit-extra cookie cryptonite
             data-default dhall directory ed25519 filepath fsnotify here
             http-client http-client-tls http-conduit http-types lzma-conduit
             megaparsec memory mmorph optparse-applicative process protolude
             resourcet retry safe-exceptions servant servant-auth
             servant-auth-client servant-client servant-client-core
             servant-streaming-client streaming text unix uri-bytestring
             versions
           ];
           executableHaskellDepends = [ base cachix-api ];
           executableToolDepends = [ hspec-discover ];
           doHaddock = false;
           doCheck = false;
           homepage = "https://github.com/cachix/cachix#readme";
           description = "Command line client for Nix binary cache hosting https://cachix.org";
           license = stdenv.lib.licenses.asl20;
         }) {};
      "cachix-api" = callPackage
        ({ mkDerivation, aeson, amazonka, base, base16-bytestring
         , bytestring, conduit, cookie, cryptonite, http-api-data
         , http-media, lens, memory, servant, servant-auth
         , servant-auth-server, servant-auth-swagger, servant-streaming
         , servant-swagger, servant-swagger-ui-core, stdenv, string-conv
         , swagger2, text, transformers
         }:
         mkDerivation {
           pname = "cachix-api";
           version = "0.1.0.3";
           sha256 = "aefd2d623cb8b0da0ac6861df37f2f5673659ebd341943e4da9c538befa84502";
           isLibrary = true;
           isExecutable = true;
           libraryHaskellDepends = [
             aeson amazonka base base16-bytestring bytestring conduit cookie
             cryptonite http-api-data http-media lens memory servant
             servant-auth servant-auth-server servant-auth-swagger
             servant-streaming servant-swagger servant-swagger-ui-core
             string-conv swagger2 text transformers
           ];
           executableHaskellDepends = [ aeson base ];
           doHaddock = false;
           doCheck = false;
           homepage = "https://github.com/cachix/cachix#readme";
           description = "Servant HTTP API specification for https://cachix.org";
           license = stdenv.lib.licenses.asl20;
         }) {};
      "cairo" = callPackage
        ({ mkDerivation, array, base, bytestring, Cabal, cairo
         , gtk2hs-buildtools, mtl, stdenv, text, utf8-string
         }:
         mkDerivation {
           pname = "cairo";
           version = "0.13.5.0";
           sha256 = "420acd81e0b5578ad188bcdd38463135293c233221abb741cc4004d4c8a6bef3";
           enableSeparateDataOutput = true;
           setupHaskellDepends = [ base Cabal gtk2hs-buildtools ];
           libraryHaskellDepends = [
             array base bytestring mtl text utf8-string
           ];
           libraryPkgconfigDepends = [ cairo ];
           doHaddock = false;
           doCheck = false;
           homepage = "http://projects.haskell.org/gtk2hs/";
           description = "Binding to the Cairo library";
           license = stdenv.lib.licenses.bsd3;
         }) {inherit (pkgs) cairo;};
      "calendar-recycling" = callPackage
        ({ mkDerivation, base, containers, html, old-time, stdenv
         , utility-ht
         }:
         mkDerivation {
           pname = "calendar-recycling";
           version = "0.0.0.1";
           sha256 = "8cd39ccf4fbe538f8e5d434d0efd0c559074420b9283d2c7c4b7ab6262b4d529";
           isLibrary = false;
           isExecutable = true;
           executableHaskellDepends = [
             base containers html old-time utility-ht
           ];
           doHaddock = false;
           doCheck = false;
           homepage = "http://hub.darcs.net/thielema/calendar-recycling";
           description = "List years with the same calendars";
           license = stdenv.lib.licenses.bsd3;
         }) {};
      "call-stack" = callPackage
        ({ mkDerivation, base, stdenv }:
         mkDerivation {
           pname = "call-stack";
           version = "0.1.0";
           sha256 = "f25f5e0992a39371079cc25c2a14b5abb872fa7d868a32753aac3a258b83b1e2";
           libraryHaskellDepends = [ base ];
           doHaddock = false;
           doCheck = false;
           homepage = "https://github.com/sol/call-stack#readme";
           description = "Use GHC call-stacks in a backward compatible way";
           license = stdenv.lib.licenses.mit;
         }) {};
      "capataz" = callPackage
        ({ mkDerivation, async, base, bytestring, pretty-show
         , prettyprinter, rio, stdenv, teardown, time, uuid
         }:
         mkDerivation {
           pname = "capataz";
           version = "0.2.0.0";
           sha256 = "a4dfc60ccd24bb3102127cb0226f23abfc12b7263fe45e74747cf674d736022c";
           libraryHaskellDepends = [
             async base bytestring pretty-show prettyprinter rio teardown time
             uuid
           ];
           doHaddock = false;
           doCheck = false;
           homepage = "https://github.com/roman/Haskell-capataz#readme";
           description = "OTP-like supervision trees in Haskell";
           license = stdenv.lib.licenses.mit;
         }) {};
      "carray" = callPackage
        ({ mkDerivation, array, base, binary, bytestring, ix-shapable
         , QuickCheck, stdenv, syb
         }:
         mkDerivation {
           pname = "carray";
           version = "0.1.6.8";
           sha256 = "8f1967d54c7cf9680481c6f630eafa66f6d916b93c98f3b3c47449f682f11613";
           libraryHaskellDepends = [
             array base binary bytestring ix-shapable QuickCheck syb
           ];
           doHaddock = false;
           doCheck = false;
           description = "A C-compatible array library";
           license = stdenv.lib.licenses.bsd3;
         }) {};
      "case-insensitive" = callPackage
        ({ mkDerivation, base, bytestring, deepseq, hashable, stdenv, text
         }:
         mkDerivation {
           pname = "case-insensitive";
           version = "1.2.0.11";
           sha256 = "a7ce6d17e50caaa0f19ad8e67361499022860554c521b1e57993759da3eb37e3";
           libraryHaskellDepends = [ base bytestring deepseq hashable text ];
           doHaddock = false;
           doCheck = false;
           homepage = "https://github.com/basvandijk/case-insensitive";
           description = "Case insensitive string comparison";
           license = stdenv.lib.licenses.bsd3;
         }) {};
      "cased" = callPackage
        ({ mkDerivation, base, stdenv, text }:
         mkDerivation {
           pname = "cased";
           version = "0.1.0.0";
           sha256 = "8394e6705ed83152875e1de1c51c54c26b04a2359919d8958d66997b2b60ad23";
           libraryHaskellDepends = [ base text ];
           doHaddock = false;
           doCheck = false;
           homepage = "https://github.com/jb55/cased";
           description = "Track string casing in its type";
           license = stdenv.lib.licenses.mit;
         }) {};
      "cases" = callPackage
        ({ mkDerivation, attoparsec, base-prelude, loch-th, stdenv, text }:
         mkDerivation {
           pname = "cases";
           version = "0.1.3.2";
           sha256 = "9ecf632f7751aac2ed7ec93407f9499237316f2eb50f331bb4969abf3359a8a9";
           libraryHaskellDepends = [ attoparsec base-prelude loch-th text ];
           doHaddock = false;
           doCheck = false;
           homepage = "https://github.com/nikita-volkov/cases";
           description = "A converter for spinal, snake and camel cases";
           license = stdenv.lib.licenses.mit;
         }) {};
      "casing" = callPackage
        ({ mkDerivation, base, split, stdenv }:
         mkDerivation {
           pname = "casing";
           version = "0.1.4.0";
           sha256 = "8e8a3631ef5823ae53dfeb7497ad4856c6758e3e380ff164f6a261f41685f6d7";
           libraryHaskellDepends = [ base split ];
           doHaddock = false;
           doCheck = false;
           description = "Convert between various source code casing conventions";
           license = stdenv.lib.licenses.mit;
         }) {};
      "cassava" = callPackage
        ({ mkDerivation, array, attoparsec, base, bytestring, containers
         , deepseq, hashable, Only, scientific, stdenv, text, text-short
         , unordered-containers, vector
         }:
         mkDerivation {
           pname = "cassava";
           version = "0.5.1.0";
           sha256 = "762c8aaea2cdad61f52bad1b9f1f3b32764b4b6da03371aba6e5017f69614277";
           revision = "1";
           editedCabalFile = "1brz20js95synh0yw942ihy4y9y6nk4xnsqcjqi9580y24zcigkl";
           configureFlags = [ "-f-bytestring--lt-0_10_4" ];
           libraryHaskellDepends = [
             array attoparsec base bytestring containers deepseq hashable Only
             scientific text text-short unordered-containers vector
           ];
           doHaddock = false;
           doCheck = false;
           homepage = "https://github.com/hvr/cassava";
           description = "A CSV parsing and encoding library";
           license = stdenv.lib.licenses.bsd3;
         }) {};
      "cassava-conduit" = callPackage
        ({ mkDerivation, array, base, bifunctors, bytestring, cassava
         , conduit, containers, mtl, stdenv, text
         }:
         mkDerivation {
           pname = "cassava-conduit";
           version = "0.5.0";
           sha256 = "19460ab99942455cc12fa38b15c07da80df496eb5494675e7e524d197d874876";
           libraryHaskellDepends = [
             array base bifunctors bytestring cassava conduit containers mtl
             text
           ];
           doHaddock = false;
           doCheck = false;
           homepage = "https://github.com/domdere/cassava-conduit";
           description = "Conduit interface for cassava package";
           license = stdenv.lib.licenses.bsd3;
         }) {};
      "cassava-records" = callPackage
        ({ mkDerivation, attoparsec, base, bytestring, cassava, foldl
         , stdenv, template-haskell, text, unordered-containers, vector
         }:
         mkDerivation {
           pname = "cassava-records";
           version = "0.1.0.4";
           sha256 = "11f832c11125bd7a73b57941284d9aeb7f1e7572004da7e37311b34d3366af8d";
           libraryHaskellDepends = [
             attoparsec base bytestring cassava foldl template-haskell text
             unordered-containers vector
           ];
           doHaddock = false;
           doCheck = false;
           homepage = "https://github.com/gdevanla/cassava-records#readme";
           description = "Auto-generation of records data type";
           license = stdenv.lib.licenses.bsd3;
         }) {};
      "cast" = callPackage
        ({ mkDerivation, base, stdenv }:
         mkDerivation {
           pname = "cast";
           version = "0.1.0.2";
           sha256 = "24d545e5974436b6e3ee9dfda7ed68218c9f698103adae676a60860d90d7bc91";
           libraryHaskellDepends = [ base ];
           doHaddock = false;
           doCheck = false;
           homepage = "https://github.com/haskell-patterns/cast#readme";
           description = "Abstact cast pattern";
           license = stdenv.lib.licenses.bsd3;
         }) {};
      "category" = callPackage
        ({ mkDerivation, alg, base, stdenv }:
         mkDerivation {
           pname = "category";
           version = "0.2.1.0";
           sha256 = "b0e753d69d8e46c3cf7f999003032eaa788d3a386eef4a5539cd0e9f1b475ddb";
           libraryHaskellDepends = [ alg base ];
           doHaddock = false;
           doCheck = false;
           description = "Categorical types and classes";
           license = stdenv.lib.licenses.bsd3;
         }) {};
      "cayley-client" = callPackage
        ({ mkDerivation, aeson, attoparsec, base, binary, bytestring
         , exceptions, http-client, http-conduit, lens, lens-aeson, mtl
         , stdenv, text, transformers, unordered-containers, vector
         }:
         mkDerivation {
           pname = "cayley-client";
           version = "0.4.8";
           sha256 = "b1b1328fb855211a78b9c7da74eecc7ee81c9f92101debb9ca87238d66c01926";
           libraryHaskellDepends = [
             aeson attoparsec base binary bytestring exceptions http-client
             http-conduit lens lens-aeson mtl text transformers
             unordered-containers vector
           ];
           doHaddock = false;
           doCheck = false;
           homepage = "https://github.com/MichelBoucey/cayley-client";
           description = "A Haskell client for the Cayley graph database";
           license = stdenv.lib.licenses.bsd3;
         }) {};
      "cborg" = callPackage
        ({ mkDerivation, array, base, bytestring, containers, deepseq
         , ghc-prim, half, integer-gmp, primitive, stdenv, text
         }:
         mkDerivation {
           pname = "cborg";
           version = "0.2.1.0";
           sha256 = "9198735f7645ae492345505448f790433f5fe407b19e1c6b2ec2a4c76bd97483";
           libraryHaskellDepends = [
             array base bytestring containers deepseq ghc-prim half integer-gmp
             primitive text
           ];
           doHaddock = false;
           doCheck = false;
           description = "Concise Binary Object Representation";
           license = stdenv.lib.licenses.bsd3;
         }) {};
      "cereal" = callPackage
        ({ mkDerivation, array, base, bytestring, containers, ghc-prim
         , stdenv
         }:
         mkDerivation {
           pname = "cereal";
           version = "0.5.7.0";
           sha256 = "7abdaf6d52260e714adcf1c3e16f2e25a56492d90a747d1a9594e15f05acf1c8";
           libraryHaskellDepends = [
             array base bytestring containers ghc-prim
           ];
           doHaddock = false;
           doCheck = false;
           homepage = "https://github.com/GaloisInc/cereal";
           description = "A binary serialization library";
           license = stdenv.lib.licenses.bsd3;
         }) {};
      "cereal-conduit" = callPackage
        ({ mkDerivation, base, bytestring, cereal, conduit, resourcet
         , stdenv, transformers
         }:
         mkDerivation {
           pname = "cereal-conduit";
           version = "0.8.0";
           sha256 = "d95c4518a9984feacfd811c64be993705bff74c1f2daa00b4687bbb79f3a39eb";
           revision = "1";
           editedCabalFile = "1imyl3g2bni8bc6kajr857xh94fscphksj3286pxfpa8yp9vqqpc";
           libraryHaskellDepends = [
             base bytestring cereal conduit resourcet transformers
           ];
           doHaddock = false;
           doCheck = false;
           homepage = "https://github.com/snoyberg/conduit";
           description = "Turn Data.Serialize Gets and Puts into Sources, Sinks, and Conduits";
           license = stdenv.lib.licenses.bsd3;
         }) {};
      "cereal-text" = callPackage
        ({ mkDerivation, base, cereal, stdenv, text }:
         mkDerivation {
           pname = "cereal-text";
           version = "0.1.0.2";
           sha256 = "3c7a15f4681fa53b66dcd5165f31f56ff9751a752ac5123ecc5bcf5c3ea0354c";
           libraryHaskellDepends = [ base cereal text ];
           doHaddock = false;
           doCheck = false;
           homepage = "https://github.com/ulikoehler/cereal-text";
           description = "Data.Text instances for the cereal serialization library";
           license = stdenv.lib.licenses.asl20;
         }) {};
      "cereal-time" = callPackage
        ({ mkDerivation, base, cereal, stdenv, time }:
         mkDerivation {
           pname = "cereal-time";
           version = "0.1.0.0";
           sha256 = "bec6d5103ec45bee242825da4cf695f574f101bb1d48778bf7823175dfa43cb2";
           libraryHaskellDepends = [ base cereal time ];
           doHaddock = false;
           doCheck = false;
           description = "Serialize instances for types from `time` package";
           license = stdenv.lib.licenses.bsd3;
         }) {};
      "cereal-vector" = callPackage
        ({ mkDerivation, base, bytestring, cereal, stdenv, vector }:
         mkDerivation {
           pname = "cereal-vector";
           version = "0.2.0.1";
           sha256 = "ff0685a6c39e7aae32f8b4165e2ae06f284c867298ad4f7b776c1c1b2859f933";
           libraryHaskellDepends = [ base bytestring cereal vector ];
           doHaddock = false;
           doCheck = false;
           homepage = "https://github.com/acfoltzer/cereal-vector";
           description = "Serialize instances for Data.Vector types.";
           license = stdenv.lib.licenses.bsd3;
         }) {};
      "cfenv" = callPackage
        ({ mkDerivation, aeson, base, bytestring, containers, stdenv }:
         mkDerivation {
           pname = "cfenv";
           version = "0.1.0.0";
           sha256 = "8ce96643559ebe4504c0641f9817d8795b22631f614084af50c88e51277e747e";
           libraryHaskellDepends = [ aeson base bytestring containers ];
           doHaddock = false;
           doCheck = false;
           homepage = "https://github.com/tomphp/haskell-cfenv#readme";
           description = "A library getting the environment when running on Cloud Foundry";
           license = stdenv.lib.licenses.bsd3;
         }) {};
      "chan" = callPackage
        ({ mkDerivation, async, base, stdenv, stm }:
         mkDerivation {
           pname = "chan";
           version = "0.0.4.1";
           sha256 = "926fcb205f6d43ed3a2b85b8e88a6c99a2deb097bc7988116c493a04a52547cf";
           libraryHaskellDepends = [ async base stm ];
           doHaddock = false;
           doCheck = false;
           homepage = "https://github.com/athanclark/chan#readme";
           description = "Some extra kit for Chans";
           license = stdenv.lib.licenses.bsd3;
         }) {};
      "charset" = callPackage
        ({ mkDerivation, array, base, bytestring, containers, semigroups
         , stdenv, unordered-containers
         }:
         mkDerivation {
           pname = "charset";
           version = "0.3.7.1";
           sha256 = "3d415d2883bd7bf0cc9f038e8323f19c71e07dd12a3c712f449ccb8b4daac0be";
           revision = "1";
           editedCabalFile = "1z6nxw2g9vgsjq0g159sk8mwj68lwzxzi5iv5ynha0h85jcqxszy";
           libraryHaskellDepends = [
             array base bytestring containers semigroups unordered-containers
           ];
           doHaddock = false;
           doCheck = false;
           homepage = "http://github.com/ekmett/charset";
           description = "Fast unicode character sets based on complemented PATRICIA tries";
           license = stdenv.lib.licenses.bsd3;
         }) {};
      "charsetdetect-ae" = callPackage
        ({ mkDerivation, base, bytestring, stdenv }:
         mkDerivation {
           pname = "charsetdetect-ae";
           version = "1.1.0.4";
           sha256 = "9bbaa48d3026abdd403ed59ee5f41978b2f5be6d0dc545e142c86d5aa790410c";
           libraryHaskellDepends = [ base bytestring ];
           doHaddock = false;
           doCheck = false;
           homepage = "http://github.com/aelve/charsetdetect-ae";
           description = "Character set detection using Mozilla's Universal Character Set Detector";
           license = "LGPL";
         }) {};
      "chart-unit" = callPackage
        ({ mkDerivation, base, colour, data-default, diagrams-lib
         , diagrams-svg, foldl, formatting, generic-lens, lens, linear
         , numhask, numhask-prelude, numhask-range, palette, protolude
         , scientific, stdenv, svg-builder, SVGFonts, text, time
         }:
         mkDerivation {
           pname = "chart-unit";
           version = "0.7.0.0";
           sha256 = "97f893f3a9f28cf93d8ad30991ed6fec04c908e8a5bbc4f8e018f06a00bab20e";
           libraryHaskellDepends = [
             base colour data-default diagrams-lib diagrams-svg foldl formatting
             generic-lens lens linear numhask numhask-prelude numhask-range
             palette protolude scientific svg-builder SVGFonts text time
           ];
           doHaddock = false;
           doCheck = false;
           homepage = "https://github.com/tonyday567/chart-unit#readme";
           description = "Native haskell charts";
           license = stdenv.lib.licenses.bsd3;
         }) {};
      "chaselev-deque" = callPackage
        ({ mkDerivation, abstract-deque, array, atomic-primops, base
         , ghc-prim, stdenv, transformers, vector
         }:
         mkDerivation {
           pname = "chaselev-deque";
           version = "0.5.0.5";
           sha256 = "4d58f8d56228e9f5bea2a65717dea65106323cb5ead9b5f39f904dac5c0043f4";
           libraryHaskellDepends = [
             abstract-deque array atomic-primops base ghc-prim transformers
             vector
           ];
           doHaddock = false;
           doCheck = false;
           homepage = "https://github.com/rrnewton/haskell-lockfree/wiki";
           description = "Chase & Lev work-stealing lock-free double-ended queues (deques)";
           license = stdenv.lib.licenses.bsd3;
         }) {};
      "chatwork" = callPackage
        ({ mkDerivation, aeson, aeson-casing, base, bytestring, connection
         , data-default-class, http-api-data, http-client, http-client-tls
         , http-types, req, stdenv, text
         }:
         mkDerivation {
           pname = "chatwork";
           version = "0.1.3.5";
           sha256 = "755e81663dcfd3c325bff3ffe2aedb1594bf46b303a172e8a2f42ae43eec6959";
           isLibrary = true;
           isExecutable = true;
           libraryHaskellDepends = [
             aeson aeson-casing base bytestring connection data-default-class
             http-api-data http-client http-client-tls http-types req text
           ];
           executableHaskellDepends = [
             aeson aeson-casing base bytestring connection data-default-class
             http-api-data http-client http-client-tls http-types req text
           ];
           doHaddock = false;
           doCheck = false;
           homepage = "https://github.com/matsubara0507/chatwork#readme";
           description = "The ChatWork API in Haskell";
           license = stdenv.lib.licenses.mit;
         }) {};
      "cheapskate" = callPackage
        ({ mkDerivation, base, blaze-html, bytestring, containers
         , data-default, deepseq, mtl, stdenv, syb, text, uniplate
         , xss-sanitize
         }:
         mkDerivation {
           pname = "cheapskate";
           version = "0.1.1.1";
           sha256 = "d50d4f6978343f4990aeb6debf11e33054d8dc5ec4390196f12b8b68176ade62";
           revision = "1";
           editedCabalFile = "0mf6qdpgh56n0ynyy272vhkk2bjrdhppks2vrw79gk0kzn29fggh";
           isLibrary = true;
           isExecutable = true;
           libraryHaskellDepends = [
             base blaze-html containers data-default deepseq mtl syb text
             uniplate xss-sanitize
           ];
           executableHaskellDepends = [ base blaze-html bytestring text ];
           doHaddock = false;
           doCheck = false;
           homepage = "http://github.com/jgm/cheapskate";
           description = "Experimental markdown processor";
           license = stdenv.lib.licenses.bsd3;
         }) {};
      "cheapskate-highlight" = callPackage
        ({ mkDerivation, base, blaze-html, cheapskate, highlighting-kate
         , stdenv, text
         }:
         mkDerivation {
           pname = "cheapskate-highlight";
           version = "0.1.0.0";
           sha256 = "5af7afb26b4ea80952963b44db695cbf18da34d3e8a7d32382a7dbfa4832d370";
           revision = "1";
           editedCabalFile = "1c8kxqdqf0j962xjdrrjfcbjsl0c1kax31rjykymv7w16d6hmlj4";
           libraryHaskellDepends = [
             base blaze-html cheapskate highlighting-kate text
           ];
           doHaddock = false;
           doCheck = false;
           homepage = "http://github.com/aelve/cheapskate-highlight";
           description = "Code highlighting for cheapskate";
           license = stdenv.lib.licenses.bsd3;
         }) {};
      "cheapskate-lucid" = callPackage
        ({ mkDerivation, base, blaze-html, cheapskate, lucid, stdenv }:
         mkDerivation {
           pname = "cheapskate-lucid";
           version = "0.1.0.0";
           sha256 = "f582e512befd2707a7056c1d15541967de2e0ce5702bc2197a3fced58a777245";
           revision = "1";
           editedCabalFile = "197nx95xw21i7zyvgzcgnr36ab6vrk17c66iz8ndwz61vp1jf6hc";
           libraryHaskellDepends = [ base blaze-html cheapskate lucid ];
           doHaddock = false;
           doCheck = false;
           homepage = "http://github.com/aelve/cheapskate-lucid";
           description = "Use cheapskate with Lucid";
           license = stdenv.lib.licenses.bsd3;
         }) {};
      "check-email" = callPackage
        ({ mkDerivation, base, bytestring, email-validate, resolv, stdenv
         }:
         mkDerivation {
           pname = "check-email";
           version = "1.0.2";
           sha256 = "1c2615fadba09a5d7aa5c68648d12218a595efb759842fb4f524cf380afa9327";
           libraryHaskellDepends = [ base bytestring email-validate ];
           librarySystemDepends = [ resolv ];
           doHaddock = false;
           doCheck = false;
           homepage = "https://github.com/qoelet/check-email#readme";
           description = "Confirm whether an email is valid and probably existant";
           license = stdenv.lib.licenses.bsd3;
         }) {inherit (pkgs) resolv;};
      "checkers" = callPackage
        ({ mkDerivation, array, base, QuickCheck, random, semigroupoids
         , stdenv
         }:
         mkDerivation {
           pname = "checkers";
           version = "0.4.11";
           sha256 = "d0602d3561b9c3d9365387543e363e40b11851ace42698feb519c6567d842d38";
           libraryHaskellDepends = [
             array base QuickCheck random semigroupoids
           ];
           doHaddock = false;
           doCheck = false;
           homepage = "https://github.com/conal/checkers";
           description = "Check properties on standard classes and data structures";
           license = stdenv.lib.licenses.bsd3;
         }) {};
      "checksum" = callPackage
        ({ mkDerivation, base, explicit-exception, stdenv, utility-ht }:
         mkDerivation {
           pname = "checksum";
           version = "0.0";
           sha256 = "337a0f6fcf7687469ecd410a3ed41c85ab68de08b5da0798d0d0aeb861a4470c";
           libraryHaskellDepends = [ base explicit-exception utility-ht ];
           doHaddock = false;
           doCheck = false;
           homepage = "http://hub.darcs.net/thielema/checksum";
           description = "Compute and verify checksums of ISBN, IBAN, etc";
           license = stdenv.lib.licenses.bsd3;
         }) {};
      "choice" = callPackage
        ({ mkDerivation, base, stdenv }:
         mkDerivation {
           pname = "choice";
           version = "0.2.2";
           sha256 = "d367e4321329df5913216f9746528e4526e14b5ad1f33edc82de8288ad719e61";
           libraryHaskellDepends = [ base ];
           doHaddock = false;
           doCheck = false;
           homepage = "https://github.com/mboes/choice#readme";
           description = "A solution to boolean blindness";
           license = stdenv.lib.licenses.publicDomain;
         }) {};
      "chronologique" = callPackage
        ({ mkDerivation, aeson, base, hourglass, stdenv, text, time, vector
         }:
         mkDerivation {
           pname = "chronologique";
           version = "0.3.1.1";
           sha256 = "c538bc2e7b1cb9c1f4ae4177a5545c08d3ff66c29c80ef8faddd92daaa499e16";
           libraryHaskellDepends = [ aeson base hourglass text time vector ];
           doHaddock = false;
           doCheck = false;
           homepage = "https://github.com/afcowie/chronologique/";
           description = "Time to manipulate time";
           license = stdenv.lib.licenses.bsd3;
         }) {};
      "chunked-data" = callPackage
        ({ mkDerivation, base, bytestring, containers, semigroups, stdenv
         , text, transformers, vector
         }:
         mkDerivation {
           pname = "chunked-data";
           version = "0.3.1";
           sha256 = "f710c581aee1f899e807fc9e6cba721b27d53dc9d56986f1922bc7ccddf1a79a";
           libraryHaskellDepends = [
             base bytestring containers semigroups text transformers vector
           ];
           doHaddock = false;
           doCheck = false;
           homepage = "https://github.com/snoyberg/mono-traversable#readme";
           description = "Typeclasses for dealing with various chunked data representations";
           license = stdenv.lib.licenses.mit;
         }) {};
      "cipher-aes" = callPackage
        ({ mkDerivation, base, byteable, bytestring, crypto-cipher-types
         , securemem, stdenv
         }:
         mkDerivation {
           pname = "cipher-aes";
           version = "0.2.11";
           sha256 = "d3b171895698c73da24d7ce97543f725d26637f038de670c0fd4012ca7f95015";
           libraryHaskellDepends = [
             base byteable bytestring crypto-cipher-types securemem
           ];
           doHaddock = false;
           doCheck = false;
           homepage = "https://github.com/vincenthz/hs-cipher-aes";
           description = "Fast AES cipher implementation with advanced mode of operations";
           license = stdenv.lib.licenses.bsd3;
         }) {};
      "cipher-aes128" = callPackage
        ({ mkDerivation, base, bytestring, Cabal, cereal, crypto-api
         , process, stdenv, tagged
         }:
         mkDerivation {
           pname = "cipher-aes128";
           version = "0.7.0.4";
           sha256 = "cd8d8987c1a1839f3c66e655277981083be85489d34b6b47f95d7e82d2d10285";
           isLibrary = true;
           isExecutable = true;
           setupHaskellDepends = [ base Cabal process ];
           libraryHaskellDepends = [
             base bytestring cereal crypto-api tagged
           ];
           doHaddock = false;
           doCheck = false;
           homepage = "https://github.com/TomMD/cipher-aes128";
           description = "AES and common modes using AES-NI when available";
           license = stdenv.lib.licenses.bsd3;
         }) {};
      "cipher-blowfish" = callPackage
        ({ mkDerivation, base, byteable, bytestring, crypto-cipher-types
         , securemem, stdenv, vector
         }:
         mkDerivation {
           pname = "cipher-blowfish";
           version = "0.0.3";
           sha256 = "8f41170a851dba6d0b6f07298af3213baca09ab2a8aaf2adb733631feb3b6641";
           libraryHaskellDepends = [
             base byteable bytestring crypto-cipher-types securemem vector
           ];
           doHaddock = false;
           doCheck = false;
           homepage = "http://github.com/vincenthz/hs-crypto-cipher";
           description = "Blowfish cipher";
           license = stdenv.lib.licenses.bsd3;
         }) {};
      "cipher-camellia" = callPackage
        ({ mkDerivation, base, byteable, bytestring, crypto-cipher-types
         , securemem, stdenv, vector
         }:
         mkDerivation {
           pname = "cipher-camellia";
           version = "0.0.2";
           sha256 = "8d0cd137cdb890646bb5d3bb52b20fa6d74e1b0c35d7d524d60edd9d43ace2a7";
           libraryHaskellDepends = [
             base byteable bytestring crypto-cipher-types securemem vector
           ];
           doHaddock = false;
           doCheck = false;
           homepage = "http://github.com/vincenthz/hs-crypto-cipher";
           description = "Camellia block cipher primitives";
           license = stdenv.lib.licenses.bsd3;
         }) {};
      "cipher-des" = callPackage
        ({ mkDerivation, base, byteable, bytestring, crypto-cipher-types
         , securemem, stdenv
         }:
         mkDerivation {
           pname = "cipher-des";
           version = "0.0.6";
           sha256 = "85f1bccdec625a120ecf83b861afcb6478f8f899ceaa06fc083e642b54ff4ac7";
           libraryHaskellDepends = [
             base byteable bytestring crypto-cipher-types securemem
           ];
           doHaddock = false;
           doCheck = false;
           homepage = "http://github.com/vincenthz/hs-crypto-cipher";
           description = "DES and 3DES primitives";
           license = stdenv.lib.licenses.bsd3;
         }) {};
      "cipher-rc4" = callPackage
        ({ mkDerivation, base, byteable, bytestring, crypto-cipher-types
         , stdenv
         }:
         mkDerivation {
           pname = "cipher-rc4";
           version = "0.1.4";
           sha256 = "c67e731bc9e7f3882e33609c3d9ec97b4e9bbd2f95cd882926acfb621970384d";
           libraryHaskellDepends = [
             base byteable bytestring crypto-cipher-types
           ];
           doHaddock = false;
           doCheck = false;
           homepage = "http://github.com/vincenthz/hs-cipher-rc4";
           description = "Fast RC4 cipher implementation";
           license = stdenv.lib.licenses.bsd3;
         }) {};
      "circle-packing" = callPackage
        ({ mkDerivation, base, stdenv }:
         mkDerivation {
           pname = "circle-packing";
           version = "0.1.0.6";
           sha256 = "64ee44a90da3e5fe20d5b78bfe6eba93102a6b52c65f8a7b99af7799798ee81b";
           revision = "2";
           editedCabalFile = "1ag213lv6yfzxdc4ghbywy165qblnqx5b3j9d23kc6fcyf19nfyk";
           libraryHaskellDepends = [ base ];
           doHaddock = false;
           doCheck = false;
           description = "Simple heuristic for packing discs of varying radii in a circle";
           license = stdenv.lib.licenses.bsd3;
         }) {};
      "cisco-spark-api" = callPackage
        ({ mkDerivation, aeson, attoparsec, base, bitset-word8, bytestring
         , conduit, data-default, http-conduit, network-uri
         , optparse-applicative, stdenv, text, utf8-string
         }:
         mkDerivation {
           pname = "cisco-spark-api";
           version = "0.1.0.4";
           sha256 = "6f550e999cb3b3bf1d4d041363c0bead0eec02f078dc51301873cc450143a244";
           isLibrary = true;
           isExecutable = true;
           libraryHaskellDepends = [
             aeson attoparsec base bitset-word8 bytestring conduit data-default
             http-conduit network-uri text
           ];
           executableHaskellDepends = [
             aeson base bytestring conduit data-default http-conduit
             optparse-applicative text utf8-string
           ];
           doHaddock = false;
           doCheck = false;
           homepage = "https://github.com/nshimaza/webex-teams-api#readme";
           description = "DEPRECATED in favor of webex-teams-api";
           license = stdenv.lib.licenses.mit;
         }) {};
      "clang-compilation-database" = callPackage
        ({ mkDerivation, aeson, base, bytestring, stdenv, text }:
         mkDerivation {
           pname = "clang-compilation-database";
           version = "0.1.0.1";
           sha256 = "114601a1769471e4fc2e8d100c5546e95fa803b9e56dcd342dab9829d0dc1ca8";
           libraryHaskellDepends = [ aeson base bytestring text ];
           doHaddock = false;
           doCheck = false;
           homepage = "https://github.com/lambdageek/clang-compilation-database";
           description = "JSON Compilation Database Format encoding and decoding";
           license = stdenv.lib.licenses.mit;
         }) {};
      "clash-ghc" = callPackage
        ({ mkDerivation, array, base, bifunctors, bytestring, clash-lib
         , clash-prelude, concurrent-supply, containers, deepseq, directory
         , filepath, ghc, ghc-boot, ghc-prim, ghc-typelits-extra
         , ghc-typelits-knownnat, ghc-typelits-natnormalise, ghci, hashable
         , haskeline, integer-gmp, lens, mtl, primitive, process, reflection
         , stdenv, text, time, transformers, unbound-generics, uniplate
         , unix, unordered-containers, vector
         }:
         mkDerivation {
           pname = "clash-ghc";
           version = "0.99.3";
           sha256 = "89470f1e133514a488d8c77ffd63535ffae5b014fc2288c6bc8879c10ddc4b3e";
           revision = "1";
           editedCabalFile = "0r86409nh73wcychmwh2j3qnbbjk9z2yxr5amx7gpc8gar4qb3qi";
           isLibrary = true;
           isExecutable = true;
           libraryHaskellDepends = [
             array base bifunctors bytestring clash-lib clash-prelude
             concurrent-supply containers deepseq directory filepath ghc
             ghc-boot ghc-prim ghc-typelits-extra ghc-typelits-knownnat
             ghc-typelits-natnormalise ghci hashable haskeline integer-gmp lens
             mtl primitive process reflection text time transformers
             unbound-generics uniplate unix unordered-containers vector
           ];
           executableHaskellDepends = [ base ];
           doHaddock = false;
           doCheck = false;
           homepage = "http://www.clash-lang.org/";
           description = "CAES Language for Synchronous Hardware";
           license = stdenv.lib.licenses.bsd2;
         }) {};
      "clash-lib" = callPackage
        ({ mkDerivation, aeson, ansi-wl-pprint, attoparsec, base
         , bytestring, clash-prelude, concurrent-supply, containers
         , data-binary-ieee754, deepseq, directory, errors, fgl, filepath
         , ghc, hashable, integer-gmp, lens, mtl, parsers, prettyprinter
         , primitive, process, reducers, stdenv, template-haskell, text
         , time, transformers, trifecta, unbound-generics
         , unordered-containers, vector
         }:
         mkDerivation {
           pname = "clash-lib";
           version = "0.99.3";
           sha256 = "556b0fc0166f2f3a48e3f9d6deecc25e472cce5183887fb046c0642cae73daba";
           enableSeparateDataOutput = true;
           libraryHaskellDepends = [
             aeson ansi-wl-pprint attoparsec base bytestring clash-prelude
             concurrent-supply containers data-binary-ieee754 deepseq directory
             errors fgl filepath ghc hashable integer-gmp lens mtl parsers
             prettyprinter primitive process reducers template-haskell text time
             transformers trifecta unbound-generics unordered-containers vector
           ];
           doHaddock = false;
           doCheck = false;
           homepage = "http://www.clash-lang.org/";
           description = "CAES Language for Synchronous Hardware - As a Library";
           license = stdenv.lib.licenses.bsd2;
         }) {};
      "clash-prelude" = callPackage
        ({ mkDerivation, array, base, bifunctors, constraints
         , data-binary-ieee754, data-default, deepseq, ghc-prim
         , ghc-typelits-extra, ghc-typelits-knownnat
         , ghc-typelits-natnormalise, half, integer-gmp, lens, QuickCheck
         , reflection, singletons, stdenv, template-haskell, transformers
         , vector
         }:
         mkDerivation {
           pname = "clash-prelude";
           version = "0.99.3";
           sha256 = "ef4628671f207dc7f27c7df46e5151f4c20826438507defd9bf05f76658b77bc";
           libraryHaskellDepends = [
             array base bifunctors constraints data-binary-ieee754 data-default
             deepseq ghc-prim ghc-typelits-extra ghc-typelits-knownnat
             ghc-typelits-natnormalise half integer-gmp lens QuickCheck
             reflection singletons template-haskell transformers vector
           ];
           doHaddock = false;
           doCheck = false;
           homepage = "http://www.clash-lang.org/";
           description = "CAES Language for Synchronous Hardware - Prelude library";
           license = stdenv.lib.licenses.bsd2;
         }) {};
      "classy-prelude" = callPackage
        ({ mkDerivation, async, base, basic-prelude, bifunctors, bytestring
         , chunked-data, containers, deepseq, dlist, ghc-prim, hashable
         , mono-traversable, mono-traversable-instances, mtl
         , mutable-containers, primitive, say, semigroups, stdenv, stm
         , stm-chans, text, time, transformers, unliftio
         , unordered-containers, vector, vector-instances
         }:
         mkDerivation {
           pname = "classy-prelude";
           version = "1.4.0";
           sha256 = "2b3b255676ab0fdeb39aebafa3543535ddd684d00c645b643e50cb9e2d25f9e0";
           revision = "1";
           editedCabalFile = "1gf615lz0bfsn09vrjgj63d8zcpsmz1cgvdv8px3h0b4jrwdij6v";
           libraryHaskellDepends = [
             async base basic-prelude bifunctors bytestring chunked-data
             containers deepseq dlist ghc-prim hashable mono-traversable
             mono-traversable-instances mtl mutable-containers primitive say
             semigroups stm stm-chans text time transformers unliftio
             unordered-containers vector vector-instances
           ];
           doHaddock = false;
           doCheck = false;
           homepage = "https://github.com/snoyberg/mono-traversable#readme";
           description = "A typeclass-based Prelude";
           license = stdenv.lib.licenses.mit;
         }) {};
      "classy-prelude-conduit" = callPackage
        ({ mkDerivation, base, bytestring, classy-prelude, conduit
         , monad-control, resourcet, stdenv, transformers, void
         }:
         mkDerivation {
           pname = "classy-prelude-conduit";
           version = "1.4.0";
           sha256 = "39ef2567a3542ebf91f6ebc103cc4afb64c2a4ec051c7ce578b577ef9931c424";
           libraryHaskellDepends = [
             base bytestring classy-prelude conduit monad-control resourcet
             transformers void
           ];
           doHaddock = false;
           doCheck = false;
           homepage = "https://github.com/snoyberg/mono-traversable#readme";
           description = "classy-prelude together with conduit functions";
           license = stdenv.lib.licenses.mit;
         }) {};
      "classy-prelude-yesod" = callPackage
        ({ mkDerivation, aeson, base, classy-prelude
         , classy-prelude-conduit, data-default, http-conduit, http-types
         , persistent, stdenv, yesod, yesod-newsfeed, yesod-static
         }:
         mkDerivation {
           pname = "classy-prelude-yesod";
           version = "1.4.0";
           sha256 = "0cd2a88f42c3541ba4bce6801c8b8d9c331e1c49a6288bf16f764676a34b9e28";
           libraryHaskellDepends = [
             aeson base classy-prelude classy-prelude-conduit data-default
             http-conduit http-types persistent yesod yesod-newsfeed
             yesod-static
           ];
           doHaddock = false;
           doCheck = false;
           homepage = "https://github.com/snoyberg/mono-traversable#readme";
           description = "Provide a classy prelude including common Yesod functionality";
           license = stdenv.lib.licenses.mit;
         }) {};
      "classyplate" = callPackage
        ({ mkDerivation, base, stdenv, template-haskell }:
         mkDerivation {
           pname = "classyplate";
           version = "0.3.2.0";
           sha256 = "712eefbe6b6fd92d6e5e7982d82a27e45b7992a83c2b09fc8696b1e30752527a";
           libraryHaskellDepends = [ base template-haskell ];
           doHaddock = false;
           doCheck = false;
           description = "Fuseable type-class based generics";
           license = stdenv.lib.licenses.bsd3;
         }) {};
      "clay" = callPackage
        ({ mkDerivation, base, mtl, stdenv, text }:
         mkDerivation {
           pname = "clay";
           version = "0.13.1";
           sha256 = "844e9101cc1835eb12bac50e289d00f19c24eeee12bcdebae1b633edffa328a3";
           libraryHaskellDepends = [ base mtl text ];
           doHaddock = false;
           doCheck = false;
           homepage = "http://fvisser.nl/clay";
           description = "CSS preprocessor as embedded Haskell";
           license = stdenv.lib.licenses.bsd3;
         }) {};
      "clientsession" = callPackage
        ({ mkDerivation, base, base64-bytestring, bytestring, cereal
         , cipher-aes, cprng-aes, crypto-api, crypto-random, directory
         , entropy, setenv, skein, stdenv, tagged
         }:
         mkDerivation {
           pname = "clientsession";
           version = "0.9.1.2";
           sha256 = "5915adc4de26d2a8b03f1a445bac0b0f5d10a5b0380a4eed71b79a20a727d068";
           isLibrary = true;
           isExecutable = true;
           libraryHaskellDepends = [
             base base64-bytestring bytestring cereal cipher-aes cprng-aes
             crypto-api crypto-random directory entropy setenv skein tagged
           ];
           executableHaskellDepends = [ base ];
           doHaddock = false;
           doCheck = false;
           homepage = "http://github.com/yesodweb/clientsession/tree/master";
           description = "Securely store session data in a client-side cookie";
           license = stdenv.lib.licenses.mit;
         }) {};
      "clock" = callPackage
        ({ mkDerivation, base, stdenv }:
         mkDerivation {
           pname = "clock";
           version = "0.7.2";
           sha256 = "886601978898d3a91412fef895e864576a7125d661e1f8abc49a2a08840e691f";
           libraryHaskellDepends = [ base ];
           doHaddock = false;
           doCheck = false;
           homepage = "https://github.com/corsis/clock";
           description = "High-resolution clock functions: monotonic, realtime, cputime";
           license = stdenv.lib.licenses.bsd3;
         }) {};
      "clock-extras" = callPackage
        ({ mkDerivation, base, clock, stdenv }:
         mkDerivation {
           pname = "clock-extras";
           version = "0.1.0.2";
           sha256 = "a9ed097aa9d48b53c6a555bc5f67e347249b08e2252dd4fc998fb4ab42edda59";
           libraryHaskellDepends = [ base clock ];
           doHaddock = false;
           doCheck = false;
           description = "A couple functions that probably should be in the 'clock' package";
           license = stdenv.lib.licenses.bsd3;
         }) {};
      "closed" = callPackage
        ({ mkDerivation, aeson, base, cassava, deepseq, hashable
         , persistent, QuickCheck, stdenv, text
         }:
         mkDerivation {
           pname = "closed";
           version = "0.2.0";
           sha256 = "7a301c6c543ae60354b737c56c2259dfc9e01ddf9eee452e4469c6262c53c21c";
           revision = "1";
           editedCabalFile = "0n4g5in0lzy0gs04jj4y0kb3ndychp6nd92pqcsy80bqlllqv2a9";
           libraryHaskellDepends = [
             aeson base cassava deepseq hashable persistent QuickCheck text
           ];
           doHaddock = false;
           doCheck = false;
           homepage = "https://github.com/frontrowed/closed#readme";
           description = "Integers bounded by a closed interval";
           license = stdenv.lib.licenses.mit;
         }) {};
      "clr-host" = callPackage
        ({ mkDerivation, base, bytestring, Cabal, clr-marshal, directory
         , file-embed, filepath, glib, mono, stdenv, text, transformers
         }:
         mkDerivation {
           pname = "clr-host";
           version = "0.2.1.0";
           sha256 = "fe2abf0386c96df6e51cbae4f45e074b54452fc01f9308b098198ade4ffc5ea4";
           setupHaskellDepends = [
             base Cabal directory filepath transformers
           ];
           libraryHaskellDepends = [
             base bytestring clr-marshal file-embed text
           ];
           librarySystemDepends = [ glib mono ];
           doHaddock = false;
           doCheck = false;
           homepage = "https://gitlab.com/tim-m89/clr-haskell/tree/master/libs/clr-host";
           description = "Hosting the Common Language Runtime";
           license = stdenv.lib.licenses.bsd3;
         }) {inherit (pkgs) glib; inherit (pkgs) mono;};
      "clr-marshal" = callPackage
        ({ mkDerivation, base, stdenv, text }:
         mkDerivation {
           pname = "clr-marshal";
           version = "0.2.0.0";
           sha256 = "4113651f3d10de21813b2a44b78ca19f9ab62b6c6d9df0c25a88940fabebdcd6";
           libraryHaskellDepends = [ base text ];
           doHaddock = false;
           doCheck = false;
           homepage = "https://gitlab.com/tim-m89/clr-haskell/tree/master/libs/clr-marshal";
           description = "Marshaling for the clr";
           license = stdenv.lib.licenses.bsd3;
         }) {};
      "clumpiness" = callPackage
        ({ mkDerivation, base, containers, stdenv, tree-fun }:
         mkDerivation {
           pname = "clumpiness";
           version = "0.17.0.0";
           sha256 = "fd4b303d206eaf242c779bb65c42256e42220c8497a6bcf3bc59589b9396c495";
           libraryHaskellDepends = [ base containers tree-fun ];
           doHaddock = false;
           doCheck = false;
           description = "Calculate the clumpiness of leaf properties in a tree";
           license = stdenv.lib.licenses.gpl3;
         }) {};
      "cmark-gfm" = callPackage
        ({ mkDerivation, base, bytestring, stdenv, text }:
         mkDerivation {
           pname = "cmark-gfm";
           version = "0.1.6";
           sha256 = "c8f916c8fbc9b3c564dcd6946cd530a292a055b60c784dde303803199a6c6968";
           libraryHaskellDepends = [ base bytestring text ];
           doHaddock = false;
           doCheck = false;
           homepage = "https://github.com/kivikakk/cmark-gfm-hs";
           description = "Fast, accurate GitHub Flavored Markdown parser and renderer";
           license = stdenv.lib.licenses.bsd3;
         }) {};
      "cmdargs" = callPackage
        ({ mkDerivation, base, filepath, process, stdenv, template-haskell
         , transformers
         }:
         mkDerivation {
           pname = "cmdargs";
           version = "0.10.20";
           sha256 = "0e269dc48c3d4c0447c96ffd772a6fe69dfa1260c323f4cd7bf171cbf2ab7331";
           isLibrary = true;
           isExecutable = true;
           libraryHaskellDepends = [
             base filepath process template-haskell transformers
           ];
           doHaddock = false;
           doCheck = false;
           homepage = "https://github.com/ndmitchell/cmdargs#readme";
           description = "Command line argument processing";
           license = stdenv.lib.licenses.bsd3;
         }) {};
      "code-builder" = callPackage
        ({ mkDerivation, base, containers, stdenv }:
         mkDerivation {
           pname = "code-builder";
           version = "0.1.3";
           sha256 = "559e47a44cec85a8e95df92e5d2693cacc9761503c30be3b83eaebd95360a4ab";
           libraryHaskellDepends = [ base containers ];
           doHaddock = false;
           doCheck = false;
           description = "Simple system for generating code";
           license = stdenv.lib.licenses.bsd3;
         }) {};
      "code-page" = callPackage
        ({ mkDerivation, base, stdenv }:
         mkDerivation {
           pname = "code-page";
           version = "0.1.3";
           sha256 = "e65c86600e06d85f2e2c2a9df4b3d68e2dbd3adb2df9e922a4cd744966762191";
           libraryHaskellDepends = [ base ];
           doHaddock = false;
           doCheck = false;
           homepage = "https://github.com/RyanGlScott/code-page";
           description = "Windows code page library for Haskell";
           license = stdenv.lib.licenses.bsd3;
         }) {};
      "codec" = callPackage
        ({ mkDerivation, aeson, base, binary, binary-bits, bytestring, mtl
         , profunctors, stdenv, template-haskell, text, transformers
         , unordered-containers, vector
         }:
         mkDerivation {
           pname = "codec";
           version = "0.2.1";
           sha256 = "ffc261b58108c3d90c0b0b68461857d1148208d1a9645916e63241aaa3c25b28";
           libraryHaskellDepends = [
             aeson base binary binary-bits bytestring mtl profunctors
             template-haskell text transformers unordered-containers vector
           ];
           doHaddock = false;
           doCheck = false;
           homepage = "https://github.com/chpatrick/codec";
           description = "Simple bidirectional serialization";
           license = stdenv.lib.licenses.bsd3;
         }) {};
      "codec-beam" = callPackage
        ({ mkDerivation, base, bytestring, containers, stdenv, text, zlib
         }:
         mkDerivation {
           pname = "codec-beam";
           version = "0.2.0";
           sha256 = "61eb624e5f347ec9249f976bc8b62ae597777604d82ab0e62acb9901374ae365";
           libraryHaskellDepends = [ base bytestring containers text zlib ];
           doHaddock = false;
           doCheck = false;
           homepage = "https://github.com/hkgumbs/codec-beam#readme";
           description = "Erlang VM byte code assembler";
           license = stdenv.lib.licenses.bsd3;
         }) {};
      "codec-rpm" = callPackage
        ({ mkDerivation, attoparsec, attoparsec-binary, base, bytestring
         , conduit, conduit-extra, cpio-conduit, exceptions, lzma-conduit
         , mtl, parsec, pretty, resourcet, stdenv, text
         }:
         mkDerivation {
           pname = "codec-rpm";
           version = "0.2.2";
           sha256 = "a34b88378dc79b08b56c39515763b6d940166595c24dc45e61cc8d2bb4ed4b97";
           libraryHaskellDepends = [
             attoparsec attoparsec-binary base bytestring conduit conduit-extra
             cpio-conduit exceptions lzma-conduit mtl parsec pretty resourcet
             text
           ];
           doHaddock = false;
           doCheck = false;
           homepage = "https://github.com/weldr/codec-rpm";
           description = "A library for manipulating RPM files";
           license = stdenv.lib.licenses.lgpl21;
         }) {};
      "codo-notation" = callPackage
        ({ mkDerivation, base, comonad, haskell-src-meta, parsec, stdenv
         , template-haskell, uniplate
         }:
         mkDerivation {
           pname = "codo-notation";
           version = "0.5.2";
           sha256 = "78eb57004541ed29eb4c54196b91ac2dd1028a3315f51cd4dc00debfc0938eaf";
           libraryHaskellDepends = [
             base comonad haskell-src-meta parsec template-haskell uniplate
           ];
           doHaddock = false;
           doCheck = false;
           description = "A notation for comonads, analogous to the do-notation for monads";
           license = stdenv.lib.licenses.bsd3;
         }) {};
      "coercible-utils" = callPackage
        ({ mkDerivation, base, stdenv }:
         mkDerivation {
           pname = "coercible-utils";
           version = "0.0.0";
           sha256 = "2a624986cdc010c7fc3e90f8c94f722995af9fe6e88b9d52a94ebaa319b08c98";
           libraryHaskellDepends = [ base ];
           doHaddock = false;
           doCheck = false;
           homepage = "https://github.com/sjakobi/coercible-utils";
           description = "Utility functions for Coercible types";
           license = stdenv.lib.licenses.bsd3;
         }) {};
      "colonnade" = callPackage
        ({ mkDerivation, base, bytestring, contravariant, profunctors
         , stdenv, text, vector
         }:
         mkDerivation {
           pname = "colonnade";
           version = "1.2.0.1";
           sha256 = "32ebd86360c9a363d62a2490b7120de5651a6674a79c4f9d85e13d2cc8cb3e8b";
           libraryHaskellDepends = [
             base bytestring contravariant profunctors text vector
           ];
           doHaddock = false;
           doCheck = false;
           homepage = "https://github.com/andrewthad/colonnade#readme";
           description = "Generic types and functions for columnar encoding and decoding";
           license = stdenv.lib.licenses.bsd3;
         }) {};
      "colorful-monoids" = callPackage
        ({ mkDerivation, base, stdenv }:
         mkDerivation {
           pname = "colorful-monoids";
           version = "0.2.1.2";
           sha256 = "0b42ff47e011f011f73e444d7121b7bc54324077cb2a1011ee01766483706578";
           libraryHaskellDepends = [ base ];
           doHaddock = false;
           doCheck = false;
           homepage = "https://github.com/minad/colorful-monoids#readme";
           description = "Styled console text output using ANSI escape sequences";
           license = stdenv.lib.licenses.mit;
         }) {};
      "colorize-haskell" = callPackage
        ({ mkDerivation, ansi-terminal, base, haskell-lexer, stdenv }:
         mkDerivation {
           pname = "colorize-haskell";
           version = "1.0.1";
           sha256 = "03764374bd1aed5c63e20517441ccaae7c95cb2fa9e416da952f26be8dba9aec";
           isLibrary = true;
           isExecutable = true;
           libraryHaskellDepends = [ ansi-terminal base haskell-lexer ];
           executableHaskellDepends = [ ansi-terminal base haskell-lexer ];
           doHaddock = false;
           doCheck = false;
           homepage = "http://github.com/yav/colorize-haskell";
           description = "Highligt Haskell source";
           license = stdenv.lib.licenses.bsd3;
         }) {};
      "colour" = callPackage
        ({ mkDerivation, base, stdenv }:
         mkDerivation {
           pname = "colour";
           version = "2.3.4";
           sha256 = "0f439f00b322ce3d551f28a4dd1520aa2c91d699de4cdc6d485b9b04be0dc5eb";
           revision = "1";
           editedCabalFile = "1awhbn3pk4zgzpnbbhb10rbxzbb4fz5gywa5h3xl589dclv912ls";
           enableSeparateDataOutput = true;
           libraryHaskellDepends = [ base ];
           doHaddock = false;
           doCheck = false;
           homepage = "http://www.haskell.org/haskellwiki/Colour";
           description = "A model for human colour/color perception";
           license = stdenv.lib.licenses.mit;
         }) {};
      "combinatorial" = callPackage
        ({ mkDerivation, array, base, containers, stdenv, transformers
         , utility-ht
         }:
         mkDerivation {
           pname = "combinatorial";
           version = "0.1.0.1";
           sha256 = "c4d67854fecd353f5e7e6be009ffbd16cd6e9f6f41af16f072ae89778596db70";
           libraryHaskellDepends = [
             array base containers transformers utility-ht
           ];
           doHaddock = false;
           doCheck = false;
           homepage = "http://hub.darcs.net/thielema/combinatorial/";
           description = "Count, enumerate, rank and unrank combinatorial objects";
           license = stdenv.lib.licenses.bsd3;
         }) {};
      "comfort-graph" = callPackage
        ({ mkDerivation, base, containers, QuickCheck, semigroups, stdenv
         , transformers, utility-ht
         }:
         mkDerivation {
           pname = "comfort-graph";
           version = "0.0.3.1";
           sha256 = "c926189971d0b416b4b078a1652de65a12a9fabd013d2373204bbe96fef8b562";
           libraryHaskellDepends = [
             base containers QuickCheck semigroups transformers utility-ht
           ];
           doHaddock = false;
           doCheck = false;
           homepage = "http://hub.darcs.net/thielema/comfort-graph";
           description = "Graph structure with type parameters for nodes and edges";
           license = stdenv.lib.licenses.bsd3;
         }) {};
      "commutative" = callPackage
        ({ mkDerivation, base, random, semigroups, stdenv, vector }:
         mkDerivation {
           pname = "commutative";
           version = "0.0.2";
           sha256 = "ccbc6a445bbc5c26a504a322664b2275e9834fdc17c80a2bdcef0dc517609969";
           libraryHaskellDepends = [ base random semigroups vector ];
           doHaddock = false;
           doCheck = false;
           homepage = "https://github.com/athanclark/commutative#readme";
           description = "Commutative binary operations";
           license = stdenv.lib.licenses.bsd3;
         }) {};
      "comonad" = callPackage
        ({ mkDerivation, base, Cabal, cabal-doctest, containers
         , contravariant, distributive, semigroups, stdenv, tagged
         , transformers, transformers-compat
         }:
         mkDerivation {
           pname = "comonad";
           version = "5.0.4";
           sha256 = "78a89d7f9f0975b40b3294adcb70885649572b687ac5f5dc98e452471838e825";
           setupHaskellDepends = [ base Cabal cabal-doctest ];
           libraryHaskellDepends = [
             base containers contravariant distributive semigroups tagged
             transformers transformers-compat
           ];
           doHaddock = false;
           doCheck = false;
           homepage = "http://github.com/ekmett/comonad/";
           description = "Comonads";
           license = stdenv.lib.licenses.bsd3;
         }) {};
      "compactmap" = callPackage
        ({ mkDerivation, base, stdenv, vector }:
         mkDerivation {
           pname = "compactmap";
           version = "0.1.4.2.1";
           sha256 = "22166e0a2a78bf2b7cff49448ed9fcb145dece4f034de9afc8ce5b692fd0f774";
           libraryHaskellDepends = [ base vector ];
           doHaddock = false;
           doCheck = false;
           description = "A read-only memory-efficient key-value store";
           license = stdenv.lib.licenses.bsd3;
         }) {};
      "compensated" = callPackage
        ({ mkDerivation, base, bifunctors, binary, bytes, Cabal
         , cabal-doctest, cereal, comonad, deepseq, distributive, hashable
         , lens, log-domain, safecopy, semigroupoids, semigroups, stdenv
         , vector
         }:
         mkDerivation {
           pname = "compensated";
           version = "0.7.2";
           sha256 = "c7f9bf47a586720deda33b82ddc633d3507c8bc199eb5555c80931f6c323cae2";
           setupHaskellDepends = [ base Cabal cabal-doctest ];
           libraryHaskellDepends = [
             base bifunctors binary bytes cereal comonad deepseq distributive
             hashable lens log-domain safecopy semigroupoids semigroups vector
           ];
           doHaddock = false;
           doCheck = false;
           homepage = "http://github.com/analytics/compensated/";
           description = "Compensated floating-point arithmetic";
           license = stdenv.lib.licenses.bsd3;
         }) {};
      "compiler-warnings" = callPackage
        ({ mkDerivation, base, binary, parsec, stdenv, text }:
         mkDerivation {
           pname = "compiler-warnings";
           version = "0.1.0";
           sha256 = "8cf4c57e1b4d61b1163969faa6e9f2cb8f22073fa75bf982d9b8a328225f5ce3";
           libraryHaskellDepends = [ base binary parsec text ];
           doHaddock = false;
           doCheck = false;
           homepage = "https://github.com/yi-editor/compiler-warnings#readme";
           description = "Parser for common compiler warning formats";
           license = stdenv.lib.licenses.bsd2;
         }) {};
      "componentm" = callPackage
        ({ mkDerivation, base, containers, deepseq, exceptions, pretty-show
         , prettyprinter, rio, stdenv, teardown
         }:
         mkDerivation {
           pname = "componentm";
           version = "0.0.0.2";
           sha256 = "efe23d927d3ad2aee5052ef379f7a472f60e1b0749195e9b46bbf0d8c756b6a7";
           libraryHaskellDepends = [
             base containers deepseq exceptions pretty-show prettyprinter rio
             teardown
           ];
           doHaddock = false;
           doCheck = false;
           homepage = "https://github.com/roman/Haskell-componentm#readme";
           description = "Monad for allocation and cleanup of application resources";
           license = stdenv.lib.licenses.mit;
         }) {};
      "componentm-devel" = callPackage
        ({ mkDerivation, base, componentm, foreign-store, rio, stdenv
         , teardown
         }:
         mkDerivation {
           pname = "componentm-devel";
           version = "0.0.0.2";
           sha256 = "2dd7303c9b26d748baf1a0893b19072ef2a2817c8c77639e3c844e559cd85b0a";
           libraryHaskellDepends = [
             base componentm foreign-store rio teardown
           ];
           doHaddock = false;
           doCheck = false;
           homepage = "https://github.com/roman/Haskell-componentm#readme";
           description = "Easy REPL driven development using ComponentM";
           license = stdenv.lib.licenses.mit;
         }) {};
      "composable-associations" = callPackage
        ({ mkDerivation, base, stdenv }:
         mkDerivation {
           pname = "composable-associations";
           version = "0.1.0.0";
           sha256 = "9d1a10bc7ee1b514221bd8d0fc71f43f8d2338b1faebe6722f1d4db3bc29800e";
           libraryHaskellDepends = [ base ];
           doHaddock = false;
           doCheck = false;
           homepage = "https://github.com/SamProtas/composable-associations#readme";
           description = "Types and helpers for composing types into a single larger key-value type";
           license = stdenv.lib.licenses.bsd3;
         }) {};
      "composable-associations-aeson" = callPackage
        ({ mkDerivation, aeson, base, composable-associations, stdenv, text
         , unordered-containers
         }:
         mkDerivation {
           pname = "composable-associations-aeson";
           version = "0.1.0.0";
           sha256 = "dbd754ed6d624469f16c4cd2ad51c441eeb8c62d6af66673f76034c7517c2a4f";
           libraryHaskellDepends = [
             aeson base composable-associations text unordered-containers
           ];
           doHaddock = false;
           doCheck = false;
           homepage = "https://github.com/SamProtas/composable-associations#readme";
           description = "Aeson ToJSON/FromJSON implementation for the types of composable-associations";
           license = stdenv.lib.licenses.bsd3;
         }) {};
      "composition" = callPackage
        ({ mkDerivation, stdenv }:
         mkDerivation {
           pname = "composition";
           version = "1.0.2.1";
           sha256 = "7123300f5eca5a7cec4eb731dc0e9c2c44aabe26b37e6579582a7267d9f7ad6a";
           doHaddock = false;
           doCheck = false;
           description = "Combinators for unorthodox function composition";
           license = stdenv.lib.licenses.bsd3;
         }) {};
      "composition-extra" = callPackage
        ({ mkDerivation, base, composition, contravariant, stdenv }:
         mkDerivation {
           pname = "composition-extra";
           version = "2.0.0";
           sha256 = "c998244a8fd160af3dd7ee93c417f665af51a46a04ce6b7d4623f46596ba7129";
           libraryHaskellDepends = [ base composition contravariant ];
           doHaddock = false;
           doCheck = false;
           description = "Combinators for unorthodox structure composition";
           license = stdenv.lib.licenses.bsd3;
         }) {};
      "composition-prelude" = callPackage
        ({ mkDerivation, base, stdenv }:
         mkDerivation {
           pname = "composition-prelude";
           version = "1.5.3.1";
           sha256 = "ed4c5090b8281b3a69ed50c49cc2558cb9953be19f22b3eb56c2e391bbfd0437";
           libraryHaskellDepends = [ base ];
           doHaddock = false;
           doCheck = false;
           description = "Higher-order function combinators";
           license = stdenv.lib.licenses.bsd3;
         }) {};
      "compressed" = callPackage
        ({ mkDerivation, base, comonad, containers, fingertree, hashable
         , keys, pointed, reducers, semigroupoids, semigroups, stdenv
         , unordered-containers
         }:
         mkDerivation {
           pname = "compressed";
           version = "3.11";
           sha256 = "d77bbf2f445d32f138dfde9e860e68db5de8ae04c52ffda23941ddf7bdabdd3d";
           revision = "1";
           editedCabalFile = "0h3kfr2kdn74vk0mam5mwk6phclrcm79khd8yz2pp8j9zv1v8q3r";
           libraryHaskellDepends = [
             base comonad containers fingertree hashable keys pointed reducers
             semigroupoids semigroups unordered-containers
           ];
           doHaddock = false;
           doCheck = false;
           homepage = "http://github.com/ekmett/compressed/";
           description = "Compressed containers and reducers";
           license = stdenv.lib.licenses.bsd3;
         }) {};
      "concise" = callPackage
        ({ mkDerivation, base, bytestring, lens, stdenv, text }:
         mkDerivation {
           pname = "concise";
           version = "0.1.0.1";
           sha256 = "5c27df5a3e1fe820548e90abc4a0e326b6d0fb286218619aa22d3af90c7b9925";
           libraryHaskellDepends = [ base bytestring lens text ];
           doHaddock = false;
           doCheck = false;
           homepage = "https://github.com/frasertweedale/hs-concise";
           description = "Utilities for Control.Lens.Cons";
           license = stdenv.lib.licenses.bsd3;
         }) {};
      "concurrency" = callPackage
        ({ mkDerivation, array, atomic-primops, base, exceptions
         , monad-control, mtl, stdenv, stm, transformers
         }:
         mkDerivation {
           pname = "concurrency";
           version = "1.6.2.0";
           sha256 = "c8e43e6d19f075e7a66a7191350eba0d177b5339ba6db6d3bcfde2d73a0f9000";
           libraryHaskellDepends = [
             array atomic-primops base exceptions monad-control mtl stm
             transformers
           ];
           doHaddock = false;
           doCheck = false;
           homepage = "https://github.com/barrucadu/dejafu";
           description = "Typeclasses, functions, and data types for concurrency and STM";
           license = stdenv.lib.licenses.mit;
         }) {};
      "concurrent-extra" = callPackage
        ({ mkDerivation, base, stdenv, stm, unbounded-delays }:
         mkDerivation {
           pname = "concurrent-extra";
           version = "0.7.0.12";
           sha256 = "040e6db9e0147de9929661759930f1566a7250add4c7f65b04dc6e070c991df9";
           libraryHaskellDepends = [ base stm unbounded-delays ];
           doHaddock = false;
           doCheck = false;
           homepage = "https://github.com/basvandijk/concurrent-extra";
           description = "Extra concurrency primitives";
           license = stdenv.lib.licenses.bsd3;
         }) {};
      "concurrent-output" = callPackage
        ({ mkDerivation, ansi-terminal, async, base, directory, exceptions
         , process, stdenv, stm, terminal-size, text, transformers, unix
         }:
         mkDerivation {
           pname = "concurrent-output";
           version = "1.10.9";
           sha256 = "8cc49408e957c65359182fbfcda80717b931915d101e4be55ccb26c44b098e57";
           libraryHaskellDepends = [
             ansi-terminal async base directory exceptions process stm
             terminal-size text transformers unix
           ];
           doHaddock = false;
           doCheck = false;
           description = "Ungarble output from several threads or commands";
           license = stdenv.lib.licenses.bsd2;
         }) {};
      "concurrent-split" = callPackage
        ({ mkDerivation, base, stdenv }:
         mkDerivation {
           pname = "concurrent-split";
           version = "0.0.1.1";
           sha256 = "ae0028cfaf27da2c4d0e70783e8f45e82d33f402af1dfc6778c8ab81cf542f45";
           libraryHaskellDepends = [ base ];
           doHaddock = false;
           doCheck = false;
           description = "MVars and Channels with distinguished input and output side";
           license = stdenv.lib.licenses.bsd3;
         }) {};
      "concurrent-supply" = callPackage
        ({ mkDerivation, base, ghc-prim, hashable, stdenv }:
         mkDerivation {
           pname = "concurrent-supply";
           version = "0.1.8";
           sha256 = "ccf827dcd221298ae93fad6021c63a06707456de0671706b44f1f2fed867f21f";
           libraryHaskellDepends = [ base ghc-prim hashable ];
           doHaddock = false;
           doCheck = false;
           homepage = "http://github.com/ekmett/concurrent-supply/";
           description = "A fast concurrent unique identifier supply with a pure API";
           license = stdenv.lib.licenses.bsd3;
         }) {};
      "cond" = callPackage
        ({ mkDerivation, base, stdenv }:
         mkDerivation {
           pname = "cond";
           version = "0.4.1.1";
           sha256 = "039c76e43b5484bdc78627f50740106ae2844b3c877d92b5228de9106997ac8b";
           libraryHaskellDepends = [ base ];
           doHaddock = false;
           doCheck = false;
           homepage = "https://github.com/kallisti-dev/cond";
           description = "Basic conditional and boolean operators with monadic variants";
           license = stdenv.lib.licenses.bsd3;
         }) {};
      "conduit" = callPackage
        ({ mkDerivation, base, bytestring, directory, exceptions, filepath
         , mono-traversable, mtl, primitive, resourcet, stdenv, text
         , transformers, unix, unliftio-core, vector
         }:
         mkDerivation {
           pname = "conduit";
           version = "1.3.1";
           sha256 = "ae129b66ada785c43a693d3b260f0e7b2f01d79fbf04ae43f7341405455320d6";
           libraryHaskellDepends = [
             base bytestring directory exceptions filepath mono-traversable mtl
             primitive resourcet text transformers unix unliftio-core vector
           ];
           doHaddock = false;
           doCheck = false;
           homepage = "http://github.com/snoyberg/conduit";
           description = "Streaming data processing library";
           license = stdenv.lib.licenses.mit;
         }) {};
      "conduit-algorithms" = callPackage
        ({ mkDerivation, async, base, bytestring, bzlib-conduit, conduit
         , conduit-combinators, conduit-extra, containers, deepseq
         , exceptions, lzma-conduit, monad-control, mtl, pqueue, resourcet
         , stdenv, stm, stm-conduit, streaming-commons, transformers
         , unliftio-core, vector
         }:
         mkDerivation {
           pname = "conduit-algorithms";
           version = "0.0.8.2";
           sha256 = "a897faa37209780088ed3203aadb0195169d7c24f1eae39bd2ad2f0f851d82e8";
           libraryHaskellDepends = [
             async base bytestring bzlib-conduit conduit conduit-combinators
             conduit-extra containers deepseq exceptions lzma-conduit
             monad-control mtl pqueue resourcet stm stm-conduit
             streaming-commons transformers unliftio-core vector
           ];
           doHaddock = false;
           doCheck = false;
           homepage = "https://github.com/luispedro/conduit-algorithms#readme";
           description = "Conduit-based algorithms";
           license = stdenv.lib.licenses.mit;
         }) {};
      "conduit-combinators" = callPackage
        ({ mkDerivation, base, stdenv }:
         mkDerivation {
           pname = "conduit-combinators";
           version = "1.3.0";
           sha256 = "9717d916a0422a7fb7cc262302333269607530d40cd0bea3be947872f906e7d3";
           libraryHaskellDepends = [ base ];
           doHaddock = false;
           doCheck = false;
           homepage = "https://github.com/snoyberg/mono-traversable#readme";
           description = "DEPRECATED Functionality merged into the conduit package itself";
           license = stdenv.lib.licenses.mit;
         }) {};
      "conduit-connection" = callPackage
        ({ mkDerivation, base, bytestring, conduit, connection, resourcet
         , stdenv, transformers
         }:
         mkDerivation {
           pname = "conduit-connection";
           version = "0.1.0.4";
           sha256 = "5e784117f3698dc653b286fbb53d530068d0cdadbe130ec02abf42e3f2c821fc";
           libraryHaskellDepends = [
             base bytestring conduit connection resourcet transformers
           ];
           doHaddock = false;
           doCheck = false;
           homepage = "https://github.com/sdroege/conduit-connection";
           description = "Conduit source and sink for Network.Connection.";
           license = stdenv.lib.licenses.bsd3;
         }) {};
      "conduit-extra" = callPackage
        ({ mkDerivation, async, attoparsec, base, bytestring, conduit
         , directory, filepath, network, primitive, process, resourcet
         , stdenv, stm, streaming-commons, text, transformers, typed-process
         , unliftio-core
         }:
         mkDerivation {
           pname = "conduit-extra";
           version = "1.3.0";
           sha256 = "2c41c925fc53d9ba2e640c7cdca72c492b28c0d45f1a82e94baef8dfa65922ae";
           libraryHaskellDepends = [
             async attoparsec base bytestring conduit directory filepath network
             primitive process resourcet stm streaming-commons text transformers
             typed-process unliftio-core
           ];
           doHaddock = false;
           doCheck = false;
           homepage = "http://github.com/snoyberg/conduit";
           description = "Batteries included conduit: adapters for common libraries";
           license = stdenv.lib.licenses.mit;
         }) {};
      "conduit-iconv" = callPackage
        ({ mkDerivation, base, bytestring, conduit, stdenv }:
         mkDerivation {
           pname = "conduit-iconv";
           version = "0.1.1.3";
           sha256 = "1c71304782e4599a2987321028b50356c4982b45d9096d954e0b7c0b7ad3acb6";
           libraryHaskellDepends = [ base bytestring conduit ];
           doHaddock = false;
           doCheck = false;
           homepage = "https://github.com/sdroege/conduit-iconv";
           description = "Conduit for character encoding conversion";
           license = stdenv.lib.licenses.bsd3;
         }) {};
      "conduit-parse" = callPackage
        ({ mkDerivation, base, conduit, dlist, mtl, parsers, safe
         , safe-exceptions, stdenv, text, transformers
         }:
         mkDerivation {
           pname = "conduit-parse";
           version = "0.2.1.0";
           sha256 = "b585dbdc0c1e3a844a9cd97cd1e72d7a73521b66b856001960afe4057130dae1";
           revision = "1";
           editedCabalFile = "1bgxjn9lbx67584xpwl2k9jrwvlgyqf4vkv0s7vs1nnc1h6qk7qw";
           libraryHaskellDepends = [
             base conduit dlist mtl parsers safe safe-exceptions text
             transformers
           ];
           doHaddock = false;
           doCheck = false;
           homepage = "https://github.com/k0ral/conduit-parse";
           description = "Parsing framework based on conduit";
           license = stdenv.lib.licenses.publicDomain;
         }) {};
      "conduit-throttle" = callPackage
        ({ mkDerivation, async, base, conduit, conduit-combinators
         , conduit-extra, monad-control, resourcet, stdenv, stm, stm-chans
         , throttle-io-stream, unliftio, unliftio-core
         }:
         mkDerivation {
           pname = "conduit-throttle";
           version = "0.3.1.0";
           sha256 = "8dd6d616f5ddce25668bb34069bfdcdfe2a866c8d708b725a9b2e450a95aa329";
           libraryHaskellDepends = [
             async base conduit conduit-combinators conduit-extra monad-control
             resourcet stm stm-chans throttle-io-stream unliftio unliftio-core
           ];
           doHaddock = false;
           doCheck = false;
           homepage = "https://github.com/mtesseract/conduit-throttle#readme";
           description = "Throttle Conduit Producers";
           license = stdenv.lib.licenses.bsd3;
         }) {};
      "config-ini" = callPackage
        ({ mkDerivation, base, containers, megaparsec, stdenv, text
         , transformers, unordered-containers
         }:
         mkDerivation {
           pname = "config-ini";
           version = "0.2.2.0";
           sha256 = "364d67b876abf867d97eaacac630e920521ff96478fe9869a41983893ce140a0";
           libraryHaskellDepends = [
             base containers megaparsec text transformers unordered-containers
           ];
           doHaddock = false;
           doCheck = false;
           homepage = "https://github.com/aisamanra/config-ini";
           description = "A library for simple INI-based configuration files";
           license = stdenv.lib.licenses.bsd3;
         }) {};
      "configuration-tools" = callPackage
        ({ mkDerivation, aeson, ansi-wl-pprint, attoparsec, base
         , base-unicode-symbols, base64-bytestring, bytestring, Cabal
         , case-insensitive, connection, data-default, deepseq, directory
         , dlist, enclosed-exceptions, filepath, http-client
         , http-client-tls, http-types, monad-control, mtl, network-uri
         , optparse-applicative, process, profunctors, semigroups, stdenv
         , text, tls, transformers, unordered-containers, x509, x509-system
         , x509-validation, yaml
         }:
         mkDerivation {
           pname = "configuration-tools";
           version = "0.3.1";
           sha256 = "e0df7e71b084c1bd831cd9887584f06e016e359291dc4f71b72d2027f7f86e47";
           libraryHaskellDepends = [
             aeson ansi-wl-pprint attoparsec base base-unicode-symbols
             base64-bytestring bytestring Cabal case-insensitive connection
             data-default deepseq directory dlist enclosed-exceptions filepath
             http-client http-client-tls http-types monad-control mtl
             network-uri optparse-applicative process profunctors semigroups
             text tls transformers unordered-containers x509 x509-system
             x509-validation yaml
           ];
           doHaddock = false;
           doCheck = false;
           homepage = "https://github.com/alephcloud/hs-configuration-tools";
           description = "Tools for specifying and parsing configurations";
           license = stdenv.lib.licenses.mit;
         }) {};
      "configurator" = callPackage
        ({ mkDerivation, attoparsec, base, bytestring, directory, hashable
         , stdenv, text, unix-compat, unordered-containers
         }:
         mkDerivation {
           pname = "configurator";
           version = "0.3.0.0";
           sha256 = "6eb9996b672e9f7112ca23482c42fa533553312c3c13f38a8a06476e67c031b4";
           enableSeparateDataOutput = true;
           libraryHaskellDepends = [
             attoparsec base bytestring directory hashable text unix-compat
             unordered-containers
           ];
           doHaddock = false;
           doCheck = false;
           homepage = "http://github.com/bos/configurator";
           description = "Configuration management";
           license = stdenv.lib.licenses.bsd3;
         }) {};
      "configurator-export" = callPackage
        ({ mkDerivation, base, base-compat, configurator, pretty
         , semigroups, stdenv, text, unordered-containers
         }:
         mkDerivation {
           pname = "configurator-export";
           version = "0.1.0.1";
           sha256 = "9dbd62ef29c97792ccdfdb1b3b79aedfa527dce49a9ac5054f21b29a7f9b824c";
           libraryHaskellDepends = [
             base base-compat configurator pretty semigroups text
             unordered-containers
           ];
           doHaddock = false;
           doCheck = false;
           homepage = "http://github.com/mstksg/configurator-export";
           description = "Pretty printer and exporter for configurations from the \"configurator\" library";
           license = stdenv.lib.licenses.bsd3;
         }) {};
      "connection" = callPackage
        ({ mkDerivation, base, byteable, bytestring, containers
         , data-default-class, network, socks, stdenv, tls, x509, x509-store
         , x509-system, x509-validation
         }:
         mkDerivation {
           pname = "connection";
           version = "0.2.8";
           sha256 = "70b1f44e8786320c18b26fc5d4ec115fc8ac016ba1f852fa8137f55d785a93eb";
           revision = "2";
           editedCabalFile = "0bhwcd9dqa2jk23bdz3z3vn2p1gzssinp96dxzznb7af4y5x2gmk";
           libraryHaskellDepends = [
             base byteable bytestring containers data-default-class network
             socks tls x509 x509-store x509-system x509-validation
           ];
           doHaddock = false;
           doCheck = false;
           homepage = "http://github.com/vincenthz/hs-connection";
           description = "Simple and easy network connections API";
           license = stdenv.lib.licenses.bsd3;
         }) {};
      "connection-pool" = callPackage
        ({ mkDerivation, base, between, data-default-class, monad-control
         , network, resource-pool, stdenv, streaming-commons, time
         , transformers-base
         }:
         mkDerivation {
           pname = "connection-pool";
           version = "0.2.2";
           sha256 = "f2cf43b7698b719b05467b3625884d00c748de2b3eb1229d19490b029a667353";
           libraryHaskellDepends = [
             base between data-default-class monad-control network resource-pool
             streaming-commons time transformers-base
           ];
           doHaddock = false;
           doCheck = false;
           homepage = "https://github.com/trskop/connection-pool";
           description = "Connection pool built on top of resource-pool and streaming-commons";
           license = stdenv.lib.licenses.bsd3;
         }) {};
      "console-style" = callPackage
        ({ mkDerivation, base, mtl, stdenv, transformers }:
         mkDerivation {
           pname = "console-style";
           version = "0.0.2.1";
           sha256 = "6d818ea841d7acfe6c42cc3fc7751e324656abfd0509ce470bc8bdbf52d1bd7f";
           libraryHaskellDepends = [ base mtl transformers ];
           doHaddock = false;
           doCheck = false;
           homepage = "https://github.com/minad/console-style#readme";
           description = "Styled console text output using ANSI escape sequences";
           license = stdenv.lib.licenses.mit;
         }) {};
      "constraint" = callPackage
        ({ mkDerivation, base, category, stdenv }:
         mkDerivation {
           pname = "constraint";
           version = "0.1.1.1";
           sha256 = "22800d629e3255c7e37d9265ac70b9a4ec4bee2d5f4cc19948e8d28b911ddf47";
           libraryHaskellDepends = [ base category ];
           doHaddock = false;
           doCheck = false;
           description = "Reified constraints";
           license = stdenv.lib.licenses.bsd3;
         }) {};
      "constraints" = callPackage
        ({ mkDerivation, base, binary, deepseq, ghc-prim, hashable, mtl
         , semigroups, stdenv, transformers, transformers-compat
         }:
         mkDerivation {
           pname = "constraints";
           version = "0.10.1";
           sha256 = "5880ec261e053841b307c7c8c59614f46c2efbd5189f0f2a3c817589cedec3f7";
           revision = "1";
           editedCabalFile = "1i2rd805mjz5q7s98ryy1m91zd4b9hx92gw1rwr6kpibqqw9smcb";
           libraryHaskellDepends = [
             base binary deepseq ghc-prim hashable mtl semigroups transformers
             transformers-compat
           ];
           doHaddock = false;
           doCheck = false;
           homepage = "http://github.com/ekmett/constraints/";
           description = "Constraint manipulation";
           license = stdenv.lib.licenses.bsd2;
         }) {};
      "consul-haskell" = callPackage
        ({ mkDerivation, aeson, base, base64-bytestring, bytestring
         , connection, either, exceptions, http-client, http-client-tls
         , http-types, lifted-async, lifted-base, monad-control, network
         , retry, stdenv, stm, text, transformers, unordered-containers
         , vector
         }:
         mkDerivation {
           pname = "consul-haskell";
           version = "0.4.2";
           sha256 = "b10812b70dfbce7037f9f23eda71fa2fa6fc97ed309bd63c00f226522d30d80a";
           libraryHaskellDepends = [
             aeson base base64-bytestring bytestring connection either
             exceptions http-client http-client-tls http-types lifted-async
             lifted-base monad-control network retry stm text transformers
             unordered-containers vector
           ];
           doHaddock = false;
           doCheck = false;
           homepage = "https://github.com/alphaHeavy/consul-haskell";
           description = "A consul client for Haskell";
           license = stdenv.lib.licenses.bsd3;
         }) {};
      "containers-unicode-symbols" = callPackage
        ({ mkDerivation, base, base-unicode-symbols, containers, stdenv }:
         mkDerivation {
           pname = "containers-unicode-symbols";
           version = "0.3.1.1";
           sha256 = "4655f286a2d116cb5f2b89f472df54df739bf904ac8e932b2fd34d3f713e9b31";
           libraryHaskellDepends = [ base base-unicode-symbols containers ];
           doHaddock = false;
           doCheck = false;
           homepage = "http://haskell.org/haskellwiki/Unicode-symbols";
           description = "Unicode alternatives for common functions and operators";
           license = stdenv.lib.licenses.bsd3;
         }) {};
      "contravariant" = callPackage
        ({ mkDerivation, base, StateVar, stdenv, transformers
         , transformers-compat
         }:
         mkDerivation {
           pname = "contravariant";
           version = "1.4.1";
           sha256 = "c93d3d619fa378f3fdf92c53bb8b04b8f47963b88aba7cfa54b57656189ad0ed";
           revision = "1";
           editedCabalFile = "0qj5nymccrb9p0cd6hffsy90jidjng14g9yv95z8v6h4q84sbzvx";
           libraryHaskellDepends = [
             base StateVar transformers transformers-compat
           ];
           doHaddock = false;
           doCheck = false;
           homepage = "http://github.com/ekmett/contravariant/";
           description = "Contravariant functors";
           license = stdenv.lib.licenses.bsd3;
         }) {};
      "contravariant-extras" = callPackage
        ({ mkDerivation, base, base-prelude, contravariant, semigroups
         , stdenv, template-haskell, tuple-th
         }:
         mkDerivation {
           pname = "contravariant-extras";
           version = "0.3.4";
           sha256 = "36a9239d5a84bc6a418a3aa1a0df145d76ece24d00b76deb817b92441913e63d";
           revision = "1";
           editedCabalFile = "1h2955ahga6i4fn7k8v66l03v77p6fhsac6ck8gpabkc08ij60wp";
           libraryHaskellDepends = [
             base base-prelude contravariant semigroups template-haskell
             tuple-th
           ];
           doHaddock = false;
           doCheck = false;
           homepage = "https://github.com/nikita-volkov/contravariant-extras";
           description = "Extras for the \"contravariant\" package";
           license = stdenv.lib.licenses.mit;
         }) {};
      "control-bool" = callPackage
        ({ mkDerivation, base, stdenv }:
         mkDerivation {
           pname = "control-bool";
           version = "0.2.1";
           sha256 = "e46a85d2985a65f8d7ecbcdab0cfb12734b4d6e4c558631e6ab01fe742ed5581";
           libraryHaskellDepends = [ base ];
           doHaddock = false;
           doCheck = false;
           homepage = "https://github.com/fumieval/control-bool";
           description = "Useful combinators for boolean expressions";
           license = stdenv.lib.licenses.bsd3;
         }) {};
      "control-dsl" = callPackage
        ({ mkDerivation, base, stdenv }:
         mkDerivation {
           pname = "control-dsl";
           version = "0.2.1.3";
           sha256 = "e8c795e256030194ef9beb8009ed49f1257790ad1b51d3f629c98f6ce5e56967";
           revision = "2";
           editedCabalFile = "18jypzsawq0mp12i35f58px80i3k07ri0g07wcrh6af93vqkhvil";
           libraryHaskellDepends = [ base ];
           doHaddock = false;
           doCheck = false;
           homepage = "https://github.com/Atry/Control.Dsl#readme";
           description = "An alternative to monads in do-notation";
           license = stdenv.lib.licenses.bsd3;
         }) {};
      "control-monad-free" = callPackage
        ({ mkDerivation, base, stdenv, transformers }:
         mkDerivation {
           pname = "control-monad-free";
           version = "0.6.2";
           sha256 = "63c830bd2af23e372ebfee628d9f538a32d8368cf74f897370d839bf8e7b4bc1";
           libraryHaskellDepends = [ base transformers ];
           doHaddock = false;
           doCheck = false;
           homepage = "http://github.com/pepeiborra/control-monad-free";
           description = "Free monads and monad transformers";
           license = stdenv.lib.licenses.publicDomain;
         }) {};
      "control-monad-omega" = callPackage
        ({ mkDerivation, base, stdenv }:
         mkDerivation {
           pname = "control-monad-omega";
           version = "0.3.1";
           sha256 = "383b98ecf5db5add42f318672af9eb1c8b9d99ec42d48c240e209a93b5cf1186";
           revision = "1";
           editedCabalFile = "029v5j0mnlzzn6my7jgw26gdm5fbs2h7y395zk1q7r5bfar00q58";
           libraryHaskellDepends = [ base ];
           doHaddock = false;
           doCheck = false;
           homepage = "http://github.com/luqui/control-monad-omega";
           description = "A breadth-first list monad";
           license = stdenv.lib.licenses.publicDomain;
         }) {};
      "convertible" = callPackage
        ({ mkDerivation, base, bytestring, containers, mtl, old-locale
         , old-time, stdenv, text, time
         }:
         mkDerivation {
           pname = "convertible";
           version = "1.1.1.0";
           sha256 = "e9f9a70904b9995314c2aeb41580d654a2c76293feb955fb6bd63256c355286c";
           isLibrary = true;
           isExecutable = true;
           libraryHaskellDepends = [
             base bytestring containers mtl old-locale old-time text time
           ];
           doHaddock = false;
           doCheck = false;
           homepage = "http://hackage.haskell.org/package/convertible";
           description = "Typeclasses and instances for converting between types";
           license = stdenv.lib.licenses.bsd3;
         }) {};
      "cookie" = callPackage
        ({ mkDerivation, base, bytestring, data-default-class, deepseq
         , stdenv, text, time
         }:
         mkDerivation {
           pname = "cookie";
           version = "0.4.4";
           sha256 = "3245ed04ae933cf7becede816d1f76043b851472700abf558ae90b28414cc0e3";
           libraryHaskellDepends = [
             base bytestring data-default-class deepseq text time
           ];
           doHaddock = false;
           doCheck = false;
           homepage = "http://github.com/snoyberg/cookie";
           description = "HTTP cookie parsing and rendering";
           license = stdenv.lib.licenses.mit;
         }) {};
      "countable" = callPackage
        ({ mkDerivation, base, stdenv }:
         mkDerivation {
           pname = "countable";
           version = "1.0";
           sha256 = "f9a0eb6f697a044bdf72e9c08126d4cb0f2d6de82cce07e55cb87ddbae6a0e6c";
           libraryHaskellDepends = [ base ];
           doHaddock = false;
           doCheck = false;
           homepage = "https://github.com/AshleyYakeley/countable";
           description = "Countable, Searchable, Finite, Empty classes";
           license = stdenv.lib.licenses.bsd3;
         }) {};
      "country" = callPackage
        ({ mkDerivation, aeson, attoparsec, base, bytestring, deepseq
         , ghc-prim, hashable, primitive, scientific, stdenv, text
         , unordered-containers
         }:
         mkDerivation {
           pname = "country";
           version = "0.1.6";
           sha256 = "09b36e30dfb1fa5fa7a2c5c38f316a70e0c740b8a4dd6e340abe9770ad149928";
           revision = "2";
           editedCabalFile = "0721d9nc2snr6046ybmdj80xas7627lwd1ym6h1n8lclihw7ll6d";
           libraryHaskellDepends = [
             aeson attoparsec base bytestring deepseq ghc-prim hashable
             primitive scientific text unordered-containers
           ];
           doHaddock = false;
           doCheck = false;
           homepage = "https://github.com/andrewthad/country#readme";
           description = "Country data type and functions";
           license = stdenv.lib.licenses.bsd3;
         }) {};
      "courier" = callPackage
        ({ mkDerivation, async, base, bytestring, cereal, containers
         , hslogger, network, stdenv, stm, text, uuid
         }:
         mkDerivation {
           pname = "courier";
           version = "0.1.1.5";
           sha256 = "ac9e674ff33de347b173da2892859b3807a408b341d10d6101d2a7d07ac334d3";
           isLibrary = true;
           isExecutable = true;
           libraryHaskellDepends = [
             async base bytestring cereal containers hslogger network stm text
             uuid
           ];
           executableHaskellDepends = [ base cereal ];
           doHaddock = false;
           doCheck = false;
           homepage = "http://github.com/hargettp/courier";
           description = "A message-passing library for simplifying network applications";
           license = stdenv.lib.licenses.mit;
         }) {};
      "cpio-conduit" = callPackage
        ({ mkDerivation, base, base16-bytestring, binary, bytestring
         , conduit, conduit-extra, stdenv
         }:
         mkDerivation {
           pname = "cpio-conduit";
           version = "0.7.0";
           sha256 = "8f0be7538b234496ef3b2fb2633336908ae99040ecb6d9832b3dbd1d0750f513";
           libraryHaskellDepends = [
             base base16-bytestring binary bytestring conduit conduit-extra
           ];
           doHaddock = false;
           doCheck = false;
           homepage = "http://github.com/da-x/cpio-conduit";
           description = "Conduit-based CPIO";
           license = stdenv.lib.licenses.asl20;
         }) {};
      "cpphs" = callPackage
        ({ mkDerivation, base, directory, old-locale, old-time, polyparse
         , stdenv
         }:
         mkDerivation {
           pname = "cpphs";
           version = "1.20.8";
           sha256 = "e56d64a7d8058e0fb63f0669397c1c861efb20a0376e0e74d86942ac151105ae";
           isLibrary = true;
           isExecutable = true;
           libraryHaskellDepends = [
             base directory old-locale old-time polyparse
           ];
           executableHaskellDepends = [
             base directory old-locale old-time polyparse
           ];
           doHaddock = false;
           doCheck = false;
           homepage = "http://projects.haskell.org/cpphs/";
           description = "A liberalised re-implementation of cpp, the C pre-processor";
           license = "LGPL";
         }) {};
      "cprng-aes" = callPackage
        ({ mkDerivation, base, byteable, bytestring, cipher-aes
         , crypto-random, stdenv
         }:
         mkDerivation {
           pname = "cprng-aes";
           version = "0.6.1";
           sha256 = "64592a01de8c6683c5e29f538dceee918887ffe211d87214a2e38559d72c21f3";
           enableSeparateDataOutput = true;
           libraryHaskellDepends = [
             base byteable bytestring cipher-aes crypto-random
           ];
           doHaddock = false;
           doCheck = false;
           homepage = "http://github.com/vincenthz/hs-cprng-aes";
           description = "Crypto Pseudo Random Number Generator using AES in counter mode";
           license = stdenv.lib.licenses.bsd3;
         }) {};
      "cpu" = callPackage
        ({ mkDerivation, base, stdenv }:
         mkDerivation {
           pname = "cpu";
           version = "0.1.2";
           sha256 = "5627feb4974a3ff8499c42cc958927e88761a2e004c4000d34e9cd6a15ad2974";
           isLibrary = true;
           isExecutable = true;
           enableSeparateDataOutput = true;
           libraryHaskellDepends = [ base ];
           doHaddock = false;
           doCheck = false;
           homepage = "http://github.com/vincenthz/hs-cpu";
           description = "Cpu information and properties helpers";
           license = stdenv.lib.licenses.bsd3;
         }) {};
      "cpuinfo" = callPackage
        ({ mkDerivation, attoparsec, base, bytestring, deepseq, stdenv }:
         mkDerivation {
           pname = "cpuinfo";
           version = "0.1.0.1";
           sha256 = "d1b3e3992cc0c82edfb21f30e1684bb66e6a3cb23a26b777a079702362d05655";
           libraryHaskellDepends = [ attoparsec base bytestring deepseq ];
           doHaddock = false;
           doCheck = false;
           homepage = "https://github.com/TravisWhitaker/cpuinfo";
           description = "Haskell Library for Checking CPU Information";
           license = stdenv.lib.licenses.mit;
         }) {};
      "cql" = callPackage
        ({ mkDerivation, base, bytestring, cereal, containers, Decimal
         , iproute, network, stdenv, template-haskell, text, time
         , transformers, uuid, vector
         }:
         mkDerivation {
           pname = "cql";
           version = "4.0.1";
           sha256 = "89294c6a6ed2c6f8c6037ee2ca4236d3606bf9019a39df9e39b7ad8dcd573808";
           libraryHaskellDepends = [
             base bytestring cereal containers Decimal iproute network
             template-haskell text time transformers uuid vector
           ];
           doHaddock = false;
           doCheck = false;
           homepage = "https://gitlab.com/twittner/cql/";
           description = "Cassandra CQL binary protocol";
           license = "unknown";
           hydraPlatforms = stdenv.lib.platforms.none;
         }) {};
      "cql-io" = callPackage
        ({ mkDerivation, async, auto-update, base, bytestring, containers
         , cql, cryptohash, data-default-class, exceptions, hashable
         , HsOpenSSL, iproute, lens, monad-control, mtl, mwc-random, network
         , retry, semigroups, stdenv, stm, text, time, tinylog, transformers
         , transformers-base, unordered-containers, uuid, vector
         }:
         mkDerivation {
           pname = "cql-io";
           version = "1.0.1.1";
           sha256 = "ac1353fc3ae4b182877aa518282ea1bd839cf5a3ffb936d6da4807b11d00bbcd";
           libraryHaskellDepends = [
             async auto-update base bytestring containers cql cryptohash
             data-default-class exceptions hashable HsOpenSSL iproute lens
             monad-control mtl mwc-random network retry semigroups stm text time
             tinylog transformers transformers-base unordered-containers uuid
             vector
           ];
           doHaddock = false;
           doCheck = false;
           homepage = "https://gitlab.com/twittner/cql-io/";
           description = "Cassandra CQL client";
           license = stdenv.lib.licenses.mpl20;
         }) {};
      "crackNum" = callPackage
        ({ mkDerivation, array, base, FloatingHex, stdenv }:
         mkDerivation {
           pname = "crackNum";
           version = "2.3";
           sha256 = "428f25cfa0f7c4c126ee96fb9122966c2b175a194d59c200470a6f689ec038f3";
           isLibrary = true;
           isExecutable = true;
           libraryHaskellDepends = [ array base FloatingHex ];
           executableHaskellDepends = [ array base FloatingHex ];
           doHaddock = false;
           doCheck = false;
           homepage = "http://github.com/LeventErkok/CrackNum";
           description = "Crack various integer, floating-point data formats";
           license = stdenv.lib.licenses.bsd3;
         }) {};
      "credential-store" = callPackage
        ({ mkDerivation, base, bytestring, containers, cryptonite, dbus
         , memory, safe-exceptions, stdenv
         }:
         mkDerivation {
           pname = "credential-store";
           version = "0.1.2";
           sha256 = "4dadbc219a7187442258608c1d834f4297652fb605fc6bbbb41d751fef6a9284";
           isLibrary = true;
           isExecutable = true;
           libraryHaskellDepends = [
             base bytestring containers cryptonite dbus memory safe-exceptions
           ];
           executableHaskellDepends = [ base bytestring ];
           doHaddock = false;
           doCheck = false;
           homepage = "https://github.com/rblaze/credential-store#readme";
           description = "Library to access secure credential storage providers";
           license = stdenv.lib.licenses.asl20;
         }) {};
      "criterion" = callPackage
        ({ mkDerivation, aeson, ansi-wl-pprint, base, base-compat-batteries
         , binary, bytestring, cassava, code-page, containers, deepseq
         , directory, exceptions, filepath, Glob, js-flot, js-jquery
         , microstache, mtl, mwc-random, optparse-applicative, parsec
         , semigroups, statistics, stdenv, text, time, transformers
         , transformers-compat, vector, vector-algorithms
         }:
         mkDerivation {
           pname = "criterion";
           version = "1.4.1.0";
           sha256 = "c49306676aa7927c3ca3c1807b081d1e86771eb8da99c8391f9c4dacb24a826c";
           revision = "1";
           editedCabalFile = "0jg7mk9y9br5aqi29vrrrq28mnyknyg96zmr8rrlxw0rf68l892a";
           isLibrary = true;
           isExecutable = true;
           enableSeparateDataOutput = true;
           libraryHaskellDepends = [
             aeson ansi-wl-pprint base base-compat-batteries binary bytestring
             cassava code-page containers deepseq directory exceptions filepath
             Glob js-flot js-jquery microstache mtl mwc-random
             optparse-applicative parsec semigroups statistics text time
             transformers transformers-compat vector vector-algorithms
           ];
           executableHaskellDepends = [
             base base-compat-batteries optparse-applicative semigroups
           ];
           doHaddock = false;
           doCheck = false;
           homepage = "http://www.serpentine.com/criterion";
           description = "Robust, reliable performance measurement and analysis";
           license = stdenv.lib.licenses.bsd3;
         }) {};
      "criterion-measurement" = callPackage
        ({ mkDerivation, aeson, base, base-compat, binary, containers
         , deepseq, stdenv, vector
         }:
         mkDerivation {
           pname = "criterion-measurement";
           version = "0.1.1.0";
           sha256 = "f5f87769386a927dbf487d2f256fc6804f2902078e86dcf113e35178a582ab56";
           libraryHaskellDepends = [
             aeson base base-compat binary containers deepseq vector
           ];
           doHaddock = false;
           doCheck = false;
           homepage = "https://github.com/bos/criterion";
           description = "Criterion measurement functionality and associated types";
           license = stdenv.lib.licenses.bsd3;
         }) {};
      "cron" = callPackage
        ({ mkDerivation, attoparsec, base, data-default-class, mtl
         , mtl-compat, old-locale, semigroups, stdenv, text, time
         }:
         mkDerivation {
           pname = "cron";
           version = "0.6.1";
           sha256 = "8c1af53bde729026809b722468f6b36c4f96cb532f26a390f32f1c91fb8b3251";
           libraryHaskellDepends = [
             attoparsec base data-default-class mtl mtl-compat old-locale
             semigroups text time
           ];
           doHaddock = false;
           doCheck = false;
           homepage = "http://github.com/michaelxavier/cron";
           description = "Cron datatypes and Attoparsec parser";
           license = stdenv.lib.licenses.mit;
         }) {};
      "crypt-sha512" = callPackage
        ({ mkDerivation, attoparsec, base, bytestring, cryptohash-sha512
         , stdenv
         }:
         mkDerivation {
           pname = "crypt-sha512";
           version = "0";
           sha256 = "c2be6252bf12f38c74950eb778039426c730e9a7cd7f034a4cc3e6965d5255f3";
           revision = "2";
           editedCabalFile = "071lxiwsf23ga1fkbjd47ykz7f5irhsh7q7zz2qczzjgnvzadadh";
           libraryHaskellDepends = [
             attoparsec base bytestring cryptohash-sha512
           ];
           doHaddock = false;
           doCheck = false;
           homepage = "https://github.com/phadej/crypt-sha512";
           description = "Pure Haskell implelementation for GNU SHA512 crypt algorithm";
           license = stdenv.lib.licenses.bsd3;
         }) {};
      "crypto-api" = callPackage
        ({ mkDerivation, base, bytestring, cereal, entropy, stdenv, tagged
         , transformers
         }:
         mkDerivation {
           pname = "crypto-api";
           version = "0.13.3";
           sha256 = "298a9ea7ce97c8ccf4bfe46d4864092c3a007a56bede73560070db3bf1ac7aa5";
           revision = "1";
           editedCabalFile = "1z6n1sa5pn3iqvqjrd8hv4bc2pxzsrhm5sh0l8z7g9lbqp6w0wp5";
           libraryHaskellDepends = [
             base bytestring cereal entropy tagged transformers
           ];
           doHaddock = false;
           doCheck = false;
           homepage = "https://github.com/TomMD/crypto-api";
           description = "A generic interface for cryptographic operations";
           license = stdenv.lib.licenses.bsd3;
         }) {};
      "crypto-api-tests" = callPackage
        ({ mkDerivation, base, bytestring, cereal, crypto-api, directory
         , filepath, HUnit, QuickCheck, stdenv, test-framework
         , test-framework-hunit, test-framework-quickcheck2
         }:
         mkDerivation {
           pname = "crypto-api-tests";
           version = "0.3";
           sha256 = "f44aecdd4ceb9da9f38330e84d9c17745a82b0611085ebb34442d2dce4207270";
           enableSeparateDataOutput = true;
           libraryHaskellDepends = [
             base bytestring cereal crypto-api directory filepath HUnit
             QuickCheck test-framework test-framework-hunit
             test-framework-quickcheck2
           ];
           doHaddock = false;
           doCheck = false;
           homepage = "http://trac.haskell.org/crypto-api/wiki";
           description = "A test framework and KATs for cryptographic operations";
           license = stdenv.lib.licenses.bsd3;
         }) {};
      "crypto-cipher-tests" = callPackage
        ({ mkDerivation, base, byteable, bytestring, crypto-cipher-types
         , HUnit, mtl, QuickCheck, securemem, stdenv, test-framework
         , test-framework-hunit, test-framework-quickcheck2
         }:
         mkDerivation {
           pname = "crypto-cipher-tests";
           version = "0.0.11";
           sha256 = "dfb670b73d4091b8683634d0d4d5a40576d573ad160650d5e518244ced8b98a7";
           libraryHaskellDepends = [
             base byteable bytestring crypto-cipher-types HUnit mtl QuickCheck
             securemem test-framework test-framework-hunit
             test-framework-quickcheck2
           ];
           doHaddock = false;
           doCheck = false;
           homepage = "http://github.com/vincenthz/hs-crypto-cipher";
           description = "Generic cryptography cipher tests";
           license = stdenv.lib.licenses.bsd3;
         }) {};
      "crypto-cipher-types" = callPackage
        ({ mkDerivation, base, byteable, bytestring, securemem, stdenv }:
         mkDerivation {
           pname = "crypto-cipher-types";
           version = "0.0.9";
           sha256 = "2073f6b70df7916aebe2da49d224497183662d56d19da87b76f70039430c0a0f";
           enableSeparateDataOutput = true;
           libraryHaskellDepends = [ base byteable bytestring securemem ];
           doHaddock = false;
           doCheck = false;
           homepage = "http://github.com/vincenthz/hs-crypto-cipher";
           description = "Generic cryptography cipher types";
           license = stdenv.lib.licenses.bsd3;
         }) {};
      "crypto-enigma" = callPackage
        ({ mkDerivation, ansi-terminal, base, containers, mtl
         , optparse-applicative, split, stdenv, text
         }:
         mkDerivation {
           pname = "crypto-enigma";
           version = "0.0.3.1";
           sha256 = "22221a31e8a1e1e63ab27733e037bf5b5b5a59b07463590ce69f7a42aeff4d45";
           isLibrary = true;
           isExecutable = true;
           libraryHaskellDepends = [ base containers mtl split text ];
           executableHaskellDepends = [
             ansi-terminal base containers mtl optparse-applicative split text
           ];
           doHaddock = false;
           doCheck = false;
           homepage = "https://github.com/orome/crypto-enigma-hs";
           description = "An Enigma machine simulator with display";
           license = stdenv.lib.licenses.bsd3;
         }) {};
      "crypto-numbers" = callPackage
        ({ mkDerivation, base, bytestring, crypto-random, ghc-prim
         , integer-gmp, stdenv, vector
         }:
         mkDerivation {
           pname = "crypto-numbers";
           version = "0.2.7";
           sha256 = "420aeb17e9cdcfdf8c950c6c6f10c54503c5524d36f611aa7238e3fd65f189a6";
           revision = "1";
           editedCabalFile = "1jjkhid8kwrz5894nad537rqxzzyx6b687bmgyk70nv0ny336j9b";
           libraryHaskellDepends = [
             base bytestring crypto-random ghc-prim integer-gmp vector
           ];
           doHaddock = false;
           doCheck = false;
           homepage = "https://github.com/vincenthz/hs-crypto-numbers";
           description = "Cryptographic numbers: functions and algorithms";
           license = stdenv.lib.licenses.bsd3;
         }) {};
      "crypto-pubkey" = callPackage
        ({ mkDerivation, base, byteable, bytestring, crypto-numbers
         , crypto-pubkey-types, crypto-random, cryptohash, stdenv
         }:
         mkDerivation {
           pname = "crypto-pubkey";
           version = "0.2.8";
           sha256 = "c0ccf2f5c38517de1f1626cb0a2542f35aefad8842f8ad5c1fac0b8c9de8b56e";
           libraryHaskellDepends = [
             base byteable bytestring crypto-numbers crypto-pubkey-types
             crypto-random cryptohash
           ];
           doHaddock = false;
           doCheck = false;
           homepage = "https://github.com/vincenthz/hs-crypto-pubkey";
           description = "Public Key cryptography";
           license = stdenv.lib.licenses.bsd3;
         }) {};
      "crypto-pubkey-types" = callPackage
        ({ mkDerivation, asn1-encoding, asn1-types, base, stdenv }:
         mkDerivation {
           pname = "crypto-pubkey-types";
           version = "0.4.3";
           sha256 = "7ed9f52281ec4e34021a91818fe45288e33d65bff937f60334a3f45be5a71c60";
           libraryHaskellDepends = [ asn1-encoding asn1-types base ];
           doHaddock = false;
           doCheck = false;
           homepage = "http://github.com/vincenthz/hs-crypto-pubkey-types";
           description = "Generic cryptography Public keys algorithm types";
           license = stdenv.lib.licenses.bsd3;
         }) {};
      "crypto-random" = callPackage
        ({ mkDerivation, base, bytestring, securemem, stdenv, unix, vector
         }:
         mkDerivation {
           pname = "crypto-random";
           version = "0.0.9";
           sha256 = "170a7a18441379c2d1c19b502ee5919026a19adc6e78641cd4fb40b1d69a6904";
           revision = "1";
           editedCabalFile = "1ax1iafbbqkcrvjnnxlvqh2zgpx8xzcbxl6l870207bpzwrja2f1";
           libraryHaskellDepends = [ base bytestring securemem unix vector ];
           doHaddock = false;
           doCheck = false;
           homepage = "http://github.com/vincenthz/hs-crypto-random";
           description = "Simple cryptographic random related types";
           license = stdenv.lib.licenses.bsd3;
         }) {};
      "crypto-random-api" = callPackage
        ({ mkDerivation, base, bytestring, entropy, stdenv }:
         mkDerivation {
           pname = "crypto-random-api";
           version = "0.2.0";
           sha256 = "56e9777061bd9ce553683d097ba3a11fdc371724060b62ca103f1f291f9f897c";
           libraryHaskellDepends = [ base bytestring entropy ];
           doHaddock = false;
           doCheck = false;
           homepage = "http://github.com/vincenthz/hs-crypto-random-api";
           description = "Simple random generators API for cryptography related code";
           license = stdenv.lib.licenses.bsd3;
         }) {};
      "cryptocipher" = callPackage
        ({ mkDerivation, base, cipher-aes, cipher-blowfish, cipher-camellia
         , cipher-des, cipher-rc4, crypto-cipher-types, stdenv
         }:
         mkDerivation {
           pname = "cryptocipher";
           version = "0.6.2";
           sha256 = "34b9e62dee36c4019dd0c0e86576295d0bd1bb573eeb24686ec635a09550e346";
           libraryHaskellDepends = [
             base cipher-aes cipher-blowfish cipher-camellia cipher-des
             cipher-rc4 crypto-cipher-types
           ];
           doHaddock = false;
           doCheck = false;
           homepage = "http://github.com/vincenthz/hs-crypto-cipher";
           description = "Symmetrical block and stream ciphers";
           license = stdenv.lib.licenses.bsd3;
         }) {};
      "cryptocompare" = callPackage
        ({ mkDerivation, aeson, base, bytestring, containers, directory
         , exceptions, http-conduit, MissingH, stdenv, text, time
         , transformers, unordered-containers
         }:
         mkDerivation {
           pname = "cryptocompare";
           version = "0.1.1";
           sha256 = "d12e0f6fd133e538852e5700b0a31d81c6885dc8b1e9e88d1b331dcec38316b3";
           libraryHaskellDepends = [
             aeson base bytestring containers directory exceptions http-conduit
             MissingH text time transformers unordered-containers
           ];
           doHaddock = false;
           doCheck = false;
           homepage = "https://github.com/aviaviavi/cryptocompare";
           description = "Haskell wrapper for the cryptocompare API";
           license = stdenv.lib.licenses.mit;
         }) {};
      "cryptohash" = callPackage
        ({ mkDerivation, base, byteable, bytestring, cryptonite, ghc-prim
         , memory, stdenv
         }:
         mkDerivation {
           pname = "cryptohash";
           version = "0.11.9";
           sha256 = "c28f847fc1fcd65b6eea2e74a100300af940919f04bb21d391f6a773968f22fb";
           libraryHaskellDepends = [
             base byteable bytestring cryptonite ghc-prim memory
           ];
           doHaddock = false;
           doCheck = false;
           homepage = "http://github.com/vincenthz/hs-cryptohash";
           description = "collection of crypto hashes, fast, pure and practical";
           license = stdenv.lib.licenses.bsd3;
         }) {};
      "cryptohash-cryptoapi" = callPackage
        ({ mkDerivation, base, bytestring, cereal, crypto-api, cryptonite
         , memory, stdenv, tagged
         }:
         mkDerivation {
           pname = "cryptohash-cryptoapi";
           version = "0.1.4";
           sha256 = "717a8664ebfaa1c31aaec1d78c9b7c776a5adcfdfc50ad88e21a34566f72058e";
           enableSeparateDataOutput = true;
           libraryHaskellDepends = [
             base bytestring cereal crypto-api cryptonite memory tagged
           ];
           doHaddock = false;
           doCheck = false;
           homepage = "https://github.com/vincenthz/hs-cryptohash-cryptoapi";
           description = "Crypto-api interfaces for cryptohash";
           license = stdenv.lib.licenses.bsd3;
         }) {};
      "cryptohash-md5" = callPackage
        ({ mkDerivation, base, bytestring, stdenv }:
         mkDerivation {
           pname = "cryptohash-md5";
           version = "0.11.100.1";
           sha256 = "710bd48770fa3e9a3b05428c6dc77fb72c91956d334a1eb89ded11bb843e18f9";
           revision = "3";
           editedCabalFile = "0ld224mdmw9mgzcl20q82rqkyl7d5vmi1iknsyymq58gcvcwdi2m";
           libraryHaskellDepends = [ base bytestring ];
           doHaddock = false;
           doCheck = false;
           homepage = "https://github.com/hvr/cryptohash-md5";
           description = "Fast, pure and practical MD5 implementation";
           license = stdenv.lib.licenses.bsd3;
         }) {};
      "cryptohash-sha1" = callPackage
        ({ mkDerivation, base, bytestring, stdenv }:
         mkDerivation {
           pname = "cryptohash-sha1";
           version = "0.11.100.1";
           sha256 = "3c79af33542512442f8f87f6abb1faef7cd43bbfb2859260a33251d861eb0dab";
           revision = "3";
           editedCabalFile = "0i30cc85732v27baibdjy2kjjkdfv335ib5sk5ggwvsysvvvr66l";
           libraryHaskellDepends = [ base bytestring ];
           doHaddock = false;
           doCheck = false;
           homepage = "https://github.com/hvr/cryptohash-sha1";
           description = "Fast, pure and practical SHA-1 implementation";
           license = stdenv.lib.licenses.bsd3;
         }) {};
      "cryptohash-sha256" = callPackage
        ({ mkDerivation, base, bytestring, stdenv }:
         mkDerivation {
           pname = "cryptohash-sha256";
           version = "0.11.101.0";
           sha256 = "52756435dbea248e344fbcbcc5df5307f60dfacf337dfd11ae30f1c7a4da05dd";
           revision = "2";
           editedCabalFile = "0m5h68xm60wrjv88gg6cn1q5qki5674mxl4d6sn3vxpbcj9b5417";
           isLibrary = true;
           isExecutable = true;
           libraryHaskellDepends = [ base bytestring ];
           doHaddock = false;
           doCheck = false;
           homepage = "https://github.com/hvr/cryptohash-sha256";
           description = "Fast, pure and practical SHA-256 implementation";
           license = stdenv.lib.licenses.bsd3;
         }) {};
      "cryptohash-sha512" = callPackage
        ({ mkDerivation, base, bytestring, stdenv }:
         mkDerivation {
           pname = "cryptohash-sha512";
           version = "0.11.100.1";
           sha256 = "10698bb9575eaa414a65d9644caa9408f9276c63447406e0a4faef91db1071a9";
           revision = "3";
           editedCabalFile = "19m1fp0i7ba84aa72d5wf59c7j0p4yr1bc43in8pspgywhsr3lfl";
           libraryHaskellDepends = [ base bytestring ];
           doHaddock = false;
           doCheck = false;
           homepage = "https://github.com/hvr/cryptohash-sha512";
           description = "Fast, pure and practical SHA-512 implementation";
           license = stdenv.lib.licenses.bsd3;
         }) {};
      "cryptonite" = callPackage
        ({ mkDerivation, base, basement, bytestring, deepseq, ghc-prim
         , integer-gmp, memory, stdenv
         }:
         mkDerivation {
           pname = "cryptonite";
           version = "0.25";
           sha256 = "89be1a18af8730a7bfe4d718d7d5f6ce858e9df93a411566d15bf992db5a3c8c";
           libraryHaskellDepends = [
             base basement bytestring deepseq ghc-prim integer-gmp memory
           ];
           doHaddock = false;
           doCheck = false;
           homepage = "https://github.com/haskell-crypto/cryptonite";
           description = "Cryptography Primitives sink";
           license = stdenv.lib.licenses.bsd3;
         }) {};
      "cryptonite-conduit" = callPackage
        ({ mkDerivation, base, bytestring, conduit, conduit-extra
         , cryptonite, exceptions, memory, resourcet, stdenv, transformers
         }:
         mkDerivation {
           pname = "cryptonite-conduit";
           version = "0.2.2";
           sha256 = "705d69ab3f79b7b8810c7b9e7da81a1c6686b6a4323b1e78150576a25a658dae";
           revision = "1";
           editedCabalFile = "1hh2nzfz4qpxgivfilgk4ll416lph8b2fdkzpzrmqfjglivydfmz";
           libraryHaskellDepends = [
             base bytestring conduit conduit-extra cryptonite exceptions memory
             resourcet transformers
           ];
           doHaddock = false;
           doCheck = false;
           homepage = "https://github.com/haskell-crypto/cryptonite-conduit";
           description = "cryptonite conduit";
           license = stdenv.lib.licenses.bsd3;
         }) {};
      "cryptonite-openssl" = callPackage
        ({ mkDerivation, base, basement, bytestring, cryptonite, memory
         , openssl, stdenv
         }:
         mkDerivation {
           pname = "cryptonite-openssl";
           version = "0.7";
           sha256 = "9e4e1c08264f26e602ef3054f3c827c3c65d153e5b9d68a0cb44f446ca0844f6";
           libraryHaskellDepends = [
             base basement bytestring cryptonite memory
           ];
           librarySystemDepends = [ openssl ];
           doHaddock = false;
           doCheck = false;
           homepage = "https://github.com/haskell-crypto/cryptonite-openssl";
           description = "Crypto stuff using OpenSSL cryptographic library";
           license = stdenv.lib.licenses.bsd3;
         }) {inherit (pkgs) openssl;};
      "csg" = callPackage
        ({ mkDerivation, attoparsec, base, bytestring, containers, gloss
         , gloss-raster, QuickCheck, simple-vec3, stdenv, strict
         , system-filepath, transformers, turtle
         }:
         mkDerivation {
           pname = "csg";
           version = "0.1.0.5";
           sha256 = "09436d220b669b6d35146c8bc696a37f05eac60c737388b9d504471cbb70fc8b";
           isLibrary = true;
           isExecutable = true;
           libraryHaskellDepends = [
             attoparsec base bytestring containers QuickCheck simple-vec3 strict
             transformers
           ];
           executableHaskellDepends = [
             base gloss gloss-raster QuickCheck simple-vec3 strict
             system-filepath turtle
           ];
           doHaddock = false;
           doCheck = false;
           homepage = "https://github.com/dzhus/csg#readme";
           description = "Analytical CSG (Constructive Solid Geometry) library";
           license = stdenv.lib.licenses.bsd3;
         }) {};
      "csp" = callPackage
        ({ mkDerivation, base, containers, mtl, nondeterminism, stdenv }:
         mkDerivation {
           pname = "csp";
           version = "1.4.0";
           sha256 = "08877f5ff196772675ac55b3c43ab39b527259114da8cfc36122c0cd7ce93496";
           libraryHaskellDepends = [ base containers mtl nondeterminism ];
           doHaddock = false;
           doCheck = false;
           description = "Discrete constraint satisfaction problem (CSP) solver";
           license = "LGPL";
         }) {};
      "css-syntax" = callPackage
        ({ mkDerivation, attoparsec, base, bytestring, scientific, stdenv
         , text
         }:
         mkDerivation {
           pname = "css-syntax";
           version = "0.0.8";
           sha256 = "4271ecf02ee47334dc8bee8bf6bcaa99503056aa73f42ef9eb3ad5840d3030c1";
           libraryHaskellDepends = [
             attoparsec base bytestring scientific text
           ];
           doHaddock = false;
           doCheck = false;
           description = "This package implments a parser for the CSS syntax";
           license = stdenv.lib.licenses.mit;
         }) {};
      "css-text" = callPackage
        ({ mkDerivation, attoparsec, base, stdenv, text }:
         mkDerivation {
           pname = "css-text";
           version = "0.1.3.0";
           sha256 = "5ff507bf3863219f41e7f2d215e5511fe15ee13d1e28bd3ee64e0b0b894bcd7a";
           libraryHaskellDepends = [ attoparsec base text ];
           doHaddock = false;
           doCheck = false;
           homepage = "https://github.com/yesodweb/css-text.git#readme";
           description = "CSS parser and renderer";
           license = stdenv.lib.licenses.mit;
         }) {};
      "csv" = callPackage
        ({ mkDerivation, base, filepath, parsec, stdenv }:
         mkDerivation {
           pname = "csv";
           version = "0.1.2";
           sha256 = "8cf43442325faa1368f9b55ad952beccf677d9980cdffa3d70a7f204a23ae600";
           libraryHaskellDepends = [ base filepath parsec ];
           doHaddock = false;
           doCheck = false;
           description = "CSV loader and dumper";
           license = stdenv.lib.licenses.mit;
         }) {};
      "ctrie" = callPackage
        ({ mkDerivation, atomic-primops, base, hashable, primitive, stdenv
         }:
         mkDerivation {
           pname = "ctrie";
           version = "0.2";
           sha256 = "20e3a6d39f65ed1663ff5ab2c5431dc12b1c601d2133a74bc7bea1596ad9c814";
           libraryHaskellDepends = [ atomic-primops base hashable primitive ];
           doHaddock = false;
           doCheck = false;
           homepage = "https://github.com/mcschroeder/ctrie";
           description = "Non-blocking concurrent map";
           license = stdenv.lib.licenses.mit;
         }) {};
      "cubicbezier" = callPackage
        ({ mkDerivation, base, containers, fast-math, integration, matrices
         , microlens, microlens-mtl, microlens-th, mtl, stdenv, vector
         , vector-space
         }:
         mkDerivation {
           pname = "cubicbezier";
           version = "0.6.0.5";
           sha256 = "c5c9825782d97c4059b2261dddd6471fdb270ddac0ff97d6d02d4f0d44b62758";
           revision = "1";
           editedCabalFile = "0dii4z0cl1ylvay1n5z90d6rbvnk9k30q81i6izhgxbgdawwhh33";
           libraryHaskellDepends = [
             base containers fast-math integration matrices microlens
             microlens-mtl microlens-th mtl vector vector-space
           ];
           doHaddock = false;
           doCheck = false;
           description = "Efficient manipulating of 2D cubic bezier curves";
           license = stdenv.lib.licenses.bsd3;
         }) {};
      "cubicspline" = callPackage
        ({ mkDerivation, base, hmatrix, safe, stdenv }:
         mkDerivation {
           pname = "cubicspline";
           version = "0.1.2";
           sha256 = "5b6ced9ca65b0d01ddceaf18605c8f915491d8d4a6aaef73475c4e8d4b1a9b79";
           libraryHaskellDepends = [ base hmatrix safe ];
           doHaddock = false;
           doCheck = false;
           description = "Natural cubic spline interpolation";
           license = stdenv.lib.licenses.bsd3;
         }) {};
      "cue-sheet" = callPackage
        ({ mkDerivation, base, bytestring, containers, data-default-class
         , exceptions, megaparsec, mtl, QuickCheck, stdenv, text
         }:
         mkDerivation {
           pname = "cue-sheet";
           version = "1.0.1";
           sha256 = "214a58e87a849c8311eb652ca215b4f5789d724e7499324544b3a01187577f8f";
           revision = "3";
           editedCabalFile = "14kgk1digf1vbsr7v5jvj8gajkx0rkn3zjl4m8csqhxalkaxa2zl";
           enableSeparateDataOutput = true;
           libraryHaskellDepends = [
             base bytestring containers data-default-class exceptions megaparsec
             mtl QuickCheck text
           ];
           doHaddock = false;
           doCheck = false;
           homepage = "https://github.com/mrkkrp/cue-sheet";
           description = "Support for construction, rendering, and parsing of CUE sheets";
           license = stdenv.lib.licenses.bsd3;
         }) {};
      "curl" = callPackage
        ({ mkDerivation, base, bytestring, containers, curl, stdenv }:
         mkDerivation {
           pname = "curl";
           version = "1.3.8";
           sha256 = "9087c936bfcdb865bad3166baa3f12bf37acf076fa76010e3b5f82a1d485446e";
           revision = "1";
           editedCabalFile = "02sq2bjw5igc2k9f9ssh58k2ivii2xsvk5r00ky3cxh8j61qy86q";
           configureFlags = [ "-fnew-base" ];
           libraryHaskellDepends = [ base bytestring containers ];
           librarySystemDepends = [ curl ];
           doHaddock = false;
           doCheck = false;
           description = "Haskell binding to libcurl";
           license = stdenv.lib.licenses.bsd3;
         }) {inherit (pkgs) curl;};
      "curl-runnings" = callPackage
        ({ mkDerivation, aeson, aeson-pretty, base, bytestring
         , case-insensitive, cmdargs, directory, hspec, hspec-expectations
         , http-conduit, http-types, megaparsec, stdenv, text
         , unordered-containers, vector, yaml
         }:
         mkDerivation {
           pname = "curl-runnings";
           version = "0.6.0";
           sha256 = "44204017b483d96659948011a3abe78f05afa5b63cd561bcaa36ea5f21efac19";
           isLibrary = true;
           isExecutable = true;
           libraryHaskellDepends = [
             aeson aeson-pretty base bytestring case-insensitive directory hspec
             hspec-expectations http-conduit http-types megaparsec text
             unordered-containers vector yaml
           ];
           executableHaskellDepends = [ base cmdargs text ];
           doHaddock = false;
           doCheck = false;
           homepage = "https://github.com/aviaviavi/curl-runnings#readme";
           description = "A framework for declaratively writing curl based API tests";
           license = stdenv.lib.licenses.mit;
         }) {};
      "currencies" = callPackage
        ({ mkDerivation, base, stdenv, text }:
         mkDerivation {
           pname = "currencies";
           version = "0.2.0.0";
           sha256 = "fb7292d4a5b9c4389690d1386fe24ce6a93eacbcfa952936ca6d4fd3afa98499";
           libraryHaskellDepends = [ base text ];
           doHaddock = false;
           doCheck = false;
           homepage = "https://github.com/alx741/currencies#readme";
           description = "Currencies representation, pretty printing and conversion";
           license = stdenv.lib.licenses.bsd3;
         }) {};
      "currency" = callPackage
        ({ mkDerivation, base, containers, hashable, iso3166-country-codes
         , stdenv
         }:
         mkDerivation {
           pname = "currency";
           version = "0.2.0.0";
           sha256 = "bcd517f3d9f47f0dd3c4e802143159239e4a90db2fc552be4a99d759ffe9417a";
           libraryHaskellDepends = [
             base containers hashable iso3166-country-codes
           ];
           doHaddock = false;
           doCheck = false;
           homepage = "https://github.com/singpolyma/currency-haskell";
           description = "Types representing standard and non-standard currencies";
           license = "unknown";
           hydraPlatforms = stdenv.lib.platforms.none;
         }) {};
      "cutter" = callPackage
        ({ mkDerivation, base, bytestring, explicit-exception, spreadsheet
         , stdenv, utility-ht
         }:
         mkDerivation {
           pname = "cutter";
           version = "0.0";
           sha256 = "117319c36a20efea6d9edd0a8d902e37ec0386512f2eb8a6e5563411c00c6ac2";
           isLibrary = false;
           isExecutable = true;
           executableHaskellDepends = [
             base bytestring explicit-exception spreadsheet utility-ht
           ];
           doHaddock = false;
           doCheck = false;
           description = "Cut files according to a position list";
           license = stdenv.lib.licenses.bsd3;
         }) {};
      "cyclotomic" = callPackage
        ({ mkDerivation, arithmoi, base, containers, stdenv }:
         mkDerivation {
           pname = "cyclotomic";
           version = "0.5.1";
           sha256 = "f72098bac1ec2fe561a2cc654334d8931b1a9074424be0081157901df56f5ffd";
           libraryHaskellDepends = [ arithmoi base containers ];
           doHaddock = false;
           doCheck = false;
           description = "A subfield of the complex numbers for exact calculation";
           license = stdenv.lib.licenses.gpl3;
         }) {};
      "czipwith" = callPackage
        ({ mkDerivation, base, stdenv, template-haskell }:
         mkDerivation {
           pname = "czipwith";
           version = "1.0.1.1";
           sha256 = "4a148579f4ef822544b721a4b59f7a9e62a965e270dee9d2a54a98ceab494243";
           libraryHaskellDepends = [ base template-haskell ];
           doHaddock = false;
           doCheck = false;
           homepage = "https://github.com/lspitzner/czipwith/";
           description = "CZipWith class and deriving via TH";
           license = stdenv.lib.licenses.bsd3;
         }) {};
      "darcs" = callPackage
        ({ mkDerivation, array, async, attoparsec, base, base16-bytestring
         , binary, bytestring, Cabal, containers, cryptohash, curl
         , data-ordlist, directory, fgl, filepath, graphviz, hashable
         , haskeline, html, HTTP, mmap, mtl, network, network-uri, old-time
         , parsec, process, random, regex-applicative, regex-compat-tdfa
         , sandi, stdenv, stm, tar, terminfo, text, time, transformers, unix
         , unix-compat, utf8-string, vector, zip-archive, zlib
         }:
         mkDerivation {
           pname = "darcs";
           version = "2.14.1";
           sha256 = "61ddbc99acaf06df3a114437064e9241e0da467c23d1d3fb520a782eee32cd35";
           configureFlags = [ "-fforce-char8-encoding" "-flibrary" ];
           isLibrary = true;
           isExecutable = true;
           setupHaskellDepends = [ base Cabal directory filepath process ];
           libraryHaskellDepends = [
             array async attoparsec base base16-bytestring binary bytestring
             containers cryptohash data-ordlist directory fgl filepath graphviz
             hashable haskeline html HTTP mmap mtl network network-uri old-time
             parsec process random regex-applicative regex-compat-tdfa sandi stm
             tar terminfo text time transformers unix unix-compat utf8-string
             vector zip-archive zlib
           ];
           librarySystemDepends = [ curl ];
           executableHaskellDepends = [ base ];
           doHaddock = false;
           doCheck = false;
           postInstall = ''
             mkdir -p $out/etc/bash_completion.d
             mv contrib/darcs_completion $out/etc/bash_completion.d/darcs
           '';
           homepage = "http://darcs.net/";
           description = "a distributed, interactive, smart revision control system";
           license = stdenv.lib.licenses.gpl2;
         }) {inherit (pkgs) curl;};
      "data-accessor" = callPackage
        ({ mkDerivation, array, base, containers, stdenv, transformers }:
         mkDerivation {
           pname = "data-accessor";
           version = "0.2.2.8";
           sha256 = "ac3f95162df227a16eabf6be65d1d6563e5207d581edf72b680bfcd59f7f04bb";
           libraryHaskellDepends = [ array base containers transformers ];
           doHaddock = false;
           doCheck = false;
           homepage = "http://www.haskell.org/haskellwiki/Record_access";
           description = "Utilities for accessing and manipulating fields of records";
           license = stdenv.lib.licenses.bsd3;
         }) {};
      "data-accessor-mtl" = callPackage
        ({ mkDerivation, base, data-accessor, mtl, stdenv }:
         mkDerivation {
           pname = "data-accessor-mtl";
           version = "0.2.0.4";
           sha256 = "10cf9166e2e046076b7e58987718e57b31408e7cada9f26c8ff111e0379814c5";
           libraryHaskellDepends = [ base data-accessor mtl ];
           doHaddock = false;
           doCheck = false;
           homepage = "http://www.haskell.org/haskellwiki/Record_access";
           description = "Use Accessor to access state in mtl State monad class";
           license = stdenv.lib.licenses.bsd3;
         }) {};
      "data-accessor-template" = callPackage
        ({ mkDerivation, base, data-accessor, stdenv, template-haskell
         , utility-ht
         }:
         mkDerivation {
           pname = "data-accessor-template";
           version = "0.2.1.16";
           sha256 = "93e7f2120b8974d81a4acc56bd6a5b7121dac4672d974a42512c169c6937ed95";
           libraryHaskellDepends = [
             base data-accessor template-haskell utility-ht
           ];
           doHaddock = false;
           doCheck = false;
           homepage = "http://www.haskell.org/haskellwiki/Record_access";
           description = "Utilities for accessing and manipulating fields of records";
           license = stdenv.lib.licenses.bsd3;
         }) {};
      "data-accessor-transformers" = callPackage
        ({ mkDerivation, base, data-accessor, stdenv, transformers }:
         mkDerivation {
           pname = "data-accessor-transformers";
           version = "0.2.1.7";
           sha256 = "20c8823dc16c7ca6f55c64eb5564c9aae4b5565406987a046ded2ea73618e07a";
           libraryHaskellDepends = [ base data-accessor transformers ];
           doHaddock = false;
           doCheck = false;
           homepage = "http://www.haskell.org/haskellwiki/Record_access";
           description = "Use Accessor to access state in transformers State monad";
           license = stdenv.lib.licenses.bsd3;
         }) {};
      "data-binary-ieee754" = callPackage
        ({ mkDerivation, base, binary, stdenv }:
         mkDerivation {
           pname = "data-binary-ieee754";
           version = "0.4.4";
           sha256 = "59975abed8f4caa602f0780c10a9b2493479e6feb71ad189bb10c3ac5678df0a";
           libraryHaskellDepends = [ base binary ];
           doHaddock = false;
           doCheck = false;
           homepage = "https://john-millikin.com/software/data-binary-ieee754/";
           description = "Parser/Serialiser for IEEE-754 floating-point values";
           license = stdenv.lib.licenses.mit;
         }) {};
      "data-bword" = callPackage
        ({ mkDerivation, base, ghc-prim, stdenv }:
         mkDerivation {
           pname = "data-bword";
           version = "0.1.0.1";
           sha256 = "70f01f857865edcf1d1d20128b0202320b1635cc03b00954b6d1447cd699db7d";
           libraryHaskellDepends = [ base ghc-prim ];
           doHaddock = false;
           doCheck = false;
           homepage = "https://github.com/mvv/data-bword";
           description = "Extra operations on binary words of fixed length";
           license = stdenv.lib.licenses.bsd3;
         }) {};
      "data-checked" = callPackage
        ({ mkDerivation, base, deepseq, stdenv }:
         mkDerivation {
           pname = "data-checked";
           version = "0.3";
           sha256 = "dc87d09c7c8587c9e6e372166e8de3b42c2cd804a493ff100c253e4d713c5676";
           libraryHaskellDepends = [ base deepseq ];
           doHaddock = false;
           doCheck = false;
           homepage = "https://github.com/mvv/data-checked";
           description = "Type-indexed runtime-checked properties";
           license = stdenv.lib.licenses.bsd3;
         }) {};
      "data-clist" = callPackage
        ({ mkDerivation, base, deepseq, QuickCheck, stdenv }:
         mkDerivation {
           pname = "data-clist";
           version = "0.1.2.2";
           sha256 = "d1a73743b45c36ac75cfa4ebdbb3fc63860093651f05dc171d28e91d688d2baa";
           libraryHaskellDepends = [ base deepseq QuickCheck ];
           doHaddock = false;
           doCheck = false;
           homepage = "https://github.com/sw17ch/data-clist";
           description = "Simple functional ring type";
           license = stdenv.lib.licenses.bsd3;
         }) {};
      "data-default" = callPackage
        ({ mkDerivation, base, data-default-class
         , data-default-instances-containers, data-default-instances-dlist
         , data-default-instances-old-locale, stdenv
         }:
         mkDerivation {
           pname = "data-default";
           version = "0.7.1.1";
           sha256 = "b0f95d279cd75cacaa8152a01590dc3460f7134f6840b37052abb3ba3cb2a511";
           libraryHaskellDepends = [
             base data-default-class data-default-instances-containers
             data-default-instances-dlist data-default-instances-old-locale
           ];
           doHaddock = false;
           doCheck = false;
           description = "A class for types with a default value";
           license = stdenv.lib.licenses.bsd3;
         }) {};
      "data-default-class" = callPackage
        ({ mkDerivation, base, stdenv }:
         mkDerivation {
           pname = "data-default-class";
           version = "0.1.2.0";
           sha256 = "4f01b423f000c3e069aaf52a348564a6536797f31498bb85c3db4bd2d0973e56";
           libraryHaskellDepends = [ base ];
           doHaddock = false;
           doCheck = false;
           description = "A class for types with a default value";
           license = stdenv.lib.licenses.bsd3;
         }) {};
      "data-default-instances-containers" = callPackage
        ({ mkDerivation, base, containers, data-default-class, stdenv }:
         mkDerivation {
           pname = "data-default-instances-containers";
           version = "0.0.1";
           sha256 = "a55e07af005c9815d82f3fc95e125db82994377c9f4a769428878701d4ec081a";
           libraryHaskellDepends = [ base containers data-default-class ];
           doHaddock = false;
           doCheck = false;
           description = "Default instances for types in containers";
           license = stdenv.lib.licenses.bsd3;
         }) {};
      "data-default-instances-dlist" = callPackage
        ({ mkDerivation, base, data-default-class, dlist, stdenv }:
         mkDerivation {
           pname = "data-default-instances-dlist";
           version = "0.0.1";
           sha256 = "7d683711cbf08abd7adcd5ac2be825381308d220397315a5570fe61b719b5959";
           libraryHaskellDepends = [ base data-default-class dlist ];
           doHaddock = false;
           doCheck = false;
           description = "Default instances for types in dlist";
           license = stdenv.lib.licenses.bsd3;
         }) {};
      "data-default-instances-old-locale" = callPackage
        ({ mkDerivation, base, data-default-class, old-locale, stdenv }:
         mkDerivation {
           pname = "data-default-instances-old-locale";
           version = "0.0.1";
           sha256 = "60d3b02922958c4908d7bf2b24ddf61511665745f784227d206745784b0c0802";
           libraryHaskellDepends = [ base data-default-class old-locale ];
           doHaddock = false;
           doCheck = false;
           description = "Default instances for types in old-locale";
           license = stdenv.lib.licenses.bsd3;
         }) {};
      "data-diverse" = callPackage
        ({ mkDerivation, base, containers, deepseq, ghc-prim, stdenv
         , tagged
         }:
         mkDerivation {
           pname = "data-diverse";
           version = "4.6.0.0";
           sha256 = "094d44446b2429bad5707b4aef0f1f63a9d101739d9a244cb2131f7646eccbd4";
           libraryHaskellDepends = [
             base containers deepseq ghc-prim tagged
           ];
           doHaddock = false;
           doCheck = false;
           homepage = "https://github.com/louispan/data-diverse#readme";
           description = "Extensible records and polymorphic variants";
           license = stdenv.lib.licenses.bsd3;
         }) {};
      "data-diverse-lens" = callPackage
        ({ mkDerivation, base, data-diverse, data-has, lens, profunctors
         , stdenv, tagged
         }:
         mkDerivation {
           pname = "data-diverse-lens";
           version = "4.3.0.0";
           sha256 = "97d049769f0a3693428bac8eb8de73e004f6fc9a1d0e3dc0c567f9d39f8ed986";
           libraryHaskellDepends = [
             base data-diverse data-has lens profunctors tagged
           ];
           doHaddock = false;
           doCheck = false;
           homepage = "https://github.com/louispan/data-diverse-lens#readme";
           description = "Isos & Lens for Data.Diverse.Many and Prisms for Data.Diverse.Which";
           license = stdenv.lib.licenses.bsd3;
         }) {};
      "data-dword" = callPackage
        ({ mkDerivation, base, data-bword, ghc-prim, hashable, stdenv
         , template-haskell
         }:
         mkDerivation {
           pname = "data-dword";
           version = "0.3.1.2";
           sha256 = "6b677600221de86eaee21dd2d4c23c04320370c594a56f7bb3477ef4e4b69120";
           libraryHaskellDepends = [
             base data-bword ghc-prim hashable template-haskell
           ];
           doHaddock = false;
           doCheck = false;
           homepage = "https://github.com/mvv/data-dword";
           description = "Stick two binary words together to get a bigger one";
           license = stdenv.lib.licenses.bsd3;
         }) {};
      "data-endian" = callPackage
        ({ mkDerivation, base, stdenv }:
         mkDerivation {
           pname = "data-endian";
           version = "0.1.1";
           sha256 = "8c1d4f30374f8331d31f4d7c6b39284331b6b9436e7b50f86547417bd05f2ac0";
           libraryHaskellDepends = [ base ];
           doHaddock = false;
           doCheck = false;
           homepage = "https://github.com/mvv/data-endian";
           description = "Endian-sensitive data";
           license = stdenv.lib.licenses.bsd3;
         }) {};
      "data-fix" = callPackage
        ({ mkDerivation, base, stdenv }:
         mkDerivation {
           pname = "data-fix";
           version = "0.2.0";
           sha256 = "7e5718055cb27ccac1e0bf25be70ba9bfe2b0d021cfe0a57a163355830341392";
           libraryHaskellDepends = [ base ];
           doHaddock = false;
           doCheck = false;
           homepage = "https://github.com/anton-k/data-fix";
           description = "Fixpoint data types";
           license = stdenv.lib.licenses.bsd3;
         }) {};
      "data-has" = callPackage
        ({ mkDerivation, base, stdenv }:
         mkDerivation {
           pname = "data-has";
           version = "0.3.0.0";
           sha256 = "3c25d403605ecb196df53c8c8fb7829cd7b6a88e0ea04b88038602ba7faa7379";
           libraryHaskellDepends = [ base ];
           doHaddock = false;
           doCheck = false;
           homepage = "https://github.com/winterland1989/data-has";
           description = "Simple extensible product";
           license = stdenv.lib.licenses.bsd3;
         }) {};
      "data-hash" = callPackage
        ({ mkDerivation, array, base, containers, stdenv }:
         mkDerivation {
           pname = "data-hash";
           version = "0.2.0.1";
           sha256 = "9117dd49013ca28ff188fc71c3595ac3af23d56d301c1f39bac93d44d8c60bbe";
           libraryHaskellDepends = [ array base containers ];
           doHaddock = false;
           doCheck = false;
           description = "Combinators for building fast hashing functions";
           license = stdenv.lib.licenses.bsd3;
         }) {};
      "data-inttrie" = callPackage
        ({ mkDerivation, base, stdenv }:
         mkDerivation {
           pname = "data-inttrie";
           version = "0.1.4";
           sha256 = "6b3a7d8d49b0676c09486ac08107b0e5a6dfd66d9627443be440e9fd11e7bd54";
           libraryHaskellDepends = [ base ];
           doHaddock = false;
           doCheck = false;
           homepage = "https://github.com/luqui/data-inttrie";
           description = "A simple lazy, infinite trie from integers";
           license = stdenv.lib.licenses.bsd3;
         }) {};
      "data-lens-light" = callPackage
        ({ mkDerivation, base, mtl, stdenv, template-haskell }:
         mkDerivation {
           pname = "data-lens-light";
           version = "0.1.2.2";
           sha256 = "72d3e6a73bde4a32eccd2024eb58ca96da962d4b659d76baed4ab37f28dcb36e";
           libraryHaskellDepends = [ base mtl template-haskell ];
           doHaddock = false;
           doCheck = false;
           homepage = "https://github.com/feuerbach/data-lens-light";
           description = "Simple lenses, minimum dependencies";
           license = stdenv.lib.licenses.mit;
         }) {};
      "data-memocombinators" = callPackage
        ({ mkDerivation, array, base, data-inttrie, stdenv }:
         mkDerivation {
           pname = "data-memocombinators";
           version = "0.5.1";
           sha256 = "b4341d2024b84a43f92edc39f6d6766bf4f0f00a40fd834b9f6f8e987b606ed7";
           libraryHaskellDepends = [ array base data-inttrie ];
           doHaddock = false;
           doCheck = false;
           homepage = "http://github.com/luqui/data-memocombinators";
           description = "Combinators for building memo tables";
           license = stdenv.lib.licenses.bsd3;
         }) {};
      "data-msgpack" = callPackage
        ({ mkDerivation, base, binary, bytestring, data-binary-ieee754
         , data-msgpack-types, groom, stdenv, text
         }:
         mkDerivation {
           pname = "data-msgpack";
           version = "0.0.12";
           sha256 = "5c9f8b04fbc30368e0a085de2c33e08cb0601fc9e95f767c38435d5a0ce1f487";
           isLibrary = true;
           isExecutable = true;
           libraryHaskellDepends = [
             base binary bytestring data-binary-ieee754 data-msgpack-types text
           ];
           executableHaskellDepends = [ base bytestring groom ];
           doHaddock = false;
           doCheck = false;
           homepage = "http://msgpack.org/";
           description = "A Haskell implementation of MessagePack";
           license = stdenv.lib.licenses.bsd3;
         }) {};
      "data-msgpack-types" = callPackage
        ({ mkDerivation, base, bytestring, containers, deepseq, hashable
         , QuickCheck, stdenv, text, unordered-containers, vector, void
         }:
         mkDerivation {
           pname = "data-msgpack-types";
           version = "0.0.2";
           sha256 = "54fdda1fa485c9f86f1f0f2aa8cc71d111b2f36504b7fb9c0a2de95c0b1287a5";
           libraryHaskellDepends = [
             base bytestring containers deepseq hashable QuickCheck text
             unordered-containers vector void
           ];
           doHaddock = false;
           doCheck = false;
           homepage = "http://msgpack.org/";
           description = "A Haskell implementation of MessagePack";
           license = stdenv.lib.licenses.bsd3;
         }) {};
      "data-or" = callPackage
        ({ mkDerivation, base, stdenv }:
         mkDerivation {
           pname = "data-or";
           version = "1.0.0.5";
           sha256 = "9defb64f1c7210460a940beb7f32ba1c79f363fbf3a5bd126feb876930c6e672";
           libraryHaskellDepends = [ base ];
           doHaddock = false;
           doCheck = false;
           homepage = "http://code.haskell.org/~wren/";
           description = "A data type for non-exclusive disjunction";
           license = stdenv.lib.licenses.bsd3;
         }) {};
      "data-ordlist" = callPackage
        ({ mkDerivation, base, stdenv }:
         mkDerivation {
           pname = "data-ordlist";
           version = "0.4.7.0";
           sha256 = "6f6c1e7a9a9155ad78ca78cb9abd6f7e2e1c78b3e549b179dc0874e6428f490d";
           libraryHaskellDepends = [ base ];
           doHaddock = false;
           doCheck = false;
           description = "Set and bag operations on ordered lists";
           license = stdenv.lib.licenses.bsd3;
         }) {};
      "data-ref" = callPackage
        ({ mkDerivation, base, stdenv, stm, transformers }:
         mkDerivation {
           pname = "data-ref";
           version = "0.0.1.2";
           sha256 = "605cf65aa01f93a5834305001056b2206a95830e25b7f969b34c9479a7e42621";
           libraryHaskellDepends = [ base stm transformers ];
           doHaddock = false;
           doCheck = false;
           homepage = "http://wiki.haskell.org/Mutable_variable";
           description = "Unify STRef and IORef in plain Haskell 98";
           license = stdenv.lib.licenses.bsd3;
         }) {};
      "data-reify" = callPackage
        ({ mkDerivation, base, containers, stdenv }:
         mkDerivation {
           pname = "data-reify";
           version = "0.6.1";
           sha256 = "61350a1e96cb1276c2b6b8b13fa1bade5d4e63c702509a3f5e90bbc19ad9b202";
           revision = "1";
           editedCabalFile = "0ixlibqrz7fd4bg9vnnd431a9kqvz4ajx8sbgyvpx9l2yjrabwzp";
           isLibrary = true;
           isExecutable = true;
           libraryHaskellDepends = [ base containers ];
           doHaddock = false;
           doCheck = false;
           homepage = "http://ku-fpg.github.io/software/data-reify/";
           description = "Reify a recursive data structure into an explicit graph";
           license = stdenv.lib.licenses.bsd3;
         }) {};
      "data-serializer" = callPackage
        ({ mkDerivation, base, binary, bytestring, cereal, data-endian
         , parsers, semigroups, split, stdenv
         }:
         mkDerivation {
           pname = "data-serializer";
           version = "0.3.4";
           sha256 = "e793156aa2262ca294183a9d045f37e6ff2070825b40d2ffe5a8d64e0b455ec6";
           libraryHaskellDepends = [
             base binary bytestring cereal data-endian parsers semigroups split
           ];
           doHaddock = false;
           doCheck = false;
           homepage = "https://github.com/mvv/data-serializer";
           description = "Common API for serialization libraries";
           license = stdenv.lib.licenses.bsd3;
         }) {};
      "data-textual" = callPackage
        ({ mkDerivation, base, bytestring, parsers, stdenv, text
         , text-latin1, text-printer
         }:
         mkDerivation {
           pname = "data-textual";
           version = "0.3.0.2";
           sha256 = "44c530b081a486c50d668004637814223d1f1890716d39f7b692c83644d29830";
           libraryHaskellDepends = [
             base bytestring parsers text text-latin1 text-printer
           ];
           doHaddock = false;
           doCheck = false;
           homepage = "https://github.com/mvv/data-textual";
           description = "Human-friendly textual representations";
           license = stdenv.lib.licenses.bsd3;
         }) {};
      "data-tree-print" = callPackage
        ({ mkDerivation, base, pretty, stdenv, syb }:
         mkDerivation {
           pname = "data-tree-print";
           version = "0.1.0.2";
           sha256 = "c3ef24d803946a3caf0ff0e51f0c0b9f49055d7dc790518ad518d568d5195002";
           libraryHaskellDepends = [ base pretty syb ];
           doHaddock = false;
           doCheck = false;
           homepage = "https://github.com/lspitzner/data-tree-print";
           description = "Print Data instances as a nested tree";
           license = stdenv.lib.licenses.bsd3;
         }) {};
      "datadog" = callPackage
        ({ mkDerivation, aeson, auto-update, base, buffer-builder
         , bytestring, containers, dlist, http-client, http-client-tls
         , http-types, lens, lifted-base, monad-control, network, old-locale
         , stdenv, text, time, transformers-base, unliftio
         , unordered-containers, vector
         }:
         mkDerivation {
           pname = "datadog";
           version = "0.2.3.0";
           sha256 = "9bb5eda1c704261160e0714499eef8c03dc2dd4d8673ad085e80c164445c1934";
           libraryHaskellDepends = [
             aeson auto-update base buffer-builder bytestring containers dlist
             http-client http-client-tls http-types lens lifted-base
             monad-control network old-locale text time transformers-base
             unliftio unordered-containers vector
           ];
           doHaddock = false;
           doCheck = false;
           homepage = "https://github.com/iand675/datadog";
           description = "Datadog client for Haskell. Supports both the HTTP API and StatsD.";
           license = stdenv.lib.licenses.mit;
         }) {};
      "datasets" = callPackage
        ({ mkDerivation, aeson, attoparsec, base, bytestring, cassava
         , directory, file-embed, filepath, hashable, microlens, stdenv
         , stringsearch, text, time, vector, wreq
         }:
         mkDerivation {
           pname = "datasets";
           version = "0.2.5";
           sha256 = "9a9139130936102bbfa60324e1ed7f9fd5b9a68db096917f589e8bb07999fdba";
           revision = "1";
           editedCabalFile = "1q96bxn8cjzr3pnygxz1s7bjk40l9kkxji9w4hxjbl3qh1m2i1sw";
           libraryHaskellDepends = [
             aeson attoparsec base bytestring cassava directory file-embed
             filepath hashable microlens stringsearch text time vector wreq
           ];
           doHaddock = false;
           doCheck = false;
           homepage = "https://github.com/diffusionkinetics/open/datasets";
           description = "Classical data sets for statistics and machine learning";
           license = stdenv.lib.licenses.mit;
         }) {};
      "dataurl" = callPackage
        ({ mkDerivation, attoparsec, base, base64-bytestring, bytestring
         , stdenv, text
         }:
         mkDerivation {
           pname = "dataurl";
           version = "0.1.0.0";
           sha256 = "b1e72b48dbe72520f0b43b06ae75cb025e9750213982583f527e16b605660fb2";
           libraryHaskellDepends = [
             attoparsec base base64-bytestring bytestring text
           ];
           doHaddock = false;
           doCheck = false;
           homepage = "http://github.com/agrafix/dataurl#readme";
           description = "Handle data-urls";
           license = stdenv.lib.licenses.mit;
         }) {};
      "dawg-ord" = callPackage
        ({ mkDerivation, base, containers, mtl, stdenv, transformers
         , vector
         }:
         mkDerivation {
           pname = "dawg-ord";
           version = "0.5.1.0";
           sha256 = "d9129acfb71ce41b6994d2c72a040319fc85af408226122d3958d5617e8922e9";
           libraryHaskellDepends = [
             base containers mtl transformers vector
           ];
           doHaddock = false;
           doCheck = false;
           homepage = "https://github.com/kawu/dawg-ord";
           description = "Directed acyclic word graphs";
           license = stdenv.lib.licenses.bsd3;
         }) {};
      "dbcleaner" = callPackage
        ({ mkDerivation, base, postgresql-simple, stdenv, text }:
         mkDerivation {
           pname = "dbcleaner";
           version = "0.1.3";
           sha256 = "0817b0e1698d8d48ac58d631f51dc6e34663f4e97af7bac3fd03e31349830f35";
           libraryHaskellDepends = [ base postgresql-simple text ];
           doHaddock = false;
           doCheck = false;
           description = "Clean database tables automatically around hspec tests";
           license = stdenv.lib.licenses.mit;
         }) {};
      "dbus" = callPackage
        ({ mkDerivation, base, bytestring, cereal, containers, deepseq
         , filepath, lens, libxml-sax, network, parsec, random, split
         , stdenv, template-haskell, text, th-lift, transformers, unix
         , vector, xml-types
         }:
         mkDerivation {
           pname = "dbus";
           version = "1.0.1";
           sha256 = "a325b5c6958a343b30fd378d54ac01f9db889a4d7cadb14b2103da7ef4e7e8f5";
           revision = "2";
           editedCabalFile = "0fskpis9ryzj4bkzjh9h2hdw2lwr38qjh74drazfq25w5ba2zj3j";
           libraryHaskellDepends = [
             base bytestring cereal containers deepseq filepath lens libxml-sax
             network parsec random split template-haskell text th-lift
             transformers unix vector xml-types
           ];
           doHaddock = false;
           doCheck = false;
           homepage = "https://github.com/rblaze/haskell-dbus#readme";
           description = "A client library for the D-Bus IPC system";
           license = stdenv.lib.licenses.asl20;
         }) {};
      "debian-build" = callPackage
        ({ mkDerivation, base, directory, filepath, process, split, stdenv
         , transformers
         }:
         mkDerivation {
           pname = "debian-build";
           version = "0.10.1.2";
           sha256 = "1cd3b5f099f0d26d0f14e2611b11b6599e4fad4cc217b88b61d1e478d3ec1641";
           isLibrary = true;
           isExecutable = true;
           libraryHaskellDepends = [
             base directory filepath process split transformers
           ];
           executableHaskellDepends = [ base filepath transformers ];
           doHaddock = false;
           doCheck = false;
           homepage = "http://twitter.com/khibino/";
           description = "Debian package build sequence tools";
           license = stdenv.lib.licenses.bsd3;
         }) {};
      "debug" = callPackage
        ({ mkDerivation, aeson, base, bytestring, clock, containers
         , deepseq, directory, extra, filepath, ghc-prim, hashable, Hoed
         , libgraph, open-browser, prettyprinter
         , prettyprinter-compat-ansi-wl-pprint, stdenv, template-haskell
         , text, uniplate, unordered-containers, vector, yaml
         }:
         mkDerivation {
           pname = "debug";
           version = "0.1.1";
           sha256 = "330f44c6341833c5e0cccf08fa7674dd54f14a843a2b5703e25ce08ffed49248";
           isLibrary = true;
           isExecutable = true;
           enableSeparateDataOutput = true;
           libraryHaskellDepends = [
             aeson base bytestring clock containers deepseq directory extra
             ghc-prim hashable Hoed libgraph open-browser prettyprinter
             prettyprinter-compat-ansi-wl-pprint template-haskell text uniplate
             unordered-containers vector
           ];
           executableHaskellDepends = [ aeson base directory filepath yaml ];
           doHaddock = false;
           doCheck = false;
           homepage = "https://github.com/ndmitchell/debug";
           description = "Simple trace-based debugger";
           license = stdenv.lib.licenses.bsd3;
         }) {};
      "debug-trace-var" = callPackage
        ({ mkDerivation, base, stdenv, template-haskell, unicode-show }:
         mkDerivation {
           pname = "debug-trace-var";
           version = "0.2.0";
           sha256 = "174f79d31d905c99adc880dd79899b3f335e1a7c552a7bcff8664abbffb6b489";
           libraryHaskellDepends = [ base template-haskell unicode-show ];
           doHaddock = false;
           doCheck = false;
           homepage = "https://github.com/ncaq/debug-trace-var#readme";
           description = "You do not have to write variable names twice in Debug.Trace";
           license = stdenv.lib.licenses.mit;
         }) {};
      "declarative" = callPackage
        ({ mkDerivation, base, hasty-hamiltonian, kan-extensions, lens
         , mcmc-types, mighty-metropolis, mwc-probability, pipes, primitive
         , speedy-slice, stdenv, transformers
         }:
         mkDerivation {
           pname = "declarative";
           version = "0.5.2";
           sha256 = "1ea8cf5eb0283ed9d9a7e1d46e5386960587c1671f7ce568d6eaf1d1b8ba9a04";
           libraryHaskellDepends = [
             base hasty-hamiltonian kan-extensions lens mcmc-types
             mighty-metropolis mwc-probability pipes primitive speedy-slice
             transformers
           ];
           doHaddock = false;
           doCheck = false;
           homepage = "http://github.com/jtobin/declarative";
           description = "DIY Markov Chains";
           license = stdenv.lib.licenses.mit;
         }) {};
      "deepseq-generics" = callPackage
        ({ mkDerivation, base, deepseq, ghc-prim, stdenv }:
         mkDerivation {
           pname = "deepseq-generics";
           version = "0.2.0.0";
           sha256 = "b0b3ef5546c0768ef9194519a90c629f8f2ba0348487e620bb89d512187c7c9d";
           revision = "3";
           editedCabalFile = "0734x6dm7ny1422n5ik4agzmjybvd3yybj1mnrc8z0kb89xdprcs";
           libraryHaskellDepends = [ base deepseq ghc-prim ];
           doHaddock = false;
           doCheck = false;
           homepage = "https://github.com/hvr/deepseq-generics";
           description = "GHC.Generics-based Control.DeepSeq.rnf implementation";
           license = stdenv.lib.licenses.bsd3;
         }) {};
      "dejafu" = callPackage
        ({ mkDerivation, base, concurrency, containers, contravariant
         , deepseq, exceptions, leancheck, profunctors, random, stdenv
         , transformers
         }:
         mkDerivation {
           pname = "dejafu";
           version = "1.11.0.4";
           sha256 = "af25f89cf243d3ccd038f7e9c9d52fc462061587fa05852b7a9e36db70257a7e";
           libraryHaskellDepends = [
             base concurrency containers contravariant deepseq exceptions
             leancheck profunctors random transformers
           ];
           doHaddock = false;
           doCheck = false;
           homepage = "https://github.com/barrucadu/dejafu";
           description = "A library for unit-testing concurrent programs";
           license = stdenv.lib.licenses.mit;
         }) {};
      "dependent-map" = callPackage
        ({ mkDerivation, base, containers, dependent-sum, stdenv }:
         mkDerivation {
           pname = "dependent-map";
           version = "0.2.4.0";
           sha256 = "5db396bdb5d156434af920c074316c3b84b4d39ba8e1cd349c7bb6679cb28246";
           libraryHaskellDepends = [ base containers dependent-sum ];
           doHaddock = false;
           doCheck = false;
           homepage = "https://github.com/mokus0/dependent-map";
           description = "Dependent finite maps (partial dependent products)";
           license = "unknown";
           hydraPlatforms = stdenv.lib.platforms.none;
         }) {};
      "dependent-sum" = callPackage
        ({ mkDerivation, base, stdenv }:
         mkDerivation {
           pname = "dependent-sum";
           version = "0.4";
           sha256 = "a8deecb4153a1878173f8d0a18de0378ab068bc15e5035b9e4cb478e8e4e1a1e";
           libraryHaskellDepends = [ base ];
           doHaddock = false;
           doCheck = false;
           homepage = "https://github.com/mokus0/dependent-sum";
           description = "Dependent sum type";
           license = stdenv.lib.licenses.publicDomain;
         }) {};
      "dependent-sum-template" = callPackage
        ({ mkDerivation, base, dependent-sum, stdenv, template-haskell
         , th-extras
         }:
         mkDerivation {
           pname = "dependent-sum-template";
           version = "0.0.0.6";
           sha256 = "994cb4891949cad1b9ca268052377c58c174f77a469cae44742ac83727be91ad";
           libraryHaskellDepends = [
             base dependent-sum template-haskell th-extras
           ];
           doHaddock = false;
           doCheck = false;
           homepage = "/dev/null";
           description = "Template Haskell code to generate instances of classes in dependent-sum package";
           license = stdenv.lib.licenses.publicDomain;
         }) {};
      "deque" = callPackage
        ({ mkDerivation, base, stdenv }:
         mkDerivation {
           pname = "deque";
           version = "0.2.1";
           sha256 = "019d197e306724f1a09ad53ab9309cee1cfbbf5456f2956d3ab52a59fe523264";
           libraryHaskellDepends = [ base ];
           doHaddock = false;
           doCheck = false;
           homepage = "https://github.com/nikita-volkov/deque";
           description = "Double-ended queue";
           license = stdenv.lib.licenses.mit;
         }) {};
      "deriving-compat" = callPackage
        ({ mkDerivation, base, containers, ghc-boot-th, ghc-prim, stdenv
         , template-haskell, th-abstraction, transformers
         , transformers-compat
         }:
         mkDerivation {
           pname = "deriving-compat";
           version = "0.5.2";
           sha256 = "495660f8b41bbb5ab372e2d393eaf57ba8ebd5d4f80b1477b2fd5caef875b240";
           revision = "1";
           editedCabalFile = "1s672vc7w96fmvr1p3fkqi9q80sn860j14545sskpxb8iz9f7sxg";
           libraryHaskellDepends = [
             base containers ghc-boot-th ghc-prim template-haskell
             th-abstraction transformers transformers-compat
           ];
           doHaddock = false;
           doCheck = false;
           homepage = "https://github.com/haskell-compat/deriving-compat";
           description = "Backports of GHC deriving extensions";
           license = stdenv.lib.licenses.bsd3;
         }) {};
      "derulo" = callPackage
        ({ mkDerivation, base, stdenv }:
         mkDerivation {
           pname = "derulo";
           version = "1.0.5";
           sha256 = "9ed69dd320fafe190d296ae24aaf4d1e85688cdb8240cf1fea187a0bb3a1cadf";
           isLibrary = true;
           isExecutable = true;
           libraryHaskellDepends = [ base ];
           executableHaskellDepends = [ base ];
           doHaddock = false;
           doCheck = false;
           homepage = "https://github.com/tfausak/derulo#readme";
           description = "Parse and render JSON simply";
           license = stdenv.lib.licenses.mit;
         }) {};
      "detour-via-sci" = callPackage
        ({ mkDerivation, aeson, base, cassava, newtype, scientific
         , siggy-chardust, stdenv, template-haskell
         }:
         mkDerivation {
           pname = "detour-via-sci";
           version = "1.0.0";
           sha256 = "451e1194f7bf6a7dea02379679c790313cc20423271fd8e98f164c942e3d81e4";
           revision = "1";
           editedCabalFile = "00dj8vf9gg9ww37sir6mblf3xhcpam8qgfz5bfana23arhf2cixj";
           libraryHaskellDepends = [
             aeson base cassava newtype scientific siggy-chardust
             template-haskell
           ];
           doHaddock = false;
           doCheck = false;
           homepage = "https://github.com/blockscope/flare-timing/tree/master/detour-via-sci#readme";
           description = "JSON and CSV encoding for rationals as decimal point numbers";
           license = stdenv.lib.licenses.mpl20;
         }) {};
      "df1" = callPackage
        ({ mkDerivation, attoparsec, base, bytestring, containers, stdenv
         , text, time
         }:
         mkDerivation {
           pname = "df1";
           version = "0.1.1";
           sha256 = "362409d7f47f69f9afc746b87c2380bc6d1536c1e9d1b8b77963b83504722fe3";
           libraryHaskellDepends = [
             attoparsec base bytestring containers text time
           ];
           doHaddock = false;
           doCheck = false;
           homepage = "https://github.com/k0001/di";
           description = "Type, render and parse the df1 hierarchical structured log format";
           license = stdenv.lib.licenses.bsd3;
         }) {};
      "dhall" = callPackage
        ({ mkDerivation, ansi-terminal, base, bytestring, case-insensitive
         , containers, contravariant, cryptonite, Diff, directory
         , exceptions, filepath, haskeline, http-client, http-client-tls
         , insert-ordered-containers, lens-family-core, megaparsec, memory
         , mtl, optparse-applicative, parsers, prettyprinter
         , prettyprinter-ansi-terminal, repline, scientific, stdenv
         , template-haskell, text, transformers, unordered-containers
         , vector
         }:
         mkDerivation {
           pname = "dhall";
           version = "1.15.1";
           sha256 = "ea3bb3b6a006b82e0286d72757ba9969f6ee292ef12eea2376939ba219c88e30";
           isLibrary = true;
           isExecutable = true;
           libraryHaskellDepends = [
             ansi-terminal base bytestring case-insensitive containers
             contravariant cryptonite Diff directory exceptions filepath
             haskeline http-client http-client-tls insert-ordered-containers
             lens-family-core megaparsec memory mtl optparse-applicative parsers
             prettyprinter prettyprinter-ansi-terminal repline scientific
             template-haskell text transformers unordered-containers vector
           ];
           executableHaskellDepends = [ base ];
           doHaddock = false;
           doCheck = false;
           description = "A configuration language guaranteed to terminate";
           license = stdenv.lib.licenses.bsd3;
         }) {};
      "dhall-bash" = callPackage
        ({ mkDerivation, base, bytestring, containers, dhall
         , insert-ordered-containers, neat-interpolation, optparse-generic
         , shell-escape, stdenv, text
         }:
         mkDerivation {
           pname = "dhall-bash";
           version = "1.0.15";
           sha256 = "045b8f405e9ace3ad3547727ed0de6cc7974d825f70e1447626a15dfe973af97";
           isLibrary = true;
           isExecutable = true;
           libraryHaskellDepends = [
             base bytestring containers dhall insert-ordered-containers
             neat-interpolation shell-escape text
           ];
           executableHaskellDepends = [
             base bytestring dhall optparse-generic text
           ];
           doHaddock = false;
           doCheck = false;
           description = "Compile Dhall to Bash";
           license = stdenv.lib.licenses.bsd3;
         }) {};
      "dhall-json" = callPackage
        ({ mkDerivation, aeson, aeson-pretty, base, bytestring, dhall
         , insert-ordered-containers, optparse-applicative, stdenv, text
         , unordered-containers, yaml
         }:
         mkDerivation {
           pname = "dhall-json";
           version = "1.2.3";
           sha256 = "83cb1e27f937c50ba6852eeb55ed3f06af8db9b73716bfa8c1326699482ffcda";
           revision = "1";
           editedCabalFile = "02zwka1vav66z3528hmhhlsnwmsi0haj4bhp7r57w2j877c25z2h";
           isLibrary = true;
           isExecutable = true;
           libraryHaskellDepends = [
             aeson base dhall insert-ordered-containers optparse-applicative
             text unordered-containers
           ];
           executableHaskellDepends = [
             aeson aeson-pretty base bytestring dhall optparse-applicative text
             yaml
           ];
           doHaddock = false;
           doCheck = false;
           description = "Compile Dhall to JSON or YAML";
           license = stdenv.lib.licenses.bsd3;
         }) {};
      "dhall-text" = callPackage
        ({ mkDerivation, base, dhall, optparse-applicative, stdenv, text }:
         mkDerivation {
           pname = "dhall-text";
           version = "1.0.14";
           sha256 = "5e9b8f8e6d9f711dab814be92392b9063ee1c8bc41c299d66278c0af1cb90591";
           isLibrary = false;
           isExecutable = true;
           executableHaskellDepends = [
             base dhall optparse-applicative text
           ];
           doHaddock = false;
           doCheck = false;
           description = "Template text using Dhall";
           license = stdenv.lib.licenses.bsd3;
         }) {};
      "di" = callPackage
        ({ mkDerivation, base, df1, di-core, di-df1, di-handle, di-monad
         , exceptions, stdenv
         }:
         mkDerivation {
           pname = "di";
           version = "1.0.1";
           sha256 = "2913ed3a7b8db8d9160a6aec510a35e5f8199c962c0e115f84c0c88d8236ec40";
           libraryHaskellDepends = [
             base df1 di-core di-df1 di-handle di-monad exceptions
           ];
           doHaddock = false;
           doCheck = false;
           homepage = "https://github.com/k0001/di";
           description = "Typeful hierarchical structured logging using di, mtl and df1";
           license = stdenv.lib.licenses.bsd3;
         }) {};
      "di-core" = callPackage
        ({ mkDerivation, base, containers, safe-exceptions, stdenv, stm
         , time
         }:
         mkDerivation {
           pname = "di-core";
           version = "1.0.3";
           sha256 = "f0900e071c6a4fd99ac5588b1801333bcd50aa73a212222b29c731494d52dfe5";
           libraryHaskellDepends = [
             base containers safe-exceptions stm time
           ];
           doHaddock = false;
           doCheck = false;
           homepage = "https://github.com/k0001/di";
           description = "Typeful hierarchical structured logging without monad towers";
           license = stdenv.lib.licenses.bsd3;
         }) {};
      "di-df1" = callPackage
        ({ mkDerivation, base, df1, di-core, di-handle, di-monad, stdenv
         , stm
         }:
         mkDerivation {
           pname = "di-df1";
           version = "1.0.2";
           sha256 = "d0518d17165c6f9baa60772526f263b11128a17edd1f214c91f0e42aad11b3c6";
           libraryHaskellDepends = [
             base df1 di-core di-handle di-monad stm
           ];
           doHaddock = false;
           doCheck = false;
           homepage = "https://github.com/k0001/di";
           description = "Write logs in the df1 format using the di logging framework";
           license = stdenv.lib.licenses.bsd3;
         }) {};
      "di-handle" = callPackage
        ({ mkDerivation, base, bytestring, di-core, exceptions, stdenv
         , unix
         }:
         mkDerivation {
           pname = "di-handle";
           version = "1.0";
           sha256 = "cd081f53824a173b30550ae9dbea744a2e7ac8931092d1f1b246b9bd5bb092ec";
           libraryHaskellDepends = [
             base bytestring di-core exceptions unix
           ];
           doHaddock = false;
           doCheck = false;
           homepage = "https://github.com/k0001/di";
           description = "IO support for file handles in di-core";
           license = stdenv.lib.licenses.bsd3;
         }) {};
      "di-monad" = callPackage
        ({ mkDerivation, base, containers, di-core, exceptions, mtl, pipes
         , stdenv, stm, transformers
         }:
         mkDerivation {
           pname = "di-monad";
           version = "1.0.2";
           sha256 = "b84d79e180778720b6aa31bf5e7f72db809378f92c97c391828639c876164ee8";
           libraryHaskellDepends = [
             base containers di-core exceptions mtl pipes stm transformers
           ];
           doHaddock = false;
           doCheck = false;
           homepage = "https://github.com/k0001/di";
           description = "mtl flavoured typeful hierarchical structured logging for di-core";
           license = stdenv.lib.licenses.bsd3;
         }) {};
      "diagrams" = callPackage
        ({ mkDerivation, diagrams-contrib, diagrams-core, diagrams-lib
         , diagrams-svg, stdenv
         }:
         mkDerivation {
           pname = "diagrams";
           version = "1.4";
           sha256 = "8608f6fa682b8c43b9fbe7c42c033c7a6de0680bd7383f6a81ea8bca37999139";
           libraryHaskellDepends = [
             diagrams-contrib diagrams-core diagrams-lib diagrams-svg
           ];
           doHaddock = false;
           doCheck = false;
           homepage = "http://projects.haskell.org/diagrams";
           description = "Embedded domain-specific language for declarative vector graphics";
           license = stdenv.lib.licenses.bsd3;
         }) {};
      "diagrams-builder" = callPackage
        ({ mkDerivation, base, base-orphans, bytestring, cmdargs
         , diagrams-cairo, diagrams-lib, diagrams-postscript
         , diagrams-rasterific, diagrams-svg, directory, exceptions
         , filepath, hashable, haskell-src-exts, haskell-src-exts-simple
         , hint, JuicyPixels, lens, mtl, split, stdenv, svg-builder
         , transformers
         }:
         mkDerivation {
           pname = "diagrams-builder";
           version = "0.8.0.3";
           sha256 = "3a80ac090b73838de3d2a9d006d128cb7903852b2f8df24db30855f729b30abd";
           revision = "1";
           editedCabalFile = "0cdnriavw7y0cr12n60vd0hwcyi09vkx5zjr47af3bj00lq1v9hk";
           configureFlags = [ "-fcairo" "-fps" "-frasterific" "-fsvg" ];
           isLibrary = true;
           isExecutable = true;
           libraryHaskellDepends = [
             base base-orphans cmdargs diagrams-lib directory exceptions
             filepath hashable haskell-src-exts haskell-src-exts-simple hint
             lens mtl split transformers
           ];
           executableHaskellDepends = [
             base bytestring cmdargs diagrams-cairo diagrams-lib
             diagrams-postscript diagrams-rasterific diagrams-svg directory
             filepath JuicyPixels lens svg-builder
           ];
           doHaddock = false;
           doCheck = false;
           homepage = "http://projects.haskell.org/diagrams";
           description = "hint-based build service for the diagrams graphics EDSL";
           license = stdenv.lib.licenses.bsd3;
         }) {};
      "diagrams-cairo" = callPackage
        ({ mkDerivation, array, base, bytestring, cairo, colour, containers
         , data-default-class, diagrams-core, diagrams-lib, filepath
         , hashable, JuicyPixels, lens, mtl, optparse-applicative, pango
         , split, statestack, stdenv, transformers, unix, vector
         }:
         mkDerivation {
           pname = "diagrams-cairo";
           version = "1.4.1";
           sha256 = "df64fd41f4c8eb37e2edcc458c4d49c574d22cf7ca2ef7ceb5de4a79f6436658";
           revision = "1";
           editedCabalFile = "0irrv1mf7lz3n4dy5pz9y6kw00v1rly47g2g6hi95nj6a6hib3z0";
           libraryHaskellDepends = [
             array base bytestring cairo colour containers data-default-class
             diagrams-core diagrams-lib filepath hashable JuicyPixels lens mtl
             optparse-applicative pango split statestack transformers unix
             vector
           ];
           doHaddock = false;
           doCheck = false;
           homepage = "http://projects.haskell.org/diagrams";
           description = "Cairo backend for diagrams drawing EDSL";
           license = stdenv.lib.licenses.bsd3;
         }) {};
      "diagrams-canvas" = callPackage
        ({ mkDerivation, base, blank-canvas, cmdargs, containers
         , data-default-class, diagrams-core, diagrams-lib, lens, mtl
         , NumInstances, optparse-applicative, statestack, stdenv, text
         }:
         mkDerivation {
           pname = "diagrams-canvas";
           version = "1.4.1";
           sha256 = "92def277f039ab95428bb3339f66e6068dd6c1699f24a4c76ca8894004d915c6";
           libraryHaskellDepends = [
             base blank-canvas cmdargs containers data-default-class
             diagrams-core diagrams-lib lens mtl NumInstances
             optparse-applicative statestack text
           ];
           doHaddock = false;
           doCheck = false;
           homepage = "http://projects.haskell.org/diagrams/";
           description = "HTML5 canvas backend for diagrams drawing EDSL";
           license = stdenv.lib.licenses.bsd3;
         }) {};
      "diagrams-contrib" = callPackage
        ({ mkDerivation, base, circle-packing, colour, containers
         , cubicbezier, data-default, data-default-class, diagrams-core
         , diagrams-lib, diagrams-solve, force-layout, hashable, lens
         , linear, mfsolve, MonadRandom, monoid-extras, mtl, mtl-compat
         , parsec, random, semigroups, split, stdenv, text
         }:
         mkDerivation {
           pname = "diagrams-contrib";
           version = "1.4.3";
           sha256 = "65fba87bb7752b1053fb3ab8e4ae30d5920208ff48441c4d8969cdbe73402007";
           revision = "3";
           editedCabalFile = "0mm1mmagx6q8g6dxk1cagqka38z6393ihp0lvf6095prlvidasqs";
           libraryHaskellDepends = [
             base circle-packing colour containers cubicbezier data-default
             data-default-class diagrams-core diagrams-lib diagrams-solve
             force-layout hashable lens linear mfsolve MonadRandom monoid-extras
             mtl mtl-compat parsec random semigroups split text
           ];
           doHaddock = false;
           doCheck = false;
           homepage = "http://projects.haskell.org/diagrams/";
           description = "Collection of user contributions to diagrams EDSL";
           license = stdenv.lib.licenses.bsd3;
         }) {};
      "diagrams-core" = callPackage
        ({ mkDerivation, adjunctions, base, containers, distributive
         , dual-tree, lens, linear, monoid-extras, mtl, profunctors
         , semigroups, stdenv, unordered-containers
         }:
         mkDerivation {
           pname = "diagrams-core";
           version = "1.4.1.1";
           sha256 = "a182e9f99e3664efdfa5e18f4b403703112fba33c5b877a91c9eabed1d8bb682";
           revision = "2";
           editedCabalFile = "1lf7xcq42l4hjksgp1nhj7600shvw9q5a27bh729fyfphmvv3xkf";
           libraryHaskellDepends = [
             adjunctions base containers distributive dual-tree lens linear
             monoid-extras mtl profunctors semigroups unordered-containers
           ];
           doHaddock = false;
           doCheck = false;
           homepage = "http://projects.haskell.org/diagrams";
           description = "Core libraries for diagrams EDSL";
           license = stdenv.lib.licenses.bsd3;
         }) {};
      "diagrams-gtk" = callPackage
        ({ mkDerivation, base, cairo, diagrams-cairo, diagrams-lib, gtk
         , stdenv
         }:
         mkDerivation {
           pname = "diagrams-gtk";
           version = "1.4";
           sha256 = "b66bde621a09b79b99185af50b2d1ed0b2bd3988c95ed27c7e92e5383917eae9";
           revision = "2";
           editedCabalFile = "0hblrqvwk1pbssaci97v36r71kpm7kkcghh5ijmq52lmjfq72jqm";
           libraryHaskellDepends = [
             base cairo diagrams-cairo diagrams-lib gtk
           ];
           doHaddock = false;
           doCheck = false;
           homepage = "http://projects.haskell.org/diagrams/";
           description = "Backend for rendering diagrams directly to GTK windows";
           license = stdenv.lib.licenses.bsd3;
         }) {};
      "diagrams-html5" = callPackage
        ({ mkDerivation, base, cmdargs, containers, data-default-class
         , diagrams-core, diagrams-lib, lens, mtl, NumInstances
         , optparse-applicative, split, statestack, static-canvas, stdenv
         , text
         }:
         mkDerivation {
           pname = "diagrams-html5";
           version = "1.4.1";
           sha256 = "e8eed3f8ae1176099c96806281262227618d9e9f40512a430fc9379af44ce96e";
           libraryHaskellDepends = [
             base cmdargs containers data-default-class diagrams-core
             diagrams-lib lens mtl NumInstances optparse-applicative split
             statestack static-canvas text
           ];
           doHaddock = false;
           doCheck = false;
           homepage = "http://projects.haskell.org/diagrams/";
           description = "HTML5 canvas backend for diagrams drawing EDSL";
           license = stdenv.lib.licenses.bsd3;
         }) {};
      "diagrams-lib" = callPackage
        ({ mkDerivation, active, adjunctions, array, base, bytestring
         , cereal, colour, containers, data-default-class, diagrams-core
         , diagrams-solve, directory, distributive, dual-tree, exceptions
         , filepath, fingertree, fsnotify, hashable, intervals, JuicyPixels
         , lens, linear, monoid-extras, mtl, optparse-applicative, process
         , profunctors, semigroups, stdenv, tagged, text, transformers
         , unordered-containers
         }:
         mkDerivation {
           pname = "diagrams-lib";
           version = "1.4.2.3";
           sha256 = "25a7adccbe3175cdb081a3824413ba431e561026c6ddd9a647cd133e4bfcbe9c";
           revision = "2";
           editedCabalFile = "0gn1lpsq1v9qpyhpizyknn3sfixg1b64s0dsl1jf25lz4kcrpbs7";
           libraryHaskellDepends = [
             active adjunctions array base bytestring cereal colour containers
             data-default-class diagrams-core diagrams-solve directory
             distributive dual-tree exceptions filepath fingertree fsnotify
             hashable intervals JuicyPixels lens linear monoid-extras mtl
             optparse-applicative process profunctors semigroups tagged text
             transformers unordered-containers
           ];
           doHaddock = false;
           doCheck = false;
           homepage = "http://projects.haskell.org/diagrams";
           description = "Embedded domain-specific language for declarative graphics";
           license = stdenv.lib.licenses.bsd3;
         }) {};
      "diagrams-postscript" = callPackage
        ({ mkDerivation, base, containers, data-default-class
         , diagrams-core, diagrams-lib, dlist, hashable, lens, monoid-extras
         , mtl, semigroups, split, statestack, stdenv
         }:
         mkDerivation {
           pname = "diagrams-postscript";
           version = "1.4.1";
           sha256 = "a758191d99c30bd663dc0df2dedef13cd735a33c143e77906aa88baceb282c9c";
           revision = "2";
           editedCabalFile = "0s6z3kaj1dm5kifaydnd2nx97g5qbc6jjqy3wn4dwa9rm7w49753";
           libraryHaskellDepends = [
             base containers data-default-class diagrams-core diagrams-lib dlist
             hashable lens monoid-extras mtl semigroups split statestack
           ];
           doHaddock = false;
           doCheck = false;
           homepage = "http://projects.haskell.org/diagrams/";
           description = "Postscript backend for diagrams drawing EDSL";
           license = stdenv.lib.licenses.bsd3;
         }) {};
      "diagrams-rasterific" = callPackage
        ({ mkDerivation, base, bytestring, containers, data-default-class
         , diagrams-core, diagrams-lib, file-embed, filepath, FontyFruity
         , hashable, JuicyPixels, lens, mtl, optparse-applicative
         , Rasterific, stdenv
         }:
         mkDerivation {
           pname = "diagrams-rasterific";
           version = "1.4.1.1";
           sha256 = "f72a87b421b1da874757256d9c9603c40fdad1f0a82be17bf1806820188a5365";
           enableSeparateDataOutput = true;
           libraryHaskellDepends = [
             base bytestring containers data-default-class diagrams-core
             diagrams-lib file-embed filepath FontyFruity hashable JuicyPixels
             lens mtl optparse-applicative Rasterific
           ];
           doHaddock = false;
           doCheck = false;
           homepage = "http://projects.haskell.org/diagrams/";
           description = "Rasterific backend for diagrams";
           license = stdenv.lib.licenses.bsd3;
         }) {};
      "diagrams-solve" = callPackage
        ({ mkDerivation, base, stdenv }:
         mkDerivation {
           pname = "diagrams-solve";
           version = "0.1.1";
           sha256 = "a41f5f410b10f162b1e5c07bd4ca3305544870ff1314ae4f5824c83a31644f9d";
           revision = "4";
           editedCabalFile = "1yjacw17ga4rh6iw70vclk03qm5xjw4y17c7m43gjw8h3cfaq15d";
           libraryHaskellDepends = [ base ];
           doHaddock = false;
           doCheck = false;
           homepage = "http://projects.haskell.org/diagrams";
           description = "Pure Haskell solver routines used by diagrams";
           license = stdenv.lib.licenses.bsd3;
         }) {};
      "diagrams-svg" = callPackage
        ({ mkDerivation, base, base64-bytestring, bytestring, colour
         , containers, diagrams-core, diagrams-lib, filepath, hashable
         , JuicyPixels, lens, monoid-extras, mtl, optparse-applicative
         , semigroups, split, stdenv, svg-builder, text
         }:
         mkDerivation {
           pname = "diagrams-svg";
           version = "1.4.2";
           sha256 = "5455b68d92826a5405d51490976870cc0fa5b8b56aef0a8f56982b5f48efded2";
           revision = "2";
           editedCabalFile = "15sn85xaachw4cj56w61bjcwrbf4qmnkfl8mbgdapxi5k0y4f2qv";
           libraryHaskellDepends = [
             base base64-bytestring bytestring colour containers diagrams-core
             diagrams-lib filepath hashable JuicyPixels lens monoid-extras mtl
             optparse-applicative semigroups split svg-builder text
           ];
           doHaddock = false;
           doCheck = false;
           homepage = "http://projects.haskell.org/diagrams/";
           description = "SVG backend for diagrams drawing EDSL";
           license = stdenv.lib.licenses.bsd3;
         }) {};
      "dictionary-sharing" = callPackage
        ({ mkDerivation, base, containers, stdenv }:
         mkDerivation {
           pname = "dictionary-sharing";
           version = "0.1.0.0";
           sha256 = "8c3b5184d5d6056433d51a49c5402e4ab7b0260073d5342685b8e141d2be5a01";
           revision = "3";
           editedCabalFile = "1mn7jcc7h3b8f1pn9zigqp6mc2n0qb66lms5qnrx4zswdv5w9439";
           libraryHaskellDepends = [ base containers ];
           doHaddock = false;
           doCheck = false;
           description = "Sharing/memoization of class members";
           license = stdenv.lib.licenses.bsd3;
         }) {};
      "digest" = callPackage
        ({ mkDerivation, base, bytestring, stdenv, zlib }:
         mkDerivation {
           pname = "digest";
           version = "0.0.1.2";
           sha256 = "641717eb16392abf8965986a9e8dc21eebf1d97775bbb6923c7b7f8fee17fe11";
           libraryHaskellDepends = [ base bytestring ];
           librarySystemDepends = [ zlib ];
           doHaddock = false;
           doCheck = false;
           description = "Various cryptographic hashes for bytestrings; CRC32 and Adler32 for now";
           license = stdenv.lib.licenses.bsd3;
         }) {inherit (pkgs) zlib;};
      "digits" = callPackage
        ({ mkDerivation, base, QuickCheck, stdenv }:
         mkDerivation {
           pname = "digits";
           version = "0.3.1";
           sha256 = "a8499c9745dcf8a4e6c48594f555e6c6276e8d91c457dcc562a370ccadcd6a2c";
           libraryHaskellDepends = [ base QuickCheck ];
           doHaddock = false;
           doCheck = false;
           description = "Converts integers to lists of digits and back";
           license = stdenv.lib.licenses.bsd3;
         }) {};
      "dimensional" = callPackage
        ({ mkDerivation, base, deepseq, exact-pi, ieee754, numtype-dk
         , semigroups, stdenv, vector
         }:
         mkDerivation {
           pname = "dimensional";
           version = "1.1";
           sha256 = "3a25889c1c67966a2739a9c1ccd040278c89e10823a1b2463fbf571b74075e16";
           revision = "2";
           editedCabalFile = "0922kd3svn96c1qg2lx3ya0xlrbll51csc18cnma0f8j899r4xgn";
           libraryHaskellDepends = [
             base deepseq exact-pi ieee754 numtype-dk semigroups vector
           ];
           doHaddock = false;
           doCheck = false;
           homepage = "https://github.com/bjornbm/dimensional/";
           description = "Statically checked physical dimensions, using Type Families and Data Kinds";
           license = stdenv.lib.licenses.bsd3;
         }) {};
      "direct-sqlite" = callPackage
        ({ mkDerivation, base, bytestring, semigroups, stdenv, text }:
         mkDerivation {
           pname = "direct-sqlite";
           version = "2.3.23";
           sha256 = "1fdb6f6ea34ac978e72f61a845786e4b4b945014ccc64ddb07ddcafa1254937b";
           libraryHaskellDepends = [ base bytestring semigroups text ];
           doHaddock = false;
           doCheck = false;
           homepage = "https://github.com/IreneKnapp/direct-sqlite";
           description = "Low-level binding to SQLite3. Includes UTF8 and BLOB support.";
           license = stdenv.lib.licenses.bsd3;
         }) {};
      "directory-tree" = callPackage
        ({ mkDerivation, base, directory, filepath, stdenv }:
         mkDerivation {
           pname = "directory-tree";
           version = "0.12.1";
           sha256 = "e2084495b3a226cf54d949635c86fc14e89daa09d86cce39e3c3cf898ae6e517";
           libraryHaskellDepends = [ base directory filepath ];
           doHaddock = false;
           doCheck = false;
           homepage = "http://brandon.si/code/directory-tree-module-released/";
           description = "A simple directory-like tree datatype, with useful IO functions";
           license = stdenv.lib.licenses.bsd3;
         }) {};
      "discount" = callPackage
        ({ mkDerivation, base, bytestring, markdown, stdenv, text }:
         mkDerivation {
           pname = "discount";
           version = "0.1.1";
           sha256 = "e99cb7fdd1896dd1e525616597f936c1305a657cea1ef82cc0b3dcfe5afa34e0";
           libraryHaskellDepends = [ base bytestring text ];
           librarySystemDepends = [ markdown ];
           doHaddock = false;
           doCheck = false;
           homepage = "http://github.com/lightquake/discount";
           description = "Haskell bindings to the discount Markdown library";
           license = stdenv.lib.licenses.mit;
         }) {inherit (pkgs) markdown;};
      "discrimination" = callPackage
        ({ mkDerivation, array, base, containers, contravariant, deepseq
         , ghc-prim, hashable, primitive, profunctors, promises, semigroups
         , stdenv, transformers, transformers-compat, vector, void
         }:
         mkDerivation {
           pname = "discrimination";
           version = "0.3";
           sha256 = "d6d4b285783e66446a8f798b3a440b1020bdc681285b05794d3ec84d96dc4ca3";
           revision = "1";
           editedCabalFile = "1p39vcdmv9k9wxlkh49w1dr1isvn2hvhjjbs95qwljpxca74i23g";
           libraryHaskellDepends = [
             array base containers contravariant deepseq ghc-prim hashable
             primitive profunctors promises semigroups transformers
             transformers-compat vector void
           ];
           doHaddock = false;
           doCheck = false;
           homepage = "http://github.com/ekmett/discrimination/";
           description = "Fast generic linear-time sorting, joins and container construction";
           license = stdenv.lib.licenses.bsd3;
         }) {};
      "disk-free-space" = callPackage
        ({ mkDerivation, base, stdenv }:
         mkDerivation {
           pname = "disk-free-space";
           version = "0.1.0.1";
           sha256 = "f17a4f9c3b41083ccbb6c11b2debdbc705f86097b7459ff0f46cc01d2692381f";
           revision = "3";
           editedCabalFile = "0x0wjycr3rhw9vcq51b4sz8cf7mcvx7whhywv72y25r9385lxb3i";
           libraryHaskellDepends = [ base ];
           doHaddock = false;
           doCheck = false;
           homepage = "https://github.com/redneb/disk-free-space";
           description = "Retrieve information about disk space usage";
           license = stdenv.lib.licenses.bsd3;
         }) {};
      "distributed-closure" = callPackage
        ({ mkDerivation, async, base, binary, bytestring, constraints
         , stdenv, syb, template-haskell
         }:
         mkDerivation {
           pname = "distributed-closure";
           version = "0.4.1";
           sha256 = "de4efea05ec685e9b5b087857ea3460a24d4314862e329279b99ca914b2e7ce6";
           isLibrary = true;
           isExecutable = true;
           libraryHaskellDepends = [
             base binary bytestring constraints syb template-haskell
           ];
           executableHaskellDepends = [ async base binary bytestring ];
           doHaddock = false;
           doCheck = false;
           homepage = "https://github.com/tweag/distributed-closure";
           description = "Serializable closures for distributed programming";
           license = stdenv.lib.licenses.bsd3;
         }) {};
      "distributed-static" = callPackage
        ({ mkDerivation, base, binary, bytestring, containers, deepseq
         , rank1dynamic, stdenv
         }:
         mkDerivation {
           pname = "distributed-static";
           version = "0.3.8";
           sha256 = "954bf65722b662794990c81ba31a7fdbccd9d233af9212896443aa5ab9d4ffc2";
           libraryHaskellDepends = [
             base binary bytestring containers deepseq rank1dynamic
           ];
           doHaddock = false;
           doCheck = false;
           homepage = "http://haskell-distributed.github.com";
           description = "Compositional, type-safe, polymorphic static values and closures";
           license = stdenv.lib.licenses.bsd3;
         }) {};
      "distribution-nixpkgs" = callPackage
        ({ mkDerivation, aeson, base, bytestring, Cabal, containers
         , deepseq, language-nix, lens, pretty, process, split, stdenv
         }:
         mkDerivation {
           pname = "distribution-nixpkgs";
           version = "1.1.1";
           sha256 = "55eb858a98995f4f2b2eec5fcbc44ba1901284e915ef5e18609e253a5a662499";
           libraryHaskellDepends = [
             aeson base bytestring Cabal containers deepseq language-nix lens
             pretty process split
           ];
           doHaddock = false;
           doCheck = false;
           homepage = "https://github.com/peti/distribution-nixpkgs#readme";
           description = "Types and functions to manipulate the Nixpkgs distribution";
           license = stdenv.lib.licenses.bsd3;
         }) {};
      "distributive" = callPackage
        ({ mkDerivation, base, base-orphans, Cabal, cabal-doctest, stdenv
         , tagged, transformers, transformers-compat
         }:
         mkDerivation {
           pname = "distributive";
           version = "0.5.3";
           sha256 = "9173805b9c941bda1f37e5aeb68ae30f57a12df9b17bd2aa86db3b7d5236a678";
           revision = "6";
           editedCabalFile = "06bd38rf31yrvvy989r44pm0id3dsxwcp6nxg7wk6ccj3n2b8rzk";
           setupHaskellDepends = [ base Cabal cabal-doctest ];
           libraryHaskellDepends = [
             base base-orphans tagged transformers transformers-compat
           ];
           doHaddock = false;
           doCheck = false;
           homepage = "http://github.com/ekmett/distributive/";
           description = "Distributive functors -- Dual to Traversable";
           license = stdenv.lib.licenses.bsd3;
         }) {};
      "dlist" = callPackage
        ({ mkDerivation, base, deepseq, stdenv }:
         mkDerivation {
           pname = "dlist";
           version = "0.8.0.5";
           sha256 = "98a88aa839b40d4aee8b08880030d282d627b63de311f5414dca6e831a951b43";
           revision = "1";
           editedCabalFile = "1jh8zw1vpx0ld4gmc4l0pqpgbl9frpgbyw9kvsr56bnz0v2rgqpx";
           libraryHaskellDepends = [ base deepseq ];
           doHaddock = false;
           doCheck = false;
           homepage = "https://github.com/spl/dlist";
           description = "Difference lists";
           license = stdenv.lib.licenses.bsd3;
         }) {};
      "dlist-instances" = callPackage
        ({ mkDerivation, base, dlist, semigroups, stdenv }:
         mkDerivation {
           pname = "dlist-instances";
           version = "0.1.1.1";
           sha256 = "d14a10c06f52fb412b2c1066d729f5534aa43204221e7ba7d81d935c44ce4f5b";
           libraryHaskellDepends = [ base dlist semigroups ];
           doHaddock = false;
           doCheck = false;
           homepage = "https://github.com/gregwebs/dlist-instances";
           description = "Difference lists instances";
           license = stdenv.lib.licenses.bsd3;
         }) {};
      "dlist-nonempty" = callPackage
        ({ mkDerivation, base, base-compat, deepseq, dlist, semigroupoids
         , stdenv
         }:
         mkDerivation {
           pname = "dlist-nonempty";
           version = "0.1.1";
           sha256 = "40e8a64c979ca07b4f67a38878d1d13c1127fe2d1ad6b2b4daff0ee2dbd54b33";
           revision = "5";
           editedCabalFile = "01x05d62y8f3kippxawra3fdr7jdms3zcgd7c4n8wf39np9wy556";
           libraryHaskellDepends = [
             base base-compat deepseq dlist semigroupoids
           ];
           doHaddock = false;
           doCheck = false;
           homepage = "https://github.com/phadej/dlist-nonempty";
           description = "Non-empty difference lists";
           license = stdenv.lib.licenses.bsd3;
         }) {};
      "dns" = callPackage
        ({ mkDerivation, async, attoparsec, auto-update, base
         , base64-bytestring, binary, bytestring, containers, cryptonite
         , iproute, mtl, network, psqueues, safe, stdenv, time
         }:
         mkDerivation {
           pname = "dns";
           version = "3.0.4";
           sha256 = "7b3433b536b7d225914d7b8495c7af1927d9554538d7d86c2644ccf9d3fa44a9";
           revision = "1";
           editedCabalFile = "15jafrm919w4p23m7kpmyc1yvzpy88jcccycc00dza69d119zjdr";
           libraryHaskellDepends = [
             async attoparsec auto-update base base64-bytestring binary
             bytestring containers cryptonite iproute mtl network psqueues safe
             time
           ];
           doHaddock = false;
           doCheck = false;
           testTarget = "spec";
           description = "DNS library in Haskell";
           license = stdenv.lib.licenses.bsd3;
         }) {};
      "do-list" = callPackage
        ({ mkDerivation, base, stdenv }:
         mkDerivation {
           pname = "do-list";
           version = "1.0.1";
           sha256 = "b377193461b0ad7a81f9e66bcf10f8838b6f1e39f4a5de3b2e2f45c749c5b694";
           libraryHaskellDepends = [ base ];
           doHaddock = false;
           doCheck = false;
           homepage = "https://github.com/tserduke/do-list#readme";
           description = "Do notation for free";
           license = stdenv.lib.licenses.bsd3;
         }) {};
      "docker" = callPackage
        ({ mkDerivation, aeson, base, blaze-builder, bytestring, conduit
         , conduit-combinators, conduit-extra, containers
         , data-default-class, directory, exceptions, filemanip, filepath
         , http-client, http-conduit, http-types, monad-control, mtl
         , network, resourcet, scientific, stdenv, tar, temporary, text
         , time, tls, transformers, transformers-base, unliftio-core
         , unordered-containers, uuid, vector, x509, x509-store, x509-system
         , zlib
         }:
         mkDerivation {
           pname = "docker";
           version = "0.6.0.0";
           sha256 = "4d3a00300abc09c2f9214f03d2d16fb51aa5b2f182aa6c4de69a3017e4b42045";
           libraryHaskellDepends = [
             aeson base blaze-builder bytestring conduit conduit-combinators
             conduit-extra containers data-default-class directory exceptions
             filemanip filepath http-client http-conduit http-types
             monad-control mtl network resourcet scientific tar temporary text
             time tls transformers transformers-base unliftio-core
             unordered-containers uuid vector x509 x509-store x509-system zlib
           ];
           doHaddock = false;
           doCheck = false;
           homepage = "https://github.com/denibertovic/docker-hs";
           description = "An API client for docker written in Haskell";
           license = stdenv.lib.licenses.bsd3;
         }) {};
      "dockerfile" = callPackage
        ({ mkDerivation, base, stdenv }:
         mkDerivation {
           pname = "dockerfile";
           version = "0.1.0.1";
           sha256 = "294ac0b6c0546da15bf5453d6006979aeb6f6b36f0566be75767f5021de00025";
           libraryHaskellDepends = [ base ];
           doHaddock = false;
           doCheck = false;
           description = "A simple DSL for describing and generating Dockerfile containers in Haskell";
           license = stdenv.lib.licenses.mit;
         }) {};
      "docopt" = callPackage
        ({ mkDerivation, base, containers, parsec, stdenv, template-haskell
         , th-lift
         }:
         mkDerivation {
           pname = "docopt";
           version = "0.7.0.5";
           sha256 = "15790808a4896bbf0748c1c0f3ab63c07aea4621d95b93a39886813f829d05ee";
           enableSeparateDataOutput = true;
           libraryHaskellDepends = [
             base containers parsec template-haskell th-lift
           ];
           doHaddock = false;
           doCheck = false;
           homepage = "https://github.com/docopt/docopt.hs";
           description = "A command-line interface parser that will make you smile";
           license = stdenv.lib.licenses.mit;
         }) {};
      "doctemplates" = callPackage
        ({ mkDerivation, aeson, base, blaze-html, blaze-markup, bytestring
         , containers, parsec, scientific, stdenv, text
         , unordered-containers, vector
         }:
         mkDerivation {
           pname = "doctemplates";
           version = "0.2.2.1";
           sha256 = "6b0cfb565fc7fa90d71ac56b83aedecf670678e6f1441278877fbf399e9bccbf";
           enableSeparateDataOutput = true;
           libraryHaskellDepends = [
             aeson base blaze-html blaze-markup bytestring containers parsec
             scientific text unordered-containers vector
           ];
           doHaddock = false;
           doCheck = false;
           homepage = "https://github.com/jgm/doctemplates#readme";
           description = "Pandoc-style document templates";
           license = stdenv.lib.licenses.bsd3;
         }) {};
      "doctest" = callPackage
        ({ mkDerivation, base, base-compat, code-page, deepseq, directory
         , filepath, ghc, ghc-paths, process, stdenv, syb, transformers
         }:
         mkDerivation {
           pname = "doctest";
           version = "0.16.0.1";
           sha256 = "9b5275497330607f66aaf2625b798b2ad566867fed3f52cea9de31a23361d780";
           isLibrary = true;
           isExecutable = true;
           libraryHaskellDepends = [
             base base-compat code-page deepseq directory filepath ghc ghc-paths
             process syb transformers
           ];
           executableHaskellDepends = [
             base base-compat code-page deepseq directory filepath ghc ghc-paths
             process syb transformers
           ];
           doHaddock = false;
           doCheck = false;
           homepage = "https://github.com/sol/doctest#readme";
           description = "Test interactive Haskell examples";
           license = stdenv.lib.licenses.mit;
         }) {};
      "doctest-discover" = callPackage
        ({ mkDerivation, aeson, base, bytestring, directory, doctest
         , filepath, stdenv
         }:
         mkDerivation {
           pname = "doctest-discover";
           version = "0.1.0.9";
           sha256 = "6790bb2df19b692131dca9f910a789884c2d4361a25f812f5bcb8803033799b2";
           isLibrary = true;
           isExecutable = true;
           libraryHaskellDepends = [
             aeson base bytestring directory doctest filepath
           ];
           executableHaskellDepends = [
             aeson base bytestring directory doctest filepath
           ];
           doHaddock = false;
           doCheck = false;
           homepage = "http://github.com/karun012/doctest-discover";
           description = "Easy way to run doctests via cabal";
           license = stdenv.lib.licenses.publicDomain;
         }) {};
      "doctest-driver-gen" = callPackage
        ({ mkDerivation, base, doctest, stdenv }:
         mkDerivation {
           pname = "doctest-driver-gen";
           version = "0.2.0.4";
           sha256 = "d986edd163e61911c71dd6611e23d0d872c2d11595736be1b3e4c07b01c57a71";
           isLibrary = true;
           isExecutable = true;
           libraryHaskellDepends = [ base doctest ];
           executableHaskellDepends = [ base ];
           doHaddock = false;
           doCheck = false;
           homepage = "https://github.com/Hexirp/doctest-driver-gen#readme";
           description = "Generate driver file for doctest's cabal integration";
           license = stdenv.lib.licenses.bsd3;
         }) {};
      "dom-parser" = callPackage
        ({ mkDerivation, base, case-insensitive, containers, lens, mtl
         , scientific, semigroups, stdenv, text, transformers, xml-conduit
         , xml-lens
         }:
         mkDerivation {
           pname = "dom-parser";
           version = "3.1.0";
           sha256 = "d7e15cae0b27d708389160517b1616343da1911baf95f2c97e213732a0262ac3";
           libraryHaskellDepends = [
             base case-insensitive containers lens mtl scientific semigroups
             text transformers xml-conduit xml-lens
           ];
           doHaddock = false;
           doCheck = false;
           homepage = "https://github.com/typeable/dom-parser";
           description = "Simple monadic DOM parser";
           license = stdenv.lib.licenses.mit;
         }) {};
      "dotenv" = callPackage
        ({ mkDerivation, base, base-compat, directory, exceptions
         , megaparsec, optparse-applicative, process, stdenv, text
         , transformers, yaml
         }:
         mkDerivation {
           pname = "dotenv";
           version = "0.5.2.5";
           sha256 = "a197bf60643fc4dea5acd71b03b71cb89e8df91d55cc400b2ada5e79b4b6f4e1";
           isLibrary = true;
           isExecutable = true;
           enableSeparateDataOutput = true;
           libraryHaskellDepends = [
             base base-compat directory exceptions megaparsec process text
             transformers yaml
           ];
           executableHaskellDepends = [
             base base-compat megaparsec optparse-applicative process text
             transformers yaml
           ];
           doHaddock = false;
           doCheck = false;
           homepage = "https://github.com/stackbuilders/dotenv-hs";
           description = "Loads environment variables from dotenv files";
           license = stdenv.lib.licenses.mit;
         }) {};
      "dotnet-timespan" = callPackage
        ({ mkDerivation, base, stdenv }:
         mkDerivation {
           pname = "dotnet-timespan";
           version = "0.0.1.0";
           sha256 = "d8ca8dffbc916ff5139d6f0df4a22c947ab5f996c376f1ab8c2e120789209ac3";
           libraryHaskellDepends = [ base ];
           doHaddock = false;
           doCheck = false;
           homepage = "http://github.com/YoEight/dotnet-timespan";
           description = ".NET TimeSpan";
           license = stdenv.lib.licenses.bsd3;
         }) {};
      "double-conversion" = callPackage
        ({ mkDerivation, base, bytestring, ghc-prim, stdenv, text }:
         mkDerivation {
           pname = "double-conversion";
           version = "2.0.2.0";
           sha256 = "44cde172395401169e844d6791b6eb0ef2c2e55a08de8dda96551cfe029ba26b";
           libraryHaskellDepends = [ base bytestring ghc-prim text ];
           doHaddock = false;
           doCheck = false;
           homepage = "https://github.com/bos/double-conversion";
           description = "Fast conversion between double precision floating point and text";
           license = stdenv.lib.licenses.bsd3;
         }) {};
      "download" = callPackage
        ({ mkDerivation, base, bytestring, feed, stdenv, tagsoup, xml }:
         mkDerivation {
           pname = "download";
           version = "0.3.2.6";
           sha256 = "a06d401a2ca58b6ee494ce462c753939ef0a2d11b4d475ae40848884fb44eef2";
           libraryHaskellDepends = [ base bytestring feed tagsoup xml ];
           doHaddock = false;
           doCheck = false;
           homepage = "https://github.com/psibi/download";
           description = "High-level file download based on URLs";
           license = stdenv.lib.licenses.bsd3;
         }) {};
      "drawille" = callPackage
        ({ mkDerivation, base, containers, stdenv }:
         mkDerivation {
           pname = "drawille";
           version = "0.1.2.0";
           sha256 = "b8188ee87a06c168974c9655188450eb86c331c556decb31cf084efa846237df";
           isLibrary = true;
           isExecutable = true;
           libraryHaskellDepends = [ base containers ];
           doHaddock = false;
           doCheck = false;
           homepage = "https://github.com/yamadapc/haskell-drawille#readme";
           description = "A port of asciimoo's drawille to haskell";
           license = stdenv.lib.licenses.gpl3;
         }) {};
      "drifter" = callPackage
        ({ mkDerivation, base, containers, fgl, stdenv, text }:
         mkDerivation {
           pname = "drifter";
           version = "0.2.3";
           sha256 = "df539d47e47a6064997619079cde28cc0ae039cbda1915cec447380736d92638";
           libraryHaskellDepends = [ base containers fgl text ];
           doHaddock = false;
           doCheck = false;
           homepage = "https://github.com/AndrewRademacher/drifter";
           description = "Simple schema management for arbitrary databases";
           license = stdenv.lib.licenses.mit;
         }) {};
      "drifter-postgresql" = callPackage
        ({ mkDerivation, base, containers, drifter, mtl, postgresql-simple
         , stdenv, time, transformers, transformers-compat
         }:
         mkDerivation {
           pname = "drifter-postgresql";
           version = "0.2.1";
           sha256 = "93320177ec9aab96799623ccc274f5b069500587f002f5f415c24159dd6eed5c";
           libraryHaskellDepends = [
             base containers drifter mtl postgresql-simple time transformers
             transformers-compat
           ];
           doHaddock = false;
           doCheck = false;
           homepage = "http://github.com/michaelxavier/drifter-postgresql";
           description = "PostgreSQL support for the drifter schema migration tool";
           license = stdenv.lib.licenses.mit;
         }) {};
      "dsp" = callPackage
        ({ mkDerivation, array, base, containers, random, stdenv }:
         mkDerivation {
           pname = "dsp";
           version = "0.2.4.1";
           sha256 = "3322954e87b279a94c1fb43a5d16e4d0022e7d422a2d2b9be0f3c4b4d346e42c";
           isLibrary = true;
           isExecutable = true;
           libraryHaskellDepends = [ array base containers random ];
           doHaddock = false;
           doCheck = false;
           homepage = "http://www.haskell.org/haskellwiki/DSP";
           description = "Haskell Digital Signal Processing";
           license = "GPL";
         }) {};
      "dual-tree" = callPackage
        ({ mkDerivation, base, monoid-extras, newtype-generics, semigroups
         , stdenv
         }:
         mkDerivation {
           pname = "dual-tree";
           version = "0.2.2";
           sha256 = "7412d70cf239da98b5a21df1cbbeab7319fd23d757427d4f5ce71b907dbaa9eb";
           revision = "2";
           editedCabalFile = "0r8idr1haqixa9nlp8db5iw9vr9sdk6rcargkr7w7s6i99lm6jmh";
           libraryHaskellDepends = [
             base monoid-extras newtype-generics semigroups
           ];
           doHaddock = false;
           doCheck = false;
           description = "Rose trees with cached and accumulating monoidal annotations";
           license = stdenv.lib.licenses.bsd3;
         }) {};
      "dublincore-xml-conduit" = callPackage
        ({ mkDerivation, base, conduit, conduit-combinators
         , safe-exceptions, stdenv, text, time, timerep, uri-bytestring
         , xml-conduit, xml-types
         }:
         mkDerivation {
           pname = "dublincore-xml-conduit";
           version = "0.1.0.2";
           sha256 = "d47a8dcb21d1866f0229168d11d1da136da3028a2f4252bee61d219988f45f9e";
           revision = "1";
           editedCabalFile = "1rljgmi4jb6yhigfy394jb64q5f5qx7i1g68pw6zgq9ziz91p321";
           libraryHaskellDepends = [
             base conduit conduit-combinators safe-exceptions text time timerep
             uri-bytestring xml-conduit xml-types
           ];
           doHaddock = false;
           doCheck = false;
           homepage = "https://github.com/k0ral/dublincore-xml-conduit";
           description = "XML streaming parser/renderer for the Dublin Core standard elements";
           license = stdenv.lib.licenses.publicDomain;
         }) {};
      "dunai" = callPackage
        ({ mkDerivation, base, MonadRandom, stdenv, transformers
         , transformers-base
         }:
         mkDerivation {
           pname = "dunai";
           version = "0.4.0.0";
           sha256 = "d6f48393ed9ed584eafe2393c848b78288fca1db5c504ed4749f9f0efe82b817";
           libraryHaskellDepends = [
             base MonadRandom transformers transformers-base
           ];
           doHaddock = false;
           doCheck = false;
           homepage = "https://github.com/ivanperez-keera/dunai";
           description = "Generalised reactive framework supporting classic, arrowized and monadic FRP";
           license = stdenv.lib.licenses.bsd3;
         }) {};
      "dvorak" = callPackage
        ({ mkDerivation, base, containers, stdenv }:
         mkDerivation {
           pname = "dvorak";
           version = "0.1.0.0";
           sha256 = "afc8ba89415a01039ccdc719b875826b6b12befb4a6a97bcd7544f22eaffb6cf";
           libraryHaskellDepends = [ base containers ];
           doHaddock = false;
           doCheck = false;
           homepage = "https://github.com/kvanberendonck/codec-dvorak";
           description = "Dvorak encoding for Haskell";
           license = stdenv.lib.licenses.bsd3;
         }) {};
      "dynamic-state" = callPackage
        ({ mkDerivation, base, binary, bytestring, hashable, stdenv
         , unordered-containers
         }:
         mkDerivation {
           pname = "dynamic-state";
           version = "0.3.1";
           sha256 = "c4d50bdf03e7b2af05ee2b78fdd5dd5d16e72ef5edf78cada60bf4cdc6a23537";
           libraryHaskellDepends = [
             base binary bytestring hashable unordered-containers
           ];
           doHaddock = false;
           doCheck = false;
           description = "Optionally serializable dynamic state keyed by type";
           license = stdenv.lib.licenses.gpl2;
         }) {};
      "dyre" = callPackage
        ({ mkDerivation, base, binary, directory, executable-path, filepath
         , ghc-paths, io-storage, process, stdenv, time, unix, xdg-basedir
         }:
         mkDerivation {
           pname = "dyre";
           version = "0.8.12";
           sha256 = "e224305cc6b38b4143f49489931c2ea94b326915206d34eddf5b2ee2b5a71682";
           libraryHaskellDepends = [
             base binary directory executable-path filepath ghc-paths io-storage
             process time unix xdg-basedir
           ];
           doHaddock = false;
           doCheck = false;
           homepage = "http://github.com/willdonnelly/dyre";
           description = "Dynamic reconfiguration in Haskell";
           license = stdenv.lib.licenses.bsd3;
         }) {};
      "easy-file" = callPackage
        ({ mkDerivation, base, directory, filepath, stdenv, time, unix }:
         mkDerivation {
           pname = "easy-file";
           version = "0.2.2";
           sha256 = "52f52e72ba48d60935932401c233a72bf45c582871238aecc5a18021ce67b47e";
           libraryHaskellDepends = [ base directory filepath time unix ];
           doHaddock = false;
           doCheck = false;
           homepage = "http://github.com/kazu-yamamoto/easy-file";
           description = "Cross-platform File handling";
           license = stdenv.lib.licenses.bsd3;
         }) {};
      "easytest" = callPackage
        ({ mkDerivation, async, base, call-stack, containers, mtl, random
         , stdenv, stm, text, transformers
         }:
         mkDerivation {
           pname = "easytest";
           version = "0.2.1";
           sha256 = "1155c3da78460eae48762e041c033d0f64f7644fa94479be2fa1194e3f57be3d";
           libraryHaskellDepends = [
             async base call-stack containers mtl random stm text transformers
           ];
           doHaddock = false;
           doCheck = false;
           homepage = "https://github.com/joelburget/easytest";
           description = "Simple, expressive testing library";
           license = stdenv.lib.licenses.mit;
         }) {};
      "echo" = callPackage
        ({ mkDerivation, base, process, stdenv }:
         mkDerivation {
           pname = "echo";
           version = "0.1.3";
           sha256 = "704f07310f8272d170f8ab7fb2a2c13f15d8501ef8310801e36964c8eff485ef";
           revision = "1";
           editedCabalFile = "0br8wfiybcw5hand4imiw0i5hacdmrax1dv8g95f35gazffbx42l";
           isLibrary = true;
           isExecutable = true;
           libraryHaskellDepends = [ base process ];
           doHaddock = false;
           doCheck = false;
           homepage = "https://github.com/RyanGlScott/echo";
           description = "A cross-platform, cross-console way to handle echoing terminal input";
           license = stdenv.lib.licenses.bsd3;
         }) {};
      "ed25519" = callPackage
        ({ mkDerivation, base, bytestring, ghc-prim, stdenv }:
         mkDerivation {
           pname = "ed25519";
           version = "0.0.5.0";
           sha256 = "d8a5958ebfa9309790efade64275dc5c441b568645c45ceed1b0c6ff36d6156d";
           revision = "2";
           editedCabalFile = "1cq6h3jqkb1kvd9fjfhsllg5gq78sdiyf2gy9862xhlbv6wil19f";
           libraryHaskellDepends = [ base bytestring ghc-prim ];
           doHaddock = false;
           doCheck = false;
           homepage = "http://thoughtpolice.github.com/hs-ed25519";
           description = "Ed25519 cryptographic signatures";
           license = stdenv.lib.licenses.mit;
         }) {};
      "edit-distance" = callPackage
        ({ mkDerivation, array, base, containers, random, stdenv }:
         mkDerivation {
           pname = "edit-distance";
           version = "0.2.2.1";
           sha256 = "3e8885ee2f56ad4da940f043ae8f981ee2fe336b5e8e4ba3f7436cff4f526c4a";
           revision = "1";
           editedCabalFile = "1vjn4ryzdilz7l1ad7czh11nw48h5mj8if7ij3q0mmc3sffa8csd";
           libraryHaskellDepends = [ array base containers random ];
           doHaddock = false;
           doCheck = false;
           homepage = "http://github.com/phadej/edit-distance";
           description = "Levenshtein and restricted Damerau-Levenshtein edit distances";
           license = stdenv.lib.licenses.bsd3;
         }) {};
      "edit-distance-vector" = callPackage
        ({ mkDerivation, base, stdenv, vector }:
         mkDerivation {
           pname = "edit-distance-vector";
           version = "1.0.0.4";
           sha256 = "b7dfddd86d315ef1b0c86415f321efc04b4a1b47a7b13edafc73a6e81b620f1f";
           libraryHaskellDepends = [ base vector ];
           doHaddock = false;
           doCheck = false;
           homepage = "https://github.com/thsutton/edit-distance-vector";
           description = "Calculate edit distances and edit scripts between vectors";
           license = stdenv.lib.licenses.bsd3;
         }) {};
      "editor-open" = callPackage
        ({ mkDerivation, base, bytestring, conduit, conduit-extra
         , directory, process, resourcet, stdenv, temporary, transformers
         , unix
         }:
         mkDerivation {
           pname = "editor-open";
           version = "0.6.0.0";
           sha256 = "2fc5d19bce2d477935202a5a4522671529d0352a0ee28be1307f8ab391065265";
           isLibrary = true;
           isExecutable = true;
           enableSeparateDataOutput = true;
           libraryHaskellDepends = [
             base bytestring conduit conduit-extra directory process resourcet
             temporary transformers unix
           ];
           executableHaskellDepends = [
             base bytestring conduit conduit-extra resourcet
           ];
           doHaddock = false;
           doCheck = false;
           homepage = "https://github.com/pharpend/editor-open";
           description = "Open the user's $VISUAL or $EDITOR for text input";
           license = stdenv.lib.licenses.asl20;
         }) {};
      "either" = callPackage
        ({ mkDerivation, base, bifunctors, mtl, profunctors, semigroupoids
         , semigroups, stdenv
         }:
         mkDerivation {
           pname = "either";
           version = "5.0.1";
           sha256 = "6cb6eb3f60223f5ffedfcd749589e870a81d272e130cafd1d17fb6d3a8939018";
           revision = "2";
           editedCabalFile = "0859h2dc77fq0f14jh11h4i89hrg3iqvzk0yrk78516k6m7n96zc";
           libraryHaskellDepends = [
             base bifunctors mtl profunctors semigroupoids semigroups
           ];
           doHaddock = false;
           doCheck = false;
           homepage = "http://github.com/ekmett/either/";
           description = "Combinators for working with sums";
           license = stdenv.lib.licenses.bsd3;
         }) {};
      "either-unwrap" = callPackage
        ({ mkDerivation, base, stdenv }:
         mkDerivation {
           pname = "either-unwrap";
           version = "1.1";
           sha256 = "ccabd6f87118abc8dcba481b316c76b8195ac9e8a8f3ddb478de5eb64e2d2e3c";
           libraryHaskellDepends = [ base ];
           doHaddock = false;
           doCheck = false;
           homepage = "http://github.com/gcross/either-unwrap";
           description = "Functions for probing and unwrapping values inside of Either";
           license = stdenv.lib.licenses.bsd3;
         }) {};
      "ekg" = callPackage
        ({ mkDerivation, aeson, base, bytestring, ekg-core, ekg-json
         , filepath, network, snap-core, snap-server, stdenv, text, time
         , transformers, unordered-containers
         }:
         mkDerivation {
           pname = "ekg";
           version = "0.4.0.15";
           sha256 = "482ae3be495cfe4f03332ad1c79ce8b5ad4f9c8eec824980c664808ae32c6dcc";
           revision = "6";
           editedCabalFile = "012y235n8k7hhx651l01xf88vgr2wskapbsn83w18ls1h1njqnzk";
           enableSeparateDataOutput = true;
           libraryHaskellDepends = [
             aeson base bytestring ekg-core ekg-json filepath network snap-core
             snap-server text time transformers unordered-containers
           ];
           doHaddock = false;
           doCheck = false;
           homepage = "https://github.com/tibbe/ekg";
           description = "Remote monitoring of processes";
           license = stdenv.lib.licenses.bsd3;
         }) {};
      "ekg-core" = callPackage
        ({ mkDerivation, base, containers, ghc-prim, stdenv, text
         , unordered-containers
         }:
         mkDerivation {
           pname = "ekg-core";
           version = "0.1.1.6";
           sha256 = "66a8dd79ad27659052168f08dd41fabb8593e364de00fb857ef5cc943acd5742";
           libraryHaskellDepends = [
             base containers ghc-prim text unordered-containers
           ];
           doHaddock = false;
           doCheck = false;
           homepage = "https://github.com/tibbe/ekg-core";
           description = "Tracking of system metrics";
           license = stdenv.lib.licenses.bsd3;
         }) {};
      "ekg-json" = callPackage
        ({ mkDerivation, aeson, base, ekg-core, stdenv, text
         , unordered-containers
         }:
         mkDerivation {
           pname = "ekg-json";
           version = "0.1.0.6";
           sha256 = "1e6a80aa0a28bbf41c9c6364cbb5731160d14fa54145f27a82d0b3467a04dd47";
           revision = "4";
           editedCabalFile = "16sn4nbqm0rxkf0swi6r2jn6z9x92qmcg9xlx258d98kqb5fkwjg";
           libraryHaskellDepends = [
             aeson base ekg-core text unordered-containers
           ];
           doHaddock = false;
           doCheck = false;
           homepage = "https://github.com/tibbe/ekg-json";
           description = "JSON encoding of ekg metrics";
           license = stdenv.lib.licenses.bsd3;
         }) {};
      "ekg-statsd" = callPackage
        ({ mkDerivation, base, bytestring, ekg-core, network, stdenv, text
         , time, unordered-containers
         }:
         mkDerivation {
           pname = "ekg-statsd";
           version = "0.2.4.0";
           sha256 = "5e74bf63a1cd347c939d4eb7beb9181556b7bd033a60e5f6f4df0505e98a7adb";
           revision = "3";
           editedCabalFile = "0va7fliya7g546f5qbc42bl7dyh74al38sspd2smjyl7a9d5mmlk";
           libraryHaskellDepends = [
             base bytestring ekg-core network text time unordered-containers
           ];
           doHaddock = false;
           doCheck = false;
           homepage = "https://github.com/tibbe/ekg-statsd";
           description = "Push metrics to statsd";
           license = stdenv.lib.licenses.bsd3;
         }) {};
      "ekg-wai" = callPackage
        ({ mkDerivation, aeson, base, bytestring, ekg-core, ekg-json
         , filepath, http-types, network, stdenv, text, time, transformers
         , unordered-containers, wai, wai-app-static, warp
         }:
         mkDerivation {
           pname = "ekg-wai";
           version = "0.1.0.3";
           sha256 = "bfd35917b663da0c1354339dd30837eee6ddf0d42cf57442fd916a42c977a2e9";
           revision = "2";
           editedCabalFile = "17kca2wzlcv8nxyq096fv57jfklhz4ibnvf5nqqdszczb03j3dnn";
           enableSeparateDataOutput = true;
           libraryHaskellDepends = [
             aeson base bytestring ekg-core ekg-json filepath http-types network
             text time transformers unordered-containers wai wai-app-static warp
           ];
           doHaddock = false;
           doCheck = false;
           homepage = "https://github.com/tvh/ekg-wai";
           description = "Remote monitoring of processes";
           license = stdenv.lib.licenses.bsd3;
         }) {};
      "elerea" = callPackage
        ({ mkDerivation, base, containers, stdenv, transformers
         , transformers-base
         }:
         mkDerivation {
           pname = "elerea";
           version = "2.9.0";
           sha256 = "901221660b32597803b20fe2e78bb6f1f60f064d04671fb3f0baa05c87446681";
           libraryHaskellDepends = [
             base containers transformers transformers-base
           ];
           doHaddock = false;
           doCheck = false;
           description = "A minimalistic FRP library";
           license = stdenv.lib.licenses.bsd3;
         }) {};
      "elf" = callPackage
        ({ mkDerivation, base, binary, bytestring, stdenv }:
         mkDerivation {
           pname = "elf";
           version = "0.29";
           sha256 = "426509f12279bdc5a0228f74edef86997dbb47fddc19d83e9815dd301d4a8fac";
           libraryHaskellDepends = [ base binary bytestring ];
           doHaddock = false;
           doCheck = false;
           homepage = "https://github.com/wangbj/elf";
           description = "An Elf parser";
           license = stdenv.lib.licenses.bsd3;
         }) {};
      "eliminators" = callPackage
        ({ mkDerivation, base, extra, singleton-nats, singletons, stdenv
         , template-haskell, th-abstraction, th-desugar
         }:
         mkDerivation {
           pname = "eliminators";
           version = "0.4.1";
           sha256 = "3becae7b9634055dd02c3908d800dd12b3335b524299e033215a38cfe51b1d00";
           libraryHaskellDepends = [
             base extra singleton-nats singletons template-haskell
             th-abstraction th-desugar
           ];
           doHaddock = false;
           doCheck = false;
           homepage = "https://github.com/RyanGlScott/eliminators";
           description = "Dependently typed elimination functions using singletons";
           license = stdenv.lib.licenses.bsd3;
         }) {};
      "elm-core-sources" = callPackage
        ({ mkDerivation, base, bytestring, containers, file-embed, stdenv
         , template-haskell
         }:
         mkDerivation {
           pname = "elm-core-sources";
           version = "1.0.0";
           sha256 = "a403505d50cd6ff0d21243db55c6decc6dde14b88a6a393e2b6243f09f6620fb";
           libraryHaskellDepends = [
             base bytestring containers file-embed template-haskell
           ];
           doHaddock = false;
           doCheck = false;
           homepage = "http://github.com/JoeyEremondi/elm-build-lib";
           description = "Source files for the Elm runtime and standard libraries";
           license = stdenv.lib.licenses.bsd3;
         }) {};
      "elm-export" = callPackage
        ({ mkDerivation, base, bytestring, containers, directory
         , formatting, mtl, stdenv, text, time, wl-pprint-text
         }:
         mkDerivation {
           pname = "elm-export";
           version = "0.6.0.1";
           sha256 = "bf9862015918c72b54b421efcd9d858969dcd94ef0a3d0cb92d9bc0c4363f9d5";
           libraryHaskellDepends = [
             base bytestring containers directory formatting mtl text time
             wl-pprint-text
           ];
           doHaddock = false;
           doCheck = false;
           homepage = "http://github.com/krisajenkins/elm-export";
           description = "A library to generate Elm types from Haskell source";
           license = "unknown";
           hydraPlatforms = stdenv.lib.platforms.none;
         }) {};
      "email-validate" = callPackage
        ({ mkDerivation, attoparsec, base, bytestring, stdenv
         , template-haskell
         }:
         mkDerivation {
           pname = "email-validate";
           version = "2.3.2.9";
           sha256 = "aeac6eea61192683bbde6bb8bdcf2150a03f79fa2bf4a1deb5e838a0011a4e8b";
           libraryHaskellDepends = [
             attoparsec base bytestring template-haskell
           ];
           doHaddock = false;
           doCheck = false;
           homepage = "https://github.com/Porges/email-validate-hs";
           description = "Email address validation";
           license = stdenv.lib.licenses.bsd3;
         }) {};
      "enclosed-exceptions" = callPackage
        ({ mkDerivation, base, deepseq, lifted-base, monad-control, stdenv
         , transformers, transformers-base
         }:
         mkDerivation {
           pname = "enclosed-exceptions";
           version = "1.0.3";
           sha256 = "af6d93f113ac92b89a32af1fed52f445f492afcc0be93980cbadc5698f94f0b9";
           libraryHaskellDepends = [
             base deepseq lifted-base monad-control transformers
             transformers-base
           ];
           doHaddock = false;
           doCheck = false;
           homepage = "https://github.com/jcristovao/enclosed-exceptions";
           description = "Catching all exceptions from within an enclosed computation";
           license = stdenv.lib.licenses.mit;
         }) {};
      "entropy" = callPackage
        ({ mkDerivation, base, bytestring, Cabal, directory, filepath
         , process, stdenv, unix
         }:
         mkDerivation {
           pname = "entropy";
           version = "0.4.1.4";
           sha256 = "2e3f6a65c8fde3551a8fb03b0a519b718762fc3278b1a5750f96d399e821eeb9";
           revision = "1";
           editedCabalFile = "0h9wvpq4hw5ipn15ni0qdsrssjil0m59wm4l5hl607l3w2lif864";
           setupHaskellDepends = [ base Cabal directory filepath process ];
           libraryHaskellDepends = [ base bytestring unix ];
           doHaddock = false;
           doCheck = false;
           homepage = "https://github.com/TomMD/entropy";
           description = "A platform independent entropy source";
           license = stdenv.lib.licenses.bsd3;
         }) {};
      "enum-subset-generate" = callPackage
        ({ mkDerivation, base, microlens, stdenv, template-haskell }:
         mkDerivation {
           pname = "enum-subset-generate";
           version = "0.1.0.0";
           sha256 = "dd07c2089495ee5b07bdb371bc10004341edb58cbc287d4862ee96b797b14581";
           libraryHaskellDepends = [ base microlens template-haskell ];
           doHaddock = false;
           doCheck = false;
           homepage = "https://github.com/0xd34df00d/enum-subset-generate#readme";
           description = "Generate an ADT being a subset of another ADT, and the corresponding mappings";
           license = stdenv.lib.licenses.bsd3;
         }) {};
      "enummapset" = callPackage
        ({ mkDerivation, base, containers, deepseq, semigroups, stdenv }:
         mkDerivation {
           pname = "enummapset";
           version = "0.5.2.2";
           sha256 = "792fdbdf387de02580accb3ad49a6f5191b24eb2283ef141355eacfd328cce74";
           libraryHaskellDepends = [ base containers deepseq semigroups ];
           doHaddock = false;
           doCheck = false;
           homepage = "https://github.com/michalt/enummapset";
           description = "IntMap and IntSet with Enum keys/elements";
           license = stdenv.lib.licenses.bsd3;
         }) {};
      "enumset" = callPackage
        ({ mkDerivation, base, data-accessor, semigroups, stdenv
         , storable-record
         }:
         mkDerivation {
           pname = "enumset";
           version = "0.0.4.1";
           sha256 = "5f9d115f7f2b2d4dba290f9d62cd7e9f52f6f6f8235ac5ed9bbf6e982a51d054";
           libraryHaskellDepends = [
             base data-accessor semigroups storable-record
           ];
           doHaddock = false;
           doCheck = false;
           description = "Sets of enumeration values represented by machine words";
           license = stdenv.lib.licenses.bsd3;
         }) {};
      "envelope" = callPackage
        ({ mkDerivation, aeson, base, http-api-data, mtl, stdenv, text }:
         mkDerivation {
           pname = "envelope";
           version = "0.2.2.0";
           sha256 = "cf4d6fe3f906e859ec3c16684a8dafb349e77f0fa4f21b7090ca33e707867ef9";
           libraryHaskellDepends = [ aeson base http-api-data mtl text ];
           doHaddock = false;
           doCheck = false;
           homepage = "https://github.com/cdepillabout/envelope#readme";
           description = "Defines generic 'Envelope' type to wrap reponses from a JSON API";
           license = stdenv.lib.licenses.bsd3;
         }) {};
      "envy" = callPackage
        ({ mkDerivation, base, bytestring, containers, mtl, stdenv, text
         , time, transformers
         }:
         mkDerivation {
           pname = "envy";
           version = "1.5.1.0";
           sha256 = "2dcacbb9901603f44e8e933849b532ba7b56ee2d7feff3980f9c7b556c4041e4";
           libraryHaskellDepends = [
             base bytestring containers mtl text time transformers
           ];
           doHaddock = false;
           doCheck = false;
           description = "An environmentally friendly way to deal with environment variables";
           license = stdenv.lib.licenses.bsd3;
         }) {};
      "epub-metadata" = callPackage
        ({ mkDerivation, base, bytestring, containers, directory, filepath
         , hxt, mtl, regex-compat-tdfa, stdenv, utf8-string, zip-archive
         }:
         mkDerivation {
           pname = "epub-metadata";
           version = "4.5";
           sha256 = "19ae3914df5936908c8d7264ae5f1e310262fa06bd7e4390838892840e4c0349";
           isLibrary = true;
           isExecutable = true;
           libraryHaskellDepends = [
             base bytestring containers directory filepath hxt mtl
             regex-compat-tdfa utf8-string zip-archive
           ];
           executableHaskellDepends = [ base mtl ];
           doHaddock = false;
           doCheck = false;
           homepage = "http://hub.darcs.net/dino/epub-metadata";
           description = "Library for parsing epub document metadata";
           license = stdenv.lib.licenses.bsd3;
         }) {};
      "eq" = callPackage
        ({ mkDerivation, base, semigroupoids, stdenv }:
         mkDerivation {
           pname = "eq";
           version = "4.2";
           sha256 = "4160703a06af1c7518b8ff3244a04013fc7c04a012637dd26be31308e23970e8";
           libraryHaskellDepends = [ base semigroupoids ];
           doHaddock = false;
           doCheck = false;
           homepage = "http://github.com/ekmett/eq/";
           description = "Leibnizian equality";
           license = stdenv.lib.licenses.bsd3;
         }) {};
      "equal-files" = callPackage
        ({ mkDerivation, base, bytestring, explicit-exception, filemanip
         , stdenv, transformers, utility-ht
         }:
         mkDerivation {
           pname = "equal-files";
           version = "0.0.5.3";
           sha256 = "e5b785c286c557c57dba7107d913b220781aa2549ba4b7685da494b20a0172aa";
           isLibrary = false;
           isExecutable = true;
           executableHaskellDepends = [
             base bytestring explicit-exception filemanip transformers
             utility-ht
           ];
           doHaddock = false;
           doCheck = false;
           homepage = "http://code.haskell.org/~thielema/equal-files/";
           description = "Shell command for finding equal files";
           license = "GPL";
         }) {};
      "equivalence" = callPackage
        ({ mkDerivation, base, containers, mtl, stdenv, STMonadTrans
         , transformers, transformers-compat
         }:
         mkDerivation {
           pname = "equivalence";
           version = "0.3.3";
           sha256 = "ee8dd8ce12298e6252f331e3844f684cfe7f32b70e529fe7b8dd63153eb2500a";
           libraryHaskellDepends = [
             base containers mtl STMonadTrans transformers transformers-compat
           ];
           doHaddock = false;
           doCheck = false;
           homepage = "https://github.com/pa-ba/equivalence";
           description = "Maintaining an equivalence relation implemented as union-find using STT";
           license = stdenv.lib.licenses.bsd3;
         }) {};
      "erf" = callPackage
        ({ mkDerivation, base, stdenv }:
         mkDerivation {
           pname = "erf";
           version = "2.0.0.0";
           sha256 = "24f0b79c7e1d25cb2cd44c2258d7a464bf6db8079775b50b60b54a254616b337";
           libraryHaskellDepends = [ base ];
           doHaddock = false;
           doCheck = false;
           description = "The error function, erf, and related functions";
           license = stdenv.lib.licenses.bsd3;
         }) {};
      "error-util" = callPackage
        ({ mkDerivation, base, stdenv, transformers }:
         mkDerivation {
           pname = "error-util";
           version = "0.0.1.2";
           sha256 = "df1916a2de007697b7b1a9f83eacab4588d8dc472fd0f21395dce83b085e4e06";
           libraryHaskellDepends = [ base transformers ];
           doHaddock = false;
           doCheck = false;
           homepage = "http://github.com/pmlodawski/error-util";
           description = "Set of utils and operators for error handling";
           license = stdenv.lib.licenses.mit;
         }) {};
      "errors" = callPackage
        ({ mkDerivation, base, exceptions, safe, stdenv, text, transformers
         , transformers-compat
         }:
         mkDerivation {
           pname = "errors";
           version = "2.3.0";
           sha256 = "6772e5689f07e82077ffe3339bc672934d83d83a97a7d4f1349de1302cb71f75";
           libraryHaskellDepends = [
             base exceptions safe text transformers transformers-compat
           ];
           doHaddock = false;
           doCheck = false;
           description = "Simplified error-handling";
           license = stdenv.lib.licenses.bsd3;
         }) {};
      "errors-ext" = callPackage
        ({ mkDerivation, base, errors, exceptions, monad-control, mtl
         , stdenv, transformers
         }:
         mkDerivation {
           pname = "errors-ext";
           version = "0.4.2";
           sha256 = "406e65338046d6c1d6994072b529272fab4ad7abbdb2c3b63576788fd8dd9618";
           libraryHaskellDepends = [
             base errors exceptions monad-control mtl transformers
           ];
           doHaddock = false;
           doCheck = false;
           homepage = "https://github.com/A1-Triard/errors-ext#readme";
           description = "`bracket`-like functions for `ExceptT` over `IO` monad";
           license = stdenv.lib.licenses.asl20;
         }) {};
      "ersatz" = callPackage
        ({ mkDerivation, array, attoparsec, base, bytestring, Cabal
         , cabal-doctest, containers, data-default, lens, mtl, parsec
         , process, semigroups, stdenv, temporary, transformers
         , unordered-containers
         }:
         mkDerivation {
           pname = "ersatz";
           version = "0.4.4";
           sha256 = "42dca507046c32e00459bf6167d02bb508b72bb47669470a0eb3fba20b73a019";
           isLibrary = true;
           isExecutable = true;
           enableSeparateDataOutput = true;
           setupHaskellDepends = [ base Cabal cabal-doctest ];
           libraryHaskellDepends = [
             array attoparsec base bytestring containers data-default lens mtl
             process semigroups temporary transformers unordered-containers
           ];
           executableHaskellDepends = [
             array base containers lens mtl parsec semigroups
           ];
           doHaddock = false;
           doCheck = false;
           homepage = "http://github.com/ekmett/ersatz";
           description = "A monad for expressing SAT or QSAT problems using observable sharing";
           license = stdenv.lib.licenses.bsd3;
         }) {};
      "esqueleto" = callPackage
        ({ mkDerivation, base, blaze-html, bytestring, conduit, fetchgit
         , hpack, monad-logger, persistent, resourcet, stdenv, tagged, text
         , time, transformers, unliftio, unordered-containers
         }:
         mkDerivation {
           pname = "esqueleto";
           version = "2.6.0";
           src = fetchgit {
             url = "https://github.com/bitemyapp/esqueleto.git";
             sha256 = "16jjxqv71izpk2cz2ns3abmx876i5mgbynyq6fq90yikkmscwxra";
             rev = "08c9b4cdf977d5bcd1baba046a007940c1940758";
             fetchSubmodules = true;
           };
           libraryHaskellDepends = [
             base blaze-html bytestring conduit monad-logger persistent
             resourcet tagged text time transformers unliftio
             unordered-containers
           ];
           libraryToolDepends = [ hpack ];
           doHaddock = false;
           doCheck = false;
           preConfigure = "hpack";
           homepage = "https://github.com/bitemyapp/esqueleto";
           description = "Type-safe EDSL for SQL queries on persistent backends";
           license = stdenv.lib.licenses.bsd3;
         }) {};
      "etc" = callPackage
        ({ mkDerivation, aeson, base, rio, stdenv, template-haskell, text
         , typed-process, unliftio
         }:
         mkDerivation {
           pname = "etc";
           version = "0.4.1.0";
           sha256 = "61b4d5f29a1fc66df082623e5fc9269bdbb49d28ebf4cbb740c71319257a27c8";
           enableSeparateDataOutput = true;
           libraryHaskellDepends = [
             aeson base rio template-haskell text typed-process unliftio
           ];
           doHaddock = false;
           doCheck = false;
           homepage = "https://github.com/roman/Haskell-etc";
           description = "Declarative configuration spec for Haskell projects";
           license = stdenv.lib.licenses.mit;
         }) {};
      "event" = callPackage
        ({ mkDerivation, base, containers, semigroups, stdenv, transformers
         }:
         mkDerivation {
           pname = "event";
           version = "0.1.4";
           sha256 = "6791d1402b4d77a11407ab592f65cb61ee60c5a80b99751c5d775afcc9d1824a";
           libraryHaskellDepends = [
             base containers semigroups transformers
           ];
           doHaddock = false;
           doCheck = false;
           description = "Monoidal, monadic and first-class events";
           license = stdenv.lib.licenses.bsd3;
         }) {};
      "event-list" = callPackage
        ({ mkDerivation, base, non-negative, QuickCheck, semigroups, stdenv
         , transformers, utility-ht
         }:
         mkDerivation {
           pname = "event-list";
           version = "0.1.2";
           sha256 = "624e30b876e0acdaea895efbb2000bbbec2d5be0743ecac9805655ae634af89c";
           libraryHaskellDepends = [
             base non-negative QuickCheck semigroups transformers utility-ht
           ];
           doHaddock = false;
           doCheck = false;
           homepage = "http://code.haskell.org/~thielema/event-list/";
           description = "Event lists with relative or absolute time stamps";
           license = "GPL";
         }) {};
      "eventful-core" = callPackage
        ({ mkDerivation, aeson, base, containers, contravariant
         , http-api-data, path-pieces, stdenv, sum-type-boilerplate
         , template-haskell, text, transformers, uuid
         }:
         mkDerivation {
           pname = "eventful-core";
           version = "0.2.0";
           sha256 = "e0f55e7498d8e48232ce2d5194c69f635beaeb322cb64753766076d7b35c9019";
           libraryHaskellDepends = [
             aeson base containers contravariant http-api-data path-pieces
             sum-type-boilerplate template-haskell text transformers uuid
           ];
           doHaddock = false;
           doCheck = false;
           homepage = "https://github.com/jdreaver/eventful#readme";
           description = "Core module for eventful";
           license = stdenv.lib.licenses.mit;
         }) {};
      "eventful-memory" = callPackage
        ({ mkDerivation, base, containers, eventful-core, mtl, safe, stdenv
         , stm
         }:
         mkDerivation {
           pname = "eventful-memory";
           version = "0.2.0";
           sha256 = "6a7c3e0a12e3c4e572927929020ad92075933e5d3c66ea61ff615a3ac217adb9";
           libraryHaskellDepends = [
             base containers eventful-core mtl safe stm
           ];
           doHaddock = false;
           doCheck = false;
           homepage = "https://github.com/jdreaver/eventful#readme";
           description = "In-memory implementations for eventful";
           license = stdenv.lib.licenses.mit;
         }) {};
      "eventful-sql-common" = callPackage
        ({ mkDerivation, aeson, base, bytestring, eventful-core, mtl
         , persistent, persistent-template, stdenv, text, uuid
         }:
         mkDerivation {
           pname = "eventful-sql-common";
           version = "0.2.0";
           sha256 = "a46ea18cbbb5bd04b3a6846273e8161b7e4208660d0abf5a401192b07636aebc";
           libraryHaskellDepends = [
             aeson base bytestring eventful-core mtl persistent
             persistent-template text uuid
           ];
           doHaddock = false;
           doCheck = false;
           homepage = "https://github.com/jdreaver/eventful#readme";
           description = "Common library for SQL event stores";
           license = stdenv.lib.licenses.mit;
         }) {};
      "eventful-sqlite" = callPackage
        ({ mkDerivation, aeson, base, bytestring, eventful-core
         , eventful-sql-common, mtl, persistent, stdenv, text, uuid
         }:
         mkDerivation {
           pname = "eventful-sqlite";
           version = "0.2.0";
           sha256 = "c0bbea0ebd1f0a4891a74b190f499caf85ac026f49b9401fc76f181b0041dfef";
           libraryHaskellDepends = [
             aeson base bytestring eventful-core eventful-sql-common mtl
             persistent text uuid
           ];
           doHaddock = false;
           doCheck = false;
           homepage = "https://github.com/jdreaver/eventful#readme";
           description = "SQLite implementations for eventful";
           license = stdenv.lib.licenses.mit;
         }) {};
      "eventful-test-helpers" = callPackage
        ({ mkDerivation, aeson, aeson-casing, base, eventful-core, extra
         , hspec, monad-logger, stdenv, text
         }:
         mkDerivation {
           pname = "eventful-test-helpers";
           version = "0.2.0";
           sha256 = "a99f9d0cde3926add542c4fc59e079da7d71f2b40e2251b7d79777585c4ebfe0";
           libraryHaskellDepends = [
             aeson aeson-casing base eventful-core extra hspec monad-logger text
           ];
           doHaddock = false;
           doCheck = false;
           homepage = "https://github.com/jdreaver/eventful#readme";
           description = "Common module used for eventful tests";
           license = stdenv.lib.licenses.mit;
         }) {};
      "eventstore" = callPackage
        ({ mkDerivation, aeson, array, base, bifunctors, bytestring, cereal
         , clock, connection, containers, dns, dotnet-timespan, ekg-core
         , exceptions, fast-logger, hashable, http-client, interpolate
         , lifted-async, lifted-base, machines, monad-control, monad-logger
         , mono-traversable, mtl, protobuf, random, safe-exceptions
         , semigroups, stdenv, stm, stm-chans, text, time, transformers-base
         , unordered-containers, uuid
         }:
         mkDerivation {
           pname = "eventstore";
           version = "1.1.6";
           sha256 = "dca4fd1fae1deb7af5b13ef3f640c9cd0915986e131671f2da7da9cce99c6d01";
           revision = "1";
           editedCabalFile = "1y1a7brw220bg4mfc80qhkcyzlm38qvs6pkr7p8xyk104b8k5qgx";
           libraryHaskellDepends = [
             aeson array base bifunctors bytestring cereal clock connection
             containers dns dotnet-timespan ekg-core exceptions fast-logger
             hashable http-client interpolate lifted-async lifted-base machines
             monad-control monad-logger mono-traversable mtl protobuf random
             safe-exceptions semigroups stm stm-chans text time
             transformers-base unordered-containers uuid
           ];
           doHaddock = false;
           doCheck = false;
           homepage = "https://gitlab.com/YoEight/eventstore-hs";
           description = "EventStore TCP Client";
           license = stdenv.lib.licenses.bsd3;
           platforms = [ "x86_64-darwin" "x86_64-linux" ];
         }) {};
      "every" = callPackage
        ({ mkDerivation, async, base, stdenv, stm }:
         mkDerivation {
           pname = "every";
           version = "0.0.1";
           sha256 = "5d0ff0e4cefb094c44b55defa283146b16b925722a2eb244a5ef4364737980e5";
           libraryHaskellDepends = [ async base stm ];
           doHaddock = false;
           doCheck = false;
           homepage = "https://github.com/athanclark/every#readme";
           description = "Run a process every so often";
           license = stdenv.lib.licenses.bsd3;
         }) {};
      "exact-combinatorics" = callPackage
        ({ mkDerivation, base, stdenv }:
         mkDerivation {
           pname = "exact-combinatorics";
           version = "0.2.0.8";
           sha256 = "32a822b109ab6e9f62fe23d76bd5af593c20ba0e589005d3985ccda00dd4475e";
           libraryHaskellDepends = [ base ];
           doHaddock = false;
           doCheck = false;
           homepage = "http://code.haskell.org/~wren/";
           description = "Efficient exact computation of combinatoric functions";
           license = stdenv.lib.licenses.bsd3;
         }) {};
      "exact-pi" = callPackage
        ({ mkDerivation, base, numtype-dk, stdenv }:
         mkDerivation {
           pname = "exact-pi";
           version = "0.4.1.4";
           sha256 = "7bf496b46e831936942ae0e6035b48f262d129a2e0b92f8df1e7bd5f2c076197";
           libraryHaskellDepends = [ base numtype-dk ];
           doHaddock = false;
           doCheck = false;
           homepage = "https://github.com/dmcclean/exact-pi/";
           description = "Exact rational multiples of pi (and integer powers of pi)";
           license = stdenv.lib.licenses.mit;
         }) {};
      "exception-hierarchy" = callPackage
        ({ mkDerivation, base, stdenv, template-haskell }:
         mkDerivation {
           pname = "exception-hierarchy";
           version = "0.1.0.1";
           sha256 = "a9424dc79f08bc98bf49353550101495c9a72ad67ba7c302388f64eed03760fe";
           libraryHaskellDepends = [ base template-haskell ];
           doHaddock = false;
           doCheck = false;
           homepage = "yet";
           description = "Exception type hierarchy with TemplateHaskell";
           license = stdenv.lib.licenses.bsd3;
         }) {};
      "exception-mtl" = callPackage
        ({ mkDerivation, base, exception-transformers, mtl, stdenv
         , transformers
         }:
         mkDerivation {
           pname = "exception-mtl";
           version = "0.4.0.1";
           sha256 = "ec13bcbae6cdde218a7118a2bd3058493af09a330b86e28469a278c9b2cea134";
           libraryHaskellDepends = [
             base exception-transformers mtl transformers
           ];
           doHaddock = false;
           doCheck = false;
           description = "Exception monad transformer instances for mtl classes";
           license = stdenv.lib.licenses.bsd3;
         }) {};
      "exception-transformers" = callPackage
        ({ mkDerivation, base, stdenv, stm, transformers
         , transformers-compat
         }:
         mkDerivation {
           pname = "exception-transformers";
           version = "0.4.0.7";
           sha256 = "925b61eb3d19148a521e79f8b4c8ac097f6e0dea6a09cc2f533279f3abf1f2ef";
           revision = "1";
           editedCabalFile = "0sahi93f75acvmqagkjc1lcwx31crja6z9hyww9abj85x45pqa6f";
           libraryHaskellDepends = [
             base stm transformers transformers-compat
           ];
           doHaddock = false;
           doCheck = false;
           description = "Type classes and monads for unchecked extensible exceptions";
           license = stdenv.lib.licenses.bsd3;
         }) {};
      "exceptional" = callPackage
        ({ mkDerivation, base, exceptions, stdenv }:
         mkDerivation {
           pname = "exceptional";
           version = "0.3.0.0";
           sha256 = "da866ed28ea14d245cc065271f4ddd6da0a91b83e8d83daddcd1ef0623e99f06";
           libraryHaskellDepends = [ base exceptions ];
           doHaddock = false;
           doCheck = false;
           homepage = "https://github.com/";
           description = "Essentially the Maybe type with error messages";
           license = stdenv.lib.licenses.bsd2;
         }) {};
      "exceptions" = callPackage
        ({ mkDerivation, base, mtl, stdenv, stm, template-haskell
         , transformers, transformers-compat
         }:
         mkDerivation {
           pname = "exceptions";
           version = "0.10.0";
           sha256 = "1edd912e5ea5cbda37941b06738597d35214dc247d332b1bfffc82adadfa49d7";
           revision = "2";
           editedCabalFile = "0aiihbjfrlmxzw9q8idvr6mihhs7kbx9s3w1vj8x3pz27p0ncq7g";
           libraryHaskellDepends = [
             base mtl stm template-haskell transformers transformers-compat
           ];
           doHaddock = false;
           doCheck = false;
           homepage = "http://github.com/ekmett/exceptions/";
           description = "Extensible optionally-pure exceptions";
           license = stdenv.lib.licenses.bsd3;
         }) {};
      "executable-hash" = callPackage
        ({ mkDerivation, base, bytestring, Cabal, cryptohash, directory
         , executable-path, file-embed, filepath, stdenv, template-haskell
         }:
         mkDerivation {
           pname = "executable-hash";
           version = "0.2.0.4";
           sha256 = "34eaf5662d90d3b7841f66b322ac5bc54900b0e3cb06792852b08b3c05a42ba4";
           isLibrary = true;
           isExecutable = true;
           setupHaskellDepends = [
             base bytestring Cabal cryptohash directory file-embed filepath
             template-haskell
           ];
           libraryHaskellDepends = [
             base bytestring cryptohash directory executable-path file-embed
             template-haskell
           ];
           executableHaskellDepends = [ base ];
           doHaddock = false;
           doCheck = false;
           homepage = "http://github.com/fpco/executable-hash";
           description = "Provides the SHA1 hash of the program executable";
           license = stdenv.lib.licenses.mit;
         }) {};
      "executable-path" = callPackage
        ({ mkDerivation, base, directory, filepath, stdenv, unix }:
         mkDerivation {
           pname = "executable-path";
           version = "0.0.3.1";
           sha256 = "9cc742b6d40a487b3af38dca6852ca3b50a0db94d42fe819576c84beb5adbc6f";
           libraryHaskellDepends = [ base directory filepath unix ];
           doHaddock = false;
           doCheck = false;
           homepage = "http://code.haskell.org/~bkomuves/";
           description = "Finding out the full path of the executable";
           license = stdenv.lib.licenses.publicDomain;
         }) {};
      "exinst" = callPackage
        ({ mkDerivation, aeson, base, binary, bytes, cereal, constraints
         , deepseq, hashable, profunctors, QuickCheck, singletons, stdenv
         }:
         mkDerivation {
           pname = "exinst";
           version = "0.6";
           sha256 = "e906a149bfe195c16c25a5ab9ec2116e2577e5a10de134c17dff2be2c17c925e";
           configureFlags = [ "-f-serialise" ];
           libraryHaskellDepends = [
             aeson base binary bytes cereal constraints deepseq hashable
             profunctors QuickCheck singletons
           ];
           doHaddock = false;
           doCheck = false;
           homepage = "https://github.com/k0001/exinst";
           description = "Dependent pairs and their instances";
           license = stdenv.lib.licenses.bsd3;
         }) {};
      "exomizer" = callPackage
        ({ mkDerivation, base, bytestring, c2hs, stdenv }:
         mkDerivation {
           pname = "exomizer";
           version = "1.0.0";
           sha256 = "94c24d436d12666d16cb7171c83cedec449b992dc3aeaaa6decdc0faf8e2cfd2";
           enableSeparateDataOutput = true;
           libraryHaskellDepends = [ base bytestring ];
           libraryToolDepends = [ c2hs ];
           doHaddock = false;
           doCheck = false;
           homepage = "https://github.com/alexkazik/exomizer#readme";
           description = "Compression and decompression in the exomizer format";
           license = "unknown";
           hydraPlatforms = stdenv.lib.platforms.none;
         }) {};
      "exp-pairs" = callPackage
        ({ mkDerivation, base, containers, deepseq, ghc-prim, prettyprinter
         , stdenv
         }:
         mkDerivation {
           pname = "exp-pairs";
           version = "0.1.6.0";
           sha256 = "e63ad90fcd292a9a31bd42b94408930c7cdf06700c9879453e61423a89a75be3";
           revision = "1";
           editedCabalFile = "1zbsjlj6wavz9ysfzjqb4ng7688crlfvsbyj4li84khc1jp71xj3";
           libraryHaskellDepends = [
             base containers deepseq ghc-prim prettyprinter
           ];
           doHaddock = false;
           doCheck = false;
           homepage = "https://github.com/Bodigrim/exp-pairs";
           description = "Linear programming over exponent pairs";
           license = stdenv.lib.licenses.gpl3;
         }) {};
      "expiring-cache-map" = callPackage
        ({ mkDerivation, base, containers, hashable, stdenv
         , unordered-containers
         }:
         mkDerivation {
           pname = "expiring-cache-map";
           version = "0.0.6.1";
           sha256 = "0e3bc294978b46ee59bf0b4a7e7a5bd7ed5da7bc261ffebdb0cb1b60353c64b9";
           libraryHaskellDepends = [
             base containers hashable unordered-containers
           ];
           doHaddock = false;
           doCheck = false;
           homepage = "https://github.com/elblake/expiring-cache-map";
           description = "General purpose simple caching";
           license = stdenv.lib.licenses.bsd3;
         }) {};
      "explicit-exception" = callPackage
        ({ mkDerivation, base, deepseq, semigroups, stdenv, transformers }:
         mkDerivation {
           pname = "explicit-exception";
           version = "0.1.9.2";
           sha256 = "60f6029777f80ec958e28cef19a15723242987a01f09f6bfef252f24207649f6";
           isLibrary = true;
           isExecutable = true;
           libraryHaskellDepends = [ base deepseq semigroups transformers ];
           doHaddock = false;
           doCheck = false;
           homepage = "http://www.haskell.org/haskellwiki/Exception";
           description = "Exceptions which are explicit in the type signature";
           license = stdenv.lib.licenses.bsd3;
         }) {};
      "extensible" = callPackage
        ({ mkDerivation, aeson, base, bytestring, cassava, comonad
         , constraints, deepseq, ghc-prim, hashable, monad-skeleton, mtl
         , prettyprinter, primitive, profunctors, QuickCheck, semigroups
         , StateVar, stdenv, tagged, template-haskell, text, th-lift
         , transformers, unordered-containers, vector
         }:
         mkDerivation {
           pname = "extensible";
           version = "0.4.9";
           sha256 = "b752ea6f45ff57e2994e12af911c92977b54246756c5181e376e09fd28f93e86";
           libraryHaskellDepends = [
             aeson base bytestring cassava comonad constraints deepseq ghc-prim
             hashable monad-skeleton mtl prettyprinter primitive profunctors
             QuickCheck semigroups StateVar tagged template-haskell text th-lift
             transformers unordered-containers vector
           ];
           doHaddock = false;
           doCheck = false;
           homepage = "https://github.com/fumieval/extensible";
           description = "Extensible, efficient, optics-friendly data types and effects";
           license = stdenv.lib.licenses.bsd3;
         }) {};
      "extensible-exceptions" = callPackage
        ({ mkDerivation, base, stdenv }:
         mkDerivation {
           pname = "extensible-exceptions";
           version = "0.1.1.4";
           sha256 = "6ce5e8801760385a408dab71b53550f87629e661b260bdc2cd41c6a439b6e388";
           libraryHaskellDepends = [ base ];
           doHaddock = false;
           doCheck = false;
           description = "Extensible exceptions";
           license = stdenv.lib.licenses.bsd3;
         }) {};
      "extra" = callPackage
        ({ mkDerivation, base, clock, directory, filepath, process, stdenv
         , time, unix
         }:
         mkDerivation {
           pname = "extra";
           version = "1.6.14";
           sha256 = "a60641530d96653ecc365aa042f4061892154995915d91f432ea5a2e3aaf129c";
           libraryHaskellDepends = [
             base clock directory filepath process time unix
           ];
           doHaddock = false;
           doCheck = false;
           homepage = "https://github.com/ndmitchell/extra#readme";
           description = "Extra functions I use";
           license = stdenv.lib.licenses.bsd3;
         }) {};
      "extractable-singleton" = callPackage
        ({ mkDerivation, base, stdenv, transformers }:
         mkDerivation {
           pname = "extractable-singleton";
           version = "0.0.1";
           sha256 = "e8da1928d98c57ef3d1bab7deb1378f51fa496721495777233663dd0b1b2c0ad";
           libraryHaskellDepends = [ base transformers ];
           doHaddock = false;
           doCheck = false;
           homepage = "https://github.com/athanclark/extractable-singleton#readme";
           description = "A functor, where the \"stored\" value is isomorphic to Identity";
           license = stdenv.lib.licenses.bsd3;
         }) {};
      "extrapolate" = callPackage
        ({ mkDerivation, base, leancheck, speculate, stdenv
         , template-haskell
         }:
         mkDerivation {
           pname = "extrapolate";
           version = "0.3.3";
           sha256 = "22fff22a2c5b36a6545b27495c0eba63e8e3f72baccb3f9d687967c6532381d5";
           libraryHaskellDepends = [
             base leancheck speculate template-haskell
           ];
           doHaddock = false;
           doCheck = false;
           homepage = "https://github.com/rudymatela/extrapolate#readme";
           description = "generalize counter-examples of test properties";
           license = stdenv.lib.licenses.bsd3;
         }) {};
      "facts" = callPackage
        ({ mkDerivation, base, exceptions, mtl, stdenv, template-haskell }:
         mkDerivation {
           pname = "facts";
           version = "0.0.1.0";
           sha256 = "dde59212abc383920c5ac5c5a0b5253f4a309d14ebbb21b45310d5b78d922e8a";
           revision = "1";
           editedCabalFile = "03v6p3vlilz6vk5xlvw3r31cqicx3m1xjii9shcqpacxvlh2zzlp";
           libraryHaskellDepends = [ base exceptions mtl template-haskell ];
           doHaddock = false;
           doCheck = false;
           homepage = "https://github.com/mrkkrp/facts";
           description = "Refined types";
           license = stdenv.lib.licenses.bsd3;
         }) {};
      "fail" = callPackage
        ({ mkDerivation, stdenv }:
         mkDerivation {
           pname = "fail";
           version = "4.9.0.0";
           sha256 = "6d5cdb1a5c539425a9665f740e364722e1d9d6ae37fbc55f30fe3dbbbb91d4a2";
           doHaddock = false;
           doCheck = false;
           homepage = "https://prime.haskell.org/wiki/Libraries/Proposals/MonadFail";
           description = "Forward-compatible MonadFail class";
           license = stdenv.lib.licenses.bsd3;
         }) {};
      "farmhash" = callPackage
        ({ mkDerivation, base, bytestring, stdenv }:
         mkDerivation {
           pname = "farmhash";
           version = "0.1.0.5";
           sha256 = "0e685a5445f7bce88682d209bccb47d03f06065a627475df44a8e2af8bc20fa1";
           libraryHaskellDepends = [ base bytestring ];
           doHaddock = false;
           doCheck = false;
           homepage = "https://github.com/abhinav/farmhash";
           description = "Fast hash functions";
           license = stdenv.lib.licenses.bsd3;
         }) {};
      "fast-digits" = callPackage
        ({ mkDerivation, base, integer-gmp, stdenv }:
         mkDerivation {
           pname = "fast-digits";
           version = "0.2.1.0";
           sha256 = "ec84576e479202de8257c7c499b66e91bcf18444f7683475d74b575e166dd83b";
           libraryHaskellDepends = [ base integer-gmp ];
           doHaddock = false;
           doCheck = false;
           homepage = "https://github.com/Bodigrim/fast-digits";
           description = "The fast library for integer-to-digits conversion";
           license = stdenv.lib.licenses.gpl3;
         }) {};
      "fast-logger" = callPackage
        ({ mkDerivation, array, auto-update, base, bytestring, directory
         , easy-file, filepath, stdenv, text, unix, unix-time
         }:
         mkDerivation {
           pname = "fast-logger";
           version = "2.4.11";
           sha256 = "bbe5deab58f435754dbe938cf0ddf26fc21f317c35fb3431d4bdb96809dea2a9";
           libraryHaskellDepends = [
             array auto-update base bytestring directory easy-file filepath text
             unix unix-time
           ];
           doHaddock = false;
           doCheck = false;
           homepage = "https://github.com/kazu-yamamoto/logger";
           description = "A fast logging system";
           license = stdenv.lib.licenses.bsd3;
         }) {};
      "fast-math" = callPackage
        ({ mkDerivation, base, stdenv }:
         mkDerivation {
           pname = "fast-math";
           version = "1.0.2";
           sha256 = "45101ddc8b86402e866ec029bcfbc2662779e578e43b40acd971a9f411e2be95";
           libraryHaskellDepends = [ base ];
           doHaddock = false;
           doCheck = false;
           description = "Non IEEE-754 compliant compile-time floating-point optimisations";
           license = stdenv.lib.licenses.bsd3;
         }) {};
      "fay" = callPackage
        ({ mkDerivation, aeson, attoparsec, base, base-compat, bytestring
         , Cabal, containers, data-default, data-lens-light, directory
         , filepath, ghc-paths, haskell-src-exts, language-ecmascript, mtl
         , mtl-compat, optparse-applicative, process, random, safe
         , shakespeare, sourcemap, split, spoon, stdenv, syb, tasty
         , tasty-hunit, tasty-th, text, time, transformers
         , transformers-compat, traverse-with-class, uniplate
         , unordered-containers, utf8-string, vector
         }:
         mkDerivation {
           pname = "fay";
           version = "0.24.0.1";
           sha256 = "a26ef27237670a6dccbc566a649fb9e137dc736a61e65c05814b381fb86fe817";
           configureFlags = [ "-ftest" ];
           isLibrary = true;
           isExecutable = true;
           enableSeparateDataOutput = true;
           setupHaskellDepends = [ base Cabal ];
           libraryHaskellDepends = [
             aeson base base-compat bytestring containers data-default
             data-lens-light directory filepath ghc-paths haskell-src-exts
             language-ecmascript mtl mtl-compat process safe shakespeare
             sourcemap split spoon syb text time transformers
             transformers-compat traverse-with-class uniplate
             unordered-containers utf8-string vector
           ];
           executableHaskellDepends = [
             aeson attoparsec base bytestring containers directory filepath
             haskell-src-exts mtl optparse-applicative random split tasty
             tasty-hunit tasty-th text utf8-string
           ];
           doHaddock = false;
           doCheck = false;
           homepage = "https://github.com/faylang/fay/wiki";
           description = "A compiler for Fay, a Haskell subset that compiles to JavaScript";
           license = stdenv.lib.licenses.bsd3;
         }) {};
      "fay-base" = callPackage
        ({ mkDerivation, base, fay, stdenv }:
         mkDerivation {
           pname = "fay-base";
           version = "0.21.1.0";
           sha256 = "5f94e3657276c5d15fcec039e8fa28f4f0d923aab17069518f6a7ca208c029c4";
           enableSeparateDataOutput = true;
           libraryHaskellDepends = [ base fay ];
           doHaddock = false;
           doCheck = false;
           homepage = "https://github.com/faylang/fay/";
           description = "The base package for Fay";
           license = stdenv.lib.licenses.bsd3;
         }) {};
      "fay-dom" = callPackage
        ({ mkDerivation, fay-base, stdenv }:
         mkDerivation {
           pname = "fay-dom";
           version = "0.5.0.1";
           sha256 = "e0f2e4dc11a13c4a9c43d707a3cf24bc1badb585540d24b29e8a6bc6ace1a6fe";
           revision = "1";
           editedCabalFile = "1lhmkf2n7prv6w51bl3szz4g9cn2dkhb873m7f568nnwysqibv8b";
           enableSeparateDataOutput = true;
           libraryHaskellDepends = [ fay-base ];
           doHaddock = false;
           doCheck = false;
           homepage = "https://github.com/faylang/fay-dom";
           description = "DOM FFI wrapper library for Fay";
           license = stdenv.lib.licenses.bsd3;
         }) {};
      "fb" = callPackage
        ({ mkDerivation, aeson, attoparsec, base, base16-bytestring
         , base64-bytestring, bytestring, cereal, conduit, conduit-extra
         , crypto-api, cryptohash, cryptohash-cryptoapi, data-default
         , http-client, http-conduit, http-types, monad-logger, old-locale
         , resourcet, stdenv, text, time, transformers, transformers-base
         , unliftio, unliftio-core, unordered-containers
         }:
         mkDerivation {
           pname = "fb";
           version = "1.2.1";
           sha256 = "a9d670a763e2ccf3e457e6b310769d5d8977cb1c00a78c8825861999da055d15";
           libraryHaskellDepends = [
             aeson attoparsec base base16-bytestring base64-bytestring
             bytestring cereal conduit conduit-extra crypto-api cryptohash
             cryptohash-cryptoapi data-default http-client http-conduit
             http-types monad-logger old-locale resourcet text time transformers
             transformers-base unliftio unliftio-core unordered-containers
           ];
           doHaddock = false;
           doCheck = false;
           homepage = "https://github.com/psibi/fb";
           description = "Bindings to Facebook's API";
           license = stdenv.lib.licenses.bsd3;
         }) {};
      "fclabels" = callPackage
        ({ mkDerivation, base, mtl, stdenv, template-haskell, transformers
         }:
         mkDerivation {
           pname = "fclabels";
           version = "2.0.3.3";
           sha256 = "9a9472a46dc23b5acc0545d345ecd708f7b003f72ab212e2d12125b902b9c2e0";
           revision = "3";
           editedCabalFile = "1wncfnvh4mv87gh0ddhiqf839d63rqs1qzi3y386y6r8hfnvra0l";
           libraryHaskellDepends = [ base mtl template-haskell transformers ];
           doHaddock = false;
           doCheck = false;
           homepage = "https://github.com/sebastiaanvisser/fclabels";
           description = "First class accessor labels implemented as lenses";
           license = stdenv.lib.licenses.bsd3;
         }) {};
      "feature-flags" = callPackage
        ({ mkDerivation, base, stdenv, text }:
         mkDerivation {
           pname = "feature-flags";
           version = "0.1.0.1";
           sha256 = "0e4cf7db6791b0875975dfa001d71bf31797b2edbfd2424f6b6202ace7935ad3";
           libraryHaskellDepends = [ base text ];
           doHaddock = false;
           doCheck = false;
           homepage = "https://github.com/iand675/feature-flags";
           description = "A simple library for dynamically enabling and disabling functionality";
           license = stdenv.lib.licenses.mit;
         }) {};
      "fedora-haskell-tools" = callPackage
        ({ mkDerivation, base, directory, filepath, process, stdenv, time
         , unix
         }:
         mkDerivation {
           pname = "fedora-haskell-tools";
           version = "0.5.1";
           sha256 = "b9a9119aace941ff5860c02462bf340c6f3cce29f7bdcb42af98dedfa9888394";
           isLibrary = false;
           isExecutable = true;
           executableHaskellDepends = [
             base directory filepath process time unix
           ];
           doHaddock = false;
           doCheck = false;
           homepage = "https://github.com/fedora-haskell/fedora-haskell-tools";
           description = "Building and managing tools for Fedora Haskell";
           license = stdenv.lib.licenses.gpl3;
         }) {};
      "feed" = callPackage
        ({ mkDerivation, base, base-compat, bytestring, old-locale
         , old-time, safe, stdenv, text, time, time-locale-compat
         , utf8-string, xml-conduit, xml-types
         }:
         mkDerivation {
           pname = "feed";
           version = "1.0.1.0";
           sha256 = "87bd055b13c43f54e997f716a33d647c6bc1cdb78337c840d144c0b5fdccd31c";
           revision = "1";
           editedCabalFile = "10xjd3syr70g3blnjy7xvd6s21y68vxsi69f6bmizpsylbfb0245";
           enableSeparateDataOutput = true;
           libraryHaskellDepends = [
             base base-compat bytestring old-locale old-time safe text time
             time-locale-compat utf8-string xml-conduit xml-types
           ];
           doHaddock = false;
           doCheck = false;
           homepage = "https://github.com/bergmark/feed";
           description = "Interfacing with RSS (v 0.9x, 2.x, 1.0) + Atom feeds.";
           license = stdenv.lib.licenses.bsd3;
         }) {};
      "fft" = callPackage
        ({ mkDerivation, array, base, carray, fftw, fftwFloat, ix-shapable
         , stdenv, storable-complex, syb, transformers
         }:
         mkDerivation {
           pname = "fft";
           version = "0.1.8.6";
           sha256 = "2ed8d8301903283c9a62eda1f1cf49db0c471c4c128fbfdef562d598401e5b42";
           libraryHaskellDepends = [
             array base carray ix-shapable storable-complex syb transformers
           ];
           libraryPkgconfigDepends = [ fftw fftwFloat ];
           doHaddock = false;
           doCheck = false;
           description = "Bindings to the FFTW library";
           license = stdenv.lib.licenses.bsd3;
         }) {inherit (pkgs) fftw; inherit (pkgs) fftwFloat;};
      "fgl" = callPackage
        ({ mkDerivation, array, base, containers, deepseq, stdenv
         , transformers
         }:
         mkDerivation {
           pname = "fgl";
           version = "5.6.0.0";
           sha256 = "94722e1eb3dca66069e26a2d4b072c558bc896816ee016fc99521f3e16b9ccc4";
           revision = "1";
           editedCabalFile = "17r5p1c6srgyzpdkqkjcl9k3ax9c82lvps1kqjhxpdzypsnzns70";
           libraryHaskellDepends = [
             array base containers deepseq transformers
           ];
           doHaddock = false;
           doCheck = false;
           description = "Martin Erwig's Functional Graph Library";
           license = stdenv.lib.licenses.bsd3;
         }) {};
      "file-embed" = callPackage
        ({ mkDerivation, base, bytestring, directory, filepath, stdenv
         , template-haskell
         }:
         mkDerivation {
           pname = "file-embed";
           version = "0.0.10.1";
           sha256 = "33cdeb44e8fa1ca8ade64e2b8d0924ea8c70b2b521455a0f22cde36f19314152";
           libraryHaskellDepends = [
             base bytestring directory filepath template-haskell
           ];
           doHaddock = false;
           doCheck = false;
           homepage = "https://github.com/snoyberg/file-embed";
           description = "Use Template Haskell to embed file contents directly";
           license = stdenv.lib.licenses.bsd3;
         }) {};
      "file-embed-lzma" = callPackage
        ({ mkDerivation, base, base-compat, bytestring, directory, filepath
         , lzma, stdenv, template-haskell, text, th-lift-instances
         , transformers
         }:
         mkDerivation {
           pname = "file-embed-lzma";
           version = "0";
           sha256 = "e86cf44f747cf403898158e9fdf9342871e293097a29679fcf587aed497f0c77";
           revision = "2";
           editedCabalFile = "0dmg69gsj2k9lf112bvqw6z2w8hl0p1lx5zxdvlvk85bb3qz6304";
           libraryHaskellDepends = [
             base base-compat bytestring directory filepath lzma
             template-haskell text th-lift-instances transformers
           ];
           doHaddock = false;
           doCheck = false;
           homepage = "https://github.com/phadej/file-embed-lzma";
           description = "Use Template Haskell to embed (LZMA compressed) data";
           license = stdenv.lib.licenses.bsd3;
         }) {};
      "file-modules" = callPackage
        ({ mkDerivation, async, base, directory, filepath, haskell-src-exts
         , MissingH, regex-compat, regex-pcre, stdenv
         }:
         mkDerivation {
           pname = "file-modules";
           version = "0.1.2.4";
           sha256 = "ffea2dbd51f77ed76f8559d8519674a1210611a35e2dbea72dfb41d7d5f0f235";
           isLibrary = true;
           isExecutable = true;
           libraryHaskellDepends = [
             async base directory filepath haskell-src-exts MissingH
             regex-compat regex-pcre
           ];
           executableHaskellDepends = [
             async base directory filepath haskell-src-exts MissingH
             regex-compat regex-pcre
           ];
           doHaddock = false;
           doCheck = false;
           homepage = "https://github.com/yamadapc/stack-run-auto";
           description = "Takes a Haskell source-code file and outputs its modules";
           license = stdenv.lib.licenses.mit;
         }) {};
      "filecache" = callPackage
        ({ mkDerivation, base, containers, directory, exceptions, filepath
         , fsnotify, mtl, stdenv, stm, strict-base-types, time
         }:
         mkDerivation {
           pname = "filecache";
           version = "0.4.1";
           sha256 = "c502a8b43cf08694c8d2657dc282306d811cdd91f284614a6a9945267c93cb9d";
           libraryHaskellDepends = [
             base containers directory exceptions filepath fsnotify mtl stm
             strict-base-types time
           ];
           doHaddock = false;
           doCheck = false;
           homepage = "http://lpuppet.banquise.net/";
           description = "A cache system associating values to files";
           license = stdenv.lib.licenses.bsd3;
         }) {};
      "filelock" = callPackage
        ({ mkDerivation, base, stdenv, unix }:
         mkDerivation {
           pname = "filelock";
           version = "0.1.1.2";
           sha256 = "0ff1dcb13ec619f72496035e2a1298ef9dc6a814ba304d882cd9b145eae3203d";
           libraryHaskellDepends = [ base unix ];
           doHaddock = false;
           doCheck = false;
           homepage = "http://github.com/takano-akio/filelock";
           description = "Portable interface to file locking (flock / LockFileEx)";
           license = stdenv.lib.licenses.publicDomain;
         }) {};
      "filemanip" = callPackage
        ({ mkDerivation, base, bytestring, directory, filepath, mtl, stdenv
         , unix-compat
         }:
         mkDerivation {
           pname = "filemanip";
           version = "0.3.6.3";
           sha256 = "8836da17baaaf02ca080c9990ece4e0b0c8d6a128f458f8b64fd07b225ca9846";
           libraryHaskellDepends = [
             base bytestring directory filepath mtl unix-compat
           ];
           doHaddock = false;
           doCheck = false;
           homepage = "https://github.com/bos/filemanip";
           description = "Expressive file and directory manipulation for Haskell";
           license = stdenv.lib.licenses.bsd3;
         }) {};
      "fileplow" = callPackage
        ({ mkDerivation, base, binary-search, bytestring, stdenv, vector }:
         mkDerivation {
           pname = "fileplow";
           version = "0.1.0.0";
           sha256 = "9ddc7db62c97fa4413ff2435c96aac9f6f716e2f6bc7a71aa4db25c3871bee04";
           libraryHaskellDepends = [ base binary-search bytestring vector ];
           doHaddock = false;
           doCheck = false;
           homepage = "https://github.com/agrafix/fileplow#readme";
           description = "Library to process and search large files or a collection of files";
           license = stdenv.lib.licenses.bsd3;
         }) {};
      "filter-logger" = callPackage
        ({ mkDerivation, aeson, aeson-pretty, ansi-terminal, base
         , bytestring, data-default, fast-logger, http-types, scotty
         , semigroups, stdenv, time, wai, wai-extra, wai-logger
         }:
         mkDerivation {
           pname = "filter-logger";
           version = "0.6.0.0";
           sha256 = "7884124056950a7f7ff393ebb7d1622695f9b66f898c60aeb8bc991c73642f21";
           isLibrary = true;
           isExecutable = true;
           libraryHaskellDepends = [
             aeson aeson-pretty ansi-terminal base bytestring data-default
             fast-logger http-types semigroups time wai wai-extra wai-logger
           ];
           executableHaskellDepends = [ aeson base bytestring scotty ];
           doHaddock = false;
           doCheck = false;
           homepage = "https://github.com/caneroj1/filter-logger#readme";
           description = "Filterable request logging wai middleware. Change how data is logged and when.";
           license = stdenv.lib.licenses.mit;
         }) {};
      "filtrable" = callPackage
        ({ mkDerivation, base, stdenv }:
         mkDerivation {
           pname = "filtrable";
           version = "0.1.1.0";
           sha256 = "d6a53889a7d114a7ea411026b994c9f73ebfeffe68ea338ce2abf9dc977e363c";
           libraryHaskellDepends = [ base ];
           doHaddock = false;
           doCheck = false;
           homepage = "https://github.com/strake/filtrable.hs";
           description = "Class of filtrable containers";
           license = stdenv.lib.licenses.bsd3;
         }) {};
      "fin" = callPackage
        ({ mkDerivation, base, deepseq, hashable, stdenv }:
         mkDerivation {
           pname = "fin";
           version = "0.0.1";
           sha256 = "34d28a951f2899f1d27bfb75d53818204d6d7e5aeaaef1a326c50ae915361a57";
           revision = "1";
           editedCabalFile = "056d22f1j1xv5ka2qr7a3z5ad5w1im76qdf77v6dqdi4vaz52vd1";
           libraryHaskellDepends = [ base deepseq hashable ];
           doHaddock = false;
           doCheck = false;
           homepage = "https://github.com/phadej/vec";
           description = "Nat and Fin: peano naturals and finite numbers";
           license = stdenv.lib.licenses.bsd3;
         }) {};
      "find-clumpiness" = callPackage
        ({ mkDerivation, aeson, base, BiobaseNewick, bytestring, clumpiness
         , containers, hierarchical-clustering, listsafe, mtl
         , optparse-applicative, stdenv, text, text-show, tree-fun
         , unordered-containers, vector
         }:
         mkDerivation {
           pname = "find-clumpiness";
           version = "0.2.3.1";
           sha256 = "089e55641eedd12ab16ae5e81cbd2c6c0375801c01fc17fb2ce23354a0ec2c2a";
           isLibrary = true;
           isExecutable = true;
           libraryHaskellDepends = [
             aeson base BiobaseNewick bytestring clumpiness containers
             hierarchical-clustering listsafe mtl text text-show tree-fun
             unordered-containers vector
           ];
           executableHaskellDepends = [
             aeson base BiobaseNewick bytestring clumpiness containers
             optparse-applicative text tree-fun unordered-containers
           ];
           doHaddock = false;
           doCheck = false;
           homepage = "http://github.com/GregorySchwartz/find-clumpiness#readme";
           description = "Find the clumpiness of labels in a tree";
           license = stdenv.lib.licenses.gpl3;
         }) {};
      "fingertree" = callPackage
        ({ mkDerivation, base, stdenv }:
         mkDerivation {
           pname = "fingertree";
           version = "0.1.4.2";
           sha256 = "95a948341570bad5a9b2468c388c0eb2c20c57e10dd8fbfc994c7b8764b36a7f";
           libraryHaskellDepends = [ base ];
           doHaddock = false;
           doCheck = false;
           description = "Generic finger-tree structure, with example instances";
           license = stdenv.lib.licenses.bsd3;
         }) {};
      "finite-typelits" = callPackage
        ({ mkDerivation, base, deepseq, stdenv }:
         mkDerivation {
           pname = "finite-typelits";
           version = "0.1.4.2";
           sha256 = "d207a46c911b69ecc1f7c50d9d65ea1aca6c6efacec6342bc3294ed1bc4bd747";
           libraryHaskellDepends = [ base deepseq ];
           doHaddock = false;
           doCheck = false;
           homepage = "https://github.com/mniip/finite-typelits";
           description = "A type inhabited by finitely many values, indexed by type-level naturals";
           license = stdenv.lib.licenses.bsd3;
         }) {};
      "first-class-patterns" = callPackage
        ({ mkDerivation, base, stdenv, transformers }:
         mkDerivation {
           pname = "first-class-patterns";
           version = "0.3.2.4";
           sha256 = "3bf42829097277a89043021d02b82bde24950de9c30d19b33c0ffa5e1f2482b5";
           libraryHaskellDepends = [ base transformers ];
           doHaddock = false;
           doCheck = false;
           homepage = "https://github.com/kowainik/first-class-patterns";
           description = "First class patterns and pattern matching, using type families";
           license = stdenv.lib.licenses.bsd3;
         }) {};
      "fixed" = callPackage
        ({ mkDerivation, base, stdenv }:
         mkDerivation {
           pname = "fixed";
           version = "0.2.1.1";
           sha256 = "24a9e1e251998c9d06037bb771d9eab2980a91132de59a19d0166a1c51e715e2";
           libraryHaskellDepends = [ base ];
           doHaddock = false;
           doCheck = false;
           homepage = "http://github.com/ekmett/fixed";
           description = "Signed 15.16 precision fixed point arithmetic";
           license = stdenv.lib.licenses.bsd3;
         }) {};
      "fixed-length" = callPackage
        ({ mkDerivation, base, non-empty, stdenv, tfp, utility-ht }:
         mkDerivation {
           pname = "fixed-length";
           version = "0.2";
           sha256 = "3171f2d443171a8e92733b3935805c7d5b54eae1f39f9fd729a766f887a6389b";
           libraryHaskellDepends = [ base non-empty tfp utility-ht ];
           doHaddock = false;
           doCheck = false;
           homepage = "http://hub.darcs.net/thielema/fixed-length/";
           description = "Lists with statically known length based on non-empty package";
           license = stdenv.lib.licenses.bsd3;
         }) {};
      "fixed-vector" = callPackage
        ({ mkDerivation, base, deepseq, primitive, stdenv }:
         mkDerivation {
           pname = "fixed-vector";
           version = "1.1.0.0";
           sha256 = "1ed0bef94b0fead859ad2aea0b73bf1bd3686a6c1faafc75e321fbd9c3ae94c5";
           libraryHaskellDepends = [ base deepseq primitive ];
           doHaddock = false;
           doCheck = false;
           description = "Generic vectors with statically known size";
           license = stdenv.lib.licenses.bsd3;
         }) {};
      "fixed-vector-hetero" = callPackage
        ({ mkDerivation, base, deepseq, fixed-vector, primitive, stdenv }:
         mkDerivation {
           pname = "fixed-vector-hetero";
           version = "0.5.0.0";
           sha256 = "a3f25968b260c953c6ad4ec75ba5211238b2bb07185fe1f33fb98301a4ee8690";
           libraryHaskellDepends = [ base deepseq fixed-vector primitive ];
           doHaddock = false;
           doCheck = false;
           homepage = "http://github.org/Shimuuar/fixed-vector-hetero";
           description = "Generic heterogeneous vectors";
           license = stdenv.lib.licenses.bsd3;
         }) {};
      "flac" = callPackage
        ({ mkDerivation, base, bytestring, containers, data-default-class
         , directory, exceptions, filepath, FLAC, mtl, stdenv, text
         , transformers, vector, wave
         }:
         mkDerivation {
           pname = "flac";
           version = "0.1.2";
           sha256 = "5692b3dfc561cbeed25b1cf9280705f58eadd8c400aa2e6a725fd5562042ac29";
           revision = "5";
           editedCabalFile = "0rwwq8qrxd497rd5m0kidz4v69frj72ds7a6zrdqigj5f5471rhd";
           enableSeparateDataOutput = true;
           libraryHaskellDepends = [
             base bytestring containers data-default-class directory exceptions
             filepath mtl text transformers vector wave
           ];
           librarySystemDepends = [ FLAC ];
           doHaddock = false;
           doCheck = false;
           homepage = "https://github.com/mrkkrp/flac";
           description = "Complete high-level binding to libFLAC";
           license = stdenv.lib.licenses.bsd3;
         }) {inherit (pkgs) FLAC;};
      "flac-picture" = callPackage
        ({ mkDerivation, base, bytestring, flac, JuicyPixels, stdenv }:
         mkDerivation {
           pname = "flac-picture";
           version = "0.1.1";
           sha256 = "3c1cf80c48521370ce6351d4b544c14891442bfe47c65e5bf436fe58f6fec1ce";
           revision = "1";
           editedCabalFile = "02vdh61nzig0yrv6ja6fjlgfcznj5k4iqh3i5f9g5p078ycqb17w";
           enableSeparateDataOutput = true;
           libraryHaskellDepends = [ base bytestring flac JuicyPixels ];
           doHaddock = false;
           doCheck = false;
           homepage = "https://github.com/mrkkrp/flac-picture";
           description = "Support for writing picture to FLAC metadata blocks with JuicyPixels";
           license = stdenv.lib.licenses.bsd3;
         }) {};
      "flat-mcmc" = callPackage
        ({ mkDerivation, base, formatting, mcmc-types, monad-par
         , monad-par-extras, mwc-probability, pipes, primitive, stdenv, text
         , transformers, vector
         }:
         mkDerivation {
           pname = "flat-mcmc";
           version = "1.5.0";
           sha256 = "87cea9deac6e2d32d9984741ba222ccb2fb0d5f8c58e843684476bfe7632f1fd";
           revision = "1";
           editedCabalFile = "1pjkyvs4c6yx6jva08zw2b1qfhhv9q71sy806f5lddjsknnym2fn";
           libraryHaskellDepends = [
             base formatting mcmc-types monad-par monad-par-extras
             mwc-probability pipes primitive text transformers vector
           ];
           doHaddock = false;
           doCheck = false;
           homepage = "https://github.com/jtobin/flat-mcmc";
           description = "Painless general-purpose sampling";
           license = stdenv.lib.licenses.mit;
         }) {};
      "flay" = callPackage
        ({ mkDerivation, base, constraints, stdenv, transformers }:
         mkDerivation {
           pname = "flay";
           version = "0.4";
           sha256 = "01ff3e642eab48807e4369fd8c1336e22d7abdcf4374cd1322b1fe259c9413ef";
           libraryHaskellDepends = [ base constraints transformers ];
           doHaddock = false;
           doCheck = false;
           homepage = "https://github.com/k0001/flay";
           description = "Work generically on your datatype without knowing its shape nor its contents";
           license = stdenv.lib.licenses.bsd3;
         }) {};
      "flexible-defaults" = callPackage
        ({ mkDerivation, base, containers, stdenv, template-haskell
         , th-extras, transformers
         }:
         mkDerivation {
           pname = "flexible-defaults";
           version = "0.0.2";
           sha256 = "f3d5d41a6dd69dbb585dd10fe6b7fe9023bc4308bac1320a55b62758acc18a64";
           libraryHaskellDepends = [
             base containers template-haskell th-extras transformers
           ];
           doHaddock = false;
           doCheck = false;
           homepage = "https://github.com/peti/flexible-defaults";
           description = "Generate default function implementations for complex type classes";
           license = stdenv.lib.licenses.publicDomain;
         }) {};
      "floatshow" = callPackage
        ({ mkDerivation, array, base, integer-gmp, stdenv }:
         mkDerivation {
           pname = "floatshow";
           version = "0.2.4";
           sha256 = "0c4e9494df46120942b2078db53c16200b46eff603fca5ab85775a541f975dff";
           libraryHaskellDepends = [ array base integer-gmp ];
           doHaddock = false;
           doCheck = false;
           homepage = "https://bitbucket.org/dafis/floatshow";
           description = "Alternative faster String representations for Double and Float, String representations for more general numeric types";
           license = stdenv.lib.licenses.bsd3;
         }) {};
      "flow" = callPackage
        ({ mkDerivation, base, stdenv }:
         mkDerivation {
           pname = "flow";
           version = "1.0.17";
           sha256 = "86ec19d8bec13afc58e21d53f4225c3fcafda2ff902b05f64062919edbe84d19";
           libraryHaskellDepends = [ base ];
           doHaddock = false;
           doCheck = false;
           homepage = "https://github.com/tfausak/flow#readme";
           description = "Write more understandable Haskell";
           license = stdenv.lib.licenses.mit;
         }) {};
      "fmlist" = callPackage
        ({ mkDerivation, base, stdenv }:
         mkDerivation {
           pname = "fmlist";
           version = "0.9.2";
           sha256 = "8fc4b55d04e7f216740a01acd2f38293e3bd9409a9495e6042a162580c420609";
           libraryHaskellDepends = [ base ];
           doHaddock = false;
           doCheck = false;
           homepage = "https://github.com/sjoerdvisscher/fmlist";
           description = "FoldMap lists";
           license = stdenv.lib.licenses.bsd3;
         }) {};
      "fn" = callPackage
        ({ mkDerivation, base, blaze-builder, bytestring, directory
         , filepath, http-types, resourcet, stdenv, text
         , unordered-containers, wai, wai-extra
         }:
         mkDerivation {
           pname = "fn";
           version = "0.3.0.2";
           sha256 = "1e34b017aa13f60464ec06dfbae970c3c0f01f2160f5001a4e84c8179de7ae5f";
           libraryHaskellDepends = [
             base blaze-builder bytestring directory filepath http-types
             resourcet text unordered-containers wai wai-extra
           ];
           doHaddock = false;
           doCheck = false;
           homepage = "http://github.com/positiondev/fn#readme";
           description = "A functional web framework";
           license = stdenv.lib.licenses.isc;
         }) {};
      "focus" = callPackage
        ({ mkDerivation, base, stdenv }:
         mkDerivation {
           pname = "focus";
           version = "0.1.5.2";
           sha256 = "c2988d48c2bc6861a00be4e02161df96abcbf6c80e801676cee39b7628715cb7";
           libraryHaskellDepends = [ base ];
           doHaddock = false;
           doCheck = false;
           homepage = "https://github.com/nikita-volkov/focus";
           description = "A general abstraction for manipulating elements of container data structures";
           license = stdenv.lib.licenses.mit;
         }) {};
      "focuslist" = callPackage
        ({ mkDerivation, base, Cabal, cabal-doctest, containers, lens
         , mono-traversable, QuickCheck, stdenv
         }:
         mkDerivation {
           pname = "focuslist";
           version = "0.1.0.1";
           sha256 = "fdee9ae7a68f139f9b4b88df27e4f373815293da93a1df91e5c2f3dc558f05e3";
           revision = "2";
           editedCabalFile = "12x38kxhcjdqfwl8y8zdrwcpv6jdm7jaqc48ww3hg6fpv8rvvd49";
           isLibrary = true;
           isExecutable = true;
           setupHaskellDepends = [ base Cabal cabal-doctest ];
           libraryHaskellDepends = [
             base containers lens mono-traversable QuickCheck
           ];
           doHaddock = false;
           doCheck = false;
           homepage = "https://github.com/cdepillabout/focuslist";
           description = "Lists with a focused element";
           license = stdenv.lib.licenses.bsd3;
         }) {};
      "fold-debounce" = callPackage
        ({ mkDerivation, base, data-default-class, stdenv, stm, stm-delay
         , time
         }:
         mkDerivation {
           pname = "fold-debounce";
           version = "0.2.0.8";
           sha256 = "fc6b3ef028517f642886c2ffa270726cc38c79be75d1233e28f760816d08fbc8";
           libraryHaskellDepends = [
             base data-default-class stm stm-delay time
           ];
           doHaddock = false;
           doCheck = false;
           homepage = "https://github.com/debug-ito/fold-debounce";
           description = "Fold multiple events that happen in a given period of time";
           license = stdenv.lib.licenses.bsd3;
         }) {};
      "fold-debounce-conduit" = callPackage
        ({ mkDerivation, base, conduit, fold-debounce, resourcet, stdenv
         , stm, transformers, transformers-base
         }:
         mkDerivation {
           pname = "fold-debounce-conduit";
           version = "0.2.0.3";
           sha256 = "97c80c4ca7f84260539829ee7ebf0eaa6b127005158eb910411ae0b17157ef67";
           libraryHaskellDepends = [
             base conduit fold-debounce resourcet stm transformers
             transformers-base
           ];
           doHaddock = false;
           doCheck = false;
           homepage = "https://github.com/debug-ito/fold-debounce-conduit";
           description = "Regulate input traffic from conduit Source with Control.FoldDebounce";
           license = stdenv.lib.licenses.bsd3;
         }) {};
      "foldable1" = callPackage
        ({ mkDerivation, base, stdenv, transformers, util }:
         mkDerivation {
           pname = "foldable1";
           version = "0.1.0.0";
           sha256 = "85d684e5caab9e0c87dd04d016432f4a9effb5c8c62354aedcf85c96c1e3e90a";
           libraryHaskellDepends = [ base transformers util ];
           doHaddock = false;
           doCheck = false;
           description = "Foldable types with at least 1 element";
           license = stdenv.lib.licenses.bsd3;
         }) {};
      "foldl" = callPackage
        ({ mkDerivation, base, bytestring, comonad, containers
         , contravariant, hashable, mwc-random, primitive, profunctors
         , semigroupoids, semigroups, stdenv, text, transformers
         , unordered-containers, vector, vector-builder
         }:
         mkDerivation {
           pname = "foldl";
           version = "1.4.5";
           sha256 = "0ba0bd8a8b4273feef61b66b6e251e70f70537c113f8b7f0e3aeab77d8af12a7";
           revision = "2";
           editedCabalFile = "080v2qwck5k9jfix55bv04h9m9ci14kgdrjbrssab2wgraxpyjvz";
           libraryHaskellDepends = [
             base bytestring comonad containers contravariant hashable
             mwc-random primitive profunctors semigroupoids semigroups text
             transformers unordered-containers vector vector-builder
           ];
           doHaddock = false;
           doCheck = false;
           description = "Composable, streaming, and efficient left folds";
           license = stdenv.lib.licenses.bsd3;
         }) {};
      "folds" = callPackage
        ({ mkDerivation, adjunctions, base, bifunctors, Cabal
         , cabal-doctest, comonad, constraints, contravariant, data-reify
         , distributive, lens, mtl, pointed, profunctors, reflection
         , semigroupoids, stdenv, transformers, unordered-containers, vector
         }:
         mkDerivation {
           pname = "folds";
           version = "0.7.4";
           sha256 = "5c6e6f7c9c852cbe3d5372f93ed99f82400d15ae99ecf8e9e005481647734572";
           configureFlags = [ "-f-test-hlint" ];
           setupHaskellDepends = [ base Cabal cabal-doctest ];
           libraryHaskellDepends = [
             adjunctions base bifunctors comonad constraints contravariant
             data-reify distributive lens mtl pointed profunctors reflection
             semigroupoids transformers unordered-containers vector
           ];
           doHaddock = false;
           doCheck = false;
           homepage = "http://github.com/ekmett/folds";
           description = "Beautiful Folding";
           license = stdenv.lib.licenses.bsd3;
         }) {};
      "force-layout" = callPackage
        ({ mkDerivation, base, containers, data-default-class, lens, linear
         , stdenv
         }:
         mkDerivation {
           pname = "force-layout";
           version = "0.4.0.6";
           sha256 = "f7729855b1b14e0b255325faaca9f4834004e02bd21def6a865d2c55c734259d";
           revision = "4";
           editedCabalFile = "0hpr1z68lflgcdl9gbmva0i52wbgfhh4qj3iwdvzipsp8mwav7s7";
           libraryHaskellDepends = [
             base containers data-default-class lens linear
           ];
           doHaddock = false;
           doCheck = false;
           description = "Simple force-directed layout";
           license = stdenv.lib.licenses.bsd3;
         }) {};
      "foreign-store" = callPackage
        ({ mkDerivation, base, stdenv }:
         mkDerivation {
           pname = "foreign-store";
           version = "0.2";
           sha256 = "06718a214d068eaa494cc82376f23b2059a141b01048cd7efcf2176a6c3383dc";
           libraryHaskellDepends = [ base ];
           doHaddock = false;
           doCheck = false;
           homepage = "https://github.com/chrisdone/foreign-store";
           description = "Store a stable pointer in a foreign context to be retrieved later";
           license = stdenv.lib.licenses.bsd3;
         }) {};
      "forkable-monad" = callPackage
        ({ mkDerivation, base, stdenv, transformers }:
         mkDerivation {
           pname = "forkable-monad";
           version = "0.2.0.3";
           sha256 = "571e33effa5baaef4e2dc910010e2b02c01d8b8e06f051e96906f288f71ad462";
           libraryHaskellDepends = [ base transformers ];
           doHaddock = false;
           doCheck = false;
           homepage = "https://github.com/System-Indystress/ForkableMonad#readme";
           description = "An implementation of forkIO for monad stacks";
           license = stdenv.lib.licenses.bsd3;
         }) {};
      "forma" = callPackage
        ({ mkDerivation, aeson, base, containers, mtl, stdenv, text
         , unordered-containers
         }:
         mkDerivation {
           pname = "forma";
           version = "1.1.0";
           sha256 = "b7dc7270e0a294cdaf40e99f067928411d82ed50af4dad51a6088830d539c325";
           revision = "2";
           editedCabalFile = "1yc9gv1rjbl4lsxscp5idfpn7jp27c38j6gm9v7isxgyaih0j4v4";
           libraryHaskellDepends = [
             aeson base containers mtl text unordered-containers
           ];
           doHaddock = false;
           doCheck = false;
           homepage = "https://github.com/mrkkrp/forma";
           description = "Parse and validate forms in JSON format";
           license = stdenv.lib.licenses.bsd3;
         }) {};
      "format-numbers" = callPackage
        ({ mkDerivation, base, stdenv, text }:
         mkDerivation {
           pname = "format-numbers";
           version = "0.1.0.0";
           sha256 = "0ca4561b55c888552f7bf0eb68e97b62acedcb0d5e5e1cc4afd94402d01231a6";
           libraryHaskellDepends = [ base text ];
           doHaddock = false;
           doCheck = false;
           homepage = "https://github.com/agrafix/format-numbers#readme";
           description = "Various number formatting functions";
           license = stdenv.lib.licenses.mit;
         }) {};
      "formatting" = callPackage
        ({ mkDerivation, array, base, bytestring, clock, ghc-prim
         , integer-gmp, old-locale, scientific, semigroups, stdenv, text
         , time, transformers
         }:
         mkDerivation {
           pname = "formatting";
           version = "6.3.6";
           sha256 = "6a28db7625f912dfa0075d4376b6f1b7f84d139defda53c90e440dcf74aad31a";
           revision = "1";
           editedCabalFile = "0vw77ji2d7rhwhq2g7dmln9ifsghgzdlnxg4wjipb128f6gwclh7";
           libraryHaskellDepends = [
             array base bytestring clock ghc-prim integer-gmp old-locale
             scientific semigroups text time transformers
           ];
           doHaddock = false;
           doCheck = false;
           description = "Combinator-based type-safe formatting (like printf() or FORMAT)";
           license = stdenv.lib.licenses.bsd3;
         }) {};
      "foundation" = callPackage
        ({ mkDerivation, base, basement, ghc-prim, stdenv }:
         mkDerivation {
           pname = "foundation";
           version = "0.0.21";
           sha256 = "4ed3a0e7f8052b52d27c9806eff3bea51acc2587f74f81db4b8e03e938f283e0";
           revision = "1";
           editedCabalFile = "07mzfc75wl7kn2lr2gmbx4i0a5gxyi9b066rz0x2pqxqav3fwqs0";
           libraryHaskellDepends = [ base basement ghc-prim ];
           doHaddock = false;
           doCheck = false;
           homepage = "https://github.com/haskell-foundation/foundation";
           description = "Alternative prelude with batteries and no dependencies";
           license = stdenv.lib.licenses.bsd3;
         }) {};
      "free" = callPackage
        ({ mkDerivation, base, bifunctors, comonad, containers
         , distributive, exceptions, mtl, profunctors, semigroupoids
         , semigroups, stdenv, template-haskell, transformers
         , transformers-base, transformers-compat
         }:
         mkDerivation {
           pname = "free";
           version = "5.0.2";
           sha256 = "ef05eb1c8e69742a4f962c573ef362e44ad48772940f1ef69fe39f0f77b2a396";
           libraryHaskellDepends = [
             base bifunctors comonad containers distributive exceptions mtl
             profunctors semigroupoids semigroups template-haskell transformers
             transformers-base transformers-compat
           ];
           doHaddock = false;
           doCheck = false;
           homepage = "http://github.com/ekmett/free/";
           description = "Monads for free";
           license = stdenv.lib.licenses.bsd3;
         }) {};
      "free-vl" = callPackage
        ({ mkDerivation, base, stdenv }:
         mkDerivation {
           pname = "free-vl";
           version = "0.1.4";
           sha256 = "57f63ed35b42fc54fefb3cc183d0655e0d6c4a28d5371dba00fc9c9d3fa602bf";
           revision = "1";
           editedCabalFile = "1711k76b6w7gfqvc8z9jnylj4hhk3rvx7ap31y1mmq4g2a4s82qm";
           isLibrary = true;
           isExecutable = true;
           libraryHaskellDepends = [ base ];
           executableHaskellDepends = [ base ];
           doHaddock = false;
           doCheck = false;
           homepage = "http://github.com/aaronlevin/free-vl";
           description = "van Laarhoven encoded Free Monad with Extensible Effects";
           license = stdenv.lib.licenses.bsd3;
         }) {};
      "freenect" = callPackage
        ({ mkDerivation, base, freenect, freenect_sync, libfreenect, stdenv
         , vector
         }:
         mkDerivation {
           pname = "freenect";
           version = "1.2.1";
           sha256 = "fca7aa958ec04396334b101679f8603850d7c6629770d5206d774e115cd70759";
           libraryHaskellDepends = [ base vector ];
           librarySystemDepends = [ freenect freenect_sync ];
           libraryPkgconfigDepends = [ libfreenect ];
           doHaddock = false;
           doCheck = false;
           homepage = "https://github.com/chrisdone/freenect";
           description = "Interface to the Kinect device";
           license = stdenv.lib.licenses.bsd3;
         }) {inherit (pkgs) freenect; inherit (pkgs) freenect_sync; 
inherit (pkgs) libfreenect;};
      "freer-simple" = callPackage
        ({ mkDerivation, base, natural-transformation, stdenv
         , transformers-base
         }:
         mkDerivation {
           pname = "freer-simple";
           version = "1.1.0.0";
           sha256 = "2198cdb1f6206b192bed553757cfc145485ee86be7261878bf44bc0e84b1bb01";
           isLibrary = true;
           isExecutable = true;
           libraryHaskellDepends = [
             base natural-transformation transformers-base
           ];
           executableHaskellDepends = [ base ];
           doHaddock = false;
           doCheck = false;
           homepage = "https://github.com/lexi-lambda/freer-simple#readme";
           description = "Implementation of a friendly effect system for Haskell";
           license = stdenv.lib.licenses.bsd3;
         }) {};
      "freetype2" = callPackage
        ({ mkDerivation, base, stdenv }:
         mkDerivation {
           pname = "freetype2";
           version = "0.1.2";
           sha256 = "517e80298890e903b03134d7840d3d1a517bfdad53127ed57c2fdd18cbfae302";
           isLibrary = true;
           isExecutable = true;
           libraryHaskellDepends = [ base ];
           doHaddock = false;
           doCheck = false;
           description = "Haskell binding for FreeType 2 library";
           license = stdenv.lib.licenses.bsd3;
         }) {};
      "friday" = callPackage
        ({ mkDerivation, base, containers, convertible, deepseq, primitive
         , ratio-int, stdenv, transformers, vector
         }:
         mkDerivation {
           pname = "friday";
           version = "0.2.3.1";
           sha256 = "0827492c1a6116baa5c4866539a4cfa0f6d81bf31f6573616bf5ac4484199613";
           revision = "1";
           editedCabalFile = "0n1f4plvrmad6gm8dbsi6g5ghahdwwy2fhgippmnp1ixb65x7d58";
           libraryHaskellDepends = [
             base containers convertible deepseq primitive ratio-int
             transformers vector
           ];
           doHaddock = false;
           doCheck = false;
           homepage = "https://github.com/RaphaelJ/friday";
           description = "A functional image processing library for Haskell";
           license = stdenv.lib.licenses.lgpl3;
         }) {};
      "friday-juicypixels" = callPackage
        ({ mkDerivation, base, friday, JuicyPixels, stdenv, vector }:
         mkDerivation {
           pname = "friday-juicypixels";
           version = "0.1.2.4";
           sha256 = "6d59828fe700ddd0777d180551c5f62444c18fd0b27ae3a675ad185efa90ae3f";
           libraryHaskellDepends = [ base friday JuicyPixels vector ];
           doHaddock = false;
           doCheck = false;
           homepage = "github.com/TomMD/friday-juicypixels";
           description = "Converts between the Friday and JuicyPixels image types";
           license = stdenv.lib.licenses.bsd3;
         }) {};
      "friendly-time" = callPackage
        ({ mkDerivation, base, old-locale, stdenv, time }:
         mkDerivation {
           pname = "friendly-time";
           version = "0.4.1";
           sha256 = "9af3443227c3f271f5d11ed8c3c15c77a59de3ab82d87d93ac1f8455a54393c8";
           revision = "1";
           editedCabalFile = "096nfaqxavi6xblqh4q5dxks824liz75b4rm2la2hlkkn5mhqdgs";
           libraryHaskellDepends = [ base old-locale time ];
           doHaddock = false;
           doCheck = false;
           description = "Print time information in friendly ways";
           license = stdenv.lib.licenses.bsd3;
         }) {};
      "frisby" = callPackage
        ({ mkDerivation, array, base, containers, mtl, semigroups, stdenv
         }:
         mkDerivation {
           pname = "frisby";
           version = "0.2.2";
           sha256 = "c1b318dbf54d56e1012955cc47a1633af5fd77facc128c725353718c0663b6d5";
           libraryHaskellDepends = [ array base containers mtl semigroups ];
           doHaddock = false;
           doCheck = false;
           homepage = "http://repetae.net/computer/frisby/";
           description = "Linear time composable parser for PEG grammars";
           license = stdenv.lib.licenses.bsd3;
         }) {};
      "from-sum" = callPackage
        ({ mkDerivation, base, mtl, stdenv }:
         mkDerivation {
           pname = "from-sum";
           version = "0.2.1.0";
           sha256 = "a1ed8a433b98df8a70be2f9199abae3e5ed7fb4c2f2b3fb1268b6b588f326667";
           libraryHaskellDepends = [ base mtl ];
           doHaddock = false;
           doCheck = false;
           homepage = "https://github.com/cdepillabout/from-sum";
           description = "Canonical fromMaybeM and fromEitherM functions";
           license = stdenv.lib.licenses.bsd3;
         }) {};
      "frontmatter" = callPackage
        ({ mkDerivation, attoparsec, base, bytestring, stdenv, yaml }:
         mkDerivation {
           pname = "frontmatter";
           version = "0.1.0.2";
           sha256 = "66eb97b0d5097397f0238b9af764a8c6ea2bb9a4a16cd1214051719fc313b99d";
           libraryHaskellDepends = [ attoparsec base bytestring yaml ];
           doHaddock = false;
           doCheck = false;
           homepage = "https://github.com/yamadapc/haskell-frontmatter";
           description = "Parses frontmatter as used in Jekyll markdown files";
           license = stdenv.lib.licenses.mit;
         }) {};
      "fsnotify" = callPackage
        ({ mkDerivation, async, base, bytestring, containers, directory
         , filepath, hinotify, shelly, stdenv, text, time, unix, unix-compat
         }:
         mkDerivation {
           pname = "fsnotify";
           version = "0.3.0.1";
           sha256 = "ded2165f72a2b4971f941cb83ef7f58b200e3e04159be78da55ba6c5d35f6da5";
           revision = "1";
           editedCabalFile = "1pa9pa0kflkqlb4dysagy0aihn452hmf6wwlsr7fp4ygg86m7fsq";
           libraryHaskellDepends = [
             async base bytestring containers directory filepath hinotify shelly
             text time unix unix-compat
           ];
           doHaddock = false;
           doCheck = false;
           homepage = "https://github.com/haskell-fswatch/hfsnotify";
           description = "Cross platform library for file change notification";
           license = stdenv.lib.licenses.bsd3;
         }) {};
      "fsnotify-conduit" = callPackage
        ({ mkDerivation, base, conduit, directory, filepath, fsnotify
         , resourcet, stdenv, transformers
         }:
         mkDerivation {
           pname = "fsnotify-conduit";
           version = "0.1.1.1";
           sha256 = "03990f311f7d66a6996b88722602b6058fbae7ad33e74073875ef0466ef001ce";
           libraryHaskellDepends = [
             base conduit directory filepath fsnotify resourcet transformers
           ];
           doHaddock = false;
           doCheck = false;
           homepage = "https://github.com/fpco/fsnotify-conduit#readme";
           description = "Get filesystem notifications as a stream of events";
           license = stdenv.lib.licenses.mit;
         }) {};
      "funcmp" = callPackage
        ({ mkDerivation, base, filepath, pretty, process, stdenv }:
         mkDerivation {
           pname = "funcmp";
           version = "1.9";
           sha256 = "08b2b982fc301af160ae5f2ab5d01e850b4ed177963fb19b4d4b2a28e7bdaab4";
           enableSeparateDataOutput = true;
           libraryHaskellDepends = [ base filepath pretty process ];
           doHaddock = false;
           doCheck = false;
           homepage = "https://github.com/peti/funcmp";
           description = "Functional MetaPost is a Haskell frontend to the MetaPost language";
           license = stdenv.lib.licenses.gpl3;
         }) {};
      "functor-classes-compat" = callPackage
        ({ mkDerivation, base, containers, hashable, stdenv
         , unordered-containers, vector
         }:
         mkDerivation {
           pname = "functor-classes-compat";
           version = "1";
           sha256 = "ef11f94f44a74d6657ee61dcd2cfbc6d0889d233a2fb4caae6a29d9c59a1366f";
           revision = "3";
           editedCabalFile = "1jx552ysdnxvd8wdvsf4bgxlsgldpb7a8zi54abyjmxv6mkp98ys";
           configureFlags = [ "-fcontainers" ];
           libraryHaskellDepends = [
             base containers hashable unordered-containers vector
           ];
           doHaddock = false;
           doCheck = false;
           homepage = "https://github.com/phadej/functor-classes-compat#readme";
           description = "Data.Functor.Classes instances for core packages";
           license = stdenv.lib.licenses.bsd3;
         }) {};
      "fuzzcheck" = callPackage
        ({ mkDerivation, base, lifted-base, monad-control, QuickCheck
         , random, stdenv, transformers
         }:
         mkDerivation {
           pname = "fuzzcheck";
           version = "0.1.1";
           sha256 = "ecd664796e9cf5c608ca904897dd9ec18b471a86fcfb4216328382b28023d961";
           libraryHaskellDepends = [
             base lifted-base monad-control QuickCheck random transformers
           ];
           doHaddock = false;
           doCheck = false;
           homepage = "https://github.com/fpco/fuzzcheck";
           description = "A simple checker for stress testing monadic code";
           license = stdenv.lib.licenses.bsd3;
         }) {};
      "fuzzy-dates" = callPackage
        ({ mkDerivation, base, hourglass, hspec, lens, parsec, stdenv }:
         mkDerivation {
           pname = "fuzzy-dates";
           version = "0.1.1.1";
           sha256 = "e33406933fbb45172f5ee9b10194397333effecc3ce5f1495521bc903faf56c1";
           libraryHaskellDepends = [ base hourglass hspec lens parsec ];
           doHaddock = false;
           doCheck = false;
           homepage = "https://github.com/ReedOei/fuzzy-dates#readme";
           description = "Libary for parsing dates in strings in varied formats";
           license = stdenv.lib.licenses.bsd3;
         }) {};
      "fuzzyset" = callPackage
        ({ mkDerivation, base, base-unicode-symbols, data-default, lens
         , stdenv, text, text-metrics, unordered-containers, vector
         }:
         mkDerivation {
           pname = "fuzzyset";
           version = "0.1.0.6";
           sha256 = "731ae813678de30bbccac03760f7bb0baed5cc8d91ed21e871b1f8d7aafe61a3";
           libraryHaskellDepends = [
             base base-unicode-symbols data-default lens text text-metrics
             unordered-containers vector
           ];
           doHaddock = false;
           doCheck = false;
           homepage = "https://github.com/laserpants/fuzzyset-haskell";
           description = "Fuzzy set for approximate string matching";
           license = stdenv.lib.licenses.bsd3;
         }) {};
      "gauge" = callPackage
        ({ mkDerivation, base, basement, deepseq, directory, process
         , stdenv, vector
         }:
         mkDerivation {
           pname = "gauge";
           version = "0.2.4";
           sha256 = "297fa02ceeb8be23c111ecbd15bfb2203dfa22a757fce51f8ed2829d35630add";
           libraryHaskellDepends = [
             base basement deepseq directory process vector
           ];
           doHaddock = false;
           doCheck = false;
           homepage = "https://github.com/vincenthz/hs-gauge";
           description = "small framework for performance measurement and analysis";
           license = stdenv.lib.licenses.bsd3;
         }) {};
      "gc" = callPackage
        ({ mkDerivation, base, Cabal, cabal-doctest, stdenv }:
         mkDerivation {
           pname = "gc";
           version = "0.0.2";
           sha256 = "39cc5ac887319aeb184ee0d6ddb5b5a34e3f3d38c3fdf3ecc60bdf31a53dc30c";
           setupHaskellDepends = [ base Cabal cabal-doctest ];
           libraryHaskellDepends = [ base ];
           doHaddock = false;
           doCheck = false;
           homepage = "http://github.com/ekmett/gc/";
           description = "Poor Richard's Memory Manager";
           license = stdenv.lib.licenses.bsd3;
         }) {};
      "gd" = callPackage
        ({ mkDerivation, base, bytestring, expat, fontconfig, freetype, gd
         , libjpeg, libpng, stdenv, zlib
         }:
         mkDerivation {
           pname = "gd";
           version = "3000.7.3";
           sha256 = "14aecb600d9a058b1905dfdef3d51a1eb11fb92f804fbaaa041103a0bfd97fb6";
           libraryHaskellDepends = [ base bytestring ];
           librarySystemDepends = [
             expat fontconfig freetype gd libjpeg libpng zlib
           ];
           doHaddock = false;
           doCheck = false;
           description = "A Haskell binding to a subset of the GD graphics library";
           license = stdenv.lib.licenses.bsd3;
         }) {inherit (pkgs) expat; inherit (pkgs) fontconfig; 
inherit (pkgs) freetype; inherit (pkgs) gd; 
inherit (pkgs) libjpeg; inherit (pkgs) libpng; inherit (pkgs) zlib;};
      "gdax" = callPackage
        ({ mkDerivation, aeson, aeson-casing, aeson-pretty, base
         , base64-bytestring, byteable, bytestring, containers, cryptohash
         , exceptions, hashable, http-client, http-client-tls, lens
         , lens-aeson, mtl, regex-tdfa, regex-tdfa-text, scientific, stdenv
         , text, time, unordered-containers, uuid, vector, websockets, wreq
         , wuss
         }:
         mkDerivation {
           pname = "gdax";
           version = "0.6.0.0";
           sha256 = "deb8efce5e4deb5b45c0d66d23eac65224c3d560d7ac67da6d3616cd5a916721";
           isLibrary = true;
           isExecutable = true;
           libraryHaskellDepends = [
             aeson aeson-casing base base64-bytestring byteable bytestring
             containers cryptohash exceptions hashable http-client
             http-client-tls lens lens-aeson mtl regex-tdfa regex-tdfa-text
             scientific text time unordered-containers uuid vector websockets
             wreq wuss
           ];
           executableHaskellDepends = [
             aeson aeson-pretty base base64-bytestring bytestring text vector
             websockets wuss
           ];
           doHaddock = false;
           doCheck = false;
           homepage = "https://github.com/AndrewRademacher/gdax";
           description = "API Wrapping for Coinbase's GDAX exchange";
           license = stdenv.lib.licenses.mit;
         }) {};
      "gdp" = callPackage
        ({ mkDerivation, base, lawful, stdenv }:
         mkDerivation {
           pname = "gdp";
           version = "0.0.0.2";
           sha256 = "214fff5ae2e4952cb8f15e7209be125e760b6d97fac4cd99b2e0592f790a1abf";
           isLibrary = true;
           isExecutable = true;
           libraryHaskellDepends = [ base lawful ];
           executableHaskellDepends = [ base ];
           doHaddock = false;
           doCheck = false;
           homepage = "https://github.com/githubuser/gdp#readme";
           description = "Reason about invariants and preconditions with ghosts of departed proofs";
           license = stdenv.lib.licenses.bsd3;
         }) {};
      "general-games" = callPackage
        ({ mkDerivation, base, monad-loops, MonadRandom, random
         , random-shuffle, stdenv
         }:
         mkDerivation {
           pname = "general-games";
           version = "1.1.1";
           sha256 = "8b8e9e3546738b55a74589cf76ebe46c3a2f2fd346a853f9dbbf8bd0563350c0";
           libraryHaskellDepends = [
             base monad-loops MonadRandom random random-shuffle
           ];
           doHaddock = false;
           doCheck = false;
           homepage = "https://github.com/cgorski/general-games";
           description = "Library supporting simulation of a number of games";
           license = stdenv.lib.licenses.mit;
         }) {};
      "generic-aeson" = callPackage
        ({ mkDerivation, aeson, attoparsec, base, generic-deriving, mtl
         , stdenv, tagged, text, unordered-containers, vector
         }:
         mkDerivation {
           pname = "generic-aeson";
           version = "0.2.0.9";
           sha256 = "34c13f91ffa72a1f6d7f43b84fdd19b20db547045eb6164a4119f9a95dcd84cb";
           revision = "4";
           editedCabalFile = "0m2m2wfv9nhq8m7xl1nrmj4wy3yip3s31b4448za58ryrwkdgjzd";
           libraryHaskellDepends = [
             aeson attoparsec base generic-deriving mtl tagged text
             unordered-containers vector
           ];
           doHaddock = false;
           doCheck = false;
           description = "Derivation of Aeson instances using GHC generics";
           license = stdenv.lib.licenses.bsd3;
         }) {};
      "generic-arbitrary" = callPackage
        ({ mkDerivation, base, QuickCheck, stdenv }:
         mkDerivation {
           pname = "generic-arbitrary";
           version = "0.1.0";
           sha256 = "69f30a54e7a3d0a45288778e22e6d0d03cfc3b525dfe0a663cd4f559a619bcc6";
           libraryHaskellDepends = [ base QuickCheck ];
           doHaddock = false;
           doCheck = false;
           description = "Generic implementation for QuickCheck's Arbitrary";
           license = stdenv.lib.licenses.mit;
         }) {};
      "generic-deriving" = callPackage
        ({ mkDerivation, base, containers, ghc-prim, stdenv
         , template-haskell, th-abstraction
         }:
         mkDerivation {
           pname = "generic-deriving";
           version = "1.12.2";
           sha256 = "5688b85ff1e3484e3f6073a52f99624a41c8b01ddaab9fcec20afa242f33edc4";
           revision = "1";
           editedCabalFile = "0gr20ypr6s0183wmrhmia0zvpbn4dmfyr3wksrkrqj4i8nhj42fz";
           libraryHaskellDepends = [
             base containers ghc-prim template-haskell th-abstraction
           ];
           doHaddock = false;
           doCheck = false;
           homepage = "https://github.com/dreixel/generic-deriving";
           description = "Generic programming library for generalised deriving";
           license = stdenv.lib.licenses.bsd3;
         }) {};
      "generic-lens" = callPackage
        ({ mkDerivation, base, profunctors, stdenv, tagged }:
         mkDerivation {
           pname = "generic-lens";
           version = "1.0.0.2";
           sha256 = "5e6f8a188e84b0130c55d469d6bb379ac323fb59008fd84eaf73360bb8934168";
           libraryHaskellDepends = [ base profunctors tagged ];
           doHaddock = false;
           doCheck = false;
           homepage = "https://github.com/kcsongor/generic-lens";
           description = "Generically derive traversals, lenses and prisms";
           license = stdenv.lib.licenses.bsd3;
         }) {};
      "generic-random" = callPackage
        ({ mkDerivation, base, QuickCheck, stdenv }:
         mkDerivation {
           pname = "generic-random";
           version = "1.2.0.0";
           sha256 = "9b1e00d2f06b582695a34cfdb2d8b62b32f64152c6ed43f5c2d776e6e9aa148c";
           revision = "1";
           editedCabalFile = "1d0hx41r7yq2a86ydnfh2fv540ah8cz05l071s2z4wxcjw0ymyn4";
           libraryHaskellDepends = [ base QuickCheck ];
           doHaddock = false;
           doCheck = false;
           homepage = "http://github.com/lysxia/generic-random";
           description = "Generic random generators";
           license = stdenv.lib.licenses.mit;
         }) {};
      "generic-xmlpickler" = callPackage
        ({ mkDerivation, base, generic-deriving, hxt, stdenv, text }:
         mkDerivation {
           pname = "generic-xmlpickler";
           version = "0.1.0.5";
           sha256 = "d51760f5650051eebe561f2b18670657e8398014fa2a623c0e0169bfeca336af";
           revision = "8";
           editedCabalFile = "1hpcglml4b5yv192syxazminr5v7qjrgqwb2wk0cf7f0sjpm5d0q";
           libraryHaskellDepends = [ base generic-deriving hxt text ];
           doHaddock = false;
           doCheck = false;
           homepage = "http://github.com/silkapp/generic-xmlpickler";
           description = "Generic generation of HXT XmlPickler instances using GHC Generics";
           license = stdenv.lib.licenses.bsd3;
         }) {};
      "generics-eot" = callPackage
        ({ mkDerivation, base, stdenv }:
         mkDerivation {
           pname = "generics-eot";
           version = "0.4";
           sha256 = "5abedc86df738c8ff7a8c6ca9ee97605406a1b6fadd4924fa93f7aacd2fece9b";
           libraryHaskellDepends = [ base ];
           doHaddock = false;
           doCheck = false;
           homepage = "https://generics-eot.readthedocs.io/";
           description = "A library for generic programming that aims to be easy to understand";
           license = stdenv.lib.licenses.bsd3;
         }) {};
      "generics-sop" = callPackage
        ({ mkDerivation, base, deepseq, ghc-prim, stdenv, template-haskell
         }:
         mkDerivation {
           pname = "generics-sop";
           version = "0.3.2.0";
           sha256 = "3060ecd09ccbd27ecf825bb89af0af9cfcadd16f747ce5964c501682a2301b99";
           revision = "3";
           editedCabalFile = "0lw5n8npdrdd1h7j000flaig4z30b8pig4q52sj34zhwccjkdzq2";
           libraryHaskellDepends = [ base deepseq ghc-prim template-haskell ];
           doHaddock = false;
           doCheck = false;
           description = "Generic Programming using True Sums of Products";
           license = stdenv.lib.licenses.bsd3;
         }) {};
      "generics-sop-lens" = callPackage
        ({ mkDerivation, base, generics-sop, lens, stdenv }:
         mkDerivation {
           pname = "generics-sop-lens";
           version = "0.1.2.1";
           sha256 = "4e49d4cc580d45e25e0abdeee12b1191ae75937af1c7ca03333979584a8a525c";
           revision = "6";
           editedCabalFile = "0j4j3kk2nsl5n5gp0vrzqdc5y9ly31b4nvhq0bpgcpzibvik7ssw";
           libraryHaskellDepends = [ base generics-sop lens ];
           doHaddock = false;
           doCheck = false;
           homepage = "https://github.com/phadej/generics-sop-lens#readme";
           description = "Lenses for types in generics-sop";
           license = stdenv.lib.licenses.bsd3;
         }) {};
      "geniplate-mirror" = callPackage
        ({ mkDerivation, base, mtl, stdenv, template-haskell }:
         mkDerivation {
           pname = "geniplate-mirror";
           version = "0.7.6";
           sha256 = "4b6b82d0348e79ae4a5e1deac029441251ae87ec15a7667cf0a1de5ff80215f8";
           revision = "1";
           editedCabalFile = "1pyz2vdkr5w9wadmb5v4alx408dqamny3mkvl4x8v2pf549qn37k";
           libraryHaskellDepends = [ base mtl template-haskell ];
           doHaddock = false;
           doCheck = false;
           homepage = "https://github.com/danr/geniplate";
           description = "Use Template Haskell to generate Uniplate-like functions";
           license = stdenv.lib.licenses.bsd3;
         }) {};
      "genvalidity" = callPackage
        ({ mkDerivation, base, QuickCheck, stdenv, validity }:
         mkDerivation {
           pname = "genvalidity";
           version = "0.5.1.0";
           sha256 = "402ad5193fefdec24c7a0c62386f764a356bfc93e5e36672fc54a824d1c0d39f";
           libraryHaskellDepends = [ base QuickCheck validity ];
           doHaddock = false;
           doCheck = false;
           homepage = "https://github.com/NorfairKing/validity#readme";
           description = "Testing utilities for the validity library";
           license = stdenv.lib.licenses.mit;
         }) {};
      "genvalidity-aeson" = callPackage
        ({ mkDerivation, aeson, base, genvalidity, genvalidity-scientific
         , genvalidity-text, genvalidity-unordered-containers
         , genvalidity-vector, QuickCheck, stdenv, validity, validity-aeson
         }:
         mkDerivation {
           pname = "genvalidity-aeson";
           version = "0.2.0.2";
           sha256 = "d1244fea0a0a7cad4f783a72b9ff98c606131445a3f2fe9bced5194ff8a2e7b0";
           libraryHaskellDepends = [
             aeson base genvalidity genvalidity-scientific genvalidity-text
             genvalidity-unordered-containers genvalidity-vector QuickCheck
             validity validity-aeson
           ];
           doHaddock = false;
           doCheck = false;
           homepage = "https://github.com/NorfairKing/validity#readme";
           description = "GenValidity support for aeson";
           license = stdenv.lib.licenses.mit;
         }) {};
      "genvalidity-bytestring" = callPackage
        ({ mkDerivation, base, bytestring, genvalidity, QuickCheck, stdenv
         , validity, validity-bytestring
         }:
         mkDerivation {
           pname = "genvalidity-bytestring";
           version = "0.2.0.2";
           sha256 = "43b9051401d59714766d96d48435ee01016454e524af54be51427dcf804cc1e3";
           libraryHaskellDepends = [
             base bytestring genvalidity QuickCheck validity validity-bytestring
           ];
           doHaddock = false;
           doCheck = false;
           homepage = "https://github.com/NorfairKing/validity#readme";
           description = "GenValidity support for ByteString";
           license = stdenv.lib.licenses.mit;
         }) {};
      "genvalidity-containers" = callPackage
        ({ mkDerivation, base, containers, genvalidity, QuickCheck, stdenv
         , validity, validity-containers
         }:
         mkDerivation {
           pname = "genvalidity-containers";
           version = "0.5.1.0";
           sha256 = "03b5a99546232a9a9747e18b401902ca50e96f4860d2a138eb4214c72e300325";
           libraryHaskellDepends = [
             base containers genvalidity QuickCheck validity validity-containers
           ];
           doHaddock = false;
           doCheck = false;
           homepage = "https://github.com/NorfairKing/validity#readme";
           description = "GenValidity support for containers";
           license = stdenv.lib.licenses.mit;
         }) {};
      "genvalidity-hspec" = callPackage
        ({ mkDerivation, base, genvalidity, genvalidity-property, hspec
         , hspec-core, QuickCheck, stdenv, transformers, validity
         }:
         mkDerivation {
           pname = "genvalidity-hspec";
           version = "0.6.2.0";
           sha256 = "3b94c1ee78b61b6bf1d2aa0b8826eb567712a2d6f5f43ddbca9639bd7774af15";
           libraryHaskellDepends = [
             base genvalidity genvalidity-property hspec hspec-core QuickCheck
             transformers validity
           ];
           doHaddock = false;
           doCheck = false;
           homepage = "https://github.com/NorfairKing/validity#readme";
           description = "Standard spec's for GenValidity instances";
           license = stdenv.lib.licenses.mit;
         }) {};
      "genvalidity-hspec-aeson" = callPackage
        ({ mkDerivation, aeson, base, bytestring, deepseq, genvalidity
         , genvalidity-hspec, hspec, QuickCheck, stdenv
         }:
         mkDerivation {
           pname = "genvalidity-hspec-aeson";
           version = "0.3.0.0";
           sha256 = "b0e772bf802a4a70c7e52947d8fe301622cc7ffccf465f780042c8671075122f";
           libraryHaskellDepends = [
             aeson base bytestring deepseq genvalidity genvalidity-hspec hspec
             QuickCheck
           ];
           doHaddock = false;
           doCheck = false;
           homepage = "http://cs-syd.eu";
           description = "Standard spec's for aeson-related instances";
           license = stdenv.lib.licenses.mit;
         }) {};
      "genvalidity-hspec-binary" = callPackage
        ({ mkDerivation, base, binary, deepseq, genvalidity
         , genvalidity-hspec, hspec, QuickCheck, stdenv
         }:
         mkDerivation {
           pname = "genvalidity-hspec-binary";
           version = "0.2.0.2";
           sha256 = "210868b5ce59fc20c406c452970003f332298bcdf900ed736975e0592a5824c0";
           libraryHaskellDepends = [
             base binary deepseq genvalidity genvalidity-hspec hspec QuickCheck
           ];
           doHaddock = false;
           doCheck = false;
           homepage = "https://github.com/NorfairKing/validity#readme";
           description = "Standard spec's for binary-related Instances";
           license = stdenv.lib.licenses.mit;
         }) {};
      "genvalidity-hspec-cereal" = callPackage
        ({ mkDerivation, base, cereal, deepseq, genvalidity
         , genvalidity-hspec, hspec, QuickCheck, stdenv
         }:
         mkDerivation {
           pname = "genvalidity-hspec-cereal";
           version = "0.2.0.2";
           sha256 = "e150f686eb9c161b4386d1515bd0dd12724b8d5593dbe2ebda2eca9c667a249b";
           libraryHaskellDepends = [
             base cereal deepseq genvalidity genvalidity-hspec hspec QuickCheck
           ];
           doHaddock = false;
           doCheck = false;
           homepage = "http://cs-syd.eu";
           description = "Standard spec's for cereal-related instances";
           license = stdenv.lib.licenses.mit;
         }) {};
      "genvalidity-hspec-hashable" = callPackage
        ({ mkDerivation, base, genvalidity, genvalidity-hspec
         , genvalidity-property, hashable, hspec, QuickCheck, stdenv
         , validity
         }:
         mkDerivation {
           pname = "genvalidity-hspec-hashable";
           version = "0.2.0.2";
           sha256 = "3c1e48c842ced9e86c3978c61062f6afcfada9d08786e0a7368c745fc92c9f68";
           libraryHaskellDepends = [
             base genvalidity genvalidity-hspec genvalidity-property hashable
             hspec QuickCheck validity
           ];
           doHaddock = false;
           doCheck = false;
           homepage = "https://github.com/NorfairKing/validity#readme";
           description = "Standard spec's for Hashable instances";
           license = stdenv.lib.licenses.mit;
         }) {};
      "genvalidity-path" = callPackage
        ({ mkDerivation, base, genvalidity, path, QuickCheck, stdenv
         , validity-path
         }:
         mkDerivation {
           pname = "genvalidity-path";
           version = "0.3.0.2";
           sha256 = "00fc6d2f4d54cda700ad4af04efea62db002cab4fbb3ca8da4d20b1a03a340ba";
           libraryHaskellDepends = [
             base genvalidity path QuickCheck validity-path
           ];
           doHaddock = false;
           doCheck = false;
           homepage = "https://github.com/NorfairKing/validity#readme";
           description = "GenValidity support for Path";
           license = stdenv.lib.licenses.mit;
         }) {};
      "genvalidity-property" = callPackage
        ({ mkDerivation, base, genvalidity, hspec, QuickCheck, stdenv
         , validity
         }:
         mkDerivation {
           pname = "genvalidity-property";
           version = "0.2.1.1";
           sha256 = "2ba882f02c8f696d7253ba7472d04bb37548fd19dd5cbb926a2d367f452c5c32";
           libraryHaskellDepends = [
             base genvalidity hspec QuickCheck validity
           ];
           doHaddock = false;
           doCheck = false;
           homepage = "https://github.com/NorfairKing/validity#readme";
           description = "Standard properties for functions on `Validity` types";
           license = stdenv.lib.licenses.mit;
         }) {};
      "genvalidity-scientific" = callPackage
        ({ mkDerivation, base, genvalidity, QuickCheck, scientific, stdenv
         , validity, validity-scientific
         }:
         mkDerivation {
           pname = "genvalidity-scientific";
           version = "0.2.1.0";
           sha256 = "af11d48c53455eb250e68c6cb4f6e8159ddc16fb635879fc2973d57d8bd5903d";
           libraryHaskellDepends = [
             base genvalidity QuickCheck scientific validity validity-scientific
           ];
           doHaddock = false;
           doCheck = false;
           homepage = "https://github.com/NorfairKing/validity#readme";
           description = "GenValidity support for Scientific";
           license = stdenv.lib.licenses.mit;
         }) {};
      "genvalidity-text" = callPackage
        ({ mkDerivation, array, base, genvalidity, QuickCheck, stdenv, text
         , validity, validity-text
         }:
         mkDerivation {
           pname = "genvalidity-text";
           version = "0.5.1.0";
           sha256 = "ef3d7ebe85cf5ce10675f350dd80dfdb3c3f700e109170d0c4929afdbfe8ee48";
           libraryHaskellDepends = [
             array base genvalidity QuickCheck text validity validity-text
           ];
           doHaddock = false;
           doCheck = false;
           homepage = "https://github.com/NorfairKing/validity#readme";
           description = "GenValidity support for Text";
           license = stdenv.lib.licenses.mit;
         }) {};
      "genvalidity-time" = callPackage
        ({ mkDerivation, base, genvalidity, QuickCheck, stdenv, time
         , validity-time
         }:
         mkDerivation {
           pname = "genvalidity-time";
           version = "0.2.1.1";
           sha256 = "c555c206edddbd70355b295ccf9ff053463c137735c4aebcc340091f6d6b7874";
           libraryHaskellDepends = [
             base genvalidity QuickCheck time validity-time
           ];
           doHaddock = false;
           doCheck = false;
           homepage = "https://github.com/NorfairKing/validity#readme";
           description = "GenValidity support for time";
           license = stdenv.lib.licenses.mit;
         }) {};
      "genvalidity-unordered-containers" = callPackage
        ({ mkDerivation, base, genvalidity, hashable, QuickCheck, stdenv
         , unordered-containers, validity, validity-unordered-containers
         }:
         mkDerivation {
           pname = "genvalidity-unordered-containers";
           version = "0.2.0.3";
           sha256 = "ada97e40d4a68fcfa7fe90b431ba9684bdc34fa7c7c566dc06f528b375bc0965";
           libraryHaskellDepends = [
             base genvalidity hashable QuickCheck unordered-containers validity
             validity-unordered-containers
           ];
           doHaddock = false;
           doCheck = false;
           homepage = "https://github.com/NorfairKing/validity#readme";
           description = "GenValidity support for unordered-containers";
           license = stdenv.lib.licenses.mit;
         }) {};
      "genvalidity-uuid" = callPackage
        ({ mkDerivation, base, genvalidity, QuickCheck, stdenv, uuid
         , validity, validity-uuid
         }:
         mkDerivation {
           pname = "genvalidity-uuid";
           version = "0.1.0.2";
           sha256 = "d1354bdfc0a75a1f228cfed22cd0edb0cc13a925e4b2514a634d56eb5b53f412";
           libraryHaskellDepends = [
             base genvalidity QuickCheck uuid validity validity-uuid
           ];
           doHaddock = false;
           doCheck = false;
           homepage = "https://github.com/NorfairKing/validity#readme";
           description = "GenValidity support for UUID";
           license = stdenv.lib.licenses.mit;
         }) {};
      "genvalidity-vector" = callPackage
        ({ mkDerivation, base, genvalidity, QuickCheck, stdenv, validity
         , validity-vector, vector
         }:
         mkDerivation {
           pname = "genvalidity-vector";
           version = "0.2.0.3";
           sha256 = "b3c42019fea54c0da0b0947b01cad510679b3b6c2dc55a43326806f9a02e3c98";
           libraryHaskellDepends = [
             base genvalidity QuickCheck validity validity-vector vector
           ];
           doHaddock = false;
           doCheck = false;
           homepage = "https://github.com/NorfairKing/validity#readme";
           description = "GenValidity support for vector";
           license = stdenv.lib.licenses.mit;
         }) {};
      "geodetics" = callPackage
        ({ mkDerivation, array, base, dimensional, stdenv }:
         mkDerivation {
           pname = "geodetics";
           version = "0.0.6";
           sha256 = "e21dbbd01fac330a542fba24d6dedc6c3b46a4bf43e7fa6181417e6daab9e542";
           revision = "1";
           editedCabalFile = "0ns8368ylapmgk7h9l1ppvrnrqd9jgrm304icf6v47wdan1r82xr";
           enableSeparateDataOutput = true;
           libraryHaskellDepends = [ array base dimensional ];
           doHaddock = false;
           doCheck = false;
           homepage = "https://github.com/PaulJohnson/geodetics";
           description = "Terrestrial coordinate systems and geodetic calculations";
           license = stdenv.lib.licenses.bsd3;
         }) {};
      "getopt-generics" = callPackage
        ({ mkDerivation, base, base-compat, base-orphans, generics-sop
         , stdenv, tagged
         }:
         mkDerivation {
           pname = "getopt-generics";
           version = "0.13.0.3";
           sha256 = "ab05824897afa59304fd653685b5d9580cc91b1d6783d30234a03dbf9dee0288";
           libraryHaskellDepends = [
             base base-compat base-orphans generics-sop tagged
           ];
           doHaddock = false;
           doCheck = false;
           homepage = "https://github.com/soenkehahn/getopt-generics#readme";
           description = "Create command line interfaces with ease";
           license = stdenv.lib.licenses.bsd3;
         }) {};
      "ghc-core" = callPackage
        ({ mkDerivation, base, colorize-haskell, directory, filepath
         , pcre-light, process, stdenv
         }:
         mkDerivation {
           pname = "ghc-core";
           version = "0.5.6";
           sha256 = "ec34f3e5892be7c2b52945875cd330397eca3904ae1d9574559855817b8b7e85";
           isLibrary = false;
           isExecutable = true;
           executableHaskellDepends = [
             base colorize-haskell directory filepath pcre-light process
           ];
           doHaddock = false;
           doCheck = false;
           homepage = "https://github.com/shachaf/ghc-core";
           description = "Display GHC's core and assembly output in a pager";
           license = stdenv.lib.licenses.bsd3;
         }) {};
      "ghc-exactprint" = callPackage
        ({ mkDerivation, base, bytestring, containers, directory, filepath
         , free, ghc, ghc-boot, ghc-paths, mtl, stdenv, syb
         }:
         mkDerivation {
           pname = "ghc-exactprint";
           version = "0.5.6.1";
           sha256 = "07fd206d597631d7d8a78fb34423eb436f434a2477c69317c9a002ed23363390";
           isLibrary = true;
           isExecutable = true;
           libraryHaskellDepends = [
             base bytestring containers directory filepath free ghc ghc-boot
             ghc-paths mtl syb
           ];
           doHaddock = false;
           doCheck = false;
           description = "ExactPrint for GHC";
           license = stdenv.lib.licenses.bsd3;
         }) {};
      "ghc-parser" = callPackage
        ({ mkDerivation, base, cpphs, ghc, happy, stdenv }:
         mkDerivation {
           pname = "ghc-parser";
           version = "0.2.0.2";
           sha256 = "bb74cc64ff8fd3d10447075d5982c7c684210762faa15226415d0ed7da756084";
           libraryHaskellDepends = [ base ghc ];
           libraryToolDepends = [ cpphs happy ];
           doHaddock = false;
           doCheck = false;
           homepage = "https://github.com/gibiansky/IHaskell";
           description = "Haskell source parser from GHC";
           license = stdenv.lib.licenses.mit;
         }) {};
      "ghc-paths" = callPackage
        ({ mkDerivation, base, Cabal, directory, stdenv }:
         mkDerivation {
           pname = "ghc-paths";
           version = "0.1.0.9";
           sha256 = "afa68fb86123004c37c1dc354286af2d87a9dcfb12ddcb80e8bd0cd55bc87945";
           revision = "4";
           editedCabalFile = "1fp0jyvi6prqsv0dxn010c7q4mmiwlcy1xk6ppd4d539adxxy67d";
           setupHaskellDepends = [ base Cabal directory ];
           libraryHaskellDepends = [ base ];
           doHaddock = false;
           doCheck = false;
           description = "Knowledge of GHC's installation directories";
           license = stdenv.lib.licenses.bsd3;
         }) {};
      "ghc-prof" = callPackage
        ({ mkDerivation, attoparsec, base, containers, scientific, stdenv
         , text, time
         }:
         mkDerivation {
           pname = "ghc-prof";
           version = "1.4.1.5";
           sha256 = "e42d1acd9947c1396adcf1ae3a0627144884af5cf13176fb09cce0e9bcfbfe32";
           isLibrary = true;
           isExecutable = true;
           libraryHaskellDepends = [
             attoparsec base containers scientific text time
           ];
           doHaddock = false;
           doCheck = false;
           homepage = "https://github.com/maoe/ghc-prof";
           description = "Library for parsing GHC time and allocation profiling reports";
           license = stdenv.lib.licenses.bsd3;
         }) {};
      "ghc-syntax-highlighter" = callPackage
        ({ mkDerivation, base, ghc, stdenv, text }:
         mkDerivation {
           pname = "ghc-syntax-highlighter";
           version = "0.0.3.0";
           sha256 = "a137f484740f4eee967fbc8d8366e053e52e073b948ffb3001b4e1227adeec1c";
           enableSeparateDataOutput = true;
           libraryHaskellDepends = [ base ghc text ];
           doHaddock = false;
           doCheck = false;
           homepage = "https://github.com/mrkkrp/ghc-syntax-highlighter";
           description = "Syntax highlighter for Haskell using lexer of GHC itself";
           license = stdenv.lib.licenses.bsd3;
         }) {};
      "ghc-tcplugins-extra" = callPackage
        ({ mkDerivation, base, ghc, stdenv }:
         mkDerivation {
           pname = "ghc-tcplugins-extra";
           version = "0.3";
           sha256 = "30acfd21d590809c16d990512fc8fcb98361ec540a76438233bd8aa23e82374c";
           revision = "1";
           editedCabalFile = "0x2d4bp5lhyfrqjshmgbirdn2ihc057a8a6khqmz91jj9zlhf7vb";
           libraryHaskellDepends = [ base ghc ];
           doHaddock = false;
           doCheck = false;
           homepage = "http://github.com/clash-lang/ghc-tcplugins-extra";
           description = "Utilities for writing GHC type-checker plugins";
           license = stdenv.lib.licenses.bsd2;
         }) {};
      "ghc-typelits-extra" = callPackage
        ({ mkDerivation, base, ghc, ghc-prim, ghc-tcplugins-extra
         , ghc-typelits-knownnat, ghc-typelits-natnormalise, integer-gmp
         , stdenv, transformers
         }:
         mkDerivation {
           pname = "ghc-typelits-extra";
           version = "0.2.6";
           sha256 = "958d3c44543c75fabfe2f0a0db9d9cd3182bb748af9223e9c498ce4bcdcca637";
           libraryHaskellDepends = [
             base ghc ghc-prim ghc-tcplugins-extra ghc-typelits-knownnat
             ghc-typelits-natnormalise integer-gmp transformers
           ];
           doHaddock = false;
           doCheck = false;
           homepage = "http://www.clash-lang.org/";
           description = "Additional type-level operations on GHC.TypeLits.Nat";
           license = stdenv.lib.licenses.bsd2;
         }) {};
      "ghc-typelits-knownnat" = callPackage
        ({ mkDerivation, base, ghc, ghc-tcplugins-extra
         , ghc-typelits-natnormalise, stdenv, template-haskell, transformers
         }:
         mkDerivation {
           pname = "ghc-typelits-knownnat";
           version = "0.5.1";
           sha256 = "5b94c42dac0ae7fe381019d77afa9fe9b290b0ab7a2d9d6e20357381fc586d7b";
           libraryHaskellDepends = [
             base ghc ghc-tcplugins-extra ghc-typelits-natnormalise
             template-haskell transformers
           ];
           doHaddock = false;
           doCheck = false;
           homepage = "http://clash-lang.org/";
           description = "Derive KnownNat constraints from other KnownNat constraints";
           license = stdenv.lib.licenses.bsd2;
         }) {};
      "ghc-typelits-natnormalise" = callPackage
        ({ mkDerivation, base, ghc, ghc-tcplugins-extra, integer-gmp
         , stdenv, transformers
         }:
         mkDerivation {
           pname = "ghc-typelits-natnormalise";
           version = "0.6.2";
           sha256 = "801ceb41442dfa992fad04c64f2989d1d701bcfe0874a55aa8d250e63c1a4311";
           libraryHaskellDepends = [
             base ghc ghc-tcplugins-extra integer-gmp transformers
           ];
           doHaddock = false;
           doCheck = false;
           homepage = "http://www.clash-lang.org/";
           description = "GHC typechecker plugin for types of kind GHC.TypeLits.Nat";
           license = stdenv.lib.licenses.bsd2;
         }) {};
      "ghcid" = callPackage
        ({ mkDerivation, ansi-terminal, base, cmdargs, containers
         , directory, extra, filepath, fsnotify, process, stdenv
         , terminal-size, time, unix
         }:
         mkDerivation {
           pname = "ghcid";
           version = "0.7.1";
           sha256 = "a73719b5d03c24726b60d1cd4cd7379d7e50690c9b738b760149c450763bc31a";
           isLibrary = true;
           isExecutable = true;
           libraryHaskellDepends = [
             ansi-terminal base cmdargs directory extra filepath process time
           ];
           executableHaskellDepends = [
             ansi-terminal base cmdargs containers directory extra filepath
             fsnotify process terminal-size time unix
           ];
           doHaddock = false;
           doCheck = false;
           homepage = "https://github.com/ndmitchell/ghcid#readme";
           description = "GHCi based bare bones IDE";
           license = stdenv.lib.licenses.bsd3;
         }) {};
      "ghcjs-base-stub" = callPackage
        ({ mkDerivation, aeson, attoparsec, base, containers, deepseq
         , ghc-prim, primitive, scientific, stdenv, text, transformers
         , unordered-containers, vector
         }:
         mkDerivation {
           pname = "ghcjs-base-stub";
           version = "0.2.0.0";
           sha256 = "67bb7c931d1dc6cf2023fd8b7db126e3cd52772e5039bc3fd24585278d4a6516";
           revision = "1";
           editedCabalFile = "0hvmgwyhv28d39was8bm52anwqh6x4mbd1mzzqxazlm0d0l8bpwp";
           libraryHaskellDepends = [
             aeson attoparsec base containers deepseq ghc-prim primitive
             scientific text transformers unordered-containers vector
           ];
           doHaddock = false;
           doCheck = false;
           homepage = "https://github.com/louispan/javascript-stub#readme";
           description = "Allow GHCJS projects to compile under GHC and develop using intero";
           license = stdenv.lib.licenses.bsd3;
         }) {};
      "ghcjs-codemirror" = callPackage
        ({ mkDerivation, base, stdenv }:
         mkDerivation {
           pname = "ghcjs-codemirror";
           version = "0.0.0.2";
           sha256 = "6cbb2c649f6d4a874eb7486a2dd33db2ed0f138f1f8289a6447460d39b4b2097";
           enableSeparateDataOutput = true;
           libraryHaskellDepends = [ base ];
           doHaddock = false;
           doCheck = false;
           homepage = "https://github.com/ghcjs/CodeMirror";
           description = "Installs CodeMirror JavaScript files";
           license = stdenv.lib.licenses.mit;
         }) {};
      "ghost-buster" = callPackage
        ({ mkDerivation, base, stdenv }:
         mkDerivation {
           pname = "ghost-buster";
           version = "0.1.1.0";
           sha256 = "02d0930ee77838e7f5a04ebc0a74f62b15218b8ace4a5b88510d9a6b56dbf6d6";
           libraryHaskellDepends = [ base ];
           doHaddock = false;
           doCheck = false;
           homepage = "https://github.com/Lazersmoke/ghost-buster#readme";
           description = "Existential type utilites";
           license = stdenv.lib.licenses.bsd3;
         }) {};
      "gi-atk" = callPackage
        ({ mkDerivation, atk, base, bytestring, Cabal, containers, gi-glib
         , gi-gobject, haskell-gi, haskell-gi-base, haskell-gi-overloading
         , stdenv, text, transformers
         }:
         mkDerivation {
           pname = "gi-atk";
           version = "2.0.15";
           sha256 = "89753b4517e77ea956dcfd1294b4b98032c6e50df912e28c9a796d2b825fbfee";
           setupHaskellDepends = [ base Cabal haskell-gi ];
           libraryHaskellDepends = [
             base bytestring containers gi-glib gi-gobject haskell-gi
             haskell-gi-base haskell-gi-overloading text transformers
           ];
           libraryPkgconfigDepends = [ atk ];
           doHaddock = false;
           doCheck = false;
           homepage = "https://github.com/haskell-gi/haskell-gi";
           description = "Atk bindings";
           license = stdenv.lib.licenses.lgpl21;
         }) {inherit (pkgs) atk;};
      "gi-cairo" = callPackage
        ({ mkDerivation, base, bytestring, Cabal, cairo, containers
         , haskell-gi, haskell-gi-base, haskell-gi-overloading, stdenv, text
         , transformers
         }:
         mkDerivation {
           pname = "gi-cairo";
           version = "1.0.17";
           sha256 = "5dbda70a038a93cb07130597407de9cde1436603beca3f2a0a6b43953c55a7ab";
           setupHaskellDepends = [ base Cabal haskell-gi ];
           libraryHaskellDepends = [
             base bytestring containers haskell-gi haskell-gi-base
             haskell-gi-overloading text transformers
           ];
           libraryPkgconfigDepends = [ cairo ];
           doHaddock = false;
           doCheck = false;
           preCompileBuildDriver = ''
             PKG_CONFIG_PATH+=":${cairo}/lib/pkgconfig"
             setupCompileFlags+=" $(pkg-config --libs cairo-gobject)"
           '';
           homepage = "https://github.com/haskell-gi/haskell-gi";
           description = "Cairo bindings";
           license = stdenv.lib.licenses.lgpl21;
         }) {inherit (pkgs) cairo;};
      "gi-gdk" = callPackage
        ({ mkDerivation, base, bytestring, Cabal, containers, gi-cairo
         , gi-gdkpixbuf, gi-gio, gi-glib, gi-gobject, gi-pango, gtk3
         , haskell-gi, haskell-gi-base, haskell-gi-overloading, stdenv, text
         , transformers
         }:
         mkDerivation {
           pname = "gi-gdk";
           version = "3.0.16";
           sha256 = "7eb0aa493d268cd040c7ff70ad09d7bf7787e0e7619617ba220b88eafe68e34a";
           setupHaskellDepends = [ base Cabal haskell-gi ];
           libraryHaskellDepends = [
             base bytestring containers gi-cairo gi-gdkpixbuf gi-gio gi-glib
             gi-gobject gi-pango haskell-gi haskell-gi-base
             haskell-gi-overloading text transformers
           ];
           libraryPkgconfigDepends = [ gtk3 ];
           doHaddock = false;
           doCheck = false;
           homepage = "https://github.com/haskell-gi/haskell-gi";
           description = "Gdk bindings";
           license = stdenv.lib.licenses.lgpl21;
         }) {inherit (pkgs) gtk3;};
      "gi-gdkpixbuf" = callPackage
        ({ mkDerivation, base, bytestring, Cabal, containers, gdk_pixbuf
         , gi-gio, gi-glib, gi-gobject, haskell-gi, haskell-gi-base
         , haskell-gi-overloading, stdenv, text, transformers
         }:
         mkDerivation {
           pname = "gi-gdkpixbuf";
           version = "2.0.16";
           sha256 = "fdbb5f12ecd3a419a345919913e659f90000b38b973ce79fb6e9ba05f5d4166f";
           setupHaskellDepends = [ base Cabal haskell-gi ];
           libraryHaskellDepends = [
             base bytestring containers gi-gio gi-glib gi-gobject haskell-gi
             haskell-gi-base haskell-gi-overloading text transformers
           ];
           libraryPkgconfigDepends = [ gdk_pixbuf ];
           doHaddock = false;
           doCheck = false;
           homepage = "https://github.com/haskell-gi/haskell-gi";
           description = "GdkPixbuf bindings";
           license = stdenv.lib.licenses.lgpl21;
         }) {inherit (pkgs) gdk_pixbuf;};
      "gi-gio" = callPackage
        ({ mkDerivation, base, bytestring, Cabal, containers, gi-glib
         , gi-gobject, glib, haskell-gi, haskell-gi-base
         , haskell-gi-overloading, stdenv, text, transformers
         }:
         mkDerivation {
           pname = "gi-gio";
           version = "2.0.18";
           sha256 = "13ebcd9c5d804de97db1f0ce7de520a73ba2eed950cbf5be84950fe33a8ef440";
           setupHaskellDepends = [ base Cabal haskell-gi ];
           libraryHaskellDepends = [
             base bytestring containers gi-glib gi-gobject haskell-gi
             haskell-gi-base haskell-gi-overloading text transformers
           ];
           libraryPkgconfigDepends = [ glib ];
           doHaddock = false;
           doCheck = false;
           homepage = "https://github.com/haskell-gi/haskell-gi";
           description = "Gio bindings";
           license = stdenv.lib.licenses.lgpl21;
         }) {inherit (pkgs) glib;};
      "gi-glib" = callPackage
        ({ mkDerivation, base, bytestring, Cabal, containers, glib
         , haskell-gi, haskell-gi-base, haskell-gi-overloading, stdenv, text
         , transformers
         }:
         mkDerivation {
           pname = "gi-glib";
           version = "2.0.17";
           sha256 = "9d7abe0a9d66689c5102629edb43a2336d1bb8dc805f0cbe214e5a4e799eab67";
           setupHaskellDepends = [ base Cabal haskell-gi ];
           libraryHaskellDepends = [
             base bytestring containers haskell-gi haskell-gi-base
             haskell-gi-overloading text transformers
           ];
           libraryPkgconfigDepends = [ glib ];
           doHaddock = false;
           doCheck = false;
           homepage = "https://github.com/haskell-gi/haskell-gi";
           description = "GLib bindings";
           license = stdenv.lib.licenses.lgpl21;
         }) {inherit (pkgs) glib;};
      "gi-gobject" = callPackage
        ({ mkDerivation, base, bytestring, Cabal, containers, gi-glib, glib
         , haskell-gi, haskell-gi-base, haskell-gi-overloading, stdenv, text
         , transformers
         }:
         mkDerivation {
           pname = "gi-gobject";
           version = "2.0.16";
           sha256 = "c57844d5b9566834ece584bfbbdff1c3ef2de5aa67c711c406fe92d4b927f6ad";
           setupHaskellDepends = [ base Cabal haskell-gi ];
           libraryHaskellDepends = [
             base bytestring containers gi-glib haskell-gi haskell-gi-base
             haskell-gi-overloading text transformers
           ];
           libraryPkgconfigDepends = [ glib ];
           doHaddock = false;
           doCheck = false;
           homepage = "https://github.com/haskell-gi/haskell-gi";
           description = "GObject bindings";
           license = stdenv.lib.licenses.lgpl21;
         }) {inherit (pkgs) glib;};
      "gi-gtk" = callPackage
        ({ mkDerivation, base, bytestring, Cabal, containers, gi-atk
         , gi-cairo, gi-gdk, gi-gdkpixbuf, gi-gio, gi-glib, gi-gobject
         , gi-pango, gtk3, haskell-gi, haskell-gi-base
         , haskell-gi-overloading, stdenv, text, transformers
         }:
         mkDerivation {
           pname = "gi-gtk";
           version = "3.0.26";
           sha256 = "ceaae0a48c39cd30c3baf9f71136bfed1f85fbe284ee0c3dfe13d42e99741aac";
           setupHaskellDepends = [ base Cabal haskell-gi ];
           libraryHaskellDepends = [
             base bytestring containers gi-atk gi-cairo gi-gdk gi-gdkpixbuf
             gi-gio gi-glib gi-gobject gi-pango haskell-gi haskell-gi-base
             haskell-gi-overloading text transformers
           ];
           libraryPkgconfigDepends = [ gtk3 ];
           doHaddock = false;
           doCheck = false;
           homepage = "https://github.com/haskell-gi/haskell-gi";
           description = "Gtk bindings";
           license = stdenv.lib.licenses.lgpl21;
         }) {inherit (pkgs) gtk3;};
      "gi-gtk-hs" = callPackage
        ({ mkDerivation, base, base-compat, containers, gi-gdk
         , gi-gdkpixbuf, gi-glib, gi-gobject, gi-gtk, haskell-gi-base, mtl
         , stdenv, text, transformers
         }:
         mkDerivation {
           pname = "gi-gtk-hs";
           version = "0.3.6.3";
           sha256 = "5e894629b84bb79bb8b91e2d006965e351d24665c1dd37f354a77ce5acd6d976";
           libraryHaskellDepends = [
             base base-compat containers gi-gdk gi-gdkpixbuf gi-glib gi-gobject
             gi-gtk haskell-gi-base mtl text transformers
           ];
           doHaddock = false;
           doCheck = false;
           homepage = "https://github.com/haskell-gi/gi-gtk-hs";
           description = "A wrapper for gi-gtk, adding a few more idiomatic API parts on top";
           license = stdenv.lib.licenses.lgpl21;
         }) {};
      "gi-gtksource" = callPackage
        ({ mkDerivation, base, bytestring, Cabal, containers, gi-atk
         , gi-cairo, gi-gdk, gi-gdkpixbuf, gi-gio, gi-glib, gi-gobject
         , gi-gtk, gi-pango, gtksourceview3, haskell-gi, haskell-gi-base
         , haskell-gi-overloading, stdenv, text, transformers
         }:
         mkDerivation {
           pname = "gi-gtksource";
           version = "3.0.16";
           sha256 = "97b91b9f48b9e0c65a3936beb6e814ac5a55ab20aefbd9a167313982bd5da53a";
           setupHaskellDepends = [ base Cabal haskell-gi ];
           libraryHaskellDepends = [
             base bytestring containers gi-atk gi-cairo gi-gdk gi-gdkpixbuf
             gi-gio gi-glib gi-gobject gi-gtk gi-pango haskell-gi
             haskell-gi-base haskell-gi-overloading text transformers
           ];
           libraryPkgconfigDepends = [ gtksourceview3 ];
           doHaddock = false;
           doCheck = false;
           homepage = "https://github.com/haskell-gi/haskell-gi";
           description = "GtkSource bindings";
           license = stdenv.lib.licenses.lgpl21;
         }) {inherit (pkgs) gtksourceview3;};
      "gi-javascriptcore" = callPackage
        ({ mkDerivation, base, bytestring, Cabal, containers, gi-glib
         , gi-gobject, haskell-gi, haskell-gi-base, haskell-gi-overloading
         , stdenv, text, transformers, webkitgtk
         }:
         mkDerivation {
           pname = "gi-javascriptcore";
           version = "4.0.16";
           sha256 = "5f30d7da8cca149b0234de871f18e4ff96288c928f678c649a620a7275c2304e";
           setupHaskellDepends = [ base Cabal haskell-gi ];
           libraryHaskellDepends = [
             base bytestring containers gi-glib gi-gobject haskell-gi
             haskell-gi-base haskell-gi-overloading text transformers
           ];
           libraryPkgconfigDepends = [ webkitgtk ];
           doHaddock = false;
           doCheck = false;
           homepage = "https://github.com/haskell-gi/haskell-gi";
           description = "JavaScriptCore bindings";
           license = stdenv.lib.licenses.lgpl21;
         }) {inherit (pkgs) webkitgtk;};
      "gi-pango" = callPackage
        ({ mkDerivation, base, bytestring, Cabal, cairo, containers
         , gi-glib, gi-gobject, haskell-gi, haskell-gi-base
         , haskell-gi-overloading, pango, stdenv, text, transformers
         }:
         mkDerivation {
           pname = "gi-pango";
           version = "1.0.16";
           sha256 = "a7bcc68413d7f7479e9b746eacf08b0c29a93b7c8af17005d96607ce090e78f4";
           setupHaskellDepends = [ base Cabal haskell-gi ];
           libraryHaskellDepends = [
             base bytestring containers gi-glib gi-gobject haskell-gi
             haskell-gi-base haskell-gi-overloading text transformers
           ];
           libraryPkgconfigDepends = [ cairo pango ];
           doHaddock = false;
           doCheck = false;
           preCompileBuildDriver = ''
             PKG_CONFIG_PATH+=":${cairo}/lib/pkgconfig"
             setupCompileFlags+=" $(pkg-config --libs cairo-gobject)"
           '';
           homepage = "https://github.com/haskell-gi/haskell-gi";
           description = "Pango bindings";
           license = stdenv.lib.licenses.lgpl21;
         }) {inherit (pkgs) cairo; inherit (pkgs) pango;};
      "gi-vte" = callPackage
        ({ mkDerivation, base, bytestring, Cabal, containers, gi-atk
         , gi-gdk, gi-gio, gi-glib, gi-gobject, gi-gtk, gi-pango, haskell-gi
         , haskell-gi-base, haskell-gi-overloading, stdenv, text
         , transformers, vte_291
         }:
         mkDerivation {
           pname = "gi-vte";
           version = "2.91.19";
           sha256 = "9eb476c66295f9786df59bcf429d16a94462846dd3486a048a07ca93658bd0c2";
           setupHaskellDepends = [ base Cabal haskell-gi ];
           libraryHaskellDepends = [
             base bytestring containers gi-atk gi-gdk gi-gio gi-glib gi-gobject
             gi-gtk gi-pango haskell-gi haskell-gi-base haskell-gi-overloading
             text transformers
           ];
           libraryPkgconfigDepends = [ vte_291 ];
           doHaddock = false;
           doCheck = false;
           homepage = "https://github.com/haskell-gi/haskell-gi";
           description = "Vte bindings";
           license = stdenv.lib.licenses.lgpl21;
         }) {vte_291 = pkgs.vte;};
      "gio" = callPackage
        ({ mkDerivation, array, base, bytestring, Cabal, containers, glib
         , gtk2hs-buildtools, mtl, stdenv, system-glib
         }:
         mkDerivation {
           pname = "gio";
           version = "0.13.5.0";
           sha256 = "5c761423e947c02181721bdac7c11293d1bd31515fabe969e7e4ac9fd7e7355c";
           enableSeparateDataOutput = true;
           setupHaskellDepends = [ base Cabal gtk2hs-buildtools ];
           libraryHaskellDepends = [
             array base bytestring containers glib mtl
           ];
           libraryPkgconfigDepends = [ system-glib ];
           doHaddock = false;
           doCheck = false;
           homepage = "http://projects.haskell.org/gtk2hs/";
           description = "Binding to GIO";
           license = stdenv.lib.licenses.lgpl21;
         }) {system-glib = pkgs.glib;};
      "giphy-api" = callPackage
        ({ mkDerivation, aeson, base, containers, http-api-data
         , http-client, http-client-tls, microlens, microlens-th, mtl
         , network-uri, servant, servant-client, stdenv, text, transformers
         }:
         mkDerivation {
           pname = "giphy-api";
           version = "0.6.0.1";
           sha256 = "8ddfb5005bc26553850366c527c0a1a93e6b1efaf4334f195a4f5ab647408604";
           isLibrary = true;
           isExecutable = true;
           libraryHaskellDepends = [
             aeson base containers http-api-data http-client http-client-tls
             microlens microlens-th mtl network-uri servant servant-client text
             transformers
           ];
           doHaddock = false;
           doCheck = false;
           homepage = "http://github.com/passy/giphy-api#readme";
           description = "Giphy HTTP API wrapper and CLI search tool";
           license = stdenv.lib.licenses.bsd3;
         }) {};
      "git-vogue" = callPackage
        ({ mkDerivation, base, bifunctors, containers, cpphs, Diff
         , directory, filepath, formatting, haskell-src-exts, hlint
         , hscolour, optparse-applicative, process, split, stdenv, strict
         , stylish-haskell, temporary, text, transformers, unix
         }:
         mkDerivation {
           pname = "git-vogue";
           version = "0.3.0.2";
           sha256 = "b41669f86776dd8fc56bec61f96f14b1fa0fc6720eaf3ed0559db97b4020705c";
           isLibrary = true;
           isExecutable = true;
           enableSeparateDataOutput = true;
           libraryHaskellDepends = [
             base containers directory filepath formatting optparse-applicative
             process split temporary text transformers unix
           ];
           executableHaskellDepends = [
             base bifunctors cpphs Diff directory haskell-src-exts hlint
             hscolour optparse-applicative process strict stylish-haskell text
           ];
           doHaddock = false;
           doCheck = false;
           homepage = "https://github.com/christian-marie/git-vogue";
           description = "A framework for pre-commit checks";
           license = stdenv.lib.licenses.bsd3;
         }) {};
      "githash" = callPackage
        ({ mkDerivation, base, bytestring, directory, filepath, process
         , stdenv, template-haskell
         }:
         mkDerivation {
           pname = "githash";
           version = "0.1.3.0";
           sha256 = "e75aca04c7829bb1a0ba2265d540d14e6ed9a92c5a78774468b38095252dd766";
           libraryHaskellDepends = [
             base bytestring directory filepath process template-haskell
           ];
           doHaddock = false;
           doCheck = false;
           homepage = "https://github.com/snoyberg/githash#readme";
           description = "Compile git revision info into Haskell projects";
           license = stdenv.lib.licenses.bsd3;
         }) {};
      "github" = callPackage
        ({ mkDerivation, aeson, aeson-compat, base, base-compat
         , base16-bytestring, binary, binary-orphans, byteable, bytestring
         , containers, cryptohash, deepseq, deepseq-generics, exceptions
         , hashable, http-client, http-client-tls, http-link-header
         , http-types, iso8601-time, mtl, network-uri, semigroups, stdenv
         , text, time, tls, transformers, transformers-compat
         , unordered-containers, vector, vector-instances
         }:
         mkDerivation {
           pname = "github";
           version = "0.19";
           sha256 = "f0ea9b57cd21645bba40e37e5e7c83ad78469cc3e32526b15e9a4bb2b3b84394";
           revision = "3";
           editedCabalFile = "0s3zmkzgfbh1mc0492i7rjiawxkzg0im8z2p10niv5ff58m87yri";
           libraryHaskellDepends = [
             aeson aeson-compat base base-compat base16-bytestring binary
             binary-orphans byteable bytestring containers cryptohash deepseq
             deepseq-generics exceptions hashable http-client http-client-tls
             http-link-header http-types iso8601-time mtl network-uri semigroups
             text time tls transformers transformers-compat unordered-containers
             vector vector-instances
           ];
           doHaddock = false;
           doCheck = false;
           homepage = "https://github.com/phadej/github";
           description = "Access to the GitHub API, v3";
           license = stdenv.lib.licenses.bsd3;
         }) {};
      "github-release" = callPackage
        ({ mkDerivation, aeson, base, bytestring, http-client
         , http-client-tls, http-types, mime-types, optparse-generic, stdenv
         , text, unordered-containers, uri-templater
         }:
         mkDerivation {
           pname = "github-release";
           version = "1.2.3";
           sha256 = "1e50df80c6cd2e1b4e007648c5e0833489cc57d41daf0262e65fd4e59f404b92";
           isLibrary = true;
           isExecutable = true;
           libraryHaskellDepends = [
             aeson base bytestring http-client http-client-tls http-types
             mime-types optparse-generic text unordered-containers uri-templater
           ];
           executableHaskellDepends = [
             aeson base bytestring http-client http-client-tls http-types
             mime-types optparse-generic text unordered-containers uri-templater
           ];
           doHaddock = false;
           doCheck = false;
           homepage = "https://github.com/tfausak/github-release#readme";
           description = "Upload files to GitHub releases";
           license = stdenv.lib.licenses.mit;
         }) {};
      "github-types" = callPackage
        ({ mkDerivation, aeson, base, stdenv, text, time }:
         mkDerivation {
           pname = "github-types";
           version = "0.2.1";
           sha256 = "cce4ea461b3ea7c92d130181244cfe7f29c10aecc7e7a980ee6722b6d6af7867";
           libraryHaskellDepends = [ aeson base text time ];
           doHaddock = false;
           doCheck = false;
           description = "Type definitions for objects used by the GitHub v3 API";
           license = "unknown";
           hydraPlatforms = stdenv.lib.platforms.none;
         }) {};
      "github-webhooks" = callPackage
        ({ mkDerivation, aeson, base, base16-bytestring, bytestring
         , cryptonite, deepseq, deepseq-generics, memory, stdenv, text, time
         , vector
         }:
         mkDerivation {
           pname = "github-webhooks";
           version = "0.10.0";
           sha256 = "084a8aa9cc71f89a47a0c8cdb1d0f9eac79fb7d4360ed224efd8443f0c7271df";
           libraryHaskellDepends = [
             aeson base base16-bytestring bytestring cryptonite deepseq
             deepseq-generics memory text time vector
           ];
           doHaddock = false;
           doCheck = false;
           homepage = "https://github.com/onrock-eng/github-webhooks#readme";
           description = "Aeson instances for GitHub Webhook payloads";
           license = stdenv.lib.licenses.mit;
         }) {};
      "gitrev" = callPackage
        ({ mkDerivation, base, base-compat, directory, filepath, process
         , stdenv, template-haskell
         }:
         mkDerivation {
           pname = "gitrev";
           version = "1.3.1";
           sha256 = "a89964db24f56727b0e7b10c98fe7c116d721d8c46f52d6e77088669aaa38332";
           libraryHaskellDepends = [
             base base-compat directory filepath process template-haskell
           ];
           doHaddock = false;
           doCheck = false;
           homepage = "https://github.com/acfoltzer/gitrev";
           description = "Compile git revision info into Haskell projects";
           license = stdenv.lib.licenses.bsd3;
         }) {};
      "gl" = callPackage
        ({ mkDerivation, base, Cabal, containers, directory, filepath
         , fixed, half, hxt, libGL, stdenv, transformers
         }:
         mkDerivation {
           pname = "gl";
           version = "0.8.0";
           sha256 = "aa4d2838157c86da920bda651458a4266fccc7c291ea93a69558ab02540e1439";
           revision = "2";
           editedCabalFile = "0zbpf559ajlcwnylpbm6dbi4m3g3s08fciqfp5am3i2vrmw0wpi9";
           setupHaskellDepends = [
             base Cabal containers directory filepath hxt transformers
           ];
           libraryHaskellDepends = [
             base containers fixed half transformers
           ];
           librarySystemDepends = [ libGL ];
           doHaddock = false;
           doCheck = false;
           description = "Complete OpenGL raw bindings";
           license = stdenv.lib.licenses.bsd3;
         }) {inherit (pkgs) libGL;};
      "glabrous" = callPackage
        ({ mkDerivation, aeson, aeson-pretty, attoparsec, base, bytestring
         , cereal, cereal-text, either, stdenv, text, unordered-containers
         }:
         mkDerivation {
           pname = "glabrous";
           version = "0.3.6";
           sha256 = "3113326be49f4e1276ad6e61d47cac07768985d7203cb718c7dd60f76cd541ad";
           libraryHaskellDepends = [
             aeson aeson-pretty attoparsec base bytestring cereal cereal-text
             either text unordered-containers
           ];
           doHaddock = false;
           doCheck = false;
           homepage = "https://github.com/MichelBoucey/glabrous";
           description = "A template DSL library";
           license = stdenv.lib.licenses.bsd3;
         }) {};
      "glaze" = callPackage
        ({ mkDerivation, base, lens, stdenv }:
         mkDerivation {
           pname = "glaze";
           version = "0.3.0.1";
           sha256 = "bbb184408bcf24e8c4f89a960cf7a69ab0c51e98bf84c5fa9901aae1702e22a1";
           libraryHaskellDepends = [ base lens ];
           doHaddock = false;
           doCheck = false;
           homepage = "https://github.com/louispan/glaze#readme";
           description = "Framework for rendering things with metadata/headers and values";
           license = stdenv.lib.licenses.bsd3;
         }) {};
      "glazier" = callPackage
        ({ mkDerivation, alternators, base, data-diverse, data-diverse-lens
         , dlist, lens, mtl, stdenv, transformers, unliftio, unliftio-core
         }:
         mkDerivation {
           pname = "glazier";
           version = "1.0.0.0";
           sha256 = "e9c56250e48b99bfe6280c58d1458c5d35203bf3676705355a4d0bd89c7b71a4";
           libraryHaskellDepends = [
             alternators base data-diverse data-diverse-lens dlist lens mtl
             transformers unliftio unliftio-core
           ];
           doHaddock = false;
           doCheck = false;
           homepage = "https://github.com/louispan/glazier#readme";
           description = "Extensible effects using ContT, State and variants";
           license = stdenv.lib.licenses.bsd3;
         }) {};
      "glib" = callPackage
        ({ mkDerivation, base, bytestring, Cabal, containers, glib
         , gtk2hs-buildtools, stdenv, text, utf8-string
         }:
         mkDerivation {
           pname = "glib";
           version = "0.13.6.0";
           sha256 = "4e71062c6a458440294d820e21449aa4666deed2ea233ef5915da7c1d4aee8eb";
           setupHaskellDepends = [ base Cabal gtk2hs-buildtools ];
           libraryHaskellDepends = [
             base bytestring containers text utf8-string
           ];
           libraryPkgconfigDepends = [ glib ];
           doHaddock = false;
           doCheck = false;
           homepage = "http://projects.haskell.org/gtk2hs/";
           description = "Binding to the GLIB library for Gtk2Hs";
           license = stdenv.lib.licenses.lgpl21;
         }) {inherit (pkgs) glib;};
      "gloss" = callPackage
        ({ mkDerivation, base, bmp, bytestring, containers, ghc-prim
         , gloss-rendering, GLUT, OpenGL, stdenv
         }:
         mkDerivation {
           pname = "gloss";
           version = "1.12.0.0";
           sha256 = "6906d8ad72f094f16c27f19a4836e770cdae08dd90537239b067d5ddebdeac4b";
           libraryHaskellDepends = [
             base bmp bytestring containers ghc-prim gloss-rendering GLUT OpenGL
           ];
           doHaddock = false;
           doCheck = false;
           homepage = "http://gloss.ouroborus.net";
           description = "Painless 2D vector graphics, animations and simulations";
           license = stdenv.lib.licenses.mit;
         }) {};
      "gloss-raster" = callPackage
        ({ mkDerivation, base, containers, ghc-prim, gloss, gloss-rendering
         , repa, stdenv
         }:
         mkDerivation {
           pname = "gloss-raster";
           version = "1.12.0.0";
           sha256 = "c89f496a397f168f020ad69742da21a7c54265e0b5144f3224d7912a15c34191";
           libraryHaskellDepends = [
             base containers ghc-prim gloss gloss-rendering repa
           ];
           doHaddock = false;
           doCheck = false;
           homepage = "http://gloss.ouroborus.net";
           description = "Parallel rendering of raster images";
           license = stdenv.lib.licenses.mit;
         }) {};
      "gloss-rendering" = callPackage
        ({ mkDerivation, base, bmp, bytestring, containers, GLUT, OpenGL
         , stdenv
         }:
         mkDerivation {
           pname = "gloss-rendering";
           version = "1.12.0.0";
           sha256 = "60d90b9729b8f6c8715d621aec8a9ded3f8f95bcb0877391d39a8e303de5c4bc";
           libraryHaskellDepends = [
             base bmp bytestring containers GLUT OpenGL
           ];
           doHaddock = false;
           doCheck = false;
           description = "Gloss picture data types and rendering functions";
           license = stdenv.lib.licenses.mit;
         }) {};
      "gnuplot" = callPackage
        ({ mkDerivation, array, base, containers, data-accessor
         , data-accessor-transformers, deepseq, filepath, process
         , semigroups, stdenv, temporary, time, transformers, utility-ht
         }:
         mkDerivation {
           pname = "gnuplot";
           version = "0.5.5.3";
           sha256 = "4f742082835978919db75abc570e6cd924d63c6bdd951e1280f97d5d98540504";
           isLibrary = true;
           isExecutable = true;
           enableSeparateDataOutput = true;
           libraryHaskellDepends = [
             array base containers data-accessor data-accessor-transformers
             deepseq filepath process semigroups temporary time transformers
             utility-ht
           ];
           doHaddock = false;
           doCheck = false;
           homepage = "http://www.haskell.org/haskellwiki/Gnuplot";
           description = "2D and 3D plots using gnuplot";
           license = stdenv.lib.licenses.bsd3;
         }) {};
      "goggles" = callPackage
        ({ mkDerivation, aeson, attoparsec, base, base64-bytestring, binary
         , bytestring, containers, cryptonite, exceptions, filepath
         , http-client, http-client-tls, http-types, memory, mtl, pem, req
         , scientific, stdenv, stm, text, time, transformers, unix-time
         , x509, x509-store
         }:
         mkDerivation {
           pname = "goggles";
           version = "0.3.2";
           sha256 = "a64d25c6506b172ec6f3b8a55f7934c23ccedc66c1acfb62432063dff743e93c";
           libraryHaskellDepends = [
             aeson attoparsec base base64-bytestring binary bytestring
             containers cryptonite exceptions filepath http-client
             http-client-tls http-types memory mtl pem req scientific stm text
             time transformers unix-time x509 x509-store
           ];
           doHaddock = false;
           doCheck = false;
           homepage = "https://github.com/ocramz/goggles";
           description = "Extensible interface to Web APIs";
           license = stdenv.lib.licenses.bsd3;
         }) {};
      "google-oauth2-jwt" = callPackage
        ({ mkDerivation, base, base64-bytestring, bytestring, HsOpenSSL
         , RSA, stdenv, text, unix-time
         }:
         mkDerivation {
           pname = "google-oauth2-jwt";
           version = "0.3.1";
           sha256 = "71d7704aad64fbd2398d8b0dcb6f39311a8e710385fc80ee2b665bd6b43b2f88";
           libraryHaskellDepends = [
             base base64-bytestring bytestring HsOpenSSL RSA text unix-time
           ];
           doHaddock = false;
           doCheck = false;
           homepage = "https://github.com/MichelBoucey/google-oauth2-jwt";
           description = "Get a signed JWT for Google Service Accounts";
           license = stdenv.lib.licenses.bsd3;
         }) {};
      "gpolyline" = callPackage
        ({ mkDerivation, base, split, stdenv }:
         mkDerivation {
           pname = "gpolyline";
           version = "0.1.0.1";
           sha256 = "28b3a644853ba6f0a7d6465d8d62646a10c995008a799ae67e728c8cf4a17a05";
           libraryHaskellDepends = [ base split ];
           doHaddock = false;
           doCheck = false;
           homepage = "https://github.com/fegu/gpolyline";
           description = "Pure module for encoding/decoding Google Polyline";
           license = stdenv.lib.licenses.bsd3;
         }) {};
      "graph-core" = callPackage
        ({ mkDerivation, base, containers, deepseq, hashable, mtl, safe
         , stdenv, unordered-containers, vector
         }:
         mkDerivation {
           pname = "graph-core";
           version = "0.3.0.0";
           sha256 = "378f0baa40ebbb78e8c389f79e363eb573cdf182f799684d2f3d6ac51b10e854";
           libraryHaskellDepends = [
             base containers deepseq hashable mtl safe unordered-containers
             vector
           ];
           doHaddock = false;
           doCheck = false;
           homepage = "https://github.com/factisresearch/graph-core";
           description = "Fast, memory efficient and persistent graph implementation";
           license = stdenv.lib.licenses.mit;
         }) {};
      "graph-wrapper" = callPackage
        ({ mkDerivation, array, base, containers, stdenv }:
         mkDerivation {
           pname = "graph-wrapper";
           version = "0.2.5.2";
           sha256 = "98a42ef1eee9a5012b0bb2a91f645dd8487df6cfdcfcab5e387a8abf42768dcd";
           libraryHaskellDepends = [ array base containers ];
           doHaddock = false;
           doCheck = false;
           homepage = "https://github.com/soenkehahn/graph-wrapper";
           description = "A wrapper around the standard Data.Graph with a less awkward interface";
           license = stdenv.lib.licenses.bsd3;
         }) {};
      "graphs" = callPackage
        ({ mkDerivation, array, base, containers, stdenv, transformers
         , transformers-compat, void
         }:
         mkDerivation {
           pname = "graphs";
           version = "0.7.1";
           sha256 = "acd37a7ba5dd02f24131ac8971a5f8639cc0e9db687e7d6790a84af4af0ce209";
           revision = "1";
           editedCabalFile = "1cjyxswlkachki6l4mcaffwpjajyx86jzipzlqjg7c080vwvb19g";
           libraryHaskellDepends = [
             array base containers transformers transformers-compat void
           ];
           doHaddock = false;
           doCheck = false;
           homepage = "http://github.com/ekmett/graphs";
           description = "A simple monadic graph library";
           license = stdenv.lib.licenses.bsd3;
         }) {};
      "graphviz" = callPackage
        ({ mkDerivation, base, bytestring, colour, containers, directory
         , dlist, fgl, filepath, mtl, polyparse, process, stdenv, temporary
         , text, wl-pprint-text
         }:
         mkDerivation {
           pname = "graphviz";
           version = "2999.20.0.2";
           sha256 = "e7662eb82d1e5b22b467fb6e9094b65731036ae04c5374058e3b52fbc055474e";
           isLibrary = true;
           isExecutable = true;
           libraryHaskellDepends = [
             base bytestring colour containers directory dlist fgl filepath mtl
             polyparse process temporary text wl-pprint-text
           ];
           doHaddock = false;
           doCheck = false;
           homepage = "http://projects.haskell.org/graphviz/";
           description = "Bindings to Graphviz for graph visualisation";
           license = stdenv.lib.licenses.bsd3;
         }) {};
      "gravatar" = callPackage
        ({ mkDerivation, base, bytestring, data-default, HTTP, pureMD5
         , stdenv, text
         }:
         mkDerivation {
           pname = "gravatar";
           version = "0.8.0";
           sha256 = "6f6000acaea47f3fc8711f5a2a62d5fbe96f5bb698fcb997f9f07ffe3102f4d7";
           libraryHaskellDepends = [
             base bytestring data-default HTTP pureMD5 text
           ];
           doHaddock = false;
           doCheck = false;
           description = "Generate Gravatar image URLs";
           license = stdenv.lib.licenses.mit;
         }) {};
      "graylog" = callPackage
        ({ mkDerivation, aeson, aeson-casing, base, bytestring, network
         , random, scientific, stdenv, text, time, vector
         }:
         mkDerivation {
           pname = "graylog";
           version = "0.1.0.1";
           sha256 = "2d8173e61da8d02c39cb95e6ccea8a167c792f682a496aed5fe4edfd0e6a0082";
           libraryHaskellDepends = [
             aeson aeson-casing base bytestring network random scientific text
             time vector
           ];
           doHaddock = false;
           doCheck = false;
           homepage = "https://github.com/AndrewRademacher/haskell-graylog";
           description = "Support for graylog output";
           license = "unknown";
           hydraPlatforms = stdenv.lib.platforms.none;
         }) {};
      "greskell" = callPackage
        ({ mkDerivation, aeson, base, exceptions, greskell-core, semigroups
         , stdenv, text, transformers, unordered-containers, vector
         }:
         mkDerivation {
           pname = "greskell";
           version = "0.2.2.0";
           sha256 = "7f594dd299c20ad25cc2898383ec86d03170667c010ac1a7906d80ec1d8e44cd";
           configureFlags = [ "-f-hint-test" ];
           libraryHaskellDepends = [
             aeson base exceptions greskell-core semigroups text transformers
             unordered-containers vector
           ];
           doHaddock = false;
           doCheck = false;
           homepage = "https://github.com/debug-ito/greskell/";
           description = "Haskell binding for Gremlin graph query language";
           license = stdenv.lib.licenses.bsd3;
         }) {};
      "greskell-core" = callPackage
        ({ mkDerivation, aeson, base, containers, hashable, scientific
         , semigroups, stdenv, text, unordered-containers, uuid, vector
         }:
         mkDerivation {
           pname = "greskell-core";
           version = "0.1.2.4";
           sha256 = "201d3f76a503948114f387f0c63d88e1170ed26305b2c2a8b799a47d37dc4f85";
           libraryHaskellDepends = [
             aeson base containers hashable scientific semigroups text
             unordered-containers uuid vector
           ];
           doHaddock = false;
           doCheck = false;
           homepage = "https://github.com/debug-ito/greskell/";
           description = "Haskell binding for Gremlin graph query language - core data types and tools";
           license = stdenv.lib.licenses.bsd3;
         }) {};
      "greskell-websocket" = callPackage
        ({ mkDerivation, aeson, async, base, base64-bytestring, bytestring
         , greskell-core, hashtables, safe-exceptions, stdenv, stm, text
         , unordered-containers, uuid, vector, websockets
         }:
         mkDerivation {
           pname = "greskell-websocket";
           version = "0.1.1.2";
           sha256 = "9062b34fec1855b0262a0cf529dcc3ebf5bb20738712195420d832dd46e2cde7";
           libraryHaskellDepends = [
             aeson async base base64-bytestring bytestring greskell-core
             hashtables safe-exceptions stm text unordered-containers uuid
             vector websockets
           ];
           doHaddock = false;
           doCheck = false;
           homepage = "https://github.com/debug-ito/greskell/";
           description = "Haskell client for Gremlin Server using WebSocket serializer";
           license = stdenv.lib.licenses.bsd3;
         }) {};
      "groom" = callPackage
        ({ mkDerivation, base, haskell-src-exts, stdenv }:
         mkDerivation {
           pname = "groom";
           version = "0.1.2.1";
           sha256 = "a6b4a4d3af1b26f63039f04bd4176493f8dd4f6a9ab281f0e33c0151c20de59d";
           isLibrary = true;
           isExecutable = true;
           libraryHaskellDepends = [ base haskell-src-exts ];
           executableHaskellDepends = [ base ];
           doHaddock = false;
           doCheck = false;
           description = "Pretty printing for well-behaved Show instances";
           license = stdenv.lib.licenses.bsd3;
         }) {};
      "groundhog" = callPackage
        ({ mkDerivation, aeson, attoparsec, base, base64-bytestring
         , blaze-builder, bytestring, containers, monad-control, mtl
         , resourcet, safe-exceptions, scientific, stdenv, text, time
         , transformers, transformers-base, transformers-compat
         }:
         mkDerivation {
           pname = "groundhog";
           version = "0.9.0";
           sha256 = "407ae09955e205bfbf246400b5cbdd881eb8b616342a3263ae7b81c642b2a025";
           libraryHaskellDepends = [
             aeson attoparsec base base64-bytestring blaze-builder bytestring
             containers monad-control mtl resourcet safe-exceptions scientific
             text time transformers transformers-base transformers-compat
           ];
           doHaddock = false;
           doCheck = false;
           homepage = "http://github.com/lykahb/groundhog";
           description = "Type-safe datatype-database mapping library";
           license = stdenv.lib.licenses.bsd3;
         }) {};
      "groundhog-inspector" = callPackage
        ({ mkDerivation, aeson-pretty, base, bytestring, cmdargs
         , containers, groundhog, groundhog-sqlite, groundhog-th, mtl
         , regex-compat, stdenv, syb, template-haskell, text, time
         , transformers
         }:
         mkDerivation {
           pname = "groundhog-inspector";
           version = "0.9.0";
           sha256 = "8b7bca3f39c718b46ce1e18b77d8f3a4110c51a8ffaf7b4d53a9952c9efe69ed";
           revision = "1";
           editedCabalFile = "1fzkm7rxg3la10j65drhvqnzcv6c5rscq3cqz7f0395rbw0pakmy";
           isLibrary = true;
           isExecutable = true;
           libraryHaskellDepends = [
             aeson-pretty base bytestring containers groundhog groundhog-th
             regex-compat syb template-haskell text time transformers
           ];
           executableHaskellDepends = [
             base bytestring cmdargs containers groundhog groundhog-sqlite
             groundhog-th mtl
           ];
           doHaddock = false;
           doCheck = false;
           homepage = "http://github.com/lykahb/groundhog";
           description = "Type-safe datatype-database mapping library";
           license = stdenv.lib.licenses.bsd3;
         }) {};
      "groundhog-mysql" = callPackage
        ({ mkDerivation, base, bytestring, containers, groundhog
         , monad-control, monad-logger, mysql, mysql-simple, resource-pool
         , resourcet, stdenv, text, time, transformers
         }:
         mkDerivation {
           pname = "groundhog-mysql";
           version = "0.9.0";
           sha256 = "78b69ed182e036c68fd7ea00aa977a706e178a5355c5f7b36bb2401cd6667f58";
           libraryHaskellDepends = [
             base bytestring containers groundhog monad-control monad-logger
             mysql mysql-simple resource-pool resourcet text time transformers
           ];
           doHaddock = false;
           doCheck = false;
           description = "MySQL backend for the groundhog library";
           license = stdenv.lib.licenses.bsd3;
         }) {};
      "groundhog-postgresql" = callPackage
        ({ mkDerivation, aeson, attoparsec, base, blaze-builder, bytestring
         , containers, groundhog, monad-control, postgresql-libpq
         , postgresql-simple, resource-pool, resourcet, stdenv, text, time
         , transformers, vector
         }:
         mkDerivation {
           pname = "groundhog-postgresql";
           version = "0.9.0.1";
           sha256 = "85ee5a417ec6a26512b915dfc32378e0788f8c0d810898adbb6d559d0ba2085d";
           libraryHaskellDepends = [
             aeson attoparsec base blaze-builder bytestring containers groundhog
             monad-control postgresql-libpq postgresql-simple resource-pool
             resourcet text time transformers vector
           ];
           doHaddock = false;
           doCheck = false;
           description = "PostgreSQL backend for the groundhog library";
           license = stdenv.lib.licenses.bsd3;
         }) {};
      "groundhog-sqlite" = callPackage
        ({ mkDerivation, base, bytestring, containers, direct-sqlite
         , groundhog, monad-control, resource-pool, resourcet, stdenv, text
         , transformers, unordered-containers
         }:
         mkDerivation {
           pname = "groundhog-sqlite";
           version = "0.9.0";
           sha256 = "abfb8cfef6e848bf9d1d7605da780a4cd0bd61b4a9ce098d3bac99947d2d2819";
           libraryHaskellDepends = [
             base bytestring containers direct-sqlite groundhog monad-control
             resource-pool resourcet text transformers unordered-containers
           ];
           doHaddock = false;
           doCheck = false;
           description = "Sqlite3 backend for the groundhog library";
           license = stdenv.lib.licenses.bsd3;
         }) {};
      "groundhog-th" = callPackage
        ({ mkDerivation, aeson, base, bytestring, containers, groundhog
         , stdenv, template-haskell, text, time, unordered-containers, yaml
         }:
         mkDerivation {
           pname = "groundhog-th";
           version = "0.9.0.1";
           sha256 = "93566644ad3174b1048ad09f70ed0626e415aa67d7d458ba1e43ba5ab4413343";
           libraryHaskellDepends = [
             aeson base bytestring containers groundhog template-haskell text
             time unordered-containers yaml
           ];
           doHaddock = false;
           doCheck = false;
           description = "Type-safe datatype-database mapping library";
           license = stdenv.lib.licenses.bsd3;
         }) {};
      "groups" = callPackage
        ({ mkDerivation, base, stdenv }:
         mkDerivation {
           pname = "groups";
           version = "0.4.1.0";
           sha256 = "dd4588b71dfff42b9a30cb40304912742b95db964b20f51951aff0eee7f3f33d";
           libraryHaskellDepends = [ base ];
           doHaddock = false;
           doCheck = false;
           description = "Haskell 98 groups";
           license = stdenv.lib.licenses.bsd3;
         }) {};
      "gtk" = callPackage
        ({ mkDerivation, array, base, bytestring, Cabal, cairo, containers
         , gio, glib, gtk2, gtk2hs-buildtools, mtl, pango, stdenv, text
         }:
         mkDerivation {
           pname = "gtk";
           version = "0.14.10";
           sha256 = "28e1671eeb216335c7615513ba285a0c538d6747e38eb9acb64a5641f2650633";
           enableSeparateDataOutput = true;
           setupHaskellDepends = [ base Cabal gtk2hs-buildtools ];
           libraryHaskellDepends = [
             array base bytestring cairo containers gio glib mtl pango text
           ];
           libraryPkgconfigDepends = [ gtk2 ];
           doHaddock = false;
           doCheck = false;
           homepage = "http://projects.haskell.org/gtk2hs/";
           description = "Binding to the Gtk+ graphical user interface library";
           license = stdenv.lib.licenses.lgpl21;
         }) {inherit (pkgs) gtk2;};
      "gtk2hs-buildtools" = callPackage
        ({ mkDerivation, alex, array, base, Cabal, containers, directory
         , filepath, happy, hashtables, pretty, process, random, stdenv
         }:
         mkDerivation {
           pname = "gtk2hs-buildtools";
           version = "0.13.4.0";
           sha256 = "0f3e6ba90839efd43efe8cecbddb6478a55e2ce7788c57a0add4df477dede679";
           revision = "1";
           editedCabalFile = "0nbghg11y4nvxjxrvdm4a7fzj8z12fr12hkj4b7p27imlryg3m10";
           isLibrary = true;
           isExecutable = true;
           enableSeparateDataOutput = true;
           libraryHaskellDepends = [
             array base Cabal containers directory filepath hashtables pretty
             process random
           ];
           libraryToolDepends = [ alex happy ];
           executableHaskellDepends = [ base ];
           doHaddock = false;
           doCheck = false;
           homepage = "http://projects.haskell.org/gtk2hs/";
           description = "Tools to build the Gtk2Hs suite of User Interface libraries";
           license = stdenv.lib.licenses.gpl2;
         }) {};
      "gtk3" = callPackage
        ({ mkDerivation, array, base, bytestring, Cabal, cairo, containers
         , gio, glib, gtk2hs-buildtools, gtk3, mtl, pango, stdenv, text
         }:
         mkDerivation {
           pname = "gtk3";
           version = "0.14.9";
           sha256 = "48e14ac9180fb090718fdaa5ec8f345173edbe5fdbebd6151f0a64804d0796e5";
           isLibrary = true;
           isExecutable = true;
           enableSeparateDataOutput = true;
           setupHaskellDepends = [ base Cabal gtk2hs-buildtools ];
           libraryHaskellDepends = [
             array base bytestring cairo containers gio glib mtl pango text
           ];
           libraryPkgconfigDepends = [ gtk3 ];
           doHaddock = false;
           doCheck = false;
           homepage = "http://projects.haskell.org/gtk2hs/";
           description = "Binding to the Gtk+ 3 graphical user interface library";
           license = stdenv.lib.licenses.lgpl21;
         }) {inherit (pkgs) gtk3;};
      "gym-http-api" = callPackage
        ({ mkDerivation, aeson, base, exceptions, http-client, servant
         , servant-client, servant-lucid, stdenv, text, unordered-containers
         }:
         mkDerivation {
           pname = "gym-http-api";
           version = "0.1.0.1";
           sha256 = "2c3fd9b261cd7bc3a004d41f582cd6c629956c78f7236eb91d615ca0c9b0c910";
           isLibrary = true;
           isExecutable = true;
           libraryHaskellDepends = [
             aeson base servant servant-client servant-lucid text
             unordered-containers
           ];
           executableHaskellDepends = [
             base exceptions http-client servant-client
           ];
           doHaddock = false;
           doCheck = false;
           homepage = "https://github.com/stites/gym-http-api#readme";
           description = "REST client to the gym-http-api project";
           license = stdenv.lib.licenses.mit;
         }) {};
      "h2c" = callPackage
        ({ mkDerivation, base, bytestring, mtl, resourcet, stdenv }:
         mkDerivation {
           pname = "h2c";
           version = "1.0.0";
           sha256 = "4be2c9d54084175777624770640850aba33d7e4a31e2dc8096c122f737965499";
           libraryHaskellDepends = [ base bytestring mtl resourcet ];
           doHaddock = false;
           doCheck = false;
           homepage = "https://bitbucket.org/fmapE/h2c";
           description = "Bindings to Linux I2C with support for repeated-start transactions";
           license = stdenv.lib.licenses.mit;
         }) {};
      "hOpenPGP" = callPackage
        ({ mkDerivation, aeson, asn1-encoding, attoparsec, base
         , base16-bytestring, base64-bytestring, bifunctors, binary
         , binary-conduit, bytestring, bzlib, conduit, conduit-extra
         , containers, crypto-cipher-types, cryptonite, errors, hashable
         , incremental-parser, ixset-typed, lens, memory, monad-loops
         , nettle, network-uri, newtype, openpgp-asciiarmor, prettyprinter
         , resourcet, semigroups, split, stdenv, text, time
         , time-locale-compat, transformers, unliftio-core
         , unordered-containers, zlib
         }:
         mkDerivation {
           pname = "hOpenPGP";
           version = "2.7.4.1";
           sha256 = "1aa868310f2c1fe4a768034e8114fe7d5d91479b5f34850c27890537f3419539";
           libraryHaskellDepends = [
             aeson asn1-encoding attoparsec base base16-bytestring
             base64-bytestring bifunctors binary binary-conduit bytestring bzlib
             conduit conduit-extra containers crypto-cipher-types cryptonite
             errors hashable incremental-parser ixset-typed lens memory
             monad-loops nettle network-uri newtype openpgp-asciiarmor
             prettyprinter resourcet semigroups split text time
             time-locale-compat transformers unliftio-core unordered-containers
             zlib
           ];
           doHaddock = false;
           doCheck = false;
           homepage = "https://salsa.debian.org/clint/hOpenPGP";
           description = "native Haskell implementation of OpenPGP (RFC4880)";
           license = stdenv.lib.licenses.mit;
         }) {};
      "hackage-db" = callPackage
        ({ mkDerivation, aeson, base, bytestring, Cabal, containers
         , directory, filepath, stdenv, tar, time, utf8-string
         }:
         mkDerivation {
           pname = "hackage-db";
           version = "2.0.1";
           sha256 = "f0aac1af6d8d29b7fc2ffd43efaf5a7a5b00f2ead8dacff180bc3714c591ef8d";
           isLibrary = true;
           isExecutable = true;
           libraryHaskellDepends = [
             aeson base bytestring Cabal containers directory filepath tar time
             utf8-string
           ];
           doHaddock = false;
           doCheck = false;
           homepage = "https://github.com/peti/hackage-db#readme";
           description = "Access Hackage's package database via Data.Map";
           license = stdenv.lib.licenses.bsd3;
         }) {};
      "hackage-security" = callPackage
        ({ mkDerivation, base, base16-bytestring, base64-bytestring
         , bytestring, Cabal, containers, cryptohash-sha256, directory
         , ed25519, filepath, ghc-prim, mtl, network, network-uri, parsec
         , pretty, stdenv, tar, template-haskell, time, transformers, zlib
         }:
         mkDerivation {
           pname = "hackage-security";
           version = "0.5.3.0";
           sha256 = "db986e17e9265aa9e40901690815b890b97d53159eb24d0a6cafaa7c18577c21";
           revision = "6";
           editedCabalFile = "1xs2nkzlvkdz8g27yzfxbjdbdadfmgiydnlpn5dm77cg18r495ay";
           libraryHaskellDepends = [
             base base16-bytestring base64-bytestring bytestring Cabal
             containers cryptohash-sha256 directory ed25519 filepath ghc-prim
             mtl network network-uri parsec pretty tar template-haskell time
             transformers zlib
           ];
           doHaddock = false;
           doCheck = false;
           homepage = "https://github.com/haskell/hackage-security";
           description = "Hackage security library";
           license = stdenv.lib.licenses.bsd3;
         }) {};
      "haddock-library" = callPackage
        ({ mkDerivation, base, bytestring, containers, deepseq, stdenv
         , transformers
         }:
         mkDerivation {
           pname = "haddock-library";
           version = "1.5.0.1";
           sha256 = "ff2c10f043524135c809303c0d81c7f27a954f0174784e59a497e75e287aabb2";
           libraryHaskellDepends = [
             base bytestring containers deepseq transformers
           ];
           doHaddock = false;
           doCheck = false;
           homepage = "http://www.haskell.org/haddock/";
           description = "Library exposing some functionality of Haddock";
           license = stdenv.lib.licenses.bsd3;
         }) {};
      "hailgun" = callPackage
        ({ mkDerivation, aeson, base, bytestring, email-validate
         , exceptions, filepath, http-client, http-client-tls, http-types
         , stdenv, tagsoup, text, time, transformers
         }:
         mkDerivation {
           pname = "hailgun";
           version = "0.4.1.8";
           sha256 = "9dcc7367afec6605045246d4959f27a29a54bbdbcec543e6f5ae59b048e2dcc3";
           libraryHaskellDepends = [
             aeson base bytestring email-validate exceptions filepath
             http-client http-client-tls http-types tagsoup text time
             transformers
           ];
           doHaddock = false;
           doCheck = false;
           homepage = "https://bitbucket.org/robertmassaioli/hailgun";
           description = "Mailgun REST api interface for Haskell";
           license = stdenv.lib.licenses.mit;
         }) {};
      "hakyll" = callPackage
        ({ mkDerivation, base, binary, blaze-html, blaze-markup, bytestring
         , containers, cryptohash, data-default, deepseq, directory
         , file-embed, filepath, fsnotify, http-conduit, http-types
         , lrucache, mtl, network-uri, optparse-applicative, pandoc
         , pandoc-citeproc, parsec, process, random, regex-tdfa, resourcet
         , scientific, stdenv, tagsoup, text, time, time-locale-compat
         , unordered-containers, vector, wai, wai-app-static, warp, yaml
         }:
         mkDerivation {
           pname = "hakyll";
           version = "4.12.4.0";
           sha256 = "a187b7a105d6d565f758b726fa421933e112c81559c006600916ab6ad0dad44d";
           isLibrary = true;
           isExecutable = true;
           enableSeparateDataOutput = true;
           libraryHaskellDepends = [
             base binary blaze-html blaze-markup bytestring containers
             cryptohash data-default deepseq directory file-embed filepath
             fsnotify http-conduit http-types lrucache mtl network-uri
             optparse-applicative pandoc pandoc-citeproc parsec process random
             regex-tdfa resourcet scientific tagsoup text time
             time-locale-compat unordered-containers vector wai wai-app-static
             warp yaml
           ];
           executableHaskellDepends = [ base directory filepath ];
           doHaddock = false;
           doCheck = false;
           homepage = "http://jaspervdj.be/hakyll";
           description = "A static website compiler library";
           license = stdenv.lib.licenses.bsd3;
         }) {};
      "half" = callPackage
        ({ mkDerivation, base, deepseq, stdenv, template-haskell }:
         mkDerivation {
           pname = "half";
           version = "0.3";
           sha256 = "06b26fb062a55fa8f5df1cc2fddc47e5303f09977279f05f62d1950a51b72093";
           libraryHaskellDepends = [ base deepseq template-haskell ];
           doHaddock = false;
           doCheck = false;
           homepage = "http://github.com/ekmett/half";
           description = "Half-precision floating-point";
           license = stdenv.lib.licenses.bsd3;
         }) {};
      "hamilton" = callPackage
        ({ mkDerivation, ad, ansi-wl-pprint, base, containers
         , finite-typelits, ghc-typelits-knownnat, hmatrix, hmatrix-gsl
         , hmatrix-vector-sized, optparse-applicative, stdenv
         , typelits-witnesses, vector, vector-sized, vty
         }:
         mkDerivation {
           pname = "hamilton";
           version = "0.1.0.3";
           sha256 = "3c7623217c8e49cabc6620835e53609e7b7339f39a1523da2467076252addb1b";
           isLibrary = true;
           isExecutable = true;
           libraryHaskellDepends = [
             ad base hmatrix hmatrix-gsl hmatrix-vector-sized typelits-witnesses
             vector-sized
           ];
           executableHaskellDepends = [
             ansi-wl-pprint base containers finite-typelits
             ghc-typelits-knownnat hmatrix optparse-applicative vector
             vector-sized vty
           ];
           doHaddock = false;
           doCheck = false;
           homepage = "https://github.com/mstksg/hamilton#readme";
           description = "Physics on generalized coordinate systems using Hamiltonian Mechanics and AD";
           license = stdenv.lib.licenses.bsd3;
         }) {};
      "hamtsolo" = callPackage
        ({ mkDerivation, async, attoparsec, attoparsec-binary, base, binary
         , bytestring, conduit, conduit-combinators, conduit-extra
         , exceptions, gitrev, optparse-applicative, resourcet, stdenv
         , stm-conduit, unix
         }:
         mkDerivation {
           pname = "hamtsolo";
           version = "1.0.3";
           sha256 = "d0deda06a582db978a417d8eed9e403c339a54c4bc9c2b6c6cdee8555dbb7035";
           isLibrary = false;
           isExecutable = true;
           executableHaskellDepends = [
             async attoparsec attoparsec-binary base binary bytestring conduit
             conduit-combinators conduit-extra exceptions gitrev
             optparse-applicative resourcet stm-conduit unix
           ];
           doHaddock = false;
           doCheck = false;
           homepage = "https://github.com/tfc/hamtsolo#readme";
           description = "Intel AMT serial-over-lan (SOL) client";
           license = stdenv.lib.licenses.bsd3;
         }) {};
      "handwriting" = callPackage
        ({ mkDerivation, aeson, base, bytestring, containers, directory
         , filepath, lens, lens-aeson, random, split, stdenv, text
         , transformers, wreq
         }:
         mkDerivation {
           pname = "handwriting";
           version = "0.1.0.3";
           sha256 = "7e1b406d19b2f39b34910462dce214c7ca91bb9d78bf9fafb9f906dd44d5beaa";
           isLibrary = true;
           isExecutable = true;
           libraryHaskellDepends = [
             aeson base bytestring containers lens lens-aeson split text
             transformers wreq
           ];
           executableHaskellDepends = [
             base bytestring directory filepath random text
           ];
           doHaddock = false;
           doCheck = false;
           homepage = "http://github.com/ismailmustafa/handwriting-haskell#readme";
           description = "API Client for the handwriting.io API.";
           license = stdenv.lib.licenses.bsd3;
         }) {};
      "hapistrano" = callPackage
        ({ mkDerivation, aeson, async, base, filepath, formatting, gitrev
         , mtl, optparse-applicative, path, path-io, process, stdenv, stm
         , time, transformers, typed-process, yaml
         }:
         mkDerivation {
           pname = "hapistrano";
           version = "0.3.8.0";
           sha256 = "a6c8178f5c9c3f7ca6620f9a744f659296660eeddad3a985a01acdd31dd66ace";
           isLibrary = true;
           isExecutable = true;
           enableSeparateDataOutput = true;
           libraryHaskellDepends = [
             aeson base filepath formatting gitrev mtl path process stm time
             transformers typed-process
           ];
           executableHaskellDepends = [
             aeson async base formatting gitrev optparse-applicative path
             path-io stm yaml
           ];
           doHaddock = false;
           doCheck = false;
           homepage = "https://github.com/stackbuilders/hapistrano";
           description = "A deployment library for Haskell applications";
           license = stdenv.lib.licenses.mit;
         }) {};
      "happstack-server" = callPackage
        ({ mkDerivation, base, base64-bytestring, blaze-html, bytestring
         , containers, directory, exceptions, extensible-exceptions
         , filepath, hslogger, html, monad-control, mtl, network
         , network-uri, old-locale, parsec, process, semigroups, sendfile
         , stdenv, syb, system-filepath, template-haskell, text, threads
         , time, time-compat, transformers, transformers-base
         , transformers-compat, unix, utf8-string, xhtml, zlib
         }:
         mkDerivation {
           pname = "happstack-server";
           version = "7.5.1.3";
           sha256 = "93d237eff4d01e0de97329366662a53868fd7a043612fe36e4a3492b5caefd29";
           libraryHaskellDepends = [
             base base64-bytestring blaze-html bytestring containers directory
             exceptions extensible-exceptions filepath hslogger html
             monad-control mtl network network-uri old-locale parsec process
             semigroups sendfile syb system-filepath template-haskell text
             threads time time-compat transformers transformers-base
             transformers-compat unix utf8-string xhtml zlib
           ];
           doHaddock = false;
           doCheck = false;
           homepage = "http://happstack.com";
           description = "Web related tools and services";
           license = stdenv.lib.licenses.bsd3;
         }) {};
      "happy" = callPackage
        ({ mkDerivation, array, base, Cabal, containers, directory
         , filepath, mtl, stdenv
         }:
         mkDerivation {
           pname = "happy";
           version = "1.19.9";
           sha256 = "3e81a3e813acca3aae52721c412cde18b7b7c71ecbacfaeaa5c2f4b35abf1d8d";
           revision = "3";
           editedCabalFile = "0kwlh964nyqvfbm02np8vpc28gbhsby0r65jhz1918rm0wip9izq";
           isLibrary = false;
           isExecutable = true;
           setupHaskellDepends = [ base Cabal directory filepath ];
           executableHaskellDepends = [ array base containers mtl ];
           doHaddock = false;
           doCheck = false;
           homepage = "https://www.haskell.org/happy/";
           description = "Happy is a parser generator for Haskell";
           license = stdenv.lib.licenses.bsd2;
         }) {};
      "hasbolt" = callPackage
        ({ mkDerivation, base, binary, bytestring, connection, containers
         , data-binary-ieee754, data-default, network, stdenv, text
         , transformers
         }:
         mkDerivation {
           pname = "hasbolt";
           version = "0.1.3.2";
           sha256 = "31acb64497ce06eecfc2c54297b561a373d8584142a8d9b8f67cbabc701c5893";
           revision = "4";
           editedCabalFile = "0h38mjkr3cqhsr9hwf2wj27mknnxyb2y3swzp18s7q4vmrb1ijyz";
           libraryHaskellDepends = [
             base binary bytestring connection containers data-binary-ieee754
             data-default network text transformers
           ];
           doHaddock = false;
           doCheck = false;
           homepage = "https://github.com/zmactep/hasbolt#readme";
           description = "Haskell driver for Neo4j 3+ (BOLT protocol)";
           license = stdenv.lib.licenses.bsd3;
         }) {};
      "hashable" = callPackage
        ({ mkDerivation, base, bytestring, deepseq, ghc-prim, integer-gmp
         , stdenv, text
         }:
         mkDerivation {
           pname = "hashable";
           version = "1.2.7.0";
           sha256 = "ecb5efc0586023f5a0dc861100621c1dbb4cbb2f0516829a16ebac39f0432abf";
           revision = "1";
           editedCabalFile = "197063dpl0wn67dp7a06yc2hxp81n24ykk7klbjx0fndm5n87dh3";
           isLibrary = true;
           isExecutable = true;
           libraryHaskellDepends = [
             base bytestring deepseq ghc-prim integer-gmp text
           ];
           doHaddock = false;
           doCheck = false;
           homepage = "http://github.com/tibbe/hashable";
           description = "A class for types that can be converted to a hash value";
           license = stdenv.lib.licenses.bsd3;
         }) {};
      "hashids" = callPackage
        ({ mkDerivation, base, bytestring, containers, split, stdenv }:
         mkDerivation {
           pname = "hashids";
           version = "1.0.2.4";
           sha256 = "27991fc8a6debe76a086af80f6b72a5d451e7f1466b79cb0df973b98a2f5f3cf";
           libraryHaskellDepends = [ base bytestring containers split ];
           doHaddock = false;
           doCheck = false;
           homepage = "http://hashids.org/";
           description = "Hashids generates short, unique, non-sequential ids from numbers";
           license = stdenv.lib.licenses.mit;
         }) {};
      "hashing" = callPackage
        ({ mkDerivation, array, base, bytestring, mtl, QuickCheck, stdenv
         }:
         mkDerivation {
           pname = "hashing";
           version = "0.1.0.1";
           sha256 = "e5a4a19c6cd6f0a0adda381db76d608d23f8d303e68f1d744735433f91f49410";
           revision = "2";
           editedCabalFile = "1rwl68jiivw7f2f5cg73sr3dawlbmklnwyiwivrcsihrg4b1z1lq";
           isLibrary = true;
           isExecutable = true;
           libraryHaskellDepends = [ array base bytestring ];
           executableHaskellDepends = [
             array base bytestring mtl QuickCheck
           ];
           doHaddock = false;
           doCheck = false;
           homepage = "https://github.com/wangbj/hashing";
           description = "A pure haskell library implements several hash algorithms";
           license = stdenv.lib.licenses.mit;
         }) {};
      "hashmap" = callPackage
        ({ mkDerivation, base, containers, deepseq, hashable, stdenv }:
         mkDerivation {
           pname = "hashmap";
           version = "1.3.3";
           sha256 = "dc06b57cd1bcd656d4602df7705a3f11a54ae65f664e9be472d42a9bdcd64755";
           libraryHaskellDepends = [ base containers deepseq hashable ];
           doHaddock = false;
           doCheck = false;
           homepage = "https://github.com/foxik/hashmap";
           description = "Persistent containers Map and Set based on hashing";
           license = stdenv.lib.licenses.bsd3;
         }) {};
      "hashtables" = callPackage
        ({ mkDerivation, base, ghc-prim, hashable, primitive, stdenv
         , vector
         }:
         mkDerivation {
           pname = "hashtables";
           version = "1.2.3.1";
           sha256 = "8fd1c7c77c267eae6af01f1d9ca427754fb092cfffc8041cd50764a9144b3cbe";
           libraryHaskellDepends = [
             base ghc-prim hashable primitive vector
           ];
           doHaddock = false;
           doCheck = false;
           homepage = "http://github.com/gregorycollins/hashtables";
           description = "Mutable hash tables in the ST monad";
           license = stdenv.lib.licenses.bsd3;
         }) {};
      "haskeline" = callPackage
        ({ mkDerivation, base, bytestring, containers, directory, filepath
         , process, stdenv, stm, terminfo, transformers, unix
         }:
         mkDerivation {
           pname = "haskeline";
           version = "0.7.4.3";
           sha256 = "046d0930bc2dbc57a7cd9ddb5d1e92c7fdb71c6b91b2bbf673f5406843d6b679";
           configureFlags = [ "-fterminfo" ];
           libraryHaskellDepends = [
             base bytestring containers directory filepath process stm terminfo
             transformers unix
           ];
           doHaddock = false;
           doCheck = false;
           homepage = "https://github.com/judah/haskeline";
           description = "A command-line interface for user input, written in Haskell";
           license = stdenv.lib.licenses.bsd3;
         }) {};
      "haskell-gi" = callPackage
        ({ mkDerivation, attoparsec, base, bytestring, Cabal, containers
         , directory, filepath, glib, gobject-introspection, haskell-gi-base
         , mtl, pretty-show, process, regex-tdfa, safe, stdenv, text
         , transformers, xdg-basedir, xml-conduit
         }:
         mkDerivation {
           pname = "haskell-gi";
           version = "0.21.5";
           sha256 = "12d116c6effae4da3f97afaad46faab6766f4a58be2c8fb434f8e0feea4a71e7";
           libraryHaskellDepends = [
             attoparsec base bytestring Cabal containers directory filepath
             haskell-gi-base mtl pretty-show process regex-tdfa safe text
             transformers xdg-basedir xml-conduit
           ];
           libraryPkgconfigDepends = [ glib gobject-introspection ];
           doHaddock = false;
           doCheck = false;
           homepage = "https://github.com/haskell-gi/haskell-gi";
           description = "Generate Haskell bindings for GObject Introspection capable libraries";
           license = stdenv.lib.licenses.lgpl21;
         }) {inherit (pkgs) glib; inherit (pkgs) gobject-introspection;};
      "haskell-gi-base" = callPackage
        ({ mkDerivation, base, bytestring, containers, glib, stdenv, text
         }:
         mkDerivation {
           pname = "haskell-gi-base";
           version = "0.21.4";
           sha256 = "ba6d345e9566ca7cda979a6c8eda3b786be77f6226b8ad8e5a8006cd3103346f";
           libraryHaskellDepends = [ base bytestring containers text ];
           libraryPkgconfigDepends = [ glib ];
           doHaddock = false;
           doCheck = false;
           homepage = "https://github.com/haskell-gi/haskell-gi-base";
           description = "Foundation for libraries generated by haskell-gi";
           license = stdenv.lib.licenses.lgpl21;
         }) {inherit (pkgs) glib;};
      "haskell-gi-overloading" = callPackage
        ({ mkDerivation, stdenv }:
         mkDerivation {
           pname = "haskell-gi-overloading";
           version = "1.0";
           sha256 = "3ed797f8dd8d3535640b1ca99851bbc5968817c25a80fc499af42715d371682a";
           doHaddock = false;
           doCheck = false;
           homepage = "https://github.com/haskell-gi/haskell-gi";
           description = "Overloading support for haskell-gi";
           license = stdenv.lib.licenses.bsd3;
         }) {};
      "haskell-lexer" = callPackage
        ({ mkDerivation, base, stdenv }:
         mkDerivation {
           pname = "haskell-lexer";
           version = "1.0.2";
           sha256 = "d8cdf3122ee384ec440269108fd85ccf207a413015ceeffb2e9bf4313a6addf3";
           libraryHaskellDepends = [ base ];
           doHaddock = false;
           doCheck = false;
           homepage = "https://github.com/yav/haskell-lexer";
           description = "A fully compliant Haskell 98 lexer";
           license = stdenv.lib.licenses.bsd3;
         }) {};
      "haskell-lsp" = callPackage
        ({ mkDerivation, aeson, base, bytestring, containers, data-default
         , directory, filepath, hashable, haskell-lsp-types, hslogger, lens
         , mtl, network-uri, parsec, sorted-list, stdenv, stm, text, time
         , transformers, unordered-containers, vector, yi-rope
         }:
         mkDerivation {
           pname = "haskell-lsp";
           version = "0.2.2.0";
           sha256 = "adfb9231a1580ff7586130f513dc2d4436d3fc0315f0eeca60e283081a5f71c0";
           revision = "1";
           editedCabalFile = "0bdgpj5cj4qwp31glmilp1gqdm8c3fkqvgw18aqv8pz2wg39x23y";
           isLibrary = true;
           isExecutable = true;
           libraryHaskellDepends = [
             aeson base bytestring containers data-default directory filepath
             hashable haskell-lsp-types hslogger lens mtl network-uri parsec
             sorted-list stm text time unordered-containers yi-rope
           ];
           executableHaskellDepends = [
             aeson base bytestring containers data-default directory filepath
             hslogger lens mtl network-uri parsec stm text time transformers
             unordered-containers vector yi-rope
           ];
           doHaddock = false;
           doCheck = false;
           homepage = "https://github.com/alanz/haskell-lsp";
           description = "Haskell library for the Microsoft Language Server Protocol";
           license = stdenv.lib.licenses.mit;
         }) {};
      "haskell-lsp-types" = callPackage
        ({ mkDerivation, aeson, base, bytestring, data-default, filepath
         , hashable, lens, network-uri, stdenv, text, unordered-containers
         }:
         mkDerivation {
           pname = "haskell-lsp-types";
           version = "0.2.2.0";
           sha256 = "bd7a5a259daa504154c701d84d0b1176b46cbfbe46342341d2a0909631f29071";
           libraryHaskellDepends = [
             aeson base bytestring data-default filepath hashable lens
             network-uri text unordered-containers
           ];
           doHaddock = false;
           doCheck = false;
           homepage = "https://github.com/alanz/haskell-lsp";
           description = "Haskell library for the Microsoft Language Server Protocol, data types";
           license = stdenv.lib.licenses.mit;
         }) {};
      "haskell-spacegoo" = callPackage
        ({ mkDerivation, aeson, base, bytestring, conduit, conduit-extra
         , mtl, pretty, pretty-show, stdenv, text, vector, vector-space
         }:
         mkDerivation {
           pname = "haskell-spacegoo";
           version = "0.2.0.1";
           sha256 = "1eb3faa9a7f6a5870337eeb0bb3ad915f58987dfe4643fe95c91cbb2738ddd3c";
           libraryHaskellDepends = [
             aeson base bytestring conduit conduit-extra mtl pretty pretty-show
             text vector vector-space
           ];
           doHaddock = false;
           doCheck = false;
           description = "Client API for Rocket Scissor Spacegoo";
           license = stdenv.lib.licenses.mit;
         }) {};
      "haskell-src" = callPackage
        ({ mkDerivation, array, base, happy, pretty, stdenv, syb }:
         mkDerivation {
           pname = "haskell-src";
           version = "1.0.3.0";
           sha256 = "b4b4941e8883da32c3f2b93f3ecdd5cff82ff9304cb91e89850b19095c908dbc";
           libraryHaskellDepends = [ array base pretty syb ];
           libraryToolDepends = [ happy ];
           doHaddock = false;
           doCheck = false;
           description = "Support for manipulating Haskell source code";
           license = stdenv.lib.licenses.bsd3;
         }) {};
      "haskell-src-exts" = callPackage
        ({ mkDerivation, array, base, ghc-prim, happy, pretty, stdenv }:
         mkDerivation {
           pname = "haskell-src-exts";
           version = "1.20.3";
           sha256 = "433e68a731fb6a1435e86d3eb3b2878db9c5d51dc1f7499d85bbf5ac3ed1e4a8";
           libraryHaskellDepends = [ array base ghc-prim pretty ];
           libraryToolDepends = [ happy ];
           doHaddock = false;
           doCheck = false;
           homepage = "https://github.com/haskell-suite/haskell-src-exts";
           description = "Manipulating Haskell source: abstract syntax, lexer, parser, and pretty-printer";
           license = stdenv.lib.licenses.bsd3;
         }) {};
      "haskell-src-exts-simple" = callPackage
        ({ mkDerivation, base, haskell-src-exts, stdenv }:
         mkDerivation {
           pname = "haskell-src-exts-simple";
           version = "1.20.0.0";
           sha256 = "b305be88204f70af3b7f2e1feb972cf38f3feafb82781e94909484c5ebbde95c";
           libraryHaskellDepends = [ base haskell-src-exts ];
           doHaddock = false;
           doCheck = false;
           homepage = "https://github.com/int-e/haskell-src-exts-simple";
           description = "A simplified view on the haskell-src-exts AST";
           license = stdenv.lib.licenses.mit;
         }) {};
      "haskell-src-exts-util" = callPackage
        ({ mkDerivation, base, containers, data-default, haskell-src-exts
         , semigroups, stdenv, transformers, uniplate
         }:
         mkDerivation {
           pname = "haskell-src-exts-util";
           version = "0.2.4";
           sha256 = "beb8af3a29322c72a9c9ac9988953c5aacc8f3b882780dd4f03f621d15126ef5";
           libraryHaskellDepends = [
             base containers data-default haskell-src-exts semigroups
             transformers uniplate
           ];
           doHaddock = false;
           doCheck = false;
           homepage = "https://github.com/pepeiborra/haskell-src-exts-util";
           description = "Helper functions for working with haskell-src-exts trees";
           license = stdenv.lib.licenses.bsd3;
         }) {};
      "haskell-src-meta" = callPackage
        ({ mkDerivation, base, haskell-src-exts, pretty, stdenv, syb
         , template-haskell, th-orphans
         }:
         mkDerivation {
           pname = "haskell-src-meta";
           version = "0.8.0.3";
           sha256 = "8473e3555080860c2043581b398dbab67319584a568463b074a092fd4d095822";
           revision = "2";
           editedCabalFile = "0dp5v0yd0wgijzaggr22glgjswpa65hy84h8awdzd9d78g2fjz6c";
           libraryHaskellDepends = [
             base haskell-src-exts pretty syb template-haskell th-orphans
           ];
           doHaddock = false;
           doCheck = false;
           description = "Parse source to template-haskell abstract syntax";
           license = stdenv.lib.licenses.bsd3;
         }) {};
      "haskell-tools-ast" = callPackage
        ({ mkDerivation, base, classyplate, ghc, mtl, pretty, references
         , stdenv, template-haskell, uniplate
         }:
         mkDerivation {
           pname = "haskell-tools-ast";
           version = "1.1.0.2";
           sha256 = "2cf0f51aa551c896634ee2649782ee8994bed7088a14e03961b4bf2a5e6d0149";
           libraryHaskellDepends = [
             base classyplate ghc mtl pretty references template-haskell
             uniplate
           ];
           doHaddock = false;
           doCheck = false;
           homepage = "https://github.com/nboldi/haskell-tools";
           description = "Haskell AST for efficient tooling";
           license = stdenv.lib.licenses.bsd3;
         }) {};
      "haskell-tools-backend-ghc" = callPackage
        ({ mkDerivation, base, bytestring, containers, ghc, ghc-boot-th
         , haskell-tools-ast, mtl, references, safe, split, stdenv
         , template-haskell, transformers, uniplate
         }:
         mkDerivation {
           pname = "haskell-tools-backend-ghc";
           version = "1.1.0.2";
           sha256 = "14fe9a12005f05fac32be4c973e4b08c223bf0d6b2a879e92e190d6bf7230530";
           libraryHaskellDepends = [
             base bytestring containers ghc ghc-boot-th haskell-tools-ast mtl
             references safe split template-haskell transformers uniplate
           ];
           doHaddock = false;
           doCheck = false;
           homepage = "https://github.com/nboldi/haskell-tools";
           description = "Creating the Haskell-Tools AST from GHC's representations";
           license = stdenv.lib.licenses.bsd3;
         }) {};
      "haskell-tools-builtin-refactorings" = callPackage
        ({ mkDerivation, aeson, base, Cabal, classyplate, containers
         , deepseq, directory, filepath, ghc, ghc-paths, haskell-tools-ast
         , haskell-tools-backend-ghc, haskell-tools-prettyprint
         , haskell-tools-refactor, haskell-tools-rewrite, minisat-solver
         , mtl, portable-lines, references, split, stdenv, template-haskell
         , transformers, uniplate
         }:
         mkDerivation {
           pname = "haskell-tools-builtin-refactorings";
           version = "1.1.0.2";
           sha256 = "8916acba20c47d3091272458a131e38cb8edb26f5dd44cb7793f12ce8661a7f2";
           libraryHaskellDepends = [
             aeson base Cabal classyplate containers deepseq directory filepath
             ghc ghc-paths haskell-tools-ast haskell-tools-backend-ghc
             haskell-tools-prettyprint haskell-tools-refactor
             haskell-tools-rewrite minisat-solver mtl portable-lines references
             split template-haskell transformers uniplate
           ];
           doHaddock = false;
           doCheck = false;
           homepage = "https://github.com/haskell-tools/haskell-tools";
           description = "Refactoring Tool for Haskell";
           license = stdenv.lib.licenses.bsd3;
         }) {};
      "haskell-tools-debug" = callPackage
        ({ mkDerivation, base, classyplate, criterion, filepath, ghc
         , ghc-paths, haskell-tools-ast, haskell-tools-backend-ghc
         , haskell-tools-builtin-refactorings, haskell-tools-prettyprint
         , haskell-tools-refactor, mtl, references, split, stdenv
         , template-haskell, uniplate
         }:
         mkDerivation {
           pname = "haskell-tools-debug";
           version = "1.1.0.2";
           sha256 = "14da03518f3ea1cf1778cbf7f157437a899b86bf06b99b74f8e01502894cdbd2";
           isLibrary = true;
           isExecutable = true;
           libraryHaskellDepends = [
             base classyplate criterion filepath ghc ghc-paths haskell-tools-ast
             haskell-tools-backend-ghc haskell-tools-builtin-refactorings
             haskell-tools-prettyprint haskell-tools-refactor mtl references
             split template-haskell uniplate
           ];
           executableHaskellDepends = [ base ];
           doHaddock = false;
           doCheck = false;
           homepage = "https://github.com/haskell-tools/haskell-tools";
           description = "Debugging Tools for Haskell-tools";
           license = stdenv.lib.licenses.bsd3;
         }) {};
      "haskell-tools-demo" = callPackage
        ({ mkDerivation, aeson, base, bytestring, containers, directory
         , filepath, ghc, ghc-paths, haskell-tools-ast
         , haskell-tools-backend-ghc, haskell-tools-builtin-refactorings
         , haskell-tools-prettyprint, haskell-tools-refactor, http-types
         , mtl, references, stdenv, transformers, wai, wai-websockets, warp
         , websockets
         }:
         mkDerivation {
           pname = "haskell-tools-demo";
           version = "1.1.0.2";
           sha256 = "7deec5cfae29cecb99ee6b57cfd9d37deb0a2f2546263bbc4a5d08ca70375530";
           isLibrary = true;
           isExecutable = true;
           libraryHaskellDepends = [
             aeson base bytestring containers directory filepath ghc ghc-paths
             haskell-tools-ast haskell-tools-backend-ghc
             haskell-tools-builtin-refactorings haskell-tools-prettyprint
             haskell-tools-refactor http-types mtl references transformers wai
             wai-websockets warp websockets
           ];
           executableHaskellDepends = [ base ];
           doHaddock = false;
           doCheck = false;
           homepage = "https://github.com/haskell-tools/haskell-tools";
           description = "A web-based demo for Haskell-tools Refactor";
           license = stdenv.lib.licenses.bsd3;
         }) {};
      "haskell-tools-prettyprint" = callPackage
        ({ mkDerivation, base, containers, ghc, haskell-tools-ast, mtl
         , references, split, stdenv, text, uniplate
         }:
         mkDerivation {
           pname = "haskell-tools-prettyprint";
           version = "1.1.0.2";
           sha256 = "78396c1ac41c5810a0013077738a5ce7bf958201f6703689c0f0746ca3084206";
           libraryHaskellDepends = [
             base containers ghc haskell-tools-ast mtl references split text
             uniplate
           ];
           doHaddock = false;
           doCheck = false;
           homepage = "https://github.com/haskell-tools/haskell-tools";
           description = "Pretty printing of Haskell-Tools AST";
           license = stdenv.lib.licenses.bsd3;
         }) {};
      "haskell-tools-refactor" = callPackage
        ({ mkDerivation, aeson, base, Cabal, containers, directory
         , filepath, ghc, ghc-paths, haskell-tools-ast
         , haskell-tools-backend-ghc, haskell-tools-prettyprint
         , haskell-tools-rewrite, mtl, references, split, stdenv
         , template-haskell, transformers, uniplate
         }:
         mkDerivation {
           pname = "haskell-tools-refactor";
           version = "1.1.0.2";
           sha256 = "f833e8ca1af652c68b3e3f3f5c3714c509d9748585a004a3c4764f61a2acf389";
           libraryHaskellDepends = [
             aeson base Cabal containers directory filepath ghc ghc-paths
             haskell-tools-ast haskell-tools-backend-ghc
             haskell-tools-prettyprint haskell-tools-rewrite mtl references
             split template-haskell transformers uniplate
           ];
           doHaddock = false;
           doCheck = false;
           homepage = "https://github.com/haskell-tools/haskell-tools";
           description = "Refactoring Tool for Haskell";
           license = stdenv.lib.licenses.bsd3;
         }) {};
      "haskell-tools-rewrite" = callPackage
        ({ mkDerivation, base, containers, ghc, haskell-tools-ast
         , haskell-tools-prettyprint, mtl, references, stdenv
         }:
         mkDerivation {
           pname = "haskell-tools-rewrite";
           version = "1.1.0.2";
           sha256 = "a50009039c4428744f63905b0e3ca599aa4362dbe5c887deb15745bd8848e7ab";
           libraryHaskellDepends = [
             base containers ghc haskell-tools-ast haskell-tools-prettyprint mtl
             references
           ];
           doHaddock = false;
           doCheck = false;
           homepage = "https://github.com/haskell-tools/haskell-tools";
           description = "Facilities for generating new parts of the Haskell-Tools AST";
           license = stdenv.lib.licenses.bsd3;
         }) {};
      "haskey" = callPackage
        ({ mkDerivation, base, binary, bytestring, containers, directory
         , exceptions, filepath, focus, haskey-btree, list-t, lz4, mtl
         , semigroups, stdenv, stm, stm-containers, transformers, unix
         , xxhash-ffi
         }:
         mkDerivation {
           pname = "haskey";
           version = "0.3.0.2";
           sha256 = "901c08a8155d8e394a868fe5a4b7318912afda8f91349f870c4384c5ab9944e8";
           libraryHaskellDepends = [
             base binary bytestring containers directory exceptions filepath
             focus haskey-btree list-t lz4 mtl semigroups stm stm-containers
             transformers unix xxhash-ffi
           ];
           doHaddock = false;
           doCheck = false;
           homepage = "https://github.com/haskell-haskey";
           description = "A transactional, ACID compliant, embeddable key-value store";
           license = stdenv.lib.licenses.bsd3;
         }) {};
      "haskey-btree" = callPackage
        ({ mkDerivation, base, binary, bytestring, containers, hashable
         , mtl, semigroups, stdenv, text, transformers, vector
         }:
         mkDerivation {
           pname = "haskey-btree";
           version = "0.3.0.0";
           sha256 = "90387d9a8e2afb22f9a4ace4b8f3b1a2045b955c1283c70a614abeff2294465a";
           libraryHaskellDepends = [
             base binary bytestring containers hashable mtl semigroups text
             transformers vector
           ];
           doHaddock = false;
           doCheck = false;
           homepage = "https://github.com/haskell-haskey/haskey-btree";
           description = "B+-tree implementation in Haskell";
           license = stdenv.lib.licenses.bsd3;
         }) {};
      "haskey-mtl" = callPackage
        ({ mkDerivation, base, exceptions, haskey, haskey-btree
         , monad-control, mtl, stdenv, transformers, transformers-base
         }:
         mkDerivation {
           pname = "haskey-mtl";
           version = "0.3.1.0";
           sha256 = "1ffb00a2901dc19edeeb18299dd1a52a49ca8c25bc04e87555c1bcec90b79294";
           libraryHaskellDepends = [
             base exceptions haskey haskey-btree monad-control mtl transformers
             transformers-base
           ];
           doHaddock = false;
           doCheck = false;
           homepage = "https://github.com/haskell-haskey";
           description = "A monad transformer supporting Haskey transactions";
           license = stdenv.lib.licenses.bsd3;
         }) {};
      "haskintex" = callPackage
        ({ mkDerivation, base, binary, bytestring, containers, directory
         , filepath, haskell-src-exts, HaTeX, hint, parsec, process, stdenv
         , text, transformers
         }:
         mkDerivation {
           pname = "haskintex";
           version = "0.8.0.0";
           sha256 = "9d4974112f33baf47124a56f87b96892a0a37c10587098f851c71256d15cddd8";
           isLibrary = true;
           isExecutable = true;
           libraryHaskellDepends = [
             base binary bytestring containers directory filepath
             haskell-src-exts HaTeX hint parsec process text transformers
           ];
           executableHaskellDepends = [ base ];
           doHaddock = false;
           doCheck = false;
           homepage = "http://daniel-diaz.github.io/projects/haskintex";
           description = "Haskell Evaluation inside of LaTeX code";
           license = stdenv.lib.licenses.bsd3;
         }) {};
      "hasql" = callPackage
        ({ mkDerivation, attoparsec, base, base-prelude, bytestring
         , bytestring-strict-builder, contravariant, contravariant-extras
         , data-default-class, dlist, hashable, hashtables, loch-th, mtl
         , placeholders, postgresql-binary, postgresql-libpq, profunctors
         , stdenv, text, text-builder, transformers, vector
         }:
         mkDerivation {
           pname = "hasql";
           version = "1.3.0.3";
           sha256 = "519ac7c3b06dec89fcd4c881328c2b77c8f74ef34faaba2a4395417fcc257407";
           revision = "2";
           editedCabalFile = "14063k0dald0i2cqk70kdja1df587vn8vrzgw3rb62nxwycr0r9b";
           libraryHaskellDepends = [
             attoparsec base base-prelude bytestring bytestring-strict-builder
             contravariant contravariant-extras data-default-class dlist
             hashable hashtables loch-th mtl placeholders postgresql-binary
             postgresql-libpq profunctors text text-builder transformers vector
           ];
           doHaddock = false;
           doCheck = false;
           homepage = "https://github.com/nikita-volkov/hasql";
           description = "An efficient PostgreSQL driver and a flexible mapping API";
           license = stdenv.lib.licenses.mit;
         }) {};
      "hasql-optparse-applicative" = callPackage
        ({ mkDerivation, base-prelude, hasql, hasql-pool
         , optparse-applicative, stdenv
         }:
         mkDerivation {
           pname = "hasql-optparse-applicative";
           version = "0.3.0.3";
           sha256 = "63b4c3da21434bac9a98521cdcfda7815bcebb8829feb889f4050fffd7f06334";
           libraryHaskellDepends = [
             base-prelude hasql hasql-pool optparse-applicative
           ];
           doHaddock = false;
           doCheck = false;
           homepage = "https://github.com/sannsyn/hasql-optparse-applicative";
           description = "\"optparse-applicative\" parsers for \"hasql\"";
           license = stdenv.lib.licenses.mit;
         }) {};
      "hasql-pool" = callPackage
        ({ mkDerivation, base-prelude, hasql, resource-pool, stdenv, time
         }:
         mkDerivation {
           pname = "hasql-pool";
           version = "0.5";
           sha256 = "3a33cdfc9ae253f193afb824c9488051103b4c71316b6db39d51dce27c825d2f";
           libraryHaskellDepends = [ base-prelude hasql resource-pool time ];
           doHaddock = false;
           doCheck = false;
           homepage = "https://github.com/nikita-volkov/hasql-pool";
           description = "A pool of connections for Hasql";
           license = stdenv.lib.licenses.mit;
         }) {};
      "hasql-transaction" = callPackage
        ({ mkDerivation, base, base-prelude, bytestring
         , bytestring-tree-builder, contravariant, contravariant-extras
         , hasql, mtl, stdenv, transformers
         }:
         mkDerivation {
           pname = "hasql-transaction";
           version = "0.7";
           sha256 = "decb3c5b08f710413ee65861c30766c53dc79d05f388fab6f8e1105e4d907fcf";
           libraryHaskellDepends = [
             base base-prelude bytestring bytestring-tree-builder contravariant
             contravariant-extras hasql mtl transformers
           ];
           doHaddock = false;
           doCheck = false;
           homepage = "https://github.com/nikita-volkov/hasql-transaction";
           description = "A composable abstraction over the retryable transactions for Hasql";
           license = stdenv.lib.licenses.mit;
         }) {};
      "hasty-hamiltonian" = callPackage
        ({ mkDerivation, base, kan-extensions, lens, mcmc-types
         , mwc-probability, pipes, primitive, stdenv, transformers
         }:
         mkDerivation {
           pname = "hasty-hamiltonian";
           version = "1.3.2";
           sha256 = "e6299d72e145cfabea798e2088284580fc65f01638e3562e1f01cf9df018cc9e";
           libraryHaskellDepends = [
             base kan-extensions lens mcmc-types mwc-probability pipes primitive
             transformers
           ];
           doHaddock = false;
           doCheck = false;
           homepage = "http://github.com/jtobin/hasty-hamiltonian";
           description = "Speedy traversal through parameter space";
           license = stdenv.lib.licenses.mit;
         }) {};
      "haxl" = callPackage
        ({ mkDerivation, aeson, base, binary, bytestring, containers
         , deepseq, exceptions, filepath, ghc-prim, hashable, pretty, stdenv
         , stm, text, time, transformers, unordered-containers, vector
         }:
         mkDerivation {
           pname = "haxl";
           version = "2.0.1.1";
           sha256 = "59f30d1bde6c70736071ccf3b561776d1a060af4c5a854c66664df1a47e4d6f1";
           isLibrary = true;
           isExecutable = true;
           libraryHaskellDepends = [
             aeson base binary bytestring containers deepseq exceptions filepath
             ghc-prim hashable pretty stm text time transformers
             unordered-containers vector
           ];
           doHaddock = false;
           doCheck = false;
           homepage = "https://github.com/facebook/Haxl";
           description = "A Haskell library for efficient, concurrent, and concise data access";
           license = stdenv.lib.licenses.bsd3;
         }) {};
      "hbeanstalk" = callPackage
        ({ mkDerivation, attoparsec, base, blaze-builder, bytestring
         , containers, network, stdenv
         }:
         mkDerivation {
           pname = "hbeanstalk";
           version = "0.2.4";
           sha256 = "feaf97fd18fedb3e5abf337e61c98a03108d917d9f87f885c8d02b6b838aac8f";
           libraryHaskellDepends = [
             attoparsec base blaze-builder bytestring containers network
           ];
           doHaddock = false;
           doCheck = false;
           homepage = "http://github.com/scsibug/hbeanstalk/";
           description = "Client for the beanstalkd workqueue service";
           license = stdenv.lib.licenses.bsd3;
         }) {};
      "hdaemonize" = callPackage
        ({ mkDerivation, base, bytestring, extensible-exceptions, filepath
         , hsyslog, mtl, stdenv, unix
         }:
         mkDerivation {
           pname = "hdaemonize";
           version = "0.5.5";
           sha256 = "d250cb0c066ec45aa9b8e9e0df094677f9e7788b01eaf51ab5bc9bbd52fe029f";
           libraryHaskellDepends = [
             base bytestring extensible-exceptions filepath hsyslog mtl unix
           ];
           doHaddock = false;
           doCheck = false;
           homepage = "http://github.com/greydot/hdaemonize";
           description = "Library to handle the details of writing daemons for UNIX";
           license = stdenv.lib.licenses.bsd3;
         }) {};
      "heap" = callPackage
        ({ mkDerivation, base, stdenv }:
         mkDerivation {
           pname = "heap";
           version = "1.0.4";
           sha256 = "a4c2489e1031e9e8d96dff61ac8c15e5fcd3541080d81e0e47e298b3aad3172a";
           libraryHaskellDepends = [ base ];
           doHaddock = false;
           doCheck = false;
           description = "Heaps in Haskell";
           license = stdenv.lib.licenses.bsd3;
         }) {};
      "heaps" = callPackage
        ({ mkDerivation, base, Cabal, cabal-doctest, stdenv }:
         mkDerivation {
           pname = "heaps";
           version = "0.3.6";
           sha256 = "181c3cd7f2be698f903dc9649e5ec9311245ad2b9fed91b61f05d0dd7b7dddb2";
           revision = "3";
           editedCabalFile = "0k6wsm1hwn3vaxdvw8p7cidxg7p8zply2ig4w4qrbpyjhl6dj9x9";
           setupHaskellDepends = [ base Cabal cabal-doctest ];
           libraryHaskellDepends = [ base ];
           doHaddock = false;
           doCheck = false;
           homepage = "http://github.com/ekmett/heaps/";
           description = "Asymptotically optimal Brodal/Okasaki heaps";
           license = stdenv.lib.licenses.bsd3;
         }) {};
      "hebrew-time" = callPackage
        ({ mkDerivation, base, stdenv, time }:
         mkDerivation {
           pname = "hebrew-time";
           version = "0.1.1";
           sha256 = "c7997ee86df43d5d734df63c5e091543bb7fd75a93d530c1857067e27a8b7932";
           libraryHaskellDepends = [ base time ];
           doHaddock = false;
           doCheck = false;
           homepage = "https://github.com/snoyberg/hebrew-time";
           description = "Hebrew dates and prayer times";
           license = stdenv.lib.licenses.mit;
         }) {};
      "hedgehog" = callPackage
        ({ mkDerivation, ansi-terminal, async, base, bytestring
         , concurrent-output, containers, directory, exceptions
         , lifted-async, mmorph, monad-control, mtl, pretty-show, primitive
         , random, resourcet, semigroups, stdenv, stm, template-haskell
         , text, th-lift, time, transformers, transformers-base, unix
         , wl-pprint-annotated
         }:
         mkDerivation {
           pname = "hedgehog";
           version = "0.6.1";
           sha256 = "d2f94024906af37fed427fa1f03177d9a530078a2e54cfb24d7397da9807e177";
           revision = "5";
           editedCabalFile = "0kwmxjb1y3gk85njacw5wcvmq3bzp1649dbjzgzpiba2w342f7il";
           libraryHaskellDepends = [
             ansi-terminal async base bytestring concurrent-output containers
             directory exceptions lifted-async mmorph monad-control mtl
             pretty-show primitive random resourcet semigroups stm
             template-haskell text th-lift time transformers transformers-base
             unix wl-pprint-annotated
           ];
           doHaddock = false;
           doCheck = false;
           homepage = "https://hedgehog.qa";
           description = "Hedgehog will eat all your bugs";
           license = stdenv.lib.licenses.bsd3;
         }) {};
      "hedgehog-corpus" = callPackage
        ({ mkDerivation, base, stdenv }:
         mkDerivation {
           pname = "hedgehog-corpus";
           version = "0.1.0";
           sha256 = "c3569cd8316770115871acf334587350e887b046e35abc0d52a90dd0e6d719f2";
           libraryHaskellDepends = [ base ];
           doHaddock = false;
           doCheck = false;
           homepage = "https://github.com/tmcgilchrist/hedgehog-corpus";
           description = "hedgehog-corpus";
           license = stdenv.lib.licenses.bsd3;
         }) {};
      "hedis" = callPackage
        ({ mkDerivation, async, base, bytestring, bytestring-lexing
         , deepseq, errors, HTTP, mtl, network, network-uri, resource-pool
         , scanner, stdenv, stm, text, time, tls, unordered-containers
         , vector
         }:
         mkDerivation {
           pname = "hedis";
           version = "0.10.10";
           sha256 = "1ad2452dc78065035d58f124547caa8ae927c9a470dbe85988e2ed1b19837241";
           revision = "1";
           editedCabalFile = "0fcpf0jqga8wh0ikbpkma8sw7f5376wbc9w9rsiqp51q8f23x04h";
           libraryHaskellDepends = [
             async base bytestring bytestring-lexing deepseq errors HTTP mtl
             network network-uri resource-pool scanner stm text time tls
             unordered-containers vector
           ];
           doHaddock = false;
           doCheck = false;
           homepage = "https://github.com/informatikr/hedis";
           description = "Client library for the Redis datastore: supports full command set, pipelining";
           license = stdenv.lib.licenses.bsd3;
         }) {};
      "here" = callPackage
        ({ mkDerivation, base, haskell-src-meta, mtl, parsec, stdenv
         , template-haskell
         }:
         mkDerivation {
           pname = "here";
           version = "1.2.13";
           sha256 = "406f9c27ba1e59cd662d078d81dcf2908840a77df15aed31d75dd017b7773c00";
           libraryHaskellDepends = [
             base haskell-src-meta mtl parsec template-haskell
           ];
           doHaddock = false;
           doCheck = false;
           homepage = "https://github.com/tmhedberg/here";
           description = "Here docs & interpolated strings via quasiquotation";
           license = stdenv.lib.licenses.bsd3;
         }) {};
      "heredoc" = callPackage
        ({ mkDerivation, base, stdenv, template-haskell }:
         mkDerivation {
           pname = "heredoc";
           version = "0.2.0.0";
           sha256 = "c90d9fc61cb8cd812be510845493b6a6eddcc4b772581fd40a9433ed8f130f40";
           libraryHaskellDepends = [ base template-haskell ];
           doHaddock = false;
           doCheck = false;
           homepage = "http://hackage.haskell.org/package/heredoc";
           description = "multi-line string / here document using QuasiQuotes";
           license = stdenv.lib.licenses.publicDomain;
         }) {};
      "heterocephalus" = callPackage
        ({ mkDerivation, base, blaze-html, blaze-markup, containers, dlist
         , mtl, parsec, shakespeare, stdenv, template-haskell, text
         , transformers
         }:
         mkDerivation {
           pname = "heterocephalus";
           version = "1.0.5.3";
           sha256 = "4723e03896cc91d524da36fe1b8c5b174b81120c323a3fad692f9ada4bd8794f";
           libraryHaskellDepends = [
             base blaze-html blaze-markup containers dlist mtl parsec
             shakespeare template-haskell text transformers
           ];
           doHaddock = false;
           doCheck = false;
           homepage = "https://github.com/arowM/heterocephalus#readme";
           description = "A type-safe template engine for working with popular front end development tools";
           license = stdenv.lib.licenses.mit;
         }) {};
      "hex" = callPackage
        ({ mkDerivation, base, bytestring, stdenv }:
         mkDerivation {
           pname = "hex";
           version = "0.1.2";
           sha256 = "12ee1243edd80570a486521565fb0c9b5e39374f21a12f050636e71d55ec61ec";
           libraryHaskellDepends = [ base bytestring ];
           doHaddock = false;
           doCheck = false;
           description = "Convert strings into hexadecimal and back";
           license = stdenv.lib.licenses.bsd3;
         }) {};
      "hexml" = callPackage
        ({ mkDerivation, base, bytestring, extra, stdenv }:
         mkDerivation {
           pname = "hexml";
           version = "0.3.4";
           sha256 = "937401802ed6593aad8c5acf0ea963d0f1f4473bf72185702b12eb30e52bbe2a";
           libraryHaskellDepends = [ base bytestring extra ];
           doHaddock = false;
           doCheck = false;
           homepage = "https://github.com/ndmitchell/hexml#readme";
           description = "XML subset DOM parser";
           license = stdenv.lib.licenses.bsd3;
         }) {};
      "hexml-lens" = callPackage
        ({ mkDerivation, base, bytestring, contravariant, foundation, hexml
         , lens, profunctors, stdenv, text
         }:
         mkDerivation {
           pname = "hexml-lens";
           version = "0.2.1";
           sha256 = "baa34ef7206ff924b2559a83da8f8f07bf970e9993a171c956b8de7b70cc496b";
           libraryHaskellDepends = [
             base bytestring contravariant foundation hexml lens profunctors
             text
           ];
           doHaddock = false;
           doCheck = false;
           homepage = "https://github.com/pepeiborra/hexml-lens#readme";
           description = "Lenses for the hexml package";
           license = stdenv.lib.licenses.bsd3;
         }) {};
      "hexpat" = callPackage
        ({ mkDerivation, base, bytestring, containers, deepseq, expat, List
         , stdenv, text, transformers, utf8-string
         }:
         mkDerivation {
           pname = "hexpat";
           version = "0.20.13";
           sha256 = "46e1a0e651c1603c1f064c6ca8d4c66cb27e7a66974bfb45ecaa8f9ccc753fd1";
           libraryHaskellDepends = [
             base bytestring containers deepseq List text transformers
             utf8-string
           ];
           librarySystemDepends = [ expat ];
           doHaddock = false;
           doCheck = false;
           homepage = "http://haskell.org/haskellwiki/Hexpat/";
           description = "XML parser/formatter based on expat";
           license = stdenv.lib.licenses.bsd3;
         }) {inherit (pkgs) expat;};
      "hexstring" = callPackage
        ({ mkDerivation, aeson, base, base16-bytestring, binary, bytestring
         , stdenv, text
         }:
         mkDerivation {
           pname = "hexstring";
           version = "0.11.1";
           sha256 = "40d8dbfe22f572ffdb73f28c448b228a75008e83cc3bf78e939add0c9d800914";
           enableSeparateDataOutput = true;
           libraryHaskellDepends = [
             aeson base base16-bytestring binary bytestring text
           ];
           doHaddock = false;
           doCheck = false;
           homepage = "http://www.leonmergen.com/opensource.html";
           description = "Fast and safe representation of a hex string";
           license = stdenv.lib.licenses.mit;
         }) {};
      "hfsevents" = callPackage
        ({ mkDerivation, base, bytestring, cereal, Cocoa, CoreServices, mtl
         , stdenv, text
         }:
         mkDerivation {
           pname = "hfsevents";
           version = "0.1.6";
           sha256 = "74c3f3f3a5e55fff320c352a2d481069ff915860a0ab970864c6a0e6b65d3f05";
           libraryHaskellDepends = [ base bytestring cereal mtl text ];
           librarySystemDepends = [ Cocoa ];
           libraryToolDepends = [ CoreServices ];
           doHaddock = false;
           doCheck = false;
           homepage = "http://github.com/luite/hfsevents";
           description = "File/folder watching for OS X";
           license = stdenv.lib.licenses.bsd3;
           platforms = [ "x86_64-darwin" ];
         }) {inherit (pkgs.darwin.apple_sdk.frameworks) Cocoa;};
      "hgmp" = callPackage
        ({ mkDerivation, base, ghc-prim, integer-gmp, stdenv }:
         mkDerivation {
           pname = "hgmp";
           version = "0.1.1";
           sha256 = "b905720ad455ef54a167ed6c2a44dfb01f8e8f8efc6fe4f0a2a21ff22f5b3ac2";
           revision = "3";
           editedCabalFile = "0z2xbqzyrgm9apy3xl353wgwhbnc3hdb1giw2j6fyvv705fmpb62";
           libraryHaskellDepends = [ base ghc-prim integer-gmp ];
           doHaddock = false;
           doCheck = false;
           homepage = "https://code.mathr.co.uk/hgmp";
           description = "Haskell interface to GMP";
           license = stdenv.lib.licenses.bsd3;
         }) {};
      "hidapi" = callPackage
        ({ mkDerivation, base, bytestring, deepseq, deepseq-generics
         , stdenv, systemd
         }:
         mkDerivation {
           pname = "hidapi";
           version = "0.1.5";
           sha256 = "3726e0bcbdbda309b919241d86629625e732fd07d78cc90ad39cb39b51cd595e";
           libraryHaskellDepends = [
             base bytestring deepseq deepseq-generics
           ];
           librarySystemDepends = [ systemd ];
           doHaddock = false;
           doCheck = false;
           homepage = "https://github.com/vahokif/haskell-hidapi";
           description = "Haskell bindings to HIDAPI";
           license = stdenv.lib.licenses.mit;
         }) {inherit (pkgs) systemd;};
      "hidden-char" = callPackage
        ({ mkDerivation, base, stdenv }:
         mkDerivation {
           pname = "hidden-char";
           version = "0.1.0.2";
           sha256 = "ea909372a7cc06cda7ee8e9c1a6a5c16be19fef256ad4bd2c0b39e61d940f498";
           revision = "3";
           editedCabalFile = "0f6qghr4i3ar993pjlswdd2rl671lrnxj8740i2yhn89z410vzsa";
           libraryHaskellDepends = [ base ];
           doHaddock = false;
           doCheck = false;
           homepage = "https://github.com/rcook/hidden-char#readme";
           description = "Provides cross-platform getHiddenChar function";
           license = stdenv.lib.licenses.mit;
         }) {};
      "hierarchical-clustering" = callPackage
        ({ mkDerivation, array, base, containers, stdenv }:
         mkDerivation {
           pname = "hierarchical-clustering";
           version = "0.4.6";
           sha256 = "75f17f09b9c38d51a208edee10da2f4706ee784b5cdfe8efc31f7f86bbcdccb1";
           libraryHaskellDepends = [ array base containers ];
           doHaddock = false;
           doCheck = false;
           description = "Fast algorithms for single, average/UPGMA and complete linkage clustering";
           license = stdenv.lib.licenses.bsd3;
         }) {};
      "hierarchy" = callPackage
        ({ mkDerivation, base, exceptions, free, mmorph, monad-control, mtl
         , stdenv, transformers, transformers-base, transformers-compat
         }:
         mkDerivation {
           pname = "hierarchy";
           version = "1.0.2";
           sha256 = "25f90eff98036266e279d5730297e24bdfe27b3151cf155d29415cf7d07b1318";
           libraryHaskellDepends = [
             base exceptions free mmorph monad-control mtl transformers
             transformers-base transformers-compat
           ];
           doHaddock = false;
           doCheck = false;
           homepage = "https://github.com/jwiegley/hierarchy#readme";
           description = "Predicated traversal of generated trees";
           license = stdenv.lib.licenses.bsd3;
         }) {};
      "higher-leveldb" = callPackage
        ({ mkDerivation, base, bytestring, cereal, data-default, exceptions
         , leveldb-haskell, mtl, resourcet, stdenv, transformers
         , transformers-base, unliftio-core
         }:
         mkDerivation {
           pname = "higher-leveldb";
           version = "0.5.0.2";
           sha256 = "2afc228104a29aed6b208b1aeba93631e96fdf11efbe68ad036f838f95f8aff2";
           libraryHaskellDepends = [
             base bytestring cereal data-default exceptions leveldb-haskell mtl
             resourcet transformers transformers-base unliftio-core
           ];
           doHaddock = false;
           doCheck = false;
           homepage = "https://github.com/jeremyjh/higher-leveldb";
           description = "A rich monadic API for working with leveldb databases";
           license = stdenv.lib.licenses.bsd3;
         }) {};
      "highlighting-kate" = callPackage
        ({ mkDerivation, base, blaze-html, bytestring, containers, mtl
         , parsec, pcre-light, stdenv, utf8-string
         }:
         mkDerivation {
           pname = "highlighting-kate";
           version = "0.6.4";
           sha256 = "d8b83385f5da2ea7aa59f28eb860fd7eba0d35a4c36192a5044ee7ea1e001baf";
           configureFlags = [ "-fpcre-light" ];
           isLibrary = true;
           isExecutable = true;
           libraryHaskellDepends = [
             base blaze-html bytestring containers mtl parsec pcre-light
             utf8-string
           ];
           doHaddock = false;
           doCheck = false;
           homepage = "http://github.com/jgm/highlighting-kate";
           description = "Syntax highlighting";
           license = "GPL";
         }) {};
      "hinotify" = callPackage
        ({ mkDerivation, async, base, bytestring, containers, stdenv, unix
         }:
         mkDerivation {
           pname = "hinotify";
           version = "0.3.10";
           sha256 = "af2b7d5733ab52ca38f0d9aed1ec37304f1d6964caa0fb556b8215858c1d5d9d";
           revision = "1";
           editedCabalFile = "07z0n5rvki3w0kjr190bwv7sq8p3myspv8999ilz9rlsqf5a0324";
           libraryHaskellDepends = [ async base bytestring containers unix ];
           doHaddock = false;
           doCheck = false;
           homepage = "https://github.com/kolmodin/hinotify.git";
           description = "Haskell binding to inotify";
           license = stdenv.lib.licenses.bsd3;
         }) {};
      "hint" = callPackage
        ({ mkDerivation, base, directory, exceptions, filepath, ghc
         , ghc-boot, ghc-paths, mtl, random, stdenv, temporary, unix
         }:
         mkDerivation {
           pname = "hint";
           version = "0.8.0";
           sha256 = "2e702d62c8f56b799d767f3d3707bec12597bc529a051ad90bd5840581551c41";
           libraryHaskellDepends = [
             base directory exceptions filepath ghc ghc-boot ghc-paths mtl
             random temporary unix
           ];
           doHaddock = false;
           doCheck = false;
           homepage = "https://github.com/mvdan/hint";
           description = "Runtime Haskell interpreter (GHC API wrapper)";
           license = stdenv.lib.licenses.bsd3;
         }) {};
      "histogram-fill" = callPackage
        ({ mkDerivation, base, deepseq, ghc-prim, primitive, stdenv, vector
         }:
         mkDerivation {
           pname = "histogram-fill";
           version = "0.9.1.0";
           sha256 = "757cbbaacb4ba3bb692582fcd7f87f3a7faf7f9b01a9b4fe7a74fef928a29161";
           libraryHaskellDepends = [ base deepseq ghc-prim primitive vector ];
           doHaddock = false;
           doCheck = false;
           homepage = "https://github.com/Shimuuar/histogram-fill/";
           description = "Library for histograms creation";
           license = stdenv.lib.licenses.bsd3;
         }) {};
      "hjsmin" = callPackage
        ({ mkDerivation, base, blaze-builder, bytestring, containers
         , language-javascript, optparse-applicative, stdenv, text
         }:
         mkDerivation {
           pname = "hjsmin";
           version = "0.2.0.2";
           sha256 = "bec153d2396962c63998eb12d0a2c7c9f7df6f774cb00e41b6cdb1f5a4905484";
           isLibrary = true;
           isExecutable = true;
           libraryHaskellDepends = [
             base blaze-builder bytestring containers language-javascript text
           ];
           executableHaskellDepends = [
             base blaze-builder bytestring containers language-javascript
             optparse-applicative text
           ];
           doHaddock = false;
           doCheck = false;
           homepage = "http://github.com/erikd/hjsmin";
           description = "Haskell implementation of a javascript minifier";
           license = stdenv.lib.licenses.bsd3;
         }) {};
      "hledger" = callPackage
        ({ mkDerivation, ansi-terminal, base, base-compat-batteries
         , bytestring, cmdargs, containers, csv, data-default, Decimal, Diff
         , directory, file-embed, filepath, hashable, haskeline, here
         , hledger-lib, HUnit, lucid, megaparsec, mtl, mtl-compat, old-time
         , parsec, pretty-show, process, regex-tdfa, safe, shakespeare
         , split, stdenv, tabular, temporary, terminfo, text, time
         , transformers, unordered-containers, utf8-string, utility-ht
         , wizards
         }:
         mkDerivation {
           pname = "hledger";
           version = "1.10";
           sha256 = "f64420f852502e84dfa9374ace1d00a06ecf1641ad9fd3b22d7c2c48c1d5c4d3";
           revision = "1";
           editedCabalFile = "1kj1by80j7f6rzwfccwl2cp53bb3lyivh8a8xnawdyxab1pkyz34";
           isLibrary = true;
           isExecutable = true;
           libraryHaskellDepends = [
             ansi-terminal base base-compat-batteries bytestring cmdargs
             containers csv data-default Decimal Diff directory file-embed
             filepath hashable haskeline here hledger-lib HUnit lucid megaparsec
             mtl mtl-compat old-time parsec pretty-show process regex-tdfa safe
             shakespeare split tabular temporary terminfo text time transformers
             unordered-containers utf8-string utility-ht wizards
           ];
           executableHaskellDepends = [
             ansi-terminal base base-compat-batteries bytestring cmdargs
             containers csv data-default Decimal directory file-embed filepath
             haskeline here hledger-lib HUnit megaparsec mtl mtl-compat old-time
             parsec pretty-show process regex-tdfa safe shakespeare split
             tabular temporary terminfo text time transformers
             unordered-containers utf8-string utility-ht wizards
           ];
           doHaddock = false;
           doCheck = false;
           homepage = "http://hledger.org";
           description = "Command-line interface for the hledger accounting tool";
           license = stdenv.lib.licenses.gpl3;
         }) {};
      "hledger-api" = callPackage
        ({ mkDerivation, aeson, base, bytestring, containers, data-default
         , Decimal, docopt, either, hledger, hledger-lib, microlens
         , microlens-platform, safe, servant-server, servant-swagger, stdenv
         , swagger2, text, transformers, wai, wai-extra, warp
         }:
         mkDerivation {
           pname = "hledger-api";
           version = "1.10";
           sha256 = "6e51bf6eb84d600777e4008bc53cea8ab08b103d720c23e04a9954836fbcacab";
           isLibrary = false;
           isExecutable = true;
           executableHaskellDepends = [
             aeson base bytestring containers data-default Decimal docopt either
             hledger hledger-lib microlens microlens-platform safe
             servant-server servant-swagger swagger2 text transformers wai
             wai-extra warp
           ];
           doHaddock = false;
           doCheck = false;
           homepage = "http://hledger.org";
           description = "Web API server for the hledger accounting tool";
           license = stdenv.lib.licenses.gpl3;
         }) {};
      "hledger-interest" = callPackage
        ({ mkDerivation, base, Cabal, Decimal, hledger-lib, mtl, stdenv
         , text, time
         }:
         mkDerivation {
           pname = "hledger-interest";
           version = "1.5.3";
           sha256 = "7a7f5d437c98e42ba1f1529f2645e5df88d18962ae28b71b8c07e428fe08c1b9";
           revision = "1";
           editedCabalFile = "1myqv7hci32hvm98d4fn2zqdvkxsdx1g821n1fwr6814yn89kwjj";
           isLibrary = false;
           isExecutable = true;
           executableHaskellDepends = [
             base Cabal Decimal hledger-lib mtl text time
           ];
           doHaddock = false;
           doCheck = false;
           homepage = "https://github.com/peti/hledger-interest";
           description = "computes interest for a given account";
           license = stdenv.lib.licenses.bsd3;
         }) {};
      "hledger-lib" = callPackage
        ({ mkDerivation, ansi-terminal, array, base, base-compat-batteries
         , blaze-markup, bytestring, cmdargs, containers, csv, data-default
         , Decimal, deepseq, directory, extra, filepath, hashtables, HUnit
         , megaparsec, mtl, mtl-compat, old-time, parsec, parser-combinators
         , pretty-show, regex-tdfa, safe, split, stdenv, tabular, text, time
         , transformers, uglymemo, utf8-string
         }:
         mkDerivation {
           pname = "hledger-lib";
           version = "1.10";
           sha256 = "e18aaf23705f46c432519113148229ff78ddae3dcf41ef784e032bf5cc1943ce";
           revision = "2";
           editedCabalFile = "071bnfgdv665llvggpqbg44kc141jz4ni0j6a1miyyw7wd2dvkix";
           libraryHaskellDepends = [
             ansi-terminal array base base-compat-batteries blaze-markup
             bytestring cmdargs containers csv data-default Decimal deepseq
             directory extra filepath hashtables HUnit megaparsec mtl mtl-compat
             old-time parsec parser-combinators pretty-show regex-tdfa safe
             split tabular text time transformers uglymemo utf8-string
           ];
           doHaddock = false;
           doCheck = false;
           homepage = "http://hledger.org";
           description = "Core data types, parsers and functionality for the hledger accounting tools";
           license = stdenv.lib.licenses.gpl3;
         }) {};
      "hledger-ui" = callPackage
        ({ mkDerivation, ansi-terminal, async, base, base-compat-batteries
         , brick, cmdargs, containers, data-default, directory, filepath
         , fsnotify, hledger, hledger-lib, HUnit, megaparsec, microlens
         , microlens-platform, pretty-show, process, safe, split, stdenv
         , text, text-zipper, time, transformers, vector, vty
         }:
         mkDerivation {
           pname = "hledger-ui";
           version = "1.10.1";
           sha256 = "c7d41f9d2c9f486ab25a9cdb4d89759eae3974f8c4991bf46e3e5ea9bc8690c0";
           revision = "2";
           editedCabalFile = "0igkrj44w3rvadgb7kbi1wwlljyrs4y6awk0mhic4lvnk1slwk6m";
           isLibrary = false;
           isExecutable = true;
           executableHaskellDepends = [
             ansi-terminal async base base-compat-batteries brick cmdargs
             containers data-default directory filepath fsnotify hledger
             hledger-lib HUnit megaparsec microlens microlens-platform
             pretty-show process safe split text text-zipper time transformers
             vector vty
           ];
           doHaddock = false;
           doCheck = false;
           homepage = "http://hledger.org";
           description = "Curses-style user interface for the hledger accounting tool";
           license = stdenv.lib.licenses.gpl3;
         }) {};
      "hledger-web" = callPackage
        ({ mkDerivation, base, blaze-html, blaze-markup, bytestring
         , case-insensitive, clientsession, cmdargs, conduit, conduit-extra
         , data-default, directory, filepath, hjsmin, hledger, hledger-lib
         , http-client, http-conduit, HUnit, json, megaparsec, mtl
         , semigroups, shakespeare, stdenv, template-haskell, text, time
         , transformers, wai, wai-extra, wai-handler-launch, warp, yaml
         , yesod, yesod-core, yesod-form, yesod-static
         }:
         mkDerivation {
           pname = "hledger-web";
           version = "1.10";
           sha256 = "c9dfd130a2430a09672121d8c2e769358c9bc78e7e68118aaf8c2638f24cd4c1";
           revision = "1";
           editedCabalFile = "0zzgc6mjia06fwvjwpzzczh0p9k0a6bi2lib6zq5k1briq4gqblm";
           isLibrary = true;
           isExecutable = true;
           libraryHaskellDepends = [
             base blaze-html blaze-markup bytestring case-insensitive
             clientsession cmdargs conduit conduit-extra data-default directory
             filepath hjsmin hledger hledger-lib http-client http-conduit HUnit
             json megaparsec mtl semigroups shakespeare template-haskell text
             time transformers wai wai-extra wai-handler-launch warp yaml yesod
             yesod-core yesod-form yesod-static
           ];
           executableHaskellDepends = [ base ];
           doHaddock = false;
           doCheck = false;
           homepage = "http://hledger.org";
           description = "Web interface for the hledger accounting tool";
           license = stdenv.lib.licenses.gpl3;
         }) {};
      "hlibgit2" = callPackage
        ({ mkDerivation, base, bindings-DSL, openssl, stdenv, zlib }:
         mkDerivation {
           pname = "hlibgit2";
           version = "0.18.0.16";
           sha256 = "199e4027faafe0a39d18ca3168923d44c57b386b960c72398df1c0fb7eff8e5e";
           libraryHaskellDepends = [ base bindings-DSL zlib ];
           librarySystemDepends = [ openssl ];
           doHaddock = false;
           doCheck = false;
           description = "Low-level bindings to libgit2";
           license = stdenv.lib.licenses.mit;
         }) {inherit (pkgs) openssl;};
      "hlibsass" = callPackage
        ({ mkDerivation, base, Cabal, directory, libsass, stdenv }:
         mkDerivation {
           pname = "hlibsass";
           version = "0.1.8.0";
           sha256 = "26de9a1275e0c1cae5afbe79ad3aa1a857c3bfc0b6dcc97698e9d02d41de4feb";
           configureFlags = [ "-fexternalLibsass" ];
           setupHaskellDepends = [ base Cabal directory ];
           libraryHaskellDepends = [ base ];
           librarySystemDepends = [ libsass ];
           doHaddock = false;
           doCheck = false;
           homepage = "https://github.com/jakubfijalkowski/hlibsass";
           description = "Low-level bindings to Libsass";
           license = stdenv.lib.licenses.mit;
         }) {inherit (pkgs) libsass;};
      "hlint" = callPackage
        ({ mkDerivation, aeson, ansi-terminal, base, bytestring, cmdargs
         , containers, cpphs, data-default, directory, extra, filepath
         , haskell-src-exts, haskell-src-exts-util, hscolour, process
         , refact, stdenv, text, transformers, uniplate
         , unordered-containers, vector, yaml
         }:
         mkDerivation {
           pname = "hlint";
           version = "2.1.11";
           sha256 = "4b590d27ec6da4670deea9de4f52c83048688073b3e6389a74da31d58e30665b";
           isLibrary = true;
           isExecutable = true;
           enableSeparateDataOutput = true;
           libraryHaskellDepends = [
             aeson ansi-terminal base bytestring cmdargs containers cpphs
             data-default directory extra filepath haskell-src-exts
             haskell-src-exts-util hscolour process refact text transformers
             uniplate unordered-containers vector yaml
           ];
           executableHaskellDepends = [ base ];
           doHaddock = false;
           doCheck = false;
           homepage = "https://github.com/ndmitchell/hlint#readme";
           description = "Source code suggestions";
           license = stdenv.lib.licenses.bsd3;
         }) {};
      "hmatrix" = callPackage
        ({ mkDerivation, array, base, binary, bytestring, deepseq
         , openblasCompat, random, semigroups, split, stdenv
         , storable-complex, vector
         }:
         mkDerivation {
           pname = "hmatrix";
           version = "0.19.0.0";
           sha256 = "52eb2e42edc5839bfd9d2dec6c4fb29997eca737537a06df7b2d09bf6c324d82";
           revision = "1";
           editedCabalFile = "0krx0ds5mcj28y6zpg0r50lljn8681wi4c5lqcdz2c71nhixfq8h";
           configureFlags = [ "-fdisable-default-paths" "-fopenblas" ];
           libraryHaskellDepends = [
             array base binary bytestring deepseq random semigroups split
             storable-complex vector
           ];
           librarySystemDepends = [ openblasCompat ];
           doHaddock = false;
           doCheck = false;
           homepage = "https://github.com/albertoruiz/hmatrix";
           description = "Numeric Linear Algebra";
           license = stdenv.lib.licenses.bsd3;
         }) {inherit (pkgs) openblasCompat;};
      "hmatrix-backprop" = callPackage
        ({ mkDerivation, backprop, base, ghc-typelits-knownnat
         , ghc-typelits-natnormalise, hmatrix, hmatrix-vector-sized
         , microlens, stdenv, vector, vector-sized
         }:
         mkDerivation {
           pname = "hmatrix-backprop";
           version = "0.1.2.3";
           sha256 = "bd12d7feec08e396f4174dfc35f808bfbf096370fc75aee185827d86881a03f5";
           revision = "1";
           editedCabalFile = "03zrx1kvyz8gn2w2ygd7ql98yimsm3kyrnrr1cc99mz1cm0phnrv";
           libraryHaskellDepends = [
             backprop base ghc-typelits-knownnat ghc-typelits-natnormalise
             hmatrix hmatrix-vector-sized microlens vector vector-sized
           ];
           doHaddock = false;
           doCheck = false;
           homepage = "https://github.com/mstksg/hmatrix-backprop#readme";
           description = "hmatrix operations lifted for backprop";
           license = stdenv.lib.licenses.bsd3;
         }) {};
      "hmatrix-gsl" = callPackage
        ({ mkDerivation, array, base, gsl, hmatrix, process, random, stdenv
         , vector
         }:
         mkDerivation {
           pname = "hmatrix-gsl";
           version = "0.19.0.1";
           sha256 = "157637d336c72cded119127cc3631a569018284ea8ca54b0e29e742388a2cd6c";
           libraryHaskellDepends = [
             array base hmatrix process random vector
           ];
           libraryPkgconfigDepends = [ gsl ];
           doHaddock = false;
           doCheck = false;
           homepage = "https://github.com/albertoruiz/hmatrix";
           description = "Numerical computation";
           license = stdenv.lib.licenses.gpl3;
         }) {inherit (pkgs) gsl;};
      "hmatrix-gsl-stats" = callPackage
        ({ mkDerivation, base, binary, gsl, hmatrix, stdenv
         , storable-complex, vector
         }:
         mkDerivation {
           pname = "hmatrix-gsl-stats";
           version = "0.4.1.7";
           sha256 = "4a0f8b6ea1caefebd30f1e726c94f238d96c0f873bdeb5d920367e8aca7c54bf";
           libraryHaskellDepends = [
             base binary hmatrix storable-complex vector
           ];
           libraryPkgconfigDepends = [ gsl ];
           doHaddock = false;
           doCheck = false;
           homepage = "http://code.haskell.org/hmatrix-gsl-stats";
           description = "GSL Statistics interface";
           license = stdenv.lib.licenses.bsd3;
         }) {inherit (pkgs) gsl;};
      "hmatrix-morpheus" = callPackage
        ({ mkDerivation, base, blas, hmatrix, liblapack, stdenv }:
         mkDerivation {
           pname = "hmatrix-morpheus";
           version = "0.1.1.2";
           sha256 = "f2f3ee02607096a56c7c5c7f1ddff2f7f91ee05211ec2bd659add8208b1505a7";
           libraryHaskellDepends = [ base hmatrix ];
           librarySystemDepends = [ blas liblapack ];
           doHaddock = false;
           doCheck = false;
           homepage = "https://github.com/aligusnet/morpheus/tree/master/hmatrix-morpheus";
           description = "Low-level machine learning auxiliary functions";
           license = stdenv.lib.licenses.bsd3;
         }) {inherit (pkgs) blas; inherit (pkgs) liblapack;};
      "hmatrix-special" = callPackage
        ({ mkDerivation, base, hmatrix, hmatrix-gsl, stdenv }:
         mkDerivation {
           pname = "hmatrix-special";
           version = "0.19.0.0";
           sha256 = "1f1f8c7f1700cea53132daecc53ca1a9733d4beac91ae1dcd2a2a03c83c9dcd7";
           libraryHaskellDepends = [ base hmatrix hmatrix-gsl ];
           doHaddock = false;
           doCheck = false;
           homepage = "https://github.com/albertoruiz/hmatrix";
           description = "Interface to GSL special functions";
           license = stdenv.lib.licenses.gpl3;
         }) {};
      "hmatrix-vector-sized" = callPackage
        ({ mkDerivation, base, hmatrix, stdenv, vector, vector-sized }:
         mkDerivation {
           pname = "hmatrix-vector-sized";
           version = "0.1.1.2";
           sha256 = "86981a7f412b68e42abff0d929db8ed2eab264d1bde3e4e75fa789066a0f437e";
           libraryHaskellDepends = [ base hmatrix vector vector-sized ];
           doHaddock = false;
           doCheck = false;
           homepage = "https://github.com/mstksg/hmatrix-vector-sized#readme";
           description = "Conversions between hmatrix and vector-sized types";
           license = stdenv.lib.licenses.bsd3;
         }) {};
      "hmpfr" = callPackage
        ({ mkDerivation, base, integer-gmp, mpfr, stdenv }:
         mkDerivation {
           pname = "hmpfr";
           version = "0.4.4";
           sha256 = "2badebf032a24f6ab3bde068d5246bc9cc00bf5a8ac17da8cc0bd45c882816f5";
           enableSeparateDataOutput = true;
           libraryHaskellDepends = [ base integer-gmp ];
           librarySystemDepends = [ mpfr ];
           doHaddock = false;
           doCheck = false;
           homepage = "https://github.com/michalkonecny/hmpfr";
           description = "Haskell binding to the MPFR library";
           license = stdenv.lib.licenses.bsd3;
         }) {inherit (pkgs) mpfr;};
      "hoogle" = callPackage
        ({ mkDerivation, aeson, base, binary, bytestring, cmdargs, conduit
         , conduit-extra, connection, containers, deepseq, directory, extra
         , filepath, haskell-src-exts, http-conduit, http-types, js-flot
         , js-jquery, mmap, network, network-uri, old-locale, process-extras
         , QuickCheck, resourcet, stdenv, storable-tuple, tar
         , template-haskell, text, time, transformers, uniplate, utf8-string
         , vector, wai, wai-logger, warp, warp-tls, zlib
         }:
         mkDerivation {
           pname = "hoogle";
           version = "5.0.17.3";
           sha256 = "66bebaf75600fef1c5fc0613ccc55c137aaed4c8f69653cf903f4fb003b98f9c";
           isLibrary = true;
           isExecutable = true;
           enableSeparateDataOutput = true;
           libraryHaskellDepends = [
             aeson base binary bytestring cmdargs conduit conduit-extra
             connection containers deepseq directory extra filepath
             haskell-src-exts http-conduit http-types js-flot js-jquery mmap
             network network-uri old-locale process-extras QuickCheck resourcet
             storable-tuple tar template-haskell text time transformers uniplate
             utf8-string vector wai wai-logger warp warp-tls zlib
           ];
           executableHaskellDepends = [ base ];
           doHaddock = false;
           doCheck = false;
           testTarget = "--test-option=--no-net";
           homepage = "http://hoogle.haskell.org/";
           description = "Haskell API Search";
           license = stdenv.lib.licenses.bsd3;
         }) {};
      "hoopl" = callPackage
        ({ mkDerivation, base, containers, stdenv }:
         mkDerivation {
           pname = "hoopl";
           version = "3.10.2.2";
           sha256 = "097b1316d5f1c8ffe71133223209eb2b095fe13f43dc01d1fe43fd8a545a2b97";
           revision = "2";
           editedCabalFile = "0j6pz4jzhvviyrhhn1j22ikmjvzrg60nzvq26lbpkcb6y4q6rlyx";
           libraryHaskellDepends = [ base containers ];
           doHaddock = false;
           doCheck = false;
           homepage = "https://github.com/haskell/hoopl";
           description = "A library to support dataflow analysis and optimization";
           license = stdenv.lib.licenses.bsd3;
         }) {};
      "hopenpgp-tools" = callPackage
        ({ mkDerivation, aeson, alex, array, attoparsec, base
         , base16-bytestring, binary, binary-conduit, bytestring, conduit
         , conduit-extra, containers, crypto-pubkey, cryptohash, directory
         , errors, fgl, graphviz, happy, hOpenPGP, http-client
         , http-client-tls, http-types, ixset-typed, lens, monad-loops
         , openpgp-asciiarmor, optparse-applicative, prettyprinter
         , prettyprinter-ansi-terminal, prettyprinter-convert-ansi-wl-pprint
         , resourcet, stdenv, text, time, time-locale-compat, transformers
         , unordered-containers, yaml
         }:
         mkDerivation {
           pname = "hopenpgp-tools";
           version = "0.21.2";
           sha256 = "b418dfc81e9fb19216ffe31cdc74c78c054a049d1eb6c01f3a4acbe5c722068c";
           isLibrary = false;
           isExecutable = true;
           executableHaskellDepends = [
             aeson array attoparsec base base16-bytestring binary binary-conduit
             bytestring conduit conduit-extra containers crypto-pubkey
             cryptohash directory errors fgl graphviz hOpenPGP http-client
             http-client-tls http-types ixset-typed lens monad-loops
             openpgp-asciiarmor optparse-applicative prettyprinter
             prettyprinter-ansi-terminal prettyprinter-convert-ansi-wl-pprint
             resourcet text time time-locale-compat transformers
             unordered-containers yaml
           ];
           executableToolDepends = [ alex happy ];
           doHaddock = false;
           doCheck = false;
           homepage = "https://salsa.debian.org/clint/hOpenPGP";
           description = "hOpenPGP-based command-line tools";
           license = stdenv.lib.licenses.agpl3;
         }) {};
      "hopenssl" = callPackage
        ({ mkDerivation, base, bytestring, openssl, stdenv }:
         mkDerivation {
           pname = "hopenssl";
           version = "2.2.4";
           sha256 = "9df46c328fc4c1d1566e2d1539770c9fe9d0422e09ee254721b35ee7d48a7671";
           revision = "1";
           editedCabalFile = "14bs0wjrqnnn1v8c4yznfzggvmgypm2lssgl0cr498kmp54if0lf";
           libraryHaskellDepends = [ base bytestring ];
           librarySystemDepends = [ openssl ];
           doHaddock = false;
           doCheck = false;
           homepage = "https://github.com/peti/hopenssl";
           description = "FFI Bindings to OpenSSL's EVP Digest Interface";
           license = stdenv.lib.licenses.bsd3;
         }) {inherit (pkgs) openssl;};
      "hopfli" = callPackage
        ({ mkDerivation, base, bytestring, stdenv, zlib }:
         mkDerivation {
           pname = "hopfli";
           version = "0.2.2.1";
           sha256 = "4d71dc0f599c87445c22403b447ce310bf8567d6b10cc82efbdd00a4d4d12a18";
           revision = "1";
           editedCabalFile = "116jns5im51sb9xiwpx308wz3pr67335633anrf8f704pz8vwjka";
           libraryHaskellDepends = [ base bytestring zlib ];
           doHaddock = false;
           doCheck = false;
           homepage = "https://github.com/ananthakumaran/hopfli";
           description = "Bidings to Google's Zopfli compression library";
           license = stdenv.lib.licenses.asl20;
         }) {};
      "hostname" = callPackage
        ({ mkDerivation, base, stdenv }:
         mkDerivation {
           pname = "hostname";
           version = "1.0";
           sha256 = "9b43dab1b6da521f35685b20555da00738c8e136eb972458c786242406a9cf5c";
           libraryHaskellDepends = [ base ];
           doHaddock = false;
           doCheck = false;
           description = "A very simple package providing a cross-platform means of determining the hostname";
           license = stdenv.lib.licenses.bsd3;
         }) {};
      "hostname-validate" = callPackage
        ({ mkDerivation, attoparsec, base, bytestring, stdenv }:
         mkDerivation {
           pname = "hostname-validate";
           version = "1.0.0";
           sha256 = "7fafb1e0cfe19d453030754962e74cdb8f3e791ec5b974623cbf26872779c857";
           libraryHaskellDepends = [ attoparsec base bytestring ];
           doHaddock = false;
           doCheck = false;
           description = "Validate hostnames e.g. localhost or foo.co.uk.";
           license = stdenv.lib.licenses.bsd3;
         }) {};
      "hourglass" = callPackage
        ({ mkDerivation, base, deepseq, stdenv }:
         mkDerivation {
           pname = "hourglass";
           version = "0.2.12";
           sha256 = "44335b5c402e80c60f1db6a74462be4ea29d1a9043aa994334ffee1164f1ca4a";
           libraryHaskellDepends = [ base deepseq ];
           doHaddock = false;
           doCheck = false;
           homepage = "https://github.com/vincenthz/hs-hourglass";
           description = "simple performant time related library";
           license = stdenv.lib.licenses.bsd3;
         }) {};
      "hourglass-orphans" = callPackage
        ({ mkDerivation, aeson, base, hourglass, stdenv }:
         mkDerivation {
           pname = "hourglass-orphans";
           version = "0.1.0.0";
           sha256 = "9f0ba9f3b3cdd391b26daf3dce0bac44ab1f9dd883eaff063af9ebfb0b373d64";
           libraryHaskellDepends = [ aeson base hourglass ];
           doHaddock = false;
           doCheck = false;
           homepage = "https://github.com/psibi/hourglass-orphans#readme";
           description = "Orphan Aeson instances to hourglass";
           license = stdenv.lib.licenses.bsd3;
         }) {};
      "hp2pretty" = callPackage
        ({ mkDerivation, array, attoparsec, base, containers, filepath
         , floatshow, mtl, optparse-applicative, semigroups, stdenv, text
         }:
         mkDerivation {
           pname = "hp2pretty";
           version = "0.8.0.2";
           sha256 = "2fd19796845be73b605ee8830704a6f1f23a80f43731cd36a216fb2b3bb179c8";
           isLibrary = false;
           isExecutable = true;
           executableHaskellDepends = [
             array attoparsec base containers filepath floatshow mtl
             optparse-applicative semigroups text
           ];
           doHaddock = false;
           doCheck = false;
           homepage = "https://code.mathr.co.uk/hp2pretty";
           description = "generate pretty graphs from heap profiles";
           license = stdenv.lib.licenses.bsd3;
         }) {};
      "hpack" = callPackage
        ({ mkDerivation, aeson, base, bifunctors, bytestring, Cabal
         , containers, cryptonite, deepseq, directory, filepath, Glob
         , http-client, http-client-tls, http-types, pretty, scientific
         , stdenv, text, transformers, unordered-containers, vector, yaml
         }:
         mkDerivation {
           pname = "hpack";
           version = "0.28.2";
           sha256 = "b9601332bbac2f042947be1f7478ed0c72367e4caa211b779a75dc26cd8180a3";
           isLibrary = true;
           isExecutable = true;
           libraryHaskellDepends = [
             aeson base bifunctors bytestring Cabal containers cryptonite
             deepseq directory filepath Glob http-client http-client-tls
             http-types pretty scientific text transformers unordered-containers
             vector yaml
           ];
           executableHaskellDepends = [
             aeson base bifunctors bytestring Cabal containers cryptonite
             deepseq directory filepath Glob http-client http-client-tls
             http-types pretty scientific text transformers unordered-containers
             vector yaml
           ];
           doHaddock = false;
           doCheck = false;
           homepage = "https://github.com/sol/hpack#readme";
           description = "An alternative format for Haskell packages";
           license = stdenv.lib.licenses.mit;
         }) {};
      "hpqtypes" = callPackage
        ({ mkDerivation, aeson, async, base, bytestring, Cabal, containers
         , data-default-class, directory, exceptions, filepath, lifted-base
         , monad-control, mtl, postgresql, resource-pool, semigroups, stdenv
         , text, text-show, time, transformers, transformers-base, vector
         }:
         mkDerivation {
           pname = "hpqtypes";
           version = "1.5.3.0";
           sha256 = "ff25807beee2ce9fa59b823313b6e2fdbd6e575e6e91d885ddee0ebf8b92ffc5";
           setupHaskellDepends = [ base Cabal directory filepath ];
           libraryHaskellDepends = [
             aeson async base bytestring containers data-default-class
             exceptions lifted-base monad-control mtl resource-pool semigroups
             text text-show time transformers transformers-base vector
           ];
           librarySystemDepends = [ postgresql ];
           doHaddock = false;
           doCheck = false;
           homepage = "https://github.com/scrive/hpqtypes";
           description = "Haskell bindings to libpqtypes";
           license = stdenv.lib.licenses.bsd3;
         }) {inherit (pkgs) postgresql;};
      "hprotoc" = callPackage
        ({ mkDerivation, alex, array, base, binary, bytestring, containers
         , directory, filepath, haskell-src-exts, mtl, parsec
         , protocol-buffers, protocol-buffers-descriptor, stdenv
         , utf8-string
         }:
         mkDerivation {
           pname = "hprotoc";
           version = "2.4.11";
           sha256 = "93f2e87e8d6fb85464162183b7c9fa4bac09676058f9f7e29cdac63706f3801c";
           isLibrary = true;
           isExecutable = true;
           libraryHaskellDepends = [
             array base binary bytestring containers directory filepath
             haskell-src-exts mtl parsec protocol-buffers
             protocol-buffers-descriptor utf8-string
           ];
           libraryToolDepends = [ alex ];
           executableHaskellDepends = [
             array base binary bytestring containers directory filepath
             haskell-src-exts mtl parsec protocol-buffers
             protocol-buffers-descriptor utf8-string
           ];
           executableToolDepends = [ alex ];
           doHaddock = false;
           doCheck = false;
           homepage = "https://github.com/k-bx/protocol-buffers";
           description = "Parse Google Protocol Buffer specifications";
           license = stdenv.lib.licenses.bsd3;
         }) {};
      "hquantlib" = callPackage
        ({ mkDerivation, base, containers, hmatrix, hmatrix-gsl
         , hmatrix-special, hquantlib-time, mersenne-random-pure64, parallel
         , random, statistics, stdenv, time, vector, vector-algorithms
         }:
         mkDerivation {
           pname = "hquantlib";
           version = "0.0.5.0";
           sha256 = "868347c32e17d6f9a2aa289412453b0ad9cd71144ddf2dfb6871b599900f23fe";
           isLibrary = true;
           isExecutable = true;
           libraryHaskellDepends = [
             base containers hmatrix hmatrix-gsl hmatrix-special hquantlib-time
             mersenne-random-pure64 parallel random statistics time vector
             vector-algorithms
           ];
           executableHaskellDepends = [
             base containers mersenne-random-pure64 parallel time
           ];
           doHaddock = false;
           doCheck = false;
           homepage = "http://github.com/paulrzcz/hquantlib.git";
           description = "HQuantLib is a port of essencial parts of QuantLib to Haskell";
           license = "LGPL";
         }) {};
      "hquantlib-time" = callPackage
        ({ mkDerivation, base, stdenv, time }:
         mkDerivation {
           pname = "hquantlib-time";
           version = "0.0.4.1";
           sha256 = "ac9ced19f72197fc1bc8b9528c8ae9cf1e8887f2d2ed6519a480b048423d523c";
           libraryHaskellDepends = [ base time ];
           doHaddock = false;
           doCheck = false;
           homepage = "http://github.com/paulrzcz/hquantlib-time.git";
           description = "HQuantLib Time is a business calendar functions extracted from HQuantLib";
           license = "LGPL";
         }) {};
      "hreader" = callPackage
        ({ mkDerivation, base, exceptions, hset, mmorph, monad-control, mtl
         , stdenv, tagged, transformers, transformers-base
         }:
         mkDerivation {
           pname = "hreader";
           version = "1.1.0";
           sha256 = "2a2b02c059b343ab7ff0d340b6545a003b0d563fb8a1ad2d53d6c2f4759a7d3a";
           revision = "1";
           editedCabalFile = "0kz3yzah7m4c2r9yaawhljcgb579masx3lx4mrr4lmqy39kmsvcb";
           libraryHaskellDepends = [
             base exceptions hset mmorph monad-control mtl tagged transformers
             transformers-base
           ];
           doHaddock = false;
           doCheck = false;
           homepage = "https://bitbucket.org/s9gf4ult/hreader";
           description = "Generalization of MonadReader and ReaderT using hset";
           license = stdenv.lib.licenses.bsd3;
         }) {};
      "hreader-lens" = callPackage
        ({ mkDerivation, base, comonad, hreader, hset, lens, lens-action
         , profunctors, stdenv
         }:
         mkDerivation {
           pname = "hreader-lens";
           version = "0.1.3.0";
           sha256 = "408f0a2c6ce4bc5c00746947262f43f421f0e8fb9cc29c0cd2563ee1e87502d0";
           libraryHaskellDepends = [
             base comonad hreader hset lens lens-action profunctors
           ];
           doHaddock = false;
           doCheck = false;
           homepage = "http://github.com/dredozubov/hreader-lens";
           description = "Optics for hreader package";
           license = stdenv.lib.licenses.mit;
         }) {};
      "hruby" = callPackage
        ({ mkDerivation, aeson, attoparsec, base, bytestring, Cabal
         , process, ruby, scientific, stdenv, stm, text
         , unordered-containers, vector
         }:
         mkDerivation {
           pname = "hruby";
           version = "0.3.6";
           sha256 = "dda3b4fb243b612915c8a5c415a95c7d68c0d860901fd01b5d0315b7ccda1519";
           setupHaskellDepends = [ base Cabal process ];
           libraryHaskellDepends = [
             aeson attoparsec base bytestring scientific stm text
             unordered-containers vector
           ];
           librarySystemDepends = [ ruby ];
           doHaddock = false;
           doCheck = false;
           description = "Embed a Ruby intepreter in your Haskell program !";
           license = stdenv.lib.licenses.bsd3;
         }) {inherit (pkgs) ruby;};
      "hs-GeoIP" = callPackage
        ({ mkDerivation, base, bytestring, deepseq, GeoIP, stdenv }:
         mkDerivation {
           pname = "hs-GeoIP";
           version = "0.3";
           sha256 = "8e5ff6a132d8944336f10dcaa69d8852cdd7953a5ff18248ae06cb2819a1ab8c";
           libraryHaskellDepends = [ base bytestring deepseq ];
           librarySystemDepends = [ GeoIP ];
           doHaddock = false;
           doCheck = false;
           homepage = "http://github.com/ozataman/hs-GeoIP";
           description = "Haskell bindings to the MaxMind GeoIPCity database via the C library";
           license = stdenv.lib.licenses.bsd3;
         }) {inherit (pkgs) GeoIP;};
      "hs-bibutils" = callPackage
        ({ mkDerivation, base, stdenv, syb }:
         mkDerivation {
           pname = "hs-bibutils";
           version = "6.6.0.0";
           sha256 = "14b80075b17b9bfa517e42156dafa2e2ca8951413126d27cbe5a5942bff85a58";
           libraryHaskellDepends = [ base syb ];
           doHaddock = false;
           doCheck = false;
           homepage = "https://github.com/wilx/hs-bibutils";
           description = "Haskell bindings to bibutils, the bibliography conversion utilities";
           license = "GPL";
         }) {};
      "hs-functors" = callPackage
        ({ mkDerivation, base, stdenv, transformers }:
         mkDerivation {
           pname = "hs-functors";
           version = "0.1.3.0";
           sha256 = "3312807260f463dc58b26765379114c144be86a94868ab2091812127902eefc8";
           libraryHaskellDepends = [ base transformers ];
           doHaddock = false;
           doCheck = false;
           description = "Functors from products of Haskell and its dual to Haskell";
           license = stdenv.lib.licenses.bsd3;
         }) {};
      "hsass" = callPackage
        ({ mkDerivation, base, bytestring, data-default-class, filepath
         , hlibsass, monad-loops, stdenv, transformers
         }:
         mkDerivation {
           pname = "hsass";
           version = "0.7.0";
           sha256 = "73758e87ba43096c0b3eb9ed7029f30d3a4d602dbe68c97760f89e5165901a57";
           libraryHaskellDepends = [
             base bytestring data-default-class filepath hlibsass monad-loops
             transformers
           ];
           doHaddock = false;
           doCheck = false;
           homepage = "https://github.com/jakubfijalkowski/hsass";
           description = "Integrating Sass into Haskell applications";
           license = stdenv.lib.licenses.mit;
         }) {};
      "hscolour" = callPackage
        ({ mkDerivation, base, containers, stdenv }:
         mkDerivation {
           pname = "hscolour";
           version = "1.24.4";
           sha256 = "243332b082294117f37b2c2c68079fa61af68b36223b3fc07594f245e0e5321d";
           isLibrary = true;
           isExecutable = true;
           enableSeparateDataOutput = true;
           libraryHaskellDepends = [ base containers ];
           executableHaskellDepends = [ base containers ];
           doHaddock = false;
           doCheck = false;
           homepage = "http://code.haskell.org/~malcolm/hscolour/";
           description = "Colourise Haskell code";
           license = "LGPL";
         }) {};
      "hsdns" = callPackage
        ({ mkDerivation, adns, base, containers, network, stdenv }:
         mkDerivation {
           pname = "hsdns";
           version = "1.7.1";
           sha256 = "4fcd00e85cde989652ab5c6b179610c9514180a00cd7b161ea33ebfec3b8a044";
           revision = "1";
           editedCabalFile = "0w4hrmj7ph5dgarl82xpa0g77ncjdqk0wc9wp771pry98xxihzl8";
           isLibrary = true;
           isExecutable = true;
           libraryHaskellDepends = [ base containers network ];
           librarySystemDepends = [ adns ];
           doHaddock = false;
           doCheck = false;
           homepage = "http://github.com/peti/hsdns";
           description = "Asynchronous DNS Resolver";
           license = stdenv.lib.licenses.lgpl3;
         }) {inherit (pkgs) adns;};
      "hsebaysdk" = callPackage
        ({ mkDerivation, aeson, base, bytestring, http-client, http-types
         , stdenv, text, time, transformers, unordered-containers
         }:
         mkDerivation {
           pname = "hsebaysdk";
           version = "0.4.0.0";
           sha256 = "0738d0df113b15bb9148ecbe02f0a34562c557d8f64b65065122925e29df8901";
           libraryHaskellDepends = [
             aeson base bytestring http-client http-types text time transformers
             unordered-containers
           ];
           doHaddock = false;
           doCheck = false;
           homepage = "https://github.com/creichert/hsebaysdk";
           description = "Haskell eBay SDK";
           license = stdenv.lib.licenses.bsd3;
         }) {};
      "hsemail" = callPackage
        ({ mkDerivation, base, mtl, old-time, parsec, stdenv }:
         mkDerivation {
           pname = "hsemail";
           version = "2";
           sha256 = "f5f08a879444abd1f9a8a3e620d7fc83bc632ae3ba9b545bebdf58d5f4bfa8d9";
           libraryHaskellDepends = [ base mtl old-time parsec ];
           doHaddock = false;
           doCheck = false;
           homepage = "https://github.com/peti/hsemail#readme";
           description = "Parsec parsers for the RFC2822 Internet Message format";
           license = stdenv.lib.licenses.bsd3;
         }) {};
      "hset" = callPackage
        ({ mkDerivation, base, deepseq, stdenv, tagged, type-fun }:
         mkDerivation {
           pname = "hset";
           version = "2.2.0";
           sha256 = "b8747a0826aeaca2ca814e7a334f9de5a02f36ac83faea5e1c32c8f6040bf130";
           libraryHaskellDepends = [ base deepseq tagged type-fun ];
           doHaddock = false;
           doCheck = false;
           homepage = "https://bitbucket.org/s9gf4ult/hset";
           description = "Primitive list with elements of unique types";
           license = stdenv.lib.licenses.bsd3;
         }) {};
      "hsexif" = callPackage
        ({ mkDerivation, base, binary, bytestring, containers, iconv
         , stdenv, text, time
         }:
         mkDerivation {
           pname = "hsexif";
           version = "0.6.1.6";
           sha256 = "0f7e14cdec698c4e8e17ec84971ca5a604c9e75a861806dbf7088cdfc706b55d";
           revision = "1";
           editedCabalFile = "1dgcgsmx0k5p3ibfv3n5k0c5p1is2m5zfsd2s6nc6d0pz34d4wl9";
           libraryHaskellDepends = [
             base binary bytestring containers iconv text time
           ];
           doHaddock = false;
           doCheck = false;
           homepage = "https://github.com/emmanueltouzery/hsexif";
           description = "EXIF handling library in pure Haskell";
           license = stdenv.lib.licenses.bsd3;
         }) {};
      "hsini" = callPackage
        ({ mkDerivation, base, bytestring, containers, mtl, parsec, stdenv
         }:
         mkDerivation {
           pname = "hsini";
           version = "0.5.1.2";
           sha256 = "eaa6ae68c6271d5c3187054e702719b3ee7916524ffda27bb328cc9aad9ed8e4";
           revision = "1";
           editedCabalFile = "0wkvajjgs64l4wlw8s6sn3pbwx3ni41p1260chp67a16innr1qp6";
           libraryHaskellDepends = [ base bytestring containers mtl parsec ];
           doHaddock = false;
           doCheck = false;
           description = "ini configuration files";
           license = stdenv.lib.licenses.bsd3;
         }) {};
      "hsinstall" = callPackage
        ({ mkDerivation, base, directory, filepath, stdenv }:
         mkDerivation {
           pname = "hsinstall";
           version = "1.6";
           sha256 = "061090c68bdcdad5efef879c4fc0e4c67c26d34221c333fe4c9880216635c811";
           isLibrary = true;
           isExecutable = true;
           enableSeparateDataOutput = true;
           libraryHaskellDepends = [ base directory filepath ];
           executableHaskellDepends = [ base directory filepath ];
           doHaddock = false;
           doCheck = false;
           description = "Install Haskell software";
           license = stdenv.lib.licenses.isc;
         }) {};
      "hslogger" = callPackage
        ({ mkDerivation, base, containers, directory, mtl, network
         , old-locale, process, stdenv, time, unix
         }:
         mkDerivation {
           pname = "hslogger";
           version = "1.2.12";
           sha256 = "f97a4c89d0921f237999de5d44950127dbe8baa177960ccccbfb79cccfd46c7a";
           revision = "1";
           editedCabalFile = "1rk2lrg3959nbgbyd1aacvwbv865lsrnczqdmj4ivkfn0c8nkidh";
           libraryHaskellDepends = [
             base containers directory mtl network old-locale process time unix
           ];
           doHaddock = false;
           doCheck = false;
           homepage = "http://software.complete.org/hslogger";
           description = "Versatile logging framework";
           license = stdenv.lib.licenses.bsd3;
         }) {};
      "hslua" = callPackage
        ({ mkDerivation, base, bytestring, containers, exceptions, fail
         , lua5_3, mtl, stdenv, text
         }:
         mkDerivation {
           pname = "hslua";
           version = "0.9.5.2";
           sha256 = "0e4d26f8a76cbfb219851f33d31417c4a3c8f193123367a0749f047103d8bbe5";
           configureFlags = [ "-fsystem-lua" "-f-use-pkgconfig" ];
           libraryHaskellDepends = [
             base bytestring containers exceptions fail mtl text
           ];
           librarySystemDepends = [ lua5_3 ];
           doHaddock = false;
           doCheck = false;
           description = "A Lua language interpreter embedding in Haskell";
           license = stdenv.lib.licenses.mit;
         }) {inherit (pkgs) lua5_3;};
      "hslua-aeson" = callPackage
        ({ mkDerivation, aeson, base, hashable, hslua, scientific, stdenv
         , text, unordered-containers, vector
         }:
         mkDerivation {
           pname = "hslua-aeson";
           version = "0.3.0.2";
           sha256 = "a22acf0984e7d78955ce76f75e7660f84d50b6b59fc70357d01ccbf2bbc0d861";
           libraryHaskellDepends = [
             aeson base hashable hslua scientific text unordered-containers
             vector
           ];
           doHaddock = false;
           doCheck = false;
           homepage = "https://github.com/tarleb/hslua-aeson#readme";
           description = "Allow aeson data types to be used with lua";
           license = stdenv.lib.licenses.mit;
         }) {};
      "hslua-module-text" = callPackage
        ({ mkDerivation, base, hslua, stdenv, text }:
         mkDerivation {
           pname = "hslua-module-text";
           version = "0.1.2.1";
           sha256 = "aeb384f9743b76360f3779e44065fe297fb60f27519933f203b75bd8c2ba8e2d";
           revision = "1";
           editedCabalFile = "0vajlsd7y6pwa08635q0cx8z5c1c55bk7fvavw7g2vmyvxqjzx6n";
           libraryHaskellDepends = [ base hslua text ];
           doHaddock = false;
           doCheck = false;
           homepage = "https://github.com/hslua/hslua-module-test";
           description = "Lua module for text";
           license = stdenv.lib.licenses.mit;
         }) {};
      "hsp" = callPackage
        ({ mkDerivation, base, mtl, stdenv, text }:
         mkDerivation {
           pname = "hsp";
           version = "0.10.0";
           sha256 = "4ed3905a9db91001bde09f060290833af462e87e35476ab0def1579a1ff7ceab";
           libraryHaskellDepends = [ base mtl text ];
           doHaddock = false;
           doCheck = false;
           homepage = "http://hub.darcs.net/nibro/hsp";
           description = "Haskell Server Pages is a library for writing dynamic server-side web pages";
           license = stdenv.lib.licenses.bsd3;
         }) {};
      "hspec" = callPackage
        ({ mkDerivation, base, call-stack, hspec-core, hspec-discover
         , hspec-expectations, HUnit, QuickCheck, stdenv, transformers
         }:
         mkDerivation {
           pname = "hspec";
           version = "2.5.5";
           sha256 = "d5d5b8bc342a3782e950652bc78fae1c09ac0f2a4848c507162fce59569964fb";
           libraryHaskellDepends = [
             base call-stack hspec-core hspec-discover hspec-expectations HUnit
             QuickCheck transformers
           ];
           doHaddock = false;
           doCheck = false;
           homepage = "http://hspec.github.io/";
           description = "A Testing Framework for Haskell";
           license = stdenv.lib.licenses.mit;
         }) {};
      "hspec-attoparsec" = callPackage
        ({ mkDerivation, attoparsec, base, bytestring, hspec-expectations
         , stdenv, text
         }:
         mkDerivation {
           pname = "hspec-attoparsec";
           version = "0.1.0.2";
           sha256 = "ea7a8b3f2989abde8c8537cec1a2ae312e88df80086b9b01ed12e5324137fb64";
           libraryHaskellDepends = [
             attoparsec base bytestring hspec-expectations text
           ];
           doHaddock = false;
           doCheck = false;
           homepage = "http://github.com/alpmestan/hspec-attoparsec";
           description = "Utility functions for testing your attoparsec parsers with hspec";
           license = stdenv.lib.licenses.bsd3;
         }) {};
      "hspec-checkers" = callPackage
        ({ mkDerivation, base, checkers, hspec, stdenv }:
         mkDerivation {
           pname = "hspec-checkers";
           version = "0.1.0.2";
           sha256 = "e7db79dc527cf5b806723bbe3d511a074297976a0c7042968b9abc57f8337e99";
           libraryHaskellDepends = [ base checkers hspec ];
           doHaddock = false;
           doCheck = false;
           description = "Allows to use checkers properties from hspec";
           license = stdenv.lib.licenses.bsd3;
         }) {};
      "hspec-contrib" = callPackage
        ({ mkDerivation, base, hspec-core, HUnit, stdenv }:
         mkDerivation {
           pname = "hspec-contrib";
           version = "0.5.0";
           sha256 = "dba7348e75572f7cd79f3f0719ab39973431927f9bb5bec1445e2f8e5b4fa78c";
           libraryHaskellDepends = [ base hspec-core HUnit ];
           doHaddock = false;
           doCheck = false;
           homepage = "http://hspec.github.io/";
           description = "Contributed functionality for Hspec";
           license = stdenv.lib.licenses.mit;
         }) {};
      "hspec-core" = callPackage
        ({ mkDerivation, ansi-terminal, array, base, call-stack, clock
         , deepseq, directory, filepath, hspec-expectations, HUnit
         , QuickCheck, quickcheck-io, random, setenv, stdenv, stm, tf-random
         , transformers
         }:
         mkDerivation {
           pname = "hspec-core";
           version = "2.5.5";
           sha256 = "bd947f39c90a1dfeb943ee02c1edf7a6dcd26cb6abcf3a7de4498b612fc5d9ed";
           revision = "1";
           editedCabalFile = "1fifkdjhzrvwsx27qcsj0jam66sswjas5vfrzmb75z0xqyg5lpr7";
           libraryHaskellDepends = [
             ansi-terminal array base call-stack clock deepseq directory
             filepath hspec-expectations HUnit QuickCheck quickcheck-io random
             setenv stm tf-random transformers
           ];
           doHaddock = false;
           doCheck = false;
           testTarget = "--test-option=--skip --test-option='Test.Hspec.Core.Runner.hspecResult runs specs in parallel'";
           homepage = "http://hspec.github.io/";
           description = "A Testing Framework for Haskell";
           license = stdenv.lib.licenses.mit;
         }) {};
      "hspec-discover" = callPackage
        ({ mkDerivation, base, directory, filepath, stdenv }:
         mkDerivation {
           pname = "hspec-discover";
           version = "2.5.5";
           sha256 = "dfe177b2c19d32d16dfc44e2cd11dce993f1a1fe72bafafc4a99b190e26f5111";
           isLibrary = true;
           isExecutable = true;
           libraryHaskellDepends = [ base directory filepath ];
           executableHaskellDepends = [ base directory filepath ];
           doHaddock = false;
           doCheck = false;
           homepage = "http://hspec.github.io/";
           description = "Automatically discover and run Hspec tests";
           license = stdenv.lib.licenses.mit;
         }) {};
      "hspec-expectations" = callPackage
        ({ mkDerivation, base, call-stack, HUnit, stdenv }:
         mkDerivation {
           pname = "hspec-expectations";
           version = "0.8.2";
           sha256 = "819607ea1faf35ce5be34be61c6f50f3389ea43892d56fb28c57a9f5d54fb4ef";
           libraryHaskellDepends = [ base call-stack HUnit ];
           doHaddock = false;
           doCheck = false;
           homepage = "https://github.com/hspec/hspec-expectations#readme";
           description = "Catchy combinators for HUnit";
           license = stdenv.lib.licenses.mit;
         }) {};
      "hspec-expectations-lifted" = callPackage
        ({ mkDerivation, base, hspec-expectations, stdenv, transformers }:
         mkDerivation {
           pname = "hspec-expectations-lifted";
           version = "0.10.0";
           sha256 = "22cdf1509b396fea2f53a0bb88dec3552f540d58cc60962a82970264c1e73828";
           libraryHaskellDepends = [ base hspec-expectations transformers ];
           doHaddock = false;
           doCheck = false;
           description = "A version of hspec-expectations generalized to MonadIO";
           license = stdenv.lib.licenses.mit;
         }) {};
      "hspec-expectations-pretty-diff" = callPackage
        ({ mkDerivation, ansi-terminal, base, Diff, hscolour, HUnit
         , nicify-lib, stdenv, text
         }:
         mkDerivation {
           pname = "hspec-expectations-pretty-diff";
           version = "0.7.2.4";
           sha256 = "1bbfd524330be3cb0b27945556d01f48e3005e042ee475cdf6e441ba21b51b0a";
           libraryHaskellDepends = [
             ansi-terminal base Diff hscolour HUnit nicify-lib text
           ];
           doHaddock = false;
           doCheck = false;
           homepage = "https://github.com/myfreeweb/hspec-expectations-pretty-diff#readme";
           description = "Catchy combinators for HUnit";
           license = stdenv.lib.licenses.mit;
         }) {};
      "hspec-golden-aeson" = callPackage
        ({ mkDerivation, aeson, aeson-pretty, base, bytestring, directory
         , filepath, hspec, QuickCheck, quickcheck-arbitrary-adt, random
         , stdenv, transformers
         }:
         mkDerivation {
           pname = "hspec-golden-aeson";
           version = "0.7.0.0";
           sha256 = "114ccdbe3b7425f6bacc7d0d78d160879528aa76d2a3e774d9c152d8444a4ca2";
           libraryHaskellDepends = [
             aeson aeson-pretty base bytestring directory filepath hspec
             QuickCheck quickcheck-arbitrary-adt random transformers
           ];
           doHaddock = false;
           doCheck = false;
           homepage = "https://github.com/plow-technologies/hspec-golden-aeson#readme";
           description = "Use tests to monitor changes in Aeson serialization";
           license = stdenv.lib.licenses.bsd3;
         }) {};
      "hspec-megaparsec" = callPackage
        ({ mkDerivation, base, containers, hspec-expectations, megaparsec
         , stdenv
         }:
         mkDerivation {
           pname = "hspec-megaparsec";
           version = "1.0.0";
           sha256 = "14961ae19fde7104f5099624195d0f21b4759e5e635e79d9e63f9f2affca4eb5";
           libraryHaskellDepends = [
             base containers hspec-expectations megaparsec
           ];
           doHaddock = false;
           doCheck = false;
           homepage = "https://github.com/mrkkrp/hspec-megaparsec";
           description = "Utility functions for testing Megaparsec parsers with Hspec";
           license = stdenv.lib.licenses.bsd3;
         }) {};
      "hspec-meta" = callPackage
        ({ mkDerivation, ansi-terminal, array, async, base, call-stack
         , deepseq, directory, filepath, hspec-expectations, HUnit
         , QuickCheck, quickcheck-io, random, setenv, stdenv, time
         , transformers
         }:
         mkDerivation {
           pname = "hspec-meta";
           version = "2.4.6";
           sha256 = "2b31671bfbfe5df0604516278bb1051db42b1e55dfe474ecd446a6630398bb62";
           isLibrary = true;
           isExecutable = true;
           libraryHaskellDepends = [
             ansi-terminal array async base call-stack deepseq directory
             filepath hspec-expectations HUnit QuickCheck quickcheck-io random
             setenv time transformers
           ];
           executableHaskellDepends = [
             ansi-terminal array async base call-stack deepseq directory
             filepath hspec-expectations HUnit QuickCheck quickcheck-io random
             setenv time transformers
           ];
           doHaddock = false;
           doCheck = false;
           homepage = "http://hspec.github.io/";
           description = "A version of Hspec which is used to test Hspec itself";
           license = stdenv.lib.licenses.mit;
         }) {};
      "hspec-pg-transact" = callPackage
        ({ mkDerivation, base, bytestring, hspec, pg-transact
         , postgresql-simple, resource-pool, stdenv, text, tmp-postgres
         }:
         mkDerivation {
           pname = "hspec-pg-transact";
           version = "0.1.0.2";
           sha256 = "a5ec2a978a730500f03c15d16eff7e207a4135ebc63afe4cbca7392ad5f01c0c";
           libraryHaskellDepends = [
             base bytestring hspec pg-transact postgresql-simple resource-pool
             text tmp-postgres
           ];
           doHaddock = false;
           doCheck = false;
           homepage = "https://github.com/jfischoff/pg-transact-hspec#readme";
           description = "Helpers for creating database tests with hspec and pg-transact";
           license = stdenv.lib.licenses.bsd3;
         }) {};
      "hspec-smallcheck" = callPackage
        ({ mkDerivation, base, call-stack, hspec-core, HUnit, smallcheck
         , stdenv
         }:
         mkDerivation {
           pname = "hspec-smallcheck";
           version = "0.5.2";
           sha256 = "9a301a26a439a92b303217545b65792bd8500f25aeccbe48e46dfe914ef58119";
           libraryHaskellDepends = [
             base call-stack hspec-core HUnit smallcheck
           ];
           doHaddock = false;
           doCheck = false;
           homepage = "http://hspec.github.io/";
           description = "SmallCheck support for the Hspec testing framework";
           license = stdenv.lib.licenses.mit;
         }) {};
      "hspec-wai" = callPackage
        ({ mkDerivation, base, base-compat, bytestring, case-insensitive
         , hspec-core, hspec-expectations, http-types, QuickCheck, stdenv
         , text, transformers, wai, wai-extra
         }:
         mkDerivation {
           pname = "hspec-wai";
           version = "0.9.2";
           sha256 = "055e414bd6531d3454496f9c4bfa1164b861aa9a9102867d7ffeef8d3a92283f";
           libraryHaskellDepends = [
             base base-compat bytestring case-insensitive hspec-core
             hspec-expectations http-types QuickCheck text transformers wai
             wai-extra
           ];
           doHaddock = false;
           doCheck = false;
           homepage = "https://github.com/hspec/hspec-wai#readme";
           description = "Experimental Hspec support for testing WAI applications";
           license = stdenv.lib.licenses.mit;
         }) {};
      "hspec-wai-json" = callPackage
        ({ mkDerivation, aeson, aeson-qq, base, bytestring
         , case-insensitive, hspec-wai, stdenv, template-haskell
         }:
         mkDerivation {
           pname = "hspec-wai-json";
           version = "0.9.2";
           sha256 = "82e324482e04662121a14fc75232e7359d6d1454623c37253b6550a8ec6ccadc";
           libraryHaskellDepends = [
             aeson aeson-qq base bytestring case-insensitive hspec-wai
             template-haskell
           ];
           doHaddock = false;
           doCheck = false;
           homepage = "https://github.com/hspec/hspec-wai#readme";
           description = "Testing JSON APIs with hspec-wai";
           license = stdenv.lib.licenses.mit;
         }) {};
      "hstatsd" = callPackage
        ({ mkDerivation, base, bytestring, mtl, network, stdenv, text }:
         mkDerivation {
           pname = "hstatsd";
           version = "0.1";
           sha256 = "446779594257c0fa02d5271c997ee0c22f74f7636d89e34394ad87e5bd285824";
           libraryHaskellDepends = [ base bytestring mtl network text ];
           doHaddock = false;
           doCheck = false;
           homepage = "https://github.com/mokus0/hstatsd";
           description = "Quick and dirty statsd interface";
           license = stdenv.lib.licenses.publicDomain;
         }) {};
      "hsx-jmacro" = callPackage
        ({ mkDerivation, base, hsp, jmacro, mtl, stdenv, text
         , wl-pprint-text
         }:
         mkDerivation {
           pname = "hsx-jmacro";
           version = "7.3.8.1";
           sha256 = "f1903d80017381408ae3f7b9d7b2e4d8c193d72ede96a33ce68fe7e276f1af59";
           libraryHaskellDepends = [
             base hsp jmacro mtl text wl-pprint-text
           ];
           doHaddock = false;
           doCheck = false;
           homepage = "http://www.happstack.com/";
           description = "hsp+jmacro support";
           license = stdenv.lib.licenses.bsd3;
         }) {};
      "hsyslog" = callPackage
        ({ mkDerivation, base, Cabal, cabal-doctest, stdenv }:
         mkDerivation {
           pname = "hsyslog";
           version = "5.0.1";
           sha256 = "86de0d8820a6cb7fe166e046ae00c1bbe37d27885cd3aa701deaca8fdf646016";
           isLibrary = true;
           isExecutable = true;
           setupHaskellDepends = [ base Cabal cabal-doctest ];
           libraryHaskellDepends = [ base ];
           doHaddock = false;
           doCheck = false;
           homepage = "http://github.com/peti/hsyslog";
           description = "FFI interface to syslog(3) from POSIX.1-2001";
           license = stdenv.lib.licenses.bsd3;
         }) {};
      "hsyslog-udp" = callPackage
        ({ mkDerivation, base, bytestring, hsyslog, network, stdenv, text
         , time, unix
         }:
         mkDerivation {
           pname = "hsyslog-udp";
           version = "0.2.4";
           sha256 = "0615fd8f2c53db9112f1aeb3899d227b17af035c8db7899cb289c69021eb50f5";
           libraryHaskellDepends = [
             base bytestring hsyslog network text time unix
           ];
           doHaddock = false;
           doCheck = false;
           homepage = "https://github.com/ThoughtLeadr/hsyslog-udp";
           description = "Log to syslog over a network via UDP";
           license = stdenv.lib.licenses.bsd3;
         }) {};
      "htaglib" = callPackage
        ({ mkDerivation, base, bytestring, stdenv, taglib, text
         , transformers
         }:
         mkDerivation {
           pname = "htaglib";
           version = "1.2.0";
           sha256 = "4a17c36ff45995c079d71368a3eeabe595ed7efe2b3e4a3dcbff4bed8324005e";
           enableSeparateDataOutput = true;
           libraryHaskellDepends = [ base bytestring text transformers ];
           librarySystemDepends = [ taglib ];
           doHaddock = false;
           doCheck = false;
           homepage = "https://github.com/mrkkrp/htaglib";
           description = "Bindings to TagLib, audio meta-data library";
           license = stdenv.lib.licenses.bsd3;
         }) {inherit (pkgs) taglib;};
      "html" = callPackage
        ({ mkDerivation, base, stdenv }:
         mkDerivation {
           pname = "html";
           version = "1.0.1.2";
           sha256 = "0c35495ea33d65e69c69bc7441ec8e1af69fbb43433c2aa3406c0a13a3ab3061";
           libraryHaskellDepends = [ base ];
           doHaddock = false;
           doCheck = false;
           description = "HTML combinator library";
           license = stdenv.lib.licenses.bsd3;
         }) {};
      "html-conduit" = callPackage
        ({ mkDerivation, attoparsec, base, bytestring, conduit
         , conduit-extra, containers, resourcet, stdenv, text, transformers
         , xml-conduit, xml-types
         }:
         mkDerivation {
           pname = "html-conduit";
           version = "1.3.2";
           sha256 = "05fdbdbf9d7b610bd8d7a67e0036b52b1ec1aec276f3017194e59ee2d661b050";
           libraryHaskellDepends = [
             attoparsec base bytestring conduit conduit-extra containers
             resourcet text transformers xml-conduit xml-types
           ];
           doHaddock = false;
           doCheck = false;
           homepage = "https://github.com/snoyberg/xml";
           description = "Parse HTML documents using xml-conduit datatypes";
           license = stdenv.lib.licenses.mit;
         }) {};
      "html-email-validate" = callPackage
        ({ mkDerivation, attoparsec, base, stdenv, text }:
         mkDerivation {
           pname = "html-email-validate";
           version = "0.2.0.0";
           sha256 = "3d2a3ec75b638cec71df57512473052d485dc118aec4662d5a8dae5e95aa6daf";
           libraryHaskellDepends = [ attoparsec base text ];
           doHaddock = false;
           doCheck = false;
           description = "Validating an email address against HTML standard";
           license = stdenv.lib.licenses.bsd3;
         }) {};
      "html-entities" = callPackage
        ({ mkDerivation, attoparsec, base, base-prelude, stdenv, text
         , unordered-containers
         }:
         mkDerivation {
           pname = "html-entities";
           version = "1.1.4.2";
           sha256 = "161a0c9193b4c1279e41b2ce1203ee821e8d6ee2cf755b9f070d68602ed5cee7";
           libraryHaskellDepends = [
             attoparsec base base-prelude text unordered-containers
           ];
           doHaddock = false;
           doCheck = false;
           homepage = "https://github.com/nikita-volkov/html-entities";
           description = "A codec library for HTML-escaped text and HTML-entities";
           license = stdenv.lib.licenses.mit;
         }) {};
      "html-entity-map" = callPackage
        ({ mkDerivation, base, stdenv, text, unordered-containers }:
         mkDerivation {
           pname = "html-entity-map";
           version = "0.1.0.0";
           sha256 = "983600c33e8515e6ca31742d25490fb5a7be02503331963621b0ba5cd70d344c";
           revision = "3";
           editedCabalFile = "0aj61kpf39rhn4d7nk3vwq933b826ywhwklw479y9nkczac5lpz8";
           libraryHaskellDepends = [ base text unordered-containers ];
           doHaddock = false;
           doCheck = false;
           homepage = "https://github.com/mrkkrp/html-entity-map";
           description = "Map from HTML5 entity names to the corresponding Unicode text";
           license = stdenv.lib.licenses.bsd3;
         }) {};
      "htoml" = callPackage
        ({ mkDerivation, aeson, base, containers, old-locale, parsec
         , stdenv, text, time, unordered-containers, vector
         }:
         mkDerivation {
           pname = "htoml";
           version = "1.0.0.3";
           sha256 = "08f8d88a326f80fb55c0abb9431941c3a2a30f2d58f49c94349961ceeb4c856f";
           libraryHaskellDepends = [
             aeson base containers old-locale parsec text time
             unordered-containers vector
           ];
           doHaddock = false;
           doCheck = false;
           homepage = "https://github.com/cies/htoml";
           description = "Parser for TOML files";
           license = stdenv.lib.licenses.bsd3;
         }) {};
      "http-api-data" = callPackage
        ({ mkDerivation, attoparsec, attoparsec-iso8601, base, bytestring
         , Cabal, cabal-doctest, containers, hashable, http-types, stdenv
         , text, time, time-locale-compat, unordered-containers
         , uri-bytestring, uuid-types
         }:
         mkDerivation {
           pname = "http-api-data";
           version = "0.3.8.1";
           sha256 = "6eeaba4b29a00407cb20b865825b17b8d884c26b09c5bbe7b6e673b4522106b3";
           revision = "1";
           editedCabalFile = "1843bapm2rdkl4941rycryircpqpp7mbal7vgmlikf11f8ws7y7x";
           setupHaskellDepends = [ base Cabal cabal-doctest ];
           libraryHaskellDepends = [
             attoparsec attoparsec-iso8601 base bytestring containers hashable
             http-types text time time-locale-compat unordered-containers
             uri-bytestring uuid-types
           ];
           doHaddock = false;
           doCheck = false;
           homepage = "http://github.com/fizruk/http-api-data";
           description = "Converting to/from HTTP API data like URL pieces, headers and query parameters";
           license = stdenv.lib.licenses.bsd3;
         }) {};
      "http-client" = callPackage
        ({ mkDerivation, array, base, blaze-builder, bytestring
         , case-insensitive, containers, cookie, deepseq, exceptions
         , filepath, ghc-prim, http-types, memory, mime-types, network
         , network-uri, random, stdenv, stm, streaming-commons, text, time
         , transformers
         }:
         mkDerivation {
           pname = "http-client";
           version = "0.5.14";
           sha256 = "8e50409704021c51a8955b2d03bfec900ebc3e11fbaebf973f2e654d7bde3647";
           revision = "1";
           editedCabalFile = "0xw5ac4cvcd4hcwl7j12adi7sgffjryqhk0x992k3qs1cxyv5028";
           libraryHaskellDepends = [
             array base blaze-builder bytestring case-insensitive containers
             cookie deepseq exceptions filepath ghc-prim http-types memory
             mime-types network network-uri random stm streaming-commons text
             time transformers
           ];
           doHaddock = false;
           doCheck = false;
           homepage = "https://github.com/snoyberg/http-client";
           description = "An HTTP client engine";
           license = stdenv.lib.licenses.mit;
         }) {};
      "http-client-openssl" = callPackage
        ({ mkDerivation, base, HsOpenSSL, http-client, network, stdenv }:
         mkDerivation {
           pname = "http-client-openssl";
           version = "0.2.2.0";
           sha256 = "96410d977b70f25208d74ffc31ee00ceab4aa970347ef4f8d5757246c61210aa";
           revision = "1";
           editedCabalFile = "0l2a036ypx1kyfr99fggnrb1kv6x8mp53pxzklka2ccggvl6khx3";
           libraryHaskellDepends = [ base HsOpenSSL http-client network ];
           doHaddock = false;
           doCheck = false;
           homepage = "https://github.com/snoyberg/http-client";
           description = "http-client backend using the OpenSSL library";
           license = stdenv.lib.licenses.mit;
         }) {};
      "http-client-tls" = callPackage
        ({ mkDerivation, base, bytestring, case-insensitive, connection
         , containers, cryptonite, data-default-class, exceptions
         , http-client, http-types, memory, network, network-uri, stdenv
         , text, tls, transformers
         }:
         mkDerivation {
           pname = "http-client-tls";
           version = "0.3.5.3";
           sha256 = "471abf8f29a909f40b21eab26a410c0e120ae12ce337512a61dae9f52ebb4362";
           revision = "1";
           editedCabalFile = "0llb5k8mz1h6zyv1nd433wwgyjsw7n8x0b1fwib312iiws43sz69";
           libraryHaskellDepends = [
             base bytestring case-insensitive connection containers cryptonite
             data-default-class exceptions http-client http-types memory network
             network-uri text tls transformers
           ];
           doHaddock = false;
           doCheck = false;
           homepage = "https://github.com/snoyberg/http-client";
           description = "http-client backend using the connection package and tls library";
           license = stdenv.lib.licenses.mit;
         }) {};
      "http-common" = callPackage
        ({ mkDerivation, base, base64-bytestring, blaze-builder, bytestring
         , case-insensitive, directory, mtl, network, stdenv, text
         , transformers, unordered-containers
         }:
         mkDerivation {
           pname = "http-common";
           version = "0.8.2.0";
           sha256 = "2915e77b0d000a617d4c1304fdc46f45b70acc0942670066a95b2c8d4e504593";
           libraryHaskellDepends = [
             base base64-bytestring blaze-builder bytestring case-insensitive
             directory mtl network text transformers unordered-containers
           ];
           doHaddock = false;
           doCheck = false;
           homepage = "http://research.operationaldynamics.com/projects/http-streams/";
           description = "Common types for HTTP clients and servers";
           license = stdenv.lib.licenses.bsd3;
         }) {};
      "http-conduit" = callPackage
        ({ mkDerivation, aeson, base, bytestring, conduit, conduit-extra
         , http-client, http-client-tls, http-types, mtl, resourcet, stdenv
         , transformers, unliftio-core
         }:
         mkDerivation {
           pname = "http-conduit";
           version = "2.3.2";
           sha256 = "7596448325d8b3ad31b2100fe6ba4a3447a470a461cfb7fbcc0bc90a32245ec5";
           revision = "1";
           editedCabalFile = "0g6rg8r33q5rmrx5287vjfcqwjacchgzyfc8aqqrhrfz3fq5ll0g";
           libraryHaskellDepends = [
             aeson base bytestring conduit conduit-extra http-client
             http-client-tls http-types mtl resourcet transformers unliftio-core
           ];
           doHaddock = false;
           doCheck = false;
           homepage = "http://www.yesodweb.com/book/http-conduit";
           description = "HTTP client package with conduit interface and HTTPS support";
           license = stdenv.lib.licenses.bsd3;
         }) {};
      "http-date" = callPackage
        ({ mkDerivation, array, attoparsec, base, bytestring, stdenv, time
         }:
         mkDerivation {
           pname = "http-date";
           version = "0.0.8";
           sha256 = "0f4c6348487abe4f9d58e43d3c23bdefc7fd1fd5672effd3c7d84aaff05f5427";
           libraryHaskellDepends = [ array attoparsec base bytestring time ];
           doHaddock = false;
           doCheck = false;
           description = "HTTP Date parser/formatter";
           license = stdenv.lib.licenses.bsd3;
         }) {};
      "http-link-header" = callPackage
        ({ mkDerivation, attoparsec, base, bytestring
         , bytestring-conversion, errors, http-api-data, network-uri, stdenv
         , text
         }:
         mkDerivation {
           pname = "http-link-header";
           version = "1.0.3.1";
           sha256 = "da26db73df1eaebb20df2837b0352cc62a6c151d467bea9442767fd3d51c2a2d";
           libraryHaskellDepends = [
             attoparsec base bytestring bytestring-conversion errors
             http-api-data network-uri text
           ];
           doHaddock = false;
           doCheck = false;
           homepage = "https://github.com/myfreeweb/http-link-header";
           description = "A parser and writer for the HTTP Link header as specified in RFC 5988 \"Web Linking\"";
           license = stdenv.lib.licenses.publicDomain;
         }) {};
      "http-media" = callPackage
        ({ mkDerivation, base, bytestring, case-insensitive, containers
         , stdenv, utf8-string
         }:
         mkDerivation {
           pname = "http-media";
           version = "0.7.1.3";
           sha256 = "394ffcfb4f655721d5965870bf9861c324c14d40ed4dc173e926235fe0fe124f";
           revision = "1";
           editedCabalFile = "19py5pspx80gg679p9dzqr3iidflppxc1x4vkldamjkidyi406j8";
           libraryHaskellDepends = [
             base bytestring case-insensitive containers utf8-string
           ];
           doHaddock = false;
           doCheck = false;
           homepage = "https://github.com/zmthy/http-media";
           description = "Processing HTTP Content-Type and Accept headers";
           license = stdenv.lib.licenses.mit;
         }) {};
      "http-reverse-proxy" = callPackage
        ({ mkDerivation, base, blaze-builder, bytestring, case-insensitive
         , conduit, conduit-extra, containers, http-client, http-types
         , network, resourcet, stdenv, streaming-commons, text, transformers
         , unliftio, wai, wai-logger, word8
         }:
         mkDerivation {
           pname = "http-reverse-proxy";
           version = "0.6.0";
           sha256 = "fb1c913111478384c4f23647810b8c3c01c79e9276a08a1ea46215e4a42dd1a8";
           libraryHaskellDepends = [
             base blaze-builder bytestring case-insensitive conduit
             conduit-extra containers http-client http-types network resourcet
             streaming-commons text transformers unliftio wai wai-logger word8
           ];
           doHaddock = false;
           doCheck = false;
           homepage = "https://github.com/fpco/http-reverse-proxy";
           description = "Reverse proxy HTTP requests, either over raw sockets or with WAI";
           license = stdenv.lib.licenses.bsd3;
         }) {};
      "http-streams" = callPackage
        ({ mkDerivation, aeson, attoparsec, base, base64-bytestring
         , blaze-builder, bytestring, Cabal, case-insensitive, directory
         , HsOpenSSL, http-common, io-streams, mtl, network, network-uri
         , openssl-streams, stdenv, text, transformers, unordered-containers
         }:
         mkDerivation {
           pname = "http-streams";
           version = "0.8.6.1";
           sha256 = "b8d71f2753ac7cda35b4f03ec64e4b3c7cc4ec5c2435b5e5237fe863cb687da3";
           setupHaskellDepends = [ base Cabal ];
           libraryHaskellDepends = [
             aeson attoparsec base base64-bytestring blaze-builder bytestring
             case-insensitive directory HsOpenSSL http-common io-streams mtl
             network network-uri openssl-streams text transformers
             unordered-containers
           ];
           doHaddock = false;
           doCheck = false;
           homepage = "https://github.com/afcowie/http-streams/";
           description = "An HTTP client using io-streams";
           license = stdenv.lib.licenses.bsd3;
         }) {};
      "http-types" = callPackage
        ({ mkDerivation, array, base, bytestring, case-insensitive, stdenv
         , text
         }:
         mkDerivation {
           pname = "http-types";
           version = "0.12.2";
           sha256 = "523102d7ba8923e1b399cfd2a1c821e858146ecd934fc147c3acd0fd2b2f9305";
           libraryHaskellDepends = [
             array base bytestring case-insensitive text
           ];
           doHaddock = false;
           doCheck = false;
           homepage = "https://github.com/aristidb/http-types";
           description = "Generic HTTP types for Haskell (for both client and server code)";
           license = stdenv.lib.licenses.bsd3;
         }) {};
      "http2" = callPackage
        ({ mkDerivation, array, base, bytestring, case-insensitive
         , containers, network-byte-order, psqueues, stdenv, stm
         }:
         mkDerivation {
           pname = "http2";
           version = "1.6.4";
           sha256 = "2fcadd614cb8fa031e23a0fae096be76b08af7bbd525dc67096bd575cc3f1e66";
           isLibrary = true;
           isExecutable = true;
           libraryHaskellDepends = [
             array base bytestring case-insensitive containers
             network-byte-order psqueues stm
           ];
           doHaddock = false;
           doCheck = false;
           homepage = "https://github.com/kazu-yamamoto/http2";
           description = "HTTP/2 library including frames, priority queues and HPACK";
           license = stdenv.lib.licenses.bsd3;
         }) {};
      "httpd-shed" = callPackage
        ({ mkDerivation, base, network, network-uri, stdenv }:
         mkDerivation {
           pname = "httpd-shed";
           version = "0.4.0.3";
           sha256 = "b0ff87d81e61f788d3920d952e4469d984742ba49c006df086c159886bf09218";
           revision = "2";
           editedCabalFile = "12y9qf8s0aq4dc80wrvh14cjvvm4mcygrqq72w4z8w9n8mp8jg9p";
           isLibrary = true;
           isExecutable = true;
           libraryHaskellDepends = [ base network network-uri ];
           doHaddock = false;
           doCheck = false;
           description = "A simple web-server with an interact style API";
           license = stdenv.lib.licenses.bsd3;
         }) {};
      "human-readable-duration" = callPackage
        ({ mkDerivation, base, stdenv }:
         mkDerivation {
           pname = "human-readable-duration";
           version = "0.2.1.2";
           sha256 = "6552def225a0bde18dd4d416e02dc9a83472924550834529a349dd9286785690";
           libraryHaskellDepends = [ base ];
           doHaddock = false;
           doCheck = false;
           homepage = "https://gitlab.esy.fun/yogsototh/human-readable-duration#readme";
           description = "Provide duration helper";
           license = stdenv.lib.licenses.bsd3;
         }) {};
      "hunit-dejafu" = callPackage
        ({ mkDerivation, base, dejafu, exceptions, HUnit, stdenv }:
         mkDerivation {
           pname = "hunit-dejafu";
           version = "1.2.0.6";
           sha256 = "54aac2479fec2ecefeb7ff42e659d2d0d1fba125a339eb3df33ed2fb266ff683";
           libraryHaskellDepends = [ base dejafu exceptions HUnit ];
           doHaddock = false;
           doCheck = false;
           homepage = "https://github.com/barrucadu/dejafu";
           description = "Deja Fu support for the HUnit test framework";
           license = stdenv.lib.licenses.mit;
         }) {};
      "hvect" = callPackage
        ({ mkDerivation, base, stdenv }:
         mkDerivation {
           pname = "hvect";
           version = "0.4.0.0";
           sha256 = "cb50ef1a7f189f8c217a7d0d55b5568b2fa9bbe415b14ce114a93d2e1d5e30b6";
           libraryHaskellDepends = [ base ];
           doHaddock = false;
           doCheck = false;
           homepage = "https://github.com/agrafix/hvect";
           description = "Simple strict heterogeneous lists";
           license = stdenv.lib.licenses.mit;
         }) {};
      "hvega" = callPackage
        ({ mkDerivation, aeson, base, stdenv, text, vector }:
         mkDerivation {
           pname = "hvega";
           version = "0.1.0.3";
           sha256 = "0a7759965ad969e2b541f4ea39dc7f9d53442e39a61893edf7446bc3eb8f0542";
           libraryHaskellDepends = [ aeson base text vector ];
           doHaddock = false;
           doCheck = false;
           homepage = "https://github.com/DougBurke/hvega";
           description = "Create Vega and Vega-Lite visualizations";
           license = stdenv.lib.licenses.bsd3;
         }) {};
      "hw-balancedparens" = callPackage
        ({ mkDerivation, base, hw-bits, hw-excess, hw-prim
         , hw-rankselect-base, stdenv, vector
         }:
         mkDerivation {
           pname = "hw-balancedparens";
           version = "0.2.0.2";
           sha256 = "1622757f59d5fc789fc27c2311ba5147cd9491ad80d4e517755cb158ae87575d";
           libraryHaskellDepends = [
             base hw-bits hw-excess hw-prim hw-rankselect-base vector
           ];
           doHaddock = false;
           doCheck = false;
           homepage = "http://github.com/haskell-works/hw-balancedparens#readme";
           description = "Balanced parentheses";
           license = stdenv.lib.licenses.bsd3;
         }) {};
      "hw-bits" = callPackage
        ({ mkDerivation, base, bytestring, hw-int, hw-prim, hw-string-parse
         , safe, stdenv, vector
         }:
         mkDerivation {
           pname = "hw-bits";
           version = "0.7.0.5";
           sha256 = "1a4561307e8df6a6334db962fd772bf5bcc7d545727a9e2133e6d7aaffc46bdc";
           libraryHaskellDepends = [
             base bytestring hw-int hw-prim hw-string-parse safe vector
           ];
           doHaddock = false;
           doCheck = false;
           homepage = "http://github.com/haskell-works/hw-bits#readme";
           description = "Bit manipulation";
           license = stdenv.lib.licenses.bsd3;
         }) {};
      "hw-conduit" = callPackage
        ({ mkDerivation, array, base, bytestring, conduit
         , conduit-combinators, stdenv, time, transformers, unliftio-core
         , word8
         }:
         mkDerivation {
           pname = "hw-conduit";
           version = "0.2.0.5";
           sha256 = "047d5abec487bf522050d2a7f318ce9f0e67766a58cf67669d2d6fa7ae8dd701";
           libraryHaskellDepends = [
             array base bytestring conduit conduit-combinators time transformers
             unliftio-core word8
           ];
           doHaddock = false;
           doCheck = false;
           homepage = "http://github.com/haskell-works/hw-conduit#readme";
           description = "Conduits for tokenizing streams";
           license = stdenv.lib.licenses.mit;
         }) {};
      "hw-diagnostics" = callPackage
        ({ mkDerivation, base, stdenv }:
         mkDerivation {
           pname = "hw-diagnostics";
           version = "0.0.0.5";
           sha256 = "5ceaec01c446c5a507e889f514201e4739ea6f1cc22a4c68894bb023257bd931";
           libraryHaskellDepends = [ base ];
           doHaddock = false;
           doCheck = false;
           homepage = "http://github.com/haskell-works/hw-diagnostics#readme";
           description = "Diagnostics library";
           license = stdenv.lib.licenses.bsd3;
         }) {};
      "hw-excess" = callPackage
        ({ mkDerivation, base, hw-bits, hw-prim, hw-rankselect-base, safe
         , stdenv, vector
         }:
         mkDerivation {
           pname = "hw-excess";
           version = "0.2.0.2";
           sha256 = "6735d0cd4ee86d5c13d5ea067251c6b1126f7569d78c6241f3147eb114b7a1f6";
           libraryHaskellDepends = [
             base hw-bits hw-prim hw-rankselect-base safe vector
           ];
           doHaddock = false;
           doCheck = false;
           homepage = "http://github.com/haskell-works/hw-excess#readme";
           description = "Excess";
           license = stdenv.lib.licenses.bsd3;
         }) {};
      "hw-fingertree-strict" = callPackage
        ({ mkDerivation, base, deepseq, stdenv }:
         mkDerivation {
           pname = "hw-fingertree-strict";
           version = "0.1.1.1";
           sha256 = "1127b7cff38319a292ca6d57c8b7a1996bb80b90e86488a0f82a76eba9f91268";
           libraryHaskellDepends = [ base deepseq ];
           doHaddock = false;
           doCheck = false;
           homepage = "https://github.com/haskell-works/hw-fingertree-strict#readme";
           description = "Generic strict finger-tree structure";
           license = stdenv.lib.licenses.bsd3;
         }) {};
      "hw-hedgehog" = callPackage
        ({ mkDerivation, base, hedgehog, stdenv, vector }:
         mkDerivation {
           pname = "hw-hedgehog";
           version = "0.1.0.2";
           sha256 = "7e6d4418d915b142dc8546679a38a28be00de62683c45ece62478600ecc3653a";
           libraryHaskellDepends = [ base hedgehog vector ];
           doHaddock = false;
           doCheck = false;
           homepage = "https://github.com/haskell-works/hw-hedgehog#readme";
           description = "Extra hedgehog functionality";
           license = stdenv.lib.licenses.bsd3;
         }) {};
      "hw-hspec-hedgehog" = callPackage
        ({ mkDerivation, base, call-stack, hedgehog, hspec, HUnit, stdenv
         , transformers
         }:
         mkDerivation {
           pname = "hw-hspec-hedgehog";
           version = "0.1.0.5";
           sha256 = "d3d17aadf474e82bb2d90c2d48cadf18724cbeab08e010bdf250591ce9c5f64f";
           revision = "4";
           editedCabalFile = "1sr5cf1s86mp6nlw1vgj565zsrxmwa134g5003p1834vynyh98zq";
           libraryHaskellDepends = [
             base call-stack hedgehog hspec HUnit transformers
           ];
           doHaddock = false;
           doCheck = false;
           homepage = "https://github.com/haskell-works/hw-hspec-hedgehog#readme";
           description = "Interoperability between hspec and hedgehog";
           license = stdenv.lib.licenses.bsd3;
         }) {};
      "hw-int" = callPackage
        ({ mkDerivation, base, stdenv }:
         mkDerivation {
           pname = "hw-int";
           version = "0.0.0.3";
           sha256 = "8336a5111638d3298266c9a1458233a09798bfa6d558219d4fe3bdd35d8d4a3f";
           libraryHaskellDepends = [ base ];
           doHaddock = false;
           doCheck = false;
           homepage = "http://github.com/haskell-works/hw-int#readme";
           description = "Integers";
           license = stdenv.lib.licenses.bsd3;
         }) {};
      "hw-ip" = callPackage
        ({ mkDerivation, base, stdenv }:
         mkDerivation {
           pname = "hw-ip";
           version = "0.1.0.0";
           sha256 = "3664d0fbbb1fd734b9b3a8d39b1115390ddc1a8a5e48b4ae5d5960d3ba7980bf";
           libraryHaskellDepends = [ base ];
           doHaddock = false;
           doCheck = false;
           homepage = "https://github.com/haskell-works/hw-ip#readme";
           description = "Library for manipulating IP addresses and CIDR blocks";
           license = stdenv.lib.licenses.bsd3;
         }) {};
      "hw-json" = callPackage
        ({ mkDerivation, ansi-wl-pprint, array, attoparsec, base
         , bytestring, conduit, containers, criterion, dlist
         , hw-balancedparens, hw-bits, hw-conduit, hw-diagnostics, hw-mquery
         , hw-parser, hw-prim, hw-rankselect, hw-rankselect-base, mmap
         , mono-traversable, resourcet, stdenv, text, vector, word8
         }:
         mkDerivation {
           pname = "hw-json";
           version = "0.6.0.0";
           sha256 = "bb8e20e8a035279ee398c6d9162cda3f965d4f96e39c1d363be2456b1feb41d9";
           revision = "2";
           editedCabalFile = "0ygq95nx4sb70l5kfxlsj6rf2b3ry84ixby567n0jk1g0zks3z7s";
           isLibrary = true;
           isExecutable = true;
           libraryHaskellDepends = [
             ansi-wl-pprint array attoparsec base bytestring conduit containers
             dlist hw-balancedparens hw-bits hw-conduit hw-mquery hw-parser
             hw-prim hw-rankselect hw-rankselect-base mmap mono-traversable
             resourcet text vector word8
           ];
           executableHaskellDepends = [
             ansi-wl-pprint array attoparsec base bytestring conduit containers
             criterion dlist hw-balancedparens hw-bits hw-conduit hw-diagnostics
             hw-mquery hw-parser hw-prim hw-rankselect hw-rankselect-base mmap
             mono-traversable resourcet text vector word8
           ];
           doHaddock = false;
           doCheck = false;
           homepage = "http://github.com/haskell-works/hw-json#readme";
           description = "Memory efficient JSON parser";
           license = stdenv.lib.licenses.bsd3;
         }) {};
      "hw-mquery" = callPackage
        ({ mkDerivation, ansi-wl-pprint, base, dlist, stdenv }:
         mkDerivation {
           pname = "hw-mquery";
           version = "0.1.0.1";
           sha256 = "724aa5b0490b57a89fb71b7042a3770f7978a4c975aa3d1b671576b0e83e113d";
           isLibrary = true;
           isExecutable = true;
           libraryHaskellDepends = [ ansi-wl-pprint base dlist ];
           executableHaskellDepends = [ base ];
           doHaddock = false;
           doCheck = false;
           homepage = "http://github.com/haskell-works/hw-mquery#readme";
           description = "Conduits for tokenizing streams";
           license = stdenv.lib.licenses.mit;
         }) {};
      "hw-parser" = callPackage
        ({ mkDerivation, attoparsec, base, bytestring, hw-prim
         , mono-traversable, stdenv, text
         }:
         mkDerivation {
           pname = "hw-parser";
           version = "0.0.0.3";
           sha256 = "dd8417c76ef5da89df2842b42767d825815ec3594c8e80e28e96570d8046c6f2";
           libraryHaskellDepends = [
             attoparsec base bytestring hw-prim mono-traversable text
           ];
           doHaddock = false;
           doCheck = false;
           homepage = "http://github.com/haskell-works/hw-parser#readme";
           description = "Simple parser support";
           license = stdenv.lib.licenses.bsd3;
         }) {};
      "hw-prim" = callPackage
        ({ mkDerivation, base, bytestring, mmap, semigroups, stdenv
         , transformers, vector
         }:
         mkDerivation {
           pname = "hw-prim";
           version = "0.6.2.22";
           sha256 = "114cc374cf048f99f46c524d76f3ecd5f7d1774b47098cee79274eeabf54ae99";
           libraryHaskellDepends = [
             base bytestring mmap semigroups transformers vector
           ];
           doHaddock = false;
           doCheck = false;
           homepage = "http://github.com/haskell-works/hw-prim#readme";
           description = "Primitive functions and data types";
           license = stdenv.lib.licenses.bsd3;
         }) {};
      "hw-rankselect" = callPackage
        ({ mkDerivation, base, deepseq, directory, hw-balancedparens
         , hw-bits, hw-prim, hw-rankselect-base, mmap, stdenv, vector
         }:
         mkDerivation {
           pname = "hw-rankselect";
           version = "0.10.0.3";
           sha256 = "aa1d079f56064c649bc820219b55ae16d723faed663283ab73760db4f2f514cb";
           revision = "1";
           editedCabalFile = "1rkni89h3sq02y03phb2bgx4yrx4gly9mzan6r4ziph0qayf09wf";
           isLibrary = true;
           isExecutable = true;
           libraryHaskellDepends = [
             base deepseq hw-balancedparens hw-bits hw-prim hw-rankselect-base
             vector
           ];
           executableHaskellDepends = [
             base directory hw-bits hw-prim hw-rankselect-base mmap vector
           ];
           doHaddock = false;
           doCheck = false;
           homepage = "http://github.com/haskell-works/hw-rankselect#readme";
           description = "Rank-select";
           license = stdenv.lib.licenses.bsd3;
         }) {};
      "hw-rankselect-base" = callPackage
        ({ mkDerivation, base, bits-extra, hw-bits, hw-int, hw-prim
         , hw-string-parse, safe, stdenv, vector
         }:
         mkDerivation {
           pname = "hw-rankselect-base";
           version = "0.3.2.1";
           sha256 = "d20a6cab42189cf71a85b355d0ed52167bc2991210c3af76139a2e6229f79360";
           libraryHaskellDepends = [
             base bits-extra hw-bits hw-int hw-prim hw-string-parse safe vector
           ];
           doHaddock = false;
           doCheck = false;
           homepage = "http://github.com/haskell-works/hw-rankselect-base#readme";
           description = "Rank-select base";
           license = stdenv.lib.licenses.bsd3;
         }) {};
      "hw-string-parse" = callPackage
        ({ mkDerivation, base, stdenv }:
         mkDerivation {
           pname = "hw-string-parse";
           version = "0.0.0.4";
           sha256 = "64a1ebf8d311e255f293c40febfb346da23a55a454b67f2d5e33de1cb7e9f2b7";
           libraryHaskellDepends = [ base ];
           doHaddock = false;
           doCheck = false;
           homepage = "http://github.com/haskell-works/hw-string-parse#readme";
           description = "String parser";
           license = stdenv.lib.licenses.bsd3;
         }) {};
      "hw-succinct" = callPackage
        ({ mkDerivation, attoparsec, base, bytestring, conduit, containers
         , hw-balancedparens, hw-bits, hw-prim, hw-rankselect
         , hw-rankselect-base, mmap, mono-traversable, stdenv, text, vector
         , word8
         }:
         mkDerivation {
           pname = "hw-succinct";
           version = "0.1.0.1";
           sha256 = "002c578c1ff7a33cbef089b2a943218777c14125629f6bf63dea9e7c8e3749db";
           libraryHaskellDepends = [
             attoparsec base bytestring conduit containers hw-balancedparens
             hw-bits hw-prim hw-rankselect hw-rankselect-base mmap
             mono-traversable text vector word8
           ];
           doHaddock = false;
           doCheck = false;
           homepage = "http://github.com/haskell-works/hw-succinct#readme";
           description = "Succint datastructures";
           license = stdenv.lib.licenses.mit;
         }) {};
      "hw-xml" = callPackage
        ({ mkDerivation, ansi-wl-pprint, array, attoparsec, base
         , bytestring, cereal, conduit, containers, deepseq, ghc-prim
         , hw-balancedparens, hw-bits, hw-conduit, hw-parser, hw-prim
         , hw-rankselect, hw-rankselect-base, lens, mtl, resourcet, stdenv
         , transformers, vector, word8
         }:
         mkDerivation {
           pname = "hw-xml";
           version = "0.1.0.3";
           sha256 = "27a9a8212331c8c91d4a66baf8f0785c4ce90c087c02359bd16dfaeabc627e97";
           isLibrary = true;
           isExecutable = true;
           enableSeparateDataOutput = true;
           libraryHaskellDepends = [
             ansi-wl-pprint array attoparsec base bytestring cereal conduit
             containers deepseq ghc-prim hw-balancedparens hw-bits hw-conduit
             hw-parser hw-prim hw-rankselect hw-rankselect-base lens mtl
             resourcet transformers vector word8
           ];
           executableHaskellDepends = [
             base bytestring hw-balancedparens hw-bits hw-prim hw-rankselect
             vector
           ];
           doHaddock = false;
           doCheck = false;
           homepage = "http://github.com/haskell-works/hw-xml#readme";
           description = "Conduits for tokenizing streams";
           license = stdenv.lib.licenses.bsd3;
         }) {};
      "hweblib" = callPackage
        ({ mkDerivation, attoparsec, base, bytestring, containers, mtl
         , stdenv, text, transformers
         }:
         mkDerivation {
           pname = "hweblib";
           version = "0.6.3";
           sha256 = "1e8ee12baac496d56831935a60e78f54eb43d2b7268bf7d31acb6b9a63e9b50d";
           libraryHaskellDepends = [
             attoparsec base bytestring containers mtl text transformers
           ];
           doHaddock = false;
           doCheck = false;
           homepage = "http://github.com/aycanirican/hweblib";
           description = "Haskell Web Library";
           license = stdenv.lib.licenses.bsd3;
         }) {};
      "hworker" = callPackage
        ({ mkDerivation, aeson, attoparsec, base, bytestring, hedis, stdenv
         , text, time, uuid
         }:
         mkDerivation {
           pname = "hworker";
           version = "0.1.0.1";
           sha256 = "34cbcc4db8f190ab0dc02a072adcf1fc75b7beab7e545982872bf265a1223f1d";
           revision = "1";
           editedCabalFile = "0w2bpvfr68n2qipvr8gc5096dain3g2536m4n9kqx1fahf12mwy5";
           libraryHaskellDepends = [
             aeson attoparsec base bytestring hedis text time uuid
           ];
           doHaddock = false;
           doCheck = false;
           homepage = "http://github.com/dbp/hworker";
           description = "A reliable at-least-once job queue built on top of redis";
           license = stdenv.lib.licenses.isc;
         }) {};
      "hxt" = callPackage
        ({ mkDerivation, base, binary, bytestring, containers, deepseq
         , directory, filepath, hxt-charproperties, hxt-regex-xmlschema
         , hxt-unicode, mtl, network-uri, parsec, stdenv
         }:
         mkDerivation {
           pname = "hxt";
           version = "9.3.1.16";
           sha256 = "0d55e35cc718891d0987b7c8e6c43499efa727c68bc92e88e8b99461dff403e3";
           configureFlags = [ "-fnetwork-uri" ];
           libraryHaskellDepends = [
             base binary bytestring containers deepseq directory filepath
             hxt-charproperties hxt-regex-xmlschema hxt-unicode mtl network-uri
             parsec
           ];
           doHaddock = false;
           doCheck = false;
           homepage = "https://github.com/UweSchmidt/hxt";
           description = "A collection of tools for processing XML with Haskell";
           license = stdenv.lib.licenses.mit;
         }) {};
      "hxt-charproperties" = callPackage
        ({ mkDerivation, base, stdenv }:
         mkDerivation {
           pname = "hxt-charproperties";
           version = "9.2.0.1";
           sha256 = "e46614d6bf0390b2a6a1aeeb0771e6d366944da40fb21c12c2f8a94d1f47b4d6";
           libraryHaskellDepends = [ base ];
           doHaddock = false;
           doCheck = false;
           homepage = "https://github.com/UweSchmidt/hxt";
           description = "Character properties and classes for XML and Unicode";
           license = stdenv.lib.licenses.mit;
         }) {};
      "hxt-css" = callPackage
        ({ mkDerivation, base, hxt, parsec, split, stdenv }:
         mkDerivation {
           pname = "hxt-css";
           version = "0.1.0.3";
           sha256 = "0244fc145d5923df0522ad80949e9b221b01a028c755ebfc4740339881ef65b7";
           isLibrary = true;
           isExecutable = true;
           libraryHaskellDepends = [ base hxt parsec split ];
           doHaddock = false;
           doCheck = false;
           homepage = "https://github.com/redneb/hxt-css";
           description = "CSS selectors for HXT";
           license = stdenv.lib.licenses.bsd3;
         }) {};
      "hxt-curl" = callPackage
        ({ mkDerivation, base, bytestring, curl, hxt, parsec, stdenv }:
         mkDerivation {
           pname = "hxt-curl";
           version = "9.1.1.1";
           sha256 = "cdc1cc8bf9b8699cabdee965c9737d497c199b5cf82eabc66a5fe3f2ffb3c5ea";
           libraryHaskellDepends = [ base bytestring curl hxt parsec ];
           doHaddock = false;
           doCheck = false;
           homepage = "https://github.com/UweSchmidt/hxt";
           description = "LibCurl interface for HXT";
           license = "unknown";
           hydraPlatforms = stdenv.lib.platforms.none;
         }) {};
      "hxt-expat" = callPackage
        ({ mkDerivation, base, bytestring, hexpat, hxt, stdenv }:
         mkDerivation {
           pname = "hxt-expat";
           version = "9.1.1";
           sha256 = "10d9c43c20c82e879fbc06944fcfed373f8b43bd3e0a44f9c712db30a27022d6";
           libraryHaskellDepends = [ base bytestring hexpat hxt ];
           doHaddock = false;
           doCheck = false;
           homepage = "http://www.fh-wedel.de/~si/HXmlToolbox/index.html";
           description = "Expat parser for HXT";
           license = "unknown";
           hydraPlatforms = stdenv.lib.platforms.none;
         }) {};
      "hxt-http" = callPackage
        ({ mkDerivation, base, bytestring, HTTP, hxt, network, network-uri
         , parsec, stdenv
         }:
         mkDerivation {
           pname = "hxt-http";
           version = "9.1.5.2";
           sha256 = "6fa19d03991d53c34f4525a4fdfaafde56dd48459093b4502832a1fdd9dfdd0b";
           configureFlags = [ "-fnetwork-uri" ];
           libraryHaskellDepends = [
             base bytestring HTTP hxt network network-uri parsec
           ];
           doHaddock = false;
           doCheck = false;
           homepage = "https://github.com/UweSchmidt/hxt";
           description = "Interface to native Haskell HTTP package HTTP";
           license = stdenv.lib.licenses.mit;
         }) {};
      "hxt-pickle-utils" = callPackage
        ({ mkDerivation, base, hxt, mtl, stdenv }:
         mkDerivation {
           pname = "hxt-pickle-utils";
           version = "0.1.0.3";
           sha256 = "9ddba19f27d9d8c155012da4dd9598fb318cab862da10f14ee4bc3eb5321a9c5";
           revision = "3";
           editedCabalFile = "0d5fg718y7xzw76ip33q0w1liqk70q9074qkd198mjnijxjcrkf3";
           libraryHaskellDepends = [ base hxt mtl ];
           doHaddock = false;
           doCheck = false;
           homepage = "https://github.com/silkapp/hxt-pickle-utils";
           description = "Utility functions for using HXT picklers";
           license = stdenv.lib.licenses.bsd3;
         }) {};
      "hxt-regex-xmlschema" = callPackage
        ({ mkDerivation, base, bytestring, hxt-charproperties, parsec
         , stdenv, text
         }:
         mkDerivation {
           pname = "hxt-regex-xmlschema";
           version = "9.2.0.3";
           sha256 = "f4743ba65498d6001cdfcf5cbc3317d4bc43941be5c7030b60beb83408c892b0";
           revision = "1";
           editedCabalFile = "0vg9vnfjmq1ma6zwwv4yvfih6wbslksvsvy9b41i4f81l0hh7ia8";
           libraryHaskellDepends = [
             base bytestring hxt-charproperties parsec text
           ];
           doHaddock = false;
           doCheck = false;
           homepage = "http://www.haskell.org/haskellwiki/Regular_expressions_for_XML_Schema";
           description = "A regular expression library for W3C XML Schema regular expressions";
           license = stdenv.lib.licenses.mit;
         }) {};
      "hxt-tagsoup" = callPackage
        ({ mkDerivation, base, hxt, hxt-charproperties, hxt-unicode, stdenv
         , tagsoup
         }:
         mkDerivation {
           pname = "hxt-tagsoup";
           version = "9.1.4";
           sha256 = "d77b290d63acf0ac8e5a07c5c69753f9984b97e0c9d2c0befadd7dd5b144b283";
           libraryHaskellDepends = [
             base hxt hxt-charproperties hxt-unicode tagsoup
           ];
           doHaddock = false;
           doCheck = false;
           homepage = "https://github.com/UweSchmidt/hxt";
           description = "TagSoup parser for HXT";
           license = "unknown";
           hydraPlatforms = stdenv.lib.platforms.none;
         }) {};
      "hxt-unicode" = callPackage
        ({ mkDerivation, base, hxt-charproperties, stdenv }:
         mkDerivation {
           pname = "hxt-unicode";
           version = "9.0.2.4";
           sha256 = "7b5823f3bd94b57022d9d84ab3555303653c5121eaaef2ee1fd4918f3c434466";
           libraryHaskellDepends = [ base hxt-charproperties ];
           doHaddock = false;
           doCheck = false;
           homepage = "https://github.com/UweSchmidt/hxt";
           description = "Unicode en-/decoding functions for utf8, iso-latin-* and other encodings";
           license = stdenv.lib.licenses.mit;
         }) {};
      "hybrid-vectors" = callPackage
        ({ mkDerivation, base, deepseq, primitive, semigroups, stdenv
         , vector
         }:
         mkDerivation {
           pname = "hybrid-vectors";
           version = "0.2.2";
           sha256 = "41c6c371df64b9083354e66101ad8c92f87458474fed2a149e4632db644f86d7";
           libraryHaskellDepends = [
             base deepseq primitive semigroups vector
           ];
           doHaddock = false;
           doCheck = false;
           homepage = "http://github.com/ekmett/hybrid-vectors";
           description = "Hybrid vectors e.g. Mixed Boxed/Unboxed vectors";
           license = stdenv.lib.licenses.bsd3;
         }) {};
      "hyperloglog" = callPackage
        ({ mkDerivation, approximate, base, binary, bits, bytes, Cabal
         , cabal-doctest, cereal, cereal-vector, comonad, deepseq
         , distributive, hashable, lens, reflection, safecopy, semigroupoids
         , semigroups, siphash, stdenv, tagged, vector
         }:
         mkDerivation {
           pname = "hyperloglog";
           version = "0.4.2";
           sha256 = "f5b83cfcc2c9d1e40e04bbc9724428b2655c3b54b26beef714c98dabee5f1048";
           revision = "1";
           editedCabalFile = "1zh47rrwih6933hhq9vd0ly5s42w0bn196znkg9l8q6r6drl7xsf";
           setupHaskellDepends = [ base Cabal cabal-doctest ];
           libraryHaskellDepends = [
             approximate base binary bits bytes cereal cereal-vector comonad
             deepseq distributive hashable lens reflection safecopy
             semigroupoids semigroups siphash tagged vector
           ];
           doHaddock = false;
           doCheck = false;
           homepage = "http://github.com/analytics/hyperloglog";
           description = "An approximate streaming (constant space) unique object counter";
           license = stdenv.lib.licenses.bsd3;
         }) {};
      "hyphenation" = callPackage
        ({ mkDerivation, base, bytestring, Cabal, cabal-doctest, containers
         , stdenv, unordered-containers, zlib
         }:
         mkDerivation {
           pname = "hyphenation";
           version = "0.7.1";
           sha256 = "a25c5073f42896ccf81ff5936f3a42f290730f61da7f225b126ad22ff601b1c0";
           revision = "5";
           editedCabalFile = "00wsp69aqi5i906liqa4sfs0p2yclhr1ihz8y1700b3ymb70lzql";
           enableSeparateDataOutput = true;
           setupHaskellDepends = [ base Cabal cabal-doctest ];
           libraryHaskellDepends = [
             base bytestring containers unordered-containers zlib
           ];
           doHaddock = false;
           doCheck = false;
           homepage = "http://github.com/ekmett/hyphenation";
           description = "Configurable Knuth-Liang hyphenation";
           license = stdenv.lib.licenses.bsd2;
         }) {};
      "hyraxAbif" = callPackage
        ({ mkDerivation, base, binary, bytestring, directory, filepath
         , hscolour, pretty-show, protolude, stdenv, text
         }:
         mkDerivation {
           pname = "hyraxAbif";
           version = "0.2.3.10";
           sha256 = "6be4c3fae205e3c2e16ef25d71c9190cae9be0870edd086f07920f7afa0300f5";
           revision = "2";
           editedCabalFile = "1dwkqlkjg5hbjlwl7cjxmhg1camhlqpaqjrpmkwknscj76hfckvi";
           isLibrary = true;
           isExecutable = true;
           libraryHaskellDepends = [
             base binary bytestring directory filepath protolude text
           ];
           executableHaskellDepends = [
             base bytestring hscolour pretty-show protolude text
           ];
           doHaddock = false;
           doCheck = false;
           homepage = "https://github.com/hyraxbio/hyraxAbif/#readme";
           description = "Modules for parsing, generating and manipulating AB1 files";
           license = "(BSD-3-Clause OR Apache-2.0)";
         }) {};
      "iconv" = callPackage
        ({ mkDerivation, base, bytestring, stdenv }:
         mkDerivation {
           pname = "iconv";
           version = "0.4.1.3";
           sha256 = "36425168e3314bc83ba5ee95152872d52e94ee0f9503f3591f84d458e005b554";
           libraryHaskellDepends = [ base bytestring ];
           doHaddock = false;
           doCheck = false;
           description = "String encoding conversion";
           license = stdenv.lib.licenses.bsd3;
         }) {};
      "identicon" = callPackage
        ({ mkDerivation, base, bytestring, JuicyPixels, stdenv }:
         mkDerivation {
           pname = "identicon";
           version = "0.2.2";
           sha256 = "3679b4fcc0a5bcc93b6ed2009f43e3ec87bf9549aee3eef182f7403d0c10f263";
           revision = "3";
           editedCabalFile = "0vya6zm3nnbdv3wmj3dwqwwjgsagql8q17078knhjddv2lm8m49q";
           enableSeparateDataOutput = true;
           libraryHaskellDepends = [ base bytestring JuicyPixels ];
           doHaddock = false;
           doCheck = false;
           homepage = "https://github.com/mrkkrp/identicon";
           description = "Flexible generation of identicons";
           license = stdenv.lib.licenses.bsd3;
         }) {};
      "idris" = callPackage
        ({ mkDerivation, aeson, annotated-wl-pprint, ansi-terminal
         , ansi-wl-pprint, array, async, base, base64-bytestring, binary
         , blaze-html, blaze-markup, bytestring, Cabal, cheapskate
         , code-page, containers, deepseq, directory, filepath, fingertree
         , fsnotify, gmp, haskeline, ieee754, libffi, megaparsec, mtl
         , network, optparse-applicative, pretty, process, regex-tdfa, safe
         , split, stdenv, terminal-size, text, time, transformers, uniplate
         , unix, unordered-containers, utf8-string, vector
         , vector-binary-instances, zip-archive
         }:
         mkDerivation {
           pname = "idris";
           version = "1.3.1";
           sha256 = "d1a1b0dddbd551218fee0ecb2c223f082288888a41552ead3852a4425181c93a";
           configureFlags = [ "-fcurses" "-fexeconly" "-fffi" "-fgmp" ];
           isLibrary = true;
           isExecutable = true;
           enableSeparateDataOutput = true;
           setupHaskellDepends = [ base Cabal directory filepath process ];
           libraryHaskellDepends = [
             aeson annotated-wl-pprint ansi-terminal ansi-wl-pprint array async
             base base64-bytestring binary blaze-html blaze-markup bytestring
             cheapskate code-page containers deepseq directory filepath
             fingertree fsnotify haskeline ieee754 libffi megaparsec mtl network
             optparse-applicative pretty process regex-tdfa safe split
             terminal-size text time transformers uniplate unix
             unordered-containers utf8-string vector vector-binary-instances
             zip-archive
           ];
           librarySystemDepends = [ gmp ];
           executableHaskellDepends = [
             base directory filepath haskeline transformers
           ];
           doHaddock = false;
           doCheck = false;
           homepage = "http://www.idris-lang.org/";
           description = "Functional Programming Language with Dependent Types";
           license = stdenv.lib.licenses.bsd3;
         }) {inherit (pkgs) gmp;};
      "ieee754" = callPackage
        ({ mkDerivation, base, stdenv }:
         mkDerivation {
           pname = "ieee754";
           version = "0.8.0";
           sha256 = "0e2dff9c37f59acf5c64f978ec320005e9830f276f9f314e4bfed3f482289ad1";
           libraryHaskellDepends = [ base ];
           doHaddock = false;
           doCheck = false;
           homepage = "http://github.com/patperry/hs-ieee754";
           description = "Utilities for dealing with IEEE floating point numbers";
           license = stdenv.lib.licenses.bsd3;
         }) {};
      "if" = callPackage
        ({ mkDerivation, base, stdenv }:
         mkDerivation {
           pname = "if";
           version = "0.1.0.0";
           sha256 = "28f673e867dbe0f51324d97fcb7884673a34912593746520a470116b167a141d";
           libraryHaskellDepends = [ base ];
           doHaddock = false;
           doCheck = false;
           homepage = "https://github.com/winterland1989/if";
           description = "(?) and (?>) conditional operator";
           license = stdenv.lib.licenses.bsd3;
         }) {};
      "iff" = callPackage
        ({ mkDerivation, base, binary, bytestring, stdenv }:
         mkDerivation {
           pname = "iff";
           version = "0.0.6";
           sha256 = "6b8845808481307e2d374fd8d17e82a5de1284e612cf8ade27db8785e9e12837";
           libraryHaskellDepends = [ base binary bytestring ];
           doHaddock = false;
           doCheck = false;
           homepage = "http://code.haskell.org/~thielema/iff/";
           description = "Constructing and dissecting IFF files";
           license = "GPL";
         }) {};
      "ihaskell" = callPackage
        ({ mkDerivation, aeson, base, base64-bytestring, bytestring, cereal
         , cmdargs, containers, directory, filepath, ghc, ghc-boot
         , ghc-parser, ghc-paths, haskeline, haskell-src-exts, hlint
         , http-client, http-client-tls, ipython-kernel, mtl, parsec
         , process, random, shelly, split, stdenv, stm, strict, system-argv0
         , text, transformers, unix, unordered-containers, utf8-string, uuid
         , vector
         }:
         mkDerivation {
           pname = "ihaskell";
           version = "0.9.1.0";
           sha256 = "36aab2ee12bb8e761c6e27b7f68b7989a147ef9b12abf4aad74f33f7645ce1e4";
           isLibrary = true;
           isExecutable = true;
           enableSeparateDataOutput = true;
           libraryHaskellDepends = [
             aeson base base64-bytestring bytestring cereal cmdargs containers
             directory filepath ghc ghc-boot ghc-parser ghc-paths haskeline
             haskell-src-exts hlint http-client http-client-tls ipython-kernel
             mtl parsec process random shelly split stm strict system-argv0 text
             transformers unix unordered-containers utf8-string uuid vector
           ];
           executableHaskellDepends = [
             aeson base bytestring containers directory ghc ipython-kernel
             process strict text transformers unix
           ];
           doHaddock = false;
           doCheck = false;
           homepage = "http://github.com/gibiansky/IHaskell";
           description = "A Haskell backend kernel for the IPython project";
           license = stdenv.lib.licenses.mit;
         }) {};
      "ihaskell-hvega" = callPackage
        ({ mkDerivation, aeson, base, hvega, ihaskell, stdenv, text }:
         mkDerivation {
           pname = "ihaskell-hvega";
           version = "0.1.0.3";
           sha256 = "cb91361cbe7489c795254876458ed89bbf01757bbde00bdf93080da1a1e17836";
           libraryHaskellDepends = [ aeson base hvega ihaskell text ];
           doHaddock = false;
           doCheck = false;
           homepage = "https://github.com/DougBurke/hvega";
           description = "IHaskell display instance for hvega types";
           license = stdenv.lib.licenses.bsd3;
         }) {};
      "ihs" = callPackage
        ({ mkDerivation, base, process, stdenv }:
         mkDerivation {
           pname = "ihs";
           version = "0.1.0.3";
           sha256 = "13bf923ad64d5dd1c517a64c0fd017fe94951a18ebbfe7e587b11e3ad6ebd5fd";
           isLibrary = false;
           isExecutable = true;
           executableHaskellDepends = [ base process ];
           doHaddock = false;
           doCheck = false;
           homepage = "https://github.com/minad/ihs";
           description = "Interpolated Haskell";
           license = stdenv.lib.licenses.publicDomain;
         }) {};
      "ilist" = callPackage
        ({ mkDerivation, base, stdenv }:
         mkDerivation {
           pname = "ilist";
           version = "0.3.1.0";
           sha256 = "e898e1dd1077e5a268f66e2de15f15ef64eddac94133954c9e054d59092afe97";
           libraryHaskellDepends = [ base ];
           doHaddock = false;
           doCheck = false;
           homepage = "http://github.com/aelve/ilist";
           description = "Optimised list functions for doing index-related things";
           license = stdenv.lib.licenses.bsd3;
         }) {};
      "imagesize-conduit" = callPackage
        ({ mkDerivation, base, bytestring, conduit, conduit-extra
         , exceptions, stdenv
         }:
         mkDerivation {
           pname = "imagesize-conduit";
           version = "1.1";
           sha256 = "31c5784578b305921b89f7ab6fca35747e5a35f12884770b78c31e3a0a01ac19";
           revision = "3";
           editedCabalFile = "0p4zmizr01pg3d7gb0q88j1alvvlzbdvzyf1wbgajng68a4g0li9";
           libraryHaskellDepends = [
             base bytestring conduit conduit-extra exceptions
           ];
           doHaddock = false;
           doCheck = false;
           homepage = "http://github.com/silkapp/imagesize-conduit";
           description = "Determine the size of some common image formats";
           license = stdenv.lib.licenses.bsd3;
         }) {};
      "immortal" = callPackage
        ({ mkDerivation, base, stdenv, stm, unliftio-core }:
         mkDerivation {
           pname = "immortal";
           version = "0.3";
           sha256 = "11c89db97f33c8bbfe6f72c728c68135a247608ceb2335dfb7ac6679acb41f88";
           libraryHaskellDepends = [ base stm unliftio-core ];
           doHaddock = false;
           doCheck = false;
           homepage = "https://github.com/feuerbach/immortal";
           description = "Spawn threads that never die (unless told to do so)";
           license = stdenv.lib.licenses.mit;
         }) {};
      "include-file" = callPackage
        ({ mkDerivation, base, bytestring, random, stdenv, template-haskell
         }:
         mkDerivation {
           pname = "include-file";
           version = "0.1.0.3";
           sha256 = "208f1f3bdc717f5f953cb7c9935c84d6a6291b7cd5ed8a22fa8567184be33d29";
           libraryHaskellDepends = [
             base bytestring random template-haskell
           ];
           doHaddock = false;
           doCheck = false;
           description = "Inclusion of files in executables at compile-time";
           license = stdenv.lib.licenses.bsd3;
         }) {};
      "incremental-parser" = callPackage
        ({ mkDerivation, base, monoid-subclasses, stdenv }:
         mkDerivation {
           pname = "incremental-parser";
           version = "0.3.2.1";
           sha256 = "d9515a1938d47bc9861600aac5304ac1b98727905145a061dc12664b45b56a1d";
           libraryHaskellDepends = [ base monoid-subclasses ];
           doHaddock = false;
           doCheck = false;
           homepage = "https://github.com/blamario/incremental-parser";
           description = "Generic parser library capable of providing partial results from partial input";
           license = stdenv.lib.licenses.gpl3;
         }) {};
      "indentation-core" = callPackage
        ({ mkDerivation, base, mtl, stdenv }:
         mkDerivation {
           pname = "indentation-core";
           version = "0.0.0.2";
           sha256 = "099a3e3bb82c6af1b99172722bb01e954d1722d468e2d0722415f4f479993fd0";
           libraryHaskellDepends = [ base mtl ];
           doHaddock = false;
           doCheck = false;
           homepage = "https://bitbucket.org/adamsmd/indentation";
           description = "Indentation sensitive parsing combinators core library";
           license = stdenv.lib.licenses.bsd3;
         }) {};
      "indentation-parsec" = callPackage
        ({ mkDerivation, base, indentation-core, mtl, parsec, stdenv }:
         mkDerivation {
           pname = "indentation-parsec";
           version = "0.0.0.2";
           sha256 = "0e37846ef1ea045d6c365be38f2b55ff7dd36e960f21ba28e879137874c8f2d4";
           libraryHaskellDepends = [ base indentation-core mtl parsec ];
           doHaddock = false;
           doCheck = false;
           homepage = "https://bitbucket.org/adamsmd/indentation";
           description = "Indentation sensitive parsing combinators for Parsec";
           license = stdenv.lib.licenses.bsd3;
         }) {};
      "indents" = callPackage
        ({ mkDerivation, base, mtl, parsec, stdenv }:
         mkDerivation {
           pname = "indents";
           version = "0.5.0.0";
           sha256 = "16bcc7ca0c1292e196a9c545df507e20e96f54a94392b775a686312503d9c3d3";
           libraryHaskellDepends = [ base mtl parsec ];
           doHaddock = false;
           doCheck = false;
           homepage = "http://github.com/jaspervdj/indents";
           description = "indentation sensitive parser-combinators for parsec";
           license = stdenv.lib.licenses.bsd3;
         }) {};
      "indexed-list-literals" = callPackage
        ({ mkDerivation, base, Only, stdenv }:
         mkDerivation {
           pname = "indexed-list-literals";
           version = "0.2.1.2";
           sha256 = "d896ae5b3919a7a9fecdd9336e8f330d055fbdae4821be04b7c1266ccaa07d10";
           libraryHaskellDepends = [ base Only ];
           doHaddock = false;
           doCheck = false;
           homepage = "https://github.com/davidm-d/indexed-list-literals";
           description = "Type safe indexed list literals";
           license = stdenv.lib.licenses.bsd3;
         }) {};
      "inflections" = callPackage
        ({ mkDerivation, base, exceptions, megaparsec, stdenv, text
         , unordered-containers
         }:
         mkDerivation {
           pname = "inflections";
           version = "0.4.0.3";
           sha256 = "bda19185f3948a8988a53b1d6b7dc8f6676033c988c1d0d3c2e615fd6e920d09";
           libraryHaskellDepends = [
             base exceptions megaparsec text unordered-containers
           ];
           doHaddock = false;
           doCheck = false;
           homepage = "https://github.com/stackbuilders/inflections-hs";
           description = "Inflections library for Haskell";
           license = stdenv.lib.licenses.mit;
         }) {};
      "influxdb" = callPackage
        ({ mkDerivation, aeson, attoparsec, base, bytestring, Cabal
         , cabal-doctest, clock, containers, foldl, http-client, http-types
         , lens, network, optional-args, scientific, stdenv, tagged, text
         , time, unordered-containers, vector
         }:
         mkDerivation {
           pname = "influxdb";
           version = "1.6.1";
           sha256 = "b7091b42093f74e45c76b00fba014450818fd8c9321f8b33f06f5f4a90b8dec1";
           isLibrary = true;
           isExecutable = true;
           setupHaskellDepends = [ base Cabal cabal-doctest ];
           libraryHaskellDepends = [
             aeson attoparsec base bytestring clock containers foldl http-client
             http-types lens network optional-args scientific tagged text time
             unordered-containers vector
           ];
           doHaddock = false;
           doCheck = false;
           homepage = "https://github.com/maoe/influxdb-haskell";
           description = "Haskell client library for InfluxDB";
           license = stdenv.lib.licenses.bsd3;
         }) {};
      "ini" = callPackage
        ({ mkDerivation, attoparsec, base, stdenv, text
         , unordered-containers
         }:
         mkDerivation {
           pname = "ini";
           version = "0.3.6";
           sha256 = "fcbbe3745a125e80dd6d0b4fe9b3a590507cf73dfaa62e115b20a46f0fd53cd9";
           revision = "1";
           editedCabalFile = "0gfikdal67aws20i5r4wg4r0lgn844glykcn3nnmbmyvwsks049l";
           libraryHaskellDepends = [
             attoparsec base text unordered-containers
           ];
           doHaddock = false;
           doCheck = false;
           homepage = "http://github.com/chrisdone/ini";
           description = "Quick and easy configuration files in the INI format";
           license = stdenv.lib.licenses.bsd3;
         }) {};
      "inline-c" = callPackage
        ({ mkDerivation, ansi-wl-pprint, base, bytestring, containers
         , hashable, mtl, parsec, parsers, stdenv, template-haskell
         , transformers, unordered-containers, vector
         }:
         mkDerivation {
           pname = "inline-c";
           version = "0.6.1.0";
           sha256 = "d0d8c1510d0d858fb8d939f99a37ec1d2f4eb15ec848ab71fcad9ea8b1ce6e6d";
           isLibrary = true;
           isExecutable = true;
           libraryHaskellDepends = [
             ansi-wl-pprint base bytestring containers hashable mtl parsec
             parsers template-haskell transformers unordered-containers vector
           ];
           doHaddock = false;
           doCheck = false;
           description = "Write Haskell source files including C code inline. No FFI required.";
           license = stdenv.lib.licenses.mit;
         }) {};
      "inline-java" = callPackage
        ({ mkDerivation, base, bytestring, Cabal, directory, filepath, ghc
         , jni, jvm, language-java, mtl, process, stdenv, template-haskell
         , temporary, text
         }:
         mkDerivation {
           pname = "inline-java";
           version = "0.8.4";
           sha256 = "5b94f54dd74530ae3427217a0d68ac1edf34995b8b23170ea3433c4026e4afb5";
           libraryHaskellDepends = [
             base bytestring Cabal directory filepath ghc jni jvm language-java
             mtl process template-haskell temporary text
           ];
           doHaddock = false;
           doCheck = false;
           homepage = "http://github.com/tweag/inline-java#readme";
           description = "Java interop via inline Java code in Haskell modules";
           license = stdenv.lib.licenses.bsd3;
         }) {};
      "inliterate" = callPackage
        ({ mkDerivation, base, blaze-html, cheapskate, containers
         , haskell-src-exts, lucid, lucid-extras, plotlyhs, stdenv, text
         , time
         }:
         mkDerivation {
           pname = "inliterate";
           version = "0.1.0";
           sha256 = "2d96cc64e3b923003668c88fd73c30d5da09a2c9e2fb6af62912f54478d1e39f";
           isLibrary = true;
           isExecutable = true;
           libraryHaskellDepends = [
             base blaze-html cheapskate containers haskell-src-exts lucid
             lucid-extras plotlyhs text time
           ];
           executableHaskellDepends = [ base text ];
           doHaddock = false;
           doCheck = false;
           homepage = "https://github.com/diffusionkinetics/open/inliterate";
           description = "Interactive literate programming";
           license = stdenv.lib.licenses.mit;
         }) {};
      "insert-ordered-containers" = callPackage
        ({ mkDerivation, aeson, base, base-compat, hashable, lens
         , semigroupoids, semigroups, stdenv, text, transformers
         , unordered-containers
         }:
         mkDerivation {
           pname = "insert-ordered-containers";
           version = "0.2.1.0";
           sha256 = "d71d126bf455898492e1d2ba18b2ad04453f8b0e4daff3926a67f0560a712298";
           revision = "9";
           editedCabalFile = "02d4zqyb9dbahkpcbpgxylrc5xxc0zbw1awj5w0jyrql2g2b6a5f";
           libraryHaskellDepends = [
             aeson base base-compat hashable lens semigroupoids semigroups text
             transformers unordered-containers
           ];
           doHaddock = false;
           doCheck = false;
           homepage = "https://github.com/phadej/insert-ordered-containers#readme";
           description = "Associative containers retaining insertion order for traversals";
           license = stdenv.lib.licenses.bsd3;
         }) {};
      "inspection-testing" = callPackage
        ({ mkDerivation, base, containers, ghc, mtl, stdenv
         , template-haskell, transformers
         }:
         mkDerivation {
           pname = "inspection-testing";
           version = "0.2.0.1";
           sha256 = "1f699bf8e95ab90d36725a8a090ad052dbb051cce379fd45a664f561e66ea194";
           libraryHaskellDepends = [
             base containers ghc mtl template-haskell transformers
           ];
           doHaddock = false;
           doCheck = false;
           homepage = "https://github.com/nomeata/inspection-testing";
           description = "GHC plugin to do inspection testing";
           license = stdenv.lib.licenses.mit;
         }) {};
      "instance-control" = callPackage
        ({ mkDerivation, base, mtl, stdenv, transformers }:
         mkDerivation {
           pname = "instance-control";
           version = "0.1.2.0";
           sha256 = "7d6dd381d8fb449584cdb016464cd02794e3ccc527c0589aab16d8a2221c6b73";
           libraryHaskellDepends = [ base mtl transformers ];
           doHaddock = false;
           doCheck = false;
           homepage = "https://github.com/lazac/instance-control";
           description = "Controls how the compiler searches for instances using type families";
           license = stdenv.lib.licenses.bsd3;
         }) {};
      "integer-logarithms" = callPackage
        ({ mkDerivation, array, base, ghc-prim, integer-gmp, stdenv }:
         mkDerivation {
           pname = "integer-logarithms";
           version = "1.0.2.2";
           sha256 = "ba86628d5c14f31fddccea86eeec122ed992af28d5b7ad964b2f5487605e7fc3";
           revision = "1";
           editedCabalFile = "1684dkh8j2xqsd85bfsmhv3iam37hasjg4x79mvl6xh7scmpfdbw";
           libraryHaskellDepends = [ array base ghc-prim integer-gmp ];
           doHaddock = false;
           doCheck = false;
           homepage = "https://github.com/Bodigrim/integer-logarithms";
           description = "Integer logarithms";
           license = stdenv.lib.licenses.mit;
         }) {};
      "integration" = callPackage
        ({ mkDerivation, base, parallel, stdenv }:
         mkDerivation {
           pname = "integration";
           version = "0.2.1";
           sha256 = "0c27385eadc10a580e78f7b7d4bc919c346b2c9b1e73aea7e7804d824d53582f";
           libraryHaskellDepends = [ base parallel ];
           doHaddock = false;
           doCheck = false;
           homepage = "https://github.com/ekmett/integration";
           description = "Fast robust numeric integration via tanh-sinh quadrature";
           license = stdenv.lib.licenses.bsd3;
         }) {};
      "intern" = callPackage
        ({ mkDerivation, array, base, bytestring, hashable, stdenv, text
         , unordered-containers
         }:
         mkDerivation {
           pname = "intern";
           version = "0.9.2";
           sha256 = "93a3b20e96dad8d83c9145dfc68bd9d2a6a72c9f64e4a7bc257d330070f42e20";
           revision = "1";
           editedCabalFile = "1mav591qx20p9dx4rg4xwpavqw8rciva82n7q0icdgvc1ayy7sl5";
           libraryHaskellDepends = [
             array base bytestring hashable text unordered-containers
           ];
           doHaddock = false;
           doCheck = false;
           homepage = "http://github.com/ekmett/intern/";
           description = "Efficient hash-consing for arbitrary data types";
           license = stdenv.lib.licenses.bsd3;
         }) {};
      "interpolate" = callPackage
        ({ mkDerivation, base, haskell-src-meta, stdenv, template-haskell
         }:
         mkDerivation {
           pname = "interpolate";
           version = "0.2.0";
           sha256 = "6e112006073f2d91e7e93432ccb147b79a21fcc21a9dedd0d8c38cef51926abe";
           libraryHaskellDepends = [ base haskell-src-meta template-haskell ];
           doHaddock = false;
           doCheck = false;
           homepage = "https://github.com/sol/interpolate#readme";
           description = "String interpolation done right";
           license = stdenv.lib.licenses.mit;
         }) {};
      "interpolatedstring-perl6" = callPackage
        ({ mkDerivation, base, bytestring, Cabal, haskell-src-meta, process
         , stdenv, template-haskell, text
         }:
         mkDerivation {
           pname = "interpolatedstring-perl6";
           version = "1.0.1";
           sha256 = "5eadba4ba24c10a8f2a4a1cc48af6eb0f07190d7c0e691a22c5a99fb37367258";
           enableSeparateDataOutput = true;
           setupHaskellDepends = [ base Cabal process ];
           libraryHaskellDepends = [
             base bytestring haskell-src-meta template-haskell text
           ];
           doHaddock = false;
           doCheck = false;
           description = "QuasiQuoter for Perl6-style multi-line interpolated strings";
           license = stdenv.lib.licenses.publicDomain;
         }) {};
      "interpolation" = callPackage
        ({ mkDerivation, base, stdenv, utility-ht }:
         mkDerivation {
           pname = "interpolation";
           version = "0.1.0.3";
           sha256 = "e29794d7bb07e13c0fc3e6a05948862fd5ccd50910b9718e4818d354e26f3049";
           isLibrary = true;
           isExecutable = true;
           libraryHaskellDepends = [ base utility-ht ];
           doHaddock = false;
           doCheck = false;
           homepage = "http://hub.darcs.net/thielema/interpolation/";
           description = "piecewise linear and cubic Hermite interpolation";
           license = stdenv.lib.licenses.bsd3;
         }) {};
      "intervals" = callPackage
        ({ mkDerivation, array, base, Cabal, cabal-doctest, distributive
         , ghc-prim, stdenv
         }:
         mkDerivation {
           pname = "intervals";
           version = "0.8.1";
           sha256 = "9ce3bf9d31b9ab2296fccc25031fd52e1c3e4abeca5d3bb452a725b586eb7e03";
           revision = "4";
           editedCabalFile = "1qx3q0v13l1zaln9zdk8chxpxhshbz5x0vqm0qda7d1kpv7h6a7r";
           setupHaskellDepends = [ base Cabal cabal-doctest ];
           libraryHaskellDepends = [ array base distributive ghc-prim ];
           doHaddock = false;
           doCheck = false;
           homepage = "http://github.com/ekmett/intervals";
           description = "Interval Arithmetic";
           license = stdenv.lib.licenses.bsd3;
         }) {};
      "intro" = callPackage
        ({ mkDerivation, base, binary, bytestring, containers, deepseq
         , dlist, extra, hashable, mtl, safe, stdenv, text, transformers
         , unordered-containers, writer-cps-mtl
         }:
         mkDerivation {
           pname = "intro";
           version = "0.3.2.0";
           sha256 = "c34f815259b405f587b09caa65dc5a464377ed5b5b3b5535d2b4689eca9ece59";
           libraryHaskellDepends = [
             base binary bytestring containers deepseq dlist extra hashable mtl
             safe text transformers unordered-containers writer-cps-mtl
           ];
           doHaddock = false;
           doCheck = false;
           homepage = "https://github.com/minad/intro#readme";
           description = "\"Fixed Prelude\" - Mostly total and safe, provides Text and Monad transformers";
           license = stdenv.lib.licenses.mit;
         }) {};
      "invariant" = callPackage
        ({ mkDerivation, array, base, bifunctors, comonad, containers
         , contravariant, ghc-prim, profunctors, semigroups, StateVar
         , stdenv, stm, tagged, template-haskell, th-abstraction
         , transformers, transformers-compat, unordered-containers
         }:
         mkDerivation {
           pname = "invariant";
           version = "0.5.1";
           sha256 = "eb8c9c45ad24020af2978f22271458bf3787937d931c50c86b580c53ca3f122b";
           revision = "1";
           editedCabalFile = "100gsacbpal53khj94m5qs4aq70hbsp4dz4065czfm49ysd4yqq4";
           libraryHaskellDepends = [
             array base bifunctors comonad containers contravariant ghc-prim
             profunctors semigroups StateVar stm tagged template-haskell
             th-abstraction transformers transformers-compat
             unordered-containers
           ];
           doHaddock = false;
           doCheck = false;
           homepage = "https://github.com/nfrisby/invariant-functors";
           description = "Haskell98 invariant functors";
           license = stdenv.lib.licenses.bsd2;
         }) {};
      "invertible" = callPackage
        ({ mkDerivation, base, haskell-src-meta, invariant, lens
         , partial-isomorphisms, semigroupoids, stdenv, template-haskell
         , transformers
         }:
         mkDerivation {
           pname = "invertible";
           version = "0.2.0.5";
           sha256 = "0a0adaa1f371f739fd2c506ff2ba3c4db278bbdfda0171bd8329d678c15b8dbb";
           libraryHaskellDepends = [
             base haskell-src-meta invariant lens partial-isomorphisms
             semigroupoids template-haskell transformers
           ];
           doHaddock = false;
           doCheck = false;
           description = "bidirectional arrows, bijective functions, and invariant functors";
           license = stdenv.lib.licenses.bsd3;
         }) {};
      "invertible-grammar" = callPackage
        ({ mkDerivation, base, bifunctors, containers, mtl, prettyprinter
         , profunctors, semigroups, stdenv, tagged, template-haskell, text
         , transformers
         }:
         mkDerivation {
           pname = "invertible-grammar";
           version = "0.1.1";
           sha256 = "29900cf54783b8f67449a7fd45e986efaec6270cb31f3815650e9a0406061bef";
           revision = "1";
           editedCabalFile = "0hgssm0vm9d1n6iiz43jnr4pnyb6lxm0f2wyywldf8dnnd2j7qdf";
           libraryHaskellDepends = [
             base bifunctors containers mtl prettyprinter profunctors semigroups
             tagged template-haskell text transformers
           ];
           doHaddock = false;
           doCheck = false;
           homepage = "https://github.com/esmolanka/invertible-grammar";
           description = "Invertible parsing combinators framework";
           license = stdenv.lib.licenses.bsd3;
         }) {};
      "io-choice" = callPackage
        ({ mkDerivation, base, lifted-base, monad-control, stdenv
         , template-haskell, transformers, transformers-base
         }:
         mkDerivation {
           pname = "io-choice";
           version = "0.0.7";
           sha256 = "394a60c4b0bcb3ce0dab6618891ab6e7405e583f724ca445ddc58b59725a669b";
           libraryHaskellDepends = [
             base lifted-base monad-control template-haskell transformers
             transformers-base
           ];
           doHaddock = false;
           doCheck = false;
           description = "Choice for IO and lifted IO";
           license = stdenv.lib.licenses.bsd3;
         }) {};
      "io-machine" = callPackage
        ({ mkDerivation, base, stdenv, time }:
         mkDerivation {
           pname = "io-machine";
           version = "0.2.0.0";
           sha256 = "05dcc8d5fcbb6f0d7f3519488ebf743eaa776bc93c2f8b0d4bbd866ac1331ccb";
           libraryHaskellDepends = [ base time ];
           doHaddock = false;
           doCheck = false;
           homepage = "https://github.com/YoshikuniJujo/io-machine#readme";
           description = "Easy I/O model to learn IO monad";
           license = stdenv.lib.licenses.bsd3;
         }) {};
      "io-manager" = callPackage
        ({ mkDerivation, base, containers, stdenv }:
         mkDerivation {
           pname = "io-manager";
           version = "0.1.0.2";
           sha256 = "bf0aa7740a8aaf31fc4f2570a47957365ae7d9248edd309e694053f1cd804138";
           isLibrary = true;
           isExecutable = true;
           libraryHaskellDepends = [ base containers ];
           executableHaskellDepends = [ base containers ];
           doHaddock = false;
           doCheck = false;
           description = "Skeleton library around the IO monad";
           license = stdenv.lib.licenses.bsd3;
         }) {};
      "io-memoize" = callPackage
        ({ mkDerivation, async, base, stdenv }:
         mkDerivation {
           pname = "io-memoize";
           version = "1.1.1.0";
           sha256 = "c753a1b1a2fb286bf608d6467e6e7599cde8e641c619885197f298bf1b2f483d";
           libraryHaskellDepends = [ async base ];
           doHaddock = false;
           doCheck = false;
           homepage = "https://github.com/DanBurton/io-memoize";
           description = "Memoize IO actions";
           license = stdenv.lib.licenses.bsd3;
         }) {};
      "io-region" = callPackage
        ({ mkDerivation, base, stdenv, stm }:
         mkDerivation {
           pname = "io-region";
           version = "0.1.1";
           sha256 = "ee303f66c2b3d33fae877b0dbb7c64624109fc759dffa669ca182e387f1015f1";
           libraryHaskellDepends = [ base stm ];
           doHaddock = false;
           doCheck = false;
           homepage = "https://github.com/Yuras/io-region/wiki";
           description = "Exception safe resource management with dynamic regions";
           license = stdenv.lib.licenses.bsd3;
         }) {};
      "io-storage" = callPackage
        ({ mkDerivation, base, containers, stdenv }:
         mkDerivation {
           pname = "io-storage";
           version = "0.3";
           sha256 = "9a0df5cc7ff2eeef11e29e1362fea284f535bc2fe67469bba6dbc41c4f5b49bd";
           libraryHaskellDepends = [ base containers ];
           doHaddock = false;
           doCheck = false;
           homepage = "http://github.com/willdonnelly/io-storage";
           description = "A key-value store in the IO monad";
           license = stdenv.lib.licenses.bsd3;
         }) {};
      "io-streams" = callPackage
        ({ mkDerivation, attoparsec, base, bytestring, bytestring-builder
         , network, primitive, process, stdenv, text, time, transformers
         , vector, zlib-bindings
         }:
         mkDerivation {
           pname = "io-streams";
           version = "1.5.0.1";
           sha256 = "5dcb3717933197a84f31be74abf545126b3d25eb0e0d64f722c480d3c46b2c8b";
           revision = "2";
           editedCabalFile = "1mcab95d6hm098myh9gp7sh10srigjphgvm8s9pfs7jg5hzghy14";
           configureFlags = [ "-fNoInteractiveTests" ];
           libraryHaskellDepends = [
             attoparsec base bytestring bytestring-builder network primitive
             process text time transformers vector zlib-bindings
           ];
           doHaddock = false;
           doCheck = false;
           description = "Simple, composable, and easy-to-use stream I/O";
           license = stdenv.lib.licenses.bsd3;
         }) {};
      "io-streams-haproxy" = callPackage
        ({ mkDerivation, attoparsec, base, bytestring, io-streams, network
         , stdenv, transformers
         }:
         mkDerivation {
           pname = "io-streams-haproxy";
           version = "1.0.0.2";
           sha256 = "77814f8258b5c32707a13e0d30ab2e144e7ad073aee821d6def65554024ed086";
           revision = "4";
           editedCabalFile = "06c51a057n5bc9xfbp2m4jz5ds4z1xvmsx5mppch6qfwbz7x5i9l";
           libraryHaskellDepends = [
             attoparsec base bytestring io-streams network transformers
           ];
           doHaddock = false;
           doCheck = false;
           homepage = "http://snapframework.com/";
           description = "HAProxy protocol 1.5 support for io-streams";
           license = stdenv.lib.licenses.bsd3;
         }) {};
      "ip" = callPackage
        ({ mkDerivation, aeson, attoparsec, base, bytestring, hashable
         , primitive, stdenv, text, vector
         }:
         mkDerivation {
           pname = "ip";
           version = "1.3.0";
           sha256 = "9e4c869d00cc8348b4648983627fb05f4b4eb4cc6b51ec72523d0419c81aac81";
           libraryHaskellDepends = [
             aeson attoparsec base bytestring hashable primitive text vector
           ];
           doHaddock = false;
           doCheck = false;
           homepage = "https://github.com/andrewthad/haskell-ip#readme";
           description = "Library for IP and MAC addresses";
           license = stdenv.lib.licenses.bsd3;
         }) {};
      "ip6addr" = callPackage
        ({ mkDerivation, base, cmdargs, IPv6Addr, stdenv, text }:
         mkDerivation {
           pname = "ip6addr";
           version = "1.0.0";
           sha256 = "e805be52d77edfb0e71740dbfa57403654cb34929083589d79d44757c01f80f1";
           isLibrary = false;
           isExecutable = true;
           executableHaskellDepends = [ base cmdargs IPv6Addr text ];
           doHaddock = false;
           doCheck = false;
           homepage = "https://github.com/MichelBoucey/ip6addr";
           description = "Commandline tool to generate IPv6 address text representations";
           license = stdenv.lib.licenses.bsd3;
         }) {};
      "iproute" = callPackage
        ({ mkDerivation, appar, base, byteorder, containers, network
         , stdenv
         }:
         mkDerivation {
           pname = "iproute";
           version = "1.7.7";
           sha256 = "e6a3fe4a6f2a78fcee0f98255f97232d8b6b9b1fa48faee3bef96f0b462a4b3d";
           libraryHaskellDepends = [
             appar base byteorder containers network
           ];
           doHaddock = false;
           doCheck = false;
           homepage = "http://www.mew.org/~kazu/proj/iproute/";
           description = "IP Routing Table";
           license = stdenv.lib.licenses.bsd3;
         }) {};
      "ipython-kernel" = callPackage
        ({ mkDerivation, aeson, base, bytestring, cereal, containers
         , cryptonite, directory, filepath, memory, mtl, process, stdenv
         , temporary, text, transformers, unordered-containers, uuid
         , zeromq4-haskell
         }:
         mkDerivation {
           pname = "ipython-kernel";
           version = "0.9.1.0";
           sha256 = "53616435d1fef56a5ba3ad219e9ccf9d8845024b0f2cc5864575440078cc8424";
           isLibrary = true;
           isExecutable = true;
           enableSeparateDataOutput = true;
           libraryHaskellDepends = [
             aeson base bytestring cereal containers cryptonite directory
             filepath memory mtl process temporary text transformers
             unordered-containers uuid zeromq4-haskell
           ];
           doHaddock = false;
           doCheck = false;
           homepage = "http://github.com/gibiansky/IHaskell";
           description = "A library for creating kernels for IPython frontends";
           license = stdenv.lib.licenses.mit;
         }) {};
      "irc" = callPackage
        ({ mkDerivation, attoparsec, base, bytestring, stdenv }:
         mkDerivation {
           pname = "irc";
           version = "0.6.1.0";
           sha256 = "3816ead4dfb32d61c03265e3a2a45053508cb27ca3132595773a27ef381637e1";
           libraryHaskellDepends = [ attoparsec base bytestring ];
           doHaddock = false;
           doCheck = false;
           description = "A small library for parsing IRC messages";
           license = stdenv.lib.licenses.bsd3;
         }) {};
      "irc-client" = callPackage
        ({ mkDerivation, base, bytestring, conduit, connection, containers
         , contravariant, exceptions, irc-conduit, irc-ctcp, mtl
         , network-conduit-tls, old-locale, profunctors, stdenv, stm
         , stm-chans, text, time, tls, transformers, x509, x509-store
         , x509-validation
         }:
         mkDerivation {
           pname = "irc-client";
           version = "1.1.0.5";
           sha256 = "27e224e1323cdc56ae3b536283a133e7e2b8051e4c5dfa9505a8bd79992a0c8f";
           libraryHaskellDepends = [
             base bytestring conduit connection containers contravariant
             exceptions irc-conduit irc-ctcp mtl network-conduit-tls old-locale
             profunctors stm stm-chans text time tls transformers x509
             x509-store x509-validation
           ];
           doHaddock = false;
           doCheck = false;
           homepage = "https://github.com/barrucadu/irc-client";
           description = "An IRC client library";
           license = stdenv.lib.licenses.mit;
         }) {};
      "irc-conduit" = callPackage
        ({ mkDerivation, async, base, bytestring, conduit, conduit-extra
         , connection, irc, irc-ctcp, network-conduit-tls, profunctors
         , stdenv, text, time, tls, transformers, x509-validation
         }:
         mkDerivation {
           pname = "irc-conduit";
           version = "0.3.0.1";
           sha256 = "b0a8f935eb3b4613e74efce7a913592f72835194b8977271f35eb09c578b3b52";
           libraryHaskellDepends = [
             async base bytestring conduit conduit-extra connection irc irc-ctcp
             network-conduit-tls profunctors text time tls transformers
             x509-validation
           ];
           doHaddock = false;
           doCheck = false;
           homepage = "https://github.com/barrucadu/irc-conduit";
           description = "Streaming IRC message library using conduits";
           license = stdenv.lib.licenses.mit;
         }) {};
      "irc-ctcp" = callPackage
        ({ mkDerivation, base, bytestring, stdenv, text }:
         mkDerivation {
           pname = "irc-ctcp";
           version = "0.1.3.0";
           sha256 = "d67cd91a5521173565033777cea76636e4d2be6e6224f681392d9e726f4bb79a";
           libraryHaskellDepends = [ base bytestring text ];
           doHaddock = false;
           doCheck = false;
           homepage = "https://github.com/barrucadu/irc-ctcp";
           description = "A CTCP encoding and decoding library for IRC clients";
           license = stdenv.lib.licenses.mit;
         }) {};
      "irc-dcc" = callPackage
        ({ mkDerivation, attoparsec, base, binary, bytestring, io-streams
         , iproute, irc-ctcp, mtl, network, path, safe-exceptions, stdenv
         , transformers, utf8-string
         }:
         mkDerivation {
           pname = "irc-dcc";
           version = "2.0.1";
           sha256 = "6408a28733743d3463664677c5e3ad72e46c168799dad458988067039f25d2df";
           revision = "8";
           editedCabalFile = "1ya1bl8pdzbs3gxkq7hsyvkaajf8prrdhr1lx5hm9pi1nqsi879z";
           libraryHaskellDepends = [
             attoparsec base binary bytestring io-streams iproute irc-ctcp mtl
             network path safe-exceptions transformers utf8-string
           ];
           doHaddock = false;
           doCheck = false;
           homepage = "https://github.com/JanGe/irc-dcc";
           description = "A DCC message parsing and helper library for IRC clients";
           license = stdenv.lib.licenses.mit;
         }) {};
      "islink" = callPackage
        ({ mkDerivation, base, stdenv, unordered-containers }:
         mkDerivation {
           pname = "islink";
           version = "0.1.0.0";
           sha256 = "cfbf9c1a6dc46327b7ed7bf9336e245a255626c9d04aeba3d887d90f26d2aed7";
           libraryHaskellDepends = [ base unordered-containers ];
           doHaddock = false;
           doCheck = false;
           homepage = "https://github.com/redneb/islink";
           description = "Check if an HTML element is a link";
           license = stdenv.lib.licenses.bsd3;
         }) {};
      "iso3166-country-codes" = callPackage
        ({ mkDerivation, base, stdenv }:
         mkDerivation {
           pname = "iso3166-country-codes";
           version = "0.20140203.8";
           sha256 = "b4d6e01cd61bcaef9a8e455c331a8e7a2298531cb587ef6f23675eae7a6b0a36";
           revision = "1";
           editedCabalFile = "0n01pmvkqi0w9l203i1v7kb6bb867plv4h5hmzlkpnhrf5abf0zf";
           libraryHaskellDepends = [ base ];
           doHaddock = false;
           doCheck = false;
           description = "A datatype for ISO 3166 country codes";
           license = "LGPL";
         }) {};
      "iso639" = callPackage
        ({ mkDerivation, base, stdenv }:
         mkDerivation {
           pname = "iso639";
           version = "0.1.0.3";
           sha256 = "124b8322fabaedb4de3dbc39880b36d0eab0e28d5775954aadb6630bc0da25e8";
           libraryHaskellDepends = [ base ];
           doHaddock = false;
           doCheck = false;
           homepage = "https://github.com/HugoDaniel/iso639";
           description = "ISO-639-1 language codes";
           license = stdenv.lib.licenses.bsd3;
         }) {};
      "iso8601-time" = callPackage
        ({ mkDerivation, base, stdenv, time }:
         mkDerivation {
           pname = "iso8601-time";
           version = "0.1.5";
           sha256 = "f2cd444b2be68402c773a4b451912817f06d33093aea691b42ebeed3630ff0c8";
           libraryHaskellDepends = [ base time ];
           doHaddock = false;
           doCheck = false;
           homepage = "https://github.com/nh2/iso8601-time";
           description = "Convert to/from the ISO 8601 time format";
           license = stdenv.lib.licenses.mit;
         }) {};
      "iterable" = callPackage
        ({ mkDerivation, base, mtl, stdenv, tagged, template-haskell
         , vector
         }:
         mkDerivation {
           pname = "iterable";
           version = "3.0";
           sha256 = "6cd13d621144e937cc88acfed1663bd2e208dcbe54be4bad1f7b7279250a87a4";
           enableSeparateDataOutput = true;
           libraryHaskellDepends = [
             base mtl tagged template-haskell vector
           ];
           doHaddock = false;
           doCheck = false;
           homepage = "https://github.com/BioHaskell/iterable";
           description = "API for hierarchical multilevel collections";
           license = stdenv.lib.licenses.bsd3;
         }) {};
      "ix-shapable" = callPackage
        ({ mkDerivation, array, base, stdenv }:
         mkDerivation {
           pname = "ix-shapable";
           version = "0.1.0";
          

numbers were prepended to the filename to force github to use that order when displaying